2 * Copyright 2010 Advanced Micro Devices, Inc.
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
22 * Authors: Alex Deucher
24 #include <linux/firmware.h>
25 #include <linux/platform_device.h>
26 #include <linux/slab.h>
29 #include "radeon_asic.h"
30 #include <drm/radeon_drm.h>
31 #include "evergreend.h"
34 #include "evergreen_reg.h"
35 #include "evergreen_blit_shaders.h"
36 #include "radeon_ucode.h"
38 static const u32 crtc_offsets
[6] =
40 EVERGREEN_CRTC0_REGISTER_OFFSET
,
41 EVERGREEN_CRTC1_REGISTER_OFFSET
,
42 EVERGREEN_CRTC2_REGISTER_OFFSET
,
43 EVERGREEN_CRTC3_REGISTER_OFFSET
,
44 EVERGREEN_CRTC4_REGISTER_OFFSET
,
45 EVERGREEN_CRTC5_REGISTER_OFFSET
48 #include "clearstate_evergreen.h"
50 static u32 sumo_rlc_save_restore_register_list
[] =
134 static u32 sumo_rlc_save_restore_register_list_size
= ARRAY_SIZE(sumo_rlc_save_restore_register_list
);
136 static void evergreen_gpu_init(struct radeon_device
*rdev
);
137 void evergreen_fini(struct radeon_device
*rdev
);
138 void evergreen_pcie_gen2_enable(struct radeon_device
*rdev
);
139 extern void cayman_cp_int_cntl_setup(struct radeon_device
*rdev
,
140 int ring
, u32 cp_int_cntl
);
142 static const u32 evergreen_golden_registers
[] =
144 0x3f90, 0xffff0000, 0xff000000,
145 0x9148, 0xffff0000, 0xff000000,
146 0x3f94, 0xffff0000, 0xff000000,
147 0x914c, 0xffff0000, 0xff000000,
148 0x9b7c, 0xffffffff, 0x00000000,
149 0x8a14, 0xffffffff, 0x00000007,
150 0x8b10, 0xffffffff, 0x00000000,
151 0x960c, 0xffffffff, 0x54763210,
152 0x88c4, 0xffffffff, 0x000000c2,
153 0x88d4, 0xffffffff, 0x00000010,
154 0x8974, 0xffffffff, 0x00000000,
155 0xc78, 0x00000080, 0x00000080,
156 0x5eb4, 0xffffffff, 0x00000002,
157 0x5e78, 0xffffffff, 0x001000f0,
158 0x6104, 0x01000300, 0x00000000,
159 0x5bc0, 0x00300000, 0x00000000,
160 0x7030, 0xffffffff, 0x00000011,
161 0x7c30, 0xffffffff, 0x00000011,
162 0x10830, 0xffffffff, 0x00000011,
163 0x11430, 0xffffffff, 0x00000011,
164 0x12030, 0xffffffff, 0x00000011,
165 0x12c30, 0xffffffff, 0x00000011,
166 0xd02c, 0xffffffff, 0x08421000,
167 0x240c, 0xffffffff, 0x00000380,
168 0x8b24, 0xffffffff, 0x00ff0fff,
169 0x28a4c, 0x06000000, 0x06000000,
170 0x10c, 0x00000001, 0x00000001,
171 0x8d00, 0xffffffff, 0x100e4848,
172 0x8d04, 0xffffffff, 0x00164745,
173 0x8c00, 0xffffffff, 0xe4000003,
174 0x8c04, 0xffffffff, 0x40600060,
175 0x8c08, 0xffffffff, 0x001c001c,
176 0x8cf0, 0xffffffff, 0x08e00620,
177 0x8c20, 0xffffffff, 0x00800080,
178 0x8c24, 0xffffffff, 0x00800080,
179 0x8c18, 0xffffffff, 0x20202078,
180 0x8c1c, 0xffffffff, 0x00001010,
181 0x28350, 0xffffffff, 0x00000000,
182 0xa008, 0xffffffff, 0x00010000,
183 0x5cc, 0xffffffff, 0x00000001,
184 0x9508, 0xffffffff, 0x00000002,
185 0x913c, 0x0000000f, 0x0000000a
188 static const u32 evergreen_golden_registers2
[] =
190 0x2f4c, 0xffffffff, 0x00000000,
191 0x54f4, 0xffffffff, 0x00000000,
192 0x54f0, 0xffffffff, 0x00000000,
193 0x5498, 0xffffffff, 0x00000000,
194 0x549c, 0xffffffff, 0x00000000,
195 0x5494, 0xffffffff, 0x00000000,
196 0x53cc, 0xffffffff, 0x00000000,
197 0x53c8, 0xffffffff, 0x00000000,
198 0x53c4, 0xffffffff, 0x00000000,
199 0x53c0, 0xffffffff, 0x00000000,
200 0x53bc, 0xffffffff, 0x00000000,
201 0x53b8, 0xffffffff, 0x00000000,
202 0x53b4, 0xffffffff, 0x00000000,
203 0x53b0, 0xffffffff, 0x00000000
206 static const u32 cypress_mgcg_init
[] =
208 0x802c, 0xffffffff, 0xc0000000,
209 0x5448, 0xffffffff, 0x00000100,
210 0x55e4, 0xffffffff, 0x00000100,
211 0x160c, 0xffffffff, 0x00000100,
212 0x5644, 0xffffffff, 0x00000100,
213 0xc164, 0xffffffff, 0x00000100,
214 0x8a18, 0xffffffff, 0x00000100,
215 0x897c, 0xffffffff, 0x06000100,
216 0x8b28, 0xffffffff, 0x00000100,
217 0x9144, 0xffffffff, 0x00000100,
218 0x9a60, 0xffffffff, 0x00000100,
219 0x9868, 0xffffffff, 0x00000100,
220 0x8d58, 0xffffffff, 0x00000100,
221 0x9510, 0xffffffff, 0x00000100,
222 0x949c, 0xffffffff, 0x00000100,
223 0x9654, 0xffffffff, 0x00000100,
224 0x9030, 0xffffffff, 0x00000100,
225 0x9034, 0xffffffff, 0x00000100,
226 0x9038, 0xffffffff, 0x00000100,
227 0x903c, 0xffffffff, 0x00000100,
228 0x9040, 0xffffffff, 0x00000100,
229 0xa200, 0xffffffff, 0x00000100,
230 0xa204, 0xffffffff, 0x00000100,
231 0xa208, 0xffffffff, 0x00000100,
232 0xa20c, 0xffffffff, 0x00000100,
233 0x971c, 0xffffffff, 0x00000100,
234 0x977c, 0xffffffff, 0x00000100,
235 0x3f80, 0xffffffff, 0x00000100,
236 0xa210, 0xffffffff, 0x00000100,
237 0xa214, 0xffffffff, 0x00000100,
238 0x4d8, 0xffffffff, 0x00000100,
239 0x9784, 0xffffffff, 0x00000100,
240 0x9698, 0xffffffff, 0x00000100,
241 0x4d4, 0xffffffff, 0x00000200,
242 0x30cc, 0xffffffff, 0x00000100,
243 0xd0c0, 0xffffffff, 0xff000100,
244 0x802c, 0xffffffff, 0x40000000,
245 0x915c, 0xffffffff, 0x00010000,
246 0x9160, 0xffffffff, 0x00030002,
247 0x9178, 0xffffffff, 0x00070000,
248 0x917c, 0xffffffff, 0x00030002,
249 0x9180, 0xffffffff, 0x00050004,
250 0x918c, 0xffffffff, 0x00010006,
251 0x9190, 0xffffffff, 0x00090008,
252 0x9194, 0xffffffff, 0x00070000,
253 0x9198, 0xffffffff, 0x00030002,
254 0x919c, 0xffffffff, 0x00050004,
255 0x91a8, 0xffffffff, 0x00010006,
256 0x91ac, 0xffffffff, 0x00090008,
257 0x91b0, 0xffffffff, 0x00070000,
258 0x91b4, 0xffffffff, 0x00030002,
259 0x91b8, 0xffffffff, 0x00050004,
260 0x91c4, 0xffffffff, 0x00010006,
261 0x91c8, 0xffffffff, 0x00090008,
262 0x91cc, 0xffffffff, 0x00070000,
263 0x91d0, 0xffffffff, 0x00030002,
264 0x91d4, 0xffffffff, 0x00050004,
265 0x91e0, 0xffffffff, 0x00010006,
266 0x91e4, 0xffffffff, 0x00090008,
267 0x91e8, 0xffffffff, 0x00000000,
268 0x91ec, 0xffffffff, 0x00070000,
269 0x91f0, 0xffffffff, 0x00030002,
270 0x91f4, 0xffffffff, 0x00050004,
271 0x9200, 0xffffffff, 0x00010006,
272 0x9204, 0xffffffff, 0x00090008,
273 0x9208, 0xffffffff, 0x00070000,
274 0x920c, 0xffffffff, 0x00030002,
275 0x9210, 0xffffffff, 0x00050004,
276 0x921c, 0xffffffff, 0x00010006,
277 0x9220, 0xffffffff, 0x00090008,
278 0x9224, 0xffffffff, 0x00070000,
279 0x9228, 0xffffffff, 0x00030002,
280 0x922c, 0xffffffff, 0x00050004,
281 0x9238, 0xffffffff, 0x00010006,
282 0x923c, 0xffffffff, 0x00090008,
283 0x9240, 0xffffffff, 0x00070000,
284 0x9244, 0xffffffff, 0x00030002,
285 0x9248, 0xffffffff, 0x00050004,
286 0x9254, 0xffffffff, 0x00010006,
287 0x9258, 0xffffffff, 0x00090008,
288 0x925c, 0xffffffff, 0x00070000,
289 0x9260, 0xffffffff, 0x00030002,
290 0x9264, 0xffffffff, 0x00050004,
291 0x9270, 0xffffffff, 0x00010006,
292 0x9274, 0xffffffff, 0x00090008,
293 0x9278, 0xffffffff, 0x00070000,
294 0x927c, 0xffffffff, 0x00030002,
295 0x9280, 0xffffffff, 0x00050004,
296 0x928c, 0xffffffff, 0x00010006,
297 0x9290, 0xffffffff, 0x00090008,
298 0x9294, 0xffffffff, 0x00000000,
299 0x929c, 0xffffffff, 0x00000001,
300 0x802c, 0xffffffff, 0x40010000,
301 0x915c, 0xffffffff, 0x00010000,
302 0x9160, 0xffffffff, 0x00030002,
303 0x9178, 0xffffffff, 0x00070000,
304 0x917c, 0xffffffff, 0x00030002,
305 0x9180, 0xffffffff, 0x00050004,
306 0x918c, 0xffffffff, 0x00010006,
307 0x9190, 0xffffffff, 0x00090008,
308 0x9194, 0xffffffff, 0x00070000,
309 0x9198, 0xffffffff, 0x00030002,
310 0x919c, 0xffffffff, 0x00050004,
311 0x91a8, 0xffffffff, 0x00010006,
312 0x91ac, 0xffffffff, 0x00090008,
313 0x91b0, 0xffffffff, 0x00070000,
314 0x91b4, 0xffffffff, 0x00030002,
315 0x91b8, 0xffffffff, 0x00050004,
316 0x91c4, 0xffffffff, 0x00010006,
317 0x91c8, 0xffffffff, 0x00090008,
318 0x91cc, 0xffffffff, 0x00070000,
319 0x91d0, 0xffffffff, 0x00030002,
320 0x91d4, 0xffffffff, 0x00050004,
321 0x91e0, 0xffffffff, 0x00010006,
322 0x91e4, 0xffffffff, 0x00090008,
323 0x91e8, 0xffffffff, 0x00000000,
324 0x91ec, 0xffffffff, 0x00070000,
325 0x91f0, 0xffffffff, 0x00030002,
326 0x91f4, 0xffffffff, 0x00050004,
327 0x9200, 0xffffffff, 0x00010006,
328 0x9204, 0xffffffff, 0x00090008,
329 0x9208, 0xffffffff, 0x00070000,
330 0x920c, 0xffffffff, 0x00030002,
331 0x9210, 0xffffffff, 0x00050004,
332 0x921c, 0xffffffff, 0x00010006,
333 0x9220, 0xffffffff, 0x00090008,
334 0x9224, 0xffffffff, 0x00070000,
335 0x9228, 0xffffffff, 0x00030002,
336 0x922c, 0xffffffff, 0x00050004,
337 0x9238, 0xffffffff, 0x00010006,
338 0x923c, 0xffffffff, 0x00090008,
339 0x9240, 0xffffffff, 0x00070000,
340 0x9244, 0xffffffff, 0x00030002,
341 0x9248, 0xffffffff, 0x00050004,
342 0x9254, 0xffffffff, 0x00010006,
343 0x9258, 0xffffffff, 0x00090008,
344 0x925c, 0xffffffff, 0x00070000,
345 0x9260, 0xffffffff, 0x00030002,
346 0x9264, 0xffffffff, 0x00050004,
347 0x9270, 0xffffffff, 0x00010006,
348 0x9274, 0xffffffff, 0x00090008,
349 0x9278, 0xffffffff, 0x00070000,
350 0x927c, 0xffffffff, 0x00030002,
351 0x9280, 0xffffffff, 0x00050004,
352 0x928c, 0xffffffff, 0x00010006,
353 0x9290, 0xffffffff, 0x00090008,
354 0x9294, 0xffffffff, 0x00000000,
355 0x929c, 0xffffffff, 0x00000001,
356 0x802c, 0xffffffff, 0xc0000000
359 static const u32 redwood_mgcg_init
[] =
361 0x802c, 0xffffffff, 0xc0000000,
362 0x5448, 0xffffffff, 0x00000100,
363 0x55e4, 0xffffffff, 0x00000100,
364 0x160c, 0xffffffff, 0x00000100,
365 0x5644, 0xffffffff, 0x00000100,
366 0xc164, 0xffffffff, 0x00000100,
367 0x8a18, 0xffffffff, 0x00000100,
368 0x897c, 0xffffffff, 0x06000100,
369 0x8b28, 0xffffffff, 0x00000100,
370 0x9144, 0xffffffff, 0x00000100,
371 0x9a60, 0xffffffff, 0x00000100,
372 0x9868, 0xffffffff, 0x00000100,
373 0x8d58, 0xffffffff, 0x00000100,
374 0x9510, 0xffffffff, 0x00000100,
375 0x949c, 0xffffffff, 0x00000100,
376 0x9654, 0xffffffff, 0x00000100,
377 0x9030, 0xffffffff, 0x00000100,
378 0x9034, 0xffffffff, 0x00000100,
379 0x9038, 0xffffffff, 0x00000100,
380 0x903c, 0xffffffff, 0x00000100,
381 0x9040, 0xffffffff, 0x00000100,
382 0xa200, 0xffffffff, 0x00000100,
383 0xa204, 0xffffffff, 0x00000100,
384 0xa208, 0xffffffff, 0x00000100,
385 0xa20c, 0xffffffff, 0x00000100,
386 0x971c, 0xffffffff, 0x00000100,
387 0x977c, 0xffffffff, 0x00000100,
388 0x3f80, 0xffffffff, 0x00000100,
389 0xa210, 0xffffffff, 0x00000100,
390 0xa214, 0xffffffff, 0x00000100,
391 0x4d8, 0xffffffff, 0x00000100,
392 0x9784, 0xffffffff, 0x00000100,
393 0x9698, 0xffffffff, 0x00000100,
394 0x4d4, 0xffffffff, 0x00000200,
395 0x30cc, 0xffffffff, 0x00000100,
396 0xd0c0, 0xffffffff, 0xff000100,
397 0x802c, 0xffffffff, 0x40000000,
398 0x915c, 0xffffffff, 0x00010000,
399 0x9160, 0xffffffff, 0x00030002,
400 0x9178, 0xffffffff, 0x00070000,
401 0x917c, 0xffffffff, 0x00030002,
402 0x9180, 0xffffffff, 0x00050004,
403 0x918c, 0xffffffff, 0x00010006,
404 0x9190, 0xffffffff, 0x00090008,
405 0x9194, 0xffffffff, 0x00070000,
406 0x9198, 0xffffffff, 0x00030002,
407 0x919c, 0xffffffff, 0x00050004,
408 0x91a8, 0xffffffff, 0x00010006,
409 0x91ac, 0xffffffff, 0x00090008,
410 0x91b0, 0xffffffff, 0x00070000,
411 0x91b4, 0xffffffff, 0x00030002,
412 0x91b8, 0xffffffff, 0x00050004,
413 0x91c4, 0xffffffff, 0x00010006,
414 0x91c8, 0xffffffff, 0x00090008,
415 0x91cc, 0xffffffff, 0x00070000,
416 0x91d0, 0xffffffff, 0x00030002,
417 0x91d4, 0xffffffff, 0x00050004,
418 0x91e0, 0xffffffff, 0x00010006,
419 0x91e4, 0xffffffff, 0x00090008,
420 0x91e8, 0xffffffff, 0x00000000,
421 0x91ec, 0xffffffff, 0x00070000,
422 0x91f0, 0xffffffff, 0x00030002,
423 0x91f4, 0xffffffff, 0x00050004,
424 0x9200, 0xffffffff, 0x00010006,
425 0x9204, 0xffffffff, 0x00090008,
426 0x9294, 0xffffffff, 0x00000000,
427 0x929c, 0xffffffff, 0x00000001,
428 0x802c, 0xffffffff, 0xc0000000
431 static const u32 cedar_golden_registers
[] =
433 0x3f90, 0xffff0000, 0xff000000,
434 0x9148, 0xffff0000, 0xff000000,
435 0x3f94, 0xffff0000, 0xff000000,
436 0x914c, 0xffff0000, 0xff000000,
437 0x9b7c, 0xffffffff, 0x00000000,
438 0x8a14, 0xffffffff, 0x00000007,
439 0x8b10, 0xffffffff, 0x00000000,
440 0x960c, 0xffffffff, 0x54763210,
441 0x88c4, 0xffffffff, 0x000000c2,
442 0x88d4, 0xffffffff, 0x00000000,
443 0x8974, 0xffffffff, 0x00000000,
444 0xc78, 0x00000080, 0x00000080,
445 0x5eb4, 0xffffffff, 0x00000002,
446 0x5e78, 0xffffffff, 0x001000f0,
447 0x6104, 0x01000300, 0x00000000,
448 0x5bc0, 0x00300000, 0x00000000,
449 0x7030, 0xffffffff, 0x00000011,
450 0x7c30, 0xffffffff, 0x00000011,
451 0x10830, 0xffffffff, 0x00000011,
452 0x11430, 0xffffffff, 0x00000011,
453 0xd02c, 0xffffffff, 0x08421000,
454 0x240c, 0xffffffff, 0x00000380,
455 0x8b24, 0xffffffff, 0x00ff0fff,
456 0x28a4c, 0x06000000, 0x06000000,
457 0x10c, 0x00000001, 0x00000001,
458 0x8d00, 0xffffffff, 0x100e4848,
459 0x8d04, 0xffffffff, 0x00164745,
460 0x8c00, 0xffffffff, 0xe4000003,
461 0x8c04, 0xffffffff, 0x40600060,
462 0x8c08, 0xffffffff, 0x001c001c,
463 0x8cf0, 0xffffffff, 0x08e00410,
464 0x8c20, 0xffffffff, 0x00800080,
465 0x8c24, 0xffffffff, 0x00800080,
466 0x8c18, 0xffffffff, 0x20202078,
467 0x8c1c, 0xffffffff, 0x00001010,
468 0x28350, 0xffffffff, 0x00000000,
469 0xa008, 0xffffffff, 0x00010000,
470 0x5cc, 0xffffffff, 0x00000001,
471 0x9508, 0xffffffff, 0x00000002
474 static const u32 cedar_mgcg_init
[] =
476 0x802c, 0xffffffff, 0xc0000000,
477 0x5448, 0xffffffff, 0x00000100,
478 0x55e4, 0xffffffff, 0x00000100,
479 0x160c, 0xffffffff, 0x00000100,
480 0x5644, 0xffffffff, 0x00000100,
481 0xc164, 0xffffffff, 0x00000100,
482 0x8a18, 0xffffffff, 0x00000100,
483 0x897c, 0xffffffff, 0x06000100,
484 0x8b28, 0xffffffff, 0x00000100,
485 0x9144, 0xffffffff, 0x00000100,
486 0x9a60, 0xffffffff, 0x00000100,
487 0x9868, 0xffffffff, 0x00000100,
488 0x8d58, 0xffffffff, 0x00000100,
489 0x9510, 0xffffffff, 0x00000100,
490 0x949c, 0xffffffff, 0x00000100,
491 0x9654, 0xffffffff, 0x00000100,
492 0x9030, 0xffffffff, 0x00000100,
493 0x9034, 0xffffffff, 0x00000100,
494 0x9038, 0xffffffff, 0x00000100,
495 0x903c, 0xffffffff, 0x00000100,
496 0x9040, 0xffffffff, 0x00000100,
497 0xa200, 0xffffffff, 0x00000100,
498 0xa204, 0xffffffff, 0x00000100,
499 0xa208, 0xffffffff, 0x00000100,
500 0xa20c, 0xffffffff, 0x00000100,
501 0x971c, 0xffffffff, 0x00000100,
502 0x977c, 0xffffffff, 0x00000100,
503 0x3f80, 0xffffffff, 0x00000100,
504 0xa210, 0xffffffff, 0x00000100,
505 0xa214, 0xffffffff, 0x00000100,
506 0x4d8, 0xffffffff, 0x00000100,
507 0x9784, 0xffffffff, 0x00000100,
508 0x9698, 0xffffffff, 0x00000100,
509 0x4d4, 0xffffffff, 0x00000200,
510 0x30cc, 0xffffffff, 0x00000100,
511 0xd0c0, 0xffffffff, 0xff000100,
512 0x802c, 0xffffffff, 0x40000000,
513 0x915c, 0xffffffff, 0x00010000,
514 0x9178, 0xffffffff, 0x00050000,
515 0x917c, 0xffffffff, 0x00030002,
516 0x918c, 0xffffffff, 0x00010004,
517 0x9190, 0xffffffff, 0x00070006,
518 0x9194, 0xffffffff, 0x00050000,
519 0x9198, 0xffffffff, 0x00030002,
520 0x91a8, 0xffffffff, 0x00010004,
521 0x91ac, 0xffffffff, 0x00070006,
522 0x91e8, 0xffffffff, 0x00000000,
523 0x9294, 0xffffffff, 0x00000000,
524 0x929c, 0xffffffff, 0x00000001,
525 0x802c, 0xffffffff, 0xc0000000
528 static const u32 juniper_mgcg_init
[] =
530 0x802c, 0xffffffff, 0xc0000000,
531 0x5448, 0xffffffff, 0x00000100,
532 0x55e4, 0xffffffff, 0x00000100,
533 0x160c, 0xffffffff, 0x00000100,
534 0x5644, 0xffffffff, 0x00000100,
535 0xc164, 0xffffffff, 0x00000100,
536 0x8a18, 0xffffffff, 0x00000100,
537 0x897c, 0xffffffff, 0x06000100,
538 0x8b28, 0xffffffff, 0x00000100,
539 0x9144, 0xffffffff, 0x00000100,
540 0x9a60, 0xffffffff, 0x00000100,
541 0x9868, 0xffffffff, 0x00000100,
542 0x8d58, 0xffffffff, 0x00000100,
543 0x9510, 0xffffffff, 0x00000100,
544 0x949c, 0xffffffff, 0x00000100,
545 0x9654, 0xffffffff, 0x00000100,
546 0x9030, 0xffffffff, 0x00000100,
547 0x9034, 0xffffffff, 0x00000100,
548 0x9038, 0xffffffff, 0x00000100,
549 0x903c, 0xffffffff, 0x00000100,
550 0x9040, 0xffffffff, 0x00000100,
551 0xa200, 0xffffffff, 0x00000100,
552 0xa204, 0xffffffff, 0x00000100,
553 0xa208, 0xffffffff, 0x00000100,
554 0xa20c, 0xffffffff, 0x00000100,
555 0x971c, 0xffffffff, 0x00000100,
556 0xd0c0, 0xffffffff, 0xff000100,
557 0x802c, 0xffffffff, 0x40000000,
558 0x915c, 0xffffffff, 0x00010000,
559 0x9160, 0xffffffff, 0x00030002,
560 0x9178, 0xffffffff, 0x00070000,
561 0x917c, 0xffffffff, 0x00030002,
562 0x9180, 0xffffffff, 0x00050004,
563 0x918c, 0xffffffff, 0x00010006,
564 0x9190, 0xffffffff, 0x00090008,
565 0x9194, 0xffffffff, 0x00070000,
566 0x9198, 0xffffffff, 0x00030002,
567 0x919c, 0xffffffff, 0x00050004,
568 0x91a8, 0xffffffff, 0x00010006,
569 0x91ac, 0xffffffff, 0x00090008,
570 0x91b0, 0xffffffff, 0x00070000,
571 0x91b4, 0xffffffff, 0x00030002,
572 0x91b8, 0xffffffff, 0x00050004,
573 0x91c4, 0xffffffff, 0x00010006,
574 0x91c8, 0xffffffff, 0x00090008,
575 0x91cc, 0xffffffff, 0x00070000,
576 0x91d0, 0xffffffff, 0x00030002,
577 0x91d4, 0xffffffff, 0x00050004,
578 0x91e0, 0xffffffff, 0x00010006,
579 0x91e4, 0xffffffff, 0x00090008,
580 0x91e8, 0xffffffff, 0x00000000,
581 0x91ec, 0xffffffff, 0x00070000,
582 0x91f0, 0xffffffff, 0x00030002,
583 0x91f4, 0xffffffff, 0x00050004,
584 0x9200, 0xffffffff, 0x00010006,
585 0x9204, 0xffffffff, 0x00090008,
586 0x9208, 0xffffffff, 0x00070000,
587 0x920c, 0xffffffff, 0x00030002,
588 0x9210, 0xffffffff, 0x00050004,
589 0x921c, 0xffffffff, 0x00010006,
590 0x9220, 0xffffffff, 0x00090008,
591 0x9224, 0xffffffff, 0x00070000,
592 0x9228, 0xffffffff, 0x00030002,
593 0x922c, 0xffffffff, 0x00050004,
594 0x9238, 0xffffffff, 0x00010006,
595 0x923c, 0xffffffff, 0x00090008,
596 0x9240, 0xffffffff, 0x00070000,
597 0x9244, 0xffffffff, 0x00030002,
598 0x9248, 0xffffffff, 0x00050004,
599 0x9254, 0xffffffff, 0x00010006,
600 0x9258, 0xffffffff, 0x00090008,
601 0x925c, 0xffffffff, 0x00070000,
602 0x9260, 0xffffffff, 0x00030002,
603 0x9264, 0xffffffff, 0x00050004,
604 0x9270, 0xffffffff, 0x00010006,
605 0x9274, 0xffffffff, 0x00090008,
606 0x9278, 0xffffffff, 0x00070000,
607 0x927c, 0xffffffff, 0x00030002,
608 0x9280, 0xffffffff, 0x00050004,
609 0x928c, 0xffffffff, 0x00010006,
610 0x9290, 0xffffffff, 0x00090008,
611 0x9294, 0xffffffff, 0x00000000,
612 0x929c, 0xffffffff, 0x00000001,
613 0x802c, 0xffffffff, 0xc0000000,
614 0x977c, 0xffffffff, 0x00000100,
615 0x3f80, 0xffffffff, 0x00000100,
616 0xa210, 0xffffffff, 0x00000100,
617 0xa214, 0xffffffff, 0x00000100,
618 0x4d8, 0xffffffff, 0x00000100,
619 0x9784, 0xffffffff, 0x00000100,
620 0x9698, 0xffffffff, 0x00000100,
621 0x4d4, 0xffffffff, 0x00000200,
622 0x30cc, 0xffffffff, 0x00000100,
623 0x802c, 0xffffffff, 0xc0000000
626 static const u32 supersumo_golden_registers
[] =
628 0x5eb4, 0xffffffff, 0x00000002,
629 0x5cc, 0xffffffff, 0x00000001,
630 0x7030, 0xffffffff, 0x00000011,
631 0x7c30, 0xffffffff, 0x00000011,
632 0x6104, 0x01000300, 0x00000000,
633 0x5bc0, 0x00300000, 0x00000000,
634 0x8c04, 0xffffffff, 0x40600060,
635 0x8c08, 0xffffffff, 0x001c001c,
636 0x8c20, 0xffffffff, 0x00800080,
637 0x8c24, 0xffffffff, 0x00800080,
638 0x8c18, 0xffffffff, 0x20202078,
639 0x8c1c, 0xffffffff, 0x00001010,
640 0x918c, 0xffffffff, 0x00010006,
641 0x91a8, 0xffffffff, 0x00010006,
642 0x91c4, 0xffffffff, 0x00010006,
643 0x91e0, 0xffffffff, 0x00010006,
644 0x9200, 0xffffffff, 0x00010006,
645 0x9150, 0xffffffff, 0x6e944040,
646 0x917c, 0xffffffff, 0x00030002,
647 0x9180, 0xffffffff, 0x00050004,
648 0x9198, 0xffffffff, 0x00030002,
649 0x919c, 0xffffffff, 0x00050004,
650 0x91b4, 0xffffffff, 0x00030002,
651 0x91b8, 0xffffffff, 0x00050004,
652 0x91d0, 0xffffffff, 0x00030002,
653 0x91d4, 0xffffffff, 0x00050004,
654 0x91f0, 0xffffffff, 0x00030002,
655 0x91f4, 0xffffffff, 0x00050004,
656 0x915c, 0xffffffff, 0x00010000,
657 0x9160, 0xffffffff, 0x00030002,
658 0x3f90, 0xffff0000, 0xff000000,
659 0x9178, 0xffffffff, 0x00070000,
660 0x9194, 0xffffffff, 0x00070000,
661 0x91b0, 0xffffffff, 0x00070000,
662 0x91cc, 0xffffffff, 0x00070000,
663 0x91ec, 0xffffffff, 0x00070000,
664 0x9148, 0xffff0000, 0xff000000,
665 0x9190, 0xffffffff, 0x00090008,
666 0x91ac, 0xffffffff, 0x00090008,
667 0x91c8, 0xffffffff, 0x00090008,
668 0x91e4, 0xffffffff, 0x00090008,
669 0x9204, 0xffffffff, 0x00090008,
670 0x3f94, 0xffff0000, 0xff000000,
671 0x914c, 0xffff0000, 0xff000000,
672 0x929c, 0xffffffff, 0x00000001,
673 0x8a18, 0xffffffff, 0x00000100,
674 0x8b28, 0xffffffff, 0x00000100,
675 0x9144, 0xffffffff, 0x00000100,
676 0x5644, 0xffffffff, 0x00000100,
677 0x9b7c, 0xffffffff, 0x00000000,
678 0x8030, 0xffffffff, 0x0000100a,
679 0x8a14, 0xffffffff, 0x00000007,
680 0x8b24, 0xffffffff, 0x00ff0fff,
681 0x8b10, 0xffffffff, 0x00000000,
682 0x28a4c, 0x06000000, 0x06000000,
683 0x4d8, 0xffffffff, 0x00000100,
684 0x913c, 0xffff000f, 0x0100000a,
685 0x960c, 0xffffffff, 0x54763210,
686 0x88c4, 0xffffffff, 0x000000c2,
687 0x88d4, 0xffffffff, 0x00000010,
688 0x8974, 0xffffffff, 0x00000000,
689 0xc78, 0x00000080, 0x00000080,
690 0x5e78, 0xffffffff, 0x001000f0,
691 0xd02c, 0xffffffff, 0x08421000,
692 0xa008, 0xffffffff, 0x00010000,
693 0x8d00, 0xffffffff, 0x100e4848,
694 0x8d04, 0xffffffff, 0x00164745,
695 0x8c00, 0xffffffff, 0xe4000003,
696 0x8cf0, 0x1fffffff, 0x08e00620,
697 0x28350, 0xffffffff, 0x00000000,
698 0x9508, 0xffffffff, 0x00000002
701 static const u32 sumo_golden_registers
[] =
703 0x900c, 0x00ffffff, 0x0017071f,
704 0x8c18, 0xffffffff, 0x10101060,
705 0x8c1c, 0xffffffff, 0x00001010,
706 0x8c30, 0x0000000f, 0x00000005,
707 0x9688, 0x0000000f, 0x00000007
710 static const u32 wrestler_golden_registers
[] =
712 0x5eb4, 0xffffffff, 0x00000002,
713 0x5cc, 0xffffffff, 0x00000001,
714 0x7030, 0xffffffff, 0x00000011,
715 0x7c30, 0xffffffff, 0x00000011,
716 0x6104, 0x01000300, 0x00000000,
717 0x5bc0, 0x00300000, 0x00000000,
718 0x918c, 0xffffffff, 0x00010006,
719 0x91a8, 0xffffffff, 0x00010006,
720 0x9150, 0xffffffff, 0x6e944040,
721 0x917c, 0xffffffff, 0x00030002,
722 0x9198, 0xffffffff, 0x00030002,
723 0x915c, 0xffffffff, 0x00010000,
724 0x3f90, 0xffff0000, 0xff000000,
725 0x9178, 0xffffffff, 0x00070000,
726 0x9194, 0xffffffff, 0x00070000,
727 0x9148, 0xffff0000, 0xff000000,
728 0x9190, 0xffffffff, 0x00090008,
729 0x91ac, 0xffffffff, 0x00090008,
730 0x3f94, 0xffff0000, 0xff000000,
731 0x914c, 0xffff0000, 0xff000000,
732 0x929c, 0xffffffff, 0x00000001,
733 0x8a18, 0xffffffff, 0x00000100,
734 0x8b28, 0xffffffff, 0x00000100,
735 0x9144, 0xffffffff, 0x00000100,
736 0x9b7c, 0xffffffff, 0x00000000,
737 0x8030, 0xffffffff, 0x0000100a,
738 0x8a14, 0xffffffff, 0x00000001,
739 0x8b24, 0xffffffff, 0x00ff0fff,
740 0x8b10, 0xffffffff, 0x00000000,
741 0x28a4c, 0x06000000, 0x06000000,
742 0x4d8, 0xffffffff, 0x00000100,
743 0x913c, 0xffff000f, 0x0100000a,
744 0x960c, 0xffffffff, 0x54763210,
745 0x88c4, 0xffffffff, 0x000000c2,
746 0x88d4, 0xffffffff, 0x00000010,
747 0x8974, 0xffffffff, 0x00000000,
748 0xc78, 0x00000080, 0x00000080,
749 0x5e78, 0xffffffff, 0x001000f0,
750 0xd02c, 0xffffffff, 0x08421000,
751 0xa008, 0xffffffff, 0x00010000,
752 0x8d00, 0xffffffff, 0x100e4848,
753 0x8d04, 0xffffffff, 0x00164745,
754 0x8c00, 0xffffffff, 0xe4000003,
755 0x8cf0, 0x1fffffff, 0x08e00410,
756 0x28350, 0xffffffff, 0x00000000,
757 0x9508, 0xffffffff, 0x00000002,
758 0x900c, 0xffffffff, 0x0017071f,
759 0x8c18, 0xffffffff, 0x10101060,
760 0x8c1c, 0xffffffff, 0x00001010
763 static const u32 barts_golden_registers
[] =
765 0x5eb4, 0xffffffff, 0x00000002,
766 0x5e78, 0x8f311ff1, 0x001000f0,
767 0x3f90, 0xffff0000, 0xff000000,
768 0x9148, 0xffff0000, 0xff000000,
769 0x3f94, 0xffff0000, 0xff000000,
770 0x914c, 0xffff0000, 0xff000000,
771 0xc78, 0x00000080, 0x00000080,
772 0xbd4, 0x70073777, 0x00010001,
773 0xd02c, 0xbfffff1f, 0x08421000,
774 0xd0b8, 0x03773777, 0x02011003,
775 0x5bc0, 0x00200000, 0x50100000,
776 0x98f8, 0x33773777, 0x02011003,
777 0x98fc, 0xffffffff, 0x76543210,
778 0x7030, 0x31000311, 0x00000011,
779 0x2f48, 0x00000007, 0x02011003,
780 0x6b28, 0x00000010, 0x00000012,
781 0x7728, 0x00000010, 0x00000012,
782 0x10328, 0x00000010, 0x00000012,
783 0x10f28, 0x00000010, 0x00000012,
784 0x11b28, 0x00000010, 0x00000012,
785 0x12728, 0x00000010, 0x00000012,
786 0x240c, 0x000007ff, 0x00000380,
787 0x8a14, 0xf000001f, 0x00000007,
788 0x8b24, 0x3fff3fff, 0x00ff0fff,
789 0x8b10, 0x0000ff0f, 0x00000000,
790 0x28a4c, 0x07ffffff, 0x06000000,
791 0x10c, 0x00000001, 0x00010003,
792 0xa02c, 0xffffffff, 0x0000009b,
793 0x913c, 0x0000000f, 0x0100000a,
794 0x8d00, 0xffff7f7f, 0x100e4848,
795 0x8d04, 0x00ffffff, 0x00164745,
796 0x8c00, 0xfffc0003, 0xe4000003,
797 0x8c04, 0xf8ff00ff, 0x40600060,
798 0x8c08, 0x00ff00ff, 0x001c001c,
799 0x8cf0, 0x1fff1fff, 0x08e00620,
800 0x8c20, 0x0fff0fff, 0x00800080,
801 0x8c24, 0x0fff0fff, 0x00800080,
802 0x8c18, 0xffffffff, 0x20202078,
803 0x8c1c, 0x0000ffff, 0x00001010,
804 0x28350, 0x00000f01, 0x00000000,
805 0x9508, 0x3700001f, 0x00000002,
806 0x960c, 0xffffffff, 0x54763210,
807 0x88c4, 0x001f3ae3, 0x000000c2,
808 0x88d4, 0x0000001f, 0x00000010,
809 0x8974, 0xffffffff, 0x00000000
812 static const u32 turks_golden_registers
[] =
814 0x5eb4, 0xffffffff, 0x00000002,
815 0x5e78, 0x8f311ff1, 0x001000f0,
816 0x8c8, 0x00003000, 0x00001070,
817 0x8cc, 0x000fffff, 0x00040035,
818 0x3f90, 0xffff0000, 0xfff00000,
819 0x9148, 0xffff0000, 0xfff00000,
820 0x3f94, 0xffff0000, 0xfff00000,
821 0x914c, 0xffff0000, 0xfff00000,
822 0xc78, 0x00000080, 0x00000080,
823 0xbd4, 0x00073007, 0x00010002,
824 0xd02c, 0xbfffff1f, 0x08421000,
825 0xd0b8, 0x03773777, 0x02010002,
826 0x5bc0, 0x00200000, 0x50100000,
827 0x98f8, 0x33773777, 0x00010002,
828 0x98fc, 0xffffffff, 0x33221100,
829 0x7030, 0x31000311, 0x00000011,
830 0x2f48, 0x33773777, 0x00010002,
831 0x6b28, 0x00000010, 0x00000012,
832 0x7728, 0x00000010, 0x00000012,
833 0x10328, 0x00000010, 0x00000012,
834 0x10f28, 0x00000010, 0x00000012,
835 0x11b28, 0x00000010, 0x00000012,
836 0x12728, 0x00000010, 0x00000012,
837 0x240c, 0x000007ff, 0x00000380,
838 0x8a14, 0xf000001f, 0x00000007,
839 0x8b24, 0x3fff3fff, 0x00ff0fff,
840 0x8b10, 0x0000ff0f, 0x00000000,
841 0x28a4c, 0x07ffffff, 0x06000000,
842 0x10c, 0x00000001, 0x00010003,
843 0xa02c, 0xffffffff, 0x0000009b,
844 0x913c, 0x0000000f, 0x0100000a,
845 0x8d00, 0xffff7f7f, 0x100e4848,
846 0x8d04, 0x00ffffff, 0x00164745,
847 0x8c00, 0xfffc0003, 0xe4000003,
848 0x8c04, 0xf8ff00ff, 0x40600060,
849 0x8c08, 0x00ff00ff, 0x001c001c,
850 0x8cf0, 0x1fff1fff, 0x08e00410,
851 0x8c20, 0x0fff0fff, 0x00800080,
852 0x8c24, 0x0fff0fff, 0x00800080,
853 0x8c18, 0xffffffff, 0x20202078,
854 0x8c1c, 0x0000ffff, 0x00001010,
855 0x28350, 0x00000f01, 0x00000000,
856 0x9508, 0x3700001f, 0x00000002,
857 0x960c, 0xffffffff, 0x54763210,
858 0x88c4, 0x001f3ae3, 0x000000c2,
859 0x88d4, 0x0000001f, 0x00000010,
860 0x8974, 0xffffffff, 0x00000000
863 static const u32 caicos_golden_registers
[] =
865 0x5eb4, 0xffffffff, 0x00000002,
866 0x5e78, 0x8f311ff1, 0x001000f0,
867 0x8c8, 0x00003420, 0x00001450,
868 0x8cc, 0x000fffff, 0x00040035,
869 0x3f90, 0xffff0000, 0xfffc0000,
870 0x9148, 0xffff0000, 0xfffc0000,
871 0x3f94, 0xffff0000, 0xfffc0000,
872 0x914c, 0xffff0000, 0xfffc0000,
873 0xc78, 0x00000080, 0x00000080,
874 0xbd4, 0x00073007, 0x00010001,
875 0xd02c, 0xbfffff1f, 0x08421000,
876 0xd0b8, 0x03773777, 0x02010001,
877 0x5bc0, 0x00200000, 0x50100000,
878 0x98f8, 0x33773777, 0x02010001,
879 0x98fc, 0xffffffff, 0x33221100,
880 0x7030, 0x31000311, 0x00000011,
881 0x2f48, 0x33773777, 0x02010001,
882 0x6b28, 0x00000010, 0x00000012,
883 0x7728, 0x00000010, 0x00000012,
884 0x10328, 0x00000010, 0x00000012,
885 0x10f28, 0x00000010, 0x00000012,
886 0x11b28, 0x00000010, 0x00000012,
887 0x12728, 0x00000010, 0x00000012,
888 0x240c, 0x000007ff, 0x00000380,
889 0x8a14, 0xf000001f, 0x00000001,
890 0x8b24, 0x3fff3fff, 0x00ff0fff,
891 0x8b10, 0x0000ff0f, 0x00000000,
892 0x28a4c, 0x07ffffff, 0x06000000,
893 0x10c, 0x00000001, 0x00010003,
894 0xa02c, 0xffffffff, 0x0000009b,
895 0x913c, 0x0000000f, 0x0100000a,
896 0x8d00, 0xffff7f7f, 0x100e4848,
897 0x8d04, 0x00ffffff, 0x00164745,
898 0x8c00, 0xfffc0003, 0xe4000003,
899 0x8c04, 0xf8ff00ff, 0x40600060,
900 0x8c08, 0x00ff00ff, 0x001c001c,
901 0x8cf0, 0x1fff1fff, 0x08e00410,
902 0x8c20, 0x0fff0fff, 0x00800080,
903 0x8c24, 0x0fff0fff, 0x00800080,
904 0x8c18, 0xffffffff, 0x20202078,
905 0x8c1c, 0x0000ffff, 0x00001010,
906 0x28350, 0x00000f01, 0x00000000,
907 0x9508, 0x3700001f, 0x00000002,
908 0x960c, 0xffffffff, 0x54763210,
909 0x88c4, 0x001f3ae3, 0x000000c2,
910 0x88d4, 0x0000001f, 0x00000010,
911 0x8974, 0xffffffff, 0x00000000
914 static void evergreen_init_golden_registers(struct radeon_device
*rdev
)
916 switch (rdev
->family
) {
919 radeon_program_register_sequence(rdev
,
920 evergreen_golden_registers
,
921 (const u32
)ARRAY_SIZE(evergreen_golden_registers
));
922 radeon_program_register_sequence(rdev
,
923 evergreen_golden_registers2
,
924 (const u32
)ARRAY_SIZE(evergreen_golden_registers2
));
925 radeon_program_register_sequence(rdev
,
927 (const u32
)ARRAY_SIZE(cypress_mgcg_init
));
930 radeon_program_register_sequence(rdev
,
931 evergreen_golden_registers
,
932 (const u32
)ARRAY_SIZE(evergreen_golden_registers
));
933 radeon_program_register_sequence(rdev
,
934 evergreen_golden_registers2
,
935 (const u32
)ARRAY_SIZE(evergreen_golden_registers2
));
936 radeon_program_register_sequence(rdev
,
938 (const u32
)ARRAY_SIZE(juniper_mgcg_init
));
941 radeon_program_register_sequence(rdev
,
942 evergreen_golden_registers
,
943 (const u32
)ARRAY_SIZE(evergreen_golden_registers
));
944 radeon_program_register_sequence(rdev
,
945 evergreen_golden_registers2
,
946 (const u32
)ARRAY_SIZE(evergreen_golden_registers2
));
947 radeon_program_register_sequence(rdev
,
949 (const u32
)ARRAY_SIZE(redwood_mgcg_init
));
952 radeon_program_register_sequence(rdev
,
953 cedar_golden_registers
,
954 (const u32
)ARRAY_SIZE(cedar_golden_registers
));
955 radeon_program_register_sequence(rdev
,
956 evergreen_golden_registers2
,
957 (const u32
)ARRAY_SIZE(evergreen_golden_registers2
));
958 radeon_program_register_sequence(rdev
,
960 (const u32
)ARRAY_SIZE(cedar_mgcg_init
));
963 radeon_program_register_sequence(rdev
,
964 wrestler_golden_registers
,
965 (const u32
)ARRAY_SIZE(wrestler_golden_registers
));
968 radeon_program_register_sequence(rdev
,
969 supersumo_golden_registers
,
970 (const u32
)ARRAY_SIZE(supersumo_golden_registers
));
973 radeon_program_register_sequence(rdev
,
974 supersumo_golden_registers
,
975 (const u32
)ARRAY_SIZE(supersumo_golden_registers
));
976 radeon_program_register_sequence(rdev
,
977 sumo_golden_registers
,
978 (const u32
)ARRAY_SIZE(sumo_golden_registers
));
981 radeon_program_register_sequence(rdev
,
982 barts_golden_registers
,
983 (const u32
)ARRAY_SIZE(barts_golden_registers
));
986 radeon_program_register_sequence(rdev
,
987 turks_golden_registers
,
988 (const u32
)ARRAY_SIZE(turks_golden_registers
));
991 radeon_program_register_sequence(rdev
,
992 caicos_golden_registers
,
993 (const u32
)ARRAY_SIZE(caicos_golden_registers
));
1000 void evergreen_tiling_fields(unsigned tiling_flags
, unsigned *bankw
,
1001 unsigned *bankh
, unsigned *mtaspect
,
1002 unsigned *tile_split
)
1004 *bankw
= (tiling_flags
>> RADEON_TILING_EG_BANKW_SHIFT
) & RADEON_TILING_EG_BANKW_MASK
;
1005 *bankh
= (tiling_flags
>> RADEON_TILING_EG_BANKH_SHIFT
) & RADEON_TILING_EG_BANKH_MASK
;
1006 *mtaspect
= (tiling_flags
>> RADEON_TILING_EG_MACRO_TILE_ASPECT_SHIFT
) & RADEON_TILING_EG_MACRO_TILE_ASPECT_MASK
;
1007 *tile_split
= (tiling_flags
>> RADEON_TILING_EG_TILE_SPLIT_SHIFT
) & RADEON_TILING_EG_TILE_SPLIT_MASK
;
1010 case 1: *bankw
= EVERGREEN_ADDR_SURF_BANK_WIDTH_1
; break;
1011 case 2: *bankw
= EVERGREEN_ADDR_SURF_BANK_WIDTH_2
; break;
1012 case 4: *bankw
= EVERGREEN_ADDR_SURF_BANK_WIDTH_4
; break;
1013 case 8: *bankw
= EVERGREEN_ADDR_SURF_BANK_WIDTH_8
; break;
1017 case 1: *bankh
= EVERGREEN_ADDR_SURF_BANK_HEIGHT_1
; break;
1018 case 2: *bankh
= EVERGREEN_ADDR_SURF_BANK_HEIGHT_2
; break;
1019 case 4: *bankh
= EVERGREEN_ADDR_SURF_BANK_HEIGHT_4
; break;
1020 case 8: *bankh
= EVERGREEN_ADDR_SURF_BANK_HEIGHT_8
; break;
1022 switch (*mtaspect
) {
1024 case 1: *mtaspect
= EVERGREEN_ADDR_SURF_MACRO_TILE_ASPECT_1
; break;
1025 case 2: *mtaspect
= EVERGREEN_ADDR_SURF_MACRO_TILE_ASPECT_2
; break;
1026 case 4: *mtaspect
= EVERGREEN_ADDR_SURF_MACRO_TILE_ASPECT_4
; break;
1027 case 8: *mtaspect
= EVERGREEN_ADDR_SURF_MACRO_TILE_ASPECT_8
; break;
1031 static int sumo_set_uvd_clock(struct radeon_device
*rdev
, u32 clock
,
1032 u32 cntl_reg
, u32 status_reg
)
1035 struct atom_clock_dividers dividers
;
1037 r
= radeon_atom_get_clock_dividers(rdev
, COMPUTE_ENGINE_PLL_PARAM
,
1038 clock
, false, ÷rs
);
1042 WREG32_P(cntl_reg
, dividers
.post_div
, ~(DCLK_DIR_CNTL_EN
|DCLK_DIVIDER_MASK
));
1044 for (i
= 0; i
< 100; i
++) {
1045 if (RREG32(status_reg
) & DCLK_STATUS
)
1055 int sumo_set_uvd_clocks(struct radeon_device
*rdev
, u32 vclk
, u32 dclk
)
1058 u32 cg_scratch
= RREG32(CG_SCRATCH1
);
1060 r
= sumo_set_uvd_clock(rdev
, vclk
, CG_VCLK_CNTL
, CG_VCLK_STATUS
);
1063 cg_scratch
&= 0xffff0000;
1064 cg_scratch
|= vclk
/ 100; /* Mhz */
1066 r
= sumo_set_uvd_clock(rdev
, dclk
, CG_DCLK_CNTL
, CG_DCLK_STATUS
);
1069 cg_scratch
&= 0x0000ffff;
1070 cg_scratch
|= (dclk
/ 100) << 16; /* Mhz */
1073 WREG32(CG_SCRATCH1
, cg_scratch
);
1078 int evergreen_set_uvd_clocks(struct radeon_device
*rdev
, u32 vclk
, u32 dclk
)
1080 /* start off with something large */
1081 unsigned fb_div
= 0, vclk_div
= 0, dclk_div
= 0;
1084 /* bypass vclk and dclk with bclk */
1085 WREG32_P(CG_UPLL_FUNC_CNTL_2
,
1086 VCLK_SRC_SEL(1) | DCLK_SRC_SEL(1),
1087 ~(VCLK_SRC_SEL_MASK
| DCLK_SRC_SEL_MASK
));
1089 /* put PLL in bypass mode */
1090 WREG32_P(CG_UPLL_FUNC_CNTL
, UPLL_BYPASS_EN_MASK
, ~UPLL_BYPASS_EN_MASK
);
1092 if (!vclk
|| !dclk
) {
1093 /* keep the Bypass mode, put PLL to sleep */
1094 WREG32_P(CG_UPLL_FUNC_CNTL
, UPLL_SLEEP_MASK
, ~UPLL_SLEEP_MASK
);
1098 r
= radeon_uvd_calc_upll_dividers(rdev
, vclk
, dclk
, 125000, 250000,
1099 16384, 0x03FFFFFF, 0, 128, 5,
1100 &fb_div
, &vclk_div
, &dclk_div
);
1104 /* set VCO_MODE to 1 */
1105 WREG32_P(CG_UPLL_FUNC_CNTL
, UPLL_VCO_MODE_MASK
, ~UPLL_VCO_MODE_MASK
);
1107 /* toggle UPLL_SLEEP to 1 then back to 0 */
1108 WREG32_P(CG_UPLL_FUNC_CNTL
, UPLL_SLEEP_MASK
, ~UPLL_SLEEP_MASK
);
1109 WREG32_P(CG_UPLL_FUNC_CNTL
, 0, ~UPLL_SLEEP_MASK
);
1111 /* deassert UPLL_RESET */
1112 WREG32_P(CG_UPLL_FUNC_CNTL
, 0, ~UPLL_RESET_MASK
);
1116 r
= radeon_uvd_send_upll_ctlreq(rdev
, CG_UPLL_FUNC_CNTL
);
1120 /* assert UPLL_RESET again */
1121 WREG32_P(CG_UPLL_FUNC_CNTL
, UPLL_RESET_MASK
, ~UPLL_RESET_MASK
);
1123 /* disable spread spectrum. */
1124 WREG32_P(CG_UPLL_SPREAD_SPECTRUM
, 0, ~SSEN_MASK
);
1126 /* set feedback divider */
1127 WREG32_P(CG_UPLL_FUNC_CNTL_3
, UPLL_FB_DIV(fb_div
), ~UPLL_FB_DIV_MASK
);
1129 /* set ref divider to 0 */
1130 WREG32_P(CG_UPLL_FUNC_CNTL
, 0, ~UPLL_REF_DIV_MASK
);
1132 if (fb_div
< 307200)
1133 WREG32_P(CG_UPLL_FUNC_CNTL_4
, 0, ~UPLL_SPARE_ISPARE9
);
1135 WREG32_P(CG_UPLL_FUNC_CNTL_4
, UPLL_SPARE_ISPARE9
, ~UPLL_SPARE_ISPARE9
);
1137 /* set PDIV_A and PDIV_B */
1138 WREG32_P(CG_UPLL_FUNC_CNTL_2
,
1139 UPLL_PDIV_A(vclk_div
) | UPLL_PDIV_B(dclk_div
),
1140 ~(UPLL_PDIV_A_MASK
| UPLL_PDIV_B_MASK
));
1142 /* give the PLL some time to settle */
1145 /* deassert PLL_RESET */
1146 WREG32_P(CG_UPLL_FUNC_CNTL
, 0, ~UPLL_RESET_MASK
);
1150 /* switch from bypass mode to normal mode */
1151 WREG32_P(CG_UPLL_FUNC_CNTL
, 0, ~UPLL_BYPASS_EN_MASK
);
1153 r
= radeon_uvd_send_upll_ctlreq(rdev
, CG_UPLL_FUNC_CNTL
);
1157 /* switch VCLK and DCLK selection */
1158 WREG32_P(CG_UPLL_FUNC_CNTL_2
,
1159 VCLK_SRC_SEL(2) | DCLK_SRC_SEL(2),
1160 ~(VCLK_SRC_SEL_MASK
| DCLK_SRC_SEL_MASK
));
1167 void evergreen_fix_pci_max_read_req_size(struct radeon_device
*rdev
)
1172 err
= pcie_capability_read_word(rdev
->pdev
, PCI_EXP_DEVCTL
, &ctl
);
1176 v
= (ctl
& PCI_EXP_DEVCTL_READRQ
) >> 12;
1178 /* if bios or OS sets MAX_READ_REQUEST_SIZE to an invalid value, fix it
1179 * to avoid hangs or perfomance issues
1181 if ((v
== 0) || (v
== 6) || (v
== 7)) {
1182 ctl
&= ~PCI_EXP_DEVCTL_READRQ
;
1184 pcie_capability_write_word(rdev
->pdev
, PCI_EXP_DEVCTL
, ctl
);
1188 static bool dce4_is_in_vblank(struct radeon_device
*rdev
, int crtc
)
1190 if (RREG32(EVERGREEN_CRTC_STATUS
+ crtc_offsets
[crtc
]) & EVERGREEN_CRTC_V_BLANK
)
1196 static bool dce4_is_counter_moving(struct radeon_device
*rdev
, int crtc
)
1200 pos1
= RREG32(EVERGREEN_CRTC_STATUS_POSITION
+ crtc_offsets
[crtc
]);
1201 pos2
= RREG32(EVERGREEN_CRTC_STATUS_POSITION
+ crtc_offsets
[crtc
]);
1210 * dce4_wait_for_vblank - vblank wait asic callback.
1212 * @rdev: radeon_device pointer
1213 * @crtc: crtc to wait for vblank on
1215 * Wait for vblank on the requested crtc (evergreen+).
1217 void dce4_wait_for_vblank(struct radeon_device
*rdev
, int crtc
)
1221 if (crtc
>= rdev
->num_crtc
)
1224 if (!(RREG32(EVERGREEN_CRTC_CONTROL
+ crtc_offsets
[crtc
]) & EVERGREEN_CRTC_MASTER_EN
))
1227 /* depending on when we hit vblank, we may be close to active; if so,
1228 * wait for another frame.
1230 while (dce4_is_in_vblank(rdev
, crtc
)) {
1231 if (i
++ % 100 == 0) {
1232 if (!dce4_is_counter_moving(rdev
, crtc
))
1237 while (!dce4_is_in_vblank(rdev
, crtc
)) {
1238 if (i
++ % 100 == 0) {
1239 if (!dce4_is_counter_moving(rdev
, crtc
))
1246 * radeon_irq_kms_pflip_irq_get - pre-pageflip callback.
1248 * @rdev: radeon_device pointer
1249 * @crtc: crtc to prepare for pageflip on
1251 * Pre-pageflip callback (evergreen+).
1252 * Enables the pageflip irq (vblank irq).
1254 void evergreen_pre_page_flip(struct radeon_device
*rdev
, int crtc
)
1256 /* enable the pflip int */
1257 radeon_irq_kms_pflip_irq_get(rdev
, crtc
);
1261 * evergreen_post_page_flip - pos-pageflip callback.
1263 * @rdev: radeon_device pointer
1264 * @crtc: crtc to cleanup pageflip on
1266 * Post-pageflip callback (evergreen+).
1267 * Disables the pageflip irq (vblank irq).
1269 void evergreen_post_page_flip(struct radeon_device
*rdev
, int crtc
)
1271 /* disable the pflip int */
1272 radeon_irq_kms_pflip_irq_put(rdev
, crtc
);
1276 * evergreen_page_flip - pageflip callback.
1278 * @rdev: radeon_device pointer
1279 * @crtc_id: crtc to cleanup pageflip on
1280 * @crtc_base: new address of the crtc (GPU MC address)
1282 * Does the actual pageflip (evergreen+).
1283 * During vblank we take the crtc lock and wait for the update_pending
1284 * bit to go high, when it does, we release the lock, and allow the
1285 * double buffered update to take place.
1286 * Returns the current update pending status.
1288 u32
evergreen_page_flip(struct radeon_device
*rdev
, int crtc_id
, u64 crtc_base
)
1290 struct radeon_crtc
*radeon_crtc
= rdev
->mode_info
.crtcs
[crtc_id
];
1291 u32 tmp
= RREG32(EVERGREEN_GRPH_UPDATE
+ radeon_crtc
->crtc_offset
);
1294 /* Lock the graphics update lock */
1295 tmp
|= EVERGREEN_GRPH_UPDATE_LOCK
;
1296 WREG32(EVERGREEN_GRPH_UPDATE
+ radeon_crtc
->crtc_offset
, tmp
);
1298 /* update the scanout addresses */
1299 WREG32(EVERGREEN_GRPH_SECONDARY_SURFACE_ADDRESS_HIGH
+ radeon_crtc
->crtc_offset
,
1300 upper_32_bits(crtc_base
));
1301 WREG32(EVERGREEN_GRPH_SECONDARY_SURFACE_ADDRESS
+ radeon_crtc
->crtc_offset
,
1304 WREG32(EVERGREEN_GRPH_PRIMARY_SURFACE_ADDRESS_HIGH
+ radeon_crtc
->crtc_offset
,
1305 upper_32_bits(crtc_base
));
1306 WREG32(EVERGREEN_GRPH_PRIMARY_SURFACE_ADDRESS
+ radeon_crtc
->crtc_offset
,
1309 /* Wait for update_pending to go high. */
1310 for (i
= 0; i
< rdev
->usec_timeout
; i
++) {
1311 if (RREG32(EVERGREEN_GRPH_UPDATE
+ radeon_crtc
->crtc_offset
) & EVERGREEN_GRPH_SURFACE_UPDATE_PENDING
)
1315 DRM_DEBUG("Update pending now high. Unlocking vupdate_lock.\n");
1317 /* Unlock the lock, so double-buffering can take place inside vblank */
1318 tmp
&= ~EVERGREEN_GRPH_UPDATE_LOCK
;
1319 WREG32(EVERGREEN_GRPH_UPDATE
+ radeon_crtc
->crtc_offset
, tmp
);
1321 /* Return current update_pending status: */
1322 return RREG32(EVERGREEN_GRPH_UPDATE
+ radeon_crtc
->crtc_offset
) & EVERGREEN_GRPH_SURFACE_UPDATE_PENDING
;
1325 /* get temperature in millidegrees */
1326 int evergreen_get_temp(struct radeon_device
*rdev
)
1329 int actual_temp
= 0;
1331 if (rdev
->family
== CHIP_JUNIPER
) {
1332 toffset
= (RREG32(CG_THERMAL_CTRL
) & TOFFSET_MASK
) >>
1334 temp
= (RREG32(CG_TS0_STATUS
) & TS0_ADC_DOUT_MASK
) >>
1337 if (toffset
& 0x100)
1338 actual_temp
= temp
/ 2 - (0x200 - toffset
);
1340 actual_temp
= temp
/ 2 + toffset
;
1342 actual_temp
= actual_temp
* 1000;
1345 temp
= (RREG32(CG_MULT_THERMAL_STATUS
) & ASIC_T_MASK
) >>
1350 else if (temp
& 0x200)
1352 else if (temp
& 0x100) {
1353 actual_temp
= temp
& 0x1ff;
1354 actual_temp
|= ~0x1ff;
1356 actual_temp
= temp
& 0xff;
1358 actual_temp
= (actual_temp
* 1000) / 2;
1364 int sumo_get_temp(struct radeon_device
*rdev
)
1366 u32 temp
= RREG32(CG_THERMAL_STATUS
) & 0xff;
1367 int actual_temp
= temp
- 49;
1369 return actual_temp
* 1000;
1373 * sumo_pm_init_profile - Initialize power profiles callback.
1375 * @rdev: radeon_device pointer
1377 * Initialize the power states used in profile mode
1378 * (sumo, trinity, SI).
1379 * Used for profile mode only.
1381 void sumo_pm_init_profile(struct radeon_device
*rdev
)
1386 rdev
->pm
.profiles
[PM_PROFILE_DEFAULT_IDX
].dpms_off_ps_idx
= rdev
->pm
.default_power_state_index
;
1387 rdev
->pm
.profiles
[PM_PROFILE_DEFAULT_IDX
].dpms_on_ps_idx
= rdev
->pm
.default_power_state_index
;
1388 rdev
->pm
.profiles
[PM_PROFILE_DEFAULT_IDX
].dpms_off_cm_idx
= 0;
1389 rdev
->pm
.profiles
[PM_PROFILE_DEFAULT_IDX
].dpms_on_cm_idx
= 0;
1392 if (rdev
->flags
& RADEON_IS_MOBILITY
)
1393 idx
= radeon_pm_get_type_index(rdev
, POWER_STATE_TYPE_BATTERY
, 0);
1395 idx
= radeon_pm_get_type_index(rdev
, POWER_STATE_TYPE_PERFORMANCE
, 0);
1397 rdev
->pm
.profiles
[PM_PROFILE_LOW_SH_IDX
].dpms_off_ps_idx
= idx
;
1398 rdev
->pm
.profiles
[PM_PROFILE_LOW_SH_IDX
].dpms_on_ps_idx
= idx
;
1399 rdev
->pm
.profiles
[PM_PROFILE_LOW_SH_IDX
].dpms_off_cm_idx
= 0;
1400 rdev
->pm
.profiles
[PM_PROFILE_LOW_SH_IDX
].dpms_on_cm_idx
= 0;
1402 rdev
->pm
.profiles
[PM_PROFILE_LOW_MH_IDX
].dpms_off_ps_idx
= idx
;
1403 rdev
->pm
.profiles
[PM_PROFILE_LOW_MH_IDX
].dpms_on_ps_idx
= idx
;
1404 rdev
->pm
.profiles
[PM_PROFILE_LOW_MH_IDX
].dpms_off_cm_idx
= 0;
1405 rdev
->pm
.profiles
[PM_PROFILE_LOW_MH_IDX
].dpms_on_cm_idx
= 0;
1407 rdev
->pm
.profiles
[PM_PROFILE_MID_SH_IDX
].dpms_off_ps_idx
= idx
;
1408 rdev
->pm
.profiles
[PM_PROFILE_MID_SH_IDX
].dpms_on_ps_idx
= idx
;
1409 rdev
->pm
.profiles
[PM_PROFILE_MID_SH_IDX
].dpms_off_cm_idx
= 0;
1410 rdev
->pm
.profiles
[PM_PROFILE_MID_SH_IDX
].dpms_on_cm_idx
= 0;
1412 rdev
->pm
.profiles
[PM_PROFILE_MID_MH_IDX
].dpms_off_ps_idx
= idx
;
1413 rdev
->pm
.profiles
[PM_PROFILE_MID_MH_IDX
].dpms_on_ps_idx
= idx
;
1414 rdev
->pm
.profiles
[PM_PROFILE_MID_MH_IDX
].dpms_off_cm_idx
= 0;
1415 rdev
->pm
.profiles
[PM_PROFILE_MID_MH_IDX
].dpms_on_cm_idx
= 0;
1418 idx
= radeon_pm_get_type_index(rdev
, POWER_STATE_TYPE_PERFORMANCE
, 0);
1419 rdev
->pm
.profiles
[PM_PROFILE_HIGH_SH_IDX
].dpms_off_ps_idx
= idx
;
1420 rdev
->pm
.profiles
[PM_PROFILE_HIGH_SH_IDX
].dpms_on_ps_idx
= idx
;
1421 rdev
->pm
.profiles
[PM_PROFILE_HIGH_SH_IDX
].dpms_off_cm_idx
= 0;
1422 rdev
->pm
.profiles
[PM_PROFILE_HIGH_SH_IDX
].dpms_on_cm_idx
=
1423 rdev
->pm
.power_state
[idx
].num_clock_modes
- 1;
1425 rdev
->pm
.profiles
[PM_PROFILE_HIGH_MH_IDX
].dpms_off_ps_idx
= idx
;
1426 rdev
->pm
.profiles
[PM_PROFILE_HIGH_MH_IDX
].dpms_on_ps_idx
= idx
;
1427 rdev
->pm
.profiles
[PM_PROFILE_HIGH_MH_IDX
].dpms_off_cm_idx
= 0;
1428 rdev
->pm
.profiles
[PM_PROFILE_HIGH_MH_IDX
].dpms_on_cm_idx
=
1429 rdev
->pm
.power_state
[idx
].num_clock_modes
- 1;
1433 * btc_pm_init_profile - Initialize power profiles callback.
1435 * @rdev: radeon_device pointer
1437 * Initialize the power states used in profile mode
1439 * Used for profile mode only.
1441 void btc_pm_init_profile(struct radeon_device
*rdev
)
1446 rdev
->pm
.profiles
[PM_PROFILE_DEFAULT_IDX
].dpms_off_ps_idx
= rdev
->pm
.default_power_state_index
;
1447 rdev
->pm
.profiles
[PM_PROFILE_DEFAULT_IDX
].dpms_on_ps_idx
= rdev
->pm
.default_power_state_index
;
1448 rdev
->pm
.profiles
[PM_PROFILE_DEFAULT_IDX
].dpms_off_cm_idx
= 0;
1449 rdev
->pm
.profiles
[PM_PROFILE_DEFAULT_IDX
].dpms_on_cm_idx
= 2;
1450 /* starting with BTC, there is one state that is used for both
1451 * MH and SH. Difference is that we always use the high clock index for
1454 if (rdev
->flags
& RADEON_IS_MOBILITY
)
1455 idx
= radeon_pm_get_type_index(rdev
, POWER_STATE_TYPE_BATTERY
, 0);
1457 idx
= radeon_pm_get_type_index(rdev
, POWER_STATE_TYPE_PERFORMANCE
, 0);
1459 rdev
->pm
.profiles
[PM_PROFILE_LOW_SH_IDX
].dpms_off_ps_idx
= idx
;
1460 rdev
->pm
.profiles
[PM_PROFILE_LOW_SH_IDX
].dpms_on_ps_idx
= idx
;
1461 rdev
->pm
.profiles
[PM_PROFILE_LOW_SH_IDX
].dpms_off_cm_idx
= 0;
1462 rdev
->pm
.profiles
[PM_PROFILE_LOW_SH_IDX
].dpms_on_cm_idx
= 0;
1464 rdev
->pm
.profiles
[PM_PROFILE_MID_SH_IDX
].dpms_off_ps_idx
= idx
;
1465 rdev
->pm
.profiles
[PM_PROFILE_MID_SH_IDX
].dpms_on_ps_idx
= idx
;
1466 rdev
->pm
.profiles
[PM_PROFILE_MID_SH_IDX
].dpms_off_cm_idx
= 0;
1467 rdev
->pm
.profiles
[PM_PROFILE_MID_SH_IDX
].dpms_on_cm_idx
= 1;
1469 rdev
->pm
.profiles
[PM_PROFILE_HIGH_SH_IDX
].dpms_off_ps_idx
= idx
;
1470 rdev
->pm
.profiles
[PM_PROFILE_HIGH_SH_IDX
].dpms_on_ps_idx
= idx
;
1471 rdev
->pm
.profiles
[PM_PROFILE_HIGH_SH_IDX
].dpms_off_cm_idx
= 0;
1472 rdev
->pm
.profiles
[PM_PROFILE_HIGH_SH_IDX
].dpms_on_cm_idx
= 2;
1474 rdev
->pm
.profiles
[PM_PROFILE_LOW_MH_IDX
].dpms_off_ps_idx
= idx
;
1475 rdev
->pm
.profiles
[PM_PROFILE_LOW_MH_IDX
].dpms_on_ps_idx
= idx
;
1476 rdev
->pm
.profiles
[PM_PROFILE_LOW_MH_IDX
].dpms_off_cm_idx
= 0;
1477 rdev
->pm
.profiles
[PM_PROFILE_LOW_MH_IDX
].dpms_on_cm_idx
= 0;
1479 rdev
->pm
.profiles
[PM_PROFILE_MID_MH_IDX
].dpms_off_ps_idx
= idx
;
1480 rdev
->pm
.profiles
[PM_PROFILE_MID_MH_IDX
].dpms_on_ps_idx
= idx
;
1481 rdev
->pm
.profiles
[PM_PROFILE_MID_MH_IDX
].dpms_off_cm_idx
= 0;
1482 rdev
->pm
.profiles
[PM_PROFILE_MID_MH_IDX
].dpms_on_cm_idx
= 1;
1484 rdev
->pm
.profiles
[PM_PROFILE_HIGH_MH_IDX
].dpms_off_ps_idx
= idx
;
1485 rdev
->pm
.profiles
[PM_PROFILE_HIGH_MH_IDX
].dpms_on_ps_idx
= idx
;
1486 rdev
->pm
.profiles
[PM_PROFILE_HIGH_MH_IDX
].dpms_off_cm_idx
= 0;
1487 rdev
->pm
.profiles
[PM_PROFILE_HIGH_MH_IDX
].dpms_on_cm_idx
= 2;
1491 * evergreen_pm_misc - set additional pm hw parameters callback.
1493 * @rdev: radeon_device pointer
1495 * Set non-clock parameters associated with a power state
1496 * (voltage, etc.) (evergreen+).
1498 void evergreen_pm_misc(struct radeon_device
*rdev
)
1500 int req_ps_idx
= rdev
->pm
.requested_power_state_index
;
1501 int req_cm_idx
= rdev
->pm
.requested_clock_mode_index
;
1502 struct radeon_power_state
*ps
= &rdev
->pm
.power_state
[req_ps_idx
];
1503 struct radeon_voltage
*voltage
= &ps
->clock_info
[req_cm_idx
].voltage
;
1505 if (voltage
->type
== VOLTAGE_SW
) {
1506 /* 0xff01 is a flag rather then an actual voltage */
1507 if (voltage
->voltage
== 0xff01)
1509 if (voltage
->voltage
&& (voltage
->voltage
!= rdev
->pm
.current_vddc
)) {
1510 radeon_atom_set_voltage(rdev
, voltage
->voltage
, SET_VOLTAGE_TYPE_ASIC_VDDC
);
1511 rdev
->pm
.current_vddc
= voltage
->voltage
;
1512 DRM_DEBUG("Setting: vddc: %d\n", voltage
->voltage
);
1515 /* starting with BTC, there is one state that is used for both
1516 * MH and SH. Difference is that we always use the high clock index for
1519 if ((rdev
->pm
.pm_method
== PM_METHOD_PROFILE
) &&
1520 (rdev
->family
>= CHIP_BARTS
) &&
1521 rdev
->pm
.active_crtc_count
&&
1522 ((rdev
->pm
.profile_index
== PM_PROFILE_MID_MH_IDX
) ||
1523 (rdev
->pm
.profile_index
== PM_PROFILE_LOW_MH_IDX
)))
1524 voltage
= &rdev
->pm
.power_state
[req_ps_idx
].
1525 clock_info
[rdev
->pm
.profiles
[PM_PROFILE_HIGH_MH_IDX
].dpms_on_cm_idx
].voltage
;
1527 /* 0xff01 is a flag rather then an actual voltage */
1528 if (voltage
->vddci
== 0xff01)
1530 if (voltage
->vddci
&& (voltage
->vddci
!= rdev
->pm
.current_vddci
)) {
1531 radeon_atom_set_voltage(rdev
, voltage
->vddci
, SET_VOLTAGE_TYPE_ASIC_VDDCI
);
1532 rdev
->pm
.current_vddci
= voltage
->vddci
;
1533 DRM_DEBUG("Setting: vddci: %d\n", voltage
->vddci
);
1539 * evergreen_pm_prepare - pre-power state change callback.
1541 * @rdev: radeon_device pointer
1543 * Prepare for a power state change (evergreen+).
1545 void evergreen_pm_prepare(struct radeon_device
*rdev
)
1547 struct drm_device
*ddev
= rdev
->ddev
;
1548 struct drm_crtc
*crtc
;
1549 struct radeon_crtc
*radeon_crtc
;
1552 /* disable any active CRTCs */
1553 list_for_each_entry(crtc
, &ddev
->mode_config
.crtc_list
, head
) {
1554 radeon_crtc
= to_radeon_crtc(crtc
);
1555 if (radeon_crtc
->enabled
) {
1556 tmp
= RREG32(EVERGREEN_CRTC_CONTROL
+ radeon_crtc
->crtc_offset
);
1557 tmp
|= EVERGREEN_CRTC_DISP_READ_REQUEST_DISABLE
;
1558 WREG32(EVERGREEN_CRTC_CONTROL
+ radeon_crtc
->crtc_offset
, tmp
);
1564 * evergreen_pm_finish - post-power state change callback.
1566 * @rdev: radeon_device pointer
1568 * Clean up after a power state change (evergreen+).
1570 void evergreen_pm_finish(struct radeon_device
*rdev
)
1572 struct drm_device
*ddev
= rdev
->ddev
;
1573 struct drm_crtc
*crtc
;
1574 struct radeon_crtc
*radeon_crtc
;
1577 /* enable any active CRTCs */
1578 list_for_each_entry(crtc
, &ddev
->mode_config
.crtc_list
, head
) {
1579 radeon_crtc
= to_radeon_crtc(crtc
);
1580 if (radeon_crtc
->enabled
) {
1581 tmp
= RREG32(EVERGREEN_CRTC_CONTROL
+ radeon_crtc
->crtc_offset
);
1582 tmp
&= ~EVERGREEN_CRTC_DISP_READ_REQUEST_DISABLE
;
1583 WREG32(EVERGREEN_CRTC_CONTROL
+ radeon_crtc
->crtc_offset
, tmp
);
1589 * evergreen_hpd_sense - hpd sense callback.
1591 * @rdev: radeon_device pointer
1592 * @hpd: hpd (hotplug detect) pin
1594 * Checks if a digital monitor is connected (evergreen+).
1595 * Returns true if connected, false if not connected.
1597 bool evergreen_hpd_sense(struct radeon_device
*rdev
, enum radeon_hpd_id hpd
)
1599 bool connected
= false;
1603 if (RREG32(DC_HPD1_INT_STATUS
) & DC_HPDx_SENSE
)
1607 if (RREG32(DC_HPD2_INT_STATUS
) & DC_HPDx_SENSE
)
1611 if (RREG32(DC_HPD3_INT_STATUS
) & DC_HPDx_SENSE
)
1615 if (RREG32(DC_HPD4_INT_STATUS
) & DC_HPDx_SENSE
)
1619 if (RREG32(DC_HPD5_INT_STATUS
) & DC_HPDx_SENSE
)
1623 if (RREG32(DC_HPD6_INT_STATUS
) & DC_HPDx_SENSE
)
1634 * evergreen_hpd_set_polarity - hpd set polarity callback.
1636 * @rdev: radeon_device pointer
1637 * @hpd: hpd (hotplug detect) pin
1639 * Set the polarity of the hpd pin (evergreen+).
1641 void evergreen_hpd_set_polarity(struct radeon_device
*rdev
,
1642 enum radeon_hpd_id hpd
)
1645 bool connected
= evergreen_hpd_sense(rdev
, hpd
);
1649 tmp
= RREG32(DC_HPD1_INT_CONTROL
);
1651 tmp
&= ~DC_HPDx_INT_POLARITY
;
1653 tmp
|= DC_HPDx_INT_POLARITY
;
1654 WREG32(DC_HPD1_INT_CONTROL
, tmp
);
1657 tmp
= RREG32(DC_HPD2_INT_CONTROL
);
1659 tmp
&= ~DC_HPDx_INT_POLARITY
;
1661 tmp
|= DC_HPDx_INT_POLARITY
;
1662 WREG32(DC_HPD2_INT_CONTROL
, tmp
);
1665 tmp
= RREG32(DC_HPD3_INT_CONTROL
);
1667 tmp
&= ~DC_HPDx_INT_POLARITY
;
1669 tmp
|= DC_HPDx_INT_POLARITY
;
1670 WREG32(DC_HPD3_INT_CONTROL
, tmp
);
1673 tmp
= RREG32(DC_HPD4_INT_CONTROL
);
1675 tmp
&= ~DC_HPDx_INT_POLARITY
;
1677 tmp
|= DC_HPDx_INT_POLARITY
;
1678 WREG32(DC_HPD4_INT_CONTROL
, tmp
);
1681 tmp
= RREG32(DC_HPD5_INT_CONTROL
);
1683 tmp
&= ~DC_HPDx_INT_POLARITY
;
1685 tmp
|= DC_HPDx_INT_POLARITY
;
1686 WREG32(DC_HPD5_INT_CONTROL
, tmp
);
1689 tmp
= RREG32(DC_HPD6_INT_CONTROL
);
1691 tmp
&= ~DC_HPDx_INT_POLARITY
;
1693 tmp
|= DC_HPDx_INT_POLARITY
;
1694 WREG32(DC_HPD6_INT_CONTROL
, tmp
);
1702 * evergreen_hpd_init - hpd setup callback.
1704 * @rdev: radeon_device pointer
1706 * Setup the hpd pins used by the card (evergreen+).
1707 * Enable the pin, set the polarity, and enable the hpd interrupts.
1709 void evergreen_hpd_init(struct radeon_device
*rdev
)
1711 struct drm_device
*dev
= rdev
->ddev
;
1712 struct drm_connector
*connector
;
1713 unsigned enabled
= 0;
1714 u32 tmp
= DC_HPDx_CONNECTION_TIMER(0x9c4) |
1715 DC_HPDx_RX_INT_TIMER(0xfa) | DC_HPDx_EN
;
1717 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, head
) {
1718 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1720 if (connector
->connector_type
== DRM_MODE_CONNECTOR_eDP
||
1721 connector
->connector_type
== DRM_MODE_CONNECTOR_LVDS
) {
1722 /* don't try to enable hpd on eDP or LVDS avoid breaking the
1723 * aux dp channel on imac and help (but not completely fix)
1724 * https://bugzilla.redhat.com/show_bug.cgi?id=726143
1725 * also avoid interrupt storms during dpms.
1729 switch (radeon_connector
->hpd
.hpd
) {
1731 WREG32(DC_HPD1_CONTROL
, tmp
);
1734 WREG32(DC_HPD2_CONTROL
, tmp
);
1737 WREG32(DC_HPD3_CONTROL
, tmp
);
1740 WREG32(DC_HPD4_CONTROL
, tmp
);
1743 WREG32(DC_HPD5_CONTROL
, tmp
);
1746 WREG32(DC_HPD6_CONTROL
, tmp
);
1751 radeon_hpd_set_polarity(rdev
, radeon_connector
->hpd
.hpd
);
1752 enabled
|= 1 << radeon_connector
->hpd
.hpd
;
1754 radeon_irq_kms_enable_hpd(rdev
, enabled
);
1758 * evergreen_hpd_fini - hpd tear down callback.
1760 * @rdev: radeon_device pointer
1762 * Tear down the hpd pins used by the card (evergreen+).
1763 * Disable the hpd interrupts.
1765 void evergreen_hpd_fini(struct radeon_device
*rdev
)
1767 struct drm_device
*dev
= rdev
->ddev
;
1768 struct drm_connector
*connector
;
1769 unsigned disabled
= 0;
1771 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, head
) {
1772 struct radeon_connector
*radeon_connector
= to_radeon_connector(connector
);
1773 switch (radeon_connector
->hpd
.hpd
) {
1775 WREG32(DC_HPD1_CONTROL
, 0);
1778 WREG32(DC_HPD2_CONTROL
, 0);
1781 WREG32(DC_HPD3_CONTROL
, 0);
1784 WREG32(DC_HPD4_CONTROL
, 0);
1787 WREG32(DC_HPD5_CONTROL
, 0);
1790 WREG32(DC_HPD6_CONTROL
, 0);
1795 disabled
|= 1 << radeon_connector
->hpd
.hpd
;
1797 radeon_irq_kms_disable_hpd(rdev
, disabled
);
1800 /* watermark setup */
1802 static u32
evergreen_line_buffer_adjust(struct radeon_device
*rdev
,
1803 struct radeon_crtc
*radeon_crtc
,
1804 struct drm_display_mode
*mode
,
1805 struct drm_display_mode
*other_mode
)
1810 * There are 3 line buffers, each one shared by 2 display controllers.
1811 * DC_LB_MEMORY_SPLIT controls how that line buffer is shared between
1812 * the display controllers. The paritioning is done via one of four
1813 * preset allocations specified in bits 2:0:
1814 * first display controller
1815 * 0 - first half of lb (3840 * 2)
1816 * 1 - first 3/4 of lb (5760 * 2)
1817 * 2 - whole lb (7680 * 2), other crtc must be disabled
1818 * 3 - first 1/4 of lb (1920 * 2)
1819 * second display controller
1820 * 4 - second half of lb (3840 * 2)
1821 * 5 - second 3/4 of lb (5760 * 2)
1822 * 6 - whole lb (7680 * 2), other crtc must be disabled
1823 * 7 - last 1/4 of lb (1920 * 2)
1825 /* this can get tricky if we have two large displays on a paired group
1826 * of crtcs. Ideally for multiple large displays we'd assign them to
1827 * non-linked crtcs for maximum line buffer allocation.
1829 if (radeon_crtc
->base
.enabled
&& mode
) {
1833 tmp
= 2; /* whole */
1837 /* second controller of the pair uses second half of the lb */
1838 if (radeon_crtc
->crtc_id
% 2)
1840 WREG32(DC_LB_MEMORY_SPLIT
+ radeon_crtc
->crtc_offset
, tmp
);
1842 if (radeon_crtc
->base
.enabled
&& mode
) {
1847 if (ASIC_IS_DCE5(rdev
))
1853 if (ASIC_IS_DCE5(rdev
))
1859 if (ASIC_IS_DCE5(rdev
))
1865 if (ASIC_IS_DCE5(rdev
))
1872 /* controller not enabled, so no lb used */
1876 u32
evergreen_get_number_of_dram_channels(struct radeon_device
*rdev
)
1878 u32 tmp
= RREG32(MC_SHARED_CHMAP
);
1880 switch ((tmp
& NOOFCHAN_MASK
) >> NOOFCHAN_SHIFT
) {
1893 struct evergreen_wm_params
{
1894 u32 dram_channels
; /* number of dram channels */
1895 u32 yclk
; /* bandwidth per dram data pin in kHz */
1896 u32 sclk
; /* engine clock in kHz */
1897 u32 disp_clk
; /* display clock in kHz */
1898 u32 src_width
; /* viewport width */
1899 u32 active_time
; /* active display time in ns */
1900 u32 blank_time
; /* blank time in ns */
1901 bool interlaced
; /* mode is interlaced */
1902 fixed20_12 vsc
; /* vertical scale ratio */
1903 u32 num_heads
; /* number of active crtcs */
1904 u32 bytes_per_pixel
; /* bytes per pixel display + overlay */
1905 u32 lb_size
; /* line buffer allocated to pipe */
1906 u32 vtaps
; /* vertical scaler taps */
1909 static u32
evergreen_dram_bandwidth(struct evergreen_wm_params
*wm
)
1911 /* Calculate DRAM Bandwidth and the part allocated to display. */
1912 fixed20_12 dram_efficiency
; /* 0.7 */
1913 fixed20_12 yclk
, dram_channels
, bandwidth
;
1916 a
.full
= dfixed_const(1000);
1917 yclk
.full
= dfixed_const(wm
->yclk
);
1918 yclk
.full
= dfixed_div(yclk
, a
);
1919 dram_channels
.full
= dfixed_const(wm
->dram_channels
* 4);
1920 a
.full
= dfixed_const(10);
1921 dram_efficiency
.full
= dfixed_const(7);
1922 dram_efficiency
.full
= dfixed_div(dram_efficiency
, a
);
1923 bandwidth
.full
= dfixed_mul(dram_channels
, yclk
);
1924 bandwidth
.full
= dfixed_mul(bandwidth
, dram_efficiency
);
1926 return dfixed_trunc(bandwidth
);
1929 static u32
evergreen_dram_bandwidth_for_display(struct evergreen_wm_params
*wm
)
1931 /* Calculate DRAM Bandwidth and the part allocated to display. */
1932 fixed20_12 disp_dram_allocation
; /* 0.3 to 0.7 */
1933 fixed20_12 yclk
, dram_channels
, bandwidth
;
1936 a
.full
= dfixed_const(1000);
1937 yclk
.full
= dfixed_const(wm
->yclk
);
1938 yclk
.full
= dfixed_div(yclk
, a
);
1939 dram_channels
.full
= dfixed_const(wm
->dram_channels
* 4);
1940 a
.full
= dfixed_const(10);
1941 disp_dram_allocation
.full
= dfixed_const(3); /* XXX worse case value 0.3 */
1942 disp_dram_allocation
.full
= dfixed_div(disp_dram_allocation
, a
);
1943 bandwidth
.full
= dfixed_mul(dram_channels
, yclk
);
1944 bandwidth
.full
= dfixed_mul(bandwidth
, disp_dram_allocation
);
1946 return dfixed_trunc(bandwidth
);
1949 static u32
evergreen_data_return_bandwidth(struct evergreen_wm_params
*wm
)
1951 /* Calculate the display Data return Bandwidth */
1952 fixed20_12 return_efficiency
; /* 0.8 */
1953 fixed20_12 sclk
, bandwidth
;
1956 a
.full
= dfixed_const(1000);
1957 sclk
.full
= dfixed_const(wm
->sclk
);
1958 sclk
.full
= dfixed_div(sclk
, a
);
1959 a
.full
= dfixed_const(10);
1960 return_efficiency
.full
= dfixed_const(8);
1961 return_efficiency
.full
= dfixed_div(return_efficiency
, a
);
1962 a
.full
= dfixed_const(32);
1963 bandwidth
.full
= dfixed_mul(a
, sclk
);
1964 bandwidth
.full
= dfixed_mul(bandwidth
, return_efficiency
);
1966 return dfixed_trunc(bandwidth
);
1969 static u32
evergreen_dmif_request_bandwidth(struct evergreen_wm_params
*wm
)
1971 /* Calculate the DMIF Request Bandwidth */
1972 fixed20_12 disp_clk_request_efficiency
; /* 0.8 */
1973 fixed20_12 disp_clk
, bandwidth
;
1976 a
.full
= dfixed_const(1000);
1977 disp_clk
.full
= dfixed_const(wm
->disp_clk
);
1978 disp_clk
.full
= dfixed_div(disp_clk
, a
);
1979 a
.full
= dfixed_const(10);
1980 disp_clk_request_efficiency
.full
= dfixed_const(8);
1981 disp_clk_request_efficiency
.full
= dfixed_div(disp_clk_request_efficiency
, a
);
1982 a
.full
= dfixed_const(32);
1983 bandwidth
.full
= dfixed_mul(a
, disp_clk
);
1984 bandwidth
.full
= dfixed_mul(bandwidth
, disp_clk_request_efficiency
);
1986 return dfixed_trunc(bandwidth
);
1989 static u32
evergreen_available_bandwidth(struct evergreen_wm_params
*wm
)
1991 /* Calculate the Available bandwidth. Display can use this temporarily but not in average. */
1992 u32 dram_bandwidth
= evergreen_dram_bandwidth(wm
);
1993 u32 data_return_bandwidth
= evergreen_data_return_bandwidth(wm
);
1994 u32 dmif_req_bandwidth
= evergreen_dmif_request_bandwidth(wm
);
1996 return min(dram_bandwidth
, min(data_return_bandwidth
, dmif_req_bandwidth
));
1999 static u32
evergreen_average_bandwidth(struct evergreen_wm_params
*wm
)
2001 /* Calculate the display mode Average Bandwidth
2002 * DisplayMode should contain the source and destination dimensions,
2006 fixed20_12 line_time
;
2007 fixed20_12 src_width
;
2008 fixed20_12 bandwidth
;
2011 a
.full
= dfixed_const(1000);
2012 line_time
.full
= dfixed_const(wm
->active_time
+ wm
->blank_time
);
2013 line_time
.full
= dfixed_div(line_time
, a
);
2014 bpp
.full
= dfixed_const(wm
->bytes_per_pixel
);
2015 src_width
.full
= dfixed_const(wm
->src_width
);
2016 bandwidth
.full
= dfixed_mul(src_width
, bpp
);
2017 bandwidth
.full
= dfixed_mul(bandwidth
, wm
->vsc
);
2018 bandwidth
.full
= dfixed_div(bandwidth
, line_time
);
2020 return dfixed_trunc(bandwidth
);
2023 static u32
evergreen_latency_watermark(struct evergreen_wm_params
*wm
)
2025 /* First calcualte the latency in ns */
2026 u32 mc_latency
= 2000; /* 2000 ns. */
2027 u32 available_bandwidth
= evergreen_available_bandwidth(wm
);
2028 u32 worst_chunk_return_time
= (512 * 8 * 1000) / available_bandwidth
;
2029 u32 cursor_line_pair_return_time
= (128 * 4 * 1000) / available_bandwidth
;
2030 u32 dc_latency
= 40000000 / wm
->disp_clk
; /* dc pipe latency */
2031 u32 other_heads_data_return_time
= ((wm
->num_heads
+ 1) * worst_chunk_return_time
) +
2032 (wm
->num_heads
* cursor_line_pair_return_time
);
2033 u32 latency
= mc_latency
+ other_heads_data_return_time
+ dc_latency
;
2034 u32 max_src_lines_per_dst_line
, lb_fill_bw
, line_fill_time
;
2037 if (wm
->num_heads
== 0)
2040 a
.full
= dfixed_const(2);
2041 b
.full
= dfixed_const(1);
2042 if ((wm
->vsc
.full
> a
.full
) ||
2043 ((wm
->vsc
.full
> b
.full
) && (wm
->vtaps
>= 3)) ||
2045 ((wm
->vsc
.full
>= a
.full
) && wm
->interlaced
))
2046 max_src_lines_per_dst_line
= 4;
2048 max_src_lines_per_dst_line
= 2;
2050 a
.full
= dfixed_const(available_bandwidth
);
2051 b
.full
= dfixed_const(wm
->num_heads
);
2052 a
.full
= dfixed_div(a
, b
);
2054 b
.full
= dfixed_const(1000);
2055 c
.full
= dfixed_const(wm
->disp_clk
);
2056 b
.full
= dfixed_div(c
, b
);
2057 c
.full
= dfixed_const(wm
->bytes_per_pixel
);
2058 b
.full
= dfixed_mul(b
, c
);
2060 lb_fill_bw
= min(dfixed_trunc(a
), dfixed_trunc(b
));
2062 a
.full
= dfixed_const(max_src_lines_per_dst_line
* wm
->src_width
* wm
->bytes_per_pixel
);
2063 b
.full
= dfixed_const(1000);
2064 c
.full
= dfixed_const(lb_fill_bw
);
2065 b
.full
= dfixed_div(c
, b
);
2066 a
.full
= dfixed_div(a
, b
);
2067 line_fill_time
= dfixed_trunc(a
);
2069 if (line_fill_time
< wm
->active_time
)
2072 return latency
+ (line_fill_time
- wm
->active_time
);
2076 static bool evergreen_average_bandwidth_vs_dram_bandwidth_for_display(struct evergreen_wm_params
*wm
)
2078 if (evergreen_average_bandwidth(wm
) <=
2079 (evergreen_dram_bandwidth_for_display(wm
) / wm
->num_heads
))
2085 static bool evergreen_average_bandwidth_vs_available_bandwidth(struct evergreen_wm_params
*wm
)
2087 if (evergreen_average_bandwidth(wm
) <=
2088 (evergreen_available_bandwidth(wm
) / wm
->num_heads
))
2094 static bool evergreen_check_latency_hiding(struct evergreen_wm_params
*wm
)
2096 u32 lb_partitions
= wm
->lb_size
/ wm
->src_width
;
2097 u32 line_time
= wm
->active_time
+ wm
->blank_time
;
2098 u32 latency_tolerant_lines
;
2102 a
.full
= dfixed_const(1);
2103 if (wm
->vsc
.full
> a
.full
)
2104 latency_tolerant_lines
= 1;
2106 if (lb_partitions
<= (wm
->vtaps
+ 1))
2107 latency_tolerant_lines
= 1;
2109 latency_tolerant_lines
= 2;
2112 latency_hiding
= (latency_tolerant_lines
* line_time
+ wm
->blank_time
);
2114 if (evergreen_latency_watermark(wm
) <= latency_hiding
)
2120 static void evergreen_program_watermarks(struct radeon_device
*rdev
,
2121 struct radeon_crtc
*radeon_crtc
,
2122 u32 lb_size
, u32 num_heads
)
2124 struct drm_display_mode
*mode
= &radeon_crtc
->base
.mode
;
2125 struct evergreen_wm_params wm_low
, wm_high
;
2129 u32 latency_watermark_a
= 0, latency_watermark_b
= 0;
2130 u32 priority_a_mark
= 0, priority_b_mark
= 0;
2131 u32 priority_a_cnt
= PRIORITY_OFF
;
2132 u32 priority_b_cnt
= PRIORITY_OFF
;
2133 u32 pipe_offset
= radeon_crtc
->crtc_id
* 16;
2134 u32 tmp
, arb_control3
;
2137 if (radeon_crtc
->base
.enabled
&& num_heads
&& mode
) {
2138 pixel_period
= 1000000 / (u32
)mode
->clock
;
2139 line_time
= min((u32
)mode
->crtc_htotal
* pixel_period
, (u32
)65535);
2142 dram_channels
= evergreen_get_number_of_dram_channels(rdev
);
2144 /* watermark for high clocks */
2145 if ((rdev
->pm
.pm_method
== PM_METHOD_DPM
) && rdev
->pm
.dpm_enabled
) {
2147 radeon_dpm_get_mclk(rdev
, false) * 10;
2149 radeon_dpm_get_sclk(rdev
, false) * 10;
2151 wm_high
.yclk
= rdev
->pm
.current_mclk
* 10;
2152 wm_high
.sclk
= rdev
->pm
.current_sclk
* 10;
2155 wm_high
.disp_clk
= mode
->clock
;
2156 wm_high
.src_width
= mode
->crtc_hdisplay
;
2157 wm_high
.active_time
= mode
->crtc_hdisplay
* pixel_period
;
2158 wm_high
.blank_time
= line_time
- wm_high
.active_time
;
2159 wm_high
.interlaced
= false;
2160 if (mode
->flags
& DRM_MODE_FLAG_INTERLACE
)
2161 wm_high
.interlaced
= true;
2162 wm_high
.vsc
= radeon_crtc
->vsc
;
2164 if (radeon_crtc
->rmx_type
!= RMX_OFF
)
2166 wm_high
.bytes_per_pixel
= 4; /* XXX: get this from fb config */
2167 wm_high
.lb_size
= lb_size
;
2168 wm_high
.dram_channels
= dram_channels
;
2169 wm_high
.num_heads
= num_heads
;
2171 /* watermark for low clocks */
2172 if ((rdev
->pm
.pm_method
== PM_METHOD_DPM
) && rdev
->pm
.dpm_enabled
) {
2174 radeon_dpm_get_mclk(rdev
, true) * 10;
2176 radeon_dpm_get_sclk(rdev
, true) * 10;
2178 wm_low
.yclk
= rdev
->pm
.current_mclk
* 10;
2179 wm_low
.sclk
= rdev
->pm
.current_sclk
* 10;
2182 wm_low
.disp_clk
= mode
->clock
;
2183 wm_low
.src_width
= mode
->crtc_hdisplay
;
2184 wm_low
.active_time
= mode
->crtc_hdisplay
* pixel_period
;
2185 wm_low
.blank_time
= line_time
- wm_low
.active_time
;
2186 wm_low
.interlaced
= false;
2187 if (mode
->flags
& DRM_MODE_FLAG_INTERLACE
)
2188 wm_low
.interlaced
= true;
2189 wm_low
.vsc
= radeon_crtc
->vsc
;
2191 if (radeon_crtc
->rmx_type
!= RMX_OFF
)
2193 wm_low
.bytes_per_pixel
= 4; /* XXX: get this from fb config */
2194 wm_low
.lb_size
= lb_size
;
2195 wm_low
.dram_channels
= dram_channels
;
2196 wm_low
.num_heads
= num_heads
;
2198 /* set for high clocks */
2199 latency_watermark_a
= min(evergreen_latency_watermark(&wm_high
), (u32
)65535);
2200 /* set for low clocks */
2201 latency_watermark_b
= min(evergreen_latency_watermark(&wm_low
), (u32
)65535);
2203 /* possibly force display priority to high */
2204 /* should really do this at mode validation time... */
2205 if (!evergreen_average_bandwidth_vs_dram_bandwidth_for_display(&wm_high
) ||
2206 !evergreen_average_bandwidth_vs_available_bandwidth(&wm_high
) ||
2207 !evergreen_check_latency_hiding(&wm_high
) ||
2208 (rdev
->disp_priority
== 2)) {
2209 DRM_DEBUG_KMS("force priority a to high\n");
2210 priority_a_cnt
|= PRIORITY_ALWAYS_ON
;
2212 if (!evergreen_average_bandwidth_vs_dram_bandwidth_for_display(&wm_low
) ||
2213 !evergreen_average_bandwidth_vs_available_bandwidth(&wm_low
) ||
2214 !evergreen_check_latency_hiding(&wm_low
) ||
2215 (rdev
->disp_priority
== 2)) {
2216 DRM_DEBUG_KMS("force priority b to high\n");
2217 priority_b_cnt
|= PRIORITY_ALWAYS_ON
;
2220 a
.full
= dfixed_const(1000);
2221 b
.full
= dfixed_const(mode
->clock
);
2222 b
.full
= dfixed_div(b
, a
);
2223 c
.full
= dfixed_const(latency_watermark_a
);
2224 c
.full
= dfixed_mul(c
, b
);
2225 c
.full
= dfixed_mul(c
, radeon_crtc
->hsc
);
2226 c
.full
= dfixed_div(c
, a
);
2227 a
.full
= dfixed_const(16);
2228 c
.full
= dfixed_div(c
, a
);
2229 priority_a_mark
= dfixed_trunc(c
);
2230 priority_a_cnt
|= priority_a_mark
& PRIORITY_MARK_MASK
;
2232 a
.full
= dfixed_const(1000);
2233 b
.full
= dfixed_const(mode
->clock
);
2234 b
.full
= dfixed_div(b
, a
);
2235 c
.full
= dfixed_const(latency_watermark_b
);
2236 c
.full
= dfixed_mul(c
, b
);
2237 c
.full
= dfixed_mul(c
, radeon_crtc
->hsc
);
2238 c
.full
= dfixed_div(c
, a
);
2239 a
.full
= dfixed_const(16);
2240 c
.full
= dfixed_div(c
, a
);
2241 priority_b_mark
= dfixed_trunc(c
);
2242 priority_b_cnt
|= priority_b_mark
& PRIORITY_MARK_MASK
;
2246 arb_control3
= RREG32(PIPE0_ARBITRATION_CONTROL3
+ pipe_offset
);
2248 tmp
&= ~LATENCY_WATERMARK_MASK(3);
2249 tmp
|= LATENCY_WATERMARK_MASK(1);
2250 WREG32(PIPE0_ARBITRATION_CONTROL3
+ pipe_offset
, tmp
);
2251 WREG32(PIPE0_LATENCY_CONTROL
+ pipe_offset
,
2252 (LATENCY_LOW_WATERMARK(latency_watermark_a
) |
2253 LATENCY_HIGH_WATERMARK(line_time
)));
2255 tmp
= RREG32(PIPE0_ARBITRATION_CONTROL3
+ pipe_offset
);
2256 tmp
&= ~LATENCY_WATERMARK_MASK(3);
2257 tmp
|= LATENCY_WATERMARK_MASK(2);
2258 WREG32(PIPE0_ARBITRATION_CONTROL3
+ pipe_offset
, tmp
);
2259 WREG32(PIPE0_LATENCY_CONTROL
+ pipe_offset
,
2260 (LATENCY_LOW_WATERMARK(latency_watermark_b
) |
2261 LATENCY_HIGH_WATERMARK(line_time
)));
2262 /* restore original selection */
2263 WREG32(PIPE0_ARBITRATION_CONTROL3
+ pipe_offset
, arb_control3
);
2265 /* write the priority marks */
2266 WREG32(PRIORITY_A_CNT
+ radeon_crtc
->crtc_offset
, priority_a_cnt
);
2267 WREG32(PRIORITY_B_CNT
+ radeon_crtc
->crtc_offset
, priority_b_cnt
);
2272 * evergreen_bandwidth_update - update display watermarks callback.
2274 * @rdev: radeon_device pointer
2276 * Update the display watermarks based on the requested mode(s)
2279 void evergreen_bandwidth_update(struct radeon_device
*rdev
)
2281 struct drm_display_mode
*mode0
= NULL
;
2282 struct drm_display_mode
*mode1
= NULL
;
2283 u32 num_heads
= 0, lb_size
;
2286 radeon_update_display_priority(rdev
);
2288 for (i
= 0; i
< rdev
->num_crtc
; i
++) {
2289 if (rdev
->mode_info
.crtcs
[i
]->base
.enabled
)
2292 for (i
= 0; i
< rdev
->num_crtc
; i
+= 2) {
2293 mode0
= &rdev
->mode_info
.crtcs
[i
]->base
.mode
;
2294 mode1
= &rdev
->mode_info
.crtcs
[i
+1]->base
.mode
;
2295 lb_size
= evergreen_line_buffer_adjust(rdev
, rdev
->mode_info
.crtcs
[i
], mode0
, mode1
);
2296 evergreen_program_watermarks(rdev
, rdev
->mode_info
.crtcs
[i
], lb_size
, num_heads
);
2297 lb_size
= evergreen_line_buffer_adjust(rdev
, rdev
->mode_info
.crtcs
[i
+1], mode1
, mode0
);
2298 evergreen_program_watermarks(rdev
, rdev
->mode_info
.crtcs
[i
+1], lb_size
, num_heads
);
2303 * evergreen_mc_wait_for_idle - wait for MC idle callback.
2305 * @rdev: radeon_device pointer
2307 * Wait for the MC (memory controller) to be idle.
2309 * Returns 0 if the MC is idle, -1 if not.
2311 int evergreen_mc_wait_for_idle(struct radeon_device
*rdev
)
2316 for (i
= 0; i
< rdev
->usec_timeout
; i
++) {
2317 /* read MC_STATUS */
2318 tmp
= RREG32(SRBM_STATUS
) & 0x1F00;
2329 void evergreen_pcie_gart_tlb_flush(struct radeon_device
*rdev
)
2334 WREG32(HDP_MEM_COHERENCY_FLUSH_CNTL
, 0x1);
2336 WREG32(VM_CONTEXT0_REQUEST_RESPONSE
, REQUEST_TYPE(1));
2337 for (i
= 0; i
< rdev
->usec_timeout
; i
++) {
2338 /* read MC_STATUS */
2339 tmp
= RREG32(VM_CONTEXT0_REQUEST_RESPONSE
);
2340 tmp
= (tmp
& RESPONSE_TYPE_MASK
) >> RESPONSE_TYPE_SHIFT
;
2342 printk(KERN_WARNING
"[drm] r600 flush TLB failed\n");
2352 static int evergreen_pcie_gart_enable(struct radeon_device
*rdev
)
2357 if (rdev
->gart
.robj
== NULL
) {
2358 dev_err(rdev
->dev
, "No VRAM object for PCIE GART.\n");
2361 r
= radeon_gart_table_vram_pin(rdev
);
2364 radeon_gart_restore(rdev
);
2365 /* Setup L2 cache */
2366 WREG32(VM_L2_CNTL
, ENABLE_L2_CACHE
| ENABLE_L2_FRAGMENT_PROCESSING
|
2367 ENABLE_L2_PTE_CACHE_LRU_UPDATE_BY_WRITE
|
2368 EFFECTIVE_L2_QUEUE_SIZE(7));
2369 WREG32(VM_L2_CNTL2
, 0);
2370 WREG32(VM_L2_CNTL3
, BANK_SELECT(0) | CACHE_UPDATE_MODE(2));
2371 /* Setup TLB control */
2372 tmp
= ENABLE_L1_TLB
| ENABLE_L1_FRAGMENT_PROCESSING
|
2373 SYSTEM_ACCESS_MODE_NOT_IN_SYS
|
2374 SYSTEM_APERTURE_UNMAPPED_ACCESS_PASS_THRU
|
2375 EFFECTIVE_L1_TLB_SIZE(5) | EFFECTIVE_L1_QUEUE_SIZE(5);
2376 if (rdev
->flags
& RADEON_IS_IGP
) {
2377 WREG32(FUS_MC_VM_MD_L1_TLB0_CNTL
, tmp
);
2378 WREG32(FUS_MC_VM_MD_L1_TLB1_CNTL
, tmp
);
2379 WREG32(FUS_MC_VM_MD_L1_TLB2_CNTL
, tmp
);
2381 WREG32(MC_VM_MD_L1_TLB0_CNTL
, tmp
);
2382 WREG32(MC_VM_MD_L1_TLB1_CNTL
, tmp
);
2383 WREG32(MC_VM_MD_L1_TLB2_CNTL
, tmp
);
2384 if ((rdev
->family
== CHIP_JUNIPER
) ||
2385 (rdev
->family
== CHIP_CYPRESS
) ||
2386 (rdev
->family
== CHIP_HEMLOCK
) ||
2387 (rdev
->family
== CHIP_BARTS
))
2388 WREG32(MC_VM_MD_L1_TLB3_CNTL
, tmp
);
2390 WREG32(MC_VM_MB_L1_TLB0_CNTL
, tmp
);
2391 WREG32(MC_VM_MB_L1_TLB1_CNTL
, tmp
);
2392 WREG32(MC_VM_MB_L1_TLB2_CNTL
, tmp
);
2393 WREG32(MC_VM_MB_L1_TLB3_CNTL
, tmp
);
2394 WREG32(VM_CONTEXT0_PAGE_TABLE_START_ADDR
, rdev
->mc
.gtt_start
>> 12);
2395 WREG32(VM_CONTEXT0_PAGE_TABLE_END_ADDR
, rdev
->mc
.gtt_end
>> 12);
2396 WREG32(VM_CONTEXT0_PAGE_TABLE_BASE_ADDR
, rdev
->gart
.table_addr
>> 12);
2397 WREG32(VM_CONTEXT0_CNTL
, ENABLE_CONTEXT
| PAGE_TABLE_DEPTH(0) |
2398 RANGE_PROTECTION_FAULT_ENABLE_DEFAULT
);
2399 WREG32(VM_CONTEXT0_PROTECTION_FAULT_DEFAULT_ADDR
,
2400 (u32
)(rdev
->dummy_page
.addr
>> 12));
2401 WREG32(VM_CONTEXT1_CNTL
, 0);
2403 evergreen_pcie_gart_tlb_flush(rdev
);
2404 DRM_INFO("PCIE GART of %uM enabled (table at 0x%016llX).\n",
2405 (unsigned)(rdev
->mc
.gtt_size
>> 20),
2406 (unsigned long long)rdev
->gart
.table_addr
);
2407 rdev
->gart
.ready
= true;
2411 static void evergreen_pcie_gart_disable(struct radeon_device
*rdev
)
2415 /* Disable all tables */
2416 WREG32(VM_CONTEXT0_CNTL
, 0);
2417 WREG32(VM_CONTEXT1_CNTL
, 0);
2419 /* Setup L2 cache */
2420 WREG32(VM_L2_CNTL
, ENABLE_L2_FRAGMENT_PROCESSING
|
2421 EFFECTIVE_L2_QUEUE_SIZE(7));
2422 WREG32(VM_L2_CNTL2
, 0);
2423 WREG32(VM_L2_CNTL3
, BANK_SELECT(0) | CACHE_UPDATE_MODE(2));
2424 /* Setup TLB control */
2425 tmp
= EFFECTIVE_L1_TLB_SIZE(5) | EFFECTIVE_L1_QUEUE_SIZE(5);
2426 WREG32(MC_VM_MD_L1_TLB0_CNTL
, tmp
);
2427 WREG32(MC_VM_MD_L1_TLB1_CNTL
, tmp
);
2428 WREG32(MC_VM_MD_L1_TLB2_CNTL
, tmp
);
2429 WREG32(MC_VM_MB_L1_TLB0_CNTL
, tmp
);
2430 WREG32(MC_VM_MB_L1_TLB1_CNTL
, tmp
);
2431 WREG32(MC_VM_MB_L1_TLB2_CNTL
, tmp
);
2432 WREG32(MC_VM_MB_L1_TLB3_CNTL
, tmp
);
2433 radeon_gart_table_vram_unpin(rdev
);
2436 static void evergreen_pcie_gart_fini(struct radeon_device
*rdev
)
2438 evergreen_pcie_gart_disable(rdev
);
2439 radeon_gart_table_vram_free(rdev
);
2440 radeon_gart_fini(rdev
);
2444 static void evergreen_agp_enable(struct radeon_device
*rdev
)
2448 /* Setup L2 cache */
2449 WREG32(VM_L2_CNTL
, ENABLE_L2_CACHE
| ENABLE_L2_FRAGMENT_PROCESSING
|
2450 ENABLE_L2_PTE_CACHE_LRU_UPDATE_BY_WRITE
|
2451 EFFECTIVE_L2_QUEUE_SIZE(7));
2452 WREG32(VM_L2_CNTL2
, 0);
2453 WREG32(VM_L2_CNTL3
, BANK_SELECT(0) | CACHE_UPDATE_MODE(2));
2454 /* Setup TLB control */
2455 tmp
= ENABLE_L1_TLB
| ENABLE_L1_FRAGMENT_PROCESSING
|
2456 SYSTEM_ACCESS_MODE_NOT_IN_SYS
|
2457 SYSTEM_APERTURE_UNMAPPED_ACCESS_PASS_THRU
|
2458 EFFECTIVE_L1_TLB_SIZE(5) | EFFECTIVE_L1_QUEUE_SIZE(5);
2459 WREG32(MC_VM_MD_L1_TLB0_CNTL
, tmp
);
2460 WREG32(MC_VM_MD_L1_TLB1_CNTL
, tmp
);
2461 WREG32(MC_VM_MD_L1_TLB2_CNTL
, tmp
);
2462 WREG32(MC_VM_MB_L1_TLB0_CNTL
, tmp
);
2463 WREG32(MC_VM_MB_L1_TLB1_CNTL
, tmp
);
2464 WREG32(MC_VM_MB_L1_TLB2_CNTL
, tmp
);
2465 WREG32(MC_VM_MB_L1_TLB3_CNTL
, tmp
);
2466 WREG32(VM_CONTEXT0_CNTL
, 0);
2467 WREG32(VM_CONTEXT1_CNTL
, 0);
2470 void evergreen_mc_stop(struct radeon_device
*rdev
, struct evergreen_mc_save
*save
)
2472 u32 crtc_enabled
, tmp
, frame_count
, blackout
;
2475 if (!ASIC_IS_NODCE(rdev
)) {
2476 save
->vga_render_control
= RREG32(VGA_RENDER_CONTROL
);
2477 save
->vga_hdp_control
= RREG32(VGA_HDP_CONTROL
);
2479 /* disable VGA render */
2480 WREG32(VGA_RENDER_CONTROL
, 0);
2482 /* blank the display controllers */
2483 for (i
= 0; i
< rdev
->num_crtc
; i
++) {
2484 crtc_enabled
= RREG32(EVERGREEN_CRTC_CONTROL
+ crtc_offsets
[i
]) & EVERGREEN_CRTC_MASTER_EN
;
2486 save
->crtc_enabled
[i
] = true;
2487 if (ASIC_IS_DCE6(rdev
)) {
2488 tmp
= RREG32(EVERGREEN_CRTC_BLANK_CONTROL
+ crtc_offsets
[i
]);
2489 if (!(tmp
& EVERGREEN_CRTC_BLANK_DATA_EN
)) {
2490 radeon_wait_for_vblank(rdev
, i
);
2491 WREG32(EVERGREEN_CRTC_UPDATE_LOCK
+ crtc_offsets
[i
], 1);
2492 tmp
|= EVERGREEN_CRTC_BLANK_DATA_EN
;
2493 WREG32(EVERGREEN_CRTC_BLANK_CONTROL
+ crtc_offsets
[i
], tmp
);
2496 tmp
= RREG32(EVERGREEN_CRTC_CONTROL
+ crtc_offsets
[i
]);
2497 if (!(tmp
& EVERGREEN_CRTC_DISP_READ_REQUEST_DISABLE
)) {
2498 radeon_wait_for_vblank(rdev
, i
);
2499 WREG32(EVERGREEN_CRTC_UPDATE_LOCK
+ crtc_offsets
[i
], 1);
2500 tmp
|= EVERGREEN_CRTC_DISP_READ_REQUEST_DISABLE
;
2501 WREG32(EVERGREEN_CRTC_CONTROL
+ crtc_offsets
[i
], tmp
);
2502 WREG32(EVERGREEN_CRTC_UPDATE_LOCK
+ crtc_offsets
[i
], 0);
2505 /* wait for the next frame */
2506 frame_count
= radeon_get_vblank_counter(rdev
, i
);
2507 for (j
= 0; j
< rdev
->usec_timeout
; j
++) {
2508 if (radeon_get_vblank_counter(rdev
, i
) != frame_count
)
2513 /* XXX this is a hack to avoid strange behavior with EFI on certain systems */
2514 WREG32(EVERGREEN_CRTC_UPDATE_LOCK
+ crtc_offsets
[i
], 1);
2515 tmp
= RREG32(EVERGREEN_CRTC_CONTROL
+ crtc_offsets
[i
]);
2516 tmp
&= ~EVERGREEN_CRTC_MASTER_EN
;
2517 WREG32(EVERGREEN_CRTC_CONTROL
+ crtc_offsets
[i
], tmp
);
2518 WREG32(EVERGREEN_CRTC_UPDATE_LOCK
+ crtc_offsets
[i
], 0);
2519 save
->crtc_enabled
[i
] = false;
2522 save
->crtc_enabled
[i
] = false;
2526 radeon_mc_wait_for_idle(rdev
);
2528 blackout
= RREG32(MC_SHARED_BLACKOUT_CNTL
);
2529 if ((blackout
& BLACKOUT_MODE_MASK
) != 1) {
2530 /* Block CPU access */
2531 WREG32(BIF_FB_EN
, 0);
2532 /* blackout the MC */
2533 blackout
&= ~BLACKOUT_MODE_MASK
;
2534 WREG32(MC_SHARED_BLACKOUT_CNTL
, blackout
| 1);
2536 /* wait for the MC to settle */
2539 /* lock double buffered regs */
2540 for (i
= 0; i
< rdev
->num_crtc
; i
++) {
2541 if (save
->crtc_enabled
[i
]) {
2542 tmp
= RREG32(EVERGREEN_GRPH_UPDATE
+ crtc_offsets
[i
]);
2543 if (!(tmp
& EVERGREEN_GRPH_UPDATE_LOCK
)) {
2544 tmp
|= EVERGREEN_GRPH_UPDATE_LOCK
;
2545 WREG32(EVERGREEN_GRPH_UPDATE
+ crtc_offsets
[i
], tmp
);
2547 tmp
= RREG32(EVERGREEN_MASTER_UPDATE_LOCK
+ crtc_offsets
[i
]);
2550 WREG32(EVERGREEN_MASTER_UPDATE_LOCK
+ crtc_offsets
[i
], tmp
);
2556 void evergreen_mc_resume(struct radeon_device
*rdev
, struct evergreen_mc_save
*save
)
2558 u32 tmp
, frame_count
;
2561 /* update crtc base addresses */
2562 for (i
= 0; i
< rdev
->num_crtc
; i
++) {
2563 WREG32(EVERGREEN_GRPH_PRIMARY_SURFACE_ADDRESS_HIGH
+ crtc_offsets
[i
],
2564 upper_32_bits(rdev
->mc
.vram_start
));
2565 WREG32(EVERGREEN_GRPH_SECONDARY_SURFACE_ADDRESS_HIGH
+ crtc_offsets
[i
],
2566 upper_32_bits(rdev
->mc
.vram_start
));
2567 WREG32(EVERGREEN_GRPH_PRIMARY_SURFACE_ADDRESS
+ crtc_offsets
[i
],
2568 (u32
)rdev
->mc
.vram_start
);
2569 WREG32(EVERGREEN_GRPH_SECONDARY_SURFACE_ADDRESS
+ crtc_offsets
[i
],
2570 (u32
)rdev
->mc
.vram_start
);
2573 if (!ASIC_IS_NODCE(rdev
)) {
2574 WREG32(EVERGREEN_VGA_MEMORY_BASE_ADDRESS_HIGH
, upper_32_bits(rdev
->mc
.vram_start
));
2575 WREG32(EVERGREEN_VGA_MEMORY_BASE_ADDRESS
, (u32
)rdev
->mc
.vram_start
);
2578 /* unlock regs and wait for update */
2579 for (i
= 0; i
< rdev
->num_crtc
; i
++) {
2580 if (save
->crtc_enabled
[i
]) {
2581 tmp
= RREG32(EVERGREEN_MASTER_UPDATE_MODE
+ crtc_offsets
[i
]);
2582 if ((tmp
& 0x3) != 0) {
2584 WREG32(EVERGREEN_MASTER_UPDATE_MODE
+ crtc_offsets
[i
], tmp
);
2586 tmp
= RREG32(EVERGREEN_GRPH_UPDATE
+ crtc_offsets
[i
]);
2587 if (tmp
& EVERGREEN_GRPH_UPDATE_LOCK
) {
2588 tmp
&= ~EVERGREEN_GRPH_UPDATE_LOCK
;
2589 WREG32(EVERGREEN_GRPH_UPDATE
+ crtc_offsets
[i
], tmp
);
2591 tmp
= RREG32(EVERGREEN_MASTER_UPDATE_LOCK
+ crtc_offsets
[i
]);
2594 WREG32(EVERGREEN_MASTER_UPDATE_LOCK
+ crtc_offsets
[i
], tmp
);
2596 for (j
= 0; j
< rdev
->usec_timeout
; j
++) {
2597 tmp
= RREG32(EVERGREEN_GRPH_UPDATE
+ crtc_offsets
[i
]);
2598 if ((tmp
& EVERGREEN_GRPH_SURFACE_UPDATE_PENDING
) == 0)
2605 /* unblackout the MC */
2606 tmp
= RREG32(MC_SHARED_BLACKOUT_CNTL
);
2607 tmp
&= ~BLACKOUT_MODE_MASK
;
2608 WREG32(MC_SHARED_BLACKOUT_CNTL
, tmp
);
2609 /* allow CPU access */
2610 WREG32(BIF_FB_EN
, FB_READ_EN
| FB_WRITE_EN
);
2612 for (i
= 0; i
< rdev
->num_crtc
; i
++) {
2613 if (save
->crtc_enabled
[i
]) {
2614 if (ASIC_IS_DCE6(rdev
)) {
2615 tmp
= RREG32(EVERGREEN_CRTC_BLANK_CONTROL
+ crtc_offsets
[i
]);
2616 tmp
|= EVERGREEN_CRTC_BLANK_DATA_EN
;
2617 WREG32(EVERGREEN_CRTC_UPDATE_LOCK
+ crtc_offsets
[i
], 1);
2618 WREG32(EVERGREEN_CRTC_BLANK_CONTROL
+ crtc_offsets
[i
], tmp
);
2619 WREG32(EVERGREEN_CRTC_UPDATE_LOCK
+ crtc_offsets
[i
], 0);
2621 tmp
= RREG32(EVERGREEN_CRTC_CONTROL
+ crtc_offsets
[i
]);
2622 tmp
&= ~EVERGREEN_CRTC_DISP_READ_REQUEST_DISABLE
;
2623 WREG32(EVERGREEN_CRTC_UPDATE_LOCK
+ crtc_offsets
[i
], 1);
2624 WREG32(EVERGREEN_CRTC_CONTROL
+ crtc_offsets
[i
], tmp
);
2625 WREG32(EVERGREEN_CRTC_UPDATE_LOCK
+ crtc_offsets
[i
], 0);
2627 /* wait for the next frame */
2628 frame_count
= radeon_get_vblank_counter(rdev
, i
);
2629 for (j
= 0; j
< rdev
->usec_timeout
; j
++) {
2630 if (radeon_get_vblank_counter(rdev
, i
) != frame_count
)
2636 if (!ASIC_IS_NODCE(rdev
)) {
2637 /* Unlock vga access */
2638 WREG32(VGA_HDP_CONTROL
, save
->vga_hdp_control
);
2640 WREG32(VGA_RENDER_CONTROL
, save
->vga_render_control
);
2644 void evergreen_mc_program(struct radeon_device
*rdev
)
2646 struct evergreen_mc_save save
;
2650 /* Initialize HDP */
2651 for (i
= 0, j
= 0; i
< 32; i
++, j
+= 0x18) {
2652 WREG32((0x2c14 + j
), 0x00000000);
2653 WREG32((0x2c18 + j
), 0x00000000);
2654 WREG32((0x2c1c + j
), 0x00000000);
2655 WREG32((0x2c20 + j
), 0x00000000);
2656 WREG32((0x2c24 + j
), 0x00000000);
2658 WREG32(HDP_REG_COHERENCY_FLUSH_CNTL
, 0);
2660 evergreen_mc_stop(rdev
, &save
);
2661 if (evergreen_mc_wait_for_idle(rdev
)) {
2662 dev_warn(rdev
->dev
, "Wait for MC idle timedout !\n");
2664 /* Lockout access through VGA aperture*/
2665 WREG32(VGA_HDP_CONTROL
, VGA_MEMORY_DISABLE
);
2666 /* Update configuration */
2667 if (rdev
->flags
& RADEON_IS_AGP
) {
2668 if (rdev
->mc
.vram_start
< rdev
->mc
.gtt_start
) {
2669 /* VRAM before AGP */
2670 WREG32(MC_VM_SYSTEM_APERTURE_LOW_ADDR
,
2671 rdev
->mc
.vram_start
>> 12);
2672 WREG32(MC_VM_SYSTEM_APERTURE_HIGH_ADDR
,
2673 rdev
->mc
.gtt_end
>> 12);
2675 /* VRAM after AGP */
2676 WREG32(MC_VM_SYSTEM_APERTURE_LOW_ADDR
,
2677 rdev
->mc
.gtt_start
>> 12);
2678 WREG32(MC_VM_SYSTEM_APERTURE_HIGH_ADDR
,
2679 rdev
->mc
.vram_end
>> 12);
2682 WREG32(MC_VM_SYSTEM_APERTURE_LOW_ADDR
,
2683 rdev
->mc
.vram_start
>> 12);
2684 WREG32(MC_VM_SYSTEM_APERTURE_HIGH_ADDR
,
2685 rdev
->mc
.vram_end
>> 12);
2687 WREG32(MC_VM_SYSTEM_APERTURE_DEFAULT_ADDR
, rdev
->vram_scratch
.gpu_addr
>> 12);
2688 /* llano/ontario only */
2689 if ((rdev
->family
== CHIP_PALM
) ||
2690 (rdev
->family
== CHIP_SUMO
) ||
2691 (rdev
->family
== CHIP_SUMO2
)) {
2692 tmp
= RREG32(MC_FUS_VM_FB_OFFSET
) & 0x000FFFFF;
2693 tmp
|= ((rdev
->mc
.vram_end
>> 20) & 0xF) << 24;
2694 tmp
|= ((rdev
->mc
.vram_start
>> 20) & 0xF) << 20;
2695 WREG32(MC_FUS_VM_FB_OFFSET
, tmp
);
2697 tmp
= ((rdev
->mc
.vram_end
>> 24) & 0xFFFF) << 16;
2698 tmp
|= ((rdev
->mc
.vram_start
>> 24) & 0xFFFF);
2699 WREG32(MC_VM_FB_LOCATION
, tmp
);
2700 WREG32(HDP_NONSURFACE_BASE
, (rdev
->mc
.vram_start
>> 8));
2701 WREG32(HDP_NONSURFACE_INFO
, (2 << 7) | (1 << 30));
2702 WREG32(HDP_NONSURFACE_SIZE
, 0x3FFFFFFF);
2703 if (rdev
->flags
& RADEON_IS_AGP
) {
2704 WREG32(MC_VM_AGP_TOP
, rdev
->mc
.gtt_end
>> 16);
2705 WREG32(MC_VM_AGP_BOT
, rdev
->mc
.gtt_start
>> 16);
2706 WREG32(MC_VM_AGP_BASE
, rdev
->mc
.agp_base
>> 22);
2708 WREG32(MC_VM_AGP_BASE
, 0);
2709 WREG32(MC_VM_AGP_TOP
, 0x0FFFFFFF);
2710 WREG32(MC_VM_AGP_BOT
, 0x0FFFFFFF);
2712 if (evergreen_mc_wait_for_idle(rdev
)) {
2713 dev_warn(rdev
->dev
, "Wait for MC idle timedout !\n");
2715 evergreen_mc_resume(rdev
, &save
);
2716 /* we need to own VRAM, so turn off the VGA renderer here
2717 * to stop it overwriting our objects */
2718 rv515_vga_render_disable(rdev
);
2724 void evergreen_ring_ib_execute(struct radeon_device
*rdev
, struct radeon_ib
*ib
)
2726 struct radeon_ring
*ring
= &rdev
->ring
[ib
->ring
];
2729 /* set to DX10/11 mode */
2730 radeon_ring_write(ring
, PACKET3(PACKET3_MODE_CONTROL
, 0));
2731 radeon_ring_write(ring
, 1);
2733 if (ring
->rptr_save_reg
) {
2734 next_rptr
= ring
->wptr
+ 3 + 4;
2735 radeon_ring_write(ring
, PACKET3(PACKET3_SET_CONFIG_REG
, 1));
2736 radeon_ring_write(ring
, ((ring
->rptr_save_reg
-
2737 PACKET3_SET_CONFIG_REG_START
) >> 2));
2738 radeon_ring_write(ring
, next_rptr
);
2739 } else if (rdev
->wb
.enabled
) {
2740 next_rptr
= ring
->wptr
+ 5 + 4;
2741 radeon_ring_write(ring
, PACKET3(PACKET3_MEM_WRITE
, 3));
2742 radeon_ring_write(ring
, ring
->next_rptr_gpu_addr
& 0xfffffffc);
2743 radeon_ring_write(ring
, (upper_32_bits(ring
->next_rptr_gpu_addr
) & 0xff) | (1 << 18));
2744 radeon_ring_write(ring
, next_rptr
);
2745 radeon_ring_write(ring
, 0);
2748 radeon_ring_write(ring
, PACKET3(PACKET3_INDIRECT_BUFFER
, 2));
2749 radeon_ring_write(ring
,
2753 (ib
->gpu_addr
& 0xFFFFFFFC));
2754 radeon_ring_write(ring
, upper_32_bits(ib
->gpu_addr
) & 0xFF);
2755 radeon_ring_write(ring
, ib
->length_dw
);
2759 static int evergreen_cp_load_microcode(struct radeon_device
*rdev
)
2761 const __be32
*fw_data
;
2764 if (!rdev
->me_fw
|| !rdev
->pfp_fw
)
2772 RB_NO_UPDATE
| RB_BLKSZ(15) | RB_BUFSZ(3));
2774 fw_data
= (const __be32
*)rdev
->pfp_fw
->data
;
2775 WREG32(CP_PFP_UCODE_ADDR
, 0);
2776 for (i
= 0; i
< EVERGREEN_PFP_UCODE_SIZE
; i
++)
2777 WREG32(CP_PFP_UCODE_DATA
, be32_to_cpup(fw_data
++));
2778 WREG32(CP_PFP_UCODE_ADDR
, 0);
2780 fw_data
= (const __be32
*)rdev
->me_fw
->data
;
2781 WREG32(CP_ME_RAM_WADDR
, 0);
2782 for (i
= 0; i
< EVERGREEN_PM4_UCODE_SIZE
; i
++)
2783 WREG32(CP_ME_RAM_DATA
, be32_to_cpup(fw_data
++));
2785 WREG32(CP_PFP_UCODE_ADDR
, 0);
2786 WREG32(CP_ME_RAM_WADDR
, 0);
2787 WREG32(CP_ME_RAM_RADDR
, 0);
2791 static int evergreen_cp_start(struct radeon_device
*rdev
)
2793 struct radeon_ring
*ring
= &rdev
->ring
[RADEON_RING_TYPE_GFX_INDEX
];
2797 r
= radeon_ring_lock(rdev
, ring
, 7);
2799 DRM_ERROR("radeon: cp failed to lock ring (%d).\n", r
);
2802 radeon_ring_write(ring
, PACKET3(PACKET3_ME_INITIALIZE
, 5));
2803 radeon_ring_write(ring
, 0x1);
2804 radeon_ring_write(ring
, 0x0);
2805 radeon_ring_write(ring
, rdev
->config
.evergreen
.max_hw_contexts
- 1);
2806 radeon_ring_write(ring
, PACKET3_ME_INITIALIZE_DEVICE_ID(1));
2807 radeon_ring_write(ring
, 0);
2808 radeon_ring_write(ring
, 0);
2809 radeon_ring_unlock_commit(rdev
, ring
);
2812 WREG32(CP_ME_CNTL
, cp_me
);
2814 r
= radeon_ring_lock(rdev
, ring
, evergreen_default_size
+ 19);
2816 DRM_ERROR("radeon: cp failed to lock ring (%d).\n", r
);
2820 /* setup clear context state */
2821 radeon_ring_write(ring
, PACKET3(PACKET3_PREAMBLE_CNTL
, 0));
2822 radeon_ring_write(ring
, PACKET3_PREAMBLE_BEGIN_CLEAR_STATE
);
2824 for (i
= 0; i
< evergreen_default_size
; i
++)
2825 radeon_ring_write(ring
, evergreen_default_state
[i
]);
2827 radeon_ring_write(ring
, PACKET3(PACKET3_PREAMBLE_CNTL
, 0));
2828 radeon_ring_write(ring
, PACKET3_PREAMBLE_END_CLEAR_STATE
);
2830 /* set clear context state */
2831 radeon_ring_write(ring
, PACKET3(PACKET3_CLEAR_STATE
, 0));
2832 radeon_ring_write(ring
, 0);
2834 /* SQ_VTX_BASE_VTX_LOC */
2835 radeon_ring_write(ring
, 0xc0026f00);
2836 radeon_ring_write(ring
, 0x00000000);
2837 radeon_ring_write(ring
, 0x00000000);
2838 radeon_ring_write(ring
, 0x00000000);
2841 radeon_ring_write(ring
, 0xc0036f00);
2842 radeon_ring_write(ring
, 0x00000bc4);
2843 radeon_ring_write(ring
, 0xffffffff);
2844 radeon_ring_write(ring
, 0xffffffff);
2845 radeon_ring_write(ring
, 0xffffffff);
2847 radeon_ring_write(ring
, 0xc0026900);
2848 radeon_ring_write(ring
, 0x00000316);
2849 radeon_ring_write(ring
, 0x0000000e); /* VGT_VERTEX_REUSE_BLOCK_CNTL */
2850 radeon_ring_write(ring
, 0x00000010); /* */
2852 radeon_ring_unlock_commit(rdev
, ring
);
2857 static int evergreen_cp_resume(struct radeon_device
*rdev
)
2859 struct radeon_ring
*ring
= &rdev
->ring
[RADEON_RING_TYPE_GFX_INDEX
];
2864 /* Reset cp; if cp is reset, then PA, SH, VGT also need to be reset */
2865 WREG32(GRBM_SOFT_RESET
, (SOFT_RESET_CP
|
2871 RREG32(GRBM_SOFT_RESET
);
2873 WREG32(GRBM_SOFT_RESET
, 0);
2874 RREG32(GRBM_SOFT_RESET
);
2876 /* Set ring buffer size */
2877 rb_bufsz
= drm_order(ring
->ring_size
/ 8);
2878 tmp
= (drm_order(RADEON_GPU_PAGE_SIZE
/8) << 8) | rb_bufsz
;
2880 tmp
|= BUF_SWAP_32BIT
;
2882 WREG32(CP_RB_CNTL
, tmp
);
2883 WREG32(CP_SEM_WAIT_TIMER
, 0x0);
2884 WREG32(CP_SEM_INCOMPLETE_TIMER_CNTL
, 0x0);
2886 /* Set the write pointer delay */
2887 WREG32(CP_RB_WPTR_DELAY
, 0);
2889 /* Initialize the ring buffer's read and write pointers */
2890 WREG32(CP_RB_CNTL
, tmp
| RB_RPTR_WR_ENA
);
2891 WREG32(CP_RB_RPTR_WR
, 0);
2893 WREG32(CP_RB_WPTR
, ring
->wptr
);
2895 /* set the wb address whether it's enabled or not */
2896 WREG32(CP_RB_RPTR_ADDR
,
2897 ((rdev
->wb
.gpu_addr
+ RADEON_WB_CP_RPTR_OFFSET
) & 0xFFFFFFFC));
2898 WREG32(CP_RB_RPTR_ADDR_HI
, upper_32_bits(rdev
->wb
.gpu_addr
+ RADEON_WB_CP_RPTR_OFFSET
) & 0xFF);
2899 WREG32(SCRATCH_ADDR
, ((rdev
->wb
.gpu_addr
+ RADEON_WB_SCRATCH_OFFSET
) >> 8) & 0xFFFFFFFF);
2901 if (rdev
->wb
.enabled
)
2902 WREG32(SCRATCH_UMSK
, 0xff);
2904 tmp
|= RB_NO_UPDATE
;
2905 WREG32(SCRATCH_UMSK
, 0);
2909 WREG32(CP_RB_CNTL
, tmp
);
2911 WREG32(CP_RB_BASE
, ring
->gpu_addr
>> 8);
2912 WREG32(CP_DEBUG
, (1 << 27) | (1 << 28));
2914 ring
->rptr
= RREG32(CP_RB_RPTR
);
2916 evergreen_cp_start(rdev
);
2918 r
= radeon_ring_test(rdev
, RADEON_RING_TYPE_GFX_INDEX
, ring
);
2920 ring
->ready
= false;
2929 static void evergreen_gpu_init(struct radeon_device
*rdev
)
2932 u32 mc_shared_chmap
, mc_arb_ramcfg
;
2936 u32 sq_lds_resource_mgmt
;
2937 u32 sq_gpr_resource_mgmt_1
;
2938 u32 sq_gpr_resource_mgmt_2
;
2939 u32 sq_gpr_resource_mgmt_3
;
2940 u32 sq_thread_resource_mgmt
;
2941 u32 sq_thread_resource_mgmt_2
;
2942 u32 sq_stack_resource_mgmt_1
;
2943 u32 sq_stack_resource_mgmt_2
;
2944 u32 sq_stack_resource_mgmt_3
;
2945 u32 vgt_cache_invalidation
;
2946 u32 hdp_host_path_cntl
, tmp
;
2947 u32 disabled_rb_mask
;
2948 int i
, j
, num_shader_engines
, ps_thread_count
;
2950 switch (rdev
->family
) {
2953 rdev
->config
.evergreen
.num_ses
= 2;
2954 rdev
->config
.evergreen
.max_pipes
= 4;
2955 rdev
->config
.evergreen
.max_tile_pipes
= 8;
2956 rdev
->config
.evergreen
.max_simds
= 10;
2957 rdev
->config
.evergreen
.max_backends
= 4 * rdev
->config
.evergreen
.num_ses
;
2958 rdev
->config
.evergreen
.max_gprs
= 256;
2959 rdev
->config
.evergreen
.max_threads
= 248;
2960 rdev
->config
.evergreen
.max_gs_threads
= 32;
2961 rdev
->config
.evergreen
.max_stack_entries
= 512;
2962 rdev
->config
.evergreen
.sx_num_of_sets
= 4;
2963 rdev
->config
.evergreen
.sx_max_export_size
= 256;
2964 rdev
->config
.evergreen
.sx_max_export_pos_size
= 64;
2965 rdev
->config
.evergreen
.sx_max_export_smx_size
= 192;
2966 rdev
->config
.evergreen
.max_hw_contexts
= 8;
2967 rdev
->config
.evergreen
.sq_num_cf_insts
= 2;
2969 rdev
->config
.evergreen
.sc_prim_fifo_size
= 0x100;
2970 rdev
->config
.evergreen
.sc_hiz_tile_fifo_size
= 0x30;
2971 rdev
->config
.evergreen
.sc_earlyz_tile_fifo_size
= 0x130;
2972 gb_addr_config
= CYPRESS_GB_ADDR_CONFIG_GOLDEN
;
2975 rdev
->config
.evergreen
.num_ses
= 1;
2976 rdev
->config
.evergreen
.max_pipes
= 4;
2977 rdev
->config
.evergreen
.max_tile_pipes
= 4;
2978 rdev
->config
.evergreen
.max_simds
= 10;
2979 rdev
->config
.evergreen
.max_backends
= 4 * rdev
->config
.evergreen
.num_ses
;
2980 rdev
->config
.evergreen
.max_gprs
= 256;
2981 rdev
->config
.evergreen
.max_threads
= 248;
2982 rdev
->config
.evergreen
.max_gs_threads
= 32;
2983 rdev
->config
.evergreen
.max_stack_entries
= 512;
2984 rdev
->config
.evergreen
.sx_num_of_sets
= 4;
2985 rdev
->config
.evergreen
.sx_max_export_size
= 256;
2986 rdev
->config
.evergreen
.sx_max_export_pos_size
= 64;
2987 rdev
->config
.evergreen
.sx_max_export_smx_size
= 192;
2988 rdev
->config
.evergreen
.max_hw_contexts
= 8;
2989 rdev
->config
.evergreen
.sq_num_cf_insts
= 2;
2991 rdev
->config
.evergreen
.sc_prim_fifo_size
= 0x100;
2992 rdev
->config
.evergreen
.sc_hiz_tile_fifo_size
= 0x30;
2993 rdev
->config
.evergreen
.sc_earlyz_tile_fifo_size
= 0x130;
2994 gb_addr_config
= JUNIPER_GB_ADDR_CONFIG_GOLDEN
;
2997 rdev
->config
.evergreen
.num_ses
= 1;
2998 rdev
->config
.evergreen
.max_pipes
= 4;
2999 rdev
->config
.evergreen
.max_tile_pipes
= 4;
3000 rdev
->config
.evergreen
.max_simds
= 5;
3001 rdev
->config
.evergreen
.max_backends
= 2 * rdev
->config
.evergreen
.num_ses
;
3002 rdev
->config
.evergreen
.max_gprs
= 256;
3003 rdev
->config
.evergreen
.max_threads
= 248;
3004 rdev
->config
.evergreen
.max_gs_threads
= 32;
3005 rdev
->config
.evergreen
.max_stack_entries
= 256;
3006 rdev
->config
.evergreen
.sx_num_of_sets
= 4;
3007 rdev
->config
.evergreen
.sx_max_export_size
= 256;
3008 rdev
->config
.evergreen
.sx_max_export_pos_size
= 64;
3009 rdev
->config
.evergreen
.sx_max_export_smx_size
= 192;
3010 rdev
->config
.evergreen
.max_hw_contexts
= 8;
3011 rdev
->config
.evergreen
.sq_num_cf_insts
= 2;
3013 rdev
->config
.evergreen
.sc_prim_fifo_size
= 0x100;
3014 rdev
->config
.evergreen
.sc_hiz_tile_fifo_size
= 0x30;
3015 rdev
->config
.evergreen
.sc_earlyz_tile_fifo_size
= 0x130;
3016 gb_addr_config
= REDWOOD_GB_ADDR_CONFIG_GOLDEN
;
3020 rdev
->config
.evergreen
.num_ses
= 1;
3021 rdev
->config
.evergreen
.max_pipes
= 2;
3022 rdev
->config
.evergreen
.max_tile_pipes
= 2;
3023 rdev
->config
.evergreen
.max_simds
= 2;
3024 rdev
->config
.evergreen
.max_backends
= 1 * rdev
->config
.evergreen
.num_ses
;
3025 rdev
->config
.evergreen
.max_gprs
= 256;
3026 rdev
->config
.evergreen
.max_threads
= 192;
3027 rdev
->config
.evergreen
.max_gs_threads
= 16;
3028 rdev
->config
.evergreen
.max_stack_entries
= 256;
3029 rdev
->config
.evergreen
.sx_num_of_sets
= 4;
3030 rdev
->config
.evergreen
.sx_max_export_size
= 128;
3031 rdev
->config
.evergreen
.sx_max_export_pos_size
= 32;
3032 rdev
->config
.evergreen
.sx_max_export_smx_size
= 96;
3033 rdev
->config
.evergreen
.max_hw_contexts
= 4;
3034 rdev
->config
.evergreen
.sq_num_cf_insts
= 1;
3036 rdev
->config
.evergreen
.sc_prim_fifo_size
= 0x40;
3037 rdev
->config
.evergreen
.sc_hiz_tile_fifo_size
= 0x30;
3038 rdev
->config
.evergreen
.sc_earlyz_tile_fifo_size
= 0x130;
3039 gb_addr_config
= CEDAR_GB_ADDR_CONFIG_GOLDEN
;
3042 rdev
->config
.evergreen
.num_ses
= 1;
3043 rdev
->config
.evergreen
.max_pipes
= 2;
3044 rdev
->config
.evergreen
.max_tile_pipes
= 2;
3045 rdev
->config
.evergreen
.max_simds
= 2;
3046 rdev
->config
.evergreen
.max_backends
= 1 * rdev
->config
.evergreen
.num_ses
;
3047 rdev
->config
.evergreen
.max_gprs
= 256;
3048 rdev
->config
.evergreen
.max_threads
= 192;
3049 rdev
->config
.evergreen
.max_gs_threads
= 16;
3050 rdev
->config
.evergreen
.max_stack_entries
= 256;
3051 rdev
->config
.evergreen
.sx_num_of_sets
= 4;
3052 rdev
->config
.evergreen
.sx_max_export_size
= 128;
3053 rdev
->config
.evergreen
.sx_max_export_pos_size
= 32;
3054 rdev
->config
.evergreen
.sx_max_export_smx_size
= 96;
3055 rdev
->config
.evergreen
.max_hw_contexts
= 4;
3056 rdev
->config
.evergreen
.sq_num_cf_insts
= 1;
3058 rdev
->config
.evergreen
.sc_prim_fifo_size
= 0x40;
3059 rdev
->config
.evergreen
.sc_hiz_tile_fifo_size
= 0x30;
3060 rdev
->config
.evergreen
.sc_earlyz_tile_fifo_size
= 0x130;
3061 gb_addr_config
= CEDAR_GB_ADDR_CONFIG_GOLDEN
;
3064 rdev
->config
.evergreen
.num_ses
= 1;
3065 rdev
->config
.evergreen
.max_pipes
= 4;
3066 rdev
->config
.evergreen
.max_tile_pipes
= 4;
3067 if (rdev
->pdev
->device
== 0x9648)
3068 rdev
->config
.evergreen
.max_simds
= 3;
3069 else if ((rdev
->pdev
->device
== 0x9647) ||
3070 (rdev
->pdev
->device
== 0x964a))
3071 rdev
->config
.evergreen
.max_simds
= 4;
3073 rdev
->config
.evergreen
.max_simds
= 5;
3074 rdev
->config
.evergreen
.max_backends
= 2 * rdev
->config
.evergreen
.num_ses
;
3075 rdev
->config
.evergreen
.max_gprs
= 256;
3076 rdev
->config
.evergreen
.max_threads
= 248;
3077 rdev
->config
.evergreen
.max_gs_threads
= 32;
3078 rdev
->config
.evergreen
.max_stack_entries
= 256;
3079 rdev
->config
.evergreen
.sx_num_of_sets
= 4;
3080 rdev
->config
.evergreen
.sx_max_export_size
= 256;
3081 rdev
->config
.evergreen
.sx_max_export_pos_size
= 64;
3082 rdev
->config
.evergreen
.sx_max_export_smx_size
= 192;
3083 rdev
->config
.evergreen
.max_hw_contexts
= 8;
3084 rdev
->config
.evergreen
.sq_num_cf_insts
= 2;
3086 rdev
->config
.evergreen
.sc_prim_fifo_size
= 0x40;
3087 rdev
->config
.evergreen
.sc_hiz_tile_fifo_size
= 0x30;
3088 rdev
->config
.evergreen
.sc_earlyz_tile_fifo_size
= 0x130;
3089 gb_addr_config
= SUMO_GB_ADDR_CONFIG_GOLDEN
;
3092 rdev
->config
.evergreen
.num_ses
= 1;
3093 rdev
->config
.evergreen
.max_pipes
= 4;
3094 rdev
->config
.evergreen
.max_tile_pipes
= 4;
3095 rdev
->config
.evergreen
.max_simds
= 2;
3096 rdev
->config
.evergreen
.max_backends
= 1 * rdev
->config
.evergreen
.num_ses
;
3097 rdev
->config
.evergreen
.max_gprs
= 256;
3098 rdev
->config
.evergreen
.max_threads
= 248;
3099 rdev
->config
.evergreen
.max_gs_threads
= 32;
3100 rdev
->config
.evergreen
.max_stack_entries
= 512;
3101 rdev
->config
.evergreen
.sx_num_of_sets
= 4;
3102 rdev
->config
.evergreen
.sx_max_export_size
= 256;
3103 rdev
->config
.evergreen
.sx_max_export_pos_size
= 64;
3104 rdev
->config
.evergreen
.sx_max_export_smx_size
= 192;
3105 rdev
->config
.evergreen
.max_hw_contexts
= 8;
3106 rdev
->config
.evergreen
.sq_num_cf_insts
= 2;
3108 rdev
->config
.evergreen
.sc_prim_fifo_size
= 0x40;
3109 rdev
->config
.evergreen
.sc_hiz_tile_fifo_size
= 0x30;
3110 rdev
->config
.evergreen
.sc_earlyz_tile_fifo_size
= 0x130;
3111 gb_addr_config
= SUMO2_GB_ADDR_CONFIG_GOLDEN
;
3114 rdev
->config
.evergreen
.num_ses
= 2;
3115 rdev
->config
.evergreen
.max_pipes
= 4;
3116 rdev
->config
.evergreen
.max_tile_pipes
= 8;
3117 rdev
->config
.evergreen
.max_simds
= 7;
3118 rdev
->config
.evergreen
.max_backends
= 4 * rdev
->config
.evergreen
.num_ses
;
3119 rdev
->config
.evergreen
.max_gprs
= 256;
3120 rdev
->config
.evergreen
.max_threads
= 248;
3121 rdev
->config
.evergreen
.max_gs_threads
= 32;
3122 rdev
->config
.evergreen
.max_stack_entries
= 512;
3123 rdev
->config
.evergreen
.sx_num_of_sets
= 4;
3124 rdev
->config
.evergreen
.sx_max_export_size
= 256;
3125 rdev
->config
.evergreen
.sx_max_export_pos_size
= 64;
3126 rdev
->config
.evergreen
.sx_max_export_smx_size
= 192;
3127 rdev
->config
.evergreen
.max_hw_contexts
= 8;
3128 rdev
->config
.evergreen
.sq_num_cf_insts
= 2;
3130 rdev
->config
.evergreen
.sc_prim_fifo_size
= 0x100;
3131 rdev
->config
.evergreen
.sc_hiz_tile_fifo_size
= 0x30;
3132 rdev
->config
.evergreen
.sc_earlyz_tile_fifo_size
= 0x130;
3133 gb_addr_config
= BARTS_GB_ADDR_CONFIG_GOLDEN
;
3136 rdev
->config
.evergreen
.num_ses
= 1;
3137 rdev
->config
.evergreen
.max_pipes
= 4;
3138 rdev
->config
.evergreen
.max_tile_pipes
= 4;
3139 rdev
->config
.evergreen
.max_simds
= 6;
3140 rdev
->config
.evergreen
.max_backends
= 2 * rdev
->config
.evergreen
.num_ses
;
3141 rdev
->config
.evergreen
.max_gprs
= 256;
3142 rdev
->config
.evergreen
.max_threads
= 248;
3143 rdev
->config
.evergreen
.max_gs_threads
= 32;
3144 rdev
->config
.evergreen
.max_stack_entries
= 256;
3145 rdev
->config
.evergreen
.sx_num_of_sets
= 4;
3146 rdev
->config
.evergreen
.sx_max_export_size
= 256;
3147 rdev
->config
.evergreen
.sx_max_export_pos_size
= 64;
3148 rdev
->config
.evergreen
.sx_max_export_smx_size
= 192;
3149 rdev
->config
.evergreen
.max_hw_contexts
= 8;
3150 rdev
->config
.evergreen
.sq_num_cf_insts
= 2;
3152 rdev
->config
.evergreen
.sc_prim_fifo_size
= 0x100;
3153 rdev
->config
.evergreen
.sc_hiz_tile_fifo_size
= 0x30;
3154 rdev
->config
.evergreen
.sc_earlyz_tile_fifo_size
= 0x130;
3155 gb_addr_config
= TURKS_GB_ADDR_CONFIG_GOLDEN
;
3158 rdev
->config
.evergreen
.num_ses
= 1;
3159 rdev
->config
.evergreen
.max_pipes
= 2;
3160 rdev
->config
.evergreen
.max_tile_pipes
= 2;
3161 rdev
->config
.evergreen
.max_simds
= 2;
3162 rdev
->config
.evergreen
.max_backends
= 1 * rdev
->config
.evergreen
.num_ses
;
3163 rdev
->config
.evergreen
.max_gprs
= 256;
3164 rdev
->config
.evergreen
.max_threads
= 192;
3165 rdev
->config
.evergreen
.max_gs_threads
= 16;
3166 rdev
->config
.evergreen
.max_stack_entries
= 256;
3167 rdev
->config
.evergreen
.sx_num_of_sets
= 4;
3168 rdev
->config
.evergreen
.sx_max_export_size
= 128;
3169 rdev
->config
.evergreen
.sx_max_export_pos_size
= 32;
3170 rdev
->config
.evergreen
.sx_max_export_smx_size
= 96;
3171 rdev
->config
.evergreen
.max_hw_contexts
= 4;
3172 rdev
->config
.evergreen
.sq_num_cf_insts
= 1;
3174 rdev
->config
.evergreen
.sc_prim_fifo_size
= 0x40;
3175 rdev
->config
.evergreen
.sc_hiz_tile_fifo_size
= 0x30;
3176 rdev
->config
.evergreen
.sc_earlyz_tile_fifo_size
= 0x130;
3177 gb_addr_config
= CAICOS_GB_ADDR_CONFIG_GOLDEN
;
3181 /* Initialize HDP */
3182 for (i
= 0, j
= 0; i
< 32; i
++, j
+= 0x18) {
3183 WREG32((0x2c14 + j
), 0x00000000);
3184 WREG32((0x2c18 + j
), 0x00000000);
3185 WREG32((0x2c1c + j
), 0x00000000);
3186 WREG32((0x2c20 + j
), 0x00000000);
3187 WREG32((0x2c24 + j
), 0x00000000);
3190 WREG32(GRBM_CNTL
, GRBM_READ_TIMEOUT(0xff));
3192 evergreen_fix_pci_max_read_req_size(rdev
);
3194 mc_shared_chmap
= RREG32(MC_SHARED_CHMAP
);
3195 if ((rdev
->family
== CHIP_PALM
) ||
3196 (rdev
->family
== CHIP_SUMO
) ||
3197 (rdev
->family
== CHIP_SUMO2
))
3198 mc_arb_ramcfg
= RREG32(FUS_MC_ARB_RAMCFG
);
3200 mc_arb_ramcfg
= RREG32(MC_ARB_RAMCFG
);
3202 /* setup tiling info dword. gb_addr_config is not adequate since it does
3203 * not have bank info, so create a custom tiling dword.
3204 * bits 3:0 num_pipes
3205 * bits 7:4 num_banks
3206 * bits 11:8 group_size
3207 * bits 15:12 row_size
3209 rdev
->config
.evergreen
.tile_config
= 0;
3210 switch (rdev
->config
.evergreen
.max_tile_pipes
) {
3213 rdev
->config
.evergreen
.tile_config
|= (0 << 0);
3216 rdev
->config
.evergreen
.tile_config
|= (1 << 0);
3219 rdev
->config
.evergreen
.tile_config
|= (2 << 0);
3222 rdev
->config
.evergreen
.tile_config
|= (3 << 0);
3225 /* num banks is 8 on all fusion asics. 0 = 4, 1 = 8, 2 = 16 */
3226 if (rdev
->flags
& RADEON_IS_IGP
)
3227 rdev
->config
.evergreen
.tile_config
|= 1 << 4;
3229 switch ((mc_arb_ramcfg
& NOOFBANK_MASK
) >> NOOFBANK_SHIFT
) {
3230 case 0: /* four banks */
3231 rdev
->config
.evergreen
.tile_config
|= 0 << 4;
3233 case 1: /* eight banks */
3234 rdev
->config
.evergreen
.tile_config
|= 1 << 4;
3236 case 2: /* sixteen banks */
3238 rdev
->config
.evergreen
.tile_config
|= 2 << 4;
3242 rdev
->config
.evergreen
.tile_config
|= 0 << 8;
3243 rdev
->config
.evergreen
.tile_config
|=
3244 ((gb_addr_config
& 0x30000000) >> 28) << 12;
3246 num_shader_engines
= (gb_addr_config
& NUM_SHADER_ENGINES(3) >> 12) + 1;
3248 if ((rdev
->family
>= CHIP_CEDAR
) && (rdev
->family
<= CHIP_HEMLOCK
)) {
3252 efuse_straps_4
= RREG32_RCU(0x204);
3253 efuse_straps_3
= RREG32_RCU(0x203);
3254 tmp
= (((efuse_straps_4
& 0xf) << 4) |
3255 ((efuse_straps_3
& 0xf0000000) >> 28));
3258 for (i
= (rdev
->config
.evergreen
.num_ses
- 1); i
>= 0; i
--) {
3259 u32 rb_disable_bitmap
;
3261 WREG32(GRBM_GFX_INDEX
, INSTANCE_BROADCAST_WRITES
| SE_INDEX(i
));
3262 WREG32(RLC_GFX_INDEX
, INSTANCE_BROADCAST_WRITES
| SE_INDEX(i
));
3263 rb_disable_bitmap
= (RREG32(CC_RB_BACKEND_DISABLE
) & 0x00ff0000) >> 16;
3265 tmp
|= rb_disable_bitmap
;
3268 /* enabled rb are just the one not disabled :) */
3269 disabled_rb_mask
= tmp
;
3271 for (i
= 0; i
< rdev
->config
.evergreen
.max_backends
; i
++)
3273 /* if all the backends are disabled, fix it up here */
3274 if ((disabled_rb_mask
& tmp
) == tmp
) {
3275 for (i
= 0; i
< rdev
->config
.evergreen
.max_backends
; i
++)
3276 disabled_rb_mask
&= ~(1 << i
);
3279 WREG32(GRBM_GFX_INDEX
, INSTANCE_BROADCAST_WRITES
| SE_BROADCAST_WRITES
);
3280 WREG32(RLC_GFX_INDEX
, INSTANCE_BROADCAST_WRITES
| SE_BROADCAST_WRITES
);
3282 WREG32(GB_ADDR_CONFIG
, gb_addr_config
);
3283 WREG32(DMIF_ADDR_CONFIG
, gb_addr_config
);
3284 WREG32(HDP_ADDR_CONFIG
, gb_addr_config
);
3285 WREG32(DMA_TILING_CONFIG
, gb_addr_config
);
3286 WREG32(UVD_UDEC_ADDR_CONFIG
, gb_addr_config
);
3287 WREG32(UVD_UDEC_DB_ADDR_CONFIG
, gb_addr_config
);
3288 WREG32(UVD_UDEC_DBW_ADDR_CONFIG
, gb_addr_config
);
3290 if ((rdev
->config
.evergreen
.max_backends
== 1) &&
3291 (rdev
->flags
& RADEON_IS_IGP
)) {
3292 if ((disabled_rb_mask
& 3) == 1) {
3293 /* RB0 disabled, RB1 enabled */
3296 /* RB1 disabled, RB0 enabled */
3300 tmp
= gb_addr_config
& NUM_PIPES_MASK
;
3301 tmp
= r6xx_remap_render_backend(rdev
, tmp
, rdev
->config
.evergreen
.max_backends
,
3302 EVERGREEN_MAX_BACKENDS
, disabled_rb_mask
);
3304 WREG32(GB_BACKEND_MAP
, tmp
);
3306 WREG32(CGTS_SYS_TCC_DISABLE
, 0);
3307 WREG32(CGTS_TCC_DISABLE
, 0);
3308 WREG32(CGTS_USER_SYS_TCC_DISABLE
, 0);
3309 WREG32(CGTS_USER_TCC_DISABLE
, 0);
3311 /* set HW defaults for 3D engine */
3312 WREG32(CP_QUEUE_THRESHOLDS
, (ROQ_IB1_START(0x16) |
3313 ROQ_IB2_START(0x2b)));
3315 WREG32(CP_MEQ_THRESHOLDS
, STQ_SPLIT(0x30));
3317 WREG32(TA_CNTL_AUX
, (DISABLE_CUBE_ANISO
|
3322 sx_debug_1
= RREG32(SX_DEBUG_1
);
3323 sx_debug_1
|= ENABLE_NEW_SMX_ADDRESS
;
3324 WREG32(SX_DEBUG_1
, sx_debug_1
);
3327 smx_dc_ctl0
= RREG32(SMX_DC_CTL0
);
3328 smx_dc_ctl0
&= ~NUMBER_OF_SETS(0x1ff);
3329 smx_dc_ctl0
|= NUMBER_OF_SETS(rdev
->config
.evergreen
.sx_num_of_sets
);
3330 WREG32(SMX_DC_CTL0
, smx_dc_ctl0
);
3332 if (rdev
->family
<= CHIP_SUMO2
)
3333 WREG32(SMX_SAR_CTL0
, 0x00010000);
3335 WREG32(SX_EXPORT_BUFFER_SIZES
, (COLOR_BUFFER_SIZE((rdev
->config
.evergreen
.sx_max_export_size
/ 4) - 1) |
3336 POSITION_BUFFER_SIZE((rdev
->config
.evergreen
.sx_max_export_pos_size
/ 4) - 1) |
3337 SMX_BUFFER_SIZE((rdev
->config
.evergreen
.sx_max_export_smx_size
/ 4) - 1)));
3339 WREG32(PA_SC_FIFO_SIZE
, (SC_PRIM_FIFO_SIZE(rdev
->config
.evergreen
.sc_prim_fifo_size
) |
3340 SC_HIZ_TILE_FIFO_SIZE(rdev
->config
.evergreen
.sc_hiz_tile_fifo_size
) |
3341 SC_EARLYZ_TILE_FIFO_SIZE(rdev
->config
.evergreen
.sc_earlyz_tile_fifo_size
)));
3343 WREG32(VGT_NUM_INSTANCES
, 1);
3344 WREG32(SPI_CONFIG_CNTL
, 0);
3345 WREG32(SPI_CONFIG_CNTL_1
, VTX_DONE_DELAY(4));
3346 WREG32(CP_PERFMON_CNTL
, 0);
3348 WREG32(SQ_MS_FIFO_SIZES
, (CACHE_FIFO_SIZE(16 * rdev
->config
.evergreen
.sq_num_cf_insts
) |
3349 FETCH_FIFO_HIWATER(0x4) |
3350 DONE_FIFO_HIWATER(0xe0) |
3351 ALU_UPDATE_FIFO_HIWATER(0x8)));
3353 sq_config
= RREG32(SQ_CONFIG
);
3354 sq_config
&= ~(PS_PRIO(3) |
3358 sq_config
|= (VC_ENABLE
|
3365 switch (rdev
->family
) {
3371 /* no vertex cache */
3372 sq_config
&= ~VC_ENABLE
;
3378 sq_lds_resource_mgmt
= RREG32(SQ_LDS_RESOURCE_MGMT
);
3380 sq_gpr_resource_mgmt_1
= NUM_PS_GPRS((rdev
->config
.evergreen
.max_gprs
- (4 * 2))* 12 / 32);
3381 sq_gpr_resource_mgmt_1
|= NUM_VS_GPRS((rdev
->config
.evergreen
.max_gprs
- (4 * 2)) * 6 / 32);
3382 sq_gpr_resource_mgmt_1
|= NUM_CLAUSE_TEMP_GPRS(4);
3383 sq_gpr_resource_mgmt_2
= NUM_GS_GPRS((rdev
->config
.evergreen
.max_gprs
- (4 * 2)) * 4 / 32);
3384 sq_gpr_resource_mgmt_2
|= NUM_ES_GPRS((rdev
->config
.evergreen
.max_gprs
- (4 * 2)) * 4 / 32);
3385 sq_gpr_resource_mgmt_3
= NUM_HS_GPRS((rdev
->config
.evergreen
.max_gprs
- (4 * 2)) * 3 / 32);
3386 sq_gpr_resource_mgmt_3
|= NUM_LS_GPRS((rdev
->config
.evergreen
.max_gprs
- (4 * 2)) * 3 / 32);
3388 switch (rdev
->family
) {
3393 ps_thread_count
= 96;
3396 ps_thread_count
= 128;
3400 sq_thread_resource_mgmt
= NUM_PS_THREADS(ps_thread_count
);
3401 sq_thread_resource_mgmt
|= NUM_VS_THREADS((((rdev
->config
.evergreen
.max_threads
- ps_thread_count
) / 6) / 8) * 8);
3402 sq_thread_resource_mgmt
|= NUM_GS_THREADS((((rdev
->config
.evergreen
.max_threads
- ps_thread_count
) / 6) / 8) * 8);
3403 sq_thread_resource_mgmt
|= NUM_ES_THREADS((((rdev
->config
.evergreen
.max_threads
- ps_thread_count
) / 6) / 8) * 8);
3404 sq_thread_resource_mgmt_2
= NUM_HS_THREADS((((rdev
->config
.evergreen
.max_threads
- ps_thread_count
) / 6) / 8) * 8);
3405 sq_thread_resource_mgmt_2
|= NUM_LS_THREADS((((rdev
->config
.evergreen
.max_threads
- ps_thread_count
) / 6) / 8) * 8);
3407 sq_stack_resource_mgmt_1
= NUM_PS_STACK_ENTRIES((rdev
->config
.evergreen
.max_stack_entries
* 1) / 6);
3408 sq_stack_resource_mgmt_1
|= NUM_VS_STACK_ENTRIES((rdev
->config
.evergreen
.max_stack_entries
* 1) / 6);
3409 sq_stack_resource_mgmt_2
= NUM_GS_STACK_ENTRIES((rdev
->config
.evergreen
.max_stack_entries
* 1) / 6);
3410 sq_stack_resource_mgmt_2
|= NUM_ES_STACK_ENTRIES((rdev
->config
.evergreen
.max_stack_entries
* 1) / 6);
3411 sq_stack_resource_mgmt_3
= NUM_HS_STACK_ENTRIES((rdev
->config
.evergreen
.max_stack_entries
* 1) / 6);
3412 sq_stack_resource_mgmt_3
|= NUM_LS_STACK_ENTRIES((rdev
->config
.evergreen
.max_stack_entries
* 1) / 6);
3414 WREG32(SQ_CONFIG
, sq_config
);
3415 WREG32(SQ_GPR_RESOURCE_MGMT_1
, sq_gpr_resource_mgmt_1
);
3416 WREG32(SQ_GPR_RESOURCE_MGMT_2
, sq_gpr_resource_mgmt_2
);
3417 WREG32(SQ_GPR_RESOURCE_MGMT_3
, sq_gpr_resource_mgmt_3
);
3418 WREG32(SQ_THREAD_RESOURCE_MGMT
, sq_thread_resource_mgmt
);
3419 WREG32(SQ_THREAD_RESOURCE_MGMT_2
, sq_thread_resource_mgmt_2
);
3420 WREG32(SQ_STACK_RESOURCE_MGMT_1
, sq_stack_resource_mgmt_1
);
3421 WREG32(SQ_STACK_RESOURCE_MGMT_2
, sq_stack_resource_mgmt_2
);
3422 WREG32(SQ_STACK_RESOURCE_MGMT_3
, sq_stack_resource_mgmt_3
);
3423 WREG32(SQ_DYN_GPR_CNTL_PS_FLUSH_REQ
, 0);
3424 WREG32(SQ_LDS_RESOURCE_MGMT
, sq_lds_resource_mgmt
);
3426 WREG32(PA_SC_FORCE_EOV_MAX_CNTS
, (FORCE_EOV_MAX_CLK_CNT(4095) |
3427 FORCE_EOV_MAX_REZ_CNT(255)));
3429 switch (rdev
->family
) {
3435 vgt_cache_invalidation
= CACHE_INVALIDATION(TC_ONLY
);
3438 vgt_cache_invalidation
= CACHE_INVALIDATION(VC_AND_TC
);
3441 vgt_cache_invalidation
|= AUTO_INVLD_EN(ES_AND_GS_AUTO
);
3442 WREG32(VGT_CACHE_INVALIDATION
, vgt_cache_invalidation
);
3444 WREG32(VGT_GS_VERTEX_REUSE
, 16);
3445 WREG32(PA_SU_LINE_STIPPLE_VALUE
, 0);
3446 WREG32(PA_SC_LINE_STIPPLE_STATE
, 0);
3448 WREG32(VGT_VERTEX_REUSE_BLOCK_CNTL
, 14);
3449 WREG32(VGT_OUT_DEALLOC_CNTL
, 16);
3451 WREG32(CB_PERF_CTR0_SEL_0
, 0);
3452 WREG32(CB_PERF_CTR0_SEL_1
, 0);
3453 WREG32(CB_PERF_CTR1_SEL_0
, 0);
3454 WREG32(CB_PERF_CTR1_SEL_1
, 0);
3455 WREG32(CB_PERF_CTR2_SEL_0
, 0);
3456 WREG32(CB_PERF_CTR2_SEL_1
, 0);
3457 WREG32(CB_PERF_CTR3_SEL_0
, 0);
3458 WREG32(CB_PERF_CTR3_SEL_1
, 0);
3460 /* clear render buffer base addresses */
3461 WREG32(CB_COLOR0_BASE
, 0);
3462 WREG32(CB_COLOR1_BASE
, 0);
3463 WREG32(CB_COLOR2_BASE
, 0);
3464 WREG32(CB_COLOR3_BASE
, 0);
3465 WREG32(CB_COLOR4_BASE
, 0);
3466 WREG32(CB_COLOR5_BASE
, 0);
3467 WREG32(CB_COLOR6_BASE
, 0);
3468 WREG32(CB_COLOR7_BASE
, 0);
3469 WREG32(CB_COLOR8_BASE
, 0);
3470 WREG32(CB_COLOR9_BASE
, 0);
3471 WREG32(CB_COLOR10_BASE
, 0);
3472 WREG32(CB_COLOR11_BASE
, 0);
3474 /* set the shader const cache sizes to 0 */
3475 for (i
= SQ_ALU_CONST_BUFFER_SIZE_PS_0
; i
< 0x28200; i
+= 4)
3477 for (i
= SQ_ALU_CONST_BUFFER_SIZE_HS_0
; i
< 0x29000; i
+= 4)
3480 tmp
= RREG32(HDP_MISC_CNTL
);
3481 tmp
|= HDP_FLUSH_INVALIDATE_CACHE
;
3482 WREG32(HDP_MISC_CNTL
, tmp
);
3484 hdp_host_path_cntl
= RREG32(HDP_HOST_PATH_CNTL
);
3485 WREG32(HDP_HOST_PATH_CNTL
, hdp_host_path_cntl
);
3487 WREG32(PA_CL_ENHANCE
, CLIP_VTX_REORDER_ENA
| NUM_CLIP_SEQ(3));
3493 int evergreen_mc_init(struct radeon_device
*rdev
)
3496 int chansize
, numchan
;
3498 /* Get VRAM informations */
3499 rdev
->mc
.vram_is_ddr
= true;
3500 if ((rdev
->family
== CHIP_PALM
) ||
3501 (rdev
->family
== CHIP_SUMO
) ||
3502 (rdev
->family
== CHIP_SUMO2
))
3503 tmp
= RREG32(FUS_MC_ARB_RAMCFG
);
3505 tmp
= RREG32(MC_ARB_RAMCFG
);
3506 if (tmp
& CHANSIZE_OVERRIDE
) {
3508 } else if (tmp
& CHANSIZE_MASK
) {
3513 tmp
= RREG32(MC_SHARED_CHMAP
);
3514 switch ((tmp
& NOOFCHAN_MASK
) >> NOOFCHAN_SHIFT
) {
3529 rdev
->mc
.vram_width
= numchan
* chansize
;
3530 /* Could aper size report 0 ? */
3531 rdev
->mc
.aper_base
= pci_resource_start(rdev
->pdev
, 0);
3532 rdev
->mc
.aper_size
= pci_resource_len(rdev
->pdev
, 0);
3533 /* Setup GPU memory space */
3534 if ((rdev
->family
== CHIP_PALM
) ||
3535 (rdev
->family
== CHIP_SUMO
) ||
3536 (rdev
->family
== CHIP_SUMO2
)) {
3537 /* size in bytes on fusion */
3538 rdev
->mc
.mc_vram_size
= RREG32(CONFIG_MEMSIZE
);
3539 rdev
->mc
.real_vram_size
= RREG32(CONFIG_MEMSIZE
);
3541 /* size in MB on evergreen/cayman/tn */
3542 rdev
->mc
.mc_vram_size
= RREG32(CONFIG_MEMSIZE
) * 1024ULL * 1024ULL;
3543 rdev
->mc
.real_vram_size
= RREG32(CONFIG_MEMSIZE
) * 1024ULL * 1024ULL;
3545 rdev
->mc
.visible_vram_size
= rdev
->mc
.aper_size
;
3546 r700_vram_gtt_location(rdev
, &rdev
->mc
);
3547 radeon_update_bandwidth_info(rdev
);
3552 void evergreen_print_gpu_status_regs(struct radeon_device
*rdev
)
3554 dev_info(rdev
->dev
, " GRBM_STATUS = 0x%08X\n",
3555 RREG32(GRBM_STATUS
));
3556 dev_info(rdev
->dev
, " GRBM_STATUS_SE0 = 0x%08X\n",
3557 RREG32(GRBM_STATUS_SE0
));
3558 dev_info(rdev
->dev
, " GRBM_STATUS_SE1 = 0x%08X\n",
3559 RREG32(GRBM_STATUS_SE1
));
3560 dev_info(rdev
->dev
, " SRBM_STATUS = 0x%08X\n",
3561 RREG32(SRBM_STATUS
));
3562 dev_info(rdev
->dev
, " SRBM_STATUS2 = 0x%08X\n",
3563 RREG32(SRBM_STATUS2
));
3564 dev_info(rdev
->dev
, " R_008674_CP_STALLED_STAT1 = 0x%08X\n",
3565 RREG32(CP_STALLED_STAT1
));
3566 dev_info(rdev
->dev
, " R_008678_CP_STALLED_STAT2 = 0x%08X\n",
3567 RREG32(CP_STALLED_STAT2
));
3568 dev_info(rdev
->dev
, " R_00867C_CP_BUSY_STAT = 0x%08X\n",
3569 RREG32(CP_BUSY_STAT
));
3570 dev_info(rdev
->dev
, " R_008680_CP_STAT = 0x%08X\n",
3572 dev_info(rdev
->dev
, " R_00D034_DMA_STATUS_REG = 0x%08X\n",
3573 RREG32(DMA_STATUS_REG
));
3574 if (rdev
->family
>= CHIP_CAYMAN
) {
3575 dev_info(rdev
->dev
, " R_00D834_DMA_STATUS_REG = 0x%08X\n",
3576 RREG32(DMA_STATUS_REG
+ 0x800));
3580 bool evergreen_is_display_hung(struct radeon_device
*rdev
)
3586 for (i
= 0; i
< rdev
->num_crtc
; i
++) {
3587 if (RREG32(EVERGREEN_CRTC_CONTROL
+ crtc_offsets
[i
]) & EVERGREEN_CRTC_MASTER_EN
) {
3588 crtc_status
[i
] = RREG32(EVERGREEN_CRTC_STATUS_HV_COUNT
+ crtc_offsets
[i
]);
3589 crtc_hung
|= (1 << i
);
3593 for (j
= 0; j
< 10; j
++) {
3594 for (i
= 0; i
< rdev
->num_crtc
; i
++) {
3595 if (crtc_hung
& (1 << i
)) {
3596 tmp
= RREG32(EVERGREEN_CRTC_STATUS_HV_COUNT
+ crtc_offsets
[i
]);
3597 if (tmp
!= crtc_status
[i
])
3598 crtc_hung
&= ~(1 << i
);
3609 static u32
evergreen_gpu_check_soft_reset(struct radeon_device
*rdev
)
3615 tmp
= RREG32(GRBM_STATUS
);
3616 if (tmp
& (PA_BUSY
| SC_BUSY
|
3618 TA_BUSY
| VGT_BUSY
|
3620 SPI_BUSY
| VGT_BUSY_NO_DMA
))
3621 reset_mask
|= RADEON_RESET_GFX
;
3623 if (tmp
& (CF_RQ_PENDING
| PF_RQ_PENDING
|
3624 CP_BUSY
| CP_COHERENCY_BUSY
))
3625 reset_mask
|= RADEON_RESET_CP
;
3627 if (tmp
& GRBM_EE_BUSY
)
3628 reset_mask
|= RADEON_RESET_GRBM
| RADEON_RESET_GFX
| RADEON_RESET_CP
;
3630 /* DMA_STATUS_REG */
3631 tmp
= RREG32(DMA_STATUS_REG
);
3632 if (!(tmp
& DMA_IDLE
))
3633 reset_mask
|= RADEON_RESET_DMA
;
3636 tmp
= RREG32(SRBM_STATUS2
);
3638 reset_mask
|= RADEON_RESET_DMA
;
3641 tmp
= RREG32(SRBM_STATUS
);
3642 if (tmp
& (RLC_RQ_PENDING
| RLC_BUSY
))
3643 reset_mask
|= RADEON_RESET_RLC
;
3646 reset_mask
|= RADEON_RESET_IH
;
3649 reset_mask
|= RADEON_RESET_SEM
;
3651 if (tmp
& GRBM_RQ_PENDING
)
3652 reset_mask
|= RADEON_RESET_GRBM
;
3655 reset_mask
|= RADEON_RESET_VMC
;
3657 if (tmp
& (MCB_BUSY
| MCB_NON_DISPLAY_BUSY
|
3658 MCC_BUSY
| MCD_BUSY
))
3659 reset_mask
|= RADEON_RESET_MC
;
3661 if (evergreen_is_display_hung(rdev
))
3662 reset_mask
|= RADEON_RESET_DISPLAY
;
3665 tmp
= RREG32(VM_L2_STATUS
);
3667 reset_mask
|= RADEON_RESET_VMC
;
3669 /* Skip MC reset as it's mostly likely not hung, just busy */
3670 if (reset_mask
& RADEON_RESET_MC
) {
3671 DRM_DEBUG("MC busy: 0x%08X, clearing.\n", reset_mask
);
3672 reset_mask
&= ~RADEON_RESET_MC
;
3678 static void evergreen_gpu_soft_reset(struct radeon_device
*rdev
, u32 reset_mask
)
3680 struct evergreen_mc_save save
;
3681 u32 grbm_soft_reset
= 0, srbm_soft_reset
= 0;
3684 if (reset_mask
== 0)
3687 dev_info(rdev
->dev
, "GPU softreset: 0x%08X\n", reset_mask
);
3689 evergreen_print_gpu_status_regs(rdev
);
3691 /* Disable CP parsing/prefetching */
3692 WREG32(CP_ME_CNTL
, CP_ME_HALT
| CP_PFP_HALT
);
3694 if (reset_mask
& RADEON_RESET_DMA
) {
3696 tmp
= RREG32(DMA_RB_CNTL
);
3697 tmp
&= ~DMA_RB_ENABLE
;
3698 WREG32(DMA_RB_CNTL
, tmp
);
3703 evergreen_mc_stop(rdev
, &save
);
3704 if (evergreen_mc_wait_for_idle(rdev
)) {
3705 dev_warn(rdev
->dev
, "Wait for MC idle timedout !\n");
3708 if (reset_mask
& (RADEON_RESET_GFX
| RADEON_RESET_COMPUTE
)) {
3709 grbm_soft_reset
|= SOFT_RESET_DB
|
3722 if (reset_mask
& RADEON_RESET_CP
) {
3723 grbm_soft_reset
|= SOFT_RESET_CP
|
3726 srbm_soft_reset
|= SOFT_RESET_GRBM
;
3729 if (reset_mask
& RADEON_RESET_DMA
)
3730 srbm_soft_reset
|= SOFT_RESET_DMA
;
3732 if (reset_mask
& RADEON_RESET_DISPLAY
)
3733 srbm_soft_reset
|= SOFT_RESET_DC
;
3735 if (reset_mask
& RADEON_RESET_RLC
)
3736 srbm_soft_reset
|= SOFT_RESET_RLC
;
3738 if (reset_mask
& RADEON_RESET_SEM
)
3739 srbm_soft_reset
|= SOFT_RESET_SEM
;
3741 if (reset_mask
& RADEON_RESET_IH
)
3742 srbm_soft_reset
|= SOFT_RESET_IH
;
3744 if (reset_mask
& RADEON_RESET_GRBM
)
3745 srbm_soft_reset
|= SOFT_RESET_GRBM
;
3747 if (reset_mask
& RADEON_RESET_VMC
)
3748 srbm_soft_reset
|= SOFT_RESET_VMC
;
3750 if (!(rdev
->flags
& RADEON_IS_IGP
)) {
3751 if (reset_mask
& RADEON_RESET_MC
)
3752 srbm_soft_reset
|= SOFT_RESET_MC
;
3755 if (grbm_soft_reset
) {
3756 tmp
= RREG32(GRBM_SOFT_RESET
);
3757 tmp
|= grbm_soft_reset
;
3758 dev_info(rdev
->dev
, "GRBM_SOFT_RESET=0x%08X\n", tmp
);
3759 WREG32(GRBM_SOFT_RESET
, tmp
);
3760 tmp
= RREG32(GRBM_SOFT_RESET
);
3764 tmp
&= ~grbm_soft_reset
;
3765 WREG32(GRBM_SOFT_RESET
, tmp
);
3766 tmp
= RREG32(GRBM_SOFT_RESET
);
3769 if (srbm_soft_reset
) {
3770 tmp
= RREG32(SRBM_SOFT_RESET
);
3771 tmp
|= srbm_soft_reset
;
3772 dev_info(rdev
->dev
, "SRBM_SOFT_RESET=0x%08X\n", tmp
);
3773 WREG32(SRBM_SOFT_RESET
, tmp
);
3774 tmp
= RREG32(SRBM_SOFT_RESET
);
3778 tmp
&= ~srbm_soft_reset
;
3779 WREG32(SRBM_SOFT_RESET
, tmp
);
3780 tmp
= RREG32(SRBM_SOFT_RESET
);
3783 /* Wait a little for things to settle down */
3786 evergreen_mc_resume(rdev
, &save
);
3789 evergreen_print_gpu_status_regs(rdev
);
3792 int evergreen_asic_reset(struct radeon_device
*rdev
)
3796 reset_mask
= evergreen_gpu_check_soft_reset(rdev
);
3799 r600_set_bios_scratch_engine_hung(rdev
, true);
3801 evergreen_gpu_soft_reset(rdev
, reset_mask
);
3803 reset_mask
= evergreen_gpu_check_soft_reset(rdev
);
3806 r600_set_bios_scratch_engine_hung(rdev
, false);
3812 * evergreen_gfx_is_lockup - Check if the GFX engine is locked up
3814 * @rdev: radeon_device pointer
3815 * @ring: radeon_ring structure holding ring information
3817 * Check if the GFX engine is locked up.
3818 * Returns true if the engine appears to be locked up, false if not.
3820 bool evergreen_gfx_is_lockup(struct radeon_device
*rdev
, struct radeon_ring
*ring
)
3822 u32 reset_mask
= evergreen_gpu_check_soft_reset(rdev
);
3824 if (!(reset_mask
& (RADEON_RESET_GFX
|
3825 RADEON_RESET_COMPUTE
|
3826 RADEON_RESET_CP
))) {
3827 radeon_ring_lockup_update(ring
);
3830 /* force CP activities */
3831 radeon_ring_force_activity(rdev
, ring
);
3832 return radeon_ring_test_lockup(rdev
, ring
);
3836 * evergreen_dma_is_lockup - Check if the DMA engine is locked up
3838 * @rdev: radeon_device pointer
3839 * @ring: radeon_ring structure holding ring information
3841 * Check if the async DMA engine is locked up.
3842 * Returns true if the engine appears to be locked up, false if not.
3844 bool evergreen_dma_is_lockup(struct radeon_device
*rdev
, struct radeon_ring
*ring
)
3846 u32 reset_mask
= evergreen_gpu_check_soft_reset(rdev
);
3848 if (!(reset_mask
& RADEON_RESET_DMA
)) {
3849 radeon_ring_lockup_update(ring
);
3852 /* force ring activities */
3853 radeon_ring_force_activity(rdev
, ring
);
3854 return radeon_ring_test_lockup(rdev
, ring
);
3860 #define RLC_SAVE_RESTORE_LIST_END_MARKER 0x00000000
3861 #define RLC_CLEAR_STATE_END_MARKER 0x00000001
3863 void sumo_rlc_fini(struct radeon_device
*rdev
)
3867 /* save restore block */
3868 if (rdev
->rlc
.save_restore_obj
) {
3869 r
= radeon_bo_reserve(rdev
->rlc
.save_restore_obj
, false);
3870 if (unlikely(r
!= 0))
3871 dev_warn(rdev
->dev
, "(%d) reserve RLC sr bo failed\n", r
);
3872 radeon_bo_unpin(rdev
->rlc
.save_restore_obj
);
3873 radeon_bo_unreserve(rdev
->rlc
.save_restore_obj
);
3875 radeon_bo_unref(&rdev
->rlc
.save_restore_obj
);
3876 rdev
->rlc
.save_restore_obj
= NULL
;
3879 /* clear state block */
3880 if (rdev
->rlc
.clear_state_obj
) {
3881 r
= radeon_bo_reserve(rdev
->rlc
.clear_state_obj
, false);
3882 if (unlikely(r
!= 0))
3883 dev_warn(rdev
->dev
, "(%d) reserve RLC c bo failed\n", r
);
3884 radeon_bo_unpin(rdev
->rlc
.clear_state_obj
);
3885 radeon_bo_unreserve(rdev
->rlc
.clear_state_obj
);
3887 radeon_bo_unref(&rdev
->rlc
.clear_state_obj
);
3888 rdev
->rlc
.clear_state_obj
= NULL
;
3892 int sumo_rlc_init(struct radeon_device
*rdev
)
3895 volatile u32
*dst_ptr
;
3896 u32 dws
, data
, i
, j
, k
, reg_num
;
3897 u32 reg_list_num
, reg_list_hdr_blk_index
, reg_list_blk_index
;
3898 u64 reg_list_mc_addr
;
3899 struct cs_section_def
*cs_data
;
3902 src_ptr
= rdev
->rlc
.reg_list
;
3903 dws
= rdev
->rlc
.reg_list_size
;
3904 cs_data
= rdev
->rlc
.cs_data
;
3906 /* save restore block */
3907 if (rdev
->rlc
.save_restore_obj
== NULL
) {
3908 r
= radeon_bo_create(rdev
, dws
* 4, PAGE_SIZE
, true,
3909 RADEON_GEM_DOMAIN_VRAM
, NULL
, &rdev
->rlc
.save_restore_obj
);
3911 dev_warn(rdev
->dev
, "(%d) create RLC sr bo failed\n", r
);
3916 r
= radeon_bo_reserve(rdev
->rlc
.save_restore_obj
, false);
3917 if (unlikely(r
!= 0)) {
3918 sumo_rlc_fini(rdev
);
3921 r
= radeon_bo_pin(rdev
->rlc
.save_restore_obj
, RADEON_GEM_DOMAIN_VRAM
,
3922 &rdev
->rlc
.save_restore_gpu_addr
);
3924 radeon_bo_unreserve(rdev
->rlc
.save_restore_obj
);
3925 dev_warn(rdev
->dev
, "(%d) pin RLC sr bo failed\n", r
);
3926 sumo_rlc_fini(rdev
);
3929 r
= radeon_bo_kmap(rdev
->rlc
.save_restore_obj
, (void **)&rdev
->rlc
.sr_ptr
);
3931 dev_warn(rdev
->dev
, "(%d) map RLC sr bo failed\n", r
);
3932 sumo_rlc_fini(rdev
);
3935 /* write the sr buffer */
3936 dst_ptr
= rdev
->rlc
.sr_ptr
;
3938 * dw0: (reg2 << 16) | reg1
3939 * dw1: reg1 save space
3940 * dw2: reg2 save space
3942 for (i
= 0; i
< dws
; i
++) {
3943 data
= src_ptr
[i
] >> 2;
3946 data
|= (src_ptr
[i
] >> 2) << 16;
3947 j
= (((i
- 1) * 3) / 2);
3951 dst_ptr
[j
] = RLC_SAVE_RESTORE_LIST_END_MARKER
;
3953 radeon_bo_kunmap(rdev
->rlc
.save_restore_obj
);
3954 radeon_bo_unreserve(rdev
->rlc
.save_restore_obj
);
3956 /* clear state block */
3959 for (i
= 0; cs_data
[i
].section
!= NULL
; i
++) {
3960 for (j
= 0; cs_data
[i
].section
[j
].extent
!= NULL
; j
++) {
3962 dws
+= cs_data
[i
].section
[j
].reg_count
;
3965 reg_list_blk_index
= (3 * reg_list_num
+ 2);
3966 dws
+= reg_list_blk_index
;
3968 if (rdev
->rlc
.clear_state_obj
== NULL
) {
3969 r
= radeon_bo_create(rdev
, dws
* 4, PAGE_SIZE
, true,
3970 RADEON_GEM_DOMAIN_VRAM
, NULL
, &rdev
->rlc
.clear_state_obj
);
3972 dev_warn(rdev
->dev
, "(%d) create RLC c bo failed\n", r
);
3973 sumo_rlc_fini(rdev
);
3977 r
= radeon_bo_reserve(rdev
->rlc
.clear_state_obj
, false);
3978 if (unlikely(r
!= 0)) {
3979 sumo_rlc_fini(rdev
);
3982 r
= radeon_bo_pin(rdev
->rlc
.clear_state_obj
, RADEON_GEM_DOMAIN_VRAM
,
3983 &rdev
->rlc
.clear_state_gpu_addr
);
3986 radeon_bo_unreserve(rdev
->rlc
.clear_state_obj
);
3987 dev_warn(rdev
->dev
, "(%d) pin RLC c bo failed\n", r
);
3988 sumo_rlc_fini(rdev
);
3991 r
= radeon_bo_kmap(rdev
->rlc
.clear_state_obj
, (void **)&rdev
->rlc
.cs_ptr
);
3993 dev_warn(rdev
->dev
, "(%d) map RLC c bo failed\n", r
);
3994 sumo_rlc_fini(rdev
);
3997 /* set up the cs buffer */
3998 dst_ptr
= rdev
->rlc
.cs_ptr
;
3999 reg_list_hdr_blk_index
= 0;
4000 reg_list_mc_addr
= rdev
->rlc
.clear_state_gpu_addr
+ (reg_list_blk_index
* 4);
4001 data
= upper_32_bits(reg_list_mc_addr
);
4002 dst_ptr
[reg_list_hdr_blk_index
] = data
;
4003 reg_list_hdr_blk_index
++;
4004 for (i
= 0; cs_data
[i
].section
!= NULL
; i
++) {
4005 for (j
= 0; cs_data
[i
].section
[j
].extent
!= NULL
; j
++) {
4006 reg_num
= cs_data
[i
].section
[j
].reg_count
;
4007 data
= reg_list_mc_addr
& 0xffffffff;
4008 dst_ptr
[reg_list_hdr_blk_index
] = data
;
4009 reg_list_hdr_blk_index
++;
4011 data
= (cs_data
[i
].section
[j
].reg_index
* 4) & 0xffffffff;
4012 dst_ptr
[reg_list_hdr_blk_index
] = data
;
4013 reg_list_hdr_blk_index
++;
4015 data
= 0x08000000 | (reg_num
* 4);
4016 dst_ptr
[reg_list_hdr_blk_index
] = data
;
4017 reg_list_hdr_blk_index
++;
4019 for (k
= 0; k
< reg_num
; k
++) {
4020 data
= cs_data
[i
].section
[j
].extent
[k
];
4021 dst_ptr
[reg_list_blk_index
+ k
] = data
;
4023 reg_list_mc_addr
+= reg_num
* 4;
4024 reg_list_blk_index
+= reg_num
;
4027 dst_ptr
[reg_list_hdr_blk_index
] = RLC_CLEAR_STATE_END_MARKER
;
4029 radeon_bo_kunmap(rdev
->rlc
.clear_state_obj
);
4030 radeon_bo_unreserve(rdev
->rlc
.clear_state_obj
);
4035 static void evergreen_rlc_start(struct radeon_device
*rdev
)
4037 if (rdev
->flags
& RADEON_IS_IGP
)
4038 WREG32(RLC_CNTL
, RLC_ENABLE
| GFX_POWER_GATING_ENABLE
| GFX_POWER_GATING_SRC
);
4040 WREG32(RLC_CNTL
, RLC_ENABLE
);
4043 int evergreen_rlc_resume(struct radeon_device
*rdev
)
4046 const __be32
*fw_data
;
4051 r600_rlc_stop(rdev
);
4053 WREG32(RLC_HB_CNTL
, 0);
4055 if (rdev
->flags
& RADEON_IS_IGP
) {
4056 WREG32(TN_RLC_SAVE_AND_RESTORE_BASE
, rdev
->rlc
.save_restore_gpu_addr
>> 8);
4057 WREG32(TN_RLC_CLEAR_STATE_RESTORE_BASE
, rdev
->rlc
.clear_state_gpu_addr
>> 8);
4059 WREG32(RLC_HB_BASE
, 0);
4060 WREG32(RLC_HB_RPTR
, 0);
4061 WREG32(RLC_HB_WPTR
, 0);
4063 WREG32(RLC_HB_WPTR_LSB_ADDR
, 0);
4064 WREG32(RLC_HB_WPTR_MSB_ADDR
, 0);
4065 WREG32(RLC_MC_CNTL
, 0);
4066 WREG32(RLC_UCODE_CNTL
, 0);
4068 fw_data
= (const __be32
*)rdev
->rlc_fw
->data
;
4069 if (rdev
->family
>= CHIP_ARUBA
) {
4070 for (i
= 0; i
< ARUBA_RLC_UCODE_SIZE
; i
++) {
4071 WREG32(RLC_UCODE_ADDR
, i
);
4072 WREG32(RLC_UCODE_DATA
, be32_to_cpup(fw_data
++));
4074 } else if (rdev
->family
>= CHIP_CAYMAN
) {
4075 for (i
= 0; i
< CAYMAN_RLC_UCODE_SIZE
; i
++) {
4076 WREG32(RLC_UCODE_ADDR
, i
);
4077 WREG32(RLC_UCODE_DATA
, be32_to_cpup(fw_data
++));
4080 for (i
= 0; i
< EVERGREEN_RLC_UCODE_SIZE
; i
++) {
4081 WREG32(RLC_UCODE_ADDR
, i
);
4082 WREG32(RLC_UCODE_DATA
, be32_to_cpup(fw_data
++));
4085 WREG32(RLC_UCODE_ADDR
, 0);
4087 evergreen_rlc_start(rdev
);
4094 u32
evergreen_get_vblank_counter(struct radeon_device
*rdev
, int crtc
)
4096 if (crtc
>= rdev
->num_crtc
)
4099 return RREG32(CRTC_STATUS_FRAME_COUNT
+ crtc_offsets
[crtc
]);
4102 void evergreen_disable_interrupt_state(struct radeon_device
*rdev
)
4106 if (rdev
->family
>= CHIP_CAYMAN
) {
4107 cayman_cp_int_cntl_setup(rdev
, 0,
4108 CNTX_BUSY_INT_ENABLE
| CNTX_EMPTY_INT_ENABLE
);
4109 cayman_cp_int_cntl_setup(rdev
, 1, 0);
4110 cayman_cp_int_cntl_setup(rdev
, 2, 0);
4111 tmp
= RREG32(CAYMAN_DMA1_CNTL
) & ~TRAP_ENABLE
;
4112 WREG32(CAYMAN_DMA1_CNTL
, tmp
);
4114 WREG32(CP_INT_CNTL
, CNTX_BUSY_INT_ENABLE
| CNTX_EMPTY_INT_ENABLE
);
4115 tmp
= RREG32(DMA_CNTL
) & ~TRAP_ENABLE
;
4116 WREG32(DMA_CNTL
, tmp
);
4117 WREG32(GRBM_INT_CNTL
, 0);
4118 WREG32(INT_MASK
+ EVERGREEN_CRTC0_REGISTER_OFFSET
, 0);
4119 WREG32(INT_MASK
+ EVERGREEN_CRTC1_REGISTER_OFFSET
, 0);
4120 if (rdev
->num_crtc
>= 4) {
4121 WREG32(INT_MASK
+ EVERGREEN_CRTC2_REGISTER_OFFSET
, 0);
4122 WREG32(INT_MASK
+ EVERGREEN_CRTC3_REGISTER_OFFSET
, 0);
4124 if (rdev
->num_crtc
>= 6) {
4125 WREG32(INT_MASK
+ EVERGREEN_CRTC4_REGISTER_OFFSET
, 0);
4126 WREG32(INT_MASK
+ EVERGREEN_CRTC5_REGISTER_OFFSET
, 0);
4129 WREG32(GRPH_INT_CONTROL
+ EVERGREEN_CRTC0_REGISTER_OFFSET
, 0);
4130 WREG32(GRPH_INT_CONTROL
+ EVERGREEN_CRTC1_REGISTER_OFFSET
, 0);
4131 if (rdev
->num_crtc
>= 4) {
4132 WREG32(GRPH_INT_CONTROL
+ EVERGREEN_CRTC2_REGISTER_OFFSET
, 0);
4133 WREG32(GRPH_INT_CONTROL
+ EVERGREEN_CRTC3_REGISTER_OFFSET
, 0);
4135 if (rdev
->num_crtc
>= 6) {
4136 WREG32(GRPH_INT_CONTROL
+ EVERGREEN_CRTC4_REGISTER_OFFSET
, 0);
4137 WREG32(GRPH_INT_CONTROL
+ EVERGREEN_CRTC5_REGISTER_OFFSET
, 0);
4140 /* only one DAC on DCE6 */
4141 if (!ASIC_IS_DCE6(rdev
))
4142 WREG32(DACA_AUTODETECT_INT_CONTROL
, 0);
4143 WREG32(DACB_AUTODETECT_INT_CONTROL
, 0);
4145 tmp
= RREG32(DC_HPD1_INT_CONTROL
) & DC_HPDx_INT_POLARITY
;
4146 WREG32(DC_HPD1_INT_CONTROL
, tmp
);
4147 tmp
= RREG32(DC_HPD2_INT_CONTROL
) & DC_HPDx_INT_POLARITY
;
4148 WREG32(DC_HPD2_INT_CONTROL
, tmp
);
4149 tmp
= RREG32(DC_HPD3_INT_CONTROL
) & DC_HPDx_INT_POLARITY
;
4150 WREG32(DC_HPD3_INT_CONTROL
, tmp
);
4151 tmp
= RREG32(DC_HPD4_INT_CONTROL
) & DC_HPDx_INT_POLARITY
;
4152 WREG32(DC_HPD4_INT_CONTROL
, tmp
);
4153 tmp
= RREG32(DC_HPD5_INT_CONTROL
) & DC_HPDx_INT_POLARITY
;
4154 WREG32(DC_HPD5_INT_CONTROL
, tmp
);
4155 tmp
= RREG32(DC_HPD6_INT_CONTROL
) & DC_HPDx_INT_POLARITY
;
4156 WREG32(DC_HPD6_INT_CONTROL
, tmp
);
4160 int evergreen_irq_set(struct radeon_device
*rdev
)
4162 u32 cp_int_cntl
= CNTX_BUSY_INT_ENABLE
| CNTX_EMPTY_INT_ENABLE
;
4163 u32 cp_int_cntl1
= 0, cp_int_cntl2
= 0;
4164 u32 crtc1
= 0, crtc2
= 0, crtc3
= 0, crtc4
= 0, crtc5
= 0, crtc6
= 0;
4165 u32 hpd1
, hpd2
, hpd3
, hpd4
, hpd5
, hpd6
;
4166 u32 grbm_int_cntl
= 0;
4167 u32 grph1
= 0, grph2
= 0, grph3
= 0, grph4
= 0, grph5
= 0, grph6
= 0;
4168 u32 afmt1
= 0, afmt2
= 0, afmt3
= 0, afmt4
= 0, afmt5
= 0, afmt6
= 0;
4169 u32 dma_cntl
, dma_cntl1
= 0;
4170 u32 thermal_int
= 0;
4172 if (!rdev
->irq
.installed
) {
4173 WARN(1, "Can't enable IRQ/MSI because no handler is installed\n");
4176 /* don't enable anything if the ih is disabled */
4177 if (!rdev
->ih
.enabled
) {
4178 r600_disable_interrupts(rdev
);
4179 /* force the active interrupt state to all disabled */
4180 evergreen_disable_interrupt_state(rdev
);
4184 hpd1
= RREG32(DC_HPD1_INT_CONTROL
) & ~DC_HPDx_INT_EN
;
4185 hpd2
= RREG32(DC_HPD2_INT_CONTROL
) & ~DC_HPDx_INT_EN
;
4186 hpd3
= RREG32(DC_HPD3_INT_CONTROL
) & ~DC_HPDx_INT_EN
;
4187 hpd4
= RREG32(DC_HPD4_INT_CONTROL
) & ~DC_HPDx_INT_EN
;
4188 hpd5
= RREG32(DC_HPD5_INT_CONTROL
) & ~DC_HPDx_INT_EN
;
4189 hpd6
= RREG32(DC_HPD6_INT_CONTROL
) & ~DC_HPDx_INT_EN
;
4190 thermal_int
= RREG32(CG_THERMAL_INT
) &
4191 ~(THERM_INT_MASK_HIGH
| THERM_INT_MASK_LOW
);
4193 afmt1
= RREG32(AFMT_AUDIO_PACKET_CONTROL
+ EVERGREEN_CRTC0_REGISTER_OFFSET
) & ~AFMT_AZ_FORMAT_WTRIG_MASK
;
4194 afmt2
= RREG32(AFMT_AUDIO_PACKET_CONTROL
+ EVERGREEN_CRTC1_REGISTER_OFFSET
) & ~AFMT_AZ_FORMAT_WTRIG_MASK
;
4195 afmt3
= RREG32(AFMT_AUDIO_PACKET_CONTROL
+ EVERGREEN_CRTC2_REGISTER_OFFSET
) & ~AFMT_AZ_FORMAT_WTRIG_MASK
;
4196 afmt4
= RREG32(AFMT_AUDIO_PACKET_CONTROL
+ EVERGREEN_CRTC3_REGISTER_OFFSET
) & ~AFMT_AZ_FORMAT_WTRIG_MASK
;
4197 afmt5
= RREG32(AFMT_AUDIO_PACKET_CONTROL
+ EVERGREEN_CRTC4_REGISTER_OFFSET
) & ~AFMT_AZ_FORMAT_WTRIG_MASK
;
4198 afmt6
= RREG32(AFMT_AUDIO_PACKET_CONTROL
+ EVERGREEN_CRTC5_REGISTER_OFFSET
) & ~AFMT_AZ_FORMAT_WTRIG_MASK
;
4200 dma_cntl
= RREG32(DMA_CNTL
) & ~TRAP_ENABLE
;
4202 if (rdev
->family
>= CHIP_CAYMAN
) {
4203 /* enable CP interrupts on all rings */
4204 if (atomic_read(&rdev
->irq
.ring_int
[RADEON_RING_TYPE_GFX_INDEX
])) {
4205 DRM_DEBUG("evergreen_irq_set: sw int gfx\n");
4206 cp_int_cntl
|= TIME_STAMP_INT_ENABLE
;
4208 if (atomic_read(&rdev
->irq
.ring_int
[CAYMAN_RING_TYPE_CP1_INDEX
])) {
4209 DRM_DEBUG("evergreen_irq_set: sw int cp1\n");
4210 cp_int_cntl1
|= TIME_STAMP_INT_ENABLE
;
4212 if (atomic_read(&rdev
->irq
.ring_int
[CAYMAN_RING_TYPE_CP2_INDEX
])) {
4213 DRM_DEBUG("evergreen_irq_set: sw int cp2\n");
4214 cp_int_cntl2
|= TIME_STAMP_INT_ENABLE
;
4217 if (atomic_read(&rdev
->irq
.ring_int
[RADEON_RING_TYPE_GFX_INDEX
])) {
4218 DRM_DEBUG("evergreen_irq_set: sw int gfx\n");
4219 cp_int_cntl
|= RB_INT_ENABLE
;
4220 cp_int_cntl
|= TIME_STAMP_INT_ENABLE
;
4224 if (atomic_read(&rdev
->irq
.ring_int
[R600_RING_TYPE_DMA_INDEX
])) {
4225 DRM_DEBUG("r600_irq_set: sw int dma\n");
4226 dma_cntl
|= TRAP_ENABLE
;
4229 if (rdev
->family
>= CHIP_CAYMAN
) {
4230 dma_cntl1
= RREG32(CAYMAN_DMA1_CNTL
) & ~TRAP_ENABLE
;
4231 if (atomic_read(&rdev
->irq
.ring_int
[CAYMAN_RING_TYPE_DMA1_INDEX
])) {
4232 DRM_DEBUG("r600_irq_set: sw int dma1\n");
4233 dma_cntl1
|= TRAP_ENABLE
;
4237 if (rdev
->irq
.dpm_thermal
) {
4238 DRM_DEBUG("dpm thermal\n");
4239 thermal_int
|= THERM_INT_MASK_HIGH
| THERM_INT_MASK_LOW
;
4242 if (rdev
->irq
.crtc_vblank_int
[0] ||
4243 atomic_read(&rdev
->irq
.pflip
[0])) {
4244 DRM_DEBUG("evergreen_irq_set: vblank 0\n");
4245 crtc1
|= VBLANK_INT_MASK
;
4247 if (rdev
->irq
.crtc_vblank_int
[1] ||
4248 atomic_read(&rdev
->irq
.pflip
[1])) {
4249 DRM_DEBUG("evergreen_irq_set: vblank 1\n");
4250 crtc2
|= VBLANK_INT_MASK
;
4252 if (rdev
->irq
.crtc_vblank_int
[2] ||
4253 atomic_read(&rdev
->irq
.pflip
[2])) {
4254 DRM_DEBUG("evergreen_irq_set: vblank 2\n");
4255 crtc3
|= VBLANK_INT_MASK
;
4257 if (rdev
->irq
.crtc_vblank_int
[3] ||
4258 atomic_read(&rdev
->irq
.pflip
[3])) {
4259 DRM_DEBUG("evergreen_irq_set: vblank 3\n");
4260 crtc4
|= VBLANK_INT_MASK
;
4262 if (rdev
->irq
.crtc_vblank_int
[4] ||
4263 atomic_read(&rdev
->irq
.pflip
[4])) {
4264 DRM_DEBUG("evergreen_irq_set: vblank 4\n");
4265 crtc5
|= VBLANK_INT_MASK
;
4267 if (rdev
->irq
.crtc_vblank_int
[5] ||
4268 atomic_read(&rdev
->irq
.pflip
[5])) {
4269 DRM_DEBUG("evergreen_irq_set: vblank 5\n");
4270 crtc6
|= VBLANK_INT_MASK
;
4272 if (rdev
->irq
.hpd
[0]) {
4273 DRM_DEBUG("evergreen_irq_set: hpd 1\n");
4274 hpd1
|= DC_HPDx_INT_EN
;
4276 if (rdev
->irq
.hpd
[1]) {
4277 DRM_DEBUG("evergreen_irq_set: hpd 2\n");
4278 hpd2
|= DC_HPDx_INT_EN
;
4280 if (rdev
->irq
.hpd
[2]) {
4281 DRM_DEBUG("evergreen_irq_set: hpd 3\n");
4282 hpd3
|= DC_HPDx_INT_EN
;
4284 if (rdev
->irq
.hpd
[3]) {
4285 DRM_DEBUG("evergreen_irq_set: hpd 4\n");
4286 hpd4
|= DC_HPDx_INT_EN
;
4288 if (rdev
->irq
.hpd
[4]) {
4289 DRM_DEBUG("evergreen_irq_set: hpd 5\n");
4290 hpd5
|= DC_HPDx_INT_EN
;
4292 if (rdev
->irq
.hpd
[5]) {
4293 DRM_DEBUG("evergreen_irq_set: hpd 6\n");
4294 hpd6
|= DC_HPDx_INT_EN
;
4296 if (rdev
->irq
.afmt
[0]) {
4297 DRM_DEBUG("evergreen_irq_set: hdmi 0\n");
4298 afmt1
|= AFMT_AZ_FORMAT_WTRIG_MASK
;
4300 if (rdev
->irq
.afmt
[1]) {
4301 DRM_DEBUG("evergreen_irq_set: hdmi 1\n");
4302 afmt2
|= AFMT_AZ_FORMAT_WTRIG_MASK
;
4304 if (rdev
->irq
.afmt
[2]) {
4305 DRM_DEBUG("evergreen_irq_set: hdmi 2\n");
4306 afmt3
|= AFMT_AZ_FORMAT_WTRIG_MASK
;
4308 if (rdev
->irq
.afmt
[3]) {
4309 DRM_DEBUG("evergreen_irq_set: hdmi 3\n");
4310 afmt4
|= AFMT_AZ_FORMAT_WTRIG_MASK
;
4312 if (rdev
->irq
.afmt
[4]) {
4313 DRM_DEBUG("evergreen_irq_set: hdmi 4\n");
4314 afmt5
|= AFMT_AZ_FORMAT_WTRIG_MASK
;
4316 if (rdev
->irq
.afmt
[5]) {
4317 DRM_DEBUG("evergreen_irq_set: hdmi 5\n");
4318 afmt6
|= AFMT_AZ_FORMAT_WTRIG_MASK
;
4321 if (rdev
->family
>= CHIP_CAYMAN
) {
4322 cayman_cp_int_cntl_setup(rdev
, 0, cp_int_cntl
);
4323 cayman_cp_int_cntl_setup(rdev
, 1, cp_int_cntl1
);
4324 cayman_cp_int_cntl_setup(rdev
, 2, cp_int_cntl2
);
4326 WREG32(CP_INT_CNTL
, cp_int_cntl
);
4328 WREG32(DMA_CNTL
, dma_cntl
);
4330 if (rdev
->family
>= CHIP_CAYMAN
)
4331 WREG32(CAYMAN_DMA1_CNTL
, dma_cntl1
);
4333 WREG32(GRBM_INT_CNTL
, grbm_int_cntl
);
4335 WREG32(INT_MASK
+ EVERGREEN_CRTC0_REGISTER_OFFSET
, crtc1
);
4336 WREG32(INT_MASK
+ EVERGREEN_CRTC1_REGISTER_OFFSET
, crtc2
);
4337 if (rdev
->num_crtc
>= 4) {
4338 WREG32(INT_MASK
+ EVERGREEN_CRTC2_REGISTER_OFFSET
, crtc3
);
4339 WREG32(INT_MASK
+ EVERGREEN_CRTC3_REGISTER_OFFSET
, crtc4
);
4341 if (rdev
->num_crtc
>= 6) {
4342 WREG32(INT_MASK
+ EVERGREEN_CRTC4_REGISTER_OFFSET
, crtc5
);
4343 WREG32(INT_MASK
+ EVERGREEN_CRTC5_REGISTER_OFFSET
, crtc6
);
4346 WREG32(GRPH_INT_CONTROL
+ EVERGREEN_CRTC0_REGISTER_OFFSET
, grph1
);
4347 WREG32(GRPH_INT_CONTROL
+ EVERGREEN_CRTC1_REGISTER_OFFSET
, grph2
);
4348 if (rdev
->num_crtc
>= 4) {
4349 WREG32(GRPH_INT_CONTROL
+ EVERGREEN_CRTC2_REGISTER_OFFSET
, grph3
);
4350 WREG32(GRPH_INT_CONTROL
+ EVERGREEN_CRTC3_REGISTER_OFFSET
, grph4
);
4352 if (rdev
->num_crtc
>= 6) {
4353 WREG32(GRPH_INT_CONTROL
+ EVERGREEN_CRTC4_REGISTER_OFFSET
, grph5
);
4354 WREG32(GRPH_INT_CONTROL
+ EVERGREEN_CRTC5_REGISTER_OFFSET
, grph6
);
4357 WREG32(DC_HPD1_INT_CONTROL
, hpd1
);
4358 WREG32(DC_HPD2_INT_CONTROL
, hpd2
);
4359 WREG32(DC_HPD3_INT_CONTROL
, hpd3
);
4360 WREG32(DC_HPD4_INT_CONTROL
, hpd4
);
4361 WREG32(DC_HPD5_INT_CONTROL
, hpd5
);
4362 WREG32(DC_HPD6_INT_CONTROL
, hpd6
);
4363 WREG32(CG_THERMAL_INT
, thermal_int
);
4365 WREG32(AFMT_AUDIO_PACKET_CONTROL
+ EVERGREEN_CRTC0_REGISTER_OFFSET
, afmt1
);
4366 WREG32(AFMT_AUDIO_PACKET_CONTROL
+ EVERGREEN_CRTC1_REGISTER_OFFSET
, afmt2
);
4367 WREG32(AFMT_AUDIO_PACKET_CONTROL
+ EVERGREEN_CRTC2_REGISTER_OFFSET
, afmt3
);
4368 WREG32(AFMT_AUDIO_PACKET_CONTROL
+ EVERGREEN_CRTC3_REGISTER_OFFSET
, afmt4
);
4369 WREG32(AFMT_AUDIO_PACKET_CONTROL
+ EVERGREEN_CRTC4_REGISTER_OFFSET
, afmt5
);
4370 WREG32(AFMT_AUDIO_PACKET_CONTROL
+ EVERGREEN_CRTC5_REGISTER_OFFSET
, afmt6
);
4375 static void evergreen_irq_ack(struct radeon_device
*rdev
)
4379 rdev
->irq
.stat_regs
.evergreen
.disp_int
= RREG32(DISP_INTERRUPT_STATUS
);
4380 rdev
->irq
.stat_regs
.evergreen
.disp_int_cont
= RREG32(DISP_INTERRUPT_STATUS_CONTINUE
);
4381 rdev
->irq
.stat_regs
.evergreen
.disp_int_cont2
= RREG32(DISP_INTERRUPT_STATUS_CONTINUE2
);
4382 rdev
->irq
.stat_regs
.evergreen
.disp_int_cont3
= RREG32(DISP_INTERRUPT_STATUS_CONTINUE3
);
4383 rdev
->irq
.stat_regs
.evergreen
.disp_int_cont4
= RREG32(DISP_INTERRUPT_STATUS_CONTINUE4
);
4384 rdev
->irq
.stat_regs
.evergreen
.disp_int_cont5
= RREG32(DISP_INTERRUPT_STATUS_CONTINUE5
);
4385 rdev
->irq
.stat_regs
.evergreen
.d1grph_int
= RREG32(GRPH_INT_STATUS
+ EVERGREEN_CRTC0_REGISTER_OFFSET
);
4386 rdev
->irq
.stat_regs
.evergreen
.d2grph_int
= RREG32(GRPH_INT_STATUS
+ EVERGREEN_CRTC1_REGISTER_OFFSET
);
4387 if (rdev
->num_crtc
>= 4) {
4388 rdev
->irq
.stat_regs
.evergreen
.d3grph_int
= RREG32(GRPH_INT_STATUS
+ EVERGREEN_CRTC2_REGISTER_OFFSET
);
4389 rdev
->irq
.stat_regs
.evergreen
.d4grph_int
= RREG32(GRPH_INT_STATUS
+ EVERGREEN_CRTC3_REGISTER_OFFSET
);
4391 if (rdev
->num_crtc
>= 6) {
4392 rdev
->irq
.stat_regs
.evergreen
.d5grph_int
= RREG32(GRPH_INT_STATUS
+ EVERGREEN_CRTC4_REGISTER_OFFSET
);
4393 rdev
->irq
.stat_regs
.evergreen
.d6grph_int
= RREG32(GRPH_INT_STATUS
+ EVERGREEN_CRTC5_REGISTER_OFFSET
);
4396 rdev
->irq
.stat_regs
.evergreen
.afmt_status1
= RREG32(AFMT_STATUS
+ EVERGREEN_CRTC0_REGISTER_OFFSET
);
4397 rdev
->irq
.stat_regs
.evergreen
.afmt_status2
= RREG32(AFMT_STATUS
+ EVERGREEN_CRTC1_REGISTER_OFFSET
);
4398 rdev
->irq
.stat_regs
.evergreen
.afmt_status3
= RREG32(AFMT_STATUS
+ EVERGREEN_CRTC2_REGISTER_OFFSET
);
4399 rdev
->irq
.stat_regs
.evergreen
.afmt_status4
= RREG32(AFMT_STATUS
+ EVERGREEN_CRTC3_REGISTER_OFFSET
);
4400 rdev
->irq
.stat_regs
.evergreen
.afmt_status5
= RREG32(AFMT_STATUS
+ EVERGREEN_CRTC4_REGISTER_OFFSET
);
4401 rdev
->irq
.stat_regs
.evergreen
.afmt_status6
= RREG32(AFMT_STATUS
+ EVERGREEN_CRTC5_REGISTER_OFFSET
);
4403 if (rdev
->irq
.stat_regs
.evergreen
.d1grph_int
& GRPH_PFLIP_INT_OCCURRED
)
4404 WREG32(GRPH_INT_STATUS
+ EVERGREEN_CRTC0_REGISTER_OFFSET
, GRPH_PFLIP_INT_CLEAR
);
4405 if (rdev
->irq
.stat_regs
.evergreen
.d2grph_int
& GRPH_PFLIP_INT_OCCURRED
)
4406 WREG32(GRPH_INT_STATUS
+ EVERGREEN_CRTC1_REGISTER_OFFSET
, GRPH_PFLIP_INT_CLEAR
);
4407 if (rdev
->irq
.stat_regs
.evergreen
.disp_int
& LB_D1_VBLANK_INTERRUPT
)
4408 WREG32(VBLANK_STATUS
+ EVERGREEN_CRTC0_REGISTER_OFFSET
, VBLANK_ACK
);
4409 if (rdev
->irq
.stat_regs
.evergreen
.disp_int
& LB_D1_VLINE_INTERRUPT
)
4410 WREG32(VLINE_STATUS
+ EVERGREEN_CRTC0_REGISTER_OFFSET
, VLINE_ACK
);
4411 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont
& LB_D2_VBLANK_INTERRUPT
)
4412 WREG32(VBLANK_STATUS
+ EVERGREEN_CRTC1_REGISTER_OFFSET
, VBLANK_ACK
);
4413 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont
& LB_D2_VLINE_INTERRUPT
)
4414 WREG32(VLINE_STATUS
+ EVERGREEN_CRTC1_REGISTER_OFFSET
, VLINE_ACK
);
4416 if (rdev
->num_crtc
>= 4) {
4417 if (rdev
->irq
.stat_regs
.evergreen
.d3grph_int
& GRPH_PFLIP_INT_OCCURRED
)
4418 WREG32(GRPH_INT_STATUS
+ EVERGREEN_CRTC2_REGISTER_OFFSET
, GRPH_PFLIP_INT_CLEAR
);
4419 if (rdev
->irq
.stat_regs
.evergreen
.d4grph_int
& GRPH_PFLIP_INT_OCCURRED
)
4420 WREG32(GRPH_INT_STATUS
+ EVERGREEN_CRTC3_REGISTER_OFFSET
, GRPH_PFLIP_INT_CLEAR
);
4421 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont2
& LB_D3_VBLANK_INTERRUPT
)
4422 WREG32(VBLANK_STATUS
+ EVERGREEN_CRTC2_REGISTER_OFFSET
, VBLANK_ACK
);
4423 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont2
& LB_D3_VLINE_INTERRUPT
)
4424 WREG32(VLINE_STATUS
+ EVERGREEN_CRTC2_REGISTER_OFFSET
, VLINE_ACK
);
4425 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont3
& LB_D4_VBLANK_INTERRUPT
)
4426 WREG32(VBLANK_STATUS
+ EVERGREEN_CRTC3_REGISTER_OFFSET
, VBLANK_ACK
);
4427 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont3
& LB_D4_VLINE_INTERRUPT
)
4428 WREG32(VLINE_STATUS
+ EVERGREEN_CRTC3_REGISTER_OFFSET
, VLINE_ACK
);
4431 if (rdev
->num_crtc
>= 6) {
4432 if (rdev
->irq
.stat_regs
.evergreen
.d5grph_int
& GRPH_PFLIP_INT_OCCURRED
)
4433 WREG32(GRPH_INT_STATUS
+ EVERGREEN_CRTC4_REGISTER_OFFSET
, GRPH_PFLIP_INT_CLEAR
);
4434 if (rdev
->irq
.stat_regs
.evergreen
.d6grph_int
& GRPH_PFLIP_INT_OCCURRED
)
4435 WREG32(GRPH_INT_STATUS
+ EVERGREEN_CRTC5_REGISTER_OFFSET
, GRPH_PFLIP_INT_CLEAR
);
4436 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont4
& LB_D5_VBLANK_INTERRUPT
)
4437 WREG32(VBLANK_STATUS
+ EVERGREEN_CRTC4_REGISTER_OFFSET
, VBLANK_ACK
);
4438 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont4
& LB_D5_VLINE_INTERRUPT
)
4439 WREG32(VLINE_STATUS
+ EVERGREEN_CRTC4_REGISTER_OFFSET
, VLINE_ACK
);
4440 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont5
& LB_D6_VBLANK_INTERRUPT
)
4441 WREG32(VBLANK_STATUS
+ EVERGREEN_CRTC5_REGISTER_OFFSET
, VBLANK_ACK
);
4442 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont5
& LB_D6_VLINE_INTERRUPT
)
4443 WREG32(VLINE_STATUS
+ EVERGREEN_CRTC5_REGISTER_OFFSET
, VLINE_ACK
);
4446 if (rdev
->irq
.stat_regs
.evergreen
.disp_int
& DC_HPD1_INTERRUPT
) {
4447 tmp
= RREG32(DC_HPD1_INT_CONTROL
);
4448 tmp
|= DC_HPDx_INT_ACK
;
4449 WREG32(DC_HPD1_INT_CONTROL
, tmp
);
4451 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont
& DC_HPD2_INTERRUPT
) {
4452 tmp
= RREG32(DC_HPD2_INT_CONTROL
);
4453 tmp
|= DC_HPDx_INT_ACK
;
4454 WREG32(DC_HPD2_INT_CONTROL
, tmp
);
4456 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont2
& DC_HPD3_INTERRUPT
) {
4457 tmp
= RREG32(DC_HPD3_INT_CONTROL
);
4458 tmp
|= DC_HPDx_INT_ACK
;
4459 WREG32(DC_HPD3_INT_CONTROL
, tmp
);
4461 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont3
& DC_HPD4_INTERRUPT
) {
4462 tmp
= RREG32(DC_HPD4_INT_CONTROL
);
4463 tmp
|= DC_HPDx_INT_ACK
;
4464 WREG32(DC_HPD4_INT_CONTROL
, tmp
);
4466 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont4
& DC_HPD5_INTERRUPT
) {
4467 tmp
= RREG32(DC_HPD5_INT_CONTROL
);
4468 tmp
|= DC_HPDx_INT_ACK
;
4469 WREG32(DC_HPD5_INT_CONTROL
, tmp
);
4471 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont5
& DC_HPD6_INTERRUPT
) {
4472 tmp
= RREG32(DC_HPD5_INT_CONTROL
);
4473 tmp
|= DC_HPDx_INT_ACK
;
4474 WREG32(DC_HPD6_INT_CONTROL
, tmp
);
4476 if (rdev
->irq
.stat_regs
.evergreen
.afmt_status1
& AFMT_AZ_FORMAT_WTRIG
) {
4477 tmp
= RREG32(AFMT_AUDIO_PACKET_CONTROL
+ EVERGREEN_CRTC0_REGISTER_OFFSET
);
4478 tmp
|= AFMT_AZ_FORMAT_WTRIG_ACK
;
4479 WREG32(AFMT_AUDIO_PACKET_CONTROL
+ EVERGREEN_CRTC0_REGISTER_OFFSET
, tmp
);
4481 if (rdev
->irq
.stat_regs
.evergreen
.afmt_status2
& AFMT_AZ_FORMAT_WTRIG
) {
4482 tmp
= RREG32(AFMT_AUDIO_PACKET_CONTROL
+ EVERGREEN_CRTC1_REGISTER_OFFSET
);
4483 tmp
|= AFMT_AZ_FORMAT_WTRIG_ACK
;
4484 WREG32(AFMT_AUDIO_PACKET_CONTROL
+ EVERGREEN_CRTC1_REGISTER_OFFSET
, tmp
);
4486 if (rdev
->irq
.stat_regs
.evergreen
.afmt_status3
& AFMT_AZ_FORMAT_WTRIG
) {
4487 tmp
= RREG32(AFMT_AUDIO_PACKET_CONTROL
+ EVERGREEN_CRTC2_REGISTER_OFFSET
);
4488 tmp
|= AFMT_AZ_FORMAT_WTRIG_ACK
;
4489 WREG32(AFMT_AUDIO_PACKET_CONTROL
+ EVERGREEN_CRTC2_REGISTER_OFFSET
, tmp
);
4491 if (rdev
->irq
.stat_regs
.evergreen
.afmt_status4
& AFMT_AZ_FORMAT_WTRIG
) {
4492 tmp
= RREG32(AFMT_AUDIO_PACKET_CONTROL
+ EVERGREEN_CRTC3_REGISTER_OFFSET
);
4493 tmp
|= AFMT_AZ_FORMAT_WTRIG_ACK
;
4494 WREG32(AFMT_AUDIO_PACKET_CONTROL
+ EVERGREEN_CRTC3_REGISTER_OFFSET
, tmp
);
4496 if (rdev
->irq
.stat_regs
.evergreen
.afmt_status5
& AFMT_AZ_FORMAT_WTRIG
) {
4497 tmp
= RREG32(AFMT_AUDIO_PACKET_CONTROL
+ EVERGREEN_CRTC4_REGISTER_OFFSET
);
4498 tmp
|= AFMT_AZ_FORMAT_WTRIG_ACK
;
4499 WREG32(AFMT_AUDIO_PACKET_CONTROL
+ EVERGREEN_CRTC4_REGISTER_OFFSET
, tmp
);
4501 if (rdev
->irq
.stat_regs
.evergreen
.afmt_status6
& AFMT_AZ_FORMAT_WTRIG
) {
4502 tmp
= RREG32(AFMT_AUDIO_PACKET_CONTROL
+ EVERGREEN_CRTC5_REGISTER_OFFSET
);
4503 tmp
|= AFMT_AZ_FORMAT_WTRIG_ACK
;
4504 WREG32(AFMT_AUDIO_PACKET_CONTROL
+ EVERGREEN_CRTC5_REGISTER_OFFSET
, tmp
);
4508 static void evergreen_irq_disable(struct radeon_device
*rdev
)
4510 r600_disable_interrupts(rdev
);
4511 /* Wait and acknowledge irq */
4513 evergreen_irq_ack(rdev
);
4514 evergreen_disable_interrupt_state(rdev
);
4517 void evergreen_irq_suspend(struct radeon_device
*rdev
)
4519 evergreen_irq_disable(rdev
);
4520 r600_rlc_stop(rdev
);
4523 static u32
evergreen_get_ih_wptr(struct radeon_device
*rdev
)
4527 if (rdev
->wb
.enabled
)
4528 wptr
= le32_to_cpu(rdev
->wb
.wb
[R600_WB_IH_WPTR_OFFSET
/4]);
4530 wptr
= RREG32(IH_RB_WPTR
);
4532 if (wptr
& RB_OVERFLOW
) {
4533 /* When a ring buffer overflow happen start parsing interrupt
4534 * from the last not overwritten vector (wptr + 16). Hopefully
4535 * this should allow us to catchup.
4537 dev_warn(rdev
->dev
, "IH ring buffer overflow (0x%08X, %d, %d)\n",
4538 wptr
, rdev
->ih
.rptr
, (wptr
+ 16) + rdev
->ih
.ptr_mask
);
4539 rdev
->ih
.rptr
= (wptr
+ 16) & rdev
->ih
.ptr_mask
;
4540 tmp
= RREG32(IH_RB_CNTL
);
4541 tmp
|= IH_WPTR_OVERFLOW_CLEAR
;
4542 WREG32(IH_RB_CNTL
, tmp
);
4544 return (wptr
& rdev
->ih
.ptr_mask
);
4547 int evergreen_irq_process(struct radeon_device
*rdev
)
4551 u32 src_id
, src_data
;
4553 bool queue_hotplug
= false;
4554 bool queue_hdmi
= false;
4555 bool queue_thermal
= false;
4557 if (!rdev
->ih
.enabled
|| rdev
->shutdown
)
4560 wptr
= evergreen_get_ih_wptr(rdev
);
4563 /* is somebody else already processing irqs? */
4564 if (atomic_xchg(&rdev
->ih
.lock
, 1))
4567 rptr
= rdev
->ih
.rptr
;
4568 DRM_DEBUG("r600_irq_process start: rptr %d, wptr %d\n", rptr
, wptr
);
4570 /* Order reading of wptr vs. reading of IH ring data */
4573 /* display interrupts */
4574 evergreen_irq_ack(rdev
);
4576 while (rptr
!= wptr
) {
4577 /* wptr/rptr are in bytes! */
4578 ring_index
= rptr
/ 4;
4579 src_id
= le32_to_cpu(rdev
->ih
.ring
[ring_index
]) & 0xff;
4580 src_data
= le32_to_cpu(rdev
->ih
.ring
[ring_index
+ 1]) & 0xfffffff;
4583 case 1: /* D1 vblank/vline */
4585 case 0: /* D1 vblank */
4586 if (rdev
->irq
.stat_regs
.evergreen
.disp_int
& LB_D1_VBLANK_INTERRUPT
) {
4587 if (rdev
->irq
.crtc_vblank_int
[0]) {
4588 drm_handle_vblank(rdev
->ddev
, 0);
4589 rdev
->pm
.vblank_sync
= true;
4590 wake_up(&rdev
->irq
.vblank_queue
);
4592 if (atomic_read(&rdev
->irq
.pflip
[0]))
4593 radeon_crtc_handle_flip(rdev
, 0);
4594 rdev
->irq
.stat_regs
.evergreen
.disp_int
&= ~LB_D1_VBLANK_INTERRUPT
;
4595 DRM_DEBUG("IH: D1 vblank\n");
4598 case 1: /* D1 vline */
4599 if (rdev
->irq
.stat_regs
.evergreen
.disp_int
& LB_D1_VLINE_INTERRUPT
) {
4600 rdev
->irq
.stat_regs
.evergreen
.disp_int
&= ~LB_D1_VLINE_INTERRUPT
;
4601 DRM_DEBUG("IH: D1 vline\n");
4605 DRM_DEBUG("Unhandled interrupt: %d %d\n", src_id
, src_data
);
4609 case 2: /* D2 vblank/vline */
4611 case 0: /* D2 vblank */
4612 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont
& LB_D2_VBLANK_INTERRUPT
) {
4613 if (rdev
->irq
.crtc_vblank_int
[1]) {
4614 drm_handle_vblank(rdev
->ddev
, 1);
4615 rdev
->pm
.vblank_sync
= true;
4616 wake_up(&rdev
->irq
.vblank_queue
);
4618 if (atomic_read(&rdev
->irq
.pflip
[1]))
4619 radeon_crtc_handle_flip(rdev
, 1);
4620 rdev
->irq
.stat_regs
.evergreen
.disp_int_cont
&= ~LB_D2_VBLANK_INTERRUPT
;
4621 DRM_DEBUG("IH: D2 vblank\n");
4624 case 1: /* D2 vline */
4625 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont
& LB_D2_VLINE_INTERRUPT
) {
4626 rdev
->irq
.stat_regs
.evergreen
.disp_int_cont
&= ~LB_D2_VLINE_INTERRUPT
;
4627 DRM_DEBUG("IH: D2 vline\n");
4631 DRM_DEBUG("Unhandled interrupt: %d %d\n", src_id
, src_data
);
4635 case 3: /* D3 vblank/vline */
4637 case 0: /* D3 vblank */
4638 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont2
& LB_D3_VBLANK_INTERRUPT
) {
4639 if (rdev
->irq
.crtc_vblank_int
[2]) {
4640 drm_handle_vblank(rdev
->ddev
, 2);
4641 rdev
->pm
.vblank_sync
= true;
4642 wake_up(&rdev
->irq
.vblank_queue
);
4644 if (atomic_read(&rdev
->irq
.pflip
[2]))
4645 radeon_crtc_handle_flip(rdev
, 2);
4646 rdev
->irq
.stat_regs
.evergreen
.disp_int_cont2
&= ~LB_D3_VBLANK_INTERRUPT
;
4647 DRM_DEBUG("IH: D3 vblank\n");
4650 case 1: /* D3 vline */
4651 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont2
& LB_D3_VLINE_INTERRUPT
) {
4652 rdev
->irq
.stat_regs
.evergreen
.disp_int_cont2
&= ~LB_D3_VLINE_INTERRUPT
;
4653 DRM_DEBUG("IH: D3 vline\n");
4657 DRM_DEBUG("Unhandled interrupt: %d %d\n", src_id
, src_data
);
4661 case 4: /* D4 vblank/vline */
4663 case 0: /* D4 vblank */
4664 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont3
& LB_D4_VBLANK_INTERRUPT
) {
4665 if (rdev
->irq
.crtc_vblank_int
[3]) {
4666 drm_handle_vblank(rdev
->ddev
, 3);
4667 rdev
->pm
.vblank_sync
= true;
4668 wake_up(&rdev
->irq
.vblank_queue
);
4670 if (atomic_read(&rdev
->irq
.pflip
[3]))
4671 radeon_crtc_handle_flip(rdev
, 3);
4672 rdev
->irq
.stat_regs
.evergreen
.disp_int_cont3
&= ~LB_D4_VBLANK_INTERRUPT
;
4673 DRM_DEBUG("IH: D4 vblank\n");
4676 case 1: /* D4 vline */
4677 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont3
& LB_D4_VLINE_INTERRUPT
) {
4678 rdev
->irq
.stat_regs
.evergreen
.disp_int_cont3
&= ~LB_D4_VLINE_INTERRUPT
;
4679 DRM_DEBUG("IH: D4 vline\n");
4683 DRM_DEBUG("Unhandled interrupt: %d %d\n", src_id
, src_data
);
4687 case 5: /* D5 vblank/vline */
4689 case 0: /* D5 vblank */
4690 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont4
& LB_D5_VBLANK_INTERRUPT
) {
4691 if (rdev
->irq
.crtc_vblank_int
[4]) {
4692 drm_handle_vblank(rdev
->ddev
, 4);
4693 rdev
->pm
.vblank_sync
= true;
4694 wake_up(&rdev
->irq
.vblank_queue
);
4696 if (atomic_read(&rdev
->irq
.pflip
[4]))
4697 radeon_crtc_handle_flip(rdev
, 4);
4698 rdev
->irq
.stat_regs
.evergreen
.disp_int_cont4
&= ~LB_D5_VBLANK_INTERRUPT
;
4699 DRM_DEBUG("IH: D5 vblank\n");
4702 case 1: /* D5 vline */
4703 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont4
& LB_D5_VLINE_INTERRUPT
) {
4704 rdev
->irq
.stat_regs
.evergreen
.disp_int_cont4
&= ~LB_D5_VLINE_INTERRUPT
;
4705 DRM_DEBUG("IH: D5 vline\n");
4709 DRM_DEBUG("Unhandled interrupt: %d %d\n", src_id
, src_data
);
4713 case 6: /* D6 vblank/vline */
4715 case 0: /* D6 vblank */
4716 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont5
& LB_D6_VBLANK_INTERRUPT
) {
4717 if (rdev
->irq
.crtc_vblank_int
[5]) {
4718 drm_handle_vblank(rdev
->ddev
, 5);
4719 rdev
->pm
.vblank_sync
= true;
4720 wake_up(&rdev
->irq
.vblank_queue
);
4722 if (atomic_read(&rdev
->irq
.pflip
[5]))
4723 radeon_crtc_handle_flip(rdev
, 5);
4724 rdev
->irq
.stat_regs
.evergreen
.disp_int_cont5
&= ~LB_D6_VBLANK_INTERRUPT
;
4725 DRM_DEBUG("IH: D6 vblank\n");
4728 case 1: /* D6 vline */
4729 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont5
& LB_D6_VLINE_INTERRUPT
) {
4730 rdev
->irq
.stat_regs
.evergreen
.disp_int_cont5
&= ~LB_D6_VLINE_INTERRUPT
;
4731 DRM_DEBUG("IH: D6 vline\n");
4735 DRM_DEBUG("Unhandled interrupt: %d %d\n", src_id
, src_data
);
4739 case 42: /* HPD hotplug */
4742 if (rdev
->irq
.stat_regs
.evergreen
.disp_int
& DC_HPD1_INTERRUPT
) {
4743 rdev
->irq
.stat_regs
.evergreen
.disp_int
&= ~DC_HPD1_INTERRUPT
;
4744 queue_hotplug
= true;
4745 DRM_DEBUG("IH: HPD1\n");
4749 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont
& DC_HPD2_INTERRUPT
) {
4750 rdev
->irq
.stat_regs
.evergreen
.disp_int_cont
&= ~DC_HPD2_INTERRUPT
;
4751 queue_hotplug
= true;
4752 DRM_DEBUG("IH: HPD2\n");
4756 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont2
& DC_HPD3_INTERRUPT
) {
4757 rdev
->irq
.stat_regs
.evergreen
.disp_int_cont2
&= ~DC_HPD3_INTERRUPT
;
4758 queue_hotplug
= true;
4759 DRM_DEBUG("IH: HPD3\n");
4763 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont3
& DC_HPD4_INTERRUPT
) {
4764 rdev
->irq
.stat_regs
.evergreen
.disp_int_cont3
&= ~DC_HPD4_INTERRUPT
;
4765 queue_hotplug
= true;
4766 DRM_DEBUG("IH: HPD4\n");
4770 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont4
& DC_HPD5_INTERRUPT
) {
4771 rdev
->irq
.stat_regs
.evergreen
.disp_int_cont4
&= ~DC_HPD5_INTERRUPT
;
4772 queue_hotplug
= true;
4773 DRM_DEBUG("IH: HPD5\n");
4777 if (rdev
->irq
.stat_regs
.evergreen
.disp_int_cont5
& DC_HPD6_INTERRUPT
) {
4778 rdev
->irq
.stat_regs
.evergreen
.disp_int_cont5
&= ~DC_HPD6_INTERRUPT
;
4779 queue_hotplug
= true;
4780 DRM_DEBUG("IH: HPD6\n");
4784 DRM_DEBUG("Unhandled interrupt: %d %d\n", src_id
, src_data
);
4791 if (rdev
->irq
.stat_regs
.evergreen
.afmt_status1
& AFMT_AZ_FORMAT_WTRIG
) {
4792 rdev
->irq
.stat_regs
.evergreen
.afmt_status1
&= ~AFMT_AZ_FORMAT_WTRIG
;
4794 DRM_DEBUG("IH: HDMI0\n");
4798 if (rdev
->irq
.stat_regs
.evergreen
.afmt_status2
& AFMT_AZ_FORMAT_WTRIG
) {
4799 rdev
->irq
.stat_regs
.evergreen
.afmt_status2
&= ~AFMT_AZ_FORMAT_WTRIG
;
4801 DRM_DEBUG("IH: HDMI1\n");
4805 if (rdev
->irq
.stat_regs
.evergreen
.afmt_status3
& AFMT_AZ_FORMAT_WTRIG
) {
4806 rdev
->irq
.stat_regs
.evergreen
.afmt_status3
&= ~AFMT_AZ_FORMAT_WTRIG
;
4808 DRM_DEBUG("IH: HDMI2\n");
4812 if (rdev
->irq
.stat_regs
.evergreen
.afmt_status4
& AFMT_AZ_FORMAT_WTRIG
) {
4813 rdev
->irq
.stat_regs
.evergreen
.afmt_status4
&= ~AFMT_AZ_FORMAT_WTRIG
;
4815 DRM_DEBUG("IH: HDMI3\n");
4819 if (rdev
->irq
.stat_regs
.evergreen
.afmt_status5
& AFMT_AZ_FORMAT_WTRIG
) {
4820 rdev
->irq
.stat_regs
.evergreen
.afmt_status5
&= ~AFMT_AZ_FORMAT_WTRIG
;
4822 DRM_DEBUG("IH: HDMI4\n");
4826 if (rdev
->irq
.stat_regs
.evergreen
.afmt_status6
& AFMT_AZ_FORMAT_WTRIG
) {
4827 rdev
->irq
.stat_regs
.evergreen
.afmt_status6
&= ~AFMT_AZ_FORMAT_WTRIG
;
4829 DRM_DEBUG("IH: HDMI5\n");
4833 DRM_ERROR("Unhandled interrupt: %d %d\n", src_id
, src_data
);
4837 DRM_DEBUG("IH: UVD int: 0x%08x\n", src_data
);
4838 radeon_fence_process(rdev
, R600_RING_TYPE_UVD_INDEX
);
4842 dev_err(rdev
->dev
, "GPU fault detected: %d 0x%08x\n", src_id
, src_data
);
4843 dev_err(rdev
->dev
, " VM_CONTEXT1_PROTECTION_FAULT_ADDR 0x%08X\n",
4844 RREG32(VM_CONTEXT1_PROTECTION_FAULT_ADDR
));
4845 dev_err(rdev
->dev
, " VM_CONTEXT1_PROTECTION_FAULT_STATUS 0x%08X\n",
4846 RREG32(VM_CONTEXT1_PROTECTION_FAULT_STATUS
));
4847 /* reset addr and status */
4848 WREG32_P(VM_CONTEXT1_CNTL2
, 1, ~1);
4850 case 176: /* CP_INT in ring buffer */
4851 case 177: /* CP_INT in IB1 */
4852 case 178: /* CP_INT in IB2 */
4853 DRM_DEBUG("IH: CP int: 0x%08x\n", src_data
);
4854 radeon_fence_process(rdev
, RADEON_RING_TYPE_GFX_INDEX
);
4856 case 181: /* CP EOP event */
4857 DRM_DEBUG("IH: CP EOP\n");
4858 if (rdev
->family
>= CHIP_CAYMAN
) {
4861 radeon_fence_process(rdev
, RADEON_RING_TYPE_GFX_INDEX
);
4864 radeon_fence_process(rdev
, CAYMAN_RING_TYPE_CP1_INDEX
);
4867 radeon_fence_process(rdev
, CAYMAN_RING_TYPE_CP2_INDEX
);
4871 radeon_fence_process(rdev
, RADEON_RING_TYPE_GFX_INDEX
);
4873 case 224: /* DMA trap event */
4874 DRM_DEBUG("IH: DMA trap\n");
4875 radeon_fence_process(rdev
, R600_RING_TYPE_DMA_INDEX
);
4877 case 230: /* thermal low to high */
4878 DRM_DEBUG("IH: thermal low to high\n");
4879 rdev
->pm
.dpm
.thermal
.high_to_low
= false;
4880 queue_thermal
= true;
4882 case 231: /* thermal high to low */
4883 DRM_DEBUG("IH: thermal high to low\n");
4884 rdev
->pm
.dpm
.thermal
.high_to_low
= true;
4885 queue_thermal
= true;
4887 case 233: /* GUI IDLE */
4888 DRM_DEBUG("IH: GUI idle\n");
4890 case 244: /* DMA trap event */
4891 if (rdev
->family
>= CHIP_CAYMAN
) {
4892 DRM_DEBUG("IH: DMA1 trap\n");
4893 radeon_fence_process(rdev
, CAYMAN_RING_TYPE_DMA1_INDEX
);
4897 DRM_DEBUG("Unhandled interrupt: %d %d\n", src_id
, src_data
);
4901 /* wptr/rptr are in bytes! */
4903 rptr
&= rdev
->ih
.ptr_mask
;
4906 schedule_work(&rdev
->hotplug_work
);
4908 schedule_work(&rdev
->audio_work
);
4909 if (queue_thermal
&& rdev
->pm
.dpm_enabled
)
4910 schedule_work(&rdev
->pm
.dpm
.thermal
.work
);
4911 rdev
->ih
.rptr
= rptr
;
4912 WREG32(IH_RB_RPTR
, rdev
->ih
.rptr
);
4913 atomic_set(&rdev
->ih
.lock
, 0);
4915 /* make sure wptr hasn't changed while processing */
4916 wptr
= evergreen_get_ih_wptr(rdev
);
4924 * evergreen_dma_fence_ring_emit - emit a fence on the DMA ring
4926 * @rdev: radeon_device pointer
4927 * @fence: radeon fence object
4929 * Add a DMA fence packet to the ring to write
4930 * the fence seq number and DMA trap packet to generate
4931 * an interrupt if needed (evergreen-SI).
4933 void evergreen_dma_fence_ring_emit(struct radeon_device
*rdev
,
4934 struct radeon_fence
*fence
)
4936 struct radeon_ring
*ring
= &rdev
->ring
[fence
->ring
];
4937 u64 addr
= rdev
->fence_drv
[fence
->ring
].gpu_addr
;
4938 /* write the fence */
4939 radeon_ring_write(ring
, DMA_PACKET(DMA_PACKET_FENCE
, 0, 0));
4940 radeon_ring_write(ring
, addr
& 0xfffffffc);
4941 radeon_ring_write(ring
, (upper_32_bits(addr
) & 0xff));
4942 radeon_ring_write(ring
, fence
->seq
);
4943 /* generate an interrupt */
4944 radeon_ring_write(ring
, DMA_PACKET(DMA_PACKET_TRAP
, 0, 0));
4946 radeon_ring_write(ring
, DMA_PACKET(DMA_PACKET_SRBM_WRITE
, 0, 0));
4947 radeon_ring_write(ring
, (0xf << 16) | (HDP_MEM_COHERENCY_FLUSH_CNTL
>> 2));
4948 radeon_ring_write(ring
, 1);
4952 * evergreen_dma_ring_ib_execute - schedule an IB on the DMA engine
4954 * @rdev: radeon_device pointer
4955 * @ib: IB object to schedule
4957 * Schedule an IB in the DMA ring (evergreen).
4959 void evergreen_dma_ring_ib_execute(struct radeon_device
*rdev
,
4960 struct radeon_ib
*ib
)
4962 struct radeon_ring
*ring
= &rdev
->ring
[ib
->ring
];
4964 if (rdev
->wb
.enabled
) {
4965 u32 next_rptr
= ring
->wptr
+ 4;
4966 while ((next_rptr
& 7) != 5)
4969 radeon_ring_write(ring
, DMA_PACKET(DMA_PACKET_WRITE
, 0, 1));
4970 radeon_ring_write(ring
, ring
->next_rptr_gpu_addr
& 0xfffffffc);
4971 radeon_ring_write(ring
, upper_32_bits(ring
->next_rptr_gpu_addr
) & 0xff);
4972 radeon_ring_write(ring
, next_rptr
);
4975 /* The indirect buffer packet must end on an 8 DW boundary in the DMA ring.
4976 * Pad as necessary with NOPs.
4978 while ((ring
->wptr
& 7) != 5)
4979 radeon_ring_write(ring
, DMA_PACKET(DMA_PACKET_NOP
, 0, 0));
4980 radeon_ring_write(ring
, DMA_PACKET(DMA_PACKET_INDIRECT_BUFFER
, 0, 0));
4981 radeon_ring_write(ring
, (ib
->gpu_addr
& 0xFFFFFFE0));
4982 radeon_ring_write(ring
, (ib
->length_dw
<< 12) | (upper_32_bits(ib
->gpu_addr
) & 0xFF));
4987 * evergreen_copy_dma - copy pages using the DMA engine
4989 * @rdev: radeon_device pointer
4990 * @src_offset: src GPU address
4991 * @dst_offset: dst GPU address
4992 * @num_gpu_pages: number of GPU pages to xfer
4993 * @fence: radeon fence object
4995 * Copy GPU paging using the DMA engine (evergreen-cayman).
4996 * Used by the radeon ttm implementation to move pages if
4997 * registered as the asic copy callback.
4999 int evergreen_copy_dma(struct radeon_device
*rdev
,
5000 uint64_t src_offset
, uint64_t dst_offset
,
5001 unsigned num_gpu_pages
,
5002 struct radeon_fence
**fence
)
5004 struct radeon_semaphore
*sem
= NULL
;
5005 int ring_index
= rdev
->asic
->copy
.dma_ring_index
;
5006 struct radeon_ring
*ring
= &rdev
->ring
[ring_index
];
5007 u32 size_in_dw
, cur_size_in_dw
;
5011 r
= radeon_semaphore_create(rdev
, &sem
);
5013 DRM_ERROR("radeon: moving bo (%d).\n", r
);
5017 size_in_dw
= (num_gpu_pages
<< RADEON_GPU_PAGE_SHIFT
) / 4;
5018 num_loops
= DIV_ROUND_UP(size_in_dw
, 0xfffff);
5019 r
= radeon_ring_lock(rdev
, ring
, num_loops
* 5 + 11);
5021 DRM_ERROR("radeon: moving bo (%d).\n", r
);
5022 radeon_semaphore_free(rdev
, &sem
, NULL
);
5026 if (radeon_fence_need_sync(*fence
, ring
->idx
)) {
5027 radeon_semaphore_sync_rings(rdev
, sem
, (*fence
)->ring
,
5029 radeon_fence_note_sync(*fence
, ring
->idx
);
5031 radeon_semaphore_free(rdev
, &sem
, NULL
);
5034 for (i
= 0; i
< num_loops
; i
++) {
5035 cur_size_in_dw
= size_in_dw
;
5036 if (cur_size_in_dw
> 0xFFFFF)
5037 cur_size_in_dw
= 0xFFFFF;
5038 size_in_dw
-= cur_size_in_dw
;
5039 radeon_ring_write(ring
, DMA_PACKET(DMA_PACKET_COPY
, 0, cur_size_in_dw
));
5040 radeon_ring_write(ring
, dst_offset
& 0xfffffffc);
5041 radeon_ring_write(ring
, src_offset
& 0xfffffffc);
5042 radeon_ring_write(ring
, upper_32_bits(dst_offset
) & 0xff);
5043 radeon_ring_write(ring
, upper_32_bits(src_offset
) & 0xff);
5044 src_offset
+= cur_size_in_dw
* 4;
5045 dst_offset
+= cur_size_in_dw
* 4;
5048 r
= radeon_fence_emit(rdev
, fence
, ring
->idx
);
5050 radeon_ring_unlock_undo(rdev
, ring
);
5054 radeon_ring_unlock_commit(rdev
, ring
);
5055 radeon_semaphore_free(rdev
, &sem
, *fence
);
5060 static int evergreen_startup(struct radeon_device
*rdev
)
5062 struct radeon_ring
*ring
;
5065 /* enable pcie gen2 link */
5066 evergreen_pcie_gen2_enable(rdev
);
5068 if (ASIC_IS_DCE5(rdev
)) {
5069 if (!rdev
->me_fw
|| !rdev
->pfp_fw
|| !rdev
->rlc_fw
|| !rdev
->mc_fw
) {
5070 r
= ni_init_microcode(rdev
);
5072 DRM_ERROR("Failed to load firmware!\n");
5076 r
= ni_mc_load_microcode(rdev
);
5078 DRM_ERROR("Failed to load MC firmware!\n");
5082 if (!rdev
->me_fw
|| !rdev
->pfp_fw
|| !rdev
->rlc_fw
) {
5083 r
= r600_init_microcode(rdev
);
5085 DRM_ERROR("Failed to load firmware!\n");
5091 r
= r600_vram_scratch_init(rdev
);
5095 evergreen_mc_program(rdev
);
5096 if (rdev
->flags
& RADEON_IS_AGP
) {
5097 evergreen_agp_enable(rdev
);
5099 r
= evergreen_pcie_gart_enable(rdev
);
5103 evergreen_gpu_init(rdev
);
5105 r
= evergreen_blit_init(rdev
);
5107 r600_blit_fini(rdev
);
5108 rdev
->asic
->copy
.copy
= NULL
;
5109 dev_warn(rdev
->dev
, "failed blitter (%d) falling back to memcpy\n", r
);
5112 /* allocate rlc buffers */
5113 if (rdev
->flags
& RADEON_IS_IGP
) {
5114 rdev
->rlc
.reg_list
= sumo_rlc_save_restore_register_list
;
5115 rdev
->rlc
.reg_list_size
= sumo_rlc_save_restore_register_list_size
;
5116 rdev
->rlc
.cs_data
= evergreen_cs_data
;
5117 r
= sumo_rlc_init(rdev
);
5119 DRM_ERROR("Failed to init rlc BOs!\n");
5124 /* allocate wb buffer */
5125 r
= radeon_wb_init(rdev
);
5129 r
= radeon_fence_driver_start_ring(rdev
, RADEON_RING_TYPE_GFX_INDEX
);
5131 dev_err(rdev
->dev
, "failed initializing CP fences (%d).\n", r
);
5135 r
= radeon_fence_driver_start_ring(rdev
, R600_RING_TYPE_DMA_INDEX
);
5137 dev_err(rdev
->dev
, "failed initializing DMA fences (%d).\n", r
);
5141 r
= rv770_uvd_resume(rdev
);
5143 r
= radeon_fence_driver_start_ring(rdev
,
5144 R600_RING_TYPE_UVD_INDEX
);
5146 dev_err(rdev
->dev
, "UVD fences init error (%d).\n", r
);
5150 rdev
->ring
[R600_RING_TYPE_UVD_INDEX
].ring_size
= 0;
5153 if (!rdev
->irq
.installed
) {
5154 r
= radeon_irq_kms_init(rdev
);
5159 r
= r600_irq_init(rdev
);
5161 DRM_ERROR("radeon: IH init failed (%d).\n", r
);
5162 radeon_irq_kms_fini(rdev
);
5165 evergreen_irq_set(rdev
);
5167 ring
= &rdev
->ring
[RADEON_RING_TYPE_GFX_INDEX
];
5168 r
= radeon_ring_init(rdev
, ring
, ring
->ring_size
, RADEON_WB_CP_RPTR_OFFSET
,
5169 R600_CP_RB_RPTR
, R600_CP_RB_WPTR
,
5170 0, 0xfffff, RADEON_CP_PACKET2
);
5174 ring
= &rdev
->ring
[R600_RING_TYPE_DMA_INDEX
];
5175 r
= radeon_ring_init(rdev
, ring
, ring
->ring_size
, R600_WB_DMA_RPTR_OFFSET
,
5176 DMA_RB_RPTR
, DMA_RB_WPTR
,
5177 2, 0x3fffc, DMA_PACKET(DMA_PACKET_NOP
, 0, 0));
5181 r
= evergreen_cp_load_microcode(rdev
);
5184 r
= evergreen_cp_resume(rdev
);
5187 r
= r600_dma_resume(rdev
);
5191 ring
= &rdev
->ring
[R600_RING_TYPE_UVD_INDEX
];
5192 if (ring
->ring_size
) {
5193 r
= radeon_ring_init(rdev
, ring
, ring
->ring_size
,
5194 R600_WB_UVD_RPTR_OFFSET
,
5195 UVD_RBC_RB_RPTR
, UVD_RBC_RB_WPTR
,
5196 0, 0xfffff, RADEON_CP_PACKET2
);
5198 r
= r600_uvd_init(rdev
);
5201 DRM_ERROR("radeon: error initializing UVD (%d).\n", r
);
5204 r
= radeon_ib_pool_init(rdev
);
5206 dev_err(rdev
->dev
, "IB initialization failed (%d).\n", r
);
5210 r
= r600_audio_init(rdev
);
5212 DRM_ERROR("radeon: audio init failed\n");
5219 int evergreen_resume(struct radeon_device
*rdev
)
5223 /* reset the asic, the gfx blocks are often in a bad state
5224 * after the driver is unloaded or after a resume
5226 if (radeon_asic_reset(rdev
))
5227 dev_warn(rdev
->dev
, "GPU reset failed !\n");
5228 /* Do not reset GPU before posting, on rv770 hw unlike on r500 hw,
5229 * posting will perform necessary task to bring back GPU into good
5233 atom_asic_init(rdev
->mode_info
.atom_context
);
5235 /* init golden registers */
5236 evergreen_init_golden_registers(rdev
);
5238 rdev
->accel_working
= true;
5239 r
= evergreen_startup(rdev
);
5241 DRM_ERROR("evergreen startup failed on resume\n");
5242 rdev
->accel_working
= false;
5250 int evergreen_suspend(struct radeon_device
*rdev
)
5252 r600_audio_fini(rdev
);
5253 radeon_uvd_suspend(rdev
);
5255 r600_dma_stop(rdev
);
5256 r600_uvd_rbc_stop(rdev
);
5257 evergreen_irq_suspend(rdev
);
5258 radeon_wb_disable(rdev
);
5259 evergreen_pcie_gart_disable(rdev
);
5264 /* Plan is to move initialization in that function and use
5265 * helper function so that radeon_device_init pretty much
5266 * do nothing more than calling asic specific function. This
5267 * should also allow to remove a bunch of callback function
5270 int evergreen_init(struct radeon_device
*rdev
)
5275 if (!radeon_get_bios(rdev
)) {
5276 if (ASIC_IS_AVIVO(rdev
))
5279 /* Must be an ATOMBIOS */
5280 if (!rdev
->is_atom_bios
) {
5281 dev_err(rdev
->dev
, "Expecting atombios for evergreen GPU\n");
5284 r
= radeon_atombios_init(rdev
);
5287 /* reset the asic, the gfx blocks are often in a bad state
5288 * after the driver is unloaded or after a resume
5290 if (radeon_asic_reset(rdev
))
5291 dev_warn(rdev
->dev
, "GPU reset failed !\n");
5292 /* Post card if necessary */
5293 if (!radeon_card_posted(rdev
)) {
5295 dev_err(rdev
->dev
, "Card not posted and no BIOS - ignoring\n");
5298 DRM_INFO("GPU not posted. posting now...\n");
5299 atom_asic_init(rdev
->mode_info
.atom_context
);
5301 /* init golden registers */
5302 evergreen_init_golden_registers(rdev
);
5303 /* Initialize scratch registers */
5304 r600_scratch_init(rdev
);
5305 /* Initialize surface registers */
5306 radeon_surface_init(rdev
);
5307 /* Initialize clocks */
5308 radeon_get_clock_info(rdev
->ddev
);
5310 r
= radeon_fence_driver_init(rdev
);
5313 /* initialize AGP */
5314 if (rdev
->flags
& RADEON_IS_AGP
) {
5315 r
= radeon_agp_init(rdev
);
5317 radeon_agp_disable(rdev
);
5319 /* initialize memory controller */
5320 r
= evergreen_mc_init(rdev
);
5323 /* Memory manager */
5324 r
= radeon_bo_init(rdev
);
5328 rdev
->ring
[RADEON_RING_TYPE_GFX_INDEX
].ring_obj
= NULL
;
5329 r600_ring_init(rdev
, &rdev
->ring
[RADEON_RING_TYPE_GFX_INDEX
], 1024 * 1024);
5331 rdev
->ring
[R600_RING_TYPE_DMA_INDEX
].ring_obj
= NULL
;
5332 r600_ring_init(rdev
, &rdev
->ring
[R600_RING_TYPE_DMA_INDEX
], 64 * 1024);
5334 r
= radeon_uvd_init(rdev
);
5336 rdev
->ring
[R600_RING_TYPE_UVD_INDEX
].ring_obj
= NULL
;
5337 r600_ring_init(rdev
, &rdev
->ring
[R600_RING_TYPE_UVD_INDEX
],
5341 rdev
->ih
.ring_obj
= NULL
;
5342 r600_ih_ring_init(rdev
, 64 * 1024);
5344 r
= r600_pcie_gart_init(rdev
);
5348 rdev
->accel_working
= true;
5349 r
= evergreen_startup(rdev
);
5351 dev_err(rdev
->dev
, "disabling GPU acceleration\n");
5353 r600_dma_fini(rdev
);
5354 r600_irq_fini(rdev
);
5355 if (rdev
->flags
& RADEON_IS_IGP
)
5356 sumo_rlc_fini(rdev
);
5357 radeon_wb_fini(rdev
);
5358 radeon_ib_pool_fini(rdev
);
5359 radeon_irq_kms_fini(rdev
);
5360 evergreen_pcie_gart_fini(rdev
);
5361 rdev
->accel_working
= false;
5364 /* Don't start up if the MC ucode is missing on BTC parts.
5365 * The default clocks and voltages before the MC ucode
5366 * is loaded are not suffient for advanced operations.
5368 if (ASIC_IS_DCE5(rdev
)) {
5369 if (!rdev
->mc_fw
&& !(rdev
->flags
& RADEON_IS_IGP
)) {
5370 DRM_ERROR("radeon: MC ucode required for NI+.\n");
5378 void evergreen_fini(struct radeon_device
*rdev
)
5380 r600_audio_fini(rdev
);
5381 r600_blit_fini(rdev
);
5383 r600_dma_fini(rdev
);
5384 r600_irq_fini(rdev
);
5385 if (rdev
->flags
& RADEON_IS_IGP
)
5386 sumo_rlc_fini(rdev
);
5387 radeon_wb_fini(rdev
);
5388 radeon_ib_pool_fini(rdev
);
5389 radeon_irq_kms_fini(rdev
);
5390 evergreen_pcie_gart_fini(rdev
);
5391 radeon_uvd_fini(rdev
);
5392 r600_vram_scratch_fini(rdev
);
5393 radeon_gem_fini(rdev
);
5394 radeon_fence_driver_fini(rdev
);
5395 radeon_agp_fini(rdev
);
5396 radeon_bo_fini(rdev
);
5397 radeon_atombios_fini(rdev
);
5402 void evergreen_pcie_gen2_enable(struct radeon_device
*rdev
)
5404 u32 link_width_cntl
, speed_cntl
;
5406 if (radeon_pcie_gen2
== 0)
5409 if (rdev
->flags
& RADEON_IS_IGP
)
5412 if (!(rdev
->flags
& RADEON_IS_PCIE
))
5415 /* x2 cards have a special sequence */
5416 if (ASIC_IS_X2(rdev
))
5419 if ((rdev
->pdev
->bus
->max_bus_speed
!= PCIE_SPEED_5_0GT
) &&
5420 (rdev
->pdev
->bus
->max_bus_speed
!= PCIE_SPEED_8_0GT
))
5423 speed_cntl
= RREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL
);
5424 if (speed_cntl
& LC_CURRENT_DATA_RATE
) {
5425 DRM_INFO("PCIE gen 2 link speeds already enabled\n");
5429 DRM_INFO("enabling PCIE gen 2 link speeds, disable with radeon.pcie_gen2=0\n");
5431 if ((speed_cntl
& LC_OTHER_SIDE_EVER_SENT_GEN2
) ||
5432 (speed_cntl
& LC_OTHER_SIDE_SUPPORTS_GEN2
)) {
5434 link_width_cntl
= RREG32_PCIE_PORT(PCIE_LC_LINK_WIDTH_CNTL
);
5435 link_width_cntl
&= ~LC_UPCONFIGURE_DIS
;
5436 WREG32_PCIE_PORT(PCIE_LC_LINK_WIDTH_CNTL
, link_width_cntl
);
5438 speed_cntl
= RREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL
);
5439 speed_cntl
&= ~LC_TARGET_LINK_SPEED_OVERRIDE_EN
;
5440 WREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL
, speed_cntl
);
5442 speed_cntl
= RREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL
);
5443 speed_cntl
|= LC_CLR_FAILED_SPD_CHANGE_CNT
;
5444 WREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL
, speed_cntl
);
5446 speed_cntl
= RREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL
);
5447 speed_cntl
&= ~LC_CLR_FAILED_SPD_CHANGE_CNT
;
5448 WREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL
, speed_cntl
);
5450 speed_cntl
= RREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL
);
5451 speed_cntl
|= LC_GEN2_EN_STRAP
;
5452 WREG32_PCIE_PORT(PCIE_LC_SPEED_CNTL
, speed_cntl
);
5455 link_width_cntl
= RREG32_PCIE_PORT(PCIE_LC_LINK_WIDTH_CNTL
);
5456 /* XXX: only disable it if gen1 bridge vendor == 0x111d or 0x1106 */
5458 link_width_cntl
|= LC_UPCONFIGURE_DIS
;
5460 link_width_cntl
&= ~LC_UPCONFIGURE_DIS
;
5461 WREG32_PCIE_PORT(PCIE_LC_LINK_WIDTH_CNTL
, link_width_cntl
);