2019-05-29 23:57:35 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0-only */
|
2007-10-21 23:41:49 +00:00
|
|
|
/*
|
2015-09-09 10:40:47 +00:00
|
|
|
* Copyright © 2006-2015, Intel Corporation.
|
|
|
|
*
|
|
|
|
* Authors: Ashok Raj <ashok.raj@intel.com>
|
|
|
|
* Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
|
|
|
|
* David Woodhouse <David.Woodhouse@intel.com>
|
2007-10-21 23:41:49 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef _INTEL_IOMMU_H_
|
|
|
|
#define _INTEL_IOMMU_H_
|
|
|
|
|
|
|
|
#include <linux/types.h>
|
2008-09-09 15:37:29 +00:00
|
|
|
#include <linux/iova.h>
|
2007-10-21 23:41:49 +00:00
|
|
|
#include <linux/io.h>
|
2015-09-09 10:40:47 +00:00
|
|
|
#include <linux/idr.h>
|
|
|
|
#include <linux/mmu_notifier.h>
|
|
|
|
#include <linux/list.h>
|
2017-02-01 12:23:08 +00:00
|
|
|
#include <linux/iommu.h>
|
2017-03-16 14:23:55 +00:00
|
|
|
#include <linux/io-64-nonatomic-lo-hi.h>
|
2018-07-14 07:46:57 +00:00
|
|
|
#include <linux/dmar.h>
|
2020-05-16 06:20:51 +00:00
|
|
|
#include <linux/ioasid.h>
|
2021-03-18 00:53:40 +00:00
|
|
|
#include <linux/bitfield.h>
|
2017-03-16 14:23:55 +00:00
|
|
|
|
2008-07-10 18:16:42 +00:00
|
|
|
#include <asm/cacheflush.h>
|
2008-10-17 01:02:32 +00:00
|
|
|
#include <asm/iommu.h>
|
2008-02-06 09:36:23 +00:00
|
|
|
|
2007-10-21 23:41:49 +00:00
|
|
|
/*
|
2018-11-12 06:40:08 +00:00
|
|
|
* VT-d hardware uses 4KiB page size regardless of host page size.
|
2007-10-21 23:41:49 +00:00
|
|
|
*/
|
2018-11-12 06:40:08 +00:00
|
|
|
#define VTD_PAGE_SHIFT (12)
|
|
|
|
#define VTD_PAGE_SIZE (1UL << VTD_PAGE_SHIFT)
|
|
|
|
#define VTD_PAGE_MASK (((u64)-1) << VTD_PAGE_SHIFT)
|
|
|
|
#define VTD_PAGE_ALIGN(addr) (((addr) + VTD_PAGE_SIZE - 1) & VTD_PAGE_MASK)
|
|
|
|
|
|
|
|
#define VTD_STRIDE_SHIFT (9)
|
|
|
|
#define VTD_STRIDE_MASK (((u64)-1) << VTD_STRIDE_SHIFT)
|
|
|
|
|
2020-01-02 00:18:17 +00:00
|
|
|
#define DMA_PTE_READ BIT_ULL(0)
|
|
|
|
#define DMA_PTE_WRITE BIT_ULL(1)
|
|
|
|
#define DMA_PTE_LARGE_PAGE BIT_ULL(7)
|
|
|
|
#define DMA_PTE_SNP BIT_ULL(11)
|
|
|
|
|
|
|
|
#define DMA_FL_PTE_PRESENT BIT_ULL(0)
|
2020-06-22 23:13:41 +00:00
|
|
|
#define DMA_FL_PTE_US BIT_ULL(2)
|
2021-01-15 00:42:02 +00:00
|
|
|
#define DMA_FL_PTE_ACCESS BIT_ULL(5)
|
|
|
|
#define DMA_FL_PTE_DIRTY BIT_ULL(6)
|
2020-01-02 00:18:17 +00:00
|
|
|
#define DMA_FL_PTE_XD BIT_ULL(63)
|
2018-11-12 06:40:08 +00:00
|
|
|
|
2020-05-16 06:20:46 +00:00
|
|
|
#define ADDR_WIDTH_5LEVEL (57)
|
|
|
|
#define ADDR_WIDTH_4LEVEL (48)
|
|
|
|
|
2018-11-12 06:40:08 +00:00
|
|
|
#define CONTEXT_TT_MULTI_LEVEL 0
|
|
|
|
#define CONTEXT_TT_DEV_IOTLB 1
|
|
|
|
#define CONTEXT_TT_PASS_THROUGH 2
|
2018-12-10 01:59:05 +00:00
|
|
|
#define CONTEXT_PASIDE BIT_ULL(3)
|
2007-10-21 23:41:49 +00:00
|
|
|
|
2018-11-12 06:40:08 +00:00
|
|
|
/*
|
|
|
|
* Intel IOMMU register specification per version 1.0 public spec.
|
|
|
|
*/
|
2007-10-21 23:41:49 +00:00
|
|
|
#define DMAR_VER_REG 0x0 /* Arch version supported by this IOMMU */
|
|
|
|
#define DMAR_CAP_REG 0x8 /* Hardware supported capabilities */
|
|
|
|
#define DMAR_ECAP_REG 0x10 /* Extended capabilities supported */
|
|
|
|
#define DMAR_GCMD_REG 0x18 /* Global command register */
|
|
|
|
#define DMAR_GSTS_REG 0x1c /* Global status register */
|
|
|
|
#define DMAR_RTADDR_REG 0x20 /* Root entry table */
|
|
|
|
#define DMAR_CCMD_REG 0x28 /* Context command reg */
|
|
|
|
#define DMAR_FSTS_REG 0x34 /* Fault Status register */
|
|
|
|
#define DMAR_FECTL_REG 0x38 /* Fault control register */
|
|
|
|
#define DMAR_FEDATA_REG 0x3c /* Fault event interrupt data register */
|
|
|
|
#define DMAR_FEADDR_REG 0x40 /* Fault event interrupt addr register */
|
|
|
|
#define DMAR_FEUADDR_REG 0x44 /* Upper address register */
|
|
|
|
#define DMAR_AFLOG_REG 0x58 /* Advanced Fault control */
|
|
|
|
#define DMAR_PMEN_REG 0x64 /* Enable Protected Memory Region */
|
|
|
|
#define DMAR_PLMBASE_REG 0x68 /* PMRR Low addr */
|
|
|
|
#define DMAR_PLMLIMIT_REG 0x6c /* PMRR low limit */
|
|
|
|
#define DMAR_PHMBASE_REG 0x70 /* pmrr high base addr */
|
|
|
|
#define DMAR_PHMLIMIT_REG 0x78 /* pmrr high limit */
|
2008-07-10 18:16:42 +00:00
|
|
|
#define DMAR_IQH_REG 0x80 /* Invalidation queue head register */
|
|
|
|
#define DMAR_IQT_REG 0x88 /* Invalidation queue tail register */
|
2009-05-18 05:51:35 +00:00
|
|
|
#define DMAR_IQ_SHIFT 4 /* Invalidation queue head/tail shift */
|
2008-07-10 18:16:42 +00:00
|
|
|
#define DMAR_IQA_REG 0x90 /* Invalidation queue addr register */
|
2013-09-13 06:27:32 +00:00
|
|
|
#define DMAR_ICS_REG 0x9c /* Invalidation complete status register */
|
2021-03-18 00:53:40 +00:00
|
|
|
#define DMAR_IQER_REG 0xb0 /* Invalidation queue error record register */
|
2008-07-10 18:16:43 +00:00
|
|
|
#define DMAR_IRTA_REG 0xb8 /* Interrupt remapping table addr register */
|
2015-10-07 14:37:03 +00:00
|
|
|
#define DMAR_PQH_REG 0xc0 /* Page request queue head register */
|
|
|
|
#define DMAR_PQT_REG 0xc8 /* Page request queue tail register */
|
|
|
|
#define DMAR_PQA_REG 0xd0 /* Page request queue address register */
|
|
|
|
#define DMAR_PRS_REG 0xdc /* Page request status register */
|
|
|
|
#define DMAR_PECTL_REG 0xe0 /* Page request event control register */
|
|
|
|
#define DMAR_PEDATA_REG 0xe4 /* Page request event interrupt data register */
|
|
|
|
#define DMAR_PEADDR_REG 0xe8 /* Page request event interrupt addr register */
|
|
|
|
#define DMAR_PEUADDR_REG 0xec /* Page request event Upper address register */
|
2018-09-12 00:11:37 +00:00
|
|
|
#define DMAR_MTRRCAP_REG 0x100 /* MTRR capability register */
|
|
|
|
#define DMAR_MTRRDEF_REG 0x108 /* MTRR default type register */
|
|
|
|
#define DMAR_MTRR_FIX64K_00000_REG 0x120 /* MTRR Fixed range registers */
|
|
|
|
#define DMAR_MTRR_FIX16K_80000_REG 0x128
|
|
|
|
#define DMAR_MTRR_FIX16K_A0000_REG 0x130
|
|
|
|
#define DMAR_MTRR_FIX4K_C0000_REG 0x138
|
|
|
|
#define DMAR_MTRR_FIX4K_C8000_REG 0x140
|
|
|
|
#define DMAR_MTRR_FIX4K_D0000_REG 0x148
|
|
|
|
#define DMAR_MTRR_FIX4K_D8000_REG 0x150
|
|
|
|
#define DMAR_MTRR_FIX4K_E0000_REG 0x158
|
|
|
|
#define DMAR_MTRR_FIX4K_E8000_REG 0x160
|
|
|
|
#define DMAR_MTRR_FIX4K_F0000_REG 0x168
|
|
|
|
#define DMAR_MTRR_FIX4K_F8000_REG 0x170
|
|
|
|
#define DMAR_MTRR_PHYSBASE0_REG 0x180 /* MTRR Variable range registers */
|
|
|
|
#define DMAR_MTRR_PHYSMASK0_REG 0x188
|
|
|
|
#define DMAR_MTRR_PHYSBASE1_REG 0x190
|
|
|
|
#define DMAR_MTRR_PHYSMASK1_REG 0x198
|
|
|
|
#define DMAR_MTRR_PHYSBASE2_REG 0x1a0
|
|
|
|
#define DMAR_MTRR_PHYSMASK2_REG 0x1a8
|
|
|
|
#define DMAR_MTRR_PHYSBASE3_REG 0x1b0
|
|
|
|
#define DMAR_MTRR_PHYSMASK3_REG 0x1b8
|
|
|
|
#define DMAR_MTRR_PHYSBASE4_REG 0x1c0
|
|
|
|
#define DMAR_MTRR_PHYSMASK4_REG 0x1c8
|
|
|
|
#define DMAR_MTRR_PHYSBASE5_REG 0x1d0
|
|
|
|
#define DMAR_MTRR_PHYSMASK5_REG 0x1d8
|
|
|
|
#define DMAR_MTRR_PHYSBASE6_REG 0x1e0
|
|
|
|
#define DMAR_MTRR_PHYSMASK6_REG 0x1e8
|
|
|
|
#define DMAR_MTRR_PHYSBASE7_REG 0x1f0
|
|
|
|
#define DMAR_MTRR_PHYSMASK7_REG 0x1f8
|
|
|
|
#define DMAR_MTRR_PHYSBASE8_REG 0x200
|
|
|
|
#define DMAR_MTRR_PHYSMASK8_REG 0x208
|
|
|
|
#define DMAR_MTRR_PHYSBASE9_REG 0x210
|
|
|
|
#define DMAR_MTRR_PHYSMASK9_REG 0x218
|
2021-08-18 13:48:44 +00:00
|
|
|
#define DMAR_VCCAP_REG 0xe30 /* Virtual command capability register */
|
|
|
|
#define DMAR_VCMD_REG 0xe00 /* Virtual command register */
|
|
|
|
#define DMAR_VCRSP_REG 0xe10 /* Virtual command response register */
|
2007-10-21 23:41:49 +00:00
|
|
|
|
2021-03-18 00:53:40 +00:00
|
|
|
#define DMAR_IQER_REG_IQEI(reg) FIELD_GET(GENMASK_ULL(3, 0), reg)
|
|
|
|
#define DMAR_IQER_REG_ITESID(reg) FIELD_GET(GENMASK_ULL(47, 32), reg)
|
|
|
|
#define DMAR_IQER_REG_ICESID(reg) FIELD_GET(GENMASK_ULL(63, 48), reg)
|
|
|
|
|
2007-10-21 23:41:49 +00:00
|
|
|
#define OFFSET_STRIDE (9)
|
2015-10-13 19:48:21 +00:00
|
|
|
|
|
|
|
#define dmar_readq(a) readq(a)
|
|
|
|
#define dmar_writeq(a,v) writeq(v,a)
|
2020-03-09 20:09:46 +00:00
|
|
|
#define dmar_readl(a) readl(a)
|
|
|
|
#define dmar_writel(a, v) writel(v, a)
|
2007-10-21 23:41:49 +00:00
|
|
|
|
|
|
|
#define DMAR_VER_MAJOR(v) (((v) & 0xf0) >> 4)
|
|
|
|
#define DMAR_VER_MINOR(v) ((v) & 0x0f)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decoding Capability Register
|
|
|
|
*/
|
2017-12-20 19:59:26 +00:00
|
|
|
#define cap_5lp_support(c) (((c) >> 60) & 1)
|
2015-06-09 05:20:34 +00:00
|
|
|
#define cap_pi_support(c) (((c) >> 59) & 1)
|
2017-12-20 19:59:25 +00:00
|
|
|
#define cap_fl1gp_support(c) (((c) >> 56) & 1)
|
2007-10-21 23:41:49 +00:00
|
|
|
#define cap_read_drain(c) (((c) >> 55) & 1)
|
|
|
|
#define cap_write_drain(c) (((c) >> 54) & 1)
|
|
|
|
#define cap_max_amask_val(c) (((c) >> 48) & 0x3f)
|
|
|
|
#define cap_num_fault_regs(c) ((((c) >> 40) & 0xff) + 1)
|
|
|
|
#define cap_pgsel_inv(c) (((c) >> 39) & 1)
|
|
|
|
|
|
|
|
#define cap_super_page_val(c) (((c) >> 34) & 0xf)
|
|
|
|
#define cap_super_offset(c) (((find_first_bit(&cap_super_page_val(c), 4)) \
|
|
|
|
* OFFSET_STRIDE) + 21)
|
|
|
|
|
|
|
|
#define cap_fault_reg_offset(c) ((((c) >> 24) & 0x3ff) * 16)
|
|
|
|
#define cap_max_fault_reg_offset(c) \
|
|
|
|
(cap_fault_reg_offset(c) + cap_num_fault_regs(c) * 16)
|
|
|
|
|
|
|
|
#define cap_zlr(c) (((c) >> 22) & 1)
|
|
|
|
#define cap_isoch(c) (((c) >> 23) & 1)
|
|
|
|
#define cap_mgaw(c) ((((c) >> 16) & 0x3f) + 1)
|
|
|
|
#define cap_sagaw(c) (((c) >> 8) & 0x1f)
|
|
|
|
#define cap_caching_mode(c) (((c) >> 7) & 1)
|
|
|
|
#define cap_phmr(c) (((c) >> 6) & 1)
|
|
|
|
#define cap_plmr(c) (((c) >> 5) & 1)
|
|
|
|
#define cap_rwbf(c) (((c) >> 4) & 1)
|
|
|
|
#define cap_afl(c) (((c) >> 3) & 1)
|
|
|
|
#define cap_ndoms(c) (((unsigned long)1) << (4 + 2 * ((c) & 0x7)))
|
|
|
|
/*
|
|
|
|
* Extended Capability Register
|
|
|
|
*/
|
|
|
|
|
2021-02-04 01:43:56 +00:00
|
|
|
#define ecap_rps(e) (((e) >> 49) & 0x1)
|
2018-12-10 01:59:00 +00:00
|
|
|
#define ecap_smpwc(e) (((e) >> 48) & 0x1)
|
2018-12-10 01:59:04 +00:00
|
|
|
#define ecap_flts(e) (((e) >> 47) & 0x1)
|
2018-12-10 01:59:00 +00:00
|
|
|
#define ecap_slts(e) (((e) >> 46) & 0x1)
|
2021-02-04 01:43:56 +00:00
|
|
|
#define ecap_slads(e) (((e) >> 45) & 0x1)
|
2020-05-16 06:20:50 +00:00
|
|
|
#define ecap_vcs(e) (((e) >> 44) & 0x1)
|
2018-12-10 01:58:55 +00:00
|
|
|
#define ecap_smts(e) (((e) >> 43) & 0x1)
|
2021-02-04 01:43:56 +00:00
|
|
|
#define ecap_dit(e) (((e) >> 41) & 0x1)
|
|
|
|
#define ecap_pds(e) (((e) >> 42) & 0x1)
|
|
|
|
#define ecap_pasid(e) (((e) >> 40) & 0x1)
|
|
|
|
#define ecap_pss(e) (((e) >> 35) & 0x1f)
|
|
|
|
#define ecap_eafs(e) (((e) >> 34) & 0x1)
|
|
|
|
#define ecap_nwfs(e) (((e) >> 33) & 0x1)
|
|
|
|
#define ecap_srs(e) (((e) >> 31) & 0x1)
|
|
|
|
#define ecap_ers(e) (((e) >> 30) & 0x1)
|
|
|
|
#define ecap_prs(e) (((e) >> 29) & 0x1)
|
|
|
|
#define ecap_broken_pasid(e) (((e) >> 28) & 0x1)
|
|
|
|
#define ecap_dis(e) (((e) >> 27) & 0x1)
|
|
|
|
#define ecap_nest(e) (((e) >> 26) & 0x1)
|
|
|
|
#define ecap_mts(e) (((e) >> 25) & 0x1)
|
|
|
|
#define ecap_ecs(e) (((e) >> 24) & 0x1)
|
2007-10-21 23:41:49 +00:00
|
|
|
#define ecap_iotlb_offset(e) ((((e) >> 8) & 0x3ff) * 16)
|
2015-02-13 14:25:24 +00:00
|
|
|
#define ecap_max_iotlb_offset(e) (ecap_iotlb_offset(e) + 16)
|
2007-10-21 23:41:49 +00:00
|
|
|
#define ecap_coherent(e) ((e) & 0x1)
|
2008-07-10 18:16:42 +00:00
|
|
|
#define ecap_qis(e) ((e) & 0x2)
|
2021-02-04 01:43:56 +00:00
|
|
|
#define ecap_pass_through(e) (((e) >> 6) & 0x1)
|
|
|
|
#define ecap_eim_support(e) (((e) >> 4) & 0x1)
|
|
|
|
#define ecap_ir_support(e) (((e) >> 3) & 0x1)
|
2009-05-18 05:51:37 +00:00
|
|
|
#define ecap_dev_iotlb_support(e) (((e) >> 2) & 0x1)
|
2021-02-04 01:43:56 +00:00
|
|
|
#define ecap_max_handle_mask(e) (((e) >> 20) & 0xf)
|
|
|
|
#define ecap_sc_support(e) (((e) >> 7) & 0x1) /* Snooping Control */
|
2007-10-21 23:41:49 +00:00
|
|
|
|
2020-05-16 06:20:51 +00:00
|
|
|
/* Virtual command interface capability */
|
|
|
|
#define vccap_pasid(v) (((v) & DMA_VCS_PAS)) /* PASID allocation */
|
|
|
|
|
2007-10-21 23:41:49 +00:00
|
|
|
/* IOTLB_REG */
|
2008-10-16 23:31:55 +00:00
|
|
|
#define DMA_TLB_FLUSH_GRANU_OFFSET 60
|
2007-10-21 23:41:49 +00:00
|
|
|
#define DMA_TLB_GLOBAL_FLUSH (((u64)1) << 60)
|
|
|
|
#define DMA_TLB_DSI_FLUSH (((u64)2) << 60)
|
|
|
|
#define DMA_TLB_PSI_FLUSH (((u64)3) << 60)
|
2017-01-30 17:39:52 +00:00
|
|
|
#define DMA_TLB_IIRG(type) ((type >> 60) & 3)
|
|
|
|
#define DMA_TLB_IAIG(val) (((val) >> 57) & 3)
|
2007-10-21 23:41:49 +00:00
|
|
|
#define DMA_TLB_READ_DRAIN (((u64)1) << 49)
|
|
|
|
#define DMA_TLB_WRITE_DRAIN (((u64)1) << 48)
|
|
|
|
#define DMA_TLB_DID(id) (((u64)((id) & 0xffff)) << 32)
|
|
|
|
#define DMA_TLB_IVT (((u64)1) << 63)
|
|
|
|
#define DMA_TLB_IH_NONLEAF (((u64)1) << 6)
|
|
|
|
#define DMA_TLB_MAX_SIZE (0x3f)
|
|
|
|
|
2008-07-10 18:16:42 +00:00
|
|
|
/* INVALID_DESC */
|
2008-10-16 23:31:55 +00:00
|
|
|
#define DMA_CCMD_INVL_GRANU_OFFSET 61
|
2017-01-30 17:39:52 +00:00
|
|
|
#define DMA_ID_TLB_GLOBAL_FLUSH (((u64)1) << 4)
|
|
|
|
#define DMA_ID_TLB_DSI_FLUSH (((u64)2) << 4)
|
|
|
|
#define DMA_ID_TLB_PSI_FLUSH (((u64)3) << 4)
|
2008-07-10 18:16:42 +00:00
|
|
|
#define DMA_ID_TLB_READ_DRAIN (((u64)1) << 7)
|
|
|
|
#define DMA_ID_TLB_WRITE_DRAIN (((u64)1) << 6)
|
|
|
|
#define DMA_ID_TLB_DID(id) (((u64)((id & 0xffff) << 16)))
|
|
|
|
#define DMA_ID_TLB_IH_NONLEAF (((u64)1) << 6)
|
|
|
|
#define DMA_ID_TLB_ADDR(addr) (addr)
|
|
|
|
#define DMA_ID_TLB_ADDR_MASK(mask) (mask)
|
|
|
|
|
2008-02-08 12:18:38 +00:00
|
|
|
/* PMEN_REG */
|
|
|
|
#define DMA_PMEN_EPM (((u32)1)<<31)
|
|
|
|
#define DMA_PMEN_PRS (((u32)1)<<0)
|
|
|
|
|
2007-10-21 23:41:49 +00:00
|
|
|
/* GCMD_REG */
|
|
|
|
#define DMA_GCMD_TE (((u32)1) << 31)
|
|
|
|
#define DMA_GCMD_SRTP (((u32)1) << 30)
|
|
|
|
#define DMA_GCMD_SFL (((u32)1) << 29)
|
|
|
|
#define DMA_GCMD_EAFL (((u32)1) << 28)
|
|
|
|
#define DMA_GCMD_WBF (((u32)1) << 27)
|
2008-07-10 18:16:43 +00:00
|
|
|
#define DMA_GCMD_QIE (((u32)1) << 26)
|
|
|
|
#define DMA_GCMD_SIRTP (((u32)1) << 24)
|
|
|
|
#define DMA_GCMD_IRE (((u32) 1) << 25)
|
2009-04-03 09:15:47 +00:00
|
|
|
#define DMA_GCMD_CFI (((u32) 1) << 23)
|
2007-10-21 23:41:49 +00:00
|
|
|
|
|
|
|
/* GSTS_REG */
|
|
|
|
#define DMA_GSTS_TES (((u32)1) << 31)
|
|
|
|
#define DMA_GSTS_RTPS (((u32)1) << 30)
|
|
|
|
#define DMA_GSTS_FLS (((u32)1) << 29)
|
|
|
|
#define DMA_GSTS_AFLS (((u32)1) << 28)
|
|
|
|
#define DMA_GSTS_WBFS (((u32)1) << 27)
|
2008-07-10 18:16:43 +00:00
|
|
|
#define DMA_GSTS_QIES (((u32)1) << 26)
|
|
|
|
#define DMA_GSTS_IRTPS (((u32)1) << 24)
|
|
|
|
#define DMA_GSTS_IRES (((u32)1) << 25)
|
2009-04-03 09:15:47 +00:00
|
|
|
#define DMA_GSTS_CFIS (((u32)1) << 23)
|
2007-10-21 23:41:49 +00:00
|
|
|
|
2015-03-25 15:43:39 +00:00
|
|
|
/* DMA_RTADDR_REG */
|
|
|
|
#define DMA_RTADDR_RTT (((u64)1) << 11)
|
2018-12-10 01:59:03 +00:00
|
|
|
#define DMA_RTADDR_SMT (((u64)1) << 10)
|
2015-03-25 15:43:39 +00:00
|
|
|
|
2007-10-21 23:41:49 +00:00
|
|
|
/* CCMD_REG */
|
|
|
|
#define DMA_CCMD_ICC (((u64)1) << 63)
|
|
|
|
#define DMA_CCMD_GLOBAL_INVL (((u64)1) << 61)
|
|
|
|
#define DMA_CCMD_DOMAIN_INVL (((u64)2) << 61)
|
|
|
|
#define DMA_CCMD_DEVICE_INVL (((u64)3) << 61)
|
|
|
|
#define DMA_CCMD_FM(m) (((u64)((m) & 0x3)) << 32)
|
|
|
|
#define DMA_CCMD_MASK_NOBIT 0
|
|
|
|
#define DMA_CCMD_MASK_1BIT 1
|
|
|
|
#define DMA_CCMD_MASK_2BIT 2
|
|
|
|
#define DMA_CCMD_MASK_3BIT 3
|
|
|
|
#define DMA_CCMD_SID(s) (((u64)((s) & 0xffff)) << 16)
|
|
|
|
#define DMA_CCMD_DID(d) ((u64)((d) & 0xffff))
|
|
|
|
|
|
|
|
/* FECTL_REG */
|
|
|
|
#define DMA_FECTL_IM (((u32)1) << 31)
|
|
|
|
|
|
|
|
/* FSTS_REG */
|
2018-02-12 16:48:21 +00:00
|
|
|
#define DMA_FSTS_PFO (1 << 0) /* Primary Fault Overflow */
|
|
|
|
#define DMA_FSTS_PPF (1 << 1) /* Primary Pending Fault */
|
|
|
|
#define DMA_FSTS_IQE (1 << 4) /* Invalidation Queue Error */
|
|
|
|
#define DMA_FSTS_ICE (1 << 5) /* Invalidation Completion Error */
|
|
|
|
#define DMA_FSTS_ITE (1 << 6) /* Invalidation Time-out Error */
|
|
|
|
#define DMA_FSTS_PRO (1 << 7) /* Page Request Overflow */
|
2007-10-21 23:41:49 +00:00
|
|
|
#define dma_fsts_fault_record_index(s) (((s) >> 8) & 0xff)
|
|
|
|
|
|
|
|
/* FRCD_REG, 32 bits access */
|
|
|
|
#define DMA_FRCD_F (((u32)1) << 31)
|
|
|
|
#define dma_frcd_type(d) ((d >> 30) & 1)
|
|
|
|
#define dma_frcd_fault_reason(c) (c & 0xff)
|
|
|
|
#define dma_frcd_source_id(c) (c & 0xffff)
|
2019-09-06 18:14:02 +00:00
|
|
|
#define dma_frcd_pasid_value(c) (((c) >> 8) & 0xfffff)
|
|
|
|
#define dma_frcd_pasid_present(c) (((c) >> 31) & 1)
|
2008-10-17 01:02:32 +00:00
|
|
|
/* low 64 bit */
|
|
|
|
#define dma_frcd_page_addr(d) (d & (((u64)-1) << PAGE_SHIFT))
|
|
|
|
|
2016-02-15 12:42:38 +00:00
|
|
|
/* PRS_REG */
|
|
|
|
#define DMA_PRS_PPR ((u32)1)
|
2020-05-16 06:20:58 +00:00
|
|
|
#define DMA_PRS_PRO ((u32)2)
|
|
|
|
|
2020-05-16 06:20:51 +00:00
|
|
|
#define DMA_VCS_PAS ((u64)1)
|
2016-02-15 12:42:38 +00:00
|
|
|
|
2008-10-17 01:02:32 +00:00
|
|
|
#define IOMMU_WAIT_OP(iommu, offset, op, cond, sts) \
|
|
|
|
do { \
|
|
|
|
cycles_t start_time = get_cycles(); \
|
|
|
|
while (1) { \
|
|
|
|
sts = op(iommu->reg + offset); \
|
|
|
|
if (cond) \
|
|
|
|
break; \
|
2008-07-10 18:16:41 +00:00
|
|
|
if (DMAR_OPERATION_TIMEOUT < (get_cycles() - start_time))\
|
2008-10-17 01:02:32 +00:00
|
|
|
panic("DMAR hardware is malfunctioning\n"); \
|
|
|
|
cpu_relax(); \
|
|
|
|
} \
|
|
|
|
} while (0)
|
2008-07-10 18:16:41 +00:00
|
|
|
|
2008-07-10 18:16:42 +00:00
|
|
|
#define QI_LENGTH 256 /* queue length */
|
|
|
|
|
|
|
|
enum {
|
|
|
|
QI_FREE,
|
|
|
|
QI_IN_USE,
|
2009-05-18 05:51:35 +00:00
|
|
|
QI_DONE,
|
|
|
|
QI_ABORT
|
2008-07-10 18:16:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#define QI_CC_TYPE 0x1
|
|
|
|
#define QI_IOTLB_TYPE 0x2
|
|
|
|
#define QI_DIOTLB_TYPE 0x3
|
|
|
|
#define QI_IEC_TYPE 0x4
|
|
|
|
#define QI_IWD_TYPE 0x5
|
2015-09-09 10:40:47 +00:00
|
|
|
#define QI_EIOTLB_TYPE 0x6
|
|
|
|
#define QI_PC_TYPE 0x7
|
|
|
|
#define QI_DEIOTLB_TYPE 0x8
|
2015-10-07 22:35:18 +00:00
|
|
|
#define QI_PGRP_RESP_TYPE 0x9
|
|
|
|
#define QI_PSTRM_RESP_TYPE 0xa
|
2008-07-10 18:16:42 +00:00
|
|
|
|
|
|
|
#define QI_IEC_SELECTIVE (((u64)1) << 4)
|
|
|
|
#define QI_IEC_IIDEX(idx) (((u64)(idx & 0xffff) << 32))
|
|
|
|
#define QI_IEC_IM(m) (((u64)(m & 0x1f) << 27))
|
|
|
|
|
|
|
|
#define QI_IWD_STATUS_DATA(d) (((u64)d) << 32)
|
|
|
|
#define QI_IWD_STATUS_WRITE (((u64)1) << 5)
|
2020-05-16 06:20:58 +00:00
|
|
|
#define QI_IWD_FENCE (((u64)1) << 6)
|
2020-05-16 06:20:55 +00:00
|
|
|
#define QI_IWD_PRQ_DRAIN (((u64)1) << 7)
|
2008-07-10 18:16:42 +00:00
|
|
|
|
2008-10-16 23:31:55 +00:00
|
|
|
#define QI_IOTLB_DID(did) (((u64)did) << 16)
|
|
|
|
#define QI_IOTLB_DR(dr) (((u64)dr) << 7)
|
|
|
|
#define QI_IOTLB_DW(dw) (((u64)dw) << 6)
|
|
|
|
#define QI_IOTLB_GRAN(gran) (((u64)gran) >> (DMA_TLB_FLUSH_GRANU_OFFSET-4))
|
2008-10-17 01:02:32 +00:00
|
|
|
#define QI_IOTLB_ADDR(addr) (((u64)addr) & VTD_PAGE_MASK)
|
2008-10-16 23:31:55 +00:00
|
|
|
#define QI_IOTLB_IH(ih) (((u64)ih) << 6)
|
2020-05-16 06:20:48 +00:00
|
|
|
#define QI_IOTLB_AM(am) (((u8)am) & 0x3f)
|
2008-10-16 23:31:55 +00:00
|
|
|
|
|
|
|
#define QI_CC_FM(fm) (((u64)fm) << 48)
|
|
|
|
#define QI_CC_SID(sid) (((u64)sid) << 32)
|
|
|
|
#define QI_CC_DID(did) (((u64)did) << 16)
|
|
|
|
#define QI_CC_GRAN(gran) (((u64)gran) >> (DMA_CCMD_INVL_GRANU_OFFSET-4))
|
|
|
|
|
2009-05-18 05:51:35 +00:00
|
|
|
#define QI_DEV_IOTLB_SID(sid) ((u64)((sid) & 0xffff) << 32)
|
|
|
|
#define QI_DEV_IOTLB_QDEP(qdep) (((qdep) & 0x1f) << 16)
|
|
|
|
#define QI_DEV_IOTLB_ADDR(addr) ((u64)(addr) & VTD_PAGE_MASK)
|
2019-11-08 15:58:03 +00:00
|
|
|
#define QI_DEV_IOTLB_PFSID(pfsid) (((u64)(pfsid & 0xf) << 12) | \
|
|
|
|
((u64)((pfsid >> 4) & 0xfff) << 52))
|
2009-05-18 05:51:35 +00:00
|
|
|
#define QI_DEV_IOTLB_SIZE 1
|
|
|
|
#define QI_DEV_IOTLB_MAX_INVS 32
|
|
|
|
|
2015-09-09 10:40:47 +00:00
|
|
|
#define QI_PC_PASID(pasid) (((u64)pasid) << 32)
|
|
|
|
#define QI_PC_DID(did) (((u64)did) << 16)
|
|
|
|
#define QI_PC_GRAN(gran) (((u64)gran) << 4)
|
|
|
|
|
2020-05-16 06:20:48 +00:00
|
|
|
/* PASID cache invalidation granu */
|
|
|
|
#define QI_PC_ALL_PASIDS 0
|
|
|
|
#define QI_PC_PASID_SEL 1
|
2021-03-20 02:54:13 +00:00
|
|
|
#define QI_PC_GLOBAL 3
|
2015-09-09 10:40:47 +00:00
|
|
|
|
|
|
|
#define QI_EIOTLB_ADDR(addr) ((u64)(addr) & VTD_PAGE_MASK)
|
|
|
|
#define QI_EIOTLB_IH(ih) (((u64)ih) << 6)
|
2020-05-16 06:20:48 +00:00
|
|
|
#define QI_EIOTLB_AM(am) (((u64)am) & 0x3f)
|
2015-09-09 10:40:47 +00:00
|
|
|
#define QI_EIOTLB_PASID(pasid) (((u64)pasid) << 32)
|
|
|
|
#define QI_EIOTLB_DID(did) (((u64)did) << 16)
|
|
|
|
#define QI_EIOTLB_GRAN(gran) (((u64)gran) << 4)
|
|
|
|
|
2020-05-16 06:20:48 +00:00
|
|
|
/* QI Dev-IOTLB inv granu */
|
|
|
|
#define QI_DEV_IOTLB_GRAN_ALL 1
|
|
|
|
#define QI_DEV_IOTLB_GRAN_PASID_SEL 0
|
|
|
|
|
2015-09-09 10:40:47 +00:00
|
|
|
#define QI_DEV_EIOTLB_ADDR(a) ((u64)(a) & VTD_PAGE_MASK)
|
|
|
|
#define QI_DEV_EIOTLB_SIZE (((u64)1) << 11)
|
2020-07-24 01:49:14 +00:00
|
|
|
#define QI_DEV_EIOTLB_PASID(p) ((u64)((p) & 0xfffff) << 32)
|
2017-01-30 17:39:52 +00:00
|
|
|
#define QI_DEV_EIOTLB_SID(sid) ((u64)((sid) & 0xffff) << 16)
|
|
|
|
#define QI_DEV_EIOTLB_QDEP(qd) ((u64)((qd) & 0x1f) << 4)
|
2019-11-08 15:58:03 +00:00
|
|
|
#define QI_DEV_EIOTLB_PFSID(pfsid) (((u64)(pfsid & 0xf) << 12) | \
|
|
|
|
((u64)((pfsid >> 4) & 0xfff) << 52))
|
2015-09-09 10:40:47 +00:00
|
|
|
#define QI_DEV_EIOTLB_MAX_INVS 32
|
|
|
|
|
2019-01-11 05:04:57 +00:00
|
|
|
/* Page group response descriptor QW0 */
|
2015-10-07 22:35:18 +00:00
|
|
|
#define QI_PGRP_PASID_P(p) (((u64)(p)) << 4)
|
2019-01-11 05:04:57 +00:00
|
|
|
#define QI_PGRP_PDP(p) (((u64)(p)) << 5)
|
|
|
|
#define QI_PGRP_RESP_CODE(res) (((u64)(res)) << 12)
|
|
|
|
#define QI_PGRP_DID(rid) (((u64)(rid)) << 16)
|
|
|
|
#define QI_PGRP_PASID(pasid) (((u64)(pasid)) << 32)
|
|
|
|
|
|
|
|
/* Page group response descriptor QW1 */
|
|
|
|
#define QI_PGRP_LPIG(x) (((u64)(x)) << 2)
|
|
|
|
#define QI_PGRP_IDX(idx) (((u64)(idx)) << 3)
|
2015-10-07 22:35:18 +00:00
|
|
|
|
|
|
|
|
|
|
|
#define QI_RESP_SUCCESS 0x0
|
|
|
|
#define QI_RESP_INVALID 0x1
|
|
|
|
#define QI_RESP_FAILURE 0xf
|
|
|
|
|
2015-09-09 10:40:47 +00:00
|
|
|
#define QI_GRAN_NONG_PASID 2
|
|
|
|
#define QI_GRAN_PSI_PASID 3
|
|
|
|
|
2018-12-10 01:58:58 +00:00
|
|
|
#define qi_shift(iommu) (DMAR_IQ_SHIFT + !!ecap_smts((iommu)->ecap))
|
|
|
|
|
2008-07-10 18:16:42 +00:00
|
|
|
struct qi_desc {
|
2018-12-10 01:58:58 +00:00
|
|
|
u64 qw0;
|
|
|
|
u64 qw1;
|
|
|
|
u64 qw2;
|
|
|
|
u64 qw3;
|
2008-07-10 18:16:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct q_inval {
|
2011-07-19 15:02:07 +00:00
|
|
|
raw_spinlock_t q_lock;
|
2018-12-10 01:58:58 +00:00
|
|
|
void *desc; /* invalidation queue */
|
2008-07-10 18:16:42 +00:00
|
|
|
int *desc_status; /* desc status */
|
|
|
|
int free_head; /* first free entry */
|
|
|
|
int free_tail; /* last free entry */
|
|
|
|
int free_cnt;
|
|
|
|
};
|
|
|
|
|
2020-08-26 11:16:59 +00:00
|
|
|
struct dmar_pci_notify_info;
|
|
|
|
|
2011-08-24 00:05:25 +00:00
|
|
|
#ifdef CONFIG_IRQ_REMAP
|
2008-07-10 18:16:43 +00:00
|
|
|
/* 1MB - maximum possible interrupt remapping table size */
|
|
|
|
#define INTR_REMAP_PAGE_ORDER 8
|
|
|
|
#define INTR_REMAP_TABLE_REG_SIZE 0xf
|
2015-06-12 13:00:21 +00:00
|
|
|
#define INTR_REMAP_TABLE_REG_SIZE_MASK 0xf
|
2008-07-10 18:16:43 +00:00
|
|
|
|
2008-07-10 18:16:44 +00:00
|
|
|
#define INTR_REMAP_TABLE_ENTRIES 65536
|
|
|
|
|
2015-04-13 06:11:32 +00:00
|
|
|
struct irq_domain;
|
|
|
|
|
2008-07-10 18:16:43 +00:00
|
|
|
struct ir_table {
|
|
|
|
struct irte *base;
|
2014-01-06 06:18:08 +00:00
|
|
|
unsigned long *bitmap;
|
2008-07-10 18:16:43 +00:00
|
|
|
};
|
2020-08-26 11:16:59 +00:00
|
|
|
|
|
|
|
void intel_irq_remap_add_device(struct dmar_pci_notify_info *info);
|
|
|
|
#else
|
|
|
|
static inline void
|
|
|
|
intel_irq_remap_add_device(struct dmar_pci_notify_info *info) { }
|
2008-07-10 18:16:43 +00:00
|
|
|
#endif
|
|
|
|
|
2008-10-16 23:31:56 +00:00
|
|
|
struct iommu_flush {
|
2009-05-10 16:16:06 +00:00
|
|
|
void (*flush_context)(struct intel_iommu *iommu, u16 did, u16 sid,
|
|
|
|
u8 fm, u64 type);
|
2009-05-10 18:58:49 +00:00
|
|
|
void (*flush_iotlb)(struct intel_iommu *iommu, u16 did, u64 addr,
|
|
|
|
unsigned int size_order, u64 type);
|
2008-10-16 23:31:56 +00:00
|
|
|
};
|
|
|
|
|
2009-03-27 21:22:42 +00:00
|
|
|
enum {
|
|
|
|
SR_DMAR_FECTL_REG,
|
|
|
|
SR_DMAR_FEDATA_REG,
|
|
|
|
SR_DMAR_FEADDR_REG,
|
|
|
|
SR_DMAR_FEUADDR_REG,
|
|
|
|
MAX_SR_DMAR_REGS
|
|
|
|
};
|
|
|
|
|
2015-06-12 08:14:02 +00:00
|
|
|
#define VTD_FLAG_TRANS_PRE_ENABLED (1 << 0)
|
|
|
|
#define VTD_FLAG_IRQ_REMAP_PRE_ENABLED (1 << 1)
|
2020-01-02 00:18:03 +00:00
|
|
|
#define VTD_FLAG_SVM_CAPABLE (1 << 2)
|
2015-06-12 08:14:02 +00:00
|
|
|
|
2019-05-24 23:40:16 +00:00
|
|
|
extern int intel_iommu_sm;
|
2020-01-02 00:18:22 +00:00
|
|
|
extern spinlock_t device_domain_lock;
|
2019-05-24 23:40:16 +00:00
|
|
|
|
|
|
|
#define sm_supported(iommu) (intel_iommu_sm && ecap_smts((iommu)->ecap))
|
|
|
|
#define pasid_supported(iommu) (sm_supported(iommu) && \
|
|
|
|
ecap_pasid((iommu)->ecap))
|
|
|
|
|
2015-03-24 14:54:56 +00:00
|
|
|
struct pasid_entry;
|
|
|
|
struct pasid_state_entry;
|
2015-10-07 22:35:18 +00:00
|
|
|
struct page_req_dsc;
|
2015-03-24 14:54:56 +00:00
|
|
|
|
2018-09-12 00:11:36 +00:00
|
|
|
/*
|
|
|
|
* 0: Present
|
|
|
|
* 1-11: Reserved
|
|
|
|
* 12-63: Context Ptr (12 - (haw-1))
|
|
|
|
* 64-127: Reserved
|
|
|
|
*/
|
|
|
|
struct root_entry {
|
|
|
|
u64 lo;
|
|
|
|
u64 hi;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* low 64 bits:
|
|
|
|
* 0: present
|
|
|
|
* 1: fault processing disable
|
|
|
|
* 2-3: translation type
|
|
|
|
* 12-63: address space root
|
|
|
|
* high 64 bits:
|
|
|
|
* 0-2: address width
|
|
|
|
* 3-6: aval
|
|
|
|
* 8-23: domain id
|
|
|
|
*/
|
|
|
|
struct context_entry {
|
|
|
|
u64 lo;
|
|
|
|
u64 hi;
|
|
|
|
};
|
|
|
|
|
2020-05-16 06:20:46 +00:00
|
|
|
/*
|
|
|
|
* When VT-d works in the scalable mode, it allows DMA translation to
|
|
|
|
* happen through either first level or second level page table. This
|
|
|
|
* bit marks that the DMA translation for the domain goes through the
|
|
|
|
* first level page table, otherwise, it goes through the second level.
|
|
|
|
*/
|
|
|
|
#define DOMAIN_FLAG_USE_FIRST_LEVEL BIT(1)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Domain represents a virtual machine which demands iommu nested
|
|
|
|
* translation mode support.
|
|
|
|
*/
|
|
|
|
#define DOMAIN_FLAG_NESTING_MODE BIT(2)
|
|
|
|
|
2018-07-14 07:46:57 +00:00
|
|
|
struct dmar_domain {
|
|
|
|
int nid; /* node id */
|
|
|
|
|
2021-06-10 02:01:14 +00:00
|
|
|
unsigned int iommu_refcnt[DMAR_UNITS_SUPPORTED];
|
2018-07-14 07:46:57 +00:00
|
|
|
/* Refcount of devices per iommu */
|
|
|
|
|
|
|
|
|
|
|
|
u16 iommu_did[DMAR_UNITS_SUPPORTED];
|
|
|
|
/* Domain ids per IOMMU. Use u16 since
|
|
|
|
* domain ids are 16 bit wide according
|
|
|
|
* to VT-d spec, section 9.3 */
|
|
|
|
|
iommu/vt-d: Use bitfields for DMAR capabilities
IOTLB device presence, iommu coherency and snooping are boolean
capabilities. Use them as bits and keep them adjacent.
Structure layout before the reorg.
$ pahole -C dmar_domain drivers/iommu/intel/dmar.o
struct dmar_domain {
int nid; /* 0 4 */
unsigned int iommu_refcnt[128]; /* 4 512 */
/* --- cacheline 8 boundary (512 bytes) was 4 bytes ago --- */
u16 iommu_did[128]; /* 516 256 */
/* --- cacheline 12 boundary (768 bytes) was 4 bytes ago --- */
bool has_iotlb_device; /* 772 1 */
/* XXX 3 bytes hole, try to pack */
struct list_head devices; /* 776 16 */
struct list_head subdevices; /* 792 16 */
struct iova_domain iovad __attribute__((__aligned__(8)));
/* 808 2320 */
/* --- cacheline 48 boundary (3072 bytes) was 56 bytes ago --- */
struct dma_pte * pgd; /* 3128 8 */
/* --- cacheline 49 boundary (3136 bytes) --- */
int gaw; /* 3136 4 */
int agaw; /* 3140 4 */
int flags; /* 3144 4 */
int iommu_coherency; /* 3148 4 */
int iommu_snooping; /* 3152 4 */
int iommu_count; /* 3156 4 */
int iommu_superpage; /* 3160 4 */
/* XXX 4 bytes hole, try to pack */
u64 max_addr; /* 3168 8 */
u32 default_pasid; /* 3176 4 */
/* XXX 4 bytes hole, try to pack */
struct iommu_domain domain; /* 3184 72 */
/* size: 3256, cachelines: 51, members: 18 */
/* sum members: 3245, holes: 3, sum holes: 11 */
/* forced alignments: 1 */
/* last cacheline: 56 bytes */
} __attribute__((__aligned__(8)));
After arranging it for natural padding and to make flags as u8 bits, it
saves 8 bytes for the struct.
struct dmar_domain {
int nid; /* 0 4 */
unsigned int iommu_refcnt[128]; /* 4 512 */
/* --- cacheline 8 boundary (512 bytes) was 4 bytes ago --- */
u16 iommu_did[128]; /* 516 256 */
/* --- cacheline 12 boundary (768 bytes) was 4 bytes ago --- */
u8 has_iotlb_device:1; /* 772: 0 1 */
u8 iommu_coherency:1; /* 772: 1 1 */
u8 iommu_snooping:1; /* 772: 2 1 */
/* XXX 5 bits hole, try to pack */
/* XXX 3 bytes hole, try to pack */
struct list_head devices; /* 776 16 */
struct list_head subdevices; /* 792 16 */
struct iova_domain iovad __attribute__((__aligned__(8)));
/* 808 2320 */
/* --- cacheline 48 boundary (3072 bytes) was 56 bytes ago --- */
struct dma_pte * pgd; /* 3128 8 */
/* --- cacheline 49 boundary (3136 bytes) --- */
int gaw; /* 3136 4 */
int agaw; /* 3140 4 */
int flags; /* 3144 4 */
int iommu_count; /* 3148 4 */
int iommu_superpage; /* 3152 4 */
/* XXX 4 bytes hole, try to pack */
u64 max_addr; /* 3160 8 */
u32 default_pasid; /* 3168 4 */
/* XXX 4 bytes hole, try to pack */
struct iommu_domain domain; /* 3176 72 */
/* size: 3248, cachelines: 51, members: 18 */
/* sum members: 3236, holes: 3, sum holes: 11 */
/* sum bitfield members: 3 bits, bit holes: 1, sum bit holes: 5 bits */
/* forced alignments: 1 */
/* last cacheline: 48 bytes */
} __attribute__((__aligned__(8)));
Signed-off-by: Parav Pandit <parav@nvidia.com>
Signed-off-by: Lu Baolu <baolu.lu@linux.intel.com>
Link: https://lore.kernel.org/r/20210530075053.264218-1-parav@nvidia.com
Link: https://lore.kernel.org/r/20210610020115.1637656-20-baolu.lu@linux.intel.com
Signed-off-by: Joerg Roedel <jroedel@suse.de>
2021-06-10 02:01:11 +00:00
|
|
|
u8 has_iotlb_device: 1;
|
|
|
|
u8 iommu_coherency: 1; /* indicate coherency of iommu access */
|
|
|
|
u8 iommu_snooping: 1; /* indicate snooping control feature */
|
|
|
|
|
2018-07-14 07:46:57 +00:00
|
|
|
struct list_head devices; /* all devices' list */
|
2021-01-06 16:03:56 +00:00
|
|
|
struct list_head subdevices; /* all subdevices' list */
|
2018-07-14 07:46:57 +00:00
|
|
|
struct iova_domain iovad; /* iova's that belong to this domain */
|
|
|
|
|
|
|
|
struct dma_pte *pgd; /* virtual address */
|
|
|
|
int gaw; /* max guest address width */
|
|
|
|
|
|
|
|
/* adjusted guest address width, 0 is level 2 30-bit */
|
|
|
|
int agaw;
|
|
|
|
|
|
|
|
int flags; /* flags to find out type of domain */
|
|
|
|
int iommu_superpage;/* Level of superpages supported:
|
|
|
|
0 == 4KiB (no superpages), 1 == 2MiB,
|
|
|
|
2 == 1GiB, 3 == 512GiB, 4 == 1TiB */
|
|
|
|
u64 max_addr; /* maximum mapped address */
|
|
|
|
|
2020-09-15 16:30:05 +00:00
|
|
|
u32 default_pasid; /*
|
2019-03-25 01:30:32 +00:00
|
|
|
* The default pasid used for non-SVM
|
|
|
|
* traffic on mediated devices.
|
|
|
|
*/
|
|
|
|
|
2018-07-14 07:46:57 +00:00
|
|
|
struct iommu_domain domain; /* generic domain data structure for
|
|
|
|
iommu core */
|
|
|
|
};
|
|
|
|
|
2007-10-21 23:41:49 +00:00
|
|
|
struct intel_iommu {
|
|
|
|
void __iomem *reg; /* Pointer to hardware regs, virtual addr */
|
2012-06-04 21:29:02 +00:00
|
|
|
u64 reg_phys; /* physical address of hw register set */
|
|
|
|
u64 reg_size; /* size of hw register set */
|
2007-10-21 23:41:49 +00:00
|
|
|
u64 cap;
|
|
|
|
u64 ecap;
|
2020-05-16 06:20:51 +00:00
|
|
|
u64 vccap;
|
2007-10-21 23:41:49 +00:00
|
|
|
u32 gcmd; /* Holds TE, EAFL. Don't need SRTP, SFL, WBF */
|
2011-07-19 14:19:51 +00:00
|
|
|
raw_spinlock_t register_lock; /* protect register handling */
|
2008-07-10 18:16:36 +00:00
|
|
|
int seq_id; /* sequence id of the iommu */
|
2008-12-08 07:34:06 +00:00
|
|
|
int agaw; /* agaw of this iommu */
|
2009-04-25 00:30:20 +00:00
|
|
|
int msagaw; /* max sagaw of this iommu */
|
2015-10-07 14:37:03 +00:00
|
|
|
unsigned int irq, pr_irq;
|
2014-03-09 20:49:45 +00:00
|
|
|
u16 segment; /* PCI segment# */
|
2009-03-17 00:04:55 +00:00
|
|
|
unsigned char name[13]; /* Device Name */
|
2008-07-10 18:16:35 +00:00
|
|
|
|
2011-08-24 00:05:25 +00:00
|
|
|
#ifdef CONFIG_INTEL_IOMMU
|
2008-07-10 18:16:35 +00:00
|
|
|
unsigned long *domain_ids; /* bitmap of domains */
|
2015-07-21 08:41:21 +00:00
|
|
|
struct dmar_domain ***domains; /* ptr to domains */
|
2008-07-10 18:16:35 +00:00
|
|
|
spinlock_t lock; /* protect context, domain ids */
|
2007-10-21 23:41:49 +00:00
|
|
|
struct root_entry *root_entry; /* virtual address */
|
|
|
|
|
2008-10-16 23:31:56 +00:00
|
|
|
struct iommu_flush flush;
|
2015-03-24 14:54:56 +00:00
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_INTEL_IOMMU_SVM
|
2015-10-07 22:35:18 +00:00
|
|
|
struct page_req_dsc *prq;
|
|
|
|
unsigned char prq_name[16]; /* Name for PRQ interrupt */
|
2020-05-16 06:20:58 +00:00
|
|
|
struct completion prq_complete;
|
2020-05-16 06:20:51 +00:00
|
|
|
struct ioasid_allocator_ops pasid_allocator; /* Custom allocator for PASIDs */
|
2008-07-10 18:16:35 +00:00
|
|
|
#endif
|
2021-06-10 02:01:02 +00:00
|
|
|
struct iopf_queue *iopf_queue;
|
|
|
|
unsigned char iopfq_name[16];
|
2008-07-10 18:16:42 +00:00
|
|
|
struct q_inval *qi; /* Queued invalidation info */
|
2009-03-27 21:22:42 +00:00
|
|
|
u32 *iommu_state; /* Store iommu states between suspend and resume.*/
|
|
|
|
|
2011-08-24 00:05:25 +00:00
|
|
|
#ifdef CONFIG_IRQ_REMAP
|
2008-07-10 18:16:43 +00:00
|
|
|
struct ir_table *ir_table; /* Interrupt remapping info */
|
2015-04-13 06:11:32 +00:00
|
|
|
struct irq_domain *ir_domain;
|
|
|
|
struct irq_domain *ir_msi_domain;
|
2008-07-10 18:16:43 +00:00
|
|
|
#endif
|
2017-02-01 12:23:08 +00:00
|
|
|
struct iommu_device iommu; /* IOMMU core code handle */
|
2009-10-02 18:01:21 +00:00
|
|
|
int node;
|
2015-06-12 08:14:02 +00:00
|
|
|
u32 flags; /* Software defined flags */
|
2020-07-23 01:34:37 +00:00
|
|
|
|
|
|
|
struct dmar_drhd_unit *drhd;
|
2021-06-10 02:01:05 +00:00
|
|
|
void *perf_statistic;
|
2007-10-21 23:41:49 +00:00
|
|
|
};
|
|
|
|
|
2021-01-06 16:03:56 +00:00
|
|
|
/* Per subdevice private data */
|
|
|
|
struct subdev_domain_info {
|
|
|
|
struct list_head link_phys; /* link to phys device siblings */
|
|
|
|
struct list_head link_domain; /* link to domain siblings */
|
|
|
|
struct device *pdev; /* physical device derived from */
|
|
|
|
struct dmar_domain *domain; /* aux-domain */
|
|
|
|
int users; /* user count */
|
|
|
|
};
|
|
|
|
|
2018-07-14 07:46:57 +00:00
|
|
|
/* PCI domain-device relationship */
|
|
|
|
struct device_domain_info {
|
|
|
|
struct list_head link; /* link to domain siblings */
|
|
|
|
struct list_head global; /* link to global list */
|
2018-07-14 07:46:59 +00:00
|
|
|
struct list_head table; /* link to pasid table */
|
2021-01-06 16:03:56 +00:00
|
|
|
struct list_head subdevices; /* subdevices sibling */
|
2020-05-27 16:56:16 +00:00
|
|
|
u32 segment; /* PCI segment number */
|
2018-07-14 07:46:57 +00:00
|
|
|
u8 bus; /* PCI bus number */
|
|
|
|
u8 devfn; /* PCI devfn number */
|
|
|
|
u16 pfsid; /* SRIOV physical function source ID */
|
|
|
|
u8 pasid_supported:3;
|
|
|
|
u8 pasid_enabled:1;
|
|
|
|
u8 pri_supported:1;
|
|
|
|
u8 pri_enabled:1;
|
|
|
|
u8 ats_supported:1;
|
|
|
|
u8 ats_enabled:1;
|
2019-03-25 01:30:30 +00:00
|
|
|
u8 auxd_enabled:1; /* Multiple domains per device */
|
2018-07-14 07:46:57 +00:00
|
|
|
u8 ats_qdep;
|
|
|
|
struct device *dev; /* it's NULL for PCIe-to-PCI bridge */
|
|
|
|
struct intel_iommu *iommu; /* IOMMU used by this device */
|
|
|
|
struct dmar_domain *domain; /* pointer to domain */
|
2018-07-14 07:46:59 +00:00
|
|
|
struct pasid_table *pasid_table; /* pasid table */
|
2018-07-14 07:46:57 +00:00
|
|
|
};
|
|
|
|
|
2008-07-10 18:16:42 +00:00
|
|
|
static inline void __iommu_flush_cache(
|
|
|
|
struct intel_iommu *iommu, void *addr, int size)
|
|
|
|
{
|
|
|
|
if (!ecap_coherent(iommu->ecap))
|
|
|
|
clflush_cache_range(addr, size);
|
|
|
|
}
|
|
|
|
|
2020-05-16 06:20:44 +00:00
|
|
|
/* Convert generic struct iommu_domain to private struct dmar_domain */
|
|
|
|
static inline struct dmar_domain *to_dmar_domain(struct iommu_domain *dom)
|
|
|
|
{
|
|
|
|
return container_of(dom, struct dmar_domain, domain);
|
|
|
|
}
|
|
|
|
|
2018-12-10 01:58:57 +00:00
|
|
|
/*
|
|
|
|
* 0: readable
|
|
|
|
* 1: writable
|
|
|
|
* 2-6: reserved
|
|
|
|
* 7: super page
|
|
|
|
* 8-10: available
|
|
|
|
* 11: snoop behavior
|
2021-02-04 01:43:55 +00:00
|
|
|
* 12-63: Host physical address
|
2018-12-10 01:58:57 +00:00
|
|
|
*/
|
|
|
|
struct dma_pte {
|
|
|
|
u64 val;
|
|
|
|
};
|
|
|
|
|
|
|
|
static inline void dma_clear_pte(struct dma_pte *pte)
|
|
|
|
{
|
|
|
|
pte->val = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u64 dma_pte_addr(struct dma_pte *pte)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_64BIT
|
2020-01-02 00:18:17 +00:00
|
|
|
return pte->val & VTD_PAGE_MASK & (~DMA_FL_PTE_XD);
|
2018-12-10 01:58:57 +00:00
|
|
|
#else
|
|
|
|
/* Must have a full atomic 64-bit read */
|
2020-01-02 00:18:17 +00:00
|
|
|
return __cmpxchg64(&pte->val, 0ULL, 0ULL) &
|
|
|
|
VTD_PAGE_MASK & (~DMA_FL_PTE_XD);
|
2018-12-10 01:58:57 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool dma_pte_present(struct dma_pte *pte)
|
|
|
|
{
|
|
|
|
return (pte->val & 3) != 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool dma_pte_superpage(struct dma_pte *pte)
|
|
|
|
{
|
|
|
|
return (pte->val & DMA_PTE_LARGE_PAGE);
|
|
|
|
}
|
|
|
|
|
2021-10-14 05:38:38 +00:00
|
|
|
static inline bool first_pte_in_page(struct dma_pte *pte)
|
2018-12-10 01:58:57 +00:00
|
|
|
{
|
2021-10-14 05:38:38 +00:00
|
|
|
return IS_ALIGNED((unsigned long)pte, VTD_PAGE_SIZE);
|
2018-12-10 01:58:57 +00:00
|
|
|
}
|
|
|
|
|
iommu/vt-d: Avoid duplicate removing in __domain_mapping()
The __domain_mapping() always removes the pages in the range from
'iov_pfn' to 'end_pfn', but the 'end_pfn' is always the last pfn
of the range that the caller wants to map.
This would introduce too many duplicated removing and leads the
map operation take too long, for example:
Map iova=0x100000,nr_pages=0x7d61800
iov_pfn: 0x100000, end_pfn: 0x7e617ff
iov_pfn: 0x140000, end_pfn: 0x7e617ff
iov_pfn: 0x180000, end_pfn: 0x7e617ff
iov_pfn: 0x1c0000, end_pfn: 0x7e617ff
iov_pfn: 0x200000, end_pfn: 0x7e617ff
...
it takes about 50ms in total.
We can reduce the cost by recalculate the 'end_pfn' and limit it
to the boundary of the end of this pte page.
Map iova=0x100000,nr_pages=0x7d61800
iov_pfn: 0x100000, end_pfn: 0x13ffff
iov_pfn: 0x140000, end_pfn: 0x17ffff
iov_pfn: 0x180000, end_pfn: 0x1bffff
iov_pfn: 0x1c0000, end_pfn: 0x1fffff
iov_pfn: 0x200000, end_pfn: 0x23ffff
...
it only need 9ms now.
This also removes a meaningless BUG_ON() in __domain_mapping().
Signed-off-by: Longpeng(Mike) <longpeng2@huawei.com>
Tested-by: Liujunjie <liujunjie23@huawei.com>
Link: https://lore.kernel.org/r/20211008000433.1115-1-longpeng2@huawei.com
Signed-off-by: Lu Baolu <baolu.lu@linux.intel.com>
Link: https://lore.kernel.org/r/20211014053839.727419-10-baolu.lu@linux.intel.com
Signed-off-by: Joerg Roedel <jroedel@suse.de>
2021-10-14 05:38:39 +00:00
|
|
|
static inline int nr_pte_to_next_page(struct dma_pte *pte)
|
|
|
|
{
|
|
|
|
return first_pte_in_page(pte) ? BIT_ULL(VTD_STRIDE_SHIFT) :
|
|
|
|
(struct dma_pte *)ALIGN((unsigned long)pte, VTD_PAGE_SIZE) - pte;
|
|
|
|
}
|
|
|
|
|
2008-07-10 18:16:35 +00:00
|
|
|
extern struct dmar_drhd_unit * dmar_find_matched_drhd_unit(struct pci_dev *dev);
|
2009-05-18 05:51:34 +00:00
|
|
|
extern int dmar_find_matched_atsr_unit(struct pci_dev *dev);
|
2008-07-10 18:16:35 +00:00
|
|
|
|
2008-07-10 18:16:43 +00:00
|
|
|
extern int dmar_enable_qi(struct intel_iommu *iommu);
|
2009-03-17 00:04:56 +00:00
|
|
|
extern void dmar_disable_qi(struct intel_iommu *iommu);
|
2009-03-27 21:22:42 +00:00
|
|
|
extern int dmar_reenable_qi(struct intel_iommu *iommu);
|
2008-07-10 18:16:43 +00:00
|
|
|
extern void qi_global_iec(struct intel_iommu *iommu);
|
2007-10-21 23:41:55 +00:00
|
|
|
|
2009-05-10 16:16:06 +00:00
|
|
|
extern void qi_flush_context(struct intel_iommu *iommu, u16 did, u16 sid,
|
|
|
|
u8 fm, u64 type);
|
2009-05-10 18:58:49 +00:00
|
|
|
extern void qi_flush_iotlb(struct intel_iommu *iommu, u16 did, u64 addr,
|
|
|
|
unsigned int size_order, u64 type);
|
2018-06-07 16:57:00 +00:00
|
|
|
extern void qi_flush_dev_iotlb(struct intel_iommu *iommu, u16 sid, u16 pfsid,
|
|
|
|
u16 qdep, u64 addr, unsigned mask);
|
2020-05-16 06:20:48 +00:00
|
|
|
|
2020-01-02 00:18:18 +00:00
|
|
|
void qi_flush_piotlb(struct intel_iommu *iommu, u16 did, u32 pasid, u64 addr,
|
|
|
|
unsigned long npages, bool ih);
|
2020-05-16 06:20:48 +00:00
|
|
|
|
|
|
|
void qi_flush_dev_iotlb_pasid(struct intel_iommu *iommu, u16 sid, u16 pfsid,
|
|
|
|
u32 pasid, u16 qdep, u64 addr,
|
2020-07-24 01:49:15 +00:00
|
|
|
unsigned int size_order);
|
2020-05-16 06:20:48 +00:00
|
|
|
void qi_flush_pasid_cache(struct intel_iommu *iommu, u16 did, u64 granu,
|
2020-09-15 16:30:05 +00:00
|
|
|
u32 pasid);
|
2020-05-16 06:20:48 +00:00
|
|
|
|
2020-05-16 06:20:55 +00:00
|
|
|
int qi_submit_sync(struct intel_iommu *iommu, struct qi_desc *desc,
|
|
|
|
unsigned int count, unsigned long options);
|
|
|
|
/*
|
|
|
|
* Options used in qi_submit_sync:
|
|
|
|
* QI_OPT_WAIT_DRAIN - Wait for PRQ drain completion, spec 6.5.2.8.
|
|
|
|
*/
|
|
|
|
#define QI_OPT_WAIT_DRAIN BIT(0)
|
2008-09-09 15:37:29 +00:00
|
|
|
|
2009-09-09 16:05:39 +00:00
|
|
|
extern int dmar_ir_support(void);
|
|
|
|
|
2018-07-14 07:46:57 +00:00
|
|
|
void *alloc_pgtable_page(int node);
|
|
|
|
void free_pgtable_page(void *vaddr);
|
|
|
|
struct intel_iommu *domain_get_iommu(struct dmar_domain *domain);
|
2018-07-14 07:46:58 +00:00
|
|
|
int for_each_device_domain(int (*fn)(struct device_domain_info *info,
|
|
|
|
void *data), void *data);
|
2018-12-10 01:59:00 +00:00
|
|
|
void iommu_flush_write_buffer(struct intel_iommu *iommu);
|
2019-03-25 01:30:29 +00:00
|
|
|
int intel_iommu_enable_pasid(struct intel_iommu *iommu, struct device *dev);
|
2020-01-02 00:18:22 +00:00
|
|
|
struct dmar_domain *find_domain(struct device *dev);
|
2020-05-16 06:20:52 +00:00
|
|
|
struct device_domain_info *get_domain_info(struct device *dev);
|
2020-07-24 01:49:21 +00:00
|
|
|
struct intel_iommu *device_to_iommu(struct device *dev, u8 *bus, u8 *devfn);
|
2018-07-14 07:46:57 +00:00
|
|
|
|
2015-09-09 10:40:47 +00:00
|
|
|
#ifdef CONFIG_INTEL_IOMMU_SVM
|
2020-01-02 00:18:03 +00:00
|
|
|
extern void intel_svm_check(struct intel_iommu *iommu);
|
2015-10-07 22:35:18 +00:00
|
|
|
extern int intel_svm_enable_prq(struct intel_iommu *iommu);
|
|
|
|
extern int intel_svm_finish_prq(struct intel_iommu *iommu);
|
2020-05-16 06:20:47 +00:00
|
|
|
int intel_svm_bind_gpasid(struct iommu_domain *domain, struct device *dev,
|
|
|
|
struct iommu_gpasid_bind_data *data);
|
2020-09-15 16:30:05 +00:00
|
|
|
int intel_svm_unbind_gpasid(struct device *dev, u32 pasid);
|
2020-05-16 06:20:54 +00:00
|
|
|
struct iommu_sva *intel_svm_bind(struct device *dev, struct mm_struct *mm,
|
|
|
|
void *drvdata);
|
|
|
|
void intel_svm_unbind(struct iommu_sva *handle);
|
2020-09-15 16:30:05 +00:00
|
|
|
u32 intel_svm_get_pasid(struct iommu_sva *handle);
|
2020-07-24 01:49:24 +00:00
|
|
|
int intel_svm_page_response(struct device *dev, struct iommu_fault_event *evt,
|
|
|
|
struct iommu_page_response *msg);
|
|
|
|
|
2015-09-09 10:40:47 +00:00
|
|
|
struct intel_svm_dev {
|
|
|
|
struct list_head list;
|
|
|
|
struct rcu_head rcu;
|
|
|
|
struct device *dev;
|
2021-01-06 16:03:55 +00:00
|
|
|
struct intel_iommu *iommu;
|
2020-05-16 06:20:54 +00:00
|
|
|
struct iommu_sva sva;
|
2021-06-10 02:01:04 +00:00
|
|
|
unsigned long prq_seq_number;
|
2020-09-15 16:30:05 +00:00
|
|
|
u32 pasid;
|
2015-09-09 10:40:47 +00:00
|
|
|
int users;
|
|
|
|
u16 did;
|
|
|
|
u16 dev_iotlb:1;
|
|
|
|
u16 sid, qdep;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct intel_svm {
|
|
|
|
struct mmu_notifier notifier;
|
|
|
|
struct mm_struct *mm;
|
2020-05-16 06:20:47 +00:00
|
|
|
|
2020-09-15 16:30:06 +00:00
|
|
|
unsigned int flags;
|
2020-09-15 16:30:05 +00:00
|
|
|
u32 pasid;
|
2020-05-16 06:20:47 +00:00
|
|
|
int gpasid; /* In case that guest PASID is different from host PASID */
|
2015-09-09 10:40:47 +00:00
|
|
|
struct list_head devs;
|
|
|
|
};
|
2020-01-02 00:18:03 +00:00
|
|
|
#else
|
|
|
|
static inline void intel_svm_check(struct intel_iommu *iommu) {}
|
2015-09-09 10:40:47 +00:00
|
|
|
#endif
|
|
|
|
|
2018-09-12 00:11:38 +00:00
|
|
|
#ifdef CONFIG_INTEL_IOMMU_DEBUGFS
|
|
|
|
void intel_iommu_debugfs_init(void);
|
|
|
|
#else
|
|
|
|
static inline void intel_iommu_debugfs_init(void) {}
|
|
|
|
#endif /* CONFIG_INTEL_IOMMU_DEBUGFS */
|
|
|
|
|
iommu/vt-d: Make use of IOMMU sysfs support
Register our DRHD IOMMUs, cross link devices, and provide a base set
of attributes for the IOMMU. Note that IRQ remapping support parses
the DMAR table very early in boot, well before the iommu_class can
reasonably be setup, so our registration is split between
intel_iommu_init(), which occurs later, and alloc_iommu(), which
typically occurs much earlier, but may happen at any time later
with IOMMU hot-add support.
On a typical desktop system, this provides the following (pruned):
$ find /sys | grep dmar
/sys/devices/virtual/iommu/dmar0
/sys/devices/virtual/iommu/dmar0/devices
/sys/devices/virtual/iommu/dmar0/devices/0000:00:02.0
/sys/devices/virtual/iommu/dmar0/intel-iommu
/sys/devices/virtual/iommu/dmar0/intel-iommu/cap
/sys/devices/virtual/iommu/dmar0/intel-iommu/ecap
/sys/devices/virtual/iommu/dmar0/intel-iommu/address
/sys/devices/virtual/iommu/dmar0/intel-iommu/version
/sys/devices/virtual/iommu/dmar1
/sys/devices/virtual/iommu/dmar1/devices
/sys/devices/virtual/iommu/dmar1/devices/0000:00:00.0
/sys/devices/virtual/iommu/dmar1/devices/0000:00:01.0
/sys/devices/virtual/iommu/dmar1/devices/0000:00:16.0
/sys/devices/virtual/iommu/dmar1/devices/0000:00:1a.0
/sys/devices/virtual/iommu/dmar1/devices/0000:00:1b.0
/sys/devices/virtual/iommu/dmar1/devices/0000:00:1c.0
...
/sys/devices/virtual/iommu/dmar1/intel-iommu
/sys/devices/virtual/iommu/dmar1/intel-iommu/cap
/sys/devices/virtual/iommu/dmar1/intel-iommu/ecap
/sys/devices/virtual/iommu/dmar1/intel-iommu/address
/sys/devices/virtual/iommu/dmar1/intel-iommu/version
/sys/class/iommu/dmar0
/sys/class/iommu/dmar1
(devices also link back to the dmar units)
This makes address, version, capabilities, and extended capabilities
available, just like printed on boot. I've tried not to duplicate
data that can be found in the DMAR table, with the exception of the
address, which provides an easy way to associate the sysfs device with
a DRHD entry in the DMAR. It's tempting to add scopes and RMRR data
here, but the full DMAR table is already exposed under /sys/firmware/
and therefore already provides a way for userspace to learn such
details.
Signed-off-by: Alex Williamson <alex.williamson@redhat.com>
Signed-off-by: Joerg Roedel <jroedel@suse.de>
2014-06-12 22:12:31 +00:00
|
|
|
extern const struct attribute_group *intel_iommu_groups[];
|
2018-09-12 00:11:36 +00:00
|
|
|
bool context_present(struct context_entry *context);
|
|
|
|
struct context_entry *iommu_context_addr(struct intel_iommu *iommu, u8 bus,
|
|
|
|
u8 devfn, int alloc);
|
iommu/vt-d: Make use of IOMMU sysfs support
Register our DRHD IOMMUs, cross link devices, and provide a base set
of attributes for the IOMMU. Note that IRQ remapping support parses
the DMAR table very early in boot, well before the iommu_class can
reasonably be setup, so our registration is split between
intel_iommu_init(), which occurs later, and alloc_iommu(), which
typically occurs much earlier, but may happen at any time later
with IOMMU hot-add support.
On a typical desktop system, this provides the following (pruned):
$ find /sys | grep dmar
/sys/devices/virtual/iommu/dmar0
/sys/devices/virtual/iommu/dmar0/devices
/sys/devices/virtual/iommu/dmar0/devices/0000:00:02.0
/sys/devices/virtual/iommu/dmar0/intel-iommu
/sys/devices/virtual/iommu/dmar0/intel-iommu/cap
/sys/devices/virtual/iommu/dmar0/intel-iommu/ecap
/sys/devices/virtual/iommu/dmar0/intel-iommu/address
/sys/devices/virtual/iommu/dmar0/intel-iommu/version
/sys/devices/virtual/iommu/dmar1
/sys/devices/virtual/iommu/dmar1/devices
/sys/devices/virtual/iommu/dmar1/devices/0000:00:00.0
/sys/devices/virtual/iommu/dmar1/devices/0000:00:01.0
/sys/devices/virtual/iommu/dmar1/devices/0000:00:16.0
/sys/devices/virtual/iommu/dmar1/devices/0000:00:1a.0
/sys/devices/virtual/iommu/dmar1/devices/0000:00:1b.0
/sys/devices/virtual/iommu/dmar1/devices/0000:00:1c.0
...
/sys/devices/virtual/iommu/dmar1/intel-iommu
/sys/devices/virtual/iommu/dmar1/intel-iommu/cap
/sys/devices/virtual/iommu/dmar1/intel-iommu/ecap
/sys/devices/virtual/iommu/dmar1/intel-iommu/address
/sys/devices/virtual/iommu/dmar1/intel-iommu/version
/sys/class/iommu/dmar0
/sys/class/iommu/dmar1
(devices also link back to the dmar units)
This makes address, version, capabilities, and extended capabilities
available, just like printed on boot. I've tried not to duplicate
data that can be found in the DMAR table, with the exception of the
address, which provides an easy way to associate the sysfs device with
a DRHD entry in the DMAR. It's tempting to add scopes and RMRR data
here, but the full DMAR table is already exposed under /sys/firmware/
and therefore already provides a way for userspace to learn such
details.
Signed-off-by: Alex Williamson <alex.williamson@redhat.com>
Signed-off-by: Joerg Roedel <jroedel@suse.de>
2014-06-12 22:12:31 +00:00
|
|
|
|
2018-11-12 06:40:08 +00:00
|
|
|
#ifdef CONFIG_INTEL_IOMMU
|
|
|
|
extern int iommu_calculate_agaw(struct intel_iommu *iommu);
|
|
|
|
extern int iommu_calculate_max_sagaw(struct intel_iommu *iommu);
|
|
|
|
extern int dmar_disabled;
|
|
|
|
extern int intel_iommu_enabled;
|
2020-08-28 16:12:11 +00:00
|
|
|
extern int intel_iommu_gfx_mapped;
|
2018-11-12 06:40:08 +00:00
|
|
|
#else
|
|
|
|
static inline int iommu_calculate_agaw(struct intel_iommu *iommu)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
static inline int iommu_calculate_max_sagaw(struct intel_iommu *iommu)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#define dmar_disabled (1)
|
|
|
|
#define intel_iommu_enabled (0)
|
|
|
|
#endif
|
|
|
|
|
2021-06-10 02:01:04 +00:00
|
|
|
static inline const char *decode_prq_descriptor(char *str, size_t size,
|
|
|
|
u64 dw0, u64 dw1, u64 dw2, u64 dw3)
|
|
|
|
{
|
|
|
|
char *buf = str;
|
|
|
|
int bytes;
|
|
|
|
|
|
|
|
bytes = snprintf(buf, size,
|
|
|
|
"rid=0x%llx addr=0x%llx %c%c%c%c%c pasid=0x%llx index=0x%llx",
|
|
|
|
FIELD_GET(GENMASK_ULL(31, 16), dw0),
|
|
|
|
FIELD_GET(GENMASK_ULL(63, 12), dw1),
|
|
|
|
dw1 & BIT_ULL(0) ? 'r' : '-',
|
|
|
|
dw1 & BIT_ULL(1) ? 'w' : '-',
|
|
|
|
dw0 & BIT_ULL(52) ? 'x' : '-',
|
|
|
|
dw0 & BIT_ULL(53) ? 'p' : '-',
|
|
|
|
dw1 & BIT_ULL(2) ? 'l' : '-',
|
|
|
|
FIELD_GET(GENMASK_ULL(51, 32), dw0),
|
|
|
|
FIELD_GET(GENMASK_ULL(11, 3), dw1));
|
|
|
|
|
|
|
|
/* Private Data */
|
|
|
|
if (dw0 & BIT_ULL(9)) {
|
|
|
|
size -= bytes;
|
|
|
|
buf += bytes;
|
|
|
|
snprintf(buf, size, " private=0x%llx/0x%llx\n", dw2, dw3);
|
|
|
|
}
|
|
|
|
|
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
2007-10-21 23:41:49 +00:00
|
|
|
#endif
|