1 // SPDX-License-Identifier: GPL-2.0+
4 * Rob Emanuele <rob@emanuele.us>
5 * Reinhard Meyer, EMK Elektronik <reinhard.meyer@emk-elektronik.de>
8 * Copyright (C) 2004-2006 Atmel Corporation
18 #include <linux/errno.h>
19 #include <asm/byteorder.h>
20 #include <asm/arch/clk.h>
21 #include <asm/arch/hardware.h>
22 #include "atmel_mci.h"
24 #ifndef CONFIG_SYS_MMC_CLK_OD
25 # define CONFIG_SYS_MMC_CLK_OD 150000
28 #define MMC_DEFAULT_BLKLEN 512
30 #if defined(CONFIG_ATMEL_MCI_PORTB)
37 struct atmel_mci_plat {
39 struct mmc_config cfg;
40 struct atmel_mci *mci;
44 struct atmel_mci_priv {
46 struct mmc_config cfg;
47 struct atmel_mci *mci;
49 unsigned int initialized:1;
50 unsigned int curr_clk;
56 /* Read Atmel MCI IP version */
57 static unsigned int atmel_mci_get_version(struct atmel_mci *mci)
59 return readl(&mci->version) & 0x00000fff;
63 * Print command and status:
65 * - always when DEBUG is defined
68 static void dump_cmd(u32 cmdr, u32 arg, u32 status, const char* msg)
70 debug("gen_atmel_mci: CMDR %08x (%2u) ARGR %08x (SR: %08x) %s\n",
71 cmdr, cmdr & 0x3F, arg, status, msg);
74 static inline void mci_set_blklen(atmel_mci_t *mci, int blklen)
76 unsigned int version = atmel_mci_get_version(mci);
80 /* MCI IP version >= 0x200 has blkr */
82 writel(MMCI_BFINS(BLKLEN, blklen, readl(&mci->blkr)),
85 writel(MMCI_BFINS(BLKLEN, blklen, readl(&mci->mr)), &mci->mr);
88 /* Setup for MCI Clock and Block Size */
90 static void mci_set_mode(struct udevice *dev, u32 hz, u32 blklen)
92 struct atmel_mci_plat *plat = dev_get_platdata(dev);
93 struct atmel_mci_priv *priv = dev_get_priv(dev);
94 struct mmc *mmc = &plat->mmc;
95 u32 bus_hz = priv->bus_clk_rate;
96 atmel_mci_t *mci = plat->mci;
98 static void mci_set_mode(struct mmc *mmc, u32 hz, u32 blklen)
100 struct atmel_mci_priv *priv = mmc->priv;
101 u32 bus_hz = get_mci_clk_rate();
102 atmel_mci_t *mci = priv->mci;
106 unsigned int version = atmel_mci_get_version(mci);
110 debug("mci: bus_hz is %u, setting clock %u Hz, block size %u\n",
113 if (version >= 0x500) {
114 clkdiv = DIV_ROUND_UP(bus_hz, hz) - 2;
121 debug("mci: setting clock %u Hz, block size %u\n",
122 bus_hz / (clkdiv * 2 + clkodd + 2), blklen);
124 /* find clkdiv yielding a rate <= than requested */
125 for (clkdiv = 0; clkdiv < 255; clkdiv++) {
126 if ((bus_hz / (clkdiv + 1) / 2) <= hz)
129 debug("mci: setting clock %u Hz, block size %u\n",
130 (bus_hz / (clkdiv + 1)) / 2, blklen);
134 if (version >= 0x500)
135 priv->curr_clk = bus_hz / (clkdiv * 2 + clkodd + 2);
137 priv->curr_clk = (bus_hz / (clkdiv + 1)) / 2;
139 mr = MMCI_BF(CLKDIV, clkdiv);
141 /* MCI IP version >= 0x200 has R/WPROOF */
142 if (version >= 0x200)
143 mr |= MMCI_BIT(RDPROOF) | MMCI_BIT(WRPROOF);
146 * MCI IP version >= 0x500 use bit 16 as clkodd.
147 * MCI IP version < 0x500 use upper 16 bits for blklen.
149 if (version >= 0x500)
150 mr |= MMCI_BF(CLKODD, clkodd);
152 writel(mr, &mci->mr);
154 mci_set_blklen(mci, blklen);
156 if (mmc->card_caps & mmc->cfg->host_caps & MMC_MODE_HS)
157 writel(MMCI_BIT(HSMODE), &mci->cfg);
159 priv->initialized = 1;
162 /* Return the CMDR with flags for a given command and data packet */
163 static u32 mci_encode_cmd(
164 struct mmc_cmd *cmd, struct mmc_data *data, u32* error_flags)
168 /* Default Flags for Errors */
169 *error_flags |= (MMCI_BIT(DTOE) | MMCI_BIT(RDIRE) | MMCI_BIT(RENDE) |
170 MMCI_BIT(RINDE) | MMCI_BIT(RTOE));
172 /* Default Flags for the Command */
173 cmdr |= MMCI_BIT(MAXLAT);
176 cmdr |= MMCI_BF(TRCMD, 1);
177 if (data->blocks > 1)
178 cmdr |= MMCI_BF(TRTYP, 1);
179 if (data->flags & MMC_DATA_READ)
180 cmdr |= MMCI_BIT(TRDIR);
183 if (cmd->resp_type & MMC_RSP_CRC)
184 *error_flags |= MMCI_BIT(RCRCE);
185 if (cmd->resp_type & MMC_RSP_136)
186 cmdr |= MMCI_BF(RSPTYP, 2);
187 else if (cmd->resp_type & MMC_RSP_BUSY)
188 cmdr |= MMCI_BF(RSPTYP, 3);
189 else if (cmd->resp_type & MMC_RSP_PRESENT)
190 cmdr |= MMCI_BF(RSPTYP, 1);
192 return cmdr | MMCI_BF(CMDNB, cmd->cmdidx);
195 /* Entered into function pointer in mci_send_cmd */
196 static u32 mci_data_read(atmel_mci_t *mci, u32* data, u32 error_flags)
201 status = readl(&mci->sr);
202 if (status & (error_flags | MMCI_BIT(OVRE)))
204 } while (!(status & MMCI_BIT(RXRDY)));
206 if (status & MMCI_BIT(RXRDY)) {
207 *data = readl(&mci->rdr);
214 /* Entered into function pointer in mci_send_cmd */
215 static u32 mci_data_write(atmel_mci_t *mci, u32* data, u32 error_flags)
220 status = readl(&mci->sr);
221 if (status & (error_flags | MMCI_BIT(UNRE)))
223 } while (!(status & MMCI_BIT(TXRDY)));
225 if (status & MMCI_BIT(TXRDY)) {
226 writel(*data, &mci->tdr);
234 * Entered into mmc structure during driver init
236 * Sends a command out on the bus and deals with the block data.
237 * Takes the mmc pointer, a command pointer, and an optional data pointer.
240 static int atmel_mci_send_cmd(struct udevice *dev, struct mmc_cmd *cmd,
241 struct mmc_data *data)
243 struct atmel_mci_plat *plat = dev_get_platdata(dev);
244 struct atmel_mci_priv *priv = dev_get_priv(dev);
245 atmel_mci_t *mci = plat->mci;
248 mci_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
250 struct atmel_mci_priv *priv = mmc->priv;
251 atmel_mci_t *mci = priv->mci;
257 if (!priv->initialized) {
258 puts ("MCI not initialized!\n");
262 /* Figure out the transfer arguments */
263 cmdr = mci_encode_cmd(cmd, data, &error_flags);
265 mci_set_blklen(mci, data->blocksize);
267 /* For multi blocks read/write, set the block register */
268 if ((cmd->cmdidx == MMC_CMD_READ_MULTIPLE_BLOCK)
269 || (cmd->cmdidx == MMC_CMD_WRITE_MULTIPLE_BLOCK))
270 writel(data->blocks | MMCI_BF(BLKLEN, data->blocksize),
273 /* Send the command */
274 writel(cmd->cmdarg, &mci->argr);
275 writel(cmdr, &mci->cmdr);
278 dump_cmd(cmdr, cmd->cmdarg, 0, "DEBUG");
281 /* Wait for the command to complete */
282 while (!((status = readl(&mci->sr)) & MMCI_BIT(CMDRDY)));
284 if ((status & error_flags) & MMCI_BIT(RTOE)) {
285 dump_cmd(cmdr, cmd->cmdarg, status, "Command Time Out");
287 } else if (status & error_flags) {
288 dump_cmd(cmdr, cmd->cmdarg, status, "Command Failed");
292 /* Copy the response to the response buffer */
293 if (cmd->resp_type & MMC_RSP_136) {
294 cmd->response[0] = readl(&mci->rspr);
295 cmd->response[1] = readl(&mci->rspr1);
296 cmd->response[2] = readl(&mci->rspr2);
297 cmd->response[3] = readl(&mci->rspr3);
299 cmd->response[0] = readl(&mci->rspr);
301 /* transfer all of the blocks */
303 u32 word_count, block_count;
307 (atmel_mci_t *mci, u32* data, u32 error_flags);
309 if (data->flags & MMC_DATA_READ) {
310 mci_data_op = mci_data_read;
311 ioptr = (u32*)data->dest;
313 mci_data_op = mci_data_write;
314 ioptr = (u32*)data->src;
318 for (block_count = 0;
319 block_count < data->blocks && !status;
323 status = mci_data_op(mci, ioptr, error_flags);
326 } while (!status && word_count < (data->blocksize/4));
328 if (data->flags & MMC_DATA_READ)
330 u32 cnt = word_count * 4;
331 printf("Read Data:\n");
332 print_buffer(0, data->dest + cnt * block_count,
337 dump_cmd(cmdr, cmd->cmdarg, status,
338 "Data Transfer Failed");
343 /* Wait for Transfer End */
346 status = readl(&mci->sr);
348 if (status & error_flags) {
349 dump_cmd(cmdr, cmd->cmdarg, status,
354 } while ((status & MMCI_BIT(DTIP)) && i < 10000);
355 if (status & MMCI_BIT(DTIP)) {
356 dump_cmd(cmdr, cmd->cmdarg, status,
357 "XFER DTIP never unset, ignoring");
362 * After the switch command, wait for 8 clocks before the next
365 if (cmd->cmdidx == MMC_CMD_SWITCH)
366 udelay(8*1000000 / priv->curr_clk); /* 8 clk in us */
372 static int atmel_mci_set_ios(struct udevice *dev)
374 struct atmel_mci_plat *plat = dev_get_platdata(dev);
375 struct mmc *mmc = mmc_get_mmc_dev(dev);
376 atmel_mci_t *mci = plat->mci;
378 /* Entered into mmc structure during driver init */
379 static int mci_set_ios(struct mmc *mmc)
381 struct atmel_mci_priv *priv = mmc->priv;
382 atmel_mci_t *mci = priv->mci;
384 int bus_width = mmc->bus_width;
385 unsigned int version = atmel_mci_get_version(mci);
388 /* Set the clock speed */
390 mci_set_mode(dev, mmc->clock, MMC_DEFAULT_BLKLEN);
392 mci_set_mode(mmc, mmc->clock, MMC_DEFAULT_BLKLEN);
396 * set the bus width and select slot for this interface
397 * there is no capability for multiple slots on the same interface yet
399 if ((version & 0xf00) >= 0x300) {
412 writel(busw << 6 | MMCI_BF(SCDSEL, MCI_BUS), &mci->sdcr);
414 busw = (bus_width == 4) ? 1 : 0;
416 writel(busw << 7 | MMCI_BF(SCDSEL, MCI_BUS), &mci->sdcr);
423 static int atmel_mci_hw_init(struct udevice *dev)
425 struct atmel_mci_plat *plat = dev_get_platdata(dev);
426 atmel_mci_t *mci = plat->mci;
428 /* Entered into mmc structure during driver init */
429 static int mci_init(struct mmc *mmc)
431 struct atmel_mci_priv *priv = mmc->priv;
432 atmel_mci_t *mci = priv->mci;
435 /* Initialize controller */
436 writel(MMCI_BIT(SWRST), &mci->cr); /* soft reset */
437 writel(MMCI_BIT(PWSDIS), &mci->cr); /* disable power save */
438 writel(MMCI_BIT(MCIEN), &mci->cr); /* enable mci */
439 writel(MMCI_BF(SCDSEL, MCI_BUS), &mci->sdcr); /* select port */
441 /* This delay can be optimized, but stick with max value */
442 writel(0x7f, &mci->dtor);
443 /* Disable Interrupts */
444 writel(~0UL, &mci->idr);
446 /* Set default clocks and blocklen */
448 mci_set_mode(dev, CONFIG_SYS_MMC_CLK_OD, MMC_DEFAULT_BLKLEN);
450 mci_set_mode(mmc, CONFIG_SYS_MMC_CLK_OD, MMC_DEFAULT_BLKLEN);
456 #ifndef CONFIG_DM_MMC
457 static const struct mmc_ops atmel_mci_ops = {
458 .send_cmd = mci_send_cmd,
459 .set_ios = mci_set_ios,
464 * This is the only exported function
466 * Call it with the MCI register base address
468 int atmel_mci_init(void *regs)
471 struct mmc_config *cfg;
472 struct atmel_mci_priv *priv;
473 unsigned int version;
475 priv = calloc(1, sizeof(*priv));
482 cfg->ops = &atmel_mci_ops;
484 priv->mci = (struct atmel_mci *)regs;
485 priv->initialized = 0;
487 /* need to be able to pass these in on a board by board basis */
488 cfg->voltages = MMC_VDD_32_33 | MMC_VDD_33_34;
489 version = atmel_mci_get_version(priv->mci);
490 if ((version & 0xf00) >= 0x300) {
491 cfg->host_caps = MMC_MODE_8BIT;
492 cfg->host_caps |= MMC_MODE_HS | MMC_MODE_HS_52MHz;
495 cfg->host_caps |= MMC_MODE_4BIT;
498 * min and max frequencies determined by
499 * max and min of clock divider
501 cfg->f_min = get_mci_clk_rate() / (2*256);
502 cfg->f_max = get_mci_clk_rate() / (2*1);
504 cfg->b_max = CONFIG_SYS_MMC_MAX_BLK_COUNT;
506 mmc = mmc_create(cfg, priv);
512 /* NOTE: possibly leaking the priv structure */
519 static const struct dm_mmc_ops atmel_mci_mmc_ops = {
520 .send_cmd = atmel_mci_send_cmd,
521 .set_ios = atmel_mci_set_ios,
524 static void atmel_mci_setup_cfg(struct udevice *dev)
526 struct atmel_mci_plat *plat = dev_get_platdata(dev);
527 struct atmel_mci_priv *priv = dev_get_priv(dev);
528 struct mmc_config *cfg;
532 cfg->name = "Atmel mci";
533 cfg->voltages = MMC_VDD_32_33 | MMC_VDD_33_34;
536 * If the version is above 3.0, the capabilities of the 8-bit
537 * bus width and high speed are supported.
539 version = atmel_mci_get_version(plat->mci);
540 if ((version & 0xf00) >= 0x300) {
541 cfg->host_caps = MMC_MODE_8BIT |
542 MMC_MODE_HS | MMC_MODE_HS_52MHz;
545 cfg->host_caps |= MMC_MODE_4BIT;
546 cfg->b_max = CONFIG_SYS_MMC_MAX_BLK_COUNT;
547 cfg->f_min = priv->bus_clk_rate / (2 * 256);
548 cfg->f_max = priv->bus_clk_rate / 2;
551 static int atmel_mci_enable_clk(struct udevice *dev)
553 struct atmel_mci_priv *priv = dev_get_priv(dev);
558 ret = clk_get_by_index(dev, 0, &clk);
564 ret = clk_enable(&clk);
568 clk_rate = clk_get_rate(&clk);
574 priv->bus_clk_rate = clk_rate;
582 static int atmel_mci_probe(struct udevice *dev)
584 struct mmc_uclass_priv *upriv = dev_get_uclass_priv(dev);
585 struct atmel_mci_plat *plat = dev_get_platdata(dev);
589 ret = atmel_mci_enable_clk(dev);
593 plat->mci = (struct atmel_mci *)devfdt_get_addr_ptr(dev);
595 atmel_mci_setup_cfg(dev);
598 mmc->cfg = &plat->cfg;
602 atmel_mci_hw_init(dev);
607 static int atmel_mci_bind(struct udevice *dev)
609 struct atmel_mci_plat *plat = dev_get_platdata(dev);
611 return mmc_bind(dev, &plat->mmc, &plat->cfg);
614 static const struct udevice_id atmel_mci_ids[] = {
615 { .compatible = "atmel,hsmci" },
619 U_BOOT_DRIVER(atmel_mci) = {
622 .of_match = atmel_mci_ids,
623 .bind = atmel_mci_bind,
624 .probe = atmel_mci_probe,
625 .platdata_auto_alloc_size = sizeof(struct atmel_mci_plat),
626 .priv_auto_alloc_size = sizeof(struct atmel_mci_priv),
627 .ops = &atmel_mci_mmc_ops,