drm_fb_helper.c 64.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
/*
 * Copyright (c) 2006-2009 Red Hat Inc.
 * Copyright (c) 2006-2008 Intel Corporation
 * Copyright (c) 2007 Dave Airlie <airlied@linux.ie>
 *
 * DRM framebuffer helper functions
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that copyright
 * notice and this permission notice appear in supporting documentation, and
 * that the name of the copyright holders not be used in advertising or
 * publicity pertaining to distribution of the software without specific,
 * written prior permission.  The copyright holders make no representations
 * about the suitability of this software for any purpose.  It is provided "as
 * is" without express or implied warranty.
 *
 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
 * OF THIS SOFTWARE.
 *
 * Authors:
 *      Dave Airlie <airlied@linux.ie>
 *      Jesse Barnes <jesse.barnes@intel.com>
 */
30 31
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

32
#include <linux/console.h>
33
#include <linux/kernel.h>
34
#include <linux/sysrq.h>
35
#include <linux/slab.h>
36
#include <linux/module.h>
37 38 39 40
#include <drm/drmP.h>
#include <drm/drm_crtc.h>
#include <drm/drm_fb_helper.h>
#include <drm/drm_crtc_helper.h>
41 42
#include <drm/drm_atomic.h>
#include <drm/drm_atomic_helper.h>
43

44 45
#include "drm_crtc_helper_internal.h"

46 47 48 49 50
static bool drm_fbdev_emulation = true;
module_param_named(fbdev_emulation, drm_fbdev_emulation, bool, 0600);
MODULE_PARM_DESC(fbdev_emulation,
		 "Enable legacy fbdev emulation [default=true]");

51 52
static LIST_HEAD(kernel_fb_helper_list);

53 54 55 56
/**
 * DOC: fbdev helpers
 *
 * The fb helper functions are useful to provide an fbdev on top of a drm kernel
T
Thierry Reding 已提交
57
 * mode setting driver. They can be used mostly independently from the crtc
58 59
 * helper functions used by many drivers to implement the kernel mode setting
 * interfaces.
D
Daniel Vetter 已提交
60
 *
61 62 63 64 65
 * Initialization is done as a four-step process with drm_fb_helper_prepare(),
 * drm_fb_helper_init(), drm_fb_helper_single_add_all_connectors() and
 * drm_fb_helper_initial_config(). Drivers with fancier requirements than the
 * default behaviour can override the third step with their own code.
 * Teardown is done with drm_fb_helper_fini().
D
Daniel Vetter 已提交
66 67
 *
 * At runtime drivers should restore the fbdev console by calling
68 69
 * drm_fb_helper_restore_fbdev_mode_unlocked() from their ->lastclose callback.
 * They should also notify the fb helper code from updates to the output
D
Daniel Vetter 已提交
70 71
 * configuration by calling drm_fb_helper_hotplug_event(). For easier
 * integration with the output polling code in drm_crtc_helper.c the modeset
T
Thierry Reding 已提交
72
 * code provides a ->output_poll_changed callback.
D
Daniel Vetter 已提交
73 74 75
 *
 * All other functions exported by the fb helper library can be used to
 * implement the fbdev driver interface by the driver.
76 77 78 79 80 81 82 83 84 85 86 87 88
 *
 * It is possible, though perhaps somewhat tricky, to implement race-free
 * hotplug detection using the fbdev helpers. The drm_fb_helper_prepare()
 * helper must be called first to initialize the minimum required to make
 * hotplug detection work. Drivers also need to make sure to properly set up
 * the dev->mode_config.funcs member. After calling drm_kms_helper_poll_init()
 * it is safe to enable interrupts and start processing hotplug events. At the
 * same time, drivers should initialize all modeset objects such as CRTCs,
 * encoders and connectors. To finish up the fbdev helper initialization, the
 * drm_fb_helper_init() function is called. To probe for all attached displays
 * and set up an initial configuration using the detected hardware, drivers
 * should call drm_fb_helper_single_add_all_connectors() followed by
 * drm_fb_helper_initial_config().
89
 *
90 91 92 93 94 95 96 97
 * If &drm_framebuffer_funcs ->dirty is set, the
 * drm_fb_helper_{cfb,sys}_{write,fillrect,copyarea,imageblit} functions will
 * accumulate changes and schedule &drm_fb_helper ->dirty_work to run right
 * away. This worker then calls the dirty() function ensuring that it will
 * always run in process context since the fb_*() function could be running in
 * atomic context. If drm_fb_helper_deferred_io() is used as the deferred_io
 * callback it will also schedule dirty_work with the damage collected from the
 * mmap page writes.
98 99
 */

D
Daniel Vetter 已提交
100 101 102 103 104 105 106 107 108 109
/**
 * drm_fb_helper_single_add_all_connectors() - add all connectors to fbdev
 * 					       emulation helper
 * @fb_helper: fbdev initialized with drm_fb_helper_init
 *
 * This functions adds all the available connectors for use with the given
 * fb_helper. This is a separate step to allow drivers to freely assign
 * connectors to the fbdev, e.g. if some are reserved for special purposes or
 * not adequate to be used for the fbcon.
 *
110 111 112
 * This function is protected against concurrent connector hotadds/removals
 * using drm_fb_helper_add_one_connector() and
 * drm_fb_helper_remove_one_connector().
D
Daniel Vetter 已提交
113
 */
114
int drm_fb_helper_single_add_all_connectors(struct drm_fb_helper *fb_helper)
115
{
116 117
	struct drm_device *dev = fb_helper->dev;
	struct drm_connector *connector;
118
	int i, ret;
119

120 121 122
	if (!drm_fbdev_emulation)
		return 0;

123
	mutex_lock(&dev->mode_config.mutex);
124
	drm_for_each_connector(connector, dev) {
125
		ret = drm_fb_helper_add_one_connector(fb_helper, connector);
126

127
		if (ret)
128 129
			goto fail;
	}
130
	mutex_unlock(&dev->mode_config.mutex);
131
	return 0;
132 133 134 135 136 137
fail:
	for (i = 0; i < fb_helper->connector_count; i++) {
		kfree(fb_helper->connector_info[i]);
		fb_helper->connector_info[i] = NULL;
	}
	fb_helper->connector_count = 0;
138 139
	mutex_unlock(&dev->mode_config.mutex);

140
	return ret;
141
}
142
EXPORT_SYMBOL(drm_fb_helper_single_add_all_connectors);
143

144 145 146 147 148
int drm_fb_helper_add_one_connector(struct drm_fb_helper *fb_helper, struct drm_connector *connector)
{
	struct drm_fb_helper_connector **temp;
	struct drm_fb_helper_connector *fb_helper_connector;

149 150 151
	if (!drm_fbdev_emulation)
		return 0;

152 153
	WARN_ON(!mutex_is_locked(&fb_helper->dev->mode_config.mutex));
	if (fb_helper->connector_count + 1 > fb_helper->connector_info_alloc_count) {
154
		temp = krealloc(fb_helper->connector_info, sizeof(struct drm_fb_helper_connector *) * (fb_helper->connector_count + 1), GFP_KERNEL);
155 156 157 158 159 160 161 162 163 164 165 166
		if (!temp)
			return -ENOMEM;

		fb_helper->connector_info_alloc_count = fb_helper->connector_count + 1;
		fb_helper->connector_info = temp;
	}


	fb_helper_connector = kzalloc(sizeof(struct drm_fb_helper_connector), GFP_KERNEL);
	if (!fb_helper_connector)
		return -ENOMEM;

167
	drm_connector_reference(connector);
168 169 170 171 172 173 174 175 176 177 178 179
	fb_helper_connector->connector = connector;
	fb_helper->connector_info[fb_helper->connector_count++] = fb_helper_connector;
	return 0;
}
EXPORT_SYMBOL(drm_fb_helper_add_one_connector);

int drm_fb_helper_remove_one_connector(struct drm_fb_helper *fb_helper,
				       struct drm_connector *connector)
{
	struct drm_fb_helper_connector *fb_helper_connector;
	int i, j;

180 181 182
	if (!drm_fbdev_emulation)
		return 0;

183 184 185 186 187 188 189 190 191 192
	WARN_ON(!mutex_is_locked(&fb_helper->dev->mode_config.mutex));

	for (i = 0; i < fb_helper->connector_count; i++) {
		if (fb_helper->connector_info[i]->connector == connector)
			break;
	}

	if (i == fb_helper->connector_count)
		return -EINVAL;
	fb_helper_connector = fb_helper->connector_info[i];
193
	drm_connector_unreference(fb_helper_connector->connector);
194 195 196 197 198 199

	for (j = i + 1; j < fb_helper->connector_count; j++) {
		fb_helper->connector_info[j - 1] = fb_helper->connector_info[j];
	}
	fb_helper->connector_count--;
	kfree(fb_helper_connector);
200

201 202 203 204
	return 0;
}
EXPORT_SYMBOL(drm_fb_helper_remove_one_connector);

205 206 207 208 209
static void drm_fb_helper_save_lut_atomic(struct drm_crtc *crtc, struct drm_fb_helper *helper)
{
	uint16_t *r_base, *g_base, *b_base;
	int i;

210 211 212
	if (helper->funcs->gamma_get == NULL)
		return;

213 214 215 216 217 218 219 220 221 222 223 224
	r_base = crtc->gamma_store;
	g_base = r_base + crtc->gamma_size;
	b_base = g_base + crtc->gamma_size;

	for (i = 0; i < crtc->gamma_size; i++)
		helper->funcs->gamma_get(crtc, &r_base[i], &g_base[i], &b_base[i], i);
}

static void drm_fb_helper_restore_lut_atomic(struct drm_crtc *crtc)
{
	uint16_t *r_base, *g_base, *b_base;

225 226 227
	if (crtc->funcs->gamma_set == NULL)
		return;

228 229 230 231
	r_base = crtc->gamma_store;
	g_base = r_base + crtc->gamma_size;
	b_base = g_base + crtc->gamma_size;

232
	crtc->funcs->gamma_set(crtc, r_base, g_base, b_base, crtc->gamma_size);
233 234
}

D
Daniel Vetter 已提交
235 236 237 238
/**
 * drm_fb_helper_debug_enter - implementation for ->fb_debug_enter
 * @info: fbdev registered by the helper
 */
J
Jesse Barnes 已提交
239 240 241
int drm_fb_helper_debug_enter(struct fb_info *info)
{
	struct drm_fb_helper *helper = info->par;
242
	const struct drm_crtc_helper_funcs *funcs;
J
Jesse Barnes 已提交
243 244 245 246 247 248 249 250 251 252 253
	int i;

	list_for_each_entry(helper, &kernel_fb_helper_list, kernel_fb_list) {
		for (i = 0; i < helper->crtc_count; i++) {
			struct drm_mode_set *mode_set =
				&helper->crtc_info[i].mode_set;

			if (!mode_set->crtc->enabled)
				continue;

			funcs =	mode_set->crtc->helper_private;
254
			drm_fb_helper_save_lut_atomic(mode_set->crtc, helper);
J
Jesse Barnes 已提交
255 256 257
			funcs->mode_set_base_atomic(mode_set->crtc,
						    mode_set->fb,
						    mode_set->x,
258
						    mode_set->y,
259
						    ENTER_ATOMIC_MODE_SET);
J
Jesse Barnes 已提交
260 261 262 263 264 265 266 267 268 269 270 271 272
		}
	}

	return 0;
}
EXPORT_SYMBOL(drm_fb_helper_debug_enter);

/* Find the real fb for a given fb helper CRTC */
static struct drm_framebuffer *drm_mode_config_fb(struct drm_crtc *crtc)
{
	struct drm_device *dev = crtc->dev;
	struct drm_crtc *c;

273
	drm_for_each_crtc(c, dev) {
J
Jesse Barnes 已提交
274
		if (crtc->base.id == c->base.id)
275
			return c->primary->fb;
J
Jesse Barnes 已提交
276 277 278 279 280
	}

	return NULL;
}

D
Daniel Vetter 已提交
281 282 283 284
/**
 * drm_fb_helper_debug_leave - implementation for ->fb_debug_leave
 * @info: fbdev registered by the helper
 */
J
Jesse Barnes 已提交
285 286 287 288
int drm_fb_helper_debug_leave(struct fb_info *info)
{
	struct drm_fb_helper *helper = info->par;
	struct drm_crtc *crtc;
289
	const struct drm_crtc_helper_funcs *funcs;
J
Jesse Barnes 已提交
290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306
	struct drm_framebuffer *fb;
	int i;

	for (i = 0; i < helper->crtc_count; i++) {
		struct drm_mode_set *mode_set = &helper->crtc_info[i].mode_set;
		crtc = mode_set->crtc;
		funcs = crtc->helper_private;
		fb = drm_mode_config_fb(crtc);

		if (!crtc->enabled)
			continue;

		if (!fb) {
			DRM_ERROR("no fb to restore??\n");
			continue;
		}

307
		drm_fb_helper_restore_lut_atomic(mode_set->crtc);
J
Jesse Barnes 已提交
308
		funcs->mode_set_base_atomic(mode_set->crtc, fb, crtc->x,
309
					    crtc->y, LEAVE_ATOMIC_MODE_SET);
J
Jesse Barnes 已提交
310 311 312 313 314 315
	}

	return 0;
}
EXPORT_SYMBOL(drm_fb_helper_debug_leave);

316 317 318 319 320 321
static int restore_fbdev_mode_atomic(struct drm_fb_helper *fb_helper)
{
	struct drm_device *dev = fb_helper->dev;
	struct drm_plane *plane;
	struct drm_atomic_state *state;
	int i, ret;
322
	unsigned plane_mask;
323 324 325 326 327 328 329

	state = drm_atomic_state_alloc(dev);
	if (!state)
		return -ENOMEM;

	state->acquire_ctx = dev->mode_config.acquire_ctx;
retry:
330
	plane_mask = 0;
331 332 333 334 335 336 337 338 339
	drm_for_each_plane(plane, dev) {
		struct drm_plane_state *plane_state;

		plane_state = drm_atomic_get_plane_state(state, plane);
		if (IS_ERR(plane_state)) {
			ret = PTR_ERR(plane_state);
			goto fail;
		}

340
		plane_state->rotation = DRM_ROTATE_0;
341

342 343 344
		plane->old_fb = plane->fb;
		plane_mask |= 1 << drm_plane_index(plane);

345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364
		/* disable non-primary: */
		if (plane->type == DRM_PLANE_TYPE_PRIMARY)
			continue;

		ret = __drm_atomic_helper_disable_plane(plane, plane_state);
		if (ret != 0)
			goto fail;
	}

	for(i = 0; i < fb_helper->crtc_count; i++) {
		struct drm_mode_set *mode_set = &fb_helper->crtc_info[i].mode_set;

		ret = __drm_atomic_helper_set_config(mode_set, state);
		if (ret != 0)
			goto fail;
	}

	ret = drm_atomic_commit(state);

fail:
365
	drm_atomic_clean_old_fb(dev, plane_mask, ret);
366

367 368 369
	if (ret == -EDEADLK)
		goto backoff;

370
	drm_atomic_state_put(state);
371 372 373 374 375 376 377 378 379
	return ret;

backoff:
	drm_atomic_state_clear(state);
	drm_atomic_legacy_backoff(state);

	goto retry;
}

380
static int restore_fbdev_mode(struct drm_fb_helper *fb_helper)
381
{
382 383 384 385 386
	struct drm_device *dev = fb_helper->dev;
	struct drm_plane *plane;
	int i;

	drm_warn_on_modeset_not_all_locked(dev);
387

388
	if (dev->mode_config.funcs->atomic_commit)
389 390
		return restore_fbdev_mode_atomic(fb_helper);

391
	drm_for_each_plane(plane, dev) {
392 393
		if (plane->type != DRM_PLANE_TYPE_PRIMARY)
			drm_plane_force_disable(plane);
394

S
Sonika Jindal 已提交
395
		if (dev->mode_config.rotation_property) {
396 397
			drm_mode_plane_set_obj_prop(plane,
						    dev->mode_config.rotation_property,
398
						    DRM_ROTATE_0);
S
Sonika Jindal 已提交
399 400 401
		}
	}

402 403
	for (i = 0; i < fb_helper->crtc_count; i++) {
		struct drm_mode_set *mode_set = &fb_helper->crtc_info[i].mode_set;
404 405 406
		struct drm_crtc *crtc = mode_set->crtc;
		int ret;

407 408 409
		if (crtc->funcs->cursor_set2) {
			ret = crtc->funcs->cursor_set2(crtc, NULL, 0, 0, 0, 0, 0);
			if (ret)
410
				return ret;
411
		} else if (crtc->funcs->cursor_set) {
412 413
			ret = crtc->funcs->cursor_set(crtc, NULL, 0, 0, 0);
			if (ret)
414
				return ret;
415 416
		}

417
		ret = drm_mode_set_config_internal(mode_set);
418
		if (ret)
419
			return ret;
420
	}
421 422

	return 0;
423
}
424 425 426 427 428 429 430 431

/**
 * drm_fb_helper_restore_fbdev_mode_unlocked - restore fbdev configuration
 * @fb_helper: fbcon to restore
 *
 * This should be called from driver's drm ->lastclose callback
 * when implementing an fbcon on top of kms using this helper. This ensures that
 * the user isn't greeted with a black screen when e.g. X dies.
432 433 434
 *
 * RETURNS:
 * Zero if everything went ok, negative error code otherwise.
435
 */
436
int drm_fb_helper_restore_fbdev_mode_unlocked(struct drm_fb_helper *fb_helper)
437 438
{
	struct drm_device *dev = fb_helper->dev;
439 440
	bool do_delayed;
	int ret;
441

442 443 444
	if (!drm_fbdev_emulation)
		return -ENODEV;

445 446
	drm_modeset_lock_all(dev);
	ret = restore_fbdev_mode(fb_helper);
447 448 449 450

	do_delayed = fb_helper->delayed_hotplug;
	if (do_delayed)
		fb_helper->delayed_hotplug = false;
451
	drm_modeset_unlock_all(dev);
452 453 454

	if (do_delayed)
		drm_fb_helper_hotplug_event(fb_helper);
455 456 457
	return ret;
}
EXPORT_SYMBOL(drm_fb_helper_restore_fbdev_mode_unlocked);
458

459 460 461 462 463 464 465 466
static bool drm_fb_helper_is_bound(struct drm_fb_helper *fb_helper)
{
	struct drm_device *dev = fb_helper->dev;
	struct drm_crtc *crtc;
	int bound = 0, crtcs_bound = 0;

	/* Sometimes user space wants everything disabled, so don't steal the
	 * display if there's a master. */
467
	if (READ_ONCE(dev->master))
468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483
		return false;

	drm_for_each_crtc(crtc, dev) {
		if (crtc->primary->fb)
			crtcs_bound++;
		if (crtc->primary->fb == fb_helper->fb)
			bound++;
	}

	if (bound < crtcs_bound)
		return false;

	return true;
}

#ifdef CONFIG_MAGIC_SYSRQ
484 485 486 487
/*
 * restore fbcon display for all kms driver's using this helper, used for sysrq
 * and panic handling.
 */
488
static bool drm_fb_helper_force_kernel_mode(void)
489 490 491 492 493 494 495 496
{
	bool ret, error = false;
	struct drm_fb_helper *helper;

	if (list_empty(&kernel_fb_helper_list))
		return false;

	list_for_each_entry(helper, &kernel_fb_helper_list, kernel_fb_list) {
497 498 499 500 501
		struct drm_device *dev = helper->dev;

		if (dev->switch_power_state == DRM_SWITCH_POWER_OFF)
			continue;

502
		drm_modeset_lock_all(dev);
503
		ret = restore_fbdev_mode(helper);
504 505
		if (ret)
			error = true;
506
		drm_modeset_unlock_all(dev);
507 508 509 510 511 512
	}
	return error;
}

static void drm_fb_helper_restore_work_fn(struct work_struct *ignored)
{
513 514 515 516
	bool ret;
	ret = drm_fb_helper_force_kernel_mode();
	if (ret == true)
		DRM_ERROR("Failed to restore crtc configuration\n");
517 518 519
}
static DECLARE_WORK(drm_fb_helper_restore_work, drm_fb_helper_restore_work_fn);

520
static void drm_fb_helper_sysrq(int dummy1)
521 522 523 524 525 526 527 528 529
{
	schedule_work(&drm_fb_helper_restore_work);
}

static struct sysrq_key_op sysrq_drm_fb_helper_restore_op = {
	.handler = drm_fb_helper_sysrq,
	.help_msg = "force-fb(V)",
	.action_msg = "Restore framebuffer console",
};
530 531
#else
static struct sysrq_key_op sysrq_drm_fb_helper_restore_op = { };
532
#endif
533

534
static void drm_fb_helper_dpms(struct fb_info *info, int dpms_mode)
535 536 537 538
{
	struct drm_fb_helper *fb_helper = info->par;
	struct drm_device *dev = fb_helper->dev;
	struct drm_crtc *crtc;
539 540
	struct drm_connector *connector;
	int i, j;
541 542

	/*
543
	 * For each CRTC in this fb, turn the connectors on/off.
544
	 */
545
	drm_modeset_lock_all(dev);
546 547 548 549 550
	if (!drm_fb_helper_is_bound(fb_helper)) {
		drm_modeset_unlock_all(dev);
		return;
	}

551
	for (i = 0; i < fb_helper->crtc_count; i++) {
552
		crtc = fb_helper->crtc_info[i].mode_set.crtc;
553

554 555 556
		if (!crtc->enabled)
			continue;

557
		/* Walk the connectors & encoders on this fb turning them on/off */
558 559
		for (j = 0; j < fb_helper->connector_count; j++) {
			connector = fb_helper->connector_info[j]->connector;
560
			connector->funcs->dpms(connector, dpms_mode);
561
			drm_object_property_set_value(&connector->base,
562
				dev->mode_config.dpms_property, dpms_mode);
563 564
		}
	}
565
	drm_modeset_unlock_all(dev);
566 567
}

D
Daniel Vetter 已提交
568 569 570 571 572
/**
 * drm_fb_helper_blank - implementation for ->fb_blank
 * @blank: desired blanking state
 * @info: fbdev registered by the helper
 */
