[people/ms/u-boot.git] / drivers / mmc / mmc_write.c

/*
 * Copyright 2008, Freescale Semiconductor, Inc
 * Andy Fleming
 *
 * Based vaguely on the Linux code
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#include <config.h>
#include <common.h>
#include <part.h>
#include <div64.h>
#include <linux/math64.h>
#include "mmc_private.h"

static ulong mmc_erase_t(struct mmc *mmc, ulong start, lbaint_t blkcnt)
{
	struct mmc_cmd cmd;
	ulong end;
	int err, start_cmd, end_cmd;

	if (mmc->high_capacity) {
		end = start + blkcnt - 1;
	} else {
		end = (start + blkcnt - 1) * mmc->write_bl_len;
		start *= mmc->write_bl_len;
	}

	if (IS_SD(mmc)) {
		start_cmd = SD_CMD_ERASE_WR_BLK_START;
		end_cmd = SD_CMD_ERASE_WR_BLK_END;
	} else {
		start_cmd = MMC_CMD_ERASE_GROUP_START;
		end_cmd = MMC_CMD_ERASE_GROUP_END;
	}

	cmd.cmdidx = start_cmd;
	cmd.cmdarg = start;
	cmd.resp_type = MMC_RSP_R1;

	err = mmc_send_cmd(mmc, &cmd, NULL);
	if (err)
		goto err_out;

	cmd.cmdidx = end_cmd;
	cmd.cmdarg = end;

	err = mmc_send_cmd(mmc, &cmd, NULL);
	if (err)
		goto err_out;

	cmd.cmdidx = MMC_CMD_ERASE;
	cmd.cmdarg = MMC_ERASE_ARG;
	cmd.resp_type = MMC_RSP_R1b;

	err = mmc_send_cmd(mmc, &cmd, NULL);
	if (err)
		goto err_out;

	return 0;

err_out:
	puts("mmc erase failed\n");
	return err;
}

unsigned long mmc_berase(block_dev_desc_t *block_dev, lbaint_t start,
			 lbaint_t blkcnt)
{
	int dev_num = block_dev->dev;
	int err = 0;
	u32 start_rem, blkcnt_rem;
	struct mmc *mmc = find_mmc_device(dev_num);
	lbaint_t blk = 0, blk_r = 0;
	int timeout = 1000;

	if (!mmc)
		return -1;

	/*
	 * We want to see if the requested start or total block count are
	 * unaligned.  We discard the whole numbers and only care about the
	 * remainder.
	 */
	err = div_u64_rem(start, mmc->erase_grp_size, &start_rem);
	err = div_u64_rem(blkcnt, mmc->erase_grp_size, &blkcnt_rem);
	if (start_rem || blkcnt_rem)
		printf("\n\nCaution! Your devices Erase group is 0x%x\n"
		       "The erase range would be change to "
		       "0x" LBAF "~0x" LBAF "\n\n",
		       mmc->erase_grp_size, start & ~(mmc->erase_grp_size - 1),
		       ((start + blkcnt + mmc->erase_grp_size)
		       & ~(mmc->erase_grp_size - 1)) - 1);

	while (blk < blkcnt) {
		blk_r = ((blkcnt - blk) > mmc->erase_grp_size) ?
			mmc->erase_grp_size : (blkcnt - blk);
		err = mmc_erase_t(mmc, start + blk, blk_r);
		if (err)
			break;

		blk += blk_r;

		/* Waiting for the ready status */
		if (mmc_send_status(mmc, timeout))
			return 0;
	}

	return blk;
}

static ulong mmc_write_blocks(struct mmc *mmc, lbaint_t start,
		lbaint_t blkcnt, const void *src)
{
	struct mmc_cmd cmd;
	struct mmc_data data;
	int timeout = 1000;

	if ((start + blkcnt) > mmc->block_dev.lba) {
		printf("MMC: block number 0x" LBAF " exceeds max(0x" LBAF ")\n",
		       start + blkcnt, mmc->block_dev.lba);
		return 0;
	}

	if (blkcnt == 0)
		return 0;
	else if (blkcnt == 1)
		cmd.cmdidx = MMC_CMD_WRITE_SINGLE_BLOCK;
	else
		cmd.cmdidx = MMC_CMD_WRITE_MULTIPLE_BLOCK;

	if (mmc->high_capacity)
		cmd.cmdarg = start;
	else
		cmd.cmdarg = start * mmc->write_bl_len;

	cmd.resp_type = MMC_RSP_R1;

	data.src = src;
	data.blocks = blkcnt;
	data.blocksize = mmc->write_bl_len;
	data.flags = MMC_DATA_WRITE;

	if (mmc_send_cmd(mmc, &cmd, &data)) {
		printf("mmc write failed\n");
		return 0;
	}

	/* SPI multiblock writes terminate using a special
	 * token, not a STOP_TRANSMISSION request.
	 */
	if (!mmc_host_is_spi(mmc) && blkcnt > 1) {
		cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION;
		cmd.cmdarg = 0;
		cmd.resp_type = MMC_RSP_R1b;
		if (mmc_send_cmd(mmc, &cmd, NULL)) {
			printf("mmc fail to send stop cmd\n");
			return 0;
		}
	}

	/* Waiting for the ready status */
	if (mmc_send_status(mmc, timeout))
		return 0;

	return blkcnt;
}

ulong mmc_bwrite(block_dev_desc_t *block_dev, lbaint_t start, lbaint_t blkcnt,
		 const void *src)
{
	int dev_num = block_dev->dev;
	lbaint_t cur, blocks_todo = blkcnt;

	struct mmc *mmc = find_mmc_device(dev_num);
	if (!mmc)
		return 0;

	if (mmc_set_blocklen(mmc, mmc->write_bl_len))
		return 0;

	do {
		cur = (blocks_todo > mmc->cfg->b_max) ?
			mmc->cfg->b_max : blocks_todo;
		if (mmc_write_blocks(mmc, start, cur, src) != cur)
			return 0;
		blocks_todo -= cur;
		start += cur;
		src += cur * mmc->write_bl_len;
	} while (blocks_todo > 0);

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