drm_crtc.c 132.9 KB
Newer Older
D
Dave Airlie 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
/*
 * Copyright (c) 2006-2008 Intel Corporation
 * Copyright (c) 2007 Dave Airlie <airlied@linux.ie>
 * Copyright (c) 2008 Red Hat Inc.
 *
 * DRM core CRTC related functions
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that copyright
 * notice and this permission notice appear in supporting documentation, and
 * that the name of the copyright holders not be used in advertising or
 * publicity pertaining to distribution of the software without specific,
 * written prior permission.  The copyright holders make no representations
 * about the suitability of this software for any purpose.  It is provided "as
 * is" without express or implied warranty.
 *
 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
 * OF THIS SOFTWARE.
 *
 * Authors:
 *      Keith Packard
 *	Eric Anholt <eric@anholt.net>
 *      Dave Airlie <airlied@linux.ie>
 *      Jesse Barnes <jesse.barnes@intel.com>
 */
32
#include <linux/ctype.h>
D
Dave Airlie 已提交
33
#include <linux/list.h>
34
#include <linux/slab.h>
35
#include <linux/export.h>
36 37 38 39
#include <drm/drmP.h>
#include <drm/drm_crtc.h>
#include <drm/drm_edid.h>
#include <drm/drm_fourcc.h>
40
#include <drm/drm_modeset_lock.h>
D
Dave Airlie 已提交
41

42 43
#include "drm_crtc_internal.h"

44 45 46 47
static struct drm_framebuffer *add_framebuffer_internal(struct drm_device *dev,
							struct drm_mode_fb_cmd2 *r,
							struct drm_file *file_priv);

48 49 50 51 52
/**
 * drm_modeset_lock_all - take all modeset locks
 * @dev: drm device
 *
 * This function takes all modeset locks, suitable where a more fine-grained
53 54
 * scheme isn't (yet) implemented. Locks must be dropped with
 * drm_modeset_unlock_all.
55 56 57
 */
void drm_modeset_lock_all(struct drm_device *dev)
{
58 59 60
	struct drm_mode_config *config = &dev->mode_config;
	struct drm_modeset_acquire_ctx *ctx;
	int ret;
D
Daniel Vetter 已提交
61

62 63 64
	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
	if (WARN_ON(!ctx))
		return;
D
Daniel Vetter 已提交
65

66
	mutex_lock(&config->mutex);
67

68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93
	drm_modeset_acquire_init(ctx, 0);

retry:
	ret = drm_modeset_lock(&config->connection_mutex, ctx);
	if (ret)
		goto fail;
	ret = drm_modeset_lock_all_crtcs(dev, ctx);
	if (ret)
		goto fail;

	WARN_ON(config->acquire_ctx);

	/* now we hold the locks, so now that it is safe, stash the
	 * ctx for drm_modeset_unlock_all():
	 */
	config->acquire_ctx = ctx;

	drm_warn_on_modeset_not_all_locked(dev);

	return;

fail:
	if (ret == -EDEADLK) {
		drm_modeset_backoff(ctx);
		goto retry;
	}
94 95 96 97 98 99
}
EXPORT_SYMBOL(drm_modeset_lock_all);

/**
 * drm_modeset_unlock_all - drop all modeset locks
 * @dev: device
100 101
 *
 * This function drop all modeset locks taken by drm_modeset_lock_all.
102 103 104
 */
void drm_modeset_unlock_all(struct drm_device *dev)
{
105 106
	struct drm_mode_config *config = &dev->mode_config;
	struct drm_modeset_acquire_ctx *ctx = config->acquire_ctx;
D
Daniel Vetter 已提交
107

108 109 110 111 112 113
	if (WARN_ON(!ctx))
		return;

	config->acquire_ctx = NULL;
	drm_modeset_drop_locks(ctx);
	drm_modeset_acquire_fini(ctx);
D
Daniel Vetter 已提交
114

115
	kfree(ctx);
116

117 118 119 120
	mutex_unlock(&dev->mode_config.mutex);
}
EXPORT_SYMBOL(drm_modeset_unlock_all);

121 122 123
/**
 * drm_warn_on_modeset_not_all_locked - check that all modeset locks are locked
 * @dev: device
124 125
 *
 * Useful as a debug assert.
126 127 128 129 130
 */
void drm_warn_on_modeset_not_all_locked(struct drm_device *dev)
{
	struct drm_crtc *crtc;

131 132 133 134
	/* Locking is currently fubar in the panic handler. */
	if (oops_in_progress)
		return;

135
	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head)
136
		WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
137

138
	WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
139 140 141 142
	WARN_ON(!mutex_is_locked(&dev->mode_config.mutex));
}
EXPORT_SYMBOL(drm_warn_on_modeset_not_all_locked);

D
Dave Airlie 已提交
143 144
/* Avoid boilerplate.  I'm tired of typing. */
#define DRM_ENUM_NAME_FN(fnname, list)				\
145
	const char *fnname(int val)				\
D
Dave Airlie 已提交
146 147 148 149 150 151 152 153 154 155 156 157
	{							\
		int i;						\
		for (i = 0; i < ARRAY_SIZE(list); i++) {	\
			if (list[i].type == val)		\
				return list[i].name;		\
		}						\
		return "(unknown)";				\
	}

/*
 * Global properties
 */
158
static const struct drm_prop_enum_list drm_dpms_enum_list[] =
D
Dave Airlie 已提交
159 160 161 162 163 164 165 166
{	{ DRM_MODE_DPMS_ON, "On" },
	{ DRM_MODE_DPMS_STANDBY, "Standby" },
	{ DRM_MODE_DPMS_SUSPEND, "Suspend" },
	{ DRM_MODE_DPMS_OFF, "Off" }
};

DRM_ENUM_NAME_FN(drm_get_dpms_name, drm_dpms_enum_list)

R
Rob Clark 已提交
167 168 169 170 171 172 173
static const struct drm_prop_enum_list drm_plane_type_enum_list[] =
{
	{ DRM_PLANE_TYPE_OVERLAY, "Overlay" },
	{ DRM_PLANE_TYPE_PRIMARY, "Primary" },
	{ DRM_PLANE_TYPE_CURSOR, "Cursor" },
};

D
Dave Airlie 已提交
174 175 176
/*
 * Optional properties
 */
177
static const struct drm_prop_enum_list drm_scaling_mode_enum_list[] =
D
Dave Airlie 已提交
178
{
179 180 181 182
	{ DRM_MODE_SCALE_NONE, "None" },
	{ DRM_MODE_SCALE_FULLSCREEN, "Full" },
	{ DRM_MODE_SCALE_CENTER, "Center" },
	{ DRM_MODE_SCALE_ASPECT, "Full aspect" },
D
Dave Airlie 已提交
183 184 185 186 187
};

/*
 * Non-global properties, but "required" for certain connectors.
 */
188
static const struct drm_prop_enum_list drm_dvi_i_select_enum_list[] =
D
Dave Airlie 已提交
189 190 191 192 193 194 195 196
{
	{ DRM_MODE_SUBCONNECTOR_Automatic, "Automatic" }, /* DVI-I and TV-out */
	{ DRM_MODE_SUBCONNECTOR_DVID,      "DVI-D"     }, /* DVI-I  */
	{ DRM_MODE_SUBCONNECTOR_DVIA,      "DVI-A"     }, /* DVI-I  */
};

DRM_ENUM_NAME_FN(drm_get_dvi_i_select_name, drm_dvi_i_select_enum_list)

197
static const struct drm_prop_enum_list drm_dvi_i_subconnector_enum_list[] =
D
Dave Airlie 已提交
198 199 200 201 202 203 204 205 206
{
	{ DRM_MODE_SUBCONNECTOR_Unknown,   "Unknown"   }, /* DVI-I and TV-out */
	{ DRM_MODE_SUBCONNECTOR_DVID,      "DVI-D"     }, /* DVI-I  */
	{ DRM_MODE_SUBCONNECTOR_DVIA,      "DVI-A"     }, /* DVI-I  */
};

DRM_ENUM_NAME_FN(drm_get_dvi_i_subconnector_name,
		 drm_dvi_i_subconnector_enum_list)

207
static const struct drm_prop_enum_list drm_tv_select_enum_list[] =
D
Dave Airlie 已提交
208 209 210 211 212
{
	{ DRM_MODE_SUBCONNECTOR_Automatic, "Automatic" }, /* DVI-I and TV-out */
	{ DRM_MODE_SUBCONNECTOR_Composite, "Composite" }, /* TV-out */
	{ DRM_MODE_SUBCONNECTOR_SVIDEO,    "SVIDEO"    }, /* TV-out */
	{ DRM_MODE_SUBCONNECTOR_Component, "Component" }, /* TV-out */
213
	{ DRM_MODE_SUBCONNECTOR_SCART,     "SCART"     }, /* TV-out */
D
Dave Airlie 已提交
214 215 216 217
};

DRM_ENUM_NAME_FN(drm_get_tv_select_name, drm_tv_select_enum_list)

218
static const struct drm_prop_enum_list drm_tv_subconnector_enum_list[] =
D
Dave Airlie 已提交
219 220 221 222 223
{
	{ DRM_MODE_SUBCONNECTOR_Unknown,   "Unknown"   }, /* DVI-I and TV-out */
	{ DRM_MODE_SUBCONNECTOR_Composite, "Composite" }, /* TV-out */
	{ DRM_MODE_SUBCONNECTOR_SVIDEO,    "SVIDEO"    }, /* TV-out */
	{ DRM_MODE_SUBCONNECTOR_Component, "Component" }, /* TV-out */
224
	{ DRM_MODE_SUBCONNECTOR_SCART,     "SCART"     }, /* TV-out */
D
Dave Airlie 已提交
225 226 227 228 229
};

DRM_ENUM_NAME_FN(drm_get_tv_subconnector_name,
		 drm_tv_subconnector_enum_list)

230
static const struct drm_prop_enum_list drm_dirty_info_enum_list[] = {
231 232 233 234 235
	{ DRM_MODE_DIRTY_OFF,      "Off"      },
	{ DRM_MODE_DIRTY_ON,       "On"       },
	{ DRM_MODE_DIRTY_ANNOTATE, "Annotate" },
};

D
Dave Airlie 已提交
236 237
struct drm_conn_prop_enum_list {
	int type;
238
	const char *name;
239
	struct ida ida;
D
Dave Airlie 已提交
240 241 242 243 244 245
};

/*
 * Connector and encoder types.
 */
static struct drm_conn_prop_enum_list drm_connector_enum_list[] =
246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261
{	{ DRM_MODE_CONNECTOR_Unknown, "Unknown" },
	{ DRM_MODE_CONNECTOR_VGA, "VGA" },
	{ DRM_MODE_CONNECTOR_DVII, "DVI-I" },
	{ DRM_MODE_CONNECTOR_DVID, "DVI-D" },
	{ DRM_MODE_CONNECTOR_DVIA, "DVI-A" },
	{ DRM_MODE_CONNECTOR_Composite, "Composite" },
	{ DRM_MODE_CONNECTOR_SVIDEO, "SVIDEO" },
	{ DRM_MODE_CONNECTOR_LVDS, "LVDS" },
	{ DRM_MODE_CONNECTOR_Component, "Component" },
	{ DRM_MODE_CONNECTOR_9PinDIN, "DIN" },
	{ DRM_MODE_CONNECTOR_DisplayPort, "DP" },
	{ DRM_MODE_CONNECTOR_HDMIA, "HDMI-A" },
	{ DRM_MODE_CONNECTOR_HDMIB, "HDMI-B" },
	{ DRM_MODE_CONNECTOR_TV, "TV" },
	{ DRM_MODE_CONNECTOR_eDP, "eDP" },
	{ DRM_MODE_CONNECTOR_VIRTUAL, "Virtual" },
262
	{ DRM_MODE_CONNECTOR_DSI, "DSI" },
D
Dave Airlie 已提交
263 264
};

265
static const struct drm_prop_enum_list drm_encoder_enum_list[] =
D
Dave Airlie 已提交
266 267 268 269 270
{	{ DRM_MODE_ENCODER_NONE, "None" },
	{ DRM_MODE_ENCODER_DAC, "DAC" },
	{ DRM_MODE_ENCODER_TMDS, "TMDS" },
	{ DRM_MODE_ENCODER_LVDS, "LVDS" },
	{ DRM_MODE_ENCODER_TVDAC, "TV" },
271
	{ DRM_MODE_ENCODER_VIRTUAL, "Virtual" },
272
	{ DRM_MODE_ENCODER_DSI, "DSI" },
D
Dave Airlie 已提交
273
	{ DRM_MODE_ENCODER_DPMST, "DP MST" },
D
Dave Airlie 已提交
274 275
};

276 277 278 279 280 281 282 283 284 285
static const struct drm_prop_enum_list drm_subpixel_enum_list[] =
{
	{ SubPixelUnknown, "Unknown" },
	{ SubPixelHorizontalRGB, "Horizontal RGB" },
	{ SubPixelHorizontalBGR, "Horizontal BGR" },
	{ SubPixelVerticalRGB, "Vertical RGB" },
	{ SubPixelVerticalBGR, "Vertical BGR" },
	{ SubPixelNone, "None" },
};

286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301
void drm_connector_ida_init(void)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(drm_connector_enum_list); i++)
		ida_init(&drm_connector_enum_list[i].ida);
}

void drm_connector_ida_destroy(void)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(drm_connector_enum_list); i++)
		ida_destroy(&drm_connector_enum_list[i].ida);
}

302 303 304 305 306 307 308
/**
 * drm_get_connector_status_name - return a string for connector status
 * @status: connector status to compute name of
 *
 * In contrast to the other drm_get_*_name functions this one here returns a
 * const pointer and hence is threadsafe.
 */
309
const char *drm_get_connector_status_name(enum drm_connector_status status)
D
Dave Airlie 已提交
310 311 312 313 314 315 316 317
{
	if (status == connector_status_connected)
		return "connected";
	else if (status == connector_status_disconnected)
		return "disconnected";
	else
		return "unknown";
}
318
EXPORT_SYMBOL(drm_get_connector_status_name);
D
Dave Airlie 已提交
319

320 321 322 323 324 325 326 327 328 329 330 331 332
/**
 * drm_get_subpixel_order_name - return a string for a given subpixel enum
 * @order: enum of subpixel_order
 *
 * Note you could abuse this and return something out of bounds, but that
 * would be a caller error.  No unscrubbed user data should make it here.
 */
const char *drm_get_subpixel_order_name(enum subpixel_order order)
{
	return drm_subpixel_enum_list[order].name;
}
EXPORT_SYMBOL(drm_get_subpixel_order_name);

333 334 335 336 337
static char printable_char(int c)
{
	return isascii(c) && isprint(c) ? c : '?';
}

338 339 340 341 342 343 344 345 346
/**
 * drm_get_format_name - return a string for drm fourcc format
 * @format: format to compute name of
 *
 * Note that the buffer used by this function is globally shared and owned by
 * the function itself.
 *
 * FIXME: This isn't really multithreading safe.
 */
347
const char *drm_get_format_name(uint32_t format)
348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363
{
	static char buf[32];

	snprintf(buf, sizeof(buf),
		 "%c%c%c%c %s-endian (0x%08x)",
		 printable_char(format & 0xff),
		 printable_char((format >> 8) & 0xff),
		 printable_char((format >> 16) & 0xff),
		 printable_char((format >> 24) & 0x7f),
		 format & DRM_FORMAT_BIG_ENDIAN ? "big" : "little",
		 format);

	return buf;
}
EXPORT_SYMBOL(drm_get_format_name);

364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389
/*
 * Internal function to assign a slot in the object idr and optionally
 * register the object into the idr.
 */
static int drm_mode_object_get_reg(struct drm_device *dev,
				   struct drm_mode_object *obj,
				   uint32_t obj_type,
				   bool register_obj)
{
	int ret;

	mutex_lock(&dev->mode_config.idr_mutex);
	ret = idr_alloc(&dev->mode_config.crtc_idr, register_obj ? obj : NULL, 1, 0, GFP_KERNEL);
	if (ret >= 0) {
		/*
		 * Set up the object linking under the protection of the idr
		 * lock so that other users can't see inconsistent state.
		 */
		obj->id = ret;
		obj->type = obj_type;
	}
	mutex_unlock(&dev->mode_config.idr_mutex);

	return ret < 0 ? ret : 0;
}

D
Dave Airlie 已提交
390
/**
391
 * drm_mode_object_get - allocate a new modeset identifier
D
Dave Airlie 已提交
392
 * @dev: DRM device
393 394
 * @obj: object pointer, used to generate unique ID
 * @obj_type: object type
D
Dave Airlie 已提交
395 396
 *
 * Create a unique identifier based on @ptr in @dev's identifier space.  Used
397 398 399
 * for tracking modes, CRTCs and connectors. Note that despite the _get postfix
 * modeset identifiers are _not_ reference counted. Hence don't use this for
 * reference counted modeset objects like framebuffers.
D
Dave Airlie 已提交
400
 *
401
 * Returns:
D
Dave Airlie 已提交
402 403 404
 * New unique (relative to other objects in @dev) integer identifier for the
 * object.
 */
405 406
int drm_mode_object_get(struct drm_device *dev,
			struct drm_mode_object *obj, uint32_t obj_type)
D
Dave Airlie 已提交
407
{
408 409
	return drm_mode_object_get_reg(dev, obj, obj_type, true);
}
D
Dave Airlie 已提交
410

411 412 413
static void drm_mode_object_register(struct drm_device *dev,
				     struct drm_mode_object *obj)
{
J
Jesse Barnes 已提交
414
	mutex_lock(&dev->mode_config.idr_mutex);
415
	idr_replace(&dev->mode_config.crtc_idr, obj, obj->id);
J
Jesse Barnes 已提交
416
	mutex_unlock(&dev->mode_config.idr_mutex);
D
Dave Airlie 已提交
417 418 419
}

/**
420
 * drm_mode_object_put - free a modeset identifer
D
Dave Airlie 已提交
421
 * @dev: DRM device
422
 * @object: object to free
D
Dave Airlie 已提交
423
 *
424 425 426
 * Free @id from @dev's unique identifier pool. Note that despite the _get
 * postfix modeset identifiers are _not_ reference counted. Hence don't use this
 * for reference counted modeset objects like framebuffers.
D
Dave Airlie 已提交
427
 */
428 429
void drm_mode_object_put(struct drm_device *dev,
			 struct drm_mode_object *object)
D
Dave Airlie 已提交
430
{
J
Jesse Barnes 已提交
431
	mutex_lock(&dev->mode_config.idr_mutex);
D
Dave Airlie 已提交
432
	idr_remove(&dev->mode_config.crtc_idr, object->id);
J
Jesse Barnes 已提交
433
	mutex_unlock(&dev->mode_config.idr_mutex);
D
Dave Airlie 已提交
434 435
}

R
Rob Clark 已提交
436 437 438 439 440 441 442 443 444 445 446 447 448 449 450
static struct drm_mode_object *_object_find(struct drm_device *dev,
		uint32_t id, uint32_t type)
{
	struct drm_mode_object *obj = NULL;

	mutex_lock(&dev->mode_config.idr_mutex);
	obj = idr_find(&dev->mode_config.crtc_idr, id);
	if (!obj || (type != DRM_MODE_OBJECT_ANY && obj->type != type) ||
	    (obj->id != id))
		obj = NULL;
	mutex_unlock(&dev->mode_config.idr_mutex);

	return obj;
}

451 452 453 454 455 456 457
/**
 * drm_mode_object_find - look up a drm object with static lifetime
 * @dev: drm device
 * @id: id of the mode object
 * @type: type of the mode object
 *
 * Note that framebuffers cannot be looked up with this functions - since those
R
Rob Clark 已提交
458 459 460
 * are reference counted, they need special treatment.  Even with
 * DRM_MODE_OBJECT_ANY (although that will simply return NULL
 * rather than WARN_ON()).
461
 */
462 463
struct drm_mode_object *drm_mode_object_find(struct drm_device *dev,
		uint32_t id, uint32_t type)
D
Dave Airlie 已提交
464
{
J
Jesse Barnes 已提交
465
	struct drm_mode_object *obj = NULL;
D
Dave Airlie 已提交
466

467 468 469
	/* Framebuffers are reference counted and need their own lookup
	 * function.*/
	WARN_ON(type == DRM_MODE_OBJECT_FB);
R
Rob Clark 已提交
470 471 472
	obj = _object_find(dev, id, type);
	/* don't leak out unref'd fb's */
	if (obj && (obj->type == DRM_MODE_OBJECT_FB))
J
Jesse Barnes 已提交
473
		obj = NULL;
D
Dave Airlie 已提交
474 475 476 477 478 479 480
	return obj;
}
EXPORT_SYMBOL(drm_mode_object_find);

/**
 * drm_framebuffer_init - initialize a framebuffer
 * @dev: DRM device
481 482
 * @fb: framebuffer to be initialized
 * @funcs: ... with these functions
D
Dave Airlie 已提交
483 484 485 486
 *
 * Allocates an ID for the framebuffer's parent mode object, sets its mode
 * functions & device file and adds it to the master fd list.
 *
487 488 489 490 491 492
 * IMPORTANT:
 * This functions publishes the fb and makes it available for concurrent access
 * by other users. Which means by this point the fb _must_ be fully set up -
 * since all the fb attributes are invariant over its lifetime, no further
 * locking but only correct reference counting is required.
 *
493
 * Returns:
494
 * Zero on success, error code on failure.
D
Dave Airlie 已提交
495 496 497 498 499 500
 */
int drm_framebuffer_init(struct drm_device *dev, struct drm_framebuffer *fb,
			 const struct drm_framebuffer_funcs *funcs)
{
	int ret;

501
	mutex_lock(&dev->mode_config.fb_lock);
R
Rob Clark 已提交
502
	kref_init(&fb->refcount);
503 504 505
	INIT_LIST_HEAD(&fb->filp_head);
	fb->dev = dev;
	fb->funcs = funcs;
R
Rob Clark 已提交
506

D
Dave Airlie 已提交
507
	ret = drm_mode_object_get(dev, &fb->base, DRM_MODE_OBJECT_FB);
508
	if (ret)
509
		goto out;
D
Dave Airlie 已提交
510

511 512 513
	/* Grab the idr reference. */
	drm_framebuffer_reference(fb);

D
Dave Airlie 已提交
514 515
	dev->mode_config.num_fb++;
	list_add(&fb->head, &dev->mode_config.fb_list);
516 517
out:
	mutex_unlock(&dev->mode_config.fb_lock);
D
Dave Airlie 已提交
518 519 520 521 522

	return 0;
}
EXPORT_SYMBOL(drm_framebuffer_init);

R
Rob Clark 已提交
523 524 525 526 527 528 529
static void drm_framebuffer_free(struct kref *kref)
{
	struct drm_framebuffer *fb =
			container_of(kref, struct drm_framebuffer, refcount);
	fb->funcs->destroy(fb);
}

530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546
static struct drm_framebuffer *__drm_framebuffer_lookup(struct drm_device *dev,
							uint32_t id)
{
	struct drm_mode_object *obj = NULL;
	struct drm_framebuffer *fb;

	mutex_lock(&dev->mode_config.idr_mutex);
	obj = idr_find(&dev->mode_config.crtc_idr, id);
	if (!obj || (obj->type != DRM_MODE_OBJECT_FB) || (obj->id != id))
		fb = NULL;
	else
		fb = obj_to_fb(obj);
	mutex_unlock(&dev->mode_config.idr_mutex);

	return fb;
}

547 548 549 550 551 552 553
/**
 * drm_framebuffer_lookup - look up a drm framebuffer and grab a reference
 * @dev: drm device
 * @id: id of the fb object
 *
 * If successful, this grabs an additional reference to the framebuffer -
 * callers need to make sure to eventually unreference the returned framebuffer
554
 * again, using @drm_framebuffer_unreference.
555 556 557 558 559 560 561
 */
struct drm_framebuffer *drm_framebuffer_lookup(struct drm_device *dev,
					       uint32_t id)
{
	struct drm_framebuffer *fb;

	mutex_lock(&dev->mode_config.fb_lock);
562
	fb = __drm_framebuffer_lookup(dev, id);
563
	if (fb)
564
		drm_framebuffer_reference(fb);
565 566 567 568 569 570
	mutex_unlock(&dev->mode_config.fb_lock);

	return fb;
}
EXPORT_SYMBOL(drm_framebuffer_lookup);

R
Rob Clark 已提交
571 572
/**
 * drm_framebuffer_unreference - unref a framebuffer
573 574 575
 * @fb: framebuffer to unref
 *
 * This functions decrements the fb's refcount and frees it if it drops to zero.
R
Rob Clark 已提交
576 577 578
 */
