Prev: [PATCH] tracing: extend recordmcount to better support Blackfin mcount
Next: typo in crypto kconfig ?
From: Russell King - ARM Linux on 6 Aug 2010 03:40
On Thu, Aug 05, 2010 at 07:36:44PM -0700, Stepan Moskovchenko wrote:
> +/**
> + * struct msm_iommu_dev - a single IOMMU hardware instance
> + * name Human-readable name given to this IOMMU HW instance
> + * clk Name of the AXI clock used for the config space of this IOMMU
> + * clk_rate Rate to set for the AXI clock. 0 means don't set a rate
> + * num_ctx Number of context banks on this IOMMU device
> + *
> + */
> +struct msm_iommu_dev {
> + char *name;

const?

> + char *clk;

const? Any reason you can't have some kind of struct device instead?

> + unsigned long clk_rate;
> + unsigned int num_ctx;
> +};
> +
> +/**
> + * struct msm_iommu_ctx_dev - an IOMMU context bank instance
> + * name Human-readable name given to this context bank
> + * num Index of this context bank within the hardware
> + * mids List of Machine IDs that are to be mapped into this context
> + * bank, terminated by -1. The MID is a set of signals on the
> + * AXI bus that identifies the function associated with a specific
> + * memory request. (See ARM spec).
> + */
> +struct msm_iommu_ctx_dev {
> + char *name;

const?

> + int num;
> + int mids[MAX_NUM_MIDS];
> +};
> +
....
> +int v7_flush_kern_cache_all(void);

No - don't use internal functions directly. Use flush_cache_all()
instead.

> +#ifndef __ARCH_ARM_MACH_MSM_IOMMU_HW_8XXX_H
> +#define __ARCH_ARM_MACH_MSM_IOMMU_HW_8XXX_H
> +
> +#define CTX_SHIFT 12
> +
> +#define GET_GLOBAL_REG(reg, base) (readl((base)|(reg)))
> +#define GET_CTX_REG(reg, base, ctx) (readl((base)|(reg)|((ctx)<<CTX_SHIFT)))

This doesn't work if 'base' is correctly typed. Use addition please.
Spacces around operators please.

> +
> +#define SET_GLOBAL_REG(reg, base, val) (writel((val), (base) | (reg)))
> +
> +#define SET_CTX_REG(reg, base, ctx, val) \
> + (writel((val), (base) | (reg) | ((ctx)<<CTX_SHIFT)))

Addition.

