sandbox_mmc.c 4.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (c) 2015 Google, Inc
  4. * Written by Simon Glass <sjg@chromium.org>
  5. */
  6. #include <common.h>
  7. #include <dm.h>
  8. #include <errno.h>
  9. #include <fdtdec.h>
  10. #include <log.h>
  11. #include <mmc.h>
  12. #include <asm/test.h>
  13. struct sandbox_mmc_plat {
  14. struct mmc_config cfg;
  15. struct mmc mmc;
  16. };
  17. #define MMC_CSIZE 0
  18. #define MMC_CMULT 8 /* 8 because the card is high-capacity */
  19. #define MMC_BL_LEN_SHIFT 10
  20. #define MMC_BL_LEN BIT(MMC_BL_LEN_SHIFT)
  21. #define MMC_CAPACITY (((MMC_CSIZE + 1) << (MMC_CMULT + 2)) \
  22. * MMC_BL_LEN) /* 1 MiB */
  23. struct sandbox_mmc_priv {
  24. u8 buf[MMC_CAPACITY];
  25. };
  26. /**
  27. * sandbox_mmc_send_cmd() - Emulate SD commands
  28. *
  29. * This emulate an SD card version 2. Single-block reads result in zero data.
  30. * Multiple-block reads return a test string.
  31. */
  32. static int sandbox_mmc_send_cmd(struct udevice *dev, struct mmc_cmd *cmd,
  33. struct mmc_data *data)
  34. {
  35. struct sandbox_mmc_priv *priv = dev_get_priv(dev);
  36. struct mmc *mmc = mmc_get_mmc_dev(dev);
  37. static ulong erase_start, erase_end;
  38. switch (cmd->cmdidx) {
  39. case MMC_CMD_ALL_SEND_CID:
  40. memset(cmd->response, '\0', sizeof(cmd->response));
  41. break;
  42. case SD_CMD_SEND_RELATIVE_ADDR:
  43. cmd->response[0] = 0 << 16; /* mmc->rca */
  44. case MMC_CMD_GO_IDLE_STATE:
  45. break;
  46. case SD_CMD_SEND_IF_COND:
  47. cmd->response[0] = 0xaa;
  48. break;
  49. case MMC_CMD_SEND_STATUS:
  50. cmd->response[0] = MMC_STATUS_RDY_FOR_DATA;
  51. break;
  52. case MMC_CMD_SELECT_CARD:
  53. break;
  54. case MMC_CMD_SEND_CSD:
  55. cmd->response[0] = 0;
  56. cmd->response[1] = (MMC_BL_LEN_SHIFT << 16) |
  57. ((MMC_CSIZE >> 16) & 0x3f);
  58. cmd->response[2] = (MMC_CSIZE & 0xffff) << 16;
  59. cmd->response[3] = 0;
  60. break;
  61. case SD_CMD_SWITCH_FUNC: {
  62. if (!data)
  63. break;
  64. u32 *resp = (u32 *)data->dest;
  65. resp[3] = 0;
  66. resp[7] = cpu_to_be32(SD_HIGHSPEED_BUSY);
  67. if ((cmd->cmdarg & 0xF) == UHS_SDR12_BUS_SPEED)
  68. resp[4] = (cmd->cmdarg & 0xF) << 24;
  69. break;
  70. }
  71. case MMC_CMD_READ_SINGLE_BLOCK:
  72. case MMC_CMD_READ_MULTIPLE_BLOCK:
  73. memcpy(data->dest, &priv->buf[cmd->cmdarg * data->blocksize],
  74. data->blocks * data->blocksize);
  75. break;
  76. case MMC_CMD_WRITE_SINGLE_BLOCK:
  77. case MMC_CMD_WRITE_MULTIPLE_BLOCK:
  78. memcpy(&priv->buf[cmd->cmdarg * data->blocksize], data->src,
  79. data->blocks * data->blocksize);
  80. break;
  81. case MMC_CMD_STOP_TRANSMISSION:
  82. break;
  83. case SD_CMD_ERASE_WR_BLK_START:
  84. erase_start = cmd->cmdarg;
  85. break;
  86. case SD_CMD_ERASE_WR_BLK_END:
  87. erase_end = cmd->cmdarg;
  88. break;
  89. case MMC_CMD_ERASE:
  90. memset(&priv->buf[erase_start * mmc->write_bl_len], '\0',
  91. (erase_end - erase_start + 1) * mmc->write_bl_len);
  92. break;
  93. case SD_CMD_APP_SEND_OP_COND:
  94. cmd->response[0] = OCR_BUSY | OCR_HCS;
  95. cmd->response[1] = 0;
  96. cmd->response[2] = 0;
  97. break;
  98. case MMC_CMD_APP_CMD:
  99. break;
  100. case MMC_CMD_SET_BLOCKLEN:
  101. debug("block len %d\n", cmd->cmdarg);
  102. break;
  103. case SD_CMD_APP_SEND_SCR: {
  104. u32 *scr = (u32 *)data->dest;
  105. scr[0] = cpu_to_be32(2 << 24 | 1 << 15); /* SD version 3 */
  106. break;
  107. }
  108. default:
  109. debug("%s: Unknown command %d\n", __func__, cmd->cmdidx);
  110. break;
  111. }
  112. return 0;
  113. }
  114. static int sandbox_mmc_set_ios(struct udevice *dev)
  115. {
  116. return 0;
  117. }
  118. static int sandbox_mmc_get_cd(struct udevice *dev)
  119. {
  120. return 1;
  121. }
  122. static const struct dm_mmc_ops sandbox_mmc_ops = {
  123. .send_cmd = sandbox_mmc_send_cmd,
  124. .set_ios = sandbox_mmc_set_ios,
  125. .get_cd = sandbox_mmc_get_cd,
  126. };
  127. int sandbox_mmc_probe(struct udevice *dev)
  128. {
  129. struct sandbox_mmc_plat *plat = dev_get_plat(dev);
  130. return mmc_init(&plat->mmc);
  131. }
  132. int sandbox_mmc_bind(struct udevice *dev)
  133. {
  134. struct sandbox_mmc_plat *plat = dev_get_plat(dev);
  135. struct mmc_config *cfg = &plat->cfg;
  136. cfg->name = dev->name;
  137. cfg->host_caps = MMC_MODE_HS_52MHz | MMC_MODE_HS | MMC_MODE_8BIT;
  138. cfg->voltages = MMC_VDD_165_195 | MMC_VDD_32_33 | MMC_VDD_33_34;
  139. cfg->f_min = 1000000;
  140. cfg->f_max = 52000000;
  141. cfg->b_max = U32_MAX;
  142. return mmc_bind(dev, &plat->mmc, cfg);
  143. }
  144. int sandbox_mmc_unbind(struct udevice *dev)
  145. {
  146. mmc_unbind(dev);
  147. return 0;
  148. }
  149. static const struct udevice_id sandbox_mmc_ids[] = {
  150. { .compatible = "sandbox,mmc" },
  151. { }
  152. };
  153. U_BOOT_DRIVER(mmc_sandbox) = {
  154. .name = "mmc_sandbox",
  155. .id = UCLASS_MMC,
  156. .of_match = sandbox_mmc_ids,
  157. .ops = &sandbox_mmc_ops,
  158. .bind = sandbox_mmc_bind,
  159. .unbind = sandbox_mmc_unbind,
  160. .probe = sandbox_mmc_probe,
  161. .priv_auto = sizeof(struct sandbox_mmc_priv),
  162. .plat_auto = sizeof(struct sandbox_mmc_plat),
  163. };