Get rid of 'remove_new' relic from platform driver struct

[linux.git] / drivers / gpu / drm / imagination / pvr_mmu.c

// SPDX-License-Identifier: GPL-2.0-only OR MIT
/* Copyright (c) 2023 Imagination Technologies Ltd. */

#include "pvr_mmu.h"

#include "pvr_ccb.h"
#include "pvr_device.h"
#include "pvr_fw.h"
#include "pvr_gem.h"
#include "pvr_power.h"
#include "pvr_rogue_fwif.h"
#include "pvr_rogue_mmu_defs.h"

#include <drm/drm_drv.h>
#include <linux/atomic.h>
#include <linux/bitops.h>
#include <linux/dma-mapping.h>
#include <linux/kmemleak.h>
#include <linux/minmax.h>
#include <linux/sizes.h>

#define PVR_SHIFT_FROM_SIZE(size_) (__builtin_ctzll(size_))
#define PVR_MASK_FROM_SIZE(size_) (~((size_) - U64_C(1)))

/*
 * The value of the device page size (%PVR_DEVICE_PAGE_SIZE) is currently
 * pegged to the host page size (%PAGE_SIZE). This chunk of macro goodness both
 * ensures that the selected host page size corresponds to a valid device page
 * size and sets up values needed by the MMU code below.
 */
#if (PVR_DEVICE_PAGE_SIZE == SZ_4K)
# define ROGUE_MMUCTRL_PAGE_SIZE_X ROGUE_MMUCTRL_PAGE_SIZE_4KB
# define ROGUE_MMUCTRL_PAGE_X_RANGE_SHIFT ROGUE_MMUCTRL_PAGE_4KB_RANGE_SHIFT
# define ROGUE_MMUCTRL_PAGE_X_RANGE_CLRMSK ROGUE_MMUCTRL_PAGE_4KB_RANGE_CLRMSK
#elif (PVR_DEVICE_PAGE_SIZE == SZ_16K)
# define ROGUE_MMUCTRL_PAGE_SIZE_X ROGUE_MMUCTRL_PAGE_SIZE_16KB
# define ROGUE_MMUCTRL_PAGE_X_RANGE_SHIFT ROGUE_MMUCTRL_PAGE_16KB_RANGE_SHIFT
# define ROGUE_MMUCTRL_PAGE_X_RANGE_CLRMSK ROGUE_MMUCTRL_PAGE_16KB_RANGE_CLRMSK
#elif (PVR_DEVICE_PAGE_SIZE == SZ_64K)
# define ROGUE_MMUCTRL_PAGE_SIZE_X ROGUE_MMUCTRL_PAGE_SIZE_64KB
# define ROGUE_MMUCTRL_PAGE_X_RANGE_SHIFT ROGUE_MMUCTRL_PAGE_64KB_RANGE_SHIFT
# define ROGUE_MMUCTRL_PAGE_X_RANGE_CLRMSK ROGUE_MMUCTRL_PAGE_64KB_RANGE_CLRMSK
#elif (PVR_DEVICE_PAGE_SIZE == SZ_256K)
# define ROGUE_MMUCTRL_PAGE_SIZE_X ROGUE_MMUCTRL_PAGE_SIZE_256KB
# define ROGUE_MMUCTRL_PAGE_X_RANGE_SHIFT ROGUE_MMUCTRL_PAGE_256KB_RANGE_SHIFT
# define ROGUE_MMUCTRL_PAGE_X_RANGE_CLRMSK ROGUE_MMUCTRL_PAGE_256KB_RANGE_CLRMSK
#elif (PVR_DEVICE_PAGE_SIZE == SZ_1M)
# define ROGUE_MMUCTRL_PAGE_SIZE_X ROGUE_MMUCTRL_PAGE_SIZE_1MB
# define ROGUE_MMUCTRL_PAGE_X_RANGE_SHIFT ROGUE_MMUCTRL_PAGE_1MB_RANGE_SHIFT
# define ROGUE_MMUCTRL_PAGE_X_RANGE_CLRMSK ROGUE_MMUCTRL_PAGE_1MB_RANGE_CLRMSK
#elif (PVR_DEVICE_PAGE_SIZE == SZ_2M)
# define ROGUE_MMUCTRL_PAGE_SIZE_X ROGUE_MMUCTRL_PAGE_SIZE_2MB
# define ROGUE_MMUCTRL_PAGE_X_RANGE_SHIFT ROGUE_MMUCTRL_PAGE_2MB_RANGE_SHIFT
# define ROGUE_MMUCTRL_PAGE_X_RANGE_CLRMSK ROGUE_MMUCTRL_PAGE_2MB_RANGE_CLRMSK
#else
# error Unsupported device page size PVR_DEVICE_PAGE_SIZE
#endif

#define ROGUE_MMUCTRL_ENTRIES_PT_VALUE_X   \
        (ROGUE_MMUCTRL_ENTRIES_PT_VALUE >> \
         (PVR_DEVICE_PAGE_SHIFT - PVR_SHIFT_FROM_SIZE(SZ_4K)))

enum pvr_mmu_sync_level {
        PVR_MMU_SYNC_LEVEL_NONE = -1,
        PVR_MMU_SYNC_LEVEL_0 = 0,
        PVR_MMU_SYNC_LEVEL_1 = 1,
        PVR_MMU_SYNC_LEVEL_2 = 2,
};

#define PVR_MMU_SYNC_LEVEL_0_FLAGS (ROGUE_FWIF_MMUCACHEDATA_FLAGS_PT | \
                                    ROGUE_FWIF_MMUCACHEDATA_FLAGS_INTERRUPT | \
                                    ROGUE_FWIF_MMUCACHEDATA_FLAGS_TLB)
#define PVR_MMU_SYNC_LEVEL_1_FLAGS (PVR_MMU_SYNC_LEVEL_0_FLAGS | ROGUE_FWIF_MMUCACHEDATA_FLAGS_PD)
#define PVR_MMU_SYNC_LEVEL_2_FLAGS (PVR_MMU_SYNC_LEVEL_1_FLAGS | ROGUE_FWIF_MMUCACHEDATA_FLAGS_PC)

/**
 * pvr_mmu_set_flush_flags() - Set MMU cache flush flags for next call to
 *                             pvr_mmu_flush_exec().
 * @pvr_dev: Target PowerVR device.
 * @flags: MMU flush flags. Must be one of %PVR_MMU_SYNC_LEVEL_*_FLAGS.
 *
 * This function must be called following any possible change to the MMU page
 * tables.
 */
static void pvr_mmu_set_flush_flags(struct pvr_device *pvr_dev, u32 flags)
{
        atomic_fetch_or(flags, &pvr_dev->mmu_flush_cache_flags);
}

/**
 * pvr_mmu_flush_request_all() - Request flush of all MMU caches when
 * subsequently calling pvr_mmu_flush_exec().
 * @pvr_dev: Target PowerVR device.
 *
 * This function must be called following any possible change to the MMU page
 * tables.
 */
void pvr_mmu_flush_request_all(struct pvr_device *pvr_dev)
{
        pvr_mmu_set_flush_flags(pvr_dev, PVR_MMU_SYNC_LEVEL_2_FLAGS);
}

/**
 * pvr_mmu_flush_exec() - Execute a flush of all MMU caches previously
 * requested.
 * @pvr_dev: Target PowerVR device.
 * @wait: Do not return until the flush is completed.
 *
 * This function must be called prior to submitting any new GPU job. The flush
 * will complete before the jobs are scheduled, so this can be called once after
 * a series of maps. However, a single unmap should always be immediately
 * followed by a flush and it should be explicitly waited by setting @wait.
 *
 * As a failure to flush the MMU caches could risk memory corruption, if the
 * flush fails (implying the firmware is not responding) then the GPU device is
 * marked as lost.
 *
 * Returns:
 *  * 0 on success when @wait is true, or
 *  * -%EIO if the device is unavailable, or
 *  * Any error encountered while submitting the flush command via the KCCB.
 */
int pvr_mmu_flush_exec(struct pvr_device *pvr_dev, bool wait)
{
        struct rogue_fwif_kccb_cmd cmd_mmu_cache = {};
        struct rogue_fwif_mmucachedata *cmd_mmu_cache_data =
                &cmd_mmu_cache.cmd_data.mmu_cache_data;
        int err = 0;
        u32 slot;
        int idx;

        if (!drm_dev_enter(from_pvr_device(pvr_dev), &idx))
                return -EIO;

        /* Can't flush MMU if the firmware hasn't booted yet. */
        if (!pvr_dev->fw_dev.booted)
                goto err_drm_dev_exit;

        cmd_mmu_cache_data->cache_flags =
                atomic_xchg(&pvr_dev->mmu_flush_cache_flags, 0);

        if (!cmd_mmu_cache_data->cache_flags)
                goto err_drm_dev_exit;

        cmd_mmu_cache.cmd_type = ROGUE_FWIF_KCCB_CMD_MMUCACHE;

        pvr_fw_object_get_fw_addr(pvr_dev->fw_dev.mem.mmucache_sync_obj,
                                  &cmd_mmu_cache_data->mmu_cache_sync_fw_addr);
        cmd_mmu_cache_data->mmu_cache_sync_update_value = 0;

        err = pvr_kccb_send_cmd(pvr_dev, &cmd_mmu_cache, &slot);
        if (err)
                goto err_reset_and_retry;

        err = pvr_kccb_wait_for_completion(pvr_dev, slot, HZ, NULL);
        if (err)
                goto err_reset_and_retry;

        drm_dev_exit(idx);

        return 0;

err_reset_and_retry:
        /*
         * Flush command failure is most likely the result of a firmware lockup. Hard
         * reset the GPU and retry.
         */
        err = pvr_power_reset(pvr_dev, true);
        if (err)
                goto err_drm_dev_exit; /* Device is lost. */

        /* Retry sending flush request. */
        err = pvr_kccb_send_cmd(pvr_dev, &cmd_mmu_cache, &slot);
        if (err) {
                pvr_device_lost(pvr_dev);
                goto err_drm_dev_exit;
        }

        if (wait) {
                err = pvr_kccb_wait_for_completion(pvr_dev, slot, HZ, NULL);
                if (err)
                        pvr_device_lost(pvr_dev);
        }

err_drm_dev_exit:
        drm_dev_exit(idx);

        return err;
}

/**
 * DOC: PowerVR Virtual Memory Handling
 */
/**
 * DOC: PowerVR Virtual Memory Handling (constants)
 *
 * .. c:macro:: PVR_IDX_INVALID
 *
 *    Default value for a u16-based index.
 *
 *    This value cannot be zero, since zero is a valid index value.
 */
#define PVR_IDX_INVALID ((u16)(-1))

/**
 * DOC: MMU backing pages
 */
/**
 * DOC: MMU backing pages (constants)
 *
 * .. c:macro:: PVR_MMU_BACKING_PAGE_SIZE
 *
 *    Page size of a PowerVR device's integrated MMU. The CPU page size must be
 *    at least as large as this value for the current implementation; this is
 *    checked at compile-time.
 */
#define PVR_MMU_BACKING_PAGE_SIZE SZ_4K
static_assert(PAGE_SIZE >= PVR_MMU_BACKING_PAGE_SIZE);

/**
 * struct pvr_mmu_backing_page - Represents a single page used to back a page
 *                              table of any level.
 * @dma_addr: DMA address of this page.
 * @host_ptr: CPU address of this page.
 * @pvr_dev: The PowerVR device to which this page is associated. **For
 *           internal use only.**
 */
struct pvr_mmu_backing_page {
        dma_addr_t dma_addr;
        void *host_ptr;
/* private: internal use only */
        struct page *raw_page;
        struct pvr_device *pvr_dev;
};

/**
 * pvr_mmu_backing_page_init() - Initialize a MMU backing page.
 * @page: Target backing page.
 * @pvr_dev: Target PowerVR device.
 *
 * This function performs three distinct operations:
 *
 * 1. Allocate a single page,
 * 2. Map the page to the CPU, and
 * 3. Map the page to DMA-space.
 *
 * It is expected that @page be zeroed (e.g. from kzalloc()) before calling
 * this function.
 *
 * Return:
 *  * 0 on success, or
 *  * -%ENOMEM if allocation of the backing page or mapping of the backing
 *    page to DMA fails.
 */
static int
pvr_mmu_backing_page_init(struct pvr_mmu_backing_page *page,
                          struct pvr_device *pvr_dev)
{
        struct device *dev = from_pvr_device(pvr_dev)->dev;

        struct page *raw_page;
        int err;

        dma_addr_t dma_addr;
        void *host_ptr;

        raw_page = alloc_page(__GFP_ZERO | GFP_KERNEL);
        if (!raw_page)
                return -ENOMEM;

        host_ptr = vmap(&raw_page, 1, VM_MAP, pgprot_writecombine(PAGE_KERNEL));
        if (!host_ptr) {
                err = -ENOMEM;
                goto err_free_page;
        }

        dma_addr = dma_map_page(dev, raw_page, 0, PVR_MMU_BACKING_PAGE_SIZE,
                                DMA_TO_DEVICE);
        if (dma_mapping_error(dev, dma_addr)) {
                err = -ENOMEM;
                goto err_unmap_page;
        }

        page->dma_addr = dma_addr;
        page->host_ptr = host_ptr;
        page->pvr_dev = pvr_dev;
        page->raw_page = raw_page;
        kmemleak_alloc(page->host_ptr, PAGE_SIZE, 1, GFP_KERNEL);

        return 0;

err_unmap_page:
        vunmap(host_ptr);

err_free_page:
        __free_page(raw_page);

        return err;
}

/**
 * pvr_mmu_backing_page_fini() - Teardown a MMU backing page.
 * @page: Target backing page.
 *
 * This function performs the mirror operations to pvr_mmu_backing_page_init(),
 * in reverse order:
 *
 * 1. Unmap the page from DMA-space,
 * 2. Unmap the page from the CPU, and
 * 3. Free the page.
 *
 * It also zeros @page.
 *
 * It is a no-op to call this function a second (or further) time on any @page.
 */
static void
pvr_mmu_backing_page_fini(struct pvr_mmu_backing_page *page)
{
        struct device *dev;

        /* Do nothing if no allocation is present. */
        if (!page->pvr_dev)
                return;

        dev = from_pvr_device(page->pvr_dev)->dev;

        dma_unmap_page(dev, page->dma_addr, PVR_MMU_BACKING_PAGE_SIZE,
                       DMA_TO_DEVICE);

        kmemleak_free(page->host_ptr);
        vunmap(page->host_ptr);

        __free_page(page->raw_page);

        memset(page, 0, sizeof(*page));
}

/**
 * pvr_mmu_backing_page_sync() - Flush a MMU backing page from the CPU to the
 * device.
 * @page: Target backing page.
 * @flags: MMU flush flags. Must be one of %PVR_MMU_SYNC_LEVEL_*_FLAGS.
 *
 * .. caution::
 *
 *    **This is potentially an expensive function call.** Only call
 *    pvr_mmu_backing_page_sync() once you're sure you have no more changes to
 *    make to the backing page in the immediate future.
 */
static void
pvr_mmu_backing_page_sync(struct pvr_mmu_backing_page *page, u32 flags)
{
        struct pvr_device *pvr_dev = page->pvr_dev;
        struct device *dev;

        /*
         * Do nothing if no allocation is present. This may be the case if
         * we are unmapping pages.
         */
        if (!pvr_dev)
                return;

        dev = from_pvr_device(pvr_dev)->dev;

        dma_sync_single_for_device(dev, page->dma_addr,
                                   PVR_MMU_BACKING_PAGE_SIZE, DMA_TO_DEVICE);

        pvr_mmu_set_flush_flags(pvr_dev, flags);
}

/**
 * DOC: Raw page tables
 */

