blob: 596732e80e615f6a8ab1ccd559f11b80419647a6 [file] [log] [blame]
Andy Fleming272cc702008-10-30 16:41:01 -05001/*
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>
Rabin Vincent9b1f9422009-04-05 13:30:54 +053033#include <div64.h>
Andy Fleming272cc702008-10-30 16:41:01 -050034
Matt Waddelce0fbcd2011-02-24 16:35:23 +000035/* 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
Andy Fleming272cc702008-10-30 16:41:01 -050040static struct list_head mmc_devices;
41static int cur_dev_num = -1;
42
Thierry Reding314284b2012-01-02 01:15:36 +000043int __board_mmc_getcd(struct mmc *mmc) {
Stefano Babic11fdade2010-02-05 15:04:43 +010044 return -1;
45}
46
Thierry Reding314284b2012-01-02 01:15:36 +000047int board_mmc_getcd(struct mmc *mmc)__attribute__((weak,
Stefano Babic11fdade2010-02-05 15:04:43 +010048 alias("__board_mmc_getcd")));
49
Marek Vasut8635ff92012-03-15 18:41:35 +000050#ifdef CONFIG_MMC_BOUNCE_BUFFER
51static 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
74static 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
106static 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
131static inline int mmc_bounce_buffer_start(struct mmc_data *backup,
Anatolij Gustschindc3faf02012-03-28 21:24:32 +0000132 struct mmc_data *orig) { return 0; }
Marek Vasut8635ff92012-03-15 18:41:35 +0000133static inline void mmc_bounce_buffer_stop(struct mmc_data *backup,
134 struct mmc_data *orig) { }
135#endif
136
Andy Fleming272cc702008-10-30 16:41:01 -0500137int mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
138{
Marek Vasut8635ff92012-03-15 18:41:35 +0000139 struct mmc_data backup;
Raffaele Recalcati5db2fe32011-03-11 02:01:14 +0000140 int ret;
Marek Vasut8635ff92012-03-15 18:41:35 +0000141
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
Raffaele Recalcati5db2fe32011-03-11 02:01:14 +0000149 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);
Dirk Behme146bec72012-03-08 02:35:34 +0000182 ptr = (u8 *)&cmd->response[i];
Raffaele Recalcati5db2fe32011-03-11 02:01:14 +0000183 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 }
Raffaele Recalcati5db2fe32011-03-11 02:01:14 +0000197#else
Marek Vasut8635ff92012-03-15 18:41:35 +0000198 ret = mmc->send_cmd(mmc, cmd, data);
Raffaele Recalcati5db2fe32011-03-11 02:01:14 +0000199#endif
Marek Vasut8635ff92012-03-15 18:41:35 +0000200 mmc_bounce_buffer_stop(&backup, data);
201 return ret;
Andy Fleming272cc702008-10-30 16:41:01 -0500202}
203
Raffaele Recalcati5d4fc8d2011-03-11 02:01:12 +0000204int mmc_send_status(struct mmc *mmc, int timeout)
205{
206 struct mmc_cmd cmd;
Jan Kloetzked617c422012-02-05 22:29:12 +0000207 int err, retries = 5;
Raffaele Recalcati5d4fc8d2011-03-11 02:01:12 +0000208#ifdef CONFIG_MMC_TRACE
209 int status;
210#endif
211
212 cmd.cmdidx = MMC_CMD_SEND_STATUS;
213 cmd.resp_type = MMC_RSP_R1;
Marek Vasutaaf3d412011-08-10 09:24:48 +0200214 if (!mmc_host_is_spi(mmc))
215 cmd.cmdarg = mmc->rca << 16;
Raffaele Recalcati5d4fc8d2011-03-11 02:01:12 +0000216 cmd.flags = 0;
217
218 do {
219 err = mmc_send_cmd(mmc, &cmd, NULL);
Jan Kloetzked617c422012-02-05 22:29:12 +0000220 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)
Raffaele Recalcati5d4fc8d2011-03-11 02:01:12 +0000231 return err;
Raffaele Recalcati5d4fc8d2011-03-11 02:01:12 +0000232
233 udelay(1000);
234
Raffaele Recalcati5d4fc8d2011-03-11 02:01:12 +0000235 } while (timeout--);
236
Raffaele Recalcati5db2fe32011-03-11 02:01:14 +0000237#ifdef CONFIG_MMC_TRACE
238 status = (cmd.response[0] & MMC_STATUS_CURR_STATE) >> 9;
239 printf("CURR STATE:%d\n", status);
240#endif
Raffaele Recalcati5d4fc8d2011-03-11 02:01:12 +0000241 if (!timeout) {
242 printf("Timeout waiting card ready\n");
243 return TIMEOUT;
244 }
245
246 return 0;
247}
248
Andy Fleming272cc702008-10-30 16:41:01 -0500249int 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
261struct 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
Lei Wene6f99a52011-06-22 17:03:31 +0000278static 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
325err_out:
326 puts("mmc erase failed\n");
327 return err;
328}
329
330static unsigned long
331mmc_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
Andy Fleming272cc702008-10-30 16:41:01 -0500360static ulong
Lei Wen01581262010-10-14 13:38:11 +0800361mmc_write_blocks(struct mmc *mmc, ulong start, lbaint_t blkcnt, const void*src)
Andy Fleming272cc702008-10-30 16:41:01 -0500362{
363 struct mmc_cmd cmd;
364 struct mmc_data data;
Raffaele Recalcati5d4fc8d2011-03-11 02:01:12 +0000365 int timeout = 1000;
Andy Fleming272cc702008-10-30 16:41:01 -0500366
Lei Wend2bf29e2010-09-13 22:07:27 +0800367 if ((start + blkcnt) > mmc->block_dev.lba) {
Steve Sakomandef412b2010-10-28 09:00:26 -0700368 printf("MMC: block number 0x%lx exceeds max(0x%lx)\n",
Lei Wend2bf29e2010-09-13 22:07:27 +0800369 start + blkcnt, mmc->block_dev.lba);
370 return 0;
371 }
Andy Fleming272cc702008-10-30 16:41:01 -0500372
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
Steve Sakomandef412b2010-10-28 09:00:26 -0700381 cmd.cmdarg = start * mmc->write_bl_len;
Andy Fleming272cc702008-10-30 16:41:01 -0500382
383 cmd.resp_type = MMC_RSP_R1;
384 cmd.flags = 0;
385
386 data.src = src;
387 data.blocks = blkcnt;
Steve Sakomandef412b2010-10-28 09:00:26 -0700388 data.blocksize = mmc->write_bl_len;
Andy Fleming272cc702008-10-30 16:41:01 -0500389 data.flags = MMC_DATA_WRITE;
390
Steve Sakomandef412b2010-10-28 09:00:26 -0700391 if (mmc_send_cmd(mmc, &cmd, &data)) {
392 printf("mmc write failed\n");
393 return 0;
Andy Fleming272cc702008-10-30 16:41:01 -0500394 }
395
Thomas Choud52ebf12010-12-24 13:12:21 +0000396 /* SPI multiblock writes terminate using a special
397 * token, not a STOP_TRANSMISSION request.
398 */
399 if (!mmc_host_is_spi(mmc) && blkcnt > 1) {
Andy Fleming272cc702008-10-30 16:41:01 -0500400 cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION;
401 cmd.cmdarg = 0;
402 cmd.resp_type = MMC_RSP_R1b;
403 cmd.flags = 0;
Steve Sakomandef412b2010-10-28 09:00:26 -0700404 if (mmc_send_cmd(mmc, &cmd, NULL)) {
405 printf("mmc fail to send stop cmd\n");
406 return 0;
Lei Wen01581262010-10-14 13:38:11 +0800407 }
Andy Fleming272cc702008-10-30 16:41:01 -0500408 }
409
Jan Kloetzke93ad0d12012-02-05 22:29:11 +0000410 /* Waiting for the ready status */
411 if (mmc_send_status(mmc, timeout))
412 return 0;
413
Andy Fleming272cc702008-10-30 16:41:01 -0500414 return blkcnt;
415}
416
Lei Wen01581262010-10-14 13:38:11 +0800417static ulong
418mmc_bwrite(int dev_num, ulong start, lbaint_t blkcnt, const void*src)
419{
Lei Wen01581262010-10-14 13:38:11 +0800420 lbaint_t cur, blocks_todo = blkcnt;
421
Steve Sakomandef412b2010-10-28 09:00:26 -0700422 struct mmc *mmc = find_mmc_device(dev_num);
Lei Wen01581262010-10-14 13:38:11 +0800423 if (!mmc)
Steve Sakomandef412b2010-10-28 09:00:26 -0700424 return 0;
Lei Wen01581262010-10-14 13:38:11 +0800425
Steve Sakomandef412b2010-10-28 09:00:26 -0700426 if (mmc_set_blocklen(mmc, mmc->write_bl_len))
427 return 0;
Lei Wen01581262010-10-14 13:38:11 +0800428
429 do {
John Rigby8feafcc2011-04-18 05:50:08 +0000430 cur = (blocks_todo > mmc->b_max) ? mmc->b_max : blocks_todo;
Lei Wen01581262010-10-14 13:38:11 +0800431 if(mmc_write_blocks(mmc, start, cur, src) != cur)
Steve Sakomandef412b2010-10-28 09:00:26 -0700432 return 0;
Lei Wen01581262010-10-14 13:38:11 +0800433 blocks_todo -= cur;
434 start += cur;
435 src += cur * mmc->write_bl_len;
436 } while (blocks_todo > 0);
437
438 return blkcnt;
439}
440
Alagu Sankar4a1a06b2010-10-25 07:23:56 -0700441int mmc_read_blocks(struct mmc *mmc, void *dst, ulong start, lbaint_t blkcnt)
Andy Fleming272cc702008-10-30 16:41:01 -0500442{
443 struct mmc_cmd cmd;
444 struct mmc_data data;
445
Alagu Sankar4a1a06b2010-10-25 07:23:56 -0700446 if (blkcnt > 1)
447 cmd.cmdidx = MMC_CMD_READ_MULTIPLE_BLOCK;
448 else
449 cmd.cmdidx = MMC_CMD_READ_SINGLE_BLOCK;
Andy Fleming272cc702008-10-30 16:41:01 -0500450
451 if (mmc->high_capacity)
Alagu Sankar4a1a06b2010-10-25 07:23:56 -0700452 cmd.cmdarg = start;
Andy Fleming272cc702008-10-30 16:41:01 -0500453 else
Alagu Sankar4a1a06b2010-10-25 07:23:56 -0700454 cmd.cmdarg = start * mmc->read_bl_len;
Andy Fleming272cc702008-10-30 16:41:01 -0500455
456 cmd.resp_type = MMC_RSP_R1;
457 cmd.flags = 0;
458
459 data.dest = dst;
Alagu Sankar4a1a06b2010-10-25 07:23:56 -0700460 data.blocks = blkcnt;
Andy Fleming272cc702008-10-30 16:41:01 -0500461 data.blocksize = mmc->read_bl_len;
462 data.flags = MMC_DATA_READ;
463
Alagu Sankar4a1a06b2010-10-25 07:23:56 -0700464 if (mmc_send_cmd(mmc, &cmd, &data))
465 return 0;
Andy Fleming272cc702008-10-30 16:41:01 -0500466
Alagu Sankar4a1a06b2010-10-25 07:23:56 -0700467 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 }
Andy Fleming272cc702008-10-30 16:41:01 -0500476 }
477
Alagu Sankar4a1a06b2010-10-25 07:23:56 -0700478 return blkcnt;
Andy Fleming272cc702008-10-30 16:41:01 -0500479}
480
481static ulong mmc_bread(int dev_num, ulong start, lbaint_t blkcnt, void *dst)
482{
Alagu Sankar4a1a06b2010-10-25 07:23:56 -0700483 lbaint_t cur, blocks_todo = blkcnt;
Andy Fleming272cc702008-10-30 16:41:01 -0500484
Alagu Sankar4a1a06b2010-10-25 07:23:56 -0700485 if (blkcnt == 0)
486 return 0;
487
488 struct mmc *mmc = find_mmc_device(dev_num);
Andy Fleming272cc702008-10-30 16:41:01 -0500489 if (!mmc)
490 return 0;
491
Lei Wend2bf29e2010-09-13 22:07:27 +0800492 if ((start + blkcnt) > mmc->block_dev.lba) {
Alagu Sankar4a1a06b2010-10-25 07:23:56 -0700493 printf("MMC: block number 0x%lx exceeds max(0x%lx)\n",
Lei Wend2bf29e2010-09-13 22:07:27 +0800494 start + blkcnt, mmc->block_dev.lba);
495 return 0;
496 }
Andy Fleming272cc702008-10-30 16:41:01 -0500497
Alagu Sankar4a1a06b2010-10-25 07:23:56 -0700498 if (mmc_set_blocklen(mmc, mmc->read_bl_len))
Andy Fleming272cc702008-10-30 16:41:01 -0500499 return 0;
Andy Fleming272cc702008-10-30 16:41:01 -0500500
Alagu Sankar4a1a06b2010-10-25 07:23:56 -0700501 do {
John Rigby8feafcc2011-04-18 05:50:08 +0000502 cur = (blocks_todo > mmc->b_max) ? mmc->b_max : blocks_todo;
Alagu Sankar4a1a06b2010-10-25 07:23:56 -0700503 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);
Andy Fleming272cc702008-10-30 16:41:01 -0500509
510 return blkcnt;
511}
512
513int 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
535int
536sd_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;
Stefano Babic250de122010-01-20 18:20:39 +0100555
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 */
Thomas Choud52ebf12010-12-24 13:12:21 +0000563 cmd.cmdarg = mmc_host_is_spi(mmc) ? 0 :
564 (mmc->voltages & 0xff8000);
Andy Fleming272cc702008-10-30 16:41:01 -0500565
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
Thomas Choud52ebf12010-12-24 13:12:21 +0000583 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
Rabin Vincent998be3d2009-04-05 13:30:56 +0530595 mmc->ocr = cmd.response[0];
Andy Fleming272cc702008-10-30 16:41:01 -0500596
597 mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
598 mmc->rca = 0;
599
600 return 0;
601}
602
603int mmc_send_op_cond(struct mmc *mmc)
604{
Raffaele Recalcati31cacba2011-03-11 02:01:13 +0000605 int timeout = 10000;
Andy Fleming272cc702008-10-30 16:41:01 -0500606 struct mmc_cmd cmd;
607 int err;
608
609 /* Some cards seem to need this */
610 mmc_go_idle(mmc);
611
Raffaele Recalcati31cacba2011-03-11 02:01:13 +0000612 /* 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;
Wolfgang Denkcd6881b2011-05-19 22:21:41 +0200617
Raffaele Recalcati31cacba2011-03-11 02:01:13 +0000618 err = mmc_send_cmd(mmc, &cmd, NULL);
Wolfgang Denkcd6881b2011-05-19 22:21:41 +0200619
Raffaele Recalcati31cacba2011-03-11 02:01:13 +0000620 if (err)
621 return err;
Wolfgang Denkcd6881b2011-05-19 22:21:41 +0200622
Raffaele Recalcati31cacba2011-03-11 02:01:13 +0000623 udelay(1000);
Wolfgang Denkcd6881b2011-05-19 22:21:41 +0200624
Andy Fleming272cc702008-10-30 16:41:01 -0500625 do {
626 cmd.cmdidx = MMC_CMD_SEND_OP_COND;
627 cmd.resp_type = MMC_RSP_R3;
Raffaele Recalcati31cacba2011-03-11 02:01:13 +0000628 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));
Łukasz Majewskib1f1e8212011-07-05 02:19:44 +0000632
633 if (mmc->host_caps & MMC_MODE_HC)
634 cmd.cmdarg |= OCR_HCS;
635
Andy Fleming272cc702008-10-30 16:41:01 -0500636 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
Thomas Choud52ebf12010-12-24 13:12:21 +0000649 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
Andy Fleming272cc702008-10-30 16:41:01 -0500661 mmc->version = MMC_VERSION_UNKNOWN;
Rabin Vincent998be3d2009-04-05 13:30:56 +0530662 mmc->ocr = cmd.response[0];
Andy Fleming272cc702008-10-30 16:41:01 -0500663
664 mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
665 mmc->rca = 0;
666
667 return 0;
668}
669
670
671int 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
694int mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value)
695{
696 struct mmc_cmd cmd;
Raffaele Recalcati5d4fc8d2011-03-11 02:01:12 +0000697 int timeout = 1000;
698 int ret;
Andy Fleming272cc702008-10-30 16:41:01 -0500699
700 cmd.cmdidx = MMC_CMD_SWITCH;
701 cmd.resp_type = MMC_RSP_R1b;
702 cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
Raffaele Recalcati5d4fc8d2011-03-11 02:01:12 +0000703 (index << 16) |
704 (value << 8);
Andy Fleming272cc702008-10-30 16:41:01 -0500705 cmd.flags = 0;
706
Raffaele Recalcati5d4fc8d2011-03-11 02:01:12 +0000707 ret = mmc_send_cmd(mmc, &cmd, NULL);
708
709 /* Waiting for the ready status */
Jan Kloetzke93ad0d12012-02-05 22:29:11 +0000710 if (!ret)
711 ret = mmc_send_status(mmc, timeout);
Raffaele Recalcati5d4fc8d2011-03-11 02:01:12 +0000712
713 return ret;
714
Andy Fleming272cc702008-10-30 16:41:01 -0500715}
716
717int mmc_change_freq(struct mmc *mmc)
718{
Anton staafa1969922011-10-04 11:24:50 +0000719 ALLOC_CACHE_ALIGN_BUFFER(char, ext_csd, 512);
Andy Fleming272cc702008-10-30 16:41:01 -0500720 char cardtype;
721 int err;
722
723 mmc->card_caps = 0;
724
Thomas Choud52ebf12010-12-24 13:12:21 +0000725 if (mmc_host_is_spi(mmc))
726 return 0;
727
Andy Fleming272cc702008-10-30 16:41:01 -0500728 /* Only version 4 supports high-speed */
729 if (mmc->version < MMC_VERSION_4)
730 return 0;
731
Andy Fleming272cc702008-10-30 16:41:01 -0500732 err = mmc_send_ext_csd(mmc, ext_csd);
733
734 if (err)
735 return err;
736
Lei Wen0560db12011-10-03 20:35:10 +0000737 cardtype = ext_csd[EXT_CSD_CARD_TYPE] & 0xf;
Andy Fleming272cc702008-10-30 16:41:01 -0500738
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 */
Lei Wen0560db12011-10-03 20:35:10 +0000751 if (!ext_csd[EXT_CSD_HS_TIMING])
Andy Fleming272cc702008-10-30 16:41:01 -0500752 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
Lei Wenbc897b12011-05-02 16:26:26 +0000763int 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
Thierry Reding48972d92012-01-02 01:15:37 +0000775int 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
Andy Fleming272cc702008-10-30 16:41:01 -0500787int 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
809int sd_change_freq(struct mmc *mmc)
810{
811 int err;
812 struct mmc_cmd cmd;
Anton staaff781dd32011-10-03 13:54:59 +0000813 ALLOC_CACHE_ALIGN_BUFFER(uint, scr, 2);
814 ALLOC_CACHE_ALIGN_BUFFER(uint, switch_status, 16);
Andy Fleming272cc702008-10-30 16:41:01 -0500815 struct mmc_data data;
816 int timeout;
817
818 mmc->card_caps = 0;
819
Thomas Choud52ebf12010-12-24 13:12:21 +0000820 if (mmc_host_is_spi(mmc))
821 return 0;
822
Andy Fleming272cc702008-10-30 16:41:01 -0500823 /* 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
841retry_scr:
Anton staaff781dd32011-10-03 13:54:59 +0000842 data.dest = (char *)scr;
Andy Fleming272cc702008-10-30 16:41:01 -0500843 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
Yauhen Kharuzhy4e3d89b2009-05-07 00:43:30 +0300856 mmc->scr[0] = __be32_to_cpu(scr[0]);
857 mmc->scr[1] = __be32_to_cpu(scr[1]);
Andy Fleming272cc702008-10-30 16:41:01 -0500858
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
Alagu Sankarb44c7082010-05-12 15:08:24 +0530874 if (mmc->scr[0] & SD_DATA_4BIT)
875 mmc->card_caps |= MMC_MODE_4BIT;
876
Andy Fleming272cc702008-10-30 16:41:01 -0500877 /* 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,
Anton staaff781dd32011-10-03 13:54:59 +0000884 (u8 *)switch_status);
Andy Fleming272cc702008-10-30 16:41:01 -0500885
886 if (err)
887 return err;
888
889 /* The high-speed function is busy. Try again */
Yauhen Kharuzhy4e3d89b2009-05-07 00:43:30 +0300890 if (!(__be32_to_cpu(switch_status[7]) & SD_HIGHSPEED_BUSY))
Andy Fleming272cc702008-10-30 16:41:01 -0500891 break;
892 }
893
Andy Fleming272cc702008-10-30 16:41:01 -0500894 /* If high-speed isn't supported, we return */
Yauhen Kharuzhy4e3d89b2009-05-07 00:43:30 +0300895 if (!(__be32_to_cpu(switch_status[3]) & SD_HIGHSPEED_SUPPORTED))
Andy Fleming272cc702008-10-30 16:41:01 -0500896 return 0;
897
Macpaul Lin2c3fbf42011-11-28 16:31:09 +0000898 /*
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
Anton staaff781dd32011-10-03 13:54:59 +0000908 err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (u8 *)switch_status);
Andy Fleming272cc702008-10-30 16:41:01 -0500909
910 if (err)
911 return err;
912
Yauhen Kharuzhy4e3d89b2009-05-07 00:43:30 +0300913 if ((__be32_to_cpu(switch_status[4]) & 0x0f000000) == 0x01000000)
Andy Fleming272cc702008-10-30 16:41:01 -0500914 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 */
Mike Frysinger5f837c22010-10-20 01:15:53 +0000921static const int fbase[] = {
Andy Fleming272cc702008-10-30 16:41:01 -0500922 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 */
Mike Frysinger5f837c22010-10-20 01:15:53 +0000931static const int multipliers[] = {
Andy Fleming272cc702008-10-30 16:41:01 -0500932 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
950void mmc_set_ios(struct mmc *mmc)
951{
952 mmc->set_ios(mmc);
953}
954
955void 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
968void mmc_set_bus_width(struct mmc *mmc, uint width)
969{
970 mmc->bus_width = width;
971
972 mmc_set_ios(mmc);
973}
974
975int mmc_startup(struct mmc *mmc)
976{
Lei Wen41378942011-10-03 20:35:11 +0000977 int err, width;
Andy Fleming272cc702008-10-30 16:41:01 -0500978 uint mult, freq;
Yoshihiro Shimoda639b7822011-07-04 22:13:26 +0000979 u64 cmult, csize, capacity;
Andy Fleming272cc702008-10-30 16:41:01 -0500980 struct mmc_cmd cmd;
Anton staafa1969922011-10-04 11:24:50 +0000981 ALLOC_CACHE_ALIGN_BUFFER(char, ext_csd, 512);
Lei Wen41378942011-10-03 20:35:11 +0000982 ALLOC_CACHE_ALIGN_BUFFER(char, test_csd, 512);
Raffaele Recalcati5d4fc8d2011-03-11 02:01:12 +0000983 int timeout = 1000;
Andy Fleming272cc702008-10-30 16:41:01 -0500984
Thomas Choud52ebf12010-12-24 13:12:21 +0000985#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
Andy Fleming272cc702008-10-30 16:41:01 -0500998 /* Put the Card in Identify Mode */
Thomas Choud52ebf12010-12-24 13:12:21 +0000999 cmd.cmdidx = mmc_host_is_spi(mmc) ? MMC_CMD_SEND_CID :
1000 MMC_CMD_ALL_SEND_CID; /* cmd not supported in spi */
Andy Fleming272cc702008-10-30 16:41:01 -05001001 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 */
Thomas Choud52ebf12010-12-24 13:12:21 +00001017 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;
Andy Fleming272cc702008-10-30 16:41:01 -05001022
Thomas Choud52ebf12010-12-24 13:12:21 +00001023 err = mmc_send_cmd(mmc, &cmd, NULL);
Andy Fleming272cc702008-10-30 16:41:01 -05001024
Thomas Choud52ebf12010-12-24 13:12:21 +00001025 if (err)
1026 return err;
Andy Fleming272cc702008-10-30 16:41:01 -05001027
Thomas Choud52ebf12010-12-24 13:12:21 +00001028 if (IS_SD(mmc))
1029 mmc->rca = (cmd.response[0] >> 16) & 0xffff;
1030 }
Andy Fleming272cc702008-10-30 16:41:01 -05001031
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
Raffaele Recalcati5d4fc8d2011-03-11 02:01:12 +00001040 /* Waiting for the ready status */
1041 mmc_send_status(mmc, timeout);
1042
Andy Fleming272cc702008-10-30 16:41:01 -05001043 if (err)
1044 return err;
1045
Rabin Vincent998be3d2009-04-05 13:30:56 +05301046 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];
Andy Fleming272cc702008-10-30 16:41:01 -05001050
1051 if (mmc->version == MMC_VERSION_UNKNOWN) {
Rabin Vincent0b453ff2009-04-05 13:30:55 +05301052 int version = (cmd.response[0] >> 26) & 0xf;
Andy Fleming272cc702008-10-30 16:41:01 -05001053
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 */
Rabin Vincent0b453ff2009-04-05 13:30:55 +05301077 freq = fbase[(cmd.response[0] & 0x7)];
1078 mult = multipliers[((cmd.response[0] >> 3) & 0xf)];
Andy Fleming272cc702008-10-30 16:41:01 -05001079
1080 mmc->tran_speed = freq * mult;
1081
Rabin Vincent998be3d2009-04-05 13:30:56 +05301082 mmc->read_bl_len = 1 << ((cmd.response[1] >> 16) & 0xf);
Andy Fleming272cc702008-10-30 16:41:01 -05001083
1084 if (IS_SD(mmc))
1085 mmc->write_bl_len = mmc->read_bl_len;
1086 else
Rabin Vincent998be3d2009-04-05 13:30:56 +05301087 mmc->write_bl_len = 1 << ((cmd.response[3] >> 22) & 0xf);
Andy Fleming272cc702008-10-30 16:41:01 -05001088
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 */
Thomas Choud52ebf12010-12-24 13:12:21 +00001109 if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */
1110 cmd.cmdidx = MMC_CMD_SELECT_CARD;
Ajay Bhargavfe8f7062011-10-05 03:13:23 +00001111 cmd.resp_type = MMC_RSP_R1;
Thomas Choud52ebf12010-12-24 13:12:21 +00001112 cmd.cmdarg = mmc->rca << 16;
1113 cmd.flags = 0;
1114 err = mmc_send_cmd(mmc, &cmd, NULL);
Andy Fleming272cc702008-10-30 16:41:01 -05001115
Thomas Choud52ebf12010-12-24 13:12:21 +00001116 if (err)
1117 return err;
1118 }
Andy Fleming272cc702008-10-30 16:41:01 -05001119
Lei Wene6f99a52011-06-22 17:03:31 +00001120 /*
1121 * For SD, its erase group is always one sector
1122 */
1123 mmc->erase_grp_size = 1;
Lei Wenbc897b12011-05-02 16:26:26 +00001124 mmc->part_config = MMCPART_NOAVAILABLE;
Sukumar Ghoraid23e2c02010-09-20 18:29:29 +05301125 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);
Lei Wen0560db12011-10-03 20:35:10 +00001128 if (!err & (ext_csd[EXT_CSD_REV] >= 2)) {
Yoshihiro Shimoda639b7822011-07-04 22:13:26 +00001129 /*
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 */
Lei Wen0560db12011-10-03 20:35:10 +00001134 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;
Yoshihiro Shimoda639b7822011-07-04 22:13:26 +00001138 capacity *= 512;
Łukasz Majewskib1f1e8212011-07-05 02:19:44 +00001139 if ((capacity >> 20) > 2 * 1024)
Yoshihiro Shimoda639b7822011-07-04 22:13:26 +00001140 mmc->capacity = capacity;
Sukumar Ghoraid23e2c02010-09-20 18:29:29 +05301141 }
Lei Wenbc897b12011-05-02 16:26:26 +00001142
Lei Wene6f99a52011-06-22 17:03:31 +00001143 /*
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 */
Lei Wen0560db12011-10-03 20:35:10 +00001148 if (ext_csd[EXT_CSD_ERASE_GROUP_DEF])
1149 mmc->erase_grp_size =
1150 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] * 512 * 1024;
Lei Wene6f99a52011-06-22 17:03:31 +00001151 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
Lei Wenbc897b12011-05-02 16:26:26 +00001159 /* store the partition info of emmc */
Lei Wen0560db12011-10-03 20:35:10 +00001160 if (ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT)
1161 mmc->part_config = ext_csd[EXT_CSD_PART_CONF];
Sukumar Ghoraid23e2c02010-09-20 18:29:29 +05301162 }
1163
Andy Fleming272cc702008-10-30 16:41:01 -05001164 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 {
Lei Wen41378942011-10-03 20:35:11 +00001202 for (width = EXT_CSD_BUS_WIDTH_8; width >= 0; width--) {
Andy Fleming272cc702008-10-30 16:41:01 -05001203 /* Set the card to use 4 bit*/
1204 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
Lei Wen41378942011-10-03 20:35:11 +00001205 EXT_CSD_BUS_WIDTH, width);
Andy Fleming272cc702008-10-30 16:41:01 -05001206
1207 if (err)
Lei Wen41378942011-10-03 20:35:11 +00001208 continue;
Andy Fleming272cc702008-10-30 16:41:01 -05001209
Lei Wen41378942011-10-03 20:35:11 +00001210 if (!width) {
1211 mmc_set_bus_width(mmc, 1);
1212 break;
1213 } else
1214 mmc_set_bus_width(mmc, 4 * width);
Andy Fleming272cc702008-10-30 16:41:01 -05001215
Lei Wen41378942011-10-03 20:35:11 +00001216 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) {
Andy Fleming272cc702008-10-30 16:41:01 -05001227
Lei Wen41378942011-10-03 20:35:11 +00001228 mmc->card_caps |= width;
1229 break;
1230 }
Andy Fleming272cc702008-10-30 16:41:01 -05001231 }
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;
Rabin Vincent9b1f9422009-04-05 13:30:54 +05301246 mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len);
Rabin Vincent0b453ff2009-04-05 13:30:55 +05301247 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);
Andy Fleming272cc702008-10-30 16:41:01 -05001254 init_part(&mmc->block_dev);
1255
1256 return 0;
1257}
1258
1259int 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
Rabin Vincent998be3d2009-04-05 13:30:56 +05301275 if ((cmd.response[0] & 0xff) != 0xaa)
Andy Fleming272cc702008-10-30 16:41:01 -05001276 return UNUSABLE_ERR;
1277 else
1278 mmc->version = SD_VERSION_2;
1279
1280 return 0;
1281}
1282
1283int 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;
Lei Wene6f99a52011-06-22 17:03:31 +00001291 mmc->block_dev.block_erase = mmc_berase;
John Rigby8feafcc2011-04-18 05:50:08 +00001292 if (!mmc->b_max)
1293 mmc->b_max = CONFIG_SYS_MMC_MAX_BLK_COUNT;
Andy Fleming272cc702008-10-30 16:41:01 -05001294
1295 INIT_LIST_HEAD (&mmc->link);
1296
1297 list_add_tail (&mmc->link, &mmc_devices);
1298
1299 return 0;
1300}
1301
Matthew McClintockdf3fc522011-05-24 05:31:19 +00001302#ifdef CONFIG_PARTITIONS
Andy Fleming272cc702008-10-30 16:41:01 -05001303block_dev_desc_t *mmc_get_dev(int dev)
1304{
1305 struct mmc *mmc = find_mmc_device(dev);
1306
Rabin Vincente85649c2009-04-05 13:30:53 +05301307 return mmc ? &mmc->block_dev : NULL;
Andy Fleming272cc702008-10-30 16:41:01 -05001308}
Matthew McClintockdf3fc522011-05-24 05:31:19 +00001309#endif
Andy Fleming272cc702008-10-30 16:41:01 -05001310
1311int mmc_init(struct mmc *mmc)
1312{
Macpaul Linafd59322011-11-14 23:35:39 +00001313 int err;
Andy Fleming272cc702008-10-30 16:41:01 -05001314
Thierry Reding48972d92012-01-02 01:15:37 +00001315 if (mmc_getcd(mmc) == 0) {
1316 mmc->has_init = 0;
1317 printf("MMC: no card present\n");
1318 return NO_CARD_ERR;
1319 }
1320
Lei Wenbc897b12011-05-02 16:26:26 +00001321 if (mmc->has_init)
1322 return 0;
1323
Andy Fleming272cc702008-10-30 16:41:01 -05001324 err = mmc->init(mmc);
1325
1326 if (err)
1327 return err;
1328
Ilya Yanokb86b85e2009-06-29 17:53:16 +04001329 mmc_set_bus_width(mmc, 1);
1330 mmc_set_clock(mmc, 1);
1331
Andy Fleming272cc702008-10-30 16:41:01 -05001332 /* Reset the Card */
1333 err = mmc_go_idle(mmc);
1334
1335 if (err)
1336 return err;
1337
Lei Wenbc897b12011-05-02 16:26:26 +00001338 /* The internal partition reset to user partition(0) at every CMD0*/
1339 mmc->part_num = 0;
1340
Andy Fleming272cc702008-10-30 16:41:01 -05001341 /* Test for SD version 2 */
Macpaul Linafd59322011-11-14 23:35:39 +00001342 err = mmc_send_if_cond(mmc);
Andy Fleming272cc702008-10-30 16:41:01 -05001343
Andy Fleming272cc702008-10-30 16:41:01 -05001344 /* 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
Lei Wenbc897b12011-05-02 16:26:26 +00001357 err = mmc_startup(mmc);
1358 if (err)
1359 mmc->has_init = 0;
1360 else
1361 mmc->has_init = 1;
1362 return err;
Andy Fleming272cc702008-10-30 16:41:01 -05001363}
1364
1365/*
1366 * CPU and board-specific MMC initializations. Aliased function
1367 * signals caller to move on
1368 */
1369static int __def_mmc_init(bd_t *bis)
1370{
1371 return -1;
1372}
1373
Peter Tyserf9a109b2009-04-20 11:08:46 -05001374int cpu_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init")));
1375int board_mmc_init(bd_t *bis) __attribute__((weak, alias("__def_mmc_init")));
Andy Fleming272cc702008-10-30 16:41:01 -05001376
1377void 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
Lei Wenea6ebe22011-05-02 16:26:25 +00001394int get_mmc_num(void)
1395{
1396 return cur_dev_num;
1397}
1398
Andy Fleming272cc702008-10-30 16:41:01 -05001399int 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}