573 574
int drm_fb_helper_blank(int blank, struct fb_info *info)
{
575 576 577
	if (oops_in_progress)
		return -EBUSY;

578
	switch (blank) {
579
	/* Display: On; HSync: On, VSync: On */
580
	case FB_BLANK_UNBLANK:
581
		drm_fb_helper_dpms(info, DRM_MODE_DPMS_ON);
582
		break;
583
	/* Display: Off; HSync: On, VSync: On */
584
	case FB_BLANK_NORMAL:
585
		drm_fb_helper_dpms(info, DRM_MODE_DPMS_STANDBY);
586
		break;
587
	/* Display: Off; HSync: Off, VSync: On */
588
	case FB_BLANK_HSYNC_SUSPEND:
589
		drm_fb_helper_dpms(info, DRM_MODE_DPMS_STANDBY);
590
		break;
591
	/* Display: Off; HSync: On, VSync: Off */
592
	case FB_BLANK_VSYNC_SUSPEND:
593
		drm_fb_helper_dpms(info, DRM_MODE_DPMS_SUSPEND);
594
		break;
595
	/* Display: Off; HSync: Off, VSync: Off */
596
	case FB_BLANK_POWERDOWN:
597
		drm_fb_helper_dpms(info, DRM_MODE_DPMS_OFF);
598 599 600 601 602 603 604 605 606 607
		break;
	}
	return 0;
}
EXPORT_SYMBOL(drm_fb_helper_blank);

static void drm_fb_helper_crtc_free(struct drm_fb_helper *helper)
{
	int i;

608 609
	for (i = 0; i < helper->connector_count; i++) {
		drm_connector_unreference(helper->connector_info[i]->connector);
610
		kfree(helper->connector_info[i]);
611
	}
612
	kfree(helper->connector_info);
S
Sascha Hauer 已提交
613
	for (i = 0; i < helper->crtc_count; i++) {
614
		kfree(helper->crtc_info[i].mode_set.connectors);
S
Sascha Hauer 已提交
615 616 617
		if (helper->crtc_info[i].mode_set.mode)
			drm_mode_destroy(helper->dev, helper->crtc_info[i].mode_set.mode);
	}
618 619 620
	kfree(helper->crtc_info);
}

621 622 623 624 625 626 627 628 629 630
static void drm_fb_helper_resume_worker(struct work_struct *work)
{
	struct drm_fb_helper *helper = container_of(work, struct drm_fb_helper,
						    resume_work);

	console_lock();
	fb_set_suspend(helper->fbdev, 0);
	console_unlock();
}

631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647
static void drm_fb_helper_dirty_work(struct work_struct *work)
{
	struct drm_fb_helper *helper = container_of(work, struct drm_fb_helper,
						    dirty_work);
	struct drm_clip_rect *clip = &helper->dirty_clip;
	struct drm_clip_rect clip_copy;
	unsigned long flags;

	spin_lock_irqsave(&helper->dirty_lock, flags);
	clip_copy = *clip;
	clip->x1 = clip->y1 = ~0;
	clip->x2 = clip->y2 = 0;
	spin_unlock_irqrestore(&helper->dirty_lock, flags);

	helper->fb->funcs->dirty(helper->fb, NULL, 0, 0, &clip_copy, 1);
}

648 649 650 651 652 653 654 655 656 657 658 659 660
/**
 * drm_fb_helper_prepare - setup a drm_fb_helper structure
 * @dev: DRM device
 * @helper: driver-allocated fbdev helper structure to set up
 * @funcs: pointer to structure of functions associate with this helper
 *
 * Sets up the bare minimum to make the framebuffer helper usable. This is
 * useful to implement race-free initialization of the polling helpers.
 */
void drm_fb_helper_prepare(struct drm_device *dev, struct drm_fb_helper *helper,
			   const struct drm_fb_helper_funcs *funcs)
{
	INIT_LIST_HEAD(&helper->kernel_fb_list);
661
	spin_lock_init(&helper->dirty_lock);
662
	INIT_WORK(&helper->resume_work, drm_fb_helper_resume_worker);
663 664
	INIT_WORK(&helper->dirty_work, drm_fb_helper_dirty_work);
	helper->dirty_clip.x1 = helper->dirty_clip.y1 = ~0;
665 666 667 668 669
	helper->funcs = funcs;
	helper->dev = dev;
}
EXPORT_SYMBOL(drm_fb_helper_prepare);

D
Daniel Vetter 已提交
670 671 672 673 674 675 676 677 678 679 680 681
/**
 * drm_fb_helper_init - initialize a drm_fb_helper structure
 * @dev: drm device
 * @fb_helper: driver-allocated fbdev helper structure to initialize
 * @crtc_count: maximum number of crtcs to support in this fbdev emulation
 * @max_conn_count: max connector count
 *
 * This allocates the structures for the fbdev helper with the given limits.
 * Note that this won't yet touch the hardware (through the driver interfaces)
 * nor register the fbdev. This is only done in drm_fb_helper_initial_config()
 * to allow driver writes more control over the exact init sequence.
 *
682
 * Drivers must call drm_fb_helper_prepare() before calling this function.
D
Daniel Vetter 已提交
683 684 685 686
 *
 * RETURNS:
 * Zero if everything went ok, nonzero otherwise.
 */
687 688
int drm_fb_helper_init(struct drm_device *dev,
		       struct drm_fb_helper *fb_helper,
689
		       int crtc_count, int max_conn_count)
690 691 692 693
{
	struct drm_crtc *crtc;
	int i;

694 695 696
	if (!drm_fbdev_emulation)
		return 0;

697 698 699
	if (!max_conn_count)
		return -EINVAL;

700 701
	fb_helper->crtc_info = kcalloc(crtc_count, sizeof(struct drm_fb_helper_crtc), GFP_KERNEL);
	if (!fb_helper->crtc_info)
702 703
		return -ENOMEM;

704 705 706 707
	fb_helper->crtc_count = crtc_count;
	fb_helper->connector_info = kcalloc(dev->mode_config.num_connector, sizeof(struct drm_fb_helper_connector *), GFP_KERNEL);
	if (!fb_helper->connector_info) {
		kfree(fb_helper->crtc_info);
708 709
		return -ENOMEM;
	}
710
	fb_helper->connector_info_alloc_count = dev->mode_config.num_connector;
711
	fb_helper->connector_count = 0;
712 713

	for (i = 0; i < crtc_count; i++) {
714
		fb_helper->crtc_info[i].mode_set.connectors =
715 716 717 718
			kcalloc(max_conn_count,
				sizeof(struct drm_connector *),
				GFP_KERNEL);

719
		if (!fb_helper->crtc_info[i].mode_set.connectors)
720
			goto out_free;
721
		fb_helper->crtc_info[i].mode_set.num_connectors = 0;
722 723 724
	}

	i = 0;
725
	drm_for_each_crtc(crtc, dev) {
726
		fb_helper->crtc_info[i].mode_set.crtc = crtc;
727 728
		i++;
	}
729

730 731
	return 0;
out_free:
732
	drm_fb_helper_crtc_free(fb_helper);
733 734
	return -ENOMEM;
}
735 736
EXPORT_SYMBOL(drm_fb_helper_init);

737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816
/**
 * drm_fb_helper_alloc_fbi - allocate fb_info and some of its members
 * @fb_helper: driver-allocated fbdev helper
 *
 * A helper to alloc fb_info and the members cmap and apertures. Called
 * by the driver within the fb_probe fb_helper callback function.
 *
 * RETURNS:
 * fb_info pointer if things went okay, pointer containing error code
 * otherwise
 */
struct fb_info *drm_fb_helper_alloc_fbi(struct drm_fb_helper *fb_helper)
{
	struct device *dev = fb_helper->dev->dev;
	struct fb_info *info;
	int ret;

	info = framebuffer_alloc(0, dev);
	if (!info)
		return ERR_PTR(-ENOMEM);

	ret = fb_alloc_cmap(&info->cmap, 256, 0);
	if (ret)
		goto err_release;

	info->apertures = alloc_apertures(1);
	if (!info->apertures) {
		ret = -ENOMEM;
		goto err_free_cmap;
	}

	fb_helper->fbdev = info;

	return info;

err_free_cmap:
	fb_dealloc_cmap(&info->cmap);
err_release:
	framebuffer_release(info);
	return ERR_PTR(ret);
}
EXPORT_SYMBOL(drm_fb_helper_alloc_fbi);

/**
 * drm_fb_helper_unregister_fbi - unregister fb_info framebuffer device
 * @fb_helper: driver-allocated fbdev helper
 *
 * A wrapper around unregister_framebuffer, to release the fb_info
 * framebuffer device
 */
void drm_fb_helper_unregister_fbi(struct drm_fb_helper *fb_helper)
{
	if (fb_helper && fb_helper->fbdev)
		unregister_framebuffer(fb_helper->fbdev);
}
EXPORT_SYMBOL(drm_fb_helper_unregister_fbi);

/**
 * drm_fb_helper_release_fbi - dealloc fb_info and its members
 * @fb_helper: driver-allocated fbdev helper
 *
 * A helper to free memory taken by fb_info and the members cmap and
 * apertures
 */
void drm_fb_helper_release_fbi(struct drm_fb_helper *fb_helper)
{
	if (fb_helper) {
		struct fb_info *info = fb_helper->fbdev;

		if (info) {
			if (info->cmap.len)
				fb_dealloc_cmap(&info->cmap);
			framebuffer_release(info);
		}

		fb_helper->fbdev = NULL;
	}
}
EXPORT_SYMBOL(drm_fb_helper_release_fbi);

817 818
void drm_fb_helper_fini(struct drm_fb_helper *fb_helper)
{
819 820 821
	if (!drm_fbdev_emulation)
		return;

822 823 824 825 826 827 828 829 830 831 832
	if (!list_empty(&fb_helper->kernel_fb_list)) {
		list_del(&fb_helper->kernel_fb_list);
		if (list_empty(&kernel_fb_helper_list)) {
			unregister_sysrq_key('v', &sysrq_drm_fb_helper_restore_op);
		}
	}

	drm_fb_helper_crtc_free(fb_helper);

}
EXPORT_SYMBOL(drm_fb_helper_fini);
833

834 835 836 837 838 839 840 841 842 843 844 845 846
/**
 * drm_fb_helper_unlink_fbi - wrapper around unlink_framebuffer
 * @fb_helper: driver-allocated fbdev helper
 *
 * A wrapper around unlink_framebuffer implemented by fbdev core
 */
void drm_fb_helper_unlink_fbi(struct drm_fb_helper *fb_helper)
{
	if (fb_helper && fb_helper->fbdev)
		unlink_framebuffer(fb_helper->fbdev);
}
EXPORT_SYMBOL(drm_fb_helper_unlink_fbi);

847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899
static void drm_fb_helper_dirty(struct fb_info *info, u32 x, u32 y,
				u32 width, u32 height)
{
	struct drm_fb_helper *helper = info->par;
	struct drm_clip_rect *clip = &helper->dirty_clip;
	unsigned long flags;

	if (!helper->fb->funcs->dirty)
		return;

	spin_lock_irqsave(&helper->dirty_lock, flags);
	clip->x1 = min_t(u32, clip->x1, x);
	clip->y1 = min_t(u32, clip->y1, y);
	clip->x2 = max_t(u32, clip->x2, x + width);
	clip->y2 = max_t(u32, clip->y2, y + height);
	spin_unlock_irqrestore(&helper->dirty_lock, flags);

	schedule_work(&helper->dirty_work);
}

