From patchwork Sat Dec 3 09:51:49 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Huisong Li X-Patchwork-Id: 29251 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:adf:f944:0:0:0:0:0 with SMTP id q4csp1291425wrr; Sat, 3 Dec 2022 01:57:05 -0800 (PST) X-Google-Smtp-Source: AA0mqf5XpE3uBZ+Hw7kwFYRBTVkYDRncgwwx+cXfpTL0tKI4SbEo/0JAN9orUdFDEqbaO15tjw7n X-Received: by 2002:a17:902:7b84:b0:189:6623:4c47 with SMTP id w4-20020a1709027b8400b0018966234c47mr5505892pll.170.1670061425587; Sat, 03 Dec 2022 01:57:05 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1670061425; cv=none; d=google.com; s=arc-20160816; b=JJA8w5JjZDPfvg+ZyNAlRJgB2bd5/IqIdoIV1N3bAoF4rNOxnuQ0jEwMVNcPT6qh6+ mTGE+iYEx8thTDiu7Q2UbfvjPnDbrTGiRv/yImLzXt4sjwuic847yM7bjTHv/G+Qvt4r agHaXQhEHfGSDsQVMSKVwgwBm8MWAZ53GaGkX2tbvX4/NOQTCd25pUuM6rWTo2MGu3FK y34whPYmxt+WNE5Ti8qk4fw2mFosnwrTvjM30PrVglyg35bQYbzRisl07UgEPY98NGSU BrAKddIJmrV9EmGkLLulztc8eWRZbYJXHIM2AQY/5XKzGdlFZje6JsOxQeix+kVpDPaV jkHg== 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; bh=o5DijhYmMpo9T1ZGAT5rq1IsjEkzaFSIaBSAhGnZkJ0=; b=gJeKAOCxp2omsvJ276FPuvo8k55kXxMZRB0KDkWhyV9aRFTk1lg0ml+d1uYqqh+OCn 4AdJRRrGmsCkhd5thm0txY6xLReyu6vQrdfpUC7ByCJyYUbOtPknum0stvq2HXFqguoK sbwZ2vZFGOiAjkOLeLi0QUH7rfRUDdnFu2s4BhSCT2YYO8omJ4lyjV/I0Fo96PWyvoKL 6MLTD45MoS41mRxmxfr1U7A06Sw6lxuzmesabv0caVdVLOBvzbYcgfVMGC7faFJ3ypjs ecK4l9WwkhmbYkHzwKFot9o1xXLvE1IFZIFKd8Ma2WKcB33faYRrnsBvqLf6JYhsFtxP JVug== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=QUARANTINE sp=QUARANTINE dis=NONE) header.from=huawei.com Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id y8-20020a17090322c800b001870dc9ef63si10908065plg.129.2022.12.03.01.56.51; Sat, 03 Dec 2022 01:57:05 -0800 (PST) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=QUARANTINE sp=QUARANTINE dis=NONE) header.from=huawei.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229617AbiLCJvr (ORCPT + 99 others); Sat, 3 Dec 2022 04:51:47 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:60542 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229600AbiLCJvn (ORCPT ); Sat, 3 Dec 2022 04:51:43 -0500 Received: from szxga08-in.huawei.com (szxga08-in.huawei.com [45.249.212.255]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id AED5C68C44; Sat, 3 Dec 2022 01:51:41 -0800 (PST) Received: from kwepemm600004.china.huawei.com (unknown [172.30.72.54]) by szxga08-in.huawei.com (SkyGuard) with ESMTP id 4NPQ6m21fVz15N2q; Sat, 3 Dec 2022 17:50:56 +0800 (CST) Received: from localhost.localdomain (10.69.192.56) by kwepemm600004.china.huawei.com (7.193.23.242) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2375.31; Sat, 3 Dec 2022 17:51:39 +0800 From: Huisong Li To: , CC: , , , , , , , , , , , , Subject: [RFC-V3 1/2] mailbox: pcc: Add processing platform notification for slave subspaces Date: Sat, 3 Dec 2022 17:51:49 +0800 Message-ID: <20221203095150.45422-2-lihuisong@huawei.com> X-Mailer: git-send-email 2.33.0 In-Reply-To: <20221203095150.45422-1-lihuisong@huawei.com> References: <20221016034043.52227-1-lihuisong@huawei.com> <20221203095150.45422-1-lihuisong@huawei.com> MIME-Version: 1.0 X-Originating-IP: [10.69.192.56] X-ClientProxiedBy: dggems703-chm.china.huawei.com (10.3.19.180) To kwepemm600004.china.huawei.com (7.193.23.242) X-CFilter-Loop: Reflected X-Spam-Status: No, score=-4.2 required=5.0 tests=BAYES_00,RCVD_IN_DNSWL_MED, SPF_HELO_NONE,SPF_PASS autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1751186329313006517?= X-GMAIL-MSGID: =?utf-8?q?1751186329313006517?= Currently, PCC driver doesn't support the processing of platform notification for slave PCC subspaces because of the incomplete communication flow. According to ACPI specification, if platform sends a notification to OSPM, it must clear the command complete bit and trigger platform interrupt. OSPM needs to check whether the command complete bit is cleared, clear platform interrupt, process command, and then set the command complete and ring doorbell to Platform. But the current judgment on the command complete is not applicable to type4 in pcc_mbox_irq(). This patch introduces a communication flow direction field to detect whether the interrupt belongs to the master or slave subspace channel. And PCC driver needs to add the phase of setting the command complete and ring doorbell in pcc_mbox_irq() to complete type4 communication flow after processing command from Platform. Signed-off-by: Huisong Li --- drivers/mailbox/pcc.c | 77 +++++++++++++++++++++++++++++++++++++++---- 1 file changed, 71 insertions(+), 6 deletions(-) diff --git a/drivers/mailbox/pcc.c b/drivers/mailbox/pcc.c index 105d46c9801b..ad6d0b7d50fc 100644 --- a/drivers/mailbox/pcc.c +++ b/drivers/mailbox/pcc.c @@ -80,6 +80,13 @@ struct pcc_chan_reg { u64 status_mask; }; +enum pcc_chan_comm_flow_dir_type { + PCC_ONLY_OSPM_TO_PLATFORM, + PCC_ONLY_PLATFORM_TO_OSPM, + PCC_BIDIRECTIONAL, + PCC_DIR_UNKNOWN, +}; + /** * struct pcc_chan_info - PCC channel specific information * @@ -91,6 +98,7 @@ struct pcc_chan_reg { * @cmd_update: PCC register bundle for the command complete update register * @error: PCC register bundle for the error status register * @plat_irq: platform interrupt + * @comm_flow_dir: direction of communication flow supported by the channel */ struct pcc_chan_info { struct pcc_mbox_chan chan; @@ -100,12 +108,15 @@ struct pcc_chan_info { struct pcc_chan_reg cmd_update; struct pcc_chan_reg error; int plat_irq; + u8 comm_flow_dir; }; #define to_pcc_chan_info(c) container_of(c, struct pcc_chan_info, chan) static struct pcc_chan_info *chan_info; static int pcc_chan_count; +static int pcc_send_data(struct mbox_chan *chan, void *data); + /* * PCC can be used with perf critical drivers such as CPPC * So it makes sense to locally cache the virtual address and @@ -221,6 +232,43 @@ static int pcc_map_interrupt(u32 interrupt, u32 flags) return acpi_register_gsi(NULL, interrupt, trigger, polarity); } +static bool pcc_chan_need_rsp_irq(struct pcc_chan_info *pchan, + u64 cmd_complete_reg_val) +{ + bool need_rsp; + + if (!pchan->cmd_complete.gas) + return true; + + cmd_complete_reg_val &= pchan->cmd_complete.status_mask; + + switch (pchan->comm_flow_dir) { + case PCC_ONLY_OSPM_TO_PLATFORM: + /* + * For the communication flow from OSPM to Platform, if this + * channel is in use, command complete bit is 1 indicates that + * the executing command has been completed by Platform and OSPM + * needs to process response. + */ + need_rsp = cmd_complete_reg_val != 0; + break; + case PCC_ONLY_PLATFORM_TO_OSPM: + /* + * For the communication flow from Platform to OSPM, if this + * channel is in use, command complete bit is 0 indicates that + * Platform is sending a notification and OSPM needs to response + * the interrupt to process this command. + */ + need_rsp = cmd_complete_reg_val == 0; + break; + default: + need_rsp = true; + break; + } + + return need_rsp; +} + /** * pcc_mbox_irq - PCC mailbox interrupt handler * @irq: interrupt number @@ -240,12 +288,8 @@ static irqreturn_t pcc_mbox_irq(int irq, void *p) ret = pcc_chan_reg_read(&pchan->cmd_complete, &val); if (ret) return IRQ_NONE; - - if (val) { /* Ensure GAS exists and value is non-zero */ - val &= pchan->cmd_complete.status_mask; - if (!val) - return IRQ_NONE; - } + if (!pcc_chan_need_rsp_irq(pchan, val)) + return IRQ_NONE; ret = pcc_chan_reg_read(&pchan->error, &val); if (ret) @@ -262,6 +306,14 @@ static irqreturn_t pcc_mbox_irq(int irq, void *p) mbox_chan_received_data(chan, NULL); + /* + * For communication flow from Platform to OSPM (like, slave subspace), + * need to set the command complete bit and ring doorbell after + * processing message. + */ + if (pchan->comm_flow_dir == PCC_ONLY_PLATFORM_TO_OSPM) + pcc_send_data(chan, NULL); + return IRQ_HANDLED; } @@ -613,6 +665,18 @@ static int __init acpi_pcc_probe(void) return rc; } +static void pcc_set_chan_comm_flow_dir(struct pcc_chan_info *pchan, u8 type) +{ + if (type <= ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2) + pchan->comm_flow_dir = PCC_BIDIRECTIONAL; + else if (type == ACPI_PCCT_TYPE_EXT_PCC_MASTER_SUBSPACE) + pchan->comm_flow_dir = PCC_ONLY_OSPM_TO_PLATFORM; + else if (type == ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE) + pchan->comm_flow_dir = PCC_ONLY_PLATFORM_TO_OSPM; + else + pchan->comm_flow_dir = PCC_DIR_UNKNOWN; +} + /** * pcc_mbox_probe - Called when we find a match for the * PCCT platform device. This is purely used to represent @@ -686,6 +750,7 @@ static int pcc_mbox_probe(struct platform_device *pdev) if (rc < 0) goto err; } + pcc_set_chan_comm_flow_dir(pchan, pcct_entry->type); rc = pcc_parse_subspace_db_reg(pchan, pcct_entry); if (rc < 0) goto err; From patchwork Sat Dec 3 09:51:50 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Huisong Li X-Patchwork-Id: 29252 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:adf:f944:0:0:0:0:0 with SMTP id q4csp1291474wrr; Sat, 3 Dec 2022 01:57:16 -0800 (PST) X-Google-Smtp-Source: AA0mqf7H7V0WpFAlSN/NUpL7HmYpHUrVRAtxgu3qh2vlSbIIaT9IjF0wsJ9LKSGNjIVbanal+QBQ X-Received: by 2002:a17:902:7609:b0:189:3438:a326 with SMTP id k9-20020a170902760900b001893438a326mr55773174pll.127.1670061436035; Sat, 03 Dec 2022 01:57:16 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1670061436; cv=none; d=google.com; s=arc-20160816; b=QnnydFzn9ECGIedyqcDr2tNtghO8BlWjZriJthUqrLdAtnXhrPT/22fhZZGcLbcVFd 3ybEmUUGMHl/05JVOg7/qe9pIjMKk/1IC8ClSh0BpG2A1abPsXwOiU1KiYbkL6bP+xKd v/71Pk8KHpnsMOoU38SAIkXQ/+3jvMgf10HPC9mkvc5VWCrjaG4zhe5zdIwBWci48iju Q4WUIQIu1GSZcs2t4VxhVcnfQHhA5/Ze2W7yPZaweKTL7U9BVUsfBL1uQOO3kcHqwi41 fu/VFLSZ1ukinBvCVXPFyC1ZdghKAjeudb8a9rnHbffeKyOpVEgcLSsjtVlRNuCy9nna T8aQ== 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; bh=xzKGrySKcodNJy70kxbiklqEzcoWBDpHAONNtvmEhLw=; b=aCh530eot5knUZccGHLDUryvdueB9Tbcbk9tCGVuyuvG98e02MmbJrFKBDqT1rig9/ gWS+D7B8Q6KSO4h7XHuaqvmT3brlWPUFXnUFlwo/rO+DQTYdOdcspmwwYFCPFQ9aNyZR cR5iELj+RYJLcsMhEpOqO2V0H9XUgLFW4EmPQXtzhgAsdc1IL0T2EyC+bjNU69WzF5p3 6aiM+bf1nLE1VDEoNJysnXxeuQO3XmnNaXIUw01W2X+wt2ApvALt+nguWSPXq9zj+kw0 nGY2queNpiTj6pIYp1pmKaAcB+UXD685epF7DkEABjjeNv+0Js5JBVDai1lOk2GJ4xkR FDgA== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=QUARANTINE sp=QUARANTINE dis=NONE) header.from=huawei.com Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id b12-20020a630c0c000000b00422c003b4c9si9444277pgl.46.2022.12.03.01.57.03; Sat, 03 Dec 2022 01:57:16 -0800 (PST) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=fail (p=QUARANTINE sp=QUARANTINE dis=NONE) header.from=huawei.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229637AbiLCJvx (ORCPT + 99 others); Sat, 3 Dec 2022 04:51:53 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:60552 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229468AbiLCJvo (ORCPT ); Sat, 3 Dec 2022 04:51:44 -0500 Received: from szxga03-in.huawei.com (szxga03-in.huawei.com [45.249.212.189]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id D4B9B68C4A; Sat, 3 Dec 2022 01:51:42 -0800 (PST) Received: from kwepemm600004.china.huawei.com (unknown [172.30.72.53]) by szxga03-in.huawei.com (SkyGuard) with ESMTP id 4NPQ3f05YpzkXn6; Sat, 3 Dec 2022 17:48:13 +0800 (CST) Received: from localhost.localdomain (10.69.192.56) by kwepemm600004.china.huawei.com (7.193.23.242) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2375.31; Sat, 3 Dec 2022 17:51:40 +0800 From: Huisong Li To: , CC: , , , , , , , , , , , , Subject: [RFC-V3 2/2] mailbox: pcc: Support shared interrupt for multiple subspaces Date: Sat, 3 Dec 2022 17:51:50 +0800 Message-ID: <20221203095150.45422-3-lihuisong@huawei.com> X-Mailer: git-send-email 2.33.0 In-Reply-To: <20221203095150.45422-1-lihuisong@huawei.com> References: <20221016034043.52227-1-lihuisong@huawei.com> <20221203095150.45422-1-lihuisong@huawei.com> MIME-Version: 1.0 X-Originating-IP: [10.69.192.56] X-ClientProxiedBy: dggems703-chm.china.huawei.com (10.3.19.180) To kwepemm600004.china.huawei.com (7.193.23.242) X-CFilter-Loop: Reflected X-Spam-Status: No, score=-4.2 required=5.0 tests=BAYES_00,RCVD_IN_DNSWL_MED, SPF_HELO_NONE,SPF_PASS autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1751186340456143581?= X-GMAIL-MSGID: =?utf-8?q?1751186340456143581?= If the platform acknowledge interrupt is level triggered, then it can be shared by multiple subspaces provided each one has a unique platform interrupt ack preserve and ack set masks. If it can be shared, then we can request the irq with IRQF_SHARED and IRQF_ONESHOT flags. The first one indicating it can be shared and the latter one to keep the interrupt disabled until the hardirq handler finished. Further, since there is no way to detect if the interrupt is for a given channel as the interrupt ack preserve and ack set masks are for clearing the interrupt and not for reading the status(in case Irq Ack register may be write-only on some platforms), we need a way to identify if the given channel is in use and expecting the interrupt. PCC type0, type1 and type5 do not support shared level triggered interrupt. The methods of determining whether a given channel for remaining types should respond to an interrupt are as follows: - type2: Whether the interrupt belongs to a given channel is only determined by the status field in Generic Communications Channel Shared Memory Region, which is done in rx_callback of PCC client. - type3: This channel checks chan_in_use flag first and then checks the command complete bit(value '1' indicates that the command has been completed). - type4: Platform ensure that the default value of the command complete bit corresponding to the type4 channel is '1'. This command complete bit is '0' when receive a platform notification. Signed-off-by: Huisong Li --- drivers/mailbox/pcc.c | 46 ++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 43 insertions(+), 3 deletions(-) diff --git a/drivers/mailbox/pcc.c b/drivers/mailbox/pcc.c index ad6d0b7d50fc..90e9cc324081 100644 --- a/drivers/mailbox/pcc.c +++ b/drivers/mailbox/pcc.c @@ -99,6 +99,10 @@ enum pcc_chan_comm_flow_dir_type { * @error: PCC register bundle for the error status register * @plat_irq: platform interrupt * @comm_flow_dir: direction of communication flow supported by the channel + * @plat_irq_flags: platform interrupt flags + * @chan_in_use: flag indicating whether the channel is in use or not when use + * platform interrupt, and only use it for communication from OSPM + * to Platform. */ struct pcc_chan_info { struct pcc_mbox_chan chan; @@ -109,6 +113,8 @@ struct pcc_chan_info { struct pcc_chan_reg error; int plat_irq; u8 comm_flow_dir; + unsigned int plat_irq_flags; + bool chan_in_use; }; #define to_pcc_chan_info(c) container_of(c, struct pcc_chan_info, chan) @@ -232,6 +238,12 @@ static int pcc_map_interrupt(u32 interrupt, u32 flags) return acpi_register_gsi(NULL, interrupt, trigger, polarity); } +static bool pcc_chan_plat_irq_can_be_shared(struct pcc_chan_info *pchan) +{ + return (pchan->plat_irq_flags & ACPI_PCCT_INTERRUPT_MODE) == + ACPI_LEVEL_SENSITIVE; +} + static bool pcc_chan_need_rsp_irq(struct pcc_chan_info *pchan, u64 cmd_complete_reg_val) { @@ -284,6 +296,9 @@ static irqreturn_t pcc_mbox_irq(int irq, void *p) int ret; pchan = chan->con_priv; + if (pchan->comm_flow_dir == PCC_ONLY_OSPM_TO_PLATFORM && + !pchan->chan_in_use) + return IRQ_NONE; ret = pcc_chan_reg_read(&pchan->cmd_complete, &val); if (ret) @@ -310,9 +325,14 @@ static irqreturn_t pcc_mbox_irq(int irq, void *p) * For communication flow from Platform to OSPM (like, slave subspace), * need to set the command complete bit and ring doorbell after * processing message. + * + * For communication flow from OSPM to Platform, clear chan_in_use flag + * to free this channel. */ if (pchan->comm_flow_dir == PCC_ONLY_PLATFORM_TO_OSPM) pcc_send_data(chan, NULL); + else if (pchan->comm_flow_dir == PCC_ONLY_OSPM_TO_PLATFORM) + pchan->chan_in_use = false; return IRQ_HANDLED; } @@ -361,10 +381,13 @@ pcc_mbox_request_channel(struct mbox_client *cl, int subspace_id) spin_unlock_irqrestore(&chan->lock, flags); if (pchan->plat_irq > 0) { + unsigned long irqflags; int rc; - rc = devm_request_irq(dev, pchan->plat_irq, pcc_mbox_irq, 0, - MBOX_IRQ_NAME, chan); + irqflags = pcc_chan_plat_irq_can_be_shared(pchan) ? + IRQF_SHARED | IRQF_ONESHOT : 0; + rc = devm_request_irq(dev, pchan->plat_irq, pcc_mbox_irq, + irqflags, MBOX_IRQ_NAME, chan); if (unlikely(rc)) { dev_err(dev, "failed to register PCC interrupt %d\n", pchan->plat_irq); @@ -426,7 +449,17 @@ static int pcc_send_data(struct mbox_chan *chan, void *data) if (ret) return ret; - return pcc_chan_reg_read_modify_write(&pchan->db); + ret = pcc_chan_reg_read_modify_write(&pchan->db); + /* + * For communication flow from OSPM to Platform, set chan_in_use flag + * of this channel to true after ring doorbell, and clear this flag + * when the reply message is processed. + */ + if (!ret && pchan->comm_flow_dir == PCC_ONLY_OSPM_TO_PLATFORM && + pchan->plat_irq > 0) + pchan->chan_in_use = true; + + return ret; } static const struct mbox_chan_ops pcc_chan_ops = { @@ -509,6 +542,7 @@ static int pcc_parse_subspace_irq(struct pcc_chan_info *pchan, pcct_ss->platform_interrupt); return -EINVAL; } + pchan->plat_irq_flags = pcct_ss->flags; if (pcct_ss->header.type == ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2) { struct acpi_pcct_hw_reduced_type2 *pcct2_ss = (void *)pcct_ss; @@ -530,6 +564,12 @@ static int pcc_parse_subspace_irq(struct pcc_chan_info *pchan, "PLAT IRQ ACK"); } + if (pcc_chan_plat_irq_can_be_shared(pchan) && + !pchan->plat_irq_ack.gas) { + pr_err("PCC subspace has level IRQ with no ACK register\n"); + return -EINVAL; + } + return ret; }