blob: e1817e24f6d43f04740215e21bf061b42b723cd3 [file] [log] [blame]
Tom Warren21ef6a12011-05-31 10:30:37 +00001/*
2 * (C) Copyright 2009 SAMSUNG Electronics
3 * Minkyu Kang <mk7.kang@samsung.com>
4 * Jaehoon Chung <jh80.chung@samsung.com>
Tom Warrenc9aa8312013-02-21 12:31:30 +00005 * Portions Copyright 2011-2013 NVIDIA Corporation
Tom Warren21ef6a12011-05-31 10:30:37 +00006 *
Wolfgang Denk1a459662013-07-08 09:37:19 +02007 * SPDX-License-Identifier: GPL-2.0+
Tom Warren21ef6a12011-05-31 10:30:37 +00008 */
9
Stephen Warren19815392012-11-06 11:27:30 +000010#include <bouncebuf.h>
Tom Warren21ef6a12011-05-31 10:30:37 +000011#include <common.h>
Stephen Warren98778412011-10-31 06:51:36 +000012#include <asm/gpio.h>
Tom Warren21ef6a12011-05-31 10:30:37 +000013#include <asm/io.h>
Simon Glass4ed59e72011-09-21 12:40:04 +000014#include <asm/arch/clock.h>
Tom Warren150c2492012-09-19 15:50:56 -070015#include <asm/arch-tegra/clk_rst.h>
16#include <asm/arch-tegra/tegra_mmc.h>
17#include <mmc.h>
Tom Warren21ef6a12011-05-31 10:30:37 +000018
Tom Warrenc9aa8312013-02-21 12:31:30 +000019DECLARE_GLOBAL_DATA_PTR;
Tom Warren21ef6a12011-05-31 10:30:37 +000020
Tom Warrenc9aa8312013-02-21 12:31:30 +000021struct mmc mmc_dev[MAX_HOSTS];
22struct mmc_host mmc_host[MAX_HOSTS];
Simon Glass4ed59e72011-09-21 12:40:04 +000023
Tom Warrenc9aa8312013-02-21 12:31:30 +000024#ifndef CONFIG_OF_CONTROL
25#error "Please enable device tree support to use this driver"
26#endif
Tom Warren21ef6a12011-05-31 10:30:37 +000027
Tom Warren2d348a12013-02-26 12:31:26 -070028static void mmc_set_power(struct mmc_host *host, unsigned short power)
29{
30 u8 pwr = 0;
31 debug("%s: power = %x\n", __func__, power);
32
33 if (power != (unsigned short)-1) {
34 switch (1 << power) {
35 case MMC_VDD_165_195:
36 pwr = TEGRA_MMC_PWRCTL_SD_BUS_VOLTAGE_V1_8;
37 break;
38 case MMC_VDD_29_30:
39 case MMC_VDD_30_31:
40 pwr = TEGRA_MMC_PWRCTL_SD_BUS_VOLTAGE_V3_0;
41 break;
42 case MMC_VDD_32_33:
43 case MMC_VDD_33_34:
44 pwr = TEGRA_MMC_PWRCTL_SD_BUS_VOLTAGE_V3_3;
45 break;
46 }
47 }
48 debug("%s: pwr = %X\n", __func__, pwr);
49
50 /* Set the bus voltage first (if any) */
51 writeb(pwr, &host->reg->pwrcon);
52 if (pwr == 0)
53 return;
54
55 /* Now enable bus power */
56 pwr |= TEGRA_MMC_PWRCTL_SD_BUS_POWER;
57 writeb(pwr, &host->reg->pwrcon);
58}
59
Stephen Warren19815392012-11-06 11:27:30 +000060static void mmc_prepare_data(struct mmc_host *host, struct mmc_data *data,
61 struct bounce_buffer *bbstate)
Tom Warren21ef6a12011-05-31 10:30:37 +000062{
63 unsigned char ctrl;
64
Tom Warren21ef6a12011-05-31 10:30:37 +000065
Stephen Warren19815392012-11-06 11:27:30 +000066 debug("buf: %p (%p), data->blocks: %u, data->blocksize: %u\n",
67 bbstate->bounce_buffer, bbstate->user_buffer, data->blocks,
68 data->blocksize);
69
70 writel((u32)bbstate->bounce_buffer, &host->reg->sysad);
Tom Warren21ef6a12011-05-31 10:30:37 +000071 /*
72 * DMASEL[4:3]
73 * 00 = Selects SDMA
74 * 01 = Reserved
75 * 10 = Selects 32-bit Address ADMA2
76 * 11 = Selects 64-bit Address ADMA2
77 */
78 ctrl = readb(&host->reg->hostctl);
Anton staaf8e42f0d2011-11-10 11:56:49 +000079 ctrl &= ~TEGRA_MMC_HOSTCTL_DMASEL_MASK;
80 ctrl |= TEGRA_MMC_HOSTCTL_DMASEL_SDMA;
Tom Warren21ef6a12011-05-31 10:30:37 +000081 writeb(ctrl, &host->reg->hostctl);
82
83 /* We do not handle DMA boundaries, so set it to max (512 KiB) */
84 writew((7 << 12) | (data->blocksize & 0xFFF), &host->reg->blksize);
85 writew(data->blocks, &host->reg->blkcnt);
86}
87
88static void mmc_set_transfer_mode(struct mmc_host *host, struct mmc_data *data)
89{
90 unsigned short mode;
91 debug(" mmc_set_transfer_mode called\n");
92 /*
93 * TRNMOD
94 * MUL1SIN0[5] : Multi/Single Block Select
95 * RD1WT0[4] : Data Transfer Direction Select
96 * 1 = read
97 * 0 = write
98 * ENACMD12[2] : Auto CMD12 Enable
99 * ENBLKCNT[1] : Block Count Enable
100 * ENDMA[0] : DMA Enable
101 */
Anton staaf8e42f0d2011-11-10 11:56:49 +0000102 mode = (TEGRA_MMC_TRNMOD_DMA_ENABLE |
103 TEGRA_MMC_TRNMOD_BLOCK_COUNT_ENABLE);
104
Tom Warren21ef6a12011-05-31 10:30:37 +0000105 if (data->blocks > 1)
Anton staaf8e42f0d2011-11-10 11:56:49 +0000106 mode |= TEGRA_MMC_TRNMOD_MULTI_BLOCK_SELECT;
107
Tom Warren21ef6a12011-05-31 10:30:37 +0000108 if (data->flags & MMC_DATA_READ)
Anton staaf8e42f0d2011-11-10 11:56:49 +0000109 mode |= TEGRA_MMC_TRNMOD_DATA_XFER_DIR_SEL_READ;
Tom Warren21ef6a12011-05-31 10:30:37 +0000110
111 writew(mode, &host->reg->trnmod);
112}
113
Anton staaf0963ff32011-11-10 11:56:52 +0000114static int mmc_wait_inhibit(struct mmc_host *host,
115 struct mmc_cmd *cmd,
116 struct mmc_data *data,
117 unsigned int timeout)
Tom Warren21ef6a12011-05-31 10:30:37 +0000118{
Tom Warren21ef6a12011-05-31 10:30:37 +0000119 /*
120 * PRNSTS
Anton staaf0963ff32011-11-10 11:56:52 +0000121 * CMDINHDAT[1] : Command Inhibit (DAT)
122 * CMDINHCMD[0] : Command Inhibit (CMD)
Tom Warren21ef6a12011-05-31 10:30:37 +0000123 */
Anton staaf0963ff32011-11-10 11:56:52 +0000124 unsigned int mask = TEGRA_MMC_PRNSTS_CMD_INHIBIT_CMD;
Tom Warren21ef6a12011-05-31 10:30:37 +0000125
126 /*
127 * We shouldn't wait for data inhibit for stop commands, even
128 * though they might use busy signaling
129 */
Anton staaf0963ff32011-11-10 11:56:52 +0000130 if ((data == NULL) && (cmd->resp_type & MMC_RSP_BUSY))
131 mask |= TEGRA_MMC_PRNSTS_CMD_INHIBIT_DAT;
Tom Warren21ef6a12011-05-31 10:30:37 +0000132
133 while (readl(&host->reg->prnsts) & mask) {
134 if (timeout == 0) {
135 printf("%s: timeout error\n", __func__);
136 return -1;
137 }
138 timeout--;
139 udelay(1000);
140 }
141
Anton staaf0963ff32011-11-10 11:56:52 +0000142 return 0;
143}
144
Stephen Warren19815392012-11-06 11:27:30 +0000145static int mmc_send_cmd_bounced(struct mmc *mmc, struct mmc_cmd *cmd,
146 struct mmc_data *data, struct bounce_buffer *bbstate)
Anton staaf0963ff32011-11-10 11:56:52 +0000147{
148 struct mmc_host *host = (struct mmc_host *)mmc->priv;
149 int flags, i;
150 int result;
Anatolij Gustschin60e242e2012-03-28 03:40:00 +0000151 unsigned int mask = 0;
Anton staaf0963ff32011-11-10 11:56:52 +0000152 unsigned int retry = 0x100000;
153 debug(" mmc_send_cmd called\n");
154
155 result = mmc_wait_inhibit(host, cmd, data, 10 /* ms */);
156
157 if (result < 0)
158 return result;
159
Tom Warren21ef6a12011-05-31 10:30:37 +0000160 if (data)
Stephen Warren19815392012-11-06 11:27:30 +0000161 mmc_prepare_data(host, data, bbstate);
Tom Warren21ef6a12011-05-31 10:30:37 +0000162
163 debug("cmd->arg: %08x\n", cmd->cmdarg);
164 writel(cmd->cmdarg, &host->reg->argument);
165
166 if (data)
167 mmc_set_transfer_mode(host, data);
168
169 if ((cmd->resp_type & MMC_RSP_136) && (cmd->resp_type & MMC_RSP_BUSY))
170 return -1;
171
172 /*
173 * CMDREG
174 * CMDIDX[13:8] : Command index
175 * DATAPRNT[5] : Data Present Select
176 * ENCMDIDX[4] : Command Index Check Enable
177 * ENCMDCRC[3] : Command CRC Check Enable
178 * RSPTYP[1:0]
179 * 00 = No Response
180 * 01 = Length 136
181 * 10 = Length 48
182 * 11 = Length 48 Check busy after response
183 */
184 if (!(cmd->resp_type & MMC_RSP_PRESENT))
Anton staaf8e42f0d2011-11-10 11:56:49 +0000185 flags = TEGRA_MMC_CMDREG_RESP_TYPE_SELECT_NO_RESPONSE;
Tom Warren21ef6a12011-05-31 10:30:37 +0000186 else if (cmd->resp_type & MMC_RSP_136)
Anton staaf8e42f0d2011-11-10 11:56:49 +0000187 flags = TEGRA_MMC_CMDREG_RESP_TYPE_SELECT_LENGTH_136;
Tom Warren21ef6a12011-05-31 10:30:37 +0000188 else if (cmd->resp_type & MMC_RSP_BUSY)
Anton staaf8e42f0d2011-11-10 11:56:49 +0000189 flags = TEGRA_MMC_CMDREG_RESP_TYPE_SELECT_LENGTH_48_BUSY;
Tom Warren21ef6a12011-05-31 10:30:37 +0000190 else
Anton staaf8e42f0d2011-11-10 11:56:49 +0000191 flags = TEGRA_MMC_CMDREG_RESP_TYPE_SELECT_LENGTH_48;
Tom Warren21ef6a12011-05-31 10:30:37 +0000192
193 if (cmd->resp_type & MMC_RSP_CRC)
Anton staaf8e42f0d2011-11-10 11:56:49 +0000194 flags |= TEGRA_MMC_TRNMOD_CMD_CRC_CHECK;
Tom Warren21ef6a12011-05-31 10:30:37 +0000195 if (cmd->resp_type & MMC_RSP_OPCODE)
Anton staaf8e42f0d2011-11-10 11:56:49 +0000196 flags |= TEGRA_MMC_TRNMOD_CMD_INDEX_CHECK;
Tom Warren21ef6a12011-05-31 10:30:37 +0000197 if (data)
Anton staaf8e42f0d2011-11-10 11:56:49 +0000198 flags |= TEGRA_MMC_TRNMOD_DATA_PRESENT_SELECT_DATA_TRANSFER;
Tom Warren21ef6a12011-05-31 10:30:37 +0000199
200 debug("cmd: %d\n", cmd->cmdidx);
201
202 writew((cmd->cmdidx << 8) | flags, &host->reg->cmdreg);
203
204 for (i = 0; i < retry; i++) {
205 mask = readl(&host->reg->norintsts);
206 /* Command Complete */
Anton staaf8e42f0d2011-11-10 11:56:49 +0000207 if (mask & TEGRA_MMC_NORINTSTS_CMD_COMPLETE) {
Tom Warren21ef6a12011-05-31 10:30:37 +0000208 if (!data)
209 writel(mask, &host->reg->norintsts);
210 break;
211 }
212 }
213
214 if (i == retry) {
215 printf("%s: waiting for status update\n", __func__);
Tom Warrencf39cf52012-02-07 06:17:16 +0000216 writel(mask, &host->reg->norintsts);
Tom Warren21ef6a12011-05-31 10:30:37 +0000217 return TIMEOUT;
218 }
219
Anton staaf8e42f0d2011-11-10 11:56:49 +0000220 if (mask & TEGRA_MMC_NORINTSTS_CMD_TIMEOUT) {
Tom Warren21ef6a12011-05-31 10:30:37 +0000221 /* Timeout Error */
222 debug("timeout: %08x cmd %d\n", mask, cmd->cmdidx);
Tom Warrencf39cf52012-02-07 06:17:16 +0000223 writel(mask, &host->reg->norintsts);
Tom Warren21ef6a12011-05-31 10:30:37 +0000224 return TIMEOUT;
Anton staaf8e42f0d2011-11-10 11:56:49 +0000225 } else if (mask & TEGRA_MMC_NORINTSTS_ERR_INTERRUPT) {
Tom Warren21ef6a12011-05-31 10:30:37 +0000226 /* Error Interrupt */
227 debug("error: %08x cmd %d\n", mask, cmd->cmdidx);
Tom Warrencf39cf52012-02-07 06:17:16 +0000228 writel(mask, &host->reg->norintsts);
Tom Warren21ef6a12011-05-31 10:30:37 +0000229 return -1;
230 }
231
232 if (cmd->resp_type & MMC_RSP_PRESENT) {
233 if (cmd->resp_type & MMC_RSP_136) {
234 /* CRC is stripped so we need to do some shifting. */
235 for (i = 0; i < 4; i++) {
236 unsigned int offset =
237 (unsigned int)(&host->reg->rspreg3 - i);
238 cmd->response[i] = readl(offset) << 8;
239
240 if (i != 3) {
241 cmd->response[i] |=
242 readb(offset - 1);
243 }
244 debug("cmd->resp[%d]: %08x\n",
245 i, cmd->response[i]);
246 }
247 } else if (cmd->resp_type & MMC_RSP_BUSY) {
248 for (i = 0; i < retry; i++) {
249 /* PRNTDATA[23:20] : DAT[3:0] Line Signal */
250 if (readl(&host->reg->prnsts)
251 & (1 << 20)) /* DAT[0] */
252 break;
253 }
254
255 if (i == retry) {
256 printf("%s: card is still busy\n", __func__);
Tom Warrencf39cf52012-02-07 06:17:16 +0000257 writel(mask, &host->reg->norintsts);
Tom Warren21ef6a12011-05-31 10:30:37 +0000258 return TIMEOUT;
259 }
260
261 cmd->response[0] = readl(&host->reg->rspreg0);
262 debug("cmd->resp[0]: %08x\n", cmd->response[0]);
263 } else {
264 cmd->response[0] = readl(&host->reg->rspreg0);
265 debug("cmd->resp[0]: %08x\n", cmd->response[0]);
266 }
267 }
268
269 if (data) {
Anton staaf9b3d1872011-11-10 11:56:51 +0000270 unsigned long start = get_timer(0);
271
Tom Warren21ef6a12011-05-31 10:30:37 +0000272 while (1) {
273 mask = readl(&host->reg->norintsts);
274
Anton staaf8e42f0d2011-11-10 11:56:49 +0000275 if (mask & TEGRA_MMC_NORINTSTS_ERR_INTERRUPT) {
Tom Warren21ef6a12011-05-31 10:30:37 +0000276 /* Error Interrupt */
277 writel(mask, &host->reg->norintsts);
278 printf("%s: error during transfer: 0x%08x\n",
279 __func__, mask);
280 return -1;
Anton staaf8e42f0d2011-11-10 11:56:49 +0000281 } else if (mask & TEGRA_MMC_NORINTSTS_DMA_INTERRUPT) {
Anton staaf5a762e22011-11-10 11:56:50 +0000282 /*
283 * DMA Interrupt, restart the transfer where
284 * it was interrupted.
285 */
286 unsigned int address = readl(&host->reg->sysad);
287
Tom Warren21ef6a12011-05-31 10:30:37 +0000288 debug("DMA end\n");
Anton staaf5a762e22011-11-10 11:56:50 +0000289 writel(TEGRA_MMC_NORINTSTS_DMA_INTERRUPT,
290 &host->reg->norintsts);
291 writel(address, &host->reg->sysad);
Anton staaf8e42f0d2011-11-10 11:56:49 +0000292 } else if (mask & TEGRA_MMC_NORINTSTS_XFER_COMPLETE) {
Tom Warren21ef6a12011-05-31 10:30:37 +0000293 /* Transfer Complete */
294 debug("r/w is done\n");
295 break;
Anton staaf9b3d1872011-11-10 11:56:51 +0000296 } else if (get_timer(start) > 2000UL) {
297 writel(mask, &host->reg->norintsts);
298 printf("%s: MMC Timeout\n"
299 " Interrupt status 0x%08x\n"
300 " Interrupt status enable 0x%08x\n"
301 " Interrupt signal enable 0x%08x\n"
302 " Present status 0x%08x\n",
303 __func__, mask,
304 readl(&host->reg->norintstsen),
305 readl(&host->reg->norintsigen),
306 readl(&host->reg->prnsts));
307 return -1;
Tom Warren21ef6a12011-05-31 10:30:37 +0000308 }
309 }
310 writel(mask, &host->reg->norintsts);
311 }
312
313 udelay(1000);
314 return 0;
315}
316
Stephen Warren19815392012-11-06 11:27:30 +0000317static int mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd,
318 struct mmc_data *data)
319{
320 void *buf;
321 unsigned int bbflags;
322 size_t len;
323 struct bounce_buffer bbstate;
324 int ret;
325
326 if (data) {
327 if (data->flags & MMC_DATA_READ) {
328 buf = data->dest;
329 bbflags = GEN_BB_WRITE;
330 } else {
331 buf = (void *)data->src;
332 bbflags = GEN_BB_READ;
333 }
334 len = data->blocks * data->blocksize;
335
336 bounce_buffer_start(&bbstate, buf, len, bbflags);
337 }
338
339 ret = mmc_send_cmd_bounced(mmc, cmd, data, &bbstate);
340
341 if (data)
342 bounce_buffer_stop(&bbstate);
343
344 return ret;
345}
346
Tom Warren21ef6a12011-05-31 10:30:37 +0000347static void mmc_change_clock(struct mmc_host *host, uint clock)
348{
Simon Glass4ed59e72011-09-21 12:40:04 +0000349 int div;
Tom Warren21ef6a12011-05-31 10:30:37 +0000350 unsigned short clk;
351 unsigned long timeout;
Simon Glass4ed59e72011-09-21 12:40:04 +0000352
Tom Warren21ef6a12011-05-31 10:30:37 +0000353 debug(" mmc_change_clock called\n");
354
Simon Glass4ed59e72011-09-21 12:40:04 +0000355 /*
Tom Warren2d348a12013-02-26 12:31:26 -0700356 * Change Tegra SDMMCx clock divisor here. Source is PLLP_OUT0
Simon Glass4ed59e72011-09-21 12:40:04 +0000357 */
Tom Warren21ef6a12011-05-31 10:30:37 +0000358 if (clock == 0)
359 goto out;
Simon Glass4ed59e72011-09-21 12:40:04 +0000360 clock_adjust_periph_pll_div(host->mmc_id, CLOCK_ID_PERIPH, clock,
361 &div);
362 debug("div = %d\n", div);
Tom Warren21ef6a12011-05-31 10:30:37 +0000363
364 writew(0, &host->reg->clkcon);
365
Tom Warren21ef6a12011-05-31 10:30:37 +0000366 /*
367 * CLKCON
368 * SELFREQ[15:8] : base clock divided by value
369 * ENSDCLK[2] : SD Clock Enable
370 * STBLINTCLK[1] : Internal Clock Stable
371 * ENINTCLK[0] : Internal Clock Enable
372 */
Simon Glass4ed59e72011-09-21 12:40:04 +0000373 div >>= 1;
Anton staaf8e42f0d2011-11-10 11:56:49 +0000374 clk = ((div << TEGRA_MMC_CLKCON_SDCLK_FREQ_SEL_SHIFT) |
375 TEGRA_MMC_CLKCON_INTERNAL_CLOCK_ENABLE);
Tom Warren21ef6a12011-05-31 10:30:37 +0000376 writew(clk, &host->reg->clkcon);
377
378 /* Wait max 10 ms */
379 timeout = 10;
Anton staaf8e42f0d2011-11-10 11:56:49 +0000380 while (!(readw(&host->reg->clkcon) &
381 TEGRA_MMC_CLKCON_INTERNAL_CLOCK_STABLE)) {
Tom Warren21ef6a12011-05-31 10:30:37 +0000382 if (timeout == 0) {
383 printf("%s: timeout error\n", __func__);
384 return;
385 }
386 timeout--;
387 udelay(1000);
388 }
389
Anton staaf8e42f0d2011-11-10 11:56:49 +0000390 clk |= TEGRA_MMC_CLKCON_SD_CLOCK_ENABLE;
Tom Warren21ef6a12011-05-31 10:30:37 +0000391 writew(clk, &host->reg->clkcon);
392
393 debug("mmc_change_clock: clkcon = %08X\n", clk);
Tom Warren21ef6a12011-05-31 10:30:37 +0000394
395out:
396 host->clock = clock;
397}
398
399static void mmc_set_ios(struct mmc *mmc)
400{
401 struct mmc_host *host = mmc->priv;
402 unsigned char ctrl;
403 debug(" mmc_set_ios called\n");
404
405 debug("bus_width: %x, clock: %d\n", mmc->bus_width, mmc->clock);
406
407 /* Change clock first */
Tom Warren21ef6a12011-05-31 10:30:37 +0000408 mmc_change_clock(host, mmc->clock);
409
410 ctrl = readb(&host->reg->hostctl);
411
412 /*
413 * WIDE8[5]
414 * 0 = Depend on WIDE4
415 * 1 = 8-bit mode
416 * WIDE4[1]
417 * 1 = 4-bit mode
418 * 0 = 1-bit mode
419 */
420 if (mmc->bus_width == 8)
421 ctrl |= (1 << 5);
422 else if (mmc->bus_width == 4)
423 ctrl |= (1 << 1);
424 else
425 ctrl &= ~(1 << 1);
426
427 writeb(ctrl, &host->reg->hostctl);
428 debug("mmc_set_ios: hostctl = %08X\n", ctrl);
429}
430
Tom Warren2d348a12013-02-26 12:31:26 -0700431static void mmc_reset(struct mmc_host *host, struct mmc *mmc)
Tom Warren21ef6a12011-05-31 10:30:37 +0000432{
433 unsigned int timeout;
434 debug(" mmc_reset called\n");
435
436 /*
437 * RSTALL[0] : Software reset for all
438 * 1 = reset
439 * 0 = work
440 */
Anton staaf8e42f0d2011-11-10 11:56:49 +0000441 writeb(TEGRA_MMC_SWRST_SW_RESET_FOR_ALL, &host->reg->swrst);
Tom Warren21ef6a12011-05-31 10:30:37 +0000442
443 host->clock = 0;
444
445 /* Wait max 100 ms */
446 timeout = 100;
447
448 /* hw clears the bit when it's done */
Anton staaf8e42f0d2011-11-10 11:56:49 +0000449 while (readb(&host->reg->swrst) & TEGRA_MMC_SWRST_SW_RESET_FOR_ALL) {
Tom Warren21ef6a12011-05-31 10:30:37 +0000450 if (timeout == 0) {
451 printf("%s: timeout error\n", __func__);
452 return;
453 }
454 timeout--;
455 udelay(1000);
456 }
Tom Warren2d348a12013-02-26 12:31:26 -0700457
458 /* Set SD bus voltage & enable bus power */
459 mmc_set_power(host, fls(mmc->voltages) - 1);
460 debug("%s: power control = %02X, host control = %02X\n", __func__,
461 readb(&host->reg->pwrcon), readb(&host->reg->hostctl));
462
463 /* Make sure SDIO pads are set up */
464 pad_init_mmc(host);
Tom Warren21ef6a12011-05-31 10:30:37 +0000465}
466
467static int mmc_core_init(struct mmc *mmc)
468{
469 struct mmc_host *host = (struct mmc_host *)mmc->priv;
470 unsigned int mask;
471 debug(" mmc_core_init called\n");
472
Tom Warren2d348a12013-02-26 12:31:26 -0700473 mmc_reset(host, mmc);
Tom Warren21ef6a12011-05-31 10:30:37 +0000474
475 host->version = readw(&host->reg->hcver);
476 debug("host version = %x\n", host->version);
477
478 /* mask all */
479 writel(0xffffffff, &host->reg->norintstsen);
480 writel(0xffffffff, &host->reg->norintsigen);
481
482 writeb(0xe, &host->reg->timeoutcon); /* TMCLK * 2^27 */
483 /*
484 * NORMAL Interrupt Status Enable Register init
485 * [5] ENSTABUFRDRDY : Buffer Read Ready Status Enable
486 * [4] ENSTABUFWTRDY : Buffer write Ready Status Enable
Anton staaf5a762e22011-11-10 11:56:50 +0000487 * [3] ENSTADMAINT : DMA boundary interrupt
Tom Warren21ef6a12011-05-31 10:30:37 +0000488 * [1] ENSTASTANSCMPLT : Transfre Complete Status Enable
489 * [0] ENSTACMDCMPLT : Command Complete Status Enable
490 */
491 mask = readl(&host->reg->norintstsen);
492 mask &= ~(0xffff);
Anton staaf8e42f0d2011-11-10 11:56:49 +0000493 mask |= (TEGRA_MMC_NORINTSTSEN_CMD_COMPLETE |
494 TEGRA_MMC_NORINTSTSEN_XFER_COMPLETE |
Anton staaf5a762e22011-11-10 11:56:50 +0000495 TEGRA_MMC_NORINTSTSEN_DMA_INTERRUPT |
Anton staaf8e42f0d2011-11-10 11:56:49 +0000496 TEGRA_MMC_NORINTSTSEN_BUFFER_WRITE_READY |
497 TEGRA_MMC_NORINTSTSEN_BUFFER_READ_READY);
Tom Warren21ef6a12011-05-31 10:30:37 +0000498 writel(mask, &host->reg->norintstsen);
499
500 /*
501 * NORMAL Interrupt Signal Enable Register init
502 * [1] ENSTACMDCMPLT : Transfer Complete Signal Enable
503 */
504 mask = readl(&host->reg->norintsigen);
505 mask &= ~(0xffff);
Anton staaf8e42f0d2011-11-10 11:56:49 +0000506 mask |= TEGRA_MMC_NORINTSIGEN_XFER_COMPLETE;
Tom Warren21ef6a12011-05-31 10:30:37 +0000507 writel(mask, &host->reg->norintsigen);
508
509 return 0;
510}
511
Tom Warren29f3e3f2012-09-04 17:00:24 -0700512int tegra_mmc_getcd(struct mmc *mmc)
Thierry Redingbf836622012-01-02 01:15:39 +0000513{
514 struct mmc_host *host = (struct mmc_host *)mmc->priv;
515
Tom Warren29f3e3f2012-09-04 17:00:24 -0700516 debug("tegra_mmc_getcd called\n");
Thierry Redingbf836622012-01-02 01:15:39 +0000517
Tom Warrenc9aa8312013-02-21 12:31:30 +0000518 if (fdt_gpio_isvalid(&host->cd_gpio))
519 return fdtdec_get_gpio(&host->cd_gpio);
Thierry Redingbf836622012-01-02 01:15:39 +0000520
521 return 1;
522}
523
Tom Warrenc9aa8312013-02-21 12:31:30 +0000524static int do_mmc_init(int dev_index)
Tom Warren21ef6a12011-05-31 10:30:37 +0000525{
Stephen Warrende71fbe2011-10-31 06:51:34 +0000526 struct mmc_host *host;
Stephen Warren98778412011-10-31 06:51:36 +0000527 char gpusage[12]; /* "SD/MMCn PWR" or "SD/MMCn CD" */
Tom Warren21ef6a12011-05-31 10:30:37 +0000528 struct mmc *mmc;
529
Tom Warrenc9aa8312013-02-21 12:31:30 +0000530 /* DT should have been read & host config filled in */
Stephen Warrende71fbe2011-10-31 06:51:34 +0000531 host = &mmc_host[dev_index];
Tom Warrenc9aa8312013-02-21 12:31:30 +0000532 if (!host->enabled)
533 return -1;
534
535 debug(" do_mmc_init: index %d, bus width %d "
536 "pwr_gpio %d cd_gpio %d\n",
537 dev_index, host->width,
538 host->pwr_gpio.gpio, host->cd_gpio.gpio);
Stephen Warrende71fbe2011-10-31 06:51:34 +0000539
540 host->clock = 0;
Stephen Warrende71fbe2011-10-31 06:51:34 +0000541 clock_start_periph_pll(host->mmc_id, CLOCK_ID_PERIPH, 20000000);
542
Tom Warrenc9aa8312013-02-21 12:31:30 +0000543 if (fdt_gpio_isvalid(&host->pwr_gpio)) {
Stephen Warren98778412011-10-31 06:51:36 +0000544 sprintf(gpusage, "SD/MMC%d PWR", dev_index);
Tom Warrenc9aa8312013-02-21 12:31:30 +0000545 gpio_request(host->pwr_gpio.gpio, gpusage);
546 gpio_direction_output(host->pwr_gpio.gpio, 1);
547 debug(" Power GPIO name = %s\n", host->pwr_gpio.name);
Stephen Warren98778412011-10-31 06:51:36 +0000548 }
549
Tom Warrenc9aa8312013-02-21 12:31:30 +0000550 if (fdt_gpio_isvalid(&host->cd_gpio)) {
Stephen Warren98778412011-10-31 06:51:36 +0000551 sprintf(gpusage, "SD/MMC%d CD", dev_index);
Tom Warrenc9aa8312013-02-21 12:31:30 +0000552 gpio_request(host->cd_gpio.gpio, gpusage);
553 gpio_direction_input(host->cd_gpio.gpio);
554 debug(" CD GPIO name = %s\n", host->cd_gpio.name);
Stephen Warren98778412011-10-31 06:51:36 +0000555 }
556
Tom Warren21ef6a12011-05-31 10:30:37 +0000557 mmc = &mmc_dev[dev_index];
558
Tom Warren29f3e3f2012-09-04 17:00:24 -0700559 sprintf(mmc->name, "Tegra SD/MMC");
Stephen Warrende71fbe2011-10-31 06:51:34 +0000560 mmc->priv = host;
Tom Warren21ef6a12011-05-31 10:30:37 +0000561 mmc->send_cmd = mmc_send_cmd;
562 mmc->set_ios = mmc_set_ios;
563 mmc->init = mmc_core_init;
Tom Warren29f3e3f2012-09-04 17:00:24 -0700564 mmc->getcd = tegra_mmc_getcd;
Nikita Kiryanovd23d8d72012-12-03 02:19:46 +0000565 mmc->getwp = NULL;
Tom Warren21ef6a12011-05-31 10:30:37 +0000566
567 mmc->voltages = MMC_VDD_32_33 | MMC_VDD_33_34 | MMC_VDD_165_195;
Stephen Warren8c0ec0d2012-11-02 06:56:12 +0000568 mmc->host_caps = 0;
Tom Warrenc9aa8312013-02-21 12:31:30 +0000569 if (host->width == 8)
Stephen Warren8c0ec0d2012-11-02 06:56:12 +0000570 mmc->host_caps |= MMC_MODE_8BIT;
Tom Warrenc9aa8312013-02-21 12:31:30 +0000571 if (host->width >= 4)
Stephen Warren8c0ec0d2012-11-02 06:56:12 +0000572 mmc->host_caps |= MMC_MODE_4BIT;
Tom Warrenccf79882011-09-21 12:40:07 +0000573 mmc->host_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS | MMC_MODE_HC;
Tom Warren21ef6a12011-05-31 10:30:37 +0000574
575 /*
576 * min freq is for card identification, and is the highest
577 * low-speed SDIO card frequency (actually 400KHz)
578 * max freq is highest HS eMMC clock as per the SD/MMC spec
579 * (actually 52MHz)
Tom Warren21ef6a12011-05-31 10:30:37 +0000580 */
581 mmc->f_min = 375000;
582 mmc->f_max = 48000000;
583
Tom Warren21ef6a12011-05-31 10:30:37 +0000584 mmc_register(mmc);
585
586 return 0;
587}
Tom Warrenc9aa8312013-02-21 12:31:30 +0000588
589/**
590 * Get the host address and peripheral ID for a node.
591 *
592 * @param blob fdt blob
593 * @param node Device index (0-3)
594 * @param host Structure to fill in (reg, width, mmc_id)
595 */
596static int mmc_get_config(const void *blob, int node, struct mmc_host *host)
597{
598 debug("%s: node = %d\n", __func__, node);
599
600 host->enabled = fdtdec_get_is_enabled(blob, node);
601
602 host->reg = (struct tegra_mmc *)fdtdec_get_addr(blob, node, "reg");
603 if ((fdt_addr_t)host->reg == FDT_ADDR_T_NONE) {
604 debug("%s: no sdmmc base reg info found\n", __func__);
605 return -FDT_ERR_NOTFOUND;
606 }
607
608 host->mmc_id = clock_decode_periph_id(blob, node);
609 if (host->mmc_id == PERIPH_ID_NONE) {
610 debug("%s: could not decode periph id\n", __func__);
611 return -FDT_ERR_NOTFOUND;
612 }
613
614 /*
615 * NOTE: mmc->bus_width is determined by mmc.c dynamically.
616 * TBD: Override it with this value?
617 */
618 host->width = fdtdec_get_int(blob, node, "bus-width", 0);
619 if (!host->width)
620 debug("%s: no sdmmc width found\n", __func__);
621
622 /* These GPIOs are optional */
623 fdtdec_decode_gpio(blob, node, "cd-gpios", &host->cd_gpio);
624 fdtdec_decode_gpio(blob, node, "wp-gpios", &host->wp_gpio);
625 fdtdec_decode_gpio(blob, node, "power-gpios", &host->pwr_gpio);
626
627 debug("%s: found controller at %p, width = %d, periph_id = %d\n",
628 __func__, host->reg, host->width, host->mmc_id);
629 return 0;
630}
631
632/*
633 * Process a list of nodes, adding them to our list of SDMMC ports.
634 *
635 * @param blob fdt blob
636 * @param node_list list of nodes to process (any <=0 are ignored)
637 * @param count number of nodes to process
638 * @return 0 if ok, -1 on error
639 */
640static int process_nodes(const void *blob, int node_list[], int count)
641{
642 struct mmc_host *host;
643 int i, node;
644
645 debug("%s: count = %d\n", __func__, count);
646
647 /* build mmc_host[] for each controller */
648 for (i = 0; i < count; i++) {
649 node = node_list[i];
650 if (node <= 0)
651 continue;
652
653 host = &mmc_host[i];
654 host->id = i;
655
656 if (mmc_get_config(blob, node, host)) {
657 printf("%s: failed to decode dev %d\n", __func__, i);
658 return -1;
659 }
660 do_mmc_init(i);
661 }
662 return 0;
663}
664
665void tegra_mmc_init(void)
666{
667 int node_list[MAX_HOSTS], count;
668 const void *blob = gd->fdt_blob;
669 debug("%s entry\n", __func__);
670
Tom Warren2d348a12013-02-26 12:31:26 -0700671 /* See if any Tegra30 MMC controllers are present */
672 count = fdtdec_find_aliases_for_id(blob, "sdhci",
673 COMPAT_NVIDIA_TEGRA30_SDMMC, node_list, MAX_HOSTS);
674 debug("%s: count of T30 sdhci nodes is %d\n", __func__, count);
675 if (process_nodes(blob, node_list, count)) {
676 printf("%s: Error processing T30 mmc node(s)!\n", __func__);
677 return;
678 }
679
680 /* Now look for any Tegra20 MMC controllers */
Tom Warrenc9aa8312013-02-21 12:31:30 +0000681 count = fdtdec_find_aliases_for_id(blob, "sdhci",
682 COMPAT_NVIDIA_TEGRA20_SDMMC, node_list, MAX_HOSTS);
Tom Warren2d348a12013-02-26 12:31:26 -0700683 debug("%s: count of T20 sdhci nodes is %d\n", __func__, count);
Tom Warrenc9aa8312013-02-21 12:31:30 +0000684 if (process_nodes(blob, node_list, count)) {
Tom Warren2d348a12013-02-26 12:31:26 -0700685 printf("%s: Error processing T20 mmc node(s)!\n", __func__);
Tom Warrenc9aa8312013-02-21 12:31:30 +0000686 return;
687 }
688}