Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7d0946b9 authored by Robin Murphy's avatar Robin Murphy Committed by Isaac J. Manjarres
Browse files

iommu/arm-smmu: Move Secure access quirk to implementation 



Move detection of the Secure access quirk to its new home, trimming it
down in the process - time has proven that boolean DT flags are neither
ideal nor necessarily sufficient, so it's highly unlikely we'll ever add
more, let alone enough to justify the frankly overengineered parsing
machinery.

Change-Id: I86a898715cb1d036949df4dcf7333068bcf64836
Signed-off-by: default avatarRobin Murphy <robin.murphy@arm.com>
Signed-off-by: default avatarWill Deacon <will@kernel.org>
Git-commit: 6d7dff62
Git-repo: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git


[isaacm@codeaurora.org: resolved merge conflicts]
Signed-off-by: default avatarIsaac J. Manjarres <isaacm@codeaurora.org>
parent 2027b201

drivers/iommu/arm-smmu-impl.c

+44 −0
Original line number Diff line number Diff line
@@ -4,10 +4,54 @@ 


#define pr_fmt(fmt) "arm-smmu: " fmt



#include <linux/of.h>



#include "arm-smmu.h"





static int arm_smmu_gr0_ns(int offset)

{

	switch(offset) {

	case ARM_SMMU_GR0_sCR0:

	case ARM_SMMU_GR0_sACR:

	case ARM_SMMU_GR0_sGFSR:

	case ARM_SMMU_GR0_sGFSYNR0:

	case ARM_SMMU_GR0_sGFSYNR1:

	case ARM_SMMU_GR0_sGFSYNR2:

		return offset + 0x400;

	default:

		return offset;

	}

}



static u32 arm_smmu_read_ns(struct arm_smmu_device *smmu, int page,

			    int offset)

{

	if (page == ARM_SMMU_GR0)

		offset = arm_smmu_gr0_ns(offset);

	return readl_relaxed(arm_smmu_page(smmu, page) + offset);

}



static void arm_smmu_write_ns(struct arm_smmu_device *smmu, int page,

			      int offset, u32 val)

{

	if (page == ARM_SMMU_GR0)

		offset = arm_smmu_gr0_ns(offset);

	writel_relaxed(val, arm_smmu_page(smmu, page) + offset);

}



/* Since we don't care for sGFAR, we can do without 64-bit accessors */

const struct arm_smmu_impl calxeda_impl = {

	.read_reg = arm_smmu_read_ns,

	.write_reg = arm_smmu_write_ns,

};





struct arm_smmu_device *arm_smmu_impl_init(struct arm_smmu_device *smmu)

{

	if (of_property_read_bool(smmu->dev->of_node,

				  "calxeda,smmu-secure-config-access"))

		smmu->impl = &calxeda_impl;



	return smmu;

}

drivers/iommu/arm-smmu.c

+2 −74
Original line number Diff line number Diff line
@@ -215,88 +215,16 @@ struct arm_smmu_domain { 
	struct msm_iommu_domain		domain;

};



static int arm_smmu_gr0_ns(int offset)

{

	switch(offset) {

	case ARM_SMMU_GR0_sCR0:

	case ARM_SMMU_GR0_sACR:

	case ARM_SMMU_GR0_sGFSR:

	case ARM_SMMU_GR0_sGFSYNR0:

	case ARM_SMMU_GR0_sGFSYNR1:

	case ARM_SMMU_GR0_sGFSYNR2:

		return offset + 0x400;

	default:

		return offset;

	}

}



static void __iomem *arm_smmu_page(struct arm_smmu_device *smmu, int n)

{

	return smmu->base + (n << smmu->pgshift);

}



static u32 arm_smmu_readl(struct arm_smmu_device *smmu, int page, int offset)

{

	if ((smmu->options & ARM_SMMU_OPT_SECURE_CFG_ACCESS) && page == 0)

		offset = arm_smmu_gr0_ns(offset);



	return readl_relaxed(arm_smmu_page(smmu, page) + offset);

}



static void arm_smmu_writel(struct arm_smmu_device *smmu, int page, int offset,

			    u32 val)

{

	if ((smmu->options & ARM_SMMU_OPT_SECURE_CFG_ACCESS) && page == 0)

		offset = arm_smmu_gr0_ns(offset);



	writel_relaxed(val, arm_smmu_page(smmu, page) + offset);

}



static u64 arm_smmu_readq(struct arm_smmu_device *smmu, int page, int offset)

{

	return readq_relaxed(arm_smmu_page(smmu, page) + offset);

}



static void arm_smmu_writeq(struct arm_smmu_device *smmu, int page, int offset,

			    u64 val)

{

	writeq_relaxed(val, arm_smmu_page(smmu, page) + offset);

}



#define ARM_SMMU_GR0		0

#define ARM_SMMU_GR1		1

#define ARM_SMMU_CB(s, n)	((s)->numpage + (n))



#define arm_smmu_gr0_read(s, o)		\

	arm_smmu_readl((s), ARM_SMMU_GR0, (o))

#define arm_smmu_gr0_write(s, o, v)	\

	arm_smmu_writel((s), ARM_SMMU_GR0, (o), (v))



#define arm_smmu_gr1_read(s, o)		\

	arm_smmu_readl((s), ARM_SMMU_GR1, (o))

#define arm_smmu_gr1_write(s, o, v)	\

	arm_smmu_writel((s), ARM_SMMU_GR1, (o), (v))

static atomic_t cavium_smmu_context_count = ATOMIC_INIT(0);



#define arm_smmu_cb_read(s, n, o)	\

	arm_smmu_readl((s), ARM_SMMU_CB((s), (n)), (o))

#define arm_smmu_cb_write(s, n, o, v)	\

	arm_smmu_writel((s), ARM_SMMU_CB((s), (n)), (o), (v))

#define arm_smmu_cb_readq(s, n, o)	\

	arm_smmu_readq((s), ARM_SMMU_CB((s), (n)), (o))

#define arm_smmu_cb_writeq(s, n, o, v)	\

	arm_smmu_writeq((s), ARM_SMMU_CB((s), (n)), (o), (v))

static bool using_legacy_binding, using_generic_binding;



struct arm_smmu_option_prop {

	u32 opt;

	const char *prop;

};



static atomic_t cavium_smmu_context_count = ATOMIC_INIT(0);



static bool using_legacy_binding, using_generic_binding;



static struct arm_smmu_option_prop arm_smmu_options[] = {

	{ ARM_SMMU_OPT_SECURE_CFG_ACCESS, "calxeda,smmu-secure-config-access" },

	{ ARM_SMMU_OPT_FATAL_ASF, "qcom,fatal-asf" },

	{ ARM_SMMU_OPT_SKIP_INIT, "qcom,skip-init" },