/**
 * drm_fb_helper_deferred_io() - fbdev deferred_io callback function
 * @info: fb_info struct pointer
 * @pagelist: list of dirty mmap framebuffer pages
 *
 * This function is used as the &fb_deferred_io ->deferred_io
 * callback function for flushing the fbdev mmap writes.
 */
void drm_fb_helper_deferred_io(struct fb_info *info,
			       struct list_head *pagelist)
{
	unsigned long start, end, min, max;
	struct page *page;
	u32 y1, y2;

	min = ULONG_MAX;
	max = 0;
	list_for_each_entry(page, pagelist, lru) {
		start = page->index << PAGE_SHIFT;
		end = start + PAGE_SIZE - 1;
		min = min(min, start);
		max = max(max, end);
	}

	if (min < max) {
		y1 = min / info->fix.line_length;
		y2 = min_t(u32, DIV_ROUND_UP(max, info->fix.line_length),
			   info->var.yres);
		drm_fb_helper_dirty(info, 0, y1, info->var.xres, y2 - y1);
	}
}
EXPORT_SYMBOL(drm_fb_helper_deferred_io);

900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927
/**
 * drm_fb_helper_sys_read - wrapper around fb_sys_read
 * @info: fb_info struct pointer
 * @buf: userspace buffer to read from framebuffer memory
 * @count: number of bytes to read from framebuffer memory
 * @ppos: read offset within framebuffer memory
 *
 * A wrapper around fb_sys_read implemented by fbdev core
 */
ssize_t drm_fb_helper_sys_read(struct fb_info *info, char __user *buf,
			       size_t count, loff_t *ppos)
{
	return fb_sys_read(info, buf, count, ppos);
}
EXPORT_SYMBOL(drm_fb_helper_sys_read);

/**
 * drm_fb_helper_sys_write - wrapper around fb_sys_write
 * @info: fb_info struct pointer
 * @buf: userspace buffer to write to framebuffer memory
 * @count: number of bytes to write to framebuffer memory
 * @ppos: write offset within framebuffer memory
 *
 * A wrapper around fb_sys_write implemented by fbdev core
 */
ssize_t drm_fb_helper_sys_write(struct fb_info *info, const char __user *buf,
				size_t count, loff_t *ppos)
{
928 929 930 931 932 933 934 935
	ssize_t ret;

	ret = fb_sys_write(info, buf, count, ppos);
	if (ret > 0)
		drm_fb_helper_dirty(info, 0, 0, info->var.xres,
				    info->var.yres);

	return ret;
936 937 938
}
EXPORT_SYMBOL(drm_fb_helper_sys_write);

939 940 941 942 943 944 945 946 947 948 949
/**
 * drm_fb_helper_sys_fillrect - wrapper around sys_fillrect
 * @info: fbdev registered by the helper
 * @rect: info about rectangle to fill
 *
 * A wrapper around sys_fillrect implemented by fbdev core
 */
void drm_fb_helper_sys_fillrect(struct fb_info *info,
				const struct fb_fillrect *rect)
{
	sys_fillrect(info, rect);
950 951
	drm_fb_helper_dirty(info, rect->dx, rect->dy,
			    rect->width, rect->height);
952 953 954 955 956 957 958 959 960 961 962 963 964 965
}
EXPORT_SYMBOL(drm_fb_helper_sys_fillrect);

/**
 * drm_fb_helper_sys_copyarea - wrapper around sys_copyarea
 * @info: fbdev registered by the helper
 * @area: info about area to copy
 *
 * A wrapper around sys_copyarea implemented by fbdev core
 */
void drm_fb_helper_sys_copyarea(struct fb_info *info,
				const struct fb_copyarea *area)
{
	sys_copyarea(info, area);
966 967
	drm_fb_helper_dirty(info, area->dx, area->dy,
			    area->width, area->height);
968 969 970 971 972 973 974 975 976 977 978 979 980 981
}
EXPORT_SYMBOL(drm_fb_helper_sys_copyarea);

/**
 * drm_fb_helper_sys_imageblit - wrapper around sys_imageblit
 * @info: fbdev registered by the helper
 * @image: info about image to blit
 *
 * A wrapper around sys_imageblit implemented by fbdev core
 */
void drm_fb_helper_sys_imageblit(struct fb_info *info,
				 const struct fb_image *image)
{
	sys_imageblit(info, image);
982 983
	drm_fb_helper_dirty(info, image->dx, image->dy,
			    image->width, image->height);
984 985 986 987 988 989 990 991 992 993 994 995 996 997
}
EXPORT_SYMBOL(drm_fb_helper_sys_imageblit);

/**
 * drm_fb_helper_cfb_fillrect - wrapper around cfb_fillrect
 * @info: fbdev registered by the helper
 * @rect: info about rectangle to fill
 *
 * A wrapper around cfb_imageblit implemented by fbdev core
 */
void drm_fb_helper_cfb_fillrect(struct fb_info *info,
				const struct fb_fillrect *rect)
{
	cfb_fillrect(info, rect);
998 999
	drm_fb_helper_dirty(info, rect->dx, rect->dy,
			    rect->width, rect->height);
1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013
}
EXPORT_SYMBOL(drm_fb_helper_cfb_fillrect);

/**
 * drm_fb_helper_cfb_copyarea - wrapper around cfb_copyarea
 * @info: fbdev registered by the helper
 * @area: info about area to copy
 *
 * A wrapper around cfb_copyarea implemented by fbdev core
 */
void drm_fb_helper_cfb_copyarea(struct fb_info *info,
				const struct fb_copyarea *area)
{
	cfb_copyarea(info, area);
1014 1015
	drm_fb_helper_dirty(info, area->dx, area->dy,
			    area->width, area->height);
1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029
}
EXPORT_SYMBOL(drm_fb_helper_cfb_copyarea);

/**
 * drm_fb_helper_cfb_imageblit - wrapper around cfb_imageblit
 * @info: fbdev registered by the helper
 * @image: info about image to blit
 *
 * A wrapper around cfb_imageblit implemented by fbdev core
 */
void drm_fb_helper_cfb_imageblit(struct fb_info *info,
				 const struct fb_image *image)
{
	cfb_imageblit(info, image);
1030 1031
	drm_fb_helper_dirty(info, image->dx, image->dy,
			    image->width, image->height);
1032 1033 1034
}
EXPORT_SYMBOL(drm_fb_helper_cfb_imageblit);

1035 1036 1037
/**
 * drm_fb_helper_set_suspend - wrapper around fb_set_suspend
 * @fb_helper: driver-allocated fbdev helper
1038
 * @suspend: whether to suspend or resume
1039
 *
1040 1041 1042
 * A wrapper around fb_set_suspend implemented by fbdev core.
 * Use drm_fb_helper_set_suspend_unlocked() if you don't need to take
 * the lock yourself
1043
 */
1044
void drm_fb_helper_set_suspend(struct drm_fb_helper *fb_helper, bool suspend)
1045 1046
{
	if (fb_helper && fb_helper->fbdev)
1047
		fb_set_suspend(fb_helper->fbdev, suspend);
1048 1049 1050
}
EXPORT_SYMBOL(drm_fb_helper_set_suspend);

1051 1052 1053 1054
/**
 * drm_fb_helper_set_suspend_unlocked - wrapper around fb_set_suspend that also
 *                                      takes the console lock
 * @fb_helper: driver-allocated fbdev helper
1055
 * @suspend: whether to suspend or resume
1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067
 *
 * A wrapper around fb_set_suspend() that takes the console lock. If the lock
 * isn't available on resume, a worker is tasked with waiting for the lock
 * to become available. The console lock can be pretty contented on resume
 * due to all the printk activity.
 *
 * This function can be called multiple times with the same state since
 * &fb_info->state is checked to see if fbdev is running or not before locking.
 *
 * Use drm_fb_helper_set_suspend() if you need to take the lock yourself.
 */
void drm_fb_helper_set_suspend_unlocked(struct drm_fb_helper *fb_helper,
1068
					bool suspend)
1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096
{
	if (!fb_helper || !fb_helper->fbdev)
		return;

	/* make sure there's no pending/ongoing resume */
	flush_work(&fb_helper->resume_work);

	if (suspend) {
		if (fb_helper->fbdev->state != FBINFO_STATE_RUNNING)
			return;

		console_lock();

	} else {
		if (fb_helper->fbdev->state == FBINFO_STATE_RUNNING)
			return;

		if (!console_trylock()) {
			schedule_work(&fb_helper->resume_work);
			return;
		}
	}

	fb_set_suspend(fb_helper->fbdev, suspend);
	console_unlock();
}
EXPORT_SYMBOL(drm_fb_helper_set_suspend_unlocked);

1097
static int setcolreg(struct drm_crtc *crtc, u16 red, u16 green,
1098 1099 1100 1101 1102
		     u16 blue, u16 regno, struct fb_info *info)
{
	struct drm_fb_helper *fb_helper = info->par;
	struct drm_framebuffer *fb = fb_helper->fb;

1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115
	if (info->fix.visual == FB_VISUAL_TRUECOLOR) {
		u32 *palette;
		u32 value;
		/* place color in psuedopalette */
		if (regno > 16)
			return -EINVAL;
		palette = (u32 *)info->pseudo_palette;
		red >>= (16 - info->var.red.length);
		green >>= (16 - info->var.green.length);
		blue >>= (16 - info->var.blue.length);
		value = (red << info->var.red.offset) |
			(green << info->var.green.offset) |
			(blue << info->var.blue.offset);
1116 1117 1118 1119 1120
		if (info->var.transp.length > 0) {
			u32 mask = (1 << info->var.transp.length) - 1;
			mask <<= info->var.transp.offset;
			value |= mask;
		}
1121 1122 1123 1124
		palette[regno] = value;
		return 0;
	}

1125 1126 1127 1128 1129 1130 1131 1132
	/*
	 * The driver really shouldn't advertise pseudo/directcolor
	 * visuals if it can't deal with the palette.
	 */
	if (WARN_ON(!fb_helper->funcs->gamma_set ||
		    !fb_helper->funcs->gamma_get))
		return -EINVAL;

1133
	WARN_ON(fb->bits_per_pixel != 8);
1134

1135
	fb_helper->funcs->gamma_set(crtc, red, green, blue, regno);
1136

1137
	return 0;
1138 1139
}

D
Daniel Vetter 已提交
1140 1141 1142 1143 1144
/**
 * drm_fb_helper_setcmap - implementation for ->fb_setcmap
 * @cmap: cmap to set
 * @info: fbdev registered by the helper
 */
