From mboxrd@z Thu Jan 1 00:00:00 1970 From: Trent Piepho Subject: Re: [PATCH v16 6/6] ARM: socfpga: fpga bridge driver support Date: Tue, 14 Jun 2016 21:00:00 +0000 Message-ID: <1465938082.11684.16.camel@rtred1test09.kymeta.local> References: <1454707803-27947-1-git-send-email-atull@opensource.altera.com> <1454707803-27947-7-git-send-email-atull@opensource.altera.com> <1465525089.15779.203.camel@rtred1test09.kymeta.local> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: Content-Language: en-US Content-ID: <43A1C95AC17C9F409E27A3AAEA038FA7@kymetacorp.com> Sender: linux-doc-owner@vger.kernel.org To: atull Cc: Rob Herring , "pantelis.antoniou@konsulko.com" , Moritz Fischer , Josh Cartwright , "gregkh@linuxfoundation.org" , "monstr@monstr.eu" , "michal.simek@xilinx.com" , Pawel Moll , Mark Rutland , Ian Campbell , Kumar Gala , Jonathan Corbet , "linux-kernel@vger.kernel.org" , "devicetree@vger.kernel.org" , "linux-doc@vger.kernel.org" , "delicious.quinoa@gmail.com" , "dinguyen@opensource.altera.com" , Matthew Gerlach List-Id: devicetree@vger.kernel.org T24gTW9uLCAyMDE2LTA2LTEzIGF0IDE0OjM1IC0wNTAwLCBhdHVsbCB3cm90ZToNCj4gPiA+ICsN Cj4gPiA+ICsJLyogQWxsb3cgYnJpZGdlIHRvIGJlIHZpc2libGUgdG8gTDMgbWFzdGVycyBvciBu b3QgKi8NCj4gPiA+ICsJaWYgKHByaXYtPnJlbWFwX21hc2spIHsNCj4gPiA+ICsJCXByaXYtPmwz X3JlbWFwX3ZhbHVlIHw9IEFMVF9MM19SRU1BUF9NUFVaRVJPX01TSzsNCj4gPiANCj4gPiBEb2Vz bid0IHNlZW0gbGlrZSB0aGlzIGJlbG9uZ3MgaGVyZS4gIEkgcmVhbGl6ZSB0aGUgd3JpdGUtb25s eSByZWdpc3Rlcg0KPiA+IGlzIGEgcHJvYmxlbS4gIE1heWJlIHRoZSBzeXNjb24gZHJpdmVyIHNo b3VsZCBiZSBpbml0aWFsaXppbmcgdGhpcw0KPiA+IHZhbHVlPw0KPiA+IA0KPiA+ID4gKw0KPiA+ ID4gKwkJaWYgKGVuYWJsZSkNCj4gPiA+ICsJCQlwcml2LT5sM19yZW1hcF92YWx1ZSB8PSBwcml2 LT5yZW1hcF9tYXNrOw0KPiA+ID4gKwkJZWxzZQ0KPiA+ID4gKwkJCXByaXYtPmwzX3JlbWFwX3Zh bHVlICY9IH5wcml2LT5yZW1hcF9tYXNrOw0KPiA+ID4gKw0KPiA+ID4gKwkJcmV0ID0gcmVnbWFw X3dyaXRlKHByaXYtPmwzcmVnLCBBTFRfTDNfUkVNQVBfT0ZTVCwNCj4gPiA+ICsJCQkJICAgcHJp di0+bDNfcmVtYXBfdmFsdWUpOw0KPiA+IA0KPiA+IFRoaXMgaXNuJ3QgZ29pbmcgd29yayBpZiBt b3JlIHRoYW4gb25lIGJyaWRnZSBpcyB1c2VkLiAgRWFjaCBicmlkZ2UgaGFzDQo+ID4gaXRzIG93 biBwcml2IGFuZCB0aHVzIHByaXYtPmwzX3JlbWFwX3ZhbHVlLiAgRWFjaCBicmlkZ2UncyBwcml2 IHdpbGwNCj4gPiBoYXZlIGp1c3QgdGhlIGJpdCBmb3IgaXQncyBvd24gcmVtYXAgc2V0LiAgVGhl IDJuZCBicmlkZ2UgdG8gYmUgZW5hYmxlZA0KPiA+IHdpbGwgdHVybiBvZmYgdGhlIDFzdCBicmlk Z2Ugd2hlbiBpdCByZS13cml0ZSB0aGUgbDMgcmVnaXN0ZXIuDQo+ID4gDQo+ID4gSWYgYWxsIHRo ZSBicmlkZ2VzIHNoYXJlZCBhIHN0YXRpYyBnbG9iYWwgdG8gY2FjaGUgdGhlIHJlZywgdGhlbiB0 aGlzDQo+ID4gcHJvYmxlbSB3b3VsZCBiZSBhIHJlcGxhY2VkIGJ5IGEgcmFjZSwgc2luY2Ugbm90 aGluZyB3b3VsZCBiZSBtYW5hZ2luZw0KPiA+IGNvbmN1cnJlbnQgYWNjZXNzIHRvIHRoYXQgZ2xv YmFsIGZyb20gdGhlIGluZGVwZW5kZW50IGJyaWRnZSBkZXZpY2VzLg0KPiA+IA0KPiA+IEhvdyBh Ym91dCB1c2luZyB0aGUgYWxyZWFkeSBleGlzdGluZyByZWdtYXAgY2FjaGUgYWJpbGl0eSB0YWtl IGNhcmUgb2YNCj4gPiB0aGlzPyAgVXNlIHJlZ21hcF91cGRhdGVfYml0cygpIHRvIHVwZGF0ZSBq dXN0IHRoZSBkZXNpcmVkIGJpdCBhbmQgbGV0DQo+ID4gcmVtYXAgdGFrZSBjYXJlIG9mIGtlZXBp bmcgdHJhY2sgY2FjaGluZyB0aGUgcmVnaXN0ZXIgYW5kIHByb3RlY3RpbmcNCj4gPiBhY2Nlc3Mg ZnJvbSBtdWx0aXBsZSB1c2Vycy4gIEl0IHNob3VsZCBzdXBwb3J0IHRoYXQgYW5kIGl0IHNob3Vs ZA0KPiA+IHN1cHBvcnQgd3JpdGUtb25seSByZWdpc3RlcnMsIHdpdGggdGhlIGNyZWF0b3Igb2Yg dGhlIHJlZ21hcCAodGhlIHN5c2Nvbg0KPiA+IGRyaXZlciBpbiB0aGlzIGNhc2UpIHN1cHBseWlu ZyB0aGUgaW5pdGlhbCB2YWx1ZSBvZiB0aGUgd3JpdGUtb25seSByZWcuDQo+ID4gV2hpY2ggaXMg d2hlcmUgQUxUX0wzX1JFTUFQX01QVVpFUk9fTVNLIGNvdWxkIGdvIGluLg0KPiANCj4gUGxlYXNl IGNvcnJlY3QgbWUgaWYgSSdtIHdyb25nLCBidXQgSSB0aGluayB0aGF0IHJlZ21hcCBzdXBwb3J0 cw0KPiB0aGUgZmVhdHVyZXMgeW91IGFyZSB0YWxraW5nIGFib3V0LCBidXQgbm90IHN5c2Nvbi4N Cg0KRnJvbSBteSB0ZXN0aW5nLCBpdCB3aWxsIHdvcmsgb2sgaWYgdGhlIHN5c2NvbiBkcml2ZXIg d2VyZSB0byBzZXQNCnN5c2Nvbl9jb25maWcuY2FjaGVfdHlwZSBvbmUgb2YgdGhlIGNhY2hlcy4g IFNpbmNlIHRoZSBsMyByZWdzIHJlYWQgYmFjaw0KYXMgMCwgcmF0aGVyIHRoYW4gbm90IGJlaW5n IHJlYWRhYmxlIGF0IGFsbCwgbWFraW5nIHRoZW0gd3JpdGUtb25seSBhbmQNCmdpdmluZyBhIGRl ZmF1bHQgaXNuJ3Qgc3RyaWN0bHkgbmVjZXNzYXJ5Lg0KDQpJdCB3b3VsZG4ndCBiZSBoYXJkIHRv IGFkZCBhIHdyaXRlLW9ubHkgcHJvcGVydHkgdG8gc3lzY29uLg0KDQo+IE9uZSBzaW1wbGUgc29s dXRpb24gd291bGQgYmUgdG8gdGFrZSBsM19yZW1hcF92YWx1ZSBvdXQgb2YgdGhlIHByaXYNCj4g YW5kIGxldCBpdCBiZSBzaGFyZWQgYnkgYWxsIGgyZiBicmlkZ2VzLiAgVGhhdCBpbnZvbHZlcyB0 aGUgbGVhc3QNCj4gYW1vdW50IG9mIGNoYW5nZS4NCg0KWW91J2xsIG5lZWQgYSBzcGluLWxvY2sg dG8gcHJvdGVjdCBhZ2FpbnN0IGNvbmN1cnJlbnQgYWNjZXNzLg0KDQoNCj4gPiA+ICsNCj4gPiA+ ICtzdGF0aWMgaW50IGFsdF9ocHMyZnBnYV9lbmFibGVfc2V0KHN0cnVjdCBmcGdhX2JyaWRnZSAq YnJpZGdlLCBib29sIGVuYWJsZSkNCj4gPiA+ICt7DQo+ID4gPiArCXJldHVybiBfYWx0X2hwczJm cGdhX2VuYWJsZV9zZXQoYnJpZGdlLT5wcml2LCBlbmFibGUpOw0KPiA+ID4gK30NCj4gPiA+ICsN Cj4gPiA+ICtzdGF0aWMgY29uc3Qgc3RydWN0IGZwZ2FfYnJpZGdlX29wcyBhbHRlcmFfaHBzMmZw Z2FfYnJfb3BzID0gew0KPiA+ID4gKwkuZW5hYmxlX3NldCA9IGFsdF9ocHMyZnBnYV9lbmFibGVf c2V0LA0KPiA+ID4gKwkuZW5hYmxlX3Nob3cgPSBhbHRfaHBzMmZwZ2FfZW5hYmxlX3Nob3csDQo+ ID4gPiArfTsNCj4gPiA+ICsNCj4gPiA+ICtzdGF0aWMgc3RydWN0IGFsdGVyYV9ocHMyZnBnYV9k YXRhIGhwczJmcGdhX2RhdGEgID0gew0KPiA+ID4gKwkubmFtZSA9IEhQUzJGUEdBX0JSSURHRV9O QU1FLA0KPiA+ID4gKwkucmVtYXBfbWFzayA9IEFMVF9MM19SRU1BUF9IMkZfTVNLLA0KPiA+ID4g K307DQo+ID4gDQo+ID4gRWFjaCBvZiB0aGVzZSBkYXRhIHN0cnVjdHMgYWxzbyBpbmNsdWRlcyBz cGFjZSBmb3IgYWxsIHRoZSBwcml2YXRlIGRhdGENCj4gPiBmaWVsZCBvZiB0aGUgZHJpdmVycycg c3RhdGUuICBTZWVtcyBhIGJpdCBpbmVmZmljaWVudCBpZiBvbmx5IHR3byBvZg0KPiA+IHRoZW0g YXJlIGNvbmZpZ3VyYXRpb24gZGF0YS4gIEl0IGFsc28gbWVhbnMgb25seSBvbmUgZGV2aWNlIG9m IGVhY2ggdHlwZQ0KPiA+IGNhbiBleGlzdHMuICBJZiBvbmUgY3JlYXRlcyB0d28gYnJpZGdlcyBv ZiB0aGUgc2FtZSB0eXBlIHRoZXknbGwNCj4gPiAoc2lsZW50bHkpIHNoYXJlIGEgcHJpdiBkYXRh IHN0cnVjdCBhbmQgcmFuZG9tbHkgYnJlYWsuICBBbmQgdGhlIGNvbmZpZw0KPiA+IGRhdGEgc3Ry dWN0cyBjYW4ndCBiZSBjb25zdC4NCj4gDQo+IE91ciBoYXJkd2FyZSBkb2Vzbid0IGNvbnRhaW4g dHdvIGRldmljZXMgb2YgYW55IG9mIHRoZXNlIHRocmVlIHR5cGVzLg0KDQpOb3QgeWV0LCBidXQg ZG9lc24ndCBBcnJpYTEwIGhhdmUgdGhyZWUgRlBHQTJTRFJBTSBicmlkZ2VzPyAgQnV0IHJlYWxs eSwNCml0J3MganVzdCB0aGF0IEkgdGhpbmsgaGF2aW5nIGVhY2ggZGV2aWNlIGFsbG9jYXRlZCBz dGF0ZSBkYXRhIGZvciBqdXN0DQp0aGF0IGRldmljZSBpcyBtb3JlIGluIGxpbmUgd2l0aCB0aGUg TGludXggZGV2aWNlIG1vZGVsIHRoYW4gc2hhcmVkDQpzdGF0aWMgc3RhdGUgcHJlLWFsbG9jYXRl ZCBmb3IgYWxsIGRldmljZXMgb2YgdGhlIHNhbWUgdHlwZSB0byBzaGFyZS4NCiANCj4gPiBXaGF0 IGlmIHRoZXNlIHN0cnVjdHMgd2VyZSBhIGRpZmZlcmVudCBhbHRlcmFfaHBzX2NvbmZpZyBzdHJ1 Y3QsIHdoaWNoDQo+ID4gdGhlIHByaXZhdGUgZGF0YSBzdHJ1Y3QgY291bGQgdGhlbiBjb3B5IG9y IHBvaW50IHRvPw0KPiA+IA0KPiA+IHN0cnVjdCBhbHRlcmFfaHBzYnJpZGdlX2NvbmZpZyB7DQo+ ID4gCWNvbnN0IGNoYXIgKm5hbWU7DQo+ID4gCXVpbnQzMl90IHJlbWFwX21hc2s7DQo+ID4gfTsN Cj4gPiANCj4gPiBzdHJ1Y3QgYWx0ZXJhX2hwc2JyaWRnZV9kYXRhIHsNCj4gPiAJY29uc3Qgc3Ry dWN0IGFsdGVyYV9ocHNicmlkZ2VfY29uZmlnICpjb25maWc7DQo+ID4gCS4uLjsNCj4gPiAJc3Ry dWN0IGNsayAqY2xrOw0KPiA+IH07DQo+IA0KPiBZZXMsIHRoYXQgc291bmRzIGdvb2QgYW5kIHNl bnNpYmxlLiAgSSdsbCBkbyB0aGF0IGluIHYxOC4NCg0KQW5vdGhlciB0aG91Z2h0LCBpZiB0aGUg ImFsdHIsbDNyZWdzIiBiaW5kaW5nIGluY2x1ZGVkIG5vdCBqdXN0IHRoZQ0KcGhhbmRsZSB0byB0 aGUgbDNyZWdzIGRldmljZSwgYnV0IGFsc28gdGhlIGJpdCBhc3NvY2lhdGVkIHdpdGggdGhlDQpi cmlkZ2UsIHRoZW4gdGhlcmUgd291bGRuJ3QgbmVlZCB0byBiZSBicmlkZ2Ugc3BlY2lmaWMgY29u ZmlndXJhdGlvbiBmb3INCnRoZSBkcml2ZXIuICBUaGUgc2FtZSB3YXkgdGhlIHJlc2V0IGFuZCBj bG9jayBwcm9wZXJ0aWVzIHBvaW50IG5vdCBqdXN0DQp0byB0aGUgcmVzZXQgYW5kIGNsb2NrIGNv bnRyb2xsZXIsIGJ1dCB0byB0aGUgYml0IGluIHRoZSBjb250cm9sbGVyLg0KDQo+ID4gPiArDQo+ ID4gPiArc3RhdGljIHN0cnVjdCBhbHRlcmFfaHBzMmZwZ2FfZGF0YSBsd2hwczJmcGdhX2RhdGEg ID0gew0KPiA+ID4gKwkubmFtZSA9IExXSFBTMkZQR0FfQlJJREdFX05BTUUsDQo+ID4gPiArCS5y ZW1hcF9tYXNrID0gQUxUX0wzX1JFTUFQX0xXSDJGX01TSywNCj4gPiA+ICt9Ow0KPiA+ID4gKw0K PiA+ID4gK3N0YXRpYyBzdHJ1Y3QgYWx0ZXJhX2hwczJmcGdhX2RhdGEgZnBnYTJocHNfZGF0YSAg PSB7DQo+ID4gPiArCS5uYW1lID0gRlBHQTJIUFNfQlJJREdFX05BTUUsDQo+ID4gPiArfTsNCj4g PiA+ICsNCj4gPiA+ICtzdGF0aWMgY29uc3Qgc3RydWN0IG9mX2RldmljZV9pZCBhbHRlcmFfZnBn YV9vZl9tYXRjaFtdID0gew0KPiA+ID4gKwl7IC5jb21wYXRpYmxlID0gImFsdHIsc29jZnBnYS1o cHMyZnBnYS1icmlkZ2UiLA0KPiA+ID4gKwkgIC5kYXRhID0gJmhwczJmcGdhX2RhdGEgfSwNCj4g PiA+ICsJeyAuY29tcGF0aWJsZSA9ICJhbHRyLHNvY2ZwZ2EtbHdocHMyZnBnYS1icmlkZ2UiLA0K PiA+ID4gKwkgIC5kYXRhID0gJmx3aHBzMmZwZ2FfZGF0YSB9LA0KPiA+ID4gKwl7IC5jb21wYXRp YmxlID0gImFsdHIsc29jZnBnYS1mcGdhMmhwcy1icmlkZ2UiLA0KPiA+ID4gKwkgIC5kYXRhID0g JmZwZ2EyaHBzX2RhdGEgfSwNCj4gPiA+ICsJe30sDQo+ID4gPiArfTsNCj4gPiA+ICsNCj4gPiA+ ICtzdGF0aWMgaW50IGFsdF9mcGdhX2JyaWRnZV9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNl ICpwZGV2KQ0KPiA+ID4gK3sNCj4gPiA+ICsJc3RydWN0IGRldmljZSAqZGV2ID0gJnBkZXYtPmRl djsNCj4gPiA+ICsJc3RydWN0IGFsdGVyYV9ocHMyZnBnYV9kYXRhICpwcml2Ow0KPiA+ID4gKwlj b25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkICpvZl9pZDsNCj4gPiA+ICsJdTMyIGVuYWJsZTsNCj4g PiA+ICsJaW50IHJldDsNCj4gPiA+ICsNCj4gPiA+ICsJb2ZfaWQgPSBvZl9tYXRjaF9kZXZpY2Uo YWx0ZXJhX2ZwZ2Ffb2ZfbWF0Y2gsIGRldik7DQo+ID4gPiArCXByaXYgPSAoc3RydWN0IGFsdGVy YV9ocHMyZnBnYV9kYXRhICopb2ZfaWQtPmRhdGE7DQo+ID4gPiArDQo+ID4gPiArCXByaXYtPmJy aWRnZV9yZXNldCA9IGRldm1fcmVzZXRfY29udHJvbF9nZXQoZGV2LCBwcml2LT5uYW1lKTsNCj4g PiA+ICsJaWYgKElTX0VSUihwcml2LT5icmlkZ2VfcmVzZXQpKSB7DQo+ID4gPiArCQlkZXZfZXJy KGRldiwgIkNvdWxkIG5vdCBnZXQgJXMgcmVzZXQgY29udHJvbFxuIiwgcHJpdi0+bmFtZSk7DQo+ ID4gPiArCQlyZXR1cm4gUFRSX0VSUihwcml2LT5icmlkZ2VfcmVzZXQpOw0KPiA+ID4gKwl9DQo+ ID4gPiArDQo+ID4gDQo+ID4gDQo+ID4gPiArCXByaXYtPmwzcmVnID0gc3lzY29uX3JlZ21hcF9s b29rdXBfYnlfY29tcGF0aWJsZSgiYWx0cixsM3JlZ3MiKTsNCj4gPiA+ICsJaWYgKElTX0VSUihw cml2LT5sM3JlZykpIHsNCj4gPiA+ICsJCWRldl9lcnIoZGV2LCAicmVnbWFwIGZvciBhbHRyLGwz cmVncyBsb29rdXAgZmFpbGVkXG4iKTsNCj4gPiA+ICsJCXJldHVybiBQVFJfRVJSKHByaXYtPmwz cmVnKTsNCj4gPiA+ICsJfQ0KPiA+IA0KPiA+IFBlcmhhcHMgdGhpcyBjb3VsZCBiZSB3cmFwcGVk IGluIGlmKHByaXYtPnJlbWFwX21hc2spIHsgfS4gIFRoZSBmcGdhMmhwcw0KPiA+IGJyaWRnZSBo YXMgbm8gYml0cyBpbiB0aGUgbDMgcmVtYXAgcmVnaXN0ZXIsIHNvIHdoeSBzaG91bGQgaXQgbmVl ZCBhDQo+ID4gcGhhbmRsZSB0byB0aGUgbDMgc3lzY29uPyAgVGhpcyBhbHNvIHByZXZlbnRzIHRo aXMgZHJpdmVyIGZyb20gd29ya2luZw0KPiA+IG9uIEFycmlhMTAsIHNpbmNlIGl0IGhhcyBubyBs M3JlbWFwIHJlZ2lzdGVyIGF0IGFsbCwgZm9yIGFueSBvZiB0aGUNCj4gPiBicmlkZ2VzLCBzbyB0 aGVyZSdzIG5vdGhpbmcgZm9yIHRoZSBwaGFuZGxlIHRvIHBvaW50IHRvLg0KPiANCj4gQWdyZWVk Lg0KPiANCj4gPiANCj4gPiA+ICsNCj4gPiA+ICsJcHJpdi0+Y2xrID0gb2ZfY2xrX2dldChkZXYt Pm9mX25vZGUsIDApOw0KPiA+ID4gKwlpZiAoSVNfRVJSKHByaXYtPmNsaykpIHsNCj4gPiA+ICsJ CWRldl9lcnIoZGV2LCAibm8gY2xvY2sgc3BlY2lmaWVkXG4iKTsNCj4gPiA+ICsJCXJldHVybiBQ VFJfRVJSKHByaXYtPmNsayk7DQo+ID4gPiArCX0NCj4gPiANCj4gPiBkZXZtX2Nsa19nZXQoZGV2 LCBOVUxMKTsgc2hvdWxkIGdldCB0aGUgMXN0IGNsb2NrIGluIHRoZSBPRiBub2RlLCBidXQNCj4g PiB1c2UgdGhlIGRldiByZXNvdXJjZSBtYW5hZ2VyLCBzbyBpdCBkb2Vzbid0IG5lZWQgdG8gYmUg cHV0Lg0KPiANCj4gWWVzDQo+IA0KPiA+IA0KPiA+ID4gKw0KPiA+ID4gKwlyZXQgPSBjbGtfcHJl cGFyZV9lbmFibGUocHJpdi0+Y2xrKTsNCj4gPiA+ICsJaWYgKHJldCkgew0KPiA+ID4gKwkJZGV2 X2VycihkZXYsICJjb3VsZCBub3QgZW5hYmxlIGNsb2NrXG4iKTsNCj4gPiA+ICsJCXJldHVybiAt RUJVU1k7DQo+ID4gDQo+ID4gY2xrX3B1dCgpIG9uIGNsayBtaXNzaW5nIGhlcmUgYW5kIGFsc28g dGhlIG90aGVyIGVycm9yIHJldHVybnMuDQo+IA0KPiBJJ2xsIHVzZSBkZXZtX2Nsa19nZXQoKSBz byB0aGF0IHdvbid0IGJlIG5lZWRlZC4NCj4gDQo+ID4gDQo+ID4gPiArCX0NCj4gPiA+ICsNCj4g PiA+ICsJcmV0ID0gZnBnYV9icmlkZ2VfcmVnaXN0ZXIoZGV2LCBwcml2LT5uYW1lLCAmYWx0ZXJh X2hwczJmcGdhX2JyX29wcywNCj4gPiA+ICsJCQkJICAgcHJpdik7DQo+ID4gPiArCWlmIChyZXQp DQo+ID4gPiArCQlyZXR1cm4gcmV0Ow0KPiA+ID4gKw0KPiA+ID4gKwlpZiAoIW9mX3Byb3BlcnR5 X3JlYWRfdTMyKGRldi0+b2Zfbm9kZSwgImJyaWRnZS1lbmFibGUiLCAmZW5hYmxlKSkgew0KPiA+ ID4gKwkJaWYgKGVuYWJsZSA+IDEpIHsNCj4gPiA+ICsJCQlkZXZfd2FybihkZXYsICJpbnZhbGlk IGJyaWRnZS1lbmFibGUgJXUgPiAxXG4iLCBlbmFibGUpOw0KPiA+ID4gKwkJfSBlbHNlIHsNCj4g PiA+ICsJCQlkZXZfaW5mbyhkZXYsICIlcyBicmlkZ2VcbiIsDQo+ID4gPiArCQkJCSAoZW5hYmxl ID8gImVuYWJsaW5nIiA6ICJkaXNhYmxpbmciKSk7DQo+ID4gPiArDQo+ID4gPiArCQkJcmV0ID0g X2FsdF9ocHMyZnBnYV9lbmFibGVfc2V0KHByaXYsIGVuYWJsZSk7DQo+ID4gDQo+ID4gU2hvdWxk IHRoaXMgZ28gdGhyb3VnaCB0aGUgYnJpZGdlIGFwaSwgZS5nLiBmcGdhX2JyaWRnZV9lbmFibGUo KT8gIFNpbmNlDQo+ID4gdGhlIGJyaWRnZSBoYXMgYWxyZWFkeSBiZWVuIHJlZ2lzdGVyZWQuICBP ciBpcyB0aGUgYnJpZGdlIGZyYW1ld29yaw0KPiA+IHN1cHBvc2VkIHRvIGJlIGFibGUgdG8gc3Vw cG9ydCBicmlkZ2VzIHRoYXQgbWlnaHQgYmUgZW5hYmxlZCBvciBkaXNhYmxlZA0KPiA+IGJlaGlu ZCBpdHMgYmFjaz8gIElmIHNvLCB0aGVuIGlzbid0IHRoZXJlIGEgcmFjZSBoZXJlIHdpdGgNCj4g PiBfYWx0X2hwczJmcGdhX2VuYWJsZV9zZXQoKSBwb3NzaWJsZSBiZWluZyBjYWxsZWQgYXQgdGhl IHNhbWUgdGltZSBhcw0KPiA+IG90aGVyIG9wZXJhdGlvbnMgb24gdGhpcyBicmlkZ2UgdHJpZ2dl cmVkIGJ5IHRoZSBjb2RlIGluIGZwZ2EtYnJpZGdlLmM/DQo+ID4gDQo+ID4gQWx0ZXJuYXRpdmVs eSwgY291bGQgdGhlIGJyaWRnZSBiZSBlbmFibGVkIG9yIGRpc2FibGVkIGJlZm9yZSBiZWluZw0K PiA+IHJlZ2lzdGVyZWQ/DQo+IA0KPiBJJ2xsIGRvIHRoZSBlbmFibGluZy9kaXNhYmxpbmcgYmVm b3JlIHJlZ2lzdGVyaW5nIHRoZSBkcml2ZXIuDQo+IA0KPiBUaGFua3MgZm9yIHlvdXIgY29kZSBy ZXZpZXchDQo+IA0KPiBBbGFuDQoNCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S932523AbcFNVAM (ORCPT ); Tue, 14 Jun 2016 17:00:12 -0400 Received: from mail.kymetacorp.com ([192.81.58.21]:18931 "EHLO mail.kymetacorp.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752981AbcFNVAD (ORCPT ); Tue, 14 Jun 2016 17:00:03 -0400 From: Trent Piepho To: atull CC: Rob Herring , "pantelis.antoniou@konsulko.com" , Moritz Fischer , Josh Cartwright , "gregkh@linuxfoundation.org" , "monstr@monstr.eu" , "michal.simek@xilinx.com" , Pawel Moll , Mark Rutland , Ian Campbell , Kumar Gala , "Jonathan Corbet" , "linux-kernel@vger.kernel.org" , "devicetree@vger.kernel.org" , "linux-doc@vger.kernel.org" , "delicious.quinoa@gmail.com" , "dinguyen@opensource.altera.com" , Matthew Gerlach Subject: Re: [PATCH v16 6/6] ARM: socfpga: fpga bridge driver support Thread-Topic: [PATCH v16 6/6] ARM: socfpga: fpga bridge driver support Thread-Index: AQHRwr5Pq8+fbGwUtkGsHHTJ+zcoip/oRTaAgAGqdQA= Date: Tue, 14 Jun 2016 21:00:00 +0000 Message-ID: <1465938082.11684.16.camel@rtred1test09.kymeta.local> References: <1454707803-27947-1-git-send-email-atull@opensource.altera.com> <1454707803-27947-7-git-send-email-atull@opensource.altera.com> <1465525089.15779.203.camel@rtred1test09.kymeta.local> In-Reply-To: Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-mailer: Evolution 3.8.5 (3.8.5-31.el7) x-ms-exchange-transport-fromentityheader: Hosted x-originating-ip: [10.10.42.160] Content-Type: text/plain; charset="utf-8" Content-ID: <43A1C95AC17C9F409E27A3AAEA038FA7@kymetacorp.com> 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 u5EL0KbU020026 On Mon, 2016-06-13 at 14:35 -0500, atull wrote: > > > + > > > + /* Allow bridge to be visible to L3 masters or not */ > > > + if (priv->remap_mask) { > > > + priv->l3_remap_value |= ALT_L3_REMAP_MPUZERO_MSK; > > > > Doesn't seem like this belongs here. I realize the write-only register > > is a problem. Maybe the syscon driver should be initializing this > > value? > > > > > + > > > + if (enable) > > > + priv->l3_remap_value |= priv->remap_mask; > > > + else > > > + priv->l3_remap_value &= ~priv->remap_mask; > > > + > > > + ret = regmap_write(priv->l3reg, ALT_L3_REMAP_OFST, > > > + priv->l3_remap_value); > > > > This isn't going work if more than one bridge is used. Each bridge has > > its own priv and thus priv->l3_remap_value. Each bridge's priv will > > have just the bit for it's own remap set. The 2nd bridge to be enabled > > will turn off the 1st bridge when it re-write the l3 register. > > > > If all the bridges shared a static global to cache the reg, then this > > problem would be a replaced by a race, since nothing would be managing > > concurrent access to that global from the independent bridge devices. > > > > How about using the already existing regmap cache ability take care of > > this? Use regmap_update_bits() to update just the desired bit and let > > remap take care of keeping track caching the register and protecting > > access from multiple users. It should support that and it should > > support write-only registers, with the creator of the regmap (the syscon > > driver in this case) supplying the initial value of the write-only reg. > > Which is where ALT_L3_REMAP_MPUZERO_MSK could go in. > > Please correct me if I'm wrong, but I think that regmap supports > the features you are talking about, but not syscon. >>From my testing, it will work ok if the syscon driver were to set syscon_config.cache_type one of the caches. Since the l3 regs read back as 0, rather than not being readable at all, making them write-only and giving a default isn't strictly necessary. It wouldn't be hard to add a write-only property to syscon. > One simple solution would be to take l3_remap_value out of the priv > and let it be shared by all h2f bridges. That involves the least > amount of change. You'll need a spin-lock to protect against concurrent access. > > > + > > > +static int alt_hps2fpga_enable_set(struct fpga_bridge *bridge, bool enable) > > > +{ > > > + return _alt_hps2fpga_enable_set(bridge->priv, enable); > > > +} > > > + > > > +static const struct fpga_bridge_ops altera_hps2fpga_br_ops = { > > > + .enable_set = alt_hps2fpga_enable_set, > > > + .enable_show = alt_hps2fpga_enable_show, > > > +}; > > > + > > > +static struct altera_hps2fpga_data hps2fpga_data = { > > > + .name = HPS2FPGA_BRIDGE_NAME, > > > + .remap_mask = ALT_L3_REMAP_H2F_MSK, > > > +}; > > > > Each of these data structs also includes space for all the private data > > field of the drivers' state. Seems a bit inefficient if only two of > > them are configuration data. It also means only one device of each type > > can exists. If one creates two bridges of the same type they'll > > (silently) share a priv data struct and randomly break. And the config > > data structs can't be const. > > Our hardware doesn't contain two devices of any of these three types. Not yet, but doesn't Arria10 have three FPGA2SDRAM bridges? But really, it's just that I think having each device allocated state data for just that device is more in line with the Linux device model than shared static state pre-allocated for all devices of the same type to share. > > What if these structs were a different altera_hps_config struct, which > > the private data struct could then copy or point to? > > > > struct altera_hpsbridge_config { > > const char *name; > > uint32_t remap_mask; > > }; > > > > struct altera_hpsbridge_data { > > const struct altera_hpsbridge_config *config; > > ...; > > struct clk *clk; > > }; > > Yes, that sounds good and sensible. I'll do that in v18. Another thought, if the "altr,l3regs" binding included not just the phandle to the l3regs device, but also the bit associated with the bridge, then there wouldn't need to be bridge specific configuration for the driver. The same way the reset and clock properties point not just to the reset and clock controller, but to the bit in the controller. > > > + > > > +static struct altera_hps2fpga_data lwhps2fpga_data = { > > > + .name = LWHPS2FPGA_BRIDGE_NAME, > > > + .remap_mask = ALT_L3_REMAP_LWH2F_MSK, > > > +}; > > > + > > > +static struct altera_hps2fpga_data fpga2hps_data = { > > > + .name = FPGA2HPS_BRIDGE_NAME, > > > +}; > > > + > > > +static const struct of_device_id altera_fpga_of_match[] = { > > > + { .compatible = "altr,socfpga-hps2fpga-bridge", > > > + .data = &hps2fpga_data }, > > > + { .compatible = "altr,socfpga-lwhps2fpga-bridge", > > > + .data = &lwhps2fpga_data }, > > > + { .compatible = "altr,socfpga-fpga2hps-bridge", > > > + .data = &fpga2hps_data }, > > > + {}, > > > +}; > > > + > > > +static int alt_fpga_bridge_probe(struct platform_device *pdev) > > > +{ > > > + struct device *dev = &pdev->dev; > > > + struct altera_hps2fpga_data *priv; > > > + const struct of_device_id *of_id; > > > + u32 enable; > > > + int ret; > > > + > > > + of_id = of_match_device(altera_fpga_of_match, dev); > > > + priv = (struct altera_hps2fpga_data *)of_id->data; > > > + > > > + priv->bridge_reset = devm_reset_control_get(dev, priv->name); > > > + if (IS_ERR(priv->bridge_reset)) { > > > + dev_err(dev, "Could not get %s reset control\n", priv->name); > > > + return PTR_ERR(priv->bridge_reset); > > > + } > > > + > > > > > > > + priv->l3reg = syscon_regmap_lookup_by_compatible("altr,l3regs"); > > > + if (IS_ERR(priv->l3reg)) { > > > + dev_err(dev, "regmap for altr,l3regs lookup failed\n"); > > > + return PTR_ERR(priv->l3reg); > > > + } > > > > Perhaps this could be wrapped in if(priv->remap_mask) { }. The fpga2hps > > bridge has no bits in the l3 remap register, so why should it need a > > phandle to the l3 syscon? This also prevents this driver from working > > on Arria10, since it has no l3remap register at all, for any of the > > bridges, so there's nothing for the phandle to point to. > > Agreed. > > > > > > + > > > + priv->clk = of_clk_get(dev->of_node, 0); > > > + if (IS_ERR(priv->clk)) { > > > + dev_err(dev, "no clock specified\n"); > > > + return PTR_ERR(priv->clk); > > > + } > > > > devm_clk_get(dev, NULL); should get the 1st clock in the OF node, but > > use the dev resource manager, so it doesn't need to be put. > > Yes > > > > > > + > > > + ret = clk_prepare_enable(priv->clk); > > > + if (ret) { > > > + dev_err(dev, "could not enable clock\n"); > > > + return -EBUSY; > > > > clk_put() on clk missing here and also the other error returns. > > I'll use devm_clk_get() so that won't be needed. > > > > > > + } > > > + > > > + ret = fpga_bridge_register(dev, priv->name, &altera_hps2fpga_br_ops, > > > + priv); > > > + if (ret) > > > + return ret; > > > + > > > + if (!of_property_read_u32(dev->of_node, "bridge-enable", &enable)) { > > > + if (enable > 1) { > > > + dev_warn(dev, "invalid bridge-enable %u > 1\n", enable); > > > + } else { > > > + dev_info(dev, "%s bridge\n", > > > + (enable ? "enabling" : "disabling")); > > > + > > > + ret = _alt_hps2fpga_enable_set(priv, enable); > > > > Should this go through the bridge api, e.g. fpga_bridge_enable()? Since > > the bridge has already been registered. Or is the bridge framework > > supposed to be able to support bridges that might be enabled or disabled > > behind its back? If so, then isn't there a race here with > > _alt_hps2fpga_enable_set() possible being called at the same time as > > other operations on this bridge triggered by the code in fpga-bridge.c? > > > > Alternatively, could the bridge be enabled or disabled before being > > registered? > > I'll do the enabling/disabling before registering the driver. > > Thanks for your code review! > > Alan