From mboxrd@z Thu Jan 1 00:00:00 1970 From: Heiko Stuebner Subject: Re: [PATCH v2 2/3] soc: rockchip: add driver handling grf setup Date: Wed, 16 Nov 2016 10:58:13 +0100 Message-ID: <5037506.GEHFh4fruS@phil> References: <20161115223900.30728-1-heiko@sntech.de> <20161115223900.30728-3-heiko@sntech.de> <95cd052e-7e0d-d13b-fedb-21f7b49d17bb@rock-chips.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <95cd052e-7e0d-d13b-fedb-21f7b49d17bb-TNX95d0MmH7DzftRWevZcw@public.gmane.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Linux-rockchip" Errors-To: linux-rockchip-bounces+glpar-linux-rockchip=m.gmane.org-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r@public.gmane.org To: Shawn Lin Cc: olof-nZhT3qVonbNeoWH0uzbU5w@public.gmane.org, linux-rockchip-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r@public.gmane.org, arnd-r2nGTMty4D4@public.gmane.org, dianders-F7+t8E8rja9g9hUCZPvPmw@public.gmane.org, linux-arm-kernel-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r@public.gmane.org List-Id: linux-rockchip.vger.kernel.org SGkgU2hhd24sCgpBbSBNaXR0d29jaCwgMTYuIE5vdmVtYmVyIDIwMTYsIDE3OjMzOjIxIENFVCBz Y2hyaWViIFNoYXduIExpbjoKPiDlnKggMjAxNi8xMS8xNiA2OjM4LCBIZWlrbyBTdHVlYm5lciDl hpnpgZM6Cj4gPiBUaGUgR2VuZXJhbCBSZWdpc3RlciBGaWxlcyBhcmUgYW4gYXJlYSBvZiByZWdp c3RlcnMgY29udGFpbmluZyBhIGxvdAo+ID4gb2Ygc2luZ2xlLWJpdCBzZXR0aW5ncyBmb3IgbnVt ZXJvdXMgY29tcG9uZW50cyBhcyB3ZWxsIGZ1bGwgY29tcG9uZW50cwo+ID4gbGlrZSB1c2JwaHkg Y29udHJvbC4gVGhlcmVmb3JlIGFsbCB1c2VkIGNvbXBvbmVudHMgYXJlIGFjY2Vzc2VkCj4gPiB2 aWEgdGhlIHN5c2NvbiBwcm92aWRlZCBieSB0aGUgZ3JmIG5vZGVzIG9yIGZyb20gdGhlIHN1Yi1k ZXZpY2VzCj4gPiBjcmVhdGVkIHRocm91Z2ggdGhlIHNpbXBsZS1tZmQgY3JlYXRlZCBmcm9tIHRo ZSBncmYgbm9kZS4KPiA+IAo+ID4gU29tZSBzZXR0aW5ncyBhcmUgbm90IHVzZWQgYnkgYW55dGhp bmcgYnV0IHdpbGwgbmVlZCB0byBiZSBzZXQgdXAKPiA+IGFjY29yZGluZyB0byBleHBlY3RhdGlv bnMgb24gdGhlIGtlcm5lbCBzaWRlLgo+ID4gCj4gPiBCZXN0IGV4YW1wbGUgaXMgdGhlIGZvcmNl X2p0YWcgc2V0dGluZywgd2hpY2ggZGVmYXVsdHMgdG8gb24gYW5kCj4gPiByZXN1bHRzIGluIHRo ZSBzb2Mgc3dpdGNoaW5nIHRoZSBwaW4tb3V0cHV0cyBiZXR3ZWVuIGp0YWcgYW5kIHNkbW1jCj4g PiBhdXRvbWF0aWNhbGx5IGRlcGVuZGluZyBvbiB0aGUgY2FyZC1kZXRlY3Qgc3RhdHVzLiBUaGlz IGNvbmZsaWN0cwo+ID4gaGVhdmlseSB3aXRoIGhvdyB0aGUgZHdfbW1jIGRyaXZlciBleHBlY3Rz IHRvIGRvIGl0cyB3b3JrIGFuZCBhbHNvCj4gPiB3aXRoIHRoZSBjbG9jay1jb250cm9sbGVyLCB3 aGljaCBoYXMgbW9zdCBsaWtlbHkgZGVhY3RpdmF0ZWQgdGhlCj4gPiBqdGFnIGNsb2NrIGR1ZSB0 byBpdCBiZWluZyB1bnVzZWQuCj4gCj4gSSBoYXRlIGZvcmNlX2p0YWcgcGVyc29uYWxseS4uLiA6 KQoKeWVwLCBJIHN0aWxsIHJlbWVtYmVyIHdoZW4gd2UgaGFkIHN0cmFuZ2UgbW1jIGVycm9ycyB3 aGljaCBzaW1wbHkgY2FtZSBmcm9tIAp0aGUgc29jIHN3aXRjaGluZyBhd2F5IGZyb20gdGhlIG1t YyBmdW5jdGlvbiBiZWZvcmUgdGhlIG1tYyBkcml2ZXIgd2FzCmZpbmlzaGVkLCBzbyBJIGFsc28g ZmluZCB0aGF0IGZ1bmN0aW9uYWxpdHkgdW5oZWxwZnVsIDstKSAuCgo+ID4gU28gZmFyIHRoZSBo YW5kbGluZyBvZiB0aGlzIHNldHRpbmcgd2FzIGxpdmluZyBpbiB0aGUgbWFjaC1yb2NrY2hpcAo+ ID4gY29kZSBmb3IgdGhlIGFybTMyLWJhc2VkIHJrMzI4OCBidXQgdGhhdCBvZiBjb3Vyc2UgZG9l c24ndCB3b3JrCj4gPiBmb3IgYXJtNjQgc29jcyBhbmQgd291bGQgYWxzbyBsb29rIHVnbHkgZm9y IGZ1cnRoZXIgYXJtMzIgc29jcy4KPiAKPiB5ZXMsIEkgZGlkIHRoaXMgaW5zaWRlIHRoZSBsb2Fk ZXIuLi4uIHdoZW4gcnVubmluZyBhcm02NAo+IAo+ID4gQWxzbyBhbHdheXMgZGlzYWJsaW5nIHRo aXMgc2V0dGluZyBpcyBxdWl0ZSBzcGVjaWZpYyB0byBsaW51eCBhbmQKPiA+IGl0cyBzdWJzeXN0 ZW1zLCBvdGhlciBvcGVyYXRpbmcgc3lzdGVtcyBtaWdodCBwcmVmZXIgb3RoZXIgc2V0dGluZ3Ms Cj4gPiBzbyB0aGF0IHRoZSBib290bG9hZGVyIGNhbm5vdCByZWFsbHkgc2V0IGEgc2FuZSBkZWZh dWx0IGZvciBhbGwuCj4gPiAKPiA+IFNvIGludHJvZHVjZSBhIHRvcC1sZXZlbCBkcml2ZXIgZm9y IHRoZSBncmYgdGhhdCBoYW5kbGVzIHRoZXNlCj4gPiBzZXR0aW5ncyB0aGF0IG5lZWQgdG8gYmUg YSBjZXJ0YWluIHdheSBidXQgbm9ib2R5IGNhcmVzIGFib3V0Lgo+ID4gCj4gPiBPdGhlciBuZWVk ZWQgc2V0dGluZ3MgbWlnaHQgc3VyZmFjZSBpbiB0aGUgZnV0dXJlIGFuZCBjYW4gdGhlbgo+ID4g YmUgYWRkZWQgaGVyZSwgYnV0IG9ubHkgYXMgYSBsYXN0IG9wdGlvbi4gSWRlYWxseSBnZW5lcmFs IEdSRgo+ID4gc2V0dGluZ3Mgc2hvdWxkIGJlIGhhbmRsZWQgaW4gdGhlIGRyaXZlciBuZWVkaW5n IHRoZW0uCj4gPiAKPiA+IFNpZ25lZC1vZmYtYnk6IEhlaWtvIFN0dWVibmVyIDxoZWlrb0BzbnRl Y2guZGU+Cj4gPiAtLS0KPiA+IAo+ID4gIGRyaXZlcnMvc29jL3JvY2tjaGlwL0tjb25maWcgIHwg IDEwICsrKysKPiA+ICBkcml2ZXJzL3NvYy9yb2NrY2hpcC9NYWtlZmlsZSB8ICAgMSArCj4gPiAg ZHJpdmVycy9zb2Mvcm9ja2NoaXAvZ3JmLmMgICAgfCAxMzQKPiA+ICArKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysgMyBmaWxlcyBjaGFuZ2VkLCAxNDUKPiA+ICBpbnNl cnRpb25zKCspCj4gPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvc29jL3JvY2tjaGlwL2dy Zi5jCj4gPiAKPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3NvYy9yb2NrY2hpcC9LY29uZmlnIGIv ZHJpdmVycy9zb2Mvcm9ja2NoaXAvS2NvbmZpZwo+ID4gaW5kZXggNzE0MGZmOC4uMjBkYTU1ZCAx MDA2NDQKPiA+IC0tLSBhL2RyaXZlcnMvc29jL3JvY2tjaGlwL0tjb25maWcKPiA+ICsrKyBiL2Ry aXZlcnMvc29jL3JvY2tjaGlwL0tjb25maWcKPiA+IEBAIC0zLDYgKzMsMTYgQEAgaWYgQVJDSF9S T0NLQ0hJUCB8fCBDT01QSUxFX1RFU1QKPiA+IAo+ID4gICMKPiA+ICAjIFJvY2tjaGlwIFNvYyBk cml2ZXJzCj4gPiAgIwo+ID4gCj4gPiArCj4gPiArY29uZmlnIFJPQ0tDSElQX0dSRgo+ID4gKwli b29sCj4gPiArCWRlZmF1bHQgeQo+ID4gKwloZWxwCj4gPiArCSAgVGhlIEdlbmVyYWwgUmVnaXN0 ZXIgRmlsZXMgYXJlIGEgY2VudHJhbCBjb21wb25lbnQgcHJvdmlkaW5nCj4gPiArCSAgc3BlY2lh bCBhZGRpdGlvbmFsIHNldHRpbmdzIHJlZ2lzdGVycyBmb3IgYSBsb3Qgb2Ygc29jLWNvbXBvbmVu dHMuCj4gPiArCSAgSW4gYSBsb3Qgb2YgY2FzZXMgdGhlcmUgYWxzbyBuZWVkIHRvIGJlIGRlZmF1 bHQgc2V0dGluZ3MgaW5pdGlhbGl6ZWQKPiA+ICsJICB0byBtYWtlIHNvbWUgb2YgdGhlbSBjb25m b3JtIHRvIGV4cGVjdGF0aW9ucyBvZiB0aGUga2VybmVsLgo+ID4gKwo+ID4gCj4gPiAgY29uZmln IFJPQ0tDSElQX1BNX0RPTUFJTlMKPiA+ICAKPiA+ICAgICAgICAgIGJvb2wgIlJvY2tjaGlwIGdl bmVyaWMgcG93ZXIgZG9tYWluIgo+ID4gICAgICAgICAgZGVwZW5kcyBvbiBQTQo+ID4gCj4gPiBk aWZmIC0tZ2l0IGEvZHJpdmVycy9zb2Mvcm9ja2NoaXAvTWFrZWZpbGUgYi9kcml2ZXJzL3NvYy9y b2NrY2hpcC9NYWtlZmlsZQo+ID4gaW5kZXggM2Q3M2QwNi4uYzg1MWZhMCAxMDA2NDQKPiA+IC0t LSBhL2RyaXZlcnMvc29jL3JvY2tjaGlwL01ha2VmaWxlCj4gPiArKysgYi9kcml2ZXJzL3NvYy9y b2NrY2hpcC9NYWtlZmlsZQo+ID4gQEAgLTEsNCArMSw1IEBACj4gPiAKPiA+ICAjCj4gPiAgIyBS b2NrY2hpcCBTb2MgZHJpdmVycwo+ID4gICMKPiA+IAo+ID4gK29iai0kKENPTkZJR19ST0NLQ0hJ UF9HUkYpICs9IGdyZi5vCj4gPiAKPiA+ICBvYmotJChDT05GSUdfUk9DS0NISVBfUE1fRE9NQUlO UykgKz0gcG1fZG9tYWlucy5vCj4gPiAKPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3NvYy9yb2Nr Y2hpcC9ncmYuYyBiL2RyaXZlcnMvc29jL3JvY2tjaGlwL2dyZi5jCj4gPiBuZXcgZmlsZSBtb2Rl IDEwMDY0NAo+ID4gaW5kZXggMDAwMDAwMC4uMGM4NTQ3NmEKPiA+IC0tLSAvZGV2L251bGwKPiA+ ICsrKyBiL2RyaXZlcnMvc29jL3JvY2tjaGlwL2dyZi5jCj4gPiBAQCAtMCwwICsxLDEzNCBAQAo+ ID4gKy8qCj4gPiArICogUm9ja2NoaXAgR2VuZXJpYyBSZWdpc3RlciBGaWxlcyBzZXR1cAo+ID4g KyAqCj4gPiArICogQ29weXJpZ2h0IChjKSAyMDE2IEhlaWtvIFN0dWVibmVyIDxoZWlrb0BzbnRl Y2guZGU+Cj4gPiArICoKPiA+ICsgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91 IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQo+ID4gKyAqIGl0IHVuZGVyIHRoZSB0 ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCj4gPiAr ICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCj4gPiArICovCj4g PiArCj4gPiArI2luY2x1ZGUgPGxpbnV4L2Vyci5oPgo+ID4gKyNpbmNsdWRlIDxsaW51eC9yZWdt YXAuaD4KPiA+ICsjaW5jbHVkZSA8bGludXgvbWZkL3N5c2Nvbi5oPgo+ID4gKyNpbmNsdWRlIDxs aW51eC9vZl9kZXZpY2UuaD4KPiA+ICsjaW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+ Cj4gPiArI2luY2x1ZGUgPGxpbnV4L3JlZ21hcC5oPgo+IAo+IFRoZSBvcmRlciA6KQoKSSBqdXN0 IG5vdGljZWQgdGhhdCB0aGVyZSBpcyBhIHNlY29uZCBpbmNsdXNpb24gb2YgcmVnbWFwLmggaGVy ZSwgd2hpY2ggY2FuIGdvIAphd2F5LgoKCj4gCj4gPiArCj4gPiArI2RlZmluZSBISVdPUkRfVVBE QVRFKHZhbCwgbWFzaywgc2hpZnQpIFwKPiA+ICsJCSgodmFsKSA8PCAoc2hpZnQpIHwgKG1hc2sp IDw8ICgoc2hpZnQpICsgMTYpKQo+ID4gKwo+ID4gK3N0cnVjdCByb2NrY2hpcF9ncmZfdmFsdWUg ewo+ID4gKwljb25zdCBjaGFyICpkZXNjOwo+ID4gKwl1MzIgcmVnOwo+ID4gKwl1MzIgdmFsOwo+ ID4gK307Cj4gPiArCj4gPiArc3RydWN0IHJvY2tjaGlwX2dyZl9pbmZvIHsKPiA+ICsJY29uc3Qg c3RydWN0IHJvY2tjaGlwX2dyZl92YWx1ZSAqdmFsdWVzOwo+ID4gKwlpbnQgbnVtX3ZhbHVlczsK PiA+ICt9Owo+ID4gKwo+ID4gKyNkZWZpbmUgUkszMDM2X0dSRl9TT0NfQ09OMAkJMHgxNDAKPiA+ ICsKPiA+ICtzdGF0aWMgY29uc3Qgc3RydWN0IHJvY2tjaGlwX2dyZl92YWx1ZSByazMwMzZfZGVm YXVsdHNbXSBfX2luaXRjb25zdCA9IHsKPiA+ICsJLyoKPiA+ICsJICogRGlzYWJsZSBhdXRvIGp0 YWcvc2RtbWMgc3dpdGNoaW5nIHRoYXQgY2F1c2VzIGlzc3VlcyB3aXRoIHRoZQo+ID4gKwkgKiBj bG9jay1mcmFtZXdvcmsgYW5kIHRoZSBtbWMgY29udHJvbGxlcnMgbWFraW5nIHRoZW0gdW5yZWxp YWJsZS4KPiA+ICsJICovCj4gPiArCXsgImp0YWcgc3dpdGNoaW5nIiwgUkszMDM2X0dSRl9TT0Nf Q09OMCwgSElXT1JEX1VQREFURSgwLCAxLCAxMSkgfSwKPiA+ICt9Owo+ID4gKwo+ID4gK3N0YXRp YyBjb25zdCBzdHJ1Y3Qgcm9ja2NoaXBfZ3JmX2luZm8gcmszMDM2X2dyZiBfX2luaXRjb25zdCA9 IHsKPiA+ICsJLnZhbHVlcyA9IHJrMzAzNl9kZWZhdWx0cywKPiA+ICsJLm51bV92YWx1ZXMgPSBB UlJBWV9TSVpFKHJrMzAzNl9kZWZhdWx0cyksCj4gPiArfTsKPiA+ICsKPiA+ICsjZGVmaW5lIFJL MzI4OF9HUkZfU09DX0NPTjAJCTB4MjQ0Cj4gPiArCj4gPiArc3RhdGljIGNvbnN0IHN0cnVjdCBy b2NrY2hpcF9ncmZfdmFsdWUgcmszMjg4X2RlZmF1bHRzW10gX19pbml0Y29uc3QgPSB7Cj4gPiAr CXsgImp0YWcgc3dpdGNoaW5nIiwgUkszMjg4X0dSRl9TT0NfQ09OMCwgSElXT1JEX1VQREFURSgw LCAxLCAxMikgfSwKPiA+ICt9Owo+ID4gKwo+ID4gK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgcm9ja2No aXBfZ3JmX2luZm8gcmszMjg4X2dyZiBfX2luaXRjb25zdCA9IHsKPiA+ICsJLnZhbHVlcyA9IHJr MzI4OF9kZWZhdWx0cywKPiA+ICsJLm51bV92YWx1ZXMgPSBBUlJBWV9TSVpFKHJrMzI4OF9kZWZh dWx0cyksCj4gPiArfTsKPiA+ICsKPiA+ICsjZGVmaW5lIFJLMzM2OF9HUkZfU09DX0NPTjE1CQkw eDQzYwo+ID4gKwo+ID4gK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgcm9ja2NoaXBfZ3JmX3ZhbHVlIHJr MzM2OF9kZWZhdWx0c1tdIF9faW5pdGNvbnN0ID0gewo+ID4gKwl7ICJqdGFnIHN3aXRjaGluZyIs IFJLMzM2OF9HUkZfU09DX0NPTjE1LCBISVdPUkRfVVBEQVRFKDAsIDEsIDEzKSB9LAo+ID4gK307 Cj4gPiArCj4gPiArc3RhdGljIGNvbnN0IHN0cnVjdCByb2NrY2hpcF9ncmZfaW5mbyByazMzNjhf Z3JmIF9faW5pdGNvbnN0ID0gewo+ID4gKwkudmFsdWVzID0gcmszMzY4X2RlZmF1bHRzLAo+ID4g KwkubnVtX3ZhbHVlcyA9IEFSUkFZX1NJWkUocmszMzY4X2RlZmF1bHRzKSwKPiA+ICt9Owo+ID4g Kwo+ID4gKyNkZWZpbmUgUkszMzk5X0dSRl9TT0NfQ09ONwkJMHhlMjFjCj4gPiArCj4gPiArc3Rh dGljIGNvbnN0IHN0cnVjdCByb2NrY2hpcF9ncmZfdmFsdWUgcmszMzk5X2RlZmF1bHRzW10gX19p bml0Y29uc3QgPSB7Cj4gPiArCXsgImp0YWcgc3dpdGNoaW5nIiwgUkszMzk5X0dSRl9TT0NfQ09O NywgSElXT1JEX1VQREFURSgwLCAxLCAxMikgfSwKPiA+ICt9Owo+ID4gKwo+ID4gK3N0YXRpYyBj b25zdCBzdHJ1Y3Qgcm9ja2NoaXBfZ3JmX2luZm8gcmszMzk5X2dyZiBfX2luaXRjb25zdCA9IHsK PiA+ICsJLnZhbHVlcyA9IHJrMzM5OV9kZWZhdWx0cywKPiA+ICsJLm51bV92YWx1ZXMgPSBBUlJB WV9TSVpFKHJrMzM5OV9kZWZhdWx0cyksCj4gPiArfTsKPiA+ICsKPiA+ICtzdGF0aWMgY29uc3Qg c3RydWN0IG9mX2RldmljZV9pZCByb2NrY2hpcF9ncmZfZHRfbWF0Y2hbXSBfX2luaXRjb25zdCA9 IHsKPiA+ICsJewo+ID4gKwkJLmNvbXBhdGlibGUgPSAicm9ja2NoaXAscmszMDM2LWdyZiIsCj4g PiArCQkuZGF0YSA9ICh2b2lkICopJnJrMzAzNl9ncmYsCj4gPiArCX0sIHsKPiA+ICsJCS5jb21w YXRpYmxlID0gInJvY2tjaGlwLHJrMzI4OC1ncmYiLAo+ID4gKwkJLmRhdGEgPSAodm9pZCAqKSZy azMyODhfZ3JmLAo+ID4gKwl9LCB7Cj4gPiArCQkuY29tcGF0aWJsZSA9ICJyb2NrY2hpcCxyazMz NjgtZ3JmIiwKPiA+ICsJCS5kYXRhID0gKHZvaWQgKikmcmszMzY4X2dyZiwKPiA+ICsJfSwgewo+ ID4gKwkJLmNvbXBhdGlibGUgPSAicm9ja2NoaXAscmszMzk5LWdyZiIsCj4gPiArCQkuZGF0YSA9 ICh2b2lkICopJnJrMzM5OV9ncmYsCj4gPiArCX0sCj4gPiArCXsgLyogc2VudGluZWwgKi8gfSwK PiA+ICt9Owo+ID4gKwo+ID4gK3N0YXRpYyBpbnQgX19pbml0IHJvY2tjaGlwX2dyZl9pbml0KHZv aWQpCj4gPiArewo+ID4gKwljb25zdCBzdHJ1Y3Qgcm9ja2NoaXBfZ3JmX2luZm8gKmdyZl9pbmZv Owo+ID4gKwljb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkICptYXRjaDsKPiA+ICsJc3RydWN0IGRl dmljZV9ub2RlICpucDsKPiA+ICsJc3RydWN0IHJlZ21hcCAqZ3JmOwo+ID4gKwlpbnQgcmV0LCBp Owo+ID4gKwo+ID4gKwlucCA9IG9mX2ZpbmRfbWF0Y2hpbmdfbm9kZV9hbmRfbWF0Y2goTlVMTCwg cm9ja2NoaXBfZ3JmX2R0X21hdGNoLAo+ID4gJm1hdGNoKTsgKwlpZiAoIW5wKQo+ID4gKwkJcmV0 dXJuIC1FTk9ERVY7Cj4gPiArCWlmICghbWF0Y2ggfHwgIW1hdGNoLT5kYXRhKSB7Cj4gPiArCQlw cl9lcnIoIiVzOiBtaXNzaW5nIGdyZiBkYXRhXG4iLCBfX2Z1bmNfXyk7Cj4gPiArCQlyZXR1cm4g LUVJTlZBTDsKPiA+ICsJfQo+ID4gKwo+ID4gKwlncmZfaW5mbyA9IG1hdGNoLT5kYXRhOwo+ID4g Kwo+ID4gKwlncmYgPSBzeXNjb25fbm9kZV90b19yZWdtYXAobnApOwo+ID4gKwlpZiAoSVNfRVJS KGdyZikpIHsKPiA+ICsJCXByX2VycigiJXM6IGNvdWxkIG5vdCBnZXQgZ3JmIHN5c2NvblxuIiwg X19mdW5jX18pOwo+ID4gKwkJcmV0dXJuIFBUUl9FUlIoZ3JmKTsKPiA+ICsJfQo+ID4gKwo+ID4g Kwlmb3IgKGkgPSAwOyBpIDwgZ3JmX2luZm8tPm51bV92YWx1ZXM7IGkrKykgewo+ID4gKwkJY29u c3Qgc3RydWN0IHJvY2tjaGlwX2dyZl92YWx1ZSAqdmFsID0gJmdyZl9pbmZvLT52YWx1ZXNbaV07 Cj4gPiArCj4gPiArCQlwcl9kZWJ1ZygiJXM6IGFkanVzdGluZyAlcyBpbiAlIzZ4IHRvICUjMTB4 XG4iLCBfX2Z1bmNfXywKPiA+ICsJCQl2YWwtPmRlc2MsIHZhbC0+cmVnLCB2YWwtPnZhbCk7Cj4g PiArCQlyZXQgPSByZWdtYXBfd3JpdGUoZ3JmLCB2YWwtPnJlZywgdmFsLT52YWwpOwo+ID4gKwkJ aWYgKHJldCA8IDApCj4gPiArCQkJcHJfZXJyKCIlczogd3JpdGUgdG8gJSM2eCBmYWlsZWQgd2l0 aCAlZFxuIiwKPiA+ICsJCQkgICAgICAgX19mdW5jX18sIHZhbC0+cmVnLCByZXQpOwo+IAo+IFNv LCB3aGVuIGZhaWxpbmcgdG8gZG8gb25lIG9mIHRoZSBzZXR0aW5ncywgc2hvdWxkIHdlIHN0aWxs IGxldCBpdCBnb2VzPwo+IFNvbWV0aW1lcyB0aGUgbG9nIG9mIHBvc3Rjb3JlX2luaXRjYWxsIGlz IGVhc3kgdG8gYmUgbmVnbGVjdGVkIHdoZW4KPiBwZW9wbGUgZmluYWxseSBmaW5kIHByb2JsZW1z IGxhdGVyIGJ1dCB0aGUgdmVyeSBlYXJsaWVyIGxvZyB3YXMgbWlzc2luZwo+IGR1ZSB0byB3aGF0 ZXZlciByZWFzb24gbGlrZSBidWZmZXIgbGltaXRhdGlvbiwgZXRjLgoKSSBleHBlY3QgZXJyb3Jz IGhlcmUgdG8gYmUgdmVyeSByYXJlLiBJLmUuIERvdWcgdGhvdWdodCB0aGF0IHJlZ21hcCBtaWdo dCAKcmV0dXJuIGVycm9ycyBpZiB3ZSB3cml0ZSBvdXRzaWRlIHRoZSBtYXBwZWQgcmVnaW9uLCB3 aGljaCB3b3VsZCBtZWFuIHNvbWVvbmUgCnJlYWxseSBtZXNzZWQgdXAgaW4gdGhpcyBjb3JlIGNv bXBvbmVudCBvciBhIGNvcmUtZWxlbWVudCBvZiB0aGUgZHRzLgpCdXQgaW4gZ2VuZXJhbCB0aGUg R1JGIGlzIGFsd2F5cyBhIG1taW8tcmVnbWFwLCBzbyB0aGVyZSB3b24ndCBiZSBhbnkgaTJjL3Nw aS8Kd2hhdGV2ZXIgZXJyb3JzIHBvc3NpYmxlLgoKQWxzbyBzZXR0aW5ncyBhcmUgcHJldHR5IGlu ZGl2aWR1YWwsIHNvIGlmIHNldHRpbmcgMSBmYWlscywgc2V0dGluZyAyIGNhbiAKc3RpbGwgc3Vj Y2VlZCBhbmQgdGhlIGJvb3QgY2FuIGNvbnRpbnVlIHNvbWV3aGF0IGZhcnRoZXIuCgpUaGUgb3Zl cmFsbCB0YXJnZXQgaXMgc3VwcG9zZWQgdG8gYWx3YXlzIGJvb3QgYXMgZmFyIGFzIHBvc3NpYmxl LCBzbyB0aGF0IApwZW9wbGUgbWlnaHQgcmVjb3ZlciBvciBnZXQgbW9yZSBpbmZvcm1hdGlvbiBh bmQgbm90IGZhaWwgKGFuZCBkaWUpIGVhcmx5LgoKCkhlaWtvCgpfX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fXwpMaW51eC1yb2NrY2hpcCBtYWlsaW5nIGxpc3QK TGludXgtcm9ja2NoaXBAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFk Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LXJvY2tjaGlwCg== From mboxrd@z Thu Jan 1 00:00:00 1970 From: heiko@sntech.de (Heiko Stuebner) Date: Wed, 16 Nov 2016 10:58:13 +0100 Subject: [PATCH v2 2/3] soc: rockchip: add driver handling grf setup In-Reply-To: <95cd052e-7e0d-d13b-fedb-21f7b49d17bb@rock-chips.com> References: <20161115223900.30728-1-heiko@sntech.de> <20161115223900.30728-3-heiko@sntech.de> <95cd052e-7e0d-d13b-fedb-21f7b49d17bb@rock-chips.com> Message-ID: <5037506.GEHFh4fruS@phil> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org Hi Shawn, Am Mittwoch, 16. November 2016, 17:33:21 CET schrieb Shawn Lin: > ? 2016/11/16 6:38, Heiko Stuebner ??: > > The General Register Files are an area of registers containing a lot > > of single-bit settings for numerous components as well full components > > like usbphy control. Therefore all used components are accessed > > via the syscon provided by the grf nodes or from the sub-devices > > created through the simple-mfd created from the grf node. > > > > Some settings are not used by anything but will need to be set up > > according to expectations on the kernel side. > > > > Best example is the force_jtag setting, which defaults to on and > > results in the soc switching the pin-outputs between jtag and sdmmc > > automatically depending on the card-detect status. This conflicts > > heavily with how the dw_mmc driver expects to do its work and also > > with the clock-controller, which has most likely deactivated the > > jtag clock due to it being unused. > > I hate force_jtag personally... :) yep, I still remember when we had strange mmc errors which simply came from the soc switching away from the mmc function before the mmc driver was finished, so I also find that functionality unhelpful ;-) . > > So far the handling of this setting was living in the mach-rockchip > > code for the arm32-based rk3288 but that of course doesn't work > > for arm64 socs and would also look ugly for further arm32 socs. > > yes, I did this inside the loader.... when running arm64 > > > Also always disabling this setting is quite specific to linux and > > its subsystems, other operating systems might prefer other settings, > > so that the bootloader cannot really set a sane default for all. > > > > So introduce a top-level driver for the grf that handles these > > settings that need to be a certain way but nobody cares about. > > > > Other needed settings might surface in the future and can then > > be added here, but only as a last option. Ideally general GRF > > settings should be handled in the driver needing them. > > > > Signed-off-by: Heiko Stuebner > > --- > > > > drivers/soc/rockchip/Kconfig | 10 ++++ > > drivers/soc/rockchip/Makefile | 1 + > > drivers/soc/rockchip/grf.c | 134 > > ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 145 > > insertions(+) > > create mode 100644 drivers/soc/rockchip/grf.c > > > > diff --git a/drivers/soc/rockchip/Kconfig b/drivers/soc/rockchip/Kconfig > > index 7140ff8..20da55d 100644 > > --- a/drivers/soc/rockchip/Kconfig > > +++ b/drivers/soc/rockchip/Kconfig > > @@ -3,6 +3,16 @@ if ARCH_ROCKCHIP || COMPILE_TEST > > > > # > > # Rockchip Soc drivers > > # > > > > + > > +config ROCKCHIP_GRF > > + bool > > + default y > > + help > > + The General Register Files are a central component providing > > + special additional settings registers for a lot of soc-components. > > + In a lot of cases there also need to be default settings initialized > > + to make some of them conform to expectations of the kernel. > > + > > > > config ROCKCHIP_PM_DOMAINS > > > > bool "Rockchip generic power domain" > > depends on PM > > > > diff --git a/drivers/soc/rockchip/Makefile b/drivers/soc/rockchip/Makefile > > index 3d73d06..c851fa0 100644 > > --- a/drivers/soc/rockchip/Makefile > > +++ b/drivers/soc/rockchip/Makefile > > @@ -1,4 +1,5 @@ > > > > # > > # Rockchip Soc drivers > > # > > > > +obj-$(CONFIG_ROCKCHIP_GRF) += grf.o > > > > obj-$(CONFIG_ROCKCHIP_PM_DOMAINS) += pm_domains.o > > > > diff --git a/drivers/soc/rockchip/grf.c b/drivers/soc/rockchip/grf.c > > new file mode 100644 > > index 0000000..0c85476a > > --- /dev/null > > +++ b/drivers/soc/rockchip/grf.c > > @@ -0,0 +1,134 @@ > > +/* > > + * Rockchip Generic Register Files setup > > + * > > + * Copyright (c) 2016 Heiko Stuebner > > + * > > + * This program is free software; you can redistribute it and/or modify > > + * it under the terms of the GNU General Public License version 2 as > > + * published by the Free Software Foundation. > > + */ > > + > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > The order :) I just noticed that there is a second inclusion of regmap.h here, which can go away. > > > + > > +#define HIWORD_UPDATE(val, mask, shift) \ > > + ((val) << (shift) | (mask) << ((shift) + 16)) > > + > > +struct rockchip_grf_value { > > + const char *desc; > > + u32 reg; > > + u32 val; > > +}; > > + > > +struct rockchip_grf_info { > > + const struct rockchip_grf_value *values; > > + int num_values; > > +}; > > + > > +#define RK3036_GRF_SOC_CON0 0x140 > > + > > +static const struct rockchip_grf_value rk3036_defaults[] __initconst = { > > + /* > > + * Disable auto jtag/sdmmc switching that causes issues with the > > + * clock-framework and the mmc controllers making them unreliable. > > + */ > > + { "jtag switching", RK3036_GRF_SOC_CON0, HIWORD_UPDATE(0, 1, 11) }, > > +}; > > + > > +static const struct rockchip_grf_info rk3036_grf __initconst = { > > + .values = rk3036_defaults, > > + .num_values = ARRAY_SIZE(rk3036_defaults), > > +}; > > + > > +#define RK3288_GRF_SOC_CON0 0x244 > > + > > +static const struct rockchip_grf_value rk3288_defaults[] __initconst = { > > + { "jtag switching", RK3288_GRF_SOC_CON0, HIWORD_UPDATE(0, 1, 12) }, > > +}; > > + > > +static const struct rockchip_grf_info rk3288_grf __initconst = { > > + .values = rk3288_defaults, > > + .num_values = ARRAY_SIZE(rk3288_defaults), > > +}; > > + > > +#define RK3368_GRF_SOC_CON15 0x43c > > + > > +static const struct rockchip_grf_value rk3368_defaults[] __initconst = { > > + { "jtag switching", RK3368_GRF_SOC_CON15, HIWORD_UPDATE(0, 1, 13) }, > > +}; > > + > > +static const struct rockchip_grf_info rk3368_grf __initconst = { > > + .values = rk3368_defaults, > > + .num_values = ARRAY_SIZE(rk3368_defaults), > > +}; > > + > > +#define RK3399_GRF_SOC_CON7 0xe21c > > + > > +static const struct rockchip_grf_value rk3399_defaults[] __initconst = { > > + { "jtag switching", RK3399_GRF_SOC_CON7, HIWORD_UPDATE(0, 1, 12) }, > > +}; > > + > > +static const struct rockchip_grf_info rk3399_grf __initconst = { > > + .values = rk3399_defaults, > > + .num_values = ARRAY_SIZE(rk3399_defaults), > > +}; > > + > > +static const struct of_device_id rockchip_grf_dt_match[] __initconst = { > > + { > > + .compatible = "rockchip,rk3036-grf", > > + .data = (void *)&rk3036_grf, > > + }, { > > + .compatible = "rockchip,rk3288-grf", > > + .data = (void *)&rk3288_grf, > > + }, { > > + .compatible = "rockchip,rk3368-grf", > > + .data = (void *)&rk3368_grf, > > + }, { > > + .compatible = "rockchip,rk3399-grf", > > + .data = (void *)&rk3399_grf, > > + }, > > + { /* sentinel */ }, > > +}; > > + > > +static int __init rockchip_grf_init(void) > > +{ > > + const struct rockchip_grf_info *grf_info; > > + const struct of_device_id *match; > > + struct device_node *np; > > + struct regmap *grf; > > + int ret, i; > > + > > + np = of_find_matching_node_and_match(NULL, rockchip_grf_dt_match, > > &match); + if (!np) > > + return -ENODEV; > > + if (!match || !match->data) { > > + pr_err("%s: missing grf data\n", __func__); > > + return -EINVAL; > > + } > > + > > + grf_info = match->data; > > + > > + grf = syscon_node_to_regmap(np); > > + if (IS_ERR(grf)) { > > + pr_err("%s: could not get grf syscon\n", __func__); > > + return PTR_ERR(grf); > > + } > > + > > + for (i = 0; i < grf_info->num_values; i++) { > > + const struct rockchip_grf_value *val = &grf_info->values[i]; > > + > > + pr_debug("%s: adjusting %s in %#6x to %#10x\n", __func__, > > + val->desc, val->reg, val->val); > > + ret = regmap_write(grf, val->reg, val->val); > > + if (ret < 0) > > + pr_err("%s: write to %#6x failed with %d\n", > > + __func__, val->reg, ret); > > So, when failing to do one of the settings, should we still let it goes? > Sometimes the log of postcore_initcall is easy to be neglected when > people finally find problems later but the very earlier log was missing > due to whatever reason like buffer limitation, etc. I expect errors here to be very rare. I.e. Doug thought that regmap might return errors if we write outside the mapped region, which would mean someone really messed up in this core component or a core-element of the dts. But in general the GRF is always a mmio-regmap, so there won't be any i2c/spi/ whatever errors possible. Also settings are pretty individual, so if setting 1 fails, setting 2 can still succeed and the boot can continue somewhat farther. The overall target is supposed to always boot as far as possible, so that people might recover or get more information and not fail (and die) early. Heiko