[U-Boot] [PATCH 0/5] mmc: uniphier: migrate to CONFIG_DM_MMC_OPS and CONFIG_BLK

[U-Boot] [PATCH 0/5] mmc: uniphier: migrate to CONFIG_DM_MMC_OPS and CONFIG_BLK

[Masahiro Yamada]

Masahiro Yamada (5):
  mmc: uniphier-sd: migrate to CONFIG_DM_MMC_OPS
  mmc: uniphier-sd: move uniphier_sd_init() below
  mmc: uniphier-sd: return error code if unsupported width is given
  mmc: uniphier-sd: just return if already set to desired clock rate
  mmc: uniphier-sd: migrate to CONFIG_BLK

 arch/arm/Kconfig          |   1 +
 drivers/mmc/Kconfig       |   2 +
 drivers/mmc/uniphier-sd.c | 186 ++++++++++++++++++++++++----------------------
 3 files changed, 99 insertions(+), 90 deletions(-)

-- 
1.9.1

[U-Boot] [PATCH 1/5] mmc: uniphier-sd: migrate to CONFIG_DM_MMC_OPS

[Masahiro Yamada]

Catch up with the DM migration.

As struct dm_mmc_ops does not have .init callback, call the init
function directly from the probe function.

Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
---

 drivers/mmc/Kconfig       |  1 +
 drivers/mmc/uniphier-sd.c | 97 ++++++++++++++++++++++++-----------------------
 2 files changed, 51 insertions(+), 47 deletions(-)

diff --git a/drivers/mmc/Kconfig b/drivers/mmc/Kconfig
index b820485..4cdd9b1 100644
--- a/drivers/mmc/Kconfig
+++ b/drivers/mmc/Kconfig
@@ -80,6 +80,7 @@ config ROCKCHIP_SDHCI
 config MMC_UNIPHIER
 	bool "UniPhier SD/MMC Host Controller support"
 	depends on ARCH_UNIPHIER
+	select DM_MMC_OPS
 	help
 	  This selects support for the SD/MMC Host Controller on UniPhier SoCs.
 
