This source file includes following definitions.
- cik_ih_enable_interrupts
- cik_ih_disable_interrupts
- cik_ih_irq_init
- cik_ih_irq_disable
- cik_ih_get_wptr
- cik_ih_decode_iv
- cik_ih_set_rptr
- cik_ih_early_init
- cik_ih_sw_init
- cik_ih_sw_fini
- cik_ih_hw_init
- cik_ih_hw_fini
- cik_ih_suspend
- cik_ih_resume
- cik_ih_is_idle
- cik_ih_wait_for_idle
- cik_ih_soft_reset
- cik_ih_set_clockgating_state
- cik_ih_set_powergating_state
- cik_ih_set_interrupt_funcs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 #include <linux/pci.h>
25
26 #include "amdgpu.h"
27 #include "amdgpu_ih.h"
28 #include "cikd.h"
29
30 #include "bif/bif_4_1_d.h"
31 #include "bif/bif_4_1_sh_mask.h"
32
33 #include "oss/oss_2_0_d.h"
34 #include "oss/oss_2_0_sh_mask.h"
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51 static void cik_ih_set_interrupt_funcs(struct amdgpu_device *adev);
52
53
54
55
56
57
58
59
60 static void cik_ih_enable_interrupts(struct amdgpu_device *adev)
61 {
62 u32 ih_cntl = RREG32(mmIH_CNTL);
63 u32 ih_rb_cntl = RREG32(mmIH_RB_CNTL);
64
65 ih_cntl |= IH_CNTL__ENABLE_INTR_MASK;
66 ih_rb_cntl |= IH_RB_CNTL__RB_ENABLE_MASK;
67 WREG32(mmIH_CNTL, ih_cntl);
68 WREG32(mmIH_RB_CNTL, ih_rb_cntl);
69 adev->irq.ih.enabled = true;
70 }
71
72
73
74
75
76
77
78
79 static void cik_ih_disable_interrupts(struct amdgpu_device *adev)
80 {
81 u32 ih_rb_cntl = RREG32(mmIH_RB_CNTL);
82 u32 ih_cntl = RREG32(mmIH_CNTL);
83
84 ih_rb_cntl &= ~IH_RB_CNTL__RB_ENABLE_MASK;
85 ih_cntl &= ~IH_CNTL__ENABLE_INTR_MASK;
86 WREG32(mmIH_RB_CNTL, ih_rb_cntl);
87 WREG32(mmIH_CNTL, ih_cntl);
88
89 WREG32(mmIH_RB_RPTR, 0);
90 WREG32(mmIH_RB_WPTR, 0);
91 adev->irq.ih.enabled = false;
92 adev->irq.ih.rptr = 0;
93 }
94
95
96
97
98
99
100
101
102
103
104
105
106 static int cik_ih_irq_init(struct amdgpu_device *adev)
107 {
108 struct amdgpu_ih_ring *ih = &adev->irq.ih;
109 int rb_bufsz;
110 u32 interrupt_cntl, ih_cntl, ih_rb_cntl;
111
112
113 cik_ih_disable_interrupts(adev);
114
115
116 WREG32(mmINTERRUPT_CNTL2, adev->dummy_page_addr >> 8);
117 interrupt_cntl = RREG32(mmINTERRUPT_CNTL);
118
119
120
121 interrupt_cntl &= ~INTERRUPT_CNTL__IH_DUMMY_RD_OVERRIDE_MASK;
122
123 interrupt_cntl &= ~INTERRUPT_CNTL__IH_REQ_NONSNOOP_EN_MASK;
124 WREG32(mmINTERRUPT_CNTL, interrupt_cntl);
125
126 WREG32(mmIH_RB_BASE, adev->irq.ih.gpu_addr >> 8);
127 rb_bufsz = order_base_2(adev->irq.ih.ring_size / 4);
128
129 ih_rb_cntl = (IH_RB_CNTL__WPTR_OVERFLOW_ENABLE_MASK |
130 IH_RB_CNTL__WPTR_OVERFLOW_CLEAR_MASK |
131 (rb_bufsz << 1));
132
133 ih_rb_cntl |= IH_RB_CNTL__WPTR_WRITEBACK_ENABLE_MASK;
134
135
136 WREG32(mmIH_RB_WPTR_ADDR_LO, lower_32_bits(ih->wptr_addr));
137 WREG32(mmIH_RB_WPTR_ADDR_HI, upper_32_bits(ih->wptr_addr) & 0xFF);
138
139 WREG32(mmIH_RB_CNTL, ih_rb_cntl);
140
141
142 WREG32(mmIH_RB_RPTR, 0);
143 WREG32(mmIH_RB_WPTR, 0);
144
145
146 ih_cntl = (0x10 << IH_CNTL__MC_WRREQ_CREDIT__SHIFT) |
147 (0x10 << IH_CNTL__MC_WR_CLEAN_CNT__SHIFT) |
148 (0 << IH_CNTL__MC_VMID__SHIFT);
149
150 if (adev->irq.msi_enabled)
151 ih_cntl |= IH_CNTL__RPTR_REARM_MASK;
152 WREG32(mmIH_CNTL, ih_cntl);
153
154 pci_set_master(adev->pdev);
155
156
157 cik_ih_enable_interrupts(adev);
158
159 return 0;
160 }
161
162
163
164
165
166
167
168
169 static void cik_ih_irq_disable(struct amdgpu_device *adev)
170 {
171 cik_ih_disable_interrupts(adev);
172
173 mdelay(1);
174 }
175
176
177
178
179
180
181
182
183
184
185
186
187 static u32 cik_ih_get_wptr(struct amdgpu_device *adev,
188 struct amdgpu_ih_ring *ih)
189 {
190 u32 wptr, tmp;
191
192 wptr = le32_to_cpu(*ih->wptr_cpu);
193
194 if (wptr & IH_RB_WPTR__RB_OVERFLOW_MASK) {
195 wptr &= ~IH_RB_WPTR__RB_OVERFLOW_MASK;
196
197
198
199
200 dev_warn(adev->dev, "IH ring buffer overflow (0x%08X, 0x%08X, 0x%08X)\n",
201 wptr, ih->rptr, (wptr + 16) & ih->ptr_mask);
202 ih->rptr = (wptr + 16) & ih->ptr_mask;
203 tmp = RREG32(mmIH_RB_CNTL);
204 tmp |= IH_RB_CNTL__WPTR_OVERFLOW_CLEAR_MASK;
205 WREG32(mmIH_RB_CNTL, tmp);
206 }
207 return (wptr & ih->ptr_mask);
208 }
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241 static void cik_ih_decode_iv(struct amdgpu_device *adev,
242 struct amdgpu_ih_ring *ih,
243 struct amdgpu_iv_entry *entry)
244 {
245
246 u32 ring_index = ih->rptr >> 2;
247 uint32_t dw[4];
248
249 dw[0] = le32_to_cpu(ih->ring[ring_index + 0]);
250 dw[1] = le32_to_cpu(ih->ring[ring_index + 1]);
251 dw[2] = le32_to_cpu(ih->ring[ring_index + 2]);
252 dw[3] = le32_to_cpu(ih->ring[ring_index + 3]);
253
254 entry->client_id = AMDGPU_IRQ_CLIENTID_LEGACY;
255 entry->src_id = dw[0] & 0xff;
256 entry->src_data[0] = dw[1] & 0xfffffff;
257 entry->ring_id = dw[2] & 0xff;
258 entry->vmid = (dw[2] >> 8) & 0xff;
259 entry->pasid = (dw[2] >> 16) & 0xffff;
260
261
262 ih->rptr += 16;
263 }
264
265
266
267
268
269
270
271
272 static void cik_ih_set_rptr(struct amdgpu_device *adev,
273 struct amdgpu_ih_ring *ih)
274 {
275 WREG32(mmIH_RB_RPTR, ih->rptr);
276 }
277
278 static int cik_ih_early_init(void *handle)
279 {
280 struct amdgpu_device *adev = (struct amdgpu_device *)handle;
281 int ret;
282
283 ret = amdgpu_irq_add_domain(adev);
284 if (ret)
285 return ret;
286
287 cik_ih_set_interrupt_funcs(adev);
288
289 return 0;
290 }
291
292 static int cik_ih_sw_init(void *handle)
293 {
294 int r;
295 struct amdgpu_device *adev = (struct amdgpu_device *)handle;
296
297 r = amdgpu_ih_ring_init(adev, &adev->irq.ih, 64 * 1024, false);
298 if (r)
299 return r;
300
301 r = amdgpu_irq_init(adev);
302
303 return r;
304 }
305
306 static int cik_ih_sw_fini(void *handle)
307 {
308 struct amdgpu_device *adev = (struct amdgpu_device *)handle;
309
310 amdgpu_irq_fini(adev);
311 amdgpu_ih_ring_fini(adev, &adev->irq.ih);
312 amdgpu_irq_remove_domain(adev);
313
314 return 0;
315 }
316
317 static int cik_ih_hw_init(void *handle)
318 {
319 int r;
320 struct amdgpu_device *adev = (struct amdgpu_device *)handle;
321
322 r = cik_ih_irq_init(adev);
323 if (r)
324 return r;
325
326 return 0;
327 }
328
329 static int cik_ih_hw_fini(void *handle)
330 {
331 struct amdgpu_device *adev = (struct amdgpu_device *)handle;
332
333 cik_ih_irq_disable(adev);
334
335 return 0;
336 }
337
338 static int cik_ih_suspend(void *handle)
339 {
340 struct amdgpu_device *adev = (struct amdgpu_device *)handle;
341
342 return cik_ih_hw_fini(adev);
343 }
344
345 static int cik_ih_resume(void *handle)
346 {
347 struct amdgpu_device *adev = (struct amdgpu_device *)handle;
348
349 return cik_ih_hw_init(adev);
350 }
351
352 static bool cik_ih_is_idle(void *handle)
353 {
354 struct amdgpu_device *adev = (struct amdgpu_device *)handle;
355 u32 tmp = RREG32(mmSRBM_STATUS);
356
357 if (tmp & SRBM_STATUS__IH_BUSY_MASK)
358 return false;
359
360 return true;
361 }
362
363 static int cik_ih_wait_for_idle(void *handle)
364 {
365 unsigned i;
366 u32 tmp;
367 struct amdgpu_device *adev = (struct amdgpu_device *)handle;
368
369 for (i = 0; i < adev->usec_timeout; i++) {
370
371 tmp = RREG32(mmSRBM_STATUS) & SRBM_STATUS__IH_BUSY_MASK;
372 if (!tmp)
373 return 0;
374 udelay(1);
375 }
376 return -ETIMEDOUT;
377 }
378
379 static int cik_ih_soft_reset(void *handle)
380 {
381 struct amdgpu_device *adev = (struct amdgpu_device *)handle;
382
383 u32 srbm_soft_reset = 0;
384 u32 tmp = RREG32(mmSRBM_STATUS);
385
386 if (tmp & SRBM_STATUS__IH_BUSY_MASK)
387 srbm_soft_reset |= SRBM_SOFT_RESET__SOFT_RESET_IH_MASK;
388
389 if (srbm_soft_reset) {
390 tmp = RREG32(mmSRBM_SOFT_RESET);
391 tmp |= srbm_soft_reset;
392 dev_info(adev->dev, "SRBM_SOFT_RESET=0x%08X\n", tmp);
393 WREG32(mmSRBM_SOFT_RESET, tmp);
394 tmp = RREG32(mmSRBM_SOFT_RESET);
395
396 udelay(50);
397
398 tmp &= ~srbm_soft_reset;
399 WREG32(mmSRBM_SOFT_RESET, tmp);
400 tmp = RREG32(mmSRBM_SOFT_RESET);
401
402
403 udelay(50);
404 }
405
406 return 0;
407 }
408
409 static int cik_ih_set_clockgating_state(void *handle,
410 enum amd_clockgating_state state)
411 {
412 return 0;
413 }
414
415 static int cik_ih_set_powergating_state(void *handle,
416 enum amd_powergating_state state)
417 {
418 return 0;
419 }
420
421 static const struct amd_ip_funcs cik_ih_ip_funcs = {
422 .name = "cik_ih",
423 .early_init = cik_ih_early_init,
424 .late_init = NULL,
425 .sw_init = cik_ih_sw_init,
426 .sw_fini = cik_ih_sw_fini,
427 .hw_init = cik_ih_hw_init,
428 .hw_fini = cik_ih_hw_fini,
429 .suspend = cik_ih_suspend,
430 .resume = cik_ih_resume,
431 .is_idle = cik_ih_is_idle,
432 .wait_for_idle = cik_ih_wait_for_idle,
433 .soft_reset = cik_ih_soft_reset,
434 .set_clockgating_state = cik_ih_set_clockgating_state,
435 .set_powergating_state = cik_ih_set_powergating_state,
436 };
437
438 static const struct amdgpu_ih_funcs cik_ih_funcs = {
439 .get_wptr = cik_ih_get_wptr,
440 .decode_iv = cik_ih_decode_iv,
441 .set_rptr = cik_ih_set_rptr
442 };
443
444 static void cik_ih_set_interrupt_funcs(struct amdgpu_device *adev)
445 {
446 adev->irq.ih_funcs = &cik_ih_funcs;
447 }
448
449 const struct amdgpu_ip_block_version cik_ih_ip_block =
450 {
451 .type = AMD_IP_BLOCK_TYPE_IH,
452 .major = 2,
453 .minor = 0,
454 .rev = 0,
455 .funcs = &cik_ih_ip_funcs,
456 };