void drm_framebuffer_unreference(struct drm_framebuffer *fb)
{
R
Rob Clark 已提交
579
	DRM_DEBUG("%p: FB ID: %d (%d)\n", fb, fb->base.id, atomic_read(&fb->refcount.refcount));
R
Rob Clark 已提交
580 581 582 583 584 585
	kref_put(&fb->refcount, drm_framebuffer_free);
}
EXPORT_SYMBOL(drm_framebuffer_unreference);

/**
 * drm_framebuffer_reference - incr the fb refcnt
586
 * @fb: framebuffer
587 588
 *
 * This functions increments the fb's refcount.
R
Rob Clark 已提交
589 590 591
 */
void drm_framebuffer_reference(struct drm_framebuffer *fb)
{
R
Rob Clark 已提交
592
	DRM_DEBUG("%p: FB ID: %d (%d)\n", fb, fb->base.id, atomic_read(&fb->refcount.refcount));
R
Rob Clark 已提交
593 594 595 596
	kref_get(&fb->refcount);
}
EXPORT_SYMBOL(drm_framebuffer_reference);

597 598 599 600 601
static void drm_framebuffer_free_bug(struct kref *kref)
{
	BUG();
}

602 603
static void __drm_framebuffer_unreference(struct drm_framebuffer *fb)
{
R
Rob Clark 已提交
604
	DRM_DEBUG("%p: FB ID: %d (%d)\n", fb, fb->base.id, atomic_read(&fb->refcount.refcount));
605 606 607
	kref_put(&fb->refcount, drm_framebuffer_free_bug);
}

608 609 610 611 612 613 614 615 616 617
/* dev->mode_config.fb_lock must be held! */
static void __drm_framebuffer_unregister(struct drm_device *dev,
					 struct drm_framebuffer *fb)
{
	mutex_lock(&dev->mode_config.idr_mutex);
	idr_remove(&dev->mode_config.crtc_idr, fb->base.id);
	mutex_unlock(&dev->mode_config.idr_mutex);

	fb->base.id = 0;

618
	__drm_framebuffer_unreference(fb);
619 620
}

621 622 623 624 625 626 627 628 629 630 631
/**
 * drm_framebuffer_unregister_private - unregister a private fb from the lookup idr
 * @fb: fb to unregister
 *
 * Drivers need to call this when cleaning up driver-private framebuffers, e.g.
 * those used for fbdev. Note that the caller must hold a reference of it's own,
 * i.e. the object may not be destroyed through this call (since it'll lead to a
 * locking inversion).
 */
void drm_framebuffer_unregister_private(struct drm_framebuffer *fb)
{
632 633 634 635 636 637
	struct drm_device *dev = fb->dev;

	mutex_lock(&dev->mode_config.fb_lock);
	/* Mark fb as reaped and drop idr ref. */
	__drm_framebuffer_unregister(dev, fb);
	mutex_unlock(&dev->mode_config.fb_lock);
638 639 640
}
EXPORT_SYMBOL(drm_framebuffer_unregister_private);

D
Dave Airlie 已提交
641 642 643 644
/**
 * drm_framebuffer_cleanup - remove a framebuffer object
 * @fb: framebuffer to remove
 *
645 646 647
 * Cleanup framebuffer. This function is intended to be used from the drivers
 * ->destroy callback. It can also be used to clean up driver private
 *  framebuffers embedded into a larger structure.
648 649 650 651 652 653 654 655 656
 *
 * Note that this function does not remove the fb from active usuage - if it is
 * still used anywhere, hilarity can ensue since userspace could call getfb on
 * the id and get back -EINVAL. Obviously no concern at driver unload time.
 *
 * Also, the framebuffer will not be removed from the lookup idr - for
 * user-created framebuffers this will happen in in the rmfb ioctl. For
 * driver-private objects (e.g. for fbdev) drivers need to explicitly call
 * drm_framebuffer_unregister_private.
D
Dave Airlie 已提交
657 658
 */
void drm_framebuffer_cleanup(struct drm_framebuffer *fb)
R
Rob Clark 已提交
659 660
{
	struct drm_device *dev = fb->dev;
661

662
	mutex_lock(&dev->mode_config.fb_lock);
R
Rob Clark 已提交
663 664
	list_del(&fb->head);
	dev->mode_config.num_fb--;
665
	mutex_unlock(&dev->mode_config.fb_lock);
R
Rob Clark 已提交
666 667 668 669 670 671 672 673
}
EXPORT_SYMBOL(drm_framebuffer_cleanup);

/**
 * drm_framebuffer_remove - remove and unreference a framebuffer object
 * @fb: framebuffer to remove
 *
 * Scans all the CRTCs and planes in @dev's mode_config.  If they're
674
 * using @fb, removes it, setting it to NULL. Then drops the reference to the
675 676 677 678 679
 * passed-in framebuffer. Might take the modeset locks.
 *
 * Note that this function optimizes the cleanup away if the caller holds the
 * last reference to the framebuffer. It is also guaranteed to not take the
 * modeset locks in this case.
R
Rob Clark 已提交
680 681
 */
void drm_framebuffer_remove(struct drm_framebuffer *fb)
D
Dave Airlie 已提交
682 683 684
{
	struct drm_device *dev = fb->dev;
	struct drm_crtc *crtc;
J
Jesse Barnes 已提交
685
	struct drm_plane *plane;
686 687
	struct drm_mode_set set;
	int ret;
D
Dave Airlie 已提交
688

689
	WARN_ON(!list_empty(&fb->filp_head));
690

691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709
	/*
	 * drm ABI mandates that we remove any deleted framebuffers from active
	 * useage. But since most sane clients only remove framebuffers they no
	 * longer need, try to optimize this away.
	 *
	 * Since we're holding a reference ourselves, observing a refcount of 1
	 * means that we're the last holder and can skip it. Also, the refcount
	 * can never increase from 1 again, so we don't need any barriers or
	 * locks.
	 *
	 * Note that userspace could try to race with use and instate a new
	 * usage _after_ we've cleared all current ones. End result will be an
	 * in-use fb with fb-id == 0. Userspace is allowed to shoot its own foot
	 * in this manner.
	 */
	if (atomic_read(&fb->refcount.refcount) > 1) {
		drm_modeset_lock_all(dev);
		/* remove from any CRTC */
		list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
710
			if (crtc->primary->fb == fb) {
711 712 713 714 715 716 717 718
				/* should turn off the crtc */
				memset(&set, 0, sizeof(struct drm_mode_set));
				set.crtc = crtc;
				set.fb = NULL;
				ret = drm_mode_set_config_internal(&set);
				if (ret)
					DRM_ERROR("failed to reset crtc %p when fb was deleted\n", crtc);
			}
719
		}
D
Dave Airlie 已提交
720

721
		list_for_each_entry(plane, &dev->mode_config.plane_list, head) {
722 723
			if (plane->fb == fb)
				drm_plane_force_disable(plane);
J
Jesse Barnes 已提交
724
		}
725
		drm_modeset_unlock_all(dev);
J
Jesse Barnes 已提交
726 727
	}

R
Rob Clark 已提交
728
	drm_framebuffer_unreference(fb);
D
Dave Airlie 已提交
729
}
R
Rob Clark 已提交
730
EXPORT_SYMBOL(drm_framebuffer_remove);
D
Dave Airlie 已提交
731

732 733
DEFINE_WW_CLASS(crtc_ww_class);

D
Dave Airlie 已提交
734
/**
735 736
 * drm_crtc_init_with_planes - Initialise a new CRTC object with
 *    specified primary and cursor planes.
D
Dave Airlie 已提交
737 738
 * @dev: DRM device
 * @crtc: CRTC object to init
739 740
 * @primary: Primary plane for CRTC
 * @cursor: Cursor plane for CRTC
D
Dave Airlie 已提交
741 742
 * @funcs: callbacks for the new CRTC
 *
743
 * Inits a new object created as base part of a driver crtc object.
744
 *
745
 * Returns:
746
 * Zero on success, error code on failure.
D
Dave Airlie 已提交
747
 */
748 749
int drm_crtc_init_with_planes(struct drm_device *dev, struct drm_crtc *crtc,
			      struct drm_plane *primary,
750
			      struct drm_plane *cursor,
751
			      const struct drm_crtc_funcs *funcs)
D
Dave Airlie 已提交
752
{
753
	struct drm_mode_config *config = &dev->mode_config;
754 755
	int ret;

D
Dave Airlie 已提交
756 757
	crtc->dev = dev;
	crtc->funcs = funcs;
R
Rob Clark 已提交
758
	crtc->invert_dimensions = false;
D
Dave Airlie 已提交
759

760
	drm_modeset_lock_all(dev);
761 762 763
	drm_modeset_lock_init(&crtc->mutex);
	/* dropped by _unlock_all(): */
	drm_modeset_lock(&crtc->mutex, config->acquire_ctx);
764 765 766 767

	ret = drm_mode_object_get(dev, &crtc->base, DRM_MODE_OBJECT_CRTC);
	if (ret)
		goto out;
D
Dave Airlie 已提交
768

P
Paulo Zanoni 已提交
769 770
	crtc->base.properties = &crtc->properties;

771 772
	list_add_tail(&crtc->head, &config->crtc_list);
	config->num_crtc++;
773

774
	crtc->primary = primary;
775
	crtc->cursor = cursor;
776 777
	if (primary)
		primary->possible_crtcs = 1 << drm_crtc_index(crtc);
778 779
	if (cursor)
		cursor->possible_crtcs = 1 << drm_crtc_index(crtc);
780

781
 out:
782
	drm_modeset_unlock_all(dev);
783 784

	return ret;
D
Dave Airlie 已提交
785
}
786
EXPORT_SYMBOL(drm_crtc_init_with_planes);
D
Dave Airlie 已提交
787 788

/**
789
 * drm_crtc_cleanup - Clean up the core crtc usage
D
Dave Airlie 已提交
790 791
 * @crtc: CRTC to cleanup
 *
792 793 794
 * This function cleans up @crtc and removes it from the DRM mode setting
 * core. Note that the function does *not* free the crtc structure itself,
 * this is the responsibility of the caller.
D
Dave Airlie 已提交
795 796 797 798 799
 */
void drm_crtc_cleanup(struct drm_crtc *crtc)
{
	struct drm_device *dev = crtc->dev;

800 801
	kfree(crtc->gamma_store);
	crtc->gamma_store = NULL;
D
Dave Airlie 已提交
802

803 804
	drm_modeset_lock_fini(&crtc->mutex);

D
Dave Airlie 已提交
805 806 807 808 809 810
	drm_mode_object_put(dev, &crtc->base);
	list_del(&crtc->head);
	dev->mode_config.num_crtc--;
}
EXPORT_SYMBOL(drm_crtc_cleanup);

811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833
/**
 * drm_crtc_index - find the index of a registered CRTC
 * @crtc: CRTC to find index for
 *
 * Given a registered CRTC, return the index of that CRTC within a DRM
 * device's list of CRTCs.
 */
unsigned int drm_crtc_index(struct drm_crtc *crtc)
{
	unsigned int index = 0;
	struct drm_crtc *tmp;

	list_for_each_entry(tmp, &crtc->dev->mode_config.crtc_list, head) {
		if (tmp == crtc)
			return index;

		index++;
	}

	BUG();
}
EXPORT_SYMBOL(drm_crtc_index);

834
/*
D
Dave Airlie 已提交
835 836 837 838 839 840
 * drm_mode_remove - remove and free a mode
 * @connector: connector list to modify
 * @mode: mode to remove
 *
 * Remove @mode from @connector's mode list, then free it.
 */
841 842
static void drm_mode_remove(struct drm_connector *connector,
			    struct drm_display_mode *mode)
D
Dave Airlie 已提交
843 844
{
	list_del(&mode->head);
845
	drm_mode_destroy(connector->dev, mode);
D
Dave Airlie 已提交
846 847 848 849 850 851 852
}

/**
 * drm_connector_init - Init a preallocated connector
 * @dev: DRM device
 * @connector: the connector to init
 * @funcs: callbacks for this connector
853
 * @connector_type: user visible type of the connector
D
Dave Airlie 已提交
854 855 856
 *
 * Initialises a preallocated connector. Connectors should be
 * subclassed as part of driver connector objects.
857
 *
858
 * Returns:
859
 * Zero on success, error code on failure.
D
Dave Airlie 已提交
860
 */
861 862 863 864
int drm_connector_init(struct drm_device *dev,
		       struct drm_connector *connector,
		       const struct drm_connector_funcs *funcs,
		       int connector_type)
D
Dave Airlie 已提交
865
{
866
	int ret;
867 868
	struct ida *connector_ida =
		&drm_connector_enum_list[connector_type].ida;
869

870
	drm_modeset_lock_all(dev);
D
Dave Airlie 已提交
871

872
	ret = drm_mode_object_get_reg(dev, &connector->base, DRM_MODE_OBJECT_CONNECTOR, false);
873
	if (ret)
874
		goto out_unlock;
875

876
	connector->base.properties = &connector->properties;
D
Dave Airlie 已提交
877 878 879 880
	connector->dev = dev;
	connector->funcs = funcs;
	connector->connector_type = connector_type;
	connector->connector_type_id =
881 882 883
		ida_simple_get(connector_ida, 1, 0, GFP_KERNEL);
	if (connector->connector_type_id < 0) {
		ret = connector->connector_type_id;
884
		goto out_put;
885
	}
886 887 888 889 890 891 892 893 894
	connector->name =
		kasprintf(GFP_KERNEL, "%s-%d",
			  drm_connector_enum_list[connector_type].name,
			  connector->connector_type_id);
	if (!connector->name) {
		ret = -ENOMEM;
		goto out_put;
	}

D
Dave Airlie 已提交
895 896 897
	INIT_LIST_HEAD(&connector->probed_modes);
	INIT_LIST_HEAD(&connector->modes);
	connector->edid_blob_ptr = NULL;
898
	connector->status = connector_status_unknown;
D
Dave Airlie 已提交
899 900 901 902

	list_add_tail(&connector->head, &dev->mode_config.connector_list);
	dev->mode_config.num_connector++;

903
	if (connector_type != DRM_MODE_CONNECTOR_VIRTUAL)
904
		drm_object_attach_property(&connector->base,
905 906
					      dev->mode_config.edid_property,
					      0);
D
Dave Airlie 已提交
907

908
	drm_object_attach_property(&connector->base,
D
Dave Airlie 已提交
909 910
				      dev->mode_config.dpms_property, 0);

911 912
	connector->debugfs_entry = NULL;

913 914 915 916 917
out_put:
	if (ret)
		drm_mode_object_put(dev, &connector->base);

out_unlock:
918
	drm_modeset_unlock_all(dev);
919 920

	return ret;
D
Dave Airlie 已提交
921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940
}
EXPORT_SYMBOL(drm_connector_init);

/**
 * drm_connector_cleanup - cleans up an initialised connector
 * @connector: connector to cleanup
 *
 * Cleans up the connector but doesn't free the object.
 */
void drm_connector_cleanup(struct drm_connector *connector)
{
	struct drm_device *dev = connector->dev;
	struct drm_display_mode *mode, *t;

	list_for_each_entry_safe(mode, t, &connector->probed_modes, head)
		drm_mode_remove(connector, mode);

	list_for_each_entry_safe(mode, t, &connector->modes, head)
		drm_mode_remove(connector, mode);

941 942 943
	ida_remove(&drm_connector_enum_list[connector->connector_type].ida,
		   connector->connector_type_id);

D
Dave Airlie 已提交
944
	drm_mode_object_put(dev, &connector->base);
945 946
	kfree(connector->name);
	connector->name = NULL;
D
Dave Airlie 已提交
947
	list_del(&connector->head);
948
	dev->mode_config.num_connector--;
D
Dave Airlie 已提交
949 950 951
}
EXPORT_SYMBOL(drm_connector_cleanup);

952 953 954 955 956 957 958 959 960 961 962
/**
 * drm_connector_register - register a connector
 * @connector: the connector to register
 *
 * Register userspace interfaces for a connector
 *
 * Returns:
 * Zero on success, error code on failure.
 */
int drm_connector_register(struct drm_connector *connector)
{
963 964
	int ret;

965 966
	drm_mode_object_register(connector->dev, &connector->base);

967 968 969 970 971 972 973 974 975 976 977
	ret = drm_sysfs_connector_add(connector);
	if (ret)
		return ret;

	ret = drm_debugfs_connector_add(connector);
	if (ret) {
		drm_sysfs_connector_remove(connector);
		return ret;
	}

	return 0;
978 979 980 981 982 983 984 985 986 987 988 989
}
EXPORT_SYMBOL(drm_connector_register);

/**
 * drm_connector_unregister - unregister a connector
 * @connector: the connector to unregister
 *
 * Unregister userspace interfaces for a connector
 */
void drm_connector_unregister(struct drm_connector *connector)
{
	drm_sysfs_connector_remove(connector);
990
	drm_debugfs_connector_remove(connector);
991 992 993 994
}
EXPORT_SYMBOL(drm_connector_unregister);


995 996 997 998 999 1000 1001 1002
/**
 * drm_connector_unplug_all - unregister connector userspace interfaces
 * @dev: drm device
 *
 * This function unregisters all connector userspace interfaces in sysfs. Should
 * be call when the device is disconnected, e.g. from an usb driver's
 * ->disconnect callback.
 */
1003 1004 1005 1006 1007 1008
void drm_connector_unplug_all(struct drm_device *dev)
{
	struct drm_connector *connector;

	/* taking the mode config mutex ends up in a clash with sysfs */
	list_for_each_entry(connector, &dev->mode_config.connector_list, head)
1009
		drm_connector_unregister(connector);
1010 1011 1012 1013

}
EXPORT_SYMBOL(drm_connector_unplug_all);

1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025
/**
 * drm_bridge_init - initialize a drm transcoder/bridge
 * @dev: drm device
 * @bridge: transcoder/bridge to set up
 * @funcs: bridge function table
 *
 * Initialises a preallocated bridge. Bridges should be
 * subclassed as part of driver connector objects.
 *
 * Returns:
 * Zero on success, error code on failure.
 */
S
Sean Paul 已提交
1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048
int drm_bridge_init(struct drm_device *dev, struct drm_bridge *bridge,
		const struct drm_bridge_funcs *funcs)
{
	int ret;

	drm_modeset_lock_all(dev);

	ret = drm_mode_object_get(dev, &bridge->base, DRM_MODE_OBJECT_BRIDGE);
	if (ret)
		goto out;

	bridge->dev = dev;
	bridge->funcs = funcs;

	list_add_tail(&bridge->head, &dev->mode_config.bridge_list);
	dev->mode_config.num_bridge++;

 out:
	drm_modeset_unlock_all(dev);
	return ret;
}
EXPORT_SYMBOL(drm_bridge_init);

1049 1050 1051 1052 1053 1054
/**
 * drm_bridge_cleanup - cleans up an initialised bridge
 * @bridge: bridge to cleanup
 *
 * Cleans up the bridge but doesn't free the object.
 */
S
Sean Paul 已提交
1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066
void drm_bridge_cleanup(struct drm_bridge *bridge)
{
	struct drm_device *dev = bridge->dev;

	drm_modeset_lock_all(dev);
	drm_mode_object_put(dev, &bridge->base);
	list_del(&bridge->head);
	dev->mode_config.num_bridge--;
	drm_modeset_unlock_all(dev);
}
EXPORT_SYMBOL(drm_bridge_cleanup);

1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079
/**
 * drm_encoder_init - Init a preallocated encoder
 * @dev: drm device
 * @encoder: the encoder to init
 * @funcs: callbacks for this encoder
 * @encoder_type: user visible type of the encoder
 *
 * Initialises a preallocated encoder. Encoder should be
 * subclassed as part of driver encoder objects.
 *
 * Returns:
 * Zero on success, error code on failure.
 */
1080
int drm_encoder_init(struct drm_device *dev,
1081 1082 1083
		      struct drm_encoder *encoder,
		      const struct drm_encoder_funcs *funcs,
		      int encoder_type)
D
Dave Airlie 已提交
1084
{
1085 1086
	int ret;

1087
	drm_modeset_lock_all(dev);
D
Dave Airlie 已提交
1088

1089 1090
	ret = drm_mode_object_get(dev, &encoder->base, DRM_MODE_OBJECT_ENCODER);
	if (ret)
1091
		goto out_unlock;
D
Dave Airlie 已提交
1092

1093
	encoder->dev = dev;
D
Dave Airlie 已提交
1094 1095
	encoder->encoder_type = encoder_type;
	encoder->funcs = funcs;
1096 1097 1098 1099 1100 1101 1102
	encoder->name = kasprintf(GFP_KERNEL, "%s-%d",
				  drm_encoder_enum_list[encoder_type].name,
				  encoder->base.id);
	if (!encoder->name) {
		ret = -ENOMEM;
		goto out_put;
	}
D
Dave Airlie 已提交
1103 1104 1105 1106

	list_add_tail(&encoder->head, &dev->mode_config.encoder_list);
	dev->mode_config.num_encoder++;

1107 1108 1109 1110 1111
out_put:
	if (ret)
		drm_mode_object_put(dev, &encoder->base);

out_unlock:
1112
	drm_modeset_unlock_all(dev);
1113 1114

	return ret;
D
Dave Airlie 已提交
1115 1116 1117
}
EXPORT_SYMBOL(drm_encoder_init);

1118 1119 1120 1121 1122 1123
/**
 * drm_encoder_cleanup - cleans up an initialised encoder
 * @encoder: encoder to cleanup
 *
 * Cleans up the encoder but doesn't free the object.
 */
D
Dave Airlie 已提交
1124 1125 1126
void drm_encoder_cleanup(struct drm_encoder *encoder)
{
	struct drm_device *dev = encoder->dev;
1127
	drm_modeset_lock_all(dev);
D
Dave Airlie 已提交
1128
	drm_mode_object_put(dev, &encoder->base);
1129 1130
	kfree(encoder->name);
	encoder->name = NULL;
D
Dave Airlie 已提交
1131
	list_del(&encoder->head);
1132
	dev->mode_config.num_encoder--;
1133
	drm_modeset_unlock_all(dev);
D
Dave Airlie 已提交
1134 1135 1136
}
EXPORT_SYMBOL(drm_encoder_cleanup);

1137
/**
M
Matt Roper 已提交
1138
 * drm_universal_plane_init - Initialize a new universal plane object
1139 1140 1141 1142 1143 1144
 * @dev: DRM device
 * @plane: plane object to init
 * @possible_crtcs: bitmask of possible CRTCs
 * @funcs: callbacks for the new plane
 * @formats: array of supported formats (%DRM_FORMAT_*)
 * @format_count: number of elements in @formats
M
Matt Roper 已提交
1145
 * @type: type of plane (overlay, primary, cursor)
1146
 *
M
Matt Roper 已提交
1147
 * Initializes a plane object of type @type.
1148
 *
1149
 * Returns:
1150 1151
 * Zero on success, error code on failure.
 */
M
Matt Roper 已提交
1152 1153 1154 1155 1156
int drm_universal_plane_init(struct drm_device *dev, struct drm_plane *plane,
			     unsigned long possible_crtcs,
			     const struct drm_plane_funcs *funcs,
			     const uint32_t *formats, uint32_t format_count,
			     enum drm_plane_type type)
J
Jesse Barnes 已提交
1157
{
1158 1159
	int ret;

1160
	drm_modeset_lock_all(dev);
J
Jesse Barnes 已提交
1161

1162 1163 1164 1165
	ret = drm_mode_object_get(dev, &plane->base, DRM_MODE_OBJECT_PLANE);
	if (ret)
		goto out;

R
Rob Clark 已提交
1166
	plane->base.properties = &plane->properties;
J
Jesse Barnes 已提交
1167 1168 1169 1170 1171 1172 1173
	plane->dev = dev;
	plane->funcs = funcs;
	plane->format_types = kmalloc(sizeof(uint32_t) * format_count,
				      GFP_KERNEL);
	if (!plane->format_types) {
		DRM_DEBUG_KMS("out of memory when allocating plane\n");
		drm_mode_object_put(dev, &plane->base);
1174 1175
		ret = -ENOMEM;
		goto out;
J
Jesse Barnes 已提交
1176 1177
	}

1178
	memcpy(plane->format_types, formats, format_count * sizeof(uint32_t));
J
Jesse Barnes 已提交
1179 1180
	plane->format_count = format_count;
	plane->possible_crtcs = possible_crtcs;
M
Matt Roper 已提交
1181
	plane->type = type;
J
Jesse Barnes 已提交
1182

M
Matt Roper 已提交
1183 1184 1185 1186
	list_add_tail(&plane->head, &dev->mode_config.plane_list);
	dev->mode_config.num_total_plane++;
	if (plane->type == DRM_PLANE_TYPE_OVERLAY)
		dev->mode_config.num_overlay_plane++;
J
Jesse Barnes 已提交
1187

R
Rob Clark 已提交
1188 1189 1190 1191
	drm_object_attach_property(&plane->base,
				   dev->mode_config.plane_type_property,
				   plane->type);

1192
 out:
1193
	drm_modeset_unlock_all(dev);
J
Jesse Barnes 已提交
1194

1195
	return ret;
J
Jesse Barnes 已提交
1196
}
M
Matt Roper 已提交
1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227
EXPORT_SYMBOL(drm_universal_plane_init);

