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