IOMMU Updates for Linux v3.20
This time with:
* Generic page-table framework for ARM IOMMUs using the LPAE page-table
format, ARM-SMMU and Renesas IPMMU make use of it already.
* Break out of the IO virtual address allocator from the Intel IOMMU so
that it can be used by other DMA-API implementations too. The first
user will be the ARM64 common DMA-API implementation for IOMMUs
* Device tree support for Renesas IPMMU
* Various fixes and cleanups all over the place
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2.0.22 (GNU/Linux)
iQIcBAABAgAGBQJU3MJOAAoJECvwRC2XARrjopUP+wachFx8vb00M4hlnlwL6FCn
DyIFkA1n4wL0muPhjcBI+LViEXrSxjr2TYoJEaBg+fiByWWQ1Hefg+KPz331Lo1D
+uo7WiOa1AB3pfkQiUN9IN6xx+o6ivhb3UQPiL4FHjggB/qz+KVxMM9nx0j8o0fQ
D9q6HLFiOIsFkra3xZaSuDGvYUBpcwyfn8FP1HVfvLlg1uxIGDcUJX3qU5UBpj9q
al/lPZ4A7rp+JLApV6WyouPiyVOZKikb5x920KeRNBem7a9fNBdgf+x7QbKpNXa1
5MaT5MarwGe8lJE4wtjOqRtsllhia+A1rg/6JbROPrlGetRFiuIh2sCKLvwOCko/
IjBHSutpaRT1lFoAG0TAnXQlvHRG/58XxOlP3eF613X/p8/cezuUaTyTIwZam9X3
j2GWwbUcBiHTxlu7bQDPz6a7cTf4w6wEALzYl18QrAFv+2LqlCfOo/LSlpStmjrF
kRN8DYaohlTULvmFneSr8rfGsnp5yPgIPvdmqiSwTz/Ih7kYPgfLy6+v6IAHUqZj
0n9oGs8eMqVvSzM2qqmyA9WGuQZRyhNjj4iDwn/he5YMw2kqxUQYGMpLnSu0Oi48
n4PqodtVol64jKLwaHZwyU8u71iyjUC5K9TDot/I2wlSRcTELJhxGh6c1sfDLyrO
u/htIszgKCgFvVrQoEZB
=dwrA
-----END PGP SIGNATURE-----
Merge tag 'iommu-updates-v3.20' of git://git.kernel.org/pub/scm/linux/kernel/git/joro/iommu
Pull IOMMU updates from Joerg Roedel:
"This time with:
- Generic page-table framework for ARM IOMMUs using the LPAE
page-table format, ARM-SMMU and Renesas IPMMU make use of it
already.
- Break out the IO virtual address allocator from the Intel IOMMU so
that it can be used by other DMA-API implementations too. The
first user will be the ARM64 common DMA-API implementation for
IOMMUs
- Device tree support for Renesas IPMMU
- Various fixes and cleanups all over the place"
* tag 'iommu-updates-v3.20' of git://git.kernel.org/pub/scm/linux/kernel/git/joro/iommu: (36 commits)
iommu/amd: Convert non-returned local variable to boolean when relevant
iommu: Update my email address
iommu/amd: Use wait_event in put_pasid_state_wait
iommu/amd: Fix amd_iommu_free_device()
iommu/arm-smmu: Avoid build warning
iommu/fsl: Various cleanups
iommu/fsl: Use %pa to print phys_addr_t
iommu/omap: Print phys_addr_t using %pa
iommu: Make more drivers depend on COMPILE_TEST
iommu/ipmmu-vmsa: Fix IOMMU lookup when multiple IOMMUs are registered
iommu: Disable on !MMU builds
iommu/fsl: Remove unused fsl_of_pamu_ids[]
iommu/fsl: Fix section mismatch
iommu/ipmmu-vmsa: Use the ARM LPAE page table allocator
iommu: Fix trace_map() to report original iova and original size
iommu/arm-smmu: add support for iova_to_phys through ATS1PR
iopoll: Introduce memory-mapped IO polling macros
iommu/arm-smmu: don't touch the secure STLBIALL register
iommu/arm-smmu: make use of generic LPAE allocator
iommu: io-pgtable-arm: add non-secure quirk
...
This commit is contained in:
Linus Torvalds
commit
a26be149fa
28 changed files with 2239 additions and 1492 deletions
|
|
@ -0,0 +1,41 @@
|
|||
* Renesas VMSA-Compatible IOMMU
|
||||
|
||||
The IPMMU is an IOMMU implementation compatible with the ARM VMSA page tables.
|
||||
It provides address translation for bus masters outside of the CPU, each
|
||||
connected to the IPMMU through a port called micro-TLB.
|
||||
|
||||
|
||||
Required Properties:
|
||||
|
||||
- compatible: Must contain "renesas,ipmmu-vmsa".
|
||||
- reg: Base address and size of the IPMMU registers.
|
||||
- interrupts: Specifiers for the MMU fault interrupts. For instances that
|
||||
support secure mode two interrupts must be specified, for non-secure and
|
||||
secure mode, in that order. For instances that don't support secure mode a
|
||||
single interrupt must be specified.
|
||||
|
||||
- #iommu-cells: Must be 1.
|
||||
|
||||
Each bus master connected to an IPMMU must reference the IPMMU in its device
|
||||
node with the following property:
|
||||
|
||||
- iommus: A reference to the IPMMU in two cells. The first cell is a phandle
|
||||
to the IPMMU and the second cell the number of the micro-TLB that the
|
||||
device is connected to.
|
||||
|
||||
|
||||
Example: R8A7791 IPMMU-MX and VSP1-D0 bus master
|
||||
|
||||
ipmmu_mx: mmu@fe951000 {
|
||||
compatible = "renasas,ipmmu-vmsa";
|
||||
reg = <0 0xfe951000 0 0x1000>;
|
||||
interrupts = <0 222 IRQ_TYPE_LEVEL_HIGH>,
|
||||
<0 221 IRQ_TYPE_LEVEL_HIGH>;
|
||||
#iommu-cells = <1>;
|
||||
};
|
||||
|
||||
vsp1@fe928000 {
|
||||
...
|
||||
iommus = <&ipmmu_mx 13>;
|
||||
...
|
||||
};
|
||||
|
|
@ -1606,6 +1606,7 @@ M: Will Deacon <will.deacon@arm.com>
|
|||
L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
|
||||
S: Maintained
|
||||
F: drivers/iommu/arm-smmu.c
|
||||
F: drivers/iommu/io-pgtable-arm.c
|
||||
|
||||
ARM64 PORT (AARCH64 ARCHITECTURE)
|
||||
M: Catalin Marinas <catalin.marinas@arm.com>
|
||||
|
|
|
|||
|
|
@ -350,7 +350,6 @@ config ARM64_VA_BITS_42
|
|||
|
||||
config ARM64_VA_BITS_48
|
||||
bool "48-bit"
|
||||
depends on !ARM_SMMU
|
||||
|
||||
endchoice
|
||||
|
||||
|
|
|
|||
|
|
@ -32,8 +32,8 @@ enum pamu_stash_target {
|
|||
*/
|
||||
|
||||
struct pamu_stash_attribute {
|
||||
u32 cpu; /* cpu number */
|
||||
u32 cache; /* cache to stash to: L1,L2,L3 */
|
||||
u32 cpu; /* cpu number */
|
||||
u32 cache; /* cache to stash to: L1,L2,L3 */
|
||||
};
|
||||
|
||||
#endif /* __FSL_PAMU_STASH_H */
|
||||
|
|
|
|||
|
|
@ -4,6 +4,7 @@ config IOMMU_API
|
|||
|
||||
menuconfig IOMMU_SUPPORT
|
||||
bool "IOMMU Hardware Support"
|
||||
depends on MMU
|
||||
default y
|
||||
---help---
|
||||
Say Y here if you want to compile device drivers for IO Memory
|
||||
|
|
@ -13,13 +14,43 @@ menuconfig IOMMU_SUPPORT
|
|||
|
||||
if IOMMU_SUPPORT
|
||||
|
||||
menu "Generic IOMMU Pagetable Support"
|
||||
|
||||
# Selected by the actual pagetable implementations
|
||||
config IOMMU_IO_PGTABLE
|
||||
bool
|
||||
|
||||
config IOMMU_IO_PGTABLE_LPAE
|
||||
bool "ARMv7/v8 Long Descriptor Format"
|
||||
select IOMMU_IO_PGTABLE
|
||||
help
|
||||
Enable support for the ARM long descriptor pagetable format.
|
||||
This allocator supports 4K/2M/1G, 16K/32M and 64K/512M page
|
||||
sizes at both stage-1 and stage-2, as well as address spaces
|
||||
up to 48-bits in size.
|
||||
|
||||
config IOMMU_IO_PGTABLE_LPAE_SELFTEST
|
||||
bool "LPAE selftests"
|
||||
depends on IOMMU_IO_PGTABLE_LPAE
|
||||
help
|
||||
Enable self-tests for LPAE page table allocator. This performs
|
||||
a series of page-table consistency checks during boot.
|
||||
|
||||
If unsure, say N here.
|
||||
|
||||
endmenu
|
||||
|
||||
config IOMMU_IOVA
|
||||
bool
|
||||
|
||||
config OF_IOMMU
|
||||
def_bool y
|
||||
depends on OF && IOMMU_API
|
||||
|
||||
config FSL_PAMU
|
||||
bool "Freescale IOMMU support"
|
||||
depends on PPC_E500MC
|
||||
depends on PPC32
|
||||
depends on PPC_E500MC || COMPILE_TEST
|
||||
select IOMMU_API
|
||||
select GENERIC_ALLOCATOR
|
||||
help
|
||||
|
|
@ -30,7 +61,8 @@ config FSL_PAMU
|
|||
# MSM IOMMU support
|
||||
config MSM_IOMMU
|
||||
bool "MSM IOMMU Support"
|
||||
depends on ARCH_MSM8X60 || ARCH_MSM8960
|
||||
depends on ARM
|
||||
depends on ARCH_MSM8X60 || ARCH_MSM8960 || COMPILE_TEST
|
||||
select IOMMU_API
|
||||
help
|
||||
Support for the IOMMUs found on certain Qualcomm SOCs.
|
||||
|
|
@ -91,6 +123,7 @@ config INTEL_IOMMU
|
|||
bool "Support for Intel IOMMU using DMA Remapping Devices"
|
||||
depends on PCI_MSI && ACPI && (X86 || IA64_GENERIC)
|
||||
select IOMMU_API
|
||||
select IOMMU_IOVA
|
||||
select DMAR_TABLE
|
||||
help
|
||||
DMA remapping (DMAR) devices support enables independent address
|
||||
|
|
@ -140,7 +173,8 @@ config IRQ_REMAP
|
|||
# OMAP IOMMU support
|
||||
config OMAP_IOMMU
|
||||
bool "OMAP IOMMU Support"
|
||||
depends on ARCH_OMAP2PLUS
|
||||
depends on ARM && MMU
|
||||
depends on ARCH_OMAP2PLUS || COMPILE_TEST
|
||||
select IOMMU_API
|
||||
|
||||
config OMAP_IOMMU_DEBUG
|
||||
|
|
@ -187,7 +221,7 @@ config TEGRA_IOMMU_SMMU
|
|||
|
||||
config EXYNOS_IOMMU
|
||||
bool "Exynos IOMMU Support"
|
||||
depends on ARCH_EXYNOS && ARM
|
||||
depends on ARCH_EXYNOS && ARM && MMU
|
||||
select IOMMU_API
|
||||
select ARM_DMA_USE_IOMMU
|
||||
help
|
||||
|
|
@ -216,7 +250,7 @@ config SHMOBILE_IPMMU_TLB
|
|||
config SHMOBILE_IOMMU
|
||||
bool "IOMMU for Renesas IPMMU/IPMMUI"
|
||||
default n
|
||||
depends on ARM
|
||||
depends on ARM && MMU
|
||||
depends on ARCH_SHMOBILE || COMPILE_TEST
|
||||
select IOMMU_API
|
||||
select ARM_DMA_USE_IOMMU
|
||||
|
|
@ -287,6 +321,7 @@ config IPMMU_VMSA
|
|||
depends on ARM_LPAE
|
||||
depends on ARCH_SHMOBILE || COMPILE_TEST
|
||||
select IOMMU_API
|
||||
select IOMMU_IO_PGTABLE_LPAE
|
||||
select ARM_DMA_USE_IOMMU
|
||||
help
|
||||
Support for the Renesas VMSA-compatible IPMMU Renesas found in the
|
||||
|
|
@ -304,13 +339,13 @@ config SPAPR_TCE_IOMMU
|
|||
|
||||
config ARM_SMMU
|
||||
bool "ARM Ltd. System MMU (SMMU) Support"
|
||||
depends on ARM64 || (ARM_LPAE && OF)
|
||||
depends on (ARM64 || ARM) && MMU
|
||||
select IOMMU_API
|
||||
select IOMMU_IO_PGTABLE_LPAE
|
||||
select ARM_DMA_USE_IOMMU if ARM
|
||||
help
|
||||
Support for implementations of the ARM System MMU architecture
|
||||
versions 1 and 2. The driver supports both v7l and v8l table
|
||||
formats with 4k and 64k page sizes.
|
||||
versions 1 and 2.
|
||||
|
||||
Say Y here if your SoC includes an IOMMU device implementing
|
||||
the ARM SMMU architecture.
|
||||
|
|
|
|||
|
|
@ -1,13 +1,16 @@
|
|||
obj-$(CONFIG_IOMMU_API) += iommu.o
|
||||
obj-$(CONFIG_IOMMU_API) += iommu-traces.o
|
||||
obj-$(CONFIG_IOMMU_API) += iommu-sysfs.o
|
||||
obj-$(CONFIG_IOMMU_IO_PGTABLE) += io-pgtable.o
|
||||
obj-$(CONFIG_IOMMU_IO_PGTABLE_LPAE) += io-pgtable-arm.o
|
||||
obj-$(CONFIG_IOMMU_IOVA) += iova.o
|
||||
obj-$(CONFIG_OF_IOMMU) += of_iommu.o
|
||||
obj-$(CONFIG_MSM_IOMMU) += msm_iommu.o msm_iommu_dev.o
|
||||
obj-$(CONFIG_AMD_IOMMU) += amd_iommu.o amd_iommu_init.o
|
||||
obj-$(CONFIG_AMD_IOMMU_V2) += amd_iommu_v2.o
|
||||
obj-$(CONFIG_ARM_SMMU) += arm-smmu.o
|
||||
obj-$(CONFIG_DMAR_TABLE) += dmar.o
|
||||
obj-$(CONFIG_INTEL_IOMMU) += iova.o intel-iommu.o
|
||||
obj-$(CONFIG_INTEL_IOMMU) += intel-iommu.o
|
||||
obj-$(CONFIG_IPMMU_VMSA) += ipmmu-vmsa.o
|
||||
obj-$(CONFIG_IRQ_REMAP) += intel_irq_remapping.o irq_remapping.o
|
||||
obj-$(CONFIG_OMAP_IOMMU) += omap-iommu.o
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
* Copyright (C) 2007-2010 Advanced Micro Devices, Inc.
|
||||
* Author: Joerg Roedel <joerg.roedel@amd.com>
|
||||
* Author: Joerg Roedel <jroedel@suse.de>
|
||||
* Leo Duran <leo.duran@amd.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
|
|
@ -843,10 +843,10 @@ static void build_inv_iommu_pages(struct iommu_cmd *cmd, u64 address,
|
|||
size_t size, u16 domid, int pde)
|
||||
{
|
||||
u64 pages;
|
||||
int s;
|
||||
bool s;
|
||||
|
||||
pages = iommu_num_pages(address, size, PAGE_SIZE);
|
||||
s = 0;
|
||||
s = false;
|
||||
|
||||
if (pages > 1) {
|
||||
/*
|
||||
|
|
@ -854,7 +854,7 @@ static void build_inv_iommu_pages(struct iommu_cmd *cmd, u64 address,
|
|||
* TLB entries for this domain
|
||||
*/
|
||||
address = CMD_INV_IOMMU_ALL_PAGES_ADDRESS;
|
||||
s = 1;
|
||||
s = true;
|
||||
}
|
||||
|
||||
address &= PAGE_MASK;
|
||||
|
|
@ -874,10 +874,10 @@ static void build_inv_iotlb_pages(struct iommu_cmd *cmd, u16 devid, int qdep,
|
|||
u64 address, size_t size)
|
||||
{
|
||||
u64 pages;
|
||||
int s;
|
||||
bool s;
|
||||
|
||||
pages = iommu_num_pages(address, size, PAGE_SIZE);
|
||||
s = 0;
|
||||
s = false;
|
||||
|
||||
if (pages > 1) {
|
||||
/*
|
||||
|
|
@ -885,7 +885,7 @@ static void build_inv_iotlb_pages(struct iommu_cmd *cmd, u16 devid, int qdep,
|
|||
* TLB entries for this domain
|
||||
*/
|
||||
address = CMD_INV_IOMMU_ALL_PAGES_ADDRESS;
|
||||
s = 1;
|
||||
s = true;
|
||||
}
|
||||
|
||||
address &= PAGE_MASK;
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
* Copyright (C) 2007-2010 Advanced Micro Devices, Inc.
|
||||
* Author: Joerg Roedel <joerg.roedel@amd.com>
|
||||
* Author: Joerg Roedel <jroedel@suse.de>
|
||||
* Leo Duran <leo.duran@amd.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
* Copyright (C) 2009-2010 Advanced Micro Devices, Inc.
|
||||
* Author: Joerg Roedel <joerg.roedel@amd.com>
|
||||
* Author: Joerg Roedel <jroedel@suse.de>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 as published
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
* Copyright (C) 2007-2010 Advanced Micro Devices, Inc.
|
||||
* Author: Joerg Roedel <joerg.roedel@amd.com>
|
||||
* Author: Joerg Roedel <jroedel@suse.de>
|
||||
* Leo Duran <leo.duran@amd.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
* Copyright (C) 2010-2012 Advanced Micro Devices, Inc.
|
||||
* Author: Joerg Roedel <joerg.roedel@amd.com>
|
||||
* Author: Joerg Roedel <jroedel@suse.de>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 as published
|
||||
|
|
@ -31,7 +31,7 @@
|
|||
#include "amd_iommu_proto.h"
|
||||
|
||||
MODULE_LICENSE("GPL v2");
|
||||
MODULE_AUTHOR("Joerg Roedel <joerg.roedel@amd.com>");
|
||||
MODULE_AUTHOR("Joerg Roedel <jroedel@suse.de>");
|
||||
|
||||
#define MAX_DEVICES 0x10000
|
||||
#define PRI_QUEUE_SIZE 512
|
||||
|
|
@ -151,18 +151,6 @@ static void put_device_state(struct device_state *dev_state)
|
|||
wake_up(&dev_state->wq);
|
||||
}
|
||||
|
||||
static void put_device_state_wait(struct device_state *dev_state)
|
||||
{
|
||||
DEFINE_WAIT(wait);
|
||||
|
||||
prepare_to_wait(&dev_state->wq, &wait, TASK_UNINTERRUPTIBLE);
|
||||
if (!atomic_dec_and_test(&dev_state->count))
|
||||
schedule();
|
||||
finish_wait(&dev_state->wq, &wait);
|
||||
|
||||
free_device_state(dev_state);
|
||||
}
|
||||
|
||||
/* Must be called under dev_state->lock */
|
||||
static struct pasid_state **__get_pasid_state_ptr(struct device_state *dev_state,
|
||||
int pasid, bool alloc)
|
||||
|
|
@ -278,14 +266,7 @@ static void put_pasid_state(struct pasid_state *pasid_state)
|
|||
|
||||
static void put_pasid_state_wait(struct pasid_state *pasid_state)
|
||||
{
|
||||
DEFINE_WAIT(wait);
|
||||
|
||||
prepare_to_wait(&pasid_state->wq, &wait, TASK_UNINTERRUPTIBLE);
|
||||
|
||||
if (!atomic_dec_and_test(&pasid_state->count))
|
||||
schedule();
|
||||
|
||||
finish_wait(&pasid_state->wq, &wait);
|
||||
wait_event(pasid_state->wq, !atomic_read(&pasid_state->count));
|
||||
free_pasid_state(pasid_state);
|
||||
}
|
||||
|
||||
|
|
@ -851,7 +832,13 @@ void amd_iommu_free_device(struct pci_dev *pdev)
|
|||
/* Get rid of any remaining pasid states */
|
||||
free_pasid_states(dev_state);
|
||||
|
||||
put_device_state_wait(dev_state);
|
||||
put_device_state(dev_state);
|
||||
/*
|
||||
* Wait until the last reference is dropped before freeing
|
||||
* the device state.
|
||||
*/
|
||||
wait_event(dev_state->wq, !atomic_read(&dev_state->count));
|
||||
free_device_state(dev_state);
|
||||
}
|
||||
EXPORT_SYMBOL(amd_iommu_free_device);
|
||||
|
||||
|
|
@ -921,7 +908,7 @@ static int __init amd_iommu_v2_init(void)
|
|||
{
|
||||
int ret;
|
||||
|
||||
pr_info("AMD IOMMUv2 driver by Joerg Roedel <joerg.roedel@amd.com>\n");
|
||||
pr_info("AMD IOMMUv2 driver by Joerg Roedel <jroedel@suse.de>\n");
|
||||
|
||||
if (!amd_iommu_v2_supported()) {
|
||||
pr_info("AMD IOMMUv2 functionality not available on this system\n");
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -18,23 +18,14 @@
|
|||
|
||||
#define pr_fmt(fmt) "fsl-pamu: %s: " fmt, __func__
|
||||
|
||||
#include <linux/init.h>
|
||||
#include <linux/iommu.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/types.h>
|
||||
#include <linux/mm.h>
|
||||
#include <linux/interrupt.h>
|
||||
#include <linux/device.h>
|
||||
#include <linux/of_platform.h>
|
||||
#include <linux/bootmem.h>
|
||||
#include <linux/genalloc.h>
|
||||
#include <asm/io.h>
|
||||
#include <asm/bitops.h>
|
||||
#include <asm/fsl_guts.h>
|
||||
|
||||
#include "fsl_pamu.h"
|
||||
|
||||
#include <linux/interrupt.h>
|
||||
#include <linux/genalloc.h>
|
||||
|
||||
#include <asm/mpc85xx.h>
|
||||
#include <asm/fsl_guts.h>
|
||||
|
||||
/* define indexes for each operation mapping scenario */
|
||||
#define OMI_QMAN 0x00
|
||||
#define OMI_FMAN 0x01
|
||||
|
|
@ -44,13 +35,13 @@
|
|||
#define make64(high, low) (((u64)(high) << 32) | (low))
|
||||
|
||||
struct pamu_isr_data {
|
||||
void __iomem *pamu_reg_base; /* Base address of PAMU regs*/
|
||||
void __iomem *pamu_reg_base; /* Base address of PAMU regs */
|
||||
unsigned int count; /* The number of PAMUs */
|
||||
};
|
||||
|
||||
static struct paace *ppaact;
|
||||
static struct paace *spaact;
|
||||
static struct ome *omt;
|
||||
static struct ome *omt __initdata;
|
||||
|
||||
/*
|
||||
* Table for matching compatible strings, for device tree
|
||||
|
|
@ -58,14 +49,13 @@ static struct ome *omt;
|
|||
* "fsl,qoriq-device-config-2.0" corresponds to T4 & B4
|
||||
* SOCs. For the older SOCs "fsl,qoriq-device-config-1.0"
|
||||
* string would be used.
|
||||
*/
|
||||
static const struct of_device_id guts_device_ids[] = {
|
||||
*/
|
||||
static const struct of_device_id guts_device_ids[] __initconst = {
|
||||
{ .compatible = "fsl,qoriq-device-config-1.0", },
|
||||
{ .compatible = "fsl,qoriq-device-config-2.0", },
|
||||
{}
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* Table for matching compatible strings, for device tree
|
||||
* L3 cache controller node.
|
||||
|
|
@ -73,7 +63,7 @@ static const struct of_device_id guts_device_ids[] = {
|
|||
* "fsl,b4860-l3-cache-controller" corresponds to B4 &
|
||||
* "fsl,p4080-l3-cache-controller" corresponds to other,
|
||||
* SOCs.
|
||||
*/
|
||||
*/
|
||||
static const struct of_device_id l3_device_ids[] = {
|
||||
{ .compatible = "fsl,t4240-l3-cache-controller", },
|
||||
{ .compatible = "fsl,b4860-l3-cache-controller", },
|
||||
|
|
@ -85,7 +75,7 @@ static const struct of_device_id l3_device_ids[] = {
|
|||
static u32 max_subwindow_count;
|
||||
|
||||
/* Pool for fspi allocation */
|
||||
struct gen_pool *spaace_pool;
|
||||
static struct gen_pool *spaace_pool;
|
||||
|
||||
/**
|
||||
* pamu_get_max_subwin_cnt() - Return the maximum supported
|
||||
|
|
@ -170,7 +160,7 @@ int pamu_disable_liodn(int liodn)
|
|||
static unsigned int map_addrspace_size_to_wse(phys_addr_t addrspace_size)
|
||||
{
|
||||
/* Bug if not a power of 2 */
|
||||
BUG_ON((addrspace_size & (addrspace_size - 1)));
|
||||
BUG_ON(addrspace_size & (addrspace_size - 1));
|
||||
|
||||
/* window size is 2^(WSE+1) bytes */
|
||||
return fls64(addrspace_size) - 2;
|
||||
|
|
@ -179,8 +169,8 @@ static unsigned int map_addrspace_size_to_wse(phys_addr_t addrspace_size)
|
|||
/* Derive the PAACE window count encoding for the subwindow count */
|
||||
static unsigned int map_subwindow_cnt_to_wce(u32 subwindow_cnt)
|
||||
{
|
||||
/* window count is 2^(WCE+1) bytes */
|
||||
return __ffs(subwindow_cnt) - 1;
|
||||
/* window count is 2^(WCE+1) bytes */
|
||||
return __ffs(subwindow_cnt) - 1;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -241,7 +231,7 @@ static struct paace *pamu_get_spaace(struct paace *paace, u32 wnum)
|
|||
* If no SPAACE entry is available or the allocator can not reserve the required
|
||||
* number of contiguous entries function returns ULONG_MAX indicating a failure.
|
||||
*
|
||||
*/
|
||||
*/
|
||||
static unsigned long pamu_get_fspi_and_allocate(u32 subwin_cnt)
|
||||
{
|
||||
unsigned long spaace_addr;
|
||||
|
|
@ -288,9 +278,8 @@ int pamu_update_paace_stash(int liodn, u32 subwin, u32 value)
|
|||
}
|
||||
if (subwin) {
|
||||
paace = pamu_get_spaace(paace, subwin - 1);
|
||||
if (!paace) {
|
||||
if (!paace)
|
||||
return -ENOENT;
|
||||
}
|
||||
}
|
||||
set_bf(paace->impl_attr, PAACE_IA_CID, value);
|
||||
|
||||
|
|
@ -311,14 +300,12 @@ int pamu_disable_spaace(int liodn, u32 subwin)
|
|||
}
|
||||
if (subwin) {
|
||||
paace = pamu_get_spaace(paace, subwin - 1);
|
||||
if (!paace) {
|
||||
if (!paace)
|
||||
return -ENOENT;
|
||||
}
|
||||
set_bf(paace->addr_bitfields, PAACE_AF_V,
|
||||
PAACE_V_INVALID);
|
||||
set_bf(paace->addr_bitfields, PAACE_AF_V, PAACE_V_INVALID);
|
||||
} else {
|
||||
set_bf(paace->addr_bitfields, PAACE_AF_AP,
|
||||
PAACE_AP_PERMS_DENIED);
|
||||
PAACE_AP_PERMS_DENIED);
|
||||
}
|
||||
|
||||
mb();
|
||||
|
|
@ -326,7 +313,6 @@ int pamu_disable_spaace(int liodn, u32 subwin)
|
|||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* pamu_config_paace() - Sets up PPAACE entry for specified liodn
|
||||
*
|
||||
|
|
@ -352,7 +338,8 @@ int pamu_config_ppaace(int liodn, phys_addr_t win_addr, phys_addr_t win_size,
|
|||
unsigned long fspi;
|
||||
|
||||
if ((win_size & (win_size - 1)) || win_size < PAMU_PAGE_SIZE) {
|
||||
pr_debug("window size too small or not a power of two %llx\n", win_size);
|
||||
pr_debug("window size too small or not a power of two %pa\n",
|
||||
&win_size);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
|
|
@ -362,13 +349,12 @@ int pamu_config_ppaace(int liodn, phys_addr_t win_addr, phys_addr_t win_size,
|
|||
}
|
||||
|
||||
ppaace = pamu_get_ppaace(liodn);
|
||||
if (!ppaace) {
|
||||
if (!ppaace)
|
||||
return -ENOENT;
|
||||
}
|
||||
|
||||
/* window size is 2^(WSE+1) bytes */
|
||||
set_bf(ppaace->addr_bitfields, PPAACE_AF_WSE,
|
||||
map_addrspace_size_to_wse(win_size));
|
||||
map_addrspace_size_to_wse(win_size));
|
||||
|
||||
pamu_init_ppaace(ppaace);
|
||||
|
||||
|
|
@ -442,7 +428,6 @@ int pamu_config_spaace(int liodn, u32 subwin_cnt, u32 subwin,
|
|||
{
|
||||
struct paace *paace;
|
||||
|
||||
|
||||
/* setup sub-windows */
|
||||
if (!subwin_cnt) {
|
||||
pr_debug("Invalid subwindow count\n");
|
||||
|
|
@ -510,11 +495,11 @@ int pamu_config_spaace(int liodn, u32 subwin_cnt, u32 subwin,
|
|||
}
|
||||
|
||||
/**
|
||||
* get_ome_index() - Returns the index in the operation mapping table
|
||||
* for device.
|
||||
* @*omi_index: pointer for storing the index value
|
||||
*
|
||||
*/
|
||||
* get_ome_index() - Returns the index in the operation mapping table
|
||||
* for device.
|
||||
* @*omi_index: pointer for storing the index value
|
||||
*
|
||||
*/
|
||||
void get_ome_index(u32 *omi_index, struct device *dev)
|
||||
{
|
||||
if (of_device_is_compatible(dev->of_node, "fsl,qman-portal"))
|
||||
|
|
@ -544,9 +529,10 @@ u32 get_stash_id(u32 stash_dest_hint, u32 vcpu)
|
|||
if (stash_dest_hint == PAMU_ATTR_CACHE_L3) {
|
||||
node = of_find_matching_node(NULL, l3_device_ids);
|
||||
if (node) {
|
||||
prop = of_get_property(node, "cache-stash-id", 0);
|
||||
prop = of_get_property(node, "cache-stash-id", NULL);
|
||||
if (!prop) {
|
||||
pr_debug("missing cache-stash-id at %s\n", node->full_name);
|
||||
pr_debug("missing cache-stash-id at %s\n",
|
||||
node->full_name);
|
||||
of_node_put(node);
|
||||
return ~(u32)0;
|
||||
}
|
||||
|
|
@ -570,9 +556,10 @@ found_cpu_node:
|
|||
/* find the hwnode that represents the cache */
|
||||
for (cache_level = PAMU_ATTR_CACHE_L1; (cache_level < PAMU_ATTR_CACHE_L3) && found; cache_level++) {
|
||||
if (stash_dest_hint == cache_level) {
|
||||
prop = of_get_property(node, "cache-stash-id", 0);
|
||||
prop = of_get_property(node, "cache-stash-id", NULL);
|
||||
if (!prop) {
|
||||
pr_debug("missing cache-stash-id at %s\n", node->full_name);
|
||||
pr_debug("missing cache-stash-id at %s\n",
|
||||
node->full_name);
|
||||
of_node_put(node);
|
||||
return ~(u32)0;
|
||||
}
|
||||
|
|
@ -580,10 +567,10 @@ found_cpu_node:
|
|||
return be32_to_cpup(prop);
|
||||
}
|
||||
|
||||
prop = of_get_property(node, "next-level-cache", 0);
|
||||
prop = of_get_property(node, "next-level-cache", NULL);
|
||||
if (!prop) {
|
||||
pr_debug("can't find next-level-cache at %s\n",
|
||||
node->full_name);
|
||||
node->full_name);
|
||||
of_node_put(node);
|
||||
return ~(u32)0; /* can't traverse any further */
|
||||
}
|
||||
|
|
@ -598,7 +585,7 @@ found_cpu_node:
|
|||
}
|
||||
|
||||
pr_debug("stash dest not found for %d on vcpu %d\n",
|
||||
stash_dest_hint, vcpu);
|
||||
stash_dest_hint, vcpu);
|
||||
return ~(u32)0;
|
||||
}
|
||||
|
||||
|
|
@ -612,7 +599,7 @@ found_cpu_node:
|
|||
* Memory accesses to QMAN and BMAN private memory need not be coherent, so
|
||||
* clear the PAACE entry coherency attribute for them.
|
||||
*/
|
||||
static void setup_qbman_paace(struct paace *ppaace, int paace_type)
|
||||
static void __init setup_qbman_paace(struct paace *ppaace, int paace_type)
|
||||
{
|
||||
switch (paace_type) {
|
||||
case QMAN_PAACE:
|
||||
|
|
@ -626,7 +613,7 @@ static void setup_qbman_paace(struct paace *ppaace, int paace_type)
|
|||
case QMAN_PORTAL_PAACE:
|
||||
set_bf(ppaace->impl_attr, PAACE_IA_OTM, PAACE_OTM_INDEXED);
|
||||
ppaace->op_encode.index_ot.omi = OMI_QMAN;
|
||||
/*Set DQRR and Frame stashing for the L3 cache */
|
||||
/* Set DQRR and Frame stashing for the L3 cache */
|
||||
set_bf(ppaace->impl_attr, PAACE_IA_CID, get_stash_id(PAMU_ATTR_CACHE_L3, 0));
|
||||
break;
|
||||
case BMAN_PAACE:
|
||||
|
|
@ -679,7 +666,7 @@ static void __init setup_omt(struct ome *omt)
|
|||
* Get the maximum number of PAACT table entries
|
||||
* and subwindows supported by PAMU
|
||||
*/
|
||||
static void get_pamu_cap_values(unsigned long pamu_reg_base)
|
||||
static void __init get_pamu_cap_values(unsigned long pamu_reg_base)
|
||||
{
|
||||
u32 pc_val;
|
||||
|
||||
|
|
@ -689,9 +676,9 @@ static void get_pamu_cap_values(unsigned long pamu_reg_base)
|
|||
}
|
||||
|
||||
/* Setup PAMU registers pointing to PAACT, SPAACT and OMT */
|
||||
int setup_one_pamu(unsigned long pamu_reg_base, unsigned long pamu_reg_size,
|
||||
phys_addr_t ppaact_phys, phys_addr_t spaact_phys,
|
||||
phys_addr_t omt_phys)
|
||||
static int __init setup_one_pamu(unsigned long pamu_reg_base, unsigned long pamu_reg_size,
|
||||
phys_addr_t ppaact_phys, phys_addr_t spaact_phys,
|
||||
phys_addr_t omt_phys)
|
||||
{
|
||||
u32 *pc;
|
||||
struct pamu_mmap_regs *pamu_regs;
|
||||
|
|
@ -727,7 +714,7 @@ int setup_one_pamu(unsigned long pamu_reg_base, unsigned long pamu_reg_size,
|
|||
*/
|
||||
|
||||
out_be32((u32 *)(pamu_reg_base + PAMU_PICS),
|
||||
PAMU_ACCESS_VIOLATION_ENABLE);
|
||||
PAMU_ACCESS_VIOLATION_ENABLE);
|
||||
out_be32(pc, PAMU_PC_PE | PAMU_PC_OCE | PAMU_PC_SPCC | PAMU_PC_PPCC);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -757,9 +744,9 @@ static void __init setup_liodns(void)
|
|||
ppaace->wbah = 0;
|
||||
set_bf(ppaace->addr_bitfields, PPAACE_AF_WBAL, 0);
|
||||
set_bf(ppaace->impl_attr, PAACE_IA_ATM,
|
||||
PAACE_ATM_NO_XLATE);
|
||||
PAACE_ATM_NO_XLATE);
|
||||
set_bf(ppaace->addr_bitfields, PAACE_AF_AP,
|
||||
PAACE_AP_PERMS_ALL);
|
||||
PAACE_AP_PERMS_ALL);
|
||||
if (of_device_is_compatible(node, "fsl,qman-portal"))
|
||||
setup_qbman_paace(ppaace, QMAN_PORTAL_PAACE);
|
||||
if (of_device_is_compatible(node, "fsl,qman"))
|
||||
|
|
@ -772,7 +759,7 @@ static void __init setup_liodns(void)
|
|||
}
|
||||
}
|
||||
|
||||
irqreturn_t pamu_av_isr(int irq, void *arg)
|
||||
static irqreturn_t pamu_av_isr(int irq, void *arg)
|
||||
{
|
||||
struct pamu_isr_data *data = arg;
|
||||
phys_addr_t phys;
|
||||
|
|
@ -792,14 +779,16 @@ irqreturn_t pamu_av_isr(int irq, void *arg)
|
|||
pr_emerg("POES2=%08x\n", in_be32(p + PAMU_POES2));
|
||||
pr_emerg("AVS1=%08x\n", avs1);
|
||||
pr_emerg("AVS2=%08x\n", in_be32(p + PAMU_AVS2));
|
||||
pr_emerg("AVA=%016llx\n", make64(in_be32(p + PAMU_AVAH),
|
||||
in_be32(p + PAMU_AVAL)));
|
||||
pr_emerg("AVA=%016llx\n",
|
||||
make64(in_be32(p + PAMU_AVAH),
|
||||
in_be32(p + PAMU_AVAL)));
|
||||
pr_emerg("UDAD=%08x\n", in_be32(p + PAMU_UDAD));
|
||||
pr_emerg("POEA=%016llx\n", make64(in_be32(p + PAMU_POEAH),
|
||||
in_be32(p + PAMU_POEAL)));
|
||||
pr_emerg("POEA=%016llx\n",
|
||||
make64(in_be32(p + PAMU_POEAH),
|
||||
in_be32(p + PAMU_POEAL)));
|
||||
|
||||
phys = make64(in_be32(p + PAMU_POEAH),
|
||||
in_be32(p + PAMU_POEAL));
|
||||
in_be32(p + PAMU_POEAL));
|
||||
|
||||
/* Assume that POEA points to a PAACE */
|
||||
if (phys) {
|
||||
|
|
@ -807,11 +796,12 @@ irqreturn_t pamu_av_isr(int irq, void *arg)
|
|||
|
||||
/* Only the first four words are relevant */
|
||||
for (j = 0; j < 4; j++)
|
||||
pr_emerg("PAACE[%u]=%08x\n", j, in_be32(paace + j));
|
||||
pr_emerg("PAACE[%u]=%08x\n",
|
||||
j, in_be32(paace + j));
|
||||
}
|
||||
|
||||
/* clear access violation condition */
|
||||
out_be32((p + PAMU_AVS1), avs1 & PAMU_AV_MASK);
|
||||
out_be32(p + PAMU_AVS1, avs1 & PAMU_AV_MASK);
|
||||
paace = pamu_get_ppaace(avs1 >> PAMU_AVS1_LIODN_SHIFT);
|
||||
BUG_ON(!paace);
|
||||
/* check if we got a violation for a disabled LIODN */
|
||||
|
|
@ -827,13 +817,13 @@ irqreturn_t pamu_av_isr(int irq, void *arg)
|
|||
/* Disable the LIODN */
|
||||
ret = pamu_disable_liodn(avs1 >> PAMU_AVS1_LIODN_SHIFT);
|
||||
BUG_ON(ret);
|
||||
pr_emerg("Disabling liodn %x\n", avs1 >> PAMU_AVS1_LIODN_SHIFT);
|
||||
pr_emerg("Disabling liodn %x\n",
|
||||
avs1 >> PAMU_AVS1_LIODN_SHIFT);
|
||||
}
|
||||
out_be32((p + PAMU_PICS), pics);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
return IRQ_HANDLED;
|
||||
}
|
||||
|
||||
|
|
@ -952,7 +942,7 @@ static int __init create_csd(phys_addr_t phys, size_t size, u32 csd_port_id)
|
|||
}
|
||||
|
||||
if (i == 0 || i == num_laws) {
|
||||
/* This should never happen*/
|
||||
/* This should never happen */
|
||||
ret = -ENOENT;
|
||||
goto error;
|
||||
}
|
||||
|
|
@ -998,26 +988,27 @@ error:
|
|||
static const struct {
|
||||
u32 svr;
|
||||
u32 port_id;
|
||||
} port_id_map[] = {
|
||||
{0x82100010, 0xFF000000}, /* P2040 1.0 */
|
||||
{0x82100011, 0xFF000000}, /* P2040 1.1 */
|
||||
{0x82100110, 0xFF000000}, /* P2041 1.0 */
|
||||
{0x82100111, 0xFF000000}, /* P2041 1.1 */
|
||||
{0x82110310, 0xFF000000}, /* P3041 1.0 */
|
||||
{0x82110311, 0xFF000000}, /* P3041 1.1 */
|
||||
{0x82010020, 0xFFF80000}, /* P4040 2.0 */
|
||||
{0x82000020, 0xFFF80000}, /* P4080 2.0 */
|
||||
{0x82210010, 0xFC000000}, /* P5010 1.0 */
|
||||
{0x82210020, 0xFC000000}, /* P5010 2.0 */
|
||||
{0x82200010, 0xFC000000}, /* P5020 1.0 */
|
||||
{0x82050010, 0xFF800000}, /* P5021 1.0 */
|
||||
{0x82040010, 0xFF800000}, /* P5040 1.0 */
|
||||
} port_id_map[] __initconst = {
|
||||
{(SVR_P2040 << 8) | 0x10, 0xFF000000}, /* P2040 1.0 */
|
||||
{(SVR_P2040 << 8) | 0x11, 0xFF000000}, /* P2040 1.1 */
|
||||
{(SVR_P2041 << 8) | 0x10, 0xFF000000}, /* P2041 1.0 */
|
||||
{(SVR_P2041 << 8) | 0x11, 0xFF000000}, /* P2041 1.1 */
|
||||
{(SVR_P3041 << 8) | 0x10, 0xFF000000}, /* P3041 1.0 */
|
||||
{(SVR_P3041 << 8) | 0x11, 0xFF000000}, /* P3041 1.1 */
|
||||
{(SVR_P4040 << 8) | 0x20, 0xFFF80000}, /* P4040 2.0 */
|
||||
{(SVR_P4080 << 8) | 0x20, 0xFFF80000}, /* P4080 2.0 */
|
||||
{(SVR_P5010 << 8) | 0x10, 0xFC000000}, /* P5010 1.0 */
|
||||
{(SVR_P5010 << 8) | 0x20, 0xFC000000}, /* P5010 2.0 */
|
||||
{(SVR_P5020 << 8) | 0x10, 0xFC000000}, /* P5020 1.0 */
|
||||
{(SVR_P5021 << 8) | 0x10, 0xFF800000}, /* P5021 1.0 */
|
||||
{(SVR_P5040 << 8) | 0x10, 0xFF800000}, /* P5040 1.0 */
|
||||
};
|
||||
|
||||
#define SVR_SECURITY 0x80000 /* The Security (E) bit */
|
||||
|
||||
static int __init fsl_pamu_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct device *dev = &pdev->dev;
|
||||
void __iomem *pamu_regs = NULL;
|
||||
struct ccsr_guts __iomem *guts_regs = NULL;
|
||||
u32 pamubypenr, pamu_counter;
|
||||
|
|
@ -1042,22 +1033,21 @@ static int __init fsl_pamu_probe(struct platform_device *pdev)
|
|||
* NOTE : All PAMUs share the same LIODN tables.
|
||||
*/
|
||||
|
||||
pamu_regs = of_iomap(pdev->dev.of_node, 0);
|
||||
pamu_regs = of_iomap(dev->of_node, 0);
|
||||
if (!pamu_regs) {
|
||||
dev_err(&pdev->dev, "ioremap of PAMU node failed\n");
|
||||
dev_err(dev, "ioremap of PAMU node failed\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
of_get_address(pdev->dev.of_node, 0, &size, NULL);
|
||||
of_get_address(dev->of_node, 0, &size, NULL);
|
||||
|
||||
irq = irq_of_parse_and_map(pdev->dev.of_node, 0);
|
||||
irq = irq_of_parse_and_map(dev->of_node, 0);
|
||||
if (irq == NO_IRQ) {
|
||||
dev_warn(&pdev->dev, "no interrupts listed in PAMU node\n");
|
||||
dev_warn(dev, "no interrupts listed in PAMU node\n");
|
||||
goto error;
|
||||
}
|
||||
|
||||
data = kzalloc(sizeof(struct pamu_isr_data), GFP_KERNEL);
|
||||
data = kzalloc(sizeof(*data), GFP_KERNEL);
|
||||
if (!data) {
|
||||
dev_err(&pdev->dev, "PAMU isr data memory allocation failed\n");
|
||||
ret = -ENOMEM;
|
||||
goto error;
|
||||
}
|
||||
|
|
@ -1067,15 +1057,14 @@ static int __init fsl_pamu_probe(struct platform_device *pdev)
|
|||
/* The ISR needs access to the regs, so we won't iounmap them */
|
||||
ret = request_irq(irq, pamu_av_isr, 0, "pamu", data);
|
||||
if (ret < 0) {
|
||||
dev_err(&pdev->dev, "error %i installing ISR for irq %i\n",
|
||||
ret, irq);
|
||||
dev_err(dev, "error %i installing ISR for irq %i\n", ret, irq);
|
||||
goto error;
|
||||
}
|
||||
|
||||
guts_node = of_find_matching_node(NULL, guts_device_ids);
|
||||
if (!guts_node) {
|
||||
dev_err(&pdev->dev, "could not find GUTS node %s\n",
|
||||
pdev->dev.of_node->full_name);
|
||||
dev_err(dev, "could not find GUTS node %s\n",
|
||||
dev->of_node->full_name);
|
||||
ret = -ENODEV;
|
||||
goto error;
|
||||
}
|
||||
|
|
@ -1083,7 +1072,7 @@ static int __init fsl_pamu_probe(struct platform_device *pdev)
|
|||
guts_regs = of_iomap(guts_node, 0);
|
||||
of_node_put(guts_node);
|
||||
if (!guts_regs) {
|
||||
dev_err(&pdev->dev, "ioremap of GUTS node failed\n");
|
||||
dev_err(dev, "ioremap of GUTS node failed\n");
|
||||
ret = -ENODEV;
|
||||
goto error;
|
||||
}
|
||||
|
|
@ -1103,7 +1092,7 @@ static int __init fsl_pamu_probe(struct platform_device *pdev)
|
|||
|
||||
p = alloc_pages(GFP_KERNEL | __GFP_ZERO, order);
|
||||
if (!p) {
|
||||
dev_err(&pdev->dev, "unable to allocate PAACT/SPAACT/OMT block\n");
|
||||
dev_err(dev, "unable to allocate PAACT/SPAACT/OMT block\n");
|
||||
ret = -ENOMEM;
|
||||
goto error;
|
||||
}
|
||||
|
|
@ -1113,7 +1102,7 @@ static int __init fsl_pamu_probe(struct platform_device *pdev)
|
|||
|
||||
/* Make sure the memory is naturally aligned */
|
||||
if (ppaact_phys & ((PAGE_SIZE << order) - 1)) {
|
||||
dev_err(&pdev->dev, "PAACT/OMT block is unaligned\n");
|
||||
dev_err(dev, "PAACT/OMT block is unaligned\n");
|
||||
ret = -ENOMEM;
|
||||
goto error;
|
||||
}
|
||||
|
|
@ -1121,8 +1110,7 @@ static int __init fsl_pamu_probe(struct platform_device *pdev)
|
|||
spaact = (void *)ppaact + (PAGE_SIZE << get_order(PAACT_SIZE));
|
||||
omt = (void *)spaact + (PAGE_SIZE << get_order(SPAACT_SIZE));
|
||||
|
||||
dev_dbg(&pdev->dev, "ppaact virt=%p phys=0x%llx\n", ppaact,
|
||||
(unsigned long long) ppaact_phys);
|
||||
dev_dbg(dev, "ppaact virt=%p phys=%pa\n", ppaact, &ppaact_phys);
|
||||
|
||||
/* Check to see if we need to implement the work-around on this SOC */
|
||||
|
||||
|
|
@ -1130,21 +1118,19 @@ static int __init fsl_pamu_probe(struct platform_device *pdev)
|
|||
for (i = 0; i < ARRAY_SIZE(port_id_map); i++) {
|
||||
if (port_id_map[i].svr == (mfspr(SPRN_SVR) & ~SVR_SECURITY)) {
|
||||
csd_port_id = port_id_map[i].port_id;
|
||||
dev_dbg(&pdev->dev, "found matching SVR %08x\n",
|
||||
dev_dbg(dev, "found matching SVR %08x\n",
|
||||
port_id_map[i].svr);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (csd_port_id) {
|
||||
dev_dbg(&pdev->dev, "creating coherency subdomain at address "
|
||||
"0x%llx, size %zu, port id 0x%08x", ppaact_phys,
|
||||
mem_size, csd_port_id);
|
||||
dev_dbg(dev, "creating coherency subdomain at address %pa, size %zu, port id 0x%08x",
|
||||
&ppaact_phys, mem_size, csd_port_id);
|
||||
|
||||
ret = create_csd(ppaact_phys, mem_size, csd_port_id);
|
||||
if (ret) {
|
||||
dev_err(&pdev->dev, "could not create coherence "
|
||||
"subdomain\n");
|
||||
dev_err(dev, "could not create coherence subdomain\n");
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
|
@ -1155,7 +1141,7 @@ static int __init fsl_pamu_probe(struct platform_device *pdev)
|
|||
spaace_pool = gen_pool_create(ilog2(sizeof(struct paace)), -1);
|
||||
if (!spaace_pool) {
|
||||
ret = -ENOMEM;
|
||||
dev_err(&pdev->dev, "PAMU : failed to allocate spaace gen pool\n");
|
||||
dev_err(dev, "Failed to allocate spaace gen pool\n");
|
||||
goto error;
|
||||
}
|
||||
|
||||
|
|
@ -1168,9 +1154,9 @@ static int __init fsl_pamu_probe(struct platform_device *pdev)
|
|||
for (pamu_reg_off = 0, pamu_counter = 0x80000000; pamu_reg_off < size;
|
||||
pamu_reg_off += PAMU_OFFSET, pamu_counter >>= 1) {
|
||||
|
||||
pamu_reg_base = (unsigned long) pamu_regs + pamu_reg_off;
|
||||
pamu_reg_base = (unsigned long)pamu_regs + pamu_reg_off;
|
||||
setup_one_pamu(pamu_reg_base, pamu_reg_off, ppaact_phys,
|
||||
spaact_phys, omt_phys);
|
||||
spaact_phys, omt_phys);
|
||||
/* Disable PAMU bypass for this PAMU */
|
||||
pamubypenr &= ~pamu_counter;
|
||||
}
|
||||
|
|
@ -1182,7 +1168,7 @@ static int __init fsl_pamu_probe(struct platform_device *pdev)
|
|||
|
||||
iounmap(guts_regs);
|
||||
|
||||
/* Enable DMA for the LIODNs in the device tree*/
|
||||
/* Enable DMA for the LIODNs in the device tree */
|
||||
|
||||
setup_liodns();
|
||||
|
||||
|
|
@ -1214,17 +1200,7 @@ error:
|
|||
return ret;
|
||||
}
|
||||
|
||||
static const struct of_device_id fsl_of_pamu_ids[] = {
|
||||
{
|
||||
.compatible = "fsl,p4080-pamu",
|
||||
},
|
||||
{
|
||||
.compatible = "fsl,pamu",
|
||||
},
|
||||
{},
|
||||
};
|
||||
|
||||
static struct platform_driver fsl_of_pamu_driver = {
|
||||
static struct platform_driver fsl_of_pamu_driver __initdata = {
|
||||
.driver = {
|
||||
.name = "fsl-of-pamu",
|
||||
},
|
||||
|
|
|
|||
|
|
@ -19,13 +19,15 @@
|
|||
#ifndef __FSL_PAMU_H
|
||||
#define __FSL_PAMU_H
|
||||
|
||||
#include <linux/iommu.h>
|
||||
|
||||
#include <asm/fsl_pamu_stash.h>
|
||||
|
||||
/* Bit Field macros
|
||||
* v = bit field variable; m = mask, m##_SHIFT = shift, x = value to load
|
||||
*/
|
||||
#define set_bf(v, m, x) (v = ((v) & ~(m)) | (((x) << (m##_SHIFT)) & (m)))
|
||||
#define get_bf(v, m) (((v) & (m)) >> (m##_SHIFT))
|
||||
#define set_bf(v, m, x) (v = ((v) & ~(m)) | (((x) << m##_SHIFT) & (m)))
|
||||
#define get_bf(v, m) (((v) & (m)) >> m##_SHIFT)
|
||||
|
||||
/* PAMU CCSR space */
|
||||
#define PAMU_PGC 0x00000000 /* Allows all peripheral accesses */
|
||||
|
|
@ -65,7 +67,7 @@ struct pamu_mmap_regs {
|
|||
#define PAMU_AVS1_GCV 0x2000
|
||||
#define PAMU_AVS1_PDV 0x4000
|
||||
#define PAMU_AV_MASK (PAMU_AVS1_AV | PAMU_AVS1_OTV | PAMU_AVS1_APV | PAMU_AVS1_WAV \
|
||||
| PAMU_AVS1_LAV | PAMU_AVS1_GCV | PAMU_AVS1_PDV)
|
||||
| PAMU_AVS1_LAV | PAMU_AVS1_GCV | PAMU_AVS1_PDV)
|
||||
#define PAMU_AVS1_LIODN_SHIFT 16
|
||||
#define PAMU_LAV_LIODN_NOT_IN_PPAACT 0x400
|
||||
|
||||
|
|
@ -198,8 +200,7 @@ struct pamu_mmap_regs {
|
|||
#define PAACE_ATM_NO_XLATE 0x00
|
||||
#define PAACE_ATM_WINDOW_XLATE 0x01
|
||||
#define PAACE_ATM_PAGE_XLATE 0x02
|
||||
#define PAACE_ATM_WIN_PG_XLATE \
|
||||
(PAACE_ATM_WINDOW_XLATE | PAACE_ATM_PAGE_XLATE)
|
||||
#define PAACE_ATM_WIN_PG_XLATE (PAACE_ATM_WINDOW_XLATE | PAACE_ATM_PAGE_XLATE)
|
||||
#define PAACE_OTM_NO_XLATE 0x00
|
||||
#define PAACE_OTM_IMMEDIATE 0x01
|
||||
#define PAACE_OTM_INDEXED 0x02
|
||||
|
|
@ -219,7 +220,7 @@ struct pamu_mmap_regs {
|
|||
#define PAACE_TCEF_FORMAT0_8B 0x00
|
||||
#define PAACE_TCEF_FORMAT1_RSVD 0x01
|
||||
/*
|
||||
* Hard coded value for the PAACT size to accomodate
|
||||
* Hard coded value for the PAACT size to accommodate
|
||||
* maximum LIODN value generated by u-boot.
|
||||
*/
|
||||
#define PAACE_NUMBER_ENTRIES 0x500
|
||||
|
|
@ -332,7 +333,7 @@ struct paace {
|
|||
#define NUM_MOE 128
|
||||
struct ome {
|
||||
u8 moe[NUM_MOE];
|
||||
} __attribute__((packed));
|
||||
} __packed;
|
||||
|
||||
#define PAACT_SIZE (sizeof(struct paace) * PAACE_NUMBER_ENTRIES)
|
||||
#define SPAACT_SIZE (sizeof(struct paace) * SPAACE_NUMBER_ENTRIES)
|
||||
|
|
|
|||
|
|
@ -19,26 +19,10 @@
|
|||
|
||||
#define pr_fmt(fmt) "fsl-pamu-domain: %s: " fmt, __func__
|
||||
|
||||
#include <linux/init.h>
|
||||
#include <linux/iommu.h>
|
||||
#include <linux/notifier.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/types.h>
|
||||
#include <linux/mm.h>
|
||||
#include <linux/interrupt.h>
|
||||
#include <linux/device.h>
|
||||
#include <linux/of_platform.h>
|
||||
#include <linux/bootmem.h>
|
||||
#include <linux/err.h>
|
||||
#include <asm/io.h>
|
||||
#include <asm/bitops.h>
|
||||
|
||||
#include <asm/pci-bridge.h>
|
||||
#include <sysdev/fsl_pci.h>
|
||||
|
||||
#include "fsl_pamu_domain.h"
|
||||
|
||||
#include <sysdev/fsl_pci.h>
|
||||
|
||||
/*
|
||||
* Global spinlock that needs to be held while
|
||||
* configuring PAMU.
|
||||
|
|
@ -51,23 +35,21 @@ static DEFINE_SPINLOCK(device_domain_lock);
|
|||
|
||||
static int __init iommu_init_mempool(void)
|
||||
{
|
||||
|
||||
fsl_pamu_domain_cache = kmem_cache_create("fsl_pamu_domain",
|
||||
sizeof(struct fsl_dma_domain),
|
||||
0,
|
||||
SLAB_HWCACHE_ALIGN,
|
||||
|
||||
NULL);
|
||||
sizeof(struct fsl_dma_domain),
|
||||
0,
|
||||
SLAB_HWCACHE_ALIGN,
|
||||
NULL);
|
||||
if (!fsl_pamu_domain_cache) {
|
||||
pr_debug("Couldn't create fsl iommu_domain cache\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
iommu_devinfo_cache = kmem_cache_create("iommu_devinfo",
|
||||
sizeof(struct device_domain_info),
|
||||
0,
|
||||
SLAB_HWCACHE_ALIGN,
|
||||
NULL);
|
||||
sizeof(struct device_domain_info),
|
||||
0,
|
||||
SLAB_HWCACHE_ALIGN,
|
||||
NULL);
|
||||
if (!iommu_devinfo_cache) {
|
||||
pr_debug("Couldn't create devinfo cache\n");
|
||||
kmem_cache_destroy(fsl_pamu_domain_cache);
|
||||
|
|
@ -80,8 +62,7 @@ static int __init iommu_init_mempool(void)
|
|||
static phys_addr_t get_phys_addr(struct fsl_dma_domain *dma_domain, dma_addr_t iova)
|
||||
{
|
||||
u32 win_cnt = dma_domain->win_cnt;
|
||||
struct dma_window *win_ptr =
|
||||
&dma_domain->win_arr[0];
|
||||
struct dma_window *win_ptr = &dma_domain->win_arr[0];
|
||||
struct iommu_domain_geometry *geom;
|
||||
|
||||
geom = &dma_domain->iommu_domain->geometry;
|
||||
|
|
@ -103,22 +84,20 @@ static phys_addr_t get_phys_addr(struct fsl_dma_domain *dma_domain, dma_addr_t i
|
|||
}
|
||||
|
||||
if (win_ptr->valid)
|
||||
return (win_ptr->paddr + (iova & (win_ptr->size - 1)));
|
||||
return win_ptr->paddr + (iova & (win_ptr->size - 1));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int map_subwins(int liodn, struct fsl_dma_domain *dma_domain)
|
||||
{
|
||||
struct dma_window *sub_win_ptr =
|
||||
&dma_domain->win_arr[0];
|
||||
struct dma_window *sub_win_ptr = &dma_domain->win_arr[0];
|
||||
int i, ret;
|
||||
unsigned long rpn, flags;
|
||||
|
||||
for (i = 0; i < dma_domain->win_cnt; i++) {
|
||||
if (sub_win_ptr[i].valid) {
|
||||
rpn = sub_win_ptr[i].paddr >>
|
||||
PAMU_PAGE_SHIFT;
|
||||
rpn = sub_win_ptr[i].paddr >> PAMU_PAGE_SHIFT;
|
||||
spin_lock_irqsave(&iommu_lock, flags);
|
||||
ret = pamu_config_spaace(liodn, dma_domain->win_cnt, i,
|
||||
sub_win_ptr[i].size,
|
||||
|
|
@ -130,7 +109,7 @@ static int map_subwins(int liodn, struct fsl_dma_domain *dma_domain)
|
|||
sub_win_ptr[i].prot);
|
||||
spin_unlock_irqrestore(&iommu_lock, flags);
|
||||
if (ret) {
|
||||
pr_debug("PAMU SPAACE configuration failed for liodn %d\n",
|
||||
pr_debug("SPAACE configuration failed for liodn %d\n",
|
||||
liodn);
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -156,8 +135,7 @@ static int map_win(int liodn, struct fsl_dma_domain *dma_domain)
|
|||
0, wnd->prot);
|
||||
spin_unlock_irqrestore(&iommu_lock, flags);
|
||||
if (ret)
|
||||
pr_debug("PAMU PAACE configuration failed for liodn %d\n",
|
||||
liodn);
|
||||
pr_debug("PAACE configuration failed for liodn %d\n", liodn);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -169,7 +147,6 @@ static int map_liodn(int liodn, struct fsl_dma_domain *dma_domain)
|
|||
return map_subwins(liodn, dma_domain);
|
||||
else
|
||||
return map_win(liodn, dma_domain);
|
||||
|
||||
}
|
||||
|
||||
/* Update window/subwindow mapping for the LIODN */
|
||||
|
|
@ -190,7 +167,8 @@ static int update_liodn(int liodn, struct fsl_dma_domain *dma_domain, u32 wnd_nr
|
|||
(wnd_nr > 0) ? 1 : 0,
|
||||
wnd->prot);
|
||||
if (ret)
|
||||
pr_debug("Subwindow reconfiguration failed for liodn %d\n", liodn);
|
||||
pr_debug("Subwindow reconfiguration failed for liodn %d\n",
|
||||
liodn);
|
||||
} else {
|
||||
phys_addr_t wnd_addr;
|
||||
|
||||
|
|
@ -200,10 +178,11 @@ static int update_liodn(int liodn, struct fsl_dma_domain *dma_domain, u32 wnd_nr
|
|||
wnd->size,
|
||||
~(u32)0,
|
||||
wnd->paddr >> PAMU_PAGE_SHIFT,
|
||||
dma_domain->snoop_id, dma_domain->stash_id,
|
||||
0, wnd->prot);
|
||||
dma_domain->snoop_id, dma_domain->stash_id,
|
||||
0, wnd->prot);
|
||||
if (ret)
|
||||
pr_debug("Window reconfiguration failed for liodn %d\n", liodn);
|
||||
pr_debug("Window reconfiguration failed for liodn %d\n",
|
||||
liodn);
|
||||
}
|
||||
|
||||
spin_unlock_irqrestore(&iommu_lock, flags);
|
||||
|
|
@ -212,14 +191,15 @@ static int update_liodn(int liodn, struct fsl_dma_domain *dma_domain, u32 wnd_nr
|
|||
}
|
||||
|
||||
static int update_liodn_stash(int liodn, struct fsl_dma_domain *dma_domain,
|
||||
u32 val)
|
||||
u32 val)
|
||||
{
|
||||
int ret = 0, i;
|
||||
unsigned long flags;
|
||||
|
||||
spin_lock_irqsave(&iommu_lock, flags);
|
||||
if (!dma_domain->win_arr) {
|
||||
pr_debug("Windows not configured, stash destination update failed for liodn %d\n", liodn);
|
||||
pr_debug("Windows not configured, stash destination update failed for liodn %d\n",
|
||||
liodn);
|
||||
spin_unlock_irqrestore(&iommu_lock, flags);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
|
@ -227,7 +207,8 @@ static int update_liodn_stash(int liodn, struct fsl_dma_domain *dma_domain,
|
|||
for (i = 0; i < dma_domain->win_cnt; i++) {
|
||||
ret = pamu_update_paace_stash(liodn, i, val);
|
||||
if (ret) {
|
||||
pr_debug("Failed to update SPAACE %d field for liodn %d\n ", i, liodn);
|
||||
pr_debug("Failed to update SPAACE %d field for liodn %d\n ",
|
||||
i, liodn);
|
||||
spin_unlock_irqrestore(&iommu_lock, flags);
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -240,9 +221,9 @@ static int update_liodn_stash(int liodn, struct fsl_dma_domain *dma_domain,
|
|||
|
||||
/* Set the geometry parameters for a LIODN */
|
||||
static int pamu_set_liodn(int liodn, struct device *dev,
|
||||
struct fsl_dma_domain *dma_domain,
|
||||
struct iommu_domain_geometry *geom_attr,
|
||||
u32 win_cnt)
|
||||
struct fsl_dma_domain *dma_domain,
|
||||
struct iommu_domain_geometry *geom_attr,
|
||||
u32 win_cnt)
|
||||
{
|
||||
phys_addr_t window_addr, window_size;
|
||||
phys_addr_t subwin_size;
|
||||
|
|
@ -268,7 +249,8 @@ static int pamu_set_liodn(int liodn, struct device *dev,
|
|||
dma_domain->stash_id, win_cnt, 0);
|
||||
spin_unlock_irqrestore(&iommu_lock, flags);
|
||||
if (ret) {
|
||||
pr_debug("PAMU PAACE configuration failed for liodn %d, win_cnt =%d\n", liodn, win_cnt);
|
||||
pr_debug("PAACE configuration failed for liodn %d, win_cnt =%d\n",
|
||||
liodn, win_cnt);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
@ -285,7 +267,8 @@ static int pamu_set_liodn(int liodn, struct device *dev,
|
|||
0, 0);
|
||||
spin_unlock_irqrestore(&iommu_lock, flags);
|
||||
if (ret) {
|
||||
pr_debug("PAMU SPAACE configuration failed for liodn %d\n", liodn);
|
||||
pr_debug("SPAACE configuration failed for liodn %d\n",
|
||||
liodn);
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
|
@ -301,13 +284,13 @@ static int check_size(u64 size, dma_addr_t iova)
|
|||
* to PAMU page size.
|
||||
*/
|
||||
if ((size & (size - 1)) || size < PAMU_PAGE_SIZE) {
|
||||
pr_debug("%s: size too small or not a power of two\n", __func__);
|
||||
pr_debug("Size too small or not a power of two\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* iova must be page size aligned*/
|
||||
/* iova must be page size aligned */
|
||||
if (iova & (size - 1)) {
|
||||
pr_debug("%s: address is not aligned with window size\n", __func__);
|
||||
pr_debug("Address is not aligned with window size\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
|
|
@ -396,16 +379,15 @@ static void attach_device(struct fsl_dma_domain *dma_domain, int liodn, struct d
|
|||
if (!dev->archdata.iommu_domain)
|
||||
dev->archdata.iommu_domain = info;
|
||||
spin_unlock_irqrestore(&device_domain_lock, flags);
|
||||
|
||||
}
|
||||
|
||||
static phys_addr_t fsl_pamu_iova_to_phys(struct iommu_domain *domain,
|
||||
dma_addr_t iova)
|
||||
dma_addr_t iova)
|
||||
{
|
||||
struct fsl_dma_domain *dma_domain = domain->priv;
|
||||
|
||||
if ((iova < domain->geometry.aperture_start) ||
|
||||
iova > (domain->geometry.aperture_end))
|
||||
if (iova < domain->geometry.aperture_start ||
|
||||
iova > domain->geometry.aperture_end)
|
||||
return 0;
|
||||
|
||||
return get_phys_addr(dma_domain, iova);
|
||||
|
|
@ -460,7 +442,7 @@ static int pamu_set_domain_geometry(struct fsl_dma_domain *dma_domain,
|
|||
|
||||
list_for_each_entry(info, &dma_domain->devices, link) {
|
||||
ret = pamu_set_liodn(info->liodn, info->dev, dma_domain,
|
||||
geom_attr, win_cnt);
|
||||
geom_attr, win_cnt);
|
||||
if (ret)
|
||||
break;
|
||||
}
|
||||
|
|
@ -543,7 +525,6 @@ static void fsl_pamu_window_disable(struct iommu_domain *domain, u32 wnd_nr)
|
|||
}
|
||||
|
||||
spin_unlock_irqrestore(&dma_domain->domain_lock, flags);
|
||||
|
||||
}
|
||||
|
||||
static int fsl_pamu_window_enable(struct iommu_domain *domain, u32 wnd_nr,
|
||||
|
|
@ -576,7 +557,7 @@ static int fsl_pamu_window_enable(struct iommu_domain *domain, u32 wnd_nr,
|
|||
|
||||
win_size = dma_domain->geom_size >> ilog2(dma_domain->win_cnt);
|
||||
if (size > win_size) {
|
||||
pr_debug("Invalid window size \n");
|
||||
pr_debug("Invalid window size\n");
|
||||
spin_unlock_irqrestore(&dma_domain->domain_lock, flags);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
|
@ -622,8 +603,8 @@ static int fsl_pamu_window_enable(struct iommu_domain *domain, u32 wnd_nr,
|
|||
* and window mappings.
|
||||
*/
|
||||
static int handle_attach_device(struct fsl_dma_domain *dma_domain,
|
||||
struct device *dev, const u32 *liodn,
|
||||
int num)
|
||||
struct device *dev, const u32 *liodn,
|
||||
int num)
|
||||
{
|
||||
unsigned long flags;
|
||||
struct iommu_domain *domain = dma_domain->iommu_domain;
|
||||
|
|
@ -632,11 +613,10 @@ static int handle_attach_device(struct fsl_dma_domain *dma_domain,
|
|||
|
||||
spin_lock_irqsave(&dma_domain->domain_lock, flags);
|
||||
for (i = 0; i < num; i++) {
|
||||
|
||||
/* Ensure that LIODN value is valid */
|
||||
if (liodn[i] >= PAACE_NUMBER_ENTRIES) {
|
||||
pr_debug("Invalid liodn %d, attach device failed for %s\n",
|
||||
liodn[i], dev->of_node->full_name);
|
||||
liodn[i], dev->of_node->full_name);
|
||||
ret = -EINVAL;
|
||||
break;
|
||||
}
|
||||
|
|
@ -649,9 +629,9 @@ static int handle_attach_device(struct fsl_dma_domain *dma_domain,
|
|||
*/
|
||||
if (dma_domain->win_arr) {
|
||||
u32 win_cnt = dma_domain->win_cnt > 1 ? dma_domain->win_cnt : 0;
|
||||
|
||||
ret = pamu_set_liodn(liodn[i], dev, dma_domain,
|
||||
&domain->geometry,
|
||||
win_cnt);
|
||||
&domain->geometry, win_cnt);
|
||||
if (ret)
|
||||
break;
|
||||
if (dma_domain->mapped) {
|
||||
|
|
@ -698,19 +678,18 @@ static int fsl_pamu_attach_device(struct iommu_domain *domain,
|
|||
liodn = of_get_property(dev->of_node, "fsl,liodn", &len);
|
||||
if (liodn) {
|
||||
liodn_cnt = len / sizeof(u32);
|
||||
ret = handle_attach_device(dma_domain, dev,
|
||||
liodn, liodn_cnt);
|
||||
ret = handle_attach_device(dma_domain, dev, liodn, liodn_cnt);
|
||||
} else {
|
||||
pr_debug("missing fsl,liodn property at %s\n",
|
||||
dev->of_node->full_name);
|
||||
ret = -EINVAL;
|
||||
dev->of_node->full_name);
|
||||
ret = -EINVAL;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void fsl_pamu_detach_device(struct iommu_domain *domain,
|
||||
struct device *dev)
|
||||
struct device *dev)
|
||||
{
|
||||
struct fsl_dma_domain *dma_domain = domain->priv;
|
||||
const u32 *prop;
|
||||
|
|
@ -738,7 +717,7 @@ static void fsl_pamu_detach_device(struct iommu_domain *domain,
|
|||
detach_device(dev, dma_domain);
|
||||
else
|
||||
pr_debug("missing fsl,liodn property at %s\n",
|
||||
dev->of_node->full_name);
|
||||
dev->of_node->full_name);
|
||||
}
|
||||
|
||||
static int configure_domain_geometry(struct iommu_domain *domain, void *data)
|
||||
|
|
@ -754,10 +733,10 @@ static int configure_domain_geometry(struct iommu_domain *domain, void *data)
|
|||
* DMA outside of the geometry.
|
||||
*/
|
||||
if (check_size(geom_size, geom_attr->aperture_start) ||
|
||||
!geom_attr->force_aperture) {
|
||||
pr_debug("Invalid PAMU geometry attributes\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
!geom_attr->force_aperture) {
|
||||
pr_debug("Invalid PAMU geometry attributes\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
spin_lock_irqsave(&dma_domain->domain_lock, flags);
|
||||
if (dma_domain->enabled) {
|
||||
|
|
@ -786,7 +765,7 @@ static int configure_domain_stash(struct fsl_dma_domain *dma_domain, void *data)
|
|||
spin_lock_irqsave(&dma_domain->domain_lock, flags);
|
||||
|
||||
memcpy(&dma_domain->dma_stash, stash_attr,
|
||||
sizeof(struct pamu_stash_attribute));
|
||||
sizeof(struct pamu_stash_attribute));
|
||||
|
||||
dma_domain->stash_id = get_stash_id(stash_attr->cache,
|
||||
stash_attr->cpu);
|
||||
|
|
@ -803,7 +782,7 @@ static int configure_domain_stash(struct fsl_dma_domain *dma_domain, void *data)
|
|||
return ret;
|
||||
}
|
||||
|
||||
/* Configure domain dma state i.e. enable/disable DMA*/
|
||||
/* Configure domain dma state i.e. enable/disable DMA */
|
||||
static int configure_domain_dma_state(struct fsl_dma_domain *dma_domain, bool enable)
|
||||
{
|
||||
struct device_domain_info *info;
|
||||
|
|
@ -819,8 +798,7 @@ static int configure_domain_dma_state(struct fsl_dma_domain *dma_domain, bool en
|
|||
}
|
||||
|
||||
dma_domain->enabled = enable;
|
||||
list_for_each_entry(info, &dma_domain->devices,
|
||||
link) {
|
||||
list_for_each_entry(info, &dma_domain->devices, link) {
|
||||
ret = (enable) ? pamu_enable_liodn(info->liodn) :
|
||||
pamu_disable_liodn(info->liodn);
|
||||
if (ret)
|
||||
|
|
@ -833,12 +811,11 @@ static int configure_domain_dma_state(struct fsl_dma_domain *dma_domain, bool en
|
|||
}
|
||||
|
||||
static int fsl_pamu_set_domain_attr(struct iommu_domain *domain,
|
||||
enum iommu_attr attr_type, void *data)
|
||||
enum iommu_attr attr_type, void *data)
|
||||
{
|
||||
struct fsl_dma_domain *dma_domain = domain->priv;
|
||||
int ret = 0;
|
||||
|
||||
|
||||
switch (attr_type) {
|
||||
case DOMAIN_ATTR_GEOMETRY:
|
||||
ret = configure_domain_geometry(domain, data);
|
||||
|
|
@ -853,22 +830,21 @@ static int fsl_pamu_set_domain_attr(struct iommu_domain *domain,
|
|||
pr_debug("Unsupported attribute type\n");
|
||||
ret = -EINVAL;
|
||||
break;
|
||||
};
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int fsl_pamu_get_domain_attr(struct iommu_domain *domain,
|
||||
enum iommu_attr attr_type, void *data)
|
||||
enum iommu_attr attr_type, void *data)
|
||||
{
|
||||
struct fsl_dma_domain *dma_domain = domain->priv;
|
||||
int ret = 0;
|
||||
|
||||
|
||||
switch (attr_type) {
|
||||
case DOMAIN_ATTR_FSL_PAMU_STASH:
|
||||
memcpy((struct pamu_stash_attribute *) data, &dma_domain->dma_stash,
|
||||
sizeof(struct pamu_stash_attribute));
|
||||
memcpy(data, &dma_domain->dma_stash,
|
||||
sizeof(struct pamu_stash_attribute));
|
||||
break;
|
||||
case DOMAIN_ATTR_FSL_PAMU_ENABLE:
|
||||
*(int *)data = dma_domain->enabled;
|
||||
|
|
@ -880,7 +856,7 @@ static int fsl_pamu_get_domain_attr(struct iommu_domain *domain,
|
|||
pr_debug("Unsupported attribute type\n");
|
||||
ret = -EINVAL;
|
||||
break;
|
||||
};
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -903,11 +879,8 @@ static bool check_pci_ctl_endpt_part(struct pci_controller *pci_ctl)
|
|||
/* Check the PCI controller version number by readding BRR1 register */
|
||||
version = in_be32(pci_ctl->cfg_addr + (PCI_FSL_BRR1 >> 2));
|
||||
version &= PCI_FSL_BRR1_VER;
|
||||
/* If PCI controller version is >= 0x204 we can partition endpoints*/
|
||||
if (version >= 0x204)
|
||||
return 1;
|
||||
|
||||
return 0;
|
||||
/* If PCI controller version is >= 0x204 we can partition endpoints */
|
||||
return version >= 0x204;
|
||||
}
|
||||
|
||||
/* Get iommu group information from peer devices or devices on the parent bus */
|
||||
|
|
@ -968,8 +941,9 @@ static struct iommu_group *get_pci_device_group(struct pci_dev *pdev)
|
|||
if (pci_ctl->parent->iommu_group) {
|
||||
group = get_device_iommu_group(pci_ctl->parent);
|
||||
iommu_group_remove_device(pci_ctl->parent);
|
||||
} else
|
||||
} else {
|
||||
group = get_shared_pci_device_group(pdev);
|
||||
}
|
||||
}
|
||||
|
||||
if (!group)
|
||||
|
|
@ -1055,11 +1029,12 @@ static int fsl_pamu_set_windows(struct iommu_domain *domain, u32 w_count)
|
|||
}
|
||||
|
||||
ret = pamu_set_domain_geometry(dma_domain, &domain->geometry,
|
||||
((w_count > 1) ? w_count : 0));
|
||||
w_count > 1 ? w_count : 0);
|
||||
if (!ret) {
|
||||
kfree(dma_domain->win_arr);
|
||||
dma_domain->win_arr = kzalloc(sizeof(struct dma_window) *
|
||||
w_count, GFP_ATOMIC);
|
||||
dma_domain->win_arr = kcalloc(w_count,
|
||||
sizeof(*dma_domain->win_arr),
|
||||
GFP_ATOMIC);
|
||||
if (!dma_domain->win_arr) {
|
||||
spin_unlock_irqrestore(&dma_domain->domain_lock, flags);
|
||||
return -ENOMEM;
|
||||
|
|
@ -1095,7 +1070,7 @@ static const struct iommu_ops fsl_pamu_ops = {
|
|||
.remove_device = fsl_pamu_remove_device,
|
||||
};
|
||||
|
||||
int pamu_domain_init(void)
|
||||
int __init pamu_domain_init(void)
|
||||
{
|
||||
int ret = 0;
|
||||
|
||||
|
|
|
|||
|
|
@ -71,6 +71,9 @@
|
|||
__DOMAIN_MAX_PFN(gaw), (unsigned long)-1))
|
||||
#define DOMAIN_MAX_ADDR(gaw) (((uint64_t)__DOMAIN_MAX_PFN(gaw)) << VTD_PAGE_SHIFT)
|
||||
|
||||
/* IO virtual address start page frame number */
|
||||
#define IOVA_START_PFN (1)
|
||||
|
||||
#define IOVA_PFN(addr) ((addr) >> PAGE_SHIFT)
|
||||
#define DMA_32BIT_PFN IOVA_PFN(DMA_BIT_MASK(32))
|
||||
#define DMA_64BIT_PFN IOVA_PFN(DMA_BIT_MASK(64))
|
||||
|
|
@ -485,7 +488,6 @@ __setup("intel_iommu=", intel_iommu_setup);
|
|||
|
||||
static struct kmem_cache *iommu_domain_cache;
|
||||
static struct kmem_cache *iommu_devinfo_cache;
|
||||
static struct kmem_cache *iommu_iova_cache;
|
||||
|
||||
static inline void *alloc_pgtable_page(int node)
|
||||
{
|
||||
|
|
@ -523,16 +525,6 @@ static inline void free_devinfo_mem(void *vaddr)
|
|||
kmem_cache_free(iommu_devinfo_cache, vaddr);
|
||||
}
|
||||
|
||||
struct iova *alloc_iova_mem(void)
|
||||
{
|
||||
return kmem_cache_alloc(iommu_iova_cache, GFP_ATOMIC);
|
||||
}
|
||||
|
||||
void free_iova_mem(struct iova *iova)
|
||||
{
|
||||
kmem_cache_free(iommu_iova_cache, iova);
|
||||
}
|
||||
|
||||
static inline int domain_type_is_vm(struct dmar_domain *domain)
|
||||
{
|
||||
return domain->flags & DOMAIN_FLAG_VIRTUAL_MACHINE;
|
||||
|
|
@ -1643,7 +1635,8 @@ static int dmar_init_reserved_ranges(void)
|
|||
struct iova *iova;
|
||||
int i;
|
||||
|
||||
init_iova_domain(&reserved_iova_list, DMA_32BIT_PFN);
|
||||
init_iova_domain(&reserved_iova_list, VTD_PAGE_SIZE, IOVA_START_PFN,
|
||||
DMA_32BIT_PFN);
|
||||
|
||||
lockdep_set_class(&reserved_iova_list.iova_rbtree_lock,
|
||||
&reserved_rbtree_key);
|
||||
|
|
@ -1701,7 +1694,8 @@ static int domain_init(struct dmar_domain *domain, int guest_width)
|
|||
int adjust_width, agaw;
|
||||
unsigned long sagaw;
|
||||
|
||||
init_iova_domain(&domain->iovad, DMA_32BIT_PFN);
|
||||
init_iova_domain(&domain->iovad, VTD_PAGE_SIZE, IOVA_START_PFN,
|
||||
DMA_32BIT_PFN);
|
||||
domain_reserve_special_ranges(domain);
|
||||
|
||||
/* calculate AGAW */
|
||||
|
|
@ -3427,23 +3421,6 @@ static inline int iommu_devinfo_cache_init(void)
|
|||
return ret;
|
||||
}
|
||||
|
||||
static inline int iommu_iova_cache_init(void)
|
||||
{
|
||||
int ret = 0;
|
||||
|
||||
iommu_iova_cache = kmem_cache_create("iommu_iova",
|
||||
sizeof(struct iova),
|
||||
0,
|
||||
SLAB_HWCACHE_ALIGN,
|
||||
NULL);
|
||||
if (!iommu_iova_cache) {
|
||||
printk(KERN_ERR "Couldn't create iova cache\n");
|
||||
ret = -ENOMEM;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int __init iommu_init_mempool(void)
|
||||
{
|
||||
int ret;
|
||||
|
|
@ -3461,7 +3438,7 @@ static int __init iommu_init_mempool(void)
|
|||
|
||||
kmem_cache_destroy(iommu_domain_cache);
|
||||
domain_error:
|
||||
kmem_cache_destroy(iommu_iova_cache);
|
||||
iommu_iova_cache_destroy();
|
||||
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
|
@ -3470,8 +3447,7 @@ static void __init iommu_exit_mempool(void)
|
|||
{
|
||||
kmem_cache_destroy(iommu_devinfo_cache);
|
||||
kmem_cache_destroy(iommu_domain_cache);
|
||||
kmem_cache_destroy(iommu_iova_cache);
|
||||
|
||||
iommu_iova_cache_destroy();
|
||||
}
|
||||
|
||||
static void quirk_ioat_snb_local_iommu(struct pci_dev *pdev)
|
||||
|
|
@ -4342,7 +4318,8 @@ static int md_domain_init(struct dmar_domain *domain, int guest_width)
|
|||
{
|
||||
int adjust_width;
|
||||
|
||||
init_iova_domain(&domain->iovad, DMA_32BIT_PFN);
|
||||
init_iova_domain(&domain->iovad, VTD_PAGE_SIZE, IOVA_START_PFN,
|
||||
DMA_32BIT_PFN);
|
||||
domain_reserve_special_ranges(domain);
|
||||
|
||||
/* calculate AGAW */
|
||||
|
|
|
|||
986
drivers/iommu/io-pgtable-arm.c
Normal file
986
drivers/iommu/io-pgtable-arm.c
Normal file
|
|
@ -0,0 +1,986 @@
|
|||
/*
|
||||
* CPU-agnostic ARM page table allocator.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope that 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/>.
|
||||
*
|
||||
* Copyright (C) 2014 ARM Limited
|
||||
*
|
||||
* Author: Will Deacon <will.deacon@arm.com>
|
||||
*/
|
||||
|
||||
#define pr_fmt(fmt) "arm-lpae io-pgtable: " fmt
|
||||
|
||||
#include <linux/iommu.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/sizes.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/types.h>
|
||||
|
||||
#include "io-pgtable.h"
|
||||
|
||||
#define ARM_LPAE_MAX_ADDR_BITS 48
|
||||
#define ARM_LPAE_S2_MAX_CONCAT_PAGES 16
|
||||
#define ARM_LPAE_MAX_LEVELS 4
|
||||
|
||||
/* Struct accessors */
|
||||
#define io_pgtable_to_data(x) \
|
||||
container_of((x), struct arm_lpae_io_pgtable, iop)
|
||||
|
||||
#define io_pgtable_ops_to_pgtable(x) \
|
||||
container_of((x), struct io_pgtable, ops)
|
||||
|
||||
#define io_pgtable_ops_to_data(x) \
|
||||
io_pgtable_to_data(io_pgtable_ops_to_pgtable(x))
|
||||
|
||||
/*
|
||||
* For consistency with the architecture, we always consider
|
||||
* ARM_LPAE_MAX_LEVELS levels, with the walk starting at level n >=0
|
||||
*/
|
||||
#define ARM_LPAE_START_LVL(d) (ARM_LPAE_MAX_LEVELS - (d)->levels)
|
||||
|
||||
/*
|
||||
* Calculate the right shift amount to get to the portion describing level l
|
||||
* in a virtual address mapped by the pagetable in d.
|
||||
*/
|
||||
#define ARM_LPAE_LVL_SHIFT(l,d) \
|
||||
((((d)->levels - ((l) - ARM_LPAE_START_LVL(d) + 1)) \
|
||||
* (d)->bits_per_level) + (d)->pg_shift)
|
||||
|
||||
#define ARM_LPAE_PAGES_PER_PGD(d) ((d)->pgd_size >> (d)->pg_shift)
|
||||
|
||||
/*
|
||||
* Calculate the index at level l used to map virtual address a using the
|
||||
* pagetable in d.
|
||||
*/
|
||||
#define ARM_LPAE_PGD_IDX(l,d) \
|
||||
((l) == ARM_LPAE_START_LVL(d) ? ilog2(ARM_LPAE_PAGES_PER_PGD(d)) : 0)
|
||||
|
||||
#define ARM_LPAE_LVL_IDX(a,l,d) \
|
||||
(((a) >> ARM_LPAE_LVL_SHIFT(l,d)) & \
|
||||
((1 << ((d)->bits_per_level + ARM_LPAE_PGD_IDX(l,d))) - 1))
|
||||
|
||||
/* Calculate the block/page mapping size at level l for pagetable in d. */
|
||||
#define ARM_LPAE_BLOCK_SIZE(l,d) \
|
||||
(1 << (ilog2(sizeof(arm_lpae_iopte)) + \
|
||||
((ARM_LPAE_MAX_LEVELS - (l)) * (d)->bits_per_level)))
|
||||
|
||||
/* Page table bits */
|
||||
#define ARM_LPAE_PTE_TYPE_SHIFT 0
|
||||
#define ARM_LPAE_PTE_TYPE_MASK 0x3
|
||||
|
||||
#define ARM_LPAE_PTE_TYPE_BLOCK 1
|
||||
#define ARM_LPAE_PTE_TYPE_TABLE 3
|
||||
#define ARM_LPAE_PTE_TYPE_PAGE 3
|
||||
|
||||
#define ARM_LPAE_PTE_NSTABLE (((arm_lpae_iopte)1) << 63)
|
||||
#define ARM_LPAE_PTE_XN (((arm_lpae_iopte)3) << 53)
|
||||
#define ARM_LPAE_PTE_AF (((arm_lpae_iopte)1) << 10)
|
||||
#define ARM_LPAE_PTE_SH_NS (((arm_lpae_iopte)0) << 8)
|
||||
#define ARM_LPAE_PTE_SH_OS (((arm_lpae_iopte)2) << 8)
|
||||
#define ARM_LPAE_PTE_SH_IS (((arm_lpae_iopte)3) << 8)
|
||||
#define ARM_LPAE_PTE_NS (((arm_lpae_iopte)1) << 5)
|
||||
#define ARM_LPAE_PTE_VALID (((arm_lpae_iopte)1) << 0)
|
||||
|
||||
#define ARM_LPAE_PTE_ATTR_LO_MASK (((arm_lpae_iopte)0x3ff) << 2)
|
||||
/* Ignore the contiguous bit for block splitting */
|
||||
#define ARM_LPAE_PTE_ATTR_HI_MASK (((arm_lpae_iopte)6) << 52)
|
||||
#define ARM_LPAE_PTE_ATTR_MASK (ARM_LPAE_PTE_ATTR_LO_MASK | \
|
||||
ARM_LPAE_PTE_ATTR_HI_MASK)
|
||||
|
||||
/* Stage-1 PTE */
|
||||
#define ARM_LPAE_PTE_AP_UNPRIV (((arm_lpae_iopte)1) << 6)
|
||||
#define ARM_LPAE_PTE_AP_RDONLY (((arm_lpae_iopte)2) << 6)
|
||||
#define ARM_LPAE_PTE_ATTRINDX_SHIFT 2
|
||||
#define ARM_LPAE_PTE_nG (((arm_lpae_iopte)1) << 11)
|
||||
|
||||
/* Stage-2 PTE */
|
||||
#define ARM_LPAE_PTE_HAP_FAULT (((arm_lpae_iopte)0) << 6)
|
||||
#define ARM_LPAE_PTE_HAP_READ (((arm_lpae_iopte)1) << 6)
|
||||
#define ARM_LPAE_PTE_HAP_WRITE (((arm_lpae_iopte)2) << 6)
|
||||
#define ARM_LPAE_PTE_MEMATTR_OIWB (((arm_lpae_iopte)0xf) << 2)
|
||||
#define ARM_LPAE_PTE_MEMATTR_NC (((arm_lpae_iopte)0x5) << 2)
|
||||
#define ARM_LPAE_PTE_MEMATTR_DEV (((arm_lpae_iopte)0x1) << 2)
|
||||
|
||||
/* Register bits */
|
||||
#define ARM_32_LPAE_TCR_EAE (1 << 31)
|
||||
#define ARM_64_LPAE_S2_TCR_RES1 (1 << 31)
|
||||
|
||||
#define ARM_LPAE_TCR_TG0_4K (0 << 14)
|
||||
#define ARM_LPAE_TCR_TG0_64K (1 << 14)
|
||||
#define ARM_LPAE_TCR_TG0_16K (2 << 14)
|
||||
|
||||
#define ARM_LPAE_TCR_SH0_SHIFT 12
|
||||
#define ARM_LPAE_TCR_SH0_MASK 0x3
|
||||
#define ARM_LPAE_TCR_SH_NS 0
|
||||
#define ARM_LPAE_TCR_SH_OS 2
|
||||
#define ARM_LPAE_TCR_SH_IS 3
|
||||
|
||||
#define ARM_LPAE_TCR_ORGN0_SHIFT 10
|
||||
#define ARM_LPAE_TCR_IRGN0_SHIFT 8
|
||||
#define ARM_LPAE_TCR_RGN_MASK 0x3
|
||||
#define ARM_LPAE_TCR_RGN_NC 0
|
||||
#define ARM_LPAE_TCR_RGN_WBWA 1
|
||||
#define ARM_LPAE_TCR_RGN_WT 2
|
||||
#define ARM_LPAE_TCR_RGN_WB 3
|
||||
|
||||
#define ARM_LPAE_TCR_SL0_SHIFT 6
|
||||
#define ARM_LPAE_TCR_SL0_MASK 0x3
|
||||
|
||||
#define ARM_LPAE_TCR_T0SZ_SHIFT 0
|
||||
#define ARM_LPAE_TCR_SZ_MASK 0xf
|
||||
|
||||
#define ARM_LPAE_TCR_PS_SHIFT 16
|
||||
#define ARM_LPAE_TCR_PS_MASK 0x7
|
||||
|
||||
#define ARM_LPAE_TCR_IPS_SHIFT 32
|
||||
#define ARM_LPAE_TCR_IPS_MASK 0x7
|
||||
|
||||
#define ARM_LPAE_TCR_PS_32_BIT 0x0ULL
|
||||
#define ARM_LPAE_TCR_PS_36_BIT 0x1ULL
|
||||
#define ARM_LPAE_TCR_PS_40_BIT 0x2ULL
|
||||
#define ARM_LPAE_TCR_PS_42_BIT 0x3ULL
|
||||
#define ARM_LPAE_TCR_PS_44_BIT 0x4ULL
|
||||
#define ARM_LPAE_TCR_PS_48_BIT 0x5ULL
|
||||
|
||||
#define ARM_LPAE_MAIR_ATTR_SHIFT(n) ((n) << 3)
|
||||
#define ARM_LPAE_MAIR_ATTR_MASK 0xff
|
||||
#define ARM_LPAE_MAIR_ATTR_DEVICE 0x04
|
||||
#define ARM_LPAE_MAIR_ATTR_NC 0x44
|
||||
#define ARM_LPAE_MAIR_ATTR_WBRWA 0xff
|
||||
#define ARM_LPAE_MAIR_ATTR_IDX_NC 0
|
||||
#define ARM_LPAE_MAIR_ATTR_IDX_CACHE 1
|
||||
#define ARM_LPAE_MAIR_ATTR_IDX_DEV 2
|
||||
|
||||
/* IOPTE accessors */
|
||||
#define iopte_deref(pte,d) \
|
||||
(__va((pte) & ((1ULL << ARM_LPAE_MAX_ADDR_BITS) - 1) \
|
||||
& ~((1ULL << (d)->pg_shift) - 1)))
|
||||
|
||||
#define iopte_type(pte,l) \
|
||||
(((pte) >> ARM_LPAE_PTE_TYPE_SHIFT) & ARM_LPAE_PTE_TYPE_MASK)
|
||||
|
||||
#define iopte_prot(pte) ((pte) & ARM_LPAE_PTE_ATTR_MASK)
|
||||
|
||||
#define iopte_leaf(pte,l) \
|
||||
(l == (ARM_LPAE_MAX_LEVELS - 1) ? \
|
||||
(iopte_type(pte,l) == ARM_LPAE_PTE_TYPE_PAGE) : \
|
||||
(iopte_type(pte,l) == ARM_LPAE_PTE_TYPE_BLOCK))
|
||||
|
||||
#define iopte_to_pfn(pte,d) \
|
||||
(((pte) & ((1ULL << ARM_LPAE_MAX_ADDR_BITS) - 1)) >> (d)->pg_shift)
|
||||
|
||||
#define pfn_to_iopte(pfn,d) \
|
||||
(((pfn) << (d)->pg_shift) & ((1ULL << ARM_LPAE_MAX_ADDR_BITS) - 1))
|
||||
|
||||
struct arm_lpae_io_pgtable {
|
||||
struct io_pgtable iop;
|
||||
|
||||
int levels;
|
||||
size_t pgd_size;
|
||||
unsigned long pg_shift;
|
||||
unsigned long bits_per_level;
|
||||
|
||||
void *pgd;
|
||||
};
|
||||
|
||||
typedef u64 arm_lpae_iopte;
|
||||
|
||||
static bool selftest_running = false;
|
||||
|
||||
static int arm_lpae_init_pte(struct arm_lpae_io_pgtable *data,
|
||||
unsigned long iova, phys_addr_t paddr,
|
||||
arm_lpae_iopte prot, int lvl,
|
||||
arm_lpae_iopte *ptep)
|
||||
{
|
||||
arm_lpae_iopte pte = prot;
|
||||
|
||||
/* We require an unmap first */
|
||||
if (iopte_leaf(*ptep, lvl)) {
|
||||
WARN_ON(!selftest_running);
|
||||
return -EEXIST;
|
||||
}
|
||||
|
||||
if (data->iop.cfg.quirks & IO_PGTABLE_QUIRK_ARM_NS)
|
||||
pte |= ARM_LPAE_PTE_NS;
|
||||
|
||||
if (lvl == ARM_LPAE_MAX_LEVELS - 1)
|
||||
pte |= ARM_LPAE_PTE_TYPE_PAGE;
|
||||
else
|
||||
pte |= ARM_LPAE_PTE_TYPE_BLOCK;
|
||||
|
||||
pte |= ARM_LPAE_PTE_AF | ARM_LPAE_PTE_SH_IS;
|
||||
pte |= pfn_to_iopte(paddr >> data->pg_shift, data);
|
||||
|
||||
*ptep = pte;
|
||||
data->iop.cfg.tlb->flush_pgtable(ptep, sizeof(*ptep), data->iop.cookie);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __arm_lpae_map(struct arm_lpae_io_pgtable *data, unsigned long iova,
|
||||
phys_addr_t paddr, size_t size, arm_lpae_iopte prot,
|
||||
int lvl, arm_lpae_iopte *ptep)
|
||||
{
|
||||
arm_lpae_iopte *cptep, pte;
|
||||
void *cookie = data->iop.cookie;
|
||||
size_t block_size = ARM_LPAE_BLOCK_SIZE(lvl, data);
|
||||
|
||||
/* Find our entry at the current level */
|
||||
ptep += ARM_LPAE_LVL_IDX(iova, lvl, data);
|
||||
|
||||
/* If we can install a leaf entry at this level, then do so */
|
||||
if (size == block_size && (size & data->iop.cfg.pgsize_bitmap))
|
||||
return arm_lpae_init_pte(data, iova, paddr, prot, lvl, ptep);
|
||||
|
||||
/* We can't allocate tables at the final level */
|
||||
if (WARN_ON(lvl >= ARM_LPAE_MAX_LEVELS - 1))
|
||||
return -EINVAL;
|
||||
|
||||
/* Grab a pointer to the next level */
|
||||
pte = *ptep;
|
||||
if (!pte) {
|
||||
cptep = alloc_pages_exact(1UL << data->pg_shift,
|
||||
GFP_ATOMIC | __GFP_ZERO);
|
||||
if (!cptep)
|
||||
return -ENOMEM;
|
||||
|
||||
data->iop.cfg.tlb->flush_pgtable(cptep, 1UL << data->pg_shift,
|
||||
cookie);
|
||||
pte = __pa(cptep) | ARM_LPAE_PTE_TYPE_TABLE;
|
||||
if (data->iop.cfg.quirks & IO_PGTABLE_QUIRK_ARM_NS)
|
||||
pte |= ARM_LPAE_PTE_NSTABLE;
|
||||
*ptep = pte;
|
||||
data->iop.cfg.tlb->flush_pgtable(ptep, sizeof(*ptep), cookie);
|
||||
} else {
|
||||
cptep = iopte_deref(pte, data);
|
||||
}
|
||||
|
||||
/* Rinse, repeat */
|
||||
return __arm_lpae_map(data, iova, paddr, size, prot, lvl + 1, cptep);
|
||||
}
|
||||
|
||||
static arm_lpae_iopte arm_lpae_prot_to_pte(struct arm_lpae_io_pgtable *data,
|
||||
int prot)
|
||||
{
|
||||
arm_lpae_iopte pte;
|
||||
|
||||
if (data->iop.fmt == ARM_64_LPAE_S1 ||
|
||||
data->iop.fmt == ARM_32_LPAE_S1) {
|
||||
pte = ARM_LPAE_PTE_AP_UNPRIV | ARM_LPAE_PTE_nG;
|
||||
|
||||
if (!(prot & IOMMU_WRITE) && (prot & IOMMU_READ))
|
||||
pte |= ARM_LPAE_PTE_AP_RDONLY;
|
||||
|
||||
if (prot & IOMMU_CACHE)
|
||||
pte |= (ARM_LPAE_MAIR_ATTR_IDX_CACHE
|
||||
<< ARM_LPAE_PTE_ATTRINDX_SHIFT);
|
||||
} else {
|
||||
pte = ARM_LPAE_PTE_HAP_FAULT;
|
||||
if (prot & IOMMU_READ)
|
||||
pte |= ARM_LPAE_PTE_HAP_READ;
|
||||
if (prot & IOMMU_WRITE)
|
||||
pte |= ARM_LPAE_PTE_HAP_WRITE;
|
||||
if (prot & IOMMU_CACHE)
|
||||
pte |= ARM_LPAE_PTE_MEMATTR_OIWB;
|
||||
else
|
||||
pte |= ARM_LPAE_PTE_MEMATTR_NC;
|
||||
}
|
||||
|
||||
if (prot & IOMMU_NOEXEC)
|
||||
pte |= ARM_LPAE_PTE_XN;
|
||||
|
||||
return pte;
|
||||
}
|
||||
|
||||
static int arm_lpae_map(struct io_pgtable_ops *ops, unsigned long iova,
|
||||
phys_addr_t paddr, size_t size, int iommu_prot)
|
||||
{
|
||||
struct arm_lpae_io_pgtable *data = io_pgtable_ops_to_data(ops);
|
||||
arm_lpae_iopte *ptep = data->pgd;
|
||||
int lvl = ARM_LPAE_START_LVL(data);
|
||||
arm_lpae_iopte prot;
|
||||
|
||||
/* If no access, then nothing to do */
|
||||
if (!(iommu_prot & (IOMMU_READ | IOMMU_WRITE)))
|
||||
return 0;
|
||||
|
||||
prot = arm_lpae_prot_to_pte(data, iommu_prot);
|
||||
return __arm_lpae_map(data, iova, paddr, size, prot, lvl, ptep);
|
||||
}
|
||||
|
||||
static void __arm_lpae_free_pgtable(struct arm_lpae_io_pgtable *data, int lvl,
|
||||
arm_lpae_iopte *ptep)
|
||||
{
|
||||
arm_lpae_iopte *start, *end;
|
||||
unsigned long table_size;
|
||||
|
||||
/* Only leaf entries at the last level */
|
||||
if (lvl == ARM_LPAE_MAX_LEVELS - 1)
|
||||
return;
|
||||
|
||||
if (lvl == ARM_LPAE_START_LVL(data))
|
||||
table_size = data->pgd_size;
|
||||
else
|
||||
table_size = 1UL << data->pg_shift;
|
||||
|
||||
start = ptep;
|
||||
end = (void *)ptep + table_size;
|
||||
|
||||
while (ptep != end) {
|
||||
arm_lpae_iopte pte = *ptep++;
|
||||
|
||||
if (!pte || iopte_leaf(pte, lvl))
|
||||
continue;
|
||||
|
||||
__arm_lpae_free_pgtable(data, lvl + 1, iopte_deref(pte, data));
|
||||
}
|
||||
|
||||
free_pages_exact(start, table_size);
|
||||
}
|
||||
|
||||
static void arm_lpae_free_pgtable(struct io_pgtable *iop)
|
||||
{
|
||||
struct arm_lpae_io_pgtable *data = io_pgtable_to_data(iop);
|
||||
|
||||
__arm_lpae_free_pgtable(data, ARM_LPAE_START_LVL(data), data->pgd);
|
||||
kfree(data);
|
||||
}
|
||||
|
||||
static int arm_lpae_split_blk_unmap(struct arm_lpae_io_pgtable *data,
|
||||
unsigned long iova, size_t size,
|
||||
arm_lpae_iopte prot, int lvl,
|
||||
arm_lpae_iopte *ptep, size_t blk_size)
|
||||
{
|
||||
unsigned long blk_start, blk_end;
|
||||
phys_addr_t blk_paddr;
|
||||
arm_lpae_iopte table = 0;
|
||||
void *cookie = data->iop.cookie;
|
||||
const struct iommu_gather_ops *tlb = data->iop.cfg.tlb;
|
||||
|
||||
blk_start = iova & ~(blk_size - 1);
|
||||
blk_end = blk_start + blk_size;
|
||||
blk_paddr = iopte_to_pfn(*ptep, data) << data->pg_shift;
|
||||
|
||||
for (; blk_start < blk_end; blk_start += size, blk_paddr += size) {
|
||||
arm_lpae_iopte *tablep;
|
||||
|
||||
/* Unmap! */
|
||||
if (blk_start == iova)
|
||||
continue;
|
||||
|
||||
/* __arm_lpae_map expects a pointer to the start of the table */
|
||||
tablep = &table - ARM_LPAE_LVL_IDX(blk_start, lvl, data);
|
||||
if (__arm_lpae_map(data, blk_start, blk_paddr, size, prot, lvl,
|
||||
tablep) < 0) {
|
||||
if (table) {
|
||||
/* Free the table we allocated */
|
||||
tablep = iopte_deref(table, data);
|
||||
__arm_lpae_free_pgtable(data, lvl + 1, tablep);
|
||||
}
|
||||
return 0; /* Bytes unmapped */
|
||||
}
|
||||
}
|
||||
|
||||
*ptep = table;
|
||||
tlb->flush_pgtable(ptep, sizeof(*ptep), cookie);
|
||||
iova &= ~(blk_size - 1);
|
||||
tlb->tlb_add_flush(iova, blk_size, true, cookie);
|
||||
return size;
|
||||
}
|
||||
|
||||
static int __arm_lpae_unmap(struct arm_lpae_io_pgtable *data,
|
||||
unsigned long iova, size_t size, int lvl,
|
||||
arm_lpae_iopte *ptep)
|
||||
{
|
||||
arm_lpae_iopte pte;
|
||||
const struct iommu_gather_ops *tlb = data->iop.cfg.tlb;
|
||||
void *cookie = data->iop.cookie;
|
||||
size_t blk_size = ARM_LPAE_BLOCK_SIZE(lvl, data);
|
||||
|
||||
ptep += ARM_LPAE_LVL_IDX(iova, lvl, data);
|
||||
pte = *ptep;
|
||||
|
||||
/* Something went horribly wrong and we ran out of page table */
|
||||
if (WARN_ON(!pte || (lvl == ARM_LPAE_MAX_LEVELS)))
|
||||
return 0;
|
||||
|
||||
/* If the size matches this level, we're in the right place */
|
||||
if (size == blk_size) {
|
||||
*ptep = 0;
|
||||
tlb->flush_pgtable(ptep, sizeof(*ptep), cookie);
|
||||
|
||||
if (!iopte_leaf(pte, lvl)) {
|
||||
/* Also flush any partial walks */
|
||||
tlb->tlb_add_flush(iova, size, false, cookie);
|
||||
tlb->tlb_sync(data->iop.cookie);
|
||||
ptep = iopte_deref(pte, data);
|
||||
__arm_lpae_free_pgtable(data, lvl + 1, ptep);
|
||||
} else {
|
||||
tlb->tlb_add_flush(iova, size, true, cookie);
|
||||
}
|
||||
|
||||
return size;
|
||||
} else if (iopte_leaf(pte, lvl)) {
|
||||
/*
|
||||
* Insert a table at the next level to map the old region,
|
||||
* minus the part we want to unmap
|
||||
*/
|
||||
return arm_lpae_split_blk_unmap(data, iova, size,
|
||||
iopte_prot(pte), lvl, ptep,
|
||||
blk_size);
|
||||
}
|
||||
|
||||
/* Keep on walkin' */
|
||||
ptep = iopte_deref(pte, data);
|
||||
return __arm_lpae_unmap(data, iova, size, lvl + 1, ptep);
|
||||
}
|
||||
|
||||
static int arm_lpae_unmap(struct io_pgtable_ops *ops, unsigned long iova,
|
||||
size_t size)
|
||||
{
|
||||
size_t unmapped;
|
||||
struct arm_lpae_io_pgtable *data = io_pgtable_ops_to_data(ops);
|
||||
struct io_pgtable *iop = &data->iop;
|
||||
arm_lpae_iopte *ptep = data->pgd;
|
||||
int lvl = ARM_LPAE_START_LVL(data);
|
||||
|
||||
unmapped = __arm_lpae_unmap(data, iova, size, lvl, ptep);
|
||||
if (unmapped)
|
||||
iop->cfg.tlb->tlb_sync(iop->cookie);
|
||||
|
||||
return unmapped;
|
||||
}
|
||||
|
||||
static phys_addr_t arm_lpae_iova_to_phys(struct io_pgtable_ops *ops,
|
||||
unsigned long iova)
|
||||
{
|
||||
struct arm_lpae_io_pgtable *data = io_pgtable_ops_to_data(ops);
|
||||
arm_lpae_iopte pte, *ptep = data->pgd;
|
||||
int lvl = ARM_LPAE_START_LVL(data);
|
||||
|
||||
do {
|
||||
/* Valid IOPTE pointer? */
|
||||
if (!ptep)
|
||||
return 0;
|
||||
|
||||
/* Grab the IOPTE we're interested in */
|
||||
pte = *(ptep + ARM_LPAE_LVL_IDX(iova, lvl, data));
|
||||
|
||||
/* Valid entry? */
|
||||
if (!pte)
|
||||
return 0;
|
||||
|
||||
/* Leaf entry? */
|
||||
if (iopte_leaf(pte,lvl))
|
||||
goto found_translation;
|
||||
|
||||
/* Take it to the next level */
|
||||
ptep = iopte_deref(pte, data);
|
||||
} while (++lvl < ARM_LPAE_MAX_LEVELS);
|
||||
|
||||
/* Ran out of page tables to walk */
|
||||
return 0;
|
||||
|
||||
found_translation:
|
||||
iova &= ((1 << data->pg_shift) - 1);
|
||||
return ((phys_addr_t)iopte_to_pfn(pte,data) << data->pg_shift) | iova;
|
||||
}
|
||||
|
||||
static void arm_lpae_restrict_pgsizes(struct io_pgtable_cfg *cfg)
|
||||
{
|
||||
unsigned long granule;
|
||||
|
||||
/*
|
||||
* We need to restrict the supported page sizes to match the
|
||||
* translation regime for a particular granule. Aim to match
|
||||
* the CPU page size if possible, otherwise prefer smaller sizes.
|
||||
* While we're at it, restrict the block sizes to match the
|
||||
* chosen granule.
|
||||
*/
|
||||
if (cfg->pgsize_bitmap & PAGE_SIZE)
|
||||
granule = PAGE_SIZE;
|
||||
else if (cfg->pgsize_bitmap & ~PAGE_MASK)
|
||||
granule = 1UL << __fls(cfg->pgsize_bitmap & ~PAGE_MASK);
|
||||
else if (cfg->pgsize_bitmap & PAGE_MASK)
|
||||
granule = 1UL << __ffs(cfg->pgsize_bitmap & PAGE_MASK);
|
||||
else
|
||||
granule = 0;
|
||||
|
||||
switch (granule) {
|
||||
case SZ_4K:
|
||||
cfg->pgsize_bitmap &= (SZ_4K | SZ_2M | SZ_1G);
|
||||
break;
|
||||
case SZ_16K:
|
||||
cfg->pgsize_bitmap &= (SZ_16K | SZ_32M);
|
||||
break;
|
||||
case SZ_64K:
|
||||
cfg->pgsize_bitmap &= (SZ_64K | SZ_512M);
|
||||
break;
|
||||
default:
|
||||
cfg->pgsize_bitmap = 0;
|
||||
}
|
||||
}
|
||||
|
||||
static struct arm_lpae_io_pgtable *
|
||||
arm_lpae_alloc_pgtable(struct io_pgtable_cfg *cfg)
|
||||
{
|
||||
unsigned long va_bits, pgd_bits;
|
||||
struct arm_lpae_io_pgtable *data;
|
||||
|
||||
arm_lpae_restrict_pgsizes(cfg);
|
||||
|
||||
if (!(cfg->pgsize_bitmap & (SZ_4K | SZ_16K | SZ_64K)))
|
||||
return NULL;
|
||||
|
||||
if (cfg->ias > ARM_LPAE_MAX_ADDR_BITS)
|
||||
return NULL;
|
||||
|
||||
if (cfg->oas > ARM_LPAE_MAX_ADDR_BITS)
|
||||
return NULL;
|
||||
|
||||
data = kmalloc(sizeof(*data), GFP_KERNEL);
|
||||
if (!data)
|
||||
return NULL;
|
||||
|
||||
data->pg_shift = __ffs(cfg->pgsize_bitmap);
|
||||
data->bits_per_level = data->pg_shift - ilog2(sizeof(arm_lpae_iopte));
|
||||
|
||||
va_bits = cfg->ias - data->pg_shift;
|
||||
data->levels = DIV_ROUND_UP(va_bits, data->bits_per_level);
|
||||
|
||||
/* Calculate the actual size of our pgd (without concatenation) */
|
||||
pgd_bits = va_bits - (data->bits_per_level * (data->levels - 1));
|
||||
data->pgd_size = 1UL << (pgd_bits + ilog2(sizeof(arm_lpae_iopte)));
|
||||
|
||||
data->iop.ops = (struct io_pgtable_ops) {
|
||||
.map = arm_lpae_map,
|
||||
.unmap = arm_lpae_unmap,
|
||||
.iova_to_phys = arm_lpae_iova_to_phys,
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
static struct io_pgtable *
|
||||
arm_64_lpae_alloc_pgtable_s1(struct io_pgtable_cfg *cfg, void *cookie)
|
||||
{
|
||||
u64 reg;
|
||||
struct arm_lpae_io_pgtable *data = arm_lpae_alloc_pgtable(cfg);
|
||||
|
||||
if (!data)
|
||||
return NULL;
|
||||
|
||||
/* TCR */
|
||||
reg = (ARM_LPAE_TCR_SH_IS << ARM_LPAE_TCR_SH0_SHIFT) |
|
||||
(ARM_LPAE_TCR_RGN_WBWA << ARM_LPAE_TCR_IRGN0_SHIFT) |
|
||||
(ARM_LPAE_TCR_RGN_WBWA << ARM_LPAE_TCR_ORGN0_SHIFT);
|
||||
|
||||
switch (1 << data->pg_shift) {
|
||||
case SZ_4K:
|
||||
reg |= ARM_LPAE_TCR_TG0_4K;
|
||||
break;
|
||||
case SZ_16K:
|
||||
reg |= ARM_LPAE_TCR_TG0_16K;
|
||||
break;
|
||||
case SZ_64K:
|
||||
reg |= ARM_LPAE_TCR_TG0_64K;
|
||||
break;
|
||||
}
|
||||
|
||||
switch (cfg->oas) {
|
||||
case 32:
|
||||
reg |= (ARM_LPAE_TCR_PS_32_BIT << ARM_LPAE_TCR_IPS_SHIFT);
|
||||
break;
|
||||
case 36:
|
||||
reg |= (ARM_LPAE_TCR_PS_36_BIT << ARM_LPAE_TCR_IPS_SHIFT);
|
||||
break;
|
||||
case 40:
|
||||
reg |= (ARM_LPAE_TCR_PS_40_BIT << ARM_LPAE_TCR_IPS_SHIFT);
|
||||
break;
|
||||
case 42:
|
||||
reg |= (ARM_LPAE_TCR_PS_42_BIT << ARM_LPAE_TCR_IPS_SHIFT);
|
||||
break;
|
||||
case 44:
|
||||
reg |= (ARM_LPAE_TCR_PS_44_BIT << ARM_LPAE_TCR_IPS_SHIFT);
|
||||
break;
|
||||
case 48:
|
||||
reg |= (ARM_LPAE_TCR_PS_48_BIT << ARM_LPAE_TCR_IPS_SHIFT);
|
||||
break;
|
||||
default:
|
||||
goto out_free_data;
|
||||
}
|
||||
|
||||
reg |= (64ULL - cfg->ias) << ARM_LPAE_TCR_T0SZ_SHIFT;
|
||||
cfg->arm_lpae_s1_cfg.tcr = reg;
|
||||
|
||||
/* MAIRs */
|
||||
reg = (ARM_LPAE_MAIR_ATTR_NC
|
||||
<< ARM_LPAE_MAIR_ATTR_SHIFT(ARM_LPAE_MAIR_ATTR_IDX_NC)) |
|
||||
(ARM_LPAE_MAIR_ATTR_WBRWA
|
||||
<< ARM_LPAE_MAIR_ATTR_SHIFT(ARM_LPAE_MAIR_ATTR_IDX_CACHE)) |
|
||||
(ARM_LPAE_MAIR_ATTR_DEVICE
|
||||
<< ARM_LPAE_MAIR_ATTR_SHIFT(ARM_LPAE_MAIR_ATTR_IDX_DEV));
|
||||
|
||||
cfg->arm_lpae_s1_cfg.mair[0] = reg;
|
||||
cfg->arm_lpae_s1_cfg.mair[1] = 0;
|
||||
|
||||
/* Looking good; allocate a pgd */
|
||||
data->pgd = alloc_pages_exact(data->pgd_size, GFP_KERNEL | __GFP_ZERO);
|
||||
if (!data->pgd)
|
||||
goto out_free_data;
|
||||
|
||||
cfg->tlb->flush_pgtable(data->pgd, data->pgd_size, cookie);
|
||||
|
||||
/* TTBRs */
|
||||
cfg->arm_lpae_s1_cfg.ttbr[0] = virt_to_phys(data->pgd);
|
||||
cfg->arm_lpae_s1_cfg.ttbr[1] = 0;
|
||||
return &data->iop;
|
||||
|
||||
out_free_data:
|
||||
kfree(data);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static struct io_pgtable *
|
||||
arm_64_lpae_alloc_pgtable_s2(struct io_pgtable_cfg *cfg, void *cookie)
|
||||
{
|
||||
u64 reg, sl;
|
||||
struct arm_lpae_io_pgtable *data = arm_lpae_alloc_pgtable(cfg);
|
||||
|
||||
if (!data)
|
||||
return NULL;
|
||||
|
||||
/*
|
||||
* Concatenate PGDs at level 1 if possible in order to reduce
|
||||
* the depth of the stage-2 walk.
|
||||
*/
|
||||
if (data->levels == ARM_LPAE_MAX_LEVELS) {
|
||||
unsigned long pgd_pages;
|
||||
|
||||
pgd_pages = data->pgd_size >> ilog2(sizeof(arm_lpae_iopte));
|
||||
if (pgd_pages <= ARM_LPAE_S2_MAX_CONCAT_PAGES) {
|
||||
data->pgd_size = pgd_pages << data->pg_shift;
|
||||
data->levels--;
|
||||
}
|
||||
}
|
||||
|
||||
/* VTCR */
|
||||
reg = ARM_64_LPAE_S2_TCR_RES1 |
|
||||
(ARM_LPAE_TCR_SH_IS << ARM_LPAE_TCR_SH0_SHIFT) |
|
||||
(ARM_LPAE_TCR_RGN_WBWA << ARM_LPAE_TCR_IRGN0_SHIFT) |
|
||||
(ARM_LPAE_TCR_RGN_WBWA << ARM_LPAE_TCR_ORGN0_SHIFT);
|
||||
|
||||
sl = ARM_LPAE_START_LVL(data);
|
||||
|
||||
switch (1 << data->pg_shift) {
|
||||
case SZ_4K:
|
||||
reg |= ARM_LPAE_TCR_TG0_4K;
|
||||
sl++; /* SL0 format is different for 4K granule size */
|
||||
break;
|
||||
case SZ_16K:
|
||||
reg |= ARM_LPAE_TCR_TG0_16K;
|
||||
break;
|
||||
case SZ_64K:
|
||||
reg |= ARM_LPAE_TCR_TG0_64K;
|
||||
break;
|
||||
}
|
||||
|
||||
switch (cfg->oas) {
|
||||
case 32:
|
||||
reg |= (ARM_LPAE_TCR_PS_32_BIT << ARM_LPAE_TCR_PS_SHIFT);
|
||||
break;
|
||||
case 36:
|
||||
reg |= (ARM_LPAE_TCR_PS_36_BIT << ARM_LPAE_TCR_PS_SHIFT);
|
||||
break;
|
||||
case 40:
|
||||
reg |= (ARM_LPAE_TCR_PS_40_BIT << ARM_LPAE_TCR_PS_SHIFT);
|
||||
break;
|
||||
case 42:
|
||||
reg |= (ARM_LPAE_TCR_PS_42_BIT << ARM_LPAE_TCR_PS_SHIFT);
|
||||
break;
|
||||
case 44:
|
||||
reg |= (ARM_LPAE_TCR_PS_44_BIT << ARM_LPAE_TCR_PS_SHIFT);
|
||||
break;
|
||||
case 48:
|
||||
reg |= (ARM_LPAE_TCR_PS_48_BIT << ARM_LPAE_TCR_PS_SHIFT);
|
||||
break;
|
||||
default:
|
||||
goto out_free_data;
|
||||
}
|
||||
|
||||
reg |= (64ULL - cfg->ias) << ARM_LPAE_TCR_T0SZ_SHIFT;
|
||||
reg |= (~sl & ARM_LPAE_TCR_SL0_MASK) << ARM_LPAE_TCR_SL0_SHIFT;
|
||||
cfg->arm_lpae_s2_cfg.vtcr = reg;
|
||||
|
||||
/* Allocate pgd pages */
|
||||
data->pgd = alloc_pages_exact(data->pgd_size, GFP_KERNEL | __GFP_ZERO);
|
||||
if (!data->pgd)
|
||||
goto out_free_data;
|
||||
|
||||
cfg->tlb->flush_pgtable(data->pgd, data->pgd_size, cookie);
|
||||
|
||||
/* VTTBR */
|
||||
cfg->arm_lpae_s2_cfg.vttbr = virt_to_phys(data->pgd);
|
||||
return &data->iop;
|
||||
|
||||
out_free_data:
|
||||
kfree(data);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static struct io_pgtable *
|
||||
arm_32_lpae_alloc_pgtable_s1(struct io_pgtable_cfg *cfg, void *cookie)
|
||||
{
|
||||
struct io_pgtable *iop;
|
||||
|
||||
if (cfg->ias > 32 || cfg->oas > 40)
|
||||
return NULL;
|
||||
|
||||
cfg->pgsize_bitmap &= (SZ_4K | SZ_2M | SZ_1G);
|
||||
iop = arm_64_lpae_alloc_pgtable_s1(cfg, cookie);
|
||||
if (iop) {
|
||||
cfg->arm_lpae_s1_cfg.tcr |= ARM_32_LPAE_TCR_EAE;
|
||||
cfg->arm_lpae_s1_cfg.tcr &= 0xffffffff;
|
||||
}
|
||||
|
||||
return iop;
|
||||
}
|
||||
|
||||
static struct io_pgtable *
|
||||
arm_32_lpae_alloc_pgtable_s2(struct io_pgtable_cfg *cfg, void *cookie)
|
||||
{
|
||||
struct io_pgtable *iop;
|
||||
|
||||
if (cfg->ias > 40 || cfg->oas > 40)
|
||||
return NULL;
|
||||
|
||||
cfg->pgsize_bitmap &= (SZ_4K | SZ_2M | SZ_1G);
|
||||
iop = arm_64_lpae_alloc_pgtable_s2(cfg, cookie);
|
||||
if (iop)
|
||||
cfg->arm_lpae_s2_cfg.vtcr &= 0xffffffff;
|
||||
|
||||
return iop;
|
||||
}
|
||||
|
||||
struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns = {
|
||||
.alloc = arm_64_lpae_alloc_pgtable_s1,
|
||||
.free = arm_lpae_free_pgtable,
|
||||
};
|
||||
|
||||
struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns = {
|
||||
.alloc = arm_64_lpae_alloc_pgtable_s2,
|
||||
.free = arm_lpae_free_pgtable,
|
||||
};
|
||||
|
||||
struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns = {
|
||||
.alloc = arm_32_lpae_alloc_pgtable_s1,
|
||||
.free = arm_lpae_free_pgtable,
|
||||
};
|
||||
|
||||
struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns = {
|
||||
.alloc = arm_32_lpae_alloc_pgtable_s2,
|
||||
.free = arm_lpae_free_pgtable,
|
||||
};
|
||||
|
||||
#ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE_SELFTEST
|
||||
|
||||
static struct io_pgtable_cfg *cfg_cookie;
|
||||
|
||||
static void dummy_tlb_flush_all(void *cookie)
|
||||
{
|
||||
WARN_ON(cookie != cfg_cookie);
|
||||
}
|
||||
|
||||
static void dummy_tlb_add_flush(unsigned long iova, size_t size, bool leaf,
|
||||
void *cookie)
|
||||
{
|
||||
WARN_ON(cookie != cfg_cookie);
|
||||
WARN_ON(!(size & cfg_cookie->pgsize_bitmap));
|
||||
}
|
||||
|
||||
static void dummy_tlb_sync(void *cookie)
|
||||
{
|
||||
WARN_ON(cookie != cfg_cookie);
|
||||
}
|
||||
|
||||
static void dummy_flush_pgtable(void *ptr, size_t size, void *cookie)
|
||||
{
|
||||
WARN_ON(cookie != cfg_cookie);
|
||||
}
|
||||
|
||||
static struct iommu_gather_ops dummy_tlb_ops __initdata = {
|
||||
.tlb_flush_all = dummy_tlb_flush_all,
|
||||
.tlb_add_flush = dummy_tlb_add_flush,
|
||||
.tlb_sync = dummy_tlb_sync,
|
||||
.flush_pgtable = dummy_flush_pgtable,
|
||||
};
|
||||
|
||||
static void __init arm_lpae_dump_ops(struct io_pgtable_ops *ops)
|
||||
{
|
||||
struct arm_lpae_io_pgtable *data = io_pgtable_ops_to_data(ops);
|
||||
struct io_pgtable_cfg *cfg = &data->iop.cfg;
|
||||
|
||||
pr_err("cfg: pgsize_bitmap 0x%lx, ias %u-bit\n",
|
||||
cfg->pgsize_bitmap, cfg->ias);
|
||||
pr_err("data: %d levels, 0x%zx pgd_size, %lu pg_shift, %lu bits_per_level, pgd @ %p\n",
|
||||
data->levels, data->pgd_size, data->pg_shift,
|
||||
data->bits_per_level, data->pgd);
|
||||
}
|
||||
|
||||
#define __FAIL(ops, i) ({ \
|
||||
WARN(1, "selftest: test failed for fmt idx %d\n", (i)); \
|
||||
arm_lpae_dump_ops(ops); \
|
||||
selftest_running = false; \
|
||||
-EFAULT; \
|
||||
})
|
||||
|
||||
static int __init arm_lpae_run_tests(struct io_pgtable_cfg *cfg)
|
||||
{
|
||||
static const enum io_pgtable_fmt fmts[] = {
|
||||
ARM_64_LPAE_S1,
|
||||
ARM_64_LPAE_S2,
|
||||
};
|
||||
|
||||
int i, j;
|
||||
unsigned long iova;
|
||||
size_t size;
|
||||
struct io_pgtable_ops *ops;
|
||||
|
||||
selftest_running = true;
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(fmts); ++i) {
|
||||
cfg_cookie = cfg;
|
||||
ops = alloc_io_pgtable_ops(fmts[i], cfg, cfg);
|
||||
if (!ops) {
|
||||
pr_err("selftest: failed to allocate io pgtable ops\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
/*
|
||||
* Initial sanity checks.
|
||||
* Empty page tables shouldn't provide any translations.
|
||||
*/
|
||||
if (ops->iova_to_phys(ops, 42))
|
||||
return __FAIL(ops, i);
|
||||
|
||||
if (ops->iova_to_phys(ops, SZ_1G + 42))
|
||||
return __FAIL(ops, i);
|
||||
|
||||
if (ops->iova_to_phys(ops, SZ_2G + 42))
|
||||
return __FAIL(ops, i);
|
||||
|
||||
/*
|
||||
* Distinct mappings of different granule sizes.
|
||||
*/
|
||||
iova = 0;
|
||||
j = find_first_bit(&cfg->pgsize_bitmap, BITS_PER_LONG);
|
||||
while (j != BITS_PER_LONG) {
|
||||
size = 1UL << j;
|
||||
|
||||
if (ops->map(ops, iova, iova, size, IOMMU_READ |
|
||||
IOMMU_WRITE |
|
||||
IOMMU_NOEXEC |
|
||||
IOMMU_CACHE))
|
||||
return __FAIL(ops, i);
|
||||
|
||||
/* Overlapping mappings */
|
||||
if (!ops->map(ops, iova, iova + size, size,
|
||||
IOMMU_READ | IOMMU_NOEXEC))
|
||||
return __FAIL(ops, i);
|
||||
|
||||
if (ops->iova_to_phys(ops, iova + 42) != (iova + 42))
|
||||
return __FAIL(ops, i);
|
||||
|
||||
iova += SZ_1G;
|
||||
j++;
|
||||
j = find_next_bit(&cfg->pgsize_bitmap, BITS_PER_LONG, j);
|
||||
}
|
||||
|
||||
/* Partial unmap */
|
||||
size = 1UL << __ffs(cfg->pgsize_bitmap);
|
||||
if (ops->unmap(ops, SZ_1G + size, size) != size)
|
||||
return __FAIL(ops, i);
|
||||
|
||||
/* Remap of partial unmap */
|
||||
if (ops->map(ops, SZ_1G + size, size, size, IOMMU_READ))
|
||||
return __FAIL(ops, i);
|
||||
|
||||
if (ops->iova_to_phys(ops, SZ_1G + size + 42) != (size + 42))
|
||||
return __FAIL(ops, i);
|
||||
|
||||
/* Full unmap */
|
||||
iova = 0;
|
||||
j = find_first_bit(&cfg->pgsize_bitmap, BITS_PER_LONG);
|
||||
while (j != BITS_PER_LONG) {
|
||||
size = 1UL << j;
|
||||
|
||||
if (ops->unmap(ops, iova, size) != size)
|
||||
return __FAIL(ops, i);
|
||||
|
||||
if (ops->iova_to_phys(ops, iova + 42))
|
||||
return __FAIL(ops, i);
|
||||
|
||||
/* Remap full block */
|
||||
if (ops->map(ops, iova, iova, size, IOMMU_WRITE))
|
||||
return __FAIL(ops, i);
|
||||
|
||||
if (ops->iova_to_phys(ops, iova + 42) != (iova + 42))
|
||||
return __FAIL(ops, i);
|
||||
|
||||
iova += SZ_1G;
|
||||
j++;
|
||||
j = find_next_bit(&cfg->pgsize_bitmap, BITS_PER_LONG, j);
|
||||
}
|
||||
|
||||
free_io_pgtable_ops(ops);
|
||||
}
|
||||
|
||||
selftest_running = false;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __init arm_lpae_do_selftests(void)
|
||||
{
|
||||
static const unsigned long pgsize[] = {
|
||||
SZ_4K | SZ_2M | SZ_1G,
|
||||
SZ_16K | SZ_32M,
|
||||
SZ_64K | SZ_512M,
|
||||
};
|
||||
|
||||
static const unsigned int ias[] = {
|
||||
32, 36, 40, 42, 44, 48,
|
||||
};
|
||||
|
||||
int i, j, pass = 0, fail = 0;
|
||||
struct io_pgtable_cfg cfg = {
|
||||
.tlb = &dummy_tlb_ops,
|
||||
.oas = 48,
|
||||
};
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(pgsize); ++i) {
|
||||
for (j = 0; j < ARRAY_SIZE(ias); ++j) {
|
||||
cfg.pgsize_bitmap = pgsize[i];
|
||||
cfg.ias = ias[j];
|
||||
pr_info("selftest: pgsize_bitmap 0x%08lx, IAS %u\n",
|
||||
pgsize[i], ias[j]);
|
||||
if (arm_lpae_run_tests(&cfg))
|
||||
fail++;
|
||||
else
|
||||
pass++;
|
||||
}
|
||||
}
|
||||
|
||||
pr_info("selftest: completed with %d PASS %d FAIL\n", pass, fail);
|
||||
return fail ? -EFAULT : 0;
|
||||
}
|
||||
subsys_initcall(arm_lpae_do_selftests);
|
||||
#endif
|
||||
82
drivers/iommu/io-pgtable.c
Normal file
82
drivers/iommu/io-pgtable.c
Normal file
|
|
@ -0,0 +1,82 @@
|
|||
/*
|
||||
* Generic page table allocator for IOMMUs.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope that 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/>.
|
||||
*
|
||||
* Copyright (C) 2014 ARM Limited
|
||||
*
|
||||
* Author: Will Deacon <will.deacon@arm.com>
|
||||
*/
|
||||
|
||||
#include <linux/bug.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/types.h>
|
||||
|
||||
#include "io-pgtable.h"
|
||||
|
||||
extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s1_init_fns;
|
||||
extern struct io_pgtable_init_fns io_pgtable_arm_32_lpae_s2_init_fns;
|
||||
extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s1_init_fns;
|
||||
extern struct io_pgtable_init_fns io_pgtable_arm_64_lpae_s2_init_fns;
|
||||
|
||||
static const struct io_pgtable_init_fns *
|
||||
io_pgtable_init_table[IO_PGTABLE_NUM_FMTS] =
|
||||
{
|
||||
#ifdef CONFIG_IOMMU_IO_PGTABLE_LPAE
|
||||
[ARM_32_LPAE_S1] = &io_pgtable_arm_32_lpae_s1_init_fns,
|
||||
[ARM_32_LPAE_S2] = &io_pgtable_arm_32_lpae_s2_init_fns,
|
||||
[ARM_64_LPAE_S1] = &io_pgtable_arm_64_lpae_s1_init_fns,
|
||||
[ARM_64_LPAE_S2] = &io_pgtable_arm_64_lpae_s2_init_fns,
|
||||
#endif
|
||||
};
|
||||
|
||||
struct io_pgtable_ops *alloc_io_pgtable_ops(enum io_pgtable_fmt fmt,
|
||||
struct io_pgtable_cfg *cfg,
|
||||
void *cookie)
|
||||
{
|
||||
struct io_pgtable *iop;
|
||||
const struct io_pgtable_init_fns *fns;
|
||||
|
||||
if (fmt >= IO_PGTABLE_NUM_FMTS)
|
||||
return NULL;
|
||||
|
||||
fns = io_pgtable_init_table[fmt];
|
||||
if (!fns)
|
||||
return NULL;
|
||||
|
||||
iop = fns->alloc(cfg, cookie);
|
||||
if (!iop)
|
||||
return NULL;
|
||||
|
||||
iop->fmt = fmt;
|
||||
iop->cookie = cookie;
|
||||
iop->cfg = *cfg;
|
||||
|
||||
return &iop->ops;
|
||||
}
|
||||
|
||||
/*
|
||||
* It is the IOMMU driver's responsibility to ensure that the page table
|
||||
* is no longer accessible to the walker by this point.
|
||||
*/
|
||||
void free_io_pgtable_ops(struct io_pgtable_ops *ops)
|
||||
{
|
||||
struct io_pgtable *iop;
|
||||
|
||||
if (!ops)
|
||||
return;
|
||||
|
||||
iop = container_of(ops, struct io_pgtable, ops);
|
||||
iop->cfg.tlb->tlb_flush_all(iop->cookie);
|
||||
io_pgtable_init_table[iop->fmt]->free(iop);
|
||||
}
|
||||
143
drivers/iommu/io-pgtable.h
Normal file
143
drivers/iommu/io-pgtable.h
Normal file
|
|
@ -0,0 +1,143 @@
|
|||
#ifndef __IO_PGTABLE_H
|
||||
#define __IO_PGTABLE_H
|
||||
|
||||
/*
|
||||
* Public API for use by IOMMU drivers
|
||||
*/
|
||||
enum io_pgtable_fmt {
|
||||
ARM_32_LPAE_S1,
|
||||
ARM_32_LPAE_S2,
|
||||
ARM_64_LPAE_S1,
|
||||
ARM_64_LPAE_S2,
|
||||
IO_PGTABLE_NUM_FMTS,
|
||||
};
|
||||
|
||||
/**
|
||||
* struct iommu_gather_ops - IOMMU callbacks for TLB and page table management.
|
||||
*
|
||||
* @tlb_flush_all: Synchronously invalidate the entire TLB context.
|
||||
* @tlb_add_flush: Queue up a TLB invalidation for a virtual address range.
|
||||
* @tlb_sync: Ensure any queue TLB invalidation has taken effect.
|
||||
* @flush_pgtable: Ensure page table updates are visible to the IOMMU.
|
||||
*
|
||||
* Note that these can all be called in atomic context and must therefore
|
||||
* not block.
|
||||
*/
|
||||
struct iommu_gather_ops {
|
||||
void (*tlb_flush_all)(void *cookie);
|
||||
void (*tlb_add_flush)(unsigned long iova, size_t size, bool leaf,
|
||||
void *cookie);
|
||||
void (*tlb_sync)(void *cookie);
|
||||
void (*flush_pgtable)(void *ptr, size_t size, void *cookie);
|
||||
};
|
||||
|
||||
/**
|
||||
* struct io_pgtable_cfg - Configuration data for a set of page tables.
|
||||
*
|
||||
* @quirks: A bitmap of hardware quirks that require some special
|
||||
* action by the low-level page table allocator.
|
||||
* @pgsize_bitmap: A bitmap of page sizes supported by this set of page
|
||||
* tables.
|
||||
* @ias: Input address (iova) size, in bits.
|
||||
* @oas: Output address (paddr) size, in bits.
|
||||
* @tlb: TLB management callbacks for this set of tables.
|
||||
*/
|
||||
struct io_pgtable_cfg {
|
||||
#define IO_PGTABLE_QUIRK_ARM_NS (1 << 0) /* Set NS bit in PTEs */
|
||||
int quirks;
|
||||
unsigned long pgsize_bitmap;
|
||||
unsigned int ias;
|
||||
unsigned int oas;
|
||||
const struct iommu_gather_ops *tlb;
|
||||
|
||||
/* Low-level data specific to the table format */
|
||||
union {
|
||||
struct {
|
||||
u64 ttbr[2];
|
||||
u64 tcr;
|
||||
u64 mair[2];
|
||||
} arm_lpae_s1_cfg;
|
||||
|
||||
struct {
|
||||
u64 vttbr;
|
||||
u64 vtcr;
|
||||
} arm_lpae_s2_cfg;
|
||||
};
|
||||
};
|
||||
|
||||
/**
|
||||
* struct io_pgtable_ops - Page table manipulation API for IOMMU drivers.
|
||||
*
|
||||
* @map: Map a physically contiguous memory region.
|
||||
* @unmap: Unmap a physically contiguous memory region.
|
||||
* @iova_to_phys: Translate iova to physical address.
|
||||
*
|
||||
* These functions map directly onto the iommu_ops member functions with
|
||||
* the same names.
|
||||
*/
|
||||
struct io_pgtable_ops {
|
||||
int (*map)(struct io_pgtable_ops *ops, unsigned long iova,
|
||||
phys_addr_t paddr, size_t size, int prot);
|
||||
int (*unmap)(struct io_pgtable_ops *ops, unsigned long iova,
|
||||
size_t size);
|
||||
phys_addr_t (*iova_to_phys)(struct io_pgtable_ops *ops,
|
||||
unsigned long iova);
|
||||
};
|
||||
|
||||
/**
|
||||
* alloc_io_pgtable_ops() - Allocate a page table allocator for use by an IOMMU.
|
||||
*
|
||||
* @fmt: The page table format.
|
||||
* @cfg: The page table configuration. This will be modified to represent
|
||||
* the configuration actually provided by the allocator (e.g. the
|
||||
* pgsize_bitmap may be restricted).
|
||||
* @cookie: An opaque token provided by the IOMMU driver and passed back to
|
||||
* the callback routines in cfg->tlb.
|
||||
*/
|
||||
struct io_pgtable_ops *alloc_io_pgtable_ops(enum io_pgtable_fmt fmt,
|
||||
struct io_pgtable_cfg *cfg,
|
||||
void *cookie);
|
||||
|
||||
/**
|
||||
* free_io_pgtable_ops() - Free an io_pgtable_ops structure. The caller
|
||||
* *must* ensure that the page table is no longer
|
||||
* live, but the TLB can be dirty.
|
||||
*
|
||||
* @ops: The ops returned from alloc_io_pgtable_ops.
|
||||
*/
|
||||
void free_io_pgtable_ops(struct io_pgtable_ops *ops);
|
||||
|
||||
|
||||
/*
|
||||
* Internal structures for page table allocator implementations.
|
||||
*/
|
||||
|
||||
/**
|
||||
* struct io_pgtable - Internal structure describing a set of page tables.
|
||||
*
|
||||
* @fmt: The page table format.
|
||||
* @cookie: An opaque token provided by the IOMMU driver and passed back to
|
||||
* any callback routines.
|
||||
* @cfg: A copy of the page table configuration.
|
||||
* @ops: The page table operations in use for this set of page tables.
|
||||
*/
|
||||
struct io_pgtable {
|
||||
enum io_pgtable_fmt fmt;
|
||||
void *cookie;
|
||||
struct io_pgtable_cfg cfg;
|
||||
struct io_pgtable_ops ops;
|
||||
};
|
||||
|
||||
/**
|
||||
* struct io_pgtable_init_fns - Alloc/free a set of page tables for a
|
||||
* particular format.
|
||||
*
|
||||
* @alloc: Allocate a set of page tables described by cfg.
|
||||
* @free: Free the page tables associated with iop.
|
||||
*/
|
||||
struct io_pgtable_init_fns {
|
||||
struct io_pgtable *(*alloc)(struct io_pgtable_cfg *cfg, void *cookie);
|
||||
void (*free)(struct io_pgtable *iop);
|
||||
};
|
||||
|
||||
#endif /* __IO_PGTABLE_H */
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
/*
|
||||
* Copyright (C) 2007-2008 Advanced Micro Devices, Inc.
|
||||
* Author: Joerg Roedel <joerg.roedel@amd.com>
|
||||
* Author: Joerg Roedel <jroedel@suse.de>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License version 2 as published
|
||||
|
|
@ -1084,7 +1084,7 @@ int iommu_map(struct iommu_domain *domain, unsigned long iova,
|
|||
if (ret)
|
||||
iommu_unmap(domain, orig_iova, orig_size - size);
|
||||
else
|
||||
trace_map(iova, paddr, size);
|
||||
trace_map(orig_iova, paddr, orig_size);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -1094,6 +1094,7 @@ size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova, size_t size)
|
|||
{
|
||||
size_t unmapped_page, unmapped = 0;
|
||||
unsigned int min_pagesz;
|
||||
unsigned long orig_iova = iova;
|
||||
|
||||
if (unlikely(domain->ops->unmap == NULL ||
|
||||
domain->ops->pgsize_bitmap == 0UL))
|
||||
|
|
@ -1133,7 +1134,7 @@ size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova, size_t size)
|
|||
unmapped += unmapped_page;
|
||||
}
|
||||
|
||||
trace_unmap(iova, 0, size);
|
||||
trace_unmap(orig_iova, size, unmapped);
|
||||
return unmapped;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(iommu_unmap);
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue