From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Williams, Dan J" Subject: Re: [PATCH 09/20] i915: switch from acpi_os_ioremap to memremap Date: Mon, 12 Oct 2015 21:12:57 +0000 Message-ID: <1444684376.9780.5.camel@intel.com> References: <20151009221537.32203.5867.stgit@dwillia2-desk3.jf.intel.com> <20151009221625.32203.74117.stgit@dwillia2-desk3.jf.intel.com> <20151012070102.GV26718@phenom.ffwll.local> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20151012070102.GV26718@phenom.ffwll.local> Content-Language: en-US Content-ID: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: "daniel@ffwll.ch" Cc: "linux-arch@vger.kernel.org" , "airlied@linux.ie" , "intel-gfx@lists.freedesktop.org" , "linux-kernel@vger.kernel.org" , "dri-devel@lists.freedesktop.org" , "Vetter, Daniel" , "linux-arm-kernel@lists.infradead.org" List-Id: linux-arch.vger.kernel.org T24gTW9uLCAyMDE1LTEwLTEyIGF0IDA5OjAxICswMjAwLCBEYW5pZWwgVmV0dGVyIHdyb3RlOg0K PiBPbiBGcmksIE9jdCAwOSwgMjAxNSBhdCAwNjoxNjoyNVBNIC0wNDAwLCBEYW4gV2lsbGlhbXMg d3JvdGU6DQo+ID4gaTkxNSBleHBlY3RzIHRoZSBPcFJlZ2lvbiB0byBiZSBjYWNoZWQgKGkuZS4g bm90IF9faW9tZW0pLCBzbyBleHBsaWNpdGx5DQo+ID4gbWFwIGl0IHdpdGggbWVtcmVtYXAgcmF0 aGVyIHRoYW4gdGhlIGltcGxpZWQgY2FjaGUgc2V0dGluZyBvZg0KPiA+IGFjcGlfb3NfaW9yZW1h cCgpLg0KPiA+IA0KPiA+IENjOiBEYW5pZWwgVmV0dGVyIDxkYW5pZWwudmV0dGVyQGludGVsLmNv bT4NCj4gPiBDYzogSmFuaSBOaWt1bGEgPGphbmkubmlrdWxhQGxpbnV4LmludGVsLmNvbT4NCj4g PiBDYzogaW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZw0KPiA+IENjOiBEYXZpZCBBaXJs aWUgPGFpcmxpZWRAbGludXguaWU+DQo+ID4gQ2M6IGRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3Rv cC5vcmcNCj4gPiBTaWduZWQtb2ZmLWJ5OiBEYW4gV2lsbGlhbXMgPGRhbi5qLndpbGxpYW1zQGlu dGVsLmNvbT4NCj4gDQo+IEFzc3VtaW5nIHlvdSd2ZSBydW4gc3BhcnNlIG92ZXIgdGhpcyB0byBt YWtlIHN1cmUgeW91J3ZlIGNhdWdodCB0aGVtIGFsbCwNCj4gYW5kIHdpdGggdGhlIG5pdCBiZWxv dyBhZGRyZXNzZWQgdGhpcyBpcw0KPiANCj4gUmV2aWV3ZWQtYnk6IERhbmllbCBWZXR0ZXIgPGRh bmllbC52ZXR0ZXJAZmZ3bGwuY2g+DQoNCkluZGVlZCwgcmUtcnVubmluZyBzcGFyc2UgYWdhaW4g Zm91bmQgYSBmZXcgY29udmVyc2lvbnMgb2YgaW9yZWFkKiBJDQptaXNzZWQgYXMgd2VsbCBhcyBt b3ZpbmcgdGhlIGZvcmNlIGNhc3Rpbmcgb3V0IG9mIHZhbGlkYXRlX3ZidCgpIHRvDQpmaW5kX3Zi dCgpLg0KDQo+IEZlZWwgZnJlZSB0byBwdWxsIHYyIGludG8gd2hhdGV2ZXIgdHJlZSB5b3UgdGhp bmsgaXQncyBzdWl0YWJsZSBmb3IgKGJ1dA0KPiB5b3UgY2FuIGFsc28gcmVzZW5kIGFuZCBJJ2xs IHBpY2sgaXQgdXApLg0KDQpQbGVhc2UgcGljayB1cCB2MiBiZWxvdy4NCg0KPiANCj4gPiBkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcGFuZWwuYyBiL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2ludGVsX3BhbmVsLmMNCj4gPiBpbmRleCBlMmFiM2Y2ZWQwMjIuLmM4NDQ0ZDVm NTQ5ZiAxMDA2NDQNCj4gPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9wYW5lbC5j DQo+ID4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcGFuZWwuYw0KPiA+IEBAIC0z ODcsNyArMzg3LDcgQEAgaW50ZWxfcGFuZWxfZGV0ZWN0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYp DQo+ID4gIA0KPiA+ICAJLyogQXNzdW1lIHRoYXQgdGhlIEJJT1MgZG9lcyBub3QgbGllIHRocm91 Z2ggdGhlIE9wUmVnaW9uLi4uICovDQo+ID4gIAlpZiAoIWk5MTUucGFuZWxfaWdub3JlX2xpZCAm JiBkZXZfcHJpdi0+b3ByZWdpb24ubGlkX3N0YXRlKSB7DQo+ID4gLQkJcmV0dXJuIGlvcmVhZDMy KGRldl9wcml2LT5vcHJlZ2lvbi5saWRfc3RhdGUpICYgMHgxID8NCj4gPiArCQlyZXR1cm4gKihk ZXZfcHJpdi0+b3ByZWdpb24ubGlkX3N0YXRlKSAmIDB4MSA/DQo+IA0KPiAoKSBhcmUgcmVkdW5k YW50IG5vdyBoZXJlLg0KDQpZdXAsIGZpeGVkLg0KDQo4PC0tLS0NClN1YmplY3Q6IGk5MTU6IHN3 aXRjaCBmcm9tIGFjcGlfb3NfaW9yZW1hcCB0byBtZW1yZW1hcA0KDQpGcm9tOiBEYW4gV2lsbGlh bXMgPGRhbi5qLndpbGxpYW1zQGludGVsLmNvbT4NCg0KaTkxNSBleHBlY3RzIHRoZSBPcFJlZ2lv biB0byBiZSBjYWNoZWQgKGkuZS4gbm90IF9faW9tZW0pLCBzbyBleHBsaWNpdGx5DQptYXAgaXQg d2l0aCBtZW1yZW1hcCByYXRoZXIgdGhhbiB0aGUgaW1wbGllZCBjYWNoZSBzZXR0aW5nIG9mDQph Y3BpX29zX2lvcmVtYXAoKS4NCg0KQ2M6IERhbmllbCBWZXR0ZXIgPGRhbmllbC52ZXR0ZXJAaW50 ZWwuY29tPg0KQ2M6IEphbmkgTmlrdWxhIDxqYW5pLm5pa3VsYUBsaW51eC5pbnRlbC5jb20+DQpD YzogaW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZw0KQ2M6IERhdmlkIEFpcmxpZSA8YWly bGllZEBsaW51eC5pZT4NCkNjOiBkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnDQpTaWdu ZWQtb2ZmLWJ5OiBEYW4gV2lsbGlhbXMgPGRhbi5qLndpbGxpYW1zQGludGVsLmNvbT4NCi0tLQ0K IGRyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZGVidWdmcy5jICAgfCAgICAyIC0NCiBkcml2ZXJz L2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5oICAgICAgIHwgICAxMiArKy0tLQ0KIGRyaXZlcnMvZ3B1 L2RybS9pOTE1L2ludGVsX2Jpb3MuYyAgICAgfCAgIDI1ICsrKysrLS0tLS0NCiBkcml2ZXJzL2dw dS9kcm0vaTkxNS9pbnRlbF9vcHJlZ2lvbi5jIHwgICA4MyArKysrKysrKysrKysrKysrLS0tLS0t LS0tLS0tLS0tLS0NCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9wYW5lbC5jICAgIHwgICAg MiAtDQogNSBmaWxlcyBjaGFuZ2VkLCA2MiBpbnNlcnRpb25zKCspLCA2MiBkZWxldGlvbnMoLSkN Cg0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZGVidWdmcy5jIGIvZHJp dmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kZWJ1Z2ZzLmMNCmluZGV4IGUzZWM5MDQ5MDgxZi4uMTU5 ODljYzE2ZTkyIDEwMDY0NA0KLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kZWJ1Z2Zz LmMNCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZGVidWdmcy5jDQpAQCAtMTg0OSw3 ICsxODQ5LDcgQEAgc3RhdGljIGludCBpOTE1X29wcmVnaW9uKHN0cnVjdCBzZXFfZmlsZSAqbSwg dm9pZCAqdW51c2VkKQ0KIAkJZ290byBvdXQ7DQogDQogCWlmIChvcHJlZ2lvbi0+aGVhZGVyKSB7 DQotCQltZW1jcHlfZnJvbWlvKGRhdGEsIG9wcmVnaW9uLT5oZWFkZXIsIE9QUkVHSU9OX1NJWkUp Ow0KKwkJbWVtY3B5KGRhdGEsIG9wcmVnaW9uLT5oZWFkZXIsIE9QUkVHSU9OX1NJWkUpOw0KIAkJ c2VxX3dyaXRlKG0sIGRhdGEsIE9QUkVHSU9OX1NJWkUpOw0KIAl9DQogDQpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5 MTVfZHJ2LmgNCmluZGV4IGUxZGI4ZGU1Mjg1MS4uZDg2ODQ2MzRhMzFkIDEwMDY0NA0KLS0tIGEv ZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuaA0KKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5 MTUvaTkxNV9kcnYuaA0KQEAgLTQ0NCwxNCArNDQ0LDE0IEBAIHN0cnVjdCBvcHJlZ2lvbl9zd3Nj aTsNCiBzdHJ1Y3Qgb3ByZWdpb25fYXNsZTsNCiANCiBzdHJ1Y3QgaW50ZWxfb3ByZWdpb24gew0K LQlzdHJ1Y3Qgb3ByZWdpb25faGVhZGVyIF9faW9tZW0gKmhlYWRlcjsNCi0Jc3RydWN0IG9wcmVn aW9uX2FjcGkgX19pb21lbSAqYWNwaTsNCi0Jc3RydWN0IG9wcmVnaW9uX3N3c2NpIF9faW9tZW0g KnN3c2NpOw0KKwlzdHJ1Y3Qgb3ByZWdpb25faGVhZGVyICpoZWFkZXI7DQorCXN0cnVjdCBvcHJl Z2lvbl9hY3BpICphY3BpOw0KKwlzdHJ1Y3Qgb3ByZWdpb25fc3dzY2kgKnN3c2NpOw0KIAl1MzIg c3dzY2lfZ2JkYV9zdWJfZnVuY3Rpb25zOw0KIAl1MzIgc3dzY2lfc2JjYl9zdWJfZnVuY3Rpb25z Ow0KLQlzdHJ1Y3Qgb3ByZWdpb25fYXNsZSBfX2lvbWVtICphc2xlOw0KLQl2b2lkIF9faW9tZW0g KnZidDsNCi0JdTMyIF9faW9tZW0gKmxpZF9zdGF0ZTsNCisJc3RydWN0IG9wcmVnaW9uX2FzbGUg KmFzbGU7DQorCXZvaWQgKnZidDsNCisJdTMyICpsaWRfc3RhdGU7DQogCXN0cnVjdCB3b3JrX3N0 cnVjdCBhc2xlX3dvcms7DQogfTsNCiAjZGVmaW5lIE9QUkVHSU9OX1NJWkUgICAgICAgICAgICAo OCoxMDI0KQ0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Jpb3MuYyBi L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Jpb3MuYw0KaW5kZXggYzE5ZTY2OWZmZTUwLi5m Njc2MmE1ZmFlZTggMTAwNjQ0DQotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9iaW9z LmMNCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Jpb3MuYw0KQEAgLTEyMzEsMjAg KzEyMzEsMTMgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBkbWlfc3lzdGVtX2lkIGludGVsX25vX29w cmVnaW9uX3ZidFtdID0gew0KIAl7IH0NCiB9Ow0KIA0KLXN0YXRpYyBjb25zdCBzdHJ1Y3QgYmRi X2hlYWRlciAqdmFsaWRhdGVfdmJ0KGNvbnN0IHZvaWQgX19pb21lbSAqX2Jhc2UsDQorc3RhdGlj IGNvbnN0IHN0cnVjdCBiZGJfaGVhZGVyICp2YWxpZGF0ZV92YnQoY29uc3Qgdm9pZCAqYmFzZSwN CiAJCQkJCSAgICAgc2l6ZV90IHNpemUsDQotCQkJCQkgICAgIGNvbnN0IHZvaWQgX19pb21lbSAq X3ZidCwNCisJCQkJCSAgICAgY29uc3Qgdm9pZCAqX3ZidCwNCiAJCQkJCSAgICAgY29uc3QgY2hh ciAqc291cmNlKQ0KIHsNCi0JLyoNCi0JICogVGhpcyBpcyB0aGUgb25lIHBsYWNlIHdoZXJlIHdl IGV4cGxpY2l0bHkgZGlzY2FyZCB0aGUgYWRkcmVzcyBzcGFjZQ0KLQkgKiAoX19pb21lbSkgb2Yg dGhlIEJJT1MvVkJULiAoQW5kIHRoaXMgd2lsbCBjYXVzZSBhIHNwYXJzZSBjb21wbGFpbnQuKQ0K LQkgKiBGcm9tIG5vdyBvbiBldmVyeXRoaW5nIGlzIGJhc2VkIG9uICdiYXNlJywgYW5kIHRyZWF0 ZWQgYXMgcmVndWxhcg0KLQkgKiBtZW1vcnkuDQotCSAqLw0KLQljb25zdCB2b2lkICpiYXNlID0g KGNvbnN0IHZvaWQgKikgX2Jhc2U7DQotCXNpemVfdCBvZmZzZXQgPSBfdmJ0IC0gX2Jhc2U7DQot CWNvbnN0IHN0cnVjdCB2YnRfaGVhZGVyICp2YnQgPSBiYXNlICsgb2Zmc2V0Ow0KKwlzaXplX3Qg b2Zmc2V0ID0gX3ZidCAtIGJhc2U7DQorCWNvbnN0IHN0cnVjdCB2YnRfaGVhZGVyICp2YnQgPSBf dmJ0Ow0KIAljb25zdCBzdHJ1Y3QgYmRiX2hlYWRlciAqYmRiOw0KIA0KIAlpZiAob2Zmc2V0ICsg c2l6ZW9mKHN0cnVjdCB2YnRfaGVhZGVyKSA+IHNpemUpIHsNCkBAIC0xMjgyLDcgKzEyNzUsMTUg QEAgc3RhdGljIGNvbnN0IHN0cnVjdCBiZGJfaGVhZGVyICpmaW5kX3ZidCh2b2lkIF9faW9tZW0g KmJpb3MsIHNpemVfdCBzaXplKQ0KIAkvKiBTY291ciBtZW1vcnkgbG9va2luZyBmb3IgdGhlIFZC VCBzaWduYXR1cmUuICovDQogCWZvciAoaSA9IDA7IGkgKyA0IDwgc2l6ZTsgaSsrKSB7DQogCQlp ZiAoaW9yZWFkMzIoYmlvcyArIGkpID09ICooKGNvbnN0IHUzMiAqKSAiJFZCVCIpKSB7DQotCQkJ YmRiID0gdmFsaWRhdGVfdmJ0KGJpb3MsIHNpemUsIGJpb3MgKyBpLCAiUENJIFJPTSIpOw0KKwkJ CS8qDQorCQkJICogVGhpcyBpcyB0aGUgb25lIHBsYWNlIHdoZXJlIHdlIGV4cGxpY2l0bHkgZGlz Y2FyZCB0aGUNCisJCQkgKiBhZGRyZXNzIHNwYWNlIChfX2lvbWVtKSBvZiB0aGUgQklPUy9WQlQu IEZyb20gbm93IG9uDQorCQkJICogZXZlcnl0aGluZyBpcyBiYXNlZCBvbiAnYmFzZScsIGFuZCB0 cmVhdGVkIGFzIHJlZ3VsYXINCisJCQkgKiBtZW1vcnkuDQorCQkJICovDQorCQkJdm9pZCAqX2Jp b3MgPSAodm9pZCBfX2ZvcmNlICopIGJpb3M7DQorDQorCQkJYmRiID0gdmFsaWRhdGVfdmJ0KF9i aW9zLCBzaXplLCBfYmlvcyArIGksICJQQ0kgUk9NIik7DQogCQkJYnJlYWs7DQogCQl9DQogCX0N CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9vcHJlZ2lvbi5jIGIvZHJp dmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfb3ByZWdpb24uYw0KaW5kZXggY2IxYzY1NzM5NDI1Li40 MWQ0NGE1ZWY2MjYgMTAwNjQ0DQotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9vcHJl Z2lvbi5jDQorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9vcHJlZ2lvbi5jDQpAQCAt MjM5LDcgKzIzOSw3IEBAIHN0cnVjdCBvcHJlZ2lvbl9hc2xlIHsNCiBzdGF0aWMgaW50IHN3c2Np KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHUzMiBmdW5jdGlvbiwgdTMyIHBhcm0sIHUzMiAqcGFy bV9vdXQpDQogew0KIAlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYgPSBkZXYtPmRl dl9wcml2YXRlOw0KLQlzdHJ1Y3Qgb3ByZWdpb25fc3dzY2kgX19pb21lbSAqc3dzY2kgPSBkZXZf cHJpdi0+b3ByZWdpb24uc3dzY2k7DQorCXN0cnVjdCBvcHJlZ2lvbl9zd3NjaSAqc3dzY2kgPSBk ZXZfcHJpdi0+b3ByZWdpb24uc3dzY2k7DQogCXUzMiBtYWluX2Z1bmN0aW9uLCBzdWJfZnVuY3Rp b24sIHNjaWM7DQogCXUxNiBwY2lfc3dzY2k7DQogCXUzMiBkc2xwOw0KQEAgLTI2NCw3ICsyNjQs NyBAQCBzdGF0aWMgaW50IHN3c2NpKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHUzMiBmdW5jdGlv biwgdTMyIHBhcm0sIHUzMiAqcGFybV9vdXQpDQogCX0NCiANCiAJLyogRHJpdmVyIHNsZWVwIHRp bWVvdXQgaW4gbXMuICovDQotCWRzbHAgPSBpb3JlYWQzMigmc3dzY2ktPmRzbHApOw0KKwlkc2xw ID0gc3dzY2ktPmRzbHA7DQogCWlmICghZHNscCkgew0KIAkJLyogVGhlIHNwZWMgc2F5cyAybXMg c2hvdWxkIGJlIHRoZSBkZWZhdWx0LCBidXQgaXQncyB0b28gc21hbGwNCiAJCSAqIGZvciBzb21l IG1hY2hpbmVzLiAqLw0KQEAgLTI3Nyw3ICsyNzcsNyBAQCBzdGF0aWMgaW50IHN3c2NpKHN0cnVj dCBkcm1fZGV2aWNlICpkZXYsIHUzMiBmdW5jdGlvbiwgdTMyIHBhcm0sIHUzMiAqcGFybV9vdXQp DQogCX0NCiANCiAJLyogVGhlIHNwZWMgdGVsbHMgdXMgdG8gZG8gdGhpcywgYnV0IHdlIGFyZSB0 aGUgb25seSB1c2VyLi4uICovDQotCXNjaWMgPSBpb3JlYWQzMigmc3dzY2ktPnNjaWMpOw0KKwlz Y2ljID0gc3dzY2ktPnNjaWM7DQogCWlmIChzY2ljICYgU1dTQ0lfU0NJQ19JTkRJQ0FUT1IpIHsN CiAJCURSTV9ERUJVR19EUklWRVIoIlNXU0NJIHJlcXVlc3QgYWxyZWFkeSBpbiBwcm9ncmVzc1xu Iik7DQogCQlyZXR1cm4gLUVCVVNZOw0KQEAgLTI4NSw4ICsyODUsOCBAQCBzdGF0aWMgaW50IHN3 c2NpKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHUzMiBmdW5jdGlvbiwgdTMyIHBhcm0sIHUzMiAq cGFybV9vdXQpDQogDQogCXNjaWMgPSBmdW5jdGlvbiB8IFNXU0NJX1NDSUNfSU5ESUNBVE9SOw0K IA0KLQlpb3dyaXRlMzIocGFybSwgJnN3c2NpLT5wYXJtKTsNCi0JaW93cml0ZTMyKHNjaWMsICZz d3NjaS0+c2NpYyk7DQorCXN3c2NpLT5wYXJtID0gcGFybTsNCisJc3dzY2ktPnNjaWMgPSBzY2lj Ow0KIA0KIAkvKiBFbnN1cmUgU0NJIGV2ZW50IGlzIHNlbGVjdGVkIGFuZCBldmVudCB0cmlnZ2Vy IGlzIGNsZWFyZWQuICovDQogCXBjaV9yZWFkX2NvbmZpZ193b3JkKGRldi0+cGRldiwgUENJX1NX U0NJLCAmcGNpX3N3c2NpKTsNCkBAIC0zMDEsNyArMzAxLDcgQEAgc3RhdGljIGludCBzd3NjaShz dHJ1Y3QgZHJtX2RldmljZSAqZGV2LCB1MzIgZnVuY3Rpb24sIHUzMiBwYXJtLCB1MzIgKnBhcm1f b3V0KQ0KIAlwY2lfd3JpdGVfY29uZmlnX3dvcmQoZGV2LT5wZGV2LCBQQ0lfU1dTQ0ksIHBjaV9z d3NjaSk7DQogDQogCS8qIFBvbGwgZm9yIHRoZSByZXN1bHQuICovDQotI2RlZmluZSBDICgoKHNj aWMgPSBpb3JlYWQzMigmc3dzY2ktPnNjaWMpKSAmIFNXU0NJX1NDSUNfSU5ESUNBVE9SKSA9PSAw KQ0KKyNkZWZpbmUgQyAoKChzY2ljID0gc3dzY2ktPnNjaWMpICYgU1dTQ0lfU0NJQ19JTkRJQ0FU T1IpID09IDApDQogCWlmICh3YWl0X2ZvcihDLCBkc2xwKSkgew0KIAkJRFJNX0RFQlVHX0RSSVZF UigiU1dTQ0kgcmVxdWVzdCB0aW1lZCBvdXRcbiIpOw0KIAkJcmV0dXJuIC1FVElNRURPVVQ7DQpA QCAtMzE3LDcgKzMxNyw3IEBAIHN0YXRpYyBpbnQgc3dzY2koc3RydWN0IGRybV9kZXZpY2UgKmRl diwgdTMyIGZ1bmN0aW9uLCB1MzIgcGFybSwgdTMyICpwYXJtX291dCkNCiAJfQ0KIA0KIAlpZiAo cGFybV9vdXQpDQotCQkqcGFybV9vdXQgPSBpb3JlYWQzMigmc3dzY2ktPnBhcm0pOw0KKwkJKnBh cm1fb3V0ID0gc3dzY2ktPnBhcm07DQogDQogCXJldHVybiAwOw0KIA0KQEAgLTQwNyw3ICs0MDcs NyBAQCBzdGF0aWMgdTMyIGFzbGVfc2V0X2JhY2tsaWdodChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2 LCB1MzIgYmNscCkNCiB7DQogCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IGRl di0+ZGV2X3ByaXZhdGU7DQogCXN0cnVjdCBpbnRlbF9jb25uZWN0b3IgKmludGVsX2Nvbm5lY3Rv cjsNCi0Jc3RydWN0IG9wcmVnaW9uX2FzbGUgX19pb21lbSAqYXNsZSA9IGRldl9wcml2LT5vcHJl Z2lvbi5hc2xlOw0KKwlzdHJ1Y3Qgb3ByZWdpb25fYXNsZSAqYXNsZSA9IGRldl9wcml2LT5vcHJl Z2lvbi5hc2xlOw0KIA0KIAlEUk1fREVCVUdfRFJJVkVSKCJiY2xwID0gMHglMDh4XG4iLCBiY2xw KTsNCiANCkBAIC00MzIsNyArNDMyLDcgQEAgc3RhdGljIHUzMiBhc2xlX3NldF9iYWNrbGlnaHQo c3RydWN0IGRybV9kZXZpY2UgKmRldiwgdTMyIGJjbHApDQogCURSTV9ERUJVR19LTVMoInVwZGF0 aW5nIG9wcmVnaW9uIGJhY2tsaWdodCAlZC8yNTVcbiIsIGJjbHApOw0KIAlsaXN0X2Zvcl9lYWNo X2VudHJ5KGludGVsX2Nvbm5lY3RvciwgJmRldi0+bW9kZV9jb25maWcuY29ubmVjdG9yX2xpc3Qs IGJhc2UuaGVhZCkNCiAJCWludGVsX3BhbmVsX3NldF9iYWNrbGlnaHRfYWNwaShpbnRlbF9jb25u ZWN0b3IsIGJjbHAsIDI1NSk7DQotCWlvd3JpdGUzMihESVZfUk9VTkRfVVAoYmNscCAqIDEwMCwg MjU1KSB8IEFTTEVfQ0JMVl9WQUxJRCwgJmFzbGUtPmNibHYpOw0KKwlhc2xlLT5jYmx2ID0gRElW X1JPVU5EX1VQKGJjbHAgKiAxMDAsIDI1NSkgfCBBU0xFX0NCTFZfVkFMSUQ7DQogDQogCWRybV9t b2Rlc2V0X3VubG9jaygmZGV2LT5tb2RlX2NvbmZpZy5jb25uZWN0aW9uX211dGV4KTsNCiANCkBA IC01MTksMTQgKzUxOSwxNCBAQCBzdGF0aWMgdm9pZCBhc2xlX3dvcmsoc3RydWN0IHdvcmtfc3Ry dWN0ICp3b3JrKQ0KIAlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYgPQ0KIAkJY29u dGFpbmVyX29mKG9wcmVnaW9uLCBzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSwgb3ByZWdpb24pOw0K IAlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gZGV2X3ByaXYtPmRldjsNCi0Jc3RydWN0IG9wcmVn aW9uX2FzbGUgX19pb21lbSAqYXNsZSA9IGRldl9wcml2LT5vcHJlZ2lvbi5hc2xlOw0KKwlzdHJ1 Y3Qgb3ByZWdpb25fYXNsZSAqYXNsZSA9IGRldl9wcml2LT5vcHJlZ2lvbi5hc2xlOw0KIAl1MzIg YXNsY19zdGF0ID0gMDsNCiAJdTMyIGFzbGNfcmVxOw0KIA0KIAlpZiAoIWFzbGUpDQogCQlyZXR1 cm47DQogDQotCWFzbGNfcmVxID0gaW9yZWFkMzIoJmFzbGUtPmFzbGMpOw0KKwlhc2xjX3JlcSA9 IGFzbGUtPmFzbGM7DQogDQogCWlmICghKGFzbGNfcmVxICYgQVNMQ19SRVFfTVNLKSkgew0KIAkJ RFJNX0RFQlVHX0RSSVZFUigiTm8gcmVxdWVzdCBvbiBBU0xDIGludGVycnVwdCAweCUwOHhcbiIs DQpAQCAtNTM1LDM0ICs1MzUsMzQgQEAgc3RhdGljIHZvaWQgYXNsZV93b3JrKHN0cnVjdCB3b3Jr X3N0cnVjdCAqd29yaykNCiAJfQ0KIA0KIAlpZiAoYXNsY19yZXEgJiBBU0xDX1NFVF9BTFNfSUxM VU0pDQotCQlhc2xjX3N0YXQgfD0gYXNsZV9zZXRfYWxzX2lsbHVtKGRldiwgaW9yZWFkMzIoJmFz bGUtPmFsc2kpKTsNCisJCWFzbGNfc3RhdCB8PSBhc2xlX3NldF9hbHNfaWxsdW0oZGV2LCBhc2xl LT5hbHNpKTsNCiANCiAJaWYgKGFzbGNfcmVxICYgQVNMQ19TRVRfQkFDS0xJR0hUKQ0KLQkJYXNs Y19zdGF0IHw9IGFzbGVfc2V0X2JhY2tsaWdodChkZXYsIGlvcmVhZDMyKCZhc2xlLT5iY2xwKSk7 DQorCQlhc2xjX3N0YXQgfD0gYXNsZV9zZXRfYmFja2xpZ2h0KGRldiwgYXNsZS0+YmNscCk7DQog DQogCWlmIChhc2xjX3JlcSAmIEFTTENfU0VUX1BGSVQpDQotCQlhc2xjX3N0YXQgfD0gYXNsZV9z ZXRfcGZpdChkZXYsIGlvcmVhZDMyKCZhc2xlLT5wZml0KSk7DQorCQlhc2xjX3N0YXQgfD0gYXNs ZV9zZXRfcGZpdChkZXYsIGFzbGUtPnBmaXQpOw0KIA0KIAlpZiAoYXNsY19yZXEgJiBBU0xDX1NF VF9QV01fRlJFUSkNCi0JCWFzbGNfc3RhdCB8PSBhc2xlX3NldF9wd21fZnJlcShkZXYsIGlvcmVh ZDMyKCZhc2xlLT5wZm1iKSk7DQorCQlhc2xjX3N0YXQgfD0gYXNsZV9zZXRfcHdtX2ZyZXEoZGV2 LCBhc2xlLT5wZm1iKTsNCiANCiAJaWYgKGFzbGNfcmVxICYgQVNMQ19TVVBQT1JURURfUk9UQVRJ T05fQU5HTEVTKQ0KIAkJYXNsY19zdGF0IHw9IGFzbGVfc2V0X3N1cHBvcnRlZF9yb3RhdGlvbl9h bmdsZXMoZGV2LA0KLQkJCQkJCQlpb3JlYWQzMigmYXNsZS0+c3JvdCkpOw0KKwkJCQkJCQlhc2xl LT5zcm90KTsNCiANCiAJaWYgKGFzbGNfcmVxICYgQVNMQ19CVVRUT05fQVJSQVkpDQotCQlhc2xj X3N0YXQgfD0gYXNsZV9zZXRfYnV0dG9uX2FycmF5KGRldiwgaW9yZWFkMzIoJmFzbGUtPml1ZXIp KTsNCisJCWFzbGNfc3RhdCB8PSBhc2xlX3NldF9idXR0b25fYXJyYXkoZGV2LCBhc2xlLT5pdWVy KTsNCiANCiAJaWYgKGFzbGNfcmVxICYgQVNMQ19DT05WRVJUSUJMRV9JTkRJQ0FUT1IpDQotCQlh c2xjX3N0YXQgfD0gYXNsZV9zZXRfY29udmVydGlibGUoZGV2LCBpb3JlYWQzMigmYXNsZS0+aXVl cikpOw0KKwkJYXNsY19zdGF0IHw9IGFzbGVfc2V0X2NvbnZlcnRpYmxlKGRldiwgYXNsZS0+aXVl cik7DQogDQogCWlmIChhc2xjX3JlcSAmIEFTTENfRE9DS0lOR19JTkRJQ0FUT1IpDQotCQlhc2xj X3N0YXQgfD0gYXNsZV9zZXRfZG9ja2luZyhkZXYsIGlvcmVhZDMyKCZhc2xlLT5pdWVyKSk7DQor CQlhc2xjX3N0YXQgfD0gYXNsZV9zZXRfZG9ja2luZyhkZXYsIGFzbGUtPml1ZXIpOw0KIA0KIAlp ZiAoYXNsY19yZXEgJiBBU0xDX0lTQ1RfU1RBVEVfQ0hBTkdFKQ0KIAkJYXNsY19zdGF0IHw9IGFz bGVfaXNjdF9zdGF0ZShkZXYpOw0KIA0KLQlpb3dyaXRlMzIoYXNsY19zdGF0LCAmYXNsZS0+YXNs Yyk7DQorCWFzbGUtPmFzbGMgPSBhc2xjX3N0YXQ7DQogfQ0KIA0KIHZvaWQgaW50ZWxfb3ByZWdp b25fYXNsZV9pbnRyKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpDQpAQCAtNTg3LDggKzU4Nyw4IEBA IHN0YXRpYyBpbnQgaW50ZWxfb3ByZWdpb25fdmlkZW9fZXZlbnQoc3RydWN0IG5vdGlmaWVyX2Js b2NrICpuYiwNCiAJICAgTGludXgsIHRoZXNlIGFyZSBoYW5kbGVkIGJ5IHRoZSBkb2NrLCBidXR0 b24gYW5kIHZpZGVvIGRyaXZlcnMuDQogCSovDQogDQotCXN0cnVjdCBvcHJlZ2lvbl9hY3BpIF9f aW9tZW0gKmFjcGk7DQogCXN0cnVjdCBhY3BpX2J1c19ldmVudCAqZXZlbnQgPSBkYXRhOw0KKwlz dHJ1Y3Qgb3ByZWdpb25fYWNwaSAqYWNwaTsNCiAJaW50IHJldCA9IE5PVElGWV9PSzsNCiANCiAJ aWYgKHN0cmNtcChldmVudC0+ZGV2aWNlX2NsYXNzLCBBQ1BJX1ZJREVPX0NMQVNTKSAhPSAwKQ0K QEAgLTU5OSwxMSArNTk5LDEwIEBAIHN0YXRpYyBpbnQgaW50ZWxfb3ByZWdpb25fdmlkZW9fZXZl bnQoc3RydWN0IG5vdGlmaWVyX2Jsb2NrICpuYiwNCiANCiAJYWNwaSA9IHN5c3RlbV9vcHJlZ2lv bi0+YWNwaTsNCiANCi0JaWYgKGV2ZW50LT50eXBlID09IDB4ODAgJiYNCi0JICAgIChpb3JlYWQz MigmYWNwaS0+Y2V2dCkgJiAxKSA9PSAwKQ0KKwlpZiAoZXZlbnQtPnR5cGUgPT0gMHg4MCAmJiAo KGFjcGktPmNldnQgJiAxKSA9PSAwKSkNCiAJCXJldCA9IE5PVElGWV9CQUQ7DQogDQotCWlvd3Jp dGUzMigwLCAmYWNwaS0+Y3N0cyk7DQorCWFjcGktPmNzdHMgPSAwOw0KIA0KIAlyZXR1cm4gcmV0 Ow0KIH0NCkBAIC02MjMsMTQgKzYyMiwxNCBAQCBzdGF0aWMgdTMyIGdldF9kaWQoc3RydWN0IGlu dGVsX29wcmVnaW9uICpvcHJlZ2lvbiwgaW50IGkpDQogCXUzMiBkaWQ7DQogDQogCWlmIChpIDwg QVJSQVlfU0laRShvcHJlZ2lvbi0+YWNwaS0+ZGlkbCkpIHsNCi0JCWRpZCA9IGlvcmVhZDMyKCZv cHJlZ2lvbi0+YWNwaS0+ZGlkbFtpXSk7DQorCQlkaWQgPSBvcHJlZ2lvbi0+YWNwaS0+ZGlkbFtp XTsNCiAJfSBlbHNlIHsNCiAJCWkgLT0gQVJSQVlfU0laRShvcHJlZ2lvbi0+YWNwaS0+ZGlkbCk7 DQogDQogCQlpZiAoV0FSTl9PTihpID49IEFSUkFZX1NJWkUob3ByZWdpb24tPmFjcGktPmRpZDIp KSkNCiAJCQlyZXR1cm4gMDsNCiANCi0JCWRpZCA9IGlvcmVhZDMyKCZvcHJlZ2lvbi0+YWNwaS0+ ZGlkMltpXSk7DQorCQlkaWQgPSBvcHJlZ2lvbi0+YWNwaS0+ZGlkMltpXTsNCiAJfQ0KIA0KIAly ZXR1cm4gZGlkOw0KQEAgLTYzOSwxNCArNjM4LDE0IEBAIHN0YXRpYyB1MzIgZ2V0X2RpZChzdHJ1 Y3QgaW50ZWxfb3ByZWdpb24gKm9wcmVnaW9uLCBpbnQgaSkNCiBzdGF0aWMgdm9pZCBzZXRfZGlk KHN0cnVjdCBpbnRlbF9vcHJlZ2lvbiAqb3ByZWdpb24sIGludCBpLCB1MzIgdmFsKQ0KIHsNCiAJ aWYgKGkgPCBBUlJBWV9TSVpFKG9wcmVnaW9uLT5hY3BpLT5kaWRsKSkgew0KLQkJaW93cml0ZTMy KHZhbCwgJm9wcmVnaW9uLT5hY3BpLT5kaWRsW2ldKTsNCisJCW9wcmVnaW9uLT5hY3BpLT5kaWRs W2ldID0gdmFsOw0KIAl9IGVsc2Ugew0KIAkJaSAtPSBBUlJBWV9TSVpFKG9wcmVnaW9uLT5hY3Bp LT5kaWRsKTsNCiANCiAJCWlmIChXQVJOX09OKGkgPj0gQVJSQVlfU0laRShvcHJlZ2lvbi0+YWNw aS0+ZGlkMikpKQ0KIAkJCXJldHVybjsNCiANCi0JCWlvd3JpdGUzMih2YWwsICZvcHJlZ2lvbi0+ YWNwaS0+ZGlkMltpXSk7DQorCQlvcHJlZ2lvbi0+YWNwaS0+ZGlkMltpXSA9IHZhbDsNCiAJfQ0K IH0NCiANCkBAIC03NjgsNyArNzY3LDcgQEAgc3RhdGljIHZvaWQgaW50ZWxfc2V0dXBfY2FkbHMo c3RydWN0IGRybV9kZXZpY2UgKmRldikNCiAJICogdGhlcmUgYXJlIGxlc3MgdGhhbiBlaWdodCBk ZXZpY2VzLiAqLw0KIAlkbyB7DQogCQlkaXNwX2lkID0gZ2V0X2RpZChvcHJlZ2lvbiwgaSk7DQot CQlpb3dyaXRlMzIoZGlzcF9pZCwgJm9wcmVnaW9uLT5hY3BpLT5jYWRsW2ldKTsNCisJCW9wcmVn aW9uLT5hY3BpLT5jYWRsW2ldID0gZGlzcF9pZDsNCiAJfSB3aGlsZSAoKytpIDwgOCAmJiBkaXNw X2lkICE9IDApOw0KIH0NCiANCkBAIC03ODcsMTYgKzc4NiwxNiBAQCB2b2lkIGludGVsX29wcmVn aW9uX2luaXQoc3RydWN0IGRybV9kZXZpY2UgKmRldikNCiAJCS8qIE5vdGlmeSBCSU9TIHdlIGFy ZSByZWFkeSB0byBoYW5kbGUgQUNQSSB2aWRlbyBleHQgbm90aWZzLg0KIAkJICogUmlnaHQgbm93 LCBhbGwgdGhlIGV2ZW50cyBhcmUgaGFuZGxlZCBieSB0aGUgQUNQSSB2aWRlbyBtb2R1bGUuDQog CQkgKiBXZSBkb24ndCBhY3R1YWxseSBuZWVkIHRvIGRvIGFueXRoaW5nIHdpdGggdGhlbS4gKi8N Ci0JCWlvd3JpdGUzMigwLCAmb3ByZWdpb24tPmFjcGktPmNzdHMpOw0KLQkJaW93cml0ZTMyKDEs ICZvcHJlZ2lvbi0+YWNwaS0+ZHJkeSk7DQorCQlvcHJlZ2lvbi0+YWNwaS0+Y3N0cyA9IDA7DQor CQlvcHJlZ2lvbi0+YWNwaS0+ZHJkeSA9IDE7DQogDQogCQlzeXN0ZW1fb3ByZWdpb24gPSBvcHJl Z2lvbjsNCiAJCXJlZ2lzdGVyX2FjcGlfbm90aWZpZXIoJmludGVsX29wcmVnaW9uX25vdGlmaWVy KTsNCiAJfQ0KIA0KIAlpZiAob3ByZWdpb24tPmFzbGUpIHsNCi0JCWlvd3JpdGUzMihBU0xFX1RD SEVfQkxDX0VOLCAmb3ByZWdpb24tPmFzbGUtPnRjaGUpOw0KLQkJaW93cml0ZTMyKEFTTEVfQVJE WV9SRUFEWSwgJm9wcmVnaW9uLT5hc2xlLT5hcmR5KTsNCisJCW9wcmVnaW9uLT5hc2xlLT50Y2hl ID0gQVNMRV9UQ0hFX0JMQ19FTjsNCisJCW9wcmVnaW9uLT5hc2xlLT5hcmR5ID0gQVNMRV9BUkRZ X1JFQURZOw0KIAl9DQogfQ0KIA0KQEAgLTgwOSwxOSArODA4LDE5IEBAIHZvaWQgaW50ZWxfb3By ZWdpb25fZmluaShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQ0KIAkJcmV0dXJuOw0KIA0KIAlpZiAo b3ByZWdpb24tPmFzbGUpDQotCQlpb3dyaXRlMzIoQVNMRV9BUkRZX05PVF9SRUFEWSwgJm9wcmVn aW9uLT5hc2xlLT5hcmR5KTsNCisJCW9wcmVnaW9uLT5hc2xlLT5hcmR5ID0gQVNMRV9BUkRZX05P VF9SRUFEWTsNCiANCiAJY2FuY2VsX3dvcmtfc3luYygmZGV2X3ByaXYtPm9wcmVnaW9uLmFzbGVf d29yayk7DQogDQogCWlmIChvcHJlZ2lvbi0+YWNwaSkgew0KLQkJaW93cml0ZTMyKDAsICZvcHJl Z2lvbi0+YWNwaS0+ZHJkeSk7DQorCQlvcHJlZ2lvbi0+YWNwaS0+ZHJkeSA9IDA7DQogDQogCQlz eXN0ZW1fb3ByZWdpb24gPSBOVUxMOw0KIAkJdW5yZWdpc3Rlcl9hY3BpX25vdGlmaWVyKCZpbnRl bF9vcHJlZ2lvbl9ub3RpZmllcik7DQogCX0NCiANCiAJLyoganVzdCBjbGVhciBhbGwgb3ByZWdp b24gbWVtb3J5IHBvaW50ZXJzIG5vdyAqLw0KLQlpb3VubWFwKG9wcmVnaW9uLT5oZWFkZXIpOw0K KwltZW11bm1hcChvcHJlZ2lvbi0+aGVhZGVyKTsNCiAJb3ByZWdpb24tPmhlYWRlciA9IE5VTEw7 DQogCW9wcmVnaW9uLT5hY3BpID0gTlVMTDsNCiAJb3ByZWdpb24tPnN3c2NpID0gTlVMTDsNCkBA IC04OTQsMTAgKzg5MywxMCBAQCBpbnQgaW50ZWxfb3ByZWdpb25fc2V0dXAoc3RydWN0IGRybV9k ZXZpY2UgKmRldikNCiB7DQogCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IGRl di0+ZGV2X3ByaXZhdGU7DQogCXN0cnVjdCBpbnRlbF9vcHJlZ2lvbiAqb3ByZWdpb24gPSAmZGV2 X3ByaXYtPm9wcmVnaW9uOw0KLQl2b2lkIF9faW9tZW0gKmJhc2U7DQogCXUzMiBhc2xzLCBtYm94 ZXM7DQogCWNoYXIgYnVmW3NpemVvZihPUFJFR0lPTl9TSUdOQVRVUkUpXTsNCiAJaW50IGVyciA9 IDA7DQorCXZvaWQgKmJhc2U7DQogDQogCUJVSUxEX0JVR19PTihzaXplb2Yoc3RydWN0IG9wcmVn aW9uX2hlYWRlcikgIT0gMHgxMDApOw0KIAlCVUlMRF9CVUdfT04oc2l6ZW9mKHN0cnVjdCBvcHJl Z2lvbl9hY3BpKSAhPSAweDEwMCk7DQpAQCAtOTE1LDExICs5MTQsMTEgQEAgaW50IGludGVsX29w cmVnaW9uX3NldHVwKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpDQogCUlOSVRfV09SSygmb3ByZWdp b24tPmFzbGVfd29yaywgYXNsZV93b3JrKTsNCiAjZW5kaWYNCiANCi0JYmFzZSA9IGFjcGlfb3Nf aW9yZW1hcChhc2xzLCBPUFJFR0lPTl9TSVpFKTsNCisJYmFzZSA9IG1lbXJlbWFwKGFzbHMsIE9Q UkVHSU9OX1NJWkUsIE1FTVJFTUFQX1dCKTsNCiAJaWYgKCFiYXNlKQ0KIAkJcmV0dXJuIC1FTk9N RU07DQogDQotCW1lbWNweV9mcm9taW8oYnVmLCBiYXNlLCBzaXplb2YoYnVmKSk7DQorCW1lbWNw eShidWYsIGJhc2UsIHNpemVvZihidWYpKTsNCiANCiAJaWYgKG1lbWNtcChidWYsIE9QUkVHSU9O X1NJR05BVFVSRSwgMTYpKSB7DQogCQlEUk1fREVCVUdfRFJJVkVSKCJvcHJlZ2lvbiBzaWduYXR1 cmUgbWlzbWF0Y2hcbiIpOw0KQEAgLTkzMSw3ICs5MzAsNyBAQCBpbnQgaW50ZWxfb3ByZWdpb25f c2V0dXAoc3RydWN0IGRybV9kZXZpY2UgKmRldikNCiANCiAJb3ByZWdpb24tPmxpZF9zdGF0ZSA9 IGJhc2UgKyBBQ1BJX0NMSUQ7DQogDQotCW1ib3hlcyA9IGlvcmVhZDMyKCZvcHJlZ2lvbi0+aGVh ZGVyLT5tYm94ZXMpOw0KKwltYm94ZXMgPSBvcHJlZ2lvbi0+aGVhZGVyLT5tYm94ZXM7DQogCWlm IChtYm94ZXMgJiBNQk9YX0FDUEkpIHsNCiAJCURSTV9ERUJVR19EUklWRVIoIlB1YmxpYyBBQ1BJ IG1ldGhvZHMgc3VwcG9ydGVkXG4iKTsNCiAJCW9wcmVnaW9uLT5hY3BpID0gYmFzZSArIE9QUkVH SU9OX0FDUElfT0ZGU0VUOw0KQEAgLTk0NiwxMiArOTQ1LDEyIEBAIGludCBpbnRlbF9vcHJlZ2lv bl9zZXR1cChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQ0KIAkJRFJNX0RFQlVHX0RSSVZFUigiQVNM RSBzdXBwb3J0ZWRcbiIpOw0KIAkJb3ByZWdpb24tPmFzbGUgPSBiYXNlICsgT1BSRUdJT05fQVNM RV9PRkZTRVQ7DQogDQotCQlpb3dyaXRlMzIoQVNMRV9BUkRZX05PVF9SRUFEWSwgJm9wcmVnaW9u LT5hc2xlLT5hcmR5KTsNCisJCW9wcmVnaW9uLT5hc2xlLT5hcmR5ID0gQVNMRV9BUkRZX05PVF9S RUFEWTsNCiAJfQ0KIA0KIAlyZXR1cm4gMDsNCiANCiBlcnJfb3V0Og0KLQlpb3VubWFwKGJhc2Up Ow0KKwltZW11bm1hcChiYXNlKTsNCiAJcmV0dXJuIGVycjsNCiB9DQpkaWZmIC0tZ2l0IGEvZHJp dmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcGFuZWwuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2lu dGVsX3BhbmVsLmMNCmluZGV4IGUyYWIzZjZlZDAyMi4uZWZlNTQyNGIyOTBjIDEwMDY0NA0KLS0t IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcGFuZWwuYw0KKysrIGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvaW50ZWxfcGFuZWwuYw0KQEAgLTM4Nyw3ICszODcsNyBAQCBpbnRlbF9wYW5lbF9k ZXRlY3Qoc3RydWN0IGRybV9kZXZpY2UgKmRldikNCiANCiAJLyogQXNzdW1lIHRoYXQgdGhlIEJJ T1MgZG9lcyBub3QgbGllIHRocm91Z2ggdGhlIE9wUmVnaW9uLi4uICovDQogCWlmICghaTkxNS5w YW5lbF9pZ25vcmVfbGlkICYmIGRldl9wcml2LT5vcHJlZ2lvbi5saWRfc3RhdGUpIHsNCi0JCXJl dHVybiBpb3JlYWQzMihkZXZfcHJpdi0+b3ByZWdpb24ubGlkX3N0YXRlKSAmIDB4MSA/DQorCQly ZXR1cm4gKmRldl9wcml2LT5vcHJlZ2lvbi5saWRfc3RhdGUgJiAweDEgPw0KIAkJCWNvbm5lY3Rv cl9zdGF0dXNfY29ubmVjdGVkIDoNCiAJCQljb25uZWN0b3Jfc3RhdHVzX2Rpc2Nvbm5lY3RlZDsN CiAJfQ0KDQpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpJ bnRlbC1nZnggbWFpbGluZyBsaXN0CkludGVsLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0 cDovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga03.intel.com ([134.134.136.65]:27545 "EHLO mga03.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752330AbbJLVNS (ORCPT ); Mon, 12 Oct 2015 17:13:18 -0400 From: "Williams, Dan J" Subject: Re: [Intel-gfx] [PATCH 09/20] i915: switch from acpi_os_ioremap to memremap Date: Mon, 12 Oct 2015 21:12:57 +0000 Message-ID: <1444684376.9780.5.camel@intel.com> References: <20151009221537.32203.5867.stgit@dwillia2-desk3.jf.intel.com> <20151009221625.32203.74117.stgit@dwillia2-desk3.jf.intel.com> <20151012070102.GV26718@phenom.ffwll.local> In-Reply-To: <20151012070102.GV26718@phenom.ffwll.local> Content-Language: en-US Content-Type: text/plain; charset="utf-8" Content-ID: Content-Transfer-Encoding: base64 MIME-Version: 1.0 Sender: linux-arch-owner@vger.kernel.org List-ID: To: "daniel@ffwll.ch" Cc: "dri-devel@lists.freedesktop.org" , "linux-kernel@vger.kernel.org" , "linux-arch@vger.kernel.org" , "linux-arm-kernel@lists.infradead.org" , "intel-gfx@lists.freedesktop.org" , "Vetter, Daniel" , "airlied@linux.ie" Message-ID: <20151012211257.01Ow0vcWE8BlEAFFWZw9SX3fn6Ea0UHhjBRJ1Btsr5A@z> T24gTW9uLCAyMDE1LTEwLTEyIGF0IDA5OjAxICswMjAwLCBEYW5pZWwgVmV0dGVyIHdyb3RlOg0K PiBPbiBGcmksIE9jdCAwOSwgMjAxNSBhdCAwNjoxNjoyNVBNIC0wNDAwLCBEYW4gV2lsbGlhbXMg d3JvdGU6DQo+ID4gaTkxNSBleHBlY3RzIHRoZSBPcFJlZ2lvbiB0byBiZSBjYWNoZWQgKGkuZS4g bm90IF9faW9tZW0pLCBzbyBleHBsaWNpdGx5DQo+ID4gbWFwIGl0IHdpdGggbWVtcmVtYXAgcmF0 aGVyIHRoYW4gdGhlIGltcGxpZWQgY2FjaGUgc2V0dGluZyBvZg0KPiA+IGFjcGlfb3NfaW9yZW1h cCgpLg0KPiA+IA0KPiA+IENjOiBEYW5pZWwgVmV0dGVyIDxkYW5pZWwudmV0dGVyQGludGVsLmNv bT4NCj4gPiBDYzogSmFuaSBOaWt1bGEgPGphbmkubmlrdWxhQGxpbnV4LmludGVsLmNvbT4NCj4g PiBDYzogaW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZw0KPiA+IENjOiBEYXZpZCBBaXJs aWUgPGFpcmxpZWRAbGludXguaWU+DQo+ID4gQ2M6IGRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3Rv cC5vcmcNCj4gPiBTaWduZWQtb2ZmLWJ5OiBEYW4gV2lsbGlhbXMgPGRhbi5qLndpbGxpYW1zQGlu dGVsLmNvbT4NCj4gDQo+IEFzc3VtaW5nIHlvdSd2ZSBydW4gc3BhcnNlIG92ZXIgdGhpcyB0byBt YWtlIHN1cmUgeW91J3ZlIGNhdWdodCB0aGVtIGFsbCwNCj4gYW5kIHdpdGggdGhlIG5pdCBiZWxv dyBhZGRyZXNzZWQgdGhpcyBpcw0KPiANCj4gUmV2aWV3ZWQtYnk6IERhbmllbCBWZXR0ZXIgPGRh bmllbC52ZXR0ZXJAZmZ3bGwuY2g+DQoNCkluZGVlZCwgcmUtcnVubmluZyBzcGFyc2UgYWdhaW4g Zm91bmQgYSBmZXcgY29udmVyc2lvbnMgb2YgaW9yZWFkKiBJDQptaXNzZWQgYXMgd2VsbCBhcyBt b3ZpbmcgdGhlIGZvcmNlIGNhc3Rpbmcgb3V0IG9mIHZhbGlkYXRlX3ZidCgpIHRvDQpmaW5kX3Zi dCgpLg0KDQo+IEZlZWwgZnJlZSB0byBwdWxsIHYyIGludG8gd2hhdGV2ZXIgdHJlZSB5b3UgdGhp bmsgaXQncyBzdWl0YWJsZSBmb3IgKGJ1dA0KPiB5b3UgY2FuIGFsc28gcmVzZW5kIGFuZCBJJ2xs IHBpY2sgaXQgdXApLg0KDQpQbGVhc2UgcGljayB1cCB2MiBiZWxvdy4NCg0KPiANCj4gPiBkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcGFuZWwuYyBiL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2ludGVsX3BhbmVsLmMNCj4gPiBpbmRleCBlMmFiM2Y2ZWQwMjIuLmM4NDQ0ZDVm NTQ5ZiAxMDA2NDQNCj4gPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9wYW5lbC5j DQo+ID4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcGFuZWwuYw0KPiA+IEBAIC0z ODcsNyArMzg3LDcgQEAgaW50ZWxfcGFuZWxfZGV0ZWN0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYp DQo+ID4gIA0KPiA+ICAJLyogQXNzdW1lIHRoYXQgdGhlIEJJT1MgZG9lcyBub3QgbGllIHRocm91 Z2ggdGhlIE9wUmVnaW9uLi4uICovDQo+ID4gIAlpZiAoIWk5MTUucGFuZWxfaWdub3JlX2xpZCAm JiBkZXZfcHJpdi0+b3ByZWdpb24ubGlkX3N0YXRlKSB7DQo+ID4gLQkJcmV0dXJuIGlvcmVhZDMy KGRldl9wcml2LT5vcHJlZ2lvbi5saWRfc3RhdGUpICYgMHgxID8NCj4gPiArCQlyZXR1cm4gKihk ZXZfcHJpdi0+b3ByZWdpb24ubGlkX3N0YXRlKSAmIDB4MSA/DQo+IA0KPiAoKSBhcmUgcmVkdW5k YW50IG5vdyBoZXJlLg0KDQpZdXAsIGZpeGVkLg0KDQo4PC0tLS0NClN1YmplY3Q6IGk5MTU6IHN3 aXRjaCBmcm9tIGFjcGlfb3NfaW9yZW1hcCB0byBtZW1yZW1hcA0KDQpGcm9tOiBEYW4gV2lsbGlh bXMgPGRhbi5qLndpbGxpYW1zQGludGVsLmNvbT4NCg0KaTkxNSBleHBlY3RzIHRoZSBPcFJlZ2lv biB0byBiZSBjYWNoZWQgKGkuZS4gbm90IF9faW9tZW0pLCBzbyBleHBsaWNpdGx5DQptYXAgaXQg d2l0aCBtZW1yZW1hcCByYXRoZXIgdGhhbiB0aGUgaW1wbGllZCBjYWNoZSBzZXR0aW5nIG9mDQph Y3BpX29zX2lvcmVtYXAoKS4NCg0KQ2M6IERhbmllbCBWZXR0ZXIgPGRhbmllbC52ZXR0ZXJAaW50 ZWwuY29tPg0KQ2M6IEphbmkgTmlrdWxhIDxqYW5pLm5pa3VsYUBsaW51eC5pbnRlbC5jb20+DQpD YzogaW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZw0KQ2M6IERhdmlkIEFpcmxpZSA8YWly bGllZEBsaW51eC5pZT4NCkNjOiBkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnDQpTaWdu ZWQtb2ZmLWJ5OiBEYW4gV2lsbGlhbXMgPGRhbi5qLndpbGxpYW1zQGludGVsLmNvbT4NCi0tLQ0K IGRyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZGVidWdmcy5jICAgfCAgICAyIC0NCiBkcml2ZXJz L2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5oICAgICAgIHwgICAxMiArKy0tLQ0KIGRyaXZlcnMvZ3B1 L2RybS9pOTE1L2ludGVsX2Jpb3MuYyAgICAgfCAgIDI1ICsrKysrLS0tLS0NCiBkcml2ZXJzL2dw dS9kcm0vaTkxNS9pbnRlbF9vcHJlZ2lvbi5jIHwgICA4MyArKysrKysrKysrKysrKysrLS0tLS0t LS0tLS0tLS0tLS0NCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9wYW5lbC5jICAgIHwgICAg MiAtDQogNSBmaWxlcyBjaGFuZ2VkLCA2MiBpbnNlcnRpb25zKCspLCA2MiBkZWxldGlvbnMoLSkN Cg0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZGVidWdmcy5jIGIvZHJp dmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kZWJ1Z2ZzLmMNCmluZGV4IGUzZWM5MDQ5MDgxZi4uMTU5 ODljYzE2ZTkyIDEwMDY0NA0KLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kZWJ1Z2Zz LmMNCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZGVidWdmcy5jDQpAQCAtMTg0OSw3 ICsxODQ5LDcgQEAgc3RhdGljIGludCBpOTE1X29wcmVnaW9uKHN0cnVjdCBzZXFfZmlsZSAqbSwg dm9pZCAqdW51c2VkKQ0KIAkJZ290byBvdXQ7DQogDQogCWlmIChvcHJlZ2lvbi0+aGVhZGVyKSB7 DQotCQltZW1jcHlfZnJvbWlvKGRhdGEsIG9wcmVnaW9uLT5oZWFkZXIsIE9QUkVHSU9OX1NJWkUp Ow0KKwkJbWVtY3B5KGRhdGEsIG9wcmVnaW9uLT5oZWFkZXIsIE9QUkVHSU9OX1NJWkUpOw0KIAkJ c2VxX3dyaXRlKG0sIGRhdGEsIE9QUkVHSU9OX1NJWkUpOw0KIAl9DQogDQpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5 MTVfZHJ2LmgNCmluZGV4IGUxZGI4ZGU1Mjg1MS4uZDg2ODQ2MzRhMzFkIDEwMDY0NA0KLS0tIGEv ZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuaA0KKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5 MTUvaTkxNV9kcnYuaA0KQEAgLTQ0NCwxNCArNDQ0LDE0IEBAIHN0cnVjdCBvcHJlZ2lvbl9zd3Nj aTsNCiBzdHJ1Y3Qgb3ByZWdpb25fYXNsZTsNCiANCiBzdHJ1Y3QgaW50ZWxfb3ByZWdpb24gew0K LQlzdHJ1Y3Qgb3ByZWdpb25faGVhZGVyIF9faW9tZW0gKmhlYWRlcjsNCi0Jc3RydWN0IG9wcmVn aW9uX2FjcGkgX19pb21lbSAqYWNwaTsNCi0Jc3RydWN0IG9wcmVnaW9uX3N3c2NpIF9faW9tZW0g KnN3c2NpOw0KKwlzdHJ1Y3Qgb3ByZWdpb25faGVhZGVyICpoZWFkZXI7DQorCXN0cnVjdCBvcHJl Z2lvbl9hY3BpICphY3BpOw0KKwlzdHJ1Y3Qgb3ByZWdpb25fc3dzY2kgKnN3c2NpOw0KIAl1MzIg c3dzY2lfZ2JkYV9zdWJfZnVuY3Rpb25zOw0KIAl1MzIgc3dzY2lfc2JjYl9zdWJfZnVuY3Rpb25z Ow0KLQlzdHJ1Y3Qgb3ByZWdpb25fYXNsZSBfX2lvbWVtICphc2xlOw0KLQl2b2lkIF9faW9tZW0g KnZidDsNCi0JdTMyIF9faW9tZW0gKmxpZF9zdGF0ZTsNCisJc3RydWN0IG9wcmVnaW9uX2FzbGUg KmFzbGU7DQorCXZvaWQgKnZidDsNCisJdTMyICpsaWRfc3RhdGU7DQogCXN0cnVjdCB3b3JrX3N0 cnVjdCBhc2xlX3dvcms7DQogfTsNCiAjZGVmaW5lIE9QUkVHSU9OX1NJWkUgICAgICAgICAgICAo OCoxMDI0KQ0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Jpb3MuYyBi L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Jpb3MuYw0KaW5kZXggYzE5ZTY2OWZmZTUwLi5m Njc2MmE1ZmFlZTggMTAwNjQ0DQotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9iaW9z LmMNCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Jpb3MuYw0KQEAgLTEyMzEsMjAg KzEyMzEsMTMgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBkbWlfc3lzdGVtX2lkIGludGVsX25vX29w cmVnaW9uX3ZidFtdID0gew0KIAl7IH0NCiB9Ow0KIA0KLXN0YXRpYyBjb25zdCBzdHJ1Y3QgYmRi X2hlYWRlciAqdmFsaWRhdGVfdmJ0KGNvbnN0IHZvaWQgX19pb21lbSAqX2Jhc2UsDQorc3RhdGlj IGNvbnN0IHN0cnVjdCBiZGJfaGVhZGVyICp2YWxpZGF0ZV92YnQoY29uc3Qgdm9pZCAqYmFzZSwN CiAJCQkJCSAgICAgc2l6ZV90IHNpemUsDQotCQkJCQkgICAgIGNvbnN0IHZvaWQgX19pb21lbSAq X3ZidCwNCisJCQkJCSAgICAgY29uc3Qgdm9pZCAqX3ZidCwNCiAJCQkJCSAgICAgY29uc3QgY2hh ciAqc291cmNlKQ0KIHsNCi0JLyoNCi0JICogVGhpcyBpcyB0aGUgb25lIHBsYWNlIHdoZXJlIHdl IGV4cGxpY2l0bHkgZGlzY2FyZCB0aGUgYWRkcmVzcyBzcGFjZQ0KLQkgKiAoX19pb21lbSkgb2Yg dGhlIEJJT1MvVkJULiAoQW5kIHRoaXMgd2lsbCBjYXVzZSBhIHNwYXJzZSBjb21wbGFpbnQuKQ0K LQkgKiBGcm9tIG5vdyBvbiBldmVyeXRoaW5nIGlzIGJhc2VkIG9uICdiYXNlJywgYW5kIHRyZWF0 ZWQgYXMgcmVndWxhcg0KLQkgKiBtZW1vcnkuDQotCSAqLw0KLQljb25zdCB2b2lkICpiYXNlID0g KGNvbnN0IHZvaWQgKikgX2Jhc2U7DQotCXNpemVfdCBvZmZzZXQgPSBfdmJ0IC0gX2Jhc2U7DQot CWNvbnN0IHN0cnVjdCB2YnRfaGVhZGVyICp2YnQgPSBiYXNlICsgb2Zmc2V0Ow0KKwlzaXplX3Qg b2Zmc2V0ID0gX3ZidCAtIGJhc2U7DQorCWNvbnN0IHN0cnVjdCB2YnRfaGVhZGVyICp2YnQgPSBf dmJ0Ow0KIAljb25zdCBzdHJ1Y3QgYmRiX2hlYWRlciAqYmRiOw0KIA0KIAlpZiAob2Zmc2V0ICsg c2l6ZW9mKHN0cnVjdCB2YnRfaGVhZGVyKSA+IHNpemUpIHsNCkBAIC0xMjgyLDcgKzEyNzUsMTUg QEAgc3RhdGljIGNvbnN0IHN0cnVjdCBiZGJfaGVhZGVyICpmaW5kX3ZidCh2b2lkIF9faW9tZW0g KmJpb3MsIHNpemVfdCBzaXplKQ0KIAkvKiBTY291ciBtZW1vcnkgbG9va2luZyBmb3IgdGhlIFZC VCBzaWduYXR1cmUuICovDQogCWZvciAoaSA9IDA7IGkgKyA0IDwgc2l6ZTsgaSsrKSB7DQogCQlp ZiAoaW9yZWFkMzIoYmlvcyArIGkpID09ICooKGNvbnN0IHUzMiAqKSAiJFZCVCIpKSB7DQotCQkJ YmRiID0gdmFsaWRhdGVfdmJ0KGJpb3MsIHNpemUsIGJpb3MgKyBpLCAiUENJIFJPTSIpOw0KKwkJ CS8qDQorCQkJICogVGhpcyBpcyB0aGUgb25lIHBsYWNlIHdoZXJlIHdlIGV4cGxpY2l0bHkgZGlz Y2FyZCB0aGUNCisJCQkgKiBhZGRyZXNzIHNwYWNlIChfX2lvbWVtKSBvZiB0aGUgQklPUy9WQlQu IEZyb20gbm93IG9uDQorCQkJICogZXZlcnl0aGluZyBpcyBiYXNlZCBvbiAnYmFzZScsIGFuZCB0 cmVhdGVkIGFzIHJlZ3VsYXINCisJCQkgKiBtZW1vcnkuDQorCQkJICovDQorCQkJdm9pZCAqX2Jp b3MgPSAodm9pZCBfX2ZvcmNlICopIGJpb3M7DQorDQorCQkJYmRiID0gdmFsaWRhdGVfdmJ0KF9i aW9zLCBzaXplLCBfYmlvcyArIGksICJQQ0kgUk9NIik7DQogCQkJYnJlYWs7DQogCQl9DQogCX0N CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9vcHJlZ2lvbi5jIGIvZHJp dmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfb3ByZWdpb24uYw0KaW5kZXggY2IxYzY1NzM5NDI1Li40 MWQ0NGE1ZWY2MjYgMTAwNjQ0DQotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9vcHJl Z2lvbi5jDQorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9vcHJlZ2lvbi5jDQpAQCAt MjM5LDcgKzIzOSw3IEBAIHN0cnVjdCBvcHJlZ2lvbl9hc2xlIHsNCiBzdGF0aWMgaW50IHN3c2Np KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHUzMiBmdW5jdGlvbiwgdTMyIHBhcm0sIHUzMiAqcGFy bV9vdXQpDQogew0KIAlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYgPSBkZXYtPmRl dl9wcml2YXRlOw0KLQlzdHJ1Y3Qgb3ByZWdpb25fc3dzY2kgX19pb21lbSAqc3dzY2kgPSBkZXZf cHJpdi0+b3ByZWdpb24uc3dzY2k7DQorCXN0cnVjdCBvcHJlZ2lvbl9zd3NjaSAqc3dzY2kgPSBk ZXZfcHJpdi0+b3ByZWdpb24uc3dzY2k7DQogCXUzMiBtYWluX2Z1bmN0aW9uLCBzdWJfZnVuY3Rp b24sIHNjaWM7DQogCXUxNiBwY2lfc3dzY2k7DQogCXUzMiBkc2xwOw0KQEAgLTI2NCw3ICsyNjQs NyBAQCBzdGF0aWMgaW50IHN3c2NpKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHUzMiBmdW5jdGlv biwgdTMyIHBhcm0sIHUzMiAqcGFybV9vdXQpDQogCX0NCiANCiAJLyogRHJpdmVyIHNsZWVwIHRp bWVvdXQgaW4gbXMuICovDQotCWRzbHAgPSBpb3JlYWQzMigmc3dzY2ktPmRzbHApOw0KKwlkc2xw ID0gc3dzY2ktPmRzbHA7DQogCWlmICghZHNscCkgew0KIAkJLyogVGhlIHNwZWMgc2F5cyAybXMg c2hvdWxkIGJlIHRoZSBkZWZhdWx0LCBidXQgaXQncyB0b28gc21hbGwNCiAJCSAqIGZvciBzb21l IG1hY2hpbmVzLiAqLw0KQEAgLTI3Nyw3ICsyNzcsNyBAQCBzdGF0aWMgaW50IHN3c2NpKHN0cnVj dCBkcm1fZGV2aWNlICpkZXYsIHUzMiBmdW5jdGlvbiwgdTMyIHBhcm0sIHUzMiAqcGFybV9vdXQp DQogCX0NCiANCiAJLyogVGhlIHNwZWMgdGVsbHMgdXMgdG8gZG8gdGhpcywgYnV0IHdlIGFyZSB0 aGUgb25seSB1c2VyLi4uICovDQotCXNjaWMgPSBpb3JlYWQzMigmc3dzY2ktPnNjaWMpOw0KKwlz Y2ljID0gc3dzY2ktPnNjaWM7DQogCWlmIChzY2ljICYgU1dTQ0lfU0NJQ19JTkRJQ0FUT1IpIHsN CiAJCURSTV9ERUJVR19EUklWRVIoIlNXU0NJIHJlcXVlc3QgYWxyZWFkeSBpbiBwcm9ncmVzc1xu Iik7DQogCQlyZXR1cm4gLUVCVVNZOw0KQEAgLTI4NSw4ICsyODUsOCBAQCBzdGF0aWMgaW50IHN3 c2NpKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHUzMiBmdW5jdGlvbiwgdTMyIHBhcm0sIHUzMiAq cGFybV9vdXQpDQogDQogCXNjaWMgPSBmdW5jdGlvbiB8IFNXU0NJX1NDSUNfSU5ESUNBVE9SOw0K IA0KLQlpb3dyaXRlMzIocGFybSwgJnN3c2NpLT5wYXJtKTsNCi0JaW93cml0ZTMyKHNjaWMsICZz d3NjaS0+c2NpYyk7DQorCXN3c2NpLT5wYXJtID0gcGFybTsNCisJc3dzY2ktPnNjaWMgPSBzY2lj Ow0KIA0KIAkvKiBFbnN1cmUgU0NJIGV2ZW50IGlzIHNlbGVjdGVkIGFuZCBldmVudCB0cmlnZ2Vy IGlzIGNsZWFyZWQuICovDQogCXBjaV9yZWFkX2NvbmZpZ193b3JkKGRldi0+cGRldiwgUENJX1NX U0NJLCAmcGNpX3N3c2NpKTsNCkBAIC0zMDEsNyArMzAxLDcgQEAgc3RhdGljIGludCBzd3NjaShz dHJ1Y3QgZHJtX2RldmljZSAqZGV2LCB1MzIgZnVuY3Rpb24sIHUzMiBwYXJtLCB1MzIgKnBhcm1f b3V0KQ0KIAlwY2lfd3JpdGVfY29uZmlnX3dvcmQoZGV2LT5wZGV2LCBQQ0lfU1dTQ0ksIHBjaV9z d3NjaSk7DQogDQogCS8qIFBvbGwgZm9yIHRoZSByZXN1bHQuICovDQotI2RlZmluZSBDICgoKHNj aWMgPSBpb3JlYWQzMigmc3dzY2ktPnNjaWMpKSAmIFNXU0NJX1NDSUNfSU5ESUNBVE9SKSA9PSAw KQ0KKyNkZWZpbmUgQyAoKChzY2ljID0gc3dzY2ktPnNjaWMpICYgU1dTQ0lfU0NJQ19JTkRJQ0FU T1IpID09IDApDQogCWlmICh3YWl0X2ZvcihDLCBkc2xwKSkgew0KIAkJRFJNX0RFQlVHX0RSSVZF UigiU1dTQ0kgcmVxdWVzdCB0aW1lZCBvdXRcbiIpOw0KIAkJcmV0dXJuIC1FVElNRURPVVQ7DQpA QCAtMzE3LDcgKzMxNyw3IEBAIHN0YXRpYyBpbnQgc3dzY2koc3RydWN0IGRybV9kZXZpY2UgKmRl diwgdTMyIGZ1bmN0aW9uLCB1MzIgcGFybSwgdTMyICpwYXJtX291dCkNCiAJfQ0KIA0KIAlpZiAo cGFybV9vdXQpDQotCQkqcGFybV9vdXQgPSBpb3JlYWQzMigmc3dzY2ktPnBhcm0pOw0KKwkJKnBh cm1fb3V0ID0gc3dzY2ktPnBhcm07DQogDQogCXJldHVybiAwOw0KIA0KQEAgLTQwNyw3ICs0MDcs NyBAQCBzdGF0aWMgdTMyIGFzbGVfc2V0X2JhY2tsaWdodChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2 LCB1MzIgYmNscCkNCiB7DQogCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IGRl di0+ZGV2X3ByaXZhdGU7DQogCXN0cnVjdCBpbnRlbF9jb25uZWN0b3IgKmludGVsX2Nvbm5lY3Rv cjsNCi0Jc3RydWN0IG9wcmVnaW9uX2FzbGUgX19pb21lbSAqYXNsZSA9IGRldl9wcml2LT5vcHJl Z2lvbi5hc2xlOw0KKwlzdHJ1Y3Qgb3ByZWdpb25fYXNsZSAqYXNsZSA9IGRldl9wcml2LT5vcHJl Z2lvbi5hc2xlOw0KIA0KIAlEUk1fREVCVUdfRFJJVkVSKCJiY2xwID0gMHglMDh4XG4iLCBiY2xw KTsNCiANCkBAIC00MzIsNyArNDMyLDcgQEAgc3RhdGljIHUzMiBhc2xlX3NldF9iYWNrbGlnaHQo c3RydWN0IGRybV9kZXZpY2UgKmRldiwgdTMyIGJjbHApDQogCURSTV9ERUJVR19LTVMoInVwZGF0 aW5nIG9wcmVnaW9uIGJhY2tsaWdodCAlZC8yNTVcbiIsIGJjbHApOw0KIAlsaXN0X2Zvcl9lYWNo X2VudHJ5KGludGVsX2Nvbm5lY3RvciwgJmRldi0+bW9kZV9jb25maWcuY29ubmVjdG9yX2xpc3Qs IGJhc2UuaGVhZCkNCiAJCWludGVsX3BhbmVsX3NldF9iYWNrbGlnaHRfYWNwaShpbnRlbF9jb25u ZWN0b3IsIGJjbHAsIDI1NSk7DQotCWlvd3JpdGUzMihESVZfUk9VTkRfVVAoYmNscCAqIDEwMCwg MjU1KSB8IEFTTEVfQ0JMVl9WQUxJRCwgJmFzbGUtPmNibHYpOw0KKwlhc2xlLT5jYmx2ID0gRElW X1JPVU5EX1VQKGJjbHAgKiAxMDAsIDI1NSkgfCBBU0xFX0NCTFZfVkFMSUQ7DQogDQogCWRybV9t b2Rlc2V0X3VubG9jaygmZGV2LT5tb2RlX2NvbmZpZy5jb25uZWN0aW9uX211dGV4KTsNCiANCkBA IC01MTksMTQgKzUxOSwxNCBAQCBzdGF0aWMgdm9pZCBhc2xlX3dvcmsoc3RydWN0IHdvcmtfc3Ry dWN0ICp3b3JrKQ0KIAlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYgPQ0KIAkJY29u dGFpbmVyX29mKG9wcmVnaW9uLCBzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSwgb3ByZWdpb24pOw0K IAlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gZGV2X3ByaXYtPmRldjsNCi0Jc3RydWN0IG9wcmVn aW9uX2FzbGUgX19pb21lbSAqYXNsZSA9IGRldl9wcml2LT5vcHJlZ2lvbi5hc2xlOw0KKwlzdHJ1 Y3Qgb3ByZWdpb25fYXNsZSAqYXNsZSA9IGRldl9wcml2LT5vcHJlZ2lvbi5hc2xlOw0KIAl1MzIg YXNsY19zdGF0ID0gMDsNCiAJdTMyIGFzbGNfcmVxOw0KIA0KIAlpZiAoIWFzbGUpDQogCQlyZXR1 cm47DQogDQotCWFzbGNfcmVxID0gaW9yZWFkMzIoJmFzbGUtPmFzbGMpOw0KKwlhc2xjX3JlcSA9 IGFzbGUtPmFzbGM7DQogDQogCWlmICghKGFzbGNfcmVxICYgQVNMQ19SRVFfTVNLKSkgew0KIAkJ RFJNX0RFQlVHX0RSSVZFUigiTm8gcmVxdWVzdCBvbiBBU0xDIGludGVycnVwdCAweCUwOHhcbiIs DQpAQCAtNTM1LDM0ICs1MzUsMzQgQEAgc3RhdGljIHZvaWQgYXNsZV93b3JrKHN0cnVjdCB3b3Jr X3N0cnVjdCAqd29yaykNCiAJfQ0KIA0KIAlpZiAoYXNsY19yZXEgJiBBU0xDX1NFVF9BTFNfSUxM VU0pDQotCQlhc2xjX3N0YXQgfD0gYXNsZV9zZXRfYWxzX2lsbHVtKGRldiwgaW9yZWFkMzIoJmFz bGUtPmFsc2kpKTsNCisJCWFzbGNfc3RhdCB8PSBhc2xlX3NldF9hbHNfaWxsdW0oZGV2LCBhc2xl LT5hbHNpKTsNCiANCiAJaWYgKGFzbGNfcmVxICYgQVNMQ19TRVRfQkFDS0xJR0hUKQ0KLQkJYXNs Y19zdGF0IHw9IGFzbGVfc2V0X2JhY2tsaWdodChkZXYsIGlvcmVhZDMyKCZhc2xlLT5iY2xwKSk7 DQorCQlhc2xjX3N0YXQgfD0gYXNsZV9zZXRfYmFja2xpZ2h0KGRldiwgYXNsZS0+YmNscCk7DQog DQogCWlmIChhc2xjX3JlcSAmIEFTTENfU0VUX1BGSVQpDQotCQlhc2xjX3N0YXQgfD0gYXNsZV9z ZXRfcGZpdChkZXYsIGlvcmVhZDMyKCZhc2xlLT5wZml0KSk7DQorCQlhc2xjX3N0YXQgfD0gYXNs ZV9zZXRfcGZpdChkZXYsIGFzbGUtPnBmaXQpOw0KIA0KIAlpZiAoYXNsY19yZXEgJiBBU0xDX1NF VF9QV01fRlJFUSkNCi0JCWFzbGNfc3RhdCB8PSBhc2xlX3NldF9wd21fZnJlcShkZXYsIGlvcmVh ZDMyKCZhc2xlLT5wZm1iKSk7DQorCQlhc2xjX3N0YXQgfD0gYXNsZV9zZXRfcHdtX2ZyZXEoZGV2 LCBhc2xlLT5wZm1iKTsNCiANCiAJaWYgKGFzbGNfcmVxICYgQVNMQ19TVVBQT1JURURfUk9UQVRJ T05fQU5HTEVTKQ0KIAkJYXNsY19zdGF0IHw9IGFzbGVfc2V0X3N1cHBvcnRlZF9yb3RhdGlvbl9h bmdsZXMoZGV2LA0KLQkJCQkJCQlpb3JlYWQzMigmYXNsZS0+c3JvdCkpOw0KKwkJCQkJCQlhc2xl LT5zcm90KTsNCiANCiAJaWYgKGFzbGNfcmVxICYgQVNMQ19CVVRUT05fQVJSQVkpDQotCQlhc2xj X3N0YXQgfD0gYXNsZV9zZXRfYnV0dG9uX2FycmF5KGRldiwgaW9yZWFkMzIoJmFzbGUtPml1ZXIp KTsNCisJCWFzbGNfc3RhdCB8PSBhc2xlX3NldF9idXR0b25fYXJyYXkoZGV2LCBhc2xlLT5pdWVy KTsNCiANCiAJaWYgKGFzbGNfcmVxICYgQVNMQ19DT05WRVJUSUJMRV9JTkRJQ0FUT1IpDQotCQlh c2xjX3N0YXQgfD0gYXNsZV9zZXRfY29udmVydGlibGUoZGV2LCBpb3JlYWQzMigmYXNsZS0+aXVl cikpOw0KKwkJYXNsY19zdGF0IHw9IGFzbGVfc2V0X2NvbnZlcnRpYmxlKGRldiwgYXNsZS0+aXVl cik7DQogDQogCWlmIChhc2xjX3JlcSAmIEFTTENfRE9DS0lOR19JTkRJQ0FUT1IpDQotCQlhc2xj X3N0YXQgfD0gYXNsZV9zZXRfZG9ja2luZyhkZXYsIGlvcmVhZDMyKCZhc2xlLT5pdWVyKSk7DQor CQlhc2xjX3N0YXQgfD0gYXNsZV9zZXRfZG9ja2luZyhkZXYsIGFzbGUtPml1ZXIpOw0KIA0KIAlp ZiAoYXNsY19yZXEgJiBBU0xDX0lTQ1RfU1RBVEVfQ0hBTkdFKQ0KIAkJYXNsY19zdGF0IHw9IGFz bGVfaXNjdF9zdGF0ZShkZXYpOw0KIA0KLQlpb3dyaXRlMzIoYXNsY19zdGF0LCAmYXNsZS0+YXNs Yyk7DQorCWFzbGUtPmFzbGMgPSBhc2xjX3N0YXQ7DQogfQ0KIA0KIHZvaWQgaW50ZWxfb3ByZWdp b25fYXNsZV9pbnRyKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpDQpAQCAtNTg3LDggKzU4Nyw4IEBA IHN0YXRpYyBpbnQgaW50ZWxfb3ByZWdpb25fdmlkZW9fZXZlbnQoc3RydWN0IG5vdGlmaWVyX2Js b2NrICpuYiwNCiAJICAgTGludXgsIHRoZXNlIGFyZSBoYW5kbGVkIGJ5IHRoZSBkb2NrLCBidXR0 b24gYW5kIHZpZGVvIGRyaXZlcnMuDQogCSovDQogDQotCXN0cnVjdCBvcHJlZ2lvbl9hY3BpIF9f aW9tZW0gKmFjcGk7DQogCXN0cnVjdCBhY3BpX2J1c19ldmVudCAqZXZlbnQgPSBkYXRhOw0KKwlz dHJ1Y3Qgb3ByZWdpb25fYWNwaSAqYWNwaTsNCiAJaW50IHJldCA9IE5PVElGWV9PSzsNCiANCiAJ aWYgKHN0cmNtcChldmVudC0+ZGV2aWNlX2NsYXNzLCBBQ1BJX1ZJREVPX0NMQVNTKSAhPSAwKQ0K QEAgLTU5OSwxMSArNTk5LDEwIEBAIHN0YXRpYyBpbnQgaW50ZWxfb3ByZWdpb25fdmlkZW9fZXZl bnQoc3RydWN0IG5vdGlmaWVyX2Jsb2NrICpuYiwNCiANCiAJYWNwaSA9IHN5c3RlbV9vcHJlZ2lv bi0+YWNwaTsNCiANCi0JaWYgKGV2ZW50LT50eXBlID09IDB4ODAgJiYNCi0JICAgIChpb3JlYWQz MigmYWNwaS0+Y2V2dCkgJiAxKSA9PSAwKQ0KKwlpZiAoZXZlbnQtPnR5cGUgPT0gMHg4MCAmJiAo KGFjcGktPmNldnQgJiAxKSA9PSAwKSkNCiAJCXJldCA9IE5PVElGWV9CQUQ7DQogDQotCWlvd3Jp dGUzMigwLCAmYWNwaS0+Y3N0cyk7DQorCWFjcGktPmNzdHMgPSAwOw0KIA0KIAlyZXR1cm4gcmV0 Ow0KIH0NCkBAIC02MjMsMTQgKzYyMiwxNCBAQCBzdGF0aWMgdTMyIGdldF9kaWQoc3RydWN0IGlu dGVsX29wcmVnaW9uICpvcHJlZ2lvbiwgaW50IGkpDQogCXUzMiBkaWQ7DQogDQogCWlmIChpIDwg QVJSQVlfU0laRShvcHJlZ2lvbi0+YWNwaS0+ZGlkbCkpIHsNCi0JCWRpZCA9IGlvcmVhZDMyKCZv cHJlZ2lvbi0+YWNwaS0+ZGlkbFtpXSk7DQorCQlkaWQgPSBvcHJlZ2lvbi0+YWNwaS0+ZGlkbFtp XTsNCiAJfSBlbHNlIHsNCiAJCWkgLT0gQVJSQVlfU0laRShvcHJlZ2lvbi0+YWNwaS0+ZGlkbCk7 DQogDQogCQlpZiAoV0FSTl9PTihpID49IEFSUkFZX1NJWkUob3ByZWdpb24tPmFjcGktPmRpZDIp KSkNCiAJCQlyZXR1cm4gMDsNCiANCi0JCWRpZCA9IGlvcmVhZDMyKCZvcHJlZ2lvbi0+YWNwaS0+ ZGlkMltpXSk7DQorCQlkaWQgPSBvcHJlZ2lvbi0+YWNwaS0+ZGlkMltpXTsNCiAJfQ0KIA0KIAly ZXR1cm4gZGlkOw0KQEAgLTYzOSwxNCArNjM4LDE0IEBAIHN0YXRpYyB1MzIgZ2V0X2RpZChzdHJ1 Y3QgaW50ZWxfb3ByZWdpb24gKm9wcmVnaW9uLCBpbnQgaSkNCiBzdGF0aWMgdm9pZCBzZXRfZGlk KHN0cnVjdCBpbnRlbF9vcHJlZ2lvbiAqb3ByZWdpb24sIGludCBpLCB1MzIgdmFsKQ0KIHsNCiAJ aWYgKGkgPCBBUlJBWV9TSVpFKG9wcmVnaW9uLT5hY3BpLT5kaWRsKSkgew0KLQkJaW93cml0ZTMy KHZhbCwgJm9wcmVnaW9uLT5hY3BpLT5kaWRsW2ldKTsNCisJCW9wcmVnaW9uLT5hY3BpLT5kaWRs W2ldID0gdmFsOw0KIAl9IGVsc2Ugew0KIAkJaSAtPSBBUlJBWV9TSVpFKG9wcmVnaW9uLT5hY3Bp LT5kaWRsKTsNCiANCiAJCWlmIChXQVJOX09OKGkgPj0gQVJSQVlfU0laRShvcHJlZ2lvbi0+YWNw aS0+ZGlkMikpKQ0KIAkJCXJldHVybjsNCiANCi0JCWlvd3JpdGUzMih2YWwsICZvcHJlZ2lvbi0+ YWNwaS0+ZGlkMltpXSk7DQorCQlvcHJlZ2lvbi0+YWNwaS0+ZGlkMltpXSA9IHZhbDsNCiAJfQ0K IH0NCiANCkBAIC03NjgsNyArNzY3LDcgQEAgc3RhdGljIHZvaWQgaW50ZWxfc2V0dXBfY2FkbHMo c3RydWN0IGRybV9kZXZpY2UgKmRldikNCiAJICogdGhlcmUgYXJlIGxlc3MgdGhhbiBlaWdodCBk ZXZpY2VzLiAqLw0KIAlkbyB7DQogCQlkaXNwX2lkID0gZ2V0X2RpZChvcHJlZ2lvbiwgaSk7DQot CQlpb3dyaXRlMzIoZGlzcF9pZCwgJm9wcmVnaW9uLT5hY3BpLT5jYWRsW2ldKTsNCisJCW9wcmVn aW9uLT5hY3BpLT5jYWRsW2ldID0gZGlzcF9pZDsNCiAJfSB3aGlsZSAoKytpIDwgOCAmJiBkaXNw X2lkICE9IDApOw0KIH0NCiANCkBAIC03ODcsMTYgKzc4NiwxNiBAQCB2b2lkIGludGVsX29wcmVn aW9uX2luaXQoc3RydWN0IGRybV9kZXZpY2UgKmRldikNCiAJCS8qIE5vdGlmeSBCSU9TIHdlIGFy ZSByZWFkeSB0byBoYW5kbGUgQUNQSSB2aWRlbyBleHQgbm90aWZzLg0KIAkJICogUmlnaHQgbm93 LCBhbGwgdGhlIGV2ZW50cyBhcmUgaGFuZGxlZCBieSB0aGUgQUNQSSB2aWRlbyBtb2R1bGUuDQog CQkgKiBXZSBkb24ndCBhY3R1YWxseSBuZWVkIHRvIGRvIGFueXRoaW5nIHdpdGggdGhlbS4gKi8N Ci0JCWlvd3JpdGUzMigwLCAmb3ByZWdpb24tPmFjcGktPmNzdHMpOw0KLQkJaW93cml0ZTMyKDEs ICZvcHJlZ2lvbi0+YWNwaS0+ZHJkeSk7DQorCQlvcHJlZ2lvbi0+YWNwaS0+Y3N0cyA9IDA7DQor CQlvcHJlZ2lvbi0+YWNwaS0+ZHJkeSA9IDE7DQogDQogCQlzeXN0ZW1fb3ByZWdpb24gPSBvcHJl Z2lvbjsNCiAJCXJlZ2lzdGVyX2FjcGlfbm90aWZpZXIoJmludGVsX29wcmVnaW9uX25vdGlmaWVy KTsNCiAJfQ0KIA0KIAlpZiAob3ByZWdpb24tPmFzbGUpIHsNCi0JCWlvd3JpdGUzMihBU0xFX1RD SEVfQkxDX0VOLCAmb3ByZWdpb24tPmFzbGUtPnRjaGUpOw0KLQkJaW93cml0ZTMyKEFTTEVfQVJE WV9SRUFEWSwgJm9wcmVnaW9uLT5hc2xlLT5hcmR5KTsNCisJCW9wcmVnaW9uLT5hc2xlLT50Y2hl ID0gQVNMRV9UQ0hFX0JMQ19FTjsNCisJCW9wcmVnaW9uLT5hc2xlLT5hcmR5ID0gQVNMRV9BUkRZ X1JFQURZOw0KIAl9DQogfQ0KIA0KQEAgLTgwOSwxOSArODA4LDE5IEBAIHZvaWQgaW50ZWxfb3By ZWdpb25fZmluaShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQ0KIAkJcmV0dXJuOw0KIA0KIAlpZiAo b3ByZWdpb24tPmFzbGUpDQotCQlpb3dyaXRlMzIoQVNMRV9BUkRZX05PVF9SRUFEWSwgJm9wcmVn aW9uLT5hc2xlLT5hcmR5KTsNCisJCW9wcmVnaW9uLT5hc2xlLT5hcmR5ID0gQVNMRV9BUkRZX05P VF9SRUFEWTsNCiANCiAJY2FuY2VsX3dvcmtfc3luYygmZGV2X3ByaXYtPm9wcmVnaW9uLmFzbGVf d29yayk7DQogDQogCWlmIChvcHJlZ2lvbi0+YWNwaSkgew0KLQkJaW93cml0ZTMyKDAsICZvcHJl Z2lvbi0+YWNwaS0+ZHJkeSk7DQorCQlvcHJlZ2lvbi0+YWNwaS0+ZHJkeSA9IDA7DQogDQogCQlz eXN0ZW1fb3ByZWdpb24gPSBOVUxMOw0KIAkJdW5yZWdpc3Rlcl9hY3BpX25vdGlmaWVyKCZpbnRl bF9vcHJlZ2lvbl9ub3RpZmllcik7DQogCX0NCiANCiAJLyoganVzdCBjbGVhciBhbGwgb3ByZWdp b24gbWVtb3J5IHBvaW50ZXJzIG5vdyAqLw0KLQlpb3VubWFwKG9wcmVnaW9uLT5oZWFkZXIpOw0K KwltZW11bm1hcChvcHJlZ2lvbi0+aGVhZGVyKTsNCiAJb3ByZWdpb24tPmhlYWRlciA9IE5VTEw7 DQogCW9wcmVnaW9uLT5hY3BpID0gTlVMTDsNCiAJb3ByZWdpb24tPnN3c2NpID0gTlVMTDsNCkBA IC04OTQsMTAgKzg5MywxMCBAQCBpbnQgaW50ZWxfb3ByZWdpb25fc2V0dXAoc3RydWN0IGRybV9k ZXZpY2UgKmRldikNCiB7DQogCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IGRl di0+ZGV2X3ByaXZhdGU7DQogCXN0cnVjdCBpbnRlbF9vcHJlZ2lvbiAqb3ByZWdpb24gPSAmZGV2 X3ByaXYtPm9wcmVnaW9uOw0KLQl2b2lkIF9faW9tZW0gKmJhc2U7DQogCXUzMiBhc2xzLCBtYm94 ZXM7DQogCWNoYXIgYnVmW3NpemVvZihPUFJFR0lPTl9TSUdOQVRVUkUpXTsNCiAJaW50IGVyciA9 IDA7DQorCXZvaWQgKmJhc2U7DQogDQogCUJVSUxEX0JVR19PTihzaXplb2Yoc3RydWN0IG9wcmVn aW9uX2hlYWRlcikgIT0gMHgxMDApOw0KIAlCVUlMRF9CVUdfT04oc2l6ZW9mKHN0cnVjdCBvcHJl Z2lvbl9hY3BpKSAhPSAweDEwMCk7DQpAQCAtOTE1LDExICs5MTQsMTEgQEAgaW50IGludGVsX29w cmVnaW9uX3NldHVwKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpDQogCUlOSVRfV09SSygmb3ByZWdp b24tPmFzbGVfd29yaywgYXNsZV93b3JrKTsNCiAjZW5kaWYNCiANCi0JYmFzZSA9IGFjcGlfb3Nf aW9yZW1hcChhc2xzLCBPUFJFR0lPTl9TSVpFKTsNCisJYmFzZSA9IG1lbXJlbWFwKGFzbHMsIE9Q UkVHSU9OX1NJWkUsIE1FTVJFTUFQX1dCKTsNCiAJaWYgKCFiYXNlKQ0KIAkJcmV0dXJuIC1FTk9N RU07DQogDQotCW1lbWNweV9mcm9taW8oYnVmLCBiYXNlLCBzaXplb2YoYnVmKSk7DQorCW1lbWNw eShidWYsIGJhc2UsIHNpemVvZihidWYpKTsNCiANCiAJaWYgKG1lbWNtcChidWYsIE9QUkVHSU9O X1NJR05BVFVSRSwgMTYpKSB7DQogCQlEUk1fREVCVUdfRFJJVkVSKCJvcHJlZ2lvbiBzaWduYXR1 cmUgbWlzbWF0Y2hcbiIpOw0KQEAgLTkzMSw3ICs5MzAsNyBAQCBpbnQgaW50ZWxfb3ByZWdpb25f c2V0dXAoc3RydWN0IGRybV9kZXZpY2UgKmRldikNCiANCiAJb3ByZWdpb24tPmxpZF9zdGF0ZSA9 IGJhc2UgKyBBQ1BJX0NMSUQ7DQogDQotCW1ib3hlcyA9IGlvcmVhZDMyKCZvcHJlZ2lvbi0+aGVh ZGVyLT5tYm94ZXMpOw0KKwltYm94ZXMgPSBvcHJlZ2lvbi0+aGVhZGVyLT5tYm94ZXM7DQogCWlm IChtYm94ZXMgJiBNQk9YX0FDUEkpIHsNCiAJCURSTV9ERUJVR19EUklWRVIoIlB1YmxpYyBBQ1BJ IG1ldGhvZHMgc3VwcG9ydGVkXG4iKTsNCiAJCW9wcmVnaW9uLT5hY3BpID0gYmFzZSArIE9QUkVH SU9OX0FDUElfT0ZGU0VUOw0KQEAgLTk0NiwxMiArOTQ1LDEyIEBAIGludCBpbnRlbF9vcHJlZ2lv bl9zZXR1cChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQ0KIAkJRFJNX0RFQlVHX0RSSVZFUigiQVNM RSBzdXBwb3J0ZWRcbiIpOw0KIAkJb3ByZWdpb24tPmFzbGUgPSBiYXNlICsgT1BSRUdJT05fQVNM RV9PRkZTRVQ7DQogDQotCQlpb3dyaXRlMzIoQVNMRV9BUkRZX05PVF9SRUFEWSwgJm9wcmVnaW9u LT5hc2xlLT5hcmR5KTsNCisJCW9wcmVnaW9uLT5hc2xlLT5hcmR5ID0gQVNMRV9BUkRZX05PVF9S RUFEWTsNCiAJfQ0KIA0KIAlyZXR1cm4gMDsNCiANCiBlcnJfb3V0Og0KLQlpb3VubWFwKGJhc2Up Ow0KKwltZW11bm1hcChiYXNlKTsNCiAJcmV0dXJuIGVycjsNCiB9DQpkaWZmIC0tZ2l0IGEvZHJp dmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcGFuZWwuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2lu dGVsX3BhbmVsLmMNCmluZGV4IGUyYWIzZjZlZDAyMi4uZWZlNTQyNGIyOTBjIDEwMDY0NA0KLS0t IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcGFuZWwuYw0KKysrIGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvaW50ZWxfcGFuZWwuYw0KQEAgLTM4Nyw3ICszODcsNyBAQCBpbnRlbF9wYW5lbF9k ZXRlY3Qoc3RydWN0IGRybV9kZXZpY2UgKmRldikNCiANCiAJLyogQXNzdW1lIHRoYXQgdGhlIEJJ T1MgZG9lcyBub3QgbGllIHRocm91Z2ggdGhlIE9wUmVnaW9uLi4uICovDQogCWlmICghaTkxNS5w YW5lbF9pZ25vcmVfbGlkICYmIGRldl9wcml2LT5vcHJlZ2lvbi5saWRfc3RhdGUpIHsNCi0JCXJl dHVybiBpb3JlYWQzMihkZXZfcHJpdi0+b3ByZWdpb24ubGlkX3N0YXRlKSAmIDB4MSA/DQorCQly ZXR1cm4gKmRldl9wcml2LT5vcHJlZ2lvbi5saWRfc3RhdGUgJiAweDEgPw0KIAkJCWNvbm5lY3Rv cl9zdGF0dXNfY29ubmVjdGVkIDoNCiAJCQljb25uZWN0b3Jfc3RhdHVzX2Rpc2Nvbm5lY3RlZDsN CiAJfQ0KDQo= From mboxrd@z Thu Jan 1 00:00:00 1970 From: dan.j.williams@intel.com (Williams, Dan J) Date: Mon, 12 Oct 2015 21:12:57 +0000 Subject: [Intel-gfx] [PATCH 09/20] i915: switch from acpi_os_ioremap to memremap In-Reply-To: <20151012070102.GV26718@phenom.ffwll.local> References: <20151009221537.32203.5867.stgit@dwillia2-desk3.jf.intel.com> <20151009221625.32203.74117.stgit@dwillia2-desk3.jf.intel.com> <20151012070102.GV26718@phenom.ffwll.local> Message-ID: <1444684376.9780.5.camel@intel.com> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org On Mon, 2015-10-12 at 09:01 +0200, Daniel Vetter wrote: > On Fri, Oct 09, 2015 at 06:16:25PM -0400, Dan Williams wrote: > > 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 at lists.freedesktop.org > > Cc: David Airlie > > Cc: dri-devel at lists.freedesktop.org > > Signed-off-by: Dan Williams > > Assuming you've run sparse over this to make sure you've caught them all, > and with the nit below addressed this is > > Reviewed-by: Daniel Vetter Indeed, re-running sparse again found a few conversions of ioread* I missed as well as moving the force casting out of validate_vbt() to find_vbt(). > Feel free to pull v2 into whatever tree you think it's suitable for (but > you can also resend and I'll pick it up). Please pick up v2 below. > > > 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 ? > > () are redundant now here. Yup, fixed. 8<---- Subject: i915: switch from acpi_os_ioremap to memremap From: Dan Williams 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 at lists.freedesktop.org Cc: David Airlie Cc: dri-devel at 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 | 25 +++++----- drivers/gpu/drm/i915/intel_opregion.c | 83 ++++++++++++++++----------------- drivers/gpu/drm/i915/intel_panel.c | 2 - 5 files changed, 62 insertions(+), 62 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..f6762a5faee8 100644 --- a/drivers/gpu/drm/i915/intel_bios.c +++ b/drivers/gpu/drm/i915/intel_bios.c @@ -1231,20 +1231,13 @@ static const struct dmi_system_id intel_no_opregion_vbt[] = { { } }; -static const struct bdb_header *validate_vbt(const void __iomem *_base, +static const struct bdb_header *validate_vbt(const void *base, size_t size, - const void __iomem *_vbt, + const void *_vbt, const char *source) { - /* - * 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. - */ - const void *base = (const void *) _base; - size_t offset = _vbt - _base; - const struct vbt_header *vbt = base + offset; + size_t offset = _vbt - base; + const struct vbt_header *vbt = _vbt; const struct bdb_header *bdb; if (offset + sizeof(struct vbt_header) > size) { @@ -1282,7 +1275,15 @@ static const struct bdb_header *find_vbt(void __iomem *bios, size_t size) /* Scour memory looking for the VBT signature. */ for (i = 0; i + 4 < size; i++) { if (ioread32(bios + i) == *((const u32 *) "$VBT")) { - bdb = validate_vbt(bios, size, bios + i, "PCI ROM"); + /* + * This is the one place where we explicitly discard the + * address space (__iomem) of the BIOS/VBT. From now on + * everything is based on 'base', and treated as regular + * memory. + */ + void *_bios = (void __force *) bios; + + bdb = validate_vbt(_bios, size, _bios + i, "PCI ROM"); break; } } diff --git a/drivers/gpu/drm/i915/intel_opregion.c b/drivers/gpu/drm/i915/intel_opregion.c index cb1c65739425..41d44a5ef626 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; } @@ -623,14 +622,14 @@ static u32 get_did(struct intel_opregion *opregion, int i) u32 did; if (i < ARRAY_SIZE(opregion->acpi->didl)) { - did = ioread32(&opregion->acpi->didl[i]); + did = opregion->acpi->didl[i]; } else { i -= ARRAY_SIZE(opregion->acpi->didl); if (WARN_ON(i >= ARRAY_SIZE(opregion->acpi->did2))) return 0; - did = ioread32(&opregion->acpi->did2[i]); + did = opregion->acpi->did2[i]; } return did; @@ -639,14 +638,14 @@ static u32 get_did(struct intel_opregion *opregion, int i) static void set_did(struct intel_opregion *opregion, int i, u32 val) { if (i < ARRAY_SIZE(opregion->acpi->didl)) { - iowrite32(val, &opregion->acpi->didl[i]); + opregion->acpi->didl[i] = val; } else { i -= ARRAY_SIZE(opregion->acpi->didl); if (WARN_ON(i >= ARRAY_SIZE(opregion->acpi->did2))) return; - iowrite32(val, &opregion->acpi->did2[i]); + opregion->acpi->did2[i] = val; } } @@ -768,7 +767,7 @@ static void intel_setup_cadls(struct drm_device *dev) * there are less than eight devices. */ do { disp_id = get_did(opregion, i); - iowrite32(disp_id, &opregion->acpi->cadl[i]); + opregion->acpi->cadl[i] = disp_id; } while (++i < 8 && disp_id != 0); } @@ -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..efe5424b290c 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; } From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752487AbbJLVNY (ORCPT ); Mon, 12 Oct 2015 17:13:24 -0400 Received: from mga03.intel.com ([134.134.136.65]:27545 "EHLO mga03.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752330AbbJLVNS (ORCPT ); Mon, 12 Oct 2015 17:13:18 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.17,675,1437462000"; d="scan'208";a="825288773" From: "Williams, Dan J" To: "daniel@ffwll.ch" CC: "dri-devel@lists.freedesktop.org" , "linux-kernel@vger.kernel.org" , "linux-arch@vger.kernel.org" , "linux-arm-kernel@lists.infradead.org" , "intel-gfx@lists.freedesktop.org" , "Vetter, Daniel" , "airlied@linux.ie" Subject: Re: [Intel-gfx] [PATCH 09/20] i915: switch from acpi_os_ioremap to memremap Thread-Topic: [Intel-gfx] [PATCH 09/20] i915: switch from acpi_os_ioremap to memremap Thread-Index: AQHRAuD0bBDnYDJntEyKgo28V+OZkZ5n5xkAgADuBQA= Date: Mon, 12 Oct 2015 21:12:57 +0000 Message-ID: <1444684376.9780.5.camel@intel.com> References: <20151009221537.32203.5867.stgit@dwillia2-desk3.jf.intel.com> <20151009221625.32203.74117.stgit@dwillia2-desk3.jf.intel.com> <20151012070102.GV26718@phenom.ffwll.local> In-Reply-To: <20151012070102.GV26718@phenom.ffwll.local> Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-originating-ip: [10.22.254.139] Content-Type: text/plain; charset="utf-8" Content-ID: MIME-Version: 1.0 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: 8bit X-MIME-Autoconverted: from base64 to 8bit by mail.home.local id t9CLDVIQ021482 On Mon, 2015-10-12 at 09:01 +0200, Daniel Vetter wrote: > On Fri, Oct 09, 2015 at 06:16:25PM -0400, Dan Williams wrote: > > 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 > > Assuming you've run sparse over this to make sure you've caught them all, > and with the nit below addressed this is > > Reviewed-by: Daniel Vetter Indeed, re-running sparse again found a few conversions of ioread* I missed as well as moving the force casting out of validate_vbt() to find_vbt(). > Feel free to pull v2 into whatever tree you think it's suitable for (but > you can also resend and I'll pick it up). Please pick up v2 below. > > > 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 ? > > () are redundant now here. Yup, fixed. 8<---- Subject: i915: switch from acpi_os_ioremap to memremap From: Dan Williams 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 | 25 +++++----- drivers/gpu/drm/i915/intel_opregion.c | 83 ++++++++++++++++----------------- drivers/gpu/drm/i915/intel_panel.c | 2 - 5 files changed, 62 insertions(+), 62 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..f6762a5faee8 100644 --- a/drivers/gpu/drm/i915/intel_bios.c +++ b/drivers/gpu/drm/i915/intel_bios.c @@ -1231,20 +1231,13 @@ static const struct dmi_system_id intel_no_opregion_vbt[] = { { } }; -static const struct bdb_header *validate_vbt(const void __iomem *_base, +static const struct bdb_header *validate_vbt(const void *base, size_t size, - const void __iomem *_vbt, + const void *_vbt, const char *source) { - /* - * 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. - */ - const void *base = (const void *) _base; - size_t offset = _vbt - _base; - const struct vbt_header *vbt = base + offset; + size_t offset = _vbt - base; + const struct vbt_header *vbt = _vbt; const struct bdb_header *bdb; if (offset + sizeof(struct vbt_header) > size) { @@ -1282,7 +1275,15 @@ static const struct bdb_header *find_vbt(void __iomem *bios, size_t size) /* Scour memory looking for the VBT signature. */ for (i = 0; i + 4 < size; i++) { if (ioread32(bios + i) == *((const u32 *) "$VBT")) { - bdb = validate_vbt(bios, size, bios + i, "PCI ROM"); + /* + * This is the one place where we explicitly discard the + * address space (__iomem) of the BIOS/VBT. From now on + * everything is based on 'base', and treated as regular + * memory. + */ + void *_bios = (void __force *) bios; + + bdb = validate_vbt(_bios, size, _bios + i, "PCI ROM"); break; } } diff --git a/drivers/gpu/drm/i915/intel_opregion.c b/drivers/gpu/drm/i915/intel_opregion.c index cb1c65739425..41d44a5ef626 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; } @@ -623,14 +622,14 @@ static u32 get_did(struct intel_opregion *opregion, int i) u32 did; if (i < ARRAY_SIZE(opregion->acpi->didl)) { - did = ioread32(&opregion->acpi->didl[i]); + did = opregion->acpi->didl[i]; } else { i -= ARRAY_SIZE(opregion->acpi->didl); if (WARN_ON(i >= ARRAY_SIZE(opregion->acpi->did2))) return 0; - did = ioread32(&opregion->acpi->did2[i]); + did = opregion->acpi->did2[i]; } return did; @@ -639,14 +638,14 @@ static u32 get_did(struct intel_opregion *opregion, int i) static void set_did(struct intel_opregion *opregion, int i, u32 val) { if (i < ARRAY_SIZE(opregion->acpi->didl)) { - iowrite32(val, &opregion->acpi->didl[i]); + opregion->acpi->didl[i] = val; } else { i -= ARRAY_SIZE(opregion->acpi->didl); if (WARN_ON(i >= ARRAY_SIZE(opregion->acpi->did2))) return; - iowrite32(val, &opregion->acpi->did2[i]); + opregion->acpi->did2[i] = val; } } @@ -768,7 +767,7 @@ static void intel_setup_cadls(struct drm_device *dev) * there are less than eight devices. */ do { disp_id = get_did(opregion, i); - iowrite32(disp_id, &opregion->acpi->cadl[i]); + opregion->acpi->cadl[i] = disp_id; } while (++i < 8 && disp_id != 0); } @@ -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..efe5424b290c 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; } {.n++%ݶw{.n+{G{ayʇڙ,jfhz_(階ݢj"mG?&~iOzv^m ?I