From patchwork Tue Sep 6 22:29:52 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Frank Li X-Patchwork-Id: 9317923 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork.web.codeaurora.org (Postfix) with ESMTP id 77AF5601C0 for ; Tue, 6 Sep 2016 21:31:31 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 7D2B728ED0 for ; Tue, 6 Sep 2016 21:31:31 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 7181528EE5; Tue, 6 Sep 2016 21:31:31 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-4.1 required=2.0 tests=BAD_ENC_HEADER,BAYES_00, DKIM_SIGNED, RCVD_IN_DNSWL_MED, T_DKIM_INVALID autolearn=ham version=3.3.1 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.9]) (using TLSv1.2 with cipher AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by mail.wl.linuxfoundation.org (Postfix) with ESMTPS id 0AC2328ED0 for ; Tue, 6 Sep 2016 21:31:30 +0000 (UTC) Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.85_2 #1 (Red Hat Linux)) id 1bhNwE-0001up-OS; Tue, 06 Sep 2016 21:29:50 +0000 Received: from mail-he1eur01on0071.outbound.protection.outlook.com ([104.47.0.71] helo=EUR01-HE1-obe.outbound.protection.outlook.com) by bombadil.infradead.org with esmtps (Exim 4.85_2 #1 (Red Hat Linux)) id 1bhNw7-0001sl-Ch for linux-arm-kernel@lists.infradead.org; Tue, 06 Sep 2016 21:29:46 +0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nxp.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version; bh=TUQRJco3sIrHemijVDl5C3LiteSn4wxcETHPGd1k95M=; b=ivd9VfyiddH1hC8cRITmHhe74i+3/duoiusHNEHWYqLjPFZ/TD/FrE1hxty8DnAXPAArl75zgcugkRBxofMo61mwAudDGYjLkqk07cizkGHHTZAGu2S75uzKn8vP0NWWJ2wJA12mXh0OX8iO98DeWSx4PozcopVJVwk4LsRX+AI= Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=frank.li@nxp.com; Received: from lizhi-Precision-Tower-5810.am.freescale.net (192.88.168.49) by DB4PR04MB267.eurprd04.prod.outlook.com (10.242.231.22) with Microsoft SMTP Server (version=TLS1_0, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA_P384) id 15.1.609.3; Tue, 6 Sep 2016 21:29:16 +0000 From: Frank Li To: Subject: [PATCH 1/1 v5] ARM: imx: Added perf functionality to mmdc driver Date: Tue, 6 Sep 2016 17:29:52 -0500 Message-ID: <1473200992-24179-1-git-send-email-Frank.Li@nxp.com> X-Mailer: git-send-email 2.5.2 MIME-Version: 1.0 X-Originating-IP: [192.88.168.49] X-ClientProxiedBy: BLUPR01CA044.prod.exchangelabs.com (10.160.23.34) To DB4PR04MB267.eurprd04.prod.outlook.com (10.242.231.22) X-MS-Office365-Filtering-Correlation-Id: 33c488d7-e705-427a-b052-08d3d69cdc1e X-Microsoft-Exchange-Diagnostics: 1; DB4PR04MB267; 2:ZA167zFoyH4CUqQbRGRwyzw2R4LqmD5ykrK0WVpJSmXxWa/ArdMqb5E2QDx/GR2MHAa9jMUFuO90waV3W+jkDSrouysIzEGfhusIAP9MJts7BVMDBoDFvCd1gls3+Mpnq/sjaNpgOEUxxO8hFv+UnoVU/YXLKQeQJFEkg1P1rqscHQHmWJXQ1PjDL6itaYrO; 3:wMQHVRTrYTE9oXlO3TZ9QriRrISPhOhEEBIl4RtY0kn5fY7Dn9IKZyVkO6AiPXZWCbepS/ZbQIhEJMu/DcP9/y9ybEIUFMkbAqJHacgHAbWlOr9aVWgFV0tBP1h7Jj/j; 25:pA/7+rjB7Canm5Q1gx9XlpqnDASFDHPbnk3VvYXuPCHieqYjjWloBJZOqZOhw8t3rgvhVyOVgPT67l9yIERXUCWMDsBW73/MM1hjDoQse58lvlbiWwWqLyOLkC2aN1vMdH3fdacERx9sTSzcuw4E3Q8f4/vtuItZyhVAXV9aSvw8EDZVYfy7zMlffFNFcBG50PBHMwWhEIHQITGmBtCqxcgF4ul2hDmqIbZAhivRFOYLeTGbGlrSqskcG0GYGRpTogxwjB0jJcUxk76GXt+ejUOB0MdWogW3aPDCDxJPUYjT8mzz0IJJL9B1CsfXFLbJOcbmOv8H+tLOZa/d+s5vQPjob/IPAHxMD5su7i42Qxoab5RCKxGCYl1dJv5ARCw887nOc8RyMXTdhW9oO37Jq1ku6xtImj7Y0c4iWz8Pneg= X-Microsoft-Antispam: UriScan:;BCL:0;PCL:0;RULEID:;SRVR:DB4PR04MB267; X-Microsoft-Exchange-Diagnostics: 1; DB4PR04MB267; 31:w//52QKAUsK9V9ZK0jVO7KD7QoIcy5IxcRf+Jc15U+799gsLMQRVLgV8bDiYD2+Z+sNo6q1wSZlFaSWr/3tGtqLxoENIoNC/kXp3F7/0hHZ+KVzufif0adQs09pf4Y2bkW3DA5ECL/ToYoo4Jby+LOQTLh2oEmDWFN7rSJD9KpCMGFdma2pCZQItb3N+e5//xXeRJUz+AvwNg50nCYcuRDAcMgj6n5hqr8EkZRFwqLo=; 20:uy+XtNZKJdG0cSN/6Nyhcz68rLItiLbwg4aY2Ue5flKF8quPEb3NF1P7qAakPOeRwNH8wSMmziJo53Iug6jxfYO0YJZOAR7p6WtfSzUIg/Lbgswzq1LrOIthtcWaemY65kG5QkQT63KYRUk60mr9UK+ntJeXXNQYY7wNu7WIO1fnO/ORvpKPB0OlOsSxLavN+6tVALrpKXtfbIVKI151v1VUvPAMgmN9XGtyaFCElFWPdpcwAktvXKtt7ivbLn0bKkUEDbNO4L4Abxoh1zX5e9UMl6LI4QIHHbz/oMZRzAS3ahGIYXd73YXt6WgJkVZXq/Uv8yweFSO92cD36QBK7oDHREbbWDyPQPk0pU5Pm1mje0BItZTTYgbpGDp33PGcQX3HtStFyPdCjwWtboNXHNsT+2/C3/ncTkGbqKKCSxGDutDWST3d8jwTPZRTA5RGJLfemScwWlDClY7dJpuNoHFHiTrBMrCIN9OGLYih81854ybdRBjeTn5hExGuIBPcU6gMgGc/fdGKVcX8EXxyWA== X-NIPS-smtp-INBOUND: xFSL-EDGE X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(250305191791016)(22074186197030)(185117386973197)(788757137089); X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(6040176)(601004)(2401047)(8121501046)(5005006)(3002001)(10201501046)(6055026); SRVR:DB4PR04MB267; BCL:0; PCL:0; RULEID:; SRVR:DB4PR04MB267; X-Microsoft-Exchange-Diagnostics: 1; DB4PR04MB267; 4:BqqEdSVmaYL0yBn6tGU2Q51OKdeqSfjYBITAPTsMHuIzXmYoub+SBkfR/2WbwPti9tCr7UH7dD9L0CUT/W5dSUHx3tL8yyQQOL5wqRpsqUWMhHOB6NKzB7cJXVximkAe4b2lvqvLe4StcKg4PwX33OpUytUy+14vrfw6zjKbOhRHQktudt1o/vjfNP/HmJeHf23qmQblF/r+thYrJoQaNYrYwKMXNAo4WmUq21n3yPDIcQ4NzQT7vQSjBV0/ygyqhQkqIPftD2Ki2Yq/JibpY/tFtjzwNc84xnrrD7cjt8ROek9x6PLK+wuo3Kfru9hgBDleTjqkFyLCJaU2GQiibTV0uAuLDqnnBtfTbT0YWWq4+OzugaO9yMs51aWNTn7LYoIqQqFAktYBR4d8iF9rc6Jj3elnIEZiCa3CEViV9aK1AB0nb3qF4hToIxOwG4E3m0gzR8BEN4Kt/btNwmxx0guqerxafgVbI59HN/eYLEp921RssPGS0FtEy94Plz7rlLnZgU9HjqGMgih7GZxP3SPfxR95vbSFI2A1iLbj+gg= X-Forefront-PRVS: 0057EE387C X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(4630300001)(6009001)(7916002)(189002)(199003)(4326007)(19580395003)(101416001)(19580405001)(105586002)(2906002)(5660300001)(50466002)(68736007)(2351001)(106356001)(92566002)(86362001)(15975445007)(47776003)(8676002)(66066001)(3846002)(5890100001)(189998001)(77096005)(110136002)(97736004)(48376002)(7416002)(36756003)(50226002)(7846002)(6116002)(305945005)(50986999)(7736002)(586003)(81166006)(42186005)(81156014)(5003940100001)(229853001); DIR:OUT; SFP:1101; SCL:1; SRVR:DB4PR04MB267; H:lizhi-Precision-Tower-5810.am.freescale.net; FPR:; SPF:None; PTR:InfoNoRecords; MX:1; A:1; LANG:en; Received-SPF: None (protection.outlook.com: nxp.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; DB4PR04MB267; 23:ulKyijMXfsLpd8fsfgvL0tDJV8IrZOP3JeIq9LZ2yC?= =?us-ascii?Q?IAshcsBVtlRXiB712YDF+2Znt9Cfz2JBIzeHMvdlJulUQ/ohUL6aHKsPUxwR?= =?us-ascii?Q?upgKbmL47jA830yLn0CqU7SMOA5lT3v6Mh9AXtcKlhHJMKX9etgk1etmIfcN?= =?us-ascii?Q?L0ipNWebWtIWLQXKccKfA8iT4BkStPvmODAdQiLAfnoYciEC7kZznzvrkxDN?= =?us-ascii?Q?fHayP1JddJWUGIjDHa4GidlWa+FWv05xsYNyLFJZ+0w34TvxXccmRkzXbo2I?= =?us-ascii?Q?9tew+pAc9n4mnIm9A9Z7sFcLLz1XYSklXF3841XEib8itUcJ80LD1mJY210o?= =?us-ascii?Q?2wBnzN8Z+HP/MimQzDEBGa7r+tIz5tARYhHLMucYSfVRwZEJ2SLP1F3nWofd?= =?us-ascii?Q?UkWFPMN3fzJ605tiWezdG9hYJYa0cKaJOgyVjfKwD+JaknLk49tPyWplKPOh?= =?us-ascii?Q?C/44Ty/TRCizxKuuD8JP2jy9271WNHTL2B/oxObkXjNt0lQKwMQhKniRwpDZ?= =?us-ascii?Q?z0Ga5kGoBz+VHPyX0b7zchxlZc829apSf+XYRC2i/8hjo+3dN2EZclWgBoLV?= =?us-ascii?Q?LL6VZDfyRytlMUlOXMpvgeH/KrPc5Xu+/L50TVKoRjsVLcQZriS1Nn5qe5Qt?= =?us-ascii?Q?MVPVqnA5+DmiSgcNoT/V8iIZdEUAnt+QQ3r+WmzMOdzyWox7AC+GCWbl1P9n?= =?us-ascii?Q?z9XtoKA+ELaFX9bJtL1MxO35fFoRJN42v/tbaaR6K4Drwx3CPspa249M+Knm?= =?us-ascii?Q?cP4y0jOIbV2T2hsDOtQBFGcQmq7LyY9dbwFcOvuBB/Tm1pDeN2/f4PE2/8wM?= =?us-ascii?Q?xQnC9O8LKh+QDNiqsJuqL7BomknUDhuQiTi3JygR07pywJWEIcC5zuAWdZm4?= =?us-ascii?Q?3FwYwH//XKwqoimRymglyt1BRjLamq9BzmroPDlLoPrc5KLniVAGjfTXKDqt?= =?us-ascii?Q?xNwpVuProPe9JqTpkyYSu7AXao7T9XLRGNoa/LkFB9zz5sWqhSwta2hzOiNa?= =?us-ascii?Q?d/bnppgiEqgTsmFxpDyLrAbivSlZltOww6H9O1O7wy+0T+sdcvyNuXAphkox?= =?us-ascii?Q?Q5nED/j/rbVPh8uaultkiN7Ts4rTgBdfeh+ArAu+p0fDH+0g=3D=3D?= X-Microsoft-Exchange-Diagnostics: 1; DB4PR04MB267; 6:HHpFScSqMUkUkWdOckb80mw+4hBTZ7l2SJXOTlvEksEdQikvU74/h2BVhJHdlZ8A8K+6ceaQKTleHTdAExIPr4r+5BJd/gjxSl9XMjVeCVObaf7A/2D7zbFWhtU2NCySoiPwmMAUYyj11TLB/ZWYEZSKW3JKOO8S0isponAlviiqP+TfROG5xwuiNYcUJFaCahblZ3JSCGW8SKPAYx9gY7jpU96GrznM7MdYksuaxq4yy1ajYerr6adWYGnDhMaqMc6GOtlPVDgw3k1CI3GxjjlK5ERjS93XovmUCh1fD77aOgF49HZ5HtefNcDlFk1o+MTu3cl82+62CDDcDLMEbw==; 5:W4CXTBbk9V5EISwH6B5pPTsPD4k8naAtx1WUG/1ohpmP8FCd4shWiw2Sf0GEleeDqoCbiXbMfJ8whr+15jmAlEeW4XxO9nKFVyI20zfeK/YJWJb1X9M/dHRE/JDsgOZnx3HDgwsYtWbbhTeu0iFzAQ==; 24:g5mX9XABtY4JUIQ4FriJho5f5kgbkOwo05i8h41AzD+JhG2478WVWR0O1bm3NUSsv09yag2Jy+gx+bZPjJIa9TicbCLlR57UOkyTNgJqVZY=; 7:2G6CMTukHdjzsk4OjbVuBgDpV9Msu6S7Fr6Ol50LoPwtmpmUYPhuwhwhWANkKCjbg6mhY2M33tHR5SE/d3Zvi1KYVZoQZPd9QZprjgEFPNDsDIlvdggsW5mCnWCZoV7/3jWl8Nt83RjFKHlZ0uMAz+3CwPWiBycGr08SnqXu5wUiVVNK6vZ9l/ebLIoMCGeEvLAWLP55WJSsq8ZTYA98XUwaIVMPo06BYnUNykHRLzuzhLSHb4sqe1fUTssM0UPA SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-OriginatorOrg: nxp.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 06 Sep 2016 21:29:16.6467 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-Transport-CrossTenantHeadersStamped: DB4PR04MB267 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20160906_142944_222259_CBB8026E X-CRM114-Status: GOOD ( 12.79 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.20 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: mark.rutland@arm.com, peterz@infradead.org, frank.li@nxp.com, linux-kernel@vger.kernel.org, acme@kernel.org, Zhengyu Shen , alexander.shishkin@linux.intel.com, mingo@redhat.com, jerry.zhengyu.shen@gmail.com, lznuaa@gmail.com, linux-arm-kernel@lists.infradead.org Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org X-Virus-Scanned: ClamAV using ClamSMTP From: Zhengyu Shen MMDC is a multi-mode DDR controller that supports DDR3/DDR3L x16/x32/x64 and LPDDR2 two channel x16/x32 memory types. MMDC is configurable, high performance, and optimized. MMDC is present on i.MX6 Quad and i.MX6 QuadPlus devices, but this driver only supports i.MX6 Quad at the moment. MMDC provides registers for performance counters which read via this driver to help debug memory throughput and similar issues. $ perf stat -a -e mmdc/busy-cycles/,mmdc/read-accesses/,mmdc/read-bytes/,mmdc/total-cycles/,mmdc/write-accesses/,mmdc/write-bytes/ dd if=/dev/zero of=/dev/null bs=1M count=5000 Performance counter stats for 'dd if=/dev/zero of=/dev/null bs=1M count=5000': 898021787 mmdc/busy-cycles/ 14819600 mmdc/read-accesses/ 471.30 MB mmdc/read-bytes/ 2815419216 mmdc/total-cycles/ 13367354 mmdc/write-accesses/ 427.76 MB mmdc/write-bytes/ 5.334757334 seconds time elapsed Signed-off-by: Zhengyu Shen Signed-off-by: Frank Li --- Changes from v4 to v5 Remove mmdc_pmu:irq remove static variable cpuhp_mmdc_pmu remove spin_lock check is_sampling_event(event) remove unnecessary cast use hw_perf_event::prev_count Changes from v3 to v4: Tested and fixed crash relating to removing events with perf fuzzer Adjusted formatting Moved all perf event code under CONFIG_PERF_EVENTS Switched cpuhp_setup_state to cpuhp_setup_state_nocalls Changes from v2 to v3: Use WARN_ONCE instead of returning generic error values Replace CPU Notifiers with newer state machine hotplug Added additional checks on event_init for grouping and sampling Remove useless mmdc_enable_profiling function Added comments Moved start index of events from 0x01 to 0x00 Added a counter to pmu_mmdc to only stop hrtimer after all events are finished Replace readl_relaxed and writel_relaxed with readl and writel Removed duplicate update function Used devm_kasprintf when naming mmdcs probed Changes from v1 to v2: Added cpumask and migration handling support to driver Validated event during event_init Added code to properly stop counters Used perf_invalid_context instead of perf_sw_context Added hrtimer to poll for overflow Added better description Added support for multiple mmdcs arch/arm/mach-imx/mmdc.c | 435 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 433 insertions(+), 2 deletions(-) diff --git a/arch/arm/mach-imx/mmdc.c b/arch/arm/mach-imx/mmdc.c index db9621c..f1fa6d9 100644 --- a/arch/arm/mach-imx/mmdc.c +++ b/arch/arm/mach-imx/mmdc.c @@ -1,5 +1,5 @@ /* - * Copyright 2011 Freescale Semiconductor, Inc. + * Copyright 2011,2016 Freescale Semiconductor, Inc. * Copyright 2011 Linaro Ltd. * * The code contained herein is licensed under the GNU General Public @@ -10,12 +10,16 @@ * http://www.gnu.org/copyleft/gpl.html */ +#include #include +#include #include #include #include #include #include +#include +#include #include "common.h" @@ -27,8 +31,434 @@ #define BM_MMDC_MDMISC_DDR_TYPE 0x18 #define BP_MMDC_MDMISC_DDR_TYPE 0x3 +#define TOTAL_CYCLES 0x0 +#define BUSY_CYCLES 0x1 +#define READ_ACCESSES 0x2 +#define WRITE_ACCESSES 0x3 +#define READ_BYTES 0x4 +#define WRITE_BYTES 0x5 + +/* Enables, resets, freezes, overflow profiling*/ +#define DBG_DIS 0x0 +#define DBG_EN 0x1 +#define DBG_RST 0x2 +#define PRF_FRZ 0x4 +#define CYC_OVF 0x8 + +#define MMDC_MADPCR0 0x410 +#define MMDC_MADPSR0 0x418 +#define MMDC_MADPSR1 0x41C +#define MMDC_MADPSR2 0x420 +#define MMDC_MADPSR3 0x424 +#define MMDC_MADPSR4 0x428 +#define MMDC_MADPSR5 0x42C + +#define MMDC_NUM_COUNTERS 6 + +#define to_mmdc_pmu(p) container_of(p, struct mmdc_pmu, pmu) + static int ddr_type; +#ifdef CONFIG_PERF_EVENTS + +static DEFINE_IDA(mmdc_ida); + +PMU_EVENT_ATTR_STRING(total-cycles, mmdc_total_cycles, "event=0x00") +PMU_EVENT_ATTR_STRING(busy-cycles, mmdc_busy_cycles, "event=0x01") +PMU_EVENT_ATTR_STRING(read-accesses, mmdc_read_accesses, "event=0x02") +PMU_EVENT_ATTR_STRING(write-accesses, mmdc_write_accesses, "config=0x03") +PMU_EVENT_ATTR_STRING(read-bytes, mmdc_read_bytes, "event=0x04") +PMU_EVENT_ATTR_STRING(read-bytes.unit, mmdc_read_bytes_unit, "MB"); +PMU_EVENT_ATTR_STRING(read-bytes.scale, mmdc_read_bytes_scale, "0.000001"); +PMU_EVENT_ATTR_STRING(write-bytes, mmdc_write_bytes, "event=0x05") +PMU_EVENT_ATTR_STRING(write-bytes.unit, mmdc_write_bytes_unit, "MB"); +PMU_EVENT_ATTR_STRING(write-bytes.scale, mmdc_write_bytes_scale, "0.000001"); + +struct mmdc_pmu { + struct pmu pmu; + void __iomem *mmdc_base; + cpumask_t cpu; + struct hrtimer hrtimer; + unsigned int active_events; + struct device *dev; + struct perf_event *mmdc_events[MMDC_NUM_COUNTERS]; + struct hlist_node node; +}; + +static struct mmdc_pmu *cpuhp_mmdc_pmu; + +/* + * Polling period is set to one second, overflow of total-cycles (the fastest + * increasing counter) takes ten seconds so one second is safe + */ +static unsigned int mmdc_poll_period_us = 1000000; + +module_param_named(pmu_poll_period_us, mmdc_poll_period_us, uint, + S_IRUGO | S_IWUSR); + +static ktime_t mmdc_timer_period(void) +{ + return ns_to_ktime((u64)mmdc_poll_period_us * 1000); +} + +static ssize_t mmdc_cpumask_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct mmdc_pmu *pmu_mmdc = dev_get_drvdata(dev); + + return cpumap_print_to_pagebuf(true, buf, &pmu_mmdc->cpu); +} + +static struct device_attribute mmdc_cpumask_attr = +__ATTR(cpumask, S_IRUGO, mmdc_cpumask_show, NULL); + +static struct attribute *mmdc_cpumask_attrs[] = { + &mmdc_cpumask_attr.attr, + NULL, +}; + +static struct attribute_group mmdc_cpumask_attr_group = { + .attrs = mmdc_cpumask_attrs, +}; + +static struct attribute *mmdc_events_attrs[] = { + &mmdc_total_cycles.attr.attr, + &mmdc_busy_cycles.attr.attr, + &mmdc_read_accesses.attr.attr, + &mmdc_write_accesses.attr.attr, + &mmdc_read_bytes.attr.attr, + &mmdc_read_bytes_unit.attr.attr, + &mmdc_read_bytes_scale.attr.attr, + &mmdc_write_bytes.attr.attr, + &mmdc_write_bytes_unit.attr.attr, + &mmdc_write_bytes_scale.attr.attr, + NULL, +}; + +static struct attribute_group mmdc_events_attr_group = { + .name = "events", + .attrs = mmdc_events_attrs, +}; + +PMU_FORMAT_ATTR(event, "config:0-63"); +static struct attribute *mmdc_format_attrs[] = { + &format_attr_event.attr, + NULL, +}; + +static struct attribute_group mmdc_format_attr_group = { + .name = "format", + .attrs = mmdc_format_attrs, +}; + +static const struct attribute_group *attr_groups[] = { + &mmdc_events_attr_group, + &mmdc_format_attr_group, + &mmdc_cpumask_attr_group, + NULL, +}; + +static u32 mmdc_read_counter(struct mmdc_pmu *pmu_mmdc, int cfg) +{ + void __iomem *mmdc_base, *reg; + + mmdc_base = pmu_mmdc->mmdc_base; + + switch (cfg) { + case TOTAL_CYCLES: + reg = mmdc_base + MMDC_MADPSR0; + break; + case BUSY_CYCLES: + reg = mmdc_base + MMDC_MADPSR1; + break; + case READ_ACCESSES: + reg = mmdc_base + MMDC_MADPSR2; + break; + case WRITE_ACCESSES: + reg = mmdc_base + MMDC_MADPSR3; + break; + case READ_BYTES: + reg = mmdc_base + MMDC_MADPSR4; + break; + case WRITE_BYTES: + reg = mmdc_base + MMDC_MADPSR5; + break; + default: + return WARN_ONCE(1, + "invalid configuration %d for mmdc counter", cfg); + } + return readl(reg); +} + +static int mmdc_pmu_offline_cpu(unsigned int cpu, struct hlist_node *node) +{ + struct mmdc_pmu *pmu_mmdc = hlist_entry_safe(node, struct mmdc_pmu, node); + int target; + + if (!cpumask_test_and_clear_cpu(cpu, &pmu_mmdc->cpu)) + return 0; + + target = cpumask_any_but(cpu_online_mask, cpu); + if (target >= nr_cpu_ids) + return 0; + + perf_pmu_migrate_context(&pmu_mmdc->pmu, cpu, target); + cpumask_set_cpu(target, &pmu_mmdc->cpu); + + return 0; +} + +static int mmdc_event_init(struct perf_event *event) +{ + struct mmdc_pmu *pmu_mmdc = to_mmdc_pmu(event->pmu); + int cfg = event->attr.config; + struct perf_event *sibling; + + if (event->attr.type != event->pmu->type) + return -ENOENT; + + if (is_sampling_event(event) || event->attach_state & PERF_ATTACH_TASK) + return -EOPNOTSUPP; + + if (event->cpu < 0) { + dev_warn(pmu_mmdc->dev, "Can't provide per-task data!\n"); + return -EOPNOTSUPP; + } + + if (event->attr.exclude_user || + event->attr.exclude_kernel || + event->attr.exclude_hv || + event->attr.exclude_idle || + event->attr.exclude_host || + event->attr.exclude_guest || + event->attr.sample_period) + return -EINVAL; + + if (cfg < 0 || cfg >= MMDC_NUM_COUNTERS) + return -EINVAL; + + if (event->group_leader->pmu != event->pmu && + !is_software_event(event->group_leader)) + return -EINVAL; + + list_for_each_entry(sibling, &event->group_leader->sibling_list, + group_entry) { + if (sibling->pmu != event->pmu && + !is_software_event(sibling)) + return -EINVAL; + } + + event->cpu = cpumask_first(&pmu_mmdc->cpu); + return 0; +} + +static void mmdc_event_update(struct perf_event *event) +{ + struct mmdc_pmu *pmu_mmdc = to_mmdc_pmu(event->pmu); + struct hw_perf_event *hwc = &event->hw; + u64 delta, prev_raw_count, new_raw_count; + + do { + prev_raw_count = local64_read(&hwc->prev_count); + new_raw_count = mmdc_read_counter(pmu_mmdc, + event->attr.config); + } while (local64_cmpxchg(&hwc->prev_count, prev_raw_count, + new_raw_count) != prev_raw_count); + + delta = (new_raw_count - prev_raw_count) & 0xFFFFFFFF; + + local64_add(delta, &event->count); +} + +static void mmdc_event_start(struct perf_event *event, int flags) +{ + struct mmdc_pmu *pmu_mmdc = to_mmdc_pmu(event->pmu); + struct hw_perf_event *hwc = &event->hw; + void __iomem *mmdc_base, *reg; + + mmdc_base = pmu_mmdc->mmdc_base; + reg = mmdc_base + MMDC_MADPCR0; + + /* + * hrtimer is required because mmdc does not provide an interrupt so + * polling is necessary + */ + hrtimer_start(&pmu_mmdc->hrtimer, mmdc_timer_period(), + HRTIMER_MODE_REL_PINNED); + + local64_set(&hwc->prev_count, 0); + + writel(DBG_RST, reg); + writel(DBG_EN, reg); +} + +static int mmdc_event_add(struct perf_event *event, int flags) +{ + struct mmdc_pmu *pmu_mmdc = to_mmdc_pmu(event->pmu); + struct hw_perf_event *hwc = &event->hw; + + int cfg = event->attr.config; + + if (WARN_ONCE((cfg < 0 || cfg >= MMDC_NUM_COUNTERS), + "invalid configuration %d for mmdc", cfg)) + return -1; + + if (flags & PERF_EF_START) + mmdc_event_start(event, flags); + + pmu_mmdc->mmdc_events[cfg] = event; + pmu_mmdc->active_events++; + + local64_set(&hwc->prev_count, mmdc_read_counter(pmu_mmdc, cfg)); + + return 0; +} + +static void mmdc_event_stop(struct perf_event *event, int flags) +{ + struct mmdc_pmu *pmu_mmdc = to_mmdc_pmu(event->pmu); + void __iomem *mmdc_base, *reg; + int cfg = (int)event->attr.config; + + mmdc_base = pmu_mmdc->mmdc_base; + reg = mmdc_base + MMDC_MADPCR0; + + if (WARN_ONCE((cfg < 0 || cfg >= MMDC_NUM_COUNTERS), + "invalid configuration %d for mmdc counter", cfg)) + return; + + writel(PRF_FRZ, reg); + mmdc_event_update(event); +} + +static void mmdc_event_del(struct perf_event *event, int flags) +{ + struct mmdc_pmu *pmu_mmdc = to_mmdc_pmu(event->pmu); + int cfg = event->attr.config; + + pmu_mmdc->mmdc_events[cfg] = NULL; + pmu_mmdc->active_events--; + + if (pmu_mmdc->active_events <= 0) + hrtimer_cancel(&pmu_mmdc->hrtimer); + + mmdc_event_stop(event, PERF_EF_UPDATE); +} + +static void mmdc_overflow_handler(struct mmdc_pmu *pmu_mmdc) +{ + int i; + + for (i = 0; i < MMDC_NUM_COUNTERS; i++) { + struct perf_event *event = pmu_mmdc->mmdc_events[i]; + + if (event) + mmdc_event_update(event); + } +} + +static enum hrtimer_restart mmdc_timer_handler(struct hrtimer *hrtimer) +{ + struct mmdc_pmu *pmu_mmdc = container_of(hrtimer, struct mmdc_pmu, + hrtimer); + + mmdc_overflow_handler(pmu_mmdc); + hrtimer_forward_now(hrtimer, mmdc_timer_period()); + + return HRTIMER_RESTART; +} + +static int mmdc_pmu_init(struct mmdc_pmu *pmu_mmdc, + void __iomem *mmdc_base, struct device *dev) +{ + int mmdc_num; + + *pmu_mmdc = (struct mmdc_pmu) { + .pmu = (struct pmu) { + .task_ctx_nr = perf_invalid_context, + .attr_groups = attr_groups, + .event_init = mmdc_event_init, + .add = mmdc_event_add, + .del = mmdc_event_del, + .start = mmdc_event_start, + .stop = mmdc_event_stop, + .read = mmdc_event_update, + }, + .mmdc_base = mmdc_base, + .dev = dev, + .active_events = 0, + }; + + mmdc_num = ida_simple_get(&mmdc_ida, 0, 0, GFP_KERNEL); + + return mmdc_num; +} + +static int imx_mmdc_remove(struct platform_device *pdev) +{ + struct mmdc_pmu *pmu_mmdc = platform_get_drvdata(pdev); + + perf_pmu_unregister(&pmu_mmdc->pmu); + cpuhp_remove_state_nocalls(CPUHP_ONLINE); + cpuhp_mmdc_pmu = NULL; + kfree(pmu_mmdc); + return 0; +} + +static int imx_mmdc_perf_init(struct platform_device *pdev, void __iomem *mmdc_base) +{ + struct mmdc_pmu *pmu_mmdc; + char *name; + int mmdc_num; + int ret; + + pmu_mmdc = kzalloc(sizeof(*pmu_mmdc), GFP_KERNEL); + if (!pmu_mmdc) { + pr_err("failed to allocate PMU device!\n"); + return -ENOMEM; + } + + mmdc_num = mmdc_pmu_init(pmu_mmdc, mmdc_base, &pdev->dev); + if (mmdc_num == 0) + name = "mmdc"; + else + name = devm_kasprintf(&pdev->dev, + GFP_KERNEL, "mmdc%d", mmdc_num); + + hrtimer_init(&pmu_mmdc->hrtimer, CLOCK_MONOTONIC, + HRTIMER_MODE_REL); + pmu_mmdc->hrtimer.function = mmdc_timer_handler; + + cpuhp_state_add_instance_nocalls(CPUHP_ONLINE, + &pmu_mmdc->node); + cpumask_set_cpu(smp_processor_id(), &pmu_mmdc->cpu); + ret = cpuhp_setup_state_multi(CPUHP_AP_NOTIFY_ONLINE, + "MMDC_ONLINE", NULL, + mmdc_pmu_offline_cpu); + if (ret) + { + pr_err("cpuhp_setup_state_multi failure\n"); + goto pmu_register_err; + } + + ret = perf_pmu_register(&(pmu_mmdc->pmu), name, -1); + platform_set_drvdata(pdev, pmu_mmdc); + if (ret) + goto pmu_register_err; + return 0; + +pmu_register_err: + pr_warn("MMDC Perf PMU failed (%d), disabled\n", ret); + hrtimer_cancel(&pmu_mmdc->hrtimer); + kfree(pmu_mmdc); + return ret; +} + +#else +#define imx_mmdc_remove NULL +#define imx_mmdc_perf_init(pdev, mmdc_base) 0 +#endif + static int imx_mmdc_probe(struct platform_device *pdev) { struct device_node *np = pdev->dev.of_node; @@ -62,7 +492,7 @@ static int imx_mmdc_probe(struct platform_device *pdev) return -EBUSY; } - return 0; + return imx_mmdc_perf_init(pdev, mmdc_base); } int imx_mmdc_get_ddr_type(void) @@ -81,6 +511,7 @@ static struct platform_driver imx_mmdc_driver = { .of_match_table = imx_mmdc_dt_ids, }, .probe = imx_mmdc_probe, + .remove = imx_mmdc_remove, }; static int __init imx_mmdc_init(void)