| Message ID | 1528373500-24663-3-git-send-email-manish.narani@xilinx.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
Ping for RFC > -----Original Message----- > From: Manish Narani [mailto:manish.narani@xilinx.com] > Sent: Thursday, June 7, 2018 5:42 PM > To: robh+dt@kernel.org; mark.rutland@arm.com; catalin.marinas@arm.com; > will.deacon@arm.com; mdf@kernel.org; stefan.krsmanovic@aggios.com; > linux-arm-kernel@lists.infradead.org; linux-kernel@vger.kernel.org; linux- > mmc@vger.kernel.org; devicetree@vger.kernel.org; > adrian.hunter@intel.com; michal.simek@xilinx.com; ulf.hansson@linaro.org > Cc: Manish Narani <MNARANI@xilinx.com> > Subject: [RFC PATCH 3/3] sdhci: arasan: Add support to read Tap Delay values > from DT > > This patch adds support for reading Tap Delay values from Device Tree and > write them via eemi calls. The macros containing these tap delay values are > removed from the driver. > > Signed-off-by: Manish Narani <manish.narani@xilinx.com> > --- > drivers/mmc/host/sdhci-of-arasan.c | 131 > +++++++++++++++++++++++++++++++++++++ > 1 file changed, 131 insertions(+) > > diff --git a/drivers/mmc/host/sdhci-of-arasan.c b/drivers/mmc/host/sdhci- > of-arasan.c > index e3332a5..fc0fd01 100644 > --- a/drivers/mmc/host/sdhci-of-arasan.c > +++ b/drivers/mmc/host/sdhci-of-arasan.c > @@ -36,6 +36,8 @@ > > #define PHY_CLK_TOO_SLOW_HZ 400000 > > +#define MMC_BANK2 0x2 > + > /* > * On some SoCs the syscon area has a feature where the upper 16-bits of > * each 32-bit register act as a write mask for the lower 16-bits. This allows > @@ -90,6 +92,10 @@ struct sdhci_arasan_data { > struct sdhci_host *host; > struct clk *clk_ahb; > struct phy *phy; > + u32 mio_bank; > + u32 device_id; > + u32 itapdly[MMC_TIMING_MMC_HS400 + 1]; > + u32 otapdly[MMC_TIMING_MMC_HS400 + 1]; > bool is_phy_on; > > bool has_cqe; > @@ -160,11 +166,36 @@ static int sdhci_arasan_syscon_write(struct > sdhci_host *host, > return ret; > } > > +/** > + * arasan_zynqmp_set_tap_delay - Program the tap delays. > + * @deviceid: Unique Id of device > + * @itap_delay: Input Tap Delay > + * @oitap_delay: Output Tap Delay > + */ > +static void arasan_zynqmp_set_tap_delay(u8 deviceid, u8 itap_delay, u8 > +otap_delay) { > + const struct zynqmp_eemi_ops *eemi_ops = > zynqmp_pm_get_eemi_ops(); > + u32 node_id = (deviceid == 0) ? NODE_SD_0 : NODE_SD_1; > + > + if (!eemi_ops || !eemi_ops->ioctl) > + return; > + > + if (itap_delay) > + eemi_ops->ioctl(node_id, IOCTL_SET_SD_TAPDELAY, > + PM_TAPDELAY_INPUT, itap_delay, NULL); > + > + if (otap_delay) > + eemi_ops->ioctl(node_id, IOCTL_SET_SD_TAPDELAY, > + PM_TAPDELAY_OUTPUT, otap_delay, NULL); > } > + > static void sdhci_arasan_set_clock(struct sdhci_host *host, unsigned int > clock) { > struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); > struct sdhci_arasan_data *sdhci_arasan = > sdhci_pltfm_priv(pltfm_host); > bool ctrl_phy = false; > + u8 itap_delay; > + u8 otap_delay; > > if (!IS_ERR(sdhci_arasan->phy)) { > if (!sdhci_arasan->is_phy_on && clock <= > PHY_CLK_TOO_SLOW_HZ) { @@ -200,6 +231,16 @@ static void > sdhci_arasan_set_clock(struct sdhci_host *host, unsigned int clock) > } > } > > + if (host->version >= SDHCI_SPEC_300) { > + if ((host->timing != MMC_TIMING_LEGACY) && > + (host->timing != MMC_TIMING_UHS_SDR12)) { > + itap_delay = sdhci_arasan->itapdly[host->timing]; > + otap_delay = sdhci_arasan->otapdly[host->timing]; > + arasan_zynqmp_set_tap_delay(sdhci_arasan- > >device_id, > + itap_delay, otap_delay); > + } > + } > + > if (ctrl_phy && sdhci_arasan->is_phy_on) { > phy_power_off(sdhci_arasan->phy); > sdhci_arasan->is_phy_on = false; > @@ -456,6 +497,7 @@ static const struct of_device_id > sdhci_arasan_of_match[] = { > { .compatible = "arasan,sdhci-8.9a" }, > { .compatible = "arasan,sdhci-5.1" }, > { .compatible = "arasan,sdhci-4.9a" }, > + { .compatible = "xlnx,zynqmp-8.9a" }, > > { /* sentinel */ } > }; > @@ -641,6 +683,74 @@ static void sdhci_arasan_unregister_sdclk(struct > device *dev) > of_clk_del_provider(dev->of_node); > } > > +/** > + * arasan_zynqmp_dt_parse_tap_delays - Read Tap Delay values from DT > + * > + * Called at initialization to parse the values of Tap Delays. > + * > + * @dev: Pointer to our struct device. > + */ > +static void arasan_zynqmp_dt_parse_tap_delays(struct device *dev) { > + struct platform_device *pdev = to_platform_device(dev); > + struct sdhci_host *host = platform_get_drvdata(pdev); > + struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); > + struct sdhci_arasan_data *sdhci_arasan = > sdhci_pltfm_priv(pltfm_host); > + struct device_node *np = dev->of_node; > + > + of_property_read_u32(np, "xlnx,itap_delay_sd_hsd", > + &sdhci_arasan->itapdly[MMC_TIMING_SD_HS]); > + of_property_read_u32(np, "xlnx,otap_delay_sd_hsd", > + &sdhci_arasan->otapdly[MMC_TIMING_SD_HS]); > + of_property_read_u32(np, "xlnx,itap_delay_sdr25", > + &sdhci_arasan- > >itapdly[MMC_TIMING_UHS_SDR25]); > + of_property_read_u32(np, "xlnx,otap_delay_sdr25", > + &sdhci_arasan- > >otapdly[MMC_TIMING_UHS_SDR25]); > + of_property_read_u32(np, "xlnx,itap_delay_sdr50", > + &sdhci_arasan- > >itapdly[MMC_TIMING_UHS_SDR50]); > + of_property_read_u32(np, "xlnx,otap_delay_sdr50", > + &sdhci_arasan- > >otapdly[MMC_TIMING_UHS_SDR50]); > + of_property_read_u32(np, "xlnx,itap_delay_sd_ddr50", > + &sdhci_arasan- > >itapdly[MMC_TIMING_UHS_DDR50]); > + of_property_read_u32(np, "xlnx,otap_delay_sd_ddr50", > + &sdhci_arasan- > >otapdly[MMC_TIMING_UHS_DDR50]); > + of_property_read_u32(np, "xlnx,itap_delay_mmc_hsd", > + &sdhci_arasan- > >itapdly[MMC_TIMING_MMC_HS]); > + of_property_read_u32(np, "xlnx,otap_delay_mmc_hsd", > + &sdhci_arasan- > >otapdly[MMC_TIMING_MMC_HS]); > + of_property_read_u32(np, "xlnx,itap_delay_mmc_ddr50", > + &sdhci_arasan- > >itapdly[MMC_TIMING_MMC_DDR52]); > + of_property_read_u32(np, "xlnx,otap_delay_mmc_ddr50", > + &sdhci_arasan- > >otapdly[MMC_TIMING_MMC_DDR52]); > + if (sdhci_arasan->mio_bank == MMC_BANK2) { > + of_property_read_u32(np, > + "xlnx,itap_delay_sdr104_b2", > + &sdhci_arasan- > >itapdly[MMC_TIMING_UHS_SDR104]); > + of_property_read_u32(np, > + "xlnx,otap_delay_sdr104_b2", > + &sdhci_arasan- > >otapdly[MMC_TIMING_UHS_SDR104]); > + of_property_read_u32(np, > + "xlnx,itap_delay_mmc_hs200_b2", > + &sdhci_arasan- > >itapdly[MMC_TIMING_MMC_HS200]); > + of_property_read_u32(np, > + "xlnx,otap_delay_mmc_hs200_b2", > + &sdhci_arasan- > >otapdly[MMC_TIMING_MMC_HS200]); > + } else { > + of_property_read_u32(np, > + "xlnx,itap_delay_sdr104_b0", > + &sdhci_arasan- > >itapdly[MMC_TIMING_UHS_SDR104]); > + of_property_read_u32(np, > + "xlnx,otap_delay_sdr104_b0", > + &sdhci_arasan- > >otapdly[MMC_TIMING_UHS_SDR104]); > + of_property_read_u32(np, > + "xlnx,itap_delay_mmc_hs200_b0", > + &sdhci_arasan- > >itapdly[MMC_TIMING_MMC_HS200]); > + of_property_read_u32(np, > + "xlnx,otap_delay_mmc_hs200_b0", > + &sdhci_arasan- > >otapdly[MMC_TIMING_MMC_HS200]); > + } > +} > + > static int sdhci_arasan_add_host(struct sdhci_arasan_data *sdhci_arasan) { > struct sdhci_host *host = sdhci_arasan->host; @@ -776,6 +886,27 > @@ static int sdhci_arasan_probe(struct platform_device *pdev) > goto unreg_clk; > } > > + if (of_device_is_compatible(pdev->dev.of_node, > + "xlnx,zynqmp-8.9a")) { > + ret = of_property_read_u32(pdev->dev.of_node, > + "xlnx,mio_bank", > + &sdhci_arasan->mio_bank); > + if (ret < 0) { > + dev_err(&pdev->dev, > + "\"xlnx,mio_bank \" property is missing.\n"); > + goto clk_disable_all; > + } > + ret = of_property_read_u32(pdev->dev.of_node, > + "xlnx,device_id", > + &sdhci_arasan->device_id); > + if (ret < 0) { > + dev_err(&pdev->dev, > + "\"xlnx,device_id \" property is missing.\n"); > + goto clk_disable_all; > + } > + arasan_zynqmp_dt_parse_tap_delays(&pdev->dev); > + } > + > sdhci_arasan->phy = ERR_PTR(-ENODEV); > if (of_device_is_compatible(pdev->dev.of_node, > "arasan,sdhci-5.1")) { > -- > 2.7.4 -- To unsubscribe from this list: send the line "unsubscribe linux-mmc" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On 14/06/18 08:38, Manish Narani wrote: > Ping for RFC What is eemi? Why aren't there patches for that? > >> -----Original Message----- >> From: Manish Narani [mailto:manish.narani@xilinx.com] >> Sent: Thursday, June 7, 2018 5:42 PM >> To: robh+dt@kernel.org; mark.rutland@arm.com; catalin.marinas@arm.com; >> will.deacon@arm.com; mdf@kernel.org; stefan.krsmanovic@aggios.com; >> linux-arm-kernel@lists.infradead.org; linux-kernel@vger.kernel.org; linux- >> mmc@vger.kernel.org; devicetree@vger.kernel.org; >> adrian.hunter@intel.com; michal.simek@xilinx.com; ulf.hansson@linaro.org >> Cc: Manish Narani <MNARANI@xilinx.com> >> Subject: [RFC PATCH 3/3] sdhci: arasan: Add support to read Tap Delay values >> from DT >> >> This patch adds support for reading Tap Delay values from Device Tree and >> write them via eemi calls. The macros containing these tap delay values are >> removed from the driver. >> >> Signed-off-by: Manish Narani <manish.narani@xilinx.com> >> --- >> drivers/mmc/host/sdhci-of-arasan.c | 131 >> +++++++++++++++++++++++++++++++++++++ >> 1 file changed, 131 insertions(+) >> >> diff --git a/drivers/mmc/host/sdhci-of-arasan.c b/drivers/mmc/host/sdhci- >> of-arasan.c >> index e3332a5..fc0fd01 100644 >> --- a/drivers/mmc/host/sdhci-of-arasan.c >> +++ b/drivers/mmc/host/sdhci-of-arasan.c >> @@ -36,6 +36,8 @@ >> >> #define PHY_CLK_TOO_SLOW_HZ 400000 >> >> +#define MMC_BANK2 0x2 >> + >> /* >> * On some SoCs the syscon area has a feature where the upper 16-bits of >> * each 32-bit register act as a write mask for the lower 16-bits. This allows >> @@ -90,6 +92,10 @@ struct sdhci_arasan_data { >> struct sdhci_host *host; >> struct clk *clk_ahb; >> struct phy *phy; >> + u32 mio_bank; >> + u32 device_id; >> + u32 itapdly[MMC_TIMING_MMC_HS400 + 1]; >> + u32 otapdly[MMC_TIMING_MMC_HS400 + 1]; >> bool is_phy_on; >> >> bool has_cqe; >> @@ -160,11 +166,36 @@ static int sdhci_arasan_syscon_write(struct >> sdhci_host *host, >> return ret; >> } >> >> +/** >> + * arasan_zynqmp_set_tap_delay - Program the tap delays. >> + * @deviceid: Unique Id of device >> + * @itap_delay: Input Tap Delay >> + * @oitap_delay: Output Tap Delay >> + */ >> +static void arasan_zynqmp_set_tap_delay(u8 deviceid, u8 itap_delay, u8 >> +otap_delay) { >> + const struct zynqmp_eemi_ops *eemi_ops = >> zynqmp_pm_get_eemi_ops(); >> + u32 node_id = (deviceid == 0) ? NODE_SD_0 : NODE_SD_1; >> + >> + if (!eemi_ops || !eemi_ops->ioctl) >> + return; >> + >> + if (itap_delay) >> + eemi_ops->ioctl(node_id, IOCTL_SET_SD_TAPDELAY, >> + PM_TAPDELAY_INPUT, itap_delay, NULL); >> + >> + if (otap_delay) >> + eemi_ops->ioctl(node_id, IOCTL_SET_SD_TAPDELAY, >> + PM_TAPDELAY_OUTPUT, otap_delay, NULL); >> } >> + >> static void sdhci_arasan_set_clock(struct sdhci_host *host, unsigned int >> clock) { >> struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); >> struct sdhci_arasan_data *sdhci_arasan = >> sdhci_pltfm_priv(pltfm_host); >> bool ctrl_phy = false; >> + u8 itap_delay; >> + u8 otap_delay; >> >> if (!IS_ERR(sdhci_arasan->phy)) { >> if (!sdhci_arasan->is_phy_on && clock <= >> PHY_CLK_TOO_SLOW_HZ) { @@ -200,6 +231,16 @@ static void >> sdhci_arasan_set_clock(struct sdhci_host *host, unsigned int clock) >> } >> } >> >> + if (host->version >= SDHCI_SPEC_300) { >> + if ((host->timing != MMC_TIMING_LEGACY) && >> + (host->timing != MMC_TIMING_UHS_SDR12)) { >> + itap_delay = sdhci_arasan->itapdly[host->timing]; >> + otap_delay = sdhci_arasan->otapdly[host->timing]; >> + arasan_zynqmp_set_tap_delay(sdhci_arasan- >>> device_id, >> + itap_delay, otap_delay); >> + } >> + } >> + >> if (ctrl_phy && sdhci_arasan->is_phy_on) { >> phy_power_off(sdhci_arasan->phy); >> sdhci_arasan->is_phy_on = false; >> @@ -456,6 +497,7 @@ static const struct of_device_id >> sdhci_arasan_of_match[] = { >> { .compatible = "arasan,sdhci-8.9a" }, >> { .compatible = "arasan,sdhci-5.1" }, >> { .compatible = "arasan,sdhci-4.9a" }, >> + { .compatible = "xlnx,zynqmp-8.9a" }, >> >> { /* sentinel */ } >> }; >> @@ -641,6 +683,74 @@ static void sdhci_arasan_unregister_sdclk(struct >> device *dev) >> of_clk_del_provider(dev->of_node); >> } >> >> +/** >> + * arasan_zynqmp_dt_parse_tap_delays - Read Tap Delay values from DT >> + * >> + * Called at initialization to parse the values of Tap Delays. >> + * >> + * @dev: Pointer to our struct device. >> + */ >> +static void arasan_zynqmp_dt_parse_tap_delays(struct device *dev) { >> + struct platform_device *pdev = to_platform_device(dev); >> + struct sdhci_host *host = platform_get_drvdata(pdev); >> + struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); >> + struct sdhci_arasan_data *sdhci_arasan = >> sdhci_pltfm_priv(pltfm_host); >> + struct device_node *np = dev->of_node; >> + >> + of_property_read_u32(np, "xlnx,itap_delay_sd_hsd", >> + &sdhci_arasan->itapdly[MMC_TIMING_SD_HS]); >> + of_property_read_u32(np, "xlnx,otap_delay_sd_hsd", >> + &sdhci_arasan->otapdly[MMC_TIMING_SD_HS]); >> + of_property_read_u32(np, "xlnx,itap_delay_sdr25", >> + &sdhci_arasan- >>> itapdly[MMC_TIMING_UHS_SDR25]); >> + of_property_read_u32(np, "xlnx,otap_delay_sdr25", >> + &sdhci_arasan- >>> otapdly[MMC_TIMING_UHS_SDR25]); >> + of_property_read_u32(np, "xlnx,itap_delay_sdr50", >> + &sdhci_arasan- >>> itapdly[MMC_TIMING_UHS_SDR50]); >> + of_property_read_u32(np, "xlnx,otap_delay_sdr50", >> + &sdhci_arasan- >>> otapdly[MMC_TIMING_UHS_SDR50]); >> + of_property_read_u32(np, "xlnx,itap_delay_sd_ddr50", >> + &sdhci_arasan- >>> itapdly[MMC_TIMING_UHS_DDR50]); >> + of_property_read_u32(np, "xlnx,otap_delay_sd_ddr50", >> + &sdhci_arasan- >>> otapdly[MMC_TIMING_UHS_DDR50]); >> + of_property_read_u32(np, "xlnx,itap_delay_mmc_hsd", >> + &sdhci_arasan- >>> itapdly[MMC_TIMING_MMC_HS]); >> + of_property_read_u32(np, "xlnx,otap_delay_mmc_hsd", >> + &sdhci_arasan- >>> otapdly[MMC_TIMING_MMC_HS]); >> + of_property_read_u32(np, "xlnx,itap_delay_mmc_ddr50", >> + &sdhci_arasan- >>> itapdly[MMC_TIMING_MMC_DDR52]); >> + of_property_read_u32(np, "xlnx,otap_delay_mmc_ddr50", >> + &sdhci_arasan- >>> otapdly[MMC_TIMING_MMC_DDR52]); >> + if (sdhci_arasan->mio_bank == MMC_BANK2) { >> + of_property_read_u32(np, >> + "xlnx,itap_delay_sdr104_b2", >> + &sdhci_arasan- >>> itapdly[MMC_TIMING_UHS_SDR104]); >> + of_property_read_u32(np, >> + "xlnx,otap_delay_sdr104_b2", >> + &sdhci_arasan- >>> otapdly[MMC_TIMING_UHS_SDR104]); >> + of_property_read_u32(np, >> + "xlnx,itap_delay_mmc_hs200_b2", >> + &sdhci_arasan- >>> itapdly[MMC_TIMING_MMC_HS200]); >> + of_property_read_u32(np, >> + "xlnx,otap_delay_mmc_hs200_b2", >> + &sdhci_arasan- >>> otapdly[MMC_TIMING_MMC_HS200]); >> + } else { >> + of_property_read_u32(np, >> + "xlnx,itap_delay_sdr104_b0", >> + &sdhci_arasan- >>> itapdly[MMC_TIMING_UHS_SDR104]); >> + of_property_read_u32(np, >> + "xlnx,otap_delay_sdr104_b0", >> + &sdhci_arasan- >>> otapdly[MMC_TIMING_UHS_SDR104]); >> + of_property_read_u32(np, >> + "xlnx,itap_delay_mmc_hs200_b0", >> + &sdhci_arasan- >>> itapdly[MMC_TIMING_MMC_HS200]); >> + of_property_read_u32(np, >> + "xlnx,otap_delay_mmc_hs200_b0", >> + &sdhci_arasan- >>> otapdly[MMC_TIMING_MMC_HS200]); >> + } >> +} >> + >> static int sdhci_arasan_add_host(struct sdhci_arasan_data *sdhci_arasan) { >> struct sdhci_host *host = sdhci_arasan->host; @@ -776,6 +886,27 >> @@ static int sdhci_arasan_probe(struct platform_device *pdev) >> goto unreg_clk; >> } >> >> + if (of_device_is_compatible(pdev->dev.of_node, >> + "xlnx,zynqmp-8.9a")) { >> + ret = of_property_read_u32(pdev->dev.of_node, >> + "xlnx,mio_bank", >> + &sdhci_arasan->mio_bank); >> + if (ret < 0) { >> + dev_err(&pdev->dev, >> + "\"xlnx,mio_bank \" property is missing.\n"); >> + goto clk_disable_all; >> + } >> + ret = of_property_read_u32(pdev->dev.of_node, >> + "xlnx,device_id", >> + &sdhci_arasan->device_id); >> + if (ret < 0) { >> + dev_err(&pdev->dev, >> + "\"xlnx,device_id \" property is missing.\n"); >> + goto clk_disable_all; >> + } >> + arasan_zynqmp_dt_parse_tap_delays(&pdev->dev); >> + } >> + >> sdhci_arasan->phy = ERR_PTR(-ENODEV); >> if (of_device_is_compatible(pdev->dev.of_node, >> "arasan,sdhci-5.1")) { >> -- >> 2.7.4 > > -- To unsubscribe from this list: send the line "unsubscribe linux-mmc" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
SGkgQWRyaWFuLA0KDQo+IC0tLS0tT3JpZ2luYWwgTWVzc2FnZS0tLS0tDQo+IEZyb206IEFkcmlh biBIdW50ZXIgW21haWx0bzphZHJpYW4uaHVudGVyQGludGVsLmNvbV0NCj4gU2VudDogVHVlc2Rh eSwgSnVuZSAxOSwgMjAxOCA1OjA4IFBNDQo+IFRvOiBNYW5pc2ggTmFyYW5pIDxNTkFSQU5JQHhp bGlueC5jb20+OyByb2JoK2R0QGtlcm5lbC5vcmc7DQo+IGNhdGFsaW4ubWFyaW5hc0Bhcm0uY29t OyB3aWxsLmRlYWNvbkBhcm0uY29tOyBtZGZAa2VybmVsLm9yZzsNCj4gc3RlZmFuLmtyc21hbm92 aWNAYWdnaW9zLmNvbTsgbGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZyYWRlYWQub3JnOyBsaW51 eC0NCj4ga2VybmVsQHZnZXIua2VybmVsLm9yZzsgbGludXgtbW1jQHZnZXIua2VybmVsLm9yZzsN Cj4gZGV2aWNldHJlZUB2Z2VyLmtlcm5lbC5vcmc7IE1pY2hhbCBTaW1layA8bWljaGFsc0B4aWxp bnguY29tPjsNCj4gdWxmLmhhbnNzb25AbGluYXJvLm9yZw0KPiBDYzogU3Jpbml2YXMgR291ZCA8 c2dvdWRAeGlsaW54LmNvbT47IEFuaXJ1ZGhhIFNhcmFuZ2kNCj4gPGFuaXJ1ZGhAeGlsaW54LmNv bT4NCj4gU3ViamVjdDogUmU6IFtSRkMgUEFUQ0ggMy8zXSBzZGhjaTogYXJhc2FuOiBBZGQgc3Vw cG9ydCB0byByZWFkIFRhcCBEZWxheQ0KPiB2YWx1ZXMgZnJvbSBEVA0KPiANCj4gT24gMTQvMDYv MTggMDg6MzgsIE1hbmlzaCBOYXJhbmkgd3JvdGU6DQo+ID4gUGluZyBmb3IgUkZDDQo+IA0KPiBX aGF0IGlzIGVlbWk/ICBXaHkgYXJlbid0IHRoZXJlIHBhdGNoZXMgZm9yIHRoYXQ/DQpFZW1pKEV4 dGVuc2libGUgRW5lcmd5IE1hbmFnZW1lbnQgSW50ZXJmYWNlKSBpcyBhIHBvd2VyIG1hbmFnZW1l bnQgaW50ZXJmYWNlIGZvciBaeW5xTVAgY29yZS4gVGhlIHBhdGNoZXMgZm9yIHRoZSBzYW1lIGFy ZSBhbHJlYWR5IGluIHByb2Nlc3Mgb2YgbWFpbmxpbmluZy4gDQpodHRwczovL2xrbWwub3JnL2xr bWwvMjAxOC82LzIwLzgyMw0KDQpUaGFua3MsDQpNYW5pc2gNCj4gDQo+ID4NCj4gPj4gLS0tLS1P cmlnaW5hbCBNZXNzYWdlLS0tLS0NCj4gPj4gRnJvbTogTWFuaXNoIE5hcmFuaSBbbWFpbHRvOm1h bmlzaC5uYXJhbmlAeGlsaW54LmNvbV0NCj4gPj4gU2VudDogVGh1cnNkYXksIEp1bmUgNywgMjAx OCA1OjQyIFBNDQo+ID4+IFRvOiByb2JoK2R0QGtlcm5lbC5vcmc7IG1hcmsucnV0bGFuZEBhcm0u Y29tOw0KPiA+PiBjYXRhbGluLm1hcmluYXNAYXJtLmNvbTsgd2lsbC5kZWFjb25AYXJtLmNvbTsg bWRmQGtlcm5lbC5vcmc7DQo+ID4+IHN0ZWZhbi5rcnNtYW5vdmljQGFnZ2lvcy5jb207IGxpbnV4 LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZzsNCj4gPj4gbGludXgta2VybmVsQHZnZXIu a2VybmVsLm9yZzsgbGludXgtIG1tY0B2Z2VyLmtlcm5lbC5vcmc7DQo+ID4+IGRldmljZXRyZWVA dmdlci5rZXJuZWwub3JnOyBhZHJpYW4uaHVudGVyQGludGVsLmNvbTsNCj4gPj4gbWljaGFsLnNp bWVrQHhpbGlueC5jb207IHVsZi5oYW5zc29uQGxpbmFyby5vcmcNCj4gPj4gQ2M6IE1hbmlzaCBO YXJhbmkgPE1OQVJBTklAeGlsaW54LmNvbT4NCj4gPj4gU3ViamVjdDogW1JGQyBQQVRDSCAzLzNd IHNkaGNpOiBhcmFzYW46IEFkZCBzdXBwb3J0IHRvIHJlYWQgVGFwIERlbGF5DQo+ID4+IHZhbHVl cyBmcm9tIERUDQo+ID4+DQo+ID4+IFRoaXMgcGF0Y2ggYWRkcyBzdXBwb3J0IGZvciByZWFkaW5n IFRhcCBEZWxheSB2YWx1ZXMgZnJvbSBEZXZpY2UgVHJlZQ0KPiA+PiBhbmQgd3JpdGUgdGhlbSB2 aWEgZWVtaSBjYWxscy4gVGhlIG1hY3JvcyBjb250YWluaW5nIHRoZXNlIHRhcCBkZWxheQ0KPiA+ PiB2YWx1ZXMgYXJlIHJlbW92ZWQgZnJvbSB0aGUgZHJpdmVyLg0KPiA+Pg0KPiA+PiBTaWduZWQt b2ZmLWJ5OiBNYW5pc2ggTmFyYW5pIDxtYW5pc2gubmFyYW5pQHhpbGlueC5jb20+DQo+ID4+IC0t LQ0KPiA+PiAgZHJpdmVycy9tbWMvaG9zdC9zZGhjaS1vZi1hcmFzYW4uYyB8IDEzMQ0KPiA+PiAr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrDQo+ID4+ICAxIGZpbGUgY2hhbmdl ZCwgMTMxIGluc2VydGlvbnMoKykNCj4gPj4NCj4gPj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbW1j L2hvc3Qvc2RoY2ktb2YtYXJhc2FuLmMNCj4gPj4gYi9kcml2ZXJzL21tYy9ob3N0L3NkaGNpLSBv Zi1hcmFzYW4uYyBpbmRleCBlMzMzMmE1Li5mYzBmZDAxIDEwMDY0NA0KPiA+PiAtLS0gYS9kcml2 ZXJzL21tYy9ob3N0L3NkaGNpLW9mLWFyYXNhbi5jDQo+ID4+ICsrKyBiL2RyaXZlcnMvbW1jL2hv c3Qvc2RoY2ktb2YtYXJhc2FuLmMNCj4gPj4gQEAgLTM2LDYgKzM2LDggQEANCj4gPj4NCj4gPj4g ICNkZWZpbmUgUEhZX0NMS19UT09fU0xPV19IWgkJNDAwMDAwDQo+ID4+DQo+ID4+ICsjZGVmaW5l IE1NQ19CQU5LMgkJMHgyDQo+ID4+ICsNCj4gPj4gIC8qDQo+ID4+ICAgKiBPbiBzb21lIFNvQ3Mg dGhlIHN5c2NvbiBhcmVhIGhhcyBhIGZlYXR1cmUgd2hlcmUgdGhlIHVwcGVyIDE2LWJpdHMgb2YN Cj4gPj4gICAqIGVhY2ggMzItYml0IHJlZ2lzdGVyIGFjdCBhcyBhIHdyaXRlIG1hc2sgZm9yIHRo ZSBsb3dlciAxNi1iaXRzLg0KPiA+PiBUaGlzIGFsbG93cyBAQCAtOTAsNiArOTIsMTAgQEAgc3Ry dWN0IHNkaGNpX2FyYXNhbl9kYXRhIHsNCj4gPj4gIAlzdHJ1Y3Qgc2RoY2lfaG9zdCAqaG9zdDsN Cj4gPj4gIAlzdHJ1Y3QgY2xrCSpjbGtfYWhiOw0KPiA+PiAgCXN0cnVjdCBwaHkJKnBoeTsNCj4g Pj4gKwl1MzIgbWlvX2Jhbms7DQo+ID4+ICsJdTMyIGRldmljZV9pZDsNCj4gPj4gKwl1MzIgaXRh cGRseVtNTUNfVElNSU5HX01NQ19IUzQwMCArIDFdOw0KPiA+PiArCXUzMiBvdGFwZGx5W01NQ19U SU1JTkdfTU1DX0hTNDAwICsgMV07DQo+ID4+ICAJYm9vbAkJaXNfcGh5X29uOw0KPiA+Pg0KPiA+ PiAgCWJvb2wJCWhhc19jcWU7DQo+ID4+IEBAIC0xNjAsMTEgKzE2NiwzNiBAQCBzdGF0aWMgaW50 IHNkaGNpX2FyYXNhbl9zeXNjb25fd3JpdGUoc3RydWN0DQo+ID4+IHNkaGNpX2hvc3QgKmhvc3Qs DQo+ID4+ICAJcmV0dXJuIHJldDsNCj4gPj4gIH0NCj4gPj4NCj4gPj4gKy8qKg0KPiA+PiArICog YXJhc2FuX3p5bnFtcF9zZXRfdGFwX2RlbGF5IC0gUHJvZ3JhbSB0aGUgdGFwIGRlbGF5cy4NCj4g Pj4gKyAqIEBkZXZpY2VpZDoJCVVuaXF1ZSBJZCBvZiBkZXZpY2UNCj4gPj4gKyAqIEBpdGFwX2Rl bGF5OgkJSW5wdXQgVGFwIERlbGF5DQo+ID4+ICsgKiBAb2l0YXBfZGVsYXk6CU91dHB1dCBUYXAg RGVsYXkNCj4gPj4gKyAqLw0KPiA+PiArc3RhdGljIHZvaWQgYXJhc2FuX3p5bnFtcF9zZXRfdGFw X2RlbGF5KHU4IGRldmljZWlkLCB1OCBpdGFwX2RlbGF5LA0KPiA+PiArdTgNCj4gPj4gK290YXBf ZGVsYXkpIHsNCj4gPj4gKwljb25zdCBzdHJ1Y3QgenlucW1wX2VlbWlfb3BzICplZW1pX29wcyA9 DQo+ID4+IHp5bnFtcF9wbV9nZXRfZWVtaV9vcHMoKTsNCj4gPj4gKwl1MzIgbm9kZV9pZCA9IChk ZXZpY2VpZCA9PSAwKSA/IE5PREVfU0RfMCA6IE5PREVfU0RfMTsNCj4gPj4gKw0KPiA+PiArCWlm ICghZWVtaV9vcHMgfHwgIWVlbWlfb3BzLT5pb2N0bCkNCj4gPj4gKwkJcmV0dXJuOw0KPiA+PiAr DQo+ID4+ICsJaWYgKGl0YXBfZGVsYXkpDQo+ID4+ICsJCWVlbWlfb3BzLT5pb2N0bChub2RlX2lk LCBJT0NUTF9TRVRfU0RfVEFQREVMQVksDQo+ID4+ICsJCQkJUE1fVEFQREVMQVlfSU5QVVQsIGl0 YXBfZGVsYXksIE5VTEwpOw0KPiA+PiArDQo+ID4+ICsJaWYgKG90YXBfZGVsYXkpDQo+ID4+ICsJ CWVlbWlfb3BzLT5pb2N0bChub2RlX2lkLCBJT0NUTF9TRVRfU0RfVEFQREVMQVksDQo+ID4+ICsJ CQkJUE1fVEFQREVMQVlfT1VUUFVULCBvdGFwX2RlbGF5LCBOVUxMKTsNCj4gPj4gfQ0KPiA+PiAr DQo+ID4+ICBzdGF0aWMgdm9pZCBzZGhjaV9hcmFzYW5fc2V0X2Nsb2NrKHN0cnVjdCBzZGhjaV9o b3N0ICpob3N0LCB1bnNpZ25lZA0KPiA+PiBpbnQNCj4gPj4gY2xvY2spICB7DQo+ID4+ICAJc3Ry dWN0IHNkaGNpX3BsdGZtX2hvc3QgKnBsdGZtX2hvc3QgPSBzZGhjaV9wcml2KGhvc3QpOw0KPiA+ PiAgCXN0cnVjdCBzZGhjaV9hcmFzYW5fZGF0YSAqc2RoY2lfYXJhc2FuID0NCj4gPj4gc2RoY2lf cGx0Zm1fcHJpdihwbHRmbV9ob3N0KTsNCj4gPj4gIAlib29sIGN0cmxfcGh5ID0gZmFsc2U7DQo+ ID4+ICsJdTggaXRhcF9kZWxheTsNCj4gPj4gKwl1OCBvdGFwX2RlbGF5Ow0KPiA+Pg0KPiA+PiAg CWlmICghSVNfRVJSKHNkaGNpX2FyYXNhbi0+cGh5KSkgew0KPiA+PiAgCQlpZiAoIXNkaGNpX2Fy YXNhbi0+aXNfcGh5X29uICYmIGNsb2NrIDw9DQo+ID4+IFBIWV9DTEtfVE9PX1NMT1dfSFopIHsg QEAgLTIwMCw2ICsyMzEsMTYgQEAgc3RhdGljIHZvaWQNCj4gPj4gc2RoY2lfYXJhc2FuX3NldF9j bG9jayhzdHJ1Y3Qgc2RoY2lfaG9zdCAqaG9zdCwgdW5zaWduZWQgaW50IGNsb2NrKQ0KPiA+PiAg CQl9DQo+ID4+ICAJfQ0KPiA+Pg0KPiA+PiArCWlmIChob3N0LT52ZXJzaW9uID49IFNESENJX1NQ RUNfMzAwKSB7DQo+ID4+ICsJCWlmICgoaG9zdC0+dGltaW5nICE9IE1NQ19USU1JTkdfTEVHQUNZ KSAmJg0KPiA+PiArCQkJKGhvc3QtPnRpbWluZyAhPSBNTUNfVElNSU5HX1VIU19TRFIxMikpIHsN Cj4gPj4gKwkJCWl0YXBfZGVsYXkgPSBzZGhjaV9hcmFzYW4tPml0YXBkbHlbaG9zdC0+dGltaW5n XTsNCj4gPj4gKwkJCW90YXBfZGVsYXkgPSBzZGhjaV9hcmFzYW4tPm90YXBkbHlbaG9zdC0+dGlt aW5nXTsNCj4gPj4gKwkJCWFyYXNhbl96eW5xbXBfc2V0X3RhcF9kZWxheShzZGhjaV9hcmFzYW4t DQo+ID4+PiBkZXZpY2VfaWQsDQo+ID4+ICsJCQkJCQkgICAgaXRhcF9kZWxheSwgb3RhcF9kZWxh eSk7DQo+ID4+ICsJCX0NCj4gPj4gKwl9DQo+ID4+ICsNCj4gPj4gIAlpZiAoY3RybF9waHkgJiYg c2RoY2lfYXJhc2FuLT5pc19waHlfb24pIHsNCj4gPj4gIAkJcGh5X3Bvd2VyX29mZihzZGhjaV9h cmFzYW4tPnBoeSk7DQo+ID4+ICAJCXNkaGNpX2FyYXNhbi0+aXNfcGh5X29uID0gZmFsc2U7DQo+ ID4+IEBAIC00NTYsNiArNDk3LDcgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQN Cj4gPj4gc2RoY2lfYXJhc2FuX29mX21hdGNoW10gPSB7DQo+ID4+ICAJeyAuY29tcGF0aWJsZSA9 ICJhcmFzYW4sc2RoY2ktOC45YSIgfSwNCj4gPj4gIAl7IC5jb21wYXRpYmxlID0gImFyYXNhbixz ZGhjaS01LjEiIH0sDQo+ID4+ICAJeyAuY29tcGF0aWJsZSA9ICJhcmFzYW4sc2RoY2ktNC45YSIg fSwNCj4gPj4gKwl7IC5jb21wYXRpYmxlID0gInhsbngsenlucW1wLTguOWEiIH0sDQo+ID4+DQo+ ID4+ICAJeyAvKiBzZW50aW5lbCAqLyB9DQo+ID4+ICB9Ow0KPiA+PiBAQCAtNjQxLDYgKzY4Myw3 NCBAQCBzdGF0aWMgdm9pZCBzZGhjaV9hcmFzYW5fdW5yZWdpc3Rlcl9zZGNsayhzdHJ1Y3QNCj4g Pj4gZGV2aWNlICpkZXYpDQo+ID4+ICAJb2ZfY2xrX2RlbF9wcm92aWRlcihkZXYtPm9mX25vZGUp Ow0KPiA+PiAgfQ0KPiA+Pg0KPiA+PiArLyoqDQo+ID4+ICsgKiBhcmFzYW5fenlucW1wX2R0X3Bh cnNlX3RhcF9kZWxheXMgLSBSZWFkIFRhcCBEZWxheSB2YWx1ZXMgZnJvbSBEVA0KPiA+PiArICoN Cj4gPj4gKyAqIENhbGxlZCBhdCBpbml0aWFsaXphdGlvbiB0byBwYXJzZSB0aGUgdmFsdWVzIG9m IFRhcCBEZWxheXMuDQo+ID4+ICsgKg0KPiA+PiArICogQGRldjoJCVBvaW50ZXIgdG8gb3VyIHN0 cnVjdCBkZXZpY2UuDQo+ID4+ICsgKi8NCj4gPj4gK3N0YXRpYyB2b2lkIGFyYXNhbl96eW5xbXBf ZHRfcGFyc2VfdGFwX2RlbGF5cyhzdHJ1Y3QgZGV2aWNlICpkZXYpIHsNCj4gPj4gKwlzdHJ1Y3Qg cGxhdGZvcm1fZGV2aWNlICpwZGV2ID0gdG9fcGxhdGZvcm1fZGV2aWNlKGRldik7DQo+ID4+ICsJ c3RydWN0IHNkaGNpX2hvc3QgKmhvc3QgPSBwbGF0Zm9ybV9nZXRfZHJ2ZGF0YShwZGV2KTsNCj4g Pj4gKwlzdHJ1Y3Qgc2RoY2lfcGx0Zm1faG9zdCAqcGx0Zm1faG9zdCA9IHNkaGNpX3ByaXYoaG9z dCk7DQo+ID4+ICsJc3RydWN0IHNkaGNpX2FyYXNhbl9kYXRhICpzZGhjaV9hcmFzYW4gPQ0KPiA+ PiBzZGhjaV9wbHRmbV9wcml2KHBsdGZtX2hvc3QpOw0KPiA+PiArCXN0cnVjdCBkZXZpY2Vfbm9k ZSAqbnAgPSBkZXYtPm9mX25vZGU7DQo+ID4+ICsNCj4gPj4gKwlvZl9wcm9wZXJ0eV9yZWFkX3Uz MihucCwgInhsbngsaXRhcF9kZWxheV9zZF9oc2QiLA0KPiA+PiArCQkJICAgICAmc2RoY2lfYXJh c2FuLT5pdGFwZGx5W01NQ19USU1JTkdfU0RfSFNdKTsNCj4gPj4gKwlvZl9wcm9wZXJ0eV9yZWFk X3UzMihucCwgInhsbngsb3RhcF9kZWxheV9zZF9oc2QiLA0KPiA+PiArCQkJICAgICAmc2RoY2lf YXJhc2FuLT5vdGFwZGx5W01NQ19USU1JTkdfU0RfSFNdKTsNCj4gPj4gKwlvZl9wcm9wZXJ0eV9y ZWFkX3UzMihucCwgInhsbngsaXRhcF9kZWxheV9zZHIyNSIsDQo+ID4+ICsJCQkgICAgICZzZGhj aV9hcmFzYW4tDQo+ID4+PiBpdGFwZGx5W01NQ19USU1JTkdfVUhTX1NEUjI1XSk7DQo+ID4+ICsJ b2ZfcHJvcGVydHlfcmVhZF91MzIobnAsICJ4bG54LG90YXBfZGVsYXlfc2RyMjUiLA0KPiA+PiAr CQkJICAgICAmc2RoY2lfYXJhc2FuLQ0KPiA+Pj4gb3RhcGRseVtNTUNfVElNSU5HX1VIU19TRFIy NV0pOw0KPiA+PiArCW9mX3Byb3BlcnR5X3JlYWRfdTMyKG5wLCAieGxueCxpdGFwX2RlbGF5X3Nk cjUwIiwNCj4gPj4gKwkJCSAgICAgJnNkaGNpX2FyYXNhbi0NCj4gPj4+IGl0YXBkbHlbTU1DX1RJ TUlOR19VSFNfU0RSNTBdKTsNCj4gPj4gKwlvZl9wcm9wZXJ0eV9yZWFkX3UzMihucCwgInhsbngs b3RhcF9kZWxheV9zZHI1MCIsDQo+ID4+ICsJCQkgICAgICZzZGhjaV9hcmFzYW4tDQo+ID4+PiBv dGFwZGx5W01NQ19USU1JTkdfVUhTX1NEUjUwXSk7DQo+ID4+ICsJb2ZfcHJvcGVydHlfcmVhZF91 MzIobnAsICJ4bG54LGl0YXBfZGVsYXlfc2RfZGRyNTAiLA0KPiA+PiArCQkJICAgICAmc2RoY2lf YXJhc2FuLQ0KPiA+Pj4gaXRhcGRseVtNTUNfVElNSU5HX1VIU19ERFI1MF0pOw0KPiA+PiArCW9m X3Byb3BlcnR5X3JlYWRfdTMyKG5wLCAieGxueCxvdGFwX2RlbGF5X3NkX2RkcjUwIiwNCj4gPj4g KwkJCSAgICAgJnNkaGNpX2FyYXNhbi0NCj4gPj4+IG90YXBkbHlbTU1DX1RJTUlOR19VSFNfRERS NTBdKTsNCj4gPj4gKwlvZl9wcm9wZXJ0eV9yZWFkX3UzMihucCwgInhsbngsaXRhcF9kZWxheV9t bWNfaHNkIiwNCj4gPj4gKwkJCSAgICAgJnNkaGNpX2FyYXNhbi0NCj4gPj4+IGl0YXBkbHlbTU1D X1RJTUlOR19NTUNfSFNdKTsNCj4gPj4gKwlvZl9wcm9wZXJ0eV9yZWFkX3UzMihucCwgInhsbngs b3RhcF9kZWxheV9tbWNfaHNkIiwNCj4gPj4gKwkJCSAgICAgJnNkaGNpX2FyYXNhbi0NCj4gPj4+ IG90YXBkbHlbTU1DX1RJTUlOR19NTUNfSFNdKTsNCj4gPj4gKwlvZl9wcm9wZXJ0eV9yZWFkX3Uz MihucCwgInhsbngsaXRhcF9kZWxheV9tbWNfZGRyNTAiLA0KPiA+PiArCQkJICAgICAmc2RoY2lf YXJhc2FuLQ0KPiA+Pj4gaXRhcGRseVtNTUNfVElNSU5HX01NQ19ERFI1Ml0pOw0KPiA+PiArCW9m X3Byb3BlcnR5X3JlYWRfdTMyKG5wLCAieGxueCxvdGFwX2RlbGF5X21tY19kZHI1MCIsDQo+ID4+ ICsJCQkgICAgICZzZGhjaV9hcmFzYW4tDQo+ID4+PiBvdGFwZGx5W01NQ19USU1JTkdfTU1DX0RE UjUyXSk7DQo+ID4+ICsJaWYgKHNkaGNpX2FyYXNhbi0+bWlvX2JhbmsgPT0gTU1DX0JBTksyKSB7 DQo+ID4+ICsJCW9mX3Byb3BlcnR5X3JlYWRfdTMyKG5wLA0KPiA+PiArCQkJCSAgICAgInhsbngs aXRhcF9kZWxheV9zZHIxMDRfYjIiLA0KPiA+PiArCQkJCSZzZGhjaV9hcmFzYW4tDQo+ID4+PiBp dGFwZGx5W01NQ19USU1JTkdfVUhTX1NEUjEwNF0pOw0KPiA+PiArCQlvZl9wcm9wZXJ0eV9yZWFk X3UzMihucCwNCj4gPj4gKwkJCQkgICAgICJ4bG54LG90YXBfZGVsYXlfc2RyMTA0X2IyIiwNCj4g Pj4gKwkJCQkmc2RoY2lfYXJhc2FuLQ0KPiA+Pj4gb3RhcGRseVtNTUNfVElNSU5HX1VIU19TRFIx MDRdKTsNCj4gPj4gKwkJb2ZfcHJvcGVydHlfcmVhZF91MzIobnAsDQo+ID4+ICsJCQkJICAgICAi eGxueCxpdGFwX2RlbGF5X21tY19oczIwMF9iMiIsDQo+ID4+ICsJCQkJJnNkaGNpX2FyYXNhbi0N Cj4gPj4+IGl0YXBkbHlbTU1DX1RJTUlOR19NTUNfSFMyMDBdKTsNCj4gPj4gKwkJb2ZfcHJvcGVy dHlfcmVhZF91MzIobnAsDQo+ID4+ICsJCQkJICAgICAieGxueCxvdGFwX2RlbGF5X21tY19oczIw MF9iMiIsDQo+ID4+ICsJCQkJJnNkaGNpX2FyYXNhbi0NCj4gPj4+IG90YXBkbHlbTU1DX1RJTUlO R19NTUNfSFMyMDBdKTsNCj4gPj4gKwl9IGVsc2Ugew0KPiA+PiArCQlvZl9wcm9wZXJ0eV9yZWFk X3UzMihucCwNCj4gPj4gKwkJCQkgICAgICJ4bG54LGl0YXBfZGVsYXlfc2RyMTA0X2IwIiwNCj4g Pj4gKwkJCQkmc2RoY2lfYXJhc2FuLQ0KPiA+Pj4gaXRhcGRseVtNTUNfVElNSU5HX1VIU19TRFIx MDRdKTsNCj4gPj4gKwkJb2ZfcHJvcGVydHlfcmVhZF91MzIobnAsDQo+ID4+ICsJCQkJICAgICAi eGxueCxvdGFwX2RlbGF5X3NkcjEwNF9iMCIsDQo+ID4+ICsJCQkJJnNkaGNpX2FyYXNhbi0NCj4g Pj4+IG90YXBkbHlbTU1DX1RJTUlOR19VSFNfU0RSMTA0XSk7DQo+ID4+ICsJCW9mX3Byb3BlcnR5 X3JlYWRfdTMyKG5wLA0KPiA+PiArCQkJCSAgICAgInhsbngsaXRhcF9kZWxheV9tbWNfaHMyMDBf YjAiLA0KPiA+PiArCQkJCSZzZGhjaV9hcmFzYW4tDQo+ID4+PiBpdGFwZGx5W01NQ19USU1JTkdf TU1DX0hTMjAwXSk7DQo+ID4+ICsJCW9mX3Byb3BlcnR5X3JlYWRfdTMyKG5wLA0KPiA+PiArCQkJ CSAgICAgInhsbngsb3RhcF9kZWxheV9tbWNfaHMyMDBfYjAiLA0KPiA+PiArCQkJCSZzZGhjaV9h cmFzYW4tDQo+ID4+PiBvdGFwZGx5W01NQ19USU1JTkdfTU1DX0hTMjAwXSk7DQo+ID4+ICsJfQ0K PiA+PiArfQ0KPiA+PiArDQo+ID4+ICBzdGF0aWMgaW50IHNkaGNpX2FyYXNhbl9hZGRfaG9zdChz dHJ1Y3Qgc2RoY2lfYXJhc2FuX2RhdGEgKnNkaGNpX2FyYXNhbikgIHsNCj4gPj4gIAlzdHJ1Y3Qg c2RoY2lfaG9zdCAqaG9zdCA9IHNkaGNpX2FyYXNhbi0+aG9zdDsgQEAgLTc3Niw2ICs4ODYsMjcg QEANCj4gPj4gc3RhdGljIGludCBzZGhjaV9hcmFzYW5fcHJvYmUoc3RydWN0IHBsYXRmb3JtX2Rl dmljZSAqcGRldikNCj4gPj4gIAkJZ290byB1bnJlZ19jbGs7DQo+ID4+ICAJfQ0KPiA+Pg0KPiA+ PiArCWlmIChvZl9kZXZpY2VfaXNfY29tcGF0aWJsZShwZGV2LT5kZXYub2Zfbm9kZSwNCj4gPj4g KwkJCQkgICAgInhsbngsenlucW1wLTguOWEiKSkgew0KPiA+PiArCQlyZXQgPSBvZl9wcm9wZXJ0 eV9yZWFkX3UzMihwZGV2LT5kZXYub2Zfbm9kZSwNCj4gPj4gKwkJCQkJICAgInhsbngsbWlvX2Jh bmsiLA0KPiA+PiArCQkJCQkgICAmc2RoY2lfYXJhc2FuLT5taW9fYmFuayk7DQo+ID4+ICsJCWlm IChyZXQgPCAwKSB7DQo+ID4+ICsJCQlkZXZfZXJyKCZwZGV2LT5kZXYsDQo+ID4+ICsJCQkJIlwi eGxueCxtaW9fYmFuayBcIiBwcm9wZXJ0eSBpcyBtaXNzaW5nLlxuIik7DQo+ID4+ICsJCQlnb3Rv IGNsa19kaXNhYmxlX2FsbDsNCj4gPj4gKwkJfQ0KPiA+PiArCQlyZXQgPSBvZl9wcm9wZXJ0eV9y ZWFkX3UzMihwZGV2LT5kZXYub2Zfbm9kZSwNCj4gPj4gKwkJCQkJICAgInhsbngsZGV2aWNlX2lk IiwNCj4gPj4gKwkJCQkJICAgJnNkaGNpX2FyYXNhbi0+ZGV2aWNlX2lkKTsNCj4gPj4gKwkJaWYg KHJldCA8IDApIHsNCj4gPj4gKwkJCWRldl9lcnIoJnBkZXYtPmRldiwNCj4gPj4gKwkJCQkiXCJ4 bG54LGRldmljZV9pZCBcIiBwcm9wZXJ0eSBpcyBtaXNzaW5nLlxuIik7DQo+ID4+ICsJCQlnb3Rv IGNsa19kaXNhYmxlX2FsbDsNCj4gPj4gKwkJfQ0KPiA+PiArCQlhcmFzYW5fenlucW1wX2R0X3Bh cnNlX3RhcF9kZWxheXMoJnBkZXYtPmRldik7DQo+ID4+ICsJfQ0KPiA+PiArDQo+ID4+ICAJc2Ro Y2lfYXJhc2FuLT5waHkgPSBFUlJfUFRSKC1FTk9ERVYpOw0KPiA+PiAgCWlmIChvZl9kZXZpY2Vf aXNfY29tcGF0aWJsZShwZGV2LT5kZXYub2Zfbm9kZSwNCj4gPj4gIAkJCQkgICAgImFyYXNhbixz ZGhjaS01LjEiKSkgew0KPiA+PiAtLQ0KPiA+PiAyLjcuNA0KPiA+DQo+ID4NCg0K -- To unsubscribe from this list: send the line "unsubscribe linux-mmc" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
UGluZw0KDQo+IC0tLS0tT3JpZ2luYWwgTWVzc2FnZS0tLS0tDQo+IEZyb206IE1hbmlzaCBOYXJh bmkNCj4gU2VudDogVGh1cnNkYXksIEp1bmUgMjEsIDIwMTggNjoyNSBQTQ0KPiBUbzogQWRyaWFu IEh1bnRlciA8YWRyaWFuLmh1bnRlckBpbnRlbC5jb20+OyByb2JoK2R0QGtlcm5lbC5vcmc7DQo+ IGNhdGFsaW4ubWFyaW5hc0Bhcm0uY29tOyB3aWxsLmRlYWNvbkBhcm0uY29tOyBtZGZAa2VybmVs Lm9yZzsNCj4gc3RlZmFuLmtyc21hbm92aWNAYWdnaW9zLmNvbTsgbGludXgtYXJtLWtlcm5lbEBs aXN0cy5pbmZyYWRlYWQub3JnOyBsaW51eC0NCj4ga2VybmVsQHZnZXIua2VybmVsLm9yZzsgbGlu dXgtbW1jQHZnZXIua2VybmVsLm9yZzsNCj4gZGV2aWNldHJlZUB2Z2VyLmtlcm5lbC5vcmc7IE1p Y2hhbCBTaW1layA8bWljaGFsc0B4aWxpbnguY29tPjsNCj4gdWxmLmhhbnNzb25AbGluYXJvLm9y Zw0KPiBDYzogU3Jpbml2YXMgR291ZCA8c2dvdWRAeGlsaW54LmNvbT47IEFuaXJ1ZGhhIFNhcmFu Z2kNCj4gPGFuaXJ1ZGhAeGlsaW54LmNvbT4NCj4gU3ViamVjdDogUkU6IFtSRkMgUEFUQ0ggMy8z XSBzZGhjaTogYXJhc2FuOiBBZGQgc3VwcG9ydCB0byByZWFkIFRhcCBEZWxheQ0KPiB2YWx1ZXMg ZnJvbSBEVA0KPiANCj4gSGkgQWRyaWFuLA0KPiANCj4gPiAtLS0tLU9yaWdpbmFsIE1lc3NhZ2Ut LS0tLQ0KPiA+IEZyb206IEFkcmlhbiBIdW50ZXIgW21haWx0bzphZHJpYW4uaHVudGVyQGludGVs LmNvbV0NCj4gPiBTZW50OiBUdWVzZGF5LCBKdW5lIDE5LCAyMDE4IDU6MDggUE0NCj4gPiBUbzog TWFuaXNoIE5hcmFuaSA8TU5BUkFOSUB4aWxpbnguY29tPjsgcm9iaCtkdEBrZXJuZWwub3JnOw0K PiA+IGNhdGFsaW4ubWFyaW5hc0Bhcm0uY29tOyB3aWxsLmRlYWNvbkBhcm0uY29tOyBtZGZAa2Vy bmVsLm9yZzsNCj4gPiBzdGVmYW4ua3JzbWFub3ZpY0BhZ2dpb3MuY29tOyBsaW51eC1hcm0ta2Vy bmVsQGxpc3RzLmluZnJhZGVhZC5vcmc7DQo+ID4gbGludXgtIGtlcm5lbEB2Z2VyLmtlcm5lbC5v cmc7IGxpbnV4LW1tY0B2Z2VyLmtlcm5lbC5vcmc7DQo+ID4gZGV2aWNldHJlZUB2Z2VyLmtlcm5l bC5vcmc7IE1pY2hhbCBTaW1layA8bWljaGFsc0B4aWxpbnguY29tPjsNCj4gPiB1bGYuaGFuc3Nv bkBsaW5hcm8ub3JnDQo+ID4gQ2M6IFNyaW5pdmFzIEdvdWQgPHNnb3VkQHhpbGlueC5jb20+OyBB bmlydWRoYSBTYXJhbmdpDQo+ID4gPGFuaXJ1ZGhAeGlsaW54LmNvbT4NCj4gPiBTdWJqZWN0OiBS ZTogW1JGQyBQQVRDSCAzLzNdIHNkaGNpOiBhcmFzYW46IEFkZCBzdXBwb3J0IHRvIHJlYWQgVGFw DQo+ID4gRGVsYXkgdmFsdWVzIGZyb20gRFQNCj4gPg0KPiA+IE9uIDE0LzA2LzE4IDA4OjM4LCBN YW5pc2ggTmFyYW5pIHdyb3RlOg0KPiA+ID4gUGluZyBmb3IgUkZDDQo+ID4NCj4gPiBXaGF0IGlz IGVlbWk/ICBXaHkgYXJlbid0IHRoZXJlIHBhdGNoZXMgZm9yIHRoYXQ/DQo+IEVlbWkoRXh0ZW5z aWJsZSBFbmVyZ3kgTWFuYWdlbWVudCBJbnRlcmZhY2UpIGlzIGEgcG93ZXIgbWFuYWdlbWVudA0K PiBpbnRlcmZhY2UgZm9yIFp5bnFNUCBjb3JlLiBUaGUgcGF0Y2hlcyBmb3IgdGhlIHNhbWUgYXJl IGFscmVhZHkgaW4gcHJvY2VzcyBvZg0KPiBtYWlubGluaW5nLg0KPiBodHRwczovL2xrbWwub3Jn L2xrbWwvMjAxOC82LzIwLzgyMw0KPiANCj4gVGhhbmtzLA0KPiBNYW5pc2gNCj4gPg0KPiA+ID4N Cj4gPiA+PiAtLS0tLU9yaWdpbmFsIE1lc3NhZ2UtLS0tLQ0KPiA+ID4+IEZyb206IE1hbmlzaCBO YXJhbmkgW21haWx0bzptYW5pc2gubmFyYW5pQHhpbGlueC5jb21dDQo+ID4gPj4gU2VudDogVGh1 cnNkYXksIEp1bmUgNywgMjAxOCA1OjQyIFBNDQo+ID4gPj4gVG86IHJvYmgrZHRAa2VybmVsLm9y ZzsgbWFyay5ydXRsYW5kQGFybS5jb207DQo+ID4gPj4gY2F0YWxpbi5tYXJpbmFzQGFybS5jb207 IHdpbGwuZGVhY29uQGFybS5jb207IG1kZkBrZXJuZWwub3JnOw0KPiA+ID4+IHN0ZWZhbi5rcnNt YW5vdmljQGFnZ2lvcy5jb207IGxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZzsN Cj4gPiA+PiBsaW51eC1rZXJuZWxAdmdlci5rZXJuZWwub3JnOyBsaW51eC0gbW1jQHZnZXIua2Vy bmVsLm9yZzsNCj4gPiA+PiBkZXZpY2V0cmVlQHZnZXIua2VybmVsLm9yZzsgYWRyaWFuLmh1bnRl ckBpbnRlbC5jb207DQo+ID4gPj4gbWljaGFsLnNpbWVrQHhpbGlueC5jb207IHVsZi5oYW5zc29u QGxpbmFyby5vcmcNCj4gPiA+PiBDYzogTWFuaXNoIE5hcmFuaSA8TU5BUkFOSUB4aWxpbnguY29t Pg0KPiA+ID4+IFN1YmplY3Q6IFtSRkMgUEFUQ0ggMy8zXSBzZGhjaTogYXJhc2FuOiBBZGQgc3Vw cG9ydCB0byByZWFkIFRhcA0KPiA+ID4+IERlbGF5IHZhbHVlcyBmcm9tIERUDQo+ID4gPj4NCj4g PiA+PiBUaGlzIHBhdGNoIGFkZHMgc3VwcG9ydCBmb3IgcmVhZGluZyBUYXAgRGVsYXkgdmFsdWVz IGZyb20gRGV2aWNlDQo+ID4gPj4gVHJlZSBhbmQgd3JpdGUgdGhlbSB2aWEgZWVtaSBjYWxscy4g VGhlIG1hY3JvcyBjb250YWluaW5nIHRoZXNlIHRhcA0KPiA+ID4+IGRlbGF5IHZhbHVlcyBhcmUg cmVtb3ZlZCBmcm9tIHRoZSBkcml2ZXIuDQo+ID4gPj4NCj4gPiA+PiBTaWduZWQtb2ZmLWJ5OiBN YW5pc2ggTmFyYW5pIDxtYW5pc2gubmFyYW5pQHhpbGlueC5jb20+DQo+ID4gPj4gLS0tDQo+ID4g Pj4gIGRyaXZlcnMvbW1jL2hvc3Qvc2RoY2ktb2YtYXJhc2FuLmMgfCAxMzENCj4gPiA+PiArKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrDQo+ID4gPj4gIDEgZmlsZSBjaGFuZ2Vk LCAxMzEgaW5zZXJ0aW9ucygrKQ0KPiA+ID4+DQo+ID4gPj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMv bW1jL2hvc3Qvc2RoY2ktb2YtYXJhc2FuLmMNCj4gPiA+PiBiL2RyaXZlcnMvbW1jL2hvc3Qvc2Ro Y2ktIG9mLWFyYXNhbi5jIGluZGV4IGUzMzMyYTUuLmZjMGZkMDEgMTAwNjQ0DQo+ID4gPj4gLS0t IGEvZHJpdmVycy9tbWMvaG9zdC9zZGhjaS1vZi1hcmFzYW4uYw0KPiA+ID4+ICsrKyBiL2RyaXZl cnMvbW1jL2hvc3Qvc2RoY2ktb2YtYXJhc2FuLmMNCj4gPiA+PiBAQCAtMzYsNiArMzYsOCBAQA0K PiA+ID4+DQo+ID4gPj4gICNkZWZpbmUgUEhZX0NMS19UT09fU0xPV19IWgkJNDAwMDAwDQo+ID4g Pj4NCj4gPiA+PiArI2RlZmluZSBNTUNfQkFOSzIJCTB4Mg0KPiA+ID4+ICsNCj4gPiA+PiAgLyoN Cj4gPiA+PiAgICogT24gc29tZSBTb0NzIHRoZSBzeXNjb24gYXJlYSBoYXMgYSBmZWF0dXJlIHdo ZXJlIHRoZSB1cHBlciAxNi1iaXRzIG9mDQo+ID4gPj4gICAqIGVhY2ggMzItYml0IHJlZ2lzdGVy IGFjdCBhcyBhIHdyaXRlIG1hc2sgZm9yIHRoZSBsb3dlciAxNi1iaXRzLg0KPiA+ID4+IFRoaXMg YWxsb3dzIEBAIC05MCw2ICs5MiwxMCBAQCBzdHJ1Y3Qgc2RoY2lfYXJhc2FuX2RhdGEgew0KPiA+ ID4+ICAJc3RydWN0IHNkaGNpX2hvc3QgKmhvc3Q7DQo+ID4gPj4gIAlzdHJ1Y3QgY2xrCSpjbGtf YWhiOw0KPiA+ID4+ICAJc3RydWN0IHBoeQkqcGh5Ow0KPiA+ID4+ICsJdTMyIG1pb19iYW5rOw0K PiA+ID4+ICsJdTMyIGRldmljZV9pZDsNCj4gPiA+PiArCXUzMiBpdGFwZGx5W01NQ19USU1JTkdf TU1DX0hTNDAwICsgMV07DQo+ID4gPj4gKwl1MzIgb3RhcGRseVtNTUNfVElNSU5HX01NQ19IUzQw MCArIDFdOw0KPiA+ID4+ICAJYm9vbAkJaXNfcGh5X29uOw0KPiA+ID4+DQo+ID4gPj4gIAlib29s CQloYXNfY3FlOw0KPiA+ID4+IEBAIC0xNjAsMTEgKzE2NiwzNiBAQCBzdGF0aWMgaW50IHNkaGNp X2FyYXNhbl9zeXNjb25fd3JpdGUoc3RydWN0DQo+ID4gPj4gc2RoY2lfaG9zdCAqaG9zdCwNCj4g PiA+PiAgCXJldHVybiByZXQ7DQo+ID4gPj4gIH0NCj4gPiA+Pg0KPiA+ID4+ICsvKioNCj4gPiA+ PiArICogYXJhc2FuX3p5bnFtcF9zZXRfdGFwX2RlbGF5IC0gUHJvZ3JhbSB0aGUgdGFwIGRlbGF5 cy4NCj4gPiA+PiArICogQGRldmljZWlkOgkJVW5pcXVlIElkIG9mIGRldmljZQ0KPiA+ID4+ICsg KiBAaXRhcF9kZWxheToJCUlucHV0IFRhcCBEZWxheQ0KPiA+ID4+ICsgKiBAb2l0YXBfZGVsYXk6 CU91dHB1dCBUYXAgRGVsYXkNCj4gPiA+PiArICovDQo+ID4gPj4gK3N0YXRpYyB2b2lkIGFyYXNh bl96eW5xbXBfc2V0X3RhcF9kZWxheSh1OCBkZXZpY2VpZCwgdTgNCj4gPiA+PiAraXRhcF9kZWxh eSwNCj4gPiA+PiArdTgNCj4gPiA+PiArb3RhcF9kZWxheSkgew0KPiA+ID4+ICsJY29uc3Qgc3Ry dWN0IHp5bnFtcF9lZW1pX29wcyAqZWVtaV9vcHMgPQ0KPiA+ID4+IHp5bnFtcF9wbV9nZXRfZWVt aV9vcHMoKTsNCj4gPiA+PiArCXUzMiBub2RlX2lkID0gKGRldmljZWlkID09IDApID8gTk9ERV9T RF8wIDogTk9ERV9TRF8xOw0KPiA+ID4+ICsNCj4gPiA+PiArCWlmICghZWVtaV9vcHMgfHwgIWVl bWlfb3BzLT5pb2N0bCkNCj4gPiA+PiArCQlyZXR1cm47DQo+ID4gPj4gKw0KPiA+ID4+ICsJaWYg KGl0YXBfZGVsYXkpDQo+ID4gPj4gKwkJZWVtaV9vcHMtPmlvY3RsKG5vZGVfaWQsIElPQ1RMX1NF VF9TRF9UQVBERUxBWSwNCj4gPiA+PiArCQkJCVBNX1RBUERFTEFZX0lOUFVULCBpdGFwX2RlbGF5 LCBOVUxMKTsNCj4gPiA+PiArDQo+ID4gPj4gKwlpZiAob3RhcF9kZWxheSkNCj4gPiA+PiArCQll ZW1pX29wcy0+aW9jdGwobm9kZV9pZCwgSU9DVExfU0VUX1NEX1RBUERFTEFZLA0KPiA+ID4+ICsJ CQkJUE1fVEFQREVMQVlfT1VUUFVULCBvdGFwX2RlbGF5LCBOVUxMKTsNCj4gPiA+PiB9DQo+ID4g Pj4gKw0KPiA+ID4+ICBzdGF0aWMgdm9pZCBzZGhjaV9hcmFzYW5fc2V0X2Nsb2NrKHN0cnVjdCBz ZGhjaV9ob3N0ICpob3N0LA0KPiA+ID4+IHVuc2lnbmVkIGludA0KPiA+ID4+IGNsb2NrKSAgew0K PiA+ID4+ICAJc3RydWN0IHNkaGNpX3BsdGZtX2hvc3QgKnBsdGZtX2hvc3QgPSBzZGhjaV9wcml2 KGhvc3QpOw0KPiA+ID4+ICAJc3RydWN0IHNkaGNpX2FyYXNhbl9kYXRhICpzZGhjaV9hcmFzYW4g PQ0KPiA+ID4+IHNkaGNpX3BsdGZtX3ByaXYocGx0Zm1faG9zdCk7DQo+ID4gPj4gIAlib29sIGN0 cmxfcGh5ID0gZmFsc2U7DQo+ID4gPj4gKwl1OCBpdGFwX2RlbGF5Ow0KPiA+ID4+ICsJdTggb3Rh cF9kZWxheTsNCj4gPiA+Pg0KPiA+ID4+ICAJaWYgKCFJU19FUlIoc2RoY2lfYXJhc2FuLT5waHkp KSB7DQo+ID4gPj4gIAkJaWYgKCFzZGhjaV9hcmFzYW4tPmlzX3BoeV9vbiAmJiBjbG9jayA8PQ0K PiA+ID4+IFBIWV9DTEtfVE9PX1NMT1dfSFopIHsgQEAgLTIwMCw2ICsyMzEsMTYgQEAgc3RhdGlj IHZvaWQNCj4gPiA+PiBzZGhjaV9hcmFzYW5fc2V0X2Nsb2NrKHN0cnVjdCBzZGhjaV9ob3N0ICpo b3N0LCB1bnNpZ25lZCBpbnQgY2xvY2spDQo+ID4gPj4gIAkJfQ0KPiA+ID4+ICAJfQ0KPiA+ID4+ DQo+ID4gPj4gKwlpZiAoaG9zdC0+dmVyc2lvbiA+PSBTREhDSV9TUEVDXzMwMCkgew0KPiA+ID4+ ICsJCWlmICgoaG9zdC0+dGltaW5nICE9IE1NQ19USU1JTkdfTEVHQUNZKSAmJg0KPiA+ID4+ICsJ CQkoaG9zdC0+dGltaW5nICE9IE1NQ19USU1JTkdfVUhTX1NEUjEyKSkgew0KPiA+ID4+ICsJCQlp dGFwX2RlbGF5ID0gc2RoY2lfYXJhc2FuLT5pdGFwZGx5W2hvc3QtPnRpbWluZ107DQo+ID4gPj4g KwkJCW90YXBfZGVsYXkgPSBzZGhjaV9hcmFzYW4tPm90YXBkbHlbaG9zdC0+dGltaW5nXTsNCj4g PiA+PiArCQkJYXJhc2FuX3p5bnFtcF9zZXRfdGFwX2RlbGF5KHNkaGNpX2FyYXNhbi0NCj4gPiA+ Pj4gZGV2aWNlX2lkLA0KPiA+ID4+ICsJCQkJCQkgICAgaXRhcF9kZWxheSwgb3RhcF9kZWxheSk7 DQo+ID4gPj4gKwkJfQ0KPiA+ID4+ICsJfQ0KPiA+ID4+ICsNCj4gPiA+PiAgCWlmIChjdHJsX3Bo eSAmJiBzZGhjaV9hcmFzYW4tPmlzX3BoeV9vbikgew0KPiA+ID4+ICAJCXBoeV9wb3dlcl9vZmYo c2RoY2lfYXJhc2FuLT5waHkpOw0KPiA+ID4+ICAJCXNkaGNpX2FyYXNhbi0+aXNfcGh5X29uID0g ZmFsc2U7IEBAIC00NTYsNiArNDk3LDcgQEAgc3RhdGljDQo+ID4gPj4gY29uc3Qgc3RydWN0IG9m X2RldmljZV9pZCBzZGhjaV9hcmFzYW5fb2ZfbWF0Y2hbXSA9IHsNCj4gPiA+PiAgCXsgLmNvbXBh dGlibGUgPSAiYXJhc2FuLHNkaGNpLTguOWEiIH0sDQo+ID4gPj4gIAl7IC5jb21wYXRpYmxlID0g ImFyYXNhbixzZGhjaS01LjEiIH0sDQo+ID4gPj4gIAl7IC5jb21wYXRpYmxlID0gImFyYXNhbixz ZGhjaS00LjlhIiB9LA0KPiA+ID4+ICsJeyAuY29tcGF0aWJsZSA9ICJ4bG54LHp5bnFtcC04Ljlh IiB9LA0KPiA+ID4+DQo+ID4gPj4gIAl7IC8qIHNlbnRpbmVsICovIH0NCj4gPiA+PiAgfTsNCj4g PiA+PiBAQCAtNjQxLDYgKzY4Myw3NCBAQCBzdGF0aWMgdm9pZA0KPiA+ID4+IHNkaGNpX2FyYXNh bl91bnJlZ2lzdGVyX3NkY2xrKHN0cnVjdA0KPiA+ID4+IGRldmljZSAqZGV2KQ0KPiA+ID4+ICAJ b2ZfY2xrX2RlbF9wcm92aWRlcihkZXYtPm9mX25vZGUpOw0KPiA+ID4+ICB9DQo+ID4gPj4NCj4g PiA+PiArLyoqDQo+ID4gPj4gKyAqIGFyYXNhbl96eW5xbXBfZHRfcGFyc2VfdGFwX2RlbGF5cyAt IFJlYWQgVGFwIERlbGF5IHZhbHVlcyBmcm9tDQo+ID4gPj4gK0RUDQo+ID4gPj4gKyAqDQo+ID4g Pj4gKyAqIENhbGxlZCBhdCBpbml0aWFsaXphdGlvbiB0byBwYXJzZSB0aGUgdmFsdWVzIG9mIFRh cCBEZWxheXMuDQo+ID4gPj4gKyAqDQo+ID4gPj4gKyAqIEBkZXY6CQlQb2ludGVyIHRvIG91ciBz dHJ1Y3QgZGV2aWNlLg0KPiA+ID4+ICsgKi8NCj4gPiA+PiArc3RhdGljIHZvaWQgYXJhc2FuX3p5 bnFtcF9kdF9wYXJzZV90YXBfZGVsYXlzKHN0cnVjdCBkZXZpY2UgKmRldikgew0KPiA+ID4+ICsJ c3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiA9IHRvX3BsYXRmb3JtX2RldmljZShkZXYpOw0K PiA+ID4+ICsJc3RydWN0IHNkaGNpX2hvc3QgKmhvc3QgPSBwbGF0Zm9ybV9nZXRfZHJ2ZGF0YShw ZGV2KTsNCj4gPiA+PiArCXN0cnVjdCBzZGhjaV9wbHRmbV9ob3N0ICpwbHRmbV9ob3N0ID0gc2Ro Y2lfcHJpdihob3N0KTsNCj4gPiA+PiArCXN0cnVjdCBzZGhjaV9hcmFzYW5fZGF0YSAqc2RoY2lf YXJhc2FuID0NCj4gPiA+PiBzZGhjaV9wbHRmbV9wcml2KHBsdGZtX2hvc3QpOw0KPiA+ID4+ICsJ c3RydWN0IGRldmljZV9ub2RlICpucCA9IGRldi0+b2Zfbm9kZTsNCj4gPiA+PiArDQo+ID4gPj4g KwlvZl9wcm9wZXJ0eV9yZWFkX3UzMihucCwgInhsbngsaXRhcF9kZWxheV9zZF9oc2QiLA0KPiA+ ID4+ICsJCQkgICAgICZzZGhjaV9hcmFzYW4tPml0YXBkbHlbTU1DX1RJTUlOR19TRF9IU10pOw0K PiA+ID4+ICsJb2ZfcHJvcGVydHlfcmVhZF91MzIobnAsICJ4bG54LG90YXBfZGVsYXlfc2RfaHNk IiwNCj4gPiA+PiArCQkJICAgICAmc2RoY2lfYXJhc2FuLT5vdGFwZGx5W01NQ19USU1JTkdfU0Rf SFNdKTsNCj4gPiA+PiArCW9mX3Byb3BlcnR5X3JlYWRfdTMyKG5wLCAieGxueCxpdGFwX2RlbGF5 X3NkcjI1IiwNCj4gPiA+PiArCQkJICAgICAmc2RoY2lfYXJhc2FuLQ0KPiA+ID4+PiBpdGFwZGx5 W01NQ19USU1JTkdfVUhTX1NEUjI1XSk7DQo+ID4gPj4gKwlvZl9wcm9wZXJ0eV9yZWFkX3UzMihu cCwgInhsbngsb3RhcF9kZWxheV9zZHIyNSIsDQo+ID4gPj4gKwkJCSAgICAgJnNkaGNpX2FyYXNh bi0NCj4gPiA+Pj4gb3RhcGRseVtNTUNfVElNSU5HX1VIU19TRFIyNV0pOw0KPiA+ID4+ICsJb2Zf cHJvcGVydHlfcmVhZF91MzIobnAsICJ4bG54LGl0YXBfZGVsYXlfc2RyNTAiLA0KPiA+ID4+ICsJ CQkgICAgICZzZGhjaV9hcmFzYW4tDQo+ID4gPj4+IGl0YXBkbHlbTU1DX1RJTUlOR19VSFNfU0RS NTBdKTsNCj4gPiA+PiArCW9mX3Byb3BlcnR5X3JlYWRfdTMyKG5wLCAieGxueCxvdGFwX2RlbGF5 X3NkcjUwIiwNCj4gPiA+PiArCQkJICAgICAmc2RoY2lfYXJhc2FuLQ0KPiA+ID4+PiBvdGFwZGx5 W01NQ19USU1JTkdfVUhTX1NEUjUwXSk7DQo+ID4gPj4gKwlvZl9wcm9wZXJ0eV9yZWFkX3UzMihu cCwgInhsbngsaXRhcF9kZWxheV9zZF9kZHI1MCIsDQo+ID4gPj4gKwkJCSAgICAgJnNkaGNpX2Fy YXNhbi0NCj4gPiA+Pj4gaXRhcGRseVtNTUNfVElNSU5HX1VIU19ERFI1MF0pOw0KPiA+ID4+ICsJ b2ZfcHJvcGVydHlfcmVhZF91MzIobnAsICJ4bG54LG90YXBfZGVsYXlfc2RfZGRyNTAiLA0KPiA+ ID4+ICsJCQkgICAgICZzZGhjaV9hcmFzYW4tDQo+ID4gPj4+IG90YXBkbHlbTU1DX1RJTUlOR19V SFNfRERSNTBdKTsNCj4gPiA+PiArCW9mX3Byb3BlcnR5X3JlYWRfdTMyKG5wLCAieGxueCxpdGFw X2RlbGF5X21tY19oc2QiLA0KPiA+ID4+ICsJCQkgICAgICZzZGhjaV9hcmFzYW4tDQo+ID4gPj4+ IGl0YXBkbHlbTU1DX1RJTUlOR19NTUNfSFNdKTsNCj4gPiA+PiArCW9mX3Byb3BlcnR5X3JlYWRf dTMyKG5wLCAieGxueCxvdGFwX2RlbGF5X21tY19oc2QiLA0KPiA+ID4+ICsJCQkgICAgICZzZGhj aV9hcmFzYW4tDQo+ID4gPj4+IG90YXBkbHlbTU1DX1RJTUlOR19NTUNfSFNdKTsNCj4gPiA+PiAr CW9mX3Byb3BlcnR5X3JlYWRfdTMyKG5wLCAieGxueCxpdGFwX2RlbGF5X21tY19kZHI1MCIsDQo+ ID4gPj4gKwkJCSAgICAgJnNkaGNpX2FyYXNhbi0NCj4gPiA+Pj4gaXRhcGRseVtNTUNfVElNSU5H X01NQ19ERFI1Ml0pOw0KPiA+ID4+ICsJb2ZfcHJvcGVydHlfcmVhZF91MzIobnAsICJ4bG54LG90 YXBfZGVsYXlfbW1jX2RkcjUwIiwNCj4gPiA+PiArCQkJICAgICAmc2RoY2lfYXJhc2FuLQ0KPiA+ ID4+PiBvdGFwZGx5W01NQ19USU1JTkdfTU1DX0REUjUyXSk7DQo+ID4gPj4gKwlpZiAoc2RoY2lf YXJhc2FuLT5taW9fYmFuayA9PSBNTUNfQkFOSzIpIHsNCj4gPiA+PiArCQlvZl9wcm9wZXJ0eV9y ZWFkX3UzMihucCwNCj4gPiA+PiArCQkJCSAgICAgInhsbngsaXRhcF9kZWxheV9zZHIxMDRfYjIi LA0KPiA+ID4+ICsJCQkJJnNkaGNpX2FyYXNhbi0NCj4gPiA+Pj4gaXRhcGRseVtNTUNfVElNSU5H X1VIU19TRFIxMDRdKTsNCj4gPiA+PiArCQlvZl9wcm9wZXJ0eV9yZWFkX3UzMihucCwNCj4gPiA+ PiArCQkJCSAgICAgInhsbngsb3RhcF9kZWxheV9zZHIxMDRfYjIiLA0KPiA+ID4+ICsJCQkJJnNk aGNpX2FyYXNhbi0NCj4gPiA+Pj4gb3RhcGRseVtNTUNfVElNSU5HX1VIU19TRFIxMDRdKTsNCj4g PiA+PiArCQlvZl9wcm9wZXJ0eV9yZWFkX3UzMihucCwNCj4gPiA+PiArCQkJCSAgICAgInhsbngs aXRhcF9kZWxheV9tbWNfaHMyMDBfYjIiLA0KPiA+ID4+ICsJCQkJJnNkaGNpX2FyYXNhbi0NCj4g PiA+Pj4gaXRhcGRseVtNTUNfVElNSU5HX01NQ19IUzIwMF0pOw0KPiA+ID4+ICsJCW9mX3Byb3Bl cnR5X3JlYWRfdTMyKG5wLA0KPiA+ID4+ICsJCQkJICAgICAieGxueCxvdGFwX2RlbGF5X21tY19o czIwMF9iMiIsDQo+ID4gPj4gKwkJCQkmc2RoY2lfYXJhc2FuLQ0KPiA+ID4+PiBvdGFwZGx5W01N Q19USU1JTkdfTU1DX0hTMjAwXSk7DQo+ID4gPj4gKwl9IGVsc2Ugew0KPiA+ID4+ICsJCW9mX3By b3BlcnR5X3JlYWRfdTMyKG5wLA0KPiA+ID4+ICsJCQkJICAgICAieGxueCxpdGFwX2RlbGF5X3Nk cjEwNF9iMCIsDQo+ID4gPj4gKwkJCQkmc2RoY2lfYXJhc2FuLQ0KPiA+ID4+PiBpdGFwZGx5W01N Q19USU1JTkdfVUhTX1NEUjEwNF0pOw0KPiA+ID4+ICsJCW9mX3Byb3BlcnR5X3JlYWRfdTMyKG5w LA0KPiA+ID4+ICsJCQkJICAgICAieGxueCxvdGFwX2RlbGF5X3NkcjEwNF9iMCIsDQo+ID4gPj4g KwkJCQkmc2RoY2lfYXJhc2FuLQ0KPiA+ID4+PiBvdGFwZGx5W01NQ19USU1JTkdfVUhTX1NEUjEw NF0pOw0KPiA+ID4+ICsJCW9mX3Byb3BlcnR5X3JlYWRfdTMyKG5wLA0KPiA+ID4+ICsJCQkJICAg ICAieGxueCxpdGFwX2RlbGF5X21tY19oczIwMF9iMCIsDQo+ID4gPj4gKwkJCQkmc2RoY2lfYXJh c2FuLQ0KPiA+ID4+PiBpdGFwZGx5W01NQ19USU1JTkdfTU1DX0hTMjAwXSk7DQo+ID4gPj4gKwkJ b2ZfcHJvcGVydHlfcmVhZF91MzIobnAsDQo+ID4gPj4gKwkJCQkgICAgICJ4bG54LG90YXBfZGVs YXlfbW1jX2hzMjAwX2IwIiwNCj4gPiA+PiArCQkJCSZzZGhjaV9hcmFzYW4tDQo+ID4gPj4+IG90 YXBkbHlbTU1DX1RJTUlOR19NTUNfSFMyMDBdKTsNCj4gPiA+PiArCX0NCj4gPiA+PiArfQ0KPiA+ ID4+ICsNCj4gPiA+PiAgc3RhdGljIGludCBzZGhjaV9hcmFzYW5fYWRkX2hvc3Qoc3RydWN0IHNk aGNpX2FyYXNhbl9kYXRhICpzZGhjaV9hcmFzYW4pDQo+IHsNCj4gPiA+PiAgCXN0cnVjdCBzZGhj aV9ob3N0ICpob3N0ID0gc2RoY2lfYXJhc2FuLT5ob3N0OyBAQCAtNzc2LDYgKzg4NiwyNw0KPiA+ ID4+IEBAIHN0YXRpYyBpbnQgc2RoY2lfYXJhc2FuX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZp Y2UgKnBkZXYpDQo+ID4gPj4gIAkJZ290byB1bnJlZ19jbGs7DQo+ID4gPj4gIAl9DQo+ID4gPj4N Cj4gPiA+PiArCWlmIChvZl9kZXZpY2VfaXNfY29tcGF0aWJsZShwZGV2LT5kZXYub2Zfbm9kZSwN Cj4gPiA+PiArCQkJCSAgICAieGxueCx6eW5xbXAtOC45YSIpKSB7DQo+ID4gPj4gKwkJcmV0ID0g b2ZfcHJvcGVydHlfcmVhZF91MzIocGRldi0+ZGV2Lm9mX25vZGUsDQo+ID4gPj4gKwkJCQkJICAg InhsbngsbWlvX2JhbmsiLA0KPiA+ID4+ICsJCQkJCSAgICZzZGhjaV9hcmFzYW4tPm1pb19iYW5r KTsNCj4gPiA+PiArCQlpZiAocmV0IDwgMCkgew0KPiA+ID4+ICsJCQlkZXZfZXJyKCZwZGV2LT5k ZXYsDQo+ID4gPj4gKwkJCQkiXCJ4bG54LG1pb19iYW5rIFwiIHByb3BlcnR5IGlzIG1pc3Npbmcu XG4iKTsNCj4gPiA+PiArCQkJZ290byBjbGtfZGlzYWJsZV9hbGw7DQo+ID4gPj4gKwkJfQ0KPiA+ ID4+ICsJCXJldCA9IG9mX3Byb3BlcnR5X3JlYWRfdTMyKHBkZXYtPmRldi5vZl9ub2RlLA0KPiA+ ID4+ICsJCQkJCSAgICJ4bG54LGRldmljZV9pZCIsDQo+ID4gPj4gKwkJCQkJICAgJnNkaGNpX2Fy YXNhbi0+ZGV2aWNlX2lkKTsNCj4gPiA+PiArCQlpZiAocmV0IDwgMCkgew0KPiA+ID4+ICsJCQlk ZXZfZXJyKCZwZGV2LT5kZXYsDQo+ID4gPj4gKwkJCQkiXCJ4bG54LGRldmljZV9pZCBcIiBwcm9w ZXJ0eSBpcyBtaXNzaW5nLlxuIik7DQo+ID4gPj4gKwkJCWdvdG8gY2xrX2Rpc2FibGVfYWxsOw0K PiA+ID4+ICsJCX0NCj4gPiA+PiArCQlhcmFzYW5fenlucW1wX2R0X3BhcnNlX3RhcF9kZWxheXMo JnBkZXYtPmRldik7DQo+ID4gPj4gKwl9DQo+ID4gPj4gKw0KPiA+ID4+ICAJc2RoY2lfYXJhc2Fu LT5waHkgPSBFUlJfUFRSKC1FTk9ERVYpOw0KPiA+ID4+ICAJaWYgKG9mX2RldmljZV9pc19jb21w YXRpYmxlKHBkZXYtPmRldi5vZl9ub2RlLA0KPiA+ID4+ICAJCQkJICAgICJhcmFzYW4sc2RoY2kt NS4xIikpIHsNCj4gPiA+PiAtLQ0KPiA+ID4+IDIuNy40DQo+ID4gPg0KPiA+ID4NCg0K -- To unsubscribe from this list: send the line "unsubscribe linux-mmc" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On 7 June 2018 at 14:11, Manish Narani <manish.narani@xilinx.com> wrote: > This patch adds support for reading Tap Delay values from Device Tree > and write them via eemi calls. The macros containing these tap delay > values are removed from the driver. > > Signed-off-by: Manish Narani <manish.narani@xilinx.com> > --- > drivers/mmc/host/sdhci-of-arasan.c | 131 +++++++++++++++++++++++++++++++++++++ > 1 file changed, 131 insertions(+) > > diff --git a/drivers/mmc/host/sdhci-of-arasan.c b/drivers/mmc/host/sdhci-of-arasan.c > index e3332a5..fc0fd01 100644 > --- a/drivers/mmc/host/sdhci-of-arasan.c > +++ b/drivers/mmc/host/sdhci-of-arasan.c > @@ -36,6 +36,8 @@ > > #define PHY_CLK_TOO_SLOW_HZ 400000 > > +#define MMC_BANK2 0x2 > + > /* > * On some SoCs the syscon area has a feature where the upper 16-bits of > * each 32-bit register act as a write mask for the lower 16-bits. This allows > @@ -90,6 +92,10 @@ struct sdhci_arasan_data { > struct sdhci_host *host; > struct clk *clk_ahb; > struct phy *phy; > + u32 mio_bank; > + u32 device_id; > + u32 itapdly[MMC_TIMING_MMC_HS400 + 1]; > + u32 otapdly[MMC_TIMING_MMC_HS400 + 1]; > bool is_phy_on; > > bool has_cqe; > @@ -160,11 +166,36 @@ static int sdhci_arasan_syscon_write(struct sdhci_host *host, > return ret; > } > > +/** > + * arasan_zynqmp_set_tap_delay - Program the tap delays. > + * @deviceid: Unique Id of device > + * @itap_delay: Input Tap Delay > + * @oitap_delay: Output Tap Delay > + */ > +static void arasan_zynqmp_set_tap_delay(u8 deviceid, u8 itap_delay, u8 otap_delay) > +{ > + const struct zynqmp_eemi_ops *eemi_ops = zynqmp_pm_get_eemi_ops(); No thanks! Isn't there a more generic framework we can use to change the tap values, rather than calling SoC specific functions from the driver? BTW, what is a tap value, more exactly? What does changing a tap value mean and where does the property belong, really? Of course this doesn't even compile, as you have a dependency to another series. Next time, please clarify that in a cover-letter (maybe you did, but I can't find it). > + u32 node_id = (deviceid == 0) ? NODE_SD_0 : NODE_SD_1; > + > + if (!eemi_ops || !eemi_ops->ioctl) > + return; > + > + if (itap_delay) > + eemi_ops->ioctl(node_id, IOCTL_SET_SD_TAPDELAY, > + PM_TAPDELAY_INPUT, itap_delay, NULL); > + > + if (otap_delay) > + eemi_ops->ioctl(node_id, IOCTL_SET_SD_TAPDELAY, > + PM_TAPDELAY_OUTPUT, otap_delay, NULL); > +} Another overall comment for the series. I would recommend to change the order of the patches in the series. Let the DT doc change come first, next the driver change and finally the change to the DTS file(s). This makes it easier to follow and review. [...] Kind regards Uffe -- To unsubscribe from this list: send the line "unsubscribe linux-mmc" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
SGkgVWZmZSwNCg0KPiAtLS0tLU9yaWdpbmFsIE1lc3NhZ2UtLS0tLQ0KPiBGcm9tOiBVbGYgSGFu c3NvbiBbbWFpbHRvOnVsZi5oYW5zc29uQGxpbmFyby5vcmddDQo+IFNlbnQ6IFR1ZXNkYXksIEp1 bHkgMTAsIDIwMTggMjowMiBQTQ0KPiBUbzogTWFuaXNoIE5hcmFuaSA8TU5BUkFOSUB4aWxpbngu Y29tPg0KPiBDYzogUm9iIEhlcnJpbmcgPHJvYmgrZHRAa2VybmVsLm9yZz47IE1hcmsgUnV0bGFu ZA0KPiA8bWFyay5ydXRsYW5kQGFybS5jb20+OyBDYXRhbGluIE1hcmluYXMgPGNhdGFsaW4ubWFy aW5hc0Bhcm0uY29tPjsgV2lsbA0KPiBEZWFjb24gPHdpbGwuZGVhY29uQGFybS5jb20+OyBNb3Jp dHogRmlzY2hlciA8bWRmQGtlcm5lbC5vcmc+Ow0KPiBzdGVmYW4ua3JzbWFub3ZpY0BhZ2dpb3Mu Y29tOyBMaW51eCBBUk0gPGxpbnV4LWFybS0NCj4ga2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmc+ OyBMaW51eCBLZXJuZWwgTWFpbGluZyBMaXN0IDxsaW51eC0NCj4ga2VybmVsQHZnZXIua2VybmVs Lm9yZz47IGxpbnV4LW1tY0B2Z2VyLmtlcm5lbC5vcmc7DQo+IGRldmljZXRyZWVAdmdlci5rZXJu ZWwub3JnOyBBZHJpYW4gSHVudGVyIDxhZHJpYW4uaHVudGVyQGludGVsLmNvbT47DQo+IE1pY2hh bCBTaW1layA8bWljaGFsc0B4aWxpbnguY29tPg0KPiBTdWJqZWN0OiBSZTogW1JGQyBQQVRDSCAz LzNdIHNkaGNpOiBhcmFzYW46IEFkZCBzdXBwb3J0IHRvIHJlYWQgVGFwIERlbGF5DQo+IHZhbHVl cyBmcm9tIERUDQo+IA0KPiBPbiA3IEp1bmUgMjAxOCBhdCAxNDoxMSwgTWFuaXNoIE5hcmFuaSA8 bWFuaXNoLm5hcmFuaUB4aWxpbnguY29tPiB3cm90ZToNCj4gPiBUaGlzIHBhdGNoIGFkZHMgc3Vw cG9ydCBmb3IgcmVhZGluZyBUYXAgRGVsYXkgdmFsdWVzIGZyb20gRGV2aWNlIFRyZWUNCj4gPiBh bmQgd3JpdGUgdGhlbSB2aWEgZWVtaSBjYWxscy4gVGhlIG1hY3JvcyBjb250YWluaW5nIHRoZXNl IHRhcCBkZWxheQ0KPiA+IHZhbHVlcyBhcmUgcmVtb3ZlZCBmcm9tIHRoZSBkcml2ZXIuDQo+ID4N Cj4gPiBTaWduZWQtb2ZmLWJ5OiBNYW5pc2ggTmFyYW5pIDxtYW5pc2gubmFyYW5pQHhpbGlueC5j b20+DQo+ID4gLS0tDQo+ID4gIGRyaXZlcnMvbW1jL2hvc3Qvc2RoY2ktb2YtYXJhc2FuLmMgfCAx MzENCj4gPiArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrDQo+ID4gIDEgZmls ZSBjaGFuZ2VkLCAxMzEgaW5zZXJ0aW9ucygrKQ0KPiA+DQo+ID4gZGlmZiAtLWdpdCBhL2RyaXZl cnMvbW1jL2hvc3Qvc2RoY2ktb2YtYXJhc2FuLmMNCj4gPiBiL2RyaXZlcnMvbW1jL2hvc3Qvc2Ro Y2ktb2YtYXJhc2FuLmMNCj4gPiBpbmRleCBlMzMzMmE1Li5mYzBmZDAxIDEwMDY0NA0KPiA+IC0t LSBhL2RyaXZlcnMvbW1jL2hvc3Qvc2RoY2ktb2YtYXJhc2FuLmMNCj4gPiArKysgYi9kcml2ZXJz L21tYy9ob3N0L3NkaGNpLW9mLWFyYXNhbi5jDQo+ID4gQEAgLTM2LDYgKzM2LDggQEANCj4gPg0K PiA+ICAjZGVmaW5lIFBIWV9DTEtfVE9PX1NMT1dfSFogICAgICAgICAgICA0MDAwMDANCj4gPg0K PiA+ICsjZGVmaW5lIE1NQ19CQU5LMiAgICAgICAgICAgICAgMHgyDQo+ID4gKw0KPiA+ICAvKg0K PiA+ICAgKiBPbiBzb21lIFNvQ3MgdGhlIHN5c2NvbiBhcmVhIGhhcyBhIGZlYXR1cmUgd2hlcmUg dGhlIHVwcGVyIDE2LWJpdHMgb2YNCj4gPiAgICogZWFjaCAzMi1iaXQgcmVnaXN0ZXIgYWN0IGFz IGEgd3JpdGUgbWFzayBmb3IgdGhlIGxvd2VyIDE2LWJpdHMuDQo+ID4gVGhpcyBhbGxvd3MgQEAg LTkwLDYgKzkyLDEwIEBAIHN0cnVjdCBzZGhjaV9hcmFzYW5fZGF0YSB7DQo+ID4gICAgICAgICBz dHJ1Y3Qgc2RoY2lfaG9zdCAqaG9zdDsNCj4gPiAgICAgICAgIHN0cnVjdCBjbGsgICAgICAqY2xr X2FoYjsNCj4gPiAgICAgICAgIHN0cnVjdCBwaHkgICAgICAqcGh5Ow0KPiA+ICsgICAgICAgdTMy IG1pb19iYW5rOw0KPiA+ICsgICAgICAgdTMyIGRldmljZV9pZDsNCj4gPiArICAgICAgIHUzMiBp dGFwZGx5W01NQ19USU1JTkdfTU1DX0hTNDAwICsgMV07DQo+ID4gKyAgICAgICB1MzIgb3RhcGRs eVtNTUNfVElNSU5HX01NQ19IUzQwMCArIDFdOw0KPiA+ICAgICAgICAgYm9vbCAgICAgICAgICAg IGlzX3BoeV9vbjsNCj4gPg0KPiA+ICAgICAgICAgYm9vbCAgICAgICAgICAgIGhhc19jcWU7DQo+ ID4gQEAgLTE2MCwxMSArMTY2LDM2IEBAIHN0YXRpYyBpbnQgc2RoY2lfYXJhc2FuX3N5c2Nvbl93 cml0ZShzdHJ1Y3QNCj4gc2RoY2lfaG9zdCAqaG9zdCwNCj4gPiAgICAgICAgIHJldHVybiByZXQ7 DQo+ID4gIH0NCj4gPg0KPiA+ICsvKioNCj4gPiArICogYXJhc2FuX3p5bnFtcF9zZXRfdGFwX2Rl bGF5IC0gUHJvZ3JhbSB0aGUgdGFwIGRlbGF5cy4NCj4gPiArICogQGRldmljZWlkOiAgICAgICAg ICBVbmlxdWUgSWQgb2YgZGV2aWNlDQo+ID4gKyAqIEBpdGFwX2RlbGF5OiAgICAgICAgICAgICAg ICBJbnB1dCBUYXAgRGVsYXkNCj4gPiArICogQG9pdGFwX2RlbGF5OiAgICAgICBPdXRwdXQgVGFw IERlbGF5DQo+ID4gKyAqLw0KPiA+ICtzdGF0aWMgdm9pZCBhcmFzYW5fenlucW1wX3NldF90YXBf ZGVsYXkodTggZGV2aWNlaWQsIHU4IGl0YXBfZGVsYXksDQo+ID4gK3U4IG90YXBfZGVsYXkpIHsN Cj4gPiArICAgICAgIGNvbnN0IHN0cnVjdCB6eW5xbXBfZWVtaV9vcHMgKmVlbWlfb3BzID0NCj4g PiArenlucW1wX3BtX2dldF9lZW1pX29wcygpOw0KPiANCj4gTm8gdGhhbmtzIQ0KPiANCj4gSXNu J3QgdGhlcmUgYSBtb3JlIGdlbmVyaWMgZnJhbWV3b3JrIHdlIGNhbiB1c2UgdG8gY2hhbmdlIHRo ZSB0YXAgdmFsdWVzLA0KPiByYXRoZXIgdGhhbiBjYWxsaW5nIFNvQyBzcGVjaWZpYyBmdW5jdGlv bnMgZnJvbSB0aGUgZHJpdmVyPw0KWWVzLCBUaGFua3MgZm9yIHlvdXIgc3VnZ2VzdGlvbi4gSSB3 aWxsIHdvcmsgb24gdGhlIGdlbmVyaWMgZnJhbWV3b3JrIHdoaWNoIHdpbGwgYmUgdXNlZCB0byBj aGFuZ2UgdGFwIHZhbHVlcw0KVmlhIFNvQyBkcml2ZXJzLg0KPiANCj4gQlRXLCB3aGF0IGlzIGEg dGFwIHZhbHVlLCBtb3JlIGV4YWN0bHk/DQo+IFdoYXQgZG9lcyBjaGFuZ2luZyBhIHRhcCB2YWx1 ZSBtZWFuIGFuZCB3aGVyZSBkb2VzIHRoZSBwcm9wZXJ0eSBiZWxvbmcsDQo+IHJlYWxseT8NClRh cCBWYWx1ZSBpcyB0aGUgZGVsYXkgb2YgY2xvY2sgcGhhc2Ugd2hpY2ggaXMgdXNlZCB0byBhZGp1 c3QgcGhhc2UgdG8gdGhlIHdvcmtpbmcgdmFsdWUuIFRoZSBhdXRvIHR1bmluZw0KcHJvY2VzcyBn ZW5lcmFsbHkgc2V0cyB0YXAgdmFsdWVzIGludGVybmFsbHkgaW4gY29udHJvbGxlciBpbiBTRCBV SFMgbW9kZXMuIEJ1dCBmb3Igb3RoZXIgbW9kZXMgd2hlcmUNCmF1dG8gdHVuaW5nIGlzIGFwcGxp Y2FibGUsIHdlIGFyZSBkZXRlcm1pbmluZyB0YXAgdmFsdWVzIHZpYSB0cmlhbCAmIGVycm9yIG1l dGhvZCBmb3Igc3BlY2lmaWMgU29DLg0KPiA+IA0KPiBPZiBjb3Vyc2UgdGhpcyBkb2Vzbid0IGV2 ZW4gY29tcGlsZSwgYXMgeW91IGhhdmUgYSBkZXBlbmRlbmN5IHRvIGFub3RoZXINCj4gc2VyaWVz LiBOZXh0IHRpbWUsIHBsZWFzZSBjbGFyaWZ5IHRoYXQgaW4gYSBjb3Zlci1sZXR0ZXIgKG1heWJl IHlvdSBkaWQsIGJ1dCBJDQo+IGNhbid0IGZpbmQgaXQpLg0KPiANCj4gPiArICAgICAgIHUzMiBu b2RlX2lkID0gKGRldmljZWlkID09IDApID8gTk9ERV9TRF8wIDogTk9ERV9TRF8xOw0KPiA+ICsN Cj4gPiArICAgICAgIGlmICghZWVtaV9vcHMgfHwgIWVlbWlfb3BzLT5pb2N0bCkNCj4gPiArICAg ICAgICAgICAgICAgcmV0dXJuOw0KPiA+ICsNCj4gPiArICAgICAgIGlmIChpdGFwX2RlbGF5KQ0K PiA+ICsgICAgICAgICAgICAgICBlZW1pX29wcy0+aW9jdGwobm9kZV9pZCwgSU9DVExfU0VUX1NE X1RBUERFTEFZLA0KPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgUE1fVEFQREVM QVlfSU5QVVQsIGl0YXBfZGVsYXksIE5VTEwpOw0KPiA+ICsNCj4gPiArICAgICAgIGlmIChvdGFw X2RlbGF5KQ0KPiA+ICsgICAgICAgICAgICAgICBlZW1pX29wcy0+aW9jdGwobm9kZV9pZCwgSU9D VExfU0VUX1NEX1RBUERFTEFZLA0KPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg UE1fVEFQREVMQVlfT1VUUFVULCBvdGFwX2RlbGF5LCBOVUxMKTsNCj4gPiArfQ0KPiANCj4gQW5v dGhlciBvdmVyYWxsIGNvbW1lbnQgZm9yIHRoZSBzZXJpZXMuDQo+IA0KPiBJIHdvdWxkIHJlY29t bWVuZCB0byBjaGFuZ2UgdGhlIG9yZGVyIG9mIHRoZSBwYXRjaGVzIGluIHRoZSBzZXJpZXMuDQo+ IExldCB0aGUgRFQgZG9jIGNoYW5nZSBjb21lIGZpcnN0LCBuZXh0IHRoZSBkcml2ZXIgY2hhbmdl IGFuZCBmaW5hbGx5IHRoZSBjaGFuZ2UNCj4gdG8gdGhlIERUUyBmaWxlKHMpLiBUaGlzIG1ha2Vz IGl0IGVhc2llciB0byBmb2xsb3cgYW5kIHJldmlldy4NClN1cmUsIEkgd2lsbCBkbyB0aGF0Lg0K DQpUaGFua3MgJiBSZWdhcmRzLA0KTWFuaXNoDQoNCj4gDQo+IFsuLi5dDQo+IA0KPiBLaW5kIHJl Z2FyZHMNCj4gVWZmZQ0K -- To unsubscribe from this list: send the line "unsubscribe linux-mmc" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
diff --git a/drivers/mmc/host/sdhci-of-arasan.c b/drivers/mmc/host/sdhci-of-arasan.c index e3332a5..fc0fd01 100644 --- a/drivers/mmc/host/sdhci-of-arasan.c +++ b/drivers/mmc/host/sdhci-of-arasan.c @@ -36,6 +36,8 @@ #define PHY_CLK_TOO_SLOW_HZ 400000 +#define MMC_BANK2 0x2 + /* * On some SoCs the syscon area has a feature where the upper 16-bits of * each 32-bit register act as a write mask for the lower 16-bits. This allows @@ -90,6 +92,10 @@ struct sdhci_arasan_data { struct sdhci_host *host; struct clk *clk_ahb; struct phy *phy; + u32 mio_bank; + u32 device_id; + u32 itapdly[MMC_TIMING_MMC_HS400 + 1]; + u32 otapdly[MMC_TIMING_MMC_HS400 + 1]; bool is_phy_on; bool has_cqe; @@ -160,11 +166,36 @@ static int sdhci_arasan_syscon_write(struct sdhci_host *host, return ret; } +/** + * arasan_zynqmp_set_tap_delay - Program the tap delays. + * @deviceid: Unique Id of device + * @itap_delay: Input Tap Delay + * @oitap_delay: Output Tap Delay + */ +static void arasan_zynqmp_set_tap_delay(u8 deviceid, u8 itap_delay, u8 otap_delay) +{ + const struct zynqmp_eemi_ops *eemi_ops = zynqmp_pm_get_eemi_ops(); + u32 node_id = (deviceid == 0) ? NODE_SD_0 : NODE_SD_1; + + if (!eemi_ops || !eemi_ops->ioctl) + return; + + if (itap_delay) + eemi_ops->ioctl(node_id, IOCTL_SET_SD_TAPDELAY, + PM_TAPDELAY_INPUT, itap_delay, NULL); + + if (otap_delay) + eemi_ops->ioctl(node_id, IOCTL_SET_SD_TAPDELAY, + PM_TAPDELAY_OUTPUT, otap_delay, NULL); +} + static void sdhci_arasan_set_clock(struct sdhci_host *host, unsigned int clock) { struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); struct sdhci_arasan_data *sdhci_arasan = sdhci_pltfm_priv(pltfm_host); bool ctrl_phy = false; + u8 itap_delay; + u8 otap_delay; if (!IS_ERR(sdhci_arasan->phy)) { if (!sdhci_arasan->is_phy_on && clock <= PHY_CLK_TOO_SLOW_HZ) { @@ -200,6 +231,16 @@ static void sdhci_arasan_set_clock(struct sdhci_host *host, unsigned int clock) } } + if (host->version >= SDHCI_SPEC_300) { + if ((host->timing != MMC_TIMING_LEGACY) && + (host->timing != MMC_TIMING_UHS_SDR12)) { + itap_delay = sdhci_arasan->itapdly[host->timing]; + otap_delay = sdhci_arasan->otapdly[host->timing]; + arasan_zynqmp_set_tap_delay(sdhci_arasan->device_id, + itap_delay, otap_delay); + } + } + if (ctrl_phy && sdhci_arasan->is_phy_on) { phy_power_off(sdhci_arasan->phy); sdhci_arasan->is_phy_on = false; @@ -456,6 +497,7 @@ static const struct of_device_id sdhci_arasan_of_match[] = { { .compatible = "arasan,sdhci-8.9a" }, { .compatible = "arasan,sdhci-5.1" }, { .compatible = "arasan,sdhci-4.9a" }, + { .compatible = "xlnx,zynqmp-8.9a" }, { /* sentinel */ } }; @@ -641,6 +683,74 @@ static void sdhci_arasan_unregister_sdclk(struct device *dev) of_clk_del_provider(dev->of_node); } +/** + * arasan_zynqmp_dt_parse_tap_delays - Read Tap Delay values from DT + * + * Called at initialization to parse the values of Tap Delays. + * + * @dev: Pointer to our struct device. + */ +static void arasan_zynqmp_dt_parse_tap_delays(struct device *dev) +{ + struct platform_device *pdev = to_platform_device(dev); + struct sdhci_host *host = platform_get_drvdata(pdev); + struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); + struct sdhci_arasan_data *sdhci_arasan = sdhci_pltfm_priv(pltfm_host); + struct device_node *np = dev->of_node; + + of_property_read_u32(np, "xlnx,itap_delay_sd_hsd", + &sdhci_arasan->itapdly[MMC_TIMING_SD_HS]); + of_property_read_u32(np, "xlnx,otap_delay_sd_hsd", + &sdhci_arasan->otapdly[MMC_TIMING_SD_HS]); + of_property_read_u32(np, "xlnx,itap_delay_sdr25", + &sdhci_arasan->itapdly[MMC_TIMING_UHS_SDR25]); + of_property_read_u32(np, "xlnx,otap_delay_sdr25", + &sdhci_arasan->otapdly[MMC_TIMING_UHS_SDR25]); + of_property_read_u32(np, "xlnx,itap_delay_sdr50", + &sdhci_arasan->itapdly[MMC_TIMING_UHS_SDR50]); + of_property_read_u32(np, "xlnx,otap_delay_sdr50", + &sdhci_arasan->otapdly[MMC_TIMING_UHS_SDR50]); + of_property_read_u32(np, "xlnx,itap_delay_sd_ddr50", + &sdhci_arasan->itapdly[MMC_TIMING_UHS_DDR50]); + of_property_read_u32(np, "xlnx,otap_delay_sd_ddr50", + &sdhci_arasan->otapdly[MMC_TIMING_UHS_DDR50]); + of_property_read_u32(np, "xlnx,itap_delay_mmc_hsd", + &sdhci_arasan->itapdly[MMC_TIMING_MMC_HS]); + of_property_read_u32(np, "xlnx,otap_delay_mmc_hsd", + &sdhci_arasan->otapdly[MMC_TIMING_MMC_HS]); + of_property_read_u32(np, "xlnx,itap_delay_mmc_ddr50", + &sdhci_arasan->itapdly[MMC_TIMING_MMC_DDR52]); + of_property_read_u32(np, "xlnx,otap_delay_mmc_ddr50", + &sdhci_arasan->otapdly[MMC_TIMING_MMC_DDR52]); + if (sdhci_arasan->mio_bank == MMC_BANK2) { + of_property_read_u32(np, + "xlnx,itap_delay_sdr104_b2", + &sdhci_arasan->itapdly[MMC_TIMING_UHS_SDR104]); + of_property_read_u32(np, + "xlnx,otap_delay_sdr104_b2", + &sdhci_arasan->otapdly[MMC_TIMING_UHS_SDR104]); + of_property_read_u32(np, + "xlnx,itap_delay_mmc_hs200_b2", + &sdhci_arasan->itapdly[MMC_TIMING_MMC_HS200]); + of_property_read_u32(np, + "xlnx,otap_delay_mmc_hs200_b2", + &sdhci_arasan->otapdly[MMC_TIMING_MMC_HS200]); + } else { + of_property_read_u32(np, + "xlnx,itap_delay_sdr104_b0", + &sdhci_arasan->itapdly[MMC_TIMING_UHS_SDR104]); + of_property_read_u32(np, + "xlnx,otap_delay_sdr104_b0", + &sdhci_arasan->otapdly[MMC_TIMING_UHS_SDR104]); + of_property_read_u32(np, + "xlnx,itap_delay_mmc_hs200_b0", + &sdhci_arasan->itapdly[MMC_TIMING_MMC_HS200]); + of_property_read_u32(np, + "xlnx,otap_delay_mmc_hs200_b0", + &sdhci_arasan->otapdly[MMC_TIMING_MMC_HS200]); + } +} + static int sdhci_arasan_add_host(struct sdhci_arasan_data *sdhci_arasan) { struct sdhci_host *host = sdhci_arasan->host; @@ -776,6 +886,27 @@ static int sdhci_arasan_probe(struct platform_device *pdev) goto unreg_clk; } + if (of_device_is_compatible(pdev->dev.of_node, + "xlnx,zynqmp-8.9a")) { + ret = of_property_read_u32(pdev->dev.of_node, + "xlnx,mio_bank", + &sdhci_arasan->mio_bank); + if (ret < 0) { + dev_err(&pdev->dev, + "\"xlnx,mio_bank \" property is missing.\n"); + goto clk_disable_all; + } + ret = of_property_read_u32(pdev->dev.of_node, + "xlnx,device_id", + &sdhci_arasan->device_id); + if (ret < 0) { + dev_err(&pdev->dev, + "\"xlnx,device_id \" property is missing.\n"); + goto clk_disable_all; + } + arasan_zynqmp_dt_parse_tap_delays(&pdev->dev); + } + sdhci_arasan->phy = ERR_PTR(-ENODEV); if (of_device_is_compatible(pdev->dev.of_node, "arasan,sdhci-5.1")) {
This patch adds support for reading Tap Delay values from Device Tree and write them via eemi calls. The macros containing these tap delay values are removed from the driver. Signed-off-by: Manish Narani <manish.narani@xilinx.com> --- drivers/mmc/host/sdhci-of-arasan.c | 131 +++++++++++++++++++++++++++++++++++++ 1 file changed, 131 insertions(+) -- 2.7.4 This email and any attachments are intended for the sole use of the named recipient(s) and contain(s) confidential information that may be proprietary, privileged or copyrighted under applicable law. If you are not the intended recipient, do not read, copy, or forward this email message or any attachments. Delete this email message and any attachments immediately. -- To unsubscribe from this list: send the line "unsubscribe linux-mmc" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html