Re: [RFC PATCH v3.1 22/27] mmc: sdhci-uhs2: add add_host() and others to set up the driver

From: Adrian Hunter
Date: Thu Dec 03 2020 - 04:43:44 EST


On 6/11/20 4:27 am, AKASHI Takahiro wrote:
> This is a UHS-II version of sdhci's add_host/remove_host operation.
> Any sdhci drivers which are capable of handling UHS-II cards must
> call those functions instead of the corresponding sdhci's.
>
> Signed-off-by: Ben Chuang <ben.chuang@xxxxxxxxxxxxxxxxxxx>
> Signed-off-by: AKASHI Takahiro <takahiro.akashi@xxxxxxxxxx>
> ---
> drivers/mmc/host/sdhci-uhs2.c | 198 ++++++++++++++++++++++++++++++++++
> drivers/mmc/host/sdhci-uhs2.h | 2 +
> drivers/mmc/host/sdhci.c | 24 +++--
> drivers/mmc/host/sdhci.h | 10 ++
> 4 files changed, 226 insertions(+), 8 deletions(-)
>
> diff --git a/drivers/mmc/host/sdhci-uhs2.c b/drivers/mmc/host/sdhci-uhs2.c
> index d50134e912f3..5d3362ea138f 100644
> --- a/drivers/mmc/host/sdhci-uhs2.c
> +++ b/drivers/mmc/host/sdhci-uhs2.c
> @@ -15,6 +15,7 @@
> #include <linux/ktime.h>
> #include <linux/module.h>
> #include <linux/mmc/mmc.h>
> +#include <linux/regulator/consumer.h>
>
> #include "sdhci.h"
> #include "sdhci-uhs2.h"
> @@ -406,6 +407,15 @@ static inline void sdhci_led_deactivate(struct sdhci_host *host)
> {
> }
> #else
> +static inline int sdhci_led_register(struct sdhci_host *host)
> +{
> + return 0;
> +}
> +
> +static inline void sdhci_led_unregister(struct sdhci_host *host)
> +{
> +}
> +
> static inline void sdhci_led_activate(struct sdhci_host *host)
> {
> __sdhci_led_activate(host);
> @@ -1298,6 +1308,194 @@ static irqreturn_t sdhci_uhs2_thread_irq(int irq, void *dev_id)
> return IRQ_HANDLED;
> }
>
> +/*****************************************************************************\
> + *
> + * Device allocation/registration *
> + * *
> +\*****************************************************************************/
> +
> +static int __sdhci_uhs2_add_host_v4(struct sdhci_host *host, u32 caps1)
> +{
> + struct mmc_host *mmc;
> + u32 max_current_caps2;
> +
> + if (host->version < SDHCI_SPEC_400)
> + return 0;
> +
> + mmc = host->mmc;
> +
> + /* Support UHS2 */
> + if (caps1 & SDHCI_SUPPORT_UHS2)
> + mmc->caps |= MMC_CAP_UHS2;
> +
> + max_current_caps2 = sdhci_readl(host, SDHCI_MAX_CURRENT_1);
> +
> + if ((caps1 & SDHCI_SUPPORT_VDD2_180) &&
> + !max_current_caps2 &&
> + !IS_ERR(mmc->supply.vmmc2)) {
> + /* UHS2 - VDD2 */
> + int curr = regulator_get_current_limit(mmc->supply.vmmc2);
> +
> + if (curr > 0) {
> + /* convert to SDHCI_MAX_CURRENT format */
> + curr = curr / 1000; /* convert to mA */
> + curr = curr / SDHCI_MAX_CURRENT_MULTIPLIER;
> + curr = min_t(u32, curr, SDHCI_MAX_CURRENT_LIMIT);
> + max_current_caps2 = curr;
> + }
> + }
> +
> + if (caps1 & SDHCI_SUPPORT_VDD2_180) {
> + mmc->ocr_avail_uhs2 |= MMC_VDD2_165_195;
> + /*
> + * UHS2 doesn't require this. Only UHS-I bus needs to set
> + * max current.
> + */
> + mmc->max_current_180_vdd2 = (max_current_caps2 &
> + SDHCI_MAX_CURRENT_VDD2_180_MASK) *
> + SDHCI_MAX_CURRENT_MULTIPLIER;
> + } else {
> + mmc->caps &= ~MMC_CAP_UHS2;
> + }
> +
> + return 0;
> +}
> +
> +static int sdhci_uhs2_host_ops_init(struct sdhci_host *host);
> +
> +static int __sdhci_uhs2_add_host(struct sdhci_host *host)

Can you leverage __sdhci_add_host() here?

> +{
> + unsigned int flags = WQ_UNBOUND | WQ_MEM_RECLAIM | WQ_HIGHPRI;
> + struct mmc_host *mmc = host->mmc;
> + int ret;
> +
> + if ((mmc->caps2 & MMC_CAP2_CQE) &&
> + (host->quirks & SDHCI_QUIRK_BROKEN_CQE)) {
> + mmc->caps2 &= ~MMC_CAP2_CQE;
> + mmc->cqe_ops = NULL;
> + }
> +
> + /* overwrite ops */
> + if (mmc->caps & MMC_CAP_UHS2)
> + sdhci_uhs2_host_ops_init(host);
> +
> + host->complete_wq = alloc_workqueue("sdhci", flags, 0);
> + if (!host->complete_wq)
> + return -ENOMEM;
> +
> + INIT_WORK(&host->complete_work, sdhci_uhs2_complete_work);
> +
> + timer_setup(&host->timer, sdhci_timeout_timer, 0);
> + timer_setup(&host->data_timer, sdhci_timeout_data_timer, 0);
> +
> + init_waitqueue_head(&host->buf_ready_int);
> +
> + sdhci_init(host, 0);
> +
> + ret = request_threaded_irq(host->irq, sdhci_irq,
> + sdhci_uhs2_thread_irq,
> + IRQF_SHARED, mmc_hostname(mmc), host);
> + if (ret) {
> + pr_err("%s: Failed to request IRQ %d: %d\n",
> + mmc_hostname(mmc), host->irq, ret);
> + goto unwq;
> + }
> +
> + ret = sdhci_led_register(host);
> + if (ret) {
> + pr_err("%s: Failed to register LED device: %d\n",
> + mmc_hostname(mmc), ret);
> + goto unirq;
> + }
> +
> + ret = mmc_add_host(mmc);
> + if (ret)
> + goto unled;
> +
> + pr_info("%s: SDHCI controller on %s [%s] using %s\n",
> + mmc_hostname(mmc), host->hw_name, dev_name(mmc_dev(mmc)),
> + host->use_external_dma ? "External DMA" :
> + (host->flags & SDHCI_USE_ADMA) ?
> + (host->flags & SDHCI_USE_64_BIT_DMA) ? "ADMA 64-bit" : "ADMA" :
> + (host->flags & SDHCI_USE_SDMA) ? "DMA" : "PIO");
> +
> + sdhci_enable_card_detection(host);
> +
> + return 0;
> +
> +unled:
> + sdhci_led_unregister(host);
> +unirq:
> + sdhci_do_reset(host, SDHCI_RESET_ALL);
> + sdhci_writel(host, 0, SDHCI_INT_ENABLE);
> + sdhci_writel(host, 0, SDHCI_SIGNAL_ENABLE);
> + free_irq(host->irq, host);
> +unwq:
> + destroy_workqueue(host->complete_wq);
> +
> + return ret;
> +}
> +
> +static void __sdhci_uhs2_remove_host(struct sdhci_host *host, int dead)
> +{
> + if (!(host->mmc) || !(host->mmc->flags & MMC_UHS2_SUPPORT))
> + return;
> +
> + if (!dead)
> + sdhci_uhs2_reset(host, SDHCI_UHS2_SW_RESET_FULL);
> +
> + sdhci_writel(host, 0, SDHCI_UHS2_ERR_INT_STATUS_EN);
> + sdhci_writel(host, 0, SDHCI_UHS2_ERR_INT_SIG_EN);
> + host->mmc->flags &= ~MMC_UHS2_INITIALIZED;
> +}
> +
> +int sdhci_uhs2_add_host(struct sdhci_host *host)
> +{
> + struct mmc_host *mmc = host->mmc;
> + int ret;
> +
> + ret = sdhci_setup_host(host);
> + if (ret)
> + return ret;
> +
> + if (host->version >= SDHCI_SPEC_400) {
> + ret = __sdhci_uhs2_add_host_v4(host, host->caps1);
> + if (ret)
> + goto cleanup;
> + }
> +
> + if ((mmc->caps & MMC_CAP_UHS2) && !host->v4_mode)
> + /* host doesn't want to enable UHS2 support */
> + /* FIXME: Do we have to do some cleanup here? */
> + mmc->caps &= ~MMC_CAP_UHS2;
> +
> + ret = __sdhci_uhs2_add_host(host);
> + if (ret)
> + goto cleanup2;
> +
> + return 0;
> +
> +cleanup2:
> + /*
> + * TODO: Is this a right cleanup?
> + */
> + if (host->version >= SDHCI_SPEC_400)
> + __sdhci_uhs2_remove_host(host, 0);
> +cleanup:
> + sdhci_cleanup_host(host);
> +
> + return ret;
> +}
> +EXPORT_SYMBOL_GPL(sdhci_uhs2_add_host);
> +
> +void sdhci_uhs2_remove_host(struct sdhci_host *host, int dead)
> +{
> + __sdhci_uhs2_remove_host(host, dead);
> +
> + sdhci_uhs2_remove_host(host, dead);

Meant to be sdhci_remove_host() presumably?

> +}
> +EXPORT_SYMBOL_GPL(sdhci_uhs2_remove_host);
> +
> /*****************************************************************************\
> * *
> * Driver init/exit *
> diff --git a/drivers/mmc/host/sdhci-uhs2.h b/drivers/mmc/host/sdhci-uhs2.h
> index b74af641d00e..34e140f21284 100644
> --- a/drivers/mmc/host/sdhci-uhs2.h
> +++ b/drivers/mmc/host/sdhci-uhs2.h
> @@ -218,5 +218,7 @@ void sdhci_uhs2_clear_set_irqs(struct sdhci_host *host, u32 clear, u32 set);
> void sdhci_uhs2_request(struct mmc_host *mmc, struct mmc_request *mrq);
> int sdhci_uhs2_request_atomic(struct mmc_host *mmc, struct mmc_request *mrq);
> u32 sdhci_uhs2_irq(struct sdhci_host *host, u32 intmask);
> +int sdhci_uhs2_add_host(struct sdhci_host *host);
> +void sdhci_uhs2_remove_host(struct sdhci_host *host, int dead);
>
> #endif /* __SDHCI_UHS2_H */
> diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
> index e2dfc7767bcf..d37c3edb1ed0 100644
> --- a/drivers/mmc/host/sdhci.c
> +++ b/drivers/mmc/host/sdhci.c
> @@ -176,10 +176,11 @@ static void sdhci_set_card_detection(struct sdhci_host *host, bool enable)
> sdhci_writel(host, host->ier, SDHCI_SIGNAL_ENABLE);
> }
>
> -static void sdhci_enable_card_detection(struct sdhci_host *host)
> +void sdhci_enable_card_detection(struct sdhci_host *host)
> {
> sdhci_set_card_detection(host, true);
> }
> +EXPORT_SYMBOL_GPL(sdhci_enable_card_detection);
>
> static void sdhci_disable_card_detection(struct sdhci_host *host)
> {
> @@ -237,7 +238,7 @@ void sdhci_reset(struct sdhci_host *host, u8 mask)
> }
> EXPORT_SYMBOL_GPL(sdhci_reset);
>
> -static void sdhci_do_reset(struct sdhci_host *host, u8 mask)
> +void sdhci_do_reset(struct sdhci_host *host, u8 mask)
> {
> if (host->quirks & SDHCI_QUIRK_NO_CARD_NO_RESET) {
> struct mmc_host *mmc = host->mmc;
> @@ -258,6 +259,7 @@ static void sdhci_do_reset(struct sdhci_host *host, u8 mask)
> host->preset_enabled = false;
> }
> }
> +EXPORT_SYMBOL_GPL(sdhci_do_reset);
>
> static void sdhci_set_default_irqs(struct sdhci_host *host)
> {
> @@ -321,7 +323,7 @@ static void sdhci_config_dma(struct sdhci_host *host)
> sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
> }
>
> -static void sdhci_init(struct sdhci_host *host, int soft)
> +void sdhci_init(struct sdhci_host *host, int soft)
> {
> struct mmc_host *mmc = host->mmc;
> unsigned long flags;
> @@ -346,6 +348,7 @@ static void sdhci_init(struct sdhci_host *host, int soft)
> mmc->ops->set_ios(mmc, &mmc->ios);
> }
> }
> +EXPORT_SYMBOL_GPL(sdhci_init);
>
> static void sdhci_reinit(struct sdhci_host *host)
> {
> @@ -410,7 +413,7 @@ static void sdhci_led_control(struct led_classdev *led,
> spin_unlock_irqrestore(&host->lock, flags);
> }
>
> -static int sdhci_led_register(struct sdhci_host *host)
> +int sdhci_led_register(struct sdhci_host *host)
> {
> struct mmc_host *mmc = host->mmc;
>
> @@ -427,14 +430,16 @@ static int sdhci_led_register(struct sdhci_host *host)
>
> return led_classdev_register(mmc_dev(mmc), &host->led);
> }
> +EXPORT_SYMBOL_GPL(sdhci_led_register);
>
> -static void sdhci_led_unregister(struct sdhci_host *host)
> +void sdhci_led_unregister(struct sdhci_host *host)
> {
> if (host->quirks & SDHCI_QUIRK_NO_LED)
> return;
>
> led_classdev_unregister(&host->led);
> }
> +EXPORT_SYMBOL_GPL(sdhci_led_unregister);
>
> static inline void sdhci_led_activate(struct sdhci_host *host)
> {
> @@ -3175,7 +3180,7 @@ static void sdhci_complete_work(struct work_struct *work)
> ;
> }
>
> -static void sdhci_timeout_timer(struct timer_list *t)
> +void sdhci_timeout_timer(struct timer_list *t)
> {
> struct sdhci_host *host;
> unsigned long flags;
> @@ -3195,8 +3200,9 @@ static void sdhci_timeout_timer(struct timer_list *t)
>
> spin_unlock_irqrestore(&host->lock, flags);
> }
> +EXPORT_SYMBOL_GPL(sdhci_timeout_timer);
>
> -static void sdhci_timeout_data_timer(struct timer_list *t)
> +void sdhci_timeout_data_timer(struct timer_list *t)
> {
> struct sdhci_host *host;
> unsigned long flags;
> @@ -3226,6 +3232,7 @@ static void sdhci_timeout_data_timer(struct timer_list *t)
>
> spin_unlock_irqrestore(&host->lock, flags);
> }
> +EXPORT_SYMBOL_GPL(sdhci_timeout_data_timer);
>
> /*****************************************************************************\
> * *
> @@ -3469,7 +3476,7 @@ static inline bool sdhci_defer_done(struct sdhci_host *host,
> data->host_cookie == COOKIE_MAPPED);
> }
>
> -static irqreturn_t sdhci_irq(int irq, void *dev_id)
> +irqreturn_t sdhci_irq(int irq, void *dev_id)
> {
> struct mmc_request *mrqs_done[SDHCI_MAX_MRQS] = {0};
> irqreturn_t result = IRQ_NONE;
> @@ -3609,6 +3616,7 @@ static irqreturn_t sdhci_irq(int irq, void *dev_id)
>
> return result;
> }
> +EXPORT_SYMBOL_GPL(sdhci_irq);
>
> static irqreturn_t sdhci_thread_irq(int irq, void *dev_id)
> {
> diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
> index 74572b54ec47..b1d856664b58 100644
> --- a/drivers/mmc/host/sdhci.h
> +++ b/drivers/mmc/host/sdhci.h
> @@ -832,8 +832,15 @@ static inline void sdhci_read_caps(struct sdhci_host *host)
> }
>
> bool sdhci_data_line_cmd(struct mmc_command *cmd);
> +void sdhci_enable_card_detection(struct sdhci_host *host);
> void sdhci_runtime_pm_bus_on(struct sdhci_host *host);
> void sdhci_runtime_pm_bus_off(struct sdhci_host *host);
> +void sdhci_do_reset(struct sdhci_host *host, u8 mask);
> +void sdhci_init(struct sdhci_host *host, int soft);
> +#if IS_REACHABLE(CONFIG_LEDS_CLASS)
> +int sdhci_led_register(struct sdhci_host *host);
> +void sdhci_led_unregister(struct sdhci_host *host);
> +#endif
> void sdhci_mod_timer(struct sdhci_host *host, struct mmc_request *mrq,
> unsigned long timeout);
> void sdhci_initialize_data(struct sdhci_host *host, struct mmc_data *data);
> @@ -884,6 +891,9 @@ int sdhci_start_signal_voltage_switch(struct mmc_host *mmc,
> void sdhci_enable_sdio_irq(struct mmc_host *mmc, int enable);
> void sdhci_request_done_dma(struct sdhci_host *host, struct mmc_request *mrq);
> bool sdhci_request_done(struct sdhci_host *host);
> +void sdhci_timeout_timer(struct timer_list *t);
> +void sdhci_timeout_data_timer(struct timer_list *t);
> +irqreturn_t sdhci_irq(int irq, void *dev_id);
> void sdhci_adma_write_desc(struct sdhci_host *host, void **desc,
> dma_addr_t addr, int len, unsigned int cmd);
>
>