/**
 * drm_plane_init - Initialize a legacy plane
 * @dev: DRM device
 * @plane: plane object to init
 * @possible_crtcs: bitmask of possible CRTCs
 * @funcs: callbacks for the new plane
 * @formats: array of supported formats (%DRM_FORMAT_*)
 * @format_count: number of elements in @formats
 * @is_primary: plane type (primary vs overlay)
 *
 * Legacy API to initialize a DRM plane.
 *
 * New drivers should call drm_universal_plane_init() instead.
 *
 * Returns:
 * Zero on success, error code on failure.
 */
int drm_plane_init(struct drm_device *dev, struct drm_plane *plane,
		   unsigned long possible_crtcs,
		   const struct drm_plane_funcs *funcs,
		   const uint32_t *formats, uint32_t format_count,
		   bool is_primary)
{
	enum drm_plane_type type;

	type = is_primary ? DRM_PLANE_TYPE_PRIMARY : DRM_PLANE_TYPE_OVERLAY;
	return drm_universal_plane_init(dev, plane, possible_crtcs, funcs,
					formats, format_count, type);
}
J
Jesse Barnes 已提交
1228 1229
EXPORT_SYMBOL(drm_plane_init);

1230 1231 1232 1233 1234 1235 1236 1237
/**
 * drm_plane_cleanup - Clean up the core plane usage
 * @plane: plane to cleanup
 *
 * This function cleans up @plane and removes it from the DRM mode setting
 * core. Note that the function does *not* free the plane structure itself,
 * this is the responsibility of the caller.
 */
J
Jesse Barnes 已提交
1238 1239 1240 1241
void drm_plane_cleanup(struct drm_plane *plane)
{
	struct drm_device *dev = plane->dev;

1242
	drm_modeset_lock_all(dev);
J
Jesse Barnes 已提交
1243 1244
	kfree(plane->format_types);
	drm_mode_object_put(dev, &plane->base);
M
Matt Roper 已提交
1245 1246 1247 1248 1249 1250 1251

	BUG_ON(list_empty(&plane->head));

	list_del(&plane->head);
	dev->mode_config.num_total_plane--;
	if (plane->type == DRM_PLANE_TYPE_OVERLAY)
		dev->mode_config.num_overlay_plane--;
1252
	drm_modeset_unlock_all(dev);
J
Jesse Barnes 已提交
1253 1254 1255
}
EXPORT_SYMBOL(drm_plane_cleanup);

1256 1257 1258 1259 1260 1261 1262 1263 1264
/**
 * drm_plane_force_disable - Forcibly disable a plane
 * @plane: plane to disable
 *
 * Forces the plane to be disabled.
 *
 * Used when the plane's current framebuffer is destroyed,
 * and when restoring fbdev mode.
 */
1265 1266
void drm_plane_force_disable(struct drm_plane *plane)
{
1267
	struct drm_framebuffer *old_fb = plane->fb;
1268 1269
	int ret;

1270
	if (!old_fb)
1271 1272 1273
		return;

	ret = plane->funcs->disable_plane(plane);
1274
	if (ret) {
1275
		DRM_ERROR("failed to disable plane with busy fb\n");
1276 1277
		return;
	}
1278
	/* disconnect the plane from the fb and crtc: */
1279
	__drm_framebuffer_unreference(old_fb);
1280 1281 1282 1283 1284
	plane->fb = NULL;
	plane->crtc = NULL;
}
EXPORT_SYMBOL(drm_plane_force_disable);

D
Dave Airlie 已提交
1285 1286 1287 1288
static int drm_mode_create_standard_connector_properties(struct drm_device *dev)
{
	struct drm_property *edid;
	struct drm_property *dpms;
D
Dave Airlie 已提交
1289
	struct drm_property *dev_path;
D
Dave Airlie 已提交
1290 1291 1292 1293 1294 1295 1296 1297 1298

	/*
	 * Standard properties (apply to all connectors)
	 */
	edid = drm_property_create(dev, DRM_MODE_PROP_BLOB |
				   DRM_MODE_PROP_IMMUTABLE,
				   "EDID", 0);
	dev->mode_config.edid_property = edid;

1299 1300 1301
	dpms = drm_property_create_enum(dev, 0,
				   "DPMS", drm_dpms_enum_list,
				   ARRAY_SIZE(drm_dpms_enum_list));
D
Dave Airlie 已提交
1302 1303
	dev->mode_config.dpms_property = dpms;

D
Dave Airlie 已提交
1304 1305 1306 1307 1308 1309
	dev_path = drm_property_create(dev,
				       DRM_MODE_PROP_BLOB |
				       DRM_MODE_PROP_IMMUTABLE,
				       "PATH", 0);
	dev->mode_config.path_property = dev_path;

D
Dave Airlie 已提交
1310 1311 1312
	return 0;
}

R
Rob Clark 已提交
1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327
static int drm_mode_create_standard_plane_properties(struct drm_device *dev)
{
	struct drm_property *type;

	/*
	 * Standard properties (apply to all planes)
	 */
	type = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
					"type", drm_plane_type_enum_list,
					ARRAY_SIZE(drm_plane_type_enum_list));
	dev->mode_config.plane_type_property = type;

	return 0;
}

D
Dave Airlie 已提交
1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342
/**
 * drm_mode_create_dvi_i_properties - create DVI-I specific connector properties
 * @dev: DRM device
 *
 * Called by a driver the first time a DVI-I connector is made.
 */
int drm_mode_create_dvi_i_properties(struct drm_device *dev)
{
	struct drm_property *dvi_i_selector;
	struct drm_property *dvi_i_subconnector;

	if (dev->mode_config.dvi_i_select_subconnector_property)
		return 0;

	dvi_i_selector =
1343
		drm_property_create_enum(dev, 0,
D
Dave Airlie 已提交
1344
				    "select subconnector",
1345
				    drm_dvi_i_select_enum_list,
D
Dave Airlie 已提交
1346 1347 1348
				    ARRAY_SIZE(drm_dvi_i_select_enum_list));
	dev->mode_config.dvi_i_select_subconnector_property = dvi_i_selector;

1349
	dvi_i_subconnector = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
D
Dave Airlie 已提交
1350
				    "subconnector",
1351
				    drm_dvi_i_subconnector_enum_list,
D
Dave Airlie 已提交
1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382
				    ARRAY_SIZE(drm_dvi_i_subconnector_enum_list));
	dev->mode_config.dvi_i_subconnector_property = dvi_i_subconnector;

	return 0;
}
EXPORT_SYMBOL(drm_mode_create_dvi_i_properties);

/**
 * drm_create_tv_properties - create TV specific connector properties
 * @dev: DRM device
 * @num_modes: number of different TV formats (modes) supported
 * @modes: array of pointers to strings containing name of each format
 *
 * Called by a driver's TV initialization routine, this function creates
 * the TV specific connector properties for a given device.  Caller is
 * responsible for allocating a list of format names and passing them to
 * this routine.
 */
int drm_mode_create_tv_properties(struct drm_device *dev, int num_modes,
				  char *modes[])
{
	struct drm_property *tv_selector;
	struct drm_property *tv_subconnector;
	int i;

	if (dev->mode_config.tv_select_subconnector_property)
		return 0;

	/*
	 * Basic connector properties
	 */
1383
	tv_selector = drm_property_create_enum(dev, 0,
D
Dave Airlie 已提交
1384
					  "select subconnector",
1385
					  drm_tv_select_enum_list,
D
Dave Airlie 已提交
1386 1387 1388 1389
					  ARRAY_SIZE(drm_tv_select_enum_list));
	dev->mode_config.tv_select_subconnector_property = tv_selector;

	tv_subconnector =
1390 1391 1392
		drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
				    "subconnector",
				    drm_tv_subconnector_enum_list,
D
Dave Airlie 已提交
1393 1394 1395 1396 1397 1398 1399
				    ARRAY_SIZE(drm_tv_subconnector_enum_list));
	dev->mode_config.tv_subconnector_property = tv_subconnector;

	/*
	 * Other, TV specific properties: margins & TV modes.
	 */
	dev->mode_config.tv_left_margin_property =
1400
		drm_property_create_range(dev, 0, "left margin", 0, 100);
D
Dave Airlie 已提交
1401 1402

	dev->mode_config.tv_right_margin_property =
1403
		drm_property_create_range(dev, 0, "right margin", 0, 100);
D
Dave Airlie 已提交
1404 1405

	dev->mode_config.tv_top_margin_property =
1406
		drm_property_create_range(dev, 0, "top margin", 0, 100);
D
Dave Airlie 已提交
1407 1408

	dev->mode_config.tv_bottom_margin_property =
1409
		drm_property_create_range(dev, 0, "bottom margin", 0, 100);
D
Dave Airlie 已提交
1410 1411 1412 1413 1414 1415 1416 1417

	dev->mode_config.tv_mode_property =
		drm_property_create(dev, DRM_MODE_PROP_ENUM,
				    "mode", num_modes);
	for (i = 0; i < num_modes; i++)
		drm_property_add_enum(dev->mode_config.tv_mode_property, i,
				      i, modes[i]);

1418
	dev->mode_config.tv_brightness_property =
1419
		drm_property_create_range(dev, 0, "brightness", 0, 100);
1420 1421

	dev->mode_config.tv_contrast_property =
1422
		drm_property_create_range(dev, 0, "contrast", 0, 100);
1423 1424

	dev->mode_config.tv_flicker_reduction_property =
1425
		drm_property_create_range(dev, 0, "flicker reduction", 0, 100);
1426

1427
	dev->mode_config.tv_overscan_property =
1428
		drm_property_create_range(dev, 0, "overscan", 0, 100);
1429 1430

	dev->mode_config.tv_saturation_property =
1431
		drm_property_create_range(dev, 0, "saturation", 0, 100);
1432 1433

	dev->mode_config.tv_hue_property =
1434
		drm_property_create_range(dev, 0, "hue", 0, 100);
1435

D
Dave Airlie 已提交
1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454
	return 0;
}
EXPORT_SYMBOL(drm_mode_create_tv_properties);

/**
 * drm_mode_create_scaling_mode_property - create scaling mode property
 * @dev: DRM device
 *
 * Called by a driver the first time it's needed, must be attached to desired
 * connectors.
 */
int drm_mode_create_scaling_mode_property(struct drm_device *dev)
{
	struct drm_property *scaling_mode;

	if (dev->mode_config.scaling_mode_property)
		return 0;

	scaling_mode =
1455 1456
		drm_property_create_enum(dev, 0, "scaling mode",
				drm_scaling_mode_enum_list,
D
Dave Airlie 已提交
1457 1458 1459 1460 1461 1462 1463 1464
				    ARRAY_SIZE(drm_scaling_mode_enum_list));

	dev->mode_config.scaling_mode_property = scaling_mode;

	return 0;
}
EXPORT_SYMBOL(drm_mode_create_scaling_mode_property);

1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479
/**
 * drm_mode_create_dirty_property - create dirty property
 * @dev: DRM device
 *
 * Called by a driver the first time it's needed, must be attached to desired
 * connectors.
 */
int drm_mode_create_dirty_info_property(struct drm_device *dev)
{
	struct drm_property *dirty_info;

	if (dev->mode_config.dirty_info_property)
		return 0;

	dirty_info =
1480
		drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
1481
				    "dirty",
1482
				    drm_dirty_info_enum_list,
1483 1484 1485 1486 1487 1488 1489
				    ARRAY_SIZE(drm_dirty_info_enum_list));
	dev->mode_config.dirty_info_property = dirty_info;

	return 0;
}
EXPORT_SYMBOL(drm_mode_create_dirty_info_property);

1490
static int drm_mode_group_init(struct drm_device *dev, struct drm_mode_group *group)
D
Dave Airlie 已提交
1491 1492 1493 1494 1495 1496
{
	uint32_t total_objects = 0;

	total_objects += dev->mode_config.num_crtc;
	total_objects += dev->mode_config.num_connector;
	total_objects += dev->mode_config.num_encoder;
S
Sean Paul 已提交
1497
	total_objects += dev->mode_config.num_bridge;
D
Dave Airlie 已提交
1498 1499 1500 1501 1502 1503 1504 1505

	group->id_list = kzalloc(total_objects * sizeof(uint32_t), GFP_KERNEL);
	if (!group->id_list)
		return -ENOMEM;

	group->num_crtcs = 0;
	group->num_connectors = 0;
	group->num_encoders = 0;
S
Sean Paul 已提交
1506
	group->num_bridges = 0;
D
Dave Airlie 已提交
1507 1508 1509
	return 0;
}

1510 1511 1512 1513 1514 1515
void drm_mode_group_destroy(struct drm_mode_group *group)
{
	kfree(group->id_list);
	group->id_list = NULL;
}

1516 1517 1518 1519
/*
 * NOTE: Driver's shouldn't ever call drm_mode_group_init_legacy_group - it is
 * the drm core's responsibility to set up mode control groups.
 */
D
Dave Airlie 已提交
1520 1521 1522 1523 1524 1525
int drm_mode_group_init_legacy_group(struct drm_device *dev,
				     struct drm_mode_group *group)
{
	struct drm_crtc *crtc;
	struct drm_encoder *encoder;
	struct drm_connector *connector;
S
Sean Paul 已提交
1526
	struct drm_bridge *bridge;
D
Dave Airlie 已提交
1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542
	int ret;

	if ((ret = drm_mode_group_init(dev, group)))
		return ret;

	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head)
		group->id_list[group->num_crtcs++] = crtc->base.id;

	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head)
		group->id_list[group->num_crtcs + group->num_encoders++] =
		encoder->base.id;

	list_for_each_entry(connector, &dev->mode_config.connector_list, head)
		group->id_list[group->num_crtcs + group->num_encoders +
			       group->num_connectors++] = connector->base.id;

S
Sean Paul 已提交
1543 1544 1545 1546 1547
	list_for_each_entry(bridge, &dev->mode_config.bridge_list, head)
		group->id_list[group->num_crtcs + group->num_encoders +
			       group->num_connectors + group->num_bridges++] =
					bridge->base.id;

D
Dave Airlie 已提交
1548 1549
	return 0;
}
1550
EXPORT_SYMBOL(drm_mode_group_init_legacy_group);
D
Dave Airlie 已提交
1551

1552 1553 1554 1555 1556 1557 1558 1559 1560
void drm_reinit_primary_mode_group(struct drm_device *dev)
{
	drm_modeset_lock_all(dev);
	drm_mode_group_destroy(&dev->primary->mode_group);
	drm_mode_group_init_legacy_group(dev, &dev->primary->mode_group);
	drm_modeset_unlock_all(dev);
}
EXPORT_SYMBOL(drm_reinit_primary_mode_group);

D
Dave Airlie 已提交
1561 1562 1563 1564 1565 1566 1567 1568
/**
 * drm_crtc_convert_to_umode - convert a drm_display_mode into a modeinfo
 * @out: drm_mode_modeinfo struct to return to the user
 * @in: drm_display_mode to use
 *
 * Convert a drm_display_mode into a drm_mode_modeinfo structure to return to
 * the user.
 */
1569 1570
static void drm_crtc_convert_to_umode(struct drm_mode_modeinfo *out,
				      const struct drm_display_mode *in)
D
Dave Airlie 已提交
1571
{
1572 1573 1574 1575 1576 1577 1578
	WARN(in->hdisplay > USHRT_MAX || in->hsync_start > USHRT_MAX ||
	     in->hsync_end > USHRT_MAX || in->htotal > USHRT_MAX ||
	     in->hskew > USHRT_MAX || in->vdisplay > USHRT_MAX ||
	     in->vsync_start > USHRT_MAX || in->vsync_end > USHRT_MAX ||
	     in->vtotal > USHRT_MAX || in->vscan > USHRT_MAX,
	     "timing values too large for mode info\n");

D
Dave Airlie 已提交
1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597
	out->clock = in->clock;
	out->hdisplay = in->hdisplay;
	out->hsync_start = in->hsync_start;
	out->hsync_end = in->hsync_end;
	out->htotal = in->htotal;
	out->hskew = in->hskew;
	out->vdisplay = in->vdisplay;
	out->vsync_start = in->vsync_start;
	out->vsync_end = in->vsync_end;
	out->vtotal = in->vtotal;
	out->vscan = in->vscan;
	out->vrefresh = in->vrefresh;
	out->flags = in->flags;
	out->type = in->type;
	strncpy(out->name, in->name, DRM_DISPLAY_MODE_LEN);
	out->name[DRM_DISPLAY_MODE_LEN-1] = 0;
}

/**
M
Marc-André Lureau 已提交
1598
 * drm_crtc_convert_umode - convert a modeinfo into a drm_display_mode
D
Dave Airlie 已提交
1599 1600 1601 1602 1603
 * @out: drm_display_mode to return to the user
 * @in: drm_mode_modeinfo to use
 *
 * Convert a drm_mode_modeinfo into a drm_display_mode structure to return to
 * the caller.
1604
 *
1605
 * Returns:
1606
 * Zero on success, errno on failure.
D
Dave Airlie 已提交
1607
 */
1608 1609
static int drm_crtc_convert_umode(struct drm_display_mode *out,
				  const struct drm_mode_modeinfo *in)
D
Dave Airlie 已提交
1610
{
1611 1612 1613
	if (in->clock > INT_MAX || in->vrefresh > INT_MAX)
		return -ERANGE;

1614 1615 1616
	if ((in->flags & DRM_MODE_FLAG_3D_MASK) > DRM_MODE_FLAG_3D_MAX)
		return -EINVAL;

D
Dave Airlie 已提交
1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632
	out->clock = in->clock;
	out->hdisplay = in->hdisplay;
	out->hsync_start = in->hsync_start;
	out->hsync_end = in->hsync_end;
	out->htotal = in->htotal;
	out->hskew = in->hskew;
	out->vdisplay = in->vdisplay;
	out->vsync_start = in->vsync_start;
	out->vsync_end = in->vsync_end;
	out->vtotal = in->vtotal;
	out->vscan = in->vscan;
	out->vrefresh = in->vrefresh;
	out->flags = in->flags;
	out->type = in->type;
	strncpy(out->name, in->name, DRM_DISPLAY_MODE_LEN);
	out->name[DRM_DISPLAY_MODE_LEN-1] = 0;
1633 1634

	return 0;
D
Dave Airlie 已提交
1635 1636 1637 1638
}

/**
 * drm_mode_getresources - get graphics configuration
1639 1640 1641
 * @dev: drm device for the ioctl
 * @data: data pointer for the ioctl
 * @file_priv: drm file for the ioctl call
D
Dave Airlie 已提交
1642 1643 1644 1645 1646 1647
 *
 * Construct a set of configuration description structures and return
 * them to the user, including CRTC, connector and framebuffer configuration.
 *
 * Called by the user via ioctl.
 *
1648
 * Returns:
D
Dave Airlie 已提交
1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671
 * Zero on success, errno on failure.
 */
int drm_mode_getresources(struct drm_device *dev, void *data,
			  struct drm_file *file_priv)
{
	struct drm_mode_card_res *card_res = data;
	struct list_head *lh;
	struct drm_framebuffer *fb;
	struct drm_connector *connector;
	struct drm_crtc *crtc;
	struct drm_encoder *encoder;
	int ret = 0;
	int connector_count = 0;
	int crtc_count = 0;
	int fb_count = 0;
	int encoder_count = 0;
	int copied = 0, i;
	uint32_t __user *fb_id;
	uint32_t __user *crtc_id;
	uint32_t __user *connector_id;
	uint32_t __user *encoder_id;
	struct drm_mode_group *mode_group;

1672 1673 1674
	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		return -EINVAL;

D
Dave Airlie 已提交
1675

1676
	mutex_lock(&file_priv->fbs_lock);
D
Dave Airlie 已提交
1677 1678 1679 1680 1681 1682 1683
	/*
	 * For the non-control nodes we need to limit the list of resources
	 * by IDs in the group list for this node
	 */
	list_for_each(lh, &file_priv->fbs)
		fb_count++;

1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700
	/* handle this in 4 parts */
	/* FBs */
	if (card_res->count_fbs >= fb_count) {
		copied = 0;
		fb_id = (uint32_t __user *)(unsigned long)card_res->fb_id_ptr;
		list_for_each_entry(fb, &file_priv->fbs, filp_head) {
			if (put_user(fb->base.id, fb_id + copied)) {
				mutex_unlock(&file_priv->fbs_lock);
				return -EFAULT;
			}
			copied++;
		}
	}
	card_res->count_fbs = fb_count;
	mutex_unlock(&file_priv->fbs_lock);

	drm_modeset_lock_all(dev);
1701
	if (!drm_is_primary_client(file_priv)) {
D
Dave Airlie 已提交
1702

1703
		mode_group = NULL;
D
Dave Airlie 已提交
1704 1705 1706 1707 1708 1709 1710 1711 1712 1713
		list_for_each(lh, &dev->mode_config.crtc_list)
			crtc_count++;

		list_for_each(lh, &dev->mode_config.connector_list)
			connector_count++;

		list_for_each(lh, &dev->mode_config.encoder_list)
			encoder_count++;
	} else {

1714
		mode_group = &file_priv->master->minor->mode_group;
D
Dave Airlie 已提交
1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728
		crtc_count = mode_group->num_crtcs;
		connector_count = mode_group->num_connectors;
		encoder_count = mode_group->num_encoders;
	}

	card_res->max_height = dev->mode_config.max_height;
	card_res->min_height = dev->mode_config.min_height;
	card_res->max_width = dev->mode_config.max_width;
	card_res->min_width = dev->mode_config.min_width;

	/* CRTCs */
	if (card_res->count_crtcs >= crtc_count) {
		copied = 0;
		crtc_id = (uint32_t __user *)(unsigned long)card_res->crtc_id_ptr;
1729
		if (!mode_group) {
D
Dave Airlie 已提交
1730 1731
			list_for_each_entry(crtc, &dev->mode_config.crtc_list,
					    head) {
1732
				DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id);
D
Dave Airlie 已提交
1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755
				if (put_user(crtc->base.id, crtc_id + copied)) {
					ret = -EFAULT;
					goto out;
				}
				copied++;
			}
		} else {
			for (i = 0; i < mode_group->num_crtcs; i++) {
				if (put_user(mode_group->id_list[i],
					     crtc_id + copied)) {
					ret = -EFAULT;
					goto out;
				}
				copied++;
			}
		}
	}
	card_res->count_crtcs = crtc_count;

	/* Encoders */
	if (card_res->count_encoders >= encoder_count) {
		copied = 0;
		encoder_id = (uint32_t __user *)(unsigned long)card_res->encoder_id_ptr;
1756
		if (!mode_group) {
D
Dave Airlie 已提交
1757 1758 1759
			list_for_each_entry(encoder,
					    &dev->mode_config.encoder_list,
					    head) {
1760
				DRM_DEBUG_KMS("[ENCODER:%d:%s]\n", encoder->base.id,
1761
						encoder->name);
D
Dave Airlie 已提交
1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786
				if (put_user(encoder->base.id, encoder_id +
					     copied)) {
					ret = -EFAULT;
					goto out;
				}
				copied++;
			}
		} else {
			for (i = mode_group->num_crtcs; i < mode_group->num_crtcs + mode_group->num_encoders; i++) {
				if (put_user(mode_group->id_list[i],
					     encoder_id + copied)) {
					ret = -EFAULT;
					goto out;
				}
				copied++;
			}

		}
	}
	card_res->count_encoders = encoder_count;

	/* Connectors */
	if (card_res->count_connectors >= connector_count) {
		copied = 0;
		connector_id = (uint32_t __user *)(unsigned long)card_res->connector_id_ptr;
1787
		if (!mode_group) {
D
Dave Airlie 已提交
1788 1789 1790
			list_for_each_entry(connector,
					    &dev->mode_config.connector_list,
					    head) {
1791 1792
				DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
					connector->base.id,
1793
					connector->name);
D
Dave Airlie 已提交
1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815
				if (put_user(connector->base.id,
					     connector_id + copied)) {
					ret = -EFAULT;
					goto out;
				}
				copied++;
			}
		} else {
			int start = mode_group->num_crtcs +
				mode_group->num_encoders;
			for (i = start; i < start + mode_group->num_connectors; i++) {
				if (put_user(mode_group->id_list[i],
					     connector_id + copied)) {
					ret = -EFAULT;
					goto out;
				}
				copied++;
			}
		}
	}
	card_res->count_connectors = connector_count;

