drm_crtc.c 159.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" },
D
Dave Airlie 已提交
171 172
};

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

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

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

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

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

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

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

271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296
/*
 * Internal function to assign a slot in the object idr and optionally
 * register the object into the idr.
 */
static int drm_mode_object_get_reg(struct drm_device *dev,
				   struct drm_mode_object *obj,
				   uint32_t obj_type,
				   bool register_obj)
{
	int ret;

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

	return ret < 0 ? ret : 0;
}

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

317 318 319
static void drm_mode_object_register(struct drm_device *dev,
				     struct drm_mode_object *obj)
{
J
Jesse Barnes 已提交
320
	mutex_lock(&dev->mode_config.idr_mutex);
321
	idr_replace(&dev->mode_config.crtc_idr, obj, obj->id);
J
Jesse Barnes 已提交
322
	mutex_unlock(&dev->mode_config.idr_mutex);
D
Dave Airlie 已提交
323 324 325
}

/**
326
 * drm_mode_object_put - free a modeset identifer
D
Dave Airlie 已提交
327
 * @dev: DRM device
328
 * @object: object to free
D
Dave Airlie 已提交
329
 *
330 331 332
 * Free @id from @dev's unique identifier pool. Note that despite the _get
 * postfix modeset identifiers are _not_ reference counted. Hence don't use this
 * for reference counted modeset objects like framebuffers.
D
Dave Airlie 已提交
333
 */
334 335
void drm_mode_object_put(struct drm_device *dev,
			 struct drm_mode_object *object)
D
Dave Airlie 已提交
336
{
J
Jesse Barnes 已提交
337
	mutex_lock(&dev->mode_config.idr_mutex);
D
Dave Airlie 已提交
338
	idr_remove(&dev->mode_config.crtc_idr, object->id);
J
Jesse Barnes 已提交
339
	mutex_unlock(&dev->mode_config.idr_mutex);
D
Dave Airlie 已提交
340 341
}

R
Rob Clark 已提交
342 343 344 345 346 347 348
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);
349 350 351 352 353
	if (obj && type != DRM_MODE_OBJECT_ANY && obj->type != type)
		obj = NULL;
	if (obj && obj->id != id)
		obj = NULL;
	/* don't leak out unref'd fb's */
354 355 356
	if (obj &&
	    (obj->type == DRM_MODE_OBJECT_FB ||
	     obj->type == DRM_MODE_OBJECT_BLOB))
R
Rob Clark 已提交
357 358 359 360 361 362
		obj = NULL;
	mutex_unlock(&dev->mode_config.idr_mutex);

	return obj;
}

363 364 365 366 367 368 369
/**
 * drm_mode_object_find - look up a drm object with static lifetime
 * @dev: drm device
 * @id: id of the mode object
 * @type: type of the mode object
 *
 * Note that framebuffers cannot be looked up with this functions - since those
R
Rob Clark 已提交
370 371 372
 * are reference counted, they need special treatment.  Even with
 * DRM_MODE_OBJECT_ANY (although that will simply return NULL
 * rather than WARN_ON()).
373
 */
374 375
struct drm_mode_object *drm_mode_object_find(struct drm_device *dev,
		uint32_t id, uint32_t type)
D
Dave Airlie 已提交
376
{
J
Jesse Barnes 已提交
377
	struct drm_mode_object *obj = NULL;
D
Dave Airlie 已提交
378

379 380
	/* Framebuffers are reference counted and need their own lookup
	 * function.*/
381
	WARN_ON(type == DRM_MODE_OBJECT_FB || type == DRM_MODE_OBJECT_BLOB);
R
Rob Clark 已提交
382
	obj = _object_find(dev, id, type);
D
Dave Airlie 已提交
383 384 385 386 387 388 389
	return obj;
}
EXPORT_SYMBOL(drm_mode_object_find);

/**
 * drm_framebuffer_init - initialize a framebuffer
 * @dev: DRM device
390 391
 * @fb: framebuffer to be initialized
 * @funcs: ... with these functions
D
Dave Airlie 已提交
392 393 394 395
 *
 * Allocates an ID for the framebuffer's parent mode object, sets its mode
 * functions & device file and adds it to the master fd list.
 *
396 397 398 399 400 401
 * 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.
 *
402
 * Returns:
403
 * Zero on success, error code on failure.
D
Dave Airlie 已提交
404 405 406 407 408 409
 */
int drm_framebuffer_init(struct drm_device *dev, struct drm_framebuffer *fb,
			 const struct drm_framebuffer_funcs *funcs)
{
	int ret;

410
	mutex_lock(&dev->mode_config.fb_lock);
R
Rob Clark 已提交
411
	kref_init(&fb->refcount);
412 413 414
	INIT_LIST_HEAD(&fb->filp_head);
	fb->dev = dev;
	fb->funcs = funcs;
R
Rob Clark 已提交
415

D
Dave Airlie 已提交
416
	ret = drm_mode_object_get(dev, &fb->base, DRM_MODE_OBJECT_FB);
417
	if (ret)
418
		goto out;
D
Dave Airlie 已提交
419 420 421

	dev->mode_config.num_fb++;
	list_add(&fb->head, &dev->mode_config.fb_list);
422 423
out:
	mutex_unlock(&dev->mode_config.fb_lock);
D
Dave Airlie 已提交
424

425
	return ret;
D
Dave Airlie 已提交
426 427 428
}
EXPORT_SYMBOL(drm_framebuffer_init);

429 430 431 432 433 434 435 436 437 438 439
/* dev->mode_config.fb_lock must be held! */
static void __drm_framebuffer_unregister(struct drm_device *dev,
					 struct drm_framebuffer *fb)
{
	mutex_lock(&dev->mode_config.idr_mutex);
	idr_remove(&dev->mode_config.crtc_idr, fb->base.id);
	mutex_unlock(&dev->mode_config.idr_mutex);

	fb->base.id = 0;
}

R
Rob Clark 已提交
440 441 442 443
static void drm_framebuffer_free(struct kref *kref)
{
	struct drm_framebuffer *fb =
			container_of(kref, struct drm_framebuffer, refcount);
444 445 446 447 448 449 450 451 452 453 454 455 456
	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.
	 */
	mutex_lock(&dev->mode_config.fb_lock);
	if (fb->base.id) {
		/* Mark fb as reaped and drop idr ref. */
		__drm_framebuffer_unregister(dev, fb);
	}
	mutex_unlock(&dev->mode_config.fb_lock);

R
Rob Clark 已提交
457 458 459
	fb->funcs->destroy(fb);
}

460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476
static struct drm_framebuffer *__drm_framebuffer_lookup(struct drm_device *dev,
							uint32_t id)
{
	struct drm_mode_object *obj = NULL;
	struct drm_framebuffer *fb;

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

	return fb;
}

477 478 479 480 481 482 483
/**
 * 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
484
 * again, using @drm_framebuffer_unreference.
485 486 487 488 489 490 491
 */
struct drm_framebuffer *drm_framebuffer_lookup(struct drm_device *dev,
					       uint32_t id)
{
	struct drm_framebuffer *fb;

	mutex_lock(&dev->mode_config.fb_lock);
492
	fb = __drm_framebuffer_lookup(dev, id);
493 494 495 496
	if (fb) {
		if (!kref_get_unless_zero(&fb->refcount))
			fb = NULL;
	}
497 498 499 500 501 502
	mutex_unlock(&dev->mode_config.fb_lock);

	return fb;
}
EXPORT_SYMBOL(drm_framebuffer_lookup);

R
Rob Clark 已提交
503 504
/**
 * drm_framebuffer_unreference - unref a framebuffer
505 506 507
 * @fb: framebuffer to unref
 *
 * This functions decrements the fb's refcount and frees it if it drops to zero.
R
Rob Clark 已提交
508 509 510
 */
void drm_framebuffer_unreference(struct drm_framebuffer *fb)
{
R
Rob Clark 已提交
511
	DRM_DEBUG("%p: FB ID: %d (%d)\n", fb, fb->base.id, atomic_read(&fb->refcount.refcount));
R
Rob Clark 已提交
512 513 514 515 516 517
	kref_put(&fb->refcount, drm_framebuffer_free);
}
EXPORT_SYMBOL(drm_framebuffer_unreference);

/**
 * drm_framebuffer_reference - incr the fb refcnt
518
 * @fb: framebuffer
519 520
 *
 * This functions increments the fb's refcount.
R
Rob Clark 已提交
521 522 523
 */
void drm_framebuffer_reference(struct drm_framebuffer *fb)
{
R
Rob Clark 已提交
524
	DRM_DEBUG("%p: FB ID: %d (%d)\n", fb, fb->base.id, atomic_read(&fb->refcount.refcount));
R
Rob Clark 已提交
525 526 527 528
	kref_get(&fb->refcount);
}
EXPORT_SYMBOL(drm_framebuffer_reference);

529 530 531 532 533 534 535 536 537 538 539
/**
 * 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)
{
540 541 542 543 544 545
	struct drm_device *dev;

	if (!fb)
		return;

	dev = fb->dev;
546 547 548 549 550

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

D
Dave Airlie 已提交
554 555 556 557
/**
 * drm_framebuffer_cleanup - remove a framebuffer object
 * @fb: framebuffer to remove
 *
558 559 560
 * Cleanup framebuffer. This function is intended to be used from the drivers
 * ->destroy callback. It can also be used to clean up driver private
 *  framebuffers embedded into a larger structure.
561 562 563 564 565 566 567 568 569
 *
 * 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 已提交
570 571
 */
void drm_framebuffer_cleanup(struct drm_framebuffer *fb)
R
Rob Clark 已提交
572 573
{
	struct drm_device *dev = fb->dev;
574

575
	mutex_lock(&dev->mode_config.fb_lock);
R
Rob Clark 已提交
576 577
	list_del(&fb->head);
	dev->mode_config.num_fb--;
578
	mutex_unlock(&dev->mode_config.fb_lock);
R
Rob Clark 已提交
579 580 581 582 583 584 585 586
}
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
587
 * using @fb, removes it, setting it to NULL. Then drops the reference to the
588 589 590 591 592
 * 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 已提交
593 594
 */
