From mboxrd@z Thu Jan 1 00:00:00 1970 From: Arnd Bergmann Subject: powerpc/cell/cpufreq: add spu aware cpufreq governor Date: Mon, 7 Jul 2008 17:02:30 +0200 Message-ID: <200807071702.31240.arnd@arndb.de> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: cpufreq-bounces@lists.linux.org.uk Errors-To: cpufreq-bounces+glkc-cpufreq=m.gmane.org+glkc-cpufreq=m.gmane.org@lists.linux.org.uk To: Dave Jones Cc: Stephen Rothwell , cpufreq@lists.linux.org.uk, linuxppc-dev@ozlabs.org, Jeremy Kerr , Benjamin Herrenschmidt , cbe-oss-dev@ozlabs.org RnJvbTogQ2hyaXN0aWFuIEtyYWZmdCA8a3JhZmZ0QGRlLmlibS5jb20+CgpUaGlzIHBhdGNoIGFk ZHMgYSBjcHVmcmVxIGdvdmVybm9yIHRoYXQgdGFrZXMgdGhlIG51bWJlciBvZiBydW5uaW5nIHNw dXMKaW50byBhY2NvdW50LiBJdCdzIHZlcnkgc2ltaWxhciB0byB0aGUgb25kZW1hbmQgZ292ZXJu b3IsIGJ1dCBub3QgYXMgY29tcGxleC4KSW5zdGVhZCBvZiBoYWNraW5nIHNwdSBsb2FkIGludG8g dGhlIG9uZGVtYW5kIGdvdmVybm9yIGl0IG1pZ2h0IGJlIGVhc2llciB0bwpoYXZlIGNwdWZyZXEg YWNjZXB0aW5nIG11bHRpcGxlIGdvdmVybm9ycyBwZXIgY3B1IGluIGZ1dHVyZS4KRG9uJ3Qga25v dyBpZiB0aGlzIGlzIHRoZSByaWdodCB3YXksIGJ1dCBpdCB3b3VsZCBrZWVwIHRoZSBnb3Zlcm5v cnMgc2ltcGxlLgoKU2lnbmVkLW9mZi1ieTogQ2hyaXN0aWFuIEtyYWZmdCA8a3JhZmZ0QGRlLmli bS5jb20+ClNpZ25lZC1vZmYtYnk6IEFybmQgQmVyZ21hbm4gPGFybmRAYXJuZGIuZGU+Ci0tLQoK RGF2ZSBvciBvdGhlciBjcHVmcmVxIHBlb3BsZSwgY2FuIHlvdSB0YWtlIGEgbG9vayBhdCB0aGlz CmFuZCBhZGQgYW4gQWNrZWQtYnkgd2hlbiB5b3UncmUgaGFwcHk/CgpXZSBoYXZlIG9uZSBwcmVy ZXF1aXNpdGUgcGF0Y2ggaW4gdGhlIHBvd2VycGMgY29kZSAoaW4gc3B1ZnMpLApzbyBzaG91bGQg aXQgZ2V0IG1lcmdlZCB0aHJvdWdoIHBvd2VycGMuZ2l0PwoKIGFyY2gvcG93ZXJwYy9wbGF0Zm9y bXMvY2VsbC9LY29uZmlnICAgICAgICAgICAgfCAgIDEwICsrCiBhcmNoL3Bvd2VycGMvcGxhdGZv cm1zL2NlbGwvTWFrZWZpbGUgICAgICAgICAgIHwgICAgMSArCiBhcmNoL3Bvd2VycGMvcGxhdGZv cm1zL2NlbGwvY2JlX3NwdV9nb3Zlcm5vci5jIHwgIDE4MyArKysrKysrKysrKysrKysrKysrKysr KysKIDMgZmlsZXMgY2hhbmdlZCwgMTk0IGluc2VydGlvbnMoKyksIDAgZGVsZXRpb25zKC0pCiBj cmVhdGUgbW9kZSAxMDA2NDQgYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9jZWxsL2NiZV9zcHVfZ292 ZXJub3IuYwoKSW5kZXg6IGxpbnV4LTIuNi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL2NlbGwvS2Nv bmZpZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBsaW51eC0yLjYub3JpZy9hcmNoL3Bvd2VycGMvcGxhdGZvcm1z L2NlbGwvS2NvbmZpZworKysgbGludXgtMi42L2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvY2VsbC9L Y29uZmlnCkBAIC0xMDcsNiArMTA3LDE2IEBAIGNvbmZpZyBDQkVfQ1BVRlJFUV9QTUkKIAkgIHBy b2Nlc3NvciB3aWxsIG5vdCBvbmx5IGJlIGFibGUgdG8gcnVuIGF0IGxvd2VyIHNwZWVkLAogCSAg YnV0IGFsc28gYXQgbG93ZXIgY29yZSB2b2x0YWdlLgogCitjb25maWcgQ0JFX0NQVUZSRVFfU1BV X0dPVkVSTk9SCisJdHJpc3RhdGUgIkNCRSBmcmVxdWVuY3kgc2NhbGluZyBiYXNlZCBvbiBTUFUg dXNhZ2UiCisJZGVwZW5kcyBvbiBTUFVfRlMKKwlzZWxlY3QgQ0JFX0NQVUZSRVEKKwlkZWZhdWx0 IG0KKwloZWxwCisJICBUaGlzIGdvdmVybm9yIGNoZWNrcyBmb3Igc3B1IHVzYWdlIHRvIGFkanVz dCB0aGUgY3B1IGZyZXF1ZW5jeS4KKwkgIElmIG5vIHNwdSBpcyBydW5uaW5nIG9uIGEgZ2l2ZW4g Y3B1LCB0aGF0IGNwdSB3aWxsIGJlIHRocm90dGxlZCB0bworCSAgdGhlIG1pbmltYWwgcG9zc2li bGUgZnJlcXVlbmN5LgorCiBlbmRtZW51CiAKIGNvbmZpZyBPUFJPRklMRV9DRUxMCkluZGV4OiBs aW51eC0yLjYvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9jZWxsL01ha2VmaWxlCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIGxpbnV4LTIuNi5vcmlnL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvY2VsbC9NYWtlZmlsZQor KysgbGludXgtMi42L2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvY2VsbC9NYWtlZmlsZQpAQCAtOCw2 ICs4LDcgQEAgb2JqLSQoQ09ORklHX0NCRV9USEVSTSkJCQkrPSBjYmVfdGhlcm1hbAogb2JqLSQo Q09ORklHX0NCRV9DUFVGUkVRX1BNSSkJCSs9IGNiZV9jcHVmcmVxX3BtaS5vCiBvYmotJChDT05G SUdfQ0JFX0NQVUZSRVEpCQkrPSBjYmUtY3B1ZnJlcS5vCiBjYmUtY3B1ZnJlcS15CQkJCSs9IGNi ZV9jcHVmcmVxX3BlcnZhc2l2ZS5vIGNiZV9jcHVmcmVxLm8KK29iai0kKENPTkZJR19DQkVfQ1BV RlJFUV9TUFVfR09WRVJOT1IpCSs9IGNiZV9zcHVfZ292ZXJub3IubwogCiBpZmVxICgkKENPTkZJ R19TTVApLHkpCiBvYmotJChDT05GSUdfUFBDX0NFTExfTkFUSVZFKQkJKz0gc21wLm8KSW5kZXg6 IGxpbnV4LTIuNi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL2NlbGwvY2JlX3NwdV9nb3Zlcm5vci5j Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIC9kZXYvbnVsbAorKysgbGludXgtMi42L2FyY2gvcG93ZXJwYy9wbGF0 Zm9ybXMvY2VsbC9jYmVfc3B1X2dvdmVybm9yLmMKQEAgLTAsMCArMSwxODQgQEAKKy8qCisgKiBz cHUgYXdhcmUgY3B1ZnJlcSBnb3Zlcm5vciBmb3IgdGhlIGNlbGwgcHJvY2Vzc29yCisgKgorICog wqkgQ29weXJpZ2h0IElCTSBDb3Jwb3JhdGlvbiAyMDA2LTIwMDgKKyAqCisgKiBBdXRob3I6IENo cmlzdGlhbiBLcmFmZnQgPGtyYWZmdEBkZS5pYm0uY29tPgorICoKKyAqIFRoaXMgcHJvZ3JhbSBp cyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Cisg KiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFz IHB1Ymxpc2hlZCBieQorICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZl cnNpb24gMiwgb3IgKGF0IHlvdXIgb3B0aW9uKQorICogYW55IGxhdGVyIHZlcnNpb24uCisgKgor ICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBi ZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUg aW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEg UEFSVElDVUxBUiBQVVJQT1NFLiBTZWUgdGhlCisgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5z ZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNv cHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgKiBhbG9uZyB3aXRoIHRoaXMg cHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQorICogRm91bmRhdGlv biwgSW5jLiwgNjc1IE1hc3MgQXZlLCBDYW1icmlkZ2UsIE1BIDAyMTM5LCBVU0EuCisgKi8KKwor I2luY2x1ZGUgPGxpbnV4L2NwdWZyZXEuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgorI2lu Y2x1ZGUgPGxpbnV4L3RpbWVyLmg+CisjaW5jbHVkZSA8bGludXgvd29ya3F1ZXVlLmg+CisjaW5j bHVkZSA8YXNtL2F0b21pYy5oPgorI2luY2x1ZGUgPGFzbS9tYWNoZGVwLmg+CisjaW5jbHVkZSA8 YXNtL3NwdS5oPgorCisjZGVmaW5lIFBPTExfVElNRQkxMDAwMDAJCS8qIGluIMK1cyAqLworI2Rl ZmluZSBFWFAJCTc1MwkJLyogZXhwKC0xKSBpbiBmaXhlZC1wb2ludCAqLworCitzdHJ1Y3Qgc3B1 X2dvdl9pbmZvX3N0cnVjdCB7CisJdW5zaWduZWQgbG9uZyBidXN5X3NwdXM7CS8qIGZpeGVkLXBv aW50ICovCisJc3RydWN0IGNwdWZyZXFfcG9saWN5ICpwb2xpY3k7CisJc3RydWN0IGRlbGF5ZWRf d29yayB3b3JrOworCXVuc2lnbmVkIGludCBwb2xsX2ludDsJCS8qIMK1cyAqLworfTsKK3N0YXRp YyBERUZJTkVfUEVSX0NQVShzdHJ1Y3Qgc3B1X2dvdl9pbmZvX3N0cnVjdCwgc3B1X2dvdl9pbmZv KTsKKworc3RhdGljIHN0cnVjdCB3b3JrcXVldWVfc3RydWN0ICprc3B1Z292X3dxOworCitzdGF0 aWMgaW50IGNhbGNfZnJlcShzdHJ1Y3Qgc3B1X2dvdl9pbmZvX3N0cnVjdCAqaW5mbykKK3sKKwlp bnQgY3B1OworCWludCBidXN5X3NwdXM7CisKKwljcHUgPSBpbmZvLT5wb2xpY3ktPmNwdTsKKwli dXN5X3NwdXMgPSBhdG9taWNfcmVhZCgmY2JlX3NwdV9pbmZvW2NwdV90b19ub2RlKGNwdSldLmJ1 c3lfc3B1cyk7CisKKwlDQUxDX0xPQUQoaW5mby0+YnVzeV9zcHVzLCBFWFAsIGJ1c3lfc3B1cyAq IEZJWEVEXzEpOworCXByX2RlYnVnKCJjcHUgJWQ6IGJ1c3lfc3B1cz0lZCwgaW5mby0+YnVzeV9z cHVzPSVsZFxuIiwKKwkJCWNwdSwgYnVzeV9zcHVzLCBpbmZvLT5idXN5X3NwdXMpOworCisJcmV0 dXJuIGluZm8tPnBvbGljeS0+bWF4ICogaW5mby0+YnVzeV9zcHVzIC8gRklYRURfMTsKK30KKwor c3RhdGljIHZvaWQgc3B1X2dvdl93b3JrKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yaykKK3sKKwlz dHJ1Y3Qgc3B1X2dvdl9pbmZvX3N0cnVjdCAqaW5mbzsKKwlpbnQgZGVsYXk7CisJdW5zaWduZWQg bG9uZyB0YXJnZXRfZnJlcTsKKworCWluZm8gPSBjb250YWluZXJfb2Yod29yaywgc3RydWN0IHNw dV9nb3ZfaW5mb19zdHJ1Y3QsIHdvcmsud29yayk7CisKKwkvKiBhZnRlciBjYW5jZWxfZGVsYXll ZF93b3JrX3N5bmMgd2UgdW5zZXQgaW5mby0+cG9saWN5ICovCisJQlVHX09OKGluZm8tPnBvbGlj eSA9PSBOVUxMKTsKKworCXRhcmdldF9mcmVxID0gY2FsY19mcmVxKGluZm8pOworCV9fY3B1ZnJl cV9kcml2ZXJfdGFyZ2V0KGluZm8tPnBvbGljeSwgdGFyZ2V0X2ZyZXEsIENQVUZSRVFfUkVMQVRJ T05fSCk7CisKKwlkZWxheSA9IHVzZWNzX3RvX2ppZmZpZXMoaW5mby0+cG9sbF9pbnQpOworCXF1 ZXVlX2RlbGF5ZWRfd29ya19vbihpbmZvLT5wb2xpY3ktPmNwdSwga3NwdWdvdl93cSwgJmluZm8t PndvcmssIGRlbGF5KTsKK30KKworc3RhdGljIHZvaWQgc3B1X2dvdl9pbml0X3dvcmsoc3RydWN0 IHNwdV9nb3ZfaW5mb19zdHJ1Y3QgKmluZm8pCit7CisJaW50IGRlbGF5ID0gdXNlY3NfdG9famlm ZmllcyhpbmZvLT5wb2xsX2ludCk7CisJSU5JVF9ERUxBWUVEX1dPUktfREVGRVJSQUJMRSgmaW5m by0+d29yaywgc3B1X2dvdl93b3JrKTsKKwlxdWV1ZV9kZWxheWVkX3dvcmtfb24oaW5mby0+cG9s aWN5LT5jcHUsIGtzcHVnb3Zfd3EsICZpbmZvLT53b3JrLCBkZWxheSk7Cit9CisKK3N0YXRpYyB2 b2lkIHNwdV9nb3ZfY2FuY2VsX3dvcmsoc3RydWN0IHNwdV9nb3ZfaW5mb19zdHJ1Y3QgKmluZm8p Cit7CisJY2FuY2VsX2RlbGF5ZWRfd29ya19zeW5jKCZpbmZvLT53b3JrKTsKK30KKworc3RhdGlj IGludCBzcHVfZ292X2dvdmVybihzdHJ1Y3QgY3B1ZnJlcV9wb2xpY3kgKnBvbGljeSwgdW5zaWdu ZWQgaW50IGV2ZW50KQoreworCXVuc2lnbmVkIGludCBjcHUgPSBwb2xpY3ktPmNwdTsKKwlzdHJ1 Y3Qgc3B1X2dvdl9pbmZvX3N0cnVjdCAqaW5mbywgKmFmZmVjdGVkX2luZm87CisJaW50IGk7CisJ aW50IHJldCA9IDA7CisKKwlpbmZvID0gJnBlcl9jcHUoc3B1X2dvdl9pbmZvLCBjcHUpOworCisJ c3dpdGNoIChldmVudCkgeworCWNhc2UgQ1BVRlJFUV9HT1ZfU1RBUlQ6CisJCWlmICghY3B1X29u bGluZShjcHUpKSB7CisJCQlwcmludGsoS0VSTl9FUlIgImNwdSAlZCBpcyBub3Qgb25saW5lXG4i LCBjcHUpOworCQkJcmV0ID0gLUVJTlZBTDsKKwkJCWJyZWFrOworCQl9CisKKwkJaWYgKCFwb2xp Y3ktPmN1cikgeworCQkJcHJpbnRrKEtFUk5fRVJSICJubyBjcHUgc3BlY2lmaWVkIGluIHBvbGlj eVxuIik7CisJCQlyZXQgPSAtRUlOVkFMOworCQkJYnJlYWs7CisJCX0KKworCQkvKiBpbml0aWFs aXplIHNwdV9nb3ZfaW5mbyBmb3IgYWxsIGFmZmVjdGVkIGNwdXMgKi8KKwkJZm9yX2VhY2hfY3B1 X21hc2soaSwgcG9saWN5LT5jcHVzKSB7CisJCQlhZmZlY3RlZF9pbmZvID0gJnBlcl9jcHUoc3B1 X2dvdl9pbmZvLCBpKTsKKwkJCWFmZmVjdGVkX2luZm8tPnBvbGljeSA9IHBvbGljeTsKKwkJfQor CisJCWluZm8tPnBvbGxfaW50ID0gUE9MTF9USU1FOworCisJCS8qIHNldHVwIHRpbWVyICovCisJ CXNwdV9nb3ZfaW5pdF93b3JrKGluZm8pOworCisJCWJyZWFrOworCisJY2FzZSBDUFVGUkVRX0dP Vl9TVE9QOgorCQkvKiBjYW5jZWwgdGltZXIgKi8KKwkJc3B1X2dvdl9jYW5jZWxfd29yayhpbmZv KTsKKworCQkvKiBjbGVhbiBzcHVfZ292X2luZm8gZm9yIGFsbCBhZmZlY3RlZCBjcHVzICovCisJ CWZvcl9lYWNoX2NwdV9tYXNrIChpLCBwb2xpY3ktPmNwdXMpIHsKKwkJCWluZm8gPSAmcGVyX2Nw dShzcHVfZ292X2luZm8sIGkpOworCQkJaW5mby0+cG9saWN5ID0gTlVMTDsKKwkJfQorCisJCWJy ZWFrOworCX0KKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgY3B1ZnJlcV9nb3Zl cm5vciBzcHVfZ292ZXJub3IgPSB7CisJLm5hbWUgPSAic3B1X2dvdmVybm9yIiwKKwkuZ292ZXJu b3IgPSBzcHVfZ292X2dvdmVybiwKKwkub3duZXIgPSBUSElTX01PRFVMRSwKK307CisKKy8qCisg KiBtb2R1bGUgaW5pdCBhbmQgZGVzdG95CisgKi8KKworc3RhdGljIGludCBfX2luaXQgc3B1X2dv dl9pbml0KHZvaWQpCit7CisJaW50IHJldDsKKworCWtzcHVnb3Zfd3EgPSBjcmVhdGVfd29ya3F1 ZXVlKCJrc3B1Z292Iik7CisJaWYgKCFrc3B1Z292X3dxKSB7CisJCXByaW50ayhLRVJOX0VSUiAi Y3JlYXRpb24gb2Yga3NwdWdvdiBmYWlsZWRcbiIpOworCQlyZXQgPSAtRUZBVUxUOworCQlnb3Rv IG91dDsKKwl9CisKKwlyZXQgPSBjcHVmcmVxX3JlZ2lzdGVyX2dvdmVybm9yKCZzcHVfZ292ZXJu b3IpOworCWlmIChyZXQpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJyZWdpc3RyYXRpb24gb2YgZ292 ZXJub3IgZmFpbGVkXG4iKTsKKwkJZGVzdHJveV93b3JrcXVldWUoa3NwdWdvdl93cSk7CisJCWdv dG8gb3V0OworCX0KK291dDoKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgdm9pZCBfX2V4aXQg c3B1X2dvdl9leGl0KHZvaWQpCit7CisJY3B1ZnJlcV91bnJlZ2lzdGVyX2dvdmVybm9yKCZzcHVf Z292ZXJub3IpOworCWRlc3Ryb3lfd29ya3F1ZXVlKGtzcHVnb3Zfd3EpOworfQorCisKK21vZHVs ZV9pbml0KHNwdV9nb3ZfaW5pdCk7Cittb2R1bGVfZXhpdChzcHVfZ292X2V4aXQpOworCitNT0RV TEVfTElDRU5TRSgiR1BMIik7CitNT0RVTEVfQVVUSE9SKCJDaHJpc3RpYW4gS3JhZmZ0IDxrcmFm ZnRAZGUuaWJtLmNvbT4iKTsKKwoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX18KQ3B1ZnJlcSBtYWlsaW5nIGxpc3QKQ3B1ZnJlcUBsaXN0cy5saW51eC5vcmcu dWsKaHR0cDovL2xpc3RzLmxpbnV4Lm9yZy51ay9tYWlsbWFuL2xpc3RpbmZvL2NwdWZyZXEK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: From: Arnd Bergmann To: Dave Jones Subject: powerpc/cell/cpufreq: add spu aware cpufreq governor Date: Mon, 7 Jul 2008 17:02:30 +0200 MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Message-Id: <200807071702.31240.arnd@arndb.de> Cc: Stephen Rothwell , cpufreq@lists.linux.org.uk, linuxppc-dev@ozlabs.org, Jeremy Kerr , cbe-oss-dev@ozlabs.org List-Id: Linux on PowerPC Developers Mail List List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , =46rom: Christian Krafft This patch adds a cpufreq governor that takes the number of running spus into account. It's very similar to the ondemand governor, but not as comple= x. Instead of hacking spu load into the ondemand governor it might be easier to have cpufreq accepting multiple governors per cpu in future. Don't know if this is the right way, but it would keep the governors simple. Signed-off-by: Christian Krafft Signed-off-by: Arnd Bergmann =2D-- Dave or other cpufreq people, can you take a look at this and add an Acked-by when you're happy? We have one prerequisite patch in the powerpc code (in spufs), so should it get merged through powerpc.git? arch/powerpc/platforms/cell/Kconfig | 10 ++ arch/powerpc/platforms/cell/Makefile | 1 + arch/powerpc/platforms/cell/cbe_spu_governor.c | 183 ++++++++++++++++++++= ++++ 3 files changed, 194 insertions(+), 0 deletions(-) create mode 100644 arch/powerpc/platforms/cell/cbe_spu_governor.c Index: linux-2.6/arch/powerpc/platforms/cell/Kconfig =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =2D-- linux-2.6.orig/arch/powerpc/platforms/cell/Kconfig +++ linux-2.6/arch/powerpc/platforms/cell/Kconfig @@ -107,6 +107,16 @@ config CBE_CPUFREQ_PMI processor will not only be able to run at lower speed, but also at lower core voltage. =20 +config CBE_CPUFREQ_SPU_GOVERNOR + tristate "CBE frequency scaling based on SPU usage" + depends on SPU_FS + select CBE_CPUFREQ + default m + help + This governor checks for spu usage to adjust the cpu frequency. + If no spu is running on a given cpu, that cpu will be throttled to + the minimal possible frequency. + endmenu =20 config OPROFILE_CELL Index: linux-2.6/arch/powerpc/platforms/cell/Makefile =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =2D-- linux-2.6.orig/arch/powerpc/platforms/cell/Makefile +++ linux-2.6/arch/powerpc/platforms/cell/Makefile @@ -8,6 +8,7 @@ obj-$(CONFIG_CBE_THERM) +=3D cbe_thermal obj-$(CONFIG_CBE_CPUFREQ_PMI) +=3D cbe_cpufreq_pmi.o obj-$(CONFIG_CBE_CPUFREQ) +=3D cbe-cpufreq.o cbe-cpufreq-y +=3D cbe_cpufreq_pervasive.o cbe_cpufreq.o +obj-$(CONFIG_CBE_CPUFREQ_SPU_GOVERNOR) +=3D cbe_spu_governor.o =20 ifeq ($(CONFIG_SMP),y) obj-$(CONFIG_PPC_CELL_NATIVE) +=3D smp.o Index: linux-2.6/arch/powerpc/platforms/cell/cbe_spu_governor.c =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =2D-- /dev/null +++ linux-2.6/arch/powerpc/platforms/cell/cbe_spu_governor.c @@ -0,0 +1,184 @@ +/* + * spu aware cpufreq governor for the cell processor + * + * =C2=A9 Copyright IBM Corporation 2006-2008 + * + * Author: Christian Krafft + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include +#include +#include +#include +#include +#include +#include + +#define POLL_TIME 100000 /* in =C2=B5s */ +#define EXP 753 /* exp(-1) in fixed-point */ + +struct spu_gov_info_struct { + unsigned long busy_spus; /* fixed-point */ + struct cpufreq_policy *policy; + struct delayed_work work; + unsigned int poll_int; /* =C2=B5s */ +}; +static DEFINE_PER_CPU(struct spu_gov_info_struct, spu_gov_info); + +static struct workqueue_struct *kspugov_wq; + +static int calc_freq(struct spu_gov_info_struct *info) +{ + int cpu; + int busy_spus; + + cpu =3D info->policy->cpu; + busy_spus =3D atomic_read(&cbe_spu_info[cpu_to_node(cpu)].busy_spus); + + CALC_LOAD(info->busy_spus, EXP, busy_spus * FIXED_1); + pr_debug("cpu %d: busy_spus=3D%d, info->busy_spus=3D%ld\n", + cpu, busy_spus, info->busy_spus); + + return info->policy->max * info->busy_spus / FIXED_1; +} + +static void spu_gov_work(struct work_struct *work) +{ + struct spu_gov_info_struct *info; + int delay; + unsigned long target_freq; + + info =3D container_of(work, struct spu_gov_info_struct, work.work); + + /* after cancel_delayed_work_sync we unset info->policy */ + BUG_ON(info->policy =3D=3D NULL); + + target_freq =3D calc_freq(info); + __cpufreq_driver_target(info->policy, target_freq, CPUFREQ_RELATION_H); + + delay =3D usecs_to_jiffies(info->poll_int); + queue_delayed_work_on(info->policy->cpu, kspugov_wq, &info->work, delay); +} + +static void spu_gov_init_work(struct spu_gov_info_struct *info) +{ + int delay =3D usecs_to_jiffies(info->poll_int); + INIT_DELAYED_WORK_DEFERRABLE(&info->work, spu_gov_work); + queue_delayed_work_on(info->policy->cpu, kspugov_wq, &info->work, delay); +} + +static void spu_gov_cancel_work(struct spu_gov_info_struct *info) +{ + cancel_delayed_work_sync(&info->work); +} + +static int spu_gov_govern(struct cpufreq_policy *policy, unsigned int even= t) +{ + unsigned int cpu =3D policy->cpu; + struct spu_gov_info_struct *info, *affected_info; + int i; + int ret =3D 0; + + info =3D &per_cpu(spu_gov_info, cpu); + + switch (event) { + case CPUFREQ_GOV_START: + if (!cpu_online(cpu)) { + printk(KERN_ERR "cpu %d is not online\n", cpu); + ret =3D -EINVAL; + break; + } + + if (!policy->cur) { + printk(KERN_ERR "no cpu specified in policy\n"); + ret =3D -EINVAL; + break; + } + + /* initialize spu_gov_info for all affected cpus */ + for_each_cpu_mask(i, policy->cpus) { + affected_info =3D &per_cpu(spu_gov_info, i); + affected_info->policy =3D policy; + } + + info->poll_int =3D POLL_TIME; + + /* setup timer */ + spu_gov_init_work(info); + + break; + + case CPUFREQ_GOV_STOP: + /* cancel timer */ + spu_gov_cancel_work(info); + + /* clean spu_gov_info for all affected cpus */ + for_each_cpu_mask (i, policy->cpus) { + info =3D &per_cpu(spu_gov_info, i); + info->policy =3D NULL; + } + + break; + } + + return ret; +} + +static struct cpufreq_governor spu_governor =3D { + .name =3D "spu_governor", + .governor =3D spu_gov_govern, + .owner =3D THIS_MODULE, +}; + +/* + * module init and destoy + */ + +static int __init spu_gov_init(void) +{ + int ret; + + kspugov_wq =3D create_workqueue("kspugov"); + if (!kspugov_wq) { + printk(KERN_ERR "creation of kspugov failed\n"); + ret =3D -EFAULT; + goto out; + } + + ret =3D cpufreq_register_governor(&spu_governor); + if (ret) { + printk(KERN_ERR "registration of governor failed\n"); + destroy_workqueue(kspugov_wq); + goto out; + } +out: + return ret; +} + +static void __exit spu_gov_exit(void) +{ + cpufreq_unregister_governor(&spu_governor); + destroy_workqueue(kspugov_wq); +} + + +module_init(spu_gov_init); +module_exit(spu_gov_exit); + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Christian Krafft "); +