1/*
   2 * Copyright (c) 2006-2009 Red Hat Inc.
   3 * Copyright (c) 2006-2008 Intel Corporation
   4 * Copyright (c) 2007 Dave Airlie <airlied@linux.ie>
   5 *
   6 * DRM framebuffer helper functions
   7 *
   8 * Permission to use, copy, modify, distribute, and sell this software and its
   9 * documentation for any purpose is hereby granted without fee, provided that
  10 * the above copyright notice appear in all copies and that both that copyright
  11 * notice and this permission notice appear in supporting documentation, and
  12 * that the name of the copyright holders not be used in advertising or
  13 * publicity pertaining to distribution of the software without specific,
  14 * written prior permission.  The copyright holders make no representations
  15 * about the suitability of this software for any purpose.  It is provided "as
  16 * is" without express or implied warranty.
  17 *
  18 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  19 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  20 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  21 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  22 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  23 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  24 * OF THIS SOFTWARE.
  25 *
  26 * Authors:
  27 *      Dave Airlie <airlied@linux.ie>
  28 *      Jesse Barnes <jesse.barnes@intel.com>
  29 */
  30#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  31
  32#include <linux/console.h>
  33#include <linux/pci.h>
 
 
 
  34#include <linux/sysrq.h>
  35#include <linux/vga_switcheroo.h>
  36
  37#include <drm/drm_atomic.h>
 
 
  38#include <drm/drm_drv.h>
  39#include <drm/drm_fb_helper.h>
  40#include <drm/drm_fourcc.h>
  41#include <drm/drm_framebuffer.h>
  42#include <drm/drm_modeset_helper_vtables.h>
  43#include <drm/drm_print.h>
  44#include <drm/drm_vblank.h>
  45
 
  46#include "drm_internal.h"
  47#include "drm_crtc_internal.h"
  48
  49static bool drm_fbdev_emulation = true;
  50module_param_named(fbdev_emulation, drm_fbdev_emulation, bool, 0600);
  51MODULE_PARM_DESC(fbdev_emulation,
  52		 "Enable legacy fbdev emulation [default=true]");
  53
  54static int drm_fbdev_overalloc = CONFIG_DRM_FBDEV_OVERALLOC;
  55module_param(drm_fbdev_overalloc, int, 0444);
  56MODULE_PARM_DESC(drm_fbdev_overalloc,
  57		 "Overallocation of the fbdev buffer (%) [default="
  58		 __MODULE_STRING(CONFIG_DRM_FBDEV_OVERALLOC) "]");
  59
  60/*
  61 * In order to keep user-space compatibility, we want in certain use-cases
  62 * to keep leaking the fbdev physical address to the user-space program
  63 * handling the fbdev buffer.
  64 *
  65 * This is a bad habit, essentially kept to support closed-source OpenGL
  66 * drivers that should really be moved into open-source upstream projects
  67 * instead of using legacy physical addresses in user space to communicate
  68 * with other out-of-tree kernel modules.
  69 *
  70 * This module_param *should* be removed as soon as possible and be
  71 * considered as a broken and legacy behaviour from a modern fbdev device.
  72 */
  73static bool drm_leak_fbdev_smem;
  74#if IS_ENABLED(CONFIG_DRM_FBDEV_LEAK_PHYS_SMEM)
 
  75module_param_unsafe(drm_leak_fbdev_smem, bool, 0600);
  76MODULE_PARM_DESC(drm_leak_fbdev_smem,
  77		 "Allow unsafe leaking fbdev physical smem address [default=false]");
  78#endif
  79
  80static LIST_HEAD(kernel_fb_helper_list);
  81static DEFINE_MUTEX(kernel_fb_helper_lock);
  82
  83/**
  84 * DOC: fbdev helpers
  85 *
  86 * The fb helper functions are useful to provide an fbdev on top of a drm kernel
  87 * mode setting driver. They can be used mostly independently from the crtc
  88 * helper functions used by many drivers to implement the kernel mode setting
  89 * interfaces. Drivers that use one of the shared memory managers, TTM, SHMEM,
  90 * DMA, should instead use the corresponding fbdev emulation.
 
 
 
 
 
 
 
 
 
 
  91 *
  92 * For suspend/resume consider using drm_mode_config_helper_suspend() and
  93 * drm_mode_config_helper_resume() which takes care of fbdev as well.
  94 *
  95 * All other functions exported by the fb helper library can be used to
  96 * implement the fbdev driver interface by the driver.
  97 *
  98 * It is possible, though perhaps somewhat tricky, to implement race-free
  99 * hotplug detection using the fbdev helpers. The drm_fb_helper_prepare()
 100 * helper must be called first to initialize the minimum required to make
 101 * hotplug detection work. Drivers also need to make sure to properly set up
 102 * the &drm_mode_config.funcs member. After calling drm_kms_helper_poll_init()
 103 * it is safe to enable interrupts and start processing hotplug events. At the
 104 * same time, drivers should initialize all modeset objects such as CRTCs,
 105 * encoders and connectors. To finish up the fbdev helper initialization, the
 106 * drm_fb_helper_init() function is called. To probe for all attached displays
 107 * and set up an initial configuration using the detected hardware, drivers
 108 * should call drm_fb_helper_initial_config().
 109 *
 110 * If &drm_framebuffer_funcs.dirty is set, the
 111 * drm_fb_helper_{cfb,sys}_{write,fillrect,copyarea,imageblit} functions will
 112 * accumulate changes and schedule &drm_fb_helper.dirty_work to run right
 113 * away. This worker then calls the dirty() function ensuring that it will
 114 * always run in process context since the fb_*() function could be running in
 115 * atomic context. If drm_fb_helper_deferred_io() is used as the deferred_io
 116 * callback it will also schedule dirty_work with the damage collected from the
 117 * mmap page writes.
 
 
 
 118 */
 119
 120static void drm_fb_helper_restore_lut_atomic(struct drm_crtc *crtc)
 121{
 122	uint16_t *r_base, *g_base, *b_base;
 123
 124	if (crtc->funcs->gamma_set == NULL)
 125		return;
 126
 127	r_base = crtc->gamma_store;
 128	g_base = r_base + crtc->gamma_size;
 129	b_base = g_base + crtc->gamma_size;
 130
 131	crtc->funcs->gamma_set(crtc, r_base, g_base, b_base,
 132			       crtc->gamma_size, NULL);
 133}
 134
 135/**
 136 * drm_fb_helper_debug_enter - implementation for &fb_ops.fb_debug_enter
 137 * @info: fbdev registered by the helper
 138 */
 139int drm_fb_helper_debug_enter(struct fb_info *info)
 140{
 141	struct drm_fb_helper *helper = info->par;
 142	const struct drm_crtc_helper_funcs *funcs;
 143	struct drm_mode_set *mode_set;
 144
 145	list_for_each_entry(helper, &kernel_fb_helper_list, kernel_fb_list) {
 146		mutex_lock(&helper->client.modeset_mutex);
 147		drm_client_for_each_modeset(mode_set, &helper->client) {
 148			if (!mode_set->crtc->enabled)
 149				continue;
 150
 151			funcs =	mode_set->crtc->helper_private;
 152			if (funcs->mode_set_base_atomic == NULL)
 153				continue;
 154
 155			if (drm_drv_uses_atomic_modeset(mode_set->crtc->dev))
 156				continue;
 157
 158			funcs->mode_set_base_atomic(mode_set->crtc,
 159						    mode_set->fb,
 160						    mode_set->x,
 161						    mode_set->y,
 162						    ENTER_ATOMIC_MODE_SET);
 163		}
 164		mutex_unlock(&helper->client.modeset_mutex);
 165	}
 166
 167	return 0;
 168}
 169EXPORT_SYMBOL(drm_fb_helper_debug_enter);
 170
 171/**
 172 * drm_fb_helper_debug_leave - implementation for &fb_ops.fb_debug_leave
 173 * @info: fbdev registered by the helper
 174 */
 175int drm_fb_helper_debug_leave(struct fb_info *info)
 176{
 177	struct drm_fb_helper *helper = info->par;
 178	struct drm_client_dev *client = &helper->client;
 179	struct drm_device *dev = helper->dev;
 180	struct drm_crtc *crtc;
 181	const struct drm_crtc_helper_funcs *funcs;
 182	struct drm_mode_set *mode_set;
 183	struct drm_framebuffer *fb;
 184
 185	mutex_lock(&client->modeset_mutex);
 186	drm_client_for_each_modeset(mode_set, client) {
 187		crtc = mode_set->crtc;
 188		if (drm_drv_uses_atomic_modeset(crtc->dev))
 189			continue;
 190
 191		funcs = crtc->helper_private;
 192		fb = crtc->primary->fb;
 193
 194		if (!crtc->enabled)
 195			continue;
 196
 197		if (!fb) {
 198			drm_err(dev, "no fb to restore?\n");
 199			continue;
 200		}
 201
 202		if (funcs->mode_set_base_atomic == NULL)
 203			continue;
 204
 205		drm_fb_helper_restore_lut_atomic(mode_set->crtc);
 206		funcs->mode_set_base_atomic(mode_set->crtc, fb, crtc->x,
 207					    crtc->y, LEAVE_ATOMIC_MODE_SET);
 208	}
 209	mutex_unlock(&client->modeset_mutex);
 210
 211	return 0;
 212}
 213EXPORT_SYMBOL(drm_fb_helper_debug_leave);
 214
 215static int
 216__drm_fb_helper_restore_fbdev_mode_unlocked(struct drm_fb_helper *fb_helper,
 217					    bool force)
 218{
 219	bool do_delayed;
 220	int ret;
 221
 222	if (!drm_fbdev_emulation || !fb_helper)
 223		return -ENODEV;
 224
 225	if (READ_ONCE(fb_helper->deferred_setup))
 226		return 0;
 227
 228	mutex_lock(&fb_helper->lock);
 229	if (force) {
 230		/*
 231		 * Yes this is the _locked version which expects the master lock
 232		 * to be held. But for forced restores we're intentionally
 233		 * racing here, see drm_fb_helper_set_par().
 234		 */
 235		ret = drm_client_modeset_commit_locked(&fb_helper->client);
 236	} else {
 237		ret = drm_client_modeset_commit(&fb_helper->client);
 238	}
 239
 240	do_delayed = fb_helper->delayed_hotplug;
 241	if (do_delayed)
 242		fb_helper->delayed_hotplug = false;
 243	mutex_unlock(&fb_helper->lock);
 244
 245	if (do_delayed)
 246		drm_fb_helper_hotplug_event(fb_helper);
 247
 248	return ret;
 249}
 250
 251/**
 252 * drm_fb_helper_restore_fbdev_mode_unlocked - restore fbdev configuration
 253 * @fb_helper: driver-allocated fbdev helper, can be NULL
 254 *
 255 * This helper should be called from fbdev emulation's &drm_client_funcs.restore
 256 * callback. It ensures that the user isn't greeted with a black screen when the
 257 * userspace compositor releases the display device.
 258 *
 259 * Returns:
 260 * 0 on success, or a negative errno code otherwise.
 261 */
 262int drm_fb_helper_restore_fbdev_mode_unlocked(struct drm_fb_helper *fb_helper)
 263{
 264	return __drm_fb_helper_restore_fbdev_mode_unlocked(fb_helper, false);
 265}
 266EXPORT_SYMBOL(drm_fb_helper_restore_fbdev_mode_unlocked);
 267
 268#ifdef CONFIG_MAGIC_SYSRQ
 269/* emergency restore, don't bother with error reporting */
 270static void drm_fb_helper_restore_work_fn(struct work_struct *ignored)
 271{
 272	struct drm_fb_helper *helper;
 273
 274	mutex_lock(&kernel_fb_helper_lock);
 275	list_for_each_entry(helper, &kernel_fb_helper_list, kernel_fb_list) {
 276		struct drm_device *dev = helper->dev;
 277
 278		if (dev->switch_power_state == DRM_SWITCH_POWER_OFF)
 279			continue;
 280
 281		mutex_lock(&helper->lock);
 282		drm_client_modeset_commit_locked(&helper->client);
 283		mutex_unlock(&helper->lock);
 284	}
 285	mutex_unlock(&kernel_fb_helper_lock);
 286}
 287
 288static DECLARE_WORK(drm_fb_helper_restore_work, drm_fb_helper_restore_work_fn);
 289
 290static void drm_fb_helper_sysrq(u8 dummy1)
 291{
 292	schedule_work(&drm_fb_helper_restore_work);
 293}
 294
 295static const struct sysrq_key_op sysrq_drm_fb_helper_restore_op = {
 296	.handler = drm_fb_helper_sysrq,
 297	.help_msg = "force-fb(v)",
 298	.action_msg = "Restore framebuffer console",
 299};
 300#else
 301static const struct sysrq_key_op sysrq_drm_fb_helper_restore_op = { };
 302#endif
 303
 304static void drm_fb_helper_dpms(struct fb_info *info, int dpms_mode)
 305{
 306	struct drm_fb_helper *fb_helper = info->par;
 307
 308	mutex_lock(&fb_helper->lock);
 309	drm_client_modeset_dpms(&fb_helper->client, dpms_mode);
 310	mutex_unlock(&fb_helper->lock);
 311}
 312
 313/**
 314 * drm_fb_helper_blank - implementation for &fb_ops.fb_blank
 315 * @blank: desired blanking state
 316 * @info: fbdev registered by the helper
 317 */
 318int drm_fb_helper_blank(int blank, struct fb_info *info)
 319{
 320	if (oops_in_progress)
 321		return -EBUSY;
 322
 323	switch (blank) {
 324	/* Display: On; HSync: On, VSync: On */
 325	case FB_BLANK_UNBLANK:
 326		drm_fb_helper_dpms(info, DRM_MODE_DPMS_ON);
 327		break;
 328	/* Display: Off; HSync: On, VSync: On */
 329	case FB_BLANK_NORMAL:
 330		drm_fb_helper_dpms(info, DRM_MODE_DPMS_STANDBY);
 331		break;
 332	/* Display: Off; HSync: Off, VSync: On */
 333	case FB_BLANK_HSYNC_SUSPEND:
 334		drm_fb_helper_dpms(info, DRM_MODE_DPMS_STANDBY);
 335		break;
 336	/* Display: Off; HSync: On, VSync: Off */
 337	case FB_BLANK_VSYNC_SUSPEND:
 338		drm_fb_helper_dpms(info, DRM_MODE_DPMS_SUSPEND);
 339		break;
 340	/* Display: Off; HSync: Off, VSync: Off */
 341	case FB_BLANK_POWERDOWN:
 342		drm_fb_helper_dpms(info, DRM_MODE_DPMS_OFF);
 343		break;
 344	}
 345	return 0;
 346}
 347EXPORT_SYMBOL(drm_fb_helper_blank);
 348
 349static void drm_fb_helper_resume_worker(struct work_struct *work)
 350{
 351	struct drm_fb_helper *helper = container_of(work, struct drm_fb_helper,
 352						    resume_work);
 353
 354	console_lock();
 355	fb_set_suspend(helper->info, 0);
 356	console_unlock();
 357}
 358
 359static void drm_fb_helper_fb_dirty(struct drm_fb_helper *helper)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 360{
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 361	struct drm_device *dev = helper->dev;
 362	struct drm_clip_rect *clip = &helper->damage_clip;
 363	struct drm_clip_rect clip_copy;
 364	unsigned long flags;
 365	int ret;
 366
 367	if (drm_WARN_ON_ONCE(dev, !helper->funcs->fb_dirty))
 368		return;
 369
 370	spin_lock_irqsave(&helper->damage_lock, flags);
 371	clip_copy = *clip;
 372	clip->x1 = clip->y1 = ~0;
 373	clip->x2 = clip->y2 = 0;
 374	spin_unlock_irqrestore(&helper->damage_lock, flags);
 375
 376	ret = helper->funcs->fb_dirty(helper, &clip_copy);
 377	if (ret)
 378		goto err;
 
 
 
 
 
 
 
 
 
 
 
 
 379
 380	return;
 381
 382err:
 383	/*
 384	 * Restore damage clip rectangle on errors. The next run
 385	 * of the damage worker will perform the update.
 386	 */
 387	spin_lock_irqsave(&helper->damage_lock, flags);
 388	clip->x1 = min_t(u32, clip->x1, clip_copy.x1);
 389	clip->y1 = min_t(u32, clip->y1, clip_copy.y1);
 390	clip->x2 = max_t(u32, clip->x2, clip_copy.x2);
 391	clip->y2 = max_t(u32, clip->y2, clip_copy.y2);
 392	spin_unlock_irqrestore(&helper->damage_lock, flags);
 393}
 394
 395static void drm_fb_helper_damage_work(struct work_struct *work)
 396{
 397	struct drm_fb_helper *helper = container_of(work, struct drm_fb_helper, damage_work);
 398
 399	drm_fb_helper_fb_dirty(helper);
 400}
 401
 402/**
 403 * drm_fb_helper_prepare - setup a drm_fb_helper structure
 404 * @dev: DRM device
 405 * @helper: driver-allocated fbdev helper structure to set up
 406 * @preferred_bpp: Preferred bits per pixel for the device.
 407 * @funcs: pointer to structure of functions associate with this helper
 408 *
 409 * Sets up the bare minimum to make the framebuffer helper usable. This is
 410 * useful to implement race-free initialization of the polling helpers.
 411 */
 412void drm_fb_helper_prepare(struct drm_device *dev, struct drm_fb_helper *helper,
 413			   unsigned int preferred_bpp,
 414			   const struct drm_fb_helper_funcs *funcs)
 415{
 416	/*
 417	 * Pick a preferred bpp of 32 if no value has been given. This
 418	 * will select XRGB8888 for the framebuffer formats. All drivers
 419	 * have to support XRGB8888 for backwards compatibility with legacy
 420	 * userspace, so it's the safe choice here.
 421	 *
 422	 * TODO: Replace struct drm_mode_config.preferred_depth and this
 423	 *       bpp value with a preferred format that is given as struct
 424	 *       drm_format_info. Then derive all other values from the
 425	 *       format.
 426	 */
 427	if (!preferred_bpp)
 428		preferred_bpp = 32;
 429
 430	INIT_LIST_HEAD(&helper->kernel_fb_list);
 431	spin_lock_init(&helper->damage_lock);
 432	INIT_WORK(&helper->resume_work, drm_fb_helper_resume_worker);
 433	INIT_WORK(&helper->damage_work, drm_fb_helper_damage_work);
 434	helper->damage_clip.x1 = helper->damage_clip.y1 = ~0;
 435	mutex_init(&helper->lock);
 436	helper->funcs = funcs;
 437	helper->dev = dev;
 438	helper->preferred_bpp = preferred_bpp;
 439}
 440EXPORT_SYMBOL(drm_fb_helper_prepare);
 441
 442/**
 443 * drm_fb_helper_unprepare - clean up a drm_fb_helper structure
 444 * @fb_helper: driver-allocated fbdev helper structure to set up
 445 *
 446 * Cleans up the framebuffer helper. Inverse of drm_fb_helper_prepare().
 447 */
 448void drm_fb_helper_unprepare(struct drm_fb_helper *fb_helper)
 449{
 450	mutex_destroy(&fb_helper->lock);
 451}
 452EXPORT_SYMBOL(drm_fb_helper_unprepare);
 453
 454/**
 455 * drm_fb_helper_init - initialize a &struct drm_fb_helper
 456 * @dev: drm device
 457 * @fb_helper: driver-allocated fbdev helper structure to initialize
 458 *
 459 * This allocates the structures for the fbdev helper with the given limits.
 460 * Note that this won't yet touch the hardware (through the driver interfaces)
 461 * nor register the fbdev. This is only done in drm_fb_helper_initial_config()
 462 * to allow driver writes more control over the exact init sequence.
 463 *
 464 * Drivers must call drm_fb_helper_prepare() before calling this function.
 465 *
 466 * RETURNS:
 467 * Zero if everything went ok, nonzero otherwise.
 468 */
 469int drm_fb_helper_init(struct drm_device *dev,
 470		       struct drm_fb_helper *fb_helper)
 471{
 472	int ret;
 473
 
 
 
 
 
 474	/*
 475	 * If this is not the generic fbdev client, initialize a drm_client
 476	 * without callbacks so we can use the modesets.
 477	 */
 478	if (!fb_helper->client.funcs) {
 479		ret = drm_client_init(dev, &fb_helper->client, "drm_fb_helper", NULL);
 480		if (ret)
 481			return ret;
 482	}
 483
 484	dev->fb_helper = fb_helper;
 485
 486	return 0;
 487}
 488EXPORT_SYMBOL(drm_fb_helper_init);
 489
 490/**
 491 * drm_fb_helper_alloc_info - allocate fb_info and some of its members
 492 * @fb_helper: driver-allocated fbdev helper
 493 *
 494 * A helper to alloc fb_info and the member cmap. Called by the driver
 495 * within the struct &drm_driver.fbdev_probe callback function. Drivers do
 496 * not need to release the allocated fb_info structure themselves, this is
 497 * automatically done when calling drm_fb_helper_fini().
 498 *
 499 * RETURNS:
 500 * fb_info pointer if things went okay, pointer containing error code
 501 * otherwise
 502 */
 503struct fb_info *drm_fb_helper_alloc_info(struct drm_fb_helper *fb_helper)
 504{
 505	struct device *dev = fb_helper->dev->dev;
 506	struct fb_info *info;
 507	int ret;
 508
 509	info = framebuffer_alloc(0, dev);
 510	if (!info)
 511		return ERR_PTR(-ENOMEM);
 512
 513	if (!drm_leak_fbdev_smem)
 514		info->flags |= FBINFO_HIDE_SMEM_START;
 515
 516	ret = fb_alloc_cmap(&info->cmap, 256, 0);
 517	if (ret)
 518		goto err_release;
 519
 520	fb_helper->info = info;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 521	info->skip_vt_switch = true;
 522
 523	info->skip_panic = drm_panic_is_enabled(fb_helper->dev);
 524	return info;
 525
 
 
 526err_release:
 527	framebuffer_release(info);
 528	return ERR_PTR(ret);
 529}
 530EXPORT_SYMBOL(drm_fb_helper_alloc_info);
 531
 532/**
 533 * drm_fb_helper_release_info - release fb_info and its members
 534 * @fb_helper: driver-allocated fbdev helper
 535 *
 536 * A helper to release fb_info and the member cmap.  Drivers do not
 537 * need to release the allocated fb_info structure themselves, this is
 538 * automatically done when calling drm_fb_helper_fini().
 539 */
 540void drm_fb_helper_release_info(struct drm_fb_helper *fb_helper)
 541{
 542	struct fb_info *info = fb_helper->info;
 543
 544	if (!info)
 545		return;
 546
 547	fb_helper->info = NULL;
 548
 549	if (info->cmap.len)
 550		fb_dealloc_cmap(&info->cmap);
 551	framebuffer_release(info);
 552}
 553EXPORT_SYMBOL(drm_fb_helper_release_info);
 554
 555/**
 556 * drm_fb_helper_unregister_info - unregister fb_info framebuffer device
 557 * @fb_helper: driver-allocated fbdev helper, must not be NULL
 558 *
 559 * A wrapper around unregister_framebuffer, to release the fb_info
 560 * framebuffer device. This must be called before releasing all resources for
 561 * @fb_helper by calling drm_fb_helper_fini().
 562 */
 563void drm_fb_helper_unregister_info(struct drm_fb_helper *fb_helper)
 564{
 565	struct fb_info *info = fb_helper->info;
 566	struct device *dev = info->device;
 567
 568	if (dev_is_pci(dev))
 569		vga_switcheroo_client_fb_set(to_pci_dev(dev), NULL);
 570	unregister_framebuffer(fb_helper->info);
 571}
 572EXPORT_SYMBOL(drm_fb_helper_unregister_info);
 573
 574/**
 575 * drm_fb_helper_fini - finialize a &struct drm_fb_helper
 576 * @fb_helper: driver-allocated fbdev helper, can be NULL
 577 *
 578 * This cleans up all remaining resources associated with @fb_helper.
 579 */
 580void drm_fb_helper_fini(struct drm_fb_helper *fb_helper)
 581{
 
 
 582	if (!fb_helper)
 583		return;
 584
 585	fb_helper->dev->fb_helper = NULL;
 586
 587	if (!drm_fbdev_emulation)
 588		return;
 589
 590	cancel_work_sync(&fb_helper->resume_work);
 591	cancel_work_sync(&fb_helper->damage_work);
 592
 593	drm_fb_helper_release_info(fb_helper);
 
 
 
 
 
 
 594
 595	mutex_lock(&kernel_fb_helper_lock);
 596	if (!list_empty(&fb_helper->kernel_fb_list)) {
 597		list_del(&fb_helper->kernel_fb_list);
 598		if (list_empty(&kernel_fb_helper_list))
 599			unregister_sysrq_key('v', &sysrq_drm_fb_helper_restore_op);
 600	}
 601	mutex_unlock(&kernel_fb_helper_lock);
 602
 
 
 603	if (!fb_helper->client.funcs)
 604		drm_client_release(&fb_helper->client);
 605}
 606EXPORT_SYMBOL(drm_fb_helper_fini);
 607
 608static void drm_fb_helper_add_damage_clip(struct drm_fb_helper *helper, u32 x, u32 y,
 609					  u32 width, u32 height)
 610{
 
 
 
 
 
 
 
 
 
 
 
 
 611	struct drm_clip_rect *clip = &helper->damage_clip;
 612	unsigned long flags;
 613
 
 
 
 614	spin_lock_irqsave(&helper->damage_lock, flags);
 615	clip->x1 = min_t(u32, clip->x1, x);
 616	clip->y1 = min_t(u32, clip->y1, y);
 617	clip->x2 = max_t(u32, clip->x2, x + width);
 618	clip->y2 = max_t(u32, clip->y2, y + height);
 619	spin_unlock_irqrestore(&helper->damage_lock, flags);
 
 
 620}
 621
 622static void drm_fb_helper_damage(struct drm_fb_helper *helper, u32 x, u32 y,
 623				 u32 width, u32 height)
 
 
 
 
 
 
 
 
 624{
 625	/*
 626	 * This function may be invoked by panic() to flush the frame
 627	 * buffer, where all CPUs except the panic CPU are stopped.
 628	 * During the following schedule_work(), the panic CPU needs
 629	 * the worker_pool lock, which might be held by a stopped CPU,
 630	 * causing schedule_work() and panic() to block. Return early on
 631	 * oops_in_progress to prevent this blocking.
 632	 */
 633	if (oops_in_progress)
 634		return;
 635
 636	drm_fb_helper_add_damage_clip(helper, x, y, width, height);
 637
 638	schedule_work(&helper->damage_work);
 
 
 
 
 
 639}
 
 640
 641/*
 642 * Convert memory region into area of scanlines and pixels per
 643 * scanline. The parameters off and len must not reach beyond
 644 * the end of the framebuffer.
 645 */
 646static void drm_fb_helper_memory_range_to_clip(struct fb_info *info, off_t off, size_t len,
 647					       struct drm_rect *clip)
 648{
 649	u32 line_length = info->fix.line_length;
 650	u32 fb_height = info->var.yres;
 651	off_t end = off + len;
 652	u32 x1 = 0;
 653	u32 y1 = off / line_length;
 654	u32 x2 = info->var.xres;
 655	u32 y2 = DIV_ROUND_UP(end, line_length);
 656
 657	/* Don't allow any of them beyond the bottom bound of display area */
 658	if (y1 > fb_height)
 659		y1 = fb_height;
 660	if (y2 > fb_height)
 661		y2 = fb_height;
 662
 663	if ((y2 - y1) == 1) {
 664		/*
 665		 * We've only written to a single scanline. Try to reduce
 666		 * the number of horizontal pixels that need an update.
 667		 */
 668		off_t bit_off = (off % line_length) * 8;
 669		off_t bit_end = (end % line_length) * 8;
 
 
 
 
 
 
 670
 671		x1 = bit_off / info->var.bits_per_pixel;
 672		x2 = DIV_ROUND_UP(bit_end, info->var.bits_per_pixel);
 673	}
 674
 675	drm_rect_init(clip, x1, y1, x2 - x1, y2 - y1);
 676}
 
 677
 678/* Don't use in new code. */
 679void drm_fb_helper_damage_range(struct fb_info *info, off_t off, size_t len)
 
 
 
 
 
 
 
 680{
 681	struct drm_fb_helper *fb_helper = info->par;
 682	struct drm_rect damage_area;
 683
 684	drm_fb_helper_memory_range_to_clip(info, off, len, &damage_area);
 685	drm_fb_helper_damage(fb_helper, damage_area.x1, damage_area.y1,
 686			     drm_rect_width(&damage_area),
 687			     drm_rect_height(&damage_area));
 688}
 689EXPORT_SYMBOL(drm_fb_helper_damage_range);
 690
 691/* Don't use in new code. */
 692void drm_fb_helper_damage_area(struct fb_info *info, u32 x, u32 y, u32 width, u32 height)
 
 
 
 
 
 
 
 693{
 694	struct drm_fb_helper *fb_helper = info->par;
 
 
 
 695
 696	drm_fb_helper_damage(fb_helper, x, y, width, height);
 
 
 
 
 
 
 
 
 
 
 
 697}
 698EXPORT_SYMBOL(drm_fb_helper_damage_area);
 699
 700#ifdef CONFIG_FB_DEFERRED_IO
 701/**
 702 * drm_fb_helper_deferred_io() - fbdev deferred_io callback function
 703 * @info: fb_info struct pointer
 704 * @pagereflist: list of mmap framebuffer pages that have to be flushed
 705 *
 706 * This function is used as the &fb_deferred_io.deferred_io
 707 * callback function for flushing the fbdev mmap writes.
 708 */
 709void drm_fb_helper_deferred_io(struct fb_info *info, struct list_head *pagereflist)
 
 710{
 711	struct drm_fb_helper *helper = info->par;
 712	unsigned long start, end, min_off, max_off, total_size;
 713	struct fb_deferred_io_pageref *pageref;
 714	struct drm_rect damage_area;
 715
 716	min_off = ULONG_MAX;
 717	max_off = 0;
 718	list_for_each_entry(pageref, pagereflist, list) {
 719		start = pageref->offset;
 720		end = start + PAGE_SIZE;
 721		min_off = min(min_off, start);
 722		max_off = max(max_off, end);
 723	}
 724
 725	/*
 726	 * As we can only track pages, we might reach beyond the end
 727	 * of the screen and account for non-existing scanlines. Hence,
 728	 * keep the covered memory area within the screen buffer.
 729	 */
 730	if (info->screen_size)
 731		total_size = info->screen_size;
 732	else
 733		total_size = info->fix.smem_len;
 734	max_off = min(max_off, total_size);
 
 
 
 
 735
 736	if (min_off < max_off) {
 737		drm_fb_helper_memory_range_to_clip(info, min_off, max_off - min_off, &damage_area);
 738		drm_fb_helper_damage(helper, damage_area.x1, damage_area.y1,
 739				     drm_rect_width(&damage_area),
 740				     drm_rect_height(&damage_area));
 741	}
 
 
 
 
 
 
 742}
 743EXPORT_SYMBOL(drm_fb_helper_deferred_io);
 744#endif
 745
 746/**
 747 * drm_fb_helper_set_suspend - wrapper around fb_set_suspend
 748 * @fb_helper: driver-allocated fbdev helper, can be NULL
 749 * @suspend: whether to suspend or resume
 750 *
 751 * A wrapper around fb_set_suspend implemented by fbdev core.
 752 * Use drm_fb_helper_set_suspend_unlocked() if you don't need to take
 753 * the lock yourself
 754 */
 755void drm_fb_helper_set_suspend(struct drm_fb_helper *fb_helper, bool suspend)
 756{
 757	if (fb_helper && fb_helper->info)
 758		fb_set_suspend(fb_helper->info, suspend);
 759}
 760EXPORT_SYMBOL(drm_fb_helper_set_suspend);
 761
 762/**
 763 * drm_fb_helper_set_suspend_unlocked - wrapper around fb_set_suspend that also
 764 *                                      takes the console lock
 765 * @fb_helper: driver-allocated fbdev helper, can be NULL
 766 * @suspend: whether to suspend or resume
 767 *
 768 * A wrapper around fb_set_suspend() that takes the console lock. If the lock
 769 * isn't available on resume, a worker is tasked with waiting for the lock
 770 * to become available. The console lock can be pretty contented on resume
 771 * due to all the printk activity.
 772 *
 773 * This function can be called multiple times with the same state since
 774 * &fb_info.state is checked to see if fbdev is running or not before locking.
 775 *
 776 * Use drm_fb_helper_set_suspend() if you need to take the lock yourself.
 777 */
 778void drm_fb_helper_set_suspend_unlocked(struct drm_fb_helper *fb_helper,
 779					bool suspend)
 780{
 781	if (!fb_helper || !fb_helper->info)
 782		return;
 783
 784	/* make sure there's no pending/ongoing resume */
 785	flush_work(&fb_helper->resume_work);
 786
 787	if (suspend) {
 788		if (fb_helper->info->state != FBINFO_STATE_RUNNING)
 789			return;
 790
 791		console_lock();
 792
 793	} else {
 794		if (fb_helper->info->state == FBINFO_STATE_RUNNING)
 795			return;
 796
 797		if (!console_trylock()) {
 798			schedule_work(&fb_helper->resume_work);
 799			return;
 800		}
 801	}
 802
 803	fb_set_suspend(fb_helper->info, suspend);
 804	console_unlock();
 805}
 806EXPORT_SYMBOL(drm_fb_helper_set_suspend_unlocked);
 807
 808static int setcmap_pseudo_palette(struct fb_cmap *cmap, struct fb_info *info)
 809{
 810	u32 *palette = (u32 *)info->pseudo_palette;
 811	int i;
 812
 813	if (cmap->start + cmap->len > 16)
 814		return -EINVAL;
 815
 816	for (i = 0; i < cmap->len; ++i) {
 817		u16 red = cmap->red[i];
 818		u16 green = cmap->green[i];
 819		u16 blue = cmap->blue[i];
 820		u32 value;
 821
 822		red >>= 16 - info->var.red.length;
 823		green >>= 16 - info->var.green.length;
 824		blue >>= 16 - info->var.blue.length;
 825		value = (red << info->var.red.offset) |
 826			(green << info->var.green.offset) |
 827			(blue << info->var.blue.offset);
 828		if (info->var.transp.length > 0) {
 829			u32 mask = (1 << info->var.transp.length) - 1;
 830
 831			mask <<= info->var.transp.offset;
 832			value |= mask;
 833		}
 834		palette[cmap->start + i] = value;
 835	}
 836
 837	return 0;
 838}
 839
 840static int setcmap_legacy(struct fb_cmap *cmap, struct fb_info *info)
 841{
 842	struct drm_fb_helper *fb_helper = info->par;
 843	struct drm_mode_set *modeset;
 844	struct drm_crtc *crtc;
 845	u16 *r, *g, *b;
 846	int ret = 0;
 847
 848	drm_modeset_lock_all(fb_helper->dev);
 849	drm_client_for_each_modeset(modeset, &fb_helper->client) {
 850		crtc = modeset->crtc;
 851		if (!crtc->funcs->gamma_set || !crtc->gamma_size) {
 852			ret = -EINVAL;
 853			goto out;
 854		}
 855
 856		if (cmap->start + cmap->len > crtc->gamma_size) {
 857			ret = -EINVAL;
 858			goto out;
 859		}
 860
 861		r = crtc->gamma_store;
 862		g = r + crtc->gamma_size;
 863		b = g + crtc->gamma_size;
 864
 865		memcpy(r + cmap->start, cmap->red, cmap->len * sizeof(*r));
 866		memcpy(g + cmap->start, cmap->green, cmap->len * sizeof(*g));
 867		memcpy(b + cmap->start, cmap->blue, cmap->len * sizeof(*b));
 868
 869		ret = crtc->funcs->gamma_set(crtc, r, g, b,
 870					     crtc->gamma_size, NULL);
 871		if (ret)
 872			goto out;
 873	}
 874out:
 875	drm_modeset_unlock_all(fb_helper->dev);
 876
 877	return ret;
 878}
 879
 880static struct drm_property_blob *setcmap_new_gamma_lut(struct drm_crtc *crtc,
 881						       struct fb_cmap *cmap)
 882{
 883	struct drm_device *dev = crtc->dev;
 884	struct drm_property_blob *gamma_lut;
 885	struct drm_color_lut *lut;
 886	int size = crtc->gamma_size;
 887	int i;
 888
 889	if (!size || cmap->start + cmap->len > size)
 890		return ERR_PTR(-EINVAL);
 891
 892	gamma_lut = drm_property_create_blob(dev, sizeof(*lut) * size, NULL);
 893	if (IS_ERR(gamma_lut))
 894		return gamma_lut;
 895
 896	lut = gamma_lut->data;
 897	if (cmap->start || cmap->len != size) {
 898		u16 *r = crtc->gamma_store;
 899		u16 *g = r + crtc->gamma_size;
 900		u16 *b = g + crtc->gamma_size;
 901
 902		for (i = 0; i < cmap->start; i++) {
 903			lut[i].red = r[i];
 904			lut[i].green = g[i];
 905			lut[i].blue = b[i];
 906		}
 907		for (i = cmap->start + cmap->len; i < size; i++) {
 908			lut[i].red = r[i];
 909			lut[i].green = g[i];
 910			lut[i].blue = b[i];
 911		}
 912	}
 913
 914	for (i = 0; i < cmap->len; i++) {
 915		lut[cmap->start + i].red = cmap->red[i];
 916		lut[cmap->start + i].green = cmap->green[i];
 917		lut[cmap->start + i].blue = cmap->blue[i];
 918	}
 919
 920	return gamma_lut;
 921}
 922
 923static int setcmap_atomic(struct fb_cmap *cmap, struct fb_info *info)
 924{
 925	struct drm_fb_helper *fb_helper = info->par;
 926	struct drm_device *dev = fb_helper->dev;
 927	struct drm_property_blob *gamma_lut = NULL;
 928	struct drm_modeset_acquire_ctx ctx;
 929	struct drm_crtc_state *crtc_state;
 930	struct drm_atomic_state *state;
 931	struct drm_mode_set *modeset;
 932	struct drm_crtc *crtc;
 933	u16 *r, *g, *b;
 934	bool replaced;
 935	int ret = 0;
 936
 937	drm_modeset_acquire_init(&ctx, 0);
 938
 939	state = drm_atomic_state_alloc(dev);
 940	if (!state) {
 941		ret = -ENOMEM;
 942		goto out_ctx;
 943	}
 944
 945	state->acquire_ctx = &ctx;
 946retry:
 947	drm_client_for_each_modeset(modeset, &fb_helper->client) {
 948		crtc = modeset->crtc;
 949
 950		if (!gamma_lut)
 951			gamma_lut = setcmap_new_gamma_lut(crtc, cmap);
 952		if (IS_ERR(gamma_lut)) {
 953			ret = PTR_ERR(gamma_lut);
 954			gamma_lut = NULL;
 955			goto out_state;
 956		}
 957
 958		crtc_state = drm_atomic_get_crtc_state(state, crtc);
 959		if (IS_ERR(crtc_state)) {
 960			ret = PTR_ERR(crtc_state);
 961			goto out_state;
 962		}
 963
 964		/*
 965		 * FIXME: This always uses gamma_lut. Some HW have only
 966		 * degamma_lut, in which case we should reset gamma_lut and set
 967		 * degamma_lut. See drm_crtc_legacy_gamma_set().
 968		 */
 969		replaced  = drm_property_replace_blob(&crtc_state->degamma_lut,
 970						      NULL);
 971		replaced |= drm_property_replace_blob(&crtc_state->ctm, NULL);
 972		replaced |= drm_property_replace_blob(&crtc_state->gamma_lut,
 973						      gamma_lut);
 974		crtc_state->color_mgmt_changed |= replaced;
 975	}
 976
 977	ret = drm_atomic_commit(state);
 978	if (ret)
 979		goto out_state;
 980
 981	drm_client_for_each_modeset(modeset, &fb_helper->client) {
 982		crtc = modeset->crtc;
 983
 984		r = crtc->gamma_store;
 985		g = r + crtc->gamma_size;
 986		b = g + crtc->gamma_size;
 987
 988		memcpy(r + cmap->start, cmap->red, cmap->len * sizeof(*r));
 989		memcpy(g + cmap->start, cmap->green, cmap->len * sizeof(*g));
 990		memcpy(b + cmap->start, cmap->blue, cmap->len * sizeof(*b));
 991	}
 992
 993out_state:
 994	if (ret == -EDEADLK)
 995		goto backoff;
 996
 997	drm_property_blob_put(gamma_lut);
 998	drm_atomic_state_put(state);
 999out_ctx:
1000	drm_modeset_drop_locks(&ctx);
1001	drm_modeset_acquire_fini(&ctx);
1002
1003	return ret;
1004
1005backoff:
1006	drm_atomic_state_clear(state);
1007	drm_modeset_backoff(&ctx);
1008	goto retry;
1009}
1010
1011/**
1012 * drm_fb_helper_setcmap - implementation for &fb_ops.fb_setcmap
1013 * @cmap: cmap to set
1014 * @info: fbdev registered by the helper
1015 */
1016int drm_fb_helper_setcmap(struct fb_cmap *cmap, struct fb_info *info)
1017{
1018	struct drm_fb_helper *fb_helper = info->par;
1019	struct drm_device *dev = fb_helper->dev;
1020	int ret;
1021
1022	if (oops_in_progress)
1023		return -EBUSY;
1024
1025	mutex_lock(&fb_helper->lock);
1026
1027	if (!drm_master_internal_acquire(dev)) {
1028		ret = -EBUSY;
1029		goto unlock;
1030	}
1031
1032	mutex_lock(&fb_helper->client.modeset_mutex);
1033	if (info->fix.visual == FB_VISUAL_TRUECOLOR)
1034		ret = setcmap_pseudo_palette(cmap, info);
1035	else if (drm_drv_uses_atomic_modeset(fb_helper->dev))
1036		ret = setcmap_atomic(cmap, info);
1037	else
1038		ret = setcmap_legacy(cmap, info);
1039	mutex_unlock(&fb_helper->client.modeset_mutex);
1040
1041	drm_master_internal_release(dev);
1042unlock:
1043	mutex_unlock(&fb_helper->lock);
1044
1045	return ret;
1046}
1047EXPORT_SYMBOL(drm_fb_helper_setcmap);
1048
1049/**
1050 * drm_fb_helper_ioctl - legacy ioctl implementation
1051 * @info: fbdev registered by the helper
1052 * @cmd: ioctl command
1053 * @arg: ioctl argument
1054 *
1055 * A helper to implement the standard fbdev ioctl. Only
1056 * FBIO_WAITFORVSYNC is implemented for now.
1057 */
1058int drm_fb_helper_ioctl(struct fb_info *info, unsigned int cmd,
1059			unsigned long arg)
1060{
1061	struct drm_fb_helper *fb_helper = info->par;
1062	struct drm_device *dev = fb_helper->dev;
1063	struct drm_crtc *crtc;
1064	int ret = 0;
1065
1066	mutex_lock(&fb_helper->lock);
1067	if (!drm_master_internal_acquire(dev)) {
1068		ret = -EBUSY;
1069		goto unlock;
1070	}
1071
1072	switch (cmd) {
1073	case FBIO_WAITFORVSYNC:
1074		/*
1075		 * Only consider the first CRTC.
1076		 *
1077		 * This ioctl is supposed to take the CRTC number as
1078		 * an argument, but in fbdev times, what that number
1079		 * was supposed to be was quite unclear, different
1080		 * drivers were passing that argument differently
1081		 * (some by reference, some by value), and most of the
1082		 * userspace applications were just hardcoding 0 as an
1083		 * argument.
1084		 *
1085		 * The first CRTC should be the integrated panel on
1086		 * most drivers, so this is the best choice we can
1087		 * make. If we're not smart enough here, one should
1088		 * just consider switch the userspace to KMS.
1089		 */
1090		crtc = fb_helper->client.modesets[0].crtc;
1091
1092		/*
1093		 * Only wait for a vblank event if the CRTC is
1094		 * enabled, otherwise just don't do anythintg,
1095		 * not even report an error.
1096		 */
1097		ret = drm_crtc_vblank_get(crtc);
1098		if (!ret) {
1099			drm_crtc_wait_one_vblank(crtc);
1100			drm_crtc_vblank_put(crtc);
1101		}
1102
1103		ret = 0;
1104		break;
1105	default:
1106		ret = -ENOTTY;
1107	}
1108
1109	drm_master_internal_release(dev);
1110unlock:
1111	mutex_unlock(&fb_helper->lock);
1112	return ret;
1113}
1114EXPORT_SYMBOL(drm_fb_helper_ioctl);
1115
1116static bool drm_fb_pixel_format_equal(const struct fb_var_screeninfo *var_1,
1117				      const struct fb_var_screeninfo *var_2)
1118{
1119	return var_1->bits_per_pixel == var_2->bits_per_pixel &&
1120	       var_1->grayscale == var_2->grayscale &&
1121	       var_1->red.offset == var_2->red.offset &&
1122	       var_1->red.length == var_2->red.length &&
1123	       var_1->red.msb_right == var_2->red.msb_right &&
1124	       var_1->green.offset == var_2->green.offset &&
1125	       var_1->green.length == var_2->green.length &&
1126	       var_1->green.msb_right == var_2->green.msb_right &&
1127	       var_1->blue.offset == var_2->blue.offset &&
1128	       var_1->blue.length == var_2->blue.length &&
1129	       var_1->blue.msb_right == var_2->blue.msb_right &&
1130	       var_1->transp.offset == var_2->transp.offset &&
1131	       var_1->transp.length == var_2->transp.length &&
1132	       var_1->transp.msb_right == var_2->transp.msb_right;
1133}
1134
1135static void drm_fb_helper_fill_pixel_fmt(struct fb_var_screeninfo *var,
1136					 const struct drm_format_info *format)
1137{
1138	u8 depth = format->depth;
1139
1140	if (format->is_color_indexed) {
1141		var->red.offset = 0;
1142		var->green.offset = 0;
1143		var->blue.offset = 0;
1144		var->red.length = depth;
1145		var->green.length = depth;
1146		var->blue.length = depth;
1147		var->transp.offset = 0;
1148		var->transp.length = 0;
1149		return;
1150	}
1151
1152	switch (depth) {
1153	case 15:
1154		var->red.offset = 10;
1155		var->green.offset = 5;
1156		var->blue.offset = 0;
1157		var->red.length = 5;
1158		var->green.length = 5;
1159		var->blue.length = 5;
1160		var->transp.offset = 15;
1161		var->transp.length = 1;
1162		break;
1163	case 16:
1164		var->red.offset = 11;
1165		var->green.offset = 5;
1166		var->blue.offset = 0;
1167		var->red.length = 5;
1168		var->green.length = 6;
1169		var->blue.length = 5;
1170		var->transp.offset = 0;
1171		break;
1172	case 24:
1173		var->red.offset = 16;
1174		var->green.offset = 8;
1175		var->blue.offset = 0;
1176		var->red.length = 8;
1177		var->green.length = 8;
1178		var->blue.length = 8;
1179		var->transp.offset = 0;
1180		var->transp.length = 0;
1181		break;
1182	case 32:
1183		var->red.offset = 16;
1184		var->green.offset = 8;
1185		var->blue.offset = 0;
1186		var->red.length = 8;
1187		var->green.length = 8;
1188		var->blue.length = 8;
1189		var->transp.offset = 24;
1190		var->transp.length = 8;
1191		break;
1192	default:
1193		break;
1194	}
1195}
1196
1197static void __fill_var(struct fb_var_screeninfo *var, struct fb_info *info,
1198		       struct drm_framebuffer *fb)
1199{
1200	int i;
1201
1202	var->xres_virtual = fb->width;
1203	var->yres_virtual = fb->height;
1204	var->accel_flags = 0;
1205	var->bits_per_pixel = drm_format_info_bpp(fb->format, 0);
1206
1207	var->height = info->var.height;
1208	var->width = info->var.width;
1209
1210	var->left_margin = var->right_margin = 0;
1211	var->upper_margin = var->lower_margin = 0;
1212	var->hsync_len = var->vsync_len = 0;
1213	var->sync = var->vmode = 0;
1214	var->rotate = 0;
1215	var->colorspace = 0;
1216	for (i = 0; i < 4; i++)
1217		var->reserved[i] = 0;
1218}
1219
1220/**
1221 * drm_fb_helper_check_var - implementation for &fb_ops.fb_check_var
1222 * @var: screeninfo to check
1223 * @info: fbdev registered by the helper
1224 */
1225int drm_fb_helper_check_var(struct fb_var_screeninfo *var,
1226			    struct fb_info *info)
1227{
1228	struct drm_fb_helper *fb_helper = info->par;
1229	struct drm_framebuffer *fb = fb_helper->fb;
1230	const struct drm_format_info *format = fb->format;
1231	struct drm_device *dev = fb_helper->dev;
1232	unsigned int bpp;
1233
1234	if (in_dbg_master())
1235		return -EINVAL;
1236
1237	if (var->pixclock != 0) {
1238		drm_dbg_kms(dev, "fbdev emulation doesn't support changing the pixel clock, value of pixclock is ignored\n");
1239		var->pixclock = 0;
1240	}
1241
1242	switch (format->format) {
1243	case DRM_FORMAT_C1:
1244	case DRM_FORMAT_C2:
1245	case DRM_FORMAT_C4:
1246		/* supported format with sub-byte pixels */
1247		break;
1248
1249	default:
1250		if ((drm_format_info_block_width(format, 0) > 1) ||
1251		    (drm_format_info_block_height(format, 0) > 1))
1252			return -EINVAL;
1253		break;
1254	}
1255
1256	/*
1257	 * Changes struct fb_var_screeninfo are currently not pushed back
1258	 * to KMS, hence fail if different settings are requested.
1259	 */
1260	bpp = drm_format_info_bpp(format, 0);
1261	if (var->bits_per_pixel > bpp ||
1262	    var->xres > fb->width || var->yres > fb->height ||
1263	    var->xres_virtual > fb->width || var->yres_virtual > fb->height) {
1264		drm_dbg_kms(dev, "fb requested width/height/bpp can't fit in current fb "
1265			  "request %dx%d-%d (virtual %dx%d) > %dx%d-%d\n",
1266			  var->xres, var->yres, var->bits_per_pixel,
1267			  var->xres_virtual, var->yres_virtual,
1268			  fb->width, fb->height, bpp);
1269		return -EINVAL;
1270	}
1271
1272	__fill_var(var, info, fb);
1273
1274	/*
1275	 * fb_pan_display() validates this, but fb_set_par() doesn't and just
1276	 * falls over. Note that __fill_var above adjusts y/res_virtual.
1277	 */
1278	if (var->yoffset > var->yres_virtual - var->yres ||
1279	    var->xoffset > var->xres_virtual - var->xres)
1280		return -EINVAL;
1281
1282	/* We neither support grayscale nor FOURCC (also stored in here). */
1283	if (var->grayscale > 0)
1284		return -EINVAL;
1285
1286	if (var->nonstd)
1287		return -EINVAL;
1288
1289	/*
1290	 * Workaround for SDL 1.2, which is known to be setting all pixel format
1291	 * fields values to zero in some cases. We treat this situation as a
1292	 * kind of "use some reasonable autodetected values".
1293	 */
1294	if (!var->red.offset     && !var->green.offset    &&
1295	    !var->blue.offset    && !var->transp.offset   &&
1296	    !var->red.length     && !var->green.length    &&
1297	    !var->blue.length    && !var->transp.length   &&
1298	    !var->red.msb_right  && !var->green.msb_right &&
1299	    !var->blue.msb_right && !var->transp.msb_right) {
1300		drm_fb_helper_fill_pixel_fmt(var, format);
1301	}
1302
1303	/*
 
 
 
 
 
1304	 * drm fbdev emulation doesn't support changing the pixel format at all,
1305	 * so reject all pixel format changing requests.
1306	 */
1307	if (!drm_fb_pixel_format_equal(var, &info->var)) {
1308		drm_dbg_kms(dev, "fbdev emulation doesn't support changing the pixel format\n");
1309		return -EINVAL;
1310	}
1311
1312	return 0;
1313}
1314EXPORT_SYMBOL(drm_fb_helper_check_var);
1315
1316/**
1317 * drm_fb_helper_set_par - implementation for &fb_ops.fb_set_par
1318 * @info: fbdev registered by the helper
1319 *
1320 * This will let fbcon do the mode init and is called at initialization time by
1321 * the fbdev core when registering the driver, and later on through the hotplug
1322 * callback.
1323 */
1324int drm_fb_helper_set_par(struct fb_info *info)
1325{
1326	struct drm_fb_helper *fb_helper = info->par;
1327	struct fb_var_screeninfo *var = &info->var;
1328	bool force;
1329
1330	if (oops_in_progress)
1331		return -EBUSY;
1332
 
 
 
 
 
1333	/*
1334	 * Normally we want to make sure that a kms master takes precedence over
1335	 * fbdev, to avoid fbdev flickering and occasionally stealing the
1336	 * display status. But Xorg first sets the vt back to text mode using
1337	 * the KDSET IOCTL with KD_TEXT, and only after that drops the master
1338	 * status when exiting.
1339	 *
1340	 * In the past this was caught by drm_fb_helper_lastclose(), but on
1341	 * modern systems where logind always keeps a drm fd open to orchestrate
1342	 * the vt switching, this doesn't work.
1343	 *
1344	 * To not break the userspace ABI we have this special case here, which
1345	 * is only used for the above case. Everything else uses the normal
1346	 * commit function, which ensures that we never steal the display from
1347	 * an active drm master.
1348	 */
1349	force = var->activate & FB_ACTIVATE_KD_TEXT;
1350
1351	__drm_fb_helper_restore_fbdev_mode_unlocked(fb_helper, force);
1352
1353	return 0;
1354}
1355EXPORT_SYMBOL(drm_fb_helper_set_par);
1356
1357static void pan_set(struct drm_fb_helper *fb_helper, int dx, int dy)
1358{
1359	struct drm_mode_set *mode_set;
1360
1361	mutex_lock(&fb_helper->client.modeset_mutex);
1362	drm_client_for_each_modeset(mode_set, &fb_helper->client) {
1363		mode_set->x += dx;
1364		mode_set->y += dy;
1365	}
1366	mutex_unlock(&fb_helper->client.modeset_mutex);
1367}
1368
1369static int pan_display_atomic(struct fb_var_screeninfo *var,
1370			      struct fb_info *info)
1371{
1372	struct drm_fb_helper *fb_helper = info->par;
1373	int ret, dx, dy;
1374
1375	dx = var->xoffset - info->var.xoffset;
1376	dy = var->yoffset - info->var.yoffset;
1377	pan_set(fb_helper, dx, dy);
1378
1379	ret = drm_client_modeset_commit_locked(&fb_helper->client);
1380	if (!ret) {
1381		info->var.xoffset = var->xoffset;
1382		info->var.yoffset = var->yoffset;
1383	} else
1384		pan_set(fb_helper, -dx, -dy);
1385
1386	return ret;
1387}
1388
1389static int pan_display_legacy(struct fb_var_screeninfo *var,
1390			      struct fb_info *info)
1391{
1392	struct drm_fb_helper *fb_helper = info->par;
1393	struct drm_client_dev *client = &fb_helper->client;
1394	struct drm_mode_set *modeset;
1395	int ret = 0;
1396
1397	mutex_lock(&client->modeset_mutex);
1398	drm_modeset_lock_all(fb_helper->dev);
1399	drm_client_for_each_modeset(modeset, client) {
1400		modeset->x = var->xoffset;
1401		modeset->y = var->yoffset;
1402
1403		if (modeset->num_connectors) {
1404			ret = drm_mode_set_config_internal(modeset);
1405			if (!ret) {
1406				info->var.xoffset = var->xoffset;
1407				info->var.yoffset = var->yoffset;
1408			}
1409		}
1410	}
1411	drm_modeset_unlock_all(fb_helper->dev);
1412	mutex_unlock(&client->modeset_mutex);
1413
1414	return ret;
1415}
1416
1417/**
1418 * drm_fb_helper_pan_display - implementation for &fb_ops.fb_pan_display
1419 * @var: updated screen information
1420 * @info: fbdev registered by the helper
1421 */
1422int drm_fb_helper_pan_display(struct fb_var_screeninfo *var,
1423			      struct fb_info *info)
1424{
1425	struct drm_fb_helper *fb_helper = info->par;
1426	struct drm_device *dev = fb_helper->dev;
1427	int ret;
1428
1429	if (oops_in_progress)
1430		return -EBUSY;
1431
1432	mutex_lock(&fb_helper->lock);
1433	if (!drm_master_internal_acquire(dev)) {
1434		ret = -EBUSY;
1435		goto unlock;
1436	}
1437
1438	if (drm_drv_uses_atomic_modeset(dev))
1439		ret = pan_display_atomic(var, info);
1440	else
1441		ret = pan_display_legacy(var, info);
1442
1443	drm_master_internal_release(dev);
1444unlock:
1445	mutex_unlock(&fb_helper->lock);
1446
1447	return ret;
1448}
1449EXPORT_SYMBOL(drm_fb_helper_pan_display);
1450
1451static uint32_t drm_fb_helper_find_format(struct drm_fb_helper *fb_helper, const uint32_t *formats,
1452					  size_t format_count, unsigned int color_mode)
1453{
1454	struct drm_device *dev = fb_helper->dev;
1455	uint32_t format;
1456	size_t i;
1457
1458	format = drm_driver_color_mode_format(dev, color_mode);
1459	if (!format) {
1460		drm_info(dev, "unsupported color mode of %d\n", color_mode);
1461		return DRM_FORMAT_INVALID;
1462	}
1463
1464	for (i = 0; i < format_count; ++i) {
1465		if (formats[i] == format)
1466			return format;
1467	}
1468	drm_warn(dev, "format %p4cc not supported\n", &format);
1469
1470	return DRM_FORMAT_INVALID;
1471}
1472
1473static int __drm_fb_helper_find_sizes(struct drm_fb_helper *fb_helper,
1474				      struct drm_fb_helper_surface_size *sizes)
1475{
1476	struct drm_client_dev *client = &fb_helper->client;
1477	struct drm_device *dev = fb_helper->dev;
 
 
1478	int crtc_count = 0;
1479	struct drm_connector_list_iter conn_iter;
 
1480	struct drm_connector *connector;
1481	struct drm_mode_set *mode_set;
1482	uint32_t surface_format = DRM_FORMAT_INVALID;
1483	const struct drm_format_info *info;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1484
1485	memset(sizes, 0, sizeof(*sizes));
1486	sizes->fb_width = (u32)-1;
1487	sizes->fb_height = (u32)-1;
1488
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1489	drm_client_for_each_modeset(mode_set, client) {
1490		struct drm_crtc *crtc = mode_set->crtc;
1491		struct drm_plane *plane = crtc->primary;
 
1492
1493		drm_dbg_kms(dev, "test CRTC %u primary plane\n", drm_crtc_index(crtc));
1494
1495		drm_connector_list_iter_begin(fb_helper->dev, &conn_iter);
1496		drm_client_for_each_connector_iter(connector, &conn_iter) {
1497			struct drm_cmdline_mode *cmdline_mode = &connector->cmdline_mode;
 
1498
1499			if (!cmdline_mode->bpp_specified)
 
 
 
 
 
 
 
1500				continue;
1501
1502			surface_format = drm_fb_helper_find_format(fb_helper,
1503								   plane->format_types,
1504								   plane->format_count,
1505								   cmdline_mode->bpp);
1506			if (surface_format != DRM_FORMAT_INVALID)
1507				break; /* found supported format */
1508		}
1509		drm_connector_list_iter_end(&conn_iter);
1510
1511		if (surface_format != DRM_FORMAT_INVALID)
1512			break; /* found supported format */
 
1513
1514		/* try preferred color mode */
1515		surface_format = drm_fb_helper_find_format(fb_helper,
1516							   plane->format_types,
1517							   plane->format_count,
1518							   fb_helper->preferred_bpp);
1519		if (surface_format != DRM_FORMAT_INVALID)
1520			break; /* found supported format */
1521	}
1522
1523	if (surface_format == DRM_FORMAT_INVALID) {
1524		/*
1525		 * If none of the given color modes works, fall back
1526		 * to XRGB8888. Drivers are expected to provide this
1527		 * format for compatibility with legacy applications.
1528		 */
1529		drm_warn(dev, "No compatible format found\n");
1530		surface_format = drm_driver_legacy_fb_format(dev, 32, 24);
1531	}
1532
1533	info = drm_format_info(surface_format);
1534	sizes->surface_bpp = drm_format_info_bpp(info, 0);
1535	sizes->surface_depth = info->depth;
1536
1537	/* first up get a count of crtcs now in use and new min/maxes width/heights */
1538	crtc_count = 0;
1539	drm_client_for_each_modeset(mode_set, client) {
1540		struct drm_display_mode *desired_mode;
1541		int x, y, j;
1542		/* in case of tile group, are we the last tile vert or horiz?
1543		 * If no tile group you are always the last one both vertically
1544		 * and horizontally
1545		 */
1546		bool lastv = true, lasth = true;
1547
1548		desired_mode = mode_set->mode;
1549
1550		if (!desired_mode)
1551			continue;
1552
1553		crtc_count++;
1554
1555		x = mode_set->x;
1556		y = mode_set->y;
1557
1558		sizes->surface_width  =
1559			max_t(u32, desired_mode->hdisplay + x, sizes->surface_width);
1560		sizes->surface_height =
1561			max_t(u32, desired_mode->vdisplay + y, sizes->surface_height);
1562
1563		for (j = 0; j < mode_set->num_connectors; j++) {
1564			struct drm_connector *connector = mode_set->connectors[j];
1565
1566			if (connector->has_tile &&
1567			    desired_mode->hdisplay == connector->tile_h_size &&
1568			    desired_mode->vdisplay == connector->tile_v_size) {
1569				lasth = (connector->tile_h_loc == (connector->num_h_tile - 1));
1570				lastv = (connector->tile_v_loc == (connector->num_v_tile - 1));
1571				/* cloning to multiple tiles is just crazy-talk, so: */
1572				break;
1573			}
1574		}
1575
1576		if (lasth)
1577			sizes->fb_width  = min_t(u32, desired_mode->hdisplay + x, sizes->fb_width);
1578		if (lastv)
1579			sizes->fb_height = min_t(u32, desired_mode->vdisplay + y, sizes->fb_height);
1580	}
 
1581
1582	if (crtc_count == 0 || sizes->fb_width == -1 || sizes->fb_height == -1) {
1583		drm_info(dev, "Cannot find any crtc or sizes\n");
 
 
 
 
1584		return -EAGAIN;
1585	}
1586
1587	return 0;
1588}
1589
1590static int drm_fb_helper_find_sizes(struct drm_fb_helper *fb_helper,
1591				    struct drm_fb_helper_surface_size *sizes)
1592{
1593	struct drm_client_dev *client = &fb_helper->client;
1594	struct drm_device *dev = fb_helper->dev;
1595	struct drm_mode_config *config = &dev->mode_config;
1596	int ret;
1597
1598	mutex_lock(&client->modeset_mutex);
1599	ret = __drm_fb_helper_find_sizes(fb_helper, sizes);
1600	mutex_unlock(&client->modeset_mutex);
1601
1602	if (ret)
1603		return ret;
1604
1605	/* Handle our overallocation */
1606	sizes->surface_height *= drm_fbdev_overalloc;
1607	sizes->surface_height /= 100;
1608	if (sizes->surface_height > config->max_height) {
1609		drm_dbg_kms(dev, "Fbdev over-allocation too large; clamping height to %d\n",
1610			    config->max_height);
1611		sizes->surface_height = config->max_height;
1612	}
1613
1614	return 0;
1615}
1616
1617/*
1618 * Allocates the backing storage and sets up the fbdev info structure through
1619 * the ->fbdev_probe callback.
1620 */
1621static int drm_fb_helper_single_fb_probe(struct drm_fb_helper *fb_helper)
1622{
1623	struct drm_client_dev *client = &fb_helper->client;
1624	struct drm_device *dev = fb_helper->dev;
1625	struct drm_fb_helper_surface_size sizes;
1626	struct fb_info *info;
1627	int ret;
1628
1629	ret = drm_fb_helper_find_sizes(fb_helper, &sizes);
1630	if (ret) {
1631		/* First time: disable all crtc's.. */
1632		if (!fb_helper->deferred_setup)
1633			drm_client_modeset_commit(client);
1634		return ret;
1635	}
1636
1637	/* push down into drivers */
1638	if (dev->driver->fbdev_probe)
1639		ret = dev->driver->fbdev_probe(fb_helper, &sizes);
1640	else if (fb_helper->funcs)
1641		ret = fb_helper->funcs->fb_probe(fb_helper, &sizes);
1642	if (ret < 0)
1643		return ret;
1644
1645	strcpy(fb_helper->fb->comm, "[fbcon]");
1646
1647	info = fb_helper->info;
1648
1649	/* Set the fb info for vgaswitcheroo clients. Does nothing otherwise. */
1650	if (dev_is_pci(info->device))
1651		vga_switcheroo_client_fb_set(to_pci_dev(info->device), info);
1652
1653	return 0;
1654}
1655
1656static void drm_fb_helper_fill_fix(struct fb_info *info, uint32_t pitch,
1657				   bool is_color_indexed)
1658{
1659	info->fix.type = FB_TYPE_PACKED_PIXELS;
1660	info->fix.visual = is_color_indexed ? FB_VISUAL_PSEUDOCOLOR
1661					    : FB_VISUAL_TRUECOLOR;
1662	info->fix.mmio_start = 0;
1663	info->fix.mmio_len = 0;
1664	info->fix.type_aux = 0;
1665	info->fix.xpanstep = 1; /* doing it in hw */
1666	info->fix.ypanstep = 1; /* doing it in hw */
1667	info->fix.ywrapstep = 0;
1668	info->fix.accel = FB_ACCEL_NONE;
1669
1670	info->fix.line_length = pitch;
1671}
1672
1673static void drm_fb_helper_fill_var(struct fb_info *info,
1674				   struct drm_fb_helper *fb_helper,
1675				   uint32_t fb_width, uint32_t fb_height)
1676{
1677	struct drm_framebuffer *fb = fb_helper->fb;
1678	const struct drm_format_info *format = fb->format;
1679
1680	switch (format->format) {
1681	case DRM_FORMAT_C1:
1682	case DRM_FORMAT_C2:
1683	case DRM_FORMAT_C4:
1684		/* supported format with sub-byte pixels */
1685		break;
1686
1687	default:
1688		WARN_ON((drm_format_info_block_width(format, 0) > 1) ||
1689			(drm_format_info_block_height(format, 0) > 1));
1690		break;
1691	}
1692
 
 
1693	info->pseudo_palette = fb_helper->pseudo_palette;
 
 
 
 
1694	info->var.xoffset = 0;
1695	info->var.yoffset = 0;
1696	__fill_var(&info->var, info, fb);
1697	info->var.activate = FB_ACTIVATE_NOW;
1698
1699	drm_fb_helper_fill_pixel_fmt(&info->var, format);
1700
1701	info->var.xres = fb_width;
1702	info->var.yres = fb_height;
1703}
1704
1705/**
1706 * drm_fb_helper_fill_info - initializes fbdev information
1707 * @info: fbdev instance to set up
1708 * @fb_helper: fb helper instance to use as template
1709 * @sizes: describes fbdev size and scanout surface size
1710 *
1711 * Sets up the variable and fixed fbdev metainformation from the given fb helper
1712 * instance and the drm framebuffer allocated in &drm_fb_helper.fb.
1713 *
1714 * Drivers should call this (or their equivalent setup code) from their
1715 * &drm_driver.fbdev_probe callback after having allocated the fbdev
1716 * backing storage framebuffer.
1717 */
1718void drm_fb_helper_fill_info(struct fb_info *info,
1719			     struct drm_fb_helper *fb_helper,
1720			     struct drm_fb_helper_surface_size *sizes)
1721{
1722	struct drm_framebuffer *fb = fb_helper->fb;
1723
1724	drm_fb_helper_fill_fix(info, fb->pitches[0],
1725			       fb->format->is_color_indexed);
1726	drm_fb_helper_fill_var(info, fb_helper,
1727			       sizes->fb_width, sizes->fb_height);
1728
1729	info->par = fb_helper;
1730	/*
1731	 * The DRM drivers fbdev emulation device name can be confusing if the
1732	 * driver name also has a "drm" suffix on it. Leading to names such as
1733	 * "simpledrmdrmfb" in /proc/fb. Unfortunately, it's an uAPI and can't
1734	 * be changed due user-space tools (e.g: pm-utils) matching against it.
1735	 */
1736	snprintf(info->fix.id, sizeof(info->fix.id), "%sdrmfb",
1737		 fb_helper->dev->driver->name);
1738
1739}
1740EXPORT_SYMBOL(drm_fb_helper_fill_info);
1741
1742/*
1743 * This is a continuation of drm_setup_crtcs() that sets up anything related
1744 * to the framebuffer. During initialization, drm_setup_crtcs() is called before
1745 * the framebuffer has been allocated (fb_helper->fb and fb_helper->info).
1746 * So, any setup that touches those fields needs to be done here instead of in
1747 * drm_setup_crtcs().
1748 */
1749static void drm_setup_crtcs_fb(struct drm_fb_helper *fb_helper)
1750{
1751	struct drm_client_dev *client = &fb_helper->client;
1752	struct drm_connector_list_iter conn_iter;
1753	struct fb_info *info = fb_helper->info;
1754	unsigned int rotation, sw_rotations = 0;
1755	struct drm_connector *connector;
1756	struct drm_mode_set *modeset;
1757
1758	mutex_lock(&client->modeset_mutex);
1759	drm_client_for_each_modeset(modeset, client) {
1760		if (!modeset->num_connectors)
1761			continue;
1762
1763		modeset->fb = fb_helper->fb;
1764
1765		if (drm_client_rotation(modeset, &rotation))
1766			/* Rotating in hardware, fbcon should not rotate */
1767			sw_rotations |= DRM_MODE_ROTATE_0;
1768		else
1769			sw_rotations |= rotation;
1770	}
1771	mutex_unlock(&client->modeset_mutex);
1772
1773	drm_connector_list_iter_begin(fb_helper->dev, &conn_iter);
1774	drm_client_for_each_connector_iter(connector, &conn_iter) {
1775
1776		/* use first connected connector for the physical dimensions */
1777		if (connector->status == connector_status_connected) {
1778			info->var.width = connector->display_info.width_mm;
1779			info->var.height = connector->display_info.height_mm;
1780			break;
1781		}
1782	}
1783	drm_connector_list_iter_end(&conn_iter);
1784
1785	switch (sw_rotations) {
1786	case DRM_MODE_ROTATE_0:
1787		info->fbcon_rotate_hint = FB_ROTATE_UR;
1788		break;
1789	case DRM_MODE_ROTATE_90:
1790		info->fbcon_rotate_hint = FB_ROTATE_CCW;
1791		break;
1792	case DRM_MODE_ROTATE_180:
1793		info->fbcon_rotate_hint = FB_ROTATE_UD;
1794		break;
1795	case DRM_MODE_ROTATE_270:
1796		info->fbcon_rotate_hint = FB_ROTATE_CW;
1797		break;
1798	default:
1799		/*
1800		 * Multiple bits are set / multiple rotations requested
1801		 * fbcon cannot handle separate rotation settings per
1802		 * output, so fallback to unrotated.
1803		 */
1804		info->fbcon_rotate_hint = FB_ROTATE_UR;
1805	}
1806}
1807
1808/* Note: Drops fb_helper->lock before returning. */
1809static int
1810__drm_fb_helper_initial_config_and_unlock(struct drm_fb_helper *fb_helper)
 
