From mboxrd@z Thu Jan 1 00:00:00 1970 From: Daniel Lezcano Subject: Re: [PATCH v2 11/12] cpuidle: mvebu: Add initial CPU idle support for Armada 370/XP SoC Date: Fri, 13 Sep 2013 17:36:50 +0200 Message-ID: <52333112.2050003@linaro.org> References: <1379066801-16276-1-git-send-email-gregory.clement@free-electrons.com> <1379066801-16276-12-git-send-email-gregory.clement@free-electrons.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1379066801-16276-12-git-send-email-gregory.clement@free-electrons.com> 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: Gregory CLEMENT Cc: Lior Amsalem , Andrew Lunn , Ike Pan , Atsushi Yamagata , Nadav Haklai , David Marlin , Yehuda Yitschak , Tawfik Bayouk , Dan Frazier , Eran Ben-Avi , Ezequiel Garcia , Leif Lindholm , Sebastian Hesselbarth , Tomonori Kimura , Jason Cooper , Nobuhiro Iwamatsu , linux-pm@vger.kernel.org, Jon Masters , "Rafael J. Wysocki" , Hironobu Shibata , linux-arm-kernel@lists.infradead.org, Thomas Petazzoni , Chris Van Hoof List-Id: linux-pm@vger.kernel.org T24gMDkvMTMvMjAxMyAxMjowNiBQTSwgR3JlZ29yeSBDTEVNRU5UIHdyb3RlOgo+IEFkZCB0aGUg d2ZpLCBjcHUgaWRsZSBhbmQgY3B1IGRlZXAgaWRsZSBwb3dlciBzdGF0ZXMgc3VwcG9ydCBmb3Ig dGhlCj4gQXJtYWRhIFhQIFNvQ3MuCj4gCj4gQWxsIHRoZSBsYXRlbmNpZXMgYW5kIHRoZSBwb3dl ciBjb25zdW1wdGlvbiB2YWx1ZXMgdXNlZCBhdCB0aGUKPiAiYXJtYWRhXzM3MF94cF9pZGxlX2Ry aXZlciIgc3RydWN0dXJlIGFyZSBwcmVsaW1pbmFyeSBhbmQgd2lsbCBiZQo+IG1vZGlmaWVkIGlu IHRoZSBmdXR1cmUgYWZ0ZXIgcnVubmluZyBzb21lIG1lYXN1cmVtZW50cyBhbmQgYW5hbHlzaXMu Cj4gCj4gQmFzZWQgb24gdGhlIHdvcmsgb2YgTmFkYXYgSGFrbGFpLgo+IAo+IFNpZ25lZC1vZmYt Ynk6IE5hZGF2IEhha2xhaSA8bmFkYXZoQG1hcnZlbGwuY29tPgo+IFNpZ25lZC1vZmYtYnk6IEdy ZWdvcnkgQ0xFTUVOVCA8Z3JlZ29yeS5jbGVtZW50QGZyZWUtZWxlY3Ryb25zLmNvbT4KPiAtLS0K PiAgZHJpdmVycy9jcHVpZGxlL0tjb25maWcuYXJtICAgICAgICAgICAgIHwgICA1ICsrCj4gIGRy aXZlcnMvY3B1aWRsZS9NYWtlZmlsZSAgICAgICAgICAgICAgICB8ICAgMSArCj4gIGRyaXZlcnMv Y3B1aWRsZS9jcHVpZGxlLWFybWFkYS0zNzAteHAuYyB8IDEwMyArKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKwo+ICBkcml2ZXJzL2NwdWlkbGUvc3VzcGVuZC1hcm1hZGEtMzcwLXhwLlMg fCAgOTEgKysrKysrKysrKysrKysrKysrKysrKysrKysrKwoKU29tZWhvdywgeW91IHdpbGwgaGF2 ZSB0byBtb3ZlICJzdXNwZW5kLWFybWFkYS0zNzAteHAuUyIgaW50byBhcmNoL2FybS4KCj4gIDQg ZmlsZXMgY2hhbmdlZCwgMjAwIGluc2VydGlvbnMoKykKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRy aXZlcnMvY3B1aWRsZS9jcHVpZGxlLWFybWFkYS0zNzAteHAuYwo+ICBjcmVhdGUgbW9kZSAxMDA2 NDQgZHJpdmVycy9jcHVpZGxlL3N1c3BlbmQtYXJtYWRhLTM3MC14cC5TCj4gCj4gZGlmZiAtLWdp dCBhL2RyaXZlcnMvY3B1aWRsZS9LY29uZmlnLmFybSBiL2RyaXZlcnMvY3B1aWRsZS9LY29uZmln LmFybQo+IGluZGV4IDhlMzY2MDMuLjA3MWQ5NjAgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9jcHVp ZGxlL0tjb25maWcuYXJtCj4gKysrIGIvZHJpdmVycy9jcHVpZGxlL0tjb25maWcuYXJtCj4gQEAg LTEsNiArMSwxMSBAQAo+ICAjCj4gICMgQVJNIENQVSBJZGxlIGRyaXZlcnMKPiAgIwo+ICtjb25m aWcgQVJNX0FSTUFEQV8zNzBfWFBfQ1BVSURMRQo+ICsJYm9vbCAiQ1BVIElkbGUgRHJpdmVyIGZv ciBBcm1hZGEgMzcwL1hQIGZhbWlseSBwcm9jZXNzb3JzIgo+ICsJZGVwZW5kcyBvbiBBUkNIX01W RUJVCj4gKwloZWxwCj4gKwkgIFNlbGVjdCB0aGlzIHRvIGVuYWJsZSBjcHVpZGxlIG9uIEFybWFk YSAzNzAvWFAgcHJvY2Vzc29ycy4KPiAgCj4gIGNvbmZpZyBBUk1fSElHSEJBTktfQ1BVSURMRQo+ ICAJYm9vbCAiQ1BVIElkbGUgRHJpdmVyIGZvciBDYWx4ZWRhIHByb2Nlc3NvcnMiCj4gZGlmZiAt LWdpdCBhL2RyaXZlcnMvY3B1aWRsZS9NYWtlZmlsZSBiL2RyaXZlcnMvY3B1aWRsZS9NYWtlZmls ZQo+IGluZGV4IGNlYTVlZjUuLjkwZmM0YTYgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9jcHVpZGxl L01ha2VmaWxlCj4gKysrIGIvZHJpdmVycy9jcHVpZGxlL01ha2VmaWxlCj4gQEAgLTcsNiArNyw3 IEBAIG9iai0kKENPTkZJR19BUkNIX05FRURTX0NQVV9JRExFX0NPVVBMRUQpICs9IGNvdXBsZWQu bwo+ICAKPiAgIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMj IyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwo+ICAjIEFSTSBTb0MgZHJpdmVycwo+ ICtvYmotJChDT05GSUdfQVJNX0FSTUFEQV8zNzBfWFBfQ1BVSURMRSkgKz0gY3B1aWRsZS1hcm1h ZGEtMzcwLXhwLm8gc3VzcGVuZC1hcm1hZGEtMzcwLXhwLm8KPiAgb2JqLSQoQ09ORklHX0FSTV9I SUdIQkFOS19DUFVJRExFKQkrPSBjcHVpZGxlLWNhbHhlZGEubwo+ICBvYmotJChDT05GSUdfQVJN X0tJUktXT09EX0NQVUlETEUpCSs9IGNwdWlkbGUta2lya3dvb2Qubwo+ICBvYmotJChDT05GSUdf QVJNX1pZTlFfQ1BVSURMRSkJCSs9IGNwdWlkbGUtenlucS5vCj4gZGlmZiAtLWdpdCBhL2RyaXZl cnMvY3B1aWRsZS9jcHVpZGxlLWFybWFkYS0zNzAteHAuYyBiL2RyaXZlcnMvY3B1aWRsZS9jcHVp ZGxlLWFybWFkYS0zNzAteHAuYwo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAw MC4uN2M3OGQ5Mgo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL2NwdWlkbGUvY3B1aWRs ZS1hcm1hZGEtMzcwLXhwLmMKPiBAQCAtMCwwICsxLDEwMyBAQAo+ICsvKgo+ICsgKiBNYXJ2ZWxs IEFybWFkYSAzNzAgYW5kIEFybWFkYSBYUCBTb0MgY3B1aWRsZSBkcml2ZXIKPiArICoKPiArICog Q29weXJpZ2h0IChDKSAyMDEzIE1hcnZlbGwKPiArICoKPiArICogTmFkYXYgSGFrbGFpIDxuYWRh dmhAbWFydmVsbC5jb20+Cj4gKyAqIEdyZWdvcnkgQ0xFTUVOVCA8Z3JlZ29yeS5jbGVtZW50QGZy ZWUtZWxlY3Ryb25zLmNvbT4KPiArICoKPiArICogVGhpcyBmaWxlIGlzIGxpY2Vuc2VkIHVuZGVy IHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljCj4gKyAqIExpY2Vuc2UgdmVyc2lv biAyLiAgVGhpcyBwcm9ncmFtIGlzIGxpY2Vuc2VkICJhcyBpcyIgd2l0aG91dCBhbnkKPiArICog d2FycmFudHkgb2YgYW55IGtpbmQsIHdoZXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLgo+ICsgKgo+ ICsgKiBNYWludGFpbmVyOiBHcmVnb3J5IENMRU1FTlQgPGdyZWdvcnkuY2xlbWVudEBmcmVlLWVs ZWN0cm9ucy5jb20+Cj4gKyAqLwo+ICsKPiArI2luY2x1ZGUgPGxpbnV4L2NwdWlkbGUuaD4KPiAr I2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgo+ICsjaW5jbHVkZSA8bGludXgvaW8uaD4KPiArI2lu Y2x1ZGUgPGxpbnV4L29mLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9zdXNwZW5kLmg+Cj4gKyNpbmNs dWRlIDxhc20vc3VzcGVuZC5oPgo+ICsjaW5jbHVkZSA8bGludXgvc21wLmg+Cj4gKyNpbmNsdWRl IDxhc20vY3B1aWRsZS5oPgo+ICsjaW5jbHVkZSA8YXNtL3NtcF9wbGF0Lmg+Cj4gKyNpbmNsdWRl IDxsaW51eC9hcm1hZGEtMzcwLXhwLXBtc3UuaD4KPiArCj4gKyNkZWZpbmUgQVJNQURBXzM3MF9Y UF9NQVhfU1RBVEVTCTMKPiArCj4gK2VudW0gbXZfcG1fc3RhdGVzIHsKPiArCVdGSSA9IDAsCj4g KwlNVl9DUFVfSURMRSwKPiArCU1WX0NQVV9ERUVQX0lETEUsCj4gK307Cj4gKwo+ICtleHRlcm4g dm9pZCB2N19mbHVzaF9kY2FjaGVfYWxsKHZvaWQpOwo+ICsKPiArLyogRnVuY3Rpb25zIGRlZmlu ZWQgaW4gc3VzcGVuZC1hcm1hZGEtMzcwLXhwLlMgKi8KPiAraW50IGFybWFkYV8zNzBfeHBfY3B1 X3Jlc3VtZSh1bnNpZ25lZCBsb25nKTsKPiAraW50IGFybWFkYV8zNzBfeHBfY3B1X3N1c3BlbmQo dW5zaWduZWQgbG9uZyk7Cj4gKwo+ICtzdGF0aWMgaW50IGFybWFkYV8zNzBfeHBfZW50ZXJfaWRs ZShzdHJ1Y3QgY3B1aWRsZV9kZXZpY2UgKmRldiwKPiArCQkJCXN0cnVjdCBjcHVpZGxlX2RyaXZl ciAqZHJ2LAo+ICsJCQkJaW50IGluZGV4KQo+ICt7Cj4gKwlib29sIGRlZXBpZGxlID0gZmFsc2U7 Cj4gKwl1bnNpZ25lZCBpbnQgaHdfY3B1ID0gY3B1X2xvZ2ljYWxfbWFwKHNtcF9wcm9jZXNzb3Jf aWQoKSk7Cj4gKwo+ICsJYXJtYWRhXzM3MF94cF9wbXN1X3NldF9zdGFydF9hZGRyKGFybWFkYV8z NzBfeHBfY3B1X3Jlc3VtZSwgaHdfY3B1KTsKPiArCj4gKwlpZiAoaW5kZXggPT0gTVZfQ1BVX0RF RVBfSURMRSkKPiArCQlkZWVwaWRsZSA9IHRydWU7CgpUaGF0IGxvb2tzIGEgYml0IGhhY2tpc2gg bm8gPyA6KQoKQ2FuJ3QgeW91IHVzZSB0aGUgQ1BVSURMRV9EUklWRVJfRkxBR1NfTUFTSyB0byBz dG9yZSB0aGlzIGluZm9ybWF0aW9uID8KCj4gKwljcHVfc3VzcGVuZChkZWVwaWRsZSwgYXJtYWRh XzM3MF94cF9jcHVfc3VzcGVuZCk7Cj4gKwo+ICsJY3B1X2luaXQoKTsKPiArCj4gKwlhcm1hZGFf MzcwX3hwX3Btc3VfaWRsZV9yZXN0b3JlKCk7Cj4gKwo+ICsJcmV0dXJuIGluZGV4Owo+ICt9Cj4g Kwo+ICtzdGF0aWMgc3RydWN0IGNwdWlkbGVfZHJpdmVyIGFybWFkYV8zNzBfeHBfaWRsZV9kcml2 ZXIgPSB7Cj4gKwkubmFtZQkJCT0gImFybWFkYV8zNzBfeHBfaWRsZSIsCj4gKwkuc3RhdGVzWzBd CQk9IEFSTV9DUFVJRExFX1dGSV9TVEFURSwKPiArCS5zdGF0ZXNbMV0JCT0gewo+ICsJCS5lbnRl cgkJCT0gYXJtYWRhXzM3MF94cF9lbnRlcl9pZGxlLAo+ICsJCS5leGl0X2xhdGVuY3kJCT0gMTAs Cj4gKwkJLnBvd2VyX3VzYWdlCQk9IDUwLAo+ICsJCS50YXJnZXRfcmVzaWRlbmN5CT0gMTAwLAo+ ICsJCS5mbGFncwkJCT0gQ1BVSURMRV9GTEFHX1RJTUVfVkFMSUQsCj4gKwkJLm5hbWUJCQk9ICJN ViBDUFUgSURMRSIsCj4gKwkJLmRlc2MJCQk9ICJDUFUgcG93ZXIgZG93biIsCj4gKwl9LAo+ICsJ LnN0YXRlc1syXQkJPSB7Cj4gKwkJLmVudGVyCQkJPSBhcm1hZGFfMzcwX3hwX2VudGVyX2lkbGUs Cj4gKwkJLmV4aXRfbGF0ZW5jeQkJPSAxMDAsCj4gKwkJLnBvd2VyX3VzYWdlCQk9IDUsCj4gKwkJ LnRhcmdldF9yZXNpZGVuY3kJPSAxMDAwLAo+ICsJCS5mbGFncwkJCT0gQ1BVSURMRV9GTEFHX1RJ TUVfVkFMSUQsCj4gKwkJLm5hbWUJCQk9ICJNViBDUFUgREVFUCBJRExFIiwKPiArCQkuZGVzYwkJ CT0gIkNQVSBhbmQgTDIgRmFicmljIHBvd2VyIGRvd24iLAo+ICsJfSwKPiArCS5zdGF0ZV9jb3Vu dCA9IEFSTUFEQV8zNzBfWFBfTUFYX1NUQVRFUywKPiArfTsKCldoYXQgYWJvdXQgdGhlIGxvY2Fs IHRpbWVycyA/IEFyZSB0aGV5IHNodXRkb3duID8KCj4gKwo+ICtzdGF0aWMgaW50IF9faW5pdCBh cm1hZGFfMzcwX3hwX2NwdWlkbGVfaW5pdCh2b2lkKQo+ICt7Cj4gKwlpZiAoIW9mX2ZpbmRfY29t cGF0aWJsZV9ub2RlKE5VTEwsIE5VTEwsICJtYXJ2ZWxsLGFybWFkYS0zNzAteHAtcG1zdSIpKQo+ ICsJCXJldHVybiAtRU5PREVWOwo+ICsKPiArCWlmICghb2ZfZmluZF9jb21wYXRpYmxlX25vZGUo TlVMTCwgTlVMTCwgIm1hcnZlbGwsY29oZXJlbmN5LWZhYnJpYyIpKQo+ICsJCXJldHVybiAtRU5P REVWOwo+ICsKPiArCXByX2luZm8oIkluaXRpYWxpemluZyBBcm1hZGEtWFAgQ1BVIHBvd2VyIG1h bmFnZW1lbnQgIik7Cj4gKwo+ICsJYXJtYWRhXzM3MF94cF9wbXN1X2VuYWJsZV9sMl9wb3dlcmRv d25fb25pZGxlKCk7Cj4gKwo+ICsJcmV0dXJuIGNwdWlkbGVfcmVnaXN0ZXIoJmFybWFkYV8zNzBf eHBfaWRsZV9kcml2ZXIsIE5VTEwpOwo+ICt9Cj4gKwo+ICttb2R1bGVfaW5pdChhcm1hZGFfMzcw X3hwX2NwdWlkbGVfaW5pdCk7CgpJc24ndCBpdCBwb3NzaWJsZSB0byByZXBsYWNlIGl0IGJ5IG1v ZHVsZV9wbGF0Zm9ybV9kcml2ZXIgPyBsaWtlIHV4NTAwCm9yIGtpcmt3b29kID8KClRoYW5rcwog IC0tIERhbmllbAoKPiArTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOwoKWyAuLi4gXQoKCi0tIAogPGh0 dHA6Ly93d3cubGluYXJvLm9yZy8+IExpbmFyby5vcmcg4pSCIE9wZW4gc291cmNlIHNvZnR3YXJl IGZvciBBUk0gU29DcwoKRm9sbG93IExpbmFybzogIDxodHRwOi8vd3d3LmZhY2Vib29rLmNvbS9w YWdlcy9MaW5hcm8+IEZhY2Vib29rIHwKPGh0dHA6Ly90d2l0dGVyLmNvbS8jIS9saW5hcm9vcmc+ IFR3aXR0ZXIgfAo8aHR0cDovL3d3dy5saW5hcm8ub3JnL2xpbmFyby1ibG9nLz4gQmxvZwoKCl9f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4LWFybS1r ZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZwpo dHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFybS1rZXJu ZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 From: daniel.lezcano@linaro.org (Daniel Lezcano) Date: Fri, 13 Sep 2013 17:36:50 +0200 Subject: [PATCH v2 11/12] cpuidle: mvebu: Add initial CPU idle support for Armada 370/XP SoC In-Reply-To: <1379066801-16276-12-git-send-email-gregory.clement@free-electrons.com> References: <1379066801-16276-1-git-send-email-gregory.clement@free-electrons.com> <1379066801-16276-12-git-send-email-gregory.clement@free-electrons.com> Message-ID: <52333112.2050003@linaro.org> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org On 09/13/2013 12:06 PM, Gregory CLEMENT wrote: > Add the wfi, cpu idle and cpu deep idle power states support for the > Armada XP SoCs. > > All the latencies and the power consumption values used at the > "armada_370_xp_idle_driver" structure are preliminary and will be > modified in the future after running some measurements and analysis. > > Based on the work of Nadav Haklai. > > Signed-off-by: Nadav Haklai > Signed-off-by: Gregory CLEMENT > --- > drivers/cpuidle/Kconfig.arm | 5 ++ > drivers/cpuidle/Makefile | 1 + > drivers/cpuidle/cpuidle-armada-370-xp.c | 103 ++++++++++++++++++++++++++++++++ > drivers/cpuidle/suspend-armada-370-xp.S | 91 ++++++++++++++++++++++++++++ Somehow, you will have to move "suspend-armada-370-xp.S" into arch/arm. > 4 files changed, 200 insertions(+) > create mode 100644 drivers/cpuidle/cpuidle-armada-370-xp.c > create mode 100644 drivers/cpuidle/suspend-armada-370-xp.S > > diff --git a/drivers/cpuidle/Kconfig.arm b/drivers/cpuidle/Kconfig.arm > index 8e36603..071d960 100644 > --- a/drivers/cpuidle/Kconfig.arm > +++ b/drivers/cpuidle/Kconfig.arm > @@ -1,6 +1,11 @@ > # > # ARM CPU Idle drivers > # > +config ARM_ARMADA_370_XP_CPUIDLE > + bool "CPU Idle Driver for Armada 370/XP family processors" > + depends on ARCH_MVEBU > + help > + Select this to enable cpuidle on Armada 370/XP processors. > > config ARM_HIGHBANK_CPUIDLE > bool "CPU Idle Driver for Calxeda processors" > diff --git a/drivers/cpuidle/Makefile b/drivers/cpuidle/Makefile > index cea5ef5..90fc4a6 100644 > --- a/drivers/cpuidle/Makefile > +++ b/drivers/cpuidle/Makefile > @@ -7,6 +7,7 @@ obj-$(CONFIG_ARCH_NEEDS_CPU_IDLE_COUPLED) += coupled.o > > ################################################################################## > # ARM SoC drivers > +obj-$(CONFIG_ARM_ARMADA_370_XP_CPUIDLE) += cpuidle-armada-370-xp.o suspend-armada-370-xp.o > obj-$(CONFIG_ARM_HIGHBANK_CPUIDLE) += cpuidle-calxeda.o > obj-$(CONFIG_ARM_KIRKWOOD_CPUIDLE) += cpuidle-kirkwood.o > obj-$(CONFIG_ARM_ZYNQ_CPUIDLE) += cpuidle-zynq.o > diff --git a/drivers/cpuidle/cpuidle-armada-370-xp.c b/drivers/cpuidle/cpuidle-armada-370-xp.c > new file mode 100644 > index 0000000..7c78d92 > --- /dev/null > +++ b/drivers/cpuidle/cpuidle-armada-370-xp.c > @@ -0,0 +1,103 @@ > +/* > + * Marvell Armada 370 and Armada XP SoC cpuidle driver > + * > + * Copyright (C) 2013 Marvell > + * > + * Nadav Haklai > + * Gregory CLEMENT > + * > + * This file is licensed under the terms of the GNU General Public > + * License version 2. This program is licensed "as is" without any > + * warranty of any kind, whether express or implied. > + * > + * Maintainer: Gregory CLEMENT > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#define ARMADA_370_XP_MAX_STATES 3 > + > +enum mv_pm_states { > + WFI = 0, > + MV_CPU_IDLE, > + MV_CPU_DEEP_IDLE, > +}; > + > +extern void v7_flush_dcache_all(void); > + > +/* Functions defined in suspend-armada-370-xp.S */ > +int armada_370_xp_cpu_resume(unsigned long); > +int armada_370_xp_cpu_suspend(unsigned long); > + > +static int armada_370_xp_enter_idle(struct cpuidle_device *dev, > + struct cpuidle_driver *drv, > + int index) > +{ > + bool deepidle = false; > + unsigned int hw_cpu = cpu_logical_map(smp_processor_id()); > + > + armada_370_xp_pmsu_set_start_addr(armada_370_xp_cpu_resume, hw_cpu); > + > + if (index == MV_CPU_DEEP_IDLE) > + deepidle = true; That looks a bit hackish no ? :) Can't you use the CPUIDLE_DRIVER_FLAGS_MASK to store this information ? > + cpu_suspend(deepidle, armada_370_xp_cpu_suspend); > + > + cpu_init(); > + > + armada_370_xp_pmsu_idle_restore(); > + > + return index; > +} > + > +static struct cpuidle_driver armada_370_xp_idle_driver = { > + .name = "armada_370_xp_idle", > + .states[0] = ARM_CPUIDLE_WFI_STATE, > + .states[1] = { > + .enter = armada_370_xp_enter_idle, > + .exit_latency = 10, > + .power_usage = 50, > + .target_residency = 100, > + .flags = CPUIDLE_FLAG_TIME_VALID, > + .name = "MV CPU IDLE", > + .desc = "CPU power down", > + }, > + .states[2] = { > + .enter = armada_370_xp_enter_idle, > + .exit_latency = 100, > + .power_usage = 5, > + .target_residency = 1000, > + .flags = CPUIDLE_FLAG_TIME_VALID, > + .name = "MV CPU DEEP IDLE", > + .desc = "CPU and L2 Fabric power down", > + }, > + .state_count = ARMADA_370_XP_MAX_STATES, > +}; What about the local timers ? Are they shutdown ? > + > +static int __init armada_370_xp_cpuidle_init(void) > +{ > + if (!of_find_compatible_node(NULL, NULL, "marvell,armada-370-xp-pmsu")) > + return -ENODEV; > + > + if (!of_find_compatible_node(NULL, NULL, "marvell,coherency-fabric")) > + return -ENODEV; > + > + pr_info("Initializing Armada-XP CPU power management "); > + > + armada_370_xp_pmsu_enable_l2_powerdown_onidle(); > + > + return cpuidle_register(&armada_370_xp_idle_driver, NULL); > +} > + > +module_init(armada_370_xp_cpuidle_init); Isn't it possible to replace it by module_platform_driver ? like ux500 or kirkwood ? Thanks -- Daniel > +MODULE_LICENSE("GPL"); [ ... ] -- Linaro.org ? Open source software for ARM SoCs Follow Linaro: Facebook | Twitter | Blog