From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dan Williams Subject: [PATCH 09/20] i915: switch from acpi_os_ioremap to memremap Date: Fri, 09 Oct 2015 18:16:25 -0400 Message-ID: <20151009221625.32203.74117.stgit@dwillia2-desk3.jf.intel.com> References: <20151009221537.32203.5867.stgit@dwillia2-desk3.jf.intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20151009221537.32203.5867.stgit@dwillia2-desk3.jf.intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: linux-kernel@vger.kernel.org Cc: linux-arch@vger.kernel.org, David Airlie , intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org, Daniel Vetter , linux-arm-kernel@lists.infradead.org List-Id: linux-arch.vger.kernel.org aTkxNSBleHBlY3RzIHRoZSBPcFJlZ2lvbiB0byBiZSBjYWNoZWQgKGkuZS4gbm90IF9faW9tZW0p LCBzbyBleHBsaWNpdGx5Cm1hcCBpdCB3aXRoIG1lbXJlbWFwIHJhdGhlciB0aGFuIHRoZSBpbXBs aWVkIGNhY2hlIHNldHRpbmcgb2YKYWNwaV9vc19pb3JlbWFwKCkuCgpDYzogRGFuaWVsIFZldHRl ciA8ZGFuaWVsLnZldHRlckBpbnRlbC5jb20+CkNjOiBKYW5pIE5pa3VsYSA8amFuaS5uaWt1bGFA bGludXguaW50ZWwuY29tPgpDYzogaW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpDYzog RGF2aWQgQWlybGllIDxhaXJsaWVkQGxpbnV4LmllPgpDYzogZHJpLWRldmVsQGxpc3RzLmZyZWVk ZXNrdG9wLm9yZwpTaWduZWQtb2ZmLWJ5OiBEYW4gV2lsbGlhbXMgPGRhbi5qLndpbGxpYW1zQGlu dGVsLmNvbT4KLS0tCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2RlYnVnZnMuYyAgIHwgICAg MiAtCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5oICAgICAgIHwgICAxMiArKystLQog ZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfYmlvcy5jICAgICB8ICAgIDcgKy0tCiBkcml2ZXJz L2dwdS9kcm0vaTkxNS9pbnRlbF9vcHJlZ2lvbi5jIHwgICA3MyArKysrKysrKysrKysrKysrLS0t LS0tLS0tLS0tLS0tLS0KIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3BhbmVsLmMgICAgfCAg ICAyIC0KIDUgZmlsZXMgY2hhbmdlZCwgNDcgaW5zZXJ0aW9ucygrKSwgNDkgZGVsZXRpb25zKC0p CgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kZWJ1Z2ZzLmMgYi9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2RlYnVnZnMuYwppbmRleCBlM2VjOTA0OTA4MWYuLjE1OTg5 Y2MxNmU5MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kZWJ1Z2ZzLmMK KysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kZWJ1Z2ZzLmMKQEAgLTE4NDksNyArMTg0 OSw3IEBAIHN0YXRpYyBpbnQgaTkxNV9vcHJlZ2lvbihzdHJ1Y3Qgc2VxX2ZpbGUgKm0sIHZvaWQg KnVudXNlZCkKIAkJZ290byBvdXQ7CiAKIAlpZiAob3ByZWdpb24tPmhlYWRlcikgewotCQltZW1j cHlfZnJvbWlvKGRhdGEsIG9wcmVnaW9uLT5oZWFkZXIsIE9QUkVHSU9OX1NJWkUpOworCQltZW1j cHkoZGF0YSwgb3ByZWdpb24tPmhlYWRlciwgT1BSRUdJT05fU0laRSk7CiAJCXNlcV93cml0ZSht LCBkYXRhLCBPUFJFR0lPTl9TSVpFKTsKIAl9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2k5MTVfZHJ2LmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5oCmluZGV4 IGUxZGI4ZGU1Mjg1MS4uZDg2ODQ2MzRhMzFkIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0v aTkxNS9pOTE1X2Rydi5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmgKQEAg LTQ0NCwxNCArNDQ0LDE0IEBAIHN0cnVjdCBvcHJlZ2lvbl9zd3NjaTsKIHN0cnVjdCBvcHJlZ2lv bl9hc2xlOwogCiBzdHJ1Y3QgaW50ZWxfb3ByZWdpb24gewotCXN0cnVjdCBvcHJlZ2lvbl9oZWFk ZXIgX19pb21lbSAqaGVhZGVyOwotCXN0cnVjdCBvcHJlZ2lvbl9hY3BpIF9faW9tZW0gKmFjcGk7 Ci0Jc3RydWN0IG9wcmVnaW9uX3N3c2NpIF9faW9tZW0gKnN3c2NpOworCXN0cnVjdCBvcHJlZ2lv bl9oZWFkZXIgKmhlYWRlcjsKKwlzdHJ1Y3Qgb3ByZWdpb25fYWNwaSAqYWNwaTsKKwlzdHJ1Y3Qg b3ByZWdpb25fc3dzY2kgKnN3c2NpOwogCXUzMiBzd3NjaV9nYmRhX3N1Yl9mdW5jdGlvbnM7CiAJ dTMyIHN3c2NpX3NiY2Jfc3ViX2Z1bmN0aW9uczsKLQlzdHJ1Y3Qgb3ByZWdpb25fYXNsZSBfX2lv bWVtICphc2xlOwotCXZvaWQgX19pb21lbSAqdmJ0OwotCXUzMiBfX2lvbWVtICpsaWRfc3RhdGU7 CisJc3RydWN0IG9wcmVnaW9uX2FzbGUgKmFzbGU7CisJdm9pZCAqdmJ0OworCXUzMiAqbGlkX3N0 YXRlOwogCXN0cnVjdCB3b3JrX3N0cnVjdCBhc2xlX3dvcms7CiB9OwogI2RlZmluZSBPUFJFR0lP Tl9TSVpFICAgICAgICAgICAgKDgqMTAyNCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2ludGVsX2Jpb3MuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Jpb3MuYwppbmRl eCBjMTllNjY5ZmZlNTAuLjFlZTJmMTFkMzU1ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJt L2k5MTUvaW50ZWxfYmlvcy5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Jpb3Mu YwpAQCAtMTIzOCwxMSArMTIzOCwxMCBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IGJkYl9oZWFkZXIg KnZhbGlkYXRlX3ZidChjb25zdCB2b2lkIF9faW9tZW0gKl9iYXNlLAogewogCS8qCiAJICogVGhp cyBpcyB0aGUgb25lIHBsYWNlIHdoZXJlIHdlIGV4cGxpY2l0bHkgZGlzY2FyZCB0aGUgYWRkcmVz cyBzcGFjZQotCSAqIChfX2lvbWVtKSBvZiB0aGUgQklPUy9WQlQuIChBbmQgdGhpcyB3aWxsIGNh dXNlIGEgc3BhcnNlIGNvbXBsYWludC4pCi0JICogRnJvbSBub3cgb24gZXZlcnl0aGluZyBpcyBi YXNlZCBvbiAnYmFzZScsIGFuZCB0cmVhdGVkIGFzIHJlZ3VsYXIKLQkgKiBtZW1vcnkuCisJICog KF9faW9tZW0pIG9mIHRoZSBCSU9TL1ZCVC4gRnJvbSBub3cgb24gZXZlcnl0aGluZyBpcyBiYXNl ZCBvbgorCSAqICdiYXNlJywgYW5kIHRyZWF0ZWQgYXMgcmVndWxhciBtZW1vcnkuCiAJICovCi0J Y29uc3Qgdm9pZCAqYmFzZSA9IChjb25zdCB2b2lkICopIF9iYXNlOworCWNvbnN0IHZvaWQgKmJh c2UgPSAoY29uc3Qgdm9pZCBfX2ZvcmNlICopIF9iYXNlOwogCXNpemVfdCBvZmZzZXQgPSBfdmJ0 IC0gX2Jhc2U7CiAJY29uc3Qgc3RydWN0IHZidF9oZWFkZXIgKnZidCA9IGJhc2UgKyBvZmZzZXQ7 CiAJY29uc3Qgc3RydWN0IGJkYl9oZWFkZXIgKmJkYjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2ludGVsX29wcmVnaW9uLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9v cHJlZ2lvbi5jCmluZGV4IGNiMWM2NTczOTQyNS4uNGY2NWNkYjM4ZTFiIDEwMDY0NAotLS0gYS9k cml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9vcHJlZ2lvbi5jCisrKyBiL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2ludGVsX29wcmVnaW9uLmMKQEAgLTIzOSw3ICsyMzksNyBAQCBzdHJ1Y3Qgb3ByZWdp b25fYXNsZSB7CiBzdGF0aWMgaW50IHN3c2NpKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHUzMiBm dW5jdGlvbiwgdTMyIHBhcm0sIHUzMiAqcGFybV9vdXQpCiB7CiAJc3RydWN0IGRybV9pOTE1X3By aXZhdGUgKmRldl9wcml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsKLQlzdHJ1Y3Qgb3ByZWdpb25fc3dz Y2kgX19pb21lbSAqc3dzY2kgPSBkZXZfcHJpdi0+b3ByZWdpb24uc3dzY2k7CisJc3RydWN0IG9w cmVnaW9uX3N3c2NpICpzd3NjaSA9IGRldl9wcml2LT5vcHJlZ2lvbi5zd3NjaTsKIAl1MzIgbWFp bl9mdW5jdGlvbiwgc3ViX2Z1bmN0aW9uLCBzY2ljOwogCXUxNiBwY2lfc3dzY2k7CiAJdTMyIGRz bHA7CkBAIC0yNjQsNyArMjY0LDcgQEAgc3RhdGljIGludCBzd3NjaShzdHJ1Y3QgZHJtX2Rldmlj ZSAqZGV2LCB1MzIgZnVuY3Rpb24sIHUzMiBwYXJtLCB1MzIgKnBhcm1fb3V0KQogCX0KIAogCS8q IERyaXZlciBzbGVlcCB0aW1lb3V0IGluIG1zLiAqLwotCWRzbHAgPSBpb3JlYWQzMigmc3dzY2kt PmRzbHApOworCWRzbHAgPSBzd3NjaS0+ZHNscDsKIAlpZiAoIWRzbHApIHsKIAkJLyogVGhlIHNw ZWMgc2F5cyAybXMgc2hvdWxkIGJlIHRoZSBkZWZhdWx0LCBidXQgaXQncyB0b28gc21hbGwKIAkJ ICogZm9yIHNvbWUgbWFjaGluZXMuICovCkBAIC0yNzcsNyArMjc3LDcgQEAgc3RhdGljIGludCBz d3NjaShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCB1MzIgZnVuY3Rpb24sIHUzMiBwYXJtLCB1MzIg KnBhcm1fb3V0KQogCX0KIAogCS8qIFRoZSBzcGVjIHRlbGxzIHVzIHRvIGRvIHRoaXMsIGJ1dCB3 ZSBhcmUgdGhlIG9ubHkgdXNlci4uLiAqLwotCXNjaWMgPSBpb3JlYWQzMigmc3dzY2ktPnNjaWMp OworCXNjaWMgPSBzd3NjaS0+c2NpYzsKIAlpZiAoc2NpYyAmIFNXU0NJX1NDSUNfSU5ESUNBVE9S KSB7CiAJCURSTV9ERUJVR19EUklWRVIoIlNXU0NJIHJlcXVlc3QgYWxyZWFkeSBpbiBwcm9ncmVz c1xuIik7CiAJCXJldHVybiAtRUJVU1k7CkBAIC0yODUsOCArMjg1LDggQEAgc3RhdGljIGludCBz d3NjaShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCB1MzIgZnVuY3Rpb24sIHUzMiBwYXJtLCB1MzIg KnBhcm1fb3V0KQogCiAJc2NpYyA9IGZ1bmN0aW9uIHwgU1dTQ0lfU0NJQ19JTkRJQ0FUT1I7CiAK LQlpb3dyaXRlMzIocGFybSwgJnN3c2NpLT5wYXJtKTsKLQlpb3dyaXRlMzIoc2NpYywgJnN3c2Np LT5zY2ljKTsKKwlzd3NjaS0+cGFybSA9IHBhcm07CisJc3dzY2ktPnNjaWMgPSBzY2ljOwogCiAJ LyogRW5zdXJlIFNDSSBldmVudCBpcyBzZWxlY3RlZCBhbmQgZXZlbnQgdHJpZ2dlciBpcyBjbGVh cmVkLiAqLwogCXBjaV9yZWFkX2NvbmZpZ193b3JkKGRldi0+cGRldiwgUENJX1NXU0NJLCAmcGNp X3N3c2NpKTsKQEAgLTMwMSw3ICszMDEsNyBAQCBzdGF0aWMgaW50IHN3c2NpKHN0cnVjdCBkcm1f ZGV2aWNlICpkZXYsIHUzMiBmdW5jdGlvbiwgdTMyIHBhcm0sIHUzMiAqcGFybV9vdXQpCiAJcGNp X3dyaXRlX2NvbmZpZ193b3JkKGRldi0+cGRldiwgUENJX1NXU0NJLCBwY2lfc3dzY2kpOwogCiAJ LyogUG9sbCBmb3IgdGhlIHJlc3VsdC4gKi8KLSNkZWZpbmUgQyAoKChzY2ljID0gaW9yZWFkMzIo JnN3c2NpLT5zY2ljKSkgJiBTV1NDSV9TQ0lDX0lORElDQVRPUikgPT0gMCkKKyNkZWZpbmUgQyAo KChzY2ljID0gc3dzY2ktPnNjaWMpICYgU1dTQ0lfU0NJQ19JTkRJQ0FUT1IpID09IDApCiAJaWYg KHdhaXRfZm9yKEMsIGRzbHApKSB7CiAJCURSTV9ERUJVR19EUklWRVIoIlNXU0NJIHJlcXVlc3Qg dGltZWQgb3V0XG4iKTsKIAkJcmV0dXJuIC1FVElNRURPVVQ7CkBAIC0zMTcsNyArMzE3LDcgQEAg c3RhdGljIGludCBzd3NjaShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCB1MzIgZnVuY3Rpb24sIHUz MiBwYXJtLCB1MzIgKnBhcm1fb3V0KQogCX0KIAogCWlmIChwYXJtX291dCkKLQkJKnBhcm1fb3V0 ID0gaW9yZWFkMzIoJnN3c2NpLT5wYXJtKTsKKwkJKnBhcm1fb3V0ID0gc3dzY2ktPnBhcm07CiAK IAlyZXR1cm4gMDsKIApAQCAtNDA3LDcgKzQwNyw3IEBAIHN0YXRpYyB1MzIgYXNsZV9zZXRfYmFj a2xpZ2h0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHUzMiBiY2xwKQogewogCXN0cnVjdCBkcm1f aTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IGRldi0+ZGV2X3ByaXZhdGU7CiAJc3RydWN0IGludGVs X2Nvbm5lY3RvciAqaW50ZWxfY29ubmVjdG9yOwotCXN0cnVjdCBvcHJlZ2lvbl9hc2xlIF9faW9t ZW0gKmFzbGUgPSBkZXZfcHJpdi0+b3ByZWdpb24uYXNsZTsKKwlzdHJ1Y3Qgb3ByZWdpb25fYXNs ZSAqYXNsZSA9IGRldl9wcml2LT5vcHJlZ2lvbi5hc2xlOwogCiAJRFJNX0RFQlVHX0RSSVZFUigi YmNscCA9IDB4JTA4eFxuIiwgYmNscCk7CiAKQEAgLTQzMiw3ICs0MzIsNyBAQCBzdGF0aWMgdTMy IGFzbGVfc2V0X2JhY2tsaWdodChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCB1MzIgYmNscCkKIAlE Uk1fREVCVUdfS01TKCJ1cGRhdGluZyBvcHJlZ2lvbiBiYWNrbGlnaHQgJWQvMjU1XG4iLCBiY2xw KTsKIAlsaXN0X2Zvcl9lYWNoX2VudHJ5KGludGVsX2Nvbm5lY3RvciwgJmRldi0+bW9kZV9jb25m aWcuY29ubmVjdG9yX2xpc3QsIGJhc2UuaGVhZCkKIAkJaW50ZWxfcGFuZWxfc2V0X2JhY2tsaWdo dF9hY3BpKGludGVsX2Nvbm5lY3RvciwgYmNscCwgMjU1KTsKLQlpb3dyaXRlMzIoRElWX1JPVU5E X1VQKGJjbHAgKiAxMDAsIDI1NSkgfCBBU0xFX0NCTFZfVkFMSUQsICZhc2xlLT5jYmx2KTsKKwlh c2xlLT5jYmx2ID0gRElWX1JPVU5EX1VQKGJjbHAgKiAxMDAsIDI1NSkgfCBBU0xFX0NCTFZfVkFM SUQ7CiAKIAlkcm1fbW9kZXNldF91bmxvY2soJmRldi0+bW9kZV9jb25maWcuY29ubmVjdGlvbl9t dXRleCk7CiAKQEAgLTUxOSwxNCArNTE5LDE0IEBAIHN0YXRpYyB2b2lkIGFzbGVfd29yayhzdHJ1 Y3Qgd29ya19zdHJ1Y3QgKndvcmspCiAJc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2 ID0KIAkJY29udGFpbmVyX29mKG9wcmVnaW9uLCBzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSwgb3By ZWdpb24pOwogCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSBkZXZfcHJpdi0+ZGV2OwotCXN0cnVj dCBvcHJlZ2lvbl9hc2xlIF9faW9tZW0gKmFzbGUgPSBkZXZfcHJpdi0+b3ByZWdpb24uYXNsZTsK KwlzdHJ1Y3Qgb3ByZWdpb25fYXNsZSAqYXNsZSA9IGRldl9wcml2LT5vcHJlZ2lvbi5hc2xlOwog CXUzMiBhc2xjX3N0YXQgPSAwOwogCXUzMiBhc2xjX3JlcTsKIAogCWlmICghYXNsZSkKIAkJcmV0 dXJuOwogCi0JYXNsY19yZXEgPSBpb3JlYWQzMigmYXNsZS0+YXNsYyk7CisJYXNsY19yZXEgPSBh c2xlLT5hc2xjOwogCiAJaWYgKCEoYXNsY19yZXEgJiBBU0xDX1JFUV9NU0spKSB7CiAJCURSTV9E RUJVR19EUklWRVIoIk5vIHJlcXVlc3Qgb24gQVNMQyBpbnRlcnJ1cHQgMHglMDh4XG4iLApAQCAt NTM1LDM0ICs1MzUsMzQgQEAgc3RhdGljIHZvaWQgYXNsZV93b3JrKHN0cnVjdCB3b3JrX3N0cnVj dCAqd29yaykKIAl9CiAKIAlpZiAoYXNsY19yZXEgJiBBU0xDX1NFVF9BTFNfSUxMVU0pCi0JCWFz bGNfc3RhdCB8PSBhc2xlX3NldF9hbHNfaWxsdW0oZGV2LCBpb3JlYWQzMigmYXNsZS0+YWxzaSkp OworCQlhc2xjX3N0YXQgfD0gYXNsZV9zZXRfYWxzX2lsbHVtKGRldiwgYXNsZS0+YWxzaSk7CiAK IAlpZiAoYXNsY19yZXEgJiBBU0xDX1NFVF9CQUNLTElHSFQpCi0JCWFzbGNfc3RhdCB8PSBhc2xl X3NldF9iYWNrbGlnaHQoZGV2LCBpb3JlYWQzMigmYXNsZS0+YmNscCkpOworCQlhc2xjX3N0YXQg fD0gYXNsZV9zZXRfYmFja2xpZ2h0KGRldiwgYXNsZS0+YmNscCk7CiAKIAlpZiAoYXNsY19yZXEg JiBBU0xDX1NFVF9QRklUKQotCQlhc2xjX3N0YXQgfD0gYXNsZV9zZXRfcGZpdChkZXYsIGlvcmVh ZDMyKCZhc2xlLT5wZml0KSk7CisJCWFzbGNfc3RhdCB8PSBhc2xlX3NldF9wZml0KGRldiwgYXNs ZS0+cGZpdCk7CiAKIAlpZiAoYXNsY19yZXEgJiBBU0xDX1NFVF9QV01fRlJFUSkKLQkJYXNsY19z dGF0IHw9IGFzbGVfc2V0X3B3bV9mcmVxKGRldiwgaW9yZWFkMzIoJmFzbGUtPnBmbWIpKTsKKwkJ YXNsY19zdGF0IHw9IGFzbGVfc2V0X3B3bV9mcmVxKGRldiwgYXNsZS0+cGZtYik7CiAKIAlpZiAo YXNsY19yZXEgJiBBU0xDX1NVUFBPUlRFRF9ST1RBVElPTl9BTkdMRVMpCiAJCWFzbGNfc3RhdCB8 PSBhc2xlX3NldF9zdXBwb3J0ZWRfcm90YXRpb25fYW5nbGVzKGRldiwKLQkJCQkJCQlpb3JlYWQz MigmYXNsZS0+c3JvdCkpOworCQkJCQkJCWFzbGUtPnNyb3QpOwogCiAJaWYgKGFzbGNfcmVxICYg QVNMQ19CVVRUT05fQVJSQVkpCi0JCWFzbGNfc3RhdCB8PSBhc2xlX3NldF9idXR0b25fYXJyYXko ZGV2LCBpb3JlYWQzMigmYXNsZS0+aXVlcikpOworCQlhc2xjX3N0YXQgfD0gYXNsZV9zZXRfYnV0 dG9uX2FycmF5KGRldiwgYXNsZS0+aXVlcik7CiAKIAlpZiAoYXNsY19yZXEgJiBBU0xDX0NPTlZF UlRJQkxFX0lORElDQVRPUikKLQkJYXNsY19zdGF0IHw9IGFzbGVfc2V0X2NvbnZlcnRpYmxlKGRl diwgaW9yZWFkMzIoJmFzbGUtPml1ZXIpKTsKKwkJYXNsY19zdGF0IHw9IGFzbGVfc2V0X2NvbnZl cnRpYmxlKGRldiwgYXNsZS0+aXVlcik7CiAKIAlpZiAoYXNsY19yZXEgJiBBU0xDX0RPQ0tJTkdf SU5ESUNBVE9SKQotCQlhc2xjX3N0YXQgfD0gYXNsZV9zZXRfZG9ja2luZyhkZXYsIGlvcmVhZDMy KCZhc2xlLT5pdWVyKSk7CisJCWFzbGNfc3RhdCB8PSBhc2xlX3NldF9kb2NraW5nKGRldiwgYXNs ZS0+aXVlcik7CiAKIAlpZiAoYXNsY19yZXEgJiBBU0xDX0lTQ1RfU1RBVEVfQ0hBTkdFKQogCQlh c2xjX3N0YXQgfD0gYXNsZV9pc2N0X3N0YXRlKGRldik7CiAKLQlpb3dyaXRlMzIoYXNsY19zdGF0 LCAmYXNsZS0+YXNsYyk7CisJYXNsZS0+YXNsYyA9IGFzbGNfc3RhdDsKIH0KIAogdm9pZCBpbnRl bF9vcHJlZ2lvbl9hc2xlX2ludHIoc3RydWN0IGRybV9kZXZpY2UgKmRldikKQEAgLTU4Nyw4ICs1 ODcsOCBAQCBzdGF0aWMgaW50IGludGVsX29wcmVnaW9uX3ZpZGVvX2V2ZW50KHN0cnVjdCBub3Rp Zmllcl9ibG9jayAqbmIsCiAJICAgTGludXgsIHRoZXNlIGFyZSBoYW5kbGVkIGJ5IHRoZSBkb2Nr LCBidXR0b24gYW5kIHZpZGVvIGRyaXZlcnMuCiAJKi8KIAotCXN0cnVjdCBvcHJlZ2lvbl9hY3Bp IF9faW9tZW0gKmFjcGk7CiAJc3RydWN0IGFjcGlfYnVzX2V2ZW50ICpldmVudCA9IGRhdGE7CisJ c3RydWN0IG9wcmVnaW9uX2FjcGkgKmFjcGk7CiAJaW50IHJldCA9IE5PVElGWV9PSzsKIAogCWlm IChzdHJjbXAoZXZlbnQtPmRldmljZV9jbGFzcywgQUNQSV9WSURFT19DTEFTUykgIT0gMCkKQEAg LTU5OSwxMSArNTk5LDEwIEBAIHN0YXRpYyBpbnQgaW50ZWxfb3ByZWdpb25fdmlkZW9fZXZlbnQo c3RydWN0IG5vdGlmaWVyX2Jsb2NrICpuYiwKIAogCWFjcGkgPSBzeXN0ZW1fb3ByZWdpb24tPmFj cGk7CiAKLQlpZiAoZXZlbnQtPnR5cGUgPT0gMHg4MCAmJgotCSAgICAoaW9yZWFkMzIoJmFjcGkt PmNldnQpICYgMSkgPT0gMCkKKwlpZiAoZXZlbnQtPnR5cGUgPT0gMHg4MCAmJiAoKGFjcGktPmNl dnQgJiAxKSA9PSAwKSkKIAkJcmV0ID0gTk9USUZZX0JBRDsKIAotCWlvd3JpdGUzMigwLCAmYWNw aS0+Y3N0cyk7CisJYWNwaS0+Y3N0cyA9IDA7CiAKIAlyZXR1cm4gcmV0OwogfQpAQCAtNzg3LDE2 ICs3ODYsMTYgQEAgdm9pZCBpbnRlbF9vcHJlZ2lvbl9pbml0KHN0cnVjdCBkcm1fZGV2aWNlICpk ZXYpCiAJCS8qIE5vdGlmeSBCSU9TIHdlIGFyZSByZWFkeSB0byBoYW5kbGUgQUNQSSB2aWRlbyBl eHQgbm90aWZzLgogCQkgKiBSaWdodCBub3csIGFsbCB0aGUgZXZlbnRzIGFyZSBoYW5kbGVkIGJ5 IHRoZSBBQ1BJIHZpZGVvIG1vZHVsZS4KIAkJICogV2UgZG9uJ3QgYWN0dWFsbHkgbmVlZCB0byBk byBhbnl0aGluZyB3aXRoIHRoZW0uICovCi0JCWlvd3JpdGUzMigwLCAmb3ByZWdpb24tPmFjcGkt PmNzdHMpOwotCQlpb3dyaXRlMzIoMSwgJm9wcmVnaW9uLT5hY3BpLT5kcmR5KTsKKwkJb3ByZWdp b24tPmFjcGktPmNzdHMgPSAwOworCQlvcHJlZ2lvbi0+YWNwaS0+ZHJkeSA9IDE7CiAKIAkJc3lz dGVtX29wcmVnaW9uID0gb3ByZWdpb247CiAJCXJlZ2lzdGVyX2FjcGlfbm90aWZpZXIoJmludGVs X29wcmVnaW9uX25vdGlmaWVyKTsKIAl9CiAKIAlpZiAob3ByZWdpb24tPmFzbGUpIHsKLQkJaW93 cml0ZTMyKEFTTEVfVENIRV9CTENfRU4sICZvcHJlZ2lvbi0+YXNsZS0+dGNoZSk7Ci0JCWlvd3Jp dGUzMihBU0xFX0FSRFlfUkVBRFksICZvcHJlZ2lvbi0+YXNsZS0+YXJkeSk7CisJCW9wcmVnaW9u LT5hc2xlLT50Y2hlID0gQVNMRV9UQ0hFX0JMQ19FTjsKKwkJb3ByZWdpb24tPmFzbGUtPmFyZHkg PSBBU0xFX0FSRFlfUkVBRFk7CiAJfQogfQogCkBAIC04MDksMTkgKzgwOCwxOSBAQCB2b2lkIGlu dGVsX29wcmVnaW9uX2Zpbmkoc3RydWN0IGRybV9kZXZpY2UgKmRldikKIAkJcmV0dXJuOwogCiAJ aWYgKG9wcmVnaW9uLT5hc2xlKQotCQlpb3dyaXRlMzIoQVNMRV9BUkRZX05PVF9SRUFEWSwgJm9w cmVnaW9uLT5hc2xlLT5hcmR5KTsKKwkJb3ByZWdpb24tPmFzbGUtPmFyZHkgPSBBU0xFX0FSRFlf Tk9UX1JFQURZOwogCiAJY2FuY2VsX3dvcmtfc3luYygmZGV2X3ByaXYtPm9wcmVnaW9uLmFzbGVf d29yayk7CiAKIAlpZiAob3ByZWdpb24tPmFjcGkpIHsKLQkJaW93cml0ZTMyKDAsICZvcHJlZ2lv bi0+YWNwaS0+ZHJkeSk7CisJCW9wcmVnaW9uLT5hY3BpLT5kcmR5ID0gMDsKIAogCQlzeXN0ZW1f b3ByZWdpb24gPSBOVUxMOwogCQl1bnJlZ2lzdGVyX2FjcGlfbm90aWZpZXIoJmludGVsX29wcmVn aW9uX25vdGlmaWVyKTsKIAl9CiAKIAkvKiBqdXN0IGNsZWFyIGFsbCBvcHJlZ2lvbiBtZW1vcnkg cG9pbnRlcnMgbm93ICovCi0JaW91bm1hcChvcHJlZ2lvbi0+aGVhZGVyKTsKKwltZW11bm1hcChv cHJlZ2lvbi0+aGVhZGVyKTsKIAlvcHJlZ2lvbi0+aGVhZGVyID0gTlVMTDsKIAlvcHJlZ2lvbi0+ YWNwaSA9IE5VTEw7CiAJb3ByZWdpb24tPnN3c2NpID0gTlVMTDsKQEAgLTg5NCwxMCArODkzLDEw IEBAIGludCBpbnRlbF9vcHJlZ2lvbl9zZXR1cChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQogewog CXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IGRldi0+ZGV2X3ByaXZhdGU7CiAJ c3RydWN0IGludGVsX29wcmVnaW9uICpvcHJlZ2lvbiA9ICZkZXZfcHJpdi0+b3ByZWdpb247Ci0J dm9pZCBfX2lvbWVtICpiYXNlOwogCXUzMiBhc2xzLCBtYm94ZXM7CiAJY2hhciBidWZbc2l6ZW9m KE9QUkVHSU9OX1NJR05BVFVSRSldOwogCWludCBlcnIgPSAwOworCXZvaWQgKmJhc2U7CiAKIAlC VUlMRF9CVUdfT04oc2l6ZW9mKHN0cnVjdCBvcHJlZ2lvbl9oZWFkZXIpICE9IDB4MTAwKTsKIAlC VUlMRF9CVUdfT04oc2l6ZW9mKHN0cnVjdCBvcHJlZ2lvbl9hY3BpKSAhPSAweDEwMCk7CkBAIC05 MTUsMTEgKzkxNCwxMSBAQCBpbnQgaW50ZWxfb3ByZWdpb25fc2V0dXAoc3RydWN0IGRybV9kZXZp Y2UgKmRldikKIAlJTklUX1dPUksoJm9wcmVnaW9uLT5hc2xlX3dvcmssIGFzbGVfd29yayk7CiAj ZW5kaWYKIAotCWJhc2UgPSBhY3BpX29zX2lvcmVtYXAoYXNscywgT1BSRUdJT05fU0laRSk7CisJ YmFzZSA9IG1lbXJlbWFwKGFzbHMsIE9QUkVHSU9OX1NJWkUsIE1FTVJFTUFQX1dCKTsKIAlpZiAo IWJhc2UpCiAJCXJldHVybiAtRU5PTUVNOwogCi0JbWVtY3B5X2Zyb21pbyhidWYsIGJhc2UsIHNp emVvZihidWYpKTsKKwltZW1jcHkoYnVmLCBiYXNlLCBzaXplb2YoYnVmKSk7CiAKIAlpZiAobWVt Y21wKGJ1ZiwgT1BSRUdJT05fU0lHTkFUVVJFLCAxNikpIHsKIAkJRFJNX0RFQlVHX0RSSVZFUigi b3ByZWdpb24gc2lnbmF0dXJlIG1pc21hdGNoXG4iKTsKQEAgLTkzMSw3ICs5MzAsNyBAQCBpbnQg aW50ZWxfb3ByZWdpb25fc2V0dXAoc3RydWN0IGRybV9kZXZpY2UgKmRldikKIAogCW9wcmVnaW9u LT5saWRfc3RhdGUgPSBiYXNlICsgQUNQSV9DTElEOwogCi0JbWJveGVzID0gaW9yZWFkMzIoJm9w cmVnaW9uLT5oZWFkZXItPm1ib3hlcyk7CisJbWJveGVzID0gb3ByZWdpb24tPmhlYWRlci0+bWJv eGVzOwogCWlmIChtYm94ZXMgJiBNQk9YX0FDUEkpIHsKIAkJRFJNX0RFQlVHX0RSSVZFUigiUHVi bGljIEFDUEkgbWV0aG9kcyBzdXBwb3J0ZWRcbiIpOwogCQlvcHJlZ2lvbi0+YWNwaSA9IGJhc2Ug KyBPUFJFR0lPTl9BQ1BJX09GRlNFVDsKQEAgLTk0NiwxMiArOTQ1LDEyIEBAIGludCBpbnRlbF9v cHJlZ2lvbl9zZXR1cChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQogCQlEUk1fREVCVUdfRFJJVkVS KCJBU0xFIHN1cHBvcnRlZFxuIik7CiAJCW9wcmVnaW9uLT5hc2xlID0gYmFzZSArIE9QUkVHSU9O X0FTTEVfT0ZGU0VUOwogCi0JCWlvd3JpdGUzMihBU0xFX0FSRFlfTk9UX1JFQURZLCAmb3ByZWdp b24tPmFzbGUtPmFyZHkpOworCQlvcHJlZ2lvbi0+YXNsZS0+YXJkeSA9IEFTTEVfQVJEWV9OT1Rf UkVBRFk7CiAJfQogCiAJcmV0dXJuIDA7CiAKIGVycl9vdXQ6Ci0JaW91bm1hcChiYXNlKTsKKwlt ZW11bm1hcChiYXNlKTsKIAlyZXR1cm4gZXJyOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUv ZHJtL2k5MTUvaW50ZWxfcGFuZWwuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3BhbmVs LmMKaW5kZXggZTJhYjNmNmVkMDIyLi5jODQ0NGQ1ZjU0OWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2ludGVsX3BhbmVsLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50 ZWxfcGFuZWwuYwpAQCAtMzg3LDcgKzM4Nyw3IEBAIGludGVsX3BhbmVsX2RldGVjdChzdHJ1Y3Qg ZHJtX2RldmljZSAqZGV2KQogCiAJLyogQXNzdW1lIHRoYXQgdGhlIEJJT1MgZG9lcyBub3QgbGll IHRocm91Z2ggdGhlIE9wUmVnaW9uLi4uICovCiAJaWYgKCFpOTE1LnBhbmVsX2lnbm9yZV9saWQg JiYgZGV2X3ByaXYtPm9wcmVnaW9uLmxpZF9zdGF0ZSkgewotCQlyZXR1cm4gaW9yZWFkMzIoZGV2 X3ByaXYtPm9wcmVnaW9uLmxpZF9zdGF0ZSkgJiAweDEgPworCQlyZXR1cm4gKihkZXZfcHJpdi0+ b3ByZWdpb24ubGlkX3N0YXRlKSAmIDB4MSA/CiAJCQljb25uZWN0b3Jfc3RhdHVzX2Nvbm5lY3Rl ZCA6CiAJCQljb25uZWN0b3Jfc3RhdHVzX2Rpc2Nvbm5lY3RlZDsKIAl9CgpfX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpJbnRlbC1nZnggbWFpbGluZyBsaXN0 CkludGVsLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cDovL2xpc3RzLmZyZWVkZXNrdG9w Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga03.intel.com ([134.134.136.65]:15263 "EHLO mga03.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S932961AbbJIWWI (ORCPT ); Fri, 9 Oct 2015 18:22:08 -0400 Subject: [PATCH 09/20] i915: switch from acpi_os_ioremap to memremap From: Dan Williams Date: Fri, 09 Oct 2015 18:16:25 -0400 Message-ID: <20151009221625.32203.74117.stgit@dwillia2-desk3.jf.intel.com> In-Reply-To: <20151009221537.32203.5867.stgit@dwillia2-desk3.jf.intel.com> References: <20151009221537.32203.5867.stgit@dwillia2-desk3.jf.intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 7bit Sender: linux-arch-owner@vger.kernel.org List-ID: To: linux-kernel@vger.kernel.org Cc: linux-arch@vger.kernel.org, David Airlie , intel-gfx@lists.freedesktop.org, Jani Nikula , dri-devel@lists.freedesktop.org, Daniel Vetter , linux-arm-kernel@lists.infradead.org Message-ID: <20151009221625.45BYjKk2cR5ErtJwJaLsJOJDcAlo4exITRyZG-xB1MM@z> i915 expects the OpRegion to be cached (i.e. not __iomem), so explicitly map it with memremap rather than the implied cache setting of acpi_os_ioremap(). Cc: Daniel Vetter Cc: Jani Nikula Cc: intel-gfx@lists.freedesktop.org Cc: David Airlie Cc: dri-devel@lists.freedesktop.org Signed-off-by: Dan Williams --- drivers/gpu/drm/i915/i915_debugfs.c | 2 - drivers/gpu/drm/i915/i915_drv.h | 12 +++-- drivers/gpu/drm/i915/intel_bios.c | 7 +-- drivers/gpu/drm/i915/intel_opregion.c | 73 ++++++++++++++++----------------- drivers/gpu/drm/i915/intel_panel.c | 2 - 5 files changed, 47 insertions(+), 49 deletions(-) diff --git a/drivers/gpu/drm/i915/i915_debugfs.c b/drivers/gpu/drm/i915/i915_debugfs.c index e3ec9049081f..15989cc16e92 100644 --- a/drivers/gpu/drm/i915/i915_debugfs.c +++ b/drivers/gpu/drm/i915/i915_debugfs.c @@ -1849,7 +1849,7 @@ static int i915_opregion(struct seq_file *m, void *unused) goto out; if (opregion->header) { - memcpy_fromio(data, opregion->header, OPREGION_SIZE); + memcpy(data, opregion->header, OPREGION_SIZE); seq_write(m, data, OPREGION_SIZE); } diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h index e1db8de52851..d8684634a31d 100644 --- a/drivers/gpu/drm/i915/i915_drv.h +++ b/drivers/gpu/drm/i915/i915_drv.h @@ -444,14 +444,14 @@ struct opregion_swsci; struct opregion_asle; struct intel_opregion { - struct opregion_header __iomem *header; - struct opregion_acpi __iomem *acpi; - struct opregion_swsci __iomem *swsci; + struct opregion_header *header; + struct opregion_acpi *acpi; + struct opregion_swsci *swsci; u32 swsci_gbda_sub_functions; u32 swsci_sbcb_sub_functions; - struct opregion_asle __iomem *asle; - void __iomem *vbt; - u32 __iomem *lid_state; + struct opregion_asle *asle; + void *vbt; + u32 *lid_state; struct work_struct asle_work; }; #define OPREGION_SIZE (8*1024) diff --git a/drivers/gpu/drm/i915/intel_bios.c b/drivers/gpu/drm/i915/intel_bios.c index c19e669ffe50..1ee2f11d355d 100644 --- a/drivers/gpu/drm/i915/intel_bios.c +++ b/drivers/gpu/drm/i915/intel_bios.c @@ -1238,11 +1238,10 @@ static const struct bdb_header *validate_vbt(const void __iomem *_base, { /* * This is the one place where we explicitly discard the address space - * (__iomem) of the BIOS/VBT. (And this will cause a sparse complaint.) - * From now on everything is based on 'base', and treated as regular - * memory. + * (__iomem) of the BIOS/VBT. From now on everything is based on + * 'base', and treated as regular memory. */ - const void *base = (const void *) _base; + const void *base = (const void __force *) _base; size_t offset = _vbt - _base; const struct vbt_header *vbt = base + offset; const struct bdb_header *bdb; diff --git a/drivers/gpu/drm/i915/intel_opregion.c b/drivers/gpu/drm/i915/intel_opregion.c index cb1c65739425..4f65cdb38e1b 100644 --- a/drivers/gpu/drm/i915/intel_opregion.c +++ b/drivers/gpu/drm/i915/intel_opregion.c @@ -239,7 +239,7 @@ struct opregion_asle { static int swsci(struct drm_device *dev, u32 function, u32 parm, u32 *parm_out) { struct drm_i915_private *dev_priv = dev->dev_private; - struct opregion_swsci __iomem *swsci = dev_priv->opregion.swsci; + struct opregion_swsci *swsci = dev_priv->opregion.swsci; u32 main_function, sub_function, scic; u16 pci_swsci; u32 dslp; @@ -264,7 +264,7 @@ static int swsci(struct drm_device *dev, u32 function, u32 parm, u32 *parm_out) } /* Driver sleep timeout in ms. */ - dslp = ioread32(&swsci->dslp); + dslp = swsci->dslp; if (!dslp) { /* The spec says 2ms should be the default, but it's too small * for some machines. */ @@ -277,7 +277,7 @@ static int swsci(struct drm_device *dev, u32 function, u32 parm, u32 *parm_out) } /* The spec tells us to do this, but we are the only user... */ - scic = ioread32(&swsci->scic); + scic = swsci->scic; if (scic & SWSCI_SCIC_INDICATOR) { DRM_DEBUG_DRIVER("SWSCI request already in progress\n"); return -EBUSY; @@ -285,8 +285,8 @@ static int swsci(struct drm_device *dev, u32 function, u32 parm, u32 *parm_out) scic = function | SWSCI_SCIC_INDICATOR; - iowrite32(parm, &swsci->parm); - iowrite32(scic, &swsci->scic); + swsci->parm = parm; + swsci->scic = scic; /* Ensure SCI event is selected and event trigger is cleared. */ pci_read_config_word(dev->pdev, PCI_SWSCI, &pci_swsci); @@ -301,7 +301,7 @@ static int swsci(struct drm_device *dev, u32 function, u32 parm, u32 *parm_out) pci_write_config_word(dev->pdev, PCI_SWSCI, pci_swsci); /* Poll for the result. */ -#define C (((scic = ioread32(&swsci->scic)) & SWSCI_SCIC_INDICATOR) == 0) +#define C (((scic = swsci->scic) & SWSCI_SCIC_INDICATOR) == 0) if (wait_for(C, dslp)) { DRM_DEBUG_DRIVER("SWSCI request timed out\n"); return -ETIMEDOUT; @@ -317,7 +317,7 @@ static int swsci(struct drm_device *dev, u32 function, u32 parm, u32 *parm_out) } if (parm_out) - *parm_out = ioread32(&swsci->parm); + *parm_out = swsci->parm; return 0; @@ -407,7 +407,7 @@ static u32 asle_set_backlight(struct drm_device *dev, u32 bclp) { struct drm_i915_private *dev_priv = dev->dev_private; struct intel_connector *intel_connector; - struct opregion_asle __iomem *asle = dev_priv->opregion.asle; + struct opregion_asle *asle = dev_priv->opregion.asle; DRM_DEBUG_DRIVER("bclp = 0x%08x\n", bclp); @@ -432,7 +432,7 @@ static u32 asle_set_backlight(struct drm_device *dev, u32 bclp) DRM_DEBUG_KMS("updating opregion backlight %d/255\n", bclp); list_for_each_entry(intel_connector, &dev->mode_config.connector_list, base.head) intel_panel_set_backlight_acpi(intel_connector, bclp, 255); - iowrite32(DIV_ROUND_UP(bclp * 100, 255) | ASLE_CBLV_VALID, &asle->cblv); + asle->cblv = DIV_ROUND_UP(bclp * 100, 255) | ASLE_CBLV_VALID; drm_modeset_unlock(&dev->mode_config.connection_mutex); @@ -519,14 +519,14 @@ static void asle_work(struct work_struct *work) struct drm_i915_private *dev_priv = container_of(opregion, struct drm_i915_private, opregion); struct drm_device *dev = dev_priv->dev; - struct opregion_asle __iomem *asle = dev_priv->opregion.asle; + struct opregion_asle *asle = dev_priv->opregion.asle; u32 aslc_stat = 0; u32 aslc_req; if (!asle) return; - aslc_req = ioread32(&asle->aslc); + aslc_req = asle->aslc; if (!(aslc_req & ASLC_REQ_MSK)) { DRM_DEBUG_DRIVER("No request on ASLC interrupt 0x%08x\n", @@ -535,34 +535,34 @@ static void asle_work(struct work_struct *work) } if (aslc_req & ASLC_SET_ALS_ILLUM) - aslc_stat |= asle_set_als_illum(dev, ioread32(&asle->alsi)); + aslc_stat |= asle_set_als_illum(dev, asle->alsi); if (aslc_req & ASLC_SET_BACKLIGHT) - aslc_stat |= asle_set_backlight(dev, ioread32(&asle->bclp)); + aslc_stat |= asle_set_backlight(dev, asle->bclp); if (aslc_req & ASLC_SET_PFIT) - aslc_stat |= asle_set_pfit(dev, ioread32(&asle->pfit)); + aslc_stat |= asle_set_pfit(dev, asle->pfit); if (aslc_req & ASLC_SET_PWM_FREQ) - aslc_stat |= asle_set_pwm_freq(dev, ioread32(&asle->pfmb)); + aslc_stat |= asle_set_pwm_freq(dev, asle->pfmb); if (aslc_req & ASLC_SUPPORTED_ROTATION_ANGLES) aslc_stat |= asle_set_supported_rotation_angles(dev, - ioread32(&asle->srot)); + asle->srot); if (aslc_req & ASLC_BUTTON_ARRAY) - aslc_stat |= asle_set_button_array(dev, ioread32(&asle->iuer)); + aslc_stat |= asle_set_button_array(dev, asle->iuer); if (aslc_req & ASLC_CONVERTIBLE_INDICATOR) - aslc_stat |= asle_set_convertible(dev, ioread32(&asle->iuer)); + aslc_stat |= asle_set_convertible(dev, asle->iuer); if (aslc_req & ASLC_DOCKING_INDICATOR) - aslc_stat |= asle_set_docking(dev, ioread32(&asle->iuer)); + aslc_stat |= asle_set_docking(dev, asle->iuer); if (aslc_req & ASLC_ISCT_STATE_CHANGE) aslc_stat |= asle_isct_state(dev); - iowrite32(aslc_stat, &asle->aslc); + asle->aslc = aslc_stat; } void intel_opregion_asle_intr(struct drm_device *dev) @@ -587,8 +587,8 @@ static int intel_opregion_video_event(struct notifier_block *nb, Linux, these are handled by the dock, button and video drivers. */ - struct opregion_acpi __iomem *acpi; struct acpi_bus_event *event = data; + struct opregion_acpi *acpi; int ret = NOTIFY_OK; if (strcmp(event->device_class, ACPI_VIDEO_CLASS) != 0) @@ -599,11 +599,10 @@ static int intel_opregion_video_event(struct notifier_block *nb, acpi = system_opregion->acpi; - if (event->type == 0x80 && - (ioread32(&acpi->cevt) & 1) == 0) + if (event->type == 0x80 && ((acpi->cevt & 1) == 0)) ret = NOTIFY_BAD; - iowrite32(0, &acpi->csts); + acpi->csts = 0; return ret; } @@ -787,16 +786,16 @@ void intel_opregion_init(struct drm_device *dev) /* Notify BIOS we are ready to handle ACPI video ext notifs. * Right now, all the events are handled by the ACPI video module. * We don't actually need to do anything with them. */ - iowrite32(0, &opregion->acpi->csts); - iowrite32(1, &opregion->acpi->drdy); + opregion->acpi->csts = 0; + opregion->acpi->drdy = 1; system_opregion = opregion; register_acpi_notifier(&intel_opregion_notifier); } if (opregion->asle) { - iowrite32(ASLE_TCHE_BLC_EN, &opregion->asle->tche); - iowrite32(ASLE_ARDY_READY, &opregion->asle->ardy); + opregion->asle->tche = ASLE_TCHE_BLC_EN; + opregion->asle->ardy = ASLE_ARDY_READY; } } @@ -809,19 +808,19 @@ void intel_opregion_fini(struct drm_device *dev) return; if (opregion->asle) - iowrite32(ASLE_ARDY_NOT_READY, &opregion->asle->ardy); + opregion->asle->ardy = ASLE_ARDY_NOT_READY; cancel_work_sync(&dev_priv->opregion.asle_work); if (opregion->acpi) { - iowrite32(0, &opregion->acpi->drdy); + opregion->acpi->drdy = 0; system_opregion = NULL; unregister_acpi_notifier(&intel_opregion_notifier); } /* just clear all opregion memory pointers now */ - iounmap(opregion->header); + memunmap(opregion->header); opregion->header = NULL; opregion->acpi = NULL; opregion->swsci = NULL; @@ -894,10 +893,10 @@ int intel_opregion_setup(struct drm_device *dev) { struct drm_i915_private *dev_priv = dev->dev_private; struct intel_opregion *opregion = &dev_priv->opregion; - void __iomem *base; u32 asls, mboxes; char buf[sizeof(OPREGION_SIGNATURE)]; int err = 0; + void *base; BUILD_BUG_ON(sizeof(struct opregion_header) != 0x100); BUILD_BUG_ON(sizeof(struct opregion_acpi) != 0x100); @@ -915,11 +914,11 @@ int intel_opregion_setup(struct drm_device *dev) INIT_WORK(&opregion->asle_work, asle_work); #endif - base = acpi_os_ioremap(asls, OPREGION_SIZE); + base = memremap(asls, OPREGION_SIZE, MEMREMAP_WB); if (!base) return -ENOMEM; - memcpy_fromio(buf, base, sizeof(buf)); + memcpy(buf, base, sizeof(buf)); if (memcmp(buf, OPREGION_SIGNATURE, 16)) { DRM_DEBUG_DRIVER("opregion signature mismatch\n"); @@ -931,7 +930,7 @@ int intel_opregion_setup(struct drm_device *dev) opregion->lid_state = base + ACPI_CLID; - mboxes = ioread32(&opregion->header->mboxes); + mboxes = opregion->header->mboxes; if (mboxes & MBOX_ACPI) { DRM_DEBUG_DRIVER("Public ACPI methods supported\n"); opregion->acpi = base + OPREGION_ACPI_OFFSET; @@ -946,12 +945,12 @@ int intel_opregion_setup(struct drm_device *dev) DRM_DEBUG_DRIVER("ASLE supported\n"); opregion->asle = base + OPREGION_ASLE_OFFSET; - iowrite32(ASLE_ARDY_NOT_READY, &opregion->asle->ardy); + opregion->asle->ardy = ASLE_ARDY_NOT_READY; } return 0; err_out: - iounmap(base); + memunmap(base); return err; } diff --git a/drivers/gpu/drm/i915/intel_panel.c b/drivers/gpu/drm/i915/intel_panel.c index e2ab3f6ed022..c8444d5f549f 100644 --- a/drivers/gpu/drm/i915/intel_panel.c +++ b/drivers/gpu/drm/i915/intel_panel.c @@ -387,7 +387,7 @@ intel_panel_detect(struct drm_device *dev) /* Assume that the BIOS does not lie through the OpRegion... */ if (!i915.panel_ignore_lid && dev_priv->opregion.lid_state) { - return ioread32(dev_priv->opregion.lid_state) & 0x1 ? + return *(dev_priv->opregion.lid_state) & 0x1 ? connector_status_connected : connector_status_disconnected; }