From patchwork Wed Dec 16 16:52:38 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Grzegorz Jaszczyk X-Patchwork-Id: 344517 Delivered-To: patch@linaro.org Received: by 2002:a17:906:4755:0:0:0:0 with SMTP id j21csp506519ejs; Wed, 16 Dec 2020 08:55:00 -0800 (PST) X-Google-Smtp-Source: ABdhPJzePqh8CGYNS7bPc3q50alEtE9Qz8Xqrw9qnlcCKOtBqH/QpPHYRlor5S/SxMD/EpeC1Cr4 X-Received: by 2002:a17:907:7253:: with SMTP id ds19mr33017597ejc.166.1608137700644; Wed, 16 Dec 2020 08:55:00 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1608137700; cv=none; d=google.com; s=arc-20160816; b=g4MYHEb+mFQEXCq5U8P9PPMCqPOG5OPmo2WUoFm4TiOAa8inpPwlcfXNO8eMh5XVeL 26rK9Nga5ajyxvkVvk5jAbMXPf9D2s6OMepS6Nkisu/72bipadDodzcwjQNYUCphkdZU S33J0ANDpTeuQk6rXkD4dGovN6Bh7cshThqRXgTSHsEOqOV/SDlK+Tt7fFyhM6M1xfan RcZ7MangZ8f2Rjv83Et/En1PUnLFETT8FnSmGeM95TPlbm+S0LtovGwfNNUP7i/p4Sgp brawcznbF91VMAbx4AHutwLQeX2Kxn/Uq58DYwbYmpOtUKvYOO96ZIyfHz5w67X4uAl4 gLrQ== 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=P45j3wiFR9Tri3Ofzw18omORpyymmURP37wmkg2klyw=; b=c/sqKFVb2/QgvEY21JLmFybLxK2SL5KIZDCoO37pofC9qL/QBD1vrFN73N1Km5weOI fCjwApiN9tY/Q90n4vFCAAlTA0JV1eCcgx1qZW32CsvFWpen4zaRLgah16iIqsLzEvzy FyQj04psKY7Cd2q/MrCNRPf4WyOSmUfJqoRbHQl3E8k+oOaBZUf6VRGCeKmSPiuAXXSp oolwMhQjViOqVqovTGheSZmgIzLl8Wx7Mt11xzwt7KdKAghTzKnyP/Apoi/ODeTmirBV cyc3j7fUiK5Bd9IGMJOSw3ecA1eAGngP3+4imVaVBVidrkS7yXMFFXwneA1Y04UPtRcX m/mA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b="TdD0moJ/"; 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 ml22si1153631ejb.172.2020.12.16.08.55.00; Wed, 16 Dec 2020 08:55:00 -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="TdD0moJ/"; 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 S1726884AbgLPQy4 (ORCPT + 7 others); Wed, 16 Dec 2020 11:54:56 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:34552 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726880AbgLPQy4 (ORCPT ); Wed, 16 Dec 2020 11:54:56 -0500 Received: from mail-lf1-x129.google.com (mail-lf1-x129.google.com [IPv6:2a00:1450:4864:20::129]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 920C7C0611BB for ; Wed, 16 Dec 2020 08:53:00 -0800 (PST) Received: by mail-lf1-x129.google.com with SMTP id a12so50057898lfl.6 for ; Wed, 16 Dec 2020 08:53:00 -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=P45j3wiFR9Tri3Ofzw18omORpyymmURP37wmkg2klyw=; b=TdD0moJ/izalkc+QkYizCyULJHTgkKxJXdM4rvie7LnZSFbXVrqnphFHAPrrZpsQL7 T3VK6npCnSgtGJ6lRKTKSDps/FccK7MjxyQaG+a6Ufxfd239tiLTnqeyACshBTWsPSkn b0g3RoRDb9PVPreKG0wDBepphnZu9myExIwyvhU5YEUb60ngOGkoSrK7/VV8GX6irHNF f7QA0/cbIOAUGMs4pemsUr+bjFLVW0SZH2+Q1tDBiMlCKVKqQQVyLg0iW3L6ClO0ZIP9 R+AyHbW2dNxhzibGtnsN7YVPHz+7nEAuFceBcVa7sjol6RPWP5VMWAlhoyq1oIdPEyZJ yT7Q== 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=P45j3wiFR9Tri3Ofzw18omORpyymmURP37wmkg2klyw=; b=GQrB08gNyO/vnfcPOZhr+wC+f46H5s1z/xeRzRmcIiH/tKTLeyCvp20/+NBbteb8tx maPFvl1mdZ0Ym6qclh0TUD9MomBx80V9XtXahNgD0lV6WsxuTf43VScfb5soQg9WuggA kOoGYCDYL0NgCeap5FEuwH2u5p9+d6leFN1BCX/0DAcY+BpGx96EI5lUlCf23iaAPzvd SRxmFtTJW6U/6w6W+hfAMrcHvIbHRumw46nVuufzVYJcXzlBLRG0sXnwoV7quMQeyNYI yRBaO+t1SihnXrhzVOGWjNBay6P/YqWD4HFnuqAZsxyHrHIB05GIuGGSY0NiZY83YuG+ KwyQ== X-Gm-Message-State: AOAM530A7szACdWj0usoyLKdCcLDIRgeT6JWxn0KoI80ricLQDu5bS1/ JpIQ/+X/tS2wg+qxkOBC7Tts3Q== X-Received: by 2002:a19:418e:: with SMTP id o136mr13145940lfa.80.1608137577965; Wed, 16 Dec 2020 08:52:57 -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 t3sm281645lfe.263.2020.12.16.08.52.56 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Wed, 16 Dec 2020 08:52:57 -0800 (PST) From: Grzegorz Jaszczyk To: ohad@wizery.com, bjorn.andersson@linaro.org, mathieu.poirier@linaro.org, robh+dt@kernel.org, s-anna@ti.com, ssantosh@kernel.org Cc: grzegorz.jaszczyk@linaro.org, linux-remoteproc@vger.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, t-kristo@ti.com Subject: [PATCH v2 4/5] remoteproc: pru: Add pru_rproc_set_ctable() function Date: Wed, 16 Dec 2020 17:52:38 +0100 Message-Id: <20201216165239.2744-5-grzegorz.jaszczyk@linaro.org> X-Mailer: git-send-email 2.29.0 In-Reply-To: <20201216165239.2744-1-grzegorz.jaszczyk@linaro.org> References: <20201216165239.2744-1-grzegorz.jaszczyk@linaro.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org From: Roger Quadros Some firmwares expect the OS drivers to configure the CTABLE entries publishing dynamically allocated memory regions. For example, the PRU Ethernet firmwares use the C28 and C30 entries for retrieving the Shared RAM and System SRAM (OCMC) areas allocated by the PRU Ethernet client driver. Provide a way for users to do that through a new API, pru_rproc_set_ctable(). The API returns 0 on success and a negative value on error. NOTE: The programmable CTABLE entries are typically re-programmed by the PRU firmwares when dealing with a certain block of memory during block processing. This API provides an interface to the PRU client drivers to publish a dynamically allocated memory block with the PRU firmware using a CTABLE entry instead of a negotiated address in shared memory. Additional synchronization may be needed between the PRU client drivers and firmwares if different addresses needs to be published at run-time reusing the same CTABLE entry. Co-developed-by: Andrew F. Davis Signed-off-by: Andrew F. Davis Co-developed-by: Suman Anna Signed-off-by: Suman Anna Signed-off-by: Roger Quadros Co-developed-by: Grzegorz Jaszczyk Signed-off-by: Grzegorz Jaszczyk --- drivers/remoteproc/pru_rproc.c | 59 ++++++++++++++++++++++++++++++++++ include/linux/pruss.h | 22 +++++++++++++ 2 files changed, 81 insertions(+) -- 2.29.0 diff --git a/drivers/remoteproc/pru_rproc.c b/drivers/remoteproc/pru_rproc.c index 3ffd49f77cfc..a37c3f5838ea 100644 --- a/drivers/remoteproc/pru_rproc.c +++ b/drivers/remoteproc/pru_rproc.c @@ -118,6 +118,7 @@ struct pru_private_data { * @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 + * @rmw_lock: lock for read, modify, write operations on registers * @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 @@ -135,6 +136,7 @@ struct pru_rproc { unsigned int *mapped_irq; struct pru_irq_rsc *pru_interrupt_map; size_t pru_interrupt_map_sz; + spinlock_t rmw_lock; /* register access lock */ u32 dbg_single_step; u32 dbg_continuous; u8 evt_count; @@ -151,6 +153,23 @@ 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 +void pru_control_set_reg(struct pru_rproc *pru, unsigned int reg, + u32 mask, u32 set) +{ + u32 val; + unsigned long flags; + + spin_lock_irqsave(&pru->rmw_lock, flags); + + val = pru_control_read_reg(pru, reg); + val &= ~mask; + val |= (set & mask); + pru_control_write_reg(pru, reg, val); + + spin_unlock_irqrestore(&pru->rmw_lock, flags); +} + static struct rproc *__pru_rproc_get(struct device_node *np, int index) { struct device_node *rproc_np = NULL; @@ -266,6 +285,45 @@ void pru_rproc_put(struct rproc *rproc) } EXPORT_SYMBOL_GPL(pru_rproc_put); +/** + * pru_rproc_set_ctable() - set the constant table index for the PRU + * @rproc: the rproc instance of the PRU + * @c: constant table index to set + * @addr: physical address to set it to + * + * Return: 0 on success, or errno in error case. + */ +int pru_rproc_set_ctable(struct rproc *rproc, enum pru_ctable_idx c, u32 addr) +{ + struct pru_rproc *pru = rproc->priv; + unsigned int reg; + u32 mask, set; + u16 idx; + u16 idx_mask; + + if (IS_ERR_OR_NULL(rproc)) + return -EINVAL; + + if (!rproc->dev.parent || !is_pru_rproc(rproc->dev.parent)) + return -ENODEV; + + /* pointer is 16 bit and index is 8-bit so mask out the rest */ + idx_mask = (c >= PRU_C28) ? 0xFFFF : 0xFF; + + /* ctable uses bit 8 and upwards only */ + idx = (addr >> 8) & idx_mask; + + /* configurable ctable (i.e. C24) starts at PRU_CTRL_CTBIR0 */ + reg = PRU_CTRL_CTBIR0 + 4 * (c >> 1); + mask = idx_mask << (16 * (c & 1)); + set = idx << (16 * (c & 1)); + + pru_control_set_reg(pru, reg, mask, set); + + return 0; +} +EXPORT_SYMBOL_GPL(pru_rproc_set_ctable); + 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); @@ -895,6 +953,7 @@ static int pru_rproc_probe(struct platform_device *pdev) pru->pruss = platform_get_drvdata(ppdev); pru->rproc = rproc; pru->fw_name = fw_name; + spin_lock_init(&pru->rmw_lock); mutex_init(&pru->lock); for (i = 0; i < ARRAY_SIZE(mem_names); i++) { diff --git a/include/linux/pruss.h b/include/linux/pruss.h index 43cb5c2eed08..903d0c0b75be 100644 --- a/include/linux/pruss.h +++ b/include/linux/pruss.h @@ -23,13 +23,29 @@ enum pruss_pru_id { PRUSS_NUM_PRUS, }; +/* + * enum pru_ctable_idx - Configurable Constant table index identifiers + */ +enum pru_ctable_idx { + PRU_C24 = 0, + PRU_C25, + PRU_C26, + PRU_C27, + PRU_C28, + PRU_C29, + PRU_C30, + PRU_C31, +}; + struct device_node; +struct rproc; #if IS_ENABLED(CONFIG_PRU_REMOTEPROC) struct rproc *pru_rproc_get(struct device_node *np, int index, enum pruss_pru_id *pru_id); void pru_rproc_put(struct rproc *rproc); +int pru_rproc_set_ctable(struct rproc *rproc, enum pru_ctable_idx c, u32 addr); #else @@ -41,6 +57,12 @@ pru_rproc_get(struct device_node *np, int index, enum pruss_pru_id *pru_id) static inline void pru_rproc_put(struct rproc *rproc) { } +static inline int pru_rproc_set_ctable(struct rproc *rproc, + enum pru_ctable_idx c, u32 addr) +{ + return -ENOTSUPP; +} + #endif /* CONFIG_PRU_REMOTEPROC */ static inline bool is_pru_rproc(struct device *dev)