From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-11.4 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,MIME_BASE64_TEXT,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, UNPARSEABLE_RELAY,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id D1FEBC433DF for ; Wed, 29 Jul 2020 08:18:30 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id A1114207F5 for ; Wed, 29 Jul 2020 08:18:30 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="iDiyH8sJ" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728053AbgG2IS3 (ORCPT ); Wed, 29 Jul 2020 04:18:29 -0400 Received: from mailgw02.mediatek.com ([210.61.82.184]:53386 "EHLO mailgw02.mediatek.com" rhost-flags-OK-FAIL-OK-FAIL) by vger.kernel.org with ESMTP id S1727907AbgG2ISZ (ORCPT ); Wed, 29 Jul 2020 04:18:25 -0400 X-UUID: f9ca2b709783475f8fbce760d8f49a8e-20200729 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=mediatek.com; s=dk; h=Content-Transfer-Encoding:Content-Type:MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:CC:To:From; bh=4HoCUm1VKa+OVqJwqdlK9Is/oFM+0Id/fxBkQMe/9cU=; b=iDiyH8sJRZXAJXv3rFoV5pML4Thnsjy759HPsYVFLWpEDKwuJQRv7bA1Xe/6+NwWC1fgSlh4Zd9bv0t58XTlWlgBqkcuOFllKqp3wD3+Z0ex8vpVvSGhkf6L50Mj6rQaalbJs754nkH95aQ/sXtEvLTod/CsoIplHVN/e7zYgxk=; X-UUID: f9ca2b709783475f8fbce760d8f49a8e-20200729 Received: from mtkcas07.mediatek.inc [(172.21.101.84)] by mailgw02.mediatek.com (envelope-from ) (Cellopoint E-mail Firewall v4.1.10 Build 0809 with TLS) with ESMTP id 1070123174; Wed, 29 Jul 2020 16:18:13 +0800 Received: from MTKCAS06.mediatek.inc (172.21.101.30) by mtkmbs02n2.mediatek.inc (172.21.101.101) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Wed, 29 Jul 2020 16:18:10 +0800 Received: from mtkswgap22.mediatek.inc (172.21.77.33) by MTKCAS06.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.0.1497.2 via Frontend Transport; Wed, 29 Jul 2020 16:18:10 +0800 From: Neal Liu To: Rob Herring , Matthias Brugger CC: Neal Liu , , , , lkml , Subject: [PATCH v4 2/2] soc: mediatek: add mtk-devapc driver Date: Wed, 29 Jul 2020 16:18:10 +0800 Message-ID: <1596010690-13178-3-git-send-email-neal.liu@mediatek.com> X-Mailer: git-send-email 1.7.9.5 In-Reply-To: <1596010690-13178-1-git-send-email-neal.liu@mediatek.com> References: <1596010690-13178-1-git-send-email-neal.liu@mediatek.com> MIME-Version: 1.0 Content-Type: text/plain X-TM-SNTS-SMTP: F4037C3EF092712B35F92E4A59BA033C2B72336223F6C9CDEDC4DC3748514F6C2000:8 X-MTK: N Content-Transfer-Encoding: base64 Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org TWVkaWFUZWsgYnVzIGZhYnJpYyBwcm92aWRlcyBUcnVzdFpvbmUgc2VjdXJpdHkgc3VwcG9ydCBh bmQgZGF0YQ0KcHJvdGVjdGlvbiB0byBwcmV2ZW50IHNsYXZlcyBmcm9tIGJlaW5nIGFjY2Vzc2Vk IGJ5IHVuZXhwZWN0ZWQNCm1hc3RlcnMuDQpUaGUgc2VjdXJpdHkgdmlvbGF0aW9uIGlzIGxvZ2dl ZCBhbmQgc2VudCB0byB0aGUgcHJvY2Vzc29yIGZvcg0KZnVydGhlciBhbmFseXNpcyBvciBjb3Vu dGVybWVhc3VyZXMuDQoNCkFueSBvY2N1cnJlbmNlIG9mIHNlY3VyaXR5IHZpb2xhdGlvbiB3b3Vs ZCByYWlzZSBhbiBpbnRlcnJ1cHQsIGFuZA0KaXQgd2lsbCBiZSBoYW5kbGVkIGJ5IG10ay1kZXZh cGMgZHJpdmVyLiBUaGUgdmlvbGF0aW9uDQppbmZvcm1hdGlvbiBpcyBwcmludGVkIGluIG9yZGVy IHRvIGZpbmQgdGhlIG11cmRlcmVyLg0KDQpTaWduZWQtb2ZmLWJ5OiBOZWFsIExpdSA8bmVhbC5s aXVAbWVkaWF0ZWsuY29tPg0KLS0tDQogZHJpdmVycy9zb2MvbWVkaWF0ZWsvS2NvbmZpZyAgICAg IHwgICAgOSArKw0KIGRyaXZlcnMvc29jL21lZGlhdGVrL01ha2VmaWxlICAgICB8ICAgIDEgKw0K IGRyaXZlcnMvc29jL21lZGlhdGVrL210ay1kZXZhcGMuYyB8ICAzMjMgKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKw0KIGRyaXZlcnMvc29jL21lZGlhdGVrL210ay1kZXZhcGMu aCB8ICAgNTQgKysrKysrKw0KIDQgZmlsZXMgY2hhbmdlZCwgMzg3IGluc2VydGlvbnMoKykNCiBj cmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9zb2MvbWVkaWF0ZWsvbXRrLWRldmFwYy5jDQogY3Jl YXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvc29jL21lZGlhdGVrL210ay1kZXZhcGMuaA0KDQpkaWZm IC0tZ2l0IGEvZHJpdmVycy9zb2MvbWVkaWF0ZWsvS2NvbmZpZyBiL2RyaXZlcnMvc29jL21lZGlh dGVrL0tjb25maWcNCmluZGV4IDU5YTU2Y2QuLjExNzdjOTggMTAwNjQ0DQotLS0gYS9kcml2ZXJz L3NvYy9tZWRpYXRlay9LY29uZmlnDQorKysgYi9kcml2ZXJzL3NvYy9tZWRpYXRlay9LY29uZmln DQpAQCAtMTcsNiArMTcsMTUgQEAgY29uZmlnIE1US19DTURRDQogCSAgdGltZSBsaW1pdGF0aW9u LCBzdWNoIGFzIHVwZGF0aW5nIGRpc3BsYXkgY29uZmlndXJhdGlvbiBkdXJpbmcgdGhlDQogCSAg dmJsYW5rLg0KIA0KK2NvbmZpZyBNVEtfREVWQVBDDQorCXRyaXN0YXRlICJNZWRpYXRlayBEZXZp Y2UgQVBDIFN1cHBvcnQiDQorCWhlbHANCisJICBTYXkgeWVzIGhlcmUgdG8gZW5hYmxlIHN1cHBv cnQgZm9yIE1lZGlhdGVrIERldmljZSBBUEMgZHJpdmVyLg0KKwkgIFRoaXMgZHJpdmVyIGlzIG1h aW5seSB1c2VkIHRvIGhhbmRsZSB0aGUgdmlvbGF0aW9uIHdoaWNoIGNhdGNoZXMNCisJICB1bmV4 cGVjdGVkIHRyYW5zYWN0aW9uLg0KKwkgIFRoZSB2aW9sYXRpb24gaW5mb3JtYXRpb24gaXMgbG9n Z2VkIGZvciBmdXJ0aGVyIGFuYWx5c2lzIG9yDQorCSAgY291bnRlcm1lYXN1cmVzLg0KKw0KIGNv bmZpZyBNVEtfSU5GUkFDRkcNCiAJYm9vbCAiTWVkaWFUZWsgSU5GUkFDRkcgU3VwcG9ydCINCiAJ c2VsZWN0IFJFR01BUA0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc29jL21lZGlhdGVrL01ha2VmaWxl IGIvZHJpdmVycy9zb2MvbWVkaWF0ZWsvTWFrZWZpbGUNCmluZGV4IDAxZjlmODcuLmFiZmQ0YmEg MTAwNjQ0DQotLS0gYS9kcml2ZXJzL3NvYy9tZWRpYXRlay9NYWtlZmlsZQ0KKysrIGIvZHJpdmVy cy9zb2MvbWVkaWF0ZWsvTWFrZWZpbGUNCkBAIC0xLDUgKzEsNiBAQA0KICMgU1BEWC1MaWNlbnNl LUlkZW50aWZpZXI6IEdQTC0yLjAtb25seQ0KIG9iai0kKENPTkZJR19NVEtfQ01EUSkgKz0gbXRr LWNtZHEtaGVscGVyLm8NCitvYmotJChDT05GSUdfTVRLX0RFVkFQQykgKz0gbXRrLWRldmFwYy5v DQogb2JqLSQoQ09ORklHX01US19JTkZSQUNGRykgKz0gbXRrLWluZnJhY2ZnLm8NCiBvYmotJChD T05GSUdfTVRLX1BNSUNfV1JBUCkgKz0gbXRrLXBtaWMtd3JhcC5vDQogb2JqLSQoQ09ORklHX01U S19TQ1BTWVMpICs9IG10ay1zY3BzeXMubw0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc29jL21lZGlh dGVrL210ay1kZXZhcGMuYyBiL2RyaXZlcnMvc29jL21lZGlhdGVrL210ay1kZXZhcGMuYw0KbmV3 IGZpbGUgbW9kZSAxMDA2NDQNCmluZGV4IDAwMDAwMDAuLmRiNzUxZDANCi0tLSAvZGV2L251bGwN CisrKyBiL2RyaXZlcnMvc29jL21lZGlhdGVrL210ay1kZXZhcGMuYw0KQEAgLTAsMCArMSwzMjMg QEANCisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMA0KKy8qDQorICogQ29weXJp Z2h0IChDKSAyMDIwIE1lZGlhVGVrIEluYy4NCisgKi8NCisNCisjaW5jbHVkZSA8bGludXgvY2xr Lmg+DQorI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPg0KKyNpbmNsdWRlIDxsaW51eC9pb3Bv bGwuaD4NCisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+DQorI2luY2x1ZGUgPGxpbnV4L3BsYXRm b3JtX2RldmljZS5oPg0KKyNpbmNsdWRlIDxsaW51eC9vZl9kZXZpY2UuaD4NCisjaW5jbHVkZSA8 bGludXgvb2ZfaXJxLmg+DQorI2luY2x1ZGUgPGxpbnV4L29mX2FkZHJlc3MuaD4NCisjaW5jbHVk ZSAibXRrLWRldmFwYy5oIg0KKw0KK3N0YXRpYyBpbnQgZ2V0X3NoaWZ0X2dyb3VwKHN0cnVjdCBt dGtfZGV2YXBjX2NvbnRleHQgKmN0eCkNCit7DQorCXUzMiB2aW9fc2hpZnRfc3RhOw0KKwl2b2lk IF9faW9tZW0gKnJlZzsNCisNCisJcmVnID0gY3R4LT5kZXZhcGNfcGRfYmFzZSArIGN0eC0+b2Zm c2V0LT52aW9fc2hpZnRfc3RhOw0KKwl2aW9fc2hpZnRfc3RhID0gcmVhZGwocmVnKTsNCisNCisJ aWYgKHZpb19zaGlmdF9zdGEpDQorCQlyZXR1cm4gX19mZnModmlvX3NoaWZ0X3N0YSk7DQorDQor CXJldHVybiAtRUlPOw0KK30NCisNCitzdGF0aWMgdm9pZCBjbGVhcl92aW9fc3RhdHVzKHN0cnVj dCBtdGtfZGV2YXBjX2NvbnRleHQgKmN0eCwgdTMyIG1vZHVsZSkNCit7DQorCXZvaWQgX19pb21l bSAqcmVnOw0KKw0KKwlyZWcgPSBjdHgtPmRldmFwY19wZF9iYXNlICsgY3R4LT5vZmZzZXQtPnZp b19zdGE7DQorCXJlZyArPSAweDQgKiBWSU9fTU9EX1RPX1JFR19JTkQobW9kdWxlKTsNCisNCisJ d3JpdGVsKDB4MSA8PCBWSU9fTU9EX1RPX1JFR19PRkYobW9kdWxlKSwgcmVnKTsNCit9DQorDQor c3RhdGljIHZvaWQgbWFza19tb2R1bGVfaXJxKHN0cnVjdCBtdGtfZGV2YXBjX2NvbnRleHQgKmN0 eCwgdTMyIG1vZHVsZSwNCisJCQkgICAgYm9vbCBtYXNrKQ0KK3sNCisJdm9pZCBfX2lvbWVtICpy ZWc7DQorCXUzMiB2YWx1ZTsNCisNCisJcmVnID0gY3R4LT5kZXZhcGNfcGRfYmFzZSArIGN0eC0+ b2Zmc2V0LT52aW9fbWFzazsNCisJcmVnICs9IDB4NCAqIFZJT19NT0RfVE9fUkVHX0lORChtb2R1 bGUpOw0KKw0KKwl2YWx1ZSA9IHJlYWRsKHJlZyk7DQorCWlmIChtYXNrKQ0KKwkJdmFsdWUgfD0g KDB4MSA8PCBWSU9fTU9EX1RPX1JFR19PRkYobW9kdWxlKSk7DQorCWVsc2UNCisJCXZhbHVlICY9 IH4oMHgxIDw8IFZJT19NT0RfVE9fUkVHX09GRihtb2R1bGUpKTsNCisNCisJd3JpdGVsKHZhbHVl LCByZWcpOw0KK30NCisNCisjZGVmaW5lIFBIWV9ERVZBUENfVElNRU9VVAkweDEwMDAwDQorDQor LyoNCisgKiBzeW5jX3Zpb19kYmcgLSBkbyAic2hpZnQiIG1lY2hhbnNpbSIgdG8gZ2V0IGZ1bGwg dmlvbGF0aW9uIGluZm9ybWF0aW9uLg0KKyAqICAgICAgICAgICAgICAgIHNoaWZ0IG1lY2hhbmlz bSBpcyBkZXBlbmRzIG9uIGRldmFwYyBoYXJkd2FyZSBkZXNpZ24uDQorICogICAgICAgICAgICAg ICAgTWVkaWF0ZWsgZGV2YXBjIHNldCBtdWx0aXBsZSBzbGF2ZXMgYXMgYSBncm91cC4gV2hlbiB2 aW9sYXRpb24NCisgKiAgICAgICAgICAgICAgICBpcyB0cmlnZ2VyZWQsIHZpb2xhdGlvbiBpbmZv IGlzIGtlcHQgaW5zaWRlIGRldmFwYyBoYXJkd2FyZS4NCisgKiAgICAgICAgICAgICAgICBEcml2 ZXIgc2hvdWxkIGRvIHNoaWZ0IG1lY2hhbnNpbSB0byAic2hpZnQiIGZ1bGwgdmlvbGF0aW9uDQor ICogICAgICAgICAgICAgICAgaW5mbyB0byBWSU9fREJHcyByZWdpc3RlcnMuDQorICoNCisgKi8N CitzdGF0aWMgaW50IHN5bmNfdmlvX2RiZyhzdHJ1Y3QgbXRrX2RldmFwY19jb250ZXh0ICpjdHgs IHUzMiBzaGlmdF9iaXQpDQorew0KKwl2b2lkIF9faW9tZW0gKnBkX3Zpb19zaGlmdF9zdGFfcmVn Ow0KKwl2b2lkIF9faW9tZW0gKnBkX3Zpb19zaGlmdF9zZWxfcmVnOw0KKwl2b2lkIF9faW9tZW0g KnBkX3Zpb19zaGlmdF9jb25fcmVnOw0KKwlpbnQgcmV0Ow0KKwl1MzIgdmFsOw0KKw0KKwlwZF92 aW9fc2hpZnRfc3RhX3JlZyA9IGN0eC0+ZGV2YXBjX3BkX2Jhc2UgKyBjdHgtPm9mZnNldC0+dmlv X3NoaWZ0X3N0YTsNCisJcGRfdmlvX3NoaWZ0X3NlbF9yZWcgPSBjdHgtPmRldmFwY19wZF9iYXNl ICsgY3R4LT5vZmZzZXQtPnZpb19zaGlmdF9zZWw7DQorCXBkX3Zpb19zaGlmdF9jb25fcmVnID0g Y3R4LT5kZXZhcGNfcGRfYmFzZSArIGN0eC0+b2Zmc2V0LT52aW9fc2hpZnRfY29uOw0KKw0KKwkv KiBFbmFibGUgc2hpZnQgbWVjaGFuc2ltICovDQorCXdyaXRlbCgweDEgPDwgc2hpZnRfYml0LCBw ZF92aW9fc2hpZnRfc2VsX3JlZyk7DQorCXdyaXRlbCgweDEsIHBkX3Zpb19zaGlmdF9jb25fcmVn KTsNCisNCisJcmV0ID0gcmVhZGxfcG9sbF90aW1lb3V0KHBkX3Zpb19zaGlmdF9jb25fcmVnLCB2 YWwsIHZhbCA9PSAweDMsIDAsDQorCQkJCSBQSFlfREVWQVBDX1RJTUVPVVQpOw0KKwlpZiAocmV0 KQ0KKwkJZGV2X2VycihjdHgtPmRldiwgIiVzOiBTaGlmdCB2aW9sYXRpb24gaW5mbyBmYWlsZWRc biIsIF9fZnVuY19fKTsNCisNCisJLyogRGlzYWJsZSBzaGlmdCBtZWNoYW5pc20gKi8NCisJd3Jp dGVsKDB4MCwgcGRfdmlvX3NoaWZ0X2Nvbl9yZWcpOw0KKwl3cml0ZWwoMHgwLCBwZF92aW9fc2hp ZnRfc2VsX3JlZyk7DQorCXdyaXRlbCgweDEgPDwgc2hpZnRfYml0LCBwZF92aW9fc2hpZnRfc3Rh X3JlZyk7DQorDQorCXJldHVybiByZXQ7DQorfQ0KKw0KK3N0YXRpYyB2b2lkIGRldmFwY192aW9f aW5mb19wcmludChzdHJ1Y3QgbXRrX2RldmFwY19jb250ZXh0ICpjdHgpDQorew0KKwlzdHJ1Y3Qg bXRrX2RldmFwY192aW9faW5mbyAqdmlvX2luZm8gPSBjdHgtPnZpb19pbmZvOw0KKw0KKwkvKiBQ cmludCB2aW9sYXRpb24gaW5mb3JtYXRpb24gKi8NCisJaWYgKHZpb19pbmZvLT53cml0ZSkNCisJ CWRldl9pbmZvKGN0eC0+ZGV2LCAiV3JpdGUgVmlvbGF0aW9uXG4iKTsNCisJZWxzZSBpZiAodmlv X2luZm8tPnJlYWQpDQorCQlkZXZfaW5mbyhjdHgtPmRldiwgIlJlYWQgVmlvbGF0aW9uXG4iKTsN CisNCisJZGV2X2luZm8oY3R4LT5kZXYsICJWaW8gQWRkcjoweCV4LCBIaWdoOjB4JXgsIEJ1cyBJ RDoweCV4LCBEb20gSUQ6JXhcbiIsDQorCQkgdmlvX2luZm8tPnZpb19hZGRyLCB2aW9faW5mby0+ dmlvX2FkZHJfaGlnaCwNCisJCSB2aW9faW5mby0+bWFzdGVyX2lkLCB2aW9faW5mby0+ZG9tYWlu X2lkKTsNCit9DQorDQorLyoNCisgKiBkZXZhcGNfZXh0cmFjdF92aW9fZGJnIC0gZXh0cmFjdCBm dWxsIHZpb2xhdGlvbiBpbmZvcm1hdGlvbiBhZnRlciBkb2luZw0KKyAqICAgICAgICAgICAgICAg ICAgICAgICAgICBzaGlmdCBtZWNoYW5pc20uDQorICovDQorc3RhdGljIHZvaWQgZGV2YXBjX2V4 dHJhY3RfdmlvX2RiZyhzdHJ1Y3QgbXRrX2RldmFwY19jb250ZXh0ICpjdHgpDQorew0KKwljb25z dCBzdHJ1Y3QgbXRrX2RldmFwY192aW9fZGJncyAqdmlvX2RiZ3M7DQorCXN0cnVjdCBtdGtfZGV2 YXBjX3Zpb19pbmZvICp2aW9faW5mbzsNCisJdm9pZCBfX2lvbWVtICp2aW9fZGJnMF9yZWc7DQor CXZvaWQgX19pb21lbSAqdmlvX2RiZzFfcmVnOw0KKwl1MzIgZGJnMDsNCisNCisJdmlvX2RiZzBf cmVnID0gY3R4LT5kZXZhcGNfcGRfYmFzZSArIGN0eC0+b2Zmc2V0LT52aW9fZGJnMDsNCisJdmlv X2RiZzFfcmVnID0gY3R4LT5kZXZhcGNfcGRfYmFzZSArIGN0eC0+b2Zmc2V0LT52aW9fZGJnMTsN CisNCisJdmlvX2RiZ3MgPSBjdHgtPnZpb19kYmdzOw0KKwl2aW9faW5mbyA9IGN0eC0+dmlvX2lu Zm87DQorDQorCS8qIFN0YXJ0cyB0byBleHRyYWN0IHZpb2xhdGlvbiBpbmZvcm1hdGlvbiAqLw0K KwlkYmcwID0gcmVhZGwodmlvX2RiZzBfcmVnKTsNCisJdmlvX2luZm8tPnZpb19hZGRyID0gcmVh ZGwodmlvX2RiZzFfcmVnKTsNCisNCisJdmlvX2luZm8tPm1hc3Rlcl9pZCA9IChkYmcwICYgdmlv X2RiZ3MtPm1zdGlkLm1hc2spID4+DQorCQkJICAgICAgdmlvX2RiZ3MtPm1zdGlkLnN0YXJ0Ow0K Kwl2aW9faW5mby0+ZG9tYWluX2lkID0gKGRiZzAgJiB2aW9fZGJncy0+ZG1uaWQubWFzaykgPj4N CisJCQkgICAgICB2aW9fZGJncy0+ZG1uaWQuc3RhcnQ7DQorCXZpb19pbmZvLT53cml0ZSA9ICgo ZGJnMCAmIHZpb19kYmdzLT52aW9fdy5tYXNrKSA+Pg0KKwkJCSAgICB2aW9fZGJncy0+dmlvX3cu c3RhcnQpID09IDE7DQorCXZpb19pbmZvLT5yZWFkID0gKChkYmcwICYgdmlvX2RiZ3MtPnZpb19y Lm1hc2spID4+DQorCQkJICB2aW9fZGJncy0+dmlvX3Iuc3RhcnQpID09IDE7DQorCXZpb19pbmZv LT52aW9fYWRkcl9oaWdoID0gKGRiZzAgJiB2aW9fZGJncy0+YWRkcl9oLm1hc2spID4+DQorCQkJ CSAgdmlvX2RiZ3MtPmFkZHJfaC5zdGFydDsNCisNCisJZGV2YXBjX3Zpb19pbmZvX3ByaW50KGN0 eCk7DQorfQ0KKw0KKy8qDQorICogZGV2YXBjX2R1bXBfdmlvX2RiZyAtIHNoaWZ0IGFuZCBkdW1w IHRoZSB2aW9sYXRpb24gZGVidWcgaW5mb3JtYXRpb24uDQorICovDQorc3RhdGljIHZvaWQgZGV2 YXBjX2R1bXBfdmlvX2RiZyhzdHJ1Y3QgbXRrX2RldmFwY19jb250ZXh0ICpjdHgpDQorew0KKwlp bnQgc2hpZnRfYml0Ow0KKw0KKwkvKg0KKwkgKiBBbGwgZ3JvdXBzIHZpb19pZHggYmVsb25ncyB0 byBpcyBkZXRlcm1pbmVkIGJ5IGhhcmR3YXJlLA0KKwkgKiBhbmQgZWFjaCBncm91cCBjYW4gb25s eSBtYWludGFpbiBvbmUgdmlvbGF0aW9uIGluZm8gYXQgYSB0aW1lLg0KKwkgKg0KKwkgKiBTY2Fu IGFsbCBncm91cHMgd2hpY2ggdmlvX2lkeCBoYXMgdmlvbGF0aW9uLCBkdW1wIGl0IGZvcg0KKwkg KiBmdXJ0aGVyIGFuYWx5c2lzLg0KKwkgKi8NCisJd2hpbGUgKDEpIHsNCisJCXNoaWZ0X2JpdCA9 IGdldF9zaGlmdF9ncm91cChjdHgpOw0KKw0KKwkJaWYgKHNoaWZ0X2JpdCA+PSAwICYmIHNoaWZ0 X2JpdCA8PSAzMSkgew0KKwkJCWlmICghc3luY192aW9fZGJnKGN0eCwgc2hpZnRfYml0KSkNCisJ CQkJZGV2YXBjX2V4dHJhY3RfdmlvX2RiZyhjdHgpOw0KKw0KKwkJCWNvbnRpbnVlOw0KKwkJfQ0K Kw0KKwkJYnJlYWs7DQorCX0NCit9DQorDQorLyoNCisgKiBkZXZhcGNfdmlvbGF0aW9uX2lycSAt IHRoZSBkZXZhcGMgSW50ZXJydXB0IFNlcnZpY2UgUm91dGluZSAoSVNSKSB3aWxsIGR1bXANCisg KiAgICAgICAgICAgICAgICAgICAgICAgIHZpb2xhdGlvbiBpbmZvcm1hdGlvbiBpbmNsdWRpbmcg d2hpY2ggbWFzdGVyIHZpb2xhdGVzDQorICogICAgICAgICAgICAgICAgICAgICAgICBhY2Nlc3Mg c2xhdmUuDQorICovDQorc3RhdGljIGlycXJldHVybl90IGRldmFwY192aW9sYXRpb25faXJxKGlu dCBpcnFfbnVtYmVyLA0KKwkJCQkJc3RydWN0IG10a19kZXZhcGNfY29udGV4dCAqY3R4KQ0KK3sN CisJdTMyIHZpb19pZHg7DQorDQorCS8qDQorCSAqIE1hc2sgc2xhdmUncyBpcnEgYmVmb3JlIGNs ZWFyaW5nIHZpbyBzdGF0dXMuDQorCSAqIE11c3QgZG8gaXQgdG8gYXZvaWQgbmVzdGVkIGludGVy cnVwdCBhbmQgcHJldmVudA0KKwkgKiB1bmV4cGVjdGVkIGJlaGF2aW9yLg0KKwkgKi8NCisJZm9y ICh2aW9faWR4ID0gMDsgdmlvX2lkeCA8IGN0eC0+dmlvX2lkeF9udW07IHZpb19pZHgrKykNCisJ CW1hc2tfbW9kdWxlX2lycShjdHgsIHZpb19pZHgsIHRydWUpOw0KKw0KKwlkZXZhcGNfZHVtcF92 aW9fZGJnKGN0eCk7DQorDQorCS8qDQorCSAqIEVuc3VyZSB0aGF0IHZpb2xhdGlvbiBpbmZvIGFy ZSB3cml0dGVuDQorCSAqIGJlZm9yZSBmdXJ0aGVyIG9wZXJhdGlvbnMNCisJICovDQorCXNtcF9t YigpOw0KKw0KKwlmb3IgKHZpb19pZHggPSAwOyB2aW9faWR4IDwgY3R4LT52aW9faWR4X251bTsg dmlvX2lkeCsrKSB7DQorCQljbGVhcl92aW9fc3RhdHVzKGN0eCwgdmlvX2lkeCk7DQorCQltYXNr X21vZHVsZV9pcnEoY3R4LCB2aW9faWR4LCBmYWxzZSk7DQorCX0NCisNCisJcmV0dXJuIElSUV9I QU5ETEVEOw0KK30NCisNCisvKg0KKyAqIHN0YXJ0X2RldmFwYyAtIHVubWFzayBzbGF2ZSdzIGly cSB0byBzdGFydCByZWNlaXZpbmcgZGV2YXBjIHZpb2xhdGlvbi4NCisgKi8NCitzdGF0aWMgdm9p ZCBzdGFydF9kZXZhcGMoc3RydWN0IG10a19kZXZhcGNfY29udGV4dCAqY3R4KQ0KK3sNCisJdTMy IHZpb19pZHg7DQorDQorCWZvciAodmlvX2lkeCA9IDA7IHZpb19pZHggPCBjdHgtPnZpb19pZHhf bnVtOyB2aW9faWR4KyspDQorCQltYXNrX21vZHVsZV9pcnEoY3R4LCB2aW9faWR4LCBmYWxzZSk7 DQorfQ0KKw0KK3N0YXRpYyBjb25zdCBzdHJ1Y3QgbXRrX2RldmFwY19wZF9vZmZzZXQgbXQ2Nzc5 X3BkX29mZnNldCA9IHsNCisJLnZpb19tYXNrID0gMHgwLA0KKwkudmlvX3N0YSA9IDB4NDAwLA0K KwkudmlvX2RiZzAgPSAweDkwMCwNCisJLnZpb19kYmcxID0gMHg5MDQsDQorCS5hcGNfY29uID0g MHhGMDAsDQorCS52aW9fc2hpZnRfc3RhID0gMHhGMTAsDQorCS52aW9fc2hpZnRfc2VsID0gMHhG MTQsDQorCS52aW9fc2hpZnRfY29uID0gMHhGMjAsDQorfTsNCisNCitzdGF0aWMgY29uc3Qgc3Ry dWN0IG10a19kZXZhcGNfdmlvX2RiZ3MgbXQ2Nzc5X3Zpb19kYmdzID0gew0KKwkubXN0aWQgPSAg ezB4MDAwMEZGRkYsIDB4MH0sDQorCS5kbW5pZCA9ICB7MHgwMDNGMDAwMCwgMHgxMH0sDQorCS52 aW9fdyA9ICB7MHgwMDQwMDAwMCwgMHgxNn0sDQorCS52aW9fciA9ICB7MHgwMDgwMDAwMCwgMHgx N30sDQorCS5hZGRyX2ggPSB7MHgwRjAwMDAwMCwgMHgxOH0sDQorfTsNCisNCitzdGF0aWMgY29u c3Qgc3RydWN0IG10a19kZXZhcGNfY29udGV4dCBkZXZhcGNfbXQ2Nzc5ID0gew0KKwkudmlvX2lk eF9udW0gPSA1MTAsDQorCS5vZmZzZXQgPSAmbXQ2Nzc5X3BkX29mZnNldCwNCisJLnZpb19kYmdz ID0gJm10Njc3OV92aW9fZGJncywNCit9Ow0KKw0KK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgb2ZfZGV2 aWNlX2lkIG10a19kZXZhcGNfZHRfbWF0Y2hbXSA9IHsNCisJew0KKwkJLmNvbXBhdGlibGUgPSAi bWVkaWF0ZWssbXQ2Nzc5LWRldmFwYyIsDQorCQkuZGF0YSA9ICZkZXZhcGNfbXQ2Nzc5LA0KKwl9 LCB7DQorCX0sDQorfTsNCisNCitzdGF0aWMgaW50IG10a19kZXZhcGNfcHJvYmUoc3RydWN0IHBs YXRmb3JtX2RldmljZSAqcGRldikNCit7DQorCXN0cnVjdCBkZXZpY2Vfbm9kZSAqbm9kZSA9IHBk ZXYtPmRldi5vZl9ub2RlOw0KKwlzdHJ1Y3QgbXRrX2RldmFwY19jb250ZXh0ICpjdHg7DQorCXN0 cnVjdCBjbGsgKmRldmFwY19pbmZyYV9jbGs7DQorCXUzMiBkZXZhcGNfaXJxOw0KKwlpbnQgcmV0 Ow0KKw0KKwlpZiAoSVNfRVJSKG5vZGUpKQ0KKwkJcmV0dXJuIC1FTk9ERVY7DQorDQorCWN0eCA9 IGRldm1fa3phbGxvYygmcGRldi0+ZGV2LCBzaXplb2YoKmN0eCksIEdGUF9LRVJORUwpOw0KKwlp ZiAoIWN0eCkNCisJCXJldHVybiAtRU5PTUVNOw0KKw0KKwljdHggPSAoc3RydWN0IG10a19kZXZh cGNfY29udGV4dCAqKW9mX2RldmljZV9nZXRfbWF0Y2hfZGF0YSgmcGRldi0+ZGV2KTsNCisJY3R4 LT5kZXYgPSAmcGRldi0+ZGV2Ow0KKw0KKwljdHgtPnZpb19pbmZvID0gZGV2bV9remFsbG9jKCZw ZGV2LT5kZXYsDQorCQkJCSAgICAgc2l6ZW9mKHN0cnVjdCBtdGtfZGV2YXBjX3Zpb19pbmZvKSwN CisJCQkJICAgICBHRlBfS0VSTkVMKTsNCisJaWYgKCFjdHgtPnZpb19pbmZvKQ0KKwkJcmV0dXJu IC1FTk9NRU07DQorDQorCWN0eC0+ZGV2YXBjX3BkX2Jhc2UgPSBvZl9pb21hcChub2RlLCAwKTsN CisJaWYgKCFjdHgtPmRldmFwY19wZF9iYXNlKQ0KKwkJcmV0dXJuIC1FSU5WQUw7DQorDQorCWRl dmFwY19pcnEgPSBpcnFfb2ZfcGFyc2VfYW5kX21hcChub2RlLCAwKTsNCisJaWYgKCFkZXZhcGNf aXJxKQ0KKwkJcmV0dXJuIC1FSU5WQUw7DQorDQorCWRldmFwY19pbmZyYV9jbGsgPSBkZXZtX2Ns a19nZXQoJnBkZXYtPmRldiwgImRldmFwYy1pbmZyYS1jbG9jayIpOw0KKwlpZiAoSVNfRVJSKGRl dmFwY19pbmZyYV9jbGspKQ0KKwkJcmV0dXJuIC1FSU5WQUw7DQorDQorCWlmIChjbGtfcHJlcGFy ZV9lbmFibGUoZGV2YXBjX2luZnJhX2NsaykpDQorCQlyZXR1cm4gLUVJTlZBTDsNCisNCisJcmV0 ID0gZGV2bV9yZXF1ZXN0X2lycSgmcGRldi0+ZGV2LCBkZXZhcGNfaXJxLA0KKwkJCSAgICAgICAo aXJxX2hhbmRsZXJfdClkZXZhcGNfdmlvbGF0aW9uX2lycSwNCisJCQkgICAgICAgSVJRRl9UUklH R0VSX05PTkUsICJkZXZhcGMiLCBjdHgpOw0KKwlpZiAocmV0KQ0KKwkJcmV0dXJuIHJldDsNCisN CisJc3RhcnRfZGV2YXBjKGN0eCk7DQorDQorCXJldHVybiAwOw0KK30NCisNCitzdGF0aWMgaW50 IG10a19kZXZhcGNfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKmRldikNCit7DQorCXJl dHVybiAwOw0KK30NCisNCitzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciBtdGtfZGV2YXBj X2RyaXZlciA9IHsNCisJLnByb2JlID0gbXRrX2RldmFwY19wcm9iZSwNCisJLnJlbW92ZSA9IG10 a19kZXZhcGNfcmVtb3ZlLA0KKwkuZHJpdmVyID0gew0KKwkJLm5hbWUgPSBLQlVJTERfTU9ETkFN RSwNCisJCS5vZl9tYXRjaF90YWJsZSA9IG10a19kZXZhcGNfZHRfbWF0Y2gsDQorCX0sDQorfTsN CisNCittb2R1bGVfcGxhdGZvcm1fZHJpdmVyKG10a19kZXZhcGNfZHJpdmVyKTsNCisNCitNT0RV TEVfREVTQ1JJUFRJT04oIk1lZGlhdGVrIERldmljZSBBUEMgRHJpdmVyIik7DQorTU9EVUxFX0FV VEhPUigiTmVhbCBMaXUgPG5lYWwubGl1QG1lZGlhdGVrLmNvbT4iKTsNCitNT0RVTEVfTElDRU5T RSgiR1BMIik7DQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zb2MvbWVkaWF0ZWsvbXRrLWRldmFwYy5o IGIvZHJpdmVycy9zb2MvbWVkaWF0ZWsvbXRrLWRldmFwYy5oDQpuZXcgZmlsZSBtb2RlIDEwMDY0 NA0KaW5kZXggMDAwMDAwMC4uN2JkN2U2Ng0KLS0tIC9kZXYvbnVsbA0KKysrIGIvZHJpdmVycy9z b2MvbWVkaWF0ZWsvbXRrLWRldmFwYy5oDQpAQCAtMCwwICsxLDU0IEBADQorLyogU1BEWC1MaWNl bnNlLUlkZW50aWZpZXI6IEdQTC0yLjAgKi8NCisvKg0KKyAqIENvcHlyaWdodCAoQykgMjAyMCBN ZWRpYVRlayBJbmMuDQorICovDQorDQorI2lmbmRlZiBfX01US19ERVZBUENfSF9fDQorI2RlZmlu ZSBfX01US19ERVZBUENfSF9fDQorDQorI2RlZmluZSBWSU9fTU9EX1RPX1JFR19JTkQobSkJKCht KSAvIDMyKQ0KKyNkZWZpbmUgVklPX01PRF9UT19SRUdfT0ZGKG0pCSgobSkgJSAzMikNCisNCitz dHJ1Y3QgbXRrX2RldmFwY19wZF9vZmZzZXQgew0KKwl1MzIgdmlvX21hc2s7DQorCXUzMiB2aW9f c3RhOw0KKwl1MzIgdmlvX2RiZzA7DQorCXUzMiB2aW9fZGJnMTsNCisJdTMyIGFwY19jb247DQor CXUzMiB2aW9fc2hpZnRfc3RhOw0KKwl1MzIgdmlvX3NoaWZ0X3NlbDsNCisJdTMyIHZpb19zaGlm dF9jb247DQorfTsNCisNCitzdHJ1Y3QgbXRrX2RldmFwY192aW9fZGJnc19kZXNjIHsNCisJdTMy IG1hc2s7DQorCXUzMiBzdGFydDsNCit9Ow0KKw0KK3N0cnVjdCBtdGtfZGV2YXBjX3Zpb19kYmdz IHsNCisJc3RydWN0IG10a19kZXZhcGNfdmlvX2RiZ3NfZGVzYyBtc3RpZDsNCisJc3RydWN0IG10 a19kZXZhcGNfdmlvX2RiZ3NfZGVzYyBkbW5pZDsNCisJc3RydWN0IG10a19kZXZhcGNfdmlvX2Ri Z3NfZGVzYyB2aW9fdzsNCisJc3RydWN0IG10a19kZXZhcGNfdmlvX2RiZ3NfZGVzYyB2aW9fcjsN CisJc3RydWN0IG10a19kZXZhcGNfdmlvX2RiZ3NfZGVzYyBhZGRyX2g7DQorfTsNCisNCitzdHJ1 Y3QgbXRrX2RldmFwY192aW9faW5mbyB7DQorCWJvb2wgcmVhZDsNCisJYm9vbCB3cml0ZTsNCisJ dTMyIHZpb19hZGRyOw0KKwl1MzIgdmlvX2FkZHJfaGlnaDsNCisJdTMyIG1hc3Rlcl9pZDsNCisJ dTMyIGRvbWFpbl9pZDsNCit9Ow0KKw0KK3N0cnVjdCBtdGtfZGV2YXBjX2NvbnRleHQgew0KKwlz dHJ1Y3QgZGV2aWNlICpkZXY7DQorCXUzMiB2aW9faWR4X251bTsNCisJdm9pZCBfX2lvbWVtICpk ZXZhcGNfcGRfYmFzZTsNCisJc3RydWN0IG10a19kZXZhcGNfdmlvX2luZm8gKnZpb19pbmZvOw0K Kwljb25zdCBzdHJ1Y3QgbXRrX2RldmFwY19wZF9vZmZzZXQgKm9mZnNldDsNCisJY29uc3Qgc3Ry dWN0IG10a19kZXZhcGNfdmlvX2RiZ3MgKnZpb19kYmdzOw0KK307DQorDQorI2VuZGlmIC8qIF9f TVRLX0RFVkFQQ19IX18gKi8NCi0tIA0KMS43LjkuNQ0K From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-13.0 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,UNPARSEABLE_RELAY, URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 2850CC433E0 for ; Wed, 29 Jul 2020 08:29:04 +0000 (UTC) Received: from merlin.infradead.org (merlin.infradead.org [205.233.59.134]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id D85F220838 for ; Wed, 29 Jul 2020 08:29:03 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="ShrM487M"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="iDiyH8sJ" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org D85F220838 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=mediatek.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-mediatek-bounces+linux-mediatek=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=merlin.20170209; h=Sender:Content-Transfer-Encoding: Content-Type:Cc:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To:Message-ID:Date: Subject:To:From:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=GruqVRTxIPQpDABjdkMERb0xiGA+8LYX7IrEoKGyJRw=; b=ShrM487MJ7JLnO4LnN/lPqlAk kAWlYYRjNlGgaVDeMWpYKQDZru69VHC7eKkw/8lYf5Eg8lKF8Oiw/lPuK+DB69OelGa0OxyYa+SgO L2ajpV9l6jwHr+lFvitl+ZANFuh8adQmpqOsW5P6CbSReaxHQRbifHWRwdv9k4OH4JVbIdxKkbeBw g2e/SDzjzjX6ltBrTGsrxyCK6j4a4M02Fp63E4gESzxpmx2teOkNnuyj6xcsRnkrcRzvgSFitB+vG dpgq59Y8o2yCWJMuMls2VVCMH50OfHDKYzkyp5Cd+cqzMQjWDuY2Sa95a/I70M9IWymSo5Y6RMLCq t3e8imT2g==; Received: from localhost ([::1] helo=merlin.infradead.org) by merlin.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1k0hSH-0005nV-7s; Wed, 29 Jul 2020 08:28:53 +0000 Received: from mailgw01.mediatek.com ([216.200.240.184]) by merlin.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1k0hRu-0005cG-10; Wed, 29 Jul 2020 08:28:33 +0000 X-UUID: 83c25699cde941ba9740561f687af8c0-20200729 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=mediatek.com; s=dk; h=Content-Transfer-Encoding:Content-Type:MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:CC:To:From; bh=4HoCUm1VKa+OVqJwqdlK9Is/oFM+0Id/fxBkQMe/9cU=; b=iDiyH8sJRZXAJXv3rFoV5pML4Thnsjy759HPsYVFLWpEDKwuJQRv7bA1Xe/6+NwWC1fgSlh4Zd9bv0t58XTlWlgBqkcuOFllKqp3wD3+Z0ex8vpVvSGhkf6L50Mj6rQaalbJs754nkH95aQ/sXtEvLTod/CsoIplHVN/e7zYgxk=; X-UUID: 83c25699cde941ba9740561f687af8c0-20200729 Received: from mtkcas66.mediatek.inc [(172.29.193.44)] by mailgw01.mediatek.com (envelope-from ) (musrelay.mediatek.com ESMTP with TLS) with ESMTP id 1221550992; Wed, 29 Jul 2020 00:28:35 -0800 Received: from MTKMBS02N2.mediatek.inc (172.21.101.101) by MTKMBS62N2.mediatek.inc (172.29.193.42) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Wed, 29 Jul 2020 01:18:19 -0700 Received: from MTKCAS06.mediatek.inc (172.21.101.30) by mtkmbs02n2.mediatek.inc (172.21.101.101) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Wed, 29 Jul 2020 16:18:10 +0800 Received: from mtkswgap22.mediatek.inc (172.21.77.33) by MTKCAS06.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.0.1497.2 via Frontend Transport; Wed, 29 Jul 2020 16:18:10 +0800 From: Neal Liu To: Rob Herring , Matthias Brugger Subject: [PATCH v4 2/2] soc: mediatek: add mtk-devapc driver Date: Wed, 29 Jul 2020 16:18:10 +0800 Message-ID: <1596010690-13178-3-git-send-email-neal.liu@mediatek.com> X-Mailer: git-send-email 1.7.9.5 In-Reply-To: <1596010690-13178-1-git-send-email-neal.liu@mediatek.com> References: <1596010690-13178-1-git-send-email-neal.liu@mediatek.com> MIME-Version: 1.0 X-TM-SNTS-SMTP: F4037C3EF092712B35F92E4A59BA033C2B72336223F6C9CDEDC4DC3748514F6C2000:8 X-MTK: N X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200729_042830_327408_88BD69D4 X-CRM114-Status: GOOD ( 23.80 ) X-BeenThere: linux-mediatek@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: devicetree@vger.kernel.org, wsd_upstream@mediatek.com, lkml , linux-mediatek@lists.infradead.org, Neal Liu , linux-arm-kernel@lists.infradead.org Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: "Linux-mediatek" Errors-To: linux-mediatek-bounces+linux-mediatek=archiver.kernel.org@lists.infradead.org MediaTek bus fabric provides TrustZone security support and data protection to prevent slaves from being accessed by unexpected masters. The security violation is logged and sent to the processor for further analysis or countermeasures. Any occurrence of security violation would raise an interrupt, and it will be handled by mtk-devapc driver. The violation information is printed in order to find the murderer. Signed-off-by: Neal Liu --- drivers/soc/mediatek/Kconfig | 9 ++ drivers/soc/mediatek/Makefile | 1 + drivers/soc/mediatek/mtk-devapc.c | 323 +++++++++++++++++++++++++++++++++++++ drivers/soc/mediatek/mtk-devapc.h | 54 +++++++ 4 files changed, 387 insertions(+) create mode 100644 drivers/soc/mediatek/mtk-devapc.c create mode 100644 drivers/soc/mediatek/mtk-devapc.h diff --git a/drivers/soc/mediatek/Kconfig b/drivers/soc/mediatek/Kconfig index 59a56cd..1177c98 100644 --- a/drivers/soc/mediatek/Kconfig +++ b/drivers/soc/mediatek/Kconfig @@ -17,6 +17,15 @@ config MTK_CMDQ time limitation, such as updating display configuration during the vblank. +config MTK_DEVAPC + tristate "Mediatek Device APC Support" + help + Say yes here to enable support for Mediatek Device APC driver. + This driver is mainly used to handle the violation which catches + unexpected transaction. + The violation information is logged for further analysis or + countermeasures. + config MTK_INFRACFG bool "MediaTek INFRACFG Support" select REGMAP diff --git a/drivers/soc/mediatek/Makefile b/drivers/soc/mediatek/Makefile index 01f9f87..abfd4ba 100644 --- a/drivers/soc/mediatek/Makefile +++ b/drivers/soc/mediatek/Makefile @@ -1,5 +1,6 @@ # SPDX-License-Identifier: GPL-2.0-only obj-$(CONFIG_MTK_CMDQ) += mtk-cmdq-helper.o +obj-$(CONFIG_MTK_DEVAPC) += mtk-devapc.o obj-$(CONFIG_MTK_INFRACFG) += mtk-infracfg.o obj-$(CONFIG_MTK_PMIC_WRAP) += mtk-pmic-wrap.o obj-$(CONFIG_MTK_SCPSYS) += mtk-scpsys.o diff --git a/drivers/soc/mediatek/mtk-devapc.c b/drivers/soc/mediatek/mtk-devapc.c new file mode 100644 index 0000000..db751d0 --- /dev/null +++ b/drivers/soc/mediatek/mtk-devapc.c @@ -0,0 +1,323 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (C) 2020 MediaTek Inc. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include "mtk-devapc.h" + +static int get_shift_group(struct mtk_devapc_context *ctx) +{ + u32 vio_shift_sta; + void __iomem *reg; + + reg = ctx->devapc_pd_base + ctx->offset->vio_shift_sta; + vio_shift_sta = readl(reg); + + if (vio_shift_sta) + return __ffs(vio_shift_sta); + + return -EIO; +} + +static void clear_vio_status(struct mtk_devapc_context *ctx, u32 module) +{ + void __iomem *reg; + + reg = ctx->devapc_pd_base + ctx->offset->vio_sta; + reg += 0x4 * VIO_MOD_TO_REG_IND(module); + + writel(0x1 << VIO_MOD_TO_REG_OFF(module), reg); +} + +static void mask_module_irq(struct mtk_devapc_context *ctx, u32 module, + bool mask) +{ + void __iomem *reg; + u32 value; + + reg = ctx->devapc_pd_base + ctx->offset->vio_mask; + reg += 0x4 * VIO_MOD_TO_REG_IND(module); + + value = readl(reg); + if (mask) + value |= (0x1 << VIO_MOD_TO_REG_OFF(module)); + else + value &= ~(0x1 << VIO_MOD_TO_REG_OFF(module)); + + writel(value, reg); +} + +#define PHY_DEVAPC_TIMEOUT 0x10000 + +/* + * sync_vio_dbg - do "shift" mechansim" to get full violation information. + * shift mechanism is depends on devapc hardware design. + * Mediatek devapc set multiple slaves as a group. When violation + * is triggered, violation info is kept inside devapc hardware. + * Driver should do shift mechansim to "shift" full violation + * info to VIO_DBGs registers. + * + */ +static int sync_vio_dbg(struct mtk_devapc_context *ctx, u32 shift_bit) +{ + void __iomem *pd_vio_shift_sta_reg; + void __iomem *pd_vio_shift_sel_reg; + void __iomem *pd_vio_shift_con_reg; + int ret; + u32 val; + + pd_vio_shift_sta_reg = ctx->devapc_pd_base + ctx->offset->vio_shift_sta; + pd_vio_shift_sel_reg = ctx->devapc_pd_base + ctx->offset->vio_shift_sel; + pd_vio_shift_con_reg = ctx->devapc_pd_base + ctx->offset->vio_shift_con; + + /* Enable shift mechansim */ + writel(0x1 << shift_bit, pd_vio_shift_sel_reg); + writel(0x1, pd_vio_shift_con_reg); + + ret = readl_poll_timeout(pd_vio_shift_con_reg, val, val == 0x3, 0, + PHY_DEVAPC_TIMEOUT); + if (ret) + dev_err(ctx->dev, "%s: Shift violation info failed\n", __func__); + + /* Disable shift mechanism */ + writel(0x0, pd_vio_shift_con_reg); + writel(0x0, pd_vio_shift_sel_reg); + writel(0x1 << shift_bit, pd_vio_shift_sta_reg); + + return ret; +} + +static void devapc_vio_info_print(struct mtk_devapc_context *ctx) +{ + struct mtk_devapc_vio_info *vio_info = ctx->vio_info; + + /* Print violation information */ + if (vio_info->write) + dev_info(ctx->dev, "Write Violation\n"); + else if (vio_info->read) + dev_info(ctx->dev, "Read Violation\n"); + + dev_info(ctx->dev, "Vio Addr:0x%x, High:0x%x, Bus ID:0x%x, Dom ID:%x\n", + vio_info->vio_addr, vio_info->vio_addr_high, + vio_info->master_id, vio_info->domain_id); +} + +/* + * devapc_extract_vio_dbg - extract full violation information after doing + * shift mechanism. + */ +static void devapc_extract_vio_dbg(struct mtk_devapc_context *ctx) +{ + const struct mtk_devapc_vio_dbgs *vio_dbgs; + struct mtk_devapc_vio_info *vio_info; + void __iomem *vio_dbg0_reg; + void __iomem *vio_dbg1_reg; + u32 dbg0; + + vio_dbg0_reg = ctx->devapc_pd_base + ctx->offset->vio_dbg0; + vio_dbg1_reg = ctx->devapc_pd_base + ctx->offset->vio_dbg1; + + vio_dbgs = ctx->vio_dbgs; + vio_info = ctx->vio_info; + + /* Starts to extract violation information */ + dbg0 = readl(vio_dbg0_reg); + vio_info->vio_addr = readl(vio_dbg1_reg); + + vio_info->master_id = (dbg0 & vio_dbgs->mstid.mask) >> + vio_dbgs->mstid.start; + vio_info->domain_id = (dbg0 & vio_dbgs->dmnid.mask) >> + vio_dbgs->dmnid.start; + vio_info->write = ((dbg0 & vio_dbgs->vio_w.mask) >> + vio_dbgs->vio_w.start) == 1; + vio_info->read = ((dbg0 & vio_dbgs->vio_r.mask) >> + vio_dbgs->vio_r.start) == 1; + vio_info->vio_addr_high = (dbg0 & vio_dbgs->addr_h.mask) >> + vio_dbgs->addr_h.start; + + devapc_vio_info_print(ctx); +} + +/* + * devapc_dump_vio_dbg - shift and dump the violation debug information. + */ +static void devapc_dump_vio_dbg(struct mtk_devapc_context *ctx) +{ + int shift_bit; + + /* + * All groups vio_idx belongs to is determined by hardware, + * and each group can only maintain one violation info at a time. + * + * Scan all groups which vio_idx has violation, dump it for + * further analysis. + */ + while (1) { + shift_bit = get_shift_group(ctx); + + if (shift_bit >= 0 && shift_bit <= 31) { + if (!sync_vio_dbg(ctx, shift_bit)) + devapc_extract_vio_dbg(ctx); + + continue; + } + + break; + } +} + +/* + * devapc_violation_irq - the devapc Interrupt Service Routine (ISR) will dump + * violation information including which master violates + * access slave. + */ +static irqreturn_t devapc_violation_irq(int irq_number, + struct mtk_devapc_context *ctx) +{ + u32 vio_idx; + + /* + * Mask slave's irq before clearing vio status. + * Must do it to avoid nested interrupt and prevent + * unexpected behavior. + */ + for (vio_idx = 0; vio_idx < ctx->vio_idx_num; vio_idx++) + mask_module_irq(ctx, vio_idx, true); + + devapc_dump_vio_dbg(ctx); + + /* + * Ensure that violation info are written + * before further operations + */ + smp_mb(); + + for (vio_idx = 0; vio_idx < ctx->vio_idx_num; vio_idx++) { + clear_vio_status(ctx, vio_idx); + mask_module_irq(ctx, vio_idx, false); + } + + return IRQ_HANDLED; +} + +/* + * start_devapc - unmask slave's irq to start receiving devapc violation. + */ +static void start_devapc(struct mtk_devapc_context *ctx) +{ + u32 vio_idx; + + for (vio_idx = 0; vio_idx < ctx->vio_idx_num; vio_idx++) + mask_module_irq(ctx, vio_idx, false); +} + +static const struct mtk_devapc_pd_offset mt6779_pd_offset = { + .vio_mask = 0x0, + .vio_sta = 0x400, + .vio_dbg0 = 0x900, + .vio_dbg1 = 0x904, + .apc_con = 0xF00, + .vio_shift_sta = 0xF10, + .vio_shift_sel = 0xF14, + .vio_shift_con = 0xF20, +}; + +static const struct mtk_devapc_vio_dbgs mt6779_vio_dbgs = { + .mstid = {0x0000FFFF, 0x0}, + .dmnid = {0x003F0000, 0x10}, + .vio_w = {0x00400000, 0x16}, + .vio_r = {0x00800000, 0x17}, + .addr_h = {0x0F000000, 0x18}, +}; + +static const struct mtk_devapc_context devapc_mt6779 = { + .vio_idx_num = 510, + .offset = &mt6779_pd_offset, + .vio_dbgs = &mt6779_vio_dbgs, +}; + +static const struct of_device_id mtk_devapc_dt_match[] = { + { + .compatible = "mediatek,mt6779-devapc", + .data = &devapc_mt6779, + }, { + }, +}; + +static int mtk_devapc_probe(struct platform_device *pdev) +{ + struct device_node *node = pdev->dev.of_node; + struct mtk_devapc_context *ctx; + struct clk *devapc_infra_clk; + u32 devapc_irq; + int ret; + + if (IS_ERR(node)) + return -ENODEV; + + ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL); + if (!ctx) + return -ENOMEM; + + ctx = (struct mtk_devapc_context *)of_device_get_match_data(&pdev->dev); + ctx->dev = &pdev->dev; + + ctx->vio_info = devm_kzalloc(&pdev->dev, + sizeof(struct mtk_devapc_vio_info), + GFP_KERNEL); + if (!ctx->vio_info) + return -ENOMEM; + + ctx->devapc_pd_base = of_iomap(node, 0); + if (!ctx->devapc_pd_base) + return -EINVAL; + + devapc_irq = irq_of_parse_and_map(node, 0); + if (!devapc_irq) + return -EINVAL; + + devapc_infra_clk = devm_clk_get(&pdev->dev, "devapc-infra-clock"); + if (IS_ERR(devapc_infra_clk)) + return -EINVAL; + + if (clk_prepare_enable(devapc_infra_clk)) + return -EINVAL; + + ret = devm_request_irq(&pdev->dev, devapc_irq, + (irq_handler_t)devapc_violation_irq, + IRQF_TRIGGER_NONE, "devapc", ctx); + if (ret) + return ret; + + start_devapc(ctx); + + return 0; +} + +static int mtk_devapc_remove(struct platform_device *dev) +{ + return 0; +} + +static struct platform_driver mtk_devapc_driver = { + .probe = mtk_devapc_probe, + .remove = mtk_devapc_remove, + .driver = { + .name = KBUILD_MODNAME, + .of_match_table = mtk_devapc_dt_match, + }, +}; + +module_platform_driver(mtk_devapc_driver); + +MODULE_DESCRIPTION("Mediatek Device APC Driver"); +MODULE_AUTHOR("Neal Liu "); +MODULE_LICENSE("GPL"); diff --git a/drivers/soc/mediatek/mtk-devapc.h b/drivers/soc/mediatek/mtk-devapc.h new file mode 100644 index 0000000..7bd7e66 --- /dev/null +++ b/drivers/soc/mediatek/mtk-devapc.h @@ -0,0 +1,54 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Copyright (C) 2020 MediaTek Inc. + */ + +#ifndef __MTK_DEVAPC_H__ +#define __MTK_DEVAPC_H__ + +#define VIO_MOD_TO_REG_IND(m) ((m) / 32) +#define VIO_MOD_TO_REG_OFF(m) ((m) % 32) + +struct mtk_devapc_pd_offset { + u32 vio_mask; + u32 vio_sta; + u32 vio_dbg0; + u32 vio_dbg1; + u32 apc_con; + u32 vio_shift_sta; + u32 vio_shift_sel; + u32 vio_shift_con; +}; + +struct mtk_devapc_vio_dbgs_desc { + u32 mask; + u32 start; +}; + +struct mtk_devapc_vio_dbgs { + struct mtk_devapc_vio_dbgs_desc mstid; + struct mtk_devapc_vio_dbgs_desc dmnid; + struct mtk_devapc_vio_dbgs_desc vio_w; + struct mtk_devapc_vio_dbgs_desc vio_r; + struct mtk_devapc_vio_dbgs_desc addr_h; +}; + +struct mtk_devapc_vio_info { + bool read; + bool write; + u32 vio_addr; + u32 vio_addr_high; + u32 master_id; + u32 domain_id; +}; + +struct mtk_devapc_context { + struct device *dev; + u32 vio_idx_num; + void __iomem *devapc_pd_base; + struct mtk_devapc_vio_info *vio_info; + const struct mtk_devapc_pd_offset *offset; + const struct mtk_devapc_vio_dbgs *vio_dbgs; +}; + +#endif /* __MTK_DEVAPC_H__ */ -- 1.7.9.5 _______________________________________________ Linux-mediatek mailing list Linux-mediatek@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-mediatek From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-13.0 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,UNPARSEABLE_RELAY, URIBL_BLOCKED,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id ECE60C433DF for ; Wed, 29 Jul 2020 08:30:36 +0000 (UTC) Received: from merlin.infradead.org (merlin.infradead.org [205.233.59.134]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id ABF38206D4 for ; Wed, 29 Jul 2020 08:30:36 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="I3bUHDzy"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="iDiyH8sJ" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org ABF38206D4 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=mediatek.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=merlin.20170209; h=Sender:Content-Transfer-Encoding: Content-Type:Cc:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To:Message-ID:Date: Subject:To:From:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=DtpDDrQ+CATvtCaquSCgLRXsRvxQvLtdJYcWHNv3OhI=; b=I3bUHDzyVrU+CChTuHIKr6W1H mAeIfL57q5PngxDY3um9Wxbz3LLlJ38p8v+AJJcw/pe9A3gSjEM5NHi4MyvB9iz3uJD0MHVRivhF8 5i94KQOPAJ01N620KJr67a2skqf7h4dLaPS1p9/JNpBKNFWjJ4TNG6NltNwQGQZwpDoZ60KtsgJcI zuI7HOoyBKWom49Y41OaOYX/fdJHQ08pvEKGRLijfVjavQWBTsQ6j/4iTKewhQFd0+R8towf6yxX2 2jiFd4kPrlRCqxMHkYEHGpNPEfqC/1c7efIVjrwWq0Gp/ItCu4+nQeJBpIviYDj0GuuJlfB8lwdPJ ZvpAEXm1Q==; Received: from localhost ([::1] helo=merlin.infradead.org) by merlin.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1k0hSD-0005kl-Ha; Wed, 29 Jul 2020 08:28:49 +0000 Received: from mailgw01.mediatek.com ([216.200.240.184]) by merlin.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1k0hRu-0005cG-10; Wed, 29 Jul 2020 08:28:33 +0000 X-UUID: 83c25699cde941ba9740561f687af8c0-20200729 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=mediatek.com; s=dk; h=Content-Transfer-Encoding:Content-Type:MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:CC:To:From; bh=4HoCUm1VKa+OVqJwqdlK9Is/oFM+0Id/fxBkQMe/9cU=; b=iDiyH8sJRZXAJXv3rFoV5pML4Thnsjy759HPsYVFLWpEDKwuJQRv7bA1Xe/6+NwWC1fgSlh4Zd9bv0t58XTlWlgBqkcuOFllKqp3wD3+Z0ex8vpVvSGhkf6L50Mj6rQaalbJs754nkH95aQ/sXtEvLTod/CsoIplHVN/e7zYgxk=; X-UUID: 83c25699cde941ba9740561f687af8c0-20200729 Received: from mtkcas66.mediatek.inc [(172.29.193.44)] by mailgw01.mediatek.com (envelope-from ) (musrelay.mediatek.com ESMTP with TLS) with ESMTP id 1221550992; Wed, 29 Jul 2020 00:28:35 -0800 Received: from MTKMBS02N2.mediatek.inc (172.21.101.101) by MTKMBS62N2.mediatek.inc (172.29.193.42) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Wed, 29 Jul 2020 01:18:19 -0700 Received: from MTKCAS06.mediatek.inc (172.21.101.30) by mtkmbs02n2.mediatek.inc (172.21.101.101) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Wed, 29 Jul 2020 16:18:10 +0800 Received: from mtkswgap22.mediatek.inc (172.21.77.33) by MTKCAS06.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.0.1497.2 via Frontend Transport; Wed, 29 Jul 2020 16:18:10 +0800 From: Neal Liu To: Rob Herring , Matthias Brugger Subject: [PATCH v4 2/2] soc: mediatek: add mtk-devapc driver Date: Wed, 29 Jul 2020 16:18:10 +0800 Message-ID: <1596010690-13178-3-git-send-email-neal.liu@mediatek.com> X-Mailer: git-send-email 1.7.9.5 In-Reply-To: <1596010690-13178-1-git-send-email-neal.liu@mediatek.com> References: <1596010690-13178-1-git-send-email-neal.liu@mediatek.com> MIME-Version: 1.0 X-TM-SNTS-SMTP: F4037C3EF092712B35F92E4A59BA033C2B72336223F6C9CDEDC4DC3748514F6C2000:8 X-MTK: N X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200729_042830_327408_88BD69D4 X-CRM114-Status: GOOD ( 23.80 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: devicetree@vger.kernel.org, wsd_upstream@mediatek.com, lkml , linux-mediatek@lists.infradead.org, Neal Liu , linux-arm-kernel@lists.infradead.org Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org MediaTek bus fabric provides TrustZone security support and data protection to prevent slaves from being accessed by unexpected masters. The security violation is logged and sent to the processor for further analysis or countermeasures. Any occurrence of security violation would raise an interrupt, and it will be handled by mtk-devapc driver. The violation information is printed in order to find the murderer. Signed-off-by: Neal Liu --- drivers/soc/mediatek/Kconfig | 9 ++ drivers/soc/mediatek/Makefile | 1 + drivers/soc/mediatek/mtk-devapc.c | 323 +++++++++++++++++++++++++++++++++++++ drivers/soc/mediatek/mtk-devapc.h | 54 +++++++ 4 files changed, 387 insertions(+) create mode 100644 drivers/soc/mediatek/mtk-devapc.c create mode 100644 drivers/soc/mediatek/mtk-devapc.h diff --git a/drivers/soc/mediatek/Kconfig b/drivers/soc/mediatek/Kconfig index 59a56cd..1177c98 100644 --- a/drivers/soc/mediatek/Kconfig +++ b/drivers/soc/mediatek/Kconfig @@ -17,6 +17,15 @@ config MTK_CMDQ time limitation, such as updating display configuration during the vblank. +config MTK_DEVAPC + tristate "Mediatek Device APC Support" + help + Say yes here to enable support for Mediatek Device APC driver. + This driver is mainly used to handle the violation which catches + unexpected transaction. + The violation information is logged for further analysis or + countermeasures. + config MTK_INFRACFG bool "MediaTek INFRACFG Support" select REGMAP diff --git a/drivers/soc/mediatek/Makefile b/drivers/soc/mediatek/Makefile index 01f9f87..abfd4ba 100644 --- a/drivers/soc/mediatek/Makefile +++ b/drivers/soc/mediatek/Makefile @@ -1,5 +1,6 @@ # SPDX-License-Identifier: GPL-2.0-only obj-$(CONFIG_MTK_CMDQ) += mtk-cmdq-helper.o +obj-$(CONFIG_MTK_DEVAPC) += mtk-devapc.o obj-$(CONFIG_MTK_INFRACFG) += mtk-infracfg.o obj-$(CONFIG_MTK_PMIC_WRAP) += mtk-pmic-wrap.o obj-$(CONFIG_MTK_SCPSYS) += mtk-scpsys.o diff --git a/drivers/soc/mediatek/mtk-devapc.c b/drivers/soc/mediatek/mtk-devapc.c new file mode 100644 index 0000000..db751d0 --- /dev/null +++ b/drivers/soc/mediatek/mtk-devapc.c @@ -0,0 +1,323 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (C) 2020 MediaTek Inc. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include "mtk-devapc.h" + +static int get_shift_group(struct mtk_devapc_context *ctx) +{ + u32 vio_shift_sta; + void __iomem *reg; + + reg = ctx->devapc_pd_base + ctx->offset->vio_shift_sta; + vio_shift_sta = readl(reg); + + if (vio_shift_sta) + return __ffs(vio_shift_sta); + + return -EIO; +} + +static void clear_vio_status(struct mtk_devapc_context *ctx, u32 module) +{ + void __iomem *reg; + + reg = ctx->devapc_pd_base + ctx->offset->vio_sta; + reg += 0x4 * VIO_MOD_TO_REG_IND(module); + + writel(0x1 << VIO_MOD_TO_REG_OFF(module), reg); +} + +static void mask_module_irq(struct mtk_devapc_context *ctx, u32 module, + bool mask) +{ + void __iomem *reg; + u32 value; + + reg = ctx->devapc_pd_base + ctx->offset->vio_mask; + reg += 0x4 * VIO_MOD_TO_REG_IND(module); + + value = readl(reg); + if (mask) + value |= (0x1 << VIO_MOD_TO_REG_OFF(module)); + else + value &= ~(0x1 << VIO_MOD_TO_REG_OFF(module)); + + writel(value, reg); +} + +#define PHY_DEVAPC_TIMEOUT 0x10000 + +/* + * sync_vio_dbg - do "shift" mechansim" to get full violation information. + * shift mechanism is depends on devapc hardware design. + * Mediatek devapc set multiple slaves as a group. When violation + * is triggered, violation info is kept inside devapc hardware. + * Driver should do shift mechansim to "shift" full violation + * info to VIO_DBGs registers. + * + */ +static int sync_vio_dbg(struct mtk_devapc_context *ctx, u32 shift_bit) +{ + void __iomem *pd_vio_shift_sta_reg; + void __iomem *pd_vio_shift_sel_reg; + void __iomem *pd_vio_shift_con_reg; + int ret; + u32 val; + + pd_vio_shift_sta_reg = ctx->devapc_pd_base + ctx->offset->vio_shift_sta; + pd_vio_shift_sel_reg = ctx->devapc_pd_base + ctx->offset->vio_shift_sel; + pd_vio_shift_con_reg = ctx->devapc_pd_base + ctx->offset->vio_shift_con; + + /* Enable shift mechansim */ + writel(0x1 << shift_bit, pd_vio_shift_sel_reg); + writel(0x1, pd_vio_shift_con_reg); + + ret = readl_poll_timeout(pd_vio_shift_con_reg, val, val == 0x3, 0, + PHY_DEVAPC_TIMEOUT); + if (ret) + dev_err(ctx->dev, "%s: Shift violation info failed\n", __func__); + + /* Disable shift mechanism */ + writel(0x0, pd_vio_shift_con_reg); + writel(0x0, pd_vio_shift_sel_reg); + writel(0x1 << shift_bit, pd_vio_shift_sta_reg); + + return ret; +} + +static void devapc_vio_info_print(struct mtk_devapc_context *ctx) +{ + struct mtk_devapc_vio_info *vio_info = ctx->vio_info; + + /* Print violation information */ + if (vio_info->write) + dev_info(ctx->dev, "Write Violation\n"); + else if (vio_info->read) + dev_info(ctx->dev, "Read Violation\n"); + + dev_info(ctx->dev, "Vio Addr:0x%x, High:0x%x, Bus ID:0x%x, Dom ID:%x\n", + vio_info->vio_addr, vio_info->vio_addr_high, + vio_info->master_id, vio_info->domain_id); +} + +/* + * devapc_extract_vio_dbg - extract full violation information after doing + * shift mechanism. + */ +static void devapc_extract_vio_dbg(struct mtk_devapc_context *ctx) +{ + const struct mtk_devapc_vio_dbgs *vio_dbgs; + struct mtk_devapc_vio_info *vio_info; + void __iomem *vio_dbg0_reg; + void __iomem *vio_dbg1_reg; + u32 dbg0; + + vio_dbg0_reg = ctx->devapc_pd_base + ctx->offset->vio_dbg0; + vio_dbg1_reg = ctx->devapc_pd_base + ctx->offset->vio_dbg1; + + vio_dbgs = ctx->vio_dbgs; + vio_info = ctx->vio_info; + + /* Starts to extract violation information */ + dbg0 = readl(vio_dbg0_reg); + vio_info->vio_addr = readl(vio_dbg1_reg); + + vio_info->master_id = (dbg0 & vio_dbgs->mstid.mask) >> + vio_dbgs->mstid.start; + vio_info->domain_id = (dbg0 & vio_dbgs->dmnid.mask) >> + vio_dbgs->dmnid.start; + vio_info->write = ((dbg0 & vio_dbgs->vio_w.mask) >> + vio_dbgs->vio_w.start) == 1; + vio_info->read = ((dbg0 & vio_dbgs->vio_r.mask) >> + vio_dbgs->vio_r.start) == 1; + vio_info->vio_addr_high = (dbg0 & vio_dbgs->addr_h.mask) >> + vio_dbgs->addr_h.start; + + devapc_vio_info_print(ctx); +} + +/* + * devapc_dump_vio_dbg - shift and dump the violation debug information. + */ +static void devapc_dump_vio_dbg(struct mtk_devapc_context *ctx) +{ + int shift_bit; + + /* + * All groups vio_idx belongs to is determined by hardware, + * and each group can only maintain one violation info at a time. + * + * Scan all groups which vio_idx has violation, dump it for + * further analysis. + */ + while (1) { + shift_bit = get_shift_group(ctx); + + if (shift_bit >= 0 && shift_bit <= 31) { + if (!sync_vio_dbg(ctx, shift_bit)) + devapc_extract_vio_dbg(ctx); + + continue; + } + + break; + } +} + +/* + * devapc_violation_irq - the devapc Interrupt Service Routine (ISR) will dump + * violation information including which master violates + * access slave. + */ +static irqreturn_t devapc_violation_irq(int irq_number, + struct mtk_devapc_context *ctx) +{ + u32 vio_idx; + + /* + * Mask slave's irq before clearing vio status. + * Must do it to avoid nested interrupt and prevent + * unexpected behavior. + */ + for (vio_idx = 0; vio_idx < ctx->vio_idx_num; vio_idx++) + mask_module_irq(ctx, vio_idx, true); + + devapc_dump_vio_dbg(ctx); + + /* + * Ensure that violation info are written + * before further operations + */ + smp_mb(); + + for (vio_idx = 0; vio_idx < ctx->vio_idx_num; vio_idx++) { + clear_vio_status(ctx, vio_idx); + mask_module_irq(ctx, vio_idx, false); + } + + return IRQ_HANDLED; +} + +/* + * start_devapc - unmask slave's irq to start receiving devapc violation. + */ +static void start_devapc(struct mtk_devapc_context *ctx) +{ + u32 vio_idx; + + for (vio_idx = 0; vio_idx < ctx->vio_idx_num; vio_idx++) + mask_module_irq(ctx, vio_idx, false); +} + +static const struct mtk_devapc_pd_offset mt6779_pd_offset = { + .vio_mask = 0x0, + .vio_sta = 0x400, + .vio_dbg0 = 0x900, + .vio_dbg1 = 0x904, + .apc_con = 0xF00, + .vio_shift_sta = 0xF10, + .vio_shift_sel = 0xF14, + .vio_shift_con = 0xF20, +}; + +static const struct mtk_devapc_vio_dbgs mt6779_vio_dbgs = { + .mstid = {0x0000FFFF, 0x0}, + .dmnid = {0x003F0000, 0x10}, + .vio_w = {0x00400000, 0x16}, + .vio_r = {0x00800000, 0x17}, + .addr_h = {0x0F000000, 0x18}, +}; + +static const struct mtk_devapc_context devapc_mt6779 = { + .vio_idx_num = 510, + .offset = &mt6779_pd_offset, + .vio_dbgs = &mt6779_vio_dbgs, +}; + +static const struct of_device_id mtk_devapc_dt_match[] = { + { + .compatible = "mediatek,mt6779-devapc", + .data = &devapc_mt6779, + }, { + }, +}; + +static int mtk_devapc_probe(struct platform_device *pdev) +{ + struct device_node *node = pdev->dev.of_node; + struct mtk_devapc_context *ctx; + struct clk *devapc_infra_clk; + u32 devapc_irq; + int ret; + + if (IS_ERR(node)) + return -ENODEV; + + ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL); + if (!ctx) + return -ENOMEM; + + ctx = (struct mtk_devapc_context *)of_device_get_match_data(&pdev->dev); + ctx->dev = &pdev->dev; + + ctx->vio_info = devm_kzalloc(&pdev->dev, + sizeof(struct mtk_devapc_vio_info), + GFP_KERNEL); + if (!ctx->vio_info) + return -ENOMEM; + + ctx->devapc_pd_base = of_iomap(node, 0); + if (!ctx->devapc_pd_base) + return -EINVAL; + + devapc_irq = irq_of_parse_and_map(node, 0); + if (!devapc_irq) + return -EINVAL; + + devapc_infra_clk = devm_clk_get(&pdev->dev, "devapc-infra-clock"); + if (IS_ERR(devapc_infra_clk)) + return -EINVAL; + + if (clk_prepare_enable(devapc_infra_clk)) + return -EINVAL; + + ret = devm_request_irq(&pdev->dev, devapc_irq, + (irq_handler_t)devapc_violation_irq, + IRQF_TRIGGER_NONE, "devapc", ctx); + if (ret) + return ret; + + start_devapc(ctx); + + return 0; +} + +static int mtk_devapc_remove(struct platform_device *dev) +{ + return 0; +} + +static struct platform_driver mtk_devapc_driver = { + .probe = mtk_devapc_probe, + .remove = mtk_devapc_remove, + .driver = { + .name = KBUILD_MODNAME, + .of_match_table = mtk_devapc_dt_match, + }, +}; + +module_platform_driver(mtk_devapc_driver); + +MODULE_DESCRIPTION("Mediatek Device APC Driver"); +MODULE_AUTHOR("Neal Liu "); +MODULE_LICENSE("GPL"); diff --git a/drivers/soc/mediatek/mtk-devapc.h b/drivers/soc/mediatek/mtk-devapc.h new file mode 100644 index 0000000..7bd7e66 --- /dev/null +++ b/drivers/soc/mediatek/mtk-devapc.h @@ -0,0 +1,54 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Copyright (C) 2020 MediaTek Inc. + */ + +#ifndef __MTK_DEVAPC_H__ +#define __MTK_DEVAPC_H__ + +#define VIO_MOD_TO_REG_IND(m) ((m) / 32) +#define VIO_MOD_TO_REG_OFF(m) ((m) % 32) + +struct mtk_devapc_pd_offset { + u32 vio_mask; + u32 vio_sta; + u32 vio_dbg0; + u32 vio_dbg1; + u32 apc_con; + u32 vio_shift_sta; + u32 vio_shift_sel; + u32 vio_shift_con; +}; + +struct mtk_devapc_vio_dbgs_desc { + u32 mask; + u32 start; +}; + +struct mtk_devapc_vio_dbgs { + struct mtk_devapc_vio_dbgs_desc mstid; + struct mtk_devapc_vio_dbgs_desc dmnid; + struct mtk_devapc_vio_dbgs_desc vio_w; + struct mtk_devapc_vio_dbgs_desc vio_r; + struct mtk_devapc_vio_dbgs_desc addr_h; +}; + +struct mtk_devapc_vio_info { + bool read; + bool write; + u32 vio_addr; + u32 vio_addr_high; + u32 master_id; + u32 domain_id; +}; + +struct mtk_devapc_context { + struct device *dev; + u32 vio_idx_num; + void __iomem *devapc_pd_base; + struct mtk_devapc_vio_info *vio_info; + const struct mtk_devapc_pd_offset *offset; + const struct mtk_devapc_vio_dbgs *vio_dbgs; +}; + +#endif /* __MTK_DEVAPC_H__ */ -- 1.7.9.5 _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel