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