From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751915AbdFIJIg (ORCPT ); Fri, 9 Jun 2017 05:08:36 -0400 Received: from pegasos-out.vodafone.de ([80.84.1.38]:59379 "EHLO pegasos-out.vodafone.de" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751537AbdFIJIa (ORCPT ); Fri, 9 Jun 2017 05:08:30 -0400 X-Spam-Flag: NO X-Spam-Score: -0.055 Authentication-Results: rohrpostix1.prod.vfnet.de (amavisd-new); dkim=pass header.i=@vodafone.de X-DKIM: OpenDKIM Filter v2.6.8 pegasos-out.vodafone.de 3D686261F3C From: =?UTF-8?q?Christian=20K=C3=B6nig?= To: helgaas@kernel.org, linux-pci@vger.kernel.org, dri-devel@lists.freedesktop.org, platform-driver-x86@vger.kernel.org, linux-kernel@vger.kernel.org, amd-gfx@lists.freedesktop.org Subject: [PATCH v5 4/6] x86/PCI: Enable a 64bit BAR on AMD Family 15h (Models 30h-3fh) Processors v4 Date: Fri, 9 Jun 2017 10:59:45 +0200 Message-Id: <1496998787-6371-5-git-send-email-deathsimple@vodafone.de> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1496998787-6371-1-git-send-email-deathsimple@vodafone.de> References: <1496998787-6371-1-git-send-email-deathsimple@vodafone.de> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Christian König Most BIOS don't enable this because of compatibility reasons. Manually enable a 64bit BAR of 64GB size so that we have enough room for PCI devices. v2: style cleanups, increase size, add resource name, set correct flags, print message that windows was added v3: add defines for all the magic numbers, style cleanups v4: add some comment that the BIOS should actually allow this using _PRS and _SRS. Signed-off-by: Christian König Reviewed-by: Andy Shevchenko --- arch/x86/pci/fixup.c | 76 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 76 insertions(+) diff --git a/arch/x86/pci/fixup.c b/arch/x86/pci/fixup.c index 6d52b94..489e753 100644 --- a/arch/x86/pci/fixup.c +++ b/arch/x86/pci/fixup.c @@ -571,3 +571,79 @@ DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_INTEL, 0x2fc0, pci_invalid_bar); DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_INTEL, 0x6f60, pci_invalid_bar); DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_INTEL, 0x6fa0, pci_invalid_bar); DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_INTEL, 0x6fc0, pci_invalid_bar); + +#define AMD_141b_MMIO_BASE(x) (0x80 + (x) * 0x8) +#define AMD_141b_MMIO_BASE_RE_MASK BIT(0) +#define AMD_141b_MMIO_BASE_WE_MASK BIT(1) +#define AMD_141b_MMIO_BASE_MMIOBASE_MASK GENMASK(31,8) + +#define AMD_141b_MMIO_LIMIT(x) (0x84 + (x) * 0x8) +#define AMD_141b_MMIO_LIMIT_MMIOLIMIT_MASK GENMASK(31,8) + +#define AMD_141b_MMIO_HIGH(x) (0x180 + (x) * 0x4) +#define AMD_141b_MMIO_HIGH_MMIOBASE_MASK GENMASK(7,0) +#define AMD_141b_MMIO_HIGH_MMIOLIMIT_SHIFT 16 +#define AMD_141b_MMIO_HIGH_MMIOLIMIT_MASK GENMASK(23,16) + +/* + * The PCI Firmware Spec, rev 3.2 notes that ACPI should optionally allow + * configuring host bridge windows using the _PRS and _SRS methods. + * + * But this is rarely implemented, so we manually enable a large 64bit BAR for + * PCIe device on AMD Family 15h (Models 30h-3fh) Processors here. + */ +static void pci_amd_enable_64bit_bar(struct pci_dev *dev) +{ + struct resource *res, *conflict; + u32 base, limit, high; + unsigned i; + + for (i = 0; i < 8; ++i) { + pci_read_config_dword(dev, AMD_141b_MMIO_BASE(i), &base); + pci_read_config_dword(dev, AMD_141b_MMIO_HIGH(i), &high); + + /* Is this slot free? */ + if (!(base & (AMD_141b_MMIO_BASE_RE_MASK | + AMD_141b_MMIO_BASE_WE_MASK))) + break; + + base >>= 8; + base |= high << 24; + + /* Abort if a slot already configures a 64bit BAR. */ + if (base > 0x10000) + return; + } + if (i == 8) + return; + + res = kzalloc(sizeof(*res), GFP_KERNEL); + if (!res) + return; + + res->name = "PCI Bus 0000:00"; + res->flags = IORESOURCE_PREFETCH | IORESOURCE_MEM | + IORESOURCE_MEM_64 | IORESOURCE_WINDOW; + res->start = 0x100000000ull; + res->end = 0xfd00000000ull - 1; + + /* Just grab the free area behind system memory for this */ + while ((conflict = request_resource_conflict(&iomem_resource, res))) + res->start = conflict->end + 1; + + dev_info(&dev->dev, "adding root bus resource %pR\n", res); + + base = ((res->start >> 8) & AMD_141b_MMIO_BASE_MMIOBASE_MASK) | + AMD_141b_MMIO_BASE_RE_MASK | AMD_141b_MMIO_BASE_WE_MASK; + limit = ((res->end + 1) >> 8) & AMD_141b_MMIO_LIMIT_MMIOLIMIT_MASK; + high = ((res->start >> 40) & AMD_141b_MMIO_HIGH_MMIOBASE_MASK) | + ((((res->end + 1) >> 40) << AMD_141b_MMIO_HIGH_MMIOLIMIT_SHIFT) + & AMD_141b_MMIO_HIGH_MMIOLIMIT_MASK); + + pci_write_config_dword(dev, AMD_141b_MMIO_HIGH(i), high); + pci_write_config_dword(dev, AMD_141b_MMIO_LIMIT(i), limit); + pci_write_config_dword(dev, AMD_141b_MMIO_BASE(i), base); + + pci_bus_add_resource(dev->bus, res, 0); +} +DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_AMD, 0x141b, pci_amd_enable_64bit_bar); -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: =?UTF-8?q?Christian=20K=C3=B6nig?= Subject: [PATCH v5 4/6] x86/PCI: Enable a 64bit BAR on AMD Family 15h (Models 30h-3fh) Processors v4 Date: Fri, 9 Jun 2017 10:59:45 +0200 Message-ID: <1496998787-6371-5-git-send-email-deathsimple@vodafone.de> References: <1496998787-6371-1-git-send-email-deathsimple@vodafone.de> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1496998787-6371-1-git-send-email-deathsimple-ANTagKRnAhcb1SvskN2V4Q@public.gmane.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: amd-gfx-bounces-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Sender: "amd-gfx" To: helgaas-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org, linux-pci-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, dri-devel-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, platform-driver-x86-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, amd-gfx-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org List-Id: platform-driver-x86.vger.kernel.org RnJvbTogQ2hyaXN0aWFuIEvDtm5pZyA8Y2hyaXN0aWFuLmtvZW5pZ0BhbWQuY29tPgoKTW9zdCBC SU9TIGRvbid0IGVuYWJsZSB0aGlzIGJlY2F1c2Ugb2YgY29tcGF0aWJpbGl0eSByZWFzb25zLgoK TWFudWFsbHkgZW5hYmxlIGEgNjRiaXQgQkFSIG9mIDY0R0Igc2l6ZSBzbyB0aGF0IHdlIGhhdmUK ZW5vdWdoIHJvb20gZm9yIFBDSSBkZXZpY2VzLgoKdjI6IHN0eWxlIGNsZWFudXBzLCBpbmNyZWFz ZSBzaXplLCBhZGQgcmVzb3VyY2UgbmFtZSwgc2V0IGNvcnJlY3QgZmxhZ3MsCiAgICBwcmludCBt ZXNzYWdlIHRoYXQgd2luZG93cyB3YXMgYWRkZWQKdjM6IGFkZCBkZWZpbmVzIGZvciBhbGwgdGhl IG1hZ2ljIG51bWJlcnMsIHN0eWxlIGNsZWFudXBzCnY0OiBhZGQgc29tZSBjb21tZW50IHRoYXQg dGhlIEJJT1Mgc2hvdWxkIGFjdHVhbGx5IGFsbG93IHRoaXMgdXNpbmcKICAgIF9QUlMgYW5kIF9T UlMuCgpTaWduZWQtb2ZmLWJ5OiBDaHJpc3RpYW4gS8O2bmlnIDxjaHJpc3RpYW4ua29lbmlnQGFt ZC5jb20+ClJldmlld2VkLWJ5OiBBbmR5IFNoZXZjaGVua28gPGFuZHkuc2hldmNoZW5rb0BnbWFp bC5jb20+Ci0tLQogYXJjaC94ODYvcGNpL2ZpeHVwLmMgfCA3NiArKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiAxIGZpbGUgY2hhbmdlZCwgNzYgaW5z ZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL2FyY2gveDg2L3BjaS9maXh1cC5jIGIvYXJjaC94ODYv cGNpL2ZpeHVwLmMKaW5kZXggNmQ1MmI5NC4uNDg5ZTc1MyAxMDA2NDQKLS0tIGEvYXJjaC94ODYv cGNpL2ZpeHVwLmMKKysrIGIvYXJjaC94ODYvcGNpL2ZpeHVwLmMKQEAgLTU3MSwzICs1NzEsNzkg QEAgREVDTEFSRV9QQ0lfRklYVVBfRUFSTFkoUENJX1ZFTkRPUl9JRF9JTlRFTCwgMHgyZmMwLCBw Y2lfaW52YWxpZF9iYXIpOwogREVDTEFSRV9QQ0lfRklYVVBfRUFSTFkoUENJX1ZFTkRPUl9JRF9J TlRFTCwgMHg2ZjYwLCBwY2lfaW52YWxpZF9iYXIpOwogREVDTEFSRV9QQ0lfRklYVVBfRUFSTFko UENJX1ZFTkRPUl9JRF9JTlRFTCwgMHg2ZmEwLCBwY2lfaW52YWxpZF9iYXIpOwogREVDTEFSRV9Q Q0lfRklYVVBfRUFSTFkoUENJX1ZFTkRPUl9JRF9JTlRFTCwgMHg2ZmMwLCBwY2lfaW52YWxpZF9i YXIpOworCisjZGVmaW5lIEFNRF8xNDFiX01NSU9fQkFTRSh4KQkoMHg4MCArICh4KSAqIDB4OCkK KyNkZWZpbmUgQU1EXzE0MWJfTU1JT19CQVNFX1JFX01BU0sJCUJJVCgwKQorI2RlZmluZSBBTURf MTQxYl9NTUlPX0JBU0VfV0VfTUFTSwkJQklUKDEpCisjZGVmaW5lIEFNRF8xNDFiX01NSU9fQkFT RV9NTUlPQkFTRV9NQVNLCUdFTk1BU0soMzEsOCkKKworI2RlZmluZSBBTURfMTQxYl9NTUlPX0xJ TUlUKHgpCSgweDg0ICsgKHgpICogMHg4KQorI2RlZmluZSBBTURfMTQxYl9NTUlPX0xJTUlUX01N SU9MSU1JVF9NQVNLCUdFTk1BU0soMzEsOCkKKworI2RlZmluZSBBTURfMTQxYl9NTUlPX0hJR0go eCkJKDB4MTgwICsgKHgpICogMHg0KQorI2RlZmluZSBBTURfMTQxYl9NTUlPX0hJR0hfTU1JT0JB U0VfTUFTSwlHRU5NQVNLKDcsMCkKKyNkZWZpbmUgQU1EXzE0MWJfTU1JT19ISUdIX01NSU9MSU1J VF9TSElGVAkxNgorI2RlZmluZSBBTURfMTQxYl9NTUlPX0hJR0hfTU1JT0xJTUlUX01BU0sJR0VO TUFTSygyMywxNikKKworLyoKKyAqIFRoZSBQQ0kgRmlybXdhcmUgU3BlYywgcmV2IDMuMiBub3Rl cyB0aGF0IEFDUEkgc2hvdWxkIG9wdGlvbmFsbHkgYWxsb3cKKyAqIGNvbmZpZ3VyaW5nIGhvc3Qg YnJpZGdlIHdpbmRvd3MgdXNpbmcgdGhlIF9QUlMgYW5kIF9TUlMgbWV0aG9kcy4KKyAqCisgKiBC dXQgdGhpcyBpcyByYXJlbHkgaW1wbGVtZW50ZWQsIHNvIHdlIG1hbnVhbGx5IGVuYWJsZSBhIGxh cmdlIDY0Yml0IEJBUiBmb3IKKyAqIFBDSWUgZGV2aWNlIG9uIEFNRCBGYW1pbHkgMTVoIChNb2Rl bHMgMzBoLTNmaCkgUHJvY2Vzc29ycyBoZXJlLgorICovCitzdGF0aWMgdm9pZCBwY2lfYW1kX2Vu YWJsZV82NGJpdF9iYXIoc3RydWN0IHBjaV9kZXYgKmRldikKK3sKKwlzdHJ1Y3QgcmVzb3VyY2Ug KnJlcywgKmNvbmZsaWN0OworCXUzMiBiYXNlLCBsaW1pdCwgaGlnaDsKKwl1bnNpZ25lZCBpOwor CisJZm9yIChpID0gMDsgaSA8IDg7ICsraSkgeworCQlwY2lfcmVhZF9jb25maWdfZHdvcmQoZGV2 LCBBTURfMTQxYl9NTUlPX0JBU0UoaSksICZiYXNlKTsKKwkJcGNpX3JlYWRfY29uZmlnX2R3b3Jk KGRldiwgQU1EXzE0MWJfTU1JT19ISUdIKGkpLCAmaGlnaCk7CisKKwkJLyogSXMgdGhpcyBzbG90 IGZyZWU/ICovCisJCWlmICghKGJhc2UgJiAoQU1EXzE0MWJfTU1JT19CQVNFX1JFX01BU0sgfAor CQkJICAgICAgQU1EXzE0MWJfTU1JT19CQVNFX1dFX01BU0spKSkKKwkJCWJyZWFrOworCisJCWJh c2UgPj49IDg7CisJCWJhc2UgfD0gaGlnaCA8PCAyNDsKKworCQkvKiBBYm9ydCBpZiBhIHNsb3Qg YWxyZWFkeSBjb25maWd1cmVzIGEgNjRiaXQgQkFSLiAqLworCQlpZiAoYmFzZSA+IDB4MTAwMDAp CisJCQlyZXR1cm47CisJfQorCWlmIChpID09IDgpCisJCXJldHVybjsKKworCXJlcyA9IGt6YWxs b2Moc2l6ZW9mKCpyZXMpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIXJlcykKKwkJcmV0dXJuOworCisJ cmVzLT5uYW1lID0gIlBDSSBCdXMgMDAwMDowMCI7CisJcmVzLT5mbGFncyA9IElPUkVTT1VSQ0Vf UFJFRkVUQ0ggfCBJT1JFU09VUkNFX01FTSB8CisJCUlPUkVTT1VSQ0VfTUVNXzY0IHwgSU9SRVNP VVJDRV9XSU5ET1c7CisJcmVzLT5zdGFydCA9IDB4MTAwMDAwMDAwdWxsOworCXJlcy0+ZW5kID0g MHhmZDAwMDAwMDAwdWxsIC0gMTsKKworCS8qIEp1c3QgZ3JhYiB0aGUgZnJlZSBhcmVhIGJlaGlu ZCBzeXN0ZW0gbWVtb3J5IGZvciB0aGlzICovCisJd2hpbGUgKChjb25mbGljdCA9IHJlcXVlc3Rf cmVzb3VyY2VfY29uZmxpY3QoJmlvbWVtX3Jlc291cmNlLCByZXMpKSkKKwkJcmVzLT5zdGFydCA9 IGNvbmZsaWN0LT5lbmQgKyAxOworCisJZGV2X2luZm8oJmRldi0+ZGV2LCAiYWRkaW5nIHJvb3Qg YnVzIHJlc291cmNlICVwUlxuIiwgcmVzKTsKKworCWJhc2UgPSAoKHJlcy0+c3RhcnQgPj4gOCkg JiBBTURfMTQxYl9NTUlPX0JBU0VfTU1JT0JBU0VfTUFTSykgfAorCQlBTURfMTQxYl9NTUlPX0JB U0VfUkVfTUFTSyB8IEFNRF8xNDFiX01NSU9fQkFTRV9XRV9NQVNLOworCWxpbWl0ID0gKChyZXMt PmVuZCArIDEpID4+IDgpICYgQU1EXzE0MWJfTU1JT19MSU1JVF9NTUlPTElNSVRfTUFTSzsKKwlo aWdoID0gKChyZXMtPnN0YXJ0ID4+IDQwKSAmIEFNRF8xNDFiX01NSU9fSElHSF9NTUlPQkFTRV9N QVNLKSB8CisJCSgoKChyZXMtPmVuZCArIDEpID4+IDQwKSA8PCBBTURfMTQxYl9NTUlPX0hJR0hf TU1JT0xJTUlUX1NISUZUKQorCQkgJiBBTURfMTQxYl9NTUlPX0hJR0hfTU1JT0xJTUlUX01BU0sp OworCisJcGNpX3dyaXRlX2NvbmZpZ19kd29yZChkZXYsIEFNRF8xNDFiX01NSU9fSElHSChpKSwg aGlnaCk7CisJcGNpX3dyaXRlX2NvbmZpZ19kd29yZChkZXYsIEFNRF8xNDFiX01NSU9fTElNSVQo aSksIGxpbWl0KTsKKwlwY2lfd3JpdGVfY29uZmlnX2R3b3JkKGRldiwgQU1EXzE0MWJfTU1JT19C QVNFKGkpLCBiYXNlKTsKKworCXBjaV9idXNfYWRkX3Jlc291cmNlKGRldi0+YnVzLCByZXMsIDAp OworfQorREVDTEFSRV9QQ0lfRklYVVBfRUFSTFkoUENJX1ZFTkRPUl9JRF9BTUQsIDB4MTQxYiwg cGNpX2FtZF9lbmFibGVfNjRiaXRfYmFyKTsKLS0gCjIuNy40CgpfX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fXwphbWQtZ2Z4IG1haWxpbmcgbGlzdAphbWQtZ2Z4 QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWls bWFuL2xpc3RpbmZvL2FtZC1nZngK