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/kernel.h>
  33#include <linux/sysrq.h>
  34#include <linux/slab.h>
  35#include <linux/fb.h>
  36#include <linux/module.h>
  37#include <drm/drmP.h>
 
 
 
 
  38#include <drm/drm_crtc.h>
  39#include <drm/drm_fb_helper.h>
  40#include <drm/drm_crtc_helper.h>
  41#include <drm/drm_atomic.h>
  42#include <drm/drm_atomic_helper.h>
 
 
 
 
 
 
  43
  44static bool drm_fbdev_emulation = true;
  45module_param_named(fbdev_emulation, drm_fbdev_emulation, bool, 0600);
  46MODULE_PARM_DESC(fbdev_emulation,
  47		 "Enable legacy fbdev emulation [default=true]");
  48
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  49static LIST_HEAD(kernel_fb_helper_list);
 
  50
  51/**
  52 * DOC: fbdev helpers
  53 *
  54 * The fb helper functions are useful to provide an fbdev on top of a drm kernel
  55 * mode setting driver. They can be used mostly independently from the crtc
  56 * helper functions used by many drivers to implement the kernel mode setting
  57 * interfaces.
  58 *
  59 * Initialization is done as a four-step process with drm_fb_helper_prepare(),
  60 * drm_fb_helper_init(), drm_fb_helper_single_add_all_connectors() and
  61 * drm_fb_helper_initial_config(). Drivers with fancier requirements than the
  62 * default behaviour can override the third step with their own code.
  63 * Teardown is done with drm_fb_helper_fini().
  64 *
  65 * At runtime drivers should restore the fbdev console by calling
  66 * drm_fb_helper_restore_fbdev_mode_unlocked() from their ->lastclose callback.
  67 * They should also notify the fb helper code from updates to the output
  68 * configuration by calling drm_fb_helper_hotplug_event(). For easier
  69 * integration with the output polling code in drm_crtc_helper.c the modeset
  70 * code provides a ->output_poll_changed callback.
 
 
  71 *
  72 * All other functions exported by the fb helper library can be used to
  73 * implement the fbdev driver interface by the driver.
  74 *
  75 * It is possible, though perhaps somewhat tricky, to implement race-free
  76 * hotplug detection using the fbdev helpers. The drm_fb_helper_prepare()
  77 * helper must be called first to initialize the minimum required to make
  78 * hotplug detection work. Drivers also need to make sure to properly set up
  79 * the dev->mode_config.funcs member. After calling drm_kms_helper_poll_init()
  80 * it is safe to enable interrupts and start processing hotplug events. At the
  81 * same time, drivers should initialize all modeset objects such as CRTCs,
  82 * encoders and connectors. To finish up the fbdev helper initialization, the
  83 * drm_fb_helper_init() function is called. To probe for all attached displays
  84 * and set up an initial configuration using the detected hardware, drivers
  85 * should call drm_fb_helper_single_add_all_connectors() followed by
  86 * drm_fb_helper_initial_config().
  87 */
  88
  89/**
  90 * drm_fb_helper_single_add_all_connectors() - add all connectors to fbdev
  91 * 					       emulation helper
  92 * @fb_helper: fbdev initialized with drm_fb_helper_init
  93 *
  94 * This functions adds all the available connectors for use with the given
  95 * fb_helper. This is a separate step to allow drivers to freely assign
  96 * connectors to the fbdev, e.g. if some are reserved for special purposes or
  97 * not adequate to be used for the fbcon.
 
 
 
 
  98 *
  99 * This function is protected against concurrent connector hotadds/removals
 100 * using drm_fb_helper_add_one_connector() and
 101 * drm_fb_helper_remove_one_connector().
 102 */
 103int drm_fb_helper_single_add_all_connectors(struct drm_fb_helper *fb_helper)
 104{
 105	struct drm_device *dev = fb_helper->dev;
 106	struct drm_connector *connector;
 107	int i, ret;
 108
 109	if (!drm_fbdev_emulation)
 110		return 0;
 111
 112	mutex_lock(&dev->mode_config.mutex);
 113	drm_for_each_connector(connector, dev) {
 114		ret = drm_fb_helper_add_one_connector(fb_helper, connector);
 115
 116		if (ret)
 117			goto fail;
 118	}
 119	mutex_unlock(&dev->mode_config.mutex);
 120	return 0;
 121fail:
 122	for (i = 0; i < fb_helper->connector_count; i++) {
 123		kfree(fb_helper->connector_info[i]);
 124		fb_helper->connector_info[i] = NULL;
 125	}
 126	fb_helper->connector_count = 0;
 127	mutex_unlock(&dev->mode_config.mutex);
 128
 129	return ret;
 130}
 131EXPORT_SYMBOL(drm_fb_helper_single_add_all_connectors);
 132
 133int drm_fb_helper_add_one_connector(struct drm_fb_helper *fb_helper, struct drm_connector *connector)
 134{
 135	struct drm_fb_helper_connector **temp;
 136	struct drm_fb_helper_connector *fb_helper_connector;
 137
 138	if (!drm_fbdev_emulation)
 139		return 0;
 140
 141	WARN_ON(!mutex_is_locked(&fb_helper->dev->mode_config.mutex));
 142	if (fb_helper->connector_count + 1 > fb_helper->connector_info_alloc_count) {
 143		temp = krealloc(fb_helper->connector_info, sizeof(struct drm_fb_helper_connector *) * (fb_helper->connector_count + 1), GFP_KERNEL);
 144		if (!temp)
 145			return -ENOMEM;
 146
 147		fb_helper->connector_info_alloc_count = fb_helper->connector_count + 1;
 148		fb_helper->connector_info = temp;
 149	}
 150
 151
 152	fb_helper_connector = kzalloc(sizeof(struct drm_fb_helper_connector), GFP_KERNEL);
 153	if (!fb_helper_connector)
 154		return -ENOMEM;
 155
 156	fb_helper_connector->connector = connector;
 157	fb_helper->connector_info[fb_helper->connector_count++] = fb_helper_connector;
 158	return 0;
 159}
 160EXPORT_SYMBOL(drm_fb_helper_add_one_connector);
 161
 162static void remove_from_modeset(struct drm_mode_set *set,
 163		struct drm_connector *connector)
 164{
 165	int i, j;
 166
 167	for (i = 0; i < set->num_connectors; i++) {
 168		if (set->connectors[i] == connector)
 169			break;
 170	}
 171
 172	if (i == set->num_connectors)
 173		return;
 174
 175	for (j = i + 1; j < set->num_connectors; j++) {
 176		set->connectors[j - 1] = set->connectors[j];
 177	}
 178	set->num_connectors--;
 179
 180	/*
 181	 * TODO maybe need to makes sure we set it back to !=NULL somewhere?
 182	 */
 183	if (set->num_connectors == 0) {
 184		set->fb = NULL;
 185		drm_mode_destroy(connector->dev, set->mode);
 186		set->mode = NULL;
 187	}
 188}
 189
 190int drm_fb_helper_remove_one_connector(struct drm_fb_helper *fb_helper,
 191				       struct drm_connector *connector)
 192{
 193	struct drm_fb_helper_connector *fb_helper_connector;
 194	int i, j;
 195
 196	if (!drm_fbdev_emulation)
 197		return 0;
 198
 199	WARN_ON(!mutex_is_locked(&fb_helper->dev->mode_config.mutex));
 200
 201	for (i = 0; i < fb_helper->connector_count; i++) {
 202		if (fb_helper->connector_info[i]->connector == connector)
 203			break;
 204	}
 205
 206	if (i == fb_helper->connector_count)
 207		return -EINVAL;
 208	fb_helper_connector = fb_helper->connector_info[i];
 209
 210	for (j = i + 1; j < fb_helper->connector_count; j++) {
 211		fb_helper->connector_info[j - 1] = fb_helper->connector_info[j];
 212	}
 213	fb_helper->connector_count--;
 214	kfree(fb_helper_connector);
 215
 216	/* also cleanup dangling references to the connector: */
 217	for (i = 0; i < fb_helper->crtc_count; i++)
 218		remove_from_modeset(&fb_helper->crtc_info[i].mode_set, connector);
 219
 220	return 0;
 221}
 222EXPORT_SYMBOL(drm_fb_helper_remove_one_connector);
 223
 224static void drm_fb_helper_save_lut_atomic(struct drm_crtc *crtc, struct drm_fb_helper *helper)
 225{
 226	uint16_t *r_base, *g_base, *b_base;
 227	int i;
 228
 229	if (helper->funcs->gamma_get == NULL)
 230		return;
 231
 232	r_base = crtc->gamma_store;
 233	g_base = r_base + crtc->gamma_size;
 234	b_base = g_base + crtc->gamma_size;
 235
 236	for (i = 0; i < crtc->gamma_size; i++)
 237		helper->funcs->gamma_get(crtc, &r_base[i], &g_base[i], &b_base[i], i);
 238}
 239
 240static void drm_fb_helper_restore_lut_atomic(struct drm_crtc *crtc)
 241{
 242	uint16_t *r_base, *g_base, *b_base;
 243
 244	if (crtc->funcs->gamma_set == NULL)
 245		return;
 246
 247	r_base = crtc->gamma_store;
 248	g_base = r_base + crtc->gamma_size;
 249	b_base = g_base + crtc->gamma_size;
 250
 251	crtc->funcs->gamma_set(crtc, r_base, g_base, b_base, 0, crtc->gamma_size);
 
 252}
 253
 254/**
 255 * drm_fb_helper_debug_enter - implementation for ->fb_debug_enter
 256 * @info: fbdev registered by the helper
 257 */
 258int drm_fb_helper_debug_enter(struct fb_info *info)
 259{
 260	struct drm_fb_helper *helper = info->par;
 261	const struct drm_crtc_helper_funcs *funcs;
 262	int i;
 263
 264	list_for_each_entry(helper, &kernel_fb_helper_list, kernel_fb_list) {
 265		for (i = 0; i < helper->crtc_count; i++) {
 266			struct drm_mode_set *mode_set =
 267				&helper->crtc_info[i].mode_set;
 268
 269			if (!mode_set->crtc->enabled)
 270				continue;
 271
 272			funcs =	mode_set->crtc->helper_private;
 273			drm_fb_helper_save_lut_atomic(mode_set->crtc, helper);
 
 
 
 
 
 274			funcs->mode_set_base_atomic(mode_set->crtc,
 275						    mode_set->fb,
 276						    mode_set->x,
 277						    mode_set->y,
 278						    ENTER_ATOMIC_MODE_SET);
 279		}
 
 280	}
 281
 282	return 0;
 283}
 284EXPORT_SYMBOL(drm_fb_helper_debug_enter);
 285
 286/* Find the real fb for a given fb helper CRTC */
 287static struct drm_framebuffer *drm_mode_config_fb(struct drm_crtc *crtc)
 288{
 289	struct drm_device *dev = crtc->dev;
 290	struct drm_crtc *c;
 291
 292	drm_for_each_crtc(c, dev) {
 293		if (crtc->base.id == c->base.id)
 294			return c->primary->fb;
 295	}
 296
 297	return NULL;
 298}
 299
 300/**
 301 * drm_fb_helper_debug_leave - implementation for ->fb_debug_leave
 302 * @info: fbdev registered by the helper
 303 */
 304int drm_fb_helper_debug_leave(struct fb_info *info)
 305{
 306	struct drm_fb_helper *helper = info->par;
 
 
 307	struct drm_crtc *crtc;
 308	const struct drm_crtc_helper_funcs *funcs;
 
 309	struct drm_framebuffer *fb;
 310	int i;
 311
 312	for (i = 0; i < helper->crtc_count; i++) {
 313		struct drm_mode_set *mode_set = &helper->crtc_info[i].mode_set;
 314		crtc = mode_set->crtc;
 
 
 
 315		funcs = crtc->helper_private;
 316		fb = drm_mode_config_fb(crtc);
 317
 318		if (!crtc->enabled)
 319			continue;
 320
 321		if (!fb) {
 322			DRM_ERROR("no fb to restore??\n");
 323			continue;
 324		}
 325
 
 
 
 326		drm_fb_helper_restore_lut_atomic(mode_set->crtc);
 327		funcs->mode_set_base_atomic(mode_set->crtc, fb, crtc->x,
 328					    crtc->y, LEAVE_ATOMIC_MODE_SET);
 329	}
 
 330
 331	return 0;
 332}
 333EXPORT_SYMBOL(drm_fb_helper_debug_leave);
 334
 335static int restore_fbdev_mode_atomic(struct drm_fb_helper *fb_helper)
 
 
 336{
 337	struct drm_device *dev = fb_helper->dev;
 338	struct drm_plane *plane;
 339	struct drm_atomic_state *state;
 340	int i, ret;
 341	unsigned plane_mask;
 342
 343	state = drm_atomic_state_alloc(dev);
 344	if (!state)
 345		return -ENOMEM;
 346
 347	state->acquire_ctx = dev->mode_config.acquire_ctx;
 348retry:
 349	plane_mask = 0;
 350	drm_for_each_plane(plane, dev) {
 351		struct drm_plane_state *plane_state;
 352
 353		plane_state = drm_atomic_get_plane_state(state, plane);
 354		if (IS_ERR(plane_state)) {
 355			ret = PTR_ERR(plane_state);
 356			goto fail;
 357		}
 358
 359		plane_state->rotation = BIT(DRM_ROTATE_0);
 360
 361		plane->old_fb = plane->fb;
 362		plane_mask |= 1 << drm_plane_index(plane);
 363
 364		/* disable non-primary: */
 365		if (plane->type == DRM_PLANE_TYPE_PRIMARY)
 366			continue;
 367
 368		ret = __drm_atomic_helper_disable_plane(plane, plane_state);
 369		if (ret != 0)
 370			goto fail;
 371	}
 372
 373	for(i = 0; i < fb_helper->crtc_count; i++) {
 374		struct drm_mode_set *mode_set = &fb_helper->crtc_info[i].mode_set;
 375
 376		ret = __drm_atomic_helper_set_config(mode_set, state);
 377		if (ret != 0)
 378			goto fail;
 
 
 
 
 
 
 
 379	}
 380
 381	ret = drm_atomic_commit(state);
 382
 383fail:
 384	drm_atomic_clean_old_fb(dev, plane_mask, ret);
 385
 386	if (ret == -EDEADLK)
 387		goto backoff;
 388
 389	if (ret != 0)
 390		drm_atomic_state_free(state);
 391
 392	return ret;
 393
 394backoff:
 395	drm_atomic_state_clear(state);
 396	drm_atomic_legacy_backoff(state);
 397
 398	goto retry;
 399}
 400
 401static int restore_fbdev_mode(struct drm_fb_helper *fb_helper)
 402{
 403	struct drm_device *dev = fb_helper->dev;
 404	struct drm_plane *plane;
 405	int i;
 406
 407	drm_warn_on_modeset_not_all_locked(dev);
 408
 409	if (fb_helper->atomic)
 410		return restore_fbdev_mode_atomic(fb_helper);
 411
 412	drm_for_each_plane(plane, dev) {
 413		if (plane->type != DRM_PLANE_TYPE_PRIMARY)
 414			drm_plane_force_disable(plane);
 415
 416		if (dev->mode_config.rotation_property) {
 417			drm_mode_plane_set_obj_prop(plane,
 418						    dev->mode_config.rotation_property,
 419						    BIT(DRM_ROTATE_0));
 420		}
 421	}
 422
 423	for (i = 0; i < fb_helper->crtc_count; i++) {
 424		struct drm_mode_set *mode_set = &fb_helper->crtc_info[i].mode_set;
 425		struct drm_crtc *crtc = mode_set->crtc;
 426		int ret;
 427
 428		if (crtc->funcs->cursor_set2) {
 429			ret = crtc->funcs->cursor_set2(crtc, NULL, 0, 0, 0, 0, 0);
 430			if (ret)
 431				return ret;
 432		} else if (crtc->funcs->cursor_set) {
 433			ret = crtc->funcs->cursor_set(crtc, NULL, 0, 0, 0);
 434			if (ret)
 435				return ret;
 436		}
 437
 438		ret = drm_mode_set_config_internal(mode_set);
 439		if (ret)
 440			return ret;
 441	}
 442
 443	return 0;
 444}
 445
 446/**
 447 * drm_fb_helper_restore_fbdev_mode_unlocked - restore fbdev configuration
 448 * @fb_helper: fbcon to restore
 449 *
 450 * This should be called from driver's drm ->lastclose callback
 451 * when implementing an fbcon on top of kms using this helper. This ensures that
 452 * the user isn't greeted with a black screen when e.g. X dies.
 453 *
 454 * RETURNS:
 455 * Zero if everything went ok, negative error code otherwise.
 456 */
 457int drm_fb_helper_restore_fbdev_mode_unlocked(struct drm_fb_helper *fb_helper)
 458{
 459	struct drm_device *dev = fb_helper->dev;
 460	bool do_delayed;
 461	int ret;
 462
 463	if (!drm_fbdev_emulation)
 464		return -ENODEV;
 465
 466	drm_modeset_lock_all(dev);
 467	ret = restore_fbdev_mode(fb_helper);
 468
 469	do_delayed = fb_helper->delayed_hotplug;
 470	if (do_delayed)
 471		fb_helper->delayed_hotplug = false;
 472	drm_modeset_unlock_all(dev);
 473
 474	if (do_delayed)
 475		drm_fb_helper_hotplug_event(fb_helper);
 476	return ret;
 477}
 478EXPORT_SYMBOL(drm_fb_helper_restore_fbdev_mode_unlocked);
 479
 480static bool drm_fb_helper_is_bound(struct drm_fb_helper *fb_helper)
 481{
 482	struct drm_device *dev = fb_helper->dev;
 483	struct drm_crtc *crtc;
 484	int bound = 0, crtcs_bound = 0;
 485
 486	/* Sometimes user space wants everything disabled, so don't steal the
 487	 * display if there's a master. */
 488	if (dev->primary->master)
 489		return false;
 490
 491	drm_for_each_crtc(crtc, dev) {
 492		if (crtc->primary->fb)
 493			crtcs_bound++;
 494		if (crtc->primary->fb == fb_helper->fb)
 495			bound++;
 496	}
 497
 498	if (bound < crtcs_bound)
 499		return false;
 500
 501	return true;
 502}
 503
 504#ifdef CONFIG_MAGIC_SYSRQ
 505/*
 506 * restore fbcon display for all kms driver's using this helper, used for sysrq
 507 * and panic handling.
 508 */
 509static bool drm_fb_helper_force_kernel_mode(void)
 510{
 511	bool ret, error = false;
 512	struct drm_fb_helper *helper;
 513
 514	if (list_empty(&kernel_fb_helper_list))
 515		return false;
 516
 517	list_for_each_entry(helper, &kernel_fb_helper_list, kernel_fb_list) {
 518		struct drm_device *dev = helper->dev;
 519
 520		if (dev->switch_power_state == DRM_SWITCH_POWER_OFF)
 521			continue;
 522
 523		drm_modeset_lock_all(dev);
 524		ret = restore_fbdev_mode(helper);
 525		if (ret)
 526			error = true;
 527		drm_modeset_unlock_all(dev);
 528	}
 529	return error;
 530}
 531
 532static void drm_fb_helper_restore_work_fn(struct work_struct *ignored)
 533{
 534	bool ret;
 535	ret = drm_fb_helper_force_kernel_mode();
 536	if (ret == true)
 537		DRM_ERROR("Failed to restore crtc configuration\n");
 538}
 539static DECLARE_WORK(drm_fb_helper_restore_work, drm_fb_helper_restore_work_fn);
 540
 541static void drm_fb_helper_sysrq(int dummy1)
 542{
 543	schedule_work(&drm_fb_helper_restore_work);
 544}
 545
 546static struct sysrq_key_op sysrq_drm_fb_helper_restore_op = {
 547	.handler = drm_fb_helper_sysrq,
 548	.help_msg = "force-fb(V)",
 549	.action_msg = "Restore framebuffer console",
 550};
 551#else
 552static struct sysrq_key_op sysrq_drm_fb_helper_restore_op = { };
 553#endif
 554
 555static void drm_fb_helper_dpms(struct fb_info *info, int dpms_mode)
 556{
 557	struct drm_fb_helper *fb_helper = info->par;
 558	struct drm_device *dev = fb_helper->dev;
 559	struct drm_crtc *crtc;
 560	struct drm_connector *connector;
 561	int i, j;
 562
 563	/*
 564	 * For each CRTC in this fb, turn the connectors on/off.
 565	 */
 566	drm_modeset_lock_all(dev);
 567	if (!drm_fb_helper_is_bound(fb_helper)) {
 568		drm_modeset_unlock_all(dev);
 569		return;
 570	}
 571
 572	for (i = 0; i < fb_helper->crtc_count; i++) {
 573		crtc = fb_helper->crtc_info[i].mode_set.crtc;
 574
 575		if (!crtc->enabled)
 576			continue;
 577
 578		/* Walk the connectors & encoders on this fb turning them on/off */
 579		for (j = 0; j < fb_helper->connector_count; j++) {
 580			connector = fb_helper->connector_info[j]->connector;
 581			connector->funcs->dpms(connector, dpms_mode);
 582			drm_object_property_set_value(&connector->base,
 583				dev->mode_config.dpms_property, dpms_mode);
 584		}
 585	}
 586	drm_modeset_unlock_all(dev);
 587}
 588
 589/**
 590 * drm_fb_helper_blank - implementation for ->fb_blank
 591 * @blank: desired blanking state
 592 * @info: fbdev registered by the helper
 593 */
 594int drm_fb_helper_blank(int blank, struct fb_info *info)
 595{
 596	if (oops_in_progress)
 597		return -EBUSY;
 598
 599	switch (blank) {
 600	/* Display: On; HSync: On, VSync: On */
 601	case FB_BLANK_UNBLANK:
 602		drm_fb_helper_dpms(info, DRM_MODE_DPMS_ON);
 603		break;
 604	/* Display: Off; HSync: On, VSync: On */
 605	case FB_BLANK_NORMAL:
 606		drm_fb_helper_dpms(info, DRM_MODE_DPMS_STANDBY);
 607		break;
 608	/* Display: Off; HSync: Off, VSync: On */
 609	case FB_BLANK_HSYNC_SUSPEND:
 610		drm_fb_helper_dpms(info, DRM_MODE_DPMS_STANDBY);
 611		break;
 612	/* Display: Off; HSync: On, VSync: Off */
 613	case FB_BLANK_VSYNC_SUSPEND:
 614		drm_fb_helper_dpms(info, DRM_MODE_DPMS_SUSPEND);
 615		break;
 616	/* Display: Off; HSync: Off, VSync: Off */
 617	case FB_BLANK_POWERDOWN:
 618		drm_fb_helper_dpms(info, DRM_MODE_DPMS_OFF);
 619		break;
 620	}
 621	return 0;
 622}
 623EXPORT_SYMBOL(drm_fb_helper_blank);
 624
 625static void drm_fb_helper_crtc_free(struct drm_fb_helper *helper)
 626{
 627	int i;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 628
 629	for (i = 0; i < helper->connector_count; i++)
 630		kfree(helper->connector_info[i]);
 631	kfree(helper->connector_info);
 632	for (i = 0; i < helper->crtc_count; i++) {
 633		kfree(helper->crtc_info[i].mode_set.connectors);
 634		if (helper->crtc_info[i].mode_set.mode)
 635			drm_mode_destroy(helper->dev, helper->crtc_info[i].mode_set.mode);
 
 
 
 
 
 
 
 636	}
 637	kfree(helper->crtc_info);
 
 
 
 
 
 
 
 
 
 
 
 
 
 638}
 639
 640/**
 641 * drm_fb_helper_prepare - setup a drm_fb_helper structure
 642 * @dev: DRM device
 643 * @helper: driver-allocated fbdev helper structure to set up
 644 * @funcs: pointer to structure of functions associate with this helper
 645 *
 646 * Sets up the bare minimum to make the framebuffer helper usable. This is
 647 * useful to implement race-free initialization of the polling helpers.
 648 */
 649void drm_fb_helper_prepare(struct drm_device *dev, struct drm_fb_helper *helper,
 650			   const struct drm_fb_helper_funcs *funcs)
 651{
 652	INIT_LIST_HEAD(&helper->kernel_fb_list);
 
 
 
 
 
 653	helper->funcs = funcs;
 654	helper->dev = dev;
 655}
 656EXPORT_SYMBOL(drm_fb_helper_prepare);
 657
 658/**
 659 * drm_fb_helper_init - initialize a drm_fb_helper structure
 660 * @dev: drm device
 661 * @fb_helper: driver-allocated fbdev helper structure to initialize
 662 * @crtc_count: maximum number of crtcs to support in this fbdev emulation
 663 * @max_conn_count: max connector count
 664 *
 665 * This allocates the structures for the fbdev helper with the given limits.
 666 * Note that this won't yet touch the hardware (through the driver interfaces)
 667 * nor register the fbdev. This is only done in drm_fb_helper_initial_config()
 668 * to allow driver writes more control over the exact init sequence.
 669 *
 670 * Drivers must call drm_fb_helper_prepare() before calling this function.
 671 *
 672 * RETURNS:
 673 * Zero if everything went ok, nonzero otherwise.
 674 */
 675int drm_fb_helper_init(struct drm_device *dev,
 676		       struct drm_fb_helper *fb_helper,
 677		       int crtc_count, int max_conn_count)
 678{
 679	struct drm_crtc *crtc;
 680	int i;
 681
 682	if (!drm_fbdev_emulation)
 
 683		return 0;
 684
 685	if (!max_conn_count)
 686		return -EINVAL;
 687
 688	fb_helper->crtc_info = kcalloc(crtc_count, sizeof(struct drm_fb_helper_crtc), GFP_KERNEL);
 689	if (!fb_helper->crtc_info)
 690		return -ENOMEM;
 691
 692	fb_helper->crtc_count = crtc_count;
 693	fb_helper->connector_info = kcalloc(dev->mode_config.num_connector, sizeof(struct drm_fb_helper_connector *), GFP_KERNEL);
 694	if (!fb_helper->connector_info) {
 695		kfree(fb_helper->crtc_info);
 696		return -ENOMEM;
 697	}
 698	fb_helper->connector_info_alloc_count = dev->mode_config.num_connector;
 699	fb_helper->connector_count = 0;
 700
 701	for (i = 0; i < crtc_count; i++) {
 702		fb_helper->crtc_info[i].mode_set.connectors =
 703			kcalloc(max_conn_count,
 704				sizeof(struct drm_connector *),
 705				GFP_KERNEL);
 706
 707		if (!fb_helper->crtc_info[i].mode_set.connectors)
 708			goto out_free;
 709		fb_helper->crtc_info[i].mode_set.num_connectors = 0;
 710	}
 711
 712	i = 0;
 713	drm_for_each_crtc(crtc, dev) {
 714		fb_helper->crtc_info[i].mode_set.crtc = crtc;
 715		i++;
 
 
 
 
 716	}
 717
 718	fb_helper->atomic = !!drm_core_check_feature(dev, DRIVER_ATOMIC);
 719
 720	return 0;
 721out_free:
 722	drm_fb_helper_crtc_free(fb_helper);
 723	return -ENOMEM;
 724}
 725EXPORT_SYMBOL(drm_fb_helper_init);
 726
 727/**
 728 * drm_fb_helper_alloc_fbi - allocate fb_info and some of its members
 729 * @fb_helper: driver-allocated fbdev helper
 730 *
 731 * A helper to alloc fb_info and the members cmap and apertures. Called
 732 * by the driver within the fb_probe fb_helper callback function.
 
 
 733 *
 734 * RETURNS:
 735 * fb_info pointer if things went okay, pointer containing error code
 736 * otherwise
 737 */
 738struct fb_info *drm_fb_helper_alloc_fbi(struct drm_fb_helper *fb_helper)
 739{
 740	struct device *dev = fb_helper->dev->dev;
 741	struct fb_info *info;
 742	int ret;
 743
 744	info = framebuffer_alloc(0, dev);
 745	if (!info)
 746		return ERR_PTR(-ENOMEM);
 747
 748	ret = fb_alloc_cmap(&info->cmap, 256, 0);
 749	if (ret)
 750		goto err_release;
 751
 
 
 
 
 
 
 
 
 752	info->apertures = alloc_apertures(1);
 753	if (!info->apertures) {
 754		ret = -ENOMEM;
 755		goto err_free_cmap;
 756	}
 757
 758	fb_helper->fbdev = info;
 
 759
 760	return info;
 761
 762err_free_cmap:
 763	fb_dealloc_cmap(&info->cmap);
 764err_release:
 765	framebuffer_release(info);
 766	return ERR_PTR(ret);
 767}
 768EXPORT_SYMBOL(drm_fb_helper_alloc_fbi);
 769
 770/**
 771 * drm_fb_helper_unregister_fbi - unregister fb_info framebuffer device
 772 * @fb_helper: driver-allocated fbdev helper
 773 *
 774 * A wrapper around unregister_framebuffer, to release the fb_info
 775 * framebuffer device
 
 776 */
 777void drm_fb_helper_unregister_fbi(struct drm_fb_helper *fb_helper)
 778{
 779	if (fb_helper && fb_helper->fbdev)
 780		unregister_framebuffer(fb_helper->fbdev);
 781}
 782EXPORT_SYMBOL(drm_fb_helper_unregister_fbi);
 783
 784/**
 785 * drm_fb_helper_release_fbi - dealloc fb_info and its members
 786 * @fb_helper: driver-allocated fbdev helper
 787 *
 788 * A helper to free memory taken by fb_info and the members cmap and
 789 * apertures
 790 */
 791void drm_fb_helper_release_fbi(struct drm_fb_helper *fb_helper)
 792{
 793	if (fb_helper) {
 794		struct fb_info *info = fb_helper->fbdev;
 795
 796		if (info) {
 797			if (info->cmap.len)
 798				fb_dealloc_cmap(&info->cmap);
 799			framebuffer_release(info);
 800		}
 801
 802		fb_helper->fbdev = NULL;
 803	}
 804}
 805EXPORT_SYMBOL(drm_fb_helper_release_fbi);
 806
 807void drm_fb_helper_fini(struct drm_fb_helper *fb_helper)
 808{
 809	if (!drm_fbdev_emulation)
 810		return;
 811
 
 
 
 
 
 
 
 
 
 
 
 
 812	if (!list_empty(&fb_helper->kernel_fb_list)) {
 813		list_del(&fb_helper->kernel_fb_list);
 814		if (list_empty(&kernel_fb_helper_list)) {
 815			unregister_sysrq_key('v', &sysrq_drm_fb_helper_restore_op);
 816		}
 817	}
 
 818
 819	drm_fb_helper_crtc_free(fb_helper);
 820
 
 
 821}
 822EXPORT_SYMBOL(drm_fb_helper_fini);
 823
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 824/**
 825 * drm_fb_helper_unlink_fbi - wrapper around unlink_framebuffer
 826 * @fb_helper: driver-allocated fbdev helper
 
 827 *
 828 * A wrapper around unlink_framebuffer implemented by fbdev core
 
 829 */
 830void drm_fb_helper_unlink_fbi(struct drm_fb_helper *fb_helper)
 
 831{
 832	if (fb_helper && fb_helper->fbdev)
 833		unlink_framebuffer(fb_helper->fbdev);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 834}
 835EXPORT_SYMBOL(drm_fb_helper_unlink_fbi);
 836
 837/**
 838 * drm_fb_helper_sys_read - wrapper around fb_sys_read
 839 * @info: fb_info struct pointer
 840 * @buf: userspace buffer to read from framebuffer memory
 841 * @count: number of bytes to read from framebuffer memory
 842 * @ppos: read offset within framebuffer memory
 843 *
 844 * A wrapper around fb_sys_read implemented by fbdev core
 845 */
 846ssize_t drm_fb_helper_sys_read(struct fb_info *info, char __user *buf,
 847			       size_t count, loff_t *ppos)
 848{
 849	return fb_sys_read(info, buf, count, ppos);
 850}
 851EXPORT_SYMBOL(drm_fb_helper_sys_read);
 852
 853/**
 854 * drm_fb_helper_sys_write - wrapper around fb_sys_write
 855 * @info: fb_info struct pointer
 856 * @buf: userspace buffer to write to framebuffer memory
 857 * @count: number of bytes to write to framebuffer memory
 858 * @ppos: write offset within framebuffer memory
 859 *
 860 * A wrapper around fb_sys_write implemented by fbdev core
 861 */
 862ssize_t drm_fb_helper_sys_write(struct fb_info *info, const char __user *buf,
 863				size_t count, loff_t *ppos)
 864{
 865	return fb_sys_write(info, buf, count, ppos);
 
 
 
 
 
 
 866}
 867EXPORT_SYMBOL(drm_fb_helper_sys_write);
 868
 869/**
 870 * drm_fb_helper_sys_fillrect - wrapper around sys_fillrect
 871 * @info: fbdev registered by the helper
 872 * @rect: info about rectangle to fill
 873 *
 874 * A wrapper around sys_fillrect implemented by fbdev core
 875 */
 876void drm_fb_helper_sys_fillrect(struct fb_info *info,
 877				const struct fb_fillrect *rect)
 878{
 879	sys_fillrect(info, rect);
 
 880}
 881EXPORT_SYMBOL(drm_fb_helper_sys_fillrect);
 882
 883/**
 884 * drm_fb_helper_sys_copyarea - wrapper around sys_copyarea
 885 * @info: fbdev registered by the helper
 886 * @area: info about area to copy
 887 *
 888 * A wrapper around sys_copyarea implemented by fbdev core
 889 */
 890void drm_fb_helper_sys_copyarea(struct fb_info *info,
 891				const struct fb_copyarea *area)
 892{
 893	sys_copyarea(info, area);
 
 894}
 895EXPORT_SYMBOL(drm_fb_helper_sys_copyarea);
 896
 897/**
 898 * drm_fb_helper_sys_imageblit - wrapper around sys_imageblit
 899 * @info: fbdev registered by the helper
 900 * @image: info about image to blit
 901 *
 902 * A wrapper around sys_imageblit implemented by fbdev core
 903 */
 904void drm_fb_helper_sys_imageblit(struct fb_info *info,
 905				 const struct fb_image *image)
 906{
 907	sys_imageblit(info, image);
 
 908}
 909EXPORT_SYMBOL(drm_fb_helper_sys_imageblit);
 910
 911/**
 912 * drm_fb_helper_cfb_fillrect - wrapper around cfb_fillrect
 913 * @info: fbdev registered by the helper
 914 * @rect: info about rectangle to fill
 915 *
 916 * A wrapper around cfb_imageblit implemented by fbdev core
 917 */
 918void drm_fb_helper_cfb_fillrect(struct fb_info *info,
 919				const struct fb_fillrect *rect)
 920{
 921	cfb_fillrect(info, rect);
 
 922}
 923EXPORT_SYMBOL(drm_fb_helper_cfb_fillrect);
 924
 925/**
 926 * drm_fb_helper_cfb_copyarea - wrapper around cfb_copyarea
 927 * @info: fbdev registered by the helper
 928 * @area: info about area to copy
 929 *
 930 * A wrapper around cfb_copyarea implemented by fbdev core
 931 */
 932void drm_fb_helper_cfb_copyarea(struct fb_info *info,
 933				const struct fb_copyarea *area)
 934{
 935	cfb_copyarea(info, area);
 
 936}
 937EXPORT_SYMBOL(drm_fb_helper_cfb_copyarea);
 938
 939/**
 940 * drm_fb_helper_cfb_imageblit - wrapper around cfb_imageblit
 941 * @info: fbdev registered by the helper
 942 * @image: info about image to blit
 943 *
 944 * A wrapper around cfb_imageblit implemented by fbdev core
 945 */
 946void drm_fb_helper_cfb_imageblit(struct fb_info *info,
 947				 const struct fb_image *image)
 948{
 949	cfb_imageblit(info, image);
 
 950}
 951EXPORT_SYMBOL(drm_fb_helper_cfb_imageblit);
 952
 953/**
 954 * drm_fb_helper_set_suspend - wrapper around fb_set_suspend
 955 * @fb_helper: driver-allocated fbdev helper
 956 * @state: desired state, zero to resume, non-zero to suspend
 957 *
 958 * A wrapper around fb_set_suspend implemented by fbdev core
 
 
 959 */
 960void drm_fb_helper_set_suspend(struct drm_fb_helper *fb_helper, int state)
 961{
 962	if (fb_helper && fb_helper->fbdev)
 963		fb_set_suspend(fb_helper->fbdev, state);
 964}
 965EXPORT_SYMBOL(drm_fb_helper_set_suspend);
 966
 967static int setcolreg(struct drm_crtc *crtc, u16 red, u16 green,
 968		     u16 blue, u16 regno, struct fb_info *info)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 969{
 970	struct drm_fb_helper *fb_helper = info->par;
 971	struct drm_framebuffer *fb = fb_helper->fb;
 972	int pindex;
 
 
 
 
 
 
 
 
 973
 974	if (info->fix.visual == FB_VISUAL_TRUECOLOR) {
 975		u32 *palette;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 976		u32 value;
 977		/* place color in psuedopalette */
 978		if (regno > 16)
 979			return -EINVAL;
 980		palette = (u32 *)info->pseudo_palette;
 981		red >>= (16 - info->var.red.length);
 982		green >>= (16 - info->var.green.length);
 983		blue >>= (16 - info->var.blue.length);
 984		value = (red << info->var.red.offset) |
 985			(green << info->var.green.offset) |
 986			(blue << info->var.blue.offset);
 987		if (info->var.transp.length > 0) {
 988			u32 mask = (1 << info->var.transp.length) - 1;
 
 989			mask <<= info->var.transp.offset;
 990			value |= mask;
 991		}
 992		palette[regno] = value;
 993		return 0;
 994	}
 995
 996	/*
 997	 * The driver really shouldn't advertise pseudo/directcolor
 998	 * visuals if it can't deal with the palette.
 999	 */
1000	if (WARN_ON(!fb_helper->funcs->gamma_set ||
1001		    !fb_helper->funcs->gamma_get))
1002		return -EINVAL;
 
 
 
1003
1004	pindex = regno;
 
 
 
 
 
 
1005
1006	if (fb->bits_per_pixel == 16) {
1007		pindex = regno << 3;
 
 
1008
1009		if (fb->depth == 16 && regno > 63)
1010			return -EINVAL;
1011		if (fb->depth == 15 && regno > 31)
1012			return -EINVAL;
1013
1014		if (fb->depth == 16) {
1015			u16 r, g, b;
1016			int i;
1017			if (regno < 32) {
1018				for (i = 0; i < 8; i++)
1019					fb_helper->funcs->gamma_set(crtc, red,
1020						green, blue, pindex + i);
1021			}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1022
1023			fb_helper->funcs->gamma_get(crtc, &r,
1024						    &g, &b,
1025						    pindex >> 1);
1026
1027			for (i = 0; i < 4; i++)
1028				fb_helper->funcs->gamma_set(crtc, r,
1029							    green, b,
1030							    (pindex >> 1) + i);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1031		}
1032	}
1033
1034	if (fb->depth != 16)
1035		fb_helper->funcs->gamma_set(crtc, red, green, blue, pindex);
1036	return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1037}
1038
1039/**
1040 * drm_fb_helper_setcmap - implementation for ->fb_setcmap
1041 * @cmap: cmap to set
1042 * @info: fbdev registered by the helper
1043 */
1044int drm_fb_helper_setcmap(struct fb_cmap *cmap, struct fb_info *info)
1045{
1046	struct drm_fb_helper *fb_helper = info->par;
1047	struct drm_device *dev = fb_helper->dev;
1048	const struct drm_crtc_helper_funcs *crtc_funcs;
1049	u16 *red, *green, *blue, *transp;
1050	struct drm_crtc *crtc;
1051	int i, j, rc = 0;
1052	int start;
1053
1054	if (oops_in_progress)
1055		return -EBUSY;
1056
1057	drm_modeset_lock_all(dev);
1058	if (!drm_fb_helper_is_bound(fb_helper)) {
1059		drm_modeset_unlock_all(dev);
1060		return -EBUSY;
1061	}
1062
1063	for (i = 0; i < fb_helper->crtc_count; i++) {
1064		crtc = fb_helper->crtc_info[i].mode_set.crtc;
1065		crtc_funcs = crtc->helper_private;
1066
1067		red = cmap->red;
1068		green = cmap->green;
1069		blue = cmap->blue;
1070		transp = cmap->transp;
1071		start = cmap->start;
1072
1073		for (j = 0; j < cmap->len; j++) {
1074			u16 hred, hgreen, hblue, htransp = 0xffff;
1075
1076			hred = *red++;
1077			hgreen = *green++;
1078			hblue = *blue++;
1079
1080			if (transp)
1081				htransp = *transp++;
1082
1083			rc = setcolreg(crtc, hred, hgreen, hblue, start++, info);
1084			if (rc)
1085				goto out;
1086		}
1087		if (crtc_funcs->load_lut)
1088			crtc_funcs->load_lut(crtc);
1089	}
1090 out:
1091	drm_modeset_unlock_all(dev);
1092	return rc;
 
 
 
 
 
 
 
 
 
 
 
 
1093}
1094EXPORT_SYMBOL(drm_fb_helper_setcmap);
1095
1096/**
1097 * drm_fb_helper_check_var - implementation for ->fb_check_var
1098 * @var: screeninfo to check
1099 * @info: fbdev registered by the helper
 
 
 
 
 
1100 */
1101int drm_fb_helper_check_var(struct fb_var_screeninfo *var,
1102			    struct fb_info *info)
1103{
1104	struct drm_fb_helper *fb_helper = info->par;
1105	struct drm_framebuffer *fb = fb_helper->fb;
1106	int depth;
1107
1108	if (var->pixclock != 0 || in_dbg_master())
1109		return -EINVAL;
1110
1111	/* Need to resize the fb object !!! */
1112	if (var->bits_per_pixel > fb->bits_per_pixel ||
1113	    var->xres > fb->width || var->yres > fb->height ||
1114	    var->xres_virtual > fb->width || var->yres_virtual > fb->height) {
1115		DRM_DEBUG("fb userspace requested width/height/bpp is greater than current fb "
1116			  "request %dx%d-%d (virtual %dx%d) > %dx%d-%d\n",
1117			  var->xres, var->yres, var->bits_per_pixel,
1118			  var->xres_virtual, var->yres_virtual,
1119			  fb->width, fb->height, fb->bits_per_pixel);
1120		return -EINVAL;
1121	}
1122
1123	switch (var->bits_per_pixel) {
1124	case 16:
1125		depth = (var->green.length == 6) ? 16 : 15;
1126		break;
1127	case 32:
1128		depth = (var->transp.length > 0) ? 32 : 24;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1129		break;
1130	default:
1131		depth = var->bits_per_pixel;
1132		break;
1133	}
1134
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1135	switch (depth) {
1136	case 8:
1137		var->red.offset = 0;
1138		var->green.offset = 0;
1139		var->blue.offset = 0;
1140		var->red.length = 8;
1141		var->green.length = 8;
1142		var->blue.length = 8;
1143		var->transp.length = 0;
1144		var->transp.offset = 0;
 
1145		break;
1146	case 15:
1147		var->red.offset = 10;
1148		var->green.offset = 5;
1149		var->blue.offset = 0;
1150		var->red.length = 5;
1151		var->green.length = 5;
1152		var->blue.length = 5;
1153		var->transp.length = 1;
1154		var->transp.offset = 15;
 
1155		break;
1156	case 16:
1157		var->red.offset = 11;
1158		var->green.offset = 5;
1159		var->blue.offset = 0;
1160		var->red.length = 5;
1161		var->green.length = 6;
1162		var->blue.length = 5;
1163		var->transp.length = 0;
1164		var->transp.offset = 0;
1165		break;
1166	case 24:
1167		var->red.offset = 16;
1168		var->green.offset = 8;
1169		var->blue.offset = 0;
1170		var->red.length = 8;
1171		var->green.length = 8;
1172		var->blue.length = 8;
1173		var->transp.length = 0;
1174		var->transp.offset = 0;
 
1175		break;
1176	case 32:
1177		var->red.offset = 16;
1178		var->green.offset = 8;
1179		var->blue.offset = 0;
1180		var->red.length = 8;
1181		var->green.length = 8;
1182		var->blue.length = 8;
1183		var->transp.length = 8;
1184		var->transp.offset = 24;
 
1185		break;
1186	default:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1187		return -EINVAL;
 
 
 
 
1188	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1189	return 0;
1190}
1191EXPORT_SYMBOL(drm_fb_helper_check_var);
1192
1193/**
1194 * drm_fb_helper_set_par - implementation for ->fb_set_par
1195 * @info: fbdev registered by the helper
1196 *
1197 * This will let fbcon do the mode init and is called at initialization time by
1198 * the fbdev core when registering the driver, and later on through the hotplug
1199 * callback.
1200 */
1201int drm_fb_helper_set_par(struct fb_info *info)
1202{
1203	struct drm_fb_helper *fb_helper = info->par;
1204	struct fb_var_screeninfo *var = &info->var;
 
1205
1206	if (oops_in_progress)
1207		return -EBUSY;
1208
1209	if (var->pixclock != 0) {
1210		DRM_ERROR("PIXEL CLOCK SET\n");
1211		return -EINVAL;
1212	}
1213
1214	drm_fb_helper_restore_fbdev_mode_unlocked(fb_helper);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1215
1216	return 0;
1217}
1218EXPORT_SYMBOL(drm_fb_helper_set_par);
1219
 
 
 
 
 
 
 
 
 
 
 
 
1220static int pan_display_atomic(struct fb_var_screeninfo *var,
1221			      struct fb_info *info)
1222{
1223	struct drm_fb_helper *fb_helper = info->par;
1224	struct drm_device *dev = fb_helper->dev;
1225	struct drm_atomic_state *state;
1226	struct drm_plane *plane;
1227	int i, ret;
1228	unsigned plane_mask;
1229
1230	state = drm_atomic_state_alloc(dev);
1231	if (!state)
1232		return -ENOMEM;
1233
1234	state->acquire_ctx = dev->mode_config.acquire_ctx;
1235retry:
1236	plane_mask = 0;
1237	for(i = 0; i < fb_helper->crtc_count; i++) {
1238		struct drm_mode_set *mode_set;
1239
1240		mode_set = &fb_helper->crtc_info[i].mode_set;
1241
1242		mode_set->x = var->xoffset;
1243		mode_set->y = var->yoffset;
1244
1245		ret = __drm_atomic_helper_set_config(mode_set, state);
1246		if (ret != 0)
1247			goto fail;
1248
1249		plane = mode_set->crtc->primary;
1250		plane_mask |= (1 << drm_plane_index(plane));
1251		plane->old_fb = plane->fb;
1252	}
1253
1254	ret = drm_atomic_commit(state);
1255	if (ret != 0)
1256		goto fail;
1257
1258	info->var.xoffset = var->xoffset;
1259	info->var.yoffset = var->yoffset;
 
 
 
 
1260
 
 
1261
1262fail:
1263	drm_atomic_clean_old_fb(dev, plane_mask, ret);
 
 
 
 
 
1264
1265	if (ret == -EDEADLK)
1266		goto backoff;
 
 
 
1267
1268	if (ret != 0)
1269		drm_atomic_state_free(state);
 
 
 
 
 
 
 
 
1270
1271	return ret;
1272
1273backoff:
1274	drm_atomic_state_clear(state);
1275	drm_atomic_legacy_backoff(state);
1276
1277	goto retry;
1278}
1279
1280/**
1281 * drm_fb_helper_pan_display - implementation for ->fb_pan_display
1282 * @var: updated screen information
1283 * @info: fbdev registered by the helper
1284 */
1285int drm_fb_helper_pan_display(struct fb_var_screeninfo *var,
1286			      struct fb_info *info)
1287{
1288	struct drm_fb_helper *fb_helper = info->par;
1289	struct drm_device *dev = fb_helper->dev;
1290	struct drm_mode_set *modeset;
1291	int ret = 0;
1292	int i;
1293
1294	if (oops_in_progress)
1295		return -EBUSY;
1296
1297	drm_modeset_lock_all(dev);
1298	if (!drm_fb_helper_is_bound(fb_helper)) {
1299		drm_modeset_unlock_all(dev);
1300		return -EBUSY;
1301	}
1302
1303	if (fb_helper->atomic) {
1304		ret = pan_display_atomic(var, info);
1305		goto unlock;
1306	}
1307
1308	for (i = 0; i < fb_helper->crtc_count; i++) {
1309		modeset = &fb_helper->crtc_info[i].mode_set;
1310
1311		modeset->x = var->xoffset;
1312		modeset->y = var->yoffset;
1313
1314		if (modeset->num_connectors) {
1315			ret = drm_mode_set_config_internal(modeset);
1316			if (!ret) {
1317				info->var.xoffset = var->xoffset;
1318				info->var.yoffset = var->yoffset;
1319			}
1320		}
1321	}
1322unlock:
1323	drm_modeset_unlock_all(dev);
 
1324	return ret;
1325}
1326EXPORT_SYMBOL(drm_fb_helper_pan_display);
1327
1328/*
1329 * Allocates the backing storage and sets up the fbdev info structure through
1330 * the ->fb_probe callback and then registers the fbdev and sets up the panic
1331 * notifier.
1332 */
1333static int drm_fb_helper_single_fb_probe(struct drm_fb_helper *fb_helper,
1334					 int preferred_bpp)
1335{
 
 
 
1336	int ret = 0;
1337	int crtc_count = 0;
1338	int i;
1339	struct fb_info *info;
1340	struct drm_fb_helper_surface_size sizes;
1341	int gamma_size = 0;
 
 
1342
1343	memset(&sizes, 0, sizeof(struct drm_fb_helper_surface_size));
1344	sizes.surface_depth = 24;
1345	sizes.surface_bpp = 32;
1346	sizes.fb_width = (unsigned)-1;
1347	sizes.fb_height = (unsigned)-1;
1348
1349	/* if driver picks 8 or 16 by default use that
1350	   for both depth/bpp */
 
 
1351	if (preferred_bpp != sizes.surface_bpp)
1352		sizes.surface_depth = sizes.surface_bpp = preferred_bpp;
1353
1354	/* first up get a count of crtcs now in use and new min/maxes width/heights */
1355	for (i = 0; i < fb_helper->connector_count; i++) {
1356		struct drm_fb_helper_connector *fb_helper_conn = fb_helper->connector_info[i];
1357		struct drm_cmdline_mode *cmdline_mode;
1358
1359		cmdline_mode = &fb_helper_conn->connector->cmdline_mode;
1360
1361		if (cmdline_mode->bpp_specified) {
1362			switch (cmdline_mode->bpp) {
1363			case 8:
1364				sizes.surface_depth = sizes.surface_bpp = 8;
1365				break;
1366			case 15:
1367				sizes.surface_depth = 15;
1368				sizes.surface_bpp = 16;
1369				break;
1370			case 16:
1371				sizes.surface_depth = sizes.surface_bpp = 16;
1372				break;
1373			case 24:
1374				sizes.surface_depth = sizes.surface_bpp = 24;
1375				break;
1376			case 32:
1377				sizes.surface_depth = 24;
1378				sizes.surface_bpp = 32;
1379				break;
1380			}
1381			break;
1382		}
1383	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1384
 
1385	crtc_count = 0;
1386	for (i = 0; i < fb_helper->crtc_count; i++) {
1387		struct drm_display_mode *desired_mode;
1388		struct drm_mode_set *mode_set;
1389		int x, y, j;
1390		/* in case of tile group, are we the last tile vert or horiz?
1391		 * If no tile group you are always the last one both vertically
1392		 * and horizontally
1393		 */
1394		bool lastv = true, lasth = true;
1395
1396		desired_mode = fb_helper->crtc_info[i].desired_mode;
1397		mode_set = &fb_helper->crtc_info[i].mode_set;
1398
1399		if (!desired_mode)
1400			continue;
1401
1402		crtc_count++;
1403
1404		x = fb_helper->crtc_info[i].x;
1405		y = fb_helper->crtc_info[i].y;
1406
1407		if (gamma_size == 0)
1408			gamma_size = fb_helper->crtc_info[i].mode_set.crtc->gamma_size;
1409
1410		sizes.surface_width  = max_t(u32, desired_mode->hdisplay + x, sizes.surface_width);
1411		sizes.surface_height = max_t(u32, desired_mode->vdisplay + y, sizes.surface_height);
1412
1413		for (j = 0; j < mode_set->num_connectors; j++) {
1414			struct drm_connector *connector = mode_set->connectors[j];
1415			if (connector->has_tile) {
 
 
 
1416				lasth = (connector->tile_h_loc == (connector->num_h_tile - 1));
1417				lastv = (connector->tile_v_loc == (connector->num_v_tile - 1));
1418				/* cloning to multiple tiles is just crazy-talk, so: */
1419				break;
1420			}
1421		}
1422
1423		if (lasth)
1424			sizes.fb_width  = min_t(u32, desired_mode->hdisplay + x, sizes.fb_width);
1425		if (lastv)
1426			sizes.fb_height = min_t(u32, desired_mode->vdisplay + y, sizes.fb_height);
1427	}
 
1428
1429	if (crtc_count == 0 || sizes.fb_width == -1 || sizes.fb_height == -1) {
1430		/* hmm everyone went away - assume VGA cable just fell out
1431		   and will come back later. */
1432		DRM_INFO("Cannot find any crtc or sizes - going 1024x768\n");
1433		sizes.fb_width = sizes.surface_width = 1024;
1434		sizes.fb_height = sizes.surface_height = 768;
 
 
 
 
 
 
 
 
 
 
1435	}
1436
1437	/* push down into drivers */
1438	ret = (*fb_helper->funcs->fb_probe)(fb_helper, &sizes);
1439	if (ret < 0)
1440		return ret;
1441
1442	info = fb_helper->fbdev;
1443
1444	/*
1445	 * Set the fb pointer - usually drm_setup_crtcs does this for hotplug
1446	 * events, but at init time drm_setup_crtcs needs to be called before
1447	 * the fb is allocated (since we need to figure out the desired size of
1448	 * the fb before we can allocate it ...). Hence we need to fix things up
1449	 * here again.
1450	 */
1451	for (i = 0; i < fb_helper->crtc_count; i++)
1452		if (fb_helper->crtc_info[i].mode_set.num_connectors)
1453			fb_helper->crtc_info[i].mode_set.fb = fb_helper->fb;
1454
1455
1456	info->var.pixclock = 0;
1457	if (register_framebuffer(info) < 0)
1458		return -EINVAL;
1459
1460	dev_info(fb_helper->dev->dev, "fb%d: %s frame buffer device\n",
1461			info->node, info->fix.id);
1462
1463	if (list_empty(&kernel_fb_helper_list)) {
1464		register_sysrq_key('v', &sysrq_drm_fb_helper_restore_op);
1465	}
1466
1467	list_add(&fb_helper->kernel_fb_list, &kernel_fb_helper_list);
1468
1469	return 0;
1470}
1471
1472/**
1473 * drm_fb_helper_fill_fix - initializes fixed fbdev information
1474 * @info: fbdev registered by the helper
1475 * @pitch: desired pitch
1476 * @depth: desired depth
1477 *
1478 * Helper to fill in the fixed fbdev information useful for a non-accelerated
1479 * fbdev emulations. Drivers which support acceleration methods which impose
1480 * additional constraints need to set up their own limits.
1481 *
1482 * Drivers should call this (or their equivalent setup code) from their
1483 * ->fb_probe callback.
1484 */
1485void drm_fb_helper_fill_fix(struct fb_info *info, uint32_t pitch,
1486			    uint32_t depth)
1487{
1488	info->fix.type = FB_TYPE_PACKED_PIXELS;
1489	info->fix.visual = depth == 8 ? FB_VISUAL_PSEUDOCOLOR :
1490		FB_VISUAL_TRUECOLOR;
1491	info->fix.mmio_start = 0;
1492	info->fix.mmio_len = 0;
1493	info->fix.type_aux = 0;
1494	info->fix.xpanstep = 1; /* doing it in hw */
1495	info->fix.ypanstep = 1; /* doing it in hw */
1496	info->fix.ywrapstep = 0;
1497	info->fix.accel = FB_ACCEL_NONE;
1498
1499	info->fix.line_length = pitch;
1500	return;
1501}
1502EXPORT_SYMBOL(drm_fb_helper_fill_fix);
1503
1504/**
1505 * drm_fb_helper_fill_var - initalizes variable fbdev information
1506 * @info: fbdev instance to set up
1507 * @fb_helper: fb helper instance to use as template
1508 * @fb_width: desired fb width
1509 * @fb_height: desired fb height
1510 *
1511 * Sets up the variable fbdev metainformation from the given fb helper instance
1512 * and the drm framebuffer allocated in fb_helper->fb.
1513 *
1514 * Drivers should call this (or their equivalent setup code) from their
1515 * ->fb_probe callback after having allocated the fbdev backing
1516 * storage framebuffer.
1517 */
1518void drm_fb_helper_fill_var(struct fb_info *info, struct drm_fb_helper *fb_helper,
1519			    uint32_t fb_width, uint32_t fb_height)
1520{
1521	struct drm_framebuffer *fb = fb_helper->fb;
 
 
 
1522	info->pseudo_palette = fb_helper->pseudo_palette;
1523	info->var.xres_virtual = fb->width;
1524	info->var.yres_virtual = fb->height;
1525	info->var.bits_per_pixel = fb->bits_per_pixel;
1526	info->var.accel_flags = FB_ACCELF_TEXT;
1527	info->var.xoffset = 0;
1528	info->var.yoffset = 0;
1529	info->var.activate = FB_ACTIVATE_NOW;
1530	info->var.height = -1;
1531	info->var.width = -1;
1532
1533	switch (fb->depth) {
1534	case 8:
1535		info->var.red.offset = 0;
1536		info->var.green.offset = 0;
1537		info->var.blue.offset = 0;
1538		info->var.red.length = 8; /* 8bit DAC */
1539		info->var.green.length = 8;
1540		info->var.blue.length = 8;
1541		info->var.transp.offset = 0;
1542		info->var.transp.length = 0;
1543		break;
1544	case 15:
1545		info->var.red.offset = 10;
1546		info->var.green.offset = 5;
1547		info->var.blue.offset = 0;
1548		info->var.red.length = 5;
1549		info->var.green.length = 5;
1550		info->var.blue.length = 5;
1551		info->var.transp.offset = 15;
1552		info->var.transp.length = 1;
1553		break;
1554	case 16:
1555		info->var.red.offset = 11;
1556		info->var.green.offset = 5;
1557		info->var.blue.offset = 0;
1558		info->var.red.length = 5;
1559		info->var.green.length = 6;
1560		info->var.blue.length = 5;
1561		info->var.transp.offset = 0;
1562		break;
1563	case 24:
1564		info->var.red.offset = 16;
1565		info->var.green.offset = 8;
1566		info->var.blue.offset = 0;
1567		info->var.red.length = 8;
1568		info->var.green.length = 8;
1569		info->var.blue.length = 8;
1570		info->var.transp.offset = 0;
1571		info->var.transp.length = 0;
1572		break;
1573	case 32:
1574		info->var.red.offset = 16;
1575		info->var.green.offset = 8;
1576		info->var.blue.offset = 0;
1577		info->var.red.length = 8;
1578		info->var.green.length = 8;
1579		info->var.blue.length = 8;
1580		info->var.transp.offset = 24;
1581		info->var.transp.length = 8;
1582		break;
1583	default:
1584		break;
1585	}
1586
1587	info->var.xres = fb_width;
1588	info->var.yres = fb_height;
1589}
1590EXPORT_SYMBOL(drm_fb_helper_fill_var);
1591
1592static int drm_fb_helper_probe_connector_modes(struct drm_fb_helper *fb_helper,
1593					       uint32_t maxX,
1594					       uint32_t maxY)
 
 
 
 
 
 
 
 
 
 
 
 
 
1595{
1596	struct drm_connector *connector;
1597	int count = 0;
1598	int i;
1599
1600	for (i = 0; i < fb_helper->connector_count; i++) {
1601		connector = fb_helper->connector_info[i]->connector;
1602		count += connector->funcs->fill_modes(connector, maxX, maxY);
1603	}
 
 
 
1604
1605	return count;
1606}
 
1607
1608struct drm_display_mode *drm_has_preferred_mode(struct drm_fb_helper_connector *fb_connector, int width, int height)
1609{
1610	struct drm_display_mode *mode;
 
 
 
 
 
 
 
 
 
 
 
 
1611
1612	list_for_each_entry(mode, &fb_connector->connector->modes, head) {
1613		if (mode->hdisplay > width ||
1614		    mode->vdisplay > height)
1615			continue;
1616		if (mode->type & DRM_MODE_TYPE_PREFERRED)
1617			return mode;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1618	}
1619	return NULL;
1620}
1621EXPORT_SYMBOL(drm_has_preferred_mode);
1622
1623static bool drm_has_cmdline_mode(struct drm_fb_helper_connector *fb_connector)
 
 
 
1624{
1625	return fb_connector->connector->cmdline_mode.specified;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1626}
1627
1628struct drm_display_mode *drm_pick_cmdline_mode(struct drm_fb_helper_connector *fb_helper_conn,
1629						      int width, int height)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1630{
1631	struct drm_cmdline_mode *cmdline_mode;
1632	struct drm_display_mode *mode;
1633	bool prefer_non_interlace;
1634
1635	cmdline_mode = &fb_helper_conn->connector->cmdline_mode;
1636	if (cmdline_mode->specified == false)
1637		return NULL;
1638
1639	/* attempt to find a matching mode in the list of modes
1640	 *  we have gotten so far, if not add a CVT mode that conforms
1641	 */
1642	if (cmdline_mode->rb || cmdline_mode->margins)
1643		goto create_mode;
1644
1645	prefer_non_interlace = !cmdline_mode->interlace;
1646again:
1647	list_for_each_entry(mode, &fb_helper_conn->connector->modes, head) {
1648		/* check width/height */
1649		if (mode->hdisplay != cmdline_mode->xres ||
1650		    mode->vdisplay != cmdline_mode->yres)
1651			continue;
1652
1653		if (cmdline_mode->refresh_specified) {
1654			if (mode->vrefresh != cmdline_mode->refresh)
1655				continue;
1656		}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1657
1658		if (cmdline_mode->interlace) {
1659			if (!(mode->flags & DRM_MODE_FLAG_INTERLACE))
1660				continue;
1661		} else if (prefer_non_interlace) {
1662			if (mode->flags & DRM_MODE_FLAG_INTERLACE)
1663				continue;
1664		}
1665		return mode;
1666	}
1667
1668	if (prefer_non_interlace) {
1669		prefer_non_interlace = false;
1670		goto again;
 
1671	}
1672
1673create_mode:
1674	mode = drm_mode_create_from_cmdline_mode(fb_helper_conn->connector->dev,
1675						 cmdline_mode);
1676	list_add(&mode->head, &fb_helper_conn->connector->modes);
1677	return mode;
 
 
 
 
 
 
1678}
1679EXPORT_SYMBOL(drm_pick_cmdline_mode);
1680
1681static bool drm_connector_enabled(struct drm_connector *connector, bool strict)
 
 
 
 
 
 
 
1682{
1683	bool enable;
 
 
1684
1685	if (strict)
1686		enable = connector->status == connector_status_connected;
1687	else
1688		enable = connector->status != connector_status_disconnected;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1689
1690	return enable;
1691}
1692
1693static void drm_enable_connectors(struct drm_fb_helper *fb_helper,
1694				  bool *enabled)
1695{
1696	bool any_enabled = false;
1697	struct drm_connector *connector;
1698	int i = 0;
1699
1700	for (i = 0; i < fb_helper->connector_count; i++) {
1701		connector = fb_helper->connector_info[i]->connector;
1702		enabled[i] = drm_connector_enabled(connector, true);
1703		DRM_DEBUG_KMS("connector %d enabled? %s\n", connector->base.id,
1704			  enabled[i] ? "yes" : "no");
1705		any_enabled |= enabled[i];
1706	}
1707
1708	if (any_enabled)
 
 
 
 
 
1709		return;
1710
1711	for (i = 0; i < fb_helper->connector_count; i++) {
1712		connector = fb_helper->connector_info[i]->connector;
1713		enabled[i] = drm_connector_enabled(connector, false);
 
 
1714	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1715}
1716
1717static bool drm_target_cloned(struct drm_fb_helper *fb_helper,
1718			      struct drm_display_mode **modes,
1719			      struct drm_fb_offset *offsets,
1720			      bool *enabled, int width, int height)
 
1721{
1722	int count, i, j;
1723	bool can_clone = false;
1724	struct drm_fb_helper_connector *fb_helper_conn;
1725	struct drm_display_mode *dmt_mode, *mode;
1726
1727	/* only contemplate cloning in the single crtc case */
1728	if (fb_helper->crtc_count > 1)
1729		return false;
1730
1731	count = 0;
1732	for (i = 0; i < fb_helper->connector_count; i++) {
1733		if (enabled[i])
1734			count++;
1735	}
1736
1737	/* only contemplate cloning if more than one connector is enabled */
1738	if (count <= 1)
1739		return false;
 
1740
1741	/* check the command line or if nothing common pick 1024x768 */
1742	can_clone = true;
1743	for (i = 0; i < fb_helper->connector_count; i++) {
1744		if (!enabled[i])
1745			continue;
1746		fb_helper_conn = fb_helper->connector_info[i];
1747		modes[i] = drm_pick_cmdline_mode(fb_helper_conn, width, height);
1748		if (!modes[i]) {
1749			can_clone = false;
 
 
 
 
 
 
 
 
 
 
 
 
 
1750			break;
1751		}
1752		for (j = 0; j < i; j++) {
1753			if (!enabled[j])
1754				continue;
1755			if (!drm_mode_equal(modes[j], modes[i]))
1756				can_clone = false;
1757		}
1758	}
1759
1760	if (can_clone) {
1761		DRM_DEBUG_KMS("can clone using command line\n");
1762		return true;
 
1763	}
1764
1765	/* try and find a 1024x768 mode on each connector */
1766	can_clone = true;
1767	dmt_mode = drm_mode_find_dmt(fb_helper->dev, 1024, 768, 60, false);
1768
1769	for (i = 0; i < fb_helper->connector_count; i++) {
 
1770
1771		if (!enabled[i])
1772			continue;
 
 
1773
1774		fb_helper_conn = fb_helper->connector_info[i];
1775		list_for_each_entry(mode, &fb_helper_conn->connector->modes, head) {
1776			if (drm_mode_equal(mode, dmt_mode))
1777				modes[i] = mode;
1778		}
1779		if (!modes[i])
1780			can_clone = false;
1781	}
1782
1783	if (can_clone) {
1784		DRM_DEBUG_KMS("can clone using 1024x768\n");
1785		return true;
1786	}
1787	DRM_INFO("kms: can't enable cloning when we probably wanted to.\n");
1788	return false;
1789}
1790
1791static int drm_get_tile_offsets(struct drm_fb_helper *fb_helper,
1792				struct drm_display_mode **modes,
1793				struct drm_fb_offset *offsets,
1794				int idx,
1795				int h_idx, int v_idx)
1796{
1797	struct drm_fb_helper_connector *fb_helper_conn;
1798	int i;
1799	int hoffset = 0, voffset = 0;
1800
1801	for (i = 0; i < fb_helper->connector_count; i++) {
1802		fb_helper_conn = fb_helper->connector_info[i];
1803		if (!fb_helper_conn->connector->has_tile)
1804			continue;
1805
1806		if (!modes[i] && (h_idx || v_idx)) {
1807			DRM_DEBUG_KMS("no modes for connector tiled %d %d\n", i,
1808				      fb_helper_conn->connector->base.id);
1809			continue;
1810		}
1811		if (fb_helper_conn->connector->tile_h_loc < h_idx)
1812			hoffset += modes[i]->hdisplay;
1813
1814		if (fb_helper_conn->connector->tile_v_loc < v_idx)
1815			voffset += modes[i]->vdisplay;
1816	}
1817	offsets[idx].x = hoffset;
1818	offsets[idx].y = voffset;
1819	DRM_DEBUG_KMS("returned %d %d for %d %d\n", hoffset, voffset, h_idx, v_idx);
1820	return 0;
 
 
1821}
1822
1823static bool drm_target_preferred(struct drm_fb_helper *fb_helper,
1824				 struct drm_display_mode **modes,
1825				 struct drm_fb_offset *offsets,
1826				 bool *enabled, int width, int height)
1827{
1828	struct drm_fb_helper_connector *fb_helper_conn;
1829	int i;
1830	uint64_t conn_configured = 0, mask;
1831	int tile_pass = 0;
1832	mask = (1 << fb_helper->connector_count) - 1;
1833retry:
1834	for (i = 0; i < fb_helper->connector_count; i++) {
1835		fb_helper_conn = fb_helper->connector_info[i];
1836
1837		if (conn_configured & (1 << i))
1838			continue;
 
1839
1840		if (enabled[i] == false) {
1841			conn_configured |= (1 << i);
1842			continue;
 
 
 
1843		}
 
1844
1845		/* first pass over all the untiled connectors */
1846		if (tile_pass == 0 && fb_helper_conn->connector->has_tile)
1847			continue;
 
 
1848
1849		if (tile_pass == 1) {
1850			if (fb_helper_conn->connector->tile_h_loc != 0 ||
1851			    fb_helper_conn->connector->tile_v_loc != 0)
1852				continue;
1853
1854		} else {
1855			if (fb_helper_conn->connector->tile_h_loc != tile_pass -1 &&
1856			    fb_helper_conn->connector->tile_v_loc != tile_pass - 1)
1857			/* if this tile_pass doesn't cover any of the tiles - keep going */
1858				continue;
1859
1860			/* find the tile offsets for this pass - need
1861			   to find all tiles left and above */
1862			drm_get_tile_offsets(fb_helper, modes, offsets,
1863					     i, fb_helper_conn->connector->tile_h_loc, fb_helper_conn->connector->tile_v_loc);
1864		}
1865		DRM_DEBUG_KMS("looking for cmdline mode on connector %d\n",
1866			      fb_helper_conn->connector->base.id);
1867
1868		/* got for command line mode first */
1869		modes[i] = drm_pick_cmdline_mode(fb_helper_conn, width, height);
1870		if (!modes[i]) {
1871			DRM_DEBUG_KMS("looking for preferred mode on connector %d %d\n",
1872				      fb_helper_conn->connector->base.id, fb_helper_conn->connector->tile_group ? fb_helper_conn->connector->tile_group->id : 0);
1873			modes[i] = drm_has_preferred_mode(fb_helper_conn, width, height);
1874		}
1875		/* No preferred modes, pick one off the list */
1876		if (!modes[i] && !list_empty(&fb_helper_conn->connector->modes)) {
1877			list_for_each_entry(modes[i], &fb_helper_conn->connector->modes, head)
1878				break;
1879		}
1880		DRM_DEBUG_KMS("found mode %s\n", modes[i] ? modes[i]->name :
1881			  "none");
1882		conn_configured |= (1 << i);
1883	}
1884
1885	if ((conn_configured & mask) != mask) {
1886		tile_pass++;
1887		goto retry;
1888	}
1889	return true;
1890}
1891
1892static int drm_pick_crtcs(struct drm_fb_helper *fb_helper,
1893			  struct drm_fb_helper_crtc **best_crtcs,
1894			  struct drm_display_mode **modes,
1895			  int n, int width, int height)
1896{
1897	int c, o;
1898	struct drm_device *dev = fb_helper->dev;
1899	struct drm_connector *connector;
1900	const struct drm_connector_helper_funcs *connector_funcs;
1901	struct drm_encoder *encoder;
1902	int my_score, best_score, score;
1903	struct drm_fb_helper_crtc **crtcs, *crtc;
1904	struct drm_fb_helper_connector *fb_helper_conn;
1905
1906	if (n == fb_helper->connector_count)
1907		return 0;
 
 
1908
1909	fb_helper_conn = fb_helper->connector_info[n];
1910	connector = fb_helper_conn->connector;
 
 
 
 
 
 
 
 
 
1911
1912	best_crtcs[n] = NULL;
1913	best_score = drm_pick_crtcs(fb_helper, best_crtcs, modes, n+1, width, height);
1914	if (modes[n] == NULL)
1915		return best_score;
1916
1917	crtcs = kzalloc(dev->mode_config.num_connector *
1918			sizeof(struct drm_fb_helper_crtc *), GFP_KERNEL);
1919	if (!crtcs)
1920		return best_score;
1921
1922	my_score = 1;
1923	if (connector->status == connector_status_connected)
1924		my_score++;
1925	if (drm_has_cmdline_mode(fb_helper_conn))
1926		my_score++;
1927	if (drm_has_preferred_mode(fb_helper_conn, width, height))
1928		my_score++;
1929
1930	connector_funcs = connector->helper_private;
1931	encoder = connector_funcs->best_encoder(connector);
1932	if (!encoder)
1933		goto out;
1934
1935	/* select a crtc for this connector and then attempt to configure
1936	   remaining connectors */
1937	for (c = 0; c < fb_helper->crtc_count; c++) {
1938		crtc = &fb_helper->crtc_info[c];
1939
1940		if ((encoder->possible_crtcs & (1 << c)) == 0)
1941			continue;
1942
1943		for (o = 0; o < n; o++)
1944			if (best_crtcs[o] == crtc)
1945				break;
1946
1947		if (o < n) {
1948			/* ignore cloning unless only a single crtc */
1949			if (fb_helper->crtc_count > 1)
1950				continue;
 
 
 
 
1951
1952			if (!drm_mode_equal(modes[o], modes[n]))
1953				continue;
1954		}
 
 
 
 
 
1955
1956		crtcs[n] = crtc;
1957		memcpy(crtcs, best_crtcs, n * sizeof(struct drm_fb_helper_crtc *));
1958		score = my_score + drm_pick_crtcs(fb_helper, crtcs, modes, n + 1,
1959						  width, height);
1960		if (score > best_score) {
1961			best_score = score;
1962			memcpy(best_crtcs, crtcs,
1963			       dev->mode_config.num_connector *
1964			       sizeof(struct drm_fb_helper_crtc *));
1965		}
1966	}
1967out:
1968	kfree(crtcs);
1969	return best_score;
1970}
1971
1972static void drm_setup_crtcs(struct drm_fb_helper *fb_helper)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1973{
 
1974	struct drm_device *dev = fb_helper->dev;
1975	struct drm_fb_helper_crtc **crtcs;
1976	struct drm_display_mode **modes;
1977	struct drm_fb_offset *offsets;
1978	struct drm_mode_set *modeset;
1979	bool *enabled;
1980	int width, height;
1981	int i;
1982
1983	DRM_DEBUG_KMS("\n");
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1984
1985	width = dev->mode_config.max_width;
1986	height = dev->mode_config.max_height;
1987
1988	crtcs = kcalloc(fb_helper->connector_count,
1989			sizeof(struct drm_fb_helper_crtc *), GFP_KERNEL);
1990	modes = kcalloc(fb_helper->connector_count,
1991			sizeof(struct drm_display_mode *), GFP_KERNEL);
1992	offsets = kcalloc(fb_helper->connector_count,
1993			  sizeof(struct drm_fb_offset), GFP_KERNEL);
1994	enabled = kcalloc(fb_helper->connector_count,
1995			  sizeof(bool), GFP_KERNEL);
1996	if (!crtcs || !modes || !enabled || !offsets) {
1997		DRM_ERROR("Memory allocation failed\n");
1998		goto out;
 
 
 
 
 
 
 
 
 
 
 
1999	}
2000
 
 
2001
2002	drm_enable_connectors(fb_helper, enabled);
 
 
2003
2004	if (!(fb_helper->funcs->initial_config &&
2005	      fb_helper->funcs->initial_config(fb_helper, crtcs, modes,
2006					       offsets,
2007					       enabled, width, height))) {
2008		memset(modes, 0, fb_helper->connector_count*sizeof(modes[0]));
2009		memset(crtcs, 0, fb_helper->connector_count*sizeof(crtcs[0]));
2010		memset(offsets, 0, fb_helper->connector_count*sizeof(offsets[0]));
2011
2012		if (!drm_target_cloned(fb_helper, modes, offsets,
2013				       enabled, width, height) &&
2014		    !drm_target_preferred(fb_helper, modes, offsets,
2015					  enabled, width, height))
2016			DRM_ERROR("Unable to find initial modes\n");
2017
2018		DRM_DEBUG_KMS("picking CRTCs for %dx%d config\n",
2019			      width, height);
2020
2021		drm_pick_crtcs(fb_helper, crtcs, modes, 0, width, height);
2022	}
2023
2024	/* need to set the modesets up here for use later */
2025	/* fill out the connector<->crtc mappings into the modesets */
2026	for (i = 0; i < fb_helper->crtc_count; i++) {
2027		modeset = &fb_helper->crtc_info[i].mode_set;
2028		modeset->num_connectors = 0;
2029		modeset->fb = NULL;
2030	}
2031
2032	for (i = 0; i < fb_helper->connector_count; i++) {
2033		struct drm_display_mode *mode = modes[i];
2034		struct drm_fb_helper_crtc *fb_crtc = crtcs[i];
2035		struct drm_fb_offset *offset = &offsets[i];
2036		modeset = &fb_crtc->mode_set;
2037
2038		if (mode && fb_crtc) {
2039			DRM_DEBUG_KMS("desired mode %s set on crtc %d (%d,%d)\n",
2040				      mode->name, fb_crtc->mode_set.crtc->base.id, offset->x, offset->y);
2041			fb_crtc->desired_mode = mode;
2042			fb_crtc->x = offset->x;
2043			fb_crtc->y = offset->y;
2044			if (modeset->mode)
2045				drm_mode_destroy(dev, modeset->mode);
2046			modeset->mode = drm_mode_duplicate(dev,
2047							   fb_crtc->desired_mode);
2048			modeset->connectors[modeset->num_connectors++] = fb_helper->connector_info[i]->connector;
2049			modeset->fb = fb_helper->fb;
2050			modeset->x = offset->x;
2051			modeset->y = offset->y;
2052		}
2053	}
2054
2055	/* Clear out any old modes if there are no more connected outputs. */
2056	for (i = 0; i < fb_helper->crtc_count; i++) {
2057		modeset = &fb_helper->crtc_info[i].mode_set;
2058		if (modeset->num_connectors == 0) {
2059			BUG_ON(modeset->fb);
2060			if (modeset->mode)
2061				drm_mode_destroy(dev, modeset->mode);
2062			modeset->mode = NULL;
2063		}
2064	}
2065out:
2066	kfree(crtcs);
2067	kfree(modes);
2068	kfree(offsets);
2069	kfree(enabled);
2070}
2071
2072/**
2073 * drm_fb_helper_initial_config - setup a sane initial connector configuration
2074 * @fb_helper: fb_helper device struct
2075 * @bpp_sel: bpp value to use for the framebuffer configuration
2076 *
2077 * Scans the CRTCs and connectors and tries to put together an initial setup.
2078 * At the moment, this is a cloned configuration across all heads with
2079 * a new framebuffer object as the backing store.
2080 *
2081 * Note that this also registers the fbdev and so allows userspace to call into
2082 * the driver through the fbdev interfaces.
2083 *
2084 * This function will call down into the ->fb_probe callback to let
2085 * the driver allocate and initialize the fbdev info structure and the drm
2086 * framebuffer used to back the fbdev. drm_fb_helper_fill_var() and
2087 * drm_fb_helper_fill_fix() are provided as helpers to setup simple default
2088 * values for the fbdev info structure.
2089 *
2090 * HANG DEBUGGING:
2091 *
2092 * When you have fbcon support built-in or already loaded, this function will do
2093 * a full modeset to setup the fbdev console. Due to locking misdesign in the
2094 * VT/fbdev subsystem that entire modeset sequence has to be done while holding
2095 * console_lock. Until console_unlock is called no dmesg lines will be sent out
2096 * to consoles, not even serial console. This means when your driver crashes,
2097 * you will see absolutely nothing else but a system stuck in this function,
2098 * with no further output. Any kind of printk() you place within your own driver
2099 * or in the drm core modeset code will also never show up.
2100 *
2101 * Standard debug practice is to run the fbcon setup without taking the
2102 * console_lock as a hack, to be able to see backtraces and crashes on the
2103 * serial line. This can be done by setting the fb.lockless_register_fb=1 kernel
2104 * cmdline option.
2105 *
2106 * The other option is to just disable fbdev emulation since very likely the
2107 * first modest from userspace will crash in the same way, and is even easier to
2108 * debug. This can be done by setting the drm_kms_helper.fbdev_emulation=0
2109 * kernel cmdline option.
2110 *
2111 * RETURNS:
2112 * Zero if everything went ok, nonzero otherwise.
2113 */
2114int drm_fb_helper_initial_config(struct drm_fb_helper *fb_helper, int bpp_sel)
2115{
2116	struct drm_device *dev = fb_helper->dev;
2117	int count = 0;
2118
2119	if (!drm_fbdev_emulation)
 
 
 
 
 
 
 
 
 
 
2120		return 0;
2121
2122	mutex_lock(&dev->mode_config.mutex);
2123	count = drm_fb_helper_probe_connector_modes(fb_helper,
2124						    dev->mode_config.max_width,
2125						    dev->mode_config.max_height);
2126	mutex_unlock(&dev->mode_config.mutex);
2127	/*
2128	 * we shouldn't end up with no modes here.
2129	 */
2130	if (count == 0)
2131		dev_info(fb_helper->dev->dev, "No connectors reported connected with modes\n");
 
 
 
2132
2133	drm_setup_crtcs(fb_helper);
 
2134
2135	return drm_fb_helper_single_fb_probe(fb_helper, bpp_sel);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2136}
2137EXPORT_SYMBOL(drm_fb_helper_initial_config);
 
 
 
 
 
 
2138
2139/**
2140 * drm_fb_helper_hotplug_event - respond to a hotplug notification by
2141 *                               probing all the outputs attached to the fb
2142 * @fb_helper: the drm_fb_helper
2143 *
2144 * Scan the connectors attached to the fb_helper and try to put together a
2145 * setup after *notification of a change in output configuration.
2146 *
2147 * Called at runtime, takes the mode config locks to be able to check/change the
2148 * modeset configuration. Must be run from process context (which usually means
2149 * either the output polling work or a work item launched from the driver's
2150 * hotplug interrupt).
2151 *
2152 * Note that drivers may call this even before calling
2153 * drm_fb_helper_initial_config but only aftert drm_fb_helper_init. This allows
2154 * for a race-free fbcon setup and will make sure that the fbdev emulation will
2155 * not miss any hotplug events.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2156 *
2157 * RETURNS:
2158 * 0 on success and a non-zero error code otherwise.
2159 */
2160int drm_fb_helper_hotplug_event(struct drm_fb_helper *fb_helper)
 
2161{
2162	struct drm_device *dev = fb_helper->dev;
2163	u32 max_width, max_height;
 
 
 
2164
2165	if (!drm_fbdev_emulation)
2166		return 0;
2167
2168	mutex_lock(&fb_helper->dev->mode_config.mutex);
2169	if (!fb_helper->fb || !drm_fb_helper_is_bound(fb_helper)) {
2170		fb_helper->delayed_hotplug = true;
2171		mutex_unlock(&fb_helper->dev->mode_config.mutex);
2172		return 0;
2173	}
2174	DRM_DEBUG_KMS("\n");
2175
2176	max_width = fb_helper->fb->width;
2177	max_height = fb_helper->fb->height;
2178
2179	drm_fb_helper_probe_connector_modes(fb_helper, max_width, max_height);
2180	mutex_unlock(&fb_helper->dev->mode_config.mutex);
2181
2182	drm_modeset_lock_all(dev);
2183	drm_setup_crtcs(fb_helper);
2184	drm_modeset_unlock_all(dev);
2185	drm_fb_helper_set_par(fb_helper->fbdev);
 
 
2186
2187	return 0;
2188}
2189EXPORT_SYMBOL(drm_fb_helper_hotplug_event);
 
 
 
 
 
 
 
2190
2191/* The Kconfig DRM_KMS_HELPER selects FRAMEBUFFER_CONSOLE (if !EXPERT)
2192 * but the module doesn't depend on any fb console symbols.  At least
2193 * attempt to load fbcon to avoid leaving the system without a usable console.
2194 */
2195int __init drm_fb_helper_modinit(void)
2196{
2197#if defined(CONFIG_FRAMEBUFFER_CONSOLE_MODULE) && !defined(CONFIG_EXPERT)
2198	const char *name = "fbcon";
2199	struct module *fbcon;
2200
2201	mutex_lock(&module_mutex);
2202	fbcon = find_module(name);
2203	mutex_unlock(&module_mutex);
2204
2205	if (!fbcon)
2206		request_module_nowait(name);
2207#endif
2208	return 0;
2209}
2210EXPORT_SYMBOL(drm_fb_helper_modinit);