1816
	DRM_DEBUG_KMS("CRTC[%d] CONNECTORS[%d] ENCODERS[%d]\n", card_res->count_crtcs,
D
Dave Airlie 已提交
1817 1818 1819
		  card_res->count_connectors, card_res->count_encoders);

out:
1820
	drm_modeset_unlock_all(dev);
D
Dave Airlie 已提交
1821 1822 1823 1824 1825
	return ret;
}

/**
 * drm_mode_getcrtc - get CRTC configuration
1826 1827 1828
 * @dev: drm device for the ioctl
 * @data: data pointer for the ioctl
 * @file_priv: drm file for the ioctl call
D
Dave Airlie 已提交
1829 1830 1831 1832 1833
 *
 * Construct a CRTC configuration structure to return to the user.
 *
 * Called by the user via ioctl.
 *
1834
 * Returns:
D
Dave Airlie 已提交
1835 1836 1837 1838 1839 1840 1841 1842 1843
 * Zero on success, errno on failure.
 */
int drm_mode_getcrtc(struct drm_device *dev,
		     void *data, struct drm_file *file_priv)
{
	struct drm_mode_crtc *crtc_resp = data;
	struct drm_crtc *crtc;
	int ret = 0;

1844 1845 1846
	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		return -EINVAL;

1847
	drm_modeset_lock_all(dev);
D
Dave Airlie 已提交
1848

R
Rob Clark 已提交
1849 1850
	crtc = drm_crtc_find(dev, crtc_resp->crtc_id);
	if (!crtc) {
1851
		ret = -ENOENT;
D
Dave Airlie 已提交
1852 1853 1854 1855 1856 1857
		goto out;
	}

	crtc_resp->x = crtc->x;
	crtc_resp->y = crtc->y;
	crtc_resp->gamma_size = crtc->gamma_size;
1858 1859
	if (crtc->primary->fb)
		crtc_resp->fb_id = crtc->primary->fb->base.id;
D
Dave Airlie 已提交
1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872
	else
		crtc_resp->fb_id = 0;

	if (crtc->enabled) {

		drm_crtc_convert_to_umode(&crtc_resp->mode, &crtc->mode);
		crtc_resp->mode_valid = 1;

	} else {
		crtc_resp->mode_valid = 0;
	}

out:
1873
	drm_modeset_unlock_all(dev);
D
Dave Airlie 已提交
1874 1875 1876
	return ret;
}

1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889
static bool drm_mode_expose_to_userspace(const struct drm_display_mode *mode,
					 const struct drm_file *file_priv)
{
	/*
	 * If user-space hasn't configured the driver to expose the stereo 3D
	 * modes, don't expose them.
	 */
	if (!file_priv->stereo_allowed && drm_mode_is_stereo(mode))
		return false;

	return true;
}

D
Dave Airlie 已提交
1890 1891
/**
 * drm_mode_getconnector - get connector configuration
1892 1893 1894
 * @dev: drm device for the ioctl
 * @data: data pointer for the ioctl
 * @file_priv: drm file for the ioctl call
D
Dave Airlie 已提交
1895 1896 1897 1898 1899
 *
 * Construct a connector configuration structure to return to the user.
 *
 * Called by the user via ioctl.
 *
1900
 * Returns:
D
Dave Airlie 已提交
1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920
 * Zero on success, errno on failure.
 */
int drm_mode_getconnector(struct drm_device *dev, void *data,
			  struct drm_file *file_priv)
{
	struct drm_mode_get_connector *out_resp = data;
	struct drm_connector *connector;
	struct drm_display_mode *mode;
	int mode_count = 0;
	int props_count = 0;
	int encoders_count = 0;
	int ret = 0;
	int copied = 0;
	int i;
	struct drm_mode_modeinfo u_mode;
	struct drm_mode_modeinfo __user *mode_ptr;
	uint32_t __user *prop_ptr;
	uint64_t __user *prop_values;
	uint32_t __user *encoder_ptr;

1921 1922 1923
	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		return -EINVAL;

D
Dave Airlie 已提交
1924 1925
	memset(&u_mode, 0, sizeof(struct drm_mode_modeinfo));

1926
	DRM_DEBUG_KMS("[CONNECTOR:%d:?]\n", out_resp->connector_id);
D
Dave Airlie 已提交
1927

1928
	mutex_lock(&dev->mode_config.mutex);
D
Dave Airlie 已提交
1929

R
Rob Clark 已提交
1930 1931
	connector = drm_connector_find(dev, out_resp->connector_id);
	if (!connector) {
1932
		ret = -ENOENT;
D
Dave Airlie 已提交
1933 1934 1935
		goto out;
	}

1936
	props_count = connector->properties.count;
D
Dave Airlie 已提交
1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951

	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		if (connector->encoder_ids[i] != 0) {
			encoders_count++;
		}
	}

	if (out_resp->count_modes == 0) {
		connector->funcs->fill_modes(connector,
					     dev->mode_config.max_width,
					     dev->mode_config.max_height);
	}

	/* delayed so we get modes regardless of pre-fill_modes state */
	list_for_each_entry(mode, &connector->modes, head)
1952 1953
		if (drm_mode_expose_to_userspace(mode, file_priv))
			mode_count++;
D
Dave Airlie 已提交
1954 1955 1956 1957 1958 1959 1960 1961

	out_resp->connector_id = connector->base.id;
	out_resp->connector_type = connector->connector_type;
	out_resp->connector_type_id = connector->connector_type_id;
	out_resp->mm_width = connector->display_info.width_mm;
	out_resp->mm_height = connector->display_info.height_mm;
	out_resp->subpixel = connector->display_info.subpixel_order;
	out_resp->connection = connector->status;
1962
	drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
D
Dave Airlie 已提交
1963 1964 1965 1966
	if (connector->encoder)
		out_resp->encoder_id = connector->encoder->base.id;
	else
		out_resp->encoder_id = 0;
1967
	drm_modeset_unlock(&dev->mode_config.connection_mutex);
D
Dave Airlie 已提交
1968 1969 1970 1971 1972 1973 1974

	/*
	 * This ioctl is called twice, once to determine how much space is
	 * needed, and the 2nd time to fill it.
	 */
	if ((out_resp->count_modes >= mode_count) && mode_count) {
		copied = 0;
V
Ville Syrjälä 已提交
1975
		mode_ptr = (struct drm_mode_modeinfo __user *)(unsigned long)out_resp->modes_ptr;
D
Dave Airlie 已提交
1976
		list_for_each_entry(mode, &connector->modes, head) {
1977 1978 1979
			if (!drm_mode_expose_to_userspace(mode, file_priv))
				continue;

D
Dave Airlie 已提交
1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992
			drm_crtc_convert_to_umode(&u_mode, mode);
			if (copy_to_user(mode_ptr + copied,
					 &u_mode, sizeof(u_mode))) {
				ret = -EFAULT;
				goto out;
			}
			copied++;
		}
	}
	out_resp->count_modes = mode_count;

	if ((out_resp->count_props >= props_count) && props_count) {
		copied = 0;
V
Ville Syrjälä 已提交
1993 1994
		prop_ptr = (uint32_t __user *)(unsigned long)(out_resp->props_ptr);
		prop_values = (uint64_t __user *)(unsigned long)(out_resp->prop_values_ptr);
1995 1996 1997 1998 1999 2000
		for (i = 0; i < connector->properties.count; i++) {
			if (put_user(connector->properties.ids[i],
				     prop_ptr + copied)) {
				ret = -EFAULT;
				goto out;
			}
D
Dave Airlie 已提交
2001

2002 2003 2004 2005
			if (put_user(connector->properties.values[i],
				     prop_values + copied)) {
				ret = -EFAULT;
				goto out;
D
Dave Airlie 已提交
2006
			}
2007
			copied++;
D
Dave Airlie 已提交
2008 2009 2010 2011 2012 2013
		}
	}
	out_resp->count_props = props_count;

	if ((out_resp->count_encoders >= encoders_count) && encoders_count) {
		copied = 0;
V
Ville Syrjälä 已提交
2014
		encoder_ptr = (uint32_t __user *)(unsigned long)(out_resp->encoders_ptr);
D
Dave Airlie 已提交
2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028
		for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
			if (connector->encoder_ids[i] != 0) {
				if (put_user(connector->encoder_ids[i],
					     encoder_ptr + copied)) {
					ret = -EFAULT;
					goto out;
				}
				copied++;
			}
		}
	}
	out_resp->count_encoders = encoders_count;

out:
2029 2030
	mutex_unlock(&dev->mode_config.mutex);

D
Dave Airlie 已提交
2031 2032 2033
	return ret;
}

2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046
/**
 * drm_mode_getencoder - get encoder configuration
 * @dev: drm device for the ioctl
 * @data: data pointer for the ioctl
 * @file_priv: drm file for the ioctl call
 *
 * Construct a encoder configuration structure to return to the user.
 *
 * Called by the user via ioctl.
 *
 * Returns:
 * Zero on success, errno on failure.
 */
D
Dave Airlie 已提交
2047 2048 2049 2050 2051 2052 2053
int drm_mode_getencoder(struct drm_device *dev, void *data,
			struct drm_file *file_priv)
{
	struct drm_mode_get_encoder *enc_resp = data;
	struct drm_encoder *encoder;
	int ret = 0;

2054 2055 2056
	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		return -EINVAL;

2057
	drm_modeset_lock_all(dev);
R
Rob Clark 已提交
2058 2059
	encoder = drm_encoder_find(dev, enc_resp->encoder_id);
	if (!encoder) {
2060
		ret = -ENOENT;
D
Dave Airlie 已提交
2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073
		goto out;
	}

	if (encoder->crtc)
		enc_resp->crtc_id = encoder->crtc->base.id;
	else
		enc_resp->crtc_id = 0;
	enc_resp->encoder_type = encoder->encoder_type;
	enc_resp->encoder_id = encoder->base.id;
	enc_resp->possible_crtcs = encoder->possible_crtcs;
	enc_resp->possible_clones = encoder->possible_clones;

out:
2074
	drm_modeset_unlock_all(dev);
D
Dave Airlie 已提交
2075 2076 2077
	return ret;
}

J
Jesse Barnes 已提交
2078
/**
2079
 * drm_mode_getplane_res - enumerate all plane resources
J
Jesse Barnes 已提交
2080 2081 2082 2083
 * @dev: DRM device
 * @data: ioctl data
 * @file_priv: DRM file info
 *
2084 2085 2086 2087 2088 2089
 * Construct a list of plane ids to return to the user.
 *
 * Called by the user via ioctl.
 *
 * Returns:
 * Zero on success, errno on failure.
J
Jesse Barnes 已提交
2090 2091
 */
int drm_mode_getplane_res(struct drm_device *dev, void *data,
2092
			  struct drm_file *file_priv)
J
Jesse Barnes 已提交
2093 2094 2095 2096 2097 2098
{
	struct drm_mode_get_plane_res *plane_resp = data;
	struct drm_mode_config *config;
	struct drm_plane *plane;
	uint32_t __user *plane_ptr;
	int copied = 0, ret = 0;
2099
	unsigned num_planes;
J
Jesse Barnes 已提交
2100 2101 2102 2103

	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		return -EINVAL;

2104
	drm_modeset_lock_all(dev);
J
Jesse Barnes 已提交
2105 2106
	config = &dev->mode_config;

2107 2108 2109 2110 2111
	if (file_priv->universal_planes)
		num_planes = config->num_total_plane;
	else
		num_planes = config->num_overlay_plane;

J
Jesse Barnes 已提交
2112 2113 2114 2115
	/*
	 * This ioctl is called twice, once to determine how much space is
	 * needed, and the 2nd time to fill it.
	 */
2116 2117
	if (num_planes &&
	    (plane_resp->count_planes >= num_planes)) {
V
Ville Syrjälä 已提交
2118
		plane_ptr = (uint32_t __user *)(unsigned long)plane_resp->plane_id_ptr;
J
Jesse Barnes 已提交
2119 2120

		list_for_each_entry(plane, &config->plane_list, head) {
2121 2122 2123 2124 2125 2126
			/*
			 * Unless userspace set the 'universal planes'
			 * capability bit, only advertise overlays.
			 */
			if (plane->type != DRM_PLANE_TYPE_OVERLAY &&
			    !file_priv->universal_planes)
2127 2128
				continue;

J
Jesse Barnes 已提交
2129 2130 2131 2132 2133 2134 2135
			if (put_user(plane->base.id, plane_ptr + copied)) {
				ret = -EFAULT;
				goto out;
			}
			copied++;
		}
	}
2136
	plane_resp->count_planes = num_planes;
J
Jesse Barnes 已提交
2137 2138

out:
2139
	drm_modeset_unlock_all(dev);
J
Jesse Barnes 已提交
2140 2141 2142 2143
	return ret;
}

/**
2144
 * drm_mode_getplane - get plane configuration
J
Jesse Barnes 已提交
2145 2146 2147 2148
 * @dev: DRM device
 * @data: ioctl data
 * @file_priv: DRM file info
 *
2149 2150 2151 2152 2153 2154
 * Construct a plane configuration structure to return to the user.
 *
 * Called by the user via ioctl.
 *
 * Returns:
 * Zero on success, errno on failure.
J
Jesse Barnes 已提交
2155 2156
 */
int drm_mode_getplane(struct drm_device *dev, void *data,
2157
		      struct drm_file *file_priv)
J
Jesse Barnes 已提交
2158 2159 2160 2161 2162 2163 2164 2165 2166
{
	struct drm_mode_get_plane *plane_resp = data;
	struct drm_plane *plane;
	uint32_t __user *format_ptr;
	int ret = 0;

	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		return -EINVAL;

2167
	drm_modeset_lock_all(dev);
R
Rob Clark 已提交
2168 2169
	plane = drm_plane_find(dev, plane_resp->plane_id);
	if (!plane) {
J
Jesse Barnes 已提交
2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185
		ret = -ENOENT;
		goto out;
	}

	if (plane->crtc)
		plane_resp->crtc_id = plane->crtc->base.id;
	else
		plane_resp->crtc_id = 0;

	if (plane->fb)
		plane_resp->fb_id = plane->fb->base.id;
	else
		plane_resp->fb_id = 0;

	plane_resp->plane_id = plane->base.id;
	plane_resp->possible_crtcs = plane->possible_crtcs;
2186
	plane_resp->gamma_size = 0;
J
Jesse Barnes 已提交
2187 2188 2189 2190 2191 2192 2193

	/*
	 * This ioctl is called twice, once to determine how much space is
	 * needed, and the 2nd time to fill it.
	 */
	if (plane->format_count &&
	    (plane_resp->count_format_types >= plane->format_count)) {
V
Ville Syrjälä 已提交
2194
		format_ptr = (uint32_t __user *)(unsigned long)plane_resp->format_type_ptr;
J
Jesse Barnes 已提交
2195 2196 2197 2198 2199 2200 2201 2202 2203 2204
		if (copy_to_user(format_ptr,
				 plane->format_types,
				 sizeof(uint32_t) * plane->format_count)) {
			ret = -EFAULT;
			goto out;
		}
	}
	plane_resp->count_format_types = plane->format_count;

out:
2205
	drm_modeset_unlock_all(dev);
J
Jesse Barnes 已提交
2206 2207 2208
	return ret;
}

2209 2210
/*
 * setplane_internal - setplane handler for internal callers
J
Jesse Barnes 已提交
2211
 *
2212 2213 2214
 * Note that we assume an extra reference has already been taken on fb.  If the
 * update fails, this reference will be dropped before return; if it succeeds,
 * the previous framebuffer (if any) will be unreferenced instead.
2215
 *
2216
 * src_{x,y,w,h} are provided in 16.16 fixed point format
J
Jesse Barnes 已提交
2217
 */
2218 2219
static int setplane_internal(struct drm_plane *plane,
			     struct drm_crtc *crtc,
2220 2221 2222 2223 2224 2225
			     struct drm_framebuffer *fb,
			     int32_t crtc_x, int32_t crtc_y,
			     uint32_t crtc_w, uint32_t crtc_h,
			     /* src_{x,y,w,h} values are 16.16 fixed point */
			     uint32_t src_x, uint32_t src_y,
			     uint32_t src_w, uint32_t src_h)
J
Jesse Barnes 已提交
2226
{
2227
	struct drm_device *dev = plane->dev;
2228
	struct drm_framebuffer *old_fb = NULL;
J
Jesse Barnes 已提交
2229
	int ret = 0;
2230
	unsigned int fb_width, fb_height;
2231
	int i;
J
Jesse Barnes 已提交
2232 2233

	/* No fb means shut it down */
2234
	if (!fb) {
2235 2236
		drm_modeset_lock_all(dev);
		old_fb = plane->fb;
2237 2238 2239 2240 2241 2242 2243
		ret = plane->funcs->disable_plane(plane);
		if (!ret) {
			plane->crtc = NULL;
			plane->fb = NULL;
		} else {
			old_fb = NULL;
		}
2244
		drm_modeset_unlock_all(dev);
J
Jesse Barnes 已提交
2245 2246 2247
		goto out;
	}

2248 2249 2250 2251 2252 2253 2254
	/* Check whether this plane is usable on this CRTC */
	if (!(plane->possible_crtcs & drm_crtc_mask(crtc))) {
		DRM_DEBUG_KMS("Invalid crtc for plane\n");
		ret = -EINVAL;
		goto out;
	}

2255 2256 2257 2258 2259
	/* Check whether this plane supports the fb pixel format. */
	for (i = 0; i < plane->format_count; i++)
		if (fb->pixel_format == plane->format_types[i])
			break;
	if (i == plane->format_count) {
2260 2261
		DRM_DEBUG_KMS("Invalid pixel format %s\n",
			      drm_get_format_name(fb->pixel_format));
2262 2263 2264 2265
		ret = -EINVAL;
		goto out;
	}

2266 2267 2268 2269
	fb_width = fb->width << 16;
	fb_height = fb->height << 16;

	/* Make sure source coordinates are inside the fb. */
2270 2271 2272 2273
	if (src_w > fb_width ||
	    src_x > fb_width - src_w ||
	    src_h > fb_height ||
	    src_y > fb_height - src_h) {
2274 2275
		DRM_DEBUG_KMS("Invalid source coordinates "
			      "%u.%06ux%u.%06u+%u.%06u+%u.%06u\n",
2276 2277 2278 2279
			      src_w >> 16, ((src_w & 0xffff) * 15625) >> 10,
			      src_h >> 16, ((src_h & 0xffff) * 15625) >> 10,
			      src_x >> 16, ((src_x & 0xffff) * 15625) >> 10,
			      src_y >> 16, ((src_y & 0xffff) * 15625) >> 10);
2280 2281 2282 2283
		ret = -ENOSPC;
		goto out;
	}

2284
	drm_modeset_lock_all(dev);
2285
	old_fb = plane->fb;
J
Jesse Barnes 已提交
2286
	ret = plane->funcs->update_plane(plane, crtc, fb,
2287 2288
					 crtc_x, crtc_y, crtc_w, crtc_h,
					 src_x, src_y, src_w, src_h);
J
Jesse Barnes 已提交
2289 2290 2291
	if (!ret) {
		plane->crtc = crtc;
		plane->fb = fb;
2292
		fb = NULL;
2293 2294
	} else {
		old_fb = NULL;
J
Jesse Barnes 已提交
2295
	}
2296
	drm_modeset_unlock_all(dev);
J
Jesse Barnes 已提交
2297 2298

out:
2299 2300 2301 2302
	if (fb)
		drm_framebuffer_unreference(fb);
	if (old_fb)
		drm_framebuffer_unreference(old_fb);
J
Jesse Barnes 已提交
2303 2304

	return ret;
2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374

}

/**
 * drm_mode_setplane - configure a plane's configuration
 * @dev: DRM device
 * @data: ioctl data*
 * @file_priv: DRM file info
 *
 * Set plane configuration, including placement, fb, scaling, and other factors.
 * Or pass a NULL fb to disable (planes may be disabled without providing a
 * valid crtc).
 *
 * Returns:
 * Zero on success, errno on failure.
 */
int drm_mode_setplane(struct drm_device *dev, void *data,
		      struct drm_file *file_priv)
{
	struct drm_mode_set_plane *plane_req = data;
	struct drm_mode_object *obj;
	struct drm_plane *plane;
	struct drm_crtc *crtc = NULL;
	struct drm_framebuffer *fb = NULL;

	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		return -EINVAL;

	/* Give drivers some help against integer overflows */
	if (plane_req->crtc_w > INT_MAX ||
	    plane_req->crtc_x > INT_MAX - (int32_t) plane_req->crtc_w ||
	    plane_req->crtc_h > INT_MAX ||
	    plane_req->crtc_y > INT_MAX - (int32_t) plane_req->crtc_h) {
		DRM_DEBUG_KMS("Invalid CRTC coordinates %ux%u+%d+%d\n",
			      plane_req->crtc_w, plane_req->crtc_h,
			      plane_req->crtc_x, plane_req->crtc_y);
		return -ERANGE;
	}

	/*
	 * First, find the plane, crtc, and fb objects.  If not available,
	 * we don't bother to call the driver.
	 */
	obj = drm_mode_object_find(dev, plane_req->plane_id,
				   DRM_MODE_OBJECT_PLANE);
	if (!obj) {
		DRM_DEBUG_KMS("Unknown plane ID %d\n",
			      plane_req->plane_id);
		return -ENOENT;
	}
	plane = obj_to_plane(obj);

	if (plane_req->fb_id) {
		fb = drm_framebuffer_lookup(dev, plane_req->fb_id);
		if (!fb) {
			DRM_DEBUG_KMS("Unknown framebuffer ID %d\n",
				      plane_req->fb_id);
			return -ENOENT;
		}

		obj = drm_mode_object_find(dev, plane_req->crtc_id,
					   DRM_MODE_OBJECT_CRTC);
		if (!obj) {
			DRM_DEBUG_KMS("Unknown crtc ID %d\n",
				      plane_req->crtc_id);
			return -ENOENT;
		}
		crtc = obj_to_crtc(obj);
	}

2375 2376 2377 2378
	/*
	 * setplane_internal will take care of deref'ing either the old or new
	 * framebuffer depending on success.
	 */
2379
	return setplane_internal(plane, crtc, fb,
2380 2381 2382 2383
				 plane_req->crtc_x, plane_req->crtc_y,
				 plane_req->crtc_w, plane_req->crtc_h,
				 plane_req->src_x, plane_req->src_y,
				 plane_req->src_w, plane_req->src_h);
J
Jesse Barnes 已提交
2384 2385
}

2386 2387 2388 2389 2390 2391
/**
 * drm_mode_set_config_internal - helper to call ->set_config
 * @set: modeset config to set
 *
 * This is a little helper to wrap internal calls to the ->set_config driver
 * interface. The only thing it adds is correct refcounting dance.
2392 2393 2394
 * 
 * Returns:
 * Zero on success, errno on failure.
2395 2396 2397 2398
 */
int drm_mode_set_config_internal(struct drm_mode_set *set)
{
	struct drm_crtc *crtc = set->crtc;
D
Daniel Vetter 已提交
2399 2400
	struct drm_framebuffer *fb;
	struct drm_crtc *tmp;
2401 2402
	int ret;

D
Daniel Vetter 已提交
2403 2404 2405 2406 2407 2408
	/*
	 * NOTE: ->set_config can also disable other crtcs (if we steal all
	 * connectors from it), hence we need to refcount the fbs across all
	 * crtcs. Atomic modeset will have saner semantics ...
	 */
	list_for_each_entry(tmp, &crtc->dev->mode_config.crtc_list, head)
2409
		tmp->old_fb = tmp->primary->fb;
D
Daniel Vetter 已提交
2410

2411
	fb = set->fb;
2412

2413 2414
	ret = crtc->funcs->set_config(set);
	if (ret == 0) {
2415
		crtc->primary->crtc = crtc;
2416
		crtc->primary->fb = fb;
D
Daniel Vetter 已提交
2417
	}
2418

D
Daniel Vetter 已提交
2419
	list_for_each_entry(tmp, &crtc->dev->mode_config.crtc_list, head) {
2420 2421
		if (tmp->primary->fb)
			drm_framebuffer_reference(tmp->primary->fb);
D
Daniel Vetter 已提交
2422 2423
		if (tmp->old_fb)
			drm_framebuffer_unreference(tmp->old_fb);
2424 2425 2426
	}

	return ret;
2427 2428 2429
}
EXPORT_SYMBOL(drm_mode_set_config_internal);

2430 2431 2432 2433 2434 2435 2436 2437
/**
 * drm_crtc_check_viewport - Checks that a framebuffer is big enough for the
 *     CRTC viewport
 * @crtc: CRTC that framebuffer will be displayed on
 * @x: x panning
 * @y: y panning
 * @mode: mode that framebuffer will be displayed under
 * @fb: framebuffer to check size of
2438
 */
