Re: [PATCH] mtd: spinand: cache the last read page to avoid redundant SPI operations

[kernel test robot <lkp@intel.com>]

Hi fzz,

kernel test robot noticed the following build errors:

[auto build test ERROR on mtd/nand/next]
[also build test ERROR on linus/master v7.3-rc2 next-20260907]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]

url:    https://github.com/intel-lab-lkp/linux/commits/fzz/mtd-spinand-cache-the-last-read-page-to-avoid-redundant-SPI-operations/20260907-191040
base:   https://git.kernel.org/pub/scm/linux/kernel/git/mtd/linux.git nand/next
patch link:    https://lore.kernel.org/r/tencent_219EED44C45D6CEC1D6B6724343E13733005%40qq.com
patch subject: [PATCH] mtd: spinand: cache the last read page to avoid redundant SPI operations
config: powerpc-randconfig-r072-20260908 (https://download.01.org/0day-ci/archive/20260908/202609080921.381EOoBZ-lkp@intel.com/config)
compiler: powerpc-linux-gcc (GCC) 9.5.0
smatch: v0.5.0-9187-g5189e3fb
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20260908/202609080921.381EOoBZ-lkp@intel.com/reproduce)

If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <lkp@intel.com>
| Closes: https://lore.kernel.org/oe-kbuild-all/202609080921.381EOoBZ-lkp@intel.com/

All errors (new ones prefixed by >>):

   drivers/mtd/nand/spi/core.c: In function 'spinand_read_from_cache_op':
>> drivers/mtd/nand/spi/core.c:563:46: error: 'const struct nand_page_io_req' has no member named 'disable_ecc'
     563 |  if (req->datalen && !req->continuous && !req->disable_ecc) {
         |                                              ^~


vim +563 drivers/mtd/nand/spi/core.c

   474	
   475	static int spinand_read_from_cache_op(struct spinand_device *spinand,
   476					      const struct nand_page_io_req *req)
   477	{
   478		struct nand_device *nand = spinand_to_nand(spinand);
   479		struct mtd_info *mtd = spinand_to_mtd(spinand);
   480		struct spi_mem_dirmap_desc *rdesc;
   481		unsigned int nbytes = 0;
   482		void *buf = NULL;
   483		u16 column = 0;
   484		ssize_t ret;
   485	
   486		if (req->datalen) {
   487			buf = spinand->databuf;
   488			if (!req->continuous)
   489				nbytes = nanddev_page_size(nand);
   490			else
   491				nbytes = round_up(req->dataoffs + req->datalen,
   492						  nanddev_page_size(nand));
   493			column = 0;
   494		}
   495	
   496		if (req->ooblen) {
   497			nbytes += nanddev_per_page_oobsize(nand);
   498			if (!buf) {
   499				buf = spinand->oobbuf;
   500				column = nanddev_page_size(nand);
   501			}
   502		}
   503	
   504		rdesc = spinand->dirmaps[req->pos.plane].rdesc;
   505	
   506		if (spinand->op_templates->cont_read_cache && req->continuous)
   507			rdesc->info.op_tmpl = &rdesc->info.secondary_op_tmpl;
   508		else
   509			rdesc->info.op_tmpl = &rdesc->info.primary_op_tmpl;
   510	
   511		if (nand->ecc.engine->integration == NAND_ECC_ENGINE_INTEGRATION_PIPELINED &&
   512		    req->mode != MTD_OPS_RAW)
   513			rdesc->info.op_tmpl->data.ecc = true;
   514		else
   515			rdesc->info.op_tmpl->data.ecc = false;
   516	
   517		if (spinand->flags & SPINAND_HAS_READ_PLANE_SELECT_BIT)
   518			column |= req->pos.plane << fls(nanddev_page_size(nand));
   519	
   520		while (nbytes) {
   521			ret = spi_mem_dirmap_read(rdesc, column, nbytes, buf);
   522			if (ret < 0)
   523				return ret;
   524	
   525			if (!ret || ret > nbytes)
   526				return -EIO;
   527	
   528			nbytes -= ret;
   529			column += ret;
   530			buf += ret;
   531	
   532			/*
   533			 * Dirmap accesses are allowed to toggle the CS.
   534			 * Toggling the CS during a continuous read is forbidden.
   535			 */
   536			if (nbytes && req->continuous) {
   537				/*
   538				 * Spi controller with broken support of continuous
   539				 * reading was detected. Disable future use of
   540				 * continuous reading and return -EAGAIN to retry
   541				 * reading within regular mode.
   542				 */
   543				spinand->cont_read_possible = false;
   544				return -EAGAIN;
   545			}
   546		}
   547	
   548		if (req->datalen)
   549			memcpy(req->databuf.in, spinand->databuf + req->dataoffs,
   550			       req->datalen);
   551	
   552		if (req->ooblen) {
   553			if (req->mode == MTD_OPS_AUTO_OOB)
   554				mtd_ooblayout_get_databytes(mtd, req->oobbuf.in,
   555							    spinand->oobbuf,
   556							    req->ooboffs,
   557							    req->ooblen);
   558			else
   559				memcpy(req->oobbuf.in, spinand->oobbuf + req->ooboffs,
   560					req->ooblen);
   561		}
   562	
 > 563		if (req->datalen && !req->continuous && !req->disable_ecc) {
   564			spinand->cur_target_cache = req->pos.target;
   565			spinand->cur_block_cache = req->pos.eraseblock;
   566			spinand->cur_page_cache = req->pos.page;
   567			spinand->cache_valid = true;
   568		}
   569	
   570		return 0;
   571	}
   572	

--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki