From mboxrd@z Thu Jan 1 00:00:00 1970 From: Bjorn Helgaas Subject: Re: [PATCH] pci: fix incorrect value returned from pcie_get_speed_cap Date: Mon, 26 Nov 2018 16:33:41 -0600 Message-ID: <20181126223340.GA212532@google.com> References: Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: List-Id: Discussion list for AMD gfx List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: amd-gfx-bounces-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Sender: "amd-gfx" To: Mikulas Patocka Cc: Tal Gilboa , linux-pci-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Alex Deucher , amd-gfx-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, Tariq Toukan T24gVHVlLCBPY3QgMzAsIDIwMTggYXQgMTI6MzY6MDhQTSAtMDQwMCwgTWlrdWxhcyBQYXRvY2th IHdyb3RlOgo+IFRoZSBtYWNyb3MgUENJX0VYUF9MTktDQVBfU0xTXypHQiBhcmUgdmFsdWVzLCBu b3QgYml0IG1hc2tzLiBXZSBtdXN0IG1hc2sKPiB0aGUgcmVnaXN0ZXIgYW5kIGNvbXBhcmUgaXQg YWdhaW5zdCB0aGVtLgo+IAo+IFRoaXMgcGF0Y2ggZml4ZXMgZXJyb3JzICJhbWRncHU6IFtwb3dl cnBsYXldIGZhaWxlZCB0byBzZW5kIG1lc3NhZ2UgMjYxCj4gcmV0IGlzIDAiIGVycm9ycyB3aGVu IFBDSWUtdjMgY2FyZCBpcyBwbHVnZ2VkIGludG8gUENJZS12MSBzbG90LCBiZWNhdXNlCj4gdGhl IHNsb3QgaXMgYmVpbmcgaW5jb3JyZWN0bHkgcmVwb3J0ZWQgYXMgUENJZS12MyBjYXBhYmxlLgo+ IAo+IFNpZ25lZC1vZmYtYnk6IE1pa3VsYXMgUGF0b2NrYSA8bXBhdG9ja2FAcmVkaGF0LmNvbT4K CkFwcGxpZWQgdGhlIHBhdGNoIGJlbG93IHRvIGZvci1saW51cyBmb3IgdjQuMjAgYW5kIGJhY2tw b3J0IHRvIHY0LjE3KwpzdGFibGUga2VybmVscywgdGhhbmtzIQoKSSByZW1vdmVkIHRoZSAiaWYg KGxua2NhcCkiIHRlc3QgYmVjYXVzZSB0aGUgTE5LQ0FQIGNhc2UgaXMgbm90CnBhcmFsbGVsIHRv IHRoZSBMTktDQVAyIGNhc2UuICBMTktDQVAyIGlzIG9wdGlvbmFsIHNvIHdlIGhhdmUgdG8gdGVz dApmb3IgbG5rY2FwMiBiZWluZyBub24temVyby4gIEJ1dCBMTktDQVAgaXMgcmVxdWlyZWQgZm9y IGFsbCBkZXZpY2VzLgpJZiB0aGUgY29uZmlnIHJlYWQgb2YgaXQgZmFpbHMsIHdlIHNob3VsZCBn ZXQgZWl0aGVyIDAgb3IgfjAsIGFuZApuZWl0aGVyIG9uZSB3aWxsIHNhdGlzZnkgdGhlIDUuMCBv ciAyLjUgY2hlY2tzLgoKPiBGaXhlczogNmNmNTdiZTBmNzhlICgiUENJOiBBZGQgcGNpZV9nZXRf c3BlZWRfY2FwKCkgdG8gZmluZCBtYXggc3VwcG9ydGVkIGxpbmsgc3BlZWQiKQo+IENjOiBzdGFi bGVAdmdlci5rZXJuZWwub3JnCSMgdjQuMTcrCj4gCj4gLS0tCj4gIGRyaXZlcnMvcGNpL3BjaS5j IHwgICAgOCArKysrLS0tLQo+ICAxIGZpbGUgY2hhbmdlZCwgNCBpbnNlcnRpb25zKCspLCA0IGRl bGV0aW9ucygtKQo+IAo+IEluZGV4OiBsaW51eC00LjE5L2RyaXZlcnMvcGNpL3BjaS5jCj4gPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQo+IC0tLSBsaW51eC00LjE5Lm9yaWcvZHJpdmVycy9wY2kvcGNpLmMJMjAxOC0xMC0z MCAxNjo1ODo1OC4wMDAwMDAwMDAgKzAxMDAKPiArKysgbGludXgtNC4xOS9kcml2ZXJzL3BjaS9w Y2kuYwkyMDE4LTEwLTMwIDE2OjU4OjU4LjAwMDAwMDAwMCArMDEwMAo+IEBAIC01NDkyLDEzICs1 NDkyLDEzIEBAIGVudW0gcGNpX2J1c19zcGVlZCBwY2llX2dldF9zcGVlZF9jYXAoc3QKPiAgCj4g IAlwY2llX2NhcGFiaWxpdHlfcmVhZF9kd29yZChkZXYsIFBDSV9FWFBfTE5LQ0FQLCAmbG5rY2Fw KTsKPiAgCWlmIChsbmtjYXApIHsKPiAtCQlpZiAobG5rY2FwICYgUENJX0VYUF9MTktDQVBfU0xT XzE2XzBHQikKPiArCQlpZiAoKGxua2NhcCAmIFBDSV9FWFBfTE5LQ0FQX1NMUykgPT0gUENJX0VY UF9MTktDQVBfU0xTXzE2XzBHQikKPiAgCQkJcmV0dXJuIFBDSUVfU1BFRURfMTZfMEdUOwo+IC0J CWVsc2UgaWYgKGxua2NhcCAmIFBDSV9FWFBfTE5LQ0FQX1NMU184XzBHQikKPiArCQllbHNlIGlm ICgobG5rY2FwICYgUENJX0VYUF9MTktDQVBfU0xTKSA9PSBQQ0lfRVhQX0xOS0NBUF9TTFNfOF8w R0IpCj4gIAkJCXJldHVybiBQQ0lFX1NQRUVEXzhfMEdUOwo+IC0JCWVsc2UgaWYgKGxua2NhcCAm IFBDSV9FWFBfTE5LQ0FQX1NMU181XzBHQikKPiArCQllbHNlIGlmICgobG5rY2FwICYgUENJX0VY UF9MTktDQVBfU0xTKSA9PVBDSV9FWFBfTE5LQ0FQX1NMU181XzBHQikKPiAgCQkJcmV0dXJuIFBD SUVfU1BFRURfNV8wR1Q7Cj4gLQkJZWxzZSBpZiAobG5rY2FwICYgUENJX0VYUF9MTktDQVBfU0xT XzJfNUdCKQo+ICsJCWVsc2UgaWYgKChsbmtjYXAgJiBQQ0lfRVhQX0xOS0NBUF9TTFMpID09IFBD SV9FWFBfTE5LQ0FQX1NMU18yXzVHQikKPiAgCQkJcmV0dXJuIFBDSUVfU1BFRURfMl81R1Q7Cj4g IAl9Cj4gIAoKY29tbWl0IDk0ZWEwMWE2ZDlhNgpBdXRob3I6IE1pa3VsYXMgUGF0b2NrYSA8bXBh dG9ja2FAcmVkaGF0LmNvbT4KRGF0ZTogICBNb24gTm92IDI2IDEwOjM3OjEzIDIwMTggLTA2MDAK CiAgICBQQ0k6IEZpeCBpbmNvcnJlY3QgdmFsdWUgcmV0dXJuZWQgZnJvbSBwY2llX2dldF9zcGVl ZF9jYXAoKQogICAgCiAgICBUaGUgbWFjcm9zIFBDSV9FWFBfTE5LQ0FQX1NMU18qR0IgYXJlIHZh bHVlcywgbm90IGJpdCBtYXNrcy4gIFdlIG11c3QgbWFzawogICAgdGhlIHJlZ2lzdGVyIGFuZCBj b21wYXJlIGl0IGFnYWluc3QgdGhlbS4KICAgIAogICAgVGhpcyBmaXhlcyBlcnJvcnMgbGlrZSB0 aGlzOgogICAgCiAgICAgIGFtZGdwdTogW3Bvd2VycGxheV0gZmFpbGVkIHRvIHNlbmQgbWVzc2Fn ZSAyNjEgcmV0IGlzIDAKICAgIAogICAgd2hlbiBQQ0llLXYzIGNhcmQgaXMgcGx1Z2dlZCBpbnRv IGEgUENJZS12MSBzbG90LCBiZWNhdXNlIHRoZSBzbG90IGlzIGJlaW5nCiAgICBpbmNvcnJlY3Rs eSByZXBvcnRlZCBhcyBQQ0llLXYzIGNhcGFibGUuCiAgICAKICAgIDZjZjU3YmUwZjc4ZSwgd2hp Y2ggYXBwZWFyZWQgaW4gdjQuMTcsIGFkZGVkIHBjaWVfZ2V0X3NwZWVkX2NhcCgpIHdpdGggdGhl CiAgICBpbmNvcnJlY3QgdGVzdCBvZiBQQ0lfRVhQX0xOS0NBUF9TTFMgYXMgYSBiaXRtYXNrLiAg NWQ5YTYzMzA0MDMyLCB3aGljaAogICAgYXBwZWFyZWQgaW4gdjQuMTksIGNoYW5nZWQgYW1kZ3B1 IHRvIHVzZSBwY2llX2dldF9zcGVlZF9jYXAoKSwgc28gdGhlCiAgICBhbWRncHUgYnVnIHJlcG9y dHMgYmVsb3cgYXJlIHJlZ3Jlc3Npb25zIGluIHY0LjE5LgogICAgCiAgICBGaXhlczogNmNmNTdi ZTBmNzhlICgiUENJOiBBZGQgcGNpZV9nZXRfc3BlZWRfY2FwKCkgdG8gZmluZCBtYXggc3VwcG9y dGVkIGxpbmsgc3BlZWQiKQogICAgRml4ZXM6IDVkOWE2MzMwNDAzMiAoImRybS9hbWRncHU6IHVz ZSBwY2llIGZ1bmN0aW9ucyBmb3IgbGluayB3aWR0aCBhbmQgc3BlZWQiKQogICAgTGluazogaHR0 cHM6Ly9idWdzLmZyZWVkZXNrdG9wLm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTA4NzA0CiAgICBMaW5r OiBodHRwczovL2J1Z3MuZnJlZWRlc2t0b3Aub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDg3NzgKICAg IFNpZ25lZC1vZmYtYnk6IE1pa3VsYXMgUGF0b2NrYSA8bXBhdG9ja2FAcmVkaGF0LmNvbT4KICAg IFtiaGVsZ2FhczogdXBkYXRlIGNvbW1lbnQsIHJlbW92ZSB1c2Ugb2YgUENJX0VYUF9MTktDQVBf U0xTXzhfMEdCIGFuZAogICAgUENJX0VYUF9MTktDQVBfU0xTXzE2XzBHQiBzaW5jZSB0aG9zZSBz aG91bGQgYmUgY292ZXJlZCBieSBQQ0lfRVhQX0xOS0NBUDIsCiAgICByZW1vdmUgdGVzdCBvZiBQ Q0lfRVhQX0xOS0NBUCBmb3IgemVybywgc2luY2UgdGhhdCByZWdpc3RlciBpcyByZXF1aXJlZF0K ICAgIFNpZ25lZC1vZmYtYnk6IEJqb3JuIEhlbGdhYXMgPGJoZWxnYWFzQGdvb2dsZS5jb20+CiAg ICBBY2tlZC1ieTogQWxleCBEZXVjaGVyIDxhbGV4YW5kZXIuZGV1Y2hlckBhbWQuY29tPgogICAg Q2M6IHN0YWJsZUB2Z2VyLmtlcm5lbC5vcmcgICAgICAjIHY0LjE3KwoKZGlmZiAtLWdpdCBhL2Ry aXZlcnMvcGNpL3BjaS5jIGIvZHJpdmVycy9wY2kvcGNpLmMKaW5kZXggZDA2OGYxMWQwOGE3Li5j OWQ4ZTNjODM3ZGUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGNpL3BjaS5jCisrKyBiL2RyaXZlcnMv cGNpL3BjaS5jCkBAIC01NTU2LDkgKzU1NTYsMTMgQEAgZW51bSBwY2lfYnVzX3NwZWVkIHBjaWVf Z2V0X3NwZWVkX2NhcChzdHJ1Y3QgcGNpX2RldiAqZGV2KQogCXUzMiBsbmtjYXAyLCBsbmtjYXA7 CiAKIAkvKgotCSAqIFBDSWUgcjQuMCBzZWMgNy41LjMuMTggcmVjb21tZW5kcyB1c2luZyB0aGUg U3VwcG9ydGVkIExpbmsKLQkgKiBTcGVlZHMgVmVjdG9yIGluIExpbmsgQ2FwYWJpbGl0aWVzIDIg d2hlbiBzdXBwb3J0ZWQsIGZhbGxpbmcKLQkgKiBiYWNrIHRvIE1heCBMaW5rIFNwZWVkIGluIExp bmsgQ2FwYWJpbGl0aWVzIG90aGVyd2lzZS4KKwkgKiBMaW5rIENhcGFiaWxpdGllcyAyIHdhcyBh ZGRlZCBpbiBQQ0llIHIzLjAsIHNlYyA3LjguMTguICBUaGUKKwkgKiBpbXBsZW1lbnRhdGlvbiBu b3RlIHRoZXJlIHJlY29tbWVuZHMgdXNpbmcgdGhlIFN1cHBvcnRlZCBMaW5rCisJICogU3BlZWRz IFZlY3RvciBpbiBMaW5rIENhcGFiaWxpdGllcyAyIHdoZW4gc3VwcG9ydGVkLgorCSAqCisJICog V2l0aG91dCBMaW5rIENhcGFiaWxpdGllcyAyLCBpLmUuLCBwcmlvciB0byBQQ0llIHIzLjAsIHNv ZnR3YXJlCisJICogc2hvdWxkIHVzZSB0aGUgU3VwcG9ydGVkIExpbmsgU3BlZWRzIGZpZWxkIGlu IExpbmsgQ2FwYWJpbGl0aWVzLAorCSAqIHdoZXJlIG9ubHkgMi41IEdUL3MgYW5kIDUuMCBHVC9z IHNwZWVkcyB3ZXJlIGRlZmluZWQuCiAJICovCiAJcGNpZV9jYXBhYmlsaXR5X3JlYWRfZHdvcmQo ZGV2LCBQQ0lfRVhQX0xOS0NBUDIsICZsbmtjYXAyKTsKIAlpZiAobG5rY2FwMikgeyAvKiBQQ0ll IHIzLjAtY29tcGxpYW50ICovCkBAIC01NTc0LDE2ICs1NTc4LDEwIEBAIGVudW0gcGNpX2J1c19z cGVlZCBwY2llX2dldF9zcGVlZF9jYXAoc3RydWN0IHBjaV9kZXYgKmRldikKIAl9CiAKIAlwY2ll X2NhcGFiaWxpdHlfcmVhZF9kd29yZChkZXYsIFBDSV9FWFBfTE5LQ0FQLCAmbG5rY2FwKTsKLQlp ZiAobG5rY2FwKSB7Ci0JCWlmIChsbmtjYXAgJiBQQ0lfRVhQX0xOS0NBUF9TTFNfMTZfMEdCKQot CQkJcmV0dXJuIFBDSUVfU1BFRURfMTZfMEdUOwotCQllbHNlIGlmIChsbmtjYXAgJiBQQ0lfRVhQ X0xOS0NBUF9TTFNfOF8wR0IpCi0JCQlyZXR1cm4gUENJRV9TUEVFRF84XzBHVDsKLQkJZWxzZSBp ZiAobG5rY2FwICYgUENJX0VYUF9MTktDQVBfU0xTXzVfMEdCKQotCQkJcmV0dXJuIFBDSUVfU1BF RURfNV8wR1Q7Ci0JCWVsc2UgaWYgKGxua2NhcCAmIFBDSV9FWFBfTE5LQ0FQX1NMU18yXzVHQikK LQkJCXJldHVybiBQQ0lFX1NQRUVEXzJfNUdUOwotCX0KKwlpZiAoKGxua2NhcCAmIFBDSV9FWFBf TE5LQ0FQX1NMUykgPT0gUENJX0VYUF9MTktDQVBfU0xTXzVfMEdCKQorCQlyZXR1cm4gUENJRV9T UEVFRF81XzBHVDsKKwllbHNlIGlmICgobG5rY2FwICYgUENJX0VYUF9MTktDQVBfU0xTKSA9PSBQ Q0lfRVhQX0xOS0NBUF9TTFNfMl81R0IpCisJCXJldHVybiBQQ0lFX1NQRUVEXzJfNUdUOwogCiAJ cmV0dXJuIFBDSV9TUEVFRF9VTktOT1dOOwogfQpfX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fXwphbWQtZ2Z4IG1haWxpbmcgbGlzdAphbWQtZ2Z4QGxpc3RzLmZy ZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3Rp bmZvL2FtZC1nZngK 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=-10.1 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_PASS,URIBL_BLOCKED,USER_AGENT_MUTT 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 05451C43441 for ; Mon, 26 Nov 2018 22:33:46 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id B7B2921104 for ; Mon, 26 Nov 2018 22:33:45 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=kernel.org header.i=@kernel.org header.b="jyCFPS5s" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org B7B2921104 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=kernel.org Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-pci-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726516AbeK0J3W (ORCPT ); Tue, 27 Nov 2018 04:29:22 -0500 Received: from mail.kernel.org ([198.145.29.99]:56976 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726513AbeK0J3W (ORCPT ); Tue, 27 Nov 2018 04:29:22 -0500 Received: from localhost (unknown [69.71.4.100]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPSA id 26D61208E7; Mon, 26 Nov 2018 22:33:43 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1543271623; bh=X7UJjgpBjz0pPMdhcuGIMWm0fPuxjkZmHbzd+EFR/Nc=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=jyCFPS5sQ4LSP+dsatdHfPyFUyMKUXPlBm8+9mrI2lwdXijU58B61c9FdtI/unTU0 TluxlzK9DN6j9RanAivhLgpLiOwSyVvehYDsZMIEoSQCiWAcYkpMZ6mWp6B/4y40fy Lrits4+s5COcff7EgkRnyl8tuR0lMH60CiMAsnUA= Date: Mon, 26 Nov 2018 16:33:41 -0600 From: Bjorn Helgaas To: Mikulas Patocka Cc: linux-pci@vger.kernel.org, Tal Gilboa , Tariq Toukan , Alex Deucher , amd-gfx@lists.freedesktop.org Subject: Re: [PATCH] pci: fix incorrect value returned from pcie_get_speed_cap Message-ID: <20181126223340.GA212532@google.com> References: MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: User-Agent: Mutt/1.10.1 (2018-07-13) Sender: linux-pci-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-pci@vger.kernel.org On Tue, Oct 30, 2018 at 12:36:08PM -0400, Mikulas Patocka wrote: > The macros PCI_EXP_LNKCAP_SLS_*GB are values, not bit masks. We must mask > the register and compare it against them. > > This patch fixes errors "amdgpu: [powerplay] failed to send message 261 > ret is 0" errors when PCIe-v3 card is plugged into PCIe-v1 slot, because > the slot is being incorrectly reported as PCIe-v3 capable. > > Signed-off-by: Mikulas Patocka Applied the patch below to for-linus for v4.20 and backport to v4.17+ stable kernels, thanks! I removed the "if (lnkcap)" test because the LNKCAP case is not parallel to the LNKCAP2 case. LNKCAP2 is optional so we have to test for lnkcap2 being non-zero. But LNKCAP is required for all devices. If the config read of it fails, we should get either 0 or ~0, and neither one will satisfy the 5.0 or 2.5 checks. > Fixes: 6cf57be0f78e ("PCI: Add pcie_get_speed_cap() to find max supported link speed") > Cc: stable@vger.kernel.org # v4.17+ > > --- > drivers/pci/pci.c | 8 ++++---- > 1 file changed, 4 insertions(+), 4 deletions(-) > > Index: linux-4.19/drivers/pci/pci.c > =================================================================== > --- linux-4.19.orig/drivers/pci/pci.c 2018-10-30 16:58:58.000000000 +0100 > +++ linux-4.19/drivers/pci/pci.c 2018-10-30 16:58:58.000000000 +0100 > @@ -5492,13 +5492,13 @@ enum pci_bus_speed pcie_get_speed_cap(st > > pcie_capability_read_dword(dev, PCI_EXP_LNKCAP, &lnkcap); > if (lnkcap) { > - if (lnkcap & PCI_EXP_LNKCAP_SLS_16_0GB) > + if ((lnkcap & PCI_EXP_LNKCAP_SLS) == PCI_EXP_LNKCAP_SLS_16_0GB) > return PCIE_SPEED_16_0GT; > - else if (lnkcap & PCI_EXP_LNKCAP_SLS_8_0GB) > + else if ((lnkcap & PCI_EXP_LNKCAP_SLS) == PCI_EXP_LNKCAP_SLS_8_0GB) > return PCIE_SPEED_8_0GT; > - else if (lnkcap & PCI_EXP_LNKCAP_SLS_5_0GB) > + else if ((lnkcap & PCI_EXP_LNKCAP_SLS) ==PCI_EXP_LNKCAP_SLS_5_0GB) > return PCIE_SPEED_5_0GT; > - else if (lnkcap & PCI_EXP_LNKCAP_SLS_2_5GB) > + else if ((lnkcap & PCI_EXP_LNKCAP_SLS) == PCI_EXP_LNKCAP_SLS_2_5GB) > return PCIE_SPEED_2_5GT; > } > commit 94ea01a6d9a6 Author: Mikulas Patocka Date: Mon Nov 26 10:37:13 2018 -0600 PCI: Fix incorrect value returned from pcie_get_speed_cap() The macros PCI_EXP_LNKCAP_SLS_*GB are values, not bit masks. We must mask the register and compare it against them. This fixes errors like this: amdgpu: [powerplay] failed to send message 261 ret is 0 when PCIe-v3 card is plugged into a PCIe-v1 slot, because the slot is being incorrectly reported as PCIe-v3 capable. 6cf57be0f78e, which appeared in v4.17, added pcie_get_speed_cap() with the incorrect test of PCI_EXP_LNKCAP_SLS as a bitmask. 5d9a63304032, which appeared in v4.19, changed amdgpu to use pcie_get_speed_cap(), so the amdgpu bug reports below are regressions in v4.19. Fixes: 6cf57be0f78e ("PCI: Add pcie_get_speed_cap() to find max supported link speed") Fixes: 5d9a63304032 ("drm/amdgpu: use pcie functions for link width and speed") Link: https://bugs.freedesktop.org/show_bug.cgi?id=108704 Link: https://bugs.freedesktop.org/show_bug.cgi?id=108778 Signed-off-by: Mikulas Patocka [bhelgaas: update comment, remove use of PCI_EXP_LNKCAP_SLS_8_0GB and PCI_EXP_LNKCAP_SLS_16_0GB since those should be covered by PCI_EXP_LNKCAP2, remove test of PCI_EXP_LNKCAP for zero, since that register is required] Signed-off-by: Bjorn Helgaas Acked-by: Alex Deucher Cc: stable@vger.kernel.org # v4.17+ diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c index d068f11d08a7..c9d8e3c837de 100644 --- a/drivers/pci/pci.c +++ b/drivers/pci/pci.c @@ -5556,9 +5556,13 @@ enum pci_bus_speed pcie_get_speed_cap(struct pci_dev *dev) u32 lnkcap2, lnkcap; /* - * PCIe r4.0 sec 7.5.3.18 recommends using the Supported Link - * Speeds Vector in Link Capabilities 2 when supported, falling - * back to Max Link Speed in Link Capabilities otherwise. + * Link Capabilities 2 was added in PCIe r3.0, sec 7.8.18. The + * implementation note there recommends using the Supported Link + * Speeds Vector in Link Capabilities 2 when supported. + * + * Without Link Capabilities 2, i.e., prior to PCIe r3.0, software + * should use the Supported Link Speeds field in Link Capabilities, + * where only 2.5 GT/s and 5.0 GT/s speeds were defined. */ pcie_capability_read_dword(dev, PCI_EXP_LNKCAP2, &lnkcap2); if (lnkcap2) { /* PCIe r3.0-compliant */ @@ -5574,16 +5578,10 @@ enum pci_bus_speed pcie_get_speed_cap(struct pci_dev *dev) } pcie_capability_read_dword(dev, PCI_EXP_LNKCAP, &lnkcap); - if (lnkcap) { - if (lnkcap & PCI_EXP_LNKCAP_SLS_16_0GB) - return PCIE_SPEED_16_0GT; - else if (lnkcap & PCI_EXP_LNKCAP_SLS_8_0GB) - return PCIE_SPEED_8_0GT; - else if (lnkcap & PCI_EXP_LNKCAP_SLS_5_0GB) - return PCIE_SPEED_5_0GT; - else if (lnkcap & PCI_EXP_LNKCAP_SLS_2_5GB) - return PCIE_SPEED_2_5GT; - } + if ((lnkcap & PCI_EXP_LNKCAP_SLS) == PCI_EXP_LNKCAP_SLS_5_0GB) + return PCIE_SPEED_5_0GT; + else if ((lnkcap & PCI_EXP_LNKCAP_SLS) == PCI_EXP_LNKCAP_SLS_2_5GB) + return PCIE_SPEED_2_5GT; return PCI_SPEED_UNKNOWN; }