1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (C) Fuzhou Rockchip Electronics Co.Ltd
4 * Author:Mark Yao <mark.yao@rock-chips.com>
5 */
6
7 #include <linux/kernel.h>
8 #include <linux/devfreq.h>
9
10 #include <drm/drm.h>
11 #include <drm/drm_atomic.h>
12 #include <drm/drm_damage_helper.h>
13 #include <drm/drm_fb_helper.h>
14 #include <drm/drm_fourcc.h>
15 #include <drm/drm_gem_framebuffer_helper.h>
16 #include <drm/drm_probe_helper.h>
17 #include <soc/rockchip/rockchip_dmc.h>
18
19 #include "rockchip_drm_drv.h"
20 #include "rockchip_drm_fb.h"
21 #include "rockchip_drm_gem.h"
22 #include "rockchip_drm_logo.h"
23
is_rockchip_logo_fb(struct drm_framebuffer * fb)24 static bool is_rockchip_logo_fb(struct drm_framebuffer *fb)
25 {
26 return fb->flags & ROCKCHIP_DRM_MODE_LOGO_FB ? true : false;
27 }
28
__rockchip_drm_fb_destroy(struct drm_framebuffer * fb)29 static void __rockchip_drm_fb_destroy(struct drm_framebuffer *fb)
30 {
31 int i = 0;
32
33 drm_framebuffer_cleanup(fb);
34
35 if (is_rockchip_logo_fb(fb)) {
36 struct rockchip_drm_logo_fb *rockchip_logo_fb = to_rockchip_logo_fb(fb);
37
38 #ifndef MODULE
39 rockchip_free_loader_memory(fb->dev);
40 #endif
41 drm_gem_object_release(rockchip_logo_fb->fb.obj[0]);
42 kfree(rockchip_logo_fb);
43 } else {
44 for (i = 0; i < 4; i++) {
45 if (fb->obj[i])
46 drm_gem_object_put(fb->obj[i]);
47 }
48
49 kfree(fb);
50 }
51 }
52
rockchip_drm_fb_destroy_work(struct work_struct * work)53 static void rockchip_drm_fb_destroy_work(struct work_struct *work)
54 {
55 struct rockchip_drm_logo_fb *fb;
56
57 fb = container_of(to_delayed_work(work), struct rockchip_drm_logo_fb, destroy_work);
58
59 __rockchip_drm_fb_destroy(&fb->fb);
60 }
61
rockchip_drm_fb_destroy(struct drm_framebuffer * fb)62 static void rockchip_drm_fb_destroy(struct drm_framebuffer *fb)
63 {
64
65 if (is_rockchip_logo_fb(fb)) {
66 struct rockchip_drm_logo_fb *rockchip_logo_fb = to_rockchip_logo_fb(fb);
67
68 schedule_delayed_work(&rockchip_logo_fb->destroy_work, HZ);
69 } else {
70 __rockchip_drm_fb_destroy(fb);
71 }
72 }
73
rockchip_drm_gem_fb_create_handle(struct drm_framebuffer * fb,struct drm_file * file,unsigned int * handle)74 static int rockchip_drm_gem_fb_create_handle(struct drm_framebuffer *fb,
75 struct drm_file *file,
76 unsigned int *handle)
77 {
78 if (is_rockchip_logo_fb(fb))
79 return -EOPNOTSUPP;
80
81 return drm_gem_fb_create_handle(fb, file, handle);
82 }
83
84 static const struct drm_framebuffer_funcs rockchip_drm_fb_funcs = {
85 .destroy = rockchip_drm_fb_destroy,
86 .create_handle = rockchip_drm_gem_fb_create_handle,
87 };
88
89 struct drm_framebuffer *
rockchip_fb_alloc(struct drm_device * dev,const struct drm_mode_fb_cmd2 * mode_cmd,struct drm_gem_object ** obj,unsigned int num_planes)90 rockchip_fb_alloc(struct drm_device *dev, const struct drm_mode_fb_cmd2 *mode_cmd,
91 struct drm_gem_object **obj, unsigned int num_planes)
92 {
93 struct drm_framebuffer *fb;
94 int ret;
95 int i;
96
97 fb = kzalloc(sizeof(*fb), GFP_KERNEL);
98 if (!fb)
99 return ERR_PTR(-ENOMEM);
100
101 drm_helper_mode_fill_fb_struct(dev, fb, mode_cmd);
102
103 for (i = 0; i < num_planes; i++)
104 fb->obj[i] = obj[i];
105
106 ret = drm_framebuffer_init(dev, fb, &rockchip_drm_fb_funcs);
107 if (ret) {
108 DRM_DEV_ERROR(dev->dev,
109 "Failed to initialize framebuffer: %d\n",
110 ret);
111 kfree(fb);
112 return ERR_PTR(ret);
113 }
114
115 return fb;
116 }
117
118 struct drm_framebuffer *
rockchip_drm_logo_fb_alloc(struct drm_device * dev,const struct drm_mode_fb_cmd2 * mode_cmd,struct rockchip_logo * logo)119 rockchip_drm_logo_fb_alloc(struct drm_device *dev, const struct drm_mode_fb_cmd2 *mode_cmd,
120 struct rockchip_logo *logo)
121 {
122 int ret = 0;
123 struct rockchip_drm_logo_fb *rockchip_logo_fb;
124 struct drm_framebuffer *fb;
125
126 rockchip_logo_fb = kzalloc(sizeof(*rockchip_logo_fb), GFP_KERNEL);
127 if (!rockchip_logo_fb)
128 return ERR_PTR(-ENOMEM);
129 fb = &rockchip_logo_fb->fb;
130
131 drm_helper_mode_fill_fb_struct(dev, fb, mode_cmd);
132
133 ret = drm_framebuffer_init(dev, fb, &rockchip_drm_fb_funcs);
134 if (ret) {
135 DRM_DEV_ERROR(dev->dev,
136 "Failed to initialize rockchip logo fb: %d\n",
137 ret);
138 kfree(rockchip_logo_fb);
139 return ERR_PTR(ret);
140 }
141
142 fb->flags |= ROCKCHIP_DRM_MODE_LOGO_FB;
143 rockchip_logo_fb->logo = logo;
144 rockchip_logo_fb->fb.obj[0] = &rockchip_logo_fb->rk_obj.base;
145 drm_gem_object_init(dev, rockchip_logo_fb->fb.obj[0], PAGE_ALIGN(logo->size));
146 rockchip_logo_fb->rk_obj.dma_addr = logo->dma_addr;
147 rockchip_logo_fb->rk_obj.kvaddr = logo->kvaddr;
148 logo->count++;
149 INIT_DELAYED_WORK(&rockchip_logo_fb->destroy_work, rockchip_drm_fb_destroy_work);
150 return &rockchip_logo_fb->fb;
151 }
152
rockchip_drm_bandwidth_atomic_check(struct drm_device * dev,struct drm_atomic_state * state,struct dmcfreq_vop_info * vop_bw_info)153 static int rockchip_drm_bandwidth_atomic_check(struct drm_device *dev,
154 struct drm_atomic_state *state,
155 struct dmcfreq_vop_info *vop_bw_info)
156 {
157 struct rockchip_drm_private *priv = dev->dev_private;
158 struct drm_crtc_state *old_crtc_state;
159 const struct rockchip_crtc_funcs *funcs;
160 struct drm_crtc *crtc;
161 int i;
162
163 vop_bw_info->line_bw_mbyte = 0;
164 vop_bw_info->frame_bw_mbyte = 0;
165 vop_bw_info->plane_num = 0;
166 vop_bw_info->plane_num_4k = 0;
167
168 for_each_old_crtc_in_state(state, crtc, old_crtc_state, i) {
169 funcs = priv->crtc_funcs[drm_crtc_index(crtc)];
170
171 if (funcs && funcs->bandwidth)
172 funcs->bandwidth(crtc, old_crtc_state, vop_bw_info);
173 }
174
175 return 0;
176 }
177
drm_atomic_helper_connector_commit(struct drm_device * dev,struct drm_atomic_state * old_state)178 static void drm_atomic_helper_connector_commit(struct drm_device *dev,
179 struct drm_atomic_state *old_state)
180 {
181 struct drm_connector *connector;
182 struct drm_connector_state *new_conn_state;
183 int i;
184
185 for_each_new_connector_in_state(old_state, connector, new_conn_state, i) {
186 const struct drm_connector_helper_funcs *funcs;
187
188 funcs = connector->helper_private;
189 if (!funcs->atomic_commit)
190 continue;
191
192 funcs->atomic_commit(connector, new_conn_state);
193 }
194 }
195
196 /**
197 * rockchip_drm_atomic_helper_commit_tail_rpm - commit atomic update to hardware
198 * @old_state: new modeset state to be committed
199 *
200 * This is an alternative implementation for the
201 * &drm_mode_config_helper_funcs.atomic_commit_tail hook, for drivers
202 * that support runtime_pm or need the CRTC to be enabled to perform a
203 * commit. Otherwise, one should use the default implementation
204 * drm_atomic_helper_commit_tail().
205 */
rockchip_drm_atomic_helper_commit_tail_rpm(struct drm_atomic_state * old_state)206 static void rockchip_drm_atomic_helper_commit_tail_rpm(struct drm_atomic_state *old_state)
207 {
208 struct drm_device *dev = old_state->dev;
209 struct rockchip_drm_private *prv = dev->dev_private;
210 struct dmcfreq_vop_info vop_bw_info;
211
212 drm_atomic_helper_commit_modeset_disables(dev, old_state);
213
214 drm_atomic_helper_commit_modeset_enables(dev, old_state);
215
216 rockchip_drm_bandwidth_atomic_check(dev, old_state, &vop_bw_info);
217
218 rockchip_dmcfreq_vop_bandwidth_update(&vop_bw_info);
219
220 mutex_lock(&prv->ovl_lock);
221 drm_atomic_helper_commit_planes(dev, old_state, DRM_PLANE_COMMIT_ACTIVE_ONLY);
222 mutex_unlock(&prv->ovl_lock);
223
224 drm_atomic_helper_fake_vblank(old_state);
225
226 drm_atomic_helper_connector_commit(dev, old_state);
227
228 drm_atomic_helper_commit_hw_done(old_state);
229
230 drm_atomic_helper_wait_for_vblanks(dev, old_state);
231
232 drm_atomic_helper_cleanup_planes(dev, old_state);
233 }
234
235 static const struct drm_mode_config_helper_funcs rockchip_mode_config_helpers = {
236 .atomic_commit_tail = rockchip_drm_atomic_helper_commit_tail_rpm,
237 };
238
239 static struct drm_framebuffer *
rockchip_fb_create(struct drm_device * dev,struct drm_file * file,const struct drm_mode_fb_cmd2 * mode_cmd)240 rockchip_fb_create(struct drm_device *dev, struct drm_file *file,
241 const struct drm_mode_fb_cmd2 *mode_cmd)
242 {
243 struct drm_afbc_framebuffer *afbc_fb;
244 const struct drm_format_info *info;
245 int ret, i;
246
247 info = drm_get_format_info(dev, mode_cmd);
248 if (!info)
249 return ERR_PTR(-ENOMEM);
250
251 for (i = 0; i < info->num_planes; ++i) {
252 if (mode_cmd->pitches[i] % 4) {
253 DRM_DEV_ERROR_RATELIMITED(dev->dev,
254 "fb pitch[%d] must be 4 byte aligned: %d\n", i, mode_cmd->pitches[i]);
255 return ERR_PTR(-EINVAL);
256 }
257 }
258
259 afbc_fb = kzalloc(sizeof(*afbc_fb), GFP_KERNEL);
260 if (!afbc_fb)
261 return ERR_PTR(-ENOMEM);
262
263 ret = drm_gem_fb_init_with_funcs(dev, &afbc_fb->base, file, mode_cmd,
264 &rockchip_drm_fb_funcs);
265 if (ret) {
266 kfree(afbc_fb);
267 return ERR_PTR(ret);
268 }
269
270 if (drm_is_afbc(mode_cmd->modifier[0])) {
271 ret = drm_gem_fb_afbc_init(dev, mode_cmd, afbc_fb);
272 if (ret) {
273 struct drm_gem_object **obj = afbc_fb->base.obj;
274
275 for (i = 0; i < info->num_planes; ++i)
276 drm_gem_object_put(obj[i]);
277
278 kfree(afbc_fb);
279 return ERR_PTR(ret);
280 }
281 }
282
283 return &afbc_fb->base;
284 }
285
rockchip_drm_output_poll_changed(struct drm_device * dev)286 static void rockchip_drm_output_poll_changed(struct drm_device *dev)
287 {
288 struct rockchip_drm_private *private = dev->dev_private;
289 struct drm_fb_helper *fb_helper = private->fbdev_helper;
290
291 if (fb_helper && dev->mode_config.poll_enabled && !private->loader_protect)
292 drm_fb_helper_hotplug_event(fb_helper);
293 }
294
295 static const struct drm_mode_config_funcs rockchip_drm_mode_config_funcs = {
296 .fb_create = rockchip_fb_create,
297 .output_poll_changed = rockchip_drm_output_poll_changed,
298 .atomic_check = drm_atomic_helper_check,
299 .atomic_commit = drm_atomic_helper_commit,
300 };
301
302 struct drm_framebuffer *
rockchip_drm_framebuffer_init(struct drm_device * dev,const struct drm_mode_fb_cmd2 * mode_cmd,struct drm_gem_object * obj)303 rockchip_drm_framebuffer_init(struct drm_device *dev,
304 const struct drm_mode_fb_cmd2 *mode_cmd,
305 struct drm_gem_object *obj)
306 {
307 struct drm_framebuffer *fb;
308
309 fb = rockchip_fb_alloc(dev, mode_cmd, &obj, 1);
310 if (IS_ERR(fb))
311 return ERR_CAST(fb);
312
313 return fb;
314 }
315
rockchip_drm_mode_config_init(struct drm_device * dev)316 void rockchip_drm_mode_config_init(struct drm_device *dev)
317 {
318 dev->mode_config.min_width = 0;
319 dev->mode_config.min_height = 0;
320
321 /*
322 * set max width and height as default value(16384x16384).
323 * this value would be used to check framebuffer size limitation
324 * at drm_mode_addfb().
325 */
326 dev->mode_config.max_width = 16384;
327 dev->mode_config.max_height = 16384;
328 dev->mode_config.async_page_flip = true;
329
330 dev->mode_config.funcs = &rockchip_drm_mode_config_funcs;
331 dev->mode_config.helper_private = &rockchip_mode_config_helpers;
332 }
333