#define PVR_PAGE_TABLE_TYPEOF_ENTRY(level_) \
        typeof_member(struct pvr_page_table_l##level_##_entry_raw, val)

#define PVR_PAGE_TABLE_FIELD_GET(level_, name_, field_, entry_)           \
        (((entry_).val &                                           \
          ~ROGUE_MMUCTRL_##name_##_DATA_##field_##_CLRMSK) >> \
         ROGUE_MMUCTRL_##name_##_DATA_##field_##_SHIFT)

#define PVR_PAGE_TABLE_FIELD_PREP(level_, name_, field_, val_)            \
        ((((PVR_PAGE_TABLE_TYPEOF_ENTRY(level_))(val_))            \
          << ROGUE_MMUCTRL_##name_##_DATA_##field_##_SHIFT) & \
         ~ROGUE_MMUCTRL_##name_##_DATA_##field_##_CLRMSK)

/**
 * struct pvr_page_table_l2_entry_raw - A single entry in a level 2 page table.
 * @val: The raw value of this entry.
 *
 * This type is a structure for type-checking purposes. At compile-time, its
 * size is checked against %ROGUE_MMUCTRL_ENTRY_SIZE_PC_VALUE.
 *
 * The value stored in this structure can be decoded using the following bitmap:
 *
 * .. flat-table::
 *    :widths: 1 5
 *    :stub-columns: 1
 *
 *    * - 31..4
 *      - **Level 1 Page Table Base Address:** Bits 39..12 of the L1
 *        page table base address, which is 4KiB aligned.
 *
 *    * - 3..2
 *      - *(reserved)*
 *
 *    * - 1
 *      - **Pending:** When valid bit is not set, indicates that a valid
 *        entry is pending and the MMU should wait for the driver to map
 *        the entry. This is used to support page demand mapping of
 *        memory.
 *
 *    * - 0
 *      - **Valid:** Indicates that the entry contains a valid L1 page
 *        table. If the valid bit is not set, then an attempted use of
 *        the page would result in a page fault.
 */
struct pvr_page_table_l2_entry_raw {
        u32 val;
} __packed;
static_assert(sizeof(struct pvr_page_table_l2_entry_raw) * 8 ==
              ROGUE_MMUCTRL_ENTRY_SIZE_PC_VALUE);

static bool
pvr_page_table_l2_entry_raw_is_valid(struct pvr_page_table_l2_entry_raw entry)
{
        return PVR_PAGE_TABLE_FIELD_GET(2, PC, VALID, entry);
}

/**
 * pvr_page_table_l2_entry_raw_set() - Write a valid entry into a raw level 2
 *                                     page table.
 * @entry: Target raw level 2 page table entry.
 * @child_table_dma_addr: DMA address of the level 1 page table to be
 *                        associated with @entry.
 *
 * When calling this function, @child_table_dma_addr must be a valid DMA
 * address and a multiple of %ROGUE_MMUCTRL_PC_DATA_PD_BASE_ALIGNSIZE.
 */
static void
pvr_page_table_l2_entry_raw_set(struct pvr_page_table_l2_entry_raw *entry,
                                dma_addr_t child_table_dma_addr)
{
        child_table_dma_addr >>= ROGUE_MMUCTRL_PC_DATA_PD_BASE_ALIGNSHIFT;

        WRITE_ONCE(entry->val,
                   PVR_PAGE_TABLE_FIELD_PREP(2, PC, VALID, true) |
                   PVR_PAGE_TABLE_FIELD_PREP(2, PC, ENTRY_PENDING, false) |
                   PVR_PAGE_TABLE_FIELD_PREP(2, PC, PD_BASE, child_table_dma_addr));
}

static void
pvr_page_table_l2_entry_raw_clear(struct pvr_page_table_l2_entry_raw *entry)
{
        WRITE_ONCE(entry->val, 0);
}

/**
 * struct pvr_page_table_l1_entry_raw - A single entry in a level 1 page table.
 * @val: The raw value of this entry.
 *
 * This type is a structure for type-checking purposes. At compile-time, its
 * size is checked against %ROGUE_MMUCTRL_ENTRY_SIZE_PD_VALUE.
 *
 * The value stored in this structure can be decoded using the following bitmap:
 *
 * .. flat-table::
 *    :widths: 1 5
 *    :stub-columns: 1
 *
 *    * - 63..41
 *      - *(reserved)*
 *
 *    * - 40
 *      - **Pending:** When valid bit is not set, indicates that a valid entry
 *        is pending and the MMU should wait for the driver to map the entry.
 *        This is used to support page demand mapping of memory.
 *
 *    * - 39..5
 *      - **Level 0 Page Table Base Address:** The way this value is
 *        interpreted depends on the page size. Bits not specified in the
 *        table below (e.g. bits 11..5 for page size 4KiB) should be
 *        considered reserved.
 *
 *        This table shows the bits used in an L1 page table entry to
 *        represent the Physical Table Base Address for a given Page Size.
 *        Since each L1 page table entry covers 2MiB of address space, the
 *        maximum page size is 2MiB.
 *
 *        .. flat-table::
 *           :widths: 1 1 1 1
 *           :header-rows: 1
 *           :stub-columns: 1
 *
 *           * - Page size
 *             - L0 page table base address bits
 *             - Number of L0 page table entries
 *             - Size of L0 page table
 *
 *           * - 4KiB
 *             - 39..12
 *             - 512
 *             - 4KiB
 *
 *           * - 16KiB
 *             - 39..10
 *             - 128
 *             - 1KiB
 *
 *           * - 64KiB
 *             - 39..8
 *             - 32
 *             - 256B
 *
 *           * - 256KiB
 *             - 39..6
 *             - 8
 *             - 64B
 *
 *           * - 1MiB
 *             - 39..5 (4 = '0')
 *             - 2
 *             - 16B
 *
 *           * - 2MiB
 *             - 39..5 (4..3 = '00')
 *             - 1
 *             - 8B
 *
 *    * - 4
 *      - *(reserved)*
 *
 *    * - 3..1
 *      - **Page Size:** Sets the page size, from 4KiB to 2MiB.
 *
 *    * - 0
 *      - **Valid:** Indicates that the entry contains a valid L0 page table.
 *        If the valid bit is not set, then an attempted use of the page would
 *        result in a page fault.
 */
struct pvr_page_table_l1_entry_raw {
        u64 val;
} __packed;
static_assert(sizeof(struct pvr_page_table_l1_entry_raw) * 8 ==
              ROGUE_MMUCTRL_ENTRY_SIZE_PD_VALUE);

static bool
pvr_page_table_l1_entry_raw_is_valid(struct pvr_page_table_l1_entry_raw entry)
{
        return PVR_PAGE_TABLE_FIELD_GET(1, PD, VALID, entry);
}

/**
 * pvr_page_table_l1_entry_raw_set() - Write a valid entry into a raw level 1
 *                                     page table.
 * @entry: Target raw level 1 page table entry.
 * @child_table_dma_addr: DMA address of the level 0 page table to be
 *                        associated with @entry.
 *
 * When calling this function, @child_table_dma_addr must be a valid DMA
 * address and a multiple of 4 KiB.
 */
static void
pvr_page_table_l1_entry_raw_set(struct pvr_page_table_l1_entry_raw *entry,
                                dma_addr_t child_table_dma_addr)
{
        WRITE_ONCE(entry->val,
                   PVR_PAGE_TABLE_FIELD_PREP(1, PD, VALID, true) |
                   PVR_PAGE_TABLE_FIELD_PREP(1, PD, ENTRY_PENDING, false) |
                   PVR_PAGE_TABLE_FIELD_PREP(1, PD, PAGE_SIZE, ROGUE_MMUCTRL_PAGE_SIZE_X) |
                   /*
                    * The use of a 4K-specific macro here is correct. It is
                    * a future optimization to allocate sub-host-page-sized
                    * blocks for individual tables, so the condition that any
                    * page table address is aligned to the size of the
                    * largest (a 4KB) table currently holds.
                    */
                   (child_table_dma_addr & ~ROGUE_MMUCTRL_PT_BASE_4KB_RANGE_CLRMSK));
}

static void
pvr_page_table_l1_entry_raw_clear(struct pvr_page_table_l1_entry_raw *entry)
{
        WRITE_ONCE(entry->val, 0);
}

/**
 * struct pvr_page_table_l0_entry_raw - A single entry in a level 0 page table.
 * @val: The raw value of this entry.
 *
 * This type is a structure for type-checking purposes. At compile-time, its
 * size is checked against %ROGUE_MMUCTRL_ENTRY_SIZE_PT_VALUE.
 *
 * The value stored in this structure can be decoded using the following bitmap:
 *
 * .. flat-table::
 *    :widths: 1 5
 *    :stub-columns: 1
 *
 *    * - 63
 *      - *(reserved)*
 *
 *    * - 62
 *      - **PM/FW Protect:** Indicates a protected region which only the
 *        Parameter Manager (PM) or firmware processor can write to.
 *
 *    * - 61..40
 *      - **VP Page (High):** Virtual-physical page used for Parameter Manager
 *        (PM) memory. This field is only used if the additional level of PB
 *        virtualization is enabled. The VP Page field is needed by the PM in
 *        order to correctly reconstitute the free lists after render
 *        completion. This (High) field holds bits 39..18 of the value; the
 *        Low field holds bits 17..12. Bits 11..0 are always zero because the
 *        value is always aligned to the 4KiB page size.
 *
 *    * - 39..12
 *      - **Physical Page Address:** The way this value is interpreted depends
 *        on the page size. Bits not specified in the table below (e.g. bits
 *        20..12 for page size 2MiB) should be considered reserved.
 *
 *        This table shows the bits used in an L0 page table entry to represent
 *        the Physical Page Address for a given page size (as defined in the
 *        associated L1 page table entry).
 *
 *        .. flat-table::
 *           :widths: 1 1
 *           :header-rows: 1
 *           :stub-columns: 1
 *
 *           * - Page size
 *             - Physical address bits
 *
 *           * - 4KiB
 *             - 39..12
 *
 *           * - 16KiB
 *             - 39..14
 *
 *           * - 64KiB
 *             - 39..16
 *
 *           * - 256KiB
 *             - 39..18
 *
 *           * - 1MiB
 *             - 39..20
 *
 *           * - 2MiB
 *             - 39..21
 *
 *    * - 11..6
 *      - **VP Page (Low):** Continuation of VP Page (High).
 *
 *    * - 5
 *      - **Pending:** When valid bit is not set, indicates that a valid entry
 *        is pending and the MMU should wait for the driver to map the entry.
 *        This is used to support page demand mapping of memory.
 *
 *    * - 4
 *      - **PM Src:** Set on Parameter Manager (PM) allocated page table
 *        entries when indicated by the PM. Note that this bit will only be set
 *        by the PM, not by the device driver.
 *
 *    * - 3
 *      - **SLC Bypass Control:** Specifies requests to this page should bypass
 *        the System Level Cache (SLC), if enabled in SLC configuration.
 *
 *    * - 2
 *      - **Cache Coherency:** Indicates that the page is coherent (i.e. it
 *        does not require a cache flush between operations on the CPU and the
 *        device).
 *
 *    * - 1
 *      - **Read Only:** If set, this bit indicates that the page is read only.
 *        An attempted write to this page would result in a write-protection
 *        fault.
 *
 *    * - 0
 *      - **Valid:** Indicates that the entry contains a valid page. If the
 *        valid bit is not set, then an attempted use of the page would result
 *        in a page fault.
 */
struct pvr_page_table_l0_entry_raw {
        u64 val;
} __packed;
static_assert(sizeof(struct pvr_page_table_l0_entry_raw) * 8 ==
              ROGUE_MMUCTRL_ENTRY_SIZE_PT_VALUE);

/**
 * struct pvr_page_flags_raw - The configurable flags from a single entry in a
 *                             level 0 page table.
 * @val: The raw value of these flags. Since these are a strict subset of
 *       &struct pvr_page_table_l0_entry_raw; use that type for our member here.
 *
 * The flags stored in this type are: PM/FW Protect; SLC Bypass Control; Cache
 * Coherency, and Read Only (bits 62, 3, 2 and 1 respectively).
 *
 * This type should never be instantiated directly; instead use
 * pvr_page_flags_raw_create() to ensure only valid bits of @val are set.
 */
struct pvr_page_flags_raw {
        struct pvr_page_table_l0_entry_raw val;
} __packed;
static_assert(sizeof(struct pvr_page_flags_raw) ==
              sizeof(struct pvr_page_table_l0_entry_raw));

static bool
pvr_page_table_l0_entry_raw_is_valid(struct pvr_page_table_l0_entry_raw entry)
{
        return PVR_PAGE_TABLE_FIELD_GET(0, PT, VALID, entry);
}

/**
 * pvr_page_table_l0_entry_raw_set() - Write a valid entry into a raw level 0
 *                                     page table.
 * @entry: Target raw level 0 page table entry.
 * @dma_addr: DMA address of the physical page to be associated with @entry.
 * @flags: Options to be set on @entry.
 *
 * When calling this function, @child_table_dma_addr must be a valid DMA
 * address and a multiple of %PVR_DEVICE_PAGE_SIZE.
 *
 * The @flags parameter is directly assigned into @entry. It is the callers
 * responsibility to ensure that only bits specified in
 * &struct pvr_page_flags_raw are set in @flags.
 */
static void
pvr_page_table_l0_entry_raw_set(struct pvr_page_table_l0_entry_raw *entry,
                                dma_addr_t dma_addr,
                                struct pvr_page_flags_raw flags)
{
        WRITE_ONCE(entry->val, PVR_PAGE_TABLE_FIELD_PREP(0, PT, VALID, true) |
                               PVR_PAGE_TABLE_FIELD_PREP(0, PT, ENTRY_PENDING, false) |
                               (dma_addr & ~ROGUE_MMUCTRL_PAGE_X_RANGE_CLRMSK) |
                               flags.val.val);
}

static void
pvr_page_table_l0_entry_raw_clear(struct pvr_page_table_l0_entry_raw *entry)
{
        WRITE_ONCE(entry->val, 0);
}

/**
 * pvr_page_flags_raw_create() - Initialize the flag bits of a raw level 0 page
 *                               table entry.
 * @read_only: This page is read-only (see: Read Only).
 * @cache_coherent: This page does not require cache flushes (see: Cache
 *                  Coherency).
 * @slc_bypass: This page bypasses the device cache (see: SLC Bypass Control).
 * @pm_fw_protect: This page is only for use by the firmware or Parameter
 *                 Manager (see PM/FW Protect).
 *
 * For more details on the use of these four options, see their respective
 * entries in the table under &struct pvr_page_table_l0_entry_raw.
 *
 * Return:
 * A new &struct pvr_page_flags_raw instance which can be passed directly to
 * pvr_page_table_l0_entry_raw_set() or pvr_page_table_l0_insert().
 */
static struct pvr_page_flags_raw
pvr_page_flags_raw_create(bool read_only, bool cache_coherent, bool slc_bypass,
                          bool pm_fw_protect)
{
        struct pvr_page_flags_raw flags;

        flags.val.val =
                PVR_PAGE_TABLE_FIELD_PREP(0, PT, READ_ONLY, read_only) |
                PVR_PAGE_TABLE_FIELD_PREP(0, PT, CC, cache_coherent) |
                PVR_PAGE_TABLE_FIELD_PREP(0, PT, SLC_BYPASS_CTRL, slc_bypass) |
                PVR_PAGE_TABLE_FIELD_PREP(0, PT, PM_META_PROTECT, pm_fw_protect);

        return flags;
}

/**
 * struct pvr_page_table_l2_raw - The raw data of a level 2 page table.
 *
 * This type is a structure for type-checking purposes. At compile-time, its
 * size is checked against %PVR_MMU_BACKING_PAGE_SIZE.
 */
struct pvr_page_table_l2_raw {
        /** @entries: The raw values of this table. */
        struct pvr_page_table_l2_entry_raw
                entries[ROGUE_MMUCTRL_ENTRIES_PC_VALUE];
} __packed;
static_assert(sizeof(struct pvr_page_table_l2_raw) == PVR_MMU_BACKING_PAGE_SIZE);

/**
 * struct pvr_page_table_l1_raw - The raw data of a level 1 page table.
 *
 * This type is a structure for type-checking purposes. At compile-time, its
 * size is checked against %PVR_MMU_BACKING_PAGE_SIZE.
 */
struct pvr_page_table_l1_raw {
        /** @entries: The raw values of this table. */
        struct pvr_page_table_l1_entry_raw
                entries[ROGUE_MMUCTRL_ENTRIES_PD_VALUE];
} __packed;
static_assert(sizeof(struct pvr_page_table_l1_raw) == PVR_MMU_BACKING_PAGE_SIZE);

/**
 * struct pvr_page_table_l0_raw - The raw data of a level 0 page table.
 *
 * This type is a structure for type-checking purposes. At compile-time, its
 * size is checked against %PVR_MMU_BACKING_PAGE_SIZE.
 *
 * .. caution::
 *
 *    The size of level 0 page tables is variable depending on the page size
 *    specified in the associated level 1 page table entry. Since the device
 *    page size in use is pegged to the host page size, it cannot vary at
 *    runtime. This structure is therefore only defined to contain the required
 *    number of entries for the current device page size. **You should never
 *    read or write beyond the last supported entry.**
 */
struct pvr_page_table_l0_raw {
        /** @entries: The raw values of this table. */
        struct pvr_page_table_l0_entry_raw
                entries[ROGUE_MMUCTRL_ENTRIES_PT_VALUE_X];
} __packed;
static_assert(sizeof(struct pvr_page_table_l0_raw) <= PVR_MMU_BACKING_PAGE_SIZE);

/**
 * DOC: Mirror page tables
 */

/*
 * We pre-declare these types because they cross-depend on pointers to each
 * other.
 */
struct pvr_page_table_l1;
struct pvr_page_table_l0;

/**
 * struct pvr_page_table_l2 - A wrapped level 2 page table.
 *
 * To access the raw part of this table, use pvr_page_table_l2_get_raw().
 * Alternatively to access a raw entry directly, use
 * pvr_page_table_l2_get_entry_raw().
 *
 * A level 2 page table forms the root of the page table tree structure, so
 * this type has no &parent or &parent_idx members.
 */
struct pvr_page_table_l2 {
        /**
         * @entries: The children of this node in the page table tree
         * structure. These are also mirror tables. The indexing of this array
         * is identical to that of the raw equivalent
         * (&pvr_page_table_l1_raw.entries).
         */
        struct pvr_page_table_l1 *entries[ROGUE_MMUCTRL_ENTRIES_PC_VALUE];

        /**
         * @backing_page: A handle to the memory which holds the raw
         * equivalent of this table. **For internal use only.**
         */
        struct pvr_mmu_backing_page backing_page;

        /**
         * @entry_count: The current number of valid entries (that we know of)
         * in this table. This value is essentially a refcount - the table is
         * destroyed when this value is decremented to zero by
         * pvr_page_table_l2_remove().
         */
        u16 entry_count;
};

/**
 * pvr_page_table_l2_init() - Initialize a level 2 page table.
 * @table: Target level 2 page table.
 * @pvr_dev: Target PowerVR device
 *
 * It is expected that @table be zeroed (e.g. from kzalloc()) before calling
 * this function.
 *
 * Return:
 *  * 0 on success, or
 *  * Any error encountered while intializing &table->backing_page using
 *    pvr_mmu_backing_page_init().
 */
static int
pvr_page_table_l2_init(struct pvr_page_table_l2 *table,
                       struct pvr_device *pvr_dev)
{
        return pvr_mmu_backing_page_init(&table->backing_page, pvr_dev);
}

/**
 * pvr_page_table_l2_fini() - Teardown a level 2 page table.
 * @table: Target level 2 page table.
 *
 * It is an error to attempt to use @table after calling this function.
 */
static void
pvr_page_table_l2_fini(struct pvr_page_table_l2 *table)
{
        pvr_mmu_backing_page_fini(&table->backing_page);
}

/**
 * pvr_page_table_l2_sync() - Flush a level 2 page table from the CPU to the
 *                            device.
 * @table: Target level 2 page table.
 *
 * This is just a thin wrapper around pvr_mmu_backing_page_sync(), so the
 * warning there applies here too: **Only call pvr_page_table_l2_sync() once
 * you're sure you have no more changes to make to** @table **in the immediate
 * future.**
 *
 * If child level 1 page tables of @table also need to be flushed, this should
 * be done first using pvr_page_table_l1_sync() *before* calling this function.
 */
static void
pvr_page_table_l2_sync(struct pvr_page_table_l2 *table)
{
        pvr_mmu_backing_page_sync(&table->backing_page, PVR_MMU_SYNC_LEVEL_2_FLAGS);
}

/**
 * pvr_page_table_l2_get_raw() - Access the raw equivalent of a mirror level 2
 *                               page table.
 * @table: Target level 2 page table.
 *
 * Essentially returns the CPU address of the raw equivalent of @table, cast to
 * a &struct pvr_page_table_l2_raw pointer.
 *
 * You probably want to call pvr_page_table_l2_get_entry_raw() instead.
 *
 * Return:
 * The raw equivalent of @table.
 */
static struct pvr_page_table_l2_raw *
pvr_page_table_l2_get_raw(struct pvr_page_table_l2 *table)
{
        return table->backing_page.host_ptr;
}

/**
 * pvr_page_table_l2_get_entry_raw() - Access an entry from the raw equivalent
 *                                     of a mirror level 2 page table.
 * @table: Target level 2 page table.
 * @idx: Index of the entry to access.
 *
 * Technically this function returns a pointer to a slot in a raw level 2 page
 * table, since the returned "entry" is not guaranteed to be valid. The caller
 * must verify the validity of the entry at the returned address (perhaps using
 * pvr_page_table_l2_entry_raw_is_valid()) before reading or overwriting it.
 *
 * The value of @idx is not checked here; it is the callers responsibility to
 * ensure @idx refers to a valid index within @table before dereferencing the
 * returned pointer.
 *
 * Return:
 * A pointer to the requested raw level 2 page table entry.
 */
static struct pvr_page_table_l2_entry_raw *
pvr_page_table_l2_get_entry_raw(struct pvr_page_table_l2 *table, u16 idx)
{
        return &pvr_page_table_l2_get_raw(table)->entries[idx];
}

/**
 * pvr_page_table_l2_entry_is_valid() - Check if a level 2 page table entry is
 *                                      marked as valid.
 * @table: Target level 2 page table.
 * @idx: Index of the entry to check.
 *
 * The value of @idx is not checked here; it is the callers responsibility to
 * ensure @idx refers to a valid index within @table before calling this
 * function.
 */
static bool
pvr_page_table_l2_entry_is_valid(struct pvr_page_table_l2 *table, u16 idx)
{
        struct pvr_page_table_l2_entry_raw entry_raw =
                *pvr_page_table_l2_get_entry_raw(table, idx);

        return pvr_page_table_l2_entry_raw_is_valid(entry_raw);
}

/**
 * struct pvr_page_table_l1 - A wrapped level 1 page table.
 *
 * To access the raw part of this table, use pvr_page_table_l1_get_raw().
 * Alternatively to access a raw entry directly, use
 * pvr_page_table_l1_get_entry_raw().
 */
struct pvr_page_table_l1 {
        /**
         * @entries: The children of this node in the page table tree
         * structure. These are also mirror tables. The indexing of this array
         * is identical to that of the raw equivalent
         * (&pvr_page_table_l0_raw.entries).
         */
        struct pvr_page_table_l0 *entries[ROGUE_MMUCTRL_ENTRIES_PD_VALUE];

        /**
         * @backing_page: A handle to the memory which holds the raw
         * equivalent of this table. **For internal use only.**
         */
        struct pvr_mmu_backing_page backing_page;

        union {
                /**
                 * @parent: The parent of this node in the page table tree structure.
                 *
                 * This is also a mirror table.
                 *
                 * Only valid when the L1 page table is active. When the L1 page table
                 * has been removed and queued for destruction, the next_free field
                 * should be used instead.
                 */
                struct pvr_page_table_l2 *parent;

                /**
                 * @next_free: Pointer to the next L1 page table to take/free.
                 *
                 * Used to form a linked list of L1 page tables. This is used
                 * when preallocating tables and when the page table has been
                 * removed and queued for destruction.
                 */
                struct pvr_page_table_l1 *next_free;
        };

        /**
         * @parent_idx: The index of the entry in the parent table (see
         * @parent) which corresponds to this table.
         */
        u16 parent_idx;

        /**
         * @entry_count: The current number of valid entries (that we know of)
         * in this table. This value is essentially a refcount - the table is
         * destroyed when this value is decremented to zero by
         * pvr_page_table_l1_remove().
         */
        u16 entry_count;
};

/**
 * pvr_page_table_l1_init() - Initialize a level 1 page table.
 * @table: Target level 1 page table.
 * @pvr_dev: Target PowerVR device
 *
 * When this function returns successfully, @table is still not considered
 * valid. It must be inserted into the page table tree structure with
 * pvr_page_table_l2_insert() before it is ready for use.
 *
 * It is expected that @table be zeroed (e.g. from kzalloc()) before calling
 * this function.
 *
 * Return:
 *  * 0 on success, or
 *  * Any error encountered while intializing &table->backing_page using
 *    pvr_mmu_backing_page_init().
 */
static int
pvr_page_table_l1_init(struct pvr_page_table_l1 *table,
                       struct pvr_device *pvr_dev)
{
        table->parent_idx = PVR_IDX_INVALID;

        return pvr_mmu_backing_page_init(&table->backing_page, pvr_dev);
}

/**
 * pvr_page_table_l1_free() - Teardown a level 1 page table.
 * @table: Target level 1 page table.
 *
 * It is an error to attempt to use @table after calling this function, even
 * indirectly. This includes calling pvr_page_table_l2_remove(), which must
 * be called *before* pvr_page_table_l1_free().
 */
static void
pvr_page_table_l1_free(struct pvr_page_table_l1 *table)
{
        pvr_mmu_backing_page_fini(&table->backing_page);
        kfree(table);
}

/**
 * pvr_page_table_l1_sync() - Flush a level 1 page table from the CPU to the
 *                            device.
 * @table: Target level 1 page table.
 *
 * This is just a thin wrapper around pvr_mmu_backing_page_sync(), so the
 * warning there applies here too: **Only call pvr_page_table_l1_sync() once
 * you're sure you have no more changes to make to** @table **in the immediate
 * future.**
 *
 * If child level 0 page tables of @table also need to be flushed, this should
 * be done first using pvr_page_table_l0_sync() *before* calling this function.
 */
static void
pvr_page_table_l1_sync(struct pvr_page_table_l1 *table)
{
        pvr_mmu_backing_page_sync(&table->backing_page, PVR_MMU_SYNC_LEVEL_1_FLAGS);
}

/**
 * pvr_page_table_l1_get_raw() - Access the raw equivalent of a mirror level 1
 *                               page table.
 * @table: Target level 1 page table.
 *
 * Essentially returns the CPU address of the raw equivalent of @table, cast to
 * a &struct pvr_page_table_l1_raw pointer.
 *
 * You probably want to call pvr_page_table_l1_get_entry_raw() instead.
 *
 * Return:
 * The raw equivalent of @table.
 */
static struct pvr_page_table_l1_raw *
pvr_page_table_l1_get_raw(struct pvr_page_table_l1 *table)
{
        return table->backing_page.host_ptr;
}

/**
 * pvr_page_table_l1_get_entry_raw() - Access an entry from the raw equivalent
 *                                     of a mirror level 1 page table.
 * @table: Target level 1 page table.
 * @idx: Index of the entry to access.
 *
 * Technically this function returns a pointer to a slot in a raw level 1 page
 * table, since the returned "entry" is not guaranteed to be valid. The caller
 * must verify the validity of the entry at the returned address (perhaps using
 * pvr_page_table_l1_entry_raw_is_valid()) before reading or overwriting it.
 *
 * The value of @idx is not checked here; it is the callers responsibility to
 * ensure @idx refers to a valid index within @table before dereferencing the
 * returned pointer.
 *
 * Return:
 * A pointer to the requested raw level 1 page table entry.
 */
static struct pvr_page_table_l1_entry_raw *
pvr_page_table_l1_get_entry_raw(struct pvr_page_table_l1 *table, u16 idx)
{
        return &pvr_page_table_l1_get_raw(table)->entries[idx];
}

/**
 * pvr_page_table_l1_entry_is_valid() - Check if a level 1 page table entry is
 *                                      marked as valid.
 * @table: Target level 1 page table.
 * @idx: Index of the entry to check.
 *
 * The value of @idx is not checked here; it is the callers responsibility to
 * ensure @idx refers to a valid index within @table before calling this
 * function.
 */
static bool
pvr_page_table_l1_entry_is_valid(struct pvr_page_table_l1 *table, u16 idx)
{
        struct pvr_page_table_l1_entry_raw entry_raw =
                *pvr_page_table_l1_get_entry_raw(table, idx);

        return pvr_page_table_l1_entry_raw_is_valid(entry_raw);
}

/**
 * struct pvr_page_table_l0 - A wrapped level 0 page table.
 *
 * To access the raw part of this table, use pvr_page_table_l0_get_raw().
 * Alternatively to access a raw entry directly, use
 * pvr_page_table_l0_get_entry_raw().
 *
 * There is no mirror representation of an individual page, so this type has no
 * &entries member.
 */
struct pvr_page_table_l0 {
        /**
         * @backing_page: A handle to the memory which holds the raw
         * equivalent of this table. **For internal use only.**
         */
        struct pvr_mmu_backing_page backing_page;

        union {
                /**
                 * @parent: The parent of this node in the page table tree structure.
                 *
                 * This is also a mirror table.
                 *
                 * Only valid when the L0 page table is active. When the L0 page table
                 * has been removed and queued for destruction, the next_free field
                 * should be used instead.
                 */
                struct pvr_page_table_l1 *parent;

                /**
                 * @next_free: Pointer to the next L0 page table to take/free.
                 *
                 * Used to form a linked list of L0 page tables. This is used
                 * when preallocating tables and when the page table has been
                 * removed and queued for destruction.
                 */
                struct pvr_page_table_l0 *next_free;
        };

        /**
         * @parent_idx: The index of the entry in the parent table (see
         * @parent) which corresponds to this table.
         */
        u16 parent_idx;

        /**
         * @entry_count: The current number of valid entries (that we know of)
         * in this table. This value is essentially a refcount - the table is
         * destroyed when this value is decremented to zero by
         * pvr_page_table_l0_remove().
         */
        u16 entry_count;
};

/**
 * pvr_page_table_l0_init() - Initialize a level 0 page table.
 * @table: Target level 0 page table.
 * @pvr_dev: Target PowerVR device
 *
 * When this function returns successfully, @table is still not considered
 * valid. It must be inserted into the page table tree structure with
 * pvr_page_table_l1_insert() before it is ready for use.
 *
 * It is expected that @table be zeroed (e.g. from kzalloc()) before calling
 * this function.
 *
 * Return:
 *  * 0 on success, or
 *  * Any error encountered while intializing &table->backing_page using
 *    pvr_mmu_backing_page_init().
 */
static int
pvr_page_table_l0_init(struct pvr_page_table_l0 *table,
                       struct pvr_device *pvr_dev)
{
        table->parent_idx = PVR_IDX_INVALID;

        return pvr_mmu_backing_page_init(&table->backing_page, pvr_dev);
}

/**
 * pvr_page_table_l0_free() - Teardown a level 0 page table.
 * @table: Target level 0 page table.
 *
 * It is an error to attempt to use @table after calling this function, even
 * indirectly. This includes calling pvr_page_table_l1_remove(), which must
 * be called *before* pvr_page_table_l0_free().
 */
static void
pvr_page_table_l0_free(struct pvr_page_table_l0 *table)
{
        pvr_mmu_backing_page_fini(&table->backing_page);
        kfree(table);
}

/**
 * pvr_page_table_l0_sync() - Flush a level 0 page table from the CPU to the
 *                            device.
 * @table: Target level 0 page table.
 *
 * This is just a thin wrapper around pvr_mmu_backing_page_sync(), so the
 * warning there applies here too: **Only call pvr_page_table_l0_sync() once
 * you're sure you have no more changes to make to** @table **in the immediate
 * future.**
 *
 * If child pages of @table also need to be flushed, this should be done first
 * using a DMA sync function (e.g. dma_sync_sg_for_device()) *before* calling
 * this function.
 */
static void
pvr_page_table_l0_sync(struct pvr_page_table_l0 *table)
{
        pvr_mmu_backing_page_sync(&table->backing_page, PVR_MMU_SYNC_LEVEL_0_FLAGS);
}

/**
 * pvr_page_table_l0_get_raw() - Access the raw equivalent of a mirror level 0
 *                               page table.
 * @table: Target level 0 page table.
 *
 * Essentially returns the CPU address of the raw equivalent of @table, cast to
 * a &struct pvr_page_table_l0_raw pointer.
 *
 * You probably want to call pvr_page_table_l0_get_entry_raw() instead.
 *
 * Return:
 * The raw equivalent of @table.
 */
static struct pvr_page_table_l0_raw *
pvr_page_table_l0_get_raw(struct pvr_page_table_l0 *table)
{
        return table->backing_page.host_ptr;
}

/**
 * pvr_page_table_l0_get_entry_raw() - Access an entry from the raw equivalent
 *                                     of a mirror level 0 page table.
 * @table: Target level 0 page table.
 * @idx: Index of the entry to access.
 *
 * Technically this function returns a pointer to a slot in a raw level 0 page
 * table, since the returned "entry" is not guaranteed to be valid. The caller
 * must verify the validity of the entry at the returned address (perhaps using
 * pvr_page_table_l0_entry_raw_is_valid()) before reading or overwriting it.
 *
 * The value of @idx is not checked here; it is the callers responsibility to
 * ensure @idx refers to a valid index within @table before dereferencing the
 * returned pointer. This is espcially important for level 0 page tables, which
 * can have a variable number of entries.
 *
 * Return:
 * A pointer to the requested raw level 0 page table entry.
 */
static struct pvr_page_table_l0_entry_raw *
pvr_page_table_l0_get_entry_raw(struct pvr_page_table_l0 *table, u16 idx)
{
        return &pvr_page_table_l0_get_raw(table)->entries[idx];
}

/**
 * pvr_page_table_l0_entry_is_valid() - Check if a level 0 page table entry is
 *                                      marked as valid.
 * @table: Target level 0 page table.
 * @idx: Index of the entry to check.
 *
 * The value of @idx is not checked here; it is the callers responsibility to
 * ensure @idx refers to a valid index within @table before calling this
 * function.
 */
static bool
pvr_page_table_l0_entry_is_valid(struct pvr_page_table_l0 *table, u16 idx)
{
        struct pvr_page_table_l0_entry_raw entry_raw =
                *pvr_page_table_l0_get_entry_raw(table, idx);

        return pvr_page_table_l0_entry_raw_is_valid(entry_raw);
}

/**
 * struct pvr_mmu_context - context holding data for operations at page
 * catalogue level, intended for use with a VM context.
 */
struct pvr_mmu_context {
        /** @pvr_dev: The PVR device associated with the owning VM context. */
        struct pvr_device *pvr_dev;

        /** @page_table_l2: The MMU table root. */
        struct pvr_page_table_l2 page_table_l2;
};

/**
 * struct pvr_page_table_ptr - A reference to a single physical page as indexed
 * by the page table structure.
 *
 * Intended for embedding in a &struct pvr_mmu_op_context.
 */
struct pvr_page_table_ptr {
        /**
         * @l1_table: A cached handle to the level 1 page table the
         * context is currently traversing.
         */
        struct pvr_page_table_l1 *l1_table;

        /**
         * @l0_table: A cached handle to the level 0 page table the
         * context is currently traversing.
         */
        struct pvr_page_table_l0 *l0_table;

        /**
         * @l2_idx: Index into the level 2 page table the context is
         * currently referencing.
         */
        u16 l2_idx;

        /**
         * @l1_idx: Index into the level 1 page table the context is
         * currently referencing.
         */
        u16 l1_idx;

        /**
         * @l0_idx: Index into the level 0 page table the context is
         * currently referencing.
         */
        u16 l0_idx;
};

/**
 * struct pvr_mmu_op_context - context holding data for individual
 * device-virtual mapping operations. Intended for use with a VM bind operation.
 */
struct pvr_mmu_op_context {
        /** @mmu_ctx: The MMU context associated with the owning VM context. */
        struct pvr_mmu_context *mmu_ctx;

        /** @map: Data specifically for map operations. */
        struct {
                /**
                 * @sgt: Scatter gather table containing pages pinned for use by
                 * this context - these are currently pinned when initialising
                 * the VM bind operation.
                 */
                struct sg_table *sgt;

                /** @sgt_offset: Start address of the device-virtual mapping. */
                u64 sgt_offset;

                /**
                 * @l1_prealloc_tables: Preallocated l1 page table objects
                 * use by this context when creating a page mapping. Linked list
                 * fully created during initialisation.
                 */
                struct pvr_page_table_l1 *l1_prealloc_tables;

                /**
                 * @l0_prealloc_tables: Preallocated l0 page table objects
                 * use by this context when creating a page mapping. Linked list
                 * fully created during initialisation.
                 */
                struct pvr_page_table_l0 *l0_prealloc_tables;
        } map;

        /** @unmap: Data specifically for unmap operations. */
        struct {
                /**
                 * @l1_free_tables: Collects page table objects freed by unmap
                 * ops. Linked list empty at creation.
                 */
                struct pvr_page_table_l1 *l1_free_tables;

                /**
                 * @l0_free_tables: Collects page table objects freed by unmap
                 * ops. Linked list empty at creation.
                 */
                struct pvr_page_table_l0 *l0_free_tables;
        } unmap;

        /**
         * @curr_page: A reference to a single physical page as indexed by the
         * page table structure.
         */
        struct pvr_page_table_ptr curr_page;

        /**
         * @sync_level_required: The maximum level of the page table tree
         * structure which has (possibly) been modified since it was last
         * flushed to the device.
         *
         * This field should only be set with pvr_mmu_op_context_require_sync()
         * or indirectly by pvr_mmu_op_context_sync_partial().
         */
        enum pvr_mmu_sync_level sync_level_required;
};

/**
 * pvr_page_table_l2_insert() - Insert an entry referring to a level 1 page
 * table into a level 2 page table.
 * @op_ctx: Target MMU op context pointing at the entry to insert the L1 page
 * table into.
 * @child_table: Target level 1 page table to be referenced by the new entry.
 *
 * It is the caller's responsibility to ensure @op_ctx.curr_page points to a
 * valid L2 entry.
 *
 * It is the caller's responsibility to execute any memory barries to ensure
 * that the creation of @child_table is ordered before the L2 entry is inserted.
 */
static void
pvr_page_table_l2_insert(struct pvr_mmu_op_context *op_ctx,
                         struct pvr_page_table_l1 *child_table)
{
        struct pvr_page_table_l2 *l2_table =
                &op_ctx->mmu_ctx->page_table_l2;
        struct pvr_page_table_l2_entry_raw *entry_raw =
                pvr_page_table_l2_get_entry_raw(l2_table,
                                                op_ctx->curr_page.l2_idx);

        pvr_page_table_l2_entry_raw_set(entry_raw,
                                        child_table->backing_page.dma_addr);

        child_table->parent = l2_table;
        child_table->parent_idx = op_ctx->curr_page.l2_idx;
        l2_table->entries[op_ctx->curr_page.l2_idx] = child_table;
        ++l2_table->entry_count;
        op_ctx->curr_page.l1_table = child_table;
}

/**
 * pvr_page_table_l2_remove() - Remove a level 1 page table from a level 2 page
 * table.
 * @op_ctx: Target MMU op context pointing at the L2 entry to remove.
 *
 * It is the caller's responsibility to ensure @op_ctx.curr_page points to a
 * valid L2 entry.
 */
static void
pvr_page_table_l2_remove(struct pvr_mmu_op_context *op_ctx)
{
        struct pvr_page_table_l2 *l2_table =
                &op_ctx->mmu_ctx->page_table_l2;
        struct pvr_page_table_l2_entry_raw *entry_raw =
                pvr_page_table_l2_get_entry_raw(l2_table,
                                                op_ctx->curr_page.l1_table->parent_idx);

        WARN_ON(op_ctx->curr_page.l1_table->parent != l2_table);

        pvr_page_table_l2_entry_raw_clear(entry_raw);

        l2_table->entries[op_ctx->curr_page.l1_table->parent_idx] = NULL;
        op_ctx->curr_page.l1_table->parent_idx = PVR_IDX_INVALID;
        op_ctx->curr_page.l1_table->next_free = op_ctx->unmap.l1_free_tables;
        op_ctx->unmap.l1_free_tables = op_ctx->curr_page.l1_table;
        op_ctx->curr_page.l1_table = NULL;

        --l2_table->entry_count;
}

/**
 * pvr_page_table_l1_insert() - Insert an entry referring to a level 0 page
 * table into a level 1 page table.
 * @op_ctx: Target MMU op context pointing at the entry to insert the L0 page
 * table into.
 * @child_table: L0 page table to insert.
 *
 * It is the caller's responsibility to ensure @op_ctx.curr_page points to a
 * valid L1 entry.
 *
 * It is the caller's responsibility to execute any memory barries to ensure
 * that the creation of @child_table is ordered before the L1 entry is inserted.
 */
static void
pvr_page_table_l1_insert(struct pvr_mmu_op_context *op_ctx,
                         struct pvr_page_table_l0 *child_table)
{
        struct pvr_page_table_l1_entry_raw *entry_raw =
                pvr_page_table_l1_get_entry_raw(op_ctx->curr_page.l1_table,
                                                op_ctx->curr_page.l1_idx);

        pvr_page_table_l1_entry_raw_set(entry_raw,
                                        child_table->backing_page.dma_addr);

        child_table->parent = op_ctx->curr_page.l1_table;
        child_table->parent_idx = op_ctx->curr_page.l1_idx;
        op_ctx->curr_page.l1_table->entries[op_ctx->curr_page.l1_idx] = child_table;
        ++op_ctx->curr_page.l1_table->entry_count;
        op_ctx->curr_page.l0_table = child_table;
}

/**
 * pvr_page_table_l1_remove() - Remove a level 0 page table from a level 1 page
 *                              table.
 * @op_ctx: Target MMU op context pointing at the L1 entry to remove.
 *
 * If this function results in the L1 table becoming empty, it will be removed
 * from its parent level 2 page table and destroyed.
 *
 * It is the caller's responsibility to ensure @op_ctx.curr_page points to a
 * valid L1 entry.
 */
static void
pvr_page_table_l1_remove(struct pvr_mmu_op_context *op_ctx)
{
        struct pvr_page_table_l1_entry_raw *entry_raw =
                pvr_page_table_l1_get_entry_raw(op_ctx->curr_page.l0_table->parent,
                                                op_ctx->curr_page.l0_table->parent_idx);

        WARN_ON(op_ctx->curr_page.l0_table->parent !=
                op_ctx->curr_page.l1_table);

        pvr_page_table_l1_entry_raw_clear(entry_raw);

        op_ctx->curr_page.l1_table->entries[op_ctx->curr_page.l0_table->parent_idx] = NULL;
        op_ctx->curr_page.l0_table->parent_idx = PVR_IDX_INVALID;
        op_ctx->curr_page.l0_table->next_free = op_ctx->unmap.l0_free_tables;
        op_ctx->unmap.l0_free_tables = op_ctx->curr_page.l0_table;
        op_ctx->curr_page.l0_table = NULL;

        if (--op_ctx->curr_page.l1_table->entry_count == 0) {
                /* Clear the parent L2 page table entry. */
                if (op_ctx->curr_page.l1_table->parent_idx != PVR_IDX_INVALID)
                        pvr_page_table_l2_remove(op_ctx);
        }
}

/**
 * pvr_page_table_l0_insert() - Insert an entry referring to a physical page
 * into a level 0 page table.
 * @op_ctx: Target MMU op context pointing at the L0 entry to insert.
 * @dma_addr: Target DMA address to be referenced by the new entry.
 * @flags: Page options to be stored in the new entry.
 *
 * It is the caller's responsibility to ensure @op_ctx.curr_page points to a
 * valid L0 entry.
 */
static void
pvr_page_table_l0_insert(struct pvr_mmu_op_context *op_ctx,
                         dma_addr_t dma_addr, struct pvr_page_flags_raw flags)
{
        struct pvr_page_table_l0_entry_raw *entry_raw =
                pvr_page_table_l0_get_entry_raw(op_ctx->curr_page.l0_table,
                                                op_ctx->curr_page.l0_idx);

        pvr_page_table_l0_entry_raw_set(entry_raw, dma_addr, flags);

        /*
         * There is no entry to set here - we don't keep a mirror of
         * individual pages.
         */

        ++op_ctx->curr_page.l0_table->entry_count;
}

/**
 * pvr_page_table_l0_remove() - Remove a physical page from a level 0 page
 * table.
 * @op_ctx: Target MMU op context pointing at the L0 entry to remove.
 *
 * If this function results in the L0 table becoming empty, it will be removed
 * from its parent L1 page table and destroyed.
 *
 * It is the caller's responsibility to ensure @op_ctx.curr_page points to a
 * valid L0 entry.
 */
static void
pvr_page_table_l0_remove(struct pvr_mmu_op_context *op_ctx)
{
        struct pvr_page_table_l0_entry_raw *entry_raw =
                pvr_page_table_l0_get_entry_raw(op_ctx->curr_page.l0_table,
                                                op_ctx->curr_page.l0_idx);

        pvr_page_table_l0_entry_raw_clear(entry_raw);

        /*
         * There is no entry to clear here - we don't keep a mirror of
         * individual pages.
         */

        if (--op_ctx->curr_page.l0_table->entry_count == 0) {
                /* Clear the parent L1 page table entry. */
                if (op_ctx->curr_page.l0_table->parent_idx != PVR_IDX_INVALID)
                        pvr_page_table_l1_remove(op_ctx);
        }
}

/**
 * DOC: Page table index utilities
 */

/**
 * pvr_page_table_l2_idx() - Calculate the level 2 page table index for a
 *                           device-virtual address.
 * @device_addr: Target device-virtual address.
 *
 * This function does not perform any bounds checking - it is the caller's
 * responsibility to ensure that @device_addr is valid before interpreting
 * the result.
 *
 * Return:
 * The index into a level 2 page table corresponding to @device_addr.
 */
static u16
pvr_page_table_l2_idx(u64 device_addr)
{
        return (device_addr & ~ROGUE_MMUCTRL_VADDR_PC_INDEX_CLRMSK) >>
               ROGUE_MMUCTRL_VADDR_PC_INDEX_SHIFT;
}

/**
 * pvr_page_table_l1_idx() - Calculate the level 1 page table index for a
 *                           device-virtual address.
 * @device_addr: Target device-virtual address.
 *
 * This function does not perform any bounds checking - it is the caller's
 * responsibility to ensure that @device_addr is valid before interpreting
 * the result.
 *
 * Return:
 * The index into a level 1 page table corresponding to @device_addr.
 */
static u16
pvr_page_table_l1_idx(u64 device_addr)
{
        return (device_addr & ~ROGUE_MMUCTRL_VADDR_PD_INDEX_CLRMSK) >>
               ROGUE_MMUCTRL_VADDR_PD_INDEX_SHIFT;
}

/**
 * pvr_page_table_l0_idx() - Calculate the level 0 page table index for a
 *                           device-virtual address.
 * @device_addr: Target device-virtual address.
 *
 * This function does not perform any bounds checking - it is the caller's
 * responsibility to ensure that @device_addr is valid before interpreting
 * the result.
 *
 * Return:
 * The index into a level 0 page table corresponding to @device_addr.
 */
static u16
pvr_page_table_l0_idx(u64 device_addr)
{
        return (device_addr & ~ROGUE_MMUCTRL_VADDR_PT_INDEX_CLRMSK) >>
               ROGUE_MMUCTRL_PAGE_X_RANGE_SHIFT;
}

/**
 * DOC: High-level page table operations
 */

/**
 * pvr_page_table_l1_get_or_insert() - Retrieves (optionally inserting if
 * necessary) a level 1 page table from the specified level 2 page table entry.
 * @op_ctx: Target MMU op context.
 * @should_insert: [IN] Specifies whether new page tables should be inserted
 * when empty page table entries are encountered during traversal.
 *
 * Return:
 *  * 0 on success, or
 *
 *    If @should_insert is %false:
 *     * -%ENXIO if a level 1 page table would have been inserted.
 *
 *    If @should_insert is %true:
 *     * Any error encountered while inserting the level 1 page table.
 */
static int
pvr_page_table_l1_get_or_insert(struct pvr_mmu_op_context *op_ctx,
                                bool should_insert)
{
        struct pvr_page_table_l2 *l2_table =
                &op_ctx->mmu_ctx->page_table_l2;
        struct pvr_page_table_l1 *table;

        if (pvr_page_table_l2_entry_is_valid(l2_table,
                                             op_ctx->curr_page.l2_idx)) {
                op_ctx->curr_page.l1_table =
                        l2_table->entries[op_ctx->curr_page.l2_idx];
                return 0;
        }

        if (!should_insert)
                return -ENXIO;

        /* Take a prealloced table. */
        table = op_ctx->map.l1_prealloc_tables;
        if (!table)
                return -ENOMEM;

        /* Pop */
        op_ctx->map.l1_prealloc_tables = table->next_free;
        table->next_free = NULL;

        /* Ensure new table is fully written out before adding to L2 page table. */
        wmb();

        pvr_page_table_l2_insert(op_ctx, table);

        return 0;
}

/**
 * pvr_page_table_l0_get_or_insert() - Retrieves (optionally inserting if
 * necessary) a level 0 page table from the specified level 1 page table entry.
 * @op_ctx: Target MMU op context.
 * @should_insert: [IN] Specifies whether new page tables should be inserted
 * when empty page table entries are encountered during traversal.
 *
 * Return:
 *  * 0 on success,
 *
 *    If @should_insert is %false:
 *     * -%ENXIO if a level 0 page table would have been inserted.
 *
 *    If @should_insert is %true:
 *     * Any error encountered while inserting the level 0 page table.
 */
static int
pvr_page_table_l0_get_or_insert(struct pvr_mmu_op_context *op_ctx,
                                bool should_insert)
{
        struct pvr_page_table_l0 *table;

        if (pvr_page_table_l1_entry_is_valid(op_ctx->curr_page.l1_table,
                                             op_ctx->curr_page.l1_idx)) {
                op_ctx->curr_page.l0_table =
                        op_ctx->curr_page.l1_table->entries[op_ctx->curr_page.l1_idx];
                return 0;
        }

        if (!should_insert)
                return -ENXIO;

        /* Take a prealloced table. */
        table = op_ctx->map.l0_prealloc_tables;
        if (!table)
                return -ENOMEM;

        /* Pop */
        op_ctx->map.l0_prealloc_tables = table->next_free;
        table->next_free = NULL;

        /* Ensure new table is fully written out before adding to L1 page table. */
        wmb();

        pvr_page_table_l1_insert(op_ctx, table);

        return 0;
}

/**
 * pvr_mmu_context_create() - Create an MMU context.
 * @pvr_dev: PVR device associated with owning VM context.
 *
 * Returns:
 *  * Newly created MMU context object on success, or
 *  * -%ENOMEM if no memory is available,
 *  * Any error code returned by pvr_page_table_l2_init().
 */
struct pvr_mmu_context *pvr_mmu_context_create(struct pvr_device *pvr_dev)
{
        struct pvr_mmu_context *ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
        int err;

        if (!ctx)
                return ERR_PTR(-ENOMEM);

        err = pvr_page_table_l2_init(&ctx->page_table_l2, pvr_dev);
        if (err)
                return ERR_PTR(err);

        ctx->pvr_dev = pvr_dev;

        return ctx;
}

/**
 * pvr_mmu_context_destroy() - Destroy an MMU context.
 * @ctx: Target MMU context.
 */
void pvr_mmu_context_destroy(struct pvr_mmu_context *ctx)
{
        pvr_page_table_l2_fini(&ctx->page_table_l2);
        kfree(ctx);
}

/**
 * pvr_mmu_get_root_table_dma_addr() - Get the DMA address of the root of the
 * page table structure behind a VM context.
 * @ctx: Target MMU context.
 */
dma_addr_t pvr_mmu_get_root_table_dma_addr(struct pvr_mmu_context *ctx)
{
        return ctx->page_table_l2.backing_page.dma_addr;
}

/**
 * pvr_page_table_l1_alloc() - Allocate a l1 page_table object.
 * @ctx: MMU context of owning VM context.
 *
 * Returns:
 *  * Newly created page table object on success, or
 *  * -%ENOMEM if no memory is available,
 *  * Any error code returned by pvr_page_table_l1_init().
 */
static struct pvr_page_table_l1 *
pvr_page_table_l1_alloc(struct pvr_mmu_context *ctx)
{
        int err;

        struct pvr_page_table_l1 *table =
                kzalloc(sizeof(*table), GFP_KERNEL);

        if (!table)
                return ERR_PTR(-ENOMEM);

        err = pvr_page_table_l1_init(table, ctx->pvr_dev);
        if (err) {
                kfree(table);
                return ERR_PTR(err);
        }

        return table;
}

/**
 * pvr_page_table_l0_alloc() - Allocate a l0 page_table object.
 * @ctx: MMU context of owning VM context.
 *
 * Returns:
 *  * Newly created page table object on success, or
 *  * -%ENOMEM if no memory is available,
 *  * Any error code returned by pvr_page_table_l0_init().
 */
static struct pvr_page_table_l0 *
pvr_page_table_l0_alloc(struct pvr_mmu_context *ctx)
{
        int err;

        struct pvr_page_table_l0 *table =
                kzalloc(sizeof(*table), GFP_KERNEL);

        if (!table)
                return ERR_PTR(-ENOMEM);

        err = pvr_page_table_l0_init(table, ctx->pvr_dev);
        if (err) {
                kfree(table);
                return ERR_PTR(err);
        }

        return table;
}

/**
 * pvr_mmu_op_context_require_sync() - Mark an MMU op context as requiring a
 * sync operation for the referenced page tables up to a specified level.
 * @op_ctx: Target MMU op context.
 * @level: Maximum page table level for which a sync is required.
 */
static void
pvr_mmu_op_context_require_sync(struct pvr_mmu_op_context *op_ctx,
                                enum pvr_mmu_sync_level level)
{
        if (op_ctx->sync_level_required < level)
                op_ctx->sync_level_required = level;
}

/**
 * pvr_mmu_op_context_sync_manual() - Trigger a sync of some or all of the
 * page tables referenced by a MMU op context.
 * @op_ctx: Target MMU op context.
 * @level: Maximum page table level to sync.
 *
 * Do not call this function directly. Instead use
 * pvr_mmu_op_context_sync_partial() which is checked against the current
 * value of &op_ctx->sync_level_required as set by
 * pvr_mmu_op_context_require_sync().
 */
static void
pvr_mmu_op_context_sync_manual(struct pvr_mmu_op_context *op_ctx,
                               enum pvr_mmu_sync_level level)
{
        /*
         * We sync the page table levels in ascending order (starting from the
         * leaf node) to ensure consistency.
         */

        WARN_ON(level < PVR_MMU_SYNC_LEVEL_NONE);

        if (level <= PVR_MMU_SYNC_LEVEL_NONE)
                return;

        if (op_ctx->curr_page.l0_table)
                pvr_page_table_l0_sync(op_ctx->curr_page.l0_table);

        if (level < PVR_MMU_SYNC_LEVEL_1)
                return;

        if (op_ctx->curr_page.l1_table)
                pvr_page_table_l1_sync(op_ctx->curr_page.l1_table);

        if (level < PVR_MMU_SYNC_LEVEL_2)
                return;

        pvr_page_table_l2_sync(&op_ctx->mmu_ctx->page_table_l2);
}

/**
 * pvr_mmu_op_context_sync_partial() - Trigger a sync of some or all of the
 * page tables referenced by a MMU op context.
 * @op_ctx: Target MMU op context.
 * @level: Requested page table level to sync up to (inclusive).
 *
 * If @level is greater than the maximum level recorded by @op_ctx as requiring
 * a sync operation, only the previously recorded maximum will be used.
 *
 * Additionally, if @level is greater than or equal to the maximum level
 * recorded by @op_ctx as requiring a sync operation, that maximum level will be
 * reset as a full sync will be performed. This is equivalent to calling
 * pvr_mmu_op_context_sync().
 */
static void
pvr_mmu_op_context_sync_partial(struct pvr_mmu_op_context *op_ctx,
                                enum pvr_mmu_sync_level level)
{
        /*
         * If the requested sync level is greater than or equal to the
         * currently required sync level, we do two things:
         *  * Don't waste time syncing levels we haven't previously marked as
         *    requiring a sync, and
         *  * Reset the required sync level since we are about to sync
         *    everything that was previously marked as requiring a sync.
         */
        if (level >= op_ctx->sync_level_required) {
                level = op_ctx->sync_level_required;
                op_ctx->sync_level_required = PVR_MMU_SYNC_LEVEL_NONE;
        }

        pvr_mmu_op_context_sync_manual(op_ctx, level);
}

/**
 * pvr_mmu_op_context_sync() - Trigger a sync of every page table referenced by
 * a MMU op context.
 * @op_ctx: Target MMU op context.
 *
 * The maximum level marked internally as requiring a sync will be reset so
 * that subsequent calls to this function will be no-ops unless @op_ctx is
 * otherwise updated.
 */
static void
pvr_mmu_op_context_sync(struct pvr_mmu_op_context *op_ctx)
{
        pvr_mmu_op_context_sync_manual(op_ctx, op_ctx->sync_level_required);

        op_ctx->sync_level_required = PVR_MMU_SYNC_LEVEL_NONE;
}

/**
 * pvr_mmu_op_context_load_tables() - Load pointers to tables in each level of
 * the page table tree structure needed to reference the physical page
 * referenced by a MMU op context.
 * @op_ctx: Target MMU op context.
 * @should_create: Specifies whether new page tables should be created when
 * empty page table entries are encountered during traversal.
 * @load_level_required: Maximum page table level to load.
 *
 * If @should_create is %true, this function may modify the stored required
 * sync level of @op_ctx as new page tables are created and inserted into their
 * respective parents.
 *
 * Since there is only one root page table, it is technically incorrect to call
 * this function with a value of @load_level_required greater than or equal to
 * the root level number. However, this is not explicitly disallowed here.
 *
 * Return:
 *  * 0 on success,
 *  * Any error returned by pvr_page_table_l1_get_or_create() if
 *    @load_level_required >= 1 except -%ENXIO, or
 *  * Any error returned by pvr_page_table_l0_get_or_create() if
 *    @load_level_required >= 0 except -%ENXIO.
 */
static int
pvr_mmu_op_context_load_tables(struct pvr_mmu_op_context *op_ctx,
                               bool should_create,
                               enum pvr_mmu_sync_level load_level_required)
{
        const struct pvr_page_table_l1 *l1_head_before =
                op_ctx->map.l1_prealloc_tables;
        const struct pvr_page_table_l0 *l0_head_before =
                op_ctx->map.l0_prealloc_tables;
        int err;

        /* Clear tables we're about to fetch in case of error states. */
        if (load_level_required >= PVR_MMU_SYNC_LEVEL_1)
                op_ctx->curr_page.l1_table = NULL;

        if (load_level_required >= PVR_MMU_SYNC_LEVEL_0)
                op_ctx->curr_page.l0_table = NULL;

        /* Get or create L1 page table. */
        if (load_level_required >= PVR_MMU_SYNC_LEVEL_1) {
                err = pvr_page_table_l1_get_or_insert(op_ctx, should_create);
                if (err) {
                        /*
                         * If @should_create is %false and no L1 page table was
                         * found, return early but without an error. Since
                         * pvr_page_table_l1_get_or_create() can only return
                         * -%ENXIO if @should_create is %false, there is no
                         * need to check it here.
                         */
                        if (err == -ENXIO)
                                err = 0;

                        return err;
                }
        }

        /* Get or create L0 page table. */
        if (load_level_required >= PVR_MMU_SYNC_LEVEL_0) {
                err = pvr_page_table_l0_get_or_insert(op_ctx, should_create);
                if (err) {
                        /*
                         * If @should_create is %false and no L0 page table was
                         * found, return early but without an error. Since
                         * pvr_page_table_l0_get_or_insert() can only return
                         * -%ENXIO if @should_create is %false, there is no
                         * need to check it here.
                         */
                        if (err == -ENXIO)
                                err = 0;

                        /*
                         * At this point, an L1 page table could have been
                         * inserted but is now empty due to the failed attempt
                         * at inserting an L0 page table. In this instance, we
                         * must remove the empty L1 page table ourselves as
                         * pvr_page_table_l1_remove() is never called as part
                         * of the error path in
                         * pvr_page_table_l0_get_or_insert().
                         */
                        if (l1_head_before != op_ctx->map.l1_prealloc_tables) {
                                pvr_page_table_l2_remove(op_ctx);
                                pvr_mmu_op_context_require_sync(op_ctx, PVR_MMU_SYNC_LEVEL_2);
                        }

                        return err;
                }
        }

        /*
         * A sync is only needed if table objects were inserted. This can be
         * inferred by checking if the pointer at the head of the linked list
         * has changed.
         */
        if (l1_head_before != op_ctx->map.l1_prealloc_tables)
                pvr_mmu_op_context_require_sync(op_ctx, PVR_MMU_SYNC_LEVEL_2);
        else if (l0_head_before != op_ctx->map.l0_prealloc_tables)
                pvr_mmu_op_context_require_sync(op_ctx, PVR_MMU_SYNC_LEVEL_1);

        return 0;
}

/**
 * pvr_mmu_op_context_set_curr_page() - Reassign the current page of an MMU op
 * context, syncing any page tables previously assigned to it which are no
 * longer relevant.
 * @op_ctx: Target MMU op context.
 * @device_addr: New pointer target.
 * @should_create: Specify whether new page tables should be created when
 * empty page table entries are encountered during traversal.
 *
 * This function performs a full sync on the pointer, regardless of which
 * levels are modified.
 *
 * Return:
 *  * 0 on success, or
 *  * Any error returned by pvr_mmu_op_context_load_tables().
 */
static int
pvr_mmu_op_context_set_curr_page(struct pvr_mmu_op_context *op_ctx,
                                 u64 device_addr, bool should_create)
{
        pvr_mmu_op_context_sync(op_ctx);

        op_ctx->curr_page.l2_idx = pvr_page_table_l2_idx(device_addr);
        op_ctx->curr_page.l1_idx = pvr_page_table_l1_idx(device_addr);
        op_ctx->curr_page.l0_idx = pvr_page_table_l0_idx(device_addr);
        op_ctx->curr_page.l1_table = NULL;
        op_ctx->curr_page.l0_table = NULL;

        return pvr_mmu_op_context_load_tables(op_ctx, should_create,
                                              PVR_MMU_SYNC_LEVEL_1);
}

/**
 * pvr_mmu_op_context_next_page() - Advance the current page of an MMU op
 * context.
 * @op_ctx: Target MMU op context.
 * @should_create: Specify whether new page tables should be created when
 * empty page table entries are encountered during traversal.
 *
 * If @should_create is %false, it is the caller's responsibility to verify that
 * the state of the table references in @op_ctx is valid on return. If -%ENXIO
 * is returned, at least one of the table references is invalid. It should be
 * noted that @op_ctx as a whole will be left in a valid state if -%ENXIO is
 * returned, unlike other error codes. The caller should check which references
 * are invalid by comparing them to %NULL. Only &@ptr->l2_table is guaranteed
 * to be valid, since it represents the root of the page table tree structure.
 *
 * Return:
 *  * 0 on success,
 *  * -%EPERM if the operation would wrap at the top of the page table
 *    hierarchy,
 *  * -%ENXIO if @should_create is %false and a page table of any level would
 *    have otherwise been created, or
 *  * Any error returned while attempting to create missing page tables if
 *    @should_create is %true.
 */
static int
pvr_mmu_op_context_next_page(struct pvr_mmu_op_context *op_ctx,
                             bool should_create)
{
        s8 load_level_required = PVR_MMU_SYNC_LEVEL_NONE;

        if (++op_ctx->curr_page.l0_idx != ROGUE_MMUCTRL_ENTRIES_PT_VALUE_X)
                goto load_tables;

        op_ctx->curr_page.l0_idx = 0;
        load_level_required = PVR_MMU_SYNC_LEVEL_0;

        if (++op_ctx->curr_page.l1_idx != ROGUE_MMUCTRL_ENTRIES_PD_VALUE)
                goto load_tables;

        op_ctx->curr_page.l1_idx = 0;
        load_level_required = PVR_MMU_SYNC_LEVEL_1;

        if (++op_ctx->curr_page.l2_idx != ROGUE_MMUCTRL_ENTRIES_PC_VALUE)
                goto load_tables;

        /*
         * If the pattern continued, we would set &op_ctx->curr_page.l2_idx to
         * zero here. However, that would wrap the top layer of the page table
         * hierarchy which is not a valid operation. Instead, we warn and return
         * an error.
         */
        WARN(true,
             "%s(%p) attempted to loop the top of the page table hierarchy",
             __func__, op_ctx);
        return -EPERM;

        /* If indices have wrapped, we need to load new tables. */
load_tables:
        /* First, flush tables which will be unloaded. */
        pvr_mmu_op_context_sync_partial(op_ctx, load_level_required);

        /* Then load tables from the required level down. */
        return pvr_mmu_op_context_load_tables(op_ctx, should_create,
                                              load_level_required);
}

/**
 * DOC: Single page operations
 */

/**
 * pvr_page_create() - Create a device-virtual memory page and insert it into
 * a level 0 page table.
 * @op_ctx: Target MMU op context pointing at the device-virtual address of the
 * target page.
 * @dma_addr: DMA address of the physical page backing the created page.
 * @flags: Page options saved on the level 0 page table entry for reading by
 *         the device.
 *
 * Return:
 *  * 0 on success, or
 *  * -%EEXIST if the requested page already exists.
 */
static int
pvr_page_create(struct pvr_mmu_op_context *op_ctx, dma_addr_t dma_addr,
                struct pvr_page_flags_raw flags)
{
        /* Do not create a new page if one already exists. */
        if (pvr_page_table_l0_entry_is_valid(op_ctx->curr_page.l0_table,
                                             op_ctx->curr_page.l0_idx)) {
                return -EEXIST;
        }

        pvr_page_table_l0_insert(op_ctx, dma_addr, flags);

        pvr_mmu_op_context_require_sync(op_ctx, PVR_MMU_SYNC_LEVEL_0);

        return 0;
}

/**
 * pvr_page_destroy() - Destroy a device page after removing it from its
 * parent level 0 page table.
 * @op_ctx: Target MMU op context.
 */
static void
pvr_page_destroy(struct pvr_mmu_op_context *op_ctx)
{
        /* Do nothing if the page does not exist. */
        if (!pvr_page_table_l0_entry_is_valid(op_ctx->curr_page.l0_table,
                                              op_ctx->curr_page.l0_idx)) {
                return;
        }

        /* Clear the parent L0 page table entry. */
        pvr_page_table_l0_remove(op_ctx);

        pvr_mmu_op_context_require_sync(op_ctx, PVR_MMU_SYNC_LEVEL_0);
}

/**
 * pvr_mmu_op_context_destroy() - Destroy an MMU op context.
 * @op_ctx: Target MMU op context.
 */
void pvr_mmu_op_context_destroy(struct pvr_mmu_op_context *op_ctx)
{
        const bool flush_caches =
                op_ctx->sync_level_required != PVR_MMU_SYNC_LEVEL_NONE;

        pvr_mmu_op_context_sync(op_ctx);

        /* Unmaps should be flushed immediately. Map flushes can be deferred. */
        if (flush_caches && !op_ctx->map.sgt)
                pvr_mmu_flush_exec(op_ctx->mmu_ctx->pvr_dev, true);

        while (op_ctx->map.l0_prealloc_tables) {
                struct pvr_page_table_l0 *tmp = op_ctx->map.l0_prealloc_tables;

                op_ctx->map.l0_prealloc_tables =
                        op_ctx->map.l0_prealloc_tables->next_free;
                pvr_page_table_l0_free(tmp);
        }

        while (op_ctx->map.l1_prealloc_tables) {
                struct pvr_page_table_l1 *tmp = op_ctx->map.l1_prealloc_tables;

                op_ctx->map.l1_prealloc_tables =
                        op_ctx->map.l1_prealloc_tables->next_free;
                pvr_page_table_l1_free(tmp);
        }

        while (op_ctx->unmap.l0_free_tables) {
                struct pvr_page_table_l0 *tmp = op_ctx->unmap.l0_free_tables;

                op_ctx->unmap.l0_free_tables =
                        op_ctx->unmap.l0_free_tables->next_free;
                pvr_page_table_l0_free(tmp);
        }

        while (op_ctx->unmap.l1_free_tables) {
                struct pvr_page_table_l1 *tmp = op_ctx->unmap.l1_free_tables;

                op_ctx->unmap.l1_free_tables =
                        op_ctx->unmap.l1_free_tables->next_free;
                pvr_page_table_l1_free(tmp);
        }

        kfree(op_ctx);
}

/**
 * pvr_mmu_op_context_create() - Create an MMU op context.
 * @ctx: MMU context associated with owning VM context.
 * @sgt: Scatter gather table containing pages pinned for use by this context.
 * @sgt_offset: Start offset of the requested device-virtual memory mapping.
 * @size: Size in bytes of the requested device-virtual memory mapping. For an
 * unmapping, this should be zero so that no page tables are allocated.
 *
 * Returns:
 *  * Newly created MMU op context object on success, or
 *  * -%ENOMEM if no memory is available,
 *  * Any error code returned by pvr_page_table_l2_init().
 */
struct pvr_mmu_op_context *
pvr_mmu_op_context_create(struct pvr_mmu_context *ctx, struct sg_table *sgt,
                          u64 sgt_offset, u64 size)
{
        int err;

        struct pvr_mmu_op_context *op_ctx =
                kzalloc(sizeof(*op_ctx), GFP_KERNEL);

        if (!op_ctx)
                return ERR_PTR(-ENOMEM);

        op_ctx->mmu_ctx = ctx;
        op_ctx->map.sgt = sgt;
        op_ctx->map.sgt_offset = sgt_offset;
        op_ctx->sync_level_required = PVR_MMU_SYNC_LEVEL_NONE;

        if (size) {
                /*
                 * The number of page table objects we need to prealloc is
                 * indicated by the mapping size, start offset and the sizes
                 * of the areas mapped per PT or PD. The range calculation is
                 * identical to that for the index into a table for a device
                 * address, so we reuse those functions here.
                 */
                const u32 l1_start_idx = pvr_page_table_l2_idx(sgt_offset);
                const u32 l1_end_idx = pvr_page_table_l2_idx(sgt_offset + size);
                const u32 l1_count = l1_end_idx - l1_start_idx + 1;
                const u32 l0_start_idx = pvr_page_table_l1_idx(sgt_offset);
                const u32 l0_end_idx = pvr_page_table_l1_idx(sgt_offset + size);
                const u32 l0_count = l0_end_idx - l0_start_idx + 1;

                /*
                 * Alloc and push page table entries until we have enough of
                 * each type, ending with linked lists of l0 and l1 entries in
                 * reverse order.
                 */
                for (int i = 0; i < l1_count; i++) {
                        struct pvr_page_table_l1 *l1_tmp =
                                pvr_page_table_l1_alloc(ctx);

                        err = PTR_ERR_OR_ZERO(l1_tmp);
                        if (err)
                                goto err_cleanup;

                        l1_tmp->next_free = op_ctx->map.l1_prealloc_tables;
                        op_ctx->map.l1_prealloc_tables = l1_tmp;
                }

                for (int i = 0; i < l0_count; i++) {
                        struct pvr_page_table_l0 *l0_tmp =
                                pvr_page_table_l0_alloc(ctx);

                        err = PTR_ERR_OR_ZERO(l0_tmp);
                        if (err)
                                goto err_cleanup;

                        l0_tmp->next_free = op_ctx->map.l0_prealloc_tables;
                        op_ctx->map.l0_prealloc_tables = l0_tmp;
                }
        }

        return op_ctx;

err_cleanup:
        pvr_mmu_op_context_destroy(op_ctx);

        return ERR_PTR(err);
}

/**
 * pvr_mmu_op_context_unmap_curr_page() - Unmap pages from a memory context
 * starting from the current page of an MMU op context.
 * @op_ctx: Target MMU op context pointing at the first page to unmap.
 * @nr_pages: Number of pages to unmap.
 *
 * Return:
 *  * 0 on success, or
 *  * Any error encountered while advancing @op_ctx.curr_page with
 *    pvr_mmu_op_context_next_page() (except -%ENXIO).
 */
static int
pvr_mmu_op_context_unmap_curr_page(struct pvr_mmu_op_context *op_ctx,
                                   u64 nr_pages)
{
        int err;

        if (nr_pages == 0)
                return 0;

        /*
         * Destroy first page outside loop, as it doesn't require a page
         * advance beforehand. If the L0 page table reference in
         * @op_ctx.curr_page is %NULL, there cannot be a mapped page at
         * @op_ctx.curr_page (so skip ahead).
         */
        if (op_ctx->curr_page.l0_table)
                pvr_page_destroy(op_ctx);

        for (u64 page = 1; page < nr_pages; ++page) {
                err = pvr_mmu_op_context_next_page(op_ctx, false);
                /*
                 * If the page table tree structure at @op_ctx.curr_page is
                 * incomplete, skip ahead. We don't care about unmapping pages
                 * that cannot exist.
                 *
                 * FIXME: This could be made more efficient by jumping ahead
                 * using pvr_mmu_op_context_set_curr_page().
                 */
                if (err == -ENXIO)
                        continue;
                else if (err)
                        return err;

                pvr_page_destroy(op_ctx);
        }

        return 0;
}

/**
 * pvr_mmu_unmap() - Unmap pages from a memory context.
 * @op_ctx: Target MMU op context.
 * @device_addr: First device-virtual address to unmap.
 * @size: Size in bytes to unmap.
 *
 * The total amount of device-virtual memory unmapped is
 * @nr_pages * %PVR_DEVICE_PAGE_SIZE.
 *
 * Returns:
 *  * 0 on success, or
 *  * Any error code returned by pvr_page_table_ptr_init(), or
 *  * Any error code returned by pvr_page_table_ptr_unmap().
 */
int pvr_mmu_unmap(struct pvr_mmu_op_context *op_ctx, u64 device_addr, u64 size)
{
        int err = pvr_mmu_op_context_set_curr_page(op_ctx, device_addr, false);

        if (err)
                return err;

        return pvr_mmu_op_context_unmap_curr_page(op_ctx,
                                                  size >> PVR_DEVICE_PAGE_SHIFT);
}

/**
 * pvr_mmu_map_sgl() - Map part of a scatter-gather table entry to
 * device-virtual memory.
 * @op_ctx: Target MMU op context pointing to the first page that should be
 * mapped.
 * @sgl: Target scatter-gather table entry.
 * @offset: Offset into @sgl to map from. Must result in a starting address
 * from @sgl which is CPU page-aligned.
 * @size: Size of the memory to be mapped in bytes. Must be a non-zero multiple
 * of the device page size.
 * @page_flags: Page options to be applied to every device-virtual memory page
 * in the created mapping.
 *
 * Return:
 *  * 0 on success,
 *  * -%EINVAL if the range specified by @offset and @size is not completely
 *    within @sgl, or
 *  * Any error encountered while creating a page with pvr_page_create(), or
 *  * Any error encountered while advancing @op_ctx.curr_page with
 *    pvr_mmu_op_context_next_page().
 */
static int
pvr_mmu_map_sgl(struct pvr_mmu_op_context *op_ctx, struct scatterlist *sgl,
                u64 offset, u64 size, struct pvr_page_flags_raw page_flags)
{
        const unsigned int pages = size >> PVR_DEVICE_PAGE_SHIFT;
        dma_addr_t dma_addr = sg_dma_address(sgl) + offset;
        const unsigned int dma_len = sg_dma_len(sgl);
        struct pvr_page_table_ptr ptr_copy;
        unsigned int page;
        int err;

        if (size > dma_len || offset > dma_len - size)
                return -EINVAL;

        /*
         * Before progressing, save a copy of the start pointer so we can use
         * it again if we enter an error state and have to destroy pages.
         */
        memcpy(&ptr_copy, &op_ctx->curr_page, sizeof(ptr_copy));

        /*
         * Create first page outside loop, as it doesn't require a page advance
         * beforehand.
         */
        err = pvr_page_create(op_ctx, dma_addr, page_flags);
        if (err)
                return err;

        for (page = 1; page < pages; ++page) {
                err = pvr_mmu_op_context_next_page(op_ctx, true);
                if (err)
                        goto err_destroy_pages;

                dma_addr += PVR_DEVICE_PAGE_SIZE;

                err = pvr_page_create(op_ctx, dma_addr, page_flags);
                if (err)
                        goto err_destroy_pages;
        }

        return 0;

err_destroy_pages:
        memcpy(&op_ctx->curr_page, &ptr_copy, sizeof(op_ctx->curr_page));
        err = pvr_mmu_op_context_unmap_curr_page(op_ctx, page);

        return err;
}

/**
 * pvr_mmu_map() - Map an object's virtual memory to physical memory.
 * @op_ctx: Target MMU op context.
 * @size: Size of memory to be mapped in bytes. Must be a non-zero multiple
 * of the device page size.
 * @flags: Flags from pvr_gem_object associated with the mapping.
 * @device_addr: Virtual device address to map to. Must be device page-aligned.
 *
 * Returns:
 *  * 0 on success, or
 *  * Any error code returned by pvr_page_table_ptr_init(), or
 *  * Any error code returned by pvr_mmu_map_sgl(), or
 *  * Any error code returned by pvr_page_table_ptr_next_page().
 */
int pvr_mmu_map(struct pvr_mmu_op_context *op_ctx, u64 size, u64 flags,
                u64 device_addr)
{
        struct pvr_page_table_ptr ptr_copy;
        struct pvr_page_flags_raw flags_raw;
        struct scatterlist *sgl;
        u64 mapped_size = 0;
        unsigned int count;
        int err;

        if (!size)
                return 0;

        if ((op_ctx->map.sgt_offset | size) & ~PVR_DEVICE_PAGE_MASK)
                return -EINVAL;

        err = pvr_mmu_op_context_set_curr_page(op_ctx, device_addr, true);
        if (err)
                return -EINVAL;

        memcpy(&ptr_copy, &op_ctx->curr_page, sizeof(ptr_copy));

        flags_raw = pvr_page_flags_raw_create(false, false,
                                              flags & DRM_PVR_BO_BYPASS_DEVICE_CACHE,
                                              flags & DRM_PVR_BO_PM_FW_PROTECT);

        /* Map scatter gather table */
        for_each_sgtable_dma_sg(op_ctx->map.sgt, sgl, count) {
                const size_t sgl_len = sg_dma_len(sgl);
                u64 sgl_offset, map_sgl_len;

                if (sgl_len <= op_ctx->map.sgt_offset) {
                        op_ctx->map.sgt_offset -= sgl_len;
                        continue;
                }

                sgl_offset = op_ctx->map.sgt_offset;
                map_sgl_len = min_t(u64, sgl_len - sgl_offset, size - mapped_size);

                err = pvr_mmu_map_sgl(op_ctx, sgl, sgl_offset, map_sgl_len,
                                      flags_raw);
                if (err)
                        break;

                /*
                 * Flag the L0 page table as requiring a flush when the MMU op
                 * context is destroyed.
                 */
                pvr_mmu_op_context_require_sync(op_ctx, PVR_MMU_SYNC_LEVEL_0);

                op_ctx->map.sgt_offset = 0;
                mapped_size += map_sgl_len;

                if (mapped_size >= size)
                        break;

                err = pvr_mmu_op_context_next_page(op_ctx, true);
                if (err)
                        break;
        }

        if (err && mapped_size) {
                memcpy(&op_ctx->curr_page, &ptr_copy, sizeof(op_ctx->curr_page));
                pvr_mmu_op_context_unmap_curr_page(op_ctx,
                                                   mapped_size >> PVR_DEVICE_PAGE_SHIFT);
        }

        return err;
}