1da71b7e3SCédric Le Goater /* 2da71b7e3SCédric Le Goater * QEMU PowerPC XIVE2 interrupt controller model (POWER10) 3da71b7e3SCédric Le Goater * 4da71b7e3SCédric Le Goater * Copyright (c) 2019-2022, IBM Corporation. 5da71b7e3SCédric Le Goater * 6da71b7e3SCédric Le Goater * This code is licensed under the GPL version 2 or later. See the 7da71b7e3SCédric Le Goater * COPYING file in the top-level directory. 8da71b7e3SCédric Le Goater */ 9da71b7e3SCédric Le Goater 10da71b7e3SCédric Le Goater #include "qemu/osdep.h" 11da71b7e3SCédric Le Goater #include "qemu/log.h" 12da71b7e3SCédric Le Goater #include "qapi/error.h" 13da71b7e3SCédric Le Goater #include "target/ppc/cpu.h" 14da71b7e3SCédric Le Goater #include "sysemu/cpus.h" 15da71b7e3SCédric Le Goater #include "sysemu/dma.h" 16da71b7e3SCédric Le Goater #include "hw/ppc/fdt.h" 17da71b7e3SCédric Le Goater #include "hw/ppc/pnv.h" 182c6fe2e2SMarkus Armbruster #include "hw/ppc/pnv_chip.h" 19da71b7e3SCédric Le Goater #include "hw/ppc/pnv_core.h" 20da71b7e3SCédric Le Goater #include "hw/ppc/pnv_xscom.h" 21da71b7e3SCédric Le Goater #include "hw/ppc/xive2.h" 22da71b7e3SCédric Le Goater #include "hw/ppc/pnv_xive.h" 23da71b7e3SCédric Le Goater #include "hw/ppc/xive_regs.h" 24da71b7e3SCédric Le Goater #include "hw/ppc/xive2_regs.h" 25da71b7e3SCédric Le Goater #include "hw/ppc/ppc.h" 26da71b7e3SCédric Le Goater #include "hw/qdev-properties.h" 27da71b7e3SCédric Le Goater #include "sysemu/reset.h" 2876125c01SNicholas Piggin #include "sysemu/qtest.h" 29da71b7e3SCédric Le Goater 30da71b7e3SCédric Le Goater #include <libfdt.h> 31da71b7e3SCédric Le Goater 32da71b7e3SCédric Le Goater #include "pnv_xive2_regs.h" 33da71b7e3SCédric Le Goater 34da71b7e3SCédric Le Goater #undef XIVE2_DEBUG 35da71b7e3SCédric Le Goater 3676125c01SNicholas Piggin /* XIVE Sync or Flush Notification Block */ 3776125c01SNicholas Piggin typedef struct XiveSfnBlock { 3876125c01SNicholas Piggin uint8_t bytes[32]; 3976125c01SNicholas Piggin } XiveSfnBlock; 4076125c01SNicholas Piggin 4176125c01SNicholas Piggin /* XIVE Thread Sync or Flush Notification Area */ 4276125c01SNicholas Piggin typedef struct XiveThreadNA { 4376125c01SNicholas Piggin XiveSfnBlock topo[16]; 4476125c01SNicholas Piggin } XiveThreadNA; 4576125c01SNicholas Piggin 46da71b7e3SCédric Le Goater /* 47da71b7e3SCédric Le Goater * Virtual structures table (VST) 48da71b7e3SCédric Le Goater */ 49da71b7e3SCédric Le Goater #define SBE_PER_BYTE 4 50da71b7e3SCédric Le Goater 51da71b7e3SCédric Le Goater typedef struct XiveVstInfo { 52da71b7e3SCédric Le Goater const char *name; 53da71b7e3SCédric Le Goater uint32_t size; 54da71b7e3SCédric Le Goater uint32_t max_blocks; 55da71b7e3SCédric Le Goater } XiveVstInfo; 56da71b7e3SCédric Le Goater 57da71b7e3SCédric Le Goater static const XiveVstInfo vst_infos[] = { 58da71b7e3SCédric Le Goater 59da71b7e3SCédric Le Goater [VST_EAS] = { "EAT", sizeof(Xive2Eas), 16 }, 60da71b7e3SCédric Le Goater [VST_ESB] = { "ESB", 1, 16 }, 61da71b7e3SCédric Le Goater [VST_END] = { "ENDT", sizeof(Xive2End), 16 }, 62da71b7e3SCédric Le Goater 63da71b7e3SCédric Le Goater [VST_NVP] = { "NVPT", sizeof(Xive2Nvp), 16 }, 64da71b7e3SCédric Le Goater [VST_NVG] = { "NVGT", sizeof(Xive2Nvgc), 16 }, 65da71b7e3SCédric Le Goater [VST_NVC] = { "NVCT", sizeof(Xive2Nvgc), 16 }, 66da71b7e3SCédric Le Goater 6764770efdSMichael Kowal [VST_IC] = { "IC", 1, /* ? */ 16 }, /* Topology # */ 6876125c01SNicholas Piggin [VST_SYNC] = { "SYNC", sizeof(XiveThreadNA), 16 }, /* Topology # */ 69da71b7e3SCédric Le Goater 70da71b7e3SCédric Le Goater /* 71da71b7e3SCédric Le Goater * This table contains the backing store pages for the interrupt 72da71b7e3SCédric Le Goater * fifos of the VC sub-engine in case of overflow. 73da71b7e3SCédric Le Goater * 74da71b7e3SCédric Le Goater * 0 - IPI, 75da71b7e3SCédric Le Goater * 1 - HWD, 76da71b7e3SCédric Le Goater * 2 - NxC, 77da71b7e3SCédric Le Goater * 3 - INT, 78da71b7e3SCédric Le Goater * 4 - OS-Queue, 79da71b7e3SCédric Le Goater * 5 - Pool-Queue, 80da71b7e3SCédric Le Goater * 6 - Hard-Queue 81da71b7e3SCédric Le Goater */ 82da71b7e3SCédric Le Goater [VST_ERQ] = { "ERQ", 1, VC_QUEUE_COUNT }, 83da71b7e3SCédric Le Goater }; 84da71b7e3SCédric Le Goater 85da71b7e3SCédric Le Goater #define xive2_error(xive, fmt, ...) \ 86da71b7e3SCédric Le Goater qemu_log_mask(LOG_GUEST_ERROR, "XIVE[%x] - " fmt "\n", \ 87da71b7e3SCédric Le Goater (xive)->chip->chip_id, ## __VA_ARGS__); 88da71b7e3SCédric Le Goater 89da71b7e3SCédric Le Goater /* 90da71b7e3SCédric Le Goater * TODO: Document block id override 91da71b7e3SCédric Le Goater */ 92da71b7e3SCédric Le Goater static uint32_t pnv_xive2_block_id(PnvXive2 *xive) 93da71b7e3SCédric Le Goater { 94da71b7e3SCédric Le Goater uint8_t blk = xive->chip->chip_id; 95da71b7e3SCédric Le Goater uint64_t cfg_val = xive->cq_regs[CQ_XIVE_CFG >> 3]; 96da71b7e3SCédric Le Goater 97da71b7e3SCédric Le Goater if (cfg_val & CQ_XIVE_CFG_HYP_HARD_BLKID_OVERRIDE) { 98da71b7e3SCédric Le Goater blk = GETFIELD(CQ_XIVE_CFG_HYP_HARD_BLOCK_ID, cfg_val); 99da71b7e3SCédric Le Goater } 100da71b7e3SCédric Le Goater 101da71b7e3SCédric Le Goater return blk; 102da71b7e3SCédric Le Goater } 103da71b7e3SCédric Le Goater 104da71b7e3SCédric Le Goater /* 105da71b7e3SCédric Le Goater * Remote access to controllers. HW uses MMIOs. For now, a simple scan 106da71b7e3SCédric Le Goater * of the chips is good enough. 107da71b7e3SCédric Le Goater * 108da71b7e3SCédric Le Goater * TODO: Block scope support 109da71b7e3SCédric Le Goater */ 110da71b7e3SCédric Le Goater static PnvXive2 *pnv_xive2_get_remote(uint8_t blk) 111da71b7e3SCédric Le Goater { 112da71b7e3SCédric Le Goater PnvMachineState *pnv = PNV_MACHINE(qdev_get_machine()); 113da71b7e3SCédric Le Goater int i; 114da71b7e3SCédric Le Goater 115da71b7e3SCédric Le Goater for (i = 0; i < pnv->num_chips; i++) { 116da71b7e3SCédric Le Goater Pnv10Chip *chip10 = PNV10_CHIP(pnv->chips[i]); 117da71b7e3SCédric Le Goater PnvXive2 *xive = &chip10->xive; 118da71b7e3SCédric Le Goater 119da71b7e3SCédric Le Goater if (pnv_xive2_block_id(xive) == blk) { 120da71b7e3SCédric Le Goater return xive; 121da71b7e3SCédric Le Goater } 122da71b7e3SCédric Le Goater } 123da71b7e3SCédric Le Goater return NULL; 124da71b7e3SCédric Le Goater } 125da71b7e3SCédric Le Goater 126da71b7e3SCédric Le Goater /* 127da71b7e3SCédric Le Goater * VST accessors for ESB, EAT, ENDT, NVP 128da71b7e3SCédric Le Goater * 129da71b7e3SCédric Le Goater * Indirect VST tables are arrays of VSDs pointing to a page (of same 130da71b7e3SCédric Le Goater * size). Each page is a direct VST table. 131da71b7e3SCédric Le Goater */ 132da71b7e3SCédric Le Goater 133da71b7e3SCédric Le Goater #define XIVE_VSD_SIZE 8 134da71b7e3SCédric Le Goater 135da71b7e3SCédric Le Goater /* Indirect page size can be 4K, 64K, 2M, 16M. */ 136da71b7e3SCédric Le Goater static uint64_t pnv_xive2_vst_page_size_allowed(uint32_t page_shift) 137da71b7e3SCédric Le Goater { 138da71b7e3SCédric Le Goater return page_shift == 12 || page_shift == 16 || 139da71b7e3SCédric Le Goater page_shift == 21 || page_shift == 24; 140da71b7e3SCédric Le Goater } 141da71b7e3SCédric Le Goater 142da71b7e3SCédric Le Goater static uint64_t pnv_xive2_vst_addr_direct(PnvXive2 *xive, uint32_t type, 143da71b7e3SCédric Le Goater uint64_t vsd, uint32_t idx) 144da71b7e3SCédric Le Goater { 145da71b7e3SCédric Le Goater const XiveVstInfo *info = &vst_infos[type]; 146da71b7e3SCédric Le Goater uint64_t vst_addr = vsd & VSD_ADDRESS_MASK; 147da71b7e3SCédric Le Goater uint64_t vst_tsize = 1ull << (GETFIELD(VSD_TSIZE, vsd) + 12); 148da71b7e3SCédric Le Goater uint32_t idx_max; 149da71b7e3SCédric Le Goater 150da71b7e3SCédric Le Goater idx_max = vst_tsize / info->size - 1; 151da71b7e3SCédric Le Goater if (idx > idx_max) { 152da71b7e3SCédric Le Goater #ifdef XIVE2_DEBUG 153da71b7e3SCédric Le Goater xive2_error(xive, "VST: %s entry %x out of range [ 0 .. %x ] !?", 154da71b7e3SCédric Le Goater info->name, idx, idx_max); 155da71b7e3SCédric Le Goater #endif 156da71b7e3SCédric Le Goater return 0; 157da71b7e3SCédric Le Goater } 158da71b7e3SCédric Le Goater 159da71b7e3SCédric Le Goater return vst_addr + idx * info->size; 160da71b7e3SCédric Le Goater } 161da71b7e3SCédric Le Goater 162da71b7e3SCédric Le Goater static uint64_t pnv_xive2_vst_addr_indirect(PnvXive2 *xive, uint32_t type, 163da71b7e3SCédric Le Goater uint64_t vsd, uint32_t idx) 164da71b7e3SCédric Le Goater { 165da71b7e3SCédric Le Goater const XiveVstInfo *info = &vst_infos[type]; 166da71b7e3SCédric Le Goater uint64_t vsd_addr; 167da71b7e3SCédric Le Goater uint32_t vsd_idx; 168da71b7e3SCédric Le Goater uint32_t page_shift; 169da71b7e3SCédric Le Goater uint32_t vst_per_page; 170da71b7e3SCédric Le Goater 171da71b7e3SCédric Le Goater /* Get the page size of the indirect table. */ 172da71b7e3SCédric Le Goater vsd_addr = vsd & VSD_ADDRESS_MASK; 173da71b7e3SCédric Le Goater ldq_be_dma(&address_space_memory, vsd_addr, &vsd, MEMTXATTRS_UNSPECIFIED); 174da71b7e3SCédric Le Goater 175da71b7e3SCédric Le Goater if (!(vsd & VSD_ADDRESS_MASK)) { 17634b43130SFrederic Barrat #ifdef XIVE2_DEBUG 177da71b7e3SCédric Le Goater xive2_error(xive, "VST: invalid %s entry %x !?", info->name, idx); 17834b43130SFrederic Barrat #endif 179da71b7e3SCédric Le Goater return 0; 180da71b7e3SCédric Le Goater } 181da71b7e3SCédric Le Goater 182da71b7e3SCédric Le Goater page_shift = GETFIELD(VSD_TSIZE, vsd) + 12; 183da71b7e3SCédric Le Goater 184da71b7e3SCédric Le Goater if (!pnv_xive2_vst_page_size_allowed(page_shift)) { 185da71b7e3SCédric Le Goater xive2_error(xive, "VST: invalid %s page shift %d", info->name, 186da71b7e3SCédric Le Goater page_shift); 187da71b7e3SCédric Le Goater return 0; 188da71b7e3SCédric Le Goater } 189da71b7e3SCédric Le Goater 190da71b7e3SCédric Le Goater vst_per_page = (1ull << page_shift) / info->size; 191da71b7e3SCédric Le Goater vsd_idx = idx / vst_per_page; 192da71b7e3SCédric Le Goater 193da71b7e3SCédric Le Goater /* Load the VSD we are looking for, if not already done */ 194da71b7e3SCédric Le Goater if (vsd_idx) { 195da71b7e3SCédric Le Goater vsd_addr = vsd_addr + vsd_idx * XIVE_VSD_SIZE; 196da71b7e3SCédric Le Goater ldq_be_dma(&address_space_memory, vsd_addr, &vsd, 197da71b7e3SCédric Le Goater MEMTXATTRS_UNSPECIFIED); 198da71b7e3SCédric Le Goater 199da71b7e3SCédric Le Goater if (!(vsd & VSD_ADDRESS_MASK)) { 20034b43130SFrederic Barrat #ifdef XIVE2_DEBUG 201da71b7e3SCédric Le Goater xive2_error(xive, "VST: invalid %s entry %x !?", info->name, idx); 20234b43130SFrederic Barrat #endif 203da71b7e3SCédric Le Goater return 0; 204da71b7e3SCédric Le Goater } 205da71b7e3SCédric Le Goater 206da71b7e3SCédric Le Goater /* 207da71b7e3SCédric Le Goater * Check that the pages have a consistent size across the 208da71b7e3SCédric Le Goater * indirect table 209da71b7e3SCédric Le Goater */ 210da71b7e3SCédric Le Goater if (page_shift != GETFIELD(VSD_TSIZE, vsd) + 12) { 211da71b7e3SCédric Le Goater xive2_error(xive, "VST: %s entry %x indirect page size differ !?", 212da71b7e3SCédric Le Goater info->name, idx); 213da71b7e3SCédric Le Goater return 0; 214da71b7e3SCédric Le Goater } 215da71b7e3SCédric Le Goater } 216da71b7e3SCédric Le Goater 217da71b7e3SCédric Le Goater return pnv_xive2_vst_addr_direct(xive, type, vsd, (idx % vst_per_page)); 218da71b7e3SCédric Le Goater } 219da71b7e3SCédric Le Goater 2209d7188a2SFrederic Barrat static uint8_t pnv_xive2_nvc_table_compress_shift(PnvXive2 *xive) 2219d7188a2SFrederic Barrat { 2229d7188a2SFrederic Barrat uint8_t shift = GETFIELD(PC_NXC_PROC_CONFIG_NVC_TABLE_COMPRESS, 2239d7188a2SFrederic Barrat xive->pc_regs[PC_NXC_PROC_CONFIG >> 3]); 2249d7188a2SFrederic Barrat return shift > 8 ? 0 : shift; 2259d7188a2SFrederic Barrat } 2269d7188a2SFrederic Barrat 2279d7188a2SFrederic Barrat static uint8_t pnv_xive2_nvg_table_compress_shift(PnvXive2 *xive) 2289d7188a2SFrederic Barrat { 2299d7188a2SFrederic Barrat uint8_t shift = GETFIELD(PC_NXC_PROC_CONFIG_NVG_TABLE_COMPRESS, 2309d7188a2SFrederic Barrat xive->pc_regs[PC_NXC_PROC_CONFIG >> 3]); 2319d7188a2SFrederic Barrat return shift > 8 ? 0 : shift; 2329d7188a2SFrederic Barrat } 2339d7188a2SFrederic Barrat 234da71b7e3SCédric Le Goater static uint64_t pnv_xive2_vst_addr(PnvXive2 *xive, uint32_t type, uint8_t blk, 235da71b7e3SCédric Le Goater uint32_t idx) 236da71b7e3SCédric Le Goater { 237da71b7e3SCédric Le Goater const XiveVstInfo *info = &vst_infos[type]; 238da71b7e3SCédric Le Goater uint64_t vsd; 239da71b7e3SCédric Le Goater 240da71b7e3SCédric Le Goater if (blk >= info->max_blocks) { 241da71b7e3SCédric Le Goater xive2_error(xive, "VST: invalid block id %d for VST %s %d !?", 242da71b7e3SCédric Le Goater blk, info->name, idx); 243da71b7e3SCédric Le Goater return 0; 244da71b7e3SCédric Le Goater } 245da71b7e3SCédric Le Goater 246da71b7e3SCédric Le Goater vsd = xive->vsds[type][blk]; 247fa414eb6SFrederic Barrat if (vsd == 0) { 248fa414eb6SFrederic Barrat xive2_error(xive, "VST: vsd == 0 block id %d for VST %s %d !?", 249fa414eb6SFrederic Barrat blk, info->name, idx); 250fa414eb6SFrederic Barrat return 0; 251fa414eb6SFrederic Barrat } 252da71b7e3SCédric Le Goater 253da71b7e3SCédric Le Goater /* Remote VST access */ 254da71b7e3SCédric Le Goater if (GETFIELD(VSD_MODE, vsd) == VSD_MODE_FORWARD) { 255da71b7e3SCédric Le Goater xive = pnv_xive2_get_remote(blk); 256da71b7e3SCédric Le Goater 257da71b7e3SCédric Le Goater return xive ? pnv_xive2_vst_addr(xive, type, blk, idx) : 0; 258da71b7e3SCédric Le Goater } 259da71b7e3SCédric Le Goater 2609d7188a2SFrederic Barrat if (type == VST_NVG) { 2619d7188a2SFrederic Barrat idx >>= pnv_xive2_nvg_table_compress_shift(xive); 2629d7188a2SFrederic Barrat } else if (type == VST_NVC) { 2639d7188a2SFrederic Barrat idx >>= pnv_xive2_nvc_table_compress_shift(xive); 2649d7188a2SFrederic Barrat } 2659d7188a2SFrederic Barrat 266da71b7e3SCédric Le Goater if (VSD_INDIRECT & vsd) { 267da71b7e3SCédric Le Goater return pnv_xive2_vst_addr_indirect(xive, type, vsd, idx); 268da71b7e3SCédric Le Goater } 269da71b7e3SCédric Le Goater 270da71b7e3SCédric Le Goater return pnv_xive2_vst_addr_direct(xive, type, vsd, idx); 271da71b7e3SCédric Le Goater } 272da71b7e3SCédric Le Goater 273da71b7e3SCédric Le Goater static int pnv_xive2_vst_read(PnvXive2 *xive, uint32_t type, uint8_t blk, 274da71b7e3SCédric Le Goater uint32_t idx, void *data) 275da71b7e3SCédric Le Goater { 276da71b7e3SCédric Le Goater const XiveVstInfo *info = &vst_infos[type]; 277da71b7e3SCédric Le Goater uint64_t addr = pnv_xive2_vst_addr(xive, type, blk, idx); 278ed409be1SCédric Le Goater MemTxResult result; 279da71b7e3SCédric Le Goater 280da71b7e3SCédric Le Goater if (!addr) { 281da71b7e3SCédric Le Goater return -1; 282da71b7e3SCédric Le Goater } 283da71b7e3SCédric Le Goater 284ed409be1SCédric Le Goater result = address_space_read(&address_space_memory, addr, 285ed409be1SCédric Le Goater MEMTXATTRS_UNSPECIFIED, data, 286ed409be1SCédric Le Goater info->size); 287ed409be1SCédric Le Goater if (result != MEMTX_OK) { 288ed409be1SCédric Le Goater xive2_error(xive, "VST: read failed at @0x%" HWADDR_PRIx 289ed409be1SCédric Le Goater " for VST %s %x/%x\n", addr, info->name, blk, idx); 290ed409be1SCédric Le Goater return -1; 291ed409be1SCédric Le Goater } 292da71b7e3SCédric Le Goater return 0; 293da71b7e3SCédric Le Goater } 294da71b7e3SCédric Le Goater 295da71b7e3SCédric Le Goater #define XIVE_VST_WORD_ALL -1 296da71b7e3SCédric Le Goater 297da71b7e3SCédric Le Goater static int pnv_xive2_vst_write(PnvXive2 *xive, uint32_t type, uint8_t blk, 298da71b7e3SCédric Le Goater uint32_t idx, void *data, uint32_t word_number) 299da71b7e3SCédric Le Goater { 300da71b7e3SCédric Le Goater const XiveVstInfo *info = &vst_infos[type]; 301da71b7e3SCédric Le Goater uint64_t addr = pnv_xive2_vst_addr(xive, type, blk, idx); 302ed409be1SCédric Le Goater MemTxResult result; 303da71b7e3SCédric Le Goater 304da71b7e3SCédric Le Goater if (!addr) { 305da71b7e3SCédric Le Goater return -1; 306da71b7e3SCédric Le Goater } 307da71b7e3SCédric Le Goater 308da71b7e3SCédric Le Goater if (word_number == XIVE_VST_WORD_ALL) { 309ed409be1SCédric Le Goater result = address_space_write(&address_space_memory, addr, 310ed409be1SCédric Le Goater MEMTXATTRS_UNSPECIFIED, data, 311ed409be1SCédric Le Goater info->size); 312da71b7e3SCédric Le Goater } else { 313ed409be1SCédric Le Goater result = address_space_write(&address_space_memory, 314ed409be1SCédric Le Goater addr + word_number * 4, 315ed409be1SCédric Le Goater MEMTXATTRS_UNSPECIFIED, 316da71b7e3SCédric Le Goater data + word_number * 4, 4); 317da71b7e3SCédric Le Goater } 318ed409be1SCédric Le Goater 319ed409be1SCédric Le Goater if (result != MEMTX_OK) { 320ed409be1SCédric Le Goater xive2_error(xive, "VST: write failed at @0x%" HWADDR_PRIx 321ed409be1SCédric Le Goater "for VST %s %x/%x\n", addr, info->name, blk, idx); 322ed409be1SCédric Le Goater return -1; 323ed409be1SCédric Le Goater } 324da71b7e3SCédric Le Goater return 0; 325da71b7e3SCédric Le Goater } 326da71b7e3SCédric Le Goater 3270aa2612aSCédric Le Goater static int pnv_xive2_get_pq(Xive2Router *xrtr, uint8_t blk, uint32_t idx, 3280aa2612aSCédric Le Goater uint8_t *pq) 3290aa2612aSCédric Le Goater { 3300aa2612aSCédric Le Goater PnvXive2 *xive = PNV_XIVE2(xrtr); 3310aa2612aSCédric Le Goater 3320aa2612aSCédric Le Goater if (pnv_xive2_block_id(xive) != blk) { 3330aa2612aSCédric Le Goater xive2_error(xive, "VST: EAS %x is remote !?", XIVE_EAS(blk, idx)); 3340aa2612aSCédric Le Goater return -1; 3350aa2612aSCédric Le Goater } 3360aa2612aSCédric Le Goater 3370aa2612aSCédric Le Goater *pq = xive_source_esb_get(&xive->ipi_source, idx); 3380aa2612aSCédric Le Goater return 0; 3390aa2612aSCédric Le Goater } 3400aa2612aSCédric Le Goater 3410aa2612aSCédric Le Goater static int pnv_xive2_set_pq(Xive2Router *xrtr, uint8_t blk, uint32_t idx, 3420aa2612aSCédric Le Goater uint8_t *pq) 3430aa2612aSCédric Le Goater { 3440aa2612aSCédric Le Goater PnvXive2 *xive = PNV_XIVE2(xrtr); 3450aa2612aSCédric Le Goater 3460aa2612aSCédric Le Goater if (pnv_xive2_block_id(xive) != blk) { 3470aa2612aSCédric Le Goater xive2_error(xive, "VST: EAS %x is remote !?", XIVE_EAS(blk, idx)); 3480aa2612aSCédric Le Goater return -1; 3490aa2612aSCédric Le Goater } 3500aa2612aSCédric Le Goater 3510aa2612aSCédric Le Goater *pq = xive_source_esb_set(&xive->ipi_source, idx, *pq); 3520aa2612aSCédric Le Goater return 0; 3530aa2612aSCédric Le Goater } 3540aa2612aSCédric Le Goater 355da71b7e3SCédric Le Goater static int pnv_xive2_get_end(Xive2Router *xrtr, uint8_t blk, uint32_t idx, 356da71b7e3SCédric Le Goater Xive2End *end) 357da71b7e3SCédric Le Goater { 358da71b7e3SCédric Le Goater return pnv_xive2_vst_read(PNV_XIVE2(xrtr), VST_END, blk, idx, end); 359da71b7e3SCédric Le Goater } 360da71b7e3SCédric Le Goater 361da71b7e3SCédric Le Goater static int pnv_xive2_write_end(Xive2Router *xrtr, uint8_t blk, uint32_t idx, 362da71b7e3SCédric Le Goater Xive2End *end, uint8_t word_number) 363da71b7e3SCédric Le Goater { 364da71b7e3SCédric Le Goater return pnv_xive2_vst_write(PNV_XIVE2(xrtr), VST_END, blk, idx, end, 365da71b7e3SCédric Le Goater word_number); 366da71b7e3SCédric Le Goater } 367da71b7e3SCédric Le Goater 36876125c01SNicholas Piggin static inline int pnv_xive2_get_current_pir(PnvXive2 *xive) 36976125c01SNicholas Piggin { 37076125c01SNicholas Piggin if (!qtest_enabled()) { 37176125c01SNicholas Piggin PowerPCCPU *cpu = POWERPC_CPU(current_cpu); 37276125c01SNicholas Piggin return ppc_cpu_pir(cpu); 37376125c01SNicholas Piggin } 37476125c01SNicholas Piggin return 0; 37576125c01SNicholas Piggin } 37676125c01SNicholas Piggin 37776125c01SNicholas Piggin /* 37876125c01SNicholas Piggin * After SW injects a Queue Sync or Cache Flush operation, HW will notify 37976125c01SNicholas Piggin * SW of the completion of the operation by writing a byte of all 1's (0xff) 38076125c01SNicholas Piggin * to a specific memory location. The memory location is calculated by first 38176125c01SNicholas Piggin * looking up a base address in the SYNC VSD using the Topology ID of the 38276125c01SNicholas Piggin * originating thread as the "block" number. This points to a 38376125c01SNicholas Piggin * 64k block of memory that is further divided into 128 512 byte chunks of 38476125c01SNicholas Piggin * memory, which is indexed by the thread id of the requesting thread. 38576125c01SNicholas Piggin * Finally, this 512 byte chunk of memory is divided into 16 32 byte 38676125c01SNicholas Piggin * chunks which are indexed by the topology id of the targeted IC's chip. 38776125c01SNicholas Piggin * The values below are the offsets into that 32 byte chunk of memory for 38876125c01SNicholas Piggin * each type of cache flush or queue sync operation. 38976125c01SNicholas Piggin */ 39076125c01SNicholas Piggin #define PNV_XIVE2_QUEUE_IPI 0x00 39176125c01SNicholas Piggin #define PNV_XIVE2_QUEUE_HW 0x01 39276125c01SNicholas Piggin #define PNV_XIVE2_QUEUE_NXC 0x02 39376125c01SNicholas Piggin #define PNV_XIVE2_QUEUE_INT 0x03 39476125c01SNicholas Piggin #define PNV_XIVE2_QUEUE_OS 0x04 39576125c01SNicholas Piggin #define PNV_XIVE2_QUEUE_POOL 0x05 39676125c01SNicholas Piggin #define PNV_XIVE2_QUEUE_HARD 0x06 39776125c01SNicholas Piggin #define PNV_XIVE2_CACHE_ENDC 0x08 39876125c01SNicholas Piggin #define PNV_XIVE2_CACHE_ESBC 0x09 39976125c01SNicholas Piggin #define PNV_XIVE2_CACHE_EASC 0x0a 40076125c01SNicholas Piggin #define PNV_XIVE2_QUEUE_NXC_LD_LCL_NCO 0x10 40176125c01SNicholas Piggin #define PNV_XIVE2_QUEUE_NXC_LD_LCL_CO 0x11 40276125c01SNicholas Piggin #define PNV_XIVE2_QUEUE_NXC_ST_LCL_NCI 0x12 40376125c01SNicholas Piggin #define PNV_XIVE2_QUEUE_NXC_ST_LCL_CI 0x13 40476125c01SNicholas Piggin #define PNV_XIVE2_QUEUE_NXC_ST_RMT_NCI 0x14 40576125c01SNicholas Piggin #define PNV_XIVE2_QUEUE_NXC_ST_RMT_CI 0x15 40676125c01SNicholas Piggin #define PNV_XIVE2_CACHE_NXC 0x18 40776125c01SNicholas Piggin 40876125c01SNicholas Piggin static int pnv_xive2_inject_notify(PnvXive2 *xive, int type) 40976125c01SNicholas Piggin { 41076125c01SNicholas Piggin uint64_t addr; 41176125c01SNicholas Piggin int pir = pnv_xive2_get_current_pir(xive); 41276125c01SNicholas Piggin int thread_nr = PNV10_PIR2THREAD(pir); 41376125c01SNicholas Piggin int thread_topo_id = PNV10_PIR2CHIP(pir); 41476125c01SNicholas Piggin int ic_topo_id = xive->chip->chip_id; 41576125c01SNicholas Piggin uint64_t offset = ic_topo_id * sizeof(XiveSfnBlock); 41676125c01SNicholas Piggin uint8_t byte = 0xff; 41776125c01SNicholas Piggin MemTxResult result; 41876125c01SNicholas Piggin 41976125c01SNicholas Piggin /* Retrieve the address of requesting thread's notification area */ 42076125c01SNicholas Piggin addr = pnv_xive2_vst_addr(xive, VST_SYNC, thread_topo_id, thread_nr); 42176125c01SNicholas Piggin 42276125c01SNicholas Piggin if (!addr) { 42376125c01SNicholas Piggin xive2_error(xive, "VST: no SYNC entry %x/%x !?", 42476125c01SNicholas Piggin thread_topo_id, thread_nr); 42576125c01SNicholas Piggin return -1; 42676125c01SNicholas Piggin } 42776125c01SNicholas Piggin 42876125c01SNicholas Piggin address_space_stb(&address_space_memory, addr + offset + type, byte, 42976125c01SNicholas Piggin MEMTXATTRS_UNSPECIFIED, &result); 43076125c01SNicholas Piggin assert(result == MEMTX_OK); 43176125c01SNicholas Piggin 43276125c01SNicholas Piggin return 0; 43376125c01SNicholas Piggin } 43476125c01SNicholas Piggin 4358c01b2e1SFrederic Barrat static int pnv_xive2_end_update(PnvXive2 *xive, uint8_t watch_engine) 436da71b7e3SCédric Le Goater { 4378c01b2e1SFrederic Barrat uint8_t blk; 4388c01b2e1SFrederic Barrat uint32_t idx; 4398c01b2e1SFrederic Barrat int i, spec_reg, data_reg; 440da71b7e3SCédric Le Goater uint64_t endc_watch[4]; 441da71b7e3SCédric Le Goater 4428c01b2e1SFrederic Barrat assert(watch_engine < ARRAY_SIZE(endc_watch)); 4438c01b2e1SFrederic Barrat 4448c01b2e1SFrederic Barrat spec_reg = (VC_ENDC_WATCH0_SPEC + watch_engine * 0x40) >> 3; 4458c01b2e1SFrederic Barrat data_reg = (VC_ENDC_WATCH0_DATA0 + watch_engine * 0x40) >> 3; 4468c01b2e1SFrederic Barrat blk = GETFIELD(VC_ENDC_WATCH_BLOCK_ID, xive->vc_regs[spec_reg]); 4478c01b2e1SFrederic Barrat idx = GETFIELD(VC_ENDC_WATCH_INDEX, xive->vc_regs[spec_reg]); 4488c01b2e1SFrederic Barrat 449da71b7e3SCédric Le Goater for (i = 0; i < ARRAY_SIZE(endc_watch); i++) { 4508c01b2e1SFrederic Barrat endc_watch[i] = cpu_to_be64(xive->vc_regs[data_reg + i]); 451da71b7e3SCédric Le Goater } 452da71b7e3SCédric Le Goater 453da71b7e3SCédric Le Goater return pnv_xive2_vst_write(xive, VST_END, blk, idx, endc_watch, 454da71b7e3SCédric Le Goater XIVE_VST_WORD_ALL); 455da71b7e3SCédric Le Goater } 456da71b7e3SCédric Le Goater 4578c01b2e1SFrederic Barrat static void pnv_xive2_end_cache_load(PnvXive2 *xive, uint8_t watch_engine) 458da71b7e3SCédric Le Goater { 4598c01b2e1SFrederic Barrat uint8_t blk; 4608c01b2e1SFrederic Barrat uint32_t idx; 461da71b7e3SCédric Le Goater uint64_t endc_watch[4] = { 0 }; 4628c01b2e1SFrederic Barrat int i, spec_reg, data_reg; 4638c01b2e1SFrederic Barrat 4648c01b2e1SFrederic Barrat assert(watch_engine < ARRAY_SIZE(endc_watch)); 4658c01b2e1SFrederic Barrat 4668c01b2e1SFrederic Barrat spec_reg = (VC_ENDC_WATCH0_SPEC + watch_engine * 0x40) >> 3; 4678c01b2e1SFrederic Barrat data_reg = (VC_ENDC_WATCH0_DATA0 + watch_engine * 0x40) >> 3; 4688c01b2e1SFrederic Barrat blk = GETFIELD(VC_ENDC_WATCH_BLOCK_ID, xive->vc_regs[spec_reg]); 4698c01b2e1SFrederic Barrat idx = GETFIELD(VC_ENDC_WATCH_INDEX, xive->vc_regs[spec_reg]); 470da71b7e3SCédric Le Goater 471da71b7e3SCédric Le Goater if (pnv_xive2_vst_read(xive, VST_END, blk, idx, endc_watch)) { 472da71b7e3SCédric Le Goater xive2_error(xive, "VST: no END entry %x/%x !?", blk, idx); 473da71b7e3SCédric Le Goater } 474da71b7e3SCédric Le Goater 475da71b7e3SCédric Le Goater for (i = 0; i < ARRAY_SIZE(endc_watch); i++) { 4768c01b2e1SFrederic Barrat xive->vc_regs[data_reg + i] = be64_to_cpu(endc_watch[i]); 477da71b7e3SCédric Le Goater } 478da71b7e3SCédric Le Goater } 479da71b7e3SCédric Le Goater 480da71b7e3SCédric Le Goater static int pnv_xive2_get_nvp(Xive2Router *xrtr, uint8_t blk, uint32_t idx, 481da71b7e3SCédric Le Goater Xive2Nvp *nvp) 482da71b7e3SCédric Le Goater { 483da71b7e3SCédric Le Goater return pnv_xive2_vst_read(PNV_XIVE2(xrtr), VST_NVP, blk, idx, nvp); 484da71b7e3SCédric Le Goater } 485da71b7e3SCédric Le Goater 486da71b7e3SCédric Le Goater static int pnv_xive2_write_nvp(Xive2Router *xrtr, uint8_t blk, uint32_t idx, 487da71b7e3SCédric Le Goater Xive2Nvp *nvp, uint8_t word_number) 488da71b7e3SCédric Le Goater { 489da71b7e3SCédric Le Goater return pnv_xive2_vst_write(PNV_XIVE2(xrtr), VST_NVP, blk, idx, nvp, 490da71b7e3SCédric Le Goater word_number); 491da71b7e3SCédric Le Goater } 492da71b7e3SCédric Le Goater 493*76798e12SFrederic Barrat static int pnv_xive2_get_nvgc(Xive2Router *xrtr, bool crowd, 494*76798e12SFrederic Barrat uint8_t blk, uint32_t idx, 495*76798e12SFrederic Barrat Xive2Nvgc *nvgc) 496*76798e12SFrederic Barrat { 497*76798e12SFrederic Barrat return pnv_xive2_vst_read(PNV_XIVE2(xrtr), crowd ? VST_NVC : VST_NVG, 498*76798e12SFrederic Barrat blk, idx, nvgc); 499*76798e12SFrederic Barrat } 500*76798e12SFrederic Barrat 501*76798e12SFrederic Barrat static int pnv_xive2_write_nvgc(Xive2Router *xrtr, bool crowd, 502*76798e12SFrederic Barrat uint8_t blk, uint32_t idx, 503*76798e12SFrederic Barrat Xive2Nvgc *nvgc) 504*76798e12SFrederic Barrat { 505*76798e12SFrederic Barrat return pnv_xive2_vst_write(PNV_XIVE2(xrtr), crowd ? VST_NVC : VST_NVG, 506*76798e12SFrederic Barrat blk, idx, nvgc, 507*76798e12SFrederic Barrat XIVE_VST_WORD_ALL); 508*76798e12SFrederic Barrat } 509*76798e12SFrederic Barrat 510d6d5f5c0SFrederic Barrat static int pnv_xive2_nxc_to_table_type(uint8_t nxc_type, uint32_t *table_type) 511da71b7e3SCédric Le Goater { 512d6d5f5c0SFrederic Barrat switch (nxc_type) { 513d6d5f5c0SFrederic Barrat case PC_NXC_WATCH_NXC_NVP: 514d6d5f5c0SFrederic Barrat *table_type = VST_NVP; 515d6d5f5c0SFrederic Barrat break; 516d6d5f5c0SFrederic Barrat case PC_NXC_WATCH_NXC_NVG: 517d6d5f5c0SFrederic Barrat *table_type = VST_NVG; 518d6d5f5c0SFrederic Barrat break; 519d6d5f5c0SFrederic Barrat case PC_NXC_WATCH_NXC_NVC: 520d6d5f5c0SFrederic Barrat *table_type = VST_NVC; 521d6d5f5c0SFrederic Barrat break; 522d6d5f5c0SFrederic Barrat default: 523d6d5f5c0SFrederic Barrat qemu_log_mask(LOG_GUEST_ERROR, 524d6d5f5c0SFrederic Barrat "XIVE: invalid table type for nxc operation\n"); 525d6d5f5c0SFrederic Barrat return -1; 526d6d5f5c0SFrederic Barrat } 527d6d5f5c0SFrederic Barrat return 0; 528d6d5f5c0SFrederic Barrat } 529d6d5f5c0SFrederic Barrat 530d6d5f5c0SFrederic Barrat static int pnv_xive2_nxc_update(PnvXive2 *xive, uint8_t watch_engine) 531d6d5f5c0SFrederic Barrat { 532d6d5f5c0SFrederic Barrat uint8_t blk, nxc_type; 533d6d5f5c0SFrederic Barrat uint32_t idx, table_type = -1; 5348c01b2e1SFrederic Barrat int i, spec_reg, data_reg; 535da71b7e3SCédric Le Goater uint64_t nxc_watch[4]; 536da71b7e3SCédric Le Goater 5378c01b2e1SFrederic Barrat assert(watch_engine < ARRAY_SIZE(nxc_watch)); 5388c01b2e1SFrederic Barrat 5398c01b2e1SFrederic Barrat spec_reg = (PC_NXC_WATCH0_SPEC + watch_engine * 0x40) >> 3; 5408c01b2e1SFrederic Barrat data_reg = (PC_NXC_WATCH0_DATA0 + watch_engine * 0x40) >> 3; 541d6d5f5c0SFrederic Barrat nxc_type = GETFIELD(PC_NXC_WATCH_NXC_TYPE, xive->pc_regs[spec_reg]); 5428c01b2e1SFrederic Barrat blk = GETFIELD(PC_NXC_WATCH_BLOCK_ID, xive->pc_regs[spec_reg]); 5438c01b2e1SFrederic Barrat idx = GETFIELD(PC_NXC_WATCH_INDEX, xive->pc_regs[spec_reg]); 5448c01b2e1SFrederic Barrat 545d6d5f5c0SFrederic Barrat assert(!pnv_xive2_nxc_to_table_type(nxc_type, &table_type)); 546d6d5f5c0SFrederic Barrat 547da71b7e3SCédric Le Goater for (i = 0; i < ARRAY_SIZE(nxc_watch); i++) { 5488c01b2e1SFrederic Barrat nxc_watch[i] = cpu_to_be64(xive->pc_regs[data_reg + i]); 549da71b7e3SCédric Le Goater } 550da71b7e3SCédric Le Goater 551d6d5f5c0SFrederic Barrat return pnv_xive2_vst_write(xive, table_type, blk, idx, nxc_watch, 552da71b7e3SCédric Le Goater XIVE_VST_WORD_ALL); 553da71b7e3SCédric Le Goater } 554da71b7e3SCédric Le Goater 555d6d5f5c0SFrederic Barrat static void pnv_xive2_nxc_cache_load(PnvXive2 *xive, uint8_t watch_engine) 556da71b7e3SCédric Le Goater { 557d6d5f5c0SFrederic Barrat uint8_t blk, nxc_type; 558d6d5f5c0SFrederic Barrat uint32_t idx, table_type = -1; 559da71b7e3SCédric Le Goater uint64_t nxc_watch[4] = { 0 }; 5608c01b2e1SFrederic Barrat int i, spec_reg, data_reg; 5618c01b2e1SFrederic Barrat 5628c01b2e1SFrederic Barrat assert(watch_engine < ARRAY_SIZE(nxc_watch)); 5638c01b2e1SFrederic Barrat 5648c01b2e1SFrederic Barrat spec_reg = (PC_NXC_WATCH0_SPEC + watch_engine * 0x40) >> 3; 5658c01b2e1SFrederic Barrat data_reg = (PC_NXC_WATCH0_DATA0 + watch_engine * 0x40) >> 3; 566d6d5f5c0SFrederic Barrat nxc_type = GETFIELD(PC_NXC_WATCH_NXC_TYPE, xive->pc_regs[spec_reg]); 5678c01b2e1SFrederic Barrat blk = GETFIELD(PC_NXC_WATCH_BLOCK_ID, xive->pc_regs[spec_reg]); 5688c01b2e1SFrederic Barrat idx = GETFIELD(PC_NXC_WATCH_INDEX, xive->pc_regs[spec_reg]); 569da71b7e3SCédric Le Goater 570d6d5f5c0SFrederic Barrat assert(!pnv_xive2_nxc_to_table_type(nxc_type, &table_type)); 571d6d5f5c0SFrederic Barrat 572d6d5f5c0SFrederic Barrat if (pnv_xive2_vst_read(xive, table_type, blk, idx, nxc_watch)) { 573d6d5f5c0SFrederic Barrat xive2_error(xive, "VST: no NXC entry %x/%x in %s table!?", 574d6d5f5c0SFrederic Barrat blk, idx, vst_infos[table_type].name); 575da71b7e3SCédric Le Goater } 576da71b7e3SCédric Le Goater 577da71b7e3SCédric Le Goater for (i = 0; i < ARRAY_SIZE(nxc_watch); i++) { 5788c01b2e1SFrederic Barrat xive->pc_regs[data_reg + i] = be64_to_cpu(nxc_watch[i]); 579da71b7e3SCédric Le Goater } 580da71b7e3SCédric Le Goater } 581da71b7e3SCédric Le Goater 582da71b7e3SCédric Le Goater static int pnv_xive2_get_eas(Xive2Router *xrtr, uint8_t blk, uint32_t idx, 583da71b7e3SCédric Le Goater Xive2Eas *eas) 584da71b7e3SCédric Le Goater { 585da71b7e3SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(xrtr); 586da71b7e3SCédric Le Goater 587da71b7e3SCédric Le Goater if (pnv_xive2_block_id(xive) != blk) { 588da71b7e3SCédric Le Goater xive2_error(xive, "VST: EAS %x is remote !?", XIVE_EAS(blk, idx)); 589da71b7e3SCédric Le Goater return -1; 590da71b7e3SCédric Le Goater } 591da71b7e3SCédric Le Goater 592da71b7e3SCédric Le Goater return pnv_xive2_vst_read(xive, VST_EAS, blk, idx, eas); 593da71b7e3SCédric Le Goater } 594da71b7e3SCédric Le Goater 595e16032b8SCédric Le Goater static uint32_t pnv_xive2_get_config(Xive2Router *xrtr) 596e16032b8SCédric Le Goater { 597e16032b8SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(xrtr); 598e16032b8SCédric Le Goater uint32_t cfg = 0; 599e16032b8SCédric Le Goater 600e16032b8SCédric Le Goater if (xive->cq_regs[CQ_XIVE_CFG >> 3] & CQ_XIVE_CFG_GEN1_TIMA_OS) { 601e16032b8SCédric Le Goater cfg |= XIVE2_GEN1_TIMA_OS; 602e16032b8SCédric Le Goater } 603e16032b8SCédric Le Goater 604835806f1SCédric Le Goater if (xive->cq_regs[CQ_XIVE_CFG >> 3] & CQ_XIVE_CFG_EN_VP_SAVE_RESTORE) { 605835806f1SCédric Le Goater cfg |= XIVE2_VP_SAVE_RESTORE; 606835806f1SCédric Le Goater } 607835806f1SCédric Le Goater 60809a7e60cSCédric Le Goater if (GETFIELD(CQ_XIVE_CFG_HYP_HARD_RANGE, 60909a7e60cSCédric Le Goater xive->cq_regs[CQ_XIVE_CFG >> 3]) == CQ_XIVE_CFG_THREADID_8BITS) { 61009a7e60cSCédric Le Goater cfg |= XIVE2_THREADID_8BITS; 61109a7e60cSCédric Le Goater } 61209a7e60cSCédric Le Goater 613e16032b8SCédric Le Goater return cfg; 614e16032b8SCédric Le Goater } 615e16032b8SCédric Le Goater 616da71b7e3SCédric Le Goater static bool pnv_xive2_is_cpu_enabled(PnvXive2 *xive, PowerPCCPU *cpu) 617da71b7e3SCédric Le Goater { 618da71b7e3SCédric Le Goater int pir = ppc_cpu_pir(cpu); 619da71b7e3SCédric Le Goater uint32_t fc = PNV10_PIR2FUSEDCORE(pir); 620da71b7e3SCédric Le Goater uint64_t reg = fc < 8 ? TCTXT_EN0 : TCTXT_EN1; 621da71b7e3SCédric Le Goater uint32_t bit = pir & 0x3f; 622da71b7e3SCédric Le Goater 623da71b7e3SCédric Le Goater return xive->tctxt_regs[reg >> 3] & PPC_BIT(bit); 624da71b7e3SCédric Le Goater } 625da71b7e3SCédric Le Goater 626da71b7e3SCédric Le Goater static int pnv_xive2_match_nvt(XivePresenter *xptr, uint8_t format, 627da71b7e3SCédric Le Goater uint8_t nvt_blk, uint32_t nvt_idx, 628da71b7e3SCédric Le Goater bool cam_ignore, uint8_t priority, 629da71b7e3SCédric Le Goater uint32_t logic_serv, XiveTCTXMatch *match) 630da71b7e3SCédric Le Goater { 631da71b7e3SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(xptr); 632da71b7e3SCédric Le Goater PnvChip *chip = xive->chip; 633da71b7e3SCédric Le Goater int count = 0; 634da71b7e3SCédric Le Goater int i, j; 635747ffe28SCédric Le Goater bool gen1_tima_os = 636747ffe28SCédric Le Goater xive->cq_regs[CQ_XIVE_CFG >> 3] & CQ_XIVE_CFG_GEN1_TIMA_OS; 637da71b7e3SCédric Le Goater 638da71b7e3SCédric Le Goater for (i = 0; i < chip->nr_cores; i++) { 639da71b7e3SCédric Le Goater PnvCore *pc = chip->cores[i]; 640da71b7e3SCédric Le Goater CPUCore *cc = CPU_CORE(pc); 641da71b7e3SCédric Le Goater 642da71b7e3SCédric Le Goater for (j = 0; j < cc->nr_threads; j++) { 643da71b7e3SCédric Le Goater PowerPCCPU *cpu = pc->threads[j]; 644da71b7e3SCédric Le Goater XiveTCTX *tctx; 645da71b7e3SCédric Le Goater int ring; 646da71b7e3SCédric Le Goater 647da71b7e3SCédric Le Goater if (!pnv_xive2_is_cpu_enabled(xive, cpu)) { 648da71b7e3SCédric Le Goater continue; 649da71b7e3SCédric Le Goater } 650da71b7e3SCédric Le Goater 651da71b7e3SCédric Le Goater tctx = XIVE_TCTX(pnv_cpu_state(cpu)->intc); 652da71b7e3SCédric Le Goater 653747ffe28SCédric Le Goater if (gen1_tima_os) { 654747ffe28SCédric Le Goater ring = xive_presenter_tctx_match(xptr, tctx, format, nvt_blk, 655747ffe28SCédric Le Goater nvt_idx, cam_ignore, 656747ffe28SCédric Le Goater logic_serv); 657747ffe28SCédric Le Goater } else { 658da71b7e3SCédric Le Goater ring = xive2_presenter_tctx_match(xptr, tctx, format, nvt_blk, 659da71b7e3SCédric Le Goater nvt_idx, cam_ignore, 660da71b7e3SCédric Le Goater logic_serv); 661747ffe28SCédric Le Goater } 662da71b7e3SCédric Le Goater 663da71b7e3SCédric Le Goater /* 664da71b7e3SCédric Le Goater * Save the context and follow on to catch duplicates, 665da71b7e3SCédric Le Goater * that we don't support yet. 666da71b7e3SCédric Le Goater */ 667da71b7e3SCédric Le Goater if (ring != -1) { 668da71b7e3SCédric Le Goater if (match->tctx) { 669da71b7e3SCédric Le Goater qemu_log_mask(LOG_GUEST_ERROR, "XIVE: already found a " 670da71b7e3SCédric Le Goater "thread context NVT %x/%x\n", 671da71b7e3SCédric Le Goater nvt_blk, nvt_idx); 672da71b7e3SCédric Le Goater return false; 673da71b7e3SCédric Le Goater } 674da71b7e3SCédric Le Goater 675da71b7e3SCédric Le Goater match->ring = ring; 676da71b7e3SCédric Le Goater match->tctx = tctx; 677da71b7e3SCédric Le Goater count++; 678da71b7e3SCédric Le Goater } 679da71b7e3SCédric Le Goater } 680da71b7e3SCédric Le Goater } 681da71b7e3SCédric Le Goater 682da71b7e3SCédric Le Goater return count; 683da71b7e3SCédric Le Goater } 684da71b7e3SCédric Le Goater 6852a24e6e3SFrederic Barrat static uint32_t pnv_xive2_presenter_get_config(XivePresenter *xptr) 6862a24e6e3SFrederic Barrat { 6872a24e6e3SFrederic Barrat PnvXive2 *xive = PNV_XIVE2(xptr); 6882a24e6e3SFrederic Barrat uint32_t cfg = 0; 6892a24e6e3SFrederic Barrat 6902a24e6e3SFrederic Barrat if (xive->cq_regs[CQ_XIVE_CFG >> 3] & CQ_XIVE_CFG_GEN1_TIMA_OS) { 6912a24e6e3SFrederic Barrat cfg |= XIVE_PRESENTER_GEN1_TIMA_OS; 6922a24e6e3SFrederic Barrat } 6932a24e6e3SFrederic Barrat return cfg; 6942a24e6e3SFrederic Barrat } 6952a24e6e3SFrederic Barrat 696da71b7e3SCédric Le Goater static uint8_t pnv_xive2_get_block_id(Xive2Router *xrtr) 697da71b7e3SCédric Le Goater { 698da71b7e3SCédric Le Goater return pnv_xive2_block_id(PNV_XIVE2(xrtr)); 699da71b7e3SCédric Le Goater } 700da71b7e3SCédric Le Goater 701da71b7e3SCédric Le Goater /* 702da71b7e3SCédric Le Goater * The TIMA MMIO space is shared among the chips and to identify the 703da71b7e3SCédric Le Goater * chip from which the access is being done, we extract the chip id 704da71b7e3SCédric Le Goater * from the PIR. 705da71b7e3SCédric Le Goater */ 706da71b7e3SCédric Le Goater static PnvXive2 *pnv_xive2_tm_get_xive(PowerPCCPU *cpu) 707da71b7e3SCédric Le Goater { 708da71b7e3SCédric Le Goater int pir = ppc_cpu_pir(cpu); 709da71b7e3SCédric Le Goater XivePresenter *xptr = XIVE_TCTX(pnv_cpu_state(cpu)->intc)->xptr; 710da71b7e3SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(xptr); 711da71b7e3SCédric Le Goater 712da71b7e3SCédric Le Goater if (!pnv_xive2_is_cpu_enabled(xive, cpu)) { 713da71b7e3SCédric Le Goater xive2_error(xive, "IC: CPU %x is not enabled", pir); 714da71b7e3SCédric Le Goater } 715da71b7e3SCédric Le Goater return xive; 716da71b7e3SCédric Le Goater } 717da71b7e3SCédric Le Goater 718da71b7e3SCédric Le Goater /* 719da71b7e3SCédric Le Goater * The internal sources of the interrupt controller have no knowledge 720da71b7e3SCédric Le Goater * of the XIVE2 chip on which they reside. Encode the block id in the 721da71b7e3SCédric Le Goater * source interrupt number before forwarding the source event 722da71b7e3SCédric Le Goater * notification to the Router. This is required on a multichip system. 723da71b7e3SCédric Le Goater */ 7240aa2612aSCédric Le Goater static void pnv_xive2_notify(XiveNotifier *xn, uint32_t srcno, bool pq_checked) 725da71b7e3SCédric Le Goater { 726da71b7e3SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(xn); 727da71b7e3SCédric Le Goater uint8_t blk = pnv_xive2_block_id(xive); 728da71b7e3SCédric Le Goater 7290aa2612aSCédric Le Goater xive2_router_notify(xn, XIVE_EAS(blk, srcno), pq_checked); 730da71b7e3SCédric Le Goater } 731da71b7e3SCédric Le Goater 732da71b7e3SCédric Le Goater /* 733da71b7e3SCédric Le Goater * Set Translation Tables 734da71b7e3SCédric Le Goater * 735da71b7e3SCédric Le Goater * TODO add support for multiple sets 736da71b7e3SCédric Le Goater */ 737da71b7e3SCédric Le Goater static int pnv_xive2_stt_set_data(PnvXive2 *xive, uint64_t val) 738da71b7e3SCédric Le Goater { 739da71b7e3SCédric Le Goater uint8_t tsel = GETFIELD(CQ_TAR_SELECT, xive->cq_regs[CQ_TAR >> 3]); 740da71b7e3SCédric Le Goater uint8_t entry = GETFIELD(CQ_TAR_ENTRY_SELECT, 741da71b7e3SCédric Le Goater xive->cq_regs[CQ_TAR >> 3]); 742da71b7e3SCédric Le Goater 743da71b7e3SCédric Le Goater switch (tsel) { 744da71b7e3SCédric Le Goater case CQ_TAR_NVPG: 745da71b7e3SCédric Le Goater case CQ_TAR_ESB: 746da71b7e3SCédric Le Goater case CQ_TAR_END: 7474c81813eSFrederic Barrat case CQ_TAR_NVC: 748da71b7e3SCédric Le Goater xive->tables[tsel][entry] = val; 749da71b7e3SCédric Le Goater break; 750da71b7e3SCédric Le Goater default: 751da71b7e3SCédric Le Goater xive2_error(xive, "IC: unsupported table %d", tsel); 752da71b7e3SCédric Le Goater return -1; 753da71b7e3SCédric Le Goater } 754da71b7e3SCédric Le Goater 755da71b7e3SCédric Le Goater if (xive->cq_regs[CQ_TAR >> 3] & CQ_TAR_AUTOINC) { 756da71b7e3SCédric Le Goater xive->cq_regs[CQ_TAR >> 3] = SETFIELD(CQ_TAR_ENTRY_SELECT, 757da71b7e3SCédric Le Goater xive->cq_regs[CQ_TAR >> 3], ++entry); 758da71b7e3SCédric Le Goater } 759da71b7e3SCédric Le Goater 760da71b7e3SCédric Le Goater return 0; 761da71b7e3SCédric Le Goater } 762da71b7e3SCédric Le Goater /* 763da71b7e3SCédric Le Goater * Virtual Structure Tables (VST) configuration 764da71b7e3SCédric Le Goater */ 765da71b7e3SCédric Le Goater static void pnv_xive2_vst_set_exclusive(PnvXive2 *xive, uint8_t type, 766da71b7e3SCédric Le Goater uint8_t blk, uint64_t vsd) 767da71b7e3SCédric Le Goater { 768da71b7e3SCédric Le Goater Xive2EndSource *end_xsrc = &xive->end_source; 769da71b7e3SCédric Le Goater XiveSource *xsrc = &xive->ipi_source; 770da71b7e3SCédric Le Goater const XiveVstInfo *info = &vst_infos[type]; 771da71b7e3SCédric Le Goater uint32_t page_shift = GETFIELD(VSD_TSIZE, vsd) + 12; 772da71b7e3SCédric Le Goater uint64_t vst_tsize = 1ull << page_shift; 773da71b7e3SCédric Le Goater uint64_t vst_addr = vsd & VSD_ADDRESS_MASK; 774da71b7e3SCédric Le Goater 775da71b7e3SCédric Le Goater /* Basic checks */ 776da71b7e3SCédric Le Goater 777da71b7e3SCédric Le Goater if (VSD_INDIRECT & vsd) { 778da71b7e3SCédric Le Goater if (!pnv_xive2_vst_page_size_allowed(page_shift)) { 779da71b7e3SCédric Le Goater xive2_error(xive, "VST: invalid %s page shift %d", info->name, 780da71b7e3SCédric Le Goater page_shift); 781da71b7e3SCédric Le Goater return; 782da71b7e3SCédric Le Goater } 783da71b7e3SCédric Le Goater } 784da71b7e3SCédric Le Goater 785da71b7e3SCédric Le Goater if (!QEMU_IS_ALIGNED(vst_addr, 1ull << page_shift)) { 786da71b7e3SCédric Le Goater xive2_error(xive, "VST: %s table address 0x%"PRIx64 787da71b7e3SCédric Le Goater " is not aligned with page shift %d", 788da71b7e3SCédric Le Goater info->name, vst_addr, page_shift); 789da71b7e3SCédric Le Goater return; 790da71b7e3SCédric Le Goater } 791da71b7e3SCédric Le Goater 792da71b7e3SCédric Le Goater /* Record the table configuration (in SRAM on HW) */ 793da71b7e3SCédric Le Goater xive->vsds[type][blk] = vsd; 794da71b7e3SCédric Le Goater 795da71b7e3SCédric Le Goater /* Now tune the models with the configuration provided by the FW */ 796da71b7e3SCédric Le Goater 797da71b7e3SCédric Le Goater switch (type) { 798da71b7e3SCédric Le Goater case VST_ESB: 799da71b7e3SCédric Le Goater /* 800da71b7e3SCédric Le Goater * Backing store pages for the source PQ bits. The model does 801da71b7e3SCédric Le Goater * not use these PQ bits backed in RAM because the XiveSource 802da71b7e3SCédric Le Goater * model has its own. 803da71b7e3SCédric Le Goater * 804da71b7e3SCédric Le Goater * If the table is direct, we can compute the number of PQ 805da71b7e3SCédric Le Goater * entries provisioned by FW (such as skiboot) and resize the 806da71b7e3SCédric Le Goater * ESB window accordingly. 807da71b7e3SCédric Le Goater */ 8081775b7d1SFrederic Barrat if (memory_region_is_mapped(&xsrc->esb_mmio)) { 8091775b7d1SFrederic Barrat memory_region_del_subregion(&xive->esb_mmio, &xsrc->esb_mmio); 8101775b7d1SFrederic Barrat } 811da71b7e3SCédric Le Goater if (!(VSD_INDIRECT & vsd)) { 812da71b7e3SCédric Le Goater memory_region_set_size(&xsrc->esb_mmio, vst_tsize * SBE_PER_BYTE 813da71b7e3SCédric Le Goater * (1ull << xsrc->esb_shift)); 814da71b7e3SCédric Le Goater } 815da71b7e3SCédric Le Goater 816da71b7e3SCédric Le Goater memory_region_add_subregion(&xive->esb_mmio, 0, &xsrc->esb_mmio); 817da71b7e3SCédric Le Goater break; 818da71b7e3SCédric Le Goater 819da71b7e3SCédric Le Goater case VST_EAS: /* Nothing to be done */ 820da71b7e3SCédric Le Goater break; 821da71b7e3SCédric Le Goater 822da71b7e3SCédric Le Goater case VST_END: 823da71b7e3SCédric Le Goater /* 824da71b7e3SCédric Le Goater * Backing store pages for the END. 825da71b7e3SCédric Le Goater */ 8261775b7d1SFrederic Barrat if (memory_region_is_mapped(&end_xsrc->esb_mmio)) { 8271775b7d1SFrederic Barrat memory_region_del_subregion(&xive->end_mmio, &end_xsrc->esb_mmio); 8281775b7d1SFrederic Barrat } 829da71b7e3SCédric Le Goater if (!(VSD_INDIRECT & vsd)) { 830da71b7e3SCédric Le Goater memory_region_set_size(&end_xsrc->esb_mmio, (vst_tsize / info->size) 831da71b7e3SCédric Le Goater * (1ull << end_xsrc->esb_shift)); 832da71b7e3SCédric Le Goater } 833da71b7e3SCédric Le Goater memory_region_add_subregion(&xive->end_mmio, 0, &end_xsrc->esb_mmio); 834da71b7e3SCédric Le Goater break; 835da71b7e3SCédric Le Goater 836da71b7e3SCédric Le Goater case VST_NVP: /* Not modeled */ 837da71b7e3SCédric Le Goater case VST_NVG: /* Not modeled */ 838da71b7e3SCédric Le Goater case VST_NVC: /* Not modeled */ 839da71b7e3SCédric Le Goater case VST_IC: /* Not modeled */ 840da71b7e3SCédric Le Goater case VST_SYNC: /* Not modeled */ 841da71b7e3SCédric Le Goater case VST_ERQ: /* Not modeled */ 842da71b7e3SCédric Le Goater break; 843da71b7e3SCédric Le Goater 844da71b7e3SCédric Le Goater default: 845da71b7e3SCédric Le Goater g_assert_not_reached(); 846da71b7e3SCédric Le Goater } 847da71b7e3SCédric Le Goater } 848da71b7e3SCédric Le Goater 849da71b7e3SCédric Le Goater /* 850da71b7e3SCédric Le Goater * Both PC and VC sub-engines are configured as each use the Virtual 851da71b7e3SCédric Le Goater * Structure Tables 852da71b7e3SCédric Le Goater */ 8531775b7d1SFrederic Barrat static void pnv_xive2_vst_set_data(PnvXive2 *xive, uint64_t vsd, 8541775b7d1SFrederic Barrat uint8_t type, uint8_t blk) 855da71b7e3SCédric Le Goater { 856da71b7e3SCédric Le Goater uint8_t mode = GETFIELD(VSD_MODE, vsd); 857da71b7e3SCédric Le Goater uint64_t vst_addr = vsd & VSD_ADDRESS_MASK; 858da71b7e3SCédric Le Goater 859da71b7e3SCédric Le Goater if (type > VST_ERQ) { 860da71b7e3SCédric Le Goater xive2_error(xive, "VST: invalid table type %d", type); 861da71b7e3SCédric Le Goater return; 862da71b7e3SCédric Le Goater } 863da71b7e3SCédric Le Goater 864da71b7e3SCédric Le Goater if (blk >= vst_infos[type].max_blocks) { 865da71b7e3SCédric Le Goater xive2_error(xive, "VST: invalid block id %d for" 866da71b7e3SCédric Le Goater " %s table", blk, vst_infos[type].name); 867da71b7e3SCédric Le Goater return; 868da71b7e3SCédric Le Goater } 869da71b7e3SCédric Le Goater 870da71b7e3SCédric Le Goater if (!vst_addr) { 871da71b7e3SCédric Le Goater xive2_error(xive, "VST: invalid %s table address", 872da71b7e3SCédric Le Goater vst_infos[type].name); 873da71b7e3SCédric Le Goater return; 874da71b7e3SCédric Le Goater } 875da71b7e3SCédric Le Goater 876da71b7e3SCédric Le Goater switch (mode) { 877da71b7e3SCédric Le Goater case VSD_MODE_FORWARD: 878da71b7e3SCédric Le Goater xive->vsds[type][blk] = vsd; 879da71b7e3SCédric Le Goater break; 880da71b7e3SCédric Le Goater 881da71b7e3SCédric Le Goater case VSD_MODE_EXCLUSIVE: 882da71b7e3SCédric Le Goater pnv_xive2_vst_set_exclusive(xive, type, blk, vsd); 883da71b7e3SCédric Le Goater break; 884da71b7e3SCédric Le Goater 885da71b7e3SCédric Le Goater default: 886da71b7e3SCédric Le Goater xive2_error(xive, "VST: unsupported table mode %d", mode); 887da71b7e3SCédric Le Goater return; 888da71b7e3SCédric Le Goater } 889da71b7e3SCédric Le Goater } 890da71b7e3SCédric Le Goater 8911775b7d1SFrederic Barrat static void pnv_xive2_vc_vst_set_data(PnvXive2 *xive, uint64_t vsd) 8921775b7d1SFrederic Barrat { 8931775b7d1SFrederic Barrat uint8_t type = GETFIELD(VC_VSD_TABLE_SELECT, 8941775b7d1SFrederic Barrat xive->vc_regs[VC_VSD_TABLE_ADDR >> 3]); 8951775b7d1SFrederic Barrat uint8_t blk = GETFIELD(VC_VSD_TABLE_ADDRESS, 8961775b7d1SFrederic Barrat xive->vc_regs[VC_VSD_TABLE_ADDR >> 3]); 8971775b7d1SFrederic Barrat 8981775b7d1SFrederic Barrat pnv_xive2_vst_set_data(xive, vsd, type, blk); 8991775b7d1SFrederic Barrat } 9001775b7d1SFrederic Barrat 901da71b7e3SCédric Le Goater /* 902da71b7e3SCédric Le Goater * MMIO handlers 903da71b7e3SCédric Le Goater */ 904da71b7e3SCédric Le Goater 905da71b7e3SCédric Le Goater 906da71b7e3SCédric Le Goater /* 907da71b7e3SCédric Le Goater * IC BAR layout 908da71b7e3SCédric Le Goater * 909da71b7e3SCédric Le Goater * Page 0: Internal CQ register accesses (reads & writes) 910da71b7e3SCédric Le Goater * Page 1: Internal PC register accesses (reads & writes) 911da71b7e3SCédric Le Goater * Page 2: Internal VC register accesses (reads & writes) 912da71b7e3SCédric Le Goater * Page 3: Internal TCTXT (TIMA) reg accesses (read & writes) 913da71b7e3SCédric Le Goater * Page 4: Notify Port page (writes only, w/data), 914da71b7e3SCédric Le Goater * Page 5: Reserved 915da71b7e3SCédric Le Goater * Page 6: Sync Poll page (writes only, dataless) 916da71b7e3SCédric Le Goater * Page 7: Sync Inject page (writes only, dataless) 917da71b7e3SCédric Le Goater * Page 8: LSI Trigger page (writes only, dataless) 918da71b7e3SCédric Le Goater * Page 9: LSI SB Management page (reads & writes dataless) 919da71b7e3SCédric Le Goater * Pages 10-255: Reserved 920da71b7e3SCédric Le Goater * Pages 256-383: Direct mapped Thread Context Area (reads & writes) 921da71b7e3SCédric Le Goater * covering the 128 threads in P10. 922da71b7e3SCédric Le Goater * Pages 384-511: Reserved 923da71b7e3SCédric Le Goater */ 924da71b7e3SCédric Le Goater typedef struct PnvXive2Region { 925da71b7e3SCédric Le Goater const char *name; 926da71b7e3SCédric Le Goater uint32_t pgoff; 927da71b7e3SCédric Le Goater uint32_t pgsize; 928da71b7e3SCédric Le Goater const MemoryRegionOps *ops; 929da71b7e3SCédric Le Goater } PnvXive2Region; 930da71b7e3SCédric Le Goater 931da71b7e3SCédric Le Goater static const MemoryRegionOps pnv_xive2_ic_cq_ops; 932da71b7e3SCédric Le Goater static const MemoryRegionOps pnv_xive2_ic_pc_ops; 933da71b7e3SCédric Le Goater static const MemoryRegionOps pnv_xive2_ic_vc_ops; 934da71b7e3SCédric Le Goater static const MemoryRegionOps pnv_xive2_ic_tctxt_ops; 935da71b7e3SCédric Le Goater static const MemoryRegionOps pnv_xive2_ic_notify_ops; 936da71b7e3SCédric Le Goater static const MemoryRegionOps pnv_xive2_ic_sync_ops; 937da71b7e3SCédric Le Goater static const MemoryRegionOps pnv_xive2_ic_lsi_ops; 938da71b7e3SCédric Le Goater static const MemoryRegionOps pnv_xive2_ic_tm_indirect_ops; 939da71b7e3SCédric Le Goater 940da71b7e3SCédric Le Goater /* 512 pages. 4K: 2M range, 64K: 32M range */ 941da71b7e3SCédric Le Goater static const PnvXive2Region pnv_xive2_ic_regions[] = { 942da71b7e3SCédric Le Goater { "xive-ic-cq", 0, 1, &pnv_xive2_ic_cq_ops }, 943da71b7e3SCédric Le Goater { "xive-ic-vc", 1, 1, &pnv_xive2_ic_vc_ops }, 944da71b7e3SCédric Le Goater { "xive-ic-pc", 2, 1, &pnv_xive2_ic_pc_ops }, 945da71b7e3SCédric Le Goater { "xive-ic-tctxt", 3, 1, &pnv_xive2_ic_tctxt_ops }, 946da71b7e3SCédric Le Goater { "xive-ic-notify", 4, 1, &pnv_xive2_ic_notify_ops }, 947da71b7e3SCédric Le Goater /* page 5 reserved */ 948da71b7e3SCédric Le Goater { "xive-ic-sync", 6, 2, &pnv_xive2_ic_sync_ops }, 949da71b7e3SCédric Le Goater { "xive-ic-lsi", 8, 2, &pnv_xive2_ic_lsi_ops }, 950da71b7e3SCédric Le Goater /* pages 10-255 reserved */ 951da71b7e3SCédric Le Goater { "xive-ic-tm-indirect", 256, 128, &pnv_xive2_ic_tm_indirect_ops }, 952da71b7e3SCédric Le Goater /* pages 384-511 reserved */ 953da71b7e3SCédric Le Goater }; 954da71b7e3SCédric Le Goater 955da71b7e3SCédric Le Goater /* 956da71b7e3SCédric Le Goater * CQ operations 957da71b7e3SCédric Le Goater */ 958da71b7e3SCédric Le Goater 959da71b7e3SCédric Le Goater static uint64_t pnv_xive2_ic_cq_read(void *opaque, hwaddr offset, 960da71b7e3SCédric Le Goater unsigned size) 961da71b7e3SCédric Le Goater { 962da71b7e3SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(opaque); 963da71b7e3SCédric Le Goater uint32_t reg = offset >> 3; 964da71b7e3SCédric Le Goater uint64_t val = 0; 965da71b7e3SCédric Le Goater 966da71b7e3SCédric Le Goater switch (offset) { 967da71b7e3SCédric Le Goater case CQ_XIVE_CAP: /* Set at reset */ 968da71b7e3SCédric Le Goater case CQ_XIVE_CFG: 969da71b7e3SCédric Le Goater val = xive->cq_regs[reg]; 970da71b7e3SCédric Le Goater break; 971da71b7e3SCédric Le Goater case CQ_MSGSND: /* TODO check the #cores of the machine */ 972da71b7e3SCédric Le Goater val = 0xffffffff00000000; 973da71b7e3SCédric Le Goater break; 974da71b7e3SCédric Le Goater case CQ_CFG_PB_GEN: 975da71b7e3SCédric Le Goater val = CQ_CFG_PB_GEN_PB_INIT; /* TODO: fix CQ_CFG_PB_GEN default value */ 976da71b7e3SCédric Le Goater break; 977da71b7e3SCédric Le Goater default: 978da71b7e3SCédric Le Goater xive2_error(xive, "CQ: invalid read @%"HWADDR_PRIx, offset); 979da71b7e3SCédric Le Goater } 980da71b7e3SCédric Le Goater 981da71b7e3SCédric Le Goater return val; 982da71b7e3SCédric Le Goater } 983da71b7e3SCédric Le Goater 984da71b7e3SCédric Le Goater static uint64_t pnv_xive2_bar_size(uint64_t val) 985da71b7e3SCédric Le Goater { 986da71b7e3SCédric Le Goater return 1ull << (GETFIELD(CQ_BAR_RANGE, val) + 24); 987da71b7e3SCédric Le Goater } 988da71b7e3SCédric Le Goater 989da71b7e3SCédric Le Goater static void pnv_xive2_ic_cq_write(void *opaque, hwaddr offset, 990da71b7e3SCédric Le Goater uint64_t val, unsigned size) 991da71b7e3SCédric Le Goater { 992da71b7e3SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(opaque); 993da71b7e3SCédric Le Goater MemoryRegion *sysmem = get_system_memory(); 994da71b7e3SCédric Le Goater uint32_t reg = offset >> 3; 995da71b7e3SCédric Le Goater int i; 996da71b7e3SCédric Le Goater 997da71b7e3SCédric Le Goater switch (offset) { 998da71b7e3SCédric Le Goater case CQ_XIVE_CFG: 999da71b7e3SCédric Le Goater case CQ_RST_CTL: /* TODO: reset all BARs */ 1000da71b7e3SCédric Le Goater break; 1001da71b7e3SCédric Le Goater 1002da71b7e3SCédric Le Goater case CQ_IC_BAR: 1003da71b7e3SCédric Le Goater xive->ic_shift = val & CQ_IC_BAR_64K ? 16 : 12; 1004da71b7e3SCédric Le Goater if (!(val & CQ_IC_BAR_VALID)) { 1005da71b7e3SCédric Le Goater xive->ic_base = 0; 1006da71b7e3SCédric Le Goater if (xive->cq_regs[reg] & CQ_IC_BAR_VALID) { 1007da71b7e3SCédric Le Goater for (i = 0; i < ARRAY_SIZE(xive->ic_mmios); i++) { 1008da71b7e3SCédric Le Goater memory_region_del_subregion(&xive->ic_mmio, 1009da71b7e3SCédric Le Goater &xive->ic_mmios[i]); 1010da71b7e3SCédric Le Goater } 1011da71b7e3SCédric Le Goater memory_region_del_subregion(sysmem, &xive->ic_mmio); 1012da71b7e3SCédric Le Goater } 1013da71b7e3SCédric Le Goater } else { 1014da71b7e3SCédric Le Goater xive->ic_base = val & ~(CQ_IC_BAR_VALID | CQ_IC_BAR_64K); 1015da71b7e3SCédric Le Goater if (!(xive->cq_regs[reg] & CQ_IC_BAR_VALID)) { 1016da71b7e3SCédric Le Goater for (i = 0; i < ARRAY_SIZE(xive->ic_mmios); i++) { 1017da71b7e3SCédric Le Goater memory_region_add_subregion(&xive->ic_mmio, 1018da71b7e3SCédric Le Goater pnv_xive2_ic_regions[i].pgoff << xive->ic_shift, 1019da71b7e3SCédric Le Goater &xive->ic_mmios[i]); 1020da71b7e3SCédric Le Goater } 1021da71b7e3SCédric Le Goater memory_region_add_subregion(sysmem, xive->ic_base, 1022da71b7e3SCédric Le Goater &xive->ic_mmio); 1023da71b7e3SCédric Le Goater } 1024da71b7e3SCédric Le Goater } 1025da71b7e3SCédric Le Goater break; 1026da71b7e3SCédric Le Goater 1027da71b7e3SCédric Le Goater case CQ_TM_BAR: 1028da71b7e3SCédric Le Goater xive->tm_shift = val & CQ_TM_BAR_64K ? 16 : 12; 1029da71b7e3SCédric Le Goater if (!(val & CQ_TM_BAR_VALID)) { 1030da71b7e3SCédric Le Goater xive->tm_base = 0; 1031da71b7e3SCédric Le Goater if (xive->cq_regs[reg] & CQ_TM_BAR_VALID) { 1032da71b7e3SCédric Le Goater memory_region_del_subregion(sysmem, &xive->tm_mmio); 1033da71b7e3SCédric Le Goater } 1034da71b7e3SCédric Le Goater } else { 1035da71b7e3SCédric Le Goater xive->tm_base = val & ~(CQ_TM_BAR_VALID | CQ_TM_BAR_64K); 1036da71b7e3SCédric Le Goater if (!(xive->cq_regs[reg] & CQ_TM_BAR_VALID)) { 1037da71b7e3SCédric Le Goater memory_region_add_subregion(sysmem, xive->tm_base, 1038da71b7e3SCédric Le Goater &xive->tm_mmio); 1039da71b7e3SCédric Le Goater } 1040da71b7e3SCédric Le Goater } 1041da71b7e3SCédric Le Goater break; 1042da71b7e3SCédric Le Goater 1043da71b7e3SCédric Le Goater case CQ_ESB_BAR: 1044da71b7e3SCédric Le Goater xive->esb_shift = val & CQ_BAR_64K ? 16 : 12; 1045da71b7e3SCédric Le Goater if (!(val & CQ_BAR_VALID)) { 1046da71b7e3SCédric Le Goater xive->esb_base = 0; 1047da71b7e3SCédric Le Goater if (xive->cq_regs[reg] & CQ_BAR_VALID) { 1048da71b7e3SCédric Le Goater memory_region_del_subregion(sysmem, &xive->esb_mmio); 1049da71b7e3SCédric Le Goater } 1050da71b7e3SCédric Le Goater } else { 1051da71b7e3SCédric Le Goater xive->esb_base = val & CQ_BAR_ADDR; 1052da71b7e3SCédric Le Goater if (!(xive->cq_regs[reg] & CQ_BAR_VALID)) { 1053da71b7e3SCédric Le Goater memory_region_set_size(&xive->esb_mmio, 1054da71b7e3SCédric Le Goater pnv_xive2_bar_size(val)); 1055da71b7e3SCédric Le Goater memory_region_add_subregion(sysmem, xive->esb_base, 1056da71b7e3SCédric Le Goater &xive->esb_mmio); 1057da71b7e3SCédric Le Goater } 1058da71b7e3SCédric Le Goater } 1059da71b7e3SCédric Le Goater break; 1060da71b7e3SCédric Le Goater 1061da71b7e3SCédric Le Goater case CQ_END_BAR: 1062da71b7e3SCédric Le Goater xive->end_shift = val & CQ_BAR_64K ? 16 : 12; 1063da71b7e3SCédric Le Goater if (!(val & CQ_BAR_VALID)) { 1064da71b7e3SCédric Le Goater xive->end_base = 0; 1065da71b7e3SCédric Le Goater if (xive->cq_regs[reg] & CQ_BAR_VALID) { 1066da71b7e3SCédric Le Goater memory_region_del_subregion(sysmem, &xive->end_mmio); 1067da71b7e3SCédric Le Goater } 1068da71b7e3SCédric Le Goater } else { 1069da71b7e3SCédric Le Goater xive->end_base = val & CQ_BAR_ADDR; 1070da71b7e3SCédric Le Goater if (!(xive->cq_regs[reg] & CQ_BAR_VALID)) { 1071da71b7e3SCédric Le Goater memory_region_set_size(&xive->end_mmio, 1072da71b7e3SCédric Le Goater pnv_xive2_bar_size(val)); 1073da71b7e3SCédric Le Goater memory_region_add_subregion(sysmem, xive->end_base, 1074da71b7e3SCédric Le Goater &xive->end_mmio); 1075da71b7e3SCédric Le Goater } 1076da71b7e3SCédric Le Goater } 1077da71b7e3SCédric Le Goater break; 1078da71b7e3SCédric Le Goater 1079da71b7e3SCédric Le Goater case CQ_NVC_BAR: 1080da71b7e3SCédric Le Goater xive->nvc_shift = val & CQ_BAR_64K ? 16 : 12; 1081da71b7e3SCédric Le Goater if (!(val & CQ_BAR_VALID)) { 1082da71b7e3SCédric Le Goater xive->nvc_base = 0; 1083da71b7e3SCédric Le Goater if (xive->cq_regs[reg] & CQ_BAR_VALID) { 1084da71b7e3SCédric Le Goater memory_region_del_subregion(sysmem, &xive->nvc_mmio); 1085da71b7e3SCédric Le Goater } 1086da71b7e3SCédric Le Goater } else { 1087da71b7e3SCédric Le Goater xive->nvc_base = val & CQ_BAR_ADDR; 1088da71b7e3SCédric Le Goater if (!(xive->cq_regs[reg] & CQ_BAR_VALID)) { 1089da71b7e3SCédric Le Goater memory_region_set_size(&xive->nvc_mmio, 1090da71b7e3SCédric Le Goater pnv_xive2_bar_size(val)); 1091da71b7e3SCédric Le Goater memory_region_add_subregion(sysmem, xive->nvc_base, 1092da71b7e3SCédric Le Goater &xive->nvc_mmio); 1093da71b7e3SCédric Le Goater } 1094da71b7e3SCédric Le Goater } 1095da71b7e3SCédric Le Goater break; 1096da71b7e3SCédric Le Goater 1097da71b7e3SCédric Le Goater case CQ_NVPG_BAR: 1098da71b7e3SCédric Le Goater xive->nvpg_shift = val & CQ_BAR_64K ? 16 : 12; 1099da71b7e3SCédric Le Goater if (!(val & CQ_BAR_VALID)) { 1100da71b7e3SCédric Le Goater xive->nvpg_base = 0; 1101da71b7e3SCédric Le Goater if (xive->cq_regs[reg] & CQ_BAR_VALID) { 1102da71b7e3SCédric Le Goater memory_region_del_subregion(sysmem, &xive->nvpg_mmio); 1103da71b7e3SCédric Le Goater } 1104da71b7e3SCédric Le Goater } else { 1105da71b7e3SCédric Le Goater xive->nvpg_base = val & CQ_BAR_ADDR; 1106da71b7e3SCédric Le Goater if (!(xive->cq_regs[reg] & CQ_BAR_VALID)) { 1107da71b7e3SCédric Le Goater memory_region_set_size(&xive->nvpg_mmio, 1108da71b7e3SCédric Le Goater pnv_xive2_bar_size(val)); 1109da71b7e3SCédric Le Goater memory_region_add_subregion(sysmem, xive->nvpg_base, 1110da71b7e3SCédric Le Goater &xive->nvpg_mmio); 1111da71b7e3SCédric Le Goater } 1112da71b7e3SCédric Le Goater } 1113da71b7e3SCédric Le Goater break; 1114da71b7e3SCédric Le Goater 1115da71b7e3SCédric Le Goater case CQ_TAR: /* Set Translation Table Address */ 1116da71b7e3SCédric Le Goater break; 1117da71b7e3SCédric Le Goater case CQ_TDR: /* Set Translation Table Data */ 1118da71b7e3SCédric Le Goater pnv_xive2_stt_set_data(xive, val); 1119da71b7e3SCédric Le Goater break; 1120da71b7e3SCédric Le Goater case CQ_FIRMASK_OR: /* FIR error reporting */ 1121da71b7e3SCédric Le Goater break; 1122da71b7e3SCédric Le Goater default: 1123da71b7e3SCédric Le Goater xive2_error(xive, "CQ: invalid write 0x%"HWADDR_PRIx, offset); 1124da71b7e3SCédric Le Goater return; 1125da71b7e3SCédric Le Goater } 1126da71b7e3SCédric Le Goater 1127da71b7e3SCédric Le Goater xive->cq_regs[reg] = val; 1128da71b7e3SCédric Le Goater } 1129da71b7e3SCédric Le Goater 1130da71b7e3SCédric Le Goater static const MemoryRegionOps pnv_xive2_ic_cq_ops = { 1131da71b7e3SCédric Le Goater .read = pnv_xive2_ic_cq_read, 1132da71b7e3SCédric Le Goater .write = pnv_xive2_ic_cq_write, 1133da71b7e3SCédric Le Goater .endianness = DEVICE_BIG_ENDIAN, 1134da71b7e3SCédric Le Goater .valid = { 1135da71b7e3SCédric Le Goater .min_access_size = 8, 1136da71b7e3SCédric Le Goater .max_access_size = 8, 1137da71b7e3SCédric Le Goater }, 1138da71b7e3SCédric Le Goater .impl = { 1139da71b7e3SCédric Le Goater .min_access_size = 8, 1140da71b7e3SCédric Le Goater .max_access_size = 8, 1141da71b7e3SCédric Le Goater }, 1142da71b7e3SCédric Le Goater }; 1143da71b7e3SCédric Le Goater 11448c01b2e1SFrederic Barrat static uint8_t pnv_xive2_cache_watch_assign(uint64_t engine_mask, 11458c01b2e1SFrederic Barrat uint64_t *state) 11468c01b2e1SFrederic Barrat { 11478c01b2e1SFrederic Barrat uint8_t val = 0xFF; 11488c01b2e1SFrederic Barrat int i; 11498c01b2e1SFrederic Barrat 11508c01b2e1SFrederic Barrat for (i = 3; i >= 0; i--) { 11518c01b2e1SFrederic Barrat if (BIT(i) & engine_mask) { 11528c01b2e1SFrederic Barrat if (!(BIT(i) & *state)) { 11538c01b2e1SFrederic Barrat *state |= BIT(i); 11548c01b2e1SFrederic Barrat val = 3 - i; 11558c01b2e1SFrederic Barrat break; 11568c01b2e1SFrederic Barrat } 11578c01b2e1SFrederic Barrat } 11588c01b2e1SFrederic Barrat } 11598c01b2e1SFrederic Barrat return val; 11608c01b2e1SFrederic Barrat } 11618c01b2e1SFrederic Barrat 11628c01b2e1SFrederic Barrat static void pnv_xive2_cache_watch_release(uint64_t *state, uint8_t watch_engine) 11638c01b2e1SFrederic Barrat { 11648c01b2e1SFrederic Barrat uint8_t engine_bit = 3 - watch_engine; 11658c01b2e1SFrederic Barrat 11668c01b2e1SFrederic Barrat if (*state & BIT(engine_bit)) { 11678c01b2e1SFrederic Barrat *state &= ~BIT(engine_bit); 11688c01b2e1SFrederic Barrat } 11698c01b2e1SFrederic Barrat } 11708c01b2e1SFrederic Barrat 11718c01b2e1SFrederic Barrat static uint8_t pnv_xive2_endc_cache_watch_assign(PnvXive2 *xive) 11728c01b2e1SFrederic Barrat { 11738c01b2e1SFrederic Barrat uint64_t engine_mask = GETFIELD(VC_ENDC_CFG_CACHE_WATCH_ASSIGN, 11748c01b2e1SFrederic Barrat xive->vc_regs[VC_ENDC_CFG >> 3]); 11758c01b2e1SFrederic Barrat uint64_t state = xive->vc_regs[VC_ENDC_WATCH_ASSIGN >> 3]; 11768c01b2e1SFrederic Barrat uint8_t val; 11778c01b2e1SFrederic Barrat 11788c01b2e1SFrederic Barrat /* 11798c01b2e1SFrederic Barrat * We keep track of which engines are currently busy in the 11808c01b2e1SFrederic Barrat * VC_ENDC_WATCH_ASSIGN register directly. When the firmware reads 11818c01b2e1SFrederic Barrat * the register, we don't return its value but the ID of an engine 11828c01b2e1SFrederic Barrat * it can use. 11838c01b2e1SFrederic Barrat * There are 4 engines. 0xFF means no engine is available. 11848c01b2e1SFrederic Barrat */ 11858c01b2e1SFrederic Barrat val = pnv_xive2_cache_watch_assign(engine_mask, &state); 11868c01b2e1SFrederic Barrat if (val != 0xFF) { 11878c01b2e1SFrederic Barrat xive->vc_regs[VC_ENDC_WATCH_ASSIGN >> 3] = state; 11888c01b2e1SFrederic Barrat } 11898c01b2e1SFrederic Barrat return val; 11908c01b2e1SFrederic Barrat } 11918c01b2e1SFrederic Barrat 11928c01b2e1SFrederic Barrat static void pnv_xive2_endc_cache_watch_release(PnvXive2 *xive, 11938c01b2e1SFrederic Barrat uint8_t watch_engine) 11948c01b2e1SFrederic Barrat { 11958c01b2e1SFrederic Barrat uint64_t state = xive->vc_regs[VC_ENDC_WATCH_ASSIGN >> 3]; 11968c01b2e1SFrederic Barrat 11978c01b2e1SFrederic Barrat pnv_xive2_cache_watch_release(&state, watch_engine); 11988c01b2e1SFrederic Barrat xive->vc_regs[VC_ENDC_WATCH_ASSIGN >> 3] = state; 11998c01b2e1SFrederic Barrat } 12008c01b2e1SFrederic Barrat 1201da71b7e3SCédric Le Goater static uint64_t pnv_xive2_ic_vc_read(void *opaque, hwaddr offset, 1202da71b7e3SCédric Le Goater unsigned size) 1203da71b7e3SCédric Le Goater { 1204da71b7e3SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(opaque); 1205da71b7e3SCédric Le Goater uint64_t val = 0; 1206da71b7e3SCédric Le Goater uint32_t reg = offset >> 3; 12078c01b2e1SFrederic Barrat uint8_t watch_engine; 1208da71b7e3SCédric Le Goater 1209da71b7e3SCédric Le Goater switch (offset) { 1210da71b7e3SCédric Le Goater /* 1211da71b7e3SCédric Le Goater * VSD table settings. 1212da71b7e3SCédric Le Goater */ 1213da71b7e3SCédric Le Goater case VC_VSD_TABLE_ADDR: 1214da71b7e3SCédric Le Goater case VC_VSD_TABLE_DATA: 1215da71b7e3SCédric Le Goater val = xive->vc_regs[reg]; 1216da71b7e3SCédric Le Goater break; 1217da71b7e3SCédric Le Goater 1218da71b7e3SCédric Le Goater /* 1219da71b7e3SCédric Le Goater * ESB cache updates (not modeled) 1220da71b7e3SCédric Le Goater */ 1221da71b7e3SCédric Le Goater case VC_ESBC_FLUSH_CTRL: 1222da71b7e3SCédric Le Goater xive->vc_regs[reg] &= ~VC_ESBC_FLUSH_CTRL_POLL_VALID; 1223da71b7e3SCédric Le Goater val = xive->vc_regs[reg]; 1224da71b7e3SCédric Le Goater break; 1225da71b7e3SCédric Le Goater 122632af01f8SFrederic Barrat case VC_ESBC_CFG: 122732af01f8SFrederic Barrat val = xive->vc_regs[reg]; 122832af01f8SFrederic Barrat break; 122932af01f8SFrederic Barrat 1230da71b7e3SCédric Le Goater /* 1231da71b7e3SCédric Le Goater * EAS cache updates (not modeled) 1232da71b7e3SCédric Le Goater */ 1233da71b7e3SCédric Le Goater case VC_EASC_FLUSH_CTRL: 1234da71b7e3SCédric Le Goater xive->vc_regs[reg] &= ~VC_EASC_FLUSH_CTRL_POLL_VALID; 1235da71b7e3SCédric Le Goater val = xive->vc_regs[reg]; 1236da71b7e3SCédric Le Goater break; 1237da71b7e3SCédric Le Goater 12388c01b2e1SFrederic Barrat case VC_ENDC_WATCH_ASSIGN: 12398c01b2e1SFrederic Barrat val = pnv_xive2_endc_cache_watch_assign(xive); 12408c01b2e1SFrederic Barrat break; 12418c01b2e1SFrederic Barrat 12428c01b2e1SFrederic Barrat case VC_ENDC_CFG: 12438c01b2e1SFrederic Barrat val = xive->vc_regs[reg]; 12448c01b2e1SFrederic Barrat break; 12458c01b2e1SFrederic Barrat 1246da71b7e3SCédric Le Goater /* 1247da71b7e3SCédric Le Goater * END cache updates 1248da71b7e3SCédric Le Goater */ 1249da71b7e3SCédric Le Goater case VC_ENDC_WATCH0_SPEC: 12508c01b2e1SFrederic Barrat case VC_ENDC_WATCH1_SPEC: 12518c01b2e1SFrederic Barrat case VC_ENDC_WATCH2_SPEC: 12528c01b2e1SFrederic Barrat case VC_ENDC_WATCH3_SPEC: 12538c01b2e1SFrederic Barrat watch_engine = (offset - VC_ENDC_WATCH0_SPEC) >> 6; 1254da71b7e3SCédric Le Goater xive->vc_regs[reg] &= ~(VC_ENDC_WATCH_FULL | VC_ENDC_WATCH_CONFLICT); 12558c01b2e1SFrederic Barrat pnv_xive2_endc_cache_watch_release(xive, watch_engine); 1256da71b7e3SCédric Le Goater val = xive->vc_regs[reg]; 1257da71b7e3SCédric Le Goater break; 1258da71b7e3SCédric Le Goater 1259da71b7e3SCédric Le Goater case VC_ENDC_WATCH0_DATA0: 12608c01b2e1SFrederic Barrat case VC_ENDC_WATCH1_DATA0: 12618c01b2e1SFrederic Barrat case VC_ENDC_WATCH2_DATA0: 12628c01b2e1SFrederic Barrat case VC_ENDC_WATCH3_DATA0: 1263da71b7e3SCédric Le Goater /* 1264da71b7e3SCédric Le Goater * Load DATA registers from cache with data requested by the 1265da71b7e3SCédric Le Goater * SPEC register 1266da71b7e3SCédric Le Goater */ 12678c01b2e1SFrederic Barrat watch_engine = (offset - VC_ENDC_WATCH0_DATA0) >> 6; 12688c01b2e1SFrederic Barrat pnv_xive2_end_cache_load(xive, watch_engine); 1269da71b7e3SCédric Le Goater val = xive->vc_regs[reg]; 1270da71b7e3SCédric Le Goater break; 1271da71b7e3SCédric Le Goater 1272da71b7e3SCédric Le Goater case VC_ENDC_WATCH0_DATA1 ... VC_ENDC_WATCH0_DATA3: 12738c01b2e1SFrederic Barrat case VC_ENDC_WATCH1_DATA1 ... VC_ENDC_WATCH1_DATA3: 12748c01b2e1SFrederic Barrat case VC_ENDC_WATCH2_DATA1 ... VC_ENDC_WATCH2_DATA3: 12758c01b2e1SFrederic Barrat case VC_ENDC_WATCH3_DATA1 ... VC_ENDC_WATCH3_DATA3: 1276da71b7e3SCédric Le Goater val = xive->vc_regs[reg]; 1277da71b7e3SCédric Le Goater break; 1278da71b7e3SCédric Le Goater 1279da71b7e3SCédric Le Goater case VC_ENDC_FLUSH_CTRL: 1280da71b7e3SCédric Le Goater xive->vc_regs[reg] &= ~VC_ENDC_FLUSH_CTRL_POLL_VALID; 1281da71b7e3SCédric Le Goater val = xive->vc_regs[reg]; 1282da71b7e3SCédric Le Goater break; 1283da71b7e3SCédric Le Goater 1284da71b7e3SCédric Le Goater /* 1285da71b7e3SCédric Le Goater * Indirect invalidation 1286da71b7e3SCédric Le Goater */ 1287da71b7e3SCédric Le Goater case VC_AT_MACRO_KILL_MASK: 1288da71b7e3SCédric Le Goater val = xive->vc_regs[reg]; 1289da71b7e3SCédric Le Goater break; 1290da71b7e3SCédric Le Goater 1291da71b7e3SCédric Le Goater case VC_AT_MACRO_KILL: 1292da71b7e3SCédric Le Goater xive->vc_regs[reg] &= ~VC_AT_MACRO_KILL_VALID; 1293da71b7e3SCédric Le Goater val = xive->vc_regs[reg]; 1294da71b7e3SCédric Le Goater break; 1295da71b7e3SCédric Le Goater 1296da71b7e3SCédric Le Goater /* 1297da71b7e3SCédric Le Goater * Interrupt fifo overflow in memory backing store (Not modeled) 1298da71b7e3SCédric Le Goater */ 1299da71b7e3SCédric Le Goater case VC_QUEUES_CFG_REM0 ... VC_QUEUES_CFG_REM6: 1300da71b7e3SCédric Le Goater val = xive->vc_regs[reg]; 1301da71b7e3SCédric Le Goater break; 1302da71b7e3SCédric Le Goater 1303da71b7e3SCédric Le Goater /* 1304da71b7e3SCédric Le Goater * Synchronisation 1305da71b7e3SCédric Le Goater */ 1306da71b7e3SCédric Le Goater case VC_ENDC_SYNC_DONE: 1307da71b7e3SCédric Le Goater val = VC_ENDC_SYNC_POLL_DONE; 1308da71b7e3SCédric Le Goater break; 1309da71b7e3SCédric Le Goater default: 1310da71b7e3SCédric Le Goater xive2_error(xive, "VC: invalid read @%"HWADDR_PRIx, offset); 1311da71b7e3SCédric Le Goater } 1312da71b7e3SCédric Le Goater 1313da71b7e3SCédric Le Goater return val; 1314da71b7e3SCédric Le Goater } 1315da71b7e3SCédric Le Goater 1316da71b7e3SCédric Le Goater static void pnv_xive2_ic_vc_write(void *opaque, hwaddr offset, 1317da71b7e3SCédric Le Goater uint64_t val, unsigned size) 1318da71b7e3SCédric Le Goater { 1319da71b7e3SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(opaque); 1320da71b7e3SCédric Le Goater uint32_t reg = offset >> 3; 13218c01b2e1SFrederic Barrat uint8_t watch_engine; 1322da71b7e3SCédric Le Goater 1323da71b7e3SCédric Le Goater switch (offset) { 1324da71b7e3SCédric Le Goater /* 1325da71b7e3SCédric Le Goater * VSD table settings. 1326da71b7e3SCédric Le Goater */ 1327da71b7e3SCédric Le Goater case VC_VSD_TABLE_ADDR: 1328da71b7e3SCédric Le Goater break; 1329da71b7e3SCédric Le Goater case VC_VSD_TABLE_DATA: 13301775b7d1SFrederic Barrat pnv_xive2_vc_vst_set_data(xive, val); 1331da71b7e3SCédric Le Goater break; 1332da71b7e3SCédric Le Goater 1333da71b7e3SCédric Le Goater /* 1334da71b7e3SCédric Le Goater * ESB cache updates (not modeled) 1335da71b7e3SCédric Le Goater */ 1336da71b7e3SCédric Le Goater /* case VC_ESBC_FLUSH_CTRL: */ 1337da71b7e3SCédric Le Goater case VC_ESBC_FLUSH_POLL: 1338da71b7e3SCédric Le Goater xive->vc_regs[VC_ESBC_FLUSH_CTRL >> 3] |= VC_ESBC_FLUSH_CTRL_POLL_VALID; 1339da71b7e3SCédric Le Goater /* ESB update */ 1340da71b7e3SCédric Le Goater break; 1341da71b7e3SCédric Le Goater 134276125c01SNicholas Piggin case VC_ESBC_FLUSH_INJECT: 134376125c01SNicholas Piggin pnv_xive2_inject_notify(xive, PNV_XIVE2_CACHE_ESBC); 134476125c01SNicholas Piggin break; 134576125c01SNicholas Piggin 134632af01f8SFrederic Barrat case VC_ESBC_CFG: 134732af01f8SFrederic Barrat break; 134832af01f8SFrederic Barrat 1349da71b7e3SCédric Le Goater /* 1350da71b7e3SCédric Le Goater * EAS cache updates (not modeled) 1351da71b7e3SCédric Le Goater */ 1352da71b7e3SCédric Le Goater /* case VC_EASC_FLUSH_CTRL: */ 1353da71b7e3SCédric Le Goater case VC_EASC_FLUSH_POLL: 1354da71b7e3SCédric Le Goater xive->vc_regs[VC_EASC_FLUSH_CTRL >> 3] |= VC_EASC_FLUSH_CTRL_POLL_VALID; 1355da71b7e3SCédric Le Goater /* EAS update */ 1356da71b7e3SCédric Le Goater break; 1357da71b7e3SCédric Le Goater 135876125c01SNicholas Piggin case VC_EASC_FLUSH_INJECT: 135976125c01SNicholas Piggin pnv_xive2_inject_notify(xive, PNV_XIVE2_CACHE_EASC); 136076125c01SNicholas Piggin break; 136176125c01SNicholas Piggin 13628c01b2e1SFrederic Barrat case VC_ENDC_CFG: 13638c01b2e1SFrederic Barrat break; 13648c01b2e1SFrederic Barrat 1365da71b7e3SCédric Le Goater /* 1366da71b7e3SCédric Le Goater * END cache updates 1367da71b7e3SCédric Le Goater */ 1368da71b7e3SCédric Le Goater case VC_ENDC_WATCH0_SPEC: 13698c01b2e1SFrederic Barrat case VC_ENDC_WATCH1_SPEC: 13708c01b2e1SFrederic Barrat case VC_ENDC_WATCH2_SPEC: 13718c01b2e1SFrederic Barrat case VC_ENDC_WATCH3_SPEC: 1372da71b7e3SCédric Le Goater val &= ~VC_ENDC_WATCH_CONFLICT; /* HW will set this bit */ 1373da71b7e3SCédric Le Goater break; 1374da71b7e3SCédric Le Goater 1375da71b7e3SCédric Le Goater case VC_ENDC_WATCH0_DATA1 ... VC_ENDC_WATCH0_DATA3: 13768c01b2e1SFrederic Barrat case VC_ENDC_WATCH1_DATA1 ... VC_ENDC_WATCH1_DATA3: 13778c01b2e1SFrederic Barrat case VC_ENDC_WATCH2_DATA1 ... VC_ENDC_WATCH2_DATA3: 13788c01b2e1SFrederic Barrat case VC_ENDC_WATCH3_DATA1 ... VC_ENDC_WATCH3_DATA3: 1379da71b7e3SCédric Le Goater break; 1380da71b7e3SCédric Le Goater case VC_ENDC_WATCH0_DATA0: 13818c01b2e1SFrederic Barrat case VC_ENDC_WATCH1_DATA0: 13828c01b2e1SFrederic Barrat case VC_ENDC_WATCH2_DATA0: 13838c01b2e1SFrederic Barrat case VC_ENDC_WATCH3_DATA0: 1384da71b7e3SCédric Le Goater /* writing to DATA0 triggers the cache write */ 13858c01b2e1SFrederic Barrat watch_engine = (offset - VC_ENDC_WATCH0_DATA0) >> 6; 1386da71b7e3SCédric Le Goater xive->vc_regs[reg] = val; 13878c01b2e1SFrederic Barrat pnv_xive2_end_update(xive, watch_engine); 1388da71b7e3SCédric Le Goater break; 1389da71b7e3SCédric Le Goater 1390da71b7e3SCédric Le Goater 1391da71b7e3SCédric Le Goater /* case VC_ENDC_FLUSH_CTRL: */ 1392da71b7e3SCédric Le Goater case VC_ENDC_FLUSH_POLL: 1393da71b7e3SCédric Le Goater xive->vc_regs[VC_ENDC_FLUSH_CTRL >> 3] |= VC_ENDC_FLUSH_CTRL_POLL_VALID; 1394da71b7e3SCédric Le Goater break; 1395da71b7e3SCédric Le Goater 139676125c01SNicholas Piggin case VC_ENDC_FLUSH_INJECT: 139776125c01SNicholas Piggin pnv_xive2_inject_notify(xive, PNV_XIVE2_CACHE_ENDC); 139876125c01SNicholas Piggin break; 139976125c01SNicholas Piggin 1400da71b7e3SCédric Le Goater /* 1401da71b7e3SCédric Le Goater * Indirect invalidation 1402da71b7e3SCédric Le Goater */ 1403da71b7e3SCédric Le Goater case VC_AT_MACRO_KILL: 1404da71b7e3SCédric Le Goater case VC_AT_MACRO_KILL_MASK: 1405da71b7e3SCédric Le Goater break; 1406da71b7e3SCédric Le Goater 1407da71b7e3SCédric Le Goater /* 1408da71b7e3SCédric Le Goater * Interrupt fifo overflow in memory backing store (Not modeled) 1409da71b7e3SCédric Le Goater */ 1410da71b7e3SCédric Le Goater case VC_QUEUES_CFG_REM0 ... VC_QUEUES_CFG_REM6: 1411da71b7e3SCédric Le Goater break; 1412da71b7e3SCédric Le Goater 1413da71b7e3SCédric Le Goater /* 1414da71b7e3SCédric Le Goater * Synchronisation 1415da71b7e3SCédric Le Goater */ 1416da71b7e3SCédric Le Goater case VC_ENDC_SYNC_DONE: 1417da71b7e3SCédric Le Goater break; 1418da71b7e3SCédric Le Goater 1419da71b7e3SCédric Le Goater default: 1420da71b7e3SCédric Le Goater xive2_error(xive, "VC: invalid write @%"HWADDR_PRIx, offset); 1421da71b7e3SCédric Le Goater return; 1422da71b7e3SCédric Le Goater } 1423da71b7e3SCédric Le Goater 1424da71b7e3SCédric Le Goater xive->vc_regs[reg] = val; 1425da71b7e3SCédric Le Goater } 1426da71b7e3SCédric Le Goater 1427da71b7e3SCédric Le Goater static const MemoryRegionOps pnv_xive2_ic_vc_ops = { 1428da71b7e3SCédric Le Goater .read = pnv_xive2_ic_vc_read, 1429da71b7e3SCédric Le Goater .write = pnv_xive2_ic_vc_write, 1430da71b7e3SCédric Le Goater .endianness = DEVICE_BIG_ENDIAN, 1431da71b7e3SCédric Le Goater .valid = { 1432da71b7e3SCédric Le Goater .min_access_size = 8, 1433da71b7e3SCédric Le Goater .max_access_size = 8, 1434da71b7e3SCédric Le Goater }, 1435da71b7e3SCédric Le Goater .impl = { 1436da71b7e3SCédric Le Goater .min_access_size = 8, 1437da71b7e3SCédric Le Goater .max_access_size = 8, 1438da71b7e3SCédric Le Goater }, 1439da71b7e3SCédric Le Goater }; 1440da71b7e3SCédric Le Goater 14418c01b2e1SFrederic Barrat static uint8_t pnv_xive2_nxc_cache_watch_assign(PnvXive2 *xive) 14428c01b2e1SFrederic Barrat { 14438c01b2e1SFrederic Barrat uint64_t engine_mask = GETFIELD(PC_NXC_PROC_CONFIG_WATCH_ASSIGN, 14448c01b2e1SFrederic Barrat xive->pc_regs[PC_NXC_PROC_CONFIG >> 3]); 14458c01b2e1SFrederic Barrat uint64_t state = xive->pc_regs[PC_NXC_WATCH_ASSIGN >> 3]; 14468c01b2e1SFrederic Barrat uint8_t val; 14478c01b2e1SFrederic Barrat 14488c01b2e1SFrederic Barrat /* 14498c01b2e1SFrederic Barrat * We keep track of which engines are currently busy in the 14508c01b2e1SFrederic Barrat * PC_NXC_WATCH_ASSIGN register directly. When the firmware reads 14518c01b2e1SFrederic Barrat * the register, we don't return its value but the ID of an engine 14528c01b2e1SFrederic Barrat * it can use. 14538c01b2e1SFrederic Barrat * There are 4 engines. 0xFF means no engine is available. 14548c01b2e1SFrederic Barrat */ 14558c01b2e1SFrederic Barrat val = pnv_xive2_cache_watch_assign(engine_mask, &state); 14568c01b2e1SFrederic Barrat if (val != 0xFF) { 14578c01b2e1SFrederic Barrat xive->pc_regs[PC_NXC_WATCH_ASSIGN >> 3] = state; 14588c01b2e1SFrederic Barrat } 14598c01b2e1SFrederic Barrat return val; 14608c01b2e1SFrederic Barrat } 14618c01b2e1SFrederic Barrat 14628c01b2e1SFrederic Barrat static void pnv_xive2_nxc_cache_watch_release(PnvXive2 *xive, 14638c01b2e1SFrederic Barrat uint8_t watch_engine) 14648c01b2e1SFrederic Barrat { 14658c01b2e1SFrederic Barrat uint64_t state = xive->pc_regs[PC_NXC_WATCH_ASSIGN >> 3]; 14668c01b2e1SFrederic Barrat 14678c01b2e1SFrederic Barrat pnv_xive2_cache_watch_release(&state, watch_engine); 14688c01b2e1SFrederic Barrat xive->pc_regs[PC_NXC_WATCH_ASSIGN >> 3] = state; 14698c01b2e1SFrederic Barrat } 14708c01b2e1SFrederic Barrat 1471da71b7e3SCédric Le Goater static uint64_t pnv_xive2_ic_pc_read(void *opaque, hwaddr offset, 1472da71b7e3SCédric Le Goater unsigned size) 1473da71b7e3SCédric Le Goater { 1474da71b7e3SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(opaque); 1475da71b7e3SCédric Le Goater uint64_t val = -1; 1476da71b7e3SCédric Le Goater uint32_t reg = offset >> 3; 14778c01b2e1SFrederic Barrat uint8_t watch_engine; 1478da71b7e3SCédric Le Goater 1479da71b7e3SCédric Le Goater switch (offset) { 1480da71b7e3SCédric Le Goater /* 1481da71b7e3SCédric Le Goater * VSD table settings. 1482da71b7e3SCédric Le Goater */ 1483da71b7e3SCédric Le Goater case PC_VSD_TABLE_ADDR: 1484da71b7e3SCédric Le Goater case PC_VSD_TABLE_DATA: 1485da71b7e3SCédric Le Goater val = xive->pc_regs[reg]; 1486da71b7e3SCédric Le Goater break; 1487da71b7e3SCédric Le Goater 14888c01b2e1SFrederic Barrat case PC_NXC_WATCH_ASSIGN: 14898c01b2e1SFrederic Barrat val = pnv_xive2_nxc_cache_watch_assign(xive); 14908c01b2e1SFrederic Barrat break; 14918c01b2e1SFrederic Barrat 14928c01b2e1SFrederic Barrat case PC_NXC_PROC_CONFIG: 14938c01b2e1SFrederic Barrat val = xive->pc_regs[reg]; 14948c01b2e1SFrederic Barrat break; 14958c01b2e1SFrederic Barrat 1496da71b7e3SCédric Le Goater /* 1497da71b7e3SCédric Le Goater * cache updates 1498da71b7e3SCédric Le Goater */ 1499da71b7e3SCédric Le Goater case PC_NXC_WATCH0_SPEC: 15008c01b2e1SFrederic Barrat case PC_NXC_WATCH1_SPEC: 15018c01b2e1SFrederic Barrat case PC_NXC_WATCH2_SPEC: 15028c01b2e1SFrederic Barrat case PC_NXC_WATCH3_SPEC: 15038c01b2e1SFrederic Barrat watch_engine = (offset - PC_NXC_WATCH0_SPEC) >> 6; 1504da71b7e3SCédric Le Goater xive->pc_regs[reg] &= ~(PC_NXC_WATCH_FULL | PC_NXC_WATCH_CONFLICT); 15058c01b2e1SFrederic Barrat pnv_xive2_nxc_cache_watch_release(xive, watch_engine); 1506da71b7e3SCédric Le Goater val = xive->pc_regs[reg]; 1507da71b7e3SCédric Le Goater break; 1508da71b7e3SCédric Le Goater 1509da71b7e3SCédric Le Goater case PC_NXC_WATCH0_DATA0: 15108c01b2e1SFrederic Barrat case PC_NXC_WATCH1_DATA0: 15118c01b2e1SFrederic Barrat case PC_NXC_WATCH2_DATA0: 15128c01b2e1SFrederic Barrat case PC_NXC_WATCH3_DATA0: 1513da71b7e3SCédric Le Goater /* 1514da71b7e3SCédric Le Goater * Load DATA registers from cache with data requested by the 1515da71b7e3SCédric Le Goater * SPEC register 1516da71b7e3SCédric Le Goater */ 15178c01b2e1SFrederic Barrat watch_engine = (offset - PC_NXC_WATCH0_DATA0) >> 6; 1518d6d5f5c0SFrederic Barrat pnv_xive2_nxc_cache_load(xive, watch_engine); 1519da71b7e3SCédric Le Goater val = xive->pc_regs[reg]; 1520da71b7e3SCédric Le Goater break; 1521da71b7e3SCédric Le Goater 1522da71b7e3SCédric Le Goater case PC_NXC_WATCH0_DATA1 ... PC_NXC_WATCH0_DATA3: 15238c01b2e1SFrederic Barrat case PC_NXC_WATCH1_DATA1 ... PC_NXC_WATCH1_DATA3: 15248c01b2e1SFrederic Barrat case PC_NXC_WATCH2_DATA1 ... PC_NXC_WATCH2_DATA3: 15258c01b2e1SFrederic Barrat case PC_NXC_WATCH3_DATA1 ... PC_NXC_WATCH3_DATA3: 1526da71b7e3SCédric Le Goater val = xive->pc_regs[reg]; 1527da71b7e3SCédric Le Goater break; 1528da71b7e3SCédric Le Goater 1529da71b7e3SCédric Le Goater case PC_NXC_FLUSH_CTRL: 1530da71b7e3SCédric Le Goater xive->pc_regs[reg] &= ~PC_NXC_FLUSH_CTRL_POLL_VALID; 1531da71b7e3SCédric Le Goater val = xive->pc_regs[reg]; 1532da71b7e3SCédric Le Goater break; 1533da71b7e3SCédric Le Goater 1534da71b7e3SCédric Le Goater /* 1535da71b7e3SCédric Le Goater * Indirect invalidation 1536da71b7e3SCédric Le Goater */ 1537da71b7e3SCédric Le Goater case PC_AT_KILL: 1538da71b7e3SCédric Le Goater xive->pc_regs[reg] &= ~PC_AT_KILL_VALID; 1539da71b7e3SCédric Le Goater val = xive->pc_regs[reg]; 1540da71b7e3SCédric Le Goater break; 1541da71b7e3SCédric Le Goater 1542da71b7e3SCédric Le Goater default: 1543da71b7e3SCédric Le Goater xive2_error(xive, "PC: invalid read @%"HWADDR_PRIx, offset); 1544da71b7e3SCédric Le Goater } 1545da71b7e3SCédric Le Goater 1546da71b7e3SCédric Le Goater return val; 1547da71b7e3SCédric Le Goater } 1548da71b7e3SCédric Le Goater 15491775b7d1SFrederic Barrat static void pnv_xive2_pc_vst_set_data(PnvXive2 *xive, uint64_t vsd) 15501775b7d1SFrederic Barrat { 15511775b7d1SFrederic Barrat uint8_t type = GETFIELD(PC_VSD_TABLE_SELECT, 15521775b7d1SFrederic Barrat xive->pc_regs[PC_VSD_TABLE_ADDR >> 3]); 15531775b7d1SFrederic Barrat uint8_t blk = GETFIELD(PC_VSD_TABLE_ADDRESS, 15541775b7d1SFrederic Barrat xive->pc_regs[PC_VSD_TABLE_ADDR >> 3]); 15551775b7d1SFrederic Barrat 15561775b7d1SFrederic Barrat pnv_xive2_vst_set_data(xive, vsd, type, blk); 15571775b7d1SFrederic Barrat } 15581775b7d1SFrederic Barrat 1559da71b7e3SCédric Le Goater static void pnv_xive2_ic_pc_write(void *opaque, hwaddr offset, 1560da71b7e3SCédric Le Goater uint64_t val, unsigned size) 1561da71b7e3SCédric Le Goater { 1562da71b7e3SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(opaque); 1563da71b7e3SCédric Le Goater uint32_t reg = offset >> 3; 15648c01b2e1SFrederic Barrat uint8_t watch_engine; 1565da71b7e3SCédric Le Goater 1566da71b7e3SCédric Le Goater switch (offset) { 1567da71b7e3SCédric Le Goater 1568da71b7e3SCédric Le Goater /* 15691775b7d1SFrederic Barrat * VSD table settings. 15701775b7d1SFrederic Barrat * The Xive2Router model combines both VC and PC sub-engines. We 15711775b7d1SFrederic Barrat * allow to configure the tables through both, for the rare cases 15721775b7d1SFrederic Barrat * where a table only really needs to be configured for one of 15731775b7d1SFrederic Barrat * them (e.g. the NVG table for the presenter). It assumes that 15741775b7d1SFrederic Barrat * firmware passes the same address to the VC and PC when tables 15751775b7d1SFrederic Barrat * are defined for both, which seems acceptable. 1576da71b7e3SCédric Le Goater */ 1577da71b7e3SCédric Le Goater case PC_VSD_TABLE_ADDR: 15781775b7d1SFrederic Barrat break; 1579da71b7e3SCédric Le Goater case PC_VSD_TABLE_DATA: 15801775b7d1SFrederic Barrat pnv_xive2_pc_vst_set_data(xive, val); 1581da71b7e3SCédric Le Goater break; 1582da71b7e3SCédric Le Goater 15838c01b2e1SFrederic Barrat case PC_NXC_PROC_CONFIG: 15848c01b2e1SFrederic Barrat break; 15858c01b2e1SFrederic Barrat 1586da71b7e3SCédric Le Goater /* 1587da71b7e3SCédric Le Goater * cache updates 1588da71b7e3SCédric Le Goater */ 1589da71b7e3SCédric Le Goater case PC_NXC_WATCH0_SPEC: 15908c01b2e1SFrederic Barrat case PC_NXC_WATCH1_SPEC: 15918c01b2e1SFrederic Barrat case PC_NXC_WATCH2_SPEC: 15928c01b2e1SFrederic Barrat case PC_NXC_WATCH3_SPEC: 1593da71b7e3SCédric Le Goater val &= ~PC_NXC_WATCH_CONFLICT; /* HW will set this bit */ 1594da71b7e3SCédric Le Goater break; 1595da71b7e3SCédric Le Goater 1596da71b7e3SCédric Le Goater case PC_NXC_WATCH0_DATA1 ... PC_NXC_WATCH0_DATA3: 15978c01b2e1SFrederic Barrat case PC_NXC_WATCH1_DATA1 ... PC_NXC_WATCH1_DATA3: 15988c01b2e1SFrederic Barrat case PC_NXC_WATCH2_DATA1 ... PC_NXC_WATCH2_DATA3: 15998c01b2e1SFrederic Barrat case PC_NXC_WATCH3_DATA1 ... PC_NXC_WATCH3_DATA3: 1600da71b7e3SCédric Le Goater break; 1601da71b7e3SCédric Le Goater case PC_NXC_WATCH0_DATA0: 16028c01b2e1SFrederic Barrat case PC_NXC_WATCH1_DATA0: 16038c01b2e1SFrederic Barrat case PC_NXC_WATCH2_DATA0: 16048c01b2e1SFrederic Barrat case PC_NXC_WATCH3_DATA0: 1605da71b7e3SCédric Le Goater /* writing to DATA0 triggers the cache write */ 16068c01b2e1SFrederic Barrat watch_engine = (offset - PC_NXC_WATCH0_DATA0) >> 6; 1607da71b7e3SCédric Le Goater xive->pc_regs[reg] = val; 1608d6d5f5c0SFrederic Barrat pnv_xive2_nxc_update(xive, watch_engine); 1609da71b7e3SCédric Le Goater break; 1610da71b7e3SCédric Le Goater 1611da71b7e3SCédric Le Goater /* case PC_NXC_FLUSH_CTRL: */ 1612da71b7e3SCédric Le Goater case PC_NXC_FLUSH_POLL: 1613da71b7e3SCédric Le Goater xive->pc_regs[PC_NXC_FLUSH_CTRL >> 3] |= PC_NXC_FLUSH_CTRL_POLL_VALID; 1614da71b7e3SCédric Le Goater break; 1615da71b7e3SCédric Le Goater 161676125c01SNicholas Piggin case PC_NXC_FLUSH_INJECT: 161776125c01SNicholas Piggin pnv_xive2_inject_notify(xive, PNV_XIVE2_CACHE_NXC); 161876125c01SNicholas Piggin break; 161976125c01SNicholas Piggin 1620da71b7e3SCédric Le Goater /* 1621da71b7e3SCédric Le Goater * Indirect invalidation 1622da71b7e3SCédric Le Goater */ 1623da71b7e3SCédric Le Goater case PC_AT_KILL: 1624da71b7e3SCédric Le Goater case PC_AT_KILL_MASK: 1625da71b7e3SCédric Le Goater break; 1626da71b7e3SCédric Le Goater 1627da71b7e3SCédric Le Goater default: 1628da71b7e3SCédric Le Goater xive2_error(xive, "PC: invalid write @%"HWADDR_PRIx, offset); 1629da71b7e3SCédric Le Goater return; 1630da71b7e3SCédric Le Goater } 1631da71b7e3SCédric Le Goater 1632da71b7e3SCédric Le Goater xive->pc_regs[reg] = val; 1633da71b7e3SCédric Le Goater } 1634da71b7e3SCédric Le Goater 1635da71b7e3SCédric Le Goater static const MemoryRegionOps pnv_xive2_ic_pc_ops = { 1636da71b7e3SCédric Le Goater .read = pnv_xive2_ic_pc_read, 1637da71b7e3SCédric Le Goater .write = pnv_xive2_ic_pc_write, 1638da71b7e3SCédric Le Goater .endianness = DEVICE_BIG_ENDIAN, 1639da71b7e3SCédric Le Goater .valid = { 1640da71b7e3SCédric Le Goater .min_access_size = 8, 1641da71b7e3SCédric Le Goater .max_access_size = 8, 1642da71b7e3SCédric Le Goater }, 1643da71b7e3SCédric Le Goater .impl = { 1644da71b7e3SCédric Le Goater .min_access_size = 8, 1645da71b7e3SCédric Le Goater .max_access_size = 8, 1646da71b7e3SCédric Le Goater }, 1647da71b7e3SCédric Le Goater }; 1648da71b7e3SCédric Le Goater 1649da71b7e3SCédric Le Goater 1650da71b7e3SCédric Le Goater static uint64_t pnv_xive2_ic_tctxt_read(void *opaque, hwaddr offset, 1651da71b7e3SCédric Le Goater unsigned size) 1652da71b7e3SCédric Le Goater { 1653da71b7e3SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(opaque); 1654da71b7e3SCédric Le Goater uint64_t val = -1; 1655da71b7e3SCédric Le Goater uint32_t reg = offset >> 3; 1656da71b7e3SCédric Le Goater 1657da71b7e3SCédric Le Goater switch (offset) { 1658da71b7e3SCédric Le Goater /* 1659da71b7e3SCédric Le Goater * XIVE2 hardware thread enablement 1660da71b7e3SCédric Le Goater */ 1661da71b7e3SCédric Le Goater case TCTXT_EN0: 1662da71b7e3SCédric Le Goater case TCTXT_EN1: 1663da71b7e3SCédric Le Goater val = xive->tctxt_regs[reg]; 1664da71b7e3SCédric Le Goater break; 1665da71b7e3SCédric Le Goater 1666da71b7e3SCédric Le Goater case TCTXT_EN0_SET: 1667da71b7e3SCédric Le Goater case TCTXT_EN0_RESET: 1668da71b7e3SCédric Le Goater val = xive->tctxt_regs[TCTXT_EN0 >> 3]; 1669da71b7e3SCédric Le Goater break; 1670da71b7e3SCédric Le Goater case TCTXT_EN1_SET: 1671da71b7e3SCédric Le Goater case TCTXT_EN1_RESET: 1672da71b7e3SCédric Le Goater val = xive->tctxt_regs[TCTXT_EN1 >> 3]; 1673da71b7e3SCédric Le Goater break; 1674cce84fc9SFrederic Barrat case TCTXT_CFG: 1675cce84fc9SFrederic Barrat val = xive->tctxt_regs[reg]; 1676cce84fc9SFrederic Barrat break; 1677da71b7e3SCédric Le Goater default: 1678da71b7e3SCédric Le Goater xive2_error(xive, "TCTXT: invalid read @%"HWADDR_PRIx, offset); 1679da71b7e3SCédric Le Goater } 1680da71b7e3SCédric Le Goater 1681da71b7e3SCédric Le Goater return val; 1682da71b7e3SCédric Le Goater } 1683da71b7e3SCédric Le Goater 1684da71b7e3SCédric Le Goater static void pnv_xive2_ic_tctxt_write(void *opaque, hwaddr offset, 1685da71b7e3SCédric Le Goater uint64_t val, unsigned size) 1686da71b7e3SCédric Le Goater { 1687da71b7e3SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(opaque); 1688cce84fc9SFrederic Barrat uint32_t reg = offset >> 3; 1689da71b7e3SCédric Le Goater 1690da71b7e3SCédric Le Goater switch (offset) { 1691da71b7e3SCédric Le Goater /* 1692da71b7e3SCédric Le Goater * XIVE2 hardware thread enablement 1693da71b7e3SCédric Le Goater */ 1694da71b7e3SCédric Le Goater case TCTXT_EN0: /* Physical Thread Enable */ 1695da71b7e3SCédric Le Goater case TCTXT_EN1: /* Physical Thread Enable (fused core) */ 1696f0fc1c29SFrederic Barrat xive->tctxt_regs[reg] = val; 1697da71b7e3SCédric Le Goater break; 1698da71b7e3SCédric Le Goater 1699da71b7e3SCédric Le Goater case TCTXT_EN0_SET: 1700da71b7e3SCédric Le Goater xive->tctxt_regs[TCTXT_EN0 >> 3] |= val; 1701da71b7e3SCédric Le Goater break; 1702da71b7e3SCédric Le Goater case TCTXT_EN1_SET: 1703da71b7e3SCédric Le Goater xive->tctxt_regs[TCTXT_EN1 >> 3] |= val; 1704da71b7e3SCédric Le Goater break; 1705da71b7e3SCédric Le Goater case TCTXT_EN0_RESET: 1706da71b7e3SCédric Le Goater xive->tctxt_regs[TCTXT_EN0 >> 3] &= ~val; 1707da71b7e3SCédric Le Goater break; 1708da71b7e3SCédric Le Goater case TCTXT_EN1_RESET: 1709da71b7e3SCédric Le Goater xive->tctxt_regs[TCTXT_EN1 >> 3] &= ~val; 1710da71b7e3SCédric Le Goater break; 1711cce84fc9SFrederic Barrat case TCTXT_CFG: 1712cce84fc9SFrederic Barrat xive->tctxt_regs[reg] = val; 1713cce84fc9SFrederic Barrat break; 1714da71b7e3SCédric Le Goater default: 1715da71b7e3SCédric Le Goater xive2_error(xive, "TCTXT: invalid write @%"HWADDR_PRIx, offset); 1716da71b7e3SCédric Le Goater return; 1717da71b7e3SCédric Le Goater } 1718da71b7e3SCédric Le Goater } 1719da71b7e3SCédric Le Goater 1720da71b7e3SCédric Le Goater static const MemoryRegionOps pnv_xive2_ic_tctxt_ops = { 1721da71b7e3SCédric Le Goater .read = pnv_xive2_ic_tctxt_read, 1722da71b7e3SCédric Le Goater .write = pnv_xive2_ic_tctxt_write, 1723da71b7e3SCédric Le Goater .endianness = DEVICE_BIG_ENDIAN, 1724da71b7e3SCédric Le Goater .valid = { 1725da71b7e3SCédric Le Goater .min_access_size = 8, 1726da71b7e3SCédric Le Goater .max_access_size = 8, 1727da71b7e3SCédric Le Goater }, 1728da71b7e3SCédric Le Goater .impl = { 1729da71b7e3SCédric Le Goater .min_access_size = 8, 1730da71b7e3SCédric Le Goater .max_access_size = 8, 1731da71b7e3SCédric Le Goater }, 1732da71b7e3SCédric Le Goater }; 1733da71b7e3SCédric Le Goater 1734da71b7e3SCédric Le Goater /* 1735da71b7e3SCédric Le Goater * Redirect XSCOM to MMIO handlers 1736da71b7e3SCédric Le Goater */ 1737da71b7e3SCédric Le Goater static uint64_t pnv_xive2_xscom_read(void *opaque, hwaddr offset, 1738da71b7e3SCédric Le Goater unsigned size) 1739da71b7e3SCédric Le Goater { 1740da71b7e3SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(opaque); 1741da71b7e3SCédric Le Goater uint64_t val = -1; 1742da71b7e3SCédric Le Goater uint32_t xscom_reg = offset >> 3; 1743da71b7e3SCédric Le Goater uint32_t mmio_offset = (xscom_reg & 0xFF) << 3; 1744da71b7e3SCédric Le Goater 1745da71b7e3SCédric Le Goater switch (xscom_reg) { 1746da71b7e3SCédric Le Goater case 0x000 ... 0x0FF: 1747da71b7e3SCédric Le Goater val = pnv_xive2_ic_cq_read(opaque, mmio_offset, size); 1748da71b7e3SCédric Le Goater break; 1749da71b7e3SCédric Le Goater case 0x100 ... 0x1FF: 1750da71b7e3SCédric Le Goater val = pnv_xive2_ic_vc_read(opaque, mmio_offset, size); 1751da71b7e3SCédric Le Goater break; 1752da71b7e3SCédric Le Goater case 0x200 ... 0x2FF: 1753da71b7e3SCédric Le Goater val = pnv_xive2_ic_pc_read(opaque, mmio_offset, size); 1754da71b7e3SCédric Le Goater break; 1755da71b7e3SCédric Le Goater case 0x300 ... 0x3FF: 1756da71b7e3SCédric Le Goater val = pnv_xive2_ic_tctxt_read(opaque, mmio_offset, size); 1757da71b7e3SCédric Le Goater break; 1758da71b7e3SCédric Le Goater default: 1759da71b7e3SCédric Le Goater xive2_error(xive, "XSCOM: invalid read @%"HWADDR_PRIx, offset); 1760da71b7e3SCédric Le Goater } 1761da71b7e3SCédric Le Goater 1762da71b7e3SCédric Le Goater return val; 1763da71b7e3SCédric Le Goater } 1764da71b7e3SCédric Le Goater 1765da71b7e3SCédric Le Goater static void pnv_xive2_xscom_write(void *opaque, hwaddr offset, 1766da71b7e3SCédric Le Goater uint64_t val, unsigned size) 1767da71b7e3SCédric Le Goater { 1768da71b7e3SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(opaque); 1769da71b7e3SCédric Le Goater uint32_t xscom_reg = offset >> 3; 1770da71b7e3SCédric Le Goater uint32_t mmio_offset = (xscom_reg & 0xFF) << 3; 1771da71b7e3SCédric Le Goater 1772da71b7e3SCédric Le Goater switch (xscom_reg) { 1773da71b7e3SCédric Le Goater case 0x000 ... 0x0FF: 1774da71b7e3SCédric Le Goater pnv_xive2_ic_cq_write(opaque, mmio_offset, val, size); 1775da71b7e3SCédric Le Goater break; 1776da71b7e3SCédric Le Goater case 0x100 ... 0x1FF: 1777da71b7e3SCédric Le Goater pnv_xive2_ic_vc_write(opaque, mmio_offset, val, size); 1778da71b7e3SCédric Le Goater break; 1779da71b7e3SCédric Le Goater case 0x200 ... 0x2FF: 1780da71b7e3SCédric Le Goater pnv_xive2_ic_pc_write(opaque, mmio_offset, val, size); 1781da71b7e3SCédric Le Goater break; 1782da71b7e3SCédric Le Goater case 0x300 ... 0x3FF: 1783da71b7e3SCédric Le Goater pnv_xive2_ic_tctxt_write(opaque, mmio_offset, val, size); 1784da71b7e3SCédric Le Goater break; 1785da71b7e3SCédric Le Goater default: 1786da71b7e3SCédric Le Goater xive2_error(xive, "XSCOM: invalid write @%"HWADDR_PRIx, offset); 1787da71b7e3SCédric Le Goater } 1788da71b7e3SCédric Le Goater } 1789da71b7e3SCédric Le Goater 1790da71b7e3SCédric Le Goater static const MemoryRegionOps pnv_xive2_xscom_ops = { 1791da71b7e3SCédric Le Goater .read = pnv_xive2_xscom_read, 1792da71b7e3SCédric Le Goater .write = pnv_xive2_xscom_write, 1793da71b7e3SCédric Le Goater .endianness = DEVICE_BIG_ENDIAN, 1794da71b7e3SCédric Le Goater .valid = { 1795da71b7e3SCédric Le Goater .min_access_size = 8, 1796da71b7e3SCédric Le Goater .max_access_size = 8, 1797da71b7e3SCédric Le Goater }, 1798da71b7e3SCédric Le Goater .impl = { 1799da71b7e3SCédric Le Goater .min_access_size = 8, 1800da71b7e3SCédric Le Goater .max_access_size = 8, 1801da71b7e3SCédric Le Goater }, 1802da71b7e3SCédric Le Goater }; 1803da71b7e3SCédric Le Goater 1804da71b7e3SCédric Le Goater /* 1805da71b7e3SCédric Le Goater * Notify port page. The layout is compatible between 4K and 64K pages : 1806da71b7e3SCédric Le Goater * 1807da71b7e3SCédric Le Goater * Page 1 Notify page (writes only) 1808da71b7e3SCédric Le Goater * 0x000 - 0x7FF IPI interrupt (NPU) 1809da71b7e3SCédric Le Goater * 0x800 - 0xFFF HW interrupt triggers (PSI, PHB) 1810da71b7e3SCédric Le Goater */ 1811da71b7e3SCédric Le Goater 1812da71b7e3SCédric Le Goater static void pnv_xive2_ic_hw_trigger(PnvXive2 *xive, hwaddr addr, 1813da71b7e3SCédric Le Goater uint64_t val) 1814da71b7e3SCédric Le Goater { 1815da71b7e3SCédric Le Goater uint8_t blk; 1816da71b7e3SCédric Le Goater uint32_t idx; 1817da71b7e3SCédric Le Goater 1818da71b7e3SCédric Le Goater if (val & XIVE_TRIGGER_END) { 1819da71b7e3SCédric Le Goater xive2_error(xive, "IC: END trigger at @0x%"HWADDR_PRIx" data 0x%"PRIx64, 1820da71b7e3SCédric Le Goater addr, val); 1821da71b7e3SCédric Le Goater return; 1822da71b7e3SCédric Le Goater } 1823da71b7e3SCédric Le Goater 1824da71b7e3SCédric Le Goater /* 1825da71b7e3SCédric Le Goater * Forward the source event notification directly to the Router. 1826da71b7e3SCédric Le Goater * The source interrupt number should already be correctly encoded 1827da71b7e3SCédric Le Goater * with the chip block id by the sending device (PHB, PSI). 1828da71b7e3SCédric Le Goater */ 1829da71b7e3SCédric Le Goater blk = XIVE_EAS_BLOCK(val); 1830da71b7e3SCédric Le Goater idx = XIVE_EAS_INDEX(val); 1831da71b7e3SCédric Le Goater 18320aa2612aSCédric Le Goater xive2_router_notify(XIVE_NOTIFIER(xive), XIVE_EAS(blk, idx), 18330aa2612aSCédric Le Goater !!(val & XIVE_TRIGGER_PQ)); 1834da71b7e3SCédric Le Goater } 1835da71b7e3SCédric Le Goater 1836da71b7e3SCédric Le Goater static void pnv_xive2_ic_notify_write(void *opaque, hwaddr offset, 1837da71b7e3SCédric Le Goater uint64_t val, unsigned size) 1838da71b7e3SCédric Le Goater { 1839da71b7e3SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(opaque); 1840da71b7e3SCédric Le Goater 1841da71b7e3SCédric Le Goater /* VC: IPI triggers */ 1842da71b7e3SCédric Le Goater switch (offset) { 1843da71b7e3SCédric Le Goater case 0x000 ... 0x7FF: 1844da71b7e3SCédric Le Goater /* TODO: check IPI notify sub-page routing */ 1845da71b7e3SCédric Le Goater pnv_xive2_ic_hw_trigger(opaque, offset, val); 1846da71b7e3SCédric Le Goater break; 1847da71b7e3SCédric Le Goater 1848da71b7e3SCédric Le Goater /* VC: HW triggers */ 1849da71b7e3SCédric Le Goater case 0x800 ... 0xFFF: 1850da71b7e3SCédric Le Goater pnv_xive2_ic_hw_trigger(opaque, offset, val); 1851da71b7e3SCédric Le Goater break; 1852da71b7e3SCédric Le Goater 1853da71b7e3SCédric Le Goater default: 1854da71b7e3SCédric Le Goater xive2_error(xive, "NOTIFY: invalid write @%"HWADDR_PRIx, offset); 1855da71b7e3SCédric Le Goater } 1856da71b7e3SCédric Le Goater } 1857da71b7e3SCédric Le Goater 1858da71b7e3SCédric Le Goater static uint64_t pnv_xive2_ic_notify_read(void *opaque, hwaddr offset, 1859da71b7e3SCédric Le Goater unsigned size) 1860da71b7e3SCédric Le Goater { 1861da71b7e3SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(opaque); 1862da71b7e3SCédric Le Goater 1863da71b7e3SCédric Le Goater /* loads are invalid */ 1864da71b7e3SCédric Le Goater xive2_error(xive, "NOTIFY: invalid read @%"HWADDR_PRIx, offset); 1865da71b7e3SCédric Le Goater return -1; 1866da71b7e3SCédric Le Goater } 1867da71b7e3SCédric Le Goater 1868da71b7e3SCédric Le Goater static const MemoryRegionOps pnv_xive2_ic_notify_ops = { 1869da71b7e3SCédric Le Goater .read = pnv_xive2_ic_notify_read, 1870da71b7e3SCédric Le Goater .write = pnv_xive2_ic_notify_write, 1871da71b7e3SCédric Le Goater .endianness = DEVICE_BIG_ENDIAN, 1872da71b7e3SCédric Le Goater .valid = { 1873da71b7e3SCédric Le Goater .min_access_size = 8, 1874da71b7e3SCédric Le Goater .max_access_size = 8, 1875da71b7e3SCédric Le Goater }, 1876da71b7e3SCédric Le Goater .impl = { 1877da71b7e3SCédric Le Goater .min_access_size = 8, 1878da71b7e3SCédric Le Goater .max_access_size = 8, 1879da71b7e3SCédric Le Goater }, 1880da71b7e3SCédric Le Goater }; 1881da71b7e3SCédric Le Goater 1882da71b7e3SCédric Le Goater static uint64_t pnv_xive2_ic_lsi_read(void *opaque, hwaddr offset, 1883da71b7e3SCédric Le Goater unsigned size) 1884da71b7e3SCédric Le Goater { 1885da71b7e3SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(opaque); 1886da71b7e3SCédric Le Goater 1887da71b7e3SCédric Le Goater xive2_error(xive, "LSI: invalid read @%"HWADDR_PRIx, offset); 1888da71b7e3SCédric Le Goater return -1; 1889da71b7e3SCédric Le Goater } 1890da71b7e3SCédric Le Goater 1891da71b7e3SCédric Le Goater static void pnv_xive2_ic_lsi_write(void *opaque, hwaddr offset, 1892da71b7e3SCédric Le Goater uint64_t val, unsigned size) 1893da71b7e3SCédric Le Goater { 1894da71b7e3SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(opaque); 1895da71b7e3SCédric Le Goater 1896da71b7e3SCédric Le Goater xive2_error(xive, "LSI: invalid write @%"HWADDR_PRIx, offset); 1897da71b7e3SCédric Le Goater } 1898da71b7e3SCédric Le Goater 1899da71b7e3SCédric Le Goater static const MemoryRegionOps pnv_xive2_ic_lsi_ops = { 1900da71b7e3SCédric Le Goater .read = pnv_xive2_ic_lsi_read, 1901da71b7e3SCédric Le Goater .write = pnv_xive2_ic_lsi_write, 1902da71b7e3SCédric Le Goater .endianness = DEVICE_BIG_ENDIAN, 1903da71b7e3SCédric Le Goater .valid = { 1904da71b7e3SCédric Le Goater .min_access_size = 8, 1905da71b7e3SCédric Le Goater .max_access_size = 8, 1906da71b7e3SCédric Le Goater }, 1907da71b7e3SCédric Le Goater .impl = { 1908da71b7e3SCédric Le Goater .min_access_size = 8, 1909da71b7e3SCédric Le Goater .max_access_size = 8, 1910da71b7e3SCédric Le Goater }, 1911da71b7e3SCédric Le Goater }; 1912da71b7e3SCédric Le Goater 1913da71b7e3SCédric Le Goater /* 1914da71b7e3SCédric Le Goater * Sync MMIO page (write only) 1915da71b7e3SCédric Le Goater */ 1916da71b7e3SCédric Le Goater #define PNV_XIVE2_SYNC_IPI 0x000 1917da71b7e3SCédric Le Goater #define PNV_XIVE2_SYNC_HW 0x080 1918da71b7e3SCédric Le Goater #define PNV_XIVE2_SYNC_NxC 0x100 1919da71b7e3SCédric Le Goater #define PNV_XIVE2_SYNC_INT 0x180 1920da71b7e3SCédric Le Goater #define PNV_XIVE2_SYNC_OS_ESC 0x200 1921da71b7e3SCédric Le Goater #define PNV_XIVE2_SYNC_POOL_ESC 0x280 1922da71b7e3SCédric Le Goater #define PNV_XIVE2_SYNC_HARD_ESC 0x300 192376125c01SNicholas Piggin #define PNV_XIVE2_SYNC_NXC_LD_LCL_NCO 0x800 192476125c01SNicholas Piggin #define PNV_XIVE2_SYNC_NXC_LD_LCL_CO 0x880 192576125c01SNicholas Piggin #define PNV_XIVE2_SYNC_NXC_ST_LCL_NCI 0x900 192676125c01SNicholas Piggin #define PNV_XIVE2_SYNC_NXC_ST_LCL_CI 0x980 192776125c01SNicholas Piggin #define PNV_XIVE2_SYNC_NXC_ST_RMT_NCI 0xA00 192876125c01SNicholas Piggin #define PNV_XIVE2_SYNC_NXC_ST_RMT_CI 0xA80 1929da71b7e3SCédric Le Goater 1930da71b7e3SCédric Le Goater static uint64_t pnv_xive2_ic_sync_read(void *opaque, hwaddr offset, 1931da71b7e3SCédric Le Goater unsigned size) 1932da71b7e3SCédric Le Goater { 1933da71b7e3SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(opaque); 1934da71b7e3SCédric Le Goater 1935da71b7e3SCédric Le Goater /* loads are invalid */ 1936da71b7e3SCédric Le Goater xive2_error(xive, "SYNC: invalid read @%"HWADDR_PRIx, offset); 1937da71b7e3SCédric Le Goater return -1; 1938da71b7e3SCédric Le Goater } 1939da71b7e3SCédric Le Goater 194076125c01SNicholas Piggin /* 194176125c01SNicholas Piggin * The sync MMIO space spans two pages. The lower page is use for 194276125c01SNicholas Piggin * queue sync "poll" requests while the upper page is used for queue 194376125c01SNicholas Piggin * sync "inject" requests. Inject requests require the HW to write 194476125c01SNicholas Piggin * a byte of all 1's to a predetermined location in memory in order 194576125c01SNicholas Piggin * to signal completion of the request. Both pages have the same 194676125c01SNicholas Piggin * layout, so it is easiest to handle both with a single function. 194776125c01SNicholas Piggin */ 1948da71b7e3SCédric Le Goater static void pnv_xive2_ic_sync_write(void *opaque, hwaddr offset, 1949da71b7e3SCédric Le Goater uint64_t val, unsigned size) 1950da71b7e3SCédric Le Goater { 1951da71b7e3SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(opaque); 195276125c01SNicholas Piggin int inject_type; 195376125c01SNicholas Piggin hwaddr pg_offset_mask = (1ull << xive->ic_shift) - 1; 1954da71b7e3SCédric Le Goater 195576125c01SNicholas Piggin /* adjust offset for inject page */ 195676125c01SNicholas Piggin hwaddr adj_offset = offset & pg_offset_mask; 195776125c01SNicholas Piggin 195876125c01SNicholas Piggin switch (adj_offset) { 1959da71b7e3SCédric Le Goater case PNV_XIVE2_SYNC_IPI: 196076125c01SNicholas Piggin inject_type = PNV_XIVE2_QUEUE_IPI; 196176125c01SNicholas Piggin break; 1962da71b7e3SCédric Le Goater case PNV_XIVE2_SYNC_HW: 196376125c01SNicholas Piggin inject_type = PNV_XIVE2_QUEUE_HW; 196476125c01SNicholas Piggin break; 1965da71b7e3SCédric Le Goater case PNV_XIVE2_SYNC_NxC: 196676125c01SNicholas Piggin inject_type = PNV_XIVE2_QUEUE_NXC; 196776125c01SNicholas Piggin break; 1968da71b7e3SCédric Le Goater case PNV_XIVE2_SYNC_INT: 196976125c01SNicholas Piggin inject_type = PNV_XIVE2_QUEUE_INT; 197076125c01SNicholas Piggin break; 1971da71b7e3SCédric Le Goater case PNV_XIVE2_SYNC_OS_ESC: 197276125c01SNicholas Piggin inject_type = PNV_XIVE2_QUEUE_OS; 197376125c01SNicholas Piggin break; 1974da71b7e3SCédric Le Goater case PNV_XIVE2_SYNC_POOL_ESC: 197576125c01SNicholas Piggin inject_type = PNV_XIVE2_QUEUE_POOL; 197676125c01SNicholas Piggin break; 1977da71b7e3SCédric Le Goater case PNV_XIVE2_SYNC_HARD_ESC: 197876125c01SNicholas Piggin inject_type = PNV_XIVE2_QUEUE_HARD; 197976125c01SNicholas Piggin break; 198076125c01SNicholas Piggin case PNV_XIVE2_SYNC_NXC_LD_LCL_NCO: 198176125c01SNicholas Piggin inject_type = PNV_XIVE2_QUEUE_NXC_LD_LCL_NCO; 198276125c01SNicholas Piggin break; 198376125c01SNicholas Piggin case PNV_XIVE2_SYNC_NXC_LD_LCL_CO: 198476125c01SNicholas Piggin inject_type = PNV_XIVE2_QUEUE_NXC_LD_LCL_CO; 198576125c01SNicholas Piggin break; 198676125c01SNicholas Piggin case PNV_XIVE2_SYNC_NXC_ST_LCL_NCI: 198776125c01SNicholas Piggin inject_type = PNV_XIVE2_QUEUE_NXC_ST_LCL_NCI; 198876125c01SNicholas Piggin break; 198976125c01SNicholas Piggin case PNV_XIVE2_SYNC_NXC_ST_LCL_CI: 199076125c01SNicholas Piggin inject_type = PNV_XIVE2_QUEUE_NXC_ST_LCL_CI; 199176125c01SNicholas Piggin break; 199276125c01SNicholas Piggin case PNV_XIVE2_SYNC_NXC_ST_RMT_NCI: 199376125c01SNicholas Piggin inject_type = PNV_XIVE2_QUEUE_NXC_ST_RMT_NCI; 199476125c01SNicholas Piggin break; 199576125c01SNicholas Piggin case PNV_XIVE2_SYNC_NXC_ST_RMT_CI: 199676125c01SNicholas Piggin inject_type = PNV_XIVE2_QUEUE_NXC_ST_RMT_CI; 1997da71b7e3SCédric Le Goater break; 1998da71b7e3SCédric Le Goater default: 1999da71b7e3SCédric Le Goater xive2_error(xive, "SYNC: invalid write @%"HWADDR_PRIx, offset); 200076125c01SNicholas Piggin return; 200176125c01SNicholas Piggin } 200276125c01SNicholas Piggin 200376125c01SNicholas Piggin /* Write Queue Sync notification byte if writing to sync inject page */ 200476125c01SNicholas Piggin if ((offset & ~pg_offset_mask) != 0) { 200576125c01SNicholas Piggin pnv_xive2_inject_notify(xive, inject_type); 2006da71b7e3SCédric Le Goater } 2007da71b7e3SCédric Le Goater } 2008da71b7e3SCédric Le Goater 2009da71b7e3SCédric Le Goater static const MemoryRegionOps pnv_xive2_ic_sync_ops = { 2010da71b7e3SCédric Le Goater .read = pnv_xive2_ic_sync_read, 2011da71b7e3SCédric Le Goater .write = pnv_xive2_ic_sync_write, 2012da71b7e3SCédric Le Goater .endianness = DEVICE_BIG_ENDIAN, 2013da71b7e3SCédric Le Goater .valid = { 2014da71b7e3SCédric Le Goater .min_access_size = 8, 2015da71b7e3SCédric Le Goater .max_access_size = 8, 2016da71b7e3SCédric Le Goater }, 2017da71b7e3SCédric Le Goater .impl = { 2018da71b7e3SCédric Le Goater .min_access_size = 8, 2019da71b7e3SCédric Le Goater .max_access_size = 8, 2020da71b7e3SCédric Le Goater }, 2021da71b7e3SCédric Le Goater }; 2022da71b7e3SCédric Le Goater 2023da71b7e3SCédric Le Goater /* 2024da71b7e3SCédric Le Goater * When the TM direct pages of the IC controller are accessed, the 2025da71b7e3SCédric Le Goater * target HW thread is deduced from the page offset. 2026da71b7e3SCédric Le Goater */ 202715130867SFrederic Barrat static uint32_t pnv_xive2_ic_tm_get_pir(PnvXive2 *xive, hwaddr offset) 202815130867SFrederic Barrat { 202915130867SFrederic Barrat /* On P10, the node ID shift in the PIR register is 8 bits */ 203015130867SFrederic Barrat return xive->chip->chip_id << 8 | offset >> xive->ic_shift; 203115130867SFrederic Barrat } 203215130867SFrederic Barrat 2033694d3cb2SFrederic Barrat static uint32_t pnv_xive2_ic_tm_get_hw_page_offset(PnvXive2 *xive, 2034694d3cb2SFrederic Barrat hwaddr offset) 2035694d3cb2SFrederic Barrat { 2036694d3cb2SFrederic Barrat /* 2037694d3cb2SFrederic Barrat * Indirect TIMA accesses are similar to direct accesses for 2038694d3cb2SFrederic Barrat * privilege ring 0. So remove any traces of the hw thread ID from 2039694d3cb2SFrederic Barrat * the offset in the IC BAR as it could be interpreted as the ring 2040694d3cb2SFrederic Barrat * privilege when calling the underlying direct access functions. 2041694d3cb2SFrederic Barrat */ 2042694d3cb2SFrederic Barrat return offset & ((1ull << xive->ic_shift) - 1); 2043694d3cb2SFrederic Barrat } 2044694d3cb2SFrederic Barrat 2045da71b7e3SCédric Le Goater static XiveTCTX *pnv_xive2_get_indirect_tctx(PnvXive2 *xive, uint32_t pir) 2046da71b7e3SCédric Le Goater { 2047da71b7e3SCédric Le Goater PnvChip *chip = xive->chip; 2048da71b7e3SCédric Le Goater PowerPCCPU *cpu = NULL; 2049da71b7e3SCédric Le Goater 2050da71b7e3SCédric Le Goater cpu = pnv_chip_find_cpu(chip, pir); 2051da71b7e3SCédric Le Goater if (!cpu) { 2052da71b7e3SCédric Le Goater xive2_error(xive, "IC: invalid PIR %x for indirect access", pir); 2053da71b7e3SCédric Le Goater return NULL; 2054da71b7e3SCédric Le Goater } 2055da71b7e3SCédric Le Goater 2056da71b7e3SCédric Le Goater if (!pnv_xive2_is_cpu_enabled(xive, cpu)) { 2057da71b7e3SCédric Le Goater xive2_error(xive, "IC: CPU %x is not enabled", pir); 2058da71b7e3SCédric Le Goater } 2059da71b7e3SCédric Le Goater 2060da71b7e3SCédric Le Goater return XIVE_TCTX(pnv_cpu_state(cpu)->intc); 2061da71b7e3SCédric Le Goater } 2062da71b7e3SCédric Le Goater 2063da71b7e3SCédric Le Goater static uint64_t pnv_xive2_ic_tm_indirect_read(void *opaque, hwaddr offset, 2064da71b7e3SCédric Le Goater unsigned size) 2065da71b7e3SCédric Le Goater { 2066da71b7e3SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(opaque); 2067ed75a123SFrederic Barrat XivePresenter *xptr = XIVE_PRESENTER(xive); 2068694d3cb2SFrederic Barrat hwaddr hw_page_offset; 206915130867SFrederic Barrat uint32_t pir; 207015130867SFrederic Barrat XiveTCTX *tctx; 2071da71b7e3SCédric Le Goater uint64_t val = -1; 2072da71b7e3SCédric Le Goater 207315130867SFrederic Barrat pir = pnv_xive2_ic_tm_get_pir(xive, offset); 2074694d3cb2SFrederic Barrat hw_page_offset = pnv_xive2_ic_tm_get_hw_page_offset(xive, offset); 207515130867SFrederic Barrat tctx = pnv_xive2_get_indirect_tctx(xive, pir); 2076da71b7e3SCédric Le Goater if (tctx) { 2077ed75a123SFrederic Barrat val = xive_tctx_tm_read(xptr, tctx, hw_page_offset, size); 2078da71b7e3SCédric Le Goater } 2079da71b7e3SCédric Le Goater 2080da71b7e3SCédric Le Goater return val; 2081da71b7e3SCédric Le Goater } 2082da71b7e3SCédric Le Goater 2083da71b7e3SCédric Le Goater static void pnv_xive2_ic_tm_indirect_write(void *opaque, hwaddr offset, 2084da71b7e3SCédric Le Goater uint64_t val, unsigned size) 2085da71b7e3SCédric Le Goater { 2086da71b7e3SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(opaque); 2087ed75a123SFrederic Barrat XivePresenter *xptr = XIVE_PRESENTER(xive); 2088694d3cb2SFrederic Barrat hwaddr hw_page_offset; 208915130867SFrederic Barrat uint32_t pir; 209015130867SFrederic Barrat XiveTCTX *tctx; 2091da71b7e3SCédric Le Goater 209215130867SFrederic Barrat pir = pnv_xive2_ic_tm_get_pir(xive, offset); 2093694d3cb2SFrederic Barrat hw_page_offset = pnv_xive2_ic_tm_get_hw_page_offset(xive, offset); 209415130867SFrederic Barrat tctx = pnv_xive2_get_indirect_tctx(xive, pir); 2095da71b7e3SCédric Le Goater if (tctx) { 2096ed75a123SFrederic Barrat xive_tctx_tm_write(xptr, tctx, hw_page_offset, val, size); 2097da71b7e3SCédric Le Goater } 2098da71b7e3SCédric Le Goater } 2099da71b7e3SCédric Le Goater 2100da71b7e3SCédric Le Goater static const MemoryRegionOps pnv_xive2_ic_tm_indirect_ops = { 2101da71b7e3SCédric Le Goater .read = pnv_xive2_ic_tm_indirect_read, 2102da71b7e3SCédric Le Goater .write = pnv_xive2_ic_tm_indirect_write, 2103da71b7e3SCédric Le Goater .endianness = DEVICE_BIG_ENDIAN, 2104da71b7e3SCédric Le Goater .valid = { 2105d73a1751SFrederic Barrat .min_access_size = 1, 2106da71b7e3SCédric Le Goater .max_access_size = 8, 2107da71b7e3SCédric Le Goater }, 2108da71b7e3SCédric Le Goater .impl = { 2109d73a1751SFrederic Barrat .min_access_size = 1, 2110da71b7e3SCédric Le Goater .max_access_size = 8, 2111da71b7e3SCédric Le Goater }, 2112da71b7e3SCédric Le Goater }; 2113da71b7e3SCédric Le Goater 2114da71b7e3SCédric Le Goater /* 2115da71b7e3SCédric Le Goater * TIMA ops 2116da71b7e3SCédric Le Goater */ 2117da71b7e3SCédric Le Goater static void pnv_xive2_tm_write(void *opaque, hwaddr offset, 2118da71b7e3SCédric Le Goater uint64_t value, unsigned size) 2119da71b7e3SCédric Le Goater { 2120da71b7e3SCédric Le Goater PowerPCCPU *cpu = POWERPC_CPU(current_cpu); 2121da71b7e3SCédric Le Goater PnvXive2 *xive = pnv_xive2_tm_get_xive(cpu); 2122da71b7e3SCédric Le Goater XiveTCTX *tctx = XIVE_TCTX(pnv_cpu_state(cpu)->intc); 212395d729e2SCédric Le Goater XivePresenter *xptr = XIVE_PRESENTER(xive); 212495d729e2SCédric Le Goater 212595d729e2SCédric Le Goater xive_tctx_tm_write(xptr, tctx, offset, value, size); 2126da71b7e3SCédric Le Goater } 2127da71b7e3SCédric Le Goater 2128da71b7e3SCédric Le Goater static uint64_t pnv_xive2_tm_read(void *opaque, hwaddr offset, unsigned size) 2129da71b7e3SCédric Le Goater { 2130da71b7e3SCédric Le Goater PowerPCCPU *cpu = POWERPC_CPU(current_cpu); 2131da71b7e3SCédric Le Goater PnvXive2 *xive = pnv_xive2_tm_get_xive(cpu); 2132da71b7e3SCédric Le Goater XiveTCTX *tctx = XIVE_TCTX(pnv_cpu_state(cpu)->intc); 213395d729e2SCédric Le Goater XivePresenter *xptr = XIVE_PRESENTER(xive); 213495d729e2SCédric Le Goater 213595d729e2SCédric Le Goater return xive_tctx_tm_read(xptr, tctx, offset, size); 2136da71b7e3SCédric Le Goater } 2137da71b7e3SCédric Le Goater 2138da71b7e3SCédric Le Goater static const MemoryRegionOps pnv_xive2_tm_ops = { 2139da71b7e3SCédric Le Goater .read = pnv_xive2_tm_read, 2140da71b7e3SCédric Le Goater .write = pnv_xive2_tm_write, 2141da71b7e3SCédric Le Goater .endianness = DEVICE_BIG_ENDIAN, 2142da71b7e3SCédric Le Goater .valid = { 2143da71b7e3SCédric Le Goater .min_access_size = 1, 2144da71b7e3SCédric Le Goater .max_access_size = 8, 2145da71b7e3SCédric Le Goater }, 2146da71b7e3SCédric Le Goater .impl = { 2147da71b7e3SCédric Le Goater .min_access_size = 1, 2148da71b7e3SCédric Le Goater .max_access_size = 8, 2149da71b7e3SCédric Le Goater }, 2150da71b7e3SCédric Le Goater }; 2151da71b7e3SCédric Le Goater 2152da71b7e3SCédric Le Goater static uint64_t pnv_xive2_nvc_read(void *opaque, hwaddr offset, 2153da71b7e3SCédric Le Goater unsigned size) 2154da71b7e3SCédric Le Goater { 2155da71b7e3SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(opaque); 2156da71b7e3SCédric Le Goater 2157da71b7e3SCédric Le Goater xive2_error(xive, "NVC: invalid read @%"HWADDR_PRIx, offset); 2158da71b7e3SCédric Le Goater return -1; 2159da71b7e3SCédric Le Goater } 2160da71b7e3SCédric Le Goater 2161da71b7e3SCédric Le Goater static void pnv_xive2_nvc_write(void *opaque, hwaddr offset, 2162da71b7e3SCédric Le Goater uint64_t val, unsigned size) 2163da71b7e3SCédric Le Goater { 2164da71b7e3SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(opaque); 2165da71b7e3SCédric Le Goater 2166da71b7e3SCédric Le Goater xive2_error(xive, "NVC: invalid write @%"HWADDR_PRIx, offset); 2167da71b7e3SCédric Le Goater } 2168da71b7e3SCédric Le Goater 2169da71b7e3SCédric Le Goater static const MemoryRegionOps pnv_xive2_nvc_ops = { 2170da71b7e3SCédric Le Goater .read = pnv_xive2_nvc_read, 2171da71b7e3SCédric Le Goater .write = pnv_xive2_nvc_write, 2172da71b7e3SCédric Le Goater .endianness = DEVICE_BIG_ENDIAN, 2173da71b7e3SCédric Le Goater .valid = { 2174da71b7e3SCédric Le Goater .min_access_size = 8, 2175da71b7e3SCédric Le Goater .max_access_size = 8, 2176da71b7e3SCédric Le Goater }, 2177da71b7e3SCédric Le Goater .impl = { 2178da71b7e3SCédric Le Goater .min_access_size = 8, 2179da71b7e3SCédric Le Goater .max_access_size = 8, 2180da71b7e3SCédric Le Goater }, 2181da71b7e3SCédric Le Goater }; 2182da71b7e3SCédric Le Goater 2183da71b7e3SCédric Le Goater static uint64_t pnv_xive2_nvpg_read(void *opaque, hwaddr offset, 2184da71b7e3SCédric Le Goater unsigned size) 2185da71b7e3SCédric Le Goater { 2186da71b7e3SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(opaque); 2187da71b7e3SCédric Le Goater 2188da71b7e3SCédric Le Goater xive2_error(xive, "NVPG: invalid read @%"HWADDR_PRIx, offset); 2189da71b7e3SCédric Le Goater return -1; 2190da71b7e3SCédric Le Goater } 2191da71b7e3SCédric Le Goater 2192da71b7e3SCédric Le Goater static void pnv_xive2_nvpg_write(void *opaque, hwaddr offset, 2193da71b7e3SCédric Le Goater uint64_t val, unsigned size) 2194da71b7e3SCédric Le Goater { 2195da71b7e3SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(opaque); 2196da71b7e3SCédric Le Goater 2197da71b7e3SCédric Le Goater xive2_error(xive, "NVPG: invalid write @%"HWADDR_PRIx, offset); 2198da71b7e3SCédric Le Goater } 2199da71b7e3SCédric Le Goater 2200da71b7e3SCédric Le Goater static const MemoryRegionOps pnv_xive2_nvpg_ops = { 2201da71b7e3SCédric Le Goater .read = pnv_xive2_nvpg_read, 2202da71b7e3SCédric Le Goater .write = pnv_xive2_nvpg_write, 2203da71b7e3SCédric Le Goater .endianness = DEVICE_BIG_ENDIAN, 2204da71b7e3SCédric Le Goater .valid = { 2205da71b7e3SCédric Le Goater .min_access_size = 8, 2206da71b7e3SCédric Le Goater .max_access_size = 8, 2207da71b7e3SCédric Le Goater }, 2208da71b7e3SCédric Le Goater .impl = { 2209da71b7e3SCédric Le Goater .min_access_size = 8, 2210da71b7e3SCédric Le Goater .max_access_size = 8, 2211da71b7e3SCédric Le Goater }, 2212da71b7e3SCédric Le Goater }; 2213da71b7e3SCédric Le Goater 2214da71b7e3SCédric Le Goater /* 2215707ea7abSCédric Le Goater * POWER10 default capabilities: 0x2000120076f000FC 2216da71b7e3SCédric Le Goater */ 2217707ea7abSCédric Le Goater #define PNV_XIVE2_CAPABILITIES 0x2000120076f000FC 2218da71b7e3SCédric Le Goater 2219da71b7e3SCédric Le Goater /* 2220da71b7e3SCédric Le Goater * POWER10 default configuration: 0x0030000033000000 2221da71b7e3SCédric Le Goater * 2222da71b7e3SCédric Le Goater * 8bits thread id was dropped for P10 2223da71b7e3SCédric Le Goater */ 2224da71b7e3SCédric Le Goater #define PNV_XIVE2_CONFIGURATION 0x0030000033000000 2225da71b7e3SCédric Le Goater 2226da71b7e3SCédric Le Goater static void pnv_xive2_reset(void *dev) 2227da71b7e3SCédric Le Goater { 2228da71b7e3SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(dev); 2229da71b7e3SCédric Le Goater XiveSource *xsrc = &xive->ipi_source; 2230da71b7e3SCédric Le Goater Xive2EndSource *end_xsrc = &xive->end_source; 2231da71b7e3SCédric Le Goater 2232da71b7e3SCédric Le Goater xive->cq_regs[CQ_XIVE_CAP >> 3] = xive->capabilities; 2233da71b7e3SCédric Le Goater xive->cq_regs[CQ_XIVE_CFG >> 3] = xive->config; 2234da71b7e3SCédric Le Goater 2235da71b7e3SCédric Le Goater /* HW hardwires the #Topology of the chip in the block field */ 2236da71b7e3SCédric Le Goater xive->cq_regs[CQ_XIVE_CFG >> 3] |= 2237da71b7e3SCédric Le Goater SETFIELD(CQ_XIVE_CFG_HYP_HARD_BLOCK_ID, 0ull, xive->chip->chip_id); 2238da71b7e3SCédric Le Goater 22398c01b2e1SFrederic Barrat /* VC and PC cache watch assign mechanism */ 22408c01b2e1SFrederic Barrat xive->vc_regs[VC_ENDC_CFG >> 3] = 22418c01b2e1SFrederic Barrat SETFIELD(VC_ENDC_CFG_CACHE_WATCH_ASSIGN, 0ull, 0b0111); 22428c01b2e1SFrederic Barrat xive->pc_regs[PC_NXC_PROC_CONFIG >> 3] = 22438c01b2e1SFrederic Barrat SETFIELD(PC_NXC_PROC_CONFIG_WATCH_ASSIGN, 0ull, 0b0111); 22448c01b2e1SFrederic Barrat 2245da71b7e3SCédric Le Goater /* Set default page size to 64k */ 2246da71b7e3SCédric Le Goater xive->ic_shift = xive->esb_shift = xive->end_shift = 16; 2247da71b7e3SCédric Le Goater xive->nvc_shift = xive->nvpg_shift = xive->tm_shift = 16; 2248da71b7e3SCédric Le Goater 2249da71b7e3SCédric Le Goater /* Clear source MMIOs */ 2250da71b7e3SCédric Le Goater if (memory_region_is_mapped(&xsrc->esb_mmio)) { 2251da71b7e3SCédric Le Goater memory_region_del_subregion(&xive->esb_mmio, &xsrc->esb_mmio); 2252da71b7e3SCédric Le Goater } 2253da71b7e3SCédric Le Goater 2254da71b7e3SCédric Le Goater if (memory_region_is_mapped(&end_xsrc->esb_mmio)) { 2255da71b7e3SCédric Le Goater memory_region_del_subregion(&xive->end_mmio, &end_xsrc->esb_mmio); 2256da71b7e3SCédric Le Goater } 2257da71b7e3SCédric Le Goater } 2258da71b7e3SCédric Le Goater 2259da71b7e3SCédric Le Goater /* 2260da71b7e3SCédric Le Goater * Maximum number of IRQs and ENDs supported by HW. Will be tuned by 2261da71b7e3SCédric Le Goater * software. 2262da71b7e3SCédric Le Goater */ 2263da71b7e3SCédric Le Goater #define PNV_XIVE2_NR_IRQS (PNV10_XIVE2_ESB_SIZE / (1ull << XIVE_ESB_64K_2PAGE)) 2264da71b7e3SCédric Le Goater #define PNV_XIVE2_NR_ENDS (PNV10_XIVE2_END_SIZE / (1ull << XIVE_ESB_64K_2PAGE)) 2265da71b7e3SCédric Le Goater 2266da71b7e3SCédric Le Goater static void pnv_xive2_realize(DeviceState *dev, Error **errp) 2267da71b7e3SCédric Le Goater { 2268da71b7e3SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(dev); 2269da71b7e3SCédric Le Goater PnvXive2Class *pxc = PNV_XIVE2_GET_CLASS(dev); 2270da71b7e3SCédric Le Goater XiveSource *xsrc = &xive->ipi_source; 2271da71b7e3SCédric Le Goater Xive2EndSource *end_xsrc = &xive->end_source; 2272da71b7e3SCédric Le Goater Error *local_err = NULL; 2273da71b7e3SCédric Le Goater int i; 2274da71b7e3SCédric Le Goater 2275da71b7e3SCédric Le Goater pxc->parent_realize(dev, &local_err); 2276da71b7e3SCédric Le Goater if (local_err) { 2277da71b7e3SCédric Le Goater error_propagate(errp, local_err); 2278da71b7e3SCédric Le Goater return; 2279da71b7e3SCédric Le Goater } 2280da71b7e3SCédric Le Goater 2281da71b7e3SCédric Le Goater assert(xive->chip); 2282da71b7e3SCédric Le Goater 2283da71b7e3SCédric Le Goater /* 2284da71b7e3SCédric Le Goater * The XiveSource and Xive2EndSource objects are realized with the 2285da71b7e3SCédric Le Goater * maximum allowed HW configuration. The ESB MMIO regions will be 2286da71b7e3SCédric Le Goater * resized dynamically when the controller is configured by the FW 2287da71b7e3SCédric Le Goater * to limit accesses to resources not provisioned. 2288da71b7e3SCédric Le Goater */ 2289da71b7e3SCédric Le Goater object_property_set_int(OBJECT(xsrc), "flags", XIVE_SRC_STORE_EOI, 2290da71b7e3SCédric Le Goater &error_fatal); 2291da71b7e3SCédric Le Goater object_property_set_int(OBJECT(xsrc), "nr-irqs", PNV_XIVE2_NR_IRQS, 2292da71b7e3SCédric Le Goater &error_fatal); 2293da71b7e3SCédric Le Goater object_property_set_link(OBJECT(xsrc), "xive", OBJECT(xive), 2294da71b7e3SCédric Le Goater &error_fatal); 2295da71b7e3SCédric Le Goater qdev_realize(DEVICE(xsrc), NULL, &local_err); 2296da71b7e3SCédric Le Goater if (local_err) { 2297da71b7e3SCédric Le Goater error_propagate(errp, local_err); 2298da71b7e3SCédric Le Goater return; 2299da71b7e3SCédric Le Goater } 2300da71b7e3SCédric Le Goater 2301da71b7e3SCédric Le Goater object_property_set_int(OBJECT(end_xsrc), "nr-ends", PNV_XIVE2_NR_ENDS, 2302da71b7e3SCédric Le Goater &error_fatal); 2303da71b7e3SCédric Le Goater object_property_set_link(OBJECT(end_xsrc), "xive", OBJECT(xive), 2304da71b7e3SCédric Le Goater &error_abort); 2305da71b7e3SCédric Le Goater qdev_realize(DEVICE(end_xsrc), NULL, &local_err); 2306da71b7e3SCédric Le Goater if (local_err) { 2307da71b7e3SCédric Le Goater error_propagate(errp, local_err); 2308da71b7e3SCédric Le Goater return; 2309da71b7e3SCédric Le Goater } 2310da71b7e3SCédric Le Goater 2311da71b7e3SCédric Le Goater /* XSCOM region, used for initial configuration of the BARs */ 2312da71b7e3SCédric Le Goater memory_region_init_io(&xive->xscom_regs, OBJECT(dev), 2313da71b7e3SCédric Le Goater &pnv_xive2_xscom_ops, xive, "xscom-xive", 2314da71b7e3SCédric Le Goater PNV10_XSCOM_XIVE2_SIZE << 3); 2315da71b7e3SCédric Le Goater 2316da71b7e3SCédric Le Goater /* Interrupt controller MMIO regions */ 2317da71b7e3SCédric Le Goater xive->ic_shift = 16; 2318da71b7e3SCédric Le Goater memory_region_init(&xive->ic_mmio, OBJECT(dev), "xive-ic", 2319da71b7e3SCédric Le Goater PNV10_XIVE2_IC_SIZE); 2320da71b7e3SCédric Le Goater 2321da71b7e3SCédric Le Goater for (i = 0; i < ARRAY_SIZE(xive->ic_mmios); i++) { 2322da71b7e3SCédric Le Goater memory_region_init_io(&xive->ic_mmios[i], OBJECT(dev), 2323da71b7e3SCédric Le Goater pnv_xive2_ic_regions[i].ops, xive, 2324da71b7e3SCédric Le Goater pnv_xive2_ic_regions[i].name, 2325da71b7e3SCédric Le Goater pnv_xive2_ic_regions[i].pgsize << xive->ic_shift); 2326da71b7e3SCédric Le Goater } 2327da71b7e3SCédric Le Goater 2328da71b7e3SCédric Le Goater /* 2329da71b7e3SCédric Le Goater * VC MMIO regions. 2330da71b7e3SCédric Le Goater */ 2331da71b7e3SCédric Le Goater xive->esb_shift = 16; 2332da71b7e3SCédric Le Goater xive->end_shift = 16; 2333da71b7e3SCédric Le Goater memory_region_init(&xive->esb_mmio, OBJECT(xive), "xive-esb", 2334da71b7e3SCédric Le Goater PNV10_XIVE2_ESB_SIZE); 2335da71b7e3SCédric Le Goater memory_region_init(&xive->end_mmio, OBJECT(xive), "xive-end", 2336da71b7e3SCédric Le Goater PNV10_XIVE2_END_SIZE); 2337da71b7e3SCédric Le Goater 2338da71b7e3SCédric Le Goater /* Presenter Controller MMIO region (not modeled) */ 2339da71b7e3SCédric Le Goater xive->nvc_shift = 16; 2340da71b7e3SCédric Le Goater xive->nvpg_shift = 16; 2341da71b7e3SCédric Le Goater memory_region_init_io(&xive->nvc_mmio, OBJECT(dev), 2342da71b7e3SCédric Le Goater &pnv_xive2_nvc_ops, xive, 2343da71b7e3SCédric Le Goater "xive-nvc", PNV10_XIVE2_NVC_SIZE); 2344da71b7e3SCédric Le Goater 2345da71b7e3SCédric Le Goater memory_region_init_io(&xive->nvpg_mmio, OBJECT(dev), 2346da71b7e3SCédric Le Goater &pnv_xive2_nvpg_ops, xive, 2347da71b7e3SCédric Le Goater "xive-nvpg", PNV10_XIVE2_NVPG_SIZE); 2348da71b7e3SCédric Le Goater 2349da71b7e3SCédric Le Goater /* Thread Interrupt Management Area (Direct) */ 2350da71b7e3SCédric Le Goater xive->tm_shift = 16; 2351da71b7e3SCédric Le Goater memory_region_init_io(&xive->tm_mmio, OBJECT(dev), &pnv_xive2_tm_ops, 2352da71b7e3SCédric Le Goater xive, "xive-tima", PNV10_XIVE2_TM_SIZE); 2353da71b7e3SCédric Le Goater 2354da71b7e3SCédric Le Goater qemu_register_reset(pnv_xive2_reset, dev); 2355da71b7e3SCédric Le Goater } 2356da71b7e3SCédric Le Goater 2357da71b7e3SCédric Le Goater static Property pnv_xive2_properties[] = { 2358da71b7e3SCédric Le Goater DEFINE_PROP_UINT64("ic-bar", PnvXive2, ic_base, 0), 2359da71b7e3SCédric Le Goater DEFINE_PROP_UINT64("esb-bar", PnvXive2, esb_base, 0), 2360da71b7e3SCédric Le Goater DEFINE_PROP_UINT64("end-bar", PnvXive2, end_base, 0), 2361da71b7e3SCédric Le Goater DEFINE_PROP_UINT64("nvc-bar", PnvXive2, nvc_base, 0), 2362da71b7e3SCédric Le Goater DEFINE_PROP_UINT64("nvpg-bar", PnvXive2, nvpg_base, 0), 2363da71b7e3SCédric Le Goater DEFINE_PROP_UINT64("tm-bar", PnvXive2, tm_base, 0), 2364da71b7e3SCédric Le Goater DEFINE_PROP_UINT64("capabilities", PnvXive2, capabilities, 2365da71b7e3SCédric Le Goater PNV_XIVE2_CAPABILITIES), 2366da71b7e3SCédric Le Goater DEFINE_PROP_UINT64("config", PnvXive2, config, 2367da71b7e3SCédric Le Goater PNV_XIVE2_CONFIGURATION), 2368da71b7e3SCédric Le Goater DEFINE_PROP_LINK("chip", PnvXive2, chip, TYPE_PNV_CHIP, PnvChip *), 2369da71b7e3SCédric Le Goater DEFINE_PROP_END_OF_LIST(), 2370da71b7e3SCédric Le Goater }; 2371da71b7e3SCédric Le Goater 2372da71b7e3SCédric Le Goater static void pnv_xive2_instance_init(Object *obj) 2373da71b7e3SCédric Le Goater { 2374da71b7e3SCédric Le Goater PnvXive2 *xive = PNV_XIVE2(obj); 2375da71b7e3SCédric Le Goater 2376da71b7e3SCédric Le Goater object_initialize_child(obj, "ipi_source", &xive->ipi_source, 2377da71b7e3SCédric Le Goater TYPE_XIVE_SOURCE); 2378da71b7e3SCédric Le Goater object_initialize_child(obj, "end_source", &xive->end_source, 2379da71b7e3SCédric Le Goater TYPE_XIVE2_END_SOURCE); 2380da71b7e3SCédric Le Goater } 2381da71b7e3SCédric Le Goater 2382da71b7e3SCédric Le Goater static int pnv_xive2_dt_xscom(PnvXScomInterface *dev, void *fdt, 2383da71b7e3SCédric Le Goater int xscom_offset) 2384da71b7e3SCédric Le Goater { 2385da71b7e3SCédric Le Goater const char compat_p10[] = "ibm,power10-xive-x"; 2386da71b7e3SCédric Le Goater char *name; 2387da71b7e3SCédric Le Goater int offset; 2388da71b7e3SCédric Le Goater uint32_t reg[] = { 2389da71b7e3SCédric Le Goater cpu_to_be32(PNV10_XSCOM_XIVE2_BASE), 2390da71b7e3SCédric Le Goater cpu_to_be32(PNV10_XSCOM_XIVE2_SIZE) 2391da71b7e3SCédric Le Goater }; 2392da71b7e3SCédric Le Goater 2393da71b7e3SCédric Le Goater name = g_strdup_printf("xive@%x", PNV10_XSCOM_XIVE2_BASE); 2394da71b7e3SCédric Le Goater offset = fdt_add_subnode(fdt, xscom_offset, name); 2395da71b7e3SCédric Le Goater _FDT(offset); 2396da71b7e3SCédric Le Goater g_free(name); 2397da71b7e3SCédric Le Goater 2398da71b7e3SCédric Le Goater _FDT((fdt_setprop(fdt, offset, "reg", reg, sizeof(reg)))); 2399da71b7e3SCédric Le Goater _FDT(fdt_setprop(fdt, offset, "compatible", compat_p10, 2400da71b7e3SCédric Le Goater sizeof(compat_p10))); 2401da71b7e3SCédric Le Goater return 0; 2402da71b7e3SCédric Le Goater } 2403da71b7e3SCédric Le Goater 2404da71b7e3SCédric Le Goater static void pnv_xive2_class_init(ObjectClass *klass, void *data) 2405da71b7e3SCédric Le Goater { 2406da71b7e3SCédric Le Goater DeviceClass *dc = DEVICE_CLASS(klass); 2407da71b7e3SCédric Le Goater PnvXScomInterfaceClass *xdc = PNV_XSCOM_INTERFACE_CLASS(klass); 2408da71b7e3SCédric Le Goater Xive2RouterClass *xrc = XIVE2_ROUTER_CLASS(klass); 2409da71b7e3SCédric Le Goater XiveNotifierClass *xnc = XIVE_NOTIFIER_CLASS(klass); 2410da71b7e3SCédric Le Goater XivePresenterClass *xpc = XIVE_PRESENTER_CLASS(klass); 2411da71b7e3SCédric Le Goater PnvXive2Class *pxc = PNV_XIVE2_CLASS(klass); 2412da71b7e3SCédric Le Goater 2413da71b7e3SCédric Le Goater xdc->dt_xscom = pnv_xive2_dt_xscom; 2414da71b7e3SCédric Le Goater 2415da71b7e3SCédric Le Goater dc->desc = "PowerNV XIVE2 Interrupt Controller (POWER10)"; 2416da71b7e3SCédric Le Goater device_class_set_parent_realize(dc, pnv_xive2_realize, 2417da71b7e3SCédric Le Goater &pxc->parent_realize); 2418da71b7e3SCédric Le Goater device_class_set_props(dc, pnv_xive2_properties); 2419da71b7e3SCédric Le Goater 2420da71b7e3SCédric Le Goater xrc->get_eas = pnv_xive2_get_eas; 24210aa2612aSCédric Le Goater xrc->get_pq = pnv_xive2_get_pq; 24220aa2612aSCédric Le Goater xrc->set_pq = pnv_xive2_set_pq; 2423da71b7e3SCédric Le Goater xrc->get_end = pnv_xive2_get_end; 2424da71b7e3SCédric Le Goater xrc->write_end = pnv_xive2_write_end; 2425da71b7e3SCédric Le Goater xrc->get_nvp = pnv_xive2_get_nvp; 2426da71b7e3SCédric Le Goater xrc->write_nvp = pnv_xive2_write_nvp; 2427*76798e12SFrederic Barrat xrc->get_nvgc = pnv_xive2_get_nvgc; 2428*76798e12SFrederic Barrat xrc->write_nvgc = pnv_xive2_write_nvgc; 2429e16032b8SCédric Le Goater xrc->get_config = pnv_xive2_get_config; 2430da71b7e3SCédric Le Goater xrc->get_block_id = pnv_xive2_get_block_id; 2431da71b7e3SCédric Le Goater 2432da71b7e3SCédric Le Goater xnc->notify = pnv_xive2_notify; 2433da71b7e3SCédric Le Goater 2434da71b7e3SCédric Le Goater xpc->match_nvt = pnv_xive2_match_nvt; 24352a24e6e3SFrederic Barrat xpc->get_config = pnv_xive2_presenter_get_config; 2436da71b7e3SCédric Le Goater }; 2437da71b7e3SCédric Le Goater 2438da71b7e3SCédric Le Goater static const TypeInfo pnv_xive2_info = { 2439da71b7e3SCédric Le Goater .name = TYPE_PNV_XIVE2, 2440da71b7e3SCédric Le Goater .parent = TYPE_XIVE2_ROUTER, 2441da71b7e3SCédric Le Goater .instance_init = pnv_xive2_instance_init, 2442da71b7e3SCédric Le Goater .instance_size = sizeof(PnvXive2), 2443da71b7e3SCédric Le Goater .class_init = pnv_xive2_class_init, 2444da71b7e3SCédric Le Goater .class_size = sizeof(PnvXive2Class), 2445da71b7e3SCédric Le Goater .interfaces = (InterfaceInfo[]) { 2446da71b7e3SCédric Le Goater { TYPE_PNV_XSCOM_INTERFACE }, 2447da71b7e3SCédric Le Goater { } 2448da71b7e3SCédric Le Goater } 2449da71b7e3SCédric Le Goater }; 2450da71b7e3SCédric Le Goater 2451da71b7e3SCédric Le Goater static void pnv_xive2_register_types(void) 2452da71b7e3SCédric Le Goater { 2453da71b7e3SCédric Le Goater type_register_static(&pnv_xive2_info); 2454da71b7e3SCédric Le Goater } 2455da71b7e3SCédric Le Goater 2456da71b7e3SCédric Le Goater type_init(pnv_xive2_register_types) 2457da71b7e3SCédric Le Goater 2458da71b7e3SCédric Le Goater /* 2459da71b7e3SCédric Le Goater * If the table is direct, we can compute the number of PQ entries 2460da71b7e3SCédric Le Goater * provisioned by FW. 2461da71b7e3SCédric Le Goater */ 2462da71b7e3SCédric Le Goater static uint32_t pnv_xive2_nr_esbs(PnvXive2 *xive) 2463da71b7e3SCédric Le Goater { 2464da71b7e3SCédric Le Goater uint8_t blk = pnv_xive2_block_id(xive); 2465da71b7e3SCédric Le Goater uint64_t vsd = xive->vsds[VST_ESB][blk]; 2466da71b7e3SCédric Le Goater uint64_t vst_tsize = 1ull << (GETFIELD(VSD_TSIZE, vsd) + 12); 2467da71b7e3SCédric Le Goater 2468da71b7e3SCédric Le Goater return VSD_INDIRECT & vsd ? 0 : vst_tsize * SBE_PER_BYTE; 2469da71b7e3SCédric Le Goater } 2470da71b7e3SCédric Le Goater 2471da71b7e3SCédric Le Goater /* 2472da71b7e3SCédric Le Goater * Compute the number of entries per indirect subpage. 2473da71b7e3SCédric Le Goater */ 2474da71b7e3SCédric Le Goater static uint64_t pnv_xive2_vst_per_subpage(PnvXive2 *xive, uint32_t type) 2475da71b7e3SCédric Le Goater { 2476da71b7e3SCédric Le Goater uint8_t blk = pnv_xive2_block_id(xive); 2477da71b7e3SCédric Le Goater uint64_t vsd = xive->vsds[type][blk]; 2478da71b7e3SCédric Le Goater const XiveVstInfo *info = &vst_infos[type]; 2479da71b7e3SCédric Le Goater uint64_t vsd_addr; 2480da71b7e3SCédric Le Goater uint32_t page_shift; 2481da71b7e3SCédric Le Goater 2482da71b7e3SCédric Le Goater /* For direct tables, fake a valid value */ 2483da71b7e3SCédric Le Goater if (!(VSD_INDIRECT & vsd)) { 2484da71b7e3SCédric Le Goater return 1; 2485da71b7e3SCédric Le Goater } 2486da71b7e3SCédric Le Goater 2487da71b7e3SCédric Le Goater /* Get the page size of the indirect table. */ 2488da71b7e3SCédric Le Goater vsd_addr = vsd & VSD_ADDRESS_MASK; 2489da71b7e3SCédric Le Goater ldq_be_dma(&address_space_memory, vsd_addr, &vsd, MEMTXATTRS_UNSPECIFIED); 2490da71b7e3SCédric Le Goater 2491da71b7e3SCédric Le Goater if (!(vsd & VSD_ADDRESS_MASK)) { 2492da71b7e3SCédric Le Goater #ifdef XIVE2_DEBUG 2493da71b7e3SCédric Le Goater xive2_error(xive, "VST: invalid %s entry!?", info->name); 2494da71b7e3SCédric Le Goater #endif 2495da71b7e3SCédric Le Goater return 0; 2496da71b7e3SCédric Le Goater } 2497da71b7e3SCédric Le Goater 2498da71b7e3SCédric Le Goater page_shift = GETFIELD(VSD_TSIZE, vsd) + 12; 2499da71b7e3SCédric Le Goater 2500da71b7e3SCédric Le Goater if (!pnv_xive2_vst_page_size_allowed(page_shift)) { 2501da71b7e3SCédric Le Goater xive2_error(xive, "VST: invalid %s page shift %d", info->name, 2502da71b7e3SCédric Le Goater page_shift); 2503da71b7e3SCédric Le Goater return 0; 2504da71b7e3SCédric Le Goater } 2505da71b7e3SCédric Le Goater 2506da71b7e3SCédric Le Goater return (1ull << page_shift) / info->size; 2507da71b7e3SCédric Le Goater } 2508da71b7e3SCédric Le Goater 250970fb275dSPhilippe Mathieu-Daudé void pnv_xive2_pic_print_info(PnvXive2 *xive, GString *buf) 2510da71b7e3SCédric Le Goater { 2511da71b7e3SCédric Le Goater Xive2Router *xrtr = XIVE2_ROUTER(xive); 2512da71b7e3SCédric Le Goater uint8_t blk = pnv_xive2_block_id(xive); 2513da71b7e3SCédric Le Goater uint8_t chip_id = xive->chip->chip_id; 2514da71b7e3SCédric Le Goater uint32_t srcno0 = XIVE_EAS(blk, 0); 2515da71b7e3SCédric Le Goater uint32_t nr_esbs = pnv_xive2_nr_esbs(xive); 2516da71b7e3SCédric Le Goater Xive2Eas eas; 2517da71b7e3SCédric Le Goater Xive2End end; 2518da71b7e3SCédric Le Goater Xive2Nvp nvp; 2519*76798e12SFrederic Barrat Xive2Nvgc nvgc; 2520da71b7e3SCédric Le Goater int i; 2521*76798e12SFrederic Barrat uint64_t entries_per_subpage; 2522da71b7e3SCédric Le Goater 252300186664SPhilippe Mathieu-Daudé g_string_append_printf(buf, "XIVE[%x] Source %08x .. %08x\n", 252400186664SPhilippe Mathieu-Daudé blk, srcno0, srcno0 + nr_esbs - 1); 2525b71a3f67SPhilippe Mathieu-Daudé xive_source_pic_print_info(&xive->ipi_source, srcno0, buf); 2526b71a3f67SPhilippe Mathieu-Daudé 252700186664SPhilippe Mathieu-Daudé g_string_append_printf(buf, "XIVE[%x] EAT %08x .. %08x\n", 252800186664SPhilippe Mathieu-Daudé blk, srcno0, srcno0 + nr_esbs - 1); 2529da71b7e3SCédric Le Goater for (i = 0; i < nr_esbs; i++) { 2530da71b7e3SCédric Le Goater if (xive2_router_get_eas(xrtr, blk, i, &eas)) { 2531da71b7e3SCédric Le Goater break; 2532da71b7e3SCédric Le Goater } 2533da71b7e3SCédric Le Goater if (!xive2_eas_is_masked(&eas)) { 253400186664SPhilippe Mathieu-Daudé xive2_eas_pic_print_info(&eas, i, buf); 2535da71b7e3SCédric Le Goater } 2536da71b7e3SCédric Le Goater } 2537da71b7e3SCédric Le Goater 25389d5c1da9SPhilippe Mathieu-Daudé g_string_append_printf(buf, "XIVE[%x] #%d END Escalation EAT\n", 25399d5c1da9SPhilippe Mathieu-Daudé chip_id, blk); 2540da71b7e3SCédric Le Goater i = 0; 2541da71b7e3SCédric Le Goater while (!xive2_router_get_end(xrtr, blk, i, &end)) { 25429d5c1da9SPhilippe Mathieu-Daudé xive2_end_eas_pic_print_info(&end, i++, buf); 2543da71b7e3SCédric Le Goater } 2544da71b7e3SCédric Le Goater 254533e36426SPhilippe Mathieu-Daudé g_string_append_printf(buf, "XIVE[%x] #%d ENDT\n", chip_id, blk); 2546da71b7e3SCédric Le Goater i = 0; 2547da71b7e3SCédric Le Goater while (!xive2_router_get_end(xrtr, blk, i, &end)) { 254833e36426SPhilippe Mathieu-Daudé xive2_end_pic_print_info(&end, i++, buf); 2549da71b7e3SCédric Le Goater } 2550da71b7e3SCédric Le Goater 2551e6024fd8SPhilippe Mathieu-Daudé g_string_append_printf(buf, "XIVE[%x] #%d NVPT %08x .. %08x\n", 2552e6024fd8SPhilippe Mathieu-Daudé chip_id, blk, 0, XIVE2_NVP_COUNT - 1); 2553*76798e12SFrederic Barrat entries_per_subpage = pnv_xive2_vst_per_subpage(xive, VST_NVP); 2554*76798e12SFrederic Barrat for (i = 0; i < XIVE2_NVP_COUNT; i += entries_per_subpage) { 2555da71b7e3SCédric Le Goater while (!xive2_router_get_nvp(xrtr, blk, i, &nvp)) { 2556e6024fd8SPhilippe Mathieu-Daudé xive2_nvp_pic_print_info(&nvp, i++, buf); 2557da71b7e3SCédric Le Goater } 2558da71b7e3SCédric Le Goater } 2559*76798e12SFrederic Barrat 2560*76798e12SFrederic Barrat g_string_append_printf(buf, "XIVE[%x] #%d NVGT %08x .. %08x\n", 2561*76798e12SFrederic Barrat chip_id, blk, 0, XIVE2_NVP_COUNT - 1); 2562*76798e12SFrederic Barrat entries_per_subpage = pnv_xive2_vst_per_subpage(xive, VST_NVG); 2563*76798e12SFrederic Barrat for (i = 0; i < XIVE2_NVP_COUNT; i += entries_per_subpage) { 2564*76798e12SFrederic Barrat while (!xive2_router_get_nvgc(xrtr, false, blk, i, &nvgc)) { 2565*76798e12SFrederic Barrat xive2_nvgc_pic_print_info(&nvgc, i++, buf); 2566*76798e12SFrederic Barrat } 2567*76798e12SFrederic Barrat } 2568*76798e12SFrederic Barrat 2569*76798e12SFrederic Barrat g_string_append_printf(buf, "XIVE[%x] #%d NVCT %08x .. %08x\n", 2570*76798e12SFrederic Barrat chip_id, blk, 0, XIVE2_NVP_COUNT - 1); 2571*76798e12SFrederic Barrat entries_per_subpage = pnv_xive2_vst_per_subpage(xive, VST_NVC); 2572*76798e12SFrederic Barrat for (i = 0; i < XIVE2_NVP_COUNT; i += entries_per_subpage) { 2573*76798e12SFrederic Barrat while (!xive2_router_get_nvgc(xrtr, true, blk, i, &nvgc)) { 2574*76798e12SFrederic Barrat xive2_nvgc_pic_print_info(&nvgc, i++, buf); 2575*76798e12SFrederic Barrat } 2576*76798e12SFrederic Barrat } 2577da71b7e3SCédric Le Goater } 2578