2 * Copyright 2008 Advanced Micro Devices, Inc.
3 * Copyright 2008 Red Hat Inc.
4 * Copyright 2009 Jerome Glisse.
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 * OTHER DEALINGS IN THE SOFTWARE.
26 #include <linux/kthread.h>
27 #include <linux/pci.h>
28 #include <linux/uaccess.h>
30 #include <drm/drm_debugfs.h>
35 * amdgpu_debugfs_add_files - Add simple debugfs entries
37 * @adev: Device to attach debugfs entries to
38 * @files: Array of function callbacks that respond to reads
39 * @nfiles: Number of callbacks to register
42 int amdgpu_debugfs_add_files(struct amdgpu_device
*adev
,
43 const struct drm_info_list
*files
,
48 for (i
= 0; i
< adev
->debugfs_count
; i
++) {
49 if (adev
->debugfs
[i
].files
== files
) {
50 /* Already registered */
55 i
= adev
->debugfs_count
+ 1;
56 if (i
> AMDGPU_DEBUGFS_MAX_COMPONENTS
) {
57 DRM_ERROR("Reached maximum number of debugfs components.\n");
58 DRM_ERROR("Report so we increase "
59 "AMDGPU_DEBUGFS_MAX_COMPONENTS.\n");
62 adev
->debugfs
[adev
->debugfs_count
].files
= files
;
63 adev
->debugfs
[adev
->debugfs_count
].num_files
= nfiles
;
64 adev
->debugfs_count
= i
;
65 #if defined(CONFIG_DEBUG_FS)
66 drm_debugfs_create_files(files
, nfiles
,
67 adev
->ddev
->primary
->debugfs_root
,
73 #if defined(CONFIG_DEBUG_FS)
76 * amdgpu_debugfs_process_reg_op - Handle MMIO register reads/writes
78 * @read: True if reading
79 * @f: open file handle
80 * @buf: User buffer to write/read to
81 * @size: Number of bytes to write/read
82 * @pos: Offset to seek to
84 * This debugfs entry has special meaning on the offset being sought.
85 * Various bits have different meanings:
87 * Bit 62: Indicates a GRBM bank switch is needed
88 * Bit 61: Indicates a SRBM bank switch is needed (implies bit 62 is
90 * Bits 24..33: The SE or ME selector if needed
91 * Bits 34..43: The SH (or SA) or PIPE selector if needed
92 * Bits 44..53: The INSTANCE (or CU/WGP) or QUEUE selector if needed
94 * Bit 23: Indicates that the PM power gating lock should be held
95 * This is necessary to read registers that might be
96 * unreliable during a power gating transistion.
98 * The lower bits are the BYTE offset of the register to read. This
99 * allows reading multiple registers in a single call and having
100 * the returned size reflect that.
102 static int amdgpu_debugfs_process_reg_op(bool read
, struct file
*f
,
103 char __user
*buf
, size_t size
, loff_t
*pos
)
105 struct amdgpu_device
*adev
= file_inode(f
)->i_private
;
108 bool pm_pg_lock
, use_bank
, use_ring
;
109 unsigned instance_bank
, sh_bank
, se_bank
, me
, pipe
, queue
, vmid
;
111 pm_pg_lock
= use_bank
= use_ring
= false;
112 instance_bank
= sh_bank
= se_bank
= me
= pipe
= queue
= vmid
= 0;
114 if (size
& 0x3 || *pos
& 0x3 ||
115 ((*pos
& (1ULL << 62)) && (*pos
& (1ULL << 61))))
118 /* are we reading registers for which a PG lock is necessary? */
119 pm_pg_lock
= (*pos
>> 23) & 1;
121 if (*pos
& (1ULL << 62)) {
122 se_bank
= (*pos
& GENMASK_ULL(33, 24)) >> 24;
123 sh_bank
= (*pos
& GENMASK_ULL(43, 34)) >> 34;
124 instance_bank
= (*pos
& GENMASK_ULL(53, 44)) >> 44;
126 if (se_bank
== 0x3FF)
127 se_bank
= 0xFFFFFFFF;
128 if (sh_bank
== 0x3FF)
129 sh_bank
= 0xFFFFFFFF;
130 if (instance_bank
== 0x3FF)
131 instance_bank
= 0xFFFFFFFF;
133 } else if (*pos
& (1ULL << 61)) {
135 me
= (*pos
& GENMASK_ULL(33, 24)) >> 24;
136 pipe
= (*pos
& GENMASK_ULL(43, 34)) >> 34;
137 queue
= (*pos
& GENMASK_ULL(53, 44)) >> 44;
138 vmid
= (*pos
& GENMASK_ULL(58, 54)) >> 54;
142 use_bank
= use_ring
= 0;
145 *pos
&= (1UL << 22) - 1;
148 if ((sh_bank
!= 0xFFFFFFFF && sh_bank
>= adev
->gfx
.config
.max_sh_per_se
) ||
149 (se_bank
!= 0xFFFFFFFF && se_bank
>= adev
->gfx
.config
.max_shader_engines
))
151 mutex_lock(&adev
->grbm_idx_mutex
);
152 amdgpu_gfx_select_se_sh(adev
, se_bank
,
153 sh_bank
, instance_bank
);
154 } else if (use_ring
) {
155 mutex_lock(&adev
->srbm_mutex
);
156 amdgpu_gfx_select_me_pipe_q(adev
, me
, pipe
, queue
, vmid
);
160 mutex_lock(&adev
->pm
.mutex
);
166 value
= RREG32(*pos
>> 2);
167 r
= put_user(value
, (uint32_t *)buf
);
169 r
= get_user(value
, (uint32_t *)buf
);
171 WREG32(*pos
>> 2, value
);
186 amdgpu_gfx_select_se_sh(adev
, 0xffffffff, 0xffffffff, 0xffffffff);
187 mutex_unlock(&adev
->grbm_idx_mutex
);
188 } else if (use_ring
) {
189 amdgpu_gfx_select_me_pipe_q(adev
, 0, 0, 0, 0);
190 mutex_unlock(&adev
->srbm_mutex
);
194 mutex_unlock(&adev
->pm
.mutex
);
200 * amdgpu_debugfs_regs_read - Callback for reading MMIO registers
202 static ssize_t
amdgpu_debugfs_regs_read(struct file
*f
, char __user
*buf
,
203 size_t size
, loff_t
*pos
)
205 return amdgpu_debugfs_process_reg_op(true, f
, buf
, size
, pos
);
209 * amdgpu_debugfs_regs_write - Callback for writing MMIO registers
211 static ssize_t
amdgpu_debugfs_regs_write(struct file
*f
, const char __user
*buf
,
212 size_t size
, loff_t
*pos
)
214 return amdgpu_debugfs_process_reg_op(false, f
, (char __user
*)buf
, size
, pos
);
219 * amdgpu_debugfs_regs_pcie_read - Read from a PCIE register
221 * @f: open file handle
222 * @buf: User buffer to store read data in
223 * @size: Number of bytes to read
224 * @pos: Offset to seek to
226 * The lower bits are the BYTE offset of the register to read. This
227 * allows reading multiple registers in a single call and having
228 * the returned size reflect that.
230 static ssize_t
amdgpu_debugfs_regs_pcie_read(struct file
*f
, char __user
*buf
,
231 size_t size
, loff_t
*pos
)
233 struct amdgpu_device
*adev
= file_inode(f
)->i_private
;
237 if (size
& 0x3 || *pos
& 0x3)
243 value
= RREG32_PCIE(*pos
>> 2);
244 r
= put_user(value
, (uint32_t *)buf
);
258 * amdgpu_debugfs_regs_pcie_write - Write to a PCIE register
260 * @f: open file handle
261 * @buf: User buffer to write data from
262 * @size: Number of bytes to write
263 * @pos: Offset to seek to
265 * The lower bits are the BYTE offset of the register to write. This
266 * allows writing multiple registers in a single call and having
267 * the returned size reflect that.
269 static ssize_t
amdgpu_debugfs_regs_pcie_write(struct file
*f
, const char __user
*buf
,
270 size_t size
, loff_t
*pos
)
272 struct amdgpu_device
*adev
= file_inode(f
)->i_private
;
276 if (size
& 0x3 || *pos
& 0x3)
282 r
= get_user(value
, (uint32_t *)buf
);
286 WREG32_PCIE(*pos
>> 2, value
);
298 * amdgpu_debugfs_regs_didt_read - Read from a DIDT register
300 * @f: open file handle
301 * @buf: User buffer to store read data in
302 * @size: Number of bytes to read
303 * @pos: Offset to seek to
305 * The lower bits are the BYTE offset of the register to read. This
306 * allows reading multiple registers in a single call and having
307 * the returned size reflect that.
309 static ssize_t
amdgpu_debugfs_regs_didt_read(struct file
*f
, char __user
*buf
,
310 size_t size
, loff_t
*pos
)
312 struct amdgpu_device
*adev
= file_inode(f
)->i_private
;
316 if (size
& 0x3 || *pos
& 0x3)
322 value
= RREG32_DIDT(*pos
>> 2);
323 r
= put_user(value
, (uint32_t *)buf
);
337 * amdgpu_debugfs_regs_didt_write - Write to a DIDT register
339 * @f: open file handle
340 * @buf: User buffer to write data from
341 * @size: Number of bytes to write
342 * @pos: Offset to seek to
344 * The lower bits are the BYTE offset of the register to write. This
345 * allows writing multiple registers in a single call and having
346 * the returned size reflect that.
348 static ssize_t
amdgpu_debugfs_regs_didt_write(struct file
*f
, const char __user
*buf
,
349 size_t size
, loff_t
*pos
)
351 struct amdgpu_device
*adev
= file_inode(f
)->i_private
;
355 if (size
& 0x3 || *pos
& 0x3)
361 r
= get_user(value
, (uint32_t *)buf
);
365 WREG32_DIDT(*pos
>> 2, value
);
377 * amdgpu_debugfs_regs_smc_read - Read from a SMC register
379 * @f: open file handle
380 * @buf: User buffer to store read data in
381 * @size: Number of bytes to read
382 * @pos: Offset to seek to
384 * The lower bits are the BYTE offset of the register to read. This
385 * allows reading multiple registers in a single call and having
386 * the returned size reflect that.
388 static ssize_t
amdgpu_debugfs_regs_smc_read(struct file
*f
, char __user
*buf
,
389 size_t size
, loff_t
*pos
)
391 struct amdgpu_device
*adev
= file_inode(f
)->i_private
;
395 if (size
& 0x3 || *pos
& 0x3)
401 value
= RREG32_SMC(*pos
);
402 r
= put_user(value
, (uint32_t *)buf
);
416 * amdgpu_debugfs_regs_smc_write - Write to a SMC register
418 * @f: open file handle
419 * @buf: User buffer to write data from
420 * @size: Number of bytes to write
421 * @pos: Offset to seek to
423 * The lower bits are the BYTE offset of the register to write. This
424 * allows writing multiple registers in a single call and having
425 * the returned size reflect that.
427 static ssize_t
amdgpu_debugfs_regs_smc_write(struct file
*f
, const char __user
*buf
,
428 size_t size
, loff_t
*pos
)
430 struct amdgpu_device
*adev
= file_inode(f
)->i_private
;
434 if (size
& 0x3 || *pos
& 0x3)
440 r
= get_user(value
, (uint32_t *)buf
);
444 WREG32_SMC(*pos
, value
);
456 * amdgpu_debugfs_gca_config_read - Read from gfx config data
458 * @f: open file handle
459 * @buf: User buffer to store read data in
460 * @size: Number of bytes to read
461 * @pos: Offset to seek to
463 * This file is used to access configuration data in a somewhat
464 * stable fashion. The format is a series of DWORDs with the first
465 * indicating which revision it is. New content is appended to the
466 * end so that older software can still read the data.
469 static ssize_t
amdgpu_debugfs_gca_config_read(struct file
*f
, char __user
*buf
,
470 size_t size
, loff_t
*pos
)
472 struct amdgpu_device
*adev
= file_inode(f
)->i_private
;
475 uint32_t *config
, no_regs
= 0;
477 if (size
& 0x3 || *pos
& 0x3)
480 config
= kmalloc_array(256, sizeof(*config
), GFP_KERNEL
);
484 /* version, increment each time something is added */
485 config
[no_regs
++] = 3;
486 config
[no_regs
++] = adev
->gfx
.config
.max_shader_engines
;
487 config
[no_regs
++] = adev
->gfx
.config
.max_tile_pipes
;
488 config
[no_regs
++] = adev
->gfx
.config
.max_cu_per_sh
;
489 config
[no_regs
++] = adev
->gfx
.config
.max_sh_per_se
;
490 config
[no_regs
++] = adev
->gfx
.config
.max_backends_per_se
;
491 config
[no_regs
++] = adev
->gfx
.config
.max_texture_channel_caches
;
492 config
[no_regs
++] = adev
->gfx
.config
.max_gprs
;
493 config
[no_regs
++] = adev
->gfx
.config
.max_gs_threads
;
494 config
[no_regs
++] = adev
->gfx
.config
.max_hw_contexts
;
495 config
[no_regs
++] = adev
->gfx
.config
.sc_prim_fifo_size_frontend
;
496 config
[no_regs
++] = adev
->gfx
.config
.sc_prim_fifo_size_backend
;
497 config
[no_regs
++] = adev
->gfx
.config
.sc_hiz_tile_fifo_size
;
498 config
[no_regs
++] = adev
->gfx
.config
.sc_earlyz_tile_fifo_size
;
499 config
[no_regs
++] = adev
->gfx
.config
.num_tile_pipes
;
500 config
[no_regs
++] = adev
->gfx
.config
.backend_enable_mask
;
501 config
[no_regs
++] = adev
->gfx
.config
.mem_max_burst_length_bytes
;
502 config
[no_regs
++] = adev
->gfx
.config
.mem_row_size_in_kb
;
503 config
[no_regs
++] = adev
->gfx
.config
.shader_engine_tile_size
;
504 config
[no_regs
++] = adev
->gfx
.config
.num_gpus
;
505 config
[no_regs
++] = adev
->gfx
.config
.multi_gpu_tile_size
;
506 config
[no_regs
++] = adev
->gfx
.config
.mc_arb_ramcfg
;
507 config
[no_regs
++] = adev
->gfx
.config
.gb_addr_config
;
508 config
[no_regs
++] = adev
->gfx
.config
.num_rbs
;
511 config
[no_regs
++] = adev
->rev_id
;
512 config
[no_regs
++] = adev
->pg_flags
;
513 config
[no_regs
++] = adev
->cg_flags
;
516 config
[no_regs
++] = adev
->family
;
517 config
[no_regs
++] = adev
->external_rev_id
;
520 config
[no_regs
++] = adev
->pdev
->device
;
521 config
[no_regs
++] = adev
->pdev
->revision
;
522 config
[no_regs
++] = adev
->pdev
->subsystem_device
;
523 config
[no_regs
++] = adev
->pdev
->subsystem_vendor
;
525 while (size
&& (*pos
< no_regs
* 4)) {
528 value
= config
[*pos
>> 2];
529 r
= put_user(value
, (uint32_t *)buf
);
546 * amdgpu_debugfs_sensor_read - Read from the powerplay sensors
548 * @f: open file handle
549 * @buf: User buffer to store read data in
550 * @size: Number of bytes to read
551 * @pos: Offset to seek to
553 * The offset is treated as the BYTE address of one of the sensors
554 * enumerated in amd/include/kgd_pp_interface.h under the
555 * 'amd_pp_sensors' enumeration. For instance to read the UVD VCLK
556 * you would use the offset 3 * 4 = 12.
558 static ssize_t
amdgpu_debugfs_sensor_read(struct file
*f
, char __user
*buf
,
559 size_t size
, loff_t
*pos
)
561 struct amdgpu_device
*adev
= file_inode(f
)->i_private
;
562 int idx
, x
, outsize
, r
, valuesize
;
565 if (size
& 3 || *pos
& 0x3)
568 if (!adev
->pm
.dpm_enabled
)
571 /* convert offset to sensor number */
574 valuesize
= sizeof(values
);
575 r
= amdgpu_dpm_read_sensor(adev
, idx
, &values
[0], &valuesize
);
579 if (size
> valuesize
)
586 r
= put_user(values
[x
++], (int32_t *)buf
);
593 return !r
? outsize
: r
;
596 /** amdgpu_debugfs_wave_read - Read WAVE STATUS data
598 * @f: open file handle
599 * @buf: User buffer to store read data in
600 * @size: Number of bytes to read
601 * @pos: Offset to seek to
603 * The offset being sought changes which wave that the status data
604 * will be returned for. The bits are used as follows:
606 * Bits 0..6: Byte offset into data
607 * Bits 7..14: SE selector
608 * Bits 15..22: SH/SA selector
609 * Bits 23..30: CU/{WGP+SIMD} selector
610 * Bits 31..36: WAVE ID selector
611 * Bits 37..44: SIMD ID selector
613 * The returned data begins with one DWORD of version information
614 * Followed by WAVE STATUS registers relevant to the GFX IP version
615 * being used. See gfx_v8_0_read_wave_data() for an example output.
617 static ssize_t
amdgpu_debugfs_wave_read(struct file
*f
, char __user
*buf
,
618 size_t size
, loff_t
*pos
)
620 struct amdgpu_device
*adev
= f
->f_inode
->i_private
;
623 uint32_t offset
, se
, sh
, cu
, wave
, simd
, data
[32];
625 if (size
& 3 || *pos
& 3)
629 offset
= (*pos
& GENMASK_ULL(6, 0));
630 se
= (*pos
& GENMASK_ULL(14, 7)) >> 7;
631 sh
= (*pos
& GENMASK_ULL(22, 15)) >> 15;
632 cu
= (*pos
& GENMASK_ULL(30, 23)) >> 23;
633 wave
= (*pos
& GENMASK_ULL(36, 31)) >> 31;
634 simd
= (*pos
& GENMASK_ULL(44, 37)) >> 37;
636 /* switch to the specific se/sh/cu */
637 mutex_lock(&adev
->grbm_idx_mutex
);
638 amdgpu_gfx_select_se_sh(adev
, se
, sh
, cu
);
641 if (adev
->gfx
.funcs
->read_wave_data
)
642 adev
->gfx
.funcs
->read_wave_data(adev
, simd
, wave
, data
, &x
);
644 amdgpu_gfx_select_se_sh(adev
, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
645 mutex_unlock(&adev
->grbm_idx_mutex
);
650 while (size
&& (offset
< x
* 4)) {
653 value
= data
[offset
>> 2];
654 r
= put_user(value
, (uint32_t *)buf
);
667 /** amdgpu_debugfs_gpr_read - Read wave gprs
669 * @f: open file handle
670 * @buf: User buffer to store read data in
671 * @size: Number of bytes to read
672 * @pos: Offset to seek to
674 * The offset being sought changes which wave that the status data
675 * will be returned for. The bits are used as follows:
677 * Bits 0..11: Byte offset into data
678 * Bits 12..19: SE selector
679 * Bits 20..27: SH/SA selector
680 * Bits 28..35: CU/{WGP+SIMD} selector
681 * Bits 36..43: WAVE ID selector
682 * Bits 37..44: SIMD ID selector
683 * Bits 52..59: Thread selector
684 * Bits 60..61: Bank selector (VGPR=0,SGPR=1)
686 * The return data comes from the SGPR or VGPR register bank for
687 * the selected operational unit.
689 static ssize_t
amdgpu_debugfs_gpr_read(struct file
*f
, char __user
*buf
,
690 size_t size
, loff_t
*pos
)
692 struct amdgpu_device
*adev
= f
->f_inode
->i_private
;
695 uint32_t offset
, se
, sh
, cu
, wave
, simd
, thread
, bank
, *data
;
697 if (size
& 3 || *pos
& 3)
701 offset
= *pos
& GENMASK_ULL(11, 0);
702 se
= (*pos
& GENMASK_ULL(19, 12)) >> 12;
703 sh
= (*pos
& GENMASK_ULL(27, 20)) >> 20;
704 cu
= (*pos
& GENMASK_ULL(35, 28)) >> 28;
705 wave
= (*pos
& GENMASK_ULL(43, 36)) >> 36;
706 simd
= (*pos
& GENMASK_ULL(51, 44)) >> 44;
707 thread
= (*pos
& GENMASK_ULL(59, 52)) >> 52;
708 bank
= (*pos
& GENMASK_ULL(61, 60)) >> 60;
710 data
= kmalloc_array(1024, sizeof(*data
), GFP_KERNEL
);
714 /* switch to the specific se/sh/cu */
715 mutex_lock(&adev
->grbm_idx_mutex
);
716 amdgpu_gfx_select_se_sh(adev
, se
, sh
, cu
);
719 if (adev
->gfx
.funcs
->read_wave_vgprs
)
720 adev
->gfx
.funcs
->read_wave_vgprs(adev
, simd
, wave
, thread
, offset
, size
>>2, data
);
722 if (adev
->gfx
.funcs
->read_wave_sgprs
)
723 adev
->gfx
.funcs
->read_wave_sgprs(adev
, simd
, wave
, offset
, size
>>2, data
);
726 amdgpu_gfx_select_se_sh(adev
, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
727 mutex_unlock(&adev
->grbm_idx_mutex
);
732 value
= data
[offset
++];
733 r
= put_user(value
, (uint32_t *)buf
);
749 static const struct file_operations amdgpu_debugfs_regs_fops
= {
750 .owner
= THIS_MODULE
,
751 .read
= amdgpu_debugfs_regs_read
,
752 .write
= amdgpu_debugfs_regs_write
,
753 .llseek
= default_llseek
755 static const struct file_operations amdgpu_debugfs_regs_didt_fops
= {
756 .owner
= THIS_MODULE
,
757 .read
= amdgpu_debugfs_regs_didt_read
,
758 .write
= amdgpu_debugfs_regs_didt_write
,
759 .llseek
= default_llseek
761 static const struct file_operations amdgpu_debugfs_regs_pcie_fops
= {
762 .owner
= THIS_MODULE
,
763 .read
= amdgpu_debugfs_regs_pcie_read
,
764 .write
= amdgpu_debugfs_regs_pcie_write
,
765 .llseek
= default_llseek
767 static const struct file_operations amdgpu_debugfs_regs_smc_fops
= {
768 .owner
= THIS_MODULE
,
769 .read
= amdgpu_debugfs_regs_smc_read
,
770 .write
= amdgpu_debugfs_regs_smc_write
,
771 .llseek
= default_llseek
774 static const struct file_operations amdgpu_debugfs_gca_config_fops
= {
775 .owner
= THIS_MODULE
,
776 .read
= amdgpu_debugfs_gca_config_read
,
777 .llseek
= default_llseek
780 static const struct file_operations amdgpu_debugfs_sensors_fops
= {
781 .owner
= THIS_MODULE
,
782 .read
= amdgpu_debugfs_sensor_read
,
783 .llseek
= default_llseek
786 static const struct file_operations amdgpu_debugfs_wave_fops
= {
787 .owner
= THIS_MODULE
,
788 .read
= amdgpu_debugfs_wave_read
,
789 .llseek
= default_llseek
791 static const struct file_operations amdgpu_debugfs_gpr_fops
= {
792 .owner
= THIS_MODULE
,
793 .read
= amdgpu_debugfs_gpr_read
,
794 .llseek
= default_llseek
797 static const struct file_operations
*debugfs_regs
[] = {
798 &amdgpu_debugfs_regs_fops
,
799 &amdgpu_debugfs_regs_didt_fops
,
800 &amdgpu_debugfs_regs_pcie_fops
,
801 &amdgpu_debugfs_regs_smc_fops
,
802 &amdgpu_debugfs_gca_config_fops
,
803 &amdgpu_debugfs_sensors_fops
,
804 &amdgpu_debugfs_wave_fops
,
805 &amdgpu_debugfs_gpr_fops
,
808 static const char *debugfs_regs_names
[] = {
820 * amdgpu_debugfs_regs_init - Initialize debugfs entries that provide
823 * @adev: The device to attach the debugfs entries to
825 int amdgpu_debugfs_regs_init(struct amdgpu_device
*adev
)
827 struct drm_minor
*minor
= adev
->ddev
->primary
;
828 struct dentry
*ent
, *root
= minor
->debugfs_root
;
831 for (i
= 0; i
< ARRAY_SIZE(debugfs_regs
); i
++) {
832 ent
= debugfs_create_file(debugfs_regs_names
[i
],
833 S_IFREG
| S_IRUGO
, root
,
834 adev
, debugfs_regs
[i
]);
835 if (!i
&& !IS_ERR_OR_NULL(ent
))
836 i_size_write(ent
->d_inode
, adev
->rmmio_size
);
837 adev
->debugfs_regs
[i
] = ent
;
843 void amdgpu_debugfs_regs_cleanup(struct amdgpu_device
*adev
)
847 for (i
= 0; i
< ARRAY_SIZE(debugfs_regs
); i
++) {
848 if (adev
->debugfs_regs
[i
]) {
849 debugfs_remove(adev
->debugfs_regs
[i
]);
850 adev
->debugfs_regs
[i
] = NULL
;
855 static int amdgpu_debugfs_test_ib(struct seq_file
*m
, void *data
)
857 struct drm_info_node
*node
= (struct drm_info_node
*) m
->private;
858 struct drm_device
*dev
= node
->minor
->dev
;
859 struct amdgpu_device
*adev
= dev
->dev_private
;
862 /* hold on the scheduler */
863 for (i
= 0; i
< AMDGPU_MAX_RINGS
; i
++) {
864 struct amdgpu_ring
*ring
= adev
->rings
[i
];
866 if (!ring
|| !ring
->sched
.thread
)
868 kthread_park(ring
->sched
.thread
);
871 seq_printf(m
, "run ib test:\n");
872 r
= amdgpu_ib_ring_tests(adev
);
874 seq_printf(m
, "ib ring tests failed (%d).\n", r
);
876 seq_printf(m
, "ib ring tests passed.\n");
878 /* go on the scheduler */
879 for (i
= 0; i
< AMDGPU_MAX_RINGS
; i
++) {
880 struct amdgpu_ring
*ring
= adev
->rings
[i
];
882 if (!ring
|| !ring
->sched
.thread
)
884 kthread_unpark(ring
->sched
.thread
);
890 static int amdgpu_debugfs_get_vbios_dump(struct seq_file
*m
, void *data
)
892 struct drm_info_node
*node
= (struct drm_info_node
*) m
->private;
893 struct drm_device
*dev
= node
->minor
->dev
;
894 struct amdgpu_device
*adev
= dev
->dev_private
;
896 seq_write(m
, adev
->bios
, adev
->bios_size
);
900 static int amdgpu_debugfs_evict_vram(struct seq_file
*m
, void *data
)
902 struct drm_info_node
*node
= (struct drm_info_node
*)m
->private;
903 struct drm_device
*dev
= node
->minor
->dev
;
904 struct amdgpu_device
*adev
= dev
->dev_private
;
906 seq_printf(m
, "(%d)\n", amdgpu_bo_evict_vram(adev
));
910 static int amdgpu_debugfs_evict_gtt(struct seq_file
*m
, void *data
)
912 struct drm_info_node
*node
= (struct drm_info_node
*)m
->private;
913 struct drm_device
*dev
= node
->minor
->dev
;
914 struct amdgpu_device
*adev
= dev
->dev_private
;
916 seq_printf(m
, "(%d)\n", ttm_bo_evict_mm(&adev
->mman
.bdev
, TTM_PL_TT
));
920 static const struct drm_info_list amdgpu_debugfs_list
[] = {
921 {"amdgpu_vbios", amdgpu_debugfs_get_vbios_dump
},
922 {"amdgpu_test_ib", &amdgpu_debugfs_test_ib
},
923 {"amdgpu_evict_vram", &amdgpu_debugfs_evict_vram
},
924 {"amdgpu_evict_gtt", &amdgpu_debugfs_evict_gtt
},
927 static void amdgpu_ib_preempt_fences_swap(struct amdgpu_ring
*ring
,
928 struct dma_fence
**fences
)
930 struct amdgpu_fence_driver
*drv
= &ring
->fence_drv
;
931 uint32_t sync_seq
, last_seq
;
933 last_seq
= atomic_read(&ring
->fence_drv
.last_seq
);
934 sync_seq
= ring
->fence_drv
.sync_seq
;
936 last_seq
&= drv
->num_fences_mask
;
937 sync_seq
&= drv
->num_fences_mask
;
940 struct dma_fence
*fence
, **ptr
;
943 last_seq
&= drv
->num_fences_mask
;
944 ptr
= &drv
->fences
[last_seq
];
946 fence
= rcu_dereference_protected(*ptr
, 1);
947 RCU_INIT_POINTER(*ptr
, NULL
);
952 fences
[last_seq
] = fence
;
954 } while (last_seq
!= sync_seq
);
957 static void amdgpu_ib_preempt_signal_fences(struct dma_fence
**fences
,
961 struct dma_fence
*fence
;
963 for (i
= 0; i
< length
; i
++) {
967 dma_fence_signal(fence
);
968 dma_fence_put(fence
);
972 static void amdgpu_ib_preempt_job_recovery(struct drm_gpu_scheduler
*sched
)
974 struct drm_sched_job
*s_job
;
975 struct dma_fence
*fence
;
977 spin_lock(&sched
->job_list_lock
);
978 list_for_each_entry(s_job
, &sched
->ring_mirror_list
, node
) {
979 fence
= sched
->ops
->run_job(s_job
);
980 dma_fence_put(fence
);
982 spin_unlock(&sched
->job_list_lock
);
985 static void amdgpu_ib_preempt_mark_partial_job(struct amdgpu_ring
*ring
)
987 struct amdgpu_job
*job
;
988 struct drm_sched_job
*s_job
;
989 uint32_t preempt_seq
;
990 struct dma_fence
*fence
, **ptr
;
991 struct amdgpu_fence_driver
*drv
= &ring
->fence_drv
;
992 struct drm_gpu_scheduler
*sched
= &ring
->sched
;
994 if (ring
->funcs
->type
!= AMDGPU_RING_TYPE_GFX
)
997 preempt_seq
= le32_to_cpu(*(drv
->cpu_addr
+ 2));
998 if (preempt_seq
<= atomic_read(&drv
->last_seq
))
1001 preempt_seq
&= drv
->num_fences_mask
;
1002 ptr
= &drv
->fences
[preempt_seq
];
1003 fence
= rcu_dereference_protected(*ptr
, 1);
1005 spin_lock(&sched
->job_list_lock
);
1006 list_for_each_entry(s_job
, &sched
->ring_mirror_list
, node
) {
1007 job
= to_amdgpu_job(s_job
);
1008 if (job
->fence
== fence
)
1009 /* mark the job as preempted */
1010 job
->preemption_status
|= AMDGPU_IB_PREEMPTED
;
1012 spin_unlock(&sched
->job_list_lock
);
1015 static int amdgpu_debugfs_ib_preempt(void *data
, u64 val
)
1017 int r
, resched
, length
;
1018 struct amdgpu_ring
*ring
;
1019 struct dma_fence
**fences
= NULL
;
1020 struct amdgpu_device
*adev
= (struct amdgpu_device
*)data
;
1022 if (val
>= AMDGPU_MAX_RINGS
)
1025 ring
= adev
->rings
[val
];
1027 if (!ring
|| !ring
->funcs
->preempt_ib
|| !ring
->sched
.thread
)
1030 /* the last preemption failed */
1031 if (ring
->trail_seq
!= le32_to_cpu(*ring
->trail_fence_cpu_addr
))
1034 length
= ring
->fence_drv
.num_fences_mask
+ 1;
1035 fences
= kcalloc(length
, sizeof(void *), GFP_KERNEL
);
1039 /* stop the scheduler */
1040 kthread_park(ring
->sched
.thread
);
1042 resched
= ttm_bo_lock_delayed_workqueue(&adev
->mman
.bdev
);
1044 /* preempt the IB */
1045 r
= amdgpu_ring_preempt_ib(ring
);
1047 DRM_WARN("failed to preempt ring %d\n", ring
->idx
);
1051 amdgpu_fence_process(ring
);
1053 if (atomic_read(&ring
->fence_drv
.last_seq
) !=
1054 ring
->fence_drv
.sync_seq
) {
1055 DRM_INFO("ring %d was preempted\n", ring
->idx
);
1057 amdgpu_ib_preempt_mark_partial_job(ring
);
1059 /* swap out the old fences */
1060 amdgpu_ib_preempt_fences_swap(ring
, fences
);
1062 amdgpu_fence_driver_force_completion(ring
);
1064 /* resubmit unfinished jobs */
1065 amdgpu_ib_preempt_job_recovery(&ring
->sched
);
1067 /* wait for jobs finished */
1068 amdgpu_fence_wait_empty(ring
);
1070 /* signal the old fences */
1071 amdgpu_ib_preempt_signal_fences(fences
, length
);
1075 /* restart the scheduler */
1076 kthread_unpark(ring
->sched
.thread
);
1078 ttm_bo_unlock_delayed_workqueue(&adev
->mman
.bdev
, resched
);
1086 DEFINE_SIMPLE_ATTRIBUTE(fops_ib_preempt
, NULL
,
1087 amdgpu_debugfs_ib_preempt
, "%llu\n");
1089 int amdgpu_debugfs_init(struct amdgpu_device
*adev
)
1091 adev
->debugfs_preempt
=
1092 debugfs_create_file("amdgpu_preempt_ib", 0600,
1093 adev
->ddev
->primary
->debugfs_root
,
1094 (void *)adev
, &fops_ib_preempt
);
1095 if (!(adev
->debugfs_preempt
)) {
1096 DRM_ERROR("unable to create amdgpu_preempt_ib debugsfs file\n");
1100 return amdgpu_debugfs_add_files(adev
, amdgpu_debugfs_list
,
1101 ARRAY_SIZE(amdgpu_debugfs_list
));
1104 void amdgpu_debugfs_preempt_cleanup(struct amdgpu_device
*adev
)
1106 if (adev
->debugfs_preempt
)
1107 debugfs_remove(adev
->debugfs_preempt
);
1111 int amdgpu_debugfs_init(struct amdgpu_device
*adev
)
1115 void amdgpu_debugfs_preempt_cleanup(struct amdgpu_device
*adev
) { }
1116 int amdgpu_debugfs_regs_init(struct amdgpu_device
*adev
)
1120 void amdgpu_debugfs_regs_cleanup(struct amdgpu_device
*adev
) { }