From mboxrd@z Thu Jan 1 00:00:00 1970 From: Mark Zhang Subject: Re: [RFC,v2,1/8] video: tegra: Add nvhost driver Date: Thu, 29 Nov 2012 17:10:46 +0800 Message-ID: <50B72696.3030205@gmail.com> References: <1353935954-13763-2-git-send-email-tbergstrom@nvidia.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1353935954-13763-2-git-send-email-tbergstrom@nvidia.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: Terje Bergstrom Cc: linux-tegra@vger.kernel.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org List-Id: linux-tegra@vger.kernel.org T24gMTEvMjYvMjAxMiAwOToxOSBQTSwgVGVyamUgQmVyZ3N0csO2bSA8dGJlcmdzdHJvbUBudmlk aWEuY29tPiB3cm90ZToKPiBBZGQgbnZob3N0LCB0aGUgZHJpdmVyIGZvciBob3N0MXguIFRoaXMg cGF0Y2ggYWRkcyBzdXBwb3J0IGZvciByZWFkaW5nIGFuZAo+IGluY3JlbWVudGluZyBzeW5jIHBv aW50cyBhbmQgZHluYW1pYyBwb3dlciBtYW5hZ2VtZW50Lgo+IAo+IFNpZ25lZC1vZmYtYnk6IFRl cmplIEJlcmdzdHJvbSA8dGJlcmdzdHJvbUBudmlkaWEuY29tPgo+IAo+IC0tLQo+IGRyaXZlcnMv dmlkZW8vS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAgMiArCj4gIGRy aXZlcnMvdmlkZW8vTWFrZWZpbGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAgMiAr Cj4gIGRyaXZlcnMvdmlkZW8vdGVncmEvaG9zdC9LY29uZmlnICAgICAgICAgICAgICAgICAgIHwg ICAgNSArCj4gIGRyaXZlcnMvdmlkZW8vdGVncmEvaG9zdC9NYWtlZmlsZSAgICAgICAgICAgICAg ICAgIHwgICAxMCArCj4gIGRyaXZlcnMvdmlkZW8vdGVncmEvaG9zdC9jaGlwX3N1cHBvcnQuYyAg ICAgICAgICAgIHwgICA0OCArKwo+ICBkcml2ZXJzL3ZpZGVvL3RlZ3JhL2hvc3QvY2hpcF9zdXBw b3J0LmggICAgICAgICAgICB8ICAgNTIgKysrCj4gIGRyaXZlcnMvdmlkZW8vdGVncmEvaG9zdC9k ZXYuYyAgICAgICAgICAgICAgICAgICAgIHwgICA5NiArKysrCj4gIGRyaXZlcnMvdmlkZW8vdGVn cmEvaG9zdC9ob3N0MXgvTWFrZWZpbGUgICAgICAgICAgIHwgICAgNyArCj4gIGRyaXZlcnMvdmlk ZW8vdGVncmEvaG9zdC9ob3N0MXgvaG9zdDF4LmMgICAgICAgICAgIHwgIDIwNCArKysrKysrKysK PiAgZHJpdmVycy92aWRlby90ZWdyYS9ob3N0L2hvc3QxeC9ob3N0MXguaCAgICAgICAgICAgfCAg IDc4ICsrKysKPiAgZHJpdmVycy92aWRlby90ZWdyYS9ob3N0L2hvc3QxeC9ob3N0MXgwMS5jICAg ICAgICAgfCAgIDM3ICsrCj4gIGRyaXZlcnMvdmlkZW8vdGVncmEvaG9zdC9ob3N0MXgvaG9zdDF4 MDEuaCAgICAgICAgIHwgICAyOSArKwo+ICAuLi4vdmlkZW8vdGVncmEvaG9zdC9ob3N0MXgvaG9z dDF4MDFfaGFyZHdhcmUuaCAgICB8ICAgMzYgKysKPiAgZHJpdmVycy92aWRlby90ZWdyYS9ob3N0 L2hvc3QxeC9ob3N0MXhfc3luY3B0LmMgICAgfCAgMTU2ICsrKysrKysKPiAgZHJpdmVycy92aWRl by90ZWdyYS9ob3N0L2hvc3QxeC9od19ob3N0MXgwMV9zeW5jLmggfCAgMzk4ICsrKysrKysrKysr KysrKysKPiAgZHJpdmVycy92aWRlby90ZWdyYS9ob3N0L252aG9zdF9hY20uYyAgICAgICAgICAg ICAgfCAgNDgxICsrKysrKysrKysrKysrKysrKysrCj4gIGRyaXZlcnMvdmlkZW8vdGVncmEvaG9z dC9udmhvc3RfYWNtLmggICAgICAgICAgICAgIHwgICA0NSArKwo+ICBkcml2ZXJzL3ZpZGVvL3Rl Z3JhL2hvc3QvbnZob3N0X3N5bmNwdC5jICAgICAgICAgICB8ICAzMzMgKysrKysrKysrKysrKysK PiAgZHJpdmVycy92aWRlby90ZWdyYS9ob3N0L252aG9zdF9zeW5jcHQuaCAgICAgICAgICAgfCAg MTM2ICsrKysrKwo+ICBpbmNsdWRlL2xpbnV4L252aG9zdC5oICAgICAgICAgICAgICAgICAgICAg ICAgICAgICB8ICAxNDMgKysrKysrCj4gIDIwIGZpbGVzIGNoYW5nZWQsIDIyOTggaW5zZXJ0aW9u cygrKQpbLi4uXQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL3RlZ3JhL2hvc3QvY2hpcF9z dXBwb3J0LmMgYi9kcml2ZXJzL3ZpZGVvL3RlZ3JhL2hvc3QvY2hpcF9zdXBwb3J0LmMKPiArI2lu Y2x1ZGUgImNoaXBfc3VwcG9ydC5oIgo+ICsjaW5jbHVkZSAiaG9zdDF4L2hvc3QxeDAxLmgiCj4g Kwo+ICtzdHJ1Y3QgbnZob3N0X2NoaXBfc3VwcG9ydCAqbnZob3N0X2NoaXBfb3BzOwo+ICsKPiAr c3RydWN0IG52aG9zdF9jaGlwX3N1cHBvcnQgKm52aG9zdF9nZXRfY2hpcF9vcHModm9pZCkKPiAr ewo+ICsJcmV0dXJuIG52aG9zdF9jaGlwX29wczsKPiArfQoKSWYgeW91IHdhbm5hIGhpZGUgIm52 aG9zdF9jaGlwX29wcyIgZnJvbSBvdGhlciBzb3VyY2UgZmlsZXMsIGRlY2xhcmUgaXQKYXMgInN0 YXRpYyIuIFNvIHRoaXMgaXMgbm90IGEgc3RhdGljIG1lbWJlciB3aGljaCBtZWFucyBvdGhlciBm aWxlcyBpcwphYmxlIHRvIHRvdWNoIGl0IGJ5ICJleHRlcm4iIGJ1dCB3ZSBhbHNvIGRlZmluZSBh IGZ1bmN0aW9uIHRvIGdldCBpdCwKYW5kIHRoaXMgbG9va3MgcmVkdW5kYW50LgoKWy4uLl0KPiBk aWZmIC0tZ2l0IGEvZHJpdmVycy92aWRlby90ZWdyYS9ob3N0L2hvc3QxeC9NYWtlZmlsZSBiL2Ry aXZlcnMvdmlkZW8vdGVncmEvaG9zdC9ob3N0MXgvTWFrZWZpbGUKPiBuZXcgZmlsZSBtb2RlIDEw MDY0NAo+IGluZGV4IDAwMDAwMDAuLjMzMGQ1MDcKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvZHJp dmVycy92aWRlby90ZWdyYS9ob3N0L2hvc3QxeC9NYWtlZmlsZQo+IEBAIC0wLDAgKzEsNyBAQAo+ ICtjY2ZsYWdzLXkgPSAtSWRyaXZlcnMvdmlkZW8vdGVncmEvaG9zdAo+ICsKPiArbnZob3N0LWhv c3QxeC1vYmpzICA9IFwKPiArCWhvc3QxeC5vIFwKPiArCWhvc3QxeDAxLm8KCkNhbiB3ZSByZW5h bWUgdGhpcyAiaG9zdDF4MDEuYyI/IEkganVzdCByZWFsbHkgZG9uJ3QgbGlrZSB0aGlzIGtpbmQg b2YKdmFyaWFibGVzL2ZpbGVzLCBJIG1lYW4sIEkgY2FuJ3QgaW1hZ2luZSB0aGUgcHVycG9zZSBv ZiB0aGUgZmlsZQphY2NvcmRpbmcgdG8gaXQncyBuYW1lLi4uCgpbLi4uXQo+ICsKPiArc3RhdGlj IGludCBfX2RldmluaXQgbnZob3N0X2FsbG9jX3Jlc291cmNlcyhzdHJ1Y3QgbnZob3N0X21hc3Rl ciAqaG9zdCkKPiArewo+ICsJaW50IGVycjsKPiArCj4gKwllcnIgPSBudmhvc3RfaW5pdF9jaGlw X3N1cHBvcnQoaG9zdCk7Cj4gKwlpZiAoZXJyKQo+ICsJCXJldHVybiBlcnI7Cj4gKwo+ICsJcmV0 dXJuIDA7Cj4gK30KCkp1c3QgInJldHVybiBudmhvc3RfaW5pdF9jaGlwX3N1cHBvcnQoaG9zdCki IGlzIGVub3VnaC4gSWYgc28sIGRvIHdlCnN0aWxsIG5lZWQgdGhpcyBmdW5jdGlvbj8KClsuLi5d Cj4gKwo+ICtzdGF0aWMgaW50IF9fZGV2aW5pdCBudmhvc3RfcHJvYmUoc3RydWN0IHBsYXRmb3Jt X2RldmljZSAqZGV2KQo+ICsKWy4uLl0KPiArCWRldl9pbmZvKCZkZXYtPmRldiwgImluaXRpYWxp emVkXG4iKTsKPiArCj4gKwlyZXR1cm4gMDsKPiArCj4gK2ZhaWw6CgpBZGQgbW9yZSAiZnJlZSIg Y29kZXMgaGVyZS4gQWN0dWFsbHksICJudmhvc3RfZnJlZV9yZXNvdXJjZXMiIGZyZWVzIHRoZQpo b3N0LT5pbnRyLnN5bmNwdCB3aGljaCBpcyBub3QgbmVlZGVkIHRvIGZyZWUgbWFudWFsbHkuClNl ZW1zIGF0IGxlYXN0IHdlIG5lZWQgdG8gYWRkICJudmhvc3Rfc3luY3B0X2RlaW5pdCIgaGVyZS4K ClsuLi5dCj4gKwo+ICtzdGF0aWMgc3RydWN0IG9mX2RldmljZV9pZCBob3N0MXhfbWF0Y2hbXSBf X2RldmluaXRkYXRhID0gewo+ICsJeyAuY29tcGF0aWJsZSA9ICJudmlkaWEsdGVncmEyMC1ob3N0 MXgiLCB9LAo+ICsJeyAuY29tcGF0aWJsZSA9ICJudmlkaWEsdGVncmEzMC1ob3N0MXgiLCB9LAoK QWdhaW4sIHBsYWNlIHRlZ3JhMzAtaG9zdDF4IGJlZm9yZSB0ZWdyYTIwLWhvc3QxeC4KClsuLi5d Cj4gKwo+ICsvKioKPiArICogV3JpdGUgYSBjcHUgc3luY3BvaW50IGluY3JlbWVudCB0byB0aGUg aGFyZHdhcmUsIHdpdGhvdXQgdG91Y2hpbmcKPiArICogdGhlIGNhY2hlLiBDYWxsZXIgaXMgcmVz cG9uc2libGUgZm9yIGhvc3QgYmVpbmcgcG93ZXJlZC4KPiArICovCj4gK3N0YXRpYyB2b2lkIGhv c3QxeF9zeW5jcHRfY3B1X2luY3Ioc3RydWN0IG52aG9zdF9zeW5jcHQgKnNwLCB1MzIgaWQpCj4g K3sKPiArCXN0cnVjdCBudmhvc3RfbWFzdGVyICpkZXYgPSBzeW5jcHRfdG9fZGV2KHNwKTsKPiAr CXUzMiByZWdfb2Zmc2V0ID0gaWQgLyAzMjsKPiArCj4gKwlpZiAoIW52aG9zdF9tb2R1bGVfcG93 ZXJlZChkZXYtPmRldikpIHsKPiArCQlkZXZfZXJyKCZzeW5jcHRfdG9fZGV2KHNwKS0+ZGV2LT5k ZXYsCj4gKwkJCSJUcnlpbmcgdG8gYWNjZXNzIGhvc3QxeCB3aGVuIGl0J3Mgb2ZmIik7Cj4gKwkJ cmV0dXJuOwo+ICsJfQo+ICsKPiArCWlmICghbnZob3N0X3N5bmNwdF9jbGllbnRfbWFuYWdlZChz cCwgaWQpCj4gKwkJCSYmIG52aG9zdF9zeW5jcHRfbWluX2VxX21heChzcCwgaWQpKSB7Cj4gKwkJ ZGV2X2Vycigmc3luY3B0X3RvX2RldihzcCktPmRldi0+ZGV2LAo+ICsJCQkiVHJ5aW5nIHRvIGlu Y3JlbWVudCBzeW5jcG9pbnQgaWQgJWQgYmV5b25kIG1heFxuIiwKPiArCQkJaWQpOwo+ICsJCXJl dHVybjsKPiArCX0KPiArCXdyaXRlbChCSVRfTUFTSyhpZCksIGRldi0+c3luY19hcGVydHVyZSAr Cj4gKwkJCWhvc3QxeF9zeW5jX3N5bmNwdF9jcHVfaW5jcl9yKCkgKyByZWdfb2Zmc2V0ICogNCk7 CgpJIGhhdmUgYSBzdHVwaWQgcXVlc3Rpb246IEFjY29yZGluZyB0byB0aGUgbmFtZSBhbmQgdGhl IGNvbnRleHQgb2YgdGhpcwpmdW5jdGlvbiwgc2VlbXMgaXQgaW5jcmVhc2VzIHRoZSBzeW5jcHQg dmFsdWUgd2hpY2ggc3BlY2lmaWVkIGJ5IHBhcmFtCiJpZCIuIFNvIGhvdyBkb2VzIHRoaXMgIndy aXRlbCIgaW5jcmVhc2UgdGhlIHZhbHVlPyBJIGRvbid0IGtub3cgbXVjaAphYm91dCBob3N0MXgv c3luY3B0IHJlZyBvcGVyYXRpb25zLCBzbyBjb3VsZCB5b3UgZXhwbGFpbiBhIGxpdHRsZSBiaXQg b3IKSSBqdXN0IGNvbXBsZXRlbHkgaGF2ZSBhIHdyb25nIHVuZGVyc3RhbmRpbmc/CgpbLi4uXQo+ ICsKPiArc3RhdGljIHNzaXplX3QgcG93ZXJnYXRlX2RlbGF5X3N0b3JlKHN0cnVjdCBrb2JqZWN0 ICprb2JqLAo+ICsJc3RydWN0IGtvYmpfYXR0cmlidXRlICphdHRyLCBjb25zdCBjaGFyICpidWYs IHNpemVfdCBjb3VudCkKPiArewo+ICsJaW50IHBvd2VyZ2F0ZV9kZWxheSA9IDAsIHJldCA9IDA7 Cj4gKwlzdHJ1Y3QgbnZob3N0X2RldmljZV9wb3dlcl9hdHRyICpwb3dlcl9hdHRyaWJ1dGUgPQo+ ICsJCWNvbnRhaW5lcl9vZihhdHRyLCBzdHJ1Y3QgbnZob3N0X2RldmljZV9wb3dlcl9hdHRyLAo+ ICsJCQlwb3dlcl9hdHRyW05WSE9TVF9QT1dFUl9TWVNGU19BVFRSSUJfUE9XRVJHQVRFX0RFTEFZ XSk7Cj4gKwlzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpkZXYgPSBwb3dlcl9hdHRyaWJ1dGUtPm5k ZXY7Cj4gKwlzdHJ1Y3QgbnZob3N0X2RldmljZV9kYXRhICpwZGF0YSA9IHBsYXRmb3JtX2dldF9k cnZkYXRhKGRldik7Cj4gKwo+ICsJaWYgKCFwZGF0YS0+Y2FuX3Bvd2VyZ2F0ZSkgewo+ICsJCWRl dl9pbmZvKCZkZXYtPmRldiwgImRvZXMgbm90IHN1cHBvcnQgcG93ZXItZ2F0aW5nXG4iKTsKPiAr CQlyZXR1cm4gY291bnQ7Cj4gKwl9Cj4gKwo+ICsJbXV0ZXhfbG9jaygmcGRhdGEtPmxvY2spOwo+ ICsJcmV0ID0gc3NjYW5mKGJ1ZiwgIiVkIiwgJnBvd2VyZ2F0ZV9kZWxheSk7Cj4gKwlpZiAocmV0 ID09IDEgJiYgcG93ZXJnYXRlX2RlbGF5ID49IDApCj4gKwkJcGRhdGEtPnBvd2VyZ2F0ZV9kZWxh eSA9IHBvd2VyZ2F0ZV9kZWxheTsKPiArCWVsc2UKPiArCQlkZXZfZXJyKCZkZXYtPmRldiwgIklu dmFsaWQgcG93ZXJnYXRlIGRlbGF5XG4iKTsKPiArCW11dGV4X3VubG9jaygmcGRhdGEtPmxvY2sp Owo+ICsKPiArCXJldHVybiBjb3VudDsKCldoeSB3ZSBuZWVkIHRvIHJldHVybiBhbiB1bmNoYW5n ZWQgcGFyYW0/IFNlZW1zIHBhcmFtICJjb3VudCIgZG9lc24ndAptYWtlIHNlbnNlIGhlcmUuCgpb Li4uXQo+ICsKPiAraW50IG52aG9zdF9tb2R1bGVfaW5pdChzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNl ICpkZXYpCj4gK3sKPiArCWludCBpID0gMCwgZXJyID0gMDsKPiArCXN0cnVjdCBrb2JqX2F0dHJp YnV0ZSAqYXR0ciA9IE5VTEw7Cj4gKwlzdHJ1Y3QgbnZob3N0X2RldmljZV9kYXRhICpwZGF0YSA9 IHBsYXRmb3JtX2dldF9kcnZkYXRhKGRldik7Cj4gKwo+ICsJLyogaW5pdGlhbGl6ZSBjbG9ja3Mg dG8ga25vd24gc3RhdGUgKi8KPiArCXdoaWxlIChwZGF0YS0+Y2xvY2tzW2ldLm5hbWUgJiYgaSA8 IE5WSE9TVF9NT0RVTEVfTUFYX0NMT0NLUykgewo+ICsJCWxvbmcgcmF0ZSA9IHBkYXRhLT5jbG9j a3NbaV0uZGVmYXVsdF9yYXRlOwo+ICsJCXN0cnVjdCBjbGsgKmM7Cj4gKwo+ICsJCWMgPSBkZXZt X2Nsa19nZXQoJmRldi0+ZGV2LCBwZGF0YS0+Y2xvY2tzW2ldLm5hbWUpOwo+ICsJCWlmIChJU19F UlJfT1JfTlVMTChjKSkgewo+ICsJCQlkZXZfZXJyKCZkZXYtPmRldiwgIkNhbm5vdCBnZXQgY2xv Y2sgJXNcbiIsCj4gKwkJCQkJcGRhdGEtPmNsb2Nrc1tpXS5uYW1lKTsKPiArCQkJcmV0dXJuIC1F Tk9ERVY7Cj4gKwkJfQo+ICsKPiArCQlyYXRlID0gY2xrX3JvdW5kX3JhdGUoYywgcmF0ZSk7Cj4g KwkJY2xrX3ByZXBhcmVfZW5hYmxlKGMpOwo+ICsJCWNsa19zZXRfcmF0ZShjLCByYXRlKTsKPiAr CQljbGtfZGlzYWJsZV91bnByZXBhcmUoYyk7Cj4gKwkJcGRhdGEtPmNsa1tpXSA9IGM7Cj4gKwkJ aSsrOwo+ICsJfQo+ICsJcGRhdGEtPm51bV9jbGtzID0gaTsKPiArCj4gKwltdXRleF9pbml0KCZw ZGF0YS0+bG9jayk7Cj4gKwlpbml0X3dhaXRxdWV1ZV9oZWFkKCZwZGF0YS0+aWRsZV93cSk7Cj4g KwlJTklUX0RFTEFZRURfV09SSygmcGRhdGEtPnBvd2Vyc3RhdGVfZG93biwgcG93ZXJzdGF0ZV9k b3duX2hhbmRsZXIpOwo+ICsKPiArCS8qIHBvd2VyIGdhdGUgdW5pdHMgdGhhdCB3ZSBjYW4gcG93 ZXIgZ2F0ZSAqLwo+ICsJaWYgKHBkYXRhLT5jYW5fcG93ZXJnYXRlKSB7Cj4gKwkJZG9fcG93ZXJn YXRlX2xvY2tlZChwZGF0YS0+cG93ZXJnYXRlX2lkc1swXSk7Cj4gKwkJZG9fcG93ZXJnYXRlX2xv Y2tlZChwZGF0YS0+cG93ZXJnYXRlX2lkc1sxXSk7CgpTZWVtcyB3ZSBkb24ndCBzZXQgdGhlc2Ug MiBwb3dlcmdhdGVfaWRzLiBEb2VzIHRoaXMgbWVhbiB3ZSBoYXZlIG5vdAplbmFibGVkIHBvd2Vy IG1hbmFnZW1lbnQgZmVhdHVyZSBpbiB0aGlzIHZlcnNpb24/CgpbLi4uXQo+ICsKPiAraW50IG52 aG9zdF9tb2R1bGVfc3VzcGVuZChzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpkZXYpCj4gK3sKPiAr CWludCByZXQ7Cj4gKwlzdHJ1Y3QgbnZob3N0X2RldmljZV9kYXRhICpwZGF0YSA9IHBsYXRmb3Jt X2dldF9kcnZkYXRhKGRldik7Cj4gKwo+ICsJcmV0ID0gd2FpdF9ldmVudF90aW1lb3V0KHBkYXRh LT5pZGxlX3dxLCBpc19tb2R1bGVfaWRsZShkZXYpLAo+ICsJCQlBQ01fU1VTUEVORF9XQUlUX0ZP Ul9JRExFX1RJTUVPVVQpOwo+ICsJaWYgKHJldCA9PSAwKSB7Cj4gKwkJZGV2X2luZm8oJmRldi0+ ZGV2LCAiJXMgcHJldmVudGVkIHN1c3BlbmRcbiIsCj4gKwkJCQlkZXZfbmFtZSgmZGV2LT5kZXYp KTsKPiArCQlyZXR1cm4gLUVCVVNZOwo+ICsJfQo+ICsKCkknbSBub3Qgc3VyZSB3aGV0aGVyIHRo ZXJlIGlzIGEgcmFjZSBjb25kaXRpb24gaGVyZS4gV2Ugd2FpdCB1bnRpbCB0aGlzCm1vZHVsZSBp cyBpZGxlKHJlZmNvdW50ID09IDApLCB0aGVuIHRyeSB0byBwb3dlcmdhdGUgaXQgbmV4dC4gQnV0 IHRoZQp3YWl0IHF1ZXVlIGZ1bmN0aW9uICJwb3dlcnN0YXRlX2Rvd25faGFuZGxlciIgbWlnaHQg YWxyZWFkeSBwb3dlcmdhdGUKaXQuIFNvIHdlIG5lZWQgdG8gZWl0aGVyICAiY2FuY2VsX2RlbGF5 ZWRfd29yaygmcGRhdGUtPnBvd2Vyc3RhdGVfZG93bikiCmJlZm9yZSB3YWl0aW5nIHRoZSBtb2R1 bGUgdG8gaWRsZSBzdGF0ZSBvciBhZGQgc29tZSBwcm90ZWN0aW9uIGNvZGVzIGluCiJ0b19zdGF0 ZV9wb3dlcmdhdGVkX2xvY2tlZCIuCgo+ICsJbXV0ZXhfbG9jaygmcGRhdGEtPmxvY2spOwo+ICsJ Y2FuY2VsX2RlbGF5ZWRfd29yaygmcGRhdGEtPnBvd2Vyc3RhdGVfZG93bik7Cj4gKwl0b19zdGF0 ZV9wb3dlcmdhdGVkX2xvY2tlZChkZXYpOwo+ICsJbXV0ZXhfdW5sb2NrKCZwZGF0YS0+bG9jayk7 Cj4gKwo+ICsJaWYgKHBkYXRhLT5zdXNwZW5kX25kZXYpCj4gKwkJcGRhdGEtPnN1c3BlbmRfbmRl dihkZXYpOwo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwpbLi4uXQo+ICsKPiAraW50IG52aG9z dF9zeW5jcHRfaW5pdChzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpkZXYsCj4gKwkJc3RydWN0IG52 aG9zdF9zeW5jcHQgKnNwKQo+ICt7Cj4gKwlpbnQgaTsKPiArCXN0cnVjdCBudmhvc3RfbWFzdGVy ICpob3N0ID0gc3luY3B0X3RvX2RldihzcCk7Cj4gKwlpbnQgZXJyID0gMDsKPiArCj4gKwkvKiBB bGxvY2F0ZSBzdHJ1Y3RzIGZvciBtaW4sIG1heCBhbmQgYmFzZSB2YWx1ZXMgKi8KPiArCXNwLT5t aW5fdmFsID0ga3phbGxvYyhzaXplb2YoYXRvbWljX3QpICogbnZob3N0X3N5bmNwdF9uYl9wdHMo c3ApLAo+ICsJCQlHRlBfS0VSTkVMKTsKPiArCXNwLT5tYXhfdmFsID0ga3phbGxvYyhzaXplb2Yo YXRvbWljX3QpICogbnZob3N0X3N5bmNwdF9uYl9wdHMoc3ApLAo+ICsJCQlHRlBfS0VSTkVMKTsK PiArCXNwLT5iYXNlX3ZhbCA9IGt6YWxsb2Moc2l6ZW9mKHUzMikgKiBudmhvc3Rfc3luY3B0X25i X2Jhc2VzKHNwKSwKPiArCQkJR0ZQX0tFUk5FTCk7Cj4gKwlzcC0+bG9ja19jb3VudHMgPQo+ICsJ CWt6YWxsb2Moc2l6ZW9mKGF0b21pY190KSAqIG52aG9zdF9zeW5jcHRfbmJfbWxvY2tzKHNwKSwK PiArCQkJR0ZQX0tFUk5FTCk7Cj4gKwo+ICsJaWYgKCEoc3AtPm1pbl92YWwgJiYgc3AtPm1heF92 YWwgJiYgc3AtPmJhc2VfdmFsICYmIHNwLT5sb2NrX2NvdW50cykpIHsKPiArCQkvKiBmcmVlcyBo YXBwZW4gaW4gdGhlIGRlaW5pdCAqLwo+ICsJCWVyciA9IC1FTk9NRU07Cj4gKwkJZ290byBmYWls Owo+ICsJfQo+ICsKPiArCXNwLT5rb2JqID0ga29iamVjdF9jcmVhdGVfYW5kX2FkZCgic3luY3B0 IiwgJmRldi0+ZGV2LmtvYmopOwo+ICsJaWYgKCFzcC0+a29iaikgewo+ICsJCWVyciA9IC1FSU87 Cj4gKwkJZ290byBmYWlsOwo+ICsJfQo+ICsKPiArCS8qIEFsbG9jYXRlIHR3byBhdHRyaWJ1dGVz IGZvciBlYWNoIHN5bmMgcG9pbnQ6IG1pbiBhbmQgbWF4ICovCj4gKwlzcC0+c3luY3B0X2F0dHJz ID0ga3phbGxvYyhzaXplb2YoKnNwLT5zeW5jcHRfYXR0cnMpCj4gKwkJCSogbnZob3N0X3N5bmNw dF9uYl9wdHMoc3ApICogMiwgR0ZQX0tFUk5FTCk7Cj4gKwlpZiAoIXNwLT5zeW5jcHRfYXR0cnMp IHsKPiArCQllcnIgPSAtRU5PTUVNOwo+ICsJCWdvdG8gZmFpbDsKPiArCX0KPiArCj4gKwkvKiBG aWxsIGluIHRoZSBhdHRyaWJ1dGVzICovCj4gKwlmb3IgKGkgPSAwOyBpIDwgbnZob3N0X3N5bmNw dF9uYl9wdHMoc3ApOyBpKyspIHsKPiArCQljaGFyIG5hbWVbTUFYX1NZTkNQVF9MRU5HVEhdOwo+ ICsJCXN0cnVjdCBrb2JqZWN0ICprb2JqOwo+ICsJCXN0cnVjdCBudmhvc3Rfc3luY3B0X2F0dHIg Km1pbiA9ICZzcC0+c3luY3B0X2F0dHJzW2kqMl07Cj4gKwkJc3RydWN0IG52aG9zdF9zeW5jcHRf YXR0ciAqbWF4ID0gJnNwLT5zeW5jcHRfYXR0cnNbaSoyKzFdOwo+ICsKPiArCQkvKiBDcmVhdGUg b25lIGRpcmVjdG9yeSBwZXIgc3luYyBwb2ludCAqLwo+ICsJCXNucHJpbnRmKG5hbWUsIHNpemVv ZihuYW1lKSwgIiVkIiwgaSk7Cj4gKwkJa29iaiA9IGtvYmplY3RfY3JlYXRlX2FuZF9hZGQobmFt ZSwgc3AtPmtvYmopOwoKV2hlcmUgZG8gd2UgImtvYmplY3RfcHV0IiB0aGlzIGtvYmo/CgpbLi4u XQo+ICsJCWlmICgha29iaikgewo+ICsJCQllcnIgPSAtRUlPOwo+ICsJCQlnb3RvIGZhaWw7Cj4g KwkJfQo+ICsKPiArCQltaW4tPmlkID0gaTsKPiArCQltaW4tPmhvc3QgPSBob3N0Owo+ICsJCW1p bi0+YXR0ci5hdHRyLm5hbWUgPSBtaW5fbmFtZTsKPiArCQltaW4tPmF0dHIuYXR0ci5tb2RlID0g U19JUlVHTzsKPiArCQltaW4tPmF0dHIuc2hvdyA9IHN5bmNwdF9taW5fc2hvdzsKPiArCQlpZiAo c3lzZnNfY3JlYXRlX2ZpbGUoa29iaiwgJm1pbi0+YXR0ci5hdHRyKSkgewo+ICsJCQllcnIgPSAt RUlPOwo+ICsJCQlnb3RvIGZhaWw7Cj4gKwkJfQo+ICsKPiArCQltYXgtPmlkID0gaTsKPiArCQlt YXgtPmhvc3QgPSBob3N0Owo+ICsJCW1heC0+YXR0ci5hdHRyLm5hbWUgPSBtYXhfbmFtZTsKPiAr CQltYXgtPmF0dHIuYXR0ci5tb2RlID0gU19JUlVHTzsKPiArCQltYXgtPmF0dHIuc2hvdyA9IHN5 bmNwdF9tYXhfc2hvdzsKPiArCQlpZiAoc3lzZnNfY3JlYXRlX2ZpbGUoa29iaiwgJm1heC0+YXR0 ci5hdHRyKSkgewo+ICsJCQllcnIgPSAtRUlPOwo+ICsJCQlnb3RvIGZhaWw7Cj4gKwkJfQo+ICsJ fQo+ICsKPiArCXJldHVybiBlcnI7Cj4gKwo+ICtmYWlsOgo+ICsJbnZob3N0X3N5bmNwdF9kZWlu aXQoc3ApOwo+ICsJcmV0dXJuIGVycjsKPiArfQo+ICsKWy4uLl0KPiArLyogcHVibGljIGhvc3Qx eCBzeW5jLXBvaW50IG1hbmFnZW1lbnQgQVBJcyAqLwo+ICt1MzIgaG9zdDF4X3N5bmNwdF9pbmNy X21heCh1MzIgaWQsIHUzMiBpbmNycyk7Cj4gK3ZvaWQgaG9zdDF4X3N5bmNwdF9pbmNyKHUzMiBp ZCk7Cj4gK3UzMiBob3N0MXhfc3luY3B0X3JlYWQodTMyIGlkKTsKPiArCj4gKyNlbmRpZgo+IApf X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwg bWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cDovL2xpc3Rz LmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752720Ab2K2JLG (ORCPT ); Thu, 29 Nov 2012 04:11:06 -0500 Received: from mail-pb0-f46.google.com ([209.85.160.46]:53856 "EHLO mail-pb0-f46.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751369Ab2K2JK6 (ORCPT ); Thu, 29 Nov 2012 04:10:58 -0500 Message-ID: <50B72696.3030205@gmail.com> Date: Thu, 29 Nov 2012 17:10:46 +0800 From: Mark Zhang User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:17.0) Gecko/17.0 Thunderbird/17.0 MIME-Version: 1.0 To: Terje Bergstrom CC: thierry.reding@avionic-design.de, linux-tegra@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org Subject: Re: [RFC,v2,1/8] video: tegra: Add nvhost driver References: <1353935954-13763-2-git-send-email-tbergstrom@nvidia.com> In-Reply-To: <1353935954-13763-2-git-send-email-tbergstrom@nvidia.com> Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On 11/26/2012 09:19 PM, Terje Bergström wrote: > Add nvhost, the driver for host1x. This patch adds support for reading and > incrementing sync points and dynamic power management. > > Signed-off-by: Terje Bergstrom > > --- > drivers/video/Kconfig | 2 + > drivers/video/Makefile | 2 + > drivers/video/tegra/host/Kconfig | 5 + > drivers/video/tegra/host/Makefile | 10 + > drivers/video/tegra/host/chip_support.c | 48 ++ > drivers/video/tegra/host/chip_support.h | 52 +++ > drivers/video/tegra/host/dev.c | 96 ++++ > drivers/video/tegra/host/host1x/Makefile | 7 + > drivers/video/tegra/host/host1x/host1x.c | 204 +++++++++ > drivers/video/tegra/host/host1x/host1x.h | 78 ++++ > drivers/video/tegra/host/host1x/host1x01.c | 37 ++ > drivers/video/tegra/host/host1x/host1x01.h | 29 ++ > .../video/tegra/host/host1x/host1x01_hardware.h | 36 ++ > drivers/video/tegra/host/host1x/host1x_syncpt.c | 156 +++++++ > drivers/video/tegra/host/host1x/hw_host1x01_sync.h | 398 ++++++++++++++++ > drivers/video/tegra/host/nvhost_acm.c | 481 ++++++++++++++++++++ > drivers/video/tegra/host/nvhost_acm.h | 45 ++ > drivers/video/tegra/host/nvhost_syncpt.c | 333 ++++++++++++++ > drivers/video/tegra/host/nvhost_syncpt.h | 136 ++++++ > include/linux/nvhost.h | 143 ++++++ > 20 files changed, 2298 insertions(+) [...] > diff --git a/drivers/video/tegra/host/chip_support.c b/drivers/video/tegra/host/chip_support.c > +#include "chip_support.h" > +#include "host1x/host1x01.h" > + > +struct nvhost_chip_support *nvhost_chip_ops; > + > +struct nvhost_chip_support *nvhost_get_chip_ops(void) > +{ > + return nvhost_chip_ops; > +} If you wanna hide "nvhost_chip_ops" from other source files, declare it as "static". So this is not a static member which means other files is able to touch it by "extern" but we also define a function to get it, and this looks redundant. [...] > diff --git a/drivers/video/tegra/host/host1x/Makefile b/drivers/video/tegra/host/host1x/Makefile > new file mode 100644 > index 0000000..330d507 > --- /dev/null > +++ b/drivers/video/tegra/host/host1x/Makefile > @@ -0,0 +1,7 @@ > +ccflags-y = -Idrivers/video/tegra/host > + > +nvhost-host1x-objs = \ > + host1x.o \ > + host1x01.o Can we rename this "host1x01.c"? I just really don't like this kind of variables/files, I mean, I can't imagine the purpose of the file according to it's name... [...] > + > +static int __devinit nvhost_alloc_resources(struct nvhost_master *host) > +{ > + int err; > + > + err = nvhost_init_chip_support(host); > + if (err) > + return err; > + > + return 0; > +} Just "return nvhost_init_chip_support(host)" is enough. If so, do we still need this function? [...] > + > +static int __devinit nvhost_probe(struct platform_device *dev) > + [...] > + dev_info(&dev->dev, "initialized\n"); > + > + return 0; > + > +fail: Add more "free" codes here. Actually, "nvhost_free_resources" frees the host->intr.syncpt which is not needed to free manually. Seems at least we need to add "nvhost_syncpt_deinit" here. [...] > + > +static struct of_device_id host1x_match[] __devinitdata = { > + { .compatible = "nvidia,tegra20-host1x", }, > + { .compatible = "nvidia,tegra30-host1x", }, Again, place tegra30-host1x before tegra20-host1x. [...] > + > +/** > + * Write a cpu syncpoint increment to the hardware, without touching > + * the cache. Caller is responsible for host being powered. > + */ > +static void host1x_syncpt_cpu_incr(struct nvhost_syncpt *sp, u32 id) > +{ > + struct nvhost_master *dev = syncpt_to_dev(sp); > + u32 reg_offset = id / 32; > + > + if (!nvhost_module_powered(dev->dev)) { > + dev_err(&syncpt_to_dev(sp)->dev->dev, > + "Trying to access host1x when it's off"); > + return; > + } > + > + if (!nvhost_syncpt_client_managed(sp, id) > + && nvhost_syncpt_min_eq_max(sp, id)) { > + dev_err(&syncpt_to_dev(sp)->dev->dev, > + "Trying to increment syncpoint id %d beyond max\n", > + id); > + return; > + } > + writel(BIT_MASK(id), dev->sync_aperture + > + host1x_sync_syncpt_cpu_incr_r() + reg_offset * 4); I have a stupid question: According to the name and the context of this function, seems it increases the syncpt value which specified by param "id". So how does this "writel" increase the value? I don't know much about host1x/syncpt reg operations, so could you explain a little bit or I just completely have a wrong understanding? [...] > + > +static ssize_t powergate_delay_store(struct kobject *kobj, > + struct kobj_attribute *attr, const char *buf, size_t count) > +{ > + int powergate_delay = 0, ret = 0; > + struct nvhost_device_power_attr *power_attribute = > + container_of(attr, struct nvhost_device_power_attr, > + power_attr[NVHOST_POWER_SYSFS_ATTRIB_POWERGATE_DELAY]); > + struct platform_device *dev = power_attribute->ndev; > + struct nvhost_device_data *pdata = platform_get_drvdata(dev); > + > + if (!pdata->can_powergate) { > + dev_info(&dev->dev, "does not support power-gating\n"); > + return count; > + } > + > + mutex_lock(&pdata->lock); > + ret = sscanf(buf, "%d", &powergate_delay); > + if (ret == 1 && powergate_delay >= 0) > + pdata->powergate_delay = powergate_delay; > + else > + dev_err(&dev->dev, "Invalid powergate delay\n"); > + mutex_unlock(&pdata->lock); > + > + return count; Why we need to return an unchanged param? Seems param "count" doesn't make sense here. [...] > + > +int nvhost_module_init(struct platform_device *dev) > +{ > + int i = 0, err = 0; > + struct kobj_attribute *attr = NULL; > + struct nvhost_device_data *pdata = platform_get_drvdata(dev); > + > + /* initialize clocks to known state */ > + while (pdata->clocks[i].name && i < NVHOST_MODULE_MAX_CLOCKS) { > + long rate = pdata->clocks[i].default_rate; > + struct clk *c; > + > + c = devm_clk_get(&dev->dev, pdata->clocks[i].name); > + if (IS_ERR_OR_NULL(c)) { > + dev_err(&dev->dev, "Cannot get clock %s\n", > + pdata->clocks[i].name); > + return -ENODEV; > + } > + > + rate = clk_round_rate(c, rate); > + clk_prepare_enable(c); > + clk_set_rate(c, rate); > + clk_disable_unprepare(c); > + pdata->clk[i] = c; > + i++; > + } > + pdata->num_clks = i; > + > + mutex_init(&pdata->lock); > + init_waitqueue_head(&pdata->idle_wq); > + INIT_DELAYED_WORK(&pdata->powerstate_down, powerstate_down_handler); > + > + /* power gate units that we can power gate */ > + if (pdata->can_powergate) { > + do_powergate_locked(pdata->powergate_ids[0]); > + do_powergate_locked(pdata->powergate_ids[1]); Seems we don't set these 2 powergate_ids. Does this mean we have not enabled power management feature in this version? [...] > + > +int nvhost_module_suspend(struct platform_device *dev) > +{ > + int ret; > + struct nvhost_device_data *pdata = platform_get_drvdata(dev); > + > + ret = wait_event_timeout(pdata->idle_wq, is_module_idle(dev), > + ACM_SUSPEND_WAIT_FOR_IDLE_TIMEOUT); > + if (ret == 0) { > + dev_info(&dev->dev, "%s prevented suspend\n", > + dev_name(&dev->dev)); > + return -EBUSY; > + } > + I'm not sure whether there is a race condition here. We wait until this module is idle(refcount == 0), then try to powergate it next. But the wait queue function "powerstate_down_handler" might already powergate it. So we need to either "cancel_delayed_work(&pdate->powerstate_down)" before waiting the module to idle state or add some protection codes in "to_state_powergated_locked". > + mutex_lock(&pdata->lock); > + cancel_delayed_work(&pdata->powerstate_down); > + to_state_powergated_locked(dev); > + mutex_unlock(&pdata->lock); > + > + if (pdata->suspend_ndev) > + pdata->suspend_ndev(dev); > + > + return 0; > +} > + [...] > + > +int nvhost_syncpt_init(struct platform_device *dev, > + struct nvhost_syncpt *sp) > +{ > + int i; > + struct nvhost_master *host = syncpt_to_dev(sp); > + int err = 0; > + > + /* Allocate structs for min, max and base values */ > + sp->min_val = kzalloc(sizeof(atomic_t) * nvhost_syncpt_nb_pts(sp), > + GFP_KERNEL); > + sp->max_val = kzalloc(sizeof(atomic_t) * nvhost_syncpt_nb_pts(sp), > + GFP_KERNEL); > + sp->base_val = kzalloc(sizeof(u32) * nvhost_syncpt_nb_bases(sp), > + GFP_KERNEL); > + sp->lock_counts = > + kzalloc(sizeof(atomic_t) * nvhost_syncpt_nb_mlocks(sp), > + GFP_KERNEL); > + > + if (!(sp->min_val && sp->max_val && sp->base_val && sp->lock_counts)) { > + /* frees happen in the deinit */ > + err = -ENOMEM; > + goto fail; > + } > + > + sp->kobj = kobject_create_and_add("syncpt", &dev->dev.kobj); > + if (!sp->kobj) { > + err = -EIO; > + goto fail; > + } > + > + /* Allocate two attributes for each sync point: min and max */ > + sp->syncpt_attrs = kzalloc(sizeof(*sp->syncpt_attrs) > + * nvhost_syncpt_nb_pts(sp) * 2, GFP_KERNEL); > + if (!sp->syncpt_attrs) { > + err = -ENOMEM; > + goto fail; > + } > + > + /* Fill in the attributes */ > + for (i = 0; i < nvhost_syncpt_nb_pts(sp); i++) { > + char name[MAX_SYNCPT_LENGTH]; > + struct kobject *kobj; > + struct nvhost_syncpt_attr *min = &sp->syncpt_attrs[i*2]; > + struct nvhost_syncpt_attr *max = &sp->syncpt_attrs[i*2+1]; > + > + /* Create one directory per sync point */ > + snprintf(name, sizeof(name), "%d", i); > + kobj = kobject_create_and_add(name, sp->kobj); Where do we "kobject_put" this kobj? [...] > + if (!kobj) { > + err = -EIO; > + goto fail; > + } > + > + min->id = i; > + min->host = host; > + min->attr.attr.name = min_name; > + min->attr.attr.mode = S_IRUGO; > + min->attr.show = syncpt_min_show; > + if (sysfs_create_file(kobj, &min->attr.attr)) { > + err = -EIO; > + goto fail; > + } > + > + max->id = i; > + max->host = host; > + max->attr.attr.name = max_name; > + max->attr.attr.mode = S_IRUGO; > + max->attr.show = syncpt_max_show; > + if (sysfs_create_file(kobj, &max->attr.attr)) { > + err = -EIO; > + goto fail; > + } > + } > + > + return err; > + > +fail: > + nvhost_syncpt_deinit(sp); > + return err; > +} > + [...] > +/* public host1x sync-point management APIs */ > +u32 host1x_syncpt_incr_max(u32 id, u32 incrs); > +void host1x_syncpt_incr(u32 id); > +u32 host1x_syncpt_read(u32 id); > + > +#endif >