1edc61147SHawking Zhang /* 2edc61147SHawking Zhang * Copyright 2019 Advanced Micro Devices, Inc. 3edc61147SHawking Zhang * 4edc61147SHawking Zhang * Permission is hereby granted, free of charge, to any person obtaining a 5edc61147SHawking Zhang * copy of this software and associated documentation files (the "Software"), 6edc61147SHawking Zhang * to deal in the Software without restriction, including without limitation 7edc61147SHawking Zhang * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8edc61147SHawking Zhang * and/or sell copies of the Software, and to permit persons to whom the 9edc61147SHawking Zhang * Software is furnished to do so, subject to the following conditions: 10edc61147SHawking Zhang * 11edc61147SHawking Zhang * The above copyright notice and this permission notice shall be included in 12edc61147SHawking Zhang * all copies or substantial portions of the Software. 13edc61147SHawking Zhang * 14edc61147SHawking Zhang * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15edc61147SHawking Zhang * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16edc61147SHawking Zhang * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 17edc61147SHawking Zhang * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR 18edc61147SHawking Zhang * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 19edc61147SHawking Zhang * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 20edc61147SHawking Zhang * OTHER DEALINGS IN THE SOFTWARE. 21edc61147SHawking Zhang * 22edc61147SHawking Zhang */ 23edc61147SHawking Zhang 24b23b2e9eSAlex Deucher #include <linux/pci.h> 25b23b2e9eSAlex Deucher 26edc61147SHawking Zhang #include "amdgpu.h" 27edc61147SHawking Zhang #include "amdgpu_ih.h" 28edc61147SHawking Zhang 29edc61147SHawking Zhang #include "oss/osssys_5_0_0_offset.h" 30edc61147SHawking Zhang #include "oss/osssys_5_0_0_sh_mask.h" 31edc61147SHawking Zhang 32edc61147SHawking Zhang #include "soc15_common.h" 33edc61147SHawking Zhang #include "navi10_ih.h" 34edc61147SHawking Zhang 35022b6518SSamir Dhume #define MAX_REARM_RETRY 10 36edc61147SHawking Zhang 37edc61147SHawking Zhang static void navi10_ih_set_interrupt_funcs(struct amdgpu_device *adev); 38edc61147SHawking Zhang 39edc61147SHawking Zhang /** 40edc61147SHawking Zhang * navi10_ih_enable_interrupts - Enable the interrupt ring buffer 41edc61147SHawking Zhang * 42edc61147SHawking Zhang * @adev: amdgpu_device pointer 43edc61147SHawking Zhang * 44edc61147SHawking Zhang * Enable the interrupt ring buffer (NAVI10). 45edc61147SHawking Zhang */ 46edc61147SHawking Zhang static void navi10_ih_enable_interrupts(struct amdgpu_device *adev) 47edc61147SHawking Zhang { 48edc61147SHawking Zhang u32 ih_rb_cntl = RREG32_SOC15(OSSSYS, 0, mmIH_RB_CNTL); 49edc61147SHawking Zhang 50edc61147SHawking Zhang ih_rb_cntl = REG_SET_FIELD(ih_rb_cntl, IH_RB_CNTL, RB_ENABLE, 1); 51edc61147SHawking Zhang ih_rb_cntl = REG_SET_FIELD(ih_rb_cntl, IH_RB_CNTL, ENABLE_INTR, 1); 52edc61147SHawking Zhang WREG32_SOC15(OSSSYS, 0, mmIH_RB_CNTL, ih_rb_cntl); 53edc61147SHawking Zhang adev->irq.ih.enabled = true; 54edc61147SHawking Zhang } 55edc61147SHawking Zhang 56edc61147SHawking Zhang /** 57edc61147SHawking Zhang * navi10_ih_disable_interrupts - Disable the interrupt ring buffer 58edc61147SHawking Zhang * 59edc61147SHawking Zhang * @adev: amdgpu_device pointer 60edc61147SHawking Zhang * 61edc61147SHawking Zhang * Disable the interrupt ring buffer (NAVI10). 62edc61147SHawking Zhang */ 63edc61147SHawking Zhang static void navi10_ih_disable_interrupts(struct amdgpu_device *adev) 64edc61147SHawking Zhang { 65edc61147SHawking Zhang u32 ih_rb_cntl = RREG32_SOC15(OSSSYS, 0, mmIH_RB_CNTL); 66edc61147SHawking Zhang 67edc61147SHawking Zhang ih_rb_cntl = REG_SET_FIELD(ih_rb_cntl, IH_RB_CNTL, RB_ENABLE, 0); 68edc61147SHawking Zhang ih_rb_cntl = REG_SET_FIELD(ih_rb_cntl, IH_RB_CNTL, ENABLE_INTR, 0); 69edc61147SHawking Zhang WREG32_SOC15(OSSSYS, 0, mmIH_RB_CNTL, ih_rb_cntl); 70edc61147SHawking Zhang /* set rptr, wptr to 0 */ 71edc61147SHawking Zhang WREG32_SOC15(OSSSYS, 0, mmIH_RB_RPTR, 0); 72edc61147SHawking Zhang WREG32_SOC15(OSSSYS, 0, mmIH_RB_WPTR, 0); 73edc61147SHawking Zhang adev->irq.ih.enabled = false; 74edc61147SHawking Zhang adev->irq.ih.rptr = 0; 75edc61147SHawking Zhang } 76edc61147SHawking Zhang 77edc61147SHawking Zhang static uint32_t navi10_ih_rb_cntl(struct amdgpu_ih_ring *ih, uint32_t ih_rb_cntl) 78edc61147SHawking Zhang { 79edc61147SHawking Zhang int rb_bufsz = order_base_2(ih->ring_size / 4); 80edc61147SHawking Zhang 81edc61147SHawking Zhang ih_rb_cntl = REG_SET_FIELD(ih_rb_cntl, IH_RB_CNTL, 82edc61147SHawking Zhang MC_SPACE, ih->use_bus_addr ? 1 : 4); 83edc61147SHawking Zhang ih_rb_cntl = REG_SET_FIELD(ih_rb_cntl, IH_RB_CNTL, 84edc61147SHawking Zhang WPTR_OVERFLOW_CLEAR, 1); 85edc61147SHawking Zhang ih_rb_cntl = REG_SET_FIELD(ih_rb_cntl, IH_RB_CNTL, 86edc61147SHawking Zhang WPTR_OVERFLOW_ENABLE, 1); 87edc61147SHawking Zhang ih_rb_cntl = REG_SET_FIELD(ih_rb_cntl, IH_RB_CNTL, RB_SIZE, rb_bufsz); 88edc61147SHawking Zhang /* Ring Buffer write pointer writeback. If enabled, IH_RB_WPTR register 89edc61147SHawking Zhang * value is written to memory 90edc61147SHawking Zhang */ 91edc61147SHawking Zhang ih_rb_cntl = REG_SET_FIELD(ih_rb_cntl, IH_RB_CNTL, 92edc61147SHawking Zhang WPTR_WRITEBACK_ENABLE, 1); 93edc61147SHawking Zhang ih_rb_cntl = REG_SET_FIELD(ih_rb_cntl, IH_RB_CNTL, MC_SNOOP, 1); 94edc61147SHawking Zhang ih_rb_cntl = REG_SET_FIELD(ih_rb_cntl, IH_RB_CNTL, MC_RO, 0); 95edc61147SHawking Zhang ih_rb_cntl = REG_SET_FIELD(ih_rb_cntl, IH_RB_CNTL, MC_VMID, 0); 96edc61147SHawking Zhang 97edc61147SHawking Zhang return ih_rb_cntl; 98edc61147SHawking Zhang } 99edc61147SHawking Zhang 100edc61147SHawking Zhang /** 101edc61147SHawking Zhang * navi10_ih_irq_init - init and enable the interrupt ring 102edc61147SHawking Zhang * 103edc61147SHawking Zhang * @adev: amdgpu_device pointer 104edc61147SHawking Zhang * 105edc61147SHawking Zhang * Allocate a ring buffer for the interrupt controller, 106edc61147SHawking Zhang * enable the RLC, disable interrupts, enable the IH 107edc61147SHawking Zhang * ring buffer and enable it (NAVI). 108edc61147SHawking Zhang * Called at device load and reume. 109edc61147SHawking Zhang * Returns 0 for success, errors for failure. 110edc61147SHawking Zhang */ 111edc61147SHawking Zhang static int navi10_ih_irq_init(struct amdgpu_device *adev) 112edc61147SHawking Zhang { 113edc61147SHawking Zhang struct amdgpu_ih_ring *ih = &adev->irq.ih; 114edc61147SHawking Zhang u32 ih_rb_cntl, ih_doorbell_rtpr, ih_chicken; 115edc61147SHawking Zhang u32 tmp; 116edc61147SHawking Zhang 117edc61147SHawking Zhang /* disable irqs */ 118edc61147SHawking Zhang navi10_ih_disable_interrupts(adev); 119edc61147SHawking Zhang 120bebc0762SHawking Zhang adev->nbio.funcs->ih_control(adev); 121edc61147SHawking Zhang 122edc61147SHawking Zhang /* Ring Buffer base. [39:8] of 40-bit address of the beginning of the ring buffer*/ 123edc61147SHawking Zhang WREG32_SOC15(OSSSYS, 0, mmIH_RB_BASE, ih->gpu_addr >> 8); 124edc61147SHawking Zhang WREG32_SOC15(OSSSYS, 0, mmIH_RB_BASE_HI, (ih->gpu_addr >> 40) & 0xff); 125edc61147SHawking Zhang 126edc61147SHawking Zhang ih_rb_cntl = RREG32_SOC15(OSSSYS, 0, mmIH_RB_CNTL); 127edc61147SHawking Zhang ih_rb_cntl = navi10_ih_rb_cntl(ih, ih_rb_cntl); 128edc61147SHawking Zhang ih_rb_cntl = REG_SET_FIELD(ih_rb_cntl, IH_RB_CNTL, RPTR_REARM, 129edc61147SHawking Zhang !!adev->irq.msi_enabled); 130edc61147SHawking Zhang 131edc61147SHawking Zhang if (unlikely(adev->firmware.load_type == AMDGPU_FW_LOAD_DIRECT)) { 132edc61147SHawking Zhang if (ih->use_bus_addr) { 133edc61147SHawking Zhang ih_chicken = RREG32_SOC15(OSSSYS, 0, mmIH_CHICKEN); 134edc61147SHawking Zhang ih_chicken = REG_SET_FIELD(ih_chicken, 135edc61147SHawking Zhang IH_CHICKEN, MC_SPACE_GPA_ENABLE, 1); 136edc61147SHawking Zhang WREG32_SOC15(OSSSYS, 0, mmIH_CHICKEN, ih_chicken); 137edc61147SHawking Zhang } 138edc61147SHawking Zhang } 139edc61147SHawking Zhang 140edc61147SHawking Zhang WREG32_SOC15(OSSSYS, 0, mmIH_RB_CNTL, ih_rb_cntl); 141edc61147SHawking Zhang 142edc61147SHawking Zhang /* set the writeback address whether it's enabled or not */ 143edc61147SHawking Zhang WREG32_SOC15(OSSSYS, 0, mmIH_RB_WPTR_ADDR_LO, 144edc61147SHawking Zhang lower_32_bits(ih->wptr_addr)); 145edc61147SHawking Zhang WREG32_SOC15(OSSSYS, 0, mmIH_RB_WPTR_ADDR_HI, 146edc61147SHawking Zhang upper_32_bits(ih->wptr_addr) & 0xFFFF); 147edc61147SHawking Zhang 148edc61147SHawking Zhang /* set rptr, wptr to 0 */ 149edc61147SHawking Zhang WREG32_SOC15(OSSSYS, 0, mmIH_RB_RPTR, 0); 150edc61147SHawking Zhang WREG32_SOC15(OSSSYS, 0, mmIH_RB_WPTR, 0); 151edc61147SHawking Zhang 152edc61147SHawking Zhang ih_doorbell_rtpr = RREG32_SOC15(OSSSYS, 0, mmIH_DOORBELL_RPTR); 153edc61147SHawking Zhang if (ih->use_doorbell) { 154edc61147SHawking Zhang ih_doorbell_rtpr = REG_SET_FIELD(ih_doorbell_rtpr, 155edc61147SHawking Zhang IH_DOORBELL_RPTR, OFFSET, 156edc61147SHawking Zhang ih->doorbell_index); 157edc61147SHawking Zhang ih_doorbell_rtpr = REG_SET_FIELD(ih_doorbell_rtpr, 158edc61147SHawking Zhang IH_DOORBELL_RPTR, ENABLE, 1); 159edc61147SHawking Zhang } else { 160edc61147SHawking Zhang ih_doorbell_rtpr = REG_SET_FIELD(ih_doorbell_rtpr, 161edc61147SHawking Zhang IH_DOORBELL_RPTR, ENABLE, 0); 162edc61147SHawking Zhang } 163edc61147SHawking Zhang WREG32_SOC15(OSSSYS, 0, mmIH_DOORBELL_RPTR, ih_doorbell_rtpr); 164edc61147SHawking Zhang 165bebc0762SHawking Zhang adev->nbio.funcs->ih_doorbell_range(adev, ih->use_doorbell, 166edc61147SHawking Zhang ih->doorbell_index); 167edc61147SHawking Zhang 168edc61147SHawking Zhang tmp = RREG32_SOC15(OSSSYS, 0, mmIH_STORM_CLIENT_LIST_CNTL); 169edc61147SHawking Zhang tmp = REG_SET_FIELD(tmp, IH_STORM_CLIENT_LIST_CNTL, 170edc61147SHawking Zhang CLIENT18_IS_STORM_CLIENT, 1); 171edc61147SHawking Zhang WREG32_SOC15(OSSSYS, 0, mmIH_STORM_CLIENT_LIST_CNTL, tmp); 172edc61147SHawking Zhang 173edc61147SHawking Zhang tmp = RREG32_SOC15(OSSSYS, 0, mmIH_INT_FLOOD_CNTL); 174edc61147SHawking Zhang tmp = REG_SET_FIELD(tmp, IH_INT_FLOOD_CNTL, FLOOD_CNTL_ENABLE, 1); 175edc61147SHawking Zhang WREG32_SOC15(OSSSYS, 0, mmIH_INT_FLOOD_CNTL, tmp); 176edc61147SHawking Zhang 177edc61147SHawking Zhang pci_set_master(adev->pdev); 178edc61147SHawking Zhang 179edc61147SHawking Zhang /* enable interrupts */ 180edc61147SHawking Zhang navi10_ih_enable_interrupts(adev); 181edc61147SHawking Zhang 1827eca4006SMa Feng return 0; 183edc61147SHawking Zhang } 184edc61147SHawking Zhang 185edc61147SHawking Zhang /** 186edc61147SHawking Zhang * navi10_ih_irq_disable - disable interrupts 187edc61147SHawking Zhang * 188edc61147SHawking Zhang * @adev: amdgpu_device pointer 189edc61147SHawking Zhang * 190edc61147SHawking Zhang * Disable interrupts on the hw (NAVI10). 191edc61147SHawking Zhang */ 192edc61147SHawking Zhang static void navi10_ih_irq_disable(struct amdgpu_device *adev) 193edc61147SHawking Zhang { 194edc61147SHawking Zhang navi10_ih_disable_interrupts(adev); 195edc61147SHawking Zhang 196edc61147SHawking Zhang /* Wait and acknowledge irq */ 197edc61147SHawking Zhang mdelay(1); 198edc61147SHawking Zhang } 199edc61147SHawking Zhang 200edc61147SHawking Zhang /** 201edc61147SHawking Zhang * navi10_ih_get_wptr - get the IH ring buffer wptr 202edc61147SHawking Zhang * 203edc61147SHawking Zhang * @adev: amdgpu_device pointer 204edc61147SHawking Zhang * 205edc61147SHawking Zhang * Get the IH ring buffer wptr from either the register 206edc61147SHawking Zhang * or the writeback memory buffer (NAVI10). Also check for 207edc61147SHawking Zhang * ring buffer overflow and deal with it. 208edc61147SHawking Zhang * Returns the value of the wptr. 209edc61147SHawking Zhang */ 210edc61147SHawking Zhang static u32 navi10_ih_get_wptr(struct amdgpu_device *adev, 211edc61147SHawking Zhang struct amdgpu_ih_ring *ih) 212edc61147SHawking Zhang { 213edc61147SHawking Zhang u32 wptr, reg, tmp; 214edc61147SHawking Zhang 215edc61147SHawking Zhang wptr = le32_to_cpu(*ih->wptr_cpu); 216edc61147SHawking Zhang 217edc61147SHawking Zhang if (!REG_GET_FIELD(wptr, IH_RB_WPTR, RB_OVERFLOW)) 218edc61147SHawking Zhang goto out; 219edc61147SHawking Zhang 220edc61147SHawking Zhang reg = SOC15_REG_OFFSET(OSSSYS, 0, mmIH_RB_WPTR); 221edc61147SHawking Zhang wptr = RREG32_NO_KIQ(reg); 222edc61147SHawking Zhang if (!REG_GET_FIELD(wptr, IH_RB_WPTR, RB_OVERFLOW)) 223edc61147SHawking Zhang goto out; 224edc61147SHawking Zhang wptr = REG_SET_FIELD(wptr, IH_RB_WPTR, RB_OVERFLOW, 0); 225edc61147SHawking Zhang 226edc61147SHawking Zhang /* When a ring buffer overflow happen start parsing interrupt 227edc61147SHawking Zhang * from the last not overwritten vector (wptr + 32). Hopefully 228edc61147SHawking Zhang * this should allow us to catch up. 229edc61147SHawking Zhang */ 230edc61147SHawking Zhang tmp = (wptr + 32) & ih->ptr_mask; 231edc61147SHawking Zhang dev_warn(adev->dev, "IH ring buffer overflow " 232edc61147SHawking Zhang "(0x%08X, 0x%08X, 0x%08X)\n", 233edc61147SHawking Zhang wptr, ih->rptr, tmp); 234edc61147SHawking Zhang ih->rptr = tmp; 235edc61147SHawking Zhang 236edc61147SHawking Zhang reg = SOC15_REG_OFFSET(OSSSYS, 0, mmIH_RB_CNTL); 237edc61147SHawking Zhang tmp = RREG32_NO_KIQ(reg); 238edc61147SHawking Zhang tmp = REG_SET_FIELD(tmp, IH_RB_CNTL, WPTR_OVERFLOW_CLEAR, 1); 239edc61147SHawking Zhang WREG32_NO_KIQ(reg, tmp); 240edc61147SHawking Zhang out: 241edc61147SHawking Zhang return (wptr & ih->ptr_mask); 242edc61147SHawking Zhang } 243edc61147SHawking Zhang 244edc61147SHawking Zhang /** 245edc61147SHawking Zhang * navi10_ih_decode_iv - decode an interrupt vector 246edc61147SHawking Zhang * 247edc61147SHawking Zhang * @adev: amdgpu_device pointer 248edc61147SHawking Zhang * 249edc61147SHawking Zhang * Decodes the interrupt vector at the current rptr 250edc61147SHawking Zhang * position and also advance the position. 251edc61147SHawking Zhang */ 252edc61147SHawking Zhang static void navi10_ih_decode_iv(struct amdgpu_device *adev, 253edc61147SHawking Zhang struct amdgpu_ih_ring *ih, 254edc61147SHawking Zhang struct amdgpu_iv_entry *entry) 255edc61147SHawking Zhang { 256edc61147SHawking Zhang /* wptr/rptr are in bytes! */ 257edc61147SHawking Zhang u32 ring_index = ih->rptr >> 2; 258edc61147SHawking Zhang uint32_t dw[8]; 259edc61147SHawking Zhang 260edc61147SHawking Zhang dw[0] = le32_to_cpu(ih->ring[ring_index + 0]); 261edc61147SHawking Zhang dw[1] = le32_to_cpu(ih->ring[ring_index + 1]); 262edc61147SHawking Zhang dw[2] = le32_to_cpu(ih->ring[ring_index + 2]); 263edc61147SHawking Zhang dw[3] = le32_to_cpu(ih->ring[ring_index + 3]); 264edc61147SHawking Zhang dw[4] = le32_to_cpu(ih->ring[ring_index + 4]); 265edc61147SHawking Zhang dw[5] = le32_to_cpu(ih->ring[ring_index + 5]); 266edc61147SHawking Zhang dw[6] = le32_to_cpu(ih->ring[ring_index + 6]); 267edc61147SHawking Zhang dw[7] = le32_to_cpu(ih->ring[ring_index + 7]); 268edc61147SHawking Zhang 269edc61147SHawking Zhang entry->client_id = dw[0] & 0xff; 270edc61147SHawking Zhang entry->src_id = (dw[0] >> 8) & 0xff; 271edc61147SHawking Zhang entry->ring_id = (dw[0] >> 16) & 0xff; 272edc61147SHawking Zhang entry->vmid = (dw[0] >> 24) & 0xf; 273edc61147SHawking Zhang entry->vmid_src = (dw[0] >> 31); 274edc61147SHawking Zhang entry->timestamp = dw[1] | ((u64)(dw[2] & 0xffff) << 32); 275edc61147SHawking Zhang entry->timestamp_src = dw[2] >> 31; 276edc61147SHawking Zhang entry->pasid = dw[3] & 0xffff; 277edc61147SHawking Zhang entry->pasid_src = dw[3] >> 31; 278edc61147SHawking Zhang entry->src_data[0] = dw[4]; 279edc61147SHawking Zhang entry->src_data[1] = dw[5]; 280edc61147SHawking Zhang entry->src_data[2] = dw[6]; 281edc61147SHawking Zhang entry->src_data[3] = dw[7]; 282edc61147SHawking Zhang 283edc61147SHawking Zhang /* wptr/rptr are in bytes! */ 284edc61147SHawking Zhang ih->rptr += 32; 285edc61147SHawking Zhang } 286edc61147SHawking Zhang 287edc61147SHawking Zhang /** 288022b6518SSamir Dhume * navi10_ih_irq_rearm - rearm IRQ if lost 289022b6518SSamir Dhume * 290022b6518SSamir Dhume * @adev: amdgpu_device pointer 291022b6518SSamir Dhume * 292022b6518SSamir Dhume */ 293022b6518SSamir Dhume static void navi10_ih_irq_rearm(struct amdgpu_device *adev, 294022b6518SSamir Dhume struct amdgpu_ih_ring *ih) 295022b6518SSamir Dhume { 296022b6518SSamir Dhume uint32_t reg_rptr = 0; 297022b6518SSamir Dhume uint32_t v = 0; 298022b6518SSamir Dhume uint32_t i = 0; 299022b6518SSamir Dhume 300022b6518SSamir Dhume if (ih == &adev->irq.ih) 301022b6518SSamir Dhume reg_rptr = SOC15_REG_OFFSET(OSSSYS, 0, mmIH_RB_RPTR); 302022b6518SSamir Dhume else if (ih == &adev->irq.ih1) 303022b6518SSamir Dhume reg_rptr = SOC15_REG_OFFSET(OSSSYS, 0, mmIH_RB_RPTR_RING1); 304022b6518SSamir Dhume else if (ih == &adev->irq.ih2) 305022b6518SSamir Dhume reg_rptr = SOC15_REG_OFFSET(OSSSYS, 0, mmIH_RB_RPTR_RING2); 306022b6518SSamir Dhume else 307022b6518SSamir Dhume return; 308022b6518SSamir Dhume 309022b6518SSamir Dhume /* Rearm IRQ / re-write doorbell if doorbell write is lost */ 310022b6518SSamir Dhume for (i = 0; i < MAX_REARM_RETRY; i++) { 311022b6518SSamir Dhume v = RREG32_NO_KIQ(reg_rptr); 312022b6518SSamir Dhume if ((v < ih->ring_size) && (v != ih->rptr)) 313022b6518SSamir Dhume WDOORBELL32(ih->doorbell_index, ih->rptr); 314022b6518SSamir Dhume else 315022b6518SSamir Dhume break; 316022b6518SSamir Dhume } 317022b6518SSamir Dhume } 318022b6518SSamir Dhume 319022b6518SSamir Dhume /** 320edc61147SHawking Zhang * navi10_ih_set_rptr - set the IH ring buffer rptr 321edc61147SHawking Zhang * 322edc61147SHawking Zhang * @adev: amdgpu_device pointer 323edc61147SHawking Zhang * 324edc61147SHawking Zhang * Set the IH ring buffer rptr. 325edc61147SHawking Zhang */ 326edc61147SHawking Zhang static void navi10_ih_set_rptr(struct amdgpu_device *adev, 327edc61147SHawking Zhang struct amdgpu_ih_ring *ih) 328edc61147SHawking Zhang { 329edc61147SHawking Zhang if (ih->use_doorbell) { 330edc61147SHawking Zhang /* XXX check if swapping is necessary on BE */ 331edc61147SHawking Zhang *ih->rptr_cpu = ih->rptr; 332edc61147SHawking Zhang WDOORBELL32(ih->doorbell_index, ih->rptr); 333022b6518SSamir Dhume 334022b6518SSamir Dhume if (amdgpu_sriov_vf(adev)) 335022b6518SSamir Dhume navi10_ih_irq_rearm(adev, ih); 336edc61147SHawking Zhang } else 337edc61147SHawking Zhang WREG32_SOC15(OSSSYS, 0, mmIH_RB_RPTR, ih->rptr); 338edc61147SHawking Zhang } 339edc61147SHawking Zhang 340edc61147SHawking Zhang static int navi10_ih_early_init(void *handle) 341edc61147SHawking Zhang { 342edc61147SHawking Zhang struct amdgpu_device *adev = (struct amdgpu_device *)handle; 343edc61147SHawking Zhang 344edc61147SHawking Zhang navi10_ih_set_interrupt_funcs(adev); 345edc61147SHawking Zhang return 0; 346edc61147SHawking Zhang } 347edc61147SHawking Zhang 348edc61147SHawking Zhang static int navi10_ih_sw_init(void *handle) 349edc61147SHawking Zhang { 350edc61147SHawking Zhang int r; 351edc61147SHawking Zhang struct amdgpu_device *adev = (struct amdgpu_device *)handle; 352edc61147SHawking Zhang bool use_bus_addr; 353edc61147SHawking Zhang 354edc61147SHawking Zhang /* use gpu virtual address for ih ring 355edc61147SHawking Zhang * until ih_checken is programmed to allow 356edc61147SHawking Zhang * use bus address for ih ring by psp bl */ 357edc61147SHawking Zhang use_bus_addr = 358edc61147SHawking Zhang (adev->firmware.load_type == AMDGPU_FW_LOAD_PSP) ? false : true; 359edc61147SHawking Zhang r = amdgpu_ih_ring_init(adev, &adev->irq.ih, 256 * 1024, use_bus_addr); 360edc61147SHawking Zhang if (r) 361edc61147SHawking Zhang return r; 362edc61147SHawking Zhang 363edc61147SHawking Zhang adev->irq.ih.use_doorbell = true; 364edc61147SHawking Zhang adev->irq.ih.doorbell_index = adev->doorbell_index.ih << 1; 365edc61147SHawking Zhang 366edc61147SHawking Zhang r = amdgpu_irq_init(adev); 367edc61147SHawking Zhang 368edc61147SHawking Zhang return r; 369edc61147SHawking Zhang } 370edc61147SHawking Zhang 371edc61147SHawking Zhang static int navi10_ih_sw_fini(void *handle) 372edc61147SHawking Zhang { 373edc61147SHawking Zhang struct amdgpu_device *adev = (struct amdgpu_device *)handle; 374edc61147SHawking Zhang 375edc61147SHawking Zhang amdgpu_irq_fini(adev); 376edc61147SHawking Zhang amdgpu_ih_ring_fini(adev, &adev->irq.ih); 377edc61147SHawking Zhang 378edc61147SHawking Zhang return 0; 379edc61147SHawking Zhang } 380edc61147SHawking Zhang 381edc61147SHawking Zhang static int navi10_ih_hw_init(void *handle) 382edc61147SHawking Zhang { 383edc61147SHawking Zhang int r; 384edc61147SHawking Zhang struct amdgpu_device *adev = (struct amdgpu_device *)handle; 385edc61147SHawking Zhang 386edc61147SHawking Zhang r = navi10_ih_irq_init(adev); 387edc61147SHawking Zhang if (r) 388edc61147SHawking Zhang return r; 389edc61147SHawking Zhang 390edc61147SHawking Zhang return 0; 391edc61147SHawking Zhang } 392edc61147SHawking Zhang 393edc61147SHawking Zhang static int navi10_ih_hw_fini(void *handle) 394edc61147SHawking Zhang { 395edc61147SHawking Zhang struct amdgpu_device *adev = (struct amdgpu_device *)handle; 396edc61147SHawking Zhang 397edc61147SHawking Zhang navi10_ih_irq_disable(adev); 398edc61147SHawking Zhang 399edc61147SHawking Zhang return 0; 400edc61147SHawking Zhang } 401edc61147SHawking Zhang 402edc61147SHawking Zhang static int navi10_ih_suspend(void *handle) 403edc61147SHawking Zhang { 404edc61147SHawking Zhang struct amdgpu_device *adev = (struct amdgpu_device *)handle; 405edc61147SHawking Zhang 406edc61147SHawking Zhang return navi10_ih_hw_fini(adev); 407edc61147SHawking Zhang } 408edc61147SHawking Zhang 409edc61147SHawking Zhang static int navi10_ih_resume(void *handle) 410edc61147SHawking Zhang { 411edc61147SHawking Zhang struct amdgpu_device *adev = (struct amdgpu_device *)handle; 412edc61147SHawking Zhang 413edc61147SHawking Zhang return navi10_ih_hw_init(adev); 414edc61147SHawking Zhang } 415edc61147SHawking Zhang 416edc61147SHawking Zhang static bool navi10_ih_is_idle(void *handle) 417edc61147SHawking Zhang { 418edc61147SHawking Zhang /* todo */ 419edc61147SHawking Zhang return true; 420edc61147SHawking Zhang } 421edc61147SHawking Zhang 422edc61147SHawking Zhang static int navi10_ih_wait_for_idle(void *handle) 423edc61147SHawking Zhang { 424edc61147SHawking Zhang /* todo */ 425edc61147SHawking Zhang return -ETIMEDOUT; 426edc61147SHawking Zhang } 427edc61147SHawking Zhang 428edc61147SHawking Zhang static int navi10_ih_soft_reset(void *handle) 429edc61147SHawking Zhang { 430edc61147SHawking Zhang /* todo */ 431edc61147SHawking Zhang return 0; 432edc61147SHawking Zhang } 433edc61147SHawking Zhang 434edc61147SHawking Zhang static void navi10_ih_update_clockgating_state(struct amdgpu_device *adev, 435edc61147SHawking Zhang bool enable) 436edc61147SHawking Zhang { 437edc61147SHawking Zhang uint32_t data, def, field_val; 438edc61147SHawking Zhang 439edc61147SHawking Zhang if (adev->cg_flags & AMD_CG_SUPPORT_IH_CG) { 440edc61147SHawking Zhang def = data = RREG32_SOC15(OSSSYS, 0, mmIH_CLK_CTRL); 441edc61147SHawking Zhang field_val = enable ? 0 : 1; 442edc61147SHawking Zhang data = REG_SET_FIELD(data, IH_CLK_CTRL, 443edc61147SHawking Zhang DBUS_MUX_CLK_SOFT_OVERRIDE, field_val); 444edc61147SHawking Zhang data = REG_SET_FIELD(data, IH_CLK_CTRL, 445edc61147SHawking Zhang OSSSYS_SHARE_CLK_SOFT_OVERRIDE, field_val); 446edc61147SHawking Zhang data = REG_SET_FIELD(data, IH_CLK_CTRL, 447edc61147SHawking Zhang LIMIT_SMN_CLK_SOFT_OVERRIDE, field_val); 448edc61147SHawking Zhang data = REG_SET_FIELD(data, IH_CLK_CTRL, 449edc61147SHawking Zhang DYN_CLK_SOFT_OVERRIDE, field_val); 450edc61147SHawking Zhang data = REG_SET_FIELD(data, IH_CLK_CTRL, 451edc61147SHawking Zhang REG_CLK_SOFT_OVERRIDE, field_val); 452edc61147SHawking Zhang if (def != data) 453edc61147SHawking Zhang WREG32_SOC15(OSSSYS, 0, mmIH_CLK_CTRL, data); 454edc61147SHawking Zhang } 455edc61147SHawking Zhang 456edc61147SHawking Zhang return; 457edc61147SHawking Zhang } 458edc61147SHawking Zhang 459edc61147SHawking Zhang static int navi10_ih_set_clockgating_state(void *handle, 460edc61147SHawking Zhang enum amd_clockgating_state state) 461edc61147SHawking Zhang { 462edc61147SHawking Zhang struct amdgpu_device *adev = (struct amdgpu_device *)handle; 463edc61147SHawking Zhang 464edc61147SHawking Zhang navi10_ih_update_clockgating_state(adev, 465a9d4fe2fSNirmoy Das state == AMD_CG_STATE_GATE); 466edc61147SHawking Zhang return 0; 467edc61147SHawking Zhang } 468edc61147SHawking Zhang 469edc61147SHawking Zhang static int navi10_ih_set_powergating_state(void *handle, 470edc61147SHawking Zhang enum amd_powergating_state state) 471edc61147SHawking Zhang { 472edc61147SHawking Zhang return 0; 473edc61147SHawking Zhang } 474edc61147SHawking Zhang 475edc61147SHawking Zhang static void navi10_ih_get_clockgating_state(void *handle, u32 *flags) 476edc61147SHawking Zhang { 477edc61147SHawking Zhang struct amdgpu_device *adev = (struct amdgpu_device *)handle; 478edc61147SHawking Zhang 479edc61147SHawking Zhang if (!RREG32_SOC15(OSSSYS, 0, mmIH_CLK_CTRL)) 480edc61147SHawking Zhang *flags |= AMD_CG_SUPPORT_IH_CG; 481edc61147SHawking Zhang 482edc61147SHawking Zhang return; 483edc61147SHawking Zhang } 484edc61147SHawking Zhang 485edc61147SHawking Zhang static const struct amd_ip_funcs navi10_ih_ip_funcs = { 486edc61147SHawking Zhang .name = "navi10_ih", 487edc61147SHawking Zhang .early_init = navi10_ih_early_init, 488edc61147SHawking Zhang .late_init = NULL, 489edc61147SHawking Zhang .sw_init = navi10_ih_sw_init, 490edc61147SHawking Zhang .sw_fini = navi10_ih_sw_fini, 491edc61147SHawking Zhang .hw_init = navi10_ih_hw_init, 492edc61147SHawking Zhang .hw_fini = navi10_ih_hw_fini, 493edc61147SHawking Zhang .suspend = navi10_ih_suspend, 494edc61147SHawking Zhang .resume = navi10_ih_resume, 495edc61147SHawking Zhang .is_idle = navi10_ih_is_idle, 496edc61147SHawking Zhang .wait_for_idle = navi10_ih_wait_for_idle, 497edc61147SHawking Zhang .soft_reset = navi10_ih_soft_reset, 498edc61147SHawking Zhang .set_clockgating_state = navi10_ih_set_clockgating_state, 499edc61147SHawking Zhang .set_powergating_state = navi10_ih_set_powergating_state, 500edc61147SHawking Zhang .get_clockgating_state = navi10_ih_get_clockgating_state, 501edc61147SHawking Zhang }; 502edc61147SHawking Zhang 503edc61147SHawking Zhang static const struct amdgpu_ih_funcs navi10_ih_funcs = { 504edc61147SHawking Zhang .get_wptr = navi10_ih_get_wptr, 505edc61147SHawking Zhang .decode_iv = navi10_ih_decode_iv, 506edc61147SHawking Zhang .set_rptr = navi10_ih_set_rptr 507edc61147SHawking Zhang }; 508edc61147SHawking Zhang 509edc61147SHawking Zhang static void navi10_ih_set_interrupt_funcs(struct amdgpu_device *adev) 510edc61147SHawking Zhang { 511edc61147SHawking Zhang if (adev->irq.ih_funcs == NULL) 512edc61147SHawking Zhang adev->irq.ih_funcs = &navi10_ih_funcs; 513edc61147SHawking Zhang } 514edc61147SHawking Zhang 515edc61147SHawking Zhang const struct amdgpu_ip_block_version navi10_ih_ip_block = 516edc61147SHawking Zhang { 517edc61147SHawking Zhang .type = AMD_IP_BLOCK_TYPE_IH, 518edc61147SHawking Zhang .major = 5, 519edc61147SHawking Zhang .minor = 0, 520edc61147SHawking Zhang .rev = 0, 521edc61147SHawking Zhang .funcs = &navi10_ih_ip_funcs, 522edc61147SHawking Zhang }; 523