mmc_write.c 4.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197
  1. /*
  2. * Copyright 2008, Freescale Semiconductor, Inc
  3. * Andy Fleming
  4. *
  5. * Based vaguely on the Linux code
  6. *
  7. * SPDX-License-Identifier: GPL-2.0+
  8. */
  9. #include <comdef.h>
  10. #include "mmc_private.h"
  11. #include <mmc.h>
  12. #include <uart.h>
  13. #include <div64.h>
  14. extern struct mmc local_mmc0;
  15. static u32 mmc_erase_t(struct mmc *mmc, u32 start, unsigned int blkcnt)
  16. {
  17. struct mmc_cmd cmd;
  18. u32 end;
  19. int err, start_cmd, end_cmd;
  20. if (mmc->high_capacity) {
  21. end = start + blkcnt - 1;
  22. } else {
  23. end = (start + blkcnt - 1) * mmc->write_bl_len;
  24. start *= mmc->write_bl_len;
  25. }
  26. if (IS_SD(mmc)) {
  27. start_cmd = SD_CMD_ERASE_WR_BLK_START;
  28. end_cmd = SD_CMD_ERASE_WR_BLK_END;
  29. } else {
  30. start_cmd = MMC_CMD_ERASE_GROUP_START;
  31. end_cmd = MMC_CMD_ERASE_GROUP_END;
  32. }
  33. //printf("start_cmd = %d, end_cmd = %d\n", start_cmd,end_cmd);
  34. cmd.cmdidx = start_cmd;
  35. cmd.cmdarg = start;
  36. cmd.resp_type = MMC_RSP_R1;
  37. err = mmc_send_cmd(mmc, &cmd, NULL);
  38. if (err)
  39. goto err_out;
  40. cmd.cmdidx = end_cmd;
  41. cmd.cmdarg = end;
  42. err = mmc_send_cmd(mmc, &cmd, NULL);
  43. if (err)
  44. goto err_out;
  45. cmd.cmdidx = MMC_CMD_ERASE;
  46. cmd.cmdarg = MMC_ERASE_ARG;
  47. cmd.resp_type = MMC_RSP_R1b;
  48. err = mmc_send_cmd(mmc, &cmd, NULL);
  49. if (err)
  50. goto err_out;
  51. return 0;
  52. err_out:
  53. rlSendString("mmc erase failed\n");
  54. return err;
  55. }
  56. unsigned long mmc_berase(int dev_num, unsigned int start, unsigned int blkcnt)
  57. {
  58. int err = 0;
  59. u32 start_rem, blkcnt_rem;
  60. struct mmc *mmc;
  61. if(dev_num == 0)
  62. mmc = &local_mmc0;
  63. unsigned int blk = 0, blk_r = 0;
  64. int timeout = 1000;
  65. if (!mmc)
  66. return -1;
  67. /*
  68. * We want to see if the requested start or total block count are
  69. * unaligned. We discard the whole numbers and only care about the
  70. * remainder.
  71. */
  72. err = div_u64_rem(start, mmc->erase_grp_size, &start_rem);
  73. err = div_u64_rem(blkcnt, mmc->erase_grp_size, &blkcnt_rem);
  74. if (start_rem || blkcnt_rem)
  75. rlSendString("\n\nCaution! Your devices Erase group ,\n\n");
  76. while (blk < blkcnt) {
  77. blk_r = ((blkcnt - blk) > mmc->erase_grp_size) ?
  78. mmc->erase_grp_size : (blkcnt - blk);
  79. err = mmc_erase_t(mmc, start + blk, blk_r);
  80. if (err)
  81. break;
  82. //printf("erase blk = %d\n", blk);
  83. blk += blk_r;
  84. /* Waiting for the ready status */
  85. if (mmc_send_status(mmc, timeout))
  86. return 0;
  87. }
  88. return blk;
  89. }
  90. static u32 mmc_write_blocks(struct mmc *mmc, unsigned int start,
  91. unsigned int blkcnt, const void *src)
  92. {
  93. struct mmc_cmd cmd;
  94. struct mmc_data data;
  95. int timeout = 1000;
  96. if ((start + blkcnt) > mmc->block_dev.lba) {
  97. //printf("MMC: block number 0x%d,exceeds max(0x%d)\n",
  98. //start + blkcnt, mmc->block_dev.lba);
  99. return 0;
  100. }
  101. //printf("write blkcnt = %d\n", blkcnt);
  102. if (blkcnt == 0)
  103. return 0;
  104. else if (blkcnt == 1)
  105. cmd.cmdidx = MMC_CMD_WRITE_SINGLE_BLOCK;
  106. else
  107. cmd.cmdidx = MMC_CMD_WRITE_MULTIPLE_BLOCK;
  108. if (mmc->high_capacity)
  109. cmd.cmdarg = start;
  110. else
  111. cmd.cmdarg = start * mmc->write_bl_len;
  112. cmd.resp_type = MMC_RSP_R1;
  113. data.src = src;
  114. data.blocks = blkcnt;
  115. data.blocksize = mmc->write_bl_len;
  116. data.flags = MMC_DATA_WRITE;
  117. //printf("data.blocksize = %d\n", data.blocksize);
  118. if (mmc_send_cmd(mmc, &cmd, &data)) {
  119. rlSendString("mmc write failed\n");
  120. return 0;
  121. }
  122. /* SPI multiblock writes terminate using a special
  123. * token, not a STOP_TRANSMISSION request.
  124. */
  125. if (!mmc_host_is_spi(mmc) && blkcnt > 1) {
  126. cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION;
  127. cmd.cmdarg = 0;
  128. cmd.resp_type = MMC_RSP_R1b;
  129. if (mmc_send_cmd(mmc, &cmd, NULL)) {
  130. rlSendString("mmc fail to send stop cmd\n");
  131. return 0;
  132. }
  133. }
  134. /* Waiting for the ready status */
  135. if (mmc_send_status(mmc, timeout))
  136. return 0;
  137. return blkcnt;
  138. }
  139. unsigned long mmc_bwrite(int dev_num, unsigned int start, unsigned int blkcnt, const void *src)
  140. {
  141. unsigned int cur, blocks_todo = blkcnt;
  142. struct mmc *mmc;
  143. if(dev_num == 0)
  144. mmc = &local_mmc0;
  145. if (!mmc)
  146. return 0;
  147. if (mmc_set_blocklen(mmc, mmc->write_bl_len))
  148. return 0;
  149. do {
  150. cur = (blocks_todo > mmc->cfg->b_max) ?
  151. mmc->cfg->b_max : blocks_todo;
  152. if (mmc_write_blocks(mmc, start, cur, src) != cur)
  153. return 0;
  154. blocks_todo -= cur;
  155. start += cur;
  156. src += cur * mmc->write_bl_len;
  157. } while (blocks_todo > 0);
  158. return blkcnt;
  159. }