1145 1146 1147
int drm_fb_helper_setcmap(struct fb_cmap *cmap, struct fb_info *info)
{
	struct drm_fb_helper *fb_helper = info->par;
1148
	struct drm_device *dev = fb_helper->dev;
1149
	const struct drm_crtc_helper_funcs *crtc_funcs;
1150 1151
	u16 *red, *green, *blue, *transp;
	struct drm_crtc *crtc;
R
roel 已提交
1152
	int i, j, rc = 0;
1153 1154
	int start;

1155
	if (oops_in_progress)
1156
		return -EBUSY;
1157 1158

	drm_modeset_lock_all(dev);
1159 1160 1161 1162 1163
	if (!drm_fb_helper_is_bound(fb_helper)) {
		drm_modeset_unlock_all(dev);
		return -EBUSY;
	}

1164 1165 1166
	for (i = 0; i < fb_helper->crtc_count; i++) {
		crtc = fb_helper->crtc_info[i].mode_set.crtc;
		crtc_funcs = crtc->helper_private;
1167 1168 1169 1170 1171 1172 1173

		red = cmap->red;
		green = cmap->green;
		blue = cmap->blue;
		transp = cmap->transp;
		start = cmap->start;

R
roel 已提交
1174
		for (j = 0; j < cmap->len; j++) {
1175 1176 1177 1178 1179 1180 1181 1182 1183
			u16 hred, hgreen, hblue, htransp = 0xffff;

			hred = *red++;
			hgreen = *green++;
			hblue = *blue++;

			if (transp)
				htransp = *transp++;

1184 1185
			rc = setcolreg(crtc, hred, hgreen, hblue, start++, info);
			if (rc)
1186
				goto out;
1187
		}
1188 1189
		if (crtc_funcs->load_lut)
			crtc_funcs->load_lut(crtc);
1190
	}
1191 1192
 out:
	drm_modeset_unlock_all(dev);
1193 1194 1195 1196
	return rc;
}
EXPORT_SYMBOL(drm_fb_helper_setcmap);

D
Daniel Vetter 已提交
1197 1198 1199 1200 1201
/**
 * drm_fb_helper_check_var - implementation for ->fb_check_var
 * @var: screeninfo to check
 * @info: fbdev registered by the helper
 */
1202 1203 1204 1205 1206 1207 1208
int drm_fb_helper_check_var(struct fb_var_screeninfo *var,
			    struct fb_info *info)
{
	struct drm_fb_helper *fb_helper = info->par;
	struct drm_framebuffer *fb = fb_helper->fb;
	int depth;

1209
	if (var->pixclock != 0 || in_dbg_master())
1210 1211
		return -EINVAL;

1212 1213 1214 1215 1216 1217 1218 1219
	/*
	 * Changes struct fb_var_screeninfo are currently not pushed back
	 * to KMS, hence fail if different settings are requested.
	 */
	if (var->bits_per_pixel != fb->bits_per_pixel ||
	    var->xres != fb->width || var->yres != fb->height ||
	    var->xres_virtual != fb->width || var->yres_virtual != fb->height) {
		DRM_DEBUG("fb userspace requested width/height/bpp different than current fb "
1220 1221 1222
			  "request %dx%d-%d (virtual %dx%d) > %dx%d-%d\n",
			  var->xres, var->yres, var->bits_per_pixel,
			  var->xres_virtual, var->yres_virtual,
1223
			  fb->width, fb->height, fb->bits_per_pixel);
1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296
		return -EINVAL;
	}

	switch (var->bits_per_pixel) {
	case 16:
		depth = (var->green.length == 6) ? 16 : 15;
		break;
	case 32:
		depth = (var->transp.length > 0) ? 32 : 24;
		break;
	default:
		depth = var->bits_per_pixel;
		break;
	}

	switch (depth) {
	case 8:
		var->red.offset = 0;
		var->green.offset = 0;
		var->blue.offset = 0;
		var->red.length = 8;
		var->green.length = 8;
		var->blue.length = 8;
		var->transp.length = 0;
		var->transp.offset = 0;
		break;
	case 15:
		var->red.offset = 10;
		var->green.offset = 5;
		var->blue.offset = 0;
		var->red.length = 5;
		var->green.length = 5;
		var->blue.length = 5;
		var->transp.length = 1;
		var->transp.offset = 15;
		break;
	case 16:
		var->red.offset = 11;
		var->green.offset = 5;
		var->blue.offset = 0;
		var->red.length = 5;
		var->green.length = 6;
		var->blue.length = 5;
		var->transp.length = 0;
		var->transp.offset = 0;
		break;
	case 24:
		var->red.offset = 16;
		var->green.offset = 8;
		var->blue.offset = 0;
		var->red.length = 8;
		var->green.length = 8;
		var->blue.length = 8;
		var->transp.length = 0;
		var->transp.offset = 0;
		break;
	case 32:
		var->red.offset = 16;
		var->green.offset = 8;
		var->blue.offset = 0;
		var->red.length = 8;
		var->green.length = 8;
		var->blue.length = 8;
		var->transp.length = 8;
		var->transp.offset = 24;
		break;
	default:
		return -EINVAL;
	}
	return 0;
}
EXPORT_SYMBOL(drm_fb_helper_check_var);

D
Daniel Vetter 已提交
1297 1298 1299 1300 1301 1302 1303 1304
/**
 * drm_fb_helper_set_par - implementation for ->fb_set_par
 * @info: fbdev registered by the helper
 *
 * This will let fbcon do the mode init and is called at initialization time by
 * the fbdev core when registering the driver, and later on through the hotplug
 * callback.
 */
1305 1306 1307 1308 1309
int drm_fb_helper_set_par(struct fb_info *info)
{
	struct drm_fb_helper *fb_helper = info->par;
	struct fb_var_screeninfo *var = &info->var;

1310 1311 1312
	if (oops_in_progress)
		return -EBUSY;

1313
	if (var->pixclock != 0) {
P
Pavel Roskin 已提交
1314
		DRM_ERROR("PIXEL CLOCK SET\n");
1315 1316 1317
		return -EINVAL;
	}

1318
	drm_fb_helper_restore_fbdev_mode_unlocked(fb_helper);
1319

1320 1321 1322 1323
	return 0;
}
EXPORT_SYMBOL(drm_fb_helper_set_par);

1324
static int pan_display_atomic(struct fb_var_screeninfo *var,
1325
			      struct fb_info *info)
1326 1327 1328 1329
{
	struct drm_fb_helper *fb_helper = info->par;
	struct drm_device *dev = fb_helper->dev;
	struct drm_atomic_state *state;
1330
	struct drm_plane *plane;
1331
	int i, ret;
1332
	unsigned plane_mask;
1333 1334 1335 1336 1337 1338 1339

	state = drm_atomic_state_alloc(dev);
	if (!state)
		return -ENOMEM;

	state->acquire_ctx = dev->mode_config.acquire_ctx;
retry:
1340
	plane_mask = 0;
1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351
	for(i = 0; i < fb_helper->crtc_count; i++) {
		struct drm_mode_set *mode_set;

		mode_set = &fb_helper->crtc_info[i].mode_set;

		mode_set->x = var->xoffset;
		mode_set->y = var->yoffset;

		ret = __drm_atomic_helper_set_config(mode_set, state);
		if (ret != 0)
			goto fail;
1352 1353

		plane = mode_set->crtc->primary;
1354
		plane_mask |= (1 << drm_plane_index(plane));
1355
		plane->old_fb = plane->fb;
1356 1357 1358 1359 1360 1361 1362 1363 1364 1365
	}

	ret = drm_atomic_commit(state);
	if (ret != 0)
		goto fail;

	info->var.xoffset = var->xoffset;
	info->var.yoffset = var->yoffset;

fail:
1366
	drm_atomic_clean_old_fb(dev, plane_mask, ret);
1367

1368 1369 1370
	if (ret == -EDEADLK)
		goto backoff;

1371
	drm_atomic_state_put(state);
1372 1373 1374 1375 1376 1377 1378 1379 1380
	return ret;

backoff:
	drm_atomic_state_clear(state);
	drm_atomic_legacy_backoff(state);

	goto retry;
}

D
Daniel Vetter 已提交
1381 1382 1383 1384 1385
/**
 * drm_fb_helper_pan_display - implementation for ->fb_pan_display
 * @var: updated screen information
 * @info: fbdev registered by the helper
 */
1386 1387 1388 1389 1390 1391 1392 1393 1394
int drm_fb_helper_pan_display(struct fb_var_screeninfo *var,
			      struct fb_info *info)
{
	struct drm_fb_helper *fb_helper = info->par;
	struct drm_device *dev = fb_helper->dev;
	struct drm_mode_set *modeset;
	int ret = 0;
	int i;

1395
	if (oops_in_progress)
1396
		return -EBUSY;
1397 1398

	drm_modeset_lock_all(dev);
1399 1400 1401 1402 1403
	if (!drm_fb_helper_is_bound(fb_helper)) {
		drm_modeset_unlock_all(dev);
		return -EBUSY;
	}

1404
	if (dev->mode_config.funcs->atomic_commit) {
1405 1406 1407 1408
		ret = pan_display_atomic(var, info);
		goto unlock;
	}

1409
	for (i = 0; i < fb_helper->crtc_count; i++) {
1410 1411 1412 1413 1414 1415
		modeset = &fb_helper->crtc_info[i].mode_set;

		modeset->x = var->xoffset;
		modeset->y = var->yoffset;

		if (modeset->num_connectors) {
1416
			ret = drm_mode_set_config_internal(modeset);
1417 1418 1419 1420 1421 1422
			if (!ret) {
				info->var.xoffset = var->xoffset;
				info->var.yoffset = var->yoffset;
			}
		}
	}
1423
unlock:
1424
	drm_modeset_unlock_all(dev);
1425 1426 1427 1428
	return ret;
}
EXPORT_SYMBOL(drm_fb_helper_pan_display);

1429
/*
D
Daniel Vetter 已提交
1430 1431 1432
 * Allocates the backing storage and sets up the fbdev info structure through
 * the ->fb_probe callback and then registers the fbdev and sets up the panic
 * notifier.
1433
 */
1434 1435
static int drm_fb_helper_single_fb_probe(struct drm_fb_helper *fb_helper,
					 int preferred_bpp)
