| Message ID | 20210518093951.23136-1-patrice.chotard@foss.st.com |
|---|---|
| Headers | show |
| Series | MTD: spinand: Add spi_mem_poll_status() support | expand |
Just saw a missing update, i am sending a v4. Sorry Patrice On 5/18/21 11:39 AM, patrice.chotard@foss.st.com wrote: > From: Patrice Chotard <patrice.chotard@foss.st.com> > > This series adds support for the spi_mem_poll_status() spinand > interface. > Some QSPI controllers allows to poll automatically memory > status during operations (erase, read or write). This allows to > offload the CPU for this task. > STM32 QSPI is supporting this feature, driver update are also > part of this series. > > Chnages in v3: > - Add spi_mem_read_status() which allows to read 8 or 16 bits status. > - Add initial_delay_us and polling_delay_us parameters to spi_mem_poll_status(). > and also to poll_status() callback. > - Move spi_mem_supports_op() in SW-based polling case. > - Add delay before invoquing read_poll_timeout(). > - Remove the reinit/wait_for_completion() added in v2. > - Add initial_delay_us and polling_delay_us parameters to spinand_wait(). > - Add SPINAND_READ/WRITE/ERASE/RESET_INITIAL_DELAY_US and > SPINAND_READ/WRITE/ERASE/RESET_POLL_DELAY_US defines. > - Remove spi_mem_finalize_op() API added in v2. > > Changes in v2: > - Indicates the spi_mem_poll_status() timeout unit > - Use 2-byte wide status register > - Add spi_mem_supports_op() call in spi_mem_poll_status() > - Add completion management in spi_mem_poll_status() > - Add offload/non-offload case management in spi_mem_poll_status() > - Optimize the non-offload case by using read_poll_timeout() > - mask and match stm32_qspi_poll_status()'s parameters are 2-byte wide > - Make usage of new spi_mem_finalize_op() API in > stm32_qspi_wait_poll_status() > > Patrice Chotard (3): > spi: spi-mem: add automatic poll status functions > mtd: spinand: use the spi-mem poll status APIs > spi: stm32-qspi: add automatic poll status feature > > drivers/mtd/nand/spi/core.c | 45 +++++++++++++------ > drivers/spi/spi-mem.c | 85 ++++++++++++++++++++++++++++++++++++ > drivers/spi/spi-stm32-qspi.c | 83 +++++++++++++++++++++++++++++++---- > include/linux/mtd/spinand.h | 11 ++++- > include/linux/spi/spi-mem.h | 14 ++++++ > 5 files changed, 216 insertions(+), 22 deletions(-) >
On Tue, 18 May 2021 11:39:49 +0200 <patrice.chotard@foss.st.com> wrote: > From: Patrice Chotard <patrice.chotard@foss.st.com> > > With STM32 QSPI, it is possible to poll the status register of the device. > This could be done to offload the CPU during an operation (erase or > program a SPI NAND for example). > > spi_mem_poll_status API has been added to handle this feature. > This new function take care of the offload/non-offload cases. > > For the non-offload case, use read_poll_timeout() to poll the status in > order to release CPU during this phase. > For example, previously, when erasing large area, in non-offload case, > CPU load can reach ~50%, now it decrease to ~35%. > > Signed-off-by: Patrice Chotard <patrice.chotard@foss.st.com> > Signed-off-by: Christophe Kerello <christophe.kerello@foss.st.com> > --- > Changes in v3: > - Add spi_mem_read_status() which allows to read 8 or 16 bits status. > - Add initial_delay_us and polling_delay_us parameters to spi_mem_poll_status() > and also to poll_status() callback. > - Move spi_mem_supports_op() in SW-based polling case. > - Add delay before invoking read_poll_timeout(). > - Remove the reinit/wait_for_completion() added in v2. > > Changes in v2: > - Indicates the spi_mem_poll_status() timeout unit > - Use 2-byte wide status register > - Add spi_mem_supports_op() call in spi_mem_poll_status() > - Add completion management in spi_mem_poll_status() > - Add offload/non-offload case management in spi_mem_poll_status() > - Optimize the non-offload case by using read_poll_timeout() > > drivers/spi/spi-mem.c | 85 +++++++++++++++++++++++++++++++++++++ > include/linux/spi/spi-mem.h | 14 ++++++ > 2 files changed, 99 insertions(+) > > diff --git a/drivers/spi/spi-mem.c b/drivers/spi/spi-mem.c > index 1513553e4080..257dc501d5df 100644 > --- a/drivers/spi/spi-mem.c > +++ b/drivers/spi/spi-mem.c > @@ -6,6 +6,7 @@ > * Author: Boris Brezillon <boris.brezillon@bootlin.com> > */ > #include <linux/dmaengine.h> > +#include <linux/iopoll.h> > #include <linux/pm_runtime.h> > #include <linux/spi/spi.h> > #include <linux/spi/spi-mem.h> > @@ -743,6 +744,89 @@ static inline struct spi_mem_driver *to_spi_mem_drv(struct device_driver *drv) > return container_of(drv, struct spi_mem_driver, spidrv.driver); > } > > +int spi_mem_read_status(struct spi_mem *mem, > + const struct spi_mem_op *op, > + u16 *status) > +{ > + const u8 *bytes = (u8 *)op->data.buf.in; > + int ret; > + > + ret = spi_mem_exec_op(mem, op); > + if (ret) > + return ret; > + > + if (op->data.nbytes > 1) > + *status = ((u16)bytes[0] << 8) | bytes[1]; > + else > + *status = bytes[0]; > + > + return 0; > +} > + > +/** > + * spi_mem_poll_status() - Poll memory device status > + * @mem: SPI memory device > + * @op: the memory operation to execute > + * @mask: status bitmask to ckeck > + * @match: (status & mask) expected value > + * @initial_delay_us: delay in us before starting to poll > + * @polling_delay_us: time to sleep between reads in us > + * @timeout_ms: timeout in milliseconds > + * > + * This function send a polling status request to the controller driver > + * > + * Return: 0 in case of success, -ETIMEDOUT in case of error, > + * -EOPNOTSUPP if not supported. > + */ > +int spi_mem_poll_status(struct spi_mem *mem, > + const struct spi_mem_op *op, > + u16 mask, u16 match, > + unsigned long initial_delay_us, > + unsigned long polling_delay_us, > + u16 timeout_ms) > +{ > + struct spi_controller *ctlr = mem->spi->controller; > + int ret = -EOPNOTSUPP; > + int read_status_ret; > + u16 status; > + > + if (op->data.nbytes < 1 || op->data.nbytes > 2) > + return -EINVAL; > + > + if (ctlr->mem_ops && ctlr->mem_ops->poll_status) { > + ret = spi_mem_access_start(mem); > + if (ret) > + return ret; > + > + ret = ctlr->mem_ops->poll_status(mem, op, mask, match, > + initial_delay_us, polling_delay_us, > + timeout_ms); > + > + spi_mem_access_end(mem); > + } > + > + if (ret == -EOPNOTSUPP) { > + if (!spi_mem_supports_op(mem, op)) > + return ret; > + > + if (initial_delay_us < 10) > + udelay(initial_delay_us); > + else > + usleep_range((initial_delay_us >> 2) + 1, > + initial_delay_us); > + > + ret = read_poll_timeout(spi_mem_read_status, read_status_ret, > + (read_status_ret || ((status) & mask) == match), > + polling_delay_us, timeout_ms * 1000, false, mem, > + op, &status); > + if (read_status_ret) > + return read_status_ret; > + } > + > + return ret; > +} > +EXPORT_SYMBOL_GPL(spi_mem_poll_status); > + > static int spi_mem_probe(struct spi_device *spi) > { > struct spi_mem_driver *memdrv = to_spi_mem_drv(spi->dev.driver); > @@ -763,6 +847,7 @@ static int spi_mem_probe(struct spi_device *spi) > if (IS_ERR_OR_NULL(mem->name)) > return PTR_ERR_OR_ZERO(mem->name); > > + init_completion(&ctlr->xfer_completion); Is this still needed? > spi_set_drvdata(spi, mem); > > return memdrv->probe(mem); > diff --git a/include/linux/spi/spi-mem.h b/include/linux/spi/spi-mem.h > index 2b65c9edc34e..10375d9ad747 100644 > --- a/include/linux/spi/spi-mem.h > +++ b/include/linux/spi/spi-mem.h > @@ -250,6 +250,7 @@ static inline void *spi_mem_get_drvdata(struct spi_mem *mem) > * the currently mapped area), and the caller of > * spi_mem_dirmap_write() is responsible for calling it again in > * this case. > + * @poll_status: poll memory device status > * > * This interface should be implemented by SPI controllers providing an > * high-level interface to execute SPI memory operation, which is usually the > @@ -274,6 +275,12 @@ struct spi_controller_mem_ops { > u64 offs, size_t len, void *buf); > ssize_t (*dirmap_write)(struct spi_mem_dirmap_desc *desc, > u64 offs, size_t len, const void *buf); > + int (*poll_status)(struct spi_mem *mem, > + const struct spi_mem_op *op, > + u16 mask, u16 match, > + unsigned long initial_delay_us, > + unsigned long polling_rate_us, > + unsigned long timeout_ms); > }; > > /** > @@ -369,6 +376,13 @@ devm_spi_mem_dirmap_create(struct device *dev, struct spi_mem *mem, > void devm_spi_mem_dirmap_destroy(struct device *dev, > struct spi_mem_dirmap_desc *desc); > > +int spi_mem_poll_status(struct spi_mem *mem, > + const struct spi_mem_op *op, > + u16 mask, u16 match, > + unsigned long initial_delay_us, > + unsigned long polling_delay_us, > + u16 timeout); > + > int spi_mem_driver_register_with_owner(struct spi_mem_driver *drv, > struct module *owner); >
On Tue, 18 May 2021 11:39:49 +0200 <patrice.chotard@foss.st.com> wrote: > +/** > + * spi_mem_poll_status() - Poll memory device status > + * @mem: SPI memory device > + * @op: the memory operation to execute > + * @mask: status bitmask to ckeck > + * @match: (status & mask) expected value > + * @initial_delay_us: delay in us before starting to poll > + * @polling_delay_us: time to sleep between reads in us > + * @timeout_ms: timeout in milliseconds > + * > + * This function send a polling status request to the controller driver > + * > + * Return: 0 in case of success, -ETIMEDOUT in case of error, > + * -EOPNOTSUPP if not supported. > + */ > +int spi_mem_poll_status(struct spi_mem *mem, > + const struct spi_mem_op *op, > + u16 mask, u16 match, > + unsigned long initial_delay_us, > + unsigned long polling_delay_us, > + u16 timeout_ms) > +{ > + struct spi_controller *ctlr = mem->spi->controller; > + int ret = -EOPNOTSUPP; > + int read_status_ret; > + u16 status; > + > + if (op->data.nbytes < 1 || op->data.nbytes > 2) > + return -EINVAL; We should also make sure this is a read operation. > + > + if (ctlr->mem_ops && ctlr->mem_ops->poll_status) { > + ret = spi_mem_access_start(mem); > + if (ret) > + return ret; > + > + ret = ctlr->mem_ops->poll_status(mem, op, mask, match, > + initial_delay_us, polling_delay_us, > + timeout_ms); > + > + spi_mem_access_end(mem); > + } > + > + if (ret == -EOPNOTSUPP) { > + if (!spi_mem_supports_op(mem, op)) > + return ret; > + > + if (initial_delay_us < 10) > + udelay(initial_delay_us); > + else > + usleep_range((initial_delay_us >> 2) + 1, > + initial_delay_us); > + > + ret = read_poll_timeout(spi_mem_read_status, read_status_ret, > + (read_status_ret || ((status) & mask) == match), > + polling_delay_us, timeout_ms * 1000, false, mem, > + op, &status); > + if (read_status_ret) > + return read_status_ret; > + } > + > + return ret; > +}
Hi Boris On 5/18/21 1:30 PM, Boris Brezillon wrote: > On Tue, 18 May 2021 11:39:49 +0200 > <patrice.chotard@foss.st.com> wrote: > >> From: Patrice Chotard <patrice.chotard@foss.st.com> >> >> With STM32 QSPI, it is possible to poll the status register of the device. >> This could be done to offload the CPU during an operation (erase or >> program a SPI NAND for example). >> >> spi_mem_poll_status API has been added to handle this feature. >> This new function take care of the offload/non-offload cases. >> >> For the non-offload case, use read_poll_timeout() to poll the status in >> order to release CPU during this phase. >> For example, previously, when erasing large area, in non-offload case, >> CPU load can reach ~50%, now it decrease to ~35%. >> >> Signed-off-by: Patrice Chotard <patrice.chotard@foss.st.com> >> Signed-off-by: Christophe Kerello <christophe.kerello@foss.st.com> >> --- >> Changes in v3: >> - Add spi_mem_read_status() which allows to read 8 or 16 bits status. >> - Add initial_delay_us and polling_delay_us parameters to spi_mem_poll_status() >> and also to poll_status() callback. >> - Move spi_mem_supports_op() in SW-based polling case. >> - Add delay before invoking read_poll_timeout(). >> - Remove the reinit/wait_for_completion() added in v2. >> >> Changes in v2: >> - Indicates the spi_mem_poll_status() timeout unit >> - Use 2-byte wide status register >> - Add spi_mem_supports_op() call in spi_mem_poll_status() >> - Add completion management in spi_mem_poll_status() >> - Add offload/non-offload case management in spi_mem_poll_status() >> - Optimize the non-offload case by using read_poll_timeout() >> >> drivers/spi/spi-mem.c | 85 +++++++++++++++++++++++++++++++++++++ >> include/linux/spi/spi-mem.h | 14 ++++++ >> 2 files changed, 99 insertions(+) >> >> diff --git a/drivers/spi/spi-mem.c b/drivers/spi/spi-mem.c >> index 1513553e4080..257dc501d5df 100644 >> --- a/drivers/spi/spi-mem.c >> +++ b/drivers/spi/spi-mem.c >> @@ -6,6 +6,7 @@ >> * Author: Boris Brezillon <boris.brezillon@bootlin.com> >> */ >> #include <linux/dmaengine.h> >> +#include <linux/iopoll.h> >> #include <linux/pm_runtime.h> >> #include <linux/spi/spi.h> >> #include <linux/spi/spi-mem.h> >> @@ -743,6 +744,89 @@ static inline struct spi_mem_driver *to_spi_mem_drv(struct device_driver *drv) >> return container_of(drv, struct spi_mem_driver, spidrv.driver); >> } >> >> +int spi_mem_read_status(struct spi_mem *mem, >> + const struct spi_mem_op *op, >> + u16 *status) >> +{ >> + const u8 *bytes = (u8 *)op->data.buf.in; >> + int ret; >> + >> + ret = spi_mem_exec_op(mem, op); >> + if (ret) >> + return ret; >> + >> + if (op->data.nbytes > 1) >> + *status = ((u16)bytes[0] << 8) | bytes[1]; >> + else >> + *status = bytes[0]; >> + >> + return 0; >> +} >> + >> +/** >> + * spi_mem_poll_status() - Poll memory device status >> + * @mem: SPI memory device >> + * @op: the memory operation to execute >> + * @mask: status bitmask to ckeck >> + * @match: (status & mask) expected value >> + * @initial_delay_us: delay in us before starting to poll >> + * @polling_delay_us: time to sleep between reads in us >> + * @timeout_ms: timeout in milliseconds >> + * >> + * This function send a polling status request to the controller driver >> + * >> + * Return: 0 in case of success, -ETIMEDOUT in case of error, >> + * -EOPNOTSUPP if not supported. >> + */ >> +int spi_mem_poll_status(struct spi_mem *mem, >> + const struct spi_mem_op *op, >> + u16 mask, u16 match, >> + unsigned long initial_delay_us, >> + unsigned long polling_delay_us, >> + u16 timeout_ms) >> +{ >> + struct spi_controller *ctlr = mem->spi->controller; >> + int ret = -EOPNOTSUPP; >> + int read_status_ret; >> + u16 status; >> + >> + if (op->data.nbytes < 1 || op->data.nbytes > 2) >> + return -EINVAL; >> + >> + if (ctlr->mem_ops && ctlr->mem_ops->poll_status) { >> + ret = spi_mem_access_start(mem); >> + if (ret) >> + return ret; >> + >> + ret = ctlr->mem_ops->poll_status(mem, op, mask, match, >> + initial_delay_us, polling_delay_us, >> + timeout_ms); >> + >> + spi_mem_access_end(mem); >> + } >> + >> + if (ret == -EOPNOTSUPP) { >> + if (!spi_mem_supports_op(mem, op)) >> + return ret; >> + >> + if (initial_delay_us < 10) >> + udelay(initial_delay_us); >> + else >> + usleep_range((initial_delay_us >> 2) + 1, >> + initial_delay_us); >> + >> + ret = read_poll_timeout(spi_mem_read_status, read_status_ret, >> + (read_status_ret || ((status) & mask) == match), >> + polling_delay_us, timeout_ms * 1000, false, mem, >> + op, &status); >> + if (read_status_ret) >> + return read_status_ret; >> + } >> + >> + return ret; >> +} >> +EXPORT_SYMBOL_GPL(spi_mem_poll_status); >> + >> static int spi_mem_probe(struct spi_device *spi) >> { >> struct spi_mem_driver *memdrv = to_spi_mem_drv(spi->dev.driver); >> @@ -763,6 +847,7 @@ static int spi_mem_probe(struct spi_device *spi) >> if (IS_ERR_OR_NULL(mem->name)) >> return PTR_ERR_OR_ZERO(mem->name); >> >> + init_completion(&ctlr->xfer_completion); > > Is this still needed? No, i forgot to remove it when reworking this v3 Thanks Patrice > >> spi_set_drvdata(spi, mem); >> >> return memdrv->probe(mem); >> diff --git a/include/linux/spi/spi-mem.h b/include/linux/spi/spi-mem.h >> index 2b65c9edc34e..10375d9ad747 100644 >> --- a/include/linux/spi/spi-mem.h >> +++ b/include/linux/spi/spi-mem.h >> @@ -250,6 +250,7 @@ static inline void *spi_mem_get_drvdata(struct spi_mem *mem) >> * the currently mapped area), and the caller of >> * spi_mem_dirmap_write() is responsible for calling it again in >> * this case. >> + * @poll_status: poll memory device status >> * >> * This interface should be implemented by SPI controllers providing an >> * high-level interface to execute SPI memory operation, which is usually the >> @@ -274,6 +275,12 @@ struct spi_controller_mem_ops { >> u64 offs, size_t len, void *buf); >> ssize_t (*dirmap_write)(struct spi_mem_dirmap_desc *desc, >> u64 offs, size_t len, const void *buf); >> + int (*poll_status)(struct spi_mem *mem, >> + const struct spi_mem_op *op, >> + u16 mask, u16 match, >> + unsigned long initial_delay_us, >> + unsigned long polling_rate_us, >> + unsigned long timeout_ms); >> }; >> >> /** >> @@ -369,6 +376,13 @@ devm_spi_mem_dirmap_create(struct device *dev, struct spi_mem *mem, >> void devm_spi_mem_dirmap_destroy(struct device *dev, >> struct spi_mem_dirmap_desc *desc); >> >> +int spi_mem_poll_status(struct spi_mem *mem, >> + const struct spi_mem_op *op, >> + u16 mask, u16 match, >> + unsigned long initial_delay_us, >> + unsigned long polling_delay_us, >> + u16 timeout); >> + >> int spi_mem_driver_register_with_owner(struct spi_mem_driver *drv, >> struct module *owner); >> >
On 5/18/21 1:40 PM, Boris Brezillon wrote: > On Tue, 18 May 2021 11:39:49 +0200 > <patrice.chotard@foss.st.com> wrote: > >> +/** >> + * spi_mem_poll_status() - Poll memory device status >> + * @mem: SPI memory device >> + * @op: the memory operation to execute >> + * @mask: status bitmask to ckeck >> + * @match: (status & mask) expected value >> + * @initial_delay_us: delay in us before starting to poll >> + * @polling_delay_us: time to sleep between reads in us >> + * @timeout_ms: timeout in milliseconds >> + * >> + * This function send a polling status request to the controller driver >> + * >> + * Return: 0 in case of success, -ETIMEDOUT in case of error, >> + * -EOPNOTSUPP if not supported. >> + */ >> +int spi_mem_poll_status(struct spi_mem *mem, >> + const struct spi_mem_op *op, >> + u16 mask, u16 match, >> + unsigned long initial_delay_us, >> + unsigned long polling_delay_us, >> + u16 timeout_ms) >> +{ >> + struct spi_controller *ctlr = mem->spi->controller; >> + int ret = -EOPNOTSUPP; >> + int read_status_ret; >> + u16 status; >> + >> + if (op->data.nbytes < 1 || op->data.nbytes > 2) >> + return -EINVAL; > > We should also make sure this is a read operation. Ok , i will add a check here Thanks Patrice > >> + >> + if (ctlr->mem_ops && ctlr->mem_ops->poll_status) { >> + ret = spi_mem_access_start(mem); >> + if (ret) >> + return ret; >> + >> + ret = ctlr->mem_ops->poll_status(mem, op, mask, match, >> + initial_delay_us, polling_delay_us, >> + timeout_ms); >> + >> + spi_mem_access_end(mem); >> + } >> + >> + if (ret == -EOPNOTSUPP) { >> + if (!spi_mem_supports_op(mem, op)) >> + return ret; >> + >> + if (initial_delay_us < 10) >> + udelay(initial_delay_us); >> + else >> + usleep_range((initial_delay_us >> 2) + 1, >> + initial_delay_us); >> + >> + ret = read_poll_timeout(spi_mem_read_status, read_status_ret, >> + (read_status_ret || ((status) & mask) == match), >> + polling_delay_us, timeout_ms * 1000, false, mem, >> + op, &status); >> + if (read_status_ret) >> + return read_status_ret; >> + } >> + >> + return ret; >> +}
From: Patrice Chotard <patrice.chotard@foss.st.com> This series adds support for the spi_mem_poll_status() spinand interface. Some QSPI controllers allows to poll automatically memory status during operations (erase, read or write). This allows to offload the CPU for this task. STM32 QSPI is supporting this feature, driver update are also part of this series. Chnages in v3: - Add spi_mem_read_status() which allows to read 8 or 16 bits status. - Add initial_delay_us and polling_delay_us parameters to spi_mem_poll_status(). and also to poll_status() callback. - Move spi_mem_supports_op() in SW-based polling case. - Add delay before invoquing read_poll_timeout(). - Remove the reinit/wait_for_completion() added in v2. - Add initial_delay_us and polling_delay_us parameters to spinand_wait(). - Add SPINAND_READ/WRITE/ERASE/RESET_INITIAL_DELAY_US and SPINAND_READ/WRITE/ERASE/RESET_POLL_DELAY_US defines. - Remove spi_mem_finalize_op() API added in v2. Changes in v2: - Indicates the spi_mem_poll_status() timeout unit - Use 2-byte wide status register - Add spi_mem_supports_op() call in spi_mem_poll_status() - Add completion management in spi_mem_poll_status() - Add offload/non-offload case management in spi_mem_poll_status() - Optimize the non-offload case by using read_poll_timeout() - mask and match stm32_qspi_poll_status()'s parameters are 2-byte wide - Make usage of new spi_mem_finalize_op() API in stm32_qspi_wait_poll_status() Patrice Chotard (3): spi: spi-mem: add automatic poll status functions mtd: spinand: use the spi-mem poll status APIs spi: stm32-qspi: add automatic poll status feature drivers/mtd/nand/spi/core.c | 45 +++++++++++++------ drivers/spi/spi-mem.c | 85 ++++++++++++++++++++++++++++++++++++ drivers/spi/spi-stm32-qspi.c | 83 +++++++++++++++++++++++++++++++---- include/linux/mtd/spinand.h | 11 ++++- include/linux/spi/spi-mem.h | 14 ++++++ 5 files changed, 216 insertions(+), 22 deletions(-)