ni-buildsystem/package/kernel/patches/vuplus/3_14_fix_mmc_3.14.28-1.10.patch

diff -u -N -r stblinux-3.14-1.8/drivers/clk/clk.c stblinux-3.14-1.10-git/drivers/clk/clk.c
--- stblinux-3.14-1.8/drivers/clk/clk.c	2015-07-28 23:57:38.000000000 +0000
+++ stblinux-3.14-1.10-git/drivers/clk/clk.c	2019-02-10 22:05:52.950336124 +0000
@@ -929,6 +929,9 @@
 	if (clk->prepare_count == 0) {
 		if (clk->flags & CLK_IS_SW)
 			for (i = 0; i < clk->num_parents; i++) {
+				if (!clk->parents[i])
+					clk->parents[i] =
+						__clk_lookup(clk->parent_names[i]);
 				ret = __clk_prepare(clk->parents[i]);
 				if (ret) {
 					for (j = i - 1; j >= 0; j--)
@@ -1042,6 +1045,9 @@
 	if (clk->enable_count == 0) {
 		if (clk->flags & CLK_IS_SW)
 			for (i = 0; i < clk->num_parents && !ret; i++) {
+				if (!clk->parents[i])
+					clk->parents[i] =
+						__clk_lookup(clk->parent_names[i]);
 				ret = __clk_enable(clk->parents[i]);
 				if (ret) {
 					for (j = i - 1; j >= 0; j--)
diff -u -N -r stblinux-3.14-1.8/drivers/mmc/core/mmc.c stblinux-3.14-1.10-git/drivers/mmc/core/mmc.c
--- stblinux-3.14-1.8/drivers/mmc/core/mmc.c	2015-07-28 23:57:39.000000000 +0000
+++ stblinux-3.14-1.10-git/drivers/mmc/core/mmc.c	2019-02-10 22:05:52.950336124 +0000
@@ -293,13 +293,12 @@
 		}
 	}
 
+	/*
+	 * The EXT_CSD format is meant to be forward compatible. As long
+	 * as CSD_STRUCTURE does not change, all values for EXT_CSD_REV
+	 * are authorized, see JEDEC JESD84-B50 section B.8.
+	 */
 	card->ext_csd.rev = ext_csd[EXT_CSD_REV];
-	if (card->ext_csd.rev > 7) {
-		pr_err("%s: unrecognised EXT_CSD revision %d\n",
-			mmc_hostname(card->host), card->ext_csd.rev);
-		err = -EINVAL;
-		goto out;
-	}
 
 	card->ext_csd.raw_sectors[0] = ext_csd[EXT_CSD_SEC_CNT + 0];
 	card->ext_csd.raw_sectors[1] = ext_csd[EXT_CSD_SEC_CNT + 1];
diff -u -N -r stblinux-3.14-1.8/drivers/mmc/core/sd.c stblinux-3.14-1.10-git/drivers/mmc/core/sd.c
--- stblinux-3.14-1.8/drivers/mmc/core/sd.c	2015-07-28 23:57:39.000000000 +0000
+++ stblinux-3.14-1.10-git/drivers/mmc/core/sd.c	2019-02-10 22:05:52.950336124 +0000
@@ -389,18 +389,9 @@
 {
 	int host_drv_type = SD_DRIVER_TYPE_B;
 	int card_drv_type = SD_DRIVER_TYPE_B;
-	int drive_strength;
+	int drive_strength, drv_type;
 	int err;
 
-	/*
-	 * If the host doesn't support any of the Driver Types A,C or D,
-	 * or there is no board specific handler then default Driver
-	 * Type B is used.
-	 */
-	if (!(card->host->caps & (MMC_CAP_DRIVER_TYPE_A | MMC_CAP_DRIVER_TYPE_C
-	    | MMC_CAP_DRIVER_TYPE_D)))
-		return 0;
-
 	if (!card->host->ops->select_drive_strength)
 		return 0;
 
@@ -429,22 +420,24 @@
 	 * return what is possible given the options
 	 */
 	mmc_host_clk_hold(card->host);
-	drive_strength = card->host->ops->select_drive_strength(
+	drive_strength = card->host->ops->select_drive_strength(card,
 		card->sw_caps.uhs_max_dtr,
-		host_drv_type, card_drv_type);
+		host_drv_type, card_drv_type, &drv_type);
 	mmc_host_clk_release(card->host);
 
-	err = mmc_sd_switch(card, 1, 2, drive_strength, status);
-	if (err)
-		return err;
-
-	if ((status[15] & 0xF) != drive_strength) {
-		pr_warning("%s: Problem setting drive strength!\n",
-			mmc_hostname(card->host));
-		return 0;
+	if (drive_strength) {
+		err = mmc_sd_switch(card, 1, 2, drive_strength, status);
+		if (err)
+			return err;
+		if ((status[15] & 0xF) != drive_strength) {
+			pr_warn("%s: Problem setting drive strength!\n",
+				mmc_hostname(card->host));
+			return 0;
+		}
 	}
 
-	mmc_set_driver_type(card->host, drive_strength);
+	if (drv_type)
+		mmc_set_driver_type(card->host, drv_type);
 
 	return 0;
 }
diff -u -N -r stblinux-3.14-1.8/drivers/mmc/core/sdio.c stblinux-3.14-1.10-git/drivers/mmc/core/sdio.c
--- stblinux-3.14-1.8/drivers/mmc/core/sdio.c	2015-07-28 23:57:39.000000000 +0000
+++ stblinux-3.14-1.10-git/drivers/mmc/core/sdio.c	2019-02-10 22:05:52.950336124 +0000
@@ -401,21 +401,10 @@
 {
 	int host_drv_type = SD_DRIVER_TYPE_B;
 	int card_drv_type = SD_DRIVER_TYPE_B;
-	int drive_strength;
+	int drive_strength, drv_type;
 	unsigned char card_strength;
 	int err;
 
-	/*
-	 * If the host doesn't support any of the Driver Types A,C or D,
-	 * or there is no board specific handler then default Driver
-	 * Type B is used.
-	 */
-	if (!(card->host->caps &
-		(MMC_CAP_DRIVER_TYPE_A |
-		 MMC_CAP_DRIVER_TYPE_C |
-		 MMC_CAP_DRIVER_TYPE_D)))
-		return;
-
 	if (!card->host->ops->select_drive_strength)
 		return;
 
@@ -443,25 +432,29 @@
 	 * information and let the hardware specific code
 	 * return what is possible given the options
 	 */
-	drive_strength = card->host->ops->select_drive_strength(
+	drive_strength = card->host->ops->select_drive_strength(card,
 		card->sw_caps.uhs_max_dtr,
-		host_drv_type, card_drv_type);
-
-	/* if error just use default for drive strength B */
-	err = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_DRIVE_STRENGTH, 0,
-		&card_strength);
-	if (err)
-		return;
-
-	card_strength &= ~(SDIO_DRIVE_DTSx_MASK<<SDIO_DRIVE_DTSx_SHIFT);
-	card_strength |= host_drive_to_sdio_drive(drive_strength);
+		host_drv_type, card_drv_type, &drv_type);
 
-	err = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_DRIVE_STRENGTH,
-		card_strength, NULL);
+	if (drive_strength) {
+		/* if error just use default for drive strength B */
+		err = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_DRIVE_STRENGTH, 0,
+				       &card_strength);
+		if (err)
+			return;
+
+		card_strength &= ~(SDIO_DRIVE_DTSx_MASK<<SDIO_DRIVE_DTSx_SHIFT);
+		card_strength |= host_drive_to_sdio_drive(drive_strength);
+
+		/* if error default to drive strength B */
+		err = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_DRIVE_STRENGTH,
+				       card_strength, NULL);
+		if (err)
+			return;
+	}
 
-	/* if error default to drive strength B */
-	if (!err)
-		mmc_set_driver_type(card->host, drive_strength);
+	if (drv_type)
+		mmc_set_driver_type(card->host, drv_type);
 }
 
 
diff -u -N -r stblinux-3.14-1.8/drivers/mmc/host/sdhci-brcmstb.c stblinux-3.14-1.10-git/drivers/mmc/host/sdhci-brcmstb.c
--- stblinux-3.14-1.8/drivers/mmc/host/sdhci-brcmstb.c	2015-07-28 23:57:39.000000000 +0000
+++ stblinux-3.14-1.10-git/drivers/mmc/host/sdhci-brcmstb.c	2019-02-10 22:06:28.132824631 +0000
@@ -31,6 +31,18 @@
 #define SDIO_CFG_REG(x, y)	(x + BCHP_SDIO_0_CFG_##y -	\
 				BCHP_SDIO_0_CFG_REG_START)
 
