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