blob: 9dc924c412651f8b9b270a47dcfa5b0698f4c68c [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);
Mario Schuknecht786a27b2014-09-30 17:04:42 +02001137 /* Only compare read only fields */
Lei Wen41378942011-10-03 20:35:11 +00001138 if (!err && ext_csd[EXT_CSD_PARTITIONING_SUPPORT] \
1139 == test_csd[EXT_CSD_PARTITIONING_SUPPORT]
Mario Schuknecht786a27b2014-09-30 17:04:42 +02001140 && ext_csd[EXT_CSD_HC_WP_GRP_SIZE] \
1141 == test_csd[EXT_CSD_HC_WP_GRP_SIZE] \
Lei Wen41378942011-10-03 20:35:11 +00001142 && ext_csd[EXT_CSD_REV] \
1143 == test_csd[EXT_CSD_REV]
1144 && ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] \
1145 == test_csd[EXT_CSD_HC_ERASE_GRP_SIZE]
1146 && memcmp(&ext_csd[EXT_CSD_SEC_CNT], \
1147 &test_csd[EXT_CSD_SEC_CNT], 4) == 0) {
Andy Fleming272cc702008-10-30 16:41:01 -05001148
Andy Fleming7798f6d2012-10-31 19:02:38 +00001149 mmc->card_caps |= ext_to_hostcaps[extw];
Lei Wen41378942011-10-03 20:35:11 +00001150 break;
1151 }
Andy Fleming272cc702008-10-30 16:41:01 -05001152 }
1153
1154 if (mmc->card_caps & MMC_MODE_HS) {
1155 if (mmc->card_caps & MMC_MODE_HS_52MHz)
Jaehoon Chungad5fd922012-03-26 21:16:03 +00001156 mmc->tran_speed = 52000000;
Andy Fleming272cc702008-10-30 16:41:01 -05001157 else
Jaehoon Chungad5fd922012-03-26 21:16:03 +00001158 mmc->tran_speed = 26000000;
1159 }
Andy Fleming272cc702008-10-30 16:41:01 -05001160 }
1161
Jaehoon Chungad5fd922012-03-26 21:16:03 +00001162 mmc_set_clock(mmc, mmc->tran_speed);
1163
Andy Fleming272cc702008-10-30 16:41:01 -05001164 /* fill in device description */
1165 mmc->block_dev.lun = 0;
1166 mmc->block_dev.type = 0;
1167 mmc->block_dev.blksz = mmc->read_bl_len;
Egbert Eich0472fbf2013-04-09 21:11:56 +00001168 mmc->block_dev.log2blksz = LOG2(mmc->block_dev.blksz);
Rabin Vincent9b1f9422009-04-05 13:30:54 +05301169 mmc->block_dev.lba = lldiv(mmc->capacity, mmc->read_bl_len);
Paul Burton56196822013-09-04 16:12:25 +01001170#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
Taylor Huttbabce5f2012-10-20 17:15:59 +00001171 sprintf(mmc->block_dev.vendor, "Man %06x Snr %04x%04x",
1172 mmc->cid[0] >> 24, (mmc->cid[2] & 0xffff),
1173 (mmc->cid[3] >> 16) & 0xffff);
1174 sprintf(mmc->block_dev.product, "%c%c%c%c%c%c", mmc->cid[0] & 0xff,
1175 (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff,
1176 (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff,
1177 (mmc->cid[2] >> 24) & 0xff);
1178 sprintf(mmc->block_dev.revision, "%d.%d", (mmc->cid[2] >> 20) & 0xf,
1179 (mmc->cid[2] >> 16) & 0xf);
Paul Burton56196822013-09-04 16:12:25 +01001180#else
1181 mmc->block_dev.vendor[0] = 0;
1182 mmc->block_dev.product[0] = 0;
1183 mmc->block_dev.revision[0] = 0;
1184#endif
Mikhail Kshevetskiy122efd42012-07-09 08:53:38 +00001185#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBDISK_SUPPORT)
Andy Fleming272cc702008-10-30 16:41:01 -05001186 init_part(&mmc->block_dev);
Mikhail Kshevetskiy122efd42012-07-09 08:53:38 +00001187#endif
Andy Fleming272cc702008-10-30 16:41:01 -05001188
1189 return 0;
1190}
1191
Kim Phillipsfdbb8732012-10-29 13:34:43 +00001192static int mmc_send_if_cond(struct mmc *mmc)
Andy Fleming272cc702008-10-30 16:41:01 -05001193{
1194 struct mmc_cmd cmd;
1195 int err;
1196
1197 cmd.cmdidx = SD_CMD_SEND_IF_COND;
1198 /* We set the bit if the host supports voltages between 2.7 and 3.6 V */
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001199 cmd.cmdarg = ((mmc->cfg->voltages & 0xff8000) != 0) << 8 | 0xaa;
Andy Fleming272cc702008-10-30 16:41:01 -05001200 cmd.resp_type = MMC_RSP_R7;
Andy Fleming272cc702008-10-30 16:41:01 -05001201
1202 err = mmc_send_cmd(mmc, &cmd, NULL);
1203
1204 if (err)
1205 return err;
1206
Rabin Vincent998be3d2009-04-05 13:30:56 +05301207 if ((cmd.response[0] & 0xff) != 0xaa)
Andy Fleming272cc702008-10-30 16:41:01 -05001208 return UNUSABLE_ERR;
1209 else
1210 mmc->version = SD_VERSION_2;
1211
1212 return 0;
1213}
1214
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001215/* not used any more */
1216int __deprecated mmc_register(struct mmc *mmc)
Andy Fleming272cc702008-10-30 16:41:01 -05001217{
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001218#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
1219 printf("%s is deprecated! use mmc_create() instead.\n", __func__);
1220#endif
1221 return -1;
1222}
1223
1224struct mmc *mmc_create(const struct mmc_config *cfg, void *priv)
1225{
1226 struct mmc *mmc;
1227
1228 /* quick validation */
1229 if (cfg == NULL || cfg->ops == NULL || cfg->ops->send_cmd == NULL ||
1230 cfg->f_min == 0 || cfg->f_max == 0 || cfg->b_max == 0)
1231 return NULL;
1232
1233 mmc = calloc(1, sizeof(*mmc));
1234 if (mmc == NULL)
1235 return NULL;
1236
1237 mmc->cfg = cfg;
1238 mmc->priv = priv;
1239
1240 /* the following chunk was mmc_register() */
1241
Markus Niebelab711882013-12-16 13:40:46 +01001242 /* Setup dsr related values */
1243 mmc->dsr_imp = 0;
1244 mmc->dsr = 0xffffffff;
Andy Fleming272cc702008-10-30 16:41:01 -05001245 /* Setup the universal parts of the block interface just once */
1246 mmc->block_dev.if_type = IF_TYPE_MMC;
1247 mmc->block_dev.dev = cur_dev_num++;
1248 mmc->block_dev.removable = 1;
1249 mmc->block_dev.block_read = mmc_bread;
1250 mmc->block_dev.block_write = mmc_bwrite;
Lei Wene6f99a52011-06-22 17:03:31 +00001251 mmc->block_dev.block_erase = mmc_berase;
Andy Fleming272cc702008-10-30 16:41:01 -05001252
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001253 /* setup initial part type */
1254 mmc->block_dev.part_type = mmc->cfg->part_type;
Andy Fleming272cc702008-10-30 16:41:01 -05001255
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001256 INIT_LIST_HEAD(&mmc->link);
Andy Fleming272cc702008-10-30 16:41:01 -05001257
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001258 list_add_tail(&mmc->link, &mmc_devices);
1259
1260 return mmc;
1261}
1262
1263void mmc_destroy(struct mmc *mmc)
1264{
1265 /* only freeing memory for now */
1266 free(mmc);
Andy Fleming272cc702008-10-30 16:41:01 -05001267}
1268
Matthew McClintockdf3fc522011-05-24 05:31:19 +00001269#ifdef CONFIG_PARTITIONS
Andy Fleming272cc702008-10-30 16:41:01 -05001270block_dev_desc_t *mmc_get_dev(int dev)
1271{
1272 struct mmc *mmc = find_mmc_device(dev);
Benoît Thébaudeau6bb4b4b2012-08-10 08:59:12 +00001273 if (!mmc || mmc_init(mmc))
Łukasz Majewski40242bc2012-04-19 02:39:18 +00001274 return NULL;
Andy Fleming272cc702008-10-30 16:41:01 -05001275
Łukasz Majewski40242bc2012-04-19 02:39:18 +00001276 return &mmc->block_dev;
Andy Fleming272cc702008-10-30 16:41:01 -05001277}
Matthew McClintockdf3fc522011-05-24 05:31:19 +00001278#endif
Andy Fleming272cc702008-10-30 16:41:01 -05001279
Paul Kocialkowski95de9ab2014-11-08 20:55:45 +01001280/* board-specific MMC power initializations. */
1281__weak void board_mmc_power_init(void)
1282{
1283}
1284
Che-Liang Chioue9550442012-11-28 15:21:13 +00001285int mmc_start_init(struct mmc *mmc)
Andy Fleming272cc702008-10-30 16:41:01 -05001286{
Macpaul Linafd59322011-11-14 23:35:39 +00001287 int err;
Andy Fleming272cc702008-10-30 16:41:01 -05001288
Pantelis Antoniouab769f22014-02-26 19:28:45 +02001289 /* we pretend there's no card when init is NULL */
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001290 if (mmc_getcd(mmc) == 0 || mmc->cfg->ops->init == NULL) {
Thierry Reding48972d92012-01-02 01:15:37 +00001291 mmc->has_init = 0;
Paul Burton56196822013-09-04 16:12:25 +01001292#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
Thierry Reding48972d92012-01-02 01:15:37 +00001293 printf("MMC: no card present\n");
Paul Burton56196822013-09-04 16:12:25 +01001294#endif
Thierry Reding48972d92012-01-02 01:15:37 +00001295 return NO_CARD_ERR;
1296 }
1297
Lei Wenbc897b12011-05-02 16:26:26 +00001298 if (mmc->has_init)
1299 return 0;
1300
Paul Kocialkowski95de9ab2014-11-08 20:55:45 +01001301 board_mmc_power_init();
1302
Pantelis Antoniouab769f22014-02-26 19:28:45 +02001303 /* made sure it's not NULL earlier */
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001304 err = mmc->cfg->ops->init(mmc);
Andy Fleming272cc702008-10-30 16:41:01 -05001305
1306 if (err)
1307 return err;
1308
Ilya Yanokb86b85e2009-06-29 17:53:16 +04001309 mmc_set_bus_width(mmc, 1);
1310 mmc_set_clock(mmc, 1);
1311
Andy Fleming272cc702008-10-30 16:41:01 -05001312 /* Reset the Card */
1313 err = mmc_go_idle(mmc);
1314
1315 if (err)
1316 return err;
1317
Lei Wenbc897b12011-05-02 16:26:26 +00001318 /* The internal partition reset to user partition(0) at every CMD0*/
1319 mmc->part_num = 0;
1320
Andy Fleming272cc702008-10-30 16:41:01 -05001321 /* Test for SD version 2 */
Macpaul Linafd59322011-11-14 23:35:39 +00001322 err = mmc_send_if_cond(mmc);
Andy Fleming272cc702008-10-30 16:41:01 -05001323
Andy Fleming272cc702008-10-30 16:41:01 -05001324 /* Now try to get the SD card's operating condition */
1325 err = sd_send_op_cond(mmc);
1326
1327 /* If the command timed out, we check for an MMC card */
1328 if (err == TIMEOUT) {
1329 err = mmc_send_op_cond(mmc);
1330
Che-Liang Chioue9550442012-11-28 15:21:13 +00001331 if (err && err != IN_PROGRESS) {
Paul Burton56196822013-09-04 16:12:25 +01001332#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
Andy Fleming272cc702008-10-30 16:41:01 -05001333 printf("Card did not respond to voltage select!\n");
Paul Burton56196822013-09-04 16:12:25 +01001334#endif
Andy Fleming272cc702008-10-30 16:41:01 -05001335 return UNUSABLE_ERR;
1336 }
1337 }
1338
Che-Liang Chioue9550442012-11-28 15:21:13 +00001339 if (err == IN_PROGRESS)
1340 mmc->init_in_progress = 1;
1341
1342 return err;
1343}
1344
1345static int mmc_complete_init(struct mmc *mmc)
1346{
1347 int err = 0;
1348
1349 if (mmc->op_cond_pending)
1350 err = mmc_complete_op_cond(mmc);
1351
1352 if (!err)
1353 err = mmc_startup(mmc);
Lei Wenbc897b12011-05-02 16:26:26 +00001354 if (err)
1355 mmc->has_init = 0;
1356 else
1357 mmc->has_init = 1;
Che-Liang Chioue9550442012-11-28 15:21:13 +00001358 mmc->init_in_progress = 0;
1359 return err;
1360}
1361
1362int mmc_init(struct mmc *mmc)
1363{
1364 int err = IN_PROGRESS;
Mateusz Zalegad803fea2014-04-29 20:15:30 +02001365 unsigned start;
Che-Liang Chioue9550442012-11-28 15:21:13 +00001366
1367 if (mmc->has_init)
1368 return 0;
Mateusz Zalegad803fea2014-04-29 20:15:30 +02001369
1370 start = get_timer(0);
1371
Che-Liang Chioue9550442012-11-28 15:21:13 +00001372 if (!mmc->init_in_progress)
1373 err = mmc_start_init(mmc);
1374
1375 if (!err || err == IN_PROGRESS)
1376 err = mmc_complete_init(mmc);
1377 debug("%s: %d, time %lu\n", __func__, err, get_timer(start));
Lei Wenbc897b12011-05-02 16:26:26 +00001378 return err;
Andy Fleming272cc702008-10-30 16:41:01 -05001379}
1380
Markus Niebelab711882013-12-16 13:40:46 +01001381int mmc_set_dsr(struct mmc *mmc, u16 val)
1382{
1383 mmc->dsr = val;
1384 return 0;
1385}
1386
Jeroen Hofsteecee9ab72014-07-10 22:46:28 +02001387/* CPU-specific MMC initializations */
1388__weak int cpu_mmc_init(bd_t *bis)
Andy Fleming272cc702008-10-30 16:41:01 -05001389{
1390 return -1;
1391}
1392
Jeroen Hofsteecee9ab72014-07-10 22:46:28 +02001393/* board-specific MMC initializations. */
1394__weak int board_mmc_init(bd_t *bis)
1395{
1396 return -1;
1397}
Andy Fleming272cc702008-10-30 16:41:01 -05001398
Paul Burton56196822013-09-04 16:12:25 +01001399#if !defined(CONFIG_SPL_BUILD) || defined(CONFIG_SPL_LIBCOMMON_SUPPORT)
1400
Andy Fleming272cc702008-10-30 16:41:01 -05001401void print_mmc_devices(char separator)
1402{
1403 struct mmc *m;
1404 struct list_head *entry;
1405
1406 list_for_each(entry, &mmc_devices) {
1407 m = list_entry(entry, struct mmc, link);
1408
Pantelis Antoniou93bfd612014-03-11 19:34:20 +02001409 printf("%s: %d", m->cfg->name, m->block_dev.dev);
Andy Fleming272cc702008-10-30 16:41:01 -05001410
Lubomir Popove75eaf12014-11-11 12:25:42 +02001411 if (entry->next != &mmc_devices) {
1412 printf("%c", separator);
1413 if (separator != '\n')
1414 puts (" ");
1415 }
Andy Fleming272cc702008-10-30 16:41:01 -05001416 }
1417
1418 printf("\n");
1419}
1420
Paul Burton56196822013-09-04 16:12:25 +01001421#else
1422void print_mmc_devices(char separator) { }
1423#endif
1424
Lei Wenea6ebe22011-05-02 16:26:25 +00001425int get_mmc_num(void)
1426{
1427 return cur_dev_num;
1428}
1429
Che-Liang Chioue9550442012-11-28 15:21:13 +00001430void mmc_set_preinit(struct mmc *mmc, int preinit)
1431{
1432 mmc->preinit = preinit;
1433}
1434
1435static void do_preinit(void)
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
1443 if (m->preinit)
1444 mmc_start_init(m);
1445 }
1446}
1447
1448
Andy Fleming272cc702008-10-30 16:41:01 -05001449int mmc_initialize(bd_t *bis)
1450{
1451 INIT_LIST_HEAD (&mmc_devices);
1452 cur_dev_num = 0;
1453
1454 if (board_mmc_init(bis) < 0)
1455 cpu_mmc_init(bis);
1456
Ying Zhangbb0dc102013-08-16 15:16:11 +08001457#ifndef CONFIG_SPL_BUILD
Andy Fleming272cc702008-10-30 16:41:01 -05001458 print_mmc_devices(',');
Ying Zhangbb0dc102013-08-16 15:16:11 +08001459#endif
Andy Fleming272cc702008-10-30 16:41:01 -05001460
Che-Liang Chioue9550442012-11-28 15:21:13 +00001461 do_preinit();
Andy Fleming272cc702008-10-30 16:41:01 -05001462 return 0;
1463}
Amar3690d6d2013-04-27 11:42:58 +05301464
1465#ifdef CONFIG_SUPPORT_EMMC_BOOT
1466/*
1467 * This function changes the size of boot partition and the size of rpmb
1468 * partition present on EMMC devices.
1469 *
1470 * Input Parameters:
1471 * struct *mmc: pointer for the mmc device strcuture
1472 * bootsize: size of boot partition
1473 * rpmbsize: size of rpmb partition
1474 *
1475 * Returns 0 on success.
1476 */
1477
1478int mmc_boot_partition_size_change(struct mmc *mmc, unsigned long bootsize,
1479 unsigned long rpmbsize)
1480{
1481 int err;
1482 struct mmc_cmd cmd;
1483
1484 /* Only use this command for raw EMMC moviNAND. Enter backdoor mode */
1485 cmd.cmdidx = MMC_CMD_RES_MAN;
1486 cmd.resp_type = MMC_RSP_R1b;
1487 cmd.cmdarg = MMC_CMD62_ARG1;
1488
1489 err = mmc_send_cmd(mmc, &cmd, NULL);
1490 if (err) {
1491 debug("mmc_boot_partition_size_change: Error1 = %d\n", err);
1492 return err;
1493 }
1494
1495 /* Boot partition changing mode */
1496 cmd.cmdidx = MMC_CMD_RES_MAN;
1497 cmd.resp_type = MMC_RSP_R1b;
1498 cmd.cmdarg = MMC_CMD62_ARG2;
1499
1500 err = mmc_send_cmd(mmc, &cmd, NULL);
1501 if (err) {
1502 debug("mmc_boot_partition_size_change: Error2 = %d\n", err);
1503 return err;
1504 }
1505 /* boot partition size is multiple of 128KB */
1506 bootsize = (bootsize * 1024) / 128;
1507
1508 /* Arg: boot partition size */
1509 cmd.cmdidx = MMC_CMD_RES_MAN;
1510 cmd.resp_type = MMC_RSP_R1b;
1511 cmd.cmdarg = bootsize;
1512
1513 err = mmc_send_cmd(mmc, &cmd, NULL);
1514 if (err) {
1515 debug("mmc_boot_partition_size_change: Error3 = %d\n", err);
1516 return err;
1517 }
1518 /* RPMB partition size is multiple of 128KB */
1519 rpmbsize = (rpmbsize * 1024) / 128;
1520 /* Arg: RPMB partition size */
1521 cmd.cmdidx = MMC_CMD_RES_MAN;
1522 cmd.resp_type = MMC_RSP_R1b;
1523 cmd.cmdarg = rpmbsize;
1524
1525 err = mmc_send_cmd(mmc, &cmd, NULL);
1526 if (err) {
1527 debug("mmc_boot_partition_size_change: Error4 = %d\n", err);
1528 return err;
1529 }
1530 return 0;
1531}
1532
1533/*
Tom Rini5a99b9d2014-02-05 10:24:22 -05001534 * Modify EXT_CSD[177] which is BOOT_BUS_WIDTH
1535 * based on the passed in values for BOOT_BUS_WIDTH, RESET_BOOT_BUS_WIDTH
1536 * and BOOT_MODE.
1537 *
1538 * Returns 0 on success.
1539 */
1540int mmc_set_boot_bus_width(struct mmc *mmc, u8 width, u8 reset, u8 mode)
1541{
1542 int err;
1543
1544 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BOOT_BUS_WIDTH,
1545 EXT_CSD_BOOT_BUS_WIDTH_MODE(mode) |
1546 EXT_CSD_BOOT_BUS_WIDTH_RESET(reset) |
1547 EXT_CSD_BOOT_BUS_WIDTH_WIDTH(width));
1548
1549 if (err)
1550 return err;
1551 return 0;
1552}
1553
1554/*
Tom Rini792970b2014-02-05 10:24:21 -05001555 * Modify EXT_CSD[179] which is PARTITION_CONFIG (formerly BOOT_CONFIG)
1556 * based on the passed in values for BOOT_ACK, BOOT_PARTITION_ENABLE and
1557 * PARTITION_ACCESS.
1558 *
1559 * Returns 0 on success.
1560 */
1561int mmc_set_part_conf(struct mmc *mmc, u8 ack, u8 part_num, u8 access)
1562{
1563 int err;
1564
1565 err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONF,
1566 EXT_CSD_BOOT_ACK(ack) |
1567 EXT_CSD_BOOT_PART_NUM(part_num) |
1568 EXT_CSD_PARTITION_ACCESS(access));
1569
1570 if (err)
1571 return err;
1572 return 0;
1573}
Tom Rini33ace362014-02-07 14:15:20 -05001574
1575/*
1576 * Modify EXT_CSD[162] which is RST_n_FUNCTION based on the given value
1577 * for enable. Note that this is a write-once field for non-zero values.
1578 *
1579 * Returns 0 on success.
1580 */
1581int mmc_set_rst_n_function(struct mmc *mmc, u8 enable)
1582{
1583 return mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_RST_N_FUNCTION,
1584 enable);
1585}
Amar3690d6d2013-04-27 11:42:58 +05301586#endif