void drm_framebuffer_remove(struct drm_framebuffer *fb)
D
Dave Airlie 已提交
595
{
596
	struct drm_device *dev;
D
Dave Airlie 已提交
597
	struct drm_crtc *crtc;
J
Jesse Barnes 已提交
598
	struct drm_plane *plane;
599 600
	struct drm_mode_set set;
	int ret;
D
Dave Airlie 已提交
601

602 603 604 605 606
	if (!fb)
		return;

	dev = fb->dev;

607
	WARN_ON(!list_empty(&fb->filp_head));
608

609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626
	/*
	 * drm ABI mandates that we remove any deleted framebuffers from active
	 * useage. But since most sane clients only remove framebuffers they no
	 * longer need, try to optimize this away.
	 *
	 * Since we're holding a reference ourselves, observing a refcount of 1
	 * means that we're the last holder and can skip it. Also, the refcount
	 * can never increase from 1 again, so we don't need any barriers or
	 * locks.
	 *
	 * Note that userspace could try to race with use and instate a new
	 * usage _after_ we've cleared all current ones. End result will be an
	 * in-use fb with fb-id == 0. Userspace is allowed to shoot its own foot
	 * in this manner.
	 */
	if (atomic_read(&fb->refcount.refcount) > 1) {
		drm_modeset_lock_all(dev);
		/* remove from any CRTC */
627
		drm_for_each_crtc(crtc, dev) {
628
			if (crtc->primary->fb == fb) {
629 630 631 632 633 634 635 636
				/* 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);
			}
637
		}
D
Dave Airlie 已提交
638

639
		drm_for_each_plane(plane, dev) {
640 641
			if (plane->fb == fb)
				drm_plane_force_disable(plane);
J
Jesse Barnes 已提交
642
		}
643
		drm_modeset_unlock_all(dev);
J
Jesse Barnes 已提交
644 645
	}

R
Rob Clark 已提交
646
	drm_framebuffer_unreference(fb);
D
Dave Airlie 已提交
647
}
R
Rob Clark 已提交
648
EXPORT_SYMBOL(drm_framebuffer_remove);
D
Dave Airlie 已提交
649

650 651
DEFINE_WW_CLASS(crtc_ww_class);

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

676 677 678
	WARN_ON(primary && primary->type != DRM_PLANE_TYPE_PRIMARY);
	WARN_ON(cursor && cursor->type != DRM_PLANE_TYPE_CURSOR);

D
Dave Airlie 已提交
679 680 681
	crtc->dev = dev;
	crtc->funcs = funcs;

682
	drm_modeset_lock_init(&crtc->mutex);
683 684
	ret = drm_mode_object_get(dev, &crtc->base, DRM_MODE_OBJECT_CRTC);
	if (ret)
685
		return ret;
D
Dave Airlie 已提交
686

P
Paulo Zanoni 已提交
687 688
	crtc->base.properties = &crtc->properties;

689 690
	list_add_tail(&crtc->head, &config->crtc_list);
	config->num_crtc++;
691

692
	crtc->primary = primary;
693
	crtc->cursor = cursor;
694 695
	if (primary)
		primary->possible_crtcs = 1 << drm_crtc_index(crtc);
696 697
	if (cursor)
		cursor->possible_crtcs = 1 << drm_crtc_index(crtc);
698

699 700
	if (drm_core_check_feature(dev, DRIVER_ATOMIC)) {
		drm_object_attach_property(&crtc->base, config->prop_active, 0);
D
Daniel Stone 已提交
701
		drm_object_attach_property(&crtc->base, config->prop_mode_id, 0);
702 703
	}

704
	return 0;
D
Dave Airlie 已提交
705
}
706
EXPORT_SYMBOL(drm_crtc_init_with_planes);
D
Dave Airlie 已提交
707 708

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

720 721
	kfree(crtc->gamma_store);
	crtc->gamma_store = NULL;
D
Dave Airlie 已提交
722

723 724
	drm_modeset_lock_fini(&crtc->mutex);

D
Dave Airlie 已提交
725 726 727
	drm_mode_object_put(dev, &crtc->base);
	list_del(&crtc->head);
	dev->mode_config.num_crtc--;
728 729 730 731

	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);
732 733

	memset(crtc, 0, sizeof(*crtc));
D
Dave Airlie 已提交
734 735 736
}
EXPORT_SYMBOL(drm_crtc_cleanup);

737 738 739 740 741 742 743 744 745 746 747 748
/**
 * 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;

749
	drm_for_each_crtc(tmp, crtc->dev) {
750 751 752 753 754 755 756 757 758 759
		if (tmp == crtc)
			return index;

		index++;
	}

	BUG();
}
EXPORT_SYMBOL(drm_crtc_index);

760
/*
D
Dave Airlie 已提交
761 762 763 764 765 766
 * 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.
 */
767 768
static void drm_mode_remove(struct drm_connector *connector,
			    struct drm_display_mode *mode)
D
Dave Airlie 已提交
769 770
{
	list_del(&mode->head);
771
	drm_mode_destroy(connector->dev, mode);
D
Dave Airlie 已提交
772 773
}

774 775 776
/**
 * drm_display_info_set_bus_formats - set the supported bus formats
 * @info: display info to store bus formats in
777 778
 * @formats: array containing the supported bus formats
 * @num_formats: the number of entries in the fmts array
779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795
 *
 * 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);
796
		if (!fmts)
797 798 799 800 801 802 803 804 805 806 807
			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);

808 809 810 811 812 813 814 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
/**
 * 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" : "");
}

D
Dave Airlie 已提交
860 861 862 863 864
/**
 * drm_connector_init - Init a preallocated connector
 * @dev: DRM device
 * @connector: the connector to init
 * @funcs: callbacks for this connector
865
 * @connector_type: user visible type of the connector
D
Dave Airlie 已提交
866 867 868
 *
 * Initialises a preallocated connector. Connectors should be
 * subclassed as part of driver connector objects.
869
 *
870
 * Returns:
871
 * Zero on success, error code on failure.
D
Dave Airlie 已提交
872
 */
873 874 875 876
int drm_connector_init(struct drm_device *dev,
		       struct drm_connector *connector,
		       const struct drm_connector_funcs *funcs,
		       int connector_type)
D
Dave Airlie 已提交
877
{
878
	struct drm_mode_config *config = &dev->mode_config;
879
	int ret;
880 881
	struct ida *connector_ida =
		&drm_connector_enum_list[connector_type].ida;
882

883
	drm_modeset_lock_all(dev);
D
Dave Airlie 已提交
884

885
	ret = drm_mode_object_get_reg(dev, &connector->base, DRM_MODE_OBJECT_CONNECTOR, false);
886
	if (ret)
887
		goto out_unlock;
888

889
	connector->base.properties = &connector->properties;
D
Dave Airlie 已提交
890 891 892 893
	connector->dev = dev;
	connector->funcs = funcs;
	connector->connector_type = connector_type;
	connector->connector_type_id =
894 895 896
		ida_simple_get(connector_ida, 1, 0, GFP_KERNEL);
	if (connector->connector_type_id < 0) {
		ret = connector->connector_type_id;
897
		goto out_put;
898
	}
899 900 901 902 903 904 905 906 907
	connector->name =
		kasprintf(GFP_KERNEL, "%s-%d",
			  drm_connector_enum_list[connector_type].name,
			  connector->connector_type_id);
	if (!connector->name) {
		ret = -ENOMEM;
		goto out_put;
	}

D
Dave Airlie 已提交
908 909 910
	INIT_LIST_HEAD(&connector->probed_modes);
	INIT_LIST_HEAD(&connector->modes);
	connector->edid_blob_ptr = NULL;
911
	connector->status = connector_status_unknown;
D
Dave Airlie 已提交
912

913 914
	drm_connector_get_cmdline_mode(connector);

915 916
	/* We should add connectors at the end to avoid upsetting the connector
	 * index too much. */
917 918
	list_add_tail(&connector->head, &config->connector_list);
	config->num_connector++;
D
Dave Airlie 已提交
919

920
	if (connector_type != DRM_MODE_CONNECTOR_VIRTUAL)
921
		drm_object_attach_property(&connector->base,
922
					      config->edid_property,
923
					      0);
D
Dave Airlie 已提交
924

925
	drm_object_attach_property(&connector->base,
926 927 928 929 930
				      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 已提交
931

932 933
	connector->debugfs_entry = NULL;

934 935 936 937 938
out_put:
	if (ret)
		drm_mode_object_put(dev, &connector->base);

out_unlock:
939
	drm_modeset_unlock_all(dev);
940 941

	return ret;
D
Dave Airlie 已提交
942 943 944 945 946 947 948 949 950 951 952 953 954 955
}
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;

956 957 958 959 960
	if (connector->tile_group) {
		drm_mode_put_tile_group(dev, connector->tile_group);
		connector->tile_group = NULL;
	}

D
Dave Airlie 已提交
961 962 963 964 965 966
	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);

967 968 969
	ida_remove(&drm_connector_enum_list[connector->connector_type].ida,
		   connector->connector_type_id);

970
	kfree(connector->display_info.bus_formats);
D
Dave Airlie 已提交
971
	drm_mode_object_put(dev, &connector->base);
972 973
	kfree(connector->name);
	connector->name = NULL;
D
Dave Airlie 已提交
974
	list_del(&connector->head);
975
	dev->mode_config.num_connector--;
976 977 978 979 980

	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);
981 982

	memset(connector, 0, sizeof(*connector));
D
Dave Airlie 已提交
983 984 985
}
EXPORT_SYMBOL(drm_connector_cleanup);

986 987 988 989 990 991 992 993 994 995 996
/**
 * drm_connector_index - find the index of a registered connector
 * @connector: connector to find index for
 *
 * Given a registered connector, return the index of that connector within a DRM
 * device's list of connectors.
 */
unsigned int drm_connector_index(struct drm_connector *connector)
{
	unsigned int index = 0;
	struct drm_connector *tmp;
997 998 999
	struct drm_mode_config *config = &connector->dev->mode_config;

	WARN_ON(!drm_modeset_is_locked(&config->connection_mutex));
1000

1001
	drm_for_each_connector(tmp, connector->dev) {
1002 1003 1004 1005 1006 1007 1008 1009 1010 1011
		if (tmp == connector)
			return index;

		index++;
	}

	BUG();
}
EXPORT_SYMBOL(drm_connector_index);

1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022
/**
 * 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)
{
1023 1024
	int ret;

1025 1026
	drm_mode_object_register(connector->dev, &connector->base);

1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037
	ret = drm_sysfs_connector_add(connector);
	if (ret)
		return ret;

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

	return 0;
1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049
}
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);
1050
	drm_debugfs_connector_remove(connector);
1051 1052 1053 1054
}
EXPORT_SYMBOL(drm_connector_unregister);


1055 1056 1057 1058 1059 1060 1061 1062
/**
 * drm_connector_unplug_all - unregister connector userspace interfaces
 * @dev: drm device
 *
 * This function unregisters all connector userspace interfaces in sysfs. Should
 * be call when the device is disconnected, e.g. from an usb driver's
 * ->disconnect callback.
 */
1063 1064 1065 1066
void drm_connector_unplug_all(struct drm_device *dev)
{
	struct drm_connector *connector;

1067
	/* FIXME: taking the mode config mutex ends up in a clash with sysfs */
1068
	list_for_each_entry(connector, &dev->mode_config.connector_list, head)
1069
		drm_connector_unregister(connector);
1070 1071 1072 1073

}
EXPORT_SYMBOL(drm_connector_unplug_all);

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

1094
	drm_modeset_lock_all(dev);
D
Dave Airlie 已提交
1095

1096 1097
	ret = drm_mode_object_get(dev, &encoder->base, DRM_MODE_OBJECT_ENCODER);
	if (ret)
1098
		goto out_unlock;
D
Dave Airlie 已提交
1099

1100
	encoder->dev = dev;
D
Dave Airlie 已提交
1101 1102
	encoder->encoder_type = encoder_type;
	encoder->funcs = funcs;
1103 1104 1105 1106 1107 1108 1109
	encoder->name = kasprintf(GFP_KERNEL, "%s-%d",
				  drm_encoder_enum_list[encoder_type].name,
				  encoder->base.id);
	if (!encoder->name) {
		ret = -ENOMEM;
		goto out_put;
	}
D
Dave Airlie 已提交
1110 1111 1112 1113

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

1114 1115 1116 1117 1118
out_put:
	if (ret)
		drm_mode_object_put(dev, &encoder->base);

out_unlock:
1119
	drm_modeset_unlock_all(dev);
1120 1121

	return ret;
D
Dave Airlie 已提交
1122 1123 1124
}
EXPORT_SYMBOL(drm_encoder_init);

1125 1126 1127 1128 1129 1130
/**
 * 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 已提交
1131 1132 1133
void drm_encoder_cleanup(struct drm_encoder *encoder)
{
	struct drm_device *dev = encoder->dev;
1134

1135
	drm_modeset_lock_all(dev);
D
Dave Airlie 已提交
1136
	drm_mode_object_put(dev, &encoder->base);
1137
	kfree(encoder->name);
D
Dave Airlie 已提交
1138
	list_del(&encoder->head);
1139
	dev->mode_config.num_encoder--;
1140
	drm_modeset_unlock_all(dev);
1141 1142

	memset(encoder, 0, sizeof(*encoder));
D
Dave Airlie 已提交
1143 1144 1145
}
EXPORT_SYMBOL(drm_encoder_cleanup);

1146
/**
M
Matt Roper 已提交
1147
 * drm_universal_plane_init - Initialize a new universal plane object
1148 1149 1150 1151 1152 1153
 * @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 已提交
1154
 * @type: type of plane (overlay, primary, cursor)
1155
 *
M
Matt Roper 已提交
1156
 * Initializes a plane object of type @type.
1157
 *
1158
 * Returns:
1159 1160
 * Zero on success, error code on failure.
 */
M
Matt Roper 已提交
1161 1162 1163
int drm_universal_plane_init(struct drm_device *dev, struct drm_plane *plane,
			     unsigned long possible_crtcs,
			     const struct drm_plane_funcs *funcs,
1164
			     const uint32_t *formats, unsigned int format_count,
M
Matt Roper 已提交
1165
			     enum drm_plane_type type)
J
Jesse Barnes 已提交
1166
{
R
Rob Clark 已提交
1167
	struct drm_mode_config *config = &dev->mode_config;
1168 1169 1170 1171
	int ret;

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

D
Daniel Vetter 已提交
1174 1175
	drm_modeset_lock_init(&plane->mutex);

R
Rob Clark 已提交
1176
	plane->base.properties = &plane->properties;
J
Jesse Barnes 已提交
1177 1178
	plane->dev = dev;
	plane->funcs = funcs;
1179 1180
	plane->format_types = kmalloc_array(format_count, sizeof(uint32_t),
					    GFP_KERNEL);
J
Jesse Barnes 已提交
1181 1182 1183
	if (!plane->format_types) {
		DRM_DEBUG_KMS("out of memory when allocating plane\n");
		drm_mode_object_put(dev, &plane->base);
1184
		return -ENOMEM;
J
Jesse Barnes 已提交
1185 1186
	}

1187
	memcpy(plane->format_types, formats, format_count * sizeof(uint32_t));
J
Jesse Barnes 已提交
1188 1189
	plane->format_count = format_count;
	plane->possible_crtcs = possible_crtcs;
M
Matt Roper 已提交
1190
	plane->type = type;
J
Jesse Barnes 已提交
1191

R
Rob Clark 已提交
1192 1193
	list_add_tail(&plane->head, &config->plane_list);
	config->num_total_plane++;
M
Matt Roper 已提交
1194
	if (plane->type == DRM_PLANE_TYPE_OVERLAY)
R
Rob Clark 已提交
1195
		config->num_overlay_plane++;
J
Jesse Barnes 已提交
1196

R
Rob Clark 已提交
1197
	drm_object_attach_property(&plane->base,
R
Rob Clark 已提交
1198
				   config->plane_type_property,
R
Rob Clark 已提交
1199 1200
				   plane->type);

R
Rob Clark 已提交
1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213
	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);
	}

1214
	return 0;
J
Jesse Barnes 已提交
1215
}
M
Matt Roper 已提交
1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237
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,
1238
		   const uint32_t *formats, unsigned int format_count,
M
Matt Roper 已提交
1239 1240 1241 1242 1243 1244 1245 1246
		   bool is_primary)
{
	enum drm_plane_type type;

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

1249 1250 1251 1252 1253 1254 1255 1256
/**
 * 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 已提交
1257 1258 1259 1260
void drm_plane_cleanup(struct drm_plane *plane)
{
	struct drm_device *dev = plane->dev;

1261
	drm_modeset_lock_all(dev);
J
Jesse Barnes 已提交
1262 1263
	kfree(plane->format_types);
	drm_mode_object_put(dev, &plane->base);
M
Matt Roper 已提交
1264 1265 1266 1267 1268 1269 1270

	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--;
1271
	drm_modeset_unlock_all(dev);
1272 1273 1274 1275

	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);
1276 1277

	memset(plane, 0, sizeof(*plane));
J
Jesse Barnes 已提交
1278 1279 1280
}
EXPORT_SYMBOL(drm_plane_cleanup);

1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292
/**
 * 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;

1293
	drm_for_each_plane(tmp, plane->dev) {
1294 1295 1296 1297 1298 1299 1300 1301 1302 1303
		if (tmp == plane)
			return index;

		index++;
	}

	BUG();
}
EXPORT_SYMBOL(drm_plane_index);

1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317
/**
 * 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;

1318
	drm_for_each_plane(plane, dev) {
1319 1320 1321 1322 1323 1324 1325 1326
		if (i == idx)
			return plane;
		i++;
	}
	return NULL;
}
EXPORT_SYMBOL(drm_plane_from_index);

1327 1328 1329 1330 1331 1332 1333 1334 1335
/**
 * 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.
 */
1336 1337 1338 1339
void drm_plane_force_disable(struct drm_plane *plane)
{
	int ret;

1340
	if (!plane->fb)
1341 1342
		return;

1343
	plane->old_fb = plane->fb;
1344
	ret = plane->funcs->disable_plane(plane);
1345
	if (ret) {
1346
		DRM_ERROR("failed to disable plane with busy fb\n");
1347
		plane->old_fb = NULL;
1348 1349
		return;
	}
1350
	/* disconnect the plane from the fb and crtc: */
1351
	drm_framebuffer_unreference(plane->old_fb);
1352
	plane->old_fb = NULL;
1353 1354 1355 1356 1357
	plane->fb = NULL;
	plane->crtc = NULL;
}
EXPORT_SYMBOL(drm_plane_force_disable);

R
Rob Clark 已提交
1358
static int drm_mode_create_standard_properties(struct drm_device *dev)
D
Dave Airlie 已提交
1359
{
R
Rob Clark 已提交
1360
	struct drm_property *prop;
D
Dave Airlie 已提交
1361 1362 1363 1364

	/*
	 * Standard properties (apply to all connectors)
	 */
R
Rob Clark 已提交
1365
	prop = drm_property_create(dev, DRM_MODE_PROP_BLOB |
D
Dave Airlie 已提交
1366 1367
				   DRM_MODE_PROP_IMMUTABLE,
				   "EDID", 0);
R
Rob Clark 已提交
1368 1369 1370
	if (!prop)
		return -ENOMEM;
	dev->mode_config.edid_property = prop;
D
Dave Airlie 已提交
1371

R
Rob Clark 已提交
1372
	prop = drm_property_create_enum(dev, 0,
1373 1374
				   "DPMS", drm_dpms_enum_list,
				   ARRAY_SIZE(drm_dpms_enum_list));
R
Rob Clark 已提交
1375 1376 1377
	if (!prop)
		return -ENOMEM;
	dev->mode_config.dpms_property = prop;
1378

R
Rob Clark 已提交
1379 1380 1381 1382 1383 1384 1385
	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 已提交
1386

R
Rob Clark 已提交
1387 1388 1389 1390 1391 1392 1393
	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 已提交
1394

R
Rob Clark 已提交
1395
	prop = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
R
Rob Clark 已提交
1396 1397
					"type", drm_plane_type_enum_list,
					ARRAY_SIZE(drm_plane_type_enum_list));
R
Rob Clark 已提交
1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460
	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 已提交
1461

1462 1463 1464 1465 1466 1467
	prop = drm_property_create_bool(dev, DRM_MODE_PROP_ATOMIC,
			"ACTIVE");
	if (!prop)
		return -ENOMEM;
	dev->mode_config.prop_active = prop;

D
Daniel Stone 已提交
1468 1469 1470 1471 1472 1473 1474
	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;

R
Rob Clark 已提交
1475 1476 1477
	return 0;
}

D
Dave Airlie 已提交
1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492
/**
 * 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 =
1493
		drm_property_create_enum(dev, 0,
D
Dave Airlie 已提交
1494
				    "select subconnector",
1495
				    drm_dvi_i_select_enum_list,
D
Dave Airlie 已提交
1496 1497 1498
				    ARRAY_SIZE(drm_dvi_i_select_enum_list));
	dev->mode_config.dvi_i_select_subconnector_property = dvi_i_selector;

1499
	dvi_i_subconnector = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
D
Dave Airlie 已提交
1500
				    "subconnector",
1501
				    drm_dvi_i_subconnector_enum_list,
D
Dave Airlie 已提交
1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519
				    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.
 */
1520 1521
int drm_mode_create_tv_properties(struct drm_device *dev,
				  unsigned int num_modes,
V
Ville Syrjälä 已提交
1522
				  const char * const modes[])
D
Dave Airlie 已提交
1523 1524 1525
{
	struct drm_property *tv_selector;
	struct drm_property *tv_subconnector;
1526
	unsigned int i;
D
Dave Airlie 已提交
1527 1528 1529 1530 1531 1532 1533

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

	/*
	 * Basic connector properties
	 */
1534
	tv_selector = drm_property_create_enum(dev, 0,
D
Dave Airlie 已提交
1535
					  "select subconnector",
1536
					  drm_tv_select_enum_list,
D
Dave Airlie 已提交
1537
					  ARRAY_SIZE(drm_tv_select_enum_list));
I
Insu Yun 已提交
1538 1539 1540
	if (!tv_selector)
		goto nomem;

D
Dave Airlie 已提交
1541 1542 1543
	dev->mode_config.tv_select_subconnector_property = tv_selector;

	tv_subconnector =
1544 1545 1546
		drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
				    "subconnector",
				    drm_tv_subconnector_enum_list,
D
Dave Airlie 已提交
1547
				    ARRAY_SIZE(drm_tv_subconnector_enum_list));
I
Insu Yun 已提交
1548 1549
	if (!tv_subconnector)
		goto nomem;
D
Dave Airlie 已提交
1550 1551 1552 1553 1554 1555
	dev->mode_config.tv_subconnector_property = tv_subconnector;

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

	dev->mode_config.tv_right_margin_property =
1561
		drm_property_create_range(dev, 0, "right margin", 0, 100);
I
Insu Yun 已提交
1562 1563
	if (!dev->mode_config.tv_right_margin_property)
		goto nomem;
D
Dave Airlie 已提交
1564 1565

	dev->mode_config.tv_top_margin_property =
1566
		drm_property_create_range(dev, 0, "top margin", 0, 100);
I
Insu Yun 已提交
1567 1568
	if (!dev->mode_config.tv_top_margin_property)
		goto nomem;
D
Dave Airlie 已提交
1569 1570

	dev->mode_config.tv_bottom_margin_property =
1571
		drm_property_create_range(dev, 0, "bottom margin", 0, 100);
I
Insu Yun 已提交
1572 1573
	if (!dev->mode_config.tv_bottom_margin_property)
		goto nomem;
D
Dave Airlie 已提交
1574 1575 1576 1577

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

D
Dave Airlie 已提交
1581 1582 1583 1584
	for (i = 0; i < num_modes; i++)
		drm_property_add_enum(dev->mode_config.tv_mode_property, i,
				      i, modes[i]);

1585
	dev->mode_config.tv_brightness_property =
1586
		drm_property_create_range(dev, 0, "brightness", 0, 100);
I
Insu Yun 已提交
1587 1588
	if (!dev->mode_config.tv_brightness_property)
		goto nomem;
1589 1590

	dev->mode_config.tv_contrast_property =
1591
		drm_property_create_range(dev, 0, "contrast", 0, 100);
I
Insu Yun 已提交
1592 1593
	if (!dev->mode_config.tv_contrast_property)
		goto nomem;
1594 1595

	dev->mode_config.tv_flicker_reduction_property =
1596
		drm_property_create_range(dev, 0, "flicker reduction", 0, 100);
I
Insu Yun 已提交
1597 1598
	if (!dev->mode_config.tv_flicker_reduction_property)
		goto nomem;
1599

1600
	dev->mode_config.tv_overscan_property =
1601
		drm_property_create_range(dev, 0, "overscan", 0, 100);
I
Insu Yun 已提交
1602 1603
	if (!dev->mode_config.tv_overscan_property)
		goto nomem;
1604 1605

	dev->mode_config.tv_saturation_property =
1606
		drm_property_create_range(dev, 0, "saturation", 0, 100);
I
Insu Yun 已提交
1607 1608
	if (!dev->mode_config.tv_saturation_property)
		goto nomem;
1609 1610

	dev->mode_config.tv_hue_property =
1611
		drm_property_create_range(dev, 0, "hue", 0, 100);
I
Insu Yun 已提交
1612 1613
	if (!dev->mode_config.tv_hue_property)
		goto nomem;
1614

D
Dave Airlie 已提交
1615
	return 0;
I
Insu Yun 已提交
1616 1617
nomem:
	return -ENOMEM;
D
Dave Airlie 已提交
1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635
}
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 =
1636 1637
		drm_property_create_enum(dev, 0, "scaling mode",
				drm_scaling_mode_enum_list,
D
Dave Airlie 已提交
1638 1639 1640 1641 1642 1643 1644 1645
				    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);

1646 1647 1648 1649 1650 1651 1652 1653
/**
 * 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 已提交
1654
 * Zero on success, negative errno on failure.
1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672
 */
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);

1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687
/**
 * 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 =
1688
		drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
1689
				    "dirty",
1690
				    drm_dirty_info_enum_list,
1691 1692 1693 1694 1695 1696 1697
				    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);

1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721
/**
 * 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 已提交
1722 1723
/**
 * drm_mode_getresources - get graphics configuration
1724 1725 1726
 * @dev: drm device for the ioctl
 * @data: data pointer for the ioctl
 * @file_priv: drm file for the ioctl call
D
Dave Airlie 已提交
1727 1728 1729 1730 1731 1732
 *
 * 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.
 *
1733
 * Returns:
D
Daniel Vetter 已提交
1734
 * Zero on success, negative errno on failure.
D
Dave Airlie 已提交
1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749
 */
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;
1750
	int copied = 0;
D
Dave Airlie 已提交
1751 1752 1753 1754 1755
	uint32_t __user *fb_id;
	uint32_t __user *crtc_id;
	uint32_t __user *connector_id;
	uint32_t __user *encoder_id;

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

D
Dave Airlie 已提交
1759

1760
	mutex_lock(&file_priv->fbs_lock);
D
Dave Airlie 已提交
1761 1762 1763 1764 1765 1766 1767
	/*
	 * 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++;

1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783
	/* 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);

1784 1785 1786
	/* 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);
1787 1788
	drm_for_each_crtc(crtc, dev)
		crtc_count++;
D
Dave Airlie 已提交
1789

1790 1791
	drm_for_each_connector(connector, dev)
		connector_count++;
D
Dave Airlie 已提交
1792

1793 1794
	drm_for_each_encoder(encoder, dev)
		encoder_count++;
D
Dave Airlie 已提交
1795 1796 1797 1798 1799 1800 1801 1802 1803 1804

	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;
1805 1806 1807 1808 1809
		drm_for_each_crtc(crtc, dev) {
			DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id);
			if (put_user(crtc->base.id, crtc_id + copied)) {
				ret = -EFAULT;
				goto out;
D
Dave Airlie 已提交
1810
			}
1811
			copied++;
D
Dave Airlie 已提交
1812 1813 1814 1815 1816 1817 1818 1819
		}
	}
	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;
1820 1821 1822 1823 1824 1825 1826
		drm_for_each_encoder(encoder, dev) {
			DRM_DEBUG_KMS("[ENCODER:%d:%s]\n", encoder->base.id,
					encoder->name);
			if (put_user(encoder->base.id, encoder_id +
				     copied)) {
				ret = -EFAULT;
				goto out;
D
Dave Airlie 已提交
1827
			}
1828
			copied++;
D
Dave Airlie 已提交
1829 1830 1831 1832 1833 1834 1835 1836
		}
	}
	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;
1837 1838 1839 1840 1841 1842 1843 1844
		drm_for_each_connector(connector, dev) {
			DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
				connector->base.id,
				connector->name);
			if (put_user(connector->base.id,
				     connector_id + copied)) {
				ret = -EFAULT;
				goto out;
D
Dave Airlie 已提交
1845
			}
1846
			copied++;
D
Dave Airlie 已提交
1847 1848 1849 1850
		}
	}
	card_res->count_connectors = connector_count;

1851
	DRM_DEBUG_KMS("CRTC[%d] CONNECTORS[%d] ENCODERS[%d]\n", card_res->count_crtcs,
D
Dave Airlie 已提交
1852 1853 1854
		  card_res->count_connectors, card_res->count_encoders);

out:
1855
	mutex_unlock(&dev->mode_config.mutex);
D
Dave Airlie 已提交
1856 1857 1858 1859 1860
	return ret;
}

/**
 * drm_mode_getcrtc - get CRTC configuration
1861 1862 1863
 * @dev: drm device for the ioctl
 * @data: data pointer for the ioctl
 * @file_priv: drm file for the ioctl call
D
Dave Airlie 已提交
1864 1865 1866 1867 1868
 *
 * Construct a CRTC configuration structure to return to the user.
 *
 * Called by the user via ioctl.
 *
1869
 * Returns:
D
Daniel Vetter 已提交
1870
 * Zero on success, negative errno on failure.
D
Dave Airlie 已提交
1871 1872 1873 1874 1875 1876 1877
 */
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;

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

R
Rob Clark 已提交
1881
	crtc = drm_crtc_find(dev, crtc_resp->crtc_id);
1882 1883
	if (!crtc)
		return -ENOENT;
D
Dave Airlie 已提交
1884

1885
	drm_modeset_lock_crtc(crtc, crtc->primary);
D
Dave Airlie 已提交
1886
	crtc_resp->gamma_size = crtc->gamma_size;
1887 1888
	if (crtc->primary->fb)
		crtc_resp->fb_id = crtc->primary->fb->base.id;
D
Dave Airlie 已提交
1889 1890 1891
	else
		crtc_resp->fb_id = 0;

1892 1893 1894 1895
	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) {
1896
			drm_mode_convert_to_umode(&crtc_resp->mode, &crtc->state->mode);
1897
			crtc_resp->mode_valid = 1;
D
Dave Airlie 已提交
1898

1899 1900 1901
		} else {
			crtc_resp->mode_valid = 0;
		}
D
Dave Airlie 已提交
1902
	} else {
1903 1904 1905
		crtc_resp->x = crtc->x;
		crtc_resp->y = crtc->y;
		if (crtc->enabled) {
1906
			drm_mode_convert_to_umode(&crtc_resp->mode, &crtc->mode);
1907 1908 1909 1910 1911
			crtc_resp->mode_valid = 1;

		} else {
			crtc_resp->mode_valid = 0;
		}
D
Dave Airlie 已提交
1912
	}
1913
	drm_modeset_unlock_crtc(crtc);
D
Dave Airlie 已提交
1914

1915
	return 0;
D
Dave Airlie 已提交
1916 1917
}

1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930
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;
}

1931 1932 1933 1934 1935 1936 1937 1938 1939
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;
}

1940
/* helper for getconnector and getproperties ioctls */
R
Rob Clark 已提交
1941
static int get_properties(struct drm_mode_object *obj, bool atomic,
1942 1943 1944
		uint32_t __user *prop_ptr, uint64_t __user *prop_values,
		uint32_t *arg_count_props)
{
R
Rob Clark 已提交
1945 1946 1947 1948 1949 1950
	int props_count;
	int i, ret, copied;

	props_count = obj->properties->count;
	if (!atomic)
		props_count -= obj->properties->atomic_count;
1951 1952

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

R
Rob Clark 已提交
1957 1958 1959
			if ((prop->flags & DRM_MODE_PROP_ATOMIC) && !atomic)
				continue;

1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977
			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 已提交
1978 1979
/**
 * drm_mode_getconnector - get connector configuration
1980 1981 1982
 * @dev: drm device for the ioctl
 * @data: data pointer for the ioctl
 * @file_priv: drm file for the ioctl call
D
Dave Airlie 已提交
1983 1984 1985 1986 1987
 *
 * Construct a connector configuration structure to return to the user.
 *
 * Called by the user via ioctl.
 *
1988
 * Returns:
D
Daniel Vetter 已提交
1989
 * Zero on success, negative errno on failure.
D
Dave Airlie 已提交
1990 1991 1992 1993 1994 1995
 */
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;
1996
	struct drm_encoder *encoder;
D
Dave Airlie 已提交
1997 1998 1999 2000 2001 2002 2003 2004 2005 2006
	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;

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

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

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

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

R
Rob Clark 已提交
2016 2017
	connector = drm_connector_find(dev, out_resp->connector_id);
	if (!connector) {
2018
		ret = -ENOENT;
2019
		goto out_unlock;
D
Dave Airlie 已提交
2020 2021
	}

2022 2023
	for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++)
		if (connector->encoder_ids[i] != 0)
D
Dave Airlie 已提交
2024 2025 2026 2027 2028 2029 2030 2031 2032 2033
			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)
2034 2035
		if (drm_mode_expose_to_userspace(mode, file_priv))
			mode_count++;
D
Dave Airlie 已提交
2036 2037 2038 2039 2040 2041 2042 2043

	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;
2044 2045

	drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
2046 2047 2048
	encoder = drm_connector_get_encoder(connector);
	if (encoder)
		out_resp->encoder_id = encoder->base.id;
D
Dave Airlie 已提交
2049 2050 2051 2052 2053 2054 2055 2056 2057
	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ä 已提交
2058
		mode_ptr = (struct drm_mode_modeinfo __user *)(unsigned long)out_resp->modes_ptr;
