From patchwork Mon Dec 16 11:24:50 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Fenkart X-Patchwork-Id: 3353461 Return-Path: X-Original-To: patchwork-linux-omap@patchwork.kernel.org Delivered-To: patchwork-parsemail@patchwork2.web.kernel.org Received: from mail.kernel.org (mail.kernel.org [198.145.19.201]) by patchwork2.web.kernel.org (Postfix) with ESMTP id D94DBC0D4A for ; Mon, 16 Dec 2013 11:28:33 +0000 (UTC) Received: from mail.kernel.org (localhost [127.0.0.1]) by mail.kernel.org (Postfix) with ESMTP id 602792034C for ; Mon, 16 Dec 2013 11:28:32 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id D1D6D2015F for ; Mon, 16 Dec 2013 11:28:30 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753619Ab3LPL2U (ORCPT ); Mon, 16 Dec 2013 06:28:20 -0500 Received: from mail-ee0-f54.google.com ([74.125.83.54]:60149 "EHLO mail-ee0-f54.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753436Ab3LPL2R (ORCPT ); Mon, 16 Dec 2013 06:28:17 -0500 Received: by mail-ee0-f54.google.com with SMTP id e51so1825523eek.41 for ; Mon, 16 Dec 2013 03:28:16 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=pquF/7qyI4RKYyAC3kKwdehvIMIyYuNL7OMmKh7FTko=; b=MMB09Dv0jj64rbJQzQ35FudQ4869KJXrr7ZL9PwRjJZ3IoMgtsEhhlggodeIHPWJXp 3qtnm0e4xhmB9TkeJcJQDwSK7eH7nPEgntw9Fwl1g3ljcTqToBkJfBoipksTDH24qXAp vXAkXn96XncykXArRC2aVIOD7l0ieP//RMRu6l2q6QD+BUHlM2/YGeOZT+W7D6oseQf8 rKHcpilWB4s+Ck7N+8IwRjZCWmnDm6KgXGM9pOPX7O1NHFDNGCIdKQ6WrvzhYBPM7YG5 wJ0oUiWvUWVgmJRu6Sp+fIGi9epq3eisqLU8XmM6QDRBDfjyy5bO06jkVycQY3uNKi3V Pu9Q== X-Received: by 10.14.32.132 with SMTP id o4mr16430681eea.14.1387193296192; Mon, 16 Dec 2013 03:28:16 -0800 (PST) Received: from localhost (ip-94-112-2-16.net.upcbroadband.cz. [94.112.2.16]) by mx.google.com with ESMTPSA id h3sm41126293eem.15.2013.12.16.03.28.13 for (version=TLSv1.2 cipher=RC4-SHA bits=128/128); Mon, 16 Dec 2013 03:28:15 -0800 (PST) From: Andreas Fenkart To: Chris Ball Cc: Tony Lindgren , Grant Likely , Felipe Balbi , Balaji T K , zonque@gmail.com, galak@codeaurora.org, linux-doc@vger.kernel.org, linux-mmc@vger.kernel.org, linux-omap@vger.kernel.org, Andreas Fenkart Subject: [PATCH v6 2/3] mmc: omap_hsmmc: Pin remux workaround to support SDIO interrupt on AM335x. Date: Mon, 16 Dec 2013 12:24:50 +0100 Message-Id: <1387193091-23218-3-git-send-email-afenkart@gmail.com> X-Mailer: git-send-email 1.7.10.4 In-Reply-To: <1387193091-23218-1-git-send-email-afenkart@gmail.com> References: <1387193091-23218-1-git-send-email-afenkart@gmail.com> Sender: linux-omap-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-omap@vger.kernel.org X-Spam-Status: No, score=-7.3 required=5.0 tests=BAYES_00, DKIM_ADSP_CUSTOM_MED, DKIM_SIGNED, FREEMAIL_FROM, RCVD_IN_DNSWL_HI, RP_MATCHES_RCVD, T_DKIM_INVALID, UNPARSEABLE_RELAY autolearn=unavailable version=3.3.1 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on mail.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP The am335x can't detect pending cirq in PM runtime suspend. This patch reconfigures dat1 as a GPIO before going to suspend. SDIO interrupts are detected with the GPIO, the GPIO will only wake the module from suspend, SDIO irq detection will still happen through the IP block. Idea of remuxing the pins by Tony Lindgren as well as the implementation of omap_hsmmc_pin_init. Signed-off-by: Andreas Fenkart --- .../devicetree/bindings/mmc/ti-omap-hsmmc.txt | 50 ++++++ drivers/mmc/host/omap_hsmmc.c | 184 ++++++++++++++++++-- 2 files changed, 222 insertions(+), 12 deletions(-) diff --git a/Documentation/devicetree/bindings/mmc/ti-omap-hsmmc.txt b/Documentation/devicetree/bindings/mmc/ti-omap-hsmmc.txt index 8c8908a..8e1195e 100644 --- a/Documentation/devicetree/bindings/mmc/ti-omap-hsmmc.txt +++ b/Documentation/devicetree/bindings/mmc/ti-omap-hsmmc.txt @@ -55,3 +55,53 @@ Examples: &edma 25>; dma-names = "tx", "rx"; }; + +[workaround for missing swakeup on am33xx] + +This SOC is missing the swakeup line, it will not detect SDIO irq +while in suspend. + + ------ + | PRCM | + ------ + ^ | + swakeup | | fclk + | v + ------ ------- ----- + | card | -- CIRQ --> | hsmmc | -- IRQ --> | CPU | + ------ ------- ----- + +In suspend the fclk is off and the module is disfunctional. Even +register reads will fail. A small logic in the host will request +fclk restore, when an external event is detected. Once the clock +is restored, the host detects the event normally. Since am33xx +doesn't have this line it never wakes from suspend. + +The workaround is to reconfigure the dat1 line as a GPIO upon +suspend. To make this work, we need to set 1) the named pinctrl +states "default", "active" and "idle", 2) the gpio detecting +sdio irq in suspend and 3) compatibe section, see example below. +The MMC driver will then toggle between active and idle during +the runtime. If configuration is incomplete, a warning message is +emitted "falling back to polling". Mind not every application +needs SDIO irq, e.g. MMC cards Affected chips are am335x, +probably others + + + mmc1: mmc@48060100 { + compatible = "ti,am33xx-hsmmc"; + ... + interrupts-extended = <&intc 64 &gpio2 28 0>; + ... + pinctrl-names = "default", "active", "idle" + pinctrl-0 = <&mmc1_pins>; + pinctrl-1 = <&mmc1_pins>; + pinctrl-2 = <&mmc1_cirq_pin>; + ... + }; + + mmc1_cirq_pin: pinmux_cirq_pin { + pinctrl-single,pins = < + 0x0f8 0x3f /* GPIO2_28 */ + >; + }; diff --git a/drivers/mmc/host/omap_hsmmc.c b/drivers/mmc/host/omap_hsmmc.c index c197028..bb01d86 100644 --- a/drivers/mmc/host/omap_hsmmc.c +++ b/drivers/mmc/host/omap_hsmmc.c @@ -29,6 +29,7 @@ #include #include #include +#include #include #include #include @@ -36,6 +37,7 @@ #include #include #include +#include #include #include #include @@ -206,6 +208,7 @@ struct omap_hsmmc_host { u32 sysctl; u32 capa; int irq; + int gpio_sdio_irq; int use_dma, dma_ch; struct dma_chan *tx_chan; struct dma_chan *rx_chan; @@ -218,11 +221,32 @@ struct omap_hsmmc_host { int req_in_progress; int flags; #define HSMMC_SDIO_IRQ_ENABLED (1 << 0) /* SDIO irq enabled */ +#define HSMMC_SWAKEUP_QUIRK (1 << 1) +#define HSMMC_CIRQ_GPIO_ENABLED (1 << 2) struct omap_hsmmc_next next_data; + struct pinctrl *pinctrl; + struct pinctrl_state *fixed, *active, *idle; struct omap_mmc_platform_data *pdata; }; +static irqreturn_t omap_hsmmc_cirq(int irq, void *dev_id) +{ + struct omap_hsmmc_host *host = dev_id; + unsigned long flags; + + spin_lock_irqsave(&host->irq_lock, flags); + if (host->flags & HSMMC_CIRQ_GPIO_ENABLED) { + disable_irq_nosync(host->gpio_sdio_irq); + host->flags &= ~HSMMC_CIRQ_GPIO_ENABLED; + } + spin_unlock_irqrestore(&host->irq_lock, flags); + + pm_request_resume(host->dev); /* no use counter */ + + return IRQ_HANDLED; +} + static int omap_hsmmc_card_detect(struct device *dev, int slot) { struct omap_hsmmc_host *host = dev_get_drvdata(dev); @@ -476,6 +500,67 @@ static void omap_hsmmc_gpio_free(struct omap_mmc_platform_data *pdata) gpio_free(pdata->slots[0].switch_pin); } +static int omap_hsmmc_pin_init(struct omap_hsmmc_host *host) +{ + int ret; + + host->pinctrl = devm_pinctrl_get(host->dev); + if (IS_ERR(host->pinctrl)) { + dev_dbg(host->dev, "no pinctrl handle\n"); + ret = 0; + goto out; + } + + host->fixed = pinctrl_lookup_state(host->pinctrl, + PINCTRL_STATE_DEFAULT); + if (IS_ERR(host->fixed)) { + dev_dbg(host->dev, + "pins are not configured from the driver\n"); + host->fixed = NULL; + ret = 0; + goto out; + } + + ret = pinctrl_select_state(host->pinctrl, host->fixed); + if (ret < 0) + goto err; + + /* For most cases we don't have wake-ups, and exit after this */ + host->active = pinctrl_lookup_state(host->pinctrl, "active"); + if (IS_ERR(host->active)) { + ret = PTR_ERR(host->active); + host->active = NULL; + return 0; + } + + host->idle = pinctrl_lookup_state(host->pinctrl, + PINCTRL_STATE_IDLE); + if (IS_ERR(host->idle)) { + ret = PTR_ERR(host->idle); + host->idle = NULL; + goto err; + } + + /* Let's make sure the active and idle states work */ + ret = pinctrl_select_state(host->pinctrl, host->idle); + if (ret < 0) + goto err; + + ret = pinctrl_select_state(host->pinctrl, host->active); + if (ret < 0) + goto err; + + dev_info(mmc_dev(host->mmc), "pins configured for wake-up events\n"); + + return 0; + +err: + dev_err(mmc_dev(host->mmc), "pins configuration error: %i\n", ret); + +out: + return ret; +} + /* * Start clock to the card */ @@ -1854,11 +1939,10 @@ static int omap_hsmmc_probe(struct platform_device *pdev) struct mmc_host *mmc; struct omap_hsmmc_host *host = NULL; struct resource *res; - int ret, irq; + int ret, irq, irq2; const struct of_device_id *match; dma_cap_mask_t mask; unsigned tx_req, rx_req; - struct pinctrl *pinctrl; match = of_match_device(of_match_ptr(omap_mmc_of_match), &pdev->dev); if (match) { @@ -1891,6 +1975,10 @@ static int omap_hsmmc_probe(struct platform_device *pdev) if (res == NULL || irq < 0) return -ENXIO; + irq2 = 0; + if (pdev->dev.of_node) + irq2 = irq_of_parse_and_map(pdev->dev.of_node, 1); + res = request_mem_region(res->start, resource_size(res), pdev->name); if (res == NULL) return -EBUSY; @@ -1912,6 +2000,7 @@ static int omap_hsmmc_probe(struct platform_device *pdev) host->use_dma = 1; host->dma_ch = -1; host->irq = irq; + host->gpio_sdio_irq = irq2; host->slot_id = 0; host->mapbase = res->start + pdata->reg_offset; host->base = ioremap(host->mapbase, SZ_4K); @@ -2083,10 +2172,9 @@ static int omap_hsmmc_probe(struct platform_device *pdev) omap_hsmmc_disable_irq(host); - pinctrl = devm_pinctrl_get_select_default(&pdev->dev); - if (IS_ERR(pinctrl)) - dev_warn(&pdev->dev, - "pins are not configured from the driver\n"); + ret = omap_hsmmc_pin_init(host); + if (ret) + goto err_pinctrl_state; /* * For now, only support SDIO interrupt if we are booted with @@ -2098,8 +2186,28 @@ static int omap_hsmmc_probe(struct platform_device *pdev) if (pdev->dev.of_node) { mmc->caps |= MMC_CAP_SDIO_IRQ; if (pdata->controller_flags & OMAP_HSMMC_SWAKEUP_MISSING) { - /* no wakeup from deeper power states, use polling */ - mmc->caps &= ~MMC_CAP_SDIO_IRQ; + /* use GPIO to wakeup from deeper power states */ + if (!host->idle || !host->gpio_sdio_irq) { + dev_warn(mmc_dev(host->mmc), + "Disable SDIO IRQ workaround, GPIO IRQ or pinctrl idle state missing, falling back to polling\n"); + mmc->caps &= ~MMC_CAP_SDIO_IRQ; + } else { + host->flags |= HSMMC_SWAKEUP_QUIRK; + + } + } + + if (host->flags & HSMMC_SWAKEUP_QUIRK) { + /* prevent auto-enabling of IRQ */ + irq_set_status_flags(host->gpio_sdio_irq, IRQ_NOAUTOEN); + ret = request_irq(host->gpio_sdio_irq, omap_hsmmc_cirq, + IRQF_TRIGGER_LOW | IRQF_ONESHOT, + mmc_hostname(mmc), host); + if (ret) { + dev_err(mmc_dev(host->mmc), + "Unable to grab GPIO SDIO IRQ\n"); + goto err_irq_sdio; + } } } @@ -2127,7 +2235,13 @@ static int omap_hsmmc_probe(struct platform_device *pdev) err_slot_name: mmc_remove_host(mmc); - free_irq(mmc_slot(host).card_detect_irq, host); + if (host->gpio_sdio_irq) + free_irq(host->gpio_sdio_irq, host); +err_irq_sdio: + devm_pinctrl_put(host->pinctrl); +err_pinctrl_state: + if ((mmc_slot(host).card_detect_irq)) + free_irq(mmc_slot(host).card_detect_irq, host); err_irq_cd: if (host->use_reg) omap_hsmmc_reg_put(host); @@ -2172,13 +2286,15 @@ static int omap_hsmmc_remove(struct platform_device *pdev) if (host->pdata->cleanup) host->pdata->cleanup(&pdev->dev); free_irq(host->irq, host); + if ((host->gpio_sdio_irq)) + free_irq(host->gpio_sdio_irq, host); if (mmc_slot(host).card_detect_irq) free_irq(mmc_slot(host).card_detect_irq, host); - if (host->tx_chan) dma_release_channel(host->tx_chan); if (host->rx_chan) dma_release_channel(host->rx_chan); + devm_pinctrl_put(host->pinctrl); pm_runtime_put_sync(host->dev); pm_runtime_disable(host->dev); @@ -2234,6 +2350,9 @@ static int omap_hsmmc_suspend(struct device *dev) OMAP_HSMMC_READ(host->base, HCTL) & ~SDBP); } + if (host->flags & HSMMC_SWAKEUP_QUIRK) + disable_irq(host->gpio_sdio_irq); + if (host->dbclk) clk_disable_unprepare(host->dbclk); @@ -2259,6 +2378,9 @@ static int omap_hsmmc_resume(struct device *dev) omap_hsmmc_protect_card(host); + if (host->flags & HSMMC_SWAKEUP_QUIRK) + enable_irq(host->gpio_sdio_irq); + pm_runtime_mark_last_busy(host->dev); pm_runtime_put_autosuspend(host->dev); return 0; @@ -2274,23 +2396,61 @@ static int omap_hsmmc_resume(struct device *dev) static int omap_hsmmc_runtime_suspend(struct device *dev) { struct omap_hsmmc_host *host; + unsigned long flags; + int ret = 0; host = platform_get_drvdata(to_platform_device(dev)); omap_hsmmc_context_save(host); dev_dbg(dev, "disabled\n"); - return 0; + if (host->flags & HSMMC_SWAKEUP_QUIRK) { + OMAP_HSMMC_WRITE(host->base, ISE, 0); + OMAP_HSMMC_WRITE(host->base, IE, 0); + OMAP_HSMMC_WRITE(host->base, STAT, STAT_CLEAR); + + ret = pinctrl_select_state(host->pinctrl, host->idle); + if (ret < 0) + dev_warn(mmc_dev(host->mmc), "Unable to select idle pinmux\n"); + + spin_lock_irqsave(&host->irq_lock, flags); + if (host->flags & HSMMC_SDIO_IRQ_ENABLED) { + enable_irq(host->gpio_sdio_irq); + host->flags |= HSMMC_CIRQ_GPIO_ENABLED; + } + spin_unlock_irqrestore(&host->irq_lock, flags); + } + + return ret; } static int omap_hsmmc_runtime_resume(struct device *dev) { struct omap_hsmmc_host *host; + unsigned long flags; + int ret = 0; host = platform_get_drvdata(to_platform_device(dev)); omap_hsmmc_context_restore(host); dev_dbg(dev, "enabled\n"); - return 0; + if (host->flags & HSMMC_SWAKEUP_QUIRK) { + + spin_lock_irqsave(&host->irq_lock, flags); + if (host->flags & HSMMC_CIRQ_GPIO_ENABLED) { + disable_irq_nosync(host->gpio_sdio_irq); + host->flags &= ~HSMMC_CIRQ_GPIO_ENABLED; + } + spin_unlock_irqrestore(&host->irq_lock, flags); + + ret = pinctrl_select_state(host->pinctrl, host->active); + if (ret < 0) + dev_warn(mmc_dev(host->mmc), "Unable to select active pinmux\n"); + + OMAP_HSMMC_WRITE(host->base, STAT, STAT_CLEAR); + OMAP_HSMMC_WRITE(host->base, ISE, CIRQ_EN); + OMAP_HSMMC_WRITE(host->base, IE, CIRQ_EN); + } + return ret; } static struct dev_pm_ops omap_hsmmc_dev_pm_ops = {