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