Commit 87f42391 authored by Jean-Philippe Brucker's avatar Jean-Philippe Brucker Committed by Will Deacon
Browse files

iommu/arm-smmu-v3: Add support for Substream IDs 



At the moment, the SMMUv3 driver implements only one stage-1 or stage-2
page directory per device. However SMMUv3 allows more than one address
space for some devices, by providing multiple stage-1 page directories. In
addition to the Stream ID (SID), that identifies a device, we can now have
Substream IDs (SSID) identifying an address space. In PCIe, SID is called
Requester ID (RID) and SSID is called Process Address-Space ID (PASID).
A complete stage-1 walk goes through the context descriptor table:

      Stream tables       Ctx. Desc. tables       Page tables
        +--------+   ,------->+-------+   ,------->+-------+
        :        :   |        :       :   |        :       :
        +--------+   |        +-------+   |        +-------+
   SID->|  STE   |---'  SSID->|  CD   |---'  IOVA->|  PTE  |--> IPA
        +--------+            +-------+            +-------+
        :        :            :       :            :       :
        +--------+            +-------+            +-------+

Rewrite arm_smmu_write_ctx_desc() to modify context descriptor table
entries. To keep things simple we only implement one level of context
descriptor tables here, but as with stream and page tables, an SSID can
be split to index multiple levels of tables.

Signed-off-by: default avatarJean-Philippe Brucker <jean-philippe@linaro.org>
Signed-off-by: default avatarWill Deacon <will@kernel.org>
parent a557aff0

drivers/iommu/arm-smmu-v3.c

+111 −22
Original line number Diff line number Diff line
@@ -226,6 +226,11 @@ 
#define STRTAB_STE_0_S1CTXPTR_MASK	GENMASK_ULL(51, 6)

#define STRTAB_STE_0_S1CDMAX		GENMASK_ULL(63, 59)



#define STRTAB_STE_1_S1DSS		GENMASK_ULL(1, 0)

#define STRTAB_STE_1_S1DSS_TERMINATE	0x0

#define STRTAB_STE_1_S1DSS_BYPASS	0x1

#define STRTAB_STE_1_S1DSS_SSID0	0x2



#define STRTAB_STE_1_S1C_CACHE_NC	0UL

#define STRTAB_STE_1_S1C_CACHE_WBRA	1UL

#define STRTAB_STE_1_S1C_CACHE_WT	2UL
@@ -322,6 +327,7 @@ 
#define CMDQ_PREFETCH_1_SIZE		GENMASK_ULL(4, 0)

#define CMDQ_PREFETCH_1_ADDR_MASK	GENMASK_ULL(63, 12)



#define CMDQ_CFGI_0_SSID		GENMASK_ULL(31, 12)

#define CMDQ_CFGI_0_SID			GENMASK_ULL(63, 32)

#define CMDQ_CFGI_1_LEAF		(1UL << 0)

#define CMDQ_CFGI_1_RANGE		GENMASK_ULL(4, 0)
@@ -435,8 +441,11 @@ struct arm_smmu_cmdq_ent { 


		#define CMDQ_OP_CFGI_STE	0x3

		#define CMDQ_OP_CFGI_ALL	0x4

		#define CMDQ_OP_CFGI_CD		0x5

		#define CMDQ_OP_CFGI_CD_ALL	0x6

		struct {

			u32			sid;

			u32			ssid;

			union {

				bool		leaf;

				u8		span;
@@ -558,6 +567,7 @@ struct arm_smmu_ctx_desc_cfg { 
struct arm_smmu_s1_cfg {

	struct arm_smmu_ctx_desc_cfg	cdcfg;

	struct arm_smmu_ctx_desc	cd;

	u8				s1fmt;

	u8				s1cdmax;

};
@@ -850,10 +860,16 @@ static int arm_smmu_cmdq_build_cmd(u64 *cmd, struct arm_smmu_cmdq_ent *ent) 
		cmd[1] |= FIELD_PREP(CMDQ_PREFETCH_1_SIZE, ent->prefetch.size);

		cmd[1] |= ent->prefetch.addr & CMDQ_PREFETCH_1_ADDR_MASK;

		break;

	case CMDQ_OP_CFGI_CD:

		cmd[0] |= FIELD_PREP(CMDQ_CFGI_0_SSID, ent->cfgi.ssid);

		/* Fallthrough */

	case CMDQ_OP_CFGI_STE:

		cmd[0] |= FIELD_PREP(CMDQ_CFGI_0_SID, ent->cfgi.sid);

		cmd[1] |= FIELD_PREP(CMDQ_CFGI_1_LEAF, ent->cfgi.leaf);

		break;

	case CMDQ_OP_CFGI_CD_ALL:

		cmd[0] |= FIELD_PREP(CMDQ_CFGI_0_SID, ent->cfgi.sid);

		break;

	case CMDQ_OP_CFGI_ALL:

		/* Cover the entire SID range */

		cmd[1] |= FIELD_PREP(CMDQ_CFGI_1_RANGE, 31);
@@ -1447,34 +1463,101 @@ static int arm_smmu_cmdq_issue_sync(struct arm_smmu_device *smmu) 
}



/* Context descriptor manipulation functions */

static void arm_smmu_write_ctx_desc(struct arm_smmu_device *smmu,

				    struct arm_smmu_s1_cfg *cfg)

static void arm_smmu_sync_cd(struct arm_smmu_domain *smmu_domain,

			     int ssid, bool leaf)

{

	size_t i;

	unsigned long flags;

	struct arm_smmu_master *master;

	struct arm_smmu_device *smmu = smmu_domain->smmu;

	struct arm_smmu_cmdq_ent cmd = {

		.opcode	= CMDQ_OP_CFGI_CD,

		.cfgi	= {

			.ssid	= ssid,

			.leaf	= leaf,

		},

	};



	spin_lock_irqsave(&smmu_domain->devices_lock, flags);

	list_for_each_entry(master, &smmu_domain->devices, domain_head) {

		for (i = 0; i < master->num_sids; i++) {

			cmd.cfgi.sid = master->sids[i];

			arm_smmu_cmdq_issue_cmd(smmu, &cmd);

		}

	}

	spin_unlock_irqrestore(&smmu_domain->devices_lock, flags);



	arm_smmu_cmdq_issue_sync(smmu);

}



static int arm_smmu_write_ctx_desc(struct arm_smmu_domain *smmu_domain,

				   int ssid, struct arm_smmu_ctx_desc *cd)

{

	/*

	 * This function handles the following cases:

	 *

	 * (1) Install primary CD, for normal DMA traffic (SSID = 0).

	 * (2) Install a secondary CD, for SID+SSID traffic.

	 * (3) Update ASID of a CD. Atomically write the first 64 bits of the

	 *     CD, then invalidate the old entry and mappings.

	 * (4) Remove a secondary CD.

	 */

	u64 val;

	__le64 *cdptr = cfg->cdcfg.cdtab;

	bool cd_live;

	struct arm_smmu_device *smmu = smmu_domain->smmu;

	__le64 *cdptr = smmu_domain->s1_cfg.cdcfg.cdtab + ssid *

			CTXDESC_CD_DWORDS;



	val = le64_to_cpu(cdptr[0]);

	cd_live = !!(val & CTXDESC_CD_0_V);



	if (!cd) { /* (4) */

		val = 0;

	} else if (cd_live) { /* (3) */

		val &= ~CTXDESC_CD_0_ASID;

		val |= FIELD_PREP(CTXDESC_CD_0_ASID, cd->asid);

		/*

	 * We don't need to issue any invalidation here, as we'll invalidate

	 * the STE when installing the new entry anyway.

		 * Until CD+TLB invalidation, both ASIDs may be used for tagging

		 * this substream's traffic

		 */

	val = cfg->cd.tcr |

	} else { /* (1) and (2) */

		cdptr[1] = cpu_to_le64(cd->ttbr & CTXDESC_CD_1_TTB0_MASK);

		cdptr[2] = 0;

		cdptr[3] = cpu_to_le64(cd->mair);



		/*

		 * STE is live, and the SMMU might read dwords of this CD in any

		 * order. Ensure that it observes valid values before reading

		 * V=1.

		 */

		arm_smmu_sync_cd(smmu_domain, ssid, true);



		val = cd->tcr |

#ifdef __BIG_ENDIAN

			CTXDESC_CD_0_ENDI |

#endif

			CTXDESC_CD_0_R | CTXDESC_CD_0_A | CTXDESC_CD_0_ASET |

	      CTXDESC_CD_0_AA64 | FIELD_PREP(CTXDESC_CD_0_ASID, cfg->cd.asid) |

			CTXDESC_CD_0_AA64 |

			FIELD_PREP(CTXDESC_CD_0_ASID, cd->asid) |

			CTXDESC_CD_0_V;



		/* STALL_MODEL==0b10 && CD.S==0 is ILLEGAL */

		if (smmu->features & ARM_SMMU_FEAT_STALL_FORCE)

			val |= CTXDESC_CD_0_S;

	}



	cdptr[0] = cpu_to_le64(val);



	val = cfg->cd.ttbr & CTXDESC_CD_1_TTB0_MASK;

	cdptr[1] = cpu_to_le64(val);



	cdptr[3] = cpu_to_le64(cfg->cd.mair);

	/*

	 * The SMMU accesses 64-bit values atomically. See IHI0070Ca 3.21.3

	 * "Configuration structures and configuration invalidation completion"

	 *

	 *   The size of single-copy atomic reads made by the SMMU is

	 *   IMPLEMENTATION DEFINED but must be at least 64 bits. Any single

	 *   field within an aligned 64-bit span of a structure can be altered

	 *   without first making the structure invalid.

	 */

	WRITE_ONCE(cdptr[0], cpu_to_le64(val));

	arm_smmu_sync_cd(smmu_domain, ssid, true);

	return 0;

}



static int arm_smmu_alloc_cd_tables(struct arm_smmu_domain *smmu_domain)
@@ -1484,6 +1567,8 @@ static int arm_smmu_alloc_cd_tables(struct arm_smmu_domain *smmu_domain) 
	struct arm_smmu_s1_cfg *cfg = &smmu_domain->s1_cfg;

	struct arm_smmu_ctx_desc_cfg *cdcfg = &cfg->cdcfg;



	cfg->s1fmt = STRTAB_STE_0_S1FMT_LINEAR;



	cdcfg->num_l1_ents = 1UL << cfg->s1cdmax;

	l1size = cdcfg->num_l1_ents * (CTXDESC_CD_DWORDS << 3);

	cdcfg->cdtab = dmam_alloc_coherent(smmu->dev, l1size, &cdcfg->cdtab_dma,
@@ -1625,6 +1710,7 @@ static void arm_smmu_write_strtab_ent(struct arm_smmu_master *master, u32 sid, 
	if (s1_cfg) {

		BUG_ON(ste_live);

		dst[1] = cpu_to_le64(

			 FIELD_PREP(STRTAB_STE_1_S1DSS, STRTAB_STE_1_S1DSS_SSID0) |

			 FIELD_PREP(STRTAB_STE_1_S1CIR, STRTAB_STE_1_S1C_CACHE_WBRA) |

			 FIELD_PREP(STRTAB_STE_1_S1COR, STRTAB_STE_1_S1C_CACHE_WBRA) |

			 FIELD_PREP(STRTAB_STE_1_S1CSH, ARM_SMMU_SH_ISH) |
@@ -1635,7 +1721,9 @@ static void arm_smmu_write_strtab_ent(struct arm_smmu_master *master, u32 sid, 
			dst[1] |= cpu_to_le64(STRTAB_STE_1_S1STALLD);



		val |= (s1_cfg->cdcfg.cdtab_dma & STRTAB_STE_0_S1CTXPTR_MASK) |

			FIELD_PREP(STRTAB_STE_0_CFG, STRTAB_STE_0_CFG_S1_TRANS);

			FIELD_PREP(STRTAB_STE_0_CFG, STRTAB_STE_0_CFG_S1_TRANS) |

			FIELD_PREP(STRTAB_STE_0_S1CDMAX, s1_cfg->s1cdmax) |

			FIELD_PREP(STRTAB_STE_0_S1FMT, s1_cfg->s1fmt);

	}



	if (s2_cfg) {
@@ -2455,7 +2543,8 @@ static int arm_smmu_attach_dev(struct iommu_domain *domain, struct device *dev) 
		master->ats_enabled = arm_smmu_ats_supported(master);



	if (smmu_domain->stage == ARM_SMMU_DOMAIN_S1)

		arm_smmu_write_ctx_desc(smmu, &smmu_domain->s1_cfg);

		arm_smmu_write_ctx_desc(smmu_domain, 0,

					&smmu_domain->s1_cfg.cd);



	arm_smmu_install_ste_for_dev(master);

CRA Git | Maintained and supported by SUSTech CRA and CCSE