D
Dave Airlie 已提交
2059
		list_for_each_entry(mode, &connector->modes, head) {
2060 2061 2062
			if (!drm_mode_expose_to_userspace(mode, file_priv))
				continue;

2063
			drm_mode_convert_to_umode(&u_mode, mode);
D
Dave Airlie 已提交
2064 2065 2066 2067 2068 2069 2070 2071 2072 2073
			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 已提交
2074
	ret = get_properties(&connector->base, file_priv->atomic,
2075 2076 2077 2078 2079
			(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 已提交
2080 2081 2082

	if ((out_resp->count_encoders >= encoders_count) && encoders_count) {
		copied = 0;
V
Ville Syrjälä 已提交
2083
		encoder_ptr = (uint32_t __user *)(unsigned long)(out_resp->encoders_ptr);
D
Dave Airlie 已提交
2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097
		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 已提交
2098
	drm_modeset_unlock(&dev->mode_config.connection_mutex);
2099 2100

out_unlock:
2101 2102
	mutex_unlock(&dev->mode_config.mutex);

D
Dave Airlie 已提交
2103 2104 2105
	return ret;
}

2106 2107 2108 2109 2110 2111 2112 2113
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. */
2114
	drm_for_each_connector(connector, dev) {
2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132
		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;
}

2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143
/**
 * 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 已提交
2144
 * Zero on success, negative errno on failure.
2145
 */
D
Dave Airlie 已提交
2146 2147 2148 2149 2150
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;
2151
	struct drm_crtc *crtc;
D
Dave Airlie 已提交
2152

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

R
Rob Clark 已提交
2156
	encoder = drm_encoder_find(dev, enc_resp->encoder_id);
2157 2158
	if (!encoder)
		return -ENOENT;
D
Dave Airlie 已提交
2159

2160
	drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
2161 2162 2163
	crtc = drm_encoder_get_crtc(encoder);
	if (crtc)
		enc_resp->crtc_id = crtc->base.id;
D
Dave Airlie 已提交
2164 2165
	else
		enc_resp->crtc_id = 0;
2166 2167
	drm_modeset_unlock(&dev->mode_config.connection_mutex);

D
Dave Airlie 已提交
2168 2169 2170 2171 2172
	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;

2173
	return 0;
D
Dave Airlie 已提交
2174 2175
}

J
Jesse Barnes 已提交
2176
/**
2177
 * drm_mode_getplane_res - enumerate all plane resources
J
Jesse Barnes 已提交
2178 2179 2180 2181
 * @dev: DRM device
 * @data: ioctl data
 * @file_priv: DRM file info
 *
2182 2183 2184 2185 2186
 * Construct a list of plane ids to return to the user.
 *
 * Called by the user via ioctl.
 *
 * Returns:
D
Daniel Vetter 已提交
2187
 * Zero on success, negative errno on failure.
J
Jesse Barnes 已提交
2188 2189
 */
int drm_mode_getplane_res(struct drm_device *dev, void *data,
2190
			  struct drm_file *file_priv)
J
Jesse Barnes 已提交
2191 2192 2193 2194 2195
{
	struct drm_mode_get_plane_res *plane_resp = data;
	struct drm_mode_config *config;
	struct drm_plane *plane;
	uint32_t __user *plane_ptr;
2196
	int copied = 0;
2197
	unsigned num_planes;
J
Jesse Barnes 已提交
2198 2199 2200 2201 2202 2203

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

	config = &dev->mode_config;

2204 2205 2206 2207 2208
	if (file_priv->universal_planes)
		num_planes = config->num_total_plane;
	else
		num_planes = config->num_overlay_plane;

J
Jesse Barnes 已提交
2209 2210 2211 2212
	/*
	 * This ioctl is called twice, once to determine how much space is
	 * needed, and the 2nd time to fill it.
	 */
2213 2214
	if (num_planes &&
	    (plane_resp->count_planes >= num_planes)) {
V
Ville Syrjälä 已提交
2215
		plane_ptr = (uint32_t __user *)(unsigned long)plane_resp->plane_id_ptr;
J
Jesse Barnes 已提交
2216

2217
		/* Plane lists are invariant, no locking needed. */
2218
		drm_for_each_plane(plane, dev) {
2219 2220 2221 2222 2223 2224
			/*
			 * Unless userspace set the 'universal planes'
			 * capability bit, only advertise overlays.
			 */
			if (plane->type != DRM_PLANE_TYPE_OVERLAY &&
			    !file_priv->universal_planes)
2225 2226
				continue;

2227 2228
			if (put_user(plane->base.id, plane_ptr + copied))
				return -EFAULT;
J
Jesse Barnes 已提交
2229 2230 2231
			copied++;
		}
	}
2232
	plane_resp->count_planes = num_planes;
J
Jesse Barnes 已提交
2233

2234
	return 0;
J
Jesse Barnes 已提交
2235 2236 2237
}

/**
2238
 * drm_mode_getplane - get plane configuration
J
Jesse Barnes 已提交
2239 2240 2241 2242
 * @dev: DRM device
 * @data: ioctl data
 * @file_priv: DRM file info
 *
2243 2244 2245 2246 2247
 * Construct a plane configuration structure to return to the user.
 *
 * Called by the user via ioctl.
 *
 * Returns:
D
Daniel Vetter 已提交
2248
 * Zero on success, negative errno on failure.
J
Jesse Barnes 已提交
2249 2250
 */
int drm_mode_getplane(struct drm_device *dev, void *data,
2251
		      struct drm_file *file_priv)
J
Jesse Barnes 已提交
2252 2253 2254 2255 2256 2257 2258 2259
{
	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 已提交
2260
	plane = drm_plane_find(dev, plane_resp->plane_id);
2261 2262
	if (!plane)
		return -ENOENT;
J
Jesse Barnes 已提交
2263

2264
	drm_modeset_lock(&plane->mutex, NULL);
J
Jesse Barnes 已提交
2265 2266 2267 2268 2269 2270 2271 2272 2273
	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;
2274
	drm_modeset_unlock(&plane->mutex);
J
Jesse Barnes 已提交
2275 2276 2277

	plane_resp->plane_id = plane->base.id;
	plane_resp->possible_crtcs = plane->possible_crtcs;
2278
	plane_resp->gamma_size = 0;
J
Jesse Barnes 已提交
2279 2280 2281 2282 2283 2284 2285

	/*
	 * 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ä 已提交
2286
		format_ptr = (uint32_t __user *)(unsigned long)plane_resp->format_type_ptr;
J
Jesse Barnes 已提交
2287 2288 2289
		if (copy_to_user(format_ptr,
				 plane->format_types,
				 sizeof(uint32_t) * plane->format_count)) {
2290
			return -EFAULT;
J
Jesse Barnes 已提交
2291 2292 2293 2294
		}
	}
	plane_resp->count_format_types = plane->format_count;

2295
	return 0;
J
Jesse Barnes 已提交
2296 2297
}

2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318
/**
 * 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;
}

2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344
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;
}

2345 2346
/*
 * setplane_internal - setplane handler for internal callers
J
Jesse Barnes 已提交
2347
 *
2348 2349 2350
 * 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.
2351
 *
2352
 * src_{x,y,w,h} are provided in 16.16 fixed point format
J
Jesse Barnes 已提交
2353
 */
2354 2355 2356 2357 2358 2359 2360 2361
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 已提交
2362 2363 2364 2365
{
	int ret = 0;

	/* No fb means shut it down */
2366
	if (!fb) {
2367
		plane->old_fb = plane->fb;
2368 2369 2370 2371 2372
		ret = plane->funcs->disable_plane(plane);
		if (!ret) {
			plane->crtc = NULL;
			plane->fb = NULL;
		} else {
2373
			plane->old_fb = NULL;
2374
		}
J
Jesse Barnes 已提交
2375 2376 2377
		goto out;
	}

2378 2379 2380 2381 2382 2383 2384
	/* 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;
	}

2385
	/* Check whether this plane supports the fb pixel format. */
2386 2387
	ret = drm_plane_check_pixel_format(plane, fb->pixel_format);
	if (ret) {
2388 2389
		DRM_DEBUG_KMS("Invalid pixel format %s\n",
			      drm_get_format_name(fb->pixel_format));
2390 2391 2392
		goto out;
	}

2393 2394 2395 2396 2397 2398 2399
	/* 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);
2400 2401
		ret = -ERANGE;
		goto out;
2402 2403
	}

2404 2405
	ret = check_src_coords(src_x, src_y, src_w, src_h, fb);
	if (ret)
2406 2407
		goto out;

2408
	plane->old_fb = plane->fb;
J
Jesse Barnes 已提交
2409
	ret = plane->funcs->update_plane(plane, crtc, fb,
2410 2411
					 crtc_x, crtc_y, crtc_w, crtc_h,
					 src_x, src_y, src_w, src_h);
J
Jesse Barnes 已提交
2412 2413 2414
	if (!ret) {
		plane->crtc = crtc;
		plane->fb = fb;
2415
		fb = NULL;
2416
	} else {
2417
		plane->old_fb = NULL;
J
Jesse Barnes 已提交
2418 2419 2420
	}

out:
2421 2422
	if (fb)
		drm_framebuffer_unreference(fb);
2423 2424 2425
	if (plane->old_fb)
		drm_framebuffer_unreference(plane->old_fb);
	plane->old_fb = NULL;
J
Jesse Barnes 已提交
2426 2427

	return ret;
2428
}
2429

2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447
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;
2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460
}

/**
 * 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 已提交
2461
 * Zero on success, negative errno on failure.
2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477
 */
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 已提交
2478 2479
	plane = drm_plane_find(dev, plane_req->plane_id);
	if (!plane) {
2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492
		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 已提交
2493 2494
		crtc = drm_crtc_find(dev, plane_req->crtc_id);
		if (!crtc) {
2495 2496 2497 2498 2499 2500
			DRM_DEBUG_KMS("Unknown crtc ID %d\n",
				      plane_req->crtc_id);
			return -ENOENT;
		}
	}

2501 2502 2503 2504
	/*
	 * setplane_internal will take care of deref'ing either the old or new
	 * framebuffer depending on success.
	 */
2505
	return setplane_internal(plane, crtc, fb,
2506 2507 2508 2509
				 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 已提交
2510 2511
}

2512 2513 2514 2515 2516 2517
/**
 * 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.
2518
 *
2519
 * Returns:
D
Daniel Vetter 已提交
2520
 * Zero on success, negative errno on failure.
2521 2522 2523 2524
 */
int drm_mode_set_config_internal(struct drm_mode_set *set)
{
	struct drm_crtc *crtc = set->crtc;
D
Daniel Vetter 已提交
2525 2526
	struct drm_framebuffer *fb;
	struct drm_crtc *tmp;
2527 2528
	int ret;

D
Daniel Vetter 已提交
2529 2530 2531 2532 2533
	/*
	 * 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 ...
	 */
2534
	drm_for_each_crtc(tmp, crtc->dev)
2535
		tmp->primary->old_fb = tmp->primary->fb;
D
Daniel Vetter 已提交
2536

2537
	fb = set->fb;
2538

2539 2540
	ret = crtc->funcs->set_config(set);
	if (ret == 0) {
2541
		crtc->primary->crtc = crtc;
2542
		crtc->primary->fb = fb;
D
Daniel Vetter 已提交
2543
	}
2544

2545
	drm_for_each_crtc(tmp, crtc->dev) {
2546 2547
		if (tmp->primary->fb)
			drm_framebuffer_reference(tmp->primary->fb);
2548 2549 2550
		if (tmp->primary->old_fb)
			drm_framebuffer_unreference(tmp->primary->old_fb);
		tmp->primary->old_fb = NULL;
2551 2552 2553
	}

	return ret;
2554 2555 2556
}
EXPORT_SYMBOL(drm_mode_set_config_internal);

2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577
/**
 * 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);

2578 2579 2580 2581 2582 2583 2584 2585
/**
 * 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
2586
 */
2587 2588 2589 2590
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)
2591 2592 2593 2594

{
	int hdisplay, vdisplay;

2595
	drm_crtc_get_hv_timing(mode, &hdisplay, &vdisplay);
2596

2597 2598 2599
	if (crtc->state &&
	    crtc->primary->state->rotation & (BIT(DRM_ROTATE_90) |
					      BIT(DRM_ROTATE_270)))
2600 2601
		swap(hdisplay, vdisplay);

2602 2603
	return check_src_coords(x << 16, y << 16,
				hdisplay << 16, vdisplay << 16, fb);
2604
}
2605
EXPORT_SYMBOL(drm_crtc_check_viewport);
2606

D
Dave Airlie 已提交
2607 2608
/**
 * drm_mode_setcrtc - set CRTC configuration
2609 2610 2611
 * @dev: drm device for the ioctl
 * @data: data pointer for the ioctl
 * @file_priv: drm file for the ioctl call
D
Dave Airlie 已提交
2612 2613 2614 2615 2616
 *
 * Build a new CRTC configuration based on user request.
 *
 * Called by the user via ioctl.
 *
2617
 * Returns:
D
Daniel Vetter 已提交
2618
 * Zero on success, negative errno on failure.
D
Dave Airlie 已提交
2619 2620 2621 2622 2623 2624
 */
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;
2625
	struct drm_crtc *crtc;
D
Dave Airlie 已提交
2626 2627 2628 2629 2630
	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;
2631
	int ret;
D
Dave Airlie 已提交
2632 2633
	int i;

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

2637 2638 2639 2640 2641
	/*
	 * 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)
2642 2643
		return -ERANGE;

2644
	drm_modeset_lock_all(dev);
R
Rob Clark 已提交
2645 2646
	crtc = drm_crtc_find(dev, crtc_req->crtc_id);
	if (!crtc) {
2647
		DRM_DEBUG_KMS("Unknown CRTC ID %d\n", crtc_req->crtc_id);
2648
		ret = -ENOENT;
D
Dave Airlie 已提交
2649 2650
		goto out;
	}
2651
	DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id);
D
Dave Airlie 已提交
2652 2653 2654 2655 2656

	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) {
2657
			if (!crtc->primary->fb) {
2658 2659 2660
				DRM_DEBUG_KMS("CRTC doesn't have current FB\n");
				ret = -EINVAL;
				goto out;
D
Dave Airlie 已提交
2661
			}
2662
			fb = crtc->primary->fb;
2663 2664
			/* Make refcounting symmetric with the lookup path. */
			drm_framebuffer_reference(fb);
D
Dave Airlie 已提交
2665
		} else {
2666 2667
			fb = drm_framebuffer_lookup(dev, crtc_req->fb_id);
			if (!fb) {
2668 2669
				DRM_DEBUG_KMS("Unknown FB ID%d\n",
						crtc_req->fb_id);
2670
				ret = -ENOENT;
D
Dave Airlie 已提交
2671 2672 2673 2674 2675
				goto out;
			}
		}

		mode = drm_mode_create(dev);
2676 2677 2678 2679 2680
		if (!mode) {
			ret = -ENOMEM;
			goto out;
		}

2681
		ret = drm_mode_convert_umode(mode, &crtc_req->mode);
2682 2683 2684 2685 2686
		if (ret) {
			DRM_DEBUG_KMS("Invalid mode\n");
			goto out;
		}

D
Dave Airlie 已提交
2687
		drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
2688

2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705
		/*
		 * 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;
			}
		}

2706 2707 2708
		ret = drm_crtc_check_viewport(crtc, crtc_req->x, crtc_req->y,
					      mode, fb);
		if (ret)
2709
			goto out;
2710

D
Dave Airlie 已提交
2711 2712 2713
	}

	if (crtc_req->count_connectors == 0 && mode) {
2714
		DRM_DEBUG_KMS("Count connectors is 0 but mode set\n");
D
Dave Airlie 已提交
2715 2716 2717 2718
		ret = -EINVAL;
		goto out;
	}

2719
	if (crtc_req->count_connectors > 0 && (!mode || !fb)) {
2720
		DRM_DEBUG_KMS("Count connectors is %d but no mode or fb set\n",
D
Dave Airlie 已提交
2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734
			  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;
		}

2735 2736 2737
		connector_set = kmalloc_array(crtc_req->count_connectors,
					      sizeof(struct drm_connector *),
					      GFP_KERNEL);
D
Dave Airlie 已提交
2738 2739 2740 2741 2742 2743
		if (!connector_set) {
			ret = -ENOMEM;
			goto out;
		}

		for (i = 0; i < crtc_req->count_connectors; i++) {
V
Ville Syrjälä 已提交
2744
			set_connectors_ptr = (uint32_t __user *)(unsigned long)crtc_req->set_connectors_ptr;
D
Dave Airlie 已提交
2745 2746 2747 2748 2749
			if (get_user(out_id, &set_connectors_ptr[i])) {
				ret = -EFAULT;
				goto out;
			}

R
Rob Clark 已提交
2750 2751
			connector = drm_connector_find(dev, out_id);
			if (!connector) {
2752 2753
				DRM_DEBUG_KMS("Connector id %d unknown\n",
						out_id);
2754
				ret = -ENOENT;
D
Dave Airlie 已提交
2755 2756
				goto out;
			}
2757 2758
			DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
					connector->base.id,
2759
					connector->name);
D
Dave Airlie 已提交
2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770

			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;
2771
	set.fb = fb;
2772
	ret = drm_mode_set_config_internal(&set);
D
Dave Airlie 已提交
2773 2774

out:
2775 2776 2777
	if (fb)
		drm_framebuffer_unreference(fb);

D
Dave Airlie 已提交
2778
	kfree(connector_set);
2779
	drm_mode_destroy(dev, mode);
2780
	drm_modeset_unlock_all(dev);
D
Dave Airlie 已提交
2781 2782 2783
	return ret;
}

2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800
/**
 * 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 已提交
2801
 * Zero on success, negative errno on failure.
2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821
 */
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);
2822
	WARN_ON(crtc->cursor->crtc != crtc && crtc->cursor->crtc != NULL);
2823 2824 2825 2826 2827 2828 2829 2830

	/*
	 * 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) {
2831
			fb = internal_framebuffer_create(dev, &fbreq, file_priv);
2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863
			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.
	 */
2864
	ret = __setplane_internal(crtc->cursor, crtc, fb,
2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876
				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;
}

2877 2878 2879
static int drm_mode_cursor_common(struct drm_device *dev,
				  struct drm_mode_cursor2 *req,
				  struct drm_file *file_priv)
D
Dave Airlie 已提交
2880 2881 2882 2883
{
	struct drm_crtc *crtc;
	int ret = 0;

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

2887
	if (!req->flags || (~DRM_MODE_CURSOR_FLAGS & req->flags))
D
Dave Airlie 已提交
2888 2889
		return -EINVAL;

R
Rob Clark 已提交
2890 2891
	crtc = drm_crtc_find(dev, req->crtc_id);
	if (!crtc) {
2892
		DRM_DEBUG_KMS("Unknown CRTC ID %d\n", req->crtc_id);
2893
		return -ENOENT;
D
Dave Airlie 已提交
2894 2895
	}

2896 2897 2898 2899
	/*
	 * If this crtc has a universal cursor plane, call that plane's update
	 * handler rather than using legacy cursor handlers.
	 */
D
Daniel Vetter 已提交
2900
	drm_modeset_lock_crtc(crtc, crtc->cursor);
2901 2902 2903 2904 2905
	if (crtc->cursor) {
		ret = drm_mode_cursor_universal(crtc, req, file_priv);
		goto out;
	}

D
Dave Airlie 已提交
2906
	if (req->flags & DRM_MODE_CURSOR_BO) {
2907
		if (!crtc->funcs->cursor_set && !crtc->funcs->cursor_set2) {
D
Dave Airlie 已提交
2908 2909 2910 2911
			ret = -ENXIO;
			goto out;
		}
		/* Turns off the cursor if handle is 0 */
2912 2913 2914 2915 2916 2917
		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 已提交
2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928
	}

	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:
2929
	drm_modeset_unlock_crtc(crtc);
2930

D
Dave Airlie 已提交
2931
	return ret;
2932 2933

}
2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946


/**
 * 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 已提交
2947
 * Zero on success, negative errno on failure.
2948
 */
2949
int drm_mode_cursor_ioctl(struct drm_device *dev,
2950
			  void *data, struct drm_file *file_priv)
2951 2952 2953 2954 2955 2956 2957 2958 2959 2960
{
	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);
}

2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973
/**
 * 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 已提交
2974
 * Zero on success, negative errno on failure.
2975
 */
2976 2977 2978 2979
int drm_mode_cursor2_ioctl(struct drm_device *dev,
			   void *data, struct drm_file *file_priv)
{
	struct drm_mode_cursor2 *req = data;
2980

2981
	return drm_mode_cursor_common(dev, req, file_priv);
D
Dave Airlie 已提交
2982 2983
}

2984 2985 2986 2987 2988 2989 2990 2991
/**
 * 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.
 */
2992 2993 2994 2995 2996 2997
uint32_t drm_mode_legacy_fb_format(uint32_t bpp, uint32_t depth)
{
	uint32_t fmt;

	switch (bpp) {
	case 8:
2998
		fmt = DRM_FORMAT_C8;
2999 3000 3001
		break;
	case 16:
		if (depth == 15)
V
Ville Syrjälä 已提交
3002
			fmt = DRM_FORMAT_XRGB1555;
3003
		else
V
Ville Syrjälä 已提交
3004
			fmt = DRM_FORMAT_RGB565;
3005 3006
		break;
	case 24:
V
Ville Syrjälä 已提交
3007
		fmt = DRM_FORMAT_RGB888;
3008 3009 3010
		break;
	case 32:
		if (depth == 24)
V
Ville Syrjälä 已提交
3011
			fmt = DRM_FORMAT_XRGB8888;
3012
		else if (depth == 30)
V
Ville Syrjälä 已提交
3013
			fmt = DRM_FORMAT_XRGB2101010;
3014
		else
V
Ville Syrjälä 已提交
3015
			fmt = DRM_FORMAT_ARGB8888;
3016 3017
		break;
	default:
V
Ville Syrjälä 已提交
3018 3019
		DRM_ERROR("bad bpp, assuming x8r8g8b8 pixel format\n");
		fmt = DRM_FORMAT_XRGB8888;
3020 3021 3022 3023 3024 3025 3026
		break;
	}

	return fmt;
}
EXPORT_SYMBOL(drm_mode_legacy_fb_format);

D
Dave Airlie 已提交
3027 3028
/**
 * drm_mode_addfb - add an FB to the graphics configuration
3029 3030 3031
 * @dev: drm device for the ioctl
 * @data: data pointer for the ioctl
 * @file_priv: drm file for the ioctl call
D
Dave Airlie 已提交
3032
 *
3033
 * Add a new FB to the specified CRTC, given a user request. This is the
C
Chuck Ebbert 已提交
3034
 * original addfb ioctl which only supported RGB formats.
D
Dave Airlie 已提交
3035 3036 3037
 *
 * Called by the user via ioctl.
 *
3038
 * Returns:
D
Daniel Vetter 已提交
3039
 * Zero on success, negative errno on failure.
D
Dave Airlie 已提交
3040 3041 3042 3043
 */
int drm_mode_addfb(struct drm_device *dev,
		   void *data, struct drm_file *file_priv)
{
3044 3045
	struct drm_mode_fb_cmd *or = data;
	struct drm_mode_fb_cmd2 r = {};
3046
	int ret;
3047

3048
	/* convert to new format and call new ioctl */
3049 3050 3051 3052 3053 3054 3055
	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;

3056 3057 3058
	ret = drm_mode_addfb2(dev, &r, file_priv);
	if (ret)
		return ret;
3059

3060
	or->fb_id = r.fb_id;
3061

3062
	return 0;
3063 3064
}

3065
static int format_check(const struct drm_mode_fb_cmd2 *r)
3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117
{
	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:
3118 3119
	case DRM_FORMAT_NV24:
	case DRM_FORMAT_NV42:
3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131
	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:
3132 3133
		DRM_DEBUG_KMS("invalid pixel format %s\n",
			      drm_get_format_name(r->pixel_format));
3134 3135 3136 3137
		return -EINVAL;
	}
}

3138
static int framebuffer_check(const struct drm_mode_fb_cmd2 *r)
3139 3140 3141 3142 3143
{
	int ret, hsub, vsub, num_planes, i;

	ret = format_check(r);
	if (ret) {
3144 3145
		DRM_DEBUG_KMS("bad framebuffer format %s\n",
			      drm_get_format_name(r->pixel_format));
3146 3147 3148 3149 3150 3151 3152 3153
		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 已提交
3154
		DRM_DEBUG_KMS("bad framebuffer width %u\n", r->width);
3155 3156 3157 3158
		return -EINVAL;
	}

	if (r->height == 0 || r->height % vsub) {
3159
		DRM_DEBUG_KMS("bad framebuffer height %u\n", r->height);
3160 3161 3162 3163 3164
		return -EINVAL;
	}

	for (i = 0; i < num_planes; i++) {
		unsigned int width = r->width / (i != 0 ? hsub : 1);
3165 3166
		unsigned int height = r->height / (i != 0 ? vsub : 1);
		unsigned int cpp = drm_format_plane_cpp(r->pixel_format, i);
3167 3168

		if (!r->handles[i]) {
3169
			DRM_DEBUG_KMS("no buffer object handle for plane %d\n", i);
3170 3171 3172
			return -EINVAL;
		}

3173 3174 3175 3176 3177 3178 3179
		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) {
3180
			DRM_DEBUG_KMS("bad pitch %u for plane %d\n", r->pitches[i], i);
3181 3182
			return -EINVAL;
		}
3183 3184 3185 3186 3187 3188

		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;
		}
3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206

		/* 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;
		}
3207 3208
	}

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

3235 3236 3237
	return 0;
}

3238 3239
static struct drm_framebuffer *
internal_framebuffer_create(struct drm_device *dev,
3240
			    const struct drm_mode_fb_cmd2 *r,
3241
			    struct drm_file *file_priv)
3242
{
D
Dave Airlie 已提交
3243 3244
	struct drm_mode_config *config = &dev->mode_config;
	struct drm_framebuffer *fb;
3245
	int ret;
D
Dave Airlie 已提交
3246

3247
	if (r->flags & ~(DRM_MODE_FB_INTERLACED | DRM_MODE_FB_MODIFIERS)) {
3248
		DRM_DEBUG_KMS("bad framebuffer flags 0x%08x\n", r->flags);
3249
		return ERR_PTR(-EINVAL);
3250 3251
	}

D
Dave Airlie 已提交
3252
	if ((config->min_width > r->width) || (r->width > config->max_width)) {
3253
		DRM_DEBUG_KMS("bad framebuffer width %d, should be >= %d && <= %d\n",
J
Jesse Barnes 已提交
3254
			  r->width, config->min_width, config->max_width);
3255
		return ERR_PTR(-EINVAL);
D
Dave Airlie 已提交
3256 3257
	}
	if ((config->min_height > r->height) || (r->height > config->max_height)) {
3258
		DRM_DEBUG_KMS("bad framebuffer height %d, should be >= %d && <= %d\n",
J
Jesse Barnes 已提交
3259
			  r->height, config->min_height, config->max_height);
3260
		return ERR_PTR(-EINVAL);
D
Dave Airlie 已提交
3261 3262
	}

3263 3264 3265 3266 3267 3268
	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);
	}

3269 3270
	ret = framebuffer_check(r);
	if (ret)
3271
		return ERR_PTR(ret);
3272

D
Dave Airlie 已提交
3273
	fb = dev->mode_config.funcs->fb_create(dev, file_priv, r);
3274
	if (IS_ERR(fb)) {
3275
		DRM_DEBUG_KMS("could not create framebuffer\n");
3276
		return fb;
D
Dave Airlie 已提交
3277 3278
	}

3279 3280
	return fb;
}
3281

3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294
/**
 * 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 已提交
3295
 * Zero on success, negative errno on failure.
3296 3297 3298 3299
 */
int drm_mode_addfb2(struct drm_device *dev,
		    void *data, struct drm_file *file_priv)
{
3300
	struct drm_mode_fb_cmd2 *r = data;
3301 3302 3303 3304 3305
	struct drm_framebuffer *fb;

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

3306
	fb = internal_framebuffer_create(dev, r, file_priv);
3307 3308 3309
	if (IS_ERR(fb))
		return PTR_ERR(fb);

3310 3311 3312 3313 3314 3315 3316 3317
	/* Transfer ownership to the filp for reaping on close */

	DRM_DEBUG_KMS("[FB:%d]\n", fb->base.id);
	mutex_lock(&file_priv->fbs_lock);
	r->fb_id = fb->base.id;
	list_add(&fb->filp_head, &file_priv->fbs);
	mutex_unlock(&file_priv->fbs_lock);

3318
	return 0;
D
Dave Airlie 已提交
3319 3320 3321 3322
}

/**
 * drm_mode_rmfb - remove an FB from the configuration
3323 3324 3325
 * @dev: drm device for the ioctl
 * @data: data pointer for the ioctl
 * @file_priv: drm file for the ioctl call
D
Dave Airlie 已提交
3326 3327 3328 3329 3330
 *
 * Remove the FB specified by the user.
 *
 * Called by the user via ioctl.
 *
3331
 * Returns:
D
Daniel Vetter 已提交
3332
 * Zero on success, negative errno on failure.
D
Dave Airlie 已提交
3333 3334 3335 3336 3337 3338 3339 3340 3341
 */
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;

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

3345
	mutex_lock(&file_priv->fbs_lock);
3346 3347 3348 3349 3350
	mutex_lock(&dev->mode_config.fb_lock);
	fb = __drm_framebuffer_lookup(dev, *id);
	if (!fb)
		goto fail_lookup;

D
Dave Airlie 已提交
3351 3352 3353
	list_for_each_entry(fbl, &file_priv->fbs, filp_head)
		if (fb == fbl)
			found = 1;
3354 3355 3356
	if (!found)
		goto fail_lookup;

3357
	list_del_init(&fb->filp_head);
3358
	mutex_unlock(&dev->mode_config.fb_lock);
3359
	mutex_unlock(&file_priv->fbs_lock);
D
Dave Airlie 已提交
3360

3361
	drm_framebuffer_unreference(fb);
3362

3363 3364 3365 3366 3367 3368
	return 0;

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

3369
	return -ENOENT;
D
Dave Airlie 已提交
3370 3371 3372 3373
}

/**
 * drm_mode_getfb - get FB info
3374 3375 3376
 * @dev: drm device for the ioctl
 * @data: data pointer for the ioctl
 * @file_priv: drm file for the ioctl call
D
Dave Airlie 已提交
3377 3378 3379 3380 3381
 *
 * Lookup the FB given its ID and return info about it.
 *
 * Called by the user via ioctl.
 *
3382
 * Returns:
D
Daniel Vetter 已提交
3383
 * Zero on success, negative errno on failure.
D
Dave Airlie 已提交
3384 3385 3386 3387 3388 3389
 */
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;
3390
	int ret;
D
Dave Airlie 已提交
3391

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

3395
	fb = drm_framebuffer_lookup(dev, r->fb_id);
3396
	if (!fb)
3397
		return -ENOENT;
D
Dave Airlie 已提交
3398 3399 3400 3401 3402

	r->height = fb->height;
	r->width = fb->width;
	r->depth = fb->depth;
	r->bpp = fb->bits_per_pixel;
3403
	r->pitch = fb->pitches[0];
3404
	if (fb->funcs->create_handle) {
3405
		if (file_priv->is_master || capable(CAP_SYS_ADMIN) ||
3406
		    drm_is_control_client(file_priv)) {
3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418
			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 {
3419
		ret = -ENODEV;
3420
	}
D
Dave Airlie 已提交
3421

3422 3423
	drm_framebuffer_unreference(fb);

D
Dave Airlie 已提交
3424 3425 3426
	return ret;
}

3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443
/**
 * 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 已提交
3444
 * Zero on success, negative errno on failure.
3445
 */
3446 3447 3448 3449 3450 3451 3452 3453 3454
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;
3455
	int ret;
3456

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

3460
	fb = drm_framebuffer_lookup(dev, r->fb_id);
3461
	if (!fb)
3462
		return -ENOENT;
3463 3464

	num_clips = r->num_clips;
V
Ville Syrjälä 已提交
3465
	clips_ptr = (struct drm_clip_rect __user *)(unsigned long)r->clips_ptr;
3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480

	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) {
3481 3482 3483 3484
		if (num_clips < 0 || num_clips > DRM_MODE_FB_DIRTY_MAX_CLIPS) {
			ret = -EINVAL;
			goto out_err1;
		}
3485
		clips = kcalloc(num_clips, sizeof(*clips), GFP_KERNEL);
3486 3487 3488 3489 3490 3491 3492
		if (!clips) {
			ret = -ENOMEM;
			goto out_err1;
		}

		ret = copy_from_user(clips, clips_ptr,
				     num_clips * sizeof(*clips));
3493 3494
		if (ret) {
			ret = -EFAULT;
3495
			goto out_err2;
3496
		}
3497 3498 3499
	}

	if (fb->funcs->dirty) {
3500 3501
		ret = fb->funcs->dirty(fb, file_priv, flags, r->color,
				       clips, num_clips);
3502 3503 3504 3505 3506 3507 3508
	} else {
		ret = -ENOSYS;
	}

