From mboxrd@z Thu Jan 1 00:00:00 1970 From: mturquette@linaro.org (Mike Turquette) Date: Tue, 18 Feb 2014 21:21:25 -0800 Subject: [PATCH v7 2/8] clk: sunxi: Implement MMC phase control In-Reply-To: <20140218141532.GH3142@lukather> References: <20140217095907.15040.81893.stgit@pagira.o2s.ch> <20140217100221.15040.47203.stgit@pagira.o2s.ch> <20140218141532.GH3142@lukather> Message-ID: <20140219052125.8345.70717@quantum> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org Quoting Maxime Ripard (2014-02-18 06:15:32) > Hi, > > On Mon, Feb 17, 2014 at 11:02:21AM +0100, David Lanzend?rfer wrote: > > From: Emilio L?pez > > > > Signed-off-by: Emilio L?pez > > You're missing your Signed-off-by here too. Remember, for every patch > you send, your Signed-off-by must be there, regardless wether you're > the author or not. > > A commit log would be very much welcome too. > > Now, down to the patch itself, I remember Mike saying that he would > prefer adding a function in the framework instead of hardcoding > it. Mike, what's your feeling on this? Would merging this seem > reasonnable to you as is, or do you want to take this to the > framework? Hi Maxime & Emilio, Maybe something like the following RFC? If it seems sufficient for this case then I will post to the wider list with an eye towards merging it for 3.15. I've Cc'd Dinh since this came up on the socfpga thread as well. Regards, Mike >>From 56fa297591be5c5e22df6d2ca43fccf285a45636 Mon Sep 17 00:00:00 2001 From: Mike Turquette Date: Tue, 18 Feb 2014 20:33:50 -0800 Subject: [PATCH] clk: introduce clk_set_phase function & callback A common operation for a clock signal generator is to shift the phase of that signal. This patch introduces a new function to the clk.h API to dynamically adjust the phase of a clock signal. Additionally this patch introduces support for the new function in the common clock framework via the .set_phase call back in struct clk_ops. Signed-off-by: Mike Turquette --- This patch is totally untested. It may make your board burst into flames. drivers/clk/clk.c | 84 +++++++++++++++++++++++++++++++++++++++++--- include/linux/clk-private.h | 1 + include/linux/clk-provider.h | 5 +++ include/linux/clk.h | 29 +++++++++++++++ 4 files changed, 115 insertions(+), 4 deletions(-) diff --git a/drivers/clk/clk.c b/drivers/clk/clk.c index ea2ca9f..635170a 100644 --- a/drivers/clk/clk.c +++ b/drivers/clk/clk.c @@ -106,11 +106,11 @@ static void clk_summary_show_one(struct seq_file *s, struct clk *c, int level) if (!c) return; - seq_printf(s, "%*s%-*s %-11d %-12d %-10lu %-11lu", + seq_printf(s, "%*s%-*s %-11d %-12d %-10lu %-11lu %-3d", level * 3 + 1, "", 30 - level * 3, c->name, c->enable_count, c->prepare_count, clk_get_rate(c), - clk_get_accuracy(c)); + clk_get_accuracy(c), clk_get_phase(c)); seq_printf(s, "\n"); } @@ -132,8 +132,8 @@ static int clk_summary_show(struct seq_file *s, void *data) { struct clk *c; - seq_printf(s, " clock enable_cnt prepare_cnt rate accuracy\n"); - seq_printf(s, "---------------------------------------------------------------------------------\n"); + seq_printf(s, " clock enable_cnt prepare_cnt rate accuracy phase\n"); + seq_printf(s, "-----------------------------------------------------------------------------------------\n"); clk_prepare_lock(); @@ -171,6 +171,7 @@ static void clk_dump_one(struct seq_file *s, struct clk *c, int level) seq_printf(s, "\"prepare_count\": %d,", c->prepare_count); seq_printf(s, "\"rate\": %lu", clk_get_rate(c)); seq_printf(s, "\"accuracy\": %lu", clk_get_accuracy(c)); + seq_printf(s, "\"phase\": %d", clk_get_phase(c)); } static void clk_dump_subtree(struct seq_file *s, struct clk *c, int level) @@ -257,6 +258,11 @@ static int clk_debug_create_one(struct clk *clk, struct dentry *pdentry) if (!d) goto err_out; + d = debugfs_create_u32("clk_phase", S_IRUGO, clk->dentry, + (u32 *)&clk->phase); + if (!d) + goto err_out; + d = debugfs_create_x32("clk_flags", S_IRUGO, clk->dentry, (u32 *)&clk->flags); if (!d) @@ -1766,6 +1772,76 @@ out: EXPORT_SYMBOL_GPL(clk_set_parent); /** + * clk_set_phase - adjust the phase shift of a clock signal + * @clk: clock signal source + * @degrees: number of degrees the signal is shifted + * + * Shifts the phase of a clock signal by the specified degrees. Returns 0 on + * success, -EERROR otherwise. + * + * This function makes no distiction about the input or reference signal that + * we adjust the clock signal phase against. For example phase locked-loop + * clock signal generators we may shift phase with respect to feedback clock + * signal input, but for other cases the clock phase may be shifted with + * respect to some other, unspecified signal. + * + * Additionally the concept of phase shift does not propagate through the clock + * tree hierarchy, which sets it appart from clock rates and clock accuracy. A + * parent clock phase attribute does not have an impact on the phase attribute + * of a child clock. + */ +int clk_set_phase(struct clk *clk, int degrees) +{ + int ret = 0; + + if (!clk) + goto out; + + /* sanity check degrees */ + degrees %= 360; + if (degrees < 0) + degrees += 360; + + clk_prepare_lock(); + + if (!clk->ops->set_phase) + goto out_unlock; + + ret = clk->ops->set_phase(clk->hw, degrees); + + if (!ret) + clk->phase = degrees; + +out_unlock: + clk_prepare_unlock(); + +out: + return ret; +} + +/** + * clk_get_phase - return the phase shift of a clock signal + * @clk: clock signal source + * + * Returns the phase shift of a clock node in degrees, otherwise returns + * -EERROR. + */ +int clk_get_phase(struct clk *clk) +{ + int ret = 0; + + if (!clk) + goto out; + + clk_prepare_lock(); + ret = clk->phase; + clk_prepare_unlock(); + +out: + return ret; +} + +/** * __clk_init - initialize the data structures in a struct clk * @dev: device initializing this clk, placeholder for now * @clk: clk being initialized diff --git a/include/linux/clk-private.h b/include/linux/clk-private.h index efbf70b..845be30 100644 --- a/include/linux/clk-private.h +++ b/include/linux/clk-private.h @@ -46,6 +46,7 @@ struct clk { unsigned int enable_count; unsigned int prepare_count; unsigned long accuracy; + int phase; struct hlist_head children; struct hlist_node child_node; unsigned int notifier_count; diff --git a/include/linux/clk-provider.h b/include/linux/clk-provider.h index 939533d..cc49fb8 100644 --- a/include/linux/clk-provider.h +++ b/include/linux/clk-provider.h @@ -127,6 +127,10 @@ struct clk_hw; * separately via calls to .set_parent and .set_rate. * Returns 0 on success, -EERROR otherwise. * + * @set_phase: Shift the phase this clock signal in degrees specified + * by the second argument. Valid values for degrees are + * 0-359. Return 0 on success, otherwise -EERROR. + * * * The clk_enable/clk_disable and clk_prepare/clk_unprepare pairs allow * implementations to split any work between atomic (enable) and sleepable @@ -164,6 +168,7 @@ struct clk_ops { unsigned long parent_rate, u8 index); unsigned long (*recalc_accuracy)(struct clk_hw *hw, unsigned long parent_accuracy); + int (*set_phase)(struct clk_hw *hw, int degrees); void (*init)(struct clk_hw *hw); }; diff --git a/include/linux/clk.h b/include/linux/clk.h index 0dd9114..ae2b2f4 100644 --- a/include/linux/clk.h +++ b/include/linux/clk.h @@ -92,6 +92,25 @@ int clk_notifier_unregister(struct clk *clk, struct notifier_block *nb); */ long clk_get_accuracy(struct clk *clk); +/** + * clk_set_phase - adjust the phase shift of a clock signal + * @clk: clock signal source + * @degrees: number of degrees the signal is shifted + * + * Shifts the phase of a clock signal by the specified degrees. Returns 0 on + * success, -EERROR otherwise. + */ +int clk_set_phase(struct clk *clk, int degrees); + +/** + * clk_get_phase - return the phase shift of a clock signal + * @clk: clock signal source + * + * Returns the phase shift of a clock node in degrees, otherwise returns + * -EERROR. + */ +int clk_get_phase(struct clk *clk); + #else static inline long clk_get_accuracy(struct clk *clk) @@ -99,6 +118,16 @@ static inline long clk_get_accuracy(struct clk *clk) return -ENOTSUPP; } +static inline long clk_set_phase(struct clk *clk, int phase) +{ + return -ENOTSUPP; +} + +static inline long clk_get_phase(struct clk *clk) +{ + return -ENOTSUPP; +} + #endif /** -- 1.8.3.2 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Mike Turquette Subject: Re: [PATCH v7 2/8] clk: sunxi: Implement MMC phase control Date: Tue, 18 Feb 2014 21:21:25 -0800 Message-ID: <20140219052125.8345.70717@quantum> References: <20140217095907.15040.81893.stgit@pagira.o2s.ch> <20140217100221.15040.47203.stgit@pagira.o2s.ch> <20140218141532.GH3142@lukather> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20140218141532.GH3142@lukather> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=m.gmane.org@lists.infradead.org To: Maxime Ripard , =?utf-8?q?David_Lanzend=C3=B6rfer?= Cc: devicetree@vger.kernel.org, dinguyen@altera.com, "Ulf Hansson , Laurent Pinchart , Simon Baatz , Hans de Goede , =?utf-8?q?Emilio_L=C3=B3pez?= , linux-mmc@vger.kernel.org, Chris Ball , linux-kernel@vger.kernel.org, H Hartley Sweeten , linux-sunxi@googlegroups.com, Tejun Heo , Guennadi Liakhovetski" , linux-arm-kernel@lists.infradead.org List-Id: devicetree@vger.kernel.org UXVvdGluZyBNYXhpbWUgUmlwYXJkICgyMDE0LTAyLTE4IDA2OjE1OjMyKQo+IEhpLAo+IAo+IE9u IE1vbiwgRmViIDE3LCAyMDE0IGF0IDExOjAyOjIxQU0gKzAxMDAsIERhdmlkIExhbnplbmTDtnJm ZXIgd3JvdGU6Cj4gPiBGcm9tOiBFbWlsaW8gTMOzcGV6IDxlbWlsaW9AZWxvcGV6LmNvbS5hcj4K PiA+IAo+ID4gU2lnbmVkLW9mZi1ieTogRW1pbGlvIEzDs3BleiA8ZW1pbGlvQGVsb3Blei5jb20u YXI+Cj4gCj4gWW91J3JlIG1pc3NpbmcgeW91ciBTaWduZWQtb2ZmLWJ5IGhlcmUgdG9vLiAgUmVt ZW1iZXIsIGZvciBldmVyeSBwYXRjaAo+IHlvdSBzZW5kLCB5b3VyIFNpZ25lZC1vZmYtYnkgbXVz dCBiZSB0aGVyZSwgcmVnYXJkbGVzcyB3ZXRoZXIgeW91J3JlCj4gdGhlIGF1dGhvciBvciBub3Qu Cj4gCj4gQSBjb21taXQgbG9nIHdvdWxkIGJlIHZlcnkgbXVjaCB3ZWxjb21lIHRvby4KPiAKPiBO b3csIGRvd24gdG8gdGhlIHBhdGNoIGl0c2VsZiwgSSByZW1lbWJlciBNaWtlIHNheWluZyB0aGF0 IGhlIHdvdWxkCj4gcHJlZmVyIGFkZGluZyBhIGZ1bmN0aW9uIGluIHRoZSBmcmFtZXdvcmsgaW5z dGVhZCBvZiBoYXJkY29kaW5nCj4gaXQuIE1pa2UsIHdoYXQncyB5b3VyIGZlZWxpbmcgb24gdGhp cz8gV291bGQgbWVyZ2luZyB0aGlzIHNlZW0KPiByZWFzb25uYWJsZSB0byB5b3UgYXMgaXMsIG9y IGRvIHlvdSB3YW50IHRvIHRha2UgdGhpcyB0byB0aGUKPiBmcmFtZXdvcms/CgpIaSBNYXhpbWUg JiBFbWlsaW8sCgpNYXliZSBzb21ldGhpbmcgbGlrZSB0aGUgZm9sbG93aW5nIFJGQz8gSWYgaXQg c2VlbXMgc3VmZmljaWVudCBmb3IgdGhpcwpjYXNlIHRoZW4gSSB3aWxsIHBvc3QgdG8gdGhlIHdp ZGVyIGxpc3Qgd2l0aCBhbiBleWUgdG93YXJkcyBtZXJnaW5nIGl0CmZvciAzLjE1LiBJJ3ZlIENj J2QgRGluaCBzaW5jZSB0aGlzIGNhbWUgdXAgb24gdGhlIHNvY2ZwZ2EgdGhyZWFkIGFzCndlbGwu CgpSZWdhcmRzLApNaWtlCgoKCkZyb20gNTZmYTI5NzU5MWJlNWM1ZTIyZGY2ZDJjYTQzZmNjZjI4 NWE0NTYzNiBNb24gU2VwIDE3IDAwOjAwOjAwIDIwMDEKRnJvbTogTWlrZSBUdXJxdWV0dGUgPG10 dXJxdWV0dGVAbGluYXJvLm9yZz4KRGF0ZTogVHVlLCAxOCBGZWIgMjAxNCAyMDozMzo1MCAtMDgw MApTdWJqZWN0OiBbUEFUQ0hdIGNsazogaW50cm9kdWNlIGNsa19zZXRfcGhhc2UgZnVuY3Rpb24g JiBjYWxsYmFjawoKQSBjb21tb24gb3BlcmF0aW9uIGZvciBhIGNsb2NrIHNpZ25hbCBnZW5lcmF0 b3IgaXMgdG8gc2hpZnQgdGhlIHBoYXNlIG9mCnRoYXQgc2lnbmFsLiBUaGlzIHBhdGNoIGludHJv ZHVjZXMgYSBuZXcgZnVuY3Rpb24gdG8gdGhlIGNsay5oIEFQSSB0bwpkeW5hbWljYWxseSBhZGp1 c3QgdGhlIHBoYXNlIG9mIGEgY2xvY2sgc2lnbmFsLiBBZGRpdGlvbmFsbHkgdGhpcyBwYXRjaApp bnRyb2R1Y2VzIHN1cHBvcnQgZm9yIHRoZSBuZXcgZnVuY3Rpb24gaW4gdGhlIGNvbW1vbiBjbG9j ayBmcmFtZXdvcmsKdmlhIHRoZSAuc2V0X3BoYXNlIGNhbGwgYmFjayBpbiBzdHJ1Y3QgY2xrX29w cy4KClNpZ25lZC1vZmYtYnk6IE1pa2UgVHVycXVldHRlIDxtdHVycXVldHRlQGxpbmFyby5vcmc+ Ci0tLQpUaGlzIHBhdGNoIGlzIHRvdGFsbHkgdW50ZXN0ZWQuIEl0IG1heSBtYWtlIHlvdXIgYm9h cmQgYnVyc3QgaW50bwpmbGFtZXMuCgogZHJpdmVycy9jbGsvY2xrLmMgICAgICAgICAgICB8IDg0 ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLS0tCiBpbmNsdWRlL2xp bnV4L2Nsay1wcml2YXRlLmggIHwgIDEgKwogaW5jbHVkZS9saW51eC9jbGstcHJvdmlkZXIuaCB8 ICA1ICsrKwogaW5jbHVkZS9saW51eC9jbGsuaCAgICAgICAgICB8IDI5ICsrKysrKysrKysrKysr KwogNCBmaWxlcyBjaGFuZ2VkLCAxMTUgaW5zZXJ0aW9ucygrKSwgNCBkZWxldGlvbnMoLSkKCmRp ZmYgLS1naXQgYS9kcml2ZXJzL2Nsay9jbGsuYyBiL2RyaXZlcnMvY2xrL2Nsay5jCmluZGV4IGVh MmNhOWYuLjYzNTE3MGEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY2xrL2Nsay5jCisrKyBiL2RyaXZl cnMvY2xrL2Nsay5jCkBAIC0xMDYsMTEgKzEwNiwxMSBAQCBzdGF0aWMgdm9pZCBjbGtfc3VtbWFy eV9zaG93X29uZShzdHJ1Y3Qgc2VxX2ZpbGUgKnMsIHN0cnVjdCBjbGsgKmMsIGludCBsZXZlbCkK IAlpZiAoIWMpCiAJCXJldHVybjsKIAotCXNlcV9wcmludGYocywgIiUqcyUtKnMgJS0xMWQgJS0x MmQgJS0xMGx1ICUtMTFsdSIsCisJc2VxX3ByaW50ZihzLCAiJSpzJS0qcyAlLTExZCAlLTEyZCAl LTEwbHUgJS0xMWx1ICUtM2QiLAogCQkgICBsZXZlbCAqIDMgKyAxLCAiIiwKIAkJICAgMzAgLSBs ZXZlbCAqIDMsIGMtPm5hbWUsCiAJCSAgIGMtPmVuYWJsZV9jb3VudCwgYy0+cHJlcGFyZV9jb3Vu dCwgY2xrX2dldF9yYXRlKGMpLAotCQkgICBjbGtfZ2V0X2FjY3VyYWN5KGMpKTsKKwkJICAgY2xr X2dldF9hY2N1cmFjeShjKSwgY2xrX2dldF9waGFzZShjKSk7CiAJc2VxX3ByaW50ZihzLCAiXG4i KTsKIH0KIApAQCAtMTMyLDggKzEzMiw4IEBAIHN0YXRpYyBpbnQgY2xrX3N1bW1hcnlfc2hvdyhz dHJ1Y3Qgc2VxX2ZpbGUgKnMsIHZvaWQgKmRhdGEpCiB7CiAJc3RydWN0IGNsayAqYzsKIAotCXNl cV9wcmludGYocywgIiAgIGNsb2NrICAgICAgICAgICAgICAgICAgICAgICAgZW5hYmxlX2NudCAg cHJlcGFyZV9jbnQgIHJhdGUgICAgICAgIGFjY3VyYWN5XG4iKTsKLQlzZXFfcHJpbnRmKHMsICIt LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS1cbiIpOworCXNlcV9wcmludGYocywgIiAgIGNsb2NrICAg ICAgICAgICAgICAgICAgICAgICAgZW5hYmxlX2NudCAgcHJlcGFyZV9jbnQgIHJhdGUgICAgICAg IGFjY3VyYWN5ICAgcGhhc2VcbiIpOworCXNlcV9wcmludGYocywgIi0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tXG4iKTsKIAogCWNsa19wcmVwYXJlX2xvY2soKTsKIApAQCAtMTcxLDYg KzE3MSw3IEBAIHN0YXRpYyB2b2lkIGNsa19kdW1wX29uZShzdHJ1Y3Qgc2VxX2ZpbGUgKnMsIHN0 cnVjdCBjbGsgKmMsIGludCBsZXZlbCkKIAlzZXFfcHJpbnRmKHMsICJcInByZXBhcmVfY291bnRc IjogJWQsIiwgYy0+cHJlcGFyZV9jb3VudCk7CiAJc2VxX3ByaW50ZihzLCAiXCJyYXRlXCI6ICVs dSIsIGNsa19nZXRfcmF0ZShjKSk7CiAJc2VxX3ByaW50ZihzLCAiXCJhY2N1cmFjeVwiOiAlbHUi LCBjbGtfZ2V0X2FjY3VyYWN5KGMpKTsKKwlzZXFfcHJpbnRmKHMsICJcInBoYXNlXCI6ICVkIiwg Y2xrX2dldF9waGFzZShjKSk7CiB9CiAKIHN0YXRpYyB2b2lkIGNsa19kdW1wX3N1YnRyZWUoc3Ry dWN0IHNlcV9maWxlICpzLCBzdHJ1Y3QgY2xrICpjLCBpbnQgbGV2ZWwpCkBAIC0yNTcsNiArMjU4 LDExIEBAIHN0YXRpYyBpbnQgY2xrX2RlYnVnX2NyZWF0ZV9vbmUoc3RydWN0IGNsayAqY2xrLCBz dHJ1Y3QgZGVudHJ5ICpwZGVudHJ5KQogCWlmICghZCkKIAkJZ290byBlcnJfb3V0OwogCisJZCA9 IGRlYnVnZnNfY3JlYXRlX3UzMigiY2xrX3BoYXNlIiwgU19JUlVHTywgY2xrLT5kZW50cnksCisJ CQkodTMyICopJmNsay0+cGhhc2UpOworCWlmICghZCkKKwkJZ290byBlcnJfb3V0OworCiAJZCA9 IGRlYnVnZnNfY3JlYXRlX3gzMigiY2xrX2ZsYWdzIiwgU19JUlVHTywgY2xrLT5kZW50cnksCiAJ CQkodTMyICopJmNsay0+ZmxhZ3MpOwogCWlmICghZCkKQEAgLTE3NjYsNiArMTc3Miw3NiBAQCBv dXQ6CiBFWFBPUlRfU1lNQk9MX0dQTChjbGtfc2V0X3BhcmVudCk7CiAKIC8qKgorICogY2xrX3Nl dF9waGFzZSAtIGFkanVzdCB0aGUgcGhhc2Ugc2hpZnQgb2YgYSBjbG9jayBzaWduYWwKKyAqIEBj bGs6IGNsb2NrIHNpZ25hbCBzb3VyY2UKKyAqIEBkZWdyZWVzOiBudW1iZXIgb2YgZGVncmVlcyB0 aGUgc2lnbmFsIGlzIHNoaWZ0ZWQKKyAqCisgKiBTaGlmdHMgdGhlIHBoYXNlIG9mIGEgY2xvY2sg c2lnbmFsIGJ5IHRoZSBzcGVjaWZpZWQgZGVncmVlcy4gUmV0dXJucyAwIG9uCisgKiBzdWNjZXNz LCAtRUVSUk9SIG90aGVyd2lzZS4KKyAqCisgKiBUaGlzIGZ1bmN0aW9uIG1ha2VzIG5vIGRpc3Rp Y3Rpb24gYWJvdXQgdGhlIGlucHV0IG9yIHJlZmVyZW5jZSBzaWduYWwgdGhhdAorICogd2UgYWRq dXN0IHRoZSBjbG9jayBzaWduYWwgcGhhc2UgYWdhaW5zdC4gRm9yIGV4YW1wbGUgcGhhc2UgbG9j a2VkLWxvb3AKKyAqIGNsb2NrIHNpZ25hbCBnZW5lcmF0b3JzIHdlIG1heSBzaGlmdCBwaGFzZSB3 aXRoIHJlc3BlY3QgdG8gZmVlZGJhY2sgY2xvY2sKKyAqIHNpZ25hbCBpbnB1dCwgYnV0IGZvciBv dGhlciBjYXNlcyB0aGUgY2xvY2sgcGhhc2UgbWF5IGJlIHNoaWZ0ZWQgd2l0aAorICogcmVzcGVj dCB0byBzb21lIG90aGVyLCB1bnNwZWNpZmllZCBzaWduYWwuCisgKgorICogQWRkaXRpb25hbGx5 IHRoZSBjb25jZXB0IG9mIHBoYXNlIHNoaWZ0IGRvZXMgbm90IHByb3BhZ2F0ZSB0aHJvdWdoIHRo ZSBjbG9jaworICogdHJlZSBoaWVyYXJjaHksIHdoaWNoIHNldHMgaXQgYXBwYXJ0IGZyb20gY2xv Y2sgcmF0ZXMgYW5kIGNsb2NrIGFjY3VyYWN5LiBBCisgKiBwYXJlbnQgY2xvY2sgcGhhc2UgYXR0 cmlidXRlIGRvZXMgbm90IGhhdmUgYW4gaW1wYWN0IG9uIHRoZSBwaGFzZSBhdHRyaWJ1dGUKKyAq IG9mIGEgY2hpbGQgY2xvY2suCisgKi8KK2ludCBjbGtfc2V0X3BoYXNlKHN0cnVjdCBjbGsgKmNs aywgaW50IGRlZ3JlZXMpCit7CisJaW50IHJldCA9IDA7CisKKwlpZiAoIWNsaykKKwkJZ290byBv dXQ7CisKKwkvKiBzYW5pdHkgY2hlY2sgZGVncmVlcyAqLworCWRlZ3JlZXMgJT0gMzYwOworCWlm IChkZWdyZWVzIDwgMCkKKwkJZGVncmVlcyArPSAzNjA7CisKKwljbGtfcHJlcGFyZV9sb2NrKCk7 CisKKwlpZiAoIWNsay0+b3BzLT5zZXRfcGhhc2UpCisJCWdvdG8gb3V0X3VubG9jazsKKworCXJl dCA9IGNsay0+b3BzLT5zZXRfcGhhc2UoY2xrLT5odywgZGVncmVlcyk7CisKKwlpZiAoIXJldCkK KwkJY2xrLT5waGFzZSA9IGRlZ3JlZXM7CisKK291dF91bmxvY2s6CisJY2xrX3ByZXBhcmVfdW5s b2NrKCk7CisKK291dDoKKwlyZXR1cm4gcmV0OworfQorCisvKioKKyAqIGNsa19nZXRfcGhhc2Ug LSByZXR1cm4gdGhlIHBoYXNlIHNoaWZ0IG9mIGEgY2xvY2sgc2lnbmFsCisgKiBAY2xrOiBjbG9j ayBzaWduYWwgc291cmNlCisgKgorICogUmV0dXJucyB0aGUgcGhhc2Ugc2hpZnQgb2YgYSBjbG9j ayBub2RlIGluIGRlZ3JlZXMsIG90aGVyd2lzZSByZXR1cm5zCisgKiAtRUVSUk9SLgorICovCitp bnQgY2xrX2dldF9waGFzZShzdHJ1Y3QgY2xrICpjbGspCit7CisJaW50IHJldCA9IDA7CisKKwlp ZiAoIWNsaykKKwkJZ290byBvdXQ7CisKKwljbGtfcHJlcGFyZV9sb2NrKCk7CisJcmV0ID0gY2xr LT5waGFzZTsKKwljbGtfcHJlcGFyZV91bmxvY2soKTsKKworb3V0OgorCXJldHVybiByZXQ7Cit9 CisKKy8qKgogICogX19jbGtfaW5pdCAtIGluaXRpYWxpemUgdGhlIGRhdGEgc3RydWN0dXJlcyBp biBhIHN0cnVjdCBjbGsKICAqIEBkZXY6CWRldmljZSBpbml0aWFsaXppbmcgdGhpcyBjbGssIHBs YWNlaG9sZGVyIGZvciBub3cKICAqIEBjbGs6CWNsayBiZWluZyBpbml0aWFsaXplZApkaWZmIC0t Z2l0IGEvaW5jbHVkZS9saW51eC9jbGstcHJpdmF0ZS5oIGIvaW5jbHVkZS9saW51eC9jbGstcHJp dmF0ZS5oCmluZGV4IGVmYmY3MGIuLjg0NWJlMzAgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgv Y2xrLXByaXZhdGUuaAorKysgYi9pbmNsdWRlL2xpbnV4L2Nsay1wcml2YXRlLmgKQEAgLTQ2LDYg KzQ2LDcgQEAgc3RydWN0IGNsayB7CiAJdW5zaWduZWQgaW50CQllbmFibGVfY291bnQ7CiAJdW5z aWduZWQgaW50CQlwcmVwYXJlX2NvdW50OwogCXVuc2lnbmVkIGxvbmcJCWFjY3VyYWN5OworCWlu dAkJCXBoYXNlOwogCXN0cnVjdCBobGlzdF9oZWFkCWNoaWxkcmVuOwogCXN0cnVjdCBobGlzdF9u b2RlCWNoaWxkX25vZGU7CiAJdW5zaWduZWQgaW50CQlub3RpZmllcl9jb3VudDsKZGlmZiAtLWdp dCBhL2luY2x1ZGUvbGludXgvY2xrLXByb3ZpZGVyLmggYi9pbmNsdWRlL2xpbnV4L2Nsay1wcm92 aWRlci5oCmluZGV4IDkzOTUzM2QuLmNjNDlmYjggMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgv Y2xrLXByb3ZpZGVyLmgKKysrIGIvaW5jbHVkZS9saW51eC9jbGstcHJvdmlkZXIuaApAQCAtMTI3 LDYgKzEyNywxMCBAQCBzdHJ1Y3QgY2xrX2h3OwogICoJCXNlcGFyYXRlbHkgdmlhIGNhbGxzIHRv IC5zZXRfcGFyZW50IGFuZCAuc2V0X3JhdGUuCiAgKgkJUmV0dXJucyAwIG9uIHN1Y2Nlc3MsIC1F RVJST1Igb3RoZXJ3aXNlLgogICoKKyAqIEBzZXRfcGhhc2U6CVNoaWZ0IHRoZSBwaGFzZSB0aGlz IGNsb2NrIHNpZ25hbCBpbiBkZWdyZWVzIHNwZWNpZmllZAorICoJCWJ5IHRoZSBzZWNvbmQgYXJn dW1lbnQuIFZhbGlkIHZhbHVlcyBmb3IgZGVncmVlcyBhcmUKKyAqCQkwLTM1OS4gUmV0dXJuIDAg b24gc3VjY2Vzcywgb3RoZXJ3aXNlIC1FRVJST1IuCisgKgogICoKICAqIFRoZSBjbGtfZW5hYmxl L2Nsa19kaXNhYmxlIGFuZCBjbGtfcHJlcGFyZS9jbGtfdW5wcmVwYXJlIHBhaXJzIGFsbG93CiAg KiBpbXBsZW1lbnRhdGlvbnMgdG8gc3BsaXQgYW55IHdvcmsgYmV0d2VlbiBhdG9taWMgKGVuYWJs ZSkgYW5kIHNsZWVwYWJsZQpAQCAtMTY0LDYgKzE2OCw3IEBAIHN0cnVjdCBjbGtfb3BzIHsKIAkJ CQkgICAgdW5zaWduZWQgbG9uZyBwYXJlbnRfcmF0ZSwgdTggaW5kZXgpOwogCXVuc2lnbmVkIGxv bmcJKCpyZWNhbGNfYWNjdXJhY3kpKHN0cnVjdCBjbGtfaHcgKmh3LAogCQkJCQkgICB1bnNpZ25l ZCBsb25nIHBhcmVudF9hY2N1cmFjeSk7CisJaW50CQkoKnNldF9waGFzZSkoc3RydWN0IGNsa19o dyAqaHcsIGludCBkZWdyZWVzKTsKIAl2b2lkCQkoKmluaXQpKHN0cnVjdCBjbGtfaHcgKmh3KTsK IH07CiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvY2xrLmggYi9pbmNsdWRlL2xpbnV4L2Ns ay5oCmluZGV4IDBkZDkxMTQuLmFlMmIyZjQgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvY2xr LmgKKysrIGIvaW5jbHVkZS9saW51eC9jbGsuaApAQCAtOTIsNiArOTIsMjUgQEAgaW50IGNsa19u b3RpZmllcl91bnJlZ2lzdGVyKHN0cnVjdCBjbGsgKmNsaywgc3RydWN0IG5vdGlmaWVyX2Jsb2Nr ICpuYik7CiAgKi8KIGxvbmcgY2xrX2dldF9hY2N1cmFjeShzdHJ1Y3QgY2xrICpjbGspOwogCisv KioKKyAqIGNsa19zZXRfcGhhc2UgLSBhZGp1c3QgdGhlIHBoYXNlIHNoaWZ0IG9mIGEgY2xvY2sg c2lnbmFsCisgKiBAY2xrOiBjbG9jayBzaWduYWwgc291cmNlCisgKiBAZGVncmVlczogbnVtYmVy IG9mIGRlZ3JlZXMgdGhlIHNpZ25hbCBpcyBzaGlmdGVkCisgKgorICogU2hpZnRzIHRoZSBwaGFz ZSBvZiBhIGNsb2NrIHNpZ25hbCBieSB0aGUgc3BlY2lmaWVkIGRlZ3JlZXMuIFJldHVybnMgMCBv bgorICogc3VjY2VzcywgLUVFUlJPUiBvdGhlcndpc2UuCisgKi8KK2ludCBjbGtfc2V0X3BoYXNl KHN0cnVjdCBjbGsgKmNsaywgaW50IGRlZ3JlZXMpOworCisvKioKKyAqIGNsa19nZXRfcGhhc2Ug LSByZXR1cm4gdGhlIHBoYXNlIHNoaWZ0IG9mIGEgY2xvY2sgc2lnbmFsCisgKiBAY2xrOiBjbG9j ayBzaWduYWwgc291cmNlCisgKgorICogUmV0dXJucyB0aGUgcGhhc2Ugc2hpZnQgb2YgYSBjbG9j ayBub2RlIGluIGRlZ3JlZXMsIG90aGVyd2lzZSByZXR1cm5zCisgKiAtRUVSUk9SLgorICovCitp bnQgY2xrX2dldF9waGFzZShzdHJ1Y3QgY2xrICpjbGspOworCiAjZWxzZQogCiBzdGF0aWMgaW5s aW5lIGxvbmcgY2xrX2dldF9hY2N1cmFjeShzdHJ1Y3QgY2xrICpjbGspCkBAIC05OSw2ICsxMTgs MTYgQEAgc3RhdGljIGlubGluZSBsb25nIGNsa19nZXRfYWNjdXJhY3koc3RydWN0IGNsayAqY2xr KQogCXJldHVybiAtRU5PVFNVUFA7CiB9CiAKK3N0YXRpYyBpbmxpbmUgbG9uZyBjbGtfc2V0X3Bo YXNlKHN0cnVjdCBjbGsgKmNsaywgaW50IHBoYXNlKQoreworCXJldHVybiAtRU5PVFNVUFA7Cit9 CisKK3N0YXRpYyBpbmxpbmUgbG9uZyBjbGtfZ2V0X3BoYXNlKHN0cnVjdCBjbGsgKmNsaykKK3sK KwlyZXR1cm4gLUVOT1RTVVBQOworfQorCiAjZW5kaWYKIAogLyoqCi0tIAoxLjguMy4yCgoKX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGludXgtYXJtLWtl cm5lbCBtYWlsaW5nIGxpc3QKbGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZyYWRlYWQub3JnCmh0 dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtYXJtLWtlcm5l bAo=