diff --git a/drivers/mmc/uniphier-sd.c b/drivers/mmc/uniphier-sd.c
index f06e737..b8e784f 100644
--- a/drivers/mmc/uniphier-sd.c
+++ b/drivers/mmc/uniphier-sd.c
@@ -122,7 +122,6 @@ DECLARE_GLOBAL_DATA_PTR;
 struct uniphier_sd_priv {
 	struct mmc_config cfg;
 	struct mmc *mmc;
-	struct udevice *dev;
 	void __iomem *regbase;
 	unsigned long mclk;
 	unsigned int version;
@@ -152,8 +151,9 @@ static void __dma_unmap_single(dma_addr_t addr, size_t size,
 		invalidate_dcache_range(addr, addr + size);
 }
 
-static int uniphier_sd_check_error(struct uniphier_sd_priv *priv)
+static int uniphier_sd_check_error(struct udevice *dev)
 {
+	struct uniphier_sd_priv *priv = dev_get_priv(dev);
 	u32 info2 = readl(priv->regbase + UNIPHIER_SD_INFO2);
 
 	if (info2 & UNIPHIER_SD_INFO2_ERR_RTO) {
@@ -166,38 +166,39 @@ static int uniphier_sd_check_error(struct uniphier_sd_priv *priv)
 	}
 
 	if (info2 & UNIPHIER_SD_INFO2_ERR_TO) {
-		dev_err(priv->dev, "timeout error\n");
+		dev_err(dev, "timeout error\n");
 		return -ETIMEDOUT;
 	}
 
 	if (info2 & (UNIPHIER_SD_INFO2_ERR_END | UNIPHIER_SD_INFO2_ERR_CRC |
 		     UNIPHIER_SD_INFO2_ERR_IDX)) {
-		dev_err(priv->dev, "communication out of sync\n");
+		dev_err(dev, "communication out of sync\n");
 		return -EILSEQ;
 	}
 
 	if (info2 & (UNIPHIER_SD_INFO2_ERR_ILA | UNIPHIER_SD_INFO2_ERR_ILR |
 		     UNIPHIER_SD_INFO2_ERR_ILW)) {
-		dev_err(priv->dev, "illegal access\n");
+		dev_err(dev, "illegal access\n");
 		return -EIO;
 	}
 
 	return 0;
 }
 
-static int uniphier_sd_wait_for_irq(struct uniphier_sd_priv *priv,
-				    unsigned int reg, u32 flag)
+static int uniphier_sd_wait_for_irq(struct udevice *dev, unsigned int reg,
+				    u32 flag)
 {
+	struct uniphier_sd_priv *priv = dev_get_priv(dev);
 	long wait = 1000000;
 	int ret;
 
 	while (!(readl(priv->regbase + reg) & flag)) {
 		if (wait-- < 0) {
-			dev_err(priv->dev, "timeout\n");
+			dev_err(dev, "timeout\n");
 			return -ETIMEDOUT;
 		}
 
-		ret = uniphier_sd_check_error(priv);
+		ret = uniphier_sd_check_error(dev);
 		if (ret)
 			return ret;
 
@@ -207,14 +208,14 @@ static int uniphier_sd_wait_for_irq(struct uniphier_sd_priv *priv,
 	return 0;
 }
 
-static int uniphier_sd_pio_read_one_block(struct mmc *mmc, u32 **pbuf,
+static int uniphier_sd_pio_read_one_block(struct udevice *dev, u32 **pbuf,
 					  uint blocksize)
 {
-	struct uniphier_sd_priv *priv = mmc->priv;
+	struct uniphier_sd_priv *priv = dev_get_priv(dev);
 	int i, ret;
 
 	/* wait until the buffer is filled with data */
-	ret = uniphier_sd_wait_for_irq(priv, UNIPHIER_SD_INFO2,
+	ret = uniphier_sd_wait_for_irq(dev, UNIPHIER_SD_INFO2,
 				       UNIPHIER_SD_INFO2_BRE);
 	if (ret)
 		return ret;
@@ -237,14 +238,14 @@ static int uniphier_sd_pio_read_one_block(struct mmc *mmc, u32 **pbuf,
 	return 0;
 }
 
-static int uniphier_sd_pio_write_one_block(struct mmc *mmc, const u32 **pbuf,
-					   uint blocksize)
+static int uniphier_sd_pio_write_one_block(struct udevice *dev,
+					   const u32 **pbuf, uint blocksize)
 {
-	struct uniphier_sd_priv *priv = mmc->priv;
+	struct uniphier_sd_priv *priv = dev_get_priv(dev);
 	int i, ret;
 
 	/* wait until the buffer becomes empty */
-	ret = uniphier_sd_wait_for_irq(priv, UNIPHIER_SD_INFO2,
+	ret = uniphier_sd_wait_for_irq(dev, UNIPHIER_SD_INFO2,
 				       UNIPHIER_SD_INFO2_BWE);
 	if (ret)
 		return ret;
@@ -263,7 +264,7 @@ static int uniphier_sd_pio_write_one_block(struct mmc *mmc, const u32 **pbuf,
 	return 0;
 }
 
-static int uniphier_sd_pio_xfer(struct mmc *mmc, struct mmc_data *data)
+static int uniphier_sd_pio_xfer(struct udevice *dev, struct mmc_data *data)
 {
 	u32 *dest = (u32 *)data->dest;
 	const u32 *src = (const u32 *)data->src;
@@ -271,10 +272,10 @@ static int uniphier_sd_pio_xfer(struct mmc *mmc, struct mmc_data *data)
 
 	for (i = 0; i < data->blocks; i++) {
 		if (data->flags & MMC_DATA_READ)
-			ret = uniphier_sd_pio_read_one_block(mmc, &dest,
+			ret = uniphier_sd_pio_read_one_block(dev, &dest,
 							     data->blocksize);
 		else
-			ret = uniphier_sd_pio_write_one_block(mmc, &src,
+			ret = uniphier_sd_pio_write_one_block(dev, &src,
 							      data->blocksize);
 		if (ret)
 			return ret;
@@ -306,14 +307,15 @@ static void uniphier_sd_dma_start(struct uniphier_sd_priv *priv,
 	writel(UNIPHIER_SD_DMA_CTL_START, priv->regbase + UNIPHIER_SD_DMA_CTL);
 }
 
-static int uniphier_sd_dma_wait_for_irq(struct uniphier_sd_priv *priv, u32 flag,
+static int uniphier_sd_dma_wait_for_irq(struct udevice *dev, u32 flag,
 					unsigned int blocks)
 {
+	struct uniphier_sd_priv *priv = dev_get_priv(dev);
 	long wait = 1000000 + 10 * blocks;
 
 	while (!(readl(priv->regbase + UNIPHIER_SD_DMA_INFO1) & flag)) {
 		if (wait-- < 0) {
-			dev_err(priv->dev, "timeout during DMA\n");
+			dev_err(dev, "timeout during DMA\n");
 			return -ETIMEDOUT;
 		}
 
@@ -321,16 +323,16 @@ static int uniphier_sd_dma_wait_for_irq(struct uniphier_sd_priv *priv, u32 flag,
 	}
 
 	if (readl(priv->regbase + UNIPHIER_SD_DMA_INFO2)) {
-		dev_err(priv->dev, "error during DMA\n");
+		dev_err(dev, "error during DMA\n");
 		return -EIO;
 	}
 
 	return 0;
 }
 
-static int uniphier_sd_dma_xfer(struct mmc *mmc, struct mmc_data *data)
+static int uniphier_sd_dma_xfer(struct udevice *dev, struct mmc_data *data)
 {
-	struct uniphier_sd_priv *priv = mmc->priv;
+	struct uniphier_sd_priv *priv = dev_get_priv(dev);
 	size_t len = data->blocks * data->blocksize;
 	void *buf;
 	enum dma_data_direction dir;
@@ -358,7 +360,7 @@ static int uniphier_sd_dma_xfer(struct mmc *mmc, struct mmc_data *data)
 
 	uniphier_sd_dma_start(priv, dma_addr);
 
-	ret = uniphier_sd_dma_wait_for_irq(priv, poll_flag, data->blocks);
+	ret = uniphier_sd_dma_wait_for_irq(dev, poll_flag, data->blocks);
 
 	__dma_unmap_single(dma_addr, len, dir);
 
@@ -384,15 +386,15 @@ static bool uniphier_sd_addr_is_dmaable(unsigned long addr)
 	return true;
 }
 
-static int uniphier_sd_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd,
+static int uniphier_sd_send_cmd(struct udevice *dev, struct mmc_cmd *cmd,
 				struct mmc_data *data)
 {
-	struct uniphier_sd_priv *priv = mmc->priv;
+	struct uniphier_sd_priv *priv = dev_get_priv(dev);
 	int ret;
 	u32 tmp;
 
 	if (readl(priv->regbase + UNIPHIER_SD_INFO2) & UNIPHIER_SD_INFO2_CBSY) {
-		dev_err(priv->dev, "command busy\n");
+		dev_err(dev, "command busy\n");
 		return -EBUSY;
 	}
 
@@ -446,15 +448,15 @@ static int uniphier_sd_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd,
 		tmp |= UNIPHIER_SD_CMD_RSP_R3;
 		break;
 	default:
-		dev_err(priv->dev, "unknown response type\n");
+		dev_err(dev, "unknown response type\n");
 		return -EINVAL;
 	}
 
-	dev_dbg(priv->dev, "sending CMD%d (SD_CMD=%08x, SD_ARG=%08x)\n",
+	dev_dbg(dev, "sending CMD%d (SD_CMD=%08x, SD_ARG=%08x)\n",
 		cmd->cmdidx, tmp, cmd->cmdarg);
 	writel(tmp, priv->regbase + UNIPHIER_SD_CMD);
 
-	ret = uniphier_sd_wait_for_irq(priv, UNIPHIER_SD_INFO1,
+	ret = uniphier_sd_wait_for_irq(dev, UNIPHIER_SD_INFO1,
 				       UNIPHIER_SD_INFO1_RSP);
 	if (ret)
 		return ret;
@@ -481,11 +483,11 @@ static int uniphier_sd_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd,
 		/* use DMA if the HW supports it and the buffer is aligned */
 		if (priv->caps & UNIPHIER_SD_CAP_DMA_INTERNAL &&
 		    uniphier_sd_addr_is_dmaable((long)data->src))
-			ret = uniphier_sd_dma_xfer(mmc, data);
+			ret = uniphier_sd_dma_xfer(dev, data);
 		else
-			ret = uniphier_sd_pio_xfer(mmc, data);
+			ret = uniphier_sd_pio_xfer(dev, data);
 
-		ret = uniphier_sd_wait_for_irq(priv, UNIPHIER_SD_INFO1,
+		ret = uniphier_sd_wait_for_irq(dev, UNIPHIER_SD_INFO1,
 					       UNIPHIER_SD_INFO1_CMP);
 		if (ret)
 			return ret;
@@ -581,11 +583,12 @@ static void uniphier_sd_set_clk_rate(struct uniphier_sd_priv *priv,
 	writel(tmp, priv->regbase + UNIPHIER_SD_CLKCTL);
 }
 
-static void uniphier_sd_set_ios(struct mmc *mmc)
+static int uniphier_sd_set_ios(struct udevice *dev)
 {
-	struct uniphier_sd_priv *priv = mmc->priv;
+	struct uniphier_sd_priv *priv = dev_get_priv(dev);
+	struct mmc *mmc = mmc_get_mmc_dev(dev);
 
-	dev_dbg(priv->dev, "clock %uHz, DDRmode %d, width %u\n",
+	dev_dbg(dev, "clock %uHz, DDRmode %d, width %u\n",
 		mmc->clock, mmc->ddr_mode, mmc->bus_width);
 
 	uniphier_sd_set_bus_width(priv, mmc);
@@ -593,11 +596,12 @@ static void uniphier_sd_set_ios(struct mmc *mmc)
 	uniphier_sd_set_clk_rate(priv, mmc);
 
 	udelay(1000);
+
+	return 0;
 }
 
-static int uniphier_sd_init(struct mmc *mmc)
+static int uniphier_sd_init(struct uniphier_sd_priv *priv)
 {
-	struct uniphier_sd_priv *priv = mmc->priv;
 	u32 tmp;
 
 	/* soft reset of the host */
@@ -628,9 +632,9 @@ static int uniphier_sd_init(struct mmc *mmc)
 	return 0;
 }
 
-static int uniphier_sd_getcd(struct mmc *mmc)
+static int uniphier_sd_get_cd(struct udevice *dev)
 {
-	struct uniphier_sd_priv *priv = mmc->priv;
+	struct uniphier_sd_priv *priv = dev_get_priv(dev);
 
 	if (priv->caps & UNIPHIER_SD_CAP_NONREMOVABLE)
 		return 1;
@@ -639,11 +643,10 @@ static int uniphier_sd_getcd(struct mmc *mmc)
 		  UNIPHIER_SD_INFO1_CD);
 }
 
-static const struct mmc_ops uniphier_sd_ops = {
+static const struct dm_mmc_ops uniphier_sd_ops = {
 	.send_cmd = uniphier_sd_send_cmd,
 	.set_ios = uniphier_sd_set_ios,
-	.init = uniphier_sd_init,
-	.getcd = uniphier_sd_getcd,
+	.get_cd = uniphier_sd_get_cd,
 };
 
 static int uniphier_sd_probe(struct udevice *dev)
@@ -654,8 +657,6 @@ static int uniphier_sd_probe(struct udevice *dev)
 	struct clk clk;
 	int ret;
 
-	priv->dev = dev;
-
 	base = dev_get_addr(dev);
 	if (base == FDT_ADDR_T_NONE)
 		return -EINVAL;
@@ -686,7 +687,6 @@ static int uniphier_sd_probe(struct udevice *dev)
 	}
 
 	priv->cfg.name = dev->name;
-	priv->cfg.ops = &uniphier_sd_ops;
 	priv->cfg.host_caps = MMC_MODE_HS_52MHz | MMC_MODE_HS;
 
 	switch (fdtdec_get_int(gd->fdt_blob, dev->of_offset, "bus-width", 1)) {
@@ -715,6 +715,8 @@ static int uniphier_sd_probe(struct udevice *dev)
 		priv->caps |= UNIPHIER_SD_CAP_DIV1024;
 	}
 
+	uniphier_sd_init(priv);
+
 	priv->cfg.voltages = MMC_VDD_165_195 | MMC_VDD_32_33 | MMC_VDD_33_34;
 	priv->cfg.f_min = priv->mclk /
 			(priv->caps & UNIPHIER_SD_CAP_DIV1024 ? 1024 : 512);
@@ -752,4 +754,5 @@ U_BOOT_DRIVER(uniphier_mmc) = {
 	.probe = uniphier_sd_probe,
 	.remove = uniphier_sd_remove,
 	.priv_auto_alloc_size = sizeof(struct uniphier_sd_priv),
+	.ops = &uniphier_sd_ops,
 };
-- 
1.9.1

[U-Boot] [PATCH 2/5] mmc: uniphier-sd: move uniphier_sd_init() below

[Masahiro Yamada]

No more reason to define this function above the ops structure.
Move it near the caller.  Also, change its return type to void
because it never fails.

Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
---

 drivers/mmc/uniphier-sd.c | 40 +++++++++++++++++++---------------------
 1 file changed, 19 insertions(+), 21 deletions(-)

diff --git a/drivers/mmc/uniphier-sd.c b/drivers/mmc/uniphier-sd.c
index b8e784f..b254c70 100644
--- a/drivers/mmc/uniphier-sd.c
+++ b/drivers/mmc/uniphier-sd.c
@@ -600,7 +600,24 @@ static int uniphier_sd_set_ios(struct udevice *dev)
 	return 0;
 }
 
-static int uniphier_sd_init(struct uniphier_sd_priv *priv)
+static int uniphier_sd_get_cd(struct udevice *dev)
+{
+	struct uniphier_sd_priv *priv = dev_get_priv(dev);
+
+	if (priv->caps & UNIPHIER_SD_CAP_NONREMOVABLE)
+		return 1;
+
+	return !!(readl(priv->regbase + UNIPHIER_SD_INFO1) &
+		  UNIPHIER_SD_INFO1_CD);
+}
+
+static const struct dm_mmc_ops uniphier_sd_ops = {
+	.send_cmd = uniphier_sd_send_cmd,
+	.set_ios = uniphier_sd_set_ios,
+	.get_cd = uniphier_sd_get_cd,
+};
+
+static void uniphier_sd_host_init(struct uniphier_sd_priv *priv)
 {
 	u32 tmp;
 
@@ -628,27 +645,8 @@ static int uniphier_sd_init(struct uniphier_sd_priv *priv)
 		tmp |= UNIPHIER_SD_DMA_MODE_ADDR_INC;
 		writel(tmp, priv->regbase + UNIPHIER_SD_DMA_MODE);
 	}
-
-	return 0;
-}
-
-static int uniphier_sd_get_cd(struct udevice *dev)
-{
-	struct uniphier_sd_priv *priv = dev_get_priv(dev);
-
-	if (priv->caps & UNIPHIER_SD_CAP_NONREMOVABLE)
-		return 1;
-
-	return !!(readl(priv->regbase + UNIPHIER_SD_INFO1) &
-		  UNIPHIER_SD_INFO1_CD);
 }
 
-static const struct dm_mmc_ops uniphier_sd_ops = {
-	.send_cmd = uniphier_sd_send_cmd,
-	.set_ios = uniphier_sd_set_ios,
-	.get_cd = uniphier_sd_get_cd,
-};
-
 static int uniphier_sd_probe(struct udevice *dev)
 {
 	struct uniphier_sd_priv *priv = dev_get_priv(dev);
@@ -715,7 +713,7 @@ static int uniphier_sd_probe(struct udevice *dev)
 		priv->caps |= UNIPHIER_SD_CAP_DIV1024;
 	}
 
-	uniphier_sd_init(priv);
+	uniphier_sd_host_init(priv);
 
 	priv->cfg.voltages = MMC_VDD_165_195 | MMC_VDD_32_33 | MMC_VDD_33_34;
 	priv->cfg.f_min = priv->mclk /
-- 
1.9.1

[U-Boot] [PATCH 3/5] mmc: uniphier-sd: return error code if unsupported width is given

[Masahiro Yamada]

With the CONFIG_DM_MMC_OPS migration, the .set_ios callback can
return an integer now.  Return an appropriate error value rather
than sudden death by BUG().

Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
---

 drivers/mmc/uniphier-sd.c | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/drivers/mmc/uniphier-sd.c b/drivers/mmc/uniphier-sd.c
index b254c70..40a5c85 100644
--- a/drivers/mmc/uniphier-sd.c
+++ b/drivers/mmc/uniphier-sd.c
@@ -496,8 +496,8 @@ static int uniphier_sd_send_cmd(struct udevice *dev, struct mmc_cmd *cmd,
 	return ret;
 }
 
-static void uniphier_sd_set_bus_width(struct uniphier_sd_priv *priv,
-				      struct mmc *mmc)
+static int uniphier_sd_set_bus_width(struct uniphier_sd_priv *priv,
+				     struct mmc *mmc)
 {
 	u32 val, tmp;
 
@@ -512,14 +512,15 @@ static void uniphier_sd_set_bus_width(struct uniphier_sd_priv *priv,
 		val = UNIPHIER_SD_OPTION_WIDTH_8;
 		break;
 	default:
-		BUG();
-		break;
+		return -EINVAL;
 	}
 
 	tmp = readl(priv->regbase + UNIPHIER_SD_OPTION);
 	tmp &= ~UNIPHIER_SD_OPTION_WIDTH_MASK;
 	tmp |= val;
 	writel(tmp, priv->regbase + UNIPHIER_SD_OPTION);
+
+	return 0;
 }
 
 static void uniphier_sd_set_ddr_mode(struct uniphier_sd_priv *priv,
@@ -587,11 +588,14 @@ static int uniphier_sd_set_ios(struct udevice *dev)
 {
 	struct uniphier_sd_priv *priv = dev_get_priv(dev);
 	struct mmc *mmc = mmc_get_mmc_dev(dev);
+	int ret;
 
 	dev_dbg(dev, "clock %uHz, DDRmode %d, width %u\n",
 		mmc->clock, mmc->ddr_mode, mmc->bus_width);
 
-	uniphier_sd_set_bus_width(priv, mmc);
+	ret = uniphier_sd_set_bus_width(priv, mmc);
+	if (ret)
+		return ret;
 	uniphier_sd_set_ddr_mode(priv, mmc);
 	uniphier_sd_set_clk_rate(priv, mmc);
 
-- 
1.9.1

[U-Boot] [PATCH 4/5] mmc: uniphier-sd: just return if already set to desired clock rate

[Masahiro Yamada]

With this, we can save unnecessary udelay().

Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
---

 drivers/mmc/uniphier-sd.c | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/drivers/mmc/uniphier-sd.c b/drivers/mmc/uniphier-sd.c
index 40a5c85..701b26f 100644
--- a/drivers/mmc/uniphier-sd.c
+++ b/drivers/mmc/uniphier-sd.c
@@ -571,6 +571,9 @@ static void uniphier_sd_set_clk_rate(struct uniphier_sd_priv *priv,
 		val = UNIPHIER_SD_CLKCTL_DIV1024;
 
 	tmp = readl(priv->regbase + UNIPHIER_SD_CLKCTL);
+	if (tmp & UNIPHIER_SD_CLKCTL_SCLKEN &&
+	    (tmp & UNIPHIER_SD_CLKCTL_DIV_MASK) == val)
+		return;
 
 	/* stop the clock before changing its rate to avoid a glitch signal */
 	tmp &= ~UNIPHIER_SD_CLKCTL_SCLKEN;
@@ -582,6 +585,8 @@ static void uniphier_sd_set_clk_rate(struct uniphier_sd_priv *priv,
 
 	tmp |= UNIPHIER_SD_CLKCTL_SCLKEN;
 	writel(tmp, priv->regbase + UNIPHIER_SD_CLKCTL);
+
+	udelay(1000);
 }
 
 static int uniphier_sd_set_ios(struct udevice *dev)
@@ -599,8 +604,6 @@ static int uniphier_sd_set_ios(struct udevice *dev)
 	uniphier_sd_set_ddr_mode(priv, mmc);
 	uniphier_sd_set_clk_rate(priv, mmc);
 
-	udelay(1000);
-
 	return 0;
 }
 
-- 
1.9.1

[U-Boot] [PATCH 5/5] mmc: uniphier-sd: migrate to CONFIG_BLK

[Masahiro Yamada]

This is the state-of-the-art MMC driver implementation.

Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
---

 arch/arm/Kconfig          |  1 +
 drivers/mmc/Kconfig       |  1 +
 drivers/mmc/uniphier-sd.c | 50 +++++++++++++++++++++++------------------------
 3 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig
index 61b86ce..1ebd968 100644
--- a/arch/arm/Kconfig
+++ b/arch/arm/Kconfig
@@ -825,6 +825,7 @@ config TARGET_COLIBRI_PXA270
 
 config ARCH_UNIPHIER
 	bool "Socionext UniPhier SoCs"
+	select BLK
 	select CLK_UNIPHIER
 	select SUPPORT_SPL
 	select SPL
diff --git a/drivers/mmc/Kconfig b/drivers/mmc/Kconfig
index 4cdd9b1..068845a 100644
--- a/drivers/mmc/Kconfig
+++ b/drivers/mmc/Kconfig
@@ -80,6 +80,7 @@ config ROCKCHIP_SDHCI
 config MMC_UNIPHIER
 	bool "UniPhier SD/MMC Host Controller support"
 	depends on ARCH_UNIPHIER
+	depends on BLK
 	select DM_MMC_OPS
 	help
 	  This selects support for the SD/MMC Host Controller on UniPhier SoCs.
diff --git a/drivers/mmc/uniphier-sd.c b/drivers/mmc/uniphier-sd.c
index 701b26f..4af7fdb 100644
--- a/drivers/mmc/uniphier-sd.c
+++ b/drivers/mmc/uniphier-sd.c
@@ -119,9 +119,12 @@ DECLARE_GLOBAL_DATA_PTR;
 /* alignment required by the DMA engine of this controller */
 #define UNIPHIER_SD_DMA_MINALIGN	0x10
 
-struct uniphier_sd_priv {
+struct uniphier_sd_plat {
 	struct mmc_config cfg;
-	struct mmc *mmc;
+	struct mmc mmc;
+};
+
+struct uniphier_sd_priv {
 	void __iomem *regbase;
 	unsigned long mclk;
 	unsigned int version;
@@ -654,8 +657,16 @@ static void uniphier_sd_host_init(struct uniphier_sd_priv *priv)
 	}
 }
 
+static int uniphier_sd_bind(struct udevice *dev)
+{
+	struct uniphier_sd_plat *plat = dev_get_platdata(dev);
+
+	return mmc_bind(dev, &plat->mmc, &plat->cfg);
+}
+
 static int uniphier_sd_probe(struct udevice *dev)
 {
+	struct uniphier_sd_plat *plat = dev_get_platdata(dev);
 	struct uniphier_sd_priv *priv = dev_get_priv(dev);
 	struct mmc_uclass_priv *upriv = dev_get_uclass_priv(dev);
 	fdt_addr_t base;
@@ -691,15 +702,15 @@ static int uniphier_sd_probe(struct udevice *dev)
 		return ret;
 	}
 
-	priv->cfg.name = dev->name;
-	priv->cfg.host_caps = MMC_MODE_HS_52MHz | MMC_MODE_HS;
+	plat->cfg.name = dev->name;
+	plat->cfg.host_caps = MMC_MODE_HS_52MHz | MMC_MODE_HS;
 
 	switch (fdtdec_get_int(gd->fdt_blob, dev->of_offset, "bus-width", 1)) {
 	case 8:
-		priv->cfg.host_caps |= MMC_MODE_8BIT;
+		plat->cfg.host_caps |= MMC_MODE_8BIT;
 		break;
 	case 4:
-		priv->cfg.host_caps |= MMC_MODE_4BIT;
+		plat->cfg.host_caps |= MMC_MODE_4BIT;
 		break;
 	case 1:
 		break;
@@ -722,27 +733,13 @@ static int uniphier_sd_probe(struct udevice *dev)
 
 	uniphier_sd_host_init(priv);
 
-	priv->cfg.voltages = MMC_VDD_165_195 | MMC_VDD_32_33 | MMC_VDD_33_34;
-	priv->cfg.f_min = priv->mclk /
+	plat->cfg.voltages = MMC_VDD_165_195 | MMC_VDD_32_33 | MMC_VDD_33_34;
+	plat->cfg.f_min = priv->mclk /
 			(priv->caps & UNIPHIER_SD_CAP_DIV1024 ? 1024 : 512);
-	priv->cfg.f_max = priv->mclk;
-	priv->cfg.b_max = U32_MAX; /* max value of UNIPHIER_SD_SECCNT */
-
-	priv->mmc = mmc_create(&priv->cfg, priv);
-	if (!priv->mmc)
-		return -EIO;
-
-	upriv->mmc = priv->mmc;
-	priv->mmc->dev = dev;
-
-	return 0;
-}
-
-static int uniphier_sd_remove(struct udevice *dev)
-{
-	struct uniphier_sd_priv *priv = dev_get_priv(dev);
+	plat->cfg.f_max = priv->mclk;
+	plat->cfg.b_max = U32_MAX; /* max value of UNIPHIER_SD_SECCNT */
 
-	mmc_destroy(priv->mmc);
+	upriv->mmc = &plat->mmc;
 
 	return 0;
 }
@@ -756,8 +753,9 @@ U_BOOT_DRIVER(uniphier_mmc) = {
 	.name = "uniphier-mmc",
 	.id = UCLASS_MMC,
 	.of_match = uniphier_sd_match,
+	.bind = uniphier_sd_bind,
 	.probe = uniphier_sd_probe,
-	.remove = uniphier_sd_remove,
 	.priv_auto_alloc_size = sizeof(struct uniphier_sd_priv),
+	.platdata_auto_alloc_size = sizeof(struct uniphier_sd_plat),
 	.ops = &uniphier_sd_ops,
 };
-- 
1.9.1

[U-Boot] [PATCH 0/5] mmc: uniphier: migrate to CONFIG_DM_MMC_OPS and CONFIG_BLK

[Masahiro Yamada]

2016-08-25 14:52 GMT+09:00 Masahiro Yamada <yamada.masahiro@socionext.com>:
>
>
>
> Masahiro Yamada (5):
>   mmc: uniphier-sd: migrate to CONFIG_DM_MMC_OPS
>   mmc: uniphier-sd: move uniphier_sd_init() below
>   mmc: uniphier-sd: return error code if unsupported width is given
>   mmc: uniphier-sd: just return if already set to desired clock rate
>   mmc: uniphier-sd: migrate to CONFIG_BLK
>


Series except 05, Applied to u-boot-uniphier/master.
05 has been deferred until USB is converted to CONFIG_BLK.

-- 
Best Regards
Masahiro Yamada

[U-Boot] [PATCH 1/5] mmc: uniphier-sd: migrate to CONFIG_DM_MMC_OPS

[Simon Glass]

On 24 August 2016 at 23:52, Masahiro Yamada
<yamada.masahiro@socionext.com> wrote:
> Catch up with the DM migration.
>
> As struct dm_mmc_ops does not have .init callback, call the init
> function directly from the probe function.
>
> Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
> ---
>
>  drivers/mmc/Kconfig       |  1 +
>  drivers/mmc/uniphier-sd.c | 97 ++++++++++++++++++++++++-----------------------
>  2 files changed, 51 insertions(+), 47 deletions(-)

Reviewed-by: Simon Glass <sjg@chromium.org>

[U-Boot] [PATCH 5/5] mmc: uniphier-sd: migrate to CONFIG_BLK

[Simon Glass]

On 24 August 2016 at 23:52, Masahiro Yamada
<yamada.masahiro@socionext.com> wrote:
> This is the state-of-the-art MMC driver implementation.
>
> Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
> ---
>
>  arch/arm/Kconfig          |  1 +
>  drivers/mmc/Kconfig       |  1 +
>  drivers/mmc/uniphier-sd.c | 50 +++++++++++++++++++++++------------------------
>  3 files changed, 26 insertions(+), 26 deletions(-)

Reviewed-by: Simon Glass <sjg@chromium.org>