out_err2:
	kfree(clips);
out_err1:
3509 3510
	drm_framebuffer_unreference(fb);

3511 3512 3513 3514
	return ret;
}


D
Dave Airlie 已提交
3515 3516
/**
 * drm_fb_release - remove and free the FBs on this file
3517
 * @priv: drm file for the ioctl
D
Dave Airlie 已提交
3518 3519 3520 3521 3522
 *
 * Destroy all the FBs associated with @filp.
 *
 * Called by the user via ioctl.
 *
3523
 * Returns:
D
Daniel Vetter 已提交
3524
 * Zero on success, negative errno on failure.
D
Dave Airlie 已提交
3525
 */
3526
void drm_fb_release(struct drm_file *priv)
D
Dave Airlie 已提交
3527 3528 3529
{
	struct drm_framebuffer *fb, *tfb;

3530 3531
	/*
	 * When the file gets released that means no one else can access the fb
3532
	 * list any more, so no need to grab fpriv->fbs_lock. And we need to
3533 3534 3535 3536 3537 3538 3539
	 * 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 已提交
3540
	list_for_each_entry_safe(fb, tfb, &priv->fbs, filp_head) {
3541
		list_del_init(&fb->filp_head);
3542

3543
		/* This drops the fpriv->fbs reference. */
3544
		drm_framebuffer_unreference(fb);
D
Dave Airlie 已提交
3545 3546 3547
	}
}

3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558
/**
 * 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.
 *
3559 3560 3561 3562
 * 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.
 *
3563 3564 3565
 * Returns:
 * A pointer to the newly created property on success, NULL on failure.
 */
D
Dave Airlie 已提交
3566 3567 3568 3569
struct drm_property *drm_property_create(struct drm_device *dev, int flags,
					 const char *name, int num_values)
{
	struct drm_property *property = NULL;
3570
	int ret;
D
Dave Airlie 已提交
3571 3572 3573 3574 3575

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

R
Rob Clark 已提交
3576 3577
	property->dev = dev;

D
Dave Airlie 已提交
3578
	if (num_values) {
3579 3580
		property->values = kcalloc(num_values, sizeof(uint64_t),
					   GFP_KERNEL);
D
Dave Airlie 已提交
3581 3582 3583 3584
		if (!property->values)
			goto fail;
	}

3585 3586 3587 3588
	ret = drm_mode_object_get(dev, &property->base, DRM_MODE_OBJECT_PROPERTY);
	if (ret)
		goto fail;

D
Dave Airlie 已提交
3589 3590
	property->flags = flags;
	property->num_values = num_values;
3591
	INIT_LIST_HEAD(&property->enum_list);
D
Dave Airlie 已提交
3592

3593
	if (name) {
D
Dave Airlie 已提交
3594
		strncpy(property->name, name, DRM_PROP_NAME_LEN);
3595 3596
		property->name[DRM_PROP_NAME_LEN-1] = '\0';
	}
D
Dave Airlie 已提交
3597 3598

	list_add_tail(&property->head, &dev->mode_config.property_list);
R
Rob Clark 已提交
3599 3600 3601

	WARN_ON(!drm_property_type_valid(property));

D
Dave Airlie 已提交
3602 3603
	return property;
fail:
3604
	kfree(property->values);
D
Dave Airlie 已提交
3605 3606 3607 3608 3609
	kfree(property);
	return NULL;
}
EXPORT_SYMBOL(drm_property_create);

3610
/**
3611
 * drm_property_create_enum - create a new enumeration property type
3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627
 * @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.
 */
3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655
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);

3656
/**
3657
 * drm_property_create_bitmask - create a new bitmask property type
3658 3659 3660 3661
 * @dev: drm device
 * @flags: flags specifying the property type
 * @name: name of the property
 * @props: enumeration lists with property bitflags
D
Daniel Vetter 已提交
3662 3663
 * @num_props: size of the @props array
 * @supported_bits: bitmask of all supported enumeration values
3664
 *
D
Daniel Vetter 已提交
3665
 * This creates a new bitmask drm property which can then be attached to a drm
3666 3667 3668 3669 3670 3671 3672 3673 3674
 * 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 已提交
3675 3676 3677
struct drm_property *drm_property_create_bitmask(struct drm_device *dev,
					 int flags, const char *name,
					 const struct drm_prop_enum_list *props,
3678 3679
					 int num_props,
					 uint64_t supported_bits)
R
Rob Clark 已提交
3680 3681
{
	struct drm_property *property;
3682 3683
	int i, ret, index = 0;
	int num_values = hweight64(supported_bits);
R
Rob Clark 已提交
3684 3685 3686 3687 3688 3689

	flags |= DRM_MODE_PROP_BITMASK;

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

3694 3695 3696 3697 3698 3699
		if (WARN_ON(index >= num_values)) {
			drm_property_destroy(dev, property);
			return NULL;
		}

		ret = drm_property_add_enum(property, index++,
R
Rob Clark 已提交
3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711
				      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 已提交
3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727
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;
}

3728
/**
3729
 * drm_property_create_range - create a new unsigned ranged property type
3730 3731 3732 3733 3734 3735 3736 3737 3738 3739
 * @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.
 *
3740 3741
 * Userspace is allowed to set any unsigned integer value in the (min, max)
 * range inclusive.
3742 3743 3744 3745
 *
 * Returns:
 * A pointer to the newly created property on success, NULL on failure.
 */
3746 3747 3748 3749
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 已提交
3750 3751
	return property_create_range(dev, DRM_MODE_PROP_RANGE | flags,
			name, min, max);
3752 3753 3754
}
EXPORT_SYMBOL(drm_property_create_range);

3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772
/**
 * 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 已提交
3773 3774 3775 3776 3777 3778 3779 3780 3781
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);

3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798
/**
 * 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 已提交
3799 3800 3801 3802 3803 3804 3805
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;

3806 3807 3808
	if (WARN_ON(!(flags & DRM_MODE_PROP_ATOMIC)))
		return NULL;

R
Rob Clark 已提交
3809 3810 3811 3812 3813 3814 3815 3816 3817 3818
	property = drm_property_create(dev, flags, name, 1);
	if (!property)
		return NULL;

	property->values[0] = type;

	return property;
}
EXPORT_SYMBOL(drm_property_create_object);

3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840
/**
 * 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);

3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855
/**
 * 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 已提交
3856 3857 3858 3859 3860
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 已提交
3861 3862
	if (!(drm_property_type_is(property, DRM_MODE_PROP_ENUM) ||
			drm_property_type_is(property, DRM_MODE_PROP_BITMASK)))
R
Rob Clark 已提交
3863 3864 3865 3866 3867 3868
		return -EINVAL;

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

3873 3874
	if (!list_empty(&property->enum_list)) {
		list_for_each_entry(prop_enum, &property->enum_list, head) {
D
Dave Airlie 已提交
3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891
			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;
3892
	list_add_tail(&prop_enum->head, &property->enum_list);
D
Dave Airlie 已提交
3893 3894 3895 3896
	return 0;
}
EXPORT_SYMBOL(drm_property_add_enum);

3897 3898 3899 3900 3901 3902 3903 3904
/**
 * 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 已提交
3905 3906 3907 3908
void drm_property_destroy(struct drm_device *dev, struct drm_property *property)
{
	struct drm_property_enum *prop_enum, *pt;

3909
	list_for_each_entry_safe(prop_enum, pt, &property->enum_list, head) {
D
Dave Airlie 已提交
3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921
		list_del(&prop_enum->head);
		kfree(prop_enum);
	}

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

3922 3923 3924 3925 3926 3927 3928 3929 3930 3931
/**
 * 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.
 */
3932 3933 3934 3935
void drm_object_attach_property(struct drm_mode_object *obj,
				struct drm_property *property,
				uint64_t init_val)
{
3936
	int count = obj->properties->count;
3937

3938 3939 3940 3941 3942 3943
	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;
3944 3945
	}

3946
	obj->properties->properties[count] = property;
3947 3948
	obj->properties->values[count] = init_val;
	obj->properties->count++;
R
Rob Clark 已提交
3949 3950
	if (property->flags & DRM_MODE_PROP_ATOMIC)
		obj->properties->atomic_count++;
3951 3952 3953
}
EXPORT_SYMBOL(drm_object_attach_property);

3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966
/**
 * 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.
 */
3967 3968 3969 3970 3971
int drm_object_property_set_value(struct drm_mode_object *obj,
				  struct drm_property *property, uint64_t val)
{
	int i;

3972
	for (i = 0; i < obj->properties->count; i++) {
3973
		if (obj->properties->properties[i] == property) {
3974 3975 3976 3977 3978 3979 3980 3981 3982
			obj->properties->values[i] = val;
			return 0;
		}
	}

	return -EINVAL;
}
EXPORT_SYMBOL(drm_object_property_set_value);

3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996
/**
 * 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.
 */
