Increase the malloc area size significantly to cater for bounce buffer used by the SDHI driver.

Signed-off-by: Marek Vasut marek.vasut+renesas@gmail.com Cc: Daniel Schwierzeck daniel.schwierzeck@gmail.com Cc: Masahiro Yamada yamada.masahiro@socionext.com Cc: Peng Fan peng.fan@nxp.com Cc: Simon Glass sjg@chromium.org Cc: Tom Rini trini@konsulko.com --- V2: No change --- include/configs/rcar-gen3-common.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/configs/rcar-gen3-common.h b/include/configs/rcar-gen3-common.h index 6528f1fa62..8f400ba05a 100644 --- a/include/configs/rcar-gen3-common.h +++ b/include/configs/rcar-gen3-common.h @@ -47,7 +47,7 @@

#define CONFIG_SYS_MONITOR_BASE 0x00000000 #define CONFIG_SYS_MONITOR_LEN (1 * 1024 * 1024) -#define CONFIG_SYS_MALLOC_LEN (1 * 1024 * 1024) +#define CONFIG_SYS_MALLOC_LEN (64 * 1024 * 1024) #define CONFIG_SYS_BOOTM_LEN (64 << 20)

/* The HF/QSPI layout permits up to 1 MiB large bootloader blob */

Add getter function which permits adjusting the maximum number of blocks that could be read in a single sustained read transfer based on the location of the source/target buffer and length, before such transfer starts.

This is mainly useful on systems which have various DMA restrictions for different memory locations, e.g. DMA limited to 32bit addresses, and where a bounce buffer is used to work around such restrictions. Since the U-Boot bounce buffer is mallocated, it's size is limited by the malloc area size, and the read transfer to such a buffer must also be limited. However, as not all areas are limited equally, the b_max should be adjusted accordinly as needed to avoid degrading performance unnecessarily.

Signed-off-by: Marek Vasut marek.vasut+renesas@gmail.com Cc: Daniel Schwierzeck daniel.schwierzeck@gmail.com Cc: Masahiro Yamada yamada.masahiro@socionext.com Cc: Peng Fan peng.fan@nxp.com Cc: Simon Glass sjg@chromium.org Cc: Tom Rini trini@konsulko.com --- V2: No change --- drivers/mmc/mmc-uclass.c | 16 ++++++++++++++++ drivers/mmc/mmc.c | 16 ++++++++++++++-- include/mmc.h | 16 ++++++++++++++++ 3 files changed, 46 insertions(+), 2 deletions(-)

diff --git a/drivers/mmc/mmc-uclass.c b/drivers/mmc/mmc-uclass.c index c75892a72c..cb26d841be 100644 --- a/drivers/mmc/mmc-uclass.c +++ b/drivers/mmc/mmc-uclass.c @@ -13,6 +13,22 @@ #include <linux/compat.h> #include "mmc_private.h"

