Revert "tests/amdgpu: Fix various warnings"

This reverts commit fb1634583f3ba22c67cad0df7022b6ac48a40c56.

diff --git a/tests/amdgpu/basic_tests.c b/tests/amdgpu/basic_tests.c
index 1f6890e0455a127dd22e152e5b7ec5638b5db297..84f3827deb6b0ecb7696c322795c40467c7555ad 100644 (file)
--- a/tests/amdgpu/basic_tests.c
+++ b/tests/amdgpu/basic_tests.c
@@ -3306,7 +3306,7 @@ static void amdgpu_memcpy_draw(amdgpu_device_handle device_handle,
        int bo_cmd_size = 4096;
        struct amdgpu_cs_request ibs_request = {0};
        struct amdgpu_cs_ib_info ib_info= {0};
-       uint32_t expired;
+       uint32_t hang_state, hangs, expired;
        amdgpu_bo_list_handle bo_list;
        struct amdgpu_cs_fence fence_status = {0};
 

diff --git a/tests/amdgpu/cs_tests.c b/tests/amdgpu/cs_tests.c
index ae4f65f59b1f97329e9de1e5b95d13f33887bb2e..7ad0f0dcb3ee281fb82719471e01b498c9950e7d 100644 (file)
--- a/tests/amdgpu/cs_tests.c
+++ b/tests/amdgpu/cs_tests.c
@@ -358,7 +358,6 @@ static void amdgpu_cs_uvd_decode(void)
                bs_addr = fb_addr + 4*1024;
        dpb_addr = ALIGN(bs_addr + sizeof(uvd_bitstream), 4*1024);
 
-       ctx_addr = 0;
        if (family_id >= AMDGPU_FAMILY_VI) {
                if ((family_id == AMDGPU_FAMILY_AI) ||
                    (chip_id == chip_rev+0x50 || chip_id == chip_rev+0x5A ||

diff --git a/tests/amdgpu/ras_tests.c b/tests/amdgpu/ras_tests.c
index d714be733b1e52627c9b937b4dcc2468b9861d3d..c1c543c1213bc1bd07d07a4c1db3266a8eb3f0fc 100644 (file)
--- a/tests/amdgpu/ras_tests.c
+++ b/tests/amdgpu/ras_tests.c
@@ -522,6 +522,124 @@ static int amdgpu_ras_lookup_id(drmDevicePtr device)
        return -1;
 }
 
+CU_BOOL suite_ras_tests_enable(void)
+{
+       amdgpu_device_handle device_handle;
+       uint32_t  major_version;
+       uint32_t  minor_version;
+       int i;
+       drmDevicePtr device;
+
+       for (i = 0; i < MAX_CARDS_SUPPORTED && drm_amdgpu[i] >= 0; i++) {
+               if (amdgpu_device_initialize(drm_amdgpu[i], &major_version,
+                                       &minor_version, &device_handle))
+                       continue;
+
+               if (drmGetDevice2(drm_amdgpu[i],
+                                       DRM_DEVICE_GET_PCI_REVISION,
+                                       &device))
+                       continue;
+
+               if (device->bustype == DRM_BUS_PCI &&
+                               amdgpu_ras_lookup_capability(device_handle)) {
+                       amdgpu_device_deinitialize(device_handle);
+                       return CU_TRUE;
+               }
+
+               if (amdgpu_device_deinitialize(device_handle))
+                       continue;
+       }
+
+       return CU_FALSE;
+}
+
+int suite_ras_tests_init(void)
+{
+       drmDevicePtr device;
+       amdgpu_device_handle device_handle;
+       uint32_t  major_version;
+       uint32_t  minor_version;
+       uint32_t  capability;
+       struct ras_test_mask test_mask;
+       int id;
+       int i;
+       int r;
+
+       for (i = 0; i < MAX_CARDS_SUPPORTED && drm_amdgpu[i] >= 0; i++) {
+               r = amdgpu_device_initialize(drm_amdgpu[i], &major_version,
+                               &minor_version, &device_handle);
+               if (r)
+                       continue;
+
+               if (drmGetDevice2(drm_amdgpu[i],
+                                       DRM_DEVICE_GET_PCI_REVISION,
+                                       &device)) {
+                       amdgpu_device_deinitialize(device_handle);
+                       continue;
+               }
+
+               if (device->bustype != DRM_BUS_PCI) {
+                       amdgpu_device_deinitialize(device_handle);
+                       continue;
+               }
+
+               capability = amdgpu_ras_lookup_capability(device_handle);
+               if (capability == 0) {
+                       amdgpu_device_deinitialize(device_handle);
+                       continue;
+
+               }
+
+               id = amdgpu_ras_lookup_id(device);
+               if (id == -1) {
+                       amdgpu_device_deinitialize(device_handle);
+                       continue;
+               }
+
+               test_mask = amdgpu_ras_get_test_mask(device);
+
+               devices[devices_count++] = (struct amdgpu_ras_data) {
+                       device_handle, id, capability, test_mask,
+               };
+       }
+
+       if (devices_count == 0)
+               return CUE_SINIT_FAILED;
+
+       return CUE_SUCCESS;
+}
+
+int suite_ras_tests_clean(void)
+{
+       int r;
+       int i;
+       int ret = CUE_SUCCESS;
+
+       for (i = 0; i < devices_count; i++) {
+               r = amdgpu_device_deinitialize(devices[i].device_handle);
+               if (r)
+                       ret = CUE_SCLEAN_FAILED;
+       }
+       return ret;
+}
+
+static void amdgpu_ras_disable_test(void);
+static void amdgpu_ras_enable_test(void);
+static void amdgpu_ras_inject_test(void);
+static void amdgpu_ras_query_test(void);
+static void amdgpu_ras_basic_test(void);
+
+CU_TestInfo ras_tests[] = {
+       { "ras basic test",     amdgpu_ras_basic_test },
+       { "ras query test",     amdgpu_ras_query_test },
+       { "ras inject test",    amdgpu_ras_inject_test },
+       { "ras disable test",   amdgpu_ras_disable_test },
+#if 0
+       { "ras enable test",    amdgpu_ras_enable_test },
+#endif
+       CU_TEST_INFO_NULL,
+};
+
 //helpers
 
 static int test_card;
@@ -530,8 +648,10 @@ static char debugfs_path[1024];
 static uint32_t ras_mask;
 static amdgpu_device_handle device_handle;
 
-static void set_test_card(int card)
+static int set_test_card(int card)
 {
+       int i;
+
        test_card = card;
        sprintf(sysfs_path, "/sys/class/drm/card%d/device/ras/", devices[card].id);
        sprintf(debugfs_path, "/sys/kernel/debug/dri/%d/ras/", devices[card].id);
@@ -540,6 +660,8 @@ static void set_test_card(int card)
        ras_block_mask_inject = devices[card].test_mask.inject_mask;
        ras_block_mask_query = devices[card].test_mask.query_mask;
        ras_block_mask_basic = devices[card].test_mask.basic_mask;
+
+       return 0;
 }
 
 static const char *get_ras_sysfs_root(void)
@@ -620,6 +742,7 @@ static int amdgpu_ras_query_err_count(enum amdgpu_ras_block block,
 {
        char buf[64];
        char name[1024];
+       int ret;
 
        *ue = *ce = 0;
 
@@ -656,7 +779,7 @@ static int amdgpu_ras_inject(enum amdgpu_ras_block block,
        inject->head.block = block;
        inject->head.type = type;
        inject->head.sub_block_index = sub_block;
-       strncpy(inject->head.name, ras_block_str(block), sizeof(inject->head.name)-1);
+       strncpy(inject->head.name, ras_block_str(block), 32);
        inject->address = address;
        inject->value = value;
 
@@ -833,6 +956,8 @@ static void amdgpu_ras_query_test(void)
 
 static void amdgpu_ras_basic_test(void)
 {
+       unsigned long ue, ce;
+       char name[1024];
        int ret;
        int i;
        int j;
@@ -875,115 +1000,3 @@ static void amdgpu_ras_basic_test(void)
                }
        }
 }
-
-CU_TestInfo ras_tests[] = {
-       { "ras basic test",     amdgpu_ras_basic_test },
-       { "ras query test",     amdgpu_ras_query_test },
-       { "ras inject test",    amdgpu_ras_inject_test },
-       { "ras disable test",   amdgpu_ras_disable_test },
-#if 0
-       { "ras enable test",    amdgpu_ras_enable_test },
-#endif
-       CU_TEST_INFO_NULL,
-};
-
-CU_BOOL suite_ras_tests_enable(void)
-{
-       amdgpu_device_handle device_handle;
-       uint32_t  major_version;
-       uint32_t  minor_version;
-       int i;
-       drmDevicePtr device;
-
-       for (i = 0; i < MAX_CARDS_SUPPORTED && drm_amdgpu[i] >= 0; i++) {
-               if (amdgpu_device_initialize(drm_amdgpu[i], &major_version,
-                                       &minor_version, &device_handle))
-                       continue;
-
-               if (drmGetDevice2(drm_amdgpu[i],
-                                       DRM_DEVICE_GET_PCI_REVISION,
-                                       &device))
-                       continue;
-
-               if (device->bustype == DRM_BUS_PCI &&
-                               amdgpu_ras_lookup_capability(device_handle)) {
-                       amdgpu_device_deinitialize(device_handle);
-                       return CU_TRUE;
-               }
-
-               if (amdgpu_device_deinitialize(device_handle))
-                       continue;
-       }
-
-       return CU_FALSE;
-}
-
-int suite_ras_tests_init(void)
-{
-       drmDevicePtr device;
-       amdgpu_device_handle device_handle;
-       uint32_t  major_version;
-       uint32_t  minor_version;
-       uint32_t  capability;
-       struct ras_test_mask test_mask;
-       int id;
-       int i;
-       int r;
-
-       for (i = 0; i < MAX_CARDS_SUPPORTED && drm_amdgpu[i] >= 0; i++) {
-               r = amdgpu_device_initialize(drm_amdgpu[i], &major_version,
-                               &minor_version, &device_handle);
-               if (r)
-                       continue;
-
-               if (drmGetDevice2(drm_amdgpu[i],
-                                       DRM_DEVICE_GET_PCI_REVISION,
-                                       &device)) {
-                       amdgpu_device_deinitialize(device_handle);
-                       continue;
-               }
-
-               if (device->bustype != DRM_BUS_PCI) {
-                       amdgpu_device_deinitialize(device_handle);
-                       continue;
-               }
-
-               capability = amdgpu_ras_lookup_capability(device_handle);
-               if (capability == 0) {
-                       amdgpu_device_deinitialize(device_handle);
-                       continue;
-
-               }
-
-               id = amdgpu_ras_lookup_id(device);
-               if (id == -1) {
-                       amdgpu_device_deinitialize(device_handle);
-                       continue;
-               }
-
-               test_mask = amdgpu_ras_get_test_mask(device);
-
-               devices[devices_count++] = (struct amdgpu_ras_data) {
-                       device_handle, id, capability, test_mask,
-               };
-       }
-
-       if (devices_count == 0)
-               return CUE_SINIT_FAILED;
-
-       return CUE_SUCCESS;
-}
-
-int suite_ras_tests_clean(void)
-{
-       int r;
-       int i;
-       int ret = CUE_SUCCESS;
-
-       for (i = 0; i < devices_count; i++) {
-               r = amdgpu_device_deinitialize(devices[i].device_handle);
-               if (r)
-                       ret = CUE_SCLEAN_FAILED;
-       }
-       return ret;
-}

diff --git a/tests/amdgpu/syncobj_tests.c b/tests/amdgpu/syncobj_tests.c
index 3a7b38eb19dbd3007081378aa196dcaa91d38818..869ed88ea5c0d5deeb57183477725fc7973797bf 100644 (file)
--- a/tests/amdgpu/syncobj_tests.c
+++ b/tests/amdgpu/syncobj_tests.c
@@ -96,7 +96,7 @@ static int syncobj_command_submission_helper(uint32_t syncobj_handle, bool
        struct amdgpu_cs_fence fence_status;
        amdgpu_bo_list_handle bo_list;
        amdgpu_va_handle va_handle;
-       uint32_t expired;
+       uint32_t expired, flags;
        int i, r;
        uint64_t seq_no;
        static uint32_t *ptr;