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