Commit 934f98d7 authored by Linus Torvalds's avatar Linus Torvalds

Merge tag 'vfio-v4.4-rc1' of git://github.com/awilliam/linux-vfio

Pull VFIO updates from Alex Williamson:
 - Use kernel interfaces for VPD emulation (Alex Williamson)
 - Platform fix for releasing IRQs (Eric Auger)
 - Type1 IOMMU always advertises PAGE_SIZE support when smaller mapping
   sizes are available (Eric Auger)
 - Platform fixes for incorrectly using copies of structures rather than
   pointers to structures (James Morse)
 - Rework platform reset modules, fix leak, and add AMD xgbe reset
   module (Eric Auger)
 - Fix vfio_device_get_from_name() return value (Joerg Roedel)
 - No-IOMMU interface (Alex Williamson)
 - Fix potential out of bounds array access in PCI config handling (Dan
   Carpenter)

* tag 'vfio-v4.4-rc1' of git://github.com/awilliam/linux-vfio:
  vfio/pci: make an array larger
  vfio: Include No-IOMMU mode
  vfio: Fix bug in vfio_device_get_from_name()
  VFIO: platform: reset: AMD xgbe reset module
  vfio: platform: reset: calxedaxgmac: fix ioaddr leak
  vfio: platform: add dev_info on device reset
  vfio: platform: use list of registered reset function
  vfio: platform: add compat in vfio_platform_device
  vfio: platform: reset: calxedaxgmac: add reset function registration
  vfio: platform: introduce module_vfio_reset_handler macro
  vfio: platform: add capability to register a reset function
  vfio: platform: introduce vfio-platform-base module
  vfio/platform: store mapped memory in region, instead of an on-stack copy
  vfio/type1: handle case where IOMMU does not support PAGE_SIZE size
  VFIO: platform: clear IRQ_NOAUTOEN when de-assigning the IRQ
  vfio/pci: Use kernel VPD access functions
  vfio: Whitelist PCI bridges
