blob: 48e21ef7a59546bf8f6c45b7431c32005fed22e9 [file] [log] [blame]
wdenk71f95112003-06-15 22:40:42 +00001/*
2 * (C) Copyright 2003
3 * Kyle Harris, Nexus Technologies, Inc. kharris@nexus-tech.net
4 *
5 * See file CREDITS for list of people who contributed to this
6 * project.
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License as
10 * published by the Free Software Foundation; either version 2 of
11 * the License, or (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
21 * MA 02111-1307 USA
22 */
23
24#include <config.h>
25#include <common.h>
26#include <mmc.h>
27#include <asm/errno.h>
28#include <asm/arch/hardware.h>
wdenk7205e402003-09-10 22:30:53 +000029#include <part.h>
Marek Vasut3ba8bf72010-09-09 09:50:39 +020030#include <asm/io.h>
wdenk71f95112003-06-15 22:40:42 +000031
Jean-Christophe PLAGNIOL-VILLARDb03d92e2009-02-20 03:47:50 +010032#include "pxa_mmc.h"
wdenk71f95112003-06-15 22:40:42 +000033
stefano babicc95219f2007-11-20 10:40:24 +010034extern int fat_register_device(block_dev_desc_t * dev_desc, int part_no);
wdenk7205e402003-09-10 22:30:53 +000035
36static block_dev_desc_t mmc_dev;
37
stefano babicc95219f2007-11-20 10:40:24 +010038block_dev_desc_t *mmc_get_dev(int dev)
wdenk7205e402003-09-10 22:30:53 +000039{
stefano babicc95219f2007-11-20 10:40:24 +010040 return ((block_dev_desc_t *) & mmc_dev);
wdenk7205e402003-09-10 22:30:53 +000041}
wdenk71f95112003-06-15 22:40:42 +000042
wdenk8bde7f72003-06-27 21:31:46 +000043/*
wdenk71f95112003-06-15 22:40:42 +000044 * FIXME needs to read cid and csd info to determine block size
45 * and other parameters
46 */
47static uchar mmc_buf[MMC_BLOCK_SIZE];
stefano babicc95219f2007-11-20 10:40:24 +010048static uchar spec_ver;
wdenk71f95112003-06-15 22:40:42 +000049static int mmc_ready = 0;
stefano babicc95219f2007-11-20 10:40:24 +010050static int wide = 0;
wdenk71f95112003-06-15 22:40:42 +000051
stefano babicc95219f2007-11-20 10:40:24 +010052static uint32_t *
wdenk71f95112003-06-15 22:40:42 +000053/****************************************************/
54mmc_cmd(ushort cmd, ushort argh, ushort argl, ushort cmdat)
55/****************************************************/
56{
stefano babicc95219f2007-11-20 10:40:24 +010057 static uint32_t resp[4], a, b, c;
wdenk71f95112003-06-15 22:40:42 +000058 ulong status;
stefano babicc95219f2007-11-20 10:40:24 +010059 int i;
wdenk71f95112003-06-15 22:40:42 +000060
stefano babicc95219f2007-11-20 10:40:24 +010061 debug("mmc_cmd %u 0x%04x 0x%04x 0x%04x\n", cmd, argh, argl,
62 cmdat | wide);
Marek Vasut3ba8bf72010-09-09 09:50:39 +020063 writel(MMC_STRPCL_STOP_CLK, MMC_STRPCL);
64 writel(~MMC_I_MASK_CLK_IS_OFF, MMC_I_MASK);
65 while (!(readl(MMC_I_REG) & MMC_I_REG_CLK_IS_OFF))
66 ;
67 writel(cmd, MMC_CMD);
68 writel(argh, MMC_ARGH);
69 writel(argl, MMC_ARGL);
70 writel(cmdat | wide, MMC_CMDAT);
71 writel(~MMC_I_MASK_END_CMD_RES, MMC_I_MASK);
72 writel(MMC_STRPCL_START_CLK, MMC_STRPCL);
73 while (!(readl(MMC_I_REG) & MMC_I_REG_END_CMD_RES))
74 ;
wdenk71f95112003-06-15 22:40:42 +000075
Marek Vasut3ba8bf72010-09-09 09:50:39 +020076 status = readl(MMC_STAT);
stefano babicc95219f2007-11-20 10:40:24 +010077 debug("MMC status 0x%08x\n", status);
wdenk20787e22005-04-06 00:04:16 +000078 if (status & MMC_STAT_TIME_OUT_RESPONSE) {
wdenk71f95112003-06-15 22:40:42 +000079 return 0;
80 }
81
stefano babicc95219f2007-11-20 10:40:24 +010082 /* Linux says:
83 * Did I mention this is Sick. We always need to
84 * discard the upper 8 bits of the first 16-bit word.
85 */
Marek Vasut3ba8bf72010-09-09 09:50:39 +020086 a = (readl(MMC_RES) & 0xffff);
stefano babicc95219f2007-11-20 10:40:24 +010087 for (i = 0; i < 4; i++) {
Marek Vasut3ba8bf72010-09-09 09:50:39 +020088 b = (readl(MMC_RES) & 0xffff);
89 c = (readl(MMC_RES) & 0xffff);
stefano babicc95219f2007-11-20 10:40:24 +010090 resp[i] = (a << 24) | (b << 8) | (c >> 8);
91 a = c;
92 debug("MMC resp[%d] = %#08x\n", i, resp[i]);
wdenk71f95112003-06-15 22:40:42 +000093 }
wdenk71f95112003-06-15 22:40:42 +000094
wdenk71f95112003-06-15 22:40:42 +000095 return resp;
96}
97
98int
99/****************************************************/
stefano babicc95219f2007-11-20 10:40:24 +0100100mmc_block_read(uchar * dst, ulong src, ulong len)
wdenk71f95112003-06-15 22:40:42 +0000101/****************************************************/
102{
wdenk71f95112003-06-15 22:40:42 +0000103 ushort argh, argl;
104 ulong status;
105
wdenk20787e22005-04-06 00:04:16 +0000106 if (len == 0) {
wdenk71f95112003-06-15 22:40:42 +0000107 return 0;
108 }
109
stefano babicc95219f2007-11-20 10:40:24 +0100110 debug("mmc_block_rd dst %lx src %lx len %d\n", (ulong) dst, src, len);
wdenk71f95112003-06-15 22:40:42 +0000111
112 argh = len >> 16;
113 argl = len & 0xffff;
114
115 /* set block len */
stefano babicc95219f2007-11-20 10:40:24 +0100116 mmc_cmd(MMC_CMD_SET_BLOCKLEN, argh, argl, MMC_CMDAT_R1);
wdenk71f95112003-06-15 22:40:42 +0000117
118 /* send read command */
119 argh = src >> 16;
120 argl = src & 0xffff;
Marek Vasut3ba8bf72010-09-09 09:50:39 +0200121 writel(MMC_STRPCL_STOP_CLK, MMC_STRPCL);
122 writel(0xffff, MMC_RDTO);
123 writel(1, MMC_NOB);
124 writel(len, MMC_BLKLEN);
Haavard Skinnemoen341188b2008-05-22 11:09:59 +0200125 mmc_cmd(MMC_CMD_READ_SINGLE_BLOCK, argh, argl,
stefano babicc95219f2007-11-20 10:40:24 +0100126 MMC_CMDAT_R1 | MMC_CMDAT_READ | MMC_CMDAT_BLOCK |
127 MMC_CMDAT_DATA_EN);
wdenk8bde7f72003-06-27 21:31:46 +0000128
Marek Vasut3ba8bf72010-09-09 09:50:39 +0200129 writel(~MMC_I_MASK_RXFIFO_RD_REQ, MMC_I_MASK);
wdenk20787e22005-04-06 00:04:16 +0000130 while (len) {
Marek Vasut3ba8bf72010-09-09 09:50:39 +0200131 if (readl(MMC_I_REG) & MMC_I_REG_RXFIFO_RD_REQ) {
Marek Vasut43c15d32009-10-14 00:25:33 +0200132#if defined(CONFIG_PXA27X) || defined(CONFIG_CPU_MONAHANS)
wdenk20787e22005-04-06 00:04:16 +0000133 int i;
stefano babicc95219f2007-11-20 10:40:24 +0100134 for (i = min(len, 32); i; i--) {
Marek Vasut3ba8bf72010-09-09 09:50:39 +0200135 *dst++ = readb(MMC_RXFIFO);
wdenk20787e22005-04-06 00:04:16 +0000136 len--;
137 }
138#else
Marek Vasut3ba8bf72010-09-09 09:50:39 +0200139 *dst++ = readb(MMC_RXFIFO);
wdenk71f95112003-06-15 22:40:42 +0000140 len--;
wdenk20787e22005-04-06 00:04:16 +0000141#endif
wdenk71f95112003-06-15 22:40:42 +0000142 }
Marek Vasut3ba8bf72010-09-09 09:50:39 +0200143 status = readl(MMC_STAT);
wdenk20787e22005-04-06 00:04:16 +0000144 if (status & MMC_STAT_ERRORS) {
wdenk71f95112003-06-15 22:40:42 +0000145 printf("MMC_STAT error %lx\n", status);
146 return -1;
147 }
148 }
Marek Vasut3ba8bf72010-09-09 09:50:39 +0200149 writel(~MMC_I_MASK_DATA_TRAN_DONE, MMC_I_MASK);
150 while (!(readl(MMC_I_REG) & MMC_I_REG_DATA_TRAN_DONE))
151 ;
152 status = readl(MMC_STAT);
wdenk20787e22005-04-06 00:04:16 +0000153 if (status & MMC_STAT_ERRORS) {
wdenk71f95112003-06-15 22:40:42 +0000154 printf("MMC_STAT error %lx\n", status);
155 return -1;
156 }
157 return 0;
158}
159
160int
161/****************************************************/
stefano babicc95219f2007-11-20 10:40:24 +0100162mmc_block_write(ulong dst, uchar * src, int len)
wdenk71f95112003-06-15 22:40:42 +0000163/****************************************************/
164{
wdenk71f95112003-06-15 22:40:42 +0000165 ushort argh, argl;
166 ulong status;
167
wdenk20787e22005-04-06 00:04:16 +0000168 if (len == 0) {
wdenk71f95112003-06-15 22:40:42 +0000169 return 0;
170 }
171
stefano babicc95219f2007-11-20 10:40:24 +0100172 debug("mmc_block_wr dst %lx src %lx len %d\n", dst, (ulong) src, len);
wdenk71f95112003-06-15 22:40:42 +0000173
174 argh = len >> 16;
175 argl = len & 0xffff;
176
177 /* set block len */
stefano babicc95219f2007-11-20 10:40:24 +0100178 mmc_cmd(MMC_CMD_SET_BLOCKLEN, argh, argl, MMC_CMDAT_R1);
wdenk71f95112003-06-15 22:40:42 +0000179
180 /* send write command */
181 argh = dst >> 16;
182 argl = dst & 0xffff;
Marek Vasut3ba8bf72010-09-09 09:50:39 +0200183 writel(MMC_STRPCL_STOP_CLK, MMC_STRPCL);
184 writel(1, MMC_NOB);
185 writel(len, MMC_BLKLEN);
Tom Rixe3ba7f12009-02-20 03:47:50 +0100186 mmc_cmd(MMC_CMD_WRITE_SINGLE_BLOCK, argh, argl,
stefano babicc95219f2007-11-20 10:40:24 +0100187 MMC_CMDAT_R1 | MMC_CMDAT_WRITE | MMC_CMDAT_BLOCK |
188 MMC_CMDAT_DATA_EN);
wdenk8bde7f72003-06-27 21:31:46 +0000189
Marek Vasut3ba8bf72010-09-09 09:50:39 +0200190 writel(~MMC_I_MASK_TXFIFO_WR_REQ, MMC_I_MASK);
wdenk20787e22005-04-06 00:04:16 +0000191 while (len) {
Marek Vasut3ba8bf72010-09-09 09:50:39 +0200192 if (readl(MMC_I_REG) & MMC_I_REG_TXFIFO_WR_REQ) {
stefano babicc95219f2007-11-20 10:40:24 +0100193 int i, bytes = min(32, len);
wdenk71f95112003-06-15 22:40:42 +0000194
stefano babicc95219f2007-11-20 10:40:24 +0100195 for (i = 0; i < bytes; i++) {
Marek Vasut3ba8bf72010-09-09 09:50:39 +0200196 writel(*src++, MMC_TXFIFO);
wdenk71f95112003-06-15 22:40:42 +0000197 }
wdenk20787e22005-04-06 00:04:16 +0000198 if (bytes < 32) {
Marek Vasut3ba8bf72010-09-09 09:50:39 +0200199 writel(MMC_PRTBUF_BUF_PART_FULL, MMC_PRTBUF);
wdenk71f95112003-06-15 22:40:42 +0000200 }
201 len -= bytes;
202 }
Marek Vasut3ba8bf72010-09-09 09:50:39 +0200203 status = readl(MMC_STAT);
wdenk20787e22005-04-06 00:04:16 +0000204 if (status & MMC_STAT_ERRORS) {
wdenk71f95112003-06-15 22:40:42 +0000205 printf("MMC_STAT error %lx\n", status);
206 return -1;
207 }
208 }
Marek Vasut3ba8bf72010-09-09 09:50:39 +0200209 writel(~MMC_I_MASK_DATA_TRAN_DONE, MMC_I_MASK);
210 while (!(readl(MMC_I_REG) & MMC_I_REG_DATA_TRAN_DONE))
211 ;
212 writel(~MMC_I_MASK_PRG_DONE, MMC_I_MASK);
213 while (!(readl(MMC_I_REG) & MMC_I_REG_PRG_DONE))
214 ;
215 status = readl(MMC_STAT);
wdenk20787e22005-04-06 00:04:16 +0000216 if (status & MMC_STAT_ERRORS) {
wdenk71f95112003-06-15 22:40:42 +0000217 printf("MMC_STAT error %lx\n", status);
218 return -1;
219 }
220 return 0;
221}
222
wdenk71f95112003-06-15 22:40:42 +0000223int
224/****************************************************/
Andy Fleming682beea2009-02-20 03:47:50 +0100225pxa_mmc_read(long src, uchar * dst, int size)
wdenk71f95112003-06-15 22:40:42 +0000226/****************************************************/
227{
228 ulong end, part_start, part_end, part_len, aligned_start, aligned_end;
229 ulong mmc_block_size, mmc_block_address;
230
wdenk20787e22005-04-06 00:04:16 +0000231 if (size == 0) {
wdenk71f95112003-06-15 22:40:42 +0000232 return 0;
233 }
234
wdenk20787e22005-04-06 00:04:16 +0000235 if (!mmc_ready) {
wdenk71f95112003-06-15 22:40:42 +0000236 printf("Please initial the MMC first\n");
237 return -1;
238 }
239
240 mmc_block_size = MMC_BLOCK_SIZE;
241 mmc_block_address = ~(mmc_block_size - 1);
242
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200243 src -= CONFIG_SYS_MMC_BASE;
wdenk71f95112003-06-15 22:40:42 +0000244 end = src + size;
245 part_start = ~mmc_block_address & src;
246 part_end = ~mmc_block_address & end;
247 aligned_start = mmc_block_address & src;
248 aligned_end = mmc_block_address & end;
249
250 /* all block aligned accesses */
stefano babicc95219f2007-11-20 10:40:24 +0100251 debug
252 ("src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend %lx\n",
253 src, (ulong) dst, end, part_start, part_end, aligned_start,
254 aligned_end);
wdenk20787e22005-04-06 00:04:16 +0000255 if (part_start) {
wdenk71f95112003-06-15 22:40:42 +0000256 part_len = mmc_block_size - part_start;
stefano babicc95219f2007-11-20 10:40:24 +0100257 debug
258 ("ps src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend %lx\n",
259 src, (ulong) dst, end, part_start, part_end, aligned_start,
260 aligned_end);
261 if ((mmc_block_read(mmc_buf, aligned_start, mmc_block_size)) <
262 0) {
wdenk71f95112003-06-15 22:40:42 +0000263 return -1;
264 }
stefano babicc95219f2007-11-20 10:40:24 +0100265 memcpy(dst, mmc_buf + part_start, part_len);
wdenk71f95112003-06-15 22:40:42 +0000266 dst += part_len;
267 src += part_len;
268 }
stefano babicc95219f2007-11-20 10:40:24 +0100269 debug
270 ("src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend %lx\n",
271 src, (ulong) dst, end, part_start, part_end, aligned_start,
272 aligned_end);
wdenk20787e22005-04-06 00:04:16 +0000273 for (; src < aligned_end; src += mmc_block_size, dst += mmc_block_size) {
stefano babicc95219f2007-11-20 10:40:24 +0100274 debug
275 ("al src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend %lx\n",
276 src, (ulong) dst, end, part_start, part_end, aligned_start,
277 aligned_end);
278 if ((mmc_block_read((uchar *) (dst), src, mmc_block_size)) < 0) {
wdenk71f95112003-06-15 22:40:42 +0000279 return -1;
280 }
281 }
stefano babicc95219f2007-11-20 10:40:24 +0100282 debug
283 ("src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend %lx\n",
284 src, (ulong) dst, end, part_start, part_end, aligned_start,
285 aligned_end);
wdenk20787e22005-04-06 00:04:16 +0000286 if (part_end && src < end) {
stefano babicc95219f2007-11-20 10:40:24 +0100287 debug
288 ("pe src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend %lx\n",
289 src, (ulong) dst, end, part_start, part_end, aligned_start,
290 aligned_end);
wdenk20787e22005-04-06 00:04:16 +0000291 if ((mmc_block_read(mmc_buf, aligned_end, mmc_block_size)) < 0) {
wdenk71f95112003-06-15 22:40:42 +0000292 return -1;
293 }
294 memcpy(dst, mmc_buf, part_end);
295 }
296 return 0;
297}
298
299int
300/****************************************************/
Andy Fleming682beea2009-02-20 03:47:50 +0100301pxa_mmc_write(uchar * src, ulong dst, int size)
wdenk71f95112003-06-15 22:40:42 +0000302/****************************************************/
303{
304 ulong end, part_start, part_end, part_len, aligned_start, aligned_end;
305 ulong mmc_block_size, mmc_block_address;
306
wdenk20787e22005-04-06 00:04:16 +0000307 if (size == 0) {
wdenk71f95112003-06-15 22:40:42 +0000308 return 0;
309 }
310
wdenk20787e22005-04-06 00:04:16 +0000311 if (!mmc_ready) {
wdenk71f95112003-06-15 22:40:42 +0000312 printf("Please initial the MMC first\n");
313 return -1;
314 }
315
316 mmc_block_size = MMC_BLOCK_SIZE;
317 mmc_block_address = ~(mmc_block_size - 1);
318
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200319 dst -= CONFIG_SYS_MMC_BASE;
wdenk71f95112003-06-15 22:40:42 +0000320 end = dst + size;
321 part_start = ~mmc_block_address & dst;
322 part_end = ~mmc_block_address & end;
323 aligned_start = mmc_block_address & dst;
324 aligned_end = mmc_block_address & end;
325
326 /* all block aligned accesses */
stefano babicc95219f2007-11-20 10:40:24 +0100327 debug
328 ("src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend %lx\n",
329 src, (ulong) dst, end, part_start, part_end, aligned_start,
330 aligned_end);
wdenk20787e22005-04-06 00:04:16 +0000331 if (part_start) {
wdenk71f95112003-06-15 22:40:42 +0000332 part_len = mmc_block_size - part_start;
stefano babicc95219f2007-11-20 10:40:24 +0100333 debug
334 ("ps src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend %lx\n",
335 (ulong) src, dst, end, part_start, part_end, aligned_start,
336 aligned_end);
337 if ((mmc_block_read(mmc_buf, aligned_start, mmc_block_size)) <
338 0) {
wdenk71f95112003-06-15 22:40:42 +0000339 return -1;
340 }
stefano babicc95219f2007-11-20 10:40:24 +0100341 memcpy(mmc_buf + part_start, src, part_len);
342 if ((mmc_block_write(aligned_start, mmc_buf, mmc_block_size)) <
343 0) {
wdenk71f95112003-06-15 22:40:42 +0000344 return -1;
345 }
346 dst += part_len;
347 src += part_len;
348 }
stefano babicc95219f2007-11-20 10:40:24 +0100349 debug
350 ("src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend %lx\n",
351 src, (ulong) dst, end, part_start, part_end, aligned_start,
352 aligned_end);
wdenk20787e22005-04-06 00:04:16 +0000353 for (; dst < aligned_end; src += mmc_block_size, dst += mmc_block_size) {
stefano babicc95219f2007-11-20 10:40:24 +0100354 debug
355 ("al src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend %lx\n",
356 src, (ulong) dst, end, part_start, part_end, aligned_start,
357 aligned_end);
358 if ((mmc_block_write(dst, (uchar *) src, mmc_block_size)) < 0) {
wdenk71f95112003-06-15 22:40:42 +0000359 return -1;
360 }
361 }
stefano babicc95219f2007-11-20 10:40:24 +0100362 debug
363 ("src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend %lx\n",
364 src, (ulong) dst, end, part_start, part_end, aligned_start,
365 aligned_end);
wdenk20787e22005-04-06 00:04:16 +0000366 if (part_end && dst < end) {
stefano babicc95219f2007-11-20 10:40:24 +0100367 debug
368 ("pe src %lx dst %lx end %lx pstart %lx pend %lx astart %lx aend %lx\n",
369 src, (ulong) dst, end, part_start, part_end, aligned_start,
370 aligned_end);
wdenk20787e22005-04-06 00:04:16 +0000371 if ((mmc_block_read(mmc_buf, aligned_end, mmc_block_size)) < 0) {
wdenk71f95112003-06-15 22:40:42 +0000372 return -1;
373 }
374 memcpy(mmc_buf, src, part_end);
wdenk20787e22005-04-06 00:04:16 +0000375 if ((mmc_block_write(aligned_end, mmc_buf, mmc_block_size)) < 0) {
wdenk71f95112003-06-15 22:40:42 +0000376 return -1;
377 }
378 }
379 return 0;
380}
381
Andy Fleming682beea2009-02-20 03:47:50 +0100382static ulong
wdenk71f95112003-06-15 22:40:42 +0000383/****************************************************/
Jean-Christophe PLAGNIOL-VILLARD0937b8d2008-02-17 14:15:32 +0100384mmc_bread(int dev_num, ulong blknr, lbaint_t blkcnt, void *dst)
wdenk71f95112003-06-15 22:40:42 +0000385/****************************************************/
386{
387 int mmc_block_size = MMC_BLOCK_SIZE;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200388 ulong src = blknr * mmc_block_size + CONFIG_SYS_MMC_BASE;
wdenk71f95112003-06-15 22:40:42 +0000389
Andy Fleming682beea2009-02-20 03:47:50 +0100390 pxa_mmc_read(src, (uchar *) dst, blkcnt * mmc_block_size);
wdenk71f95112003-06-15 22:40:42 +0000391 return blkcnt;
392}
393
stefano babicc95219f2007-11-20 10:40:24 +0100394#ifdef __GNUC__
395#define likely(x) __builtin_expect(!!(x), 1)
396#define unlikely(x) __builtin_expect(!!(x), 0)
397#else
398#define likely(x) (x)
399#define unlikely(x) (x)
400#endif
401
402#define UNSTUFF_BITS(resp,start,size) \
403 ({ \
404 const int __size = size; \
405 const uint32_t __mask = (__size < 32 ? 1 << __size : 0) - 1; \
406 const int32_t __off = 3 - ((start) / 32); \
407 const int32_t __shft = (start) & 31; \
408 uint32_t __res; \
409 \
410 __res = resp[__off] >> __shft; \
411 if (__size + __shft > 32) \
412 __res |= resp[__off-1] << ((32 - __shft) % 32); \
413 __res & __mask; \
414 })
415
416/*
417 * Given the decoded CSD structure, decode the raw CID to our CID structure.
418 */
419static void mmc_decode_cid(uint32_t * resp)
420{
421 if (IF_TYPE_SD == mmc_dev.if_type) {
422 /*
423 * SD doesn't currently have a version field so we will
424 * have to assume we can parse this.
425 */
426 sprintf((char *)mmc_dev.vendor,
427 "Man %02x OEM %c%c \"%c%c%c%c%c\" Date %02u/%04u",
428 UNSTUFF_BITS(resp, 120, 8), UNSTUFF_BITS(resp, 112, 8),
429 UNSTUFF_BITS(resp, 104, 8), UNSTUFF_BITS(resp, 96, 8),
430 UNSTUFF_BITS(resp, 88, 8), UNSTUFF_BITS(resp, 80, 8),
431 UNSTUFF_BITS(resp, 72, 8), UNSTUFF_BITS(resp, 64, 8),
432 UNSTUFF_BITS(resp, 8, 4), UNSTUFF_BITS(resp, 12,
433 8) + 2000);
434 sprintf((char *)mmc_dev.revision, "%d.%d",
435 UNSTUFF_BITS(resp, 60, 4), UNSTUFF_BITS(resp, 56, 4));
436 sprintf((char *)mmc_dev.product, "%u",
437 UNSTUFF_BITS(resp, 24, 32));
438 } else {
439 /*
440 * The selection of the format here is based upon published
441 * specs from sandisk and from what people have reported.
442 */
443 switch (spec_ver) {
444 case 0: /* MMC v1.0 - v1.2 */
445 case 1: /* MMC v1.4 */
446 sprintf((char *)mmc_dev.vendor,
447 "Man %02x%02x%02x \"%c%c%c%c%c%c%c\" Date %02u/%04u",
448 UNSTUFF_BITS(resp, 120, 8), UNSTUFF_BITS(resp,
449 112,
450 8),
451 UNSTUFF_BITS(resp, 104, 8), UNSTUFF_BITS(resp,
452 96, 8),
453 UNSTUFF_BITS(resp, 88, 8), UNSTUFF_BITS(resp,
454 80, 8),
455 UNSTUFF_BITS(resp, 72, 8), UNSTUFF_BITS(resp,
456 64, 8),
457 UNSTUFF_BITS(resp, 56, 8), UNSTUFF_BITS(resp,
458 48, 8),
459 UNSTUFF_BITS(resp, 12, 4), UNSTUFF_BITS(resp, 8,
460 4) +
461 1997);
462 sprintf((char *)mmc_dev.revision, "%d.%d",
463 UNSTUFF_BITS(resp, 44, 4), UNSTUFF_BITS(resp,
464 40, 4));
465 sprintf((char *)mmc_dev.product, "%u",
466 UNSTUFF_BITS(resp, 16, 24));
467 break;
468
469 case 2: /* MMC v2.0 - v2.2 */
470 case 3: /* MMC v3.1 - v3.3 */
471 case 4: /* MMC v4 */
472 sprintf((char *)mmc_dev.vendor,
473 "Man %02x OEM %04x \"%c%c%c%c%c%c\" Date %02u/%04u",
474 UNSTUFF_BITS(resp, 120, 8), UNSTUFF_BITS(resp,
475 104,
476 16),
477 UNSTUFF_BITS(resp, 96, 8), UNSTUFF_BITS(resp,
478 88, 8),
479 UNSTUFF_BITS(resp, 80, 8), UNSTUFF_BITS(resp,
480 72, 8),
481 UNSTUFF_BITS(resp, 64, 8), UNSTUFF_BITS(resp,
482 56, 8),
483 UNSTUFF_BITS(resp, 12, 4), UNSTUFF_BITS(resp, 8,
484 4) +
485 1997);
486 sprintf((char *)mmc_dev.product, "%u",
487 UNSTUFF_BITS(resp, 16, 32));
488 sprintf((char *)mmc_dev.revision, "N/A");
489 break;
490
491 default:
492 printf("MMC card has unknown MMCA version %d\n",
493 spec_ver);
494 break;
495 }
496 }
497 printf("%s card.\nVendor: %s\nProduct: %s\nRevision: %s\n",
498 (IF_TYPE_SD == mmc_dev.if_type) ? "SD" : "MMC", mmc_dev.vendor,
499 mmc_dev.product, mmc_dev.revision);
500}
501
502/*
503 * Given a 128-bit response, decode to our card CSD structure.
504 */
505static void mmc_decode_csd(uint32_t * resp)
506{
507 unsigned int mult, csd_struct;
508
509 if (IF_TYPE_SD == mmc_dev.if_type) {
510 csd_struct = UNSTUFF_BITS(resp, 126, 2);
511 if (csd_struct != 0) {
512 printf("SD: unrecognised CSD structure version %d\n",
513 csd_struct);
514 return;
515 }
516 } else {
517 /*
518 * We only understand CSD structure v1.1 and v1.2.
519 * v1.2 has extra information in bits 15, 11 and 10.
520 */
521 csd_struct = UNSTUFF_BITS(resp, 126, 2);
522 if (csd_struct != 1 && csd_struct != 2) {
523 printf("MMC: unrecognised CSD structure version %d\n",
524 csd_struct);
525 return;
526 }
527
528 spec_ver = UNSTUFF_BITS(resp, 122, 4);
529 mmc_dev.if_type = IF_TYPE_MMC;
530 }
531
532 mult = 1 << (UNSTUFF_BITS(resp, 47, 3) + 2);
533 mmc_dev.lba = (1 + UNSTUFF_BITS(resp, 62, 12)) * mult;
534 mmc_dev.blksz = 1 << UNSTUFF_BITS(resp, 80, 4);
535
536 /* FIXME: The following just makes assumes that's the partition type -- should really read it */
537 mmc_dev.part_type = PART_TYPE_DOS;
538 mmc_dev.dev = 0;
539 mmc_dev.lun = 0;
540 mmc_dev.type = DEV_TYPE_HARDDISK;
541 mmc_dev.removable = 0;
542 mmc_dev.block_read = mmc_bread;
543
Jean-Christophe PLAGNIOL-VILLARD0a5676b2008-07-12 14:36:34 +0200544 printf("Detected: %lu blocks of %lu bytes (%luMB) ",
545 mmc_dev.lba,
546 mmc_dev.blksz,
547 mmc_dev.lba * mmc_dev.blksz / (1024 * 1024));
stefano babicc95219f2007-11-20 10:40:24 +0100548}
549
wdenk71f95112003-06-15 22:40:42 +0000550int
551/****************************************************/
Andy Flemingabb54662008-10-30 16:21:00 -0500552mmc_legacy_init(int verbose)
wdenk71f95112003-06-15 22:40:42 +0000553/****************************************************/
554{
stefano babicc95219f2007-11-20 10:40:24 +0100555 int retries, rc = -ENODEV;
556 uint32_t cid_resp[4];
557 uint32_t *resp;
558 uint16_t rca = 0;
wdenk71f95112003-06-15 22:40:42 +0000559
stefano babicc95219f2007-11-20 10:40:24 +0100560 /* Reset device interface type */
561 mmc_dev.if_type = IF_TYPE_UNKNOWN;
562
563#if defined (CONFIG_LUBBOCK) || (defined (CONFIG_GUMSTIX) && !defined(CONFIG_PXA27X))
564 set_GPIO_mode(GPIO6_MMCCLK_MD);
565 set_GPIO_mode(GPIO8_MMCCS0_MD);
wdenk71f95112003-06-15 22:40:42 +0000566#endif
Marek Vasut43c15d32009-10-14 00:25:33 +0200567#ifdef CONFIG_CPU_MONAHANS /* pxa3xx */
Marek Vasut3ba8bf72010-09-09 09:50:39 +0200568 writel(readl(CKENA) | CKENA_12_MMC0 | CKENA_13_MMC1, CKENA);
Marek Vasut43c15d32009-10-14 00:25:33 +0200569#else /* pxa2xx */
Marek Vasut3ba8bf72010-09-09 09:50:39 +0200570 writel(readl(CKEN) | CKEN12_MMC, CKEN); /* enable MMC unit clock */
Marek Vasut43c15d32009-10-14 00:25:33 +0200571#endif
Marek Vasut3ba8bf72010-09-09 09:50:39 +0200572 writel(MMC_CLKRT_0_3125MHZ, MMC_CLKRT);
573 writel(MMC_RES_TO_MAX, MMC_RESTO);
574 writel(MMC_SPI_DISABLE, MMC_SPI);
wdenk71f95112003-06-15 22:40:42 +0000575
576 /* reset */
Haavard Skinnemoen341188b2008-05-22 11:09:59 +0200577 mmc_cmd(MMC_CMD_GO_IDLE_STATE, 0, 0, MMC_CMDAT_INIT | MMC_CMDAT_R0);
stefano babicc95219f2007-11-20 10:40:24 +0100578 udelay(200000);
579 retries = 3;
580 while (retries--) {
581 resp = mmc_cmd(MMC_CMD_APP_CMD, 0, 0, MMC_CMDAT_R1);
582 if (!(resp[0] & 0x00000020)) { /* Card does not support APP_CMD */
583 debug("Card does not support APP_CMD\n");
584 break;
585 }
586
Adrian Filipic455d072008-07-18 11:52:02 -0400587 /* Select 3.2-3.3V and 3.3-3.4V */
588 resp = mmc_cmd(SD_CMD_APP_SEND_OP_COND, 0x0030, 0x0000,
Haavard Skinnemoen341188b2008-05-22 11:09:59 +0200589 MMC_CMDAT_R3 | (retries < 2 ? 0
590 : MMC_CMDAT_INIT));
stefano babicc95219f2007-11-20 10:40:24 +0100591 if (resp[0] & 0x80000000) {
592 mmc_dev.if_type = IF_TYPE_SD;
593 debug("Detected SD card\n");
594 break;
595 }
stefano babicc95219f2007-11-20 10:40:24 +0100596 udelay(200000);
stefano babicc95219f2007-11-20 10:40:24 +0100597 }
598
599 if (retries <= 0 || !(IF_TYPE_SD == mmc_dev.if_type)) {
600 debug("Failed to detect SD Card, trying MMC\n");
601 resp =
602 mmc_cmd(MMC_CMD_SEND_OP_COND, 0x00ff, 0x8000, MMC_CMDAT_R3);
603
604 retries = 10;
605 while (retries-- && resp && !(resp[0] & 0x80000000)) {
stefano babicc95219f2007-11-20 10:40:24 +0100606 udelay(200000);
stefano babicc95219f2007-11-20 10:40:24 +0100607 resp =
608 mmc_cmd(MMC_CMD_SEND_OP_COND, 0x00ff, 0x8000,
609 MMC_CMDAT_R3);
610 }
wdenk71f95112003-06-15 22:40:42 +0000611 }
612
613 /* try to get card id */
stefano babicc95219f2007-11-20 10:40:24 +0100614 resp =
615 mmc_cmd(MMC_CMD_ALL_SEND_CID, 0, 0, MMC_CMDAT_R2 | MMC_CMDAT_BUSY);
wdenk20787e22005-04-06 00:04:16 +0000616 if (resp) {
stefano babicc95219f2007-11-20 10:40:24 +0100617 memcpy(cid_resp, resp, sizeof(cid_resp));
wdenk71f95112003-06-15 22:40:42 +0000618
619 /* MMC exists, get CSD too */
Haavard Skinnemoen341188b2008-05-22 11:09:59 +0200620 resp = mmc_cmd(MMC_CMD_SET_RELATIVE_ADDR, 0, 0, MMC_CMDAT_R1);
stefano babicc95219f2007-11-20 10:40:24 +0100621 if (IF_TYPE_SD == mmc_dev.if_type)
622 rca = ((resp[0] & 0xffff0000) >> 16);
623 resp = mmc_cmd(MMC_CMD_SEND_CSD, rca, 0, MMC_CMDAT_R2);
wdenk20787e22005-04-06 00:04:16 +0000624 if (resp) {
stefano babicc95219f2007-11-20 10:40:24 +0100625 mmc_decode_csd(resp);
wdenk71f95112003-06-15 22:40:42 +0000626 rc = 0;
627 mmc_ready = 1;
wdenk71f95112003-06-15 22:40:42 +0000628 }
stefano babicc95219f2007-11-20 10:40:24 +0100629
630 mmc_decode_cid(cid_resp);
wdenk71f95112003-06-15 22:40:42 +0000631 }
632
Marek Vasut3ba8bf72010-09-09 09:50:39 +0200633 writel(0, MMC_CLKRT); /* 20 MHz */
stefano babicc95219f2007-11-20 10:40:24 +0100634 resp = mmc_cmd(MMC_CMD_SELECT_CARD, rca, 0, MMC_CMDAT_R1);
wdenk71f95112003-06-15 22:40:42 +0000635
Marek Vasut43c15d32009-10-14 00:25:33 +0200636#if defined(CONFIG_PXA27X) || defined(CONFIG_CPU_MONAHANS)
stefano babicc95219f2007-11-20 10:40:24 +0100637 if (IF_TYPE_SD == mmc_dev.if_type) {
638 resp = mmc_cmd(MMC_CMD_APP_CMD, rca, 0, MMC_CMDAT_R1);
639 resp = mmc_cmd(SD_CMD_APP_SET_BUS_WIDTH, 0, 2, MMC_CMDAT_R1);
640 wide = MMC_CMDAT_SD_4DAT;
641 }
642#endif
643
644 fat_register_device(&mmc_dev, 1); /* partitions start counting with 1 */
wdenk71f95112003-06-15 22:40:42 +0000645
646 return rc;
647}