2439 2440 2441 2442
int drm_crtc_check_viewport(const struct drm_crtc *crtc,
			    int x, int y,
			    const struct drm_display_mode *mode,
			    const struct drm_framebuffer *fb)
2443 2444 2445 2446 2447 2448 2449

{
	int hdisplay, vdisplay;

	hdisplay = mode->hdisplay;
	vdisplay = mode->vdisplay;

2450 2451 2452 2453 2454 2455 2456 2457
	if (drm_mode_is_stereo(mode)) {
		struct drm_display_mode adjusted = *mode;

		drm_mode_set_crtcinfo(&adjusted, CRTC_STEREO_DOUBLE);
		hdisplay = adjusted.crtc_hdisplay;
		vdisplay = adjusted.crtc_vdisplay;
	}

2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472
	if (crtc->invert_dimensions)
		swap(hdisplay, vdisplay);

	if (hdisplay > fb->width ||
	    vdisplay > fb->height ||
	    x > fb->width - hdisplay ||
	    y > fb->height - vdisplay) {
		DRM_DEBUG_KMS("Invalid fb size %ux%u for CRTC viewport %ux%u+%d+%d%s.\n",
			      fb->width, fb->height, hdisplay, vdisplay, x, y,
			      crtc->invert_dimensions ? " (inverted)" : "");
		return -ENOSPC;
	}

	return 0;
}
2473
EXPORT_SYMBOL(drm_crtc_check_viewport);
2474

D
Dave Airlie 已提交
2475 2476
/**
 * drm_mode_setcrtc - set CRTC configuration
2477 2478 2479
 * @dev: drm device for the ioctl
 * @data: data pointer for the ioctl
 * @file_priv: drm file for the ioctl call
D
Dave Airlie 已提交
2480 2481 2482 2483 2484
 *
 * Build a new CRTC configuration based on user request.
 *
 * Called by the user via ioctl.
 *
2485
 * Returns:
D
Dave Airlie 已提交
2486 2487 2488 2489 2490 2491 2492
 * Zero on success, errno on failure.
 */
int drm_mode_setcrtc(struct drm_device *dev, void *data,
		     struct drm_file *file_priv)
{
	struct drm_mode_config *config = &dev->mode_config;
	struct drm_mode_crtc *crtc_req = data;
2493
	struct drm_crtc *crtc;
D
Dave Airlie 已提交
2494 2495 2496 2497 2498
	struct drm_connector **connector_set = NULL, *connector;
	struct drm_framebuffer *fb = NULL;
	struct drm_display_mode *mode = NULL;
	struct drm_mode_set set;
	uint32_t __user *set_connectors_ptr;
2499
	int ret;
D
Dave Airlie 已提交
2500 2501
	int i;

2502 2503 2504
	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		return -EINVAL;

2505 2506 2507 2508
	/* For some reason crtc x/y offsets are signed internally. */
	if (crtc_req->x > INT_MAX || crtc_req->y > INT_MAX)
		return -ERANGE;

2509
	drm_modeset_lock_all(dev);
R
Rob Clark 已提交
2510 2511
	crtc = drm_crtc_find(dev, crtc_req->crtc_id);
	if (!crtc) {
2512
		DRM_DEBUG_KMS("Unknown CRTC ID %d\n", crtc_req->crtc_id);
2513
		ret = -ENOENT;
D
Dave Airlie 已提交
2514 2515
		goto out;
	}
2516
	DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id);
D
Dave Airlie 已提交
2517 2518 2519 2520 2521

	if (crtc_req->mode_valid) {
		/* If we have a mode we need a framebuffer. */
		/* If we pass -1, set the mode with the currently bound fb */
		if (crtc_req->fb_id == -1) {
2522
			if (!crtc->primary->fb) {
2523 2524 2525
				DRM_DEBUG_KMS("CRTC doesn't have current FB\n");
				ret = -EINVAL;
				goto out;
D
Dave Airlie 已提交
2526
			}
2527
			fb = crtc->primary->fb;
2528 2529
			/* Make refcounting symmetric with the lookup path. */
			drm_framebuffer_reference(fb);
D
Dave Airlie 已提交
2530
		} else {
2531 2532
			fb = drm_framebuffer_lookup(dev, crtc_req->fb_id);
			if (!fb) {
2533 2534
				DRM_DEBUG_KMS("Unknown FB ID%d\n",
						crtc_req->fb_id);
2535
				ret = -ENOENT;
D
Dave Airlie 已提交
2536 2537 2538 2539 2540
				goto out;
			}
		}

		mode = drm_mode_create(dev);
2541 2542 2543 2544 2545
		if (!mode) {
			ret = -ENOMEM;
			goto out;
		}

2546 2547 2548 2549 2550 2551
		ret = drm_crtc_convert_umode(mode, &crtc_req->mode);
		if (ret) {
			DRM_DEBUG_KMS("Invalid mode\n");
			goto out;
		}

D
Dave Airlie 已提交
2552
		drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
2553

2554 2555 2556
		ret = drm_crtc_check_viewport(crtc, crtc_req->x, crtc_req->y,
					      mode, fb);
		if (ret)
2557
			goto out;
2558

D
Dave Airlie 已提交
2559 2560 2561
	}

	if (crtc_req->count_connectors == 0 && mode) {
2562
		DRM_DEBUG_KMS("Count connectors is 0 but mode set\n");
D
Dave Airlie 已提交
2563 2564 2565 2566
		ret = -EINVAL;
		goto out;
	}

2567
	if (crtc_req->count_connectors > 0 && (!mode || !fb)) {
2568
		DRM_DEBUG_KMS("Count connectors is %d but no mode or fb set\n",
D
Dave Airlie 已提交
2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591
			  crtc_req->count_connectors);
		ret = -EINVAL;
		goto out;
	}

	if (crtc_req->count_connectors > 0) {
		u32 out_id;

		/* Avoid unbounded kernel memory allocation */
		if (crtc_req->count_connectors > config->num_connector) {
			ret = -EINVAL;
			goto out;
		}

		connector_set = kmalloc(crtc_req->count_connectors *
					sizeof(struct drm_connector *),
					GFP_KERNEL);
		if (!connector_set) {
			ret = -ENOMEM;
			goto out;
		}

		for (i = 0; i < crtc_req->count_connectors; i++) {
V
Ville Syrjälä 已提交
2592
			set_connectors_ptr = (uint32_t __user *)(unsigned long)crtc_req->set_connectors_ptr;
D
Dave Airlie 已提交
2593 2594 2595 2596 2597
			if (get_user(out_id, &set_connectors_ptr[i])) {
				ret = -EFAULT;
				goto out;
			}

R
Rob Clark 已提交
2598 2599
			connector = drm_connector_find(dev, out_id);
			if (!connector) {
2600 2601
				DRM_DEBUG_KMS("Connector id %d unknown\n",
						out_id);
2602
				ret = -ENOENT;
D
Dave Airlie 已提交
2603 2604
				goto out;
			}
2605 2606
			DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
					connector->base.id,
2607
					connector->name);
D
Dave Airlie 已提交
2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618

			connector_set[i] = connector;
		}
	}

	set.crtc = crtc;
	set.x = crtc_req->x;
	set.y = crtc_req->y;
	set.mode = mode;
	set.connectors = connector_set;
	set.num_connectors = crtc_req->count_connectors;
2619
	set.fb = fb;
2620
	ret = drm_mode_set_config_internal(&set);
D
Dave Airlie 已提交
2621 2622

out:
2623 2624 2625
	if (fb)
		drm_framebuffer_unreference(fb);

D
Dave Airlie 已提交
2626
	kfree(connector_set);
2627
	drm_mode_destroy(dev, mode);
2628
	drm_modeset_unlock_all(dev);
D
Dave Airlie 已提交
2629 2630 2631
	return ret;
}

2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714
/**
 * drm_mode_cursor_universal - translate legacy cursor ioctl call into a
 *     universal plane handler call
 * @crtc: crtc to update cursor for
 * @req: data pointer for the ioctl
 * @file_priv: drm file for the ioctl call
 *
 * Legacy cursor ioctl's work directly with driver buffer handles.  To
 * translate legacy ioctl calls into universal plane handler calls, we need to
 * wrap the native buffer handle in a drm_framebuffer.
 *
 * Note that we assume any handle passed to the legacy ioctls was a 32-bit ARGB
 * buffer with a pitch of 4*width; the universal plane interface should be used
 * directly in cases where the hardware can support other buffer settings and
 * userspace wants to make use of these capabilities.
 *
 * Returns:
 * Zero on success, errno on failure.
 */
static int drm_mode_cursor_universal(struct drm_crtc *crtc,
				     struct drm_mode_cursor2 *req,
				     struct drm_file *file_priv)
{
	struct drm_device *dev = crtc->dev;
	struct drm_framebuffer *fb = NULL;
	struct drm_mode_fb_cmd2 fbreq = {
		.width = req->width,
		.height = req->height,
		.pixel_format = DRM_FORMAT_ARGB8888,
		.pitches = { req->width * 4 },
		.handles = { req->handle },
	};
	int32_t crtc_x, crtc_y;
	uint32_t crtc_w = 0, crtc_h = 0;
	uint32_t src_w = 0, src_h = 0;
	int ret = 0;

	BUG_ON(!crtc->cursor);

	/*
	 * Obtain fb we'll be using (either new or existing) and take an extra
	 * reference to it if fb != null.  setplane will take care of dropping
	 * the reference if the plane update fails.
	 */
	if (req->flags & DRM_MODE_CURSOR_BO) {
		if (req->handle) {
			fb = add_framebuffer_internal(dev, &fbreq, file_priv);
			if (IS_ERR(fb)) {
				DRM_DEBUG_KMS("failed to wrap cursor buffer in drm framebuffer\n");
				return PTR_ERR(fb);
			}

			drm_framebuffer_reference(fb);
		} else {
			fb = NULL;
		}
	} else {
		mutex_lock(&dev->mode_config.mutex);
		fb = crtc->cursor->fb;
		if (fb)
			drm_framebuffer_reference(fb);
		mutex_unlock(&dev->mode_config.mutex);
	}

	if (req->flags & DRM_MODE_CURSOR_MOVE) {
		crtc_x = req->x;
		crtc_y = req->y;
	} else {
		crtc_x = crtc->cursor_x;
		crtc_y = crtc->cursor_y;
	}

	if (fb) {
		crtc_w = fb->width;
		crtc_h = fb->height;
		src_w = fb->width << 16;
		src_h = fb->height << 16;
	}

	/*
	 * setplane_internal will take care of deref'ing either the old or new
	 * framebuffer depending on success.
	 */
2715
	ret = setplane_internal(crtc->cursor, crtc, fb,
2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727
				crtc_x, crtc_y, crtc_w, crtc_h,
				0, 0, src_w, src_h);

	/* Update successful; save new cursor position, if necessary */
	if (ret == 0 && req->flags & DRM_MODE_CURSOR_MOVE) {
		crtc->cursor_x = req->x;
		crtc->cursor_y = req->y;
	}

	return ret;
}

2728 2729 2730
static int drm_mode_cursor_common(struct drm_device *dev,
				  struct drm_mode_cursor2 *req,
				  struct drm_file *file_priv)
D
Dave Airlie 已提交
2731 2732 2733 2734
{
	struct drm_crtc *crtc;
	int ret = 0;

2735 2736 2737
	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		return -EINVAL;

2738
	if (!req->flags || (~DRM_MODE_CURSOR_FLAGS & req->flags))
D
Dave Airlie 已提交
2739 2740
		return -EINVAL;

R
Rob Clark 已提交
2741 2742
	crtc = drm_crtc_find(dev, req->crtc_id);
	if (!crtc) {
2743
		DRM_DEBUG_KMS("Unknown CRTC ID %d\n", req->crtc_id);
2744
		return -ENOENT;
D
Dave Airlie 已提交
2745 2746
	}

2747 2748 2749 2750 2751 2752 2753
	/*
	 * If this crtc has a universal cursor plane, call that plane's update
	 * handler rather than using legacy cursor handlers.
	 */
	if (crtc->cursor)
		return drm_mode_cursor_universal(crtc, req, file_priv);

2754
	drm_modeset_lock(&crtc->mutex, NULL);
D
Dave Airlie 已提交
2755
	if (req->flags & DRM_MODE_CURSOR_BO) {
2756
		if (!crtc->funcs->cursor_set && !crtc->funcs->cursor_set2) {
D
Dave Airlie 已提交
2757 2758 2759 2760
			ret = -ENXIO;
			goto out;
		}
		/* Turns off the cursor if handle is 0 */
2761 2762 2763 2764 2765 2766
		if (crtc->funcs->cursor_set2)
			ret = crtc->funcs->cursor_set2(crtc, file_priv, req->handle,
						      req->width, req->height, req->hot_x, req->hot_y);
		else
			ret = crtc->funcs->cursor_set(crtc, file_priv, req->handle,
						      req->width, req->height);
D
Dave Airlie 已提交
2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777
	}

	if (req->flags & DRM_MODE_CURSOR_MOVE) {
		if (crtc->funcs->cursor_move) {
			ret = crtc->funcs->cursor_move(crtc, req->x, req->y);
		} else {
			ret = -EFAULT;
			goto out;
		}
	}
out:
2778
	drm_modeset_unlock(&crtc->mutex);
2779

D
Dave Airlie 已提交
2780
	return ret;
2781 2782

}
2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797


/**
 * drm_mode_cursor_ioctl - set CRTC's cursor configuration
 * @dev: drm device for the ioctl
 * @data: data pointer for the ioctl
 * @file_priv: drm file for the ioctl call
 *
 * Set the cursor configuration based on user request.
 *
 * Called by the user via ioctl.
 *
 * Returns:
 * Zero on success, errno on failure.
 */
2798
int drm_mode_cursor_ioctl(struct drm_device *dev,
2799
			  void *data, struct drm_file *file_priv)
2800 2801 2802 2803 2804 2805 2806 2807 2808 2809
{
	struct drm_mode_cursor *req = data;
	struct drm_mode_cursor2 new_req;

	memcpy(&new_req, req, sizeof(struct drm_mode_cursor));
	new_req.hot_x = new_req.hot_y = 0;

	return drm_mode_cursor_common(dev, &new_req, file_priv);
}

2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824
/**
 * drm_mode_cursor2_ioctl - set CRTC's cursor configuration
 * @dev: drm device for the ioctl
 * @data: data pointer for the ioctl
 * @file_priv: drm file for the ioctl call
 *
 * Set the cursor configuration based on user request. This implements the 2nd
 * version of the cursor ioctl, which allows userspace to additionally specify
 * the hotspot of the pointer.
 *
 * Called by the user via ioctl.
 *
 * Returns:
 * Zero on success, errno on failure.
 */
2825 2826 2827 2828 2829
int drm_mode_cursor2_ioctl(struct drm_device *dev,
			   void *data, struct drm_file *file_priv)
{
	struct drm_mode_cursor2 *req = data;
	return drm_mode_cursor_common(dev, req, file_priv);
D
Dave Airlie 已提交
2830 2831
}

2832 2833 2834 2835 2836 2837 2838 2839
/**
 * drm_mode_legacy_fb_format - compute drm fourcc code from legacy description
 * @bpp: bits per pixels
 * @depth: bit depth per pixel
 *
 * Computes a drm fourcc pixel format code for the given @bpp/@depth values.
 * Useful in fbdev emulation code, since that deals in those values.
 */
2840 2841 2842 2843 2844 2845
uint32_t drm_mode_legacy_fb_format(uint32_t bpp, uint32_t depth)
{
	uint32_t fmt;

	switch (bpp) {
	case 8:
2846
		fmt = DRM_FORMAT_C8;
2847 2848 2849
		break;
	case 16:
		if (depth == 15)
V
Ville Syrjälä 已提交
2850
			fmt = DRM_FORMAT_XRGB1555;
2851
		else
V
Ville Syrjälä 已提交
2852
			fmt = DRM_FORMAT_RGB565;
2853 2854
		break;
	case 24:
V
Ville Syrjälä 已提交
2855
		fmt = DRM_FORMAT_RGB888;
2856 2857 2858
		break;
	case 32:
		if (depth == 24)
V
Ville Syrjälä 已提交
2859
			fmt = DRM_FORMAT_XRGB8888;
2860
		else if (depth == 30)
V
Ville Syrjälä 已提交
2861
			fmt = DRM_FORMAT_XRGB2101010;
2862
		else
V
Ville Syrjälä 已提交
2863
			fmt = DRM_FORMAT_ARGB8888;
2864 2865
		break;
	default:
V
Ville Syrjälä 已提交
2866 2867
		DRM_ERROR("bad bpp, assuming x8r8g8b8 pixel format\n");
		fmt = DRM_FORMAT_XRGB8888;
2868 2869 2870 2871 2872 2873 2874
		break;
	}

	return fmt;
}
EXPORT_SYMBOL(drm_mode_legacy_fb_format);

D
Dave Airlie 已提交
2875 2876
/**
 * drm_mode_addfb - add an FB to the graphics configuration
2877 2878 2879
 * @dev: drm device for the ioctl
 * @data: data pointer for the ioctl
 * @file_priv: drm file for the ioctl call
D
Dave Airlie 已提交
2880
 *
2881 2882
 * Add a new FB to the specified CRTC, given a user request. This is the
 * original addfb ioclt which only supported RGB formats.
D
Dave Airlie 已提交
2883 2884 2885
 *
 * Called by the user via ioctl.
 *
2886
 * Returns:
D
Dave Airlie 已提交
2887 2888 2889 2890 2891
 * Zero on success, errno on failure.
 */
int drm_mode_addfb(struct drm_device *dev,
		   void *data, struct drm_file *file_priv)
{
2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908
	struct drm_mode_fb_cmd *or = data;
	struct drm_mode_fb_cmd2 r = {};
	struct drm_mode_config *config = &dev->mode_config;
	struct drm_framebuffer *fb;
	int ret = 0;

	/* Use new struct with format internally */
	r.fb_id = or->fb_id;
	r.width = or->width;
	r.height = or->height;
	r.pitches[0] = or->pitch;
	r.pixel_format = drm_mode_legacy_fb_format(or->bpp, or->depth);
	r.handles[0] = or->handle;

	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		return -EINVAL;

2909
	if ((config->min_width > r.width) || (r.width > config->max_width))
2910
		return -EINVAL;
2911 2912

	if ((config->min_height > r.height) || (r.height > config->max_height))
2913 2914 2915 2916
		return -EINVAL;

	fb = dev->mode_config.funcs->fb_create(dev, file_priv, &r);
	if (IS_ERR(fb)) {
2917
		DRM_DEBUG_KMS("could not create framebuffer\n");
2918
		return PTR_ERR(fb);
2919 2920
	}

2921
	mutex_lock(&file_priv->fbs_lock);
2922 2923 2924
	or->fb_id = fb->base.id;
	list_add(&fb->filp_head, &file_priv->fbs);
	DRM_DEBUG_KMS("[FB:%d]\n", fb->base.id);
2925 2926
	mutex_unlock(&file_priv->fbs_lock);

2927 2928 2929
	return ret;
}

2930
static int format_check(const struct drm_mode_fb_cmd2 *r)
2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982
{
	uint32_t format = r->pixel_format & ~DRM_FORMAT_BIG_ENDIAN;

	switch (format) {
	case DRM_FORMAT_C8:
	case DRM_FORMAT_RGB332:
	case DRM_FORMAT_BGR233:
	case DRM_FORMAT_XRGB4444:
	case DRM_FORMAT_XBGR4444:
	case DRM_FORMAT_RGBX4444:
	case DRM_FORMAT_BGRX4444:
	case DRM_FORMAT_ARGB4444:
	case DRM_FORMAT_ABGR4444:
	case DRM_FORMAT_RGBA4444:
	case DRM_FORMAT_BGRA4444:
	case DRM_FORMAT_XRGB1555:
	case DRM_FORMAT_XBGR1555:
	case DRM_FORMAT_RGBX5551:
	case DRM_FORMAT_BGRX5551:
	case DRM_FORMAT_ARGB1555:
	case DRM_FORMAT_ABGR1555:
	case DRM_FORMAT_RGBA5551:
	case DRM_FORMAT_BGRA5551:
	case DRM_FORMAT_RGB565:
	case DRM_FORMAT_BGR565:
	case DRM_FORMAT_RGB888:
	case DRM_FORMAT_BGR888:
	case DRM_FORMAT_XRGB8888:
	case DRM_FORMAT_XBGR8888:
	case DRM_FORMAT_RGBX8888:
	case DRM_FORMAT_BGRX8888:
	case DRM_FORMAT_ARGB8888:
	case DRM_FORMAT_ABGR8888:
	case DRM_FORMAT_RGBA8888:
	case DRM_FORMAT_BGRA8888:
	case DRM_FORMAT_XRGB2101010:
	case DRM_FORMAT_XBGR2101010:
	case DRM_FORMAT_RGBX1010102:
	case DRM_FORMAT_BGRX1010102:
	case DRM_FORMAT_ARGB2101010:
	case DRM_FORMAT_ABGR2101010:
	case DRM_FORMAT_RGBA1010102:
	case DRM_FORMAT_BGRA1010102:
	case DRM_FORMAT_YUYV:
	case DRM_FORMAT_YVYU:
	case DRM_FORMAT_UYVY:
	case DRM_FORMAT_VYUY:
	case DRM_FORMAT_AYUV:
	case DRM_FORMAT_NV12:
	case DRM_FORMAT_NV21:
	case DRM_FORMAT_NV16:
	case DRM_FORMAT_NV61:
2983 2984
	case DRM_FORMAT_NV24:
	case DRM_FORMAT_NV42:
2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996
	case DRM_FORMAT_YUV410:
	case DRM_FORMAT_YVU410:
	case DRM_FORMAT_YUV411:
	case DRM_FORMAT_YVU411:
	case DRM_FORMAT_YUV420:
	case DRM_FORMAT_YVU420:
	case DRM_FORMAT_YUV422:
	case DRM_FORMAT_YVU422:
	case DRM_FORMAT_YUV444:
	case DRM_FORMAT_YVU444:
		return 0;
	default:
2997 2998
		DRM_DEBUG_KMS("invalid pixel format %s\n",
			      drm_get_format_name(r->pixel_format));
2999 3000 3001 3002
		return -EINVAL;
	}
}

3003
static int framebuffer_check(const struct drm_mode_fb_cmd2 *r)
3004 3005 3006 3007 3008
{
	int ret, hsub, vsub, num_planes, i;

	ret = format_check(r);
	if (ret) {
3009 3010
		DRM_DEBUG_KMS("bad framebuffer format %s\n",
			      drm_get_format_name(r->pixel_format));
3011 3012 3013 3014 3015 3016 3017 3018
		return ret;
	}

	hsub = drm_format_horz_chroma_subsampling(r->pixel_format);
	vsub = drm_format_vert_chroma_subsampling(r->pixel_format);
	num_planes = drm_format_num_planes(r->pixel_format);

	if (r->width == 0 || r->width % hsub) {
3019
		DRM_DEBUG_KMS("bad framebuffer width %u\n", r->height);
3020 3021 3022 3023
		return -EINVAL;
	}

	if (r->height == 0 || r->height % vsub) {
3024
		DRM_DEBUG_KMS("bad framebuffer height %u\n", r->height);
3025 3026 3027 3028 3029
		return -EINVAL;
	}

	for (i = 0; i < num_planes; i++) {
		unsigned int width = r->width / (i != 0 ? hsub : 1);
3030 3031
		unsigned int height = r->height / (i != 0 ? vsub : 1);
		unsigned int cpp = drm_format_plane_cpp(r->pixel_format, i);
3032 3033

		if (!r->handles[i]) {
3034
			DRM_DEBUG_KMS("no buffer object handle for plane %d\n", i);
3035 3036 3037
			return -EINVAL;
		}

3038 3039 3040 3041 3042 3043 3044
		if ((uint64_t) width * cpp > UINT_MAX)
			return -ERANGE;

		if ((uint64_t) height * r->pitches[i] + r->offsets[i] > UINT_MAX)
			return -ERANGE;

		if (r->pitches[i] < width * cpp) {
3045
			DRM_DEBUG_KMS("bad pitch %u for plane %d\n", r->pitches[i], i);
3046 3047 3048 3049 3050 3051 3052
			return -EINVAL;
		}
	}

	return 0;
}

3053 3054 3055
static struct drm_framebuffer *add_framebuffer_internal(struct drm_device *dev,
							struct drm_mode_fb_cmd2 *r,
							struct drm_file *file_priv)
