1263b2ba5SJacek Lawrynowicz // SPDX-License-Identifier: GPL-2.0-only 2263b2ba5SJacek Lawrynowicz /* 3263b2ba5SJacek Lawrynowicz * Copyright (C) 2020-2023 Intel Corporation 4263b2ba5SJacek Lawrynowicz */ 5263b2ba5SJacek Lawrynowicz 6263b2ba5SJacek Lawrynowicz #include <linux/circ_buf.h> 7263b2ba5SJacek Lawrynowicz #include <linux/highmem.h> 8263b2ba5SJacek Lawrynowicz 9263b2ba5SJacek Lawrynowicz #include "ivpu_drv.h" 10263b2ba5SJacek Lawrynowicz #include "ivpu_hw_mtl_reg.h" 11263b2ba5SJacek Lawrynowicz #include "ivpu_hw_reg_io.h" 12263b2ba5SJacek Lawrynowicz #include "ivpu_mmu.h" 13263b2ba5SJacek Lawrynowicz #include "ivpu_mmu_context.h" 14*852be13fSJacek Lawrynowicz #include "ivpu_pm.h" 15263b2ba5SJacek Lawrynowicz 16263b2ba5SJacek Lawrynowicz #define IVPU_MMU_IDR0_REF 0x080f3e0f 17263b2ba5SJacek Lawrynowicz #define IVPU_MMU_IDR0_REF_SIMICS 0x080f3e1f 18263b2ba5SJacek Lawrynowicz #define IVPU_MMU_IDR1_REF 0x0e739d18 19263b2ba5SJacek Lawrynowicz #define IVPU_MMU_IDR3_REF 0x0000003c 20263b2ba5SJacek Lawrynowicz #define IVPU_MMU_IDR5_REF 0x00040070 21263b2ba5SJacek Lawrynowicz #define IVPU_MMU_IDR5_REF_SIMICS 0x00000075 22263b2ba5SJacek Lawrynowicz #define IVPU_MMU_IDR5_REF_FPGA 0x00800075 23263b2ba5SJacek Lawrynowicz 24263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CDTAB_ENT_SIZE 64 25263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CDTAB_ENT_COUNT_LOG2 8 /* 256 entries */ 26263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CDTAB_ENT_COUNT ((u32)1 << IVPU_MMU_CDTAB_ENT_COUNT_LOG2) 27263b2ba5SJacek Lawrynowicz 28263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STREAM_ID0 0 29263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STREAM_ID3 3 30263b2ba5SJacek Lawrynowicz 31263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STRTAB_ENT_SIZE 64 32263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STRTAB_ENT_COUNT 4 33263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STRTAB_CFG_LOG2SIZE 2 34263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STRTAB_CFG IVPU_MMU_STRTAB_CFG_LOG2SIZE 35263b2ba5SJacek Lawrynowicz 36263b2ba5SJacek Lawrynowicz #define IVPU_MMU_Q_COUNT_LOG2 4 /* 16 entries */ 37263b2ba5SJacek Lawrynowicz #define IVPU_MMU_Q_COUNT ((u32)1 << IVPU_MMU_Q_COUNT_LOG2) 38263b2ba5SJacek Lawrynowicz #define IVPU_MMU_Q_WRAP_BIT (IVPU_MMU_Q_COUNT << 1) 39263b2ba5SJacek Lawrynowicz #define IVPU_MMU_Q_WRAP_MASK (IVPU_MMU_Q_WRAP_BIT - 1) 40263b2ba5SJacek Lawrynowicz #define IVPU_MMU_Q_IDX_MASK (IVPU_MMU_Q_COUNT - 1) 41263b2ba5SJacek Lawrynowicz #define IVPU_MMU_Q_IDX(val) ((val) & IVPU_MMU_Q_IDX_MASK) 42263b2ba5SJacek Lawrynowicz 43263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CMDQ_CMD_SIZE 16 44263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CMDQ_SIZE (IVPU_MMU_Q_COUNT * IVPU_MMU_CMDQ_CMD_SIZE) 45263b2ba5SJacek Lawrynowicz 46263b2ba5SJacek Lawrynowicz #define IVPU_MMU_EVTQ_CMD_SIZE 32 47263b2ba5SJacek Lawrynowicz #define IVPU_MMU_EVTQ_SIZE (IVPU_MMU_Q_COUNT * IVPU_MMU_EVTQ_CMD_SIZE) 48263b2ba5SJacek Lawrynowicz 49263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CMD_OPCODE GENMASK(7, 0) 50263b2ba5SJacek Lawrynowicz 51263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CMD_SYNC_0_CS GENMASK(13, 12) 52263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CMD_SYNC_0_MSH GENMASK(23, 22) 53263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CMD_SYNC_0_MSI_ATTR GENMASK(27, 24) 54263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CMD_SYNC_0_MSI_ATTR GENMASK(27, 24) 55263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CMD_SYNC_0_MSI_DATA GENMASK(63, 32) 56263b2ba5SJacek Lawrynowicz 57263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CMD_CFGI_0_SSEC BIT(10) 58263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CMD_CFGI_0_SSV BIT(11) 59263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CMD_CFGI_0_SSID GENMASK(31, 12) 60263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CMD_CFGI_0_SID GENMASK(63, 32) 61263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CMD_CFGI_1_RANGE GENMASK(4, 0) 62263b2ba5SJacek Lawrynowicz 63263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CMD_TLBI_0_ASID GENMASK(63, 48) 64263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CMD_TLBI_0_VMID GENMASK(47, 32) 65263b2ba5SJacek Lawrynowicz 66263b2ba5SJacek Lawrynowicz #define CMD_PREFETCH_CFG 0x1 67263b2ba5SJacek Lawrynowicz #define CMD_CFGI_STE 0x3 68263b2ba5SJacek Lawrynowicz #define CMD_CFGI_ALL 0x4 69263b2ba5SJacek Lawrynowicz #define CMD_CFGI_CD 0x5 70263b2ba5SJacek Lawrynowicz #define CMD_CFGI_CD_ALL 0x6 71263b2ba5SJacek Lawrynowicz #define CMD_TLBI_NH_ASID 0x11 72263b2ba5SJacek Lawrynowicz #define CMD_TLBI_EL2_ALL 0x20 73263b2ba5SJacek Lawrynowicz #define CMD_TLBI_NSNH_ALL 0x30 74263b2ba5SJacek Lawrynowicz #define CMD_SYNC 0x46 75263b2ba5SJacek Lawrynowicz 76263b2ba5SJacek Lawrynowicz #define IVPU_MMU_EVT_F_UUT 0x01 77263b2ba5SJacek Lawrynowicz #define IVPU_MMU_EVT_C_BAD_STREAMID 0x02 78263b2ba5SJacek Lawrynowicz #define IVPU_MMU_EVT_F_STE_FETCH 0x03 79263b2ba5SJacek Lawrynowicz #define IVPU_MMU_EVT_C_BAD_STE 0x04 80263b2ba5SJacek Lawrynowicz #define IVPU_MMU_EVT_F_BAD_ATS_TREQ 0x05 81263b2ba5SJacek Lawrynowicz #define IVPU_MMU_EVT_F_STREAM_DISABLED 0x06 82263b2ba5SJacek Lawrynowicz #define IVPU_MMU_EVT_F_TRANSL_FORBIDDEN 0x07 83263b2ba5SJacek Lawrynowicz #define IVPU_MMU_EVT_C_BAD_SUBSTREAMID 0x08 84263b2ba5SJacek Lawrynowicz #define IVPU_MMU_EVT_F_CD_FETCH 0x09 85263b2ba5SJacek Lawrynowicz #define IVPU_MMU_EVT_C_BAD_CD 0x0a 86263b2ba5SJacek Lawrynowicz #define IVPU_MMU_EVT_F_WALK_EABT 0x0b 87263b2ba5SJacek Lawrynowicz #define IVPU_MMU_EVT_F_TRANSLATION 0x10 88263b2ba5SJacek Lawrynowicz #define IVPU_MMU_EVT_F_ADDR_SIZE 0x11 89263b2ba5SJacek Lawrynowicz #define IVPU_MMU_EVT_F_ACCESS 0x12 90263b2ba5SJacek Lawrynowicz #define IVPU_MMU_EVT_F_PERMISSION 0x13 91263b2ba5SJacek Lawrynowicz #define IVPU_MMU_EVT_F_TLB_CONFLICT 0x20 92263b2ba5SJacek Lawrynowicz #define IVPU_MMU_EVT_F_CFG_CONFLICT 0x21 93263b2ba5SJacek Lawrynowicz #define IVPU_MMU_EVT_E_PAGE_REQUEST 0x24 94263b2ba5SJacek Lawrynowicz #define IVPU_MMU_EVT_F_VMS_FETCH 0x25 95263b2ba5SJacek Lawrynowicz 96263b2ba5SJacek Lawrynowicz #define IVPU_MMU_EVT_OP_MASK GENMASK_ULL(7, 0) 97263b2ba5SJacek Lawrynowicz #define IVPU_MMU_EVT_SSID_MASK GENMASK_ULL(31, 12) 98263b2ba5SJacek Lawrynowicz 99263b2ba5SJacek Lawrynowicz #define IVPU_MMU_Q_BASE_RWA BIT(62) 100263b2ba5SJacek Lawrynowicz #define IVPU_MMU_Q_BASE_ADDR_MASK GENMASK_ULL(51, 5) 101263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STRTAB_BASE_RA BIT(62) 102263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STRTAB_BASE_ADDR_MASK GENMASK_ULL(51, 6) 103263b2ba5SJacek Lawrynowicz 104263b2ba5SJacek Lawrynowicz #define IVPU_MMU_IRQ_EVTQ_EN BIT(2) 105263b2ba5SJacek Lawrynowicz #define IVPU_MMU_IRQ_GERROR_EN BIT(0) 106263b2ba5SJacek Lawrynowicz 107263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CR0_ATSCHK BIT(4) 108263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CR0_CMDQEN BIT(3) 109263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CR0_EVTQEN BIT(2) 110263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CR0_PRIQEN BIT(1) 111263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CR0_SMMUEN BIT(0) 112263b2ba5SJacek Lawrynowicz 113263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CR1_TABLE_SH GENMASK(11, 10) 114263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CR1_TABLE_OC GENMASK(9, 8) 115263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CR1_TABLE_IC GENMASK(7, 6) 116263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CR1_QUEUE_SH GENMASK(5, 4) 117263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CR1_QUEUE_OC GENMASK(3, 2) 118263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CR1_QUEUE_IC GENMASK(1, 0) 119263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CACHE_NC 0 120263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CACHE_WB 1 121263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CACHE_WT 2 122263b2ba5SJacek Lawrynowicz #define IVPU_MMU_SH_NSH 0 123263b2ba5SJacek Lawrynowicz #define IVPU_MMU_SH_OSH 2 124263b2ba5SJacek Lawrynowicz #define IVPU_MMU_SH_ISH 3 125263b2ba5SJacek Lawrynowicz 126263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CMDQ_OP GENMASK_ULL(7, 0) 127263b2ba5SJacek Lawrynowicz 128263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CD_0_TCR_T0SZ GENMASK_ULL(5, 0) 129263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CD_0_TCR_TG0 GENMASK_ULL(7, 6) 130263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CD_0_TCR_IRGN0 GENMASK_ULL(9, 8) 131263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CD_0_TCR_ORGN0 GENMASK_ULL(11, 10) 132263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CD_0_TCR_SH0 GENMASK_ULL(13, 12) 133263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CD_0_TCR_EPD0 BIT_ULL(14) 134263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CD_0_TCR_EPD1 BIT_ULL(30) 135263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CD_0_ENDI BIT(15) 136263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CD_0_V BIT(31) 137263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CD_0_TCR_IPS GENMASK_ULL(34, 32) 138263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CD_0_TCR_TBI0 BIT_ULL(38) 139263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CD_0_AA64 BIT(41) 140263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CD_0_S BIT(44) 141263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CD_0_R BIT(45) 142263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CD_0_A BIT(46) 143263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CD_0_ASET BIT(47) 144263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CD_0_ASID GENMASK_ULL(63, 48) 145263b2ba5SJacek Lawrynowicz 146263b2ba5SJacek Lawrynowicz #define IVPU_MMU_CD_1_TTB0_MASK GENMASK_ULL(51, 4) 147263b2ba5SJacek Lawrynowicz 148263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STE_0_S1CDMAX GENMASK_ULL(63, 59) 149263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STE_0_S1FMT GENMASK_ULL(5, 4) 150263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STE_0_S1FMT_LINEAR 0 151263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STE_DWORDS 8 152263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STE_0_CFG_S1_TRANS 5 153263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STE_0_CFG GENMASK_ULL(3, 1) 154263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STE_0_S1CTXPTR_MASK GENMASK_ULL(51, 6) 155263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STE_0_V BIT(0) 156263b2ba5SJacek Lawrynowicz 157263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STE_1_STRW_NSEL1 0ul 158263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STE_1_CONT GENMASK_ULL(16, 13) 159263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STE_1_STRW GENMASK_ULL(31, 30) 160263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STE_1_PRIVCFG GENMASK_ULL(49, 48) 161263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STE_1_PRIVCFG_UNPRIV 2ul 162263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STE_1_INSTCFG GENMASK_ULL(51, 50) 163263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STE_1_INSTCFG_DATA 2ul 164263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STE_1_MEV BIT(19) 165263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STE_1_S1STALLD BIT(27) 166263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STE_1_S1C_CACHE_NC 0ul 167263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STE_1_S1C_CACHE_WBRA 1ul 168263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STE_1_S1C_CACHE_WT 2ul 169263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STE_1_S1C_CACHE_WB 3ul 170263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STE_1_S1CIR GENMASK_ULL(3, 2) 171263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STE_1_S1COR GENMASK_ULL(5, 4) 172263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STE_1_S1CSH GENMASK_ULL(7, 6) 173263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STE_1_S1DSS GENMASK_ULL(1, 0) 174263b2ba5SJacek Lawrynowicz #define IVPU_MMU_STE_1_S1DSS_TERMINATE 0x0 175263b2ba5SJacek Lawrynowicz 176263b2ba5SJacek Lawrynowicz #define IVPU_MMU_REG_TIMEOUT_US (10 * USEC_PER_MSEC) 177263b2ba5SJacek Lawrynowicz #define IVPU_MMU_QUEUE_TIMEOUT_US (100 * USEC_PER_MSEC) 178263b2ba5SJacek Lawrynowicz 179263b2ba5SJacek Lawrynowicz #define IVPU_MMU_GERROR_ERR_MASK ((REG_FLD(MTL_VPU_HOST_MMU_GERROR, CMDQ)) | \ 180263b2ba5SJacek Lawrynowicz (REG_FLD(MTL_VPU_HOST_MMU_GERROR, EVTQ_ABT)) | \ 181263b2ba5SJacek Lawrynowicz (REG_FLD(MTL_VPU_HOST_MMU_GERROR, PRIQ_ABT)) | \ 182263b2ba5SJacek Lawrynowicz (REG_FLD(MTL_VPU_HOST_MMU_GERROR, MSI_CMDQ_ABT)) | \ 183263b2ba5SJacek Lawrynowicz (REG_FLD(MTL_VPU_HOST_MMU_GERROR, MSI_EVTQ_ABT)) | \ 184263b2ba5SJacek Lawrynowicz (REG_FLD(MTL_VPU_HOST_MMU_GERROR, MSI_PRIQ_ABT)) | \ 185263b2ba5SJacek Lawrynowicz (REG_FLD(MTL_VPU_HOST_MMU_GERROR, MSI_ABT))) 186263b2ba5SJacek Lawrynowicz 187263b2ba5SJacek Lawrynowicz static char *ivpu_mmu_event_to_str(u32 cmd) 188263b2ba5SJacek Lawrynowicz { 189263b2ba5SJacek Lawrynowicz switch (cmd) { 190263b2ba5SJacek Lawrynowicz case IVPU_MMU_EVT_F_UUT: 191263b2ba5SJacek Lawrynowicz return "Unsupported Upstream Transaction"; 192263b2ba5SJacek Lawrynowicz case IVPU_MMU_EVT_C_BAD_STREAMID: 193263b2ba5SJacek Lawrynowicz return "Transaction StreamID out of range"; 194263b2ba5SJacek Lawrynowicz case IVPU_MMU_EVT_F_STE_FETCH: 195263b2ba5SJacek Lawrynowicz return "Fetch of STE caused external abort"; 196263b2ba5SJacek Lawrynowicz case IVPU_MMU_EVT_C_BAD_STE: 197263b2ba5SJacek Lawrynowicz return "Used STE invalid"; 198263b2ba5SJacek Lawrynowicz case IVPU_MMU_EVT_F_BAD_ATS_TREQ: 199263b2ba5SJacek Lawrynowicz return "Address Request disallowed for a StreamID"; 200263b2ba5SJacek Lawrynowicz case IVPU_MMU_EVT_F_STREAM_DISABLED: 201263b2ba5SJacek Lawrynowicz return "Transaction marks non-substream disabled"; 202263b2ba5SJacek Lawrynowicz case IVPU_MMU_EVT_F_TRANSL_FORBIDDEN: 203263b2ba5SJacek Lawrynowicz return "MMU bypass is disallowed for this StreamID"; 204263b2ba5SJacek Lawrynowicz case IVPU_MMU_EVT_C_BAD_SUBSTREAMID: 205263b2ba5SJacek Lawrynowicz return "Invalid StreamID"; 206263b2ba5SJacek Lawrynowicz case IVPU_MMU_EVT_F_CD_FETCH: 207263b2ba5SJacek Lawrynowicz return "Fetch of CD caused external abort"; 208263b2ba5SJacek Lawrynowicz case IVPU_MMU_EVT_C_BAD_CD: 209263b2ba5SJacek Lawrynowicz return "Fetched CD invalid"; 210263b2ba5SJacek Lawrynowicz case IVPU_MMU_EVT_F_WALK_EABT: 211263b2ba5SJacek Lawrynowicz return " An external abort occurred fetching a TLB"; 212263b2ba5SJacek Lawrynowicz case IVPU_MMU_EVT_F_TRANSLATION: 213263b2ba5SJacek Lawrynowicz return "Translation fault"; 214263b2ba5SJacek Lawrynowicz case IVPU_MMU_EVT_F_ADDR_SIZE: 215263b2ba5SJacek Lawrynowicz return " Output address caused address size fault"; 216263b2ba5SJacek Lawrynowicz case IVPU_MMU_EVT_F_ACCESS: 217263b2ba5SJacek Lawrynowicz return "Access flag fault"; 218263b2ba5SJacek Lawrynowicz case IVPU_MMU_EVT_F_PERMISSION: 219263b2ba5SJacek Lawrynowicz return "Permission fault occurred on page access"; 220263b2ba5SJacek Lawrynowicz case IVPU_MMU_EVT_F_TLB_CONFLICT: 221263b2ba5SJacek Lawrynowicz return "A TLB conflict"; 222263b2ba5SJacek Lawrynowicz case IVPU_MMU_EVT_F_CFG_CONFLICT: 223263b2ba5SJacek Lawrynowicz return "A configuration cache conflict"; 224263b2ba5SJacek Lawrynowicz case IVPU_MMU_EVT_E_PAGE_REQUEST: 225263b2ba5SJacek Lawrynowicz return "Page request hint from a client device"; 226263b2ba5SJacek Lawrynowicz case IVPU_MMU_EVT_F_VMS_FETCH: 227263b2ba5SJacek Lawrynowicz return "Fetch of VMS caused external abort"; 228263b2ba5SJacek Lawrynowicz default: 229263b2ba5SJacek Lawrynowicz return "Unknown CMDQ command"; 230263b2ba5SJacek Lawrynowicz } 231263b2ba5SJacek Lawrynowicz } 232263b2ba5SJacek Lawrynowicz 233263b2ba5SJacek Lawrynowicz static void ivpu_mmu_config_check(struct ivpu_device *vdev) 234263b2ba5SJacek Lawrynowicz { 235263b2ba5SJacek Lawrynowicz u32 val_ref; 236263b2ba5SJacek Lawrynowicz u32 val; 237263b2ba5SJacek Lawrynowicz 238263b2ba5SJacek Lawrynowicz if (ivpu_is_simics(vdev)) 239263b2ba5SJacek Lawrynowicz val_ref = IVPU_MMU_IDR0_REF_SIMICS; 240263b2ba5SJacek Lawrynowicz else 241263b2ba5SJacek Lawrynowicz val_ref = IVPU_MMU_IDR0_REF; 242263b2ba5SJacek Lawrynowicz 243263b2ba5SJacek Lawrynowicz val = REGV_RD32(MTL_VPU_HOST_MMU_IDR0); 244263b2ba5SJacek Lawrynowicz if (val != val_ref) 245263b2ba5SJacek Lawrynowicz ivpu_dbg(vdev, MMU, "IDR0 0x%x != IDR0_REF 0x%x\n", val, val_ref); 246263b2ba5SJacek Lawrynowicz 247263b2ba5SJacek Lawrynowicz val = REGV_RD32(MTL_VPU_HOST_MMU_IDR1); 248263b2ba5SJacek Lawrynowicz if (val != IVPU_MMU_IDR1_REF) 249263b2ba5SJacek Lawrynowicz ivpu_dbg(vdev, MMU, "IDR1 0x%x != IDR1_REF 0x%x\n", val, IVPU_MMU_IDR1_REF); 250263b2ba5SJacek Lawrynowicz 251263b2ba5SJacek Lawrynowicz val = REGV_RD32(MTL_VPU_HOST_MMU_IDR3); 252263b2ba5SJacek Lawrynowicz if (val != IVPU_MMU_IDR3_REF) 253263b2ba5SJacek Lawrynowicz ivpu_dbg(vdev, MMU, "IDR3 0x%x != IDR3_REF 0x%x\n", val, IVPU_MMU_IDR3_REF); 254263b2ba5SJacek Lawrynowicz 255263b2ba5SJacek Lawrynowicz if (ivpu_is_simics(vdev)) 256263b2ba5SJacek Lawrynowicz val_ref = IVPU_MMU_IDR5_REF_SIMICS; 257263b2ba5SJacek Lawrynowicz else if (ivpu_is_fpga(vdev)) 258263b2ba5SJacek Lawrynowicz val_ref = IVPU_MMU_IDR5_REF_FPGA; 259263b2ba5SJacek Lawrynowicz else 260263b2ba5SJacek Lawrynowicz val_ref = IVPU_MMU_IDR5_REF; 261263b2ba5SJacek Lawrynowicz 262263b2ba5SJacek Lawrynowicz val = REGV_RD32(MTL_VPU_HOST_MMU_IDR5); 263263b2ba5SJacek Lawrynowicz if (val != val_ref) 264263b2ba5SJacek Lawrynowicz ivpu_dbg(vdev, MMU, "IDR5 0x%x != IDR5_REF 0x%x\n", val, val_ref); 265263b2ba5SJacek Lawrynowicz } 266263b2ba5SJacek Lawrynowicz 267263b2ba5SJacek Lawrynowicz static int ivpu_mmu_cdtab_alloc(struct ivpu_device *vdev) 268263b2ba5SJacek Lawrynowicz { 269263b2ba5SJacek Lawrynowicz struct ivpu_mmu_info *mmu = vdev->mmu; 270263b2ba5SJacek Lawrynowicz struct ivpu_mmu_cdtab *cdtab = &mmu->cdtab; 271263b2ba5SJacek Lawrynowicz size_t size = IVPU_MMU_CDTAB_ENT_COUNT * IVPU_MMU_CDTAB_ENT_SIZE; 272263b2ba5SJacek Lawrynowicz 273263b2ba5SJacek Lawrynowicz cdtab->base = dmam_alloc_coherent(vdev->drm.dev, size, &cdtab->dma, GFP_KERNEL); 274263b2ba5SJacek Lawrynowicz if (!cdtab->base) 275263b2ba5SJacek Lawrynowicz return -ENOMEM; 276263b2ba5SJacek Lawrynowicz 277263b2ba5SJacek Lawrynowicz ivpu_dbg(vdev, MMU, "CDTAB alloc: dma=%pad size=%zu\n", &cdtab->dma, size); 278263b2ba5SJacek Lawrynowicz 279263b2ba5SJacek Lawrynowicz return 0; 280263b2ba5SJacek Lawrynowicz } 281263b2ba5SJacek Lawrynowicz 282263b2ba5SJacek Lawrynowicz static int ivpu_mmu_strtab_alloc(struct ivpu_device *vdev) 283263b2ba5SJacek Lawrynowicz { 284263b2ba5SJacek Lawrynowicz struct ivpu_mmu_info *mmu = vdev->mmu; 285263b2ba5SJacek Lawrynowicz struct ivpu_mmu_strtab *strtab = &mmu->strtab; 286263b2ba5SJacek Lawrynowicz size_t size = IVPU_MMU_STRTAB_ENT_COUNT * IVPU_MMU_STRTAB_ENT_SIZE; 287263b2ba5SJacek Lawrynowicz 288263b2ba5SJacek Lawrynowicz strtab->base = dmam_alloc_coherent(vdev->drm.dev, size, &strtab->dma, GFP_KERNEL); 289263b2ba5SJacek Lawrynowicz if (!strtab->base) 290263b2ba5SJacek Lawrynowicz return -ENOMEM; 291263b2ba5SJacek Lawrynowicz 292263b2ba5SJacek Lawrynowicz strtab->base_cfg = IVPU_MMU_STRTAB_CFG; 293263b2ba5SJacek Lawrynowicz strtab->dma_q = IVPU_MMU_STRTAB_BASE_RA; 294263b2ba5SJacek Lawrynowicz strtab->dma_q |= strtab->dma & IVPU_MMU_STRTAB_BASE_ADDR_MASK; 295263b2ba5SJacek Lawrynowicz 296263b2ba5SJacek Lawrynowicz ivpu_dbg(vdev, MMU, "STRTAB alloc: dma=%pad dma_q=%pad size=%zu\n", 297263b2ba5SJacek Lawrynowicz &strtab->dma, &strtab->dma_q, size); 298263b2ba5SJacek Lawrynowicz 299263b2ba5SJacek Lawrynowicz return 0; 300263b2ba5SJacek Lawrynowicz } 301263b2ba5SJacek Lawrynowicz 302263b2ba5SJacek Lawrynowicz static int ivpu_mmu_cmdq_alloc(struct ivpu_device *vdev) 303263b2ba5SJacek Lawrynowicz { 304263b2ba5SJacek Lawrynowicz struct ivpu_mmu_info *mmu = vdev->mmu; 305263b2ba5SJacek Lawrynowicz struct ivpu_mmu_queue *q = &mmu->cmdq; 306263b2ba5SJacek Lawrynowicz 307263b2ba5SJacek Lawrynowicz q->base = dmam_alloc_coherent(vdev->drm.dev, IVPU_MMU_CMDQ_SIZE, &q->dma, GFP_KERNEL); 308263b2ba5SJacek Lawrynowicz if (!q->base) 309263b2ba5SJacek Lawrynowicz return -ENOMEM; 310263b2ba5SJacek Lawrynowicz 311263b2ba5SJacek Lawrynowicz q->dma_q = IVPU_MMU_Q_BASE_RWA; 312263b2ba5SJacek Lawrynowicz q->dma_q |= q->dma & IVPU_MMU_Q_BASE_ADDR_MASK; 313263b2ba5SJacek Lawrynowicz q->dma_q |= IVPU_MMU_Q_COUNT_LOG2; 314263b2ba5SJacek Lawrynowicz 315263b2ba5SJacek Lawrynowicz ivpu_dbg(vdev, MMU, "CMDQ alloc: dma=%pad dma_q=%pad size=%u\n", 316263b2ba5SJacek Lawrynowicz &q->dma, &q->dma_q, IVPU_MMU_CMDQ_SIZE); 317263b2ba5SJacek Lawrynowicz 318263b2ba5SJacek Lawrynowicz return 0; 319263b2ba5SJacek Lawrynowicz } 320263b2ba5SJacek Lawrynowicz 321263b2ba5SJacek Lawrynowicz static int ivpu_mmu_evtq_alloc(struct ivpu_device *vdev) 322263b2ba5SJacek Lawrynowicz { 323263b2ba5SJacek Lawrynowicz struct ivpu_mmu_info *mmu = vdev->mmu; 324263b2ba5SJacek Lawrynowicz struct ivpu_mmu_queue *q = &mmu->evtq; 325263b2ba5SJacek Lawrynowicz 326263b2ba5SJacek Lawrynowicz q->base = dmam_alloc_coherent(vdev->drm.dev, IVPU_MMU_EVTQ_SIZE, &q->dma, GFP_KERNEL); 327263b2ba5SJacek Lawrynowicz if (!q->base) 328263b2ba5SJacek Lawrynowicz return -ENOMEM; 329263b2ba5SJacek Lawrynowicz 330263b2ba5SJacek Lawrynowicz q->dma_q = IVPU_MMU_Q_BASE_RWA; 331263b2ba5SJacek Lawrynowicz q->dma_q |= q->dma & IVPU_MMU_Q_BASE_ADDR_MASK; 332263b2ba5SJacek Lawrynowicz q->dma_q |= IVPU_MMU_Q_COUNT_LOG2; 333263b2ba5SJacek Lawrynowicz 334263b2ba5SJacek Lawrynowicz ivpu_dbg(vdev, MMU, "EVTQ alloc: dma=%pad dma_q=%pad size=%u\n", 335263b2ba5SJacek Lawrynowicz &q->dma, &q->dma_q, IVPU_MMU_EVTQ_SIZE); 336263b2ba5SJacek Lawrynowicz 337263b2ba5SJacek Lawrynowicz return 0; 338263b2ba5SJacek Lawrynowicz } 339263b2ba5SJacek Lawrynowicz 340263b2ba5SJacek Lawrynowicz static int ivpu_mmu_structs_alloc(struct ivpu_device *vdev) 341263b2ba5SJacek Lawrynowicz { 342263b2ba5SJacek Lawrynowicz int ret; 343263b2ba5SJacek Lawrynowicz 344263b2ba5SJacek Lawrynowicz ret = ivpu_mmu_cdtab_alloc(vdev); 345263b2ba5SJacek Lawrynowicz if (ret) { 346263b2ba5SJacek Lawrynowicz ivpu_err(vdev, "Failed to allocate cdtab: %d\n", ret); 347263b2ba5SJacek Lawrynowicz return ret; 348263b2ba5SJacek Lawrynowicz } 349263b2ba5SJacek Lawrynowicz 350263b2ba5SJacek Lawrynowicz ret = ivpu_mmu_strtab_alloc(vdev); 351263b2ba5SJacek Lawrynowicz if (ret) { 352263b2ba5SJacek Lawrynowicz ivpu_err(vdev, "Failed to allocate strtab: %d\n", ret); 353263b2ba5SJacek Lawrynowicz return ret; 354263b2ba5SJacek Lawrynowicz } 355263b2ba5SJacek Lawrynowicz 356263b2ba5SJacek Lawrynowicz ret = ivpu_mmu_cmdq_alloc(vdev); 357263b2ba5SJacek Lawrynowicz if (ret) { 358263b2ba5SJacek Lawrynowicz ivpu_err(vdev, "Failed to allocate cmdq: %d\n", ret); 359263b2ba5SJacek Lawrynowicz return ret; 360263b2ba5SJacek Lawrynowicz } 361263b2ba5SJacek Lawrynowicz 362263b2ba5SJacek Lawrynowicz ret = ivpu_mmu_evtq_alloc(vdev); 363263b2ba5SJacek Lawrynowicz if (ret) 364263b2ba5SJacek Lawrynowicz ivpu_err(vdev, "Failed to allocate evtq: %d\n", ret); 365263b2ba5SJacek Lawrynowicz 366263b2ba5SJacek Lawrynowicz return ret; 367263b2ba5SJacek Lawrynowicz } 368263b2ba5SJacek Lawrynowicz 369263b2ba5SJacek Lawrynowicz static int ivpu_mmu_reg_write(struct ivpu_device *vdev, u32 reg, u32 val) 370263b2ba5SJacek Lawrynowicz { 371263b2ba5SJacek Lawrynowicz u32 reg_ack = reg + 4; /* ACK register is 4B after base register */ 372263b2ba5SJacek Lawrynowicz u32 val_ack; 373263b2ba5SJacek Lawrynowicz int ret; 374263b2ba5SJacek Lawrynowicz 375263b2ba5SJacek Lawrynowicz REGV_WR32(reg, val); 376263b2ba5SJacek Lawrynowicz 377263b2ba5SJacek Lawrynowicz ret = REGV_POLL(reg_ack, val_ack, (val == val_ack), IVPU_MMU_REG_TIMEOUT_US); 378263b2ba5SJacek Lawrynowicz if (ret) 379263b2ba5SJacek Lawrynowicz ivpu_err(vdev, "Failed to write register 0x%x\n", reg); 380263b2ba5SJacek Lawrynowicz 381263b2ba5SJacek Lawrynowicz return ret; 382263b2ba5SJacek Lawrynowicz } 383263b2ba5SJacek Lawrynowicz 384263b2ba5SJacek Lawrynowicz static int ivpu_mmu_irqs_setup(struct ivpu_device *vdev) 385263b2ba5SJacek Lawrynowicz { 386263b2ba5SJacek Lawrynowicz u32 irq_ctrl = IVPU_MMU_IRQ_EVTQ_EN | IVPU_MMU_IRQ_GERROR_EN; 387263b2ba5SJacek Lawrynowicz int ret; 388263b2ba5SJacek Lawrynowicz 389263b2ba5SJacek Lawrynowicz ret = ivpu_mmu_reg_write(vdev, MTL_VPU_HOST_MMU_IRQ_CTRL, 0); 390263b2ba5SJacek Lawrynowicz if (ret) 391263b2ba5SJacek Lawrynowicz return ret; 392263b2ba5SJacek Lawrynowicz 393263b2ba5SJacek Lawrynowicz return ivpu_mmu_reg_write(vdev, MTL_VPU_HOST_MMU_IRQ_CTRL, irq_ctrl); 394263b2ba5SJacek Lawrynowicz } 395263b2ba5SJacek Lawrynowicz 396263b2ba5SJacek Lawrynowicz static int ivpu_mmu_cmdq_wait_for_cons(struct ivpu_device *vdev) 397263b2ba5SJacek Lawrynowicz { 398263b2ba5SJacek Lawrynowicz struct ivpu_mmu_queue *cmdq = &vdev->mmu->cmdq; 399263b2ba5SJacek Lawrynowicz 400263b2ba5SJacek Lawrynowicz return REGV_POLL(MTL_VPU_HOST_MMU_CMDQ_CONS, cmdq->cons, (cmdq->prod == cmdq->cons), 401263b2ba5SJacek Lawrynowicz IVPU_MMU_QUEUE_TIMEOUT_US); 402263b2ba5SJacek Lawrynowicz } 403263b2ba5SJacek Lawrynowicz 404263b2ba5SJacek Lawrynowicz static int ivpu_mmu_cmdq_cmd_write(struct ivpu_device *vdev, const char *name, u64 data0, u64 data1) 405263b2ba5SJacek Lawrynowicz { 406263b2ba5SJacek Lawrynowicz struct ivpu_mmu_queue *q = &vdev->mmu->cmdq; 407263b2ba5SJacek Lawrynowicz u64 *queue_buffer = q->base; 408263b2ba5SJacek Lawrynowicz int idx = IVPU_MMU_Q_IDX(q->prod) * (IVPU_MMU_CMDQ_CMD_SIZE / sizeof(*queue_buffer)); 409263b2ba5SJacek Lawrynowicz 410263b2ba5SJacek Lawrynowicz if (!CIRC_SPACE(IVPU_MMU_Q_IDX(q->prod), IVPU_MMU_Q_IDX(q->cons), IVPU_MMU_Q_COUNT)) { 411263b2ba5SJacek Lawrynowicz ivpu_err(vdev, "Failed to write MMU CMD %s\n", name); 412263b2ba5SJacek Lawrynowicz return -EBUSY; 413263b2ba5SJacek Lawrynowicz } 414263b2ba5SJacek Lawrynowicz 415263b2ba5SJacek Lawrynowicz queue_buffer[idx] = data0; 416263b2ba5SJacek Lawrynowicz queue_buffer[idx + 1] = data1; 417263b2ba5SJacek Lawrynowicz q->prod = (q->prod + 1) & IVPU_MMU_Q_WRAP_MASK; 418263b2ba5SJacek Lawrynowicz 419263b2ba5SJacek Lawrynowicz ivpu_dbg(vdev, MMU, "CMD write: %s data: 0x%llx 0x%llx\n", name, data0, data1); 420263b2ba5SJacek Lawrynowicz 421263b2ba5SJacek Lawrynowicz return 0; 422263b2ba5SJacek Lawrynowicz } 423263b2ba5SJacek Lawrynowicz 424263b2ba5SJacek Lawrynowicz static int ivpu_mmu_cmdq_sync(struct ivpu_device *vdev) 425263b2ba5SJacek Lawrynowicz { 426263b2ba5SJacek Lawrynowicz struct ivpu_mmu_queue *q = &vdev->mmu->cmdq; 427263b2ba5SJacek Lawrynowicz u64 val; 428263b2ba5SJacek Lawrynowicz int ret; 429263b2ba5SJacek Lawrynowicz 430263b2ba5SJacek Lawrynowicz val = FIELD_PREP(IVPU_MMU_CMD_OPCODE, CMD_SYNC) | 431263b2ba5SJacek Lawrynowicz FIELD_PREP(IVPU_MMU_CMD_SYNC_0_CS, 0x2) | 432263b2ba5SJacek Lawrynowicz FIELD_PREP(IVPU_MMU_CMD_SYNC_0_MSH, 0x3) | 433263b2ba5SJacek Lawrynowicz FIELD_PREP(IVPU_MMU_CMD_SYNC_0_MSI_ATTR, 0xf); 434263b2ba5SJacek Lawrynowicz 435263b2ba5SJacek Lawrynowicz ret = ivpu_mmu_cmdq_cmd_write(vdev, "SYNC", val, 0); 436263b2ba5SJacek Lawrynowicz if (ret) 437263b2ba5SJacek Lawrynowicz return ret; 438263b2ba5SJacek Lawrynowicz 439263b2ba5SJacek Lawrynowicz clflush_cache_range(q->base, IVPU_MMU_CMDQ_SIZE); 440263b2ba5SJacek Lawrynowicz REGV_WR32(MTL_VPU_HOST_MMU_CMDQ_PROD, q->prod); 441263b2ba5SJacek Lawrynowicz 442263b2ba5SJacek Lawrynowicz ret = ivpu_mmu_cmdq_wait_for_cons(vdev); 443263b2ba5SJacek Lawrynowicz if (ret) 444263b2ba5SJacek Lawrynowicz ivpu_err(vdev, "Timed out waiting for consumer: %d\n", ret); 445263b2ba5SJacek Lawrynowicz 446263b2ba5SJacek Lawrynowicz return ret; 447263b2ba5SJacek Lawrynowicz } 448263b2ba5SJacek Lawrynowicz 449263b2ba5SJacek Lawrynowicz static int ivpu_mmu_cmdq_write_cfgi_all(struct ivpu_device *vdev) 450263b2ba5SJacek Lawrynowicz { 451263b2ba5SJacek Lawrynowicz u64 data0 = FIELD_PREP(IVPU_MMU_CMD_OPCODE, CMD_CFGI_ALL); 452263b2ba5SJacek Lawrynowicz u64 data1 = FIELD_PREP(IVPU_MMU_CMD_CFGI_1_RANGE, 0x1f); 453263b2ba5SJacek Lawrynowicz 454263b2ba5SJacek Lawrynowicz return ivpu_mmu_cmdq_cmd_write(vdev, "CFGI_ALL", data0, data1); 455263b2ba5SJacek Lawrynowicz } 456263b2ba5SJacek Lawrynowicz 457263b2ba5SJacek Lawrynowicz static int ivpu_mmu_cmdq_write_tlbi_nh_asid(struct ivpu_device *vdev, u16 ssid) 458263b2ba5SJacek Lawrynowicz { 459263b2ba5SJacek Lawrynowicz u64 val = FIELD_PREP(IVPU_MMU_CMD_OPCODE, CMD_TLBI_NH_ASID) | 460263b2ba5SJacek Lawrynowicz FIELD_PREP(IVPU_MMU_CMD_TLBI_0_ASID, ssid); 461263b2ba5SJacek Lawrynowicz 462263b2ba5SJacek Lawrynowicz return ivpu_mmu_cmdq_cmd_write(vdev, "TLBI_NH_ASID", val, 0); 463263b2ba5SJacek Lawrynowicz } 464263b2ba5SJacek Lawrynowicz 465263b2ba5SJacek Lawrynowicz static int ivpu_mmu_cmdq_write_tlbi_nsnh_all(struct ivpu_device *vdev) 466263b2ba5SJacek Lawrynowicz { 467263b2ba5SJacek Lawrynowicz u64 val = FIELD_PREP(IVPU_MMU_CMD_OPCODE, CMD_TLBI_NSNH_ALL); 468263b2ba5SJacek Lawrynowicz 469263b2ba5SJacek Lawrynowicz return ivpu_mmu_cmdq_cmd_write(vdev, "TLBI_NSNH_ALL", val, 0); 470263b2ba5SJacek Lawrynowicz } 471263b2ba5SJacek Lawrynowicz 472263b2ba5SJacek Lawrynowicz static int ivpu_mmu_reset(struct ivpu_device *vdev) 473263b2ba5SJacek Lawrynowicz { 474263b2ba5SJacek Lawrynowicz struct ivpu_mmu_info *mmu = vdev->mmu; 475263b2ba5SJacek Lawrynowicz u32 val; 476263b2ba5SJacek Lawrynowicz int ret; 477263b2ba5SJacek Lawrynowicz 478263b2ba5SJacek Lawrynowicz memset(mmu->cmdq.base, 0, IVPU_MMU_CMDQ_SIZE); 479263b2ba5SJacek Lawrynowicz clflush_cache_range(mmu->cmdq.base, IVPU_MMU_CMDQ_SIZE); 480263b2ba5SJacek Lawrynowicz mmu->cmdq.prod = 0; 481263b2ba5SJacek Lawrynowicz mmu->cmdq.cons = 0; 482263b2ba5SJacek Lawrynowicz 483263b2ba5SJacek Lawrynowicz memset(mmu->evtq.base, 0, IVPU_MMU_EVTQ_SIZE); 484263b2ba5SJacek Lawrynowicz clflush_cache_range(mmu->evtq.base, IVPU_MMU_EVTQ_SIZE); 485263b2ba5SJacek Lawrynowicz mmu->evtq.prod = 0; 486263b2ba5SJacek Lawrynowicz mmu->evtq.cons = 0; 487263b2ba5SJacek Lawrynowicz 488263b2ba5SJacek Lawrynowicz ret = ivpu_mmu_reg_write(vdev, MTL_VPU_HOST_MMU_CR0, 0); 489263b2ba5SJacek Lawrynowicz if (ret) 490263b2ba5SJacek Lawrynowicz return ret; 491263b2ba5SJacek Lawrynowicz 492263b2ba5SJacek Lawrynowicz val = FIELD_PREP(IVPU_MMU_CR1_TABLE_SH, IVPU_MMU_SH_ISH) | 493263b2ba5SJacek Lawrynowicz FIELD_PREP(IVPU_MMU_CR1_TABLE_OC, IVPU_MMU_CACHE_WB) | 494263b2ba5SJacek Lawrynowicz FIELD_PREP(IVPU_MMU_CR1_TABLE_IC, IVPU_MMU_CACHE_WB) | 495263b2ba5SJacek Lawrynowicz FIELD_PREP(IVPU_MMU_CR1_QUEUE_SH, IVPU_MMU_SH_ISH) | 496263b2ba5SJacek Lawrynowicz FIELD_PREP(IVPU_MMU_CR1_QUEUE_OC, IVPU_MMU_CACHE_WB) | 497263b2ba5SJacek Lawrynowicz FIELD_PREP(IVPU_MMU_CR1_QUEUE_IC, IVPU_MMU_CACHE_WB); 498263b2ba5SJacek Lawrynowicz REGV_WR32(MTL_VPU_HOST_MMU_CR1, val); 499263b2ba5SJacek Lawrynowicz 500263b2ba5SJacek Lawrynowicz REGV_WR64(MTL_VPU_HOST_MMU_STRTAB_BASE, mmu->strtab.dma_q); 501263b2ba5SJacek Lawrynowicz REGV_WR32(MTL_VPU_HOST_MMU_STRTAB_BASE_CFG, mmu->strtab.base_cfg); 502263b2ba5SJacek Lawrynowicz 503263b2ba5SJacek Lawrynowicz REGV_WR64(MTL_VPU_HOST_MMU_CMDQ_BASE, mmu->cmdq.dma_q); 504263b2ba5SJacek Lawrynowicz REGV_WR32(MTL_VPU_HOST_MMU_CMDQ_PROD, 0); 505263b2ba5SJacek Lawrynowicz REGV_WR32(MTL_VPU_HOST_MMU_CMDQ_CONS, 0); 506263b2ba5SJacek Lawrynowicz 507263b2ba5SJacek Lawrynowicz val = IVPU_MMU_CR0_CMDQEN; 508263b2ba5SJacek Lawrynowicz ret = ivpu_mmu_reg_write(vdev, MTL_VPU_HOST_MMU_CR0, val); 509263b2ba5SJacek Lawrynowicz if (ret) 510263b2ba5SJacek Lawrynowicz return ret; 511263b2ba5SJacek Lawrynowicz 512263b2ba5SJacek Lawrynowicz ret = ivpu_mmu_cmdq_write_cfgi_all(vdev); 513263b2ba5SJacek Lawrynowicz if (ret) 514263b2ba5SJacek Lawrynowicz return ret; 515263b2ba5SJacek Lawrynowicz 516263b2ba5SJacek Lawrynowicz ret = ivpu_mmu_cmdq_write_tlbi_nsnh_all(vdev); 517263b2ba5SJacek Lawrynowicz if (ret) 518263b2ba5SJacek Lawrynowicz return ret; 519263b2ba5SJacek Lawrynowicz 520263b2ba5SJacek Lawrynowicz ret = ivpu_mmu_cmdq_sync(vdev); 521263b2ba5SJacek Lawrynowicz if (ret) 522263b2ba5SJacek Lawrynowicz return ret; 523263b2ba5SJacek Lawrynowicz 524263b2ba5SJacek Lawrynowicz REGV_WR64(MTL_VPU_HOST_MMU_EVTQ_BASE, mmu->evtq.dma_q); 525263b2ba5SJacek Lawrynowicz REGV_WR32(MTL_VPU_HOST_MMU_EVTQ_PROD_SEC, 0); 526263b2ba5SJacek Lawrynowicz REGV_WR32(MTL_VPU_HOST_MMU_EVTQ_CONS_SEC, 0); 527263b2ba5SJacek Lawrynowicz 528263b2ba5SJacek Lawrynowicz val |= IVPU_MMU_CR0_EVTQEN; 529263b2ba5SJacek Lawrynowicz ret = ivpu_mmu_reg_write(vdev, MTL_VPU_HOST_MMU_CR0, val); 530263b2ba5SJacek Lawrynowicz if (ret) 531263b2ba5SJacek Lawrynowicz return ret; 532263b2ba5SJacek Lawrynowicz 533263b2ba5SJacek Lawrynowicz val |= IVPU_MMU_CR0_ATSCHK; 534263b2ba5SJacek Lawrynowicz ret = ivpu_mmu_reg_write(vdev, MTL_VPU_HOST_MMU_CR0, val); 535263b2ba5SJacek Lawrynowicz if (ret) 536263b2ba5SJacek Lawrynowicz return ret; 537263b2ba5SJacek Lawrynowicz 538263b2ba5SJacek Lawrynowicz ret = ivpu_mmu_irqs_setup(vdev); 539263b2ba5SJacek Lawrynowicz if (ret) 540263b2ba5SJacek Lawrynowicz return ret; 541263b2ba5SJacek Lawrynowicz 542263b2ba5SJacek Lawrynowicz val |= IVPU_MMU_CR0_SMMUEN; 543263b2ba5SJacek Lawrynowicz return ivpu_mmu_reg_write(vdev, MTL_VPU_HOST_MMU_CR0, val); 544263b2ba5SJacek Lawrynowicz } 545263b2ba5SJacek Lawrynowicz 546263b2ba5SJacek Lawrynowicz static void ivpu_mmu_strtab_link_cd(struct ivpu_device *vdev, u32 sid) 547263b2ba5SJacek Lawrynowicz { 548263b2ba5SJacek Lawrynowicz struct ivpu_mmu_info *mmu = vdev->mmu; 549263b2ba5SJacek Lawrynowicz struct ivpu_mmu_strtab *strtab = &mmu->strtab; 550263b2ba5SJacek Lawrynowicz struct ivpu_mmu_cdtab *cdtab = &mmu->cdtab; 551263b2ba5SJacek Lawrynowicz u64 *entry = strtab->base + (sid * IVPU_MMU_STRTAB_ENT_SIZE); 552263b2ba5SJacek Lawrynowicz u64 str[2]; 553263b2ba5SJacek Lawrynowicz 554263b2ba5SJacek Lawrynowicz str[0] = FIELD_PREP(IVPU_MMU_STE_0_CFG, IVPU_MMU_STE_0_CFG_S1_TRANS) | 555263b2ba5SJacek Lawrynowicz FIELD_PREP(IVPU_MMU_STE_0_S1CDMAX, IVPU_MMU_CDTAB_ENT_COUNT_LOG2) | 556263b2ba5SJacek Lawrynowicz FIELD_PREP(IVPU_MMU_STE_0_S1FMT, IVPU_MMU_STE_0_S1FMT_LINEAR) | 557263b2ba5SJacek Lawrynowicz IVPU_MMU_STE_0_V | 558263b2ba5SJacek Lawrynowicz (cdtab->dma & IVPU_MMU_STE_0_S1CTXPTR_MASK); 559263b2ba5SJacek Lawrynowicz 560263b2ba5SJacek Lawrynowicz str[1] = FIELD_PREP(IVPU_MMU_STE_1_S1DSS, IVPU_MMU_STE_1_S1DSS_TERMINATE) | 561263b2ba5SJacek Lawrynowicz FIELD_PREP(IVPU_MMU_STE_1_S1CIR, IVPU_MMU_STE_1_S1C_CACHE_NC) | 562263b2ba5SJacek Lawrynowicz FIELD_PREP(IVPU_MMU_STE_1_S1COR, IVPU_MMU_STE_1_S1C_CACHE_NC) | 563263b2ba5SJacek Lawrynowicz FIELD_PREP(IVPU_MMU_STE_1_S1CSH, IVPU_MMU_SH_NSH) | 564263b2ba5SJacek Lawrynowicz FIELD_PREP(IVPU_MMU_STE_1_PRIVCFG, IVPU_MMU_STE_1_PRIVCFG_UNPRIV) | 565263b2ba5SJacek Lawrynowicz FIELD_PREP(IVPU_MMU_STE_1_INSTCFG, IVPU_MMU_STE_1_INSTCFG_DATA) | 566263b2ba5SJacek Lawrynowicz FIELD_PREP(IVPU_MMU_STE_1_STRW, IVPU_MMU_STE_1_STRW_NSEL1) | 567263b2ba5SJacek Lawrynowicz FIELD_PREP(IVPU_MMU_STE_1_CONT, IVPU_MMU_STRTAB_CFG_LOG2SIZE) | 568263b2ba5SJacek Lawrynowicz IVPU_MMU_STE_1_MEV | 569263b2ba5SJacek Lawrynowicz IVPU_MMU_STE_1_S1STALLD; 570263b2ba5SJacek Lawrynowicz 571263b2ba5SJacek Lawrynowicz WRITE_ONCE(entry[1], str[1]); 572263b2ba5SJacek Lawrynowicz WRITE_ONCE(entry[0], str[0]); 573263b2ba5SJacek Lawrynowicz 574263b2ba5SJacek Lawrynowicz clflush_cache_range(entry, IVPU_MMU_STRTAB_ENT_SIZE); 575263b2ba5SJacek Lawrynowicz 576263b2ba5SJacek Lawrynowicz ivpu_dbg(vdev, MMU, "STRTAB write entry (SSID=%u): 0x%llx, 0x%llx\n", sid, str[0], str[1]); 577263b2ba5SJacek Lawrynowicz } 578263b2ba5SJacek Lawrynowicz 579263b2ba5SJacek Lawrynowicz static int ivpu_mmu_strtab_init(struct ivpu_device *vdev) 580263b2ba5SJacek Lawrynowicz { 581263b2ba5SJacek Lawrynowicz ivpu_mmu_strtab_link_cd(vdev, IVPU_MMU_STREAM_ID0); 582263b2ba5SJacek Lawrynowicz ivpu_mmu_strtab_link_cd(vdev, IVPU_MMU_STREAM_ID3); 583263b2ba5SJacek Lawrynowicz 584263b2ba5SJacek Lawrynowicz return 0; 585263b2ba5SJacek Lawrynowicz } 586263b2ba5SJacek Lawrynowicz 587263b2ba5SJacek Lawrynowicz int ivpu_mmu_invalidate_tlb(struct ivpu_device *vdev, u16 ssid) 588263b2ba5SJacek Lawrynowicz { 589263b2ba5SJacek Lawrynowicz struct ivpu_mmu_info *mmu = vdev->mmu; 590263b2ba5SJacek Lawrynowicz int ret; 591263b2ba5SJacek Lawrynowicz 592263b2ba5SJacek Lawrynowicz ret = mutex_lock_interruptible(&mmu->lock); 593263b2ba5SJacek Lawrynowicz if (ret) 594263b2ba5SJacek Lawrynowicz return ret; 595263b2ba5SJacek Lawrynowicz 596263b2ba5SJacek Lawrynowicz if (!mmu->on) { 597263b2ba5SJacek Lawrynowicz ret = 0; 598263b2ba5SJacek Lawrynowicz goto unlock; 599263b2ba5SJacek Lawrynowicz } 600263b2ba5SJacek Lawrynowicz 601263b2ba5SJacek Lawrynowicz ret = ivpu_mmu_cmdq_write_tlbi_nh_asid(vdev, ssid); 602263b2ba5SJacek Lawrynowicz if (ret) 603263b2ba5SJacek Lawrynowicz goto unlock; 604263b2ba5SJacek Lawrynowicz 605263b2ba5SJacek Lawrynowicz ret = ivpu_mmu_cmdq_sync(vdev); 606263b2ba5SJacek Lawrynowicz unlock: 607263b2ba5SJacek Lawrynowicz mutex_unlock(&mmu->lock); 608263b2ba5SJacek Lawrynowicz return ret; 609263b2ba5SJacek Lawrynowicz } 610263b2ba5SJacek Lawrynowicz 611263b2ba5SJacek Lawrynowicz static int ivpu_mmu_cd_add(struct ivpu_device *vdev, u32 ssid, u64 cd_dma) 612263b2ba5SJacek Lawrynowicz { 613263b2ba5SJacek Lawrynowicz struct ivpu_mmu_info *mmu = vdev->mmu; 614263b2ba5SJacek Lawrynowicz struct ivpu_mmu_cdtab *cdtab = &mmu->cdtab; 615263b2ba5SJacek Lawrynowicz u64 *entry; 616263b2ba5SJacek Lawrynowicz u64 cd[4]; 617263b2ba5SJacek Lawrynowicz int ret; 618263b2ba5SJacek Lawrynowicz 619263b2ba5SJacek Lawrynowicz if (ssid > IVPU_MMU_CDTAB_ENT_COUNT) 620263b2ba5SJacek Lawrynowicz return -EINVAL; 621263b2ba5SJacek Lawrynowicz 622263b2ba5SJacek Lawrynowicz entry = cdtab->base + (ssid * IVPU_MMU_CDTAB_ENT_SIZE); 623263b2ba5SJacek Lawrynowicz 624263b2ba5SJacek Lawrynowicz if (cd_dma != 0) { 625263b2ba5SJacek Lawrynowicz cd[0] = FIELD_PREP(IVPU_MMU_CD_0_TCR_T0SZ, 26) | 626263b2ba5SJacek Lawrynowicz FIELD_PREP(IVPU_MMU_CD_0_TCR_TG0, 0) | 627263b2ba5SJacek Lawrynowicz FIELD_PREP(IVPU_MMU_CD_0_TCR_IRGN0, 0) | 628263b2ba5SJacek Lawrynowicz FIELD_PREP(IVPU_MMU_CD_0_TCR_ORGN0, 0) | 629263b2ba5SJacek Lawrynowicz FIELD_PREP(IVPU_MMU_CD_0_TCR_SH0, 0) | 630263b2ba5SJacek Lawrynowicz FIELD_PREP(IVPU_MMU_CD_0_TCR_IPS, 3) | 631263b2ba5SJacek Lawrynowicz FIELD_PREP(IVPU_MMU_CD_0_ASID, ssid) | 632263b2ba5SJacek Lawrynowicz IVPU_MMU_CD_0_TCR_EPD1 | 633263b2ba5SJacek Lawrynowicz IVPU_MMU_CD_0_AA64 | 634263b2ba5SJacek Lawrynowicz IVPU_MMU_CD_0_R | 635263b2ba5SJacek Lawrynowicz IVPU_MMU_CD_0_ASET | 636263b2ba5SJacek Lawrynowicz IVPU_MMU_CD_0_V; 637263b2ba5SJacek Lawrynowicz cd[1] = cd_dma & IVPU_MMU_CD_1_TTB0_MASK; 638263b2ba5SJacek Lawrynowicz cd[2] = 0; 639263b2ba5SJacek Lawrynowicz cd[3] = 0x0000000000007444; 640263b2ba5SJacek Lawrynowicz 641263b2ba5SJacek Lawrynowicz /* For global context generate memory fault on VPU */ 642263b2ba5SJacek Lawrynowicz if (ssid == IVPU_GLOBAL_CONTEXT_MMU_SSID) 643263b2ba5SJacek Lawrynowicz cd[0] |= IVPU_MMU_CD_0_A; 644263b2ba5SJacek Lawrynowicz } else { 645263b2ba5SJacek Lawrynowicz memset(cd, 0, sizeof(cd)); 646263b2ba5SJacek Lawrynowicz } 647263b2ba5SJacek Lawrynowicz 648263b2ba5SJacek Lawrynowicz WRITE_ONCE(entry[1], cd[1]); 649263b2ba5SJacek Lawrynowicz WRITE_ONCE(entry[2], cd[2]); 650263b2ba5SJacek Lawrynowicz WRITE_ONCE(entry[3], cd[3]); 651263b2ba5SJacek Lawrynowicz WRITE_ONCE(entry[0], cd[0]); 652263b2ba5SJacek Lawrynowicz 653263b2ba5SJacek Lawrynowicz clflush_cache_range(entry, IVPU_MMU_CDTAB_ENT_SIZE); 654263b2ba5SJacek Lawrynowicz 655263b2ba5SJacek Lawrynowicz ivpu_dbg(vdev, MMU, "CDTAB %s entry (SSID=%u, dma=%pad): 0x%llx, 0x%llx, 0x%llx, 0x%llx\n", 656263b2ba5SJacek Lawrynowicz cd_dma ? "write" : "clear", ssid, &cd_dma, cd[0], cd[1], cd[2], cd[3]); 657263b2ba5SJacek Lawrynowicz 658263b2ba5SJacek Lawrynowicz ret = mutex_lock_interruptible(&mmu->lock); 659263b2ba5SJacek Lawrynowicz if (ret) 660263b2ba5SJacek Lawrynowicz return ret; 661263b2ba5SJacek Lawrynowicz 662263b2ba5SJacek Lawrynowicz if (!mmu->on) { 663263b2ba5SJacek Lawrynowicz ret = 0; 664263b2ba5SJacek Lawrynowicz goto unlock; 665263b2ba5SJacek Lawrynowicz } 666263b2ba5SJacek Lawrynowicz 667263b2ba5SJacek Lawrynowicz ret = ivpu_mmu_cmdq_write_cfgi_all(vdev); 668263b2ba5SJacek Lawrynowicz if (ret) 669263b2ba5SJacek Lawrynowicz goto unlock; 670263b2ba5SJacek Lawrynowicz 671263b2ba5SJacek Lawrynowicz ret = ivpu_mmu_cmdq_sync(vdev); 672263b2ba5SJacek Lawrynowicz unlock: 673263b2ba5SJacek Lawrynowicz mutex_unlock(&mmu->lock); 674263b2ba5SJacek Lawrynowicz return ret; 675263b2ba5SJacek Lawrynowicz } 676263b2ba5SJacek Lawrynowicz 677263b2ba5SJacek Lawrynowicz static int ivpu_mmu_cd_add_gbl(struct ivpu_device *vdev) 678263b2ba5SJacek Lawrynowicz { 679263b2ba5SJacek Lawrynowicz int ret; 680263b2ba5SJacek Lawrynowicz 681263b2ba5SJacek Lawrynowicz ret = ivpu_mmu_cd_add(vdev, 0, vdev->gctx.pgtable.pgd_dma); 682263b2ba5SJacek Lawrynowicz if (ret) 683263b2ba5SJacek Lawrynowicz ivpu_err(vdev, "Failed to add global CD entry: %d\n", ret); 684263b2ba5SJacek Lawrynowicz 685263b2ba5SJacek Lawrynowicz return ret; 686263b2ba5SJacek Lawrynowicz } 687263b2ba5SJacek Lawrynowicz 688263b2ba5SJacek Lawrynowicz static int ivpu_mmu_cd_add_user(struct ivpu_device *vdev, u32 ssid, dma_addr_t cd_dma) 689263b2ba5SJacek Lawrynowicz { 690263b2ba5SJacek Lawrynowicz int ret; 691263b2ba5SJacek Lawrynowicz 692263b2ba5SJacek Lawrynowicz if (ssid == 0) { 693263b2ba5SJacek Lawrynowicz ivpu_err(vdev, "Invalid SSID: %u\n", ssid); 694263b2ba5SJacek Lawrynowicz return -EINVAL; 695263b2ba5SJacek Lawrynowicz } 696263b2ba5SJacek Lawrynowicz 697263b2ba5SJacek Lawrynowicz ret = ivpu_mmu_cd_add(vdev, ssid, cd_dma); 698263b2ba5SJacek Lawrynowicz if (ret) 699263b2ba5SJacek Lawrynowicz ivpu_err(vdev, "Failed to add CD entry SSID=%u: %d\n", ssid, ret); 700263b2ba5SJacek Lawrynowicz 701263b2ba5SJacek Lawrynowicz return ret; 702263b2ba5SJacek Lawrynowicz } 703263b2ba5SJacek Lawrynowicz 704263b2ba5SJacek Lawrynowicz int ivpu_mmu_init(struct ivpu_device *vdev) 705263b2ba5SJacek Lawrynowicz { 706263b2ba5SJacek Lawrynowicz struct ivpu_mmu_info *mmu = vdev->mmu; 707263b2ba5SJacek Lawrynowicz int ret; 708263b2ba5SJacek Lawrynowicz 709263b2ba5SJacek Lawrynowicz ivpu_dbg(vdev, MMU, "Init..\n"); 710263b2ba5SJacek Lawrynowicz 711263b2ba5SJacek Lawrynowicz drmm_mutex_init(&vdev->drm, &mmu->lock); 712263b2ba5SJacek Lawrynowicz ivpu_mmu_config_check(vdev); 713263b2ba5SJacek Lawrynowicz 714263b2ba5SJacek Lawrynowicz ret = ivpu_mmu_structs_alloc(vdev); 715263b2ba5SJacek Lawrynowicz if (ret) 716263b2ba5SJacek Lawrynowicz return ret; 717263b2ba5SJacek Lawrynowicz 718263b2ba5SJacek Lawrynowicz ret = ivpu_mmu_strtab_init(vdev); 719263b2ba5SJacek Lawrynowicz if (ret) { 720263b2ba5SJacek Lawrynowicz ivpu_err(vdev, "Failed to initialize strtab: %d\n", ret); 721263b2ba5SJacek Lawrynowicz return ret; 722263b2ba5SJacek Lawrynowicz } 723263b2ba5SJacek Lawrynowicz 724263b2ba5SJacek Lawrynowicz ret = ivpu_mmu_cd_add_gbl(vdev); 725263b2ba5SJacek Lawrynowicz if (ret) { 726263b2ba5SJacek Lawrynowicz ivpu_err(vdev, "Failed to initialize strtab: %d\n", ret); 727263b2ba5SJacek Lawrynowicz return ret; 728263b2ba5SJacek Lawrynowicz } 729263b2ba5SJacek Lawrynowicz 730263b2ba5SJacek Lawrynowicz ret = ivpu_mmu_enable(vdev); 731263b2ba5SJacek Lawrynowicz if (ret) { 732263b2ba5SJacek Lawrynowicz ivpu_err(vdev, "Failed to resume MMU: %d\n", ret); 733263b2ba5SJacek Lawrynowicz return ret; 734263b2ba5SJacek Lawrynowicz } 735263b2ba5SJacek Lawrynowicz 736263b2ba5SJacek Lawrynowicz ivpu_dbg(vdev, MMU, "Init done\n"); 737263b2ba5SJacek Lawrynowicz 738263b2ba5SJacek Lawrynowicz return 0; 739263b2ba5SJacek Lawrynowicz } 740263b2ba5SJacek Lawrynowicz 741263b2ba5SJacek Lawrynowicz int ivpu_mmu_enable(struct ivpu_device *vdev) 742263b2ba5SJacek Lawrynowicz { 743263b2ba5SJacek Lawrynowicz struct ivpu_mmu_info *mmu = vdev->mmu; 744263b2ba5SJacek Lawrynowicz int ret; 745263b2ba5SJacek Lawrynowicz 746263b2ba5SJacek Lawrynowicz mutex_lock(&mmu->lock); 747263b2ba5SJacek Lawrynowicz 748263b2ba5SJacek Lawrynowicz mmu->on = true; 749263b2ba5SJacek Lawrynowicz 750263b2ba5SJacek Lawrynowicz ret = ivpu_mmu_reset(vdev); 751263b2ba5SJacek Lawrynowicz if (ret) { 752263b2ba5SJacek Lawrynowicz ivpu_err(vdev, "Failed to reset MMU: %d\n", ret); 753263b2ba5SJacek Lawrynowicz goto err; 754263b2ba5SJacek Lawrynowicz } 755263b2ba5SJacek Lawrynowicz 756263b2ba5SJacek Lawrynowicz ret = ivpu_mmu_cmdq_write_cfgi_all(vdev); 757263b2ba5SJacek Lawrynowicz if (ret) 758263b2ba5SJacek Lawrynowicz goto err; 759263b2ba5SJacek Lawrynowicz 760263b2ba5SJacek Lawrynowicz ret = ivpu_mmu_cmdq_write_tlbi_nsnh_all(vdev); 761263b2ba5SJacek Lawrynowicz if (ret) 762263b2ba5SJacek Lawrynowicz goto err; 763263b2ba5SJacek Lawrynowicz 764263b2ba5SJacek Lawrynowicz ret = ivpu_mmu_cmdq_sync(vdev); 765263b2ba5SJacek Lawrynowicz if (ret) 766263b2ba5SJacek Lawrynowicz goto err; 767263b2ba5SJacek Lawrynowicz 768263b2ba5SJacek Lawrynowicz mutex_unlock(&mmu->lock); 769263b2ba5SJacek Lawrynowicz 770263b2ba5SJacek Lawrynowicz return 0; 771263b2ba5SJacek Lawrynowicz err: 772263b2ba5SJacek Lawrynowicz mmu->on = false; 773263b2ba5SJacek Lawrynowicz mutex_unlock(&mmu->lock); 774263b2ba5SJacek Lawrynowicz return ret; 775263b2ba5SJacek Lawrynowicz } 776263b2ba5SJacek Lawrynowicz 777263b2ba5SJacek Lawrynowicz void ivpu_mmu_disable(struct ivpu_device *vdev) 778263b2ba5SJacek Lawrynowicz { 779263b2ba5SJacek Lawrynowicz struct ivpu_mmu_info *mmu = vdev->mmu; 780263b2ba5SJacek Lawrynowicz 781263b2ba5SJacek Lawrynowicz mutex_lock(&mmu->lock); 782263b2ba5SJacek Lawrynowicz mmu->on = false; 783263b2ba5SJacek Lawrynowicz mutex_unlock(&mmu->lock); 784263b2ba5SJacek Lawrynowicz } 785263b2ba5SJacek Lawrynowicz 786263b2ba5SJacek Lawrynowicz static void ivpu_mmu_dump_event(struct ivpu_device *vdev, u32 *event) 787263b2ba5SJacek Lawrynowicz { 788263b2ba5SJacek Lawrynowicz u32 ssid = FIELD_GET(IVPU_MMU_EVT_SSID_MASK, event[0]); 789263b2ba5SJacek Lawrynowicz u32 op = FIELD_GET(IVPU_MMU_EVT_OP_MASK, event[0]); 790263b2ba5SJacek Lawrynowicz u64 fetch_addr = ((u64)event[7]) << 32 | event[6]; 791263b2ba5SJacek Lawrynowicz u64 in_addr = ((u64)event[5]) << 32 | event[4]; 792263b2ba5SJacek Lawrynowicz u32 sid = event[1]; 793263b2ba5SJacek Lawrynowicz 794263b2ba5SJacek Lawrynowicz ivpu_err(vdev, "MMU EVTQ: 0x%x (%s) SSID: %d SID: %d, e[2] %08x, e[3] %08x, in addr: 0x%llx, fetch addr: 0x%llx\n", 795263b2ba5SJacek Lawrynowicz op, ivpu_mmu_event_to_str(op), ssid, sid, event[2], event[3], in_addr, fetch_addr); 796263b2ba5SJacek Lawrynowicz } 797263b2ba5SJacek Lawrynowicz 798263b2ba5SJacek Lawrynowicz static u32 *ivpu_mmu_get_event(struct ivpu_device *vdev) 799263b2ba5SJacek Lawrynowicz { 800263b2ba5SJacek Lawrynowicz struct ivpu_mmu_queue *evtq = &vdev->mmu->evtq; 801263b2ba5SJacek Lawrynowicz u32 idx = IVPU_MMU_Q_IDX(evtq->cons); 802263b2ba5SJacek Lawrynowicz u32 *evt = evtq->base + (idx * IVPU_MMU_EVTQ_CMD_SIZE); 803263b2ba5SJacek Lawrynowicz 804263b2ba5SJacek Lawrynowicz evtq->prod = REGV_RD32(MTL_VPU_HOST_MMU_EVTQ_PROD_SEC); 805263b2ba5SJacek Lawrynowicz if (!CIRC_CNT(IVPU_MMU_Q_IDX(evtq->prod), IVPU_MMU_Q_IDX(evtq->cons), IVPU_MMU_Q_COUNT)) 806263b2ba5SJacek Lawrynowicz return NULL; 807263b2ba5SJacek Lawrynowicz 808263b2ba5SJacek Lawrynowicz clflush_cache_range(evt, IVPU_MMU_EVTQ_CMD_SIZE); 809263b2ba5SJacek Lawrynowicz 810263b2ba5SJacek Lawrynowicz evtq->cons = (evtq->cons + 1) & IVPU_MMU_Q_WRAP_MASK; 811263b2ba5SJacek Lawrynowicz REGV_WR32(MTL_VPU_HOST_MMU_EVTQ_CONS_SEC, evtq->cons); 812263b2ba5SJacek Lawrynowicz 813263b2ba5SJacek Lawrynowicz return evt; 814263b2ba5SJacek Lawrynowicz } 815263b2ba5SJacek Lawrynowicz 816263b2ba5SJacek Lawrynowicz void ivpu_mmu_irq_evtq_handler(struct ivpu_device *vdev) 817263b2ba5SJacek Lawrynowicz { 818*852be13fSJacek Lawrynowicz bool schedule_recovery = false; 819263b2ba5SJacek Lawrynowicz u32 *event; 820263b2ba5SJacek Lawrynowicz u32 ssid; 821263b2ba5SJacek Lawrynowicz 822263b2ba5SJacek Lawrynowicz ivpu_dbg(vdev, IRQ, "MMU event queue\n"); 823263b2ba5SJacek Lawrynowicz 824263b2ba5SJacek Lawrynowicz while ((event = ivpu_mmu_get_event(vdev)) != NULL) { 825263b2ba5SJacek Lawrynowicz ivpu_mmu_dump_event(vdev, event); 826263b2ba5SJacek Lawrynowicz 827263b2ba5SJacek Lawrynowicz ssid = FIELD_GET(IVPU_MMU_EVT_SSID_MASK, event[0]); 828*852be13fSJacek Lawrynowicz if (ssid == IVPU_GLOBAL_CONTEXT_MMU_SSID) 829*852be13fSJacek Lawrynowicz schedule_recovery = true; 830*852be13fSJacek Lawrynowicz else 831263b2ba5SJacek Lawrynowicz ivpu_mmu_user_context_mark_invalid(vdev, ssid); 832263b2ba5SJacek Lawrynowicz } 833*852be13fSJacek Lawrynowicz 834*852be13fSJacek Lawrynowicz if (schedule_recovery) 835*852be13fSJacek Lawrynowicz ivpu_pm_schedule_recovery(vdev); 836263b2ba5SJacek Lawrynowicz } 837263b2ba5SJacek Lawrynowicz 838263b2ba5SJacek Lawrynowicz void ivpu_mmu_irq_gerr_handler(struct ivpu_device *vdev) 839263b2ba5SJacek Lawrynowicz { 840263b2ba5SJacek Lawrynowicz u32 gerror_val, gerrorn_val, active; 841263b2ba5SJacek Lawrynowicz 842263b2ba5SJacek Lawrynowicz ivpu_dbg(vdev, IRQ, "MMU error\n"); 843263b2ba5SJacek Lawrynowicz 844263b2ba5SJacek Lawrynowicz gerror_val = REGV_RD32(MTL_VPU_HOST_MMU_GERROR); 845263b2ba5SJacek Lawrynowicz gerrorn_val = REGV_RD32(MTL_VPU_HOST_MMU_GERRORN); 846263b2ba5SJacek Lawrynowicz 847263b2ba5SJacek Lawrynowicz active = gerror_val ^ gerrorn_val; 848263b2ba5SJacek Lawrynowicz if (!(active & IVPU_MMU_GERROR_ERR_MASK)) 849263b2ba5SJacek Lawrynowicz return; 850263b2ba5SJacek Lawrynowicz 851263b2ba5SJacek Lawrynowicz if (REG_TEST_FLD(MTL_VPU_HOST_MMU_GERROR, MSI_ABT, active)) 852263b2ba5SJacek Lawrynowicz ivpu_warn_ratelimited(vdev, "MMU MSI ABT write aborted\n"); 853263b2ba5SJacek Lawrynowicz 854263b2ba5SJacek Lawrynowicz if (REG_TEST_FLD(MTL_VPU_HOST_MMU_GERROR, MSI_PRIQ_ABT, active)) 855263b2ba5SJacek Lawrynowicz ivpu_warn_ratelimited(vdev, "MMU PRIQ MSI ABT write aborted\n"); 856263b2ba5SJacek Lawrynowicz 857263b2ba5SJacek Lawrynowicz if (REG_TEST_FLD(MTL_VPU_HOST_MMU_GERROR, MSI_EVTQ_ABT, active)) 858263b2ba5SJacek Lawrynowicz ivpu_warn_ratelimited(vdev, "MMU EVTQ MSI ABT write aborted\n"); 859263b2ba5SJacek Lawrynowicz 860263b2ba5SJacek Lawrynowicz if (REG_TEST_FLD(MTL_VPU_HOST_MMU_GERROR, MSI_CMDQ_ABT, active)) 861263b2ba5SJacek Lawrynowicz ivpu_warn_ratelimited(vdev, "MMU CMDQ MSI ABT write aborted\n"); 862263b2ba5SJacek Lawrynowicz 863263b2ba5SJacek Lawrynowicz if (REG_TEST_FLD(MTL_VPU_HOST_MMU_GERROR, PRIQ_ABT, active)) 864263b2ba5SJacek Lawrynowicz ivpu_err_ratelimited(vdev, "MMU PRIQ write aborted\n"); 865263b2ba5SJacek Lawrynowicz 866263b2ba5SJacek Lawrynowicz if (REG_TEST_FLD(MTL_VPU_HOST_MMU_GERROR, EVTQ_ABT, active)) 867263b2ba5SJacek Lawrynowicz ivpu_err_ratelimited(vdev, "MMU EVTQ write aborted\n"); 868263b2ba5SJacek Lawrynowicz 869263b2ba5SJacek Lawrynowicz if (REG_TEST_FLD(MTL_VPU_HOST_MMU_GERROR, CMDQ, active)) 870263b2ba5SJacek Lawrynowicz ivpu_err_ratelimited(vdev, "MMU CMDQ write aborted\n"); 871263b2ba5SJacek Lawrynowicz 872263b2ba5SJacek Lawrynowicz REGV_WR32(MTL_VPU_HOST_MMU_GERRORN, gerror_val); 873263b2ba5SJacek Lawrynowicz } 874263b2ba5SJacek Lawrynowicz 875263b2ba5SJacek Lawrynowicz int ivpu_mmu_set_pgtable(struct ivpu_device *vdev, int ssid, struct ivpu_mmu_pgtable *pgtable) 876263b2ba5SJacek Lawrynowicz { 877263b2ba5SJacek Lawrynowicz return ivpu_mmu_cd_add_user(vdev, ssid, pgtable->pgd_dma); 878263b2ba5SJacek Lawrynowicz } 879263b2ba5SJacek Lawrynowicz 880263b2ba5SJacek Lawrynowicz void ivpu_mmu_clear_pgtable(struct ivpu_device *vdev, int ssid) 881263b2ba5SJacek Lawrynowicz { 882263b2ba5SJacek Lawrynowicz ivpu_mmu_cd_add_user(vdev, ssid, 0); /* 0 will clear CD entry */ 883263b2ba5SJacek Lawrynowicz } 884