From mboxrd@z Thu Jan 1 00:00:00 1970 From: =?UTF-8?B?Q2hyaXN0aWFuIEvDtm5pZw==?= Subject: Re: [PATCH 1/2] drm/radeon: refactor set_page chipset interface v2 Date: Sat, 15 Sep 2012 15:22:44 +0200 Message-ID: <50548124.4020104@vodafone.de> References: <1347644982-17386-1-git-send-email-Dmitrii.Cherkasov@amd.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8"; Format="flowed" Content-Transfer-Encoding: base64 Return-path: Received: from outgoing.email.vodafone.de (outgoing.email.vodafone.de [139.7.28.128]) by gabe.freedesktop.org (Postfix) with ESMTP id 094B99E807 for ; Sat, 15 Sep 2012 06:22:52 -0700 (PDT) In-Reply-To: <1347644982-17386-1-git-send-email-Dmitrii.Cherkasov@amd.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: dri-devel-bounces+sf-dri-devel=m.gmane.org@lists.freedesktop.org Errors-To: dri-devel-bounces+sf-dri-devel=m.gmane.org@lists.freedesktop.org To: Dmitry Cherkasov Cc: Alex Deucher , Dmitry Cherkassov , linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org TG9va3MgZ29vZCBpbiBnZW5lcmFsLCBzb21lIG1pbm9yIGNvbW1lbnRzIGJlbG93OgoKT24gMTQu MDkuMjAxMiAxOTo0OSwgRG1pdHJ5IENoZXJrYXNvdiB3cm90ZToKPiBGcm9tOiBDaHJpc3RpYW4g S8O2bmlnIDxkZWF0aHNpbXBsZUB2b2RhZm9uZS5kZT4KPgo+IENsZWFudXAgdGhlIGludGVyZmFj ZSBpbiBwcmVwYXJhdGlvbiBmb3IgaGllcmFyY2hpY2FsIHBhZ2UgdGFibGVzLgo+IHYyOiAqIGFk ZCBpbmNyIHBhcmFtZXRlciB0byBzZXRfcGFnZSBmb3Igc2ltcGxlIHNjYXR0ZXJlZCBQVHMgdXB0 YXRlcwo+ICAgICAgKiBhZGRlZCBQREUtc3BlY2lmaWMgZmxhZ3MgdG8gcjYwMF9mbGFncyBhbmQg cmFkZW9uX2RybS5oCj4gICAgICAqIHJlbW92ZWQgc3VwZXJmbG91cyB2YWx1ZSBtYXNraW5nIHdp dGggMHhmZmZmZmZmZgo+Cj4gU2lnbmVkLW9mZi1ieTogQ2hyaXN0aWFuIEvDtm5pZyA8ZGVhdGhz aW1wbGVAdm9kYWZvbmUuZGU+Cj4gU2lnbmVkLW9mZi1ieTogRG1pdHJ5IENoZXJrYXNzb3YgPERt aXRyaWkuQ2hlcmthc292QGFtZC5jb20+Cj4gLS0tCj4gICBkcml2ZXJzL2dwdS9kcm0vcmFkZW9u L25pLmMgICAgICAgICAgfCAgIDQ3ICsrKysrKysrKysrKysrKysrKysrLS0tLS0tLS0tLS0KPiAg IGRyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uLmggICAgICB8ICAgMTQgKysrKystLS0tLQo+ ICAgZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fYXNpYy5oIHwgICAgNiArKy0tCj4gICBk cml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9nYXJ0LmMgfCAgIDUxICsrKysrKysrKysrKyst LS0tLS0tLS0tLS0tLS0tLS0tLS0KPiAgIGluY2x1ZGUvZHJtL3JhZGVvbl9kcm0uaCAgICAgICAg ICAgICB8ICAgIDEgKwo+ICAgNSBmaWxlcyBjaGFuZ2VkLCA2MiBpbnNlcnRpb25zKCspLCA1NyBk ZWxldGlvbnMoLSkKPgo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL25pLmMg Yi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL25pLmMKPiBpbmRleCBiMjM4MjE2Li4wMzU1YzhkIDEw MDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vbmkuYwo+ICsrKyBiL2RyaXZlcnMv Z3B1L2RybS9yYWRlb24vbmkuYwo+IEBAIC0xNDk3LDYgKzE0OTcsNyBAQCB2b2lkIGNheW1hbl92 bV9maW5pKHN0cnVjdCByYWRlb25fZGV2aWNlICpyZGV2KQo+ICAgewo+ICAgfQo+ICAgCj4gKyNk ZWZpbmUgUjYwMF9QREVfVkFMSUQgICAgICgxIDw8IDApCj4gICAjZGVmaW5lIFI2MDBfUFRFX1ZB TElEICAgICAoMSA8PCAwKQpXaHkgdGhlIGRpc3RpbmN0aW9uIGJldHdlZW4gUjYwMF9QREVfVkFM SUQgYW5kIFI2MDBfUFRFX1ZBTElEPwpKdXN0IHJlbmFtaW5nIHRoZSBSNjAwX1BURV8qIGZsYWdz IHNvdW5kIG1vcmUgc2FuZSB0byBtZS4KCj4gICAjZGVmaW5lIFI2MDBfUFRFX1NZU1RFTSAgICAo MSA8PCAxKQo+ICAgI2RlZmluZSBSNjAwX1BURV9TTk9PUEVEICAgKDEgPDwgMikKPiBAQCAtMTUw Nyw2ICsxNTA4LDcgQEAgdWludDMyX3QgY2F5bWFuX3ZtX3BhZ2VfZmxhZ3Moc3RydWN0IHJhZGVv bl9kZXZpY2UgKnJkZXYsIHVpbnQzMl90IGZsYWdzKQo+ICAgewo+ICAgCXVpbnQzMl90IHI2MDBf ZmxhZ3MgPSAwOwo+ICAgCj4gKwlyNjAwX2ZsYWdzIHw9IChmbGFncyAmIFJBREVPTl9WTV9QREVf VkFMSUQpID8gUjYwMF9QREVfVkFMSUQgOiAwOwo+ICAgCXI2MDBfZmxhZ3MgfD0gKGZsYWdzICYg UkFERU9OX1ZNX1BBR0VfVkFMSUQpID8gUjYwMF9QVEVfVkFMSUQgOiAwOwo+ICAgCXI2MDBfZmxh Z3MgfD0gKGZsYWdzICYgUkFERU9OX1ZNX1BBR0VfUkVBREFCTEUpID8gUjYwMF9QVEVfUkVBREFC TEUgOiAwOwo+ICAgCXI2MDBfZmxhZ3MgfD0gKGZsYWdzICYgUkFERU9OX1ZNX1BBR0VfV1JJVEVB QkxFKSA/IFI2MDBfUFRFX1dSSVRFQUJMRSA6IDA7Cj4gQEAgLTE1MjEsMzAgKzE1MjMsNDMgQEAg dWludDMyX3QgY2F5bWFuX3ZtX3BhZ2VfZmxhZ3Moc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYs IHVpbnQzMl90IGZsYWdzKQo+ICAgICogY2F5bWFuX3ZtX3NldF9wYWdlIC0gdXBkYXRlIHRoZSBw YWdlIHRhYmxlcyB1c2luZyB0aGUgQ1AKPiAgICAqCj4gICAgKiBAcmRldjogcmFkZW9uX2Rldmlj ZSBwb2ludGVyCj4gKyAqIEBwZTogYWRkciBvZiB0aGUgcGFnZSBlbnRyeQo+ICsgKiBAYWRkcjog ZHN0IGFkZHIgdG8gd3JpdGUgaW50byBwZQo+ICsgKiBAY291bnQ6IG51bWJlciBvZiBwYWdlIGVu dHJpZXMgdG8gdXBkYXRlCj4gKyAqIEBmbGFnczogYWNjZXNzIGZsYWdzCj4gICAgKgo+ICAgICog VXBkYXRlIHRoZSBwYWdlIHRhYmxlcyB1c2luZyB0aGUgQ1AgKGNheW1hbi1zaSkuCj4gICAgKi8K PiAtdm9pZCBjYXltYW5fdm1fc2V0X3BhZ2Uoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYsIHN0 cnVjdCByYWRlb25fdm0gKnZtLAo+IC0JCQl1bnNpZ25lZCBwZm4sIHN0cnVjdCB0dG1fbWVtX3Jl ZyAqbWVtLAo+IC0JCQl1bnNpZ25lZCBucGFnZXMsIHVpbnQzMl90IGZsYWdzKQo+ICt2b2lkIGNh eW1hbl92bV9zZXRfcGFnZShzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldiwgdWludDY0X3QgcGUs Cj4gKwkJCXVpbnQ2NF90IGFkZHIsIHVuc2lnbmVkIGNvdW50LAo+ICsJCQl1aW50MzJfdCBmbGFn cywgdWludDMyX3QgaW5jcikKPiAgIHsKPiAgIAlzdHJ1Y3QgcmFkZW9uX3JpbmcgKnJpbmcgPSAm cmRldi0+cmluZ1tyZGV2LT5hc2ljLT52bS5wdF9yaW5nX2luZGV4XTsKPiAtCXVpbnQ2NF90IGFk ZHIsIHB0ID0gdm0tPnB0X2dwdV9hZGRyICsgcGZuICogODsKPiArCXVpbnQzMl90IHI2MDBfZmxh Z3MgPSBjYXltYW5fdm1fcGFnZV9mbGFncyhyZGV2LCBmbGFncyk7Cj4gICAJaW50IGk7Cj4gICAK PiAtCWFkZHIgPSBmbGFncyA9IGNheW1hbl92bV9wYWdlX2ZsYWdzKHJkZXYsIGZsYWdzKTsKPiAt Cj4gLQlyYWRlb25fcmluZ193cml0ZShyaW5nLCBQQUNLRVQzKFBBQ0tFVDNfTUVfV1JJVEUsIDEg KyBucGFnZXMgKiAyKSk7Cj4gLQlyYWRlb25fcmluZ193cml0ZShyaW5nLCBwdCAmIDB4ZmZmZmZm ZmYpOwo+IC0JcmFkZW9uX3Jpbmdfd3JpdGUocmluZywgKHB0ID4+IDMyKSAmIDB4ZmYpOwo+IC0J Zm9yIChpID0gMDsgaSA8IG5wYWdlczsgKytpKSB7Cj4gLQkJaWYgKG1lbSkgewo+IC0JCQlhZGRy ID0gcmFkZW9uX3ZtX2dldF9hZGRyKHJkZXYsIG1lbSwgaSk7Cj4gLQkJCWFkZHIgPSBhZGRyICYg MHhGRkZGRkZGRkZGRkZGMDAwVUxMOwo+IC0JCQlhZGRyIHw9IGZsYWdzOwo+ICsJcmFkZW9uX3Jp bmdfd3JpdGUocmluZywgUEFDS0VUMyhQQUNLRVQzX01FX1dSSVRFLCAxICsgY291bnQgKiAyKSk7 Cj4gKwlyYWRlb25fcmluZ193cml0ZShyaW5nLCBwZSAmIDB4ZmZmZmZmZmYpOwo+ICsJcmFkZW9u X3Jpbmdfd3JpdGUocmluZywgKHBlID4+IDMyKSAmIDB4ZmYpOwo+ICsJZm9yIChpID0gMDsgaSA8 IGNvdW50OyArK2kpIHsKPiArCQl1aW50NjRfdCB2YWx1ZSA9IDA7Cj4gKwkJaWYgKGZsYWdzICYg UkFERU9OX1ZNX1BBR0VfU1lTVEVNKSB7Cj4gKwkJCXZhbHVlID0gcmFkZW9uX3ZtX21hcF9nYXJ0 KHJkZXYsIGFkZHIpOwo+ICsJCQl2YWx1ZSAmPSAweEZGRkZGRkZGRkZGRkYwMDBVTEw7Cj4gKwkJ CWFkZHIgKz0gUkFERU9OX0dQVV9QQUdFX1NJWkU7Cj4gKwo+ICsJCX0gZWxzZSBpZiAoZmxhZ3Mg JiBSQURFT05fVk1fUEFHRV9WQUxJRCkgewo+ICsJCQl2YWx1ZSA9IGFkZHI7Cj4gKwkJCWFkZHIg Kz0gUkFERU9OX0dQVV9QQUdFX1NJWkU7Cj4gKwo+ICsJCX0gZWxzZSBpZiAoZmxhZ3MgJiBSQURF T05fVk1fUERFX1ZBTElEKSB7Cj4gKwkJCXZhbHVlID0gYWRkcjsKPiArCQkJYWRkciArPSBpbmNy Owo+ICAgCQl9ClNhbWUgaGVyZSwgd2h5IHRoZSBkaXN0aW5jdGlvbiBiZXR3ZWVuIFJBREVPTl9W TV9QREVfVkFMSUQgYW5kIApSQURFT05fVk1fUEFHRV9WQUxJRD8KQWRkaXRpb25hbCB0byB0aGF0 IEkgd291bGQgYWxzbyBwcmVmZXIgdG8gYWx3YXlzIHVzZSAiaW5jciIgZm9yIGJvdGggdGhlIApS QURFT05fVk1fUEFHRV9TWVNURU1hbmQgdGhlIFJBREVPTl9WTV9QQUdFX1ZBTElEIGNhc2UuCgo+ IC0JCXJhZGVvbl9yaW5nX3dyaXRlKHJpbmcsIGFkZHIgJiAweGZmZmZmZmZmKTsKPiAtCQlyYWRl b25fcmluZ193cml0ZShyaW5nLCAoYWRkciA+PiAzMikgJiAweGZmZmZmZmZmKTsKPiArCj4gKwkJ dmFsdWUgfD0gcjYwMF9mbGFnczsKPiArCQlyYWRlb25fcmluZ193cml0ZShyaW5nLCB2YWx1ZSk7 Cj4gKwkJcmFkZW9uX3Jpbmdfd3JpdGUocmluZywgKHZhbHVlID4+IDMyKSk7Cj4gICAJfQo+ICAg fQo+ICAgCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uLmggYi9k cml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbi5oCj4gaW5kZXggNGQ2N2YwZi4uZjAyZWE4ZSAx MDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbi5oCj4gKysrIGIvZHJp dmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb24uaAo+IEBAIC0xMTQxLDkgKzExNDEsOSBAQCBzdHJ1 Y3QgcmFkZW9uX2FzaWMgewo+ICAgCQl2b2lkICgqZmluaSkoc3RydWN0IHJhZGVvbl9kZXZpY2Ug KnJkZXYpOwo+ICAgCj4gICAJCXUzMiBwdF9yaW5nX2luZGV4Owo+IC0JCXZvaWQgKCpzZXRfcGFn ZSkoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYsIHN0cnVjdCByYWRlb25fdm0gKnZtLAo+IC0J CQkJIHVuc2lnbmVkIHBmbiwgc3RydWN0IHR0bV9tZW1fcmVnICptZW0sCj4gLQkJCQkgdW5zaWdu ZWQgbnBhZ2VzLCB1aW50MzJfdCBmbGFncyk7Cj4gKwkJdm9pZCAoKnNldF9wYWdlKQo+ICsJCShz dHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldiwgdWludDY0X3QgcGUsCj4gKwkJIHVpbnQ2NF90IGFk ZHIsIHVuc2lnbmVkIGNvdW50LCB1aW50MzJfdCBmbGFncywgdWludDMyX3QgaW5jcik7ClBsZWFz ZSBkb24ndCBicmVhayB0aGUgY29kaW5nIHN0eWxlIGhlcmUuIE9yIHdhcyBpdCBtZSB3aG8gZGlk IHRoYXQ/IApBbnl3YXkga2VlcCB0aGUgaW5kZW50aW9uIGFzIGl0IHdhcyBiZWZvcmUuCgpBZGRp dGlvbmFsIHRvIHRoYXQgYXQgbGVhc3QgSSB3b3VsZCBwdXQgdGhlIGFyZ3VtZW50cyBpbiB0aGF0 IG9yZGVyOiBwZSwgCmFkZHIgdGhlbiBjb3VudCwgaW5jciBhbmQgbGFzdCBmbGFncy4KCj4gICAJ fSB2bTsKPiAgIAkvKiByaW5nIHNwZWNpZmljIGNhbGxiYWNrcyAqLwo+ICAgCXN0cnVjdCB7Cj4g QEAgLTE3NTUsNyArMTc1NSw5IEBAIHZvaWQgcmFkZW9uX3Jpbmdfd3JpdGUoc3RydWN0IHJhZGVv bl9yaW5nICpyaW5nLCB1aW50MzJfdCB2KTsKPiAgICNkZWZpbmUgcmFkZW9uX2dhcnRfc2V0X3Bh Z2UocmRldiwgaSwgcCkgKHJkZXYpLT5hc2ljLT5nYXJ0LnNldF9wYWdlKChyZGV2KSwgKGkpLCAo cCkpCj4gICAjZGVmaW5lIHJhZGVvbl9hc2ljX3ZtX2luaXQocmRldikgKHJkZXYpLT5hc2ljLT52 bS5pbml0KChyZGV2KSkKPiAgICNkZWZpbmUgcmFkZW9uX2FzaWNfdm1fZmluaShyZGV2KSAocmRl diktPmFzaWMtPnZtLmZpbmkoKHJkZXYpKQo+IC0jZGVmaW5lIHJhZGVvbl9hc2ljX3ZtX3NldF9w YWdlKHJkZXYsIHYsIHBmbiwgbWVtLCBucGFnZXMsIGZsYWdzKSAocmRldiktPmFzaWMtPnZtLnNl dF9wYWdlKChyZGV2KSwgKHYpLCAocGZuKSwgKG1lbSksIChucGFnZXMpLCAoZmxhZ3MpKQo+ICsj ZGVmaW5lIHJhZGVvbl9hc2ljX3ZtX3NldF9wYWdlKHJkZXYsIHBlLCBhZGRyLCBjb3VudCwgZmxh Z3MsIGluY3IpIFwKPiArCSgocmRldiktPmFzaWMtPnZtLnNldF9wYWdlKChyZGV2KSwgKHBlKSwg KGFkZHIpLCBcCj4gKwkJCQkgKGNvdW50KSwgKGZsYWdzKSwgKGluY3IpKSkKU2FtZSBoZXJlLCBu byBpZGVhIHdoeSB3ZSBoYXZlIHRob3NlIG1hY3JvcyBhbGwgb24gb25lIGxpbmUuIEJ1dCBwbGVh c2UgCm1ha2UgaXQgbG9vayBsaWtlIHRoZSByZXN0IG9mIHRoZSBjb2RlLgoKPiAgICNkZWZpbmUg cmFkZW9uX3Jpbmdfc3RhcnQocmRldiwgciwgY3ApIChyZGV2KS0+YXNpYy0+cmluZ1socildLnJp bmdfc3RhcnQoKHJkZXYpLCAoY3ApKQo+ICAgI2RlZmluZSByYWRlb25fcmluZ190ZXN0KHJkZXYs IHIsIGNwKSAocmRldiktPmFzaWMtPnJpbmdbKHIpXS5yaW5nX3Rlc3QoKHJkZXYpLCAoY3ApKQo+ ICAgI2RlZmluZSByYWRlb25faWJfdGVzdChyZGV2LCByLCBjcCkgKHJkZXYpLT5hc2ljLT5yaW5n WyhyKV0uaWJfdGVzdCgocmRldiksIChjcCkpCj4gQEAgLTE4NDAsOSArMTg0Miw3IEBAIHN0cnVj dCByYWRlb25fZmVuY2UgKnJhZGVvbl92bV9ncmFiX2lkKHN0cnVjdCByYWRlb25fZGV2aWNlICpy ZGV2LAo+ICAgdm9pZCByYWRlb25fdm1fZmVuY2Uoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYs Cj4gICAJCSAgICAgc3RydWN0IHJhZGVvbl92bSAqdm0sCj4gICAJCSAgICAgc3RydWN0IHJhZGVv bl9mZW5jZSAqZmVuY2UpOwo+IC11NjQgcmFkZW9uX3ZtX2dldF9hZGRyKHN0cnVjdCByYWRlb25f ZGV2aWNlICpyZGV2LAo+IC0gICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCB0dG1fbWVtX3Jl ZyAqbWVtLAo+IC0gICAgICAgICAgICAgICAgICAgICAgIHVuc2lnbmVkIHBmbik7Cj4gK3VpbnQ2 NF90IHJhZGVvbl92bV9tYXBfZ2FydChzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldiwgdWludDY0 X3QgYWRkcik7Cj4gICBpbnQgcmFkZW9uX3ZtX2JvX3VwZGF0ZV9wdGUoc3RydWN0IHJhZGVvbl9k ZXZpY2UgKnJkZXYsCj4gICAJCQkgICAgc3RydWN0IHJhZGVvbl92bSAqdm0sCj4gICAJCQkgICAg c3RydWN0IHJhZGVvbl9ibyAqYm8sCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yYWRl b24vcmFkZW9uX2FzaWMuaCBiL2RyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX2FzaWMuaAo+ IGluZGV4IDI5YjNkMDUuLjcxNjZkNWYgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL3Jh ZGVvbi9yYWRlb25fYXNpYy5oCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25f YXNpYy5oCj4gQEAgLTQ0Miw5ICs0NDIsOSBAQCBpbnQgY2F5bWFuX3ZtX2luaXQoc3RydWN0IHJh ZGVvbl9kZXZpY2UgKnJkZXYpOwo+ICAgdm9pZCBjYXltYW5fdm1fZmluaShzdHJ1Y3QgcmFkZW9u X2RldmljZSAqcmRldik7Cj4gICB2b2lkIGNheW1hbl92bV9mbHVzaChzdHJ1Y3QgcmFkZW9uX2Rl dmljZSAqcmRldiwgc3RydWN0IHJhZGVvbl9pYiAqaWIpOwo+ICAgdWludDMyX3QgY2F5bWFuX3Zt X3BhZ2VfZmxhZ3Moc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYsIHVpbnQzMl90IGZsYWdzKTsK PiAtdm9pZCBjYXltYW5fdm1fc2V0X3BhZ2Uoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYsIHN0 cnVjdCByYWRlb25fdm0gKnZtLAo+IC0JCQl1bnNpZ25lZCBwZm4sIHN0cnVjdCB0dG1fbWVtX3Jl ZyAqbWVtLAo+IC0JCQl1bnNpZ25lZCBucGFnZXMsIHVpbnQzMl90IGZsYWdzKTsKPiArdm9pZCBj YXltYW5fdm1fc2V0X3BhZ2Uoc3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYsIHVpbnQ2NF90IHBl LAo+ICsJCQl1aW50NjRfdCBhZGRyLCB1bnNpZ25lZCBjb3VudCwKPiArCQkJdWludDMyX3QgZmxh Z3MsIHVpbnQzMl90IGluY3IpOwo+ICAgaW50IGV2ZXJncmVlbl9pYl9wYXJzZShzdHJ1Y3QgcmFk ZW9uX2RldmljZSAqcmRldiwgc3RydWN0IHJhZGVvbl9pYiAqaWIpOwo+ICAgCj4gICAvKiBEQ0U2 IC0gU0kgKi8KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fZ2Fy dC5jIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fZ2FydC5jCj4gaW5kZXggMmYyOGZm My4uYmFkYzgzNSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9n YXJ0LmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9nYXJ0LmMKPiBAQCAt ODIyLDQyICs4MjIsMjYgQEAgaW50IHJhZGVvbl92bV9ib19zZXRfYWRkcihzdHJ1Y3QgcmFkZW9u X2RldmljZSAqcmRldiwKPiAgIH0KPiAgIAo+ICAgLyoqCj4gLSAqIHJhZGVvbl92bV9nZXRfYWRk ciAtIGdldCB0aGUgcGh5c2ljYWwgYWRkcmVzcyBvZiB0aGUgcGFnZQo+ICsgKiByYWRlb25fdm1f bWFwX2dhcnQgLSBnZXQgdGhlIHBoeXNpY2FsIGFkZHJlc3Mgb2YgYSBnYXJ0IHBhZ2UKPiAgICAq Cj4gICAgKiBAcmRldjogcmFkZW9uX2RldmljZSBwb2ludGVyCj4gLSAqIEBtZW06IHR0bSBtZW0K PiAtICogQHBmbjogcGZuCj4gKyAqIEBhZGRyOiB0aGUgdW5tYXBwZWQgYWRkcgo+ICAgICoKPiAg ICAqIExvb2sgdXAgdGhlIHBoeXNpY2FsIGFkZHJlc3Mgb2YgdGhlIHBhZ2UgdGhhdCB0aGUgcHRl IHJlc29sdmVzCj4gICAgKiB0byAoY2F5bWFuKykuCj4gICAgKiBSZXR1cm5zIHRoZSBwaHlzaWNh bCBhZGRyZXNzIG9mIHRoZSBwYWdlLgo+ICAgICovCj4gLXU2NCByYWRlb25fdm1fZ2V0X2FkZHIo c3RydWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYsCj4gLQkJICAgICAgIHN0cnVjdCB0dG1fbWVtX3Jl ZyAqbWVtLAo+IC0JCSAgICAgICB1bnNpZ25lZCBwZm4pCj4gK3VpbnQ2NF90IHJhZGVvbl92bV9t YXBfZ2FydChzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldiwgdWludDY0X3QgYWRkcikKPiAgIHsK PiAtCXU2NCBhZGRyID0gMDsKPiAtCj4gLQlzd2l0Y2ggKG1lbS0+bWVtX3R5cGUpIHsKPiAtCWNh c2UgVFRNX1BMX1ZSQU06Cj4gLQkJYWRkciA9IChtZW0tPnN0YXJ0IDw8IFBBR0VfU0hJRlQpOwo+ IC0JCWFkZHIgKz0gcGZuICogUkFERU9OX0dQVV9QQUdFX1NJWkU7Cj4gLQkJYWRkciArPSByZGV2 LT52bV9tYW5hZ2VyLnZyYW1fYmFzZV9vZmZzZXQ7Cj4gLQkJYnJlYWs7Cj4gLQljYXNlIFRUTV9Q TF9UVDoKPiAtCQkvKiBvZmZzZXQgaW5zaWRlIHBhZ2UgdGFibGUgKi8KPiAtCQlhZGRyID0gbWVt LT5zdGFydCA8PCBQQUdFX1NISUZUOwo+IC0JCWFkZHIgKz0gcGZuICogUkFERU9OX0dQVV9QQUdF X1NJWkU7Cj4gLQkJYWRkciA9IGFkZHIgPj4gUEFHRV9TSElGVDsKPiAtCQkvKiBwYWdlIHRhYmxl IG9mZnNldCAqLwo+IC0JCWFkZHIgPSByZGV2LT5nYXJ0LnBhZ2VzX2FkZHJbYWRkcl07Cj4gLQkJ LyogaW4gY2FzZSBjcHUgcGFnZSBzaXplICE9IGdwdSBwYWdlIHNpemUqLwo+IC0JCWFkZHIgKz0g KHBmbiAqIFJBREVPTl9HUFVfUEFHRV9TSVpFKSAmICh+UEFHRV9NQVNLKTsKPiAtCQlicmVhazsK PiAtCWRlZmF1bHQ6Cj4gLQkJYnJlYWs7Cj4gLQl9Cj4gLQlyZXR1cm4gYWRkcjsKPiArCXVpbnQ2 NF90IHJlc3VsdDsKPiArCj4gKwkvKiBwYWdlIHRhYmxlIG9mZnNldCAqLwo+ICsJcmVzdWx0ID0g cmRldi0+Z2FydC5wYWdlc19hZGRyW2FkZHIgPj4gUEFHRV9TSElGVF07Cj4gKwo+ICsJLyogaW4g Y2FzZSBjcHUgcGFnZSBzaXplICE9IGdwdSBwYWdlIHNpemUqLwo+ICsJcmVzdWx0IHw9IGFkZHIg JiAoflBBR0VfTUFTSyk7Cj4gKwo+ICsJcmV0dXJuIHJlc3VsdDsKPiAgIH0KPiAgIAo+ICAgLyoq Cj4gQEAgLTg4Myw3ICs4NjcsNyBAQCBpbnQgcmFkZW9uX3ZtX2JvX3VwZGF0ZV9wdGUoc3RydWN0 IHJhZGVvbl9kZXZpY2UgKnJkZXYsCj4gICAJc3RydWN0IHJhZGVvbl9zZW1hcGhvcmUgKnNlbSA9 IE5VTEw7Cj4gICAJc3RydWN0IHJhZGVvbl9ib192YSAqYm9fdmE7Cj4gICAJdW5zaWduZWQgbmdw dV9wYWdlcywgbmR3Owo+IC0JdWludDY0X3QgcGZuOwo+ICsJdWludDY0X3QgcGZuLCBhZGRyOwo+ ICAgCWludCByOwo+ICAgCj4gICAJLyogbm90aGluZyB0byBkbyBpZiB2bSBpc24ndCBib3VuZCAq Lwo+IEBAIC05MDgsMjEgKzg5MiwyNSBAQCBpbnQgcmFkZW9uX3ZtX2JvX3VwZGF0ZV9wdGUoc3Ry dWN0IHJhZGVvbl9kZXZpY2UgKnJkZXYsCj4gICAJbmdwdV9wYWdlcyA9IHJhZGVvbl9ib19uZ3B1 X3BhZ2VzKGJvKTsKPiAgIAlib192YS0+ZmxhZ3MgJj0gflJBREVPTl9WTV9QQUdFX1ZBTElEOwo+ ICAgCWJvX3ZhLT5mbGFncyAmPSB+UkFERU9OX1ZNX1BBR0VfU1lTVEVNOwo+ICsJcGZuID0gYm9f dmEtPnNvZmZzZXQgLyBSQURFT05fR1BVX1BBR0VfU0laRTsKPiAgIAlpZiAobWVtKSB7Cj4gKwkJ YWRkciA9IG1lbS0+c3RhcnQgPDwgUEFHRV9TSElGVDsKPiAgIAkJaWYgKG1lbS0+bWVtX3R5cGUg IT0gVFRNX1BMX1NZU1RFTSkgewo+ICAgCQkJYm9fdmEtPmZsYWdzIHw9IFJBREVPTl9WTV9QQUdF X1ZBTElEOwo+ICAgCQkJYm9fdmEtPnZhbGlkID0gdHJ1ZTsKPiAgIAkJfQo+ICAgCQlpZiAobWVt LT5tZW1fdHlwZSA9PSBUVE1fUExfVFQpIHsKPiAgIAkJCWJvX3ZhLT5mbGFncyB8PSBSQURFT05f Vk1fUEFHRV9TWVNURU07Cj4gKwkJfSBlbHNlIHsKPiArCQkJYWRkciArPSByZGV2LT52bV9tYW5h Z2VyLnZyYW1fYmFzZV9vZmZzZXQ7Cj4gICAJCX0KCj4gICAJCWlmICghYm9fdmEtPnZhbGlkKSB7 Cj4gICAJCQltZW0gPSBOVUxMOwo+ICAgCQl9ClRoYXQgY2hlY2sgYW5kIHNldHRpbmcgbWVtID0g TlVMTCBpcyBub3cgc3VwZXJmbHVvdXMsIHNpbmNlIHdlIGRvbid0IHVzZSAKbWVtIGFueW1vcmUu Ck1pc3NlZCB0aGF0IHdoaWxlIGhhY2tpbmcgdGhlIGluaXRpYWwgcGF0Y2gsIHBsZWFzZSBqdXN0 IHJlbW92ZS4KCj4gICAJfSBlbHNlIHsKPiArCQlhZGRyID0gMDsKPiAgIAkJYm9fdmEtPnZhbGlk ID0gZmFsc2U7Cj4gICAJfQo+IC0JcGZuID0gYm9fdmEtPnNvZmZzZXQgLyBSQURFT05fR1BVX1BB R0VfU0laRTsKPiAgIAo+ICAgCWlmICh2bS0+ZmVuY2UgJiYgcmFkZW9uX2ZlbmNlX3NpZ25hbGVk KHZtLT5mZW5jZSkpIHsKPiAgIAkJcmFkZW9uX2ZlbmNlX3VucmVmKCZ2bS0+ZmVuY2UpOwo+IEBA IC05NTAsNyArOTM4LDggQEAgaW50IHJhZGVvbl92bV9ib191cGRhdGVfcHRlKHN0cnVjdCByYWRl b25fZGV2aWNlICpyZGV2LAo+ICAgCQlyYWRlb25fZmVuY2Vfbm90ZV9zeW5jKHZtLT5mZW5jZSwg cmlkeCk7Cj4gICAJfQo+ICAgCj4gLQlyYWRlb25fYXNpY192bV9zZXRfcGFnZShyZGV2LCB2bSwg cGZuLCBtZW0sIG5ncHVfcGFnZXMsIGJvX3ZhLT5mbGFncyk7Cj4gKwlyYWRlb25fYXNpY192bV9z ZXRfcGFnZShyZGV2LCB2bS0+cHRfZ3B1X2FkZHIgKyBwZm4gKiA4LCBhZGRyLAo+ICsJCQkJbmdw dV9wYWdlcywgYm9fdmEtPmZsYWdzLCAwKTsKPiAgIAo+ICAgCXJhZGVvbl9mZW5jZV91bnJlZigm dm0tPmZlbmNlKTsKPiAgIAlyID0gcmFkZW9uX2ZlbmNlX2VtaXQocmRldiwgJnZtLT5mZW5jZSwg cmlkeCk7Cj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvZHJtL3JhZGVvbl9kcm0uaCBiL2luY2x1ZGUv ZHJtL3JhZGVvbl9kcm0uaAo+IGluZGV4IGRjM2E4Y2QuLmYzNmViZTUgMTAwNjQ0Cj4gLS0tIGEv aW5jbHVkZS9kcm0vcmFkZW9uX2RybS5oCj4gKysrIGIvaW5jbHVkZS9kcm0vcmFkZW9uX2RybS5o Cj4gQEAgLTg5Niw2ICs4OTYsNyBAQCBzdHJ1Y3QgZHJtX3JhZGVvbl9nZW1fcHdyaXRlIHsKPiAg ICNkZWZpbmUgUkFERU9OX1ZNX1BBR0VfV1JJVEVBQkxFCSgxIDw8IDIpCj4gICAjZGVmaW5lIFJB REVPTl9WTV9QQUdFX1NZU1RFTQkJKDEgPDwgMykKPiAgICNkZWZpbmUgUkFERU9OX1ZNX1BBR0Vf U05PT1BFRAkJKDEgPDwgNCkKPiArI2RlZmluZSBSQURFT05fVk1fUERFX1ZBTElECQkoMSA8PCA1 KQo+ICAgCj4gICBzdHJ1Y3QgZHJtX3JhZGVvbl9nZW1fdmEgewo+ICAgCXVpbnQzMl90CQloYW5k bGU7CgpDaGVlcnMsCkNocmlzdGlhbi4KX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJl ZWRlc2t0b3Aub3JnCmh0dHA6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5m by9kcmktZGV2ZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751518Ab2IONW5 (ORCPT ); Sat, 15 Sep 2012 09:22:57 -0400 Received: from outgoing.email.vodafone.de ([139.7.28.128]:33755 "EHLO outgoing.email.vodafone.de" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750852Ab2IONWz (ORCPT ); Sat, 15 Sep 2012 09:22:55 -0400 X-Authentication-Info: Sender authenticated as deathsimple@vodafone.de (using CRAM-MD5) Message-ID: <50548124.4020104@vodafone.de> Date: Sat, 15 Sep 2012 15:22:44 +0200 From: =?UTF-8?B?Q2hyaXN0aWFuIEvDtm5pZw==?= User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:15.0) Gecko/20120827 Thunderbird/15.0 MIME-Version: 1.0 To: Dmitry Cherkasov CC: dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, Alex Deucher , Dmitry Cherkassov Subject: Re: [PATCH 1/2] drm/radeon: refactor set_page chipset interface v2 References: <1347644982-17386-1-git-send-email-Dmitrii.Cherkasov@amd.com> In-Reply-To: <1347644982-17386-1-git-send-email-Dmitrii.Cherkasov@amd.com> Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Looks good in general, some minor comments below: On 14.09.2012 19:49, Dmitry Cherkasov wrote: > From: Christian König > > Cleanup the interface in preparation for hierarchical page tables. > v2: * add incr parameter to set_page for simple scattered PTs uptates > * added PDE-specific flags to r600_flags and radeon_drm.h > * removed superflous value masking with 0xffffffff > > Signed-off-by: Christian König > Signed-off-by: Dmitry Cherkassov > --- > drivers/gpu/drm/radeon/ni.c | 47 ++++++++++++++++++++----------- > drivers/gpu/drm/radeon/radeon.h | 14 +++++----- > drivers/gpu/drm/radeon/radeon_asic.h | 6 ++-- > drivers/gpu/drm/radeon/radeon_gart.c | 51 +++++++++++++--------------------- > include/drm/radeon_drm.h | 1 + > 5 files changed, 62 insertions(+), 57 deletions(-) > > diff --git a/drivers/gpu/drm/radeon/ni.c b/drivers/gpu/drm/radeon/ni.c > index b238216..0355c8d 100644 > --- a/drivers/gpu/drm/radeon/ni.c > +++ b/drivers/gpu/drm/radeon/ni.c > @@ -1497,6 +1497,7 @@ void cayman_vm_fini(struct radeon_device *rdev) > { > } > > +#define R600_PDE_VALID (1 << 0) > #define R600_PTE_VALID (1 << 0) Why the distinction between R600_PDE_VALID and R600_PTE_VALID? Just renaming the R600_PTE_* flags sound more sane to me. > #define R600_PTE_SYSTEM (1 << 1) > #define R600_PTE_SNOOPED (1 << 2) > @@ -1507,6 +1508,7 @@ uint32_t cayman_vm_page_flags(struct radeon_device *rdev, uint32_t flags) > { > uint32_t r600_flags = 0; > > + r600_flags |= (flags & RADEON_VM_PDE_VALID) ? R600_PDE_VALID : 0; > r600_flags |= (flags & RADEON_VM_PAGE_VALID) ? R600_PTE_VALID : 0; > r600_flags |= (flags & RADEON_VM_PAGE_READABLE) ? R600_PTE_READABLE : 0; > r600_flags |= (flags & RADEON_VM_PAGE_WRITEABLE) ? R600_PTE_WRITEABLE : 0; > @@ -1521,30 +1523,43 @@ uint32_t cayman_vm_page_flags(struct radeon_device *rdev, uint32_t flags) > * cayman_vm_set_page - update the page tables using the CP > * > * @rdev: radeon_device pointer > + * @pe: addr of the page entry > + * @addr: dst addr to write into pe > + * @count: number of page entries to update > + * @flags: access flags > * > * Update the page tables using the CP (cayman-si). > */ > -void cayman_vm_set_page(struct radeon_device *rdev, struct radeon_vm *vm, > - unsigned pfn, struct ttm_mem_reg *mem, > - unsigned npages, uint32_t flags) > +void cayman_vm_set_page(struct radeon_device *rdev, uint64_t pe, > + uint64_t addr, unsigned count, > + uint32_t flags, uint32_t incr) > { > struct radeon_ring *ring = &rdev->ring[rdev->asic->vm.pt_ring_index]; > - uint64_t addr, pt = vm->pt_gpu_addr + pfn * 8; > + uint32_t r600_flags = cayman_vm_page_flags(rdev, flags); > int i; > > - addr = flags = cayman_vm_page_flags(rdev, flags); > - > - radeon_ring_write(ring, PACKET3(PACKET3_ME_WRITE, 1 + npages * 2)); > - radeon_ring_write(ring, pt & 0xffffffff); > - radeon_ring_write(ring, (pt >> 32) & 0xff); > - for (i = 0; i < npages; ++i) { > - if (mem) { > - addr = radeon_vm_get_addr(rdev, mem, i); > - addr = addr & 0xFFFFFFFFFFFFF000ULL; > - addr |= flags; > + radeon_ring_write(ring, PACKET3(PACKET3_ME_WRITE, 1 + count * 2)); > + radeon_ring_write(ring, pe & 0xffffffff); > + radeon_ring_write(ring, (pe >> 32) & 0xff); > + for (i = 0; i < count; ++i) { > + uint64_t value = 0; > + if (flags & RADEON_VM_PAGE_SYSTEM) { > + value = radeon_vm_map_gart(rdev, addr); > + value &= 0xFFFFFFFFFFFFF000ULL; > + addr += RADEON_GPU_PAGE_SIZE; > + > + } else if (flags & RADEON_VM_PAGE_VALID) { > + value = addr; > + addr += RADEON_GPU_PAGE_SIZE; > + > + } else if (flags & RADEON_VM_PDE_VALID) { > + value = addr; > + addr += incr; > } Same here, why the distinction between RADEON_VM_PDE_VALID and RADEON_VM_PAGE_VALID? Additional to that I would also prefer to always use "incr" for both the RADEON_VM_PAGE_SYSTEMand the RADEON_VM_PAGE_VALID case. > - radeon_ring_write(ring, addr & 0xffffffff); > - radeon_ring_write(ring, (addr >> 32) & 0xffffffff); > + > + value |= r600_flags; > + radeon_ring_write(ring, value); > + radeon_ring_write(ring, (value >> 32)); > } > } > > diff --git a/drivers/gpu/drm/radeon/radeon.h b/drivers/gpu/drm/radeon/radeon.h > index 4d67f0f..f02ea8e 100644 > --- a/drivers/gpu/drm/radeon/radeon.h > +++ b/drivers/gpu/drm/radeon/radeon.h > @@ -1141,9 +1141,9 @@ struct radeon_asic { > void (*fini)(struct radeon_device *rdev); > > u32 pt_ring_index; > - void (*set_page)(struct radeon_device *rdev, struct radeon_vm *vm, > - unsigned pfn, struct ttm_mem_reg *mem, > - unsigned npages, uint32_t flags); > + void (*set_page) > + (struct radeon_device *rdev, uint64_t pe, > + uint64_t addr, unsigned count, uint32_t flags, uint32_t incr); Please don't break the coding style here. Or was it me who did that? Anyway keep the indention as it was before. Additional to that at least I would put the arguments in that order: pe, addr then count, incr and last flags. > } vm; > /* ring specific callbacks */ > struct { > @@ -1755,7 +1755,9 @@ void radeon_ring_write(struct radeon_ring *ring, uint32_t v); > #define radeon_gart_set_page(rdev, i, p) (rdev)->asic->gart.set_page((rdev), (i), (p)) > #define radeon_asic_vm_init(rdev) (rdev)->asic->vm.init((rdev)) > #define radeon_asic_vm_fini(rdev) (rdev)->asic->vm.fini((rdev)) > -#define radeon_asic_vm_set_page(rdev, v, pfn, mem, npages, flags) (rdev)->asic->vm.set_page((rdev), (v), (pfn), (mem), (npages), (flags)) > +#define radeon_asic_vm_set_page(rdev, pe, addr, count, flags, incr) \ > + ((rdev)->asic->vm.set_page((rdev), (pe), (addr), \ > + (count), (flags), (incr))) Same here, no idea why we have those macros all on one line. But please make it look like the rest of the code. > #define radeon_ring_start(rdev, r, cp) (rdev)->asic->ring[(r)].ring_start((rdev), (cp)) > #define radeon_ring_test(rdev, r, cp) (rdev)->asic->ring[(r)].ring_test((rdev), (cp)) > #define radeon_ib_test(rdev, r, cp) (rdev)->asic->ring[(r)].ib_test((rdev), (cp)) > @@ -1840,9 +1842,7 @@ struct radeon_fence *radeon_vm_grab_id(struct radeon_device *rdev, > void radeon_vm_fence(struct radeon_device *rdev, > struct radeon_vm *vm, > struct radeon_fence *fence); > -u64 radeon_vm_get_addr(struct radeon_device *rdev, > - struct ttm_mem_reg *mem, > - unsigned pfn); > +uint64_t radeon_vm_map_gart(struct radeon_device *rdev, uint64_t addr); > int radeon_vm_bo_update_pte(struct radeon_device *rdev, > struct radeon_vm *vm, > struct radeon_bo *bo, > diff --git a/drivers/gpu/drm/radeon/radeon_asic.h b/drivers/gpu/drm/radeon/radeon_asic.h > index 29b3d05..7166d5f 100644 > --- a/drivers/gpu/drm/radeon/radeon_asic.h > +++ b/drivers/gpu/drm/radeon/radeon_asic.h > @@ -442,9 +442,9 @@ int cayman_vm_init(struct radeon_device *rdev); > void cayman_vm_fini(struct radeon_device *rdev); > void cayman_vm_flush(struct radeon_device *rdev, struct radeon_ib *ib); > uint32_t cayman_vm_page_flags(struct radeon_device *rdev, uint32_t flags); > -void cayman_vm_set_page(struct radeon_device *rdev, struct radeon_vm *vm, > - unsigned pfn, struct ttm_mem_reg *mem, > - unsigned npages, uint32_t flags); > +void cayman_vm_set_page(struct radeon_device *rdev, uint64_t pe, > + uint64_t addr, unsigned count, > + uint32_t flags, uint32_t incr); > int evergreen_ib_parse(struct radeon_device *rdev, struct radeon_ib *ib); > > /* DCE6 - SI */ > diff --git a/drivers/gpu/drm/radeon/radeon_gart.c b/drivers/gpu/drm/radeon/radeon_gart.c > index 2f28ff3..badc835 100644 > --- a/drivers/gpu/drm/radeon/radeon_gart.c > +++ b/drivers/gpu/drm/radeon/radeon_gart.c > @@ -822,42 +822,26 @@ int radeon_vm_bo_set_addr(struct radeon_device *rdev, > } > > /** > - * radeon_vm_get_addr - get the physical address of the page > + * radeon_vm_map_gart - get the physical address of a gart page > * > * @rdev: radeon_device pointer > - * @mem: ttm mem > - * @pfn: pfn > + * @addr: the unmapped addr > * > * Look up the physical address of the page that the pte resolves > * to (cayman+). > * Returns the physical address of the page. > */ > -u64 radeon_vm_get_addr(struct radeon_device *rdev, > - struct ttm_mem_reg *mem, > - unsigned pfn) > +uint64_t radeon_vm_map_gart(struct radeon_device *rdev, uint64_t addr) > { > - u64 addr = 0; > - > - switch (mem->mem_type) { > - case TTM_PL_VRAM: > - addr = (mem->start << PAGE_SHIFT); > - addr += pfn * RADEON_GPU_PAGE_SIZE; > - addr += rdev->vm_manager.vram_base_offset; > - break; > - case TTM_PL_TT: > - /* offset inside page table */ > - addr = mem->start << PAGE_SHIFT; > - addr += pfn * RADEON_GPU_PAGE_SIZE; > - addr = addr >> PAGE_SHIFT; > - /* page table offset */ > - addr = rdev->gart.pages_addr[addr]; > - /* in case cpu page size != gpu page size*/ > - addr += (pfn * RADEON_GPU_PAGE_SIZE) & (~PAGE_MASK); > - break; > - default: > - break; > - } > - return addr; > + uint64_t result; > + > + /* page table offset */ > + result = rdev->gart.pages_addr[addr >> PAGE_SHIFT]; > + > + /* in case cpu page size != gpu page size*/ > + result |= addr & (~PAGE_MASK); > + > + return result; > } > > /** > @@ -883,7 +867,7 @@ int radeon_vm_bo_update_pte(struct radeon_device *rdev, > struct radeon_semaphore *sem = NULL; > struct radeon_bo_va *bo_va; > unsigned ngpu_pages, ndw; > - uint64_t pfn; > + uint64_t pfn, addr; > int r; > > /* nothing to do if vm isn't bound */ > @@ -908,21 +892,25 @@ int radeon_vm_bo_update_pte(struct radeon_device *rdev, > ngpu_pages = radeon_bo_ngpu_pages(bo); > bo_va->flags &= ~RADEON_VM_PAGE_VALID; > bo_va->flags &= ~RADEON_VM_PAGE_SYSTEM; > + pfn = bo_va->soffset / RADEON_GPU_PAGE_SIZE; > if (mem) { > + addr = mem->start << PAGE_SHIFT; > if (mem->mem_type != TTM_PL_SYSTEM) { > bo_va->flags |= RADEON_VM_PAGE_VALID; > bo_va->valid = true; > } > if (mem->mem_type == TTM_PL_TT) { > bo_va->flags |= RADEON_VM_PAGE_SYSTEM; > + } else { > + addr += rdev->vm_manager.vram_base_offset; > } > if (!bo_va->valid) { > mem = NULL; > } That check and setting mem = NULL is now superfluous, since we don't use mem anymore. Missed that while hacking the initial patch, please just remove. > } else { > + addr = 0; > bo_va->valid = false; > } > - pfn = bo_va->soffset / RADEON_GPU_PAGE_SIZE; > > if (vm->fence && radeon_fence_signaled(vm->fence)) { > radeon_fence_unref(&vm->fence); > @@ -950,7 +938,8 @@ int radeon_vm_bo_update_pte(struct radeon_device *rdev, > radeon_fence_note_sync(vm->fence, ridx); > } > > - radeon_asic_vm_set_page(rdev, vm, pfn, mem, ngpu_pages, bo_va->flags); > + radeon_asic_vm_set_page(rdev, vm->pt_gpu_addr + pfn * 8, addr, > + ngpu_pages, bo_va->flags, 0); > > radeon_fence_unref(&vm->fence); > r = radeon_fence_emit(rdev, &vm->fence, ridx); > diff --git a/include/drm/radeon_drm.h b/include/drm/radeon_drm.h > index dc3a8cd..f36ebe5 100644 > --- a/include/drm/radeon_drm.h > +++ b/include/drm/radeon_drm.h > @@ -896,6 +896,7 @@ struct drm_radeon_gem_pwrite { > #define RADEON_VM_PAGE_WRITEABLE (1 << 2) > #define RADEON_VM_PAGE_SYSTEM (1 << 3) > #define RADEON_VM_PAGE_SNOOPED (1 << 4) > +#define RADEON_VM_PDE_VALID (1 << 5) > > struct drm_radeon_gem_va { > uint32_t handle; Cheers, Christian.