Line data    Source code

       1             : /*
       2             :  * Copyright 2020 Advanced Micro Devices, Inc.
       3             :  *
       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:
      10             :  *
      11             :  * The above copyright notice and this permission notice shall be included in
      12             :  * all copies or substantial portions of the Software.
      13             :  *
      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.
      21             :  *
      22             :  *
      23             :  */
      24             : #include <linux/debugfs.h>
      25             : #include <linux/pm_runtime.h>
      26             : 
      27             : #include "amdgpu.h"
      28             : #include "amdgpu_rap.h"
      29             : 
      30             : /**
      31             :  * DOC: AMDGPU RAP debugfs test interface
      32             :  *
      33             :  * how to use?
      34             :  * echo opcode > <debugfs_dir>/dri/xxx/rap_test
      35             :  *
      36             :  * opcode:
      37             :  * currently, only 2 is supported by Linux host driver,
      38             :  * opcode 2 stands for TA_CMD_RAP__VALIDATE_L0, used to
      39             :  * trigger L0 policy validation, you can refer more detail
      40             :  * from header file ta_rap_if.h
      41             :  *
      42             :  */
      43             : static ssize_t amdgpu_rap_debugfs_write(struct file *f, const char __user *buf,
      44             :                 size_t size, loff_t *pos)
      45             : {
      46             :         struct amdgpu_device *adev = (struct amdgpu_device *)file_inode(f)->i_private;
      47             :         struct ta_rap_shared_memory *rap_shared_mem;
      48             :         struct ta_rap_cmd_output_data *rap_cmd_output;
      49             :         struct drm_device *dev = adev_to_drm(adev);
      50             :         uint32_t op;
      51             :         enum ta_rap_status status;
      52             :         int ret;
      53             : 
      54             :         if (*pos || size != 2)
      55             :                 return -EINVAL;
      56             : 
      57             :         ret = kstrtouint_from_user(buf, size, *pos, &op);
      58             :         if (ret)
      59             :                 return ret;
      60             : 
      61             :         ret = pm_runtime_get_sync(dev->dev);
      62             :         if (ret < 0) {
      63             :                 pm_runtime_put_autosuspend(dev->dev);
      64             :                 return ret;
      65             :         }
      66             : 
      67             :         /* make sure gfx core is on, RAP TA cann't handle
      68             :          * GFX OFF case currently.
      69             :          */
      70             :         amdgpu_gfx_off_ctrl(adev, false);
      71             : 
      72             :         switch (op) {
      73             :         case 2:
      74             :                 ret = psp_rap_invoke(&adev->psp, op, &status);
      75             :                 if (!ret && status == TA_RAP_STATUS__SUCCESS) {
      76             :                         dev_info(adev->dev, "RAP L0 validate test success.\n");
      77             :                 } else {
      78             :                         rap_shared_mem = (struct ta_rap_shared_memory *)
      79             :                                          adev->psp.rap_context.context.mem_context.shared_buf;
      80             :                         rap_cmd_output = &(rap_shared_mem->rap_out_message.output);
      81             : 
      82             :                         dev_info(adev->dev, "RAP test failed, the output is:\n");
      83             :                         dev_info(adev->dev, "\tlast_subsection: 0x%08x.\n",
      84             :                                  rap_cmd_output->last_subsection);
      85             :                         dev_info(adev->dev, "\tnum_total_validate: 0x%08x.\n",
      86             :                                  rap_cmd_output->num_total_validate);
      87             :                         dev_info(adev->dev, "\tnum_valid: 0x%08x.\n",
      88             :                                  rap_cmd_output->num_valid);
      89             :                         dev_info(adev->dev, "\tlast_validate_addr: 0x%08x.\n",
      90             :                                  rap_cmd_output->last_validate_addr);
      91             :                         dev_info(adev->dev, "\tlast_validate_val: 0x%08x.\n",
      92             :                                  rap_cmd_output->last_validate_val);
      93             :                         dev_info(adev->dev, "\tlast_validate_val_exptd: 0x%08x.\n",
      94             :                                  rap_cmd_output->last_validate_val_exptd);
      95             :                 }
      96             :                 break;
      97             :         default:
      98             :                 dev_info(adev->dev, "Unsupported op id: %d, ", op);
      99             :                 dev_info(adev->dev, "Only support op 2(L0 validate test).\n");
     100             :                 break;
     101             :         }
     102             : 
     103             :         amdgpu_gfx_off_ctrl(adev, true);
     104             :         pm_runtime_mark_last_busy(dev->dev);
     105             :         pm_runtime_put_autosuspend(dev->dev);
     106             : 
     107             :         return size;
     108             : }
     109             : 
     110             : static const struct file_operations amdgpu_rap_debugfs_ops = {
     111             :         .owner = THIS_MODULE,
     112             :         .read = NULL,
     113             :         .write = amdgpu_rap_debugfs_write,
     114             :         .llseek = default_llseek
     115             : };
     116             : 
     117           0 : void amdgpu_rap_debugfs_init(struct amdgpu_device *adev)
     118             : {
     119             : #if defined(CONFIG_DEBUG_FS)
     120             :         struct drm_minor *minor = adev_to_drm(adev)->primary;
     121             : 
     122             :         if (!adev->psp.rap_context.context.initialized)
     123             :                 return;
     124             : 
     125             :         debugfs_create_file("rap_test", S_IWUSR, minor->debugfs_root,
     126             :                                 adev, &amdgpu_rap_debugfs_ops);
     127             : #endif
     128           0 : }