From patchwork Fri Dec 11 14:29:30 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Grzegorz Jaszczyk X-Patchwork-Id: 341969 Delivered-To: patch@linaro.org Received: by 2002:a02:85a7:0:0:0:0:0 with SMTP id d36csp591598jai; Fri, 11 Dec 2020 06:33:27 -0800 (PST) X-Google-Smtp-Source: ABdhPJwmNUaT4CQW61ARciEig2Z1I7dgoUx87kZN+LrcFpkojUfOGlNKGLEV4Ce5RzSBUfsFm410 X-Received: by 2002:a17:907:11ca:: with SMTP id va10mr144540ejb.78.1607697207739; Fri, 11 Dec 2020 06:33:27 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1607697207; cv=none; d=google.com; s=arc-20160816; b=suSgqu1NVFpKMvfWptxQOwdFVu0TsU5sZJbTdGxm1pmpV4nINk8HL4rwmCv5ZVvAya k1LyJeetqKxjN9KwQtFIIuLg2Zbe9SFa0sdMwIDYyDziqSW5QX+AyEw3QGR2cOlWFRtS +JwuMl8Udy/t/lsfURb/JTBY2Q04uo9IYUsMfek5Mfsx/PEdvnz2Rwng1lagRtfv1E23 +WZ6B8zZyAEAf0rr9OR3UtEcgFKewS5GREU1gjpzjcRBqasHW/8CwvGP3TLJfHcXXRvP dJeFrlG95H6z9+hN+7XOxA6LEu0+rLZMf3y+E0ISrAC5i1HZWBu9vaclIliBKD9fdQpt r45g== 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=C1SR8RrxOc74lsMmszdu5piQ6864h8pZBYqiJVBluj4=; b=h02kSNy3NgFvdmGEgoUVRmBLhIJ4jhI0uwr5QdKw/2fjlWh5fUNS0PvWIl2j3XplLq u0hwfNdswHU+ZUk3ezTkB5CmSQ0hwHxKooeax4Fix8AB39dyiL14zyGEgy8Crfa/YAEO NDJxy71HhpVgrDDhXcIolR76U+Qa1aKbiifSTOVj+zQk+iCL7KbU9YKFHOaOXl+ZRuLZ pZlKhAvzpthBzS48d4dio6+Qk3vJVA3Bga2tpr+8NZGHkK0qIcqiKq02FHDcN8qlhkjf 7VcTr+ooTh/kzeC9uhc9XDEHzBYgNp/ustL2X8VTBBx96XhTZqCHb60aIaQY6Vkgv/jt 29XQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=cP5FweuW; 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 l89si5784444ede.577.2020.12.11.06.33.27; Fri, 11 Dec 2020 06:33:27 -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=cP5FweuW; 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 S2406249AbgLKOcJ (ORCPT + 7 others); Fri, 11 Dec 2020 09:32:09 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:45002 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2406244AbgLKOcE (ORCPT ); Fri, 11 Dec 2020 09:32:04 -0500 Received: from mail-lf1-x142.google.com (mail-lf1-x142.google.com [IPv6:2a00:1450:4864:20::142]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 30D6FC061282 for ; Fri, 11 Dec 2020 06:30:46 -0800 (PST) Received: by mail-lf1-x142.google.com with SMTP id h19so13547006lfc.12 for ; Fri, 11 Dec 2020 06:30:46 -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=C1SR8RrxOc74lsMmszdu5piQ6864h8pZBYqiJVBluj4=; b=cP5FweuWQW4jWJFUOEYzkaeaIE0uuS5uRoDi1M6DG/Z/A/wqXB1gW7LqwfjyH80kzN 8l3ZMTxA6w9CyZiFmP8lyTMWjMRpQ/GxtRFZP7F9C+YczNRJtrZV3+pea50FxiOwTEkW KReElXdk4kgKObNkx7TYTHxevsOx8krJyweDA49nbNvUoUWDJwwtFlQGRaxM5tB7/PMh 1o0vi/hbuR3oRIaDwUdIujKLzHLQBpjoYEhYUrkrgdeymoPrp3Bppf6MsAQm4Qv0qz/+ LoXyUHgdrZa2TN0VFZ5cIByUn9Scc8L2U+YRqWIS0N2oABi3ksfMl3wRkKlm54jRuVV+ ZucQ== 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=C1SR8RrxOc74lsMmszdu5piQ6864h8pZBYqiJVBluj4=; b=BERKXR0hC+Udih0XIZZUPoqrgEwmg5TgTQ1TCPsZIsDcOEGGhwDRWmqQWHSZ9gRk/w 6RoJjjidjgSSwde20ehhwRYFldyCBaXUWPmd+cuOQzHmEd7bRjEqtleuWfeKKAN0je6C blvMMQeZ5Th9ZASHcrS967SD6z3RmigYtxAIdV8h2Ajd28vDzWAsq3jha7imSjgT/Y+i Y23+Y6bdHDJQXeTQIswfAwb/W82S2ZVPctForh3cAML4c7z/2O/CX601Tcl6YBsygKsu m+JoOfUIp4GyJpSJmrmTbxAeHrtVdd6LiD5Zfc2SJ0eR7n1TMdUlrzEcAyadn39WPLcT 98KA== X-Gm-Message-State: AOAM5326OgJxpU+AUtiCphCpFrqXmx/MU7JmAQzNMj9BsLfwdmZtxdbA Xe2xVUur8aryGEy/Aa5Xs4WzhQ== X-Received: by 2002:a19:c8cc:: with SMTP id y195mr1120505lff.352.1607697044656; Fri, 11 Dec 2020 06:30:44 -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 x26sm906491lfq.112.2020.12.11.06.30.43 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Fri, 11 Dec 2020 06:30:44 -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 Subject: [PATCH 2/5] remoteproc: pru: Add APIs to get and put the PRU cores Date: Fri, 11 Dec 2020 15:29:30 +0100 Message-Id: <20201211142933.25784-3-grzegorz.jaszczyk@linaro.org> X-Mailer: git-send-email 2.29.0 In-Reply-To: <20201211142933.25784-1-grzegorz.jaszczyk@linaro.org> References: <20201211142933.25784-1-grzegorz.jaszczyk@linaro.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org From: Tero Kristo Add two new APIs, pru_rproc_get() and pru_rproc_put(), to the PRU driver to allow client drivers to acquire and release the remoteproc device associated with a PRU core. The PRU cores are treated as resources with only one client owning it at a time. The pru_rproc_get() function returns the rproc handle corresponding to a PRU core identified by the device tree "prus" property under the client node. The pru_rproc_put() is the complementary function to pru_rproc_get(). Co-developed-by: Suman Anna Signed-off-by: Suman Anna Signed-off-by: Tero Kristo Co-developed-by: Grzegorz Jaszczyk Signed-off-by: Grzegorz Jaszczyk --- drivers/remoteproc/pru_rproc.c | 125 ++++++++++++++++++++++++++++++++- include/linux/pruss.h | 56 +++++++++++++++ 2 files changed, 178 insertions(+), 3 deletions(-) create mode 100644 include/linux/pruss.h -- 2.29.0 diff --git a/drivers/remoteproc/pru_rproc.c b/drivers/remoteproc/pru_rproc.c index 2667919d76b3..cc2e585778b1 100644 --- a/drivers/remoteproc/pru_rproc.c +++ b/drivers/remoteproc/pru_rproc.c @@ -16,6 +16,7 @@ #include #include #include +#include #include #include @@ -111,6 +112,8 @@ struct pru_private_data { * @rproc: remoteproc pointer for this PRU core * @data: PRU core specific data * @mem_regions: data for each of the PRU memory regions + * @client_np: client device node + * @lock: mutex to protect client usage * @fw_name: name of firmware image used during loading * @mapped_irq: virtual interrupt numbers of created fw specific mapping * @pru_interrupt_map: pointer to interrupt mapping description (firmware) @@ -126,6 +129,8 @@ struct pru_rproc { struct rproc *rproc; const struct pru_private_data *data; struct pruss_mem_region mem_regions[PRU_IOMEM_MAX]; + struct device_node *client_np; + struct mutex lock; /* client access lock */ const char *fw_name; unsigned int *mapped_irq; struct pru_irq_rsc *pru_interrupt_map; @@ -146,6 +151,119 @@ 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 struct rproc *__pru_rproc_get(struct device_node *np, int index) +{ + struct device_node *rproc_np = NULL; + struct platform_device *pdev; + struct rproc *rproc; + + rproc_np = of_parse_phandle(np, "prus", index); + if (!rproc_np || !of_device_is_available(rproc_np)) + return ERR_PTR(-ENODEV); + + pdev = of_find_device_by_node(rproc_np); + of_node_put(rproc_np); + + if (!pdev) + /* probably PRU not yet probed */ + return ERR_PTR(-EPROBE_DEFER); + + /* make sure it is PRU rproc */ + if (!is_pru_rproc(&pdev->dev)) { + put_device(&pdev->dev); + return ERR_PTR(-ENODEV); + } + + rproc = platform_get_drvdata(pdev); + put_device(&pdev->dev); + if (!rproc) + return ERR_PTR(-EPROBE_DEFER); + + get_device(&rproc->dev); + + return rproc; +} + +/** + * pru_rproc_get() - get the PRU rproc instance from a device node + * @np: the user/client device node + * @index: index to use for the prus property + * @pru_id: optional pointer to return the PRU remoteproc processor id + * + * This function looks through a client device node's "prus" property at index + * @index and returns the rproc handle for a valid PRU remote processor if + * found. The function allows only one user to own the PRU rproc resource at + * a time. Caller must call pru_rproc_put() when done with using the rproc, + * not required if the function returns a failure. + * + * When optional @pru_id pointer is passed the PRU remoteproc processor id is + * returned. + * + * Return: rproc handle on success, and an ERR_PTR on failure using one + * of the following error values + * -ENODEV if device is not found + * -EBUSY if PRU is already acquired by anyone + * -EPROBE_DEFER is PRU device is not probed yet + */ +struct rproc *pru_rproc_get(struct device_node *np, int index, + enum pruss_pru_id *pru_id) +{ + struct rproc *rproc; + struct pru_rproc *pru; + struct device *dev; + + rproc = __pru_rproc_get(np, index); + if (IS_ERR(rproc)) + return rproc; + + pru = rproc->priv; + dev = &rproc->dev; + + mutex_lock(&pru->lock); + + if (pru->client_np) { + mutex_unlock(&pru->lock); + put_device(dev); + return ERR_PTR(-EBUSY); + } + + pru->client_np = np; + + mutex_unlock(&pru->lock); + + if (pru_id) + *pru_id = pru->id; + + return rproc; +} +EXPORT_SYMBOL_GPL(pru_rproc_get); + +/** + * pru_rproc_put() - release the PRU rproc resource + * @rproc: the rproc resource to release + * + * Releases the PRU rproc resource and makes it available to other + * users. + */ +void pru_rproc_put(struct rproc *rproc) +{ + struct pru_rproc *pru; + + if (IS_ERR_OR_NULL(rproc) || !is_pru_rproc(rproc->dev.parent)) + return; + + pru = rproc->priv; + if (!pru->client_np) + return; + + mutex_lock(&pru->lock); + pru->client_np = NULL; + mutex_unlock(&pru->lock); + + put_device(&rproc->dev); +} +EXPORT_SYMBOL_GPL(pru_rproc_put); + 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); @@ -706,14 +824,14 @@ static int pru_rproc_set_id(struct pru_rproc *pru) case RTU0_IRAM_ADDR_MASK: fallthrough; case PRU0_IRAM_ADDR_MASK: - pru->id = 0; + pru->id = PRUSS_PRU0; break; case TX_PRU1_IRAM_ADDR_MASK: fallthrough; case RTU1_IRAM_ADDR_MASK: fallthrough; case PRU1_IRAM_ADDR_MASK: - pru->id = 1; + pru->id = PRUSS_PRU1; break; default: ret = -EINVAL; @@ -775,6 +893,7 @@ static int pru_rproc_probe(struct platform_device *pdev) pru->pruss = platform_get_drvdata(ppdev); pru->rproc = rproc; pru->fw_name = fw_name; + mutex_init(&pru->lock); for (i = 0; i < ARRAY_SIZE(mem_names); i++) { res = platform_get_resource_byname(pdev, IORESOURCE_MEM, @@ -859,7 +978,7 @@ MODULE_DEVICE_TABLE(of, pru_rproc_match); static struct platform_driver pru_rproc_driver = { .driver = { - .name = "pru-rproc", + .name = PRU_RPROC_DRVNAME, .of_match_table = pru_rproc_match, .suppress_bind_attrs = true, }, diff --git a/include/linux/pruss.h b/include/linux/pruss.h new file mode 100644 index 000000000000..43cb5c2eed08 --- /dev/null +++ b/include/linux/pruss.h @@ -0,0 +1,56 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/** + * PRU-ICSS Subsystem user interfaces + * + * Copyright (C) 2015-2020 Texas Instruments Incorporated - http://www.ti.com + * Suman Anna + */ + +#ifndef __LINUX_PRUSS_H +#define __LINUX_PRUSS_H + +#include +#include + +#define PRU_RPROC_DRVNAME "pru-rproc" + +/* + * enum pruss_pru_id - PRU core identifiers + */ +enum pruss_pru_id { + PRUSS_PRU0 = 0, + PRUSS_PRU1, + PRUSS_NUM_PRUS, +}; + +struct device_node; + +#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); + +#else + +static inline struct rproc * +pru_rproc_get(struct device_node *np, int index, enum pruss_pru_id *pru_id) +{ + return ERR_PTR(-ENOTSUPP); +} + +static inline void pru_rproc_put(struct rproc *rproc) { } + +#endif /* CONFIG_PRU_REMOTEPROC */ + +static inline bool is_pru_rproc(struct device *dev) +{ + const char *drv_name = dev_driver_string(dev); + + if (strncmp(drv_name, PRU_RPROC_DRVNAME, sizeof(PRU_RPROC_DRVNAME))) + return false; + + return true; +} + +#endif /* __LINUX_PRUSS_H */ From patchwork Fri Dec 11 14:29:31 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Grzegorz Jaszczyk X-Patchwork-Id: 341973 Delivered-To: patch@linaro.org Received: by 2002:a02:85a7:0:0:0:0:0 with SMTP id d36csp592070jai; Fri, 11 Dec 2020 06:33:57 -0800 (PST) X-Google-Smtp-Source: ABdhPJxn92ZuWU//0IPbebvbqfEO3peYz5XpNWfH2SdLrdwMlbeol7iEEcShD6a5sf9gxeOgdHZC X-Received: by 2002:a05:6402:16c8:: with SMTP id r8mr11868779edx.59.1607697236940; Fri, 11 Dec 2020 06:33:56 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1607697236; cv=none; d=google.com; s=arc-20160816; b=a3maCY9HxZGsqKzFTZFX0T++LKYI6ynWLSxtNKjFkAk88ZqayUS38udUWvpiHOgcwx zVtRtwZTGmmOpwKhMz+UWaUj2gRSzQyt6QBAEkPYOVvrcqKSjG6C/Dz/PyulFc/1wPc4 2SmIn2UIwYfrQ7EG6ToJGfnAW63D9Ycac6B19tpqcM1xsgYJ0KCsJtCTqqLQrtiuPfVS DR891aVI6Zds+TGM709KO65Y4ijvXc3FiVHc84ec144gL4Ps8uA6kAc3wXnYOj5FRRyh I4rlCwizOdKVcwGh5E8BoLhg/5FH1+HPYZOW8l2tcCIS1RzvyDpw/Jdi3UgjNAKwOYku EBTA== 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=9s2KpvaYSw4t1bCR1j0Xjb/I6S5cN8m0t3IpN4+bDAo=; b=KzgrCmH/eCO9qwatLqerAu63cLWMPxg2Jyv56DEYGnKLW3DFZxMAIXuaww+dBZvejV Tn4DcFeWmnNocwXBhoeXI6xlnZtkrwuPFL1gvIn+1J2NZzqCWuFbMqaCs7wl0F5VYLOy 6aWpr650A4F7tCsXwpvQUOno2t39p0UBztFEDNnbAd9k0d7CSlq9DN9td4xx6Qi8tUDY ogzEiRoD1eS63E1zUET5UL7vRgcZpVKPfpm0/P5iwFqyWZ9E0531JiYXL5ZNoghxxEEQ ZYXRvahcG7AR4WnN03bz1qsuDW6uZGdpsnMW5hRkMdaQhcKGaqPxpYem85krQTXw5Uh7 Siew== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=kJPwUO5U; 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 l89si5784444ede.577.2020.12.11.06.33.56; Fri, 11 Dec 2020 06:33:56 -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=kJPwUO5U; 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 S2406254AbgLKOcP (ORCPT + 7 others); Fri, 11 Dec 2020 09:32:15 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:45010 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2406247AbgLKOcF (ORCPT ); Fri, 11 Dec 2020 09:32:05 -0500 Received: from mail-lj1-x244.google.com (mail-lj1-x244.google.com [IPv6:2a00:1450:4864:20::244]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 662C3C0611C5 for ; Fri, 11 Dec 2020 06:30:47 -0800 (PST) Received: by mail-lj1-x244.google.com with SMTP id f11so11140104ljn.2 for ; Fri, 11 Dec 2020 06:30:47 -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=9s2KpvaYSw4t1bCR1j0Xjb/I6S5cN8m0t3IpN4+bDAo=; b=kJPwUO5UuwXNyW/ebEs5EvhbjUqSE88TXvhu4eiG8sLKbdu7OKM74z1RwuRjjeHkii qavyLXpEpZKdIcu70f4Qfh0M0ctJAaM2Er8ozd93xT7AbXsYrCIlID+8Bk9nI/5zVHQe D9e/6zcvjh27WV20GIAIP0a9PQVVyTo5v6udkGqE2v9GN+JqUgFS0+lAZlTr8qZO7Mnw eAXID3uJk+ncUCJ3iBAjVfZ3qlcT8OfOpVnXyEGlwDV52a2ztWeIcAle96h387AUQDmj zSVoLQLspaeJZc48LdZFKWGXrOy/1jwTK6I7vfAO0/pJ4PoQCMuQ/IdsTdeKD/v9Gf2g u/Hw== 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=9s2KpvaYSw4t1bCR1j0Xjb/I6S5cN8m0t3IpN4+bDAo=; b=rVAZ0n2RgaiN20hUN425gJi1CMHpWX9hv8Kiwipvh9E0aJRDZEByNdrJaKk+DEafy5 7oYuID8wvYVt7V7tG1iv/ZtnqtYNh1TkjTEkBZ0TLoV1HsHWI53QyDT3urJ0O5DFfPPL xtI11i6bzm603OnsWNJCOBA1KCCStznL/k5gFIXKP7tVI/hUa1UFJ1PFh4bhuzEI9qWq b1+/IlkaNaM0Ty7fq2BmTW7XvOfZ4ZqqsPGiewUrZYuC2HBJKdctD6Qp6psKJyYQF6if 6Zhzx/lZM1xHoHrwfqDAPl4Rf6/YJlwum4s9zBiUcvcfXWhFPDI47QNew1fZ+prbO45J upFw== X-Gm-Message-State: AOAM532yWsB+iD00v3yOgE4qgBAjOk6IpAAf52mIhXXBGM2+JVeAxbvV KdC03NXPo/mi6HMhPVFKWnSKBQ== X-Received: by 2002:a2e:9e87:: with SMTP id f7mr5454185ljk.358.1607697045950; Fri, 11 Dec 2020 06:30:45 -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 x26sm906491lfq.112.2020.12.11.06.30.44 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Fri, 11 Dec 2020 06:30:45 -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 Subject: [PATCH 3/5] remoteproc: pru: Deny rproc sysfs ops for PRU client driven boots Date: Fri, 11 Dec 2020 15:29:31 +0100 Message-Id: <20201211142933.25784-4-grzegorz.jaszczyk@linaro.org> X-Mailer: git-send-email 2.29.0 In-Reply-To: <20201211142933.25784-1-grzegorz.jaszczyk@linaro.org> References: <20201211142933.25784-1-grzegorz.jaszczyk@linaro.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org From: Suman Anna The PRU remoteproc driver is not configured for 'auto-boot' by default, and allows to be booted either by in-kernel PRU client drivers or by userspace using the generic remoteproc sysfs interfaces. The sysfs interfaces should not be permitted to change the remoteproc firmwares or states when a PRU is being managed by an in-kernel client driver. Use the newly introduced remoteproc generic 'deny_sysfs_ops' flag to provide these restrictions by setting and clearing it appropriately during the PRU acquire and release steps. Signed-off-by: Suman Anna Co-developed-by: Grzegorz Jaszczyk Signed-off-by: Grzegorz Jaszczyk --- drivers/remoteproc/pru_rproc.c | 2 ++ 1 file changed, 2 insertions(+) -- 2.29.0 diff --git a/drivers/remoteproc/pru_rproc.c b/drivers/remoteproc/pru_rproc.c index cc2e585778b1..bfb53967edda 100644 --- a/drivers/remoteproc/pru_rproc.c +++ b/drivers/remoteproc/pru_rproc.c @@ -228,6 +228,7 @@ struct rproc *pru_rproc_get(struct device_node *np, int index, } pru->client_np = np; + rproc->deny_sysfs_ops = true; mutex_unlock(&pru->lock); @@ -258,6 +259,7 @@ void pru_rproc_put(struct rproc *rproc) mutex_lock(&pru->lock); pru->client_np = NULL; + rproc->deny_sysfs_ops = false; mutex_unlock(&pru->lock); put_device(&rproc->dev); From patchwork Fri Dec 11 14:29:32 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Grzegorz Jaszczyk X-Patchwork-Id: 341972 Delivered-To: patch@linaro.org Received: by 2002:a02:85a7:0:0:0:0:0 with SMTP id d36csp591872jai; Fri, 11 Dec 2020 06:33:45 -0800 (PST) X-Google-Smtp-Source: ABdhPJwIP14BVP78PEgGfp0SphYS+vnwbBIMvRVcLE5ayoCh3OQh/VPIH7kIcvIW2YoWCc54FZbs X-Received: by 2002:a05:6402:142f:: with SMTP id c15mr12151778edx.33.1607697225836; Fri, 11 Dec 2020 06:33:45 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1607697225; cv=none; d=google.com; s=arc-20160816; b=LZ9yFQfcUmbXv0WYmH+XRfdS+NZZtN3EfkVPzN59pJtcCK0MJX86NAC6m7DVIYAuM5 BP4BMaqyMaAbBql+2UsiPjLpyrHXYEX7/ovJIt4Zl5fFGy5FpBF50bY8oI4+kn9tyIRI s0y8DZ7DjDVdBbolNB7bWhHTu7SJzRnNOg8+uIuH6qP3/dZDQe8xUVLvqi+uPzOd90GB 581nwbNDas1egjDZit2HYjq4cWuVQwd4Kq7EoqJJkNzgLePUJhN9eDwkmrjgU+YRXC30 b7lt3ZrGLYLSO8virK0FdwxJDL8iONjclxO3DJY7d1oZQt1VOKHdjmq4Lai5yTtjxa4Y btig== 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=I4kaS8K9NJ34up6Kjdshn5LWbMYzqvOti/z8UesqHNI=; b=n2ACd0Vffq++ZEKFFuQxMdDEUG/ZaToP5kDvWv2m0kKgYoRU25ga64QIF4jnV0KjLO 9oOjYnQVgoIFznpUtyAhdKImYU+8ogNx7wrKGpkbZ+V9u+JJr/OGfZc96MEHfktOFEoc cqprbCQOpMc5oGrroaF75/yf6QeVrZLyxOjTv4Xoy4K7hJhxqFvNN+zllHP4VOmIh4+k e9jQlaDloOF/fsCdyLXWzzzvhPlFC7G9zrWBxK/dooYGDslDOohMB1+ac9wqc/nH7+tc A+i9+WOJX0z5P9lIM0cqBsORuoOMU/rxQhhvHZ3JpHX2UoCzi5UQX0iYD5vdlr1WAb8x 1cuQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=KlC1mAT3; 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 l89si5784444ede.577.2020.12.11.06.33.45; Fri, 11 Dec 2020 06:33:45 -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=KlC1mAT3; 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 S2406267AbgLKOdQ (ORCPT + 7 others); Fri, 11 Dec 2020 09:33:16 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:45112 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2406266AbgLKOco (ORCPT ); Fri, 11 Dec 2020 09:32:44 -0500 Received: from mail-lj1-x244.google.com (mail-lj1-x244.google.com [IPv6:2a00:1450:4864:20::244]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id B48E1C0611CE for ; Fri, 11 Dec 2020 06:30:48 -0800 (PST) Received: by mail-lj1-x244.google.com with SMTP id m13so11076916ljo.11 for ; Fri, 11 Dec 2020 06:30:48 -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=I4kaS8K9NJ34up6Kjdshn5LWbMYzqvOti/z8UesqHNI=; b=KlC1mAT3qQPNJXPLj8Xkgal4/KRedM5OyNLIxtjlqAjGmXYRSRLNq6CxROHw1S2+LR mlQoJM1RhLhIvwHXnsCZtEjOhGkN1y9OJMJ2WlAzYtuufl+Aea3Z7hwwnMMvA/GrjNkg 9U/RO4fzvrW96MWs5zglVc08bB+bk6w6rWm0FOV3uBZCL/uq2eIYcLfcvt1mp3xs6FLG DuwhFSZkKFGop46MVYkSSnxziPxWPahHDCeuIJqGnuzGbndsoRJVKcckPN7nNF+fGYnR UqSoEJv862YcgJh/kIzXoIPt1dYc4i5UUavubF21JtUXFMtO0fftcxw0beNn+WlEeZVg eIsQ== 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=I4kaS8K9NJ34up6Kjdshn5LWbMYzqvOti/z8UesqHNI=; b=Kwc7rThfg7CY1TKhJ43ZZLv221wbil/W6tOYt7wbW+cEHUQMV6vLdjzHThVDCOOd5f Atc9LL0S08qTJv1GCPYrjsy6q+YYkpgEZznOJbgCXDuGOPuqkFrd0MKADayqcW3bmPRE arZPHjq/1oHVDrAm8LrgoDloZnFGsu9a+kiGTVWf6YDGVxznEOiYQIGhAvzq/z2LHWdh dKQpQ9G5cyJgqE4A5PDGyJuYYfodqhA1SiC9E26d7GH7tg5iAz3BgmaOgCJuHIlDLzGS P48IlRKdJPMMfkmo4TOAM5nOXhS5Rp9/pFxEBsH2fyvG9yZU3MFesXVgFpIYmp542siO qroQ== X-Gm-Message-State: AOAM533yjcYMBC2ID8+19ot8uIscw3mJGhOLFrdOjC6ejlaxLM1kEUCq mYZfa7WKyFPmpuWoHwV8t1O18w== X-Received: by 2002:a2e:9546:: with SMTP id t6mr5288769ljh.222.1607697047196; Fri, 11 Dec 2020 06:30:47 -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 x26sm906491lfq.112.2020.12.11.06.30.46 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Fri, 11 Dec 2020 06:30:46 -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 Subject: [PATCH 4/5] remoteproc: pru: Add pru_rproc_set_ctable() function Date: Fri, 11 Dec 2020 15:29:32 +0100 Message-Id: <20201211142933.25784-5-grzegorz.jaszczyk@linaro.org> X-Mailer: git-send-email 2.29.0 In-Reply-To: <20201211142933.25784-1-grzegorz.jaszczyk@linaro.org> References: <20201211142933.25784-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 bfb53967edda..ac13e4452a57 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) From patchwork Fri Dec 11 14:29:33 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Grzegorz Jaszczyk X-Patchwork-Id: 342123 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=-18.7 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_CR_TRAILER, INCLUDES_PATCH, MAILING_LIST_MULTI, SPF_HELO_NONE, SPF_PASS, 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 9EA5BC2BB40 for ; Fri, 11 Dec 2020 15:00:55 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 54DEF206A5 for ; Fri, 11 Dec 2020 15:00:55 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2406291AbgLKOdQ (ORCPT ); Fri, 11 Dec 2020 09:33:16 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:45116 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2406268AbgLKOco (ORCPT ); Fri, 11 Dec 2020 09:32:44 -0500 Received: from mail-lf1-x143.google.com (mail-lf1-x143.google.com [IPv6:2a00:1450:4864:20::143]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 357AEC0611D0 for ; Fri, 11 Dec 2020 06:30:50 -0800 (PST) Received: by mail-lf1-x143.google.com with SMTP id m12so13605477lfo.7 for ; Fri, 11 Dec 2020 06:30:50 -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=TC3nvcCsKElennu363xgzX81b8s+QPHA8xr9Tbhrl4w=; b=fInATpmn5aXIMdqqCMq1nnYMD46JaKgeio7qqkIWPAy5iyQuaCf5xpZAzST7LnZiTm pT70ncVHd2lqP67P4nbKHZ9a+8Iw2NPSoqecYwa0jtOBDVCG+mIRCn0Q6jO27a7E9Jem ahwGZg63orgPCV+6S6kwJOvwUqast68vh5XMgDJ2lWzJngEVaQ00QMHEZAiTifJToCsP xK98/H2A+EoE7gRboeajuRtpbjG80nnEqCp0WgPh88s/1f3JHi7gPkc9WG1gTYUtugLy IlUJihn1oN5NSWXah1ZJG90tgoB8u82HSIRq82qIFd/JIvwvjQvTjDA9uoxSlHc0qgOo iOLg== 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=TC3nvcCsKElennu363xgzX81b8s+QPHA8xr9Tbhrl4w=; b=tmzRs+0QPci5TLCc+sdfBHf0CrA49zJpOUHUNoDHzxTMzxn5SqM4VzfwOcwPXTwOoN TTM6flciy7ycLRThVCOLsWc4+RB4p6Lkfq22HSWSs+1L6jA+VRLbHgZL/vxSQtmBi6du dpOGIlGN6WwWbvguvAkRDVa5A4IV6U56AwNfFNA5cramKuK2a+Safq/f2cdEgHr1FYvo 62YasbIw74wcysjotGYBCr9CU9JMUhFjmw7egXDoBFPT89mVgRkmqpxOek3IlLTTU+Oa Rk83SnJLg2gvAcztezSpFAIBiCI/5O3hWWpvihKI14dMI4dypgwf/eU0lmBwEA0TElYp 0htw== X-Gm-Message-State: AOAM533UT+HMyDZQBsA1UTC56kjIDEyyrhr00TP5YMziRSpNhql0JLyp 9465T/axDC2ylen2BAQCrfi0OA== X-Google-Smtp-Source: ABdhPJxMxrQ4KNASC27zblm4T7/0+PW+bq/u7+d/RQzYScHtQ48AArv3ONiHIP4xpRXDnTufQITTrA== X-Received: by 2002:a19:5f5d:: with SMTP id a29mr4517141lfj.212.1607697048664; Fri, 11 Dec 2020 06:30:48 -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 x26sm906491lfq.112.2020.12.11.06.30.47 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Fri, 11 Dec 2020 06:30:48 -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 Subject: [PATCH 5/5] remoteproc: pru: Configure firmware based on client setup Date: Fri, 11 Dec 2020 15:29:33 +0100 Message-Id: <20201211142933.25784-6-grzegorz.jaszczyk@linaro.org> X-Mailer: git-send-email 2.29.0 In-Reply-To: <20201211142933.25784-1-grzegorz.jaszczyk@linaro.org> References: <20201211142933.25784-1-grzegorz.jaszczyk@linaro.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org From: Tero Kristo Client device node property firmware-name is now used to configure firmware for the PRU instances. The default firmware is also restored once releasing the PRU resource. Co-developed-by: Suman Anna Signed-off-by: Suman Anna Signed-off-by: Tero Kristo Co-developed-by: Grzegorz Jaszczyk Signed-off-by: Grzegorz Jaszczyk --- drivers/remoteproc/pru_rproc.c | 35 ++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) diff --git a/drivers/remoteproc/pru_rproc.c b/drivers/remoteproc/pru_rproc.c index ac13e4452a57..fed7a2051ebf 100644 --- a/drivers/remoteproc/pru_rproc.c +++ b/drivers/remoteproc/pru_rproc.c @@ -170,6 +170,23 @@ void pru_control_set_reg(struct pru_rproc *pru, unsigned int reg, spin_unlock_irqrestore(&pru->rmw_lock, flags); } +/** + * pru_rproc_set_firmware() - set firmware for a pru core + * @rproc: the rproc instance of the PRU + * @fw_name: the new firmware name, or NULL if default is desired + * + * Return: 0 on success, or errno in error case. + */ +static int pru_rproc_set_firmware(struct rproc *rproc, const char *fw_name) +{ + struct pru_rproc *pru = rproc->priv; + + if (!fw_name) + fw_name = pru->fw_name; + + return rproc_set_firmware(rproc, fw_name); +} + static struct rproc *__pru_rproc_get(struct device_node *np, int index) { struct device_node *rproc_np = NULL; @@ -230,6 +247,8 @@ struct rproc *pru_rproc_get(struct device_node *np, int index, struct rproc *rproc; struct pru_rproc *pru; struct device *dev; + const char *fw_name; + int ret; rproc = __pru_rproc_get(np, index); if (IS_ERR(rproc)) @@ -254,7 +273,21 @@ struct rproc *pru_rproc_get(struct device_node *np, int index, if (pru_id) *pru_id = pru->id; + ret = of_property_read_string_index(np, "firmware-name", index, + &fw_name); + if (!ret) { + ret = pru_rproc_set_firmware(rproc, fw_name); + if (ret) { + dev_err(dev, "failed to set firmware: %d\n", ret); + goto err; + } + } + return rproc; + +err: + pru_rproc_put(rproc); + return ERR_PTR(ret); } EXPORT_SYMBOL_GPL(pru_rproc_get); @@ -276,6 +309,8 @@ void pru_rproc_put(struct rproc *rproc) if (!pru->client_np) return; + pru_rproc_set_firmware(rproc, NULL); + mutex_lock(&pru->lock); pru->client_np = NULL; rproc->deny_sysfs_ops = false;