From patchwork Wed Jun 26 22:30:23 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Guenter Roeck X-Patchwork-Id: 2789131 Return-Path: X-Original-To: patchwork-kvm@patchwork.kernel.org Delivered-To: patchwork-parsemail@patchwork2.web.kernel.org Received: from mail.kernel.org (mail.kernel.org [198.145.19.201]) by patchwork2.web.kernel.org (Postfix) with ESMTP id 84820C0AB1 for ; Wed, 26 Jun 2013 22:30:44 +0000 (UTC) Received: from mail.kernel.org (localhost [127.0.0.1]) by mail.kernel.org (Postfix) with ESMTP id B0673202ED for ; Wed, 26 Jun 2013 22:30:42 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id A1425202D1 for ; Wed, 26 Jun 2013 22:30:41 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753407Ab3FZWa2 (ORCPT ); Wed, 26 Jun 2013 18:30:28 -0400 Received: from mail.active-venture.com ([67.228.131.205]:54748 "EHLO mail.active-venture.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753390Ab3FZWa0 (ORCPT ); Wed, 26 Jun 2013 18:30:26 -0400 Received: (qmail 96303 invoked by uid 399); 26 Jun 2013 22:30:22 -0000 X-Virus-Scan: Scanned by ClamAV 0.97.2 (no viruses); Wed, 26 Jun 2013 17:30:22 -0500 Received: from unknown (HELO localhost) (guenter@roeck-us.net@108.223.40.66) by mail.active-venture.com with ESMTPAM; 26 Jun 2013 22:30:21 -0000 X-Originating-IP: 108.223.40.66 X-Sender: guenter@roeck-us.net From: Guenter Roeck To: linux-kernel@vger.kernel.org Cc: kvm@vger.kernel.org, Greg Kroah-Hartman , "Hans J. Koch" , "Michael S. Tsirkin" , Rob Landley , linux-doc@vger.kernel.org, Guenter Roeck Subject: [RFC PATCH] uio: uio_pci_generic: Add support for MSI interrupts Date: Wed, 26 Jun 2013 15:30:23 -0700 Message-Id: <1372285823-6293-1-git-send-email-linux@roeck-us.net> X-Mailer: git-send-email 1.7.9.7 Sender: kvm-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org X-Spam-Status: No, score=-8.2 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_HI, RP_MATCHES_RCVD, UNPARSEABLE_RELAY autolearn=unavailable version=3.3.1 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on mail.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP Enable support for MSI interrupts if the device supports it. Since MSI interrupts are edge triggered, it is no longer necessary to disable interrupts in the kernel and re-enable them from user-space. Instead, clearing the interrupt condition in the user space application automatically re-enables the interrupt. Signed-off-by: Guenter Roeck --- An open question is if we can just do this unconditionally or if there should be some flag to enable it. A module parameter, maybe ? Documentation/DocBook/uio-howto.tmpl | 23 ++++++++++++++++++++--- drivers/uio/uio_pci_generic.c | 15 ++++++++++++--- 2 files changed, 32 insertions(+), 6 deletions(-) diff --git a/Documentation/DocBook/uio-howto.tmpl b/Documentation/DocBook/uio-howto.tmpl index 9561815..69b54e0 100644 --- a/Documentation/DocBook/uio-howto.tmpl +++ b/Documentation/DocBook/uio-howto.tmpl @@ -46,6 +46,12 @@ GPL version 2. + 0.10 + 2013-06-26 + gr + Added MSI support to uio_pci_generic. + + 0.9 2009-07-16 mst @@ -935,15 +941,26 @@ and look in the output for failure reasons Things to know about uio_pci_generic -Interrupts are handled using the Interrupt Disable bit in the PCI command +Interrupts are handled either as MSI interrupts (if the device supports it) or +as legacy INTx interrupts. + + +uio_pci_generic automatically configures a device to use MSI interrupts +if the device supports it. If an MSI interrupt is received, the user space +driver is notified. Since MSI interrupts are edge sensitive, the user space +driver needs to clear the interrupt condition in the device before blocking +and waiting for more interrupts. + + +Legacy interrupts are handled using the Interrupt Disable bit in the PCI command register and Interrupt Status bit in the PCI status register. All devices compliant to PCI 2.3 (circa 2002) and all compliant PCI Express devices should support these bits. uio_pci_generic detects this support, and won't bind to devices which do not support the Interrupt Disable Bit in the command register. -On each interrupt, uio_pci_generic sets the Interrupt Disable bit. -This prevents the device from generating further interrupts +If legacy interrupts are used, uio_pci_generic sets the Interrupt Disable bit on +each interrupt. This prevents the device from generating further interrupts until the bit is cleared. The userspace driver should clear this bit before blocking and waiting for more interrupts. diff --git a/drivers/uio/uio_pci_generic.c b/drivers/uio/uio_pci_generic.c index 14aa10c..3366fdb 100644 --- a/drivers/uio/uio_pci_generic.c +++ b/drivers/uio/uio_pci_generic.c @@ -32,6 +32,7 @@ struct uio_pci_generic_dev { struct uio_info info; struct pci_dev *pdev; + bool have_msi; }; static inline struct uio_pci_generic_dev * @@ -46,7 +47,7 @@ static irqreturn_t irqhandler(int irq, struct uio_info *info) { struct uio_pci_generic_dev *gdev = to_uio_pci_generic_dev(info); - if (!pci_check_and_mask_intx(gdev->pdev)) + if (!gdev->have_msi && !pci_check_and_mask_intx(gdev->pdev)) return IRQ_NONE; /* UIO core will signal the user process. */ @@ -58,6 +59,7 @@ static int probe(struct pci_dev *pdev, { struct uio_pci_generic_dev *gdev; int err; + bool have_msi = false; err = pci_enable_device(pdev); if (err) { @@ -73,7 +75,9 @@ static int probe(struct pci_dev *pdev, return -ENODEV; } - if (!pci_intx_mask_supported(pdev)) { + if (!pci_enable_msi(pdev)) { + have_msi = true; + } else if (!pci_intx_mask_supported(pdev)) { err = -ENODEV; goto err_verify; } @@ -84,10 +88,11 @@ static int probe(struct pci_dev *pdev, goto err_alloc; } + gdev->have_msi = have_msi; gdev->info.name = "uio_pci_generic"; gdev->info.version = DRIVER_VERSION; gdev->info.irq = pdev->irq; - gdev->info.irq_flags = IRQF_SHARED; + gdev->info.irq_flags = have_msi ? 0 : IRQF_SHARED; gdev->info.handler = irqhandler; gdev->pdev = pdev; @@ -99,6 +104,8 @@ static int probe(struct pci_dev *pdev, err_register: kfree(gdev); err_alloc: + if (have_msi) + pci_disable_msi(pdev); err_verify: pci_disable_device(pdev); return err; @@ -109,6 +116,8 @@ static void remove(struct pci_dev *pdev) struct uio_pci_generic_dev *gdev = pci_get_drvdata(pdev); uio_unregister_device(&gdev->info); + if (gdev->have_msi) + pci_disable_msi(pdev); pci_disable_device(pdev); kfree(gdev); }