From nobody Sat Sep 21 09:55:08 2024 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 190B8C433FE for ; Wed, 2 Nov 2022 10:08:28 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230396AbiKBKI0 (ORCPT ); Wed, 2 Nov 2022 06:08:26 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:36812 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230306AbiKBKIJ (ORCPT ); Wed, 2 Nov 2022 06:08:09 -0400 Received: from madras.collabora.co.uk (madras.collabora.co.uk [IPv6:2a00:1098:0:82:1000:25:2eeb:e5ab]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 531C227142 for ; Wed, 2 Nov 2022 03:07:45 -0700 (PDT) Received: from IcarusMOD.eternityproject.eu (2-237-20-237.ip236.fastwebnet.it [2.237.20.237]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) (Authenticated sender: kholk11) by madras.collabora.co.uk (Postfix) with ESMTPSA id 41381660293F; Wed, 2 Nov 2022 10:07:43 +0000 (GMT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=collabora.com; s=mail; t=1667383663; bh=dOsyMJtPdAV3jUm/GhRp03PrdsruZCqyjWbSMeaW3o4=; h=From:To:Cc:Subject:Date:From; b=ihmo7pC9gmxuRgb4GL9+EjnPNKr7SgIk+u7e2rgbj6C7ewb3Fuug+lWHh0ER1ep3B 3egtMbqPVnt1qmwPVf1FBbr8O0dmrop2UH/ryB2KrqCi6GlsLYygiQzsSlAcrdbmuW rDN5M3shLv77U2N0VpQ9OH2ZYn6hz7i/geud+D3uALLODBjkbjSwzCy7lUT+lVx6yS AX2dJqyxD8foOyz0h0/LXl+Qq7GdMbtnBZ9Rmuwd/mPAtatymHQdAqaqnPHTPQzO7K E/k/h+V8wclxsdBoX2tg7AB7EAdo95O1r6IDVdAqenVAYaQL9WoUJvKEMW4UE0jeZ4 I5hUnHxo6Vgnw== From: AngeloGioacchino Del Regno To: jassisinghbrar@gmail.com Cc: matthias.bgg@gmail.com, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-mediatek@lists.infradead.org, AngeloGioacchino Del Regno Subject: [PATCH] mailbox: mtk-cmdq-mailbox: Use platform data directly instead of copying Date: Wed, 2 Nov 2022 11:07:36 +0100 Message-Id: <20221102100736.37815-1-angelogioacchino.delregno@collabora.com> X-Mailer: git-send-email 2.37.2 MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Copying platform data to struct cmdq serves to no purpose, as that data is never modified during runtime: it's worth at this point storing a pointer to gce_plat in gce and. Remove all duplicated `struct gce_plat` members from `struct gce` and reuse the platform data across the driver to save some memory. Signed-off-by: AngeloGioacchino Del Regno Reviewed-by: Chun-Kuang Hu Reviewed-by: Matthias Brugger --- This commit applies only on top of series [1] [1]: https://patchwork.kernel.org/project/linux-mediatek/list/?series=3D684= 195 drivers/mailbox/mtk-cmdq-mailbox.c | 88 +++++++++++++----------------- 1 file changed, 39 insertions(+), 49 deletions(-) diff --git a/drivers/mailbox/mtk-cmdq-mailbox.c b/drivers/mailbox/mtk-cmdq-= mailbox.c index c5229f377c5e..a460ee26eb11 100644 --- a/drivers/mailbox/mtk-cmdq-mailbox.c +++ b/drivers/mailbox/mtk-cmdq-mailbox.c @@ -75,15 +75,11 @@ struct cmdq { struct mbox_controller mbox; void __iomem *base; int irq; - u32 thread_nr; u32 irq_mask; + const struct gce_plat *pdata; struct cmdq_thread *thread; struct clk_bulk_data clocks[CMDQ_GCE_NUM_MAX]; bool suspended; - u8 shift_pa; - bool control_by_sw; - bool sw_ddr_en; - u32 gce_num; }; =20 struct gce_plat { @@ -96,21 +92,21 @@ struct gce_plat { =20 static void cmdq_sw_ddr_enable(struct cmdq *cmdq, bool enable) { - WARN_ON(clk_bulk_enable(cmdq->gce_num, cmdq->clocks)); + WARN_ON(clk_bulk_enable(cmdq->pdata->gce_num, cmdq->clocks)); =20 if (enable) writel(GCE_DDR_EN | GCE_CTRL_BY_SW, cmdq->base + GCE_GCTL_VALUE); else writel(GCE_CTRL_BY_SW, cmdq->base + GCE_GCTL_VALUE); =20 - clk_bulk_disable(cmdq->gce_num, cmdq->clocks); + clk_bulk_disable(cmdq->pdata->gce_num, cmdq->clocks); } =20 u8 cmdq_get_shift_pa(struct mbox_chan *chan) { struct cmdq *cmdq =3D container_of(chan->mbox, struct cmdq, mbox); =20 - return cmdq->shift_pa; + return cmdq->pdata->shift; } EXPORT_SYMBOL(cmdq_get_shift_pa); =20 @@ -144,10 +140,10 @@ static void cmdq_init(struct cmdq *cmdq) int i; u32 gctl_regval =3D 0; =20 - WARN_ON(clk_bulk_enable(cmdq->gce_num, cmdq->clocks)); - if (cmdq->control_by_sw) + WARN_ON(clk_bulk_enable(cmdq->pdata->gce_num, cmdq->clocks)); + if (cmdq->pdata->control_by_sw) gctl_regval =3D GCE_CTRL_BY_SW; - if (cmdq->sw_ddr_en) + if (cmdq->pdata->sw_ddr_en) gctl_regval |=3D GCE_DDR_EN; =20 if (gctl_regval) @@ -156,7 +152,7 @@ static void cmdq_init(struct cmdq *cmdq) writel(CMDQ_THR_ACTIVE_SLOT_CYCLES, cmdq->base + CMDQ_THR_SLOT_CYCLES); for (i =3D 0; i <=3D CMDQ_MAX_EVENT; i++) writel(i, cmdq->base + CMDQ_SYNC_TOKEN_UPDATE); - clk_bulk_disable(cmdq->gce_num, cmdq->clocks); + clk_bulk_disable(cmdq->pdata->gce_num, cmdq->clocks); } =20 static int cmdq_thread_reset(struct cmdq *cmdq, struct cmdq_thread *thread) @@ -201,7 +197,7 @@ static void cmdq_task_insert_into_thread(struct cmdq_ta= sk *task) prev_task->pkt->cmd_buf_size, DMA_TO_DEVICE); prev_task_base[CMDQ_NUM_CMD(prev_task->pkt) - 1] =3D (u64)CMDQ_JUMP_BY_PA << 32 | - (task->pa_base >> task->cmdq->shift_pa); + (task->pa_base >> task->cmdq->pdata->shift); dma_sync_single_for_device(dev, prev_task->pa_base, prev_task->pkt->cmd_buf_size, DMA_TO_DEVICE); =20 @@ -235,7 +231,7 @@ static void cmdq_task_handle_error(struct cmdq_task *ta= sk) next_task =3D list_first_entry_or_null(&thread->task_busy_list, struct cmdq_task, list_entry); if (next_task) - writel(next_task->pa_base >> cmdq->shift_pa, + writel(next_task->pa_base >> cmdq->pdata->shift, thread->base + CMDQ_THR_CURR_ADDR); cmdq_thread_resume(thread); } @@ -266,7 +262,7 @@ static void cmdq_thread_irq_handler(struct cmdq *cmdq, else return; =20 - curr_pa =3D readl(thread->base + CMDQ_THR_CURR_ADDR) << cmdq->shift_pa; + curr_pa =3D readl(thread->base + CMDQ_THR_CURR_ADDR) << cmdq->pdata->shif= t; =20 list_for_each_entry_safe(task, tmp, &thread->task_busy_list, list_entry) { @@ -289,7 +285,7 @@ static void cmdq_thread_irq_handler(struct cmdq *cmdq, =20 if (list_empty(&thread->task_busy_list)) { cmdq_thread_disable(cmdq, thread); - clk_bulk_disable(cmdq->gce_num, cmdq->clocks); + clk_bulk_disable(cmdq->pdata->gce_num, cmdq->clocks); } } =20 @@ -303,7 +299,7 @@ static irqreturn_t cmdq_irq_handler(int irq, void *dev) if (!(irq_status ^ cmdq->irq_mask)) return IRQ_NONE; =20 - for_each_clear_bit(bit, &irq_status, cmdq->thread_nr) { + for_each_clear_bit(bit, &irq_status, cmdq->pdata->thread_nr) { struct cmdq_thread *thread =3D &cmdq->thread[bit]; =20 spin_lock_irqsave(&thread->chan->lock, flags); @@ -323,7 +319,7 @@ static int cmdq_suspend(struct device *dev) =20 cmdq->suspended =3D true; =20 - for (i =3D 0; i < cmdq->thread_nr; i++) { + for (i =3D 0; i < cmdq->pdata->thread_nr; i++) { thread =3D &cmdq->thread[i]; if (!list_empty(&thread->task_busy_list)) { task_running =3D true; @@ -334,10 +330,10 @@ static int cmdq_suspend(struct device *dev) if (task_running) dev_warn(dev, "exist running task(s) in suspend\n"); =20 - if (cmdq->sw_ddr_en) + if (cmdq->pdata->sw_ddr_en) cmdq_sw_ddr_enable(cmdq, false); =20 - clk_bulk_unprepare(cmdq->gce_num, cmdq->clocks); + clk_bulk_unprepare(cmdq->pdata->gce_num, cmdq->clocks); =20 return 0; } @@ -346,10 +342,10 @@ static int cmdq_resume(struct device *dev) { struct cmdq *cmdq =3D dev_get_drvdata(dev); =20 - WARN_ON(clk_bulk_prepare(cmdq->gce_num, cmdq->clocks)); + WARN_ON(clk_bulk_prepare(cmdq->pdata->gce_num, cmdq->clocks)); cmdq->suspended =3D false; =20 - if (cmdq->sw_ddr_en) + if (cmdq->pdata->sw_ddr_en) cmdq_sw_ddr_enable(cmdq, true); =20 return 0; @@ -359,10 +355,10 @@ static int cmdq_remove(struct platform_device *pdev) { struct cmdq *cmdq =3D platform_get_drvdata(pdev); =20 - if (cmdq->sw_ddr_en) + if (cmdq->pdata->sw_ddr_en) cmdq_sw_ddr_enable(cmdq, false); =20 - clk_bulk_unprepare(cmdq->gce_num, cmdq->clocks); + clk_bulk_unprepare(cmdq->pdata->gce_num, cmdq->clocks); return 0; } =20 @@ -388,7 +384,7 @@ static int cmdq_mbox_send_data(struct mbox_chan *chan, = void *data) task->pkt =3D pkt; =20 if (list_empty(&thread->task_busy_list)) { - WARN_ON(clk_bulk_enable(cmdq->gce_num, cmdq->clocks)); + WARN_ON(clk_bulk_enable(cmdq->pdata->gce_num, cmdq->clocks)); =20 /* * The thread reset will clear thread related register to 0, @@ -398,9 +394,9 @@ static int cmdq_mbox_send_data(struct mbox_chan *chan, = void *data) */ WARN_ON(cmdq_thread_reset(cmdq, thread) < 0); =20 - writel(task->pa_base >> cmdq->shift_pa, + writel(task->pa_base >> cmdq->pdata->shift, thread->base + CMDQ_THR_CURR_ADDR); - writel((task->pa_base + pkt->cmd_buf_size) >> cmdq->shift_pa, + writel((task->pa_base + pkt->cmd_buf_size) >> cmdq->pdata->shift, thread->base + CMDQ_THR_END_ADDR); =20 writel(thread->priority, thread->base + CMDQ_THR_PRIORITY); @@ -409,20 +405,20 @@ static int cmdq_mbox_send_data(struct mbox_chan *chan= , void *data) } else { WARN_ON(cmdq_thread_suspend(cmdq, thread) < 0); curr_pa =3D readl(thread->base + CMDQ_THR_CURR_ADDR) << - cmdq->shift_pa; + cmdq->pdata->shift; end_pa =3D readl(thread->base + CMDQ_THR_END_ADDR) << - cmdq->shift_pa; + cmdq->pdata->shift; /* check boundary */ if (curr_pa =3D=3D end_pa - CMDQ_INST_SIZE || curr_pa =3D=3D end_pa) { /* set to this task directly */ - writel(task->pa_base >> cmdq->shift_pa, + writel(task->pa_base >> cmdq->pdata->shift, thread->base + CMDQ_THR_CURR_ADDR); } else { cmdq_task_insert_into_thread(task); smp_mb(); /* modify jump before enable thread */ } - writel((task->pa_base + pkt->cmd_buf_size) >> cmdq->shift_pa, + writel((task->pa_base + pkt->cmd_buf_size) >> cmdq->pdata->shift, thread->base + CMDQ_THR_END_ADDR); cmdq_thread_resume(thread); } @@ -461,7 +457,7 @@ static void cmdq_mbox_shutdown(struct mbox_chan *chan) } =20 cmdq_thread_disable(cmdq, thread); - clk_bulk_disable(cmdq->gce_num, cmdq->clocks); + clk_bulk_disable(cmdq->pdata->gce_num, cmdq->clocks); =20 done: /* @@ -501,7 +497,7 @@ static int cmdq_mbox_flush(struct mbox_chan *chan, unsi= gned long timeout) =20 cmdq_thread_resume(thread); cmdq_thread_disable(cmdq, thread); - clk_bulk_disable(cmdq->gce_num, cmdq->clocks); + clk_bulk_disable(cmdq->pdata->gce_num, cmdq->clocks); =20 out: spin_unlock_irqrestore(&thread->chan->lock, flags); @@ -548,7 +544,6 @@ static int cmdq_probe(struct platform_device *pdev) struct device *dev =3D &pdev->dev; struct cmdq *cmdq; int err, i; - struct gce_plat *plat_data; struct device_node *phandle =3D dev->of_node; struct device_node *node; int alias_id =3D 0; @@ -567,18 +562,13 @@ static int cmdq_probe(struct platform_device *pdev) if (cmdq->irq < 0) return cmdq->irq; =20 - plat_data =3D (struct gce_plat *)of_device_get_match_data(dev); - if (!plat_data) { + cmdq->pdata =3D device_get_match_data(dev); + if (!cmdq->pdata) { dev_err(dev, "failed to get match data\n"); return -EINVAL; } =20 - cmdq->thread_nr =3D plat_data->thread_nr; - cmdq->shift_pa =3D plat_data->shift; - cmdq->control_by_sw =3D plat_data->control_by_sw; - cmdq->sw_ddr_en =3D plat_data->sw_ddr_en; - cmdq->gce_num =3D plat_data->gce_num; - cmdq->irq_mask =3D GENMASK(cmdq->thread_nr - 1, 0); + cmdq->irq_mask =3D GENMASK(cmdq->pdata->thread_nr - 1, 0); err =3D devm_request_irq(dev, cmdq->irq, cmdq_irq_handler, IRQF_SHARED, "mtk_cmdq", cmdq); if (err < 0) { @@ -589,10 +579,10 @@ static int cmdq_probe(struct platform_device *pdev) dev_dbg(dev, "cmdq device: addr:0x%p, va:0x%p, irq:%d\n", dev, cmdq->base, cmdq->irq); =20 - if (cmdq->gce_num > 1) { + if (cmdq->pdata->gce_num > 1) { for_each_child_of_node(phandle->parent, node) { alias_id =3D of_alias_get_id(node, clk_name); - if (alias_id >=3D 0 && alias_id < cmdq->gce_num) { + if (alias_id >=3D 0 && alias_id < cmdq->pdata->gce_num) { cmdq->clocks[alias_id].id =3D clk_names[alias_id]; cmdq->clocks[alias_id].clk =3D of_clk_get(node, 0); if (IS_ERR(cmdq->clocks[alias_id].clk)) { @@ -614,12 +604,12 @@ static int cmdq_probe(struct platform_device *pdev) } =20 cmdq->mbox.dev =3D dev; - cmdq->mbox.chans =3D devm_kcalloc(dev, cmdq->thread_nr, + cmdq->mbox.chans =3D devm_kcalloc(dev, cmdq->pdata->thread_nr, sizeof(*cmdq->mbox.chans), GFP_KERNEL); if (!cmdq->mbox.chans) return -ENOMEM; =20 - cmdq->mbox.num_chans =3D cmdq->thread_nr; + cmdq->mbox.num_chans =3D cmdq->pdata->thread_nr; cmdq->mbox.ops =3D &cmdq_mbox_chan_ops; cmdq->mbox.of_xlate =3D cmdq_xlate; =20 @@ -627,12 +617,12 @@ static int cmdq_probe(struct platform_device *pdev) cmdq->mbox.txdone_irq =3D false; cmdq->mbox.txdone_poll =3D false; =20 - cmdq->thread =3D devm_kcalloc(dev, cmdq->thread_nr, + cmdq->thread =3D devm_kcalloc(dev, cmdq->pdata->thread_nr, sizeof(*cmdq->thread), GFP_KERNEL); if (!cmdq->thread) return -ENOMEM; =20 - for (i =3D 0; i < cmdq->thread_nr; i++) { + for (i =3D 0; i < cmdq->pdata->thread_nr; i++) { cmdq->thread[i].base =3D cmdq->base + CMDQ_THR_BASE + CMDQ_THR_SIZE * i; INIT_LIST_HEAD(&cmdq->thread[i].task_busy_list); @@ -647,7 +637,7 @@ static int cmdq_probe(struct platform_device *pdev) =20 platform_set_drvdata(pdev, cmdq); =20 - WARN_ON(clk_bulk_prepare(cmdq->gce_num, cmdq->clocks)); + WARN_ON(clk_bulk_prepare(cmdq->pdata->gce_num, cmdq->clocks)); =20 cmdq_init(cmdq); =20 --=20 2.37.2