From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id E1A2AC10F03 for ; Fri, 22 Mar 2019 15:48:19 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id BAB512183E for ; Fri, 22 Mar 2019 15:48:19 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728607AbfCVPsS (ORCPT ); Fri, 22 Mar 2019 11:48:18 -0400 Received: from mga11.intel.com ([192.55.52.93]:60908 "EHLO mga11.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727169AbfCVPsS (ORCPT ); Fri, 22 Mar 2019 11:48:18 -0400 X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga001.fm.intel.com ([10.253.24.23]) by fmsmga102.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 22 Mar 2019 08:48:18 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.60,256,1549958400"; d="scan'208";a="157461971" Received: from mattu-haswell.fi.intel.com ([10.237.72.164]) by fmsmga001.fm.intel.com with ESMTP; 22 Mar 2019 08:48:16 -0700 From: Mathias Nyman To: Cc: , Mathias Nyman , stable@vger.kernel.org Subject: [PATCH 3/3] xhci: Don't let USB3 ports stuck in polling state prevent suspend Date: Fri, 22 Mar 2019 17:50:17 +0200 Message-Id: <1553269817-19312-4-git-send-email-mathias.nyman@linux.intel.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1553269817-19312-1-git-send-email-mathias.nyman@linux.intel.com> References: <1553269817-19312-1-git-send-email-mathias.nyman@linux.intel.com> Sender: stable-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: stable@vger.kernel.org Commit 2f31a67f01a8 ("usb: xhci: Prevent bus suspend if a port connect change or polling state is detected") was intended to prevent ports that were still link training from being forced to U3 suspend state mid enumeration. This solved enumeration issues for devices with slow link training. Turns out some devices are stuck in the link training/polling state, and thus that patch will prevent suspend completely for these devices. This is seen with USB3 card readers in some MacBooks. Instead of preventing suspend, give some time to complete the link training. On successful training the port will end up as connected and enabled. If port instead is stuck in link training the bus suspend will continue suspending after 360ms (10 * 36ms) timeout (tPollingLFPSTimeout). Original patch was sent to stable, this one should go there as well Fixes: 2f31a67f01a8 ("usb: xhci: Prevent bus suspend if a port connect change or polling state is detected") Cc: stable@vger.kernel.org Signed-off-by: Mathias Nyman --- drivers/usb/host/xhci-hub.c | 19 ++++++++++++------- drivers/usb/host/xhci.h | 8 ++++++++ 2 files changed, 20 insertions(+), 7 deletions(-) diff --git a/drivers/usb/host/xhci-hub.c b/drivers/usb/host/xhci-hub.c index e2eece6..96a7405 100644 --- a/drivers/usb/host/xhci-hub.c +++ b/drivers/usb/host/xhci-hub.c @@ -1545,20 +1545,25 @@ int xhci_bus_suspend(struct usb_hcd *hcd) port_index = max_ports; while (port_index--) { u32 t1, t2; - + int retries = 10; +retry: t1 = readl(ports[port_index]->addr); t2 = xhci_port_state_to_neutral(t1); portsc_buf[port_index] = 0; - /* Bail out if a USB3 port has a new device in link training */ - if ((hcd->speed >= HCD_USB3) && + /* + * Give a USB3 port in link training time to finish, but don't + * prevent suspend as port might be stuck + */ + if ((hcd->speed >= HCD_USB3) && retries-- && (t1 & PORT_PLS_MASK) == XDEV_POLLING) { - bus_state->bus_suspended = 0; spin_unlock_irqrestore(&xhci->lock, flags); - xhci_dbg(xhci, "Bus suspend bailout, port in polling\n"); - return -EBUSY; + msleep(XHCI_PORT_POLLING_LFPS_TIME); + spin_lock_irqsave(&xhci->lock, flags); + xhci_dbg(xhci, "port %d polling in bus suspend, waiting\n", + port_index); + goto retry; } - /* suspend ports in U0, or bail out for new connect changes */ if ((t1 & PORT_PE) && (t1 & PORT_PLS_MASK) == XDEV_U0) { if ((t1 & PORT_CSC) && wake_enabled) { diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h index 652dc36..9334cde 100644 --- a/drivers/usb/host/xhci.h +++ b/drivers/usb/host/xhci.h @@ -452,6 +452,14 @@ struct xhci_op_regs { */ #define XHCI_DEFAULT_BESL 4 +/* + * USB3 specification define a 360ms tPollingLFPSTiemout for USB3 ports + * to complete link training. usually link trainig completes much faster + * so check status 10 times with 36ms sleep in places we need to wait for + * polling to complete. + */ +#define XHCI_PORT_POLLING_LFPS_TIME 36 + /** * struct xhci_intr_reg - Interrupt Register Set * @irq_pending: IMAN - Interrupt Management Register. Used to enable -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [3/3] xhci: Don't let USB3 ports stuck in polling state prevent suspend From: Mathias Nyman Message-Id: <1553269817-19312-4-git-send-email-mathias.nyman@linux.intel.com> Date: Fri, 22 Mar 2019 17:50:17 +0200 To: gregkh@linuxfoundation.org Cc: linux-usb@vger.kernel.org, Mathias Nyman , stable@vger.kernel.org List-ID: Q29tbWl0IDJmMzFhNjdmMDFhOCAoInVzYjogeGhjaTogUHJldmVudCBidXMgc3VzcGVuZCBpZiBh IHBvcnQgY29ubmVjdApjaGFuZ2Ugb3IgcG9sbGluZyBzdGF0ZSBpcyBkZXRlY3RlZCIpIHdhcyBp bnRlbmRlZCB0byBwcmV2ZW50IHBvcnRzIHRoYXQKd2VyZSBzdGlsbCBsaW5rIHRyYWluaW5nIGZy b20gYmVpbmcgZm9yY2VkIHRvIFUzIHN1c3BlbmQgc3RhdGUgbWlkCmVudW1lcmF0aW9uLgpUaGlz IHNvbHZlZCBlbnVtZXJhdGlvbiBpc3N1ZXMgZm9yIGRldmljZXMgd2l0aCBzbG93IGxpbmsgdHJh aW5pbmcuCgpUdXJucyBvdXQgc29tZSBkZXZpY2VzIGFyZSBzdHVjayBpbiB0aGUgbGluayB0cmFp bmluZy9wb2xsaW5nIHN0YXRlLAphbmQgdGh1cyB0aGF0IHBhdGNoIHdpbGwgcHJldmVudCBzdXNw ZW5kIGNvbXBsZXRlbHkgZm9yIHRoZXNlIGRldmljZXMuClRoaXMgaXMgc2VlbiB3aXRoIFVTQjMg Y2FyZCByZWFkZXJzIGluIHNvbWUgTWFjQm9va3MuCgpJbnN0ZWFkIG9mIHByZXZlbnRpbmcgc3Vz cGVuZCwgZ2l2ZSBzb21lIHRpbWUgdG8gY29tcGxldGUgdGhlIGxpbmsKdHJhaW5pbmcuIE9uIHN1 Y2Nlc3NmdWwgdHJhaW5pbmcgdGhlIHBvcnQgd2lsbCBlbmQgdXAgYXMgY29ubmVjdGVkCmFuZCBl bmFibGVkLgpJZiBwb3J0IGluc3RlYWQgaXMgc3R1Y2sgaW4gbGluayB0cmFpbmluZyB0aGUgYnVz IHN1c3BlbmQgd2lsbCBjb250aW51ZQpzdXNwZW5kaW5nIGFmdGVyIDM2MG1zICgxMCAqIDM2bXMp IHRpbWVvdXQgKHRQb2xsaW5nTEZQU1RpbWVvdXQpLgoKT3JpZ2luYWwgcGF0Y2ggd2FzIHNlbnQg dG8gc3RhYmxlLCB0aGlzIG9uZSBzaG91bGQgZ28gdGhlcmUgYXMgd2VsbAoKRml4ZXM6IDJmMzFh NjdmMDFhOCAoInVzYjogeGhjaTogUHJldmVudCBidXMgc3VzcGVuZCBpZiBhIHBvcnQgY29ubmVj dCBjaGFuZ2Ugb3IgcG9sbGluZyBzdGF0ZSBpcyBkZXRlY3RlZCIpCkNjOiBzdGFibGVAdmdlci5r ZXJuZWwub3JnClNpZ25lZC1vZmYtYnk6IE1hdGhpYXMgTnltYW4gPG1hdGhpYXMubnltYW5AbGlu dXguaW50ZWwuY29tPgotLS0KIGRyaXZlcnMvdXNiL2hvc3QveGhjaS1odWIuYyB8IDE5ICsrKysr KysrKysrKy0tLS0tLS0KIGRyaXZlcnMvdXNiL2hvc3QveGhjaS5oICAgICB8ICA4ICsrKysrKysr CiAyIGZpbGVzIGNoYW5nZWQsIDIwIGluc2VydGlvbnMoKyksIDcgZGVsZXRpb25zKC0pCgpkaWZm IC0tZ2l0IGEvZHJpdmVycy91c2IvaG9zdC94aGNpLWh1Yi5jIGIvZHJpdmVycy91c2IvaG9zdC94 aGNpLWh1Yi5jCmluZGV4IGUyZWVjZTYuLjk2YTc0MDUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNi L2hvc3QveGhjaS1odWIuYworKysgYi9kcml2ZXJzL3VzYi9ob3N0L3hoY2ktaHViLmMKQEAgLTE1 NDUsMjAgKzE1NDUsMjUgQEAgaW50IHhoY2lfYnVzX3N1c3BlbmQoc3RydWN0IHVzYl9oY2QgKmhj ZCkKIAlwb3J0X2luZGV4ID0gbWF4X3BvcnRzOwogCXdoaWxlIChwb3J0X2luZGV4LS0pIHsKIAkJ dTMyIHQxLCB0MjsKLQorCQlpbnQgcmV0cmllcyA9IDEwOworcmV0cnk6CiAJCXQxID0gcmVhZGwo cG9ydHNbcG9ydF9pbmRleF0tPmFkZHIpOwogCQl0MiA9IHhoY2lfcG9ydF9zdGF0ZV90b19uZXV0 cmFsKHQxKTsKIAkJcG9ydHNjX2J1Zltwb3J0X2luZGV4XSA9IDA7CiAKLQkJLyogQmFpbCBvdXQg aWYgYSBVU0IzIHBvcnQgaGFzIGEgbmV3IGRldmljZSBpbiBsaW5rIHRyYWluaW5nICovCi0JCWlm ICgoaGNkLT5zcGVlZCA+PSBIQ0RfVVNCMykgJiYKKwkJLyoKKwkJICogR2l2ZSBhIFVTQjMgcG9y dCBpbiBsaW5rIHRyYWluaW5nIHRpbWUgdG8gZmluaXNoLCBidXQgZG9uJ3QKKwkJICogcHJldmVu dCBzdXNwZW5kIGFzIHBvcnQgbWlnaHQgYmUgc3R1Y2sKKwkJICovCisJCWlmICgoaGNkLT5zcGVl ZCA+PSBIQ0RfVVNCMykgJiYgcmV0cmllcy0tICYmCiAJCSAgICAodDEgJiBQT1JUX1BMU19NQVNL KSA9PSBYREVWX1BPTExJTkcpIHsKLQkJCWJ1c19zdGF0ZS0+YnVzX3N1c3BlbmRlZCA9IDA7CiAJ CQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZ4aGNpLT5sb2NrLCBmbGFncyk7Ci0JCQl4aGNpX2Ri Zyh4aGNpLCAiQnVzIHN1c3BlbmQgYmFpbG91dCwgcG9ydCBpbiBwb2xsaW5nXG4iKTsKLQkJCXJl dHVybiAtRUJVU1k7CisJCQltc2xlZXAoWEhDSV9QT1JUX1BPTExJTkdfTEZQU19USU1FKTsKKwkJ CXNwaW5fbG9ja19pcnFzYXZlKCZ4aGNpLT5sb2NrLCBmbGFncyk7CisJCQl4aGNpX2RiZyh4aGNp LCAicG9ydCAlZCBwb2xsaW5nIGluIGJ1cyBzdXNwZW5kLCB3YWl0aW5nXG4iLAorCQkJCSBwb3J0 X2luZGV4KTsKKwkJCWdvdG8gcmV0cnk7CiAJCX0KLQogCQkvKiBzdXNwZW5kIHBvcnRzIGluIFUw LCBvciBiYWlsIG91dCBmb3IgbmV3IGNvbm5lY3QgY2hhbmdlcyAqLwogCQlpZiAoKHQxICYgUE9S VF9QRSkgJiYgKHQxICYgUE9SVF9QTFNfTUFTSykgPT0gWERFVl9VMCkgewogCQkJaWYgKCh0MSAm IFBPUlRfQ1NDKSAmJiB3YWtlX2VuYWJsZWQpIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2hv c3QveGhjaS5oIGIvZHJpdmVycy91c2IvaG9zdC94aGNpLmgKaW5kZXggNjUyZGMzNi4uOTMzNGNk ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvaG9zdC94aGNpLmgKKysrIGIvZHJpdmVycy91c2Iv aG9zdC94aGNpLmgKQEAgLTQ1Miw2ICs0NTIsMTQgQEAgc3RydWN0IHhoY2lfb3BfcmVncyB7CiAg Ki8KICNkZWZpbmUgWEhDSV9ERUZBVUxUX0JFU0wJNAogCisvKgorICogVVNCMyBzcGVjaWZpY2F0 aW9uIGRlZmluZSBhIDM2MG1zIHRQb2xsaW5nTEZQU1RpZW1vdXQgZm9yIFVTQjMgcG9ydHMKKyAq IHRvIGNvbXBsZXRlIGxpbmsgdHJhaW5pbmcuIHVzdWFsbHkgbGluayB0cmFpbmlnIGNvbXBsZXRl cyBtdWNoIGZhc3RlcgorICogc28gY2hlY2sgc3RhdHVzIDEwIHRpbWVzIHdpdGggMzZtcyBzbGVl cCBpbiBwbGFjZXMgd2UgbmVlZCB0byB3YWl0IGZvcgorICogcG9sbGluZyB0byBjb21wbGV0ZS4K KyAqLworI2RlZmluZSBYSENJX1BPUlRfUE9MTElOR19MRlBTX1RJTUUgIDM2CisKIC8qKgogICog c3RydWN0IHhoY2lfaW50cl9yZWcgLSBJbnRlcnJ1cHQgUmVnaXN0ZXIgU2V0CiAgKiBAaXJxX3Bl bmRpbmc6CUlNQU4gLSBJbnRlcnJ1cHQgTWFuYWdlbWVudCBSZWdpc3Rlci4gIFVzZWQgdG8gZW5h YmxlCg==