From mboxrd@z Thu Jan 1 00:00:00 1970 From: Kevin Hilman Subject: Re: [PATCH v3 04/12] Serial: OMAP: Add runtime pm support for omap-serial driver Date: Mon, 27 Jun 2011 15:57:52 -0700 Message-ID: <87iprq7uhb.fsf@ti.com> References: <1307532194-13039-1-git-send-email-govindraj.raja@ti.com> <1307532194-13039-5-git-send-email-govindraj.raja@ti.com> <8739iyu7rh.fsf@ti.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: (Govindraj's message of "Mon, 27 Jun 2011 20:01:57 +0530") List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: linux-arm-kernel-bounces@lists.infradead.org Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=m.gmane.org@lists.infradead.org To: Govindraj Cc: Tony Lindgren , "Govindraj.R" , linux-omap@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-serial@vger.kernel.org List-Id: linux-omap@vger.kernel.org R292aW5kcmFqIDxnb3ZpbmRyYWoudGlAZ21haWwuY29tPiB3cml0ZXM6Cgo+IE9uIFNhdCwgSnVu IDI1LCAyMDExIGF0IDU6MDAgQU0sIEtldmluIEhpbG1hbiA8a2hpbG1hbkB0aS5jb20+IHdyb3Rl Ogo+PiAiR292aW5kcmFqLlIiIDxnb3ZpbmRyYWoucmFqYUB0aS5jb20+IHdyaXRlczoKPj4KPj4+ IEFkYXB0cyBvbWFwLXNlcmlhbCBkcml2ZXIgdG8gdXNlIHBtX3J1bnRpbWUgYXBpJ3MuCj4+Pgo+ Pj4gMS4pIFBvcHVsYXRlIHJlZyB2YWx1ZXMgdG8gdWFydCBwb3J0IHdoaWNoIGNhbiBiZSB1c2Vk IGZvciBjb250ZXh0IHJlc3RvcmUuCj4+Cj4+IFBsZWFzZSBtYWtlIHRoaXMgcGFydCBhIHNlcGFy YXRlIHBhdGNoLgo+Pgo+Pj4gMi4pIE1vdmluZyBjb250ZXh0X3Jlc3RvcmUgZnVuYyB0byBkcml2 ZXIgZnJvbSBzZXJpYWwuYwo+Pj4gMy4pIEFkZGluZyBwb3J0X2VuYWJsZS9kaXNhYmxlIGZ1bmMg dG8gZW5hYmxlL2Rpc2FibGUgZ2l2ZW4gdWFydCBwb3J0Lgo+Pj4gwqAgwqAgZW5hYmxlIHBvcnQg dXNpbmcgZ2V0X3N5bmMgYW5kIGRpc2FibGUgdXNpbmcgYXV0b3N1c3BlbmQuCj4+PiA0LikgdXNp bmcgcnVudGltZSBpcnEgc2FmZSBhcGkgdG8gbWFrZSBnZXRfc3luYyBiZSBjYWxsZWQgZnJvbSBp cnEgY29udGV4dC4KPj4KPj4+Cj4+PiBBY2tlZC1ieTogQWxhbiBDb3ggPGFsYW5AbGludXguaW50 ZWwuY29tPgo+Pj4gU2lnbmVkLW9mZi1ieTogR292aW5kcmFqLlIgPGdvdmluZHJhai5yYWphQHRp LmNvbT4KPj4KPj4gVGhpcyBpcyBncmVhdCEgwqB3ZSdyZSBhbG1vc3QgdGhlcmUuIMKgIFNvbWUg bWlub3IgY29tbWVudHMgYmVsb3cuLi4KPj4KPj4+IC0tLQo+Pj4gwqBhcmNoL2FybS9tYWNoLW9t YXAyL3NlcmlhbC5jIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgfCDCoCAyMiArKysKPj4+IMKg YXJjaC9hcm0vcGxhdC1vbWFwL2luY2x1ZGUvcGxhdC9vbWFwLXNlcmlhbC5oIHwgwqAgwqAyICsK Pj4+IMKgZHJpdmVycy90dHkvc2VyaWFsL29tYXAtc2VyaWFsLmMgwqAgwqAgwqAgwqAgwqAgwqAg wqB8IMKgMjEyICsrKysrKysrKysrKysrKysrKysrKystLS0KPj4+IMKgMyBmaWxlcyBjaGFuZ2Vk LCAyMTAgaW5zZXJ0aW9ucygrKSwgMjYgZGVsZXRpb25zKC0pCj4+Pgo+Pj4gZGlmZiAtLWdpdCBh L2FyY2gvYXJtL21hY2gtb21hcDIvc2VyaWFsLmMgYi9hcmNoL2FybS9tYWNoLW9tYXAyL3Nlcmlh bC5jCj4+PiBpbmRleCA4YzFhNGM3Li4xNjUxYzJjIDEwMDY0NAo+Pj4gLS0tIGEvYXJjaC9hcm0v bWFjaC1vbWFwMi9zZXJpYWwuYwo+Pj4gKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9zZXJpYWwu Ywo+Pj4gQEAgLTE4OSw2ICsxODksMjcgQEAgc3RhdGljIHZvaWQgb21hcF9zZXJpYWxfZmlsbF9k ZWZhdWx0X3BhZHMoc3RydWN0IG9tYXBfYm9hcmRfZGF0YSAqYmRhdGEpCj4+PiDCoCDCoCDCoCB9 Cj4+PiDCoH0KPj4+Cj4+PiArc3RhdGljIHZvaWQgb21hcF91YXJ0X3dha2V1cF9lbmFibGUoc3Ry dWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiwgYm9vbCBlbmFibGUpCj4+PiArewo+Pj4gKyDCoCDC oCBzdHJ1Y3Qgb21hcF91YXJ0X3BvcnRfaW5mbyAqdXAgPSBwZGV2LT5kZXYucGxhdGZvcm1fZGF0 YTsKPj4+ICsKPj4+ICsgwqAgwqAgLyogU2V0IG9yIGNsZWFyIHdha2UtZW5hYmxlIGJpdCAqLwo+ Pj4gKyDCoCDCoCBpZiAodXAtPndrX2VuICYmIHVwLT53a19tYXNrKSB7Cj4+PiArIMKgIMKgIMKg IMKgIMKgIMKgIHUzMiB2ID0gX19yYXdfcmVhZGwodXAtPndrX2VuKTsKPj4+ICsgwqAgwqAgwqAg wqAgwqAgwqAgaWYgKGVuYWJsZSkKPj4+ICsgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg diB8PSB1cC0+d2tfbWFzazsKPj4+ICsgwqAgwqAgwqAgwqAgwqAgwqAgZWxzZQo+Pj4gKyDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCB2ICY9IH51cC0+d2tfbWFzazsKPj4+ICsgwqAgwqAg wqAgwqAgwqAgwqAgX19yYXdfd3JpdGVsKHYsIHVwLT53a19lbik7Cj4+PiArIMKgIMKgIH0KPj4K Pj4gSSB0aGluayBJIGFza2VkIHRoaXMgaW4gcHJldmlvdXMgc2VyaWVzLCBidXQgY2FuJ3QgcmVt ZW1iZXIgdGhlIGFuc3dlcgo+PiBub3cuLi4gwqBjYW4ndCB3ZSBlbmFibGUgYml0cyBpbiB0aGUg V0tFTiByZWdpc3RlcnMgb25jZSBhdCBpbml0IHRpbWUsCj4+IGFuZCB0aGVuIGp1c3QgdXNlIG9t YXBfaHdtb2RfW2VuYWJsZXxkaXNhYmxlXV93YWtldXAoKSBoZXJlPwo+Pgo+Cj4gYnkgZGVmYXVs dCBhbGwgYml0cyBhcmUgZW5hYmxlZCBpbiBXS0VOLAoKd2hlcmUgZGVmYXVsdCBpcyB0aGUgUFJD TSBpbml0IGNvZGUsIHllcy4KCj4gSSB3aWxsIHVzZSBvbWFwX2h3bW9kX1tlbmFibGV8ZGlzYWJs ZV1fd2FrZXVwKCkgYXBpJ3MKPgo+IGlmIHRoZXNlIEFQSSdzIHRha2UgY2FyZSBvZiBXS0VOIHJl Z3MsIHRoZW4gbm8gaXNzdWUKPiB1c2luZyB0aGUgc2FtZS4KCk5vLCB0aGVzZSBBUElzIG9ubHkg YWZmZWN0IHRoZSBtb2R1bGUtbGV2ZWwgd2FrZXVwIGJpdCBpbiB0aGUgbW9kdWxlcwpTWVNDT05G SUcgcmVnaXN0ZXIgKEVOQVdBS0VVUCBiaXQuKQoKTXkgcXVlc3Rpb24gaXMgYXNzdW1pbmcgdGhl IFBSQ00gV0tFTiBiaXRzIGFyZSBqdXN0IGxlZnQgZW5hYmxlZCwgaXMKc2ltcGx5IHRvZ2dsaW5n IHRoZSBtb2R1bGVzIFNZU0NPTkZJRy5FTkFXQUtFVVAgYml0IGVub3VnaCB0bwplbmFibGUvZGlz YWJsZSBtb2R1bGUgd2FrZXVwcy4gIEkgYXNzdW1lIHNvLCBidXQgaGF2ZSBub3QgdmFsaWRhdGVk IGl0LgoKPj4+ICsgwqAgwqAgLyogRW5hYmxlIG9yIGNsZWFyIGlvLXBhZCB3YWtldXAgKi8KPj4+ ICsgwqAgwqAgaWYgKGVuYWJsZSkKPj4+ICsgwqAgwqAgwqAgwqAgwqAgwqAgb21hcF9kZXZpY2Vf ZW5hYmxlX2lvcmluZ193YWtldXAocGRldik7Cj4+PiArIMKgIMKgIGVsc2UKPj4+ICsgwqAgwqAg wqAgwqAgwqAgwqAgb21hcF9kZXZpY2VfZGlzYWJsZV9pb3Jpbmdfd2FrZXVwKHBkZXYpOwo+Pj4g K30KPj4+ICsKPj4+IMKgc3RhdGljIHZvaWQgb21hcF91YXJ0X2lkbGVfaW5pdChzdHJ1Y3Qgb21h cF91YXJ0X3BvcnRfaW5mbyAqdWFydCwKPj4+IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIHVuc2lnbmVkIHNob3J0IG51bSkKPj4+IMKgewo+Pj4gQEAgLTMzMiw2 ICszNTMsNyBAQCB2b2lkIF9faW5pdCBvbWFwX3NlcmlhbF9pbml0X3BvcnQoc3RydWN0IG9tYXBf Ym9hcmRfZGF0YSAqYmRhdGEpCj4+Pgo+Pj4gwqAgwqAgwqAgcGRhdGEtPnVhcnRjbGsgPSBPTUFQ MjRYWF9CQVNFX0JBVUQgKiAxNjsKPj4+IMKgIMKgIMKgIHBkYXRhLT5mbGFncyA9IFVQRl9CT09U X0FVVE9DT05GOwo+Pj4gKyDCoCDCoCBwZGF0YS0+ZW5hYmxlX3dha2V1cCA9IG9tYXBfdWFydF93 YWtldXBfZW5hYmxlOwo+Pj4gwqAgwqAgwqAgaWYgKGJkYXRhLT5pZCA9PSBvbWFwX3VhcnRfY29u X2lkKQo+Pj4gwqAgwqAgwqAgwqAgwqAgwqAgwqAgcGRhdGEtPmNvbnNvbGVfdWFydCA9IHRydWU7 Cj4+Pgo+Pj4gZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtb21hcC9pbmNsdWRlL3BsYXQvb21h cC1zZXJpYWwuaCBiL2FyY2gvYXJtL3BsYXQtb21hcC9pbmNsdWRlL3BsYXQvb21hcC1zZXJpYWwu aAo+Pj4gaW5kZXggMmNhODg1Yi4uYWMzMGRlOCAxMDA2NDQKPj4+IC0tLSBhL2FyY2gvYXJtL3Bs YXQtb21hcC9pbmNsdWRlL3BsYXQvb21hcC1zZXJpYWwuaAo+Pj4gKysrIGIvYXJjaC9hcm0vcGxh dC1vbWFwL2luY2x1ZGUvcGxhdC9vbWFwLXNlcmlhbC5oCj4+PiBAQCAtNjUsNiArNjUsNyBAQCBz dHJ1Y3Qgb21hcF91YXJ0X3BvcnRfaW5mbyB7Cj4+PiDCoCDCoCDCoCB1bnNpZ25lZCBpbnQgwqAg wqAgwqAgwqAgwqAgwqBlcnJhdGE7Cj4+PiDCoCDCoCDCoCB1bnNpZ25lZCBpbnQgwqAgwqAgwqAg wqAgwqAgwqBjb25zb2xlX3VhcnQ7Cj4+Pgo+Pj4gKyDCoCDCoCB2b2lkICgqZW5hYmxlX3dha2V1 cCkoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqLCBib29sKTsKPj4+IMKgIMKgIMKgIHZvaWQgX19p b21lbSAqd2tfc3Q7Cj4+PiDCoCDCoCDCoCB2b2lkIF9faW9tZW0gKndrX2VuOwo+Pj4gwqAgwqAg wqAgdTMyIHdrX21hc2s7Cj4+PiBAQCAtMTIwLDYgKzEyMSw3IEBAIHN0cnVjdCB1YXJ0X29tYXBf cG9ydCB7Cj4+PiDCoCDCoCDCoCBjaGFyIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgbmFt ZVsyMF07Cj4+PiDCoCDCoCDCoCB1bnNpZ25lZCBsb25nIMKgIMKgIMKgIMKgIMKgIHBvcnRfYWN0 aXZpdHk7Cj4+PiDCoCDCoCDCoCB1bnNpZ25lZCBpbnQgwqAgwqAgwqAgwqAgwqAgwqBlcnJhdGE7 Cj4+PiArIMKgIMKgIHZvaWQgKCplbmFibGVfd2FrZXVwKShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNl ICosIGJvb2wpOwo+Pj4gwqB9Owo+Pj4KPj4+IMKgI2VuZGlmIC8qIF9fT01BUF9TRVJJQUxfSF9f ICovCj4+PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy90dHkvc2VyaWFsL29tYXAtc2VyaWFsLmMgYi9k cml2ZXJzL3R0eS9zZXJpYWwvb21hcC1zZXJpYWwuYwo+Pj4gaW5kZXggNDdjYWRmNC4uODk3NDE2 ZiAxMDA2NDQKPj4+IC0tLSBhL2RyaXZlcnMvdHR5L3NlcmlhbC9vbWFwLXNlcmlhbC5jCj4+PiAr KysgYi9kcml2ZXJzL3R0eS9zZXJpYWwvb21hcC1zZXJpYWwuYwo+Pj4gQEAgLTM3LDEwICszNywx NCBAQAo+Pj4gwqAjaW5jbHVkZSA8bGludXgvY2xrLmg+Cj4+PiDCoCNpbmNsdWRlIDxsaW51eC9z ZXJpYWxfY29yZS5oPgo+Pj4gwqAjaW5jbHVkZSA8bGludXgvaXJxLmg+Cj4+PiArI2luY2x1ZGUg PGxpbnV4L3BtX3J1bnRpbWUuaD4KPj4+Cj4+PiDCoCNpbmNsdWRlIDxwbGF0L2RtYS5oPgo+Pj4g wqAjaW5jbHVkZSA8cGxhdC9kbXRpbWVyLmg+Cj4+PiDCoCNpbmNsdWRlIDxwbGF0L29tYXAtc2Vy aWFsLmg+Cj4+PiArI2luY2x1ZGUgPHBsYXQvb21hcF9kZXZpY2UuaD4KPj4+ICsKPj4+ICsjZGVm aW5lIE9NQVBfVUFSVF9BVVRPU1VTUEVORF9ERUxBWSAoMzAgKiBIWikgLyogVmFsdWUgaXMgbXNl Y3MgKi8KPj4KPj4gQXMgSm9uIGFscmVhZHkgcG9pbnRlZCBvdXQsIHRoZSBIWiBoZXJlIGlzIHdy b25nLiDCoFBsZWFzZSBkZWZpbmUgdGhpcwo+PiB2YWx1ZSBpbiBtc2Vjcy4KPj4KPgo+IGNvcnJl Y3RlZC4KPgo+Pj4gwqBzdGF0aWMgc3RydWN0IHVhcnRfb21hcF9wb3J0ICp1aVtPTUFQX01BWF9I U1VBUlRfUE9SVFNdOwo+Pj4KPj4+IEBAIC05NCw2ICs5OCwxNyBAQCBzZXJpYWxfb21hcF9nZXRf ZGl2aXNvcihzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0LCB1bnNpZ25lZCBpbnQgYmF1ZCkKPj4+IMKg IMKgIMKgIHJldHVybiBwb3J0LT51YXJ0Y2xrLyhiYXVkICogZGl2aXNvcik7Cj4+PiDCoH0KPj4+ Cj4+PiArc3RhdGljIGlubGluZSB2b2lkIHNlcmlhbF9vbWFwX3BvcnRfZGlzYWJsZShzdHJ1Y3Qg dWFydF9vbWFwX3BvcnQgKnVwKQo+Pj4gK3sKPj4+ICsgwqAgwqAgcG1fcnVudGltZV9tYXJrX2xh c3RfYnVzeSgmdXAtPnBkZXYtPmRldik7Cj4+PiArIMKgIMKgIHBtX3J1bnRpbWVfcHV0X2F1dG9z dXNwZW5kKCZ1cC0+cGRldi0+ZGV2KTsKPj4+ICt9Cj4+PiArCj4+PiArc3RhdGljIGlubGluZSB2 b2lkIHNlcmlhbF9vbWFwX3BvcnRfZW5hYmxlKHN0cnVjdCB1YXJ0X29tYXBfcG9ydCAqdXApCj4+ PiArewo+Pj4gKyDCoCDCoCBwbV9ydW50aW1lX2dldF9zeW5jKCZ1cC0+cGRldi0+ZGV2KTsKPj4+ ICt9Cj4+Cj4+IFRoZXNlIGlubGluZXMgYXJlIG5vdCBuZWVkZWQuIMKgUGxlYXNlIHVzZSBydW50 aW1lIFBNIGNhbGxzIGRpcmVjdGx5IGluCj4+IHRoZSBjb2RlLiDCoEZvciBfZW5hYmxlKCksIHRo aXMgaXMgc3RyYWlnaHQgZm9yd2FyZC4gwqBGb3IgX2Rpc2FibGUoKQo+PiB0aG91Z2gsIEkgZG9u J3QgdGhpbmsgeW91IHdhbnQgKG9yIG5lZWQpIHRvIF9tYXJrX2xhc3RfYnVzeSgpIGZvciBldmVy eQo+PiBpbnN0YW5jZSBvZiBvbWFwX3BvcnRfZGlzYWJsZSgpLiDCoFlvdSBvbmx5IG5lZWQgdG8g ZG8gdGhpcyBmb3Igb25lcwo+PiBUWC9SWCB0cmFuc2FjdGlvbnMuLi4KPj4KPgo+IEZpbmUuIHdp bGwgbW9kaWZ5Lgo+Cj4KPj4+IMKgc3RhdGljIHZvaWQgc2VyaWFsX29tYXBfc3RvcF9yeGRtYShz dHJ1Y3QgdWFydF9vbWFwX3BvcnQgKnVwKQo+Pj4gwqB7Cj4+PiDCoCDCoCDCoCBpZiAodXAtPnVh cnRfZG1hLnJ4X2RtYV91c2VkKSB7Cj4+PiBAQCAtMTEwLDggKzEyNSwxMSBAQCBzdGF0aWMgdm9p ZCBzZXJpYWxfb21hcF9lbmFibGVfbXMoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCkKPj4+IMKgIMKg IMKgIHN0cnVjdCB1YXJ0X29tYXBfcG9ydCAqdXAgPSAoc3RydWN0IHVhcnRfb21hcF9wb3J0ICop cG9ydDsKPj4+Cj4+PiDCoCDCoCDCoCBkZXZfZGJnKHVwLT5wb3J0LmRldiwgInNlcmlhbF9vbWFw X2VuYWJsZV9tcyslZFxuIiwgdXAtPnBkZXYtPmlkKTsKPj4+ICsKPj4+ICsgwqAgwqAgc2VyaWFs X29tYXBfcG9ydF9lbmFibGUodXApOwo+Pj4gwqAgwqAgwqAgdXAtPmllciB8PSBVQVJUX0lFUl9N U0k7Cj4+PiDCoCDCoCDCoCBzZXJpYWxfb3V0KHVwLCBVQVJUX0lFUiwgdXAtPmllcik7Cj4+PiAr IMKgIMKgIHNlcmlhbF9vbWFwX3BvcnRfZGlzYWJsZSh1cCk7Cj4+Cj4+IC4uLmZvciBleGFtcGxl LCB0aGlzIG9uZSBpcyBub3QgcmVhbGx5IGFjdGl2aXR5IGJhc2VkLCBzbyBzaG91bGQKPj4gcHJv YmFibHkganVzdCBiZSBwbV9ydW50aW1lX2dldF9zeW5jKCksIHdyaXRlIHRoZSByZWdpc3Rlciwg dGhlbgo+PiBwbV9ydW50aW1lX3B1dCgpIChhc3luYyB2ZXJzaW9uLikKPj4KPj4gSSBkaWRuJ3Qg bG9vayBhdCBhbGwgdGhlIG90aGVycyBiZWxvdywgYnV0IHRoZXkgc2hvdWxkIGJlIGxvb2tlZCBh dAo+PiBpbmRpdmlkdWFsbHkuCj4+Cj4KPiBvay4gSSB3aWxsIGNoZWNrIHRoZW0uCj4KPj4+IMKg fQo+Pj4KPj4+IMKgc3RhdGljIHZvaWQgc2VyaWFsX29tYXBfc3RvcF90eChzdHJ1Y3QgdWFydF9w b3J0ICpwb3J0KQo+Pj4gQEAgLTEzMSwyMSArMTQ5LDI2IEBAIHN0YXRpYyB2b2lkIHNlcmlhbF9v bWFwX3N0b3BfdHgoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCkKPj4+IMKgIMKgIMKgIMKgIMKgIMKg IMKgIHVwLT51YXJ0X2RtYS50eF9kbWFfY2hhbm5lbCA9IE9NQVBfVUFSVF9ETUFfQ0hfRlJFRTsK Pj4+IMKgIMKgIMKgIH0KPj4+Cj4+PiArIMKgIMKgIHNlcmlhbF9vbWFwX3BvcnRfZW5hYmxlKHVw KTsKPj4+IMKgIMKgIMKgIGlmICh1cC0+aWVyICYgVUFSVF9JRVJfVEhSSSkgewo+Pj4gwqAgwqAg wqAgwqAgwqAgwqAgwqAgdXAtPmllciAmPSB+VUFSVF9JRVJfVEhSSTsKPj4+IMKgIMKgIMKgIMKg IMKgIMKgIMKgIHNlcmlhbF9vdXQodXAsIFVBUlRfSUVSLCB1cC0+aWVyKTsKPj4+IMKgIMKgIMKg IH0KPj4+ICsKPj4+ICsgwqAgwqAgc2VyaWFsX29tYXBfcG9ydF9kaXNhYmxlKHVwKTsKPj4+IMKg fQo+Pj4KPj4+IMKgc3RhdGljIHZvaWQgc2VyaWFsX29tYXBfc3RvcF9yeChzdHJ1Y3QgdWFydF9w b3J0ICpwb3J0KQo+Pj4gwqB7Cj4+PiDCoCDCoCDCoCBzdHJ1Y3QgdWFydF9vbWFwX3BvcnQgKnVw ID0gKHN0cnVjdCB1YXJ0X29tYXBfcG9ydCAqKXBvcnQ7Cj4+Pgo+Pj4gKyDCoCDCoCBzZXJpYWxf b21hcF9wb3J0X2VuYWJsZSh1cCk7Cj4+PiDCoCDCoCDCoCBpZiAodXAtPnVzZV9kbWEpCj4+PiDC oCDCoCDCoCDCoCDCoCDCoCDCoCBzZXJpYWxfb21hcF9zdG9wX3J4ZG1hKHVwKTsKPj4+IMKgIMKg IMKgIHVwLT5pZXIgJj0gflVBUlRfSUVSX1JMU0k7Cj4+PiDCoCDCoCDCoCB1cC0+cG9ydC5yZWFk X3N0YXR1c19tYXNrICY9IH5VQVJUX0xTUl9EUjsKPj4+IMKgIMKgIMKgIHNlcmlhbF9vdXQodXAs IFVBUlRfSUVSLCB1cC0+aWVyKTsKPj4+ICsgwqAgwqAgc2VyaWFsX29tYXBfcG9ydF9kaXNhYmxl KHVwKTsKPj4+IMKgfQo+Pj4KPj4+IMKgc3RhdGljIGlubGluZSB2b2lkIHJlY2VpdmVfY2hhcnMo c3RydWN0IHVhcnRfb21hcF9wb3J0ICp1cCwgaW50ICpzdGF0dXMpCj4+PiBAQCAtMjYxLDggKzI4 NCwxMCBAQCBzdGF0aWMgdm9pZCBzZXJpYWxfb21hcF9zdGFydF90eChzdHJ1Y3QgdWFydF9wb3J0 ICpwb3J0KQo+Pj4gwqAgwqAgwqAgdW5zaWduZWQgaW50IHN0YXJ0Owo+Pj4gwqAgwqAgwqAgaW50 IHJldCA9IDA7Cj4+Pgo+Pj4gKyDCoCDCoCBzZXJpYWxfb21hcF9wb3J0X2VuYWJsZSh1cCk7Cj4+ PiDCoCDCoCDCoCBpZiAoIXVwLT51c2VfZG1hKSB7Cj4+PiDCoCDCoCDCoCDCoCDCoCDCoCDCoCBz ZXJpYWxfb21hcF9lbmFibGVfaWVyX3RocmkodXApOwo+Pj4gKyDCoCDCoCDCoCDCoCDCoCDCoCBz ZXJpYWxfb21hcF9wb3J0X2Rpc2FibGUodXApOwo+Pj4gwqAgwqAgwqAgwqAgwqAgwqAgwqAgcmV0 dXJuOwo+Pj4gwqAgwqAgwqAgfQo+Pj4KPj4+IEBAIC0zNTQsOSArMzc5LDEyIEBAIHN0YXRpYyBp bmxpbmUgaXJxcmV0dXJuX3Qgc2VyaWFsX29tYXBfaXJxKGludCBpcnEsIHZvaWQgKmRldl9pZCkK Pj4+IMKgIMKgIMKgIHVuc2lnbmVkIGludCBpaXIsIGxzcjsKPj4+IMKgIMKgIMKgIHVuc2lnbmVk IGxvbmcgZmxhZ3M7Cj4+Pgo+Pj4gKyDCoCDCoCBzZXJpYWxfb21hcF9wb3J0X2VuYWJsZSh1cCk7 Cj4+PiDCoCDCoCDCoCBpaXIgPSBzZXJpYWxfaW4odXAsIFVBUlRfSUlSKTsKPj4+IC0gwqAgwqAg aWYgKGlpciAmIFVBUlRfSUlSX05PX0lOVCkKPj4+ICsgwqAgwqAgaWYgKGlpciAmIFVBUlRfSUlS X05PX0lOVCkgewo+Pj4gKyDCoCDCoCDCoCDCoCDCoCDCoCBzZXJpYWxfb21hcF9wb3J0X2Rpc2Fi bGUodXApOwo+Pj4gwqAgwqAgwqAgwqAgwqAgwqAgwqAgcmV0dXJuIElSUV9OT05FOwo+Pj4gKyDC oCDCoCB9Cj4+Pgo+Pj4gwqAgwqAgwqAgc3Bpbl9sb2NrX2lycXNhdmUoJnVwLT5wb3J0LmxvY2ss IGZsYWdzKTsKPj4+IMKgIMKgIMKgIGxzciA9IHNlcmlhbF9pbih1cCwgVUFSVF9MU1IpOwo+Pj4g QEAgLTM3OCw2ICs0MDYsOCBAQCBzdGF0aWMgaW5saW5lIGlycXJldHVybl90IHNlcmlhbF9vbWFw X2lycShpbnQgaXJxLCB2b2lkICpkZXZfaWQpCj4+PiDCoCDCoCDCoCDCoCDCoCDCoCDCoCB0cmFu c21pdF9jaGFycyh1cCk7Cj4+Pgo+Pj4gwqAgwqAgwqAgc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgm dXAtPnBvcnQubG9jaywgZmxhZ3MpOwo+Pj4gKyDCoCDCoCBzZXJpYWxfb21hcF9wb3J0X2Rpc2Fi bGUodXApOwo+Pj4gKwo+Pj4gwqAgwqAgwqAgdXAtPnBvcnRfYWN0aXZpdHkgPSBqaWZmaWVzOwo+ Pj4gwqAgwqAgwqAgcmV0dXJuIElSUV9IQU5ETEVEOwo+Pj4gwqB9Cj4+PiBAQCAtMzg4LDExICs0 MTgsMTIgQEAgc3RhdGljIHVuc2lnbmVkIGludCBzZXJpYWxfb21hcF90eF9lbXB0eShzdHJ1Y3Qg dWFydF9wb3J0ICpwb3J0KQo+Pj4gwqAgwqAgwqAgdW5zaWduZWQgbG9uZyBmbGFncyA9IDA7Cj4+ PiDCoCDCoCDCoCB1bnNpZ25lZCBpbnQgcmV0ID0gMDsKPj4+Cj4+PiArIMKgIMKgIHNlcmlhbF9v bWFwX3BvcnRfZW5hYmxlKHVwKTsKPj4+IMKgIMKgIMKgIGRldl9kYmcodXAtPnBvcnQuZGV2LCAi c2VyaWFsX29tYXBfdHhfZW1wdHkrJWRcbiIsIHVwLT5wZGV2LT5pZCk7Cj4+PiDCoCDCoCDCoCBz cGluX2xvY2tfaXJxc2F2ZSgmdXAtPnBvcnQubG9jaywgZmxhZ3MpOwo+Pj4gwqAgwqAgwqAgcmV0 ID0gc2VyaWFsX2luKHVwLCBVQVJUX0xTUikgJiBVQVJUX0xTUl9URU1UID8gVElPQ1NFUl9URU1U IDogMDsKPj4+IMKgIMKgIMKgIHNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnVwLT5wb3J0LmxvY2ss IGZsYWdzKTsKPj4+IC0KPj4+ICsgwqAgwqAgc2VyaWFsX29tYXBfcG9ydF9kaXNhYmxlKHVwKTsK Pj4+IMKgIMKgIMKgIHJldHVybiByZXQ7Cj4+PiDCoH0KPj4+Cj4+PiBAQCAtNDAyLDcgKzQzMywx MCBAQCBzdGF0aWMgdW5zaWduZWQgaW50IHNlcmlhbF9vbWFwX2dldF9tY3RybChzdHJ1Y3QgdWFy dF9wb3J0ICpwb3J0KQo+Pj4gwqAgwqAgwqAgdW5zaWduZWQgY2hhciBzdGF0dXM7Cj4+PiDCoCDC oCDCoCB1bnNpZ25lZCBpbnQgcmV0ID0gMDsKPj4+Cj4+PiArIMKgIMKgIHNlcmlhbF9vbWFwX3Bv cnRfZW5hYmxlKHVwKTsKPj4+IMKgIMKgIMKgIHN0YXR1cyA9IGNoZWNrX21vZGVtX3N0YXR1cyh1 cCk7Cj4+PiArIMKgIMKgIHNlcmlhbF9vbWFwX3BvcnRfZGlzYWJsZSh1cCk7Cj4+PiArCj4+PiDC oCDCoCDCoCBkZXZfZGJnKHVwLT5wb3J0LmRldiwgInNlcmlhbF9vbWFwX2dldF9tY3RybCslZFxu IiwgdXAtPnBkZXYtPmlkKTsKPj4+Cj4+PiDCoCDCoCDCoCBpZiAoc3RhdHVzICYgVUFSVF9NU1Jf RENEKQo+Pj4gQEAgLTQzNCw3ICs0NjgsOSBAQCBzdGF0aWMgdm9pZCBzZXJpYWxfb21hcF9zZXRf bWN0cmwoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCwgdW5zaWduZWQgaW50IG1jdHJsKQo+Pj4gwqAg wqAgwqAgwqAgwqAgwqAgwqAgbWNyIHw9IFVBUlRfTUNSX0xPT1A7Cj4+Pgo+Pj4gwqAgwqAgwqAg bWNyIHw9IHVwLT5tY3I7Cj4+PiArIMKgIMKgIHNlcmlhbF9vbWFwX3BvcnRfZW5hYmxlKHVwKTsK Pj4+IMKgIMKgIMKgIHNlcmlhbF9vdXQodXAsIFVBUlRfTUNSLCBtY3IpOwo+Pj4gKyDCoCDCoCBz ZXJpYWxfb21hcF9wb3J0X2Rpc2FibGUodXApOwo+Pj4gwqB9Cj4+Pgo+Pj4gwqBzdGF0aWMgdm9p ZCBzZXJpYWxfb21hcF9icmVha19jdGwoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCwgaW50IGJyZWFr X3N0YXRlKQo+Pj4gQEAgLTQ0Myw2ICs0NzksNyBAQCBzdGF0aWMgdm9pZCBzZXJpYWxfb21hcF9i cmVha19jdGwoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCwgaW50IGJyZWFrX3N0YXRlKQo+Pj4gwqAg wqAgwqAgdW5zaWduZWQgbG9uZyBmbGFncyA9IDA7Cj4+Pgo+Pj4gwqAgwqAgwqAgZGV2X2RiZyh1 cC0+cG9ydC5kZXYsICJzZXJpYWxfb21hcF9icmVha19jdGwrJWRcbiIsIHVwLT5wZGV2LT5pZCk7 Cj4+PiArIMKgIMKgIHNlcmlhbF9vbWFwX3BvcnRfZW5hYmxlKHVwKTsKPj4+IMKgIMKgIMKgIHNw aW5fbG9ja19pcnFzYXZlKCZ1cC0+cG9ydC5sb2NrLCBmbGFncyk7Cj4+PiDCoCDCoCDCoCBpZiAo YnJlYWtfc3RhdGUgPT0gLTEpCj4+PiDCoCDCoCDCoCDCoCDCoCDCoCDCoCB1cC0+bGNyIHw9IFVB UlRfTENSX1NCQzsKPj4+IEBAIC00NTAsNiArNDg3LDcgQEAgc3RhdGljIHZvaWQgc2VyaWFsX29t YXBfYnJlYWtfY3RsKHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQsIGludCBicmVha19zdGF0ZSkKPj4+ IMKgIMKgIMKgIMKgIMKgIMKgIMKgIHVwLT5sY3IgJj0gflVBUlRfTENSX1NCQzsKPj4+IMKgIMKg IMKgIHNlcmlhbF9vdXQodXAsIFVBUlRfTENSLCB1cC0+bGNyKTsKPj4+IMKgIMKgIMKgIHNwaW5f dW5sb2NrX2lycXJlc3RvcmUoJnVwLT5wb3J0LmxvY2ssIGZsYWdzKTsKPj4+ICsgwqAgwqAgc2Vy aWFsX29tYXBfcG9ydF9kaXNhYmxlKHVwKTsKPj4+IMKgfQo+Pj4KPj4+IMKgc3RhdGljIGludCBz ZXJpYWxfb21hcF9zdGFydHVwKHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQpCj4+PiBAQCAtNDY4LDYg KzUwNiw3IEBAIHN0YXRpYyBpbnQgc2VyaWFsX29tYXBfc3RhcnR1cChzdHJ1Y3QgdWFydF9wb3J0 ICpwb3J0KQo+Pj4KPj4+IMKgIMKgIMKgIGRldl9kYmcodXAtPnBvcnQuZGV2LCAic2VyaWFsX29t YXBfc3RhcnR1cCslZFxuIiwgdXAtPnBkZXYtPmlkKTsKPj4+Cj4+PiArIMKgIMKgIHNlcmlhbF9v bWFwX3BvcnRfZW5hYmxlKHVwKTsKPj4+IMKgIMKgIMKgIC8qCj4+PiDCoCDCoCDCoCDCoCogQ2xl YXIgdGhlIEZJRk8gYnVmZmVycyBhbmQgZGlzYWJsZSB0aGVtLgo+Pj4gwqAgwqAgwqAgwqAqICh0 aGV5IHdpbGwgYmUgcmVlbmFibGVkIGluIHNldF90ZXJtaW9zKCkpCj4+PiBAQCAtNTIzLDYgKzU2 Miw3IEBAIHN0YXRpYyBpbnQgc2VyaWFsX29tYXBfc3RhcnR1cChzdHJ1Y3QgdWFydF9wb3J0ICpw b3J0KQo+Pj4gwqAgwqAgwqAgLyogRW5hYmxlIG1vZHVsZSBsZXZlbCB3YWtlIHVwICovCj4+PiDC oCDCoCDCoCBzZXJpYWxfb3V0KHVwLCBVQVJUX09NQVBfV0VSLCBPTUFQX1VBUlRfV0VSX01PRF9X S1VQKTsKPj4+Cj4+PiArIMKgIMKgIHNlcmlhbF9vbWFwX3BvcnRfZGlzYWJsZSh1cCk7Cj4+PiDC oCDCoCDCoCB1cC0+cG9ydF9hY3Rpdml0eSA9IGppZmZpZXM7Cj4+PiDCoCDCoCDCoCByZXR1cm4g MDsKPj4+IMKgfQo+Pj4gQEAgLTUzMyw2ICs1NzMsOCBAQCBzdGF0aWMgdm9pZCBzZXJpYWxfb21h cF9zaHV0ZG93bihzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0KQo+Pj4gwqAgwqAgwqAgdW5zaWduZWQg bG9uZyBmbGFncyA9IDA7Cj4+Pgo+Pj4gwqAgwqAgwqAgZGV2X2RiZyh1cC0+cG9ydC5kZXYsICJz ZXJpYWxfb21hcF9zaHV0ZG93bislZFxuIiwgdXAtPnBkZXYtPmlkKTsKPj4+ICsKPj4+ICsgwqAg wqAgc2VyaWFsX29tYXBfcG9ydF9lbmFibGUodXApOwo+Pj4gwqAgwqAgwqAgLyoKPj4+IMKgIMKg IMKgIMKgKiBEaXNhYmxlIGludGVycnVwdHMgZnJvbSB0aGlzIHBvcnQKPj4+IMKgIMKgIMKgIMKg Ki8KPj4+IEBAIC01NjYsNiArNjA4LDcgQEAgc3RhdGljIHZvaWQgc2VyaWFsX29tYXBfc2h1dGRv d24oc3RydWN0IHVhcnRfcG9ydCAqcG9ydCkKPj4+IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIHVwLT51YXJ0X2RtYS5yeF9idWZfZG1hX3BoeXMpOwo+Pj4gwqAgwqAgwqAgwqAgwqAg wqAgwqAgdXAtPnVhcnRfZG1hLnJ4X2J1ZiA9IE5VTEw7Cj4+PiDCoCDCoCDCoCB9Cj4+PiArIMKg IMKgIHNlcmlhbF9vbWFwX3BvcnRfZGlzYWJsZSh1cCk7Cj4+PiDCoCDCoCDCoCBmcmVlX2lycSh1 cC0+cG9ydC5pcnEsIHVwKTsKPj4+IMKgfQo+Pj4KPj4+IEBAIC02NzEsNiArNzE0LDEwIEBAIHNl cmlhbF9vbWFwX3NldF90ZXJtaW9zKHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQsIHN0cnVjdCBrdGVy bWlvcyAqdGVybWlvcywKPj4+IMKgIMKgIMKgIGJhdWQgPSB1YXJ0X2dldF9iYXVkX3JhdGUocG9y dCwgdGVybWlvcywgb2xkLCAwLCBwb3J0LT51YXJ0Y2xrLzEzKTsKPj4+IMKgIMKgIMKgIHF1b3Qg PSBzZXJpYWxfb21hcF9nZXRfZGl2aXNvcihwb3J0LCBiYXVkKTsKPj4+Cj4+PiArIMKgIMKgIHVw LT5kbGwgPSBxdW90ICYgMHhmZjsKPj4+ICsgwqAgwqAgdXAtPmRsaCA9IHF1b3QgPj4gODsKPj4+ ICsgwqAgwqAgdXAtPm1kcjEgPSBVQVJUX09NQVBfTURSMV9ESVNBQkxFOwo+Pj4gKwo+Pj4gwqAg wqAgwqAgdXAtPmZjciA9IFVBUlRfRkNSX1JfVFJJR18wMSB8IFVBUlRfRkNSX1RfVFJJR18wMSB8 Cj4+PiDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCBVQVJUX0ZDUl9FTkFCTEVfRklG TzsKPj4+IMKgIMKgIMKgIGlmICh1cC0+dXNlX2RtYSkKPj4+IEBAIC02ODAsNiArNzI3LDcgQEAg c2VyaWFsX29tYXBfc2V0X3Rlcm1pb3Moc3RydWN0IHVhcnRfcG9ydCAqcG9ydCwgc3RydWN0IGt0 ZXJtaW9zICp0ZXJtaW9zLAo+Pj4gwqAgwqAgwqAgwqAqIE9rLCB3ZSdyZSBub3cgY2hhbmdpbmcg dGhlIHBvcnQgc3RhdGUuIERvIGl0IHdpdGgKPj4+IMKgIMKgIMKgIMKgKiBpbnRlcnJ1cHRzIGRp c2FibGVkLgo+Pj4gwqAgwqAgwqAgwqAqLwo+Pj4gKyDCoCDCoCBzZXJpYWxfb21hcF9wb3J0X2Vu YWJsZSh1cCk7Cj4+PiDCoCDCoCDCoCBzcGluX2xvY2tfaXJxc2F2ZSgmdXAtPnBvcnQubG9jaywg ZmxhZ3MpOwo+Pj4KPj4+IMKgIMKgIMKgIC8qCj4+PiBAQCAtNzIzLDYgKzc3MSw3IEBAIHNlcmlh bF9vbWFwX3NldF90ZXJtaW9zKHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQsIHN0cnVjdCBrdGVybWlv cyAqdGVybWlvcywKPj4+IMKgIMKgIMKgIMKgIMKgIMKgIMKgIHVwLT5pZXIgfD0gVUFSVF9JRVJf TVNJOwo+Pj4gwqAgwqAgwqAgc2VyaWFsX291dCh1cCwgVUFSVF9JRVIsIHVwLT5pZXIpOwo+Pj4g wqAgwqAgwqAgc2VyaWFsX291dCh1cCwgVUFSVF9MQ1IsIGN2YWwpOyDCoCDCoCDCoCDCoCAvKiBy ZXNldCBETEFCICovCj4+PiArIMKgIMKgIHVwLT5sY3IgPSBjdmFsOwo+Pj4KPj4+IMKgIMKgIMKg IC8qIEZJRk9zIGFuZCBETUEgU2V0dGluZ3MgKi8KPj4+Cj4+PiBAQCAtNzU4LDggKzgwNyw3IEBA IHNlcmlhbF9vbWFwX3NldF90ZXJtaW9zKHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQsIHN0cnVjdCBr dGVybWlvcyAqdGVybWlvcywKPj4+IMKgIMKgIMKgIHNlcmlhbF9vdXQodXAsIFVBUlRfTUNSLCB1 cC0+bWNyKTsKPj4+Cj4+PiDCoCDCoCDCoCAvKiBQcm90b2NvbCwgQmF1ZCBSYXRlLCBhbmQgSW50 ZXJydXB0IFNldHRpbmdzICovCj4+PiAtCj4+PiAtIMKgIMKgIHNlcmlhbF9vdXQodXAsIFVBUlRf T01BUF9NRFIxLCBVQVJUX09NQVBfTURSMV9ESVNBQkxFKTsKPj4+ICsgwqAgwqAgc2VyaWFsX291 dCh1cCwgVUFSVF9PTUFQX01EUjEsIHVwLT5tZHIxKTsKPj4+IMKgIMKgIMKgIHNlcmlhbF9vdXQo dXAsIFVBUlRfTENSLCBVQVJUX0xDUl9DT05GX01PREVfQik7Cj4+Pgo+Pj4gwqAgwqAgwqAgdXAt PmVmciA9IHNlcmlhbF9pbih1cCwgVUFSVF9FRlIpOwo+Pj4gQEAgLTc2OSw4ICs4MTcsOCBAQCBz ZXJpYWxfb21hcF9zZXRfdGVybWlvcyhzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0LCBzdHJ1Y3Qga3Rl cm1pb3MgKnRlcm1pb3MsCj4+PiDCoCDCoCDCoCBzZXJpYWxfb3V0KHVwLCBVQVJUX0lFUiwgMCk7 Cj4+PiDCoCDCoCDCoCBzZXJpYWxfb3V0KHVwLCBVQVJUX0xDUiwgVUFSVF9MQ1JfQ09ORl9NT0RF X0IpOwo+Pj4KPj4+IC0gwqAgwqAgc2VyaWFsX291dCh1cCwgVUFSVF9ETEwsIHF1b3QgJiAweGZm KTsgwqAgwqAgwqAgwqAgwqAvKiBMUyBvZiBkaXZpc29yICovCj4+PiAtIMKgIMKgIHNlcmlhbF9v dXQodXAsIFVBUlRfRExNLCBxdW90ID4+IDgpOyDCoCDCoCDCoCDCoCDCoCDCoC8qIE1TIG9mIGRp dmlzb3IgKi8KPj4+ICsgwqAgwqAgc2VyaWFsX291dCh1cCwgVUFSVF9ETEwsIHVwLT5kbGwpOyDC oCDCoCDCoC8qIExTIG9mIGRpdmlzb3IgKi8KPj4+ICsgwqAgwqAgc2VyaWFsX291dCh1cCwgVUFS VF9ETE0sIHVwLT5kbGgpOyDCoCDCoCDCoC8qIE1TIG9mIGRpdmlzb3IgKi8KPj4+Cj4+PiDCoCDC oCDCoCBzZXJpYWxfb3V0KHVwLCBVQVJUX0xDUiwgMCk7Cj4+PiDCoCDCoCDCoCBzZXJpYWxfb3V0 KHVwLCBVQVJUX0lFUiwgdXAtPmllcik7Cj4+PiBAQCAtNzgwLDkgKzgyOCwxMSBAQCBzZXJpYWxf b21hcF9zZXRfdGVybWlvcyhzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0LCBzdHJ1Y3Qga3Rlcm1pb3Mg KnRlcm1pb3MsCj4+PiDCoCDCoCDCoCBzZXJpYWxfb3V0KHVwLCBVQVJUX0xDUiwgY3ZhbCk7Cj4+ Pgo+Pj4gwqAgwqAgwqAgaWYgKGJhdWQgPiAyMzA0MDAgJiYgYmF1ZCAhPSAzMDAwMDAwKQo+Pj4g LSDCoCDCoCDCoCDCoCDCoCDCoCBzZXJpYWxfb3V0KHVwLCBVQVJUX09NQVBfTURSMSwgVUFSVF9P TUFQX01EUjFfMTNYX01PREUpOwo+Pj4gKyDCoCDCoCDCoCDCoCDCoCDCoCB1cC0+bWRyMSA9IFVB UlRfT01BUF9NRFIxXzEzWF9NT0RFOwo+Pj4gwqAgwqAgwqAgZWxzZQo+Pj4gLSDCoCDCoCDCoCDC oCDCoCDCoCBzZXJpYWxfb3V0KHVwLCBVQVJUX09NQVBfTURSMSwgVUFSVF9PTUFQX01EUjFfMTZY X01PREUpOwo+Pj4gKyDCoCDCoCDCoCDCoCDCoCDCoCB1cC0+bWRyMSA9IFVBUlRfT01BUF9NRFIx XzE2WF9NT0RFOwo+Pj4gKwo+Pj4gKyDCoCDCoCBzZXJpYWxfb3V0KHVwLCBVQVJUX09NQVBfTURS MSwgdXAtPm1kcjEpCj4+Pgo+Pj4gwqAgwqAgwqAgLyogSGFyZHdhcmUgRmxvdyBDb250cm9sIENv bmZpZ3VyYXRpb24gKi8KPj4+Cj4+PiBAQCAtODEwLDYgKzg2MCw3IEBAIHNlcmlhbF9vbWFwX3Nl dF90ZXJtaW9zKHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQsIHN0cnVjdCBrdGVybWlvcyAqdGVybWlv cywKPj4+IMKgIMKgIMKgIMKgIMKgIMKgIMKgIHNlcmlhbF9vbWFwX2NvbmZpZ3VyZV94b254b2Zm KHVwLCB0ZXJtaW9zKTsKPj4+Cj4+PiDCoCDCoCDCoCBzcGluX3VubG9ja19pcnFyZXN0b3JlKCZ1 cC0+cG9ydC5sb2NrLCBmbGFncyk7Cj4+PiArIMKgIMKgIHNlcmlhbF9vbWFwX3BvcnRfZGlzYWJs ZSh1cCk7Cj4+PiDCoCDCoCDCoCBkZXZfZGJnKHVwLT5wb3J0LmRldiwgInNlcmlhbF9vbWFwX3Nl dF90ZXJtaW9zKyVkXG4iLCB1cC0+cGRldi0+aWQpOwo+Pj4gwqB9Cj4+Pgo+Pj4gQEAgLTgyMSw2 ICs4NzIsOCBAQCBzZXJpYWxfb21hcF9wbShzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0LCB1bnNpZ25l ZCBpbnQgc3RhdGUsCj4+PiDCoCDCoCDCoCB1bnNpZ25lZCBjaGFyIGVmcjsKPj4+Cj4+PiDCoCDC oCDCoCBkZXZfZGJnKHVwLT5wb3J0LmRldiwgInNlcmlhbF9vbWFwX3BtKyVkXG4iLCB1cC0+cGRl di0+aWQpOwo+Pj4gKwo+Pj4gKyDCoCDCoCBzZXJpYWxfb21hcF9wb3J0X2VuYWJsZSh1cCk7Cj4+ PiDCoCDCoCDCoCBzZXJpYWxfb3V0KHVwLCBVQVJUX0xDUiwgVUFSVF9MQ1JfQ09ORl9NT0RFX0Ip Owo+Pj4gwqAgwqAgwqAgZWZyID0gc2VyaWFsX2luKHVwLCBVQVJUX0VGUik7Cj4+PiDCoCDCoCDC oCBzZXJpYWxfb3V0KHVwLCBVQVJUX0VGUiwgZWZyIHwgVUFSVF9FRlJfRUNCKTsKPj4+IEBAIC04 MzAsNiArODgzLDEwIEBAIHNlcmlhbF9vbWFwX3BtKHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQsIHVu c2lnbmVkIGludCBzdGF0ZSwKPj4+IMKgIMKgIMKgIHNlcmlhbF9vdXQodXAsIFVBUlRfTENSLCBV QVJUX0xDUl9DT05GX01PREVfQik7Cj4+PiDCoCDCoCDCoCBzZXJpYWxfb3V0KHVwLCBVQVJUX0VG UiwgZWZyKTsKPj4+IMKgIMKgIMKgIHNlcmlhbF9vdXQodXAsIFVBUlRfTENSLCAwKTsKPj4+ICsg wqAgwqAgaWYgKHN0YXRlKQo+Pj4gKyDCoCDCoCDCoCDCoCDCoCDCoCBwbV9ydW50aW1lX3B1dF9z eW5jKCZ1cC0+cGRldi0+ZGV2KTsKPj4+ICsgwqAgwqAgZWxzZQo+Pj4gKyDCoCDCoCDCoCDCoCDC oCDCoCBzZXJpYWxfb21hcF9wb3J0X2Rpc2FibGUodXApOwo+Pgo+PiBPSywgc28gdGhpcyBib2ls cyBkb3duIHRvIGVpdGhlciBhIF9wdXRfc3luYygpIG9yIGEgX21hcmtfbGFzdF9idXN5ICsKPj4g X3B1dF9hdXRvc3VzcGVuZCgpLCBkZXBlbmRpbmcgb24gd2hldGhlciB0aGlzIGlzIHN1c3BlbmRp bmcgb3IgcmVzdW1pbmcsCj4+IHJpZ2h0Pwo+Pgo+Cj4geWVzIGFsc28gZHVyaW5nIGJvb3R1cC4K PiBkaXNhYmxlIHRoZSBwb3J0cyBpbW1lZGlhdGVseSB0aGF0IGFyZSBub3QgdXNlZCBkdXJpbmcg Ym9vdHVwLgo+Cj4+IFdoeSB0aGUgZGlmZmVyZW5jZT8KPgo+IE5lZWQgdG8gcHV0IHRoZSBwb3J0 cyBkb3duIGltbWVkaWF0ZWx5IGR1cmluZyBzeXN0ZW0gd2lkZSBzdXNwZW5kCj4gb3RoZXIgd2lz ZSBhdXRvc3VzcGVuZCBkZWxheSB3aWxsIHByZXZlbnQgc3lzdGVtIHRvIGVudGVyCj4gc3VzcGVu ZCBzdGF0ZSBpbW1lZGlhdGVseS4KCk9LLCBhcyBJIHN0YXRlZCBhYm92ZS4gIEFsbCBvZiB0aGVz ZSBzZXJpYWxfb21hcF9wb3J0X2Rpc2FibGUoKSBjYWxscwpuZWVkIHRvIGJlIHJlbW92ZWQgYW5k IHJlcGxhY2VkIHdpdGggcnVudGltZSBQTSBBUEkgY2FsbHMgZGlyZWN0bHkuCgpIZXJlLCBJIHRo aW5rIGl0IGNhbiBhbHdheXMgYmUgYSBiYXNpYyBfcHV0KCkgZm9yIHN1c3BlbmQgYW5kCl9nZXRf c3luYygpIGZvciByZXN1bWUuCgpJbmNlbmRlbnRhbGx5LCB0aGUgJ2Vsc2UnIGNsYXVzZSBvZiB0 aGF0IGNvZGUgKHN0YXRlID09IDApIHNob3VsZCBiZSB0aGUKcmVzdW1lIGNhc2UsIGJ1dCB5b3Un cmUgY2FsbGluZyBfZGlzYWJsZSgpLiAgVGhhdCBkb2Vzbid0IGxvb2sgcmlnaHQuCgo+Pgo+Pj4g wqB9Cj4+Pgo+Pj4gwqBzdGF0aWMgdm9pZCBzZXJpYWxfb21hcF9yZWxlYXNlX3BvcnQoc3RydWN0 IHVhcnRfcG9ydCAqcG9ydCkKPj4+IEBAIC05MDcsMjUgKzk2NCwzMSBAQCBzdGF0aWMgaW5saW5l IHZvaWQgd2FpdF9mb3JfeG1pdHIoc3RydWN0IHVhcnRfb21hcF9wb3J0ICp1cCkKPj4+IMKgc3Rh dGljIHZvaWQgc2VyaWFsX29tYXBfcG9sbF9wdXRfY2hhcihzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0 LCB1bnNpZ25lZCBjaGFyIGNoKQo+Pj4gwqB7Cj4+PiDCoCDCoCDCoCBzdHJ1Y3QgdWFydF9vbWFw X3BvcnQgKnVwID0gKHN0cnVjdCB1YXJ0X29tYXBfcG9ydCAqKXBvcnQ7Cj4+PiArCj4+PiArIMKg IMKgIHNlcmlhbF9vbWFwX3BvcnRfZW5hYmxlKHVwKTsKPj4+IMKgIMKgIMKgIHdhaXRfZm9yX3ht aXRyKHVwKTsKPj4+IMKgIMKgIMKgIHNlcmlhbF9vdXQodXAsIFVBUlRfVFgsIGNoKTsKPj4+ICsg wqAgwqAgc2VyaWFsX29tYXBfcG9ydF9kaXNhYmxlKHVwKTsKPj4+IMKgfQo+Pj4KPj4+IMKgc3Rh dGljIGludCBzZXJpYWxfb21hcF9wb2xsX2dldF9jaGFyKHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQp Cj4+PiDCoHsKPj4+IMKgIMKgIMKgIHN0cnVjdCB1YXJ0X29tYXBfcG9ydCAqdXAgPSAoc3RydWN0 IHVhcnRfb21hcF9wb3J0ICopcG9ydDsKPj4+IC0gwqAgwqAgdW5zaWduZWQgaW50IHN0YXR1cyA9 IHNlcmlhbF9pbih1cCwgVUFSVF9MU1IpOwo+Pj4gKyDCoCDCoCB1bnNpZ25lZCBpbnQgc3RhdHVz Owo+Pj4KPj4+ICsgwqAgwqAgc2VyaWFsX29tYXBfcG9ydF9lbmFibGUodXApOwo+Pj4gKyDCoCDC oCBzdGF0dXMgPSBzZXJpYWxfaW4odXAsIFVBUlRfTFNSKTsKPj4+IMKgIMKgIMKgIGlmICghKHN0 YXR1cyAmIFVBUlRfTFNSX0RSKSkKPj4+IMKgIMKgIMKgIMKgIMKgIMKgIMKgIHJldHVybiBOT19Q T0xMX0NIQVI7Cj4+Pgo+Pj4gLSDCoCDCoCByZXR1cm4gc2VyaWFsX2luKHVwLCBVQVJUX1JYKTsK Pj4+ICsgwqAgwqAgc3RhdHVzID0gc2VyaWFsX2luKHVwLCBVQVJUX1JYKTsKPj4+ICsgwqAgwqAg c2VyaWFsX29tYXBfcG9ydF9kaXNhYmxlKHVwKTsKPj4+ICsgwqAgwqAgcmV0dXJuIHN0YXR1czsK Pj4+IMKgfQo+Pj4KPj4+IMKgI2VuZGlmIC8qIENPTkZJR19DT05TT0xFX1BPTEwgKi8KPj4+Cj4+ PiDCoCNpZmRlZiBDT05GSUdfU0VSSUFMX09NQVBfQ09OU09MRQo+Pj4gLQo+Pj4gwqBzdGF0aWMg c3RydWN0IHVhcnRfb21hcF9wb3J0ICpzZXJpYWxfb21hcF9jb25zb2xlX3BvcnRzWzRdOwo+Pj4K Pj4+IMKgc3RhdGljIHN0cnVjdCB1YXJ0X2RyaXZlciBzZXJpYWxfb21hcF9yZWc7Cj4+PiBAQCAt OTU1LDYgKzEwMTgsOCBAQCBzZXJpYWxfb21hcF9jb25zb2xlX3dyaXRlKHN0cnVjdCBjb25zb2xl ICpjbywgY29uc3QgY2hhciAqcywKPj4+IMKgIMKgIMKgIGVsc2UKPj4+IMKgIMKgIMKgIMKgIMKg IMKgIMKgIHNwaW5fbG9jaygmdXAtPnBvcnQubG9jayk7Cj4+Pgo+Pj4gKyDCoCDCoCBzZXJpYWxf b21hcF9wb3J0X2VuYWJsZSh1cCk7Cj4+PiArCj4+PiDCoCDCoCDCoCAvKgo+Pj4gwqAgwqAgwqAg wqAqIEZpcnN0IHNhdmUgdGhlIElFUiB0aGVuIGRpc2FibGUgdGhlIGludGVycnVwdHMKPj4+IMKg IMKgIMKgIMKgKi8KPj4+IEBAIC05NzksNiArMTA0NCw3IEBAIHNlcmlhbF9vbWFwX2NvbnNvbGVf d3JpdGUoc3RydWN0IGNvbnNvbGUgKmNvLCBjb25zdCBjaGFyICpzLAo+Pj4gwqAgwqAgwqAgaWYg KHVwLT5tc3Jfc2F2ZWRfZmxhZ3MpCj4+PiDCoCDCoCDCoCDCoCDCoCDCoCDCoCBjaGVja19tb2Rl bV9zdGF0dXModXApOwo+Pj4KPj4+ICsgwqAgwqAgc2VyaWFsX29tYXBfcG9ydF9kaXNhYmxlKHVw KTsKPj4+IMKgIMKgIMKgIGlmIChsb2NrZWQpCj4+PiDCoCDCoCDCoCDCoCDCoCDCoCDCoCBzcGlu X3VubG9jaygmdXAtPnBvcnQubG9jayk7Cj4+PiDCoCDCoCDCoCBsb2NhbF9pcnFfcmVzdG9yZShm bGFncyk7Cj4+PiBAQCAtMTA2MSwyMiArMTEyNywyNyBAQCBzdGF0aWMgc3RydWN0IHVhcnRfZHJp dmVyIHNlcmlhbF9vbWFwX3JlZyA9IHsKPj4+IMKgIMKgIMKgIC5jb25zIMKgIMKgIMKgIMKgIMKg ID0gT01BUF9DT05TT0xFLAo+Pj4gwqB9Owo+Pj4KPj4+IC1zdGF0aWMgaW50Cj4+PiAtc2VyaWFs X29tYXBfc3VzcGVuZChzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2LCBwbV9tZXNzYWdlX3Qg c3RhdGUpCj4+PiArc3RhdGljIGludCBzZXJpYWxfb21hcF9zdXNwZW5kKHN0cnVjdCBkZXZpY2Ug KmRldikKPj4+IMKgewo+Pj4gLSDCoCDCoCBzdHJ1Y3QgdWFydF9vbWFwX3BvcnQgKnVwID0gcGxh dGZvcm1fZ2V0X2RydmRhdGEocGRldik7Cj4+PiArIMKgIMKgIHN0cnVjdCB1YXJ0X29tYXBfcG9y dCAqdXAgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKPj4+Cj4+PiAtIMKgIMKgIGlmICh1cCkKPj4+ ICsgwqAgwqAgaWYgKHVwKSB7Cj4+PiDCoCDCoCDCoCDCoCDCoCDCoCDCoCB1YXJ0X3N1c3BlbmRf cG9ydCgmc2VyaWFsX29tYXBfcmVnLCAmdXAtPnBvcnQpOwo+Pj4gKyDCoCDCoCDCoCDCoCDCoCDC oCBjb25zb2xlX3RyeWxvY2soKTsKPj4KPj4gVGhpcyBsb2NraW5nIG5lZWRzIHRvIGJlIGV4cGxh aW5lZC4gwqBXaHkgaXQgaXMgbmVlZGVkLCBidXQgdmVyeQo+PiBpbXBvcnRhbnRseSwgd2h5IHlv dSBhcmUgbm90IGNoZWNraW5nIHRoZSByZXR1cm4gdmFsdWUgb2YgdGhlIF90cnlsb2NrKCkKPj4K Pgo+IGFueSBwcmludCBhZnRlciB0aGlzIHBvaW50IGNhbiByZXN1bHQgaW4gZmFpbHVyZSBvZiBp bW1lZGlhdGUgc3lzdGVtIHN1c3BlbmRpbmcKPiBkdWUgdG8gZGVsYXllZCBhdXRvc3VzcGVuZCBm cm9tIG9tYXBfY29uc29sZV93cml0ZS4KCkkgbWVhbiBleHBsYWluZWQgaW4gdGhlIGNoYW5nZWxv ZyBhbmQgcHJlZmVycmFibHkgdGhlIGNvZGUuCgpBbHNvLCB0ZWNobmljYWxseSBzcGVha2luZywg aXQncyBub3QgdW50aWwgdGhlIGNsb2NrcyBhcmUgY3V0IChhZnRlciB0aGUKZGV2aWNlcyBydW50 aW1lX3N1c3BlbmQgY2FsbGJhY2sgaXMgY2FsbGVkKSB0aGF0IFVBUlQgd3JpdGVzIHdpbGwgZmF1 bHQuCgo+IGxvZyBwcmludHMgYWZ0ZXIgdWFydCBzdXNwZW5kIGFuZCBwcmludCB0aGVtIGR1cmlu ZyByZXN1bWUuCj4KPgo+Pj4gKyDCoCDCoCDCoCDCoCDCoCDCoCBzZXJpYWxfb21hcF9wbSgmdXAt PnBvcnQsIDMsIDApOwo+Pgo+PiBXaHkgaXMgdGhpcyBjYWxsIG5lZWRlZD8KPj4KPgo+IEFjdHVh bGx5IHRoaXMgaXMgbmVlZGVkIGlmIG5vX2NvbnNvbGVfc3VzcGVuZCBpcyB1c2VkLCBmb3IgdGhh dAo+IGNhc2UgdGhlIGNvbnNvbGUgd2lsbCByZW1haW4gYWN0aXZlIHNpbmNlIHNlcmlhbF9vbWFw X3BtIGlzIG5vdAo+IGdldHRpbmcgY2FsbGVkIGZyb20gc2VyaWFsX2NvcmUgYW5kIHBvcnQgaXMg bm90IHN1c3BlbmRlZAo+IGltbWVkaWF0ZWx5IHdpdGggcHV0X3N5bmMuCj4KPiBwcmludHMgZHVy aW5nIHN5c3RlbSB3aWRlIHN1c3BlbmQgYW5kIGRlbGF5ZWQgYXV0b3N1c3BlbmQKPiBmcm9tIGNv bnNvbGVfd3JpdGUga2VlcHMgc3lzdGVtIGFjdGl2ZSBpbiBub19jb25zb2xlX3N1c3BlbmQgY2Fz ZQo+IHNvIHB1dCBpbiBmb3JjZWQgc3VzcGVuZCBzdGF0ZSBhbmQgbG9nIGFsbCBwcmludHMgdG8g YmUgcHJpbnRlZCBsYXRlci4KPgo+IHByb2JhYmx5IG5lZWRzIHRvIGEgY29uZGl0aW9uIGNoZWNr IGlmIChub19jb25zb2xlX3N1c3BlbmQpCgpOby4gIElmIHRoZSB1c2VyIGhhcyByZXF1ZXN0ZWQg bm9fY29uc29sZV9zdXNwZW5kLCB0aGVuIHRoZSB1c2VyIHNob3VsZApleHBlY3QgdGhhdCB0aGUg VUFSVHMgcmVtYWluIGFjdGl2ZSBhbmQgdGh1cyBwcmV2ZW50IGxvdy1wb3dlci4KCj4+IHVhcnRf c3VzcGVuZF9wb3J0KCkgY2FsbHMgdWFydF9jaGFuZ2VfcG0oKSB3aGljaCBzaG91bGQgY2FsbCB0 aGUgLT5wbQo+PiBtZXRob2Qgb2Ygc3RydWN0IHVhcnRfb3BzICh3aGljaCBpcyBzZXJpYWxfb21h cF9wbSkuIMKgV2hhdCBhbSBJIG1pc3Npbmc/Cj4+Cj4+IEFsc28gbm90aWNlIHlvdSdyZSBub3Qg Y2FsbGluZyBzZXJpYWxfb21hcF9wbSgpIGluIHRoZSByZXN1bWUgbWV0aG9kCj4+IGJlbG93IHRv IGNoYW5nZSBpdCBiYWNrLgo+Pgo+Pj4gKyDCoCDCoCB9Cj4+PiDCoCDCoCDCoCByZXR1cm4gMDsK Pj4+IMKgfQo+Pgo+PiBBbHNvLCBkZXZpY2Ugd2FrZXVwIGNhcGFiaWxpdHkgc2hvdWxkIGJlIGNo ZWNrZWQgYW5kIGVuYWJsZWQvZGlzYWJsZWQgaW4KPj4gdGhlIHN1c3BlbmQgcGF0aCAobm90IG9u bHkgdGhlIHJ1bnRpbWUgc3VzcGVuZCBwYXRoLikKPj4KPgo+IG9rLgo+Cj4KPj4+IC1zdGF0aWMg aW50IHNlcmlhbF9vbWFwX3Jlc3VtZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpkZXYpCj4+PiAr c3RhdGljIGludCBzZXJpYWxfb21hcF9yZXN1bWUoc3RydWN0IGRldmljZSAqZGV2KQo+Pj4gwqB7 Cj4+PiAtIMKgIMKgIHN0cnVjdCB1YXJ0X29tYXBfcG9ydCAqdXAgPSBwbGF0Zm9ybV9nZXRfZHJ2 ZGF0YShkZXYpOwo+Pj4gKyDCoCDCoCBzdHJ1Y3QgdWFydF9vbWFwX3BvcnQgKnVwID0gZGV2X2dl dF9kcnZkYXRhKGRldik7Cj4+Pgo+Pj4gLSDCoCDCoCBpZiAodXApCj4+PiArIMKgIMKgIGlmICh1 cCkgewo+Pj4gwqAgwqAgwqAgwqAgwqAgwqAgwqAgdWFydF9yZXN1bWVfcG9ydCgmc2VyaWFsX29t YXBfcmVnLCAmdXAtPnBvcnQpOwo+Pj4gKyDCoCDCoCDCoCDCoCDCoCDCoCBjb25zb2xlX3VubG9j aygpOwo+Pgo+PiBBZ2FpbiwgcGxlYXNlIGRlc2NyaWJlIGxvY2tpbmcgaW4gY29tbWVudHMuCj4+ Cj4+IEFsc28sIHdoYXQgaGFwcGVucyBoZXJlIGlmIHRoZSBjb25zb2xlX3RyeWxvY2soKSBpbiB5 b3VyIHN1c3BlbmQgbWV0aG9kCj4+IGZhaWxlZD8KPj4KPgo+IG5lZWQgdG8gYWRkIGEgZmxhZyB0 byBjaGVjayBhbmQgdW5sb2NrCj4gZnJvbSByZXR1cm4gc3RhdHVzIG9mIHRyeWxvY2suCj4KPj4+ ICsgwqAgwqAgfQo+Pj4gKwo+Pj4gwqAgwqAgwqAgcmV0dXJuIDA7Cj4+PiDCoH0KPj4+Cj4+PiBA QCAtMTA5Nyw2ICsxMTY4LDcgQEAgc3RhdGljIHZvaWQgc2VyaWFsX29tYXBfcnhfdGltZW91dCh1 bnNpZ25lZCBsb25nIHVhcnRfbm8pCj4+PiDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCBzZXJpYWxfb21hcF9zdG9wX3J4ZG1hKHVwKTsKPj4+IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIHVwLT5pZXIgfD0gKFVBUlRfSUVSX1JESSB8IFVBUlRfSUVSX1JMU0kpOwo+Pj4g wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgc2VyaWFsX291dCh1cCwgVUFSVF9JRVIs IHVwLT5pZXIpOwo+Pj4gKyDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCBzZXJpYWxfb21h cF9wb3J0X2Rpc2FibGUodXApOwo+Pj4gwqAgwqAgwqAgwqAgwqAgwqAgwqAgfQo+Pj4gwqAgwqAg wqAgwqAgwqAgwqAgwqAgcmV0dXJuOwo+Pj4gwqAgwqAgwqAgfQo+Pj4gQEAgLTExMjgsNiArMTIw MCw5IEBAIHN0YXRpYyB2b2lkIHNlcmlhbF9vbWFwX3J4X3RpbWVvdXQodW5zaWduZWQgbG9uZyB1 YXJ0X25vKQo+Pj4KPj4+IMKgc3RhdGljIHZvaWQgdWFydF9yeF9kbWFfY2FsbGJhY2soaW50IGxj aCwgdTE2IGNoX3N0YXR1cywgdm9pZCAqZGF0YSkKPj4+IMKgewo+Pj4gKyDCoCDCoCBzdHJ1Y3Qg dWFydF9vbWFwX3BvcnQgKnVwID0gKHN0cnVjdCB1YXJ0X29tYXBfcG9ydCAqKWRhdGE7Cj4+PiAr Cj4+PiArIMKgIMKgIHNlcmlhbF9vbWFwX3BvcnRfZGlzYWJsZSh1cCk7Cj4+PiDCoCDCoCDCoCBy ZXR1cm47Cj4+PiDCoH0KPj4+Cj4+PiBAQCAtMTEzNSw2ICsxMjEwLDcgQEAgc3RhdGljIGludCBz ZXJpYWxfb21hcF9zdGFydF9yeGRtYShzdHJ1Y3QgdWFydF9vbWFwX3BvcnQgKnVwKQo+Pj4gwqB7 Cj4+PiDCoCDCoCDCoCBpbnQgcmV0ID0gMDsKPj4+Cj4+PiArIMKgIMKgIHNlcmlhbF9vbWFwX3Bv cnRfZW5hYmxlKHVwKTsKPj4+IMKgIMKgIMKgIGlmICh1cC0+dWFydF9kbWEucnhfZG1hX2NoYW5u ZWwgPT0gLTEpIHsKPj4+IMKgIMKgIMKgIMKgIMKgIMKgIMKgIHJldCA9IG9tYXBfcmVxdWVzdF9k bWEodXAtPnVhcnRfZG1hLnVhcnRfZG1hX3J4LAo+Pj4gwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgIlVBUlQgUnggRE1BIiwKPj4+IEBAIC0xMjE0LDYgKzEyOTAs NyBAQCBzdGF0aWMgdm9pZCB1YXJ0X3R4X2RtYV9jYWxsYmFjayhpbnQgbGNoLCB1MTYgY2hfc3Rh dHVzLCB2b2lkICpkYXRhKQo+Pj4gwqAgwqAgwqAgwqAgwqAgwqAgwqAgc2VyaWFsX29tYXBfc3Rv cF90eCgmdXAtPnBvcnQpOwo+Pj4gwqAgwqAgwqAgwqAgwqAgwqAgwqAgdXAtPnVhcnRfZG1hLnR4 X2RtYV91c2VkID0gZmFsc2U7Cj4+PiDCoCDCoCDCoCDCoCDCoCDCoCDCoCBzcGluX3VubG9jaygm KHVwLT51YXJ0X2RtYS50eF9sb2NrKSk7Cj4+PiArIMKgIMKgIMKgIMKgIMKgIMKgIHNlcmlhbF9v bWFwX3BvcnRfZGlzYWJsZSh1cCk7Cj4+PiDCoCDCoCDCoCB9IGVsc2Ugewo+Pj4gwqAgwqAgwqAg wqAgwqAgwqAgwqAgb21hcF9zdG9wX2RtYSh1cC0+dWFydF9kbWEudHhfZG1hX2NoYW5uZWwpOwo+ Pj4gwqAgwqAgwqAgwqAgwqAgwqAgwqAgc2VyaWFsX29tYXBfY29udGludWVfdHgodXApOwo+Pj4g QEAgLTEyMjQsOSArMTMwMSwxMCBAQCBzdGF0aWMgdm9pZCB1YXJ0X3R4X2RtYV9jYWxsYmFjayhp bnQgbGNoLCB1MTYgY2hfc3RhdHVzLCB2b2lkICpkYXRhKQo+Pj4KPj4+IMKgc3RhdGljIGludCBz ZXJpYWxfb21hcF9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQo+Pj4gwqB7Cj4+ PiAtIMKgIMKgIHN0cnVjdCB1YXJ0X29tYXBfcG9ydCDCoCAqdXA7Cj4+PiArIMKgIMKgIHN0cnVj dCB1YXJ0X29tYXBfcG9ydCDCoCAqdXAgPSBOVUxMOwo+Pj4gwqAgwqAgwqAgc3RydWN0IHJlc291 cmNlIMKgIMKgIMKgIMKgICptZW0sICppcnEsICpkbWFfdHgsICpkbWFfcng7Cj4+PiDCoCDCoCDC oCBzdHJ1Y3Qgb21hcF91YXJ0X3BvcnRfaW5mbyAqb21hcF91cF9pbmZvID0gcGRldi0+ZGV2LnBs YXRmb3JtX2RhdGE7Cj4+PiArIMKgIMKgIHN0cnVjdCBvbWFwX2RldmljZSAqb2Q7Cj4+PiDCoCDC oCDCoCBpbnQgcmV0ID0gLUVOT1NQQzsKPj4+Cj4+PiDCoCDCoCDCoCBtZW0gPSBwbGF0Zm9ybV9n ZXRfcmVzb3VyY2UocGRldiwgSU9SRVNPVVJDRV9NRU0sIDApOwo+Pj4gQEAgLTEyNzYsMTIgKzEz NTQsMjAgQEAgc3RhdGljIGludCBzZXJpYWxfb21hcF9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2 aWNlICpwZGV2KQo+Pj4gwqAgwqAgwqAgdXAtPnBvcnQub3BzID0gJnNlcmlhbF9vbWFwX3BvcHM7 Cj4+PiDCoCDCoCDCoCB1cC0+cG9ydC5saW5lID0gcGRldi0+aWQ7Cj4+Pgo+Pj4gLSDCoCDCoCB1 cC0+cG9ydC5tZW1iYXNlID0gb21hcF91cF9pbmZvLT5tZW1iYXNlOwo+Pj4gLSDCoCDCoCB1cC0+ cG9ydC5tYXBiYXNlID0gb21hcF91cF9pbmZvLT5tYXBiYXNlOwo+Pj4gKyDCoCDCoCB1cC0+cG9y dC5tYXBiYXNlID0gbWVtLT5zdGFydDsKPj4+ICsgwqAgwqAgdXAtPnBvcnQubWVtYmFzZSA9IGlv cmVtYXAobWVtLT5zdGFydCwgbWVtLT5lbmQgLSBtZW0tPnN0YXJ0KTsKPj4+ICsKPj4+ICsgwqAg wqAgaWYgKCF1cC0+cG9ydC5tZW1iYXNlKSB7Cj4+PiArIMKgIMKgIMKgIMKgIMKgIMKgIGRldl9l cnIoJnBkZXYtPmRldiwgImNhbid0IGlvcmVtYXAgVUFSVFxuIik7Cj4+PiArIMKgIMKgIMKgIMKg IMKgIMKgIHJldCA9IC1FTk9NRU07Cj4+PiArIMKgIMKgIMKgIMKgIMKgIMKgIGdvdG8gZXJyMTsK Pj4+ICsgwqAgwqAgfQo+Pj4gKwo+Pj4gwqAgwqAgwqAgdXAtPnBvcnQuZmxhZ3MgPSBvbWFwX3Vw X2luZm8tPmZsYWdzOwo+Pj4gLSDCoCDCoCB1cC0+cG9ydC5pcnFmbGFncyA9IG9tYXBfdXBfaW5m by0+aXJxZmxhZ3M7Cj4+PiDCoCDCoCDCoCB1cC0+cG9ydC51YXJ0Y2xrID0gb21hcF91cF9pbmZv LT51YXJ0Y2xrOwo+Pj4gwqAgwqAgwqAgdXAtPnVhcnRfZG1hLnVhcnRfYmFzZSA9IG1lbS0+c3Rh cnQ7Cj4+PiArIMKgIMKgIHVwLT5lcnJhdGEgPSBvbWFwX3VwX2luZm8tPmVycmF0YTsKPj4+ICsg wqAgwqAgdXAtPmVuYWJsZV93YWtldXAgPSBvbWFwX3VwX2luZm8tPmVuYWJsZV93YWtldXA7Cj4+ Pgo+Pj4gwqAgwqAgwqAgaWYgKG9tYXBfdXBfaW5mby0+ZG1hX2VuYWJsZWQpIHsKPj4+IMKgIMKg IMKgIMKgIMKgIMKgIMKgIHVwLT51YXJ0X2RtYS51YXJ0X2RtYV90eCA9IGRtYV90eC0+c3RhcnQ7 Cj4+PiBAQCAtMTI5NSwxOCArMTM4MSwzNiBAQCBzdGF0aWMgaW50IHNlcmlhbF9vbWFwX3Byb2Jl KHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCj4+PiDCoCDCoCDCoCDCoCDCoCDCoCDCoCB1 cC0+dWFydF9kbWEucnhfZG1hX2NoYW5uZWwgPSBPTUFQX1VBUlRfRE1BX0NIX0ZSRUU7Cj4+PiDC oCDCoCDCoCB9Cj4+Pgo+Pj4gKyDCoCDCoCBwbV9ydW50aW1lX3VzZV9hdXRvc3VzcGVuZCgmcGRl di0+ZGV2KTsKPj4+ICsgwqAgwqAgcG1fcnVudGltZV9zZXRfYXV0b3N1c3BlbmRfZGVsYXkoJnBk ZXYtPmRldiwKPj4+ICsgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgT01BUF9VQVJUX0FV VE9TVVNQRU5EX0RFTEFZKTsKPj4+ICsKPj4+ICsgwqAgwqAgcG1fcnVudGltZV9lbmFibGUoJnBk ZXYtPmRldik7Cj4+PiArIMKgIMKgIHBtX3J1bnRpbWVfaXJxX3NhZmUoJnBkZXYtPmRldik7Cj4+ PiArCj4+PiArIMKgIMKgIGlmIChvbWFwX3VwX2luZm8tPmNvbnNvbGVfdWFydCkgewo+Pj4gKyDC oCDCoCDCoCDCoCDCoCDCoCBvZCA9IHRvX29tYXBfZGV2aWNlKHVwLT5wZGV2KTsKPj4+ICsgwqAg wqAgwqAgwqAgwqAgwqAgb21hcF9od21vZF9pZGxlKG9kLT5od21vZHNbMF0pOwo+Pj4gKyDCoCDC oCDCoCDCoCDCoCDCoCBzZXJpYWxfb21hcF9wb3J0X2VuYWJsZSh1cCk7Cj4+PiArIMKgIMKgIMKg IMKgIMKgIMKgIHNlcmlhbF9vbWFwX3BvcnRfZGlzYWJsZSh1cCk7Cj4+PiArIMKgIMKgIH0KPj4+ ICsKPj4+IMKgIMKgIMKgIHVpW3BkZXYtPmlkXSA9IHVwOwo+Pj4gwqAgwqAgwqAgc2VyaWFsX29t YXBfYWRkX2NvbnNvbGVfcG9ydCh1cCk7Cj4+Pgo+Pj4gwqAgwqAgwqAgcmV0ID0gdWFydF9hZGRf b25lX3BvcnQoJnNlcmlhbF9vbWFwX3JlZywgJnVwLT5wb3J0KTsKPj4+IMKgIMKgIMKgIGlmIChy ZXQgIT0gMCkKPj4+IC0gwqAgwqAgwqAgwqAgwqAgwqAgZ290byBkb19yZWxlYXNlX3JlZ2lvbjsK Pj4+ICsgwqAgwqAgwqAgwqAgwqAgwqAgZ290byBlcnIxOwo+Pj4KPj4+ICsgwqAgwqAgZGV2X3Nl dF9kcnZkYXRhKCZwZGV2LT5kZXYsIHVwKTsKPj4+IMKgIMKgIMKgIHBsYXRmb3JtX3NldF9kcnZk YXRhKHBkZXYsIHVwKTsKPj4+ICsKPj4+IMKgIMKgIMKgIHJldHVybiAwOwo+Pj4gwqBlcnI6Cj4+ PiDCoCDCoCDCoCBkZXZfZXJyKCZwZGV2LT5kZXYsICJbVUFSVCVkXTogZmFpbHVyZSBbJXNdOiAl ZFxuIiwKPj4+IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIHBk ZXYtPmlkLCBfX2Z1bmNfXywgcmV0KTsKPj4+ICtlcnIxOgo+Pj4gKyDCoCDCoCBrZnJlZSh1cCk7 Cj4+PiDCoGRvX3JlbGVhc2VfcmVnaW9uOgo+Pj4gwqAgwqAgwqAgcmVsZWFzZV9tZW1fcmVnaW9u KG1lbS0+c3RhcnQsIChtZW0tPmVuZCAtIG1lbS0+c3RhcnQpICsgMSk7Cj4+PiDCoCDCoCDCoCBy ZXR1cm4gcmV0Owo+Pj4gQEAgLTEzMTgsMjAgKzE0MjIsNzYgQEAgc3RhdGljIGludCBzZXJpYWxf b21hcF9yZW1vdmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqZGV2KQo+Pj4KPj4+IMKgIMKgIMKg IHBsYXRmb3JtX3NldF9kcnZkYXRhKGRldiwgTlVMTCk7Cj4+PiDCoCDCoCDCoCBpZiAodXApIHsK Pj4+ICsgwqAgwqAgwqAgwqAgwqAgwqAgcG1fcnVudGltZV9kaXNhYmxlKCZ1cC0+cGRldi0+ZGV2 KTsKPj4+IMKgIMKgIMKgIMKgIMKgIMKgIMKgIHVhcnRfcmVtb3ZlX29uZV9wb3J0KCZzZXJpYWxf b21hcF9yZWcsICZ1cC0+cG9ydCk7Cj4+PiDCoCDCoCDCoCDCoCDCoCDCoCDCoCBrZnJlZSh1cCk7 Cj4+PiDCoCDCoCDCoCB9Cj4+PiDCoCDCoCDCoCByZXR1cm4gMDsKPj4+IMKgfQo+Pj4KPj4+ICtz dGF0aWMgdm9pZCBvbWFwX3VhcnRfcmVzdG9yZV9jb250ZXh0KHN0cnVjdCB1YXJ0X29tYXBfcG9y dCAqdXApCj4+PiArewo+Pj4gKyDCoCDCoCB1MTYgZWZyID0gMDsKPj4+ICsKPj4+ICsgwqAgwqAg c2VyaWFsX291dCh1cCwgVUFSVF9PTUFQX01EUjEsIHVwLT5tZHIxKTsKPj4+ICsgwqAgwqAgc2Vy aWFsX291dCh1cCwgVUFSVF9MQ1IsIDB4QkYpOyAvKiBDb25maWcgQiBtb2RlICovCj4+PiArIMKg IMKgIGVmciA9IHNlcmlhbF9pbih1cCwgVUFSVF9FRlIpOwo+Pj4gKyDCoCDCoCBzZXJpYWxfb3V0 KHVwLCBVQVJUX0VGUiwgVUFSVF9FRlJfRUNCKTsKPj4+ICsgwqAgwqAgc2VyaWFsX291dCh1cCwg VUFSVF9MQ1IsIDB4MCk7IC8qIE9wZXJhdGlvbmFsIG1vZGUgKi8KPj4+ICsgwqAgwqAgc2VyaWFs X291dCh1cCwgVUFSVF9JRVIsIDB4MCk7Cj4+PiArIMKgIMKgIHNlcmlhbF9vdXQodXAsIFVBUlRf TENSLCAweEJGKTsgLyogQ29uZmlnIEIgbW9kZSAqLwo+Pj4gKyDCoCDCoCBzZXJpYWxfb3V0KHVw LCBVQVJUX0RMTCwgdXAtPmRsbCk7Cj4+PiArIMKgIMKgIHNlcmlhbF9vdXQodXAsIFVBUlRfRExN LCB1cC0+ZGxoKTsKPj4+ICsgwqAgwqAgc2VyaWFsX291dCh1cCwgVUFSVF9MQ1IsIDB4MCk7IC8q IE9wZXJhdGlvbmFsIG1vZGUgKi8KPj4+ICsgwqAgwqAgc2VyaWFsX291dCh1cCwgVUFSVF9JRVIs IHVwLT5pZXIpOwo+Pj4gKyDCoCDCoCBzZXJpYWxfb3V0KHVwLCBVQVJUX0ZDUiwgdXAtPmZjcik7 Cj4+PiArIMKgIMKgIHNlcmlhbF9vdXQodXAsIFVBUlRfTENSLCAweDgwKTsKPj4+ICsgwqAgwqAg c2VyaWFsX291dCh1cCwgVUFSVF9NQ1IsIHVwLT5tY3IpOwo+Pj4gKyDCoCDCoCBzZXJpYWxfb3V0 KHVwLCBVQVJUX0xDUiwgMHhCRik7IC8qIENvbmZpZyBCIG1vZGUgKi8KPj4+ICsgwqAgwqAgc2Vy aWFsX291dCh1cCwgVUFSVF9FRlIsIGVmcik7Cj4+PiArIMKgIMKgIHNlcmlhbF9vdXQodXAsIFVB UlRfTENSLCB1cC0+bGNyKTsKPj4+ICsgwqAgwqAgLyogVUFSVCAxNnggbW9kZSAqLwo+Pj4gKyDC oCDCoCBzZXJpYWxfb3V0KHVwLCBVQVJUX09NQVBfTURSMSwgdXAtPm1kcjEpOwo+Pj4gK30KPj4+ ICsKPj4+ICtzdGF0aWMgaW50IG9tYXBfc2VyaWFsX3J1bnRpbWVfc3VzcGVuZChzdHJ1Y3QgZGV2 aWNlICpkZXYpCj4+PiArewo+Pj4gKyDCoCDCoCBzdHJ1Y3QgdWFydF9vbWFwX3BvcnQgKnVwID0g ZGV2X2dldF9kcnZkYXRhKGRldik7Cj4+PiArCj4+PiArIMKgIMKgIGlmICghdXApCj4+PiArIMKg IMKgIMKgIMKgIMKgIMKgIGdvdG8gZG9uZTsKPj4+ICsKPj4+ICsgwqAgwqAgaWYgKGRldmljZV9t YXlfd2FrZXVwKGRldikpCj4+PiArIMKgIMKgIMKgIMKgIMKgIMKgIHVwLT5lbmFibGVfd2FrZXVw KHVwLT5wZGV2LCB0cnVlKTsKPj4+ICsgwqAgwqAgZWxzZQo+Pj4gKyDCoCDCoCDCoCDCoCDCoCDC oCB1cC0+ZW5hYmxlX3dha2V1cCh1cC0+cGRldiwgZmFsc2UpOwo+Pgo+PiBJIGtub3cgdGhlIGVh cmxpZXIgY29kZSB3YXMgZG9pbmcgaXQgdGhpcyB3YXkgdG9vLCBidXQgYW4gb3B0aW1pemF0aW9u Cj4+IHdvdWxkIGJlIHRvIGhhdmUgdGhlIGRyaXZlciBrZWVwIHN0YXRlIHdoZXRoZXIgdGhlIHdh a2V1cHMgYXJlIGVuYWJsZWQKPj4gb3IgZGlzYWJsZWQsIHNvIHlvdSBkb24ndCBoYXZlIHRvIGtl ZXAgY2FsbGluZyB0aGlzIGZ1bmN0aW9uICh3aGljaCBjYW4KPj4gYmUgZXhwZW5zaXZlIHdpdGgg dGhlIFBSQ00gcmVhZHMvd3JpdGVzLgo+Pgo+Cj4gaWYgZHluYW1pY2FsbHkgZGlzYWJsZWQgZnJv bSB1c2VyIHNwYWNlIGZyb20gc3lzLWZzIGludGVyZmFjZS4KPiBpdCBtYXkgbm90IHJlZmxlY3Qg ZGlzYWJsZV93YWt1cCBpbW1lZGlhdGVseSBpZiBpbnRlcm5hbCBzdGF0ZSBtYWNoaW5lIG9mCj4g d2FrZXVwIGlzIG1haW50YWluZWQgd2l0aGluIHVhcnQgZHJpdmVyLgoKV2h5IGRvZXMgdGhhdCBt YXR0ZXI/ICBJdCBkb2VzIG5vdCBuZWVkIHRvIHRha2UgZWZmZWN0IGltbWVkYXRlbHksIGl0Cm9u bHkgbmVlZHMgdG8gdGFrZSBlZmZlY3Qgb24gc3VzcGVuZC4KCkp1c3QgdXBkYXRlIGludGVybmFs IHN0YXRlIHdoZW5ldmVyIHlvdSBjaGFuZ2UgdGhlIGhhcmR3YXJlLCBhbmQgd2hlbnZlcgp5b3Un cmUgYWJvdXQgdG8gY2hhbmdlIHRoZSBoYXJkd2FyZSBhZ2FpbiwgY2hlY2sgZGV2aWNlX21heV93 YWtldXAoKSBhbmQKY2hlY2sgdGhlIGRyaXZlcidzIGludGVybmFsIHN0YXRlLiAKCj4gYWxzbyBu ZWVkIHRvIG1vZGlmeSB0aGUgaW50ZXJuYWxzIG9mIHRoaXMgZnVuYyBwb2ludGVyIHRvIHVzZQo+ IGhtd29kIEFQSSdzIGFzIGNvbW1lbnRlZCBhYm92ZS4KCk9LCgoKX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGludXgtYXJtLWtlcm5lbCBtYWlsaW5nIGxp c3QKbGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZy YWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtYXJtLWtlcm5lbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 From: khilman@ti.com (Kevin Hilman) Date: Mon, 27 Jun 2011 15:57:52 -0700 Subject: [PATCH v3 04/12] Serial: OMAP: Add runtime pm support for omap-serial driver In-Reply-To: (Govindraj's message of "Mon, 27 Jun 2011 20:01:57 +0530") References: <1307532194-13039-1-git-send-email-govindraj.raja@ti.com> <1307532194-13039-5-git-send-email-govindraj.raja@ti.com> <8739iyu7rh.fsf@ti.com> Message-ID: <87iprq7uhb.fsf@ti.com> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org Govindraj writes: > On Sat, Jun 25, 2011 at 5:00 AM, Kevin Hilman wrote: >> "Govindraj.R" writes: >> >>> Adapts omap-serial driver to use pm_runtime api's. >>> >>> 1.) Populate reg values to uart port which can be used for context restore. >> >> Please make this part a separate patch. >> >>> 2.) Moving context_restore func to driver from serial.c >>> 3.) Adding port_enable/disable func to enable/disable given uart port. >>> ? ? enable port using get_sync and disable using autosuspend. >>> 4.) using runtime irq safe api to make get_sync be called from irq context. >> >>> >>> Acked-by: Alan Cox >>> Signed-off-by: Govindraj.R >> >> This is great! ?we're almost there. ? Some minor comments below... >> >>> --- >>> ?arch/arm/mach-omap2/serial.c ? ? ? ? ? ? ? ? ?| ? 22 +++ >>> ?arch/arm/plat-omap/include/plat/omap-serial.h | ? ?2 + >>> ?drivers/tty/serial/omap-serial.c ? ? ? ? ? ? ?| ?212 ++++++++++++++++++++++--- >>> ?3 files changed, 210 insertions(+), 26 deletions(-) >>> >>> diff --git a/arch/arm/mach-omap2/serial.c b/arch/arm/mach-omap2/serial.c >>> index 8c1a4c7..1651c2c 100644 >>> --- a/arch/arm/mach-omap2/serial.c >>> +++ b/arch/arm/mach-omap2/serial.c >>> @@ -189,6 +189,27 @@ static void omap_serial_fill_default_pads(struct omap_board_data *bdata) >>> ? ? ? } >>> ?} >>> >>> +static void omap_uart_wakeup_enable(struct platform_device *pdev, bool enable) >>> +{ >>> + ? ? struct omap_uart_port_info *up = pdev->dev.platform_data; >>> + >>> + ? ? /* Set or clear wake-enable bit */ >>> + ? ? if (up->wk_en && up->wk_mask) { >>> + ? ? ? ? ? ? u32 v = __raw_readl(up->wk_en); >>> + ? ? ? ? ? ? if (enable) >>> + ? ? ? ? ? ? ? ? ? ? v |= up->wk_mask; >>> + ? ? ? ? ? ? else >>> + ? ? ? ? ? ? ? ? ? ? v &= ~up->wk_mask; >>> + ? ? ? ? ? ? __raw_writel(v, up->wk_en); >>> + ? ? } >> >> I think I asked this in previous series, but can't remember the answer >> now... ?can't we enable bits in the WKEN registers once at init time, >> and then just use omap_hwmod_[enable|disable]_wakeup() here? >> > > by default all bits are enabled in WKEN, where default is the PRCM init code, yes. > I will use omap_hwmod_[enable|disable]_wakeup() api's > > if these API's take care of WKEN regs, then no issue > using the same. No, these APIs only affect the module-level wakeup bit in the modules SYSCONFIG register (ENAWAKEUP bit.) My question is assuming the PRCM WKEN bits are just left enabled, is simply toggling the modules SYSCONFIG.ENAWAKEUP bit enough to enable/disable module wakeups. I assume so, but have not validated it. >>> + ? ? /* Enable or clear io-pad wakeup */ >>> + ? ? if (enable) >>> + ? ? ? ? ? ? omap_device_enable_ioring_wakeup(pdev); >>> + ? ? else >>> + ? ? ? ? ? ? omap_device_disable_ioring_wakeup(pdev); >>> +} >>> + >>> ?static void omap_uart_idle_init(struct omap_uart_port_info *uart, >>> ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? unsigned short num) >>> ?{ >>> @@ -332,6 +353,7 @@ void __init omap_serial_init_port(struct omap_board_data *bdata) >>> >>> ? ? ? pdata->uartclk = OMAP24XX_BASE_BAUD * 16; >>> ? ? ? pdata->flags = UPF_BOOT_AUTOCONF; >>> + ? ? pdata->enable_wakeup = omap_uart_wakeup_enable; >>> ? ? ? if (bdata->id == omap_uart_con_id) >>> ? ? ? ? ? ? ? pdata->console_uart = true; >>> >>> diff --git a/arch/arm/plat-omap/include/plat/omap-serial.h b/arch/arm/plat-omap/include/plat/omap-serial.h >>> index 2ca885b..ac30de8 100644 >>> --- a/arch/arm/plat-omap/include/plat/omap-serial.h >>> +++ b/arch/arm/plat-omap/include/plat/omap-serial.h >>> @@ -65,6 +65,7 @@ struct omap_uart_port_info { >>> ? ? ? unsigned int ? ? ? ? ? ?errata; >>> ? ? ? unsigned int ? ? ? ? ? ?console_uart; >>> >>> + ? ? void (*enable_wakeup)(struct platform_device *, bool); >>> ? ? ? void __iomem *wk_st; >>> ? ? ? void __iomem *wk_en; >>> ? ? ? u32 wk_mask; >>> @@ -120,6 +121,7 @@ struct uart_omap_port { >>> ? ? ? char ? ? ? ? ? ? ? ? ? ?name[20]; >>> ? ? ? unsigned long ? ? ? ? ? port_activity; >>> ? ? ? unsigned int ? ? ? ? ? ?errata; >>> + ? ? void (*enable_wakeup)(struct platform_device *, bool); >>> ?}; >>> >>> ?#endif /* __OMAP_SERIAL_H__ */ >>> diff --git a/drivers/tty/serial/omap-serial.c b/drivers/tty/serial/omap-serial.c >>> index 47cadf4..897416f 100644 >>> --- a/drivers/tty/serial/omap-serial.c >>> +++ b/drivers/tty/serial/omap-serial.c >>> @@ -37,10 +37,14 @@ >>> ?#include >>> ?#include >>> ?#include >>> +#include >>> >>> ?#include >>> ?#include >>> ?#include >>> +#include >>> + >>> +#define OMAP_UART_AUTOSUSPEND_DELAY (30 * HZ) /* Value is msecs */ >> >> As Jon already pointed out, the HZ here is wrong. ?Please define this >> value in msecs. >> > > corrected. > >>> ?static struct uart_omap_port *ui[OMAP_MAX_HSUART_PORTS]; >>> >>> @@ -94,6 +98,17 @@ serial_omap_get_divisor(struct uart_port *port, unsigned int baud) >>> ? ? ? return port->uartclk/(baud * divisor); >>> ?} >>> >>> +static inline void serial_omap_port_disable(struct uart_omap_port *up) >>> +{ >>> + ? ? pm_runtime_mark_last_busy(&up->pdev->dev); >>> + ? ? pm_runtime_put_autosuspend(&up->pdev->dev); >>> +} >>> + >>> +static inline void serial_omap_port_enable(struct uart_omap_port *up) >>> +{ >>> + ? ? pm_runtime_get_sync(&up->pdev->dev); >>> +} >> >> These inlines are not needed. ?Please use runtime PM calls directly in >> the code. ?For _enable(), this is straight forward. ?For _disable() >> though, I don't think you want (or need) to _mark_last_busy() for every >> instance of omap_port_disable(). ?You only need to do this for ones >> TX/RX transactions... >> > > Fine. will modify. > > >>> ?static void serial_omap_stop_rxdma(struct uart_omap_port *up) >>> ?{ >>> ? ? ? if (up->uart_dma.rx_dma_used) { >>> @@ -110,8 +125,11 @@ static void serial_omap_enable_ms(struct uart_port *port) >>> ? ? ? struct uart_omap_port *up = (struct uart_omap_port *)port; >>> >>> ? ? ? dev_dbg(up->port.dev, "serial_omap_enable_ms+%d\n", up->pdev->id); >>> + >>> + ? ? serial_omap_port_enable(up); >>> ? ? ? up->ier |= UART_IER_MSI; >>> ? ? ? serial_out(up, UART_IER, up->ier); >>> + ? ? serial_omap_port_disable(up); >> >> ...for example, this one is not really activity based, so should >> probably just be pm_runtime_get_sync(), write the register, then >> pm_runtime_put() (async version.) >> >> I didn't look at all the others below, but they should be looked at >> individually. >> > > ok. I will check them. > >>> ?} >>> >>> ?static void serial_omap_stop_tx(struct uart_port *port) >>> @@ -131,21 +149,26 @@ static void serial_omap_stop_tx(struct uart_port *port) >>> ? ? ? ? ? ? ? up->uart_dma.tx_dma_channel = OMAP_UART_DMA_CH_FREE; >>> ? ? ? } >>> >>> + ? ? serial_omap_port_enable(up); >>> ? ? ? if (up->ier & UART_IER_THRI) { >>> ? ? ? ? ? ? ? up->ier &= ~UART_IER_THRI; >>> ? ? ? ? ? ? ? serial_out(up, UART_IER, up->ier); >>> ? ? ? } >>> + >>> + ? ? serial_omap_port_disable(up); >>> ?} >>> >>> ?static void serial_omap_stop_rx(struct uart_port *port) >>> ?{ >>> ? ? ? struct uart_omap_port *up = (struct uart_omap_port *)port; >>> >>> + ? ? serial_omap_port_enable(up); >>> ? ? ? if (up->use_dma) >>> ? ? ? ? ? ? ? serial_omap_stop_rxdma(up); >>> ? ? ? up->ier &= ~UART_IER_RLSI; >>> ? ? ? up->port.read_status_mask &= ~UART_LSR_DR; >>> ? ? ? serial_out(up, UART_IER, up->ier); >>> + ? ? serial_omap_port_disable(up); >>> ?} >>> >>> ?static inline void receive_chars(struct uart_omap_port *up, int *status) >>> @@ -261,8 +284,10 @@ static void serial_omap_start_tx(struct uart_port *port) >>> ? ? ? unsigned int start; >>> ? ? ? int ret = 0; >>> >>> + ? ? serial_omap_port_enable(up); >>> ? ? ? if (!up->use_dma) { >>> ? ? ? ? ? ? ? serial_omap_enable_ier_thri(up); >>> + ? ? ? ? ? ? serial_omap_port_disable(up); >>> ? ? ? ? ? ? ? return; >>> ? ? ? } >>> >>> @@ -354,9 +379,12 @@ static inline irqreturn_t serial_omap_irq(int irq, void *dev_id) >>> ? ? ? unsigned int iir, lsr; >>> ? ? ? unsigned long flags; >>> >>> + ? ? serial_omap_port_enable(up); >>> ? ? ? iir = serial_in(up, UART_IIR); >>> - ? ? if (iir & UART_IIR_NO_INT) >>> + ? ? if (iir & UART_IIR_NO_INT) { >>> + ? ? ? ? ? ? serial_omap_port_disable(up); >>> ? ? ? ? ? ? ? return IRQ_NONE; >>> + ? ? } >>> >>> ? ? ? spin_lock_irqsave(&up->port.lock, flags); >>> ? ? ? lsr = serial_in(up, UART_LSR); >>> @@ -378,6 +406,8 @@ static inline irqreturn_t serial_omap_irq(int irq, void *dev_id) >>> ? ? ? ? ? ? ? transmit_chars(up); >>> >>> ? ? ? spin_unlock_irqrestore(&up->port.lock, flags); >>> + ? ? serial_omap_port_disable(up); >>> + >>> ? ? ? up->port_activity = jiffies; >>> ? ? ? return IRQ_HANDLED; >>> ?} >>> @@ -388,11 +418,12 @@ static unsigned int serial_omap_tx_empty(struct uart_port *port) >>> ? ? ? unsigned long flags = 0; >>> ? ? ? unsigned int ret = 0; >>> >>> + ? ? serial_omap_port_enable(up); >>> ? ? ? dev_dbg(up->port.dev, "serial_omap_tx_empty+%d\n", up->pdev->id); >>> ? ? ? spin_lock_irqsave(&up->port.lock, flags); >>> ? ? ? ret = serial_in(up, UART_LSR) & UART_LSR_TEMT ? TIOCSER_TEMT : 0; >>> ? ? ? spin_unlock_irqrestore(&up->port.lock, flags); >>> - >>> + ? ? serial_omap_port_disable(up); >>> ? ? ? return ret; >>> ?} >>> >>> @@ -402,7 +433,10 @@ static unsigned int serial_omap_get_mctrl(struct uart_port *port) >>> ? ? ? unsigned char status; >>> ? ? ? unsigned int ret = 0; >>> >>> + ? ? serial_omap_port_enable(up); >>> ? ? ? status = check_modem_status(up); >>> + ? ? serial_omap_port_disable(up); >>> + >>> ? ? ? dev_dbg(up->port.dev, "serial_omap_get_mctrl+%d\n", up->pdev->id); >>> >>> ? ? ? if (status & UART_MSR_DCD) >>> @@ -434,7 +468,9 @@ static void serial_omap_set_mctrl(struct uart_port *port, unsigned int mctrl) >>> ? ? ? ? ? ? ? mcr |= UART_MCR_LOOP; >>> >>> ? ? ? mcr |= up->mcr; >>> + ? ? serial_omap_port_enable(up); >>> ? ? ? serial_out(up, UART_MCR, mcr); >>> + ? ? serial_omap_port_disable(up); >>> ?} >>> >>> ?static void serial_omap_break_ctl(struct uart_port *port, int break_state) >>> @@ -443,6 +479,7 @@ static void serial_omap_break_ctl(struct uart_port *port, int break_state) >>> ? ? ? unsigned long flags = 0; >>> >>> ? ? ? dev_dbg(up->port.dev, "serial_omap_break_ctl+%d\n", up->pdev->id); >>> + ? ? serial_omap_port_enable(up); >>> ? ? ? spin_lock_irqsave(&up->port.lock, flags); >>> ? ? ? if (break_state == -1) >>> ? ? ? ? ? ? ? up->lcr |= UART_LCR_SBC; >>> @@ -450,6 +487,7 @@ static void serial_omap_break_ctl(struct uart_port *port, int break_state) >>> ? ? ? ? ? ? ? up->lcr &= ~UART_LCR_SBC; >>> ? ? ? serial_out(up, UART_LCR, up->lcr); >>> ? ? ? spin_unlock_irqrestore(&up->port.lock, flags); >>> + ? ? serial_omap_port_disable(up); >>> ?} >>> >>> ?static int serial_omap_startup(struct uart_port *port) >>> @@ -468,6 +506,7 @@ static int serial_omap_startup(struct uart_port *port) >>> >>> ? ? ? dev_dbg(up->port.dev, "serial_omap_startup+%d\n", up->pdev->id); >>> >>> + ? ? serial_omap_port_enable(up); >>> ? ? ? /* >>> ? ? ? ?* Clear the FIFO buffers and disable them. >>> ? ? ? ?* (they will be reenabled in set_termios()) >>> @@ -523,6 +562,7 @@ static int serial_omap_startup(struct uart_port *port) >>> ? ? ? /* Enable module level wake up */ >>> ? ? ? serial_out(up, UART_OMAP_WER, OMAP_UART_WER_MOD_WKUP); >>> >>> + ? ? serial_omap_port_disable(up); >>> ? ? ? up->port_activity = jiffies; >>> ? ? ? return 0; >>> ?} >>> @@ -533,6 +573,8 @@ static void serial_omap_shutdown(struct uart_port *port) >>> ? ? ? unsigned long flags = 0; >>> >>> ? ? ? dev_dbg(up->port.dev, "serial_omap_shutdown+%d\n", up->pdev->id); >>> + >>> + ? ? serial_omap_port_enable(up); >>> ? ? ? /* >>> ? ? ? ?* Disable interrupts from this port >>> ? ? ? ?*/ >>> @@ -566,6 +608,7 @@ static void serial_omap_shutdown(struct uart_port *port) >>> ? ? ? ? ? ? ? ? ? ? ? up->uart_dma.rx_buf_dma_phys); >>> ? ? ? ? ? ? ? up->uart_dma.rx_buf = NULL; >>> ? ? ? } >>> + ? ? serial_omap_port_disable(up); >>> ? ? ? free_irq(up->port.irq, up); >>> ?} >>> >>> @@ -671,6 +714,10 @@ serial_omap_set_termios(struct uart_port *port, struct ktermios *termios, >>> ? ? ? baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/13); >>> ? ? ? quot = serial_omap_get_divisor(port, baud); >>> >>> + ? ? up->dll = quot & 0xff; >>> + ? ? up->dlh = quot >> 8; >>> + ? ? up->mdr1 = UART_OMAP_MDR1_DISABLE; >>> + >>> ? ? ? up->fcr = UART_FCR_R_TRIG_01 | UART_FCR_T_TRIG_01 | >>> ? ? ? ? ? ? ? ? ? ? ? UART_FCR_ENABLE_FIFO; >>> ? ? ? if (up->use_dma) >>> @@ -680,6 +727,7 @@ serial_omap_set_termios(struct uart_port *port, struct ktermios *termios, >>> ? ? ? ?* Ok, we're now changing the port state. Do it with >>> ? ? ? ?* interrupts disabled. >>> ? ? ? ?*/ >>> + ? ? serial_omap_port_enable(up); >>> ? ? ? spin_lock_irqsave(&up->port.lock, flags); >>> >>> ? ? ? /* >>> @@ -723,6 +771,7 @@ serial_omap_set_termios(struct uart_port *port, struct ktermios *termios, >>> ? ? ? ? ? ? ? up->ier |= UART_IER_MSI; >>> ? ? ? serial_out(up, UART_IER, up->ier); >>> ? ? ? serial_out(up, UART_LCR, cval); ? ? ? ? /* reset DLAB */ >>> + ? ? up->lcr = cval; >>> >>> ? ? ? /* FIFOs and DMA Settings */ >>> >>> @@ -758,8 +807,7 @@ serial_omap_set_termios(struct uart_port *port, struct ktermios *termios, >>> ? ? ? serial_out(up, UART_MCR, up->mcr); >>> >>> ? ? ? /* Protocol, Baud Rate, and Interrupt Settings */ >>> - >>> - ? ? serial_out(up, UART_OMAP_MDR1, UART_OMAP_MDR1_DISABLE); >>> + ? ? serial_out(up, UART_OMAP_MDR1, up->mdr1); >>> ? ? ? serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B); >>> >>> ? ? ? up->efr = serial_in(up, UART_EFR); >>> @@ -769,8 +817,8 @@ serial_omap_set_termios(struct uart_port *port, struct ktermios *termios, >>> ? ? ? serial_out(up, UART_IER, 0); >>> ? ? ? serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B); >>> >>> - ? ? serial_out(up, UART_DLL, quot & 0xff); ? ? ? ? ?/* LS of divisor */ >>> - ? ? serial_out(up, UART_DLM, quot >> 8); ? ? ? ? ? ?/* MS of divisor */ >>> + ? ? serial_out(up, UART_DLL, up->dll); ? ? ?/* LS of divisor */ >>> + ? ? serial_out(up, UART_DLM, up->dlh); ? ? ?/* MS of divisor */ >>> >>> ? ? ? serial_out(up, UART_LCR, 0); >>> ? ? ? serial_out(up, UART_IER, up->ier); >>> @@ -780,9 +828,11 @@ serial_omap_set_termios(struct uart_port *port, struct ktermios *termios, >>> ? ? ? serial_out(up, UART_LCR, cval); >>> >>> ? ? ? if (baud > 230400 && baud != 3000000) >>> - ? ? ? ? ? ? serial_out(up, UART_OMAP_MDR1, UART_OMAP_MDR1_13X_MODE); >>> + ? ? ? ? ? ? up->mdr1 = UART_OMAP_MDR1_13X_MODE; >>> ? ? ? else >>> - ? ? ? ? ? ? serial_out(up, UART_OMAP_MDR1, UART_OMAP_MDR1_16X_MODE); >>> + ? ? ? ? ? ? up->mdr1 = UART_OMAP_MDR1_16X_MODE; >>> + >>> + ? ? serial_out(up, UART_OMAP_MDR1, up->mdr1) >>> >>> ? ? ? /* Hardware Flow Control Configuration */ >>> >>> @@ -810,6 +860,7 @@ serial_omap_set_termios(struct uart_port *port, struct ktermios *termios, >>> ? ? ? ? ? ? ? serial_omap_configure_xonxoff(up, termios); >>> >>> ? ? ? spin_unlock_irqrestore(&up->port.lock, flags); >>> + ? ? serial_omap_port_disable(up); >>> ? ? ? dev_dbg(up->port.dev, "serial_omap_set_termios+%d\n", up->pdev->id); >>> ?} >>> >>> @@ -821,6 +872,8 @@ serial_omap_pm(struct uart_port *port, unsigned int state, >>> ? ? ? unsigned char efr; >>> >>> ? ? ? dev_dbg(up->port.dev, "serial_omap_pm+%d\n", up->pdev->id); >>> + >>> + ? ? serial_omap_port_enable(up); >>> ? ? ? serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B); >>> ? ? ? efr = serial_in(up, UART_EFR); >>> ? ? ? serial_out(up, UART_EFR, efr | UART_EFR_ECB); >>> @@ -830,6 +883,10 @@ serial_omap_pm(struct uart_port *port, unsigned int state, >>> ? ? ? serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B); >>> ? ? ? serial_out(up, UART_EFR, efr); >>> ? ? ? serial_out(up, UART_LCR, 0); >>> + ? ? if (state) >>> + ? ? ? ? ? ? pm_runtime_put_sync(&up->pdev->dev); >>> + ? ? else >>> + ? ? ? ? ? ? serial_omap_port_disable(up); >> >> OK, so this boils down to either a _put_sync() or a _mark_last_busy + >> _put_autosuspend(), depending on whether this is suspending or resuming, >> right? >> > > yes also during bootup. > disable the ports immediately that are not used during bootup. > >> Why the difference? > > Need to put the ports down immediately during system wide suspend > other wise autosuspend delay will prevent system to enter > suspend state immediately. OK, as I stated above. All of these serial_omap_port_disable() calls need to be removed and replaced with runtime PM API calls directly. Here, I think it can always be a basic _put() for suspend and _get_sync() for resume. Incendentally, the 'else' clause of that code (state == 0) should be the resume case, but you're calling _disable(). That doesn't look right. >> >>> ?} >>> >>> ?static void serial_omap_release_port(struct uart_port *port) >>> @@ -907,25 +964,31 @@ static inline void wait_for_xmitr(struct uart_omap_port *up) >>> ?static void serial_omap_poll_put_char(struct uart_port *port, unsigned char ch) >>> ?{ >>> ? ? ? struct uart_omap_port *up = (struct uart_omap_port *)port; >>> + >>> + ? ? serial_omap_port_enable(up); >>> ? ? ? wait_for_xmitr(up); >>> ? ? ? serial_out(up, UART_TX, ch); >>> + ? ? serial_omap_port_disable(up); >>> ?} >>> >>> ?static int serial_omap_poll_get_char(struct uart_port *port) >>> ?{ >>> ? ? ? struct uart_omap_port *up = (struct uart_omap_port *)port; >>> - ? ? unsigned int status = serial_in(up, UART_LSR); >>> + ? ? unsigned int status; >>> >>> + ? ? serial_omap_port_enable(up); >>> + ? ? status = serial_in(up, UART_LSR); >>> ? ? ? if (!(status & UART_LSR_DR)) >>> ? ? ? ? ? ? ? return NO_POLL_CHAR; >>> >>> - ? ? return serial_in(up, UART_RX); >>> + ? ? status = serial_in(up, UART_RX); >>> + ? ? serial_omap_port_disable(up); >>> + ? ? return status; >>> ?} >>> >>> ?#endif /* CONFIG_CONSOLE_POLL */ >>> >>> ?#ifdef CONFIG_SERIAL_OMAP_CONSOLE >>> - >>> ?static struct uart_omap_port *serial_omap_console_ports[4]; >>> >>> ?static struct uart_driver serial_omap_reg; >>> @@ -955,6 +1018,8 @@ serial_omap_console_write(struct console *co, const char *s, >>> ? ? ? else >>> ? ? ? ? ? ? ? spin_lock(&up->port.lock); >>> >>> + ? ? serial_omap_port_enable(up); >>> + >>> ? ? ? /* >>> ? ? ? ?* First save the IER then disable the interrupts >>> ? ? ? ?*/ >>> @@ -979,6 +1044,7 @@ serial_omap_console_write(struct console *co, const char *s, >>> ? ? ? if (up->msr_saved_flags) >>> ? ? ? ? ? ? ? check_modem_status(up); >>> >>> + ? ? serial_omap_port_disable(up); >>> ? ? ? if (locked) >>> ? ? ? ? ? ? ? spin_unlock(&up->port.lock); >>> ? ? ? local_irq_restore(flags); >>> @@ -1061,22 +1127,27 @@ static struct uart_driver serial_omap_reg = { >>> ? ? ? .cons ? ? ? ? ? = OMAP_CONSOLE, >>> ?}; >>> >>> -static int >>> -serial_omap_suspend(struct platform_device *pdev, pm_message_t state) >>> +static int serial_omap_suspend(struct device *dev) >>> ?{ >>> - ? ? struct uart_omap_port *up = platform_get_drvdata(pdev); >>> + ? ? struct uart_omap_port *up = dev_get_drvdata(dev); >>> >>> - ? ? if (up) >>> + ? ? if (up) { >>> ? ? ? ? ? ? ? uart_suspend_port(&serial_omap_reg, &up->port); >>> + ? ? ? ? ? ? console_trylock(); >> >> This locking needs to be explained. ?Why it is needed, but very >> importantly, why you are not checking the return value of the _trylock() >> > > any print after this point can result in failure of immediate system suspending > due to delayed autosuspend from omap_console_write. I mean explained in the changelog and preferrably the code. Also, technically speaking, it's not until the clocks are cut (after the devices runtime_suspend callback is called) that UART writes will fault. > log prints after uart suspend and print them during resume. > > >>> + ? ? ? ? ? ? serial_omap_pm(&up->port, 3, 0); >> >> Why is this call needed? >> > > Actually this is needed if no_console_suspend is used, for that > case the console will remain active since serial_omap_pm is not > getting called from serial_core and port is not suspended > immediately with put_sync. > > prints during system wide suspend and delayed autosuspend > from console_write keeps system active in no_console_suspend case > so put in forced suspend state and log all prints to be printed later. > > probably needs to a condition check if (no_console_suspend) No. If the user has requested no_console_suspend, then the user should expect that the UARTs remain active and thus prevent low-power. >> uart_suspend_port() calls uart_change_pm() which should call the ->pm >> method of struct uart_ops (which is serial_omap_pm). ?What am I missing? >> >> Also notice you're not calling serial_omap_pm() in the resume method >> below to change it back. >> >>> + ? ? } >>> ? ? ? return 0; >>> ?} >> >> Also, device wakeup capability should be checked and enabled/disabled in >> the suspend path (not only the runtime suspend path.) >> > > ok. > > >>> -static int serial_omap_resume(struct platform_device *dev) >>> +static int serial_omap_resume(struct device *dev) >>> ?{ >>> - ? ? struct uart_omap_port *up = platform_get_drvdata(dev); >>> + ? ? struct uart_omap_port *up = dev_get_drvdata(dev); >>> >>> - ? ? if (up) >>> + ? ? if (up) { >>> ? ? ? ? ? ? ? uart_resume_port(&serial_omap_reg, &up->port); >>> + ? ? ? ? ? ? console_unlock(); >> >> Again, please describe locking in comments. >> >> Also, what happens here if the console_trylock() in your suspend method >> failed? >> > > need to add a flag to check and unlock > from return status of trylock. > >>> + ? ? } >>> + >>> ? ? ? return 0; >>> ?} >>> >>> @@ -1097,6 +1168,7 @@ static void serial_omap_rx_timeout(unsigned long uart_no) >>> ? ? ? ? ? ? ? ? ? ? ? serial_omap_stop_rxdma(up); >>> ? ? ? ? ? ? ? ? ? ? ? up->ier |= (UART_IER_RDI | UART_IER_RLSI); >>> ? ? ? ? ? ? ? ? ? ? ? serial_out(up, UART_IER, up->ier); >>> + ? ? ? ? ? ? ? ? ? ? serial_omap_port_disable(up); >>> ? ? ? ? ? ? ? } >>> ? ? ? ? ? ? ? return; >>> ? ? ? } >>> @@ -1128,6 +1200,9 @@ static void serial_omap_rx_timeout(unsigned long uart_no) >>> >>> ?static void uart_rx_dma_callback(int lch, u16 ch_status, void *data) >>> ?{ >>> + ? ? struct uart_omap_port *up = (struct uart_omap_port *)data; >>> + >>> + ? ? serial_omap_port_disable(up); >>> ? ? ? return; >>> ?} >>> >>> @@ -1135,6 +1210,7 @@ static int serial_omap_start_rxdma(struct uart_omap_port *up) >>> ?{ >>> ? ? ? int ret = 0; >>> >>> + ? ? serial_omap_port_enable(up); >>> ? ? ? if (up->uart_dma.rx_dma_channel == -1) { >>> ? ? ? ? ? ? ? ret = omap_request_dma(up->uart_dma.uart_dma_rx, >>> ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? "UART Rx DMA", >>> @@ -1214,6 +1290,7 @@ static void uart_tx_dma_callback(int lch, u16 ch_status, void *data) >>> ? ? ? ? ? ? ? serial_omap_stop_tx(&up->port); >>> ? ? ? ? ? ? ? up->uart_dma.tx_dma_used = false; >>> ? ? ? ? ? ? ? spin_unlock(&(up->uart_dma.tx_lock)); >>> + ? ? ? ? ? ? serial_omap_port_disable(up); >>> ? ? ? } else { >>> ? ? ? ? ? ? ? omap_stop_dma(up->uart_dma.tx_dma_channel); >>> ? ? ? ? ? ? ? serial_omap_continue_tx(up); >>> @@ -1224,9 +1301,10 @@ static void uart_tx_dma_callback(int lch, u16 ch_status, void *data) >>> >>> ?static int serial_omap_probe(struct platform_device *pdev) >>> ?{ >>> - ? ? struct uart_omap_port ? *up; >>> + ? ? struct uart_omap_port ? *up = NULL; >>> ? ? ? struct resource ? ? ? ? *mem, *irq, *dma_tx, *dma_rx; >>> ? ? ? struct omap_uart_port_info *omap_up_info = pdev->dev.platform_data; >>> + ? ? struct omap_device *od; >>> ? ? ? int ret = -ENOSPC; >>> >>> ? ? ? mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); >>> @@ -1276,12 +1354,20 @@ static int serial_omap_probe(struct platform_device *pdev) >>> ? ? ? up->port.ops = &serial_omap_pops; >>> ? ? ? up->port.line = pdev->id; >>> >>> - ? ? up->port.membase = omap_up_info->membase; >>> - ? ? up->port.mapbase = omap_up_info->mapbase; >>> + ? ? up->port.mapbase = mem->start; >>> + ? ? up->port.membase = ioremap(mem->start, mem->end - mem->start); >>> + >>> + ? ? if (!up->port.membase) { >>> + ? ? ? ? ? ? dev_err(&pdev->dev, "can't ioremap UART\n"); >>> + ? ? ? ? ? ? ret = -ENOMEM; >>> + ? ? ? ? ? ? goto err1; >>> + ? ? } >>> + >>> ? ? ? up->port.flags = omap_up_info->flags; >>> - ? ? up->port.irqflags = omap_up_info->irqflags; >>> ? ? ? up->port.uartclk = omap_up_info->uartclk; >>> ? ? ? up->uart_dma.uart_base = mem->start; >>> + ? ? up->errata = omap_up_info->errata; >>> + ? ? up->enable_wakeup = omap_up_info->enable_wakeup; >>> >>> ? ? ? if (omap_up_info->dma_enabled) { >>> ? ? ? ? ? ? ? up->uart_dma.uart_dma_tx = dma_tx->start; >>> @@ -1295,18 +1381,36 @@ static int serial_omap_probe(struct platform_device *pdev) >>> ? ? ? ? ? ? ? up->uart_dma.rx_dma_channel = OMAP_UART_DMA_CH_FREE; >>> ? ? ? } >>> >>> + ? ? pm_runtime_use_autosuspend(&pdev->dev); >>> + ? ? pm_runtime_set_autosuspend_delay(&pdev->dev, >>> + ? ? ? ? ? ? ? ? ? ? OMAP_UART_AUTOSUSPEND_DELAY); >>> + >>> + ? ? pm_runtime_enable(&pdev->dev); >>> + ? ? pm_runtime_irq_safe(&pdev->dev); >>> + >>> + ? ? if (omap_up_info->console_uart) { >>> + ? ? ? ? ? ? od = to_omap_device(up->pdev); >>> + ? ? ? ? ? ? omap_hwmod_idle(od->hwmods[0]); >>> + ? ? ? ? ? ? serial_omap_port_enable(up); >>> + ? ? ? ? ? ? serial_omap_port_disable(up); >>> + ? ? } >>> + >>> ? ? ? ui[pdev->id] = up; >>> ? ? ? serial_omap_add_console_port(up); >>> >>> ? ? ? ret = uart_add_one_port(&serial_omap_reg, &up->port); >>> ? ? ? if (ret != 0) >>> - ? ? ? ? ? ? goto do_release_region; >>> + ? ? ? ? ? ? goto err1; >>> >>> + ? ? dev_set_drvdata(&pdev->dev, up); >>> ? ? ? platform_set_drvdata(pdev, up); >>> + >>> ? ? ? return 0; >>> ?err: >>> ? ? ? dev_err(&pdev->dev, "[UART%d]: failure [%s]: %d\n", >>> ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? pdev->id, __func__, ret); >>> +err1: >>> + ? ? kfree(up); >>> ?do_release_region: >>> ? ? ? release_mem_region(mem->start, (mem->end - mem->start) + 1); >>> ? ? ? return ret; >>> @@ -1318,20 +1422,76 @@ static int serial_omap_remove(struct platform_device *dev) >>> >>> ? ? ? platform_set_drvdata(dev, NULL); >>> ? ? ? if (up) { >>> + ? ? ? ? ? ? pm_runtime_disable(&up->pdev->dev); >>> ? ? ? ? ? ? ? uart_remove_one_port(&serial_omap_reg, &up->port); >>> ? ? ? ? ? ? ? kfree(up); >>> ? ? ? } >>> ? ? ? return 0; >>> ?} >>> >>> +static void omap_uart_restore_context(struct uart_omap_port *up) >>> +{ >>> + ? ? u16 efr = 0; >>> + >>> + ? ? serial_out(up, UART_OMAP_MDR1, up->mdr1); >>> + ? ? serial_out(up, UART_LCR, 0xBF); /* Config B mode */ >>> + ? ? efr = serial_in(up, UART_EFR); >>> + ? ? serial_out(up, UART_EFR, UART_EFR_ECB); >>> + ? ? serial_out(up, UART_LCR, 0x0); /* Operational mode */ >>> + ? ? serial_out(up, UART_IER, 0x0); >>> + ? ? serial_out(up, UART_LCR, 0xBF); /* Config B mode */ >>> + ? ? serial_out(up, UART_DLL, up->dll); >>> + ? ? serial_out(up, UART_DLM, up->dlh); >>> + ? ? serial_out(up, UART_LCR, 0x0); /* Operational mode */ >>> + ? ? serial_out(up, UART_IER, up->ier); >>> + ? ? serial_out(up, UART_FCR, up->fcr); >>> + ? ? serial_out(up, UART_LCR, 0x80); >>> + ? ? serial_out(up, UART_MCR, up->mcr); >>> + ? ? serial_out(up, UART_LCR, 0xBF); /* Config B mode */ >>> + ? ? serial_out(up, UART_EFR, efr); >>> + ? ? serial_out(up, UART_LCR, up->lcr); >>> + ? ? /* UART 16x mode */ >>> + ? ? serial_out(up, UART_OMAP_MDR1, up->mdr1); >>> +} >>> + >>> +static int omap_serial_runtime_suspend(struct device *dev) >>> +{ >>> + ? ? struct uart_omap_port *up = dev_get_drvdata(dev); >>> + >>> + ? ? if (!up) >>> + ? ? ? ? ? ? goto done; >>> + >>> + ? ? if (device_may_wakeup(dev)) >>> + ? ? ? ? ? ? up->enable_wakeup(up->pdev, true); >>> + ? ? else >>> + ? ? ? ? ? ? up->enable_wakeup(up->pdev, false); >> >> I know the earlier code was doing it this way too, but an optimization >> would be to have the driver keep state whether the wakeups are enabled >> or disabled, so you don't have to keep calling this function (which can >> be expensive with the PRCM reads/writes. >> > > if dynamically disabled from user space from sys-fs interface. > it may not reflect disable_wakup immediately if internal state machine of > wakeup is maintained within uart driver. Why does that matter? It does not need to take effect immedately, it only needs to take effect on suspend. Just update internal state whenever you change the hardware, and whenver you're about to change the hardware again, check device_may_wakeup() and check the driver's internal state. > also need to modify the internals of this func pointer to use > hmwod API's as commented above. OK