+struct sdhci_brcmstb_priv {
+	void __iomem *cfg_regs;
+	int host_driver_type;
+	int host_hs_driver_type;
+	int card_driver_type;
+};
+
+#define MASK_OFF_DRV (SDHCI_PRESET_SDCLK_FREQ_MASK |	\
+			SDHCI_PRESET_CLKGEN_SEL_MASK)
+
+static char *strength_type_to_string[] = {"B", "A", "C", "D"};
+
 #if defined(CONFIG_BCM74371A0)
 /*
  * HW7445-1183
@@ -47,27 +59,128 @@
 	writeb(val, host->ioaddr + reg);
 }
 
+/* We don't support drive strength override on chips that use the
+ * old version of the SDIO core.
+ */
+static void set_host_driver_strength_overrides(
+	struct sdhci_host *host,
+	struct sdhci_brcmstb_priv *priv)
+{
+}
+
+#else /* CONFIG_BCM74371A0 */
+
+static void set_host_driver_strength_overrides(
+	struct sdhci_host *host,
+	struct sdhci_brcmstb_priv *priv)
+{
+	u16 strength;
+	u16 sdr25;
+	u16 sdr50;
+	u16 ddr50;
+	u16 sdr104;
+	u32 val;
+	u32 cfg_base = (u32)priv->cfg_regs;
+
+	if (priv->host_driver_type) {
+		dev_info(mmc_dev(host->mmc),
+			"Changing UHS Host Driver TYPE Presets to TYPE %s\n",
+			strength_type_to_string[priv->host_driver_type]);
+		strength = (u16)priv->host_driver_type << 11;
+		sdr25 = sdhci_readw(host,
+				SDHCI_PRESET_FOR_SDR25) & MASK_OFF_DRV;
+		sdr50 = sdhci_readw(host,
+				SDHCI_PRESET_FOR_SDR50) & MASK_OFF_DRV;
+		ddr50 = sdhci_readw(host,
+				SDHCI_PRESET_FOR_DDR50) & MASK_OFF_DRV;
+		sdr104 = sdhci_readw(host,
+				SDHCI_PRESET_FOR_SDR104) & MASK_OFF_DRV;
+		val = (sdr25 | strength);
+		val |= ((u32)(sdr50 | strength)) << 16;
+		val |= 0x80000000;
+		DEV_WR(SDIO_CFG_REG(cfg_base, PRESET3), val);
+		val = (sdr104 | strength);
+		val |= ((u32)(ddr50 | strength)) << 16;
+		val |= 0x80000000;
+		DEV_WR(SDIO_CFG_REG(cfg_base, PRESET4), val);
+	}
+
+	/*
+	 * The Host Controller Specification states that the driver
+	 * strength setting is only valid for UHS modes, but our
+	 * host controller allows this setting to be used for HS modes
+	 * as well.
+	 */
+	if (priv->host_hs_driver_type) {
+		u16 sdr12;
+		u16 hs;
+
+		dev_info(mmc_dev(host->mmc),
+			"Changing HS Host Driver TYPE Presets to TYPE %s\n",
+			strength_type_to_string[priv->host_hs_driver_type]);
+		strength = (u16)priv->host_hs_driver_type << 11;
+		sdr12 = sdhci_readw(host, SDHCI_PRESET_FOR_SDR12) &
+			MASK_OFF_DRV;
+		hs = sdhci_readw(host, SDHCI_PRESET_FOR_HS) & MASK_OFF_DRV;
+		val = (hs | strength);
+		val |= ((u32)(sdr12 | strength)) << 16;
+		val |= 0x80000000;
+		DEV_WR(SDIO_CFG_REG(cfg_base, PRESET2), val);
+	}
+}
+#endif /* CONFIG_BCM74371A0 */
+
+static int select_one_drive_strength(struct sdhci_host *host, int supported,
+				int requested, char *type)
+{
+	char strength_ok_msg[] = "Changing %s Driver to TYPE %s\n";
+	char strength_err_msg[] =
+		"Request to change %s Driver to TYPE %s not supported by %s\n";
+	if (supported & (1 << requested)) {
+		if (requested)
+			dev_info(mmc_dev(host->mmc), strength_ok_msg, type,
+				strength_type_to_string[requested], type);
+		return requested;
+	} else {
+		dev_warn(mmc_dev(host->mmc), strength_err_msg, type,
+			strength_type_to_string[requested], type);
+		return 0;
+	}
+}
+
+static int sdhci_brcmstb_select_drive_strength(struct sdhci_host *host,
+					struct mmc_card *card,
+					unsigned int max_dtr, int host_drv,
+					int card_drv, int *drv_type)
+{
+	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+	struct sdhci_brcmstb_priv *priv = sdhci_pltfm_priv(pltfm_host);
+
+	*drv_type = select_one_drive_strength(host, host_drv,
+					priv->host_driver_type,	"Host");
+	return select_one_drive_strength(host, card_drv,
+					priv->card_driver_type,	"Card");
+}
+
 static struct sdhci_ops sdhci_brcmstb_ops = {
-	.write_b	= sdhci_brcmstb_writeb,
+	.select_drive_strength	= sdhci_brcmstb_select_drive_strength,
 };