> +
> +/* Wrappers for numbered registers */
> +#define SET_GLOBAL_REG_N(b, n, r, v) SET_GLOBAL_REG(b, ((r)|(n<<2)), (v))
> +#define GET_GLOBAL_REG_N(b, n, r) GET_GLOBAL_REG(b, ((r)|(n<<2)))
> +
> +/* Field wrappers */
> +#define GET_GLOBAL_FIELD(b, r, F) GET_FIELD(((b)|(r)), F##_MASK, F##_SHIFT)
> +#define GET_CONTEXT_FIELD(b, c, r, F) \
> + GET_FIELD(((b)|(r)|((c)<<CTX_SHIFT)), F##_MASK, F##_SHIFT)
> +
> +#define SET_GLOBAL_FIELD(b, r, F, v) \
> + SET_FIELD(((b)|(r)), F##_MASK, F##_SHIFT, (v))
> +#define SET_CONTEXT_FIELD(b, c, r, F, v) \
> + SET_FIELD(((b)|(r)|((c)<<CTX_SHIFT)), F##_MASK, F##_SHIFT, (v))
> +
> +#define GET_FIELD(addr, mask, shift) ((readl(addr) >> (shift) & (mask)))
> +
> +#define SET_FIELD(addr, mask, shift, v) \
> +do { \
> + int t = readl(addr); mb(); \
> + writel((t & ~((mask)<<(shift))) | (((v) & (mask)) << (shift)), addr);\
> + mb();\

readl/writel have barriers now, so these probably aren't required. Please
check.

....
> + if (len == SZ_16M) {
> + int i = 0;
> + for (i = 0; i < 16; i++)
> + *(fl_pte+i) = (pa & 0xFF000000) | PMD_SECT_SUPER |
> + PMD_SECT_AP_READ | PMD_SECT_AP_WRITE |
> + PMD_TYPE_SECT | PMD_SECT_S;

Don't reuse the kernel's definitions for its own page tables for IOMMU
page tables.

> + }
> +
> + if (len == SZ_1M)
> + *fl_pte = (pa & 0xFFF00000) | PMD_SECT_AP_READ |
> + PMD_SECT_AP_WRITE | PMD_TYPE_SECT |
> + PMD_SECT_S;

Ditto.

> +
> + /* Need a 2nd level table */
> + if ((len == SZ_4K || len == SZ_64K) && (*fl_pte) == 0) {
> + unsigned long *sl;
> + sl = (unsigned long *) __get_free_pages(GFP_KERNEL, 0);
> +
> + if (!sl) {
> + pr_err("could not allocate second level table\n");
> + goto fail_nomem;
> + }
> +
> + memset(sl, 0, SZ_4K);
> + *fl_pte = ((((int)__pa(sl)) & 0xFFFFFC00) | PMD_TYPE_TABLE);

Ditto.

> + }
> +
> + sl_table = (unsigned long *) __va(((*fl_pte) & 0xFFFFFC00));
> + sl_offset = SL_OFFSET(va);
> + sl_pte = sl_table + sl_offset;
> +
> +
> + if (len == SZ_4K)
> + *sl_pte = (pa & 0xFFFFF000) | PTE_EXT_AP0 | PTE_EXT_AP1 |
> + PTE_EXT_SHARED | PTE_TYPE_SMALL;

Ditto.

> +
> + if (len == SZ_64K) {
> + int i;
> +
> + for (i = 0; i < 16; i++)
> + *(sl_pte+i) = (pa & 0xFFFF0000) | PTE_EXT_AP0 |
> + PTE_EXT_AP1 | PTE_EXT_SHARED | PTE_TYPE_LARGE;

Ditto.

> + }
> +
> +#ifndef CONFIG_IOMMU_PGTABLES_L2
> + v7_flush_kern_cache_all();
> +#endif

What has L2 got to do with whether you flush the L1 cache?
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo(a)vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
From: stepanm on 6 Aug 2010 04:20
> On Thu, Aug 05, 2010 at 07:36:44PM -0700, Stepan Moskovchenko wrote:
>> +/**
>> + * struct msm_iommu_dev - a single IOMMU hardware instance
>> + * name Human-readable name given to this IOMMU HW instance
>> + * clk Name of the AXI clock used for the config space of this IOMMU
>> + * clk_rate Rate to set for the AXI clock. 0 means don't set a rate
>> + * num_ctx Number of context banks on this IOMMU device
>> + *
>> + */
>> +struct msm_iommu_dev {
>> + char *name;
>
> const?
>
>> + char *clk;
>
> const? Any reason you can't have some kind of struct device instead?
>
>> + unsigned long clk_rate;
>> + unsigned int num_ctx;
>> +};
>> +
>> +/**
>> + * struct msm_iommu_ctx_dev - an IOMMU context bank instance
>> + * name Human-readable name given to this context bank
>> + * num Index of this context bank within the hardware
>> + * mids List of Machine IDs that are to be mapped into this context
>> + * bank, terminated by -1. The MID is a set of signals on the
>> + * AXI bus that identifies the function associated with a specific
>> + * memory request. (See ARM spec).
>> + */
>> +struct msm_iommu_ctx_dev {
>> + char *name;
>
> const?
>
>> + int num;
>> + int mids[MAX_NUM_MIDS];
>> +};
>> +
> ...
>> +int v7_flush_kern_cache_all(void);
>
> No - don't use internal functions directly. Use flush_cache_all()
> instead.
>
>> +#ifndef __ARCH_ARM_MACH_MSM_IOMMU_HW_8XXX_H
>> +#define __ARCH_ARM_MACH_MSM_IOMMU_HW_8XXX_H
>> +
>> +#define CTX_SHIFT 12
>> +
>> +#define GET_GLOBAL_REG(reg, base) (readl((base)|(reg)))
>> +#define GET_CTX_REG(reg, base,
>> ctx) (readl((base)|(reg)|((ctx)<<CTX_SHIFT)))
>
> This doesn't work if 'base' is correctly typed. Use addition please.
> Spacces around operators please.
>
>> +
>> +#define SET_GLOBAL_REG(reg, base, val) (writel((val), (base) | (reg)))
>> +
>> +#define SET_CTX_REG(reg, base, ctx, val) \
>> + (writel((val), (base) | (reg) | ((ctx)<<CTX_SHIFT)))
>
> Addition.
>
>> +
>> +/* Wrappers for numbered registers */
>> +#define SET_GLOBAL_REG_N(b, n, r, v) SET_GLOBAL_REG(b, ((r)|(n<<2)),
>> (v))
>> +#define GET_GLOBAL_REG_N(b, n, r) GET_GLOBAL_REG(b, ((r)|(n<<2)))
>> +
>> +/* Field wrappers */
>> +#define GET_GLOBAL_FIELD(b, r, F) GET_FIELD(((b)|(r)), F##_MASK,
>> F##_SHIFT)
>> +#define GET_CONTEXT_FIELD(b, c, r, F) \
>> + GET_FIELD(((b)|(r)|((c)<<CTX_SHIFT)), F##_MASK, F##_SHIFT)
>> +
>> +#define SET_GLOBAL_FIELD(b, r, F, v) \
>> + SET_FIELD(((b)|(r)), F##_MASK, F##_SHIFT, (v))
>> +#define SET_CONTEXT_FIELD(b, c, r, F, v) \
>> + SET_FIELD(((b)|(r)|((c)<<CTX_SHIFT)), F##_MASK, F##_SHIFT, (v))
>> +
>> +#define GET_FIELD(addr, mask, shift) ((readl(addr) >> (shift) &
>> (mask)))
>> +
>> +#define SET_FIELD(addr, mask, shift, v) \
>> +do { \
>> + int t = readl(addr); mb(); \
>> + writel((t & ~((mask)<<(shift))) | (((v) & (mask)) << (shift)), addr);\
>> + mb();\
>
> readl/writel have barriers now, so these probably aren't required. Please
> check.
>
> ...
>> + if (len == SZ_16M) {
>> + int i = 0;
>> + for (i = 0; i < 16; i++)
>> + *(fl_pte+i) = (pa & 0xFF000000) | PMD_SECT_SUPER |
>> + PMD_SECT_AP_READ | PMD_SECT_AP_WRITE |
>> + PMD_TYPE_SECT | PMD_SECT_S;
>
> Don't reuse the kernel's definitions for its own page tables for IOMMU
> page tables.
>
>> + }
>> +
>> + if (len == SZ_1M)
>> + *fl_pte = (pa & 0xFFF00000) | PMD_SECT_AP_READ |
>> + PMD_SECT_AP_WRITE | PMD_TYPE_SECT |
>> + PMD_SECT_S;
>
> Ditto.
>
>> +
>> + /* Need a 2nd level table */
>> + if ((len == SZ_4K || len == SZ_64K) && (*fl_pte) == 0) {
>> + unsigned long *sl;
>> + sl = (unsigned long *) __get_free_pages(GFP_KERNEL, 0);
>> +
>> + if (!sl) {
>> + pr_err("could not allocate second level table\n");
>> + goto fail_nomem;
>> + }
>> +
>> + memset(sl, 0, SZ_4K);
>> + *fl_pte = ((((int)__pa(sl)) & 0xFFFFFC00) | PMD_TYPE_TABLE);
>
> Ditto.
>
>> + }
>> +
>> + sl_table = (unsigned long *) __va(((*fl_pte) & 0xFFFFFC00));
>> + sl_offset = SL_OFFSET(va);
>> + sl_pte = sl_table + sl_offset;
>> +
>> +
>> + if (len == SZ_4K)
>> + *sl_pte = (pa & 0xFFFFF000) | PTE_EXT_AP0 | PTE_EXT_AP1 |
>> + PTE_EXT_SHARED | PTE_TYPE_SMALL;
>
> Ditto.
>
>> +
>> + if (len == SZ_64K) {
>> + int i;
>> +
>> + for (i = 0; i < 16; i++)
>> + *(sl_pte+i) = (pa & 0xFFFF0000) | PTE_EXT_AP0 |
>> + PTE_EXT_AP1 | PTE_EXT_SHARED | PTE_TYPE_LARGE;
>
> Ditto.
>
>> + }
>> +
>> +#ifndef CONFIG_IOMMU_PGTABLES_L2
>> + v7_flush_kern_cache_all();
>> +#endif
>
> What has L2 got to do with whether you flush the L1 cache?

Hello

Thank you for your comments. I will apply the fixes you have mentioned. I
am flushing the cache when I update the page table because the page table
lives in regular RAM that is mapped as cacheable on the CPU side, and in
the default configuration the IOMMU reads the page table from RAM. So, I
have put in the flush call to give the IOMMU a coherent view of the page
tables. I realize it is more efficient to just flush that specific part of
L2, but this is just the basic version of the driver and that optimization
will be eventually put in. The hardware is actually capable of reading the
IOMMU page table straight out of the L2 cache, but I haven't figured out
how much control the API should give over this feature... initially I was
thinking of a Kconfig "sub-option" for it but maybe more fine-grained
control is in order, depending on the access pattern of each IOMMU. I can
add this functionality in a subsequent patch, once the basic driver is in.
If flushing the cache in this manner is not the right way to handle IOMMU
page tables, can you please suggest what would be more appropriate?

What did you mean by:
> Any reason you can't have some kind of struct device instead?

Are you referring to the clock line? As far as I understand it, the kernel
tracks the clocks by a string name, but I can look into it further. Only a
few of the IOMMUs even have clocks that I need to control in this manner,
and these are only accessed at init time. From what I remember, it is
possible to "get" a clock device, but I am not sure these can be
statically added to the struct like that.

I will make the changes you suggested and post another version soon.

Thanks
Steve

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo(a)vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
From: Russell King - ARM Linux on 6 Aug 2010 05:10
On Fri, Aug 06, 2010 at 01:17:46AM -0700, stepanm(a)codeaurora.org wrote:
> Thank you for your comments. I will apply the fixes you have mentioned. I
> am flushing the cache when I update the page table because the page table
> lives in regular RAM that is mapped as cacheable on the CPU side, and in
> the default configuration the IOMMU reads the page table from RAM.

That's fine, but use the right function.

> So, I
> have put in the flush call to give the IOMMU a coherent view of the page
> tables. I realize it is more efficient to just flush that specific part of
> L2, but this is just the basic version of the driver and that optimization
> will be eventually put in.

Here, you're talking about L2 again, but your code only touches the L1
cache. I think you're confused about caching.

> What did you mean by:
> > Any reason you can't have some kind of struct device instead?
>
> Are you referring to the clock line? As far as I understand it, the kernel
> tracks the clocks by a string name, but I can look into it further.

No.

/**
* clk_get - lookup and obtain a reference to a clock producer.
* @dev: device for clock "consumer"
* @id: clock comsumer ID
*
* Returns a struct clk corresponding to the clock producer, or
* valid IS_ERR() condition containing errno. The implementation
* uses @dev and @id to determine the clock consumer, and thereby
* the clock producer. (IOW, @id may be identical strings, but
* clk_get may return different clock producers depending on @dev.)

The intention is that 'id' is specific to each 'dev', and identifies
the connection on 'dev' that you want the clock for. It's the
_consumer's_ name, nothing to do with the clock producer.

There's also clk_get_sys() if you don't have a struct device.
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo(a)vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
From: Stepan Moskovchenko on 6 Aug 2010 19:10
On 8/6/2010 1:59 AM, Russell King - ARM Linux wrote:
> On Fri, Aug 06, 2010 at 01:17:46AM -0700, stepanm(a)codeaurora.org wrote:
>> Thank you for your comments. I will apply the fixes you have mentioned. I
>> am flushing the cache when I update the page table because the page table
>> lives in regular RAM that is mapped as cacheable on the CPU side, and in
>> the default configuration the IOMMU reads the page table from RAM.
> That's fine, but use the right function.
>
>> So, I
>> have put in the flush call to give the IOMMU a coherent view of the page
>> tables. I realize it is more efficient to just flush that specific part of
>> L2, but this is just the basic version of the driver and that optimization
>> will be eventually put in.
> Here, you're talking about L2 again, but your code only touches the L1
> cache. I think you're confused about caching.
>
>> What did you mean by:
>>> Any reason you can't have some kind of struct device instead?
>> Are you referring to the clock line? As far as I understand it, the kernel
>> tracks the clocks by a string name, but I can look into it further.
> No.
>
> /**
> * clk_get - lookup and obtain a reference to a clock producer.
> * @dev: device for clock "consumer"
> * @id: clock comsumer ID
> *
> * Returns a struct clk corresponding to the clock producer, or
> * valid IS_ERR() condition containing errno. The implementation
> * uses @dev and @id to determine the clock consumer, and thereby
> * the clock producer. (IOW, @id may be identical strings, but
> * clk_get may return different clock producers depending on @dev.)
>
> The intention is that 'id' is specific to each 'dev', and identifies
> the connection on 'dev' that you want the clock for. It's the
> _consumer's_ name, nothing to do with the clock producer.
>
> There's also clk_get_sys() if you don't have a struct device.
> --
> To unsubscribe from this list: send the line "unsubscribe linux-arm-msm" in
> the body of a message to majordomo(a)vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
Russell,
Thanks for the information. Getting the clock by the device as you
suggest should be fine. I believe I have addressed your other comments
as well. I've sent out a v2 patch. Please let me know what you think.

Thanks
Steve
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo(a)vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
From: Russell King - ARM Linux on 7 Aug 2010 10:00
On Fri, Aug 06, 2010 at 04:04:41PM -0700, Stepan Moskovchenko wrote:
> +/**
> + * struct msm_iommu_dev - a single IOMMU hardware instance
> + * name Human-readable name given to this IOMMU HW instance
> + * clk_rate Rate to set for this IOMMU's clock, if applicable to this
> + * particular IOMMU. 0 means don't set a rate.
> + *
> + */
> +struct msm_iommu_dev {
> + const char *name;
> + const unsigned long clk_rate;

Integers don't have to be const - far better to make the parent structure
const if that's what you want, and arrange for functions that are passed
the structure to take a pointer to 'const struct mem_iommu_dev'.

> +};
> +
> +/**
> + * struct msm_iommu_ctx_dev - an IOMMU context bank instance
> + * name Human-readable name given to this context bank
> + * num Index of this context bank within the hardware
> + * mids List of Machine IDs that are to be mapped into this context
> + * bank, terminated by -1. The MID is a set of signals on the
> + * AXI bus that identifies the function associated with a specific
> + * memory request. (See ARM spec).
> + */
> +struct msm_iommu_ctx_dev {
> + const char *name;
> + const int num;
> + const int mids[MAX_NUM_MIDS];
> +};

Ditto.

> +
> +
> +/**
> + * struct msm_iommu_drvdata - A single IOMMU hardware instance
> + * @base: IOMMU config port base address (VA)
> + * @irq: Interrupt number
> + *
> + * A msm_iommu_drvdata holds the global driver data about a single piece
> + * of an IOMMU hardware instance.
> + */
> +struct msm_iommu_drvdata {
> + unsigned long base;

void __iomem *base;

MMIO cookies are pointer-like, not integer like.

> + int irq;
> +};
> +
> +/**
> + * struct msm_iommu_ctx_drvdata - an IOMMU context bank instance
> + * @num: Hardware context number of this context
> + * @pdev: Platform device associated wit this HW instance
> + * @attached_elm: List element for domains to track which devices are
> + * attached to them
> + *
> + * A msm_iommu_ctx_drvdata holds the driver data for a single context bank
> + * within each IOMMU hardware instance
> + */
> +struct msm_iommu_ctx_drvdata {
> + int num;
> + struct platform_device *pdev;
> + struct list_head attached_elm;
> +};
> +
> +/*
> + * Look up an IOMMU context device by its context name. NULL if none found.
> + * Useful for testing and drivers that do not yet fully have IOMMU stuff in
> + * their platform devices.
> + */
> +struct device *msm_iommu_get_ctx(const char *ctx_name);
> +
> +/*
> + * Interrupt handler for the IOMMU context fault interrupt. Hooking the
> + * interrupt is not supported in the API yet, but this will print an error
> + * message and dump useful IOMMU registers.
> + */
> +irqreturn_t msm_iommu_fault_handler(int irq, void *dev_id);
> +
> +#endif
> diff --git a/arch/arm/mach-msm/include/mach/iommu_hw-8xxx.h b/arch/arm/mach-msm/include/mach/iommu_hw-8xxx.h
> new file mode 100644
> index 0000000..427735e
> --- /dev/null
> +++ b/arch/arm/mach-msm/include/mach/iommu_hw-8xxx.h
> @@ -0,0 +1,1864 @@
> +/* Copyright (c) 2010, Code Aurora Forum. All rights reserved.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + * GNU General Public License for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program; if not, write to the Free Software
> + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
> + * 02110-1301, USA.
> + */
> +
> +#ifndef __ARCH_ARM_MACH_MSM_IOMMU_HW_8XXX_H
> +#define __ARCH_ARM_MACH_MSM_IOMMU_HW_8XXX_H
> +
> +#define CTX_SHIFT 12
> +
> +#define GET_GLOBAL_REG(reg, base) (readl((base) + (reg)))
> +#define GET_CTX_REG(reg, base, ctx) \
> + (readl((base) + (reg) + ((ctx) << CTX_SHIFT)))
> +
> +#define SET_GLOBAL_REG(reg, base, val) (writel((val), ((base) + (reg))))

Parens around writel not required.

> +
> +#define SET_CTX_REG(reg, base, ctx, val) \
> + (writel((val), ((base) + (reg) + ((ctx) << CTX_SHIFT))))

Parens around writel not required.

> +
> +/* Wrappers for numbered registers */
> +#define SET_GLOBAL_REG_N(b, n, r, v) SET_GLOBAL_REG(b, ((r) + (n << 2)), (v))
> +#define GET_GLOBAL_REG_N(b, n, r) GET_GLOBAL_REG(b, ((r) + (n << 2)))
> +
> +/* Field wrappers */
> +#define GET_GLOBAL_FIELD(b, r, F) GET_FIELD(((b) + (r)), F##_MASK, F##_SHIFT)
> +#define GET_CONTEXT_FIELD(b, c, r, F) \
> + GET_FIELD(((b) + (r) + ((c) << CTX_SHIFT)), F##_MASK, F##_SHIFT)
> +
> +#define SET_GLOBAL_FIELD(b, r, F, v) \
> + SET_FIELD(((b) + (r)), F##_MASK, F##_SHIFT, (v))
> +#define SET_CONTEXT_FIELD(b, c, r, F, v) \
> + SET_FIELD(((b) + (r) + ((c) << CTX_SHIFT)), F##_MASK, F##_SHIFT, (v))
> +
> +#define GET_FIELD(addr, mask, shift) ((readl(addr) >> (shift)) & (mask))
> +
> +#define SET_FIELD(addr, mask, shift, v) \
> +do { \
> + int t = readl(addr); \
> + writel((t & ~((mask) << (shift))) + (((v) & (mask)) << (shift)), addr);\
> +} while (0)
> +
> +
> +/* First-level page table bits */
> +#define FL_TYPE_TABLE (1 << 0)
> +#define FL_TYPE_SECT (2 << 0)
> +#define FL_SUPERSECTION (1 << 18)
> +#define FL_AP_WRITE (1 << 10)
> +#define FL_AP_READ (1 << 11)
> +#define FL_SHARED (1 << 16)
> +
> +/* Second-level page table bits */
> +#define SL_TYPE_LARGE (1 << 0)
> +#define SL_TYPE_SMALL (2 << 0)
> +#define SL_AP0 (1 << 4)
> +#define SL_AP1 (2 << 4)
> +#define SL_SHARED (1 << 10)
> +
> +
> +/* Global register setters / getters */
> +#define SET_M2VCBR_N(b, N, v) SET_GLOBAL_REG_N(M2VCBR_N, N, (b), (v))
> +#define SET_CBACR_N(b, N, v) SET_GLOBAL_REG_N(CBACR_N, N, (b), (v))
> +#define SET_TLBRSW(b, v) SET_GLOBAL_REG(TLBRSW, (b), (v))
> +#define SET_TLBTR0(b, v) SET_GLOBAL_REG(TLBTR0, (b), (v))
> +#define SET_TLBTR1(b, v) SET_GLOBAL_REG(TLBTR1, (b), (v))
> +#define SET_TLBTR2(b, v) SET_GLOBAL_REG(TLBTR2, (b), (v))
> +#define SET_TESTBUSCR(b, v) SET_GLOBAL_REG(TESTBUSCR, (b), (v))
> +#define SET_GLOBAL_TLBIALL(b, v) SET_GLOBAL_REG(GLOBAL_TLBIALL, (b), (v))
> +#define SET_TLBIVMID(b, v) SET_GLOBAL_REG(TLBIVMID, (b), (v))
> +#define SET_CR(b, v) SET_GLOBAL_REG(CR, (b), (v))
> +#define SET_EAR(b, v) SET_GLOBAL_REG(EAR, (b), (v))
> +#define SET_ESR(b, v) SET_GLOBAL_REG(ESR, (b), (v))
> +#define SET_ESRRESTORE(b, v) SET_GLOBAL_REG(ESRRESTORE, (b), (v))
> +#define SET_ESYNR0(b, v) SET_GLOBAL_REG(ESYNR0, (b), (v))
> +#define SET_ESYNR1(b, v) SET_GLOBAL_REG(ESYNR1, (b), (v))
> +#define SET_RPU_ACR(b, v) SET_GLOBAL_REG(RPU_ACR, (b), (v))
> +
> +#define GET_M2VCBR_N(b, N) GET_GLOBAL_REG_N(M2VCBR_N, N, (b))
> +#define GET_CBACR_N(b, N) GET_GLOBAL_REG_N(CBACR_N, N, (b))
> +#define GET_TLBTR0(b) GET_GLOBAL_REG(TLBTR0, (b))
> +#define GET_TLBTR1(b) GET_GLOBAL_REG(TLBTR1, (b))
> +#define GET_TLBTR2(b) GET_GLOBAL_REG(TLBTR2, (b))
> +#define GET_TESTBUSCR(b) GET_GLOBAL_REG(TESTBUSCR, (b))
> +#define GET_GLOBAL_TLBIALL(b) GET_GLOBAL_REG(GLOBAL_TLBIALL, (b))
> +#define GET_TLBIVMID(b) GET_GLOBAL_REG(TLBIVMID, (b))
> +#define GET_CR(b) GET_GLOBAL_REG(CR, (b))
> +#define GET_EAR(b) GET_GLOBAL_REG(EAR, (b))
> +#define GET_ESR(b) GET_GLOBAL_REG(ESR, (b))
> +#define GET_ESRRESTORE(b) GET_GLOBAL_REG(ESRRESTORE, (b))
> +#define GET_ESYNR0(b) GET_GLOBAL_REG(ESYNR0, (b))
> +#define GET_ESYNR1(b) GET_GLOBAL_REG(ESYNR1, (b))
> +#define GET_REV(b) GET_GLOBAL_REG(REV, (b))
> +#define GET_IDR(b) GET_GLOBAL_REG(IDR, (b))
> +#define GET_RPU_ACR(b) GET_GLOBAL_REG(RPU_ACR, (b))
> +
> +
> +/* Context register setters/getters */
> +#define SET_SCTLR(b, c, v) SET_CTX_REG(SCTLR, (b), (c), (v))
> +#define SET_ACTLR(b, c, v) SET_CTX_REG(ACTLR, (b), (c), (v))
> +#define SET_CONTEXTIDR(b, c, v) SET_CTX_REG(CONTEXTIDR, (b), (c), (v))
> +#define SET_TTBR0(b, c, v) SET_CTX_REG(TTBR0, (b), (c), (v))
> +#define SET_TTBR1(b, c, v) SET_CTX_REG(TTBR1, (b), (c), (v))
> +#define SET_TTBCR(b, c, v) SET_CTX_REG(TTBCR, (b), (c), (v))
> +#define SET_PAR(b, c, v) SET_CTX_REG(PAR, (b), (c), (v))
> +#define SET_FSR(b, c, v) SET_CTX_REG(FSR, (b), (c), (v))
> +#define SET_FSRRESTORE(b, c, v) SET_CTX_REG(FSRRESTORE, (b), (c), (v))
> +#define SET_FAR(b, c, v) SET_CTX_REG(FAR, (b), (c), (v))
> +#define SET_FSYNR0(b, c, v) SET_CTX_REG(FSYNR0, (b), (c), (v))
> +#define SET_FSYNR1(b, c, v) SET_CTX_REG(FSYNR1, (b), (c), (v))
> +#define SET_PRRR(b, c, v) SET_CTX_REG(PRRR, (b), (c), (v))
> +#define SET_NMRR(b, c, v) SET_CTX_REG(NMRR, (b), (c), (v))
> +#define SET_TLBLKCR(b, c, v) SET_CTX_REG(TLBLCKR, (b), (c), (v))
> +#define SET_V2PSR(b, c, v) SET_CTX_REG(V2PSR, (b), (c), (v))
> +#define SET_TLBFLPTER(b, c, v) SET_CTX_REG(TLBFLPTER, (b), (c), (v))
> +#define SET_TLBSLPTER(b, c, v) SET_CTX_REG(TLBSLPTER, (b), (c), (v))
> +#define SET_BFBCR(b, c, v) SET_CTX_REG(BFBCR, (b), (c), (v))
> +#define SET_CTX_TLBIALL(b, c, v) SET_CTX_REG(CTX_TLBIALL, (b), (c), (v))
> +#define SET_TLBIASID(b, c, v) SET_CTX_REG(TLBIASID, (b), (c), (v))
> +#define SET_TLBIVA(b, c, v) SET_CTX_REG(TLBIVA, (b), (c), (v))
> +#define SET_TLBIVAA(b, c, v) SET_CTX_REG(TLBIVAA, (b), (c), (v))
> +#define SET_V2PPR(b, c, v) SET_CTX_REG(V2PPR, (b), (c), (v))
> +#define SET_V2PPW(b, c, v) SET_CTX_REG(V2PPW, (b), (c), (v))
> +#define SET_V2PUR(b, c, v) SET_CTX_REG(V2PUR, (b), (c), (v))
> +#define SET_V2PUW(b, c, v) SET_CTX_REG(V2PUW, (b), (c), (v))
> +#define SET_RESUME(b, c, v) SET_CTX_REG(RESUME, (b), (c), (v))
> +
> +#define GET_SCTLR(b, c) GET_CTX_REG(SCTLR, (b), (c))
> +#define GET_ACTLR(b, c) GET_CTX_REG(ACTLR, (b), (c))
> +#define GET_CONTEXTIDR(b, c) GET_CTX_REG(CONTEXTIDR, (b), (c))
> +#define GET_TTBR0(b, c) GET_CTX_REG(TTBR0, (b), (c))
> +#define GET_TTBR1(b, c) GET_CTX_REG(TTBR1, (b), (c))
> +#define GET_TTBCR(b, c) GET_CTX_REG(TTBCR, (b), (c))
> +#define GET_PAR(b, c) GET_CTX_REG(PAR, (b), (c))
> +#define GET_FSR(b, c) GET_CTX_REG(FSR, (b), (c))
> +#define GET_FSRRESTORE(b, c) GET_CTX_REG(FSRRESTORE, (b), (c))
> +#define GET_FAR(b, c) GET_CTX_REG(FAR, (b), (c))
> +#define GET_FSYNR0(b, c) GET_CTX_REG(FSYNR0, (b), (c))
> +#define GET_FSYNR1(b, c) GET_CTX_REG(FSYNR1, (b), (c))
> +#define GET_PRRR(b, c) GET_CTX_REG(PRRR, (b), (c))
> +#define GET_NMRR(b, c) GET_CTX_REG(NMRR, (b), (c))
> +#define GET_TLBLCKR(b, c) GET_CTX_REG(TLBLCKR, (b), (c))
> +#define GET_V2PSR(b, c) GET_CTX_REG(V2PSR, (b), (c))
> +#define GET_TLBFLPTER(b, c) GET_CTX_REG(TLBFLPTER, (b), (c))
> +#define GET_TLBSLPTER(b, c) GET_CTX_REG(TLBSLPTER, (b), (c))
> +#define GET_BFBCR(b, c) GET_CTX_REG(BFBCR, (b), (c))
> +#define GET_CTX_TLBIALL(b, c) GET_CTX_REG(CTX_TLBIALL, (b), (c))
> +#define GET_TLBIASID(b, c) GET_CTX_REG(TLBIASID, (b), (c))
> +#define GET_TLBIVA(b, c) GET_CTX_REG(TLBIVA, (b), (c))
> +#define GET_TLBIVAA(b, c) GET_CTX_REG(TLBIVAA, (b), (c))
> +#define GET_V2PPR(b, c) GET_CTX_REG(V2PPR, (b), (c))
> +#define GET_V2PPW(b, c) GET_CTX_REG(V2PPW, (b), (c))
> +#define GET_V2PUR(b, c) GET_CTX_REG(V2PUR, (b), (c))
> +#define GET_V2PUW(b, c) GET_CTX_REG(V2PUW, (b), (c))
> +#define GET_RESUME(b, c) GET_CTX_REG(RESUME, (b), (c))
> +
> +
> +/* Global field setters / getters */
> +/* Global Field Setters: */
> +/* CBACR_N */
> +#define SET_RWVMID(b, n, v) SET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), RWVMID, v)
> +#define SET_RWE(b, n, v) SET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), RWE, v)
> +#define SET_RWGE(b, n, v) SET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), RWGE, v)
> +#define SET_CBVMID(b, n, v) SET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), CBVMID, v)
> +#define SET_IRPTNDX(b, n, v) SET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), IRPTNDX, v)
> +
> +
> +/* M2VCBR_N */
> +#define SET_VMID(b, n, v) SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), VMID, v)
> +#define SET_CBNDX(b, n, v) SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), CBNDX, v)
> +#define SET_BYPASSD(b, n, v) SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BYPASSD, v)
> +#define SET_BPRCOSH(b, n, v) SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPRCOSH, v)
> +#define SET_BPRCISH(b, n, v) SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPRCISH, v)
> +#define SET_BPRCNSH(b, n, v) SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPRCNSH, v)
> +#define SET_BPSHCFG(b, n, v) SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPSHCFG, v)
> +#define SET_NSCFG(b, n, v) SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), NSCFG, v)
> +#define SET_BPMTCFG(b, n, v) SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPMTCFG, v)
> +#define SET_BPMEMTYPE(b, n, v) \
> + SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPMEMTYPE, v)
> +
> +
> +/* CR */
> +#define SET_RPUE(b, v) SET_GLOBAL_FIELD(b, CR, RPUE, v)
> +#define SET_RPUERE(b, v) SET_GLOBAL_FIELD(b, CR, RPUERE, v)
> +#define SET_RPUEIE(b, v) SET_GLOBAL_FIELD(b, CR, RPUEIE, v)
> +#define SET_DCDEE(b, v) SET_GLOBAL_FIELD(b, CR, DCDEE, v)
> +#define SET_CLIENTPD(b, v) SET_GLOBAL_FIELD(b, CR, CLIENTPD, v)
> +#define SET_STALLD(b, v) SET_GLOBAL_FIELD(b, CR, STALLD, v)
> +#define SET_TLBLKCRWE(b, v) SET_GLOBAL_FIELD(b, CR, TLBLKCRWE, v)
> +#define SET_CR_TLBIALLCFG(b, v) SET_GLOBAL_FIELD(b, CR, CR_TLBIALLCFG, v)
> +#define SET_TLBIVMIDCFG(b, v) SET_GLOBAL_FIELD(b, CR, TLBIVMIDCFG, v)
> +#define SET_CR_HUME(b, v) SET_GLOBAL_FIELD(b, CR, CR_HUME, v)
> +
> +
> +/* ESR */
> +#define SET_CFG(b, v) SET_GLOBAL_FIELD(b, ESR, CFG, v)
> +#define SET_BYPASS(b, v) SET_GLOBAL_FIELD(b, ESR, BYPASS, v)
> +#define SET_ESR_MULTI(b, v) SET_GLOBAL_FIELD(b, ESR, ESR_MULTI, v)
> +
> +
> +/* ESYNR0 */
> +#define SET_ESYNR0_AMID(b, v) SET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_AMID, v)
> +#define SET_ESYNR0_APID(b, v) SET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_APID, v)
> +#define SET_ESYNR0_ABID(b, v) SET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_ABID, v)
> +#define SET_ESYNR0_AVMID(b, v) SET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_AVMID, v)
> +#define SET_ESYNR0_ATID(b, v) SET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_ATID, v)
> +
> +
> +/* ESYNR1 */
> +#define SET_ESYNR1_AMEMTYPE(b, v) \
> + SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AMEMTYPE, v)
> +#define SET_ESYNR1_ASHARED(b, v) SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ASHARED, v)
> +#define SET_ESYNR1_AINNERSHARED(b, v) \
> + SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AINNERSHARED, v)
> +#define SET_ESYNR1_APRIV(b, v) SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_APRIV, v)
> +#define SET_ESYNR1_APROTNS(b, v) SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_APROTNS, v)
> +#define SET_ESYNR1_AINST(b, v) SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AINST, v)
> +#define SET_ESYNR1_AWRITE(b, v) SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AWRITE, v)
> +#define SET_ESYNR1_ABURST(b, v) SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ABURST, v)
> +#define SET_ESYNR1_ALEN(b, v) SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ALEN, v)
> +#define SET_ESYNR1_ASIZE(b, v) SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ASIZE, v)
> +#define SET_ESYNR1_ALOCK(b, v) SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ALOCK, v)
> +#define SET_ESYNR1_AOOO(b, v) SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AOOO, v)
> +#define SET_ESYNR1_AFULL(b, v) SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AFULL, v)
> +#define SET_ESYNR1_AC(b, v) SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AC, v)
> +#define SET_ESYNR1_DCD(b, v) SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_DCD, v)
> +
> +
> +/* TESTBUSCR */
> +#define SET_TBE(b, v) SET_GLOBAL_FIELD(b, TESTBUSCR, TBE, v)
> +#define SET_SPDMBE(b, v) SET_GLOBAL_FIELD(b, TESTBUSCR, SPDMBE, v)
> +#define SET_WGSEL(b, v) SET_GLOBAL_FIELD(b, TESTBUSCR, WGSEL, v)
> +#define SET_TBLSEL(b, v) SET_GLOBAL_FIELD(b, TESTBUSCR, TBLSEL, v)
> +#define SET_TBHSEL(b, v) SET_GLOBAL_FIELD(b, TESTBUSCR, TBHSEL, v)
> +#define SET_SPDM0SEL(b, v) SET_GLOBAL_FIELD(b, TESTBUSCR, SPDM0SEL, v)
> +#define SET_SPDM1SEL(b, v) SET_GLOBAL_FIELD(b, TESTBUSCR, SPDM1SEL, v)
> +#define SET_SPDM2SEL(b, v) SET_GLOBAL_FIELD(b, TESTBUSCR, SPDM2SEL, v)
> +#define SET_SPDM3SEL(b, v) SET_GLOBAL_FIELD(b, TESTBUSCR, SPDM3SEL, v)
> +
> +
> +/* TLBIVMID */
> +#define SET_TLBIVMID_VMID(b, v) SET_GLOBAL_FIELD(b, TLBIVMID, TLBIVMID_VMID, v)
> +
> +
> +/* TLBRSW */
> +#define SET_TLBRSW_INDEX(b, v) SET_GLOBAL_FIELD(b, TLBRSW, TLBRSW_INDEX, v)
> +#define SET_TLBBFBS(b, v) SET_GLOBAL_FIELD(b, TLBRSW, TLBBFBS, v)
> +
> +
> +/* TLBTR0 */
> +#define SET_PR(b, v) SET_GLOBAL_FIELD(b, TLBTR0, PR, v)
> +#define SET_PW(b, v) SET_GLOBAL_FIELD(b, TLBTR0, PW, v)
> +#define SET_UR(b, v) SET_GLOBAL_FIELD(b, TLBTR0, UR, v)
> +#define SET_UW(b, v) SET_GLOBAL_FIELD(b, TLBTR0, UW, v)
> +#define SET_XN(b, v) SET_GLOBAL_FIELD(b, TLBTR0, XN, v)
> +#define SET_NSDESC(b, v) SET_GLOBAL_FIELD(b, TLBTR0, NSDESC, v)
> +#define SET_ISH(b, v) SET_GLOBAL_FIELD(b, TLBTR0, ISH, v)
> +#define SET_SH(b, v) SET_GLOBAL_FIELD(b, TLBTR0, SH, v)
> +#define SET_MT(b, v) SET_GLOBAL_FIELD(b, TLBTR0, MT, v)
> +#define SET_DPSIZR(b, v) SET_GLOBAL_FIELD(b, TLBTR0, DPSIZR, v)
> +#define SET_DPSIZC(b, v) SET_GLOBAL_FIELD(b, TLBTR0, DPSIZC, v)
> +
> +
> +/* TLBTR1 */
> +#define SET_TLBTR1_VMID(b, v) SET_GLOBAL_FIELD(b, TLBTR1, TLBTR1_VMID, v)
> +#define SET_TLBTR1_PA(b, v) SET_GLOBAL_FIELD(b, TLBTR1, TLBTR1_PA, v)
> +
> +
> +/* TLBTR2 */
> +#define SET_TLBTR2_ASID(b, v) SET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_ASID, v)
> +#define SET_TLBTR2_V(b, v) SET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_V, v)
> +#define SET_TLBTR2_NSTID(b, v) SET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_NSTID, v)
> +#define SET_TLBTR2_NV(b, v) SET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_NV, v)
> +#define SET_TLBTR2_VA(b, v) SET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_VA, v)
> +
> +
> +/* Global Field Getters */
> +/* CBACR_N */
> +#define GET_RWVMID(b, n) GET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), RWVMID)
> +#define GET_RWE(b, n) GET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), RWE)
> +#define GET_RWGE(b, n) GET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), RWGE)
> +#define GET_CBVMID(b, n) GET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), CBVMID)
> +#define GET_IRPTNDX(b, n) GET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), IRPTNDX)
> +
> +
> +/* M2VCBR_N */
> +#define GET_VMID(b, n) GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), VMID)
> +#define GET_CBNDX(b, n) GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), CBNDX)
> +#define GET_BYPASSD(b, n) GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BYPASSD)
> +#define GET_BPRCOSH(b, n) GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPRCOSH)
> +#define GET_BPRCISH(b, n) GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPRCISH)
> +#define GET_BPRCNSH(b, n) GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPRCNSH)
> +#define GET_BPSHCFG(b, n) GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPSHCFG)
> +#define GET_NSCFG(b, n) GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), NSCFG)
> +#define GET_BPMTCFG(b, n) GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPMTCFG)
> +#define GET_BPMEMTYPE(b, n) GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPMEMTYPE)
> +
> +
> +/* CR */
> +#define GET_RPUE(b) GET_GLOBAL_FIELD(b, CR, RPUE)
> +#define GET_RPUERE(b) GET_GLOBAL_FIELD(b, CR, RPUERE)
> +#define GET_RPUEIE(b) GET_GLOBAL_FIELD(b, CR, RPUEIE)
> +#define GET_DCDEE(b) GET_GLOBAL_FIELD(b, CR, DCDEE)
> +#define GET_CLIENTPD(b) GET_GLOBAL_FIELD(b, CR, CLIENTPD)
> +#define GET_STALLD(b) GET_GLOBAL_FIELD(b, CR, STALLD)
> +#define GET_TLBLKCRWE(b) GET_GLOBAL_FIELD(b, CR, TLBLKCRWE)
> +#define GET_CR_TLBIALLCFG(b) GET_GLOBAL_FIELD(b, CR, CR_TLBIALLCFG)
> +#define GET_TLBIVMIDCFG(b) GET_GLOBAL_FIELD(b, CR, TLBIVMIDCFG)
> +#define GET_CR_HUME(b) GET_GLOBAL_FIELD(b, CR, CR_HUME)
> +
> +
> +/* ESR */
> +#define GET_CFG(b) GET_GLOBAL_FIELD(b, ESR, CFG)
> +#define GET_BYPASS(b) GET_GLOBAL_FIELD(b, ESR, BYPASS)
> +#define GET_ESR_MULTI(b) GET_GLOBAL_FIELD(b, ESR, ESR_MULTI)
> +
> +
> +/* ESYNR0 */
> +#define GET_ESYNR0_AMID(b) GET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_AMID)
> +#define GET_ESYNR0_APID(b) GET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_APID)
> +#define GET_ESYNR0_ABID(b) GET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_ABID)
> +#define GET_ESYNR0_AVMID(b) GET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_AVMID)
> +#define GET_ESYNR0_ATID(b) GET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_ATID)
> +
> +
> +/* ESYNR1 */
> +#define GET_ESYNR1_AMEMTYPE(b) GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AMEMTYPE)
> +#define GET_ESYNR1_ASHARED(b) GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ASHARED)
> +#define GET_ESYNR1_AINNERSHARED(b) \
> + GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AINNERSHARED)
> +#define GET_ESYNR1_APRIV(b) GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_APRIV)
> +#define GET_ESYNR1_APROTNS(b) GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_APROTNS)
> +#define GET_ESYNR1_AINST(b) GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AINST)
> +#define GET_ESYNR1_AWRITE(b) GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AWRITE)
> +#define GET_ESYNR1_ABURST(b) GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ABURST)
> +#define GET_ESYNR1_ALEN(b) GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ALEN)
> +#define GET_ESYNR1_ASIZE(b) GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ASIZE)
> +#define GET_ESYNR1_ALOCK(b) GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ALOCK)
> +#define GET_ESYNR1_AOOO(b) GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AOOO)
> +#define GET_ESYNR1_AFULL(b) GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AFULL)
> +#define GET_ESYNR1_AC(b) GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AC)
> +#define GET_ESYNR1_DCD(b) GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_DCD)
> +
> +
> +/* IDR */
> +#define GET_NM2VCBMT(b) GET_GLOBAL_FIELD(b, IDR, NM2VCBMT)
> +#define GET_HTW(b) GET_GLOBAL_FIELD(b, IDR, HTW)
> +#define GET_HUM(b) GET_GLOBAL_FIELD(b, IDR, HUM)
> +#define GET_TLBSIZE(b) GET_GLOBAL_FIELD(b, IDR, TLBSIZE)
> +#define GET_NCB(b) GET_GLOBAL_FIELD(b, IDR, NCB)
> +#define GET_NIRPT(b) GET_GLOBAL_FIELD(b, IDR, NIRPT)
> +
> +
> +/* REV */
> +#define GET_MAJOR(b) GET_GLOBAL_FIELD(b, REV, MAJOR)
> +#define GET_MINOR(b) GET_GLOBAL_FIELD(b, REV, MINOR)
> +
> +
> +/* TESTBUSCR */
> +#define GET_TBE(b) GET_GLOBAL_FIELD(b, TESTBUSCR, TBE)
> +#define GET_SPDMBE(b) GET_GLOBAL_FIELD(b, TESTBUSCR, SPDMBE)
> +#define GET_WGSEL(b) GET_GLOBAL_FIELD(b, TESTBUSCR, WGSEL)
> +#define GET_TBLSEL(b) GET_GLOBAL_FIELD(b, TESTBUSCR, TBLSEL)
> +#define GET_TBHSEL(b) GET_GLOBAL_FIELD(b, TESTBUSCR, TBHSEL)
> +#define GET_SPDM0SEL(b) GET_GLOBAL_FIELD(b, TESTBUSCR, SPDM0SEL)
> +#define GET_SPDM1SEL(b) GET_GLOBAL_FIELD(b, TESTBUSCR, SPDM1SEL)
> +#define GET_SPDM2SEL(b) GET_GLOBAL_FIELD(b, TESTBUSCR, SPDM2SEL)
> +#define GET_SPDM3SEL(b) GET_GLOBAL_FIELD(b, TESTBUSCR, SPDM3SEL)
> +
> +
> +/* TLBIVMID */
> +#define GET_TLBIVMID_VMID(b) GET_GLOBAL_FIELD(b, TLBIVMID, TLBIVMID_VMID)
> +
> +
> +/* TLBTR0 */
> +#define GET_PR(b) GET_GLOBAL_FIELD(b, TLBTR0, PR)
> +#define GET_PW(b) GET_GLOBAL_FIELD(b, TLBTR0, PW)
> +#define GET_UR(b) GET_GLOBAL_FIELD(b, TLBTR0, UR)
> +#define GET_UW(b) GET_GLOBAL_FIELD(b, TLBTR0, UW)
> +#define GET_XN(b) GET_GLOBAL_FIELD(b, TLBTR0, XN)
> +#define GET_NSDESC(b) GET_GLOBAL_FIELD(b, TLBTR0, NSDESC)
> +#define GET_ISH(b) GET_GLOBAL_FIELD(b, TLBTR0, ISH)
> +#define GET_SH(b) GET_GLOBAL_FIELD(b, TLBTR0, SH)
> +#define GET_MT(b) GET_GLOBAL_FIELD(b, TLBTR0, MT)
> +#define GET_DPSIZR(b) GET_GLOBAL_FIELD(b, TLBTR0, DPSIZR)
> +#define GET_DPSIZC(b) GET_GLOBAL_FIELD(b, TLBTR0, DPSIZC)
> +
> +
> +/* TLBTR1 */
> +#define GET_TLBTR1_VMID(b) GET_GLOBAL_FIELD(b, TLBTR1, TLBTR1_VMID)
> +#define GET_TLBTR1_PA(b) GET_GLOBAL_FIELD(b, TLBTR1, TLBTR1_PA)
> +
> +
> +/* TLBTR2 */
> +#define GET_TLBTR2_ASID(b) GET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_ASID)
> +#define GET_TLBTR2_V(b) GET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_V)
> +#define GET_TLBTR2_NSTID(b) GET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_NSTID)
> +#define GET_TLBTR2_NV(b) GET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_NV)
> +#define GET_TLBTR2_VA(b) GET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_VA)
> +
> +
> +/* Context Register setters / getters */
> +/* Context Register setters */
> +/* ACTLR */
> +#define SET_CFERE(b, c, v) SET_CONTEXT_FIELD(b, c, ACTLR, CFERE, v)
> +#define SET_CFEIE(b, c, v) SET_CONTEXT_FIELD(b, c, ACTLR, CFEIE, v)
> +#define SET_PTSHCFG(b, c, v) SET_CONTEXT_FIELD(b, c, ACTLR, PTSHCFG, v)
> +#define SET_RCOSH(b, c, v) SET_CONTEXT_FIELD(b, c, ACTLR, RCOSH, v)
> +#define SET_RCISH(b, c, v) SET_CONTEXT_FIELD(b, c, ACTLR, RCISH, v)
> +#define SET_RCNSH(b, c, v) SET_CONTEXT_FIELD(b, c, ACTLR, RCNSH, v)
> +#define SET_PRIVCFG(b, c, v) SET_CONTEXT_FIELD(b, c, ACTLR, PRIVCFG, v)
> +#define SET_DNA(b, c, v) SET_CONTEXT_FIELD(b, c, ACTLR, DNA, v)
> +#define SET_DNLV2PA(b, c, v) SET_CONTEXT_FIELD(b, c, ACTLR, DNLV2PA, v)
> +#define SET_TLBMCFG(b, c, v) SET_CONTEXT_FIELD(b, c, ACTLR, TLBMCFG, v)
> +#define SET_CFCFG(b, c, v) SET_CONTEXT_FIELD(b, c, ACTLR, CFCFG, v)
> +#define SET_TIPCF(b, c, v) SET_CONTEXT_FIELD(b, c, ACTLR, TIPCF, v)
> +#define SET_V2PCFG(b, c, v) SET_CONTEXT_FIELD(b, c, ACTLR, V2PCFG, v)
> +#define SET_HUME(b, c, v) SET_CONTEXT_FIELD(b, c, ACTLR, HUME, v)
> +#define SET_PTMTCFG(b, c, v) SET_CONTEXT_FIELD(b, c, ACTLR, PTMTCFG, v)
> +#define SET_PTMEMTYPE(b, c, v) SET_CONTEXT_FIELD(b, c, ACTLR, PTMEMTYPE, v)
> +
> +
> +/* BFBCR */
> +#define SET_BFBDFE(b, c, v) SET_CONTEXT_FIELD(b, c, BFBCR, BFBDFE, v)
> +#define SET_BFBSFE(b, c, v) SET_CONTEXT_FIELD(b, c, BFBCR, BFBSFE, v)
> +#define SET_SFVS(b, c, v) SET_CONTEXT_FIELD(b, c, BFBCR, SFVS, v)
> +#define SET_FLVIC(b, c, v) SET_CONTEXT_FIELD(b, c, BFBCR, FLVIC, v)
> +#define SET_SLVIC(b, c, v) SET_CONTEXT_FIELD(b, c, BFBCR, SLVIC, v)
> +
> +
> +/* CONTEXTIDR */
> +#define SET_CONTEXTIDR_ASID(b, c, v) \
> + SET_CONTEXT_FIELD(b, c, CONTEXTIDR, CONTEXTIDR_ASID, v)
> +#define SET_CONTEXTIDR_PROCID(b, c, v) \
> + SET_CONTEXT_FIELD(b, c, CONTEXTIDR, PROCID, v)
> +
> +
> +/* FSR */
> +#define SET_TF(b, c, v) SET_CONTEXT_FIELD(b, c, FSR, TF, v)
> +#define SET_AFF(b, c, v) SET_CONTEXT_FIELD(b, c, FSR, AFF, v)
> +#define SET_APF(b, c, v) SET_CONTEXT_FIELD(b, c, FSR, APF, v)
> +#define SET_TLBMF(b, c, v) SET_CONTEXT_FIELD(b, c, FSR, TLBMF, v)
> +#define SET_HTWDEEF(b, c, v) SET_CONTEXT_FIELD(b, c, FSR, HTWDEEF, v)
> +#define SET_HTWSEEF(b, c, v) SET_CONTEXT_FIELD(b, c, FSR, HTWSEEF, v)
> +#define SET_MHF(b, c, v) SET_CONTEXT_FIELD(b, c, FSR, MHF, v)
> +#define SET_SL(b, c, v) SET_CONTEXT_FIELD(b, c, FSR, SL, v)
> +#define SET_SS(b, c, v) SET_CONTEXT_FIELD(b, c, FSR, SS, v)
> +#define SET_MULTI(b, c, v) SET_CONTEXT_FIELD(b, c, FSR, MULTI, v)
> +
> +
> +/* FSYNR0 */
> +#define SET_AMID(b, c, v) SET_CONTEXT_FIELD(b, c, FSYNR0, AMID, v)
> +#define SET_APID(b, c, v) SET_CONTEXT_FIELD(b, c, FSYNR0, APID, v)
> +#define SET_ABID(b, c, v) SET_CONTEXT_FIELD(b, c, FSYNR0, ABID, v)
> +#define SET_ATID(b, c, v) SET_CONTEXT_FIELD(b, c, FSYNR0, ATID, v)
> +
> +
> +/* FSYNR1 */
> +#define SET_AMEMTYPE(b, c, v) SET_CONTEXT_FIELD(b, c, FSYNR1, AMEMTYPE, v)
> +#define SET_ASHARED(b, c, v) SET_CONTEXT_FIELD(b, c, FSYNR1, ASHARED, v)
> +#define SET_AINNERSHARED(b, c, v) \
> + SET_CONTEXT_FIELD(b, c, FSYNR1, AINNERSHARED, v)
> +#define SET_APRIV(b, c, v) SET_CONTEXT_FIELD(b, c, FSYNR1, APRIV, v)
> +#define SET_APROTNS(b, c, v) SET_CONTEXT_FIELD(b, c, FSYNR1, APROTNS, v)
> +#define SET_AINST(b, c, v) SET_CONTEXT_FIELD(b, c, FSYNR1, AINST, v)
> +#define SET_AWRITE(b, c, v) SET_CONTEXT_FIELD(b, c, FSYNR1, AWRITE, v)
> +#define SET_ABURST(b, c, v) SET_CONTEXT_FIELD(b, c, FSYNR1, ABURST, v)
> +#define SET_ALEN(b, c, v) SET_CONTEXT_FIELD(b, c, FSYNR1, ALEN, v)
> +#define SET_FSYNR1_ASIZE(b, c, v) \
> + SET_CONTEXT_FIELD(b, c, FSYNR1, FSYNR1_ASIZE, v)
> +#define SET_ALOCK(b, c, v) SET_CONTEXT_FIELD(b, c, FSYNR1, ALOCK, v)
> +#define SET_AFULL(b, c, v) SET_CONTEXT_FIELD(b, c, FSYNR1, AFULL, v)
> +
> +
> +/* NMRR */
> +#define SET_ICPC0(b, c, v) SET_CONTEXT_FIELD(b, c, NMRR, ICPC0, v)
> +#define SET_ICPC1(b, c, v) SET_CONTEXT_FIELD(b, c, NMRR, ICPC1, v)
> +#define SET_ICPC2(b, c, v) SET_CONTEXT_FIELD(b, c, NMRR, ICPC2, v)
> +#define SET_ICPC3(b, c, v) SET_CONTEXT_FIELD(b, c, NMRR, ICPC3, v)
> +#define SET_ICPC4(b, c, v) SET_CONTEXT_FIELD(b, c, NMRR, ICPC4, v)
> +#define SET_ICPC5(b, c, v) SET_CONTEXT_FIELD(b, c, NMRR, ICPC5, v)
> +#define SET_ICPC6(b, c, v) SET_CONTEXT_FIELD(b, c, NMRR, ICPC6, v)
> +#define SET_ICPC7(b, c, v) SET_CONTEXT_FIELD(b, c, NMRR, ICPC7, v)
> +#define SET_OCPC0(b, c, v) SET_CONTEXT_FIELD(b, c, NMRR, OCPC0, v)
> +#define SET_OCPC1(b, c, v) SET_CONTEXT_FIELD(b, c, NMRR, OCPC1, v)
> +#define SET_OCPC2(b, c, v) SET_CONTEXT_FIELD(b, c, NMRR, OCPC2, v)
> +#define SET_OCPC3(b, c, v) SET_CONTEXT_FIELD(b, c, NMRR, OCPC3, v)
> +#define SET_OCPC4(b, c, v) SET_CONTEXT_FIELD(b, c, NMRR, OCPC4, v)
> +#define SET_OCPC5(b, c, v) SET_CONTEXT_FIELD(b, c, NMRR, OCPC5, v)
> +#define SET_OCPC6(b, c, v) SET_CONTEXT_FIELD(b, c, NMRR, OCPC6, v)
> +#define SET_OCPC7(b, c, v) SET_CONTEXT_FIELD(b, c, NMRR, OCPC7, v)
> +
> +
> +/* PAR */
> +#define SET_FAULT(b, c, v) SET_CONTEXT_FIELD(b, c, PAR, FAULT, v)
> +
> +#define SET_FAULT_TF(b, c, v) SET_CONTEXT_FIELD(b, c, PAR, FAULT_TF, v)
> +#define SET_FAULT_AFF(b, c, v) SET_CONTEXT_FIELD(b, c, PAR, FAULT_AFF, v)
> +#define SET_FAULT_APF(b, c, v) SET_CONTEXT_FIELD(b, c, PAR, FAULT_APF, v)
> +#define SET_FAULT_TLBMF(b, c, v) SET_CONTEXT_FIELD(b, c, PAR, FAULT_TLBMF, v)
> +#define SET_FAULT_HTWDEEF(b, c, v) \
> + SET_CONTEXT_FIELD(b, c, PAR, FAULT_HTWDEEF, v)
> +#define SET_FAULT_HTWSEEF(b, c, v) \
> + SET_CONTEXT_FIELD(b, c, PAR, FAULT_HTWSEEF, v)
> +#define SET_FAULT_MHF(b, c, v) SET_CONTEXT_FIELD(b, c, PAR, FAULT_MHF, v)
> +#define SET_FAULT_SL(b, c, v) SET_CONTEXT_FIELD(b, c, PAR, FAULT_SL, v)
> +#define SET_FAULT_SS(b, c, v) SET_CONTEXT_FIELD(b, c, PAR, FAULT_SS, v)
> +
> +#define SET_NOFAULT_SS(b, c, v) SET_CONTEXT_FIELD(b, c, PAR, NOFAULT_SS, v)
> +#define SET_NOFAULT_MT(b, c, v) SET_CONTEXT_FIELD(b, c, PAR, NOFAULT_MT, v)
> +#define SET_NOFAULT_SH(b, c, v) SET_CONTEXT_FIELD(b, c, PAR, NOFAULT_SH, v)
> +#define SET_NOFAULT_NS(b, c, v) SET_CONTEXT_FIELD(b, c, PAR, NOFAULT_NS, v)
> +#define SET_NOFAULT_NOS(b, c, v) SET_CONTEXT_FIELD(b, c, PAR, NOFAULT_NOS, v)
> +#define SET_NPFAULT_PA(b, c, v) SET_CONTEXT_FIELD(b, c, PAR, NPFAULT_PA, v)
> +
> +
> +/* PRRR */
> +#define SET_MTC0(b, c, v) SET_CONTEXT_FIELD(b, c, PRRR, MTC0, v)
> +#define SET_MTC1(b, c, v) SET_CONTEXT_FIELD(b, c, PRRR, MTC1, v)
> +#define SET_MTC2(b, c, v) SET_CONTEXT_FIELD(b, c, PRRR, MTC2, v)
> +#define SET_MTC3(b, c, v) SET_CONTEXT_FIELD(b, c, PRRR, MTC3, v)
> +#define SET_MTC4(b, c, v) SET_CONTEXT_FIELD(b, c, PRRR, MTC4, v)
> +#define SET_MTC5(b, c, v) SET_CONTEXT_FIELD(b, c, PRRR, MTC5, v)
> +#define SET_MTC6(b, c, v) SET_CONTEXT_FIELD(b, c, PRRR, MTC6, v)
> +#define SET_MTC7(b, c, v) SET_CONTEXT_FIELD(b, c, PRRR, MTC7, v)
> +#define SET_SHDSH0(b, c, v) SET_CONTEXT_FIELD(b, c, PRRR, SHDSH0, v)
> +#define SET_SHDSH1(b, c, v) SET_CONTEXT_FIELD(b, c, PRRR, SHDSH1, v)
> +#define SET_SHNMSH0(b, c, v) SET_CONTEXT_FIELD(b, c, PRRR, SHNMSH0, v)
> +#define SET_SHNMSH1(b, c, v) SET_CONTEXT_FIELD(b, c, PRRR, SHNMSH1, v)
> +#define SET_NOS0(b, c, v) SET_CONTEXT_FIELD(b, c, PRRR, NOS0, v)
> +#define SET_NOS1(b, c, v) SET_CONTEXT_FIELD(b, c, PRRR, NOS1, v)
> +#define SET_NOS2(b, c, v) SET_CONTEXT_FIELD(b, c, PRRR, NOS2, v)
> +#define SET_NOS3(b, c, v) SET_CONTEXT_FIELD(b, c, PRRR, NOS3, v)
> +#define SET_NOS4(b, c, v) SET_CONTEXT_FIELD(b, c, PRRR, NOS4, v)
> +#define SET_NOS5(b, c, v) SET_CONTEXT_FIELD(b, c, PRRR, NOS5, v)
> +#define SET_NOS6(b, c, v) SET_CONTEXT_FIELD(b, c, PRRR, NOS6, v)
> +#define SET_NOS7(b, c, v) SET_CONTEXT_FIELD(b, c, PRRR, NOS7, v)
> +
> +
> +/* RESUME */
> +#define SET_TNR(b, c, v) SET_CONTEXT_FIELD(b, c, RESUME, TNR, v)
> +
> +
> +/* SCTLR */
> +#define SET_M(b, c, v) SET_CONTEXT_FIELD(b, c, SCTLR, M, v)
> +#define SET_TRE(b, c, v) SET_CONTEXT_FIELD(b, c, SCTLR, TRE, v)
> +#define SET_AFE(b, c, v) SET_CONTEXT_FIELD(b, c, SCTLR, AFE, v)
> +#define SET_HAF(b, c, v) SET_CONTEXT_FIELD(b, c, SCTLR, HAF, v)
> +#define SET_BE(b, c, v) SET_CONTEXT_FIELD(b, c, SCTLR, BE, v)
> +#define SET_AFFD(b, c, v) SET_CONTEXT_FIELD(b, c, SCTLR, AFFD, v)
> +
> +
> +/* TLBLKCR */
> +#define SET_LKE(b, c, v) SET_CONTEXT_FIELD(b, c, TLBLKCR, LKE, v)
> +#define SET_TLBLKCR_TLBIALLCFG(b, c, v) \
> + SET_CONTEXT_FIELD(b, c, TLBLKCR, TLBLCKR_TLBIALLCFG, v)
> +#define SET_TLBIASIDCFG(b, c, v) \
> + SET_CONTEXT_FIELD(b, c, TLBLKCR, TLBIASIDCFG, v)
> +#define SET_TLBIVAACFG(b, c, v) SET_CONTEXT_FIELD(b, c, TLBLKCR, TLBIVAACFG, v)
> +#define SET_FLOOR(b, c, v) SET_CONTEXT_FIELD(b, c, TLBLKCR, FLOOR, v)
> +#define SET_VICTIM(b, c, v) SET_CONTEXT_FIELD(b, c, TLBLKCR, VICTIM, v)
> +
> +
> +/* TTBCR */
> +#define SET_N(b, c, v) SET_CONTEXT_FIELD(b, c, TTBCR, N, v)
> +#define SET_PD0(b, c, v) SET_CONTEXT_FIELD(b, c, TTBCR, PD0, v)
> +#define SET_PD1(b, c, v) SET_CONTEXT_FIELD(b, c, TTBCR, PD1, v)
> +
> +
> +/* TTBR0 */
> +#define SET_TTBR0_IRGNH(b, c, v) SET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_IRGNH, v)
> +#define SET_TTBR0_SH(b, c, v) SET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_SH, v)
> +#define SET_TTBR0_ORGN(b, c, v) SET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_ORGN, v)
> +#define SET_TTBR0_NOS(b, c, v) SET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_NOS, v)
> +#define SET_TTBR0_IRGNL(b, c, v) SET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_IRGNL, v)
> +#define SET_TTBR0_PA(b, c, v) SET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_PA, v)
> +
> +
> +/* TTBR1 */
> +#define SET_TTBR1_IRGNH(b, c, v) SET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_IRGNH, v)
> +#define SET_TTBR1_SH(b, c, v) SET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_SH, v)
> +#define SET_TTBR1_ORGN(b, c, v) SET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_ORGN, v)
> +#define SET_TTBR1_NOS(b, c, v) SET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_NOS, v)
> +#define SET_TTBR1_IRGNL(b, c, v) SET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_IRGNL, v)
> +#define SET_TTBR1_PA(b, c, v) SET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_PA, v)
> +
> +
> +/* V2PSR */
> +#define SET_HIT(b, c, v) SET_CONTEXT_FIELD(b, c, V2PSR, HIT, v)
> +#define SET_INDEX(b, c, v) SET_CONTEXT_FIELD(b, c, V2PSR, INDEX, v)
> +
> +
> +/* V2Pxx UW UR PW PR */
> +#define SET_V2PUW_INDEX(b, c, v) SET_CONTEXT_FIELD(b, c, V2PUW, V2Pxx_INDEX, v)
> +#define SET_V2PUW_VA(b, c, v) SET_CONTEXT_FIELD(b, c, V2PUW, V2Pxx_VA, v)
> +
> +#define SET_V2PUR_INDEX(b, c, v) SET_CONTEXT_FIELD(b, c, V2PUR, V2Pxx_INDEX, v)
> +#define SET_V2PUR_VA(b, c, v) SET_CONTEXT_FIELD(b, c, V2PUR, V2Pxx_VA, v)
> +
> +#define SET_V2PPW_INDEX(b, c, v) SET_CONTEXT_FIELD(b, c, V2PPW, V2Pxx_INDEX, v)
> +#define SET_V2PPW_VA(b, c, v) SET_CONTEXT_FIELD(b, c, V2PPW, V2Pxx_VA, v)
> +
> +#define SET_V2PPR_INDEX(b, c, v) SET_CONTEXT_FIELD(b, c, V2PPR, V2Pxx_INDEX, v)
> +#define SET_V2PPR_VA(b, c, v) SET_CONTEXT_FIELD(b, c, V2PPR, V2Pxx_VA, v)
> +
> +
> +/* Context Register getters */
> +/* ACTLR */
> +#define GET_CFERE(b, c) GET_CONTEXT_FIELD(b, c, ACTLR, CFERE)
> +#define GET_CFEIE(b, c) GET_CONTEXT_FIELD(b, c, ACTLR, CFEIE)
> +#define GET_PTSHCFG(b, c) GET_CONTEXT_FIELD(b, c, ACTLR, PTSHCFG)
> +#define GET_RCOSH(b, c) GET_CONTEXT_FIELD(b, c, ACTLR, RCOSH)
> +#define GET_RCISH(b, c) GET_CONTEXT_FIELD(b, c, ACTLR, RCISH)
> +#define GET_RCNSH(b, c) GET_CONTEXT_FIELD(b, c, ACTLR, RCNSH)
> +#define GET_PRIVCFG(b, c) GET_CONTEXT_FIELD(b, c, ACTLR, PRIVCFG)
> +#define GET_DNA(b, c) GET_CONTEXT_FIELD(b, c, ACTLR, DNA)
> +#define GET_DNLV2PA(b, c) GET_CONTEXT_FIELD(b, c, ACTLR, DNLV2PA)
> +#define GET_TLBMCFG(b, c) GET_CONTEXT_FIELD(b, c, ACTLR, TLBMCFG)
> +#define GET_CFCFG(b, c) GET_CONTEXT_FIELD(b, c, ACTLR, CFCFG)
> +#define GET_TIPCF(b, c) GET_CONTEXT_FIELD(b, c, ACTLR, TIPCF)
> +#define GET_V2PCFG(b, c) GET_CONTEXT_FIELD(b, c, ACTLR, V2PCFG)
> +#define GET_HUME(b, c) GET_CONTEXT_FIELD(b, c, ACTLR, HUME)
> +#define GET_PTMTCFG(b, c) GET_CONTEXT_FIELD(b, c, ACTLR, PTMTCFG)
> +#define GET_PTMEMTYPE(b, c) GET_CONTEXT_FIELD(b, c, ACTLR, PTMEMTYPE)
> +
> +/* BFBCR */
> +#define GET_BFBDFE(b, c) GET_CONTEXT_FIELD(b, c, BFBCR, BFBDFE)
> +#define GET_BFBSFE(b, c) GET_CONTEXT_FIELD(b, c, BFBCR, BFBSFE)
> +#define GET_SFVS(b, c) GET_CONTEXT_FIELD(b, c, BFBCR, SFVS)
> +#define GET_FLVIC(b, c) GET_CONTEXT_FIELD(b, c, BFBCR, FLVIC)
> +#define GET_SLVIC(b, c) GET_CONTEXT_FIELD(b, c, BFBCR, SLVIC)
> +
> +
> +/* CONTEXTIDR */
> +#define GET_CONTEXTIDR_ASID(b, c) \
> + GET_CONTEXT_FIELD(b, c, CONTEXTIDR, CONTEXTIDR_ASID)
> +#define GET_CONTEXTIDR_PROCID(b, c) GET_CONTEXT_FIELD(b, c, CONTEXTIDR, PROCID)
> +
> +
> +/* FSR */
> +#define GET_TF(b, c) GET_CONTEXT_FIELD(b, c, FSR, TF)
> +#define GET_AFF(b, c) GET_CONTEXT_FIELD(b, c, FSR, AFF)
> +#define GET_APF(b, c) GET_CONTEXT_FIELD(b, c, FSR, APF)
> +#define GET_TLBMF(b, c) GET_CONTEXT_FIELD(b, c, FSR, TLBMF)
> +#define GET_HTWDEEF(b, c) GET_CONTEXT_FIELD(b, c, FSR, HTWDEEF)
> +#define GET_HTWSEEF(b, c) GET_CONTEXT_FIELD(b, c, FSR, HTWSEEF)
> +#define GET_MHF(b, c) GET_CONTEXT_FIELD(b, c, FSR, MHF)
> +#define GET_SL(b, c) GET_CONTEXT_FIELD(b, c, FSR, SL)
> +#define GET_SS(b, c) GET_CONTEXT_FIELD(b, c, FSR, SS)
> +#define GET_MULTI(b, c) GET_CONTEXT_FIELD(b, c, FSR, MULTI)
> +
> +
> +/* FSYNR0 */
> +#define GET_AMID(b, c) GET_CONTEXT_FIELD(b, c, FSYNR0, AMID)
> +#define GET_APID(b, c) GET_CONTEXT_FIELD(b, c, FSYNR0, APID)
> +#define GET_ABID(b, c) GET_CONTEXT_FIELD(b, c, FSYNR0, ABID)
> +#define GET_ATID(b, c) GET_CONTEXT_FIELD(b, c, FSYNR0, ATID)
> +
> +
> +/* FSYNR1 */
> +#define GET_AMEMTYPE(b, c) GET_CONTEXT_FIELD(b, c, FSYNR1, AMEMTYPE)
> +#define GET_ASHARED(b, c) GET_CONTEXT_FIELD(b, c, FSYNR1, ASHARED)
> +#define GET_AINNERSHARED(b, c) GET_CONTEXT_FIELD(b, c, FSYNR1, AINNERSHARED)
> +#define GET_APRIV(b, c) GET_CONTEXT_FIELD(b, c, FSYNR1, APRIV)
> +#define GET_APROTNS(b, c) GET_CONTEXT_FIELD(b, c, FSYNR1, APROTNS)
> +#define GET_AINST(b, c) GET_CONTEXT_FIELD(b, c, FSYNR1, AINST)
> +#define GET_AWRITE(b, c) GET_CONTEXT_FIELD(b, c, FSYNR1, AWRITE)
> +#define GET_ABURST(b, c) GET_CONTEXT_FIELD(b, c, FSYNR1, ABURST)
> +#define GET_ALEN(b, c) GET_CONTEXT_FIELD(b, c, FSYNR1, ALEN)
> +#define GET_FSYNR1_ASIZE(b, c) GET_CONTEXT_FIELD(b, c, FSYNR1, FSYNR1_ASIZE)
> +#define GET_ALOCK(b, c) GET_CONTEXT_FIELD(b, c, FSYNR1, ALOCK)
> +#define GET_AFULL(b, c) GET_CONTEXT_FIELD(b, c, FSYNR1, AFULL)
> +
> +
> +/* NMRR */
> +#define GET_ICPC0(b, c) GET_CONTEXT_FIELD(b, c, NMRR, ICPC0)
> +#define GET_ICPC1(b, c) GET_CONTEXT_FIELD(b, c, NMRR, ICPC1)
> +#define GET_ICPC2(b, c) GET_CONTEXT_FIELD(b, c, NMRR, ICPC2)
> +#define GET_ICPC3(b, c) GET_CONTEXT_FIELD(b, c, NMRR, ICPC3)
> +#define GET_ICPC4(b, c) GET_CONTEXT_FIELD(b, c, NMRR, ICPC4)
> +#define GET_ICPC5(b, c) GET_CONTEXT_FIELD(b, c, NMRR, ICPC5)
> +#define GET_ICPC6(b, c) GET_CONTEXT_FIELD(b, c, NMRR, ICPC6)
> +#define GET_ICPC7(b, c) GET_CONTEXT_FIELD(b, c, NMRR, ICPC7)
> +#define GET_OCPC0(b, c) GET_CONTEXT_FIELD(b, c, NMRR, OCPC0)
> +#define GET_OCPC1(b, c) GET_CONTEXT_FIELD(b, c, NMRR, OCPC1)
> +#define GET_OCPC2(b, c) GET_CONTEXT_FIELD(b, c, NMRR, OCPC2)
> +#define GET_OCPC3(b, c) GET_CONTEXT_FIELD(b, c, NMRR, OCPC3)
> +#define GET_OCPC4(b, c) GET_CONTEXT_FIELD(b, c, NMRR, OCPC4)
> +#define GET_OCPC5(b, c) GET_CONTEXT_FIELD(b, c, NMRR, OCPC5)
> +#define GET_OCPC6(b, c) GET_CONTEXT_FIELD(b, c, NMRR, OCPC6)
> +#define GET_OCPC7(b, c) GET_CONTEXT_FIELD(b, c, NMRR, OCPC7)
> +
> +
> +/* PAR */
> +#define GET_FAULT(b, c) GET_CONTEXT_FIELD(b, c, PAR, FAULT)
> +
> +#define GET_FAULT_TF(b, c) GET_CONTEXT_FIELD(b, c, PAR, FAULT_TF)
> +#define GET_FAULT_AFF(b, c) GET_CONTEXT_FIELD(b, c, PAR, FAULT_AFF)
> +#define GET_FAULT_APF(b, c) GET_CONTEXT_FIELD(b, c, PAR, FAULT_APF)
> +#define GET_FAULT_TLBMF(b, c) GET_CONTEXT_FIELD(b, c, PAR, FAULT_TLBMF)
> +#define GET_FAULT_HTWDEEF(b, c) GET_CONTEXT_FIELD(b, c, PAR, FAULT_HTWDEEF)
> +#define GET_FAULT_HTWSEEF(b, c) GET_CONTEXT_FIELD(b, c, PAR, FAULT_HTWSEEF)
> +#define GET_FAULT_MHF(b, c) GET_CONTEXT_FIELD(b, c, PAR, FAULT_MHF)
> +#define GET_FAULT_SL(b, c) GET_CONTEXT_FIELD(b, c, PAR, FAULT_SL)
> +#define GET_FAULT_SS(b, c) GET_CONTEXT_FIELD(b, c, PAR, FAULT_SS)
> +
> +#define GET_NOFAULT_SS(b, c) GET_CONTEXT_FIELD(b, c, PAR, PAR_NOFAULT_SS)
> +#define GET_NOFAULT_MT(b, c) GET_CONTEXT_FIELD(b, c, PAR, PAR_NOFAULT_MT)
> +#define GET_NOFAULT_SH(b, c) GET_CONTEXT_FIELD(b, c, PAR, PAR_NOFAULT_SH)
> +#define GET_NOFAULT_NS(b, c) GET_CONTEXT_FIELD(b, c, PAR, PAR_NOFAULT_NS)
> +#define GET_NOFAULT_NOS(b, c) GET_CONTEXT_FIELD(b, c, PAR, PAR_NOFAULT_NOS)
> +#define GET_NPFAULT_PA(b, c) GET_CONTEXT_FIELD(b, c, PAR, PAR_NPFAULT_PA)
> +
> +
> +/* PRRR */
> +#define GET_MTC0(b, c) GET_CONTEXT_FIELD(b, c, PRRR, MTC0)
> +#define GET_MTC1(b, c) GET_CONTEXT_FIELD(b, c, PRRR, MTC1)
> +#define GET_MTC2(b, c) GET_CONTEXT_FIELD(b, c, PRRR, MTC2)
> +#define GET_MTC3(b, c) GET_CONTEXT_FIELD(b, c, PRRR, MTC3)
> +#define GET_MTC4(b, c) GET_CONTEXT_FIELD(b, c, PRRR, MTC4)
> +#define GET_MTC5(b, c) GET_CONTEXT_FIELD(b, c, PRRR, MTC5)
> +#define GET_MTC6(b, c) GET_CONTEXT_FIELD(b, c, PRRR, MTC6)
> +#define GET_MTC7(b, c) GET_CONTEXT_FIELD(b, c, PRRR, MTC7)
> +#define GET_SHDSH0(b, c) GET_CONTEXT_FIELD(b, c, PRRR, SHDSH0)
> +#define GET_SHDSH1(b, c) GET_CONTEXT_FIELD(b, c, PRRR, SHDSH1)
> +#define GET_SHNMSH0(b, c) GET_CONTEXT_FIELD(b, c, PRRR, SHNMSH0)
> +#define GET_SHNMSH1(b, c) GET_CONTEXT_FIELD(b, c, PRRR, SHNMSH1)
> +#define GET_NOS0(b, c) GET_CONTEXT_FIELD(b, c, PRRR, NOS0)
> +#define GET_NOS1(b, c) GET_CONTEXT_FIELD(b, c, PRRR, NOS1)
> +#define GET_NOS2(b, c) GET_CONTEXT_FIELD(b, c, PRRR, NOS2)
> +#define GET_NOS3(b, c) GET_CONTEXT_FIELD(b, c, PRRR, NOS3)
> +#define GET_NOS4(b, c) GET_CONTEXT_FIELD(b, c, PRRR, NOS4)
> +#define GET_NOS5(b, c) GET_CONTEXT_FIELD(b, c, PRRR, NOS5)
> +#define GET_NOS6(b, c) GET_CONTEXT_FIELD(b, c, PRRR, NOS6)
> +#define GET_NOS7(b, c) GET_CONTEXT_FIELD(b, c, PRRR, NOS7)
> +
> +
> +/* RESUME */
> +#define GET_TNR(b, c) GET_CONTEXT_FIELD(b, c, RESUME, TNR)
> +
> +
> +/* SCTLR */
> +#define GET_M(b, c) GET_CONTEXT_FIELD(b, c, SCTLR, M)
> +#define GET_TRE(b, c) GET_CONTEXT_FIELD(b, c, SCTLR, TRE)
> +#define GET_AFE(b, c) GET_CONTEXT_FIELD(b, c, SCTLR, AFE)
> +#define GET_HAF(b, c) GET_CONTEXT_FIELD(b, c, SCTLR, HAF)
> +#define GET_BE(b, c) GET_CONTEXT_FIELD(b, c, SCTLR, BE)
> +#define GET_AFFD(b, c) GET_CONTEXT_FIELD(b, c, SCTLR, AFFD)
> +
> +
> +/* TLBLKCR */
> +#define GET_LKE(b, c) GET_CONTEXT_FIELD(b, c, TLBLKCR, LKE)
> +#define GET_TLBLCKR_TLBIALLCFG(b, c) \
> + GET_CONTEXT_FIELD(b, c, TLBLKCR, TLBLCKR_TLBIALLCFG)
> +#define GET_TLBIASIDCFG(b, c) GET_CONTEXT_FIELD(b, c, TLBLKCR, TLBIASIDCFG)
> +#define GET_TLBIVAACFG(b, c) GET_CONTEXT_FIELD(b, c, TLBLKCR, TLBIVAACFG)
> +#define GET_FLOOR(b, c) GET_CONTEXT_FIELD(b, c, TLBLKCR, FLOOR)
> +#define GET_VICTIM(b, c) GET_CONTEXT_FIELD(b, c, TLBLKCR, VICTIM)
> +
> +
> +/* TTBCR */
> +#define GET_N(b, c) GET_CONTEXT_FIELD(b, c, TTBCR, N)
> +#define GET_PD0(b, c) GET_CONTEXT_FIELD(b, c, TTBCR, PD0)
> +#define GET_PD1(b, c) GET_CONTEXT_FIELD(b, c, TTBCR, PD1)
> +
> +
> +/* TTBR0 */
> +#define GET_TTBR0_IRGNH(b, c) GET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_IRGNH)
> +#define GET_TTBR0_SH(b, c) GET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_SH)
> +#define GET_TTBR0_ORGN(b, c) GET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_ORGN)
> +#define GET_TTBR0_NOS(b, c) GET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_NOS)
> +#define GET_TTBR0_IRGNL(b, c) GET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_IRGNL)
> +#define GET_TTBR0_PA(b, c) GET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_PA)
> +
> +
> +/* TTBR1 */
> +#define GET_TTBR1_IRGNH(b, c) GET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_IRGNH)
> +#define GET_TTBR1_SH(b, c) GET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_SH)
> +#define GET_TTBR1_ORGN(b, c) GET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_ORGN)
> +#define GET_TTBR1_NOS(b, c) GET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_NOS)
> +#define GET_TTBR1_IRGNL(b, c) GET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_IRGNL)
> +#define GET_TTBR1_PA(b, c) GET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_PA)
> +
> +
> +/* V2PSR */
> +#define GET_HIT(b, c) GET_CONTEXT_FIELD(b, c, V2PSR, HIT)
> +#define GET_INDEX(b, c) GET_CONTEXT_FIELD(b, c, V2PSR, INDEX)
> +
> +
> +/* V2Pxx UW UR PW PR */
> +#define GET_V2PUW_INDEX(b, c) GET_CONTEXT_FIELD(b, c, V2PUW, V2Pxx_INDEX)
> +#define GET_V2PUW_VA(b, c) GET_CONTEXT_FIELD(b, c, V2PUW, V2Pxx_VA)
> +
> +#define GET_V2PUR_INDEX(b, c) GET_CONTEXT_FIELD(b, c, V2PUR, V2Pxx_INDEX)
> +#define GET_V2PUR_VA(b, c) GET_CONTEXT_FIELD(b, c, V2PUR, V2Pxx_VA)
> +
> +#define GET_V2PPW_INDEX(b, c) GET_CONTEXT_FIELD(b, c, V2PPW, V2Pxx_INDEX)
> +#define GET_V2PPW_VA(b, c) GET_CONTEXT_FIELD(b, c, V2PPW, V2Pxx_VA)
> +
> +#define GET_V2PPR_INDEX(b, c) GET_CONTEXT_FIELD(b, c, V2PPR, V2Pxx_INDEX)
> +#define GET_V2PPR_VA(b, c) GET_CONTEXT_FIELD(b, c, V2PPR, V2Pxx_VA)
> +
> +
> +/* Global Registers */
> +#define M2VCBR_N (0xFF000)
> +#define CBACR_N (0xFF800)
> +#define TLBRSW (0xFFE00)
> +#define TLBTR0 (0xFFE80)
> +#define TLBTR1 (0xFFE84)
> +#define TLBTR2 (0xFFE88)
> +#define TESTBUSCR (0xFFE8C)
> +#define GLOBAL_TLBIALL (0xFFF00)
> +#define TLBIVMID (0xFFF04)
> +#define CR (0xFFF80)
> +#define EAR (0xFFF84)
> +#define ESR (0xFFF88)
> +#define ESRRESTORE (0xFFF8C)
> +#define ESYNR0 (0xFFF90)
> +#define ESYNR1 (0xFFF94)
> +#define REV (0xFFFF4)
> +#define IDR (0xFFFF8)
> +#define RPU_ACR (0xFFFFC)
> +
> +
> +/* Context Bank Registers */
> +#define SCTLR (0x000)
> +#define ACTLR (0x004)
> +#define CONTEXTIDR (0x008)
> +#define TTBR0 (0x010)
> +#define TTBR1 (0x014)
> +#define TTBCR (0x018)
> +#define PAR (0x01C)
> +#define FSR (0x020)
> +#define FSRRESTORE (0x024)
> +#define FAR (0x028)
> +#define FSYNR0 (0x02C)
> +#define FSYNR1 (0x030)
> +#define PRRR (0x034)
> +#define NMRR (0x038)
> +#define TLBLCKR (0x03C)
> +#define V2PSR (0x040)
> +#define TLBFLPTER (0x044)
> +#define TLBSLPTER (0x048)
> +#define BFBCR (0x04C)
> +#define CTX_TLBIALL (0x800)
> +#define TLBIASID (0x804)
> +#define TLBIVA (0x808)
> +#define TLBIVAA (0x80C)
> +#define V2PPR (0x810)
> +#define V2PPW (0x814)
> +#define V2PUR (0x818)
> +#define V2PUW (0x81C)
> +#define RESUME (0x820)
> +
> +
> +/* Global Register Fields */
> +/* CBACRn */
> +#define RWVMID (RWVMID_MASK << RWVMID_SHIFT)
> +#define RWE (RWE_MASK << RWE_SHIFT)
> +#define RWGE (RWGE_MASK << RWGE_SHIFT)
> +#define CBVMID (CBVMID_MASK << CBVMID_SHIFT)
> +#define IRPTNDX (IRPTNDX_MASK << IRPTNDX_SHIFT)
> +
> +
> +/* CR */
> +#define RPUE (RPUE_MASK << RPUE_SHIFT)
> +#define RPUERE (RPUERE_MASK << RPUERE_SHIFT)
> +#define RPUEIE (RPUEIE_MASK << RPUEIE_SHIFT)
> +#define DCDEE (DCDEE_MASK << DCDEE_SHIFT)
> +#define CLIENTPD (CLIENTPD_MASK << CLIENTPD_SHIFT)
> +#define STALLD (STALLD_MASK << STALLD_SHIFT)
> +#define TLBLKCRWE (TLBLKCRWE_MASK << TLBLKCRWE_SHIFT)
> +#define CR_TLBIALLCFG (CR_TLBIALLCFG_MASK << CR_TLBIALLCFG_SHIFT)
> +#define TLBIVMIDCFG (TLBIVMIDCFG_MASK << TLBIVMIDCFG_SHIFT)
> +#define CR_HUME (CR_HUME_MASK << CR_HUME_SHIFT)
> +
> +
> +/* ESR */
> +#define CFG (CFG_MASK << CFG_SHIFT)
> +#define BYPASS (BYPASS_MASK << BYPASS_SHIFT)
> +#define ESR_MULTI (ESR_MULTI_MASK << ESR_MULTI_SHIFT)
> +
> +
> +/* ESYNR0 */
> +#define ESYNR0_AMID (ESYNR0_AMID_MASK << ESYNR0_AMID_SHIFT)
> +#define ESYNR0_APID (ESYNR0_APID_MASK << ESYNR0_APID_SHIFT)
> +#define ESYNR0_ABID (ESYNR0_ABID_MASK << ESYNR0_ABID_SHIFT)
> +#define ESYNR0_AVMID (ESYNR0_AVMID_MASK << ESYNR0_AVMID_SHIFT)
> +#define ESYNR0_ATID (ESYNR0_ATID_MASK << ESYNR0_ATID_SHIFT)
> +
> +
> +/* ESYNR1 */
> +#define ESYNR1_AMEMTYPE (ESYNR1_AMEMTYPE_MASK << ESYNR1_AMEMTYPE_SHIFT)
> +#define ESYNR1_ASHARED (ESYNR1_ASHARED_MASK << ESYNR1_ASHARED_SHIFT)
> +#define ESYNR1_AINNERSHARED (ESYNR1_AINNERSHARED_MASK<< \
> + ESYNR1_AINNERSHARED_SHIFT)
> +#define ESYNR1_APRIV (ESYNR1_APRIV_MASK << ESYNR1_APRIV_SHIFT)
> +#define ESYNR1_APROTNS (ESYNR1_APROTNS_MASK << ESYNR1_APROTNS_SHIFT)
> +#define ESYNR1_AINST (ESYNR1_AINST_MASK << ESYNR1_AINST_SHIFT)
> +#define ESYNR1_AWRITE (ESYNR1_AWRITE_MASK << ESYNR1_AWRITE_SHIFT)
> +#define ESYNR1_ABURST (ESYNR1_ABURST_MASK << ESYNR1_ABURST_SHIFT)
> +#define ESYNR1_ALEN (ESYNR1_ALEN_MASK << ESYNR1_ALEN_SHIFT)
> +#define ESYNR1_ASIZE (ESYNR1_ASIZE_MASK << ESYNR1_ASIZE_SHIFT)
> +#define ESYNR1_ALOCK (ESYNR1_ALOCK_MASK << ESYNR1_ALOCK_SHIFT)
> +#define ESYNR1_AOOO (ESYNR1_AOOO_MASK << ESYNR1_AOOO_SHIFT)
> +#define ESYNR1_AFULL (ESYNR1_AFULL_MASK << ESYNR1_AFULL_SHIFT)
> +#define ESYNR1_AC (ESYNR1_AC_MASK << ESYNR1_AC_SHIFT)
> +#define ESYNR1_DCD (ESYNR1_DCD_MASK << ESYNR1_DCD_SHIFT)
> +
> +
> +/* IDR */
> +#define NM2VCBMT (NM2VCBMT_MASK << NM2VCBMT_SHIFT)
> +#define HTW (HTW_MASK << HTW_SHIFT)
> +#define HUM (HUM_MASK << HUM_SHIFT)
> +#define TLBSIZE (TLBSIZE_MASK << TLBSIZE_SHIFT)
> +#define NCB (NCB_MASK << NCB_SHIFT)
> +#define NIRPT (NIRPT_MASK << NIRPT_SHIFT)
> +
> +
> +/* M2VCBRn */
> +#define VMID (VMID_MASK << VMID_SHIFT)
> +#define CBNDX (CBNDX_MASK << CBNDX_SHIFT)
> +#define BYPASSD (BYPASSD_MASK << BYPASSD_SHIFT)
> +#define BPRCOSH (BPRCOSH_MASK << BPRCOSH_SHIFT)
> +#define BPRCISH (BPRCISH_MASK << BPRCISH_SHIFT)
> +#define BPRCNSH (BPRCNSH_MASK << BPRCNSH_SHIFT)
> +#define BPSHCFG (BPSHCFG_MASK << BPSHCFG_SHIFT)
> +#define NSCFG (NSCFG_MASK << NSCFG_SHIFT)
> +#define BPMTCFG (BPMTCFG_MASK << BPMTCFG_SHIFT)
> +#define BPMEMTYPE (BPMEMTYPE_MASK << BPMEMTYPE_SHIFT)
> +
> +
> +/* REV */
> +#define IDR_MINOR (MINOR_MASK << MINOR_SHIFT)
> +#define IDR_MAJOR (MAJOR_MASK << MAJOR_SHIFT)
> +
> +
> +/* TESTBUSCR */
> +#define TBE (TBE_MASK << TBE_SHIFT)
> +#define SPDMBE (SPDMBE_MASK << SPDMBE_SHIFT)
> +#define WGSEL (WGSEL_MASK << WGSEL_SHIFT)
> +#define TBLSEL (TBLSEL_MASK << TBLSEL_SHIFT)
> +#define TBHSEL (TBHSEL_MASK << TBHSEL_SHIFT)
> +#define SPDM0SEL (SPDM0SEL_MASK << SPDM0SEL_SHIFT)
> +#define SPDM1SEL (SPDM1SEL_MASK << SPDM1SEL_SHIFT)
> +#define SPDM2SEL (SPDM2SEL_MASK << SPDM2SEL_SHIFT)
> +#define SPDM3SEL (SPDM3SEL_MASK << SPDM3SEL_SHIFT)
> +
> +
> +/* TLBIVMID */
> +#define TLBIVMID_VMID (TLBIVMID_VMID_MASK << TLBIVMID_VMID_SHIFT)
> +
> +
> +/* TLBRSW */
> +#define TLBRSW_INDEX (TLBRSW_INDEX_MASK << TLBRSW_INDEX_SHIFT)
> +#define TLBBFBS (TLBBFBS_MASK << TLBBFBS_SHIFT)
> +
> +
> +/* TLBTR0 */
> +#define PR (PR_MASK << PR_SHIFT)
> +#define PW (PW_MASK << PW_SHIFT)
> +#define UR (UR_MASK << UR_SHIFT)
> +#define UW (UW_MASK << UW_SHIFT)
> +#define XN (XN_MASK << XN_SHIFT)
> +#define NSDESC (NSDESC_MASK << NSDESC_SHIFT)
> +#define ISH (ISH_MASK << ISH_SHIFT)
> +#define SH (SH_MASK << SH_SHIFT)
> +#define MT (MT_MASK << MT_SHIFT)
> +#define DPSIZR (DPSIZR_MASK << DPSIZR_SHIFT)
> +#define DPSIZC (DPSIZC_MASK << DPSIZC_SHIFT)
> +
> +
> +/* TLBTR1 */
> +#define TLBTR1_VMID (TLBTR1_VMID_MASK << TLBTR1_VMID_SHIFT)
> +#define TLBTR1_PA (TLBTR1_PA_MASK << TLBTR1_PA_SHIFT)
> +
> +
> +/* TLBTR2 */
> +#define TLBTR2_ASID (TLBTR2_ASID_MASK << TLBTR2_ASID_SHIFT)
> +#define TLBTR2_V (TLBTR2_V_MASK << TLBTR2_V_SHIFT)
> +#define TLBTR2_NSTID (TLBTR2_NSTID_MASK << TLBTR2_NSTID_SHIFT)
> +#define TLBTR2_NV (TLBTR2_NV_MASK << TLBTR2_NV_SHIFT)
> +#define TLBTR2_VA (TLBTR2_VA_MASK << TLBTR2_VA_SHIFT)
> +
> +
> +/* Context Register Fields */
> +/* ACTLR */
> +#define CFERE (CFERE_MASK << CFERE_SHIFT)
> +#define CFEIE (CFEIE_MASK << CFEIE_SHIFT)
> +#define PTSHCFG (PTSHCFG_MASK << PTSHCFG_SHIFT)
> +#define RCOSH (RCOSH_MASK << RCOSH_SHIFT)
> +#define RCISH (RCISH_MASK << RCISH_SHIFT)
> +#define RCNSH (RCNSH_MASK << RCNSH_SHIFT)
> +#define PRIVCFG (PRIVCFG_MASK << PRIVCFG_SHIFT)
> +#define DNA (DNA_MASK << DNA_SHIFT)
> +#define DNLV2PA (DNLV2PA_MASK << DNLV2PA_SHIFT)
> +#define TLBMCFG (TLBMCFG_MASK << TLBMCFG_SHIFT)
> +#define CFCFG (CFCFG_MASK << CFCFG_SHIFT)
> +#define TIPCF (TIPCF_MASK << TIPCF_SHIFT)
> +#define V2PCFG (V2PCFG_MASK << V2PCFG_SHIFT)
> +#define HUME (HUME_MASK << HUME_SHIFT)
> +#define PTMTCFG (PTMTCFG_MASK << PTMTCFG_SHIFT)
> +#define PTMEMTYPE (PTMEMTYPE_MASK << PTMEMTYPE_SHIFT)
> +
> +
> +/* BFBCR */
> +#define BFBDFE (BFBDFE_MASK << BFBDFE_SHIFT)
> +#define BFBSFE (BFBSFE_MASK << BFBSFE_SHIFT)
> +#define SFVS (SFVS_MASK << SFVS_SHIFT)
> +#define FLVIC (FLVIC_MASK << FLVIC_SHIFT)
> +#define SLVIC (SLVIC_MASK << SLVIC_SHIFT)
> +
> +
> +/* CONTEXTIDR */
> +#define CONTEXTIDR_ASID (CONTEXTIDR_ASID_MASK << CONTEXTIDR_ASID_SHIFT)
> +#define PROCID (PROCID_MASK << PROCID_SHIFT)
> +
> +
> +/* FSR */
> +#define TF (TF_MASK << TF_SHIFT)
> +#define AFF (AFF_MASK << AFF_SHIFT)
> +#define APF (APF_MASK << APF_SHIFT)
> +#define TLBMF (TLBMF_MASK << TLBMF_SHIFT)
> +#define HTWDEEF (HTWDEEF_MASK << HTWDEEF_SHIFT)
> +#define HTWSEEF (HTWSEEF_MASK << HTWSEEF_SHIFT)
> +#define MHF (MHF_MASK << MHF_SHIFT)
> +#define SL (SL_MASK << SL_SHIFT)
> +#define SS (SS_MASK << SS_SHIFT)
> +#define MULTI (MULTI_MASK << MULTI_SHIFT)
> +
> +
> +/* FSYNR0 */
> +#define AMID (AMID_MASK << AMID_SHIFT)
> +#define APID (APID_MASK << APID_SHIFT)
> +#define ABID (ABID_MASK << ABID_SHIFT)
> +#define ATID (ATID_MASK << ATID_SHIFT)
> +
> +
> +/* FSYNR1 */
> +#define AMEMTYPE (AMEMTYPE_MASK << AMEMTYPE_SHIFT)
> +#define ASHARED (ASHARED_MASK << ASHARED_SHIFT)
> +#define AINNERSHARED (AINNERSHARED_MASK << AINNERSHARED_SHIFT)
> +#define APRIV (APRIV_MASK << APRIV_SHIFT)
> +#define APROTNS (APROTNS_MASK << APROTNS_SHIFT)
> +#define AINST (AINST_MASK << AINST_SHIFT)
> +#define AWRITE (AWRITE_MASK << AWRITE_SHIFT)
> +#define ABURST (ABURST_MASK << ABURST_SHIFT)
> +#define ALEN (ALEN_MASK << ALEN_SHIFT)
> +#define FSYNR1_ASIZE (FSYNR1_ASIZE_MASK << FSYNR1_ASIZE_SHIFT)
> +#define ALOCK (ALOCK_MASK << ALOCK_SHIFT)
> +#define AFULL (AFULL_MASK << AFULL_SHIFT)
> +
> +
> +/* NMRR */
> +#define ICPC0 (ICPC0_MASK << ICPC0_SHIFT)
> +#define ICPC1 (ICPC1_MASK << ICPC1_SHIFT)
> +#define ICPC2 (ICPC2_MASK << ICPC2_SHIFT)
> +#define ICPC3 (ICPC3_MASK << ICPC3_SHIFT)
> +#define ICPC4 (ICPC4_MASK << ICPC4_SHIFT)
> +#define ICPC5 (ICPC5_MASK << ICPC5_SHIFT)
> +#define ICPC6 (ICPC6_MASK << ICPC6_SHIFT)
> +#define ICPC7 (ICPC7_MASK << ICPC7_SHIFT)
> +#define OCPC0 (OCPC0_MASK << OCPC0_SHIFT)
> +#define OCPC1 (OCPC1_MASK << OCPC1_SHIFT)
> +#define OCPC2 (OCPC2_MASK << OCPC2_SHIFT)
> +#define OCPC3 (OCPC3_MASK << OCPC3_SHIFT)
> +#define OCPC4 (OCPC4_MASK << OCPC4_SHIFT)
> +#define OCPC5 (OCPC5_MASK << OCPC5_SHIFT)
> +#define OCPC6 (OCPC6_MASK << OCPC6_SHIFT)
> +#define OCPC7 (OCPC7_MASK << OCPC7_SHIFT)
> +
> +
> +/* PAR */
> +#define FAULT (FAULT_MASK << FAULT_SHIFT)
> +/* If a fault is present, these are the
> +same as the fault fields in the FAR */
> +#define FAULT_TF (FAULT_TF_MASK << FAULT_TF_SHIFT)
> +#define FAULT_AFF (FAULT_AFF_MASK << FAULT_AFF_SHIFT)
> +#define FAULT_APF (FAULT_APF_MASK << FAULT_APF_SHIFT)
> +#define FAULT_TLBMF (FAULT_TLBMF_MASK << FAULT_TLBMF_SHIFT)
> +#define FAULT_HTWDEEF (FAULT_HTWDEEF_MASK << FAULT_HTWDEEF_SHIFT)
> +#define FAULT_HTWSEEF (FAULT_HTWSEEF_MASK << FAULT_HTWSEEF_SHIFT)
> +#define FAULT_MHF (FAULT_MHF_MASK << FAULT_MHF_SHIFT)
> +#define FAULT_SL (FAULT_SL_MASK << FAULT_SL_SHIFT)
> +#define FAULT_SS (FAULT_SS_MASK << FAULT_SS_SHIFT)
> +
> +/* If NO fault is present, the following fields are in effect */
> +/* (FAULT remains as before) */
> +#define PAR_NOFAULT_SS (PAR_NOFAULT_SS_MASK << PAR_NOFAULT_SS_SHIFT)
> +#define PAR_NOFAULT_MT (PAR_NOFAULT_MT_MASK << PAR_NOFAULT_MT_SHIFT)
> +#define PAR_NOFAULT_SH (PAR_NOFAULT_SH_MASK << PAR_NOFAULT_SH_SHIFT)
> +#define PAR_NOFAULT_NS (PAR_NOFAULT_NS_MASK << PAR_NOFAULT_NS_SHIFT)
> +#define PAR_NOFAULT_NOS (PAR_NOFAULT_NOS_MASK << PAR_NOFAULT_NOS_SHIFT)
> +#define PAR_NPFAULT_PA (PAR_NPFAULT_PA_MASK << PAR_NPFAULT_PA_SHIFT)
> +
> +
> +/* PRRR */
> +#define MTC0 (MTC0_MASK << MTC0_SHIFT)
> +#define MTC1 (MTC1_MASK << MTC1_SHIFT)
> +#define MTC2 (MTC2_MASK << MTC2_SHIFT)
> +#define MTC3 (MTC3_MASK << MTC3_SHIFT)
> +#define MTC4 (MTC4_MASK << MTC4_SHIFT)
> +#define MTC5 (MTC5_MASK << MTC5_SHIFT)
> +#define MTC6 (MTC6_MASK << MTC6_SHIFT)
> +#define MTC7 (MTC7_MASK << MTC7_SHIFT)
> +#define SHDSH0 (SHDSH0_MASK << SHDSH0_SHIFT)
> +#define SHDSH1 (SHDSH1_MASK << SHDSH1_SHIFT)
> +#define SHNMSH0 (SHNMSH0_MASK << SHNMSH0_SHIFT)
> +#define SHNMSH1 (SHNMSH1_MASK << SHNMSH1_SHIFT)
> +#define NOS0 (NOS0_MASK << NOS0_SHIFT)
> +#define NOS1 (NOS1_MASK << NOS1_SHIFT)
> +#define NOS2 (NOS2_MASK << NOS2_SHIFT)
> +#define NOS3 (NOS3_MASK << NOS3_SHIFT)
> +#define NOS4 (NOS4_MASK << NOS4_SHIFT)
> +#define NOS5 (NOS5_MASK << NOS5_SHIFT)
> +#define NOS6 (NOS6_MASK << NOS6_SHIFT)
> +#define NOS7 (NOS7_MASK << NOS7_SHIFT)
> +
> +
> +/* RESUME */
> +#define TNR (TNR_MASK << TNR_SHIFT)
> +
> +
> +/* SCTLR */
> +#define M (M_MASK << M_SHIFT)
> +#define TRE (TRE_MASK << TRE_SHIFT)
> +#define AFE (AFE_MASK << AFE_SHIFT)
> +#define HAF (HAF_MASK << HAF_SHIFT)
> +#define BE (BE_MASK << BE_SHIFT)
> +#define AFFD (AFFD_MASK << AFFD_SHIFT)
> +
> +
> +/* TLBIASID */
> +#define TLBIASID_ASID (TLBIASID_ASID_MASK << TLBIASID_ASID_SHIFT)
> +
> +
> +/* TLBIVA */
> +#define TLBIVA_ASID (TLBIVA_ASID_MASK << TLBIVA_ASID_SHIFT)
> +#define TLBIVA_VA (TLBIVA_VA_MASK << TLBIVA_VA_SHIFT)
> +
> +
> +/* TLBIVAA */
> +#define TLBIVAA_VA (TLBIVAA_VA_MASK << TLBIVAA_VA_SHIFT)
> +
> +
> +/* TLBLCKR */
> +#define LKE (LKE_MASK << LKE_SHIFT)
> +#define TLBLCKR_TLBIALLCFG (TLBLCKR_TLBIALLCFG_MASK<<TLBLCKR_TLBIALLCFG_SHIFT)
> +#define TLBIASIDCFG (TLBIASIDCFG_MASK << TLBIASIDCFG_SHIFT)
> +#define TLBIVAACFG (TLBIVAACFG_MASK << TLBIVAACFG_SHIFT)
> +#define FLOOR (FLOOR_MASK << FLOOR_SHIFT)
> +#define VICTIM (VICTIM_MASK << VICTIM_SHIFT)
> +
> +
> +/* TTBCR */
> +#define N (N_MASK << N_SHIFT)
> +#define PD0 (PD0_MASK << PD0_SHIFT)
> +#define PD1 (PD1_MASK << PD1_SHIFT)
> +
> +
> +/* TTBR0 */
> +#define TTBR0_IRGNH (TTBR0_IRGNH_MASK << TTBR0_IRGNH_SHIFT)
> +#define TTBR0_SH (TTBR0_SH_MASK << TTBR0_SH_SHIFT)
> +#define TTBR0_ORGN (TTBR0_ORGN_MASK << TTBR0_ORGN_SHIFT)
> +#define TTBR0_NOS (TTBR0_NOS_MASK << TTBR0_NOS_SHIFT)
> +#define TTBR0_IRGNL (TTBR0_IRGNL_MASK << TTBR0_IRGNL_SHIFT)
> +#define TTBR0_PA (TTBR0_PA_MASK << TTBR0_PA_SHIFT)
> +
> +
> +/* TTBR1 */
> +#define TTBR1_IRGNH (TTBR1_IRGNH_MASK << TTBR1_IRGNH_SHIFT)
> +#define TTBR1_SH (TTBR1_SH_MASK << TTBR1_SH_SHIFT)
> +#define TTBR1_ORGN (TTBR1_ORGN_MASK << TTBR1_ORGN_SHIFT)
> +#define TTBR1_NOS (TTBR1_NOS_MASK << TTBR1_NOS_SHIFT)
> +#define TTBR1_IRGNL (TTBR1_IRGNL_MASK << TTBR1_IRGNL_SHIFT)
> +#define TTBR1_PA (TTBR1_PA_MASK << TTBR1_PA_SHIFT)
> +
> +
> +/* V2PSR */
> +#define HIT (HIT_MASK << HIT_SHIFT)
> +#define INDEX (INDEX_MASK << INDEX_SHIFT)
> +
> +
> +/* V2Pxx */
> +#define V2Pxx_INDEX (V2Pxx_INDEX_MASK << V2Pxx_INDEX_SHIFT)
> +#define V2Pxx_VA (V2Pxx_VA_MASK << V2Pxx_VA_SHIFT)
> +
> +
> +/* Global Register Masks */
> +/* CBACRn */
> +#define RWVMID_MASK 0x1F
> +#define RWE_MASK 0x01
> +#define RWGE_MASK 0x01
> +#define CBVMID_MASK 0x1F
> +#define IRPTNDX_MASK 0xFF
> +
> +
> +/* CR */
> +#define RPUE_MASK 0x01
> +#define RPUERE_MASK 0x01
> +#define RPUEIE_MASK 0x01
> +#define DCDEE_MASK 0x01
> +#define CLIENTPD_MASK 0x01
> +#define STALLD_MASK 0x01
> +#define TLBLKCRWE_MASK 0x01
> +#define CR_TLBIALLCFG_MASK 0x01
> +#define TLBIVMIDCFG_MASK 0x01
> +#define CR_HUME_MASK 0x01
> +
> +
> +/* ESR */
> +#define CFG_MASK 0x01
> +#define BYPASS_MASK 0x01
> +#define ESR_MULTI_MASK 0x01
> +
> +
> +/* ESYNR0 */
> +#define ESYNR0_AMID_MASK 0xFF
> +#define ESYNR0_APID_MASK 0x1F
> +#define ESYNR0_ABID_MASK 0x07
> +#define ESYNR0_AVMID_MASK 0x1F
> +#define ESYNR0_ATID_MASK 0xFF
> +
 |  Next  |  Last
Pages: 1 2 3
Prev: [PATCH] tracing: extend recordmcount to better support Blackfin mcount
Next: typo in crypto kconfig ?