3056
{
D
Dave Airlie 已提交
3057 3058
	struct drm_mode_config *config = &dev->mode_config;
	struct drm_framebuffer *fb;
3059
	int ret;
D
Dave Airlie 已提交
3060

3061 3062
	if (r->flags & ~DRM_MODE_FB_INTERLACED) {
		DRM_DEBUG_KMS("bad framebuffer flags 0x%08x\n", r->flags);
3063
		return ERR_PTR(-EINVAL);
3064 3065
	}

D
Dave Airlie 已提交
3066
	if ((config->min_width > r->width) || (r->width > config->max_width)) {
3067
		DRM_DEBUG_KMS("bad framebuffer width %d, should be >= %d && <= %d\n",
J
Jesse Barnes 已提交
3068
			  r->width, config->min_width, config->max_width);
3069
		return ERR_PTR(-EINVAL);
D
Dave Airlie 已提交
3070 3071
	}
	if ((config->min_height > r->height) || (r->height > config->max_height)) {
3072
		DRM_DEBUG_KMS("bad framebuffer height %d, should be >= %d && <= %d\n",
J
Jesse Barnes 已提交
3073
			  r->height, config->min_height, config->max_height);
3074
		return ERR_PTR(-EINVAL);
D
Dave Airlie 已提交
3075 3076
	}

3077 3078
	ret = framebuffer_check(r);
	if (ret)
3079
		return ERR_PTR(ret);
3080

D
Dave Airlie 已提交
3081
	fb = dev->mode_config.funcs->fb_create(dev, file_priv, r);
3082
	if (IS_ERR(fb)) {
3083
		DRM_DEBUG_KMS("could not create framebuffer\n");
3084
		return fb;
D
Dave Airlie 已提交
3085 3086
	}

3087
	mutex_lock(&file_priv->fbs_lock);
3088
	r->fb_id = fb->base.id;
D
Dave Airlie 已提交
3089
	list_add(&fb->filp_head, &file_priv->fbs);
3090
	DRM_DEBUG_KMS("[FB:%d]\n", fb->base.id);
3091
	mutex_unlock(&file_priv->fbs_lock);
D
Dave Airlie 已提交
3092

3093 3094
	return fb;
}
3095

3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123
/**
 * drm_mode_addfb2 - add an FB to the graphics configuration
 * @dev: drm device for the ioctl
 * @data: data pointer for the ioctl
 * @file_priv: drm file for the ioctl call
 *
 * Add a new FB to the specified CRTC, given a user request with format. This is
 * the 2nd version of the addfb ioctl, which supports multi-planar framebuffers
 * and uses fourcc codes as pixel format specifiers.
 *
 * Called by the user via ioctl.
 *
 * Returns:
 * Zero on success, errno on failure.
 */
int drm_mode_addfb2(struct drm_device *dev,
		    void *data, struct drm_file *file_priv)
{
	struct drm_framebuffer *fb;

	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		return -EINVAL;

	fb = add_framebuffer_internal(dev, data, file_priv);
	if (IS_ERR(fb))
		return PTR_ERR(fb);

	return 0;
D
Dave Airlie 已提交
3124 3125 3126 3127
}

/**
 * drm_mode_rmfb - remove an FB from the configuration
3128 3129 3130
 * @dev: drm device for the ioctl
 * @data: data pointer for the ioctl
 * @file_priv: drm file for the ioctl call
D
Dave Airlie 已提交
3131 3132 3133 3134 3135
 *
 * Remove the FB specified by the user.
 *
 * Called by the user via ioctl.
 *
3136
 * Returns:
D
Dave Airlie 已提交
3137 3138 3139 3140 3141 3142 3143 3144 3145 3146
 * Zero on success, errno on failure.
 */
int drm_mode_rmfb(struct drm_device *dev,
		   void *data, struct drm_file *file_priv)
{
	struct drm_framebuffer *fb = NULL;
	struct drm_framebuffer *fbl = NULL;
	uint32_t *id = data;
	int found = 0;

3147 3148 3149
	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		return -EINVAL;

3150
	mutex_lock(&file_priv->fbs_lock);
3151 3152 3153 3154 3155
	mutex_lock(&dev->mode_config.fb_lock);
	fb = __drm_framebuffer_lookup(dev, *id);
	if (!fb)
		goto fail_lookup;

D
Dave Airlie 已提交
3156 3157 3158
	list_for_each_entry(fbl, &file_priv->fbs, filp_head)
		if (fb == fbl)
			found = 1;
3159 3160 3161 3162 3163
	if (!found)
		goto fail_lookup;

	/* Mark fb as reaped, we still have a ref from fpriv->fbs. */
	__drm_framebuffer_unregister(dev, fb);
D
Dave Airlie 已提交
3164

3165
	list_del_init(&fb->filp_head);
3166
	mutex_unlock(&dev->mode_config.fb_lock);
3167
	mutex_unlock(&file_priv->fbs_lock);
D
Dave Airlie 已提交
3168

3169 3170
	drm_framebuffer_remove(fb);

3171 3172 3173 3174 3175 3176
	return 0;

fail_lookup:
	mutex_unlock(&dev->mode_config.fb_lock);
	mutex_unlock(&file_priv->fbs_lock);

3177
	return -ENOENT;
D
Dave Airlie 已提交
3178 3179 3180 3181
}

/**
 * drm_mode_getfb - get FB info
3182 3183 3184
 * @dev: drm device for the ioctl
 * @data: data pointer for the ioctl
 * @file_priv: drm file for the ioctl call
D
Dave Airlie 已提交
3185 3186 3187 3188 3189
 *
 * Lookup the FB given its ID and return info about it.
 *
 * Called by the user via ioctl.
 *
3190
 * Returns:
D
Dave Airlie 已提交
3191 3192 3193 3194 3195 3196 3197
 * Zero on success, errno on failure.
 */
int drm_mode_getfb(struct drm_device *dev,
		   void *data, struct drm_file *file_priv)
{
	struct drm_mode_fb_cmd *r = data;
	struct drm_framebuffer *fb;
3198
	int ret;
D
Dave Airlie 已提交
3199

3200 3201 3202
	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		return -EINVAL;

3203
	fb = drm_framebuffer_lookup(dev, r->fb_id);
3204
	if (!fb)
3205
		return -ENOENT;
D
Dave Airlie 已提交
3206 3207 3208 3209 3210

	r->height = fb->height;
	r->width = fb->width;
	r->depth = fb->depth;
	r->bpp = fb->bits_per_pixel;
3211
	r->pitch = fb->pitches[0];
3212
	if (fb->funcs->create_handle) {
3213
		if (file_priv->is_master || capable(CAP_SYS_ADMIN) ||
3214
		    drm_is_control_client(file_priv)) {
3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226
			ret = fb->funcs->create_handle(fb, file_priv,
						       &r->handle);
		} else {
			/* GET_FB() is an unprivileged ioctl so we must not
			 * return a buffer-handle to non-master processes! For
			 * backwards-compatibility reasons, we cannot make
			 * GET_FB() privileged, so just return an invalid handle
			 * for non-masters. */
			r->handle = 0;
			ret = 0;
		}
	} else {
3227
		ret = -ENODEV;
3228
	}
D
Dave Airlie 已提交
3229

3230 3231
	drm_framebuffer_unreference(fb);

D
Dave Airlie 已提交
3232 3233 3234
	return ret;
}

3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253
/**
 * drm_mode_dirtyfb_ioctl - flush frontbuffer rendering on an FB
 * @dev: drm device for the ioctl
 * @data: data pointer for the ioctl
 * @file_priv: drm file for the ioctl call
 *
 * Lookup the FB and flush out the damaged area supplied by userspace as a clip
 * rectangle list. Generic userspace which does frontbuffer rendering must call
 * this ioctl to flush out the changes on manual-update display outputs, e.g.
 * usb display-link, mipi manual update panels or edp panel self refresh modes.
 *
 * Modesetting drivers which always update the frontbuffer do not need to
 * implement the corresponding ->dirty framebuffer callback.
 *
 * Called by the user via ioctl.
 *
 * Returns:
 * Zero on success, errno on failure.
 */
3254 3255 3256 3257 3258 3259 3260 3261 3262
int drm_mode_dirtyfb_ioctl(struct drm_device *dev,
			   void *data, struct drm_file *file_priv)
{
	struct drm_clip_rect __user *clips_ptr;
	struct drm_clip_rect *clips = NULL;
	struct drm_mode_fb_dirty_cmd *r = data;
	struct drm_framebuffer *fb;
	unsigned flags;
	int num_clips;
3263
	int ret;
3264

3265 3266 3267
	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		return -EINVAL;

3268
	fb = drm_framebuffer_lookup(dev, r->fb_id);
3269
	if (!fb)
3270
		return -ENOENT;
3271 3272

	num_clips = r->num_clips;
V
Ville Syrjälä 已提交
3273
	clips_ptr = (struct drm_clip_rect __user *)(unsigned long)r->clips_ptr;
3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288

	if (!num_clips != !clips_ptr) {
		ret = -EINVAL;
		goto out_err1;
	}

	flags = DRM_MODE_FB_DIRTY_FLAGS & r->flags;

	/* If userspace annotates copy, clips must come in pairs */
	if (flags & DRM_MODE_FB_DIRTY_ANNOTATE_COPY && (num_clips % 2)) {
		ret = -EINVAL;
		goto out_err1;
	}

	if (num_clips && clips_ptr) {
3289 3290 3291 3292
		if (num_clips < 0 || num_clips > DRM_MODE_FB_DIRTY_MAX_CLIPS) {
			ret = -EINVAL;
			goto out_err1;
		}
3293 3294 3295 3296 3297 3298 3299 3300
		clips = kzalloc(num_clips * sizeof(*clips), GFP_KERNEL);
		if (!clips) {
			ret = -ENOMEM;
			goto out_err1;
		}

		ret = copy_from_user(clips, clips_ptr,
				     num_clips * sizeof(*clips));
3301 3302
		if (ret) {
			ret = -EFAULT;
3303
			goto out_err2;
3304
		}
3305 3306 3307
	}

	if (fb->funcs->dirty) {
3308 3309
		ret = fb->funcs->dirty(fb, file_priv, flags, r->color,
				       clips, num_clips);
3310 3311 3312 3313 3314 3315 3316
	} else {
		ret = -ENOSYS;
	}

out_err2:
	kfree(clips);
out_err1:
3317 3318
	drm_framebuffer_unreference(fb);

3319 3320 3321 3322
	return ret;
}


D
Dave Airlie 已提交
3323 3324
/**
 * drm_fb_release - remove and free the FBs on this file
3325
 * @priv: drm file for the ioctl
D
Dave Airlie 已提交
3326 3327 3328 3329 3330
 *
 * Destroy all the FBs associated with @filp.
 *
 * Called by the user via ioctl.
 *
3331
 * Returns:
D
Dave Airlie 已提交
3332 3333
 * Zero on success, errno on failure.
 */
3334
void drm_fb_release(struct drm_file *priv)
D
Dave Airlie 已提交
3335 3336 3337 3338
{
	struct drm_device *dev = priv->minor->dev;
	struct drm_framebuffer *fb, *tfb;

3339
	mutex_lock(&priv->fbs_lock);
D
Dave Airlie 已提交
3340
	list_for_each_entry_safe(fb, tfb, &priv->fbs, filp_head) {
3341 3342 3343 3344 3345 3346

		mutex_lock(&dev->mode_config.fb_lock);
		/* Mark fb as reaped, we still have a ref from fpriv->fbs. */
		__drm_framebuffer_unregister(dev, fb);
		mutex_unlock(&dev->mode_config.fb_lock);

3347
		list_del_init(&fb->filp_head);
3348 3349

		/* This will also drop the fpriv->fbs reference. */
R
Rob Clark 已提交
3350
		drm_framebuffer_remove(fb);
D
Dave Airlie 已提交
3351
	}
3352
	mutex_unlock(&priv->fbs_lock);
D
Dave Airlie 已提交
3353 3354
}

3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368
/**
 * drm_property_create - create a new property type
 * @dev: drm device
 * @flags: flags specifying the property type
 * @name: name of the property
 * @num_values: number of pre-defined values
 *
 * This creates a new generic drm property which can then be attached to a drm
 * object with drm_object_attach_property. The returned property object must be
 * freed with drm_property_destroy.
 *
 * Returns:
 * A pointer to the newly created property on success, NULL on failure.
 */
D
Dave Airlie 已提交
3369 3370 3371 3372
struct drm_property *drm_property_create(struct drm_device *dev, int flags,
					 const char *name, int num_values)
{
	struct drm_property *property = NULL;
3373
	int ret;
D
Dave Airlie 已提交
3374 3375 3376 3377 3378

	property = kzalloc(sizeof(struct drm_property), GFP_KERNEL);
	if (!property)
		return NULL;

R
Rob Clark 已提交
3379 3380
	property->dev = dev;

D
Dave Airlie 已提交
3381 3382 3383 3384 3385 3386
	if (num_values) {
		property->values = kzalloc(sizeof(uint64_t)*num_values, GFP_KERNEL);
		if (!property->values)
			goto fail;
	}

3387 3388 3389 3390
	ret = drm_mode_object_get(dev, &property->base, DRM_MODE_OBJECT_PROPERTY);
	if (ret)
		goto fail;

D
Dave Airlie 已提交
3391 3392 3393 3394
	property->flags = flags;
	property->num_values = num_values;
	INIT_LIST_HEAD(&property->enum_blob_list);

3395
	if (name) {
D
Dave Airlie 已提交
3396
		strncpy(property->name, name, DRM_PROP_NAME_LEN);
3397 3398
		property->name[DRM_PROP_NAME_LEN-1] = '\0';
	}
D
Dave Airlie 已提交
3399 3400

	list_add_tail(&property->head, &dev->mode_config.property_list);
R
Rob Clark 已提交
3401 3402 3403

	WARN_ON(!drm_property_type_valid(property));

D
Dave Airlie 已提交
3404 3405
	return property;
fail:
3406
	kfree(property->values);
D
Dave Airlie 已提交
3407 3408 3409 3410 3411
	kfree(property);
	return NULL;
}
EXPORT_SYMBOL(drm_property_create);

3412
/**
3413
 * drm_property_create_enum - create a new enumeration property type
3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429
 * @dev: drm device
 * @flags: flags specifying the property type
 * @name: name of the property
 * @props: enumeration lists with property values
 * @num_values: number of pre-defined values
 *
 * This creates a new generic drm property which can then be attached to a drm
 * object with drm_object_attach_property. The returned property object must be
 * freed with drm_property_destroy.
 *
 * Userspace is only allowed to set one of the predefined values for enumeration
 * properties.
 *
 * Returns:
 * A pointer to the newly created property on success, NULL on failure.
 */
3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457
struct drm_property *drm_property_create_enum(struct drm_device *dev, int flags,
					 const char *name,
					 const struct drm_prop_enum_list *props,
					 int num_values)
{
	struct drm_property *property;
	int i, ret;

	flags |= DRM_MODE_PROP_ENUM;

	property = drm_property_create(dev, flags, name, num_values);
	if (!property)
		return NULL;

	for (i = 0; i < num_values; i++) {
		ret = drm_property_add_enum(property, i,
				      props[i].type,
				      props[i].name);
		if (ret) {
			drm_property_destroy(dev, property);
			return NULL;
		}
	}

	return property;
}
EXPORT_SYMBOL(drm_property_create_enum);

3458
/**
3459
 * drm_property_create_bitmask - create a new bitmask property type
3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475
 * @dev: drm device
 * @flags: flags specifying the property type
 * @name: name of the property
 * @props: enumeration lists with property bitflags
 * @num_values: number of pre-defined values
 *
 * This creates a new generic drm property which can then be attached to a drm
 * object with drm_object_attach_property. The returned property object must be
 * freed with drm_property_destroy.
 *
 * Compared to plain enumeration properties userspace is allowed to set any
 * or'ed together combination of the predefined property bitflag values
 *
 * Returns:
 * A pointer to the newly created property on success, NULL on failure.
 */
R
Rob Clark 已提交
3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503
struct drm_property *drm_property_create_bitmask(struct drm_device *dev,
					 int flags, const char *name,
					 const struct drm_prop_enum_list *props,
					 int num_values)
{
	struct drm_property *property;
	int i, ret;

	flags |= DRM_MODE_PROP_BITMASK;

	property = drm_property_create(dev, flags, name, num_values);
	if (!property)
		return NULL;

	for (i = 0; i < num_values; i++) {
		ret = drm_property_add_enum(property, i,
				      props[i].type,
				      props[i].name);
		if (ret) {
			drm_property_destroy(dev, property);
			return NULL;
		}
	}

	return property;
}
EXPORT_SYMBOL(drm_property_create_bitmask);

R
Rob Clark 已提交
3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519
static struct drm_property *property_create_range(struct drm_device *dev,
					 int flags, const char *name,
					 uint64_t min, uint64_t max)
{
	struct drm_property *property;

	property = drm_property_create(dev, flags, name, 2);
	if (!property)
		return NULL;

	property->values[0] = min;
	property->values[1] = max;

	return property;
}

3520
/**
3521
 * drm_property_create_range - create a new ranged property type
3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537
 * @dev: drm device
 * @flags: flags specifying the property type
 * @name: name of the property
 * @min: minimum value of the property
 * @max: maximum value of the property
 *
 * This creates a new generic drm property which can then be attached to a drm
 * object with drm_object_attach_property. The returned property object must be
 * freed with drm_property_destroy.
 *
 * Userspace is allowed to set any interger value in the (min, max) range
 * inclusive.
 *
 * Returns:
 * A pointer to the newly created property on success, NULL on failure.
 */
3538 3539 3540 3541
struct drm_property *drm_property_create_range(struct drm_device *dev, int flags,
					 const char *name,
					 uint64_t min, uint64_t max)
{
R
Rob Clark 已提交
3542 3543
	return property_create_range(dev, DRM_MODE_PROP_RANGE | flags,
			name, min, max);
3544 3545 3546
}
EXPORT_SYMBOL(drm_property_create_range);

R
Rob Clark 已提交
3547 3548 3549 3550 3551 3552 3553 3554 3555
struct drm_property *drm_property_create_signed_range(struct drm_device *dev,
					 int flags, const char *name,
					 int64_t min, int64_t max)
{
	return property_create_range(dev, DRM_MODE_PROP_SIGNED_RANGE | flags,
			name, I642U64(min), I642U64(max));
}
EXPORT_SYMBOL(drm_property_create_signed_range);

R
Rob Clark 已提交
3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572
struct drm_property *drm_property_create_object(struct drm_device *dev,
					 int flags, const char *name, uint32_t type)
{
	struct drm_property *property;

	flags |= DRM_MODE_PROP_OBJECT;

	property = drm_property_create(dev, flags, name, 1);
	if (!property)
		return NULL;

	property->values[0] = type;

	return property;
}
EXPORT_SYMBOL(drm_property_create_object);

3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587
/**
 * drm_property_add_enum - add a possible value to an enumeration property
 * @property: enumeration property to change
 * @index: index of the new enumeration
 * @value: value of the new enumeration
 * @name: symbolic name of the new enumeration
 *
 * This functions adds enumerations to a property.
 *
 * It's use is deprecated, drivers should use one of the more specific helpers
 * to directly create the property with all enumerations already attached.
 *
 * Returns:
 * Zero on success, error code on failure.
 */
D
Dave Airlie 已提交
3588 3589 3590 3591 3592
int drm_property_add_enum(struct drm_property *property, int index,
			  uint64_t value, const char *name)
{
	struct drm_property_enum *prop_enum;

R
Rob Clark 已提交
3593 3594
	if (!(drm_property_type_is(property, DRM_MODE_PROP_ENUM) ||
			drm_property_type_is(property, DRM_MODE_PROP_BITMASK)))
R
Rob Clark 已提交
3595 3596 3597 3598 3599 3600
		return -EINVAL;

	/*
	 * Bitmask enum properties have the additional constraint of values
	 * from 0 to 63
	 */
R
Rob Clark 已提交
3601 3602
	if (drm_property_type_is(property, DRM_MODE_PROP_BITMASK) &&
			(value > 63))
D
Dave Airlie 已提交
3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628
		return -EINVAL;

	if (!list_empty(&property->enum_blob_list)) {
		list_for_each_entry(prop_enum, &property->enum_blob_list, head) {
			if (prop_enum->value == value) {
				strncpy(prop_enum->name, name, DRM_PROP_NAME_LEN);
				prop_enum->name[DRM_PROP_NAME_LEN-1] = '\0';
				return 0;
			}
		}
	}

	prop_enum = kzalloc(sizeof(struct drm_property_enum), GFP_KERNEL);
	if (!prop_enum)
		return -ENOMEM;

	strncpy(prop_enum->name, name, DRM_PROP_NAME_LEN);
	prop_enum->name[DRM_PROP_NAME_LEN-1] = '\0';
	prop_enum->value = value;

	property->values[index] = value;
	list_add_tail(&prop_enum->head, &property->enum_blob_list);
	return 0;
}
EXPORT_SYMBOL(drm_property_add_enum);

3629 3630 3631 3632 3633 3634 3635 3636
/**
 * drm_property_destroy - destroy a drm property
 * @dev: drm device
 * @property: property to destry
 *
 * This function frees a property including any attached resources like
 * enumeration values.
 */
D
Dave Airlie 已提交
3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653
void drm_property_destroy(struct drm_device *dev, struct drm_property *property)
{
	struct drm_property_enum *prop_enum, *pt;

	list_for_each_entry_safe(prop_enum, pt, &property->enum_blob_list, head) {
		list_del(&prop_enum->head);
		kfree(prop_enum);
	}

	if (property->num_values)
		kfree(property->values);
	drm_mode_object_put(dev, &property->base);
	list_del(&property->head);
	kfree(property);
}
EXPORT_SYMBOL(drm_property_destroy);

3654 3655 3656 3657 3658 3659 3660 3661 3662 3663
/**
 * drm_object_attach_property - attach a property to a modeset object
 * @obj: drm modeset object
 * @property: property to attach
 * @init_val: initial value of the property
 *
 * This attaches the given property to the modeset object with the given initial
 * value. Currently this function cannot fail since the properties are stored in
 * a statically sized array.
 */
3664 3665 3666 3667
void drm_object_attach_property(struct drm_mode_object *obj,
				struct drm_property *property,
				uint64_t init_val)
{
3668
	int count = obj->properties->count;
3669

3670 3671 3672 3673 3674 3675
	if (count == DRM_OBJECT_MAX_PROPERTY) {
		WARN(1, "Failed to attach object property (type: 0x%x). Please "
			"increase DRM_OBJECT_MAX_PROPERTY by 1 for each time "
			"you see this message on the same object type.\n",
			obj->type);
		return;
3676 3677
	}

3678 3679 3680
	obj->properties->ids[count] = property->base.id;
	obj->properties->values[count] = init_val;
	obj->properties->count++;
3681 3682 3683
}
EXPORT_SYMBOL(drm_object_attach_property);

3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696
/**
 * drm_object_property_set_value - set the value of a property
 * @obj: drm mode object to set property value for
 * @property: property to set
 * @val: value the property should be set to
 *
 * This functions sets a given property on a given object. This function only
 * changes the software state of the property, it does not call into the
 * driver's ->set_property callback.
 *
 * Returns:
 * Zero on success, error code on failure.
 */
3697 3698 3699 3700 3701
int drm_object_property_set_value(struct drm_mode_object *obj,
				  struct drm_property *property, uint64_t val)
{
	int i;

3702
	for (i = 0; i < obj->properties->count; i++) {
3703 3704 3705 3706 3707 3708 3709 3710 3711 3712
		if (obj->properties->ids[i] == property->base.id) {
			obj->properties->values[i] = val;
			return 0;
		}
	}

	return -EINVAL;
}
EXPORT_SYMBOL(drm_object_property_set_value);

3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726
/**
 * drm_object_property_get_value - retrieve the value of a property
 * @obj: drm mode object to get property value from
 * @property: property to retrieve
 * @val: storage for the property value
 *
 * This function retrieves the softare state of the given property for the given
 * property. Since there is no driver callback to retrieve the current property
 * value this might be out of sync with the hardware, depending upon the driver
 * and property.
 *
 * Returns:
 * Zero on success, error code on failure.
 */
3727 3728 3729 3730 3731
int drm_object_property_get_value(struct drm_mode_object *obj,
				  struct drm_property *property, uint64_t *val)
{
	int i;

3732
	for (i = 0; i < obj->properties->count; i++) {
3733 3734 3735 3736 3737 3738 3739 3740 3741 3742
		if (obj->properties->ids[i] == property->base.id) {
			*val = obj->properties->values[i];
			return 0;
		}
	}

	return -EINVAL;
}
EXPORT_SYMBOL(drm_object_property_get_value);