3997 3998 3999 4000 4001
int drm_object_property_get_value(struct drm_mode_object *obj,
				  struct drm_property *property, uint64_t *val)
{
	int i;

R
Rob Clark 已提交
4002 4003 4004 4005 4006 4007 4008 4009
	/* 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);

4010
	for (i = 0; i < obj->properties->count; i++) {
4011
		if (obj->properties->properties[i] == property) {
4012 4013 4014 4015 4016 4017 4018 4019 4020
			*val = obj->properties->values[i];
			return 0;
		}
	}

	return -EINVAL;
}
EXPORT_SYMBOL(drm_object_property_get_value);

4021
/**
D
Daniel Vetter 已提交
4022
 * drm_mode_getproperty_ioctl - get the property metadata
4023 4024 4025 4026
 * @dev: DRM device
 * @data: ioctl data
 * @file_priv: DRM file info
 *
D
Daniel Vetter 已提交
4027 4028 4029 4030
 * 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
4031 4032 4033 4034
 *
 * Called by the user via ioctl.
 *
 * Returns:
D
Daniel Vetter 已提交
4035
 * Zero on success, negative errno on failure.
4036
 */
D
Dave Airlie 已提交
4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049
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;

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

4053
	drm_modeset_lock_all(dev);
R
Rob Clark 已提交
4054 4055
	property = drm_property_find(dev, out_resp->prop_id);
	if (!property) {
4056
		ret = -ENOENT;
D
Dave Airlie 已提交
4057 4058 4059
		goto done;
	}

R
Rob Clark 已提交
4060 4061
	if (drm_property_type_is(property, DRM_MODE_PROP_ENUM) ||
			drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
4062
		list_for_each_entry(prop_enum, &property->enum_list, head)
D
Dave Airlie 已提交
4063 4064 4065 4066 4067 4068 4069 4070 4071 4072
			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ä 已提交
4073
		values_ptr = (uint64_t __user *)(unsigned long)out_resp->values_ptr;
D
Dave Airlie 已提交
4074 4075 4076 4077 4078 4079 4080 4081 4082
		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 已提交
4083 4084
	if (drm_property_type_is(property, DRM_MODE_PROP_ENUM) ||
			drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
D
Dave Airlie 已提交
4085 4086
		if ((out_resp->count_enum_blobs >= enum_count) && enum_count) {
			copied = 0;
V
Ville Syrjälä 已提交
4087
			enum_ptr = (struct drm_mode_property_enum __user *)(unsigned long)out_resp->enum_blob_ptr;
4088
			list_for_each_entry(prop_enum, &property->enum_list, head) {
D
Dave Airlie 已提交
4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105

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

4106 4107 4108 4109 4110 4111 4112 4113 4114 4115
	/*
	 * 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 已提交
4116
done:
4117
	drm_modeset_unlock_all(dev);
D
Dave Airlie 已提交
4118 4119 4120
	return ret;
}

4121 4122 4123 4124 4125 4126 4127 4128 4129
/**
 * 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
4130 4131 4132 4133
 *
 * Returns:
 * New blob property with a single reference on success, or an ERR_PTR
 * value on failure.
4134
 */
4135
struct drm_property_blob *
4136
drm_property_create_blob(struct drm_device *dev, size_t length,
4137
			 const void *data)
D
Dave Airlie 已提交
4138 4139
{
	struct drm_property_blob *blob;
4140
	int ret;
D
Dave Airlie 已提交
4141

4142
	if (!length || length > ULONG_MAX - sizeof(struct drm_property_blob))
4143
		return ERR_PTR(-EINVAL);
D
Dave Airlie 已提交
4144 4145 4146

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

4149 4150 4151
	/* 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 已提交
4152
	blob->length = length;
4153
	blob->dev = dev;
D
Daniel Stone 已提交
4154

4155 4156
	if (data)
		memcpy(blob->data, data, length);
D
Daniel Stone 已提交
4157 4158 4159

	mutex_lock(&dev->mode_config.blob_lock);

4160 4161 4162
	ret = drm_mode_object_get(dev, &blob->base, DRM_MODE_OBJECT_BLOB);
	if (ret) {
		kfree(blob);
D
Daniel Stone 已提交
4163
		mutex_unlock(&dev->mode_config.blob_lock);
4164
		return ERR_PTR(-EINVAL);
4165 4166
	}

4167
	kref_init(&blob->refcount);
D
Dave Airlie 已提交
4168

4169 4170
	list_add_tail(&blob->head_global,
	              &dev->mode_config.property_blob_list);
D
Dave Airlie 已提交
4171

D
Daniel Stone 已提交
4172
	mutex_unlock(&dev->mode_config.blob_lock);
D
Dave Airlie 已提交
4173 4174 4175

	return blob;
}
4176
EXPORT_SYMBOL(drm_property_create_blob);
D
Dave Airlie 已提交
4177

4178 4179 4180 4181 4182
/**
 * drm_property_free_blob - Blob property destructor
 *
 * Internal free function for blob properties; must not be used directly.
 *
4183
 * @kref: Reference
4184 4185
 */
static void drm_property_free_blob(struct kref *kref)
D
Dave Airlie 已提交
4186
{
4187 4188 4189 4190 4191
	struct drm_property_blob *blob =
		container_of(kref, struct drm_property_blob, refcount);

	WARN_ON(!mutex_is_locked(&blob->dev->mode_config.blob_lock));

4192 4193
	list_del(&blob->head_global);
	list_del(&blob->head_file);
4194
	drm_mode_object_put(blob->dev, &blob->base);
D
Daniel Stone 已提交
4195

D
Dave Airlie 已提交
4196 4197 4198
	kfree(blob);
}

4199 4200 4201 4202 4203
/**
 * drm_property_unreference_blob - Unreference a blob property
 *
 * Drop a reference on a blob property. May free the object.
 *
4204
 * @blob: Pointer to blob property
4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230
 */
void drm_property_unreference_blob(struct drm_property_blob *blob)
{
	struct drm_device *dev;

	if (!blob)
		return;

	dev = blob->dev;

	DRM_DEBUG("%p: blob ID: %d (%d)\n", blob, blob->base.id, atomic_read(&blob->refcount.refcount));

	if (kref_put_mutex(&blob->refcount, drm_property_free_blob,
			   &dev->mode_config.blob_lock))
		mutex_unlock(&dev->mode_config.blob_lock);
	else
		might_lock(&dev->mode_config.blob_lock);
}
EXPORT_SYMBOL(drm_property_unreference_blob);

/**
 * drm_property_unreference_blob_locked - Unreference a blob property with blob_lock held
 *
 * Drop a reference on a blob property. May free the object. This must be
 * called with blob_lock held.
 *
4231
 * @blob: Pointer to blob property
4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242
 */
static void drm_property_unreference_blob_locked(struct drm_property_blob *blob)
{
	if (!blob)
		return;

	DRM_DEBUG("%p: blob ID: %d (%d)\n", blob, blob->base.id, atomic_read(&blob->refcount.refcount));

	kref_put(&blob->refcount, drm_property_free_blob);
}

4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262
/**
 * 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;

	mutex_lock(&dev->mode_config.blob_lock);

	list_for_each_entry_safe(blob, bt, &file_priv->blobs, head_file) {
		list_del_init(&blob->head_file);
		drm_property_unreference_blob_locked(blob);
	}

	mutex_unlock(&dev->mode_config.blob_lock);
}

4263 4264 4265 4266 4267
/**
 * drm_property_reference_blob - Take a reference on an existing property
 *
 * Take a new reference on an existing blob property.
 *
4268
 * @blob: Pointer to blob property
4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326
 */
struct drm_property_blob *drm_property_reference_blob(struct drm_property_blob *blob)
{
	DRM_DEBUG("%p: blob ID: %d (%d)\n", blob, blob->base.id, atomic_read(&blob->refcount.refcount));
	kref_get(&blob->refcount);
	return blob;
}
EXPORT_SYMBOL(drm_property_reference_blob);

/*
 * Like drm_property_lookup_blob, but does not return an additional reference.
 * Must be called with blob_lock held.
 */
static struct drm_property_blob *__drm_property_lookup_blob(struct drm_device *dev,
							    uint32_t id)
{
	struct drm_mode_object *obj = NULL;
	struct drm_property_blob *blob;

	WARN_ON(!mutex_is_locked(&dev->mode_config.blob_lock));

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

	return 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)
{
	struct drm_property_blob *blob;

	mutex_lock(&dev->mode_config.blob_lock);
	blob = __drm_property_lookup_blob(dev, id);
	if (blob) {
		if (!kref_get_unless_zero(&blob->refcount))
			blob = NULL;
	}
	mutex_unlock(&dev->mode_config.blob_lock);

	return blob;
}
EXPORT_SYMBOL(drm_property_lookup_blob);

4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373
/**
 * 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);
4374 4375
		if (IS_ERR(new_blob))
			return PTR_ERR(new_blob);
4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391
	}

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

4392
	drm_property_unreference_blob(old_blob);
4393 4394 4395 4396 4397
	*replace = new_blob;

	return 0;

err_created:
4398
	drm_property_unreference_blob(new_blob);
4399 4400 4401
	return ret;
}

4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413
/**
 * 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 已提交
4414
 * Zero on success, negative errno on failure.
4415
 */
D
Dave Airlie 已提交
4416 4417 4418 4419 4420 4421
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ä 已提交
4422
	void __user *blob_ptr;
D
Dave Airlie 已提交
4423

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

4427
	drm_modeset_lock_all(dev);
D
Daniel Stone 已提交
4428
	mutex_lock(&dev->mode_config.blob_lock);
4429
	blob = __drm_property_lookup_blob(dev, out_resp->blob_id);
R
Rob Clark 已提交
4430
	if (!blob) {
4431
		ret = -ENOENT;
D
Dave Airlie 已提交
4432 4433 4434 4435
		goto done;
	}

	if (out_resp->length == blob->length) {
V
Ville Syrjälä 已提交
4436
		blob_ptr = (void __user *)(unsigned long)out_resp->data;
4437
		if (copy_to_user(blob_ptr, blob->data, blob->length)) {
D
Dave Airlie 已提交
4438 4439 4440 4441 4442 4443 4444
			ret = -EFAULT;
			goto done;
		}
	}
	out_resp->length = blob->length;

done:
D
Daniel Stone 已提交
4445
	mutex_unlock(&dev->mode_config.blob_lock);
4446
	drm_modeset_unlock_all(dev);
D
Dave Airlie 已提交
4447 4448 4449
	return ret;
}

4450 4451 4452 4453 4454 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
/**
 * 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;
4491
	list_add_tail(&blob->head_file, &file_priv->blobs);
4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557
	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;

	mutex_lock(&dev->mode_config.blob_lock);
	blob = __drm_property_lookup_blob(dev, out_resp->blob_id);
	if (!blob) {
		ret = -ENOENT;
		goto err;
	}

	/* 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);
	drm_property_unreference_blob_locked(blob);
	mutex_unlock(&dev->mode_config.blob_lock);

	return 0;

err:
	mutex_unlock(&dev->mode_config.blob_lock);
	return ret;
}

4558 4559 4560
/**
 * drm_mode_connector_set_path_property - set tile property on connector
 * @connector: connector to set property on.
4561
 * @path: path to use for property; must not be NULL.
4562 4563 4564 4565 4566 4567 4568
 *
 * 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 已提交
4569
 * Zero on success, negative errno on failure.
4570
 */
D
Dave Airlie 已提交
4571
int drm_mode_connector_set_path_property(struct drm_connector *connector,
4572
					 const char *path)
D
Dave Airlie 已提交
4573 4574
{
	struct drm_device *dev = connector->dev;
4575
	int ret;
D
Dave Airlie 已提交
4576

4577 4578 4579 4580 4581 4582
	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 已提交
4583 4584 4585 4586
	return ret;
}
EXPORT_SYMBOL(drm_mode_connector_set_path_property);

4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601
/**
 * 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];
4602
	int ret;
4603 4604

	if (!connector->has_tile) {
4605 4606 4607 4608 4609 4610
		ret  = drm_property_replace_global_blob(dev,
		                                        &connector->tile_blob_ptr,
		                                        0,
		                                        NULL,
		                                        &connector->base,
		                                        dev->mode_config.tile_property);
4611 4612 4613 4614 4615 4616 4617 4618 4619
		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);

4620 4621 4622 4623 4624 4625
	ret = drm_property_replace_global_blob(dev,
	                                       &connector->tile_blob_ptr,
	                                       strlen(tile) + 1,
	                                       tile,
	                                       &connector->base,
	                                       dev->mode_config.tile_property);
4626 4627 4628 4629
	return ret;
}
EXPORT_SYMBOL(drm_mode_connector_set_tile_property);

4630 4631 4632 4633 4634 4635 4636 4637 4638
/**
 * 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 已提交
4639
 * Zero on success, negative errno on failure.
4640
 */
D
Dave Airlie 已提交
4641
int drm_mode_connector_update_edid_property(struct drm_connector *connector,
4642
					    const struct edid *edid)
D
Dave Airlie 已提交
4643 4644
{
	struct drm_device *dev = connector->dev;
4645
	size_t size = 0;
4646
	int ret;
D
Dave Airlie 已提交
4647

4648 4649 4650 4651
	/* ignore requests to set edid when overridden */
	if (connector->override_edid)
		return 0;

4652
	if (edid)
4653
		size = EDID_LENGTH * (1 + edid->extensions);
D
Dave Airlie 已提交
4654

4655 4656 4657 4658 4659 4660
	ret = drm_property_replace_global_blob(dev,
					       &connector->edid_blob_ptr,
	                                       size,
	                                       edid,
	                                       &connector->base,
	                                       dev->mode_config.edid_property);
D
Dave Airlie 已提交
4661 4662 4663 4664
	return ret;
}
EXPORT_SYMBOL(drm_mode_connector_update_edid_property);

4665 4666 4667 4668 4669 4670 4671 4672
/* 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 已提交
4673
bool drm_property_change_valid_get(struct drm_property *property,
4674
					 uint64_t value, struct drm_mode_object **ref)
4675
{
T
Thierry Reding 已提交
4676 4677
	int i;

4678 4679
	if (property->flags & DRM_MODE_PROP_IMMUTABLE)
		return false;
R
Rob Clark 已提交
4680

4681 4682
	*ref = NULL;

R
Rob Clark 已提交
4683
	if (drm_property_type_is(property, DRM_MODE_PROP_RANGE)) {
4684 4685 4686
		if (value < property->values[0] || value > property->values[1])
			return false;
		return true;
R
Rob Clark 已提交
4687 4688
	} else if (drm_property_type_is(property, DRM_MODE_PROP_SIGNED_RANGE)) {
		int64_t svalue = U642I64(value);
4689

R
Rob Clark 已提交
4690 4691 4692 4693
		if (svalue < U642I64(property->values[0]) ||
				svalue > U642I64(property->values[1]))
			return false;
		return true;
R
Rob Clark 已提交
4694
	} else if (drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
4695
		uint64_t valid_mask = 0;
4696

R
Rob Clark 已提交
4697 4698 4699
		for (i = 0; i < property->num_values; i++)
			valid_mask |= (1ULL << property->values[i]);
		return !(value & ~valid_mask);
R
Rob Clark 已提交
4700
	} else if (drm_property_type_is(property, DRM_MODE_PROP_BLOB)) {
4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712
		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 已提交
4713 4714 4715 4716
	} 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;
4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730

		/* handle refcnt'd objects specially: */
		if (property->values[0] == DRM_MODE_OBJECT_FB) {
			struct drm_framebuffer *fb;
			fb = drm_framebuffer_lookup(property->dev, value);
			if (fb) {
				*ref = &fb->base;
				return true;
			} else {
				return false;
			}
		} else {
			return _object_find(property->dev, value, property->values[0]) != NULL;
		}
4731
	}
T
Thierry Reding 已提交
4732 4733 4734 4735 4736

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

R
Rob Clark 已提交
4739
void drm_property_change_valid_put(struct drm_property *property,
4740 4741 4742 4743 4744 4745 4746 4747
		struct drm_mode_object *ref)
{
	if (!ref)
		return;

	if (drm_property_type_is(property, DRM_MODE_PROP_OBJECT)) {
		if (property->values[0] == DRM_MODE_OBJECT_FB)
			drm_framebuffer_unreference(obj_to_fb(ref));
4748 4749
	} else if (drm_property_type_is(property, DRM_MODE_PROP_BLOB))
		drm_property_unreference_blob(obj_to_blob(ref));
4750 4751
}

4752 4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763
/**
 * 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 已提交
4764
 * Zero on success, negative errno on failure.
4765
 */
D
Dave Airlie 已提交
4766 4767 4768
int drm_mode_connector_property_set_ioctl(struct drm_device *dev,
				       void *data, struct drm_file *file_priv)
{
4769 4770 4771 4772 4773 4774 4775
	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
	};
4776

4777 4778
	/* 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 已提交
4779 4780
}

4781 4782 4783 4784 4785 4786 4787 4788 4789
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) {
4790
		ret = (*connector->funcs->dpms)(connector, (int)value);
4791 4792 4793 4794 4795
	} else if (connector->funcs->set_property)
		ret = connector->funcs->set_property(connector, property, value);

	/* store the property value if successful */
	if (!ret)
4796
		drm_object_property_set_value(&connector->base, property, value);
4797 4798 4799
	return ret;
}

P
Paulo Zanoni 已提交
4800 4801 4802 4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814
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;
}

4815 4816 4817 4818 4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830
/**
 * 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 已提交
4831 4832
{
	int ret = -EINVAL;
4833
	struct drm_mode_object *obj = &plane->base;
R
Rob Clark 已提交
4834 4835 4836 4837 4838 4839 4840 4841

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

4844
/**
D
Daniel Vetter 已提交
4845
 * drm_mode_obj_get_properties_ioctl - get the current value of a object's property
4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856
 * @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 已提交
4857
 * Zero on success, negative errno on failure.
4858
 */
4859 4860 4861 4862 4863 4864 4865 4866 4867 4868
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;

4869
	drm_modeset_lock_all(dev);
4870 4871 4872

	obj = drm_mode_object_find(dev, arg->obj_id, arg->obj_type);
	if (!obj) {
4873
		ret = -ENOENT;
4874 4875 4876 4877 4878 4879 4880
		goto out;
	}
	if (!obj->properties) {
		ret = -EINVAL;
		goto out;
	}

R
Rob Clark 已提交
4881
	ret = get_properties(obj, file_priv->atomic,
4882 4883 4884
			(uint32_t __user *)(unsigned long)(arg->props_ptr),
			(uint64_t __user *)(unsigned long)(arg->prop_values_ptr),
			&arg->count_props);
4885 4886

out:
4887
	drm_modeset_unlock_all(dev);
4888 4889 4890
	return ret;
}

4891 4892 4893 4894 4895 4896 4897 4898 4899 4900 4901 4902 4903 4904
/**
 * 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 已提交
4905
 * Zero on success, negative errno on failure.
4906
 */
4907 4908 4909 4910 4911 4912 4913
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;
4914 4915
	int i, ret = -EINVAL;
	struct drm_mode_object *ref;
4916 4917 4918 4919

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

4920
	drm_modeset_lock_all(dev);
4921 4922

	arg_obj = drm_mode_object_find(dev, arg->obj_id, arg->obj_type);
4923 4924
	if (!arg_obj) {
		ret = -ENOENT;
4925
		goto out;
4926
	}
4927 4928 4929
	if (!arg_obj->properties)
		goto out;

4930
	for (i = 0; i < arg_obj->properties->count; i++)
4931
		if (arg_obj->properties->properties[i]->base.id == arg->prop_id)
4932 4933
			break;

4934
	if (i == arg_obj->properties->count)
4935 4936 4937 4938
		goto out;

	prop_obj = drm_mode_object_find(dev, arg->prop_id,
					DRM_MODE_OBJECT_PROPERTY);
4939 4940
	if (!prop_obj) {
		ret = -ENOENT;
4941
		goto out;
4942
	}
4943 4944
	property = obj_to_property(prop_obj);

4945
	if (!drm_property_change_valid_get(property, arg->value, &ref))
4946 4947 4948 4949 4950 4951 4952
		goto out;

	switch (arg_obj->type) {
	case DRM_MODE_OBJECT_CONNECTOR:
		ret = drm_mode_connector_set_obj_prop(arg_obj, property,
						      arg->value);
		break;
P
Paulo Zanoni 已提交
4953 4954 4955
	case DRM_MODE_OBJECT_CRTC:
		ret = drm_mode_crtc_set_obj_prop(arg_obj, property, arg->value);
		break;
R
Rob Clark 已提交
4956
	case DRM_MODE_OBJECT_PLANE:
4957 4958
		ret = drm_mode_plane_set_obj_prop(obj_to_plane(arg_obj),
						  property, arg->value);
R
Rob Clark 已提交
4959
		break;
4960 4961
	}

4962 4963
	drm_property_change_valid_put(property, ref);

4964
out:
4965
	drm_modeset_unlock_all(dev);
4966 4967 4968
	return ret;
}

4969 4970 4971 4972 4973 4974 4975 4976 4977 4978
/**
 * 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 已提交
4979
 * Zero on success, negative errno on failure.
4980
 */
D
Dave Airlie 已提交
4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991 4992 4993 4994 4995
int drm_mode_connector_attach_encoder(struct drm_connector *connector,
				      struct drm_encoder *encoder)
{
	int i;

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

4996 4997 4998 4999 5000 5001 5002 5003 5004 5005
/**
 * 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 已提交
5006
 * Zero on success, negative errno on failure.
5007
 */
5008
int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
5009
				 int gamma_size)
D
Dave Airlie 已提交
5010 5011 5012
{
	crtc->gamma_size = gamma_size;

5013 5014
	crtc->gamma_store = kcalloc(gamma_size, sizeof(uint16_t) * 3,
				    GFP_KERNEL);
D
Dave Airlie 已提交
5015 5016
	if (!crtc->gamma_store) {
		crtc->gamma_size = 0;
5017
		return -ENOMEM;
D
Dave Airlie 已提交
5018 5019
	}

5020
	return 0;
D
Dave Airlie 已提交
5021 5022 5023
}
EXPORT_SYMBOL(drm_mode_crtc_set_gamma_size);

