From mboxrd@z Thu Jan 1 00:00:00 1970 From: Shobhit Kumar Subject: [v2 5/7] pwm: crc: Add Crystalcove (CRC) PWM driver Date: Mon, 22 Jun 2015 16:24:23 +0530 Message-ID: <1434970465-12687-6-git-send-email-shobhit.kumar@intel.com> References: <1434970465-12687-1-git-send-email-shobhit.kumar@intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1434970465-12687-1-git-send-email-shobhit.kumar@intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: linux-pwm , intel-gfx , linux-kernel , dri-devel , linux-gpio Cc: Alexandre Courbot , Paul Bolle , Samuel Ortiz , Povilas Staniulis , Jani Nikula , Shobhit Kumar , Linus Walleij , Paul Gortmaker , bloften80@gmail.com, David Airlie , Chih-Wei Huang , Thierry Reding , Daniel Vetter , Lee Jones List-Id: linux-gpio@vger.kernel.org VGhlIENyeXN0YWxjb3ZlIFBNSUMgcHJvdmlkZXMgdGhyZWUgUFdNIHNpZ25hbHMgYW5kIHRoaXMg ZHJpdmVyIGV4cG9ydHMKb25lIG9mIHRoZW0gb24gdGhlIEJZVCBwbGF0Zm9ybSB3aGljaCBpcyB1 c2VkIHRvIGNvbnRyb2wgYmFja2xpZ2h0IGZvcgpEU0kgcGFuZWwuIFRoaXMgaXMgcGxhdGZvcm0g ZGV2aWNlIGltcGxlbWVudGF0aW9uIG9mIHRoZSBkcml2ZXJzL21mZApjZWxsIGRldmljZSBmb3Ig Q1JDIFBNSUMuCgp2MjogVXNlIHRoZSBleGlzdGluZyBjb25maWcgY2FsbGJhY2sgd2l0aCBkdXR5 X25zIGFuZCBwZXJpb2RfbnMoVGhpZXJyeSkKCnYzOiBDb3JyZWN0IHRoZSBzdWJqZWN0IGxpbmUg KExlZSBqb25lcykKCnY0OiBBZGRyZXNzIGNvbW1lbnQgYnkgVGhpZXJyeSAmIFBhdWwKICAgIC0g Q29tbWl0IG1lc3NhZ2UgdXBkYXRlIGFuZCBmaXhlcyBmb3IgZmV3IHN5bnRheCBlcnJvcnMKICAg IC0gQWRkIFBXTV9DUkMgaW4gS2NvbmZpZyBhbmQgTWFrZWZpbGUgc29ydGVkIGFscGhhYmV0aWNh bGx5CiAgICAtIFVzZSB0aGUgUFdNX0JBU0VfQ0xLIGFzIDYwMDAwMDAgZm9yIGJldHRlciBjb2Rl IHJlYWRhYmlsaXR5CiAgICAtIFJlbW92ZSB0aGUgcmVkdW5kYW50IHJ1bGUgb2YgdGhyZWUgd2hp bGUgY2FsY3VsYXRpbmcgcHdtIGxldmVsCiAgICAtIFVzZSB0aGUgcGxhdGZvcm1fZGV2aWNlIGlu IHB3bV9jaGlwCiAgICAtIFVzZSBidWlsaW5fcGxhdGZvcm1fZHJpdmVyCgpDQzogU2FtdWVsIE9y dGl6IDxzYW1lb0BsaW51eC5pbnRlbC5jb20+CkNjOiBMaW51cyBXYWxsZWlqIDxsaW51cy53YWxs ZWlqQGxpbmFyby5vcmc+CkNjOiBBbGV4YW5kcmUgQ291cmJvdCA8Z251cm91QGdtYWlsLmNvbT4K Q2M6IFRoaWVycnkgUmVkaW5nIDx0aGllcnJ5LnJlZGluZ0BnbWFpbC5jb20+CkNjOiBQYXVsIEJv bGxlIDxwZWJvbGxlQHRpc2NhbGkubmw+CkNjOiBQYXVsIEdvcnRtYWtlciA8cGF1bC5nb3J0bWFr ZXJAd2luZHJpdmVyLmNvbT4KU2lnbmVkLW9mZi1ieTogU2hvYmhpdCBLdW1hciA8c2hvYmhpdC5r dW1hckBpbnRlbC5jb20+Ci0tLQogZHJpdmVycy9wd20vS2NvbmZpZyAgIHwgICA3ICsrKwogZHJp dmVycy9wd20vTWFrZWZpbGUgIHwgICAxICsKIGRyaXZlcnMvcHdtL3B3bS1jcmMuYyB8IDE1NSAr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwogMyBmaWxl cyBjaGFuZ2VkLCAxNjMgaW5zZXJ0aW9ucygrKQogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMv cHdtL3B3bS1jcmMuYwoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcHdtL0tjb25maWcgYi9kcml2ZXJz L3B3bS9LY29uZmlnCmluZGV4IGIxNTQxZjQuLjk0OGQ5YWIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv cHdtL0tjb25maWcKKysrIGIvZHJpdmVycy9wd20vS2NvbmZpZwpAQCAtMTExLDYgKzExMSwxMyBA QCBjb25maWcgUFdNX0NMUFM3MTFYCiAJICBUbyBjb21waWxlIHRoaXMgZHJpdmVyIGFzIGEgbW9k dWxlLCBjaG9vc2UgTSBoZXJlOiB0aGUgbW9kdWxlCiAJICB3aWxsIGJlIGNhbGxlZCBwd20tY2xw czcxMXguCiAKK2NvbmZpZyBQV01fQ1JDCisJYm9vbCAiSW50ZWwgQ3J5c3RhbGNvdmUgKENSQykg UFdNIHN1cHBvcnQiCisJZGVwZW5kcyBvbiBYODYgJiYgSU5URUxfU09DX1BNSUMKKwloZWxwCisJ ICBHZW5lcmljIFBXTSBmcmFtZXdvcmsgZHJpdmVyIGZvciBDcnlzdGFsY292ZSAoQ1JDKSBQTUlD IGJhc2VkIFBXTQorCSAgY29udHJvbC4KKwogY29uZmlnIFBXTV9FUDkzWFgKIAl0cmlzdGF0ZSAi Q2lycnVzIExvZ2ljIEVQOTN4eCBQV00gc3VwcG9ydCIKIAlkZXBlbmRzIG9uIEFSQ0hfRVA5M1hY CmRpZmYgLS1naXQgYS9kcml2ZXJzL3B3bS9NYWtlZmlsZSBiL2RyaXZlcnMvcHdtL01ha2VmaWxl CmluZGV4IGVjNTBlYjUuLmQxODZmMzUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcHdtL01ha2VmaWxl CisrKyBiL2RyaXZlcnMvcHdtL01ha2VmaWxlCkBAIC04LDYgKzgsNyBAQCBvYmotJChDT05GSUdf UFdNX0JDTV9LT05BKQkrPSBwd20tYmNtLWtvbmEubwogb2JqLSQoQ09ORklHX1BXTV9CQ00yODM1 KQkrPSBwd20tYmNtMjgzNS5vCiBvYmotJChDT05GSUdfUFdNX0JGSU4pCQkrPSBwd20tYmZpbi5v CiBvYmotJChDT05GSUdfUFdNX0NMUFM3MTFYKQkrPSBwd20tY2xwczcxMXgubworb2JqLSQoQ09O RklHX1BXTV9DUkMpCQkrPSBwd20tY3JjLm8KIG9iai0kKENPTkZJR19QV01fRVA5M1hYKQkrPSBw d20tZXA5M3h4Lm8KIG9iai0kKENPTkZJR19QV01fRlNMX0ZUTSkJKz0gcHdtLWZzbC1mdG0ubwog b2JqLSQoQ09ORklHX1BXTV9JTUcpCQkrPSBwd20taW1nLm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMv cHdtL3B3bS1jcmMuYyBiL2RyaXZlcnMvcHdtL3B3bS1jcmMuYwpuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwLi5kY2Q5NzgyCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9wd20v cHdtLWNyYy5jCkBAIC0wLDAgKzEsMTU1IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE1IElu dGVsIENvcnBvcmF0aW9uLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFRoaXMgcHJvZ3Jh bSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1v ZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNl IHZlcnNpb24KKyAqIDIgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRp b24uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQg aXQgd2lsbCBiZSB1c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQg ZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5F U1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQorICogR05VIEdlbmVyYWwgUHVi bGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBBdXRob3I6IFNob2JoaXQgS3Vt YXIgPHNob2JoaXQua3VtYXJAaW50ZWwuY29tPgorICovCisKKyNpbmNsdWRlIDxsaW51eC9wbGF0 Zm9ybV9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9yZWdtYXAuaD4KKyNpbmNsdWRlIDxsaW51 eC9tZmQvaW50ZWxfc29jX3BtaWMuaD4KKyNpbmNsdWRlIDxsaW51eC9wd20uaD4KKworI2RlZmlu ZSBQV00wX0NMS19ESVYJCTB4NEIKKyNkZWZpbmUgIFBXTV9PVVRQVVRfRU5BQkxFCSgxIDw8IDcp CisjZGVmaW5lICBQV01fRElWX0NMS18wCQkweDAwIC8qIERJVklERUNMSyA9IEJBU0VDTEsgKi8K KyNkZWZpbmUgIFBXTV9ESVZfQ0xLXzEwMAkweDYzIC8qIERJVklERUNMSyA9IEJBU0VDTEsvMTAw ICovCisjZGVmaW5lICBQV01fRElWX0NMS18xMjgJMHg3RiAvKiBESVZJREVDTEsgPSBCQVNFQ0xL LzEyOCAqLworCisjZGVmaW5lIFBXTTBfRFVUWV9DWUNMRQkJMHg0RQorI2RlZmluZSBCQUNLTElH SFRfRU4JCTB4NTEKKworI2RlZmluZSBQV01fTUFYX0xFVkVMCQkweEZGCisKKyNkZWZpbmUgUFdN X0JBU0VfQ0xLCQk2MDAwMDAwICAvKiA2IE1IeiAqLworI2RlZmluZSBQV01fTUFYX1BFUklPRF9O UwkyMTMzMyAgICAvKiA0Ni44NzVLSHogKi8KKworLyoqCisgKiBzdHJ1Y3QgY3J5c3RhbGNvdmVf cHdtIC0gQ3J5c3RhbCBDb3ZlIFBXTSBjb250cm9sbGVyCisgKiBAY2hpcDogdGhlIGFic3RyYWN0 IHB3bV9jaGlwIHN0cnVjdHVyZS4KKyAqIEByZWdtYXA6IHRoZSByZWdtYXAgZnJvbSB0aGUgcGFy ZW50IGRldmljZS4KKyAqLworc3RydWN0IGNyeXN0YWxjb3ZlX3B3bSB7CisJc3RydWN0IHB3bV9j aGlwIGNoaXA7CisJc3RydWN0IHJlZ21hcCAqcmVnbWFwOworfTsKKworc3RhdGljIGlubGluZSBz dHJ1Y3QgY3J5c3RhbGNvdmVfcHdtICp0b19jcmNfcHdtKHN0cnVjdCBwd21fY2hpcCAqcGMpCit7 CisJcmV0dXJuIGNvbnRhaW5lcl9vZihwYywgc3RydWN0IGNyeXN0YWxjb3ZlX3B3bSwgY2hpcCk7 Cit9CisKK3N0YXRpYyBpbnQgY3JjX3B3bV9lbmFibGUoc3RydWN0IHB3bV9jaGlwICpjLCBzdHJ1 Y3QgcHdtX2RldmljZSAqcHdtKQoreworCXN0cnVjdCBjcnlzdGFsY292ZV9wd20gKmNyY19wd20g PSB0b19jcmNfcHdtKGMpOworCisJcmVnbWFwX3dyaXRlKGNyY19wd20tPnJlZ21hcCwgQkFDS0xJ R0hUX0VOLCAxKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBjcmNfcHdtX2Rpc2Fi bGUoc3RydWN0IHB3bV9jaGlwICpjLCBzdHJ1Y3QgcHdtX2RldmljZSAqcHdtKQoreworCXN0cnVj dCBjcnlzdGFsY292ZV9wd20gKmNyY19wd20gPSB0b19jcmNfcHdtKGMpOworCisJcmVnbWFwX3dy aXRlKGNyY19wd20tPnJlZ21hcCwgQkFDS0xJR0hUX0VOLCAwKTsKK30KKworc3RhdGljIGludCBj cmNfcHdtX2NvbmZpZyhzdHJ1Y3QgcHdtX2NoaXAgKmMsIHN0cnVjdCBwd21fZGV2aWNlICpwd20s CisJCQkgIGludCBkdXR5X25zLCBpbnQgcGVyaW9kX25zKQoreworCXN0cnVjdCBjcnlzdGFsY292 ZV9wd20gKmNyY19wd20gPSB0b19jcmNfcHdtKGMpOworCXN0cnVjdCBkZXZpY2UgKmRldiA9IGNy Y19wd20tPmNoaXAuZGV2OworCWludCBsZXZlbDsKKworCWlmIChwZXJpb2RfbnMgPiBQV01fTUFY X1BFUklPRF9OUykgeworCQlkZXZfZXJyKGRldiwgInVuLXN1cHBvcnRlZCBwZXJpb2RfbnNcbiIp OworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwlpZiAocHdtLT5wZXJpb2QgIT0gcGVyaW9kX25z KSB7CisJCWludCBjbGtfZGl2OworCisJCS8qIGNoYW5naW5nIHRoZSBjbGsgZGl2aXNvciwgbmVl ZCB0byBkaXNhYmxlIGZpc3J0ICovCisJCWNyY19wd21fZGlzYWJsZShjLCBwd20pOworCQljbGtf ZGl2ID0gUFdNX0JBU0VfQ0xLICogcGVyaW9kX25zIC8gTlNFQ19QRVJfU0VDOworCisJCXJlZ21h cF93cml0ZShjcmNfcHdtLT5yZWdtYXAsIFBXTTBfQ0xLX0RJViwKKwkJCQkJY2xrX2RpdiB8IFBX TV9PVVRQVVRfRU5BQkxFKTsKKworCQkvKiBlbmFibGUgYmFjayAqLworCQljcmNfcHdtX2VuYWJs ZShjLCBwd20pOworCX0KKworCS8qIGNoYW5nZSB0aGUgcHdtIGR1dHkgY3ljbGUgKi8KKwlsZXZl bCA9IGR1dHlfbnMgKiBQV01fTUFYX0xFVkVMIC8gcGVyaW9kX25zOworCXJlZ21hcF93cml0ZShj cmNfcHdtLT5yZWdtYXAsIFBXTTBfRFVUWV9DWUNMRSwgbGV2ZWwpOworCisJcmV0dXJuIDA7Cit9 CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgcHdtX29wcyBjcmNfcHdtX29wcyA9IHsKKwkuY29uZmln ID0gY3JjX3B3bV9jb25maWcsCisJLmVuYWJsZSA9IGNyY19wd21fZW5hYmxlLAorCS5kaXNhYmxl ID0gY3JjX3B3bV9kaXNhYmxlLAorfTsKKworc3RhdGljIGludCBjcnlzdGFsY292ZV9wd21fcHJv YmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKK3sKKwlzdHJ1Y3QgY3J5c3RhbGNvdmVf cHdtICpwd207CisJaW50IHJldHZhbDsKKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSBwZGV2LT5kZXYu cGFyZW50OworCXN0cnVjdCBpbnRlbF9zb2NfcG1pYyAqcG1pYyA9IGRldl9nZXRfZHJ2ZGF0YShk ZXYpOworCisJcHdtID0gZGV2bV9remFsbG9jKCZwZGV2LT5kZXYsIHNpemVvZigqcHdtKSwgR0ZQ X0tFUk5FTCk7CisJaWYgKCFwd20pCisJCXJldHVybiAtRU5PTUVNOworCisJcHdtLT5jaGlwLmRl diA9ICZwZGV2LT5kZXY7CisJcHdtLT5jaGlwLm9wcyA9ICZjcmNfcHdtX29wczsKKwlwd20tPmNo aXAuYmFzZSA9IC0xOworCXB3bS0+Y2hpcC5ucHdtID0gMTsKKworCS8qIGdldCB0aGUgUE1JQyBy ZWdtYXAgKi8KKwlwd20tPnJlZ21hcCA9IHBtaWMtPnJlZ21hcDsKKworCXJldHZhbCA9IHB3bWNo aXBfYWRkKCZwd20tPmNoaXApOworCWlmIChyZXR2YWwgPCAwKQorCQlyZXR1cm4gcmV0dmFsOwor CisJcGxhdGZvcm1fc2V0X2RydmRhdGEocGRldiwgcHdtKTsKKworCXJldHVybiAwOworfQorCitz dGF0aWMgaW50IGNyeXN0YWxjb3ZlX3B3bV9yZW1vdmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAq cGRldikKK3sKKwlzdHJ1Y3QgY3J5c3RhbGNvdmVfcHdtICpwd20gPSBwbGF0Zm9ybV9nZXRfZHJ2 ZGF0YShwZGV2KTsKKwlpbnQgcmV0dmFsOworCisJcmV0dmFsID0gcHdtY2hpcF9yZW1vdmUoJnB3 bS0+Y2hpcCk7CisJaWYgKHJldHZhbCA8IDApCisJCXJldHVybiByZXR2YWw7CisKKwlkZXZfZGJn KCZwZGV2LT5kZXYsICJjcmMtcHdtIGRyaXZlciByZW1vdmVkXG4iKTsKKworCXJldHVybiAwOwor fQorCitzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciBjcnlzdGFsY292ZV9wd21fZHJpdmVy ID0geworCS5wcm9iZSA9IGNyeXN0YWxjb3ZlX3B3bV9wcm9iZSwKKwkucmVtb3ZlID0gY3J5c3Rh bGNvdmVfcHdtX3JlbW92ZSwKKwkuZHJpdmVyID0geworCQkubmFtZSA9ICJjcnlzdGFsX2NvdmVf cHdtIiwKKwl9LAorfTsKKworYnVpbHRpbl9wbGF0Zm9ybV9kcml2ZXIoY3J5c3RhbGNvdmVfcHdt X2RyaXZlcik7Ci0tIAoxLjkuMQoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhAbGlzdHMuZnJlZWRl c2t0b3Aub3JnCmh0dHA6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9p bnRlbC1nZngK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S933414AbbFVKzl (ORCPT ); Mon, 22 Jun 2015 06:55:41 -0400 Received: from mga09.intel.com ([134.134.136.24]:49432 "EHLO mga09.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S933331AbbFVKzB (ORCPT ); Mon, 22 Jun 2015 06:55:01 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.13,658,1427785200"; d="scan'208";a="748070724" From: Shobhit Kumar To: linux-pwm , intel-gfx , linux-kernel , dri-devel , linux-gpio Cc: Paul Bolle , Jani Nikula , Samuel Ortiz , Alexandre Courbot , David Airlie , Povilas Staniulis , Chih-Wei Huang , Thierry Reding , Daniel Vetter , Lee Jones , Linus Walleij , Paul Gortmaker , bloften80@gmail.com, Shobhit Kumar Subject: [v2 5/7] pwm: crc: Add Crystalcove (CRC) PWM driver Date: Mon, 22 Jun 2015 16:24:23 +0530 Message-Id: <1434970465-12687-6-git-send-email-shobhit.kumar@intel.com> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1434970465-12687-1-git-send-email-shobhit.kumar@intel.com> References: <1434970465-12687-1-git-send-email-shobhit.kumar@intel.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org The Crystalcove PMIC provides three PWM signals and this driver exports one of them on the BYT platform which is used to control backlight for DSI panel. This is platform device implementation of the drivers/mfd cell device for CRC PMIC. v2: Use the existing config callback with duty_ns and period_ns(Thierry) v3: Correct the subject line (Lee jones) v4: Address comment by Thierry & Paul - Commit message update and fixes for few syntax errors - Add PWM_CRC in Kconfig and Makefile sorted alphabetically - Use the PWM_BASE_CLK as 6000000 for better code readability - Remove the redundant rule of three while calculating pwm level - Use the platform_device in pwm_chip - Use builin_platform_driver CC: Samuel Ortiz Cc: Linus Walleij Cc: Alexandre Courbot Cc: Thierry Reding Cc: Paul Bolle Cc: Paul Gortmaker Signed-off-by: Shobhit Kumar --- drivers/pwm/Kconfig | 7 +++ drivers/pwm/Makefile | 1 + drivers/pwm/pwm-crc.c | 155 ++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 163 insertions(+) create mode 100644 drivers/pwm/pwm-crc.c diff --git a/drivers/pwm/Kconfig b/drivers/pwm/Kconfig index b1541f4..948d9ab 100644 --- a/drivers/pwm/Kconfig +++ b/drivers/pwm/Kconfig @@ -111,6 +111,13 @@ config PWM_CLPS711X To compile this driver as a module, choose M here: the module will be called pwm-clps711x. +config PWM_CRC + bool "Intel Crystalcove (CRC) PWM support" + depends on X86 && INTEL_SOC_PMIC + help + Generic PWM framework driver for Crystalcove (CRC) PMIC based PWM + control. + config PWM_EP93XX tristate "Cirrus Logic EP93xx PWM support" depends on ARCH_EP93XX diff --git a/drivers/pwm/Makefile b/drivers/pwm/Makefile index ec50eb5..d186f35 100644 --- a/drivers/pwm/Makefile +++ b/drivers/pwm/Makefile @@ -8,6 +8,7 @@ obj-$(CONFIG_PWM_BCM_KONA) += pwm-bcm-kona.o obj-$(CONFIG_PWM_BCM2835) += pwm-bcm2835.o obj-$(CONFIG_PWM_BFIN) += pwm-bfin.o obj-$(CONFIG_PWM_CLPS711X) += pwm-clps711x.o +obj-$(CONFIG_PWM_CRC) += pwm-crc.o obj-$(CONFIG_PWM_EP93XX) += pwm-ep93xx.o obj-$(CONFIG_PWM_FSL_FTM) += pwm-fsl-ftm.o obj-$(CONFIG_PWM_IMG) += pwm-img.o diff --git a/drivers/pwm/pwm-crc.c b/drivers/pwm/pwm-crc.c new file mode 100644 index 0000000..dcd9782 --- /dev/null +++ b/drivers/pwm/pwm-crc.c @@ -0,0 +1,155 @@ +/* + * Copyright (C) 2015 Intel Corporation. All rights reserved. + * + * 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. + * + * 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. + * + * Author: Shobhit Kumar + */ + +#include +#include +#include +#include + +#define PWM0_CLK_DIV 0x4B +#define PWM_OUTPUT_ENABLE (1 << 7) +#define PWM_DIV_CLK_0 0x00 /* DIVIDECLK = BASECLK */ +#define PWM_DIV_CLK_100 0x63 /* DIVIDECLK = BASECLK/100 */ +#define PWM_DIV_CLK_128 0x7F /* DIVIDECLK = BASECLK/128 */ + +#define PWM0_DUTY_CYCLE 0x4E +#define BACKLIGHT_EN 0x51 + +#define PWM_MAX_LEVEL 0xFF + +#define PWM_BASE_CLK 6000000 /* 6 MHz */ +#define PWM_MAX_PERIOD_NS 21333 /* 46.875KHz */ + +/** + * struct crystalcove_pwm - Crystal Cove PWM controller + * @chip: the abstract pwm_chip structure. + * @regmap: the regmap from the parent device. + */ +struct crystalcove_pwm { + struct pwm_chip chip; + struct regmap *regmap; +}; + +static inline struct crystalcove_pwm *to_crc_pwm(struct pwm_chip *pc) +{ + return container_of(pc, struct crystalcove_pwm, chip); +} + +static int crc_pwm_enable(struct pwm_chip *c, struct pwm_device *pwm) +{ + struct crystalcove_pwm *crc_pwm = to_crc_pwm(c); + + regmap_write(crc_pwm->regmap, BACKLIGHT_EN, 1); + + return 0; +} + +static void crc_pwm_disable(struct pwm_chip *c, struct pwm_device *pwm) +{ + struct crystalcove_pwm *crc_pwm = to_crc_pwm(c); + + regmap_write(crc_pwm->regmap, BACKLIGHT_EN, 0); +} + +static int crc_pwm_config(struct pwm_chip *c, struct pwm_device *pwm, + int duty_ns, int period_ns) +{ + struct crystalcove_pwm *crc_pwm = to_crc_pwm(c); + struct device *dev = crc_pwm->chip.dev; + int level; + + if (period_ns > PWM_MAX_PERIOD_NS) { + dev_err(dev, "un-supported period_ns\n"); + return -EINVAL; + } + + if (pwm->period != period_ns) { + int clk_div; + + /* changing the clk divisor, need to disable fisrt */ + crc_pwm_disable(c, pwm); + clk_div = PWM_BASE_CLK * period_ns / NSEC_PER_SEC; + + regmap_write(crc_pwm->regmap, PWM0_CLK_DIV, + clk_div | PWM_OUTPUT_ENABLE); + + /* enable back */ + crc_pwm_enable(c, pwm); + } + + /* change the pwm duty cycle */ + level = duty_ns * PWM_MAX_LEVEL / period_ns; + regmap_write(crc_pwm->regmap, PWM0_DUTY_CYCLE, level); + + return 0; +} + +static const struct pwm_ops crc_pwm_ops = { + .config = crc_pwm_config, + .enable = crc_pwm_enable, + .disable = crc_pwm_disable, +}; + +static int crystalcove_pwm_probe(struct platform_device *pdev) +{ + struct crystalcove_pwm *pwm; + int retval; + struct device *dev = pdev->dev.parent; + struct intel_soc_pmic *pmic = dev_get_drvdata(dev); + + pwm = devm_kzalloc(&pdev->dev, sizeof(*pwm), GFP_KERNEL); + if (!pwm) + return -ENOMEM; + + pwm->chip.dev = &pdev->dev; + pwm->chip.ops = &crc_pwm_ops; + pwm->chip.base = -1; + pwm->chip.npwm = 1; + + /* get the PMIC regmap */ + pwm->regmap = pmic->regmap; + + retval = pwmchip_add(&pwm->chip); + if (retval < 0) + return retval; + + platform_set_drvdata(pdev, pwm); + + return 0; +} + +static int crystalcove_pwm_remove(struct platform_device *pdev) +{ + struct crystalcove_pwm *pwm = platform_get_drvdata(pdev); + int retval; + + retval = pwmchip_remove(&pwm->chip); + if (retval < 0) + return retval; + + dev_dbg(&pdev->dev, "crc-pwm driver removed\n"); + + return 0; +} + +static struct platform_driver crystalcove_pwm_driver = { + .probe = crystalcove_pwm_probe, + .remove = crystalcove_pwm_remove, + .driver = { + .name = "crystal_cove_pwm", + }, +}; + +builtin_platform_driver(crystalcove_pwm_driver); -- 1.9.1 -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in Please read the FAQ at http://www.tux.org/lkml/