From mboxrd@z Thu Jan 1 00:00:00 1970 From: Daniel Lezcano Subject: Re: [PATCH] cpuidle: add freescale e500 family porcessors idle support Date: Wed, 02 Apr 2014 11:36:17 +0200 Message-ID: <533BDA11.9080905@linaro.org> References: <1396341234-40515-1-git-send-email-dongsheng.wang@freescale.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8"; Format="flowed" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1396341234-40515-1-git-send-email-dongsheng.wang@freescale.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: linuxppc-dev-bounces+glppe-linuxppc-embedded-2=m.gmane.org@lists.ozlabs.org Sender: "Linuxppc-dev" To: Dongsheng Wang , scottwood@freescale.com Cc: chenhui.zhao@freescale.com, linux-pm@vger.kernel.org, rjw@sisk.pl, jason.jin@freescale.com, linuxppc-dev@lists.ozlabs.org List-Id: linux-pm@vger.kernel.org T24gMDQvMDEvMjAxNCAxMDozMyBBTSwgRG9uZ3NoZW5nIFdhbmcgd3JvdGU6Cj4gRnJvbTogV2Fu ZyBEb25nc2hlbmcgPGRvbmdzaGVuZy53YW5nQGZyZWVzY2FsZS5jb20+Cj4KPiBBZGQgY3B1aWRs ZSBzdXBwb3J0IGZvciBlNTAwIGZhbWlseSwgdXNpbmcgY3B1aWRsZSBmcmFtZXdvcmsgdG8KPiBt YW5hZ2UgdmFyaW91cyBsb3cgcG93ZXIgbW9kZXMuIFRoZSBuZXcgaW1wbGVtZW50YXRpb24gd2ls bCByZW1haW4KPiBjb21wYXRpYmxlIHdpdGggb3JpZ2luYWwgaWRsZSBtZXRob2QuCj4KPiBJIGhh dmUgZG9uZSB0ZXN0IGFib3V0IHBvd2VyIGNvbnN1bXB0aW9uIGFuZCBsYXRlbmN5LiBDcHVpZGxl IGZyYW1ld29yawo+IHdpbGwgbWFrZSBDUFUgcmVzcG9uc2UgdGltZSBmYXN0ZXIgdGhhbiBvcmln aW5hbCBtZXRob2QsIGJ1dCBwb3dlcgo+IGNvbnN1bXB0aW9uIGlzIGhpZ2hlciB0aGFuIG9yaWdp bmFsIG1ldGhvZC4KPgo+IFBvd2VyIGNvbnN1bXB0aW9uOgo+IFRoZSBvcmlnaW5hbCBtZXRob2Qs IHBvd2VyIGNvbnN1bXB0aW9uIGlzIDEwLjUxMjAyIChXKS4KPiBUaGUgY3B1aWRsZSBmcmFtZXdv cmssIHBvd2VyIGNvbnN1bXB0aW9uIGlzIDEwLjUzMTEgKFcpLgo+Cj4gTGF0ZW5jeToKPiBUaGUg b3JpZ2luYWwgbWV0aG9kLCBhdmcgbGF0ZW5jeSBpcyA2NzgyICh1cykuCj4gVGhlIGNwdWlkbGUg ZnJhbWV3b3JrLCBhdmcgbGF0ZW5jeSBpcyA2NDgyICh1cykuCj4KPiBJbml0aWFsbHksIHRoaXMg c3VwcG9ydHMgUFcxMCwgUFcyMCBhbmQgc3Vic2VxdWVudCBwYXRjaGVzIHdpbGwgc3VwcG9ydAo+ IERPWkUvTkFQIGFuZCBQSDEwLCBQSDIwLgo+Cj4gU2lnbmVkLW9mZi1ieTogV2FuZyBEb25nc2hl bmcgPGRvbmdzaGVuZy53YW5nQGZyZWVzY2FsZS5jb20+Cj4KPiBkaWZmIC0tZ2l0IGEvYXJjaC9w b3dlcnBjL2luY2x1ZGUvYXNtL21hY2hkZXAuaCBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9t YWNoZGVwLmgKPiBpbmRleCA1YjZjMDNmLi45MzAxNDIwIDEwMDY0NAo+IC0tLSBhL2FyY2gvcG93 ZXJwYy9pbmNsdWRlL2FzbS9tYWNoZGVwLmgKPiArKysgYi9hcmNoL3Bvd2VycGMvaW5jbHVkZS9h c20vbWFjaGRlcC5oCj4gQEAgLTI5NCw2ICsyOTQsMTUgQEAgZXh0ZXJuIHZvaWQgcG93ZXI3X2lk bGUodm9pZCk7Cj4gICBleHRlcm4gdm9pZCBwcGM2eHhfaWRsZSh2b2lkKTsKPiAgIGV4dGVybiB2 b2lkIGJvb2szZV9pZGxlKHZvaWQpOwo+Cj4gK3N0YXRpYyBpbmxpbmUgdm9pZCBjcHVpZGxlX3dh aXQodm9pZCkKPiArewo+ICsjaWZkZWYgQ09ORklHX1BQQzY0Cj4gKwlib29rM2VfaWRsZSgpOwo+ ICsjZWxzZQo+ICsJZTUwMF9pZGxlKCk7Cj4gKyNlbmRpZgo+ICt9Cj4gKwo+ICAgLyoKPiAgICAq IHBwY19tZCBjb250YWlucyBhIGNvcHkgb2YgdGhlIG1hY2hpbmUgZGVzY3JpcHRpb24gc3RydWN0 dXJlIGZvciB0aGUKPiAgICAqIGN1cnJlbnQgcGxhdGZvcm0uIG1hY2hpbmVfaWQgY29udGFpbnMg dGhlIGluaXRpYWwgYWRkcmVzcyB3aGVyZSB0aGUKPiBkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBj L2tlcm5lbC9zeXNmcy5jIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC9zeXNmcy5jCj4gaW5kZXggOTdl MWRjOS4uZWRkMTkzZiAxMDA2NDQKPiAtLS0gYS9hcmNoL3Bvd2VycGMva2VybmVsL3N5c2ZzLmMK PiArKysgYi9hcmNoL3Bvd2VycGMva2VybmVsL3N5c2ZzLmMKPiBAQCAtMTkwLDYgKzE5MCw5IEBA IHN0YXRpYyBzc2l6ZV90IHNob3dfcHcyMF93YWl0X3RpbWUoc3RydWN0IGRldmljZSAqZGV2LAo+ ICAgCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVsbHVcbiIsIHRpbWUgPiAwID8gdGltZSA6IDApOwo+ ICAgfQo+Cj4gKyNpZmRlZiBDT05GSUdfQ1BVX0lETEVfRTUwMAo+ICt1MzIgY3B1aWRsZV9lbnRy eV9iaXQ7Cj4gKyNlbmRpZgo+ICAgc3RhdGljIHZvaWQgc2V0X3B3MjBfd2FpdF9lbnRyeV9iaXQo dm9pZCAqdmFsKQo+ICAgewo+ICAgCXUzMiAqdmFsdWUgPSB2YWw7Cj4gQEAgLTIwNCw3ICsyMDcs MTEgQEAgc3RhdGljIHZvaWQgc2V0X3B3MjBfd2FpdF9lbnRyeV9iaXQodm9pZCAqdmFsKQo+ICAg CS8qIHNldCBjb3VudCAqLwo+ICAgCXB3MjBfaWRsZSB8PSAoKE1BWF9CSVQgLSAqdmFsdWUpIDw8 IFBXUk1HVENSMF9QVzIwX0VOVF9TSElGVCk7Cj4KPiArI2lmZGVmIENPTkZJR19DUFVfSURMRV9F NTAwCj4gKwljcHVpZGxlX2VudHJ5X2JpdCA9ICp2YWx1ZTsKPiArI2Vsc2UKPiAgIAltdHNwcihT UFJOX1BXUk1HVENSMCwgcHcyMF9pZGxlKTsKPiArI2VuZGlmCj4gICB9Cj4KPiAgIHN0YXRpYyBz c2l6ZV90IHN0b3JlX3B3MjBfd2FpdF90aW1lKHN0cnVjdCBkZXZpY2UgKmRldiwKPiBkaWZmIC0t Z2l0IGEvZHJpdmVycy9jcHVpZGxlL0tjb25maWcucG93ZXJwYyBiL2RyaXZlcnMvY3B1aWRsZS9L Y29uZmlnLnBvd2VycGMKPiBpbmRleCA2NmMzYTA5Li4wOTQ5ZGJmIDEwMDY0NAo+IC0tLSBhL2Ry aXZlcnMvY3B1aWRsZS9LY29uZmlnLnBvd2VycGMKPiArKysgYi9kcml2ZXJzL2NwdWlkbGUvS2Nv bmZpZy5wb3dlcnBjCj4gQEAgLTE4LDMgKzE4LDEwIEBAIGNvbmZpZyBQT1dFUk5WX0NQVUlETEUK PiAgIAloZWxwCj4gICAJICBTZWxlY3QgdGhpcyBvcHRpb24gdG8gZW5hYmxlIHByb2Nlc3NvciBp ZGxlIHN0YXRlIG1hbmFnZW1lbnQKPiAgIAkgIHRocm91Z2ggY3B1aWRsZSBzdWJzeXN0ZW0uCj4g Kwo+ICtjb25maWcgQ1BVX0lETEVfRTUwMAo+ICsJYm9vbCAiQ1BVIElkbGUgRHJpdmVyIGZvciBF NTAwIGZhbWlseSBwcm9jZXNzb3JzIgo+ICsJZGVwZW5kcyBvbiBDUFVfSURMRQo+ICsJZGVwZW5k cyBvbiBGU0xfU09DX0JPT0tFCj4gKwloZWxwCj4gKwkgIFNlbGVjdCB0aGlzIHRvIGVuYWJsZSBj cHVpZGxlIG9uIGU1MDAgZmFtaWx5IHByb2Nlc3NvcnMuCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMv Y3B1aWRsZS9NYWtlZmlsZSBiL2RyaXZlcnMvY3B1aWRsZS9NYWtlZmlsZQo+IGluZGV4IGY3MWFl MWIuLjdlNmFkZWEgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9jcHVpZGxlL01ha2VmaWxlCj4gKysr IGIvZHJpdmVycy9jcHVpZGxlL01ha2VmaWxlCj4gQEAgLTE4LDMgKzE4LDQgQEAgb2JqLSQoQ09O RklHX0FSTV9BVDkxX0NQVUlETEUpICAgICAgICAgICs9IGNwdWlkbGUtYXQ5MS5vCj4gICAjIFBP V0VSUEMgZHJpdmVycwo+ICAgb2JqLSQoQ09ORklHX1BTRVJJRVNfQ1BVSURMRSkJCSs9IGNwdWlk bGUtcHNlcmllcy5vCj4gICBvYmotJChDT05GSUdfUE9XRVJOVl9DUFVJRExFKQkJKz0gY3B1aWRs ZS1wb3dlcm52Lm8KPiArb2JqLSQoQ09ORklHX0NQVV9JRExFX0U1MDApCQkrPSBjcHVpZGxlLWU1 MDAubwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2NwdWlkbGUvY3B1aWRsZS1lNTAwLmMgYi9kcml2 ZXJzL2NwdWlkbGUvY3B1aWRsZS1lNTAwLmMKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4 IDAwMDAwMDAuLmRkYzBkZWYKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvZHJpdmVycy9jcHVpZGxl L2NwdWlkbGUtZTUwMC5jCj4gQEAgLTAsMCArMSwxOTQgQEAKPiArLyoKPiArICogQ1BVIElkbGUg ZHJpdmVyIGZvciBGcmVlc2NhbGUgUG93ZXJQQyBlNTAwIGZhbWlseSBwcm9jZXNzb3JzLgo+ICsg Kgo+ICsgKiBDb3B5cmlnaHQgMjAxNCBGcmVlc2NhbGUgU2VtaWNvbmR1Y3RvciwgSW5jLgo+ICsg Kgo+ICsgKiBBdXRob3I6IERvbmdzaGVuZyBXYW5nIDxkb25nc2hlbmcud2FuZ0BmcmVlc2NhbGUu Y29tPgo+ICsgKgo+ICsgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiBy ZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQo+ICsgKiBpdCB1bmRlciB0aGUgdGVybXMgb2Yg dGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcwo+ICsgKiBwdWJsaXNo ZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KPiArICovCj4gKwo+ICsjaW5jbHVk ZSA8bGludXgvY3B1Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9jcHVpZGxlLmg+Cj4gKyNpbmNsdWRl IDxsaW51eC9pbml0Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KPiArI2luY2x1ZGUg PGxpbnV4L25vdGlmaWVyLmg+Cj4gKwo+ICsjaW5jbHVkZSA8YXNtL2NwdXRhYmxlLmg+Cj4gKyNp bmNsdWRlIDxhc20vbWFjaGRlcC5oPgo+ICsjaW5jbHVkZSA8YXNtL21wYzg1eHguaD4KPiArCj4g K3N0YXRpYyB1bnNpZ25lZCBpbnQgbWF4X2lkbGVfc3RhdGU7Cj4gK3N0YXRpYyBzdHJ1Y3QgY3B1 aWRsZV9zdGF0ZSAqY3B1aWRsZV9zdGF0ZV90YWJsZTsKPiArCj4gK3N0cnVjdCBjcHVpZGxlX2Ry aXZlciBlNTAwX2lkbGVfZHJpdmVyID0gewo+ICsJLm5hbWUgPSAiZTUwMF9pZGxlIiwKPiArCS5v d25lciA9IFRISVNfTU9EVUxFLAo+ICt9Owo+ICsKPiArc3RhdGljIHZvaWQgZTUwMF9jcHVpZGxl KHZvaWQpCj4gK3sKPiArCWlmIChjcHVpZGxlX2lkbGVfY2FsbCgpKQo+ICsJCWNwdWlkbGVfd2Fp dCgpOwo+ICt9CgpOb3BlLCB0aGF0IGhhcyBiZWVuIGNoYW5nZWQuIE5vIG1vcmUgY2FsbCB0byBj cHVpZGxlX2lkbGVfY2FsbCBpbiBhIGRyaXZlci4KCj4gKwo+ICtzdGF0aWMgaW50IHB3MTBfZW50 ZXIoc3RydWN0IGNwdWlkbGVfZGV2aWNlICpkZXYsCj4gKwkJCXN0cnVjdCBjcHVpZGxlX2RyaXZl ciAqZHJ2LCBpbnQgaW5kZXgpCj4gK3sKPiArCWNwdWlkbGVfd2FpdCgpOwo+ICsJcmV0dXJuIGlu ZGV4Owo+ICt9Cj4gKwo+ICsjZGVmaW5lIE1BWF9CSVQJNjMKPiArI2RlZmluZSBNSU5fQklUCTEK PiArZXh0ZXJuIHUzMiBjcHVpZGxlX2VudHJ5X2JpdDsKPiArc3RhdGljIGludCBwdzIwX2VudGVy KHN0cnVjdCBjcHVpZGxlX2RldmljZSAqZGV2LAo+ICsJCXN0cnVjdCBjcHVpZGxlX2RyaXZlciAq ZHJ2LCBpbnQgaW5kZXgpCj4gK3sKPiArCXUzMiBwdzIwX2lkbGU7Cj4gKwl1MzIgZW50cnlfYml0 Owo+ICsJcHcyMF9pZGxlID0gbWZzcHIoU1BSTl9QV1JNR1RDUjApOwo+ICsJaWYgKChwdzIwX2lk bGUgJiBQV1JNR1RDUjBfUFcyMF9FTlQpICE9IFBXUk1HVENSMF9QVzIwX0VOVCkgewo+ICsJCXB3 MjBfaWRsZSAmPSB+UFdSTUdUQ1IwX1BXMjBfRU5UOwo+ICsJCWVudHJ5X2JpdCA9IE1BWF9CSVQg LSBjcHVpZGxlX2VudHJ5X2JpdDsKPiArCQlwdzIwX2lkbGUgfD0gKGVudHJ5X2JpdCA8PCBQV1JN R1RDUjBfUFcyMF9FTlRfU0hJRlQpOwo+ICsJCW10c3ByKFNQUk5fUFdSTUdUQ1IwLCBwdzIwX2lk bGUpOwo+ICsJfQo+ICsKPiArCWNwdWlkbGVfd2FpdCgpOwo+ICsKPiArCXB3MjBfaWRsZSAmPSB+ UFdSTUdUQ1IwX1BXMjBfRU5UOwo+ICsJcHcyMF9pZGxlIHw9IChNSU5fQklUIDw8IFBXUk1HVENS MF9QVzIwX0VOVF9TSElGVCk7Cj4gKwltdHNwcihTUFJOX1BXUk1HVENSMCwgcHcyMF9pZGxlKTsK PiArCj4gKwlyZXR1cm4gaW5kZXg7Cj4gK30KCklzIGl0IHBvc3NpYmxlIHRvIGdpdmUgc29tZSBj b21tZW50cyBhbmQgZW5jYXBzdWxhdGUgdGhlIGNvZGUgd2l0aCAKZXhwbGljaXQgZnVuY3Rpb24g bmFtZXMgdG8gYmUgaW1wbGVtZW50ZWQgaW4gYW4gYXJjaCBzcGVjaWZpYyBkaXJlY3RvcnkgCmZp bGUgKGVnLiBwbS5jKSBhbmQgZXhwb3J0IHRoZXNlIGZ1bmN0aW9ucyBpbiBhIGxpbnV4LyBoZWFk ZXIgPyBXZSB0cnkgCnRvIHByZXZlbnQgdG8gaW5jbHVkZSBhc20gaWYgcG9zc2libGUuCgo+ICsK PiArc3RhdGljIHN0cnVjdCBjcHVpZGxlX3N0YXRlIHB3X2lkbGVfc3RhdGVzW10gPSB7Cj4gKwl7 Cj4gKwkJLm5hbWUgPSAicHcxMCIsCj4gKwkJLmRlc2MgPSAicHcxMCIsCj4gKwkJLmZsYWdzID0g Q1BVSURMRV9GTEFHX1RJTUVfVkFMSUQsCj4gKwkJLmV4aXRfbGF0ZW5jeSA9IDAsCj4gKwkJLnRh cmdldF9yZXNpZGVuY3kgPSAwLAo+ICsJCS5lbnRlciA9ICZwdzEwX2VudGVyCj4gKwl9LAo+ICsK PiArCXsKPiArCQkubmFtZSA9ICJwdzIwIiwKPiArCQkuZGVzYyA9ICJwdzIwLWNvcmUtaWRsZSIs Cj4gKwkJLmZsYWdzID0gQ1BVSURMRV9GTEFHX1RJTUVfVkFMSUQsCj4gKwkJLmV4aXRfbGF0ZW5j eSA9IDEsCj4gKwkJLnRhcmdldF9yZXNpZGVuY3kgPSA1MCwKPiArCQkuZW50ZXIgPSAmcHcyMF9l bnRlcgo+ICsJfSwKPiArfTsKCk5vIG5lZWQgdG8gZGVmaW5lIHRoaXMgaW50ZXJtZWRpYXRlIHN0 cnVjdHVyZSBoZXJlLCB5b3UgY2FuIGRpcmVjdGx5IAppbml0aWFsaXplIHRoZSBjcHVpZGxlX2Ry aXZlcjoKCgpzdHJ1Y3QgY3B1aWRsZV9kcml2ZXIgZTUwMF9pZGxlX2RyaXZlciA9IHsKCS5uYW1l ID0gImU1MDBfaWRsZSIsCgkub3duZXIgPSBUSElTX01PRFVMRSwKCS5zdGF0ZXMgPSB7CgkJLm5h bWUgPSAicHcxMCIsCgkJLmRlc2MgPSAicHcxMCIsCgkJLmZsYWdzID0gQ1BVSURMRV9GTEFHX1RJ TUVfVkFMSUQsCgkJLnRhcmdldF9yZXNpZGVuY3kgPSAwLAoJCS5lbnRlciA9ICZwdzEwX2VudGVy LAoJfSwKCgkuLi4uCgoJLnN0YXRlX2NvdW50ID0gMiwJCn07CgpUaGVuIGluIHRoZSBpbml0IGZ1 bmN0aW9uIHlvdSBpbml0aWFsaXplIHRoZSBzdGF0ZV9jb3VudCBjb25zZXF1ZW50bHk6CgppZiAo UFZSX1ZFUihjdXJfY3B1X3NwZWMtPnB2cl92YWx1ZSkgIT0gUFZSX1ZFUl9FNjUwMCkKCWRydi0+ c3RhdGVfY291bnQgPSAxOwoKVGhlbiB5b3UgY2FuIGtpbGw6CgptYXhfaWRsZV9zdGF0ZSwgY3B1 aWRsZV9zdGF0ZV90YWJsZSwgZTUwMF9pZGxlX3N0YXRlX3Byb2JlIGFuZCAKcHdfaWRsZV9zdGF0 ZXMuCgo+ICsKPiArc3RhdGljIGludCBjcHVfaG90cGx1Z19ub3RpZnkoc3RydWN0IG5vdGlmaWVy X2Jsb2NrICpuLAo+ICsJCQl1bnNpZ25lZCBsb25nIGFjdGlvbiwgdm9pZCAqaGNwdSkKPiArewo+ ICsJdW5zaWduZWQgbG9uZyBob3RjcHUgPSAodW5zaWduZWQgbG9uZyloY3B1Owo+ICsJc3RydWN0 IGNwdWlkbGVfZGV2aWNlICpkZXYgPQo+ICsJCQlwZXJfY3B1X3B0cihjcHVpZGxlX2RldmljZXMs IGhvdGNwdSk7Cj4gKwo+ICsJaWYgKGRldiAmJiBjcHVpZGxlX2dldF9kcml2ZXIoKSkgewo+ICsJ CXN3aXRjaCAoYWN0aW9uKSB7Cj4gKwkJY2FzZSBDUFVfT05MSU5FOgo+ICsJCWNhc2UgQ1BVX09O TElORV9GUk9aRU46Cj4gKwkJCWNwdWlkbGVfcGF1c2VfYW5kX2xvY2soKTsKPiArCQkJY3B1aWRs ZV9lbmFibGVfZGV2aWNlKGRldik7Cj4gKwkJCWNwdWlkbGVfcmVzdW1lX2FuZF91bmxvY2soKTsK PiArCQkJYnJlYWs7Cj4gKwo+ICsJCWNhc2UgQ1BVX0RFQUQ6Cj4gKwkJY2FzZSBDUFVfREVBRF9G Uk9aRU46Cj4gKwkJCWNwdWlkbGVfcGF1c2VfYW5kX2xvY2soKTsKPiArCQkJY3B1aWRsZV9kaXNh YmxlX2RldmljZShkZXYpOwo+ICsJCQljcHVpZGxlX3Jlc3VtZV9hbmRfdW5sb2NrKCk7Cj4gKwkJ CWJyZWFrOwo+ICsKPiArCQlkZWZhdWx0Ogo+ICsJCQlyZXR1cm4gTk9USUZZX0RPTkU7Cj4gKwkJ fQo+ICsJfQo+ICsKPiArCXJldHVybiBOT1RJRllfT0s7Cj4gK30KPiArCj4gK3N0YXRpYyBzdHJ1 Y3Qgbm90aWZpZXJfYmxvY2sgY3B1X2hvdHBsdWdfbm90aWZpZXIgPSB7Cj4gKwkubm90aWZpZXJf Y2FsbCA9IGNwdV9ob3RwbHVnX25vdGlmeSwKPiArfTsKCkNhbiB5b3UgZXhwbGFpbiB3aHkgdGhp cyBpcyBuZWVkZWQgPwoKPiArc3RhdGljIHZvaWQgZTUwMF9jcHVpZGxlX2RyaXZlcl9pbml0KHZv aWQpCj4gK3sKPiArCWludCBpZGxlX3N0YXRlOwo+ICsJc3RydWN0IGNwdWlkbGVfZHJpdmVyICpk cnYgPSAmZTUwMF9pZGxlX2RyaXZlcjsKClBhc3MgdGhlIGNwdWlkbGVfZHJpdmVyIGFzIHBhcmFt ZXRlciB0byB0aGUgZnVuY3Rpb24uCgo+ICsKPiArCWRydi0+c3RhdGVfY291bnQgPSAwOwo+ICsK PiArCWZvciAoaWRsZV9zdGF0ZSA9IDA7IGlkbGVfc3RhdGUgPCBtYXhfaWRsZV9zdGF0ZTsgKytp ZGxlX3N0YXRlKSB7Cj4gKwkJaWYgKCFjcHVpZGxlX3N0YXRlX3RhYmxlW2lkbGVfc3RhdGVdLmVu dGVyKQo+ICsJCQlicmVhazsKPiArCj4gKwkJZHJ2LT5zdGF0ZXNbZHJ2LT5zdGF0ZV9jb3VudF0g PSBjcHVpZGxlX3N0YXRlX3RhYmxlW2lkbGVfc3RhdGVdOwo+ICsJCWRydi0+c3RhdGVfY291bnQr KzsKPiArCX0KClRoaXMgY29kZSBzaG91bGQgZGlzYXBwZWFyLgoKQXMgdGhpcyBmdW5jdGlvbiB3 aWxsIGp1c3QgaW5pdGlhbGl6ZSBzdGF0ZV9jb3VudCwgeW91IGNhbiBtb3ZlIGl0IGluIApjYWxs ZXIgYW5kIGtpbGwgdGhpcyBmdW5jdGlvbi4KCj4gK30KPiArCj4gK3N0YXRpYyBpbnQgZTUwMF9p ZGxlX3N0YXRlX3Byb2JlKHZvaWQpCj4gK3sKPiArCWlmIChjcHVpZGxlX2Rpc2FibGUgIT0gSURM RV9OT19PVkVSUklERSkKPiArCQlyZXR1cm4gLUVOT0RFVjsKPiArCj4gKwljcHVpZGxlX3N0YXRl X3RhYmxlID0gcHdfaWRsZV9zdGF0ZXM7Cj4gKwltYXhfaWRsZV9zdGF0ZSA9IEFSUkFZX1NJWkUo cHdfaWRsZV9zdGF0ZXMpOwo+ICsKPiArCS8qIERpc2FibGUgUFcyMCBmZWF0dXJlIGZvciBlNTAw bWMsIGU1NTAwICovCj4gKwlpZiAoUFZSX1ZFUihjdXJfY3B1X3NwZWMtPnB2cl92YWx1ZSkgIT0g UFZSX1ZFUl9FNjUwMCkKPiArCQljcHVpZGxlX3N0YXRlX3RhYmxlWzFdLmVudGVyID0gTlVMTDsK PiArCj4gKwlpZiAoIWNwdWlkbGVfc3RhdGVfdGFibGUgfHwgIW1heF9pZGxlX3N0YXRlKQo+ICsJ CXJldHVybiAtRU5PREVWOwo+ICsKPiArCXJldHVybiAwOwo+ICt9CgpUaGlzIGNvZGUgc2hvdWxk IGRpc2FwcGVhci4KCj4gK3N0YXRpYyB2b2lkIHJlcGxhY2Vfb3JpZ19pZGxlKHZvaWQgKmR1bW15 KQo+ICt7Cj4gKwlyZXR1cm47Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgX19pbml0IGU1MDBfaWRs ZV9pbml0KHZvaWQpCj4gK3sKPiArCXN0cnVjdCBjcHVpZGxlX2RyaXZlciAqZHJ2ID0gJmU1MDBf aWRsZV9kcml2ZXI7Cj4gKwlpbnQgZXJyOwo+ICsKPiArCWlmIChlNTAwX2lkbGVfc3RhdGVfcHJv YmUoKSkKPiArCQlyZXR1cm4gLUVOT0RFVjsKPiArCj4gKwllNTAwX2NwdWlkbGVfZHJpdmVyX2lu aXQoKTsKPiArCWlmICghZHJ2LT5zdGF0ZV9jb3VudCkKPiArCQlyZXR1cm4gLUVOT0RFVjsKCk5v IG5lZWQgb2YgdGhpcyBjaGVjaywgYmVjYXVzZToKCjEuIHlvdSBrbm93IGhvdyB5b3UgaW5pdGlh bGl6ZWQgdGhlIGRyaXZlciAoMSBvciAyIHN0YXRlcykKMi4gdGhpcyBpcyBhbHJlYWR5IGJ5IHRo ZSBjcHVpZGxlIGZyYW1ld29yawoKPiArCj4gKwllcnIgPSBjcHVpZGxlX3JlZ2lzdGVyKGRydiwg TlVMTCk7Cj4gKwlpZiAoZXJyKSB7Cj4gKwkJcHJfZXJyKCJSZWdpc3RlciBlNTAwIGZhbWlseSBj cHVpZGxlIGRyaXZlciBmYWlsZWQuXG4iKTsKCmV4dHJhIGNhcnJpYWdlIHJldHVybi4KPiArCj4g KwkJcmV0dXJuIGVycjsKPiArCX0KPiArCj4gKwllcnIgPSByZWdpc3Rlcl9jcHVfbm90aWZpZXIo JmNwdV9ob3RwbHVnX25vdGlmaWVyKTsKPiArCWlmIChlcnIpCj4gKwkJcHJfd2FybigiQ3B1aWRs ZSBkcml2ZXI6IHJlZ2lzdGVyIGNwdSBub3RpZmllciBmYWlsZWQuXG4iKTsKPiArCj4gKwkvKiBS ZXBsYWNlIHRoZSBvcmlnaW5hbCB3YXkgb2YgaWRsZSBhZnRlciBjcHVpZGxlIHJlZ2lzdGVyZWQu ICovCj4gKwlwcGNfbWQucG93ZXJfc2F2ZSA9IGU1MDBfY3B1aWRsZTsKPiArCW9uX2VhY2hfY3B1 KHJlcGxhY2Vfb3JpZ19pZGxlLCBOVUxMLCAxKTsKCldoeSA/Cgo+ICsJcHJfaW5mbygiZTUwMF9p ZGxlX2RyaXZlciByZWdpc3RlcmVkLlxuIik7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArbGF0 ZV9pbml0Y2FsbChlNTAwX2lkbGVfaW5pdCk7Cj4KClRoYW5rcwoKICAgLS0gRGFuaWVsCgoKLS0g CiAgPGh0dHA6Ly93d3cubGluYXJvLm9yZy8+IExpbmFyby5vcmcg4pSCIE9wZW4gc291cmNlIHNv ZnR3YXJlIGZvciBBUk0gU29DcwoKRm9sbG93IExpbmFybzogIDxodHRwOi8vd3d3LmZhY2Vib29r LmNvbS9wYWdlcy9MaW5hcm8+IEZhY2Vib29rIHwKPGh0dHA6Ly90d2l0dGVyLmNvbS8jIS9saW5h cm9vcmc+IFR3aXR0ZXIgfAo8aHR0cDovL3d3dy5saW5hcm8ub3JnL2xpbmFyby1ibG9nLz4gQmxv ZwoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KTGludXhw cGMtZGV2IG1haWxpbmcgbGlzdApMaW51eHBwYy1kZXZAbGlzdHMub3psYWJzLm9yZwpodHRwczov L2xpc3RzLm96bGFicy5vcmcvbGlzdGluZm8vbGludXhwcGMtZGV2 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-we0-f179.google.com (mail-we0-f179.google.com [74.125.82.179]) (using TLSv1 with cipher ECDHE-RSA-RC4-SHA (128/128 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 143891400E0 for ; Wed, 2 Apr 2014 20:36:07 +1100 (EST) Received: by mail-we0-f179.google.com with SMTP id x48so7432299wes.38 for ; Wed, 02 Apr 2014 02:36:02 -0700 (PDT) Message-ID: <533BDA11.9080905@linaro.org> Date: Wed, 02 Apr 2014 11:36:17 +0200 From: Daniel Lezcano MIME-Version: 1.0 To: Dongsheng Wang , scottwood@freescale.com Subject: Re: [PATCH] cpuidle: add freescale e500 family porcessors idle support References: <1396341234-40515-1-git-send-email-dongsheng.wang@freescale.com> In-Reply-To: <1396341234-40515-1-git-send-email-dongsheng.wang@freescale.com> Content-Type: text/plain; charset=UTF-8; format=flowed Cc: chenhui.zhao@freescale.com, linux-pm@vger.kernel.org, rjw@sisk.pl, jason.jin@freescale.com, linuxppc-dev@lists.ozlabs.org List-Id: Linux on PowerPC Developers Mail List List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , On 04/01/2014 10:33 AM, Dongsheng Wang wrote: > From: Wang Dongsheng > > Add cpuidle support for e500 family, using cpuidle framework to > manage various low power modes. The new implementation will remain > compatible with original idle method. > > I have done test about power consumption and latency. Cpuidle framework > will make CPU response time faster than original method, but power > consumption is higher than original method. > > Power consumption: > The original method, power consumption is 10.51202 (W). > The cpuidle framework, power consumption is 10.5311 (W). > > Latency: > The original method, avg latency is 6782 (us). > The cpuidle framework, avg latency is 6482 (us). > > Initially, this supports PW10, PW20 and subsequent patches will support > DOZE/NAP and PH10, PH20. > > Signed-off-by: Wang Dongsheng > > diff --git a/arch/powerpc/include/asm/machdep.h b/arch/powerpc/include/asm/machdep.h > index 5b6c03f..9301420 100644 > --- a/arch/powerpc/include/asm/machdep.h > +++ b/arch/powerpc/include/asm/machdep.h > @@ -294,6 +294,15 @@ extern void power7_idle(void); > extern void ppc6xx_idle(void); > extern void book3e_idle(void); > > +static inline void cpuidle_wait(void) > +{ > +#ifdef CONFIG_PPC64 > + book3e_idle(); > +#else > + e500_idle(); > +#endif > +} > + > /* > * ppc_md contains a copy of the machine description structure for the > * current platform. machine_id contains the initial address where the > diff --git a/arch/powerpc/kernel/sysfs.c b/arch/powerpc/kernel/sysfs.c > index 97e1dc9..edd193f 100644 > --- a/arch/powerpc/kernel/sysfs.c > +++ b/arch/powerpc/kernel/sysfs.c > @@ -190,6 +190,9 @@ static ssize_t show_pw20_wait_time(struct device *dev, > return sprintf(buf, "%llu\n", time > 0 ? time : 0); > } > > +#ifdef CONFIG_CPU_IDLE_E500 > +u32 cpuidle_entry_bit; > +#endif > static void set_pw20_wait_entry_bit(void *val) > { > u32 *value = val; > @@ -204,7 +207,11 @@ static void set_pw20_wait_entry_bit(void *val) > /* set count */ > pw20_idle |= ((MAX_BIT - *value) << PWRMGTCR0_PW20_ENT_SHIFT); > > +#ifdef CONFIG_CPU_IDLE_E500 > + cpuidle_entry_bit = *value; > +#else > mtspr(SPRN_PWRMGTCR0, pw20_idle); > +#endif > } > > static ssize_t store_pw20_wait_time(struct device *dev, > diff --git a/drivers/cpuidle/Kconfig.powerpc b/drivers/cpuidle/Kconfig.powerpc > index 66c3a09..0949dbf 100644 > --- a/drivers/cpuidle/Kconfig.powerpc > +++ b/drivers/cpuidle/Kconfig.powerpc > @@ -18,3 +18,10 @@ config POWERNV_CPUIDLE > help > Select this option to enable processor idle state management > through cpuidle subsystem. > + > +config CPU_IDLE_E500 > + bool "CPU Idle Driver for E500 family processors" > + depends on CPU_IDLE > + depends on FSL_SOC_BOOKE > + help > + Select this to enable cpuidle on e500 family processors. > diff --git a/drivers/cpuidle/Makefile b/drivers/cpuidle/Makefile > index f71ae1b..7e6adea 100644 > --- a/drivers/cpuidle/Makefile > +++ b/drivers/cpuidle/Makefile > @@ -18,3 +18,4 @@ obj-$(CONFIG_ARM_AT91_CPUIDLE) += cpuidle-at91.o > # POWERPC drivers > obj-$(CONFIG_PSERIES_CPUIDLE) += cpuidle-pseries.o > obj-$(CONFIG_POWERNV_CPUIDLE) += cpuidle-powernv.o > +obj-$(CONFIG_CPU_IDLE_E500) += cpuidle-e500.o > diff --git a/drivers/cpuidle/cpuidle-e500.c b/drivers/cpuidle/cpuidle-e500.c > new file mode 100644 > index 0000000..ddc0def > --- /dev/null > +++ b/drivers/cpuidle/cpuidle-e500.c > @@ -0,0 +1,194 @@ > +/* > + * CPU Idle driver for Freescale PowerPC e500 family processors. > + * > + * Copyright 2014 Freescale Semiconductor, Inc. > + * > + * Author: Dongsheng Wang > + * > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License version 2 as > + * published by the Free Software Foundation. > + */ > + > +#include > +#include > +#include > +#include > +#include > + > +#include > +#include > +#include > + > +static unsigned int max_idle_state; > +static struct cpuidle_state *cpuidle_state_table; > + > +struct cpuidle_driver e500_idle_driver = { > + .name = "e500_idle", > + .owner = THIS_MODULE, > +}; > + > +static void e500_cpuidle(void) > +{ > + if (cpuidle_idle_call()) > + cpuidle_wait(); > +} Nope, that has been changed. No more call to cpuidle_idle_call in a driver. > + > +static int pw10_enter(struct cpuidle_device *dev, > + struct cpuidle_driver *drv, int index) > +{ > + cpuidle_wait(); > + return index; > +} > + > +#define MAX_BIT 63 > +#define MIN_BIT 1 > +extern u32 cpuidle_entry_bit; > +static int pw20_enter(struct cpuidle_device *dev, > + struct cpuidle_driver *drv, int index) > +{ > + u32 pw20_idle; > + u32 entry_bit; > + pw20_idle = mfspr(SPRN_PWRMGTCR0); > + if ((pw20_idle & PWRMGTCR0_PW20_ENT) != PWRMGTCR0_PW20_ENT) { > + pw20_idle &= ~PWRMGTCR0_PW20_ENT; > + entry_bit = MAX_BIT - cpuidle_entry_bit; > + pw20_idle |= (entry_bit << PWRMGTCR0_PW20_ENT_SHIFT); > + mtspr(SPRN_PWRMGTCR0, pw20_idle); > + } > + > + cpuidle_wait(); > + > + pw20_idle &= ~PWRMGTCR0_PW20_ENT; > + pw20_idle |= (MIN_BIT << PWRMGTCR0_PW20_ENT_SHIFT); > + mtspr(SPRN_PWRMGTCR0, pw20_idle); > + > + return index; > +} Is it possible to give some comments and encapsulate the code with explicit function names to be implemented in an arch specific directory file (eg. pm.c) and export these functions in a linux/ header ? We try to prevent to include asm if possible. > + > +static struct cpuidle_state pw_idle_states[] = { > + { > + .name = "pw10", > + .desc = "pw10", > + .flags = CPUIDLE_FLAG_TIME_VALID, > + .exit_latency = 0, > + .target_residency = 0, > + .enter = &pw10_enter > + }, > + > + { > + .name = "pw20", > + .desc = "pw20-core-idle", > + .flags = CPUIDLE_FLAG_TIME_VALID, > + .exit_latency = 1, > + .target_residency = 50, > + .enter = &pw20_enter > + }, > +}; No need to define this intermediate structure here, you can directly initialize the cpuidle_driver: struct cpuidle_driver e500_idle_driver = { .name = "e500_idle", .owner = THIS_MODULE, .states = { .name = "pw10", .desc = "pw10", .flags = CPUIDLE_FLAG_TIME_VALID, .target_residency = 0, .enter = &pw10_enter, }, .... .state_count = 2, }; Then in the init function you initialize the state_count consequently: if (PVR_VER(cur_cpu_spec->pvr_value) != PVR_VER_E6500) drv->state_count = 1; Then you can kill: max_idle_state, cpuidle_state_table, e500_idle_state_probe and pw_idle_states. > + > +static int cpu_hotplug_notify(struct notifier_block *n, > + unsigned long action, void *hcpu) > +{ > + unsigned long hotcpu = (unsigned long)hcpu; > + struct cpuidle_device *dev = > + per_cpu_ptr(cpuidle_devices, hotcpu); > + > + if (dev && cpuidle_get_driver()) { > + switch (action) { > + case CPU_ONLINE: > + case CPU_ONLINE_FROZEN: > + cpuidle_pause_and_lock(); > + cpuidle_enable_device(dev); > + cpuidle_resume_and_unlock(); > + break; > + > + case CPU_DEAD: > + case CPU_DEAD_FROZEN: > + cpuidle_pause_and_lock(); > + cpuidle_disable_device(dev); > + cpuidle_resume_and_unlock(); > + break; > + > + default: > + return NOTIFY_DONE; > + } > + } > + > + return NOTIFY_OK; > +} > + > +static struct notifier_block cpu_hotplug_notifier = { > + .notifier_call = cpu_hotplug_notify, > +}; Can you explain why this is needed ? > +static void e500_cpuidle_driver_init(void) > +{ > + int idle_state; > + struct cpuidle_driver *drv = &e500_idle_driver; Pass the cpuidle_driver as parameter to the function. > + > + drv->state_count = 0; > + > + for (idle_state = 0; idle_state < max_idle_state; ++idle_state) { > + if (!cpuidle_state_table[idle_state].enter) > + break; > + > + drv->states[drv->state_count] = cpuidle_state_table[idle_state]; > + drv->state_count++; > + } This code should disappear. As this function will just initialize state_count, you can move it in caller and kill this function. > +} > + > +static int e500_idle_state_probe(void) > +{ > + if (cpuidle_disable != IDLE_NO_OVERRIDE) > + return -ENODEV; > + > + cpuidle_state_table = pw_idle_states; > + max_idle_state = ARRAY_SIZE(pw_idle_states); > + > + /* Disable PW20 feature for e500mc, e5500 */ > + if (PVR_VER(cur_cpu_spec->pvr_value) != PVR_VER_E6500) > + cpuidle_state_table[1].enter = NULL; > + > + if (!cpuidle_state_table || !max_idle_state) > + return -ENODEV; > + > + return 0; > +} This code should disappear. > +static void replace_orig_idle(void *dummy) > +{ > + return; > +} > + > +static int __init e500_idle_init(void) > +{ > + struct cpuidle_driver *drv = &e500_idle_driver; > + int err; > + > + if (e500_idle_state_probe()) > + return -ENODEV; > + > + e500_cpuidle_driver_init(); > + if (!drv->state_count) > + return -ENODEV; No need of this check, because: 1. you know how you initialized the driver (1 or 2 states) 2. this is already by the cpuidle framework > + > + err = cpuidle_register(drv, NULL); > + if (err) { > + pr_err("Register e500 family cpuidle driver failed.\n"); extra carriage return. > + > + return err; > + } > + > + err = register_cpu_notifier(&cpu_hotplug_notifier); > + if (err) > + pr_warn("Cpuidle driver: register cpu notifier failed.\n"); > + > + /* Replace the original way of idle after cpuidle registered. */ > + ppc_md.power_save = e500_cpuidle; > + on_each_cpu(replace_orig_idle, NULL, 1); Why ? > + pr_info("e500_idle_driver registered.\n"); > + > + return 0; > +} > +late_initcall(e500_idle_init); > Thanks -- Daniel -- Linaro.org │ Open source software for ARM SoCs Follow Linaro: Facebook | Twitter | Blog