1436
{
1437
	int ret = 0;
1438
	int crtc_count = 0;
1439
	int i;
1440
	struct fb_info *info;
1441
	struct drm_fb_helper_surface_size sizes;
1442
	int gamma_size = 0;
1443 1444 1445 1446 1447 1448

	memset(&sizes, 0, sizeof(struct drm_fb_helper_surface_size));
	sizes.surface_depth = 24;
	sizes.surface_bpp = 32;
	sizes.fb_width = (unsigned)-1;
	sizes.fb_height = (unsigned)-1;
1449

1450 1451
	/* if driver picks 8 or 16 by default use that
	   for both depth/bpp */
1452
	if (preferred_bpp != sizes.surface_bpp)
1453
		sizes.surface_depth = sizes.surface_bpp = preferred_bpp;
1454

1455
	/* first up get a count of crtcs now in use and new min/maxes width/heights */
1456 1457
	for (i = 0; i < fb_helper->connector_count; i++) {
		struct drm_fb_helper_connector *fb_helper_conn = fb_helper->connector_info[i];
1458
		struct drm_cmdline_mode *cmdline_mode;
1459

1460
		cmdline_mode = &fb_helper_conn->connector->cmdline_mode;
1461 1462 1463 1464

		if (cmdline_mode->bpp_specified) {
			switch (cmdline_mode->bpp) {
			case 8:
1465
				sizes.surface_depth = sizes.surface_bpp = 8;
1466 1467
				break;
			case 15:
1468 1469
				sizes.surface_depth = 15;
				sizes.surface_bpp = 16;
1470 1471
				break;
			case 16:
1472
				sizes.surface_depth = sizes.surface_bpp = 16;
1473 1474
				break;
			case 24:
1475
				sizes.surface_depth = sizes.surface_bpp = 24;
1476 1477
				break;
			case 32:
1478 1479
				sizes.surface_depth = 24;
				sizes.surface_bpp = 32;
1480 1481 1482 1483 1484 1485
				break;
			}
			break;
		}
	}

1486 1487 1488
	crtc_count = 0;
	for (i = 0; i < fb_helper->crtc_count; i++) {
		struct drm_display_mode *desired_mode;
1489 1490 1491 1492 1493 1494 1495
		struct drm_mode_set *mode_set;
		int x, y, j;
		/* in case of tile group, are we the last tile vert or horiz?
		 * If no tile group you are always the last one both vertically
		 * and horizontally
		 */
		bool lastv = true, lasth = true;
R
Rob Clark 已提交
1496

1497
		desired_mode = fb_helper->crtc_info[i].desired_mode;
1498
		mode_set = &fb_helper->crtc_info[i].mode_set;
R
Rob Clark 已提交
1499 1500 1501 1502 1503 1504

		if (!desired_mode)
			continue;

		crtc_count++;

1505 1506
		x = fb_helper->crtc_info[i].x;
		y = fb_helper->crtc_info[i].y;
R
Rob Clark 已提交
1507 1508 1509 1510 1511 1512

		if (gamma_size == 0)
			gamma_size = fb_helper->crtc_info[i].mode_set.crtc->gamma_size;

		sizes.surface_width  = max_t(u32, desired_mode->hdisplay + x, sizes.surface_width);
		sizes.surface_height = max_t(u32, desired_mode->vdisplay + y, sizes.surface_height);
1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527

		for (j = 0; j < mode_set->num_connectors; j++) {
			struct drm_connector *connector = mode_set->connectors[j];
			if (connector->has_tile) {
				lasth = (connector->tile_h_loc == (connector->num_h_tile - 1));
				lastv = (connector->tile_v_loc == (connector->num_v_tile - 1));
				/* cloning to multiple tiles is just crazy-talk, so: */
				break;
			}
		}

		if (lasth)
			sizes.fb_width  = min_t(u32, desired_mode->hdisplay + x, sizes.fb_width);
		if (lastv)
			sizes.fb_height = min_t(u32, desired_mode->vdisplay + y, sizes.fb_height);
1528 1529
	}

1530
	if (crtc_count == 0 || sizes.fb_width == -1 || sizes.fb_height == -1) {
1531 1532
		/* hmm everyone went away - assume VGA cable just fell out
		   and will come back later. */
1533
		DRM_INFO("Cannot find any crtc or sizes - going 1024x768\n");
1534 1535
		sizes.fb_width = sizes.surface_width = 1024;
		sizes.fb_height = sizes.surface_height = 768;
1536 1537
	}

1538
	/* push down into drivers */
1539 1540 1541
	ret = (*fb_helper->funcs->fb_probe)(fb_helper, &sizes);
	if (ret < 0)
		return ret;
1542

1543
	info = fb_helper->fbdev;
1544

1545 1546 1547 1548 1549 1550 1551
	/*
	 * Set the fb pointer - usually drm_setup_crtcs does this for hotplug
	 * events, but at init time drm_setup_crtcs needs to be called before
	 * the fb is allocated (since we need to figure out the desired size of
	 * the fb before we can allocate it ...). Hence we need to fix things up
	 * here again.
	 */
1552
	for (i = 0; i < fb_helper->crtc_count; i++)
1553 1554 1555
		if (fb_helper->crtc_info[i].mode_set.num_connectors)
			fb_helper->crtc_info[i].mode_set.fb = fb_helper->fb;

1556

1557 1558 1559
	info->var.pixclock = 0;
	if (register_framebuffer(info) < 0)
		return -EINVAL;
1560

1561 1562
	dev_info(fb_helper->dev->dev, "fb%d: %s frame buffer device\n",
			info->node, info->fix.id);
1563 1564 1565 1566

	if (list_empty(&kernel_fb_helper_list)) {
		register_sysrq_key('v', &sysrq_drm_fb_helper_restore_op);
	}
1567 1568

	list_add(&fb_helper->kernel_fb_list, &kernel_fb_helper_list);
1569

1570 1571 1572
	return 0;
}

D
Daniel Vetter 已提交
1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585
/**
 * drm_fb_helper_fill_fix - initializes fixed fbdev information
 * @info: fbdev registered by the helper
 * @pitch: desired pitch
 * @depth: desired depth
 *
 * Helper to fill in the fixed fbdev information useful for a non-accelerated
 * fbdev emulations. Drivers which support acceleration methods which impose
 * additional constraints need to set up their own limits.
 *
 * Drivers should call this (or their equivalent setup code) from their
 * ->fb_probe callback.
 */
1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604
void drm_fb_helper_fill_fix(struct fb_info *info, uint32_t pitch,
			    uint32_t depth)
{
	info->fix.type = FB_TYPE_PACKED_PIXELS;
	info->fix.visual = depth == 8 ? FB_VISUAL_PSEUDOCOLOR :
		FB_VISUAL_TRUECOLOR;
	info->fix.mmio_start = 0;
	info->fix.mmio_len = 0;
	info->fix.type_aux = 0;
	info->fix.xpanstep = 1; /* doing it in hw */
	info->fix.ypanstep = 1; /* doing it in hw */
	info->fix.ywrapstep = 0;
	info->fix.accel = FB_ACCEL_NONE;

	info->fix.line_length = pitch;
	return;
}
EXPORT_SYMBOL(drm_fb_helper_fill_fix);

D
Daniel Vetter 已提交
1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618
/**
 * drm_fb_helper_fill_var - initalizes variable fbdev information
 * @info: fbdev instance to set up
 * @fb_helper: fb helper instance to use as template
 * @fb_width: desired fb width
 * @fb_height: desired fb height
 *
 * Sets up the variable fbdev metainformation from the given fb helper instance
 * and the drm framebuffer allocated in fb_helper->fb.
 *
 * Drivers should call this (or their equivalent setup code) from their
 * ->fb_probe callback after having allocated the fbdev backing
 * storage framebuffer.
 */
1619
void drm_fb_helper_fill_var(struct fb_info *info, struct drm_fb_helper *fb_helper,
1620 1621
			    uint32_t fb_width, uint32_t fb_height)
{
1622 1623
	struct drm_framebuffer *fb = fb_helper->fb;
	info->pseudo_palette = fb_helper->pseudo_palette;
1624 1625 1626
	info->var.xres_virtual = fb->width;
	info->var.yres_virtual = fb->height;
	info->var.bits_per_pixel = fb->bits_per_pixel;
1627
	info->var.accel_flags = FB_ACCELF_TEXT;
1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691
	info->var.xoffset = 0;
	info->var.yoffset = 0;
	info->var.activate = FB_ACTIVATE_NOW;
	info->var.height = -1;
	info->var.width = -1;

	switch (fb->depth) {
	case 8:
		info->var.red.offset = 0;
		info->var.green.offset = 0;
		info->var.blue.offset = 0;
		info->var.red.length = 8; /* 8bit DAC */
		info->var.green.length = 8;
		info->var.blue.length = 8;
		info->var.transp.offset = 0;
		info->var.transp.length = 0;
		break;
	case 15:
		info->var.red.offset = 10;
		info->var.green.offset = 5;
		info->var.blue.offset = 0;
		info->var.red.length = 5;
		info->var.green.length = 5;
		info->var.blue.length = 5;
		info->var.transp.offset = 15;
		info->var.transp.length = 1;
		break;
	case 16:
		info->var.red.offset = 11;
		info->var.green.offset = 5;
		info->var.blue.offset = 0;
		info->var.red.length = 5;
		info->var.green.length = 6;
		info->var.blue.length = 5;
		info->var.transp.offset = 0;
		break;
	case 24:
		info->var.red.offset = 16;
		info->var.green.offset = 8;
		info->var.blue.offset = 0;
		info->var.red.length = 8;
		info->var.green.length = 8;
		info->var.blue.length = 8;
		info->var.transp.offset = 0;
		info->var.transp.length = 0;
		break;
	case 32:
		info->var.red.offset = 16;
		info->var.green.offset = 8;
		info->var.blue.offset = 0;
		info->var.red.length = 8;
		info->var.green.length = 8;
		info->var.blue.length = 8;
		info->var.transp.offset = 24;
		info->var.transp.length = 8;
		break;
	default:
		break;
	}

	info->var.xres = fb_width;
	info->var.yres = fb_height;
}
EXPORT_SYMBOL(drm_fb_helper_fill_var);
1692

1693 1694 1695
static int drm_fb_helper_probe_connector_modes(struct drm_fb_helper *fb_helper,
					       uint32_t maxX,
					       uint32_t maxY)
1696 1697 1698
{
	struct drm_connector *connector;
	int count = 0;
1699
	int i;
1700

1701 1702
	for (i = 0; i < fb_helper->connector_count; i++) {
		connector = fb_helper->connector_info[i]->connector;
1703 1704 1705 1706 1707 1708
		count += connector->funcs->fill_modes(connector, maxX, maxY);
	}

	return count;
}

1709
struct drm_display_mode *drm_has_preferred_mode(struct drm_fb_helper_connector *fb_connector, int width, int height)
1710 1711 1712
{
	struct drm_display_mode *mode;

1713
	list_for_each_entry(mode, &fb_connector->connector->modes, head) {
1714 1715
		if (mode->hdisplay > width ||
		    mode->vdisplay > height)
1716 1717 1718 1719 1720 1721
			continue;
		if (mode->type & DRM_MODE_TYPE_PREFERRED)
			return mode;
	}
	return NULL;
}
1722
EXPORT_SYMBOL(drm_has_preferred_mode);
1723

1724
static bool drm_has_cmdline_mode(struct drm_fb_helper_connector *fb_connector)
1725
{
1726
	return fb_connector->connector->cmdline_mode.specified;
1727 1728
}

1729
struct drm_display_mode *drm_pick_cmdline_mode(struct drm_fb_helper_connector *fb_helper_conn,
1730
						      int width, int height)
1731
{
1732
	struct drm_cmdline_mode *cmdline_mode;
1733
	struct drm_display_mode *mode;
1734
	bool prefer_non_interlace;
1735

1736
	cmdline_mode = &fb_helper_conn->connector->cmdline_mode;
1737
	if (cmdline_mode->specified == false)
1738
		return NULL;
1739 1740 1741 1742 1743 1744 1745

	/* attempt to find a matching mode in the list of modes
	 *  we have gotten so far, if not add a CVT mode that conforms
	 */
	if (cmdline_mode->rb || cmdline_mode->margins)
		goto create_mode;

1746
	prefer_non_interlace = !cmdline_mode->interlace;
1747
again:
1748
	list_for_each_entry(mode, &fb_helper_conn->connector->modes, head) {
1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761
		/* check width/height */
		if (mode->hdisplay != cmdline_mode->xres ||
		    mode->vdisplay != cmdline_mode->yres)
			continue;

		if (cmdline_mode->refresh_specified) {
			if (mode->vrefresh != cmdline_mode->refresh)
				continue;
		}

		if (cmdline_mode->interlace) {
			if (!(mode->flags & DRM_MODE_FLAG_INTERLACE))
				continue;
1762 1763 1764
		} else if (prefer_non_interlace) {
			if (mode->flags & DRM_MODE_FLAG_INTERLACE)
				continue;
1765 1766 1767 1768
		}
		return mode;
	}

1769 1770 1771 1772 1773
	if (prefer_non_interlace) {
		prefer_non_interlace = false;
		goto again;
	}

1774
create_mode:
1775 1776
	mode = drm_mode_create_from_cmdline_mode(fb_helper_conn->connector->dev,
						 cmdline_mode);
1777
	list_add(&mode->head, &fb_helper_conn->connector->modes);
1778 1779
	return mode;
}
1780
EXPORT_SYMBOL(drm_pick_cmdline_mode);
1781 1782 1783 1784 1785

