mtd: rawnand: Cache read sequential
Subsystems (2)
v2 cover mtd: rawnand: Cache read sequential
v2:
1. correct the 3rd parameter for nand_exec_continue_read_page_op function.
2. adding mtd_info struction for judge operation in nand_exec_continue_read_page_op function.
3. adding performance result in commit log
JaimeLiao (1):
mtd: rawnand: Cache read sequential
drivers/mtd/nand/raw/nand_base.c | 96 +++++++++++++++++++++++++++-- drivers/mtd/nand/raw/nand_timings.c | 12 ++++ include/linux/mtd/rawnand.h | 7 +++ 3 files changed, 110 insertions(+), 5 deletions(-)
Signature · 6 lines
2.17.1 ______________________________________________________ Linux MTD discussion mailing list http://lists.infradead.org/mailman/listinfo/linux-mtd/
PATCH v2 1/1 mtd: rawnand: Cache read sequential
For reducing instruction in command operation and time of read sequence which address are continuous.
Adding cache read sequential feature support in raw nand existing architecture. Creating nand_exec_continue_read_page_op function for read command extend. Adding command select in nand_lp_exec_read_page_op and taking readlen to judge the last page for read.
Command of read cache sequential can be separate 3 parts.
First part is 00-ADDR-30-31-DATA_IN, it means read cache sequential enabled and next page data can be prepare while cache data reading.
Second part is 31-DATA_IN, means flash will prepare next page data for reducing time cost.
Last part is 3F-DATA_IN, means the last cache read and flash don't need to prepare next page data.
Example for 2 page read operation, as below is the NAND operation instructions:
Normal read mode:
00 -- ADDR1 -- 30 -- WAIT_RDY(tR+tRR) -- DATA1_IN
00 -- ADDR2 -- 30 -- WAIT_RDY(tR+tRR) -- DATA2_INCache read sequential mode:
00 -- ADDR1 -- 30 -- WAIT_RDY(tR) -- 31 -- WAIT_RDY(tRCBSY+tRR) -- DATA1_IN
3F -- WAIT_RDY(tRCBSY+tRR) -- DATA2_INtR is about 20 microsecond
tRCBSY is about 5 microsecond
tRR is about 20 nanosecond
As below is mtd_speedtest result between normale read and cache read sequential on NXP i.MX6 VAR-SOM-SOLO mapping mode.
===============Normal read 33M===================mtd_speedtest: MTD device: 0mtd_speedtest: MTD device size 2097152, eraseblock size 131072, page size 2048, count of eraseblocks 16, pages per eraseblock 64, OOB size 64mtd_test: scanning for bad eraseblocksmtd_test: scanned 16 eraseblocks, 0 are badmtd_speedtest: testing eraseblock write speedmtd_speedtest: eraseblock write speed is 3864 KiB/smtd_speedtest: testing eraseblock read speedmtd_speedtest: eraseblock read speed is 15633 KiB/smtd_speedtest: testing page write speedmtd_speedtest: page write speed is 3561 KiB/smtd_speedtest: testing page read speedmtd_speedtest: page read speed is 15515 KiB/smtd_speedtest: testing 2 page write speedmtd_speedtest: 2 page write speed is 3690 KiB/smtd_speedtest: testing 2 page read speedmtd_speedtest: 2 page read speed is 15398 KiB/smtd_speedtest: Testing erase speedmtd_speedtest: erase speed is 227555 KiB/smtd_speedtest: Testing 2x multi-block erase speedmtd_speedtest: 2x multi-block erase speed is 204800 KiB/smtd_speedtest: Testing 4x multi-block erase speedmtd_speedtest: 4x multi-block erase speed is 204800 KiB/smtd_speedtest: Testing 8x multi-block erase speedmtd_speedtest: 8x multi-block erase speed is 204800 KiB/smtd_speedtest: Testing 16x multi-block erase speedmtd_speedtest: 16x multi-block erase speed is 204800 KiB/smtd_speedtest: Testing 32x multi-block erase speedmtd_speedtest: 32x multi-block erase speed is 204800 KiB/smtd_speedtest: Testing 64x multi-block erase speedmtd_speedtest: 64x multi-block erase speed is 227555 KiB/smtd_speedtest: finished
=================================================
============Cache reade Sequential 33MHz===========mtd_speedtest: MTD device: 0mtd_speedtest: MTD device size 2097152, eraseblock size 131072, page size 2048, count of eraseblocks 16, pages per eraseblock 64, OOB size 64mtd_test: scanning for bad eraseblocksmtd_test: scanned 16 eraseblocks, 0 are badmtd_speedtest: testing eraseblock write speedmtd_speedtest: eraseblock write speed is 4120 KiB/smtd_speedtest: testing eraseblock read speedmtd_speedtest: eraseblock read speed is 18285 KiB/smtd_speedtest: testing page write speedmtd_speedtest: page write speed is 4031 KiB/smtd_speedtest: testing page read speedmtd_speedtest: page read speed is 15875 KiB/smtd_speedtest: testing 2 page write speedmtd_speedtest: 2 page write speed is 3946 KiB/smtd_speedtest: testing 2 page read speedmtd_speedtest: 2 page read speed is 16253 KiB/smtd_speedtest: Testing erase speedmtd_speedtest: erase speed is 227555 KiB/smtd_speedtest: Testing 2x multi-block erase speedmtd_speedtest: 2x multi-block erase speed is 227555 KiB/smtd_speedtest: Testing 4x multi-block erase speedmtd_speedtest: 4x multi-block erase speed is 204800 KiB/smtd_speedtest: Testing 8x multi-block erase speedmtd_speedtest: 8x multi-block erase speed is 204800 KiB/smtd_speedtest: Testing 16x multi-block erase speedmtd_speedtest: 16x multi-block erase speed is 227555 KiB/smtd_speedtest: Testing 32x multi-block erase speedmtd_speedtest: 32x multi-block erase speed is 204800 KiB/smtd_speedtest: Testing 64x multi-block erase speedmtd_speedtest: 64x multi-block erase speed is 204800 KiB/smtd_speedtest: finished
=================================================
The result could have about 5% improvement between 2 modes when 2 pages read.
--- drivers/mtd/nand/raw/nand_base.c | 96 +++++++++++++++++++++++++++-- drivers/mtd/nand/raw/nand_timings.c | 12 ++++ include/linux/mtd/rawnand.h | 7 +++ 3 files changed, 110 insertions(+), 5 deletions(-)
drivers/mtd/nand/raw/nand_base.c +91 -5
@@ -1176,6 +1176,39 @@ static int nand_lp_exec_read_page_op(struct nand_chip *chip, unsigned int page,const struct nand_interface_config *conf =nand_get_interface_config (chip);u8 addrs[5 ]; + +/* Command sequence select to 00-30-31 when read cache sequential is enabled */ +if (chip->ops.conti_read_require) { +struct nand_op_instr instrs[] = { +NAND_OP_CMD (NAND_CMD_READ0 ,0 ), +NAND_OP_ADDR (4 , addrs,0 ), +NAND_OP_CMD (NAND_CMD_READSTART ,NAND_COMMON_TIMING_NS (conf, tWB_max)), +NAND_OP_WAIT_RDY (NAND_COMMON_TIMING_MS (conf, tR_max),0 ), +NAND_OP_CMD (NAND_CMD_READCONTI ,NAND_COMMON_TIMING_NS (conf, tWB_max)), +NAND_OP_WAIT_RDY (NAND_COMMON_TIMING_MS (conf, tRCBSY_min), +NAND_COMMON_TIMING_NS (conf, tRR_min)), +NAND_OP_DATA_IN (len, buf,0 ), + }; +struct nand_operation op =NAND_OPERATION (chip->cur_cs, instrs); +int ret; + +if (!len) + op.ninstrs--; + + ret =nand_fill_column_cycles (chip, addrs, offset_in_page); +if (ret <0 ) +return ret; + + addrs[2 ] = page; + addrs[3 ] = page >>8 ; + +if (chip->options &NAND_ROW_ADDR_3 ) { + addrs[4 ] = page >>16 ; + instrs[1 ].ctx.addr.naddrs++; + } + +return nand_exec_op (chip, &op); + }struct nand_op_instr instrs[] = {NAND_OP_CMD (NAND_CMD_READ0 ,0 ),NAND_OP_ADDR (4 , addrs,0 ),
@@ -1206,6 +1239,32 @@ static int nand_lp_exec_read_page_op(struct nand_chip *chip, unsigned int page,return nand_exec_op (chip, &op); } +static int nand_exec_continue_read_page_op (struct nand_chip *chip, +void *buf,unsigned int len) +{ +struct mtd_info *mtd =nand_to_mtd (chip); +bool conti_read_last = false; +const struct nand_interface_config *conf = +nand_get_interface_config (chip); +/* Set conti_read_last true before the last aligned page reading */ +if (chip->ops.conti_readlen >= mtd->writesize && chip->ops.conti_readlen <2 *mtd->writesize) + conti_read_last = true; +struct nand_op_instr instrs[] = { +NAND_OP_CMD (conti_read_last?NAND_CMD_READLAST :NAND_CMD_READCONTI , +NAND_COMMON_TIMING_NS (conf, tWB_max)), +NAND_OP_WAIT_RDY (NAND_COMMON_TIMING_MS (conf, tRCBSY_min), +NAND_COMMON_TIMING_NS (conf, tRR_min)), +NAND_OP_DATA_IN (len, buf,0 ), + }; +struct nand_operation op =NAND_OPERATION (chip->cur_cs, instrs); + +/* Drop the DATA_IN instruction if len is set to 0. */ +if (!len) + op.ninstrs--; + +return nand_exec_op (chip, &op); +} +/** * nand_read_page_op - Do a READ PAGE operation * @chip: The NAND chip
@@ -1231,10 +1290,15 @@ int nand_read_page_op(struct nand_chip *chip, unsigned int page,return -EINVAL ;if (nand_has_exec_op (chip)) { -if (mtd->writesize >512 ) -return nand_lp_exec_read_page_op (chip, page, - offset_in_page, buf, - len); +if (mtd->writesize >512 ) { +/* Selecting read command sequence */ +if (!chip->ops.conti_read_first_page && chip->ops.conti_read_require) +return nand_exec_continue_read_page_op (chip, buf, len); +else +return nand_lp_exec_read_page_op (chip, page, + offset_in_page, buf, + len); + }return nand_sp_exec_read_page_op (chip, page, offset_in_page, buf, len);
@@ -3362,7 +3426,6 @@ static int nand_do_read_ops(struct nand_chip *chip, loff_t from, bytes =min (mtd->writesize - col, readlen); aligned = (bytes == mtd->writesize); -if (!aligned) use_bounce_buf =1 ;else if (chip->options &NAND_USES_DMA )
@@ -3381,6 +3444,25 @@ static int nand_do_read_ops(struct nand_chip *chip, loff_t from, __func__, buf); read_retry: +/* +* Read cache sequential command can be separate 3 parts. +* For distinguishing that flash driver set value to +* conti_read_first_page for checking whether the first page +* and set conti_read_require to select command sequence. +* And take readlen to conti_readlen for checking whether the +* last page or not. +*/ +if (!col && readlen >= (2 *mtd->writesize)) { +if (chip->ops.conti_read_require ==0 ) + chip->ops.conti_read_first_page =1 ; +else + chip->ops.conti_read_first_page =0 ; + chip->ops.conti_read_require =1 ; + chip->ops.conti_readlen = readlen; + }else if (chip->ops.conti_read_require) { + chip->ops.conti_read_first_page =0 ; + chip->ops.conti_readlen = readlen; + }/* * Now read the page into the buffer. Absent an error, * the read methods return max bitflips per ecc step.
@@ -3468,6 +3550,10 @@ static int nand_do_read_ops(struct nand_chip *chip, loff_t from, retry_mode =0 ; } +/* set conti_read_require 0 when finish the last aligned page read */ +if (readlen < mtd->writesize) + chip->ops.conti_read_require =0 ; +if (!readlen)break ;
drivers/mtd/nand/raw/nand_timings.c +12 -0
@@ -27,6 +27,7 @@ static const struct nand_interface_config onfi_sdr_timings[] = { .timings.sdr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tADL_min = 400000,
@@ -72,6 +73,7 @@ static const struct nand_interface_config onfi_sdr_timings[] = { .timings.sdr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tADL_min = 400000,
@@ -117,6 +119,7 @@ static const struct nand_interface_config onfi_sdr_timings[] = { .timings.sdr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tADL_min = 400000,
@@ -162,6 +165,7 @@ static const struct nand_interface_config onfi_sdr_timings[] = { .timings.sdr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tADL_min = 400000,
@@ -207,6 +211,7 @@ static const struct nand_interface_config onfi_sdr_timings[] = { .timings.sdr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tADL_min = 400000,
@@ -252,6 +257,7 @@ static const struct nand_interface_config onfi_sdr_timings[] = { .timings.sdr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tADL_min = 400000,
@@ -300,6 +306,7 @@ static const struct nand_interface_config onfi_nvddr_timings[] = { .timings.nvddr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tAC_min = 3000,
@@ -342,6 +349,7 @@ static const struct nand_interface_config onfi_nvddr_timings[] = { .timings.nvddr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tAC_min = 3000,
@@ -384,6 +392,7 @@ static const struct nand_interface_config onfi_nvddr_timings[] = { .timings.nvddr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tAC_min = 3000,
@@ -426,6 +435,7 @@ static const struct nand_interface_config onfi_nvddr_timings[] = { .timings.nvddr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tAC_min = 3000,
@@ -468,6 +478,7 @@ static const struct nand_interface_config onfi_nvddr_timings[] = { .timings.nvddr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tAC_min = 3000,
@@ -510,6 +521,7 @@ static const struct nand_interface_config onfi_nvddr_timings[] = { .timings.nvddr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tAC_min = 3000,
include/linux/mtd/rawnand.h +7 -0
@@ -67,6 +67,8 @@ struct gpio_desc;/* Extended commands for large page devices */ #define NAND_CMD_READSTART 0x30 +#define NAND_CMD_READCONTI 0x31 +#define NAND_CMD_READLAST 0x3f#define NAND_CMD_RNDOUTSTART 0xE0#define NAND_CMD_CACHEDPROG 0x15
@@ -436,6 +438,7 @@ struct nand_sdr_timings {u32 tCCS_min;u64 tPROG_max;u64 tR_max; +u64 tRCBSY_min;u32 tALH_min;u32 tADL_min;u32 tALS_min;
@@ -525,6 +528,7 @@ struct nand_nvddr_timings {u32 tCCS_min;u64 tPROG_max;u64 tR_max; +u64 tRCBSY_min;u32 tAC_min;u32 tAC_max;u32 tADL_min;
@@ -1173,6 +1177,9 @@ struct nand_chip_ops {int (*setup_read_retry)(struct nand_chip *chip,int retry_mode);int (*choose_interface_config)(struct nand_chip *chip,struct nand_interface_config *iface); +bool conti_read_require; +bool conti_read_first_page; +int conti_readlen; };/**
Signature · 6 lines
2.17.1 ______________________________________________________ Linux MTD discussion mailing list http://lists.infradead.org/mailman/listinfo/linux-mtd/
Miquel Raynal
maintainerHi Jaime,
Sorry for the long wait.
[email protected] wrote on Mon, 29 Aug 2022 15:24:52 +0800:
Quoted 3 lines
For reducing instruction in command operation and time of read sequence which address are continuous.
Adding cache read sequential feature support in raw nand existing architecture.
What about :
"
Add support for sequential cache reads.
Sequential reads may reduce the overhead when accessing physically continuous data by loading in cache the next page while the previous page gets sent out on the NAND bus.
The ONFI specification provides the following additional commands to handle sequential cached reads:
* 0x31 - READ CACHE SEQUENTIAL:
Requires the NAND chip to load the next page into cache while keeping the current cache available for host reads.
* 0x3F - READ CACHE END:
Tells the NAND chip this is the end of the sequential cache read, the current cache shall remain accessible for the host but no more internal cache loading operation is required.
On the bus, a multi page read operation is currently handled like this:
00 -- ADDR1 -- 30 -- WAIT_RDY (tR+tRR) -- DATA1_IN 00 -- ADDR2 -- 30 -- WAIT_RDY (tR+tRR) -- DATA2_IN 00 -- ADDR3 -- 30 -- WAIT_RDY (tR+tRR) -- DATA3_IN
Sequential cached reads may instead be achieved with:
00 -- ADDR1 -- 30 -- WAIT_RDY (tR) -- \ 31 -- WAIT_RDY (tRCBSY+tRR) -- DATA1_IN \ 31 -- WAIT_RDY (tRCBSY+tRR) -- DATA2_IN \ 3F -- WAIT_RDY (tRCBSY+tRR) -- DATA3_IN
"
Quoted 23 lines
Creating
nand_exec_continue_read_page_opfunction for read command extend. Adding command select innand_lp_exec_read_page_opand taking readlen to judge the last page for read.
Command of read cache sequential can be separate 3 parts.First part is 00-ADDR-30-31-DATA_IN, it means read cache sequential enabled and next page data can be prepare while cache data reading.
Second part is 31-DATA_IN, means flash will prepare next page data for reducing time cost.
Last part is 3F-DATA_IN, means the last cache read and flash don't need to prepare next page data.
Example for 2 page read operation, as below is the NAND operation instructions:
Normal read mode:00 -- ADDR1 -- 30 -- WAIT_RDY(tR+tRR) -- DATA1_IN 00 -- ADDR2 -- 30 -- WAIT_RDY(tR+tRR) -- DATA2_INCache read sequential mode:
00 -- ADDR1 -- 30 -- WAIT_RDY(tR) -- 31 -- WAIT_RDY(tRCBSY+tRR) -- DATA1_IN 3F -- WAIT_RDY(tRCBSY+tRR) -- DATA2_IN
Quoted 6 lines
tR is about 20 microsecond
tRCBSY is about 5 microsecond
tRR is about 20 nanosecondAs below is
mtd_speedtestresult between normale read and cache read sequential on NXP i.MX6 VAR-SOM-SOLO mapping mode.
Below are the read speed test results with regular reads and sequential cached reads, on NXP i.MX6 VAR-SOM-SOLO in mapping mode with a NAND chip characterized with the following timings:
* tR is about 20µs
* tRCBSY is about 5µs
* tRR is about 20µs
Quoted 11 lines
===============Normal read 33M===================
mtd_speedtest: MTD device: 0mtd_speedtest: MTD device size 2097152, eraseblock size 131072, page size 2048, count of eraseblocks 16, pages per eraseblock 64, OOB size 64mtd_test: scanning for bad eraseblocksmtd_test: scanned 16 eraseblocks, 0 are badmtd_speedtest: testing eraseblock write speedmtd_speedtest: eraseblock write speed is 3864 KiB/smtd_speedtest: testing eraseblock read speedmtd_speedtest: eraseblock read speed is 15633 KiB/s
Maybe in both cases you can just keep the interesting lines with the various read speeds.
Quoted 60 lines
mtd_speedtest: testing page write speedmtd_speedtest: page write speed is 3561 KiB/smtd_speedtest: testing page read speedmtd_speedtest: page read speed is 15515 KiB/smtd_speedtest: testing 2 page write speedmtd_speedtest: 2 page write speed is 3690 KiB/smtd_speedtest: testing 2 page read speedmtd_speedtest: 2 page read speed is 15398 KiB/smtd_speedtest: Testing erase speedmtd_speedtest: erase speed is 227555 KiB/smtd_speedtest: Testing 2x multi-block erase speedmtd_speedtest: 2x multi-block erase speed is 204800 KiB/smtd_speedtest: Testing 4x multi-block erase speedmtd_speedtest: 4x multi-block erase speed is 204800 KiB/smtd_speedtest: Testing 8x multi-block erase speedmtd_speedtest: 8x multi-block erase speed is 204800 KiB/smtd_speedtest: Testing 16x multi-block erase speedmtd_speedtest: 16x multi-block erase speed is 204800 KiB/smtd_speedtest: Testing 32x multi-block erase speedmtd_speedtest: 32x multi-block erase speed is 204800 KiB/smtd_speedtest: Testing 64x multi-block erase speedmtd_speedtest: 64x multi-block erase speed is 227555 KiB/smtd_speedtest: finished
=============================================================Cache reade Sequential 33MHz===========
mtd_speedtest: MTD device: 0mtd_speedtest: MTD device size 2097152, eraseblock size 131072, page size 2048, count of eraseblocks 16, pages per eraseblock 64, OOB size 64mtd_test: scanning for bad eraseblocksmtd_test: scanned 16 eraseblocks, 0 are badmtd_speedtest: testing eraseblock write speedmtd_speedtest: eraseblock write speed is 4120 KiB/smtd_speedtest: testing eraseblock read speedmtd_speedtest: eraseblock read speed is 18285 KiB/smtd_speedtest: testing page write speedmtd_speedtest: page write speed is 4031 KiB/smtd_speedtest: testing page read speedmtd_speedtest: page read speed is 15875 KiB/smtd_speedtest: testing 2 page write speedmtd_speedtest: 2 page write speed is 3946 KiB/smtd_speedtest: testing 2 page read speedmtd_speedtest: 2 page read speed is 16253 KiB/smtd_speedtest: Testing erase speedmtd_speedtest: erase speed is 227555 KiB/smtd_speedtest: Testing 2x multi-block erase speedmtd_speedtest: 2x multi-block erase speed is 227555 KiB/smtd_speedtest: Testing 4x multi-block erase speedmtd_speedtest: 4x multi-block erase speed is 204800 KiB/smtd_speedtest: Testing 8x multi-block erase speedmtd_speedtest: 8x multi-block erase speed is 204800 KiB/smtd_speedtest: Testing 16x multi-block erase speedmtd_speedtest: 16x multi-block erase speed is 227555 KiB/smtd_speedtest: Testing 32x multi-block erase speedmtd_speedtest: 32x multi-block erase speed is 204800 KiB/smtd_speedtest: Testing 64x multi-block erase speedmtd_speedtest: 64x multi-block erase speed is 204800 KiB/smtd_speedtest: finished
=================================================
Quoted 1 line
The result could have about 5% improvement between 2 modes when 2 pages read.
We observe an overall improvement of x% when reading 2 pages, y% when reading a block.
Quoted 38 lines
Signed-off-by JaimeLiao <[email protected]>--- drivers/mtd/nand/raw/nand_base.c | 96 +++++++++++++++++++++++++++-- drivers/mtd/nand/raw/nand_timings.c | 12 ++++ include/linux/mtd/rawnand.h | 7 +++ 3 files changed, 110 insertions(+), 5 deletions(-)drivers/mtd/nand/raw/nand_base.c +23
-0@@ -1176,6 +1176,39 @@ static int nand_lp_exec_read_page_op(struct nand_chip *chip, unsigned int page,const struct nand_interface_config *conf =nand_get_interface_config (chip);u8 addrs[5 ]; + +/* Command sequence select to 00-30-31 when read cache sequential is enabled */ +if (chip->ops.conti_read_require) { +struct nand_op_instr instrs[] = { +NAND_OP_CMD (NAND_CMD_READ0 ,0 ), +NAND_OP_ADDR (4 , addrs,0 ), +NAND_OP_CMD (NAND_CMD_READSTART ,NAND_COMMON_TIMING_NS (conf, tWB_max)), +NAND_OP_WAIT_RDY (NAND_COMMON_TIMING_MS (conf, tR_max),0 ), +NAND_OP_CMD (NAND_CMD_READCONTI ,NAND_COMMON_TIMING_NS (conf, tWB_max)), +NAND_OP_WAIT_RDY (NAND_COMMON_TIMING_MS (conf, tRCBSY_min), +NAND_COMMON_TIMING_NS (conf, tRR_min)), +NAND_OP_DATA_IN (len, buf,0 ), + }; +struct nand_operation op =NAND_OPERATION (chip->cur_cs, instrs); +int ret; + +if (!len) + op.ninstrs--; + + ret =nand_fill_column_cycles (chip, addrs, offset_in_page); +if (ret <0 ) +return ret; +
drivers/mtd/nand/raw/nand_base.c static int nand_lp_exec_read_page_op(struct nand_chip *chip, unsigned int page, · line 1211
Quoted 10 lines
drivers/mtd/nand/raw/nand_base.c +10
-0+ addrs[2 ] = page; + addrs[3 ] = page >>8 ; + +if (chip->options &NAND_ROW_ADDR_3 ) { + addrs[4 ] = page >>16 ; + instrs[1 ].ctx.addr.naddrs++; + } + +return nand_exec_op (chip, &op); + }
Please create a dedicated function for continuous reads, let's avoid messing with the regular path.
I would greatly appreciate additional parameters
Quoted 10 lines
drivers/mtd/nand/raw/nand_base.c +3
-0struct nand_op_instr instrs[] = {NAND_OP_CMD (NAND_CMD_READ0 ,0 ),NAND_OP_ADDR (4 , addrs,0 ),@@ -1206,6 +1239,32 @@ static int nand_lp_exec_read_page_op(struct nand_chip *chip, unsigned int page,return nand_exec_op (chip, &op); } +static int nand_exec_continue_read_page_op (struct nand_chip *chip, +void *buf,unsigned int len) +{
drivers/mtd/nand/raw/nand_base.c static int nand_lp_exec_read_page_op(struct nand_chip *chip, unsigned int page, · line 1254
Quoted 10 lines
drivers/mtd/nand/raw/nand_base.c +10
-0+struct mtd_info *mtd =nand_to_mtd (chip); +bool conti_read_last = false; +const struct nand_interface_config *conf = +nand_get_interface_config (chip); +/* Set conti_read_last true before the last aligned page reading */ +if (chip->ops.conti_readlen >= mtd->writesize && chip->ops.conti_readlen <2 *mtd->writesize) + conti_read_last = true; +struct nand_op_instr instrs[] = { +NAND_OP_CMD (conti_read_last?NAND_CMD_READLAST :NAND_CMD_READCONTI , +NAND_COMMON_TIMING_NS (conf, tWB_max)),
Please run checkpatch.pl and fix the style.
Quoted 23 lines
drivers/mtd/nand/raw/nand_base.c +13
-3+NAND_OP_WAIT_RDY (NAND_COMMON_TIMING_MS (conf, tRCBSY_min), +NAND_COMMON_TIMING_NS (conf, tRR_min)), + NAND_OP_DATA_IN(len, buf, 0), + }; +struct nand_operation op =NAND_OPERATION (chip->cur_cs, instrs); + +/* Drop the DATA_IN instruction if len is set to 0. */ +if (!len) + op.ninstrs--; + +return nand_exec_op (chip, &op); +} +/** * nand_read_page_op - Do a READ PAGE operation * @chip: The NAND chip @@ -1231,10 +1290,15 @@ int nand_read_page_op(struct nand_chip *chip, unsigned int page,return -EINVAL ;if (nand_has_exec_op (chip)) { -if (mtd->writesize >512 ) - return nand_lp_exec_read_page_op(chip, page, - offset_in_page, buf,
drivers/mtd/nand/raw/nand_base.c int nand_read_page_op(struct nand_chip *chip, unsigned int page, · line 1301
Quoted 10 lines
drivers/mtd/nand/raw/nand_base.c +9
-1- len); +if (mtd->writesize >512 ) { +/* Selecting read command sequence */ +if (!chip->ops.conti_read_first_page && chip->ops.conti_read_require) +return nand_exec_continue_read_page_op (chip, buf, len); +else +return nand_lp_exec_read_page_op (chip, page, + offset_in_page, buf, + len); + }
EZ NAND do not support sequential cache reads, please add the necessary flags to avoid trying continuous reads on them.
Also, as said above, I would create an entirely new helper like this:
nand_lp_exec_cont_read_page_op(chip, page, buf, len)
{
if (chip->cont_read_first_page == page)
start_continuous_read();
else if (chip->cont_read_last_page == page)
end_continuous_read();
else
continuous_read();
}drivers/mtd/nand/raw/nand_base.c static int nand_do_read_ops(struct nand_chip *chip, loff_t from, · line 3365
Quoted 8 lines
drivers/mtd/nand/raw/nand_base.c +0
-1return nand_sp_exec_read_page_op (chip, page, offset_in_page, buf, len);@@ -3362,7 +3426,6 @@ static int nand_do_read_ops(struct nand_chip *chip, loff_t from, bytes =min (mtd->writesize - col, readlen); aligned = (bytes == mtd->writesize); -
Unrelated change, please drop
drivers/mtd/nand/raw/nand_base.c static int nand_do_read_ops(struct nand_chip *chip, loff_t from, · line 3446
Quoted 7 lines
drivers/mtd/nand/raw/nand_base.c +0
-0if (!aligned) use_bounce_buf =1 ;else if (chip->options &NAND_USES_DMA )@@ -3381,6 +3444,25 @@ static int nand_do_read_ops(struct nand_chip *chip, loff_t from, __func__, buf); read_retry:
I believe read retries cannot be used with sequential cache reads, because the whole point of retries is to read from the NAND array into cache again, which is exactly what we are trying to avoid. Am I right? If yes, then we should disable continuous reads when a retry is required.
drivers/mtd/nand/raw/nand_base.c static int nand_do_read_ops(struct nand_chip *chip, loff_t from, · line 3453
Quoted 7 lines
drivers/mtd/nand/raw/nand_base.c +7
-0+/* +* Read cache sequential command can be separate 3 parts. +* For distinguishing that flash driver set value to +* conti_read_first_page for checking whether the first page +* and set conti_read_require to select command sequence. +* And take readlen to conti_readlen for checking whether the +* last page or not.
Maybe you could use the reworded commit log I proposed to explain the different cases.
drivers/mtd/nand/raw/nand_base.c static int nand_do_read_ops(struct nand_chip *chip, loff_t from, · line 3465
Quoted 12 lines
drivers/mtd/nand/raw/nand_base.c +12
-0+*/ +if (!col && readlen >= (2 *mtd->writesize)) { +if (chip->ops.conti_read_require ==0 ) + chip->ops.conti_read_first_page =1 ; +else + chip->ops.conti_read_first_page =0 ; + chip->ops.conti_read_require =1 ; + chip->ops.conti_readlen = readlen; + }else if (chip->ops.conti_read_require) { + chip->ops.conti_read_first_page =0 ; + chip->ops.conti_readlen = readlen; + }
I would create a helper for that.
It should look at the entire operation and just set a number of variables stored into struct nand_chip (even though I'm not a big fan of the idea, I don't see how to do it differently). The feature should be disabled if they cannot be fully used, let's support the simplest cases only. I would like to see a single parameter which tells the core:
use or do not use continuous read on this operation. Then, I would prefer storing eg. the address of the first and last pages to read so that a dumb read helper (like above) can just look at the page address and perform the right call.
drivers/mtd/nand/raw/nand_timings.c
Quoted 18 lines
drivers/mtd/nand/raw/nand_base.c +4
-0/* * Now read the page into the buffer. Absent an error, * the read methods return max bitflips per ecc step. @@ -3468,6 +3550,10 @@ static int nand_do_read_ops(struct nand_chip *chip, loff_t from, retry_mode =0 ; } +/* set conti_read_require 0 when finish the last aligned page read */ +if (readlen < mtd->writesize) + chip->ops.conti_read_require =0 ; +if (!readlen)break ;drivers/mtd/nand/raw/nand_timings.c +0
-0
Maybe the timing additions can be done in a separated patch.
Quoted 126 lines
drivers/mtd/nand/raw/nand_timings.c +12
-0@@ -27,6 +27,7 @@ static const struct nand_interface_config onfi_sdr_timings[] = { .timings.sdr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tADL_min = 400000,@@ -72,6 +73,7 @@ static const struct nand_interface_config onfi_sdr_timings[] = { .timings.sdr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tADL_min = 400000,@@ -117,6 +119,7 @@ static const struct nand_interface_config onfi_sdr_timings[] = { .timings.sdr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tADL_min = 400000,@@ -162,6 +165,7 @@ static const struct nand_interface_config onfi_sdr_timings[] = { .timings.sdr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tADL_min = 400000,@@ -207,6 +211,7 @@ static const struct nand_interface_config onfi_sdr_timings[] = { .timings.sdr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tADL_min = 400000,@@ -252,6 +257,7 @@ static const struct nand_interface_config onfi_sdr_timings[] = { .timings.sdr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tADL_min = 400000,@@ -300,6 +306,7 @@ static const struct nand_interface_config onfi_nvddr_timings[] = { .timings.nvddr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tAC_min = 3000,@@ -342,6 +349,7 @@ static const struct nand_interface_config onfi_nvddr_timings[] = { .timings.nvddr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tAC_min = 3000,@@ -384,6 +392,7 @@ static const struct nand_interface_config onfi_nvddr_timings[] = { .timings.nvddr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tAC_min = 3000,@@ -426,6 +435,7 @@ static const struct nand_interface_config onfi_nvddr_timings[] = { .timings.nvddr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tAC_min = 3000,@@ -468,6 +478,7 @@ static const struct nand_interface_config onfi_nvddr_timings[] = { .timings.nvddr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tAC_min = 3000,@@ -510,6 +521,7 @@ static const struct nand_interface_config onfi_nvddr_timings[] = { .timings.nvddr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tAC_min = 3000,include/linux/mtd/rawnand.h +4
-0@@ -67,6 +67,8 @@ struct gpio_desc;/* Extended commands for large page devices */ #define NAND_CMD_READSTART 0x30 +#define NAND_CMD_READCONTI 0x31 +#define NAND_CMD_READLAST 0x3f#define NAND_CMD_RNDOUTSTART 0xE0#define NAND_CMD_CACHEDPROG 0x15@@ -436,6 +438,7 @@ struct nand_sdr_timings {u32 tCCS_min;u64 tPROG_max;u64 tR_max; +u64 tRCBSY_min;u32 tALH_min;u32 tADL_min;u32 tALS_min;@@ -525,6 +528,7 @@ struct nand_nvddr_timings {u32 tCCS_min;u64 tPROG_max;u64 tR_max; +u64 tRCBSY_min;u32 tAC_min;u32 tAC_max;u32 tADL_min;
include/linux/mtd/rawnand.h struct nand_chip_ops { · line 1182
Quoted 6 lines
include/linux/mtd/rawnand.h +3
-0@@ -1173,6 +1177,9 @@ struct nand_chip_ops {int (*setup_read_retry)(struct nand_chip *chip,int retry_mode);int (*choose_interface_config)(struct nand_chip *chip,struct nand_interface_config *iface); +bool conti_read_require; +bool conti_read_first_page; +int conti_readlen;
I would rather prefer the cont_ prefix rather than conti_.
And why do we have these information under "nand_chip_ops" rather than nand_chip?
Thanks,
Miquèl
______________________________________________________
Linux MTD discussion mailing list
http://lists.infradead.org/mailman/listinfo/linux-mtd/
Miquel Raynal
maintainer[email protected] wrote on Mon, 7 Nov 2022 14:56:10 +0100:
Quoted 266 lines
Hi Jaime,
Sorry for the long wait.
[email protected] wrote on Mon, 29 Aug 2022 15:24:52 +0800:
Quoted 3 lines
For reducing instruction in command operation and time of read sequence which address are continuous.
Adding cache read sequential feature support in raw nand existing architecture.What about :
"
Add support for sequential cache reads.Sequential reads may reduce the overhead when accessing physically continuous data by loading in cache the next page while the previous page gets sent out on the NAND bus.
The ONFI specification provides the following additional commands to handle sequential cached reads:
*
0x31- READ CACHE SEQUENTIAL:
Requires the NAND chip to load the next page into cache while keeping the current cache available for host reads.
*0x3F- READ CACHE END:
Tells the NAND chip this is the end of the sequential cache read, the current cache shall remain accessible for the host but no more internal cache loading operation is required.On the bus, a multi page read operation is currently handled like this:
00 -- ADDR1 -- 30 -- WAIT_RDY (tR+tRR) -- DATA1_IN 00 -- ADDR2 -- 30 -- WAIT_RDY (tR+tRR) -- DATA2_IN 00 -- ADDR3 -- 30 -- WAIT_RDY (tR+tRR) -- DATA3_INSequential cached reads may instead be achieved with:
00 -- ADDR1 -- 30 -- WAIT_RDY (tR) -- \ 31 -- WAIT_RDY (tRCBSY+tRR) -- DATA1_IN \ 31 -- WAIT_RDY (tRCBSY+tRR) -- DATA2_IN \ 3F -- WAIT_RDY (tRCBSY+tRR) -- DATA3_IN"
Quoted 23 lines
Creating
nand_exec_continue_read_page_opfunction for read command extend. Adding command select innand_lp_exec_read_page_opand taking readlen to judge the last page for read.
Command of read cache sequential can be separate 3 parts.First part is 00-ADDR-30-31-DATA_IN, it means read cache sequential enabled and next page data can be prepare while cache data reading.
Second part is 31-DATA_IN, means flash will prepare next page data for reducing time cost.
Last part is 3F-DATA_IN, means the last cache read and flash don't need to prepare next page data.
Example for 2 page read operation, as below is the NAND operation instructions:
Normal read mode:00 -- ADDR1 -- 30 -- WAIT_RDY(tR+tRR) -- DATA1_IN 00 -- ADDR2 -- 30 -- WAIT_RDY(tR+tRR) -- DATA2_INCache read sequential mode:
00 -- ADDR1 -- 30 -- WAIT_RDY(tR) -- 31 -- WAIT_RDY(tRCBSY+tRR) -- DATA1_IN 3F -- WAIT_RDY(tRCBSY+tRR) -- DATA2_INQuoted 6 lines
tR is about 20 microsecond
tRCBSY is about 5 microsecond
tRR is about 20 nanosecondAs below is
mtd_speedtestresult between normale read and cache read sequential on NXP i.MX6 VAR-SOM-SOLO mapping mode.Below are the read speed test results with regular reads and sequential cached reads, on NXP i.MX6 VAR-SOM-SOLO in mapping mode with a NAND chip characterized with the following timings:
* tR is about 20µs
* tRCBSY is about 5µs
* tRR is about 20µsQuoted 11 lines
===============Normal read 33M===================
mtd_speedtest: MTD device: 0mtd_speedtest: MTD device size 2097152, eraseblock size 131072, page size 2048, count of eraseblocks 16, pages per eraseblock 64, OOB size 64mtd_test: scanning for bad eraseblocksmtd_test: scanned 16 eraseblocks, 0 are badmtd_speedtest: testing eraseblock write speedmtd_speedtest: eraseblock write speed is 3864 KiB/smtd_speedtest: testing eraseblock read speedmtd_speedtest: eraseblock read speed is 15633 KiB/sMaybe in both cases you can just keep the interesting lines with the various read speeds.
Quoted 60 lines
mtd_speedtest: testing page write speedmtd_speedtest: page write speed is 3561 KiB/smtd_speedtest: testing page read speedmtd_speedtest: page read speed is 15515 KiB/smtd_speedtest: testing 2 page write speedmtd_speedtest: 2 page write speed is 3690 KiB/smtd_speedtest: testing 2 page read speedmtd_speedtest: 2 page read speed is 15398 KiB/smtd_speedtest: Testing erase speedmtd_speedtest: erase speed is 227555 KiB/smtd_speedtest: Testing 2x multi-block erase speedmtd_speedtest: 2x multi-block erase speed is 204800 KiB/smtd_speedtest: Testing 4x multi-block erase speedmtd_speedtest: 4x multi-block erase speed is 204800 KiB/smtd_speedtest: Testing 8x multi-block erase speedmtd_speedtest: 8x multi-block erase speed is 204800 KiB/smtd_speedtest: Testing 16x multi-block erase speedmtd_speedtest: 16x multi-block erase speed is 204800 KiB/smtd_speedtest: Testing 32x multi-block erase speedmtd_speedtest: 32x multi-block erase speed is 204800 KiB/smtd_speedtest: Testing 64x multi-block erase speedmtd_speedtest: 64x multi-block erase speed is 227555 KiB/smtd_speedtest: finished
=============================================================Cache reade Sequential 33MHz===========
mtd_speedtest: MTD device: 0mtd_speedtest: MTD device size 2097152, eraseblock size 131072, page size 2048, count of eraseblocks 16, pages per eraseblock 64, OOB size 64mtd_test: scanning for bad eraseblocksmtd_test: scanned 16 eraseblocks, 0 are badmtd_speedtest: testing eraseblock write speedmtd_speedtest: eraseblock write speed is 4120 KiB/smtd_speedtest: testing eraseblock read speedmtd_speedtest: eraseblock read speed is 18285 KiB/smtd_speedtest: testing page write speedmtd_speedtest: page write speed is 4031 KiB/smtd_speedtest: testing page read speedmtd_speedtest: page read speed is 15875 KiB/smtd_speedtest: testing 2 page write speedmtd_speedtest: 2 page write speed is 3946 KiB/smtd_speedtest: testing 2 page read speedmtd_speedtest: 2 page read speed is 16253 KiB/smtd_speedtest: Testing erase speedmtd_speedtest: erase speed is 227555 KiB/smtd_speedtest: Testing 2x multi-block erase speedmtd_speedtest: 2x multi-block erase speed is 227555 KiB/smtd_speedtest: Testing 4x multi-block erase speedmtd_speedtest: 4x multi-block erase speed is 204800 KiB/smtd_speedtest: Testing 8x multi-block erase speedmtd_speedtest: 8x multi-block erase speed is 204800 KiB/smtd_speedtest: Testing 16x multi-block erase speedmtd_speedtest: 16x multi-block erase speed is 227555 KiB/smtd_speedtest: Testing 32x multi-block erase speedmtd_speedtest: 32x multi-block erase speed is 204800 KiB/smtd_speedtest: Testing 64x multi-block erase speedmtd_speedtest: 64x multi-block erase speed is 204800 KiB/smtd_speedtest: finished
=================================================Quoted 1 line
The result could have about 5% improvement between 2 modes when 2 pages read.
We observe an overall improvement of x% when reading 2 pages, y% when reading a block.
Quoted 38 lines
Signed-off-by JaimeLiao <[email protected]>--- drivers/mtd/nand/raw/nand_base.c | 96 +++++++++++++++++++++++++++-- drivers/mtd/nand/raw/nand_timings.c | 12 ++++ include/linux/mtd/rawnand.h | 7 +++ 3 files changed, 110 insertions(+), 5 deletions(-)drivers/mtd/nand/raw/nand_base.c +23
-0@@ -1176,6 +1176,39 @@ static int nand_lp_exec_read_page_op(struct nand_chip *chip, unsigned int page,const struct nand_interface_config *conf =nand_get_interface_config (chip);u8 addrs[5 ]; + +/* Command sequence select to 00-30-31 when read cache sequential is enabled */ +if (chip->ops.conti_read_require) { +struct nand_op_instr instrs[] = { +NAND_OP_CMD (NAND_CMD_READ0 ,0 ), +NAND_OP_ADDR (4 , addrs,0 ), +NAND_OP_CMD (NAND_CMD_READSTART ,NAND_COMMON_TIMING_NS (conf, tWB_max)), +NAND_OP_WAIT_RDY (NAND_COMMON_TIMING_MS (conf, tR_max),0 ), +NAND_OP_CMD (NAND_CMD_READCONTI ,NAND_COMMON_TIMING_NS (conf, tWB_max)), +NAND_OP_WAIT_RDY (NAND_COMMON_TIMING_MS (conf, tRCBSY_min), +NAND_COMMON_TIMING_NS (conf, tRR_min)), +NAND_OP_DATA_IN (len, buf,0 ), + }; +struct nand_operation op =NAND_OPERATION (chip->cur_cs, instrs); +int ret; + +if (!len) + op.ninstrs--; + + ret =nand_fill_column_cycles (chip, addrs, offset_in_page); +if (ret <0 ) +return ret; +drivers/mtd/nand/raw/nand_base.c static int nand_lp_exec_read_page_op(struct nand_chip *chip, unsigned int page, · line 1211
Quoted 10 lines
drivers/mtd/nand/raw/nand_base.c +10
-0+ addrs[2 ] = page; + addrs[3 ] = page >>8 ; + +if (chip->options &NAND_ROW_ADDR_3 ) { + addrs[4 ] = page >>16 ; + instrs[1 ].ctx.addr.naddrs++; + } + +return nand_exec_op (chip, &op); + }Please create a dedicated function for continuous reads, let's avoid messing with the regular path.
I would greatly appreciate additional parameters
Quoted 10 lines
drivers/mtd/nand/raw/nand_base.c +3
-0struct nand_op_instr instrs[] = {NAND_OP_CMD (NAND_CMD_READ0 ,0 ),NAND_OP_ADDR (4 , addrs,0 ),@@ -1206,6 +1239,32 @@ static int nand_lp_exec_read_page_op(struct nand_chip *chip, unsigned int page,return nand_exec_op (chip, &op); } +static int nand_exec_continue_read_page_op (struct nand_chip *chip, +void *buf,unsigned int len) +{drivers/mtd/nand/raw/nand_base.c static int nand_lp_exec_read_page_op(struct nand_chip *chip, unsigned int page, · line 1254
Quoted 10 lines
drivers/mtd/nand/raw/nand_base.c +10
-0+struct mtd_info *mtd =nand_to_mtd (chip); +bool conti_read_last = false; +const struct nand_interface_config *conf = +nand_get_interface_config (chip); +/* Set conti_read_last true before the last aligned page reading */ +if (chip->ops.conti_readlen >= mtd->writesize && chip->ops.conti_readlen <2 *mtd->writesize) + conti_read_last = true; +struct nand_op_instr instrs[] = { +NAND_OP_CMD (conti_read_last?NAND_CMD_READLAST :NAND_CMD_READCONTI , +NAND_COMMON_TIMING_NS (conf, tWB_max)),Please run checkpatch.pl and fix the style.
Quoted 28 lines
drivers/mtd/nand/raw/nand_base.c +17
-4+NAND_OP_WAIT_RDY (NAND_COMMON_TIMING_MS (conf, tRCBSY_min), +NAND_COMMON_TIMING_NS (conf, tRR_min)), + NAND_OP_DATA_IN(len, buf, 0), + }; +struct nand_operation op =NAND_OPERATION (chip->cur_cs, instrs); + +/* Drop the DATA_IN instruction if len is set to 0. */ +if (!len) + op.ninstrs--; + +return nand_exec_op (chip, &op); +} +/** * nand_read_page_op - Do a READ PAGE operation * @chip: The NAND chip @@ -1231,10 +1290,15 @@ int nand_read_page_op(struct nand_chip *chip, unsigned int page,return -EINVAL ;if (nand_has_exec_op (chip)) { -if (mtd->writesize >512 ) -return nand_lp_exec_read_page_op (chip, page, - offset_in_page, buf, - len); +if (mtd->writesize >512 ) { +/* Selecting read command sequence */ +if (!chip->ops.conti_read_first_page && chip->ops.conti_read_require) +return nand_exec_continue_read_page_op (chip, buf, len);
Quoted 8 lines
drivers/mtd/nand/raw/nand_base.c int nand_read_page_op(struct nand_chip *chip, unsigned int page, · line 1301
Quoted 5 lines
drivers/mtd/nand/raw/nand_base.c +5
-0+else +return nand_lp_exec_read_page_op (chip, page, + offset_in_page, buf, + len); + }EZ NAND do not support sequential cache reads, please add the necessary flags to avoid trying continuous reads on them.
Please also run exec_op with check_only set to verify the controller supports it before enabling the flag.
Quoted 229 lines
Also, as said above, I would create an entirely new helper like this:
nand_lp_exec_cont_read_page_op(chip, page, buf, len){ if (chip->cont_read_first_page == page) start_continuous_read(); else if (chip->cont_read_last_page == page) end_continuous_read(); else continuous_read(); }drivers/mtd/nand/raw/nand_base.c static int nand_do_read_ops(struct nand_chip *chip, loff_t from, · line 3365
Quoted 8 lines
drivers/mtd/nand/raw/nand_base.c +0
-1return nand_sp_exec_read_page_op (chip, page, offset_in_page, buf, len);@@ -3362,7 +3426,6 @@ static int nand_do_read_ops(struct nand_chip *chip, loff_t from, bytes =min (mtd->writesize - col, readlen); aligned = (bytes == mtd->writesize); -Unrelated change, please drop
drivers/mtd/nand/raw/nand_base.c static int nand_do_read_ops(struct nand_chip *chip, loff_t from, · line 3446
Quoted 7 lines
drivers/mtd/nand/raw/nand_base.c +0
-0if (!aligned) use_bounce_buf =1 ;else if (chip->options &NAND_USES_DMA )@@ -3381,6 +3444,25 @@ static int nand_do_read_ops(struct nand_chip *chip, loff_t from, __func__, buf); read_retry:I believe read retries cannot be used with sequential cache reads, because the whole point of retries is to read from the NAND array into cache again, which is exactly what we are trying to avoid. Am I right? If yes, then we should disable continuous reads when a retry is required.
drivers/mtd/nand/raw/nand_base.c static int nand_do_read_ops(struct nand_chip *chip, loff_t from, · line 3453
Quoted 7 lines
drivers/mtd/nand/raw/nand_base.c +7
-0+/* +* Read cache sequential command can be separate 3 parts. +* For distinguishing that flash driver set value to +* conti_read_first_page for checking whether the first page +* and set conti_read_require to select command sequence. +* And take readlen to conti_readlen for checking whether the +* last page or not. Maybe you could use the reworded commit log I proposed to explain the different cases.
drivers/mtd/nand/raw/nand_base.c static int nand_do_read_ops(struct nand_chip *chip, loff_t from, · line 3465
Quoted 12 lines
drivers/mtd/nand/raw/nand_base.c +12
-0+*/ +if (!col && readlen >= (2 *mtd->writesize)) { +if (chip->ops.conti_read_require ==0 ) + chip->ops.conti_read_first_page =1 ; +else + chip->ops.conti_read_first_page =0 ; + chip->ops.conti_read_require =1 ; + chip->ops.conti_readlen = readlen; + }else if (chip->ops.conti_read_require) { + chip->ops.conti_read_first_page =0 ; + chip->ops.conti_readlen = readlen; + }I would create a helper for that.
It should look at the entire operation and just set a number of variables stored into struct
nand_chip(even though I'm not a big fan of the idea, I don't see how to do it differently). The feature should be disabled if they cannot be fully used, let's support the simplest cases only. I would like to see a single parameter which tells the core:
use or do not use continuous read on this operation. Then, I would prefer storing eg. the address of the first and last pages to read so that a dumb read helper (like above) can just look at the page address and perform the right call.drivers/mtd/nand/raw/nand_timings.c
Quoted 18 lines
drivers/mtd/nand/raw/nand_base.c +4
-0/* * Now read the page into the buffer. Absent an error, * the read methods return max bitflips per ecc step. @@ -3468,6 +3550,10 @@ static int nand_do_read_ops(struct nand_chip *chip, loff_t from, retry_mode =0 ; } +/* set conti_read_require 0 when finish the last aligned page read */ +if (readlen < mtd->writesize) + chip->ops.conti_read_require =0 ; +if (!readlen)break ;drivers/mtd/nand/raw/nand_timings.c +0
-0Maybe the timing additions can be done in a separated patch.
Quoted 126 lines
drivers/mtd/nand/raw/nand_timings.c +12
-0@@ -27,6 +27,7 @@ static const struct nand_interface_config onfi_sdr_timings[] = { .timings.sdr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tADL_min = 400000,@@ -72,6 +73,7 @@ static const struct nand_interface_config onfi_sdr_timings[] = { .timings.sdr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tADL_min = 400000,@@ -117,6 +119,7 @@ static const struct nand_interface_config onfi_sdr_timings[] = { .timings.sdr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tADL_min = 400000,@@ -162,6 +165,7 @@ static const struct nand_interface_config onfi_sdr_timings[] = { .timings.sdr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tADL_min = 400000,@@ -207,6 +211,7 @@ static const struct nand_interface_config onfi_sdr_timings[] = { .timings.sdr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tADL_min = 400000,@@ -252,6 +257,7 @@ static const struct nand_interface_config onfi_sdr_timings[] = { .timings.sdr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tADL_min = 400000,@@ -300,6 +306,7 @@ static const struct nand_interface_config onfi_nvddr_timings[] = { .timings.nvddr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tAC_min = 3000,@@ -342,6 +349,7 @@ static const struct nand_interface_config onfi_nvddr_timings[] = { .timings.nvddr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tAC_min = 3000,@@ -384,6 +392,7 @@ static const struct nand_interface_config onfi_nvddr_timings[] = { .timings.nvddr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tAC_min = 3000,@@ -426,6 +435,7 @@ static const struct nand_interface_config onfi_nvddr_timings[] = { .timings.nvddr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tAC_min = 3000,@@ -468,6 +478,7 @@ static const struct nand_interface_config onfi_nvddr_timings[] = { .timings.nvddr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tAC_min = 3000,@@ -510,6 +521,7 @@ static const struct nand_interface_config onfi_nvddr_timings[] = { .timings.nvddr = { .tCCS_min = 500000, .tR_max = 200000000, + .tRCBSY_min = 40000000, .tPROG_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tBERS_max = 1000000ULL * ONFI_DYN_TIMING_MAX, .tAC_min = 3000,include/linux/mtd/rawnand.h +4
-0@@ -67,6 +67,8 @@ struct gpio_desc;/* Extended commands for large page devices */ #define NAND_CMD_READSTART 0x30 +#define NAND_CMD_READCONTI 0x31 +#define NAND_CMD_READLAST 0x3f#define NAND_CMD_RNDOUTSTART 0xE0#define NAND_CMD_CACHEDPROG 0x15@@ -436,6 +438,7 @@ struct nand_sdr_timings {u32 tCCS_min;u64 tPROG_max;u64 tR_max; +u64 tRCBSY_min;u32 tALH_min;u32 tADL_min;u32 tALS_min;@@ -525,6 +528,7 @@ struct nand_nvddr_timings {u32 tCCS_min;u64 tPROG_max;u64 tR_max; +u64 tRCBSY_min;u32 tAC_min;u32 tAC_max;u32 tADL_min;include/linux/mtd/rawnand.h struct nand_chip_ops { · line 1182
Quoted 6 lines
include/linux/mtd/rawnand.h +3
-0@@ -1173,6 +1177,9 @@ struct nand_chip_ops {int (*setup_read_retry)(struct nand_chip *chip,int retry_mode);int (*choose_interface_config)(struct nand_chip *chip,struct nand_interface_config *iface); +bool conti_read_require; +bool conti_read_first_page; +int conti_readlen;I would rather prefer the
cont_prefix rather thanconti_.
Quoted 5 lines
And why do we have these information under "
nand_chip_ops" rather thannand_chip?Thanks,
Miquèl
Thanks,
Miquèl
______________________________________________________
Linux MTD discussion mailing list
http://lists.infradead.org/mailman/listinfo/linux-mtd/