1 /*
2 * Copyright (c) 2006-2009 Red Hat Inc.
3 * Copyright (c) 2006-2008 Intel Corporation
4 * Copyright (c) 2007 Dave Airlie <airlied@linux.ie>
5 *
6 * DRM framebuffer helper functions
7 *
8 * Permission to use, copy, modify, distribute, and sell this software and its
9 * documentation for any purpose is hereby granted without fee, provided that
10 * the above copyright notice appear in all copies and that both that copyright
11 * notice and this permission notice appear in supporting documentation, and
12 * that the name of the copyright holders not be used in advertising or
13 * publicity pertaining to distribution of the software without specific,
14 * written prior permission. The copyright holders make no representations
15 * about the suitability of this software for any purpose. It is provided "as
16 * is" without express or implied warranty.
17 *
18 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
19 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
20 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
21 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
22 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
23 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
24 * OF THIS SOFTWARE.
25 *
26 * Authors:
27 * Dave Airlie <airlied@linux.ie>
28 * Jesse Barnes <jesse.barnes@intel.com>
29 */
30 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
31
32 #include <linux/console.h>
33 #include <linux/dma-buf.h>
34 #include <linux/kernel.h>
35 #include <linux/module.h>
36 #include <linux/slab.h>
37 #include <linux/sysrq.h>
38 #include <linux/vmalloc.h>
39
40 #include <drm/drm_atomic.h>
41 #include <drm/drm_crtc.h>
42 #include <drm/drm_crtc_helper.h>
43 #include <drm/drm_drv.h>
44 #include <drm/drm_fb_helper.h>
45 #include <drm/drm_fourcc.h>
46 #include <drm/drm_print.h>
47 #include <drm/drm_vblank.h>
48
49 #include "drm_crtc_helper_internal.h"
50 #include "drm_internal.h"
51
52 static bool drm_fbdev_emulation = true;
53 module_param_named(fbdev_emulation, drm_fbdev_emulation, bool, 0600);
54 MODULE_PARM_DESC(fbdev_emulation,
55 "Enable legacy fbdev emulation [default=true]");
56
57 static int drm_fbdev_overalloc = CONFIG_DRM_FBDEV_OVERALLOC;
58 module_param(drm_fbdev_overalloc, int, 0444);
59 MODULE_PARM_DESC(drm_fbdev_overalloc,
60 "Overallocation of the fbdev buffer (%) [default="
61 __MODULE_STRING(CONFIG_DRM_FBDEV_OVERALLOC) "]");
62
63 /*
64 * In order to keep user-space compatibility, we want in certain use-cases
65 * to keep leaking the fbdev physical address to the user-space program
66 * handling the fbdev buffer.
67 * This is a bad habit essentially kept into closed source opengl driver
68 * that should really be moved into open-source upstream projects instead
69 * of using legacy physical addresses in user space to communicate with
70 * other out-of-tree kernel modules.
71 *
72 * This module_param *should* be removed as soon as possible and be
73 * considered as a broken and legacy behaviour from a modern fbdev device.
74 */
75 #if IS_ENABLED(CONFIG_DRM_FBDEV_LEAK_PHYS_SMEM)
76 static bool drm_leak_fbdev_smem = false;
77 module_param_unsafe(drm_leak_fbdev_smem, bool, 0600);
78 MODULE_PARM_DESC(drm_leak_fbdev_smem,
79 "Allow unsafe leaking fbdev physical smem address [default=false]");
80 #endif
81
82 static LIST_HEAD(kernel_fb_helper_list);
83 static DEFINE_MUTEX(kernel_fb_helper_lock);
84
85 /**
86 * DOC: fbdev helpers
87 *
88 * The fb helper functions are useful to provide an fbdev on top of a drm kernel
89 * mode setting driver. They can be used mostly independently from the crtc
90 * helper functions used by many drivers to implement the kernel mode setting
91 * interfaces.
92 *
93 * Drivers that support a dumb buffer with a virtual address and mmap support,
94 * should try out the generic fbdev emulation using drm_fbdev_generic_setup().
95 * It will automatically set up deferred I/O if the driver requires a shadow
96 * buffer.
97 *
98 * At runtime drivers should restore the fbdev console by using
99 * drm_fb_helper_lastclose() as their &drm_driver.lastclose callback.
100 * They should also notify the fb helper code from updates to the output
101 * configuration by using drm_fb_helper_output_poll_changed() as their
102 * &drm_mode_config_funcs.output_poll_changed callback.
103 *
104 * For suspend/resume consider using drm_mode_config_helper_suspend() and
105 * drm_mode_config_helper_resume() which takes care of fbdev as well.
106 *
107 * All other functions exported by the fb helper library can be used to
108 * implement the fbdev driver interface by the driver.
109 *
110 * It is possible, though perhaps somewhat tricky, to implement race-free
111 * hotplug detection using the fbdev helpers. The drm_fb_helper_prepare()
112 * helper must be called first to initialize the minimum required to make
113 * hotplug detection work. Drivers also need to make sure to properly set up
114 * the &drm_mode_config.funcs member. After calling drm_kms_helper_poll_init()
115 * it is safe to enable interrupts and start processing hotplug events. At the
116 * same time, drivers should initialize all modeset objects such as CRTCs,
117 * encoders and connectors. To finish up the fbdev helper initialization, the
118 * drm_fb_helper_init() function is called. To probe for all attached displays
119 * and set up an initial configuration using the detected hardware, drivers
120 * should call drm_fb_helper_initial_config().
121 *
122 * If &drm_framebuffer_funcs.dirty is set, the
123 * drm_fb_helper_{cfb,sys}_{write,fillrect,copyarea,imageblit} functions will
124 * accumulate changes and schedule &drm_fb_helper.dirty_work to run right
125 * away. This worker then calls the dirty() function ensuring that it will
126 * always run in process context since the fb_*() function could be running in
127 * atomic context. If drm_fb_helper_deferred_io() is used as the deferred_io
128 * callback it will also schedule dirty_work with the damage collected from the
129 * mmap page writes.
130 *
131 * Deferred I/O is not compatible with SHMEM. Such drivers should request an
132 * fbdev shadow buffer and call drm_fbdev_generic_setup() instead.
133 */
134
drm_fb_helper_restore_lut_atomic(struct drm_crtc * crtc)135 static void drm_fb_helper_restore_lut_atomic(struct drm_crtc *crtc)
136 {
137 uint16_t *r_base, *g_base, *b_base;
138
139 if (crtc->funcs->gamma_set == NULL)
140 return;
141
142 r_base = crtc->gamma_store;
143 g_base = r_base + crtc->gamma_size;
144 b_base = g_base + crtc->gamma_size;
145
146 crtc->funcs->gamma_set(crtc, r_base, g_base, b_base,
147 crtc->gamma_size, NULL);
148 }
149
150 /**
151 * drm_fb_helper_debug_enter - implementation for &fb_ops.fb_debug_enter
152 * @info: fbdev registered by the helper
153 */
drm_fb_helper_debug_enter(struct fb_info * info)154 int drm_fb_helper_debug_enter(struct fb_info *info)
155 {
156 struct drm_fb_helper *helper = info->par;
157 const struct drm_crtc_helper_funcs *funcs;
158 struct drm_mode_set *mode_set;
159
160 list_for_each_entry(helper, &kernel_fb_helper_list, kernel_fb_list) {
161 mutex_lock(&helper->client.modeset_mutex);
162 drm_client_for_each_modeset(mode_set, &helper->client) {
163 if (!mode_set->crtc->enabled)
164 continue;
165
166 funcs = mode_set->crtc->helper_private;
167 if (funcs->mode_set_base_atomic == NULL)
168 continue;
169
170 if (drm_drv_uses_atomic_modeset(mode_set->crtc->dev))
171 continue;
172
173 funcs->mode_set_base_atomic(mode_set->crtc,
174 mode_set->fb,
175 mode_set->x,
176 mode_set->y,
177 ENTER_ATOMIC_MODE_SET);
178 }
179 mutex_unlock(&helper->client.modeset_mutex);
180 }
181
182 return 0;
183 }
184 EXPORT_SYMBOL(drm_fb_helper_debug_enter);
185
186 /**
187 * drm_fb_helper_debug_leave - implementation for &fb_ops.fb_debug_leave
188 * @info: fbdev registered by the helper
189 */
drm_fb_helper_debug_leave(struct fb_info * info)190 int drm_fb_helper_debug_leave(struct fb_info *info)
191 {
192 struct drm_fb_helper *helper = info->par;
193 struct drm_client_dev *client = &helper->client;
194 struct drm_device *dev = helper->dev;
195 struct drm_crtc *crtc;
196 const struct drm_crtc_helper_funcs *funcs;
197 struct drm_mode_set *mode_set;
198 struct drm_framebuffer *fb;
199
200 mutex_lock(&client->modeset_mutex);
201 drm_client_for_each_modeset(mode_set, client) {
202 crtc = mode_set->crtc;
203 if (drm_drv_uses_atomic_modeset(crtc->dev))
204 continue;
205
206 funcs = crtc->helper_private;
207 fb = crtc->primary->fb;
208
209 if (!crtc->enabled)
210 continue;
211
212 if (!fb) {
213 drm_err(dev, "no fb to restore?\n");
214 continue;
215 }
216
217 if (funcs->mode_set_base_atomic == NULL)
218 continue;
219
220 drm_fb_helper_restore_lut_atomic(mode_set->crtc);
221 funcs->mode_set_base_atomic(mode_set->crtc, fb, crtc->x,
222 crtc->y, LEAVE_ATOMIC_MODE_SET);
223 }
224 mutex_unlock(&client->modeset_mutex);
225
226 return 0;
227 }
228 EXPORT_SYMBOL(drm_fb_helper_debug_leave);
229
230 static int
__drm_fb_helper_restore_fbdev_mode_unlocked(struct drm_fb_helper * fb_helper,bool force)231 __drm_fb_helper_restore_fbdev_mode_unlocked(struct drm_fb_helper *fb_helper,
232 bool force)
233 {
234 bool do_delayed;
235 int ret;
236
237 if (!drm_fbdev_emulation || !fb_helper)
238 return -ENODEV;
239
240 if (READ_ONCE(fb_helper->deferred_setup))
241 return 0;
242
243 mutex_lock(&fb_helper->lock);
244 if (force) {
245 /*
246 * Yes this is the _locked version which expects the master lock
247 * to be held. But for forced restores we're intentionally
248 * racing here, see drm_fb_helper_set_par().
249 */
250 ret = drm_client_modeset_commit_locked(&fb_helper->client);
251 } else {
252 ret = drm_client_modeset_commit(&fb_helper->client);
253 }
254
255 do_delayed = fb_helper->delayed_hotplug;
256 if (do_delayed)
257 fb_helper->delayed_hotplug = false;
258 mutex_unlock(&fb_helper->lock);
259
260 if (do_delayed)
261 drm_fb_helper_hotplug_event(fb_helper);
262
263 return ret;
264 }
265
266 /**
267 * drm_fb_helper_restore_fbdev_mode_unlocked - restore fbdev configuration
268 * @fb_helper: driver-allocated fbdev helper, can be NULL
269 *
270 * This should be called from driver's drm &drm_driver.lastclose callback
271 * when implementing an fbcon on top of kms using this helper. This ensures that
272 * the user isn't greeted with a black screen when e.g. X dies.
273 *
274 * RETURNS:
275 * Zero if everything went ok, negative error code otherwise.
276 */
drm_fb_helper_restore_fbdev_mode_unlocked(struct drm_fb_helper * fb_helper)277 int drm_fb_helper_restore_fbdev_mode_unlocked(struct drm_fb_helper *fb_helper)
278 {
279 return __drm_fb_helper_restore_fbdev_mode_unlocked(fb_helper, false);
280 }
281 EXPORT_SYMBOL(drm_fb_helper_restore_fbdev_mode_unlocked);
282
283 #ifdef CONFIG_MAGIC_SYSRQ
284 /* emergency restore, don't bother with error reporting */
drm_fb_helper_restore_work_fn(struct work_struct * ignored)285 static void drm_fb_helper_restore_work_fn(struct work_struct *ignored)
286 {
287 struct drm_fb_helper *helper;
288
289 mutex_lock(&kernel_fb_helper_lock);
290 list_for_each_entry(helper, &kernel_fb_helper_list, kernel_fb_list) {
291 struct drm_device *dev = helper->dev;
292
293 if (dev->switch_power_state == DRM_SWITCH_POWER_OFF)
294 continue;
295
296 mutex_lock(&helper->lock);
297 drm_client_modeset_commit_locked(&helper->client);
298 mutex_unlock(&helper->lock);
299 }
300 mutex_unlock(&kernel_fb_helper_lock);
301 }
302
303 static DECLARE_WORK(drm_fb_helper_restore_work, drm_fb_helper_restore_work_fn);
304
drm_fb_helper_sysrq(int dummy1)305 static void drm_fb_helper_sysrq(int dummy1)
306 {
307 schedule_work(&drm_fb_helper_restore_work);
308 }
309
310 static const struct sysrq_key_op sysrq_drm_fb_helper_restore_op = {
311 .handler = drm_fb_helper_sysrq,
312 .help_msg = "force-fb(v)",
313 .action_msg = "Restore framebuffer console",
314 };
315 #else
316 static const struct sysrq_key_op sysrq_drm_fb_helper_restore_op = { };
317 #endif
318
drm_fb_helper_dpms(struct fb_info * info,int dpms_mode)319 static void drm_fb_helper_dpms(struct fb_info *info, int dpms_mode)
320 {
321 struct drm_fb_helper *fb_helper = info->par;
322
323 mutex_lock(&fb_helper->lock);
324 drm_client_modeset_dpms(&fb_helper->client, dpms_mode);
325 mutex_unlock(&fb_helper->lock);
326 }
327
328 /**
329 * drm_fb_helper_blank - implementation for &fb_ops.fb_blank
330 * @blank: desired blanking state
331 * @info: fbdev registered by the helper
332 */
drm_fb_helper_blank(int blank,struct fb_info * info)333 int drm_fb_helper_blank(int blank, struct fb_info *info)
334 {
335 if (oops_in_progress)
336 return -EBUSY;
337
338 switch (blank) {
339 /* Display: On; HSync: On, VSync: On */
340 case FB_BLANK_UNBLANK:
341 drm_fb_helper_dpms(info, DRM_MODE_DPMS_ON);
342 break;
343 /* Display: Off; HSync: On, VSync: On */
344 case FB_BLANK_NORMAL:
345 drm_fb_helper_dpms(info, DRM_MODE_DPMS_STANDBY);
346 break;
347 /* Display: Off; HSync: Off, VSync: On */
348 case FB_BLANK_HSYNC_SUSPEND:
349 drm_fb_helper_dpms(info, DRM_MODE_DPMS_STANDBY);
350 break;
351 /* Display: Off; HSync: On, VSync: Off */
352 case FB_BLANK_VSYNC_SUSPEND:
353 drm_fb_helper_dpms(info, DRM_MODE_DPMS_SUSPEND);
354 break;
355 /* Display: Off; HSync: Off, VSync: Off */
356 case FB_BLANK_POWERDOWN:
357 drm_fb_helper_dpms(info, DRM_MODE_DPMS_OFF);
358 break;
359 }
360 return 0;
361 }
362 EXPORT_SYMBOL(drm_fb_helper_blank);
363
drm_fb_helper_resume_worker(struct work_struct * work)364 static void drm_fb_helper_resume_worker(struct work_struct *work)
365 {
366 struct drm_fb_helper *helper = container_of(work, struct drm_fb_helper,
367 resume_work);
368
369 console_lock();
370 fb_set_suspend(helper->fbdev, 0);
371 console_unlock();
372 }
373
drm_fb_helper_damage_blit_real(struct drm_fb_helper * fb_helper,struct drm_clip_rect * clip,struct dma_buf_map * dst)374 static void drm_fb_helper_damage_blit_real(struct drm_fb_helper *fb_helper,
375 struct drm_clip_rect *clip,
376 struct dma_buf_map *dst)
377 {
378 struct drm_framebuffer *fb = fb_helper->fb;
379 unsigned int cpp = fb->format->cpp[0];
380 size_t offset = clip->y1 * fb->pitches[0] + clip->x1 * cpp;
381 void *src = fb_helper->fbdev->screen_buffer + offset;
382 size_t len = (clip->x2 - clip->x1) * cpp;
383 unsigned int y;
384
385 dma_buf_map_incr(dst, offset); /* go to first pixel within clip rect */
386
387 for (y = clip->y1; y < clip->y2; y++) {
388 dma_buf_map_memcpy_to(dst, src, len);
389 dma_buf_map_incr(dst, fb->pitches[0]);
390 src += fb->pitches[0];
391 }
392 }
393
drm_fb_helper_damage_blit(struct drm_fb_helper * fb_helper,struct drm_clip_rect * clip)394 static int drm_fb_helper_damage_blit(struct drm_fb_helper *fb_helper,
395 struct drm_clip_rect *clip)
396 {
397 struct drm_client_buffer *buffer = fb_helper->buffer;
398 struct dma_buf_map map, dst;
399 int ret;
400
401 /*
402 * We have to pin the client buffer to its current location while
403 * flushing the shadow buffer. In the general case, concurrent
404 * modesetting operations could try to move the buffer and would
405 * fail. The modeset has to be serialized by acquiring the reservation
406 * object of the underlying BO here.
407 *
408 * For fbdev emulation, we only have to protect against fbdev modeset
409 * operations. Nothing else will involve the client buffer's BO. So it
410 * is sufficient to acquire struct drm_fb_helper.lock here.
411 */
412 mutex_lock(&fb_helper->lock);
413
414 ret = drm_client_buffer_vmap(buffer, &map);
415 if (ret)
416 goto out;
417
418 dst = map;
419 drm_fb_helper_damage_blit_real(fb_helper, clip, &dst);
420
421 drm_client_buffer_vunmap(buffer);
422
423 out:
424 mutex_unlock(&fb_helper->lock);
425
426 return ret;
427 }
428
drm_fb_helper_damage_work(struct work_struct * work)429 static void drm_fb_helper_damage_work(struct work_struct *work)
430 {
431 struct drm_fb_helper *helper = container_of(work, struct drm_fb_helper,
432 damage_work);
433 struct drm_device *dev = helper->dev;
434 struct drm_clip_rect *clip = &helper->damage_clip;
435 struct drm_clip_rect clip_copy;
436 unsigned long flags;
437 int ret;
438
439 spin_lock_irqsave(&helper->damage_lock, flags);
440 clip_copy = *clip;
441 clip->x1 = clip->y1 = ~0;
442 clip->x2 = clip->y2 = 0;
443 spin_unlock_irqrestore(&helper->damage_lock, flags);
444
445 /* Call damage handlers only if necessary */
446 if (!(clip_copy.x1 < clip_copy.x2 && clip_copy.y1 < clip_copy.y2))
447 return;
448
449 if (helper->buffer) {
450 ret = drm_fb_helper_damage_blit(helper, &clip_copy);
451 if (drm_WARN_ONCE(dev, ret, "Damage blitter failed: ret=%d\n", ret))
452 goto err;
453 }
454
455 if (helper->fb->funcs->dirty) {
456 ret = helper->fb->funcs->dirty(helper->fb, NULL, 0, 0, &clip_copy, 1);
457 if (drm_WARN_ONCE(dev, ret, "Dirty helper failed: ret=%d\n", ret))
458 goto err;
459 }
460
461 return;
462
463 err:
464 /*
465 * Restore damage clip rectangle on errors. The next run
466 * of the damage worker will perform the update.
467 */
468 spin_lock_irqsave(&helper->damage_lock, flags);
469 clip->x1 = min_t(u32, clip->x1, clip_copy.x1);
470 clip->y1 = min_t(u32, clip->y1, clip_copy.y1);
471 clip->x2 = max_t(u32, clip->x2, clip_copy.x2);
472 clip->y2 = max_t(u32, clip->y2, clip_copy.y2);
473 spin_unlock_irqrestore(&helper->damage_lock, flags);
474 }
475
476 /**
477 * drm_fb_helper_prepare - setup a drm_fb_helper structure
478 * @dev: DRM device
479 * @helper: driver-allocated fbdev helper structure to set up
480 * @funcs: pointer to structure of functions associate with this helper
481 *
482 * Sets up the bare minimum to make the framebuffer helper usable. This is
483 * useful to implement race-free initialization of the polling helpers.
484 */
drm_fb_helper_prepare(struct drm_device * dev,struct drm_fb_helper * helper,const struct drm_fb_helper_funcs * funcs)485 void drm_fb_helper_prepare(struct drm_device *dev, struct drm_fb_helper *helper,
486 const struct drm_fb_helper_funcs *funcs)
487 {
488 INIT_LIST_HEAD(&helper->kernel_fb_list);
489 spin_lock_init(&helper->damage_lock);
490 INIT_WORK(&helper->resume_work, drm_fb_helper_resume_worker);
491 INIT_WORK(&helper->damage_work, drm_fb_helper_damage_work);
492 helper->damage_clip.x1 = helper->damage_clip.y1 = ~0;
493 mutex_init(&helper->lock);
494 helper->funcs = funcs;
495 helper->dev = dev;
496 }
497 EXPORT_SYMBOL(drm_fb_helper_prepare);
498
499 /**
500 * drm_fb_helper_init - initialize a &struct drm_fb_helper
501 * @dev: drm device
502 * @fb_helper: driver-allocated fbdev helper structure to initialize
503 *
504 * This allocates the structures for the fbdev helper with the given limits.
505 * Note that this won't yet touch the hardware (through the driver interfaces)
506 * nor register the fbdev. This is only done in drm_fb_helper_initial_config()
507 * to allow driver writes more control over the exact init sequence.
508 *
509 * Drivers must call drm_fb_helper_prepare() before calling this function.
510 *
511 * RETURNS:
512 * Zero if everything went ok, nonzero otherwise.
513 */
drm_fb_helper_init(struct drm_device * dev,struct drm_fb_helper * fb_helper)514 int drm_fb_helper_init(struct drm_device *dev,
515 struct drm_fb_helper *fb_helper)
516 {
517 int ret;
518
519 if (!drm_fbdev_emulation) {
520 dev->fb_helper = fb_helper;
521 return 0;
522 }
523
524 /*
525 * If this is not the generic fbdev client, initialize a drm_client
526 * without callbacks so we can use the modesets.
527 */
528 if (!fb_helper->client.funcs) {
529 ret = drm_client_init(dev, &fb_helper->client, "drm_fb_helper", NULL);
530 if (ret)
531 return ret;
532 }
533
534 dev->fb_helper = fb_helper;
535
536 return 0;
537 }
538 EXPORT_SYMBOL(drm_fb_helper_init);
539
540 /**
541 * drm_fb_helper_alloc_fbi - allocate fb_info and some of its members
542 * @fb_helper: driver-allocated fbdev helper
543 *
544 * A helper to alloc fb_info and the members cmap and apertures. Called
545 * by the driver within the fb_probe fb_helper callback function. Drivers do not
546 * need to release the allocated fb_info structure themselves, this is
547 * automatically done when calling drm_fb_helper_fini().
548 *
549 * RETURNS:
550 * fb_info pointer if things went okay, pointer containing error code
551 * otherwise
552 */
drm_fb_helper_alloc_fbi(struct drm_fb_helper * fb_helper)553 struct fb_info *drm_fb_helper_alloc_fbi(struct drm_fb_helper *fb_helper)
554 {
555 struct device *dev = fb_helper->dev->dev;
556 struct fb_info *info;
557 int ret;
558
559 info = framebuffer_alloc(0, dev);
560 if (!info)
561 return ERR_PTR(-ENOMEM);
562
563 ret = fb_alloc_cmap(&info->cmap, 256, 0);
564 if (ret)
565 goto err_release;
566
567 /*
568 * TODO: We really should be smarter here and alloc an aperture
569 * for each IORESOURCE_MEM resource helper->dev->dev has and also
570 * init the ranges of the appertures based on the resources.
571 * Note some drivers currently count on there being only 1 empty
572 * aperture and fill this themselves, these will need to be dealt
573 * with somehow when fixing this.
574 */
575 info->apertures = alloc_apertures(1);
576 if (!info->apertures) {
577 ret = -ENOMEM;
578 goto err_free_cmap;
579 }
580
581 fb_helper->fbdev = info;
582 info->skip_vt_switch = true;
583
584 return info;
585
586 err_free_cmap:
587 fb_dealloc_cmap(&info->cmap);
588 err_release:
589 framebuffer_release(info);
590 return ERR_PTR(ret);
591 }
592 EXPORT_SYMBOL(drm_fb_helper_alloc_fbi);
593
594 /**
595 * drm_fb_helper_unregister_fbi - unregister fb_info framebuffer device
596 * @fb_helper: driver-allocated fbdev helper, can be NULL
597 *
598 * A wrapper around unregister_framebuffer, to release the fb_info
599 * framebuffer device. This must be called before releasing all resources for
600 * @fb_helper by calling drm_fb_helper_fini().
601 */
drm_fb_helper_unregister_fbi(struct drm_fb_helper * fb_helper)602 void drm_fb_helper_unregister_fbi(struct drm_fb_helper *fb_helper)
603 {
604 if (fb_helper && fb_helper->fbdev)
605 unregister_framebuffer(fb_helper->fbdev);
606 }
607 EXPORT_SYMBOL(drm_fb_helper_unregister_fbi);
608
609 /**
610 * drm_fb_helper_fini - finialize a &struct drm_fb_helper
611 * @fb_helper: driver-allocated fbdev helper, can be NULL
612 *
613 * This cleans up all remaining resources associated with @fb_helper.
614 */
drm_fb_helper_fini(struct drm_fb_helper * fb_helper)615 void drm_fb_helper_fini(struct drm_fb_helper *fb_helper)
616 {
617 struct fb_info *info;
618
619 if (!fb_helper)
620 return;
621
622 fb_helper->dev->fb_helper = NULL;
623
624 if (!drm_fbdev_emulation)
625 return;
626
627 cancel_work_sync(&fb_helper->resume_work);
628 cancel_work_sync(&fb_helper->damage_work);
629
630 info = fb_helper->fbdev;
631 if (info) {
632 if (info->cmap.len)
633 fb_dealloc_cmap(&info->cmap);
634 framebuffer_release(info);
635 }
636 fb_helper->fbdev = NULL;
637
638 mutex_lock(&kernel_fb_helper_lock);
639 if (!list_empty(&fb_helper->kernel_fb_list)) {
640 list_del(&fb_helper->kernel_fb_list);
641 if (list_empty(&kernel_fb_helper_list))
642 unregister_sysrq_key('v', &sysrq_drm_fb_helper_restore_op);
643 }
644 mutex_unlock(&kernel_fb_helper_lock);
645
646 mutex_destroy(&fb_helper->lock);
647
648 if (!fb_helper->client.funcs)
649 drm_client_release(&fb_helper->client);
650 }
651 EXPORT_SYMBOL(drm_fb_helper_fini);
652
drm_fbdev_use_shadow_fb(struct drm_fb_helper * fb_helper)653 static bool drm_fbdev_use_shadow_fb(struct drm_fb_helper *fb_helper)
654 {
655 struct drm_device *dev = fb_helper->dev;
656 struct drm_framebuffer *fb = fb_helper->fb;
657
658 return dev->mode_config.prefer_shadow_fbdev ||
659 dev->mode_config.prefer_shadow ||
660 fb->funcs->dirty;
661 }
662
drm_fb_helper_damage(struct fb_info * info,u32 x,u32 y,u32 width,u32 height)663 static void drm_fb_helper_damage(struct fb_info *info, u32 x, u32 y,
664 u32 width, u32 height)
665 {
666 struct drm_fb_helper *helper = info->par;
667 struct drm_clip_rect *clip = &helper->damage_clip;
668 unsigned long flags;
669
670 if (!drm_fbdev_use_shadow_fb(helper))
671 return;
672
673 spin_lock_irqsave(&helper->damage_lock, flags);
674 clip->x1 = min_t(u32, clip->x1, x);
675 clip->y1 = min_t(u32, clip->y1, y);
676 clip->x2 = max_t(u32, clip->x2, x + width);
677 clip->y2 = max_t(u32, clip->y2, y + height);
678 spin_unlock_irqrestore(&helper->damage_lock, flags);
679
680 schedule_work(&helper->damage_work);
681 }
682
683 /**
684 * drm_fb_helper_deferred_io() - fbdev deferred_io callback function
685 * @info: fb_info struct pointer
686 * @pagereflist: list of mmap framebuffer pages that have to be flushed
687 *
688 * This function is used as the &fb_deferred_io.deferred_io
689 * callback function for flushing the fbdev mmap writes.
690 */
drm_fb_helper_deferred_io(struct fb_info * info,struct list_head * pagereflist)691 void drm_fb_helper_deferred_io(struct fb_info *info, struct list_head *pagereflist)
692 {
693 unsigned long start, end, min, max;
694 struct fb_deferred_io_pageref *pageref;
695 u32 y1, y2;
696
697 min = ULONG_MAX;
698 max = 0;
699 list_for_each_entry(pageref, pagereflist, list) {
700 start = pageref->offset;
701 end = start + PAGE_SIZE - 1;
702 min = min(min, start);
703 max = max(max, end);
704 }
705
706 if (min < max) {
707 y1 = min / info->fix.line_length;
708 y2 = min_t(u32, DIV_ROUND_UP(max, info->fix.line_length),
709 info->var.yres);
710 drm_fb_helper_damage(info, 0, y1, info->var.xres, y2 - y1);
711 }
712 }
713 EXPORT_SYMBOL(drm_fb_helper_deferred_io);
714
715 /**
716 * drm_fb_helper_sys_read - wrapper around fb_sys_read
717 * @info: fb_info struct pointer
718 * @buf: userspace buffer to read from framebuffer memory
719 * @count: number of bytes to read from framebuffer memory
720 * @ppos: read offset within framebuffer memory
721 *
722 * A wrapper around fb_sys_read implemented by fbdev core
723 */
drm_fb_helper_sys_read(struct fb_info * info,char __user * buf,size_t count,loff_t * ppos)724 ssize_t drm_fb_helper_sys_read(struct fb_info *info, char __user *buf,
725 size_t count, loff_t *ppos)
726 {
727 return fb_sys_read(info, buf, count, ppos);
728 }
729 EXPORT_SYMBOL(drm_fb_helper_sys_read);
730
731 /**
732 * drm_fb_helper_sys_write - wrapper around fb_sys_write
733 * @info: fb_info struct pointer
734 * @buf: userspace buffer to write to framebuffer memory
735 * @count: number of bytes to write to framebuffer memory
736 * @ppos: write offset within framebuffer memory
737 *
738 * A wrapper around fb_sys_write implemented by fbdev core
739 */
drm_fb_helper_sys_write(struct fb_info * info,const char __user * buf,size_t count,loff_t * ppos)740 ssize_t drm_fb_helper_sys_write(struct fb_info *info, const char __user *buf,
741 size_t count, loff_t *ppos)
742 {
743 ssize_t ret;
744
745 ret = fb_sys_write(info, buf, count, ppos);
746 if (ret > 0)
747 drm_fb_helper_damage(info, 0, 0, info->var.xres, info->var.yres);
748
749 return ret;
750 }
751 EXPORT_SYMBOL(drm_fb_helper_sys_write);
752
753 /**
754 * drm_fb_helper_sys_fillrect - wrapper around sys_fillrect
755 * @info: fbdev registered by the helper
756 * @rect: info about rectangle to fill
757 *
758 * A wrapper around sys_fillrect implemented by fbdev core
759 */
drm_fb_helper_sys_fillrect(struct fb_info * info,const struct fb_fillrect * rect)760 void drm_fb_helper_sys_fillrect(struct fb_info *info,
761 const struct fb_fillrect *rect)
762 {
763 sys_fillrect(info, rect);
764 drm_fb_helper_damage(info, rect->dx, rect->dy, rect->width, rect->height);
765 }
766 EXPORT_SYMBOL(drm_fb_helper_sys_fillrect);
767
768 /**
769 * drm_fb_helper_sys_copyarea - wrapper around sys_copyarea
770 * @info: fbdev registered by the helper
771 * @area: info about area to copy
772 *
773 * A wrapper around sys_copyarea implemented by fbdev core
774 */
drm_fb_helper_sys_copyarea(struct fb_info * info,const struct fb_copyarea * area)775 void drm_fb_helper_sys_copyarea(struct fb_info *info,
776 const struct fb_copyarea *area)
777 {
778 sys_copyarea(info, area);
779 drm_fb_helper_damage(info, area->dx, area->dy, area->width, area->height);
780 }
781 EXPORT_SYMBOL(drm_fb_helper_sys_copyarea);
782
783 /**
784 * drm_fb_helper_sys_imageblit - wrapper around sys_imageblit
785 * @info: fbdev registered by the helper
786 * @image: info about image to blit
787 *
788 * A wrapper around sys_imageblit implemented by fbdev core
789 */
drm_fb_helper_sys_imageblit(struct fb_info * info,const struct fb_image * image)790 void drm_fb_helper_sys_imageblit(struct fb_info *info,
791 const struct fb_image *image)
792 {
793 sys_imageblit(info, image);
794 drm_fb_helper_damage(info, image->dx, image->dy, image->width, image->height);
795 }
796 EXPORT_SYMBOL(drm_fb_helper_sys_imageblit);
797
798 /**
799 * drm_fb_helper_cfb_fillrect - wrapper around cfb_fillrect
800 * @info: fbdev registered by the helper
801 * @rect: info about rectangle to fill
802 *
803 * A wrapper around cfb_fillrect implemented by fbdev core
804 */
drm_fb_helper_cfb_fillrect(struct fb_info * info,const struct fb_fillrect * rect)805 void drm_fb_helper_cfb_fillrect(struct fb_info *info,
806 const struct fb_fillrect *rect)
807 {
808 cfb_fillrect(info, rect);
809 drm_fb_helper_damage(info, rect->dx, rect->dy, rect->width, rect->height);
810 }
811 EXPORT_SYMBOL(drm_fb_helper_cfb_fillrect);
812
813 /**
814 * drm_fb_helper_cfb_copyarea - wrapper around cfb_copyarea
815 * @info: fbdev registered by the helper
816 * @area: info about area to copy
817 *
818 * A wrapper around cfb_copyarea implemented by fbdev core
819 */
drm_fb_helper_cfb_copyarea(struct fb_info * info,const struct fb_copyarea * area)820 void drm_fb_helper_cfb_copyarea(struct fb_info *info,
821 const struct fb_copyarea *area)
822 {
823 cfb_copyarea(info, area);
824 drm_fb_helper_damage(info, area->dx, area->dy, area->width, area->height);
825 }
826 EXPORT_SYMBOL(drm_fb_helper_cfb_copyarea);
827
828 /**
829 * drm_fb_helper_cfb_imageblit - wrapper around cfb_imageblit
830 * @info: fbdev registered by the helper
831 * @image: info about image to blit
832 *
833 * A wrapper around cfb_imageblit implemented by fbdev core
834 */
drm_fb_helper_cfb_imageblit(struct fb_info * info,const struct fb_image * image)835 void drm_fb_helper_cfb_imageblit(struct fb_info *info,
836 const struct fb_image *image)
837 {
838 cfb_imageblit(info, image);
839 drm_fb_helper_damage(info, image->dx, image->dy, image->width, image->height);
840 }
841 EXPORT_SYMBOL(drm_fb_helper_cfb_imageblit);
842
843 /**
844 * drm_fb_helper_set_suspend - wrapper around fb_set_suspend
845 * @fb_helper: driver-allocated fbdev helper, can be NULL
846 * @suspend: whether to suspend or resume
847 *
848 * A wrapper around fb_set_suspend implemented by fbdev core.
849 * Use drm_fb_helper_set_suspend_unlocked() if you don't need to take
850 * the lock yourself
851 */
drm_fb_helper_set_suspend(struct drm_fb_helper * fb_helper,bool suspend)852 void drm_fb_helper_set_suspend(struct drm_fb_helper *fb_helper, bool suspend)
853 {
854 if (fb_helper && fb_helper->fbdev)
855 fb_set_suspend(fb_helper->fbdev, suspend);
856 }
857 EXPORT_SYMBOL(drm_fb_helper_set_suspend);
858
859 /**
860 * drm_fb_helper_set_suspend_unlocked - wrapper around fb_set_suspend that also
861 * takes the console lock
862 * @fb_helper: driver-allocated fbdev helper, can be NULL
863 * @suspend: whether to suspend or resume
864 *
865 * A wrapper around fb_set_suspend() that takes the console lock. If the lock
866 * isn't available on resume, a worker is tasked with waiting for the lock
867 * to become available. The console lock can be pretty contented on resume
868 * due to all the printk activity.
869 *
870 * This function can be called multiple times with the same state since
871 * &fb_info.state is checked to see if fbdev is running or not before locking.
872 *
873 * Use drm_fb_helper_set_suspend() if you need to take the lock yourself.
874 */
drm_fb_helper_set_suspend_unlocked(struct drm_fb_helper * fb_helper,bool suspend)875 void drm_fb_helper_set_suspend_unlocked(struct drm_fb_helper *fb_helper,
876 bool suspend)
877 {
878 if (!fb_helper || !fb_helper->fbdev)
879 return;
880
881 /* make sure there's no pending/ongoing resume */
882 flush_work(&fb_helper->resume_work);
883
884 if (suspend) {
885 if (fb_helper->fbdev->state != FBINFO_STATE_RUNNING)
886 return;
887
888 console_lock();
889
890 } else {
891 if (fb_helper->fbdev->state == FBINFO_STATE_RUNNING)
892 return;
893
894 if (!console_trylock()) {
895 schedule_work(&fb_helper->resume_work);
896 return;
897 }
898 }
899
900 fb_set_suspend(fb_helper->fbdev, suspend);
901 console_unlock();
902 }
903 EXPORT_SYMBOL(drm_fb_helper_set_suspend_unlocked);
904
setcmap_pseudo_palette(struct fb_cmap * cmap,struct fb_info * info)905 static int setcmap_pseudo_palette(struct fb_cmap *cmap, struct fb_info *info)
906 {
907 u32 *palette = (u32 *)info->pseudo_palette;
908 int i;
909
910 if (cmap->start + cmap->len > 16)
911 return -EINVAL;
912
913 for (i = 0; i < cmap->len; ++i) {
914 u16 red = cmap->red[i];
915 u16 green = cmap->green[i];
916 u16 blue = cmap->blue[i];
917 u32 value;
918
919 red >>= 16 - info->var.red.length;
920 green >>= 16 - info->var.green.length;
921 blue >>= 16 - info->var.blue.length;
922 value = (red << info->var.red.offset) |
923 (green << info->var.green.offset) |
924 (blue << info->var.blue.offset);
925 if (info->var.transp.length > 0) {
926 u32 mask = (1 << info->var.transp.length) - 1;
927
928 mask <<= info->var.transp.offset;
929 value |= mask;
930 }
931 palette[cmap->start + i] = value;
932 }
933
934 return 0;
935 }
936
setcmap_legacy(struct fb_cmap * cmap,struct fb_info * info)937 static int setcmap_legacy(struct fb_cmap *cmap, struct fb_info *info)
938 {
939 struct drm_fb_helper *fb_helper = info->par;
940 struct drm_mode_set *modeset;
941 struct drm_crtc *crtc;
942 u16 *r, *g, *b;
943 int ret = 0;
944
945 drm_modeset_lock_all(fb_helper->dev);
946 drm_client_for_each_modeset(modeset, &fb_helper->client) {
947 crtc = modeset->crtc;
948 if (!crtc->funcs->gamma_set || !crtc->gamma_size) {
949 ret = -EINVAL;
950 goto out;
951 }
952
953 if (cmap->start + cmap->len > crtc->gamma_size) {
954 ret = -EINVAL;
955 goto out;
956 }
957
958 r = crtc->gamma_store;
959 g = r + crtc->gamma_size;
960 b = g + crtc->gamma_size;
961
962 memcpy(r + cmap->start, cmap->red, cmap->len * sizeof(*r));
963 memcpy(g + cmap->start, cmap->green, cmap->len * sizeof(*g));
964 memcpy(b + cmap->start, cmap->blue, cmap->len * sizeof(*b));
965
966 ret = crtc->funcs->gamma_set(crtc, r, g, b,
967 crtc->gamma_size, NULL);
968 if (ret)
969 goto out;
970 }
971 out:
972 drm_modeset_unlock_all(fb_helper->dev);
973
974 return ret;
975 }
976
setcmap_new_gamma_lut(struct drm_crtc * crtc,struct fb_cmap * cmap)977 static struct drm_property_blob *setcmap_new_gamma_lut(struct drm_crtc *crtc,
978 struct fb_cmap *cmap)
979 {
980 struct drm_device *dev = crtc->dev;
981 struct drm_property_blob *gamma_lut;
982 struct drm_color_lut *lut;
983 int size = crtc->gamma_size;
984 int i;
985
986 if (!size || cmap->start + cmap->len > size)
987 return ERR_PTR(-EINVAL);
988
989 gamma_lut = drm_property_create_blob(dev, sizeof(*lut) * size, NULL);
990 if (IS_ERR(gamma_lut))
991 return gamma_lut;
992
993 lut = gamma_lut->data;
994 if (cmap->start || cmap->len != size) {
995 u16 *r = crtc->gamma_store;
996 u16 *g = r + crtc->gamma_size;
997 u16 *b = g + crtc->gamma_size;
998
999 for (i = 0; i < cmap->start; i++) {
1000 lut[i].red = r[i];
1001 lut[i].green = g[i];
1002 lut[i].blue = b[i];
1003 }
1004 for (i = cmap->start + cmap->len; i < size; i++) {
1005 lut[i].red = r[i];
1006 lut[i].green = g[i];
1007 lut[i].blue = b[i];
1008 }
1009 }
1010
1011 for (i = 0; i < cmap->len; i++) {
1012 lut[cmap->start + i].red = cmap->red[i];
1013 lut[cmap->start + i].green = cmap->green[i];
1014 lut[cmap->start + i].blue = cmap->blue[i];
1015 }
1016
1017 return gamma_lut;
1018 }
1019
setcmap_atomic(struct fb_cmap * cmap,struct fb_info * info)1020 static int setcmap_atomic(struct fb_cmap *cmap, struct fb_info *info)
1021 {
1022 struct drm_fb_helper *fb_helper = info->par;
1023 struct drm_device *dev = fb_helper->dev;
1024 struct drm_property_blob *gamma_lut = NULL;
1025 struct drm_modeset_acquire_ctx ctx;
1026 struct drm_crtc_state *crtc_state;
1027 struct drm_atomic_state *state;
1028 struct drm_mode_set *modeset;
1029 struct drm_crtc *crtc;
1030 u16 *r, *g, *b;
1031 bool replaced;
1032 int ret = 0;
1033
1034 drm_modeset_acquire_init(&ctx, 0);
1035
1036 state = drm_atomic_state_alloc(dev);
1037 if (!state) {
1038 ret = -ENOMEM;
1039 goto out_ctx;
1040 }
1041
1042 state->acquire_ctx = &ctx;
1043 retry:
1044 drm_client_for_each_modeset(modeset, &fb_helper->client) {
1045 crtc = modeset->crtc;
1046
1047 if (!gamma_lut)
1048 gamma_lut = setcmap_new_gamma_lut(crtc, cmap);
1049 if (IS_ERR(gamma_lut)) {
1050 ret = PTR_ERR(gamma_lut);
1051 gamma_lut = NULL;
1052 goto out_state;
1053 }
1054
1055 crtc_state = drm_atomic_get_crtc_state(state, crtc);
1056 if (IS_ERR(crtc_state)) {
1057 ret = PTR_ERR(crtc_state);
1058 goto out_state;
1059 }
1060
1061 /*
1062 * FIXME: This always uses gamma_lut. Some HW have only
1063 * degamma_lut, in which case we should reset gamma_lut and set
1064 * degamma_lut. See drm_crtc_legacy_gamma_set().
1065 */
1066 replaced = drm_property_replace_blob(&crtc_state->degamma_lut,
1067 NULL);
1068 replaced |= drm_property_replace_blob(&crtc_state->ctm, NULL);
1069 replaced |= drm_property_replace_blob(&crtc_state->gamma_lut,
1070 gamma_lut);
1071 crtc_state->color_mgmt_changed |= replaced;
1072 }
1073
1074 ret = drm_atomic_commit(state);
1075 if (ret)
1076 goto out_state;
1077
1078 drm_client_for_each_modeset(modeset, &fb_helper->client) {
1079 crtc = modeset->crtc;
1080
1081 r = crtc->gamma_store;
1082 g = r + crtc->gamma_size;
1083 b = g + crtc->gamma_size;
1084
1085 memcpy(r + cmap->start, cmap->red, cmap->len * sizeof(*r));
1086 memcpy(g + cmap->start, cmap->green, cmap->len * sizeof(*g));
1087 memcpy(b + cmap->start, cmap->blue, cmap->len * sizeof(*b));
1088 }
1089
1090 out_state:
1091 if (ret == -EDEADLK)
1092 goto backoff;
1093
1094 drm_property_blob_put(gamma_lut);
1095 drm_atomic_state_put(state);
1096 out_ctx:
1097 drm_modeset_drop_locks(&ctx);
1098 drm_modeset_acquire_fini(&ctx);
1099
1100 return ret;
1101
1102 backoff:
1103 drm_atomic_state_clear(state);
1104 drm_modeset_backoff(&ctx);
1105 goto retry;
1106 }
1107
1108 /**
1109 * drm_fb_helper_setcmap - implementation for &fb_ops.fb_setcmap
1110 * @cmap: cmap to set
1111 * @info: fbdev registered by the helper
1112 */
drm_fb_helper_setcmap(struct fb_cmap * cmap,struct fb_info * info)1113 int drm_fb_helper_setcmap(struct fb_cmap *cmap, struct fb_info *info)
1114 {
1115 struct drm_fb_helper *fb_helper = info->par;
1116 struct drm_device *dev = fb_helper->dev;
1117 int ret;
1118
1119 if (oops_in_progress)
1120 return -EBUSY;
1121
1122 mutex_lock(&fb_helper->lock);
1123
1124 if (!drm_master_internal_acquire(dev)) {
1125 ret = -EBUSY;
1126 goto unlock;
1127 }
1128
1129 mutex_lock(&fb_helper->client.modeset_mutex);
1130 if (info->fix.visual == FB_VISUAL_TRUECOLOR)
1131 ret = setcmap_pseudo_palette(cmap, info);
1132 else if (drm_drv_uses_atomic_modeset(fb_helper->dev))
1133 ret = setcmap_atomic(cmap, info);
1134 else
1135 ret = setcmap_legacy(cmap, info);
1136 mutex_unlock(&fb_helper->client.modeset_mutex);
1137
1138 drm_master_internal_release(dev);
1139 unlock:
1140 mutex_unlock(&fb_helper->lock);
1141
1142 return ret;
1143 }
1144 EXPORT_SYMBOL(drm_fb_helper_setcmap);
1145
1146 /**
1147 * drm_fb_helper_ioctl - legacy ioctl implementation
1148 * @info: fbdev registered by the helper
1149 * @cmd: ioctl command
1150 * @arg: ioctl argument
1151 *
1152 * A helper to implement the standard fbdev ioctl. Only
1153 * FBIO_WAITFORVSYNC is implemented for now.
1154 */
drm_fb_helper_ioctl(struct fb_info * info,unsigned int cmd,unsigned long arg)1155 int drm_fb_helper_ioctl(struct fb_info *info, unsigned int cmd,
1156 unsigned long arg)
1157 {
1158 struct drm_fb_helper *fb_helper = info->par;
1159 struct drm_device *dev = fb_helper->dev;
1160 struct drm_crtc *crtc;
1161 int ret = 0;
1162
1163 mutex_lock(&fb_helper->lock);
1164 if (!drm_master_internal_acquire(dev)) {
1165 ret = -EBUSY;
1166 goto unlock;
1167 }
1168
1169 switch (cmd) {
1170 case FBIO_WAITFORVSYNC:
1171 /*
1172 * Only consider the first CRTC.
1173 *
1174 * This ioctl is supposed to take the CRTC number as
1175 * an argument, but in fbdev times, what that number
1176 * was supposed to be was quite unclear, different
1177 * drivers were passing that argument differently
1178 * (some by reference, some by value), and most of the
1179 * userspace applications were just hardcoding 0 as an
1180 * argument.
1181 *
1182 * The first CRTC should be the integrated panel on
1183 * most drivers, so this is the best choice we can
1184 * make. If we're not smart enough here, one should
1185 * just consider switch the userspace to KMS.
1186 */
1187 crtc = fb_helper->client.modesets[0].crtc;
1188
1189 /*
1190 * Only wait for a vblank event if the CRTC is
1191 * enabled, otherwise just don't do anythintg,
1192 * not even report an error.
1193 */
1194 ret = drm_crtc_vblank_get(crtc);
1195 if (!ret) {
1196 drm_crtc_wait_one_vblank(crtc);
1197 drm_crtc_vblank_put(crtc);
1198 }
1199
1200 ret = 0;
1201 break;
1202 default:
1203 ret = -ENOTTY;
1204 }
1205
1206 drm_master_internal_release(dev);
1207 unlock:
1208 mutex_unlock(&fb_helper->lock);
1209 return ret;
1210 }
1211 EXPORT_SYMBOL(drm_fb_helper_ioctl);
1212
drm_fb_pixel_format_equal(const struct fb_var_screeninfo * var_1,const struct fb_var_screeninfo * var_2)1213 static bool drm_fb_pixel_format_equal(const struct fb_var_screeninfo *var_1,
1214 const struct fb_var_screeninfo *var_2)
1215 {
1216 return var_1->bits_per_pixel == var_2->bits_per_pixel &&
1217 var_1->grayscale == var_2->grayscale &&
1218 var_1->red.offset == var_2->red.offset &&
1219 var_1->red.length == var_2->red.length &&
1220 var_1->red.msb_right == var_2->red.msb_right &&
1221 var_1->green.offset == var_2->green.offset &&
1222 var_1->green.length == var_2->green.length &&
1223 var_1->green.msb_right == var_2->green.msb_right &&
1224 var_1->blue.offset == var_2->blue.offset &&
1225 var_1->blue.length == var_2->blue.length &&
1226 var_1->blue.msb_right == var_2->blue.msb_right &&
1227 var_1->transp.offset == var_2->transp.offset &&
1228 var_1->transp.length == var_2->transp.length &&
1229 var_1->transp.msb_right == var_2->transp.msb_right;
1230 }
1231
drm_fb_helper_fill_pixel_fmt(struct fb_var_screeninfo * var,u8 depth)1232 static void drm_fb_helper_fill_pixel_fmt(struct fb_var_screeninfo *var,
1233 u8 depth)
1234 {
1235 switch (depth) {
1236 case 8:
1237 var->red.offset = 0;
1238 var->green.offset = 0;
1239 var->blue.offset = 0;
1240 var->red.length = 8; /* 8bit DAC */
1241 var->green.length = 8;
1242 var->blue.length = 8;
1243 var->transp.offset = 0;
1244 var->transp.length = 0;
1245 break;
1246 case 15:
1247 var->red.offset = 10;
1248 var->green.offset = 5;
1249 var->blue.offset = 0;
1250 var->red.length = 5;
1251 var->green.length = 5;
1252 var->blue.length = 5;
1253 var->transp.offset = 15;
1254 var->transp.length = 1;
1255 break;
1256 case 16:
1257 var->red.offset = 11;
1258 var->green.offset = 5;
1259 var->blue.offset = 0;
1260 var->red.length = 5;
1261 var->green.length = 6;
1262 var->blue.length = 5;
1263 var->transp.offset = 0;
1264 break;
1265 case 24:
1266 var->red.offset = 16;
1267 var->green.offset = 8;
1268 var->blue.offset = 0;
1269 var->red.length = 8;
1270 var->green.length = 8;
1271 var->blue.length = 8;
1272 var->transp.offset = 0;
1273 var->transp.length = 0;
1274 break;
1275 case 32:
1276 var->red.offset = 16;
1277 var->green.offset = 8;
1278 var->blue.offset = 0;
1279 var->red.length = 8;
1280 var->green.length = 8;
1281 var->blue.length = 8;
1282 var->transp.offset = 24;
1283 var->transp.length = 8;
1284 break;
1285 default:
1286 break;
1287 }
1288 }
1289
1290 /**
1291 * drm_fb_helper_check_var - implementation for &fb_ops.fb_check_var
1292 * @var: screeninfo to check
1293 * @info: fbdev registered by the helper
1294 */
drm_fb_helper_check_var(struct fb_var_screeninfo * var,struct fb_info * info)1295 int drm_fb_helper_check_var(struct fb_var_screeninfo *var,
1296 struct fb_info *info)
1297 {
1298 struct drm_fb_helper *fb_helper = info->par;
1299 struct drm_framebuffer *fb = fb_helper->fb;
1300 struct drm_device *dev = fb_helper->dev;
1301
1302 if (in_dbg_master())
1303 return -EINVAL;
1304
1305 if (var->pixclock != 0) {
1306 drm_dbg_kms(dev, "fbdev emulation doesn't support changing the pixel clock, value of pixclock is ignored\n");
1307 var->pixclock = 0;
1308 }
1309
1310 if ((drm_format_info_block_width(fb->format, 0) > 1) ||
1311 (drm_format_info_block_height(fb->format, 0) > 1))
1312 return -EINVAL;
1313
1314 /*
1315 * Changes struct fb_var_screeninfo are currently not pushed back
1316 * to KMS, hence fail if different settings are requested.
1317 */
1318 if (var->bits_per_pixel > fb->format->cpp[0] * 8 ||
1319 var->xres > fb->width || var->yres > fb->height ||
1320 var->xres_virtual > fb->width || var->yres_virtual > fb->height) {
1321 drm_dbg_kms(dev, "fb requested width/height/bpp can't fit in current fb "
1322 "request %dx%d-%d (virtual %dx%d) > %dx%d-%d\n",
1323 var->xres, var->yres, var->bits_per_pixel,
1324 var->xres_virtual, var->yres_virtual,
1325 fb->width, fb->height, fb->format->cpp[0] * 8);
1326 return -EINVAL;
1327 }
1328
1329 var->xres_virtual = fb->width;
1330 var->yres_virtual = fb->height;
1331
1332 /*
1333 * Workaround for SDL 1.2, which is known to be setting all pixel format
1334 * fields values to zero in some cases. We treat this situation as a
1335 * kind of "use some reasonable autodetected values".
1336 */
1337 if (!var->red.offset && !var->green.offset &&
1338 !var->blue.offset && !var->transp.offset &&
1339 !var->red.length && !var->green.length &&
1340 !var->blue.length && !var->transp.length &&
1341 !var->red.msb_right && !var->green.msb_right &&
1342 !var->blue.msb_right && !var->transp.msb_right) {
1343 drm_fb_helper_fill_pixel_fmt(var, fb->format->depth);
1344 }
1345
1346 /*
1347 * Likewise, bits_per_pixel should be rounded up to a supported value.
1348 */
1349 var->bits_per_pixel = fb->format->cpp[0] * 8;
1350
1351 /*
1352 * drm fbdev emulation doesn't support changing the pixel format at all,
1353 * so reject all pixel format changing requests.
1354 */
1355 if (!drm_fb_pixel_format_equal(var, &info->var)) {
1356 drm_dbg_kms(dev, "fbdev emulation doesn't support changing the pixel format\n");
1357 return -EINVAL;
1358 }
1359
1360 return 0;
1361 }
1362 EXPORT_SYMBOL(drm_fb_helper_check_var);
1363
1364 /**
1365 * drm_fb_helper_set_par - implementation for &fb_ops.fb_set_par
1366 * @info: fbdev registered by the helper
1367 *
1368 * This will let fbcon do the mode init and is called at initialization time by
1369 * the fbdev core when registering the driver, and later on through the hotplug
1370 * callback.
1371 */
drm_fb_helper_set_par(struct fb_info * info)1372 int drm_fb_helper_set_par(struct fb_info *info)
1373 {
1374 struct drm_fb_helper *fb_helper = info->par;
1375 struct fb_var_screeninfo *var = &info->var;
1376 bool force;
1377
1378 if (oops_in_progress)
1379 return -EBUSY;
1380
1381 if (var->pixclock != 0) {
1382 drm_err(fb_helper->dev, "PIXEL CLOCK SET\n");
1383 return -EINVAL;
1384 }
1385
1386 /*
1387 * Normally we want to make sure that a kms master takes precedence over
1388 * fbdev, to avoid fbdev flickering and occasionally stealing the
1389 * display status. But Xorg first sets the vt back to text mode using
1390 * the KDSET IOCTL with KD_TEXT, and only after that drops the master
1391 * status when exiting.
1392 *
1393 * In the past this was caught by drm_fb_helper_lastclose(), but on
1394 * modern systems where logind always keeps a drm fd open to orchestrate
1395 * the vt switching, this doesn't work.
1396 *
1397 * To not break the userspace ABI we have this special case here, which
1398 * is only used for the above case. Everything else uses the normal
1399 * commit function, which ensures that we never steal the display from
1400 * an active drm master.
1401 */
1402 force = var->activate & FB_ACTIVATE_KD_TEXT;
1403
1404 __drm_fb_helper_restore_fbdev_mode_unlocked(fb_helper, force);
1405
1406 return 0;
1407 }
1408 EXPORT_SYMBOL(drm_fb_helper_set_par);
1409
pan_set(struct drm_fb_helper * fb_helper,int x,int y)1410 static void pan_set(struct drm_fb_helper *fb_helper, int x, int y)
1411 {
1412 struct drm_mode_set *mode_set;
1413
1414 mutex_lock(&fb_helper->client.modeset_mutex);
1415 drm_client_for_each_modeset(mode_set, &fb_helper->client) {
1416 mode_set->x = x;
1417 mode_set->y = y;
1418 }
1419 mutex_unlock(&fb_helper->client.modeset_mutex);
1420 }
1421
pan_display_atomic(struct fb_var_screeninfo * var,struct fb_info * info)1422 static int pan_display_atomic(struct fb_var_screeninfo *var,
1423 struct fb_info *info)
1424 {
1425 struct drm_fb_helper *fb_helper = info->par;
1426 int ret;
1427
1428 pan_set(fb_helper, var->xoffset, var->yoffset);
1429
1430 ret = drm_client_modeset_commit_locked(&fb_helper->client);
1431 if (!ret) {
1432 info->var.xoffset = var->xoffset;
1433 info->var.yoffset = var->yoffset;
1434 } else
1435 pan_set(fb_helper, info->var.xoffset, info->var.yoffset);
1436
1437 return ret;
1438 }
1439
pan_display_legacy(struct fb_var_screeninfo * var,struct fb_info * info)1440 static int pan_display_legacy(struct fb_var_screeninfo *var,
1441 struct fb_info *info)
1442 {
1443 struct drm_fb_helper *fb_helper = info->par;
1444 struct drm_client_dev *client = &fb_helper->client;
1445 struct drm_mode_set *modeset;
1446 int ret = 0;
1447
1448 mutex_lock(&client->modeset_mutex);
1449 drm_modeset_lock_all(fb_helper->dev);
1450 drm_client_for_each_modeset(modeset, client) {
1451 modeset->x = var->xoffset;
1452 modeset->y = var->yoffset;
1453
1454 if (modeset->num_connectors) {
1455 ret = drm_mode_set_config_internal(modeset);
1456 if (!ret) {
1457 info->var.xoffset = var->xoffset;
1458 info->var.yoffset = var->yoffset;
1459 }
1460 }
1461 }
1462 drm_modeset_unlock_all(fb_helper->dev);
1463 mutex_unlock(&client->modeset_mutex);
1464
1465 return ret;
1466 }
1467
1468 /**
1469 * drm_fb_helper_pan_display - implementation for &fb_ops.fb_pan_display
1470 * @var: updated screen information
1471 * @info: fbdev registered by the helper
1472 */
drm_fb_helper_pan_display(struct fb_var_screeninfo * var,struct fb_info * info)1473 int drm_fb_helper_pan_display(struct fb_var_screeninfo *var,
1474 struct fb_info *info)
1475 {
1476 struct drm_fb_helper *fb_helper = info->par;
1477 struct drm_device *dev = fb_helper->dev;
1478 int ret;
1479
1480 if (oops_in_progress)
1481 return -EBUSY;
1482
1483 mutex_lock(&fb_helper->lock);
1484 if (!drm_master_internal_acquire(dev)) {
1485 ret = -EBUSY;
1486 goto unlock;
1487 }
1488
1489 if (drm_drv_uses_atomic_modeset(dev))
1490 ret = pan_display_atomic(var, info);
1491 else
1492 ret = pan_display_legacy(var, info);
1493
1494 drm_master_internal_release(dev);
1495 unlock:
1496 mutex_unlock(&fb_helper->lock);
1497
1498 return ret;
1499 }
1500 EXPORT_SYMBOL(drm_fb_helper_pan_display);
1501
1502 /*
1503 * Allocates the backing storage and sets up the fbdev info structure through
1504 * the ->fb_probe callback.
1505 */
drm_fb_helper_single_fb_probe(struct drm_fb_helper * fb_helper,int preferred_bpp)1506 static int drm_fb_helper_single_fb_probe(struct drm_fb_helper *fb_helper,
1507 int preferred_bpp)
1508 {
1509 struct drm_client_dev *client = &fb_helper->client;
1510 struct drm_device *dev = fb_helper->dev;
1511 struct drm_mode_config *config = &dev->mode_config;
1512 int ret = 0;
1513 int crtc_count = 0;
1514 struct drm_connector_list_iter conn_iter;
1515 struct drm_fb_helper_surface_size sizes;
1516 struct drm_connector *connector;
1517 struct drm_mode_set *mode_set;
1518 int best_depth = 0;
1519
1520 memset(&sizes, 0, sizeof(struct drm_fb_helper_surface_size));
1521 sizes.surface_depth = 24;
1522 sizes.surface_bpp = 32;
1523 sizes.fb_width = (u32)-1;
1524 sizes.fb_height = (u32)-1;
1525
1526 /*
1527 * If driver picks 8 or 16 by default use that for both depth/bpp
1528 * to begin with
1529 */
1530 if (preferred_bpp != sizes.surface_bpp)
1531 sizes.surface_depth = sizes.surface_bpp = preferred_bpp;
1532
1533 drm_connector_list_iter_begin(fb_helper->dev, &conn_iter);
1534 drm_client_for_each_connector_iter(connector, &conn_iter) {
1535 struct drm_cmdline_mode *cmdline_mode;
1536
1537 cmdline_mode = &connector->cmdline_mode;
1538
1539 if (cmdline_mode->bpp_specified) {
1540 switch (cmdline_mode->bpp) {
1541 case 8:
1542 sizes.surface_depth = sizes.surface_bpp = 8;
1543 break;
1544 case 15:
1545 sizes.surface_depth = 15;
1546 sizes.surface_bpp = 16;
1547 break;
1548 case 16:
1549 sizes.surface_depth = sizes.surface_bpp = 16;
1550 break;
1551 case 24:
1552 sizes.surface_depth = sizes.surface_bpp = 24;
1553 break;
1554 case 32:
1555 sizes.surface_depth = 24;
1556 sizes.surface_bpp = 32;
1557 break;
1558 }
1559 break;
1560 }
1561 }
1562 drm_connector_list_iter_end(&conn_iter);
1563
1564 /*
1565 * If we run into a situation where, for example, the primary plane
1566 * supports RGBA5551 (16 bpp, depth 15) but not RGB565 (16 bpp, depth
1567 * 16) we need to scale down the depth of the sizes we request.
1568 */
1569 mutex_lock(&client->modeset_mutex);
1570 drm_client_for_each_modeset(mode_set, client) {
1571 struct drm_crtc *crtc = mode_set->crtc;
1572 struct drm_plane *plane = crtc->primary;
1573 int j;
1574
1575 drm_dbg_kms(dev, "test CRTC %u primary plane\n", drm_crtc_index(crtc));
1576
1577 for (j = 0; j < plane->format_count; j++) {
1578 const struct drm_format_info *fmt;
1579
1580 fmt = drm_format_info(plane->format_types[j]);
1581
1582 /*
1583 * Do not consider YUV or other complicated formats
1584 * for framebuffers. This means only legacy formats
1585 * are supported (fmt->depth is a legacy field) but
1586 * the framebuffer emulation can only deal with such
1587 * formats, specifically RGB/BGA formats.
1588 */
1589 if (fmt->depth == 0)
1590 continue;
1591
1592 /* We found a perfect fit, great */
1593 if (fmt->depth == sizes.surface_depth) {
1594 best_depth = fmt->depth;
1595 break;
1596 }
1597
1598 /* Skip depths above what we're looking for */
1599 if (fmt->depth > sizes.surface_depth)
1600 continue;
1601
1602 /* Best depth found so far */
1603 if (fmt->depth > best_depth)
1604 best_depth = fmt->depth;
1605 }
1606 }
1607 if (sizes.surface_depth != best_depth && best_depth) {
1608 drm_info(dev, "requested bpp %d, scaled depth down to %d",
1609 sizes.surface_bpp, best_depth);
1610 sizes.surface_depth = best_depth;
1611 }
1612
1613 /* first up get a count of crtcs now in use and new min/maxes width/heights */
1614 crtc_count = 0;
1615 drm_client_for_each_modeset(mode_set, client) {
1616 struct drm_display_mode *desired_mode;
1617 int x, y, j;
1618 /* in case of tile group, are we the last tile vert or horiz?
1619 * If no tile group you are always the last one both vertically
1620 * and horizontally
1621 */
1622 bool lastv = true, lasth = true;
1623
1624 desired_mode = mode_set->mode;
1625
1626 if (!desired_mode)
1627 continue;
1628
1629 crtc_count++;
1630
1631 x = mode_set->x;
1632 y = mode_set->y;
1633
1634 sizes.surface_width = max_t(u32, desired_mode->hdisplay + x, sizes.surface_width);
1635 sizes.surface_height = max_t(u32, desired_mode->vdisplay + y, sizes.surface_height);
1636
1637 for (j = 0; j < mode_set->num_connectors; j++) {
1638 struct drm_connector *connector = mode_set->connectors[j];
1639
1640 if (connector->has_tile &&
1641 desired_mode->hdisplay == connector->tile_h_size &&
1642 desired_mode->vdisplay == connector->tile_v_size) {
1643 lasth = (connector->tile_h_loc == (connector->num_h_tile - 1));
1644 lastv = (connector->tile_v_loc == (connector->num_v_tile - 1));
1645 /* cloning to multiple tiles is just crazy-talk, so: */
1646 break;
1647 }
1648 }
1649
1650 if (lasth)
1651 sizes.fb_width = min_t(u32, desired_mode->hdisplay + x, sizes.fb_width);
1652 if (lastv)
1653 sizes.fb_height = min_t(u32, desired_mode->vdisplay + y, sizes.fb_height);
1654 }
1655 mutex_unlock(&client->modeset_mutex);
1656
1657 if (crtc_count == 0 || sizes.fb_width == -1 || sizes.fb_height == -1) {
1658 drm_info(dev, "Cannot find any crtc or sizes\n");
1659
1660 /* First time: disable all crtc's.. */
1661 if (!fb_helper->deferred_setup)
1662 drm_client_modeset_commit(client);
1663 return -EAGAIN;
1664 }
1665
1666 /* Handle our overallocation */
1667 sizes.surface_height *= drm_fbdev_overalloc;
1668 sizes.surface_height /= 100;
1669 if (sizes.surface_height > config->max_height) {
1670 drm_dbg_kms(dev, "Fbdev over-allocation too large; clamping height to %d\n",
1671 config->max_height);
1672 sizes.surface_height = config->max_height;
1673 }
1674
1675 /* push down into drivers */
1676 ret = (*fb_helper->funcs->fb_probe)(fb_helper, &sizes);
1677 if (ret < 0)
1678 return ret;
1679
1680 strcpy(fb_helper->fb->comm, "[fbcon]");
1681 return 0;
1682 }
1683
drm_fb_helper_fill_fix(struct fb_info * info,uint32_t pitch,uint32_t depth)1684 static void drm_fb_helper_fill_fix(struct fb_info *info, uint32_t pitch,
1685 uint32_t depth)
1686 {
1687 info->fix.type = FB_TYPE_PACKED_PIXELS;
1688 info->fix.visual = depth == 8 ? FB_VISUAL_PSEUDOCOLOR :
1689 FB_VISUAL_TRUECOLOR;
1690 info->fix.mmio_start = 0;
1691 info->fix.mmio_len = 0;
1692 info->fix.type_aux = 0;
1693 info->fix.xpanstep = 1; /* doing it in hw */
1694 info->fix.ypanstep = 1; /* doing it in hw */
1695 info->fix.ywrapstep = 0;
1696 info->fix.accel = FB_ACCEL_NONE;
1697
1698 info->fix.line_length = pitch;
1699 }
1700
drm_fb_helper_fill_var(struct fb_info * info,struct drm_fb_helper * fb_helper,uint32_t fb_width,uint32_t fb_height)1701 static void drm_fb_helper_fill_var(struct fb_info *info,
1702 struct drm_fb_helper *fb_helper,
1703 uint32_t fb_width, uint32_t fb_height)
1704 {
1705 struct drm_framebuffer *fb = fb_helper->fb;
1706
1707 WARN_ON((drm_format_info_block_width(fb->format, 0) > 1) ||
1708 (drm_format_info_block_height(fb->format, 0) > 1));
1709 info->pseudo_palette = fb_helper->pseudo_palette;
1710 info->var.xres_virtual = fb->width;
1711 info->var.yres_virtual = fb->height;
1712 info->var.bits_per_pixel = fb->format->cpp[0] * 8;
1713 info->var.accel_flags = FB_ACCELF_TEXT;
1714 info->var.xoffset = 0;
1715 info->var.yoffset = 0;
1716 info->var.activate = FB_ACTIVATE_NOW;
1717
1718 drm_fb_helper_fill_pixel_fmt(&info->var, fb->format->depth);
1719
1720 info->var.xres = fb_width;
1721 info->var.yres = fb_height;
1722 }
1723
1724 /**
1725 * drm_fb_helper_fill_info - initializes fbdev information
1726 * @info: fbdev instance to set up
1727 * @fb_helper: fb helper instance to use as template
1728 * @sizes: describes fbdev size and scanout surface size
1729 *
1730 * Sets up the variable and fixed fbdev metainformation from the given fb helper
1731 * instance and the drm framebuffer allocated in &drm_fb_helper.fb.
1732 *
1733 * Drivers should call this (or their equivalent setup code) from their
1734 * &drm_fb_helper_funcs.fb_probe callback after having allocated the fbdev
1735 * backing storage framebuffer.
1736 */
drm_fb_helper_fill_info(struct fb_info * info,struct drm_fb_helper * fb_helper,struct drm_fb_helper_surface_size * sizes)1737 void drm_fb_helper_fill_info(struct fb_info *info,
1738 struct drm_fb_helper *fb_helper,
1739 struct drm_fb_helper_surface_size *sizes)
1740 {
1741 struct drm_framebuffer *fb = fb_helper->fb;
1742
1743 drm_fb_helper_fill_fix(info, fb->pitches[0], fb->format->depth);
1744 drm_fb_helper_fill_var(info, fb_helper,
1745 sizes->fb_width, sizes->fb_height);
1746
1747 info->par = fb_helper;
1748 /*
1749 * The DRM drivers fbdev emulation device name can be confusing if the
1750 * driver name also has a "drm" suffix on it. Leading to names such as
1751 * "simpledrmdrmfb" in /proc/fb. Unfortunately, it's an uAPI and can't
1752 * be changed due user-space tools (e.g: pm-utils) matching against it.
1753 */
1754 snprintf(info->fix.id, sizeof(info->fix.id), "%sdrmfb",
1755 fb_helper->dev->driver->name);
1756
1757 }
1758 EXPORT_SYMBOL(drm_fb_helper_fill_info);
1759
1760 /*
1761 * This is a continuation of drm_setup_crtcs() that sets up anything related
1762 * to the framebuffer. During initialization, drm_setup_crtcs() is called before
1763 * the framebuffer has been allocated (fb_helper->fb and fb_helper->fbdev).
1764 * So, any setup that touches those fields needs to be done here instead of in
1765 * drm_setup_crtcs().
1766 */
drm_setup_crtcs_fb(struct drm_fb_helper * fb_helper)1767 static void drm_setup_crtcs_fb(struct drm_fb_helper *fb_helper)
1768 {
1769 struct drm_client_dev *client = &fb_helper->client;
1770 struct drm_connector_list_iter conn_iter;
1771 struct fb_info *info = fb_helper->fbdev;
1772 unsigned int rotation, sw_rotations = 0;
1773 struct drm_connector *connector;
1774 struct drm_mode_set *modeset;
1775
1776 mutex_lock(&client->modeset_mutex);
1777 drm_client_for_each_modeset(modeset, client) {
1778 if (!modeset->num_connectors)
1779 continue;
1780
1781 modeset->fb = fb_helper->fb;
1782
1783 if (drm_client_rotation(modeset, &rotation))
1784 /* Rotating in hardware, fbcon should not rotate */
1785 sw_rotations |= DRM_MODE_ROTATE_0;
1786 else
1787 sw_rotations |= rotation;
1788 }
1789 mutex_unlock(&client->modeset_mutex);
1790
1791 drm_connector_list_iter_begin(fb_helper->dev, &conn_iter);
1792 drm_client_for_each_connector_iter(connector, &conn_iter) {
1793
1794 /* use first connected connector for the physical dimensions */
1795 if (connector->status == connector_status_connected) {
1796 info->var.width = connector->display_info.width_mm;
1797 info->var.height = connector->display_info.height_mm;
1798 break;
1799 }
1800 }
1801 drm_connector_list_iter_end(&conn_iter);
1802
1803 switch (sw_rotations) {
1804 case DRM_MODE_ROTATE_0:
1805 info->fbcon_rotate_hint = FB_ROTATE_UR;
1806 break;
1807 case DRM_MODE_ROTATE_90:
1808 info->fbcon_rotate_hint = FB_ROTATE_CCW;
1809 break;
1810 case DRM_MODE_ROTATE_180:
1811 info->fbcon_rotate_hint = FB_ROTATE_UD;
1812 break;
1813 case DRM_MODE_ROTATE_270:
1814 info->fbcon_rotate_hint = FB_ROTATE_CW;
1815 break;
1816 default:
1817 /*
1818 * Multiple bits are set / multiple rotations requested
1819 * fbcon cannot handle separate rotation settings per
1820 * output, so fallback to unrotated.
1821 */
1822 info->fbcon_rotate_hint = FB_ROTATE_UR;
1823 }
1824 }
1825
1826 /* Note: Drops fb_helper->lock before returning. */
1827 static int
__drm_fb_helper_initial_config_and_unlock(struct drm_fb_helper * fb_helper,int bpp_sel)1828 __drm_fb_helper_initial_config_and_unlock(struct drm_fb_helper *fb_helper,
1829 int bpp_sel)
1830 {
1831 struct drm_device *dev = fb_helper->dev;
1832 struct fb_info *info;
1833 unsigned int width, height;
1834 int ret;
1835
1836 width = dev->mode_config.max_width;
1837 height = dev->mode_config.max_height;
1838
1839 drm_client_modeset_probe(&fb_helper->client, width, height);
1840 ret = drm_fb_helper_single_fb_probe(fb_helper, bpp_sel);
1841 if (ret < 0) {
1842 if (ret == -EAGAIN) {
1843 fb_helper->preferred_bpp = bpp_sel;
1844 fb_helper->deferred_setup = true;
1845 ret = 0;
1846 }
1847 mutex_unlock(&fb_helper->lock);
1848
1849 return ret;
1850 }
1851 drm_setup_crtcs_fb(fb_helper);
1852
1853 fb_helper->deferred_setup = false;
1854
1855 info = fb_helper->fbdev;
1856 info->var.pixclock = 0;
1857 /* Shamelessly allow physical address leaking to userspace */
1858 #if IS_ENABLED(CONFIG_DRM_FBDEV_LEAK_PHYS_SMEM)
1859 if (!drm_leak_fbdev_smem)
1860 #endif
1861 /* don't leak any physical addresses to userspace */
1862 info->flags |= FBINFO_HIDE_SMEM_START;
1863
1864 /* Need to drop locks to avoid recursive deadlock in
1865 * register_framebuffer. This is ok because the only thing left to do is
1866 * register the fbdev emulation instance in kernel_fb_helper_list. */
1867 mutex_unlock(&fb_helper->lock);
1868
1869 ret = register_framebuffer(info);
1870 if (ret < 0)
1871 return ret;
1872
1873 drm_info(dev, "fb%d: %s frame buffer device\n",
1874 info->node, info->fix.id);
1875
1876 mutex_lock(&kernel_fb_helper_lock);
1877 if (list_empty(&kernel_fb_helper_list))
1878 register_sysrq_key('v', &sysrq_drm_fb_helper_restore_op);
1879
1880 list_add(&fb_helper->kernel_fb_list, &kernel_fb_helper_list);
1881 mutex_unlock(&kernel_fb_helper_lock);
1882
1883 return 0;
1884 }
1885
1886 /**
1887 * drm_fb_helper_initial_config - setup a sane initial connector configuration
1888 * @fb_helper: fb_helper device struct
1889 * @bpp_sel: bpp value to use for the framebuffer configuration
1890 *
1891 * Scans the CRTCs and connectors and tries to put together an initial setup.
1892 * At the moment, this is a cloned configuration across all heads with
1893 * a new framebuffer object as the backing store.
1894 *
1895 * Note that this also registers the fbdev and so allows userspace to call into
1896 * the driver through the fbdev interfaces.
1897 *
1898 * This function will call down into the &drm_fb_helper_funcs.fb_probe callback
1899 * to let the driver allocate and initialize the fbdev info structure and the
1900 * drm framebuffer used to back the fbdev. drm_fb_helper_fill_info() is provided
1901 * as a helper to setup simple default values for the fbdev info structure.
1902 *
1903 * HANG DEBUGGING:
1904 *
1905 * When you have fbcon support built-in or already loaded, this function will do
1906 * a full modeset to setup the fbdev console. Due to locking misdesign in the
1907 * VT/fbdev subsystem that entire modeset sequence has to be done while holding
1908 * console_lock. Until console_unlock is called no dmesg lines will be sent out
1909 * to consoles, not even serial console. This means when your driver crashes,
1910 * you will see absolutely nothing else but a system stuck in this function,
1911 * with no further output. Any kind of printk() you place within your own driver
1912 * or in the drm core modeset code will also never show up.
1913 *
1914 * Standard debug practice is to run the fbcon setup without taking the
1915 * console_lock as a hack, to be able to see backtraces and crashes on the
1916 * serial line. This can be done by setting the fb.lockless_register_fb=1 kernel
1917 * cmdline option.
1918 *
1919 * The other option is to just disable fbdev emulation since very likely the
1920 * first modeset from userspace will crash in the same way, and is even easier
1921 * to debug. This can be done by setting the drm_kms_helper.fbdev_emulation=0
1922 * kernel cmdline option.
1923 *
1924 * RETURNS:
1925 * Zero if everything went ok, nonzero otherwise.
1926 */
drm_fb_helper_initial_config(struct drm_fb_helper * fb_helper,int bpp_sel)1927 int drm_fb_helper_initial_config(struct drm_fb_helper *fb_helper, int bpp_sel)
1928 {
1929 int ret;
1930
1931 if (!drm_fbdev_emulation)
1932 return 0;
1933
1934 mutex_lock(&fb_helper->lock);
1935 ret = __drm_fb_helper_initial_config_and_unlock(fb_helper, bpp_sel);
1936
1937 return ret;
1938 }
1939 EXPORT_SYMBOL(drm_fb_helper_initial_config);
1940
1941 /**
1942 * drm_fb_helper_hotplug_event - respond to a hotplug notification by
1943 * probing all the outputs attached to the fb
1944 * @fb_helper: driver-allocated fbdev helper, can be NULL
1945 *
1946 * Scan the connectors attached to the fb_helper and try to put together a
1947 * setup after notification of a change in output configuration.
1948 *
1949 * Called at runtime, takes the mode config locks to be able to check/change the
1950 * modeset configuration. Must be run from process context (which usually means
1951 * either the output polling work or a work item launched from the driver's
1952 * hotplug interrupt).
1953 *
1954 * Note that drivers may call this even before calling
1955 * drm_fb_helper_initial_config but only after drm_fb_helper_init. This allows
1956 * for a race-free fbcon setup and will make sure that the fbdev emulation will
1957 * not miss any hotplug events.
1958 *
1959 * RETURNS:
1960 * 0 on success and a non-zero error code otherwise.
1961 */
drm_fb_helper_hotplug_event(struct drm_fb_helper * fb_helper)1962 int drm_fb_helper_hotplug_event(struct drm_fb_helper *fb_helper)
1963 {
1964 int err = 0;
1965
1966 if (!drm_fbdev_emulation || !fb_helper)
1967 return 0;
1968
1969 mutex_lock(&fb_helper->lock);
1970 if (fb_helper->deferred_setup) {
1971 err = __drm_fb_helper_initial_config_and_unlock(fb_helper,
1972 fb_helper->preferred_bpp);
1973 return err;
1974 }
1975
1976 if (!fb_helper->fb || !drm_master_internal_acquire(fb_helper->dev)) {
1977 fb_helper->delayed_hotplug = true;
1978 mutex_unlock(&fb_helper->lock);
1979 return err;
1980 }
1981
1982 drm_master_internal_release(fb_helper->dev);
1983
1984 drm_dbg_kms(fb_helper->dev, "\n");
1985
1986 drm_client_modeset_probe(&fb_helper->client, fb_helper->fb->width, fb_helper->fb->height);
1987 drm_setup_crtcs_fb(fb_helper);
1988 mutex_unlock(&fb_helper->lock);
1989
1990 drm_fb_helper_set_par(fb_helper->fbdev);
1991
1992 return 0;
1993 }
1994 EXPORT_SYMBOL(drm_fb_helper_hotplug_event);
1995
1996 /**
1997 * drm_fb_helper_lastclose - DRM driver lastclose helper for fbdev emulation
1998 * @dev: DRM device
1999 *
2000 * This function can be used as the &drm_driver->lastclose callback for drivers
2001 * that only need to call drm_fb_helper_restore_fbdev_mode_unlocked().
2002 */
drm_fb_helper_lastclose(struct drm_device * dev)2003 void drm_fb_helper_lastclose(struct drm_device *dev)
2004 {
2005 drm_fb_helper_restore_fbdev_mode_unlocked(dev->fb_helper);
2006 }
2007 EXPORT_SYMBOL(drm_fb_helper_lastclose);
2008
2009 /**
2010 * drm_fb_helper_output_poll_changed - DRM mode config \.output_poll_changed
2011 * helper for fbdev emulation
2012 * @dev: DRM device
2013 *
2014 * This function can be used as the
2015 * &drm_mode_config_funcs.output_poll_changed callback for drivers that only
2016 * need to call drm_fb_helper_hotplug_event().
2017 */
drm_fb_helper_output_poll_changed(struct drm_device * dev)2018 void drm_fb_helper_output_poll_changed(struct drm_device *dev)
2019 {
2020 drm_fb_helper_hotplug_event(dev->fb_helper);
2021 }
2022 EXPORT_SYMBOL(drm_fb_helper_output_poll_changed);
2023
2024 /* @user: 1=userspace, 0=fbcon */
drm_fbdev_fb_open(struct fb_info * info,int user)2025 static int drm_fbdev_fb_open(struct fb_info *info, int user)
2026 {
2027 struct drm_fb_helper *fb_helper = info->par;
2028
2029 /* No need to take a ref for fbcon because it unbinds on unregister */
2030 if (user && !try_module_get(fb_helper->dev->driver->fops->owner))
2031 return -ENODEV;
2032
2033 return 0;
2034 }
2035
drm_fbdev_fb_release(struct fb_info * info,int user)2036 static int drm_fbdev_fb_release(struct fb_info *info, int user)
2037 {
2038 struct drm_fb_helper *fb_helper = info->par;
2039
2040 if (user)
2041 module_put(fb_helper->dev->driver->fops->owner);
2042
2043 return 0;
2044 }
2045
drm_fbdev_cleanup(struct drm_fb_helper * fb_helper)2046 static void drm_fbdev_cleanup(struct drm_fb_helper *fb_helper)
2047 {
2048 struct fb_info *fbi = fb_helper->fbdev;
2049 void *shadow = NULL;
2050
2051 if (!fb_helper->dev)
2052 return;
2053
2054 if (fbi) {
2055 if (fbi->fbdefio)
2056 fb_deferred_io_cleanup(fbi);
2057 if (drm_fbdev_use_shadow_fb(fb_helper))
2058 shadow = fbi->screen_buffer;
2059 }
2060
2061 drm_fb_helper_fini(fb_helper);
2062
2063 if (shadow)
2064 vfree(shadow);
2065 else if (fb_helper->buffer)
2066 drm_client_buffer_vunmap(fb_helper->buffer);
2067
2068 drm_client_framebuffer_delete(fb_helper->buffer);
2069 }
2070
drm_fbdev_release(struct drm_fb_helper * fb_helper)2071 static void drm_fbdev_release(struct drm_fb_helper *fb_helper)
2072 {
2073 drm_fbdev_cleanup(fb_helper);
2074 drm_client_release(&fb_helper->client);
2075 kfree(fb_helper);
2076 }
2077
2078 /*
2079 * fb_ops.fb_destroy is called by the last put_fb_info() call at the end of
2080 * unregister_framebuffer() or fb_release().
2081 */
drm_fbdev_fb_destroy(struct fb_info * info)2082 static void drm_fbdev_fb_destroy(struct fb_info *info)
2083 {
2084 drm_fbdev_release(info->par);
2085 }
2086
drm_fbdev_fb_mmap(struct fb_info * info,struct vm_area_struct * vma)2087 static int drm_fbdev_fb_mmap(struct fb_info *info, struct vm_area_struct *vma)
2088 {
2089 struct drm_fb_helper *fb_helper = info->par;
2090
2091 if (fb_helper->dev->driver->gem_prime_mmap)
2092 return fb_helper->dev->driver->gem_prime_mmap(fb_helper->buffer->gem, vma);
2093 else
2094 return -ENODEV;
2095 }
2096
drm_fbdev_use_iomem(struct fb_info * info)2097 static bool drm_fbdev_use_iomem(struct fb_info *info)
2098 {
2099 struct drm_fb_helper *fb_helper = info->par;
2100 struct drm_client_buffer *buffer = fb_helper->buffer;
2101
2102 return !drm_fbdev_use_shadow_fb(fb_helper) && buffer->map.is_iomem;
2103 }
2104
fb_read_screen_base(struct fb_info * info,char __user * buf,size_t count,loff_t pos)2105 static ssize_t fb_read_screen_base(struct fb_info *info, char __user *buf, size_t count,
2106 loff_t pos)
2107 {
2108 const char __iomem *src = info->screen_base + pos;
2109 size_t alloc_size = min_t(size_t, count, PAGE_SIZE);
2110 ssize_t ret = 0;
2111 int err = 0;
2112 char *tmp;
2113
2114 tmp = kmalloc(alloc_size, GFP_KERNEL);
2115 if (!tmp)
2116 return -ENOMEM;
2117
2118 while (count) {
2119 size_t c = min_t(size_t, count, alloc_size);
2120
2121 memcpy_fromio(tmp, src, c);
2122 if (copy_to_user(buf, tmp, c)) {
2123 err = -EFAULT;
2124 break;
2125 }
2126
2127 src += c;
2128 buf += c;
2129 ret += c;
2130 count -= c;
2131 }
2132
2133 kfree(tmp);
2134
2135 return ret ? ret : err;
2136 }
2137
fb_read_screen_buffer(struct fb_info * info,char __user * buf,size_t count,loff_t pos)2138 static ssize_t fb_read_screen_buffer(struct fb_info *info, char __user *buf, size_t count,
2139 loff_t pos)
2140 {
2141 const char *src = info->screen_buffer + pos;
2142
2143 if (copy_to_user(buf, src, count))
2144 return -EFAULT;
2145
2146 return count;
2147 }
2148
drm_fbdev_fb_read(struct fb_info * info,char __user * buf,size_t count,loff_t * ppos)2149 static ssize_t drm_fbdev_fb_read(struct fb_info *info, char __user *buf,
2150 size_t count, loff_t *ppos)
2151 {
2152 loff_t pos = *ppos;
2153 size_t total_size;
2154 ssize_t ret;
2155
2156 if (info->screen_size)
2157 total_size = info->screen_size;
2158 else
2159 total_size = info->fix.smem_len;
2160
2161 if (pos >= total_size)
2162 return 0;
2163 if (count >= total_size)
2164 count = total_size;
2165 if (total_size - count < pos)
2166 count = total_size - pos;
2167
2168 if (drm_fbdev_use_iomem(info))
2169 ret = fb_read_screen_base(info, buf, count, pos);
2170 else
2171 ret = fb_read_screen_buffer(info, buf, count, pos);
2172
2173 if (ret > 0)
2174 *ppos += ret;
2175
2176 return ret;
2177 }
2178
fb_write_screen_base(struct fb_info * info,const char __user * buf,size_t count,loff_t pos)2179 static ssize_t fb_write_screen_base(struct fb_info *info, const char __user *buf, size_t count,
2180 loff_t pos)
2181 {
2182 char __iomem *dst = info->screen_base + pos;
2183 size_t alloc_size = min_t(size_t, count, PAGE_SIZE);
2184 ssize_t ret = 0;
2185 int err = 0;
2186 u8 *tmp;
2187
2188 tmp = kmalloc(alloc_size, GFP_KERNEL);
2189 if (!tmp)
2190 return -ENOMEM;
2191
2192 while (count) {
2193 size_t c = min_t(size_t, count, alloc_size);
2194
2195 if (copy_from_user(tmp, buf, c)) {
2196 err = -EFAULT;
2197 break;
2198 }
2199 memcpy_toio(dst, tmp, c);
2200
2201 dst += c;
2202 buf += c;
2203 ret += c;
2204 count -= c;
2205 }
2206
2207 kfree(tmp);
2208
2209 return ret ? ret : err;
2210 }
2211
fb_write_screen_buffer(struct fb_info * info,const char __user * buf,size_t count,loff_t pos)2212 static ssize_t fb_write_screen_buffer(struct fb_info *info, const char __user *buf, size_t count,
2213 loff_t pos)
2214 {
2215 char *dst = info->screen_buffer + pos;
2216
2217 if (copy_from_user(dst, buf, count))
2218 return -EFAULT;
2219
2220 return count;
2221 }
2222
drm_fbdev_fb_write(struct fb_info * info,const char __user * buf,size_t count,loff_t * ppos)2223 static ssize_t drm_fbdev_fb_write(struct fb_info *info, const char __user *buf,
2224 size_t count, loff_t *ppos)
2225 {
2226 loff_t pos = *ppos;
2227 size_t total_size;
2228 ssize_t ret;
2229 int err = 0;
2230
2231 if (info->screen_size)
2232 total_size = info->screen_size;
2233 else
2234 total_size = info->fix.smem_len;
2235
2236 if (pos > total_size)
2237 return -EFBIG;
2238 if (count > total_size) {
2239 err = -EFBIG;
2240 count = total_size;
2241 }
2242 if (total_size - count < pos) {
2243 if (!err)
2244 err = -ENOSPC;
2245 count = total_size - pos;
2246 }
2247
2248 /*
2249 * Copy to framebuffer even if we already logged an error. Emulates
2250 * the behavior of the original fbdev implementation.
2251 */
2252 if (drm_fbdev_use_iomem(info))
2253 ret = fb_write_screen_base(info, buf, count, pos);
2254 else
2255 ret = fb_write_screen_buffer(info, buf, count, pos);
2256
2257 if (ret > 0)
2258 *ppos += ret;
2259
2260 if (ret > 0)
2261 drm_fb_helper_damage(info, 0, 0, info->var.xres_virtual, info->var.yres_virtual);
2262
2263 return ret ? ret : err;
2264 }
2265
drm_fbdev_fb_fillrect(struct fb_info * info,const struct fb_fillrect * rect)2266 static void drm_fbdev_fb_fillrect(struct fb_info *info,
2267 const struct fb_fillrect *rect)
2268 {
2269 if (drm_fbdev_use_iomem(info))
2270 drm_fb_helper_cfb_fillrect(info, rect);
2271 else
2272 drm_fb_helper_sys_fillrect(info, rect);
2273 }
2274
drm_fbdev_fb_copyarea(struct fb_info * info,const struct fb_copyarea * area)2275 static void drm_fbdev_fb_copyarea(struct fb_info *info,
2276 const struct fb_copyarea *area)
2277 {
2278 if (drm_fbdev_use_iomem(info))
2279 drm_fb_helper_cfb_copyarea(info, area);
2280 else
2281 drm_fb_helper_sys_copyarea(info, area);
2282 }
2283
drm_fbdev_fb_imageblit(struct fb_info * info,const struct fb_image * image)2284 static void drm_fbdev_fb_imageblit(struct fb_info *info,
2285 const struct fb_image *image)
2286 {
2287 if (drm_fbdev_use_iomem(info))
2288 drm_fb_helper_cfb_imageblit(info, image);
2289 else
2290 drm_fb_helper_sys_imageblit(info, image);
2291 }
2292
2293 static const struct fb_ops drm_fbdev_fb_ops = {
2294 .owner = THIS_MODULE,
2295 DRM_FB_HELPER_DEFAULT_OPS,
2296 .fb_open = drm_fbdev_fb_open,
2297 .fb_release = drm_fbdev_fb_release,
2298 .fb_destroy = drm_fbdev_fb_destroy,
2299 .fb_mmap = drm_fbdev_fb_mmap,
2300 .fb_read = drm_fbdev_fb_read,
2301 .fb_write = drm_fbdev_fb_write,
2302 .fb_fillrect = drm_fbdev_fb_fillrect,
2303 .fb_copyarea = drm_fbdev_fb_copyarea,
2304 .fb_imageblit = drm_fbdev_fb_imageblit,
2305 };
2306
2307 static struct fb_deferred_io drm_fbdev_defio = {
2308 .delay = HZ / 20,
2309 .deferred_io = drm_fb_helper_deferred_io,
2310 };
2311
2312 /*
2313 * This function uses the client API to create a framebuffer backed by a dumb buffer.
2314 *
2315 * The _sys_ versions are used for &fb_ops.fb_read, fb_write, fb_fillrect,
2316 * fb_copyarea, fb_imageblit.
2317 */
drm_fb_helper_generic_probe(struct drm_fb_helper * fb_helper,struct drm_fb_helper_surface_size * sizes)2318 static int drm_fb_helper_generic_probe(struct drm_fb_helper *fb_helper,
2319 struct drm_fb_helper_surface_size *sizes)
2320 {
2321 struct drm_client_dev *client = &fb_helper->client;
2322 struct drm_device *dev = fb_helper->dev;
2323 struct drm_client_buffer *buffer;
2324 struct drm_framebuffer *fb;
2325 struct fb_info *fbi;
2326 u32 format;
2327 struct dma_buf_map map;
2328 int ret;
2329
2330 drm_dbg_kms(dev, "surface width(%d), height(%d) and bpp(%d)\n",
2331 sizes->surface_width, sizes->surface_height,
2332 sizes->surface_bpp);
2333
2334 format = drm_mode_legacy_fb_format(sizes->surface_bpp, sizes->surface_depth);
2335 buffer = drm_client_framebuffer_create(client, sizes->surface_width,
2336 sizes->surface_height, format);
2337 if (IS_ERR(buffer))
2338 return PTR_ERR(buffer);
2339
2340 fb_helper->buffer = buffer;
2341 fb_helper->fb = buffer->fb;
2342 fb = buffer->fb;
2343
2344 fbi = drm_fb_helper_alloc_fbi(fb_helper);
2345 if (IS_ERR(fbi))
2346 return PTR_ERR(fbi);
2347
2348 fbi->fbops = &drm_fbdev_fb_ops;
2349 fbi->screen_size = fb->height * fb->pitches[0];
2350 fbi->fix.smem_len = fbi->screen_size;
2351 fbi->flags = FBINFO_DEFAULT;
2352
2353 drm_fb_helper_fill_info(fbi, fb_helper, sizes);
2354
2355 if (drm_fbdev_use_shadow_fb(fb_helper)) {
2356 fbi->screen_buffer = vzalloc(fbi->screen_size);
2357 if (!fbi->screen_buffer)
2358 return -ENOMEM;
2359 fbi->flags |= FBINFO_VIRTFB | FBINFO_READS_FAST;
2360
2361 fbi->fbdefio = &drm_fbdev_defio;
2362 fb_deferred_io_init(fbi);
2363 } else {
2364 /* buffer is mapped for HW framebuffer */
2365 ret = drm_client_buffer_vmap(fb_helper->buffer, &map);
2366 if (ret)
2367 return ret;
2368 if (map.is_iomem) {
2369 fbi->screen_base = map.vaddr_iomem;
2370 } else {
2371 fbi->screen_buffer = map.vaddr;
2372 fbi->flags |= FBINFO_VIRTFB;
2373 }
2374
2375 /*
2376 * Shamelessly leak the physical address to user-space. As
2377 * page_to_phys() is undefined for I/O memory, warn in this
2378 * case.
2379 */
2380 #if IS_ENABLED(CONFIG_DRM_FBDEV_LEAK_PHYS_SMEM)
2381 if (drm_leak_fbdev_smem && fbi->fix.smem_start == 0 &&
2382 !drm_WARN_ON_ONCE(dev, map.is_iomem))
2383 fbi->fix.smem_start =
2384 page_to_phys(virt_to_page(fbi->screen_buffer));
2385 #endif
2386 }
2387
2388 return 0;
2389 }
2390
2391 static const struct drm_fb_helper_funcs drm_fb_helper_generic_funcs = {
2392 .fb_probe = drm_fb_helper_generic_probe,
2393 };
2394
drm_fbdev_client_unregister(struct drm_client_dev * client)2395 static void drm_fbdev_client_unregister(struct drm_client_dev *client)
2396 {
2397 struct drm_fb_helper *fb_helper = drm_fb_helper_from_client(client);
2398
2399 if (fb_helper->fbdev)
2400 /* drm_fbdev_fb_destroy() takes care of cleanup */
2401 drm_fb_helper_unregister_fbi(fb_helper);
2402 else
2403 drm_fbdev_release(fb_helper);
2404 }
2405
drm_fbdev_client_restore(struct drm_client_dev * client)2406 static int drm_fbdev_client_restore(struct drm_client_dev *client)
2407 {
2408 drm_fb_helper_lastclose(client->dev);
2409
2410 return 0;
2411 }
2412
drm_fbdev_client_hotplug(struct drm_client_dev * client)2413 static int drm_fbdev_client_hotplug(struct drm_client_dev *client)
2414 {
2415 struct drm_fb_helper *fb_helper = drm_fb_helper_from_client(client);
2416 struct drm_device *dev = client->dev;
2417 int ret;
2418
2419 /* Setup is not retried if it has failed */
2420 if (!fb_helper->dev && fb_helper->funcs)
2421 return 0;
2422
2423 if (dev->fb_helper)
2424 return drm_fb_helper_hotplug_event(dev->fb_helper);
2425
2426 if (!dev->mode_config.num_connector) {
2427 drm_dbg_kms(dev, "No connectors found, will not create framebuffer!\n");
2428 return 0;
2429 }
2430
2431 drm_fb_helper_prepare(dev, fb_helper, &drm_fb_helper_generic_funcs);
2432
2433 ret = drm_fb_helper_init(dev, fb_helper);
2434 if (ret)
2435 goto err;
2436
2437 if (!drm_drv_uses_atomic_modeset(dev))
2438 drm_helper_disable_unused_functions(dev);
2439
2440 ret = drm_fb_helper_initial_config(fb_helper, fb_helper->preferred_bpp);
2441 if (ret)
2442 goto err_cleanup;
2443
2444 return 0;
2445
2446 err_cleanup:
2447 drm_fbdev_cleanup(fb_helper);
2448 err:
2449 fb_helper->dev = NULL;
2450 fb_helper->fbdev = NULL;
2451
2452 drm_err(dev, "fbdev: Failed to setup generic emulation (ret=%d)\n", ret);
2453
2454 return ret;
2455 }
2456
2457 static const struct drm_client_funcs drm_fbdev_client_funcs = {
2458 .owner = THIS_MODULE,
2459 .unregister = drm_fbdev_client_unregister,
2460 .restore = drm_fbdev_client_restore,
2461 .hotplug = drm_fbdev_client_hotplug,
2462 };
2463
2464 /**
2465 * drm_fbdev_generic_setup() - Setup generic fbdev emulation
2466 * @dev: DRM device
2467 * @preferred_bpp: Preferred bits per pixel for the device.
2468 * @dev->mode_config.preferred_depth is used if this is zero.
2469 *
2470 * This function sets up generic fbdev emulation for drivers that supports
2471 * dumb buffers with a virtual address and that can be mmap'ed.
2472 * drm_fbdev_generic_setup() shall be called after the DRM driver registered
2473 * the new DRM device with drm_dev_register().
2474 *
2475 * Restore, hotplug events and teardown are all taken care of. Drivers that do
2476 * suspend/resume need to call drm_fb_helper_set_suspend_unlocked() themselves.
2477 * Simple drivers might use drm_mode_config_helper_suspend().
2478 *
2479 * Drivers that set the dirty callback on their framebuffer will get a shadow
2480 * fbdev buffer that is blitted onto the real buffer. This is done in order to
2481 * make deferred I/O work with all kinds of buffers. A shadow buffer can be
2482 * requested explicitly by setting struct drm_mode_config.prefer_shadow or
2483 * struct drm_mode_config.prefer_shadow_fbdev to true beforehand. This is
2484 * required to use generic fbdev emulation with SHMEM helpers.
2485 *
2486 * This function is safe to call even when there are no connectors present.
2487 * Setup will be retried on the next hotplug event.
2488 *
2489 * The fbdev is destroyed by drm_dev_unregister().
2490 */
drm_fbdev_generic_setup(struct drm_device * dev,unsigned int preferred_bpp)2491 void drm_fbdev_generic_setup(struct drm_device *dev,
2492 unsigned int preferred_bpp)
2493 {
2494 struct drm_fb_helper *fb_helper;
2495 int ret;
2496
2497 drm_WARN(dev, !dev->registered, "Device has not been registered.\n");
2498 drm_WARN(dev, dev->fb_helper, "fb_helper is already set!\n");
2499
2500 if (!drm_fbdev_emulation)
2501 return;
2502
2503 fb_helper = kzalloc(sizeof(*fb_helper), GFP_KERNEL);
2504 if (!fb_helper) {
2505 drm_err(dev, "Failed to allocate fb_helper\n");
2506 return;
2507 }
2508
2509 ret = drm_client_init(dev, &fb_helper->client, "fbdev", &drm_fbdev_client_funcs);
2510 if (ret) {
2511 kfree(fb_helper);
2512 drm_err(dev, "Failed to register client: %d\n", ret);
2513 return;
2514 }
2515
2516 /*
2517 * FIXME: This mixes up depth with bpp, which results in a glorious
2518 * mess, resulting in some drivers picking wrong fbdev defaults and
2519 * others wrong preferred_depth defaults.
2520 */
2521 if (!preferred_bpp)
2522 preferred_bpp = dev->mode_config.preferred_depth;
2523 if (!preferred_bpp)
2524 preferred_bpp = 32;
2525 fb_helper->preferred_bpp = preferred_bpp;
2526
2527 ret = drm_fbdev_client_hotplug(&fb_helper->client);
2528 if (ret)
2529 drm_dbg_kms(dev, "client hotplug ret=%d\n", ret);
2530
2531 drm_client_register(&fb_helper->client);
2532 }
2533 EXPORT_SYMBOL(drm_fbdev_generic_setup);
2534