lkml.org 
[lkml]   [2020]   [Nov]   [3]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH v6 6/7] arm64: mm: Set ZONE_DMA size based on early IORT scan
    Date
    From: Ard Biesheuvel <ardb@kernel.org>

    We recently introduced a 1 GB sized ZONE_DMA to cater for platforms
    incorporating masters that can address less than 32 bits of DMA, in
    particular the Raspberry Pi 4, which has 4 or 8 GB of DRAM, but has
    peripherals that can only address up to 1 GB (and its PCIe host
    bridge can only access the bottom 3 GB)

    Instructing the DMA layer about these limitations is straight-forward,
    even though we had to fix some issues regarding memory limits set in
    the IORT for named components, and regarding the handling of ACPI _DMA
    methods. However, the DMA layer also needs to be able to allocate
    memory that is guaranteed to meet those DMA constraints, for bounce
    buffering as well as allocating the backing for consistent mappings.

    This is why the 1 GB ZONE_DMA was introduced recently. Unfortunately,
    it turns out the having a 1 GB ZONE_DMA as well as a ZONE_DMA32 causes
    problems with kdump, and potentially in other places where allocations
    cannot cross zone boundaries. Therefore, we should avoid having two
    separate DMA zones when possible.

    So let's do an early scan of the IORT, and only create the ZONE_DMA
    if we encounter any devices that need it. This puts the burden on
    the firmware to describe such limitations in the IORT, which may be
    redundant (and less precise) if _DMA methods are also being provided.
    However, it should be noted that this situation is highly unusual for
    arm64 ACPI machines. Also, the DMA subsystem still gives precedence to
    the _DMA method if implemented, and so we will not lose the ability to
    perform streaming DMA outside the ZONE_DMA if the _DMA method permits
    it.

    Cc: Jeremy Linton <jeremy.linton@arm.com>
    Cc: Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>
    Cc: Nicolas Saenz Julienne <nsaenzjulienne@suse.de>
    Cc: Rob Herring <robh+dt@kernel.org>
    Cc: Christoph Hellwig <hch@lst.de>
    Cc: Robin Murphy <robin.murphy@arm.com>
    Cc: Hanjun Guo <guohanjun@huawei.com>
    Cc: Sudeep Holla <sudeep.holla@arm.com>
    Cc: Anshuman Khandual <anshuman.khandual@arm.com>
    Signed-off-by: Ard Biesheuvel <ardb@kernel.org>
    [nsaenz: unified implementation with DT's counterpart]
    Signed-off-by: Nicolas Saenz Julienne <nsaenzjulienne@suse.de>
    Tested-by: Jeremy Linton <jeremy.linton@arm.com>
    Acked-by: Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>
    Acked-by: Hanjun Guo <guohanjun@huawei.com>

    ---

    Changes since v5:
    - Unify with DT's counterpart, return phys_addr_t

    Changes since v3:
    - Use min_not_zero()
    - Check revision
    - Remove unnecessary #ifdef in zone_sizes_init()

    arch/arm64/mm/init.c | 5 +++-
    drivers/acpi/arm64/iort.c | 55 +++++++++++++++++++++++++++++++++++++++
    include/linux/acpi_iort.h | 4 +++
    3 files changed, 63 insertions(+), 1 deletion(-)

    diff --git a/arch/arm64/mm/init.c b/arch/arm64/mm/init.c
    index a2ce8a9a71a6..ca5d4b10679d 100644
    --- a/arch/arm64/mm/init.c
    +++ b/arch/arm64/mm/init.c
    @@ -29,6 +29,7 @@
    #include <linux/kexec.h>
    #include <linux/crash_dump.h>
    #include <linux/hugetlb.h>
    +#include <linux/acpi_iort.h>

    #include <asm/boot.h>
    #include <asm/fixmap.h>
    @@ -186,11 +187,13 @@ static phys_addr_t __init max_zone_phys(unsigned int zone_bits)
    static void __init zone_sizes_init(unsigned long min, unsigned long max)
    {
    unsigned long max_zone_pfns[MAX_NR_ZONES] = {0};
    + unsigned int __maybe_unused acpi_zone_dma_bits;
    unsigned int __maybe_unused dt_zone_dma_bits;

    #ifdef CONFIG_ZONE_DMA
    + acpi_zone_dma_bits = fls64(acpi_iort_dma_get_max_cpu_address());
    dt_zone_dma_bits = fls64(of_dma_get_max_cpu_address(NULL));
    - zone_dma_bits = min(32U, dt_zone_dma_bits);
    + zone_dma_bits = min3(32U, dt_zone_dma_bits, acpi_zone_dma_bits);
    arm64_dma_phys_limit = max_zone_phys(zone_dma_bits);
    max_zone_pfns[ZONE_DMA] = PFN_DOWN(arm64_dma_phys_limit);
    #endif
    diff --git a/drivers/acpi/arm64/iort.c b/drivers/acpi/arm64/iort.c
    index 9929ff50c0c0..1787406684aa 100644
    --- a/drivers/acpi/arm64/iort.c
    +++ b/drivers/acpi/arm64/iort.c
    @@ -1718,3 +1718,58 @@ void __init acpi_iort_init(void)

    iort_init_platform_devices();
    }
    +
    +#ifdef CONFIG_ZONE_DMA
    +/*
    + * Extract the highest CPU physical address accessible to all DMA masters in
    + * the system. PHYS_ADDR_MAX is returned when no constrained device is found.
    + */
    +phys_addr_t __init acpi_iort_dma_get_max_cpu_address(void)
    +{
    + phys_addr_t limit = PHYS_ADDR_MAX;
    + struct acpi_iort_node *node, *end;
    + struct acpi_table_iort *iort;
    + acpi_status status;
    + int i;
    +
    + if (acpi_disabled)
    + return limit;
    +
    + status = acpi_get_table(ACPI_SIG_IORT, 0,
    + (struct acpi_table_header **)&iort);
    + if (ACPI_FAILURE(status))
    + return limit;
    +
    + node = ACPI_ADD_PTR(struct acpi_iort_node, iort, iort->node_offset);
    + end = ACPI_ADD_PTR(struct acpi_iort_node, iort, iort->header.length);
    +
    + for (i = 0; i < iort->node_count; i++) {
    + if (node >= end)
    + break;
    +
    + switch (node->type) {
    + struct acpi_iort_named_component *ncomp;
    + struct acpi_iort_root_complex *rc;
    + phys_addr_t local_limit;
    +
    + case ACPI_IORT_NODE_NAMED_COMPONENT:
    + ncomp = (struct acpi_iort_named_component *)node->node_data;
    + local_limit = DMA_BIT_MASK(ncomp->memory_address_limit);
    + limit = min_not_zero(limit, local_limit);
    + break;
    +
    + case ACPI_IORT_NODE_PCI_ROOT_COMPLEX:
    + if (node->revision < 1)
    + break;
    +
    + rc = (struct acpi_iort_root_complex *)node->node_data;
    + local_limit = DMA_BIT_MASK(rc->memory_address_limit);
    + limit = min_not_zero(limit, local_limit);
    + break;
    + }
    + node = ACPI_ADD_PTR(struct acpi_iort_node, node, node->length);
    + }
    + acpi_put_table(&iort->header);
    + return limit;
    +}
    +#endif
    diff --git a/include/linux/acpi_iort.h b/include/linux/acpi_iort.h
    index 20a32120bb88..1a12baa58e40 100644
    --- a/include/linux/acpi_iort.h
    +++ b/include/linux/acpi_iort.h
    @@ -38,6 +38,7 @@ void iort_dma_setup(struct device *dev, u64 *dma_addr, u64 *size);
    const struct iommu_ops *iort_iommu_configure_id(struct device *dev,
    const u32 *id_in);
    int iort_iommu_msi_get_resv_regions(struct device *dev, struct list_head *head);
    +phys_addr_t acpi_iort_dma_get_max_cpu_address(void);
    #else
    static inline void acpi_iort_init(void) { }
    static inline u32 iort_msi_map_id(struct device *dev, u32 id)
    @@ -55,6 +56,9 @@ static inline const struct iommu_ops *iort_iommu_configure_id(
    static inline
    int iort_iommu_msi_get_resv_regions(struct device *dev, struct list_head *head)
    { return 0; }
    +
    +static inline phys_addr_t acpi_iort_dma_get_max_cpu_address(void)
    +{ return PHYS_ADDR_MAX; }
    #endif

    #endif /* __ACPI_IORT_H__ */
    --
    2.29.1
    \
     
     \ /
      Last update: 2020-11-03 18:32    [W:4.552 / U:1.008 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site