sandbox_mmc.c 4.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201
  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. static int sandbox_mmc_of_to_plat(struct udevice *dev)
  128. {
  129. struct sandbox_mmc_plat *plat = dev_get_plat(dev);
  130. struct mmc_config *cfg = &plat->cfg;
  131. struct blk_desc *blk;
  132. int ret;
  133. ret = mmc_of_parse(dev, cfg);
  134. if (ret)
  135. return ret;
  136. blk = mmc_get_blk_desc(&plat->mmc);
  137. if (blk)
  138. blk->removable = !(cfg->host_caps & MMC_CAP_NONREMOVABLE);
  139. return 0;
  140. }
  141. static int sandbox_mmc_probe(struct udevice *dev)
  142. {
  143. struct sandbox_mmc_plat *plat = dev_get_plat(dev);
  144. return mmc_init(&plat->mmc);
  145. }
  146. static int sandbox_mmc_bind(struct udevice *dev)
  147. {
  148. struct sandbox_mmc_plat *plat = dev_get_plat(dev);
  149. struct mmc_config *cfg = &plat->cfg;
  150. cfg->name = dev->name;
  151. cfg->host_caps = MMC_MODE_HS_52MHz | MMC_MODE_HS | MMC_MODE_8BIT;
  152. cfg->voltages = MMC_VDD_165_195 | MMC_VDD_32_33 | MMC_VDD_33_34;
  153. cfg->f_min = 1000000;
  154. cfg->f_max = 52000000;
  155. cfg->b_max = U32_MAX;
  156. return mmc_bind(dev, &plat->mmc, cfg);
  157. }
  158. static int sandbox_mmc_unbind(struct udevice *dev)
  159. {
  160. mmc_unbind(dev);
  161. return 0;
  162. }
  163. static const struct udevice_id sandbox_mmc_ids[] = {
  164. { .compatible = "sandbox,mmc" },
  165. { }
  166. };
  167. U_BOOT_DRIVER(mmc_sandbox) = {
  168. .name = "mmc_sandbox",
  169. .id = UCLASS_MMC,
  170. .of_match = sandbox_mmc_ids,
  171. .ops = &sandbox_mmc_ops,
  172. .bind = sandbox_mmc_bind,
  173. .unbind = sandbox_mmc_unbind,
  174. .of_to_plat = sandbox_mmc_of_to_plat,
  175. .probe = sandbox_mmc_probe,
  176. .priv_auto = sizeof(struct sandbox_mmc_priv),
  177. .plat_auto = sizeof(struct sandbox_mmc_plat),
  178. };