From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Shevchenko, Andriy" Subject: Re: [PATCH v6] serial: 8250_uniphier: add UniPhier serial driver Date: Mon, 25 May 2015 09:14:06 +0000 Message-ID: <1432545245.8736.5.camel@intel.com> References: <1432525477-14051-1-git-send-email-yamada.masahiro@socionext.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1432525477-14051-1-git-send-email-yamada.masahiro@socionext.com> Content-Language: en-US Content-ID: <7C1905571DE9974BA2FC1D39AEAA13B7@intel.com> Sender: linux-kernel-owner@vger.kernel.org To: "yamada.masahiro@socionext.com" Cc: "manabian@gmail.com" , "bigeasy@linutronix.de" , "linux-kernel@vger.kernel.org" , "alan@lxorguk.ukuu.org.uk" , "ricardo.ribalda@gmail.com" , "alan@linux.intel.com" , "blogic@openwrt.org" , "linux-serial@vger.kernel.org" , "gregkh@linuxfoundation.org" , "jslaby@suse.cz" , "matthias.bgg@gmail.com" , "peter@hurleysoftware.com" , "linux-arm-kernel@lists.infradead.org" List-Id: linux-serial@vger.kernel.org T24gTW9uLCAyMDE1LTA1LTI1IGF0IDEyOjQ0ICswOTAwLCBNYXNhaGlybyBZYW1hZGEgd3JvdGU6 DQo+IEFkZCB0aGUgZHJpdmVyIGZvciBvbi1jaGlwIFVBUlQgdXNlZCBvbiBVbmlQaGllciBTb0Nz Lg0KPiANCj4gVGhpcyBoYXJkd2FyZSBpcyBzaW1pbGFyIHRvIDgyNTAsIGJ1dCB0aGUgcmVnaXN0 ZXIgbWFwcGluZyBpcw0KPiBzbGlnaHRseSBkaWZmZXJlbnQ6DQo+ICAgLSBUaGUgb2Zmc2V0IHRv IEZDUiwgTUNSIGlzIGRpZmZlcmVudC4NCj4gICAtIFRoZSBkaXZpc29yIGxhdGNoIGFjY2VzcyBi aXQgZG9lcyBub3QgZXhpc3QuICBJbnN0ZWFkLCB0aGUNCj4gICAgIGRpdmlzb3IgbGF0Y2ggcmVn aXN0ZXIgaXMgYXZhaWxhYmxlIGF0IG9mZnNldCA5Lg0KPiANCj4gVGhpcyBkcml2ZXIgb3ZlcnJp ZGVzIHNlcmlhbF97aW4sb3V0fSwgZGxfe3JlYWQsd3JpdGV9IGNhbGxiYWNrcywNCj4gYnV0IHdh bnRzIHRvIGJvcnJvdyBtb3N0IG9mIGNvZGUgZnJvbSA4MjUwX2NvcmUuYy4NCg0KRG8gbm90IHNl bmQgc2VyaWVzIHRvbyBvZnRlbiwgbGV0IHBlb3BsZSB0byByZXZpZXcgd2hhdCB5b3UgZGlkLg0K DQpNb3JlIGNvbW1lbnRzIGJlbG93Lg0KDQo+IA0KPiBTaWduZWQtb2ZmLWJ5OiBNYXNhaGlybyBZ YW1hZGEgPHlhbWFkYS5tYXNhaGlyb0Bzb2Npb25leHQuY29tPg0KPiBSZXZpZXdlZC1ieTogTWF0 dGhpYXMgQnJ1Z2dlciA8bWF0dGhpYXMuYmdnQGdtYWlsLmNvbT4NCj4gLS0tDQo+IA0KPiBDaGFu Z2VzIGluIHY2Og0KPiAgIC0gRHJvcCB1bm5lY2Vzc2FyeSAjaW5jbHVkZSA8bGludXgvc2VyaWFs XzgyNTAuaD4NCj4gICAgIChpdCBpcyBjb3ZlcmVkIGJ5ICNpbmNsdWRlICI4MjUwLmgiKQ0KPiAN Cj4gQ2hhbmdlcyBpbiB2NToNCj4gICAtIFNldCB1cC5wb3J0Lm1hcHNpemUNCj4gICAtIFBhc3Mg TlVMTCByYWh0ZXIgdGhhbiAwIHRvIHRoZSBzZWNvbmQgYXJndW1lbnQgb2YgZGV2bV9jbGtfZ2V0 KCkNCj4gDQo+IENoYW5nZXMgaW4gdjQ6DQo+ICAgLSBVc2Ugc3Bpbl9sb2NrIGZvciByZWFkLW1v ZGlmeS13cml0ZSByZWdpc3RlciBhY2Nlc3MNCj4gICAtIEFkZCAvKiBmYWxsIHRocm91Z2ggKi8g Y29tbWVudHMgd2hlcmUgSSBpbnRlbnRpb25hbGx5DQo+ICAgICBkaWQgbm90IGFkZCAiYnJlYWsi Ow0KPiAgIC0gRHJvcCB1bm5lY2Vzc2FyeSAjaW5jbHVkZSA8bGludXgvc2VyaWFsX2NvcmUuaD4N Cj4gICAtIERyb3AgdW5uZWNlc3NhcnkgI2luY2x1ZGUgPGxpbnV4L3NlcmlhbF9yZWcuaD4NCj4g ICAtIEFkZCBhbiBlbXB0eSBsaW5lIGJldHdlZW4gI2luY2x1ZGUgPD4gYW5kICIiDQo+ICAgLSBV c2UgcGxhdGZvcm1fZ2V0X2lycSgpIGluc3RlYWQgb2YgcGxhdGZvcm1fZ2V0X3Jlc291cmNlKCkN Cj4gDQo+IENoYW5nZXMgaW4gdjM6DQo+ICAgLSBKdXN0IGFkZCAqX1NISUZUIG1hY3JvIGZvciB0 aGUgc3BlY2lhbCBjYXNlDQo+IA0KPiBDaGFuZ2VzIGluIHYyOg0KPiAgIC0gRHJvcCB1bm5lY2Vz c2FyeSAjaW5jbHVkZSA8bGludXgvaW5pdC5oPg0KPiAgIC0gU29ydCBpbmNsdWRlcyBpbiBhbHBo YWJldGljYWwgb3JkZXINCj4gICAtIFVzZSBkZXZtX2Nsa19nZXQoKSByYXRoZXIgdGhhbiBvZl9j bGtfZ2V0KCkNCj4gICAtIERlbGV0ZSB1bm5lZWRlZCBjbGtfcHV0KCkgZnJvbSB1bmlwaGllcl91 YXJ0X3JlbW92ZSBjYWxsYmFjaw0KPiAgIC0gRGVsZXRlIHVubmVlZGVkIElTX0VSUl9PUl9OVUxM IGNoZWNrIGZyb20gdW5pcGhpZXJfdWFydF9yZW1vdmUgY2FsbGJhY2sNCj4gICAtIFVzZSBVTklQ SElFUl9VQVJUXypfU0hJRlQgaW5zdGVhZCBvZiBoYXJkLWNvZGVkIHNoaWZ0IHZhbHVlcw0KPiAg IC0gQ2hhbmdlIHRoZSBmaXJzdCBhcmd1bWVudCB0eXBlIG9mIHVuaXBoaWVyX29mX3NlcmlhbF9z ZXR1cCgpDQo+ICAgICBmcm9tIChzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICopIHRvIChzdHJ1Y3Qg ZGV2aWNlICopIGZvciBjb2RlLWNsZWFudXAuDQo+IA0KPiAgZHJpdmVycy90dHkvc2VyaWFsLzgy NTAvODI1MF91bmlwaGllci5jIHwgMjU3ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr DQo+ICBkcml2ZXJzL3R0eS9zZXJpYWwvODI1MC9LY29uZmlnICAgICAgICAgfCAgIDcgKw0KPiAg ZHJpdmVycy90dHkvc2VyaWFsLzgyNTAvTWFrZWZpbGUgICAgICAgIHwgICAxICsNCj4gIDMgZmls ZXMgY2hhbmdlZCwgMjY1IGluc2VydGlvbnMoKykNCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2 ZXJzL3R0eS9zZXJpYWwvODI1MC84MjUwX3VuaXBoaWVyLmMNCj4gDQo+IGRpZmYgLS1naXQgYS9k cml2ZXJzL3R0eS9zZXJpYWwvODI1MC84MjUwX3VuaXBoaWVyLmMgYi9kcml2ZXJzL3R0eS9zZXJp YWwvODI1MC84MjUwX3VuaXBoaWVyLmMNCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQNCj4gaW5kZXgg MDAwMDAwMC4uNmYxZTk5Nw0KPiAtLS0gL2Rldi9udWxsDQo+ICsrKyBiL2RyaXZlcnMvdHR5L3Nl cmlhbC84MjUwLzgyNTBfdW5pcGhpZXIuYw0KPiBAQCAtMCwwICsxLDI1NyBAQA0KPiArLyoNCj4g KyAqIENvcHlyaWdodCAoQykgMjAxNSBNYXNhaGlybyBZYW1hZGEgPHlhbWFkYS5tYXNhaGlyb0Bz b2Npb25leHQuY29tPg0KPiArICoNCj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJl OyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5DQo+ICsgKiBpdCB1bmRlciB0 aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBi eQ0KPiArICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBv ZiB0aGUgTGljZW5zZSwgb3INCj4gKyAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNp b24uDQo+ICsgKg0KPiArICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3Bl IHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsDQo+ICsgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7 IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZg0KPiArICogTUVSQ0hBTlRBQklM SVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQ0KPiArICog R05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4NCj4gKyAqLw0KPiAr DQo+ICsjaW5jbHVkZSA8bGludXgvY2xrLmg+DQo+ICsjaW5jbHVkZSA8bGludXgvaW8uaD4NCj4g KyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4NCj4gKyNpbmNsdWRlIDxsaW51eC9vZi5oPg0KPiAr I2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPg0KPiArDQo+ICsjaW5jbHVkZSAiODI1 MC5oIg0KPiArDQo+ICsvKiBNb3N0IChidXQgbm90IGFsbCkgb2YgVW5pUGhpZXIgVUFSVCBkZXZp Y2VzIGhhdmUgNjQtZGVwdGggRklGTy4gKi8NCj4gKyNkZWZpbmUgVU5JUEhJRVJfVUFSVF9ERUZB VUxUX0ZJRk9fU0laRQk2NA0KPiArDQo+ICsjZGVmaW5lIFVOSVBISUVSX1VBUlRfQ0hBUl9GQ1IJ MwkvKiBDaGFyYWN0ZXIgLyBGSUZPIENvbnRyb2wgUmVnaXN0ZXIgKi8NCj4gKyNkZWZpbmUgVU5J UEhJRVJfVUFSVF9MQ1JfTUNSCTQJLyogTGluZS9Nb2RlbSBDb250cm9sIFJlZ2lzdGVyICovDQo+ ICsjZGVmaW5lICAgVU5JUEhJRVJfVUFSVF9MQ1JfU0hJRlQJOA0KDQpJbmRlbnRhdGlvbiBwcm9i bGVtLCBuZWVkcyB0byBiZSBmaXhlZC4NCg0KPiArI2RlZmluZSBVTklQSElFUl9VQVJUX0RMUgk5 CS8qIERpdmlzb3IgTGF0Y2ggUmVnaXN0ZXIgKi8NCj4gKw0KPiArc3RydWN0IHVuaXBoaWVyODI1 MF9wcml2IHsNCj4gKwlpbnQgbGluZTsNCj4gKwlzdHJ1Y3QgY2xrICpjbGs7DQo+ICsJc3Bpbmxv Y2tfdCBhdG9taWNfd3JpdGVfbG9jazsNCj4gK307DQo+ICsNCj4gKy8qDQo+ICsgKiBUaGUgcmVn aXN0ZXIgbWFwIGlzIHNsaWdodGx5IGRpZmZlcmVudCBmcm9tIHRoYXQgb2YgODI1MC4NCj4gKyAq IElPIGNhbGxiYWNrcyBtdXN0IGJlIG92ZXJyaWRkZW4gZm9yIGNvcnJlY3QgYWNjZXNzIHRvIEZD UiwgTENSLCBhbmQgTUNSLg0KPiArICovDQo+ICtzdGF0aWMgdW5zaWduZWQgaW50IHVuaXBoaWVy X3NlcmlhbF9pbihzdHJ1Y3QgdWFydF9wb3J0ICpwLCBpbnQgb2Zmc2V0KQ0KPiArew0KPiArCWlu dCB2YWxzaGlmdCA9IDA7DQoNClBlcmhhcHMgdW5zaWduZWQgaW50Pw0KDQo+ICsNCj4gKwlzd2l0 Y2ggKG9mZnNldCkgew0KPiArCWNhc2UgVUFSVF9MQ1I6DQo+ICsJCXZhbHNoaWZ0ID0gVU5JUEhJ RVJfVUFSVF9MQ1JfU0hJRlQ7DQo+ICsJCS8qIGZhbGwgdGhyb3VnaCAqLw0KPiArCWNhc2UgVUFS VF9NQ1I6DQo+ICsJCW9mZnNldCA9IFVOSVBISUVSX1VBUlRfTENSX01DUjsNCj4gKwkJYnJlYWs7 DQo+ICsJZGVmYXVsdDoNCj4gKwkJYnJlYWs7DQo+ICsJfQ0KPiArDQo+ICsJb2Zmc2V0IDw8PSBw LT5yZWdzaGlmdDsNCj4gKw0KPiArCS8qDQo+ICsJICogVGhlIHJldHVybiB2YWx1ZSBtdXN0IGJl IG1hc2tlZCB3aXRoIDB4ZmYgYmVjYXVzZSBMQ1IgYW5kIE1DUiByZXNpZGUNCj4gKwkgKiBpbiB0 aGUgc2FtZSByZWdpc3RlciB0aGF0IG11c3QgYmUgYWNjZXNzZWQgYnkgMzItYml0IHdyaXRlL3Jl YWQuDQo+ICsJICogOCBvciAxNiBiaXQgYWNjZXNzIHRvIHRoaXMgaGFyZHdhcmUgcmVzdWx0IGlu IHVuZXhwZWN0ZWQgYmVoYXZpb3IuDQo+ICsJICovDQo+ICsJcmV0dXJuIChyZWFkbChwLT5tZW1i YXNlICsgb2Zmc2V0KSA+PiB2YWxzaGlmdCkgJiAweGZmOw0KPiArfQ0KPiArDQo+ICtzdGF0aWMg dm9pZCB1bmlwaGllcl9zZXJpYWxfb3V0KHN0cnVjdCB1YXJ0X3BvcnQgKnAsIGludCBvZmZzZXQs IGludCB2YWx1ZSkNCj4gK3sNCj4gKwlpbnQgdmFsc2hpZnQgPSAwOw0KDQpEaXR0by4NCg0KPiAr CWJvb2wgbm9ybWFsID0gZmFsc2U7DQo+ICsNCj4gKwlzd2l0Y2ggKG9mZnNldCkgew0KPiArCWNh c2UgVUFSVF9GQ1I6DQo+ICsJCW9mZnNldCA9IFVOSVBISUVSX1VBUlRfQ0hBUl9GQ1I7DQo+ICsJ CWJyZWFrOw0KPiArCWNhc2UgVUFSVF9MQ1I6DQo+ICsJCXZhbHNoaWZ0ID0gVU5JUEhJRVJfVUFS VF9MQ1JfU0hJRlQ7DQo+ICsJCS8qIERpdmlzb3IgbGF0Y2ggYWNjZXNzIGJpdCBkb2VzIG5vdCBl eGlzdC4gKi8NCj4gKwkJdmFsdWUgJj0gfihVQVJUX0xDUl9ETEFCIDw8IHZhbHNoaWZ0KTsNCj4g KwkJLyogZmFsbCB0aHJvdWdoICovDQo+ICsJY2FzZSBVQVJUX01DUjoNCj4gKwkJb2Zmc2V0ID0g VU5JUEhJRVJfVUFSVF9MQ1JfTUNSOw0KPiArCQlicmVhazsNCj4gKwlkZWZhdWx0Og0KPiArCQlu b3JtYWwgPSB0cnVlOw0KPiArCQlicmVhazsNCj4gKwl9DQo+ICsNCj4gKwlvZmZzZXQgPDw9IHAt PnJlZ3NoaWZ0Ow0KPiArDQo+ICsJaWYgKG5vcm1hbCkgew0KPiArCQl3cml0ZWwodmFsdWUsIHAt Pm1lbWJhc2UgKyBvZmZzZXQpOw0KDQpQZXJoYXBzIHB1dCB0aGlzIGluIHBsYWNlIHdoZXJlIG5v cm1hbCA9PSB0cnVlIGFuZCB1c2UgcmV0dXJuIGluc3RlYWQgb2YNCmJyZWFrPw0KDQo+ICsJfSBl bHNlIHsNCj4gKwkJLyoNCj4gKwkJICogU3BlY2lhbCBjYXNlOiB0d28gcmVnaXN0ZXJzIHNoYXJl IHRoZSBzYW1lIGFkZHJlc3MgdGhhdA0KPiArCQkgKiBtdXN0IGJlIDMyLWJpdCBhY2Nlc3NlZC4g IEFzIHRoaXMgaXMgbm90IGxvbmdlciBhdG9taWMgc2FmZSwNCj4gKwkJICogdGFrZSBhIGxvY2sg anVzdCBpbiBjYXNlLg0KPiArCQkgKi8NCj4gKwkJc3RydWN0IHVuaXBoaWVyODI1MF9wcml2ICpw cml2ID0gcC0+cHJpdmF0ZV9kYXRhOw0KPiArCQl1bnNpZ25lZCBsb25nIGZsYWdzOw0KPiArCQl1 MzIgdG1wOw0KPiArDQo+ICsJCXNwaW5fbG9ja19pcnFzYXZlKCZwcml2LT5hdG9taWNfd3JpdGVf bG9jaywgZmxhZ3MpOw0KPiArCQl0bXAgPSByZWFkbChwLT5tZW1iYXNlICsgb2Zmc2V0KTsNCg0K PiArCQl0bXAgJj0gfigweGZmIDw8IHZhbHNoaWZ0KTsNCj4gKwkJdG1wIHw9IHZhbHVlIDw8IHZh bHNoaWZ0Ow0KDQo+ICsJCXdyaXRlbCh0bXAsIHAtPm1lbWJhc2UgKyBvZmZzZXQpOw0KPiArCQlz cGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT5hdG9taWNfd3JpdGVfbG9jaywgZmxhZ3MpOw0K PiArCX0NCj4gK30NCj4gKw0KPiArLyoNCj4gKyAqIFRoaXMgaGFyZHdhcmUgZG9lcyBub3QgaGF2 ZSB0aGUgZGl2aXNvciBsYXRjaCBhY2Nlc3MgYml0Lg0KPiArICogVGhlIGRpdmlzb3IgbGF0Y2gg cmVnaXN0ZXIgZXhpc3RzIGF0IGRpZmZlcmVudCBhZGRyZXNzLg0KPiArICogT3ZlcnJpZGUgZGxf cmVhZC93cml0ZSBjYWxsYmFja3MuDQo+ICsgKi8NCj4gK3N0YXRpYyBpbnQgdW5pcGhpZXJfc2Vy aWFsX2RsX3JlYWQoc3RydWN0IHVhcnRfODI1MF9wb3J0ICp1cCkNCj4gK3sNCj4gKwlyZXR1cm4g cmVhZGwodXAtPnBvcnQubWVtYmFzZSArIFVOSVBISUVSX1VBUlRfRExSKTsNCj4gK30NCj4gKw0K PiArc3RhdGljIHZvaWQgdW5pcGhpZXJfc2VyaWFsX2RsX3dyaXRlKHN0cnVjdCB1YXJ0XzgyNTBf cG9ydCAqdXAsIGludCB2YWx1ZSkNCj4gK3sNCj4gKwl3cml0ZWwodmFsdWUsIHVwLT5wb3J0Lm1l bWJhc2UgKyBVTklQSElFUl9VQVJUX0RMUik7DQo+ICt9DQo+ICsNCj4gK3N0YXRpYyBpbnQgdW5p cGhpZXJfb2Zfc2VyaWFsX3NldHVwKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHVhcnRfcG9y dCAqcG9ydCwNCj4gKwkJCQkgICAgc3RydWN0IHVuaXBoaWVyODI1MF9wcml2ICpwcml2KQ0KPiAr ew0KPiArCWludCByZXQ7DQo+ICsJdTMyIHByb3A7DQo+ICsJc3RydWN0IGRldmljZV9ub2RlICpu cCA9IGRldi0+b2Zfbm9kZTsNCj4gKw0KPiArCXJldCA9IG9mX2FsaWFzX2dldF9pZChucCwgInNl cmlhbCIpOw0KPiArCWlmIChyZXQgPCAwKSB7DQo+ICsJCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRv IGdldCBhbGlhcyBpZFxuIik7DQo+ICsJCXJldHVybiByZXQ7DQo+ICsJfQ0KPiArCXBvcnQtPmxp bmUgPSBwcml2LT5saW5lID0gcmV0Ow0KPiArDQo+ICsJLyogR2V0IGNsayByYXRlIHRocm91Z2gg Y2xrIGRyaXZlciAqLw0KPiArCXByaXYtPmNsayA9IGRldm1fY2xrX2dldChkZXYsIE5VTEwpOw0K PiArCWlmIChJU19FUlIocHJpdi0+Y2xrKSkgew0KPiArCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0 byBnZXQgY2xvY2tcbiIpOw0KPiArCQlyZXR1cm4gUFRSX0VSUihwcml2LT5jbGspOw0KPiArCX0N Cj4gKw0KPiArCXJldCA9IGNsa19wcmVwYXJlX2VuYWJsZShwcml2LT5jbGspOw0KPiArCWlmIChy ZXQgPCAwKQ0KPiArCQlyZXR1cm4gcmV0Ow0KPiArDQo+ICsJcG9ydC0+dWFydGNsayA9IGNsa19n ZXRfcmF0ZShwcml2LT5jbGspOw0KPiArDQo+ICsJLyogQ2hlY2sgZm9yIGZpZm8gc2l6ZSAqLw0K PiArCWlmIChvZl9wcm9wZXJ0eV9yZWFkX3UzMihucCwgImZpZm8tc2l6ZSIsICZwcm9wKSA9PSAw KQ0KPiArCQlwb3J0LT5maWZvc2l6ZSA9IHByb3A7DQo+ICsJZWxzZQ0KPiArCQlwb3J0LT5maWZv c2l6ZSA9IFVOSVBISUVSX1VBUlRfREVGQVVMVF9GSUZPX1NJWkU7DQo+ICsNCj4gKwlyZXR1cm4g MDsNCj4gK30NCj4gKw0KPiArc3RhdGljIGludCB1bmlwaGllcl91YXJ0X3Byb2JlKHN0cnVjdCBw bGF0Zm9ybV9kZXZpY2UgKnBkZXYpDQo+ICt7DQo+ICsJc3RydWN0IGRldmljZSAqZGV2ID0gJnBk ZXYtPmRldjsNCj4gKwlzdHJ1Y3QgdWFydF84MjUwX3BvcnQgdXA7DQo+ICsJc3RydWN0IHVuaXBo aWVyODI1MF9wcml2ICpwcml2Ow0KPiArCXN0cnVjdCByZXNvdXJjZSAqcmVnczsNCj4gKwl2b2lk IF9faW9tZW0gKm1lbWJhc2U7DQo+ICsJaW50IGlycTsNCj4gKwlpbnQgcmV0Ow0KPiArDQo+ICsJ cmVncyA9IHBsYXRmb3JtX2dldF9yZXNvdXJjZShwZGV2LCBJT1JFU09VUkNFX01FTSwgMCk7DQo+ ICsJaWYgKCFyZWdzKSB7DQo+ICsJCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIGdldCBtZW1vcnkg cmVzb3VyY2UiKTsNCj4gKwkJcmV0dXJuIC1FSU5WQUw7DQo+ICsJfQ0KPiArDQo+ICsJbWVtYmFz ZSA9IGRldm1faW9yZW1hcChkZXYsIHJlZ3MtPnN0YXJ0LCByZXNvdXJjZV9zaXplKHJlZ3MpKTsN Cj4gKwlpZiAoIW1lbWJhc2UpDQo+ICsJCXJldHVybiAtRU5PTUVNOw0KPiArDQo+ICsJaXJxID0g cGxhdGZvcm1fZ2V0X2lycShwZGV2LCAwKTsNCj4gKwlpZiAoaXJxIDwgMCkgew0KPiArCQlkZXZf ZXJyKGRldiwgImZhaWxlZCB0byBnZXQgSVJRIG51bWJlciIpOw0KPiArCQlyZXR1cm4gaXJxOw0K PiArCX0NCj4gKw0KPiArCXByaXYgPSBkZXZtX2t6YWxsb2MoZGV2LCBzaXplb2YoKnByaXYpLCBH RlBfS0VSTkVMKTsNCj4gKwlpZiAoIXByaXYpDQo+ICsJCXJldHVybiAtRU5PTUVNOw0KPiArDQo+ ICsJbWVtc2V0KCZ1cCwgMCwgc2l6ZW9mKHVwKSk7DQo+ICsNCj4gKwlyZXQgPSB1bmlwaGllcl9v Zl9zZXJpYWxfc2V0dXAoZGV2LCAmdXAucG9ydCwgcHJpdik7DQo+ICsJaWYgKHJldCA8IDApDQo+ ICsJCXJldHVybiByZXQ7DQo+ICsNCj4gKwlzcGluX2xvY2tfaW5pdCgmcHJpdi0+YXRvbWljX3dy aXRlX2xvY2spOw0KPiArDQo+ICsJdXAucG9ydC5kZXYgPSBkZXY7DQo+ICsJdXAucG9ydC5wcml2 YXRlX2RhdGEgPSBwcml2Ow0KPiArCXVwLnBvcnQubWFwYmFzZSA9IHJlZ3MtPnN0YXJ0Ow0KPiAr CXVwLnBvcnQubWFwc2l6ZSA9IHJlc291cmNlX3NpemUocmVncyk7DQo+ICsJdXAucG9ydC5tZW1i YXNlID0gbWVtYmFzZTsNCj4gKwl1cC5wb3J0LmlycSA9IGlycTsNCj4gKw0KPiArCXVwLnBvcnQu dHlwZSA9IFBPUlRfMTY1NTBBOw0KPiArCXVwLnBvcnQuaW90eXBlID0gVVBJT19NRU0zMjsNCj4g Kwl1cC5wb3J0LnJlZ3NoaWZ0ID0gMjsNCj4gKwl1cC5wb3J0LmZsYWdzID0gVVBGX0ZJWEVEX1BP UlQgfCBVUEZfRklYRURfVFlQRTsNCj4gKwl1cC5jYXBhYmlsaXRpZXMgPSBVQVJUX0NBUF9GSUZP Ow0KPiArDQo+ICsJdXAucG9ydC5zZXJpYWxfaW4gPSB1bmlwaGllcl9zZXJpYWxfaW47DQo+ICsJ dXAucG9ydC5zZXJpYWxfb3V0ID0gdW5pcGhpZXJfc2VyaWFsX291dDsNCj4gKwl1cC5kbF9yZWFk ID0gdW5pcGhpZXJfc2VyaWFsX2RsX3JlYWQ7DQo+ICsJdXAuZGxfd3JpdGUgPSB1bmlwaGllcl9z ZXJpYWxfZGxfd3JpdGU7DQo+ICsNCj4gKwlyZXQgPSBzZXJpYWw4MjUwX3JlZ2lzdGVyXzgyNTBf cG9ydCgmdXApOw0KPiArCWlmIChyZXQgPCAwKSB7DQo+ICsJCWRldl9lcnIoZGV2LCAiZmFpbGVk IHRvIHJlZ2lzdGVyIDgyNTAgcG9ydFxuIik7DQo+ICsJCXJldHVybiByZXQ7DQo+ICsJfQ0KPiAr DQo+ICsJcGxhdGZvcm1fc2V0X2RydmRhdGEocGRldiwgcHJpdik7DQo+ICsNCj4gKwlyZXR1cm4g MDsNCj4gK30NCj4gKw0KPiArc3RhdGljIGludCB1bmlwaGllcl91YXJ0X3JlbW92ZShzdHJ1Y3Qg cGxhdGZvcm1fZGV2aWNlICpwZGV2KQ0KPiArew0KPiArCXN0cnVjdCB1bmlwaGllcjgyNTBfcHJp diAqcHJpdiA9IHBsYXRmb3JtX2dldF9kcnZkYXRhKHBkZXYpOw0KPiArDQo+ICsJc2VyaWFsODI1 MF91bnJlZ2lzdGVyX3BvcnQocHJpdi0+bGluZSk7DQo+ICsJY2xrX2Rpc2FibGVfdW5wcmVwYXJl KHByaXYtPmNsayk7DQo+ICsNCj4gKwlyZXR1cm4gMDsNCj4gK30NCj4gKw0KPiArc3RhdGljIGNv bnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgdW5pcGhpZXJfdWFydF9tYXRjaFtdID0gew0KPiArCXsg LmNvbXBhdGlibGUgPSAic29jaW9uZXh0LHVuaXBoaWVyLXVhcnQiIH0sDQo+ICsJeyAvKiBzZW50 aW5lbCAqLyB9DQo+ICt9Ow0KPiArTU9EVUxFX0RFVklDRV9UQUJMRShvZiwgdW5pcGhpZXJfdWFy dF9tYXRjaCk7DQo+ICsNCj4gK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZHJpdmVyIHVuaXBoaWVy X3VhcnRfcGxhdGZvcm1fZHJpdmVyID0gew0KPiArCS5wcm9iZQkJPSB1bmlwaGllcl91YXJ0X3By b2JlLA0KPiArCS5yZW1vdmUJCT0gdW5pcGhpZXJfdWFydF9yZW1vdmUsDQo+ICsJLmRyaXZlciA9 IHsNCj4gKwkJLm5hbWUJPSAidW5pcGhpZXItdWFydCIsDQo+ICsJCS5vZl9tYXRjaF90YWJsZSA9 IHVuaXBoaWVyX3VhcnRfbWF0Y2gsDQo+ICsJfSwNCj4gK307DQo+ICttb2R1bGVfcGxhdGZvcm1f ZHJpdmVyKHVuaXBoaWVyX3VhcnRfcGxhdGZvcm1fZHJpdmVyKTsNCj4gKw0KPiArTU9EVUxFX0FV VEhPUigiTWFzYWhpcm8gWWFtYWRhIDx5YW1hZGEubWFzYWhpcm9Ac29jaW9uZXh0LmNvbT4iKTsN Cj4gK01PRFVMRV9ERVNDUklQVElPTigiVW5pUGhpZXIgVUFSVCBkcml2ZXIiKTsNCj4gK01PRFVM RV9MSUNFTlNFKCJHUEwiKTsNCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdHR5L3NlcmlhbC84MjUw L0tjb25maWcgYi9kcml2ZXJzL3R0eS9zZXJpYWwvODI1MC9LY29uZmlnDQo+IGluZGV4IGMzNTA3 MDMuLjNlMWFlNDQ2IDEwMDY0NA0KPiAtLS0gYS9kcml2ZXJzL3R0eS9zZXJpYWwvODI1MC9LY29u ZmlnDQo+ICsrKyBiL2RyaXZlcnMvdHR5L3NlcmlhbC84MjUwL0tjb25maWcNCj4gQEAgLTM0Miwz ICszNDIsMTAgQEAgY29uZmlnIFNFUklBTF84MjUwX01UNjU3Nw0KPiAgCWhlbHANCj4gIAkgIElm IHlvdSBoYXZlIGEgTWVkaWF0ZWsgYmFzZWQgYm9hcmQgYW5kIHdhbnQgdG8gdXNlIHRoZQ0KPiAg CSAgc2VyaWFsIHBvcnQsIHNheSBZIHRvIHRoaXMgb3B0aW9uLiBJZiB1bnN1cmUsIHNheSBOLg0K PiArDQo+ICtjb25maWcgU0VSSUFMXzgyNTBfVU5JUEhJRVINCj4gKwl0cmlzdGF0ZSAiU3VwcG9y dCBmb3IgVW5pUGhpZXIgb24tY2hpcCBVQVJUIg0KPiArCWRlcGVuZHMgb24gU0VSSUFMXzgyNTAg JiYgQVJDSF9VTklQSElFUg0KPiArCWhlbHANCj4gKwkgIElmIHlvdSBoYXZlIGEgVW5pUGhpZXIg YmFzZWQgYm9hcmQgYW5kIHdhbnQgdG8gdXNlIHRoZSBvbi1jaGlwDQo+ICsJICBzZXJpYWwgcG9y dHMsIHNheSBZIHRvIHRoaXMgb3B0aW9uLiBJZiB1bnN1cmUsIHNheSBOLg0KPiBkaWZmIC0tZ2l0 IGEvZHJpdmVycy90dHkvc2VyaWFsLzgyNTAvTWFrZWZpbGUgYi9kcml2ZXJzL3R0eS9zZXJpYWwv ODI1MC9NYWtlZmlsZQ0KPiBpbmRleCAzMWU3Y2RjLi5mN2NhOGMzIDEwMDY0NA0KPiAtLS0gYS9k cml2ZXJzL3R0eS9zZXJpYWwvODI1MC9NYWtlZmlsZQ0KPiArKysgYi9kcml2ZXJzL3R0eS9zZXJp YWwvODI1MC9NYWtlZmlsZQ0KPiBAQCAtMjMsMyArMjMsNCBAQCBvYmotJChDT05GSUdfU0VSSUFM XzgyNTBfRU0pCQkrPSA4MjUwX2VtLm8NCj4gIG9iai0kKENPTkZJR19TRVJJQUxfODI1MF9PTUFQ KQkJKz0gODI1MF9vbWFwLm8NCj4gIG9iai0kKENPTkZJR19TRVJJQUxfODI1MF9GSU5URUspCSs9 IDgyNTBfZmludGVrLm8NCj4gIG9iai0kKENPTkZJR19TRVJJQUxfODI1MF9NVDY1NzcpCSs9IDgy NTBfbXRrLm8NCj4gK29iai0kKENPTkZJR19TRVJJQUxfODI1MF9VTklQSElFUikJKz0gODI1MF91 bmlwaGllci5vDQoNCg0KLS0gDQpBbmR5IFNoZXZjaGVua28gPGFuZHJpeS5zaGV2Y2hlbmtvQGlu dGVsLmNvbT4NCkludGVsIEZpbmxhbmQgT3kNCi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQpJbnRlbCBGaW5sYW5kIE95 ClJlZ2lzdGVyZWQgQWRkcmVzczogUEwgMjgxLCAwMDE4MSBIZWxzaW5raSAKQnVzaW5lc3MgSWRl bnRpdHkgQ29kZTogMDM1NzYwNiAtIDQgCkRvbWljaWxlZCBpbiBIZWxzaW5raSAKClRoaXMgZS1t YWlsIGFuZCBhbnkgYXR0YWNobWVudHMgbWF5IGNvbnRhaW4gY29uZmlkZW50aWFsIG1hdGVyaWFs IGZvcgp0aGUgc29sZSB1c2Ugb2YgdGhlIGludGVuZGVkIHJlY2lwaWVudChzKS4gQW55IHJldmll dyBvciBkaXN0cmlidXRpb24KYnkgb3RoZXJzIGlzIHN0cmljdGx5IHByb2hpYml0ZWQuIElmIHlv dSBhcmUgbm90IHRoZSBpbnRlbmRlZApyZWNpcGllbnQsIHBsZWFzZSBjb250YWN0IHRoZSBzZW5k ZXIgYW5kIGRlbGV0ZSBhbGwgY29waWVzLgo= From mboxrd@z Thu Jan 1 00:00:00 1970 From: andriy.shevchenko@intel.com (Shevchenko, Andriy) Date: Mon, 25 May 2015 09:14:06 +0000 Subject: [PATCH v6] serial: 8250_uniphier: add UniPhier serial driver In-Reply-To: <1432525477-14051-1-git-send-email-yamada.masahiro@socionext.com> References: <1432525477-14051-1-git-send-email-yamada.masahiro@socionext.com> Message-ID: <1432545245.8736.5.camel@intel.com> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org On Mon, 2015-05-25 at 12:44 +0900, Masahiro Yamada wrote: > Add the driver for on-chip UART used on UniPhier SoCs. > > This hardware is similar to 8250, but the register mapping is > slightly different: > - The offset to FCR, MCR is different. > - The divisor latch access bit does not exist. Instead, the > divisor latch register is available at offset 9. > > This driver overrides serial_{in,out}, dl_{read,write} callbacks, > but wants to borrow most of code from 8250_core.c. Do not send series too often, let people to review what you did. More comments below. > > Signed-off-by: Masahiro Yamada > Reviewed-by: Matthias Brugger > --- > > Changes in v6: > - Drop unnecessary #include > (it is covered by #include "8250.h") > > Changes in v5: > - Set up.port.mapsize > - Pass NULL rahter than 0 to the second argument of devm_clk_get() > > Changes in v4: > - Use spin_lock for read-modify-write register access > - Add /* fall through */ comments where I intentionally > did not add "break"; > - Drop unnecessary #include > - Drop unnecessary #include > - Add an empty line between #include <> and "" > - Use platform_get_irq() instead of platform_get_resource() > > Changes in v3: > - Just add *_SHIFT macro for the special case > > Changes in v2: > - Drop unnecessary #include > - Sort includes in alphabetical order > - Use devm_clk_get() rather than of_clk_get() > - Delete unneeded clk_put() from uniphier_uart_remove callback > - Delete unneeded IS_ERR_OR_NULL check from uniphier_uart_remove callback > - Use UNIPHIER_UART_*_SHIFT instead of hard-coded shift values > - Change the first argument type of uniphier_of_serial_setup() > from (struct platform_device *) to (struct device *) for code-cleanup. > > drivers/tty/serial/8250/8250_uniphier.c | 257 ++++++++++++++++++++++++++++++++ > drivers/tty/serial/8250/Kconfig | 7 + > drivers/tty/serial/8250/Makefile | 1 + > 3 files changed, 265 insertions(+) > create mode 100644 drivers/tty/serial/8250/8250_uniphier.c > > diff --git a/drivers/tty/serial/8250/8250_uniphier.c b/drivers/tty/serial/8250/8250_uniphier.c > new file mode 100644 > index 0000000..6f1e997 > --- /dev/null > +++ b/drivers/tty/serial/8250/8250_uniphier.c > @@ -0,0 +1,257 @@ > +/* > + * Copyright (C) 2015 Masahiro Yamada > + * > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License as published by > + * the Free Software Foundation; either version 2 of the License, or > + * (at your option) any later version. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + */ > + > +#include > +#include > +#include > +#include > +#include > + > +#include "8250.h" > + > +/* Most (but not all) of UniPhier UART devices have 64-depth FIFO. */ > +#define UNIPHIER_UART_DEFAULT_FIFO_SIZE 64 > + > +#define UNIPHIER_UART_CHAR_FCR 3 /* Character / FIFO Control Register */ > +#define UNIPHIER_UART_LCR_MCR 4 /* Line/Modem Control Register */ > +#define UNIPHIER_UART_LCR_SHIFT 8 Indentation problem, needs to be fixed. > +#define UNIPHIER_UART_DLR 9 /* Divisor Latch Register */ > + > +struct uniphier8250_priv { > + int line; > + struct clk *clk; > + spinlock_t atomic_write_lock; > +}; > + > +/* > + * The register map is slightly different from that of 8250. > + * IO callbacks must be overridden for correct access to FCR, LCR, and MCR. > + */ > +static unsigned int uniphier_serial_in(struct uart_port *p, int offset) > +{ > + int valshift = 0; Perhaps unsigned int? > + > + switch (offset) { > + case UART_LCR: > + valshift = UNIPHIER_UART_LCR_SHIFT; > + /* fall through */ > + case UART_MCR: > + offset = UNIPHIER_UART_LCR_MCR; > + break; > + default: > + break; > + } > + > + offset <<= p->regshift; > + > + /* > + * The return value must be masked with 0xff because LCR and MCR reside > + * in the same register that must be accessed by 32-bit write/read. > + * 8 or 16 bit access to this hardware result in unexpected behavior. > + */ > + return (readl(p->membase + offset) >> valshift) & 0xff; > +} > + > +static void uniphier_serial_out(struct uart_port *p, int offset, int value) > +{ > + int valshift = 0; Ditto. > + bool normal = false; > + > + switch (offset) { > + case UART_FCR: > + offset = UNIPHIER_UART_CHAR_FCR; > + break; > + case UART_LCR: > + valshift = UNIPHIER_UART_LCR_SHIFT; > + /* Divisor latch access bit does not exist. */ > + value &= ~(UART_LCR_DLAB << valshift); > + /* fall through */ > + case UART_MCR: > + offset = UNIPHIER_UART_LCR_MCR; > + break; > + default: > + normal = true; > + break; > + } > + > + offset <<= p->regshift; > + > + if (normal) { > + writel(value, p->membase + offset); Perhaps put this in place where normal == true and use return instead of break? > + } else { > + /* > + * Special case: two registers share the same address that > + * must be 32-bit accessed. As this is not longer atomic safe, > + * take a lock just in case. > + */ > + struct uniphier8250_priv *priv = p->private_data; > + unsigned long flags; > + u32 tmp; > + > + spin_lock_irqsave(&priv->atomic_write_lock, flags); > + tmp = readl(p->membase + offset); > + tmp &= ~(0xff << valshift); > + tmp |= value << valshift; > + writel(tmp, p->membase + offset); > + spin_unlock_irqrestore(&priv->atomic_write_lock, flags); > + } > +} > + > +/* > + * This hardware does not have the divisor latch access bit. > + * The divisor latch register exists at different address. > + * Override dl_read/write callbacks. > + */ > +static int uniphier_serial_dl_read(struct uart_8250_port *up) > +{ > + return readl(up->port.membase + UNIPHIER_UART_DLR); > +} > + > +static void uniphier_serial_dl_write(struct uart_8250_port *up, int value) > +{ > + writel(value, up->port.membase + UNIPHIER_UART_DLR); > +} > + > +static int uniphier_of_serial_setup(struct device *dev, struct uart_port *port, > + struct uniphier8250_priv *priv) > +{ > + int ret; > + u32 prop; > + struct device_node *np = dev->of_node; > + > + ret = of_alias_get_id(np, "serial"); > + if (ret < 0) { > + dev_err(dev, "failed to get alias id\n"); > + return ret; > + } > + port->line = priv->line = ret; > + > + /* Get clk rate through clk driver */ > + priv->clk = devm_clk_get(dev, NULL); > + if (IS_ERR(priv->clk)) { > + dev_err(dev, "failed to get clock\n"); > + return PTR_ERR(priv->clk); > + } > + > + ret = clk_prepare_enable(priv->clk); > + if (ret < 0) > + return ret; > + > + port->uartclk = clk_get_rate(priv->clk); > + > + /* Check for fifo size */ > + if (of_property_read_u32(np, "fifo-size", &prop) == 0) > + port->fifosize = prop; > + else > + port->fifosize = UNIPHIER_UART_DEFAULT_FIFO_SIZE; > + > + return 0; > +} > + > +static int uniphier_uart_probe(struct platform_device *pdev) > +{ > + struct device *dev = &pdev->dev; > + struct uart_8250_port up; > + struct uniphier8250_priv *priv; > + struct resource *regs; > + void __iomem *membase; > + int irq; > + int ret; > + > + regs = platform_get_resource(pdev, IORESOURCE_MEM, 0); > + if (!regs) { > + dev_err(dev, "failed to get memory resource"); > + return -EINVAL; > + } > + > + membase = devm_ioremap(dev, regs->start, resource_size(regs)); > + if (!membase) > + return -ENOMEM; > + > + irq = platform_get_irq(pdev, 0); > + if (irq < 0) { > + dev_err(dev, "failed to get IRQ number"); > + return irq; > + } > + > + priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); > + if (!priv) > + return -ENOMEM; > + > + memset(&up, 0, sizeof(up)); > + > + ret = uniphier_of_serial_setup(dev, &up.port, priv); > + if (ret < 0) > + return ret; > + > + spin_lock_init(&priv->atomic_write_lock); > + > + up.port.dev = dev; > + up.port.private_data = priv; > + up.port.mapbase = regs->start; > + up.port.mapsize = resource_size(regs); > + up.port.membase = membase; > + up.port.irq = irq; > + > + up.port.type = PORT_16550A; > + up.port.iotype = UPIO_MEM32; > + up.port.regshift = 2; > + up.port.flags = UPF_FIXED_PORT | UPF_FIXED_TYPE; > + up.capabilities = UART_CAP_FIFO; > + > + up.port.serial_in = uniphier_serial_in; > + up.port.serial_out = uniphier_serial_out; > + up.dl_read = uniphier_serial_dl_read; > + up.dl_write = uniphier_serial_dl_write; > + > + ret = serial8250_register_8250_port(&up); > + if (ret < 0) { > + dev_err(dev, "failed to register 8250 port\n"); > + return ret; > + } > + > + platform_set_drvdata(pdev, priv); > + > + return 0; > +} > + > +static int uniphier_uart_remove(struct platform_device *pdev) > +{ > + struct uniphier8250_priv *priv = platform_get_drvdata(pdev); > + > + serial8250_unregister_port(priv->line); > + clk_disable_unprepare(priv->clk); > + > + return 0; > +} > + > +static const struct of_device_id uniphier_uart_match[] = { > + { .compatible = "socionext,uniphier-uart" }, > + { /* sentinel */ } > +}; > +MODULE_DEVICE_TABLE(of, uniphier_uart_match); > + > +static struct platform_driver uniphier_uart_platform_driver = { > + .probe = uniphier_uart_probe, > + .remove = uniphier_uart_remove, > + .driver = { > + .name = "uniphier-uart", > + .of_match_table = uniphier_uart_match, > + }, > +}; > +module_platform_driver(uniphier_uart_platform_driver); > + > +MODULE_AUTHOR("Masahiro Yamada "); > +MODULE_DESCRIPTION("UniPhier UART driver"); > +MODULE_LICENSE("GPL"); > diff --git a/drivers/tty/serial/8250/Kconfig b/drivers/tty/serial/8250/Kconfig > index c350703..3e1ae446 100644 > --- a/drivers/tty/serial/8250/Kconfig > +++ b/drivers/tty/serial/8250/Kconfig > @@ -342,3 +342,10 @@ config SERIAL_8250_MT6577 > help > If you have a Mediatek based board and want to use the > serial port, say Y to this option. If unsure, say N. > + > +config SERIAL_8250_UNIPHIER > + tristate "Support for UniPhier on-chip UART" > + depends on SERIAL_8250 && ARCH_UNIPHIER > + help > + If you have a UniPhier based board and want to use the on-chip > + serial ports, say Y to this option. If unsure, say N. > diff --git a/drivers/tty/serial/8250/Makefile b/drivers/tty/serial/8250/Makefile > index 31e7cdc..f7ca8c3 100644 > --- a/drivers/tty/serial/8250/Makefile > +++ b/drivers/tty/serial/8250/Makefile > @@ -23,3 +23,4 @@ obj-$(CONFIG_SERIAL_8250_EM) += 8250_em.o > obj-$(CONFIG_SERIAL_8250_OMAP) += 8250_omap.o > obj-$(CONFIG_SERIAL_8250_FINTEK) += 8250_fintek.o > obj-$(CONFIG_SERIAL_8250_MT6577) += 8250_mtk.o > +obj-$(CONFIG_SERIAL_8250_UNIPHIER) += 8250_uniphier.o -- Andy Shevchenko Intel Finland Oy --------------------------------------------------------------------- Intel Finland Oy Registered Address: PL 281, 00181 Helsinki Business Identity Code: 0357606 - 4 Domiciled in Helsinki This e-mail and any attachments may contain confidential material for the sole use of the intended recipient(s). Any review or distribution by others is strictly prohibited. If you are not the intended recipient, please contact the sender and delete all copies. From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751774AbbEYJOP (ORCPT ); Mon, 25 May 2015 05:14:15 -0400 Received: from mga03.intel.com ([134.134.136.65]:61743 "EHLO mga03.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750971AbbEYJOL (ORCPT ); Mon, 25 May 2015 05:14:11 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.13,491,1427785200"; d="scan'208";a="731251948" From: "Shevchenko, Andriy" To: "yamada.masahiro@socionext.com" CC: "manabian@gmail.com" , "bigeasy@linutronix.de" , "linux-kernel@vger.kernel.org" , "alan@lxorguk.ukuu.org.uk" , "ricardo.ribalda@gmail.com" , "alan@linux.intel.com" , "blogic@openwrt.org" , "linux-serial@vger.kernel.org" , "gregkh@linuxfoundation.org" , "jslaby@suse.cz" , "matthias.bgg@gmail.com" , "peter@hurleysoftware.com" , "linux-arm-kernel@lists.infradead.org" Subject: Re: [PATCH v6] serial: 8250_uniphier: add UniPhier serial driver Thread-Topic: [PATCH v6] serial: 8250_uniphier: add UniPhier serial driver Thread-Index: AQHQlp1fSViTbfCFTEeK18jo2NRp8Z2MWE2A Date: Mon, 25 May 2015 09:14:06 +0000 Message-ID: <1432545245.8736.5.camel@intel.com> References: <1432525477-14051-1-git-send-email-yamada.masahiro@socionext.com> In-Reply-To: <1432525477-14051-1-git-send-email-yamada.masahiro@socionext.com> Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-originating-ip: [10.237.72.90] Content-Type: text/plain; charset="utf-8" Content-ID: <7C1905571DE9974BA2FC1D39AEAA13B7@intel.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 nfs id t4P9ENUS004857 On Mon, 2015-05-25 at 12:44 +0900, Masahiro Yamada wrote: > Add the driver for on-chip UART used on UniPhier SoCs. > > This hardware is similar to 8250, but the register mapping is > slightly different: > - The offset to FCR, MCR is different. > - The divisor latch access bit does not exist. Instead, the > divisor latch register is available at offset 9. > > This driver overrides serial_{in,out}, dl_{read,write} callbacks, > but wants to borrow most of code from 8250_core.c. Do not send series too often, let people to review what you did. More comments below. > > Signed-off-by: Masahiro Yamada > Reviewed-by: Matthias Brugger > --- > > Changes in v6: > - Drop unnecessary #include > (it is covered by #include "8250.h") > > Changes in v5: > - Set up.port.mapsize > - Pass NULL rahter than 0 to the second argument of devm_clk_get() > > Changes in v4: > - Use spin_lock for read-modify-write register access > - Add /* fall through */ comments where I intentionally > did not add "break"; > - Drop unnecessary #include > - Drop unnecessary #include > - Add an empty line between #include <> and "" > - Use platform_get_irq() instead of platform_get_resource() > > Changes in v3: > - Just add *_SHIFT macro for the special case > > Changes in v2: > - Drop unnecessary #include > - Sort includes in alphabetical order > - Use devm_clk_get() rather than of_clk_get() > - Delete unneeded clk_put() from uniphier_uart_remove callback > - Delete unneeded IS_ERR_OR_NULL check from uniphier_uart_remove callback > - Use UNIPHIER_UART_*_SHIFT instead of hard-coded shift values > - Change the first argument type of uniphier_of_serial_setup() > from (struct platform_device *) to (struct device *) for code-cleanup. > > drivers/tty/serial/8250/8250_uniphier.c | 257 ++++++++++++++++++++++++++++++++ > drivers/tty/serial/8250/Kconfig | 7 + > drivers/tty/serial/8250/Makefile | 1 + > 3 files changed, 265 insertions(+) > create mode 100644 drivers/tty/serial/8250/8250_uniphier.c > > diff --git a/drivers/tty/serial/8250/8250_uniphier.c b/drivers/tty/serial/8250/8250_uniphier.c > new file mode 100644 > index 0000000..6f1e997 > --- /dev/null > +++ b/drivers/tty/serial/8250/8250_uniphier.c > @@ -0,0 +1,257 @@ > +/* > + * Copyright (C) 2015 Masahiro Yamada > + * > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License as published by > + * the Free Software Foundation; either version 2 of the License, or > + * (at your option) any later version. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + */ > + > +#include > +#include > +#include > +#include > +#include > + > +#include "8250.h" > + > +/* Most (but not all) of UniPhier UART devices have 64-depth FIFO. */ > +#define UNIPHIER_UART_DEFAULT_FIFO_SIZE 64 > + > +#define UNIPHIER_UART_CHAR_FCR 3 /* Character / FIFO Control Register */ > +#define UNIPHIER_UART_LCR_MCR 4 /* Line/Modem Control Register */ > +#define UNIPHIER_UART_LCR_SHIFT 8 Indentation problem, needs to be fixed. > +#define UNIPHIER_UART_DLR 9 /* Divisor Latch Register */ > + > +struct uniphier8250_priv { > + int line; > + struct clk *clk; > + spinlock_t atomic_write_lock; > +}; > + > +/* > + * The register map is slightly different from that of 8250. > + * IO callbacks must be overridden for correct access to FCR, LCR, and MCR. > + */ > +static unsigned int uniphier_serial_in(struct uart_port *p, int offset) > +{ > + int valshift = 0; Perhaps unsigned int? > + > + switch (offset) { > + case UART_LCR: > + valshift = UNIPHIER_UART_LCR_SHIFT; > + /* fall through */ > + case UART_MCR: > + offset = UNIPHIER_UART_LCR_MCR; > + break; > + default: > + break; > + } > + > + offset <<= p->regshift; > + > + /* > + * The return value must be masked with 0xff because LCR and MCR reside > + * in the same register that must be accessed by 32-bit write/read. > + * 8 or 16 bit access to this hardware result in unexpected behavior. > + */ > + return (readl(p->membase + offset) >> valshift) & 0xff; > +} > + > +static void uniphier_serial_out(struct uart_port *p, int offset, int value) > +{ > + int valshift = 0; Ditto. > + bool normal = false; > + > + switch (offset) { > + case UART_FCR: > + offset = UNIPHIER_UART_CHAR_FCR; > + break; > + case UART_LCR: > + valshift = UNIPHIER_UART_LCR_SHIFT; > + /* Divisor latch access bit does not exist. */ > + value &= ~(UART_LCR_DLAB << valshift); > + /* fall through */ > + case UART_MCR: > + offset = UNIPHIER_UART_LCR_MCR; > + break; > + default: > + normal = true; > + break; > + } > + > + offset <<= p->regshift; > + > + if (normal) { > + writel(value, p->membase + offset); Perhaps put this in place where normal == true and use return instead of break? > + } else { > + /* > + * Special case: two registers share the same address that > + * must be 32-bit accessed. As this is not longer atomic safe, > + * take a lock just in case. > + */ > + struct uniphier8250_priv *priv = p->private_data; > + unsigned long flags; > + u32 tmp; > + > + spin_lock_irqsave(&priv->atomic_write_lock, flags); > + tmp = readl(p->membase + offset); > + tmp &= ~(0xff << valshift); > + tmp |= value << valshift; > + writel(tmp, p->membase + offset); > + spin_unlock_irqrestore(&priv->atomic_write_lock, flags); > + } > +} > + > +/* > + * This hardware does not have the divisor latch access bit. > + * The divisor latch register exists at different address. > + * Override dl_read/write callbacks. > + */ > +static int uniphier_serial_dl_read(struct uart_8250_port *up) > +{ > + return readl(up->port.membase + UNIPHIER_UART_DLR); > +} > + > +static void uniphier_serial_dl_write(struct uart_8250_port *up, int value) > +{ > + writel(value, up->port.membase + UNIPHIER_UART_DLR); > +} > + > +static int uniphier_of_serial_setup(struct device *dev, struct uart_port *port, > + struct uniphier8250_priv *priv) > +{ > + int ret; > + u32 prop; > + struct device_node *np = dev->of_node; > + > + ret = of_alias_get_id(np, "serial"); > + if (ret < 0) { > + dev_err(dev, "failed to get alias id\n"); > + return ret; > + } > + port->line = priv->line = ret; > + > + /* Get clk rate through clk driver */ > + priv->clk = devm_clk_get(dev, NULL); > + if (IS_ERR(priv->clk)) { > + dev_err(dev, "failed to get clock\n"); > + return PTR_ERR(priv->clk); > + } > + > + ret = clk_prepare_enable(priv->clk); > + if (ret < 0) > + return ret; > + > + port->uartclk = clk_get_rate(priv->clk); > + > + /* Check for fifo size */ > + if (of_property_read_u32(np, "fifo-size", &prop) == 0) > + port->fifosize = prop; > + else > + port->fifosize = UNIPHIER_UART_DEFAULT_FIFO_SIZE; > + > + return 0; > +} > + > +static int uniphier_uart_probe(struct platform_device *pdev) > +{ > + struct device *dev = &pdev->dev; > + struct uart_8250_port up; > + struct uniphier8250_priv *priv; > + struct resource *regs; > + void __iomem *membase; > + int irq; > + int ret; > + > + regs = platform_get_resource(pdev, IORESOURCE_MEM, 0); > + if (!regs) { > + dev_err(dev, "failed to get memory resource"); > + return -EINVAL; > + } > + > + membase = devm_ioremap(dev, regs->start, resource_size(regs)); > + if (!membase) > + return -ENOMEM; > + > + irq = platform_get_irq(pdev, 0); > + if (irq < 0) { > + dev_err(dev, "failed to get IRQ number"); > + return irq; > + } > + > + priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); > + if (!priv) > + return -ENOMEM; > + > + memset(&up, 0, sizeof(up)); > + > + ret = uniphier_of_serial_setup(dev, &up.port, priv); > + if (ret < 0) > + return ret; > + > + spin_lock_init(&priv->atomic_write_lock); > + > + up.port.dev = dev; > + up.port.private_data = priv; > + up.port.mapbase = regs->start; > + up.port.mapsize = resource_size(regs); > + up.port.membase = membase; > + up.port.irq = irq; > + > + up.port.type = PORT_16550A; > + up.port.iotype = UPIO_MEM32; > + up.port.regshift = 2; > + up.port.flags = UPF_FIXED_PORT | UPF_FIXED_TYPE; > + up.capabilities = UART_CAP_FIFO; > + > + up.port.serial_in = uniphier_serial_in; > + up.port.serial_out = uniphier_serial_out; > + up.dl_read = uniphier_serial_dl_read; > + up.dl_write = uniphier_serial_dl_write; > + > + ret = serial8250_register_8250_port(&up); > + if (ret < 0) { > + dev_err(dev, "failed to register 8250 port\n"); > + return ret; > + } > + > + platform_set_drvdata(pdev, priv); > + > + return 0; > +} > + > +static int uniphier_uart_remove(struct platform_device *pdev) > +{ > + struct uniphier8250_priv *priv = platform_get_drvdata(pdev); > + > + serial8250_unregister_port(priv->line); > + clk_disable_unprepare(priv->clk); > + > + return 0; > +} > + > +static const struct of_device_id uniphier_uart_match[] = { > + { .compatible = "socionext,uniphier-uart" }, > + { /* sentinel */ } > +}; > +MODULE_DEVICE_TABLE(of, uniphier_uart_match); > + > +static struct platform_driver uniphier_uart_platform_driver = { > + .probe = uniphier_uart_probe, > + .remove = uniphier_uart_remove, > + .driver = { > + .name = "uniphier-uart", > + .of_match_table = uniphier_uart_match, > + }, > +}; > +module_platform_driver(uniphier_uart_platform_driver); > + > +MODULE_AUTHOR("Masahiro Yamada "); > +MODULE_DESCRIPTION("UniPhier UART driver"); > +MODULE_LICENSE("GPL"); > diff --git a/drivers/tty/serial/8250/Kconfig b/drivers/tty/serial/8250/Kconfig > index c350703..3e1ae446 100644 > --- a/drivers/tty/serial/8250/Kconfig > +++ b/drivers/tty/serial/8250/Kconfig > @@ -342,3 +342,10 @@ config SERIAL_8250_MT6577 > help > If you have a Mediatek based board and want to use the > serial port, say Y to this option. If unsure, say N. > + > +config SERIAL_8250_UNIPHIER > + tristate "Support for UniPhier on-chip UART" > + depends on SERIAL_8250 && ARCH_UNIPHIER > + help > + If you have a UniPhier based board and want to use the on-chip > + serial ports, say Y to this option. If unsure, say N. > diff --git a/drivers/tty/serial/8250/Makefile b/drivers/tty/serial/8250/Makefile > index 31e7cdc..f7ca8c3 100644 > --- a/drivers/tty/serial/8250/Makefile > +++ b/drivers/tty/serial/8250/Makefile > @@ -23,3 +23,4 @@ obj-$(CONFIG_SERIAL_8250_EM) += 8250_em.o > obj-$(CONFIG_SERIAL_8250_OMAP) += 8250_omap.o > obj-$(CONFIG_SERIAL_8250_FINTEK) += 8250_fintek.o > obj-$(CONFIG_SERIAL_8250_MT6577) += 8250_mtk.o > +obj-$(CONFIG_SERIAL_8250_UNIPHIER) += 8250_uniphier.o -- Andy Shevchenko Intel Finland Oy --------------------------------------------------------------------- Intel Finland Oy Registered Address: PL 281, 00181 Helsinki Business Identity Code: 0357606 - 4 Domiciled in Helsinki This e-mail and any attachments may contain confidential material for the sole use of the intended recipient(s). Any review or distribution by others is strictly prohibited. If you are not the intended recipient, please contact the sender and delete all copies. {.n++%ݶw{.n+{G{ayʇڙ,jfhz_(階ݢj"mG?&~iOzv^m ?I