Merge tag 'csky-for-linus-5.13-rc1' of git://github.com/c-sky/csky-linux

[linux.git] / drivers / gpu / drm / amd / amdgpu / amdgpu_kms.c

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c
index 64beb33996042647143539bace349d026fbf90dc..39ee88d29cca1f3d0d06dfd1c487172820ec4362 100644 (file)
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c
@@ -27,7 +27,6 @@
  */
 
 #include "amdgpu.h"
  */
 
 #include "amdgpu.h"

-#include <drm/drm_debugfs.h>

 #include <drm/amdgpu_drm.h>
 #include "amdgpu_uvd.h"
 #include "amdgpu_vce.h"
 #include <drm/amdgpu_drm.h>
 #include "amdgpu_uvd.h"
 #include "amdgpu_vce.h"


@@ -160,7 +159,7 @@ int amdgpu_driver_load_kms(struct amdgpu_device *adev, unsigned long flags)
                goto out;
        }
 
                goto out;
        }
 

-       if (amdgpu_device_supports_atpx(dev) &&
+       if (amdgpu_device_supports_px(dev) &&

            (amdgpu_runtime_pm != 0)) { /* enable runpm by default for atpx */
                adev->runpm = true;
                dev_info(adev->dev, "Using ATPX for runtime pm\n");
            (amdgpu_runtime_pm != 0)) { /* enable runpm by default for atpx */
                adev->runpm = true;
                dev_info(adev->dev, "Using ATPX for runtime pm\n");


@@ -201,9 +200,13 @@ int amdgpu_driver_load_kms(struct amdgpu_device *adev, unsigned long flags)
 
        if (adev->runpm) {
                /* only need to skip on ATPX */
 
        if (adev->runpm) {
                /* only need to skip on ATPX */

-               if (amdgpu_device_supports_atpx(dev) &&
-                   !amdgpu_is_atpx_hybrid())
+               if (amdgpu_device_supports_px(dev))

                        dev_pm_set_driver_flags(dev->dev, DPM_FLAG_NO_DIRECT_COMPLETE);
                        dev_pm_set_driver_flags(dev->dev, DPM_FLAG_NO_DIRECT_COMPLETE);

+               /* we want direct complete for BOCO */
+               if (amdgpu_device_supports_boco(dev))
+                       dev_pm_set_driver_flags(dev->dev, DPM_FLAG_SMART_PREPARE |
+                                               DPM_FLAG_SMART_SUSPEND |
+                                               DPM_FLAG_MAY_SKIP_RESUME);

                pm_runtime_use_autosuspend(dev->dev);
                pm_runtime_set_autosuspend_delay(dev->dev, 5000);
                pm_runtime_allow(dev->dev);
                pm_runtime_use_autosuspend(dev->dev);
                pm_runtime_set_autosuspend_delay(dev->dev, 5000);
                pm_runtime_allow(dev->dev);


@@ -287,22 +290,30 @@ static int amdgpu_firmware_info(struct drm_amdgpu_info_firmware *fw_info,
                break;
        case AMDGPU_INFO_FW_TA:
                switch (query_fw->index) {
                break;
        case AMDGPU_INFO_FW_TA:
                switch (query_fw->index) {

-               case 0:
+               case TA_FW_TYPE_PSP_XGMI:

                        fw_info->ver = adev->psp.ta_fw_version;
                        fw_info->feature = adev->psp.ta_xgmi_ucode_version;
                        break;
                        fw_info->ver = adev->psp.ta_fw_version;
                        fw_info->feature = adev->psp.ta_xgmi_ucode_version;
                        break;

-               case 1:
+               case TA_FW_TYPE_PSP_RAS:

                        fw_info->ver = adev->psp.ta_fw_version;
                        fw_info->feature = adev->psp.ta_ras_ucode_version;
                        break;
                        fw_info->ver = adev->psp.ta_fw_version;
                        fw_info->feature = adev->psp.ta_ras_ucode_version;
                        break;

-               case 2:
+               case TA_FW_TYPE_PSP_HDCP:

                        fw_info->ver = adev->psp.ta_fw_version;
                        fw_info->feature = adev->psp.ta_hdcp_ucode_version;
                        break;
                        fw_info->ver = adev->psp.ta_fw_version;
                        fw_info->feature = adev->psp.ta_hdcp_ucode_version;
                        break;

-               case 3:
+               case TA_FW_TYPE_PSP_DTM:

                        fw_info->ver = adev->psp.ta_fw_version;
                        fw_info->feature = adev->psp.ta_dtm_ucode_version;
                        break;
                        fw_info->ver = adev->psp.ta_fw_version;
                        fw_info->feature = adev->psp.ta_dtm_ucode_version;
                        break;

+               case TA_FW_TYPE_PSP_RAP:
+                       fw_info->ver = adev->psp.ta_fw_version;
+                       fw_info->feature = adev->psp.ta_rap_ucode_version;
+                       break;
+               case TA_FW_TYPE_PSP_SECUREDISPLAY:
+                       fw_info->ver = adev->psp.ta_fw_version;
+                       fw_info->feature = adev->psp.ta_securedisplay_ucode_version;
+                       break;

                default:
                        return -EINVAL;
                }
                default:
                        return -EINVAL;
                }


@@ -778,9 +789,9 @@ int amdgpu_info_ioctl(struct drm_device *dev, void *data, struct drm_file *filp)
                        dev_info->high_va_offset = AMDGPU_GMC_HOLE_END;
                        dev_info->high_va_max = AMDGPU_GMC_HOLE_END | vm_size;
                }
                        dev_info->high_va_offset = AMDGPU_GMC_HOLE_END;
                        dev_info->high_va_max = AMDGPU_GMC_HOLE_END | vm_size;
                }

-               dev_info->virtual_address_alignment = max((int)PAGE_SIZE, AMDGPU_GPU_PAGE_SIZE);
+               dev_info->virtual_address_alignment = max_t(u32, PAGE_SIZE, AMDGPU_GPU_PAGE_SIZE);

                dev_info->pte_fragment_size = (1 << adev->vm_manager.fragment_size) * AMDGPU_GPU_PAGE_SIZE;
                dev_info->pte_fragment_size = (1 << adev->vm_manager.fragment_size) * AMDGPU_GPU_PAGE_SIZE;

-               dev_info->gart_page_size = AMDGPU_GPU_PAGE_SIZE;
+               dev_info->gart_page_size = max_t(u32, PAGE_SIZE, AMDGPU_GPU_PAGE_SIZE);

                dev_info->cu_active_number = adev->gfx.cu_info.number;
                dev_info->cu_ao_mask = adev->gfx.cu_info.ao_cu_mask;
                dev_info->ce_ram_size = adev->gfx.ce_ram_size;
                dev_info->cu_active_number = adev->gfx.cu_info.number;
                dev_info->cu_ao_mask = adev->gfx.cu_info.ao_cu_mask;
                dev_info->ce_ram_size = adev->gfx.ce_ram_size;


@@ -981,6 +992,63 @@ int amdgpu_info_ioctl(struct drm_device *dev, void *data, struct drm_file *filp)
                                min_t(u64, size, sizeof(ras_mask))) ?
                        -EFAULT : 0;
        }
                                min_t(u64, size, sizeof(ras_mask))) ?
                        -EFAULT : 0;
        }

