From patchwork Sun Oct 16 03:40:43 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Huisong Li X-Patchwork-Id: 2978 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a5d:4ac7:0:0:0:0:0 with SMTP id y7csp868724wrs; Sat, 15 Oct 2022 20:42:18 -0700 (PDT) X-Google-Smtp-Source: AMsMyM77S/YkfTUDdyUvFpldJmbNDhufOp32unp1DgBk5Y5JbTt+f/MX/3FlHnxl+Kgtji2zaZ27 X-Received: by 2002:a17:90a:5915:b0:20a:d6d5:31bd with SMTP id k21-20020a17090a591500b0020ad6d531bdmr6361972pji.15.1665891738356; Sat, 15 Oct 2022 20:42:18 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1665891738; cv=none; d=google.com; s=arc-20160816; b=Myz1fB88S8eCQU5ukehYduIAa/e0bzzLdPEX+OXADf3X0FZ459f/V0cNeONKo8bF/d iVw94VtoGmO34w3pdO2+A5fjXh57CysGEqaBeYT34Ti99+MUKVFa9Oxm2uhz0soZN3bS zT9RBFDpxVi8b+PuS8Q2lSmkJKXDSBx3LQL9ODlRLOMCkIeTH6UploWuU29JVtOPHMc2 6rVuBttOniKbwPl6oTBRt9YF2wOtTxRftlpotxwvB0bfQp9Gph5Yxwx9+aIcaKgDGUF/ BoLWKHYlnB3HbacNth1xj3RbYiqdZ3BNcN5+u7ZUhz9LtcwkeC6fKjro7VZICbJWDpEG VCxw== 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 :message-id:date:subject:cc:to:from; bh=y1CIDElbEqxIseYjayeMei3+VGi9OOapkp4iFmabQmI=; b=bBEen5W1q1kcBTw11xFqfkqoMGiPcK7SPiFCFusW+OxBgoNFpisDX5NxgM8tAVfmL5 oGJjTHHsIii6iDNNDKZlWcRGVtBNm9+UvrcLveaQOxteXVqxX5mpqm9TTmWWppuWAuWu jWXZ4jVhUetBCJg0dkYo5pTmNXx8dUgGzBeUyYxZU/QSKQ5sNHWhEGMv631vM6GGhCWm aZLWrZFR2/ZUh1flHgJbxOwrC/y7Eti2bB7mGjAK5edfT9W573kh2m7yuWdRg/0P6dzQ NqQPBx2bXBJ4uBZQHF1TBhERGbTgLxUtTSkDXD5RLDbEGuloOPk1W1kXpg4NVXbaESrb x/9A== 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 l186-20020a6388c3000000b0041bd0985ea9si7561979pgd.671.2022.10.15.20.42.05; Sat, 15 Oct 2022 20:42:18 -0700 (PDT) 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 S229716AbiJPDkd (ORCPT + 99 others); Sat, 15 Oct 2022 23:40:33 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37580 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229463AbiJPDkb (ORCPT ); Sat, 15 Oct 2022 23:40:31 -0400 Received: from szxga02-in.huawei.com (szxga02-in.huawei.com [45.249.212.188]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 9ADDB2F657; Sat, 15 Oct 2022 20:40:28 -0700 (PDT) Received: from dggemv704-chm.china.huawei.com (unknown [172.30.72.57]) by szxga02-in.huawei.com (SkyGuard) with ESMTP id 4Mqm496DGhzVjW5; Sun, 16 Oct 2022 11:35:53 +0800 (CST) Received: from kwepemm600004.china.huawei.com (7.193.23.242) by dggemv704-chm.china.huawei.com (10.3.19.47) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2375.31; Sun, 16 Oct 2022 11:39:57 +0800 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; Sun, 16 Oct 2022 11:39:56 +0800 From: Huisong Li To: , CC: , , , , , , Subject: [RFC] ACPI: PCC: Support shared interrupt for multiple subspaces Date: Sun, 16 Oct 2022 11:40:43 +0800 Message-ID: <20221016034043.52227-1-lihuisong@huawei.com> X-Mailer: git-send-email 2.33.0 MIME-Version: 1.0 X-Originating-IP: [10.69.192.56] X-ClientProxiedBy: dggems705-chm.china.huawei.com (10.3.19.182) 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?1746814095521737206?= X-GMAIL-MSGID: =?utf-8?q?1746814095521737206?= As ACPI protocol descripted, if interrupts are level, a GSIV may be shared by multiple subspaces, but each one must have unique platform interrupt ack preserve and ack set masks. Therefore, need set to shared interrupt for types that can distinguish interrupt response channel if platform interrupt mode is level triggered. The distinguishing point isn't definitely command complete register. Because the two status values of command complete indicate that there is no interrupt in a subspace('1' means subspace is free for use, and '0' means platform is processing the command). On the whole, the platform interrupt ack register is more suitable for this role. As ACPI protocol said, If the subspace does support interrupts, and these are level, this register must be supplied. And is used to clear the interrupt by using a read, modify, write sequence. This register is a 'WR' register, the bit corresponding to the subspace is '1' when the command is completed, or is '0'. Therefore, register shared interrupt for multiple subspaces if support platform interrupt ack register and interrupts are level, and read the ack register to ensure the idle or unfinished command channels to quickly return IRQ_NONE. Signed-off-by: Huisong Li Signed-off-by: Sudeep Holla Reviewed-by: Sudeep Holla Reviewed-by: Sudeep Holla Reviewed-by: Hanjun Guo --- drivers/mailbox/pcc.c | 27 +++++++++++++++++++++++++-- 1 file changed, 25 insertions(+), 2 deletions(-) diff --git a/drivers/mailbox/pcc.c b/drivers/mailbox/pcc.c index 3c2bc0ca454c..86c6cc44c73d 100644 --- a/drivers/mailbox/pcc.c +++ b/drivers/mailbox/pcc.c @@ -100,6 +100,7 @@ struct pcc_chan_info { struct pcc_chan_reg cmd_update; struct pcc_chan_reg error; int plat_irq; + u8 plat_irq_trigger; }; #define to_pcc_chan_info(c) container_of(c, struct pcc_chan_info, chan) @@ -236,6 +237,15 @@ static irqreturn_t pcc_mbox_irq(int irq, void *p) int ret; pchan = chan->con_priv; + ret = pcc_chan_reg_read(&pchan->plat_irq_ack, &val); + if (ret) + return IRQ_NONE; + /* Irq ack GAS exist and check if this interrupt has the channel. */ + if (pchan->plat_irq_ack.gas) { + val &= pchan->plat_irq_ack.set_mask; + if (val == 0) + return IRQ_NONE; + } ret = pcc_chan_reg_read(&pchan->cmd_complete, &val); if (ret) @@ -309,10 +319,21 @@ 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); + /* + * As ACPI protocol descripted, if interrupts are level, a GSIV + * may be shared by multiple subspaces. + * Therefore, register shared interrupt for multiple subspaces + * if support platform interrupt ack register and interrupts + * are level. + */ + irqflags = (pchan->plat_irq_ack.gas && + pchan->plat_irq_trigger == ACPI_LEVEL_SENSITIVE) ? + IRQF_SHARED : 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); @@ -457,6 +478,8 @@ static int pcc_parse_subspace_irq(struct pcc_chan_info *pchan, pcct_ss->platform_interrupt); return -EINVAL; } + pchan->plat_irq_trigger = (pcct_ss->flags & ACPI_PCCT_INTERRUPT_MODE) ? + ACPI_EDGE_SENSITIVE : ACPI_LEVEL_SENSITIVE; if (pcct_ss->header.type == ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2) { struct acpi_pcct_hw_reduced_type2 *pcct2_ss = (void *)pcct_ss; From patchwork Tue Jun 13 12:57:28 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Huisong Li X-Patchwork-Id: 107364 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:994d:0:b0:3d9:f83d:47d9 with SMTP id k13csp524726vqr; Tue, 13 Jun 2023 06:02:39 -0700 (PDT) X-Google-Smtp-Source: ACHHUZ5GfUyDzsPsTVc5hl7xnpDsTWOfAOBz+f7GX4CJAS9MHWwkI8uHXTS+pBhsTExQK8EhRMop X-Received: by 2002:a17:907:9687:b0:96a:1ee9:4a5 with SMTP id hd7-20020a170907968700b0096a1ee904a5mr15805659ejc.8.1686661358608; Tue, 13 Jun 2023 06:02:38 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1686661358; cv=none; d=google.com; s=arc-20160816; b=sFscpzGwDuyKFdSFUC8p1QuunEHgAkBe8T4RwvoioBGdkh+d2Sz/0oBy+A/HYXIPn2 wYbIaGrxyoX8Hd0Es7QFm0VBhyU2kxSv9MaSra3H1ZaEU6lesQGCskNLPXPNBHEabCuq BkBB/URMv87M8ZZQuQD7jI/ETKs0BhKk5tEGuc9YB7If1xoBWbpvylRF7YBycuQqU+p/ QCysNdtu/Wi6+BCTo0afPfCZh7fBQSBUny+ZXcGtLg5syMt5BJk66XmsbGuAVsVzTe75 C9yEgD3ICTJDvt4QNF1uVFB6/Ty+dLDyJq9aGepO//J462cGZh7TjFive9ybyrcUja3f 1fHg== 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=nf9oS1oGdYmoqBow1uzOr/Z9Jjjj/LDA3rKH7FoXKr8=; b=elU4aI92vlKIOv7H1TnOK4pUGsiEiN9CGHruu4yWNtttUSqzUoEDEVhP0FoGLHkViY nnpUpCjV4ZqywGECdnz/venb6PFwSbOpDuscAdQXclP2HnJ12UMUBM0udOzQ/iSy1+kh WtH91SHnD1jKP+gu3PKh8Cg4HPVZiC6FNdcb4fZE+xm7zjDKexrZwaAjUBbkNVfVnaoa uCrViBJgpg7+Q5vE0Jt+lmOKnkdGdznWGZAeXCFUoGjq3U6Wvk+qyLSO9gcyfeJZIaM2 OVg6hKTSDw2cOO2oTc2q1XtSUY4SKBA3wUMqgI2S/87Fzf6R3njrfZR+dvrJvj3oAlff +8ag== 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 b17-20020a170906039100b0096aae0b36cdsi3133620eja.614.2023.06.13.06.02.05; Tue, 13 Jun 2023 06:02:38 -0700 (PDT) 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 S242393AbjFMNAA (ORCPT + 99 others); Tue, 13 Jun 2023 09:00:00 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:53850 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S242397AbjFMM7o (ORCPT ); Tue, 13 Jun 2023 08:59:44 -0400 Received: from szxga08-in.huawei.com (szxga08-in.huawei.com [45.249.212.255]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 82410184; Tue, 13 Jun 2023 05:59:40 -0700 (PDT) Received: from kwepemm600004.china.huawei.com (unknown [172.30.72.54]) by szxga08-in.huawei.com (SkyGuard) with ESMTP id 4QgT681mwGz18Lnh; Tue, 13 Jun 2023 20:54:40 +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.2507.23; Tue, 13 Jun 2023 20:59:35 +0800 From: Huisong Li To: , , , CC: , , , , , , , , , Subject: [PATCH v4 2/2] mailbox: pcc: Support shared interrupt for multiple subspaces Date: Tue, 13 Jun 2023 20:57:28 +0800 Message-ID: <20230613125728.31279-3-lihuisong@huawei.com> X-Mailer: git-send-email 2.33.0 In-Reply-To: <20230613125728.31279-1-lihuisong@huawei.com> References: <20221016034043.52227-1-lihuisong@huawei.com> <20230613125728.31279-1-lihuisong@huawei.com> MIME-Version: 1.0 X-Originating-IP: [10.69.192.56] X-ClientProxiedBy: dggems701-chm.china.huawei.com (10.3.19.178) 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,T_SCC_BODY_TEXT_LINE 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?1768592620645513910?= 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. The new field, 'chan_in_use' is used by the type only support the communication from OSPM to Platform (like type3) and should be completely ignored by other types so as to avoid too many type unnecessary checks in IRQ handler. Signed-off-by: Huisong Li Reviewed-by: Sudeep Holla --- drivers/mailbox/pcc.c | 43 ++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 40 insertions(+), 3 deletions(-) diff --git a/drivers/mailbox/pcc.c b/drivers/mailbox/pcc.c index 80310b48bfb6..94885e411085 100644 --- a/drivers/mailbox/pcc.c +++ b/drivers/mailbox/pcc.c @@ -92,6 +92,13 @@ struct pcc_chan_reg { * @error: PCC register bundle for the error status register * @plat_irq: platform interrupt * @type: PCC subspace type + * @plat_irq_flags: platform interrupt flags + * @chan_in_use: this flag is used just to check if the interrupt needs + * handling when it is shared. Since only one transfer can occur + * at a time and mailbox takes care of locking, this flag can be + * accessed without a lock. Note: the type only support the + * communication from OSPM to Platform, like type3, use it, and + * other types completely ignore it. */ struct pcc_chan_info { struct pcc_mbox_chan chan; @@ -102,6 +109,8 @@ struct pcc_chan_info { struct pcc_chan_reg error; int plat_irq; u8 type; + unsigned int plat_irq_flags; + bool chan_in_use; }; #define to_pcc_chan_info(c) container_of(c, struct pcc_chan_info, chan) @@ -225,6 +234,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_mbox_cmd_complete_check(struct pcc_chan_info *pchan) { u64 val; @@ -242,6 +257,7 @@ static bool pcc_mbox_cmd_complete_check(struct pcc_chan_info *pchan) * command complete. */ val &= pchan->cmd_complete.status_mask; + /* * If this is PCC slave subspace channel, and the command complete * bit 0 indicates that Platform is sending a notification and OSPM @@ -268,6 +284,10 @@ static irqreturn_t pcc_mbox_irq(int irq, void *p) int ret; pchan = chan->con_priv; + if (pchan->type == ACPI_PCCT_TYPE_EXT_PCC_MASTER_SUBSPACE && + !pchan->chan_in_use) + return IRQ_NONE; + if (!pcc_mbox_cmd_complete_check(pchan)) return IRQ_NONE; @@ -289,9 +309,12 @@ static irqreturn_t pcc_mbox_irq(int irq, void *p) /* * The PCC slave subspace channel needs to set the command complete bit * and ring doorbell after processing message. + * + * The PCC master subspace channel clears chan_in_use to free channel. */ if (pchan->type == ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE) pcc_send_data(chan, NULL); + pchan->chan_in_use = false; return IRQ_HANDLED; } @@ -371,7 +394,11 @@ 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); + if (!ret && pchan->plat_irq > 0) + pchan->chan_in_use = true; + + return ret; } /** @@ -384,11 +411,14 @@ static int pcc_send_data(struct mbox_chan *chan, void *data) static int pcc_startup(struct mbox_chan *chan) { struct pcc_chan_info *pchan = chan->con_priv; + unsigned long irqflags; int rc; if (pchan->plat_irq > 0) { - rc = devm_request_irq(chan->mbox->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(chan->mbox->dev, pchan->plat_irq, pcc_mbox_irq, + irqflags, MBOX_IRQ_NAME, chan); if (unlikely(rc)) { dev_err(chan->mbox->dev, "failed to register PCC interrupt %d\n", pchan->plat_irq); @@ -494,6 +524,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; @@ -515,6 +546,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; }