blob: 83dbae0fabcf1d581e4bdb3bda3d064cc7fce5ea [file] [log] [blame]
Dave Airlie785b93e2009-08-28 15:46:53 +10001/*
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 */
Sachin Kamatd56b1b92012-11-15 03:43:29 +000030#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
31
Noralf Trønnescfe63422016-08-23 13:54:06 +020032#include <linux/console.h>
Andy Shevchenko3b40a442010-02-02 14:40:32 -080033#include <linux/kernel.h>
Dave Airlie785b93e2009-08-28 15:46:53 +100034#include <linux/sysrq.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090035#include <linux/slab.h>
Paul Gortmakere0cd3602011-08-30 11:04:30 -040036#include <linux/module.h>
David Howells760285e2012-10-02 18:01:07 +010037#include <drm/drmP.h>
38#include <drm/drm_crtc.h>
39#include <drm/drm_fb_helper.h>
40#include <drm/drm_crtc_helper.h>
Rob Clarkbbb1e522015-08-25 15:35:58 -040041#include <drm/drm_atomic.h>
42#include <drm/drm_atomic_helper.h>
Dave Airlie785b93e2009-08-28 15:46:53 +100043
Ville Syrjälä699fbee2016-09-19 16:33:44 +030044#include "drm_crtc_helper_internal.h"
45
Daniel Vetterf64c5572015-08-25 15:45:13 +020046static bool drm_fbdev_emulation = true;
47module_param_named(fbdev_emulation, drm_fbdev_emulation, bool, 0600);
48MODULE_PARM_DESC(fbdev_emulation,
49 "Enable legacy fbdev emulation [default=true]");
50
Dave Airlie785b93e2009-08-28 15:46:53 +100051static LIST_HEAD(kernel_fb_helper_list);
52
Daniel Vetterd0ddc0332012-11-01 14:45:17 +010053/**
54 * DOC: fbdev helpers
55 *
56 * The fb helper functions are useful to provide an fbdev on top of a drm kernel
Thierry Reding83c617c2014-04-29 11:44:35 +020057 * mode setting driver. They can be used mostly independently from the crtc
Daniel Vetterd0ddc0332012-11-01 14:45:17 +010058 * helper functions used by many drivers to implement the kernel mode setting
59 * interfaces.
Daniel Vetter207fd322013-01-20 22:13:14 +010060 *
Thierry Reding10a23102014-06-27 17:19:24 +020061 * Initialization is done as a four-step process with drm_fb_helper_prepare(),
62 * drm_fb_helper_init(), drm_fb_helper_single_add_all_connectors() and
63 * drm_fb_helper_initial_config(). Drivers with fancier requirements than the
64 * default behaviour can override the third step with their own code.
65 * Teardown is done with drm_fb_helper_fini().
Daniel Vetter207fd322013-01-20 22:13:14 +010066 *
67 * At runtime drivers should restore the fbdev console by calling
Geert Uytterhoeven3d9e35a2015-08-04 15:22:10 +020068 * drm_fb_helper_restore_fbdev_mode_unlocked() from their ->lastclose callback.
69 * They should also notify the fb helper code from updates to the output
Daniel Vetter207fd322013-01-20 22:13:14 +010070 * configuration by calling drm_fb_helper_hotplug_event(). For easier
71 * integration with the output polling code in drm_crtc_helper.c the modeset
Thierry Reding83c617c2014-04-29 11:44:35 +020072 * code provides a ->output_poll_changed callback.
Daniel Vetter207fd322013-01-20 22:13:14 +010073 *
74 * All other functions exported by the fb helper library can be used to
75 * implement the fbdev driver interface by the driver.
Thierry Reding10a23102014-06-27 17:19:24 +020076 *
77 * It is possible, though perhaps somewhat tricky, to implement race-free
78 * hotplug detection using the fbdev helpers. The drm_fb_helper_prepare()
79 * helper must be called first to initialize the minimum required to make
80 * hotplug detection work. Drivers also need to make sure to properly set up
81 * the dev->mode_config.funcs member. After calling drm_kms_helper_poll_init()
82 * it is safe to enable interrupts and start processing hotplug events. At the
83 * same time, drivers should initialize all modeset objects such as CRTCs,
84 * encoders and connectors. To finish up the fbdev helper initialization, the
85 * drm_fb_helper_init() function is called. To probe for all attached displays
86 * and set up an initial configuration using the detected hardware, drivers
87 * should call drm_fb_helper_single_add_all_connectors() followed by
88 * drm_fb_helper_initial_config().
Noralf Trønneseaa434d2016-04-28 17:18:33 +020089 *
Noralf Trønnes2dad5512016-05-11 18:09:17 +020090 * If &drm_framebuffer_funcs ->dirty is set, the
91 * drm_fb_helper_{cfb,sys}_{write,fillrect,copyarea,imageblit} functions will
92 * accumulate changes and schedule &drm_fb_helper ->dirty_work to run right
93 * away. This worker then calls the dirty() function ensuring that it will
94 * always run in process context since the fb_*() function could be running in
95 * atomic context. If drm_fb_helper_deferred_io() is used as the deferred_io
96 * callback it will also schedule dirty_work with the damage collected from the
97 * mmap page writes.
Daniel Vetterd0ddc0332012-11-01 14:45:17 +010098 */
99
Daniel Vetter207fd322013-01-20 22:13:14 +0100100/**
101 * drm_fb_helper_single_add_all_connectors() - add all connectors to fbdev
102 * emulation helper
103 * @fb_helper: fbdev initialized with drm_fb_helper_init
104 *
105 * This functions adds all the available connectors for use with the given
106 * fb_helper. This is a separate step to allow drivers to freely assign
107 * connectors to the fbdev, e.g. if some are reserved for special purposes or
108 * not adequate to be used for the fbcon.
109 *
Daniel Vetter169faec2015-07-09 23:44:27 +0200110 * This function is protected against concurrent connector hotadds/removals
111 * using drm_fb_helper_add_one_connector() and
112 * drm_fb_helper_remove_one_connector().
Daniel Vetter207fd322013-01-20 22:13:14 +0100113 */
Dave Airlie0b4c0f32010-03-30 05:34:15 +0000114int drm_fb_helper_single_add_all_connectors(struct drm_fb_helper *fb_helper)
Dave Airlied50ba252009-09-23 14:44:08 +1000115{
Dave Airlie0b4c0f32010-03-30 05:34:15 +0000116 struct drm_device *dev = fb_helper->dev;
117 struct drm_connector *connector;
Maarten Lankhorst15fce292016-02-15 13:45:16 +0100118 int i, ret;
Dave Airlied50ba252009-09-23 14:44:08 +1000119
Daniel Vetterf64c5572015-08-25 15:45:13 +0200120 if (!drm_fbdev_emulation)
121 return 0;
122
Daniel Vetter169faec2015-07-09 23:44:27 +0200123 mutex_lock(&dev->mode_config.mutex);
Daniel Vetter6295d602015-07-09 23:44:25 +0200124 drm_for_each_connector(connector, dev) {
Maarten Lankhorst15fce292016-02-15 13:45:16 +0100125 ret = drm_fb_helper_add_one_connector(fb_helper, connector);
Dave Airlie0b4c0f32010-03-30 05:34:15 +0000126
Maarten Lankhorst15fce292016-02-15 13:45:16 +0100127 if (ret)
Dave Airlie0b4c0f32010-03-30 05:34:15 +0000128 goto fail;
Dave Airlie0b4c0f32010-03-30 05:34:15 +0000129 }
Daniel Vetter169faec2015-07-09 23:44:27 +0200130 mutex_unlock(&dev->mode_config.mutex);
Dave Airlied50ba252009-09-23 14:44:08 +1000131 return 0;
Dave Airlie0b4c0f32010-03-30 05:34:15 +0000132fail:
133 for (i = 0; i < fb_helper->connector_count; i++) {
134 kfree(fb_helper->connector_info[i]);
135 fb_helper->connector_info[i] = NULL;
136 }
137 fb_helper->connector_count = 0;
Daniel Vetter169faec2015-07-09 23:44:27 +0200138 mutex_unlock(&dev->mode_config.mutex);
139
Maarten Lankhorst15fce292016-02-15 13:45:16 +0100140 return ret;
Dave Airlied50ba252009-09-23 14:44:08 +1000141}
Dave Airlie0b4c0f32010-03-30 05:34:15 +0000142EXPORT_SYMBOL(drm_fb_helper_single_add_all_connectors);
Dave Airlied50ba252009-09-23 14:44:08 +1000143
Dave Airlie65c2a892014-06-05 14:01:30 +1000144int drm_fb_helper_add_one_connector(struct drm_fb_helper *fb_helper, struct drm_connector *connector)
145{
146 struct drm_fb_helper_connector **temp;
147 struct drm_fb_helper_connector *fb_helper_connector;
148
Daniel Vetterf64c5572015-08-25 15:45:13 +0200149 if (!drm_fbdev_emulation)
150 return 0;
151
Dave Airlie65c2a892014-06-05 14:01:30 +1000152 WARN_ON(!mutex_is_locked(&fb_helper->dev->mode_config.mutex));
153 if (fb_helper->connector_count + 1 > fb_helper->connector_info_alloc_count) {
Damien Lespiau14f476f2014-08-08 19:15:20 +0100154 temp = krealloc(fb_helper->connector_info, sizeof(struct drm_fb_helper_connector *) * (fb_helper->connector_count + 1), GFP_KERNEL);
Dave Airlie65c2a892014-06-05 14:01:30 +1000155 if (!temp)
156 return -ENOMEM;
157
158 fb_helper->connector_info_alloc_count = fb_helper->connector_count + 1;
159 fb_helper->connector_info = temp;
160 }
161
162
163 fb_helper_connector = kzalloc(sizeof(struct drm_fb_helper_connector), GFP_KERNEL);
164 if (!fb_helper_connector)
165 return -ENOMEM;
166
Dave Airlie6e86d582016-04-27 11:24:51 +1000167 drm_connector_reference(connector);
Dave Airlie65c2a892014-06-05 14:01:30 +1000168 fb_helper_connector->connector = connector;
169 fb_helper->connector_info[fb_helper->connector_count++] = fb_helper_connector;
170 return 0;
171}
172EXPORT_SYMBOL(drm_fb_helper_add_one_connector);
173
174int drm_fb_helper_remove_one_connector(struct drm_fb_helper *fb_helper,
175 struct drm_connector *connector)
176{
177 struct drm_fb_helper_connector *fb_helper_connector;
178 int i, j;
179
Daniel Vetterf64c5572015-08-25 15:45:13 +0200180 if (!drm_fbdev_emulation)
181 return 0;
182
Dave Airlie65c2a892014-06-05 14:01:30 +1000183 WARN_ON(!mutex_is_locked(&fb_helper->dev->mode_config.mutex));
184
185 for (i = 0; i < fb_helper->connector_count; i++) {
186 if (fb_helper->connector_info[i]->connector == connector)
187 break;
188 }
189
190 if (i == fb_helper->connector_count)
191 return -EINVAL;
192 fb_helper_connector = fb_helper->connector_info[i];
Dave Airlie6e86d582016-04-27 11:24:51 +1000193 drm_connector_unreference(fb_helper_connector->connector);
Dave Airlie65c2a892014-06-05 14:01:30 +1000194
195 for (j = i + 1; j < fb_helper->connector_count; j++) {
196 fb_helper->connector_info[j - 1] = fb_helper->connector_info[j];
197 }
198 fb_helper->connector_count--;
199 kfree(fb_helper_connector);
Rob Clark2148f182015-01-26 10:11:08 -0500200
Dave Airlie65c2a892014-06-05 14:01:30 +1000201 return 0;
202}
203EXPORT_SYMBOL(drm_fb_helper_remove_one_connector);
204
Jason Wessel99231022010-10-13 14:09:43 -0500205static void drm_fb_helper_save_lut_atomic(struct drm_crtc *crtc, struct drm_fb_helper *helper)
206{
207 uint16_t *r_base, *g_base, *b_base;
208 int i;
209
Ville Syrjälä04c0c562013-05-27 20:19:57 +0300210 if (helper->funcs->gamma_get == NULL)
211 return;
212
Jason Wessel99231022010-10-13 14:09:43 -0500213 r_base = crtc->gamma_store;
214 g_base = r_base + crtc->gamma_size;
215 b_base = g_base + crtc->gamma_size;
216
217 for (i = 0; i < crtc->gamma_size; i++)
218 helper->funcs->gamma_get(crtc, &r_base[i], &g_base[i], &b_base[i], i);
219}
220
221static void drm_fb_helper_restore_lut_atomic(struct drm_crtc *crtc)
222{
223 uint16_t *r_base, *g_base, *b_base;
224
Laurent Pinchartebe0f242012-05-17 13:27:24 +0200225 if (crtc->funcs->gamma_set == NULL)
226 return;
227
Jason Wessel99231022010-10-13 14:09:43 -0500228 r_base = crtc->gamma_store;
229 g_base = r_base + crtc->gamma_size;
230 b_base = g_base + crtc->gamma_size;
231
Maarten Lankhorst7ea77282016-06-07 12:49:30 +0200232 crtc->funcs->gamma_set(crtc, r_base, g_base, b_base, crtc->gamma_size);
Jason Wessel99231022010-10-13 14:09:43 -0500233}
234
Daniel Vetter207fd322013-01-20 22:13:14 +0100235/**
236 * drm_fb_helper_debug_enter - implementation for ->fb_debug_enter
237 * @info: fbdev registered by the helper
238 */
Jesse Barnes1a7aba72010-08-05 09:22:31 -0500239int drm_fb_helper_debug_enter(struct fb_info *info)
240{
241 struct drm_fb_helper *helper = info->par;
Jani Nikulabe26a662015-03-11 11:51:06 +0200242 const struct drm_crtc_helper_funcs *funcs;
Jesse Barnes1a7aba72010-08-05 09:22:31 -0500243 int i;
244
Jesse Barnes1a7aba72010-08-05 09:22:31 -0500245 list_for_each_entry(helper, &kernel_fb_helper_list, kernel_fb_list) {
246 for (i = 0; i < helper->crtc_count; i++) {
247 struct drm_mode_set *mode_set =
248 &helper->crtc_info[i].mode_set;
249
250 if (!mode_set->crtc->enabled)
251 continue;
252
253 funcs = mode_set->crtc->helper_private;
Jason Wessel99231022010-10-13 14:09:43 -0500254 drm_fb_helper_save_lut_atomic(mode_set->crtc, helper);
Jesse Barnes1a7aba72010-08-05 09:22:31 -0500255 funcs->mode_set_base_atomic(mode_set->crtc,
256 mode_set->fb,
257 mode_set->x,
Jason Wessel413d45d2010-09-26 06:47:25 -0500258 mode_set->y,
Jason Wessel21c74a82010-10-13 14:09:44 -0500259 ENTER_ATOMIC_MODE_SET);
Jesse Barnes1a7aba72010-08-05 09:22:31 -0500260 }
261 }
262
263 return 0;
264}
265EXPORT_SYMBOL(drm_fb_helper_debug_enter);
266
267/* Find the real fb for a given fb helper CRTC */
268static struct drm_framebuffer *drm_mode_config_fb(struct drm_crtc *crtc)
269{
270 struct drm_device *dev = crtc->dev;
271 struct drm_crtc *c;
272
Daniel Vetter6295d602015-07-09 23:44:25 +0200273 drm_for_each_crtc(c, dev) {
Jesse Barnes1a7aba72010-08-05 09:22:31 -0500274 if (crtc->base.id == c->base.id)
Matt Roperf4510a22014-04-01 15:22:40 -0700275 return c->primary->fb;
Jesse Barnes1a7aba72010-08-05 09:22:31 -0500276 }
277
278 return NULL;
279}
280
Daniel Vetter207fd322013-01-20 22:13:14 +0100281/**
282 * drm_fb_helper_debug_leave - implementation for ->fb_debug_leave
283 * @info: fbdev registered by the helper
284 */
Jesse Barnes1a7aba72010-08-05 09:22:31 -0500285int drm_fb_helper_debug_leave(struct fb_info *info)
286{
287 struct drm_fb_helper *helper = info->par;
288 struct drm_crtc *crtc;
Jani Nikulabe26a662015-03-11 11:51:06 +0200289 const struct drm_crtc_helper_funcs *funcs;
Jesse Barnes1a7aba72010-08-05 09:22:31 -0500290 struct drm_framebuffer *fb;
291 int i;
292
293 for (i = 0; i < helper->crtc_count; i++) {
294 struct drm_mode_set *mode_set = &helper->crtc_info[i].mode_set;
295 crtc = mode_set->crtc;
296 funcs = crtc->helper_private;
297 fb = drm_mode_config_fb(crtc);
298
299 if (!crtc->enabled)
300 continue;
301
302 if (!fb) {
303 DRM_ERROR("no fb to restore??\n");
304 continue;
305 }
306
Jason Wessel99231022010-10-13 14:09:43 -0500307 drm_fb_helper_restore_lut_atomic(mode_set->crtc);
Jesse Barnes1a7aba72010-08-05 09:22:31 -0500308 funcs->mode_set_base_atomic(mode_set->crtc, fb, crtc->x,
Jason Wessel21c74a82010-10-13 14:09:44 -0500309 crtc->y, LEAVE_ATOMIC_MODE_SET);
Jesse Barnes1a7aba72010-08-05 09:22:31 -0500310 }
311
312 return 0;
313}
314EXPORT_SYMBOL(drm_fb_helper_debug_leave);
315
Rob Clarkbbb1e522015-08-25 15:35:58 -0400316static int restore_fbdev_mode_atomic(struct drm_fb_helper *fb_helper)
317{
318 struct drm_device *dev = fb_helper->dev;
319 struct drm_plane *plane;
320 struct drm_atomic_state *state;
321 int i, ret;
Maarten Lankhorstf72c6b32015-11-11 11:29:10 +0100322 unsigned plane_mask;
Rob Clarkbbb1e522015-08-25 15:35:58 -0400323
324 state = drm_atomic_state_alloc(dev);
325 if (!state)
326 return -ENOMEM;
327
328 state->acquire_ctx = dev->mode_config.acquire_ctx;
329retry:
Maarten Lankhorstf72c6b32015-11-11 11:29:10 +0100330 plane_mask = 0;
Rob Clarkbbb1e522015-08-25 15:35:58 -0400331 drm_for_each_plane(plane, dev) {
332 struct drm_plane_state *plane_state;
333
334 plane_state = drm_atomic_get_plane_state(state, plane);
335 if (IS_ERR(plane_state)) {
336 ret = PTR_ERR(plane_state);
337 goto fail;
338 }
339
Joonas Lahtinen31ad61e2016-07-29 08:50:05 +0300340 plane_state->rotation = DRM_ROTATE_0;
Rob Clarkbbb1e522015-08-25 15:35:58 -0400341
Maarten Lankhorstf72c6b32015-11-11 11:29:10 +0100342 plane->old_fb = plane->fb;
343 plane_mask |= 1 << drm_plane_index(plane);
344
Rob Clarkbbb1e522015-08-25 15:35:58 -0400345 /* disable non-primary: */
346 if (plane->type == DRM_PLANE_TYPE_PRIMARY)
347 continue;
348
349 ret = __drm_atomic_helper_disable_plane(plane, plane_state);
350 if (ret != 0)
351 goto fail;
352 }
353
354 for(i = 0; i < fb_helper->crtc_count; i++) {
355 struct drm_mode_set *mode_set = &fb_helper->crtc_info[i].mode_set;
356
357 ret = __drm_atomic_helper_set_config(mode_set, state);
358 if (ret != 0)
359 goto fail;
360 }
361
362 ret = drm_atomic_commit(state);
Rob Clarkbbb1e522015-08-25 15:35:58 -0400363
364fail:
Maarten Lankhorstf72c6b32015-11-11 11:29:10 +0100365 drm_atomic_clean_old_fb(dev, plane_mask, ret);
Matt Roper94284032015-09-21 17:21:48 -0700366
Rob Clarkbbb1e522015-08-25 15:35:58 -0400367 if (ret == -EDEADLK)
368 goto backoff;
369
Chris Wilson08536952016-10-14 13:18:18 +0100370 drm_atomic_state_put(state);
Rob Clarkbbb1e522015-08-25 15:35:58 -0400371 return ret;
372
373backoff:
374 drm_atomic_state_clear(state);
375 drm_atomic_legacy_backoff(state);
376
377 goto retry;
378}
379
Daniel Vetterb7bdf0a82015-08-25 17:20:28 +0200380static int restore_fbdev_mode(struct drm_fb_helper *fb_helper)
Dave Airliee8e7a2b2011-04-21 22:18:32 +0100381{
Ville Syrjälä3858bc52013-06-03 16:10:42 +0300382 struct drm_device *dev = fb_helper->dev;
383 struct drm_plane *plane;
Ville Syrjälä3858bc52013-06-03 16:10:42 +0300384 int i;
Daniel Vetter6aed8ec2013-01-20 17:32:21 +0100385
Ville Syrjälä3858bc52013-06-03 16:10:42 +0300386 drm_warn_on_modeset_not_all_locked(dev);
387
Daniel Vetterd3a46182016-06-08 14:19:15 +0200388 if (dev->mode_config.funcs->atomic_commit)
Rob Clarkbbb1e522015-08-25 15:35:58 -0400389 return restore_fbdev_mode_atomic(fb_helper);
390
Daniel Vetter6295d602015-07-09 23:44:25 +0200391 drm_for_each_plane(plane, dev) {
Matt Ropere27dde32014-04-01 15:22:30 -0700392 if (plane->type != DRM_PLANE_TYPE_PRIMARY)
393 drm_plane_force_disable(plane);
Daniel Vetter6aed8ec2013-01-20 17:32:21 +0100394
Ville Syrjälä6686df82016-10-21 22:22:45 +0300395 if (plane->rotation_property)
Ville Syrjäläd138dd32016-09-26 19:30:48 +0300396 drm_mode_plane_set_obj_prop(plane,
397 plane->rotation_property,
398 DRM_ROTATE_0);
Sonika Jindal9783de22014-08-05 11:26:57 +0530399 }
400
Dave Airliee8e7a2b2011-04-21 22:18:32 +0100401 for (i = 0; i < fb_helper->crtc_count; i++) {
402 struct drm_mode_set *mode_set = &fb_helper->crtc_info[i].mode_set;
Ville Syrjälä3858bc52013-06-03 16:10:42 +0300403 struct drm_crtc *crtc = mode_set->crtc;
404 int ret;
405
Alex Deucher03f9abb2015-09-30 14:47:37 -0400406 if (crtc->funcs->cursor_set2) {
407 ret = crtc->funcs->cursor_set2(crtc, NULL, 0, 0, 0, 0, 0);
408 if (ret)
Dave Airlie48f87dd2015-10-16 10:10:32 +1000409 return ret;
Alex Deucher03f9abb2015-09-30 14:47:37 -0400410 } else if (crtc->funcs->cursor_set) {
Ville Syrjälä3858bc52013-06-03 16:10:42 +0300411 ret = crtc->funcs->cursor_set(crtc, NULL, 0, 0, 0);
412 if (ret)
Daniel Vetterb7bdf0a82015-08-25 17:20:28 +0200413 return ret;
Ville Syrjälä3858bc52013-06-03 16:10:42 +0300414 }
415
Daniel Vetter2d13b672012-12-11 13:47:23 +0100416 ret = drm_mode_set_config_internal(mode_set);
Dave Airliee8e7a2b2011-04-21 22:18:32 +0100417 if (ret)
Daniel Vetterb7bdf0a82015-08-25 17:20:28 +0200418 return ret;
Dave Airliee8e7a2b2011-04-21 22:18:32 +0100419 }
Daniel Vetterb7bdf0a82015-08-25 17:20:28 +0200420
421 return 0;
Dave Airliee8e7a2b2011-04-21 22:18:32 +0100422}
Rob Clark5ea1f752014-05-30 12:29:48 -0400423
424/**
425 * drm_fb_helper_restore_fbdev_mode_unlocked - restore fbdev configuration
426 * @fb_helper: fbcon to restore
427 *
428 * This should be called from driver's drm ->lastclose callback
429 * when implementing an fbcon on top of kms using this helper. This ensures that
430 * the user isn't greeted with a black screen when e.g. X dies.
Daniel Vetterb7bdf0a82015-08-25 17:20:28 +0200431 *
432 * RETURNS:
433 * Zero if everything went ok, negative error code otherwise.
Rob Clark5ea1f752014-05-30 12:29:48 -0400434 */
Daniel Vetterb7bdf0a82015-08-25 17:20:28 +0200435int drm_fb_helper_restore_fbdev_mode_unlocked(struct drm_fb_helper *fb_helper)
Rob Clark5ea1f752014-05-30 12:29:48 -0400436{
437 struct drm_device *dev = fb_helper->dev;
Daniel Vetterb7bdf0a82015-08-25 17:20:28 +0200438 bool do_delayed;
439 int ret;
Dave Airliee2809c72014-11-26 13:15:24 +1000440
Daniel Vetterf64c5572015-08-25 15:45:13 +0200441 if (!drm_fbdev_emulation)
442 return -ENODEV;
443
Rob Clark5ea1f752014-05-30 12:29:48 -0400444 drm_modeset_lock_all(dev);
445 ret = restore_fbdev_mode(fb_helper);
Dave Airliee2809c72014-11-26 13:15:24 +1000446
447 do_delayed = fb_helper->delayed_hotplug;
448 if (do_delayed)
449 fb_helper->delayed_hotplug = false;
Rob Clark5ea1f752014-05-30 12:29:48 -0400450 drm_modeset_unlock_all(dev);
Dave Airliee2809c72014-11-26 13:15:24 +1000451
452 if (do_delayed)
453 drm_fb_helper_hotplug_event(fb_helper);
Rob Clark5ea1f752014-05-30 12:29:48 -0400454 return ret;
455}
456EXPORT_SYMBOL(drm_fb_helper_restore_fbdev_mode_unlocked);
Dave Airliee8e7a2b2011-04-21 22:18:32 +0100457
Geert Uytterhoeven2c4124f2015-08-04 15:22:11 +0200458static bool drm_fb_helper_is_bound(struct drm_fb_helper *fb_helper)
459{
460 struct drm_device *dev = fb_helper->dev;
461 struct drm_crtc *crtc;
462 int bound = 0, crtcs_bound = 0;
463
464 /* Sometimes user space wants everything disabled, so don't steal the
465 * display if there's a master. */
Johannes Bergf17b3ea2016-08-11 11:50:21 +0200466 if (READ_ONCE(dev->master))
Geert Uytterhoeven2c4124f2015-08-04 15:22:11 +0200467 return false;
468
469 drm_for_each_crtc(crtc, dev) {
470 if (crtc->primary->fb)
471 crtcs_bound++;
472 if (crtc->primary->fb == fb_helper->fb)
473 bound++;
474 }
475
476 if (bound < crtcs_bound)
477 return false;
478
479 return true;
480}
481
482#ifdef CONFIG_MAGIC_SYSRQ
Daniel Vetterd21bf462013-01-20 18:09:52 +0100483/*
484 * restore fbcon display for all kms driver's using this helper, used for sysrq
485 * and panic handling.
486 */
Sachin Kamat78b9c352012-08-01 17:15:32 +0530487static bool drm_fb_helper_force_kernel_mode(void)
Dave Airlie785b93e2009-08-28 15:46:53 +1000488{
Dave Airlie785b93e2009-08-28 15:46:53 +1000489 bool ret, error = false;
490 struct drm_fb_helper *helper;
491
492 if (list_empty(&kernel_fb_helper_list))
493 return false;
494
495 list_for_each_entry(helper, &kernel_fb_helper_list, kernel_fb_list) {
Thierry Redingb77f0762014-04-29 11:44:32 +0200496 struct drm_device *dev = helper->dev;
497
498 if (dev->switch_power_state == DRM_SWITCH_POWER_OFF)
Dave Airliee8e7a2b2011-04-21 22:18:32 +0100499 continue;
500
Daniel Vetterdd908c82015-07-28 13:18:41 +0200501 drm_modeset_lock_all(dev);
Geert Uytterhoeven3d9e35a2015-08-04 15:22:10 +0200502 ret = restore_fbdev_mode(helper);
Dave Airliee8e7a2b2011-04-21 22:18:32 +0100503 if (ret)
504 error = true;
Daniel Vettercb597bb2014-07-27 19:09:33 +0200505 drm_modeset_unlock_all(dev);
Dave Airlie785b93e2009-08-28 15:46:53 +1000506 }
507 return error;
508}
509
Dave Airlie785b93e2009-08-28 15:46:53 +1000510static void drm_fb_helper_restore_work_fn(struct work_struct *ignored)
511{
Daniel Vetterd21bf462013-01-20 18:09:52 +0100512 bool ret;
513 ret = drm_fb_helper_force_kernel_mode();
514 if (ret == true)
515 DRM_ERROR("Failed to restore crtc configuration\n");
Dave Airlie785b93e2009-08-28 15:46:53 +1000516}
517static DECLARE_WORK(drm_fb_helper_restore_work, drm_fb_helper_restore_work_fn);
518
Dmitry Torokhov1495cc92010-08-17 21:15:46 -0700519static void drm_fb_helper_sysrq(int dummy1)
Dave Airlie785b93e2009-08-28 15:46:53 +1000520{
521 schedule_work(&drm_fb_helper_restore_work);
522}
523
524static struct sysrq_key_op sysrq_drm_fb_helper_restore_op = {
525 .handler = drm_fb_helper_sysrq,
526 .help_msg = "force-fb(V)",
527 .action_msg = "Restore framebuffer console",
528};
Randy Dunlapb8c40d62010-03-25 18:29:05 +0000529#else
530static struct sysrq_key_op sysrq_drm_fb_helper_restore_op = { };
Mikael Petterssonbea1d352009-09-28 18:26:25 +0200531#endif
Dave Airlie785b93e2009-08-28 15:46:53 +1000532
Sascha Hauer3a8148c2012-02-01 11:38:24 +0100533static void drm_fb_helper_dpms(struct fb_info *info, int dpms_mode)
Dave Airlie785b93e2009-08-28 15:46:53 +1000534{
535 struct drm_fb_helper *fb_helper = info->par;
536 struct drm_device *dev = fb_helper->dev;
537 struct drm_crtc *crtc;
Jesse Barnes023eb572010-07-02 10:48:08 -0700538 struct drm_connector *connector;
Jesse Barnes023eb572010-07-02 10:48:08 -0700539 int i, j;
Dave Airlie785b93e2009-08-28 15:46:53 +1000540
541 /*
Sascha Hauer3a8148c2012-02-01 11:38:24 +0100542 * For each CRTC in this fb, turn the connectors on/off.
Dave Airlie785b93e2009-08-28 15:46:53 +1000543 */
Daniel Vetter84849902012-12-02 00:28:11 +0100544 drm_modeset_lock_all(dev);
Daniel Vetter20c60c32012-12-17 12:13:23 +0100545 if (!drm_fb_helper_is_bound(fb_helper)) {
546 drm_modeset_unlock_all(dev);
547 return;
548 }
549
Jesse Barnese87b2c42009-09-17 18:14:41 -0700550 for (i = 0; i < fb_helper->crtc_count; i++) {
Dave Airlie8be48d92010-03-30 05:34:14 +0000551 crtc = fb_helper->crtc_info[i].mode_set.crtc;
Dave Airlie785b93e2009-08-28 15:46:53 +1000552
Dave Airlie8be48d92010-03-30 05:34:14 +0000553 if (!crtc->enabled)
554 continue;
Dave Airlie785b93e2009-08-28 15:46:53 +1000555
Sascha Hauer3a8148c2012-02-01 11:38:24 +0100556 /* Walk the connectors & encoders on this fb turning them on/off */
Jesse Barnes023eb572010-07-02 10:48:08 -0700557 for (j = 0; j < fb_helper->connector_count; j++) {
558 connector = fb_helper->connector_info[j]->connector;
Daniel Vettere04190e2012-09-07 10:14:52 +0200559 connector->funcs->dpms(connector, dpms_mode);
Rob Clark58495562012-10-11 20:50:56 -0500560 drm_object_property_set_value(&connector->base,
Sascha Hauer3a8148c2012-02-01 11:38:24 +0100561 dev->mode_config.dpms_property, dpms_mode);
Jesse Barnes023eb572010-07-02 10:48:08 -0700562 }
Dave Airlie785b93e2009-08-28 15:46:53 +1000563 }
Daniel Vetter84849902012-12-02 00:28:11 +0100564 drm_modeset_unlock_all(dev);
Dave Airlie785b93e2009-08-28 15:46:53 +1000565}
566
Daniel Vetter207fd322013-01-20 22:13:14 +0100567/**
568 * drm_fb_helper_blank - implementation for ->fb_blank
569 * @blank: desired blanking state
570 * @info: fbdev registered by the helper
571 */
Dave Airlie785b93e2009-08-28 15:46:53 +1000572int drm_fb_helper_blank(int blank, struct fb_info *info)
573{
Daniel Vetterc50bfd02015-07-28 13:18:40 +0200574 if (oops_in_progress)
575 return -EBUSY;
576
Dave Airlie785b93e2009-08-28 15:46:53 +1000577 switch (blank) {
James Simmons731b5a12009-10-29 20:39:07 +0000578 /* Display: On; HSync: On, VSync: On */
Dave Airlie785b93e2009-08-28 15:46:53 +1000579 case FB_BLANK_UNBLANK:
Sascha Hauer3a8148c2012-02-01 11:38:24 +0100580 drm_fb_helper_dpms(info, DRM_MODE_DPMS_ON);
Dave Airlie785b93e2009-08-28 15:46:53 +1000581 break;
James Simmons731b5a12009-10-29 20:39:07 +0000582 /* Display: Off; HSync: On, VSync: On */
Dave Airlie785b93e2009-08-28 15:46:53 +1000583 case FB_BLANK_NORMAL:
Sascha Hauer3a8148c2012-02-01 11:38:24 +0100584 drm_fb_helper_dpms(info, DRM_MODE_DPMS_STANDBY);
Dave Airlie785b93e2009-08-28 15:46:53 +1000585 break;
James Simmons731b5a12009-10-29 20:39:07 +0000586 /* Display: Off; HSync: Off, VSync: On */
Dave Airlie785b93e2009-08-28 15:46:53 +1000587 case FB_BLANK_HSYNC_SUSPEND:
Sascha Hauer3a8148c2012-02-01 11:38:24 +0100588 drm_fb_helper_dpms(info, DRM_MODE_DPMS_STANDBY);
Dave Airlie785b93e2009-08-28 15:46:53 +1000589 break;
James Simmons731b5a12009-10-29 20:39:07 +0000590 /* Display: Off; HSync: On, VSync: Off */
Dave Airlie785b93e2009-08-28 15:46:53 +1000591 case FB_BLANK_VSYNC_SUSPEND:
Sascha Hauer3a8148c2012-02-01 11:38:24 +0100592 drm_fb_helper_dpms(info, DRM_MODE_DPMS_SUSPEND);
Dave Airlie785b93e2009-08-28 15:46:53 +1000593 break;
James Simmons731b5a12009-10-29 20:39:07 +0000594 /* Display: Off; HSync: Off, VSync: Off */
Dave Airlie785b93e2009-08-28 15:46:53 +1000595 case FB_BLANK_POWERDOWN:
Sascha Hauer3a8148c2012-02-01 11:38:24 +0100596 drm_fb_helper_dpms(info, DRM_MODE_DPMS_OFF);
Dave Airlie785b93e2009-08-28 15:46:53 +1000597 break;
598 }
599 return 0;
600}
601EXPORT_SYMBOL(drm_fb_helper_blank);
602
603static void drm_fb_helper_crtc_free(struct drm_fb_helper *helper)
604{
605 int i;
606
Dave Airlie6e86d582016-04-27 11:24:51 +1000607 for (i = 0; i < helper->connector_count; i++) {
608 drm_connector_unreference(helper->connector_info[i]->connector);
Dave Airlie0b4c0f32010-03-30 05:34:15 +0000609 kfree(helper->connector_info[i]);
Dave Airlie6e86d582016-04-27 11:24:51 +1000610 }
Dave Airlie0b4c0f32010-03-30 05:34:15 +0000611 kfree(helper->connector_info);
Sascha Hauera1b77362012-02-01 11:38:22 +0100612 for (i = 0; i < helper->crtc_count; i++) {
Dave Airlie785b93e2009-08-28 15:46:53 +1000613 kfree(helper->crtc_info[i].mode_set.connectors);
Sascha Hauera1b77362012-02-01 11:38:22 +0100614 if (helper->crtc_info[i].mode_set.mode)
615 drm_mode_destroy(helper->dev, helper->crtc_info[i].mode_set.mode);
616 }
Dave Airlie785b93e2009-08-28 15:46:53 +1000617 kfree(helper->crtc_info);
618}
619
Noralf Trønnescfe63422016-08-23 13:54:06 +0200620static void drm_fb_helper_resume_worker(struct work_struct *work)
621{
622 struct drm_fb_helper *helper = container_of(work, struct drm_fb_helper,
623 resume_work);
624
625 console_lock();
626 fb_set_suspend(helper->fbdev, 0);
627 console_unlock();
628}
629
Noralf Trønneseaa434d2016-04-28 17:18:33 +0200630static void drm_fb_helper_dirty_work(struct work_struct *work)
631{
632 struct drm_fb_helper *helper = container_of(work, struct drm_fb_helper,
633 dirty_work);
634 struct drm_clip_rect *clip = &helper->dirty_clip;
635 struct drm_clip_rect clip_copy;
636 unsigned long flags;
637
638 spin_lock_irqsave(&helper->dirty_lock, flags);
639 clip_copy = *clip;
640 clip->x1 = clip->y1 = ~0;
641 clip->x2 = clip->y2 = 0;
642 spin_unlock_irqrestore(&helper->dirty_lock, flags);
643
644 helper->fb->funcs->dirty(helper->fb, NULL, 0, 0, &clip_copy, 1);
645}
646
Daniel Vetter207fd322013-01-20 22:13:14 +0100647/**
Thierry Reding10a23102014-06-27 17:19:24 +0200648 * drm_fb_helper_prepare - setup a drm_fb_helper structure
649 * @dev: DRM device
650 * @helper: driver-allocated fbdev helper structure to set up
651 * @funcs: pointer to structure of functions associate with this helper
652 *
653 * Sets up the bare minimum to make the framebuffer helper usable. This is
654 * useful to implement race-free initialization of the polling helpers.
655 */
656void drm_fb_helper_prepare(struct drm_device *dev, struct drm_fb_helper *helper,
657 const struct drm_fb_helper_funcs *funcs)
658{
659 INIT_LIST_HEAD(&helper->kernel_fb_list);
Noralf Trønneseaa434d2016-04-28 17:18:33 +0200660 spin_lock_init(&helper->dirty_lock);
Noralf Trønnescfe63422016-08-23 13:54:06 +0200661 INIT_WORK(&helper->resume_work, drm_fb_helper_resume_worker);
Noralf Trønneseaa434d2016-04-28 17:18:33 +0200662 INIT_WORK(&helper->dirty_work, drm_fb_helper_dirty_work);
663 helper->dirty_clip.x1 = helper->dirty_clip.y1 = ~0;
Thierry Reding10a23102014-06-27 17:19:24 +0200664 helper->funcs = funcs;
665 helper->dev = dev;
666}
667EXPORT_SYMBOL(drm_fb_helper_prepare);
668
669/**
Daniel Vetter207fd322013-01-20 22:13:14 +0100670 * drm_fb_helper_init - initialize a drm_fb_helper structure
671 * @dev: drm device
672 * @fb_helper: driver-allocated fbdev helper structure to initialize
673 * @crtc_count: maximum number of crtcs to support in this fbdev emulation
674 * @max_conn_count: max connector count
675 *
676 * This allocates the structures for the fbdev helper with the given limits.
677 * Note that this won't yet touch the hardware (through the driver interfaces)
678 * nor register the fbdev. This is only done in drm_fb_helper_initial_config()
679 * to allow driver writes more control over the exact init sequence.
680 *
Thierry Reding10a23102014-06-27 17:19:24 +0200681 * Drivers must call drm_fb_helper_prepare() before calling this function.
Daniel Vetter207fd322013-01-20 22:13:14 +0100682 *
683 * RETURNS:
684 * Zero if everything went ok, nonzero otherwise.
685 */
Dave Airlie4abe3522010-03-30 05:34:18 +0000686int drm_fb_helper_init(struct drm_device *dev,
687 struct drm_fb_helper *fb_helper,
Dave Airlieeb1f8e42010-05-07 06:42:51 +0000688 int crtc_count, int max_conn_count)
Dave Airlie785b93e2009-08-28 15:46:53 +1000689{
Dave Airlie785b93e2009-08-28 15:46:53 +1000690 struct drm_crtc *crtc;
Dave Airlie785b93e2009-08-28 15:46:53 +1000691 int i;
692
Daniel Vetterf64c5572015-08-25 15:45:13 +0200693 if (!drm_fbdev_emulation)
694 return 0;
695
Xiubo Li04cfe972014-03-10 09:33:58 +0800696 if (!max_conn_count)
697 return -EINVAL;
698
Dave Airlie4abe3522010-03-30 05:34:18 +0000699 fb_helper->crtc_info = kcalloc(crtc_count, sizeof(struct drm_fb_helper_crtc), GFP_KERNEL);
700 if (!fb_helper->crtc_info)
Dave Airlie785b93e2009-08-28 15:46:53 +1000701 return -ENOMEM;
702
Dave Airlie4abe3522010-03-30 05:34:18 +0000703 fb_helper->crtc_count = crtc_count;
704 fb_helper->connector_info = kcalloc(dev->mode_config.num_connector, sizeof(struct drm_fb_helper_connector *), GFP_KERNEL);
705 if (!fb_helper->connector_info) {
706 kfree(fb_helper->crtc_info);
Dave Airlie0b4c0f32010-03-30 05:34:15 +0000707 return -ENOMEM;
708 }
Dave Airlie65c2a892014-06-05 14:01:30 +1000709 fb_helper->connector_info_alloc_count = dev->mode_config.num_connector;
Dave Airlie4abe3522010-03-30 05:34:18 +0000710 fb_helper->connector_count = 0;
Dave Airlie785b93e2009-08-28 15:46:53 +1000711
712 for (i = 0; i < crtc_count; i++) {
Dave Airlie4abe3522010-03-30 05:34:18 +0000713 fb_helper->crtc_info[i].mode_set.connectors =
Dave Airlie785b93e2009-08-28 15:46:53 +1000714 kcalloc(max_conn_count,
715 sizeof(struct drm_connector *),
716 GFP_KERNEL);
717
Laurent Pinchart4a1b0712012-05-17 13:27:21 +0200718 if (!fb_helper->crtc_info[i].mode_set.connectors)
Dave Airlie785b93e2009-08-28 15:46:53 +1000719 goto out_free;
Dave Airlie4abe3522010-03-30 05:34:18 +0000720 fb_helper->crtc_info[i].mode_set.num_connectors = 0;
Dave Airlie785b93e2009-08-28 15:46:53 +1000721 }
722
723 i = 0;
Daniel Vetter6295d602015-07-09 23:44:25 +0200724 drm_for_each_crtc(crtc, dev) {
Dave Airlie4abe3522010-03-30 05:34:18 +0000725 fb_helper->crtc_info[i].mode_set.crtc = crtc;
Dave Airlie785b93e2009-08-28 15:46:53 +1000726 i++;
727 }
Sascha Hauere9ad3182012-02-01 11:38:25 +0100728
Dave Airlie785b93e2009-08-28 15:46:53 +1000729 return 0;
730out_free:
Dave Airlie4abe3522010-03-30 05:34:18 +0000731 drm_fb_helper_crtc_free(fb_helper);
Dave Airlie785b93e2009-08-28 15:46:53 +1000732 return -ENOMEM;
733}
Dave Airlie4abe3522010-03-30 05:34:18 +0000734EXPORT_SYMBOL(drm_fb_helper_init);
735
Archit Tanejab8017d62015-07-22 14:57:56 +0530736/**
737 * drm_fb_helper_alloc_fbi - allocate fb_info and some of its members
738 * @fb_helper: driver-allocated fbdev helper
739 *
740 * A helper to alloc fb_info and the members cmap and apertures. Called
741 * by the driver within the fb_probe fb_helper callback function.
742 *
743 * RETURNS:
744 * fb_info pointer if things went okay, pointer containing error code
745 * otherwise
746 */
747struct fb_info *drm_fb_helper_alloc_fbi(struct drm_fb_helper *fb_helper)
748{
749 struct device *dev = fb_helper->dev->dev;
750 struct fb_info *info;
751 int ret;
752
753 info = framebuffer_alloc(0, dev);
754 if (!info)
755 return ERR_PTR(-ENOMEM);
756
757 ret = fb_alloc_cmap(&info->cmap, 256, 0);
758 if (ret)
759 goto err_release;
760
761 info->apertures = alloc_apertures(1);
762 if (!info->apertures) {
763 ret = -ENOMEM;
764 goto err_free_cmap;
765 }
766
767 fb_helper->fbdev = info;
768
769 return info;
770
771err_free_cmap:
772 fb_dealloc_cmap(&info->cmap);
773err_release:
774 framebuffer_release(info);
775 return ERR_PTR(ret);
776}
777EXPORT_SYMBOL(drm_fb_helper_alloc_fbi);
778
779/**
780 * drm_fb_helper_unregister_fbi - unregister fb_info framebuffer device
781 * @fb_helper: driver-allocated fbdev helper
782 *
783 * A wrapper around unregister_framebuffer, to release the fb_info
784 * framebuffer device
785 */
786void drm_fb_helper_unregister_fbi(struct drm_fb_helper *fb_helper)
787{
788 if (fb_helper && fb_helper->fbdev)
789 unregister_framebuffer(fb_helper->fbdev);
790}
791EXPORT_SYMBOL(drm_fb_helper_unregister_fbi);
792
793/**
794 * drm_fb_helper_release_fbi - dealloc fb_info and its members
795 * @fb_helper: driver-allocated fbdev helper
796 *
797 * A helper to free memory taken by fb_info and the members cmap and
798 * apertures
799 */
800void drm_fb_helper_release_fbi(struct drm_fb_helper *fb_helper)
801{
802 if (fb_helper) {
803 struct fb_info *info = fb_helper->fbdev;
804
805 if (info) {
806 if (info->cmap.len)
807 fb_dealloc_cmap(&info->cmap);
808 framebuffer_release(info);
809 }
810
811 fb_helper->fbdev = NULL;
812 }
813}
814EXPORT_SYMBOL(drm_fb_helper_release_fbi);
815
Dave Airlie4abe3522010-03-30 05:34:18 +0000816void drm_fb_helper_fini(struct drm_fb_helper *fb_helper)
817{
Daniel Vetterf64c5572015-08-25 15:45:13 +0200818 if (!drm_fbdev_emulation)
819 return;
820
Dave Airlie4abe3522010-03-30 05:34:18 +0000821 if (!list_empty(&fb_helper->kernel_fb_list)) {
822 list_del(&fb_helper->kernel_fb_list);
823 if (list_empty(&kernel_fb_helper_list)) {
Dave Airlie4abe3522010-03-30 05:34:18 +0000824 unregister_sysrq_key('v', &sysrq_drm_fb_helper_restore_op);
825 }
826 }
827
828 drm_fb_helper_crtc_free(fb_helper);
829
Dave Airlie4abe3522010-03-30 05:34:18 +0000830}
831EXPORT_SYMBOL(drm_fb_helper_fini);
Dave Airlie785b93e2009-08-28 15:46:53 +1000832
Archit Taneja47074ab2015-07-22 14:57:57 +0530833/**
834 * drm_fb_helper_unlink_fbi - wrapper around unlink_framebuffer
835 * @fb_helper: driver-allocated fbdev helper
836 *
837 * A wrapper around unlink_framebuffer implemented by fbdev core
838 */
839void drm_fb_helper_unlink_fbi(struct drm_fb_helper *fb_helper)
840{
841 if (fb_helper && fb_helper->fbdev)
842 unlink_framebuffer(fb_helper->fbdev);
843}
844EXPORT_SYMBOL(drm_fb_helper_unlink_fbi);
845
Noralf Trønneseaa434d2016-04-28 17:18:33 +0200846static void drm_fb_helper_dirty(struct fb_info *info, u32 x, u32 y,
847 u32 width, u32 height)
848{
849 struct drm_fb_helper *helper = info->par;
850 struct drm_clip_rect *clip = &helper->dirty_clip;
851 unsigned long flags;
852
853 if (!helper->fb->funcs->dirty)
854 return;
855
856 spin_lock_irqsave(&helper->dirty_lock, flags);
857 clip->x1 = min_t(u32, clip->x1, x);
858 clip->y1 = min_t(u32, clip->y1, y);
859 clip->x2 = max_t(u32, clip->x2, x + width);
860 clip->y2 = max_t(u32, clip->y2, y + height);
861 spin_unlock_irqrestore(&helper->dirty_lock, flags);
862
863 schedule_work(&helper->dirty_work);
864}
865
866/**
867 * drm_fb_helper_deferred_io() - fbdev deferred_io callback function
868 * @info: fb_info struct pointer
869 * @pagelist: list of dirty mmap framebuffer pages
870 *
871 * This function is used as the &fb_deferred_io ->deferred_io
872 * callback function for flushing the fbdev mmap writes.
873 */
874void drm_fb_helper_deferred_io(struct fb_info *info,
875 struct list_head *pagelist)
876{
877 unsigned long start, end, min, max;
878 struct page *page;
879 u32 y1, y2;
880
881 min = ULONG_MAX;
882 max = 0;
883 list_for_each_entry(page, pagelist, lru) {
884 start = page->index << PAGE_SHIFT;
885 end = start + PAGE_SIZE - 1;
886 min = min(min, start);
887 max = max(max, end);
888 }
889
890 if (min < max) {
891 y1 = min / info->fix.line_length;
892 y2 = min_t(u32, DIV_ROUND_UP(max, info->fix.line_length),
893 info->var.yres);
894 drm_fb_helper_dirty(info, 0, y1, info->var.xres, y2 - y1);
895 }
896}
897EXPORT_SYMBOL(drm_fb_helper_deferred_io);
898
Archit Tanejacbb1a822015-07-31 16:21:41 +0530899/**
900 * drm_fb_helper_sys_read - wrapper around fb_sys_read
901 * @info: fb_info struct pointer
902 * @buf: userspace buffer to read from framebuffer memory
903 * @count: number of bytes to read from framebuffer memory
904 * @ppos: read offset within framebuffer memory
905 *
906 * A wrapper around fb_sys_read implemented by fbdev core
907 */
908ssize_t drm_fb_helper_sys_read(struct fb_info *info, char __user *buf,
909 size_t count, loff_t *ppos)
910{
911 return fb_sys_read(info, buf, count, ppos);
912}
913EXPORT_SYMBOL(drm_fb_helper_sys_read);
914
915/**
916 * drm_fb_helper_sys_write - wrapper around fb_sys_write
917 * @info: fb_info struct pointer
918 * @buf: userspace buffer to write to framebuffer memory
919 * @count: number of bytes to write to framebuffer memory
920 * @ppos: write offset within framebuffer memory
921 *
922 * A wrapper around fb_sys_write implemented by fbdev core
923 */
924ssize_t drm_fb_helper_sys_write(struct fb_info *info, const char __user *buf,
925 size_t count, loff_t *ppos)
926{
Noralf Trønneseaa434d2016-04-28 17:18:33 +0200927 ssize_t ret;
928
929 ret = fb_sys_write(info, buf, count, ppos);
930 if (ret > 0)
931 drm_fb_helper_dirty(info, 0, 0, info->var.xres,
932 info->var.yres);
933
934 return ret;
Archit Tanejacbb1a822015-07-31 16:21:41 +0530935}
936EXPORT_SYMBOL(drm_fb_helper_sys_write);
937
Archit Taneja742547b2015-07-31 16:21:42 +0530938/**
939 * drm_fb_helper_sys_fillrect - wrapper around sys_fillrect
940 * @info: fbdev registered by the helper
941 * @rect: info about rectangle to fill
942 *
943 * A wrapper around sys_fillrect implemented by fbdev core
944 */
945void drm_fb_helper_sys_fillrect(struct fb_info *info,
946 const struct fb_fillrect *rect)
947{
948 sys_fillrect(info, rect);
Noralf Trønneseaa434d2016-04-28 17:18:33 +0200949 drm_fb_helper_dirty(info, rect->dx, rect->dy,
950 rect->width, rect->height);
Archit Taneja742547b2015-07-31 16:21:42 +0530951}
952EXPORT_SYMBOL(drm_fb_helper_sys_fillrect);
953
954/**
955 * drm_fb_helper_sys_copyarea - wrapper around sys_copyarea
956 * @info: fbdev registered by the helper
957 * @area: info about area to copy
958 *
959 * A wrapper around sys_copyarea implemented by fbdev core
960 */
961void drm_fb_helper_sys_copyarea(struct fb_info *info,
962 const struct fb_copyarea *area)
963{
964 sys_copyarea(info, area);
Noralf Trønneseaa434d2016-04-28 17:18:33 +0200965 drm_fb_helper_dirty(info, area->dx, area->dy,
966 area->width, area->height);
Archit Taneja742547b2015-07-31 16:21:42 +0530967}
968EXPORT_SYMBOL(drm_fb_helper_sys_copyarea);
969
970/**
971 * drm_fb_helper_sys_imageblit - wrapper around sys_imageblit
972 * @info: fbdev registered by the helper
973 * @image: info about image to blit
974 *
975 * A wrapper around sys_imageblit implemented by fbdev core
976 */
977void drm_fb_helper_sys_imageblit(struct fb_info *info,
978 const struct fb_image *image)
979{
980 sys_imageblit(info, image);
Noralf Trønneseaa434d2016-04-28 17:18:33 +0200981 drm_fb_helper_dirty(info, image->dx, image->dy,
982 image->width, image->height);
Archit Taneja742547b2015-07-31 16:21:42 +0530983}
984EXPORT_SYMBOL(drm_fb_helper_sys_imageblit);
985
986/**
987 * drm_fb_helper_cfb_fillrect - wrapper around cfb_fillrect
988 * @info: fbdev registered by the helper
989 * @rect: info about rectangle to fill
990 *
991 * A wrapper around cfb_imageblit implemented by fbdev core
992 */
993void drm_fb_helper_cfb_fillrect(struct fb_info *info,
994 const struct fb_fillrect *rect)
995{
996 cfb_fillrect(info, rect);
Noralf Trønneseaa434d2016-04-28 17:18:33 +0200997 drm_fb_helper_dirty(info, rect->dx, rect->dy,
998 rect->width, rect->height);
Archit Taneja742547b2015-07-31 16:21:42 +0530999}
1000EXPORT_SYMBOL(drm_fb_helper_cfb_fillrect);
1001
1002/**
1003 * drm_fb_helper_cfb_copyarea - wrapper around cfb_copyarea
1004 * @info: fbdev registered by the helper
1005 * @area: info about area to copy
1006 *
1007 * A wrapper around cfb_copyarea implemented by fbdev core
1008 */
1009void drm_fb_helper_cfb_copyarea(struct fb_info *info,
1010 const struct fb_copyarea *area)
1011{
1012 cfb_copyarea(info, area);
Noralf Trønneseaa434d2016-04-28 17:18:33 +02001013 drm_fb_helper_dirty(info, area->dx, area->dy,
1014 area->width, area->height);
Archit Taneja742547b2015-07-31 16:21:42 +05301015}
1016EXPORT_SYMBOL(drm_fb_helper_cfb_copyarea);
1017
1018/**
1019 * drm_fb_helper_cfb_imageblit - wrapper around cfb_imageblit
1020 * @info: fbdev registered by the helper
1021 * @image: info about image to blit
1022 *
1023 * A wrapper around cfb_imageblit implemented by fbdev core
1024 */
1025void drm_fb_helper_cfb_imageblit(struct fb_info *info,
1026 const struct fb_image *image)
1027{
1028 cfb_imageblit(info, image);
Noralf Trønneseaa434d2016-04-28 17:18:33 +02001029 drm_fb_helper_dirty(info, image->dx, image->dy,
1030 image->width, image->height);
Archit Taneja742547b2015-07-31 16:21:42 +05301031}
1032EXPORT_SYMBOL(drm_fb_helper_cfb_imageblit);
1033
Archit Tanejafdefa582015-07-31 16:21:43 +05301034/**
1035 * drm_fb_helper_set_suspend - wrapper around fb_set_suspend
1036 * @fb_helper: driver-allocated fbdev helper
Daniel Vetter28579f32016-08-23 17:27:27 +02001037 * @suspend: whether to suspend or resume
Archit Tanejafdefa582015-07-31 16:21:43 +05301038 *
Noralf Trønnescfe63422016-08-23 13:54:06 +02001039 * A wrapper around fb_set_suspend implemented by fbdev core.
1040 * Use drm_fb_helper_set_suspend_unlocked() if you don't need to take
1041 * the lock yourself
Archit Tanejafdefa582015-07-31 16:21:43 +05301042 */
Daniel Vetter28579f32016-08-23 17:27:27 +02001043void drm_fb_helper_set_suspend(struct drm_fb_helper *fb_helper, bool suspend)
Archit Tanejafdefa582015-07-31 16:21:43 +05301044{
1045 if (fb_helper && fb_helper->fbdev)
Daniel Vetter28579f32016-08-23 17:27:27 +02001046 fb_set_suspend(fb_helper->fbdev, suspend);
Archit Tanejafdefa582015-07-31 16:21:43 +05301047}
1048EXPORT_SYMBOL(drm_fb_helper_set_suspend);
1049
Noralf Trønnescfe63422016-08-23 13:54:06 +02001050/**
1051 * drm_fb_helper_set_suspend_unlocked - wrapper around fb_set_suspend that also
1052 * takes the console lock
1053 * @fb_helper: driver-allocated fbdev helper
Daniel Vetter28579f32016-08-23 17:27:27 +02001054 * @suspend: whether to suspend or resume
Noralf Trønnescfe63422016-08-23 13:54:06 +02001055 *
1056 * A wrapper around fb_set_suspend() that takes the console lock. If the lock
1057 * isn't available on resume, a worker is tasked with waiting for the lock
1058 * to become available. The console lock can be pretty contented on resume
1059 * due to all the printk activity.
1060 *
1061 * This function can be called multiple times with the same state since
1062 * &fb_info->state is checked to see if fbdev is running or not before locking.
1063 *
1064 * Use drm_fb_helper_set_suspend() if you need to take the lock yourself.
1065 */
1066void drm_fb_helper_set_suspend_unlocked(struct drm_fb_helper *fb_helper,
Daniel Vetter28579f32016-08-23 17:27:27 +02001067 bool suspend)
Noralf Trønnescfe63422016-08-23 13:54:06 +02001068{
1069 if (!fb_helper || !fb_helper->fbdev)
1070 return;
1071
1072 /* make sure there's no pending/ongoing resume */
1073 flush_work(&fb_helper->resume_work);
1074
1075 if (suspend) {
1076 if (fb_helper->fbdev->state != FBINFO_STATE_RUNNING)
1077 return;
1078
1079 console_lock();
1080
1081 } else {
1082 if (fb_helper->fbdev->state == FBINFO_STATE_RUNNING)
1083 return;
1084
1085 if (!console_trylock()) {
1086 schedule_work(&fb_helper->resume_work);
1087 return;
1088 }
1089 }
1090
1091 fb_set_suspend(fb_helper->fbdev, suspend);
1092 console_unlock();
1093}
1094EXPORT_SYMBOL(drm_fb_helper_set_suspend_unlocked);
1095
Dave Airliec850cb72009-10-23 18:49:03 +10001096static int setcolreg(struct drm_crtc *crtc, u16 red, u16 green,
Dave Airlieb8c00ac2009-10-06 13:54:01 +10001097 u16 blue, u16 regno, struct fb_info *info)
1098{
1099 struct drm_fb_helper *fb_helper = info->par;
1100 struct drm_framebuffer *fb = fb_helper->fb;
Dave Airlieb8c00ac2009-10-06 13:54:01 +10001101
Dave Airliec850cb72009-10-23 18:49:03 +10001102 if (info->fix.visual == FB_VISUAL_TRUECOLOR) {
1103 u32 *palette;
1104 u32 value;
1105 /* place color in psuedopalette */
1106 if (regno > 16)
1107 return -EINVAL;
1108 palette = (u32 *)info->pseudo_palette;
1109 red >>= (16 - info->var.red.length);
1110 green >>= (16 - info->var.green.length);
1111 blue >>= (16 - info->var.blue.length);
1112 value = (red << info->var.red.offset) |
1113 (green << info->var.green.offset) |
1114 (blue << info->var.blue.offset);
Rob Clark9da12b6a2011-02-16 02:45:51 +00001115 if (info->var.transp.length > 0) {
1116 u32 mask = (1 << info->var.transp.length) - 1;
1117 mask <<= info->var.transp.offset;
1118 value |= mask;
1119 }
Dave Airliec850cb72009-10-23 18:49:03 +10001120 palette[regno] = value;
1121 return 0;
1122 }
1123
Ville Syrjälä04c0c562013-05-27 20:19:57 +03001124 /*
1125 * The driver really shouldn't advertise pseudo/directcolor
1126 * visuals if it can't deal with the palette.
1127 */
1128 if (WARN_ON(!fb_helper->funcs->gamma_set ||
1129 !fb_helper->funcs->gamma_get))
1130 return -EINVAL;
1131
Daniel Vetterfef14802016-03-30 11:51:17 +02001132 WARN_ON(fb->bits_per_pixel != 8);
Dave Airlieb8c00ac2009-10-06 13:54:01 +10001133
Daniel Vetterfef14802016-03-30 11:51:17 +02001134 fb_helper->funcs->gamma_set(crtc, red, green, blue, regno);
Dave Airlieb8c00ac2009-10-06 13:54:01 +10001135
Dave Airliec850cb72009-10-23 18:49:03 +10001136 return 0;
Dave Airlieb8c00ac2009-10-06 13:54:01 +10001137}
1138
Daniel Vetter207fd322013-01-20 22:13:14 +01001139/**
1140 * drm_fb_helper_setcmap - implementation for ->fb_setcmap
1141 * @cmap: cmap to set
1142 * @info: fbdev registered by the helper
1143 */
Dave Airlie068143d2009-10-05 09:58:02 +10001144int drm_fb_helper_setcmap(struct fb_cmap *cmap, struct fb_info *info)
1145{
1146 struct drm_fb_helper *fb_helper = info->par;
Ville Syrjälä8391a3d2013-05-27 20:19:56 +03001147 struct drm_device *dev = fb_helper->dev;
Jani Nikulabe26a662015-03-11 11:51:06 +02001148 const struct drm_crtc_helper_funcs *crtc_funcs;
Dave Airlie068143d2009-10-05 09:58:02 +10001149 u16 *red, *green, *blue, *transp;
1150 struct drm_crtc *crtc;
roel062ac622011-03-07 18:00:34 +01001151 int i, j, rc = 0;
Dave Airlie068143d2009-10-05 09:58:02 +10001152 int start;
1153
Daniel Vetterc50bfd02015-07-28 13:18:40 +02001154 if (oops_in_progress)
Rui Wang9aa609e2014-12-15 11:28:26 -08001155 return -EBUSY;
Daniel Vetterc50bfd02015-07-28 13:18:40 +02001156
1157 drm_modeset_lock_all(dev);
Ville Syrjälä8391a3d2013-05-27 20:19:56 +03001158 if (!drm_fb_helper_is_bound(fb_helper)) {
1159 drm_modeset_unlock_all(dev);
1160 return -EBUSY;
1161 }
1162
Dave Airlie8be48d92010-03-30 05:34:14 +00001163 for (i = 0; i < fb_helper->crtc_count; i++) {
1164 crtc = fb_helper->crtc_info[i].mode_set.crtc;
1165 crtc_funcs = crtc->helper_private;
Dave Airlie068143d2009-10-05 09:58:02 +10001166
1167 red = cmap->red;
1168 green = cmap->green;
1169 blue = cmap->blue;
1170 transp = cmap->transp;
1171 start = cmap->start;
1172
roel062ac622011-03-07 18:00:34 +01001173 for (j = 0; j < cmap->len; j++) {
Dave Airlie068143d2009-10-05 09:58:02 +10001174 u16 hred, hgreen, hblue, htransp = 0xffff;
1175
1176 hred = *red++;
1177 hgreen = *green++;
1178 hblue = *blue++;
1179
1180 if (transp)
1181 htransp = *transp++;
1182
Dave Airliec850cb72009-10-23 18:49:03 +10001183 rc = setcolreg(crtc, hred, hgreen, hblue, start++, info);
1184 if (rc)
Ville Syrjälä8391a3d2013-05-27 20:19:56 +03001185 goto out;
Dave Airlie068143d2009-10-05 09:58:02 +10001186 }
Ville Syrjälä04c0c562013-05-27 20:19:57 +03001187 if (crtc_funcs->load_lut)
1188 crtc_funcs->load_lut(crtc);
Dave Airlie068143d2009-10-05 09:58:02 +10001189 }
Ville Syrjälä8391a3d2013-05-27 20:19:56 +03001190 out:
1191 drm_modeset_unlock_all(dev);
Dave Airlie068143d2009-10-05 09:58:02 +10001192 return rc;
1193}
1194EXPORT_SYMBOL(drm_fb_helper_setcmap);
1195
Daniel Vetter207fd322013-01-20 22:13:14 +01001196/**
1197 * drm_fb_helper_check_var - implementation for ->fb_check_var
1198 * @var: screeninfo to check
1199 * @info: fbdev registered by the helper
1200 */
Dave Airlie785b93e2009-08-28 15:46:53 +10001201int drm_fb_helper_check_var(struct fb_var_screeninfo *var,
1202 struct fb_info *info)
1203{
1204 struct drm_fb_helper *fb_helper = info->par;
1205 struct drm_framebuffer *fb = fb_helper->fb;
1206 int depth;
1207
Jason Wesself90ebd92010-08-05 09:22:32 -05001208 if (var->pixclock != 0 || in_dbg_master())
Dave Airlie785b93e2009-08-28 15:46:53 +10001209 return -EINVAL;
1210
Stefan Agner865afb12016-10-11 16:15:04 -07001211 /*
1212 * Changes struct fb_var_screeninfo are currently not pushed back
1213 * to KMS, hence fail if different settings are requested.
1214 */
1215 if (var->bits_per_pixel != fb->bits_per_pixel ||
1216 var->xres != fb->width || var->yres != fb->height ||
1217 var->xres_virtual != fb->width || var->yres_virtual != fb->height) {
1218 DRM_DEBUG("fb userspace requested width/height/bpp different than current fb "
Chris Wilson62fb3762012-03-26 21:15:53 +01001219 "request %dx%d-%d (virtual %dx%d) > %dx%d-%d\n",
1220 var->xres, var->yres, var->bits_per_pixel,
1221 var->xres_virtual, var->yres_virtual,
Dave Airlie509c7d82010-01-08 09:27:08 +10001222 fb->width, fb->height, fb->bits_per_pixel);
Dave Airlie785b93e2009-08-28 15:46:53 +10001223 return -EINVAL;
1224 }
1225
1226 switch (var->bits_per_pixel) {
1227 case 16:
1228 depth = (var->green.length == 6) ? 16 : 15;
1229 break;
1230 case 32:
1231 depth = (var->transp.length > 0) ? 32 : 24;
1232 break;
1233 default:
1234 depth = var->bits_per_pixel;
1235 break;
1236 }
1237
1238 switch (depth) {
1239 case 8:
1240 var->red.offset = 0;
1241 var->green.offset = 0;
1242 var->blue.offset = 0;
1243 var->red.length = 8;
1244 var->green.length = 8;
1245 var->blue.length = 8;
1246 var->transp.length = 0;
1247 var->transp.offset = 0;
1248 break;
1249 case 15:
1250 var->red.offset = 10;
1251 var->green.offset = 5;
1252 var->blue.offset = 0;
1253 var->red.length = 5;
1254 var->green.length = 5;
1255 var->blue.length = 5;
1256 var->transp.length = 1;
1257 var->transp.offset = 15;
1258 break;
1259 case 16:
1260 var->red.offset = 11;
1261 var->green.offset = 5;
1262 var->blue.offset = 0;
1263 var->red.length = 5;
1264 var->green.length = 6;
1265 var->blue.length = 5;
1266 var->transp.length = 0;
1267 var->transp.offset = 0;
1268 break;
1269 case 24:
1270 var->red.offset = 16;
1271 var->green.offset = 8;
1272 var->blue.offset = 0;
1273 var->red.length = 8;
1274 var->green.length = 8;
1275 var->blue.length = 8;
1276 var->transp.length = 0;
1277 var->transp.offset = 0;
1278 break;
1279 case 32:
1280 var->red.offset = 16;
1281 var->green.offset = 8;
1282 var->blue.offset = 0;
1283 var->red.length = 8;
1284 var->green.length = 8;
1285 var->blue.length = 8;
1286 var->transp.length = 8;
1287 var->transp.offset = 24;
1288 break;
1289 default:
1290 return -EINVAL;
1291 }
1292 return 0;
1293}
1294EXPORT_SYMBOL(drm_fb_helper_check_var);
1295
Daniel Vetter207fd322013-01-20 22:13:14 +01001296/**
1297 * drm_fb_helper_set_par - implementation for ->fb_set_par
1298 * @info: fbdev registered by the helper
1299 *
1300 * This will let fbcon do the mode init and is called at initialization time by
1301 * the fbdev core when registering the driver, and later on through the hotplug
1302 * callback.
1303 */
Dave Airlie785b93e2009-08-28 15:46:53 +10001304int drm_fb_helper_set_par(struct fb_info *info)
1305{
1306 struct drm_fb_helper *fb_helper = info->par;
Dave Airlie785b93e2009-08-28 15:46:53 +10001307 struct fb_var_screeninfo *var = &info->var;
Dave Airlie785b93e2009-08-28 15:46:53 +10001308
Daniel Vetterc50bfd02015-07-28 13:18:40 +02001309 if (oops_in_progress)
1310 return -EBUSY;
1311
Clemens Ladisch5349ef32009-11-04 09:42:52 +01001312 if (var->pixclock != 0) {
Pavel Roskin172e91f2010-02-11 14:31:32 +10001313 DRM_ERROR("PIXEL CLOCK SET\n");
Dave Airlie785b93e2009-08-28 15:46:53 +10001314 return -EINVAL;
1315 }
1316
Rob Clark5ea1f752014-05-30 12:29:48 -04001317 drm_fb_helper_restore_fbdev_mode_unlocked(fb_helper);
Dave Airlie4abe3522010-03-30 05:34:18 +00001318
Dave Airlie785b93e2009-08-28 15:46:53 +10001319 return 0;
1320}
1321EXPORT_SYMBOL(drm_fb_helper_set_par);
1322
Rob Clark1edf0262015-08-25 15:35:59 -04001323static int pan_display_atomic(struct fb_var_screeninfo *var,
Daniel Vettera0fb6ad2015-10-16 19:11:30 +02001324 struct fb_info *info)
Rob Clark1edf0262015-08-25 15:35:59 -04001325{
1326 struct drm_fb_helper *fb_helper = info->par;
1327 struct drm_device *dev = fb_helper->dev;
1328 struct drm_atomic_state *state;
Maarten Lankhorst07d3bad2015-11-11 11:29:11 +01001329 struct drm_plane *plane;
Rob Clark1edf0262015-08-25 15:35:59 -04001330 int i, ret;
Maarten Lankhorst07d3bad2015-11-11 11:29:11 +01001331 unsigned plane_mask;
Rob Clark1edf0262015-08-25 15:35:59 -04001332
1333 state = drm_atomic_state_alloc(dev);
1334 if (!state)
1335 return -ENOMEM;
1336
1337 state->acquire_ctx = dev->mode_config.acquire_ctx;
1338retry:
Maarten Lankhorst07d3bad2015-11-11 11:29:11 +01001339 plane_mask = 0;
Rob Clark1edf0262015-08-25 15:35:59 -04001340 for(i = 0; i < fb_helper->crtc_count; i++) {
1341 struct drm_mode_set *mode_set;
1342
1343 mode_set = &fb_helper->crtc_info[i].mode_set;
1344
1345 mode_set->x = var->xoffset;
1346 mode_set->y = var->yoffset;
1347
1348 ret = __drm_atomic_helper_set_config(mode_set, state);
1349 if (ret != 0)
1350 goto fail;
Maarten Lankhorst07d3bad2015-11-11 11:29:11 +01001351
1352 plane = mode_set->crtc->primary;
Matt Roper7118fd92015-12-18 17:27:01 -08001353 plane_mask |= (1 << drm_plane_index(plane));
Maarten Lankhorst07d3bad2015-11-11 11:29:11 +01001354 plane->old_fb = plane->fb;
Rob Clark1edf0262015-08-25 15:35:59 -04001355 }
1356
1357 ret = drm_atomic_commit(state);
1358 if (ret != 0)
1359 goto fail;
1360
1361 info->var.xoffset = var->xoffset;
1362 info->var.yoffset = var->yoffset;
1363
Rob Clark1edf0262015-08-25 15:35:59 -04001364fail:
Maarten Lankhorst07d3bad2015-11-11 11:29:11 +01001365 drm_atomic_clean_old_fb(dev, plane_mask, ret);
Daniel Vettera0fb6ad2015-10-16 19:11:30 +02001366
Rob Clark1edf0262015-08-25 15:35:59 -04001367 if (ret == -EDEADLK)
1368 goto backoff;
1369
Chris Wilson08536952016-10-14 13:18:18 +01001370 drm_atomic_state_put(state);
Rob Clark1edf0262015-08-25 15:35:59 -04001371 return ret;
1372
1373backoff:
1374 drm_atomic_state_clear(state);
1375 drm_atomic_legacy_backoff(state);
1376
1377 goto retry;
1378}
1379
Daniel Vetter207fd322013-01-20 22:13:14 +01001380/**
1381 * drm_fb_helper_pan_display - implementation for ->fb_pan_display
1382 * @var: updated screen information
1383 * @info: fbdev registered by the helper
1384 */
Dave Airlie785b93e2009-08-28 15:46:53 +10001385int drm_fb_helper_pan_display(struct fb_var_screeninfo *var,
1386 struct fb_info *info)
1387{
1388 struct drm_fb_helper *fb_helper = info->par;
1389 struct drm_device *dev = fb_helper->dev;
1390 struct drm_mode_set *modeset;
Dave Airlie785b93e2009-08-28 15:46:53 +10001391 int ret = 0;
1392 int i;
1393
Daniel Vetterc50bfd02015-07-28 13:18:40 +02001394 if (oops_in_progress)
Rui Wang9aa609e2014-12-15 11:28:26 -08001395 return -EBUSY;
Daniel Vetterc50bfd02015-07-28 13:18:40 +02001396
1397 drm_modeset_lock_all(dev);
Daniel Vetter20c60c32012-12-17 12:13:23 +01001398 if (!drm_fb_helper_is_bound(fb_helper)) {
1399 drm_modeset_unlock_all(dev);
1400 return -EBUSY;
1401 }
1402
Daniel Vetterd3a46182016-06-08 14:19:15 +02001403 if (dev->mode_config.funcs->atomic_commit) {
Rob Clark1edf0262015-08-25 15:35:59 -04001404 ret = pan_display_atomic(var, info);
1405 goto unlock;
1406 }
1407
Dave Airlie8be48d92010-03-30 05:34:14 +00001408 for (i = 0; i < fb_helper->crtc_count; i++) {
Dave Airlie785b93e2009-08-28 15:46:53 +10001409 modeset = &fb_helper->crtc_info[i].mode_set;
1410
1411 modeset->x = var->xoffset;
1412 modeset->y = var->yoffset;
1413
1414 if (modeset->num_connectors) {
Daniel Vetter2d13b672012-12-11 13:47:23 +01001415 ret = drm_mode_set_config_internal(modeset);
Dave Airlie785b93e2009-08-28 15:46:53 +10001416 if (!ret) {
1417 info->var.xoffset = var->xoffset;
1418 info->var.yoffset = var->yoffset;
1419 }
1420 }
1421 }
Rob Clark1edf0262015-08-25 15:35:59 -04001422unlock:
Daniel Vetter84849902012-12-02 00:28:11 +01001423 drm_modeset_unlock_all(dev);
Dave Airlie785b93e2009-08-28 15:46:53 +10001424 return ret;
1425}
1426EXPORT_SYMBOL(drm_fb_helper_pan_display);
1427
Daniel Vetter8acf6582013-01-21 23:38:37 +01001428/*
Daniel Vetter207fd322013-01-20 22:13:14 +01001429 * Allocates the backing storage and sets up the fbdev info structure through
1430 * the ->fb_probe callback and then registers the fbdev and sets up the panic
1431 * notifier.
Daniel Vetter8acf6582013-01-21 23:38:37 +01001432 */
Daniel Vetterde1ace52013-01-20 21:50:49 +01001433static int drm_fb_helper_single_fb_probe(struct drm_fb_helper *fb_helper,
1434 int preferred_bpp)
Dave Airlie785b93e2009-08-28 15:46:53 +10001435{
Daniel Vetter8acf6582013-01-21 23:38:37 +01001436 int ret = 0;
Dave Airlie785b93e2009-08-28 15:46:53 +10001437 int crtc_count = 0;
Dave Airlie4abe3522010-03-30 05:34:18 +00001438 int i;
Dave Airlie785b93e2009-08-28 15:46:53 +10001439 struct fb_info *info;
Dave Airlie38651672010-03-30 05:34:13 +00001440 struct drm_fb_helper_surface_size sizes;
Dave Airlie8be48d92010-03-30 05:34:14 +00001441 int gamma_size = 0;
Dave Airlie38651672010-03-30 05:34:13 +00001442
1443 memset(&sizes, 0, sizeof(struct drm_fb_helper_surface_size));
1444 sizes.surface_depth = 24;
1445 sizes.surface_bpp = 32;
1446 sizes.fb_width = (unsigned)-1;
1447 sizes.fb_height = (unsigned)-1;
Dave Airlie785b93e2009-08-28 15:46:53 +10001448
Dave Airlieb8c00ac2009-10-06 13:54:01 +10001449 /* if driver picks 8 or 16 by default use that
1450 for both depth/bpp */
Sachin Kamat96081cd2012-11-15 03:43:30 +00001451 if (preferred_bpp != sizes.surface_bpp)
Dave Airlie38651672010-03-30 05:34:13 +00001452 sizes.surface_depth = sizes.surface_bpp = preferred_bpp;
Sachin Kamat96081cd2012-11-15 03:43:30 +00001453
Dave Airlie785b93e2009-08-28 15:46:53 +10001454 /* first up get a count of crtcs now in use and new min/maxes width/heights */
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001455 for (i = 0; i < fb_helper->connector_count; i++) {
1456 struct drm_fb_helper_connector *fb_helper_conn = fb_helper->connector_info[i];
Chris Wilson1794d252011-04-17 07:43:32 +01001457 struct drm_cmdline_mode *cmdline_mode;
Dave Airlie8ef86782009-09-26 06:39:00 +10001458
Chris Wilsoneaf99c72014-08-06 10:08:32 +02001459 cmdline_mode = &fb_helper_conn->connector->cmdline_mode;
Dave Airlied50ba252009-09-23 14:44:08 +10001460
1461 if (cmdline_mode->bpp_specified) {
1462 switch (cmdline_mode->bpp) {
1463 case 8:
Dave Airlie38651672010-03-30 05:34:13 +00001464 sizes.surface_depth = sizes.surface_bpp = 8;
Dave Airlied50ba252009-09-23 14:44:08 +10001465 break;
1466 case 15:
Dave Airlie38651672010-03-30 05:34:13 +00001467 sizes.surface_depth = 15;
1468 sizes.surface_bpp = 16;
Dave Airlied50ba252009-09-23 14:44:08 +10001469 break;
1470 case 16:
Dave Airlie38651672010-03-30 05:34:13 +00001471 sizes.surface_depth = sizes.surface_bpp = 16;
Dave Airlied50ba252009-09-23 14:44:08 +10001472 break;
1473 case 24:
Dave Airlie38651672010-03-30 05:34:13 +00001474 sizes.surface_depth = sizes.surface_bpp = 24;
Dave Airlied50ba252009-09-23 14:44:08 +10001475 break;
1476 case 32:
Dave Airlie38651672010-03-30 05:34:13 +00001477 sizes.surface_depth = 24;
1478 sizes.surface_bpp = 32;
Dave Airlied50ba252009-09-23 14:44:08 +10001479 break;
1480 }
1481 break;
1482 }
1483 }
1484
Dave Airlie8be48d92010-03-30 05:34:14 +00001485 crtc_count = 0;
1486 for (i = 0; i < fb_helper->crtc_count; i++) {
1487 struct drm_display_mode *desired_mode;
Rob Clark0e3704c2015-03-11 10:23:14 -04001488 struct drm_mode_set *mode_set;
1489 int x, y, j;
1490 /* in case of tile group, are we the last tile vert or horiz?
1491 * If no tile group you are always the last one both vertically
1492 * and horizontally
1493 */
1494 bool lastv = true, lasth = true;
Rob Clark675c8322015-03-11 10:23:13 -04001495
Dave Airlie8be48d92010-03-30 05:34:14 +00001496 desired_mode = fb_helper->crtc_info[i].desired_mode;
Rob Clark0e3704c2015-03-11 10:23:14 -04001497 mode_set = &fb_helper->crtc_info[i].mode_set;
Rob Clark675c8322015-03-11 10:23:13 -04001498
1499 if (!desired_mode)
1500 continue;
1501
1502 crtc_count++;
1503
Dave Airlieb0ee9e72014-10-20 16:31:53 +10001504 x = fb_helper->crtc_info[i].x;
1505 y = fb_helper->crtc_info[i].y;
Rob Clark675c8322015-03-11 10:23:13 -04001506
1507 if (gamma_size == 0)
1508 gamma_size = fb_helper->crtc_info[i].mode_set.crtc->gamma_size;
1509
1510 sizes.surface_width = max_t(u32, desired_mode->hdisplay + x, sizes.surface_width);
1511 sizes.surface_height = max_t(u32, desired_mode->vdisplay + y, sizes.surface_height);
Rob Clark0e3704c2015-03-11 10:23:14 -04001512
1513 for (j = 0; j < mode_set->num_connectors; j++) {
1514 struct drm_connector *connector = mode_set->connectors[j];
1515 if (connector->has_tile) {
1516 lasth = (connector->tile_h_loc == (connector->num_h_tile - 1));
1517 lastv = (connector->tile_v_loc == (connector->num_v_tile - 1));
1518 /* cloning to multiple tiles is just crazy-talk, so: */
1519 break;
1520 }
1521 }
1522
1523 if (lasth)
1524 sizes.fb_width = min_t(u32, desired_mode->hdisplay + x, sizes.fb_width);
1525 if (lastv)
1526 sizes.fb_height = min_t(u32, desired_mode->vdisplay + y, sizes.fb_height);
Dave Airlie785b93e2009-08-28 15:46:53 +10001527 }
1528
Dave Airlie38651672010-03-30 05:34:13 +00001529 if (crtc_count == 0 || sizes.fb_width == -1 || sizes.fb_height == -1) {
Dave Airlie785b93e2009-08-28 15:46:53 +10001530 /* hmm everyone went away - assume VGA cable just fell out
1531 and will come back later. */
Dave Airlieeb1f8e42010-05-07 06:42:51 +00001532 DRM_INFO("Cannot find any crtc or sizes - going 1024x768\n");
Dave Airlie19b4b442010-03-30 05:34:16 +00001533 sizes.fb_width = sizes.surface_width = 1024;
1534 sizes.fb_height = sizes.surface_height = 768;
Dave Airlie785b93e2009-08-28 15:46:53 +10001535 }
1536
Dave Airlie38651672010-03-30 05:34:13 +00001537 /* push down into drivers */
Daniel Vetter8acf6582013-01-21 23:38:37 +01001538 ret = (*fb_helper->funcs->fb_probe)(fb_helper, &sizes);
1539 if (ret < 0)
1540 return ret;
Dave Airlie785b93e2009-08-28 15:46:53 +10001541
Dave Airlie38651672010-03-30 05:34:13 +00001542 info = fb_helper->fbdev;
Dave Airlie785b93e2009-08-28 15:46:53 +10001543
Daniel Vetter7e53f3a2013-01-21 10:52:17 +01001544 /*
1545 * Set the fb pointer - usually drm_setup_crtcs does this for hotplug
1546 * events, but at init time drm_setup_crtcs needs to be called before
1547 * the fb is allocated (since we need to figure out the desired size of
1548 * the fb before we can allocate it ...). Hence we need to fix things up
1549 * here again.
1550 */
Sachin Kamat96081cd2012-11-15 03:43:30 +00001551 for (i = 0; i < fb_helper->crtc_count; i++)
Daniel Vetter7e53f3a2013-01-21 10:52:17 +01001552 if (fb_helper->crtc_info[i].mode_set.num_connectors)
1553 fb_helper->crtc_info[i].mode_set.fb = fb_helper->fb;
1554
Dave Airlie785b93e2009-08-28 15:46:53 +10001555
Daniel Vetter8acf6582013-01-21 23:38:37 +01001556 info->var.pixclock = 0;
1557 if (register_framebuffer(info) < 0)
1558 return -EINVAL;
Dave Airlie38651672010-03-30 05:34:13 +00001559
Daniel Vetter8acf6582013-01-21 23:38:37 +01001560 dev_info(fb_helper->dev->dev, "fb%d: %s frame buffer device\n",
1561 info->node, info->fix.id);
Dave Airlie785b93e2009-08-28 15:46:53 +10001562
Dave Airlie785b93e2009-08-28 15:46:53 +10001563 if (list_empty(&kernel_fb_helper_list)) {
Dave Airlie785b93e2009-08-28 15:46:53 +10001564 register_sysrq_key('v', &sysrq_drm_fb_helper_restore_op);
1565 }
Daniel Vetter8acf6582013-01-21 23:38:37 +01001566
1567 list_add(&fb_helper->kernel_fb_list, &kernel_fb_helper_list);
Dave Airlie38651672010-03-30 05:34:13 +00001568
Dave Airlie785b93e2009-08-28 15:46:53 +10001569 return 0;
1570}
Dave Airlie785b93e2009-08-28 15:46:53 +10001571
Daniel Vetter207fd322013-01-20 22:13:14 +01001572/**
1573 * drm_fb_helper_fill_fix - initializes fixed fbdev information
1574 * @info: fbdev registered by the helper
1575 * @pitch: desired pitch
1576 * @depth: desired depth
1577 *
1578 * Helper to fill in the fixed fbdev information useful for a non-accelerated
1579 * fbdev emulations. Drivers which support acceleration methods which impose
1580 * additional constraints need to set up their own limits.
1581 *
1582 * Drivers should call this (or their equivalent setup code) from their
1583 * ->fb_probe callback.
1584 */
Dave Airlie3632ef82011-01-15 09:27:00 +10001585void drm_fb_helper_fill_fix(struct fb_info *info, uint32_t pitch,
1586 uint32_t depth)
1587{
1588 info->fix.type = FB_TYPE_PACKED_PIXELS;
1589 info->fix.visual = depth == 8 ? FB_VISUAL_PSEUDOCOLOR :
1590 FB_VISUAL_TRUECOLOR;
1591 info->fix.mmio_start = 0;
1592 info->fix.mmio_len = 0;
1593 info->fix.type_aux = 0;
1594 info->fix.xpanstep = 1; /* doing it in hw */
1595 info->fix.ypanstep = 1; /* doing it in hw */
1596 info->fix.ywrapstep = 0;
1597 info->fix.accel = FB_ACCEL_NONE;
Dave Airlie3632ef82011-01-15 09:27:00 +10001598
1599 info->fix.line_length = pitch;
1600 return;
1601}
1602EXPORT_SYMBOL(drm_fb_helper_fill_fix);
1603
Daniel Vetter207fd322013-01-20 22:13:14 +01001604/**
1605 * drm_fb_helper_fill_var - initalizes variable fbdev information
1606 * @info: fbdev instance to set up
1607 * @fb_helper: fb helper instance to use as template
1608 * @fb_width: desired fb width
1609 * @fb_height: desired fb height
1610 *
1611 * Sets up the variable fbdev metainformation from the given fb helper instance
1612 * and the drm framebuffer allocated in fb_helper->fb.
1613 *
1614 * Drivers should call this (or their equivalent setup code) from their
1615 * ->fb_probe callback after having allocated the fbdev backing
1616 * storage framebuffer.
1617 */
Dave Airlie38651672010-03-30 05:34:13 +00001618void drm_fb_helper_fill_var(struct fb_info *info, struct drm_fb_helper *fb_helper,
Dave Airlie785b93e2009-08-28 15:46:53 +10001619 uint32_t fb_width, uint32_t fb_height)
1620{
Dave Airlie38651672010-03-30 05:34:13 +00001621 struct drm_framebuffer *fb = fb_helper->fb;
1622 info->pseudo_palette = fb_helper->pseudo_palette;
Dave Airlie785b93e2009-08-28 15:46:53 +10001623 info->var.xres_virtual = fb->width;
1624 info->var.yres_virtual = fb->height;
1625 info->var.bits_per_pixel = fb->bits_per_pixel;
James Simmons57084d02010-12-20 19:10:39 +00001626 info->var.accel_flags = FB_ACCELF_TEXT;
Dave Airlie785b93e2009-08-28 15:46:53 +10001627 info->var.xoffset = 0;
1628 info->var.yoffset = 0;
1629 info->var.activate = FB_ACTIVATE_NOW;
1630 info->var.height = -1;
1631 info->var.width = -1;
1632
1633 switch (fb->depth) {
1634 case 8:
1635 info->var.red.offset = 0;
1636 info->var.green.offset = 0;
1637 info->var.blue.offset = 0;
1638 info->var.red.length = 8; /* 8bit DAC */
1639 info->var.green.length = 8;
1640 info->var.blue.length = 8;
1641 info->var.transp.offset = 0;
1642 info->var.transp.length = 0;
1643 break;
1644 case 15:
1645 info->var.red.offset = 10;
1646 info->var.green.offset = 5;
1647 info->var.blue.offset = 0;
1648 info->var.red.length = 5;
1649 info->var.green.length = 5;
1650 info->var.blue.length = 5;
1651 info->var.transp.offset = 15;
1652 info->var.transp.length = 1;
1653 break;
1654 case 16:
1655 info->var.red.offset = 11;
1656 info->var.green.offset = 5;
1657 info->var.blue.offset = 0;
1658 info->var.red.length = 5;
1659 info->var.green.length = 6;
1660 info->var.blue.length = 5;
1661 info->var.transp.offset = 0;
1662 break;
1663 case 24:
1664 info->var.red.offset = 16;
1665 info->var.green.offset = 8;
1666 info->var.blue.offset = 0;
1667 info->var.red.length = 8;
1668 info->var.green.length = 8;
1669 info->var.blue.length = 8;
1670 info->var.transp.offset = 0;
1671 info->var.transp.length = 0;
1672 break;
1673 case 32:
1674 info->var.red.offset = 16;
1675 info->var.green.offset = 8;
1676 info->var.blue.offset = 0;
1677 info->var.red.length = 8;
1678 info->var.green.length = 8;
1679 info->var.blue.length = 8;
1680 info->var.transp.offset = 24;
1681 info->var.transp.length = 8;
1682 break;
1683 default:
1684 break;
1685 }
1686
1687 info->var.xres = fb_width;
1688 info->var.yres = fb_height;
1689}
1690EXPORT_SYMBOL(drm_fb_helper_fill_var);
Dave Airlie38651672010-03-30 05:34:13 +00001691
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001692static int drm_fb_helper_probe_connector_modes(struct drm_fb_helper *fb_helper,
1693 uint32_t maxX,
1694 uint32_t maxY)
Dave Airlie38651672010-03-30 05:34:13 +00001695{
1696 struct drm_connector *connector;
1697 int count = 0;
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001698 int i;
Dave Airlie38651672010-03-30 05:34:13 +00001699
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001700 for (i = 0; i < fb_helper->connector_count; i++) {
1701 connector = fb_helper->connector_info[i]->connector;
Dave Airlie38651672010-03-30 05:34:13 +00001702 count += connector->funcs->fill_modes(connector, maxX, maxY);
1703 }
1704
1705 return count;
1706}
1707
Jesse Barnes2f1046f2014-02-12 12:26:24 -08001708struct drm_display_mode *drm_has_preferred_mode(struct drm_fb_helper_connector *fb_connector, int width, int height)
Dave Airlie38651672010-03-30 05:34:13 +00001709{
1710 struct drm_display_mode *mode;
1711
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001712 list_for_each_entry(mode, &fb_connector->connector->modes, head) {
Daniel Vetter9d3de132014-01-23 16:27:56 +01001713 if (mode->hdisplay > width ||
1714 mode->vdisplay > height)
Dave Airlie38651672010-03-30 05:34:13 +00001715 continue;
1716 if (mode->type & DRM_MODE_TYPE_PREFERRED)
1717 return mode;
1718 }
1719 return NULL;
1720}
Jesse Barnes2f1046f2014-02-12 12:26:24 -08001721EXPORT_SYMBOL(drm_has_preferred_mode);
Dave Airlie38651672010-03-30 05:34:13 +00001722
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001723static bool drm_has_cmdline_mode(struct drm_fb_helper_connector *fb_connector)
Dave Airlie38651672010-03-30 05:34:13 +00001724{
Chris Wilsoneaf99c72014-08-06 10:08:32 +02001725 return fb_connector->connector->cmdline_mode.specified;
Dave Airlie38651672010-03-30 05:34:13 +00001726}
1727
Jesse Barnes2f1046f2014-02-12 12:26:24 -08001728struct drm_display_mode *drm_pick_cmdline_mode(struct drm_fb_helper_connector *fb_helper_conn,
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001729 int width, int height)
Dave Airlie38651672010-03-30 05:34:13 +00001730{
Chris Wilson1794d252011-04-17 07:43:32 +01001731 struct drm_cmdline_mode *cmdline_mode;
Daniel Stonef3af5c72015-03-19 04:33:01 +00001732 struct drm_display_mode *mode;
Takashi Iwaic683f422014-03-19 14:53:13 +01001733 bool prefer_non_interlace;
Dave Airlie38651672010-03-30 05:34:13 +00001734
Chris Wilsoneaf99c72014-08-06 10:08:32 +02001735 cmdline_mode = &fb_helper_conn->connector->cmdline_mode;
Dave Airlie38651672010-03-30 05:34:13 +00001736 if (cmdline_mode->specified == false)
Daniel Stonef3af5c72015-03-19 04:33:01 +00001737 return NULL;
Dave Airlie38651672010-03-30 05:34:13 +00001738
1739 /* attempt to find a matching mode in the list of modes
1740 * we have gotten so far, if not add a CVT mode that conforms
1741 */
1742 if (cmdline_mode->rb || cmdline_mode->margins)
1743 goto create_mode;
1744
Takashi Iwaic683f422014-03-19 14:53:13 +01001745 prefer_non_interlace = !cmdline_mode->interlace;
Daniel Stonef3af5c72015-03-19 04:33:01 +00001746again:
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001747 list_for_each_entry(mode, &fb_helper_conn->connector->modes, head) {
Dave Airlie38651672010-03-30 05:34:13 +00001748 /* check width/height */
1749 if (mode->hdisplay != cmdline_mode->xres ||
1750 mode->vdisplay != cmdline_mode->yres)
1751 continue;
1752
1753 if (cmdline_mode->refresh_specified) {
1754 if (mode->vrefresh != cmdline_mode->refresh)
1755 continue;
1756 }
1757
1758 if (cmdline_mode->interlace) {
1759 if (!(mode->flags & DRM_MODE_FLAG_INTERLACE))
1760 continue;
Takashi Iwaic683f422014-03-19 14:53:13 +01001761 } else if (prefer_non_interlace) {
1762 if (mode->flags & DRM_MODE_FLAG_INTERLACE)
1763 continue;
Dave Airlie38651672010-03-30 05:34:13 +00001764 }
1765 return mode;
1766 }
1767
Takashi Iwaic683f422014-03-19 14:53:13 +01001768 if (prefer_non_interlace) {
1769 prefer_non_interlace = false;
1770 goto again;
1771 }
1772
Dave Airlie38651672010-03-30 05:34:13 +00001773create_mode:
Chris Wilson1794d252011-04-17 07:43:32 +01001774 mode = drm_mode_create_from_cmdline_mode(fb_helper_conn->connector->dev,
1775 cmdline_mode);
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001776 list_add(&mode->head, &fb_helper_conn->connector->modes);
Dave Airlie38651672010-03-30 05:34:13 +00001777 return mode;
1778}
Jesse Barnes2f1046f2014-02-12 12:26:24 -08001779EXPORT_SYMBOL(drm_pick_cmdline_mode);
Dave Airlie38651672010-03-30 05:34:13 +00001780
1781static bool drm_connector_enabled(struct drm_connector *connector, bool strict)
1782{
1783 bool enable;
1784
Sachin Kamat96081cd2012-11-15 03:43:30 +00001785 if (strict)
Dave Airlie38651672010-03-30 05:34:13 +00001786 enable = connector->status == connector_status_connected;
Sachin Kamat96081cd2012-11-15 03:43:30 +00001787 else
Dave Airlie38651672010-03-30 05:34:13 +00001788 enable = connector->status != connector_status_disconnected;
Sachin Kamat96081cd2012-11-15 03:43:30 +00001789
Dave Airlie38651672010-03-30 05:34:13 +00001790 return enable;
1791}
1792
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001793static void drm_enable_connectors(struct drm_fb_helper *fb_helper,
1794 bool *enabled)
Dave Airlie38651672010-03-30 05:34:13 +00001795{
1796 bool any_enabled = false;
1797 struct drm_connector *connector;
1798 int i = 0;
1799
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001800 for (i = 0; i < fb_helper->connector_count; i++) {
1801 connector = fb_helper->connector_info[i]->connector;
Dave Airlie38651672010-03-30 05:34:13 +00001802 enabled[i] = drm_connector_enabled(connector, true);
1803 DRM_DEBUG_KMS("connector %d enabled? %s\n", connector->base.id,
1804 enabled[i] ? "yes" : "no");
1805 any_enabled |= enabled[i];
Dave Airlie38651672010-03-30 05:34:13 +00001806 }
1807
1808 if (any_enabled)
1809 return;
1810
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001811 for (i = 0; i < fb_helper->connector_count; i++) {
1812 connector = fb_helper->connector_info[i]->connector;
Dave Airlie38651672010-03-30 05:34:13 +00001813 enabled[i] = drm_connector_enabled(connector, false);
Dave Airlie38651672010-03-30 05:34:13 +00001814 }
1815}
1816
Dave Airlie1d42bbc2010-05-07 05:02:30 +00001817static bool drm_target_cloned(struct drm_fb_helper *fb_helper,
1818 struct drm_display_mode **modes,
Dave Airlieb0ee9e72014-10-20 16:31:53 +10001819 struct drm_fb_offset *offsets,
Dave Airlie1d42bbc2010-05-07 05:02:30 +00001820 bool *enabled, int width, int height)
1821{
1822 int count, i, j;
1823 bool can_clone = false;
1824 struct drm_fb_helper_connector *fb_helper_conn;
1825 struct drm_display_mode *dmt_mode, *mode;
1826
1827 /* only contemplate cloning in the single crtc case */
1828 if (fb_helper->crtc_count > 1)
1829 return false;
1830
1831 count = 0;
1832 for (i = 0; i < fb_helper->connector_count; i++) {
1833 if (enabled[i])
1834 count++;
1835 }
1836
1837 /* only contemplate cloning if more than one connector is enabled */
1838 if (count <= 1)
1839 return false;
1840
1841 /* check the command line or if nothing common pick 1024x768 */
1842 can_clone = true;
1843 for (i = 0; i < fb_helper->connector_count; i++) {
1844 if (!enabled[i])
1845 continue;
1846 fb_helper_conn = fb_helper->connector_info[i];
1847 modes[i] = drm_pick_cmdline_mode(fb_helper_conn, width, height);
1848 if (!modes[i]) {
1849 can_clone = false;
1850 break;
1851 }
1852 for (j = 0; j < i; j++) {
1853 if (!enabled[j])
1854 continue;
1855 if (!drm_mode_equal(modes[j], modes[i]))
1856 can_clone = false;
1857 }
1858 }
1859
1860 if (can_clone) {
1861 DRM_DEBUG_KMS("can clone using command line\n");
1862 return true;
1863 }
1864
1865 /* try and find a 1024x768 mode on each connector */
1866 can_clone = true;
Adam Jacksonf6e252b2012-04-13 16:33:31 -04001867 dmt_mode = drm_mode_find_dmt(fb_helper->dev, 1024, 768, 60, false);
Dave Airlie1d42bbc2010-05-07 05:02:30 +00001868
1869 for (i = 0; i < fb_helper->connector_count; i++) {
1870
1871 if (!enabled[i])
1872 continue;
1873
1874 fb_helper_conn = fb_helper->connector_info[i];
1875 list_for_each_entry(mode, &fb_helper_conn->connector->modes, head) {
1876 if (drm_mode_equal(mode, dmt_mode))
1877 modes[i] = mode;
1878 }
1879 if (!modes[i])
1880 can_clone = false;
1881 }
1882
1883 if (can_clone) {
1884 DRM_DEBUG_KMS("can clone using 1024x768\n");
1885 return true;
1886 }
1887 DRM_INFO("kms: can't enable cloning when we probably wanted to.\n");
1888 return false;
1889}
1890
Dave Airlieb0ee9e72014-10-20 16:31:53 +10001891static int drm_get_tile_offsets(struct drm_fb_helper *fb_helper,
1892 struct drm_display_mode **modes,
1893 struct drm_fb_offset *offsets,
1894 int idx,
1895 int h_idx, int v_idx)
1896{
1897 struct drm_fb_helper_connector *fb_helper_conn;
1898 int i;
1899 int hoffset = 0, voffset = 0;
1900
1901 for (i = 0; i < fb_helper->connector_count; i++) {
1902 fb_helper_conn = fb_helper->connector_info[i];
1903 if (!fb_helper_conn->connector->has_tile)
1904 continue;
1905
1906 if (!modes[i] && (h_idx || v_idx)) {
1907 DRM_DEBUG_KMS("no modes for connector tiled %d %d\n", i,
1908 fb_helper_conn->connector->base.id);
1909 continue;
1910 }
1911 if (fb_helper_conn->connector->tile_h_loc < h_idx)
1912 hoffset += modes[i]->hdisplay;
1913
1914 if (fb_helper_conn->connector->tile_v_loc < v_idx)
1915 voffset += modes[i]->vdisplay;
1916 }
1917 offsets[idx].x = hoffset;
1918 offsets[idx].y = voffset;
1919 DRM_DEBUG_KMS("returned %d %d for %d %d\n", hoffset, voffset, h_idx, v_idx);
1920 return 0;
1921}
1922
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001923static bool drm_target_preferred(struct drm_fb_helper *fb_helper,
Dave Airlie38651672010-03-30 05:34:13 +00001924 struct drm_display_mode **modes,
Dave Airlieb0ee9e72014-10-20 16:31:53 +10001925 struct drm_fb_offset *offsets,
Dave Airlie38651672010-03-30 05:34:13 +00001926 bool *enabled, int width, int height)
1927{
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001928 struct drm_fb_helper_connector *fb_helper_conn;
1929 int i;
Dave Airlieb0ee9e72014-10-20 16:31:53 +10001930 uint64_t conn_configured = 0, mask;
1931 int tile_pass = 0;
1932 mask = (1 << fb_helper->connector_count) - 1;
1933retry:
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001934 for (i = 0; i < fb_helper->connector_count; i++) {
1935 fb_helper_conn = fb_helper->connector_info[i];
Dave Airlie38651672010-03-30 05:34:13 +00001936
Dave Airlieb0ee9e72014-10-20 16:31:53 +10001937 if (conn_configured & (1 << i))
Dave Airlie38651672010-03-30 05:34:13 +00001938 continue;
Dave Airlie38651672010-03-30 05:34:13 +00001939
Dave Airlieb0ee9e72014-10-20 16:31:53 +10001940 if (enabled[i] == false) {
1941 conn_configured |= (1 << i);
1942 continue;
1943 }
1944
1945 /* first pass over all the untiled connectors */
1946 if (tile_pass == 0 && fb_helper_conn->connector->has_tile)
1947 continue;
1948
1949 if (tile_pass == 1) {
1950 if (fb_helper_conn->connector->tile_h_loc != 0 ||
1951 fb_helper_conn->connector->tile_v_loc != 0)
1952 continue;
1953
1954 } else {
1955 if (fb_helper_conn->connector->tile_h_loc != tile_pass -1 &&
1956 fb_helper_conn->connector->tile_v_loc != tile_pass - 1)
1957 /* if this tile_pass doesn't cover any of the tiles - keep going */
1958 continue;
1959
1960 /* find the tile offsets for this pass - need
1961 to find all tiles left and above */
1962 drm_get_tile_offsets(fb_helper, modes, offsets,
1963 i, fb_helper_conn->connector->tile_h_loc, fb_helper_conn->connector->tile_v_loc);
1964 }
Dave Airlie38651672010-03-30 05:34:13 +00001965 DRM_DEBUG_KMS("looking for cmdline mode on connector %d\n",
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001966 fb_helper_conn->connector->base.id);
Dave Airlie38651672010-03-30 05:34:13 +00001967
1968 /* got for command line mode first */
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001969 modes[i] = drm_pick_cmdline_mode(fb_helper_conn, width, height);
Dave Airlie38651672010-03-30 05:34:13 +00001970 if (!modes[i]) {
Dave Airlieb0ee9e72014-10-20 16:31:53 +10001971 DRM_DEBUG_KMS("looking for preferred mode on connector %d %d\n",
1972 fb_helper_conn->connector->base.id, fb_helper_conn->connector->tile_group ? fb_helper_conn->connector->tile_group->id : 0);
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001973 modes[i] = drm_has_preferred_mode(fb_helper_conn, width, height);
Dave Airlie38651672010-03-30 05:34:13 +00001974 }
1975 /* No preferred modes, pick one off the list */
Dave Airlie0b4c0f32010-03-30 05:34:15 +00001976 if (!modes[i] && !list_empty(&fb_helper_conn->connector->modes)) {
1977 list_for_each_entry(modes[i], &fb_helper_conn->connector->modes, head)
Dave Airlie38651672010-03-30 05:34:13 +00001978 break;
1979 }
1980 DRM_DEBUG_KMS("found mode %s\n", modes[i] ? modes[i]->name :
1981 "none");
Dave Airlieb0ee9e72014-10-20 16:31:53 +10001982 conn_configured |= (1 << i);
1983 }
1984
1985 if ((conn_configured & mask) != mask) {
1986 tile_pass++;
1987 goto retry;
Dave Airlie38651672010-03-30 05:34:13 +00001988 }
1989 return true;
1990}
1991
Dave Airlie8be48d92010-03-30 05:34:14 +00001992static int drm_pick_crtcs(struct drm_fb_helper *fb_helper,
1993 struct drm_fb_helper_crtc **best_crtcs,
Dave Airlie38651672010-03-30 05:34:13 +00001994 struct drm_display_mode **modes,
1995 int n, int width, int height)
1996{
1997 int c, o;
1998 struct drm_connector *connector;
Jani Nikulabe26a662015-03-11 11:51:06 +02001999 const struct drm_connector_helper_funcs *connector_funcs;
Dave Airlie38651672010-03-30 05:34:13 +00002000 struct drm_encoder *encoder;
Dave Airlie38651672010-03-30 05:34:13 +00002001 int my_score, best_score, score;
Dave Airlie8be48d92010-03-30 05:34:14 +00002002 struct drm_fb_helper_crtc **crtcs, *crtc;
Dave Airlie0b4c0f32010-03-30 05:34:15 +00002003 struct drm_fb_helper_connector *fb_helper_conn;
Dave Airlie38651672010-03-30 05:34:13 +00002004
Dave Airlie0b4c0f32010-03-30 05:34:15 +00002005 if (n == fb_helper->connector_count)
Dave Airlie38651672010-03-30 05:34:13 +00002006 return 0;
Dave Airlie0b4c0f32010-03-30 05:34:15 +00002007
2008 fb_helper_conn = fb_helper->connector_info[n];
2009 connector = fb_helper_conn->connector;
Dave Airlie38651672010-03-30 05:34:13 +00002010
2011 best_crtcs[n] = NULL;
Dave Airlie8be48d92010-03-30 05:34:14 +00002012 best_score = drm_pick_crtcs(fb_helper, best_crtcs, modes, n+1, width, height);
Dave Airlie38651672010-03-30 05:34:13 +00002013 if (modes[n] == NULL)
2014 return best_score;
2015
Lyude255f0e72016-05-12 10:56:59 -04002016 crtcs = kzalloc(fb_helper->connector_count *
Dave Airlie8be48d92010-03-30 05:34:14 +00002017 sizeof(struct drm_fb_helper_crtc *), GFP_KERNEL);
Dave Airlie38651672010-03-30 05:34:13 +00002018 if (!crtcs)
2019 return best_score;
2020
2021 my_score = 1;
2022 if (connector->status == connector_status_connected)
2023 my_score++;
Dave Airlie0b4c0f32010-03-30 05:34:15 +00002024 if (drm_has_cmdline_mode(fb_helper_conn))
Dave Airlie38651672010-03-30 05:34:13 +00002025 my_score++;
Dave Airlie0b4c0f32010-03-30 05:34:15 +00002026 if (drm_has_preferred_mode(fb_helper_conn, width, height))
Dave Airlie38651672010-03-30 05:34:13 +00002027 my_score++;
2028
2029 connector_funcs = connector->helper_private;
Boris Brezillonc61b93f2016-06-07 13:47:56 +02002030
2031 /*
2032 * If the DRM device implements atomic hooks and ->best_encoder() is
2033 * NULL we fallback to the default drm_atomic_helper_best_encoder()
2034 * helper.
2035 */
2036 if (fb_helper->dev->mode_config.funcs->atomic_commit &&
2037 !connector_funcs->best_encoder)
2038 encoder = drm_atomic_helper_best_encoder(connector);
2039 else
2040 encoder = connector_funcs->best_encoder(connector);
2041
Dave Airlie38651672010-03-30 05:34:13 +00002042 if (!encoder)
2043 goto out;
2044
Dave Airlie38651672010-03-30 05:34:13 +00002045 /* select a crtc for this connector and then attempt to configure
2046 remaining connectors */
Dave Airlie8be48d92010-03-30 05:34:14 +00002047 for (c = 0; c < fb_helper->crtc_count; c++) {
2048 crtc = &fb_helper->crtc_info[c];
Dave Airlie38651672010-03-30 05:34:13 +00002049
Sachin Kamat96081cd2012-11-15 03:43:30 +00002050 if ((encoder->possible_crtcs & (1 << c)) == 0)
Dave Airlie38651672010-03-30 05:34:13 +00002051 continue;
Dave Airlie38651672010-03-30 05:34:13 +00002052
2053 for (o = 0; o < n; o++)
2054 if (best_crtcs[o] == crtc)
2055 break;
2056
2057 if (o < n) {
Dave Airlie1d42bbc2010-05-07 05:02:30 +00002058 /* ignore cloning unless only a single crtc */
2059 if (fb_helper->crtc_count > 1)
2060 continue;
2061
2062 if (!drm_mode_equal(modes[o], modes[n]))
2063 continue;
Dave Airlie38651672010-03-30 05:34:13 +00002064 }
2065
2066 crtcs[n] = crtc;
Dave Airlie8be48d92010-03-30 05:34:14 +00002067 memcpy(crtcs, best_crtcs, n * sizeof(struct drm_fb_helper_crtc *));
2068 score = my_score + drm_pick_crtcs(fb_helper, crtcs, modes, n + 1,
Dave Airlie38651672010-03-30 05:34:13 +00002069 width, height);
2070 if (score > best_score) {
Dave Airlie38651672010-03-30 05:34:13 +00002071 best_score = score;
2072 memcpy(best_crtcs, crtcs,
Lyude255f0e72016-05-12 10:56:59 -04002073 fb_helper->connector_count *
Dave Airlie8be48d92010-03-30 05:34:14 +00002074 sizeof(struct drm_fb_helper_crtc *));
Dave Airlie38651672010-03-30 05:34:13 +00002075 }
Dave Airlie38651672010-03-30 05:34:13 +00002076 }
2077out:
2078 kfree(crtcs);
2079 return best_score;
2080}
2081
Dave Airlie8be48d92010-03-30 05:34:14 +00002082static void drm_setup_crtcs(struct drm_fb_helper *fb_helper)
Dave Airlie38651672010-03-30 05:34:13 +00002083{
Dave Airlie8be48d92010-03-30 05:34:14 +00002084 struct drm_device *dev = fb_helper->dev;
2085 struct drm_fb_helper_crtc **crtcs;
Dave Airlie38651672010-03-30 05:34:13 +00002086 struct drm_display_mode **modes;
Dave Airlieb0ee9e72014-10-20 16:31:53 +10002087 struct drm_fb_offset *offsets;
Dave Airlie8be48d92010-03-30 05:34:14 +00002088 struct drm_mode_set *modeset;
Dave Airlie38651672010-03-30 05:34:13 +00002089 bool *enabled;
2090 int width, height;
Jesse Barnes11e17a02013-02-19 13:31:39 -08002091 int i;
Dave Airlie38651672010-03-30 05:34:13 +00002092
2093 DRM_DEBUG_KMS("\n");
2094
2095 width = dev->mode_config.max_width;
2096 height = dev->mode_config.max_height;
2097
Maarten Lankhorst383b2e52016-02-15 13:45:15 +01002098 crtcs = kcalloc(fb_helper->connector_count,
Dave Airlie8be48d92010-03-30 05:34:14 +00002099 sizeof(struct drm_fb_helper_crtc *), GFP_KERNEL);
Maarten Lankhorst383b2e52016-02-15 13:45:15 +01002100 modes = kcalloc(fb_helper->connector_count,
Dave Airlie38651672010-03-30 05:34:13 +00002101 sizeof(struct drm_display_mode *), GFP_KERNEL);
Maarten Lankhorst383b2e52016-02-15 13:45:15 +01002102 offsets = kcalloc(fb_helper->connector_count,
Dave Airlieb0ee9e72014-10-20 16:31:53 +10002103 sizeof(struct drm_fb_offset), GFP_KERNEL);
Maarten Lankhorst383b2e52016-02-15 13:45:15 +01002104 enabled = kcalloc(fb_helper->connector_count,
Dave Airlie38651672010-03-30 05:34:13 +00002105 sizeof(bool), GFP_KERNEL);
Dave Airlieb0ee9e72014-10-20 16:31:53 +10002106 if (!crtcs || !modes || !enabled || !offsets) {
Sachin Kamat8c5eaca2012-11-19 09:44:58 +00002107 DRM_ERROR("Memory allocation failed\n");
2108 goto out;
2109 }
2110
Dave Airlie38651672010-03-30 05:34:13 +00002111
Dave Airlie0b4c0f32010-03-30 05:34:15 +00002112 drm_enable_connectors(fb_helper, enabled);
Dave Airlie38651672010-03-30 05:34:13 +00002113
Jesse Barnes11e17a02013-02-19 13:31:39 -08002114 if (!(fb_helper->funcs->initial_config &&
2115 fb_helper->funcs->initial_config(fb_helper, crtcs, modes,
Dave Airlieb0ee9e72014-10-20 16:31:53 +10002116 offsets,
Jesse Barnes11e17a02013-02-19 13:31:39 -08002117 enabled, width, height))) {
Maarten Lankhorst383b2e52016-02-15 13:45:15 +01002118 memset(modes, 0, fb_helper->connector_count*sizeof(modes[0]));
2119 memset(crtcs, 0, fb_helper->connector_count*sizeof(crtcs[0]));
2120 memset(offsets, 0, fb_helper->connector_count*sizeof(offsets[0]));
Jesse Barnes11e17a02013-02-19 13:31:39 -08002121
Dave Airlieb0ee9e72014-10-20 16:31:53 +10002122 if (!drm_target_cloned(fb_helper, modes, offsets,
2123 enabled, width, height) &&
2124 !drm_target_preferred(fb_helper, modes, offsets,
2125 enabled, width, height))
Dave Airlie1d42bbc2010-05-07 05:02:30 +00002126 DRM_ERROR("Unable to find initial modes\n");
Jesse Barnes11e17a02013-02-19 13:31:39 -08002127
2128 DRM_DEBUG_KMS("picking CRTCs for %dx%d config\n",
2129 width, height);
2130
2131 drm_pick_crtcs(fb_helper, crtcs, modes, 0, width, height);
Dave Airlie1d42bbc2010-05-07 05:02:30 +00002132 }
Dave Airlie38651672010-03-30 05:34:13 +00002133
Dave Airlie8be48d92010-03-30 05:34:14 +00002134 /* need to set the modesets up here for use later */
2135 /* fill out the connector<->crtc mappings into the modesets */
2136 for (i = 0; i < fb_helper->crtc_count; i++) {
2137 modeset = &fb_helper->crtc_info[i].mode_set;
2138 modeset->num_connectors = 0;
Daniel Vetter7e53f3a2013-01-21 10:52:17 +01002139 modeset->fb = NULL;
Dave Airlie8be48d92010-03-30 05:34:14 +00002140 }
Dave Airlie38651672010-03-30 05:34:13 +00002141
Dave Airlie0b4c0f32010-03-30 05:34:15 +00002142 for (i = 0; i < fb_helper->connector_count; i++) {
Dave Airlie38651672010-03-30 05:34:13 +00002143 struct drm_display_mode *mode = modes[i];
Dave Airlie8be48d92010-03-30 05:34:14 +00002144 struct drm_fb_helper_crtc *fb_crtc = crtcs[i];
Dave Airlieb0ee9e72014-10-20 16:31:53 +10002145 struct drm_fb_offset *offset = &offsets[i];
Dave Airlie8be48d92010-03-30 05:34:14 +00002146 modeset = &fb_crtc->mode_set;
Dave Airlie38651672010-03-30 05:34:13 +00002147
Dave Airlie8be48d92010-03-30 05:34:14 +00002148 if (mode && fb_crtc) {
Dave Airlieb0ee9e72014-10-20 16:31:53 +10002149 DRM_DEBUG_KMS("desired mode %s set on crtc %d (%d,%d)\n",
2150 mode->name, fb_crtc->mode_set.crtc->base.id, offset->x, offset->y);
Dave Airlie8be48d92010-03-30 05:34:14 +00002151 fb_crtc->desired_mode = mode;
Dave Airlieb0ee9e72014-10-20 16:31:53 +10002152 fb_crtc->x = offset->x;
2153 fb_crtc->y = offset->y;
Dave Airlie8be48d92010-03-30 05:34:14 +00002154 if (modeset->mode)
2155 drm_mode_destroy(dev, modeset->mode);
2156 modeset->mode = drm_mode_duplicate(dev,
2157 fb_crtc->desired_mode);
Dave Airlie0b4c0f32010-03-30 05:34:15 +00002158 modeset->connectors[modeset->num_connectors++] = fb_helper->connector_info[i]->connector;
Daniel Vetter7e53f3a2013-01-21 10:52:17 +01002159 modeset->fb = fb_helper->fb;
Dave Airlieb0ee9e72014-10-20 16:31:53 +10002160 modeset->x = offset->x;
2161 modeset->y = offset->y;
Dave Airlie38651672010-03-30 05:34:13 +00002162 }
Dave Airlie38651672010-03-30 05:34:13 +00002163 }
2164
Daniel Vetter7e53f3a2013-01-21 10:52:17 +01002165 /* Clear out any old modes if there are no more connected outputs. */
2166 for (i = 0; i < fb_helper->crtc_count; i++) {
2167 modeset = &fb_helper->crtc_info[i].mode_set;
2168 if (modeset->num_connectors == 0) {
2169 BUG_ON(modeset->fb);
Daniel Vetter7e53f3a2013-01-21 10:52:17 +01002170 if (modeset->mode)
2171 drm_mode_destroy(dev, modeset->mode);
2172 modeset->mode = NULL;
2173 }
2174 }
Sachin Kamat8c5eaca2012-11-19 09:44:58 +00002175out:
Dave Airlie38651672010-03-30 05:34:13 +00002176 kfree(crtcs);
2177 kfree(modes);
Dave Airlieb0ee9e72014-10-20 16:31:53 +10002178 kfree(offsets);
Dave Airlie38651672010-03-30 05:34:13 +00002179 kfree(enabled);
2180}
2181
2182/**
Daniel Vetter207fd322013-01-20 22:13:14 +01002183 * drm_fb_helper_initial_config - setup a sane initial connector configuration
Daniel Vetterd0ddc0332012-11-01 14:45:17 +01002184 * @fb_helper: fb_helper device struct
2185 * @bpp_sel: bpp value to use for the framebuffer configuration
Dave Airlie38651672010-03-30 05:34:13 +00002186 *
Daniel Vetterd0ddc0332012-11-01 14:45:17 +01002187 * Scans the CRTCs and connectors and tries to put together an initial setup.
Dave Airlie38651672010-03-30 05:34:13 +00002188 * At the moment, this is a cloned configuration across all heads with
2189 * a new framebuffer object as the backing store.
2190 *
Daniel Vetter207fd322013-01-20 22:13:14 +01002191 * Note that this also registers the fbdev and so allows userspace to call into
2192 * the driver through the fbdev interfaces.
2193 *
2194 * This function will call down into the ->fb_probe callback to let
2195 * the driver allocate and initialize the fbdev info structure and the drm
2196 * framebuffer used to back the fbdev. drm_fb_helper_fill_var() and
2197 * drm_fb_helper_fill_fix() are provided as helpers to setup simple default
2198 * values for the fbdev info structure.
2199 *
Daniel Vetter40f8cf42016-01-22 08:53:45 +01002200 * HANG DEBUGGING:
2201 *
2202 * When you have fbcon support built-in or already loaded, this function will do
2203 * a full modeset to setup the fbdev console. Due to locking misdesign in the
2204 * VT/fbdev subsystem that entire modeset sequence has to be done while holding
2205 * console_lock. Until console_unlock is called no dmesg lines will be sent out
2206 * to consoles, not even serial console. This means when your driver crashes,
2207 * you will see absolutely nothing else but a system stuck in this function,
2208 * with no further output. Any kind of printk() you place within your own driver
2209 * or in the drm core modeset code will also never show up.
2210 *
2211 * Standard debug practice is to run the fbcon setup without taking the
2212 * console_lock as a hack, to be able to see backtraces and crashes on the
2213 * serial line. This can be done by setting the fb.lockless_register_fb=1 kernel
2214 * cmdline option.
2215 *
2216 * The other option is to just disable fbdev emulation since very likely the
Lyudeaf509d32016-05-04 11:28:53 -04002217 * first modeset from userspace will crash in the same way, and is even easier
2218 * to debug. This can be done by setting the drm_kms_helper.fbdev_emulation=0
Daniel Vetter40f8cf42016-01-22 08:53:45 +01002219 * kernel cmdline option.
2220 *
Dave Airlie38651672010-03-30 05:34:13 +00002221 * RETURNS:
2222 * Zero if everything went ok, nonzero otherwise.
2223 */
Thierry Reding01934c22014-12-19 11:21:32 +01002224int drm_fb_helper_initial_config(struct drm_fb_helper *fb_helper, int bpp_sel)
Dave Airlie38651672010-03-30 05:34:13 +00002225{
Dave Airlie8be48d92010-03-30 05:34:14 +00002226 struct drm_device *dev = fb_helper->dev;
Dave Airlie38651672010-03-30 05:34:13 +00002227 int count = 0;
2228
Daniel Vetterf64c5572015-08-25 15:45:13 +02002229 if (!drm_fbdev_emulation)
2230 return 0;
2231
Daniel Vetter53f19042014-03-20 14:26:35 +01002232 mutex_lock(&dev->mode_config.mutex);
Dave Airlie0b4c0f32010-03-30 05:34:15 +00002233 count = drm_fb_helper_probe_connector_modes(fb_helper,
2234 dev->mode_config.max_width,
2235 dev->mode_config.max_height);
Daniel Vetter53f19042014-03-20 14:26:35 +01002236 mutex_unlock(&dev->mode_config.mutex);
Dave Airlie38651672010-03-30 05:34:13 +00002237 /*
2238 * we shouldn't end up with no modes here.
2239 */
Sachin Kamat96081cd2012-11-15 03:43:30 +00002240 if (count == 0)
Sachin Kamatd56b1b92012-11-15 03:43:29 +00002241 dev_info(fb_helper->dev->dev, "No connectors reported connected with modes\n");
Sachin Kamat96081cd2012-11-15 03:43:30 +00002242
Dave Airlie8be48d92010-03-30 05:34:14 +00002243 drm_setup_crtcs(fb_helper);
Dave Airlie38651672010-03-30 05:34:13 +00002244
Dave Airlie4abe3522010-03-30 05:34:18 +00002245 return drm_fb_helper_single_fb_probe(fb_helper, bpp_sel);
Dave Airlie38651672010-03-30 05:34:13 +00002246}
Dave Airlie8be48d92010-03-30 05:34:14 +00002247EXPORT_SYMBOL(drm_fb_helper_initial_config);
Dave Airlie38651672010-03-30 05:34:13 +00002248
Chris Wilson73943712011-04-22 11:03:57 +01002249/**
2250 * drm_fb_helper_hotplug_event - respond to a hotplug notification by
Daniel Vetterd0ddc0332012-11-01 14:45:17 +01002251 * probing all the outputs attached to the fb
Chris Wilson73943712011-04-22 11:03:57 +01002252 * @fb_helper: the drm_fb_helper
2253 *
Chris Wilson73943712011-04-22 11:03:57 +01002254 * Scan the connectors attached to the fb_helper and try to put together a
Daniel Vetter62cacc72016-08-12 22:48:37 +02002255 * setup after notification of a change in output configuration.
Chris Wilson73943712011-04-22 11:03:57 +01002256 *
Daniel Vetter207fd322013-01-20 22:13:14 +01002257 * Called at runtime, takes the mode config locks to be able to check/change the
2258 * modeset configuration. Must be run from process context (which usually means
2259 * either the output polling work or a work item launched from the driver's
2260 * hotplug interrupt).
2261 *
Daniel Vetter50c3dc92014-06-27 17:19:22 +02002262 * Note that drivers may call this even before calling
Lyudeaf509d32016-05-04 11:28:53 -04002263 * drm_fb_helper_initial_config but only after drm_fb_helper_init. This allows
Daniel Vetter50c3dc92014-06-27 17:19:22 +02002264 * for a race-free fbcon setup and will make sure that the fbdev emulation will
2265 * not miss any hotplug events.
Daniel Vetter207fd322013-01-20 22:13:14 +01002266 *
Chris Wilson73943712011-04-22 11:03:57 +01002267 * RETURNS:
2268 * 0 on success and a non-zero error code otherwise.
2269 */
2270int drm_fb_helper_hotplug_event(struct drm_fb_helper *fb_helper)
Dave Airlie38651672010-03-30 05:34:13 +00002271{
Chris Wilson73943712011-04-22 11:03:57 +01002272 struct drm_device *dev = fb_helper->dev;
Lespiau, Damien51bbd272013-09-28 16:24:05 +01002273 u32 max_width, max_height;
Dave Airlie4abe3522010-03-30 05:34:18 +00002274
Daniel Vetterf64c5572015-08-25 15:45:13 +02002275 if (!drm_fbdev_emulation)
2276 return 0;
2277
Daniel Vetter89ced122013-04-11 14:26:55 +00002278 mutex_lock(&fb_helper->dev->mode_config.mutex);
Daniel Vetter50c3dc92014-06-27 17:19:22 +02002279 if (!fb_helper->fb || !drm_fb_helper_is_bound(fb_helper)) {
Dave Airlieeb1f8e42010-05-07 06:42:51 +00002280 fb_helper->delayed_hotplug = true;
Daniel Vetter89ced122013-04-11 14:26:55 +00002281 mutex_unlock(&fb_helper->dev->mode_config.mutex);
Chris Wilson73943712011-04-22 11:03:57 +01002282 return 0;
Dave Airlieeb1f8e42010-05-07 06:42:51 +00002283 }
Dave Airlie38651672010-03-30 05:34:13 +00002284 DRM_DEBUG_KMS("\n");
2285
Dave Airlie4abe3522010-03-30 05:34:18 +00002286 max_width = fb_helper->fb->width;
2287 max_height = fb_helper->fb->height;
Dave Airlie4abe3522010-03-30 05:34:18 +00002288
Lespiau, Damien51bbd272013-09-28 16:24:05 +01002289 drm_fb_helper_probe_connector_modes(fb_helper, max_width, max_height);
Daniel Vetter89ced122013-04-11 14:26:55 +00002290 mutex_unlock(&fb_helper->dev->mode_config.mutex);
2291
2292 drm_modeset_lock_all(dev);
Dave Airlie8be48d92010-03-30 05:34:14 +00002293 drm_setup_crtcs(fb_helper);
Daniel Vetter84849902012-12-02 00:28:11 +01002294 drm_modeset_unlock_all(dev);
Daniel Vetter2180c3c2013-01-21 23:12:36 +01002295 drm_fb_helper_set_par(fb_helper->fbdev);
2296
2297 return 0;
Dave Airlie38651672010-03-30 05:34:13 +00002298}
Dave Airlieeb1f8e42010-05-07 06:42:51 +00002299EXPORT_SYMBOL(drm_fb_helper_hotplug_event);
Dave Airlie5c4426a2010-03-30 05:34:17 +00002300
David Rientjes6a108a12011-01-20 14:44:16 -08002301/* The Kconfig DRM_KMS_HELPER selects FRAMEBUFFER_CONSOLE (if !EXPERT)
David Fries3ce05162010-12-12 12:39:22 -06002302 * but the module doesn't depend on any fb console symbols. At least
2303 * attempt to load fbcon to avoid leaving the system without a usable console.
2304 */
Rafael Antognolli70412cf2016-01-21 15:10:18 -08002305int __init drm_fb_helper_modinit(void)
David Fries3ce05162010-12-12 12:39:22 -06002306{
Rafael Antognolli70412cf2016-01-21 15:10:18 -08002307#if defined(CONFIG_FRAMEBUFFER_CONSOLE_MODULE) && !defined(CONFIG_EXPERT)
David Fries3ce05162010-12-12 12:39:22 -06002308 const char *name = "fbcon";
2309 struct module *fbcon;
2310
2311 mutex_lock(&module_mutex);
2312 fbcon = find_module(name);
2313 mutex_unlock(&module_mutex);
2314
2315 if (!fbcon)
2316 request_module_nowait(name);
Rafael Antognolli70412cf2016-01-21 15:10:18 -08002317#endif
David Fries3ce05162010-12-12 12:39:22 -06002318 return 0;
2319}
Rafael Antognolli70412cf2016-01-21 15:10:18 -08002320EXPORT_SYMBOL(drm_fb_helper_modinit);