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
|
// SPDX-License-Identifier: GPL-2.0+
#include "vkms_config.h"
#include "vkms_connector.h"
#include "vkms_drv.h"
#include <drm/drm_managed.h>
int vkms_output_init(struct vkms_device *vkmsdev)
{
struct drm_device *dev = &vkmsdev->drm;
struct vkms_config_plane *plane_cfg;
struct vkms_config_crtc *crtc_cfg;
struct vkms_config_encoder *encoder_cfg;
struct vkms_config_connector *connector_cfg;
int ret;
int writeback;
if (!vkms_config_is_valid(vkmsdev->config))
return -EINVAL;
vkms_config_for_each_plane(vkmsdev->config, plane_cfg) {
enum drm_plane_type type;
type = vkms_config_plane_get_type(plane_cfg);
plane_cfg->plane = vkms_plane_init(vkmsdev, type);
if (IS_ERR(plane_cfg->plane)) {
DRM_DEV_ERROR(dev->dev, "Failed to init vkms plane\n");
return PTR_ERR(plane_cfg->plane);
}
}
vkms_config_for_each_crtc(vkmsdev->config, crtc_cfg) {
struct vkms_config_plane *primary, *cursor;
primary = vkms_config_crtc_primary_plane(vkmsdev->config, crtc_cfg);
cursor = vkms_config_crtc_cursor_plane(vkmsdev->config, crtc_cfg);
crtc_cfg->crtc = vkms_crtc_init(dev, &primary->plane->base,
cursor ? &cursor->plane->base : NULL);
if (IS_ERR(crtc_cfg->crtc)) {
DRM_ERROR("Failed to allocate CRTC\n");
return PTR_ERR(crtc_cfg->crtc);
}
/* Initialize the writeback component */
if (vkms_config_crtc_get_writeback(crtc_cfg)) {
writeback = vkms_enable_writeback_connector(vkmsdev, crtc_cfg->crtc);
if (writeback)
DRM_ERROR("Failed to init writeback connector\n");
}
}
vkms_config_for_each_plane(vkmsdev->config, plane_cfg) {
struct vkms_config_crtc *possible_crtc;
unsigned long idx = 0;
vkms_config_plane_for_each_possible_crtc(plane_cfg, idx, possible_crtc) {
plane_cfg->plane->base.possible_crtcs |=
drm_crtc_mask(&possible_crtc->crtc->crtc);
}
}
vkms_config_for_each_encoder(vkmsdev->config, encoder_cfg) {
struct vkms_config_crtc *possible_crtc;
unsigned long idx = 0;
encoder_cfg->encoder = drmm_kzalloc(dev, sizeof(*encoder_cfg->encoder), GFP_KERNEL);
if (!encoder_cfg->encoder) {
DRM_ERROR("Failed to allocate encoder\n");
return -ENOMEM;
}
ret = drmm_encoder_init(dev, encoder_cfg->encoder, NULL,
DRM_MODE_ENCODER_VIRTUAL, NULL);
if (ret) {
DRM_ERROR("Failed to init encoder\n");
return ret;
}
vkms_config_encoder_for_each_possible_crtc(encoder_cfg, idx, possible_crtc) {
encoder_cfg->encoder->possible_crtcs |=
drm_crtc_mask(&possible_crtc->crtc->crtc);
}
}
vkms_config_for_each_connector(vkmsdev->config, connector_cfg) {
struct vkms_config_encoder *possible_encoder;
unsigned long idx = 0;
connector_cfg->connector = vkms_connector_init(vkmsdev);
if (IS_ERR(connector_cfg->connector)) {
DRM_ERROR("Failed to init connector\n");
return PTR_ERR(connector_cfg->connector);
}
vkms_config_connector_for_each_possible_encoder(connector_cfg,
idx,
possible_encoder) {
ret = drm_connector_attach_encoder(&connector_cfg->connector->base,
possible_encoder->encoder);
if (ret) {
DRM_ERROR("Failed to attach connector to encoder\n");
return ret;
}
}
}
drm_mode_config_reset(dev);
return 0;
}
|
