blob: 1eb9c2733948bf954aa00414824aa491adc4a4e3 [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 *
Wolfgang Denk1a459662013-07-08 09:37:19 +02007 * SPDX-License-Identifier: GPL-2.0+
Andy Fleming272cc702008-10-30 16:41:01 -05008 */
9
10#include <config.h>
11#include <common.h>
12#include <command.h>
Stephen Warrend4622df2014-05-23 12:47:06 -060013#include <errno.h>
Andy Fleming272cc702008-10-30 16:41:01 -050014#include <mmc.h>
15#include <part.h>
16#include <malloc.h>
17#include <linux/list.h>
Rabin Vincent9b1f9422009-04-05 13:30:54 +053018#include <div64.h>
Paul Burtonda61fa52013-09-09 15:30:26 +010019#include "mmc_private.h"
Andy Fleming272cc702008-10-30 16:41:01 -050020
21static struct list_head mmc_devices;
22static int cur_dev_num = -1;
23
Jeroen Hofstee750121c2014-07-12 21:24:08 +020024__weak int board_mmc_getwp(struct mmc *mmc)
Nikita Kiryanovd23d8d72012-12-03 02:19:46 +000025{
26 return -1;
27}
28
29int mmc_getwp(struct mmc *mmc)
30{
31 int wp;
32
33 wp = board_mmc_getwp(mmc);
34
Peter Korsgaardd4e1da42013-03-21 04:00:03 +000035 if (wp < 0) {
Pantelis Antoniou93bfd612014-03-11 19:34:20 +020036 if (mmc->cfg->ops->getwp)
37 wp = mmc->cfg->ops->getwp(mmc);
Peter Korsgaardd4e1da42013-03-21 04:00:03 +000038 else
39 wp = 0;
40 }
Nikita Kiryanovd23d8d72012-12-03 02:19:46 +000041
42 return wp;
43}
44
Jeroen Hofsteecee9ab72014-07-10 22:46:28 +020045__weak int board_mmc_getcd(struct mmc *mmc)
46{
Stefano Babic11fdade2010-02-05 15:04:43 +010047 return -1;
48}
49
Paul Burtonda61fa52013-09-09 15:30:26 +010050int mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
Andy Fleming272cc702008-10-30 16:41:01 -050051{
Raffaele Recalcati5db2fe32011-03-11 02:01:14 +000052 int ret;
Marek Vasut8635ff92012-03-15 18:41:35 +000053
Marek Vasut8635ff92012-03-15 18:41:35 +000054#ifdef CONFIG_MMC_TRACE
Raffaele Recalcati5db2fe32011-03-11 02:01:14 +000055 int i;
56 u8 *ptr;
57
58 printf("CMD_SEND:%d\n", cmd->cmdidx);
59 printf("\t\tARG\t\t\t 0x%08X\n", cmd->cmdarg);
Pantelis Antoniou93bfd612014-03-11 19:34:20 +020060 ret = mmc->cfg->ops->send_cmd(mmc, cmd, data);
Raffaele Recalcati5db2fe32011-03-11 02:01:14 +000061 switch (cmd->resp_type) {
62 case MMC_RSP_NONE:
63 printf("\t\tMMC_RSP_NONE\n");
64 break;
65 case MMC_RSP_R1:
66 printf("\t\tMMC_RSP_R1,5,6,7 \t 0x%08X \n",
67 cmd->response[0]);
68 break;
69 case MMC_RSP_R1b:
70 printf("\t\tMMC_RSP_R1b\t\t 0x%08X \n",
71 cmd->response[0]);
72 break;
73 case MMC_RSP_R2:
74 printf("\t\tMMC_RSP_R2\t\t 0x%08X \n",
75 cmd->response[0]);
76 printf("\t\t \t\t 0x%08X \n",
77 cmd->response[1]);
78 printf("\t\t \t\t 0x%08X \n",
79 cmd->response[2]);
80 printf("\t\t \t\t 0x%08X \n",
81 cmd->response[3]);
82 printf("\n");
83 printf("\t\t\t\t\tDUMPING DATA\n");
84 for (i = 0; i < 4; i++) {
85 int j;
86 printf("\t\t\t\t\t%03d - ", i*4);
Dirk Behme146bec72012-03-08 02:35:34 +000087 ptr = (u8 *)&cmd->response[i];
Raffaele Recalcati5db2fe32011-03-11 02:01:14 +000088 ptr += 3;
89 for (j = 0; j < 4; j++)
90 printf("%02X ", *ptr--);
91 printf("\n");
92 }
93 break;
94 case MMC_RSP_R3:
95 printf("\t\tMMC_RSP_R3,4\t\t 0x%08X \n",
96 cmd->response[0]);
97 break;
98 default:
99 printf("\t\tERROR MMC rsp not supported\n");
100 break;
101 }
Raffaele Recalcati5db2fe32011-03-11 02:01:14 +0000102#else
Pantelis Antoniou93bfd612014-03-11 19:34:20 +0200103 ret = mmc->cfg->ops->send_cmd(mmc, cmd, data);
Raffaele Recalcati5db2fe32011-03-11 02:01:14 +0000104#endif
Marek Vasut8635ff92012-03-15 18:41:35 +0000105 return ret;
Andy Fleming272cc702008-10-30 16:41:01 -0500106}
107
Paul Burtonda61fa52013-09-09 15:30:26 +0100108int mmc_send_status(struct mmc *mmc, int timeout)
Raffaele Recalcati5d4fc8d2011-03-11 02:01:12 +0000109{
110 struct mmc_cmd cmd;
Jan Kloetzked617c422012-02-05 22:29:12 +0000111 int err, retries = 5;
Raffaele Recalcati5d4fc8d2011-03-11 02:01:12 +0000112#ifdef CONFIG_MMC_TRACE
113 int status;
114#endif
115
116 cmd.cmdidx = MMC_CMD_SEND_STATUS;
117 cmd.resp_type = MMC_RSP_R1;
Marek Vasutaaf3d412011-08-10 09:24:48 +0200118 if (!mmc_host_is_spi(mmc))
119 cmd.cmdarg = mmc->rca << 16;
Raffaele Recalcati5d4fc8d2011-03-11 02:01:12 +0000120
121 do {
122 err = mmc_send_cmd(mmc, &cmd, NULL);
Jan Kloetzked617c422012-02-05 22:29:12 +0000123 if (!err) {
124 if ((cmd.response[0] & MMC_STATUS_RDY_FOR_DATA) &&
125 (cmd.response[0] & MMC_STATUS_CURR_STATE) !=
126 MMC_STATE_PRG)
127 break;
128 else if (cmd.response[0] & MMC_STATUS_MASK) {
Paul Burton56196822013-09-04 16:12:25 +0100129#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
Jan Kloetzked617c422012-02-05 22:29:12 +0000130 printf("Status Error: 0x%08X\n",
131 cmd.response[0]);
Paul Burton56196822013-09-04 16:12:25 +0100132#endif
Jan Kloetzked617c422012-02-05 22:29:12 +0000133 return COMM_ERR;
134 }
135 } else if (--retries < 0)
Raffaele Recalcati5d4fc8d2011-03-11 02:01:12 +0000136 return err;
Raffaele Recalcati5d4fc8d2011-03-11 02:01:12 +0000137
138 udelay(1000);
139
Raffaele Recalcati5d4fc8d2011-03-11 02:01:12 +0000140 } while (timeout--);
141
Raffaele Recalcati5db2fe32011-03-11 02:01:14 +0000142#ifdef CONFIG_MMC_TRACE
143 status = (cmd.response[0] & MMC_STATUS_CURR_STATE) >> 9;
144 printf("CURR STATE:%d\n", status);
145#endif
Jongman Heo5b0c9422012-06-03 21:32:13 +0000146 if (timeout <= 0) {
Paul Burton56196822013-09-04 16:12:25 +0100147#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
Raffaele Recalcati5d4fc8d2011-03-11 02:01:12 +0000148 printf("Timeout waiting card ready\n");
Paul Burton56196822013-09-04 16:12:25 +0100149#endif
Raffaele Recalcati5d4fc8d2011-03-11 02:01:12 +0000150 return TIMEOUT;
151 }
Andrew Gabbasov6b2221b2014-04-03 04:34:32 -0500152 if (cmd.response[0] & MMC_STATUS_SWITCH_ERROR)
153 return SWITCH_ERR;
Raffaele Recalcati5d4fc8d2011-03-11 02:01:12 +0000154
155 return 0;
156}
157
Paul Burtonda61fa52013-09-09 15:30:26 +0100158int mmc_set_blocklen(struct mmc *mmc, int len)
Andy Fleming272cc702008-10-30 16:41:01 -0500159{
160 struct mmc_cmd cmd;
161
Andrew Gabbasov786e8f82014-12-01 06:59:09 -0600162 if (mmc->ddr_mode)
Jaehoon Chungd22e3d42014-05-16 13:59:54 +0900163 return 0;
164
Andy Fleming272cc702008-10-30 16:41:01 -0500165 cmd.cmdidx = MMC_CMD_SET_BLOCKLEN;
166 cmd.resp_type = MMC_RSP_R1;
167 cmd.cmdarg = len;
Andy Fleming272cc702008-10-30 16:41:01 -0500168
169 return mmc_send_cmd(mmc, &cmd, NULL);
170}
171
172struct mmc *find_mmc_device(int dev_num)
173{
174 struct mmc *m;
175 struct list_head *entry;
176
177 list_for_each(entry, &mmc_devices) {
178 m = list_entry(entry, struct mmc, link);
179
180 if (m->block_dev.dev == dev_num)
181 return m;
182 }
183
Paul Burton56196822013-09-04 16:12:25 +0100184#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
Andy Fleming272cc702008-10-30 16:41:01 -0500185 printf("MMC Device %d not found\n", dev_num);
Paul Burton56196822013-09-04 16:12:25 +0100186#endif
Andy Fleming272cc702008-10-30 16:41:01 -0500187
188 return NULL;
189}
190
Sascha Silbeff8fef52013-06-14 13:07:25 +0200191static int mmc_read_blocks(struct mmc *mmc, void *dst, lbaint_t start,
Kim Phillipsfdbb8732012-10-29 13:34:43 +0000192 lbaint_t blkcnt)
Andy Fleming272cc702008-10-30 16:41:01 -0500193{
194 struct mmc_cmd cmd;
195 struct mmc_data data;
196
Alagu Sankar4a1a06b2010-10-25 07:23:56 -0700197 if (blkcnt > 1)
198 cmd.cmdidx = MMC_CMD_READ_MULTIPLE_BLOCK;
199 else
200 cmd.cmdidx = MMC_CMD_READ_SINGLE_BLOCK;
Andy Fleming272cc702008-10-30 16:41:01 -0500201
202 if (mmc->high_capacity)
Alagu Sankar4a1a06b2010-10-25 07:23:56 -0700203 cmd.cmdarg = start;
Andy Fleming272cc702008-10-30 16:41:01 -0500204 else
Alagu Sankar4a1a06b2010-10-25 07:23:56 -0700205 cmd.cmdarg = start * mmc->read_bl_len;
Andy Fleming272cc702008-10-30 16:41:01 -0500206
207 cmd.resp_type = MMC_RSP_R1;
Andy Fleming272cc702008-10-30 16:41:01 -0500208
209 data.dest = dst;
Alagu Sankar4a1a06b2010-10-25 07:23:56 -0700210 data.blocks = blkcnt;
Andy Fleming272cc702008-10-30 16:41:01 -0500211 data.blocksize = mmc->read_bl_len;
212 data.flags = MMC_DATA_READ;
213
Alagu Sankar4a1a06b2010-10-25 07:23:56 -0700214 if (mmc_send_cmd(mmc, &cmd, &data))
215 return 0;
Andy Fleming272cc702008-10-30 16:41:01 -0500216
Alagu Sankar4a1a06b2010-10-25 07:23:56 -0700217 if (blkcnt > 1) {
218 cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION;
219 cmd.cmdarg = 0;
220 cmd.resp_type = MMC_RSP_R1b;
Alagu Sankar4a1a06b2010-10-25 07:23:56 -0700221 if (mmc_send_cmd(mmc, &cmd, NULL)) {
Paul Burton56196822013-09-04 16:12:25 +0100222#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
Alagu Sankar4a1a06b2010-10-25 07:23:56 -0700223 printf("mmc fail to send stop cmd\n");
Paul Burton56196822013-09-04 16:12:25 +0100224#endif
Alagu Sankar4a1a06b2010-10-25 07:23:56 -0700225 return 0;
226 }
Andy Fleming272cc702008-10-30 16:41:01 -0500227 }
228
Alagu Sankar4a1a06b2010-10-25 07:23:56 -0700229 return blkcnt;
Andy Fleming272cc702008-10-30 16:41:01 -0500230}
231
Sascha Silbeff8fef52013-06-14 13:07:25 +0200232static ulong mmc_bread(int dev_num, lbaint_t start, lbaint_t blkcnt, void *dst)
Andy Fleming272cc702008-10-30 16:41:01 -0500233{
Alagu Sankar4a1a06b2010-10-25 07:23:56 -0700234 lbaint_t cur, blocks_todo = blkcnt;
Andy Fleming272cc702008-10-30 16:41:01 -0500235
Alagu Sankar4a1a06b2010-10-25 07:23:56 -0700236 if (blkcnt == 0)
237 return 0;
238
239 struct mmc *mmc = find_mmc_device(dev_num);
Andy Fleming272cc702008-10-30 16:41:01 -0500240 if (!mmc)
241 return 0;
242
Lei Wend2bf29e2010-09-13 22:07:27 +0800243 if ((start + blkcnt) > mmc->block_dev.lba) {
Paul Burton56196822013-09-04 16:12:25 +0100244#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
Sascha Silbeff8fef52013-06-14 13:07:25 +0200245 printf("MMC: block number 0x" LBAF " exceeds max(0x" LBAF ")\n",
Lei Wend2bf29e2010-09-13 22:07:27 +0800246 start + blkcnt, mmc->block_dev.lba);
Paul Burton56196822013-09-04 16:12:25 +0100247#endif
Lei Wend2bf29e2010-09-13 22:07:27 +0800248 return 0;
249 }
Andy Fleming272cc702008-10-30 16:41:01 -0500250
Alagu Sankar4a1a06b2010-10-25 07:23:56 -0700251 if (mmc_set_blocklen(mmc, mmc->read_bl_len))
Andy Fleming272cc702008-10-30 16:41:01 -0500252 return 0;
Andy Fleming272cc702008-10-30 16:41:01 -0500253
Alagu Sankar4a1a06b2010-10-25 07:23:56 -0700254 do {
Pantelis Antoniou93bfd612014-03-11 19:34:20 +0200255 cur = (blocks_todo > mmc->cfg->b_max) ?
256 mmc->cfg->b_max : blocks_todo;
Alagu Sankar4a1a06b2010-10-25 07:23:56 -0700257 if(mmc_read_blocks(mmc, dst, start, cur) != cur)
258 return 0;
259 blocks_todo -= cur;
260 start += cur;
261 dst += cur * mmc->read_bl_len;
262 } while (blocks_todo > 0);
Andy Fleming272cc702008-10-30 16:41:01 -0500263
264 return blkcnt;
265}
266
Kim Phillipsfdbb8732012-10-29 13:34:43 +0000267static int mmc_go_idle(struct mmc *mmc)
Andy Fleming272cc702008-10-30 16:41:01 -0500268{
269 struct mmc_cmd cmd;
270 int err;
271
272 udelay(1000);
273
274 cmd.cmdidx = MMC_CMD_GO_IDLE_STATE;
275 cmd.cmdarg = 0;
276 cmd.resp_type = MMC_RSP_NONE;
Andy Fleming272cc702008-10-30 16:41:01 -0500277
278 err = mmc_send_cmd(mmc, &cmd, NULL);
279
280 if (err)
281 return err;
282
283 udelay(2000);
284
285 return 0;
286}
287
Kim Phillipsfdbb8732012-10-29 13:34:43 +0000288static int sd_send_op_cond(struct mmc *mmc)
Andy Fleming272cc702008-10-30 16:41:01 -0500289{
290 int timeout = 1000;
291 int err;
292 struct mmc_cmd cmd;
293
294 do {
295 cmd.cmdidx = MMC_CMD_APP_CMD;
296 cmd.resp_type = MMC_RSP_R1;
297 cmd.cmdarg = 0;
Andy Fleming272cc702008-10-30 16:41:01 -0500298
299 err = mmc_send_cmd(mmc, &cmd, NULL);
300
301 if (err)
302 return err;
303
304 cmd.cmdidx = SD_CMD_APP_SEND_OP_COND;
305 cmd.resp_type = MMC_RSP_R3;
Stefano Babic250de122010-01-20 18:20:39 +0100306
307 /*
308 * Most cards do not answer if some reserved bits
309 * in the ocr are set. However, Some controller
310 * can set bit 7 (reserved for low voltages), but
311 * how to manage low voltages SD card is not yet
312 * specified.
313 */
Thomas Choud52ebf12010-12-24 13:12:21 +0000314 cmd.cmdarg = mmc_host_is_spi(mmc) ? 0 :
Pantelis Antoniou93bfd612014-03-11 19:34:20 +0200315 (mmc->cfg->voltages & 0xff8000);
Andy Fleming272cc702008-10-30 16:41:01 -0500316
317 if (mmc->version == SD_VERSION_2)
318 cmd.cmdarg |= OCR_HCS;
319
320 err = mmc_send_cmd(mmc, &cmd, NULL);
321
322 if (err)
323 return err;
324
325 udelay(1000);
326 } while ((!(cmd.response[0] & OCR_BUSY)) && timeout--);
327
328 if (timeout <= 0)
329 return UNUSABLE_ERR;
330
331 if (mmc->version != SD_VERSION_2)
332 mmc->version = SD_VERSION_1_0;
333
Thomas Choud52ebf12010-12-24 13:12:21 +0000334 if (mmc_host_is_spi(mmc)) { /* read OCR for spi */
335 cmd.cmdidx = MMC_CMD_SPI_READ_OCR;
336 cmd.resp_type = MMC_RSP_R3;
337 cmd.cmdarg = 0;
Thomas Choud52ebf12010-12-24 13:12:21 +0000338
339 err = mmc_send_cmd(mmc, &cmd, NULL);
340
341 if (err)
342 return err;
343 }
344
Rabin Vincent998be3d2009-04-05 13:30:56 +0530345 mmc->ocr = cmd.response[0];
Andy Fleming272cc702008-10-30 16:41:01 -0500346
347 mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
348 mmc->rca = 0;
349
350 return 0;
351}
352
Che-Liang Chioue9550442012-11-28 15:21:13 +0000353/* We pass in the cmd since otherwise the init seems to fail */
354static int mmc_send_op_cond_iter(struct mmc *mmc, struct mmc_cmd *cmd,
355 int use_arg)
Andy Fleming272cc702008-10-30 16:41:01 -0500356{
Andy Fleming272cc702008-10-30 16:41:01 -0500357 int err;
358
Che-Liang Chioue9550442012-11-28 15:21:13 +0000359 cmd->cmdidx = MMC_CMD_SEND_OP_COND;
360 cmd->resp_type = MMC_RSP_R3;
361 cmd->cmdarg = 0;
362 if (use_arg && !mmc_host_is_spi(mmc)) {
363 cmd->cmdarg =
Pantelis Antoniou93bfd612014-03-11 19:34:20 +0200364 (mmc->cfg->voltages &
Che-Liang Chioue9550442012-11-28 15:21:13 +0000365 (mmc->op_cond_response & OCR_VOLTAGE_MASK)) |
366 (mmc->op_cond_response & OCR_ACCESS_MODE);
367
Pantelis Antoniou93bfd612014-03-11 19:34:20 +0200368 if (mmc->cfg->host_caps & MMC_MODE_HC)
Che-Liang Chioue9550442012-11-28 15:21:13 +0000369 cmd->cmdarg |= OCR_HCS;
370 }
371 err = mmc_send_cmd(mmc, cmd, NULL);
372 if (err)
373 return err;
374 mmc->op_cond_response = cmd->response[0];
375 return 0;
376}
377
Jeroen Hofstee750121c2014-07-12 21:24:08 +0200378static int mmc_send_op_cond(struct mmc *mmc)
Che-Liang Chioue9550442012-11-28 15:21:13 +0000379{
380 struct mmc_cmd cmd;
381 int err, i;
382
Andy Fleming272cc702008-10-30 16:41:01 -0500383 /* Some cards seem to need this */
384 mmc_go_idle(mmc);
385
Raffaele Recalcati31cacba2011-03-11 02:01:13 +0000386 /* Asking to the card its capabilities */
Che-Liang Chioue9550442012-11-28 15:21:13 +0000387 mmc->op_cond_pending = 1;
388 for (i = 0; i < 2; i++) {
389 err = mmc_send_op_cond_iter(mmc, &cmd, i != 0);
Andy Fleming272cc702008-10-30 16:41:01 -0500390 if (err)
391 return err;
392
Che-Liang Chioue9550442012-11-28 15:21:13 +0000393 /* exit if not busy (flag seems to be inverted) */
394 if (mmc->op_cond_response & OCR_BUSY)
395 return 0;
396 }
397 return IN_PROGRESS;
398}
Andy Fleming272cc702008-10-30 16:41:01 -0500399
Jeroen Hofstee750121c2014-07-12 21:24:08 +0200400static int mmc_complete_op_cond(struct mmc *mmc)
Che-Liang Chioue9550442012-11-28 15:21:13 +0000401{
402 struct mmc_cmd cmd;
403 int timeout = 1000;
404 uint start;
405 int err;
406
407 mmc->op_cond_pending = 0;
408 start = get_timer(0);
409 do {
410 err = mmc_send_op_cond_iter(mmc, &cmd, 1);
411 if (err)
412 return err;
413 if (get_timer(start) > timeout)
414 return UNUSABLE_ERR;
415 udelay(100);
416 } while (!(mmc->op_cond_response & OCR_BUSY));
Andy Fleming272cc702008-10-30 16:41:01 -0500417
Thomas Choud52ebf12010-12-24 13:12:21 +0000418 if (mmc_host_is_spi(mmc)) { /* read OCR for spi */
419 cmd.cmdidx = MMC_CMD_SPI_READ_OCR;
420 cmd.resp_type = MMC_RSP_R3;
421 cmd.cmdarg = 0;
Thomas Choud52ebf12010-12-24 13:12:21 +0000422
423 err = mmc_send_cmd(mmc, &cmd, NULL);
424
425 if (err)
426 return err;
427 }
428
Andy Fleming272cc702008-10-30 16:41:01 -0500429 mmc->version = MMC_VERSION_UNKNOWN;
Rabin Vincent998be3d2009-04-05 13:30:56 +0530430 mmc->ocr = cmd.response[0];
Andy Fleming272cc702008-10-30 16:41:01 -0500431
432 mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
Stephen Warrendef816a2014-01-30 16:11:12 -0700433 mmc->rca = 1;
Andy Fleming272cc702008-10-30 16:41:01 -0500434
435 return 0;
436}
437
438
Kim Phillipsfdbb8732012-10-29 13:34:43 +0000439static int mmc_send_ext_csd(struct mmc *mmc, u8 *ext_csd)
Andy Fleming272cc702008-10-30 16:41:01 -0500440{
441 struct mmc_cmd cmd;
442 struct mmc_data data;
443 int err;
444
445 /* Get the Card Status Register */
446 cmd.cmdidx = MMC_CMD_SEND_EXT_CSD;
447 cmd.resp_type = MMC_RSP_R1;
448 cmd.cmdarg = 0;
Andy Fleming272cc702008-10-30 16:41:01 -0500449
Yoshihiro Shimodacdfd1ac2012-06-07 19:09:11 +0000450 data.dest = (char *)ext_csd;
Andy Fleming272cc702008-10-30 16:41:01 -0500451 data.blocks = 1;
Simon Glass8bfa1952013-04-03 08:54:30 +0000452 data.blocksize = MMC_MAX_BLOCK_LEN;
Andy Fleming272cc702008-10-30 16:41:01 -0500453 data.flags = MMC_DATA_READ;
454
455 err = mmc_send_cmd(mmc, &cmd, &data);
456
457 return err;
458}
459
460
Kim Phillipsfdbb8732012-10-29 13:34:43 +0000461static int mmc_switch(struct mmc *mmc, u8 set, u8 index, u8 value)
Andy Fleming272cc702008-10-30 16:41:01 -0500462{
463 struct mmc_cmd cmd;
Raffaele Recalcati5d4fc8d2011-03-11 02:01:12 +0000464 int timeout = 1000;
465 int ret;
Andy Fleming272cc702008-10-30 16:41:01 -0500466
467 cmd.cmdidx = MMC_CMD_SWITCH;
468 cmd.resp_type = MMC_RSP_R1b;
469 cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
Raffaele Recalcati5d4fc8d2011-03-11 02:01:12 +0000470 (index << 16) |
471 (value << 8);
Andy Fleming272cc702008-10-30 16:41:01 -0500472
Raffaele Recalcati5d4fc8d2011-03-11 02:01:12 +0000473 ret = mmc_send_cmd(mmc, &cmd, NULL);
474
475 /* Waiting for the ready status */
Jan Kloetzke93ad0d12012-02-05 22:29:11 +0000476 if (!ret)
477 ret = mmc_send_status(mmc, timeout);
Raffaele Recalcati5d4fc8d2011-03-11 02:01:12 +0000478
479 return ret;
480
Andy Fleming272cc702008-10-30 16:41:01 -0500481}
482
Kim Phillipsfdbb8732012-10-29 13:34:43 +0000483static int mmc_change_freq(struct mmc *mmc)
Andy Fleming272cc702008-10-30 16:41:01 -0500484{
Simon Glass8bfa1952013-04-03 08:54:30 +0000485 ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN);
Andy Fleming272cc702008-10-30 16:41:01 -0500486 char cardtype;
487 int err;
488
Andrew Gabbasov786e8f82014-12-01 06:59:09 -0600489 mmc->card_caps = MMC_MODE_4BIT | MMC_MODE_8BIT;
Andy Fleming272cc702008-10-30 16:41:01 -0500490
Thomas Choud52ebf12010-12-24 13:12:21 +0000491 if (mmc_host_is_spi(mmc))
492 return 0;
493
Andy Fleming272cc702008-10-30 16:41:01 -0500494 /* Only version 4 supports high-speed */
495 if (mmc->version < MMC_VERSION_4)
496 return 0;
497
Andy Fleming272cc702008-10-30 16:41:01 -0500498 err = mmc_send_ext_csd(mmc, ext_csd);
499
500 if (err)
501 return err;
502
Lei Wen0560db12011-10-03 20:35:10 +0000503 cardtype = ext_csd[EXT_CSD_CARD_TYPE] & 0xf;
Andy Fleming272cc702008-10-30 16:41:01 -0500504
505 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, 1);
506
507 if (err)
Andrew Gabbasov6b2221b2014-04-03 04:34:32 -0500508 return err == SWITCH_ERR ? 0 : err;
Andy Fleming272cc702008-10-30 16:41:01 -0500509
510 /* Now check to see that it worked */
511 err = mmc_send_ext_csd(mmc, ext_csd);
512
513 if (err)
514 return err;
515
516 /* No high-speed support */
Lei Wen0560db12011-10-03 20:35:10 +0000517 if (!ext_csd[EXT_CSD_HS_TIMING])
Andy Fleming272cc702008-10-30 16:41:01 -0500518 return 0;
519
520 /* High Speed is set, there are two types: 52MHz and 26MHz */
Jaehoon Chungd22e3d42014-05-16 13:59:54 +0900521 if (cardtype & EXT_CSD_CARD_TYPE_52) {
Andrew Gabbasov201d5ac2014-12-01 06:59:10 -0600522 if (cardtype & EXT_CSD_CARD_TYPE_DDR_1_8V)
Jaehoon Chungd22e3d42014-05-16 13:59:54 +0900523 mmc->card_caps |= MMC_MODE_DDR_52MHz;
Andy Fleming272cc702008-10-30 16:41:01 -0500524 mmc->card_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS;
Jaehoon Chungd22e3d42014-05-16 13:59:54 +0900525 } else {
Andy Fleming272cc702008-10-30 16:41:01 -0500526 mmc->card_caps |= MMC_MODE_HS;
Jaehoon Chungd22e3d42014-05-16 13:59:54 +0900527 }
Andy Fleming272cc702008-10-30 16:41:01 -0500528
529 return 0;
530}
531
Stephen Warrenf866a462013-06-11 15:14:01 -0600532static int mmc_set_capacity(struct mmc *mmc, int part_num)
533{
534 switch (part_num) {
535 case 0:
536 mmc->capacity = mmc->capacity_user;
537 break;
538 case 1:
539 case 2:
540 mmc->capacity = mmc->capacity_boot;
541 break;
542 case 3:
543 mmc->capacity = mmc->capacity_rpmb;
544 break;
545 case 4:
546 case 5:
547 case 6:
548 case 7:
549 mmc->capacity = mmc->capacity_gp[part_num - 4];
550 break;
551 default:
552 return -1;
553 }
554
555 mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len);
556
557 return 0;
558}
559
Stephen Warrend2356282014-05-07 12:19:02 -0600560int mmc_select_hwpart(int dev_num, int hwpart)
561{
562 struct mmc *mmc = find_mmc_device(dev_num);
563 int ret;
564
565 if (!mmc)
Stephen Warrend4622df2014-05-23 12:47:06 -0600566 return -ENODEV;
Stephen Warrend2356282014-05-07 12:19:02 -0600567
568 if (mmc->part_num == hwpart)
569 return 0;
570
571 if (mmc->part_config == MMCPART_NOAVAILABLE) {
572 printf("Card doesn't support part_switch\n");
Stephen Warrend4622df2014-05-23 12:47:06 -0600573 return -EMEDIUMTYPE;
Stephen Warrend2356282014-05-07 12:19:02 -0600574 }
575
576 ret = mmc_switch_part(dev_num, hwpart);
577 if (ret)
Stephen Warrend4622df2014-05-23 12:47:06 -0600578 return ret;
Stephen Warrend2356282014-05-07 12:19:02 -0600579
580 mmc->part_num = hwpart;
581
582 return 0;
583}
584
585
Lei Wenbc897b12011-05-02 16:26:26 +0000586int mmc_switch_part(int dev_num, unsigned int part_num)
587{
588 struct mmc *mmc = find_mmc_device(dev_num);
Stephen Warrenf866a462013-06-11 15:14:01 -0600589 int ret;
Lei Wenbc897b12011-05-02 16:26:26 +0000590
591 if (!mmc)
592 return -1;
593
Stephen Warrenf866a462013-06-11 15:14:01 -0600594 ret = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONF,
595 (mmc->part_config & ~PART_ACCESS_MASK)
596 | (part_num & PART_ACCESS_MASK));
Stephen Warrenf866a462013-06-11 15:14:01 -0600597
Peter Bigot6dc93e72014-09-02 18:31:23 -0500598 /*
599 * Set the capacity if the switch succeeded or was intended
600 * to return to representing the raw device.
601 */
602 if ((ret == 0) || ((ret == -ENODEV) && (part_num == 0)))
603 ret = mmc_set_capacity(mmc, part_num);
604
605 return ret;
Lei Wenbc897b12011-05-02 16:26:26 +0000606}
607
Thierry Reding48972d92012-01-02 01:15:37 +0000608int mmc_getcd(struct mmc *mmc)
609{
610 int cd;
611
612 cd = board_mmc_getcd(mmc);
613
Peter Korsgaardd4e1da42013-03-21 04:00:03 +0000614 if (cd < 0) {
Pantelis Antoniou93bfd612014-03-11 19:34:20 +0200615 if (mmc->cfg->ops->getcd)
616 cd = mmc->cfg->ops->getcd(mmc);
Peter Korsgaardd4e1da42013-03-21 04:00:03 +0000617 else
618 cd = 1;
619 }
Thierry Reding48972d92012-01-02 01:15:37 +0000620
621 return cd;
622}
623
Kim Phillipsfdbb8732012-10-29 13:34:43 +0000624static int sd_switch(struct mmc *mmc, int mode, int group, u8 value, u8 *resp)
Andy Fleming272cc702008-10-30 16:41:01 -0500625{
626 struct mmc_cmd cmd;
627 struct mmc_data data;
628
629 /* Switch the frequency */
630 cmd.cmdidx = SD_CMD_SWITCH_FUNC;
631 cmd.resp_type = MMC_RSP_R1;
632 cmd.cmdarg = (mode << 31) | 0xffffff;
633 cmd.cmdarg &= ~(0xf << (group * 4));
634 cmd.cmdarg |= value << (group * 4);
Andy Fleming272cc702008-10-30 16:41:01 -0500635
636 data.dest = (char *)resp;
637 data.blocksize = 64;
638 data.blocks = 1;
639 data.flags = MMC_DATA_READ;
640
641 return mmc_send_cmd(mmc, &cmd, &data);
642}
643
644
Kim Phillipsfdbb8732012-10-29 13:34:43 +0000645static int sd_change_freq(struct mmc *mmc)
Andy Fleming272cc702008-10-30 16:41:01 -0500646{
647 int err;
648 struct mmc_cmd cmd;
Anton staaff781dd32011-10-03 13:54:59 +0000649 ALLOC_CACHE_ALIGN_BUFFER(uint, scr, 2);
650 ALLOC_CACHE_ALIGN_BUFFER(uint, switch_status, 16);
Andy Fleming272cc702008-10-30 16:41:01 -0500651 struct mmc_data data;
652 int timeout;
653
654 mmc->card_caps = 0;
655
Thomas Choud52ebf12010-12-24 13:12:21 +0000656 if (mmc_host_is_spi(mmc))
657 return 0;
658
Andy Fleming272cc702008-10-30 16:41:01 -0500659 /* Read the SCR to find out if this card supports higher speeds */
660 cmd.cmdidx = MMC_CMD_APP_CMD;
661 cmd.resp_type = MMC_RSP_R1;
662 cmd.cmdarg = mmc->rca << 16;
Andy Fleming272cc702008-10-30 16:41:01 -0500663
664 err = mmc_send_cmd(mmc, &cmd, NULL);
665
666 if (err)
667 return err;
668
669 cmd.cmdidx = SD_CMD_APP_SEND_SCR;
670 cmd.resp_type = MMC_RSP_R1;
671 cmd.cmdarg = 0;
Andy Fleming272cc702008-10-30 16:41:01 -0500672
673 timeout = 3;
674
675retry_scr:
Anton staaff781dd32011-10-03 13:54:59 +0000676 data.dest = (char *)scr;
Andy Fleming272cc702008-10-30 16:41:01 -0500677 data.blocksize = 8;
678 data.blocks = 1;
679 data.flags = MMC_DATA_READ;
680
681 err = mmc_send_cmd(mmc, &cmd, &data);
682
683 if (err) {
684 if (timeout--)
685 goto retry_scr;
686
687 return err;
688 }
689
Yauhen Kharuzhy4e3d89b2009-05-07 00:43:30 +0300690 mmc->scr[0] = __be32_to_cpu(scr[0]);
691 mmc->scr[1] = __be32_to_cpu(scr[1]);
Andy Fleming272cc702008-10-30 16:41:01 -0500692
693 switch ((mmc->scr[0] >> 24) & 0xf) {
694 case 0:
695 mmc->version = SD_VERSION_1_0;
696 break;
697 case 1:
698 mmc->version = SD_VERSION_1_10;
699 break;
700 case 2:
701 mmc->version = SD_VERSION_2;
Jaehoon Chung1741c642013-01-29 22:58:16 +0000702 if ((mmc->scr[0] >> 15) & 0x1)
703 mmc->version = SD_VERSION_3;
Andy Fleming272cc702008-10-30 16:41:01 -0500704 break;
705 default:
706 mmc->version = SD_VERSION_1_0;
707 break;
708 }
709
Alagu Sankarb44c7082010-05-12 15:08:24 +0530710 if (mmc->scr[0] & SD_DATA_4BIT)
711 mmc->card_caps |= MMC_MODE_4BIT;
712
Andy Fleming272cc702008-10-30 16:41:01 -0500713 /* Version 1.0 doesn't support switching */
714 if (mmc->version == SD_VERSION_1_0)
715 return 0;
716
717 timeout = 4;
718 while (timeout--) {
719 err = sd_switch(mmc, SD_SWITCH_CHECK, 0, 1,
Anton staaff781dd32011-10-03 13:54:59 +0000720 (u8 *)switch_status);
Andy Fleming272cc702008-10-30 16:41:01 -0500721
722 if (err)
723 return err;
724
725 /* The high-speed function is busy. Try again */
Yauhen Kharuzhy4e3d89b2009-05-07 00:43:30 +0300726 if (!(__be32_to_cpu(switch_status[7]) & SD_HIGHSPEED_BUSY))
Andy Fleming272cc702008-10-30 16:41:01 -0500727 break;
728 }
729
Andy Fleming272cc702008-10-30 16:41:01 -0500730 /* If high-speed isn't supported, we return */
Yauhen Kharuzhy4e3d89b2009-05-07 00:43:30 +0300731 if (!(__be32_to_cpu(switch_status[3]) & SD_HIGHSPEED_SUPPORTED))
Andy Fleming272cc702008-10-30 16:41:01 -0500732 return 0;
733
Macpaul Lin2c3fbf42011-11-28 16:31:09 +0000734 /*
735 * If the host doesn't support SD_HIGHSPEED, do not switch card to
736 * HIGHSPEED mode even if the card support SD_HIGHSPPED.
737 * This can avoid furthur problem when the card runs in different
738 * mode between the host.
739 */
Pantelis Antoniou93bfd612014-03-11 19:34:20 +0200740 if (!((mmc->cfg->host_caps & MMC_MODE_HS_52MHz) &&
741 (mmc->cfg->host_caps & MMC_MODE_HS)))
Macpaul Lin2c3fbf42011-11-28 16:31:09 +0000742 return 0;
743
Anton staaff781dd32011-10-03 13:54:59 +0000744 err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (u8 *)switch_status);
Andy Fleming272cc702008-10-30 16:41:01 -0500745
746 if (err)
747 return err;
748
Yauhen Kharuzhy4e3d89b2009-05-07 00:43:30 +0300749 if ((__be32_to_cpu(switch_status[4]) & 0x0f000000) == 0x01000000)
Andy Fleming272cc702008-10-30 16:41:01 -0500750 mmc->card_caps |= MMC_MODE_HS;
751
752 return 0;
753}
754
755/* frequency bases */
756/* divided by 10 to be nice to platforms without floating point */
Mike Frysinger5f837c22010-10-20 01:15:53 +0000757static const int fbase[] = {
Andy Fleming272cc702008-10-30 16:41:01 -0500758 10000,
759 100000,
760 1000000,
761 10000000,
762};
763
764/* Multiplier values for TRAN_SPEED. Multiplied by 10 to be nice
765 * to platforms without floating point.
766 */
Mike Frysinger5f837c22010-10-20 01:15:53 +0000767static const int multipliers[] = {
Andy Fleming272cc702008-10-30 16:41:01 -0500768 0, /* reserved */
769 10,
770 12,
771 13,
772 15,
773 20,
774 25,
775 30,
776 35,
777 40,
778 45,
779 50,
780 55,
781 60,
782 70,
783 80,
784};
785
Kim Phillipsfdbb8732012-10-29 13:34:43 +0000786static void mmc_set_ios(struct mmc *mmc)
Andy Fleming272cc702008-10-30 16:41:01 -0500787{
Pantelis Antoniou93bfd612014-03-11 19:34:20 +0200788 if (mmc->cfg->ops->set_ios)
789 mmc->cfg->ops->set_ios(mmc);
Andy Fleming272cc702008-10-30 16:41:01 -0500790}
791
792void mmc_set_clock(struct mmc *mmc, uint clock)
793{
Pantelis Antoniou93bfd612014-03-11 19:34:20 +0200794 if (clock > mmc->cfg->f_max)
795 clock = mmc->cfg->f_max;
Andy Fleming272cc702008-10-30 16:41:01 -0500796
Pantelis Antoniou93bfd612014-03-11 19:34:20 +0200797 if (clock < mmc->cfg->f_min)
798 clock = mmc->cfg->f_min;
Andy Fleming272cc702008-10-30 16:41:01 -0500799
800 mmc->clock = clock;
801
802 mmc_set_ios(mmc);
803}
804
Kim Phillipsfdbb8732012-10-29 13:34:43 +0000805static void mmc_set_bus_width(struct mmc *mmc, uint width)
Andy Fleming272cc702008-10-30 16:41:01 -0500806{
807 mmc->bus_width = width;
808
809 mmc_set_ios(mmc);
810}
811
Kim Phillipsfdbb8732012-10-29 13:34:43 +0000812static int mmc_startup(struct mmc *mmc)
Andy Fleming272cc702008-10-30 16:41:01 -0500813{
Stephen Warrenf866a462013-06-11 15:14:01 -0600814 int err, i;
Andy Fleming272cc702008-10-30 16:41:01 -0500815 uint mult, freq;
Yoshihiro Shimoda639b7822011-07-04 22:13:26 +0000816 u64 cmult, csize, capacity;
Andy Fleming272cc702008-10-30 16:41:01 -0500817 struct mmc_cmd cmd;
Simon Glass8bfa1952013-04-03 08:54:30 +0000818 ALLOC_CACHE_ALIGN_BUFFER(u8, ext_csd, MMC_MAX_BLOCK_LEN);
819 ALLOC_CACHE_ALIGN_BUFFER(u8, test_csd, MMC_MAX_BLOCK_LEN);
Raffaele Recalcati5d4fc8d2011-03-11 02:01:12 +0000820 int timeout = 1000;
Andy Fleming272cc702008-10-30 16:41:01 -0500821
Thomas Choud52ebf12010-12-24 13:12:21 +0000822#ifdef CONFIG_MMC_SPI_CRC_ON
823 if (mmc_host_is_spi(mmc)) { /* enable CRC check for spi */
824 cmd.cmdidx = MMC_CMD_SPI_CRC_ON_OFF;
825 cmd.resp_type = MMC_RSP_R1;
826 cmd.cmdarg = 1;
Thomas Choud52ebf12010-12-24 13:12:21 +0000827 err = mmc_send_cmd(mmc, &cmd, NULL);
828
829 if (err)
830 return err;
831 }
832#endif
833
Andy Fleming272cc702008-10-30 16:41:01 -0500834 /* Put the Card in Identify Mode */
Thomas Choud52ebf12010-12-24 13:12:21 +0000835 cmd.cmdidx = mmc_host_is_spi(mmc) ? MMC_CMD_SEND_CID :
836 MMC_CMD_ALL_SEND_CID; /* cmd not supported in spi */
Andy Fleming272cc702008-10-30 16:41:01 -0500837 cmd.resp_type = MMC_RSP_R2;
838 cmd.cmdarg = 0;
Andy Fleming272cc702008-10-30 16:41:01 -0500839
840 err = mmc_send_cmd(mmc, &cmd, NULL);
841
842 if (err)
843 return err;
844
845 memcpy(mmc->cid, cmd.response, 16);
846
847 /*
848 * For MMC cards, set the Relative Address.
849 * For SD cards, get the Relatvie Address.
850 * This also puts the cards into Standby State
851 */
Thomas Choud52ebf12010-12-24 13:12:21 +0000852 if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */
853 cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR;
854 cmd.cmdarg = mmc->rca << 16;
855 cmd.resp_type = MMC_RSP_R6;
Andy Fleming272cc702008-10-30 16:41:01 -0500856
Thomas Choud52ebf12010-12-24 13:12:21 +0000857 err = mmc_send_cmd(mmc, &cmd, NULL);
Andy Fleming272cc702008-10-30 16:41:01 -0500858
Thomas Choud52ebf12010-12-24 13:12:21 +0000859 if (err)
860 return err;
Andy Fleming272cc702008-10-30 16:41:01 -0500861
Thomas Choud52ebf12010-12-24 13:12:21 +0000862 if (IS_SD(mmc))
863 mmc->rca = (cmd.response[0] >> 16) & 0xffff;
864 }
Andy Fleming272cc702008-10-30 16:41:01 -0500865
866 /* Get the Card-Specific Data */
867 cmd.cmdidx = MMC_CMD_SEND_CSD;
868 cmd.resp_type = MMC_RSP_R2;
869 cmd.cmdarg = mmc->rca << 16;
Andy Fleming272cc702008-10-30 16:41:01 -0500870
871 err = mmc_send_cmd(mmc, &cmd, NULL);
872
Raffaele Recalcati5d4fc8d2011-03-11 02:01:12 +0000873 /* Waiting for the ready status */
874 mmc_send_status(mmc, timeout);
875
Andy Fleming272cc702008-10-30 16:41:01 -0500876 if (err)
877 return err;
878
Rabin Vincent998be3d2009-04-05 13:30:56 +0530879 mmc->csd[0] = cmd.response[0];
880 mmc->csd[1] = cmd.response[1];
881 mmc->csd[2] = cmd.response[2];
882 mmc->csd[3] = cmd.response[3];
Andy Fleming272cc702008-10-30 16:41:01 -0500883
884 if (mmc->version == MMC_VERSION_UNKNOWN) {
Rabin Vincent0b453ff2009-04-05 13:30:55 +0530885 int version = (cmd.response[0] >> 26) & 0xf;
Andy Fleming272cc702008-10-30 16:41:01 -0500886
887 switch (version) {
888 case 0:
889 mmc->version = MMC_VERSION_1_2;
890 break;
891 case 1:
892 mmc->version = MMC_VERSION_1_4;
893 break;
894 case 2:
895 mmc->version = MMC_VERSION_2_2;
896 break;
897 case 3:
898 mmc->version = MMC_VERSION_3;
899 break;
900 case 4:
901 mmc->version = MMC_VERSION_4;
902 break;
903 default:
904 mmc->version = MMC_VERSION_1_2;
905 break;
906 }
907 }
908
909 /* divide frequency by 10, since the mults are 10x bigger */
Rabin Vincent0b453ff2009-04-05 13:30:55 +0530910 freq = fbase[(cmd.response[0] & 0x7)];
911 mult = multipliers[((cmd.response[0] >> 3) & 0xf)];
Andy Fleming272cc702008-10-30 16:41:01 -0500912
913 mmc->tran_speed = freq * mult;
914
Markus Niebelab711882013-12-16 13:40:46 +0100915 mmc->dsr_imp = ((cmd.response[1] >> 12) & 0x1);
Rabin Vincent998be3d2009-04-05 13:30:56 +0530916 mmc->read_bl_len = 1 << ((cmd.response[1] >> 16) & 0xf);
Andy Fleming272cc702008-10-30 16:41:01 -0500917
918 if (IS_SD(mmc))
919 mmc->write_bl_len = mmc->read_bl_len;
920 else
Rabin Vincent998be3d2009-04-05 13:30:56 +0530921 mmc->write_bl_len = 1 << ((cmd.response[3] >> 22) & 0xf);
Andy Fleming272cc702008-10-30 16:41:01 -0500922
923 if (mmc->high_capacity) {
924 csize = (mmc->csd[1] & 0x3f) << 16
925 | (mmc->csd[2] & 0xffff0000) >> 16;
926 cmult = 8;
927 } else {
928 csize = (mmc->csd[1] & 0x3ff) << 2
929 | (mmc->csd[2] & 0xc0000000) >> 30;
930 cmult = (mmc->csd[2] & 0x00038000) >> 15;
931 }
932
Stephen Warrenf866a462013-06-11 15:14:01 -0600933 mmc->capacity_user = (csize + 1) << (cmult + 2);
934 mmc->capacity_user *= mmc->read_bl_len;
935 mmc->capacity_boot = 0;
936 mmc->capacity_rpmb = 0;
937 for (i = 0; i < 4; i++)
938 mmc->capacity_gp[i] = 0;
Andy Fleming272cc702008-10-30 16:41:01 -0500939
Simon Glass8bfa1952013-04-03 08:54:30 +0000940 if (mmc->read_bl_len > MMC_MAX_BLOCK_LEN)
941 mmc->read_bl_len = MMC_MAX_BLOCK_LEN;
Andy Fleming272cc702008-10-30 16:41:01 -0500942
Simon Glass8bfa1952013-04-03 08:54:30 +0000943 if (mmc->write_bl_len > MMC_MAX_BLOCK_LEN)
944 mmc->write_bl_len = MMC_MAX_BLOCK_LEN;
Andy Fleming272cc702008-10-30 16:41:01 -0500945
Markus Niebelab711882013-12-16 13:40:46 +0100946 if ((mmc->dsr_imp) && (0xffffffff != mmc->dsr)) {
947 cmd.cmdidx = MMC_CMD_SET_DSR;
948 cmd.cmdarg = (mmc->dsr & 0xffff) << 16;
949 cmd.resp_type = MMC_RSP_NONE;
950 if (mmc_send_cmd(mmc, &cmd, NULL))
951 printf("MMC: SET_DSR failed\n");
952 }
953
Andy Fleming272cc702008-10-30 16:41:01 -0500954 /* Select the card, and put it into Transfer Mode */
Thomas Choud52ebf12010-12-24 13:12:21 +0000955 if (!mmc_host_is_spi(mmc)) { /* cmd not supported in spi */
956 cmd.cmdidx = MMC_CMD_SELECT_CARD;
Ajay Bhargavfe8f7062011-10-05 03:13:23 +0000957 cmd.resp_type = MMC_RSP_R1;
Thomas Choud52ebf12010-12-24 13:12:21 +0000958 cmd.cmdarg = mmc->rca << 16;
Thomas Choud52ebf12010-12-24 13:12:21 +0000959 err = mmc_send_cmd(mmc, &cmd, NULL);
Andy Fleming272cc702008-10-30 16:41:01 -0500960
Thomas Choud52ebf12010-12-24 13:12:21 +0000961 if (err)
962 return err;
963 }
Andy Fleming272cc702008-10-30 16:41:01 -0500964
Lei Wene6f99a52011-06-22 17:03:31 +0000965 /*
966 * For SD, its erase group is always one sector
967 */
968 mmc->erase_grp_size = 1;
Lei Wenbc897b12011-05-02 16:26:26 +0000969 mmc->part_config = MMCPART_NOAVAILABLE;
Sukumar Ghoraid23e2c02010-09-20 18:29:29 +0530970 if (!IS_SD(mmc) && (mmc->version >= MMC_VERSION_4)) {
971 /* check ext_csd version and capacity */
972 err = mmc_send_ext_csd(mmc, ext_csd);
Kim Phillipsfdbb8732012-10-29 13:34:43 +0000973 if (!err && (ext_csd[EXT_CSD_REV] >= 2)) {
Yoshihiro Shimoda639b7822011-07-04 22:13:26 +0000974 /*
975 * According to the JEDEC Standard, the value of
976 * ext_csd's capacity is valid if the value is more
977 * than 2GB
978 */
Lei Wen0560db12011-10-03 20:35:10 +0000979 capacity = ext_csd[EXT_CSD_SEC_CNT] << 0
980 | ext_csd[EXT_CSD_SEC_CNT + 1] << 8
981 | ext_csd[EXT_CSD_SEC_CNT + 2] << 16
982 | ext_csd[EXT_CSD_SEC_CNT + 3] << 24;
Simon Glass8bfa1952013-04-03 08:54:30 +0000983 capacity *= MMC_MAX_BLOCK_LEN;
Łukasz Majewskib1f1e8212011-07-05 02:19:44 +0000984 if ((capacity >> 20) > 2 * 1024)
Stephen Warrenf866a462013-06-11 15:14:01 -0600985 mmc->capacity_user = capacity;
Sukumar Ghoraid23e2c02010-09-20 18:29:29 +0530986 }
Lei Wenbc897b12011-05-02 16:26:26 +0000987
Jaehoon Chung64f4a612013-01-29 19:31:16 +0000988 switch (ext_csd[EXT_CSD_REV]) {
989 case 1:
990 mmc->version = MMC_VERSION_4_1;
991 break;
992 case 2:
993 mmc->version = MMC_VERSION_4_2;
994 break;
995 case 3:
996 mmc->version = MMC_VERSION_4_3;
997 break;
998 case 5:
999 mmc->version = MMC_VERSION_4_41;
1000 break;
1001 case 6:
1002 mmc->version = MMC_VERSION_4_5;
1003 break;
Markus Niebeledab7232014-11-18 15:13:53 +01001004 case 7:
1005 mmc->version = MMC_VERSION_5_0;
1006 break;
Jaehoon Chung64f4a612013-01-29 19:31:16 +00001007 }
1008
Lei Wene6f99a52011-06-22 17:03:31 +00001009 /*
Oliver Metz1937e5a2013-10-01 20:32:07 +02001010 * Host needs to enable ERASE_GRP_DEF bit if device is
1011 * partitioned. This bit will be lost every time after a reset
1012 * or power off. This will affect erase size.
Lei Wene6f99a52011-06-22 17:03:31 +00001013 */
Oliver Metz1937e5a2013-10-01 20:32:07 +02001014 if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) &&
1015 (ext_csd[EXT_CSD_PARTITIONS_ATTRIBUTE] & PART_ENH_ATTRIB)) {
1016 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1017 EXT_CSD_ERASE_GROUP_DEF, 1);
1018
1019 if (err)
1020 return err;
Hannes Petermaier021a8052014-08-08 09:47:22 +02001021 else
1022 ext_csd[EXT_CSD_ERASE_GROUP_DEF] = 1;
Oliver Metz1937e5a2013-10-01 20:32:07 +02001023
1024 /* Read out group size from ext_csd */
Lei Wen0560db12011-10-03 20:35:10 +00001025 mmc->erase_grp_size =
Simon Glass8bfa1952013-04-03 08:54:30 +00001026 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] *
1027 MMC_MAX_BLOCK_LEN * 1024;
Markus Niebeld7b29122014-11-18 15:11:42 +01001028 /*
1029 * if high capacity and partition setting completed
1030 * SEC_COUNT is valid even if it is smaller than 2 GiB
1031 * JEDEC Standard JESD84-B45, 6.2.4
1032 */
1033 if (mmc->high_capacity &&
1034 (ext_csd[EXT_CSD_PARTITION_SETTING] &
1035 EXT_CSD_PARTITION_SETTING_COMPLETED)) {
1036 capacity = (ext_csd[EXT_CSD_SEC_CNT]) |
1037 (ext_csd[EXT_CSD_SEC_CNT + 1] << 8) |
1038 (ext_csd[EXT_CSD_SEC_CNT + 2] << 16) |
1039 (ext_csd[EXT_CSD_SEC_CNT + 3] << 24);
1040 capacity *= MMC_MAX_BLOCK_LEN;
1041 mmc->capacity_user = capacity;
1042 }
Simon Glass8bfa1952013-04-03 08:54:30 +00001043 } else {
Oliver Metz1937e5a2013-10-01 20:32:07 +02001044 /* Calculate the group size from the csd value. */
Lei Wene6f99a52011-06-22 17:03:31 +00001045 int erase_gsz, erase_gmul;
1046 erase_gsz = (mmc->csd[2] & 0x00007c00) >> 10;
1047 erase_gmul = (mmc->csd[2] & 0x000003e0) >> 5;
1048 mmc->erase_grp_size = (erase_gsz + 1)
1049 * (erase_gmul + 1);
1050 }
1051
Lei Wenbc897b12011-05-02 16:26:26 +00001052 /* store the partition info of emmc */
Stephen Warren8948ea82012-07-30 10:55:43 +00001053 if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) ||
1054 ext_csd[EXT_CSD_BOOT_MULT])
Lei Wen0560db12011-10-03 20:35:10 +00001055 mmc->part_config = ext_csd[EXT_CSD_PART_CONF];
Stephen Warrenf866a462013-06-11 15:14:01 -06001056
1057 mmc->capacity_boot = ext_csd[EXT_CSD_BOOT_MULT] << 17;
1058
1059 mmc->capacity_rpmb = ext_csd[EXT_CSD_RPMB_MULT] << 17;
1060
1061 for (i = 0; i < 4; i++) {
1062 int idx = EXT_CSD_GP_SIZE_MULT + i * 3;
1063 mmc->capacity_gp[i] = (ext_csd[idx + 2] << 16) +
1064 (ext_csd[idx + 1] << 8) + ext_csd[idx];
1065 mmc->capacity_gp[i] *=
1066 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
1067 mmc->capacity_gp[i] *= ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
1068 }
Sukumar Ghoraid23e2c02010-09-20 18:29:29 +05301069 }
1070
Stephen Warrenf866a462013-06-11 15:14:01 -06001071 err = mmc_set_capacity(mmc, mmc->part_num);
1072 if (err)
1073 return err;
1074
Andy Fleming272cc702008-10-30 16:41:01 -05001075 if (IS_SD(mmc))
1076 err = sd_change_freq(mmc);
1077 else
1078 err = mmc_change_freq(mmc);
1079
1080 if (err)
1081 return err;
1082
1083 /* Restrict card's capabilities by what the host can do */
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001084 mmc->card_caps &= mmc->cfg->host_caps;
Andy Fleming272cc702008-10-30 16:41:01 -05001085
1086 if (IS_SD(mmc)) {
1087 if (mmc->card_caps & MMC_MODE_4BIT) {
1088 cmd.cmdidx = MMC_CMD_APP_CMD;
1089 cmd.resp_type = MMC_RSP_R1;
1090 cmd.cmdarg = mmc->rca << 16;
Andy Fleming272cc702008-10-30 16:41:01 -05001091
1092 err = mmc_send_cmd(mmc, &cmd, NULL);
1093 if (err)
1094 return err;
1095
1096 cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH;
1097 cmd.resp_type = MMC_RSP_R1;
1098 cmd.cmdarg = 2;
Andy Fleming272cc702008-10-30 16:41:01 -05001099 err = mmc_send_cmd(mmc, &cmd, NULL);
1100 if (err)
1101 return err;
1102
1103 mmc_set_bus_width(mmc, 4);
1104 }
1105
1106 if (mmc->card_caps & MMC_MODE_HS)
Jaehoon Chungad5fd922012-03-26 21:16:03 +00001107 mmc->tran_speed = 50000000;
Andy Fleming272cc702008-10-30 16:41:01 -05001108 else
Jaehoon Chungad5fd922012-03-26 21:16:03 +00001109 mmc->tran_speed = 25000000;
Andy Fleming272cc702008-10-30 16:41:01 -05001110 } else {
Andy Fleming7798f6d2012-10-31 19:02:38 +00001111 int idx;
1112
1113 /* An array of possible bus widths in order of preference */
1114 static unsigned ext_csd_bits[] = {
Jaehoon Chungd22e3d42014-05-16 13:59:54 +09001115 EXT_CSD_DDR_BUS_WIDTH_8,
1116 EXT_CSD_DDR_BUS_WIDTH_4,
Andy Fleming7798f6d2012-10-31 19:02:38 +00001117 EXT_CSD_BUS_WIDTH_8,
1118 EXT_CSD_BUS_WIDTH_4,
1119 EXT_CSD_BUS_WIDTH_1,
1120 };
1121
1122 /* An array to map CSD bus widths to host cap bits */
1123 static unsigned ext_to_hostcaps[] = {
Andrew Gabbasov786e8f82014-12-01 06:59:09 -06001124 [EXT_CSD_DDR_BUS_WIDTH_4] =
1125 MMC_MODE_DDR_52MHz | MMC_MODE_4BIT,
1126 [EXT_CSD_DDR_BUS_WIDTH_8] =
1127 MMC_MODE_DDR_52MHz | MMC_MODE_8BIT,
Andy Fleming7798f6d2012-10-31 19:02:38 +00001128 [EXT_CSD_BUS_WIDTH_4] = MMC_MODE_4BIT,
1129 [EXT_CSD_BUS_WIDTH_8] = MMC_MODE_8BIT,
1130 };
1131
1132 /* An array to map chosen bus width to an integer */
1133 static unsigned widths[] = {
Jaehoon Chungd22e3d42014-05-16 13:59:54 +09001134 8, 4, 8, 4, 1,
Andy Fleming7798f6d2012-10-31 19:02:38 +00001135 };
1136
1137 for (idx=0; idx < ARRAY_SIZE(ext_csd_bits); idx++) {
1138 unsigned int extw = ext_csd_bits[idx];
Andrew Gabbasov786e8f82014-12-01 06:59:09 -06001139 unsigned int caps = ext_to_hostcaps[extw];
Andy Fleming7798f6d2012-10-31 19:02:38 +00001140
1141 /*
Andrew Gabbasov786e8f82014-12-01 06:59:09 -06001142 * Check to make sure the card and controller support
1143 * these capabilities
Andy Fleming7798f6d2012-10-31 19:02:38 +00001144 */
Andrew Gabbasov786e8f82014-12-01 06:59:09 -06001145 if ((mmc->card_caps & caps) != caps)
Andy Fleming7798f6d2012-10-31 19:02:38 +00001146 continue;
1147
Andy Fleming272cc702008-10-30 16:41:01 -05001148 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
Andy Fleming7798f6d2012-10-31 19:02:38 +00001149 EXT_CSD_BUS_WIDTH, extw);
Andy Fleming272cc702008-10-30 16:41:01 -05001150
1151 if (err)
Lei Wen41378942011-10-03 20:35:11 +00001152 continue;
Andy Fleming272cc702008-10-30 16:41:01 -05001153
Andrew Gabbasov786e8f82014-12-01 06:59:09 -06001154 mmc->ddr_mode = (caps & MMC_MODE_DDR_52MHz) ? 1 : 0;
Andy Fleming7798f6d2012-10-31 19:02:38 +00001155 mmc_set_bus_width(mmc, widths[idx]);
Andy Fleming272cc702008-10-30 16:41:01 -05001156
Lei Wen41378942011-10-03 20:35:11 +00001157 err = mmc_send_ext_csd(mmc, test_csd);
Andy Fleming272cc702008-10-30 16:41:01 -05001158
Andrew Gabbasov786e8f82014-12-01 06:59:09 -06001159 if (err)
1160 continue;
1161
1162 /* Only compare read only fields */
1163 if (ext_csd[EXT_CSD_PARTITIONING_SUPPORT]
1164 == test_csd[EXT_CSD_PARTITIONING_SUPPORT] &&
1165 ext_csd[EXT_CSD_HC_WP_GRP_SIZE]
1166 == test_csd[EXT_CSD_HC_WP_GRP_SIZE] &&
1167 ext_csd[EXT_CSD_REV]
1168 == test_csd[EXT_CSD_REV] &&
1169 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]
1170 == test_csd[EXT_CSD_HC_ERASE_GRP_SIZE] &&
1171 memcmp(&ext_csd[EXT_CSD_SEC_CNT],
1172 &test_csd[EXT_CSD_SEC_CNT], 4) == 0)
Lei Wen41378942011-10-03 20:35:11 +00001173 break;
Andrew Gabbasov786e8f82014-12-01 06:59:09 -06001174 else
1175 err = SWITCH_ERR;
Andy Fleming272cc702008-10-30 16:41:01 -05001176 }
1177
Andrew Gabbasov786e8f82014-12-01 06:59:09 -06001178 if (err)
1179 return err;
1180
Andy Fleming272cc702008-10-30 16:41:01 -05001181 if (mmc->card_caps & MMC_MODE_HS) {
1182 if (mmc->card_caps & MMC_MODE_HS_52MHz)
Jaehoon Chungad5fd922012-03-26 21:16:03 +00001183 mmc->tran_speed = 52000000;
Andy Fleming272cc702008-10-30 16:41:01 -05001184 else
Jaehoon Chungad5fd922012-03-26 21:16:03 +00001185 mmc->tran_speed = 26000000;
1186 }
Andy Fleming272cc702008-10-30 16:41:01 -05001187 }
1188
Jaehoon Chungad5fd922012-03-26 21:16:03 +00001189 mmc_set_clock(mmc, mmc->tran_speed);
1190
Andrew Gabbasov5af8f452014-12-01 06:59:11 -06001191 /* Fix the block length for DDR mode */
1192 if (mmc->ddr_mode) {
1193 mmc->read_bl_len = MMC_MAX_BLOCK_LEN;
1194 mmc->write_bl_len = MMC_MAX_BLOCK_LEN;
1195 }
1196
Andy Fleming272cc702008-10-30 16:41:01 -05001197 /* fill in device description */
1198 mmc->block_dev.lun = 0;
1199 mmc->block_dev.type = 0;
1200 mmc->block_dev.blksz = mmc->read_bl_len;
Egbert Eich0472fbf2013-04-09 21:11:56 +00001201 mmc->block_dev.log2blksz = LOG2(mmc->block_dev.blksz);
Rabin Vincent9b1f9422009-04-05 13:30:54 +05301202 mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len);
Paul Burton56196822013-09-04 16:12:25 +01001203#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
Taylor Huttbabce5f2012-10-20 17:15:59 +00001204 sprintf(mmc->block_dev.vendor, "Man %06x Snr %04x%04x",
1205 mmc->cid[0] >> 24, (mmc->cid[2] & 0xffff),
1206 (mmc->cid[3] >> 16) & 0xffff);
1207 sprintf(mmc->block_dev.product, "%c%c%c%c%c%c", mmc->cid[0] & 0xff,
1208 (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff,
1209 (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff,
1210 (mmc->cid[2] >> 24) & 0xff);
1211 sprintf(mmc->block_dev.revision, "%d.%d", (mmc->cid[2] >> 20) & 0xf,
1212 (mmc->cid[2] >> 16) & 0xf);
Paul Burton56196822013-09-04 16:12:25 +01001213#else
1214 mmc->block_dev.vendor[0] = 0;
1215 mmc->block_dev.product[0] = 0;
1216 mmc->block_dev.revision[0] = 0;
1217#endif
Mikhail Kshevetskiy122efd42012-07-09 08:53:38 +00001218#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBDISK_SUPPORT)
Andy Fleming272cc702008-10-30 16:41:01 -05001219 init_part(&mmc->block_dev);
Mikhail Kshevetskiy122efd42012-07-09 08:53:38 +00001220#endif
Andy Fleming272cc702008-10-30 16:41:01 -05001221
1222 return 0;
1223}
1224
Kim Phillipsfdbb8732012-10-29 13:34:43 +00001225static int mmc_send_if_cond(struct mmc *mmc)
Andy Fleming272cc702008-10-30 16:41:01 -05001226{
1227 struct mmc_cmd cmd;
1228 int err;
1229
1230 cmd.cmdidx = SD_CMD_SEND_IF_COND;
1231 /* We set the bit if the host supports voltages between 2.7 and 3.6 V */
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001232 cmd.cmdarg = ((mmc->cfg->voltages & 0xff8000) != 0) << 8 | 0xaa;
Andy Fleming272cc702008-10-30 16:41:01 -05001233 cmd.resp_type = MMC_RSP_R7;
Andy Fleming272cc702008-10-30 16:41:01 -05001234
1235 err = mmc_send_cmd(mmc, &cmd, NULL);
1236
1237 if (err)
1238 return err;
1239
Rabin Vincent998be3d2009-04-05 13:30:56 +05301240 if ((cmd.response[0] & 0xff) != 0xaa)
Andy Fleming272cc702008-10-30 16:41:01 -05001241 return UNUSABLE_ERR;
1242 else
1243 mmc->version = SD_VERSION_2;
1244
1245 return 0;
1246}
1247
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001248/* not used any more */
1249int __deprecated mmc_register(struct mmc *mmc)
Andy Fleming272cc702008-10-30 16:41:01 -05001250{
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001251#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
1252 printf("%s is deprecated! use mmc_create() instead.\n", __func__);
1253#endif
1254 return -1;
1255}
1256
1257struct mmc *mmc_create(const struct mmc_config *cfg, void *priv)
1258{
1259 struct mmc *mmc;
1260
1261 /* quick validation */
1262 if (cfg == NULL || cfg->ops == NULL || cfg->ops->send_cmd == NULL ||
1263 cfg->f_min == 0 || cfg->f_max == 0 || cfg->b_max == 0)
1264 return NULL;
1265
1266 mmc = calloc(1, sizeof(*mmc));
1267 if (mmc == NULL)
1268 return NULL;
1269
1270 mmc->cfg = cfg;
1271 mmc->priv = priv;
1272
1273 /* the following chunk was mmc_register() */
1274
Markus Niebelab711882013-12-16 13:40:46 +01001275 /* Setup dsr related values */
1276 mmc->dsr_imp = 0;
1277 mmc->dsr = 0xffffffff;
Andy Fleming272cc702008-10-30 16:41:01 -05001278 /* Setup the universal parts of the block interface just once */
1279 mmc->block_dev.if_type = IF_TYPE_MMC;
1280 mmc->block_dev.dev = cur_dev_num++;
1281 mmc->block_dev.removable = 1;
1282 mmc->block_dev.block_read = mmc_bread;
1283 mmc->block_dev.block_write = mmc_bwrite;
Lei Wene6f99a52011-06-22 17:03:31 +00001284 mmc->block_dev.block_erase = mmc_berase;
Andy Fleming272cc702008-10-30 16:41:01 -05001285
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001286 /* setup initial part type */
1287 mmc->block_dev.part_type = mmc->cfg->part_type;
Andy Fleming272cc702008-10-30 16:41:01 -05001288
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001289 INIT_LIST_HEAD(&mmc->link);
Andy Fleming272cc702008-10-30 16:41:01 -05001290
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001291 list_add_tail(&mmc->link, &mmc_devices);
1292
1293 return mmc;
1294}
1295
1296void mmc_destroy(struct mmc *mmc)
1297{
1298 /* only freeing memory for now */
1299 free(mmc);
Andy Fleming272cc702008-10-30 16:41:01 -05001300}
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);
Benoît Thébaudeau6bb4b4b2012-08-10 08:59:12 +00001306 if (!mmc || mmc_init(mmc))
Łukasz Majewski40242bc2012-04-19 02:39:18 +00001307 return NULL;
Andy Fleming272cc702008-10-30 16:41:01 -05001308
Łukasz Majewski40242bc2012-04-19 02:39:18 +00001309 return &mmc->block_dev;
Andy Fleming272cc702008-10-30 16:41:01 -05001310}
Matthew McClintockdf3fc522011-05-24 05:31:19 +00001311#endif
Andy Fleming272cc702008-10-30 16:41:01 -05001312
Paul Kocialkowski95de9ab2014-11-08 20:55:45 +01001313/* board-specific MMC power initializations. */
1314__weak void board_mmc_power_init(void)
1315{
1316}
1317
Che-Liang Chioue9550442012-11-28 15:21:13 +00001318int mmc_start_init(struct mmc *mmc)
Andy Fleming272cc702008-10-30 16:41:01 -05001319{
Macpaul Linafd59322011-11-14 23:35:39 +00001320 int err;
Andy Fleming272cc702008-10-30 16:41:01 -05001321
Pantelis Antoniouab769f22014-02-26 19:28:45 +02001322 /* we pretend there's no card when init is NULL */
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001323 if (mmc_getcd(mmc) == 0 || mmc->cfg->ops->init == NULL) {
Thierry Reding48972d92012-01-02 01:15:37 +00001324 mmc->has_init = 0;
Paul Burton56196822013-09-04 16:12:25 +01001325#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
Thierry Reding48972d92012-01-02 01:15:37 +00001326 printf("MMC: no card present\n");
Paul Burton56196822013-09-04 16:12:25 +01001327#endif
Thierry Reding48972d92012-01-02 01:15:37 +00001328 return NO_CARD_ERR;
1329 }
1330
Lei Wenbc897b12011-05-02 16:26:26 +00001331 if (mmc->has_init)
1332 return 0;
1333
Paul Kocialkowski95de9ab2014-11-08 20:55:45 +01001334 board_mmc_power_init();
1335
Pantelis Antoniouab769f22014-02-26 19:28:45 +02001336 /* made sure it's not NULL earlier */
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001337 err = mmc->cfg->ops->init(mmc);
Andy Fleming272cc702008-10-30 16:41:01 -05001338
1339 if (err)
1340 return err;
1341
Andrew Gabbasov786e8f82014-12-01 06:59:09 -06001342 mmc->ddr_mode = 0;
Ilya Yanokb86b85e2009-06-29 17:53:16 +04001343 mmc_set_bus_width(mmc, 1);
1344 mmc_set_clock(mmc, 1);
1345
Andy Fleming272cc702008-10-30 16:41:01 -05001346 /* Reset the Card */
1347 err = mmc_go_idle(mmc);
1348
1349 if (err)
1350 return err;
1351
Lei Wenbc897b12011-05-02 16:26:26 +00001352 /* The internal partition reset to user partition(0) at every CMD0*/
1353 mmc->part_num = 0;
1354
Andy Fleming272cc702008-10-30 16:41:01 -05001355 /* Test for SD version 2 */
Macpaul Linafd59322011-11-14 23:35:39 +00001356 err = mmc_send_if_cond(mmc);
Andy Fleming272cc702008-10-30 16:41:01 -05001357
Andy Fleming272cc702008-10-30 16:41:01 -05001358 /* Now try to get the SD card's operating condition */
1359 err = sd_send_op_cond(mmc);
1360
1361 /* If the command timed out, we check for an MMC card */
1362 if (err == TIMEOUT) {
1363 err = mmc_send_op_cond(mmc);
1364
Che-Liang Chioue9550442012-11-28 15:21:13 +00001365 if (err && err != IN_PROGRESS) {
Paul Burton56196822013-09-04 16:12:25 +01001366#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
Andy Fleming272cc702008-10-30 16:41:01 -05001367 printf("Card did not respond to voltage select!\n");
Paul Burton56196822013-09-04 16:12:25 +01001368#endif
Andy Fleming272cc702008-10-30 16:41:01 -05001369 return UNUSABLE_ERR;
1370 }
1371 }
1372
Che-Liang Chioue9550442012-11-28 15:21:13 +00001373 if (err == IN_PROGRESS)
1374 mmc->init_in_progress = 1;
1375
1376 return err;
1377}
1378
1379static int mmc_complete_init(struct mmc *mmc)
1380{
1381 int err = 0;
1382
1383 if (mmc->op_cond_pending)
1384 err = mmc_complete_op_cond(mmc);
1385
1386 if (!err)
1387 err = mmc_startup(mmc);
Lei Wenbc897b12011-05-02 16:26:26 +00001388 if (err)
1389 mmc->has_init = 0;
1390 else
1391 mmc->has_init = 1;
Che-Liang Chioue9550442012-11-28 15:21:13 +00001392 mmc->init_in_progress = 0;
1393 return err;
1394}
1395
1396int mmc_init(struct mmc *mmc)
1397{
1398 int err = IN_PROGRESS;
Mateusz Zalegad803fea2014-04-29 20:15:30 +02001399 unsigned start;
Che-Liang Chioue9550442012-11-28 15:21:13 +00001400
1401 if (mmc->has_init)
1402 return 0;
Mateusz Zalegad803fea2014-04-29 20:15:30 +02001403
1404 start = get_timer(0);
1405
Che-Liang Chioue9550442012-11-28 15:21:13 +00001406 if (!mmc->init_in_progress)
1407 err = mmc_start_init(mmc);
1408
1409 if (!err || err == IN_PROGRESS)
1410 err = mmc_complete_init(mmc);
1411 debug("%s: %d, time %lu\n", __func__, err, get_timer(start));
Lei Wenbc897b12011-05-02 16:26:26 +00001412 return err;
Andy Fleming272cc702008-10-30 16:41:01 -05001413}
1414
Markus Niebelab711882013-12-16 13:40:46 +01001415int mmc_set_dsr(struct mmc *mmc, u16 val)
1416{
1417 mmc->dsr = val;
1418 return 0;
1419}
1420
Jeroen Hofsteecee9ab72014-07-10 22:46:28 +02001421/* CPU-specific MMC initializations */
1422__weak int cpu_mmc_init(bd_t *bis)
Andy Fleming272cc702008-10-30 16:41:01 -05001423{
1424 return -1;
1425}
1426
Jeroen Hofsteecee9ab72014-07-10 22:46:28 +02001427/* board-specific MMC initializations. */
1428__weak int board_mmc_init(bd_t *bis)
1429{
1430 return -1;
1431}
Andy Fleming272cc702008-10-30 16:41:01 -05001432
Paul Burton56196822013-09-04 16:12:25 +01001433#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
1434
Andy Fleming272cc702008-10-30 16:41:01 -05001435void print_mmc_devices(char separator)
1436{
1437 struct mmc *m;
1438 struct list_head *entry;
1439
1440 list_for_each(entry, &mmc_devices) {
1441 m = list_entry(entry, struct mmc, link);
1442
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001443 printf("%s: %d", m->cfg->name, m->block_dev.dev);
Andy Fleming272cc702008-10-30 16:41:01 -05001444
Lubomir Popove75eaf12014-11-11 12:25:42 +02001445 if (entry->next != &mmc_devices) {
1446 printf("%c", separator);
1447 if (separator != '\n')
1448 puts (" ");
1449 }
Andy Fleming272cc702008-10-30 16:41:01 -05001450 }
1451
1452 printf("\n");
1453}
1454
Paul Burton56196822013-09-04 16:12:25 +01001455#else
1456void print_mmc_devices(char separator) { }
1457#endif
1458
Lei Wenea6ebe22011-05-02 16:26:25 +00001459int get_mmc_num(void)
1460{
1461 return cur_dev_num;
1462}
1463
Che-Liang Chioue9550442012-11-28 15:21:13 +00001464void mmc_set_preinit(struct mmc *mmc, int preinit)
1465{
1466 mmc->preinit = preinit;
1467}
1468
1469static void do_preinit(void)
1470{
1471 struct mmc *m;
1472 struct list_head *entry;
1473
1474 list_for_each(entry, &mmc_devices) {
1475 m = list_entry(entry, struct mmc, link);
1476
1477 if (m->preinit)
1478 mmc_start_init(m);
1479 }
1480}
1481
1482
Andy Fleming272cc702008-10-30 16:41:01 -05001483int mmc_initialize(bd_t *bis)
1484{
1485 INIT_LIST_HEAD (&mmc_devices);
1486 cur_dev_num = 0;
1487
1488 if (board_mmc_init(bis) < 0)
1489 cpu_mmc_init(bis);
1490
Ying Zhangbb0dc102013-08-16 15:16:11 +08001491#ifndef CONFIG_SPL_BUILD
Andy Fleming272cc702008-10-30 16:41:01 -05001492 print_mmc_devices(',');
Ying Zhangbb0dc102013-08-16 15:16:11 +08001493#endif
Andy Fleming272cc702008-10-30 16:41:01 -05001494
Che-Liang Chioue9550442012-11-28 15:21:13 +00001495 do_preinit();
Andy Fleming272cc702008-10-30 16:41:01 -05001496 return 0;
1497}
Amar3690d6d2013-04-27 11:42:58 +05301498
1499#ifdef CONFIG_SUPPORT_EMMC_BOOT
1500/*
1501 * This function changes the size of boot partition and the size of rpmb
1502 * partition present on EMMC devices.
1503 *
1504 * Input Parameters:
1505 * struct *mmc: pointer for the mmc device strcuture
1506 * bootsize: size of boot partition
1507 * rpmbsize: size of rpmb partition
1508 *
1509 * Returns 0 on success.
1510 */
1511
1512int mmc_boot_partition_size_change(struct mmc *mmc, unsigned long bootsize,
1513 unsigned long rpmbsize)
1514{
1515 int err;
1516 struct mmc_cmd cmd;
1517
1518 /* Only use this command for raw EMMC moviNAND. Enter backdoor mode */
1519 cmd.cmdidx = MMC_CMD_RES_MAN;
1520 cmd.resp_type = MMC_RSP_R1b;
1521 cmd.cmdarg = MMC_CMD62_ARG1;
1522
1523 err = mmc_send_cmd(mmc, &cmd, NULL);
1524 if (err) {
1525 debug("mmc_boot_partition_size_change: Error1 = %d\n", err);
1526 return err;
1527 }
1528
1529 /* Boot partition changing mode */
1530 cmd.cmdidx = MMC_CMD_RES_MAN;
1531 cmd.resp_type = MMC_RSP_R1b;
1532 cmd.cmdarg = MMC_CMD62_ARG2;
1533
1534 err = mmc_send_cmd(mmc, &cmd, NULL);
1535 if (err) {
1536 debug("mmc_boot_partition_size_change: Error2 = %d\n", err);
1537 return err;
1538 }
1539 /* boot partition size is multiple of 128KB */
1540 bootsize = (bootsize * 1024) / 128;
1541
1542 /* Arg: boot partition size */
1543 cmd.cmdidx = MMC_CMD_RES_MAN;
1544 cmd.resp_type = MMC_RSP_R1b;
1545 cmd.cmdarg = bootsize;
1546
1547 err = mmc_send_cmd(mmc, &cmd, NULL);
1548 if (err) {
1549 debug("mmc_boot_partition_size_change: Error3 = %d\n", err);
1550 return err;
1551 }
1552 /* RPMB partition size is multiple of 128KB */
1553 rpmbsize = (rpmbsize * 1024) / 128;
1554 /* Arg: RPMB partition size */
1555 cmd.cmdidx = MMC_CMD_RES_MAN;
1556 cmd.resp_type = MMC_RSP_R1b;
1557 cmd.cmdarg = rpmbsize;
1558
1559 err = mmc_send_cmd(mmc, &cmd, NULL);
1560 if (err) {
1561 debug("mmc_boot_partition_size_change: Error4 = %d\n", err);
1562 return err;
1563 }
1564 return 0;
1565}
1566
1567/*
Tom Rini5a99b9d2014-02-05 10:24:22 -05001568 * Modify EXT_CSD[177] which is BOOT_BUS_WIDTH
1569 * based on the passed in values for BOOT_BUS_WIDTH, RESET_BOOT_BUS_WIDTH
1570 * and BOOT_MODE.
1571 *
1572 * Returns 0 on success.
1573 */
1574int mmc_set_boot_bus_width(struct mmc *mmc, u8 width, u8 reset, u8 mode)
1575{
1576 int err;
1577
1578 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BOOT_BUS_WIDTH,
1579 EXT_CSD_BOOT_BUS_WIDTH_MODE(mode) |
1580 EXT_CSD_BOOT_BUS_WIDTH_RESET(reset) |
1581 EXT_CSD_BOOT_BUS_WIDTH_WIDTH(width));
1582
1583 if (err)
1584 return err;
1585 return 0;
1586}
1587
1588/*
Tom Rini792970b2014-02-05 10:24:21 -05001589 * Modify EXT_CSD[179] which is PARTITION_CONFIG (formerly BOOT_CONFIG)
1590 * based on the passed in values for BOOT_ACK, BOOT_PARTITION_ENABLE and
1591 * PARTITION_ACCESS.
1592 *
1593 * Returns 0 on success.
1594 */
1595int mmc_set_part_conf(struct mmc *mmc, u8 ack, u8 part_num, u8 access)
1596{
1597 int err;
1598
1599 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONF,
1600 EXT_CSD_BOOT_ACK(ack) |
1601 EXT_CSD_BOOT_PART_NUM(part_num) |
1602 EXT_CSD_PARTITION_ACCESS(access));
1603
1604 if (err)
1605 return err;
1606 return 0;
1607}
Tom Rini33ace362014-02-07 14:15:20 -05001608
1609/*
1610 * Modify EXT_CSD[162] which is RST_n_FUNCTION based on the given value
1611 * for enable. Note that this is a write-once field for non-zero values.
1612 *
1613 * Returns 0 on success.
1614 */
1615int mmc_set_rst_n_function(struct mmc *mmc, u8 enable)
1616{
1617 return mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_RST_N_FUNCTION,
1618 enable);
1619}
Amar3690d6d2013-04-27 11:42:58 +05301620#endif