1811{
1812	struct drm_device *dev = fb_helper->dev;
1813	struct fb_info *info;
1814	unsigned int width, height;
1815	int ret;
1816
1817	width = dev->mode_config.max_width;
1818	height = dev->mode_config.max_height;
1819
1820	drm_client_modeset_probe(&fb_helper->client, width, height);
1821	ret = drm_fb_helper_single_fb_probe(fb_helper);
1822	if (ret < 0) {
1823		if (ret == -EAGAIN) {
 
1824			fb_helper->deferred_setup = true;
1825			ret = 0;
1826		}
1827		mutex_unlock(&fb_helper->lock);
1828
1829		return ret;
1830	}
1831	drm_setup_crtcs_fb(fb_helper);
1832
1833	fb_helper->deferred_setup = false;
1834
1835	info = fb_helper->info;
1836	info->var.pixclock = 0;
 
 
 
 
 
 
1837
1838	/* Need to drop locks to avoid recursive deadlock in
1839	 * register_framebuffer. This is ok because the only thing left to do is
1840	 * register the fbdev emulation instance in kernel_fb_helper_list. */
1841	mutex_unlock(&fb_helper->lock);
1842
1843	ret = register_framebuffer(info);
1844	if (ret < 0)
1845		return ret;
1846
1847	drm_info(dev, "fb%d: %s frame buffer device\n",
1848		 info->node, info->fix.id);
1849
1850	mutex_lock(&kernel_fb_helper_lock);
1851	if (list_empty(&kernel_fb_helper_list))
1852		register_sysrq_key('v', &sysrq_drm_fb_helper_restore_op);
1853
1854	list_add(&fb_helper->kernel_fb_list, &kernel_fb_helper_list);
1855	mutex_unlock(&kernel_fb_helper_lock);
1856
1857	return 0;
1858}
1859
1860/**
1861 * drm_fb_helper_initial_config - setup a sane initial connector configuration
1862 * @fb_helper: fb_helper device struct
 
1863 *
1864 * Scans the CRTCs and connectors and tries to put together an initial setup.
1865 * At the moment, this is a cloned configuration across all heads with
1866 * a new framebuffer object as the backing store.
1867 *
1868 * Note that this also registers the fbdev and so allows userspace to call into
1869 * the driver through the fbdev interfaces.
1870 *
1871 * This function will call down into the &drm_driver.fbdev_probe callback
1872 * to let the driver allocate and initialize the fbdev info structure and the
1873 * drm framebuffer used to back the fbdev. drm_fb_helper_fill_info() is provided
1874 * as a helper to setup simple default values for the fbdev info structure.
1875 *
1876 * HANG DEBUGGING:
1877 *
1878 * When you have fbcon support built-in or already loaded, this function will do
1879 * a full modeset to setup the fbdev console. Due to locking misdesign in the
1880 * VT/fbdev subsystem that entire modeset sequence has to be done while holding
1881 * console_lock. Until console_unlock is called no dmesg lines will be sent out
1882 * to consoles, not even serial console. This means when your driver crashes,
1883 * you will see absolutely nothing else but a system stuck in this function,
1884 * with no further output. Any kind of printk() you place within your own driver
1885 * or in the drm core modeset code will also never show up.
1886 *
1887 * Standard debug practice is to run the fbcon setup without taking the
1888 * console_lock as a hack, to be able to see backtraces and crashes on the
1889 * serial line. This can be done by setting the fb.lockless_register_fb=1 kernel
1890 * cmdline option.
1891 *
1892 * The other option is to just disable fbdev emulation since very likely the
1893 * first modeset from userspace will crash in the same way, and is even easier
1894 * to debug. This can be done by setting the drm_kms_helper.fbdev_emulation=0
1895 * kernel cmdline option.
1896 *
1897 * RETURNS:
1898 * Zero if everything went ok, nonzero otherwise.
1899 */
1900int drm_fb_helper_initial_config(struct drm_fb_helper *fb_helper)
1901{
1902	int ret;
1903
1904	if (!drm_fbdev_emulation)
1905		return 0;
1906
1907	mutex_lock(&fb_helper->lock);
1908	ret = __drm_fb_helper_initial_config_and_unlock(fb_helper);
1909
1910	return ret;
1911}
1912EXPORT_SYMBOL(drm_fb_helper_initial_config);
1913
1914/**
1915 * drm_fb_helper_hotplug_event - respond to a hotplug notification by
1916 *                               probing all the outputs attached to the fb
1917 * @fb_helper: driver-allocated fbdev helper, can be NULL
1918 *
1919 * Scan the connectors attached to the fb_helper and try to put together a
1920 * setup after notification of a change in output configuration.
1921 *
1922 * Called at runtime, takes the mode config locks to be able to check/change the
1923 * modeset configuration. Must be run from process context (which usually means
1924 * either the output polling work or a work item launched from the driver's
1925 * hotplug interrupt).
1926 *
1927 * Note that drivers may call this even before calling
1928 * drm_fb_helper_initial_config but only after drm_fb_helper_init. This allows
1929 * for a race-free fbcon setup and will make sure that the fbdev emulation will
1930 * not miss any hotplug events.
1931 *
1932 * RETURNS:
1933 * 0 on success and a non-zero error code otherwise.
1934 */
1935int drm_fb_helper_hotplug_event(struct drm_fb_helper *fb_helper)
1936{
1937	int err = 0;
1938
1939	if (!drm_fbdev_emulation || !fb_helper)
1940		return 0;
1941
1942	mutex_lock(&fb_helper->lock);
1943	if (fb_helper->deferred_setup) {
1944		err = __drm_fb_helper_initial_config_and_unlock(fb_helper);
 
1945		return err;
1946	}
1947
1948	if (!fb_helper->fb || !drm_master_internal_acquire(fb_helper->dev)) {
1949		fb_helper->delayed_hotplug = true;
1950		mutex_unlock(&fb_helper->lock);
1951		return err;
1952	}
1953
1954	drm_master_internal_release(fb_helper->dev);
1955
1956	drm_dbg_kms(fb_helper->dev, "\n");
1957
1958	drm_client_modeset_probe(&fb_helper->client, fb_helper->fb->width, fb_helper->fb->height);
1959	drm_setup_crtcs_fb(fb_helper);
1960	mutex_unlock(&fb_helper->lock);
1961
1962	drm_fb_helper_set_par(fb_helper->info);
1963
1964	return 0;
1965}
1966EXPORT_SYMBOL(drm_fb_helper_hotplug_event);
1967
1968/**
1969 * drm_fb_helper_lastclose - DRM driver lastclose helper for fbdev emulation
1970 * @dev: DRM device
1971 *
1972 * This function is obsolete. Call drm_fb_helper_restore_fbdev_mode_unlocked()
1973 * instead.
1974 */
1975void drm_fb_helper_lastclose(struct drm_device *dev)
1976{
1977	drm_fb_helper_restore_fbdev_mode_unlocked(dev->fb_helper);
1978}
1979EXPORT_SYMBOL(drm_fb_helper_lastclose);