static bool drm_connector_enabled(struct drm_connector *connector, bool strict)
{
	bool enable;

1786
	if (strict)
1787
		enable = connector->status == connector_status_connected;
1788
	else
1789
		enable = connector->status != connector_status_disconnected;
1790

1791 1792 1793
	return enable;
}

1794 1795
static void drm_enable_connectors(struct drm_fb_helper *fb_helper,
				  bool *enabled)
1796 1797 1798 1799 1800
{
	bool any_enabled = false;
	struct drm_connector *connector;
	int i = 0;

1801 1802
	for (i = 0; i < fb_helper->connector_count; i++) {
		connector = fb_helper->connector_info[i]->connector;
1803 1804 1805 1806 1807 1808 1809 1810 1811
		enabled[i] = drm_connector_enabled(connector, true);
		DRM_DEBUG_KMS("connector %d enabled? %s\n", connector->base.id,
			  enabled[i] ? "yes" : "no");
		any_enabled |= enabled[i];
	}

	if (any_enabled)
		return;

1812 1813
	for (i = 0; i < fb_helper->connector_count; i++) {
		connector = fb_helper->connector_info[i]->connector;
1814 1815 1816 1817
		enabled[i] = drm_connector_enabled(connector, false);
	}
}

D
Dave Airlie 已提交
1818 1819
static bool drm_target_cloned(struct drm_fb_helper *fb_helper,
			      struct drm_display_mode **modes,
1820
			      struct drm_fb_offset *offsets,
D
Dave Airlie 已提交
1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867
			      bool *enabled, int width, int height)
{
	int count, i, j;
	bool can_clone = false;
	struct drm_fb_helper_connector *fb_helper_conn;
	struct drm_display_mode *dmt_mode, *mode;

	/* only contemplate cloning in the single crtc case */
	if (fb_helper->crtc_count > 1)
		return false;

	count = 0;
	for (i = 0; i < fb_helper->connector_count; i++) {
		if (enabled[i])
			count++;
	}

	/* only contemplate cloning if more than one connector is enabled */
	if (count <= 1)
		return false;

	/* check the command line or if nothing common pick 1024x768 */
	can_clone = true;
	for (i = 0; i < fb_helper->connector_count; i++) {
		if (!enabled[i])
			continue;
		fb_helper_conn = fb_helper->connector_info[i];
		modes[i] = drm_pick_cmdline_mode(fb_helper_conn, width, height);
		if (!modes[i]) {
			can_clone = false;
			break;
		}
		for (j = 0; j < i; j++) {
			if (!enabled[j])
				continue;
			if (!drm_mode_equal(modes[j], modes[i]))
				can_clone = false;
		}
	}

	if (can_clone) {
		DRM_DEBUG_KMS("can clone using command line\n");
		return true;
	}

	/* try and find a 1024x768 mode on each connector */
	can_clone = true;
1868
	dmt_mode = drm_mode_find_dmt(fb_helper->dev, 1024, 768, 60, false);
D
Dave Airlie 已提交
1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891

	for (i = 0; i < fb_helper->connector_count; i++) {

		if (!enabled[i])
			continue;

		fb_helper_conn = fb_helper->connector_info[i];
		list_for_each_entry(mode, &fb_helper_conn->connector->modes, head) {
			if (drm_mode_equal(mode, dmt_mode))
				modes[i] = mode;
		}
		if (!modes[i])
			can_clone = false;
	}

	if (can_clone) {
		DRM_DEBUG_KMS("can clone using 1024x768\n");
		return true;
	}
	DRM_INFO("kms: can't enable cloning when we probably wanted to.\n");
	return false;
}

1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923
static int drm_get_tile_offsets(struct drm_fb_helper *fb_helper,
				struct drm_display_mode **modes,
				struct drm_fb_offset *offsets,
				int idx,
				int h_idx, int v_idx)
{
	struct drm_fb_helper_connector *fb_helper_conn;
	int i;
	int hoffset = 0, voffset = 0;

	for (i = 0; i < fb_helper->connector_count; i++) {
		fb_helper_conn = fb_helper->connector_info[i];
		if (!fb_helper_conn->connector->has_tile)
			continue;

		if (!modes[i] && (h_idx || v_idx)) {
			DRM_DEBUG_KMS("no modes for connector tiled %d %d\n", i,
				      fb_helper_conn->connector->base.id);
			continue;
		}
		if (fb_helper_conn->connector->tile_h_loc < h_idx)
			hoffset += modes[i]->hdisplay;

		if (fb_helper_conn->connector->tile_v_loc < v_idx)
			voffset += modes[i]->vdisplay;
	}
	offsets[idx].x = hoffset;
	offsets[idx].y = voffset;
	DRM_DEBUG_KMS("returned %d %d for %d %d\n", hoffset, voffset, h_idx, v_idx);
	return 0;
}

1924
static bool drm_target_preferred(struct drm_fb_helper *fb_helper,
1925
				 struct drm_display_mode **modes,
1926
				 struct drm_fb_offset *offsets,
1927 1928
				 bool *enabled, int width, int height)
{
1929 1930
	struct drm_fb_helper_connector *fb_helper_conn;
	int i;
1931 1932 1933 1934
	uint64_t conn_configured = 0, mask;
	int tile_pass = 0;
	mask = (1 << fb_helper->connector_count) - 1;
retry:
1935 1936
	for (i = 0; i < fb_helper->connector_count; i++) {
		fb_helper_conn = fb_helper->connector_info[i];
1937

1938 1939 1940 1941 1942 1943 1944 1945 1946 1947
		if (conn_configured & (1 << i))
			continue;

		if (enabled[i] == false) {
			conn_configured |= (1 << i);
			continue;
		}

		/* first pass over all the untiled connectors */
		if (tile_pass == 0 && fb_helper_conn->connector->has_tile)
1948 1949
			continue;

1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965
		if (tile_pass == 1) {
			if (fb_helper_conn->connector->tile_h_loc != 0 ||
			    fb_helper_conn->connector->tile_v_loc != 0)
				continue;

		} else {
			if (fb_helper_conn->connector->tile_h_loc != tile_pass -1 &&
			    fb_helper_conn->connector->tile_v_loc != tile_pass - 1)
			/* if this tile_pass doesn't cover any of the tiles - keep going */
				continue;

			/* find the tile offsets for this pass - need
			   to find all tiles left and above */
			drm_get_tile_offsets(fb_helper, modes, offsets,
					     i, fb_helper_conn->connector->tile_h_loc, fb_helper_conn->connector->tile_v_loc);
		}
1966
		DRM_DEBUG_KMS("looking for cmdline mode on connector %d\n",
1967
			      fb_helper_conn->connector->base.id);
1968 1969

		/* got for command line mode first */
1970
		modes[i] = drm_pick_cmdline_mode(fb_helper_conn, width, height);
1971
		if (!modes[i]) {
1972 1973
			DRM_DEBUG_KMS("looking for preferred mode on connector %d %d\n",
				      fb_helper_conn->connector->base.id, fb_helper_conn->connector->tile_group ? fb_helper_conn->connector->tile_group->id : 0);
1974
			modes[i] = drm_has_preferred_mode(fb_helper_conn, width, height);
1975 1976
		}
		/* No preferred modes, pick one off the list */
1977 1978
		if (!modes[i] && !list_empty(&fb_helper_conn->connector->modes)) {
			list_for_each_entry(modes[i], &fb_helper_conn->connector->modes, head)
1979 1980 1981 1982
				break;
		}
		DRM_DEBUG_KMS("found mode %s\n", modes[i] ? modes[i]->name :
			  "none");
1983 1984 1985 1986 1987 1988
		conn_configured |= (1 << i);
	}

	if ((conn_configured & mask) != mask) {
		tile_pass++;
		goto retry;
1989 1990 1991 1992
	}
	return true;
}

1993 1994
static int drm_pick_crtcs(struct drm_fb_helper *fb_helper,
			  struct drm_fb_helper_crtc **best_crtcs,
1995 1996 1997 1998 1999
			  struct drm_display_mode **modes,
			  int n, int width, int height)
{
	int c, o;
	struct drm_connector *connector;
2000
	const struct drm_connector_helper_funcs *connector_funcs;
2001 2002
	struct drm_encoder *encoder;
	int my_score, best_score, score;
2003
	struct drm_fb_helper_crtc **crtcs, *crtc;
2004
	struct drm_fb_helper_connector *fb_helper_conn;
2005

2006
	if (n == fb_helper->connector_count)
2007
		return 0;
2008 2009 2010

	fb_helper_conn = fb_helper->connector_info[n];
	connector = fb_helper_conn->connector;
2011 2012

	best_crtcs[n] = NULL;
2013
	best_score = drm_pick_crtcs(fb_helper, best_crtcs, modes, n+1, width, height);
2014 2015 2016
	if (modes[n] == NULL)
		return best_score;

2017
	crtcs = kzalloc(fb_helper->connector_count *
2018
			sizeof(struct drm_fb_helper_crtc *), GFP_KERNEL);
2019 2020 2021 2022 2023 2024
	if (!crtcs)
		return best_score;

	my_score = 1;
	if (connector->status == connector_status_connected)
		my_score++;
2025
	if (drm_has_cmdline_mode(fb_helper_conn))
2026
		my_score++;
2027
	if (drm_has_preferred_mode(fb_helper_conn, width, height))
2028 2029 2030
		my_score++;

	connector_funcs = connector->helper_private;
2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042

	/*
	 * If the DRM device implements atomic hooks and ->best_encoder() is
	 * NULL we fallback to the default drm_atomic_helper_best_encoder()
	 * helper.
	 */
	if (fb_helper->dev->mode_config.funcs->atomic_commit &&
	    !connector_funcs->best_encoder)
		encoder = drm_atomic_helper_best_encoder(connector);
	else
		encoder = connector_funcs->best_encoder(connector);

2043 2044 2045 2046 2047
	if (!encoder)
		goto out;

	/* select a crtc for this connector and then attempt to configure
	   remaining connectors */
2048 2049
	for (c = 0; c < fb_helper->crtc_count; c++) {
		crtc = &fb_helper->crtc_info[c];
2050

2051
		if ((encoder->possible_crtcs & (1 << c)) == 0)
2052 2053 2054 2055 2056 2057 2058
			continue;

		for (o = 0; o < n; o++)
			if (best_crtcs[o] == crtc)
				break;

		if (o < n) {
D
Dave Airlie 已提交
2059 2060 2061 2062 2063 2064
			/* ignore cloning unless only a single crtc */
			if (fb_helper->crtc_count > 1)
				continue;

			if (!drm_mode_equal(modes[o], modes[n]))
				continue;
2065 2066 2067
		}

		crtcs[n] = crtc;
2068 2069
		memcpy(crtcs, best_crtcs, n * sizeof(struct drm_fb_helper_crtc *));
		score = my_score + drm_pick_crtcs(fb_helper, crtcs, modes, n + 1,
2070 2071 2072 2073
						  width, height);
		if (score > best_score) {
			best_score = score;
			memcpy(best_crtcs, crtcs,
2074
			       fb_helper->connector_count *
2075
			       sizeof(struct drm_fb_helper_crtc *));
2076 2077 2078 2079 2080 2081 2082
		}
	}
out:
	kfree(crtcs);
	return best_score;
}

