Patchwork [OneNAND] Write-while-program support v2

login
register
mail settings
Submitter Kyungmin Park
Date Nov. 17, 2008, 8:54 a.m.
Message ID <20081117085428.GA32430@july>
Download mbox | patch
Permalink /patch/9118/
State New, archived
Headers show

Comments

Kyungmin Park - Nov. 17, 2008, 8:54 a.m.
This is from Adrian hunter and modified for write_ops operation.

It's similar with read-while-program method.
but it's write side performance improvement.

Here's *updated* brief performance results.
Note: Measured from OMAP3 with async OneNAND mode. (not sync mode)
Adrian Hunter - Nov. 18, 2008, 9:03 a.m.
Kyungmin Park wrote:
> This is from Adrian hunter and modified for write_ops operation.
> 
> It's similar with read-while-program method.
> but it's write side performance improvement.
> 
> Here's *updated* brief performance results.
> Note: Measured from OMAP3 with async OneNAND mode. (not sync mode)
> 
> =================================================================
> speedtest: dev = 3
> speedtest: Size=16777216  EB size=131072  Write size=2048  EB count=128
>                 Pages per EB=64  Page size=2048
> speedtest: scanning for bad blocks
> speedtest: scanned 0
> speedtest: scanned 128, found 0 bad
> speedtest: erasing
> speedtest: erased 0
> speedtest: erased 128
> speedtest: Testing eraseblock write speed
> eraseblock write speed is 2592 KiB/s
> speedtest: Testing eraseblock read speed
> eraseblock read speed is 16786 KiB/s
> speedtest: Testing page write speed
> page write speed is 2966 KiB/s
> speedtest: Testing page read speed
> page read speed is 13277 KiB/s
> speedtest: Testing 2 page write speed
> 2 page write speed is 3182 KiB/s
> speedtest: Testing 2 page read speed
> 2 page read speed is 14773 KiB/s
> speedtest: Testing erase speed
> erase speed is 192752 KiB/s
> speedtest: speedtest finished
> =================================================================
> 
> Also it's passed all nand-tests.
> 
> Signed-off-by: Adrian Hunter <ext-adrian.hunter@nokia.com>
> Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
> diff --git a/drivers/mtd/onenand/onenand_base.c b/drivers/mtd/onenand/onenand_base.c
> index aaf3504..5a27adb 100644
> --- a/drivers/mtd/onenand/onenand_base.c
> +++ b/drivers/mtd/onenand/onenand_base.c
> @@ -1455,7 +1455,8 @@ static int onenand_write_ops_nolock(struct mtd_info *mtd, loff_t to,
>  				struct mtd_oob_ops *ops)
>  {
>  	struct onenand_chip *this = mtd->priv;
> -	int written = 0, column, thislen, subpage;
> +	int written = 0, column, thislen = 0, subpage = 0;
> +	int prev = 0, prevlen = 0, prev_subpage = 0, first = 1;
>  	int oobwritten = 0, oobcolumn, thisooblen, oobsize;
>  	size_t len = ops->len;
>  	size_t ooblen = ops->ooblen;

How about introducing a variable for write-while-program i.e.

	int wwp = !ONENAND_IS_2PLANE(this);


> @@ -1482,6 +1483,10 @@ static int onenand_write_ops_nolock(struct mtd_info *mtd, loff_t to,
>                  return -EINVAL;
>          }
>  
> +	/* Check zero length */
> +	if (!len)
> +		return 0;
> +
>  	if (ops->mode == MTD_OOB_AUTO)
>  		oobsize = this->ecclayout->oobavail;
>  	else
> @@ -1492,79 +1497,125 @@ static int onenand_write_ops_nolock(struct mtd_info *mtd, loff_t to,
>  	column = to & (mtd->writesize - 1);
>  
>  	/* Loop until all data write */
> -	while (written < len) {
> -		u_char *wbuf = (u_char *) buf;
> +	while (1) {
> +		if (written < len) {
> +			u_char *wbuf = (u_char *) buf;
>  
> -		thislen = min_t(int, mtd->writesize - column, len - written);
> -		thisooblen = min_t(int, oobsize - oobcolumn, ooblen - oobwritten);
> +			thislen = min_t(int, mtd->writesize - column, len - written);
> +			thisooblen = min_t(int, oobsize - oobcolumn, ooblen - oobwritten);
>  
> -		cond_resched();
> +			cond_resched();
>  
> -		this->command(mtd, ONENAND_CMD_BUFFERRAM, to, thislen);
> +			this->command(mtd, ONENAND_CMD_BUFFERRAM, to, thislen);
>  
> -		/* Partial page write */
> -		subpage = thislen < mtd->writesize;
> -		if (subpage) {
> -			memset(this->page_buf, 0xff, mtd->writesize);
> -			memcpy(this->page_buf + column, buf, thislen);
> -			wbuf = this->page_buf;
> -		}
> +			/* Partial page write */
> +			subpage = thislen < mtd->writesize;
> +			if (subpage) {
> +				memset(this->page_buf, 0xff, mtd->writesize);
> +				memcpy(this->page_buf + column, buf, thislen);
> +				wbuf = this->page_buf;
> +			}
>  
> -		this->write_bufferram(mtd, ONENAND_DATARAM, wbuf, 0, mtd->writesize);
> +			this->write_bufferram(mtd, ONENAND_DATARAM, wbuf, 0, mtd->writesize);
>  
> -		if (oob) {
> -			oobbuf = this->oob_buf;
> +			if (oob) {
> +				oobbuf = this->oob_buf;
>  
> -			/* We send data to spare ram with oobsize
> -			 * to prevent byte access */
> -			memset(oobbuf, 0xff, mtd->oobsize);
> -			if (ops->mode == MTD_OOB_AUTO)
> -				onenand_fill_auto_oob(mtd, oobbuf, oob, oobcolumn, thisooblen);
> -			else
> -				memcpy(oobbuf + oobcolumn, oob, thisooblen);
> +				/* We send data to spare ram with oobsize
> +				 * to prevent byte access */
> +				memset(oobbuf, 0xff, mtd->oobsize);
> +				if (ops->mode == MTD_OOB_AUTO)
> +					onenand_fill_auto_oob(mtd, oobbuf, oob, oobcolumn, thisooblen);
> +				else
> +					memcpy(oobbuf + oobcolumn, oob, thisooblen);
>  
> -			oobwritten += thisooblen;
> -			oob += thisooblen;
> -			oobcolumn = 0;
> +				oobwritten += thisooblen;
> +				oob += thisooblen;
> +				oobcolumn = 0;
> +			} else
> +				oobbuf = (u_char *) ffchars;
> +
> +			this->write_bufferram(mtd, ONENAND_SPARERAM, oobbuf, 0, mtd->oobsize);
>  		} else
> -			oobbuf = (u_char *) ffchars;
> +			ONENAND_SET_NEXT_BUFFERRAM(this);
>  
> -		this->write_bufferram(mtd, ONENAND_SPARERAM, oobbuf, 0, mtd->oobsize);
> +		/*
> +		 * 2 PLANE, MLC, and Flex-OneNAND doesn't support
> +		 * write-while-programe feature.
> +		 */
> +		if (!ONENAND_IS_2PLANE(this) && !first) {

		if (wwp && !first) {

> +			ONENAND_SET_PREV_BUFFERRAM(this);
>  
> -		this->command(mtd, ONENAND_CMD_PROG, to, mtd->writesize);
> +			ret = this->wait(mtd, FL_WRITING);
>  
> -		ret = this->wait(mtd, FL_WRITING);
> +			/* In partial page write we don't update bufferram */
> +			onenand_update_bufferram(mtd, prev, !ret && !prev_subpage);
> +			if (ret) {
> +				written -= prevlen;
> +				printk(KERN_ERR "onenand_write_ops_nolock: write filaed %d\n", ret);
> +				break;
> +			}
>  
> -		/* In partial page write we don't update bufferram */
> -		onenand_update_bufferram(mtd, to, !ret && !subpage);
> -		if (ONENAND_IS_2PLANE(this)) {
> -			ONENAND_SET_BUFFERRAM1(this);
> -			onenand_update_bufferram(mtd, to + this->writesize, !ret && !subpage);
> -		}
> +			if (written == len) {
> +				/* Only check verify write turn on */
> +				ret = onenand_verify(mtd, buf - len, to - len, len);
> +				if (ret) {
> +					printk(KERN_ERR "onenand_write_ops_nolock: verify failed %d\n", ret);
> +					break;
> +				}
> +			}
>  
> -		if (ret) {
> -			printk(KERN_ERR "onenand_write_ops_nolock: write filaed %d\n", ret);
> -			break;
> -		}
> +			if (written == len)
> +				break;
>  
> -		/* Only check verify write turn on */
> -		ret = onenand_verify(mtd, buf, to, thislen);
> -		if (ret) {
> -			printk(KERN_ERR "onenand_write_ops_nolock: verify failed %d\n", ret);
> -			break;
> +			ONENAND_SET_NEXT_BUFFERRAM(this);
>  		}
>  
> -		written += thislen;
> +		this->command(mtd, ONENAND_CMD_PROG, to, mtd->writesize);
>  
> -		if (written == len)
> -			break;
> +		/*
> +		 * 2 PLANE, MLC, and Flex-OneNAND wait here
> +		 */
> +		if (ONENAND_IS_2PLANE(this)) {

		if (!wwp) {

> +			ret = this->wait(mtd, FL_WRITING);
> +
> +			/* In partial page write we don't update bufferram */
> +			onenand_update_bufferram(mtd, to, !ret && !subpage);
> +			if (ret) {
> +				printk(KERN_ERR "onenand_write_ops_nolock: write filaed %d\n", ret);


Spelling "failed":
				printk(KERN_ERR "onenand_write_ops_nolock: write failed %d\n", ret);


> +				break;
> +			}
> +
> +			/* Only check verify write turn on */
> +			ret = onenand_verify(mtd, buf, to, thislen);
> +			if (ret) {
> +				printk(KERN_ERR "onenand_write_ops_nolock: verify failed %d\n", ret);
> +				break;
> +			}
> +
> +			written += thislen;
> +
> +			if (written == len)
> +				break;
> +
> +		} else
> +			written += thislen;
>  
>  		column = 0;
> +		prev_subpage = subpage;
> +		prev = to;
> +		prevlen = thislen;
>  		to += thislen;
>  		buf += thislen;
> +		first = 0;
>  	}
>  
> +	/* In error case, clear all bufferrams */
> +	if (written != len)
> +		onenand_invalidate_bufferram(mtd, to - written, len);

The following is simpler:

		onenand_invalidate_bufferram(mtd, 0, -1);

> +
>  	ops->retlen = written;
> +	ops->oobretlen = oobwritten;
>  
>  	return ret;
>  }
>

Patch

=================================================================
speedtest: dev = 3
speedtest: Size=16777216  EB size=131072  Write size=2048  EB count=128
                Pages per EB=64  Page size=2048
speedtest: scanning for bad blocks
speedtest: scanned 0
speedtest: scanned 128, found 0 bad
speedtest: erasing
speedtest: erased 0
speedtest: erased 128
speedtest: Testing eraseblock write speed
eraseblock write speed is 2592 KiB/s
speedtest: Testing eraseblock read speed
eraseblock read speed is 16786 KiB/s
speedtest: Testing page write speed
page write speed is 2966 KiB/s
speedtest: Testing page read speed
page read speed is 13277 KiB/s
speedtest: Testing 2 page write speed
2 page write speed is 3182 KiB/s
speedtest: Testing 2 page read speed
2 page read speed is 14773 KiB/s
speedtest: Testing erase speed
erase speed is 192752 KiB/s
speedtest: speedtest finished
=================================================================

Also it's passed all nand-tests.

Signed-off-by: Adrian Hunter <ext-adrian.hunter@nokia.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
diff --git a/drivers/mtd/onenand/onenand_base.c b/drivers/mtd/onenand/onenand_base.c
index aaf3504..5a27adb 100644
--- a/drivers/mtd/onenand/onenand_base.c
+++ b/drivers/mtd/onenand/onenand_base.c
@@ -1455,7 +1455,8 @@  static int onenand_write_ops_nolock(struct mtd_info *mtd, loff_t to,
 				struct mtd_oob_ops *ops)
 {
 	struct onenand_chip *this = mtd->priv;
-	int written = 0, column, thislen, subpage;
+	int written = 0, column, thislen = 0, subpage = 0;
+	int prev = 0, prevlen = 0, prev_subpage = 0, first = 1;
 	int oobwritten = 0, oobcolumn, thisooblen, oobsize;
 	size_t len = ops->len;
 	size_t ooblen = ops->ooblen;
@@ -1482,6 +1483,10 @@  static int onenand_write_ops_nolock(struct mtd_info *mtd, loff_t to,
                 return -EINVAL;
         }
 
+	/* Check zero length */
+	if (!len)
+		return 0;
+
 	if (ops->mode == MTD_OOB_AUTO)
 		oobsize = this->ecclayout->oobavail;
 	else
@@ -1492,79 +1497,125 @@  static int onenand_write_ops_nolock(struct mtd_info *mtd, loff_t to,
 	column = to & (mtd->writesize - 1);
 
 	/* Loop until all data write */
-	while (written < len) {
-		u_char *wbuf = (u_char *) buf;
+	while (1) {
+		if (written < len) {
+			u_char *wbuf = (u_char *) buf;
 
-		thislen = min_t(int, mtd->writesize - column, len - written);
-		thisooblen = min_t(int, oobsize - oobcolumn, ooblen - oobwritten);
+			thislen = min_t(int, mtd->writesize - column, len - written);
+			thisooblen = min_t(int, oobsize - oobcolumn, ooblen - oobwritten);
 
-		cond_resched();
+			cond_resched();
 
-		this->command(mtd, ONENAND_CMD_BUFFERRAM, to, thislen);
+			this->command(mtd, ONENAND_CMD_BUFFERRAM, to, thislen);
 
-		/* Partial page write */
-		subpage = thislen < mtd->writesize;
-		if (subpage) {
-			memset(this->page_buf, 0xff, mtd->writesize);
-			memcpy(this->page_buf + column, buf, thislen);
-			wbuf = this->page_buf;
-		}
+			/* Partial page write */
+			subpage = thislen < mtd->writesize;
+			if (subpage) {
+				memset(this->page_buf, 0xff, mtd->writesize);
+				memcpy(this->page_buf + column, buf, thislen);
+				wbuf = this->page_buf;
+			}
 
-		this->write_bufferram(mtd, ONENAND_DATARAM, wbuf, 0, mtd->writesize);
+			this->write_bufferram(mtd, ONENAND_DATARAM, wbuf, 0, mtd->writesize);
 
-		if (oob) {
-			oobbuf = this->oob_buf;
+			if (oob) {
+				oobbuf = this->oob_buf;
 
-			/* We send data to spare ram with oobsize
-			 * to prevent byte access */
-			memset(oobbuf, 0xff, mtd->oobsize);
-			if (ops->mode == MTD_OOB_AUTO)
-				onenand_fill_auto_oob(mtd, oobbuf, oob, oobcolumn, thisooblen);
-			else
-				memcpy(oobbuf + oobcolumn, oob, thisooblen);
+				/* We send data to spare ram with oobsize
+				 * to prevent byte access */
+				memset(oobbuf, 0xff, mtd->oobsize);
+				if (ops->mode == MTD_OOB_AUTO)
+					onenand_fill_auto_oob(mtd, oobbuf, oob, oobcolumn, thisooblen);
+				else
+					memcpy(oobbuf + oobcolumn, oob, thisooblen);
 
-			oobwritten += thisooblen;
-			oob += thisooblen;
-			oobcolumn = 0;
+				oobwritten += thisooblen;
+				oob += thisooblen;
+				oobcolumn = 0;
+			} else
+				oobbuf = (u_char *) ffchars;
+
+			this->write_bufferram(mtd, ONENAND_SPARERAM, oobbuf, 0, mtd->oobsize);
 		} else
-			oobbuf = (u_char *) ffchars;
+			ONENAND_SET_NEXT_BUFFERRAM(this);
 
-		this->write_bufferram(mtd, ONENAND_SPARERAM, oobbuf, 0, mtd->oobsize);
+		/*
+		 * 2 PLANE, MLC, and Flex-OneNAND doesn't support
+		 * write-while-programe feature.
+		 */
+		if (!ONENAND_IS_2PLANE(this) && !first) {
+			ONENAND_SET_PREV_BUFFERRAM(this);
 
-		this->command(mtd, ONENAND_CMD_PROG, to, mtd->writesize);
+			ret = this->wait(mtd, FL_WRITING);
 
-		ret = this->wait(mtd, FL_WRITING);
+			/* In partial page write we don't update bufferram */
+			onenand_update_bufferram(mtd, prev, !ret && !prev_subpage);
+			if (ret) {
+				written -= prevlen;
+				printk(KERN_ERR "onenand_write_ops_nolock: write filaed %d\n", ret);
+				break;
+			}
 
-		/* In partial page write we don't update bufferram */
-		onenand_update_bufferram(mtd, to, !ret && !subpage);
-		if (ONENAND_IS_2PLANE(this)) {
-			ONENAND_SET_BUFFERRAM1(this);
-			onenand_update_bufferram(mtd, to + this->writesize, !ret && !subpage);
-		}
+			if (written == len) {
+				/* Only check verify write turn on */
+				ret = onenand_verify(mtd, buf - len, to - len, len);
+				if (ret) {
+					printk(KERN_ERR "onenand_write_ops_nolock: verify failed %d\n", ret);
+					break;
+				}
+			}
 
-		if (ret) {
-			printk(KERN_ERR "onenand_write_ops_nolock: write filaed %d\n", ret);
-			break;
-		}
+			if (written == len)
+				break;
 
-		/* Only check verify write turn on */
-		ret = onenand_verify(mtd, buf, to, thislen);
-		if (ret) {
-			printk(KERN_ERR "onenand_write_ops_nolock: verify failed %d\n", ret);
-			break;
+			ONENAND_SET_NEXT_BUFFERRAM(this);
 		}
 
-		written += thislen;
+		this->command(mtd, ONENAND_CMD_PROG, to, mtd->writesize);
 
-		if (written == len)
-			break;
+		/*
+		 * 2 PLANE, MLC, and Flex-OneNAND wait here
+		 */
+		if (ONENAND_IS_2PLANE(this)) {
+			ret = this->wait(mtd, FL_WRITING);
+
+			/* In partial page write we don't update bufferram */
+			onenand_update_bufferram(mtd, to, !ret && !subpage);
+			if (ret) {
+				printk(KERN_ERR "onenand_write_ops_nolock: write filaed %d\n", ret);
+				break;
+			}
+
+			/* Only check verify write turn on */
+			ret = onenand_verify(mtd, buf, to, thislen);
+			if (ret) {
+				printk(KERN_ERR "onenand_write_ops_nolock: verify failed %d\n", ret);
+				break;
+			}
+
+			written += thislen;
+
+			if (written == len)
+				break;
+
+		} else
+			written += thislen;
 
 		column = 0;
+		prev_subpage = subpage;
+		prev = to;
+		prevlen = thislen;
 		to += thislen;
 		buf += thislen;
+		first = 0;
 	}
 
+	/* In error case, clear all bufferrams */
+	if (written != len)
+		onenand_invalidate_bufferram(mtd, to - written, len);
+
 	ops->retlen = written;
+	ops->oobretlen = oobwritten;
 
 	return ret;
 }