-#endif
 
 static struct sdhci_pltfm_data sdhci_brcmstb_pdata = {
 };
 
 #if defined(CONFIG_BCM3390A0) || defined(CONFIG_BCM7145B0) ||		\
 	defined(CONFIG_BCM7250B0) || defined(CONFIG_BCM7364A0) ||	\
-	defined(CONFIG_BCM7439B0) || defined(CONFIG_BCM7445D0)
-static int sdhci_override_caps(struct platform_device *pdev,
-			uint32_t cap0_setbits,
-			uint32_t cap0_clearbits,
-			uint32_t cap1_setbits,
-			uint32_t cap1_clearbits)
+	defined(CONFIG_BCM7445D0)
+static void sdhci_override_caps(struct sdhci_host *host,
+				struct sdhci_brcmstb_priv *priv,
+				uint32_t cap0_setbits,
+				uint32_t cap0_clearbits,
+				uint32_t cap1_setbits,
+				uint32_t cap1_clearbits)
 {
 	uint32_t val;
-	struct resource *iomem;
-	uintptr_t cfg_base;
-	struct sdhci_host *host = platform_get_drvdata(pdev);
+	void *cfg_base = priv->cfg_regs;
 
 	/*
 	 * The CAP's override bits in the CFG registers default to all
@@ -75,32 +188,33 @@
 	 * CAPS registers and then modify the requested bits and write
 	 * them to the override CFG registers.
 	 */
-	iomem = platform_get_resource(pdev, IORESOURCE_MEM, 1);
-	if (!iomem)
-		return -EINVAL;
-	cfg_base = iomem->start;
 	val = sdhci_readl(host, SDHCI_CAPABILITIES);
 	val &= ~cap0_clearbits;
 	val |= cap0_setbits;
-	BDEV_WR(SDIO_CFG_REG(cfg_base, CAP_REG0), val);
+	DEV_WR(SDIO_CFG_REG(cfg_base, CAP_REG0), val);
 	val = sdhci_readl(host, SDHCI_CAPABILITIES_1);
 	val &= ~cap1_clearbits;
 	val |= cap1_setbits;
-	BDEV_WR(SDIO_CFG_REG(cfg_base, CAP_REG1), val);
-	BDEV_WR(SDIO_CFG_REG(cfg_base, CAP_REG_OVERRIDE),
+	DEV_WR(SDIO_CFG_REG(cfg_base, CAP_REG1), val);
+	DEV_WR(SDIO_CFG_REG(cfg_base, CAP_REG_OVERRIDE),
 		BCHP_SDIO_0_CFG_CAP_REG_OVERRIDE_CAP_REG_OVERRIDE_MASK);
-	return 0;
 }
 
-static int sdhci_fix_caps(struct platform_device *pdev)
+static void sdhci_fix_caps(struct sdhci_host *host,
+			struct sdhci_brcmstb_priv *priv)
 {
+#if defined(CONFIG_BCM7445D0)
+	/* Fixed for E0 and above */
+	if (BRCM_CHIP_REV() >= 0x40)
+		return 0;
+#endif
 	/* Disable SDR50 support because tuning is broken. */
-	return sdhci_override_caps(pdev, 0, 0, 0, SDHCI_SUPPORT_SDR50);
+	sdhci_override_caps(host, priv, 0, 0, 0, SDHCI_SUPPORT_SDR50);
 }
 #else
-static int sdhci_fix_caps(struct platform_device *pdev)
+static void sdhci_fix_caps(struct sdhci_host *host,
+			struct sdhci_brcmstb_priv *priv)
 {
-	return 0;
 }
 #endif
 
@@ -123,11 +237,14 @@
 {
 	struct sdhci_host *host = dev_get_drvdata(dev);
 	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
+	struct sdhci_brcmstb_priv *priv = sdhci_pltfm_priv(pltfm_host);
 	int err;
 
 	err = clk_enable(pltfm_host->clk);
 	if (err)
 		return err;
+	sdhci_fix_caps(host, priv);
+	set_host_driver_strength_overrides(host, priv);
 	return sdhci_resume_host(host);
 }
 
@@ -136,12 +253,34 @@
 static SIMPLE_DEV_PM_OPS(sdhci_brcmstb_pmops, sdhci_brcmstb_suspend,
 			sdhci_brcmstb_resume);
 
+static void sdhci_brcmstb_of_get_driver_type(struct device_node *dn,
+					char *name, int *dtype)
+{
+	const char *driver_type;
+	int res;
+
+	res = of_property_read_string(dn, name, &driver_type);
+	if (res == 0) {
+		if (strcmp(driver_type, "A") == 0)
+			*dtype = MMC_SET_DRIVER_TYPE_A;
+		else if (strcmp(driver_type, "B") == 0)
+			*dtype = MMC_SET_DRIVER_TYPE_B;
+		else if (strcmp(driver_type, "C") == 0)
+			*dtype = MMC_SET_DRIVER_TYPE_C;
+		else if (strcmp(driver_type, "D") == 0)
+			*dtype = MMC_SET_DRIVER_TYPE_D;
+	}
+}
+
+
 static int sdhci_brcmstb_probe(struct platform_device *pdev)
 {
 	struct device_node *dn = pdev->dev.of_node;
 	struct sdhci_host *host;
 	struct sdhci_pltfm_host *pltfm_host;
+	struct sdhci_brcmstb_priv *priv;
 	struct clk *clk;
+	struct resource *resource;
 	int res;
 
 	clk = of_clk_get_by_name(dn, "sw_sdio");
@@ -153,27 +292,46 @@
 	if (res)
 		goto undo_clk_get;
 
-/* Only enable reset workaround for 7439a0 and 74371a0 senior */
 #if defined(CONFIG_BCM74371A0)
+	/* Only enable reset workaround for 74371a0 senior */
 	if (BRCM_CHIP_ID() == 0x7439)
-		sdhci_brcmstb_pdata.ops = &sdhci_brcmstb_ops;
-#endif
-	host = sdhci_pltfm_init(pdev, &sdhci_brcmstb_pdata, 0);
+		sdhci_brcmstb_ops.write_b = sdhci_brcmstb_writeb;
+#endif /* CONFIG_BCM74371A0 */
+	sdhci_brcmstb_pdata.ops = &sdhci_brcmstb_ops;
+	host = sdhci_pltfm_init(pdev, &sdhci_brcmstb_pdata,
+				sizeof(struct sdhci_brcmstb_priv));
 	if (IS_ERR(host)) {
 		res = PTR_ERR(host);
 		goto undo_clk_prep;
 	}
 	sdhci_get_of_property(pdev);
 	mmc_of_parse(host->mmc);
-	res = sdhci_fix_caps(pdev);
-	if (res)
-		goto undo_pltfm_init;
+	pltfm_host = sdhci_priv(host);
+	priv = sdhci_pltfm_priv(pltfm_host);
+	resource = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+	if (resource == NULL) {
+		dev_err(&pdev->dev, "can't get SDHCI CFG base address\n");
+		return -EINVAL;
+	}
+	priv->cfg_regs = devm_request_and_ioremap(&pdev->dev, resource);
+	if (!priv->cfg_regs) {
+		dev_err(&pdev->dev, "can't map register space\n");
+		return -EINVAL;
+	}
+	sdhci_fix_caps(host, priv);
+
+	sdhci_brcmstb_of_get_driver_type(dn, "host-driver-strength",
+					&priv->host_driver_type);
+	sdhci_brcmstb_of_get_driver_type(dn, "host-hs-driver-strength",
+					&priv->host_hs_driver_type);
+	sdhci_brcmstb_of_get_driver_type(dn, "card-driver-strength",
+					&priv->card_driver_type);
+	set_host_driver_strength_overrides(host, priv);
 
 	res = sdhci_add_host(host);
 	if (res)
 		goto undo_pltfm_init;
 
-	pltfm_host = sdhci_priv(host);
 	pltfm_host->clk = clk;
 	return res;
 
diff -u -N -r stblinux-3.14-1.8/drivers/mmc/host/sdhci.c stblinux-3.14-1.10-git/drivers/mmc/host/sdhci.c
--- stblinux-3.14-1.8/drivers/mmc/host/sdhci.c	2015-07-28 23:57:39.000000000 +0000
+++ stblinux-3.14-1.10-git/drivers/mmc/host/sdhci.c	2019-02-10 22:05:52.954335952 +0000
@@ -1527,8 +1527,18 @@
 			ctrl_2 &= ~SDHCI_CTRL_DRV_TYPE_MASK;
 			if (ios->drv_type == MMC_SET_DRIVER_TYPE_A)
 				ctrl_2 |= SDHCI_CTRL_DRV_TYPE_A;
+			else if (ios->drv_type == MMC_SET_DRIVER_TYPE_B)
+				ctrl_2 |= SDHCI_CTRL_DRV_TYPE_B;
 			else if (ios->drv_type == MMC_SET_DRIVER_TYPE_C)
 				ctrl_2 |= SDHCI_CTRL_DRV_TYPE_C;
+			else if (ios->drv_type == MMC_SET_DRIVER_TYPE_D)
+				ctrl_2 |= SDHCI_CTRL_DRV_TYPE_D;
+			else {
+				pr_warn("%s: invalid driver type, default to "
+					"driver type B\n",
+					mmc_hostname(host->mmc));
+				ctrl_2 |= SDHCI_CTRL_DRV_TYPE_B;
+			}
 
 			sdhci_writew(host, ctrl_2, SDHCI_HOST_CONTROL2);
 		} else {
@@ -2047,6 +2057,18 @@
 	return err;
 }
 
+static int sdhci_select_drive_strength(struct mmc_card *card,
+				       unsigned int max_dtr, int host_drv,
+				       int card_drv, int *drv_type)
+{
+	struct sdhci_host *host = mmc_priv(card->host);
+
+	if (!host->ops->select_drive_strength)
+		return 0;
+
+	return host->ops->select_drive_strength(host, card, max_dtr, host_drv,
+						card_drv, drv_type);
+}
 
 static void sdhci_enable_preset_value(struct sdhci_host *host, bool enable)
 {
@@ -2110,6 +2132,7 @@
 	.enable_sdio_irq = sdhci_enable_sdio_irq,
 	.start_signal_voltage_switch	= sdhci_start_signal_voltage_switch,
 	.execute_tuning			= sdhci_execute_tuning,
+	.select_drive_strength		= sdhci_select_drive_strength,
 	.card_event			= sdhci_card_event,
 	.card_busy	= sdhci_card_busy,
 };
diff -u -N -r stblinux-3.14-1.8/drivers/mmc/host/sdhci.h stblinux-3.14-1.10-git/drivers/mmc/host/sdhci.h
--- stblinux-3.14-1.8/drivers/mmc/host/sdhci.h	2015-07-28 23:57:39.000000000 +0000
+++ stblinux-3.14-1.10-git/drivers/mmc/host/sdhci.h	2019-02-10 22:05:52.954335952 +0000
@@ -229,6 +229,7 @@
 
 /* 60-FB reserved */
 
+#define SDHCI_PRESET_FOR_HS 0x64
 #define SDHCI_PRESET_FOR_SDR12 0x66
 #define SDHCI_PRESET_FOR_SDR25 0x68
 #define SDHCI_PRESET_FOR_SDR50 0x6A
@@ -296,6 +297,10 @@
 	void    (*adma_workaround)(struct sdhci_host *host, u32 intmask);
 	void	(*platform_init)(struct sdhci_host *host);
 	void    (*card_event)(struct sdhci_host *host);
+	int	(*select_drive_strength)(struct sdhci_host *host,
+					 struct mmc_card *card,
+					 unsigned int max_dtr, int host_drv,
+					 int card_drv, int *drv_type);
 };
 
 #ifdef CONFIG_MMC_SDHCI_IO_ACCESSORS
diff -u -N -r stblinux-3.14-1.8/include/linux/mmc/host.h stblinux-3.14-1.10-git/include/linux/mmc/host.h
--- stblinux-3.14-1.8/include/linux/mmc/host.h	2015-07-28 23:57:41.000000000 +0000
+++ stblinux-3.14-1.10-git/include/linux/mmc/host.h	2019-02-10 22:05:53.146327704 +0000
@@ -136,7 +136,9 @@
 
 	/* The tuning command opcode value is different for SD and eMMC cards */
 	int	(*execute_tuning)(struct mmc_host *host, u32 opcode);
-	int	(*select_drive_strength)(unsigned int max_dtr, int host_drv, int card_drv);
+	int	(*select_drive_strength)(struct mmc_card *card,
+					 unsigned int max_dtr, int host_drv,
+					 int card_drv, int *drv_type);
 	void	(*hw_reset)(struct mmc_host *host);
 	void	(*card_event)(struct mmc_host *host);
 };