2083
static void drm_setup_crtcs(struct drm_fb_helper *fb_helper)
2084
{
2085 2086
	struct drm_device *dev = fb_helper->dev;
	struct drm_fb_helper_crtc **crtcs;
2087
	struct drm_display_mode **modes;
2088
	struct drm_fb_offset *offsets;
2089
	struct drm_mode_set *modeset;
2090 2091
	bool *enabled;
	int width, height;
2092
	int i;
2093 2094 2095 2096 2097 2098

	DRM_DEBUG_KMS("\n");

	width = dev->mode_config.max_width;
	height = dev->mode_config.max_height;

2099
	crtcs = kcalloc(fb_helper->connector_count,
2100
			sizeof(struct drm_fb_helper_crtc *), GFP_KERNEL);
2101
	modes = kcalloc(fb_helper->connector_count,
2102
			sizeof(struct drm_display_mode *), GFP_KERNEL);
2103
	offsets = kcalloc(fb_helper->connector_count,
2104
			  sizeof(struct drm_fb_offset), GFP_KERNEL);
2105
	enabled = kcalloc(fb_helper->connector_count,
2106
			  sizeof(bool), GFP_KERNEL);
2107
	if (!crtcs || !modes || !enabled || !offsets) {
2108 2109 2110 2111
		DRM_ERROR("Memory allocation failed\n");
		goto out;
	}

2112

2113
	drm_enable_connectors(fb_helper, enabled);
2114

2115 2116
	if (!(fb_helper->funcs->initial_config &&
	      fb_helper->funcs->initial_config(fb_helper, crtcs, modes,
2117
					       offsets,
2118
					       enabled, width, height))) {
2119 2120 2121
		memset(modes, 0, fb_helper->connector_count*sizeof(modes[0]));
		memset(crtcs, 0, fb_helper->connector_count*sizeof(crtcs[0]));
		memset(offsets, 0, fb_helper->connector_count*sizeof(offsets[0]));
2122

2123 2124 2125 2126
		if (!drm_target_cloned(fb_helper, modes, offsets,
				       enabled, width, height) &&
		    !drm_target_preferred(fb_helper, modes, offsets,
					  enabled, width, height))
D
Dave Airlie 已提交
2127
			DRM_ERROR("Unable to find initial modes\n");
2128

2129 2130
		DRM_DEBUG_KMS("picking CRTCs for %dx%d config\n",
			      width, height);
2131

2132 2133
		drm_pick_crtcs(fb_helper, crtcs, modes, 0, width, height);
	}
2134 2135 2136 2137 2138 2139

	/* need to set the modesets up here for use later */
	/* fill out the connector<->crtc mappings into the modesets */
	for (i = 0; i < fb_helper->crtc_count; i++) {
		modeset = &fb_helper->crtc_info[i].mode_set;
		modeset->num_connectors = 0;
2140
		modeset->fb = NULL;
2141
	}
2142

2143
	for (i = 0; i < fb_helper->connector_count; i++) {
2144
		struct drm_display_mode *mode = modes[i];
2145
		struct drm_fb_helper_crtc *fb_crtc = crtcs[i];
2146
		struct drm_fb_offset *offset = &offsets[i];
2147
		modeset = &fb_crtc->mode_set;
2148

2149
		if (mode && fb_crtc) {
2150 2151
			DRM_DEBUG_KMS("desired mode %s set on crtc %d (%d,%d)\n",
				      mode->name, fb_crtc->mode_set.crtc->base.id, offset->x, offset->y);
2152
			fb_crtc->desired_mode = mode;
2153 2154
			fb_crtc->x = offset->x;
			fb_crtc->y = offset->y;
2155 2156 2157 2158
			if (modeset->mode)
				drm_mode_destroy(dev, modeset->mode);
			modeset->mode = drm_mode_duplicate(dev,
							   fb_crtc->desired_mode);
2159
			modeset->connectors[modeset->num_connectors++] = fb_helper->connector_info[i]->connector;
2160
			modeset->fb = fb_helper->fb;
2161 2162
			modeset->x = offset->x;
			modeset->y = offset->y;
2163 2164 2165
		}
	}

2166 2167 2168 2169 2170 2171 2172 2173 2174 2175
	/* Clear out any old modes if there are no more connected outputs. */
	for (i = 0; i < fb_helper->crtc_count; i++) {
		modeset = &fb_helper->crtc_info[i].mode_set;
		if (modeset->num_connectors == 0) {
			BUG_ON(modeset->fb);
			if (modeset->mode)
				drm_mode_destroy(dev, modeset->mode);
			modeset->mode = NULL;
		}
	}
2176
out:
2177 2178
	kfree(crtcs);
	kfree(modes);
2179
	kfree(offsets);
2180 2181 2182 2183
	kfree(enabled);
}

/**
D
Daniel Vetter 已提交
2184
 * drm_fb_helper_initial_config - setup a sane initial connector configuration
2185 2186
 * @fb_helper: fb_helper device struct
 * @bpp_sel: bpp value to use for the framebuffer configuration
2187
 *
2188
 * Scans the CRTCs and connectors and tries to put together an initial setup.
2189 2190 2191
 * At the moment, this is a cloned configuration across all heads with
 * a new framebuffer object as the backing store.
 *
D
Daniel Vetter 已提交
2192 2193 2194 2195 2196 2197 2198 2199 2200
 * Note that this also registers the fbdev and so allows userspace to call into
 * the driver through the fbdev interfaces.
 *
 * This function will call down into the ->fb_probe callback to let
 * the driver allocate and initialize the fbdev info structure and the drm
 * framebuffer used to back the fbdev. drm_fb_helper_fill_var() and
 * drm_fb_helper_fill_fix() are provided as helpers to setup simple default
 * values for the fbdev info structure.
 *
2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217
 * HANG DEBUGGING:
 *
 * When you have fbcon support built-in or already loaded, this function will do
 * a full modeset to setup the fbdev console. Due to locking misdesign in the
 * VT/fbdev subsystem that entire modeset sequence has to be done while holding
 * console_lock. Until console_unlock is called no dmesg lines will be sent out
 * to consoles, not even serial console. This means when your driver crashes,
 * you will see absolutely nothing else but a system stuck in this function,
 * with no further output. Any kind of printk() you place within your own driver
 * or in the drm core modeset code will also never show up.
 *
 * Standard debug practice is to run the fbcon setup without taking the
 * console_lock as a hack, to be able to see backtraces and crashes on the
 * serial line. This can be done by setting the fb.lockless_register_fb=1 kernel
 * cmdline option.
 *
 * The other option is to just disable fbdev emulation since very likely the
L
Lyude 已提交
2218 2219
 * first modeset from userspace will crash in the same way, and is even easier
 * to debug. This can be done by setting the drm_kms_helper.fbdev_emulation=0
2220 2221
 * kernel cmdline option.
 *
2222 2223 2224
 * RETURNS:
 * Zero if everything went ok, nonzero otherwise.
 */
2225
int drm_fb_helper_initial_config(struct drm_fb_helper *fb_helper, int bpp_sel)
2226
{
2227
	struct drm_device *dev = fb_helper->dev;
2228 2229
	int count = 0;

2230 2231 2232
	if (!drm_fbdev_emulation)
		return 0;

2233
	mutex_lock(&dev->mode_config.mutex);
2234 2235 2236
	count = drm_fb_helper_probe_connector_modes(fb_helper,
						    dev->mode_config.max_width,
						    dev->mode_config.max_height);
2237
	mutex_unlock(&dev->mode_config.mutex);
2238 2239 2240
	/*
	 * we shouldn't end up with no modes here.
	 */
2241
	if (count == 0)
2242
		dev_info(fb_helper->dev->dev, "No connectors reported connected with modes\n");
2243

2244
	drm_setup_crtcs(fb_helper);
2245

2246
	return drm_fb_helper_single_fb_probe(fb_helper, bpp_sel);
2247
}
2248
EXPORT_SYMBOL(drm_fb_helper_initial_config);
2249

2250 2251
/**
 * drm_fb_helper_hotplug_event - respond to a hotplug notification by
2252
 *                               probing all the outputs attached to the fb
2253 2254 2255
 * @fb_helper: the drm_fb_helper
 *
 * Scan the connectors attached to the fb_helper and try to put together a
2256
 * setup after notification of a change in output configuration.
2257
 *
D
Daniel Vetter 已提交
2258 2259 2260 2261 2262
 * Called at runtime, takes the mode config locks to be able to check/change the
 * modeset configuration. Must be run from process context (which usually means
 * either the output polling work or a work item launched from the driver's
 * hotplug interrupt).
 *
2263
 * Note that drivers may call this even before calling
L
Lyude 已提交
2264
 * drm_fb_helper_initial_config but only after drm_fb_helper_init. This allows
2265 2266
 * for a race-free fbcon setup and will make sure that the fbdev emulation will
 * not miss any hotplug events.
D
Daniel Vetter 已提交
2267
 *
2268 2269 2270 2271
 * RETURNS:
 * 0 on success and a non-zero error code otherwise.
 */
int drm_fb_helper_hotplug_event(struct drm_fb_helper *fb_helper)
2272
{
2273
	struct drm_device *dev = fb_helper->dev;
2274
	u32 max_width, max_height;
2275

2276 2277 2278
	if (!drm_fbdev_emulation)
		return 0;

2279
	mutex_lock(&fb_helper->dev->mode_config.mutex);
2280
	if (!fb_helper->fb || !drm_fb_helper_is_bound(fb_helper)) {
2281
		fb_helper->delayed_hotplug = true;
2282
		mutex_unlock(&fb_helper->dev->mode_config.mutex);
2283
		return 0;
2284
	}
2285
	DRM_DEBUG_KMS("\n");
2286

2287 2288
	max_width = fb_helper->fb->width;
	max_height = fb_helper->fb->height;
2289

2290
	drm_fb_helper_probe_connector_modes(fb_helper, max_width, max_height);
2291 2292 2293
	mutex_unlock(&fb_helper->dev->mode_config.mutex);

	drm_modeset_lock_all(dev);
2294
	drm_setup_crtcs(fb_helper);
2295
	drm_modeset_unlock_all(dev);
2296 2297 2298
	drm_fb_helper_set_par(fb_helper->fbdev);

	return 0;
2299
}
2300
EXPORT_SYMBOL(drm_fb_helper_hotplug_event);
2301

2302
/* The Kconfig DRM_KMS_HELPER selects FRAMEBUFFER_CONSOLE (if !EXPERT)
2303 2304 2305
 * but the module doesn't depend on any fb console symbols.  At least
 * attempt to load fbcon to avoid leaving the system without a usable console.
 */
2306
int __init drm_fb_helper_modinit(void)
2307
{
2308
#if defined(CONFIG_FRAMEBUFFER_CONSOLE_MODULE) && !defined(CONFIG_EXPERT)
2309 2310 2311 2312 2313 2314 2315 2316 2317
	const char *name = "fbcon";
	struct module *fbcon;

	mutex_lock(&module_mutex);
	fbcon = find_module(name);
	mutex_unlock(&module_mutex);

	if (!fbcon)
		request_module_nowait(name);
2318
#endif
2319 2320
	return 0;
}
2321
EXPORT_SYMBOL(drm_fb_helper_modinit);