drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c

   1 /*
   2  * Copyright 2008 Advanced Micro Devices, Inc.
   3  * Copyright 2008 Red Hat Inc.
   4  * Copyright 2009 Jerome Glisse.
   5  *
   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:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  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.
  23  *
  24  */
  25
  26 #include <linux/kthread.h>
  27 #include <drm/drmP.h>
  28 #include <linux/debugfs.h>
  29 #include "amdgpu.h"
  30
  31 /**
  32  * amdgpu_debugfs_add_files - Add simple debugfs entries
  33  *
  34  * @adev:  Device to attach debugfs entries to
  35  * @files:  Array of function callbacks that respond to reads
  36  * @nfiles: Number of callbacks to register
  37  *
  38  */
  39 int amdgpu_debugfs_add_files(struct amdgpu_device *adev,
  40                              const struct drm_info_list *files,
  41                              unsigned nfiles)
  42 {
  43         unsigned i;
  44
  45         for (i = 0; i < adev->debugfs_count; i++) {
  46                 if (adev->debugfs[i].files == files) {
  47                         /* Already registered */
  48                         return 0;
  49                 }
  50         }
  51
  52         i = adev->debugfs_count + 1;
  53         if (i > AMDGPU_DEBUGFS_MAX_COMPONENTS) {
  54                 DRM_ERROR("Reached maximum number of debugfs components.\n");
  55                 DRM_ERROR("Report so we increase "
  56                           "AMDGPU_DEBUGFS_MAX_COMPONENTS.\n");
  57                 return -EINVAL;
  58         }
  59         adev->debugfs[adev->debugfs_count].files = files;
  60         adev->debugfs[adev->debugfs_count].num_files = nfiles;
  61         adev->debugfs_count = i;
  62 #if defined(CONFIG_DEBUG_FS)
  63         drm_debugfs_create_files(files, nfiles,
  64                                  adev->ddev->primary->debugfs_root,
  65                                  adev->ddev->primary);
  66 #endif
  67         return 0;
  68 }
  69
  70 #if defined(CONFIG_DEBUG_FS)
  71
  72 /**
  73  * amdgpu_debugfs_process_reg_op - Handle MMIO register reads/writes
  74  *
  75  * @read: True if reading
  76  * @f: open file handle
  77  * @buf: User buffer to write/read to
  78  * @size: Number of bytes to write/read
  79  * @pos:  Offset to seek to
  80  *
  81  * This debugfs entry has special meaning on the offset being sought.
  82  * Various bits have different meanings:
  83  *
  84  * Bit 62:  Indicates a GRBM bank switch is needed
  85  * Bit 61:  Indicates a SRBM bank switch is needed (implies bit 62 is
  86  *                      zero)
  87  * Bits 24..33: The SE or ME selector if needed
  88  * Bits 34..43: The SH (or SA) or PIPE selector if needed
  89  * Bits 44..53: The INSTANCE (or CU/WGP) or QUEUE selector if needed
  90  *
  91  * Bit 23:  Indicates that the PM power gating lock should be held
  92  *                      This is necessary to read registers that might be
  93  *                      unreliable during a power gating transistion.
  94  *
  95  * The lower bits are the BYTE offset of the register to read.  This
  96  * allows reading multiple registers in a single call and having
  97  * the returned size reflect that.
  98  */
  99 static int  amdgpu_debugfs_process_reg_op(bool read, struct file *f,
 100                 char __user *buf, size_t size, loff_t *pos)
 101 {
 102         struct amdgpu_device *adev = file_inode(f)->i_private;
 103         ssize_t result = 0;
 104         int r;
 105         bool pm_pg_lock, use_bank, use_ring;
 106         unsigned instance_bank, sh_bank, se_bank, me, pipe, queue;
 107
 108         pm_pg_lock = use_bank = use_ring = false;
 109         instance_bank = sh_bank = se_bank = me = pipe = queue = 0;
 110
 111         if (size & 0x3 || *pos & 0x3 ||
 112                         ((*pos & (1ULL << 62)) && (*pos & (1ULL << 61))))
 113                 return -EINVAL;
 114
 115         /* are we reading registers for which a PG lock is necessary? */
 116         pm_pg_lock = (*pos >> 23) & 1;
 117
 118         if (*pos & (1ULL << 62)) {
 119                 se_bank = (*pos & GENMASK_ULL(33, 24)) >> 24;
 120                 sh_bank = (*pos & GENMASK_ULL(43, 34)) >> 34;
 121                 instance_bank = (*pos & GENMASK_ULL(53, 44)) >> 44;
 122
 123                 if (se_bank == 0x3FF)
 124                         se_bank = 0xFFFFFFFF;
 125                 if (sh_bank == 0x3FF)
 126                         sh_bank = 0xFFFFFFFF;
 127                 if (instance_bank == 0x3FF)
 128                         instance_bank = 0xFFFFFFFF;
 129                 use_bank = 1;
 130         } else if (*pos & (1ULL << 61)) {
 131
 132                 me = (*pos & GENMASK_ULL(33, 24)) >> 24;
 133                 pipe = (*pos & GENMASK_ULL(43, 34)) >> 34;
 134                 queue = (*pos & GENMASK_ULL(53, 44)) >> 44;
 135
 136                 use_ring = 1;
 137         } else {
 138                 use_bank = use_ring = 0;
 139         }
 140
 141         *pos &= (1UL << 22) - 1;
 142
 143         if (use_bank) {
 144                 if ((sh_bank != 0xFFFFFFFF && sh_bank >= adev->gfx.config.max_sh_per_se) ||
 145                     (se_bank != 0xFFFFFFFF && se_bank >= adev->gfx.config.max_shader_engines))
 146                         return -EINVAL;
 147                 mutex_lock(&adev->grbm_idx_mutex);
 148                 amdgpu_gfx_select_se_sh(adev, se_bank,
 149                                         sh_bank, instance_bank);
 150         } else if (use_ring) {
 151                 mutex_lock(&adev->srbm_mutex);
 152                 amdgpu_gfx_select_me_pipe_q(adev, me, pipe, queue);
 153         }
 154
 155         if (pm_pg_lock)
 156                 mutex_lock(&adev->pm.mutex);
 157
 158         while (size) {
 159                 uint32_t value;
 160
 161                 if (*pos > adev->rmmio_size)
 162                         goto end;
 163
 164                 if (read) {
 165                         value = RREG32(*pos >> 2);
 166                         r = put_user(value, (uint32_t *)buf);
 167                 } else {
 168                         r = get_user(value, (uint32_t *)buf);
 169                         if (!r)
 170                                 WREG32(*pos >> 2, value);
 171                 }
 172                 if (r) {
 173                         result = r;
 174                         goto end;
 175                 }
 176
 177                 result += 4;
 178                 buf += 4;
 179                 *pos += 4;
 180                 size -= 4;
 181         }
 182
 183 end:
 184         if (use_bank) {
 185                 amdgpu_gfx_select_se_sh(adev, 0xffffffff, 0xffffffff, 0xffffffff);
 186                 mutex_unlock(&adev->grbm_idx_mutex);
 187         } else if (use_ring) {
 188                 amdgpu_gfx_select_me_pipe_q(adev, 0, 0, 0);
 189                 mutex_unlock(&adev->srbm_mutex);
 190         }
 191
 192         if (pm_pg_lock)
 193                 mutex_unlock(&adev->pm.mutex);
 194
 195         return result;
 196 }
 197
 198 /**
 199  * amdgpu_debugfs_regs_read - Callback for reading MMIO registers
 200  */
 201 static ssize_t amdgpu_debugfs_regs_read(struct file *f, char __user *buf,
 202                                         size_t size, loff_t *pos)
 203 {
 204         return amdgpu_debugfs_process_reg_op(true, f, buf, size, pos);
 205 }
 206
 207 /**
 208  * amdgpu_debugfs_regs_write - Callback for writing MMIO registers
 209  */
 210 static ssize_t amdgpu_debugfs_regs_write(struct file *f, const char __user *buf,
 211                                          size_t size, loff_t *pos)
 212 {
 213         return amdgpu_debugfs_process_reg_op(false, f, (char __user *)buf, size, pos);
 214 }
 215
 216
 217 /**
 218  * amdgpu_debugfs_regs_pcie_read - Read from a PCIE register
 219  *
 220  * @f: open file handle
 221  * @buf: User buffer to store read data in
 222  * @size: Number of bytes to read
 223  * @pos:  Offset to seek to
 224  *
 225  * The lower bits are the BYTE offset of the register to read.  This
 226  * allows reading multiple registers in a single call and having
 227  * the returned size reflect that.
 228  */
 229 static ssize_t amdgpu_debugfs_regs_pcie_read(struct file *f, char __user *buf,
 230                                         size_t size, loff_t *pos)
 231 {
 232         struct amdgpu_device *adev = file_inode(f)->i_private;
 233         ssize_t result = 0;
 234         int r;
 235
 236         if (size & 0x3 || *pos & 0x3)
 237                 return -EINVAL;
 238
 239         while (size) {
 240                 uint32_t value;
 241
 242                 value = RREG32_PCIE(*pos);
 243                 r = put_user(value, (uint32_t *)buf);
 244                 if (r)
 245                         return r;
 246
 247                 result += 4;
 248                 buf += 4;
 249                 *pos += 4;
 250                 size -= 4;
 251         }
 252
 253         return result;
 254 }
 255
 256 /**
 257  * amdgpu_debugfs_regs_pcie_write - Write to a PCIE register
 258  *
 259  * @f: open file handle
 260  * @buf: User buffer to write data from
 261  * @size: Number of bytes to write
 262  * @pos:  Offset to seek to
 263  *
 264  * The lower bits are the BYTE offset of the register to write.  This
 265  * allows writing multiple registers in a single call and having
 266  * the returned size reflect that.
 267  */
 268 static ssize_t amdgpu_debugfs_regs_pcie_write(struct file *f, const char __user *buf,
 269                                          size_t size, loff_t *pos)
 270 {
 271         struct amdgpu_device *adev = file_inode(f)->i_private;
 272         ssize_t result = 0;
 273         int r;
 274
 275         if (size & 0x3 || *pos & 0x3)
 276                 return -EINVAL;
 277
 278         while (size) {
 279                 uint32_t value;
 280
 281                 r = get_user(value, (uint32_t *)buf);
 282                 if (r)
 283                         return r;
 284
 285                 WREG32_PCIE(*pos, value);
 286
 287                 result += 4;
 288                 buf += 4;
 289                 *pos += 4;
 290                 size -= 4;
 291         }
 292
 293         return result;
 294 }
 295
 296 /**
 297  * amdgpu_debugfs_regs_didt_read - Read from a DIDT register
 298  *
 299  * @f: open file handle
 300  * @buf: User buffer to store read data in
 301  * @size: Number of bytes to read
 302  * @pos:  Offset to seek to
 303  *
 304  * The lower bits are the BYTE offset of the register to read.  This
 305  * allows reading multiple registers in a single call and having
 306  * the returned size reflect that.
 307  */
 308 static ssize_t amdgpu_debugfs_regs_didt_read(struct file *f, char __user *buf,
 309                                         size_t size, loff_t *pos)
 310 {
 311         struct amdgpu_device *adev = file_inode(f)->i_private;
 312         ssize_t result = 0;
 313         int r;
 314
 315         if (size & 0x3 || *pos & 0x3)
 316                 return -EINVAL;
 317
 318         while (size) {
 319                 uint32_t value;
 320
 321                 value = RREG32_DIDT(*pos >> 2);
 322                 r = put_user(value, (uint32_t *)buf);
 323                 if (r)
 324                         return r;
 325
 326                 result += 4;
 327                 buf += 4;
 328                 *pos += 4;
 329                 size -= 4;
 330         }
 331
 332         return result;
 333 }
 334
 335 /**
 336  * amdgpu_debugfs_regs_didt_write - Write to a DIDT register
 337  *
 338  * @f: open file handle
 339  * @buf: User buffer to write data from
 340  * @size: Number of bytes to write
 341  * @pos:  Offset to seek to
 342  *
 343  * The lower bits are the BYTE offset of the register to write.  This
 344  * allows writing multiple registers in a single call and having
 345  * the returned size reflect that.
 346  */
 347 static ssize_t amdgpu_debugfs_regs_didt_write(struct file *f, const char __user *buf,
 348                                          size_t size, loff_t *pos)
 349 {
 350         struct amdgpu_device *adev = file_inode(f)->i_private;
 351         ssize_t result = 0;
 352         int r;
 353
 354         if (size & 0x3 || *pos & 0x3)
 355                 return -EINVAL;
 356
 357         while (size) {
 358                 uint32_t value;
 359
 360                 r = get_user(value, (uint32_t *)buf);
 361                 if (r)
 362                         return r;
 363
 364                 WREG32_DIDT(*pos >> 2, value);
 365
 366                 result += 4;
 367                 buf += 4;
 368                 *pos += 4;
 369                 size -= 4;
 370         }
 371
 372         return result;
 373 }
 374
 375 /**
 376  * amdgpu_debugfs_regs_smc_read - Read from a SMC register
 377  *
 378  * @f: open file handle
 379  * @buf: User buffer to store read data in
 380  * @size: Number of bytes to read
 381  * @pos:  Offset to seek to
 382  *
 383  * The lower bits are the BYTE offset of the register to read.  This
 384  * allows reading multiple registers in a single call and having
 385  * the returned size reflect that.
 386  */
 387 static ssize_t amdgpu_debugfs_regs_smc_read(struct file *f, char __user *buf,
 388                                         size_t size, loff_t *pos)
 389 {
 390         struct amdgpu_device *adev = file_inode(f)->i_private;
 391         ssize_t result = 0;
 392         int r;
 393
 394         if (!adev->smc_rreg)
 395                 return -EPERM;
 396
 397         if (size & 0x3 || *pos & 0x3)
 398                 return -EINVAL;
 399
 400         while (size) {
 401                 uint32_t value;
 402
 403                 value = RREG32_SMC(*pos);
 404                 r = put_user(value, (uint32_t *)buf);
 405                 if (r)
 406                         return r;
 407
 408                 result += 4;
 409                 buf += 4;
 410                 *pos += 4;
 411                 size -= 4;
 412         }
 413
 414         return result;
 415 }
 416
 417 /**
 418  * amdgpu_debugfs_regs_smc_write - Write to a SMC register
 419  *
 420  * @f: open file handle
 421  * @buf: User buffer to write data from
 422  * @size: Number of bytes to write
 423  * @pos:  Offset to seek to
 424  *
 425  * The lower bits are the BYTE offset of the register to write.  This
 426  * allows writing multiple registers in a single call and having
 427  * the returned size reflect that.
 428  */
 429 static ssize_t amdgpu_debugfs_regs_smc_write(struct file *f, const char __user *buf,
 430                                          size_t size, loff_t *pos)
 431 {
 432         struct amdgpu_device *adev = file_inode(f)->i_private;
 433         ssize_t result = 0;
 434         int r;
 435
 436         if (!adev->smc_wreg)
 437                 return -EPERM;
 438
 439         if (size & 0x3 || *pos & 0x3)
 440                 return -EINVAL;
 441
 442         while (size) {
 443                 uint32_t value;
 444
 445                 r = get_user(value, (uint32_t *)buf);
 446                 if (r)
 447                         return r;
 448
 449                 WREG32_SMC(*pos, value);
 450
 451                 result += 4;
 452                 buf += 4;
 453                 *pos += 4;
 454                 size -= 4;
 455         }
 456
 457         return result;
 458 }
 459
 460 /**
 461  * amdgpu_debugfs_gca_config_read - Read from gfx config data
 462  *
 463  * @f: open file handle
 464  * @buf: User buffer to store read data in
 465  * @size: Number of bytes to read
 466  * @pos:  Offset to seek to
 467  *
 468  * This file is used to access configuration data in a somewhat
 469  * stable fashion.  The format is a series of DWORDs with the first
 470  * indicating which revision it is.  New content is appended to the
 471  * end so that older software can still read the data.
 472  */
 473
 474 static ssize_t amdgpu_debugfs_gca_config_read(struct file *f, char __user *buf,
 475                                         size_t size, loff_t *pos)
 476 {
 477         struct amdgpu_device *adev = file_inode(f)->i_private;
 478         ssize_t result = 0;
 479         int r;
 480         uint32_t *config, no_regs = 0;
 481
 482         if (size & 0x3 || *pos & 0x3)
 483                 return -EINVAL;
 484
 485         config = kmalloc_array(256, sizeof(*config), GFP_KERNEL);
 486         if (!config)
 487                 return -ENOMEM;
 488
 489         /* version, increment each time something is added */
 490         config[no_regs++] = 3;
 491         config[no_regs++] = adev->gfx.config.max_shader_engines;
 492         config[no_regs++] = adev->gfx.config.max_tile_pipes;
 493         config[no_regs++] = adev->gfx.config.max_cu_per_sh;
 494         config[no_regs++] = adev->gfx.config.max_sh_per_se;
 495         config[no_regs++] = adev->gfx.config.max_backends_per_se;
 496         config[no_regs++] = adev->gfx.config.max_texture_channel_caches;
 497         config[no_regs++] = adev->gfx.config.max_gprs;
 498         config[no_regs++] = adev->gfx.config.max_gs_threads;
 499         config[no_regs++] = adev->gfx.config.max_hw_contexts;
 500         config[no_regs++] = adev->gfx.config.sc_prim_fifo_size_frontend;
 501         config[no_regs++] = adev->gfx.config.sc_prim_fifo_size_backend;
 502         config[no_regs++] = adev->gfx.config.sc_hiz_tile_fifo_size;
 503         config[no_regs++] = adev->gfx.config.sc_earlyz_tile_fifo_size;
 504         config[no_regs++] = adev->gfx.config.num_tile_pipes;
 505         config[no_regs++] = adev->gfx.config.backend_enable_mask;
 506         config[no_regs++] = adev->gfx.config.mem_max_burst_length_bytes;
 507         config[no_regs++] = adev->gfx.config.mem_row_size_in_kb;
 508         config[no_regs++] = adev->gfx.config.shader_engine_tile_size;
 509         config[no_regs++] = adev->gfx.config.num_gpus;
 510         config[no_regs++] = adev->gfx.config.multi_gpu_tile_size;
 511         config[no_regs++] = adev->gfx.config.mc_arb_ramcfg;
 512         config[no_regs++] = adev->gfx.config.gb_addr_config;
 513         config[no_regs++] = adev->gfx.config.num_rbs;
 514
 515         /* rev==1 */
 516         config[no_regs++] = adev->rev_id;
 517         config[no_regs++] = adev->pg_flags;
 518         config[no_regs++] = adev->cg_flags;
 519
 520         /* rev==2 */
 521         config[no_regs++] = adev->family;
 522         config[no_regs++] = adev->external_rev_id;
 523
 524         /* rev==3 */
 525         config[no_regs++] = adev->pdev->device;
 526         config[no_regs++] = adev->pdev->revision;
 527         config[no_regs++] = adev->pdev->subsystem_device;
 528         config[no_regs++] = adev->pdev->subsystem_vendor;
 529
 530         while (size && (*pos < no_regs * 4)) {
 531                 uint32_t value;
 532
 533                 value = config[*pos >> 2];
 534                 r = put_user(value, (uint32_t *)buf);
 535                 if (r) {
 536                         kfree(config);
 537                         return r;
 538                 }
 539
 540                 result += 4;
 541                 buf += 4;
 542                 *pos += 4;
 543                 size -= 4;
 544         }
 545
 546         kfree(config);
 547         return result;
 548 }
 549
 550 /**
 551  * amdgpu_debugfs_sensor_read - Read from the powerplay sensors
 552  *
 553  * @f: open file handle
 554  * @buf: User buffer to store read data in
 555  * @size: Number of bytes to read
 556  * @pos:  Offset to seek to
 557  *
 558  * The offset is treated as the BYTE address of one of the sensors
 559  * enumerated in amd/include/kgd_pp_interface.h under the
 560  * 'amd_pp_sensors' enumeration.  For instance to read the UVD VCLK
 561  * you would use the offset 3 * 4 = 12.
 562  */
 563 static ssize_t amdgpu_debugfs_sensor_read(struct file *f, char __user *buf,
 564                                         size_t size, loff_t *pos)
 565 {
 566         struct amdgpu_device *adev = file_inode(f)->i_private;
 567         int idx, x, outsize, r, valuesize;
 568         uint32_t values[16];
 569
 570         if (size & 3 || *pos & 0x3)
 571                 return -EINVAL;
 572
 573         if (!adev->pm.dpm_enabled)
 574                 return -EINVAL;
 575
 576         /* convert offset to sensor number */
 577         idx = *pos >> 2;
 578
 579         valuesize = sizeof(values);
 580         if (adev->powerplay.pp_funcs && adev->powerplay.pp_funcs->read_sensor)
 581                 r = amdgpu_dpm_read_sensor(adev, idx, &values[0], &valuesize);
 582         else
 583                 return -EINVAL;
 584
 585         if (size > valuesize)
 586                 return -EINVAL;
 587
 588         outsize = 0;
 589         x = 0;
 590         if (!r) {
 591                 while (size) {
 592                         r = put_user(values[x++], (int32_t *)buf);
 593                         buf += 4;
 594                         size -= 4;
 595                         outsize += 4;
 596                 }
 597         }
 598
 599         return !r ? outsize : r;
 600 }
 601
 602 /** amdgpu_debugfs_wave_read - Read WAVE STATUS data
 603  *
 604  * @f: open file handle
 605  * @buf: User buffer to store read data in
 606  * @size: Number of bytes to read
 607  * @pos:  Offset to seek to
 608  *
 609  * The offset being sought changes which wave that the status data
 610  * will be returned for.  The bits are used as follows:
 611  *
 612  * Bits 0..6:   Byte offset into data
 613  * Bits 7..14:  SE selector
 614  * Bits 15..22: SH/SA selector
 615  * Bits 23..30: CU/{WGP+SIMD} selector
 616  * Bits 31..36: WAVE ID selector
 617  * Bits 37..44: SIMD ID selector
 618  *
 619  * The returned data begins with one DWORD of version information
 620  * Followed by WAVE STATUS registers relevant to the GFX IP version
 621  * being used.  See gfx_v8_0_read_wave_data() for an example output.
 622  */
 623 static ssize_t amdgpu_debugfs_wave_read(struct file *f, char __user *buf,
 624                                         size_t size, loff_t *pos)
 625 {
 626         struct amdgpu_device *adev = f->f_inode->i_private;
 627         int r, x;
 628         ssize_t result=0;
 629         uint32_t offset, se, sh, cu, wave, simd, data[32];
 630
 631         if (size & 3 || *pos & 3)
 632                 return -EINVAL;
 633
 634         /* decode offset */
 635         offset = (*pos & GENMASK_ULL(6, 0));
 636         se = (*pos & GENMASK_ULL(14, 7)) >> 7;
 637         sh = (*pos & GENMASK_ULL(22, 15)) >> 15;
 638         cu = (*pos & GENMASK_ULL(30, 23)) >> 23;
 639         wave = (*pos & GENMASK_ULL(36, 31)) >> 31;
 640         simd = (*pos & GENMASK_ULL(44, 37)) >> 37;
 641
 642         /* switch to the specific se/sh/cu */
 643         mutex_lock(&adev->grbm_idx_mutex);
 644         amdgpu_gfx_select_se_sh(adev, se, sh, cu);
 645
 646         x = 0;
 647         if (adev->gfx.funcs->read_wave_data)
 648                 adev->gfx.funcs->read_wave_data(adev, simd, wave, data, &x);
 649
 650         amdgpu_gfx_select_se_sh(adev, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
 651         mutex_unlock(&adev->grbm_idx_mutex);
 652
 653         if (!x)
 654                 return -EINVAL;
 655
 656         while (size && (offset < x * 4)) {
 657                 uint32_t value;
 658
 659                 value = data[offset >> 2];
 660                 r = put_user(value, (uint32_t *)buf);
 661                 if (r)
 662                         return r;
 663
 664                 result += 4;
 665                 buf += 4;
 666                 offset += 4;
 667                 size -= 4;
 668         }
 669
 670         return result;
 671 }
 672
 673 /** amdgpu_debugfs_gpr_read - Read wave gprs
 674  *
 675  * @f: open file handle
 676  * @buf: User buffer to store read data in
 677  * @size: Number of bytes to read
 678  * @pos:  Offset to seek to
 679  *
 680  * The offset being sought changes which wave that the status data
 681  * will be returned for.  The bits are used as follows:
 682  *
 683  * Bits 0..11:  Byte offset into data
 684  * Bits 12..19: SE selector
 685  * Bits 20..27: SH/SA selector
 686  * Bits 28..35: CU/{WGP+SIMD} selector
 687  * Bits 36..43: WAVE ID selector
 688  * Bits 37..44: SIMD ID selector
 689  * Bits 52..59: Thread selector
 690  * Bits 60..61: Bank selector (VGPR=0,SGPR=1)
 691  *
 692  * The return data comes from the SGPR or VGPR register bank for
 693  * the selected operational unit.
 694  */
 695 static ssize_t amdgpu_debugfs_gpr_read(struct file *f, char __user *buf,
 696                                         size_t size, loff_t *pos)
 697 {
 698         struct amdgpu_device *adev = f->f_inode->i_private;
 699         int r;
 700         ssize_t result = 0;
 701         uint32_t offset, se, sh, cu, wave, simd, thread, bank, *data;
 702
 703         if (size > 4096 || size & 3 || *pos & 3)
 704                 return -EINVAL;
 705
 706         /* decode offset */
 707         offset = (*pos & GENMASK_ULL(11, 0)) >> 2;
 708         se = (*pos & GENMASK_ULL(19, 12)) >> 12;
 709         sh = (*pos & GENMASK_ULL(27, 20)) >> 20;
 710         cu = (*pos & GENMASK_ULL(35, 28)) >> 28;
 711         wave = (*pos & GENMASK_ULL(43, 36)) >> 36;
 712         simd = (*pos & GENMASK_ULL(51, 44)) >> 44;
 713         thread = (*pos & GENMASK_ULL(59, 52)) >> 52;
 714         bank = (*pos & GENMASK_ULL(61, 60)) >> 60;
 715
 716         data = kcalloc(1024, sizeof(*data), GFP_KERNEL);
 717         if (!data)
 718                 return -ENOMEM;
 719
 720         /* switch to the specific se/sh/cu */
 721         mutex_lock(&adev->grbm_idx_mutex);
 722         amdgpu_gfx_select_se_sh(adev, se, sh, cu);
 723
 724         if (bank == 0) {
 725                 if (adev->gfx.funcs->read_wave_vgprs)
 726                         adev->gfx.funcs->read_wave_vgprs(adev, simd, wave, thread, offset, size>>2, data);
 727         } else {
 728                 if (adev->gfx.funcs->read_wave_sgprs)
 729                         adev->gfx.funcs->read_wave_sgprs(adev, simd, wave, offset, size>>2, data);
 730         }
 731
 732         amdgpu_gfx_select_se_sh(adev, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
 733         mutex_unlock(&adev->grbm_idx_mutex);
 734
 735         while (size) {
 736                 uint32_t value;
 737
 738                 value = data[result >> 2];
 739                 r = put_user(value, (uint32_t *)buf);
 740                 if (r) {
 741                         result = r;
 742                         goto err;
 743                 }
 744
 745                 result += 4;
 746                 buf += 4;
 747                 size -= 4;
 748         }
 749
 750 err:
 751         kfree(data);
 752         return result;
 753 }
 754
 755 static const struct file_operations amdgpu_debugfs_regs_fops = {
 756         .owner = THIS_MODULE,
 757         .read = amdgpu_debugfs_regs_read,
 758         .write = amdgpu_debugfs_regs_write,
 759         .llseek = default_llseek
 760 };
 761 static const struct file_operations amdgpu_debugfs_regs_didt_fops = {
 762         .owner = THIS_MODULE,
 763         .read = amdgpu_debugfs_regs_didt_read,
 764         .write = amdgpu_debugfs_regs_didt_write,
 765         .llseek = default_llseek
 766 };
 767 static const struct file_operations amdgpu_debugfs_regs_pcie_fops = {
 768         .owner = THIS_MODULE,
 769         .read = amdgpu_debugfs_regs_pcie_read,
 770         .write = amdgpu_debugfs_regs_pcie_write,
 771         .llseek = default_llseek
 772 };
 773 static const struct file_operations amdgpu_debugfs_regs_smc_fops = {
 774         .owner = THIS_MODULE,
 775         .read = amdgpu_debugfs_regs_smc_read,
 776         .write = amdgpu_debugfs_regs_smc_write,
 777         .llseek = default_llseek
 778 };
 779
 780 static const struct file_operations amdgpu_debugfs_gca_config_fops = {
 781         .owner = THIS_MODULE,
 782         .read = amdgpu_debugfs_gca_config_read,
 783         .llseek = default_llseek
 784 };
 785
 786 static const struct file_operations amdgpu_debugfs_sensors_fops = {
 787         .owner = THIS_MODULE,
 788         .read = amdgpu_debugfs_sensor_read,
 789         .llseek = default_llseek
 790 };
 791
 792 static const struct file_operations amdgpu_debugfs_wave_fops = {
 793         .owner = THIS_MODULE,
 794         .read = amdgpu_debugfs_wave_read,
 795         .llseek = default_llseek
 796 };
 797 static const struct file_operations amdgpu_debugfs_gpr_fops = {
 798         .owner = THIS_MODULE,
 799         .read = amdgpu_debugfs_gpr_read,
 800         .llseek = default_llseek
 801 };
 802
 803 static const struct file_operations *debugfs_regs[] = {
 804         &amdgpu_debugfs_regs_fops,
 805         &amdgpu_debugfs_regs_didt_fops,
 806         &amdgpu_debugfs_regs_pcie_fops,
 807         &amdgpu_debugfs_regs_smc_fops,
 808         &amdgpu_debugfs_gca_config_fops,
 809         &amdgpu_debugfs_sensors_fops,
 810         &amdgpu_debugfs_wave_fops,
 811         &amdgpu_debugfs_gpr_fops,
 812 };
 813
 814 static const char *debugfs_regs_names[] = {
 815         "amdgpu_regs",
 816         "amdgpu_regs_didt",
 817         "amdgpu_regs_pcie",
 818         "amdgpu_regs_smc",
 819         "amdgpu_gca_config",
 820         "amdgpu_sensors",
 821         "amdgpu_wave",
 822         "amdgpu_gpr",
 823 };
 824
 825 /**
 826  * amdgpu_debugfs_regs_init -   Initialize debugfs entries that provide
 827  *                                                              register access.
 828  *
 829  * @adev: The device to attach the debugfs entries to
 830  */
 831 int amdgpu_debugfs_regs_init(struct amdgpu_device *adev)
 832 {
 833         struct drm_minor *minor = adev->ddev->primary;
 834         struct dentry *ent, *root = minor->debugfs_root;
 835         unsigned i, j;
 836
 837         for (i = 0; i < ARRAY_SIZE(debugfs_regs); i++) {
 838                 ent = debugfs_create_file(debugfs_regs_names[i],
 839                                           S_IFREG | S_IRUGO, root,
 840                                           adev, debugfs_regs[i]);
 841                 if (IS_ERR(ent)) {
 842                         for (j = 0; j < i; j++) {
 843                                 debugfs_remove(adev->debugfs_regs[i]);
 844                                 adev->debugfs_regs[i] = NULL;
 845                         }
 846                         return PTR_ERR(ent);
 847                 }
 848
 849                 if (!i)
 850                         i_size_write(ent->d_inode, adev->rmmio_size);
 851                 adev->debugfs_regs[i] = ent;
 852         }
 853
 854         return 0;
 855 }
 856
 857 void amdgpu_debugfs_regs_cleanup(struct amdgpu_device *adev)
 858 {
 859         unsigned i;
 860
 861         for (i = 0; i < ARRAY_SIZE(debugfs_regs); i++) {
 862                 if (adev->debugfs_regs[i]) {
 863                         debugfs_remove(adev->debugfs_regs[i]);
 864                         adev->debugfs_regs[i] = NULL;
 865                 }
 866         }
 867 }
 868
 869 static int amdgpu_debugfs_test_ib(struct seq_file *m, void *data)
 870 {
 871         struct drm_info_node *node = (struct drm_info_node *) m->private;
 872         struct drm_device *dev = node->minor->dev;
 873         struct amdgpu_device *adev = dev->dev_private;
 874         int r = 0, i;
 875
 876         /* hold on the scheduler */
 877         for (i = 0; i < AMDGPU_MAX_RINGS; i++) {
 878                 struct amdgpu_ring *ring = adev->rings[i];
 879
 880                 if (!ring || !ring->sched.thread)
 881                         continue;
 882                 kthread_park(ring->sched.thread);
 883         }
 884
 885         seq_printf(m, "run ib test:\n");
 886         r = amdgpu_ib_ring_tests(adev);
 887         if (r)
 888                 seq_printf(m, "ib ring tests failed (%d).\n", r);
 889         else
 890                 seq_printf(m, "ib ring tests passed.\n");
 891
 892         /* go on the scheduler */
 893         for (i = 0; i < AMDGPU_MAX_RINGS; i++) {
 894                 struct amdgpu_ring *ring = adev->rings[i];
 895
 896                 if (!ring || !ring->sched.thread)
 897                         continue;
 898                 kthread_unpark(ring->sched.thread);
 899         }
 900
 901         return 0;
 902 }
 903
 904 static int amdgpu_debugfs_get_vbios_dump(struct seq_file *m, void *data)
 905 {
 906         struct drm_info_node *node = (struct drm_info_node *) m->private;
 907         struct drm_device *dev = node->minor->dev;
 908         struct amdgpu_device *adev = dev->dev_private;
 909
 910         seq_write(m, adev->bios, adev->bios_size);
 911         return 0;
 912 }
 913
 914 static int amdgpu_debugfs_evict_vram(struct seq_file *m, void *data)
 915 {
 916         struct drm_info_node *node = (struct drm_info_node *)m->private;
 917         struct drm_device *dev = node->minor->dev;
 918         struct amdgpu_device *adev = dev->dev_private;
 919
 920         seq_printf(m, "(%d)\n", amdgpu_bo_evict_vram(adev));
 921         return 0;
 922 }
 923
 924 static int amdgpu_debugfs_evict_gtt(struct seq_file *m, void *data)
 925 {
 926         struct drm_info_node *node = (struct drm_info_node *)m->private;
 927         struct drm_device *dev = node->minor->dev;
 928         struct amdgpu_device *adev = dev->dev_private;
 929
 930         seq_printf(m, "(%d)\n", ttm_bo_evict_mm(&adev->mman.bdev, TTM_PL_TT));
 931         return 0;
 932 }
 933
 934 static const struct drm_info_list amdgpu_debugfs_list[] = {
 935         {"amdgpu_vbios", amdgpu_debugfs_get_vbios_dump},
 936         {"amdgpu_test_ib", &amdgpu_debugfs_test_ib},
 937         {"amdgpu_evict_vram", &amdgpu_debugfs_evict_vram},
 938         {"amdgpu_evict_gtt", &amdgpu_debugfs_evict_gtt},
 939 };
 940
 941 int amdgpu_debugfs_init(struct amdgpu_device *adev)
 942 {
 943         return amdgpu_debugfs_add_files(adev, amdgpu_debugfs_list,
 944                                         ARRAY_SIZE(amdgpu_debugfs_list));
 945 }
 946
 947 #else
 948 int amdgpu_debugfs_init(struct amdgpu_device *adev)
 949 {
 950         return 0;
 951 }
 952 int amdgpu_debugfs_regs_init(struct amdgpu_device *adev)
 953 {
 954         return 0;
 955 }
 956 void amdgpu_debugfs_regs_cleanup(struct amdgpu_device *adev) { }
 957 #endif