	{ ARM_SMMU_OPT_3LVL_TABLES, "qcom,use-3-lvl-tables" },

drivers/iommu/arm-smmu.h

+75 −6
Original line number Diff line number Diff line
@@ -305,15 +305,15 @@ struct arm_smmu_device { 
#define ARM_SMMU_FEAT_EXIDS		(1 << 12)

	u32				features;



#define ARM_SMMU_OPT_SECURE_CFG_ACCESS (1 << 0)

#define ARM_SMMU_OPT_FATAL_ASF		(1 << 1)

#define ARM_SMMU_OPT_SKIP_INIT		(1 << 2)

#define ARM_SMMU_OPT_3LVL_TABLES	(1 << 4)

#define ARM_SMMU_OPT_NO_ASID_RETENTION	(1 << 5)

#define ARM_SMMU_OPT_DISABLE_ATOS	(1 << 6)

#define ARM_SMMU_OPT_FATAL_ASF		(1 << 0)

#define ARM_SMMU_OPT_SKIP_INIT		(1 << 1)

#define ARM_SMMU_OPT_3LVL_TABLES	(1 << 2)

#define ARM_SMMU_OPT_NO_ASID_RETENTION	(1 << 3)

#define ARM_SMMU_OPT_DISABLE_ATOS	(1 << 4)

	u32				options;

	enum arm_smmu_arch_version	version;

	enum arm_smmu_implementation	model;

	const struct arm_smmu_impl	*impl;



	u32				num_context_banks;

	u32				num_s2_context_banks;
@@ -366,6 +366,75 @@ struct arm_smmu_device { 




/* Implementation details, yay! */

struct arm_smmu_impl {

	u32 (*read_reg)(struct arm_smmu_device *smmu, int page, int offset);

	void (*write_reg)(struct arm_smmu_device *smmu, int page, int offset,

			  u32 val);

	u64 (*read_reg64)(struct arm_smmu_device *smmu, int page, int offset);

	void (*write_reg64)(struct arm_smmu_device *smmu, int page, int offset,

			    u64 val);

};



static inline void __iomem *arm_smmu_page(struct arm_smmu_device *smmu, int n)

{

	return smmu->base + (n << smmu->pgshift);

}



static inline u32 arm_smmu_readl(struct arm_smmu_device *smmu, int page, int offset)

{

	if (smmu->impl && unlikely(smmu->impl->read_reg))

		return smmu->impl->read_reg(smmu, page, offset);

	return readl_relaxed(arm_smmu_page(smmu, page) + offset);

}



static inline void arm_smmu_writel(struct arm_smmu_device *smmu, int page,

				   int offset, u32 val)

{

	if (smmu->impl && unlikely(smmu->impl->write_reg))

		smmu->impl->write_reg(smmu, page, offset, val);

	else

		writel_relaxed(val, arm_smmu_page(smmu, page) + offset);

}



static inline u64 arm_smmu_readq(struct arm_smmu_device *smmu, int page, int offset)

{

	if (smmu->impl && unlikely(smmu->impl->read_reg64))

		return smmu->impl->read_reg64(smmu, page, offset);

	return readq_relaxed(arm_smmu_page(smmu, page) + offset);

}



static inline void arm_smmu_writeq(struct arm_smmu_device *smmu, int page,

				   int offset, u64 val)

{

	if (smmu->impl && unlikely(smmu->impl->write_reg64))

		smmu->impl->write_reg64(smmu, page, offset, val);

	else

		writeq_relaxed(val, arm_smmu_page(smmu, page) + offset);

}



#define ARM_SMMU_GR0		0

#define ARM_SMMU_GR1		1

#define ARM_SMMU_CB(s, n)	((s)->numpage + (n))



#define arm_smmu_gr0_read(s, o)		\

	arm_smmu_readl((s), ARM_SMMU_GR0, (o))

#define arm_smmu_gr0_write(s, o, v)	\

	arm_smmu_writel((s), ARM_SMMU_GR0, (o), (v))



#define arm_smmu_gr1_read(s, o)		\

	arm_smmu_readl((s), ARM_SMMU_GR1, (o))

#define arm_smmu_gr1_write(s, o, v)	\

	arm_smmu_writel((s), ARM_SMMU_GR1, (o), (v))



#define arm_smmu_cb_read(s, n, o)	\

	arm_smmu_readl((s), ARM_SMMU_CB((s), (n)), (o))

#define arm_smmu_cb_write(s, n, o, v)	\

	arm_smmu_writel((s), ARM_SMMU_CB((s), (n)), (o), (v))

#define arm_smmu_cb_readq(s, n, o)	\

	arm_smmu_readq((s), ARM_SMMU_CB((s), (n)), (o))

#define arm_smmu_cb_writeq(s, n, o, v)	\

	arm_smmu_writeq((s), ARM_SMMU_CB((s), (n)), (o), (v))



struct arm_smmu_device *arm_smmu_impl_init(struct arm_smmu_device *smmu);



#endif /* _ARM_SMMU_REGS_H */