3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755
/**
 * drm_mode_getproperty_ioctl - get the current value of a connector's property
 * @dev: DRM device
 * @data: ioctl data
 * @file_priv: DRM file info
 *
 * This function retrieves the current value for an connectors's property.
 *
 * Called by the user via ioctl.
 *
 * Returns:
 * Zero on success, errno on failure.
 */
D
Dave Airlie 已提交
3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768
int drm_mode_getproperty_ioctl(struct drm_device *dev,
			       void *data, struct drm_file *file_priv)
{
	struct drm_mode_get_property *out_resp = data;
	struct drm_property *property;
	int enum_count = 0;
	int blob_count = 0;
	int value_count = 0;
	int ret = 0, i;
	int copied;
	struct drm_property_enum *prop_enum;
	struct drm_mode_property_enum __user *enum_ptr;
	struct drm_property_blob *prop_blob;
V
Ville Syrjälä 已提交
3769
	uint32_t __user *blob_id_ptr;
D
Dave Airlie 已提交
3770 3771 3772
	uint64_t __user *values_ptr;
	uint32_t __user *blob_length_ptr;

3773 3774 3775
	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		return -EINVAL;

3776
	drm_modeset_lock_all(dev);
R
Rob Clark 已提交
3777 3778
	property = drm_property_find(dev, out_resp->prop_id);
	if (!property) {
3779
		ret = -ENOENT;
D
Dave Airlie 已提交
3780 3781 3782
		goto done;
	}

R
Rob Clark 已提交
3783 3784
	if (drm_property_type_is(property, DRM_MODE_PROP_ENUM) ||
			drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
D
Dave Airlie 已提交
3785 3786
		list_for_each_entry(prop_enum, &property->enum_blob_list, head)
			enum_count++;
R
Rob Clark 已提交
3787
	} else if (drm_property_type_is(property, DRM_MODE_PROP_BLOB)) {
D
Dave Airlie 已提交
3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798
		list_for_each_entry(prop_blob, &property->enum_blob_list, head)
			blob_count++;
	}

	value_count = property->num_values;

	strncpy(out_resp->name, property->name, DRM_PROP_NAME_LEN);
	out_resp->name[DRM_PROP_NAME_LEN-1] = 0;
	out_resp->flags = property->flags;

	if ((out_resp->count_values >= value_count) && value_count) {
V
Ville Syrjälä 已提交
3799
		values_ptr = (uint64_t __user *)(unsigned long)out_resp->values_ptr;
D
Dave Airlie 已提交
3800 3801 3802 3803 3804 3805 3806 3807 3808
		for (i = 0; i < value_count; i++) {
			if (copy_to_user(values_ptr + i, &property->values[i], sizeof(uint64_t))) {
				ret = -EFAULT;
				goto done;
			}
		}
	}
	out_resp->count_values = value_count;

R
Rob Clark 已提交
3809 3810
	if (drm_property_type_is(property, DRM_MODE_PROP_ENUM) ||
			drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
D
Dave Airlie 已提交
3811 3812
		if ((out_resp->count_enum_blobs >= enum_count) && enum_count) {
			copied = 0;
V
Ville Syrjälä 已提交
3813
			enum_ptr = (struct drm_mode_property_enum __user *)(unsigned long)out_resp->enum_blob_ptr;
D
Dave Airlie 已提交
3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831
			list_for_each_entry(prop_enum, &property->enum_blob_list, head) {

				if (copy_to_user(&enum_ptr[copied].value, &prop_enum->value, sizeof(uint64_t))) {
					ret = -EFAULT;
					goto done;
				}

				if (copy_to_user(&enum_ptr[copied].name,
						 &prop_enum->name, DRM_PROP_NAME_LEN)) {
					ret = -EFAULT;
					goto done;
				}
				copied++;
			}
		}
		out_resp->count_enum_blobs = enum_count;
	}

R
Rob Clark 已提交
3832
	if (drm_property_type_is(property, DRM_MODE_PROP_BLOB)) {
D
Dave Airlie 已提交
3833 3834
		if ((out_resp->count_enum_blobs >= blob_count) && blob_count) {
			copied = 0;
V
Ville Syrjälä 已提交
3835 3836
			blob_id_ptr = (uint32_t __user *)(unsigned long)out_resp->enum_blob_ptr;
			blob_length_ptr = (uint32_t __user *)(unsigned long)out_resp->values_ptr;
D
Dave Airlie 已提交
3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854

			list_for_each_entry(prop_blob, &property->enum_blob_list, head) {
				if (put_user(prop_blob->base.id, blob_id_ptr + copied)) {
					ret = -EFAULT;
					goto done;
				}

				if (put_user(prop_blob->length, blob_length_ptr + copied)) {
					ret = -EFAULT;
					goto done;
				}

				copied++;
			}
		}
		out_resp->count_enum_blobs = blob_count;
	}
done:
3855
	drm_modeset_unlock_all(dev);
D
Dave Airlie 已提交
3856 3857 3858 3859 3860 3861 3862
	return ret;
}

static struct drm_property_blob *drm_property_create_blob(struct drm_device *dev, int length,
							  void *data)
{
	struct drm_property_blob *blob;
3863
	int ret;
D
Dave Airlie 已提交
3864 3865 3866 3867 3868 3869 3870 3871

	if (!length || !data)
		return NULL;

	blob = kzalloc(sizeof(struct drm_property_blob)+length, GFP_KERNEL);
	if (!blob)
		return NULL;

3872 3873 3874 3875 3876 3877
	ret = drm_mode_object_get(dev, &blob->base, DRM_MODE_OBJECT_BLOB);
	if (ret) {
		kfree(blob);
		return NULL;
	}

D
Dave Airlie 已提交
3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893
	blob->length = length;

	memcpy(blob->data, data, length);

	list_add_tail(&blob->head, &dev->mode_config.property_blob_list);
	return blob;
}

static void drm_property_destroy_blob(struct drm_device *dev,
			       struct drm_property_blob *blob)
{
	drm_mode_object_put(dev, &blob->base);
	list_del(&blob->head);
	kfree(blob);
}

3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907
/**
 * drm_mode_getblob_ioctl - get the contents of a blob property value
 * @dev: DRM device
 * @data: ioctl data
 * @file_priv: DRM file info
 *
 * This function retrieves the contents of a blob property. The value stored in
 * an object's blob property is just a normal modeset object id.
 *
 * Called by the user via ioctl.
 *
 * Returns:
 * Zero on success, errno on failure.
 */
D
Dave Airlie 已提交
3908 3909 3910 3911 3912 3913
int drm_mode_getblob_ioctl(struct drm_device *dev,
			   void *data, struct drm_file *file_priv)
{
	struct drm_mode_get_blob *out_resp = data;
	struct drm_property_blob *blob;
	int ret = 0;
V
Ville Syrjälä 已提交
3914
	void __user *blob_ptr;
D
Dave Airlie 已提交
3915

3916 3917 3918
	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		return -EINVAL;

3919
	drm_modeset_lock_all(dev);
R
Rob Clark 已提交
3920 3921
	blob = drm_property_blob_find(dev, out_resp->blob_id);
	if (!blob) {
3922
		ret = -ENOENT;
D
Dave Airlie 已提交
3923 3924 3925 3926
		goto done;
	}

	if (out_resp->length == blob->length) {
V
Ville Syrjälä 已提交
3927
		blob_ptr = (void __user *)(unsigned long)out_resp->data;
D
Dave Airlie 已提交
3928 3929 3930 3931 3932 3933 3934 3935
		if (copy_to_user(blob_ptr, blob->data, blob->length)){
			ret = -EFAULT;
			goto done;
		}
	}
	out_resp->length = blob->length;

done:
3936
	drm_modeset_unlock_all(dev);
D
Dave Airlie 已提交
3937 3938 3939
	return ret;
}

D
Dave Airlie 已提交
3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958
int drm_mode_connector_set_path_property(struct drm_connector *connector,
					 char *path)
{
	struct drm_device *dev = connector->dev;
	int ret, size;
	size = strlen(path) + 1;

	connector->path_blob_ptr = drm_property_create_blob(connector->dev,
							    size, path);
	if (!connector->path_blob_ptr)
		return -EINVAL;

	ret = drm_object_property_set_value(&connector->base,
					    dev->mode_config.path_property,
					    connector->path_blob_ptr->base.id);
	return ret;
}
EXPORT_SYMBOL(drm_mode_connector_set_path_property);

3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969
/**
 * drm_mode_connector_update_edid_property - update the edid property of a connector
 * @connector: drm connector
 * @edid: new value of the edid property
 *
 * This function creates a new blob modeset object and assigns its id to the
 * connector's edid property.
 *
 * Returns:
 * Zero on success, errno on failure.
 */
D
Dave Airlie 已提交
3970 3971 3972 3973
int drm_mode_connector_update_edid_property(struct drm_connector *connector,
					    struct edid *edid)
{
	struct drm_device *dev = connector->dev;
3974
	int ret, size;
D
Dave Airlie 已提交
3975

3976 3977 3978 3979
	/* ignore requests to set edid when overridden */
	if (connector->override_edid)
		return 0;

D
Dave Airlie 已提交
3980 3981 3982 3983 3984 3985
	if (connector->edid_blob_ptr)
		drm_property_destroy_blob(dev, connector->edid_blob_ptr);

	/* Delete edid, when there is none. */
	if (!edid) {
		connector->edid_blob_ptr = NULL;
3986
		ret = drm_object_property_set_value(&connector->base, dev->mode_config.edid_property, 0);
D
Dave Airlie 已提交
3987 3988 3989
		return ret;
	}

3990 3991 3992
	size = EDID_LENGTH * (1 + edid->extensions);
	connector->edid_blob_ptr = drm_property_create_blob(connector->dev,
							    size, edid);
3993 3994
	if (!connector->edid_blob_ptr)
		return -EINVAL;
D
Dave Airlie 已提交
3995

3996
	ret = drm_object_property_set_value(&connector->base,
D
Dave Airlie 已提交
3997 3998 3999 4000 4001 4002 4003
					       dev->mode_config.edid_property,
					       connector->edid_blob_ptr->base.id);

	return ret;
}
EXPORT_SYMBOL(drm_mode_connector_update_edid_property);

4004
static bool drm_property_change_is_valid(struct drm_property *property,
4005
					 uint64_t value)
4006 4007 4008
{
	if (property->flags & DRM_MODE_PROP_IMMUTABLE)
		return false;
R
Rob Clark 已提交
4009 4010

	if (drm_property_type_is(property, DRM_MODE_PROP_RANGE)) {
4011 4012 4013
		if (value < property->values[0] || value > property->values[1])
			return false;
		return true;
R
Rob Clark 已提交
4014 4015 4016 4017 4018 4019
	} else if (drm_property_type_is(property, DRM_MODE_PROP_SIGNED_RANGE)) {
		int64_t svalue = U642I64(value);
		if (svalue < U642I64(property->values[0]) ||
				svalue > U642I64(property->values[1]))
			return false;
		return true;
R
Rob Clark 已提交
4020
	} else if (drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
R
Rob Clark 已提交
4021
		int i;
4022
		uint64_t valid_mask = 0;
R
Rob Clark 已提交
4023 4024 4025
		for (i = 0; i < property->num_values; i++)
			valid_mask |= (1ULL << property->values[i]);
		return !(value & ~valid_mask);
R
Rob Clark 已提交
4026
	} else if (drm_property_type_is(property, DRM_MODE_PROP_BLOB)) {
4027 4028
		/* Only the driver knows */
		return true;
R
Rob Clark 已提交
4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042
	} else if (drm_property_type_is(property, DRM_MODE_PROP_OBJECT)) {
		struct drm_mode_object *obj;
		/* a zero value for an object property translates to null: */
		if (value == 0)
			return true;
		/*
		 * NOTE: use _object_find() directly to bypass restriction on
		 * looking up refcnt'd objects (ie. fb's).  For a refcnt'd
		 * object this could race against object finalization, so it
		 * simply tells us that the object *was* valid.  Which is good
		 * enough.
		 */
		obj = _object_find(property->dev, value, property->values[0]);
		return obj != NULL;
4043 4044 4045 4046 4047 4048 4049 4050 4051
	} else {
		int i;
		for (i = 0; i < property->num_values; i++)
			if (property->values[i] == value)
				return true;
		return false;
	}
}

4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065
/**
 * drm_mode_connector_property_set_ioctl - set the current value of a connector property
 * @dev: DRM device
 * @data: ioctl data
 * @file_priv: DRM file info
 *
 * This function sets the current value for a connectors's property. It also
 * calls into a driver's ->set_property callback to update the hardware state
 *
 * Called by the user via ioctl.
 *
 * Returns:
 * Zero on success, errno on failure.
 */
D
Dave Airlie 已提交
4066 4067 4068
int drm_mode_connector_property_set_ioctl(struct drm_device *dev,
				       void *data, struct drm_file *file_priv)
{
4069 4070 4071 4072 4073 4074 4075
	struct drm_mode_connector_set_property *conn_set_prop = data;
	struct drm_mode_obj_set_property obj_set_prop = {
		.value = conn_set_prop->value,
		.prop_id = conn_set_prop->prop_id,
		.obj_id = conn_set_prop->connector_id,
		.obj_type = DRM_MODE_OBJECT_CONNECTOR
	};
4076

4077 4078
	/* It does all the locking and checking we need */
	return drm_mode_obj_set_property_ioctl(dev, &obj_set_prop, file_priv);
D
Dave Airlie 已提交
4079 4080
}

4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097
static int drm_mode_connector_set_obj_prop(struct drm_mode_object *obj,
					   struct drm_property *property,
					   uint64_t value)
{
	int ret = -EINVAL;
	struct drm_connector *connector = obj_to_connector(obj);

	/* Do DPMS ourselves */
	if (property == connector->dev->mode_config.dpms_property) {
		if (connector->funcs->dpms)
			(*connector->funcs->dpms)(connector, (int)value);
		ret = 0;
	} else if (connector->funcs->set_property)
		ret = connector->funcs->set_property(connector, property, value);

	/* store the property value if successful */
	if (!ret)
4098
		drm_object_property_set_value(&connector->base, property, value);
4099 4100 4101
	return ret;
}

P
Paulo Zanoni 已提交
4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116
static int drm_mode_crtc_set_obj_prop(struct drm_mode_object *obj,
				      struct drm_property *property,
				      uint64_t value)
{
	int ret = -EINVAL;
	struct drm_crtc *crtc = obj_to_crtc(obj);

	if (crtc->funcs->set_property)
		ret = crtc->funcs->set_property(crtc, property, value);
	if (!ret)
		drm_object_property_set_value(obj, property, value);

	return ret;
}

R
Rob Clark 已提交
4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131
static int drm_mode_plane_set_obj_prop(struct drm_mode_object *obj,
				      struct drm_property *property,
				      uint64_t value)
{
	int ret = -EINVAL;
	struct drm_plane *plane = obj_to_plane(obj);

	if (plane->funcs->set_property)
		ret = plane->funcs->set_property(plane, property, value);
	if (!ret)
		drm_object_property_set_value(obj, property, value);

	return ret;
}

4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146
/**
 * drm_mode_getproperty_ioctl - get the current value of a object's property
 * @dev: DRM device
 * @data: ioctl data
 * @file_priv: DRM file info
 *
 * This function retrieves the current value for an object's property. Compared
 * to the connector specific ioctl this one is extended to also work on crtc and
 * plane objects.
 *
 * Called by the user via ioctl.
 *
 * Returns:
 * Zero on success, errno on failure.
 */
4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161
int drm_mode_obj_get_properties_ioctl(struct drm_device *dev, void *data,
				      struct drm_file *file_priv)
{
	struct drm_mode_obj_get_properties *arg = data;
	struct drm_mode_object *obj;
	int ret = 0;
	int i;
	int copied = 0;
	int props_count = 0;
	uint32_t __user *props_ptr;
	uint64_t __user *prop_values_ptr;

	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		return -EINVAL;

4162
	drm_modeset_lock_all(dev);
4163 4164 4165

	obj = drm_mode_object_find(dev, arg->obj_id, arg->obj_type);
	if (!obj) {
4166
		ret = -ENOENT;
4167 4168 4169 4170 4171 4172 4173
		goto out;
	}
	if (!obj->properties) {
		ret = -EINVAL;
		goto out;
	}

4174
	props_count = obj->properties->count;
4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198

	/* This ioctl is called twice, once to determine how much space is
	 * needed, and the 2nd time to fill it. */
	if ((arg->count_props >= props_count) && props_count) {
		copied = 0;
		props_ptr = (uint32_t __user *)(unsigned long)(arg->props_ptr);
		prop_values_ptr = (uint64_t __user *)(unsigned long)
				  (arg->prop_values_ptr);
		for (i = 0; i < props_count; i++) {
			if (put_user(obj->properties->ids[i],
				     props_ptr + copied)) {
				ret = -EFAULT;
				goto out;
			}
			if (put_user(obj->properties->values[i],
				     prop_values_ptr + copied)) {
				ret = -EFAULT;
				goto out;
			}
			copied++;
		}
	}
	arg->count_props = props_count;
out:
4199
	drm_modeset_unlock_all(dev);
4200 4201 4202
	return ret;
}

4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218
/**
 * drm_mode_obj_set_property_ioctl - set the current value of an object's property
 * @dev: DRM device
 * @data: ioctl data
 * @file_priv: DRM file info
 *
 * This function sets the current value for an object's property. It also calls
 * into a driver's ->set_property callback to update the hardware state.
 * Compared to the connector specific ioctl this one is extended to also work on
 * crtc and plane objects.
 *
 * Called by the user via ioctl.
 *
 * Returns:
 * Zero on success, errno on failure.
 */
4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231
int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data,
				    struct drm_file *file_priv)
{
	struct drm_mode_obj_set_property *arg = data;
	struct drm_mode_object *arg_obj;
	struct drm_mode_object *prop_obj;
	struct drm_property *property;
	int ret = -EINVAL;
	int i;

	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		return -EINVAL;

4232
	drm_modeset_lock_all(dev);
4233 4234

	arg_obj = drm_mode_object_find(dev, arg->obj_id, arg->obj_type);
4235 4236
	if (!arg_obj) {
		ret = -ENOENT;
4237
		goto out;
4238
	}
4239 4240 4241
	if (!arg_obj->properties)
		goto out;

4242
	for (i = 0; i < arg_obj->properties->count; i++)
4243 4244 4245
		if (arg_obj->properties->ids[i] == arg->prop_id)
			break;

4246
	if (i == arg_obj->properties->count)
4247 4248 4249 4250
		goto out;

	prop_obj = drm_mode_object_find(dev, arg->prop_id,
					DRM_MODE_OBJECT_PROPERTY);
4251 4252
	if (!prop_obj) {
		ret = -ENOENT;
4253
		goto out;
4254
	}
4255 4256 4257 4258 4259 4260 4261 4262 4263 4264
	property = obj_to_property(prop_obj);

	if (!drm_property_change_is_valid(property, arg->value))
		goto out;

	switch (arg_obj->type) {
	case DRM_MODE_OBJECT_CONNECTOR:
		ret = drm_mode_connector_set_obj_prop(arg_obj, property,
						      arg->value);
		break;
P
Paulo Zanoni 已提交
4265 4266 4267
	case DRM_MODE_OBJECT_CRTC:
		ret = drm_mode_crtc_set_obj_prop(arg_obj, property, arg->value);
		break;
R
Rob Clark 已提交
4268 4269 4270
	case DRM_MODE_OBJECT_PLANE:
		ret = drm_mode_plane_set_obj_prop(arg_obj, property, arg->value);
		break;
4271 4272 4273
	}

out:
4274
	drm_modeset_unlock_all(dev);
4275 4276 4277
	return ret;
}

4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289
/**
 * drm_mode_connector_attach_encoder - attach a connector to an encoder
 * @connector: connector to attach
 * @encoder: encoder to attach @connector to
 *
 * This function links up a connector to an encoder. Note that the routing
 * restrictions between encoders and crtcs are exposed to userspace through the
 * possible_clones and possible_crtcs bitmasks.
 *
 * Returns:
 * Zero on success, errno on failure.
 */
D
Dave Airlie 已提交
4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304
int drm_mode_connector_attach_encoder(struct drm_connector *connector,
				      struct drm_encoder *encoder)
{
	int i;

	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
		if (connector->encoder_ids[i] == 0) {
			connector->encoder_ids[i] = encoder->base.id;
			return 0;
		}
	}
	return -ENOMEM;
}
EXPORT_SYMBOL(drm_mode_connector_attach_encoder);

4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316
/**
 * drm_mode_crtc_set_gamma_size - set the gamma table size
 * @crtc: CRTC to set the gamma table size for
 * @gamma_size: size of the gamma table
 *
 * Drivers which support gamma tables should set this to the supported gamma
 * table size when initializing the CRTC. Currently the drm core only supports a
 * fixed gamma table size.
 *
 * Returns:
 * Zero on success, errno on failure.
 */
4317
int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
4318
				 int gamma_size)
D
Dave Airlie 已提交
4319 4320 4321 4322 4323 4324
{
	crtc->gamma_size = gamma_size;

	crtc->gamma_store = kzalloc(gamma_size * sizeof(uint16_t) * 3, GFP_KERNEL);
	if (!crtc->gamma_store) {
		crtc->gamma_size = 0;
4325
		return -ENOMEM;
D
Dave Airlie 已提交
4326 4327
	}

4328
	return 0;
D
Dave Airlie 已提交
4329 4330 4331
}
EXPORT_SYMBOL(drm_mode_crtc_set_gamma_size);

4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345
/**
 * drm_mode_gamma_set_ioctl - set the gamma table
 * @dev: DRM device
 * @data: ioctl data
 * @file_priv: DRM file info
 *
 * Set the gamma table of a CRTC to the one passed in by the user. Userspace can
 * inquire the required gamma table size through drm_mode_gamma_get_ioctl.
 *
 * Called by the user via ioctl.
 *
 * Returns:
 * Zero on success, errno on failure.
 */
D
Dave Airlie 已提交
4346 4347 4348 4349 4350 4351 4352 4353 4354
int drm_mode_gamma_set_ioctl(struct drm_device *dev,
			     void *data, struct drm_file *file_priv)
{
	struct drm_mode_crtc_lut *crtc_lut = data;
	struct drm_crtc *crtc;
	void *r_base, *g_base, *b_base;
	int size;
	int ret = 0;

4355 4356 4357
	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		return -EINVAL;

4358
	drm_modeset_lock_all(dev);
R
Rob Clark 已提交
4359 4360
	crtc = drm_crtc_find(dev, crtc_lut->crtc_id);
	if (!crtc) {
4361
		ret = -ENOENT;
D
Dave Airlie 已提交
4362 4363 4364
		goto out;
	}

4365 4366 4367 4368 4369
	if (crtc->funcs->gamma_set == NULL) {
		ret = -ENOSYS;
		goto out;
	}

D
Dave Airlie 已提交
4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394
	/* memcpy into gamma store */
	if (crtc_lut->gamma_size != crtc->gamma_size) {
		ret = -EINVAL;
		goto out;
	}

	size = crtc_lut->gamma_size * (sizeof(uint16_t));
	r_base = crtc->gamma_store;
	if (copy_from_user(r_base, (void __user *)(unsigned long)crtc_lut->red, size)) {
		ret = -EFAULT;
		goto out;
	}

	g_base = r_base + size;
	if (copy_from_user(g_base, (void __user *)(unsigned long)crtc_lut->green, size)) {
		ret = -EFAULT;
		goto out;
	}

	b_base = g_base + size;
	if (copy_from_user(b_base, (void __user *)(unsigned long)crtc_lut->blue, size)) {
		ret = -EFAULT;
		goto out;
	}

J
James Simmons 已提交
4395
	crtc->funcs->gamma_set(crtc, r_base, g_base, b_base, 0, crtc->gamma_size);
D
Dave Airlie 已提交
4396 4397

out:
4398
	drm_modeset_unlock_all(dev);
D
Dave Airlie 已提交
4399 4400 4401 4402
	return ret;

}

4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417
/**
 * drm_mode_gamma_get_ioctl - get the gamma table
 * @dev: DRM device
 * @data: ioctl data
 * @file_priv: DRM file info
 *
 * Copy the current gamma table into the storage provided. This also provides
 * the gamma table size the driver expects, which can be used to size the
 * allocated storage.
 *
 * Called by the user via ioctl.
 *
 * Returns:
 * Zero on success, errno on failure.
 */
