Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
drm/i915: Add support for forcing the link bpp on a connector
Add support for forcing the link bpp on a connector via a connector
debugfs entry. During reducing link bpps due to a link BW limit, keep
bpps close to their forced value.
Add the debugfs entry to all relevant connectors: all DP connectors and
on an FDI link CRT/SDVO/LVDS/HDMI connectors.
v2:
- Move adding the debugfs entries to this patch.
- Rename i915_force_link_bpp to intel_force_link_bpp. (Jani)
- Select the relevant connectors via platform checks. (Jani)
- Use for_each_new_intel_connector_in_state(). (Jani)
- Fix 64 bit division vs. 32 bit build when converting str to q4. (lkp)
- Avoid division and addition overflow when converting str to q4.
v3:
- Add TODO: to make the non-DSC min bpp value connector specific. (Ankit)
Cc: Jani Nikula <jani.nikula@intel.com>
Reviewed-by: Ankit Nautiyal <ankit.k.nautiyal@intel.com>
Signed-off-by: Imre Deak <imre.deak@intel.com>
Link: https://lore.kernel.org/r/20250509180340.554867-12-imre.deak@intel.com
+241
-7
+2
drivers/gpu/drm/i915/display/intel_display_debugfs.c
+2
drivers/gpu/drm/i915/display/intel_display_debugfs.c
···
39
39
#include "intel_hdcp.h"
40
40
#include "intel_hdmi.h"
41
41
#include "intel_hotplug.h"
42
+
#include "intel_link_bw.h"
42
43
#include "intel_panel.h"
43
44
#include "intel_pps.h"
44
45
#include "intel_psr.h"
···
1326
1325
intel_psr_connector_debugfs_add(connector);
1327
1326
intel_alpm_lobf_debugfs_add(connector);
1328
1327
intel_dp_link_training_debugfs_add(connector);
1328
+
intel_link_bw_connector_debugfs_add(connector);
1329
1329
1330
1330
if (DISPLAY_VER(display) >= 11 &&
1331
1331
((connector_type == DRM_MODE_CONNECTOR_DisplayPort && !connector->mst.dp) ||
+1
drivers/gpu/drm/i915/display/intel_display_device.h
+1
drivers/gpu/drm/i915/display/intel_display_device.h
···
172
172
#define HAS_GMBUS_BURST_READ(__display) (DISPLAY_VER(__display) >= 10 || (__display)->platform.kabylake)
173
173
#define HAS_GMBUS_IRQ(__display) (DISPLAY_VER(__display) >= 4)
174
174
#define HAS_GMCH(__display) (DISPLAY_INFO(__display)->has_gmch)
175
+
#define HAS_FDI(__display) (IS_DISPLAY_VER((__display), 5, 8) && !HAS_GMCH(__display))
175
176
#define HAS_HOTPLUG(__display) (DISPLAY_INFO(__display)->has_hotplug)
176
177
#define HAS_HW_SAGV_WM(__display) (DISPLAY_VER(__display) >= 13 && !(__display)->platform.dgfx)
177
178
#define HAS_IPC(__display) (DISPLAY_INFO(__display)->has_ipc)
+4
drivers/gpu/drm/i915/display/intel_display_types.h
+4
drivers/gpu/drm/i915/display/intel_display_types.h
+232
-7
drivers/gpu/drm/i915/display/intel_link_bw.c
+232
-7
drivers/gpu/drm/i915/display/intel_link_bw.c
···
3
3
* Copyright © 2023 Intel Corporation
4
4
*/
5
5
6
+
#include <linux/ctype.h>
7
+
#include <linux/debugfs.h>
8
+
#include <linux/int_log.h>
9
+
#include <linux/math.h>
10
+
6
11
#include <drm/drm_fixed.h>
7
12
#include <drm/drm_print.h>
8
13
···
15
10
#include "intel_crtc.h"
16
11
#include "intel_display_core.h"
17
12
#include "intel_display_types.h"
13
+
#include "intel_dp.h"
18
14
#include "intel_dp_mst.h"
19
15
#include "intel_dp_tunnel.h"
20
16
#include "intel_fdi.h"
21
17
#include "intel_link_bw.h"
18
+
19
+
static int get_forced_link_bpp_x16(struct intel_atomic_state *state,
20
+
const struct intel_crtc *crtc)
21
+
{
22
+
struct intel_digital_connector_state *conn_state;
23
+
struct intel_connector *connector;
24
+
int force_bpp_x16 = INT_MAX;
25
+
int i;
26
+
27
+
for_each_new_intel_connector_in_state(state, connector, conn_state, i) {
28
+
if (conn_state->base.crtc != &crtc->base)
29
+
continue;
30
+
31
+
if (!connector->link.force_bpp_x16)
32
+
continue;
33
+
34
+
force_bpp_x16 = min(force_bpp_x16, connector->link.force_bpp_x16);
35
+
}
36
+
37
+
return force_bpp_x16 < INT_MAX ? force_bpp_x16 : 0;
38
+
}
22
39
23
40
/**
24
41
* intel_link_bw_init_limits - initialize BW limits
···
58
31
limits->force_fec_pipes = 0;
59
32
limits->bpp_limit_reached_pipes = 0;
60
33
for_each_pipe(display, pipe) {
34
+
struct intel_crtc *crtc = intel_crtc_for_pipe(display, pipe);
61
35
const struct intel_crtc_state *crtc_state =
62
-
intel_atomic_get_new_crtc_state(state,
63
-
intel_crtc_for_pipe(display, pipe));
36
+
intel_atomic_get_new_crtc_state(state, crtc);
37
+
int forced_bpp_x16 = get_forced_link_bpp_x16(state, crtc);
64
38
65
39
if (state->base.duplicated && crtc_state) {
66
40
limits->max_bpp_x16[pipe] = crtc_state->max_link_bpp_x16;
···
70
42
} else {
71
43
limits->max_bpp_x16[pipe] = INT_MAX;
72
44
}
45
+
46
+
if (forced_bpp_x16)
47
+
limits->max_bpp_x16[pipe] = min(limits->max_bpp_x16[pipe], forced_bpp_x16);
73
48
}
74
49
}
75
50
76
51
/**
77
-
* intel_link_bw_reduce_bpp - reduce maximum link bpp for a selected pipe
52
+
* __intel_link_bw_reduce_bpp - reduce maximum link bpp for a selected pipe
78
53
* @state: atomic state
79
54
* @limits: link BW limits
80
55
* @pipe_mask: mask of pipes to select from
81
56
* @reason: explanation of why bpp reduction is needed
57
+
* @reduce_forced_bpp: allow reducing bpps below their forced link bpp
82
58
*
83
59
* Select the pipe from @pipe_mask with the biggest link bpp value and set the
84
60
* maximum of link bpp in @limits below this value. Modeset the selected pipe,
···
96
64
* - %-ENOSPC if no pipe can further reduce its link bpp
97
65
* - Other negative error, if modesetting the selected pipe failed
98
66
*/
99
-
int intel_link_bw_reduce_bpp(struct intel_atomic_state *state,
100
-
struct intel_link_bw_limits *limits,
101
-
u8 pipe_mask,
102
-
const char *reason)
67
+
static int __intel_link_bw_reduce_bpp(struct intel_atomic_state *state,
68
+
struct intel_link_bw_limits *limits,
69
+
u8 pipe_mask,
70
+
const char *reason,
71
+
bool reduce_forced_bpp)
103
72
{
104
73
struct intel_display *display = to_intel_display(state);
105
74
enum pipe max_bpp_pipe = INVALID_PIPE;
···
130
97
*/
131
98
link_bpp_x16 = fxp_q4_from_int(crtc_state->pipe_bpp);
132
99
100
+
if (!reduce_forced_bpp &&
101
+
link_bpp_x16 <= get_forced_link_bpp_x16(state, crtc))
102
+
continue;
103
+
133
104
if (link_bpp_x16 > max_bpp_x16) {
134
105
max_bpp_x16 = link_bpp_x16;
135
106
max_bpp_pipe = crtc->pipe;
···
147
110
148
111
return intel_modeset_pipes_in_mask_early(state, reason,
149
112
BIT(max_bpp_pipe));
113
+
}
114
+
115
+
int intel_link_bw_reduce_bpp(struct intel_atomic_state *state,
116
+
struct intel_link_bw_limits *limits,
117
+
u8 pipe_mask,
118
+
const char *reason)
119
+
{
120
+
int ret;
121
+
122
+
/* Try to keep any forced link BPP. */
123
+
ret = __intel_link_bw_reduce_bpp(state, limits, pipe_mask, reason, false);
124
+
if (ret == -ENOSPC)
125
+
ret = __intel_link_bw_reduce_bpp(state, limits, pipe_mask, reason, true);
126
+
127
+
return ret;
150
128
}
151
129
152
130
/**
···
296
244
return -EINVAL;
297
245
298
246
return -EAGAIN;
247
+
}
248
+
249
+
static int force_link_bpp_show(struct seq_file *m, void *data)
250
+
{
251
+
struct intel_connector *connector = m->private;
252
+
253
+
seq_printf(m, FXP_Q4_FMT "\n", FXP_Q4_ARGS(connector->link.force_bpp_x16));
254
+
255
+
return 0;
256
+
}
257
+
258
+
static int str_to_fxp_q4_nonneg_int(const char *str, int *val_x16)
259
+
{
260
+
unsigned int val;
261
+
int err;
262
+
263
+
err = kstrtouint(str, 10, &val);
264
+
if (err)
265
+
return err;
266
+
267
+
if (val > INT_MAX >> 4)
268
+
return -ERANGE;
269
+
270
+
*val_x16 = fxp_q4_from_int(val);
271
+
272
+
return 0;
273
+
}
274
+
275
+
/* modifies str */
276
+
static int str_to_fxp_q4_nonneg(char *str, int *val_x16)
277
+
{
278
+
const char *int_str;
279
+
char *frac_str;
280
+
int frac_digits;
281
+
int frac_val;
282
+
int err;
283
+
284
+
int_str = strim(str);
285
+
frac_str = strchr(int_str, '.');
286
+
287
+
if (frac_str)
288
+
*frac_str++ = '\0';
289
+
290
+
err = str_to_fxp_q4_nonneg_int(int_str, val_x16);
291
+
if (err)
292
+
return err;
293
+
294
+
if (!frac_str)
295
+
return 0;
296
+
297
+
/* prevent negative number/leading +- sign mark */
298
+
if (!isdigit(*frac_str))
299
+
return -EINVAL;
300
+
301
+
err = str_to_fxp_q4_nonneg_int(frac_str, &frac_val);
302
+
if (err)
303
+
return err;
304
+
305
+
frac_digits = strlen(frac_str);
306
+
if (frac_digits > intlog10(INT_MAX) >> 24 ||
307
+
frac_val > INT_MAX - int_pow(10, frac_digits) / 2)
308
+
return -ERANGE;
309
+
310
+
frac_val = DIV_ROUND_CLOSEST(frac_val, (int)int_pow(10, frac_digits));
311
+
312
+
if (*val_x16 > INT_MAX - frac_val)
313
+
return -ERANGE;
314
+
315
+
*val_x16 += frac_val;
316
+
317
+
return 0;
318
+
}
319
+
320
+
static int user_str_to_fxp_q4_nonneg(const char __user *ubuf, size_t len, int *val_x16)
321
+
{
322
+
char *kbuf;
323
+
int err;
324
+
325
+
kbuf = memdup_user_nul(ubuf, len);
326
+
if (IS_ERR(kbuf))
327
+
return PTR_ERR(kbuf);
328
+
329
+
err = str_to_fxp_q4_nonneg(kbuf, val_x16);
330
+
331
+
kfree(kbuf);
332
+
333
+
return err;
334
+
}
335
+
336
+
static bool connector_supports_dsc(struct intel_connector *connector)
337
+
{
338
+
struct intel_display *display = to_intel_display(connector);
339
+
340
+
switch (connector->base.connector_type) {
341
+
case DRM_MODE_CONNECTOR_eDP:
342
+
return intel_dp_has_dsc(connector);
343
+
case DRM_MODE_CONNECTOR_DisplayPort:
344
+
if (connector->mst.dp)
345
+
return HAS_DSC_MST(display);
346
+
347
+
return HAS_DSC(display);
348
+
default:
349
+
return false;
350
+
}
351
+
}
352
+
353
+
static ssize_t
354
+
force_link_bpp_write(struct file *file, const char __user *ubuf, size_t len, loff_t *offp)
355
+
{
356
+
struct seq_file *m = file->private_data;
357
+
struct intel_connector *connector = m->private;
358
+
struct intel_display *display = to_intel_display(connector);
359
+
int min_bpp;
360
+
int bpp_x16;
361
+
int err;
362
+
363
+
err = user_str_to_fxp_q4_nonneg(ubuf, len, &bpp_x16);
364
+
if (err)
365
+
return err;
366
+
367
+
/* TODO: Make the non-DSC min_bpp value connector specific. */
368
+
if (connector_supports_dsc(connector))
369
+
min_bpp = intel_dp_dsc_min_src_compressed_bpp();
370
+
else
371
+
min_bpp = intel_display_min_pipe_bpp();
372
+
373
+
if (bpp_x16 &&
374
+
(bpp_x16 < fxp_q4_from_int(min_bpp) ||
375
+
bpp_x16 > fxp_q4_from_int(intel_display_max_pipe_bpp(display))))
376
+
return -EINVAL;
377
+
378
+
err = drm_modeset_lock_single_interruptible(&display->drm->mode_config.connection_mutex);
379
+
if (err)
380
+
return err;
381
+
382
+
connector->link.force_bpp_x16 = bpp_x16;
383
+
384
+
drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
385
+
386
+
*offp += len;
387
+
388
+
return len;
389
+
}
390
+
DEFINE_SHOW_STORE_ATTRIBUTE(force_link_bpp);
391
+
392
+
void intel_link_bw_connector_debugfs_add(struct intel_connector *connector)
393
+
{
394
+
struct intel_display *display = to_intel_display(connector);
395
+
struct dentry *root = connector->base.debugfs_entry;
396
+
397
+
switch (connector->base.connector_type) {
398
+
case DRM_MODE_CONNECTOR_DisplayPort:
399
+
case DRM_MODE_CONNECTOR_eDP:
400
+
break;
401
+
case DRM_MODE_CONNECTOR_VGA:
402
+
case DRM_MODE_CONNECTOR_SVIDEO:
403
+
case DRM_MODE_CONNECTOR_LVDS:
404
+
case DRM_MODE_CONNECTOR_DVID:
405
+
if (HAS_FDI(display))
406
+
break;
407
+
408
+
return;
409
+
case DRM_MODE_CONNECTOR_HDMIA:
410
+
if (HAS_FDI(display) && !HAS_DDI(display))
411
+
break;
412
+
413
+
return;
414
+
default:
415
+
return;
416
+
}
417
+
418
+
debugfs_create_file("intel_force_link_bpp", 0644, root,
419
+
connector, &force_link_bpp_fops);
299
420
}
+2
drivers/gpu/drm/i915/display/intel_link_bw.h
+2
drivers/gpu/drm/i915/display/intel_link_bw.h
···
11
11
#include "intel_display_limits.h"
12
12
13
13
struct intel_atomic_state;
14
+
struct intel_connector;
14
15
struct intel_crtc_state;
15
16
16
17
struct intel_link_bw_limits {
···
33
32
enum pipe pipe);
34
33
int intel_link_bw_atomic_check(struct intel_atomic_state *state,
35
34
struct intel_link_bw_limits *new_limits);
35
+
void intel_link_bw_connector_debugfs_add(struct intel_connector *connector);
36
36
37
37
#endif