Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
drm/{i915, xe}/stolen: make struct intel_stolen_node opaque
Add i915_gem_stolen_node_alloc() and i915_gem_stolen_node_free(),
returning struct intel_stolen_node pointer. Make struct
intel_stolen_node an opaque pointer, with different implementations in
i915 and xe.
Reviewed-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Link: https://lore.kernel.org/r/3fe71bbb4c75ee86b4d129fafa3d4cd6526363f4.1758732183.git.jani.nikula@intel.com
Signed-off-by: Jani Nikula <jani.nikula@intel.com>
+89
-30
+38
-20
drivers/gpu/drm/i915/display/intel_fbc.c
+38
-20
drivers/gpu/drm/i915/display/intel_fbc.c
···
102
102
struct mutex lock;
103
103
unsigned int busy_bits;
104
104
105
-
struct intel_stolen_node compressed_fb, compressed_llb;
105
+
struct intel_stolen_node *compressed_fb;
106
+
struct intel_stolen_node *compressed_llb;
106
107
107
108
enum intel_fbc_id id;
108
109
···
381
380
382
381
drm_WARN_ON(display->drm,
383
382
range_end_overflows_t(u64, i915_gem_stolen_area_address(i915),
384
-
i915_gem_stolen_node_offset(&fbc->compressed_fb),
383
+
i915_gem_stolen_node_offset(fbc->compressed_fb),
385
384
U32_MAX));
386
385
drm_WARN_ON(display->drm,
387
386
range_end_overflows_t(u64, i915_gem_stolen_area_address(i915),
388
-
i915_gem_stolen_node_offset(&fbc->compressed_llb),
387
+
i915_gem_stolen_node_offset(fbc->compressed_llb),
389
388
U32_MAX));
390
389
intel_de_write(display, FBC_CFB_BASE,
391
-
i915_gem_stolen_node_address(i915, &fbc->compressed_fb));
390
+
i915_gem_stolen_node_address(i915, fbc->compressed_fb));
392
391
intel_de_write(display, FBC_LL_BASE,
393
-
i915_gem_stolen_node_address(i915, &fbc->compressed_llb));
392
+
i915_gem_stolen_node_address(i915, fbc->compressed_llb));
394
393
}
395
394
396
395
static const struct intel_fbc_funcs i8xx_fbc_funcs = {
···
498
497
struct intel_display *display = fbc->display;
499
498
500
499
intel_de_write(display, DPFC_CB_BASE,
501
-
i915_gem_stolen_node_offset(&fbc->compressed_fb));
500
+
i915_gem_stolen_node_offset(fbc->compressed_fb));
502
501
}
503
502
504
503
static const struct intel_fbc_funcs g4x_fbc_funcs = {
···
567
566
struct intel_display *display = fbc->display;
568
567
569
568
intel_de_write(display, ILK_DPFC_CB_BASE(fbc->id),
570
-
i915_gem_stolen_node_offset(&fbc->compressed_fb));
569
+
i915_gem_stolen_node_offset(fbc->compressed_fb));
571
570
}
572
571
573
572
static const struct intel_fbc_funcs ilk_fbc_funcs = {
···
843
842
size /= limit;
844
843
845
844
/* Try to over-allocate to reduce reallocations and fragmentation. */
846
-
ret = i915_gem_stolen_insert_node_in_range(i915, &fbc->compressed_fb,
845
+
ret = i915_gem_stolen_insert_node_in_range(i915, fbc->compressed_fb,
847
846
size <<= 1, 4096, 0, end);
848
847
if (ret == 0)
849
848
return limit;
850
849
851
850
for (; limit <= intel_fbc_max_limit(display); limit <<= 1) {
852
-
ret = i915_gem_stolen_insert_node_in_range(i915, &fbc->compressed_fb,
851
+
ret = i915_gem_stolen_insert_node_in_range(i915, fbc->compressed_fb,
853
852
size >>= 1, 4096, 0, end);
854
853
if (ret == 0)
855
854
return limit;
···
866
865
int ret;
867
866
868
867
drm_WARN_ON(display->drm,
869
-
i915_gem_stolen_node_allocated(&fbc->compressed_fb));
868
+
i915_gem_stolen_node_allocated(fbc->compressed_fb));
870
869
drm_WARN_ON(display->drm,
871
-
i915_gem_stolen_node_allocated(&fbc->compressed_llb));
870
+
i915_gem_stolen_node_allocated(fbc->compressed_llb));
872
871
873
872
if (DISPLAY_VER(display) < 5 && !display->platform.g4x) {
874
-
ret = i915_gem_stolen_insert_node(i915, &fbc->compressed_llb,
873
+
ret = i915_gem_stolen_insert_node(i915, fbc->compressed_llb,
875
874
4096, 4096);
876
875
if (ret)
877
876
goto err;
···
888
887
889
888
drm_dbg_kms(display->drm,
890
889
"reserved %llu bytes of contiguous stolen space for FBC, limit: %d\n",
891
-
i915_gem_stolen_node_size(&fbc->compressed_fb), fbc->limit);
890
+
i915_gem_stolen_node_size(fbc->compressed_fb), fbc->limit);
892
891
return 0;
893
892
894
893
err_llb:
895
-
if (i915_gem_stolen_node_allocated(&fbc->compressed_llb))
896
-
i915_gem_stolen_remove_node(i915, &fbc->compressed_llb);
894
+
if (i915_gem_stolen_node_allocated(fbc->compressed_llb))
895
+
i915_gem_stolen_remove_node(i915, fbc->compressed_llb);
897
896
err:
898
897
if (i915_gem_stolen_initialized(i915))
899
898
drm_info_once(display->drm,
···
952
951
if (WARN_ON(intel_fbc_hw_is_active(fbc)))
953
952
return;
954
953
955
-
if (i915_gem_stolen_node_allocated(&fbc->compressed_llb))
956
-
i915_gem_stolen_remove_node(i915, &fbc->compressed_llb);
957
-
if (i915_gem_stolen_node_allocated(&fbc->compressed_fb))
958
-
i915_gem_stolen_remove_node(i915, &fbc->compressed_fb);
954
+
if (i915_gem_stolen_node_allocated(fbc->compressed_llb))
955
+
i915_gem_stolen_remove_node(i915, fbc->compressed_llb);
956
+
if (i915_gem_stolen_node_allocated(fbc->compressed_fb))
957
+
i915_gem_stolen_remove_node(i915, fbc->compressed_fb);
959
958
}
960
959
961
960
void intel_fbc_cleanup(struct intel_display *display)
···
967
966
mutex_lock(&fbc->lock);
968
967
__intel_fbc_cleanup_cfb(fbc);
969
968
mutex_unlock(&fbc->lock);
969
+
970
+
i915_gem_stolen_node_free(fbc->compressed_fb);
971
+
i915_gem_stolen_node_free(fbc->compressed_llb);
970
972
971
973
kfree(fbc);
972
974
}
···
1359
1355
1360
1356
return intel_fbc_min_limit(plane_state) <= fbc->limit &&
1361
1357
intel_fbc_cfb_size(plane_state) <= fbc->limit *
1362
-
i915_gem_stolen_node_size(&fbc->compressed_fb);
1358
+
i915_gem_stolen_node_size(fbc->compressed_fb);
1363
1359
}
1364
1360
1365
1361
static bool intel_fbc_is_ok(const struct intel_plane_state *plane_state)
···
2087
2083
if (!fbc)
2088
2084
return NULL;
2089
2085
2086
+
fbc->compressed_fb = i915_gem_stolen_node_alloc(display->drm);
2087
+
if (!fbc->compressed_fb)
2088
+
goto err;
2089
+
fbc->compressed_llb = i915_gem_stolen_node_alloc(display->drm);
2090
+
if (!fbc->compressed_llb)
2091
+
goto err;
2092
+
2090
2093
fbc->id = fbc_id;
2091
2094
fbc->display = display;
2092
2095
INIT_WORK(&fbc->underrun_work, intel_fbc_underrun_work_fn);
···
2113
2102
fbc->funcs = &i8xx_fbc_funcs;
2114
2103
2115
2104
return fbc;
2105
+
2106
+
err:
2107
+
i915_gem_stolen_node_free(fbc->compressed_llb);
2108
+
i915_gem_stolen_node_free(fbc->compressed_fb);
2109
+
kfree(fbc);
2110
+
2111
+
return NULL;
2116
2112
}
2117
2113
2118
2114
/**
+20
drivers/gpu/drm/i915/gem/i915_gem_stolen.c
+20
drivers/gpu/drm/i915/gem/i915_gem_stolen.c
···
24
24
#include "intel_mchbar_regs.h"
25
25
#include "intel_pci_config.h"
26
26
27
+
struct intel_stolen_node {
28
+
struct drm_mm_node node;
29
+
};
30
+
27
31
/*
28
32
* The BIOS typically reserves some of the system's memory for the exclusive
29
33
* use of the integrated graphics. This memory is no longer available for
···
1060
1056
u64 i915_gem_stolen_node_size(const struct intel_stolen_node *node)
1061
1057
{
1062
1058
return node->node.size;
1059
+
}
1060
+
1061
+
struct intel_stolen_node *i915_gem_stolen_node_alloc(struct drm_device *drm)
1062
+
{
1063
+
struct intel_stolen_node *node;
1064
+
1065
+
node = kzalloc(sizeof(*node), GFP_KERNEL);
1066
+
if (!node)
1067
+
return NULL;
1068
+
1069
+
return node;
1070
+
}
1071
+
1072
+
void i915_gem_stolen_node_free(const struct intel_stolen_node *node)
1073
+
{
1074
+
kfree(node);
1063
1075
}
+5
-5
drivers/gpu/drm/i915/gem/i915_gem_stolen.h
+5
-5
drivers/gpu/drm/i915/gem/i915_gem_stolen.h
···
7
7
#define __I915_GEM_STOLEN_H__
8
8
9
9
#include <linux/types.h>
10
-
#include <drm/drm_mm.h>
11
10
11
+
struct drm_device;
12
12
struct drm_i915_gem_object;
13
13
struct drm_i915_private;
14
-
15
-
struct intel_stolen_node {
16
-
struct drm_mm_node node;
17
-
};
14
+
struct intel_stolen_node;
18
15
19
16
int i915_gem_stolen_insert_node(struct drm_i915_private *i915,
20
17
struct intel_stolen_node *node, u64 size,
···
47
50
bool i915_gem_stolen_node_allocated(const struct intel_stolen_node *node);
48
51
u64 i915_gem_stolen_node_offset(const struct intel_stolen_node *node);
49
52
u64 i915_gem_stolen_node_size(const struct intel_stolen_node *node);
53
+
54
+
struct intel_stolen_node *i915_gem_stolen_node_alloc(struct drm_device *drm);
55
+
void i915_gem_stolen_node_free(const struct intel_stolen_node *node);
50
56
51
57
#endif /* __I915_GEM_STOLEN_H__ */
+6
-5
drivers/gpu/drm/xe/compat-i915-headers/gem/i915_gem_stolen.h
+6
-5
drivers/gpu/drm/xe/compat-i915-headers/gem/i915_gem_stolen.h
···
8
8
9
9
#include <linux/types.h>
10
10
11
-
struct xe_bo;
11
+
struct drm_device;
12
+
struct intel_stolen_node;
12
13
struct xe_device;
13
-
14
-
struct intel_stolen_node {
15
-
struct xe_bo *bo;
16
-
};
17
14
18
15
int i915_gem_stolen_insert_node_in_range(struct xe_device *xe,
19
16
struct intel_stolen_node *node,
···
38
41
struct intel_stolen_node *node);
39
42
40
43
u64 i915_gem_stolen_node_size(const struct intel_stolen_node *node);
44
+
45
+
struct intel_stolen_node *i915_gem_stolen_node_alloc(struct drm_device *drm);
46
+
47
+
void i915_gem_stolen_node_free(const struct intel_stolen_node *node);
41
48
42
49
#endif
+20
drivers/gpu/drm/xe/display/xe_stolen.c
+20
drivers/gpu/drm/xe/display/xe_stolen.c
···
6
6
#include "xe_ttm_stolen_mgr.h"
7
7
#include "xe_validation.h"
8
8
9
+
struct intel_stolen_node {
10
+
struct xe_bo *bo;
11
+
};
12
+
9
13
int i915_gem_stolen_insert_node_in_range(struct xe_device *xe,
10
14
struct intel_stolen_node *node,
11
15
u32 size, u32 align,
···
100
96
u64 i915_gem_stolen_node_size(const struct intel_stolen_node *node)
101
97
{
102
98
return node->bo->ttm.base.size;
99
+
}
100
+
101
+
struct intel_stolen_node *i915_gem_stolen_node_alloc(struct drm_device *drm)
102
+
{
103
+
struct intel_stolen_node *node;
104
+
105
+
node = kzalloc(sizeof(*node), GFP_KERNEL);
106
+
if (!node)
107
+
return NULL;
108
+
109
+
return node;
110
+
}
111
+
112
+
void i915_gem_stolen_node_free(const struct intel_stolen_node *node)
113
+
{
114
+
kfree(node);
103
115
}