blob: d72fe7cb90139a107940c3f401eb7ff6da8dea8a [file] [log] [blame]
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -07001/* Copyright (c) 2013, The Linux Foundation. All rights reserved.
2 *
3 * Redistribution and use in source and binary forms, with or without
4 * modification, are permitted provided that the following conditions are
5 * met:
6 * * Redistributions of source code must retain the above copyright
7 * notice, this list of conditions and the following disclaimer.
8 * * Redistributions in binary form must reproduce the above
9 * copyright notice, this list of conditions and the following
10 * disclaimer in the documentation and/or other materials provided
11 * with the distribution.
12 * * Neither the name of The Linux Foundation nor the names of its
13 * contributors may be used to endorse or promote products derived
14 * from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
23 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
25 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
26 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#include <string.h>
30#include <stdlib.h>
31#include <debug.h>
32#include <reg.h>
33#include <mmc_sdhci.h>
34#include <sdhci.h>
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -070035#include <sdhci_msm.h>
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -070036#include <partition_parser.h>
37#include <platform/iomap.h>
38#include <platform/timer.h>
39
40extern void clock_init_mmc(uint32_t);
41extern void clock_config_mmc(uint32_t, uint32_t);
42
43/* data access time unit in ns */
44static const uint32_t taac_unit[] =
45{
46 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000
47};
48
49/* data access time value x 10 */
50static const uint32_t taac_value[] =
51{
52 0, 10, 12, 13, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 70, 80
53};
54
55/* data transfer rate in kbit/s */
56static const uint32_t xfer_rate_unit[] =
57{
58 100, 1000, 10000, 100000, 0, 0, 0, 0
59};
60
61/* data transfer rate value x 10*/
62static const uint32_t xfer_rate_value[] =
63{
64 0, 10, 12, 13, 15, 20, 26, 30, 35, 40, 45, 52, 55, 60, 70, 80
65};
66
67/*
68 * Function: mmc decode and save csd
69 * Arg : Card structure & raw csd
70 * Return : 0 on Success, 1 on Failure
71 * Flow : Decodes CSD response received from the card.
72 * Note that we have defined only few of the CSD elements
73 * in csd structure. We'll only decode those values.
74 */
75static uint32_t mmc_decode_and_save_csd(struct mmc_card *card)
76{
77 uint32_t mmc_sizeof = 0;
78 uint32_t mmc_unit = 0;
79 uint32_t mmc_value = 0;
80 uint32_t mmc_temp = 0;
81 uint32_t *raw_csd = card->raw_csd;
82
83 struct mmc_csd mmc_csd;
84
85 mmc_sizeof = sizeof(uint32_t) * 8;
86
87 mmc_csd.cmmc_structure = UNPACK_BITS(raw_csd, 126, 2, mmc_sizeof);
88
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -070089 if (MMC_CARD_SD(card)) {
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -070090 /* Parse CSD according to SD card spec. */
91
92 /* CSD register is little bit differnet for CSD version 2.0 High
93 * Capacity and CSD version 1.0/2.0 Standard memory cards.
94 * In Version 2.0 some of the fields have fixed values and it's
95 * not necessary for host to refer these fields in CSD sent by
96 * card
97 */
98
99 if (mmc_csd.cmmc_structure == 1) {
100 /* CSD Version 2.0 */
101 mmc_csd.card_cmd_class = UNPACK_BITS(raw_csd, 84, 12, mmc_sizeof);
102 /* Fixed value is 9 = 2^9 = 512 */
103 mmc_csd.write_blk_len = 512;
104 /* Fixed value is 9 = 512 */
105 mmc_csd.read_blk_len = 512;
106 /* Fixed value: 010b */
107 mmc_csd.r2w_factor = 0x2;
108 /* Not there in version 2.0 */
109 mmc_csd.c_size_mult = 0;
110 mmc_csd.c_size = UNPACK_BITS(raw_csd, 48, 22, mmc_sizeof);
111 mmc_csd.nsac_clk_cycle = UNPACK_BITS(raw_csd, 104, 8, mmc_sizeof)
112 * 100;
113
114 mmc_unit = UNPACK_BITS(raw_csd, 112, 3, mmc_sizeof);
115 mmc_value = UNPACK_BITS(raw_csd, 115, 4, mmc_sizeof);
116 mmc_csd.taac_ns = (taac_value[mmc_value] * taac_unit[mmc_unit])
117 / 10;
118
119 mmc_csd.erase_blk_len = 1;
120 mmc_csd.read_blk_misalign = 0;
121 mmc_csd.write_blk_misalign = 0;
122 mmc_csd.read_blk_partial = 0;
123 mmc_csd.write_blk_partial = 0;
124
125 mmc_unit = UNPACK_BITS(raw_csd, 96, 3, mmc_sizeof);
126 mmc_value = UNPACK_BITS(raw_csd, 99, 4, mmc_sizeof);
127 mmc_csd.tran_speed = (xfer_rate_value[mmc_value] *
128 xfer_rate_unit[mmc_unit]) / 10;
129
130 mmc_csd.wp_grp_size = 0x0;
131 mmc_csd.wp_grp_enable = 0x0;
132 mmc_csd.perm_wp = UNPACK_BITS(raw_csd, 13, 1, mmc_sizeof);
133 mmc_csd.temp_wp = UNPACK_BITS(raw_csd, 12, 1, mmc_sizeof);
134
135 /* Calculate the card capcity */
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -0700136 card->capacity = (unsigned long long) (1 + mmc_csd.c_size) * 512 * 1024;
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -0700137 } else {
138 /* CSD Version 1.0 */
139 mmc_csd.card_cmd_class = UNPACK_BITS(raw_csd, 84, 12, mmc_sizeof);
140
141 mmc_temp = UNPACK_BITS(raw_csd, 22, 4, mmc_sizeof);
142 mmc_csd.write_blk_len = (mmc_temp > 8 && mmc_temp < 12) ?
143 (1 << mmc_temp) : 512;
144
145 mmc_temp = UNPACK_BITS(raw_csd, 80, 4, mmc_sizeof);
146 mmc_csd.read_blk_len = (mmc_temp > 8 && mmc_temp < 12) ?
147 (1 << mmc_temp) : 512;
148
149 mmc_unit = UNPACK_BITS(raw_csd, 112, 3, mmc_sizeof);
150 mmc_value = UNPACK_BITS(raw_csd, 115, 4, mmc_sizeof);
151 mmc_csd.taac_ns = (taac_value[mmc_value] * taac_unit[mmc_unit])
152 / 10;
153
154 mmc_unit = UNPACK_BITS(raw_csd, 96, 3, mmc_sizeof);
155 mmc_value = UNPACK_BITS(raw_csd, 99, 4, mmc_sizeof);
156 mmc_csd.tran_speed = (xfer_rate_value[mmc_value] *
157 xfer_rate_unit[mmc_unit]) / 10;
158
159 mmc_csd.nsac_clk_cycle = UNPACK_BITS(raw_csd, 104, 8, mmc_sizeof)
160 * 100;
161
162 mmc_csd.r2w_factor = UNPACK_BITS(raw_csd, 26, 3, mmc_sizeof);
163 mmc_csd.sector_size = UNPACK_BITS(raw_csd, 39, 7, mmc_sizeof) + 1;
164
165 mmc_csd.erase_blk_len = UNPACK_BITS(raw_csd, 46, 1, mmc_sizeof);
166 mmc_csd.read_blk_misalign = UNPACK_BITS(raw_csd, 77, 1, mmc_sizeof);
167 mmc_csd.write_blk_misalign = UNPACK_BITS(raw_csd, 78, 1, mmc_sizeof);
168 mmc_csd.read_blk_partial = UNPACK_BITS(raw_csd, 79, 1, mmc_sizeof);
169 mmc_csd.write_blk_partial = UNPACK_BITS(raw_csd, 21, 1, mmc_sizeof);
170
171 mmc_csd.c_size_mult = UNPACK_BITS(raw_csd, 47, 3, mmc_sizeof);
172 mmc_csd.c_size = UNPACK_BITS(raw_csd, 62, 12, mmc_sizeof);
173 mmc_csd.wp_grp_size = UNPACK_BITS(raw_csd, 32, 7, mmc_sizeof);
174 mmc_csd.wp_grp_enable = UNPACK_BITS(raw_csd, 31, 1, mmc_sizeof);
175 mmc_csd.perm_wp = UNPACK_BITS(raw_csd, 13, 1, mmc_sizeof);
176 mmc_csd.temp_wp = UNPACK_BITS(raw_csd, 12, 1, mmc_sizeof);
177
178 /* Calculate the card capacity */
179 mmc_temp = (1 << (mmc_csd.c_size_mult + 2)) * (mmc_csd.c_size + 1);
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -0700180 card->capacity = (unsigned long long)mmc_temp * mmc_csd.read_blk_len;
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -0700181 }
182 } else {
183 /* Parse CSD according to MMC card spec. */
184 mmc_csd.spec_vers = UNPACK_BITS(raw_csd, 122, 4, mmc_sizeof);
185 mmc_csd.card_cmd_class = UNPACK_BITS(raw_csd, 84, 12, mmc_sizeof);
186 mmc_csd.write_blk_len = 1 << UNPACK_BITS(raw_csd, 22, 4, mmc_sizeof);
187 mmc_csd.read_blk_len = 1 << UNPACK_BITS(raw_csd, 80, 4, mmc_sizeof);
188 mmc_csd.r2w_factor = UNPACK_BITS(raw_csd, 26, 3, mmc_sizeof);
189 mmc_csd.c_size_mult = UNPACK_BITS(raw_csd, 47, 3, mmc_sizeof);
190 mmc_csd.c_size = UNPACK_BITS(raw_csd, 62, 12, mmc_sizeof);
191 mmc_csd.nsac_clk_cycle = UNPACK_BITS(raw_csd, 104, 8, mmc_sizeof) * 100;
192
193 mmc_unit = UNPACK_BITS(raw_csd, 112, 3, mmc_sizeof);
194 mmc_value = UNPACK_BITS(raw_csd, 115, 4, mmc_sizeof);
195 mmc_csd.taac_ns = (taac_value[mmc_value] * taac_unit[mmc_unit]) / 10;
196
197 mmc_csd.read_blk_misalign = UNPACK_BITS(raw_csd, 77, 1, mmc_sizeof);
198 mmc_csd.write_blk_misalign = UNPACK_BITS(raw_csd, 78, 1, mmc_sizeof);
199 mmc_csd.read_blk_partial = UNPACK_BITS(raw_csd, 79, 1, mmc_sizeof);
200 mmc_csd.write_blk_partial = UNPACK_BITS(raw_csd, 21, 1, mmc_sizeof);
201
202 /* Ignore -- no use of this value. */
203 mmc_csd.tran_speed = 0x00;
204
205 mmc_csd.erase_grp_size = UNPACK_BITS(raw_csd, 42, 5, mmc_sizeof);
206 mmc_csd.erase_grp_mult = UNPACK_BITS(raw_csd, 37, 5, mmc_sizeof);
207 mmc_csd.wp_grp_size = UNPACK_BITS(raw_csd, 32, 5, mmc_sizeof);
208 mmc_csd.wp_grp_enable = UNPACK_BITS(raw_csd, 31, 1, mmc_sizeof);
209 mmc_csd.perm_wp = UNPACK_BITS(raw_csd, 13, 1, mmc_sizeof);
210 mmc_csd.temp_wp = UNPACK_BITS(raw_csd, 12, 1, mmc_sizeof);
211
212 /* Calculate the card capcity */
213 if (mmc_csd.c_size != 0xFFF) {
214 /* For cards less than or equal to 2GB */
215 mmc_temp = (1 << (mmc_csd.c_size_mult + 2)) * (mmc_csd.c_size + 1);
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -0700216 card->capacity = (unsigned long long) mmc_temp * mmc_csd.read_blk_len;
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -0700217 } else {
218 /* For cards greater than 2GB, Ext CSD register's SEC_COUNT
219 * is used to calculate the size.
220 */
221 uint64_t sec_count;
222
223 sec_count = (card->ext_csd[MMC_SEC_COUNT4] << MMC_SEC_COUNT4_SHIFT)
224 | (card->ext_csd[MMC_SEC_COUNT3] << MMC_SEC_COUNT3_SHIFT)
225 | (card->ext_csd[MMC_SEC_COUNT2] << MMC_SEC_COUNT2_SHIFT)
226 | card->ext_csd[MMC_SEC_COUNT1];
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -0700227 card->capacity = sec_count * MMC_BLK_SZ;
228 }
229 }
230
231 /* save the information in card structure */
232 memcpy((struct mmc_csd *)&card->csd,(struct mmc_csd *)&mmc_csd,
233 sizeof(struct mmc_csd));
234
235 dprintf(SPEW, "Decoded CSD fields:\n");
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -0700236 dprintf(SPEW, "cmmc_structure: %u\n", mmc_csd.cmmc_structure);
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -0700237 dprintf(SPEW, "card_cmd_class: %x\n", mmc_csd.card_cmd_class);
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -0700238 dprintf(SPEW, "write_blk_len: %u\n", mmc_csd.write_blk_len);
239 dprintf(SPEW, "read_blk_len: %u\n", mmc_csd.read_blk_len);
240 dprintf(SPEW, "r2w_factor: %u\n", mmc_csd.r2w_factor);
241 dprintf(SPEW, "sector_size: %u\n", mmc_csd.sector_size);
242 dprintf(SPEW, "c_size_mult:%u\n", mmc_csd.c_size_mult);
243 dprintf(SPEW, "c_size: %u\n", mmc_csd.c_size);
244 dprintf(SPEW, "nsac_clk_cycle: %u\n", mmc_csd.nsac_clk_cycle);
245 dprintf(SPEW, "taac_ns: %u\n", mmc_csd.taac_ns);
246 dprintf(SPEW, "tran_speed: %u kbps\n", mmc_csd.tran_speed);
247 dprintf(SPEW, "erase_blk_len: %u\n", mmc_csd.erase_blk_len);
248 dprintf(SPEW, "read_blk_misalign: %u\n", mmc_csd.read_blk_misalign);
249 dprintf(SPEW, "write_blk_misalign: %u\n", mmc_csd.write_blk_misalign);
250 dprintf(SPEW, "read_blk_partial: %u\n", mmc_csd.read_blk_partial);
251 dprintf(SPEW, "write_blk_partial: %u\n", mmc_csd.write_blk_partial);
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -0700252 dprintf(SPEW, "Card Capacity: %llu Bytes\n", card->capacity);
253
254 return 0;
255}
256
257/*
258 * Function: mmc decode & save cid
259 * Arg : card structure & raw cid
260 * Return : 0 on Success, 1 on Failure
261 * Flow : Decode CID sent by the card.
262 */
263static uint32_t mmc_decode_and_save_cid(struct mmc_card *card,
264 uint32_t *raw_cid)
265{
266 struct mmc_cid mmc_cid;
267 uint32_t mmc_sizeof = 0;
268 int i = 0;
269
270 if (!raw_cid) {
271 return 1;
272 }
273
274 mmc_sizeof = sizeof(uint32_t) * 8;
275
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -0700276 if (MMC_CARD_SD(card)) {
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -0700277 mmc_cid.mid = UNPACK_BITS(raw_cid, 120, 8, mmc_sizeof);
278 mmc_cid.oid = UNPACK_BITS(raw_cid, 104, 16, mmc_sizeof);
279
280 for (i = 0; i < 5; i++) {
281 mmc_cid.pnm[i] = (uint8_t)UNPACK_BITS(raw_cid,
282 (104 - 8 * (i + 1)),
283 8,
284 mmc_sizeof);
285 }
286 mmc_cid.pnm[5] = 0;
287 mmc_cid.pnm[6] = 0;
288
289 mmc_cid.prv = UNPACK_BITS(raw_cid, 56, 8, mmc_sizeof);
David Ng571b8c32013-07-30 19:17:42 -0700290 mmc_cid.psn = UNPACK_BITS(raw_cid, 24, 32, mmc_sizeof);
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -0700291 mmc_cid.month = UNPACK_BITS(raw_cid, 8, 4, mmc_sizeof);
292 mmc_cid.year = UNPACK_BITS(raw_cid, 12, 8, mmc_sizeof);
293 mmc_cid.year += 2000;
294 } else {
295 mmc_cid.mid = UNPACK_BITS(raw_cid, 120, 8, mmc_sizeof);
296 mmc_cid.oid = UNPACK_BITS(raw_cid, 104, 16, mmc_sizeof);
297
298 for (i = 0; i < 6; i++) {
299 mmc_cid.pnm[i] = (uint8_t)UNPACK_BITS(raw_cid, (104 - 8 * (i + 1)),
300 8, mmc_sizeof);
301 }
302 mmc_cid.pnm[6] = 0;
303
304 mmc_cid.prv = UNPACK_BITS(raw_cid, 48, 8, mmc_sizeof);
David Ng571b8c32013-07-30 19:17:42 -0700305 mmc_cid.psn = UNPACK_BITS(raw_cid, 16, 32, mmc_sizeof);
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -0700306 mmc_cid.month = UNPACK_BITS(raw_cid, 8, 4, mmc_sizeof);
307 mmc_cid.year = UNPACK_BITS(raw_cid, 12, 4, mmc_sizeof);
308 mmc_cid.year += 1997;
309 }
310
311 /* save it in card database */
312 memcpy((struct mmc_cid *)&card->cid,
313 (struct mmc_cid *)&mmc_cid, sizeof(struct mmc_cid));
314
315 dprintf(SPEW, "Decoded CID fields:\n");
316 dprintf(SPEW, "Manufacturer ID: %x\n", mmc_cid.mid);
317 dprintf(SPEW, "OEM ID: 0x%x\n", mmc_cid.oid);
318 dprintf(SPEW, "Product Name: %s\n", mmc_cid.pnm);
319 dprintf(SPEW, "Product revision: %d.%d\n", (mmc_cid.prv >> 4),
320 (mmc_cid.prv & 0xF));
321 dprintf(SPEW, "Product serial number: %X\n", mmc_cid.psn);
322 dprintf(SPEW, "Manufacturing date: %d %d\n", mmc_cid.month, mmc_cid.year);
323
324 return 0;
325}
326
327/*
328 * Function: mmc reset cards
329 * Arg : host structure
330 * Return : 0 on Success, 1 on Failure
331 * Flow : Reset all the cards to idle condition (CMD 0)
332 */
333static uint8_t mmc_reset_card(struct sdhci_host *host)
334{
335 struct mmc_command cmd;
336
337 memset((struct mmc_command *)&cmd, 0, sizeof(struct mmc_command));
338
339 cmd.cmd_index = CMD0_GO_IDLE_STATE;
340 cmd.argument = 0;
341 cmd.cmd_type = SDHCI_CMD_TYPE_NORMAL;
342 cmd.resp_type = SDHCI_CMD_RESP_NONE;
343
344 /* send command */
345 return sdhci_send_command(host, &cmd);
346}
347
348/*
349 * Function: mmc operations command
350 * Arg : host & card structure
351 * Return : 0 on Success, 1 on Failure
352 * Flow : Send CMD1 to know whether the card supports host VDD profile or not.
353 */
354static uint32_t mmc_send_op_cond(struct sdhci_host *host, struct mmc_card *card)
355{
356 struct mmc_command cmd;
357 uint32_t mmc_resp = 0;
358 uint32_t mmc_ret = 0;
359 uint32_t mmc_retry = 0;
360
361 memset((struct mmc_command *)&cmd, 0, sizeof(struct mmc_command));
362
363 /* CMD1 format:
364 * [31] Busy bit
365 * [30:29] Access mode
366 * [28:24] reserved
367 * [23:15] 2.7-3.6
368 * [14:8] 2.0-2.6
369 * [7] 1.7-1.95
370 * [6:0] reserved
371 */
372
373 cmd.cmd_index = CMD1_SEND_OP_COND;
374 cmd.argument = card->ocr;
375 cmd.cmd_type = SDHCI_CMD_TYPE_NORMAL;
376 cmd.resp_type = SDHCI_CMD_RESP_R3;
377
378 do {
379 mmc_ret = sdhci_send_command(host, &cmd);
380 if (mmc_ret)
381 return mmc_ret;
382
383 /* Command returned success, now it's time to examine response */
384 mmc_resp = cmd.resp[0];
385
386 /* Check the response for busy status */
387 if (!(mmc_resp & MMC_OCR_BUSY)) {
388 mmc_retry++;
389 mdelay(1);
390 continue;
391 } else
392 break;
393 } while (mmc_retry < MMC_MAX_COMMAND_RETRY);
394
395 /* If we reached here after max retries, we failed to get OCR */
396 if (mmc_retry == MMC_MAX_COMMAND_RETRY && !(mmc_resp & MMC_OCR_BUSY)) {
397 dprintf(CRITICAL, "Card has busy status set. Init did not complete\n");
398 return 1;
399 }
400
401 /* Response contains card's ocr. Update card's information */
402 card->ocr = mmc_resp;
403
404 if (mmc_resp & MMC_OCR_SEC_MODE)
405 card->type = MMC_TYPE_MMCHC;
406 else
407 card->type = MMC_TYPE_STD_MMC;
408
409 return 0;
410}
411
412/*
413 * Function: mmc send cid
414 * Arg : host & card structure
415 * Return : 0 on Success, 1 on Failure
416 * Flow : Request any card to send its uniquie card identification
417 * (CID) number (CMD2).
418 */
419static uint32_t mmc_all_send_cid(struct sdhci_host *host, struct mmc_card *card)
420{
421 struct mmc_command cmd;
422 uint32_t mmc_ret = 0;
423
424 memset((struct mmc_command *)&cmd, 0, sizeof(struct mmc_command));
425
426 /* CMD2 Format:
427 * [31:0] stuff bits
428 */
429 cmd.cmd_index = CMD2_ALL_SEND_CID;
430 cmd.argument = 0;
431 cmd.cmd_type = SDHCI_CMD_TYPE_NORMAL;
432 cmd.resp_type = SDHCI_CMD_RESP_R2;
433
434 /* send command */
435 mmc_ret = sdhci_send_command(host, &cmd);
436 if (mmc_ret) {
437 return mmc_ret;
438 }
439
440 /* Response contains card's 128 bits CID register */
441 mmc_ret = mmc_decode_and_save_cid(card, cmd.resp);
442 if (mmc_ret) {
443 return mmc_ret;
444 }
445
446 return 0;
447}
448
449/*
450 * Function: mmc send relative address
451 * Arg : host & card structure
452 * Return : 0 on Success, 1 on Failure
453 * Flow : Ask card to send it's relative card address (RCA).
454 * This RCA number is shorter than CID and is used by
455 * the host to address the card in future (CMD3)
456 */
457static uint32_t mmc_send_relative_address(struct sdhci_host *host,
458 struct mmc_card *card)
459{
460 struct mmc_command cmd;
461 uint32_t mmc_ret = 0;
462
463 memset((struct mmc_command *)&cmd, 0, sizeof(struct mmc_command));
464
465 /* CMD3 Format:
466 * [31:0] stuff bits
467 */
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -0700468 if (MMC_CARD_SD(card)) {
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -0700469 cmd.cmd_index = CMD3_SEND_RELATIVE_ADDR;
470 cmd.argument = 0;
471 cmd.cmd_type = SDHCI_CMD_TYPE_NORMAL;
472 cmd.resp_type = SDHCI_CMD_RESP_R6;
473
474 /* send command */
475 mmc_ret = sdhci_send_command(host, &cmd);
476 if (mmc_ret)
477 return mmc_ret;
478
479 /* For sD, card will send RCA. Store it */
480 card->rca = (cmd.resp[0] >> 16);
481 } else {
482 cmd.cmd_index = CMD3_SEND_RELATIVE_ADDR;
483 cmd.argument = (MMC_RCA << 16);
484 card->rca = (cmd.argument >> 16);
485 cmd.cmd_type = SDHCI_CMD_TYPE_NORMAL;
486 cmd.resp_type = SDHCI_CMD_RESP_R6;
487
488 /* send command */
489 mmc_ret = sdhci_send_command(host, &cmd);
490 if (mmc_ret)
491 return mmc_ret;
492 }
493
494 return 0;
495}
496
497/*
498 * Function: mmc send csd
499 * Arg : host, card structure & o/p arg to store csd
500 * Return : 0 on Success, 1 on Failure
501 * Flow : Requests card to send it's CSD register's contents. (CMD9)
502 */
503static uint32_t mmc_send_csd(struct sdhci_host *host, struct mmc_card *card)
504{
505 struct mmc_command cmd;
506 uint32_t mmc_arg = 0;
507 uint32_t mmc_ret = 0;
508
509 memset((struct mmc_command *)&cmd, 0, sizeof(struct mmc_command));
510
511 /* CMD9 Format:
512 * [31:16] RCA
513 * [15:0] stuff bits
514 */
515 mmc_arg |= card->rca << 16;
516
517 cmd.cmd_index = CMD9_SEND_CSD;
518 cmd.argument = mmc_arg;
519 cmd.cmd_type = SDHCI_CMD_TYPE_NORMAL;
520 cmd.resp_type = SDHCI_CMD_RESP_R2;
521
522 /* send command */
523 mmc_ret = sdhci_send_command(host, &cmd);
524 if (mmc_ret)
525 return mmc_ret;
526
527 /* response contains the card csd */
528 memcpy(card->raw_csd, cmd.resp, sizeof(cmd.resp));
529
530 return 0;
531}
532
533/*
534 * Function: mmc select card
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -0700535 * Arg : host, card structure
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -0700536 * Return : 0 on Success, 1 on Failure
537 * Flow : Selects a card by sending CMD7 to the card with its RCA.
538 * If RCA field is set as 0 ( or any other address ),
539 * the card will be de-selected. (CMD7)
540 */
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -0700541static uint32_t mmc_select_card(struct sdhci_host *host, struct mmc_card *card)
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -0700542{
543 struct mmc_command cmd;
544 uint32_t mmc_arg = 0;
545 uint32_t mmc_ret = 0;
546
547 memset((struct mmc_command *)&cmd, 0, sizeof(struct mmc_command));
548
549 /* CMD7 Format:
550 * [31:16] RCA
551 * [15:0] stuff bits
552 */
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -0700553 mmc_arg |= card->rca << 16;
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -0700554
555 cmd.cmd_index = CMD7_SELECT_DESELECT_CARD;
556 cmd.argument = mmc_arg;
557 cmd.cmd_type = SDHCI_CMD_TYPE_NORMAL;
558
559 /* If we are deselecting card, we do not get response */
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -0700560 if (card->rca) {
561 if (MMC_CARD_SD(card))
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -0700562 cmd.resp_type = SDHCI_CMD_RESP_R1B;
563 else
564 cmd.resp_type = SDHCI_CMD_RESP_R1;
565 } else
566 cmd.resp_type = SDHCI_CMD_RESP_NONE;
567
568 /* send command */
569 mmc_ret = sdhci_send_command(host, &cmd);
570 if (mmc_ret)
571 return mmc_ret;
572
573 return 0;
574}
575
576/*
577 * Function: mmc set block len
578 * Arg : host, card structure & block length
579 * Return : 0 on Success, 1 on Failure
580 * Flow : Send command to set block length.
581 */
582static uint32_t mmc_set_block_len(struct sdhci_host *host,
583 struct mmc_card *card,
584 uint32_t block_len)
585{
586 struct mmc_command cmd;
587 uint32_t mmc_ret = 0;
588
589 memset((struct mmc_command *)&cmd, 0, sizeof(struct mmc_command));
590
591 /* CMD16 Format:
592 * [31:0] block length
593 */
594
595 cmd.cmd_index = CMD16_SET_BLOCKLEN;
596 cmd.argument = block_len;
597 cmd.cmd_type = SDHCI_CMD_TYPE_NORMAL;
598 cmd.resp_type = SDHCI_CMD_RESP_R1;
599
600 /* send command */
601 mmc_ret = sdhci_send_command(host, &cmd);
602 if (mmc_ret)
603 return mmc_ret;
604
605 /*
606 * If blocklength is larger than 512 bytes,
607 * the card sets BLOCK_LEN_ERROR bit.
608 */
609 if (cmd.resp[0] & MMC_R1_BLOCK_LEN_ERR) {
610 dprintf(CRITICAL, "The block length is not supported by the card\n");
611 return 1;
612 }
613
614 return 0;
615}
616
617/*
618 * Function: mmc get card status
619 * Arg : host, card structure & o/p argument card status
620 * Return : 0 on Success, 1 on Failure
621 * Flow : Get the current status of the card
622 */
623static uint32_t mmc_get_card_status(struct sdhci_host *host,
624 struct mmc_card *card, uint32_t *status)
625{
626 struct mmc_command cmd;
627 uint32_t mmc_ret = 0;
628
629 memset((struct mmc_command *)&cmd, 0, sizeof(struct mmc_command));
630
631 /* CMD13 Format:
632 * [31:16] RCA
633 * [15:0] stuff bits
634 */
635 cmd.cmd_index = CMD13_SEND_STATUS;
636 cmd.argument = card->rca << 16;
637 cmd.cmd_type = SDHCI_CMD_TYPE_NORMAL;
638 cmd.resp_type = SDHCI_CMD_RESP_R1;
639
640 /* send command */
641 mmc_ret = sdhci_send_command(host, &cmd);
642 if (mmc_ret)
643 return mmc_ret;
644
645 /* Checking ADDR_OUT_OF_RANGE error in CMD13 response */
646 if ((cmd.resp[0] >> 31) & 0x01)
647 return 1;
648
649 *status = cmd.resp[0];
650 return 0;
651}
652
653/*
654 * Function: mmc get ext csd
655 * Arg : host, card structure & array to hold ext attributes
656 * Return : 0 on Success, 1 on Failure
657 * Flow : Send ext csd command & get the card attributes
658 */
659static uint32_t mmc_get_ext_csd(struct sdhci_host *host, struct mmc_card *card)
660{
661 struct mmc_command cmd;
662 uint32_t mmc_ret = 0;
663
664 card->ext_csd = memalign(CACHE_LINE, ROUNDUP(512, CACHE_LINE));
665
666 ASSERT(card->ext_csd);
667
668 memset(card->ext_csd, 0, sizeof(card->ext_csd));
669
670 memset((struct mmc_command *)&cmd, 0, sizeof(struct mmc_command));
671
672 /* CMD8 */
673 cmd.cmd_index = CMD8_SEND_EXT_CSD;
674 cmd.cmd_type = SDHCI_CMD_TYPE_NORMAL;
675 cmd.resp_type = SDHCI_CMD_RESP_R1;
676 cmd.data.data_ptr = card->ext_csd;
677 cmd.data.num_blocks = 1;
678 cmd.data_present = 0x1;
679 cmd.trans_mode = SDHCI_MMC_READ;
680
681 /* send command */
682 mmc_ret = sdhci_send_command(host, &cmd);
683 if (mmc_ret)
684 return mmc_ret;
685
686 return mmc_ret;
687}
688
689/*
690 * Function: mmc switch command
691 * Arg : Host, card structure, access mode, index & value to be set
692 * Return : 0 on Success, 1 on Failure
693 * Flow : Send switch command to the card to set the ext attribute @ index
694 */
695static uint32_t mmc_switch_cmd(struct sdhci_host *host, struct mmc_card *card,
696 uint32_t access, uint32_t index, uint32_t value)
697{
698
699 struct mmc_command cmd;
700 uint32_t mmc_ret = 0;
701 uint32_t mmc_status;
702
703 memset((struct mmc_command *)&cmd, 0, sizeof(struct mmc_command));
704
705 /* CMD6 Format:
706 * [31:26] set to 0
707 * [25:24] access
708 * [23:16] index
709 * [15:8] value
710 * [7:3] set to 0
711 * [2:0] cmd set
712 */
713 cmd.cmd_index = CMD6_SWITCH_FUNC;
714 cmd.argument |= (access << 24);
715 cmd.argument |= (index << 16);
716 cmd.argument |= (value << 8);
717 cmd.cmd_type = SDHCI_CMD_TYPE_NORMAL;
718 cmd.resp_type = SDHCI_CMD_RESP_R1B;
719
720 mmc_ret = sdhci_send_command(host, &cmd);
721 if (mmc_ret) {
722 dprintf(CRITICAL, "CMD6 send failed\n");
723 return mmc_ret;
724 }
725
726 /* Check if the card completed the switch command processing */
727 mmc_ret = mmc_get_card_status(host, card, &mmc_status);
728 if (mmc_ret) {
729 dprintf(CRITICAL, "Get card status failed\n");
730 return mmc_ret;
731 }
732
733 if (MMC_CARD_STATUS(mmc_status) != MMC_TRAN_STATE) {
734 dprintf(CRITICAL, "Switch cmd failed. Card not in tran state\n");
735 mmc_ret = 1;
736 }
737
738 if (mmc_status & MMC_SWITCH_FUNC_ERR_FLAG) {
739 dprintf(CRITICAL, "Switch cmd failed. Switch Error.\n");
740 mmc_ret = 1;
741 }
742
743 return mmc_ret;
744}
745
746/*
747 * Function: mmc set bus width
748 * Arg : Host, card structure & width
749 * Return : 0 on Success, 1 on Failure
750 * Flow : Send switch command to set bus width
751 */
752static uint32_t mmc_set_bus_width(struct sdhci_host *host,
753 struct mmc_card *card,
754 uint32_t width)
755{
756 uint32_t mmc_ret = 0;
757
758 mmc_ret = mmc_switch_cmd(host, card, MMC_ACCESS_WRITE,
759 MMC_EXT_MMC_BUS_WIDTH, width);
760
761 if (mmc_ret) {
762 dprintf(CRITICAL, "Switch cmd failed\n");
763 return mmc_ret;
764 }
765
766 return 0;
767}
768
769
770/*
771 * Function: mmc card supports ddr mode
772 * Arg : None
773 * Return : 1 if DDR mode is supported, 0 otherwise
774 * Flow : Check the ext csd attributes of the card
775 */
776static uint8_t mmc_card_supports_hs200_mode(struct mmc_card *card)
777{
778 if (card->ext_csd[MMC_DEVICE_TYPE] & MMC_HS_HS200_MODE)
779 return 1;
780 else
781 return 0;
782}
783
784/*
785 * Function: mmc card supports ddr mode
786 * Arg : None
787 * Return : 1 if DDR mode is supported, 0 otherwise
788 * Flow : Check the ext csd attributes of the card
789 */
790static uint8_t mmc_card_supports_ddr_mode(struct mmc_card *card)
791{
792 if (card->ext_csd[MMC_DEVICE_TYPE] & MMC_HS_DDR_MODE)
793 return 1;
794 else
795 return 0;
796}
797
798/*
799 * Function : Enable HS200 mode
800 * Arg : Host, card structure and bus width
801 * Return : 0 on Success, 1 on Failure
802 * Flow :
803 * - Set the bus width to 4/8 bit SDR as supported by the target & host
804 * - Set the HS_TIMING on ext_csd 185 for the card
805 */
806static uint32_t mmc_set_hs200_mode(struct sdhci_host *host,
807 struct mmc_card *card, uint32_t width)
808{
809 uint32_t mmc_ret = 0;
810
811 /* Set 4/8 bit SDR bus width */
812 mmc_ret = mmc_set_bus_width(host, card, width);
813 if (mmc_ret) {
814 dprintf(CRITICAL, "Failure to set wide bus for Card(RCA:%x)\n",
815 card->rca);
816 return mmc_ret;
817 }
818
819 /* Setting HS200 in HS_TIMING using EXT_CSD (CMD6) */
820 mmc_ret = mmc_switch_cmd(host, card, MMC_ACCESS_WRITE, MMC_EXT_MMC_HS_TIMING, MMC_HS200_TIMING);
821
822 if (mmc_ret) {
823 dprintf(CRITICAL, "Switch cmd returned failure %d\n", __LINE__);
824 return mmc_ret;
825 }
826
827 /* Enable hs200 mode in controller */
828 sdhci_set_sdr_mode(host);
829
830 return mmc_ret;
831}
832
833/*
834 * Function: mmc set ddr mode
835 * Arg : Host & card structure
836 * Return : 0 on Success, 1 on Failure
837 * Flow : Set bus width for ddr mode & set controller in DDR mode
838*/
839static uint8_t mmc_set_ddr_mode(struct sdhci_host *host, struct mmc_card *card)
840{
841 uint8_t mmc_ret = 0;
842
843 /* Set width for 8 bit DDR mode by default */
844 mmc_ret = mmc_set_bus_width(host, card, DATA_DDR_BUS_WIDTH_8BIT);
845
846 if (mmc_ret) {
847 dprintf(CRITICAL, "Failure to set DDR mode for Card(RCA:%x)\n",
848 card->rca);
849 return mmc_ret;
850 }
851
852 sdhci_set_ddr_mode(host);
853
854 return 0;
855}
856
857/*
858 * Function: mmc set high speed interface
859 * Arg : Host & card structure
860 * Return : None
861 * Flow : Sets the sdcc clock & clock divider in the host controller
862 * Adjust the interface speed to optimal speed
863 */
864static uint32_t mmc_set_hs_interface(struct sdhci_host *host,
865 struct mmc_card *card)
866{
867 uint32_t mmc_ret = 0;
868
869 /* Setting HS_TIMING in EXT_CSD (CMD6) */
870 mmc_ret = mmc_switch_cmd(host, card, MMC_ACCESS_WRITE,
871 MMC_EXT_MMC_HS_TIMING, MMC_HS_TIMING);
872
873 if (mmc_ret) {
874 dprintf(CRITICAL, "Switch cmd returned failure %d\n", __LINE__);
875 return mmc_ret;
876 }
877
878 return 0;
879}
880
881/*
882 * Function: mmc_host_init
883 * Arg : mmc device structure
884 * Return : 0 on success, 1 on Failure
885 * Flow : Initialize the host contoller
886 * Set the clock rate to 400 KHZ for init
887 */
888static uint8_t mmc_host_init(struct mmc_device *dev)
889{
890 uint8_t mmc_ret = 0;
891
892 struct sdhci_host *host;
893 struct mmc_config_data *cfg;
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -0700894 struct sdhci_msm_data data;
895
896 event_t sdhc_event;
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -0700897
898 host = &dev->host;
899 cfg = &dev->config;
900
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -0700901 event_init(&sdhc_event, false, EVENT_FLAG_AUTOUNSIGNAL);
902
903 host->base = cfg->sdhc_base;
904 host->sdhc_event = &sdhc_event;
905
906 data.sdhc_event = &sdhc_event;
907 data.pwrctl_base = cfg->pwrctl_base;
908 data.pwr_irq = cfg->pwr_irq;
909
Channagoud Kadabi4b2f9672013-08-08 17:44:03 -0700910 /* Initialize any clocks needed for SDC controller */
911 clock_init_mmc(cfg->slot);
912
913 clock_config_mmc(cfg->slot, cfg->max_clk_rate);
914
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -0700915 /*
916 * MSM specific sdhc init
917 */
918 sdhci_msm_init(&data);
919
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -0700920 /*
921 * Initialize the controller, read the host capabilities
922 * set power on mode
923 */
924 sdhci_init(host);
925
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -0700926 /* Setup initial freq to 400KHz */
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -0700927 mmc_ret = sdhci_clk_supply(host, SDHCI_CLK_400KHZ);
928
929 return mmc_ret;
930}
931
932/*
933 * Function: mmc identify card
934 * Arg : host & card structure
935 * Return : 0 on Success, 1 on Failure
936 * Flow : Performs card identification process:
937 * 1. Get card's unique identification number (CID)
938 * 2. Get(for sd)/set (for mmc) relative card address (RCA)
939 * 3. Select the card to put it in TRAN state
940 */
941static uint32_t mmc_identify_card(struct sdhci_host *host, struct mmc_card *card)
942{
943 uint32_t mmc_return = 0;
944 uint32_t raw_csd[4];
945
946 /* Ask card to send its unique card identification (CID) number (CMD2) */
947 mmc_return = mmc_all_send_cid(host, card);
948 if (mmc_return) {
949 dprintf(CRITICAL,"Failure getting card's CID number!\n");
950 return mmc_return;
951 }
952
953 /* Ask card to send a relative card address (RCA) (CMD3) */
954 mmc_return = mmc_send_relative_address(host, card);
955 if (mmc_return) {
956 dprintf(CRITICAL, "Failure getting card's RCA!\n");
957 return mmc_return;
958 }
959
960 /* Get card's CSD register (CMD9) */
961 mmc_return = mmc_send_csd(host, card);
962 if (mmc_return) {
963 dprintf(CRITICAL,"Failure getting card's CSD information!\n");
964 return mmc_return;
965 }
966
967 /* Select the card (CMD7) */
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -0700968 mmc_return = mmc_select_card(host, card);
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -0700969 if (mmc_return) {
970 dprintf(CRITICAL, "Failure selecting the Card with RCA: %x\n",card->rca);
971 return mmc_return;
972 }
973
974 /* Set the card status as active */
975 card->status = MMC_STATUS_ACTIVE;
976
977 return 0;
978}
979
980/*
981 * Function: mmc_reset_card_and_send_op
982 * Arg : Host & Card structure
983 * Return : 0 on Success, 1 on Failure
984 * Flow : Routine to initialize MMC card. It resets a card to idle state,
985 * verify operating voltage and set the card in ready state.
986 */
987static uint32_t mmc_reset_card_and_send_op(struct sdhci_host *host, struct mmc_card *card)
988{
989 uint32_t mmc_return = 0;
990
991 /* 1. Card Reset - CMD0 */
992 mmc_return = mmc_reset_card(host);
993 if (mmc_return) {
994 dprintf(CRITICAL, "Failure resetting MMC cards!\n");
995 return mmc_return;
996 }
997
998 /* 2. Card Initialization process */
999
1000 /*
1001 * Send CMD1 to identify and reject cards that do not match host's VDD range
1002 * profile. Cards sends its OCR register in response.
1003 */
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -07001004
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -07001005 mmc_return = mmc_send_op_cond(host, card);
1006
1007 /* OCR is not received, init could not complete */
1008 if (mmc_return) {
1009 dprintf(CRITICAL, "Failure getting OCR response from MMC Card\n");
1010 return mmc_return;
1011 }
1012
1013 return 0;
1014}
1015
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -07001016static uint32_t mmc_send_app_cmd(struct sdhci_host *host, struct mmc_card *card)
1017{
1018 struct mmc_command cmd = {0};
1019
1020 cmd.cmd_index = CMD55_APP_CMD;
1021 cmd.argument = (card->rca << 16);
1022 cmd.cmd_type = SDHCI_CMD_TYPE_NORMAL;
1023 cmd.resp_type = SDHCI_CMD_RESP_R1;
1024
1025 if (sdhci_send_command(host, &cmd))
1026 {
1027 dprintf(CRITICAL, "Failed Sending CMD55\n");
1028 return 1;
1029 }
1030 return 0;
1031}
1032
1033uint32_t mmc_sd_card_init(struct sdhci_host *host, struct mmc_card *card)
1034{
1035 uint8_t i;
1036 uint32_t mmc_ret;
1037 struct mmc_command cmd;
1038
1039 memset((struct mmc_command *)&cmd, 0, sizeof(struct mmc_command));
1040
1041 /* Use the SD card RCA 0x0 during init */
1042 card->rca = SD_CARD_RCA;
1043
1044 /* Send CMD8 for voltage check*/
1045 for (i = 0 ;i < SD_CMD8_MAX_RETRY; i++)
1046 {
1047 cmd.cmd_index = CMD8_SEND_IF_COND;
1048 cmd.argument = MMC_SD_HC_VOLT_SUPPLIED;
1049 cmd.cmd_type = SDHCI_CMD_TYPE_NORMAL;
1050 cmd.resp_type = SDHCI_CMD_RESP_R7;
1051
1052 if (sdhci_send_command(host, &cmd))
1053 {
1054 dprintf(CRITICAL, "The response for CMD8 does not match the supplied value\n");
1055 return 1;
1056 }
1057 else
1058 {
1059 /* If the command response echos the voltage back */
1060 if (cmd.resp[0] == MMC_SD_HC_VOLT_SUPPLIED)
1061 break;
1062 }
1063 /* As per SDCC the spec try for max three times with
1064 * 1 ms delay
1065 */
1066 mdelay(1);
1067 }
1068
1069 if (i == SD_CMD8_MAX_RETRY && (cmd.resp[0] != MMC_SD_HC_VOLT_SUPPLIED))
1070 {
1071 dprintf(CRITICAL, "Error: CMD8 response timed out\n");
1072 return 1;
1073 }
1074
1075 /* Send ACMD41 for OCR */
1076 for (i = 0; i < SD_ACMD41_MAX_RETRY; i++)
1077 {
1078 /* Send APP_CMD before ACMD41*/
1079 if (mmc_send_app_cmd(host, card))
1080 {
1081 dprintf(CRITICAL, "Failed sending App command\n");
1082 return 1;
1083 }
1084
1085 /* APP_CMD is successful, send ACMD41 now */
1086 cmd.cmd_index = ACMD41_SEND_OP_COND;
1087 cmd.argument = MMC_SD_OCR | MMC_SD_HC_HCS;
1088 cmd.cmd_type = SDHCI_CMD_TYPE_NORMAL;
1089 cmd.resp_type = SDHCI_CMD_RESP_R3;
1090
1091 if (sdhci_send_command(host, &cmd))
1092 {
1093 dprintf(CRITICAL, "Failure sending ACMD41\n");
1094 return 1;
1095 }
1096 else
1097 {
1098 if (cmd.resp[0] & MMC_SD_DEV_READY)
1099 {
1100 if (cmd.resp[0] & (1 << 30))
1101 card->type = MMC_CARD_TYPE_SDHC;
1102 else
1103 card->type = MMC_CARD_TYPE_STD_SD;
1104
1105 break;
1106 }
1107 }
1108 /*
1109 * As per SDCC spec try for max 1 second
1110 */
1111 mdelay(50);
1112 }
1113
1114 if (i == SD_ACMD41_MAX_RETRY && !(cmd.resp[0] & MMC_SD_DEV_READY))
1115 {
1116 dprintf(CRITICAL, "Error: ACMD41 response timed out\n");
1117 return 1;
1118 }
1119
1120 return 0;
1121}
1122
1123/*
1124 * Function to read SD card information from SD status
1125 */
1126static uint32_t mmc_sd_get_card_ssr(struct sdhci_host *host, struct mmc_card *card)
1127{
1128 BUF_DMA_ALIGN(raw_sd_status, 64);
1129 struct mmc_command cmd = {0};
1130 uint32_t sd_status[16];
1131 uint32_t *status = sd_status;
1132 uint32_t au_size;
1133 int i;
1134 int j;
1135
1136 if (mmc_send_app_cmd(host, card))
1137 {
1138 dprintf(CRITICAL, "Failed sending App command\n");
1139 return 1;
1140 }
1141
1142 cmd.cmd_index = ACMD13_SEND_SD_STATUS;
1143 cmd.argument = 0x0;
1144 cmd.cmd_type = SDHCI_CMD_TYPE_NORMAL;
1145 cmd.resp_type = SDHCI_CMD_RESP_R2;
1146 cmd.trans_mode = SDHCI_MMC_READ;
1147 cmd.data_present = 0x1;
1148 cmd.data.data_ptr = raw_sd_status;
1149 cmd.data.num_blocks = 0x1;
1150 cmd.data.blk_sz = 0x40;
1151
1152 /* send command */
1153 if (sdhci_send_command(host, &cmd))
1154 return 1;
1155
1156 memcpy(sd_status, raw_sd_status, sizeof(sd_status));
1157
1158 for (i = 15, j = 0; i >=0 ; i--, j++)
1159 sd_status[i] = swap_endian32(sd_status[j]);
1160
1161 au_size = UNPACK_BITS(status, MMC_SD_AU_SIZE_BIT, MMC_SD_AU_SIZE_LEN, 32);
1162 /* Card AU size in sectors */
1163 card->ssr.au_size = 1 << (au_size + 4);
1164 card->ssr.num_aus = UNPACK_BITS(status, MMC_SD_ERASE_SIZE_BIT, MMC_SD_ERASE_SIZE_LEN, 32);
1165
1166 return 0;
1167}
1168
1169/*
1170 * Function to read the SD CARD configuration register
1171 */
1172static uint32_t mmc_sd_get_card_scr(struct sdhci_host *host, struct mmc_card *card)
1173{
1174 BUF_DMA_ALIGN(scr_resp, 8);
1175 struct mmc_command cmd = {0};
1176 uint32_t raw_scr[2];
1177
1178 /* Now read the SCR register */
1179 /* Send APP_CMD before ACMD51*/
1180 if (mmc_send_app_cmd(host, card))
1181 {
1182 dprintf(CRITICAL, "Failed sending App command\n");
1183 return 1;
1184 }
1185
1186 cmd.cmd_index = ACMD51_READ_CARD_SCR;
1187 cmd.argument = 0x0;
1188 cmd.cmd_type = SDHCI_CMD_TYPE_NORMAL;
1189 cmd.resp_type = SDHCI_CMD_RESP_R1;
1190 cmd.trans_mode = SDHCI_MMC_READ;
1191 cmd.data_present = 0x1;
1192 cmd.data.data_ptr = scr_resp;
1193 cmd.data.num_blocks = 0x1;
1194 cmd.data.blk_sz = 0x8;
1195
1196 /* send command */
1197 if (sdhci_send_command(host, &cmd))
1198 return 1;
1199
1200 memcpy(raw_scr, scr_resp, sizeof(raw_scr));
1201
1202 card->raw_scr[0] = swap_endian32(raw_scr[0]);
1203 card->raw_scr[1] = swap_endian32(raw_scr[1]);
1204
1205 /*
1206 * Parse & Populate the SCR data as per sdcc spec
1207 */
1208 card->scr.bus_widths = (card->raw_scr[0] & SD_SCR_BUS_WIDTH_MASK) >> SD_SCR_BUS_WIDTH;
1209 card->scr.cmd23_support = (card->raw_scr[0] & SD_SCR_CMD23_SUPPORT);
1210 card->scr.sd_spec = (card->raw_scr[0] & SD_SCR_SD_SPEC_MASK) >> SD_SCR_SD_SPEC;
1211 card->scr.sd3_spec = (card->raw_scr[0] & SD_SCR_SD_SPEC3_MASK) >> SD_SCR_SD_SPEC3;
1212
1213 return 0;
1214}
1215
1216/*
1217 * Function: mmc_set_sd_bus_width
1218 * Arg : host, device structure & width
1219 * Return : 0 on Success, 1 on Failure
1220 * Flow : Set the bus width for the card
1221 */
1222uint32_t mmc_sd_set_bus_width(struct sdhci_host *host, struct mmc_card *card, uint8_t width)
1223{
1224 struct mmc_command cmd = {0};
1225
1226 /* Send APP_CMD before ACMD6*/
1227 if (mmc_send_app_cmd(host, card))
1228 {
1229 dprintf(CRITICAL, "Failed sending App command\n");
1230 return 1;
1231 }
1232
1233 cmd.cmd_index = ACMD6_SET_BUS_WIDTH;
1234 cmd.argument = (width == DATA_BUS_WIDTH_4BIT) ? (1<<1) : 0;
1235 cmd.cmd_type = SDHCI_CMD_TYPE_NORMAL;
1236 cmd.resp_type = SDHCI_CMD_RESP_R1;
1237
1238 /* send command */
1239 if (sdhci_send_command(host, &cmd))
1240 return 1;
1241
1242 return 0;
1243}
1244
1245uint32_t mmc_sd_set_hs(struct sdhci_host *host, struct mmc_card *card)
1246{
1247 struct mmc_command cmd = {0};
1248 BUF_DMA_ALIGN(switch_resp, 64);
1249
1250 cmd.cmd_index = CMD6_SWITCH_FUNC;
1251 cmd.argument = MMC_SD_SWITCH_HS;
1252 cmd.cmd_type = SDHCI_CMD_TYPE_NORMAL;
1253 cmd.resp_type = SDHCI_CMD_RESP_R1;
1254 cmd.trans_mode = SDHCI_MMC_READ;
1255 cmd.data_present = 0x1;
1256 cmd.data.data_ptr = switch_resp;
1257 cmd.data.num_blocks = 0x1;
1258 cmd.data.blk_sz = 0x40;
1259
1260 /* send command */
1261 if (sdhci_send_command(host, &cmd))
1262 return 1;
1263
1264 return 0;
1265}
1266
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -07001267/*
1268 * Function: mmc_init_card
1269 * Arg : mmc device structure
1270 * Return : 0 on Success, 1 on Failure
1271 * Flow : Performs initialization and identification of eMMC cards connected
1272 * to the host.
1273 */
1274
1275static uint32_t mmc_card_init(struct mmc_device *dev)
1276{
1277 uint32_t mmc_return = 0;
1278 uint32_t status;
1279 uint8_t bus_width = 0;
1280
1281 struct sdhci_host *host;
1282 struct mmc_card *card;
1283 struct mmc_config_data *cfg;
1284
1285 host = &dev->host;
1286 card = &dev->card;
1287 cfg = &dev->config;
1288
1289 /* Initialize MMC card structure */
1290 card->status = MMC_STATUS_INACTIVE;
1291
1292 /* TODO: Get the OCR params from target */
1293 card->ocr = MMC_OCR_27_36 | MMC_OCR_SEC_MODE;
1294
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -07001295 /* Initialize the internal MMC */
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -07001296 mmc_return = mmc_reset_card_and_send_op(host, card);
1297 if (mmc_return)
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -07001298 {
1299 dprintf(CRITICAL, "MMC card failed to respond, try for SD card\n");
1300 /* Reset the card & get the OCR */
1301 mmc_return = mmc_sd_card_init(host, card);
1302 if (mmc_return)
1303 {
1304 dprintf(CRITICAL, "Failed to initialize SD card\n");
1305 return mmc_return;
1306 }
1307 }
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -07001308
1309 /* Identify (CMD2, CMD3 & CMD9) and select the card (CMD7) */
1310 mmc_return = mmc_identify_card(host, card);
1311 if (mmc_return)
1312 return mmc_return;
1313
1314 /* set interface speed */
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -07001315 if (MMC_CARD_SD(card))
1316 {
1317 mmc_return = mmc_sd_set_hs(host, card);
1318 if (mmc_return)
1319 {
1320 dprintf(CRITICAL, "Failed to set HS for SD card\n");
1321 return mmc_return;
1322 }
1323 }
1324 else
1325 {
1326 mmc_return = mmc_set_hs_interface(host, card);
1327 if (mmc_return) {
1328 dprintf(CRITICAL, "Error adjusting interface speed!\n");
1329 return mmc_return;
1330 }
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -07001331 }
1332
1333 /* Set the sdcc clock to 50 MHZ */
1334 sdhci_clk_supply(host, SDHCI_CLK_50MHZ);
1335
1336 /* Now get the extended CSD for the card */
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -07001337 if (MMC_CARD_MMC(card))
1338 {
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -07001339 /* For MMC cards, also get the extended csd */
1340 mmc_return = mmc_get_ext_csd(host, card);
1341
1342 if (mmc_return) {
1343 dprintf(CRITICAL, "Failure getting card's ExtCSD information!\n");
1344 return mmc_return;
1345 }
1346 }
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -07001347 else
1348 {
1349 /*Read SCR for sd card */
1350 if (mmc_sd_get_card_scr(host, card))
1351 {
1352 dprintf(CRITICAL, "Failure getting card's SCR register\n");
1353 return 1;
1354 }
1355 /* Read SSR for the SD card */
1356 if (mmc_sd_get_card_ssr(host, card))
1357 {
1358 dprintf(CRITICAL, "Failed to get SSR from the card\n");
1359 return 1;
1360 }
1361 }
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -07001362
1363 /* Decode and save the CSD register */
1364 mmc_return = mmc_decode_and_save_csd(card);
1365 if (mmc_return) {
1366 dprintf(CRITICAL, "Failure decoding card's CSD information!\n");
1367 return mmc_return;
1368 }
1369
1370
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -07001371 if (MMC_CARD_MMC(card))
1372 {
1373 /* Set the bus width based on host, target capbilities */
1374 if (cfg->bus_width == DATA_BUS_WIDTH_8BIT && host->caps.bus_width_8bit)
1375 bus_width = DATA_BUS_WIDTH_8BIT;
1376 /*
1377 * Host contoller by default supports 4 bit & 1 bit mode.
1378 * No need to check for host support here
1379 */
1380 else if (cfg->bus_width == DATA_BUS_WIDTH_4BIT)
1381 bus_width = DATA_BUS_WIDTH_4BIT;
1382 else
1383 bus_width = DATA_BUS_WIDTH_1BIT;
1384
1385 /* Set 4/8 bit SDR bus width in controller */
1386 mmc_return = sdhci_set_bus_width(host, bus_width);
1387
1388 if (mmc_return) {
1389 dprintf(CRITICAL, "Failed to set bus width for host controller\n");
1390 return 1;
1391 }
1392
1393 /* Enable high speed mode in the follwing order:
1394 * 1. HS200 mode if supported by host & card
1395 * 2. DDR mode host, if supported by host & card
1396 * 3. Use normal speed mode with supported bus width
1397 */
1398 if (mmc_card_supports_hs200_mode(card) && host->caps.sdr50_support) {
1399 mmc_return = mmc_set_hs200_mode(host, card, bus_width);
1400
1401 if (mmc_return) {
1402 dprintf(CRITICAL, "Failure to set HS200 mode for Card(RCA:%x)\n",
1403 card->rca);
1404 return mmc_return;
1405 }
1406 } else if (mmc_card_supports_ddr_mode(card) && host->caps.ddr_support) {
1407 mmc_return = mmc_set_ddr_mode(host, card);
1408
1409 if (mmc_return) {
1410 dprintf(CRITICAL, "Failure to set DDR mode for Card(RCA:%x)\n",
1411 card->rca);
1412 return mmc_return;
1413 }
1414 } else {
1415 /* Set 4/8 bit bus width for the card */
1416 mmc_return = mmc_set_bus_width(host, card, bus_width);
1417 if (mmc_return) {
1418 dprintf(CRITICAL, "Failure to set wide bus for Card(RCA:%x)\n",
1419 card->rca);
1420 return mmc_return;
1421 }
1422 }
1423 }
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -07001424 else
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -07001425 {
1426 /* Check the supported bus width for the card from SCR register */
1427 if (card->scr.bus_widths & SD_SCR_WIDTH_4BIT)
1428 bus_width = DATA_BUS_WIDTH_4BIT;
1429 else
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -07001430 bus_width = DATA_BUS_WIDTH_1BIT;
1431
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -07001432 mmc_return = mmc_sd_set_bus_width(host, card, bus_width);
1433 if (mmc_return)
1434 {
1435 dprintf(CRITICAL, "Failed to set bus width for the card\n");
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -07001436 return mmc_return;
1437 }
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -07001438
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -07001439 /* Set bit SDR bus width in controller */
1440 mmc_return = sdhci_set_bus_width(host, bus_width);
1441 if (mmc_return)
1442 {
1443 dprintf(CRITICAL, "Failed to set bus width for host controller\n");
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -07001444 return mmc_return;
1445 }
1446 }
1447
1448
1449 /* Verify TRAN state after changing speed and bus width */
1450 mmc_return = mmc_get_card_status(host, card, &status);
1451 if (mmc_return)
1452 return mmc_return;
1453
1454 if (MMC_CARD_STATUS(status) != MMC_TRAN_STATE)
1455 mmc_return = 1;
1456
Channagoud Kadabi96c629e2013-09-10 14:21:30 -07001457 card->block_size = MMC_BLK_SZ;
1458
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -07001459 return mmc_return;
1460}
1461
1462/*
1463 * Function: mmc display csd
1464 * Arg : None
1465 * Return : None
1466 * Flow : Displays the csd information
1467 */
1468static void mmc_display_csd(struct mmc_card *card)
1469{
1470 dprintf(SPEW, "erase_grpsize: %d\n", card->csd.erase_grp_size);
1471 dprintf(SPEW, "erase_grpmult: %d\n", card->csd.erase_grp_mult);
1472 dprintf(SPEW, "wp_grpsize: %d\n", card->csd.wp_grp_size);
1473 dprintf(SPEW, "wp_grpen: %d\n", card->csd.wp_grp_enable);
1474 dprintf(SPEW, "perm_wp: %d\n", card->csd.perm_wp);
1475 dprintf(SPEW, "temp_wp: %d\n", card->csd.temp_wp);
1476}
1477
1478/*
1479 * Function: mmc_init
1480 * Arg : MMC configuration data
1481 * Return : Pointer to mmc device
1482 * Flow : Entry point to MMC boot process
1483 * Initialize the sd host controller
1484 * Initialize the mmc card
1485 * Set the clock & high speed mode
1486 */
1487struct mmc_device *mmc_init(struct mmc_config_data *data)
1488{
1489 uint8_t mmc_ret = 0;
1490 struct mmc_device *dev;
1491
1492 dev = (struct mmc_device *) malloc (sizeof(struct mmc_device));
1493
1494 if (!dev) {
1495 dprintf(CRITICAL, "Error allocating mmc device\n");
1496 return NULL;
1497 }
1498
1499 ASSERT(data);
1500
1501 memcpy((void*)&dev->config, (void*)data, sizeof(struct mmc_config_data));
1502
1503 memset((struct mmc_card *)&dev->card, 0, sizeof(struct mmc_card));
1504
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -07001505 /* Initialize the host & clock */
1506 dprintf(SPEW, " Initializing MMC host data structure and clock!\n");
1507
1508 mmc_ret = mmc_host_init(dev);
1509 if (mmc_ret) {
1510 dprintf(CRITICAL, "Error Initializing MMC host : %u\n", mmc_ret);
1511 return NULL;
1512 }
1513
1514 /* Initialize and identify cards connected to host */
1515 mmc_ret = mmc_card_init(dev);
1516 if (mmc_ret) {
1517 dprintf(CRITICAL, "Failed detecting MMC/SDC @ slot%d\n",
1518 dev->config.slot);
1519 return NULL;
1520 }
1521
1522 dprintf(INFO, "Done initialization of the card\n");
1523
1524 mmc_display_csd(&dev->card);
1525
1526 return dev;
1527}
1528
Channagoud Kadabi14fd2052013-10-17 18:00:50 -07001529static uint32_t mmc_parse_response(uint32_t resp)
1530{
1531 /* Trying to write beyond card capacity */
1532 if (resp & MMC_R1_ADDR_OUT_OF_RANGE) {
1533 dprintf(CRITICAL, "Attempting to read or write beyond the Device capacity\n");
1534 return 1;
1535 }
1536
1537 /* Misaligned address not matching block length */
1538 if (resp & MMC_R1_ADDR_ERR) {
1539 dprintf(CRITICAL, "The misaligned address did not match the block length used\n");
1540 return 1;
1541 }
1542
1543 /* Invalid block length */
1544 if (resp & MMC_R1_BLOCK_LEN_ERR) {
1545 dprintf(CRITICAL, "The transferred bytes does not match the block length\n");
1546 return 1;
1547 }
1548
1549 /* Tried to program write protected block */
1550 if (resp & MMC_R1_WP_VIOLATION) {
1551 dprintf(CRITICAL, "Attempt to program a write protected block\n");
1552 return 1;
1553 }
1554
1555 /* card controller error */
1556 if (resp & MMC_R1_CC_ERROR) {
1557 dprintf(CRITICAL, "Device error occurred, which is not related to the host command\n");
1558 return 1;
1559 }
1560
1561 /* Generic error */
1562 if (resp & MMC_R1_GENERIC_ERR) {
1563 dprintf(CRITICAL, "A generic Device error\n");
1564 return 1;
1565 }
1566
1567 /* Finally check for card in TRAN state */
1568 if (MMC_CARD_STATUS(resp) != MMC_TRAN_STATE) {
1569 dprintf(CRITICAL, "MMC card is not in TRAN state\n");
1570 return 1;
1571 }
1572
1573 return 0;
1574}
1575
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -07001576/*
1577 * Function: mmc sdhci read
1578 * Arg : mmc device structure, block address, number of blocks & destination
1579 * Return : 0 on Success, non zero on success
1580 * Flow : Fill in the command structure & send the command
1581 */
1582uint32_t mmc_sdhci_read(struct mmc_device *dev, void *dest,
1583 uint64_t blk_addr, uint32_t num_blocks)
1584{
1585 uint32_t mmc_ret = 0;
1586 struct mmc_command cmd;
1587
1588 memset((struct mmc_command *)&cmd, 0, sizeof(struct mmc_command));
1589
1590 /* CMD17/18 Format:
1591 * [31:0] Data Address
1592 */
1593 if (num_blocks == 1)
1594 cmd.cmd_index = CMD17_READ_SINGLE_BLOCK;
1595 else
1596 cmd.cmd_index = CMD18_READ_MULTIPLE_BLOCK;
1597
1598 cmd.argument = blk_addr;
1599 cmd.cmd_type = SDHCI_CMD_TYPE_NORMAL;
1600 cmd.resp_type = SDHCI_CMD_RESP_R1;
1601 cmd.trans_mode = SDHCI_MMC_READ;
1602 cmd.data_present = 0x1;
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -07001603 /* Use CMD23 If card supports cMD23 */
1604 cmd.cmd23_support = dev->card.scr.cmd23_support;
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -07001605 cmd.data.data_ptr = dest;
1606 cmd.data.num_blocks = num_blocks;
1607
1608 /* send command */
1609 mmc_ret = sdhci_send_command(&dev->host, &cmd);
1610 if (mmc_ret) {
1611 return mmc_ret;
1612 }
1613
Channagoud Kadabi14fd2052013-10-17 18:00:50 -07001614 /* Response contains 32 bit Card status.
1615 * Parse the errors & provide relevant information */
1616 if ((mmc_ret = mmc_parse_response(cmd.resp[0])))
1617 {
1618 dprintf(CRITICAL,"MMC Read failed, found errors in card response: %s\t%d\n", __func__, __LINE__);
1619 return mmc_ret;
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -07001620 }
1621
1622 return mmc_ret;
1623}
1624
1625/*
1626 * Function: mmc sdhci write
1627 * Arg : mmc device structure, block address, number of blocks & source
1628 * Return : 0 on Success, non zero on success
1629 * Flow : Fill in the command structure & send the command
1630 */
1631uint32_t mmc_sdhci_write(struct mmc_device *dev, void *src,
1632 uint64_t blk_addr, uint32_t num_blocks)
1633{
1634 uint32_t mmc_ret = 0;
1635 struct mmc_command cmd;
1636
1637 memset((struct mmc_command *)&cmd, 0, sizeof(struct mmc_command));
1638
1639 /* CMD24/25 Format:
1640 * [31:0] Data Address
1641 */
1642
1643 if (num_blocks == 1)
1644 cmd.cmd_index = CMD24_WRITE_SINGLE_BLOCK;
1645 else
1646 cmd.cmd_index = CMD25_WRITE_MULTIPLE_BLOCK;
1647
1648 cmd.argument = blk_addr;
1649 cmd.cmd_type = SDHCI_CMD_TYPE_NORMAL;
1650 cmd.resp_type = SDHCI_CMD_RESP_R1;
1651 cmd.trans_mode = SDHCI_MMC_WRITE;
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -07001652 /* Use CMD23 If card supports cMD23 */
1653 cmd.cmd23_support = dev->card.scr.cmd23_support;
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -07001654 cmd.data_present = 0x1;
1655 cmd.data.data_ptr = src;
1656 cmd.data.num_blocks = num_blocks;
1657
1658 /* send command */
1659 mmc_ret = sdhci_send_command(&dev->host, &cmd);
1660 if (mmc_ret)
1661 return mmc_ret;
1662
Channagoud Kadabi14fd2052013-10-17 18:00:50 -07001663 /* Response contains 32 bit Card status.
1664 * Parse the errors & provide relevant information */
1665 if ((mmc_ret = mmc_parse_response(cmd.resp[0])))
1666 {
1667 dprintf(CRITICAL,"MMC Write failed, found errors in card response: %s\t%d\n", __func__, __LINE__);
1668 return mmc_ret;
Channagoud Kadabiec0f7f72013-03-11 15:21:36 -07001669 }
1670
1671 return mmc_ret;
1672}
Channagoud Kadabi003171e2013-05-29 15:21:12 -07001673
1674/*
1675 * Send the erase group start address using CMD35
1676 */
1677static uint32_t mmc_send_erase_grp_start(struct mmc_device *dev, uint32_t erase_start)
1678{
1679 struct mmc_command cmd;
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -07001680 struct mmc_card *card = &dev->card;
Channagoud Kadabi003171e2013-05-29 15:21:12 -07001681
1682 memset((struct mmc_command *)&cmd, 0, sizeof(struct mmc_command));
1683
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -07001684 if (MMC_CARD_MMC(card))
1685 cmd.cmd_index = CMD35_ERASE_GROUP_START;
1686 else
1687 cmd.cmd_index = CMD32_ERASE_WR_BLK_START;
1688
Channagoud Kadabi003171e2013-05-29 15:21:12 -07001689 cmd.argument = erase_start;
1690 cmd.cmd_type = SDHCI_CMD_TYPE_NORMAL;
1691 cmd.resp_type = SDHCI_CMD_RESP_R1;
1692
1693 /* send command */
1694 if (sdhci_send_command(&dev->host, &cmd))
1695 return 1;
1696
1697 /*
1698 * CMD35 on failure returns address out of range error
1699 */
1700 if (MMC_ADDR_OUT_OF_RANGE(cmd.resp[0]))
1701 {
1702 dprintf(CRITICAL, "Address for CMD35 is out of range\n");
1703 return 1;
1704 }
1705
1706 return 0;
1707}
1708
1709/*
1710 * Send the erase group end address using CMD36
1711 */
1712static uint32_t mmc_send_erase_grp_end(struct mmc_device *dev, uint32_t erase_end)
1713{
1714 struct mmc_command cmd;
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -07001715 struct mmc_card *card = &dev->card;
Channagoud Kadabi003171e2013-05-29 15:21:12 -07001716
1717 memset((struct mmc_command *)&cmd, 0, sizeof(struct mmc_command));
1718
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -07001719 if (MMC_CARD_MMC(card))
1720 cmd.cmd_index = CMD36_ERASE_GROUP_END;
1721 else
1722 cmd.cmd_index = CMD33_ERASE_WR_BLK_END;
1723
Channagoud Kadabi003171e2013-05-29 15:21:12 -07001724 cmd.argument = erase_end;
1725 cmd.cmd_type = SDHCI_CMD_TYPE_NORMAL;
1726 cmd.resp_type = SDHCI_CMD_RESP_R1;
1727
1728 /* send command */
1729 if (sdhci_send_command(&dev->host, &cmd))
1730 return 1;
1731
1732 /*
1733 * CMD3 on failure returns address out of range error
1734 */
1735 if (MMC_ADDR_OUT_OF_RANGE(cmd.resp[0]))
1736 {
1737 dprintf(CRITICAL, "Address for CMD36 is out of range\n");
1738 return 1;
1739 }
1740
1741 return 0;
1742}
1743
1744/*
1745 * Send the erase CMD38, to erase the selected erase groups
1746 */
1747static uint32_t mmc_send_erase(struct mmc_device *dev)
1748{
1749 struct mmc_command cmd;
1750 uint32_t status;
Channagoud Kadabi6d1751b2013-07-05 13:03:52 -07001751 uint32_t retry = 0;
Channagoud Kadabi003171e2013-05-29 15:21:12 -07001752
1753 memset((struct mmc_command *)&cmd, 0, sizeof(struct mmc_command));
1754
1755 cmd.cmd_index = CMD38_ERASE;
1756 cmd.argument = 0x00000000;
1757 cmd.cmd_type = SDHCI_CMD_TYPE_NORMAL;
1758 cmd.resp_type = SDHCI_CMD_RESP_R1B;
1759
1760 /* send command */
1761 if (sdhci_send_command(&dev->host, &cmd))
1762 return 1;
1763
1764 do
1765 {
1766 if (mmc_get_card_status(&dev->host, &dev->card, &status))
1767 {
1768 dprintf(CRITICAL, "Failed to get card status after erase\n");
1769 return 1;
1770 }
1771 /* Check if the response of erase command has eras skip status set */
1772 if (status & MMC_R1_WP_ERASE_SKIP)
1773 dprintf(CRITICAL, "Write Protect set for the region, only partial space was erased\n");
1774
1775 retry++;
1776 udelay(1000);
1777 if (retry == MMC_MAX_CARD_STAT_RETRY)
1778 {
1779 dprintf(CRITICAL, "Card status check timed out after sending erase command\n");
1780 return 1;
1781 }
1782 } while(!(status & MMC_READY_FOR_DATA) || (MMC_CARD_STATUS(status) == MMC_PROG_STATE));
1783
1784
1785 return 0;
1786}
1787
1788
1789/*
1790 * Function: mmc sdhci erase
1791 * Arg : mmc device structure, block address and length
1792 * Return : 0 on Success, non zero on failure
1793 * Flow : Fill in the command structure & send the command
1794 */
1795uint32_t mmc_sdhci_erase(struct mmc_device *dev, uint32_t blk_addr, uint64_t len)
1796{
1797 uint32_t erase_unit_sz = 0;
1798 uint32_t erase_start;
1799 uint32_t erase_end;
1800 uint32_t blk_end;
1801 uint32_t num_erase_grps;
1802 uint32_t *out;
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -07001803 struct mmc_card *card;
1804
1805
1806 card = &dev->card;
Channagoud Kadabi003171e2013-05-29 15:21:12 -07001807
1808 /*
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -07001809 * Calculate the erase unit size,
1810 * 1. Based on emmc 4.5 spec for emmc card
1811 * 2. Use SD Card Status info for SD cards
Channagoud Kadabi003171e2013-05-29 15:21:12 -07001812 */
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -07001813 if (MMC_CARD_MMC(card))
1814 {
1815 /*
1816 * Calculate the erase unit size as per the emmc specification v4.5
1817 */
1818 if (dev->card.ext_csd[MMC_ERASE_GRP_DEF])
1819 erase_unit_sz = (MMC_HC_ERASE_MULT * dev->card.ext_csd[MMC_HC_ERASE_GRP_SIZE]) / MMC_BLK_SZ;
1820 else
1821 erase_unit_sz = (dev->card.csd.erase_grp_size + 1) * (dev->card.csd.erase_grp_mult + 1);
1822 }
Channagoud Kadabi003171e2013-05-29 15:21:12 -07001823 else
Channagoud Kadabi4d13b2c2013-06-18 12:43:29 -07001824 erase_unit_sz = dev->card.ssr.au_size * dev->card.ssr.num_aus;
1825
Channagoud Kadabi003171e2013-05-29 15:21:12 -07001826
1827 /* Convert length in blocks */
1828 len = len / MMC_BLK_SZ;
1829
1830 if (len < erase_unit_sz)
1831 {
1832 dprintf(CRITICAL, "Requested length is less than min erase group size\n");
1833 return 1;
1834 }
1835
1836 /* Calculate erase groups based on the length in blocks */
1837 num_erase_grps = len / erase_unit_sz;
1838
1839 /* Start address of the erase range */
1840 erase_start = blk_addr;
1841
1842 /* Last address of the erase range */
1843 erase_end = blk_addr + ((num_erase_grps - 1) * erase_unit_sz);
1844
1845 /* Boundary check for overlap */
1846 blk_end = blk_addr + len;
1847
1848 if (erase_end > blk_end)
1849 {
1850 dprintf(CRITICAL, "The erase group overlaps the max requested for erase\n");
1851 erase_end -= erase_unit_sz;
1852 }
1853
1854 /* Send CMD35 for erase group start */
1855 if (mmc_send_erase_grp_start(dev, erase_start))
1856 {
1857 dprintf(CRITICAL, "Failed to send erase grp start address\n");
1858 return 1;
1859 }
1860
1861 /* Send CMD36 for erase group end */
1862 if (mmc_send_erase_grp_end(dev, erase_end))
1863 {
1864 dprintf(CRITICAL, "Failed to send erase grp end address\n");
1865 return 1;
1866 }
1867
1868 /* Send CMD38 to perform erase */
1869 if (mmc_send_erase(dev))
1870 {
1871 dprintf(CRITICAL, "Failed to erase the specified partition\n");
1872 return 1;
1873 }
1874 return 0;
1875}
1876
1877/*
1878 * Function: mmc get wp status
1879 * Arg : mmc device structure, block address and buffer for getting wp status
1880 * Return : 0 on Success, 1 on Failure
1881 * Flow : Get the WP group status by sending CMD31
1882 */
1883uint32_t mmc_get_wp_status(struct mmc_device *dev, uint32_t addr, uint8_t *wp_status)
1884{
1885 struct mmc_command cmd;
1886
1887 memset((struct mmc_command *)&cmd, 0, sizeof(struct mmc_command));
1888
1889 cmd.cmd_index = CMD31_SEND_WRITE_PROT_TYPE;
1890 cmd.argument = addr;
1891 cmd.cmd_type = SDHCI_CMD_TYPE_NORMAL;
1892 cmd.resp_type = SDHCI_CMD_RESP_R1;
1893 cmd.trans_mode = SDHCI_MMC_READ;
1894 cmd.data_present = 0x1;
1895 cmd.data.data_ptr = wp_status;
1896 cmd.data.num_blocks = 0x1;
1897 cmd.data.blk_sz = 0x8;
1898
1899 if (sdhci_send_command(&dev->host, &cmd))
1900 {
1901 dprintf(CRITICAL, "Failed to get status of write protect bits\n");
1902 return 1;
1903 }
1904
1905 return 0;
1906}
1907
1908/*
1909 * Function: mmc set/clear WP on user area
1910 * Arg : mmc device structure, block address,len, & flag to set or clear
1911 * Return : 0 on success, 1 on failure
1912 * Flow : Function to set/clear power on write protect on user area
1913 */
1914
1915uint32_t mmc_set_clr_power_on_wp_user(struct mmc_device *dev, uint32_t addr, uint64_t len, uint8_t set_clr)
1916{
1917 struct mmc_command cmd;
1918 uint32_t wp_grp_size;
1919 uint32_t status;
1920 uint32_t num_wp_grps;
1921 uint32_t ret;
Channagoud Kadabi6d1751b2013-07-05 13:03:52 -07001922 uint32_t retry = 0;
Channagoud Kadabi003171e2013-05-29 15:21:12 -07001923 uint32_t i;
1924
1925 memset((struct mmc_command *)&cmd, 0, sizeof(struct mmc_command));
1926
1927 /* Convert len into blocks */
1928 len = len / MMC_BLK_SZ;
1929
1930 /* Disable PERM WP */
1931 ret = mmc_switch_cmd(&dev->host, &dev->card, MMC_SET_BIT, MMC_USR_WP, MMC_US_PERM_WP_DIS);
1932
1933 if (ret)
1934 {
1935 dprintf(CRITICAL, "Failed to Disable PERM WP\n");
1936 return ret;
1937 }
1938
1939 /* Read the default values for user WP */
1940 ret = mmc_get_ext_csd(&dev->host, &dev->card);
1941
1942 if (ret)
1943 {
1944 dprintf(CRITICAL, "Failed to read ext csd for the card\n");
1945 return ret;
1946 }
1947
1948 /* Check if user power on WP is disabled or perm WP is enabled */
1949 if ((dev->card.ext_csd[MMC_USR_WP] & MMC_US_PWR_WP_DIS)
1950 || (dev->card.ext_csd[MMC_USR_WP] & MMC_US_PERM_WP_EN))
1951 {
1952 dprintf(CRITICAL, "Power on protection is disabled, cannot be set\n");
1953 return 1;
1954 }
1955
1956 /* Calculate the wp grp size */
1957 if (dev->card.ext_csd[MMC_ERASE_GRP_DEF])
1958 wp_grp_size = MMC_HC_ERASE_MULT * dev->card.ext_csd[MMC_HC_ERASE_GRP_SIZE] / MMC_BLK_SZ;
1959 else
1960 wp_grp_size = (dev->card.csd.wp_grp_size + 1) * (dev->card.csd.erase_grp_size + 1) \
1961 * (dev->card.csd.erase_grp_mult + 1);
1962
1963
1964 if (len < wp_grp_size)
1965 {
1966 dprintf(CRITICAL, "Length is less than min WP size, WP was not set\n");
1967 return 1;
1968 }
1969
1970 /* Set power on USER WP */
1971 ret = mmc_switch_cmd(&dev->host, &dev->card, MMC_SET_BIT, MMC_USR_WP, MMC_US_PWR_WP_EN);
1972
1973 if (ret)
1974 {
1975 dprintf(CRITICAL, "Failed to set power on WP for user\n");
1976 return ret;
1977 }
1978
1979 num_wp_grps = ROUNDUP(len, wp_grp_size) / wp_grp_size;
1980
1981 if (set_clr)
1982 cmd.cmd_index = CMD28_SET_WRITE_PROTECT;
1983 else
1984 cmd.cmd_index = CMD29_CLEAR_WRITE_PROTECT;
1985
1986 cmd.cmd_type = SDHCI_CMD_TYPE_NORMAL;
1987 cmd.resp_type = SDHCI_CMD_RESP_R1B;
1988
1989 for(i = 0; i < num_wp_grps; i++)
1990 {
1991 cmd.argument = addr + (i * wp_grp_size);
1992
1993 if (sdhci_send_command(&dev->host, &cmd))
1994 return 1;
1995
1996 /* CMD28/CMD29 On failure returns address out of range error */
1997 if (MMC_ADDR_OUT_OF_RANGE(cmd.resp[0]))
1998 {
1999 dprintf(CRITICAL, "Address for CMD28/29 is out of range\n");
2000 return 1;
2001 }
2002
2003 /* Check the card status */
2004 do
2005 {
2006 if (mmc_get_card_status(&dev->host, &dev->card, &status))
2007 {
2008 dprintf(CRITICAL, "Failed to get card status afterapplying write protect\n");
2009 return 1;
2010 }
2011
2012 /* Time out for WP command */
2013 retry++;
2014 udelay(1000);
2015 if (retry == MMC_MAX_CARD_STAT_RETRY)
2016 {
2017 dprintf(CRITICAL, "Card status timed out after sending write protect command\n");
2018 return 1;
2019 }
2020 } while (!(status & MMC_READY_FOR_DATA) || (MMC_CARD_STATUS(status) == MMC_PROG_STATE));
2021
2022 }
2023
2024 return 0;
2025}
Channagoud Kadabi9e3c3b92013-06-18 18:32:32 -07002026
2027/* Function to put the mmc card to sleep */
2028void mmc_put_card_to_sleep(struct mmc_device *dev)
2029{
2030 struct mmc_command cmd = {0};
2031 struct mmc_card *card = &dev->card;
2032
2033 cmd.cmd_index = CMD7_SELECT_DESELECT_CARD;
2034 cmd.argument = 0x00000000;
2035 cmd.cmd_type = SDHCI_CMD_TYPE_NORMAL;
2036 cmd.resp_type = SDHCI_CMD_RESP_NONE;
2037
2038 /* send command */
2039 if(sdhci_send_command(&dev->host, &cmd))
2040 {
2041 dprintf(CRITICAL, "card deselect error: %s\n", __func__);
2042 return;
2043 }
2044
2045 cmd.cmd_index = CMD5_SLEEP_AWAKE;
2046 cmd.argument = (card->rca << MMC_CARD_RCA_BIT) | MMC_CARD_SLEEP;
2047 cmd.cmd_type = SDHCI_CMD_TYPE_NORMAL;
2048 cmd.resp_type = SDHCI_CMD_RESP_R1B;
2049
2050 /* send command */
2051 if(sdhci_send_command(&dev->host, &cmd))
2052 dprintf(CRITICAL, "card sleep error: %s\n", __func__);
2053}