xref: /openbmc/u-boot/drivers/mmc/mmc.c (revision 6c5be646)
1 /*
2  * Copyright 2008, Freescale Semiconductor, Inc
3  * Andy Fleming
4  *
5  * Based vaguely on the Linux code
6  *
7  * See file CREDITS for list of people who contributed to this
8  * project.
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License as
12  * published by the Free Software Foundation; either version 2 of
13  * the License, or (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
23  * MA 02111-1307 USA
24  */
25 
26 #include <config.h>
27 #include <common.h>
28 #include <command.h>
29 #include <mmc.h>
30 #include <part.h>
31 #include <malloc.h>
32 #include <linux/list.h>
33 #include <div64.h>
34 
35 /* Set block count limit because of 16 bit register limit on some hardware*/
36 #ifndef CONFIG_SYS_MMC_MAX_BLK_COUNT
37 #define CONFIG_SYS_MMC_MAX_BLK_COUNT 65535
38 #endif
39 
40 static struct list_head mmc_devices;
41 static int cur_dev_num = -1;
42 
43 int __weak board_mmc_getwp(struct mmc *mmc)
44 {
45 	return -1;
46 }
47 
48 int mmc_getwp(struct mmc *mmc)
49 {
50 	int wp;
51 
52 	wp = board_mmc_getwp(mmc);
53 
54 	if ((wp < 0) && mmc->getwp)
55 		wp = mmc->getwp(mmc);
56 
57 	return wp;
58 }
59 
60 int __board_mmc_getcd(struct mmc *mmc) {
61 	return -1;
62 }
63 
64 int board_mmc_getcd(struct mmc *mmc)__attribute__((weak,
65 	alias("__board_mmc_getcd")));
66 
67 static int mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd,
68 			struct mmc_data *data)
69 {
70 	struct mmc_data backup;
71 	int ret;
72 
73 	memset(&backup, 0, sizeof(backup));
74 
75 #ifdef CONFIG_MMC_TRACE
76 	int i;
77 	u8 *ptr;
78 
79 	printf("CMD_SEND:%d\n", cmd->cmdidx);
80 	printf("\t\tARG\t\t\t 0x%08X\n", cmd->cmdarg);
81 	ret = mmc->send_cmd(mmc, cmd, data);
82 	switch (cmd->resp_type) {
83 		case MMC_RSP_NONE:
84 			printf("\t\tMMC_RSP_NONE\n");
85 			break;
86 		case MMC_RSP_R1:
87 			printf("\t\tMMC_RSP_R1,5,6,7 \t 0x%08X \n",
88 				cmd->response[0]);
89 			break;
90 		case MMC_RSP_R1b:
91 			printf("\t\tMMC_RSP_R1b\t\t 0x%08X \n",
92 				cmd->response[0]);
93 			break;
94 		case MMC_RSP_R2:
95 			printf("\t\tMMC_RSP_R2\t\t 0x%08X \n",
96 				cmd->response[0]);
97 			printf("\t\t          \t\t 0x%08X \n",
98 				cmd->response[1]);
99 			printf("\t\t          \t\t 0x%08X \n",
100 				cmd->response[2]);
101 			printf("\t\t          \t\t 0x%08X \n",
102 				cmd->response[3]);
103 			printf("\n");
104 			printf("\t\t\t\t\tDUMPING DATA\n");
105 			for (i = 0; i < 4; i++) {
106 				int j;
107 				printf("\t\t\t\t\t%03d - ", i*4);
108 				ptr = (u8 *)&cmd->response[i];
109 				ptr += 3;
110 				for (j = 0; j < 4; j++)
111 					printf("%02X ", *ptr--);
112 				printf("\n");
113 			}
114 			break;
115 		case MMC_RSP_R3:
116 			printf("\t\tMMC_RSP_R3,4\t\t 0x%08X \n",
117 				cmd->response[0]);
118 			break;
119 		default:
120 			printf("\t\tERROR MMC rsp not supported\n");
121 			break;
122 	}
123 #else
124 	ret = mmc->send_cmd(mmc, cmd, data);
125 #endif
126 	return ret;
127 }
128 
129 static int mmc_send_status(struct mmc *mmc, int timeout)
130 {
131 	struct mmc_cmd cmd;
132 	int err, retries = 5;
133 #ifdef CONFIG_MMC_TRACE
134 	int status;
135 #endif
136 
137 	cmd.cmdidx = MMC_CMD_SEND_STATUS;
138 	cmd.resp_type = MMC_RSP_R1;
139 	if (!mmc_host_is_spi(mmc))
140 		cmd.cmdarg = mmc->rca << 16;
141 
142 	do {
143 		err = mmc_send_cmd(mmc, &cmd, NULL);
144 		if (!err) {
145 			if ((cmd.response[0] & MMC_STATUS_RDY_FOR_DATA) &&
146 			    (cmd.response[0] & MMC_STATUS_CURR_STATE) !=
147 			     MMC_STATE_PRG)
148 				break;
149 			else if (cmd.response[0] & MMC_STATUS_MASK) {
150 				printf("Status Error: 0x%08X\n",
151 					cmd.response[0]);
152 				return COMM_ERR;
153 			}
154 		} else if (--retries < 0)
155 			return err;
156 
157 		udelay(1000);
158 
159 	} while (timeout--);
160 
161 #ifdef CONFIG_MMC_TRACE
162 	status = (cmd.response[0] & MMC_STATUS_CURR_STATE) >> 9;
163 	printf("CURR STATE:%d\n", status);
164 #endif
165 	if (timeout <= 0) {
166 		printf("Timeout waiting card ready\n");
167 		return TIMEOUT;
168 	}
169 
170 	return 0;
171 }
172 
173 static int mmc_set_blocklen(struct mmc *mmc, int len)
174 {
175 	struct mmc_cmd cmd;
176 
177 	cmd.cmdidx = MMC_CMD_SET_BLOCKLEN;
178 	cmd.resp_type = MMC_RSP_R1;
179 	cmd.cmdarg = len;
180 
181 	return mmc_send_cmd(mmc, &cmd, NULL);
182 }
183 
184 struct mmc *find_mmc_device(int dev_num)
185 {
186 	struct mmc *m;
187 	struct list_head *entry;
188 
189 	list_for_each(entry, &mmc_devices) {
190 		m = list_entry(entry, struct mmc, link);
191 
192 		if (m->block_dev.dev == dev_num)
193 			return m;
194 	}
195 
196 	printf("MMC Device %d not found\n", dev_num);
197 
198 	return NULL;
199 }
200 
201 static ulong mmc_erase_t(struct mmc *mmc, ulong start, lbaint_t blkcnt)
202 {
203 	struct mmc_cmd cmd;
204 	ulong end;
205 	int err, start_cmd, end_cmd;
206 
207 	if (mmc->high_capacity)
208 		end = start + blkcnt - 1;
209 	else {
210 		end = (start + blkcnt - 1) * mmc->write_bl_len;
211 		start *= mmc->write_bl_len;
212 	}
213 
214 	if (IS_SD(mmc)) {
215 		start_cmd = SD_CMD_ERASE_WR_BLK_START;
216 		end_cmd = SD_CMD_ERASE_WR_BLK_END;
217 	} else {
218 		start_cmd = MMC_CMD_ERASE_GROUP_START;
219 		end_cmd = MMC_CMD_ERASE_GROUP_END;
220 	}
221 
222 	cmd.cmdidx = start_cmd;
223 	cmd.cmdarg = start;
224 	cmd.resp_type = MMC_RSP_R1;
225 
226 	err = mmc_send_cmd(mmc, &cmd, NULL);
227 	if (err)
228 		goto err_out;
229 
230 	cmd.cmdidx = end_cmd;
231 	cmd.cmdarg = end;
232 
233 	err = mmc_send_cmd(mmc, &cmd, NULL);
234 	if (err)
235 		goto err_out;
236 
237 	cmd.cmdidx = MMC_CMD_ERASE;
238 	cmd.cmdarg = SECURE_ERASE;
239 	cmd.resp_type = MMC_RSP_R1b;
240 
241 	err = mmc_send_cmd(mmc, &cmd, NULL);
242 	if (err)
243 		goto err_out;
244 
245 	return 0;
246 
247 err_out:
248 	puts("mmc erase failed\n");
249 	return err;
250 }
251 
252 static unsigned long
253 mmc_berase(int dev_num, unsigned long start, lbaint_t blkcnt)
254 {
255 	int err = 0;
256 	struct mmc *mmc = find_mmc_device(dev_num);
257 	lbaint_t blk = 0, blk_r = 0;
258 	int timeout = 1000;
259 
260 	if (!mmc)
261 		return -1;
262 
263 	if ((start % mmc->erase_grp_size) || (blkcnt % mmc->erase_grp_size))
264 		printf("\n\nCaution! Your devices Erase group is 0x%x\n"
265 			"The erase range would be change to 0x%lx~0x%lx\n\n",
266 		       mmc->erase_grp_size, start & ~(mmc->erase_grp_size - 1),
267 		       ((start + blkcnt + mmc->erase_grp_size)
268 		       & ~(mmc->erase_grp_size - 1)) - 1);
269 
270 	while (blk < blkcnt) {
271 		blk_r = ((blkcnt - blk) > mmc->erase_grp_size) ?
272 			mmc->erase_grp_size : (blkcnt - blk);
273 		err = mmc_erase_t(mmc, start + blk, blk_r);
274 		if (err)
275 			break;
276 
277 		blk += blk_r;
278 
279 		/* Waiting for the ready status */
280 		if (mmc_send_status(mmc, timeout))
281 			return 0;
282 	}
283 
284 	return blk;
285 }
286 
287 static ulong
288 mmc_write_blocks(struct mmc *mmc, ulong start, lbaint_t blkcnt, const void*src)
289 {
290 	struct mmc_cmd cmd;
291 	struct mmc_data data;
292 	int timeout = 1000;
293 
294 	if ((start + blkcnt) > mmc->block_dev.lba) {
295 		printf("MMC: block number 0x%lx exceeds max(0x%lx)\n",
296 			start + blkcnt, mmc->block_dev.lba);
297 		return 0;
298 	}
299 
300 	if (blkcnt > 1)
301 		cmd.cmdidx = MMC_CMD_WRITE_MULTIPLE_BLOCK;
302 	else
303 		cmd.cmdidx = MMC_CMD_WRITE_SINGLE_BLOCK;
304 
305 	if (mmc->high_capacity)
306 		cmd.cmdarg = start;
307 	else
308 		cmd.cmdarg = start * mmc->write_bl_len;
309 
310 	cmd.resp_type = MMC_RSP_R1;
311 
312 	data.src = src;
313 	data.blocks = blkcnt;
314 	data.blocksize = mmc->write_bl_len;
315 	data.flags = MMC_DATA_WRITE;
316 
317 	if (mmc_send_cmd(mmc, &cmd, &data)) {
318 		printf("mmc write failed\n");
319 		return 0;
320 	}
321 
322 	/* SPI multiblock writes terminate using a special
323 	 * token, not a STOP_TRANSMISSION request.
324 	 */
325 	if (!mmc_host_is_spi(mmc) && blkcnt > 1) {
326 		cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION;
327 		cmd.cmdarg = 0;
328 		cmd.resp_type = MMC_RSP_R1b;
329 		if (mmc_send_cmd(mmc, &cmd, NULL)) {
330 			printf("mmc fail to send stop cmd\n");
331 			return 0;
332 		}
333 	}
334 
335 	/* Waiting for the ready status */
336 	if (mmc_send_status(mmc, timeout))
337 		return 0;
338 
339 	return blkcnt;
340 }
341 
342 static ulong
343 mmc_bwrite(int dev_num, ulong start, lbaint_t blkcnt, const void*src)
344 {
345 	lbaint_t cur, blocks_todo = blkcnt;
346 
347 	struct mmc *mmc = find_mmc_device(dev_num);
348 	if (!mmc)
349 		return 0;
350 
351 	if (mmc_set_blocklen(mmc, mmc->write_bl_len))
352 		return 0;
353 
354 	do {
355 		cur = (blocks_todo > mmc->b_max) ?  mmc->b_max : blocks_todo;
356 		if(mmc_write_blocks(mmc, start, cur, src) != cur)
357 			return 0;
358 		blocks_todo -= cur;
359 		start += cur;
360 		src += cur * mmc->write_bl_len;
361 	} while (blocks_todo > 0);
362 
363 	return blkcnt;
364 }
365 
366 static int mmc_read_blocks(struct mmc *mmc, void *dst, ulong start,
367 			   lbaint_t blkcnt)
368 {
369 	struct mmc_cmd cmd;
370 	struct mmc_data data;
371 
372 	if (blkcnt > 1)
373 		cmd.cmdidx = MMC_CMD_READ_MULTIPLE_BLOCK;
374 	else
375 		cmd.cmdidx = MMC_CMD_READ_SINGLE_BLOCK;
376 
377 	if (mmc->high_capacity)
378 		cmd.cmdarg = start;
379 	else
380 		cmd.cmdarg = start * mmc->read_bl_len;
381 
382 	cmd.resp_type = MMC_RSP_R1;
383 
384 	data.dest = dst;
385 	data.blocks = blkcnt;
386 	data.blocksize = mmc->read_bl_len;
387 	data.flags = MMC_DATA_READ;
388 
389 	if (mmc_send_cmd(mmc, &cmd, &data))
390 		return 0;
391 
392 	if (blkcnt > 1) {
393 		cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION;
394 		cmd.cmdarg = 0;
395 		cmd.resp_type = MMC_RSP_R1b;
396 		if (mmc_send_cmd(mmc, &cmd, NULL)) {
397 			printf("mmc fail to send stop cmd\n");
398 			return 0;
399 		}
400 	}
401 
402 	return blkcnt;
403 }
404 
405 static ulong mmc_bread(int dev_num, ulong start, lbaint_t blkcnt, void *dst)
406 {
407 	lbaint_t cur, blocks_todo = blkcnt;
408 
409 	if (blkcnt == 0)
410 		return 0;
411 
412 	struct mmc *mmc = find_mmc_device(dev_num);
413 	if (!mmc)
414 		return 0;
415 
416 	if ((start + blkcnt) > mmc->block_dev.lba) {
417 		printf("MMC: block number 0x%lx exceeds max(0x%lx)\n",
418 			start + blkcnt, mmc->block_dev.lba);
419 		return 0;
420 	}
421 
422 	if (mmc_set_blocklen(mmc, mmc->read_bl_len))
423 		return 0;
424 
425 	do {
426 		cur = (blocks_todo > mmc->b_max) ?  mmc->b_max : blocks_todo;
427 		if(mmc_read_blocks(mmc, dst, start, cur) != cur)
428 			return 0;
429 		blocks_todo -= cur;
430 		start += cur;
431 		dst += cur * mmc->read_bl_len;
432 	} while (blocks_todo > 0);
433 
434 	return blkcnt;
435 }
436 
437 static int mmc_go_idle(struct mmc *mmc)
438 {
439 	struct mmc_cmd cmd;
440 	int err;
441 
442 	udelay(1000);
443 
444 	cmd.cmdidx = MMC_CMD_GO_IDLE_STATE;
445 	cmd.cmdarg = 0;
446 	cmd.resp_type = MMC_RSP_NONE;
447 
448 	err = mmc_send_cmd(mmc, &cmd, NULL);
449 
450 	if (err)
451 		return err;
452 
453 	udelay(2000);
454 
455 	return 0;
456 }
457 
458 static int sd_send_op_cond(struct mmc *mmc)
459 {
460 	int timeout = 1000;
461 	int err;
462 	struct mmc_cmd cmd;
463 
464 	do {
465 		cmd.cmdidx = MMC_CMD_APP_CMD;
466 		cmd.resp_type = MMC_RSP_R1;
467 		cmd.cmdarg = 0;
468 
469 		err = mmc_send_cmd(mmc, &cmd, NULL);
470 
471 		if (err)
472 			return err;
473 
474 		cmd.cmdidx = SD_CMD_APP_SEND_OP_COND;
475 		cmd.resp_type = MMC_RSP_R3;
476 
477 		/*
478 		 * Most cards do not answer if some reserved bits
479 		 * in the ocr are set. However, Some controller
480 		 * can set bit 7 (reserved for low voltages), but
481 		 * how to manage low voltages SD card is not yet
482 		 * specified.
483 		 */
484 		cmd.cmdarg = mmc_host_is_spi(mmc) ? 0 :
485 			(mmc->voltages & 0xff8000);
486 
487 		if (mmc->version == SD_VERSION_2)
488 			cmd.cmdarg |= OCR_HCS;
489 
490 		err = mmc_send_cmd(mmc, &cmd, NULL);
491 
492 		if (err)
493 			return err;
494 
495 		udelay(1000);
496 	} while ((!(cmd.response[0] & OCR_BUSY)) && timeout--);
497 
498 	if (timeout <= 0)
499 		return UNUSABLE_ERR;
500 
501 	if (mmc->version != SD_VERSION_2)
502 		mmc->version = SD_VERSION_1_0;
503 
504 	if (mmc_host_is_spi(mmc)) { /* read OCR for spi */
505 		cmd.cmdidx = MMC_CMD_SPI_READ_OCR;
506 		cmd.resp_type = MMC_RSP_R3;
507 		cmd.cmdarg = 0;
508 
509 		err = mmc_send_cmd(mmc, &cmd, NULL);
510 
511 		if (err)
512 			return err;
513 	}
514 
515 	mmc->ocr = cmd.response[0];
516 
517 	mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
518 	mmc->rca = 0;
519 
520 	return 0;
521 }
522 
523 static int mmc_send_op_cond(struct mmc *mmc)
524 {
525 	int timeout = 10000;
526 	struct mmc_cmd cmd;
527 	int err;
528 
529 	/* Some cards seem to need this */
530 	mmc_go_idle(mmc);
531 
532  	/* Asking to the card its capabilities */
533  	cmd.cmdidx = MMC_CMD_SEND_OP_COND;
534  	cmd.resp_type = MMC_RSP_R3;
535  	cmd.cmdarg = 0;
536 
537  	err = mmc_send_cmd(mmc, &cmd, NULL);
538 
539  	if (err)
540  		return err;
541 
542  	udelay(1000);
543 
544 	do {
545 		cmd.cmdidx = MMC_CMD_SEND_OP_COND;
546 		cmd.resp_type = MMC_RSP_R3;
547 		cmd.cmdarg = (mmc_host_is_spi(mmc) ? 0 :
548 				(mmc->voltages &
549 				(cmd.response[0] & OCR_VOLTAGE_MASK)) |
550 				(cmd.response[0] & OCR_ACCESS_MODE));
551 
552 		if (mmc->host_caps & MMC_MODE_HC)
553 			cmd.cmdarg |= OCR_HCS;
554 
555 		err = mmc_send_cmd(mmc, &cmd, NULL);
556 
557 		if (err)
558 			return err;
559 
560 		udelay(1000);
561 	} while (!(cmd.response[0] & OCR_BUSY) && timeout--);
562 
563 	if (timeout <= 0)
564 		return UNUSABLE_ERR;
565 
566 	if (mmc_host_is_spi(mmc)) { /* read OCR for spi */
567 		cmd.cmdidx = MMC_CMD_SPI_READ_OCR;
568 		cmd.resp_type = MMC_RSP_R3;
569 		cmd.cmdarg = 0;
570 
571 		err = mmc_send_cmd(mmc, &cmd, NULL);
572 
573 		if (err)
574 			return err;
575 	}
576 
577 	mmc->version = MMC_VERSION_UNKNOWN;
578 	mmc->ocr = cmd.response[0];
579 
580 	mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
581 	mmc->rca = 0;
582 
583 	return 0;
584 }
585 
586 
587 static int mmc_send_ext_csd(struct mmc *mmc, u8 *ext_csd)
588 {
589 	struct mmc_cmd cmd;
590 	struct mmc_data data;
591 	int err;
592 
593 	/* Get the Card Status Register */
594 	cmd.cmdidx = MMC_CMD_SEND_EXT_CSD;
595 	cmd.resp_type = MMC_RSP_R1;
596 	cmd.cmdarg = 0;
597 
598 	data.dest = (char *)ext_csd;
599 	data.blocks = 1;
600 	data.blocksize = 512;
601 	data.flags = MMC_DATA_READ;
602 
603 	err = mmc_send_cmd(mmc, &cmd, &data);
604 
605 	return err;
606 }
607 
608 
609 static int mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value)
610 {
611 	struct mmc_cmd cmd;
612 	int timeout = 1000;
613 	int ret;
614 
615 	cmd.cmdidx = MMC_CMD_SWITCH;
616 	cmd.resp_type = MMC_RSP_R1b;
617 	cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
618 				 (index << 16) |
619 				 (value << 8);
620 
621 	ret = mmc_send_cmd(mmc, &cmd, NULL);
622 
623 	/* Waiting for the ready status */
624 	if (!ret)
625 		ret = mmc_send_status(mmc, timeout);
626 
627 	return ret;
628 
629 }
630 
631 static int mmc_change_freq(struct mmc *mmc)
632 {
633 	ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, 512);
634 	char cardtype;
635 	int err;
636 
637 	mmc->card_caps = 0;
638 
639 	if (mmc_host_is_spi(mmc))
640 		return 0;
641 
642 	/* Only version 4 supports high-speed */
643 	if (mmc->version < MMC_VERSION_4)
644 		return 0;
645 
646 	err = mmc_send_ext_csd(mmc, ext_csd);
647 
648 	if (err)
649 		return err;
650 
651 	cardtype = ext_csd[EXT_CSD_CARD_TYPE] & 0xf;
652 
653 	err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, 1);
654 
655 	if (err)
656 		return err;
657 
658 	/* Now check to see that it worked */
659 	err = mmc_send_ext_csd(mmc, ext_csd);
660 
661 	if (err)
662 		return err;
663 
664 	/* No high-speed support */
665 	if (!ext_csd[EXT_CSD_HS_TIMING])
666 		return 0;
667 
668 	/* High Speed is set, there are two types: 52MHz and 26MHz */
669 	if (cardtype & MMC_HS_52MHZ)
670 		mmc->card_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS;
671 	else
672 		mmc->card_caps |= MMC_MODE_HS;
673 
674 	return 0;
675 }
676 
677 int mmc_switch_part(int dev_num, unsigned int part_num)
678 {
679 	struct mmc *mmc = find_mmc_device(dev_num);
680 
681 	if (!mmc)
682 		return -1;
683 
684 	return mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONF,
685 			  (mmc->part_config & ~PART_ACCESS_MASK)
686 			  | (part_num & PART_ACCESS_MASK));
687 }
688 
689 int mmc_getcd(struct mmc *mmc)
690 {
691 	int cd;
692 
693 	cd = board_mmc_getcd(mmc);
694 
695 	if ((cd < 0) && mmc->getcd)
696 		cd = mmc->getcd(mmc);
697 
698 	return cd;
699 }
700 
701 static int sd_switch(struct mmc *mmc, int mode, int group, u8 value, u8 *resp)
702 {
703 	struct mmc_cmd cmd;
704 	struct mmc_data data;
705 
706 	/* Switch the frequency */
707 	cmd.cmdidx = SD_CMD_SWITCH_FUNC;
708 	cmd.resp_type = MMC_RSP_R1;
709 	cmd.cmdarg = (mode << 31) | 0xffffff;
710 	cmd.cmdarg &= ~(0xf << (group * 4));
711 	cmd.cmdarg |= value << (group * 4);
712 
713 	data.dest = (char *)resp;
714 	data.blocksize = 64;
715 	data.blocks = 1;
716 	data.flags = MMC_DATA_READ;
717 
718 	return mmc_send_cmd(mmc, &cmd, &data);
719 }
720 
721 
722 static int sd_change_freq(struct mmc *mmc)
723 {
724 	int err;
725 	struct mmc_cmd cmd;
726 	ALLOC_CACHE_ALIGN_BUFFER(uint, scr, 2);
727 	ALLOC_CACHE_ALIGN_BUFFER(uint, switch_status, 16);
728 	struct mmc_data data;
729 	int timeout;
730 
731 	mmc->card_caps = 0;
732 
733 	if (mmc_host_is_spi(mmc))
734 		return 0;
735 
736 	/* Read the SCR to find out if this card supports higher speeds */
737 	cmd.cmdidx = MMC_CMD_APP_CMD;
738 	cmd.resp_type = MMC_RSP_R1;
739 	cmd.cmdarg = mmc->rca << 16;
740 
741 	err = mmc_send_cmd(mmc, &cmd, NULL);
742 
743 	if (err)
744 		return err;
745 
746 	cmd.cmdidx = SD_CMD_APP_SEND_SCR;
747 	cmd.resp_type = MMC_RSP_R1;
748 	cmd.cmdarg = 0;
749 
750 	timeout = 3;
751 
752 retry_scr:
753 	data.dest = (char *)scr;
754 	data.blocksize = 8;
755 	data.blocks = 1;
756 	data.flags = MMC_DATA_READ;
757 
758 	err = mmc_send_cmd(mmc, &cmd, &data);
759 
760 	if (err) {
761 		if (timeout--)
762 			goto retry_scr;
763 
764 		return err;
765 	}
766 
767 	mmc->scr[0] = __be32_to_cpu(scr[0]);
768 	mmc->scr[1] = __be32_to_cpu(scr[1]);
769 
770 	switch ((mmc->scr[0] >> 24) & 0xf) {
771 		case 0:
772 			mmc->version = SD_VERSION_1_0;
773 			break;
774 		case 1:
775 			mmc->version = SD_VERSION_1_10;
776 			break;
777 		case 2:
778 			mmc->version = SD_VERSION_2;
779 			break;
780 		default:
781 			mmc->version = SD_VERSION_1_0;
782 			break;
783 	}
784 
785 	if (mmc->scr[0] & SD_DATA_4BIT)
786 		mmc->card_caps |= MMC_MODE_4BIT;
787 
788 	/* Version 1.0 doesn't support switching */
789 	if (mmc->version == SD_VERSION_1_0)
790 		return 0;
791 
792 	timeout = 4;
793 	while (timeout--) {
794 		err = sd_switch(mmc, SD_SWITCH_CHECK, 0, 1,
795 				(u8 *)switch_status);
796 
797 		if (err)
798 			return err;
799 
800 		/* The high-speed function is busy.  Try again */
801 		if (!(__be32_to_cpu(switch_status[7]) & SD_HIGHSPEED_BUSY))
802 			break;
803 	}
804 
805 	/* If high-speed isn't supported, we return */
806 	if (!(__be32_to_cpu(switch_status[3]) & SD_HIGHSPEED_SUPPORTED))
807 		return 0;
808 
809 	/*
810 	 * If the host doesn't support SD_HIGHSPEED, do not switch card to
811 	 * HIGHSPEED mode even if the card support SD_HIGHSPPED.
812 	 * This can avoid furthur problem when the card runs in different
813 	 * mode between the host.
814 	 */
815 	if (!((mmc->host_caps & MMC_MODE_HS_52MHz) &&
816 		(mmc->host_caps & MMC_MODE_HS)))
817 		return 0;
818 
819 	err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (u8 *)switch_status);
820 
821 	if (err)
822 		return err;
823 
824 	if ((__be32_to_cpu(switch_status[4]) & 0x0f000000) == 0x01000000)
825 		mmc->card_caps |= MMC_MODE_HS;
826 
827 	return 0;
828 }
829 
830 /* frequency bases */
831 /* divided by 10 to be nice to platforms without floating point */
832 static const int fbase[] = {
833 	10000,
834 	100000,
835 	1000000,
836 	10000000,
837 };
838 
839 /* Multiplier values for TRAN_SPEED.  Multiplied by 10 to be nice
840  * to platforms without floating point.
841  */
842 static const int multipliers[] = {
843 	0,	/* reserved */
844 	10,
845 	12,
846 	13,
847 	15,
848 	20,
849 	25,
850 	30,
851 	35,
852 	40,
853 	45,
854 	50,
855 	55,
856 	60,
857 	70,
858 	80,
859 };
860 
861 static void mmc_set_ios(struct mmc *mmc)
862 {
863 	mmc->set_ios(mmc);
864 }
865 
866 void mmc_set_clock(struct mmc *mmc, uint clock)
867 {
868 	if (clock > mmc->f_max)
869 		clock = mmc->f_max;
870 
871 	if (clock < mmc->f_min)
872 		clock = mmc->f_min;
873 
874 	mmc->clock = clock;
875 
876 	mmc_set_ios(mmc);
877 }
878 
879 static void mmc_set_bus_width(struct mmc *mmc, uint width)
880 {
881 	mmc->bus_width = width;
882 
883 	mmc_set_ios(mmc);
884 }
885 
886 static int mmc_startup(struct mmc *mmc)
887 {
888 	int err;
889 	uint mult, freq;
890 	u64 cmult, csize, capacity;
891 	struct mmc_cmd cmd;
892 	ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, 512);
893 	ALLOC_CACHE_ALIGN_BUFFER(u8, test_csd, 512);
894 	int timeout = 1000;
895 
896 #ifdef CONFIG_MMC_SPI_CRC_ON
897 	if (mmc_host_is_spi(mmc)) { /* enable CRC check for spi */
898 		cmd.cmdidx = MMC_CMD_SPI_CRC_ON_OFF;
899 		cmd.resp_type = MMC_RSP_R1;
900 		cmd.cmdarg = 1;
901 		err = mmc_send_cmd(mmc, &cmd, NULL);
902 
903 		if (err)
904 			return err;
905 	}
906 #endif
907 
908 	/* Put the Card in Identify Mode */
909 	cmd.cmdidx = mmc_host_is_spi(mmc) ? MMC_CMD_SEND_CID :
910 		MMC_CMD_ALL_SEND_CID; /* cmd not supported in spi */
911 	cmd.resp_type = MMC_RSP_R2;
912 	cmd.cmdarg = 0;
913 
914 	err = mmc_send_cmd(mmc, &cmd, NULL);
915 
916 	if (err)
917 		return err;
918 
919 	memcpy(mmc->cid, cmd.response, 16);
920 
921 	/*
922 	 * For MMC cards, set the Relative Address.
923 	 * For SD cards, get the Relatvie Address.
924 	 * This also puts the cards into Standby State
925 	 */
926 	if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */
927 		cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR;
928 		cmd.cmdarg = mmc->rca << 16;
929 		cmd.resp_type = MMC_RSP_R6;
930 
931 		err = mmc_send_cmd(mmc, &cmd, NULL);
932 
933 		if (err)
934 			return err;
935 
936 		if (IS_SD(mmc))
937 			mmc->rca = (cmd.response[0] >> 16) & 0xffff;
938 	}
939 
940 	/* Get the Card-Specific Data */
941 	cmd.cmdidx = MMC_CMD_SEND_CSD;
942 	cmd.resp_type = MMC_RSP_R2;
943 	cmd.cmdarg = mmc->rca << 16;
944 
945 	err = mmc_send_cmd(mmc, &cmd, NULL);
946 
947 	/* Waiting for the ready status */
948 	mmc_send_status(mmc, timeout);
949 
950 	if (err)
951 		return err;
952 
953 	mmc->csd[0] = cmd.response[0];
954 	mmc->csd[1] = cmd.response[1];
955 	mmc->csd[2] = cmd.response[2];
956 	mmc->csd[3] = cmd.response[3];
957 
958 	if (mmc->version == MMC_VERSION_UNKNOWN) {
959 		int version = (cmd.response[0] >> 26) & 0xf;
960 
961 		switch (version) {
962 			case 0:
963 				mmc->version = MMC_VERSION_1_2;
964 				break;
965 			case 1:
966 				mmc->version = MMC_VERSION_1_4;
967 				break;
968 			case 2:
969 				mmc->version = MMC_VERSION_2_2;
970 				break;
971 			case 3:
972 				mmc->version = MMC_VERSION_3;
973 				break;
974 			case 4:
975 				mmc->version = MMC_VERSION_4;
976 				break;
977 			default:
978 				mmc->version = MMC_VERSION_1_2;
979 				break;
980 		}
981 	}
982 
983 	/* divide frequency by 10, since the mults are 10x bigger */
984 	freq = fbase[(cmd.response[0] & 0x7)];
985 	mult = multipliers[((cmd.response[0] >> 3) & 0xf)];
986 
987 	mmc->tran_speed = freq * mult;
988 
989 	mmc->read_bl_len = 1 << ((cmd.response[1] >> 16) & 0xf);
990 
991 	if (IS_SD(mmc))
992 		mmc->write_bl_len = mmc->read_bl_len;
993 	else
994 		mmc->write_bl_len = 1 << ((cmd.response[3] >> 22) & 0xf);
995 
996 	if (mmc->high_capacity) {
997 		csize = (mmc->csd[1] & 0x3f) << 16
998 			| (mmc->csd[2] & 0xffff0000) >> 16;
999 		cmult = 8;
1000 	} else {
1001 		csize = (mmc->csd[1] & 0x3ff) << 2
1002 			| (mmc->csd[2] & 0xc0000000) >> 30;
1003 		cmult = (mmc->csd[2] & 0x00038000) >> 15;
1004 	}
1005 
1006 	mmc->capacity = (csize + 1) << (cmult + 2);
1007 	mmc->capacity *= mmc->read_bl_len;
1008 
1009 	if (mmc->read_bl_len > 512)
1010 		mmc->read_bl_len = 512;
1011 
1012 	if (mmc->write_bl_len > 512)
1013 		mmc->write_bl_len = 512;
1014 
1015 	/* Select the card, and put it into Transfer Mode */
1016 	if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */
1017 		cmd.cmdidx = MMC_CMD_SELECT_CARD;
1018 		cmd.resp_type = MMC_RSP_R1;
1019 		cmd.cmdarg = mmc->rca << 16;
1020 		err = mmc_send_cmd(mmc, &cmd, NULL);
1021 
1022 		if (err)
1023 			return err;
1024 	}
1025 
1026 	/*
1027 	 * For SD, its erase group is always one sector
1028 	 */
1029 	mmc->erase_grp_size = 1;
1030 	mmc->part_config = MMCPART_NOAVAILABLE;
1031 	if (!IS_SD(mmc) && (mmc->version >= MMC_VERSION_4)) {
1032 		/* check  ext_csd version and capacity */
1033 		err = mmc_send_ext_csd(mmc, ext_csd);
1034 		if (!err && (ext_csd[EXT_CSD_REV] >= 2)) {
1035 			/*
1036 			 * According to the JEDEC Standard, the value of
1037 			 * ext_csd's capacity is valid if the value is more
1038 			 * than 2GB
1039 			 */
1040 			capacity = ext_csd[EXT_CSD_SEC_CNT] << 0
1041 					| ext_csd[EXT_CSD_SEC_CNT + 1] << 8
1042 					| ext_csd[EXT_CSD_SEC_CNT + 2] << 16
1043 					| ext_csd[EXT_CSD_SEC_CNT + 3] << 24;
1044 			capacity *= 512;
1045 			if ((capacity >> 20) > 2 * 1024)
1046 				mmc->capacity = capacity;
1047 		}
1048 
1049 		/*
1050 		 * Check whether GROUP_DEF is set, if yes, read out
1051 		 * group size from ext_csd directly, or calculate
1052 		 * the group size from the csd value.
1053 		 */
1054 		if (ext_csd[EXT_CSD_ERASE_GROUP_DEF])
1055 			mmc->erase_grp_size =
1056 			      ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] * 512 * 1024;
1057 		else {
1058 			int erase_gsz, erase_gmul;
1059 			erase_gsz = (mmc->csd[2] & 0x00007c00) >> 10;
1060 			erase_gmul = (mmc->csd[2] & 0x000003e0) >> 5;
1061 			mmc->erase_grp_size = (erase_gsz + 1)
1062 				* (erase_gmul + 1);
1063 		}
1064 
1065 		/* store the partition info of emmc */
1066 		if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) ||
1067 		    ext_csd[EXT_CSD_BOOT_MULT])
1068 			mmc->part_config = ext_csd[EXT_CSD_PART_CONF];
1069 	}
1070 
1071 	if (IS_SD(mmc))
1072 		err = sd_change_freq(mmc);
1073 	else
1074 		err = mmc_change_freq(mmc);
1075 
1076 	if (err)
1077 		return err;
1078 
1079 	/* Restrict card's capabilities by what the host can do */
1080 	mmc->card_caps &= mmc->host_caps;
1081 
1082 	if (IS_SD(mmc)) {
1083 		if (mmc->card_caps & MMC_MODE_4BIT) {
1084 			cmd.cmdidx = MMC_CMD_APP_CMD;
1085 			cmd.resp_type = MMC_RSP_R1;
1086 			cmd.cmdarg = mmc->rca << 16;
1087 
1088 			err = mmc_send_cmd(mmc, &cmd, NULL);
1089 			if (err)
1090 				return err;
1091 
1092 			cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH;
1093 			cmd.resp_type = MMC_RSP_R1;
1094 			cmd.cmdarg = 2;
1095 			err = mmc_send_cmd(mmc, &cmd, NULL);
1096 			if (err)
1097 				return err;
1098 
1099 			mmc_set_bus_width(mmc, 4);
1100 		}
1101 
1102 		if (mmc->card_caps & MMC_MODE_HS)
1103 			mmc->tran_speed = 50000000;
1104 		else
1105 			mmc->tran_speed = 25000000;
1106 	} else {
1107 		int idx;
1108 
1109 		/* An array of possible bus widths in order of preference */
1110 		static unsigned ext_csd_bits[] = {
1111 			EXT_CSD_BUS_WIDTH_8,
1112 			EXT_CSD_BUS_WIDTH_4,
1113 			EXT_CSD_BUS_WIDTH_1,
1114 		};
1115 
1116 		/* An array to map CSD bus widths to host cap bits */
1117 		static unsigned ext_to_hostcaps[] = {
1118 			[EXT_CSD_BUS_WIDTH_4] = MMC_MODE_4BIT,
1119 			[EXT_CSD_BUS_WIDTH_8] = MMC_MODE_8BIT,
1120 		};
1121 
1122 		/* An array to map chosen bus width to an integer */
1123 		static unsigned widths[] = {
1124 			8, 4, 1,
1125 		};
1126 
1127 		for (idx=0; idx < ARRAY_SIZE(ext_csd_bits); idx++) {
1128 			unsigned int extw = ext_csd_bits[idx];
1129 
1130 			/*
1131 			 * Check to make sure the controller supports
1132 			 * this bus width, if it's more than 1
1133 			 */
1134 			if (extw != EXT_CSD_BUS_WIDTH_1 &&
1135 					!(mmc->host_caps & ext_to_hostcaps[extw]))
1136 				continue;
1137 
1138 			err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1139 					EXT_CSD_BUS_WIDTH, extw);
1140 
1141 			if (err)
1142 				continue;
1143 
1144 			mmc_set_bus_width(mmc, widths[idx]);
1145 
1146 			err = mmc_send_ext_csd(mmc, test_csd);
1147 			if (!err && ext_csd[EXT_CSD_PARTITIONING_SUPPORT] \
1148 				    == test_csd[EXT_CSD_PARTITIONING_SUPPORT]
1149 				 && ext_csd[EXT_CSD_ERASE_GROUP_DEF] \
1150 				    == test_csd[EXT_CSD_ERASE_GROUP_DEF] \
1151 				 && ext_csd[EXT_CSD_REV] \
1152 				    == test_csd[EXT_CSD_REV]
1153 				 && ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] \
1154 				    == test_csd[EXT_CSD_HC_ERASE_GRP_SIZE]
1155 				 && memcmp(&ext_csd[EXT_CSD_SEC_CNT], \
1156 					&test_csd[EXT_CSD_SEC_CNT], 4) == 0) {
1157 
1158 				mmc->card_caps |= ext_to_hostcaps[extw];
1159 				break;
1160 			}
1161 		}
1162 
1163 		if (mmc->card_caps & MMC_MODE_HS) {
1164 			if (mmc->card_caps & MMC_MODE_HS_52MHz)
1165 				mmc->tran_speed = 52000000;
1166 			else
1167 				mmc->tran_speed = 26000000;
1168 		}
1169 	}
1170 
1171 	mmc_set_clock(mmc, mmc->tran_speed);
1172 
1173 	/* fill in device description */
1174 	mmc->block_dev.lun = 0;
1175 	mmc->block_dev.type = 0;
1176 	mmc->block_dev.blksz = mmc->read_bl_len;
1177 	mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len);
1178 	sprintf(mmc->block_dev.vendor, "Man %06x Snr %04x%04x",
1179 		mmc->cid[0] >> 24, (mmc->cid[2] & 0xffff),
1180 		(mmc->cid[3] >> 16) & 0xffff);
1181 	sprintf(mmc->block_dev.product, "%c%c%c%c%c%c", mmc->cid[0] & 0xff,
1182 		(mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff,
1183 		(mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff,
1184 		(mmc->cid[2] >> 24) & 0xff);
1185 	sprintf(mmc->block_dev.revision, "%d.%d", (mmc->cid[2] >> 20) & 0xf,
1186 		(mmc->cid[2] >> 16) & 0xf);
1187 #if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBDISK_SUPPORT)
1188 	init_part(&mmc->block_dev);
1189 #endif
1190 
1191 	return 0;
1192 }
1193 
1194 static int mmc_send_if_cond(struct mmc *mmc)
1195 {
1196 	struct mmc_cmd cmd;
1197 	int err;
1198 
1199 	cmd.cmdidx = SD_CMD_SEND_IF_COND;
1200 	/* We set the bit if the host supports voltages between 2.7 and 3.6 V */
1201 	cmd.cmdarg = ((mmc->voltages & 0xff8000) != 0) << 8 | 0xaa;
1202 	cmd.resp_type = MMC_RSP_R7;
1203 
1204 	err = mmc_send_cmd(mmc, &cmd, NULL);
1205 
1206 	if (err)
1207 		return err;
1208 
1209 	if ((cmd.response[0] & 0xff) != 0xaa)
1210 		return UNUSABLE_ERR;
1211 	else
1212 		mmc->version = SD_VERSION_2;
1213 
1214 	return 0;
1215 }
1216 
1217 int mmc_register(struct mmc *mmc)
1218 {
1219 	/* Setup the universal parts of the block interface just once */
1220 	mmc->block_dev.if_type = IF_TYPE_MMC;
1221 	mmc->block_dev.dev = cur_dev_num++;
1222 	mmc->block_dev.removable = 1;
1223 	mmc->block_dev.block_read = mmc_bread;
1224 	mmc->block_dev.block_write = mmc_bwrite;
1225 	mmc->block_dev.block_erase = mmc_berase;
1226 	if (!mmc->b_max)
1227 		mmc->b_max = CONFIG_SYS_MMC_MAX_BLK_COUNT;
1228 
1229 	INIT_LIST_HEAD (&mmc->link);
1230 
1231 	list_add_tail (&mmc->link, &mmc_devices);
1232 
1233 	return 0;
1234 }
1235 
1236 #ifdef CONFIG_PARTITIONS
1237 block_dev_desc_t *mmc_get_dev(int dev)
1238 {
1239 	struct mmc *mmc = find_mmc_device(dev);
1240 	if (!mmc || mmc_init(mmc))
1241 		return NULL;
1242 
1243 	return &mmc->block_dev;
1244 }
1245 #endif
1246 
1247 int mmc_init(struct mmc *mmc)
1248 {
1249 	int err;
1250 
1251 	if (mmc_getcd(mmc) == 0) {
1252 		mmc->has_init = 0;
1253 		printf("MMC: no card present\n");
1254 		return NO_CARD_ERR;
1255 	}
1256 
1257 	if (mmc->has_init)
1258 		return 0;
1259 
1260 	err = mmc->init(mmc);
1261 
1262 	if (err)
1263 		return err;
1264 
1265 	mmc_set_bus_width(mmc, 1);
1266 	mmc_set_clock(mmc, 1);
1267 
1268 	/* Reset the Card */
1269 	err = mmc_go_idle(mmc);
1270 
1271 	if (err)
1272 		return err;
1273 
1274 	/* The internal partition reset to user partition(0) at every CMD0*/
1275 	mmc->part_num = 0;
1276 
1277 	/* Test for SD version 2 */
1278 	err = mmc_send_if_cond(mmc);
1279 
1280 	/* Now try to get the SD card's operating condition */
1281 	err = sd_send_op_cond(mmc);
1282 
1283 	/* If the command timed out, we check for an MMC card */
1284 	if (err == TIMEOUT) {
1285 		err = mmc_send_op_cond(mmc);
1286 
1287 		if (err) {
1288 			printf("Card did not respond to voltage select!\n");
1289 			return UNUSABLE_ERR;
1290 		}
1291 	}
1292 
1293 	err = mmc_startup(mmc);
1294 	if (err)
1295 		mmc->has_init = 0;
1296 	else
1297 		mmc->has_init = 1;
1298 	return err;
1299 }
1300 
1301 /*
1302  * CPU and board-specific MMC initializations.  Aliased function
1303  * signals caller to move on
1304  */
1305 static int __def_mmc_init(bd_t *bis)
1306 {
1307 	return -1;
1308 }
1309 
1310 int cpu_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init")));
1311 int board_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init")));
1312 
1313 void print_mmc_devices(char separator)
1314 {
1315 	struct mmc *m;
1316 	struct list_head *entry;
1317 
1318 	list_for_each(entry, &mmc_devices) {
1319 		m = list_entry(entry, struct mmc, link);
1320 
1321 		printf("%s: %d", m->name, m->block_dev.dev);
1322 
1323 		if (entry->next != &mmc_devices)
1324 			printf("%c ", separator);
1325 	}
1326 
1327 	printf("\n");
1328 }
1329 
1330 int get_mmc_num(void)
1331 {
1332 	return cur_dev_num;
1333 }
1334 
1335 int mmc_initialize(bd_t *bis)
1336 {
1337 	INIT_LIST_HEAD (&mmc_devices);
1338 	cur_dev_num = 0;
1339 
1340 	if (board_mmc_init(bis) < 0)
1341 		cpu_mmc_init(bis);
1342 
1343 	print_mmc_devices(',');
1344 
1345 	return 0;
1346 }
1347