parents f3996e6a 222e684c
...@@ -31,6 +31,21 @@ menuconfig VFIO ...@@ -31,6 +31,21 @@ menuconfig VFIO
If you don't know what to do here, say N. If you don't know what to do here, say N.
menuconfig VFIO_NOIOMMU
bool "VFIO No-IOMMU support"
depends on VFIO
help
VFIO is built on the ability to isolate devices using the IOMMU.
Only with an IOMMU can userspace access to DMA capable devices be
considered secure. VFIO No-IOMMU mode enables IOMMU groups for
devices without IOMMU backing for the purpose of re-using the VFIO
infrastructure in a non-secure mode. Use of this mode will result
in an unsupportable kernel and will therefore taint the kernel.
Device assignment to virtual machines is also not possible with
this mode since there is no IOMMU to provide DMA translation.
If you don't know what to do here, say N.
source "drivers/vfio/pci/Kconfig" source "drivers/vfio/pci/Kconfig"
source "drivers/vfio/platform/Kconfig" source "drivers/vfio/platform/Kconfig"
source "virt/lib/Kconfig" source "virt/lib/Kconfig"
...@@ -940,13 +940,13 @@ static int vfio_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id) ...@@ -940,13 +940,13 @@ static int vfio_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
if (pdev->hdr_type != PCI_HEADER_TYPE_NORMAL) if (pdev->hdr_type != PCI_HEADER_TYPE_NORMAL)
return -EINVAL; return -EINVAL;
group = iommu_group_get(&pdev->dev); group = vfio_iommu_group_get(&pdev->dev);
if (!group) if (!group)
return -EINVAL; return -EINVAL;
vdev = kzalloc(sizeof(*vdev), GFP_KERNEL); vdev = kzalloc(sizeof(*vdev), GFP_KERNEL);
if (!vdev) { if (!vdev) {
iommu_group_put(group); vfio_iommu_group_put(group, &pdev->dev);
return -ENOMEM; return -ENOMEM;
} }
...@@ -957,7 +957,7 @@ static int vfio_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id) ...@@ -957,7 +957,7 @@ static int vfio_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
ret = vfio_add_group_dev(&pdev->dev, &vfio_pci_ops, vdev); ret = vfio_add_group_dev(&pdev->dev, &vfio_pci_ops, vdev);
if (ret) { if (ret) {
iommu_group_put(group); vfio_iommu_group_put(group, &pdev->dev);
kfree(vdev); kfree(vdev);
return ret; return ret;
} }
...@@ -993,7 +993,7 @@ static void vfio_pci_remove(struct pci_dev *pdev) ...@@ -993,7 +993,7 @@ static void vfio_pci_remove(struct pci_dev *pdev)
if (!vdev) if (!vdev)
return; return;
iommu_group_put(pdev->dev.iommu_group); vfio_iommu_group_put(pdev->dev.iommu_group, &pdev->dev);
kfree(vdev); kfree(vdev);
if (vfio_pci_is_vga(pdev)) { if (vfio_pci_is_vga(pdev)) {
......
...@@ -46,7 +46,7 @@ ...@@ -46,7 +46,7 @@
* 0: Removed from the user visible capability list * 0: Removed from the user visible capability list
* FF: Variable length * FF: Variable length
*/ */
static u8 pci_cap_length[] = { static const u8 pci_cap_length[PCI_CAP_ID_MAX + 1] = {
[PCI_CAP_ID_BASIC] = PCI_STD_HEADER_SIZEOF, /* pci config header */ [PCI_CAP_ID_BASIC] = PCI_STD_HEADER_SIZEOF, /* pci config header */
[PCI_CAP_ID_PM] = PCI_PM_SIZEOF, [PCI_CAP_ID_PM] = PCI_PM_SIZEOF,
[PCI_CAP_ID_AGP] = PCI_AGP_SIZEOF, [PCI_CAP_ID_AGP] = PCI_AGP_SIZEOF,
...@@ -74,7 +74,7 @@ static u8 pci_cap_length[] = { ...@@ -74,7 +74,7 @@ static u8 pci_cap_length[] = {
* 0: Removed or masked from the user visible capabilty list * 0: Removed or masked from the user visible capabilty list
* FF: Variable length * FF: Variable length
*/ */
static u16 pci_ext_cap_length[] = { static const u16 pci_ext_cap_length[PCI_EXT_CAP_ID_MAX + 1] = {
[PCI_EXT_CAP_ID_ERR] = PCI_ERR_ROOT_COMMAND, [PCI_EXT_CAP_ID_ERR] = PCI_ERR_ROOT_COMMAND,
[PCI_EXT_CAP_ID_VC] = 0xFF, [PCI_EXT_CAP_ID_VC] = 0xFF,
[PCI_EXT_CAP_ID_DSN] = PCI_EXT_CAP_DSN_SIZEOF, [PCI_EXT_CAP_ID_DSN] = PCI_EXT_CAP_DSN_SIZEOF,
...@@ -671,6 +671,73 @@ static int __init init_pci_cap_pm_perm(struct perm_bits *perm) ...@@ -671,6 +671,73 @@ static int __init init_pci_cap_pm_perm(struct perm_bits *perm)
return 0; return 0;
} }
static int vfio_vpd_config_write(struct vfio_pci_device *vdev, int pos,
int count, struct perm_bits *perm,
int offset, __le32 val)
{
struct pci_dev *pdev = vdev->pdev;
__le16 *paddr = (__le16 *)(vdev->vconfig + pos - offset + PCI_VPD_ADDR);
__le32 *pdata = (__le32 *)(vdev->vconfig + pos - offset + PCI_VPD_DATA);
u16 addr;
u32 data;
/*
* Write through to emulation. If the write includes the upper byte
* of PCI_VPD_ADDR, then the PCI_VPD_ADDR_F bit is written and we
* have work to do.
*/
count = vfio_default_config_write(vdev, pos, count, perm, offset, val);
if (count < 0 || offset > PCI_VPD_ADDR + 1 ||
offset + count <= PCI_VPD_ADDR + 1)
return count;
addr = le16_to_cpu(*paddr);
if (addr & PCI_VPD_ADDR_F) {
data = le32_to_cpu(*pdata);
if (pci_write_vpd(pdev, addr & ~PCI_VPD_ADDR_F, 4, &data) != 4)
return count;
} else {
if (pci_read_vpd(pdev, addr, 4, &data) != 4)
return count;
*pdata = cpu_to_le32(data);
}
/*
* Toggle PCI_VPD_ADDR_F in the emulated PCI_VPD_ADDR register to
* signal completion. If an error occurs above, we assume that not
* toggling this bit will induce a driver timeout.
*/
addr ^= PCI_VPD_ADDR_F;
*paddr = cpu_to_le16(addr);
return count;
}
/* Permissions for Vital Product Data capability */
static int __init init_pci_cap_vpd_perm(struct perm_bits *perm)
{
if (alloc_perm_bits(perm, pci_cap_length[PCI_CAP_ID_VPD]))
return -ENOMEM;
perm->writefn = vfio_vpd_config_write;
/*
* We always virtualize the next field so we can remove
* capabilities from the chain if we want to.
*/
p_setb(perm, PCI_CAP_LIST_NEXT, (u8)ALL_VIRT, NO_WRITE);
/*
* Both the address and data registers are virtualized to
* enable access through the pci_vpd_read/write functions
*/
p_setw(perm, PCI_VPD_ADDR, (u16)ALL_VIRT, (u16)ALL_WRITE);
p_setd(perm, PCI_VPD_DATA, ALL_VIRT, ALL_WRITE);
return 0;
}
/* Permissions for PCI-X capability */ /* Permissions for PCI-X capability */
static int __init init_pci_cap_pcix_perm(struct perm_bits *perm) static int __init init_pci_cap_pcix_perm(struct perm_bits *perm)
{ {
...@@ -790,6 +857,7 @@ void vfio_pci_uninit_perm_bits(void) ...@@ -790,6 +857,7 @@ void vfio_pci_uninit_perm_bits(void)
free_perm_bits(&cap_perms[PCI_CAP_ID_BASIC]); free_perm_bits(&cap_perms[PCI_CAP_ID_BASIC]);
free_perm_bits(&cap_perms[PCI_CAP_ID_PM]); free_perm_bits(&cap_perms[PCI_CAP_ID_PM]);
free_perm_bits(&cap_perms[PCI_CAP_ID_VPD]);
free_perm_bits(&cap_perms[PCI_CAP_ID_PCIX]); free_perm_bits(&cap_perms[PCI_CAP_ID_PCIX]);
free_perm_bits(&cap_perms[PCI_CAP_ID_EXP]); free_perm_bits(&cap_perms[PCI_CAP_ID_EXP]);
free_perm_bits(&cap_perms[PCI_CAP_ID_AF]); free_perm_bits(&cap_perms[PCI_CAP_ID_AF]);
...@@ -807,7 +875,7 @@ int __init vfio_pci_init_perm_bits(void) ...@@ -807,7 +875,7 @@ int __init vfio_pci_init_perm_bits(void)
/* Capabilities */ /* Capabilities */
ret |= init_pci_cap_pm_perm(&cap_perms[PCI_CAP_ID_PM]); ret |= init_pci_cap_pm_perm(&cap_perms[PCI_CAP_ID_PM]);
cap_perms[PCI_CAP_ID_VPD].writefn = vfio_raw_config_write; ret |= init_pci_cap_vpd_perm(&cap_perms[PCI_CAP_ID_VPD]);
ret |= init_pci_cap_pcix_perm(&cap_perms[PCI_CAP_ID_PCIX]); ret |= init_pci_cap_pcix_perm(&cap_perms[PCI_CAP_ID_PCIX]);
cap_perms[PCI_CAP_ID_VNDR].writefn = vfio_raw_config_write; cap_perms[PCI_CAP_ID_VNDR].writefn = vfio_raw_config_write;
ret |= init_pci_cap_exp_perm(&cap_perms[PCI_CAP_ID_EXP]); ret |= init_pci_cap_exp_perm(&cap_perms[PCI_CAP_ID_EXP]);
......
vfio-platform-base-y := vfio_platform_common.o vfio_platform_irq.o
vfio-platform-y := vfio_platform.o vfio_platform_common.o vfio_platform_irq.o vfio-platform-y := vfio_platform.o
obj-$(CONFIG_VFIO_PLATFORM) += vfio-platform.o obj-$(CONFIG_VFIO_PLATFORM) += vfio-platform.o
obj-$(CONFIG_VFIO_PLATFORM) += vfio-platform-base.o
obj-$(CONFIG_VFIO_PLATFORM) += reset/ obj-$(CONFIG_VFIO_PLATFORM) += reset/
vfio-amba-y := vfio_amba.o vfio-amba-y := vfio_amba.o
obj-$(CONFIG_VFIO_AMBA) += vfio-amba.o obj-$(CONFIG_VFIO_AMBA) += vfio-amba.o
obj-$(CONFIG_VFIO_AMBA) += vfio-platform-base.o
obj-$(CONFIG_VFIO_AMBA) += reset/ obj-$(CONFIG_VFIO_AMBA) += reset/
...@@ -5,3 +5,11 @@ config VFIO_PLATFORM_CALXEDAXGMAC_RESET ...@@ -5,3 +5,11 @@ config VFIO_PLATFORM_CALXEDAXGMAC_RESET
Enables the VFIO platform driver to handle reset for Calxeda xgmac Enables the VFIO platform driver to handle reset for Calxeda xgmac
If you don't know what to do here, say N. If you don't know what to do here, say N.
config VFIO_PLATFORM_AMDXGBE_RESET
tristate "VFIO support for AMD XGBE reset"
depends on VFIO_PLATFORM
help
Enables the VFIO platform driver to handle reset for AMD XGBE
If you don't know what to do here, say N.
vfio-platform-calxedaxgmac-y := vfio_platform_calxedaxgmac.o vfio-platform-calxedaxgmac-y := vfio_platform_calxedaxgmac.o
vfio-platform-amdxgbe-y := vfio_platform_amdxgbe.o
ccflags-y += -Idrivers/vfio/platform ccflags-y += -Idrivers/vfio/platform
obj-$(CONFIG_VFIO_PLATFORM_CALXEDAXGMAC_RESET) += vfio-platform-calxedaxgmac.o obj-$(CONFIG_VFIO_PLATFORM_CALXEDAXGMAC_RESET) += vfio-platform-calxedaxgmac.o
obj-$(CONFIG_VFIO_PLATFORM_AMDXGBE_RESET) += vfio-platform-amdxgbe.o
/*
* VFIO platform driver specialized for AMD xgbe reset
* reset code is inherited from AMD xgbe native driver
*
* Copyright (c) 2015 Linaro Ltd.
* www.linaro.org
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along with
* this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/io.h>
#include <uapi/linux/mdio.h>
#include <linux/delay.h>
#include "vfio_platform_private.h"
#define DMA_MR 0x3000
#define MAC_VR 0x0110
#define DMA_ISR 0x3008
#define MAC_ISR 0x00b0
#define PCS_MMD_SELECT 0xff
#define MDIO_AN_INT 0x8002
#define MDIO_AN_INTMASK 0x8001
static unsigned int xmdio_read(void *ioaddr, unsigned int mmd,
unsigned int reg)
{
unsigned int mmd_address, value;
mmd_address = (mmd << 16) | ((reg) & 0xffff);
iowrite32(mmd_address >> 8, ioaddr + (PCS_MMD_SELECT << 2));
value = ioread32(ioaddr + ((mmd_address & 0xff) << 2));
return value;
}
static void xmdio_write(void *ioaddr, unsigned int mmd,
unsigned int reg, unsigned int value)
{
unsigned int mmd_address;
mmd_address = (mmd << 16) | ((reg) & 0xffff);
iowrite32(mmd_address >> 8, ioaddr + (PCS_MMD_SELECT << 2));
iowrite32(value, ioaddr + ((mmd_address & 0xff) << 2));
}
int vfio_platform_amdxgbe_reset(struct vfio_platform_device *vdev)
{
struct vfio_platform_region *xgmac_regs = &vdev->regions[0];
struct vfio_platform_region *xpcs_regs = &vdev->regions[1];
u32 dma_mr_value, pcs_value, value;
unsigned int count;
if (!xgmac_regs->ioaddr) {
xgmac_regs->ioaddr =
ioremap_nocache(xgmac_regs->addr, xgmac_regs->size);
if (!xgmac_regs->ioaddr)
return -ENOMEM;
}
if (!xpcs_regs->ioaddr) {
xpcs_regs->ioaddr =
ioremap_nocache(xpcs_regs->addr, xpcs_regs->size);
if (!xpcs_regs->ioaddr)
return -ENOMEM;
}
/* reset the PHY through MDIO*/
pcs_value = xmdio_read(xpcs_regs->ioaddr, MDIO_MMD_PCS, MDIO_CTRL1);
pcs_value |= MDIO_CTRL1_RESET;
xmdio_write(xpcs_regs->ioaddr, MDIO_MMD_PCS, MDIO_CTRL1, pcs_value);
count = 50;
do {
msleep(20);
pcs_value = xmdio_read(xpcs_regs->ioaddr, MDIO_MMD_PCS,
MDIO_CTRL1);
} while ((pcs_value & MDIO_CTRL1_RESET) && --count);
if (pcs_value & MDIO_CTRL1_RESET)
pr_warn("%s XGBE PHY reset timeout\n", __func__);
/* disable auto-negotiation */
value = xmdio_read(xpcs_regs->ioaddr, MDIO_MMD_AN, MDIO_CTRL1);
value &= ~MDIO_AN_CTRL1_ENABLE;
xmdio_write(xpcs_regs->ioaddr, MDIO_MMD_AN, MDIO_CTRL1, value);
/* disable AN IRQ */
xmdio_write(xpcs_regs->ioaddr, MDIO_MMD_AN, MDIO_AN_INTMASK, 0);
/* clear AN IRQ */
xmdio_write(xpcs_regs->ioaddr, MDIO_MMD_AN, MDIO_AN_INT, 0);
/* MAC software reset */
dma_mr_value = ioread32(xgmac_regs->ioaddr + DMA_MR);
dma_mr_value |= 0x1;
iowrite32(dma_mr_value, xgmac_regs->ioaddr + DMA_MR);
usleep_range(10, 15);
count = 2000;
while (count-- && (ioread32(xgmac_regs->ioaddr + DMA_MR) & 1))
usleep_range(500, 600);
if (!count)
pr_warn("%s MAC SW reset failed\n", __func__);
return 0;
}
module_vfio_reset_handler("amd,xgbe-seattle-v1a", vfio_platform_amdxgbe_reset);
MODULE_VERSION("0.1");
MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("Eric Auger <eric.auger@linaro.org>");
MODULE_DESCRIPTION("Reset support for AMD xgbe vfio platform device");
...@@ -30,8 +30,6 @@ ...@@ -30,8 +30,6 @@
#define DRIVER_AUTHOR "Eric Auger <eric.auger@linaro.org>" #define DRIVER_AUTHOR "Eric Auger <eric.auger@linaro.org>"
#define DRIVER_DESC "Reset support for Calxeda xgmac vfio platform device" #define DRIVER_DESC "Reset support for Calxeda xgmac vfio platform device"
#define CALXEDAXGMAC_COMPAT "calxeda,hb-xgmac"
/* XGMAC Register definitions */ /* XGMAC Register definitions */
#define XGMAC_CONTROL 0x00000000 /* MAC Configuration */ #define XGMAC_CONTROL 0x00000000 /* MAC Configuration */
...@@ -61,24 +59,25 @@ static inline void xgmac_mac_disable(void __iomem *ioaddr) ...@@ -61,24 +59,25 @@ static inline void xgmac_mac_disable(void __iomem *ioaddr)
int vfio_platform_calxedaxgmac_reset(struct vfio_platform_device *vdev) int vfio_platform_calxedaxgmac_reset(struct vfio_platform_device *vdev)
{ {
struct vfio_platform_region reg = vdev->regions[0]; struct vfio_platform_region *reg = &vdev->regions[0];
if (!reg.ioaddr) { if (!reg->ioaddr) {
reg.ioaddr = reg->ioaddr =
ioremap_nocache(reg.addr, reg.size); ioremap_nocache(reg->addr, reg->size);
if (!reg.ioaddr) if (!reg->ioaddr)
return -ENOMEM; return -ENOMEM;
} }
/* disable IRQ */ /* disable IRQ */
writel(0, reg.ioaddr + XGMAC_DMA_INTR_ENA); writel(0, reg->ioaddr + XGMAC_DMA_INTR_ENA);
/* Disable the MAC core */ /* Disable the MAC core */
xgmac_mac_disable(reg.ioaddr); xgmac_mac_disable(reg->ioaddr);
return 0; return 0;
} }
EXPORT_SYMBOL_GPL(vfio_platform_calxedaxgmac_reset);
module_vfio_reset_handler("calxeda,hb-xgmac", vfio_platform_calxedaxgmac_reset);
MODULE_VERSION(DRIVER_VERSION); MODULE_VERSION(DRIVER_VERSION);
MODULE_LICENSE("GPL v2"); MODULE_LICENSE("GPL v2");
......
...@@ -67,6 +67,7 @@ static int vfio_amba_probe(struct amba_device *adev, const struct amba_id *id) ...@@ -67,6 +67,7 @@ static int vfio_amba_probe(struct amba_device *adev, const struct amba_id *id)
vdev->flags = VFIO_DEVICE_FLAGS_AMBA; vdev->flags = VFIO_DEVICE_FLAGS_AMBA;
vdev->get_resource = get_amba_resource; vdev->get_resource = get_amba_resource;
vdev->get_irq = get_amba_irq; vdev->get_irq = get_amba_irq;
vdev->parent_module = THIS_MODULE;
ret = vfio_platform_probe_common(vdev, &adev->dev); ret = vfio_platform_probe_common(vdev, &adev->dev);
if (ret) { if (ret) {
......
...@@ -65,6 +65,7 @@ static int vfio_platform_probe(struct platform_device *pdev) ...@@ -65,6 +65,7 @@ static int vfio_platform_probe(struct platform_device *pdev)
vdev->flags = VFIO_DEVICE_FLAGS_PLATFORM; vdev->flags = VFIO_DEVICE_FLAGS_PLATFORM;
vdev->get_resource = get_platform_resource; vdev->get_resource = get_platform_resource;
vdev->get_irq = get_platform_irq; vdev->get_irq = get_platform_irq;
vdev->parent_module = THIS_MODULE;
ret = vfio_platform_probe_common(vdev, &pdev->dev); ret = vfio_platform_probe_common(vdev, &pdev->dev);
if (ret) if (ret)
......
...@@ -23,44 +23,50 @@ ...@@ -23,44 +23,50 @@
#include "vfio_platform_private.h" #include "vfio_platform_private.h"
static DEFINE_MUTEX(driver_lock); #define DRIVER_VERSION "0.10"
#define DRIVER_AUTHOR "Antonios Motakis <a.motakis@virtualopensystems.com>"
#define DRIVER_DESC "VFIO platform base module"
static const struct vfio_platform_reset_combo reset_lookup_table[] = { static LIST_HEAD(reset_list);
{ static DEFINE_MUTEX(driver_lock);
.compat = "calxeda,hb-xgmac",
.reset_function_name = "vfio_platform_calxedaxgmac_reset",
.module_name = "vfio-platform-calxedaxgmac",
},
};
static void vfio_platform_get_reset(struct vfio_platform_device *vdev, static vfio_platform_reset_fn_t vfio_platform_lookup_reset(const char *compat,
struct device *dev) struct module **module)
{ {
const char *compat; struct vfio_platform_reset_node *iter;
int (*reset)(struct vfio_platform_device *); vfio_platform_reset_fn_t reset_fn = NULL;
int ret, i;
mutex_lock(&driver_lock);
ret = device_property_read_string(dev, "compatible", &compat); list_for_each_entry(iter, &reset_list, link) {
if (ret) if (!strcmp(iter->compat, compat) &&
return; try_module_get(iter->owner)) {
*module = iter->owner;
for (i = 0 ; i < ARRAY_SIZE(reset_lookup_table); i++) { reset_fn = iter->reset;
if (!strcmp(reset_lookup_table[i].compat, compat)) { break;
request_module(reset_lookup_table[i].module_name);
reset = __symbol_get(
reset_lookup_table[i].reset_function_name);
if (reset) {
vdev->reset = reset;
return;
}
} }
} }
mutex_unlock(&driver_lock);
return reset_fn;
}
static void vfio_platform_get_reset(struct vfio_platform_device *vdev)
{
char modname[256];
vdev->reset = vfio_platform_lookup_reset(vdev->compat,
&vdev->reset_module);
if (!vdev->reset) {
snprintf(modname, 256, "vfio-reset:%s", vdev->compat);
request_module(modname);
vdev->reset = vfio_platform_lookup_reset(vdev->compat,
&vdev->reset_module);
}
} }
static void vfio_platform_put_reset(struct vfio_platform_device *vdev) static void vfio_platform_put_reset(struct vfio_platform_device *vdev)
{ {
if (vdev->reset) if (vdev->reset)
symbol_put_addr(vdev->reset); module_put(vdev->reset_module);
} }
static int vfio_platform_regions_init(struct vfio_platform_device *vdev) static int vfio_platform_regions_init(struct vfio_platform_device *vdev)
...@@ -138,15 +144,19 @@ static void vfio_platform_release(void *device_data) ...@@ -138,15 +144,19 @@ static void vfio_platform_release(void *device_data)
mutex_lock(&driver_lock); mutex_lock(&driver_lock);
if (!(--vdev->refcnt)) { if (!(--vdev->refcnt)) {
if (vdev->reset) if (vdev->reset) {
dev_info(vdev->device, "reset\n");
vdev->reset(vdev); vdev->reset(vdev);
} else {
dev_warn(vdev->device, "no reset function found!\n");
}
vfio_platform_regions_cleanup(vdev); vfio_platform_regions_cleanup(vdev);
vfio_platform_irq_cleanup(vdev); vfio_platform_irq_cleanup(vdev);
} }
mutex_unlock(&driver_lock); mutex_unlock(&driver_lock);
module_put(THIS_MODULE); module_put(vdev->parent_module);
} }
static int vfio_platform_open(void *device_data) static int vfio_platform_open(void *device_data)
...@@ -154,7 +164,7 @@ static int vfio_platform_open(void *device_data) ...@@ -154,7 +164,7 @@ static int vfio_platform_open(void *device_data)
struct vfio_platform_device *vdev = device_data; struct vfio_platform_device *vdev = device_data;
int ret; int ret;
if (!try_module_get(THIS_MODULE)) if (!try_module_get(vdev->parent_module))
return -ENODEV; return -ENODEV;
mutex_lock(&driver_lock); mutex_lock(&driver_lock);
...@@ -168,8 +178,12 @@ static int vfio_platform_open(void *device_data) ...@@ -168,8 +178,12 @@ static int vfio_platform_open(void *device_data)
if (ret) if (ret)
goto err_irq; goto err_irq;
if (vdev->reset) if (vdev->reset) {
dev_info(vdev->device, "reset\n");
vdev->reset(vdev); vdev->reset(vdev);
} else {
dev_warn(vdev->device, "no reset function found!\n");
}
} }
vdev->refcnt++; vdev->refcnt++;
...@@ -307,17 +321,17 @@ static long vfio_platform_ioctl(void *device_data, ...@@ -307,17 +321,17 @@ static long vfio_platform_ioctl(void *device_data,
return -ENOTTY; return -ENOTTY;
} }
static ssize_t vfio_platform_read_mmio(struct vfio_platform_region reg, static ssize_t vfio_platform_read_mmio(struct vfio_platform_region *reg,
char __user *buf, size_t count, char __user *buf, size_t count,
loff_t off) loff_t off)
{ {
unsigned int done = 0; unsigned int done = 0;
if (!reg.ioaddr) { if (!reg->ioaddr) {
reg.ioaddr = reg->ioaddr =
ioremap_nocache(reg.addr, reg.size); ioremap_nocache(reg->addr, reg->size);
if (!reg.ioaddr) if (!reg->ioaddr)
return -ENOMEM; return -ENOMEM;
} }
...@@ -327,7 +341,7 @@ static ssize_t vfio_platform_read_mmio(struct vfio_platform_region reg, ...@@ -327,7 +341,7 @@ static ssize_t vfio_platform_read_mmio(struct vfio_platform_region reg,
if (count >= 4 && !(off % 4)) { if (count >= 4 && !(off % 4)) {
u32 val; u32 val;
val = ioread32(reg.ioaddr + off); val = ioread32(reg->ioaddr + off);
if (copy_to_user(buf, &val, 4)) if (copy_to_user(buf, &val, 4))
goto err; goto err;
...@@ -335,7 +349,7 @@ static ssize_t vfio_platform_read_mmio(struct vfio_platform_region reg, ...@@ -335,7 +349,7 @@ static ssize_t vfio_platform_read_mmio(struct vfio_platform_region reg,
} else if (count >= 2 && !(off % 2)) { } else if (count >= 2 && !(off % 2)) {
u16 val; u16 val;
val = ioread16(reg.ioaddr + off); val = ioread16(reg->ioaddr + off);
if (copy_to_user(buf, &val, 2)) if (copy_to_user(buf, &val, 2))
goto err; goto err;
...@@ -343,7 +357,7 @@ static ssize_t vfio_platform_read_mmio(struct vfio_platform_region reg, ...@@ -343,7 +357,7 @@ static ssize_t vfio_platform_read_mmio(struct vfio_platform_region reg,
} else { } else {
u8 val; u8 val;
val = ioread8(reg.ioaddr + off); val = ioread8(reg->ioaddr + off);
if (copy_to_user(buf, &val, 1)) if (copy_to_user(buf, &val, 1))
goto err; goto err;
...@@ -376,7 +390,7 @@ static ssize_t vfio_platform_read(void *device_data, char __user *buf, ...@@ -376,7 +390,7 @@ static ssize_t vfio_platform_read(void *device_data, char __user *buf,
return -EINVAL; return -EINVAL;
if (vdev->regions[index].type & VFIO_PLATFORM_REGION_TYPE_MMIO) if (vdev->regions[index].type & VFIO_PLATFORM_REGION_TYPE_MMIO)
return vfio_platform_read_mmio(vdev->regions[index], return vfio_platform_read_mmio(&vdev->regions[index],
buf, count, off); buf, count, off);
else if (vdev->regions[index].type & VFIO_PLATFORM_REGION_TYPE_PIO) else if (vdev->regions[index].type & VFIO_PLATFORM_REGION_TYPE_PIO)
return -EINVAL; /* not implemented */ return -EINVAL; /* not implemented */
...@@ -384,17 +398,17 @@ static ssize_t vfio_platform_read(void *device_data, char __user *buf, ...@@ -384,17 +398,17 @@ static ssize_t vfio_platform_read(void *device_data, char __user *buf,
return -EINVAL; return -EINVAL;
} }
static ssize_t vfio_platform_write_mmio(struct vfio_platform_region reg, static ssize_t vfio_platform_write_mmio(struct vfio_platform_region *reg,
const char __user *buf, size_t count, const char __user *buf, size_t count,
loff_t off) loff_t off)
{ {
unsigned int done = 0; unsigned int done = 0;
if (!reg.ioaddr) { if (!reg->ioaddr) {
reg.ioaddr = reg->ioaddr =
ioremap_nocache(reg.addr, reg.size); ioremap_nocache(reg->addr, reg->size);
if (!reg.ioaddr) if (!reg->ioaddr)
return -ENOMEM; return -ENOMEM;
} }
...@@ -406,7 +420,7 @@ static ssize_t vfio_platform_write_mmio(struct vfio_platform_region reg, ...@@ -406,7 +420,7 @@ static ssize_t vfio_platform_write_mmio(struct vfio_platform_region reg,
if (copy_from_user(&val, buf, 4)) if (copy_from_user(&val, buf, 4))
goto err; goto err;
iowrite32(val, reg.ioaddr + off); iowrite32(val, reg->ioaddr + off);
filled = 4; filled = 4;
} else if (count >= 2 && !(off % 2)) { } else if (count >= 2 && !(off % 2)) {
...@@ -414,7 +428,7 @@ static ssize_t vfio_platform_write_mmio(struct vfio_platform_region reg, ...@@ -414,7 +428,7 @@ static ssize_t vfio_platform_write_mmio(struct vfio_platform_region reg,
if (copy_from_user(&val, buf, 2)) if (copy_from_user(&val, buf, 2))
goto err; goto err;
iowrite16(val, reg.ioaddr + off); iowrite16(val, reg->ioaddr + off);
filled = 2; filled = 2;
} else { } else {
...@@ -422,7 +436,7 @@ static ssize_t vfio_platform_write_mmio(struct vfio_platform_region reg, ...@@ -422,7 +436,7 @@ static ssize_t vfio_platform_write_mmio(struct vfio_platform_region reg,
if (copy_from_user(&val, buf, 1)) if (copy_from_user(&val, buf, 1))
goto err; goto err;
iowrite8(val, reg.ioaddr + off); iowrite8(val, reg->ioaddr + off);
filled = 1; filled = 1;
} }
...@@ -452,7 +466,7 @@ static ssize_t vfio_platform_write(void *device_data, const char __user *buf, ...@@ -452,7 +466,7 @@ static ssize_t vfio_platform_write(void *device_data, const char __user *buf,
return -EINVAL; return -EINVAL;
if (vdev->regions[index].type & VFIO_PLATFORM_REGION_TYPE_MMIO) if (vdev->regions[index].type & VFIO_PLATFORM_REGION_TYPE_MMIO)
return vfio_platform_write_mmio(vdev->regions[index], return vfio_platform_write_mmio(&vdev->regions[index],
buf, count, off); buf, count, off);
else if (vdev->regions[index].type & VFIO_PLATFORM_REGION_TYPE_PIO) else if (vdev->regions[index].type & VFIO_PLATFORM_REGION_TYPE_PIO)
return -EINVAL; /* not implemented */ return -EINVAL; /* not implemented */
...@@ -539,6 +553,14 @@ int vfio_platform_probe_common(struct vfio_platform_device *vdev, ...@@ -539,6 +553,14 @@ int vfio_platform_probe_common(struct vfio_platform_device *vdev,
if (!vdev) if (!vdev)
return -EINVAL; return -EINVAL;
ret = device_property_read_string(dev, "compatible", &vdev->compat);
if (ret) {
pr_err("VFIO: cannot retrieve compat for %s\n", vdev->name);
return -EINVAL;
}
vdev->device = dev;
group = iommu_group_get(dev); group = iommu_group_get(dev);
if (!group) { if (!group) {
pr_err("VFIO: No IOMMU group for device %s\n", vdev->name); pr_err("VFIO: No IOMMU group for device %s\n", vdev->name);
...@@ -551,7 +573,7 @@ int vfio_platform_probe_common(struct vfio_platform_device *vdev, ...@@ -551,7 +573,7 @@ int vfio_platform_probe_common(struct vfio_platform_device *vdev,
return ret; return ret;
} }
vfio_platform_get_reset(vdev, dev); vfio_platform_get_reset(vdev);
mutex_init(&vdev->igate); mutex_init(&vdev->igate);
...@@ -573,3 +595,34 @@ struct vfio_platform_device *vfio_platform_remove_common(struct device *dev) ...@@ -573,3 +595,34 @@ struct vfio_platform_device *vfio_platform_remove_common(struct device *dev)
return vdev; return vdev;
} }
EXPORT_SYMBOL_GPL(vfio_platform_remove_common); EXPORT_SYMBOL_GPL(vfio_platform_remove_common);
void __vfio_platform_register_reset(struct vfio_platform_reset_node *node)
{
mutex_lock(&driver_lock);
list_add(&node->link, &reset_list);
mutex_unlock(&driver_lock);
}
EXPORT_SYMBOL_GPL(__vfio_platform_register_reset);
void vfio_platform_unregister_reset(const char *compat,
vfio_platform_reset_fn_t fn)
{
struct vfio_platform_reset_node *iter, *temp;
mutex_lock(&driver_lock);
list_for_each_entry_safe(iter, temp, &reset_list, link) {
if (!strcmp(iter->compat, compat) && (iter->reset == fn)) {
list_del(&iter->link);
break;
}
}
mutex_unlock(&driver_lock);
}
EXPORT_SYMBOL_GPL(vfio_platform_unregister_reset);
MODULE_VERSION(DRIVER_VERSION);
MODULE_LICENSE("GPL v2");
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
...@@ -185,6 +185,7 @@ static int vfio_set_trigger(struct vfio_platform_device *vdev, int index, ...@@ -185,6 +185,7 @@ static int vfio_set_trigger(struct vfio_platform_device *vdev, int index,
int ret; int ret;
if (irq->trigger) { if (irq->trigger) {
irq_clear_status_flags(irq->hwirq, IRQ_NOAUTOEN);
free_irq(irq->hwirq, irq); free_irq(irq->hwirq, irq);
kfree(irq->name); kfree(irq->name);
eventfd_ctx_put(irq->trigger); eventfd_ctx_put(irq->trigger);
......
...@@ -56,6 +56,10 @@ struct vfio_platform_device { ...@@ -56,6 +56,10 @@ struct vfio_platform_device {
u32 num_irqs; u32 num_irqs;
int refcnt; int refcnt;
struct mutex igate; struct mutex igate;
struct module *parent_module;
const char *compat;
struct module *reset_module;
struct device *device;
/* /*
* These fields should be filled by the bus specific binder * These fields should be filled by the bus specific binder
...@@ -70,10 +74,13 @@ struct vfio_platform_device { ...@@ -70,10 +74,13 @@ struct vfio_platform_device {
int (*reset)(struct vfio_platform_device *vdev); int (*reset)(struct vfio_platform_device *vdev);
}; };
struct vfio_platform_reset_combo { typedef int (*vfio_platform_reset_fn_t)(struct vfio_platform_device *vdev);
const char *compat;
const char *reset_function_name; struct vfio_platform_reset_node {
const char *module_name; struct list_head link;
char *compat;
struct module *owner;
vfio_platform_reset_fn_t reset;
}; };
extern int vfio_platform_probe_common(struct vfio_platform_device *vdev, extern int vfio_platform_probe_common(struct vfio_platform_device *vdev,
...@@ -89,4 +96,29 @@ extern int vfio_platform_set_irqs_ioctl(struct vfio_platform_device *vdev, ...@@ -89,4 +96,29 @@ extern int vfio_platform_set_irqs_ioctl(struct vfio_platform_device *vdev,
unsigned start, unsigned count, unsigned start, unsigned count,
void *data); void *data);
extern void __vfio_platform_register_reset(struct vfio_platform_reset_node *n);
extern void vfio_platform_unregister_reset(const char *compat,
vfio_platform_reset_fn_t fn);
#define vfio_platform_register_reset(__compat, __reset) \
static struct vfio_platform_reset_node __reset ## _node = { \
.owner = THIS_MODULE, \
.compat = __compat, \
.reset = __reset, \
}; \
__vfio_platform_register_reset(&__reset ## _node)
#define module_vfio_reset_handler(compat, reset) \
MODULE_ALIAS("vfio-reset:" compat); \
static int __init reset ## _module_init(void) \
{ \
vfio_platform_register_reset(compat, reset); \
return 0; \
}; \
static void __exit reset ## _module_exit(void) \
{ \
vfio_platform_unregister_reset(compat, reset); \
}; \
module_init(reset ## _module_init); \
module_exit(reset ## _module_exit)
#endif /* VFIO_PLATFORM_PRIVATE_H */ #endif /* VFIO_PLATFORM_PRIVATE_H */
This diff is collapsed.
...@@ -403,13 +403,26 @@ static void vfio_remove_dma(struct vfio_iommu *iommu, struct vfio_dma *dma) ...@@ -403,13 +403,26 @@ static void vfio_remove_dma(struct vfio_iommu *iommu, struct vfio_dma *dma)
static unsigned long vfio_pgsize_bitmap(struct vfio_iommu *iommu) static unsigned long vfio_pgsize_bitmap(struct vfio_iommu *iommu)
{ {
struct vfio_domain *domain; struct vfio_domain *domain;
unsigned long bitmap = PAGE_MASK; unsigned long bitmap = ULONG_MAX;
mutex_lock(&iommu->lock); mutex_lock(&iommu->lock);
list_for_each_entry(domain, &iommu->domain_list, next) list_for_each_entry(domain, &iommu->domain_list, next)
bitmap &= domain->domain->ops->pgsize_bitmap; bitmap &= domain->domain->ops->pgsize_bitmap;
mutex_unlock(&iommu->lock); mutex_unlock(&iommu->lock);
/*
* In case the IOMMU supports page sizes smaller than PAGE_SIZE
* we pretend PAGE_SIZE is supported and hide sub-PAGE_SIZE sizes.
* That way the user will be able to map/unmap buffers whose size/
* start address is aligned with PAGE_SIZE. Pinning code uses that
* granularity while iommu driver can use the sub-PAGE_SIZE size
* to map the buffer.
*/
if (bitmap & ~PAGE_MASK) {
bitmap &= PAGE_MASK;
bitmap |= PAGE_SIZE;
}
return bitmap; return bitmap;
} }
......
...@@ -44,6 +44,9 @@ struct vfio_device_ops { ...@@ -44,6 +44,9 @@ struct vfio_device_ops {
void (*request)(void *device_data, unsigned int count); void (*request)(void *device_data, unsigned int count);
}; };
extern struct iommu_group *vfio_iommu_group_get(struct device *dev);
extern void vfio_iommu_group_put(struct iommu_group *group, struct device *dev);
extern int vfio_add_group_dev(struct device *dev, extern int vfio_add_group_dev(struct device *dev,
const struct vfio_device_ops *ops, const struct vfio_device_ops *ops,
void *device_data); void *device_data);
......
...@@ -38,6 +38,13 @@ ...@@ -38,6 +38,13 @@
#define VFIO_SPAPR_TCE_v2_IOMMU 7 #define VFIO_SPAPR_TCE_v2_IOMMU 7
/*
* The No-IOMMU IOMMU offers no translation or isolation for devices and
* supports no ioctls outside of VFIO_CHECK_EXTENSION. Use of VFIO's No-IOMMU
* code will taint the host kernel and should be used with extreme caution.
*/
#define VFIO_NOIOMMU_IOMMU 8
/* /*
* The IOCTL interface is designed for extensibility by embedding the * The IOCTL interface is designed for extensibility by embedding the
* structure length (argsz) and flags into structures passed between * structure length (argsz) and flags into structures passed between
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment