drm_crtc.c 163.1 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>
R
Rob Clark 已提交
41
#include <drm/drm_atomic.h>
D
Dave Airlie 已提交
42

43
#include "drm_crtc_internal.h"
44
#include "drm_internal.h"
45

46 47
static struct drm_framebuffer *
internal_framebuffer_create(struct drm_device *dev,
48
			    const struct drm_mode_fb_cmd2 *r,
49
			    struct drm_file *file_priv);
50

D
Dave Airlie 已提交
51 52
/* Avoid boilerplate.  I'm tired of typing. */
#define DRM_ENUM_NAME_FN(fnname, list)				\
53
	const char *fnname(int val)				\
D
Dave Airlie 已提交
54 55 56 57 58 59 60 61 62 63 64 65
	{							\
		int i;						\
		for (i = 0; i < ARRAY_SIZE(list); i++) {	\
			if (list[i].type == val)		\
				return list[i].name;		\
		}						\
		return "(unknown)";				\
	}

/*
 * Global properties
 */
66 67
static const struct drm_prop_enum_list drm_dpms_enum_list[] = {
	{ DRM_MODE_DPMS_ON, "On" },
D
Dave Airlie 已提交
68 69 70 71 72 73 74
	{ 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)

75
static const struct drm_prop_enum_list drm_plane_type_enum_list[] = {
R
Rob Clark 已提交
76 77 78 79 80
	{ DRM_PLANE_TYPE_OVERLAY, "Overlay" },
	{ DRM_PLANE_TYPE_PRIMARY, "Primary" },
	{ DRM_PLANE_TYPE_CURSOR, "Cursor" },
};

D
Dave Airlie 已提交
81 82 83
/*
 * Optional properties
 */
84
static const struct drm_prop_enum_list drm_scaling_mode_enum_list[] = {
85 86 87 88
	{ DRM_MODE_SCALE_NONE, "None" },
	{ DRM_MODE_SCALE_FULLSCREEN, "Full" },
	{ DRM_MODE_SCALE_CENTER, "Center" },
	{ DRM_MODE_SCALE_ASPECT, "Full aspect" },
D
Dave Airlie 已提交
89 90
};

91 92 93 94 95 96
static const struct drm_prop_enum_list drm_aspect_ratio_enum_list[] = {
	{ DRM_MODE_PICTURE_ASPECT_NONE, "Automatic" },
	{ DRM_MODE_PICTURE_ASPECT_4_3, "4:3" },
	{ DRM_MODE_PICTURE_ASPECT_16_9, "16:9" },
};

D
Dave Airlie 已提交
97 98 99
/*
 * Non-global properties, but "required" for certain connectors.
 */
100
static const struct drm_prop_enum_list drm_dvi_i_select_enum_list[] = {
D
Dave Airlie 已提交
101 102 103 104 105 106 107
	{ 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)

108
static const struct drm_prop_enum_list drm_dvi_i_subconnector_enum_list[] = {
D
Dave Airlie 已提交
109 110 111 112 113 114 115 116
	{ 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)

117
static const struct drm_prop_enum_list drm_tv_select_enum_list[] = {
D
Dave Airlie 已提交
118 119 120 121
	{ 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 */
122
	{ DRM_MODE_SUBCONNECTOR_SCART,     "SCART"     }, /* TV-out */
D
Dave Airlie 已提交
123 124 125 126
};

DRM_ENUM_NAME_FN(drm_get_tv_select_name, drm_tv_select_enum_list)

127
static const struct drm_prop_enum_list drm_tv_subconnector_enum_list[] = {
D
Dave Airlie 已提交
128 129 130 131
	{ 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 */
132
	{ DRM_MODE_SUBCONNECTOR_SCART,     "SCART"     }, /* TV-out */
D
Dave Airlie 已提交
133 134 135 136 137
};

DRM_ENUM_NAME_FN(drm_get_tv_subconnector_name,
		 drm_tv_subconnector_enum_list)

138
static const struct drm_prop_enum_list drm_dirty_info_enum_list[] = {
139 140 141 142 143
	{ DRM_MODE_DIRTY_OFF,      "Off"      },
	{ DRM_MODE_DIRTY_ON,       "On"       },
	{ DRM_MODE_DIRTY_ANNOTATE, "Annotate" },
};

D
Dave Airlie 已提交
144 145
struct drm_conn_prop_enum_list {
	int type;
146
	const char *name;
147
	struct ida ida;
D
Dave Airlie 已提交
148 149 150 151 152
};

/*
 * Connector and encoder types.
 */
153 154
static struct drm_conn_prop_enum_list drm_connector_enum_list[] = {
	{ DRM_MODE_CONNECTOR_Unknown, "Unknown" },
155 156 157 158 159 160 161 162 163 164 165 166 167 168 169
	{ 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" },
170
	{ DRM_MODE_CONNECTOR_DSI, "DSI" },
171
	{ DRM_MODE_CONNECTOR_DPI, "DPI" },
D
Dave Airlie 已提交
172 173
};

174 175
static const struct drm_prop_enum_list drm_encoder_enum_list[] = {
	{ DRM_MODE_ENCODER_NONE, "None" },
D
Dave Airlie 已提交
176 177 178 179
	{ DRM_MODE_ENCODER_DAC, "DAC" },
	{ DRM_MODE_ENCODER_TMDS, "TMDS" },
	{ DRM_MODE_ENCODER_LVDS, "LVDS" },
	{ DRM_MODE_ENCODER_TVDAC, "TV" },
180
	{ DRM_MODE_ENCODER_VIRTUAL, "Virtual" },
181
	{ DRM_MODE_ENCODER_DSI, "DSI" },
D
Dave Airlie 已提交
182
	{ DRM_MODE_ENCODER_DPMST, "DP MST" },
183
	{ DRM_MODE_ENCODER_DPI, "DPI" },
D
Dave Airlie 已提交
184 185
};

186
static const struct drm_prop_enum_list drm_subpixel_enum_list[] = {
187 188 189 190 191 192 193 194
	{ SubPixelUnknown, "Unknown" },
	{ SubPixelHorizontalRGB, "Horizontal RGB" },
	{ SubPixelHorizontalBGR, "Horizontal BGR" },
	{ SubPixelVerticalRGB, "Vertical RGB" },
	{ SubPixelVerticalBGR, "Vertical BGR" },
	{ SubPixelNone, "None" },
};

195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210
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);
}

211 212 213 214 215 216 217
/**
 * 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.
 */
218
const char *drm_get_connector_status_name(enum drm_connector_status status)
D
Dave Airlie 已提交
219 220 221 222 223 224 225 226
{
	if (status == connector_status_connected)
		return "connected";
	else if (status == connector_status_disconnected)
		return "disconnected";
	else
		return "unknown";
}
227
EXPORT_SYMBOL(drm_get_connector_status_name);
D
Dave Airlie 已提交
228

229 230 231 232 233 234 235 236 237 238 239 240 241
/**
 * 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);

242 243 244 245 246
static char printable_char(int c)
{
	return isascii(c) && isprint(c) ? c : '?';
}

247 248 249 250 251 252 253 254 255
/**
 * 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.
 */
256
const char *drm_get_format_name(uint32_t format)
257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272
{
	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);

273 274 275 276 277 278 279
/*
 * 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,
280 281
				   bool register_obj,
				   void (*obj_free_cb)(struct kref *kref))
282 283 284 285 286 287 288 289 290 291 292 293
{
	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;
294 295 296 297
		if (obj_free_cb) {
			obj->free_cb = obj_free_cb;
			kref_init(&obj->refcount);
		}
298 299 300 301 302 303
	}
	mutex_unlock(&dev->mode_config.idr_mutex);

	return ret < 0 ? ret : 0;
}

D
Dave Airlie 已提交
304
/**
305
 * drm_mode_object_get - allocate a new modeset identifier
D
Dave Airlie 已提交
306
 * @dev: DRM device
307 308
 * @obj: object pointer, used to generate unique ID
 * @obj_type: object type
D
Dave Airlie 已提交
309 310
 *
 * Create a unique identifier based on @ptr in @dev's identifier space.  Used
311 312 313
 * 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 已提交
314
 *
315
 * Returns:
316
 * Zero on success, error code on failure.
D
Dave Airlie 已提交
317
 */
318 319
int drm_mode_object_get(struct drm_device *dev,
			struct drm_mode_object *obj, uint32_t obj_type)
D
Dave Airlie 已提交
320
{
321
	return drm_mode_object_get_reg(dev, obj, obj_type, true, NULL);
322
}
D
Dave Airlie 已提交
323

324 325 326
static void drm_mode_object_register(struct drm_device *dev,
				     struct drm_mode_object *obj)
{
J
Jesse Barnes 已提交
327
	mutex_lock(&dev->mode_config.idr_mutex);
328
	idr_replace(&dev->mode_config.crtc_idr, obj, obj->id);
J
Jesse Barnes 已提交
329
	mutex_unlock(&dev->mode_config.idr_mutex);
D
Dave Airlie 已提交
330 331 332
}

/**
333
 * drm_mode_object_unregister - free a modeset identifer
D
Dave Airlie 已提交
334
 * @dev: DRM device
335
 * @object: object to free
D
Dave Airlie 已提交
336
 *
337 338 339 340
 * Free @id from @dev's unique identifier pool.
 * This function can be called multiple times, and guards against
 * multiple removals.
 * These modeset identifiers are _not_ reference counted. Hence don't use this
341
 * for reference counted modeset objects like framebuffers.
D
Dave Airlie 已提交
342
 */
343
void drm_mode_object_unregister(struct drm_device *dev,
344
			 struct drm_mode_object *object)
D
Dave Airlie 已提交
345
{
J
Jesse Barnes 已提交
346
	mutex_lock(&dev->mode_config.idr_mutex);
347 348 349 350
	if (object->id) {
		idr_remove(&dev->mode_config.crtc_idr, object->id);
		object->id = 0;
	}
J
Jesse Barnes 已提交
351
	mutex_unlock(&dev->mode_config.idr_mutex);
D
Dave Airlie 已提交
352 353
}

R
Rob Clark 已提交
354 355 356 357 358 359 360
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);
361 362 363 364
	if (obj && type != DRM_MODE_OBJECT_ANY && obj->type != type)
		obj = NULL;
	if (obj && obj->id != id)
		obj = NULL;
365 366 367 368 369

	if (obj && obj->free_cb) {
		if (!kref_get_unless_zero(&obj->refcount))
			obj = NULL;
	}
R
Rob Clark 已提交
370 371 372 373 374
	mutex_unlock(&dev->mode_config.idr_mutex);

	return obj;
}

375 376 377 378 379 380
/**
 * 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
 *
381 382 383
 * This function is used to look up a modeset object. It will acquire a
 * reference for reference counted objects. This reference must be dropped again
 * by callind drm_mode_object_unreference().
384
 */
385 386
struct drm_mode_object *drm_mode_object_find(struct drm_device *dev,
		uint32_t id, uint32_t type)
D
Dave Airlie 已提交
387
{
J
Jesse Barnes 已提交
388
	struct drm_mode_object *obj = NULL;
D
Dave Airlie 已提交
389

R
Rob Clark 已提交
390
	obj = _object_find(dev, id, type);
D
Dave Airlie 已提交
391 392 393 394
	return obj;
}
EXPORT_SYMBOL(drm_mode_object_find);

395 396 397 398 399 400 401 402
/**
 * drm_mode_object_unreference - decr the object refcnt
 * @obj: mode_object
 *
 * This functions decrements the object's refcount if it is a refcounted modeset
 * object. It is a no-op on any other object. This is used to drop references
 * acquired with drm_mode_object_reference().
 */
403 404 405 406 407 408 409 410 411 412
void drm_mode_object_unreference(struct drm_mode_object *obj)
{
	if (obj->free_cb) {
		DRM_DEBUG("OBJ ID: %d (%d)\n", obj->id, atomic_read(&obj->refcount.refcount));
		kref_put(&obj->refcount, obj->free_cb);
	}
}
EXPORT_SYMBOL(drm_mode_object_unreference);

/**
413
 * drm_mode_object_reference - incr the object refcnt
414 415
 * @obj: mode_object
 *
416 417 418
 * This functions increments the object's refcount if it is a refcounted modeset
 * object. It is a no-op on any other object. References should be dropped again
 * by calling drm_mode_object_unreference().
419 420 421 422 423 424 425 426 427 428
 */
void drm_mode_object_reference(struct drm_mode_object *obj)
{
	if (obj->free_cb) {
		DRM_DEBUG("OBJ ID: %d (%d)\n", obj->id, atomic_read(&obj->refcount.refcount));
		kref_get(&obj->refcount);
	}
}
EXPORT_SYMBOL(drm_mode_object_reference);

429 430 431
static void drm_framebuffer_free(struct kref *kref)
{
	struct drm_framebuffer *fb =
432
			container_of(kref, struct drm_framebuffer, base.refcount);
433 434 435 436 437 438
	struct drm_device *dev = fb->dev;

	/*
	 * The lookup idr holds a weak reference, which has not necessarily been
	 * removed at this point. Check for that.
	 */
439
	drm_mode_object_unregister(dev, &fb->base);
440 441 442 443

	fb->funcs->destroy(fb);
}

D
Dave Airlie 已提交
444 445 446
/**
 * drm_framebuffer_init - initialize a framebuffer
 * @dev: DRM device
447 448
 * @fb: framebuffer to be initialized
 * @funcs: ... with these functions
D
Dave Airlie 已提交
449 450 451 452
 *
 * Allocates an ID for the framebuffer's parent mode object, sets its mode
 * functions & device file and adds it to the master fd list.
 *
453 454 455 456 457 458
 * 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.
 *
459
 * Returns:
460
 * Zero on success, error code on failure.
D
Dave Airlie 已提交
461 462 463 464 465 466
 */
int drm_framebuffer_init(struct drm_device *dev, struct drm_framebuffer *fb,
			 const struct drm_framebuffer_funcs *funcs)
{
	int ret;

467 468 469
	INIT_LIST_HEAD(&fb->filp_head);
	fb->dev = dev;
	fb->funcs = funcs;
R
Rob Clark 已提交
470

471
	ret = drm_mode_object_get_reg(dev, &fb->base, DRM_MODE_OBJECT_FB,
472
				      false, drm_framebuffer_free);
473
	if (ret)
474
		goto out;
D
Dave Airlie 已提交
475

476
	mutex_lock(&dev->mode_config.fb_lock);
D
Dave Airlie 已提交
477 478
	dev->mode_config.num_fb++;
	list_add(&fb->head, &dev->mode_config.fb_list);
479
	mutex_unlock(&dev->mode_config.fb_lock);
D
Dave Airlie 已提交
480

481 482
	drm_mode_object_register(dev, &fb->base);
out:
483
	return ret;
D
Dave Airlie 已提交
484 485 486
}
EXPORT_SYMBOL(drm_framebuffer_init);

487 488 489 490 491 492 493
/**
 * 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
494
 * again, using @drm_framebuffer_unreference.
495 496 497 498
 */
struct drm_framebuffer *drm_framebuffer_lookup(struct drm_device *dev,
					       uint32_t id)
{
499 500
	struct drm_mode_object *obj;
	struct drm_framebuffer *fb = NULL;
501

502
	obj = _object_find(dev, id, DRM_MODE_OBJECT_FB);
503
	if (obj)
504
		fb = obj_to_fb(obj);
505 506 507 508
	return fb;
}
EXPORT_SYMBOL(drm_framebuffer_lookup);

509 510 511 512 513 514 515 516 517 518 519
/**
 * 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)
{
520 521 522 523 524 525
	struct drm_device *dev;

	if (!fb)
		return;

	dev = fb->dev;
526 527

	/* Mark fb as reaped and drop idr ref. */
528
	drm_mode_object_unregister(dev, &fb->base);
529 530 531
}
EXPORT_SYMBOL(drm_framebuffer_unregister_private);

D
Dave Airlie 已提交
532 533 534 535
/**
 * drm_framebuffer_cleanup - remove a framebuffer object
 * @fb: framebuffer to remove
 *
536 537
 * Cleanup framebuffer. This function is intended to be used from the drivers
 * ->destroy callback. It can also be used to clean up driver private
D
Daniel Vetter 已提交
538
 * framebuffers embedded into a larger structure.
539 540 541 542 543 544 545 546 547
 *
 * 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 已提交
548 549
 */
void drm_framebuffer_cleanup(struct drm_framebuffer *fb)
R
Rob Clark 已提交
550 551
{
	struct drm_device *dev = fb->dev;
552

553
	mutex_lock(&dev->mode_config.fb_lock);
R
Rob Clark 已提交
554 555
	list_del(&fb->head);
	dev->mode_config.num_fb--;
556
	mutex_unlock(&dev->mode_config.fb_lock);
R
Rob Clark 已提交
557 558 559 560 561 562 563 564
}
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
565
 * using @fb, removes it, setting it to NULL. Then drops the reference to the
566 567 568 569 570
 * 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 已提交
571 572
 */
void drm_framebuffer_remove(struct drm_framebuffer *fb)
D
Dave Airlie 已提交
573
{
574
	struct drm_device *dev;
D
Dave Airlie 已提交
575
	struct drm_crtc *crtc;
J
Jesse Barnes 已提交
576
	struct drm_plane *plane;
577 578
	struct drm_mode_set set;
	int ret;
D
Dave Airlie 已提交
579

580 581 582 583 584
	if (!fb)
		return;

	dev = fb->dev;

585
	WARN_ON(!list_empty(&fb->filp_head));
586

587 588 589 590 591 592 593 594 595 596 597 598 599 600 601
	/*
	 * 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.
	 */
602
	if (drm_framebuffer_read_refcount(fb) > 1) {
603 604
		drm_modeset_lock_all(dev);
		/* remove from any CRTC */
605
		drm_for_each_crtc(crtc, dev) {
606
			if (crtc->primary->fb == fb) {
607 608 609 610 611 612 613 614
				/* 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);
			}
615
		}
D
Dave Airlie 已提交
616

617
		drm_for_each_plane(plane, dev) {
618 619
			if (plane->fb == fb)
				drm_plane_force_disable(plane);
J
Jesse Barnes 已提交
620
		}
621
		drm_modeset_unlock_all(dev);
J
Jesse Barnes 已提交
622 623
	}

R
Rob Clark 已提交
624
	drm_framebuffer_unreference(fb);
D
Dave Airlie 已提交
625
}
R
Rob Clark 已提交
626
EXPORT_SYMBOL(drm_framebuffer_remove);
D
Dave Airlie 已提交
627

628 629
DEFINE_WW_CLASS(crtc_ww_class);

630 631 632 633 634 635 636 637 638 639 640 641
static unsigned int drm_num_crtcs(struct drm_device *dev)
{
	unsigned int num = 0;
	struct drm_crtc *tmp;

	drm_for_each_crtc(tmp, dev) {
		num++;
	}

	return num;
}

D
Dave Airlie 已提交
642
/**
643 644
 * drm_crtc_init_with_planes - Initialise a new CRTC object with
 *    specified primary and cursor planes.
D
Dave Airlie 已提交
645 646
 * @dev: DRM device
 * @crtc: CRTC object to init
647 648
 * @primary: Primary plane for CRTC
 * @cursor: Cursor plane for CRTC
D
Dave Airlie 已提交
649
 * @funcs: callbacks for the new CRTC
650
 * @name: printf style format string for the CRTC name, or NULL for default name
D
Dave Airlie 已提交
651
 *
652
 * Inits a new object created as base part of a driver crtc object.
653
 *
654
 * Returns:
655
 * Zero on success, error code on failure.
D
Dave Airlie 已提交
656
 */
657 658
int drm_crtc_init_with_planes(struct drm_device *dev, struct drm_crtc *crtc,
			      struct drm_plane *primary,
659
			      struct drm_plane *cursor,
660 661
			      const struct drm_crtc_funcs *funcs,
			      const char *name, ...)
D
Dave Airlie 已提交
662
{
663
	struct drm_mode_config *config = &dev->mode_config;
664 665
	int ret;

666 667 668
	WARN_ON(primary && primary->type != DRM_PLANE_TYPE_PRIMARY);
	WARN_ON(cursor && cursor->type != DRM_PLANE_TYPE_CURSOR);

D
Dave Airlie 已提交
669 670 671
	crtc->dev = dev;
	crtc->funcs = funcs;

672
	drm_modeset_lock_init(&crtc->mutex);
673 674
	ret = drm_mode_object_get(dev, &crtc->base, DRM_MODE_OBJECT_CRTC);
	if (ret)
675
		return ret;
D
Dave Airlie 已提交
676

677 678 679 680 681 682 683 684 685 686 687
	if (name) {
		va_list ap;

		va_start(ap, name);
		crtc->name = kvasprintf(GFP_KERNEL, name, ap);
		va_end(ap);
	} else {
		crtc->name = kasprintf(GFP_KERNEL, "crtc-%d",
				       drm_num_crtcs(dev));
	}
	if (!crtc->name) {
688
		drm_mode_object_unregister(dev, &crtc->base);
689 690 691
		return -ENOMEM;
	}

P
Paulo Zanoni 已提交
692 693
	crtc->base.properties = &crtc->properties;

694 695
	list_add_tail(&crtc->head, &config->crtc_list);
	config->num_crtc++;
696

697
	crtc->primary = primary;
698
	crtc->cursor = cursor;
699 700
	if (primary)
		primary->possible_crtcs = 1 << drm_crtc_index(crtc);
701 702
	if (cursor)
		cursor->possible_crtcs = 1 << drm_crtc_index(crtc);
703

704 705
	if (drm_core_check_feature(dev, DRIVER_ATOMIC)) {
		drm_object_attach_property(&crtc->base, config->prop_active, 0);
D
Daniel Stone 已提交
706
		drm_object_attach_property(&crtc->base, config->prop_mode_id, 0);
707 708
	}

709
	return 0;
D
Dave Airlie 已提交
710
}
711
EXPORT_SYMBOL(drm_crtc_init_with_planes);
D
Dave Airlie 已提交
712 713

/**
714
 * drm_crtc_cleanup - Clean up the core crtc usage
D
Dave Airlie 已提交
715 716
 * @crtc: CRTC to cleanup
 *
717 718 719
 * 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 已提交
720 721 722 723 724
 */
void drm_crtc_cleanup(struct drm_crtc *crtc)
{
	struct drm_device *dev = crtc->dev;

725 726
	kfree(crtc->gamma_store);
	crtc->gamma_store = NULL;
D
Dave Airlie 已提交
727

728 729
	drm_modeset_lock_fini(&crtc->mutex);

730
	drm_mode_object_unregister(dev, &crtc->base);
D
Dave Airlie 已提交
731 732
	list_del(&crtc->head);
	dev->mode_config.num_crtc--;
733 734 735 736

	WARN_ON(crtc->state && !crtc->funcs->atomic_destroy_state);
	if (crtc->state && crtc->funcs->atomic_destroy_state)
		crtc->funcs->atomic_destroy_state(crtc, crtc->state);
737

738 739
	kfree(crtc->name);

740
	memset(crtc, 0, sizeof(*crtc));
D
Dave Airlie 已提交
741 742 743
}
EXPORT_SYMBOL(drm_crtc_cleanup);

744 745 746 747 748 749 750 751 752 753 754 755
/**
 * 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;

756
	drm_for_each_crtc(tmp, crtc->dev) {
757 758 759 760 761 762 763 764 765 766
		if (tmp == crtc)
			return index;

		index++;
	}

	BUG();
}
EXPORT_SYMBOL(drm_crtc_index);

767
/*
D
Dave Airlie 已提交
768 769 770 771 772 773
 * 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.
 */
774 775
static void drm_mode_remove(struct drm_connector *connector,
			    struct drm_display_mode *mode)
D
Dave Airlie 已提交
776 777
{
	list_del(&mode->head);
778
	drm_mode_destroy(connector->dev, mode);
D
Dave Airlie 已提交
779 780
}

781 782 783
/**
 * drm_display_info_set_bus_formats - set the supported bus formats
 * @info: display info to store bus formats in
784 785
 * @formats: array containing the supported bus formats
 * @num_formats: the number of entries in the fmts array
786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802
 *
 * Store the supported bus formats in display info structure.
 * See MEDIA_BUS_FMT_* definitions in include/uapi/linux/media-bus-format.h for
 * a full list of available formats.
 */
int drm_display_info_set_bus_formats(struct drm_display_info *info,
				     const u32 *formats,
				     unsigned int num_formats)
{
	u32 *fmts = NULL;

	if (!formats && num_formats)
		return -EINVAL;

	if (formats && num_formats) {
		fmts = kmemdup(formats, sizeof(*formats) * num_formats,
			       GFP_KERNEL);
803
		if (!fmts)
804 805 806 807 808 809 810 811 812 813 814
			return -ENOMEM;
	}

	kfree(info->bus_formats);
	info->bus_formats = fmts;
	info->num_bus_formats = num_formats;

	return 0;
}
EXPORT_SYMBOL(drm_display_info_set_bus_formats);

815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866
/**
 * drm_connector_get_cmdline_mode - reads the user's cmdline mode
 * @connector: connector to quwery
 *
 * The kernel supports per-connector configration of its consoles through
 * use of the video= parameter. This function parses that option and
 * extracts the user's specified mode (or enable/disable status) for a
 * particular connector. This is typically only used during the early fbdev
 * setup.
 */
static void drm_connector_get_cmdline_mode(struct drm_connector *connector)
{
	struct drm_cmdline_mode *mode = &connector->cmdline_mode;
	char *option = NULL;

	if (fb_get_options(connector->name, &option))
		return;

	if (!drm_mode_parse_command_line_for_connector(option,
						       connector,
						       mode))
		return;

	if (mode->force) {
		const char *s;

		switch (mode->force) {
		case DRM_FORCE_OFF:
			s = "OFF";
			break;
		case DRM_FORCE_ON_DIGITAL:
			s = "ON - dig";
			break;
		default:
		case DRM_FORCE_ON:
			s = "ON";
			break;
		}

		DRM_INFO("forcing %s connector %s\n", connector->name, s);
		connector->force = mode->force;
	}

	DRM_DEBUG_KMS("cmdline mode for connector %s %dx%d@%dHz%s%s%s\n",
		      connector->name,
		      mode->xres, mode->yres,
		      mode->refresh_specified ? mode->refresh : 60,
		      mode->rb ? " reduced blanking" : "",
		      mode->margins ? " with margins" : "",
		      mode->interlace ?  " interlaced" : "");
}

867 868 869 870 871 872 873 874 875 876
static void drm_connector_free(struct kref *kref)
{
	struct drm_connector *connector =
		container_of(kref, struct drm_connector, base.refcount);
	struct drm_device *dev = connector->dev;

	drm_mode_object_unregister(dev, &connector->base);
	connector->funcs->destroy(connector);
}

D
Dave Airlie 已提交
877 878 879 880 881
/**
 * drm_connector_init - Init a preallocated connector
 * @dev: DRM device
 * @connector: the connector to init
 * @funcs: callbacks for this connector
882
 * @connector_type: user visible type of the connector
D
Dave Airlie 已提交
883 884 885
 *
 * Initialises a preallocated connector. Connectors should be
 * subclassed as part of driver connector objects.
886
 *
887
 * Returns:
888
 * Zero on success, error code on failure.
D
Dave Airlie 已提交
889
 */
890 891 892 893
int drm_connector_init(struct drm_device *dev,
		       struct drm_connector *connector,
		       const struct drm_connector_funcs *funcs,
		       int connector_type)
D
Dave Airlie 已提交
894
{
895
	struct drm_mode_config *config = &dev->mode_config;
896
	int ret;
897 898
	struct ida *connector_ida =
		&drm_connector_enum_list[connector_type].ida;
899

900
	drm_modeset_lock_all(dev);
D
Dave Airlie 已提交
901

902 903 904
	ret = drm_mode_object_get_reg(dev, &connector->base,
				      DRM_MODE_OBJECT_CONNECTOR,
				      false, drm_connector_free);
905
	if (ret)
906
		goto out_unlock;
907

908
	connector->base.properties = &connector->properties;
D
Dave Airlie 已提交
909 910
	connector->dev = dev;
	connector->funcs = funcs;
911 912 913 914 915 916 917

	connector->connector_id = ida_simple_get(&config->connector_ida, 0, 0, GFP_KERNEL);
	if (connector->connector_id < 0) {
		ret = connector->connector_id;
		goto out_put;
	}

D
Dave Airlie 已提交
918 919
	connector->connector_type = connector_type;
	connector->connector_type_id =
920 921 922
		ida_simple_get(connector_ida, 1, 0, GFP_KERNEL);
	if (connector->connector_type_id < 0) {
		ret = connector->connector_type_id;
923
		goto out_put_id;
924
	}
925 926 927 928 929 930
	connector->name =
		kasprintf(GFP_KERNEL, "%s-%d",
			  drm_connector_enum_list[connector_type].name,
			  connector->connector_type_id);
	if (!connector->name) {
		ret = -ENOMEM;
931
		goto out_put_type_id;
932 933
	}

D
Dave Airlie 已提交
934 935 936
	INIT_LIST_HEAD(&connector->probed_modes);
	INIT_LIST_HEAD(&connector->modes);
	connector->edid_blob_ptr = NULL;
937
	connector->status = connector_status_unknown;
D
Dave Airlie 已提交
938

939 940
	drm_connector_get_cmdline_mode(connector);

941 942
	/* We should add connectors at the end to avoid upsetting the connector
	 * index too much. */
943 944
	list_add_tail(&connector->head, &config->connector_list);
	config->num_connector++;
D
Dave Airlie 已提交
945

946
	if (connector_type != DRM_MODE_CONNECTOR_VIRTUAL)
947
		drm_object_attach_property(&connector->base,
948
					      config->edid_property,
949
					      0);
D
Dave Airlie 已提交
950

951
	drm_object_attach_property(&connector->base,
952 953 954 955 956
				      config->dpms_property, 0);

	if (drm_core_check_feature(dev, DRIVER_ATOMIC)) {
		drm_object_attach_property(&connector->base, config->prop_crtc_id, 0);
	}
D
Dave Airlie 已提交
957

958
	connector->debugfs_entry = NULL;
959 960 961 962 963 964
out_put_type_id:
	if (ret)
		ida_remove(connector_ida, connector->connector_type_id);
out_put_id:
	if (ret)
		ida_remove(&config->connector_ida, connector->connector_id);
965 966
out_put:
	if (ret)
967
		drm_mode_object_unregister(dev, &connector->base);
968 969

out_unlock:
970
	drm_modeset_unlock_all(dev);
971 972

	return ret;
D
Dave Airlie 已提交
973 974 975 976 977 978 979 980 981 982 983 984 985 986
}
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;

987 988 989 990 991
	if (connector->tile_group) {
		drm_mode_put_tile_group(dev, connector->tile_group);
		connector->tile_group = NULL;
	}

D
Dave Airlie 已提交
992 993 994 995 996 997
	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);

998 999 1000
	ida_remove(&drm_connector_enum_list[connector->connector_type].ida,
		   connector->connector_type_id);

1001 1002 1003
	ida_remove(&dev->mode_config.connector_ida,
		   connector->connector_id);

1004
	kfree(connector->display_info.bus_formats);
1005
	drm_mode_object_unregister(dev, &connector->base);
1006 1007
	kfree(connector->name);
	connector->name = NULL;
D
Dave Airlie 已提交
1008
	list_del(&connector->head);
1009
	dev->mode_config.num_connector--;
1010 1011 1012 1013 1014

	WARN_ON(connector->state && !connector->funcs->atomic_destroy_state);
	if (connector->state && connector->funcs->atomic_destroy_state)
		connector->funcs->atomic_destroy_state(connector,
						       connector->state);
1015 1016

	memset(connector, 0, sizeof(*connector));
D
Dave Airlie 已提交
1017 1018 1019
}
EXPORT_SYMBOL(drm_connector_cleanup);

1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030
/**
 * 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)
{
1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042
	int ret;

	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;
	}

1043 1044
	drm_mode_object_register(connector->dev, &connector->base);

1045
	return 0;
1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057
}
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);
1058
	drm_debugfs_connector_remove(connector);
1059 1060 1061
}
EXPORT_SYMBOL(drm_connector_unregister);

1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101
/**
 * drm_connector_register_all - register all connectors
 * @dev: drm device
 *
 * This function registers all connectors in sysfs and other places so that
 * userspace can start to access them. Drivers can call it after calling
 * drm_dev_register() to complete the device registration, if they don't call
 * drm_connector_register() on each connector individually.
 *
 * When a device is unplugged and should be removed from userspace access,
 * call drm_connector_unregister_all(), which is the inverse of this
 * function.
 *
 * Returns:
 * Zero on success, error code on failure.
 */
int drm_connector_register_all(struct drm_device *dev)
{
	struct drm_connector *connector;
	int ret;

	mutex_lock(&dev->mode_config.mutex);

	drm_for_each_connector(connector, dev) {
		ret = drm_connector_register(connector);
		if (ret)
			goto err;
	}

	mutex_unlock(&dev->mode_config.mutex);

	return 0;

err:
	mutex_unlock(&dev->mode_config.mutex);
	drm_connector_unregister_all(dev);
	return ret;
}
EXPORT_SYMBOL(drm_connector_register_all);

1102
/**
1103
 * drm_connector_unregister_all - unregister connector userspace interfaces
1104 1105
 * @dev: drm device
 *
1106 1107 1108 1109 1110
 * This functions unregisters all connectors from sysfs and other places so
 * that userspace can no longer access them. Drivers should call this as the
 * first step tearing down the device instace, or when the underlying
 * physical device disappeared (e.g. USB unplug), right before calling
 * drm_dev_unregister().
1111
 */
1112
void drm_connector_unregister_all(struct drm_device *dev)
1113 1114 1115
{
	struct drm_connector *connector;

1116
	/* FIXME: taking the mode config mutex ends up in a clash with sysfs */
1117
	list_for_each_entry(connector, &dev->mode_config.connector_list, head)
1118
		drm_connector_unregister(connector);
1119
}
1120
EXPORT_SYMBOL(drm_connector_unregister_all);
1121

1122 1123 1124 1125 1126 1127
/**
 * 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
1128
 * @name: printf style format string for the encoder name, or NULL for default name
1129 1130 1131 1132 1133 1134 1135
 *
 * Initialises a preallocated encoder. Encoder should be
 * subclassed as part of driver encoder objects.
 *
 * Returns:
 * Zero on success, error code on failure.
 */
1136
int drm_encoder_init(struct drm_device *dev,
1137 1138
		      struct drm_encoder *encoder,
		      const struct drm_encoder_funcs *funcs,
1139
		      int encoder_type, const char *name, ...)
D
Dave Airlie 已提交
1140
{
1141 1142
	int ret;

1143
	drm_modeset_lock_all(dev);
D
Dave Airlie 已提交
1144

1145 1146
	ret = drm_mode_object_get(dev, &encoder->base, DRM_MODE_OBJECT_ENCODER);
	if (ret)
1147
		goto out_unlock;
D
Dave Airlie 已提交
1148

1149
	encoder->dev = dev;
D
Dave Airlie 已提交
1150 1151
	encoder->encoder_type = encoder_type;
	encoder->funcs = funcs;
1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162
	if (name) {
		va_list ap;

		va_start(ap, name);
		encoder->name = kvasprintf(GFP_KERNEL, name, ap);
		va_end(ap);
	} else {
		encoder->name = kasprintf(GFP_KERNEL, "%s-%d",
					  drm_encoder_enum_list[encoder_type].name,
					  encoder->base.id);
	}
1163 1164 1165 1166
	if (!encoder->name) {
		ret = -ENOMEM;
		goto out_put;
	}
D
Dave Airlie 已提交
1167 1168 1169 1170

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

1171 1172
out_put:
	if (ret)
1173
		drm_mode_object_unregister(dev, &encoder->base);
1174 1175

out_unlock:
1176
	drm_modeset_unlock_all(dev);
1177 1178

	return ret;
D
Dave Airlie 已提交
1179 1180 1181
}
EXPORT_SYMBOL(drm_encoder_init);

1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204
/**
 * drm_encoder_index - find the index of a registered encoder
 * @encoder: encoder to find index for
 *
 * Given a registered encoder, return the index of that encoder within a DRM
 * device's list of encoders.
 */
unsigned int drm_encoder_index(struct drm_encoder *encoder)
{
	unsigned int index = 0;
	struct drm_encoder *tmp;

	drm_for_each_encoder(tmp, encoder->dev) {
		if (tmp == encoder)
			return index;

		index++;
	}

	BUG();
}
EXPORT_SYMBOL(drm_encoder_index);

1205 1206 1207 1208 1209 1210
/**
 * 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 已提交
1211 1212 1213
void drm_encoder_cleanup(struct drm_encoder *encoder)
{
	struct drm_device *dev = encoder->dev;
1214

1215
	drm_modeset_lock_all(dev);
1216
	drm_mode_object_unregister(dev, &encoder->base);
1217
	kfree(encoder->name);
D
Dave Airlie 已提交
1218
	list_del(&encoder->head);
1219
	dev->mode_config.num_encoder--;
1220
	drm_modeset_unlock_all(dev);
1221 1222

	memset(encoder, 0, sizeof(*encoder));
D
Dave Airlie 已提交
1223 1224 1225
}
EXPORT_SYMBOL(drm_encoder_cleanup);

1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237
static unsigned int drm_num_planes(struct drm_device *dev)
{
	unsigned int num = 0;
	struct drm_plane *tmp;

	drm_for_each_plane(tmp, dev) {
		num++;
	}

	return num;
}

1238
/**
M
Matt Roper 已提交
1239
 * drm_universal_plane_init - Initialize a new universal plane object
1240 1241 1242 1243 1244 1245
 * @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 已提交
1246
 * @type: type of plane (overlay, primary, cursor)
1247
 * @name: printf style format string for the plane name, or NULL for default name
1248
 *
M
Matt Roper 已提交
1249
 * Initializes a plane object of type @type.
1250
 *
1251
 * Returns:
1252 1253
 * Zero on success, error code on failure.
 */
M
Matt Roper 已提交
1254 1255 1256
int drm_universal_plane_init(struct drm_device *dev, struct drm_plane *plane,
			     unsigned long possible_crtcs,
			     const struct drm_plane_funcs *funcs,
1257
			     const uint32_t *formats, unsigned int format_count,
1258 1259
			     enum drm_plane_type type,
			     const char *name, ...)
J
Jesse Barnes 已提交
1260
{
R
Rob Clark 已提交
1261
	struct drm_mode_config *config = &dev->mode_config;
1262 1263 1264 1265
	int ret;

	ret = drm_mode_object_get(dev, &plane->base, DRM_MODE_OBJECT_PLANE);
	if (ret)
1266
		return ret;
1267

D
Daniel Vetter 已提交
1268 1269
	drm_modeset_lock_init(&plane->mutex);

R
Rob Clark 已提交
1270
	plane->base.properties = &plane->properties;
J
Jesse Barnes 已提交
1271 1272
	plane->dev = dev;
	plane->funcs = funcs;
1273 1274
	plane->format_types = kmalloc_array(format_count, sizeof(uint32_t),
					    GFP_KERNEL);
J
Jesse Barnes 已提交
1275 1276
	if (!plane->format_types) {
		DRM_DEBUG_KMS("out of memory when allocating plane\n");
1277
		drm_mode_object_unregister(dev, &plane->base);
1278
		return -ENOMEM;
J
Jesse Barnes 已提交
1279 1280
	}

1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292
	if (name) {
		va_list ap;

		va_start(ap, name);
		plane->name = kvasprintf(GFP_KERNEL, name, ap);
		va_end(ap);
	} else {
		plane->name = kasprintf(GFP_KERNEL, "plane-%d",
					drm_num_planes(dev));
	}
	if (!plane->name) {
		kfree(plane->format_types);
1293
		drm_mode_object_unregister(dev, &plane->base);
1294 1295 1296
		return -ENOMEM;
	}

1297
	memcpy(plane->format_types, formats, format_count * sizeof(uint32_t));
J
Jesse Barnes 已提交
1298 1299
	plane->format_count = format_count;
	plane->possible_crtcs = possible_crtcs;
M
Matt Roper 已提交
1300
	plane->type = type;
J
Jesse Barnes 已提交
1301

R
Rob Clark 已提交
1302 1303
	list_add_tail(&plane->head, &config->plane_list);
	config->num_total_plane++;
M
Matt Roper 已提交
1304
	if (plane->type == DRM_PLANE_TYPE_OVERLAY)
R
Rob Clark 已提交
1305
		config->num_overlay_plane++;
J
Jesse Barnes 已提交
1306

R
Rob Clark 已提交
1307
	drm_object_attach_property(&plane->base,
R
Rob Clark 已提交
1308
				   config->plane_type_property,
R
Rob Clark 已提交
1309 1310
				   plane->type);

R
Rob Clark 已提交
1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323
	if (drm_core_check_feature(dev, DRIVER_ATOMIC)) {
		drm_object_attach_property(&plane->base, config->prop_fb_id, 0);
		drm_object_attach_property(&plane->base, config->prop_crtc_id, 0);
		drm_object_attach_property(&plane->base, config->prop_crtc_x, 0);
		drm_object_attach_property(&plane->base, config->prop_crtc_y, 0);
		drm_object_attach_property(&plane->base, config->prop_crtc_w, 0);
		drm_object_attach_property(&plane->base, config->prop_crtc_h, 0);
		drm_object_attach_property(&plane->base, config->prop_src_x, 0);
		drm_object_attach_property(&plane->base, config->prop_src_y, 0);
		drm_object_attach_property(&plane->base, config->prop_src_w, 0);
		drm_object_attach_property(&plane->base, config->prop_src_h, 0);
	}

1324
	return 0;
J
Jesse Barnes 已提交
1325
}
M
Matt Roper 已提交
1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347
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,
1348
		   const uint32_t *formats, unsigned int format_count,
M
Matt Roper 已提交
1349 1350 1351 1352 1353 1354
		   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,
1355
					formats, format_count, type, NULL);
M
Matt Roper 已提交
1356
}
J
Jesse Barnes 已提交
1357 1358
EXPORT_SYMBOL(drm_plane_init);

1359 1360 1361 1362 1363 1364 1365 1366
/**
 * 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 已提交
1367 1368 1369 1370
void drm_plane_cleanup(struct drm_plane *plane)
{
	struct drm_device *dev = plane->dev;

1371
	drm_modeset_lock_all(dev);
J
Jesse Barnes 已提交
1372
	kfree(plane->format_types);
1373
	drm_mode_object_unregister(dev, &plane->base);
M
Matt Roper 已提交
1374 1375 1376 1377 1378 1379 1380

	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--;
1381
	drm_modeset_unlock_all(dev);
1382 1383 1384 1385

	WARN_ON(plane->state && !plane->funcs->atomic_destroy_state);
	if (plane->state && plane->funcs->atomic_destroy_state)
		plane->funcs->atomic_destroy_state(plane, plane->state);
1386

1387 1388
	kfree(plane->name);

1389
	memset(plane, 0, sizeof(*plane));
J
Jesse Barnes 已提交
1390 1391 1392
}
EXPORT_SYMBOL(drm_plane_cleanup);

1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404
/**
 * drm_plane_index - find the index of a registered plane
 * @plane: plane to find index for
 *
 * Given a registered plane, return the index of that CRTC within a DRM
 * device's list of planes.
 */
unsigned int drm_plane_index(struct drm_plane *plane)
{
	unsigned int index = 0;
	struct drm_plane *tmp;

1405
	drm_for_each_plane(tmp, plane->dev) {
1406 1407 1408 1409 1410 1411 1412 1413 1414 1415
		if (tmp == plane)
			return index;

		index++;
	}

	BUG();
}
EXPORT_SYMBOL(drm_plane_index);

1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429
/**
 * drm_plane_from_index - find the registered plane at an index
 * @dev: DRM device
 * @idx: index of registered plane to find for
 *
 * Given a plane index, return the registered plane from DRM device's
 * list of planes with matching index.
 */
struct drm_plane *
drm_plane_from_index(struct drm_device *dev, int idx)
{
	struct drm_plane *plane;
	unsigned int i = 0;

1430
	drm_for_each_plane(plane, dev) {
1431 1432 1433 1434 1435 1436 1437 1438
		if (i == idx)
			return plane;
		i++;
	}
	return NULL;
}
EXPORT_SYMBOL(drm_plane_from_index);

1439 1440 1441 1442 1443 1444 1445 1446 1447
/**
 * 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.
 */
1448 1449 1450 1451
void drm_plane_force_disable(struct drm_plane *plane)
{
	int ret;

1452
	if (!plane->fb)
1453 1454
		return;

1455
	plane->old_fb = plane->fb;
1456
	ret = plane->funcs->disable_plane(plane);
1457
	if (ret) {
1458
		DRM_ERROR("failed to disable plane with busy fb\n");
1459
		plane->old_fb = NULL;
1460 1461
		return;
	}
1462
	/* disconnect the plane from the fb and crtc: */
1463
	drm_framebuffer_unreference(plane->old_fb);
1464
	plane->old_fb = NULL;
1465 1466 1467 1468 1469
	plane->fb = NULL;
	plane->crtc = NULL;
}
EXPORT_SYMBOL(drm_plane_force_disable);

R
Rob Clark 已提交
1470
static int drm_mode_create_standard_properties(struct drm_device *dev)
D
Dave Airlie 已提交
1471
{
R
Rob Clark 已提交
1472
	struct drm_property *prop;
D
Dave Airlie 已提交
1473 1474 1475 1476

	/*
	 * Standard properties (apply to all connectors)
	 */
R
Rob Clark 已提交
1477
	prop = drm_property_create(dev, DRM_MODE_PROP_BLOB |
D
Dave Airlie 已提交
1478 1479
				   DRM_MODE_PROP_IMMUTABLE,
				   "EDID", 0);
R
Rob Clark 已提交
1480 1481 1482
	if (!prop)
		return -ENOMEM;
	dev->mode_config.edid_property = prop;
D
Dave Airlie 已提交
1483

R
Rob Clark 已提交
1484
	prop = drm_property_create_enum(dev, 0,
1485 1486
				   "DPMS", drm_dpms_enum_list,
				   ARRAY_SIZE(drm_dpms_enum_list));
R
Rob Clark 已提交
1487 1488 1489
	if (!prop)
		return -ENOMEM;
	dev->mode_config.dpms_property = prop;
1490

R
Rob Clark 已提交
1491 1492 1493 1494 1495 1496 1497
	prop = drm_property_create(dev,
				   DRM_MODE_PROP_BLOB |
				   DRM_MODE_PROP_IMMUTABLE,
				   "PATH", 0);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.path_property = prop;
D
Dave Airlie 已提交
1498

R
Rob Clark 已提交
1499 1500 1501 1502 1503 1504 1505
	prop = drm_property_create(dev,
				   DRM_MODE_PROP_BLOB |
				   DRM_MODE_PROP_IMMUTABLE,
				   "TILE", 0);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.tile_property = prop;
R
Rob Clark 已提交
1506

R
Rob Clark 已提交
1507
	prop = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
R
Rob Clark 已提交
1508 1509
					"type", drm_plane_type_enum_list,
					ARRAY_SIZE(drm_plane_type_enum_list));
R
Rob Clark 已提交
1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572
	if (!prop)
		return -ENOMEM;
	dev->mode_config.plane_type_property = prop;

	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
			"SRC_X", 0, UINT_MAX);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.prop_src_x = prop;

	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
			"SRC_Y", 0, UINT_MAX);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.prop_src_y = prop;

	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
			"SRC_W", 0, UINT_MAX);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.prop_src_w = prop;

	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
			"SRC_H", 0, UINT_MAX);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.prop_src_h = prop;

	prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
			"CRTC_X", INT_MIN, INT_MAX);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.prop_crtc_x = prop;

	prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
			"CRTC_Y", INT_MIN, INT_MAX);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.prop_crtc_y = prop;

	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
			"CRTC_W", 0, INT_MAX);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.prop_crtc_w = prop;

	prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
			"CRTC_H", 0, INT_MAX);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.prop_crtc_h = prop;

	prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC,
			"FB_ID", DRM_MODE_OBJECT_FB);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.prop_fb_id = prop;

	prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC,
			"CRTC_ID", DRM_MODE_OBJECT_CRTC);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.prop_crtc_id = prop;
R
Rob Clark 已提交
1573

1574 1575 1576 1577 1578 1579
	prop = drm_property_create_bool(dev, DRM_MODE_PROP_ATOMIC,
			"ACTIVE");
	if (!prop)
		return -ENOMEM;
	dev->mode_config.prop_active = prop;

D
Daniel Stone 已提交
1580 1581 1582 1583 1584 1585 1586
	prop = drm_property_create(dev,
			DRM_MODE_PROP_ATOMIC | DRM_MODE_PROP_BLOB,
			"MODE_ID", 0);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.prop_mode_id = prop;

1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621
	prop = drm_property_create(dev,
			DRM_MODE_PROP_BLOB,
			"DEGAMMA_LUT", 0);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.degamma_lut_property = prop;

	prop = drm_property_create_range(dev,
			DRM_MODE_PROP_IMMUTABLE,
			"DEGAMMA_LUT_SIZE", 0, UINT_MAX);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.degamma_lut_size_property = prop;

	prop = drm_property_create(dev,
			DRM_MODE_PROP_BLOB,
			"CTM", 0);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.ctm_property = prop;

	prop = drm_property_create(dev,
			DRM_MODE_PROP_BLOB,
			"GAMMA_LUT", 0);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.gamma_lut_property = prop;

	prop = drm_property_create_range(dev,
			DRM_MODE_PROP_IMMUTABLE,
			"GAMMA_LUT_SIZE", 0, UINT_MAX);
	if (!prop)
		return -ENOMEM;
	dev->mode_config.gamma_lut_size_property = prop;

R
Rob Clark 已提交
1622 1623 1624
	return 0;
}

D
Dave Airlie 已提交
1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639
/**
 * 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 =
1640
		drm_property_create_enum(dev, 0,
D
Dave Airlie 已提交
1641
				    "select subconnector",
1642
				    drm_dvi_i_select_enum_list,
D
Dave Airlie 已提交
1643 1644 1645
				    ARRAY_SIZE(drm_dvi_i_select_enum_list));
	dev->mode_config.dvi_i_select_subconnector_property = dvi_i_selector;

1646
	dvi_i_subconnector = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
D
Dave Airlie 已提交
1647
				    "subconnector",
1648
				    drm_dvi_i_subconnector_enum_list,
D
Dave Airlie 已提交
1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666
				    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.
 */
1667 1668
int drm_mode_create_tv_properties(struct drm_device *dev,
				  unsigned int num_modes,
V
Ville Syrjälä 已提交
1669
				  const char * const modes[])
D
Dave Airlie 已提交
1670 1671 1672
{
	struct drm_property *tv_selector;
	struct drm_property *tv_subconnector;
1673
	unsigned int i;
D
Dave Airlie 已提交
1674 1675 1676 1677 1678 1679 1680

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

	/*
	 * Basic connector properties
	 */
1681
	tv_selector = drm_property_create_enum(dev, 0,
D
Dave Airlie 已提交
1682
					  "select subconnector",
1683
					  drm_tv_select_enum_list,
D
Dave Airlie 已提交
1684
					  ARRAY_SIZE(drm_tv_select_enum_list));
I
Insu Yun 已提交
1685 1686 1687
	if (!tv_selector)
		goto nomem;

D
Dave Airlie 已提交
1688 1689 1690
	dev->mode_config.tv_select_subconnector_property = tv_selector;

	tv_subconnector =
1691 1692 1693
		drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
				    "subconnector",
				    drm_tv_subconnector_enum_list,
D
Dave Airlie 已提交
1694
				    ARRAY_SIZE(drm_tv_subconnector_enum_list));
I
Insu Yun 已提交
1695 1696
	if (!tv_subconnector)
		goto nomem;
D
Dave Airlie 已提交
1697 1698 1699 1700 1701 1702
	dev->mode_config.tv_subconnector_property = tv_subconnector;

	/*
	 * Other, TV specific properties: margins & TV modes.
	 */
	dev->mode_config.tv_left_margin_property =
1703
		drm_property_create_range(dev, 0, "left margin", 0, 100);
I
Insu Yun 已提交
1704 1705
	if (!dev->mode_config.tv_left_margin_property)
		goto nomem;
D
Dave Airlie 已提交
1706 1707

	dev->mode_config.tv_right_margin_property =
1708
		drm_property_create_range(dev, 0, "right margin", 0, 100);
I
Insu Yun 已提交
1709 1710
	if (!dev->mode_config.tv_right_margin_property)
		goto nomem;
D
Dave Airlie 已提交
1711 1712

	dev->mode_config.tv_top_margin_property =
1713
		drm_property_create_range(dev, 0, "top margin", 0, 100);
I
Insu Yun 已提交
1714 1715
	if (!dev->mode_config.tv_top_margin_property)
		goto nomem;
D
Dave Airlie 已提交
1716 1717

	dev->mode_config.tv_bottom_margin_property =
1718
		drm_property_create_range(dev, 0, "bottom margin", 0, 100);
I
Insu Yun 已提交
1719 1720
	if (!dev->mode_config.tv_bottom_margin_property)
		goto nomem;
D
Dave Airlie 已提交
1721 1722 1723 1724

	dev->mode_config.tv_mode_property =
		drm_property_create(dev, DRM_MODE_PROP_ENUM,
				    "mode", num_modes);
I
Insu Yun 已提交
1725 1726 1727
	if (!dev->mode_config.tv_mode_property)
		goto nomem;

D
Dave Airlie 已提交
1728 1729 1730 1731
	for (i = 0; i < num_modes; i++)
		drm_property_add_enum(dev->mode_config.tv_mode_property, i,
				      i, modes[i]);

1732
	dev->mode_config.tv_brightness_property =
1733
		drm_property_create_range(dev, 0, "brightness", 0, 100);
I
Insu Yun 已提交
1734 1735
	if (!dev->mode_config.tv_brightness_property)
		goto nomem;
1736 1737

	dev->mode_config.tv_contrast_property =
1738
		drm_property_create_range(dev, 0, "contrast", 0, 100);
I
Insu Yun 已提交
1739 1740
	if (!dev->mode_config.tv_contrast_property)
		goto nomem;
1741 1742

	dev->mode_config.tv_flicker_reduction_property =
1743
		drm_property_create_range(dev, 0, "flicker reduction", 0, 100);
I
Insu Yun 已提交
1744 1745
	if (!dev->mode_config.tv_flicker_reduction_property)
		goto nomem;
1746

1747
	dev->mode_config.tv_overscan_property =
1748
		drm_property_create_range(dev, 0, "overscan", 0, 100);
I
Insu Yun 已提交
1749 1750
	if (!dev->mode_config.tv_overscan_property)
		goto nomem;
1751 1752

	dev->mode_config.tv_saturation_property =
1753
		drm_property_create_range(dev, 0, "saturation", 0, 100);
I
Insu Yun 已提交
1754 1755
	if (!dev->mode_config.tv_saturation_property)
		goto nomem;
1756 1757

	dev->mode_config.tv_hue_property =
1758
		drm_property_create_range(dev, 0, "hue", 0, 100);
I
Insu Yun 已提交
1759 1760
	if (!dev->mode_config.tv_hue_property)
		goto nomem;
1761

D
Dave Airlie 已提交
1762
	return 0;
I
Insu Yun 已提交
1763 1764
nomem:
	return -ENOMEM;
D
Dave Airlie 已提交
1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782
}
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 =
1783 1784
		drm_property_create_enum(dev, 0, "scaling mode",
				drm_scaling_mode_enum_list,
D
Dave Airlie 已提交
1785 1786 1787 1788 1789 1790 1791 1792
				    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);

1793 1794 1795 1796 1797 1798 1799 1800
/**
 * drm_mode_create_aspect_ratio_property - create aspect ratio property
 * @dev: DRM device
 *
 * Called by a driver the first time it's needed, must be attached to desired
 * connectors.
 *
 * Returns:
D
Daniel Vetter 已提交
1801
 * Zero on success, negative errno on failure.
1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819
 */
int drm_mode_create_aspect_ratio_property(struct drm_device *dev)
{
	if (dev->mode_config.aspect_ratio_property)
		return 0;

	dev->mode_config.aspect_ratio_property =
		drm_property_create_enum(dev, 0, "aspect ratio",
				drm_aspect_ratio_enum_list,
				ARRAY_SIZE(drm_aspect_ratio_enum_list));

	if (dev->mode_config.aspect_ratio_property == NULL)
		return -ENOMEM;

	return 0;
}
EXPORT_SYMBOL(drm_mode_create_aspect_ratio_property);

1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834
/**
 * 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 =
1835
		drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
1836
				    "dirty",
1837
				    drm_dirty_info_enum_list,
1838 1839 1840 1841 1842 1843 1844
				    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);

1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868
/**
 * drm_mode_create_suggested_offset_properties - create suggests offset properties
 * @dev: DRM device
 *
 * Create the the suggested x/y offset property for connectors.
 */
int drm_mode_create_suggested_offset_properties(struct drm_device *dev)
{
	if (dev->mode_config.suggested_x_property && dev->mode_config.suggested_y_property)
		return 0;

	dev->mode_config.suggested_x_property =
		drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE, "suggested X", 0, 0xffffffff);

	dev->mode_config.suggested_y_property =
		drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE, "suggested Y", 0, 0xffffffff);

	if (dev->mode_config.suggested_x_property == NULL ||
	    dev->mode_config.suggested_y_property == NULL)
		return -ENOMEM;
	return 0;
}
EXPORT_SYMBOL(drm_mode_create_suggested_offset_properties);

D
Dave Airlie 已提交
1869 1870
/**
 * drm_mode_getresources - get graphics configuration
1871 1872 1873
 * @dev: drm device for the ioctl
 * @data: data pointer for the ioctl
 * @file_priv: drm file for the ioctl call
D
Dave Airlie 已提交
1874 1875 1876 1877 1878 1879
 *
 * 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.
 *
1880
 * Returns:
D
Daniel Vetter 已提交
1881
 * Zero on success, negative errno on failure.
D
Dave Airlie 已提交
1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896
 */
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;
1897
	int copied = 0;
D
Dave Airlie 已提交
1898 1899 1900 1901 1902
	uint32_t __user *fb_id;
	uint32_t __user *crtc_id;
	uint32_t __user *connector_id;
	uint32_t __user *encoder_id;

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

D
Dave Airlie 已提交
1906

1907
	mutex_lock(&file_priv->fbs_lock);
D
Dave Airlie 已提交
1908 1909 1910 1911 1912 1913 1914
	/*
	 * 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++;

1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930
	/* 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);

1931 1932 1933
	/* mode_config.mutex protects the connector list against e.g. DP MST
	 * connector hot-adding. CRTC/Plane lists are invariant. */
	mutex_lock(&dev->mode_config.mutex);
1934 1935
	drm_for_each_crtc(crtc, dev)
		crtc_count++;
D
Dave Airlie 已提交
1936

1937 1938
	drm_for_each_connector(connector, dev)
		connector_count++;
D
Dave Airlie 已提交
1939

1940 1941
	drm_for_each_encoder(encoder, dev)
		encoder_count++;
D
Dave Airlie 已提交
1942 1943 1944 1945 1946 1947 1948 1949 1950 1951

	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;
1952 1953 1954 1955
		drm_for_each_crtc(crtc, dev) {
			if (put_user(crtc->base.id, crtc_id + copied)) {
				ret = -EFAULT;
				goto out;
D
Dave Airlie 已提交
1956
			}
1957
			copied++;
D
Dave Airlie 已提交
1958 1959 1960 1961 1962 1963 1964 1965
		}
	}
	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;
1966 1967 1968 1969 1970
		drm_for_each_encoder(encoder, dev) {
			if (put_user(encoder->base.id, encoder_id +
				     copied)) {
				ret = -EFAULT;
				goto out;
D
Dave Airlie 已提交
1971
			}
1972
			copied++;
D
Dave Airlie 已提交
1973 1974 1975 1976 1977 1978 1979 1980
		}
	}
	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;
1981 1982 1983 1984 1985
		drm_for_each_connector(connector, dev) {
			if (put_user(connector->base.id,
				     connector_id + copied)) {
				ret = -EFAULT;
				goto out;
D
Dave Airlie 已提交
1986
			}
1987
			copied++;
D
Dave Airlie 已提交
1988 1989 1990 1991 1992
		}
	}
	card_res->count_connectors = connector_count;

out:
1993
	mutex_unlock(&dev->mode_config.mutex);
D
Dave Airlie 已提交
1994 1995 1996 1997 1998
	return ret;
}

/**
 * drm_mode_getcrtc - get CRTC configuration
1999 2000 2001
 * @dev: drm device for the ioctl
 * @data: data pointer for the ioctl
 * @file_priv: drm file for the ioctl call
D
Dave Airlie 已提交
2002 2003 2004 2005 2006
 *
 * Construct a CRTC configuration structure to return to the user.
 *
 * Called by the user via ioctl.
 *
2007
 * Returns:
D
Daniel Vetter 已提交
2008
 * Zero on success, negative errno on failure.
D
Dave Airlie 已提交
2009 2010 2011 2012 2013 2014 2015
 */
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;

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

R
Rob Clark 已提交
2019
	crtc = drm_crtc_find(dev, crtc_resp->crtc_id);
2020 2021
	if (!crtc)
		return -ENOENT;
D
Dave Airlie 已提交
2022

2023
	drm_modeset_lock_crtc(crtc, crtc->primary);
D
Dave Airlie 已提交
2024
	crtc_resp->gamma_size = crtc->gamma_size;
2025 2026
	if (crtc->primary->fb)
		crtc_resp->fb_id = crtc->primary->fb->base.id;
D
Dave Airlie 已提交
2027 2028 2029
	else
		crtc_resp->fb_id = 0;

2030 2031 2032 2033
	if (crtc->state) {
		crtc_resp->x = crtc->primary->state->src_x >> 16;
		crtc_resp->y = crtc->primary->state->src_y >> 16;
		if (crtc->state->enable) {
2034
			drm_mode_convert_to_umode(&crtc_resp->mode, &crtc->state->mode);
2035
			crtc_resp->mode_valid = 1;
D
Dave Airlie 已提交
2036

2037 2038 2039
		} else {
			crtc_resp->mode_valid = 0;
		}
D
Dave Airlie 已提交
2040
	} else {
2041 2042 2043
		crtc_resp->x = crtc->x;
		crtc_resp->y = crtc->y;
		if (crtc->enabled) {
2044
			drm_mode_convert_to_umode(&crtc_resp->mode, &crtc->mode);
2045 2046 2047 2048 2049
			crtc_resp->mode_valid = 1;

		} else {
			crtc_resp->mode_valid = 0;
		}
D
Dave Airlie 已提交
2050
	}
2051
	drm_modeset_unlock_crtc(crtc);
D
Dave Airlie 已提交
2052

2053
	return 0;
D
Dave Airlie 已提交
2054 2055
}

2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068
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;
}

2069 2070 2071 2072 2073 2074 2075 2076 2077
static struct drm_encoder *drm_connector_get_encoder(struct drm_connector *connector)
{
	/* For atomic drivers only state objects are synchronously updated and
	 * protected by modeset locks, so check those first. */
	if (connector->state)
		return connector->state->best_encoder;
	return connector->encoder;
}

2078
/* helper for getconnector and getproperties ioctls */
R
Rob Clark 已提交
2079
static int get_properties(struct drm_mode_object *obj, bool atomic,
2080 2081 2082
		uint32_t __user *prop_ptr, uint64_t __user *prop_values,
		uint32_t *arg_count_props)
{
R
Rob Clark 已提交
2083 2084 2085 2086 2087 2088
	int props_count;
	int i, ret, copied;

	props_count = obj->properties->count;
	if (!atomic)
		props_count -= obj->properties->atomic_count;
2089 2090

	if ((*arg_count_props >= props_count) && props_count) {
R
Rob Clark 已提交
2091
		for (i = 0, copied = 0; copied < props_count; i++) {
2092 2093 2094
			struct drm_property *prop = obj->properties->properties[i];
			uint64_t val;

R
Rob Clark 已提交
2095 2096 2097
			if ((prop->flags & DRM_MODE_PROP_ATOMIC) && !atomic)
				continue;

2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115
			ret = drm_object_property_get_value(obj, prop, &val);
			if (ret)
				return ret;

			if (put_user(prop->base.id, prop_ptr + copied))
				return -EFAULT;

			if (put_user(val, prop_values + copied))
				return -EFAULT;

			copied++;
		}
	}
	*arg_count_props = props_count;

	return 0;
}

D
Dave Airlie 已提交
2116 2117
/**
 * drm_mode_getconnector - get connector configuration
2118 2119 2120
 * @dev: drm device for the ioctl
 * @data: data pointer for the ioctl
 * @file_priv: drm file for the ioctl call
D
Dave Airlie 已提交
2121 2122 2123 2124 2125
 *
 * Construct a connector configuration structure to return to the user.
 *
 * Called by the user via ioctl.
 *
2126
 * Returns:
D
Daniel Vetter 已提交
2127
 * Zero on success, negative errno on failure.
D
Dave Airlie 已提交
2128 2129 2130 2131 2132 2133
 */
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;
2134
	struct drm_encoder *encoder;
D
Dave Airlie 已提交
2135 2136 2137 2138 2139 2140 2141 2142 2143 2144
	struct drm_display_mode *mode;
	int mode_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 *encoder_ptr;

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

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

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

2152
	connector = drm_connector_lookup(dev, out_resp->connector_id);
R
Rob Clark 已提交
2153
	if (!connector) {
2154
		ret = -ENOENT;
2155
		goto out_unlock;
D
Dave Airlie 已提交
2156 2157
	}

2158 2159
	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++)
		if (connector->encoder_ids[i] != 0)
D
Dave Airlie 已提交
2160 2161 2162 2163 2164 2165 2166 2167 2168 2169
			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)
2170 2171
		if (drm_mode_expose_to_userspace(mode, file_priv))
			mode_count++;
D
Dave Airlie 已提交
2172 2173 2174 2175 2176 2177 2178 2179

	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;
2180 2181

	drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
2182 2183 2184
	encoder = drm_connector_get_encoder(connector);
	if (encoder)
		out_resp->encoder_id = encoder->base.id;
D
Dave Airlie 已提交
2185 2186 2187 2188 2189 2190 2191 2192 2193
	else
		out_resp->encoder_id = 0;

	/*
	 * 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ä 已提交
2194
		mode_ptr = (struct drm_mode_modeinfo __user *)(unsigned long)out_resp->modes_ptr;
D
Dave Airlie 已提交
2195
		list_for_each_entry(mode, &connector->modes, head) {
2196 2197 2198
			if (!drm_mode_expose_to_userspace(mode, file_priv))
				continue;

2199
			drm_mode_convert_to_umode(&u_mode, mode);
D
Dave Airlie 已提交
2200 2201 2202 2203 2204 2205 2206 2207 2208 2209
			if (copy_to_user(mode_ptr + copied,
					 &u_mode, sizeof(u_mode))) {
				ret = -EFAULT;
				goto out;
			}
			copied++;
		}
	}
	out_resp->count_modes = mode_count;

R
Rob Clark 已提交
2210
	ret = get_properties(&connector->base, file_priv->atomic,
2211 2212 2213 2214 2215
			(uint32_t __user *)(unsigned long)(out_resp->props_ptr),
			(uint64_t __user *)(unsigned long)(out_resp->prop_values_ptr),
			&out_resp->count_props);
	if (ret)
		goto out;
D
Dave Airlie 已提交
2216 2217 2218

	if ((out_resp->count_encoders >= encoders_count) && encoders_count) {
		copied = 0;
V
Ville Syrjälä 已提交
2219
		encoder_ptr = (uint32_t __user *)(unsigned long)(out_resp->encoders_ptr);
D
Dave Airlie 已提交
2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233
		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:
R
Rob Clark 已提交
2234
	drm_modeset_unlock(&dev->mode_config.connection_mutex);
2235

2236
	drm_connector_unreference(connector);
2237
out_unlock:
2238 2239
	mutex_unlock(&dev->mode_config.mutex);

D
Dave Airlie 已提交
2240 2241 2242
	return ret;
}

2243 2244 2245 2246 2247 2248 2249 2250
static struct drm_crtc *drm_encoder_get_crtc(struct drm_encoder *encoder)
{
	struct drm_connector *connector;
	struct drm_device *dev = encoder->dev;
	bool uses_atomic = false;

	/* For atomic drivers only state objects are synchronously updated and
	 * protected by modeset locks, so check those first. */
2251
	drm_for_each_connector(connector, dev) {
2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269
		if (!connector->state)
			continue;

		uses_atomic = true;

		if (connector->state->best_encoder != encoder)
			continue;

		return connector->state->crtc;
	}

	/* Don't return stale data (e.g. pending async disable). */
	if (uses_atomic)
		return NULL;

	return encoder->crtc;
}

2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280
/**
 * 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:
D
Daniel Vetter 已提交
2281
 * Zero on success, negative errno on failure.
2282
 */
D
Dave Airlie 已提交
2283 2284 2285 2286 2287
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;
2288
	struct drm_crtc *crtc;
D
Dave Airlie 已提交
2289

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

R
Rob Clark 已提交
2293
	encoder = drm_encoder_find(dev, enc_resp->encoder_id);
2294 2295
	if (!encoder)
		return -ENOENT;
D
Dave Airlie 已提交
2296

2297
	drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
2298 2299 2300
	crtc = drm_encoder_get_crtc(encoder);
	if (crtc)
		enc_resp->crtc_id = crtc->base.id;
D
Dave Airlie 已提交
2301 2302
	else
		enc_resp->crtc_id = 0;
2303 2304
	drm_modeset_unlock(&dev->mode_config.connection_mutex);

D
Dave Airlie 已提交
2305 2306 2307 2308 2309
	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;

2310
	return 0;
D
Dave Airlie 已提交
2311 2312
}

J
Jesse Barnes 已提交
2313
/**
2314
 * drm_mode_getplane_res - enumerate all plane resources
J
Jesse Barnes 已提交
2315 2316 2317 2318
 * @dev: DRM device
 * @data: ioctl data
 * @file_priv: DRM file info
 *
2319 2320 2321 2322 2323
 * Construct a list of plane ids to return to the user.
 *
 * Called by the user via ioctl.
 *
 * Returns:
D
Daniel Vetter 已提交
2324
 * Zero on success, negative errno on failure.
J
Jesse Barnes 已提交
2325 2326
 */
int drm_mode_getplane_res(struct drm_device *dev, void *data,
2327
			  struct drm_file *file_priv)
J
Jesse Barnes 已提交
2328 2329 2330 2331 2332
{
	struct drm_mode_get_plane_res *plane_resp = data;
	struct drm_mode_config *config;
	struct drm_plane *plane;
	uint32_t __user *plane_ptr;
2333
	int copied = 0;
2334
	unsigned num_planes;
J
Jesse Barnes 已提交
2335 2336 2337 2338 2339 2340

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

	config = &dev->mode_config;

2341 2342 2343 2344 2345
	if (file_priv->universal_planes)
		num_planes = config->num_total_plane;
	else
		num_planes = config->num_overlay_plane;

J
Jesse Barnes 已提交
2346 2347 2348 2349
	/*
	 * This ioctl is called twice, once to determine how much space is
	 * needed, and the 2nd time to fill it.
	 */
2350 2351
	if (num_planes &&
	    (plane_resp->count_planes >= num_planes)) {
V
Ville Syrjälä 已提交
2352
		plane_ptr = (uint32_t __user *)(unsigned long)plane_resp->plane_id_ptr;
J
Jesse Barnes 已提交
2353

2354
		/* Plane lists are invariant, no locking needed. */
2355
		drm_for_each_plane(plane, dev) {
2356 2357 2358 2359 2360 2361
			/*
			 * Unless userspace set the 'universal planes'
			 * capability bit, only advertise overlays.
			 */
			if (plane->type != DRM_PLANE_TYPE_OVERLAY &&
			    !file_priv->universal_planes)
2362 2363
				continue;

2364 2365
			if (put_user(plane->base.id, plane_ptr + copied))
				return -EFAULT;
J
Jesse Barnes 已提交
2366 2367 2368
			copied++;
		}
	}
2369
	plane_resp->count_planes = num_planes;
J
Jesse Barnes 已提交
2370

2371
	return 0;
J
Jesse Barnes 已提交
2372 2373 2374
}

/**
2375
 * drm_mode_getplane - get plane configuration
J
Jesse Barnes 已提交
2376 2377 2378 2379
 * @dev: DRM device
 * @data: ioctl data
 * @file_priv: DRM file info
 *
2380 2381 2382 2383 2384
 * Construct a plane configuration structure to return to the user.
 *
 * Called by the user via ioctl.
 *
 * Returns:
D
Daniel Vetter 已提交
2385
 * Zero on success, negative errno on failure.
J
Jesse Barnes 已提交
2386 2387
 */
int drm_mode_getplane(struct drm_device *dev, void *data,
2388
		      struct drm_file *file_priv)
J
Jesse Barnes 已提交
2389 2390 2391 2392 2393 2394 2395 2396
{
	struct drm_mode_get_plane *plane_resp = data;
	struct drm_plane *plane;
	uint32_t __user *format_ptr;

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

R
Rob Clark 已提交
2397
	plane = drm_plane_find(dev, plane_resp->plane_id);
2398 2399
	if (!plane)
		return -ENOENT;
J
Jesse Barnes 已提交
2400

2401
	drm_modeset_lock(&plane->mutex, NULL);
J
Jesse Barnes 已提交
2402 2403 2404 2405 2406 2407 2408 2409 2410
	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;
2411
	drm_modeset_unlock(&plane->mutex);
J
Jesse Barnes 已提交
2412 2413 2414

	plane_resp->plane_id = plane->base.id;
	plane_resp->possible_crtcs = plane->possible_crtcs;
2415
	plane_resp->gamma_size = 0;
J
Jesse Barnes 已提交
2416 2417 2418 2419 2420 2421 2422

	/*
	 * 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ä 已提交
2423
		format_ptr = (uint32_t __user *)(unsigned long)plane_resp->format_type_ptr;
J
Jesse Barnes 已提交
2424 2425 2426
		if (copy_to_user(format_ptr,
				 plane->format_types,
				 sizeof(uint32_t) * plane->format_count)) {
2427
			return -EFAULT;
J
Jesse Barnes 已提交
2428 2429 2430 2431
		}
	}
	plane_resp->count_format_types = plane->format_count;

2432
	return 0;
J
Jesse Barnes 已提交
2433 2434
}

2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455
/**
 * drm_plane_check_pixel_format - Check if the plane supports the pixel format
 * @plane: plane to check for format support
 * @format: the pixel format
 *
 * Returns:
 * Zero of @plane has @format in its list of supported pixel formats, -EINVAL
 * otherwise.
 */
int drm_plane_check_pixel_format(const struct drm_plane *plane, u32 format)
{
	unsigned int i;

	for (i = 0; i < plane->format_count; i++) {
		if (format == plane->format_types[i])
			return 0;
	}

	return -EINVAL;
}

2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481
static int check_src_coords(uint32_t src_x, uint32_t src_y,
			    uint32_t src_w, uint32_t src_h,
			    const struct drm_framebuffer *fb)
{
	unsigned int fb_width, fb_height;

	fb_width = fb->width << 16;
	fb_height = fb->height << 16;

	/* Make sure source coordinates are inside the fb. */
	if (src_w > fb_width ||
	    src_x > fb_width - src_w ||
	    src_h > fb_height ||
	    src_y > fb_height - src_h) {
		DRM_DEBUG_KMS("Invalid source coordinates "
			      "%u.%06ux%u.%06u+%u.%06u+%u.%06u\n",
			      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);
		return -ENOSPC;
	}

	return 0;
}

2482 2483
/*
 * setplane_internal - setplane handler for internal callers
J
Jesse Barnes 已提交
2484
 *
2485 2486 2487
 * 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.
2488
 *
2489
 * src_{x,y,w,h} are provided in 16.16 fixed point format
J
Jesse Barnes 已提交
2490
 */
2491 2492 2493 2494 2495 2496 2497 2498
static int __setplane_internal(struct drm_plane *plane,
			       struct drm_crtc *crtc,
			       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 已提交
2499 2500 2501 2502
{
	int ret = 0;

	/* No fb means shut it down */
2503
	if (!fb) {
2504
		plane->old_fb = plane->fb;
2505 2506 2507 2508 2509
		ret = plane->funcs->disable_plane(plane);
		if (!ret) {
			plane->crtc = NULL;
			plane->fb = NULL;
		} else {
2510
			plane->old_fb = NULL;
2511
		}
J
Jesse Barnes 已提交
2512 2513 2514
		goto out;
	}

2515 2516 2517 2518 2519 2520 2521
	/* 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;
	}

2522
	/* Check whether this plane supports the fb pixel format. */
2523 2524
	ret = drm_plane_check_pixel_format(plane, fb->pixel_format);
	if (ret) {
2525 2526
		DRM_DEBUG_KMS("Invalid pixel format %s\n",
			      drm_get_format_name(fb->pixel_format));
2527 2528 2529
		goto out;
	}

2530 2531 2532 2533 2534 2535 2536
	/* Give drivers some help against integer overflows */
	if (crtc_w > INT_MAX ||
	    crtc_x > INT_MAX - (int32_t) crtc_w ||
	    crtc_h > INT_MAX ||
	    crtc_y > INT_MAX - (int32_t) crtc_h) {
		DRM_DEBUG_KMS("Invalid CRTC coordinates %ux%u+%d+%d\n",
			      crtc_w, crtc_h, crtc_x, crtc_y);
2537 2538
		ret = -ERANGE;
		goto out;
2539 2540
	}

2541 2542
	ret = check_src_coords(src_x, src_y, src_w, src_h, fb);
	if (ret)
2543 2544
		goto out;

2545
	plane->old_fb = plane->fb;
J
Jesse Barnes 已提交
2546
	ret = plane->funcs->update_plane(plane, crtc, fb,
2547 2548
					 crtc_x, crtc_y, crtc_w, crtc_h,
					 src_x, src_y, src_w, src_h);
J
Jesse Barnes 已提交
2549 2550 2551
	if (!ret) {
		plane->crtc = crtc;
		plane->fb = fb;
2552
		fb = NULL;
2553
	} else {
2554
		plane->old_fb = NULL;
J
Jesse Barnes 已提交
2555 2556 2557
	}

out:
2558 2559
	if (fb)
		drm_framebuffer_unreference(fb);
2560 2561 2562
	if (plane->old_fb)
		drm_framebuffer_unreference(plane->old_fb);
	plane->old_fb = NULL;
J
Jesse Barnes 已提交
2563 2564

	return ret;
2565
}
2566

2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584
static int setplane_internal(struct drm_plane *plane,
			     struct drm_crtc *crtc,
			     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)
{
	int ret;

	drm_modeset_lock_all(plane->dev);
	ret = __setplane_internal(plane, crtc, fb,
				  crtc_x, crtc_y, crtc_w, crtc_h,
				  src_x, src_y, src_w, src_h);
	drm_modeset_unlock_all(plane->dev);

	return ret;
2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597
}

/**
 * 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:
D
Daniel Vetter 已提交
2598
 * Zero on success, negative errno on failure.
2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614
 */
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_plane *plane;
	struct drm_crtc *crtc = NULL;
	struct drm_framebuffer *fb = NULL;

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

	/*
	 * First, find the plane, crtc, and fb objects.  If not available,
	 * we don't bother to call the driver.
	 */
R
Rob Clark 已提交
2615 2616
	plane = drm_plane_find(dev, plane_req->plane_id);
	if (!plane) {
2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629
		DRM_DEBUG_KMS("Unknown plane ID %d\n",
			      plane_req->plane_id);
		return -ENOENT;
	}

	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;
		}

R
Rob Clark 已提交
2630 2631
		crtc = drm_crtc_find(dev, plane_req->crtc_id);
		if (!crtc) {
2632 2633 2634 2635 2636 2637
			DRM_DEBUG_KMS("Unknown crtc ID %d\n",
				      plane_req->crtc_id);
			return -ENOENT;
		}
	}

2638 2639 2640 2641
	/*
	 * setplane_internal will take care of deref'ing either the old or new
	 * framebuffer depending on success.
	 */
2642
	return setplane_internal(plane, crtc, fb,
2643 2644 2645 2646
				 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 已提交
2647 2648
}

2649 2650 2651 2652 2653 2654
/**
 * 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.
2655
 *
2656
 * Returns:
D
Daniel Vetter 已提交
2657
 * Zero on success, negative errno on failure.
2658 2659 2660 2661
 */
int drm_mode_set_config_internal(struct drm_mode_set *set)
{
	struct drm_crtc *crtc = set->crtc;
D
Daniel Vetter 已提交
2662 2663
	struct drm_framebuffer *fb;
	struct drm_crtc *tmp;
2664 2665
	int ret;

D
Daniel Vetter 已提交
2666 2667 2668 2669 2670
	/*
	 * 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 ...
	 */
2671
	drm_for_each_crtc(tmp, crtc->dev)
2672
		tmp->primary->old_fb = tmp->primary->fb;
D
Daniel Vetter 已提交
2673

2674
	fb = set->fb;
2675

2676 2677
	ret = crtc->funcs->set_config(set);
	if (ret == 0) {
2678
		crtc->primary->crtc = crtc;
2679
		crtc->primary->fb = fb;
D
Daniel Vetter 已提交
2680
	}
2681

2682
	drm_for_each_crtc(tmp, crtc->dev) {
2683 2684
		if (tmp->primary->fb)
			drm_framebuffer_reference(tmp->primary->fb);
2685 2686 2687
		if (tmp->primary->old_fb)
			drm_framebuffer_unreference(tmp->primary->old_fb);
		tmp->primary->old_fb = NULL;
2688 2689 2690
	}

	return ret;
2691 2692 2693
}
EXPORT_SYMBOL(drm_mode_set_config_internal);

2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714
/**
 * drm_crtc_get_hv_timing - Fetches hdisplay/vdisplay for given mode
 * @mode: mode to query
 * @hdisplay: hdisplay value to fill in
 * @vdisplay: vdisplay value to fill in
 *
 * The vdisplay value will be doubled if the specified mode is a stereo mode of
 * the appropriate layout.
 */
void drm_crtc_get_hv_timing(const struct drm_display_mode *mode,
			    int *hdisplay, int *vdisplay)
{
	struct drm_display_mode adjusted;

	drm_mode_copy(&adjusted, mode);
	drm_mode_set_crtcinfo(&adjusted, CRTC_STEREO_DOUBLE_ONLY);
	*hdisplay = adjusted.crtc_hdisplay;
	*vdisplay = adjusted.crtc_vdisplay;
}
EXPORT_SYMBOL(drm_crtc_get_hv_timing);

2715 2716 2717 2718 2719 2720 2721 2722
/**
 * 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
2723
 */
2724 2725 2726 2727
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)
2728 2729 2730 2731

{
	int hdisplay, vdisplay;

2732
	drm_crtc_get_hv_timing(mode, &hdisplay, &vdisplay);
2733

2734 2735 2736
	if (crtc->state &&
	    crtc->primary->state->rotation & (BIT(DRM_ROTATE_90) |
					      BIT(DRM_ROTATE_270)))
2737 2738
		swap(hdisplay, vdisplay);

2739 2740
	return check_src_coords(x << 16, y << 16,
				hdisplay << 16, vdisplay << 16, fb);
2741
}
2742
EXPORT_SYMBOL(drm_crtc_check_viewport);
2743

D
Dave Airlie 已提交
2744 2745
/**
 * drm_mode_setcrtc - set CRTC configuration
2746 2747 2748
 * @dev: drm device for the ioctl
 * @data: data pointer for the ioctl
 * @file_priv: drm file for the ioctl call
D
Dave Airlie 已提交
2749 2750 2751 2752 2753
 *
 * Build a new CRTC configuration based on user request.
 *
 * Called by the user via ioctl.
 *
2754
 * Returns:
D
Daniel Vetter 已提交
2755
 * Zero on success, negative errno on failure.
D
Dave Airlie 已提交
2756 2757 2758 2759 2760 2761
 */
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;
2762
	struct drm_crtc *crtc;
D
Dave Airlie 已提交
2763 2764 2765 2766 2767
	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;
2768
	int ret;
D
Dave Airlie 已提交
2769 2770
	int i;

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

2774 2775 2776 2777 2778
	/*
	 * Universal plane src offsets are only 16.16, prevent havoc for
	 * drivers using universal plane code internally.
	 */
	if (crtc_req->x & 0xffff0000 || crtc_req->y & 0xffff0000)
2779 2780
		return -ERANGE;

2781
	drm_modeset_lock_all(dev);
R
Rob Clark 已提交
2782 2783
	crtc = drm_crtc_find(dev, crtc_req->crtc_id);
	if (!crtc) {
2784
		DRM_DEBUG_KMS("Unknown CRTC ID %d\n", crtc_req->crtc_id);
2785
		ret = -ENOENT;
D
Dave Airlie 已提交
2786 2787
		goto out;
	}
2788
	DRM_DEBUG_KMS("[CRTC:%d:%s]\n", crtc->base.id, crtc->name);
D
Dave Airlie 已提交
2789 2790 2791 2792 2793

	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) {
2794
			if (!crtc->primary->fb) {
2795 2796 2797
				DRM_DEBUG_KMS("CRTC doesn't have current FB\n");
				ret = -EINVAL;
				goto out;
D
Dave Airlie 已提交
2798
			}
2799
			fb = crtc->primary->fb;
2800 2801
			/* Make refcounting symmetric with the lookup path. */
			drm_framebuffer_reference(fb);
D
Dave Airlie 已提交
2802
		} else {
2803 2804
			fb = drm_framebuffer_lookup(dev, crtc_req->fb_id);
			if (!fb) {
2805 2806
				DRM_DEBUG_KMS("Unknown FB ID%d\n",
						crtc_req->fb_id);
2807
				ret = -ENOENT;
D
Dave Airlie 已提交
2808 2809 2810 2811 2812
				goto out;
			}
		}

		mode = drm_mode_create(dev);
2813 2814 2815 2816 2817
		if (!mode) {
			ret = -ENOMEM;
			goto out;
		}

2818
		ret = drm_mode_convert_umode(mode, &crtc_req->mode);
2819 2820 2821 2822 2823
		if (ret) {
			DRM_DEBUG_KMS("Invalid mode\n");
			goto out;
		}

D
Dave Airlie 已提交
2824
		drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
2825

2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842
		/*
		 * Check whether the primary plane supports the fb pixel format.
		 * Drivers not implementing the universal planes API use a
		 * default formats list provided by the DRM core which doesn't
		 * match real hardware capabilities. Skip the check in that
		 * case.
		 */
		if (!crtc->primary->format_default) {
			ret = drm_plane_check_pixel_format(crtc->primary,
							   fb->pixel_format);
			if (ret) {
				DRM_DEBUG_KMS("Invalid pixel format %s\n",
					drm_get_format_name(fb->pixel_format));
				goto out;
			}
		}

2843 2844 2845
		ret = drm_crtc_check_viewport(crtc, crtc_req->x, crtc_req->y,
					      mode, fb);
		if (ret)
2846
			goto out;
2847

D
Dave Airlie 已提交
2848 2849 2850
	}

	if (crtc_req->count_connectors == 0 && mode) {
2851
		DRM_DEBUG_KMS("Count connectors is 0 but mode set\n");
D
Dave Airlie 已提交
2852 2853 2854 2855
		ret = -EINVAL;
		goto out;
	}

2856
	if (crtc_req->count_connectors > 0 && (!mode || !fb)) {
2857
		DRM_DEBUG_KMS("Count connectors is %d but no mode or fb set\n",
D
Dave Airlie 已提交
2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871
			  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;
		}

2872 2873 2874
		connector_set = kmalloc_array(crtc_req->count_connectors,
					      sizeof(struct drm_connector *),
					      GFP_KERNEL);
D
Dave Airlie 已提交
2875 2876 2877 2878 2879 2880
		if (!connector_set) {
			ret = -ENOMEM;
			goto out;
		}

		for (i = 0; i < crtc_req->count_connectors; i++) {
2881
			connector_set[i] = NULL;
V
Ville Syrjälä 已提交
2882
			set_connectors_ptr = (uint32_t __user *)(unsigned long)crtc_req->set_connectors_ptr;
D
Dave Airlie 已提交
2883 2884 2885 2886 2887
			if (get_user(out_id, &set_connectors_ptr[i])) {
				ret = -EFAULT;
				goto out;
			}

2888
			connector = drm_connector_lookup(dev, out_id);
R
Rob Clark 已提交
2889
			if (!connector) {
2890 2891
				DRM_DEBUG_KMS("Connector id %d unknown\n",
						out_id);
2892
				ret = -ENOENT;
D
Dave Airlie 已提交
2893 2894
				goto out;
			}
2895 2896
			DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
					connector->base.id,
2897
					connector->name);
D
Dave Airlie 已提交
2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908

			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;
2909
	set.fb = fb;
2910
	ret = drm_mode_set_config_internal(&set);
D
Dave Airlie 已提交
2911 2912

out:
2913 2914 2915
	if (fb)
		drm_framebuffer_unreference(fb);

2916 2917 2918 2919 2920 2921
	if (connector_set) {
		for (i = 0; i < crtc_req->count_connectors; i++) {
			if (connector_set[i])
				drm_connector_unreference(connector_set[i]);
		}
	}
D
Dave Airlie 已提交
2922
	kfree(connector_set);
2923
	drm_mode_destroy(dev, mode);
2924
	drm_modeset_unlock_all(dev);
D
Dave Airlie 已提交
2925 2926 2927
	return ret;
}

2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944
/**
 * 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:
D
Daniel Vetter 已提交
2945
 * Zero on success, negative errno on failure.
2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965
 */
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);
2966
	WARN_ON(crtc->cursor->crtc != crtc && crtc->cursor->crtc != NULL);
2967 2968 2969 2970 2971 2972 2973 2974

	/*
	 * 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) {
2975
			fb = internal_framebuffer_create(dev, &fbreq, file_priv);
2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007
			if (IS_ERR(fb)) {
				DRM_DEBUG_KMS("failed to wrap cursor buffer in drm framebuffer\n");
				return PTR_ERR(fb);
			}
		} else {
			fb = NULL;
		}
	} else {
		fb = crtc->cursor->fb;
		if (fb)
			drm_framebuffer_reference(fb);
	}

	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.
	 */
3008
	ret = __setplane_internal(crtc->cursor, crtc, fb,
3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020
				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;
}

3021 3022 3023
static int drm_mode_cursor_common(struct drm_device *dev,
				  struct drm_mode_cursor2 *req,
				  struct drm_file *file_priv)
D
Dave Airlie 已提交
3024 3025 3026 3027
{
	struct drm_crtc *crtc;
	int ret = 0;

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

3031
	if (!req->flags || (~DRM_MODE_CURSOR_FLAGS & req->flags))
D
Dave Airlie 已提交
3032 3033
		return -EINVAL;

R
Rob Clark 已提交
3034 3035
	crtc = drm_crtc_find(dev, req->crtc_id);
	if (!crtc) {
3036
		DRM_DEBUG_KMS("Unknown CRTC ID %d\n", req->crtc_id);
3037
		return -ENOENT;
D
Dave Airlie 已提交
3038 3039
	}

3040 3041 3042 3043
	/*
	 * If this crtc has a universal cursor plane, call that plane's update
	 * handler rather than using legacy cursor handlers.
	 */
D
Daniel Vetter 已提交
3044
	drm_modeset_lock_crtc(crtc, crtc->cursor);
3045 3046 3047 3048 3049
	if (crtc->cursor) {
		ret = drm_mode_cursor_universal(crtc, req, file_priv);
		goto out;
	}

D
Dave Airlie 已提交
3050
	if (req->flags & DRM_MODE_CURSOR_BO) {
3051
		if (!crtc->funcs->cursor_set && !crtc->funcs->cursor_set2) {
D
Dave Airlie 已提交
3052 3053 3054 3055
			ret = -ENXIO;
			goto out;
		}
		/* Turns off the cursor if handle is 0 */
3056 3057 3058 3059 3060 3061
		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 已提交
3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072
	}

	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:
3073
	drm_modeset_unlock_crtc(crtc);
3074

D
Dave Airlie 已提交
3075
	return ret;
3076 3077

}
3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090


/**
 * 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:
D
Daniel Vetter 已提交
3091
 * Zero on success, negative errno on failure.
3092
 */
3093
int drm_mode_cursor_ioctl(struct drm_device *dev,
3094
			  void *data, struct drm_file *file_priv)
3095 3096 3097 3098 3099 3100 3101 3102 3103 3104
{
	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);
}

3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117
/**
 * 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:
D
Daniel Vetter 已提交
3118
 * Zero on success, negative errno on failure.
3119
 */
3120 3121 3122 3123
int drm_mode_cursor2_ioctl(struct drm_device *dev,
			   void *data, struct drm_file *file_priv)
{
	struct drm_mode_cursor2 *req = data;
3124

3125
	return drm_mode_cursor_common(dev, req, file_priv);
D
Dave Airlie 已提交
3126 3127
}

3128 3129 3130 3131 3132 3133 3134 3135
/**
 * 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.
 */
3136 3137 3138 3139 3140 3141
uint32_t drm_mode_legacy_fb_format(uint32_t bpp, uint32_t depth)
{
	uint32_t fmt;

	switch (bpp) {
	case 8:
3142
		fmt = DRM_FORMAT_C8;
3143 3144 3145
		break;
	case 16:
		if (depth == 15)
V
Ville Syrjälä 已提交
3146
			fmt = DRM_FORMAT_XRGB1555;
3147
		else
V
Ville Syrjälä 已提交
3148
			fmt = DRM_FORMAT_RGB565;
3149 3150
		break;
	case 24:
V
Ville Syrjälä 已提交
3151
		fmt = DRM_FORMAT_RGB888;
3152 3153 3154
		break;
	case 32:
		if (depth == 24)
V
Ville Syrjälä 已提交
3155
			fmt = DRM_FORMAT_XRGB8888;
3156
		else if (depth == 30)
V
Ville Syrjälä 已提交
3157
			fmt = DRM_FORMAT_XRGB2101010;
3158
		else
V
Ville Syrjälä 已提交
3159
			fmt = DRM_FORMAT_ARGB8888;
3160 3161
		break;
	default:
V
Ville Syrjälä 已提交
3162 3163
		DRM_ERROR("bad bpp, assuming x8r8g8b8 pixel format\n");
		fmt = DRM_FORMAT_XRGB8888;
3164 3165 3166 3167 3168 3169 3170
		break;
	}

	return fmt;
}
EXPORT_SYMBOL(drm_mode_legacy_fb_format);

D
Dave Airlie 已提交
3171 3172
/**
 * drm_mode_addfb - add an FB to the graphics configuration
3173 3174 3175
 * @dev: drm device for the ioctl
 * @data: data pointer for the ioctl
 * @file_priv: drm file for the ioctl call
D
Dave Airlie 已提交
3176
 *
3177
 * Add a new FB to the specified CRTC, given a user request. This is the
C
Chuck Ebbert 已提交
3178
 * original addfb ioctl which only supported RGB formats.
D
Dave Airlie 已提交
3179 3180 3181
 *
 * Called by the user via ioctl.
 *
3182
 * Returns:
D
Daniel Vetter 已提交
3183
 * Zero on success, negative errno on failure.
D
Dave Airlie 已提交
3184 3185 3186 3187
 */
int drm_mode_addfb(struct drm_device *dev,
		   void *data, struct drm_file *file_priv)
{
3188 3189
	struct drm_mode_fb_cmd *or = data;
	struct drm_mode_fb_cmd2 r = {};
3190
	int ret;
3191

3192
	/* convert to new format and call new ioctl */
3193 3194 3195 3196 3197 3198 3199
	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;

3200 3201 3202
	ret = drm_mode_addfb2(dev, &r, file_priv);
	if (ret)
		return ret;
3203

3204
	or->fb_id = r.fb_id;
3205

3206
	return 0;
3207 3208
}

3209
static int format_check(const struct drm_mode_fb_cmd2 *r)
3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261
{
	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:
3262 3263
	case DRM_FORMAT_NV24:
	case DRM_FORMAT_NV42:
3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275
	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:
3276 3277
		DRM_DEBUG_KMS("invalid pixel format %s\n",
			      drm_get_format_name(r->pixel_format));
3278 3279 3280 3281
		return -EINVAL;
	}
}

3282
static int framebuffer_check(const struct drm_mode_fb_cmd2 *r)
3283 3284 3285 3286 3287
{
	int ret, hsub, vsub, num_planes, i;

	ret = format_check(r);
	if (ret) {
3288 3289
		DRM_DEBUG_KMS("bad framebuffer format %s\n",
			      drm_get_format_name(r->pixel_format));
3290 3291 3292 3293 3294 3295 3296 3297
		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) {
C
Chuck Ebbert 已提交
3298
		DRM_DEBUG_KMS("bad framebuffer width %u\n", r->width);
3299 3300 3301 3302
		return -EINVAL;
	}

	if (r->height == 0 || r->height % vsub) {
3303
		DRM_DEBUG_KMS("bad framebuffer height %u\n", r->height);
3304 3305 3306 3307 3308
		return -EINVAL;
	}

	for (i = 0; i < num_planes; i++) {
		unsigned int width = r->width / (i != 0 ? hsub : 1);
3309 3310
		unsigned int height = r->height / (i != 0 ? vsub : 1);
		unsigned int cpp = drm_format_plane_cpp(r->pixel_format, i);
3311 3312

		if (!r->handles[i]) {
3313
			DRM_DEBUG_KMS("no buffer object handle for plane %d\n", i);
3314 3315 3316
			return -EINVAL;
		}

3317 3318 3319 3320 3321 3322 3323
		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) {
3324
			DRM_DEBUG_KMS("bad pitch %u for plane %d\n", r->pitches[i], i);
3325 3326
			return -EINVAL;
		}
3327 3328 3329 3330 3331 3332

		if (r->modifier[i] && !(r->flags & DRM_MODE_FB_MODIFIERS)) {
			DRM_DEBUG_KMS("bad fb modifier %llu for plane %d\n",
				      r->modifier[i], i);
			return -EINVAL;
		}
3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350

		/* modifier specific checks: */
		switch (r->modifier[i]) {
		case DRM_FORMAT_MOD_SAMSUNG_64_32_TILE:
			/* NOTE: the pitch restriction may be lifted later if it turns
			 * out that no hw has this restriction:
			 */
			if (r->pixel_format != DRM_FORMAT_NV12 ||
					width % 128 || height % 32 ||
					r->pitches[i] % 128) {
				DRM_DEBUG_KMS("bad modifier data for plane %d\n", i);
				return -EINVAL;
			}
			break;

		default:
			break;
		}
3351 3352
	}

3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378
	for (i = num_planes; i < 4; i++) {
		if (r->modifier[i]) {
			DRM_DEBUG_KMS("non-zero modifier for unused plane %d\n", i);
			return -EINVAL;
		}

		/* Pre-FB_MODIFIERS userspace didn't clear the structs properly. */
		if (!(r->flags & DRM_MODE_FB_MODIFIERS))
			continue;

		if (r->handles[i]) {
			DRM_DEBUG_KMS("buffer object handle for unused plane %d\n", i);
			return -EINVAL;
		}

		if (r->pitches[i]) {
			DRM_DEBUG_KMS("non-zero pitch for unused plane %d\n", i);
			return -EINVAL;
		}

		if (r->offsets[i]) {
			DRM_DEBUG_KMS("non-zero offset for unused plane %d\n", i);
			return -EINVAL;
		}
	}

3379 3380 3381
	return 0;
}

3382 3383
static struct drm_framebuffer *
internal_framebuffer_create(struct drm_device *dev,
3384
			    const struct drm_mode_fb_cmd2 *r,
3385
			    struct drm_file *file_priv)
3386
{
D
Dave Airlie 已提交
3387 3388
	struct drm_mode_config *config = &dev->mode_config;
	struct drm_framebuffer *fb;
3389
	int ret;
D
Dave Airlie 已提交
3390

3391
	if (r->flags & ~(DRM_MODE_FB_INTERLACED | DRM_MODE_FB_MODIFIERS)) {
3392
		DRM_DEBUG_KMS("bad framebuffer flags 0x%08x\n", r->flags);
3393
		return ERR_PTR(-EINVAL);
3394 3395
	}

D
Dave Airlie 已提交
3396
	if ((config->min_width > r->width) || (r->width > config->max_width)) {
3397
		DRM_DEBUG_KMS("bad framebuffer width %d, should be >= %d && <= %d\n",
J
Jesse Barnes 已提交
3398
			  r->width, config->min_width, config->max_width);
3399
		return ERR_PTR(-EINVAL);
D
Dave Airlie 已提交
3400 3401
	}
	if ((config->min_height > r->height) || (r->height > config->max_height)) {
3402
		DRM_DEBUG_KMS("bad framebuffer height %d, should be >= %d && <= %d\n",
J
Jesse Barnes 已提交
3403
			  r->height, config->min_height, config->max_height);
3404
		return ERR_PTR(-EINVAL);
D
Dave Airlie 已提交
3405 3406
	}

3407 3408 3409 3410 3411 3412
	if (r->flags & DRM_MODE_FB_MODIFIERS &&
	    !dev->mode_config.allow_fb_modifiers) {
		DRM_DEBUG_KMS("driver does not support fb modifiers\n");
		return ERR_PTR(-EINVAL);
	}

3413 3414
	ret = framebuffer_check(r);
	if (ret)
3415
		return ERR_PTR(ret);
3416

D
Dave Airlie 已提交
3417
	fb = dev->mode_config.funcs->fb_create(dev, file_priv, r);
3418
	if (IS_ERR(fb)) {
3419
		DRM_DEBUG_KMS("could not create framebuffer\n");
3420
		return fb;
D
Dave Airlie 已提交
3421 3422
	}

3423 3424
	return fb;
}
3425

3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438
/**
 * 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:
D
Daniel Vetter 已提交
3439
 * Zero on success, negative errno on failure.
3440 3441 3442 3443
 */
int drm_mode_addfb2(struct drm_device *dev,
		    void *data, struct drm_file *file_priv)
{
3444
	struct drm_mode_fb_cmd2 *r = data;
3445 3446 3447 3448 3449
	struct drm_framebuffer *fb;

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

3450
	fb = internal_framebuffer_create(dev, r, file_priv);
3451 3452 3453
	if (IS_ERR(fb))
		return PTR_ERR(fb);

3454 3455
	DRM_DEBUG_KMS("[FB:%d]\n", fb->base.id);
	r->fb_id = fb->base.id;
3456 3457 3458

	/* Transfer ownership to the filp for reaping on close */
	mutex_lock(&file_priv->fbs_lock);
3459 3460 3461
	list_add(&fb->filp_head, &file_priv->fbs);
	mutex_unlock(&file_priv->fbs_lock);

3462
	return 0;
D
Dave Airlie 已提交
3463 3464
}

3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482
struct drm_mode_rmfb_work {
	struct work_struct work;
	struct list_head fbs;
};

static void drm_mode_rmfb_work_fn(struct work_struct *w)
{
	struct drm_mode_rmfb_work *arg = container_of(w, typeof(*arg), work);

	while (!list_empty(&arg->fbs)) {
		struct drm_framebuffer *fb =
			list_first_entry(&arg->fbs, typeof(*fb), filp_head);

		list_del_init(&fb->filp_head);
		drm_framebuffer_remove(fb);
	}
}

D
Dave Airlie 已提交
3483 3484
/**
 * drm_mode_rmfb - remove an FB from the configuration
3485 3486 3487
 * @dev: drm device for the ioctl
 * @data: data pointer for the ioctl
 * @file_priv: drm file for the ioctl call
D
Dave Airlie 已提交
3488 3489 3490 3491 3492
 *
 * Remove the FB specified by the user.
 *
 * Called by the user via ioctl.
 *
3493
 * Returns:
D
Daniel Vetter 已提交
3494
 * Zero on success, negative errno on failure.
D
Dave Airlie 已提交
3495 3496 3497 3498 3499 3500 3501 3502 3503
 */
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;

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

3507 3508 3509 3510
	fb = drm_framebuffer_lookup(dev, *id);
	if (!fb)
		return -ENOENT;

3511
	mutex_lock(&file_priv->fbs_lock);
D
Dave Airlie 已提交
3512 3513 3514
	list_for_each_entry(fbl, &file_priv->fbs, filp_head)
		if (fb == fbl)
			found = 1;
3515 3516 3517 3518
	if (!found) {
		mutex_unlock(&file_priv->fbs_lock);
		goto fail_unref;
	}
3519

3520 3521
	list_del_init(&fb->filp_head);
	mutex_unlock(&file_priv->fbs_lock);
D
Dave Airlie 已提交
3522

3523 3524
	/* drop the reference we picked up in framebuffer lookup */
	drm_framebuffer_unreference(fb);
3525

3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545
	/*
	 * we now own the reference that was stored in the fbs list
	 *
	 * drm_framebuffer_remove may fail with -EINTR on pending signals,
	 * so run this in a separate stack as there's no way to correctly
	 * handle this after the fb is already removed from the lookup table.
	 */
	if (drm_framebuffer_read_refcount(fb) > 1) {
		struct drm_mode_rmfb_work arg;

		INIT_WORK_ONSTACK(&arg.work, drm_mode_rmfb_work_fn);
		INIT_LIST_HEAD(&arg.fbs);
		list_add_tail(&fb->filp_head, &arg.fbs);

		schedule_work(&arg.work);
		flush_work(&arg.work);
		destroy_work_on_stack(&arg.work);
	} else
		drm_framebuffer_unreference(fb);

3546
	return 0;
3547

3548 3549
fail_unref:
	drm_framebuffer_unreference(fb);
3550
	return -ENOENT;
D
Dave Airlie 已提交
3551 3552 3553 3554
}

/**
 * drm_mode_getfb - get FB info
3555 3556 3557
 * @dev: drm device for the ioctl
 * @data: data pointer for the ioctl
 * @file_priv: drm file for the ioctl call
D
Dave Airlie 已提交
3558 3559 3560 3561 3562
 *
 * Lookup the FB given its ID and return info about it.
 *
 * Called by the user via ioctl.
 *
3563
 * Returns:
D
Daniel Vetter 已提交
3564
 * Zero on success, negative errno on failure.
D
Dave Airlie 已提交
3565 3566 3567 3568 3569 3570
 */
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;
3571
	int ret;
D
Dave Airlie 已提交
3572

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

3576
	fb = drm_framebuffer_lookup(dev, r->fb_id);
3577
	if (!fb)
3578
		return -ENOENT;
D
Dave Airlie 已提交
3579 3580 3581 3582 3583

	r->height = fb->height;
	r->width = fb->width;
	r->depth = fb->depth;
	r->bpp = fb->bits_per_pixel;
3584
	r->pitch = fb->pitches[0];
3585
	if (fb->funcs->create_handle) {
3586
		if (file_priv->is_master || capable(CAP_SYS_ADMIN) ||
3587
		    drm_is_control_client(file_priv)) {
3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599
			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 {
3600
		ret = -ENODEV;
3601
	}
D
Dave Airlie 已提交
3602

3603 3604
	drm_framebuffer_unreference(fb);

D
Dave Airlie 已提交
3605 3606 3607
	return ret;
}

3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624
/**
 * 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:
D
Daniel Vetter 已提交
3625
 * Zero on success, negative errno on failure.
3626
 */
3627 3628 3629 3630 3631 3632 3633 3634 3635
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;
3636
	int ret;
3637

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

3641
	fb = drm_framebuffer_lookup(dev, r->fb_id);
3642
	if (!fb)
3643
		return -ENOENT;
3644 3645

	num_clips = r->num_clips;
V
Ville Syrjälä 已提交
3646
	clips_ptr = (struct drm_clip_rect __user *)(unsigned long)r->clips_ptr;
3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661

	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) {
3662 3663 3664 3665
		if (num_clips < 0 || num_clips > DRM_MODE_FB_DIRTY_MAX_CLIPS) {
			ret = -EINVAL;
			goto out_err1;
		}
3666
		clips = kcalloc(num_clips, sizeof(*clips), GFP_KERNEL);
3667 3668 3669 3670 3671 3672 3673
		if (!clips) {
			ret = -ENOMEM;
			goto out_err1;
		}

		ret = copy_from_user(clips, clips_ptr,
				     num_clips * sizeof(*clips));
3674 3675
		if (ret) {
			ret = -EFAULT;
3676
			goto out_err2;
3677
		}
3678 3679 3680
	}

	if (fb->funcs->dirty) {
3681 3682
		ret = fb->funcs->dirty(fb, file_priv, flags, r->color,
				       clips, num_clips);
3683 3684 3685 3686 3687 3688 3689
	} else {
		ret = -ENOSYS;
	}