+       case AMDGPU_INFO_VIDEO_CAPS: {
+               const struct amdgpu_video_codecs *codecs;
+               struct drm_amdgpu_info_video_caps *caps;
+               int r;
+
+               switch (info->video_cap.type) {
+               case AMDGPU_INFO_VIDEO_CAPS_DECODE:
+                       r = amdgpu_asic_query_video_codecs(adev, false, &codecs);
+                       if (r)
+                               return -EINVAL;
+                       break;
+               case AMDGPU_INFO_VIDEO_CAPS_ENCODE:
+                       r = amdgpu_asic_query_video_codecs(adev, true, &codecs);
+                       if (r)
+                               return -EINVAL;
+                       break;
+               default:
+                       DRM_DEBUG_KMS("Invalid request %d\n",
+                                     info->video_cap.type);
+                       return -EINVAL;
+               }
+
+               caps = kzalloc(sizeof(*caps), GFP_KERNEL);
+               if (!caps)
+                       return -ENOMEM;
+
+               for (i = 0; i < codecs->codec_count; i++) {
+                       int idx = codecs->codec_array[i].codec_type;
+
+                       switch (idx) {
+                       case AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_MPEG2:
+                       case AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_MPEG4:
+                       case AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_VC1:
+                       case AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_MPEG4_AVC:
+                       case AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_HEVC:
+                       case AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_JPEG:
+                       case AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_VP9:
+                       case AMDGPU_INFO_VIDEO_CAPS_CODEC_IDX_AV1:
+                               caps->codec_info[idx].valid = 1;
+                               caps->codec_info[idx].max_width =
+                                       codecs->codec_array[i].max_width;
+                               caps->codec_info[idx].max_height =
+                                       codecs->codec_array[i].max_height;
+                               caps->codec_info[idx].max_pixels_per_frame =
+                                       codecs->codec_array[i].max_pixels_per_frame;
+                               caps->codec_info[idx].max_level =
+                                       codecs->codec_array[i].max_level;
+                               break;
+                       default:
+                               break;
+                       }
+               }
+               r = copy_to_user(out, caps,
+                                min((size_t)size, sizeof(*caps))) ? -EFAULT : 0;
+               kfree(caps);
+               return r;
+       }

        default:
                DRM_DEBUG_KMS("Invalid request %d\n", info->query);
                return -EINVAL;
        default:
                DRM_DEBUG_KMS("Invalid request %d\n", info->query);
                return -EINVAL;