+int dm_mmc_get_b_max(struct udevice *dev, void *dst, lbaint_t blkcnt) +{ + struct dm_mmc_ops *ops = mmc_get_ops(dev); + struct mmc *mmc = mmc_get_mmc_dev(dev); + + if (ops->get_b_max) + return ops->get_b_max(dev, dst, blkcnt); + else + return mmc->cfg->b_max; +} + +int mmc_get_b_max(struct mmc *mmc, void *dst, lbaint_t blkcnt) +{ + return dm_mmc_get_b_max(mmc->dev, dst, blkcnt); +} + int dm_mmc_send_cmd(struct udevice *dev, struct mmc_cmd *cmd, struct mmc_data *data) { diff --git a/drivers/mmc/mmc.c b/drivers/mmc/mmc.c index 3e36566693..e22834398f 100644 --- a/drivers/mmc/mmc.c +++ b/drivers/mmc/mmc.c @@ -409,6 +409,16 @@ static int mmc_read_blocks(struct mmc *mmc, void *dst, lbaint_t start, return blkcnt; }

+#if !CONFIG_IS_ENABLED(DM_MMC) +static int mmc_get_b_max(struct mmc *mmc, void *dst, lbaint_t blkcnt) +{ + if (mmc->cfg->ops->get_b_max) + return mmc->cfg->ops->get_b_max(mmc, dst, blkcnt); + else + return mmc->cfg->b_max; +} +#endif + #if CONFIG_IS_ENABLED(BLK) ulong mmc_bread(struct udevice *dev, lbaint_t start, lbaint_t blkcnt, void *dst) #else @@ -422,6 +432,7 @@ ulong mmc_bread(struct blk_desc *block_dev, lbaint_t start, lbaint_t blkcnt, int dev_num = block_dev->devnum; int err; lbaint_t cur, blocks_todo = blkcnt; + uint b_max;

if (blkcnt == 0) return 0; @@ -451,9 +462,10 @@ ulong mmc_bread(struct blk_desc *block_dev, lbaint_t start, lbaint_t blkcnt, return 0; }

+ b_max = mmc_get_b_max(mmc, dst, blkcnt); + do { - cur = (blocks_todo > mmc->cfg->b_max) ? - mmc->cfg->b_max : blocks_todo; + cur = (blocks_todo > b_max) ? b_max : blocks_todo; if (mmc_read_blocks(mmc, dst, start, cur) != cur) { pr_debug("%s: Failed to read blocks\n", __func__); return 0; diff --git a/include/mmc.h b/include/mmc.h index e83c22423b..a24e58b867 100644 --- a/include/mmc.h +++ b/include/mmc.h @@ -488,6 +488,19 @@ struct dm_mmc_ops { * @return 0 if not present, 1 if present, -ve on error */ int (*host_power_cycle)(struct udevice *dev); + + /** + * get_b_max - get maximum length of single transfer + * Called before reading blocks from the card, + * useful for system which have e.g. DMA limits + * on various memory ranges. + * + * @dev: Device to check + * @dst: Destination buffer in memory + * @blkcnt: Total number of blocks in this transfer + * @return maximum number of blocks for this transfer + */ + int (*get_b_max)(struct udevice *dev, void *dst, lbaint_t blkcnt); };

#define mmc_get_ops(dev) ((struct dm_mmc_ops *)(dev)->driver->ops) @@ -501,6 +514,7 @@ int dm_mmc_execute_tuning(struct udevice *dev, uint opcode); int dm_mmc_wait_dat0(struct udevice *dev, int state, int timeout_us); int dm_mmc_host_power_cycle(struct udevice *dev); int dm_mmc_deferred_probe(struct udevice *dev); +int dm_mmc_get_b_max(struct udevice *dev, void *dst, lbaint_t blkcnt);

/* Transition functions for compatibility */ int mmc_set_ios(struct mmc *mmc); @@ -511,6 +525,7 @@ int mmc_wait_dat0(struct mmc *mmc, int state, int timeout_us); int mmc_set_enhanced_strobe(struct mmc *mmc); int mmc_host_power_cycle(struct mmc *mmc); int mmc_deferred_probe(struct mmc *mmc); +int mmc_get_b_max(struct mmc *mmc, void *dst, lbaint_t blkcnt);

#else struct mmc_ops { @@ -521,6 +536,7 @@ struct mmc_ops { int (*getcd)(struct mmc *mmc); int (*getwp)(struct mmc *mmc); int (*host_power_cycle)(struct mmc *mmc); + int (*get_b_max)(struct mmc *mmc, void *dst, lbaint_t blkcnt); }; #endif

On 4/4/20 7:45 PM, Marek Vasut wrote:

Add extended version of the bounce_buffer_start(), which permits passing in a custom alignment checker function for the buffer. This is useful e.g. on systems with various DMA restrictions and where the checker function might be more complex than a simple CPU cache alignment check.

Signed-off-by: Marek Vasut marek.vasut+renesas@gmail.com Cc: Daniel Schwierzeck daniel.schwierzeck@gmail.com Cc: Masahiro Yamada yamada.masahiro@socionext.com Cc: Peng Fan peng.fan@nxp.com Cc: Simon Glass sjg@chromium.org Cc: Tom Rini trini@konsulko.com

---

V2: No change

common/bouncebuf.c | 20 +++++++++++++++----- include/bouncebuf.h | 15 +++++++++++++++ 2 files changed, 30 insertions(+), 5 deletions(-)

diff --git a/common/bouncebuf.c b/common/bouncebuf.c index 614eb36c78..0ace152b98 100644 --- a/common/bouncebuf.c +++ b/common/bouncebuf.c @@ -31,17 +31,19 @@ static int addr_aligned(struct bounce_buffer *state) return 1; }

-int bounce_buffer_start(struct bounce_buffer *state, void *data,

• 	size_t len, unsigned int flags)
  

+int bounce_buffer_start_extalign(struct bounce_buffer *state, void *data,

• 		 size_t len, unsigned int flags,
  

• 		 size_t alignment,
  

• 		 int (*addr_is_aligned)(struct bounce_buffer *state))
  

{ state->user_buffer = data; state->bounce_buffer = data; state->len = len;

• state->len_aligned = roundup(len, ARCH_DMA_MINALIGN);

• state->len_aligned = roundup(len, alignment); state->flags = flags;

• if (!addr_aligned(state)) {

• state->bounce_buffer = memalign(ARCH_DMA_MINALIGN,
  

• if (!addr_is_aligned(state)) {

how about checking condition whether addr_is_aligned function is present or not at here?

Best Regards, Jaehoon Chung

• state->bounce_buffer = memalign(alignment,
  			state->len_aligned);
  

  if (!state->bounce_buffer) return -ENOMEM;

@@ -62,6 +64,14 @@ int bounce_buffer_start(struct bounce_buffer *state, void *data, return 0; }

+int bounce_buffer_start(struct bounce_buffer *state, void *data,

• 	size_t len, unsigned int flags)
  

+{

• return bounce_buffer_start_extalign(state, data, len, flags,

• 			    ARCH_DMA_MINALIGN,
  

• 			    addr_aligned);
  

+}

int bounce_buffer_stop(struct bounce_buffer *state) { if (state->flags & GEN_BB_WRITE) { diff --git a/include/bouncebuf.h b/include/bouncebuf.h index fd9b0f3b28..7427bd12e2 100644 --- a/include/bouncebuf.h +++ b/include/bouncebuf.h @@ -62,6 +62,21 @@ struct bounce_buffer { */ int bounce_buffer_start(struct bounce_buffer *state, void *data, size_t len, unsigned int flags);

+/**

• • bounce_buffer_start() -- Start the bounce buffer session with external align check function
• • state: stores state passed between bounce_buffer_{start,stop}
• • data: pointer to buffer to be aligned
• • len: length of the buffer
• • flags: flags describing the transaction, see above.
• • alignment: alignment of the newly allocated bounce buffer
• • addr_is_aligned: function for checking the alignment instead of the default one
• */

+int bounce_buffer_start_extalign(struct bounce_buffer *state, void *data,

• 		 size_t len, unsigned int flags,
  

• 		 size_t alignment,
  

• 		 int (*addr_is_aligned)(struct bounce_buffer *state));
  

/**

• bounce_buffer_stop() -- Finish the bounce buffer session
• state: stores state passed between bounce_buffer_{start,stop}