D
Dave Airlie 已提交
4418 4419 4420 4421 4422 4423 4424 4425 4426
int drm_mode_gamma_get_ioctl(struct drm_device *dev,
			     void *data, struct drm_file *file_priv)
{
	struct drm_mode_crtc_lut *crtc_lut = data;
	struct drm_crtc *crtc;
	void *r_base, *g_base, *b_base;
	int size;
	int ret = 0;

4427 4428 4429
	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		return -EINVAL;

4430
	drm_modeset_lock_all(dev);
R
Rob Clark 已提交
4431 4432
	crtc = drm_crtc_find(dev, crtc_lut->crtc_id);
	if (!crtc) {
4433
		ret = -ENOENT;
D
Dave Airlie 已提交
4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461
		goto out;
	}

	/* memcpy into gamma store */
	if (crtc_lut->gamma_size != crtc->gamma_size) {
		ret = -EINVAL;
		goto out;
	}

	size = crtc_lut->gamma_size * (sizeof(uint16_t));
	r_base = crtc->gamma_store;
	if (copy_to_user((void __user *)(unsigned long)crtc_lut->red, r_base, size)) {
		ret = -EFAULT;
		goto out;
	}

	g_base = r_base + size;
	if (copy_to_user((void __user *)(unsigned long)crtc_lut->green, g_base, size)) {
		ret = -EFAULT;
		goto out;
	}

	b_base = g_base + size;
	if (copy_to_user((void __user *)(unsigned long)crtc_lut->blue, b_base, size)) {
		ret = -EFAULT;
		goto out;
	}
out:
4462
	drm_modeset_unlock_all(dev);
D
Dave Airlie 已提交
4463 4464
	return ret;
}
4465

4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483
/**
 * drm_mode_page_flip_ioctl - schedule an asynchronous fb update
 * @dev: DRM device
 * @data: ioctl data
 * @file_priv: DRM file info
 *
 * This schedules an asynchronous update on a given CRTC, called page flip.
 * Optionally a drm event is generated to signal the completion of the event.
 * Generic drivers cannot assume that a pageflip with changed framebuffer
 * properties (including driver specific metadata like tiling layout) will work,
 * but some drivers support e.g. pixel format changes through the pageflip
 * ioctl.
 *
 * Called by the user via ioctl.
 *
 * Returns:
 * Zero on success, errno on failure.
 */
4484 4485 4486 4487 4488
int drm_mode_page_flip_ioctl(struct drm_device *dev,
			     void *data, struct drm_file *file_priv)
{
	struct drm_mode_crtc_page_flip *page_flip = data;
	struct drm_crtc *crtc;
4489
	struct drm_framebuffer *fb = NULL, *old_fb = NULL;
4490 4491 4492 4493 4494 4495 4496 4497
	struct drm_pending_vblank_event *e = NULL;
	unsigned long flags;
	int ret = -EINVAL;

	if (page_flip->flags & ~DRM_MODE_PAGE_FLIP_FLAGS ||
	    page_flip->reserved != 0)
		return -EINVAL;

4498 4499 4500
	if ((page_flip->flags & DRM_MODE_PAGE_FLIP_ASYNC) && !dev->mode_config.async_page_flip)
		return -EINVAL;

R
Rob Clark 已提交
4501 4502
	crtc = drm_crtc_find(dev, page_flip->crtc_id);
	if (!crtc)
4503
		return -ENOENT;
4504

4505
	drm_modeset_lock(&crtc->mutex, NULL);
4506
	if (crtc->primary->fb == NULL) {
4507 4508 4509 4510 4511 4512 4513 4514
		/* The framebuffer is currently unbound, presumably
		 * due to a hotplug event, that userspace has not
		 * yet discovered.
		 */
		ret = -EBUSY;
		goto out;
	}

4515 4516 4517
	if (crtc->funcs->page_flip == NULL)
		goto out;

4518
	fb = drm_framebuffer_lookup(dev, page_flip->fb_id);
4519 4520
	if (!fb) {
		ret = -ENOENT;
4521
		goto out;
4522
	}
4523

4524 4525
	ret = drm_crtc_check_viewport(crtc, crtc->x, crtc->y, &crtc->mode, fb);
	if (ret)
4526 4527
		goto out;

4528
	if (crtc->primary->fb->pixel_format != fb->pixel_format) {
4529 4530 4531 4532 4533
		DRM_DEBUG_KMS("Page flip is not allowed to change frame buffer format.\n");
		ret = -EINVAL;
		goto out;
	}

4534 4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551
	if (page_flip->flags & DRM_MODE_PAGE_FLIP_EVENT) {
		ret = -ENOMEM;
		spin_lock_irqsave(&dev->event_lock, flags);
		if (file_priv->event_space < sizeof e->event) {
			spin_unlock_irqrestore(&dev->event_lock, flags);
			goto out;
		}
		file_priv->event_space -= sizeof e->event;
		spin_unlock_irqrestore(&dev->event_lock, flags);

		e = kzalloc(sizeof *e, GFP_KERNEL);
		if (e == NULL) {
			spin_lock_irqsave(&dev->event_lock, flags);
			file_priv->event_space += sizeof e->event;
			spin_unlock_irqrestore(&dev->event_lock, flags);
			goto out;
		}

4552
		e->event.base.type = DRM_EVENT_FLIP_COMPLETE;
4553 4554 4555 4556 4557 4558 4559 4560
		e->event.base.length = sizeof e->event;
		e->event.user_data = page_flip->user_data;
		e->base.event = &e->event.base;
		e->base.file_priv = file_priv;
		e->base.destroy =
			(void (*) (struct drm_pending_event *)) kfree;
	}

4561
	old_fb = crtc->primary->fb;
4562
	ret = crtc->funcs->page_flip(crtc, fb, e, page_flip->flags);
4563
	if (ret) {
4564 4565 4566 4567 4568 4569
		if (page_flip->flags & DRM_MODE_PAGE_FLIP_EVENT) {
			spin_lock_irqsave(&dev->event_lock, flags);
			file_priv->event_space += sizeof e->event;
			spin_unlock_irqrestore(&dev->event_lock, flags);
			kfree(e);
		}
4570 4571 4572
		/* Keep the old fb, don't unref it. */
		old_fb = NULL;
	} else {
4573 4574 4575 4576 4577 4578
		/*
		 * Warn if the driver hasn't properly updated the crtc->fb
		 * field to reflect that the new framebuffer is now used.
		 * Failing to do so will screw with the reference counting
		 * on framebuffers.
		 */
4579
		WARN_ON(crtc->primary->fb != fb);
4580 4581
		/* Unref only the old framebuffer. */
		fb = NULL;
4582 4583 4584
	}

out:
4585 4586 4587 4588
	if (fb)
		drm_framebuffer_unreference(fb);
	if (old_fb)
		drm_framebuffer_unreference(old_fb);
4589
	drm_modeset_unlock(&crtc->mutex);
4590

4591 4592
	return ret;
}
4593

4594 4595 4596 4597 4598 4599 4600 4601
/**
 * drm_mode_config_reset - call ->reset callbacks
 * @dev: drm device
 *
 * This functions calls all the crtc's, encoder's and connector's ->reset
 * callback. Drivers can use this in e.g. their driver load or resume code to
 * reset hardware and software state.
 */
4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615
void drm_mode_config_reset(struct drm_device *dev)
{
	struct drm_crtc *crtc;
	struct drm_encoder *encoder;
	struct drm_connector *connector;

	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head)
		if (crtc->funcs->reset)
			crtc->funcs->reset(crtc);

	list_for_each_entry(encoder, &dev->mode_config.encoder_list, head)
		if (encoder->funcs->reset)
			encoder->funcs->reset(encoder);

4616 4617 4618
	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
		connector->status = connector_status_unknown;

4619 4620
		if (connector->funcs->reset)
			connector->funcs->reset(connector);
4621
	}
4622 4623
}
EXPORT_SYMBOL(drm_mode_config_reset);
4624

4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643
/**
 * drm_mode_create_dumb_ioctl - create a dumb backing storage buffer
 * @dev: DRM device
 * @data: ioctl data
 * @file_priv: DRM file info
 *
 * This creates a new dumb buffer in the driver's backing storage manager (GEM,
 * TTM or something else entirely) and returns the resulting buffer handle. This
 * handle can then be wrapped up into a framebuffer modeset object.
 *
 * Note that userspace is not allowed to use such objects for render
 * acceleration - drivers must create their own private ioctls for such a use
 * case.
 *
 * Called by the user via ioctl.
 *
 * Returns:
 * Zero on success, errno on failure.
 */
4644 4645 4646 4647
int drm_mode_create_dumb_ioctl(struct drm_device *dev,
			       void *data, struct drm_file *file_priv)
{
	struct drm_mode_create_dumb *args = data;
4648
	u32 cpp, stride, size;
4649 4650 4651

	if (!dev->driver->dumb_create)
		return -ENOSYS;
4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667
	if (!args->width || !args->height || !args->bpp)
		return -EINVAL;

	/* overflow checks for 32bit size calculations */
	cpp = DIV_ROUND_UP(args->bpp, 8);
	if (cpp > 0xffffffffU / args->width)
		return -EINVAL;
	stride = cpp * args->width;
	if (args->height > 0xffffffffU / stride)
		return -EINVAL;

	/* test for wrap-around */
	size = args->height * stride;
	if (PAGE_ALIGN(size) == 0)
		return -EINVAL;

4668 4669 4670
	return dev->driver->dumb_create(file_priv, dev, args);
}

4671 4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684
/**
 * drm_mode_mmap_dumb_ioctl - create an mmap offset for a dumb backing storage buffer
 * @dev: DRM device
 * @data: ioctl data
 * @file_priv: DRM file info
 *
 * Allocate an offset in the drm device node's address space to be able to
 * memory map a dumb buffer.
 *
 * Called by the user via ioctl.
 *
 * Returns:
 * Zero on success, errno on failure.
 */
4685 4686 4687 4688 4689 4690 4691 4692 4693 4694 4695 4696
int drm_mode_mmap_dumb_ioctl(struct drm_device *dev,
			     void *data, struct drm_file *file_priv)
{
	struct drm_mode_map_dumb *args = data;

	/* call driver ioctl to get mmap offset */
	if (!dev->driver->dumb_map_offset)
		return -ENOSYS;

	return dev->driver->dumb_map_offset(file_priv, dev, args->handle, &args->offset);
}

4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711
/**
 * drm_mode_destroy_dumb_ioctl - destroy a dumb backing strage buffer
 * @dev: DRM device
 * @data: ioctl data
 * @file_priv: DRM file info
 *
 * This destroys the userspace handle for the given dumb backing storage buffer.
 * Since buffer objects must be reference counted in the kernel a buffer object
 * won't be immediately freed if a framebuffer modeset object still uses it.
 *
 * Called by the user via ioctl.
 *
 * Returns:
 * Zero on success, errno on failure.
 */
4712 4713 4714 4715 4716 4717 4718 4719 4720 4721
int drm_mode_destroy_dumb_ioctl(struct drm_device *dev,
				void *data, struct drm_file *file_priv)
{
	struct drm_mode_destroy_dumb *args = data;

	if (!dev->driver->dumb_destroy)
		return -ENOSYS;

	return dev->driver->dumb_destroy(file_priv, dev, args->handle);
}
4722

4723 4724 4725 4726 4727 4728 4729 4730
/**
 * drm_fb_get_bpp_depth - get the bpp/depth values for format
 * @format: pixel format (DRM_FORMAT_*)
 * @depth: storage for the depth value
 * @bpp: storage for the bpp value
 *
 * This only supports RGB formats here for compat with code that doesn't use
 * pixel formats directly yet.
4731 4732 4733 4734 4735
 */
void drm_fb_get_bpp_depth(uint32_t format, unsigned int *depth,
			  int *bpp)
{
	switch (format) {
4736
	case DRM_FORMAT_C8:
V
Ville Syrjälä 已提交
4737 4738
	case DRM_FORMAT_RGB332:
	case DRM_FORMAT_BGR233:
4739 4740 4741
		*depth = 8;
		*bpp = 8;
		break;
V
Ville Syrjälä 已提交
4742 4743 4744 4745 4746 4747 4748 4749
	case DRM_FORMAT_XRGB1555:
	case DRM_FORMAT_XBGR1555:
	case DRM_FORMAT_RGBX5551:
	case DRM_FORMAT_BGRX5551:
	case DRM_FORMAT_ARGB1555:
	case DRM_FORMAT_ABGR1555:
	case DRM_FORMAT_RGBA5551:
	case DRM_FORMAT_BGRA5551:
4750 4751 4752
		*depth = 15;
		*bpp = 16;
		break;
V
Ville Syrjälä 已提交
4753 4754
	case DRM_FORMAT_RGB565:
	case DRM_FORMAT_BGR565:
4755 4756 4757
		*depth = 16;
		*bpp = 16;
		break;
V
Ville Syrjälä 已提交
4758 4759 4760 4761 4762 4763 4764 4765 4766
	case DRM_FORMAT_RGB888:
	case DRM_FORMAT_BGR888:
		*depth = 24;
		*bpp = 24;
		break;
	case DRM_FORMAT_XRGB8888:
	case DRM_FORMAT_XBGR8888:
	case DRM_FORMAT_RGBX8888:
	case DRM_FORMAT_BGRX8888:
4767 4768 4769
		*depth = 24;
		*bpp = 32;
		break;
V
Ville Syrjälä 已提交
4770 4771 4772 4773 4774 4775 4776 4777
	case DRM_FORMAT_XRGB2101010:
	case DRM_FORMAT_XBGR2101010:
	case DRM_FORMAT_RGBX1010102:
	case DRM_FORMAT_BGRX1010102:
	case DRM_FORMAT_ARGB2101010:
	case DRM_FORMAT_ABGR2101010:
	case DRM_FORMAT_RGBA1010102:
	case DRM_FORMAT_BGRA1010102:
4778 4779 4780
		*depth = 30;
		*bpp = 32;
		break;
V
Ville Syrjälä 已提交
4781 4782 4783 4784
	case DRM_FORMAT_ARGB8888:
	case DRM_FORMAT_ABGR8888:
	case DRM_FORMAT_RGBA8888:
	case DRM_FORMAT_BGRA8888:
4785 4786 4787 4788
		*depth = 32;
		*bpp = 32;
		break;
	default:
4789 4790
		DRM_DEBUG_KMS("unsupported pixel format %s\n",
			      drm_get_format_name(format));
4791 4792 4793 4794 4795 4796
		*depth = 0;
		*bpp = 0;
		break;
	}
}
EXPORT_SYMBOL(drm_fb_get_bpp_depth);
4797 4798 4799 4800 4801

/**
 * drm_format_num_planes - get the number of planes for format
 * @format: pixel format (DRM_FORMAT_*)
 *
4802
 * Returns:
4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816 4817 4818 4819 4820 4821 4822
 * The number of planes used by the specified pixel format.
 */
int drm_format_num_planes(uint32_t format)
{
	switch (format) {
	case DRM_FORMAT_YUV410:
	case DRM_FORMAT_YVU410:
	case DRM_FORMAT_YUV411:
	case DRM_FORMAT_YVU411:
	case DRM_FORMAT_YUV420:
	case DRM_FORMAT_YVU420:
	case DRM_FORMAT_YUV422:
	case DRM_FORMAT_YVU422:
	case DRM_FORMAT_YUV444:
	case DRM_FORMAT_YVU444:
		return 3;
	case DRM_FORMAT_NV12:
	case DRM_FORMAT_NV21:
	case DRM_FORMAT_NV16:
	case DRM_FORMAT_NV61:
4823 4824
	case DRM_FORMAT_NV24:
	case DRM_FORMAT_NV42:
4825 4826 4827 4828 4829 4830
		return 2;
	default:
		return 1;
	}
}
EXPORT_SYMBOL(drm_format_num_planes);
4831 4832 4833 4834 4835 4836

/**
 * drm_format_plane_cpp - determine the bytes per pixel value
 * @format: pixel format (DRM_FORMAT_*)
 * @plane: plane index
 *
4837
 * Returns:
4838 4839 4840 4841 4842 4843 4844 4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857
 * The bytes per pixel value for the specified plane.
 */
int drm_format_plane_cpp(uint32_t format, int plane)
{
	unsigned int depth;
	int bpp;

	if (plane >= drm_format_num_planes(format))
		return 0;

	switch (format) {
	case DRM_FORMAT_YUYV:
	case DRM_FORMAT_YVYU:
	case DRM_FORMAT_UYVY:
	case DRM_FORMAT_VYUY:
		return 2;
	case DRM_FORMAT_NV12:
	case DRM_FORMAT_NV21:
	case DRM_FORMAT_NV16:
	case DRM_FORMAT_NV61:
4858 4859
	case DRM_FORMAT_NV24:
	case DRM_FORMAT_NV42:
4860 4861 4862 4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873 4874 4875 4876 4877
		return plane ? 2 : 1;
	case DRM_FORMAT_YUV410:
	case DRM_FORMAT_YVU410:
	case DRM_FORMAT_YUV411:
	case DRM_FORMAT_YVU411:
	case DRM_FORMAT_YUV420:
	case DRM_FORMAT_YVU420:
	case DRM_FORMAT_YUV422:
	case DRM_FORMAT_YVU422:
	case DRM_FORMAT_YUV444:
	case DRM_FORMAT_YVU444:
		return 1;
	default:
		drm_fb_get_bpp_depth(format, &depth, &bpp);
		return bpp >> 3;
	}
}
EXPORT_SYMBOL(drm_format_plane_cpp);
4878 4879 4880 4881 4882

/**
 * drm_format_horz_chroma_subsampling - get the horizontal chroma subsampling factor
 * @format: pixel format (DRM_FORMAT_*)
 *
4883
 * Returns:
4884 4885 4886 4887 4888 4889 4890 4891 4892 4893 4894 4895 4896 4897 4898 4899 4900 4901 4902 4903 4904 4905 4906 4907 4908 4909 4910 4911 4912 4913 4914 4915 4916 4917
 * The horizontal chroma subsampling factor for the
 * specified pixel format.
 */
int drm_format_horz_chroma_subsampling(uint32_t format)
{
	switch (format) {
	case DRM_FORMAT_YUV411:
	case DRM_FORMAT_YVU411:
	case DRM_FORMAT_YUV410:
	case DRM_FORMAT_YVU410:
		return 4;
	case DRM_FORMAT_YUYV:
	case DRM_FORMAT_YVYU:
	case DRM_FORMAT_UYVY:
	case DRM_FORMAT_VYUY:
	case DRM_FORMAT_NV12:
	case DRM_FORMAT_NV21:
	case DRM_FORMAT_NV16:
	case DRM_FORMAT_NV61:
	case DRM_FORMAT_YUV422:
	case DRM_FORMAT_YVU422:
	case DRM_FORMAT_YUV420:
	case DRM_FORMAT_YVU420:
		return 2;
	default:
		return 1;
	}
}
EXPORT_SYMBOL(drm_format_horz_chroma_subsampling);

/**
 * drm_format_vert_chroma_subsampling - get the vertical chroma subsampling factor
 * @format: pixel format (DRM_FORMAT_*)
 *
4918
 * Returns:
4919 4920 4921 4922 4923 4924 4925 4926 4927 4928 4929 4930 4931 4932 4933 4934 4935 4936 4937
 * The vertical chroma subsampling factor for the
 * specified pixel format.
 */
int drm_format_vert_chroma_subsampling(uint32_t format)
{
	switch (format) {
	case DRM_FORMAT_YUV410:
	case DRM_FORMAT_YVU410:
		return 4;
	case DRM_FORMAT_YUV420:
	case DRM_FORMAT_YVU420:
	case DRM_FORMAT_NV12:
	case DRM_FORMAT_NV21:
		return 2;
	default:
		return 1;
	}
}
EXPORT_SYMBOL(drm_format_vert_chroma_subsampling);
4938 4939 4940 4941 4942 4943 4944 4945 4946 4947 4948 4949 4950 4951 4952 4953

/**
 * drm_mode_config_init - initialize DRM mode_configuration structure
 * @dev: DRM device
 *
 * Initialize @dev's mode_config structure, used for tracking the graphics
 * configuration of @dev.
 *
 * Since this initializes the modeset locks, no locking is possible. Which is no
 * problem, since this should happen single threaded at init time. It is the
 * driver's problem to ensure this guarantee.
 *
 */
void drm_mode_config_init(struct drm_device *dev)
{
	mutex_init(&dev->mode_config.mutex);
4954
	drm_modeset_lock_init(&dev->mode_config.connection_mutex);
4955 4956 4957 4958 4959
	mutex_init(&dev->mode_config.idr_mutex);
	mutex_init(&dev->mode_config.fb_lock);
	INIT_LIST_HEAD(&dev->mode_config.fb_list);
	INIT_LIST_HEAD(&dev->mode_config.crtc_list);
	INIT_LIST_HEAD(&dev->mode_config.connector_list);
S
Sean Paul 已提交
4960
	INIT_LIST_HEAD(&dev->mode_config.bridge_list);
4961 4962 4963 4964 4965 4966 4967 4968
	INIT_LIST_HEAD(&dev->mode_config.encoder_list);
	INIT_LIST_HEAD(&dev->mode_config.property_list);
	INIT_LIST_HEAD(&dev->mode_config.property_blob_list);
	INIT_LIST_HEAD(&dev->mode_config.plane_list);
	idr_init(&dev->mode_config.crtc_idr);

	drm_modeset_lock_all(dev);
	drm_mode_create_standard_connector_properties(dev);
R
Rob Clark 已提交
4969
	drm_mode_create_standard_plane_properties(dev);
4970 4971 4972 4973 4974 4975 4976
	drm_modeset_unlock_all(dev);

	/* Just to be sure */
	dev->mode_config.num_fb = 0;
	dev->mode_config.num_connector = 0;
	dev->mode_config.num_crtc = 0;
	dev->mode_config.num_encoder = 0;
4977 4978
	dev->mode_config.num_overlay_plane = 0;
	dev->mode_config.num_total_plane = 0;
4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991 4992 4993 4994 4995 4996 4997 4998 4999
}
EXPORT_SYMBOL(drm_mode_config_init);

/**
 * drm_mode_config_cleanup - free up DRM mode_config info
 * @dev: DRM device
 *
 * Free up all the connectors and CRTCs associated with this DRM device, then
 * free up the framebuffers and associated buffer objects.
 *
 * Note that since this /should/ happen single-threaded at driver/device
 * teardown time, no locking is required. It's the driver's job to ensure that
 * this guarantee actually holds true.
 *
 * FIXME: cleanup any dangling user buffer objects too
 */
void drm_mode_config_cleanup(struct drm_device *dev)
{
	struct drm_connector *connector, *ot;
	struct drm_crtc *crtc, *ct;
	struct drm_encoder *encoder, *enct;
S
Sean Paul 已提交
5000
	struct drm_bridge *bridge, *brt;
5001 5002 5003 5004 5005 5006 5007 5008 5009 5010
	struct drm_framebuffer *fb, *fbt;
	struct drm_property *property, *pt;
	struct drm_property_blob *blob, *bt;
	struct drm_plane *plane, *plt;

	list_for_each_entry_safe(encoder, enct, &dev->mode_config.encoder_list,
				 head) {
		encoder->funcs->destroy(encoder);
	}

S
Sean Paul 已提交
5011 5012 5013 5014 5015
	list_for_each_entry_safe(bridge, brt,
				 &dev->mode_config.bridge_list, head) {
		bridge->funcs->destroy(bridge);
	}

5016 5017 5018 5019 5020 5021 5022 5023 5024 5025 5026 5027 5028 5029 5030 5031 5032 5033 5034 5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051 5052 5053
	list_for_each_entry_safe(connector, ot,
				 &dev->mode_config.connector_list, head) {
		connector->funcs->destroy(connector);
	}

	list_for_each_entry_safe(property, pt, &dev->mode_config.property_list,
				 head) {
		drm_property_destroy(dev, property);
	}

	list_for_each_entry_safe(blob, bt, &dev->mode_config.property_blob_list,
				 head) {
		drm_property_destroy_blob(dev, blob);
	}

	/*
	 * Single-threaded teardown context, so it's not required to grab the
	 * fb_lock to protect against concurrent fb_list access. Contrary, it
	 * would actually deadlock with the drm_framebuffer_cleanup function.
	 *
	 * Also, if there are any framebuffers left, that's a driver leak now,
	 * so politely WARN about this.
	 */
	WARN_ON(!list_empty(&dev->mode_config.fb_list));
	list_for_each_entry_safe(fb, fbt, &dev->mode_config.fb_list, head) {
		drm_framebuffer_remove(fb);
	}

	list_for_each_entry_safe(plane, plt, &dev->mode_config.plane_list,
				 head) {
		plane->funcs->destroy(plane);
	}

	list_for_each_entry_safe(crtc, ct, &dev->mode_config.crtc_list, head) {
		crtc->funcs->destroy(crtc);
	}

	idr_destroy(&dev->mode_config.crtc_idr);
5054
	drm_modeset_lock_fini(&dev->mode_config.connection_mutex);
5055 5056
}
EXPORT_SYMBOL(drm_mode_config_cleanup);