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 10 #include <config.h> 11 #include <common.h> 12 #include <part.h> 13 #include "mmc_private.h" 14 15 static ulong mmc_erase_t(struct mmc *mmc, ulong start, lbaint_t blkcnt) 16 { 17 struct mmc_cmd cmd; 18 ulong end; 19 int err, start_cmd, end_cmd; 20 21 if (mmc->high_capacity) { 22 end = start + blkcnt - 1; 23 } else { 24 end = (start + blkcnt - 1) * mmc->write_bl_len; 25 start *= mmc->write_bl_len; 26 } 27 28 if (IS_SD(mmc)) { 29 start_cmd = SD_CMD_ERASE_WR_BLK_START; 30 end_cmd = SD_CMD_ERASE_WR_BLK_END; 31 } else { 32 start_cmd = MMC_CMD_ERASE_GROUP_START; 33 end_cmd = MMC_CMD_ERASE_GROUP_END; 34 } 35 36 cmd.cmdidx = start_cmd; 37 cmd.cmdarg = start; 38 cmd.resp_type = MMC_RSP_R1; 39 40 err = mmc_send_cmd(mmc, &cmd, NULL); 41 if (err) 42 goto err_out; 43 44 cmd.cmdidx = end_cmd; 45 cmd.cmdarg = end; 46 47 err = mmc_send_cmd(mmc, &cmd, NULL); 48 if (err) 49 goto err_out; 50 51 cmd.cmdidx = MMC_CMD_ERASE; 52 cmd.cmdarg = SECURE_ERASE; 53 cmd.resp_type = MMC_RSP_R1b; 54 55 err = mmc_send_cmd(mmc, &cmd, NULL); 56 if (err) 57 goto err_out; 58 59 return 0; 60 61 err_out: 62 puts("mmc erase failed\n"); 63 return err; 64 } 65 66 unsigned long mmc_berase(int dev_num, lbaint_t start, lbaint_t blkcnt) 67 { 68 int err = 0; 69 struct mmc *mmc = find_mmc_device(dev_num); 70 lbaint_t blk = 0, blk_r = 0; 71 int timeout = 1000; 72 73 if (!mmc) 74 return -1; 75 76 if ((start % mmc->erase_grp_size) || (blkcnt % mmc->erase_grp_size)) 77 printf("\n\nCaution! Your devices Erase group is 0x%x\n" 78 "The erase range would be change to " 79 "0x" LBAF "~0x" LBAF "\n\n", 80 mmc->erase_grp_size, start & ~(mmc->erase_grp_size - 1), 81 ((start + blkcnt + mmc->erase_grp_size) 82 & ~(mmc->erase_grp_size - 1)) - 1); 83 84 while (blk < blkcnt) { 85 blk_r = ((blkcnt - blk) > mmc->erase_grp_size) ? 86 mmc->erase_grp_size : (blkcnt - blk); 87 err = mmc_erase_t(mmc, start + blk, blk_r); 88 if (err) 89 break; 90 91 blk += blk_r; 92 93 /* Waiting for the ready status */ 94 if (mmc_send_status(mmc, timeout)) 95 return 0; 96 } 97 98 return blk; 99 } 100 101 static ulong mmc_write_blocks(struct mmc *mmc, lbaint_t start, 102 lbaint_t blkcnt, const void *src) 103 { 104 struct mmc_cmd cmd; 105 struct mmc_data data; 106 int timeout = 1000; 107 108 if ((start + blkcnt) > mmc->block_dev.lba) { 109 printf("MMC: block number 0x" LBAF " exceeds max(0x" LBAF ")\n", 110 start + blkcnt, mmc->block_dev.lba); 111 return 0; 112 } 113 114 if (blkcnt == 0) 115 return 0; 116 else if (blkcnt == 1) 117 cmd.cmdidx = MMC_CMD_WRITE_SINGLE_BLOCK; 118 else 119 cmd.cmdidx = MMC_CMD_WRITE_MULTIPLE_BLOCK; 120 121 if (mmc->high_capacity) 122 cmd.cmdarg = start; 123 else 124 cmd.cmdarg = start * mmc->write_bl_len; 125 126 cmd.resp_type = MMC_RSP_R1; 127 128 data.src = src; 129 data.blocks = blkcnt; 130 data.blocksize = mmc->write_bl_len; 131 data.flags = MMC_DATA_WRITE; 132 133 if (mmc_send_cmd(mmc, &cmd, &data)) { 134 printf("mmc write failed\n"); 135 return 0; 136 } 137 138 /* SPI multiblock writes terminate using a special 139 * token, not a STOP_TRANSMISSION request. 140 */ 141 if (!mmc_host_is_spi(mmc) && blkcnt > 1) { 142 cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION; 143 cmd.cmdarg = 0; 144 cmd.resp_type = MMC_RSP_R1b; 145 if (mmc_send_cmd(mmc, &cmd, NULL)) { 146 printf("mmc fail to send stop cmd\n"); 147 return 0; 148 } 149 } 150 151 /* Waiting for the ready status */ 152 if (mmc_send_status(mmc, timeout)) 153 return 0; 154 155 return blkcnt; 156 } 157 158 ulong mmc_bwrite(int dev_num, lbaint_t start, lbaint_t blkcnt, const void *src) 159 { 160 lbaint_t cur, blocks_todo = blkcnt; 161 162 struct mmc *mmc = find_mmc_device(dev_num); 163 if (!mmc) 164 return 0; 165 166 if (mmc_set_blocklen(mmc, mmc->write_bl_len)) 167 return 0; 168 169 do { 170 cur = (blocks_todo > mmc->b_max) ? mmc->b_max : blocks_todo; 171 if (mmc_write_blocks(mmc, start, cur, src) != cur) 172 return 0; 173 blocks_todo -= cur; 174 start += cur; 175 src += cur * mmc->write_bl_len; 176 } while (blocks_todo > 0); 177 178 return blkcnt; 179 } 180