From patchwork Fri Dec 4 20:18:05 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Grzegorz Jaszczyk X-Patchwork-Id: 337770 Delivered-To: patch@linaro.org Received: by 2002:a02:85a7:0:0:0:0:0 with SMTP id d36csp740180jai; Fri, 4 Dec 2020 12:20:15 -0800 (PST) X-Google-Smtp-Source: ABdhPJz4YurXSirjFvEw/580qVxFrVHxU8KvrWlpxxrLUVrSJIf1beK7oFw9Mx1MQmgnypTjSMvp X-Received: by 2002:a50:fe88:: with SMTP id d8mr9192789edt.36.1607113215678; Fri, 04 Dec 2020 12:20:15 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1607113215; cv=none; d=google.com; s=arc-20160816; b=HKzkYJw5GArKPRG9fZ95dbiU3tw8vfZFvsKKGkMT+FlSKVPpCUCYip6AjBDX+IQU33 RpskmXwPBKJL8aFjvRNQz9C0dOr0V61AmRxvPkZVlCztIkAyRBWLAQxGCH/hFofqIesN +PBcsaAIRblB8uVzWesog0gcFEVDKzq51wGmjo/9AsBYg3BQsnr26tIZ4rZ5Th/WIasf m1nsFDxL3/flsCzSIQC3DbqszxvWaFTgCh/lN9/q+IwIQk/lbXX+h2WOVqs+TxR3Vyiw Q92T6MYk5TroRv53v5arihTjKj32vgxRIbmroG4FptmruMqAHol20UXJFrkZ8UPr6tY4 m1cg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=xt8QuWXk/g6askbWi99LuVBrM97JNGcNTAl0D+UbaYI=; b=1BD8hDKI1fyhZCgX9jai+QliVVRT84yErMKD/9VERnD1EfeximQ4qUw8/LeYOSdkcA Wfrf3GYfqWqlg5Ge5SBinN9TBHepuhJh8LDUUJIGdlj4yP+D2fRuM1BjJs7XqvrkE1Te rkLmIx0eKj899kXk1cZcqWvXud/+7/8qAk728puqlF8HNLEpjGUGbtzrOBn0tj7qWa5K lr2COz3i/gwRBXLgWbLF1uJsncXxoW2QDvem/SWhklQ0nfN/2qQnUMj0r8hYMEwV1gHG 0dKI0GssmQ8ms9iZwumT1X4vTpooplyOwBAec7Rx19hKw3a0VmVGFMABHmg/auG8oDIx KBag== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=rKfCVJUw; spf=pass (google.com: domain of devicetree-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=devicetree-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [23.128.96.18]) by mx.google.com with ESMTP id o2si2073501ejn.501.2020.12.04.12.20.15; Fri, 04 Dec 2020 12:20:15 -0800 (PST) Received-SPF: pass (google.com: domain of devicetree-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) client-ip=23.128.96.18; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=rKfCVJUw; spf=pass (google.com: domain of devicetree-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=devicetree-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2387493AbgLDUTw (ORCPT + 6 others); Fri, 4 Dec 2020 15:19:52 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:35384 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2387494AbgLDUTu (ORCPT ); Fri, 4 Dec 2020 15:19:50 -0500 Received: from mail-lf1-x141.google.com (mail-lf1-x141.google.com [IPv6:2a00:1450:4864:20::141]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 4A543C094241 for ; Fri, 4 Dec 2020 12:18:23 -0800 (PST) Received: by mail-lf1-x141.google.com with SMTP id v14so9391514lfo.3 for ; Fri, 04 Dec 2020 12:18:23 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=xt8QuWXk/g6askbWi99LuVBrM97JNGcNTAl0D+UbaYI=; b=rKfCVJUwnd66MPqnMbOC508RPjgxrmg4EUxCnqngmcl/AnBfBf5eQFoQlK1so9JKc3 ousXxG8hArnns/n+jOrvMbNouOh/wK51EZqkJjpLiGJUdyacqJ3dbC7zXXPj8WafTdrl 4U+Mzf19EfB5F7I2R2q9L3UTRd3SQUcC43jb2+PEi610jqTycoHdOmDxfAxLi5Jj9KDe SU2DX81y4K5/5wg077xEMWvlwnMZzt5hyJlVZjJAyRz8KeqxnNiCgOPlr73Lg1sWjPHB JYUoyqa3t7hn7tN5+vuN8jHsnOPLukfl5mmVAa2b7982jUP334Hr81u44KGuX1+EIjdw itsQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=xt8QuWXk/g6askbWi99LuVBrM97JNGcNTAl0D+UbaYI=; b=TvkTH8oikkBHYi8pSatCDeoKyEroa/GrELivtnHUOfsY4R6p/2rgFy2BwSR+F3Dxid 2lqKaRE8FLch9wyQ2W5EHvYtxmLr7zP4q7J52AiM+6WCUeK15sEf/aLS0yKhknxFDvHO YHZkdsOsbj6RaWSvf0GlX+tR9VpN56AvZj8KcRIe16+0pgsueZqdebcJkeHrznL9VywK j7hVf1VHO18QHOLyCcEjAQSEeC0gm4Ed4uzldRgKLG2glJx3lFcf1S7MxcJUTmJ/rbzv 7s4fY1MZZmMwjbZD7nP725Brl8QMkHyLnLo3PcSmn2irK9ddyvnBODJ7CMS0s1zWAMEI VMsQ== X-Gm-Message-State: AOAM530ZJEcuY9rX7IgPTUnS9aekmEhNewN/9r5OOPtD4ua7FutvVaXQ nO8BtF5P569srVmSj5BAe2hAIQ== X-Received: by 2002:a19:6144:: with SMTP id m4mr3959929lfk.546.1607113101740; Fri, 04 Dec 2020 12:18:21 -0800 (PST) Received: from gilgamesh.semihalf.com (193-106-246-138.noc.fibertech.net.pl. [193.106.246.138]) by smtp.gmail.com with ESMTPSA id w21sm2036918lff.280.2020.12.04.12.18.20 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Fri, 04 Dec 2020 12:18:21 -0800 (PST) From: Grzegorz Jaszczyk To: ohad@wizery.com, bjorn.andersson@linaro.org, mathieu.poirier@linaro.org, s-anna@ti.com Cc: grzegorz.jaszczyk@linaro.org, linux-remoteproc@vger.kernel.org, robh+dt@kernel.org, lee.jones@linaro.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-omap@vger.kernel.org, linux-arm-kernel@lists.infradead.org, praneeth@ti.com, rogerq@ti.com Subject: [PATCH v3 4/6] remoteproc: pru: Add pru-specific debugfs support Date: Fri, 4 Dec 2020 21:18:05 +0100 Message-Id: <20201204201807.14716-5-grzegorz.jaszczyk@linaro.org> X-Mailer: git-send-email 2.29.0 In-Reply-To: <20201204201807.14716-1-grzegorz.jaszczyk@linaro.org> References: <20201204201807.14716-1-grzegorz.jaszczyk@linaro.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org From: Suman Anna The remoteproc core creates certain standard debugfs entries, that does not give a whole lot of useful information for the PRUs. The PRU remoteproc driver is enhanced to add additional debugfs entries for PRU. These will be auto-cleaned up when the parent rproc debug directory is removed. The enhanced debugfs support adds two new entries: 'regs' and 'single_step'. The 'regs' dumps out the useful CTRL sub-module registers as well as each of the 32 GPREGs and CT_REGs registers. The GPREGs and CT_REGs though are printed only when the PRU is halted and accessible as per the IP design. The 'single_step' utilizes the single-step execution of the PRU cores. Writing a non-zero value performs a single step, and a zero value restores the PRU to execute in the same mode as the mode before the first single step. (note: if the PRU is halted because of a halt instruction, then no change occurs). Logic for setting the PC and jumping over a halt instruction shall be added in the future. Signed-off-by: Suman Anna Signed-off-by: Grzegorz Jaszczyk Reviewed-by: Mathieu Poirier --- v2->v3: Address Mathieu comments: - Remove extra line before DEFINE_SHOW_ATTRIBUTE(). - Add Reviewed-by: tag. --- drivers/remoteproc/pru_rproc.c | 136 +++++++++++++++++++++++++++++++++ 1 file changed, 136 insertions(+) -- 2.29.0 diff --git a/drivers/remoteproc/pru_rproc.c b/drivers/remoteproc/pru_rproc.c index 4ef59d15d888..b22c4903299e 100644 --- a/drivers/remoteproc/pru_rproc.c +++ b/drivers/remoteproc/pru_rproc.c @@ -11,6 +11,7 @@ */ #include +#include #include #include #include @@ -25,6 +26,13 @@ /* PRU_ICSS_PRU_CTRL registers */ #define PRU_CTRL_CTRL 0x0000 #define PRU_CTRL_STS 0x0004 +#define PRU_CTRL_WAKEUP_EN 0x0008 +#define PRU_CTRL_CYCLE 0x000C +#define PRU_CTRL_STALL 0x0010 +#define PRU_CTRL_CTBIR0 0x0020 +#define PRU_CTRL_CTBIR1 0x0024 +#define PRU_CTRL_CTPPR0 0x0028 +#define PRU_CTRL_CTPPR1 0x002C /* CTRL register bit-fields */ #define CTRL_CTRL_SOFT_RST_N BIT(0) @@ -34,6 +42,10 @@ #define CTRL_CTRL_SINGLE_STEP BIT(8) #define CTRL_CTRL_RUNSTATE BIT(15) +/* PRU_ICSS_PRU_DEBUG registers */ +#define PRU_DEBUG_GPREG(x) (0x0000 + (x) * 4) +#define PRU_DEBUG_CT_REG(x) (0x0080 + (x) * 4) + /* PRU Core IRAM address masks */ #define PRU_IRAM_ADDR_MASK 0x3ffff #define PRU0_IRAM_ADDR_MASK 0x34000 @@ -73,6 +85,8 @@ enum pru_iomem { * @mapped_irq: virtual interrupt numbers of created fw specific mapping * @pru_interrupt_map: pointer to interrupt mapping description (firmware) * @pru_interrupt_map_sz: pru_interrupt_map size + * @dbg_single_step: debug state variable to set PRU into single step mode + * @dbg_continuous: debug state variable to restore PRU execution mode * @evt_count: number of mapped events */ struct pru_rproc { @@ -85,6 +99,8 @@ struct pru_rproc { unsigned int *mapped_irq; struct pru_irq_rsc *pru_interrupt_map; size_t pru_interrupt_map_sz; + u32 dbg_single_step; + u32 dbg_continuous; u8 evt_count; }; @@ -99,6 +115,124 @@ void pru_control_write_reg(struct pru_rproc *pru, unsigned int reg, u32 val) writel_relaxed(val, pru->mem_regions[PRU_IOMEM_CTRL].va + reg); } +static inline u32 pru_debug_read_reg(struct pru_rproc *pru, unsigned int reg) +{ + return readl_relaxed(pru->mem_regions[PRU_IOMEM_DEBUG].va + reg); +} + +static int regs_show(struct seq_file *s, void *data) +{ + struct rproc *rproc = s->private; + struct pru_rproc *pru = rproc->priv; + int i, nregs = 32; + u32 pru_sts; + int pru_is_running; + + seq_puts(s, "============== Control Registers ==============\n"); + seq_printf(s, "CTRL := 0x%08x\n", + pru_control_read_reg(pru, PRU_CTRL_CTRL)); + pru_sts = pru_control_read_reg(pru, PRU_CTRL_STS); + seq_printf(s, "STS (PC) := 0x%08x (0x%08x)\n", pru_sts, pru_sts << 2); + seq_printf(s, "WAKEUP_EN := 0x%08x\n", + pru_control_read_reg(pru, PRU_CTRL_WAKEUP_EN)); + seq_printf(s, "CYCLE := 0x%08x\n", + pru_control_read_reg(pru, PRU_CTRL_CYCLE)); + seq_printf(s, "STALL := 0x%08x\n", + pru_control_read_reg(pru, PRU_CTRL_STALL)); + seq_printf(s, "CTBIR0 := 0x%08x\n", + pru_control_read_reg(pru, PRU_CTRL_CTBIR0)); + seq_printf(s, "CTBIR1 := 0x%08x\n", + pru_control_read_reg(pru, PRU_CTRL_CTBIR1)); + seq_printf(s, "CTPPR0 := 0x%08x\n", + pru_control_read_reg(pru, PRU_CTRL_CTPPR0)); + seq_printf(s, "CTPPR1 := 0x%08x\n", + pru_control_read_reg(pru, PRU_CTRL_CTPPR1)); + + seq_puts(s, "=============== Debug Registers ===============\n"); + pru_is_running = pru_control_read_reg(pru, PRU_CTRL_CTRL) & + CTRL_CTRL_RUNSTATE; + if (pru_is_running) { + seq_puts(s, "PRU is executing, cannot print/access debug registers.\n"); + return 0; + } + + for (i = 0; i < nregs; i++) { + seq_printf(s, "GPREG%-2d := 0x%08x\tCT_REG%-2d := 0x%08x\n", + i, pru_debug_read_reg(pru, PRU_DEBUG_GPREG(i)), + i, pru_debug_read_reg(pru, PRU_DEBUG_CT_REG(i))); + } + + return 0; +} +DEFINE_SHOW_ATTRIBUTE(regs); + +/* + * Control PRU single-step mode + * + * This is a debug helper function used for controlling the single-step + * mode of the PRU. The PRU Debug registers are not accessible when the + * PRU is in RUNNING state. + * + * Writing a non-zero value sets the PRU into single-step mode irrespective + * of its previous state. The PRU mode is saved only on the first set into + * a single-step mode. Writing a zero value will restore the PRU into its + * original mode. + */ +static int pru_rproc_debug_ss_set(void *data, u64 val) +{ + struct rproc *rproc = data; + struct pru_rproc *pru = rproc->priv; + u32 reg_val; + + val = val ? 1 : 0; + if (!val && !pru->dbg_single_step) + return 0; + + reg_val = pru_control_read_reg(pru, PRU_CTRL_CTRL); + + if (val && !pru->dbg_single_step) + pru->dbg_continuous = reg_val; + + if (val) + reg_val |= CTRL_CTRL_SINGLE_STEP | CTRL_CTRL_EN; + else + reg_val = pru->dbg_continuous; + + pru->dbg_single_step = val; + pru_control_write_reg(pru, PRU_CTRL_CTRL, reg_val); + + return 0; +} + +static int pru_rproc_debug_ss_get(void *data, u64 *val) +{ + struct rproc *rproc = data; + struct pru_rproc *pru = rproc->priv; + + *val = pru->dbg_single_step; + + return 0; +} +DEFINE_SIMPLE_ATTRIBUTE(pru_rproc_debug_ss_fops, pru_rproc_debug_ss_get, + pru_rproc_debug_ss_set, "%llu\n"); + +/* + * Create PRU-specific debugfs entries + * + * The entries are created only if the parent remoteproc debugfs directory + * exists, and will be cleaned up by the remoteproc core. + */ +static void pru_rproc_create_debug_entries(struct rproc *rproc) +{ + if (!rproc->dbg_dir) + return; + + debugfs_create_file("regs", 0400, rproc->dbg_dir, + rproc, ®s_fops); + debugfs_create_file("single_step", 0600, rproc->dbg_dir, + rproc, &pru_rproc_debug_ss_fops); +} + static void pru_dispose_irq_mapping(struct pru_rproc *pru) { while (pru->evt_count--) { @@ -571,6 +705,8 @@ static int pru_rproc_probe(struct platform_device *pdev) return ret; } + pru_rproc_create_debug_entries(rproc); + dev_dbg(dev, "PRU rproc node %pOF probed successfully\n", np); return 0;