From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Luis R. Rodriguez" Subject: [PATCH v4 05/11] PCI: Add pci_iomap_wc() variants Date: Mon, 24 Aug 2015 12:13:27 -0700 Message-ID: <1440443613-13696-6-git-send-email-mcgrof@do-not-panic.com> References: <1440443613-13696-1-git-send-email-mcgrof@do-not-panic.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1440443613-13696-1-git-send-email-mcgrof@do-not-panic.com> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Sender: xen-devel-bounces@lists.xen.org Errors-To: xen-devel-bounces@lists.xen.org To: mingo@kernel.org Cc: linux-fbdev@vger.kernel.org, mst@redhat.com, airlied@linux.ie, benh@kernel.crashing.org, =?UTF-8?q?Ville=20Syrj=C3=A4l=C3=A4?= , Dave Hansen , jbeulich@suse.com, "H. Peter Anvin" , Thomas Gleixner , linux-arch@vger.kernel.org, xen-devel@lists.xensource.com, Antonino Daplas , Davidlohr Bueso , vinod.koul@intel.com, x86@kernel.org, tomi.valkeinen@ti.com, Mel Gorman , linux-pci@vger.kernel.org, Dave Airlie , bp@suse.de, Jean-Christophe Plagniol-Villard , Arnd Bergmann , "Luis R. Rodriguez" , Rusty Russell , Stefan Bader , daniel.vetter@ffwll.ch, Suresh Siddha , bhelgaas@google.com, dan.j.williams@i List-Id: linux-arch.vger.kernel.org RnJvbTogIkx1aXMgUi4gUm9kcmlndWV6IiA8bWNncm9mQHN1c2UuY29tPgoKUENJIEJBUnMgdGVs bCB1cyB3aGV0aGVyIHByZWZldGNoaW5nIGlzIHNhZmUsIGJ1dCB0aGV5IGRvbid0IHNheQphbnl0 aGluZyBhYm91dCB3cml0ZSBjb21iaW5pbmcgKFdDKS4gV0MgY2hhbmdlcyBvcmRlcmluZyBydWxl cyBhbmQKYWxsb3dzIHdyaXRlcyB0byBiZSBjb2xsYXBzZWQsIHNvIGl0J3Mgbm90IHNhZmUgaW4g Z2VuZXJhbCB0byB1c2UgaXQgb24KYSBwcmVmZXRjaGFibGUgcmVnaW9uLgoKQWRkIHBjaV9pb21h cF93YygpIGFuZCBwY2lfaW9tYXBfd2NfcmFuZ2UoKSBzbyBkcml2ZXJzIGNhbiB0YWtlIGFkdmFu dGFnZQpvZiB3cml0ZSBjb21iaW5pbmcgd2hlbiB0aGV5IGtub3cgaXQncyBzYWZlLgoKT24gYXJj aGl0ZWN0dXJlcyB0aGF0IGRvbid0IGZ1bGx5IHN1cHBvcnQgV0MsIGUuZy4sIHg4NiB3aXRob3V0 IFBBVCwKZHJpdmVycyBmb3IgbGVnYWN5IGZyYW1lYnVmZmVycyBtYXkgZ2V0IHNvbWUgb2YgdGhl IGJlbmVmaXQgYnkgdXNpbmcKYXJjaF9waHlzX3djX2FkZCgpIGluIGFkZGl0aW9uIHRvIHBjaV9p b21hcF93YygpLiAgQnV0IGFyY2hfcGh5c193Y19hZGQoKQppcyB1bnJlbGlhYmxlIGFuZCBzaG91 bGQgYmUgYXZvaWRlZCBpbiBnZW5lcmFsLiAgT24geDg2LCBpdCB1c2VzIE1UUlJzLAp3aGljaCBh cmUgbGltaXRlZCBpbiBudW1iZXIgYW5kIHNpemUsIHNvIHRoZSByZXN1bHRzIHdpbGwgdmFyeSBi YXNlZCBvbgpkcml2ZXIgbG9hZGluZyBvcmRlci4KClRoZSBnb2FscyBvZiBhZGRpbmcgcGNpX2lv bWFwX3djKCkgYXJlIHRvOgoKLSBHaXZlIGRyaXZlcnMgYW4gYXJjaGl0ZWN0dXJlLWluZGVwZW5k ZW50IHdheSB0byB1c2UgV0Mgc28gdGhleSBjYW4gc3RvcAogIHVzaW5nIGludGVyZmFjZXMgbGlr ZSBtdHJyX2FkZCgpIChvbiB4ODYsIHBjaV9pb21hcF93YygpIHVzZXMKICBQQVQgd2hlbiBhdmFp bGFibGUpLgoKLSBNb3ZlIHRvd2FyZCB1c2luZyBfUEFHRV9DQUNIRV9NT0RFX1VDLCBub3QgX1BB R0VfQ0FDSEVfTU9ERV9VQ19NSU5VUywKICBvbiB4ODYgb24gaW9yZW1hcF9ub2NhY2hlKCkgKHNl ZSBkZTMzYzQ0MmVkMmEgKCJ4ODYgUEFUOiBmaXgKICBwZXJmb3JtYW5jZSBkcm9wIGZvciBnbHgs IHVzZSBVQyBtaW51cyBmb3IgaW9yZW1hcCgpLCBpb3JlbWFwX25vY2FjaGUoKQogIGFuZCBwY2lf bW1hcF9wYWdlX3JhbmdlKCkiKS4KClNpZ25lZC1vZmYtYnk6IEx1aXMgUi4gUm9kcmlndWV6IDxt Y2dyb2ZAc3VzZS5jb20+CkFja2VkLWJ5OiBBcm5kIEJlcmdtYW5uIDxhcm5kQGFybmRiLmRlPgpD YzogQW5kcmV3IE1vcnRvbiA8YWtwbUBsaW51eC1mb3VuZGF0aW9uLm9yZz4KQ2M6IEFuZHkgTHV0 b21pcnNraSA8bHV0b0BhbWFjYXBpdGFsLm5ldD4KQ2M6IEFudG9uaW5vIERhcGxhcyA8YWRhcGxh c0BnbWFpbC5jb20+CkNjOiBBcm5kIEJlcmdtYW5uIDxhcm5kQGFybmRiLmRlPgpDYzogYmVuaEBr ZXJuZWwuY3Jhc2hpbmcub3JnCkNjOiBiaGVsZ2Fhc0Bnb29nbGUuY29tCkNjOiBCam9ybiBIZWxn YWFzIDxiaGVsZ2Fhc0Bnb29nbGUuY29tPgpDYzogRGFuaWVsIFZldHRlciA8ZGFuaWVsLnZldHRl ckBmZndsbC5jaD4KQ2M6IERhdmUgQWlybGllIDxhaXJsaWVkQHJlZGhhdC5jb20+CkNjOiBEYXZl IEhhbnNlbiA8ZGF2ZS5oYW5zZW5AbGludXguaW50ZWwuY29tPgpDYzogRGF2aWRsb2hyIEJ1ZXNv IDxkYnVlc29Ac3VzZS5kZT4KQ2M6IGRhdmlkLnZyYWJlbEBjaXRyaXguY29tCkNjOiBILiBQZXRl ciBBbnZpbiA8aHBhQHp5dG9yLmNvbT4KQ2M6IEluZ28gTW9sbmFyIDxtaW5nb0BrZXJuZWwub3Jn PgpDYzogamJldWxpY2hAc3VzZS5jb20KQ2M6IEplYW4tQ2hyaXN0b3BoZSBQbGFnbmlvbC1WaWxs YXJkIDxwbGFnbmlvakBqY3Jvc29mdC5jb20+CkNjOiBKdWVyZ2VuIEdyb3NzIDxqZ3Jvc3NAc3Vz ZS5jb20+CkNjOiBrb25yYWQud2lsa0BvcmFjbGUuY29tCkNjOiBsaW51eC1hcmNoQHZnZXIua2Vy bmVsLm9yZwpDYzogbGludXgtZmJkZXZAdmdlci5rZXJuZWwub3JnCkNjOiBsaW51eC1wY2lAdmdl ci5rZXJuZWwub3JnCkNjOiBNZWwgR29ybWFuIDxtZ29ybWFuQHN1c2UuZGU+CkNjOiAiTWljaGFl bCBTLiBUc2lya2luIiA8bXN0QHJlZGhhdC5jb20+CkNjOiBSb2dlciBQYXUgTW9ubsOpIDxyb2dl ci5wYXVAY2l0cml4LmNvbT4KQ2M6IFJ1c3R5IFJ1c3NlbGwgPHJ1c3R5QHJ1c3Rjb3JwLmNvbS5h dT4KQ2M6IFN0ZWZhbiBCYWRlciA8c3RlZmFuLmJhZGVyQGNhbm9uaWNhbC5jb20+CkNjOiBTdXJl c2ggU2lkZGhhIDxzYnNpZGRoYUBnbWFpbC5jb20+CkNjOiBUaG9tYXMgR2xlaXhuZXIgPHRnbHhA bGludXRyb25peC5kZT4KQ2M6IFRvbWkgVmFsa2VpbmVuIDx0b21pLnZhbGtlaW5lbkB0aS5jb20+ CkNjOiBUb3NoaSBLYW5pIDx0b3NoaS5rYW5pQGhwLmNvbT4KQ2M6IHZlbmthdGVzaC5wYWxsaXBh ZGlAaW50ZWwuY29tCkNjOiBWaWxsZSBTeXJqw6Rsw6QgPHN5cmphbGFAc2NpLmZpPgpDYzogVmxh c3RpbWlsIEJhYmthIDx2YmFia2FAc3VzZS5jej4KTGluazogaHR0cDovL2xrbWwua2VybmVsLm9y Zy9yLzE0MjY4OTM1MTctMjUxMS02LWdpdC1zZW5kLWVtYWlsLW1jZ3JvZkBkby1ub3QtcGFuaWMu Y29tCkxpbms6IGh0dHA6Ly9sa21sLmtlcm5lbC5vcmcvci8xNDM1MTk1MzQyLTI2ODc5LTYtZ2l0 LXNlbmQtZW1haWwtbWNncm9mQGRvLW5vdC1wYW5pYy5jb20KWyBNb3ZlIElPUkVTT1VSQ0VfSU8g Y2hlY2sgdXAsIHNwYWNlIG91dCBzdGF0ZW1lbnRzIGZvciBiZXR0ZXIgcmVhZGFiaWxpdHkuIF0K U2lnbmVkLW9mZi1ieTogQm9yaXNsYXYgUGV0a292IDxicEBzdXNlLmRlPgotLS0KIGluY2x1ZGUv YXNtLWdlbmVyaWMvcGNpX2lvbWFwLmggfCAxNCArKysrKysrKysKIGxpYi9wY2lfaW9tYXAuYyAg ICAgICAgICAgICAgICAgfCA2NiArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKwogMiBmaWxlcyBjaGFuZ2VkLCA4MCBpbnNlcnRpb25zKCspCgpkaWZmIC0tZ2l0IGEvaW5j bHVkZS9hc20tZ2VuZXJpYy9wY2lfaW9tYXAuaCBiL2luY2x1ZGUvYXNtLWdlbmVyaWMvcGNpX2lv bWFwLmgKaW5kZXggNzM4OWM4NzExNmEwLi5iMWUxN2ZjZWUyZDAgMTAwNjQ0Ci0tLSBhL2luY2x1 ZGUvYXNtLWdlbmVyaWMvcGNpX2lvbWFwLmgKKysrIGIvaW5jbHVkZS9hc20tZ2VuZXJpYy9wY2lf aW9tYXAuaApAQCAtMTUsOSArMTUsMTMgQEAgc3RydWN0IHBjaV9kZXY7CiAjaWZkZWYgQ09ORklH X1BDSQogLyogQ3JlYXRlIGEgdmlydHVhbCBtYXBwaW5nIGNvb2tpZSBmb3IgYSBQQ0kgQkFSICht ZW1vcnkgb3IgSU8pICovCiBleHRlcm4gdm9pZCBfX2lvbWVtICpwY2lfaW9tYXAoc3RydWN0IHBj aV9kZXYgKmRldiwgaW50IGJhciwgdW5zaWduZWQgbG9uZyBtYXgpOworZXh0ZXJuIHZvaWQgX19p b21lbSAqcGNpX2lvbWFwX3djKHN0cnVjdCBwY2lfZGV2ICpkZXYsIGludCBiYXIsIHVuc2lnbmVk IGxvbmcgbWF4KTsKIGV4dGVybiB2b2lkIF9faW9tZW0gKnBjaV9pb21hcF9yYW5nZShzdHJ1Y3Qg cGNpX2RldiAqZGV2LCBpbnQgYmFyLAogCQkJCSAgICAgdW5zaWduZWQgbG9uZyBvZmZzZXQsCiAJ CQkJICAgICB1bnNpZ25lZCBsb25nIG1heGxlbik7CitleHRlcm4gdm9pZCBfX2lvbWVtICpwY2lf aW9tYXBfd2NfcmFuZ2Uoc3RydWN0IHBjaV9kZXYgKmRldiwgaW50IGJhciwKKwkJCQkJdW5zaWdu ZWQgbG9uZyBvZmZzZXQsCisJCQkJCXVuc2lnbmVkIGxvbmcgbWF4bGVuKTsKIC8qIENyZWF0ZSBh IHZpcnR1YWwgbWFwcGluZyBjb29raWUgZm9yIGEgcG9ydCBvbiBhIGdpdmVuIFBDSSBkZXZpY2Uu CiAgKiBEbyBub3QgY2FsbCB0aGlzIGRpcmVjdGx5LCBpdCBleGlzdHMgdG8gbWFrZSBpdCBlYXNp ZXIgZm9yIGFyY2hpdGVjdHVyZXMKICAqIHRvIG92ZXJyaWRlICovCkBAIC0zNCwxMiArMzgsMjIg QEAgc3RhdGljIGlubGluZSB2b2lkIF9faW9tZW0gKnBjaV9pb21hcChzdHJ1Y3QgcGNpX2RldiAq ZGV2LCBpbnQgYmFyLCB1bnNpZ25lZCBsb24KIAlyZXR1cm4gTlVMTDsKIH0KIAorc3RhdGljIGlu bGluZSB2b2lkIF9faW9tZW0gKnBjaV9pb21hcF93YyhzdHJ1Y3QgcGNpX2RldiAqZGV2LCBpbnQg YmFyLCB1bnNpZ25lZCBsb25nIG1heCkKK3sKKwlyZXR1cm4gTlVMTDsKK30KIHN0YXRpYyBpbmxp bmUgdm9pZCBfX2lvbWVtICpwY2lfaW9tYXBfcmFuZ2Uoc3RydWN0IHBjaV9kZXYgKmRldiwgaW50 IGJhciwKIAkJCQkJICAgIHVuc2lnbmVkIGxvbmcgb2Zmc2V0LAogCQkJCQkgICAgdW5zaWduZWQg bG9uZyBtYXhsZW4pCiB7CiAJcmV0dXJuIE5VTEw7CiB9CitzdGF0aWMgaW5saW5lIHZvaWQgX19p b21lbSAqcGNpX2lvbWFwX3djX3JhbmdlKHN0cnVjdCBwY2lfZGV2ICpkZXYsIGludCBiYXIsCisJ CQkJCSAgICAgICB1bnNpZ25lZCBsb25nIG9mZnNldCwKKwkJCQkJICAgICAgIHVuc2lnbmVkIGxv bmcgbWF4bGVuKQoreworCXJldHVybiBOVUxMOworfQogI2VuZGlmCiAKICNlbmRpZiAvKiBfX0FT TV9HRU5FUklDX0lPX0ggKi8KZGlmZiAtLWdpdCBhL2xpYi9wY2lfaW9tYXAuYyBiL2xpYi9wY2lf aW9tYXAuYwppbmRleCBlMTkzMGRiYWIyZGEuLmMxMGZiYTQ2MTQ1NCAxMDA2NDQKLS0tIGEvbGli L3BjaV9pb21hcC5jCisrKyBiL2xpYi9wY2lfaW9tYXAuYwpAQCAtNDksNiArNDksNTEgQEAgdm9p ZCBfX2lvbWVtICpwY2lfaW9tYXBfcmFuZ2Uoc3RydWN0IHBjaV9kZXYgKmRldiwKIEVYUE9SVF9T WU1CT0wocGNpX2lvbWFwX3JhbmdlKTsKIAogLyoqCisgKiBwY2lfaW9tYXBfd2NfcmFuZ2UgLSBj cmVhdGUgYSB2aXJ0dWFsIFdDIG1hcHBpbmcgY29va2llIGZvciBhIFBDSSBCQVIKKyAqIEBkZXY6 IFBDSSBkZXZpY2UgdGhhdCBvd25zIHRoZSBCQVIKKyAqIEBiYXI6IEJBUiBudW1iZXIKKyAqIEBv ZmZzZXQ6IG1hcCBtZW1vcnkgYXQgdGhlIGdpdmVuIG9mZnNldCBpbiBCQVIKKyAqIEBtYXhsZW46 IG1heCBsZW5ndGggb2YgdGhlIG1lbW9yeSB0byBtYXAKKyAqCisgKiBVc2luZyB0aGlzIGZ1bmN0 aW9uIHlvdSB3aWxsIGdldCBhIF9faW9tZW0gYWRkcmVzcyB0byB5b3VyIGRldmljZSBCQVIuCisg KiBZb3UgY2FuIGFjY2VzcyBpdCB1c2luZyBpb3JlYWQqKCkgYW5kIGlvd3JpdGUqKCkuIFRoZXNl IGZ1bmN0aW9ucyBoaWRlCisgKiB0aGUgZGV0YWlscyBpZiB0aGlzIGlzIGEgTU1JTyBvciBQSU8g YWRkcmVzcyBzcGFjZSBhbmQgd2lsbCBqdXN0IGRvIHdoYXQKKyAqIHlvdSBleHBlY3QgZnJvbSB0 aGVtIGluIHRoZSBjb3JyZWN0IHdheS4gV2hlbiBwb3NzaWJsZSB3cml0ZSBjb21iaW5pbmcKKyAq IGlzIHVzZWQuCisgKgorICogQG1heGxlbiBzcGVjaWZpZXMgdGhlIG1heGltdW0gbGVuZ3RoIHRv IG1hcC4gSWYgeW91IHdhbnQgdG8gZ2V0IGFjY2VzcyB0bworICogdGhlIGNvbXBsZXRlIEJBUiBm cm9tIG9mZnNldCB0byB0aGUgZW5kLCBwYXNzICUwIGhlcmUuCisgKiAqLwordm9pZCBfX2lvbWVt ICpwY2lfaW9tYXBfd2NfcmFuZ2Uoc3RydWN0IHBjaV9kZXYgKmRldiwKKwkJCQkgaW50IGJhciwK KwkJCQkgdW5zaWduZWQgbG9uZyBvZmZzZXQsCisJCQkJIHVuc2lnbmVkIGxvbmcgbWF4bGVuKQor eworCXJlc291cmNlX3NpemVfdCBzdGFydCA9IHBjaV9yZXNvdXJjZV9zdGFydChkZXYsIGJhcik7 CisJcmVzb3VyY2Vfc2l6ZV90IGxlbiA9IHBjaV9yZXNvdXJjZV9sZW4oZGV2LCBiYXIpOworCXVu c2lnbmVkIGxvbmcgZmxhZ3MgPSBwY2lfcmVzb3VyY2VfZmxhZ3MoZGV2LCBiYXIpOworCisKKwlp ZiAoZmxhZ3MgJiBJT1JFU09VUkNFX0lPKQorCQlyZXR1cm4gTlVMTDsKKworCWlmIChsZW4gPD0g b2Zmc2V0IHx8ICFzdGFydCkKKwkJcmV0dXJuIE5VTEw7CisKKwlsZW4gLT0gb2Zmc2V0OworCXN0 YXJ0ICs9IG9mZnNldDsKKwlpZiAobWF4bGVuICYmIGxlbiA+IG1heGxlbikKKwkJbGVuID0gbWF4 bGVuOworCisJaWYgKGZsYWdzICYgSU9SRVNPVVJDRV9NRU0pCisJCXJldHVybiBpb3JlbWFwX3dj KHN0YXJ0LCBsZW4pOworCisJLyogV2hhdD8gKi8KKwlyZXR1cm4gTlVMTDsKK30KK0VYUE9SVF9T WU1CT0xfR1BMKHBjaV9pb21hcF93Y19yYW5nZSk7CisKKy8qKgogICogcGNpX2lvbWFwIC0gY3Jl YXRlIGEgdmlydHVhbCBtYXBwaW5nIGNvb2tpZSBmb3IgYSBQQ0kgQkFSCiAgKiBAZGV2OiBQQ0kg ZGV2aWNlIHRoYXQgb3ducyB0aGUgQkFSCiAgKiBAYmFyOiBCQVIgbnVtYmVyCkBAIC02Nyw0ICsx MTIsMjUgQEAgdm9pZCBfX2lvbWVtICpwY2lfaW9tYXAoc3RydWN0IHBjaV9kZXYgKmRldiwgaW50 IGJhciwgdW5zaWduZWQgbG9uZyBtYXhsZW4pCiAJcmV0dXJuIHBjaV9pb21hcF9yYW5nZShkZXYs IGJhciwgMCwgbWF4bGVuKTsKIH0KIEVYUE9SVF9TWU1CT0wocGNpX2lvbWFwKTsKKworLyoqCisg KiBwY2lfaW9tYXBfd2MgLSBjcmVhdGUgYSB2aXJ0dWFsIFdDIG1hcHBpbmcgY29va2llIGZvciBh IFBDSSBCQVIKKyAqIEBkZXY6IFBDSSBkZXZpY2UgdGhhdCBvd25zIHRoZSBCQVIKKyAqIEBiYXI6 IEJBUiBudW1iZXIKKyAqIEBtYXhsZW46IGxlbmd0aCBvZiB0aGUgbWVtb3J5IHRvIG1hcAorICoK KyAqIFVzaW5nIHRoaXMgZnVuY3Rpb24geW91IHdpbGwgZ2V0IGEgX19pb21lbSBhZGRyZXNzIHRv IHlvdXIgZGV2aWNlIEJBUi4KKyAqIFlvdSBjYW4gYWNjZXNzIGl0IHVzaW5nIGlvcmVhZCooKSBh bmQgaW93cml0ZSooKS4gVGhlc2UgZnVuY3Rpb25zIGhpZGUKKyAqIHRoZSBkZXRhaWxzIGlmIHRo aXMgaXMgYSBNTUlPIG9yIFBJTyBhZGRyZXNzIHNwYWNlIGFuZCB3aWxsIGp1c3QgZG8gd2hhdAor ICogeW91IGV4cGVjdCBmcm9tIHRoZW0gaW4gdGhlIGNvcnJlY3Qgd2F5LiBXaGVuIHBvc3NpYmxl IHdyaXRlIGNvbWJpbmluZworICogaXMgdXNlZC4KKyAqCisgKiBAbWF4bGVuIHNwZWNpZmllcyB0 aGUgbWF4aW11bSBsZW5ndGggdG8gbWFwLiBJZiB5b3Ugd2FudCB0byBnZXQgYWNjZXNzIHRvCisg KiB0aGUgY29tcGxldGUgQkFSIHdpdGhvdXQgY2hlY2tpbmcgZm9yIGl0cyBsZW5ndGggZmlyc3Qs IHBhc3MgJTAgaGVyZS4KKyAqICovCit2b2lkIF9faW9tZW0gKnBjaV9pb21hcF93YyhzdHJ1Y3Qg cGNpX2RldiAqZGV2LCBpbnQgYmFyLCB1bnNpZ25lZCBsb25nIG1heGxlbikKK3sKKwlyZXR1cm4g cGNpX2lvbWFwX3djX3JhbmdlKGRldiwgYmFyLCAwLCBtYXhsZW4pOworfQorRVhQT1JUX1NZTUJP TF9HUEwocGNpX2lvbWFwX3djKTsKICNlbmRpZiAvKiBDT05GSUdfUENJICovCi0tIAoyLjQuMwoK Cl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fClhlbi1kZXZl bCBtYWlsaW5nIGxpc3QKWGVuLWRldmVsQGxpc3RzLnhlbi5vcmcKaHR0cDovL2xpc3RzLnhlbi5v cmcveGVuLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-pa0-f53.google.com ([209.85.220.53]:33248 "EHLO mail-pa0-f53.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1755374AbbHXTOB (ORCPT ); Mon, 24 Aug 2015 15:14:01 -0400 From: "Luis R. Rodriguez" Subject: [PATCH v4 05/11] PCI: Add pci_iomap_wc() variants Date: Mon, 24 Aug 2015 12:13:27 -0700 Message-ID: <1440443613-13696-6-git-send-email-mcgrof@do-not-panic.com> In-Reply-To: <1440443613-13696-1-git-send-email-mcgrof@do-not-panic.com> References: <1440443613-13696-1-git-send-email-mcgrof@do-not-panic.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-arch-owner@vger.kernel.org List-ID: To: mingo@kernel.org Cc: bp@suse.de, bhelgaas@google.com, tomi.valkeinen@ti.com, airlied@linux.ie, linux-fbdev@vger.kernel.org, luto@amacapital.net, vinod.koul@intel.com, dan.j.williams@intel.com, toshi.kani@hp.com, benh@kernel.crashing.org, mst@redhat.com, akpm@linux-foundation.org, daniel.vetter@ffwll.ch, konrad.wilk@oracle.com, x86@kernel.org, linux-kernel@vger.kernel.org, linux-pci@vger.kernel.org, xen-devel@lists.xensource.com, "Luis R. Rodriguez" , Antonino Daplas , Arnd Bergmann , Dave Airlie , Dave Hansen , Davidlohr Bueso , david.vrabel@citrix.com, "H. Peter Anvin" , jbeulich@suse.com, Jean-Christophe Plagniol-Villard , Juergen Gross , linux-arch@vger.kernel.org, Mel Gorman , =?UTF-8?q?Roger=20Pau=20Monn=C3=A9?= , Rusty Russell , Stefan Bader , Suresh Siddha , Thomas Gleixner , venkatesh.pallipadi@intel.com, =?UTF-8?q?Ville=20Syrj=C3=A4l=C3=A4?= , Vlastimil Babka Message-ID: <20150824191327.Z3EwbuEV5FkRqBV4uJXgzh5KpQVlbU6aea8aH6gnmkU@z> From: "Luis R. Rodriguez" PCI BARs tell us whether prefetching is safe, but they don't say anything about write combining (WC). WC changes ordering rules and allows writes to be collapsed, so it's not safe in general to use it on a prefetchable region. Add pci_iomap_wc() and pci_iomap_wc_range() so drivers can take advantage of write combining when they know it's safe. On architectures that don't fully support WC, e.g., x86 without PAT, drivers for legacy framebuffers may get some of the benefit by using arch_phys_wc_add() in addition to pci_iomap_wc(). But arch_phys_wc_add() is unreliable and should be avoided in general. On x86, it uses MTRRs, which are limited in number and size, so the results will vary based on driver loading order. The goals of adding pci_iomap_wc() are to: - Give drivers an architecture-independent way to use WC so they can stop using interfaces like mtrr_add() (on x86, pci_iomap_wc() uses PAT when available). - Move toward using _PAGE_CACHE_MODE_UC, not _PAGE_CACHE_MODE_UC_MINUS, on x86 on ioremap_nocache() (see de33c442ed2a ("x86 PAT: fix performance drop for glx, use UC minus for ioremap(), ioremap_nocache() and pci_mmap_page_range()"). Signed-off-by: Luis R. Rodriguez Acked-by: Arnd Bergmann Cc: Andrew Morton Cc: Andy Lutomirski Cc: Antonino Daplas Cc: Arnd Bergmann Cc: benh@kernel.crashing.org Cc: bhelgaas@google.com Cc: Bjorn Helgaas Cc: Daniel Vetter Cc: Dave Airlie Cc: Dave Hansen Cc: Davidlohr Bueso Cc: david.vrabel@citrix.com Cc: H. Peter Anvin Cc: Ingo Molnar Cc: jbeulich@suse.com Cc: Jean-Christophe Plagniol-Villard Cc: Juergen Gross Cc: konrad.wilk@oracle.com Cc: linux-arch@vger.kernel.org Cc: linux-fbdev@vger.kernel.org Cc: linux-pci@vger.kernel.org Cc: Mel Gorman Cc: "Michael S. Tsirkin" Cc: Roger Pau Monné Cc: Rusty Russell Cc: Stefan Bader Cc: Suresh Siddha Cc: Thomas Gleixner Cc: Tomi Valkeinen Cc: Toshi Kani Cc: venkatesh.pallipadi@intel.com Cc: Ville Syrjälä Cc: Vlastimil Babka Link: http://lkml.kernel.org/r/1426893517-2511-6-git-send-email-mcgrof@do-not-panic.com Link: http://lkml.kernel.org/r/1435195342-26879-6-git-send-email-mcgrof@do-not-panic.com [ Move IORESOURCE_IO check up, space out statements for better readability. ] Signed-off-by: Borislav Petkov --- include/asm-generic/pci_iomap.h | 14 +++++++++ lib/pci_iomap.c | 66 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 80 insertions(+) diff --git a/include/asm-generic/pci_iomap.h b/include/asm-generic/pci_iomap.h index 7389c87116a0..b1e17fcee2d0 100644 --- a/include/asm-generic/pci_iomap.h +++ b/include/asm-generic/pci_iomap.h @@ -15,9 +15,13 @@ struct pci_dev; #ifdef CONFIG_PCI /* Create a virtual mapping cookie for a PCI BAR (memory or IO) */ extern void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long max); +extern void __iomem *pci_iomap_wc(struct pci_dev *dev, int bar, unsigned long max); extern void __iomem *pci_iomap_range(struct pci_dev *dev, int bar, unsigned long offset, unsigned long maxlen); +extern void __iomem *pci_iomap_wc_range(struct pci_dev *dev, int bar, + unsigned long offset, + unsigned long maxlen); /* Create a virtual mapping cookie for a port on a given PCI device. * Do not call this directly, it exists to make it easier for architectures * to override */ @@ -34,12 +38,22 @@ static inline void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned lon return NULL; } +static inline void __iomem *pci_iomap_wc(struct pci_dev *dev, int bar, unsigned long max) +{ + return NULL; +} static inline void __iomem *pci_iomap_range(struct pci_dev *dev, int bar, unsigned long offset, unsigned long maxlen) { return NULL; } +static inline void __iomem *pci_iomap_wc_range(struct pci_dev *dev, int bar, + unsigned long offset, + unsigned long maxlen) +{ + return NULL; +} #endif #endif /* __ASM_GENERIC_IO_H */ diff --git a/lib/pci_iomap.c b/lib/pci_iomap.c index e1930dbab2da..c10fba461454 100644 --- a/lib/pci_iomap.c +++ b/lib/pci_iomap.c @@ -49,6 +49,51 @@ void __iomem *pci_iomap_range(struct pci_dev *dev, EXPORT_SYMBOL(pci_iomap_range); /** + * pci_iomap_wc_range - create a virtual WC mapping cookie for a PCI BAR + * @dev: PCI device that owns the BAR + * @bar: BAR number + * @offset: map memory at the given offset in BAR + * @maxlen: max length of the memory to map + * + * Using this function you will get a __iomem address to your device BAR. + * You can access it using ioread*() and iowrite*(). These functions hide + * the details if this is a MMIO or PIO address space and will just do what + * you expect from them in the correct way. When possible write combining + * is used. + * + * @maxlen specifies the maximum length to map. If you want to get access to + * the complete BAR from offset to the end, pass %0 here. + * */ +void __iomem *pci_iomap_wc_range(struct pci_dev *dev, + int bar, + unsigned long offset, + unsigned long maxlen) +{ + resource_size_t start = pci_resource_start(dev, bar); + resource_size_t len = pci_resource_len(dev, bar); + unsigned long flags = pci_resource_flags(dev, bar); + + + if (flags & IORESOURCE_IO) + return NULL; + + if (len <= offset || !start) + return NULL; + + len -= offset; + start += offset; + if (maxlen && len > maxlen) + len = maxlen; + + if (flags & IORESOURCE_MEM) + return ioremap_wc(start, len); + + /* What? */ + return NULL; +} +EXPORT_SYMBOL_GPL(pci_iomap_wc_range); + +/** * pci_iomap - create a virtual mapping cookie for a PCI BAR * @dev: PCI device that owns the BAR * @bar: BAR number @@ -67,4 +112,25 @@ void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long maxlen) return pci_iomap_range(dev, bar, 0, maxlen); } EXPORT_SYMBOL(pci_iomap); + +/** + * pci_iomap_wc - create a virtual WC mapping cookie for a PCI BAR + * @dev: PCI device that owns the BAR + * @bar: BAR number + * @maxlen: length of the memory to map + * + * Using this function you will get a __iomem address to your device BAR. + * You can access it using ioread*() and iowrite*(). These functions hide + * the details if this is a MMIO or PIO address space and will just do what + * you expect from them in the correct way. When possible write combining + * is used. + * + * @maxlen specifies the maximum length to map. If you want to get access to + * the complete BAR without checking for its length first, pass %0 here. + * */ +void __iomem *pci_iomap_wc(struct pci_dev *dev, int bar, unsigned long maxlen) +{ + return pci_iomap_wc_range(dev, bar, 0, maxlen); +} +EXPORT_SYMBOL_GPL(pci_iomap_wc); #endif /* CONFIG_PCI */ -- 2.4.3