Commit | Line | Data |
---|---|---|
c8b75bca EA |
1 | /* |
2 | * Copyright (C) 2015 Broadcom | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or modify | |
5 | * it under the terms of the GNU General Public License version 2 as | |
6 | * published by the Free Software Foundation. | |
7 | */ | |
8 | ||
9 | /** | |
10 | * DOC: VC4 KMS | |
11 | * | |
12 | * This is the general code for implementing KMS mode setting that | |
13 | * doesn't clearly associate with any of the other objects (plane, | |
14 | * crtc, HDMI encoder). | |
15 | */ | |
16 | ||
17 | #include "drm_crtc.h" | |
b501bacc | 18 | #include "drm_atomic.h" |
c8b75bca EA |
19 | #include "drm_atomic_helper.h" |
20 | #include "drm_crtc_helper.h" | |
21 | #include "drm_plane_helper.h" | |
22 | #include "drm_fb_cma_helper.h" | |
23 | #include "vc4_drv.h" | |
24 | ||
48666d56 DF |
25 | static void vc4_output_poll_changed(struct drm_device *dev) |
26 | { | |
27 | struct vc4_dev *vc4 = to_vc4_dev(dev); | |
28 | ||
63fe9bb8 | 29 | drm_fbdev_cma_hotplug_event(vc4->fbdev); |
48666d56 DF |
30 | } |
31 | ||
b501bacc EA |
32 | struct vc4_commit { |
33 | struct drm_device *dev; | |
34 | struct drm_atomic_state *state; | |
35 | struct vc4_seqno_cb cb; | |
36 | }; | |
37 | ||
38 | static void | |
39 | vc4_atomic_complete_commit(struct vc4_commit *c) | |
40 | { | |
41 | struct drm_atomic_state *state = c->state; | |
42 | struct drm_device *dev = state->dev; | |
43 | struct vc4_dev *vc4 = to_vc4_dev(dev); | |
44 | ||
45 | drm_atomic_helper_commit_modeset_disables(dev, state); | |
46 | ||
47 | drm_atomic_helper_commit_planes(dev, state, false); | |
48 | ||
49 | drm_atomic_helper_commit_modeset_enables(dev, state); | |
50 | ||
6674a904 EA |
51 | /* Make sure that drm_atomic_helper_wait_for_vblanks() |
52 | * actually waits for vblank. If we're doing a full atomic | |
53 | * modeset (as opposed to a vc4_update_plane() short circuit), | |
54 | * then we need to wait for scanout to be done with our | |
55 | * display lists before we free it and potentially reallocate | |
56 | * and overwrite the dlist memory with a new modeset. | |
57 | */ | |
58 | state->legacy_cursor_update = false; | |
59 | ||
b501bacc EA |
60 | drm_atomic_helper_wait_for_vblanks(dev, state); |
61 | ||
62 | drm_atomic_helper_cleanup_planes(dev, state); | |
63 | ||
64 | drm_atomic_state_free(state); | |
65 | ||
66 | up(&vc4->async_modeset); | |
67 | ||
68 | kfree(c); | |
69 | } | |
70 | ||
71 | static void | |
72 | vc4_atomic_complete_commit_seqno_cb(struct vc4_seqno_cb *cb) | |
73 | { | |
74 | struct vc4_commit *c = container_of(cb, struct vc4_commit, cb); | |
75 | ||
76 | vc4_atomic_complete_commit(c); | |
77 | } | |
78 | ||
79 | static struct vc4_commit *commit_init(struct drm_atomic_state *state) | |
80 | { | |
81 | struct vc4_commit *c = kzalloc(sizeof(*c), GFP_KERNEL); | |
82 | ||
83 | if (!c) | |
84 | return NULL; | |
85 | c->dev = state->dev; | |
86 | c->state = state; | |
87 | ||
88 | return c; | |
89 | } | |
90 | ||
91 | /** | |
92 | * vc4_atomic_commit - commit validated state object | |
93 | * @dev: DRM device | |
94 | * @state: the driver state object | |
eb63961b | 95 | * @nonblock: nonblocking commit |
b501bacc EA |
96 | * |
97 | * This function commits a with drm_atomic_helper_check() pre-validated state | |
98 | * object. This can still fail when e.g. the framebuffer reservation fails. For | |
99 | * now this doesn't implement asynchronous commits. | |
100 | * | |
101 | * RETURNS | |
102 | * Zero for success or -errno. | |
103 | */ | |
104 | static int vc4_atomic_commit(struct drm_device *dev, | |
105 | struct drm_atomic_state *state, | |
eb63961b | 106 | bool nonblock) |
b501bacc EA |
107 | { |
108 | struct vc4_dev *vc4 = to_vc4_dev(dev); | |
109 | int ret; | |
110 | int i; | |
111 | uint64_t wait_seqno = 0; | |
112 | struct vc4_commit *c; | |
833cd78a DV |
113 | struct drm_plane *plane; |
114 | struct drm_plane_state *new_state; | |
b501bacc EA |
115 | |
116 | c = commit_init(state); | |
117 | if (!c) | |
118 | return -ENOMEM; | |
119 | ||
120 | /* Make sure that any outstanding modesets have finished. */ | |
e7c31f6f RF |
121 | if (nonblock) { |
122 | ret = down_trylock(&vc4->async_modeset); | |
123 | if (ret) { | |
124 | kfree(c); | |
125 | return -EBUSY; | |
126 | } | |
127 | } else { | |
128 | ret = down_interruptible(&vc4->async_modeset); | |
129 | if (ret) { | |
130 | kfree(c); | |
131 | return ret; | |
132 | } | |
b501bacc EA |
133 | } |
134 | ||
135 | ret = drm_atomic_helper_prepare_planes(dev, state); | |
136 | if (ret) { | |
137 | kfree(c); | |
138 | up(&vc4->async_modeset); | |
139 | return ret; | |
140 | } | |
141 | ||
833cd78a | 142 | for_each_plane_in_state(state, plane, new_state, i) { |
b501bacc EA |
143 | if ((plane->state->fb != new_state->fb) && new_state->fb) { |
144 | struct drm_gem_cma_object *cma_bo = | |
145 | drm_fb_cma_get_gem_obj(new_state->fb, 0); | |
146 | struct vc4_bo *bo = to_vc4_bo(&cma_bo->base); | |
147 | ||
148 | wait_seqno = max(bo->seqno, wait_seqno); | |
149 | } | |
150 | } | |
151 | ||
152 | /* | |
153 | * This is the point of no return - everything below never fails except | |
154 | * when the hw goes bonghits. Which means we can commit the new state on | |
155 | * the software side now. | |
156 | */ | |
157 | ||
5e84c269 | 158 | drm_atomic_helper_swap_state(state, true); |
b501bacc EA |
159 | |
160 | /* | |
161 | * Everything below can be run asynchronously without the need to grab | |
162 | * any modeset locks at all under one condition: It must be guaranteed | |
163 | * that the asynchronous work has either been cancelled (if the driver | |
164 | * supports it, which at least requires that the framebuffers get | |
165 | * cleaned up with drm_atomic_helper_cleanup_planes()) or completed | |
166 | * before the new state gets committed on the software side with | |
167 | * drm_atomic_helper_swap_state(). | |
168 | * | |
169 | * This scheme allows new atomic state updates to be prepared and | |
170 | * checked in parallel to the asynchronous completion of the previous | |
171 | * update. Which is important since compositors need to figure out the | |
172 | * composition of the next frame right after having submitted the | |
173 | * current layout. | |
174 | */ | |
175 | ||
eb63961b | 176 | if (nonblock) { |
b501bacc EA |
177 | vc4_queue_seqno_cb(dev, &c->cb, wait_seqno, |
178 | vc4_atomic_complete_commit_seqno_cb); | |
179 | } else { | |
180 | vc4_wait_for_seqno(dev, wait_seqno, ~0ull, false); | |
181 | vc4_atomic_complete_commit(c); | |
182 | } | |
183 | ||
184 | return 0; | |
185 | } | |
186 | ||
c8b75bca | 187 | static const struct drm_mode_config_funcs vc4_mode_funcs = { |
48666d56 | 188 | .output_poll_changed = vc4_output_poll_changed, |
c8b75bca | 189 | .atomic_check = drm_atomic_helper_check, |
b501bacc | 190 | .atomic_commit = vc4_atomic_commit, |
c8b75bca EA |
191 | .fb_create = drm_fb_cma_create, |
192 | }; | |
193 | ||
194 | int vc4_kms_load(struct drm_device *dev) | |
195 | { | |
48666d56 | 196 | struct vc4_dev *vc4 = to_vc4_dev(dev); |
c8b75bca EA |
197 | int ret; |
198 | ||
b501bacc EA |
199 | sema_init(&vc4->async_modeset, 1); |
200 | ||
c8b75bca EA |
201 | ret = drm_vblank_init(dev, dev->mode_config.num_crtc); |
202 | if (ret < 0) { | |
203 | dev_err(dev->dev, "failed to initialize vblank\n"); | |
204 | return ret; | |
205 | } | |
206 | ||
207 | dev->mode_config.max_width = 2048; | |
208 | dev->mode_config.max_height = 2048; | |
209 | dev->mode_config.funcs = &vc4_mode_funcs; | |
210 | dev->mode_config.preferred_depth = 24; | |
b501bacc EA |
211 | dev->mode_config.async_page_flip = true; |
212 | ||
c8b75bca EA |
213 | drm_mode_config_reset(dev); |
214 | ||
48666d56 DF |
215 | vc4->fbdev = drm_fbdev_cma_init(dev, 32, |
216 | dev->mode_config.num_crtc, | |
217 | dev->mode_config.num_connector); | |
218 | if (IS_ERR(vc4->fbdev)) | |
219 | vc4->fbdev = NULL; | |
c8b75bca EA |
220 | |
221 | drm_kms_helper_poll_init(dev); | |
222 | ||
223 | return 0; | |
224 | } |