5024 5025 5026 5027 5028 5029 5030 5031 5032 5033 5034 5035
/**
 * 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 已提交
5036
 * Zero on success, negative errno on failure.
5037
 */
D
Dave Airlie 已提交
5038 5039 5040 5041 5042 5043 5044 5045 5046
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;

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

5050
	drm_modeset_lock_all(dev);
R
Rob Clark 已提交
5051 5052
	crtc = drm_crtc_find(dev, crtc_lut->crtc_id);
	if (!crtc) {
5053
		ret = -ENOENT;
D
Dave Airlie 已提交
5054 5055 5056
		goto out;
	}

5057 5058 5059 5060 5061
	if (crtc->funcs->gamma_set == NULL) {
		ret = -ENOSYS;
		goto out;
	}

D
Dave Airlie 已提交
5062 5063 5064 5065 5066 5067 5068 5069 5070 5071 5072 5073 5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086
	/* 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 已提交
5087
	crtc->funcs->gamma_set(crtc, r_base, g_base, b_base, 0, crtc->gamma_size);
D
Dave Airlie 已提交
5088 5089

out:
5090
	drm_modeset_unlock_all(dev);
D
Dave Airlie 已提交
5091 5092 5093 5094
	return ret;

}

5095 5096 5097 5098 5099 5100 5101 5102 5103 5104 5105 5106 5107
/**
 * 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 已提交
5108
 * Zero on success, negative errno on failure.
5109
 */
D
Dave Airlie 已提交
5110 5111 5112 5113 5114 5115 5116 5117 5118
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;

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

5122
	drm_modeset_lock_all(dev);
R
Rob Clark 已提交
5123 5124
	crtc = drm_crtc_find(dev, crtc_lut->crtc_id);
	if (!crtc) {
5125
		ret = -ENOENT;
D
Dave Airlie 已提交
5126 5127 5128 5129 5130 5131 5132 5133 5134 5135 5136 5137 5138 5139 5140 5141 5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153
		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:
5154
	drm_modeset_unlock_all(dev);
D
Dave Airlie 已提交
5155 5156
	return ret;
}
5157

5158 5159 5160 5161 5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172 5173
/**
 * 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 已提交
5174
 * Zero on success, negative errno on failure.
5175
 */
5176 5177 5178 5179 5180
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;
5181
	struct drm_framebuffer *fb = NULL;
5182 5183 5184 5185 5186 5187 5188 5189
	struct drm_pending_vblank_event *e = NULL;
	unsigned long flags;
	int ret = -EINVAL;

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

5190 5191 5192
	if ((page_flip->flags & DRM_MODE_PAGE_FLIP_ASYNC) && !dev->mode_config.async_page_flip)
		return -EINVAL;

R
Rob Clark 已提交
5193 5194
	crtc = drm_crtc_find(dev, page_flip->crtc_id);
	if (!crtc)
5195
		return -ENOENT;
5196

D
Daniel Vetter 已提交
5197
	drm_modeset_lock_crtc(crtc, crtc->primary);
5198
	if (crtc->primary->fb == NULL) {
5199 5200 5201 5202 5203 5204 5205 5206
		/* The framebuffer is currently unbound, presumably
		 * due to a hotplug event, that userspace has not
		 * yet discovered.
		 */
		ret = -EBUSY;
		goto out;
	}

5207 5208 5209
	if (crtc->funcs->page_flip == NULL)
		goto out;

5210
	fb = drm_framebuffer_lookup(dev, page_flip->fb_id);
5211 5212
	if (!fb) {
		ret = -ENOENT;
5213
		goto out;
5214
	}
5215

5216 5217 5218 5219 5220 5221 5222 5223
	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);
	}
5224
	if (ret)
5225 5226
		goto out;

5227
	if (crtc->primary->fb->pixel_format != fb->pixel_format) {
5228 5229 5230 5231 5232
		DRM_DEBUG_KMS("Page flip is not allowed to change frame buffer format.\n");
		ret = -EINVAL;
		goto out;
	}

5233 5234 5235
	if (page_flip->flags & DRM_MODE_PAGE_FLIP_EVENT) {
		ret = -ENOMEM;
		spin_lock_irqsave(&dev->event_lock, flags);
5236
		if (file_priv->event_space < sizeof(e->event)) {
5237 5238 5239
			spin_unlock_irqrestore(&dev->event_lock, flags);
			goto out;
		}
5240
		file_priv->event_space -= sizeof(e->event);
5241 5242
		spin_unlock_irqrestore(&dev->event_lock, flags);

5243
		e = kzalloc(sizeof(*e), GFP_KERNEL);
5244 5245
		if (e == NULL) {
			spin_lock_irqsave(&dev->event_lock, flags);
5246
			file_priv->event_space += sizeof(e->event);
5247 5248 5249 5250
			spin_unlock_irqrestore(&dev->event_lock, flags);
			goto out;
		}

5251
		e->event.base.type = DRM_EVENT_FLIP_COMPLETE;
5252
		e->event.base.length = sizeof(e->event);
5253 5254 5255 5256 5257 5258 5259
		e->event.user_data = page_flip->user_data;
		e->base.event = &e->event.base;
		e->base.file_priv = file_priv;
		e->base.destroy =
			(void (*) (struct drm_pending_event *)) kfree;
	}

5260
	crtc->primary->old_fb = crtc->primary->fb;
5261
	ret = crtc->funcs->page_flip(crtc, fb, e, page_flip->flags);
5262
	if (ret) {
5263 5264
		if (page_flip->flags & DRM_MODE_PAGE_FLIP_EVENT) {
			spin_lock_irqsave(&dev->event_lock, flags);
5265
			file_priv->event_space += sizeof(e->event);
5266 5267 5268
			spin_unlock_irqrestore(&dev->event_lock, flags);
			kfree(e);
		}
5269
		/* Keep the old fb, don't unref it. */
5270
		crtc->primary->old_fb = NULL;
5271
	} else {
5272
		crtc->primary->fb = fb;
5273 5274
		/* Unref only the old framebuffer. */
		fb = NULL;
5275 5276 5277
	}

out:
5278 5279
	if (fb)
		drm_framebuffer_unreference(fb);
5280 5281 5282
	if (crtc->primary->old_fb)
		drm_framebuffer_unreference(crtc->primary->old_fb);
	crtc->primary->old_fb = NULL;
5283
	drm_modeset_unlock_crtc(crtc);
5284

5285 5286
	return ret;
}
5287

5288 5289 5290 5291 5292 5293 5294 5295
/**
 * 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.
 */
5296 5297 5298
void drm_mode_config_reset(struct drm_device *dev)
{
	struct drm_crtc *crtc;
D
Daniel Vetter 已提交
5299
	struct drm_plane *plane;
5300 5301 5302
	struct drm_encoder *encoder;
	struct drm_connector *connector;

5303
	drm_for_each_plane(plane, dev)
D
Daniel Vetter 已提交
5304 5305 5306
		if (plane->funcs->reset)
			plane->funcs->reset(plane);

5307
	drm_for_each_crtc(crtc, dev)
5308 5309 5310
		if (crtc->funcs->reset)
			crtc->funcs->reset(crtc);

5311
	drm_for_each_encoder(encoder, dev)
5312 5313 5314
		if (encoder->funcs->reset)
			encoder->funcs->reset(encoder);

5315
	mutex_lock(&dev->mode_config.mutex);
D
Dave Airlie 已提交
5316
	drm_for_each_connector(connector, dev)
5317 5318
		if (connector->funcs->reset)
			connector->funcs->reset(connector);
5319
	mutex_unlock(&dev->mode_config.mutex);
5320 5321
}
EXPORT_SYMBOL(drm_mode_config_reset);
5322

5323 5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338 5339
/**
 * 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 已提交
5340
 * Zero on success, negative errno on failure.
5341
 */
5342 5343 5344 5345
int drm_mode_create_dumb_ioctl(struct drm_device *dev,
			       void *data, struct drm_file *file_priv)
{
	struct drm_mode_create_dumb *args = data;
5346
	u32 cpp, stride, size;
5347 5348 5349

	if (!dev->driver->dumb_create)
		return -ENOSYS;
5350 5351 5352 5353
	if (!args->width || !args->height || !args->bpp)
		return -EINVAL;

	/* overflow checks for 32bit size calculations */
5354
	/* NOTE: DIV_ROUND_UP() can overflow */
5355
	cpp = DIV_ROUND_UP(args->bpp, 8);
5356
	if (!cpp || cpp > 0xffffffffU / args->width)
5357 5358 5359 5360 5361 5362 5363 5364 5365 5366
		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;

5367 5368 5369 5370 5371 5372 5373 5374 5375 5376
	/*
	 * 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;

5377 5378 5379
	return dev->driver->dumb_create(file_priv, dev, args);
}

5380 5381 5382 5383 5384 5385 5386 5387 5388 5389 5390 5391
/**
 * 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 已提交
5392
 * Zero on success, negative errno on failure.
5393
 */
5394 5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405
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);
}

5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418
/**
 * 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 已提交
5419
 * Zero on success, negative errno on failure.
5420
 */
5421 5422 5423 5424 5425 5426 5427 5428 5429 5430
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);
}
5431

5432 5433 5434 5435 5436 5437 5438 5439
/**
 * 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.
5440 5441 5442 5443 5444
 */
void drm_fb_get_bpp_depth(uint32_t format, unsigned int *depth,
			  int *bpp)
{
	switch (format) {
5445
	case DRM_FORMAT_C8:
V
Ville Syrjälä 已提交
5446 5447
	case DRM_FORMAT_RGB332:
	case DRM_FORMAT_BGR233:
5448 5449 5450
		*depth = 8;
		*bpp = 8;
		break;
V
Ville Syrjälä 已提交
5451 5452 5453 5454 5455 5456 5457 5458
	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:
5459 5460 5461
		*depth = 15;
		*bpp = 16;
		break;
V
Ville Syrjälä 已提交
5462 5463
	case DRM_FORMAT_RGB565:
	case DRM_FORMAT_BGR565:
5464 5465 5466
		*depth = 16;
		*bpp = 16;
		break;
V
Ville Syrjälä 已提交
5467 5468 5469 5470 5471 5472 5473 5474 5475
	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:
5476 5477 5478
		*depth = 24;
		*bpp = 32;
		break;
V
Ville Syrjälä 已提交
5479 5480 5481 5482 5483 5484 5485 5486
	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:
5487 5488 5489
		*depth = 30;
		*bpp = 32;
		break;
V
Ville Syrjälä 已提交
5490 5491 5492 5493
	case DRM_FORMAT_ARGB8888:
	case DRM_FORMAT_ABGR8888:
	case DRM_FORMAT_RGBA8888:
	case DRM_FORMAT_BGRA8888:
5494 5495 5496 5497
		*depth = 32;
		*bpp = 32;
		break;
	default:
5498 5499
		DRM_DEBUG_KMS("unsupported pixel format %s\n",
			      drm_get_format_name(format));
5500 5501 5502 5503 5504 5505
		*depth = 0;
		*bpp = 0;
		break;
	}
}
EXPORT_SYMBOL(drm_fb_get_bpp_depth);
5506 5507 5508 5509 5510

/**
 * drm_format_num_planes - get the number of planes for format
 * @format: pixel format (DRM_FORMAT_*)
 *
5511
 * Returns:
5512 5513 5514 5515 5516 5517 5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531
 * 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:
5532 5533
	case DRM_FORMAT_NV24:
	case DRM_FORMAT_NV42:
5534 5535 5536 5537 5538 5539
		return 2;
	default:
		return 1;
	}
}
EXPORT_SYMBOL(drm_format_num_planes);
5540 5541 5542 5543 5544 5545

/**
 * drm_format_plane_cpp - determine the bytes per pixel value
 * @format: pixel format (DRM_FORMAT_*)
 * @plane: plane index
 *
5546
 * Returns:
5547 5548 5549 5550 5551 5552 5553 5554 5555 5556 5557 5558 5559 5560 5561 5562 5563 5564 5565 5566
 * 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:
5567 5568
	case DRM_FORMAT_NV24:
	case DRM_FORMAT_NV42:
5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585 5586
		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);
5587 5588 5589 5590 5591

/**
 * drm_format_horz_chroma_subsampling - get the horizontal chroma subsampling factor
 * @format: pixel format (DRM_FORMAT_*)
 *
5592
 * Returns:
5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609 5610 5611 5612 5613 5614 5615 5616 5617 5618 5619 5620 5621 5622 5623 5624 5625 5626
 * 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_*)
 *
5627
 * Returns:
5628 5629 5630 5631 5632 5633 5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644 5645 5646
 * 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);
5647

5648 5649 5650 5651 5652 5653 5654 5655 5656 5657 5658 5659 5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670
/**
 * 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);
5671 5672
		rotation = (rotation & DRM_REFLECT_MASK) |
		           BIT((ffs(rotation & DRM_ROTATE_MASK) + 1) % 4);
5673 5674 5675 5676 5677 5678
	}

	return rotation;
}
EXPORT_SYMBOL(drm_rotation_simplify);

5679 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689 5690 5691 5692 5693
/**
 * 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);
5694
	drm_modeset_lock_init(&dev->mode_config.connection_mutex);
5695 5696
	mutex_init(&dev->mode_config.idr_mutex);
	mutex_init(&dev->mode_config.fb_lock);
D
Daniel Stone 已提交
5697
	mutex_init(&dev->mode_config.blob_lock);
5698 5699 5700 5701 5702 5703 5704 5705
	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 已提交
5706
	idr_init(&dev->mode_config.tile_idr);
5707 5708

	drm_modeset_lock_all(dev);
R
Rob Clark 已提交
5709
	drm_mode_create_standard_properties(dev);
5710 5711 5712 5713 5714 5715 5716
	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;
5717 5718
	dev->mode_config.num_overlay_plane = 0;
	dev->mode_config.num_total_plane = 0;
5719 5720 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 5755 5756 5757 5758 5759 5760
}
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);
	}

	list_for_each_entry_safe(blob, bt, &dev->mode_config.property_blob_list,
5761
				 head_global) {
5762
		drm_property_unreference_blob(blob);
5763 5764 5765 5766 5767 5768 5769 5770 5771 5772 5773 5774
	}

	/*
	 * 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) {
5775
		drm_framebuffer_free(&fb->refcount);
5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786
	}

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

D
Dave Airlie 已提交
5787
	idr_destroy(&dev->mode_config.tile_idr);
5788
	idr_destroy(&dev->mode_config.crtc_idr);
5789
	drm_modeset_lock_fini(&dev->mode_config.connection_mutex);
5790 5791
}
EXPORT_SYMBOL(drm_mode_config_cleanup);
5792 5793 5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809

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 已提交
5810 5811 5812 5813 5814 5815 5816 5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840 5841 5842 5843 5844 5845 5846 5847 5848 5849 5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866 5867 5868

/**
 * 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 已提交
5869
EXPORT_SYMBOL(drm_mode_get_tile_group);
D
Dave Airlie 已提交
5870 5871 5872 5873 5874 5875 5876 5877 5878 5879 5880 5881 5882 5883 5884 5885 5886 5887 5888 5889 5890 5891 5892 5893 5894 5895 5896 5897 5898 5899 5900 5901 5902 5903 5904 5905 5906 5907

/**
 * 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 已提交
5908
EXPORT_SYMBOL(drm_mode_create_tile_group);