out_err2:
	kfree(clips);
out_err1:
3690 3691
	drm_framebuffer_unreference(fb);

3692 3693 3694
	return ret;
}

D
Dave Airlie 已提交
3695 3696
/**
 * drm_fb_release - remove and free the FBs on this file
3697
 * @priv: drm file for the ioctl
D
Dave Airlie 已提交
3698 3699 3700 3701 3702
 *
 * Destroy all the FBs associated with @filp.
 *
 * Called by the user via ioctl.
 *
3703
 * Returns:
D
Daniel Vetter 已提交
3704
 * Zero on success, negative errno on failure.
D
Dave Airlie 已提交
3705
 */
3706
void drm_fb_release(struct drm_file *priv)
D
Dave Airlie 已提交
3707 3708
{
	struct drm_framebuffer *fb, *tfb;
3709 3710 3711
	struct drm_mode_rmfb_work arg;

	INIT_LIST_HEAD(&arg.fbs);
D
Dave Airlie 已提交
3712

3713 3714
	/*
	 * When the file gets released that means no one else can access the fb
3715
	 * list any more, so no need to grab fpriv->fbs_lock. And we need to
3716 3717 3718 3719 3720 3721 3722
	 * avoid upsetting lockdep since the universal cursor code adds a
	 * framebuffer while holding mutex locks.
	 *
	 * Note that a real deadlock between fpriv->fbs_lock and the modeset
	 * locks is impossible here since no one else but this function can get
	 * at it any more.
	 */
D
Dave Airlie 已提交
3723
	list_for_each_entry_safe(fb, tfb, &priv->fbs, filp_head) {
3724 3725 3726 3727
		if (drm_framebuffer_read_refcount(fb) > 1) {
			list_move_tail(&fb->filp_head, &arg.fbs);
		} else {
			list_del_init(&fb->filp_head);
3728

3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739
			/* This drops the fpriv->fbs reference. */
			drm_framebuffer_unreference(fb);
		}
	}

	if (!list_empty(&arg.fbs)) {
		INIT_WORK_ONSTACK(&arg.work, drm_mode_rmfb_work_fn);

		schedule_work(&arg.work);
		flush_work(&arg.work);
		destroy_work_on_stack(&arg.work);
D
Dave Airlie 已提交
3740 3741 3742
	}
}

3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753
/**
 * 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.
 *
3754 3755 3756 3757
 * Note that the DRM core keeps a per-device list of properties and that, if
 * drm_mode_config_cleanup() is called, it will destroy all properties created
 * by the driver.
 *
3758 3759 3760
 * Returns:
 * A pointer to the newly created property on success, NULL on failure.
 */
D
Dave Airlie 已提交
3761 3762 3763 3764
struct drm_property *drm_property_create(struct drm_device *dev, int flags,
					 const char *name, int num_values)
{
	struct drm_property *property = NULL;
3765
	int ret;
D
Dave Airlie 已提交
3766 3767 3768 3769 3770

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

R
Rob Clark 已提交
3771 3772
	property->dev = dev;

D
Dave Airlie 已提交
3773
	if (num_values) {
3774 3775
		property->values = kcalloc(num_values, sizeof(uint64_t),
					   GFP_KERNEL);
D
Dave Airlie 已提交
3776 3777 3778 3779
		if (!property->values)
			goto fail;
	}

3780 3781 3782 3783
	ret = drm_mode_object_get(dev, &property->base, DRM_MODE_OBJECT_PROPERTY);
	if (ret)
		goto fail;

D
Dave Airlie 已提交
3784 3785
	property->flags = flags;
	property->num_values = num_values;
3786
	INIT_LIST_HEAD(&property->enum_list);
D
Dave Airlie 已提交
3787

3788
	if (name) {
D
Dave Airlie 已提交
3789
		strncpy(property->name, name, DRM_PROP_NAME_LEN);
3790 3791
		property->name[DRM_PROP_NAME_LEN-1] = '\0';
	}
D
Dave Airlie 已提交
3792 3793

	list_add_tail(&property->head, &dev->mode_config.property_list);
R
Rob Clark 已提交
3794 3795 3796

	WARN_ON(!drm_property_type_valid(property));

D
Dave Airlie 已提交
3797 3798
	return property;
fail:
3799
	kfree(property->values);
D
Dave Airlie 已提交
3800 3801 3802 3803 3804
	kfree(property);
	return NULL;
}
EXPORT_SYMBOL(drm_property_create);

3805
/**
3806
 * drm_property_create_enum - create a new enumeration property type
3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822
 * @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.
 */
3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850
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);

3851
/**
3852
 * drm_property_create_bitmask - create a new bitmask property type
3853 3854 3855 3856
 * @dev: drm device
 * @flags: flags specifying the property type
 * @name: name of the property
 * @props: enumeration lists with property bitflags
D
Daniel Vetter 已提交
3857 3858
 * @num_props: size of the @props array
 * @supported_bits: bitmask of all supported enumeration values
3859
 *
D
Daniel Vetter 已提交
3860
 * This creates a new bitmask drm property which can then be attached to a drm
3861 3862 3863 3864 3865 3866 3867 3868 3869
 * 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 已提交
3870 3871 3872
struct drm_property *drm_property_create_bitmask(struct drm_device *dev,
					 int flags, const char *name,
					 const struct drm_prop_enum_list *props,
3873 3874
					 int num_props,
					 uint64_t supported_bits)
R
Rob Clark 已提交
3875 3876
{
	struct drm_property *property;
3877 3878
	int i, ret, index = 0;
	int num_values = hweight64(supported_bits);
R
Rob Clark 已提交
3879 3880 3881 3882 3883 3884

	flags |= DRM_MODE_PROP_BITMASK;

	property = drm_property_create(dev, flags, name, num_values);
	if (!property)
		return NULL;
3885 3886 3887
	for (i = 0; i < num_props; i++) {
		if (!(supported_bits & (1ULL << props[i].type)))
			continue;
R
Rob Clark 已提交
3888

3889 3890 3891 3892 3893 3894
		if (WARN_ON(index >= num_values)) {
			drm_property_destroy(dev, property);
			return NULL;
		}

		ret = drm_property_add_enum(property, index++,
R
Rob Clark 已提交
3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906
				      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 已提交
3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922
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;
}

3923
/**
3924
 * drm_property_create_range - create a new unsigned ranged property type
3925 3926 3927 3928 3929 3930 3931 3932 3933 3934
 * @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.
 *
3935 3936
 * Userspace is allowed to set any unsigned integer value in the (min, max)
 * range inclusive.
3937 3938 3939 3940
 *
 * Returns:
 * A pointer to the newly created property on success, NULL on failure.
 */
3941 3942 3943 3944
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 已提交
3945 3946
	return property_create_range(dev, DRM_MODE_PROP_RANGE | flags,
			name, min, max);
3947 3948 3949
}
EXPORT_SYMBOL(drm_property_create_range);

3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967
/**
 * drm_property_create_signed_range - create a new signed ranged property type
 * @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 signed integer value in the (min, max)
 * range inclusive.
 *
 * Returns:
 * A pointer to the newly created property on success, NULL on failure.
 */
R
Rob Clark 已提交
3968 3969 3970 3971 3972 3973 3974 3975 3976
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);

3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993
/**
 * drm_property_create_object - create a new object property type
 * @dev: drm device
 * @flags: flags specifying the property type
 * @name: name of the property
 * @type: object type from DRM_MODE_OBJECT_* defines
 *
 * 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 this to any property value of the given
 * @type. Only useful for atomic properties, which is enforced.
 *
 * Returns:
 * A pointer to the newly created property on success, NULL on failure.
 */
R
Rob Clark 已提交
3994 3995 3996 3997 3998 3999 4000
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;

4001 4002 4003
	if (WARN_ON(!(flags & DRM_MODE_PROP_ATOMIC)))
		return NULL;

R
Rob Clark 已提交
4004 4005 4006 4007 4008 4009 4010 4011 4012 4013
	property = drm_property_create(dev, flags, name, 1);
	if (!property)
		return NULL;

	property->values[0] = type;

	return property;
}
EXPORT_SYMBOL(drm_property_create_object);

4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035
/**
 * drm_property_create_bool - create a new boolean property type
 * @dev: drm device
 * @flags: flags specifying the property type
 * @name: name 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.
 *
 * This is implemented as a ranged property with only {0, 1} as valid values.
 *
 * Returns:
 * A pointer to the newly created property on success, NULL on failure.
 */
struct drm_property *drm_property_create_bool(struct drm_device *dev, int flags,
					 const char *name)
{
	return drm_property_create_range(dev, flags, name, 0, 1);
}
EXPORT_SYMBOL(drm_property_create_bool);

4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050
/**
 * 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 已提交
4051 4052 4053 4054 4055
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 已提交
4056 4057
	if (!(drm_property_type_is(property, DRM_MODE_PROP_ENUM) ||
			drm_property_type_is(property, DRM_MODE_PROP_BITMASK)))
R
Rob Clark 已提交
4058 4059 4060 4061 4062 4063
		return -EINVAL;

	/*
	 * Bitmask enum properties have the additional constraint of values
	 * from 0 to 63
	 */
R
Rob Clark 已提交
4064 4065
	if (drm_property_type_is(property, DRM_MODE_PROP_BITMASK) &&
			(value > 63))
D
Dave Airlie 已提交
4066 4067
		return -EINVAL;

4068 4069
	if (!list_empty(&property->enum_list)) {
		list_for_each_entry(prop_enum, &property->enum_list, head) {
D
Dave Airlie 已提交
4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086
			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;
4087
	list_add_tail(&prop_enum->head, &property->enum_list);
D
Dave Airlie 已提交
4088 4089 4090 4091
	return 0;
}
EXPORT_SYMBOL(drm_property_add_enum);

4092 4093 4094 4095 4096 4097 4098 4099
/**
 * 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 已提交
4100 4101 4102 4103
void drm_property_destroy(struct drm_device *dev, struct drm_property *property)
{
	struct drm_property_enum *prop_enum, *pt;

4104
	list_for_each_entry_safe(prop_enum, pt, &property->enum_list, head) {
D
Dave Airlie 已提交
4105 4106 4107 4108 4109 4110
		list_del(&prop_enum->head);
		kfree(prop_enum);
	}

	if (property->num_values)
		kfree(property->values);
4111
	drm_mode_object_unregister(dev, &property->base);
D
Dave Airlie 已提交
4112 4113 4114 4115 4116
	list_del(&property->head);
	kfree(property);
}
EXPORT_SYMBOL(drm_property_destroy);

4117 4118 4119 4120 4121 4122 4123 4124 4125 4126
/**
 * 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.
 */
4127 4128 4129 4130
void drm_object_attach_property(struct drm_mode_object *obj,
				struct drm_property *property,
				uint64_t init_val)
{
4131
	int count = obj->properties->count;
4132

4133 4134 4135 4136 4137 4138
	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;
4139 4140
	}

4141
	obj->properties->properties[count] = property;
4142 4143
	obj->properties->values[count] = init_val;
	obj->properties->count++;
R
Rob Clark 已提交
4144 4145
	if (property->flags & DRM_MODE_PROP_ATOMIC)
		obj->properties->atomic_count++;
4146 4147 4148
}
EXPORT_SYMBOL(drm_object_attach_property);

4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161
/**
 * 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.
 */
4162 4163 4164 4165 4166
int drm_object_property_set_value(struct drm_mode_object *obj,
				  struct drm_property *property, uint64_t val)
{
	int i;

4167
	for (i = 0; i < obj->properties->count; i++) {
4168
		if (obj->properties->properties[i] == property) {
4169 4170 4171 4172 4173 4174 4175 4176 4177
			obj->properties->values[i] = val;
			return 0;
		}
	}

	return -EINVAL;
}
EXPORT_SYMBOL(drm_object_property_set_value);

4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191
/**
 * 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.
 */
4192 4193 4194 4195 4196
int drm_object_property_get_value(struct drm_mode_object *obj,
				  struct drm_property *property, uint64_t *val)
{
	int i;

R
Rob Clark 已提交
4197 4198 4199 4200 4201 4202 4203 4204
	/* read-only properties bypass atomic mechanism and still store
	 * their value in obj->properties->values[].. mostly to avoid
	 * having to deal w/ EDID and similar props in atomic paths:
	 */
	if (drm_core_check_feature(property->dev, DRIVER_ATOMIC) &&
			!(property->flags & DRM_MODE_PROP_IMMUTABLE))
		return drm_atomic_get_property(obj, property, val);

4205
	for (i = 0; i < obj->properties->count; i++) {
4206
		if (obj->properties->properties[i] == property) {
4207 4208 4209 4210 4211 4212 4213 4214 4215
			*val = obj->properties->values[i];
			return 0;
		}
	}

	return -EINVAL;
}
EXPORT_SYMBOL(drm_object_property_get_value);

4216
/**
D
Daniel Vetter 已提交
4217
 * drm_mode_getproperty_ioctl - get the property metadata
4218 4219 4220 4221
 * @dev: DRM device
 * @data: ioctl data
 * @file_priv: DRM file info
 *
D
Daniel Vetter 已提交
4222 4223 4224 4225
 * This function retrieves the metadata for a given property, like the different
 * possible values for an enum property or the limits for a range property.
 *
 * Blob properties are special
4226 4227 4228 4229
 *
 * Called by the user via ioctl.
 *
 * Returns:
D
Daniel Vetter 已提交
4230
 * Zero on success, negative errno on failure.
4231
 */
D
Dave Airlie 已提交
4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244
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 value_count = 0;
	int ret = 0, i;
	int copied;
	struct drm_property_enum *prop_enum;
	struct drm_mode_property_enum __user *enum_ptr;
	uint64_t __user *values_ptr;

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

4248
	drm_modeset_lock_all(dev);
R
Rob Clark 已提交
4249 4250
	property = drm_property_find(dev, out_resp->prop_id);
	if (!property) {
4251
		ret = -ENOENT;
D
Dave Airlie 已提交
4252 4253 4254
		goto done;
	}

R
Rob Clark 已提交
4255 4256
	if (drm_property_type_is(property, DRM_MODE_PROP_ENUM) ||
			drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
4257
		list_for_each_entry(prop_enum, &property->enum_list, head)
D
Dave Airlie 已提交
4258 4259 4260 4261 4262 4263 4264 4265 4266 4267
			enum_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ä 已提交
4268
		values_ptr = (uint64_t __user *)(unsigned long)out_resp->values_ptr;
D
Dave Airlie 已提交
4269 4270 4271 4272 4273 4274 4275 4276 4277
		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 已提交
4278 4279
	if (drm_property_type_is(property, DRM_MODE_PROP_ENUM) ||
			drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
D
Dave Airlie 已提交
4280 4281
		if ((out_resp->count_enum_blobs >= enum_count) && enum_count) {
			copied = 0;
V
Ville Syrjälä 已提交
4282
			enum_ptr = (struct drm_mode_property_enum __user *)(unsigned long)out_resp->enum_blob_ptr;
4283
			list_for_each_entry(prop_enum, &property->enum_list, head) {
D
Dave Airlie 已提交
4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300

				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;
	}

4301 4302 4303 4304 4305 4306 4307 4308 4309 4310
	/*
	 * NOTE: The idea seems to have been to use this to read all the blob
	 * property values. But nothing ever added them to the corresponding
	 * list, userspace always used the special-purpose get_blob ioctl to
	 * read the value for a blob property. It also doesn't make a lot of
	 * sense to return values here when everything else is just metadata for
	 * the property itself.
	 */
	if (drm_property_type_is(property, DRM_MODE_PROP_BLOB))
		out_resp->count_enum_blobs = 0;
D
Dave Airlie 已提交
4311
done:
4312
	drm_modeset_unlock_all(dev);
D
Dave Airlie 已提交
4313 4314 4315
	return ret;
}

4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329
static void drm_property_free_blob(struct kref *kref)
{
	struct drm_property_blob *blob =
		container_of(kref, struct drm_property_blob, base.refcount);

	mutex_lock(&blob->dev->mode_config.blob_lock);
	list_del(&blob->head_global);
	mutex_unlock(&blob->dev->mode_config.blob_lock);

	drm_mode_object_unregister(blob->dev, &blob->base);

	kfree(blob);
}

4330 4331 4332 4333 4334 4335 4336 4337 4338
/**
 * drm_property_create_blob - Create new blob property
 *
 * Creates a new blob property for a specified DRM device, optionally
 * copying data.
 *
 * @dev: DRM device to create property for
 * @length: Length to allocate for blob data
 * @data: If specified, copies data into blob
4339 4340 4341 4342
 *
 * Returns:
 * New blob property with a single reference on success, or an ERR_PTR
 * value on failure.
4343
 */
4344
struct drm_property_blob *
4345
drm_property_create_blob(struct drm_device *dev, size_t length,
4346
			 const void *data)
D
Dave Airlie 已提交
4347 4348
{
	struct drm_property_blob *blob;
4349
	int ret;
D
Dave Airlie 已提交
4350

4351
	if (!length || length > ULONG_MAX - sizeof(struct drm_property_blob))
4352
		return ERR_PTR(-EINVAL);
D
Dave Airlie 已提交
4353 4354 4355

	blob = kzalloc(sizeof(struct drm_property_blob)+length, GFP_KERNEL);
	if (!blob)
4356
		return ERR_PTR(-ENOMEM);
D
Dave Airlie 已提交
4357

4358 4359 4360
	/* This must be explicitly initialised, so we can safely call list_del
	 * on it in the removal handler, even if it isn't in a file list. */
	INIT_LIST_HEAD(&blob->head_file);
D
Daniel Stone 已提交
4361
	blob->length = length;
4362
	blob->dev = dev;
D
Daniel Stone 已提交
4363

4364 4365
	if (data)
		memcpy(blob->data, data, length);
D
Daniel Stone 已提交
4366

4367 4368
	ret = drm_mode_object_get_reg(dev, &blob->base, DRM_MODE_OBJECT_BLOB,
				      true, drm_property_free_blob);
4369 4370
	if (ret) {
		kfree(blob);
4371
		return ERR_PTR(-EINVAL);
4372 4373
	}

4374
	mutex_lock(&dev->mode_config.blob_lock);
4375 4376
	list_add_tail(&blob->head_global,
	              &dev->mode_config.property_blob_list);
D
Daniel Stone 已提交
4377
	mutex_unlock(&dev->mode_config.blob_lock);
D
Dave Airlie 已提交
4378 4379 4380

	return blob;
}
4381
EXPORT_SYMBOL(drm_property_create_blob);
D
Dave Airlie 已提交
4382

4383 4384 4385 4386 4387
/**
 * drm_property_unreference_blob - Unreference a blob property
 *
 * Drop a reference on a blob property. May free the object.
 *
4388
 * @blob: Pointer to blob property
4389 4390 4391 4392 4393 4394
 */
void drm_property_unreference_blob(struct drm_property_blob *blob)
{
	if (!blob)
		return;

4395
	drm_mode_object_unreference(&blob->base);
4396 4397 4398
}
EXPORT_SYMBOL(drm_property_unreference_blob);

4399 4400 4401 4402 4403 4404 4405 4406 4407 4408
/**
 * drm_property_destroy_user_blobs - destroy all blobs created by this client
 * @dev:       DRM device
 * @file_priv: destroy all blobs owned by this file handle
 */
void drm_property_destroy_user_blobs(struct drm_device *dev,
				     struct drm_file *file_priv)
{
	struct drm_property_blob *blob, *bt;

4409 4410 4411 4412
	/*
	 * When the file gets released that means no one else can access the
	 * blob list any more, so no need to grab dev->blob_lock.
	 */
4413 4414
	list_for_each_entry_safe(blob, bt, &file_priv->blobs, head_file) {
		list_del_init(&blob->head_file);
4415
		drm_property_unreference_blob(blob);
4416 4417 4418
	}
}

4419 4420 4421 4422 4423
/**
 * drm_property_reference_blob - Take a reference on an existing property
 *
 * Take a new reference on an existing blob property.
 *
4424
 * @blob: Pointer to blob property
4425 4426 4427
 */
struct drm_property_blob *drm_property_reference_blob(struct drm_property_blob *blob)
{
4428
	drm_mode_object_reference(&blob->base);
4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444
	return blob;
}
EXPORT_SYMBOL(drm_property_reference_blob);

/**
 * drm_property_lookup_blob - look up a blob property and take a reference
 * @dev: drm device
 * @id: id of the blob property
 *
 * If successful, this takes an additional reference to the blob property.
 * callers need to make sure to eventually unreference the returned property
 * again, using @drm_property_unreference_blob.
 */
struct drm_property_blob *drm_property_lookup_blob(struct drm_device *dev,
					           uint32_t id)
{
4445 4446
	struct drm_mode_object *obj;
	struct drm_property_blob *blob = NULL;
4447

4448 4449 4450
	obj = _object_find(dev, id, DRM_MODE_OBJECT_BLOB);
	if (obj)
		blob = obj_to_blob(obj);
4451 4452 4453 4454
	return blob;
}
EXPORT_SYMBOL(drm_property_lookup_blob);

4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501
/**
 * drm_property_replace_global_blob - atomically replace existing blob property
 * @dev: drm device
 * @replace: location of blob property pointer to be replaced
 * @length: length of data for new blob, or 0 for no data
 * @data: content for new blob, or NULL for no data
 * @obj_holds_id: optional object for property holding blob ID
 * @prop_holds_id: optional property holding blob ID
 * @return 0 on success or error on failure
 *
 * This function will atomically replace a global property in the blob list,
 * optionally updating a property which holds the ID of that property. It is
 * guaranteed to be atomic: no caller will be allowed to see intermediate
 * results, and either the entire operation will succeed and clean up the
 * previous property, or it will fail and the state will be unchanged.
 *
 * If length is 0 or data is NULL, no new blob will be created, and the holding
 * property, if specified, will be set to 0.
 *
 * Access to the replace pointer is assumed to be protected by the caller, e.g.
 * by holding the relevant modesetting object lock for its parent.
 *
 * For example, a drm_connector has a 'PATH' property, which contains the ID
 * of a blob property with the value of the MST path information. Calling this
 * function with replace pointing to the connector's path_blob_ptr, length and
 * data set for the new path information, obj_holds_id set to the connector's
 * base object, and prop_holds_id set to the path property name, will perform
 * a completely atomic update. The access to path_blob_ptr is protected by the
 * caller holding a lock on the connector.
 */
static int drm_property_replace_global_blob(struct drm_device *dev,
                                            struct drm_property_blob **replace,
                                            size_t length,
                                            const void *data,
                                            struct drm_mode_object *obj_holds_id,
                                            struct drm_property *prop_holds_id)
{
	struct drm_property_blob *new_blob = NULL;
	struct drm_property_blob *old_blob = NULL;
	int ret;

	WARN_ON(replace == NULL);

	old_blob = *replace;

	if (length && data) {
		new_blob = drm_property_create_blob(dev, length, data);
4502 4503
		if (IS_ERR(new_blob))
			return PTR_ERR(new_blob);
4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519
	}

	/* This does not need to be synchronised with blob_lock, as the
	 * get_properties ioctl locks all modesetting objects, and
	 * obj_holds_id must be locked before calling here, so we cannot
	 * have its value out of sync with the list membership modified
	 * below under blob_lock. */
	if (obj_holds_id) {
		ret = drm_object_property_set_value(obj_holds_id,
						    prop_holds_id,
						    new_blob ?
						        new_blob->base.id : 0);
		if (ret != 0)
			goto err_created;
	}

4520
	drm_property_unreference_blob(old_blob);
4521 4522 4523 4524 4525
	*replace = new_blob;

	return 0;

err_created:
4526
	drm_property_unreference_blob(new_blob);
4527 4528 4529
	return ret;
}

4530 4531 4532 4533 4534 4535 4536 4537 4538 4539 4540 4541
/**
 * 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:
D
Daniel Vetter 已提交
4542
 * Zero on success, negative errno on failure.
4543
 */
D
Dave Airlie 已提交
4544 4545 4546 4547 4548 4549
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ä 已提交
4550
	void __user *blob_ptr;
D
Dave Airlie 已提交
4551

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

4555 4556 4557
	blob = drm_property_lookup_blob(dev, out_resp->blob_id);
	if (!blob)
		return -ENOENT;
D
Dave Airlie 已提交
4558 4559

	if (out_resp->length == blob->length) {
V
Ville Syrjälä 已提交
4560
		blob_ptr = (void __user *)(unsigned long)out_resp->data;
4561
		if (copy_to_user(blob_ptr, blob->data, blob->length)) {
D
Dave Airlie 已提交
4562
			ret = -EFAULT;
4563
			goto unref;
D
Dave Airlie 已提交
4564 4565 4566
		}
	}
	out_resp->length = blob->length;
4567 4568
unref:
	drm_property_unreference_blob(blob);
D
Dave Airlie 已提交
4569 4570 4571 4572

	return ret;
}

4573 4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613
/**
 * drm_mode_createblob_ioctl - create a new blob property
 * @dev: DRM device
 * @data: ioctl data
 * @file_priv: DRM file info
 *
 * This function creates a new blob property with user-defined values. In order
 * to give us sensible validation and checking when creating, rather than at
 * every potential use, we also require a type to be provided upfront.
 *
 * Called by the user via ioctl.
 *
 * Returns:
 * Zero on success, negative errno on failure.
 */
int drm_mode_createblob_ioctl(struct drm_device *dev,
			      void *data, struct drm_file *file_priv)
{
	struct drm_mode_create_blob *out_resp = data;
	struct drm_property_blob *blob;
	void __user *blob_ptr;
	int ret = 0;

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

	blob = drm_property_create_blob(dev, out_resp->length, NULL);
	if (IS_ERR(blob))
		return PTR_ERR(blob);

	blob_ptr = (void __user *)(unsigned long)out_resp->data;
	if (copy_from_user(blob->data, blob_ptr, out_resp->length)) {
		ret = -EFAULT;
		goto out_blob;
	}

	/* Dropping the lock between create_blob and our access here is safe
	 * as only the same file_priv can remove the blob; at this point, it is
	 * not associated with any file_priv. */
	mutex_lock(&dev->mode_config.blob_lock);
	out_resp->blob_id = blob->base.id;
4614
	list_add_tail(&blob->head_file, &file_priv->blobs);
4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647
	mutex_unlock(&dev->mode_config.blob_lock);

	return 0;

out_blob:
	drm_property_unreference_blob(blob);
	return ret;
}

/**
 * drm_mode_destroyblob_ioctl - destroy a user blob property
 * @dev: DRM device
 * @data: ioctl data
 * @file_priv: DRM file info
 *
 * Destroy an existing user-defined blob property.
 *
 * Called by the user via ioctl.
 *
 * Returns:
 * Zero on success, negative errno on failure.
 */
int drm_mode_destroyblob_ioctl(struct drm_device *dev,
			       void *data, struct drm_file *file_priv)
{
	struct drm_mode_destroy_blob *out_resp = data;
	struct drm_property_blob *blob = NULL, *bt;
	bool found = false;
	int ret = 0;

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

4648 4649 4650
	blob = drm_property_lookup_blob(dev, out_resp->blob_id);
	if (!blob)
		return -ENOENT;
4651

4652
	mutex_lock(&dev->mode_config.blob_lock);
4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670
	/* Ensure the property was actually created by this user. */
	list_for_each_entry(bt, &file_priv->blobs, head_file) {
		if (bt == blob) {
			found = true;
			break;
		}
	}

	if (!found) {
		ret = -EPERM;
		goto err;
	}

	/* We must drop head_file here, because we may not be the last
	 * reference on the blob. */
	list_del_init(&blob->head_file);
	mutex_unlock(&dev->mode_config.blob_lock);

4671 4672 4673 4674
	/* One reference from lookup, and one from the filp. */
	drm_property_unreference_blob(blob);
	drm_property_unreference_blob(blob);

4675 4676 4677 4678
	return 0;

err:
	mutex_unlock(&dev->mode_config.blob_lock);
4679 4680
	drm_property_unreference_blob(blob);

4681 4682 4683
	return ret;
}

4684 4685 4686
/**
 * drm_mode_connector_set_path_property - set tile property on connector
 * @connector: connector to set property on.
4687
 * @path: path to use for property; must not be NULL.
4688 4689 4690 4691 4692 4693 4694
 *
 * This creates a property to expose to userspace to specify a
 * connector path. This is mainly used for DisplayPort MST where
 * connectors have a topology and we want to allow userspace to give
 * them more meaningful names.
 *
 * Returns:
D
Daniel Vetter 已提交
4695
 * Zero on success, negative errno on failure.
4696
 */
D
Dave Airlie 已提交
4697
int drm_mode_connector_set_path_property(struct drm_connector *connector,
4698
					 const char *path)
D
Dave Airlie 已提交
4699 4700
{
	struct drm_device *dev = connector->dev;
4701
	int ret;
D
Dave Airlie 已提交
4702

4703 4704 4705 4706 4707 4708
	ret = drm_property_replace_global_blob(dev,
	                                       &connector->path_blob_ptr,
	                                       strlen(path) + 1,
	                                       path,
	                                       &connector->base,
	                                       dev->mode_config.path_property);
D
Dave Airlie 已提交
4709 4710 4711 4712
	return ret;
}
EXPORT_SYMBOL(drm_mode_connector_set_path_property);

4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727
/**
 * drm_mode_connector_set_tile_property - set tile property on connector
 * @connector: connector to set property on.
 *
 * This looks up the tile information for a connector, and creates a
 * property for userspace to parse if it exists. The property is of
 * the form of 8 integers using ':' as a separator.
 *
 * Returns:
 * Zero on success, errno on failure.
 */
int drm_mode_connector_set_tile_property(struct drm_connector *connector)
{
	struct drm_device *dev = connector->dev;
	char tile[256];
4728
	int ret;
4729 4730

	if (!connector->has_tile) {
4731 4732 4733 4734 4735 4736
		ret  = drm_property_replace_global_blob(dev,
		                                        &connector->tile_blob_ptr,
		                                        0,
		                                        NULL,
		                                        &connector->base,
		                                        dev->mode_config.tile_property);
4737 4738 4739 4740 4741 4742 4743 4744 4745
		return ret;
	}

	snprintf(tile, 256, "%d:%d:%d:%d:%d:%d:%d:%d",
		 connector->tile_group->id, connector->tile_is_single_monitor,
		 connector->num_h_tile, connector->num_v_tile,
		 connector->tile_h_loc, connector->tile_v_loc,
		 connector->tile_h_size, connector->tile_v_size);

4746 4747 4748 4749 4750 4751
	ret = drm_property_replace_global_blob(dev,
	                                       &connector->tile_blob_ptr,
	                                       strlen(tile) + 1,
	                                       tile,
	                                       &connector->base,
	                                       dev->mode_config.tile_property);
4752 4753 4754 4755
	return ret;
}
EXPORT_SYMBOL(drm_mode_connector_set_tile_property);

4756 4757 4758 4759 4760 4761 4762 4763 4764
/**
 * 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:
D
Daniel Vetter 已提交
4765
 * Zero on success, negative errno on failure.
4766
 */
D
Dave Airlie 已提交
4767
int drm_mode_connector_update_edid_property(struct drm_connector *connector,
4768
					    const struct edid *edid)
D
Dave Airlie 已提交
4769 4770
{
	struct drm_device *dev = connector->dev;
4771
	size_t size = 0;
4772
	int ret;
D
Dave Airlie 已提交
4773

4774 4775 4776 4777
	/* ignore requests to set edid when overridden */
	if (connector->override_edid)
		return 0;

4778
	if (edid)
4779
		size = EDID_LENGTH * (1 + edid->extensions);
D
Dave Airlie 已提交
4780

4781 4782 4783 4784 4785 4786
	ret = drm_property_replace_global_blob(dev,
					       &connector->edid_blob_ptr,
	                                       size,
	                                       edid,
	                                       &connector->base,
	                                       dev->mode_config.edid_property);
D
Dave Airlie 已提交
4787 4788 4789 4790
	return ret;
}
EXPORT_SYMBOL(drm_mode_connector_update_edid_property);

4791 4792 4793 4794 4795 4796 4797 4798
/* Some properties could refer to dynamic refcnt'd objects, or things that
 * need special locking to handle lifetime issues (ie. to ensure the prop
 * value doesn't become invalid part way through the property update due to
 * race).  The value returned by reference via 'obj' should be passed back
 * to drm_property_change_valid_put() after the property is set (and the
 * object to which the property is attached has a chance to take it's own
 * reference).
 */
R
Rob Clark 已提交
4799
bool drm_property_change_valid_get(struct drm_property *property,
4800
					 uint64_t value, struct drm_mode_object **ref)
4801
{
T
Thierry Reding 已提交
4802 4803
	int i;

4804 4805
	if (property->flags & DRM_MODE_PROP_IMMUTABLE)
		return false;
R
Rob Clark 已提交
4806

4807 4808
	*ref = NULL;

R
Rob Clark 已提交
4809
	if (drm_property_type_is(property, DRM_MODE_PROP_RANGE)) {
4810 4811 4812
		if (value < property->values[0] || value > property->values[1])
			return false;
		return true;
R
Rob Clark 已提交
4813 4814
	} else if (drm_property_type_is(property, DRM_MODE_PROP_SIGNED_RANGE)) {
		int64_t svalue = U642I64(value);
4815

R
Rob Clark 已提交
4816 4817 4818 4819
		if (svalue < U642I64(property->values[0]) ||
				svalue > U642I64(property->values[1]))
			return false;
		return true;
R
Rob Clark 已提交
4820
	} else if (drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
4821
		uint64_t valid_mask = 0;
4822

R
Rob Clark 已提交
4823 4824 4825
		for (i = 0; i < property->num_values; i++)
			valid_mask |= (1ULL << property->values[i]);
		return !(value & ~valid_mask);
R
Rob Clark 已提交
4826
	} else if (drm_property_type_is(property, DRM_MODE_PROP_BLOB)) {
4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838
		struct drm_property_blob *blob;

		if (value == 0)
			return true;

		blob = drm_property_lookup_blob(property->dev, value);
		if (blob) {
			*ref = &blob->base;
			return true;
		} else {
			return false;
		}
R
Rob Clark 已提交
4839 4840 4841 4842
	} else if (drm_property_type_is(property, DRM_MODE_PROP_OBJECT)) {
		/* a zero value for an object property translates to null: */
		if (value == 0)
			return true;
4843

4844
		return _object_find(property->dev, value, property->values[0]) != NULL;
4845
	}
T
Thierry Reding 已提交
4846 4847 4848 4849 4850

	for (i = 0; i < property->num_values; i++)
		if (property->values[i] == value)
			return true;
	return false;
4851 4852
}

R
Rob Clark 已提交
4853
void drm_property_change_valid_put(struct drm_property *property,
4854 4855 4856 4857 4858 4859
		struct drm_mode_object *ref)
{
	if (!ref)
		return;

	if (drm_property_type_is(property, DRM_MODE_PROP_OBJECT)) {
4860
		drm_mode_object_unreference(ref);
4861 4862
	} else if (drm_property_type_is(property, DRM_MODE_PROP_BLOB))
		drm_property_unreference_blob(obj_to_blob(ref));
4863 4864
}

4865 4866 4867 4868 4869 4870 4871 4872 4873 4874 4875 4876
/**
 * 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:
D
Daniel Vetter 已提交
4877
 * Zero on success, negative errno on failure.
4878
 */
D
Dave Airlie 已提交
4879 4880 4881
int drm_mode_connector_property_set_ioctl(struct drm_device *dev,
				       void *data, struct drm_file *file_priv)
{
4882 4883 4884 4885 4886 4887 4888
	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
	};
4889

4890 4891
	/* 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 已提交
4892 4893
}

4894 4895 4896 4897 4898 4899 4900 4901 4902
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) {
4903
		ret = (*connector->funcs->dpms)(connector, (int)value);
4904 4905 4906 4907 4908
	} else if (connector->funcs->set_property)
		ret = connector->funcs->set_property(connector, property, value);

	/* store the property value if successful */
	if (!ret)
4909
		drm_object_property_set_value(&connector->base, property, value);
4910 4911 4912
	return ret;
}

P
Paulo Zanoni 已提交
4913 4914 4915 4916 4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927
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;
}

4928 4929 4930 4931 4932 4933 4934 4935 4936 4937 4938 4939 4940 4941 4942 4943
/**
 * drm_mode_plane_set_obj_prop - set the value of a property
 * @plane: drm plane object to set property value for
 * @property: property to set
 * @value: value the property should be set to
 *
 * This functions sets a given property on a given plane object. This function
 * calls the driver's ->set_property callback and changes the software state of
 * the property if the callback succeeds.
 *
 * Returns:
 * Zero on success, error code on failure.
 */
int drm_mode_plane_set_obj_prop(struct drm_plane *plane,
				struct drm_property *property,
				uint64_t value)
R
Rob Clark 已提交
4944 4945
{
	int ret = -EINVAL;
4946
	struct drm_mode_object *obj = &plane->base;
R
Rob Clark 已提交
4947 4948 4949 4950 4951 4952 4953 4954

	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;
}
4955
EXPORT_SYMBOL(drm_mode_plane_set_obj_prop);
R
Rob Clark 已提交
4956

4957
/**
D
Daniel Vetter 已提交
4958
 * drm_mode_obj_get_properties_ioctl - get the current value of a object's property
4959 4960 4961 4962 4963 4964 4965 4966 4967 4968 4969
 * @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:
D
Daniel Vetter 已提交
4970
 * Zero on success, negative errno on failure.
4971
 */
4972 4973 4974 4975 4976 4977 4978 4979 4980 4981
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;

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

4982
	drm_modeset_lock_all(dev);
4983 4984 4985

	obj = drm_mode_object_find(dev, arg->obj_id, arg->obj_type);
	if (!obj) {
4986
		ret = -ENOENT;
4987 4988 4989 4990
		goto out;
	}
	if (!obj->properties) {
		ret = -EINVAL;
4991
		goto out_unref;
4992 4993
	}

R
Rob Clark 已提交
4994
	ret = get_properties(obj, file_priv->atomic,
4995 4996 4997
			(uint32_t __user *)(unsigned long)(arg->props_ptr),
			(uint64_t __user *)(unsigned long)(arg->prop_values_ptr),
			&arg->count_props);
4998

4999 5000
out_unref:
	drm_mode_object_unreference(obj);
5001
out:
5002
	drm_modeset_unlock_all(dev);
5003 5004 5005
	return ret;
}

5006 5007 5008 5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019
/**
 * 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:
D
Daniel Vetter 已提交
5020
 * Zero on success, negative errno on failure.
5021
 */
5022 5023 5024 5025 5026 5027 5028
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;
5029 5030
	int i, ret = -EINVAL;
	struct drm_mode_object *ref;
5031 5032 5033 5034

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

5035
	drm_modeset_lock_all(dev);
5036 5037

	arg_obj = drm_mode_object_find(dev, arg->obj_id, arg->obj_type);
5038 5039
	if (!arg_obj) {
		ret = -ENOENT;
5040
		goto out;
5041
	}
5042
	if (!arg_obj->properties)
5043
		goto out_unref;
5044

5045
	for (i = 0; i < arg_obj->properties->count; i++)
5046
		if (arg_obj->properties->properties[i]->base.id == arg->prop_id)
5047 5048
			break;

5049
	if (i == arg_obj->properties->count)
5050
		goto out_unref;
5051 5052 5053

	prop_obj = drm_mode_object_find(dev, arg->prop_id,
					DRM_MODE_OBJECT_PROPERTY);
5054 5055
	if (!prop_obj) {
		ret = -ENOENT;
5056
		goto out_unref;
5057
	}
5058 5059
	property = obj_to_property(prop_obj);

5060
	if (!drm_property_change_valid_get(property, arg->value, &ref))
5061
		goto out_unref;
5062 5063 5064 5065 5066 5067

	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 已提交
5068 5069 5070
	case DRM_MODE_OBJECT_CRTC:
		ret = drm_mode_crtc_set_obj_prop(arg_obj, property, arg->value);
		break;
R
Rob Clark 已提交
5071
	case DRM_MODE_OBJECT_PLANE:
5072 5073
		ret = drm_mode_plane_set_obj_prop(obj_to_plane(arg_obj),
						  property, arg->value);
R
Rob Clark 已提交
5074
		break;
5075 5076
	}

5077 5078
	drm_property_change_valid_put(property, ref);

5079 5080
out_unref:
	drm_mode_object_unreference(arg_obj);
5081
out:
5082
	drm_modeset_unlock_all(dev);
5083 5084 5085
	return ret;
}

5086 5087 5088 5089 5090 5091 5092 5093 5094 5095
/**
 * 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:
D
Daniel Vetter 已提交
5096
 * Zero on success, negative errno on failure.
5097
 */
D
Dave Airlie 已提交
5098 5099 5100 5101 5102
int drm_mode_connector_attach_encoder(struct drm_connector *connector,
				      struct drm_encoder *encoder)
{
	int i;

5103 5104 5105 5106 5107 5108 5109 5110 5111 5112 5113 5114 5115 5116
	/*
	 * In the past, drivers have attempted to model the static association
	 * of connector to encoder in simple connector/encoder devices using a
	 * direct assignment of connector->encoder = encoder. This connection
	 * is a logical one and the responsibility of the core, so drivers are
	 * expected not to mess with this.
	 *
	 * Note that the error return should've been enough here, but a large
	 * majority of drivers ignores the return value, so add in a big WARN
	 * to get people's attention.
	 */
	if (WARN_ON(connector->encoder))
		return -EINVAL;

D
Dave Airlie 已提交
5117 5118 5119 5120 5121 5122 5123 5124 5125 5126
	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);

5127 5128 5129 5130 5131 5132 5133 5134 5135 5136
/**
 * 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:
D
Daniel Vetter 已提交
5137
 * Zero on success, negative errno on failure.
5138
 */
5139
int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
5140
				 int gamma_size)
D
Dave Airlie 已提交
5141
{
5142 5143 5144
	uint16_t *r_base, *g_base, *b_base;
	int i;

D
Dave Airlie 已提交
5145 5146
	crtc->gamma_size = gamma_size;

5147 5148
	crtc->gamma_store = kcalloc(gamma_size, sizeof(uint16_t) * 3,
				    GFP_KERNEL);
D
Dave Airlie 已提交
5149 5150
	if (!crtc->gamma_store) {
		crtc->gamma_size = 0;
5151
		return -ENOMEM;
D
Dave Airlie 已提交
5152 5153
	}

5154 5155 5156 5157 5158 5159 5160 5161 5162 5163
	r_base = crtc->gamma_store;
	g_base = r_base + gamma_size;
	b_base = g_base + gamma_size;
	for (i = 0; i < gamma_size; i++) {
		r_base[i] = i << 8;
		g_base[i] = i << 8;
		b_base[i] = i << 8;
	}


5164
	return 0;
D
Dave Airlie 已提交
5165 5166 5167
}
EXPORT_SYMBOL(drm_mode_crtc_set_gamma_size);

5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179
/**
 * 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:
D
Daniel Vetter 已提交
5180
 * Zero on success, negative errno on failure.
5181
 */
D
Dave Airlie 已提交
5182 5183 5184 5185 5186 5187 5188 5189 5190
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;

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

5194
	drm_modeset_lock_all(dev);
R
Rob Clark 已提交
5195 5196
	crtc = drm_crtc_find(dev, crtc_lut->crtc_id);
	if (!crtc) {
5197
		ret = -ENOENT;
D
Dave Airlie 已提交
5198 5199 5200
		goto out;
	}

5201 5202 5203 5204 5205
	if (crtc->funcs->gamma_set == NULL) {
		ret = -ENOSYS;
		goto out;
	}

D
Dave Airlie 已提交
5206 5207 5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230
	/* 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 已提交
5231
	crtc->funcs->gamma_set(crtc, r_base, g_base, b_base, 0, crtc->gamma_size);
D
Dave Airlie 已提交
5232 5233

out:
5234
	drm_modeset_unlock_all(dev);
D
Dave Airlie 已提交
5235 5236 5237 5238
	return ret;

}

5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249 5250 5251
/**
 * 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:
D
Daniel Vetter 已提交
5252
 * Zero on success, negative errno on failure.
5253
 */
D
Dave Airlie 已提交
5254 5255 5256 5257 5258 5259 5260 5261 5262
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;

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

5266
	drm_modeset_lock_all(dev);
R
Rob Clark 已提交
5267 5268
	crtc = drm_crtc_find(dev, crtc_lut->crtc_id);
	if (!crtc) {
5269
		ret = -ENOENT;
D
Dave Airlie 已提交
5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291 5292 5293 5294 5295 5296 5297
		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:
5298
	drm_modeset_unlock_all(dev);
D
Dave Airlie 已提交
5299 5300
	return ret;
}
5301

5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317
/**
 * 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:
D
Daniel Vetter 已提交
5318
 * Zero on success, negative errno on failure.
5319
 */
5320 5321 5322 5323 5324
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;
5325
	struct drm_framebuffer *fb = NULL;
5326 5327 5328 5329 5330 5331 5332
	struct drm_pending_vblank_event *e = NULL;
	int ret = -EINVAL;

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

5333 5334 5335
	if ((page_flip->flags & DRM_MODE_PAGE_FLIP_ASYNC) && !dev->mode_config.async_page_flip)
		return -EINVAL;

R
Rob Clark 已提交
5336 5337
	crtc = drm_crtc_find(dev, page_flip->crtc_id);
	if (!crtc)
5338
		return -ENOENT;
5339

D
Daniel Vetter 已提交
5340
	drm_modeset_lock_crtc(crtc, crtc->primary);
5341
	if (crtc->primary->fb == NULL) {
5342 5343 5344 5345 5346 5347 5348 5349
		/* The framebuffer is currently unbound, presumably
		 * due to a hotplug event, that userspace has not
		 * yet discovered.
		 */
		ret = -EBUSY;
		goto out;
	}

5350 5351 5352
	if (crtc->funcs->page_flip == NULL)
		goto out;

5353
	fb = drm_framebuffer_lookup(dev, page_flip->fb_id);
5354 5355
	if (!fb) {
		ret = -ENOENT;
5356
		goto out;
5357
	}
5358

5359 5360 5361 5362 5363 5364 5365 5366
	if (crtc->state) {
		const struct drm_plane_state *state = crtc->primary->state;

		ret = check_src_coords(state->src_x, state->src_y,
				       state->src_w, state->src_h, fb);
	} else {
		ret = drm_crtc_check_viewport(crtc, crtc->x, crtc->y, &crtc->mode, fb);
	}
5367
	if (ret)
5368 5369
		goto out;

5370
	if (crtc->primary->fb->pixel_format != fb->pixel_format) {
5371 5372 5373 5374 5375
		DRM_DEBUG_KMS("Page flip is not allowed to change frame buffer format.\n");
		ret = -EINVAL;
		goto out;
	}

5376
	if (page_flip->flags & DRM_MODE_PAGE_FLIP_EVENT) {
5377 5378 5379
		e = kzalloc(sizeof *e, GFP_KERNEL);
		if (!e) {
			ret = -ENOMEM;
5380 5381
			goto out;
		}
5382
		e->event.base.type = DRM_EVENT_FLIP_COMPLETE;
5383
		e->event.base.length = sizeof(e->event);
5384
		e->event.user_data = page_flip->user_data;
5385 5386 5387 5388 5389
		ret = drm_event_reserve_init(dev, file_priv, &e->base, &e->event.base);
		if (ret) {
			kfree(e);
			goto out;
		}
5390 5391
	}

5392
	crtc->primary->old_fb = crtc->primary->fb;
5393
	ret = crtc->funcs->page_flip(crtc, fb, e, page_flip->flags);
5394
	if (ret) {
5395 5396
		if (page_flip->flags & DRM_MODE_PAGE_FLIP_EVENT)
			drm_event_cancel_free(dev, &e->base);
5397
		/* Keep the old fb, don't unref it. */
5398
		crtc->primary->old_fb = NULL;
5399
	} else {
5400
		crtc->primary->fb = fb;
5401 5402
		/* Unref only the old framebuffer. */
		fb = NULL;
5403 5404 5405
	}

out:
5406 5407
	if (fb)
		drm_framebuffer_unreference(fb);
5408 5409 5410
	if (crtc->primary->old_fb)
		drm_framebuffer_unreference(crtc->primary->old_fb);
	crtc->primary->old_fb = NULL;
5411
	drm_modeset_unlock_crtc(crtc);
5412

5413 5414
	return ret;
}
5415

5416 5417 5418 5419 5420 5421 5422 5423
/**
 * 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.
 */
5424 5425 5426
void drm_mode_config_reset(struct drm_device *dev)
{
	struct drm_crtc *crtc;
D
Daniel Vetter 已提交
5427
	struct drm_plane *plane;
5428 5429 5430
	struct drm_encoder *encoder;
	struct drm_connector *connector;

5431
	drm_for_each_plane(plane, dev)
D
Daniel Vetter 已提交
5432 5433 5434
		if (plane->funcs->reset)
			plane->funcs->reset(plane);

5435
	drm_for_each_crtc(crtc, dev)
5436 5437 5438
		if (crtc->funcs->reset)
			crtc->funcs->reset(crtc);

5439
	drm_for_each_encoder(encoder, dev)
5440 5441 5442
		if (encoder->funcs->reset)
			encoder->funcs->reset(encoder);

5443
	mutex_lock(&dev->mode_config.mutex);
D
Dave Airlie 已提交
5444
	drm_for_each_connector(connector, dev)
5445 5446
		if (connector->funcs->reset)
			connector->funcs->reset(connector);
5447
	mutex_unlock(&dev->mode_config.mutex);
5448 5449
}
EXPORT_SYMBOL(drm_mode_config_reset);
5450

5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466 5467
/**
 * 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:
D
Daniel Vetter 已提交
5468
 * Zero on success, negative errno on failure.
5469
 */
5470 5471 5472 5473
int drm_mode_create_dumb_ioctl(struct drm_device *dev,
			       void *data, struct drm_file *file_priv)
{
	struct drm_mode_create_dumb *args = data;
5474
	u32 cpp, stride, size;
5475 5476 5477

	if (!dev->driver->dumb_create)
		return -ENOSYS;
5478 5479 5480 5481
	if (!args->width || !args->height || !args->bpp)
		return -EINVAL;

	/* overflow checks for 32bit size calculations */
5482
	/* NOTE: DIV_ROUND_UP() can overflow */
5483
	cpp = DIV_ROUND_UP(args->bpp, 8);
5484
	if (!cpp || cpp > 0xffffffffU / args->width)
5485 5486 5487 5488 5489 5490 5491 5492 5493 5494
		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;

5495 5496 5497 5498 5499 5500 5501 5502 5503 5504
	/*
	 * handle, pitch and size are output parameters. Zero them out to
	 * prevent drivers from accidentally using uninitialized data. Since
	 * not all existing userspace is clearing these fields properly we
	 * cannot reject IOCTL with garbage in them.
	 */
	args->handle = 0;
	args->pitch = 0;
	args->size = 0;

5505 5506 5507
	return dev->driver->dumb_create(file_priv, dev, args);
}

5508 5509 5510 5511 5512 5513 5514 5515 5516 5517 5518 5519
/**
 * 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:
D
Daniel Vetter 已提交
5520
 * Zero on success, negative errno on failure.
5521
 */
5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533
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);
}

5534 5535 5536 5537 5538 5539 5540 5541 5542 5543 5544 5545 5546
/**
 * 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:
D
Daniel Vetter 已提交
5547
 * Zero on success, negative errno on failure.
5548
 */
5549 5550 5551 5552 5553 5554 5555 5556 5557 5558
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);
}
5559

5560 5561 5562 5563 5564 5565 5566 5567
/**
 * 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.
5568 5569 5570 5571 5572
 */
void drm_fb_get_bpp_depth(uint32_t format, unsigned int *depth,
			  int *bpp)
{
	switch (format) {
5573
	case DRM_FORMAT_C8:
V
Ville Syrjälä 已提交
5574 5575
	case DRM_FORMAT_RGB332:
	case DRM_FORMAT_BGR233:
5576 5577 5578
		*depth = 8;
		*bpp = 8;
		break;
V
Ville Syrjälä 已提交
5579 5580 5581 5582 5583 5584 5585 5586
	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:
5587 5588 5589
		*depth = 15;
		*bpp = 16;
		break;
V
Ville Syrjälä 已提交
5590 5591
	case DRM_FORMAT_RGB565:
	case DRM_FORMAT_BGR565:
5592 5593 5594
		*depth = 16;
		*bpp = 16;
		break;
V
Ville Syrjälä 已提交
5595 5596 5597 5598 5599 5600 5601 5602 5603
	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:
5604 5605 5606
		*depth = 24;
		*bpp = 32;
		break;
V
Ville Syrjälä 已提交
5607 5608 5609 5610 5611 5612 5613 5614
	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:
5615 5616 5617
		*depth = 30;
		*bpp = 32;
		break;
V
Ville Syrjälä 已提交
5618 5619 5620 5621
	case DRM_FORMAT_ARGB8888:
	case DRM_FORMAT_ABGR8888:
	case DRM_FORMAT_RGBA8888:
	case DRM_FORMAT_BGRA8888:
5622 5623 5624 5625
		*depth = 32;
		*bpp = 32;
		break;
	default:
5626 5627
		DRM_DEBUG_KMS("unsupported pixel format %s\n",
			      drm_get_format_name(format));
5628 5629 5630 5631 5632 5633
		*depth = 0;
		*bpp = 0;
		break;
	}
}
EXPORT_SYMBOL(drm_fb_get_bpp_depth);
5634 5635 5636 5637 5638

/**
 * drm_format_num_planes - get the number of planes for format
 * @format: pixel format (DRM_FORMAT_*)
 *
5639
 * Returns:
5640 5641 5642 5643 5644 5645 5646 5647 5648 5649 5650 5651 5652 5653 5654 5655 5656 5657 5658 5659
 * 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:
5660 5661
	case DRM_FORMAT_NV24:
	case DRM_FORMAT_NV42:
5662 5663 5664 5665 5666 5667
		return 2;
	default:
		return 1;
	}
}
EXPORT_SYMBOL(drm_format_num_planes);
5668 5669 5670 5671 5672 5673

/**
 * drm_format_plane_cpp - determine the bytes per pixel value
 * @format: pixel format (DRM_FORMAT_*)
 * @plane: plane index
 *
5674
 * Returns:
5675 5676 5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689 5690 5691 5692 5693 5694
 * 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:
5695 5696
	case DRM_FORMAT_NV24:
	case DRM_FORMAT_NV42:
5697 5698 5699 5700 5701 5702 5703 5704 5705 5706 5707 5708 5709 5710 5711 5712 5713 5714
		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);
5715 5716 5717 5718 5719

/**
 * drm_format_horz_chroma_subsampling - get the horizontal chroma subsampling factor
 * @format: pixel format (DRM_FORMAT_*)
 *
5720
 * Returns:
5721 5722 5723 5724 5725 5726 5727 5728 5729 5730 5731 5732 5733 5734 5735 5736 5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752 5753 5754
 * 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_*)
 *
5755
 * Returns:
5756 5757 5758 5759 5760 5761 5762 5763 5764 5765 5766 5767 5768 5769 5770 5771 5772 5773 5774
 * 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);
5775

5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 5815 5816 5817
/**
 * drm_format_plane_width - width of the plane given the first plane
 * @width: width of the first plane
 * @format: pixel format
 * @plane: plane index
 *
 * Returns:
 * The width of @plane, given that the width of the first plane is @width.
 */
int drm_format_plane_width(int width, uint32_t format, int plane)
{
	if (plane >= drm_format_num_planes(format))
		return 0;

	if (plane == 0)
		return width;

	return width / drm_format_horz_chroma_subsampling(format);
}
EXPORT_SYMBOL(drm_format_plane_width);

/**
 * drm_format_plane_height - height of the plane given the first plane
 * @height: height of the first plane
 * @format: pixel format
 * @plane: plane index
 *
 * Returns:
 * The height of @plane, given that the height of the first plane is @height.
 */
int drm_format_plane_height(int height, uint32_t format, int plane)
{
	if (plane >= drm_format_num_planes(format))
		return 0;

	if (plane == 0)
		return height;

	return height / drm_format_vert_chroma_subsampling(format);
}
EXPORT_SYMBOL(drm_format_plane_height);

5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840
/**
 * drm_rotation_simplify() - Try to simplify the rotation
 * @rotation: Rotation to be simplified
 * @supported_rotations: Supported rotations
 *
 * Attempt to simplify the rotation to a form that is supported.
 * Eg. if the hardware supports everything except DRM_REFLECT_X
 * one could call this function like this:
 *
 * drm_rotation_simplify(rotation, BIT(DRM_ROTATE_0) |
 *                       BIT(DRM_ROTATE_90) | BIT(DRM_ROTATE_180) |
 *                       BIT(DRM_ROTATE_270) | BIT(DRM_REFLECT_Y));
 *
 * to eliminate the DRM_ROTATE_X flag. Depending on what kind of
 * transforms the hardware supports, this function may not
 * be able to produce a supported transform, so the caller should
 * check the result afterwards.
 */
unsigned int drm_rotation_simplify(unsigned int rotation,
				   unsigned int supported_rotations)
{
	if (rotation & ~supported_rotations) {
		rotation ^= BIT(DRM_REFLECT_X) | BIT(DRM_REFLECT_Y);
5841 5842
		rotation = (rotation & DRM_REFLECT_MASK) |
		           BIT((ffs(rotation & DRM_ROTATE_MASK) + 1) % 4);
5843 5844 5845 5846 5847 5848
	}

	return rotation;
}
EXPORT_SYMBOL(drm_rotation_simplify);

5849 5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863
/**
 * 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);
5864
	drm_modeset_lock_init(&dev->mode_config.connection_mutex);
5865 5866
	mutex_init(&dev->mode_config.idr_mutex);
	mutex_init(&dev->mode_config.fb_lock);
D
Daniel Stone 已提交
5867
	mutex_init(&dev->mode_config.blob_lock);
5868 5869 5870 5871 5872 5873 5874 5875
	INIT_LIST_HEAD(&dev->mode_config.fb_list);
	INIT_LIST_HEAD(&dev->mode_config.crtc_list);
	INIT_LIST_HEAD(&dev->mode_config.connector_list);
	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);
D
Dave Airlie 已提交
5876
	idr_init(&dev->mode_config.tile_idr);
5877
	ida_init(&dev->mode_config.connector_ida);
5878 5879

	drm_modeset_lock_all(dev);
R
Rob Clark 已提交
5880
	drm_mode_create_standard_properties(dev);
5881 5882 5883 5884 5885 5886 5887
	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;
5888 5889
	dev->mode_config.num_overlay_plane = 0;
	dev->mode_config.num_total_plane = 0;
5890 5891 5892 5893 5894 5895 5896 5897 5898 5899 5900 5901 5902 5903 5904 5905 5906 5907 5908 5909 5910 5911 5912 5913 5914 5915 5916 5917 5918 5919 5920 5921 5922 5923 5924 5925 5926 5927 5928 5929 5930
}
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;
	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);
	}

	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);
	}

5931 5932 5933 5934 5935 5936 5937 5938 5939
	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);
	}

5940
	list_for_each_entry_safe(blob, bt, &dev->mode_config.property_blob_list,
5941
				 head_global) {
5942
		drm_property_unreference_blob(blob);
5943 5944 5945 5946 5947 5948 5949 5950 5951 5952 5953 5954
	}

	/*
	 * 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) {
5955
		drm_framebuffer_free(&fb->base.refcount);
5956 5957
	}

5958
	ida_destroy(&dev->mode_config.connector_ida);
D
Dave Airlie 已提交
5959
	idr_destroy(&dev->mode_config.tile_idr);
5960
	idr_destroy(&dev->mode_config.crtc_idr);
5961
	drm_modeset_lock_fini(&dev->mode_config.connection_mutex);
5962 5963
}
EXPORT_SYMBOL(drm_mode_config_cleanup);
5964 5965 5966 5967 5968 5969 5970 5971 5972 5973 5974 5975 5976 5977 5978 5979 5980 5981

struct drm_property *drm_mode_create_rotation_property(struct drm_device *dev,
						       unsigned int supported_rotations)
{
	static const struct drm_prop_enum_list props[] = {
		{ DRM_ROTATE_0,   "rotate-0" },
		{ DRM_ROTATE_90,  "rotate-90" },
		{ DRM_ROTATE_180, "rotate-180" },
		{ DRM_ROTATE_270, "rotate-270" },
		{ DRM_REFLECT_X,  "reflect-x" },
		{ DRM_REFLECT_Y,  "reflect-y" },
	};

	return drm_property_create_bitmask(dev, 0, "rotation",
					   props, ARRAY_SIZE(props),
					   supported_rotations);
}
EXPORT_SYMBOL(drm_mode_create_rotation_property);
D
Dave Airlie 已提交
5982 5983 5984 5985 5986 5987 5988 5989 5990 5991 5992 5993 5994 5995 5996 5997 5998 5999 6000 6001 6002 6003 6004 6005 6006 6007 6008 6009 6010 6011 6012 6013 6014 6015 6016 6017 6018 6019 6020 6021 6022 6023 6024 6025 6026 6027 6028 6029 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 6040

/**
 * DOC: Tile group
 *
 * Tile groups are used to represent tiled monitors with a unique
 * integer identifier. Tiled monitors using DisplayID v1.3 have
 * a unique 8-byte handle, we store this in a tile group, so we
 * have a common identifier for all tiles in a monitor group.
 */
static void drm_tile_group_free(struct kref *kref)
{
	struct drm_tile_group *tg = container_of(kref, struct drm_tile_group, refcount);
	struct drm_device *dev = tg->dev;
	mutex_lock(&dev->mode_config.idr_mutex);
	idr_remove(&dev->mode_config.tile_idr, tg->id);
	mutex_unlock(&dev->mode_config.idr_mutex);
	kfree(tg);
}

/**
 * drm_mode_put_tile_group - drop a reference to a tile group.
 * @dev: DRM device
 * @tg: tile group to drop reference to.
 *
 * drop reference to tile group and free if 0.
 */
void drm_mode_put_tile_group(struct drm_device *dev,
			     struct drm_tile_group *tg)
{
	kref_put(&tg->refcount, drm_tile_group_free);
}

/**
 * drm_mode_get_tile_group - get a reference to an existing tile group
 * @dev: DRM device
 * @topology: 8-bytes unique per monitor.
 *
 * Use the unique bytes to get a reference to an existing tile group.
 *
 * RETURNS:
 * tile group or NULL if not found.
 */
struct drm_tile_group *drm_mode_get_tile_group(struct drm_device *dev,
					       char topology[8])
{
	struct drm_tile_group *tg;
	int id;
	mutex_lock(&dev->mode_config.idr_mutex);
	idr_for_each_entry(&dev->mode_config.tile_idr, tg, id) {
		if (!memcmp(tg->group_data, topology, 8)) {
			if (!kref_get_unless_zero(&tg->refcount))
				tg = NULL;
			mutex_unlock(&dev->mode_config.idr_mutex);
			return tg;
		}
	}
	mutex_unlock(&dev->mode_config.idr_mutex);
	return NULL;
}
R
Rob Clark 已提交
6041
EXPORT_SYMBOL(drm_mode_get_tile_group);
D
Dave Airlie 已提交
6042 6043 6044 6045 6046 6047 6048 6049 6050 6051 6052 6053 6054 6055 6056 6057 6058 6059 6060 6061 6062 6063 6064 6065 6066 6067 6068 6069 6070 6071 6072 6073 6074 6075 6076 6077 6078 6079

/**
 * drm_mode_create_tile_group - create a tile group from a displayid description
 * @dev: DRM device
 * @topology: 8-bytes unique per monitor.
 *
 * Create a tile group for the unique monitor, and get a unique
 * identifier for the tile group.
 *
 * RETURNS:
 * new tile group or error.
 */
struct drm_tile_group *drm_mode_create_tile_group(struct drm_device *dev,
						  char topology[8])
{
	struct drm_tile_group *tg;
	int ret;

	tg = kzalloc(sizeof(*tg), GFP_KERNEL);
	if (!tg)
		return ERR_PTR(-ENOMEM);

	kref_init(&tg->refcount);
	memcpy(tg->group_data, topology, 8);
	tg->dev = dev;

	mutex_lock(&dev->mode_config.idr_mutex);
	ret = idr_alloc(&dev->mode_config.tile_idr, tg, 1, 0, GFP_KERNEL);
	if (ret >= 0) {
		tg->id = ret;
	} else {
		kfree(tg);
		tg = ERR_PTR(ret);
	}

	mutex_unlock(&dev->mode_config.idr_mutex);
	return tg;
}
R
Rob Clark 已提交
6080
EXPORT_SYMBOL(drm_mode_create_tile_group);