blob: e4a28d4b4ae4105f10d757cae443a27dccf41c6d [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
Jaehoon Chungd22e3d42014-05-16 13:59:54 +0900162 if (mmc->card_caps & MMC_MODE_DDR_52MHz)
163 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
489 mmc->card_caps = 0;
490
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) {
522 if (cardtype & EXT_CSD_CARD_TYPE_DDR_52)
523 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;
1004 }
1005
Lei Wene6f99a52011-06-22 17:03:31 +00001006 /*
Oliver Metz1937e5a2013-10-01 20:32:07 +02001007 * Host needs to enable ERASE_GRP_DEF bit if device is
1008 * partitioned. This bit will be lost every time after a reset
1009 * or power off. This will affect erase size.
Lei Wene6f99a52011-06-22 17:03:31 +00001010 */
Oliver Metz1937e5a2013-10-01 20:32:07 +02001011 if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) &&
1012 (ext_csd[EXT_CSD_PARTITIONS_ATTRIBUTE] & PART_ENH_ATTRIB)) {
1013 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
1014 EXT_CSD_ERASE_GROUP_DEF, 1);
1015
1016 if (err)
1017 return err;
Hannes Petermaier021a8052014-08-08 09:47:22 +02001018 else
1019 ext_csd[EXT_CSD_ERASE_GROUP_DEF] = 1;
Oliver Metz1937e5a2013-10-01 20:32:07 +02001020
1021 /* Read out group size from ext_csd */
Lei Wen0560db12011-10-03 20:35:10 +00001022 mmc->erase_grp_size =
Simon Glass8bfa1952013-04-03 08:54:30 +00001023 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] *
1024 MMC_MAX_BLOCK_LEN * 1024;
1025 } else {
Oliver Metz1937e5a2013-10-01 20:32:07 +02001026 /* Calculate the group size from the csd value. */
Lei Wene6f99a52011-06-22 17:03:31 +00001027 int erase_gsz, erase_gmul;
1028 erase_gsz = (mmc->csd[2] & 0x00007c00) >> 10;
1029 erase_gmul = (mmc->csd[2] & 0x000003e0) >> 5;
1030 mmc->erase_grp_size = (erase_gsz + 1)
1031 * (erase_gmul + 1);
1032 }
1033
Lei Wenbc897b12011-05-02 16:26:26 +00001034 /* store the partition info of emmc */
Stephen Warren8948ea82012-07-30 10:55:43 +00001035 if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) ||
1036 ext_csd[EXT_CSD_BOOT_MULT])
Lei Wen0560db12011-10-03 20:35:10 +00001037 mmc->part_config = ext_csd[EXT_CSD_PART_CONF];
Stephen Warrenf866a462013-06-11 15:14:01 -06001038
1039 mmc->capacity_boot = ext_csd[EXT_CSD_BOOT_MULT] << 17;
1040
1041 mmc->capacity_rpmb = ext_csd[EXT_CSD_RPMB_MULT] << 17;
1042
1043 for (i = 0; i < 4; i++) {
1044 int idx = EXT_CSD_GP_SIZE_MULT + i * 3;
1045 mmc->capacity_gp[i] = (ext_csd[idx + 2] << 16) +
1046 (ext_csd[idx + 1] << 8) + ext_csd[idx];
1047 mmc->capacity_gp[i] *=
1048 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
1049 mmc->capacity_gp[i] *= ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
1050 }
Sukumar Ghoraid23e2c02010-09-20 18:29:29 +05301051 }
1052
Stephen Warrenf866a462013-06-11 15:14:01 -06001053 err = mmc_set_capacity(mmc, mmc->part_num);
1054 if (err)
1055 return err;
1056
Andy Fleming272cc702008-10-30 16:41:01 -05001057 if (IS_SD(mmc))
1058 err = sd_change_freq(mmc);
1059 else
1060 err = mmc_change_freq(mmc);
1061
1062 if (err)
1063 return err;
1064
1065 /* Restrict card's capabilities by what the host can do */
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001066 mmc->card_caps &= mmc->cfg->host_caps;
Andy Fleming272cc702008-10-30 16:41:01 -05001067
1068 if (IS_SD(mmc)) {
1069 if (mmc->card_caps & MMC_MODE_4BIT) {
1070 cmd.cmdidx = MMC_CMD_APP_CMD;
1071 cmd.resp_type = MMC_RSP_R1;
1072 cmd.cmdarg = mmc->rca << 16;
Andy Fleming272cc702008-10-30 16:41:01 -05001073
1074 err = mmc_send_cmd(mmc, &cmd, NULL);
1075 if (err)
1076 return err;
1077
1078 cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH;
1079 cmd.resp_type = MMC_RSP_R1;
1080 cmd.cmdarg = 2;
Andy Fleming272cc702008-10-30 16:41:01 -05001081 err = mmc_send_cmd(mmc, &cmd, NULL);
1082 if (err)
1083 return err;
1084
1085 mmc_set_bus_width(mmc, 4);
1086 }
1087
1088 if (mmc->card_caps & MMC_MODE_HS)
Jaehoon Chungad5fd922012-03-26 21:16:03 +00001089 mmc->tran_speed = 50000000;
Andy Fleming272cc702008-10-30 16:41:01 -05001090 else
Jaehoon Chungad5fd922012-03-26 21:16:03 +00001091 mmc->tran_speed = 25000000;
Andy Fleming272cc702008-10-30 16:41:01 -05001092 } else {
Andy Fleming7798f6d2012-10-31 19:02:38 +00001093 int idx;
1094
1095 /* An array of possible bus widths in order of preference */
1096 static unsigned ext_csd_bits[] = {
Jaehoon Chungd22e3d42014-05-16 13:59:54 +09001097 EXT_CSD_DDR_BUS_WIDTH_8,
1098 EXT_CSD_DDR_BUS_WIDTH_4,
Andy Fleming7798f6d2012-10-31 19:02:38 +00001099 EXT_CSD_BUS_WIDTH_8,
1100 EXT_CSD_BUS_WIDTH_4,
1101 EXT_CSD_BUS_WIDTH_1,
1102 };
1103
1104 /* An array to map CSD bus widths to host cap bits */
1105 static unsigned ext_to_hostcaps[] = {
Jaehoon Chungd22e3d42014-05-16 13:59:54 +09001106 [EXT_CSD_DDR_BUS_WIDTH_4] = MMC_MODE_DDR_52MHz,
1107 [EXT_CSD_DDR_BUS_WIDTH_8] = MMC_MODE_DDR_52MHz,
Andy Fleming7798f6d2012-10-31 19:02:38 +00001108 [EXT_CSD_BUS_WIDTH_4] = MMC_MODE_4BIT,
1109 [EXT_CSD_BUS_WIDTH_8] = MMC_MODE_8BIT,
1110 };
1111
1112 /* An array to map chosen bus width to an integer */
1113 static unsigned widths[] = {
Jaehoon Chungd22e3d42014-05-16 13:59:54 +09001114 8, 4, 8, 4, 1,
Andy Fleming7798f6d2012-10-31 19:02:38 +00001115 };
1116
1117 for (idx=0; idx < ARRAY_SIZE(ext_csd_bits); idx++) {
1118 unsigned int extw = ext_csd_bits[idx];
1119
1120 /*
1121 * Check to make sure the controller supports
1122 * this bus width, if it's more than 1
1123 */
1124 if (extw != EXT_CSD_BUS_WIDTH_1 &&
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001125 !(mmc->cfg->host_caps & ext_to_hostcaps[extw]))
Andy Fleming7798f6d2012-10-31 19:02:38 +00001126 continue;
1127
Andy Fleming272cc702008-10-30 16:41:01 -05001128 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
Andy Fleming7798f6d2012-10-31 19:02:38 +00001129 EXT_CSD_BUS_WIDTH, extw);
Andy Fleming272cc702008-10-30 16:41:01 -05001130
1131 if (err)
Lei Wen41378942011-10-03 20:35:11 +00001132 continue;
Andy Fleming272cc702008-10-30 16:41:01 -05001133
Andy Fleming7798f6d2012-10-31 19:02:38 +00001134 mmc_set_bus_width(mmc, widths[idx]);
Andy Fleming272cc702008-10-30 16:41:01 -05001135
Lei Wen41378942011-10-03 20:35:11 +00001136 err = mmc_send_ext_csd(mmc, test_csd);
1137 if (!err && ext_csd[EXT_CSD_PARTITIONING_SUPPORT] \
1138 == test_csd[EXT_CSD_PARTITIONING_SUPPORT]
1139 && ext_csd[EXT_CSD_ERASE_GROUP_DEF] \
1140 == test_csd[EXT_CSD_ERASE_GROUP_DEF] \
1141 && ext_csd[EXT_CSD_REV] \
1142 == test_csd[EXT_CSD_REV]
1143 && ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] \
1144 == test_csd[EXT_CSD_HC_ERASE_GRP_SIZE]
1145 && memcmp(&ext_csd[EXT_CSD_SEC_CNT], \
1146 &test_csd[EXT_CSD_SEC_CNT], 4) == 0) {
Andy Fleming272cc702008-10-30 16:41:01 -05001147
Andy Fleming7798f6d2012-10-31 19:02:38 +00001148 mmc->card_caps |= ext_to_hostcaps[extw];
Lei Wen41378942011-10-03 20:35:11 +00001149 break;
1150 }
Andy Fleming272cc702008-10-30 16:41:01 -05001151 }
1152
1153 if (mmc->card_caps & MMC_MODE_HS) {
1154 if (mmc->card_caps & MMC_MODE_HS_52MHz)
Jaehoon Chungad5fd922012-03-26 21:16:03 +00001155 mmc->tran_speed = 52000000;
Andy Fleming272cc702008-10-30 16:41:01 -05001156 else
Jaehoon Chungad5fd922012-03-26 21:16:03 +00001157 mmc->tran_speed = 26000000;
1158 }
Andy Fleming272cc702008-10-30 16:41:01 -05001159 }
1160
Jaehoon Chungad5fd922012-03-26 21:16:03 +00001161 mmc_set_clock(mmc, mmc->tran_speed);
1162
Andy Fleming272cc702008-10-30 16:41:01 -05001163 /* fill in device description */
1164 mmc->block_dev.lun = 0;
1165 mmc->block_dev.type = 0;
1166 mmc->block_dev.blksz = mmc->read_bl_len;
Egbert Eich0472fbf2013-04-09 21:11:56 +00001167 mmc->block_dev.log2blksz = LOG2(mmc->block_dev.blksz);
Rabin Vincent9b1f9422009-04-05 13:30:54 +05301168 mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len);
Paul Burton56196822013-09-04 16:12:25 +01001169#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
Taylor Huttbabce5f2012-10-20 17:15:59 +00001170 sprintf(mmc->block_dev.vendor, "Man %06x Snr %04x%04x",
1171 mmc->cid[0] >> 24, (mmc->cid[2] & 0xffff),
1172 (mmc->cid[3] >> 16) & 0xffff);
1173 sprintf(mmc->block_dev.product, "%c%c%c%c%c%c", mmc->cid[0] & 0xff,
1174 (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff,
1175 (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff,
1176 (mmc->cid[2] >> 24) & 0xff);
1177 sprintf(mmc->block_dev.revision, "%d.%d", (mmc->cid[2] >> 20) & 0xf,
1178 (mmc->cid[2] >> 16) & 0xf);
Paul Burton56196822013-09-04 16:12:25 +01001179#else
1180 mmc->block_dev.vendor[0] = 0;
1181 mmc->block_dev.product[0] = 0;
1182 mmc->block_dev.revision[0] = 0;
1183#endif
Mikhail Kshevetskiy122efd42012-07-09 08:53:38 +00001184#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBDISK_SUPPORT)
Andy Fleming272cc702008-10-30 16:41:01 -05001185 init_part(&mmc->block_dev);
Mikhail Kshevetskiy122efd42012-07-09 08:53:38 +00001186#endif
Andy Fleming272cc702008-10-30 16:41:01 -05001187
1188 return 0;
1189}
1190
Kim Phillipsfdbb8732012-10-29 13:34:43 +00001191static int mmc_send_if_cond(struct mmc *mmc)
Andy Fleming272cc702008-10-30 16:41:01 -05001192{
1193 struct mmc_cmd cmd;
1194 int err;
1195
1196 cmd.cmdidx = SD_CMD_SEND_IF_COND;
1197 /* We set the bit if the host supports voltages between 2.7 and 3.6 V */
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001198 cmd.cmdarg = ((mmc->cfg->voltages & 0xff8000) != 0) << 8 | 0xaa;
Andy Fleming272cc702008-10-30 16:41:01 -05001199 cmd.resp_type = MMC_RSP_R7;
Andy Fleming272cc702008-10-30 16:41:01 -05001200
1201 err = mmc_send_cmd(mmc, &cmd, NULL);
1202
1203 if (err)
1204 return err;
1205
Rabin Vincent998be3d2009-04-05 13:30:56 +05301206 if ((cmd.response[0] & 0xff) != 0xaa)
Andy Fleming272cc702008-10-30 16:41:01 -05001207 return UNUSABLE_ERR;
1208 else
1209 mmc->version = SD_VERSION_2;
1210
1211 return 0;
1212}
1213
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001214/* not used any more */
1215int __deprecated mmc_register(struct mmc *mmc)
Andy Fleming272cc702008-10-30 16:41:01 -05001216{
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001217#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
1218 printf("%s is deprecated! use mmc_create() instead.\n", __func__);
1219#endif
1220 return -1;
1221}
1222
1223struct mmc *mmc_create(const struct mmc_config *cfg, void *priv)
1224{
1225 struct mmc *mmc;
1226
1227 /* quick validation */
1228 if (cfg == NULL || cfg->ops == NULL || cfg->ops->send_cmd == NULL ||
1229 cfg->f_min == 0 || cfg->f_max == 0 || cfg->b_max == 0)
1230 return NULL;
1231
1232 mmc = calloc(1, sizeof(*mmc));
1233 if (mmc == NULL)
1234 return NULL;
1235
1236 mmc->cfg = cfg;
1237 mmc->priv = priv;
1238
1239 /* the following chunk was mmc_register() */
1240
Markus Niebelab711882013-12-16 13:40:46 +01001241 /* Setup dsr related values */
1242 mmc->dsr_imp = 0;
1243 mmc->dsr = 0xffffffff;
Andy Fleming272cc702008-10-30 16:41:01 -05001244 /* Setup the universal parts of the block interface just once */
1245 mmc->block_dev.if_type = IF_TYPE_MMC;
1246 mmc->block_dev.dev = cur_dev_num++;
1247 mmc->block_dev.removable = 1;
1248 mmc->block_dev.block_read = mmc_bread;
1249 mmc->block_dev.block_write = mmc_bwrite;
Lei Wene6f99a52011-06-22 17:03:31 +00001250 mmc->block_dev.block_erase = mmc_berase;
Andy Fleming272cc702008-10-30 16:41:01 -05001251
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001252 /* setup initial part type */
1253 mmc->block_dev.part_type = mmc->cfg->part_type;
Andy Fleming272cc702008-10-30 16:41:01 -05001254
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001255 INIT_LIST_HEAD(&mmc->link);
Andy Fleming272cc702008-10-30 16:41:01 -05001256
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001257 list_add_tail(&mmc->link, &mmc_devices);
1258
1259 return mmc;
1260}
1261
1262void mmc_destroy(struct mmc *mmc)
1263{
1264 /* only freeing memory for now */
1265 free(mmc);
Andy Fleming272cc702008-10-30 16:41:01 -05001266}
1267
Matthew McClintockdf3fc522011-05-24 05:31:19 +00001268#ifdef CONFIG_PARTITIONS
Andy Fleming272cc702008-10-30 16:41:01 -05001269block_dev_desc_t *mmc_get_dev(int dev)
1270{
1271 struct mmc *mmc = find_mmc_device(dev);
Benoît Thébaudeau6bb4b4b2012-08-10 08:59:12 +00001272 if (!mmc || mmc_init(mmc))
Łukasz Majewski40242bc2012-04-19 02:39:18 +00001273 return NULL;
Andy Fleming272cc702008-10-30 16:41:01 -05001274
Łukasz Majewski40242bc2012-04-19 02:39:18 +00001275 return &mmc->block_dev;
Andy Fleming272cc702008-10-30 16:41:01 -05001276}
Matthew McClintockdf3fc522011-05-24 05:31:19 +00001277#endif
Andy Fleming272cc702008-10-30 16:41:01 -05001278
Che-Liang Chioue9550442012-11-28 15:21:13 +00001279int mmc_start_init(struct mmc *mmc)
Andy Fleming272cc702008-10-30 16:41:01 -05001280{
Macpaul Linafd59322011-11-14 23:35:39 +00001281 int err;
Andy Fleming272cc702008-10-30 16:41:01 -05001282
Pantelis Antoniouab769f22014-02-26 19:28:45 +02001283 /* we pretend there's no card when init is NULL */
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001284 if (mmc_getcd(mmc) == 0 || mmc->cfg->ops->init == NULL) {
Thierry Reding48972d92012-01-02 01:15:37 +00001285 mmc->has_init = 0;
Paul Burton56196822013-09-04 16:12:25 +01001286#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
Thierry Reding48972d92012-01-02 01:15:37 +00001287 printf("MMC: no card present\n");
Paul Burton56196822013-09-04 16:12:25 +01001288#endif
Thierry Reding48972d92012-01-02 01:15:37 +00001289 return NO_CARD_ERR;
1290 }
1291
Lei Wenbc897b12011-05-02 16:26:26 +00001292 if (mmc->has_init)
1293 return 0;
1294
Pantelis Antoniouab769f22014-02-26 19:28:45 +02001295 /* made sure it's not NULL earlier */
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001296 err = mmc->cfg->ops->init(mmc);
Andy Fleming272cc702008-10-30 16:41:01 -05001297
1298 if (err)
1299 return err;
1300
Ilya Yanokb86b85e2009-06-29 17:53:16 +04001301 mmc_set_bus_width(mmc, 1);
1302 mmc_set_clock(mmc, 1);
1303
Andy Fleming272cc702008-10-30 16:41:01 -05001304 /* Reset the Card */
1305 err = mmc_go_idle(mmc);
1306
1307 if (err)
1308 return err;
1309
Lei Wenbc897b12011-05-02 16:26:26 +00001310 /* The internal partition reset to user partition(0) at every CMD0*/
1311 mmc->part_num = 0;
1312
Andy Fleming272cc702008-10-30 16:41:01 -05001313 /* Test for SD version 2 */
Macpaul Linafd59322011-11-14 23:35:39 +00001314 err = mmc_send_if_cond(mmc);
Andy Fleming272cc702008-10-30 16:41:01 -05001315
Andy Fleming272cc702008-10-30 16:41:01 -05001316 /* Now try to get the SD card's operating condition */
1317 err = sd_send_op_cond(mmc);
1318
1319 /* If the command timed out, we check for an MMC card */
1320 if (err == TIMEOUT) {
1321 err = mmc_send_op_cond(mmc);
1322
Che-Liang Chioue9550442012-11-28 15:21:13 +00001323 if (err && err != IN_PROGRESS) {
Paul Burton56196822013-09-04 16:12:25 +01001324#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
Andy Fleming272cc702008-10-30 16:41:01 -05001325 printf("Card did not respond to voltage select!\n");
Paul Burton56196822013-09-04 16:12:25 +01001326#endif
Andy Fleming272cc702008-10-30 16:41:01 -05001327 return UNUSABLE_ERR;
1328 }
1329 }
1330
Che-Liang Chioue9550442012-11-28 15:21:13 +00001331 if (err == IN_PROGRESS)
1332 mmc->init_in_progress = 1;
1333
1334 return err;
1335}
1336
1337static int mmc_complete_init(struct mmc *mmc)
1338{
1339 int err = 0;
1340
1341 if (mmc->op_cond_pending)
1342 err = mmc_complete_op_cond(mmc);
1343
1344 if (!err)
1345 err = mmc_startup(mmc);
Lei Wenbc897b12011-05-02 16:26:26 +00001346 if (err)
1347 mmc->has_init = 0;
1348 else
1349 mmc->has_init = 1;
Che-Liang Chioue9550442012-11-28 15:21:13 +00001350 mmc->init_in_progress = 0;
1351 return err;
1352}
1353
1354int mmc_init(struct mmc *mmc)
1355{
1356 int err = IN_PROGRESS;
Mateusz Zalegad803fea2014-04-29 20:15:30 +02001357 unsigned start;
Che-Liang Chioue9550442012-11-28 15:21:13 +00001358
1359 if (mmc->has_init)
1360 return 0;
Mateusz Zalegad803fea2014-04-29 20:15:30 +02001361
1362 start = get_timer(0);
1363
Che-Liang Chioue9550442012-11-28 15:21:13 +00001364 if (!mmc->init_in_progress)
1365 err = mmc_start_init(mmc);
1366
1367 if (!err || err == IN_PROGRESS)
1368 err = mmc_complete_init(mmc);
1369 debug("%s: %d, time %lu\n", __func__, err, get_timer(start));
Lei Wenbc897b12011-05-02 16:26:26 +00001370 return err;
Andy Fleming272cc702008-10-30 16:41:01 -05001371}
1372
Markus Niebelab711882013-12-16 13:40:46 +01001373int mmc_set_dsr(struct mmc *mmc, u16 val)
1374{
1375 mmc->dsr = val;
1376 return 0;
1377}
1378
Jeroen Hofsteecee9ab72014-07-10 22:46:28 +02001379/* CPU-specific MMC initializations */
1380__weak int cpu_mmc_init(bd_t *bis)
Andy Fleming272cc702008-10-30 16:41:01 -05001381{
1382 return -1;
1383}
1384
Jeroen Hofsteecee9ab72014-07-10 22:46:28 +02001385/* board-specific MMC initializations. */
1386__weak int board_mmc_init(bd_t *bis)
1387{
1388 return -1;
1389}
Andy Fleming272cc702008-10-30 16:41:01 -05001390
Paul Burton56196822013-09-04 16:12:25 +01001391#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
1392
Andy Fleming272cc702008-10-30 16:41:01 -05001393void print_mmc_devices(char separator)
1394{
1395 struct mmc *m;
1396 struct list_head *entry;
1397
1398 list_for_each(entry, &mmc_devices) {
1399 m = list_entry(entry, struct mmc, link);
1400
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001401 printf("%s: %d", m->cfg->name, m->block_dev.dev);
Andy Fleming272cc702008-10-30 16:41:01 -05001402
1403 if (entry->next != &mmc_devices)
1404 printf("%c ", separator);
1405 }
1406
1407 printf("\n");
1408}
1409
Paul Burton56196822013-09-04 16:12:25 +01001410#else
1411void print_mmc_devices(char separator) { }
1412#endif
1413
Lei Wenea6ebe22011-05-02 16:26:25 +00001414int get_mmc_num(void)
1415{
1416 return cur_dev_num;
1417}
1418
Che-Liang Chioue9550442012-11-28 15:21:13 +00001419void mmc_set_preinit(struct mmc *mmc, int preinit)
1420{
1421 mmc->preinit = preinit;
1422}
1423
1424static void do_preinit(void)
1425{
1426 struct mmc *m;
1427 struct list_head *entry;
1428
1429 list_for_each(entry, &mmc_devices) {
1430 m = list_entry(entry, struct mmc, link);
1431
1432 if (m->preinit)
1433 mmc_start_init(m);
1434 }
1435}
1436
1437
Andy Fleming272cc702008-10-30 16:41:01 -05001438int mmc_initialize(bd_t *bis)
1439{
1440 INIT_LIST_HEAD (&mmc_devices);
1441 cur_dev_num = 0;
1442
1443 if (board_mmc_init(bis) < 0)
1444 cpu_mmc_init(bis);
1445
Ying Zhangbb0dc102013-08-16 15:16:11 +08001446#ifndef CONFIG_SPL_BUILD
Andy Fleming272cc702008-10-30 16:41:01 -05001447 print_mmc_devices(',');
Ying Zhangbb0dc102013-08-16 15:16:11 +08001448#endif
Andy Fleming272cc702008-10-30 16:41:01 -05001449
Che-Liang Chioue9550442012-11-28 15:21:13 +00001450 do_preinit();
Andy Fleming272cc702008-10-30 16:41:01 -05001451 return 0;
1452}
Amar3690d6d2013-04-27 11:42:58 +05301453
1454#ifdef CONFIG_SUPPORT_EMMC_BOOT
1455/*
1456 * This function changes the size of boot partition and the size of rpmb
1457 * partition present on EMMC devices.
1458 *
1459 * Input Parameters:
1460 * struct *mmc: pointer for the mmc device strcuture
1461 * bootsize: size of boot partition
1462 * rpmbsize: size of rpmb partition
1463 *
1464 * Returns 0 on success.
1465 */
1466
1467int mmc_boot_partition_size_change(struct mmc *mmc, unsigned long bootsize,
1468 unsigned long rpmbsize)
1469{
1470 int err;
1471 struct mmc_cmd cmd;
1472
1473 /* Only use this command for raw EMMC moviNAND. Enter backdoor mode */
1474 cmd.cmdidx = MMC_CMD_RES_MAN;
1475 cmd.resp_type = MMC_RSP_R1b;
1476 cmd.cmdarg = MMC_CMD62_ARG1;
1477
1478 err = mmc_send_cmd(mmc, &cmd, NULL);
1479 if (err) {
1480 debug("mmc_boot_partition_size_change: Error1 = %d\n", err);
1481 return err;
1482 }
1483
1484 /* Boot partition changing mode */
1485 cmd.cmdidx = MMC_CMD_RES_MAN;
1486 cmd.resp_type = MMC_RSP_R1b;
1487 cmd.cmdarg = MMC_CMD62_ARG2;
1488
1489 err = mmc_send_cmd(mmc, &cmd, NULL);
1490 if (err) {
1491 debug("mmc_boot_partition_size_change: Error2 = %d\n", err);
1492 return err;
1493 }
1494 /* boot partition size is multiple of 128KB */
1495 bootsize = (bootsize * 1024) / 128;
1496
1497 /* Arg: boot partition size */
1498 cmd.cmdidx = MMC_CMD_RES_MAN;
1499 cmd.resp_type = MMC_RSP_R1b;
1500 cmd.cmdarg = bootsize;
1501
1502 err = mmc_send_cmd(mmc, &cmd, NULL);
1503 if (err) {
1504 debug("mmc_boot_partition_size_change: Error3 = %d\n", err);
1505 return err;
1506 }
1507 /* RPMB partition size is multiple of 128KB */
1508 rpmbsize = (rpmbsize * 1024) / 128;
1509 /* Arg: RPMB partition size */
1510 cmd.cmdidx = MMC_CMD_RES_MAN;
1511 cmd.resp_type = MMC_RSP_R1b;
1512 cmd.cmdarg = rpmbsize;
1513
1514 err = mmc_send_cmd(mmc, &cmd, NULL);
1515 if (err) {
1516 debug("mmc_boot_partition_size_change: Error4 = %d\n", err);
1517 return err;
1518 }
1519 return 0;
1520}
1521
1522/*
Tom Rini5a99b9d2014-02-05 10:24:22 -05001523 * Modify EXT_CSD[177] which is BOOT_BUS_WIDTH
1524 * based on the passed in values for BOOT_BUS_WIDTH, RESET_BOOT_BUS_WIDTH
1525 * and BOOT_MODE.
1526 *
1527 * Returns 0 on success.
1528 */
1529int mmc_set_boot_bus_width(struct mmc *mmc, u8 width, u8 reset, u8 mode)
1530{
1531 int err;
1532
1533 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BOOT_BUS_WIDTH,
1534 EXT_CSD_BOOT_BUS_WIDTH_MODE(mode) |
1535 EXT_CSD_BOOT_BUS_WIDTH_RESET(reset) |
1536 EXT_CSD_BOOT_BUS_WIDTH_WIDTH(width));
1537
1538 if (err)
1539 return err;
1540 return 0;
1541}
1542
1543/*
Tom Rini792970b2014-02-05 10:24:21 -05001544 * Modify EXT_CSD[179] which is PARTITION_CONFIG (formerly BOOT_CONFIG)
1545 * based on the passed in values for BOOT_ACK, BOOT_PARTITION_ENABLE and
1546 * PARTITION_ACCESS.
1547 *
1548 * Returns 0 on success.
1549 */
1550int mmc_set_part_conf(struct mmc *mmc, u8 ack, u8 part_num, u8 access)
1551{
1552 int err;
1553
1554 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONF,
1555 EXT_CSD_BOOT_ACK(ack) |
1556 EXT_CSD_BOOT_PART_NUM(part_num) |
1557 EXT_CSD_PARTITION_ACCESS(access));
1558
1559 if (err)
1560 return err;
1561 return 0;
1562}
Tom Rini33ace362014-02-07 14:15:20 -05001563
1564/*
1565 * Modify EXT_CSD[162] which is RST_n_FUNCTION based on the given value
1566 * for enable. Note that this is a write-once field for non-zero values.
1567 *
1568 * Returns 0 on success.
1569 */
1570int mmc_set_rst_n_function(struct mmc *mmc, u8 enable)
1571{
1572 return mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_RST_N_FUNCTION,
1573 enable);
1574}
Amar3690d6d2013-04-27 11:42:58 +05301575#endif