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