1 /* 2 * This is a driver for the SDHC controller found in Freescale MX2/MX3 3 * SoCs. It is basically the same hardware as found on MX1 (imxmmc.c). 4 * Unlike the hardware found on MX1, this hardware just works and does 5 * not need all the quirks found in imxmmc.c, hence the seperate driver. 6 * 7 * Copyright (C) 2009 Ilya Yanok, <yanok@emcraft.com> 8 * Copyright (C) 2008 Sascha Hauer, Pengutronix <s.hauer@pengutronix.de> 9 * Copyright (C) 2006 Pavel Pisa, PiKRON <ppisa@pikron.com> 10 * 11 * derived from pxamci.c by Russell King 12 * 13 * This program is free software; you can redistribute it and/or modify 14 * it under the terms of the GNU General Public License version 2 as 15 * published by the Free Software Foundation. 16 * 17 */ 18 19 #include <config.h> 20 #include <common.h> 21 #include <command.h> 22 #include <mmc.h> 23 #include <part.h> 24 #include <malloc.h> 25 #include <mmc.h> 26 #include <asm/errno.h> 27 #include <asm/io.h> 28 #include <asm/arch/clock.h> 29 30 #define DRIVER_NAME "mxc-mmc" 31 32 struct mxcmci_regs { 33 u32 str_stp_clk; 34 u32 status; 35 u32 clk_rate; 36 u32 cmd_dat_cont; 37 u32 res_to; 38 u32 read_to; 39 u32 blk_len; 40 u32 nob; 41 u32 rev_no; 42 u32 int_cntr; 43 u32 cmd; 44 u32 arg; 45 u32 pad; 46 u32 res_fifo; 47 u32 buffer_access; 48 }; 49 50 #define STR_STP_CLK_RESET (1 << 3) 51 #define STR_STP_CLK_START_CLK (1 << 1) 52 #define STR_STP_CLK_STOP_CLK (1 << 0) 53 54 #define STATUS_CARD_INSERTION (1 << 31) 55 #define STATUS_CARD_REMOVAL (1 << 30) 56 #define STATUS_YBUF_EMPTY (1 << 29) 57 #define STATUS_XBUF_EMPTY (1 << 28) 58 #define STATUS_YBUF_FULL (1 << 27) 59 #define STATUS_XBUF_FULL (1 << 26) 60 #define STATUS_BUF_UND_RUN (1 << 25) 61 #define STATUS_BUF_OVFL (1 << 24) 62 #define STATUS_SDIO_INT_ACTIVE (1 << 14) 63 #define STATUS_END_CMD_RESP (1 << 13) 64 #define STATUS_WRITE_OP_DONE (1 << 12) 65 #define STATUS_DATA_TRANS_DONE (1 << 11) 66 #define STATUS_READ_OP_DONE (1 << 11) 67 #define STATUS_WR_CRC_ERROR_CODE_MASK (3 << 10) 68 #define STATUS_CARD_BUS_CLK_RUN (1 << 8) 69 #define STATUS_BUF_READ_RDY (1 << 7) 70 #define STATUS_BUF_WRITE_RDY (1 << 6) 71 #define STATUS_RESP_CRC_ERR (1 << 5) 72 #define STATUS_CRC_READ_ERR (1 << 3) 73 #define STATUS_CRC_WRITE_ERR (1 << 2) 74 #define STATUS_TIME_OUT_RESP (1 << 1) 75 #define STATUS_TIME_OUT_READ (1 << 0) 76 #define STATUS_ERR_MASK 0x2f 77 78 #define CMD_DAT_CONT_CMD_RESP_LONG_OFF (1 << 12) 79 #define CMD_DAT_CONT_STOP_READWAIT (1 << 11) 80 #define CMD_DAT_CONT_START_READWAIT (1 << 10) 81 #define CMD_DAT_CONT_BUS_WIDTH_4 (2 << 8) 82 #define CMD_DAT_CONT_INIT (1 << 7) 83 #define CMD_DAT_CONT_WRITE (1 << 4) 84 #define CMD_DAT_CONT_DATA_ENABLE (1 << 3) 85 #define CMD_DAT_CONT_RESPONSE_48BIT_CRC (1 << 0) 86 #define CMD_DAT_CONT_RESPONSE_136BIT (2 << 0) 87 #define CMD_DAT_CONT_RESPONSE_48BIT (3 << 0) 88 89 #define INT_SDIO_INT_WKP_EN (1 << 18) 90 #define INT_CARD_INSERTION_WKP_EN (1 << 17) 91 #define INT_CARD_REMOVAL_WKP_EN (1 << 16) 92 #define INT_CARD_INSERTION_EN (1 << 15) 93 #define INT_CARD_REMOVAL_EN (1 << 14) 94 #define INT_SDIO_IRQ_EN (1 << 13) 95 #define INT_DAT0_EN (1 << 12) 96 #define INT_BUF_READ_EN (1 << 4) 97 #define INT_BUF_WRITE_EN (1 << 3) 98 #define INT_END_CMD_RES_EN (1 << 2) 99 #define INT_WRITE_OP_DONE_EN (1 << 1) 100 #define INT_READ_OP_EN (1 << 0) 101 102 struct mxcmci_host { 103 struct mmc *mmc; 104 struct mxcmci_regs *base; 105 int irq; 106 int detect_irq; 107 int dma; 108 int do_dma; 109 unsigned int power_mode; 110 111 struct mmc_cmd *cmd; 112 struct mmc_data *data; 113 114 unsigned int dma_nents; 115 unsigned int datasize; 116 unsigned int dma_dir; 117 118 u16 rev_no; 119 unsigned int cmdat; 120 121 int clock; 122 }; 123 124 static struct mxcmci_host mxcmci_host; 125 static struct mxcmci_host *host = &mxcmci_host; 126 127 static inline int mxcmci_use_dma(struct mxcmci_host *host) 128 { 129 return host->do_dma; 130 } 131 132 static void mxcmci_softreset(struct mxcmci_host *host) 133 { 134 int i; 135 136 /* reset sequence */ 137 writel(STR_STP_CLK_RESET, &host->base->str_stp_clk); 138 writel(STR_STP_CLK_RESET | STR_STP_CLK_START_CLK, 139 &host->base->str_stp_clk); 140 141 for (i = 0; i < 8; i++) 142 writel(STR_STP_CLK_START_CLK, &host->base->str_stp_clk); 143 144 writel(0xff, &host->base->res_to); 145 } 146 147 static void mxcmci_setup_data(struct mxcmci_host *host, struct mmc_data *data) 148 { 149 unsigned int nob = data->blocks; 150 unsigned int blksz = data->blocksize; 151 unsigned int datasize = nob * blksz; 152 153 host->data = data; 154 155 writel(nob, &host->base->nob); 156 writel(blksz, &host->base->blk_len); 157 host->datasize = datasize; 158 } 159 160 static int mxcmci_start_cmd(struct mxcmci_host *host, struct mmc_cmd *cmd, 161 unsigned int cmdat) 162 { 163 if (host->cmd != NULL) 164 printf("mxcmci: error!\n"); 165 host->cmd = cmd; 166 167 switch (cmd->resp_type) { 168 case MMC_RSP_R1: /* short CRC, OPCODE */ 169 case MMC_RSP_R1b:/* short CRC, OPCODE, BUSY */ 170 cmdat |= CMD_DAT_CONT_RESPONSE_48BIT_CRC; 171 break; 172 case MMC_RSP_R2: /* long 136 bit + CRC */ 173 cmdat |= CMD_DAT_CONT_RESPONSE_136BIT; 174 break; 175 case MMC_RSP_R3: /* short */ 176 cmdat |= CMD_DAT_CONT_RESPONSE_48BIT; 177 break; 178 case MMC_RSP_NONE: 179 break; 180 default: 181 printf("mxcmci: unhandled response type 0x%x\n", 182 cmd->resp_type); 183 return -EINVAL; 184 } 185 186 writel(cmd->cmdidx, &host->base->cmd); 187 writel(cmd->cmdarg, &host->base->arg); 188 writel(cmdat, &host->base->cmd_dat_cont); 189 190 return 0; 191 } 192 193 static void mxcmci_finish_request(struct mxcmci_host *host, 194 struct mmc_cmd *cmd, struct mmc_data *data) 195 { 196 host->cmd = NULL; 197 host->data = NULL; 198 } 199 200 static int mxcmci_finish_data(struct mxcmci_host *host, unsigned int stat) 201 { 202 int data_error = 0; 203 204 if (stat & STATUS_ERR_MASK) { 205 printf("request failed. status: 0x%08x\n", 206 stat); 207 if (stat & STATUS_CRC_READ_ERR) { 208 data_error = -EILSEQ; 209 } else if (stat & STATUS_CRC_WRITE_ERR) { 210 u32 err_code = (stat >> 9) & 0x3; 211 if (err_code == 2) /* No CRC response */ 212 data_error = TIMEOUT; 213 else 214 data_error = -EILSEQ; 215 } else if (stat & STATUS_TIME_OUT_READ) { 216 data_error = TIMEOUT; 217 } else { 218 data_error = -EIO; 219 } 220 } 221 222 host->data = NULL; 223 224 return data_error; 225 } 226 227 static int mxcmci_read_response(struct mxcmci_host *host, unsigned int stat) 228 { 229 struct mmc_cmd *cmd = host->cmd; 230 int i; 231 u32 a, b, c; 232 u32 *resp = (u32 *)cmd->response; 233 234 if (!cmd) 235 return 0; 236 237 if (stat & STATUS_TIME_OUT_RESP) { 238 printf("CMD TIMEOUT\n"); 239 return TIMEOUT; 240 } else if (stat & STATUS_RESP_CRC_ERR && cmd->resp_type & MMC_RSP_CRC) { 241 printf("cmd crc error\n"); 242 return -EILSEQ; 243 } 244 245 if (cmd->resp_type & MMC_RSP_PRESENT) { 246 if (cmd->resp_type & MMC_RSP_136) { 247 for (i = 0; i < 4; i++) { 248 a = readl(&host->base->res_fifo) & 0xFFFF; 249 b = readl(&host->base->res_fifo) & 0xFFFF; 250 resp[i] = a << 16 | b; 251 } 252 } else { 253 a = readl(&host->base->res_fifo) & 0xFFFF; 254 b = readl(&host->base->res_fifo) & 0xFFFF; 255 c = readl(&host->base->res_fifo) & 0xFFFF; 256 resp[0] = a << 24 | b << 8 | c >> 8; 257 } 258 } 259 return 0; 260 } 261 262 static int mxcmci_poll_status(struct mxcmci_host *host, u32 mask) 263 { 264 u32 stat; 265 unsigned long timeout = get_ticks() + CONFIG_SYS_HZ; 266 267 do { 268 stat = readl(&host->base->status); 269 if (stat & STATUS_ERR_MASK) 270 return stat; 271 if (timeout < get_ticks()) 272 return STATUS_TIME_OUT_READ; 273 if (stat & mask) 274 return 0; 275 } while (1); 276 } 277 278 static int mxcmci_pull(struct mxcmci_host *host, void *_buf, int bytes) 279 { 280 unsigned int stat; 281 u32 *buf = _buf; 282 283 while (bytes > 3) { 284 stat = mxcmci_poll_status(host, 285 STATUS_BUF_READ_RDY | STATUS_READ_OP_DONE); 286 if (stat) 287 return stat; 288 *buf++ = readl(&host->base->buffer_access); 289 bytes -= 4; 290 } 291 292 if (bytes) { 293 u8 *b = (u8 *)buf; 294 u32 tmp; 295 296 stat = mxcmci_poll_status(host, 297 STATUS_BUF_READ_RDY | STATUS_READ_OP_DONE); 298 if (stat) 299 return stat; 300 tmp = readl(&host->base->buffer_access); 301 memcpy(b, &tmp, bytes); 302 } 303 304 return 0; 305 } 306 307 static int mxcmci_push(struct mxcmci_host *host, const void *_buf, int bytes) 308 { 309 unsigned int stat; 310 const u32 *buf = _buf; 311 312 while (bytes > 3) { 313 stat = mxcmci_poll_status(host, STATUS_BUF_WRITE_RDY); 314 if (stat) 315 return stat; 316 writel(*buf++, &host->base->buffer_access); 317 bytes -= 4; 318 } 319 320 if (bytes) { 321 const u8 *b = (u8 *)buf; 322 u32 tmp; 323 324 stat = mxcmci_poll_status(host, STATUS_BUF_WRITE_RDY); 325 if (stat) 326 return stat; 327 328 memcpy(&tmp, b, bytes); 329 writel(tmp, &host->base->buffer_access); 330 } 331 332 stat = mxcmci_poll_status(host, STATUS_BUF_WRITE_RDY); 333 if (stat) 334 return stat; 335 336 return 0; 337 } 338 339 static int mxcmci_transfer_data(struct mxcmci_host *host) 340 { 341 struct mmc_data *data = host->data; 342 int stat; 343 unsigned long length; 344 345 length = data->blocks * data->blocksize; 346 host->datasize = 0; 347 348 if (data->flags & MMC_DATA_READ) { 349 stat = mxcmci_pull(host, data->dest, length); 350 if (stat) 351 return stat; 352 host->datasize += length; 353 } else { 354 stat = mxcmci_push(host, (const void *)(data->src), length); 355 if (stat) 356 return stat; 357 host->datasize += length; 358 stat = mxcmci_poll_status(host, STATUS_WRITE_OP_DONE); 359 if (stat) 360 return stat; 361 } 362 return 0; 363 } 364 365 static int mxcmci_cmd_done(struct mxcmci_host *host, unsigned int stat) 366 { 367 int datastat; 368 int ret; 369 370 ret = mxcmci_read_response(host, stat); 371 372 if (ret) { 373 mxcmci_finish_request(host, host->cmd, host->data); 374 return ret; 375 } 376 377 if (!host->data) { 378 mxcmci_finish_request(host, host->cmd, host->data); 379 return 0; 380 } 381 382 datastat = mxcmci_transfer_data(host); 383 ret = mxcmci_finish_data(host, datastat); 384 mxcmci_finish_request(host, host->cmd, host->data); 385 return ret; 386 } 387 388 static int mxcmci_request(struct mmc *mmc, struct mmc_cmd *cmd, 389 struct mmc_data *data) 390 { 391 struct mxcmci_host *host = mmc->priv; 392 unsigned int cmdat = host->cmdat; 393 u32 stat; 394 int ret; 395 396 host->cmdat &= ~CMD_DAT_CONT_INIT; 397 if (data) { 398 mxcmci_setup_data(host, data); 399 400 cmdat |= CMD_DAT_CONT_DATA_ENABLE; 401 402 if (data->flags & MMC_DATA_WRITE) 403 cmdat |= CMD_DAT_CONT_WRITE; 404 } 405 406 if ((ret = mxcmci_start_cmd(host, cmd, cmdat))) { 407 mxcmci_finish_request(host, cmd, data); 408 return ret; 409 } 410 411 do { 412 stat = readl(&host->base->status); 413 writel(stat, &host->base->status); 414 } while (!(stat & STATUS_END_CMD_RESP)); 415 416 return mxcmci_cmd_done(host, stat); 417 } 418 419 static void mxcmci_set_clk_rate(struct mxcmci_host *host, unsigned int clk_ios) 420 { 421 unsigned int divider; 422 int prescaler = 0; 423 unsigned long clk_in = mxc_get_clock(MXC_ESDHC_CLK); 424 425 while (prescaler <= 0x800) { 426 for (divider = 1; divider <= 0xF; divider++) { 427 int x; 428 429 x = (clk_in / (divider + 1)); 430 431 if (prescaler) 432 x /= (prescaler * 2); 433 434 if (x <= clk_ios) 435 break; 436 } 437 if (divider < 0x10) 438 break; 439 440 if (prescaler == 0) 441 prescaler = 1; 442 else 443 prescaler <<= 1; 444 } 445 446 writel((prescaler << 4) | divider, &host->base->clk_rate); 447 } 448 449 static void mxcmci_set_ios(struct mmc *mmc) 450 { 451 struct mxcmci_host *host = mmc->priv; 452 if (mmc->bus_width == 4) 453 host->cmdat |= CMD_DAT_CONT_BUS_WIDTH_4; 454 else 455 host->cmdat &= ~CMD_DAT_CONT_BUS_WIDTH_4; 456 457 if (mmc->clock) { 458 mxcmci_set_clk_rate(host, mmc->clock); 459 writel(STR_STP_CLK_START_CLK, &host->base->str_stp_clk); 460 } else { 461 writel(STR_STP_CLK_STOP_CLK, &host->base->str_stp_clk); 462 } 463 464 host->clock = mmc->clock; 465 } 466 467 static int mxcmci_init(struct mmc *mmc) 468 { 469 struct mxcmci_host *host = mmc->priv; 470 471 mxcmci_softreset(host); 472 473 host->rev_no = readl(&host->base->rev_no); 474 if (host->rev_no != 0x400) { 475 printf("wrong rev.no. 0x%08x. aborting.\n", 476 host->rev_no); 477 return -ENODEV; 478 } 479 480 /* recommended in data sheet */ 481 writel(0x2db4, &host->base->read_to); 482 483 writel(0, &host->base->int_cntr); 484 485 return 0; 486 } 487 488 static int mxcmci_initialize(bd_t *bis) 489 { 490 struct mmc *mmc = NULL; 491 492 mmc = malloc(sizeof(struct mmc)); 493 494 if (!mmc) 495 return -ENOMEM; 496 497 sprintf(mmc->name, "MXC MCI"); 498 mmc->send_cmd = mxcmci_request; 499 mmc->set_ios = mxcmci_set_ios; 500 mmc->init = mxcmci_init; 501 mmc->getcd = NULL; 502 mmc->host_caps = MMC_MODE_4BIT; 503 504 host->base = (struct mxcmci_regs *)CONFIG_MXC_MCI_REGS_BASE; 505 mmc->priv = host; 506 host->mmc = mmc; 507 508 mmc->voltages = MMC_VDD_32_33 | MMC_VDD_33_34; 509 510 mmc->f_min = mxc_get_clock(MXC_ESDHC_CLK) >> 7; 511 mmc->f_max = mxc_get_clock(MXC_ESDHC_CLK) >> 1; 512 513 mmc->b_max = 0; 514 515 mmc_register(mmc); 516 517 return 0; 518 } 519 520 int mxc_mmc_init(bd_t *bis) 521 { 522 return mxcmci_initialize(bis); 523 } 524