1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
|
// SPDX-License-Identifier: GPL-2.0 OR MIT
/*
* KUnit tests for amdgpu_dm_services.c
*
* Copyright 2026 Advanced Micro Devices, Inc.
*/
#include <kunit/test.h>
#include "dc.h"
#include "amdgpu.h"
#include "amdgpu_mode.h"
#include "amdgpu_dm.h"
#include "dm_services.h"
#include "dm_services_types.h"
/* Tests for dm_get_elapse_time_in_ns() */
/**
* dm_test_get_elapse_time_zero_delta - Test Get elapse time zero delta
* @test: The KUnit test context
*/
static void dm_test_get_elapse_time_zero_delta(struct kunit *test)
{
unsigned long long ts = 1000000ULL;
KUNIT_EXPECT_EQ(test, dm_get_elapse_time_in_ns(NULL, ts, ts), 0ULL);
}
/**
* dm_test_get_elapse_time_positive_delta - Test Get elapse time positive delta
* @test: The KUnit test context
*/
static void dm_test_get_elapse_time_positive_delta(struct kunit *test)
{
unsigned long long current_ts = 5000000ULL;
unsigned long long last_ts = 1000000ULL;
KUNIT_EXPECT_EQ(test, dm_get_elapse_time_in_ns(NULL, current_ts, last_ts),
4000000ULL);
}
/**
* dm_test_get_elapse_time_large_delta - Test Get elapse time large delta
* @test: The KUnit test context
*/
static void dm_test_get_elapse_time_large_delta(struct kunit *test)
{
unsigned long long current_ts = ULLONG_MAX;
unsigned long long last_ts = 0ULL;
KUNIT_EXPECT_EQ(test, dm_get_elapse_time_in_ns(NULL, current_ts, last_ts),
ULLONG_MAX);
}
/**
* dm_test_get_elapse_time_wraparound - Test Get elapse time wraparound
* @test: The KUnit test context
*/
static void dm_test_get_elapse_time_wraparound(struct kunit *test)
{
/* Unsigned wraparound: result = ULLONG_MAX - last + current + 1 */
unsigned long long current_ts = 5ULL;
unsigned long long last_ts = ULLONG_MAX - 4ULL;
KUNIT_EXPECT_EQ(test, dm_get_elapse_time_in_ns(NULL, current_ts, last_ts),
10ULL);
}
/* Tests for dm_perf_trace_timestamp() */
/**
* dm_test_perf_trace_timestamp_basic - Test Perf trace timestamp basic
* @test: The KUnit test context
*
* The tracepoint is a no-op without an attached probe, so this verifies the
* function dereferences ctx->perf_trace safely and does not crash.
*/
static void dm_test_perf_trace_timestamp_basic(struct kunit *test)
{
struct dc_context *ctx;
ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, ctx);
ctx->perf_trace = kunit_kzalloc(test, sizeof(*ctx->perf_trace), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, ctx->perf_trace);
ctx->perf_trace->read_count = 10;
ctx->perf_trace->write_count = 20;
dm_perf_trace_timestamp(__func__, __LINE__, ctx);
}
/* Tests for dm_trace_smu_enter() */
/**
* dm_test_trace_smu_enter_null_ctx - Test Trace smu enter null ctx
* @test: The KUnit test context
*/
static void dm_test_trace_smu_enter_null_ctx(struct kunit *test)
{
/* Empty stub — must not crash with NULL ctx */
dm_trace_smu_enter(0, 0, 0, NULL);
}
/**
* dm_test_trace_smu_enter_with_params - Test Trace smu enter with params
* @test: The KUnit test context
*/
static void dm_test_trace_smu_enter_with_params(struct kunit *test)
{
/* Exercise non-zero msg_id, param_in, and delay */
dm_trace_smu_enter(0xFF, 0x12345678, 1000, NULL);
}
/* Tests for dm_trace_smu_exit() */
/**
* dm_test_trace_smu_exit_success_null_ctx - Test Trace smu exit success null ctx
* @test: The KUnit test context
*/
static void dm_test_trace_smu_exit_success_null_ctx(struct kunit *test)
{
/* Empty stub — must not crash on success path with NULL ctx */
dm_trace_smu_exit(true, 0x0, NULL);
}
/**
* dm_test_trace_smu_exit_failure_null_ctx - Test Trace smu exit failure null ctx
* @test: The KUnit test context
*/
static void dm_test_trace_smu_exit_failure_null_ctx(struct kunit *test)
{
/* Empty stub — must not crash on failure path with NULL ctx */
dm_trace_smu_exit(false, 0x0, NULL);
}
/**
* dm_test_trace_smu_exit_with_response - Test Trace smu exit with response
* @test: The KUnit test context
*/
static void dm_test_trace_smu_exit_with_response(struct kunit *test)
{
/* Exercise non-zero response value */
dm_trace_smu_exit(true, 0xDEADBEEF, NULL);
}
/* Tests for dm_query_extended_brightness_caps() */
/**
* dm_test_query_brightness_caps_null_ctx - Test Query brightness caps null ctx
* @test: The KUnit test context
*/
static void dm_test_query_brightness_caps_null_ctx(struct kunit *test)
{
struct dm_acpi_atif_backlight_caps caps = {};
KUNIT_EXPECT_FALSE(test,
dm_query_extended_brightness_caps(NULL, AcpiDisplayType_LCD1, &caps));
}
/**
* dm_test_query_brightness_caps_null_caps - Test Query brightness caps null caps
* @test: The KUnit test context
*/
static void dm_test_query_brightness_caps_null_caps(struct kunit *test)
{
struct dc_context ctx = {};
ctx.driver_context = (void *)0x1; /* non-NULL sentinel */
KUNIT_EXPECT_FALSE(test,
dm_query_extended_brightness_caps(&ctx, AcpiDisplayType_LCD1, NULL));
}
/**
* dm_test_query_brightness_caps_null_driver_ctx - Test Query brightness caps null driver ctx
* @test: The KUnit test context
*/
static void dm_test_query_brightness_caps_null_driver_ctx(struct kunit *test)
{
struct dc_context ctx = {};
struct dm_acpi_atif_backlight_caps caps = {};
ctx.driver_context = NULL;
KUNIT_EXPECT_FALSE(test,
dm_query_extended_brightness_caps(&ctx, AcpiDisplayType_LCD1, &caps));
}
/**
* dm_test_query_brightness_caps_lcd2_null_ctx - Test Query brightness caps lcd2 null ctx
* @test: The KUnit test context
*/
static void dm_test_query_brightness_caps_lcd2_null_ctx(struct kunit *test)
{
struct dm_acpi_atif_backlight_caps caps = {};
KUNIT_EXPECT_FALSE(test,
dm_query_extended_brightness_caps(NULL, AcpiDisplayType_LCD2, &caps));
}
/**
* dm_test_query_brightness_caps_lcd1_success - Test Query brightness caps lcd1 success
* @test: The KUnit test context
*/
static void dm_test_query_brightness_caps_lcd1_success(struct kunit *test)
{
struct amdgpu_device *adev;
struct amdgpu_dm_backlight_caps *source_caps;
struct dc_context ctx = {};
struct dm_acpi_atif_backlight_caps caps = {};
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev);
source_caps = &adev->dm.backlight_caps[0];
source_caps->caps_valid = true;
source_caps->min_input_signal = 12;
source_caps->max_input_signal = 240;
source_caps->ac_level = 80;
source_caps->dc_level = 40;
source_caps->data_points = 2;
source_caps->luminance_data[0].luminance = 10;
source_caps->luminance_data[0].input_signal = 22;
source_caps->luminance_data[1].luminance = 90;
source_caps->luminance_data[1].input_signal = 200;
ctx.driver_context = adev;
KUNIT_EXPECT_TRUE(test,
dm_query_extended_brightness_caps(&ctx, AcpiDisplayType_LCD1, &caps));
KUNIT_EXPECT_EQ(test, caps.num_data_points, 2);
KUNIT_EXPECT_EQ(test, caps.max_input_signal, 240);
KUNIT_EXPECT_EQ(test, caps.min_input_signal, 12);
KUNIT_EXPECT_EQ(test, caps.ac_level_percentage, 80);
KUNIT_EXPECT_EQ(test, caps.dc_level_percentage, 40);
KUNIT_EXPECT_EQ(test, caps.data_points[0].luminance, 10);
KUNIT_EXPECT_EQ(test, caps.data_points[0].signal_level, 22);
KUNIT_EXPECT_EQ(test, caps.data_points[1].luminance, 90);
KUNIT_EXPECT_EQ(test, caps.data_points[1].signal_level, 200);
}
/**
* dm_test_query_brightness_caps_non_lcd1_uses_second_slot - Test Query brightness caps non lcd1 uses second slot
* @test: The KUnit test context
*/
static void dm_test_query_brightness_caps_non_lcd1_uses_second_slot(struct kunit *test)
{
struct amdgpu_device *adev;
struct amdgpu_dm_backlight_caps *source_caps;
struct dc_context ctx = {};
struct dm_acpi_atif_backlight_caps caps = {};
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev);
adev->dm.backlight_caps[0].caps_valid = true;
adev->dm.backlight_caps[0].min_input_signal = 1;
adev->dm.backlight_caps[0].max_input_signal = 2;
source_caps = &adev->dm.backlight_caps[1];
source_caps->caps_valid = true;
source_caps->min_input_signal = 33;
source_caps->max_input_signal = 199;
source_caps->ac_level = 70;
source_caps->dc_level = 30;
source_caps->data_points = 0;
ctx.driver_context = adev;
KUNIT_EXPECT_TRUE(test,
dm_query_extended_brightness_caps(&ctx, AcpiDisplayType_DFP1, &caps));
KUNIT_EXPECT_EQ(test, caps.num_data_points, 0);
KUNIT_EXPECT_EQ(test, caps.max_input_signal, 199);
KUNIT_EXPECT_EQ(test, caps.min_input_signal, 33);
KUNIT_EXPECT_EQ(test, caps.ac_level_percentage, 70);
KUNIT_EXPECT_EQ(test, caps.dc_level_percentage, 30);
KUNIT_EXPECT_EQ(test, caps.data_points[0].luminance, 0);
KUNIT_EXPECT_EQ(test, caps.data_points[0].signal_level, 0);
}
static struct kunit_case amdgpu_dm_services_test_cases[] = {
/* dm_get_elapse_time_in_ns */
KUNIT_CASE(dm_test_get_elapse_time_zero_delta),
KUNIT_CASE(dm_test_get_elapse_time_positive_delta),
KUNIT_CASE(dm_test_get_elapse_time_large_delta),
KUNIT_CASE(dm_test_get_elapse_time_wraparound),
/* dm_perf_trace_timestamp */
KUNIT_CASE(dm_test_perf_trace_timestamp_basic),
/* dm_trace_smu_enter */
KUNIT_CASE(dm_test_trace_smu_enter_null_ctx),
KUNIT_CASE(dm_test_trace_smu_enter_with_params),
/* dm_trace_smu_exit */
KUNIT_CASE(dm_test_trace_smu_exit_success_null_ctx),
KUNIT_CASE(dm_test_trace_smu_exit_failure_null_ctx),
KUNIT_CASE(dm_test_trace_smu_exit_with_response),
/* dm_query_extended_brightness_caps */
KUNIT_CASE(dm_test_query_brightness_caps_null_ctx),
KUNIT_CASE(dm_test_query_brightness_caps_null_caps),
KUNIT_CASE(dm_test_query_brightness_caps_null_driver_ctx),
KUNIT_CASE(dm_test_query_brightness_caps_lcd2_null_ctx),
KUNIT_CASE(dm_test_query_brightness_caps_lcd1_success),
KUNIT_CASE(dm_test_query_brightness_caps_non_lcd1_uses_second_slot),
{}
};
static struct kunit_suite amdgpu_dm_services_test_suite = {
.name = "amdgpu_dm_services",
.test_cases = amdgpu_dm_services_test_cases,
};
kunit_test_suite(amdgpu_dm_services_test_suite);
MODULE_DESCRIPTION("KUnit tests for amdgpu_dm_services");
MODULE_LICENSE("Dual MIT/GPL");
|