@@ -1262,16 +1330,25 @@ void amdgpu_disable_vblank_kms(struct drm_crtc *crtc)
  */
 #if defined(CONFIG_DEBUG_FS)
 
  */
 #if defined(CONFIG_DEBUG_FS)
 

-static int amdgpu_debugfs_firmware_info(struct seq_file *m, void *data)
+static int amdgpu_debugfs_firmware_info_show(struct seq_file *m, void *unused)

 {
 {

-       struct drm_info_node *node = (struct drm_info_node *) m->private;
-       struct drm_device *dev = node->minor->dev;
-       struct amdgpu_device *adev = drm_to_adev(dev);
+       struct amdgpu_device *adev = (struct amdgpu_device *)m->private;

        struct drm_amdgpu_info_firmware fw_info;
        struct drm_amdgpu_query_fw query_fw;
        struct atom_context *ctx = adev->mode_info.atom_context;
        int ret, i;
 
        struct drm_amdgpu_info_firmware fw_info;
        struct drm_amdgpu_query_fw query_fw;
        struct atom_context *ctx = adev->mode_info.atom_context;
        int ret, i;
 

+       static const char *ta_fw_name[TA_FW_TYPE_MAX_INDEX] = {
+#define TA_FW_NAME(type) [TA_FW_TYPE_PSP_##type] = #type
+               TA_FW_NAME(XGMI),
+               TA_FW_NAME(RAS),
+               TA_FW_NAME(HDCP),
+               TA_FW_NAME(DTM),
+               TA_FW_NAME(RAP),
+               TA_FW_NAME(SECUREDISPLAY),
+#undef TA_FW_NAME
+       };
+

        /* VCE */
        query_fw.fw_type = AMDGPU_INFO_FW_VCE;
        ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
        /* VCE */
        query_fw.fw_type = AMDGPU_INFO_FW_VCE;
        ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);


@@ -1389,31 +1466,14 @@ static int amdgpu_debugfs_firmware_info(struct seq_file *m, void *data)
                   fw_info.feature, fw_info.ver);
 
        query_fw.fw_type = AMDGPU_INFO_FW_TA;
                   fw_info.feature, fw_info.ver);
 
        query_fw.fw_type = AMDGPU_INFO_FW_TA;

-       for (i = 0; i < 4; i++) {
+       for (i = TA_FW_TYPE_PSP_XGMI; i < TA_FW_TYPE_MAX_INDEX; i++) {

                query_fw.index = i;
                ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
                if (ret)
                        continue;
                query_fw.index = i;
                ret = amdgpu_firmware_info(&fw_info, &query_fw, adev);
                if (ret)
                        continue;

-               switch (query_fw.index) {
-               case 0:
-                       seq_printf(m, "TA %s feature version: 0x%08x, firmware version: 0x%08x\n",
-                                       "RAS", fw_info.feature, fw_info.ver);
-                       break;
-               case 1:
-                       seq_printf(m, "TA %s feature version: 0x%08x, firmware version: 0x%08x\n",
-                                       "XGMI", fw_info.feature, fw_info.ver);
-                       break;
-               case 2:
-                       seq_printf(m, "TA %s feature version: 0x%08x, firmware version: 0x%08x\n",
-                                       "HDCP", fw_info.feature, fw_info.ver);
-                       break;
-               case 3:
-                       seq_printf(m, "TA %s feature version: 0x%08x, firmware version: 0x%08x\n",
-                                       "DTM", fw_info.feature, fw_info.ver);
-                       break;
-               default:
-                       return -EINVAL;
-               }
+
+               seq_printf(m, "TA %s feature version: 0x%08x, firmware version: 0x%08x\n",
+                          ta_fw_name[i], fw_info.feature, fw_info.ver);

        }
 
        /* SMC */
        }
 
        /* SMC */


@@ -1472,17 +1532,18 @@ static int amdgpu_debugfs_firmware_info(struct seq_file *m, void *data)
        return 0;
 }
 
        return 0;
 }
 

-static const struct drm_info_list amdgpu_firmware_info_list[] = {
-       {"amdgpu_firmware_info", amdgpu_debugfs_firmware_info, 0, NULL},
-};
+DEFINE_SHOW_ATTRIBUTE(amdgpu_debugfs_firmware_info);
+

 #endif
 
 #endif
 

-int amdgpu_debugfs_firmware_init(struct amdgpu_device *adev)
+void amdgpu_debugfs_firmware_init(struct amdgpu_device *adev)

 {
 #if defined(CONFIG_DEBUG_FS)
 {
 #if defined(CONFIG_DEBUG_FS)

-       return amdgpu_debugfs_add_files(adev, amdgpu_firmware_info_list,
-                                       ARRAY_SIZE(amdgpu_firmware_info_list));
-#else
-       return 0;
+       struct drm_minor *minor = adev_to_drm(adev)->primary;
+       struct dentry *root = minor->debugfs_root;
+
+       debugfs_create_file("amdgpu_firmware_info", 0444, root,
+                           adev, &amdgpu_debugfs_firmware_info_fops);
+

 #endif
 }
 #endif
 }