1	/*
2	* Copyright (c) 2016 Intel Corporation
3	*
4	* Permission to use, copy, modify, distribute, and sell this software and its
5	* documentation for any purpose is hereby granted without fee, provided that
6	* the above copyright notice appear in all copies and that both that copyright
7	* notice and this permission notice appear in supporting documentation, and
8	* that the name of the copyright holders not be used in advertising or
9	* publicity pertaining to distribution of the software without specific,
10	* written prior permission. The copyright holders make no representations
11	* about the suitability of this software for any purpose. It is provided "as
12	* is" without express or implied warranty.
13	*
14	* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
15	* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
16	* EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
17	* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
18	* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
19	* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
20	* OF THIS SOFTWARE.
21	*/
22
23	#include <drm/drm_auth.h>
24	#include <drm/drm_connector.h>
25	#include <drm/drm_drv.h>
26	#include <drm/drm_edid.h>
27	#include <drm/drm_encoder.h>
28	#include <drm/drm_file.h>
29	#include <drm/drm_managed.h>
30	#include <drm/drm_panel.h>
31	#include <drm/drm_print.h>
32	#include <drm/drm_privacy_screen_consumer.h>
33	#include <drm/drm_sysfs.h>
34	#include <drm/drm_utils.h>
35
36	#include <linux/property.h>
37	#include <linux/uaccess.h>
38
39	#include <video/cmdline.h>
40
41	#include "drm_crtc_internal.h"
42	#include "drm_internal.h"
43
44	/**
45	* DOC: overview
46	*
47	* In DRM connectors are the general abstraction for display sinks, and include
48	* also fixed panels or anything else that can display pixels in some form. As
49	* opposed to all other KMS objects representing hardware (like CRTC, encoder or
50	* plane abstractions) connectors can be hotplugged and unplugged at runtime.
51	* Hence they are reference-counted using drm_connector_get() and
52	* drm_connector_put().
53	*
54	* KMS driver must create, initialize, register and attach at a &struct
55	* drm_connector for each such sink. The instance is created as other KMS
56	* objects and initialized by setting the following fields. The connector is
57	* initialized with a call to drm_connector_init() with a pointer to the
58	* &struct drm_connector_funcs and a connector type, and then exposed to
59	* userspace with a call to drm_connector_register().
60	*
61	* Connectors must be attached to an encoder to be used. For devices that map
62	* connectors to encoders 1:1, the connector should be attached at
63	* initialization time with a call to drm_connector_attach_encoder(). The
64	* driver must also set the &drm_connector.encoder field to point to the
65	* attached encoder.
66	*
67	* For connectors which are not fixed (like built-in panels) the driver needs to
68	* support hotplug notifications. The simplest way to do that is by using the
69	* probe helpers, see drm_kms_helper_poll_init() for connectors which don't have
70	* hardware support for hotplug interrupts. Connectors with hardware hotplug
71	* support can instead use e.g. drm_helper_hpd_irq_event().
72	*/
73
74	/*
75	* Global connector list for drm_connector_find_by_fwnode().
76	* Note drm_connector_[un]register() first take connector->lock and then
77	* take the connector_list_lock.
78	*/
79	static DEFINE_MUTEX(connector_list_lock);
80	static LIST_HEAD(connector_list);
81
82	struct drm_conn_prop_enum_list {
83	int type;
84	const char *name;
85	struct ida ida;
86	};
87
88	/*
89	* Connector and encoder types.
90	*/
91	static struct drm_conn_prop_enum_list drm_connector_enum_list[] = {
92	{ DRM_MODE_CONNECTOR_Unknown, "Unknown" },
93	{ DRM_MODE_CONNECTOR_VGA, "VGA" },
94	{ DRM_MODE_CONNECTOR_DVII, "DVI-I" },
95	{ DRM_MODE_CONNECTOR_DVID, "DVI-D" },
96	{ DRM_MODE_CONNECTOR_DVIA, "DVI-A" },
97	{ DRM_MODE_CONNECTOR_Composite, "Composite" },
98	{ DRM_MODE_CONNECTOR_SVIDEO, "SVIDEO" },
99	{ DRM_MODE_CONNECTOR_LVDS, "LVDS" },
100	{ DRM_MODE_CONNECTOR_Component, "Component" },
101	{ DRM_MODE_CONNECTOR_9PinDIN, "DIN" },
102	{ DRM_MODE_CONNECTOR_DisplayPort, "DP" },
103	{ DRM_MODE_CONNECTOR_HDMIA, "HDMI-A" },
104	{ DRM_MODE_CONNECTOR_HDMIB, "HDMI-B" },
105	{ DRM_MODE_CONNECTOR_TV, "TV" },
106	{ DRM_MODE_CONNECTOR_eDP, "eDP" },
107	{ DRM_MODE_CONNECTOR_VIRTUAL, "Virtual" },
108	{ DRM_MODE_CONNECTOR_DSI, "DSI" },
109	{ DRM_MODE_CONNECTOR_DPI, "DPI" },
110	{ DRM_MODE_CONNECTOR_WRITEBACK, "Writeback" },
111	{ DRM_MODE_CONNECTOR_SPI, "SPI" },
112	{ DRM_MODE_CONNECTOR_USB, "USB" },
113	};
114
115	void drm_connector_ida_init(void)
116	{
117	int i;
118
119	for (i = 0; i < ARRAY_SIZE(drm_connector_enum_list); i++)
120	ida_init(ida: &drm_connector_enum_list[i].ida);
121	}
122
123	void drm_connector_ida_destroy(void)
124	{
125	int i;
126
127	for (i = 0; i < ARRAY_SIZE(drm_connector_enum_list); i++)
128	ida_destroy(ida: &drm_connector_enum_list[i].ida);
129	}
130
131	/**
132	* drm_get_connector_type_name - return a string for connector type
133	* @type: The connector type (DRM_MODE_CONNECTOR_*)
134	*
135	* Returns: the name of the connector type, or NULL if the type is not valid.
136	*/
137	const char *drm_get_connector_type_name(unsigned int type)
138	{
139	if (type < ARRAY_SIZE(drm_connector_enum_list))
140	return drm_connector_enum_list[type].name;
141
142	return NULL;
143	}
144	EXPORT_SYMBOL(drm_get_connector_type_name);
145
146	/**
147	* drm_connector_get_cmdline_mode - reads the user's cmdline mode
148	* @connector: connector to query
149	*
150	* The kernel supports per-connector configuration of its consoles through
151	* use of the video= parameter. This function parses that option and
152	* extracts the user's specified mode (or enable/disable status) for a
153	* particular connector. This is typically only used during the early fbdev
154	* setup.
155	*/
156	static void drm_connector_get_cmdline_mode(struct drm_connector *connector)
157	{
158	struct drm_cmdline_mode *mode = &connector->cmdline_mode;
159	const char *option;
160
161	option = video_get_options(name: connector->name);
162	if (!option)
163	return;
164
165	if (!drm_mode_parse_command_line_for_connector(mode_option: option,
166	connector,
167	mode))
168	return;
169
170	if (mode->force) {
171	DRM_INFO("forcing %s connector %s\n", connector->name,
172	drm_get_connector_force_name(mode->force));
173	connector->force = mode->force;
174	}
175
176	if (mode->panel_orientation != DRM_MODE_PANEL_ORIENTATION_UNKNOWN) {
177	DRM_INFO("cmdline forces connector %s panel_orientation to %d\n",
178	connector->name, mode->panel_orientation);
179	drm_connector_set_panel_orientation(connector,
180	panel_orientation: mode->panel_orientation);
181	}
182
183	DRM_DEBUG_KMS("cmdline mode for connector %s %s %dx%d@%dHz%s%s%s\n",
184	connector->name, mode->name,
185	mode->xres, mode->yres,
186	mode->refresh_specified ? mode->refresh : 60,
187	mode->rb ? " reduced blanking" : "",
188	mode->margins ? " with margins" : "",
189	mode->interlace ? " interlaced" : "");
190	}
191
192	static void drm_connector_free(struct kref *kref)
193	{
194	struct drm_connector *connector =
195	container_of(kref, struct drm_connector, base.refcount);
196	struct drm_device *dev = connector->dev;
197
198	drm_mode_object_unregister(dev, object: &connector->base);
199	connector->funcs->destroy(connector);
200	}
201
202	void drm_connector_free_work_fn(struct work_struct *work)
203	{
204	struct drm_connector *connector, *n;
205	struct drm_device *dev =
206	container_of(work, struct drm_device, mode_config.connector_free_work);
207	struct drm_mode_config *config = &dev->mode_config;
208	unsigned long flags;
209	struct llist_node *freed;
210
211	spin_lock_irqsave(&config->connector_list_lock, flags);
212	freed = llist_del_all(head: &config->connector_free_list);
213	spin_unlock_irqrestore(lock: &config->connector_list_lock, flags);
214
215	llist_for_each_entry_safe(connector, n, freed, free_node) {
216	drm_mode_object_unregister(dev, object: &connector->base);
217	connector->funcs->destroy(connector);
218	}
219	}
220
221	static int __drm_connector_init(struct drm_device *dev,
222	struct drm_connector *connector,
223	const struct drm_connector_funcs *funcs,
224	int connector_type,
225	struct i2c_adapter *ddc)
226	{
227	struct drm_mode_config *config = &dev->mode_config;
228	int ret;
229	struct ida *connector_ida =
230	&drm_connector_enum_list[connector_type].ida;
231
232	WARN_ON(drm_drv_uses_atomic_modeset(dev) &&
233	(!funcs->atomic_destroy_state ||
234	!funcs->atomic_duplicate_state));
235
236	ret = __drm_mode_object_add(dev, obj: &connector->base,
237	DRM_MODE_OBJECT_CONNECTOR,
238	register_obj: false, obj_free_cb: drm_connector_free);
239	if (ret)
240	return ret;
241
242	connector->base.properties = &connector->properties;
243	connector->dev = dev;
244	connector->funcs = funcs;
245
246	/* connector index is used with 32bit bitmasks */
247	ret = ida_alloc_max(ida: &config->connector_ida, max: 31, GFP_KERNEL);
248	if (ret < 0) {
249	DRM_DEBUG_KMS("Failed to allocate %s connector index: %d\n",
250	drm_connector_enum_list[connector_type].name,
251	ret);
252	goto out_put;
253	}
254	connector->index = ret;
255	ret = 0;
256
257	connector->connector_type = connector_type;
258	connector->connector_type_id =
259	ida_alloc_min(ida: connector_ida, min: 1, GFP_KERNEL);
260	if (connector->connector_type_id < 0) {
261	ret = connector->connector_type_id;
262	goto out_put_id;
263	}
264	connector->name =
265	kasprintf(GFP_KERNEL, fmt: "%s-%d",
266	drm_connector_enum_list[connector_type].name,
267	connector->connector_type_id);
268	if (!connector->name) {
269	ret = -ENOMEM;
270	goto out_put_type_id;
271	}
272
273	/* provide ddc symlink in sysfs */
274	connector->ddc = ddc;
275
276	INIT_LIST_HEAD(list: &connector->global_connector_list_entry);
277	INIT_LIST_HEAD(list: &connector->probed_modes);
278	INIT_LIST_HEAD(list: &connector->modes);
279	mutex_init(&connector->mutex);
280	mutex_init(&connector->edid_override_mutex);
281	connector->edid_blob_ptr = NULL;
282	connector->epoch_counter = 0;
283	connector->tile_blob_ptr = NULL;
284	connector->status = connector_status_unknown;
285	connector->display_info.panel_orientation =
286	DRM_MODE_PANEL_ORIENTATION_UNKNOWN;
287
288	drm_connector_get_cmdline_mode(connector);
289
290	/* We should add connectors at the end to avoid upsetting the connector
291	* index too much.
292	*/
293	spin_lock_irq(lock: &config->connector_list_lock);
294	list_add_tail(new: &connector->head, head: &config->connector_list);
295	config->num_connector++;
296	spin_unlock_irq(lock: &config->connector_list_lock);
297
298	if (connector_type != DRM_MODE_CONNECTOR_VIRTUAL &&
299	connector_type != DRM_MODE_CONNECTOR_WRITEBACK)
300	drm_connector_attach_edid_property(connector);
301
302	drm_object_attach_property(obj: &connector->base,
303	property: config->dpms_property, init_val: 0);
304
305	drm_object_attach_property(obj: &connector->base,
306	property: config->link_status_property,
307	init_val: 0);
308
309	drm_object_attach_property(obj: &connector->base,
310	property: config->non_desktop_property,
311	init_val: 0);
312	drm_object_attach_property(obj: &connector->base,
313	property: config->tile_property,
314	init_val: 0);
315
316	if (drm_core_check_feature(dev, feature: DRIVER_ATOMIC)) {
317	drm_object_attach_property(obj: &connector->base, property: config->prop_crtc_id, init_val: 0);
318	}
319
320	connector->debugfs_entry = NULL;
321	out_put_type_id:
322	if (ret)
323	ida_free(connector_ida, id: connector->connector_type_id);
324	out_put_id:
325	if (ret)
326	ida_free(&config->connector_ida, id: connector->index);
327	out_put:
328	if (ret)
329	drm_mode_object_unregister(dev, object: &connector->base);
330
331	return ret;
332	}
333
334	/**
335	* drm_connector_init - Init a preallocated connector
336	* @dev: DRM device
337	* @connector: the connector to init
338	* @funcs: callbacks for this connector
339	* @connector_type: user visible type of the connector
340	*
341	* Initialises a preallocated connector. Connectors should be
342	* subclassed as part of driver connector objects.
343	*
344	* At driver unload time the driver's &drm_connector_funcs.destroy hook
345	* should call drm_connector_cleanup() and free the connector structure.
346	* The connector structure should not be allocated with devm_kzalloc().
347	*
348	* Note: consider using drmm_connector_init() instead of
349	* drm_connector_init() to let the DRM managed resource infrastructure
350	* take care of cleanup and deallocation.
351	*
352	* Returns:
353	* Zero on success, error code on failure.
354	*/
355	int drm_connector_init(struct drm_device *dev,
356	struct drm_connector *connector,
357	const struct drm_connector_funcs *funcs,
358	int connector_type)
359	{
360	if (drm_WARN_ON(dev, !(funcs && funcs->destroy)))
361	return -EINVAL;
362
363	return __drm_connector_init(dev, connector, funcs, connector_type, NULL);
364	}
365	EXPORT_SYMBOL(drm_connector_init);
366
367	/**
368	* drm_connector_init_with_ddc - Init a preallocated connector
369	* @dev: DRM device
370	* @connector: the connector to init
371	* @funcs: callbacks for this connector
372	* @connector_type: user visible type of the connector
373	* @ddc: pointer to the associated ddc adapter
374	*
375	* Initialises a preallocated connector. Connectors should be
376	* subclassed as part of driver connector objects.
377	*
378	* At driver unload time the driver's &drm_connector_funcs.destroy hook
379	* should call drm_connector_cleanup() and free the connector structure.
380	* The connector structure should not be allocated with devm_kzalloc().
381	*
382	* Ensures that the ddc field of the connector is correctly set.
383	*
384	* Note: consider using drmm_connector_init() instead of
385	* drm_connector_init_with_ddc() to let the DRM managed resource
386	* infrastructure take care of cleanup and deallocation.
387	*
388	* Returns:
389	* Zero on success, error code on failure.
390	*/
391	int drm_connector_init_with_ddc(struct drm_device *dev,
392	struct drm_connector *connector,
393	const struct drm_connector_funcs *funcs,
394	int connector_type,
395	struct i2c_adapter *ddc)
396	{
397	if (drm_WARN_ON(dev, !(funcs && funcs->destroy)))
398	return -EINVAL;
399
400	return __drm_connector_init(dev, connector, funcs, connector_type, ddc);
401	}
402	EXPORT_SYMBOL(drm_connector_init_with_ddc);
403
404	static void drm_connector_cleanup_action(struct drm_device *dev,
405	void *ptr)
406	{
407	struct drm_connector *connector = ptr;
408
409	drm_connector_cleanup(connector);
410	}
411
412	/**
413	* drmm_connector_init - Init a preallocated connector
414	* @dev: DRM device
415	* @connector: the connector to init
416	* @funcs: callbacks for this connector
417	* @connector_type: user visible type of the connector
418	* @ddc: optional pointer to the associated ddc adapter
419	*
420	* Initialises a preallocated connector. Connectors should be
421	* subclassed as part of driver connector objects.
422	*
423	* Cleanup is automatically handled with a call to
424	* drm_connector_cleanup() in a DRM-managed action.
425	*
426	* The connector structure should be allocated with drmm_kzalloc().
427	*
428	* Returns:
429	* Zero on success, error code on failure.
430	*/
431	int drmm_connector_init(struct drm_device *dev,
432	struct drm_connector *connector,
433	const struct drm_connector_funcs *funcs,
434	int connector_type,
435	struct i2c_adapter *ddc)
436	{
437	int ret;
438
439	if (drm_WARN_ON(dev, funcs && funcs->destroy))
440	return -EINVAL;
441
442	ret = __drm_connector_init(dev, connector, funcs, connector_type, ddc);
443	if (ret)
444	return ret;
445
446	ret = drmm_add_action_or_reset(dev, drm_connector_cleanup_action,
447	connector);
448	if (ret)
449	return ret;
450
451	return 0;
452	}
453	EXPORT_SYMBOL(drmm_connector_init);
454
455	/**
456	* drm_connector_attach_edid_property - attach edid property.
457	* @connector: the connector
458	*
459	* Some connector types like DRM_MODE_CONNECTOR_VIRTUAL do not get a
460	* edid property attached by default. This function can be used to
461	* explicitly enable the edid property in these cases.
462	*/
463	void drm_connector_attach_edid_property(struct drm_connector *connector)
464	{
465	struct drm_mode_config *config = &connector->dev->mode_config;
466
467	drm_object_attach_property(obj: &connector->base,
468	property: config->edid_property,
469	init_val: 0);
470	}
471	EXPORT_SYMBOL(drm_connector_attach_edid_property);
472
473	/**
474	* drm_connector_attach_encoder - attach a connector to an encoder
475	* @connector: connector to attach
476	* @encoder: encoder to attach @connector to
477	*
478	* This function links up a connector to an encoder. Note that the routing
479	* restrictions between encoders and crtcs are exposed to userspace through the
480	* possible_clones and possible_crtcs bitmasks.
481	*
482	* Returns:
483	* Zero on success, negative errno on failure.
484	*/
485	int drm_connector_attach_encoder(struct drm_connector *connector,
486	struct drm_encoder *encoder)
487	{
488	/*
489	* In the past, drivers have attempted to model the static association
490	* of connector to encoder in simple connector/encoder devices using a
491	* direct assignment of connector->encoder = encoder. This connection
492	* is a logical one and the responsibility of the core, so drivers are
493	* expected not to mess with this.
494	*
495	* Note that the error return should've been enough here, but a large
496	* majority of drivers ignores the return value, so add in a big WARN
497	* to get people's attention.
498	*/
499	if (WARN_ON(connector->encoder))
500	return -EINVAL;
501
502	connector->possible_encoders |= drm_encoder_mask(encoder);
503
504	return 0;
505	}
506	EXPORT_SYMBOL(drm_connector_attach_encoder);
507
508	/**
509	* drm_connector_has_possible_encoder - check if the connector and encoder are
510	* associated with each other
511	* @connector: the connector
512	* @encoder: the encoder
513	*
514	* Returns:
515	* True if @encoder is one of the possible encoders for @connector.
516	*/
517	bool drm_connector_has_possible_encoder(struct drm_connector *connector,
518	struct drm_encoder *encoder)
519	{
520	return connector->possible_encoders & drm_encoder_mask(encoder);
521	}
522	EXPORT_SYMBOL(drm_connector_has_possible_encoder);
523
524	static void drm_mode_remove(struct drm_connector *connector,
525	struct drm_display_mode *mode)
526	{
527	list_del(entry: &mode->head);
528	drm_mode_destroy(dev: connector->dev, mode);
529	}
530
531	/**
532	* drm_connector_cleanup - cleans up an initialised connector
533	* @connector: connector to cleanup
534	*
535	* Cleans up the connector but doesn't free the object.
536	*/
537	void drm_connector_cleanup(struct drm_connector *connector)
538	{
539	struct drm_device *dev = connector->dev;
540	struct drm_display_mode *mode, *t;
541
542	/* The connector should have been removed from userspace long before
543	* it is finally destroyed.
544	*/
545	if (WARN_ON(connector->registration_state ==
546	DRM_CONNECTOR_REGISTERED))
547	drm_connector_unregister(connector);
548
549	if (connector->privacy_screen) {
550	drm_privacy_screen_put(priv: connector->privacy_screen);
551	connector->privacy_screen = NULL;
552	}
553
554	if (connector->tile_group) {
555	drm_mode_put_tile_group(dev, tg: connector->tile_group);
556	connector->tile_group = NULL;
557	}
558
559	list_for_each_entry_safe(mode, t, &connector->probed_modes, head)
560	drm_mode_remove(connector, mode);
561
562	list_for_each_entry_safe(mode, t, &connector->modes, head)
563	drm_mode_remove(connector, mode);
564
565	ida_free(&drm_connector_enum_list[connector->connector_type].ida,
566	id: connector->connector_type_id);
567
568	ida_free(&dev->mode_config.connector_ida, id: connector->index);
569
570	kfree(objp: connector->display_info.bus_formats);
571	kfree(objp: connector->display_info.vics);
572	drm_mode_object_unregister(dev, object: &connector->base);
573	kfree(objp: connector->name);
574	connector->name = NULL;
575	fwnode_handle_put(fwnode: connector->fwnode);
576	connector->fwnode = NULL;
577	spin_lock_irq(lock: &dev->mode_config.connector_list_lock);
578	list_del(entry: &connector->head);
579	dev->mode_config.num_connector--;
580	spin_unlock_irq(lock: &dev->mode_config.connector_list_lock);
581
582	WARN_ON(connector->state && !connector->funcs->atomic_destroy_state);
583	if (connector->state && connector->funcs->atomic_destroy_state)
584	connector->funcs->atomic_destroy_state(connector,
585	connector->state);
586
587	mutex_destroy(lock: &connector->mutex);
588
589	memset(connector, 0, sizeof(*connector));
590
591	if (dev->registered)
592	drm_sysfs_hotplug_event(dev);
593	}
594	EXPORT_SYMBOL(drm_connector_cleanup);
595
596	/**
597	* drm_connector_register - register a connector
598	* @connector: the connector to register
599	*
600	* Register userspace interfaces for a connector. Only call this for connectors
601	* which can be hotplugged after drm_dev_register() has been called already,
602	* e.g. DP MST connectors. All other connectors will be registered automatically
603	* when calling drm_dev_register().
604	*
605	* When the connector is no longer available, callers must call
606	* drm_connector_unregister().
607	*
608	* Returns:
609	* Zero on success, error code on failure.
610	*/
611	int drm_connector_register(struct drm_connector *connector)
612	{
613	int ret = 0;
614
615	if (!connector->dev->registered)
616	return 0;
617
618	mutex_lock(&connector->mutex);
619	if (connector->registration_state != DRM_CONNECTOR_INITIALIZING)
620	goto unlock;
621
622	ret = drm_sysfs_connector_add(connector);
623	if (ret)
624	goto unlock;
625
626	drm_debugfs_connector_add(connector);
627
628	if (connector->funcs->late_register) {
629	ret = connector->funcs->late_register(connector);
630	if (ret)
631	goto err_debugfs;
632	}
633
634	ret = drm_sysfs_connector_add_late(connector);
635	if (ret)
636	goto err_late_register;
637
638	drm_mode_object_register(dev: connector->dev, obj: &connector->base);
639
640	connector->registration_state = DRM_CONNECTOR_REGISTERED;
641
642	/* Let userspace know we have a new connector */
643	drm_sysfs_connector_hotplug_event(connector);
644
645	if (connector->privacy_screen)
646	drm_privacy_screen_register_notifier(priv: connector->privacy_screen,
647	nb: &connector->privacy_screen_notifier);
648
649	mutex_lock(&connector_list_lock);
650	list_add_tail(new: &connector->global_connector_list_entry, head: &connector_list);
651	mutex_unlock(lock: &connector_list_lock);
652	goto unlock;
653
654	err_late_register:
655	if (connector->funcs->early_unregister)
656	connector->funcs->early_unregister(connector);
657	err_debugfs:
658	drm_debugfs_connector_remove(connector);
659	drm_sysfs_connector_remove(connector);
660	unlock:
661	mutex_unlock(lock: &connector->mutex);
662	return ret;
663	}
664	EXPORT_SYMBOL(drm_connector_register);
665
666	/**
667	* drm_connector_unregister - unregister a connector
668	* @connector: the connector to unregister
669	*
670	* Unregister userspace interfaces for a connector. Only call this for
671	* connectors which have been registered explicitly by calling
672	* drm_connector_register().
673	*/
674	void drm_connector_unregister(struct drm_connector *connector)
675	{
676	mutex_lock(&connector->mutex);
677	if (connector->registration_state != DRM_CONNECTOR_REGISTERED) {
678	mutex_unlock(lock: &connector->mutex);
679	return;
680	}
681
682	mutex_lock(&connector_list_lock);
683	list_del_init(entry: &connector->global_connector_list_entry);
684	mutex_unlock(lock: &connector_list_lock);
685
686	if (connector->privacy_screen)
687	drm_privacy_screen_unregister_notifier(
688	priv: connector->privacy_screen,
689	nb: &connector->privacy_screen_notifier);
690
691	drm_sysfs_connector_remove_early(connector);
692
693	if (connector->funcs->early_unregister)
694	connector->funcs->early_unregister(connector);
695
696	drm_debugfs_connector_remove(connector);
697	drm_sysfs_connector_remove(connector);
698
699	connector->registration_state = DRM_CONNECTOR_UNREGISTERED;
700	mutex_unlock(lock: &connector->mutex);
701	}
702	EXPORT_SYMBOL(drm_connector_unregister);
703
704	void drm_connector_unregister_all(struct drm_device *dev)
705	{
706	struct drm_connector *connector;
707	struct drm_connector_list_iter conn_iter;
708
709	drm_connector_list_iter_begin(dev, iter: &conn_iter);
710	drm_for_each_connector_iter(connector, &conn_iter)
711	drm_connector_unregister(connector);
712	drm_connector_list_iter_end(iter: &conn_iter);
713	}
714
715	int drm_connector_register_all(struct drm_device *dev)
716	{
717	struct drm_connector *connector;
718	struct drm_connector_list_iter conn_iter;
719	int ret = 0;
720
721	drm_connector_list_iter_begin(dev, iter: &conn_iter);
722	drm_for_each_connector_iter(connector, &conn_iter) {
723	ret = drm_connector_register(connector);
724	if (ret)
725	break;
726	}
727	drm_connector_list_iter_end(iter: &conn_iter);
728
729	if (ret)
730	drm_connector_unregister_all(dev);
731	return ret;
732	}
733
734	/**
735	* drm_get_connector_status_name - return a string for connector status
736	* @status: connector status to compute name of
737	*
738	* In contrast to the other drm_get_*_name functions this one here returns a
739	* const pointer and hence is threadsafe.
740	*
741	* Returns: connector status string
742	*/
743	const char *drm_get_connector_status_name(enum drm_connector_status status)
744	{
745	if (status == connector_status_connected)
746	return "connected";
747	else if (status == connector_status_disconnected)
748	return "disconnected";
749	else
750	return "unknown";
751	}
752	EXPORT_SYMBOL(drm_get_connector_status_name);
753
754	/**
755	* drm_get_connector_force_name - return a string for connector force
756	* @force: connector force to get name of
757	*
758	* Returns: const pointer to name.
759	*/
760	const char *drm_get_connector_force_name(enum drm_connector_force force)
761	{
762	switch (force) {
763	case DRM_FORCE_UNSPECIFIED:
764	return "unspecified";
765	case DRM_FORCE_OFF:
766	return "off";
767	case DRM_FORCE_ON:
768	return "on";
769	case DRM_FORCE_ON_DIGITAL:
770	return "digital";
771	default:
772	return "unknown";
773	}
774	}
775
776	#ifdef CONFIG_LOCKDEP
777	static struct lockdep_map connector_list_iter_dep_map = {
778	.name = "drm_connector_list_iter"
779	};
780	#endif
781
782	/**
783	* drm_connector_list_iter_begin - initialize a connector_list iterator
784	* @dev: DRM device
785	* @iter: connector_list iterator
786	*
787	* Sets @iter up to walk the &drm_mode_config.connector_list of @dev. @iter
788	* must always be cleaned up again by calling drm_connector_list_iter_end().
789	* Iteration itself happens using drm_connector_list_iter_next() or
790	* drm_for_each_connector_iter().
791	*/
792	void drm_connector_list_iter_begin(struct drm_device *dev,
793	struct drm_connector_list_iter *iter)
794	{
795	iter->dev = dev;
796	iter->conn = NULL;
797	lock_acquire_shared_recursive(&connector_list_iter_dep_map, 0, 1, NULL, _RET_IP_);
798	}
799	EXPORT_SYMBOL(drm_connector_list_iter_begin);
800
801	/*
802	* Extra-safe connector put function that works in any context. Should only be
803	* used from the connector_iter functions, where we never really expect to
804	* actually release the connector when dropping our final reference.
805	*/
806	static void
807	__drm_connector_put_safe(struct drm_connector *conn)
808	{
809	struct drm_mode_config *config = &conn->dev->mode_config;
810
811	lockdep_assert_held(&config->connector_list_lock);
812
813	if (!refcount_dec_and_test(r: &conn->base.refcount.refcount))
814	return;
815
816	llist_add(new: &conn->free_node, head: &config->connector_free_list);
817	schedule_work(work: &config->connector_free_work);
818	}
819
820	/**
821	* drm_connector_list_iter_next - return next connector
822	* @iter: connector_list iterator
823	*
824	* Returns: the next connector for @iter, or NULL when the list walk has
825	* completed.
826	*/
827	struct drm_connector *
828	drm_connector_list_iter_next(struct drm_connector_list_iter *iter)
829	{
830	struct drm_connector *old_conn = iter->conn;
831	struct drm_mode_config *config = &iter->dev->mode_config;
832	struct list_head *lhead;
833	unsigned long flags;
834
835	spin_lock_irqsave(&config->connector_list_lock, flags);
836	lhead = old_conn ? &old_conn->head : &config->connector_list;
837
838	do {
839	if (lhead->next == &config->connector_list) {
840	iter->conn = NULL;
841	break;
842	}
843
844	lhead = lhead->next;
845	iter->conn = list_entry(lhead, struct drm_connector, head);
846
847	/* loop until it's not a zombie connector */
848	} while (!kref_get_unless_zero(kref: &iter->conn->base.refcount));
849
850	if (old_conn)
851	__drm_connector_put_safe(conn: old_conn);
852	spin_unlock_irqrestore(lock: &config->connector_list_lock, flags);
853
854	return iter->conn;
855	}
856	EXPORT_SYMBOL(drm_connector_list_iter_next);
857
858	/**
859	* drm_connector_list_iter_end - tear down a connector_list iterator
860	* @iter: connector_list iterator
861	*
862	* Tears down @iter and releases any resources (like &drm_connector references)
863	* acquired while walking the list. This must always be called, both when the
864	* iteration completes fully or when it was aborted without walking the entire
865	* list.
866	*/
867	void drm_connector_list_iter_end(struct drm_connector_list_iter *iter)
868	{
869	struct drm_mode_config *config = &iter->dev->mode_config;
870	unsigned long flags;
871
872	iter->dev = NULL;
873	if (iter->conn) {
874	spin_lock_irqsave(&config->connector_list_lock, flags);
875	__drm_connector_put_safe(conn: iter->conn);
876	spin_unlock_irqrestore(lock: &config->connector_list_lock, flags);
877	}
878	lock_release(lock: &connector_list_iter_dep_map, _RET_IP_);
879	}
880	EXPORT_SYMBOL(drm_connector_list_iter_end);
881
882	static const struct drm_prop_enum_list drm_subpixel_enum_list[] = {
883	{ SubPixelUnknown, "Unknown" },
884	{ SubPixelHorizontalRGB, "Horizontal RGB" },
885	{ SubPixelHorizontalBGR, "Horizontal BGR" },
886	{ SubPixelVerticalRGB, "Vertical RGB" },
887	{ SubPixelVerticalBGR, "Vertical BGR" },
888	{ SubPixelNone, "None" },
889	};
890
891	/**
892	* drm_get_subpixel_order_name - return a string for a given subpixel enum
893	* @order: enum of subpixel_order
894	*
895	* Note you could abuse this and return something out of bounds, but that
896	* would be a caller error. No unscrubbed user data should make it here.
897	*
898	* Returns: string describing an enumerated subpixel property
899	*/
900	const char *drm_get_subpixel_order_name(enum subpixel_order order)
901	{
902	return drm_subpixel_enum_list[order].name;
903	}
904	EXPORT_SYMBOL(drm_get_subpixel_order_name);
905
906	static const struct drm_prop_enum_list drm_dpms_enum_list[] = {
907	{ DRM_MODE_DPMS_ON, .name: "On" },
908	{ DRM_MODE_DPMS_STANDBY, "Standby" },
909	{ DRM_MODE_DPMS_SUSPEND, "Suspend" },
910	{ DRM_MODE_DPMS_OFF, "Off" }
911	};
912	DRM_ENUM_NAME_FN(drm_get_dpms_name, drm_dpms_enum_list)
913
914	static const struct drm_prop_enum_list drm_link_status_enum_list[] = {
915	{ DRM_MODE_LINK_STATUS_GOOD, "Good" },
916	{ DRM_MODE_LINK_STATUS_BAD, "Bad" },
917	};
918
919	/**
920	* drm_display_info_set_bus_formats - set the supported bus formats
921	* @info: display info to store bus formats in
922	* @formats: array containing the supported bus formats
923	* @num_formats: the number of entries in the fmts array
924	*
925	* Store the supported bus formats in display info structure.
926	* See MEDIA_BUS_FMT_* definitions in include/uapi/linux/media-bus-format.h for
927	* a full list of available formats.
928	*
929	* Returns:
930	* 0 on success or a negative error code on failure.
931	*/
932	int drm_display_info_set_bus_formats(struct drm_display_info *info,
933	const u32 *formats,
934	unsigned int num_formats)
935	{
936	u32 *fmts = NULL;
937
938	if (!formats && num_formats)
939	return -EINVAL;
940
941	if (formats && num_formats) {
942	fmts = kmemdup(p: formats, size: sizeof(*formats) * num_formats,
943	GFP_KERNEL);
944	if (!fmts)
945	return -ENOMEM;
946	}
947
948	kfree(objp: info->bus_formats);
949	info->bus_formats = fmts;
950	info->num_bus_formats = num_formats;
951
952	return 0;
953	}
954	EXPORT_SYMBOL(drm_display_info_set_bus_formats);
955
956	/* Optional connector properties. */
957	static const struct drm_prop_enum_list drm_scaling_mode_enum_list[] = {
958	{ DRM_MODE_SCALE_NONE, .name: "None" },
959	{ DRM_MODE_SCALE_FULLSCREEN, "Full" },
960	{ DRM_MODE_SCALE_CENTER, "Center" },
961	{ DRM_MODE_SCALE_ASPECT, "Full aspect" },
962	};
963
964	static const struct drm_prop_enum_list drm_aspect_ratio_enum_list[] = {
965	{ DRM_MODE_PICTURE_ASPECT_NONE, "Automatic" },
966	{ DRM_MODE_PICTURE_ASPECT_4_3, "4:3" },
967	{ DRM_MODE_PICTURE_ASPECT_16_9, "16:9" },
968	};
969
970	static const struct drm_prop_enum_list drm_content_type_enum_list[] = {
971	{ DRM_MODE_CONTENT_TYPE_NO_DATA, "No Data" },
972	{ DRM_MODE_CONTENT_TYPE_GRAPHICS, "Graphics" },
973	{ DRM_MODE_CONTENT_TYPE_PHOTO, "Photo" },
974	{ DRM_MODE_CONTENT_TYPE_CINEMA, "Cinema" },
975	{ DRM_MODE_CONTENT_TYPE_GAME, "Game" },
976	};
977
978	static const struct drm_prop_enum_list drm_panel_orientation_enum_list[] = {
979	{ DRM_MODE_PANEL_ORIENTATION_NORMAL, "Normal" },
980	{ DRM_MODE_PANEL_ORIENTATION_BOTTOM_UP, "Upside Down" },
981	{ DRM_MODE_PANEL_ORIENTATION_LEFT_UP, "Left Side Up" },
982	{ DRM_MODE_PANEL_ORIENTATION_RIGHT_UP, "Right Side Up" },
983	};
984
985	static const struct drm_prop_enum_list drm_dvi_i_select_enum_list[] = {
986	{ DRM_MODE_SUBCONNECTOR_Automatic, "Automatic" }, /* DVI-I and TV-out */
987	{ DRM_MODE_SUBCONNECTOR_DVID, "DVI-D" }, /* DVI-I */
988	{ DRM_MODE_SUBCONNECTOR_DVIA, "DVI-A" }, /* DVI-I */
989	};
990	DRM_ENUM_NAME_FN(drm_get_dvi_i_select_name, drm_dvi_i_select_enum_list)
991
992	static const struct drm_prop_enum_list drm_dvi_i_subconnector_enum_list[] = {
993	{ DRM_MODE_SUBCONNECTOR_Unknown, "Unknown" }, /* DVI-I, TV-out and DP */
994	{ DRM_MODE_SUBCONNECTOR_DVID, "DVI-D" }, /* DVI-I */
995	{ DRM_MODE_SUBCONNECTOR_DVIA, "DVI-A" }, /* DVI-I */
996	};
997	DRM_ENUM_NAME_FN(drm_get_dvi_i_subconnector_name,
998	drm_dvi_i_subconnector_enum_list)
999
1000	static const struct drm_prop_enum_list drm_tv_mode_enum_list[] = {
1001	{ DRM_MODE_TV_MODE_NTSC, "NTSC" },
1002	{ DRM_MODE_TV_MODE_NTSC_443, "NTSC-443" },
1003	{ DRM_MODE_TV_MODE_NTSC_J, "NTSC-J" },
1004	{ DRM_MODE_TV_MODE_PAL, "PAL" },
1005	{ DRM_MODE_TV_MODE_PAL_M, "PAL-M" },
1006	{ DRM_MODE_TV_MODE_PAL_N, "PAL-N" },
1007	{ DRM_MODE_TV_MODE_SECAM, "SECAM" },
1008	};
1009	DRM_ENUM_NAME_FN(drm_get_tv_mode_name, drm_tv_mode_enum_list)
1010
1011	/**
1012	* drm_get_tv_mode_from_name - Translates a TV mode name into its enum value
1013	* @name: TV Mode name we want to convert
1014	* @len: Length of @name
1015	*
1016	* Translates @name into an enum drm_connector_tv_mode.
1017	*
1018	* Returns: the enum value on success, a negative errno otherwise.
1019	*/
1020	int drm_get_tv_mode_from_name(const char *name, size_t len)
1021	{
1022	unsigned int i;
1023
1024	for (i = 0; i < ARRAY_SIZE(drm_tv_mode_enum_list); i++) {
1025	const struct drm_prop_enum_list *item = &drm_tv_mode_enum_list[i];
1026
1027	if (strlen(item->name) == len && !strncmp(item->name, name, len))
1028	return item->type;
1029	}
1030
1031	return -EINVAL;
1032	}
1033	EXPORT_SYMBOL(drm_get_tv_mode_from_name);
1034
1035	static const struct drm_prop_enum_list drm_tv_select_enum_list[] = {
1036	{ .type: DRM_MODE_SUBCONNECTOR_Automatic, .name: "Automatic" }, /* DVI-I and TV-out */
1037	{ DRM_MODE_SUBCONNECTOR_Composite, "Composite" }, /* TV-out */
1038	{ DRM_MODE_SUBCONNECTOR_SVIDEO, "SVIDEO" }, /* TV-out */
1039	{ DRM_MODE_SUBCONNECTOR_Component, "Component" }, /* TV-out */
1040	{ DRM_MODE_SUBCONNECTOR_SCART, "SCART" }, /* TV-out */
1041	};
1042	DRM_ENUM_NAME_FN(drm_get_tv_select_name, drm_tv_select_enum_list)
1043
1044	static const struct drm_prop_enum_list drm_tv_subconnector_enum_list[] = {
1045	{ DRM_MODE_SUBCONNECTOR_Unknown, "Unknown" }, /* DVI-I, TV-out and DP */
1046	{ DRM_MODE_SUBCONNECTOR_Composite, "Composite" }, /* TV-out */
1047	{ DRM_MODE_SUBCONNECTOR_SVIDEO, "SVIDEO" }, /* TV-out */
1048	{ DRM_MODE_SUBCONNECTOR_Component, "Component" }, /* TV-out */
1049	{ DRM_MODE_SUBCONNECTOR_SCART, "SCART" }, /* TV-out */
1050	};
1051	DRM_ENUM_NAME_FN(drm_get_tv_subconnector_name,
1052	drm_tv_subconnector_enum_list)
1053
1054	static const struct drm_prop_enum_list drm_dp_subconnector_enum_list[] = {
1055	{ DRM_MODE_SUBCONNECTOR_Unknown, "Unknown" }, /* DVI-I, TV-out and DP */
1056	{ DRM_MODE_SUBCONNECTOR_VGA, "VGA" }, /* DP */
1057	{ DRM_MODE_SUBCONNECTOR_DVID, "DVI-D" }, /* DP */
1058	{ DRM_MODE_SUBCONNECTOR_HDMIA, "HDMI" }, /* DP */
1059	{ DRM_MODE_SUBCONNECTOR_DisplayPort, "DP" }, /* DP */
1060	{ DRM_MODE_SUBCONNECTOR_Wireless, "Wireless" }, /* DP */
1061	{ DRM_MODE_SUBCONNECTOR_Native, "Native" }, /* DP */
1062	};
1063
1064	DRM_ENUM_NAME_FN(drm_get_dp_subconnector_name,
1065	drm_dp_subconnector_enum_list)
1066
1067
1068	static const char * const colorspace_names[] = {
1069	/* For Default case, driver will set the colorspace */
1070	[DRM_MODE_COLORIMETRY_DEFAULT] = "Default",
1071	/* Standard Definition Colorimetry based on CEA 861 */
1072	[DRM_MODE_COLORIMETRY_SMPTE_170M_YCC] = "SMPTE_170M_YCC",
1073	[DRM_MODE_COLORIMETRY_BT709_YCC] = "BT709_YCC",
1074	/* Standard Definition Colorimetry based on IEC 61966-2-4 */
1075	[DRM_MODE_COLORIMETRY_XVYCC_601] = "XVYCC_601",
1076	/* High Definition Colorimetry based on IEC 61966-2-4 */
1077	[DRM_MODE_COLORIMETRY_XVYCC_709] = "XVYCC_709",
1078	/* Colorimetry based on IEC 61966-2-1/Amendment 1 */
1079	[DRM_MODE_COLORIMETRY_SYCC_601] = "SYCC_601",
1080	/* Colorimetry based on IEC 61966-2-5 [33] */
1081	[DRM_MODE_COLORIMETRY_OPYCC_601] = "opYCC_601",
1082	/* Colorimetry based on IEC 61966-2-5 */
1083	[DRM_MODE_COLORIMETRY_OPRGB] = "opRGB",
1084	/* Colorimetry based on ITU-R BT.2020 */
1085	[DRM_MODE_COLORIMETRY_BT2020_CYCC] = "BT2020_CYCC",
1086	/* Colorimetry based on ITU-R BT.2020 */
1087	[DRM_MODE_COLORIMETRY_BT2020_RGB] = "BT2020_RGB",
1088	/* Colorimetry based on ITU-R BT.2020 */
1089	[DRM_MODE_COLORIMETRY_BT2020_YCC] = "BT2020_YCC",
1090	/* Added as part of Additional Colorimetry Extension in 861.G */
1091	[DRM_MODE_COLORIMETRY_DCI_P3_RGB_D65] = "DCI-P3_RGB_D65",
1092	[DRM_MODE_COLORIMETRY_DCI_P3_RGB_THEATER] = "DCI-P3_RGB_Theater",
1093	[DRM_MODE_COLORIMETRY_RGB_WIDE_FIXED] = "RGB_WIDE_FIXED",
1094	/* Colorimetry based on scRGB (IEC 61966-2-2) */
1095	[DRM_MODE_COLORIMETRY_RGB_WIDE_FLOAT] = "RGB_WIDE_FLOAT",
1096	[DRM_MODE_COLORIMETRY_BT601_YCC] = "BT601_YCC",
1097	};
1098
1099	/**
1100	* drm_get_colorspace_name - return a string for color encoding
1101	* @colorspace: color space to compute name of
1102	*
1103	* In contrast to the other drm_get_*_name functions this one here returns a
1104	* const pointer and hence is threadsafe.
1105	*/
1106	const char *drm_get_colorspace_name(enum drm_colorspace colorspace)
1107	{
1108	if (colorspace < ARRAY_SIZE(colorspace_names) && colorspace_names[colorspace])
1109	return colorspace_names[colorspace];
1110	else
1111	return "(null)";
1112	}
1113
1114	static const u32 hdmi_colorspaces =
1115	BIT(DRM_MODE_COLORIMETRY_SMPTE_170M_YCC) |
1116	BIT(DRM_MODE_COLORIMETRY_BT709_YCC) |
1117	BIT(DRM_MODE_COLORIMETRY_XVYCC_601) |
1118	BIT(DRM_MODE_COLORIMETRY_XVYCC_709) |
1119	BIT(DRM_MODE_COLORIMETRY_SYCC_601) |
1120	BIT(DRM_MODE_COLORIMETRY_OPYCC_601) |
1121	BIT(DRM_MODE_COLORIMETRY_OPRGB) |
1122	BIT(DRM_MODE_COLORIMETRY_BT2020_CYCC) |
1123	BIT(DRM_MODE_COLORIMETRY_BT2020_RGB) |
1124	BIT(DRM_MODE_COLORIMETRY_BT2020_YCC) |
1125	BIT(DRM_MODE_COLORIMETRY_DCI_P3_RGB_D65) |
1126	BIT(DRM_MODE_COLORIMETRY_DCI_P3_RGB_THEATER);
1127
1128	/*
1129	* As per DP 1.4a spec, 2.2.5.7.5 VSC SDP Payload for Pixel Encoding/Colorimetry
1130	* Format Table 2-120
1131	*/
1132	static const u32 dp_colorspaces =
1133	BIT(DRM_MODE_COLORIMETRY_RGB_WIDE_FIXED) |
1134	BIT(DRM_MODE_COLORIMETRY_RGB_WIDE_FLOAT) |
1135	BIT(DRM_MODE_COLORIMETRY_OPRGB) |
1136	BIT(DRM_MODE_COLORIMETRY_DCI_P3_RGB_D65) |
1137	BIT(DRM_MODE_COLORIMETRY_BT2020_RGB) |
1138	BIT(DRM_MODE_COLORIMETRY_BT601_YCC) |
1139	BIT(DRM_MODE_COLORIMETRY_BT709_YCC) |
1140	BIT(DRM_MODE_COLORIMETRY_XVYCC_601) |
1141	BIT(DRM_MODE_COLORIMETRY_XVYCC_709) |
1142	BIT(DRM_MODE_COLORIMETRY_SYCC_601) |
1143	BIT(DRM_MODE_COLORIMETRY_OPYCC_601) |
1144	BIT(DRM_MODE_COLORIMETRY_BT2020_CYCC) |
1145	BIT(DRM_MODE_COLORIMETRY_BT2020_YCC);
1146
1147	/**
1148	* DOC: standard connector properties
1149	*
1150	* DRM connectors have a few standardized properties:
1151	*
1152	* EDID:
1153	* Blob property which contains the current EDID read from the sink. This
1154	* is useful to parse sink identification information like vendor, model
1155	* and serial. Drivers should update this property by calling
1156	* drm_connector_update_edid_property(), usually after having parsed
1157	* the EDID using drm_add_edid_modes(). Userspace cannot change this
1158	* property.
1159	*
1160	* User-space should not parse the EDID to obtain information exposed via
1161	* other KMS properties (because the kernel might apply limits, quirks or
1162	* fixups to the EDID). For instance, user-space should not try to parse
1163	* mode lists from the EDID.
1164	* DPMS:
1165	* Legacy property for setting the power state of the connector. For atomic
1166	* drivers this is only provided for backwards compatibility with existing
1167	* drivers, it remaps to controlling the "ACTIVE" property on the CRTC the
1168	* connector is linked to. Drivers should never set this property directly,
1169	* it is handled by the DRM core by calling the &drm_connector_funcs.dpms
1170	* callback. For atomic drivers the remapping to the "ACTIVE" property is
1171	* implemented in the DRM core.
1172	*
1173	* Note that this property cannot be set through the MODE_ATOMIC ioctl,
1174	* userspace must use "ACTIVE" on the CRTC instead.
1175	*
1176	* WARNING:
1177	*
1178	* For userspace also running on legacy drivers the "DPMS" semantics are a
1179	* lot more complicated. First, userspace cannot rely on the "DPMS" value
1180	* returned by the GETCONNECTOR actually reflecting reality, because many
1181	* drivers fail to update it. For atomic drivers this is taken care of in
1182	* drm_atomic_helper_update_legacy_modeset_state().
1183	*
1184	* The second issue is that the DPMS state is only well-defined when the
1185	* connector is connected to a CRTC. In atomic the DRM core enforces that
1186	* "ACTIVE" is off in such a case, no such checks exists for "DPMS".
1187	*
1188	* Finally, when enabling an output using the legacy SETCONFIG ioctl then
1189	* "DPMS" is forced to ON. But see above, that might not be reflected in
1190	* the software value on legacy drivers.
1191	*
1192	* Summarizing: Only set "DPMS" when the connector is known to be enabled,
1193	* assume that a successful SETCONFIG call also sets "DPMS" to on, and
1194	* never read back the value of "DPMS" because it can be incorrect.
1195	* PATH:
1196	* Connector path property to identify how this sink is physically
1197	* connected. Used by DP MST. This should be set by calling
1198	* drm_connector_set_path_property(), in the case of DP MST with the
1199	* path property the MST manager created. Userspace cannot change this
1200	* property.
1201	* TILE:
1202	* Connector tile group property to indicate how a set of DRM connector
1203	* compose together into one logical screen. This is used by both high-res
1204	* external screens (often only using a single cable, but exposing multiple
1205	* DP MST sinks), or high-res integrated panels (like dual-link DSI) which
1206	* are not gen-locked. Note that for tiled panels which are genlocked, like
1207	* dual-link LVDS or dual-link DSI, the driver should try to not expose the
1208	* tiling and virtualise both &drm_crtc and &drm_plane if needed. Drivers
1209	* should update this value using drm_connector_set_tile_property().
1210	* Userspace cannot change this property.
1211	* link-status:
1212	* Connector link-status property to indicate the status of link. The
1213	* default value of link-status is "GOOD". If something fails during or
1214	* after modeset, the kernel driver may set this to "BAD" and issue a
1215	* hotplug uevent. Drivers should update this value using
1216	* drm_connector_set_link_status_property().
1217	*
1218	* When user-space receives the hotplug uevent and detects a "BAD"
1219	* link-status, the sink doesn't receive pixels anymore (e.g. the screen
1220	* becomes completely black). The list of available modes may have
1221	* changed. User-space is expected to pick a new mode if the current one
1222	* has disappeared and perform a new modeset with link-status set to
1223	* "GOOD" to re-enable the connector.
1224	*
1225	* If multiple connectors share the same CRTC and one of them gets a "BAD"
1226	* link-status, the other are unaffected (ie. the sinks still continue to
1227	* receive pixels).
1228	*
1229	* When user-space performs an atomic commit on a connector with a "BAD"
1230	* link-status without resetting the property to "GOOD", the sink may
1231	* still not receive pixels. When user-space performs an atomic commit
1232	* which resets the link-status property to "GOOD" without the
1233	* ALLOW_MODESET flag set, it might fail because a modeset is required.
1234	*
1235	* User-space can only change link-status to "GOOD", changing it to "BAD"
1236	* is a no-op.
1237	*
1238	* For backwards compatibility with non-atomic userspace the kernel
1239	* tries to automatically set the link-status back to "GOOD" in the
1240	* SETCRTC IOCTL. This might fail if the mode is no longer valid, similar
1241	* to how it might fail if a different screen has been connected in the
1242	* interim.
1243	* non_desktop:
1244	* Indicates the output should be ignored for purposes of displaying a
1245	* standard desktop environment or console. This is most likely because
1246	* the output device is not rectilinear.
1247	* Content Protection:
1248	* This property is used by userspace to request the kernel protect future
1249	* content communicated over the link. When requested, kernel will apply
1250	* the appropriate means of protection (most often HDCP), and use the
1251	* property to tell userspace the protection is active.
1252	*
1253	* Drivers can set this up by calling
1254	* drm_connector_attach_content_protection_property() on initialization.
1255	*
1256	* The value of this property can be one of the following:
1257	*
1258	* DRM_MODE_CONTENT_PROTECTION_UNDESIRED = 0
1259	* The link is not protected, content is transmitted in the clear.
1260	* DRM_MODE_CONTENT_PROTECTION_DESIRED = 1
1261	* Userspace has requested content protection, but the link is not
1262	* currently protected. When in this state, kernel should enable
1263	* Content Protection as soon as possible.
1264	* DRM_MODE_CONTENT_PROTECTION_ENABLED = 2
1265	* Userspace has requested content protection, and the link is
1266	* protected. Only the driver can set the property to this value.
1267	* If userspace attempts to set to ENABLED, kernel will return
1268	* -EINVAL.
1269	*
1270	* A few guidelines:
1271	*
1272	* - DESIRED state should be preserved until userspace de-asserts it by
1273	* setting the property to UNDESIRED. This means ENABLED should only
1274	* transition to UNDESIRED when the user explicitly requests it.
1275	* - If the state is DESIRED, kernel should attempt to re-authenticate the
1276	* link whenever possible. This includes across disable/enable, dpms,
1277	* hotplug, downstream device changes, link status failures, etc..
1278	* - Kernel sends uevent with the connector id and property id through
1279	* @drm_hdcp_update_content_protection, upon below kernel triggered
1280	* scenarios:
1281	*
1282	* - DESIRED -> ENABLED (authentication success)
1283	* - ENABLED -> DESIRED (termination of authentication)
1284	* - Please note no uevents for userspace triggered property state changes,
1285	* which can't fail such as
1286	*
1287	* - DESIRED/ENABLED -> UNDESIRED
1288	* - UNDESIRED -> DESIRED
1289	* - Userspace is responsible for polling the property or listen to uevents
1290	* to determine when the value transitions from ENABLED to DESIRED.
1291	* This signifies the link is no longer protected and userspace should
1292	* take appropriate action (whatever that might be).
1293	*
1294	* HDCP Content Type:
1295	* This Enum property is used by the userspace to declare the content type
1296	* of the display stream, to kernel. Here display stream stands for any
1297	* display content that userspace intended to display through HDCP
1298	* encryption.
1299	*
1300	* Content Type of a stream is decided by the owner of the stream, as
1301	* "HDCP Type0" or "HDCP Type1".
1302	*
1303	* The value of the property can be one of the below:
1304	* - "HDCP Type0": DRM_MODE_HDCP_CONTENT_TYPE0 = 0
1305	* - "HDCP Type1": DRM_MODE_HDCP_CONTENT_TYPE1 = 1
1306	*
1307	* When kernel starts the HDCP authentication (see "Content Protection"
1308	* for details), it uses the content type in "HDCP Content Type"
1309	* for performing the HDCP authentication with the display sink.
1310	*
1311	* Please note in HDCP spec versions, a link can be authenticated with
1312	* HDCP 2.2 for Content Type 0/Content Type 1. Where as a link can be
1313	* authenticated with HDCP1.4 only for Content Type 0(though it is implicit
1314	* in nature. As there is no reference for Content Type in HDCP1.4).
1315	*
1316	* HDCP2.2 authentication protocol itself takes the "Content Type" as a
1317	* parameter, which is a input for the DP HDCP2.2 encryption algo.
1318	*
1319	* In case of Type 0 content protection request, kernel driver can choose
1320	* either of HDCP spec versions 1.4 and 2.2. When HDCP2.2 is used for
1321	* "HDCP Type 0", a HDCP 2.2 capable repeater in the downstream can send
1322	* that content to a HDCP 1.4 authenticated HDCP sink (Type0 link).
1323	* But if the content is classified as "HDCP Type 1", above mentioned
1324	* HDCP 2.2 repeater wont send the content to the HDCP sink as it can't
1325	* authenticate the HDCP1.4 capable sink for "HDCP Type 1".
1326	*
1327	* Please note userspace can be ignorant of the HDCP versions used by the
1328	* kernel driver to achieve the "HDCP Content Type".
1329	*
1330	* At current scenario, classifying a content as Type 1 ensures that the
1331	* content will be displayed only through the HDCP2.2 encrypted link.
1332	*
1333	* Note that the HDCP Content Type property is introduced at HDCP 2.2, and
1334	* defaults to type 0. It is only exposed by drivers supporting HDCP 2.2
1335	* (hence supporting Type 0 and Type 1). Based on how next versions of
1336	* HDCP specs are defined content Type could be used for higher versions
1337	* too.
1338	*
1339	* If content type is changed when "Content Protection" is not UNDESIRED,
1340	* then kernel will disable the HDCP and re-enable with new type in the
1341	* same atomic commit. And when "Content Protection" is ENABLED, it means
1342	* that link is HDCP authenticated and encrypted, for the transmission of
1343	* the Type of stream mentioned at "HDCP Content Type".
1344	*
1345	* HDR_OUTPUT_METADATA:
1346	* Connector property to enable userspace to send HDR Metadata to
1347	* driver. This metadata is based on the composition and blending
1348	* policies decided by user, taking into account the hardware and
1349	* sink capabilities. The driver gets this metadata and creates a
1350	* Dynamic Range and Mastering Infoframe (DRM) in case of HDMI,
1351	* SDP packet (Non-audio INFOFRAME SDP v1.3) for DP. This is then
1352	* sent to sink. This notifies the sink of the upcoming frame's Color
1353	* Encoding and Luminance parameters.
1354	*
1355	* Userspace first need to detect the HDR capabilities of sink by
1356	* reading and parsing the EDID. Details of HDR metadata for HDMI
1357	* are added in CTA 861.G spec. For DP , its defined in VESA DP
1358	* Standard v1.4. It needs to then get the metadata information
1359	* of the video/game/app content which are encoded in HDR (basically
1360	* using HDR transfer functions). With this information it needs to
1361	* decide on a blending policy and compose the relevant
1362	* layers/overlays into a common format. Once this blending is done,
1363	* userspace will be aware of the metadata of the composed frame to
1364	* be send to sink. It then uses this property to communicate this
1365	* metadata to driver which then make a Infoframe packet and sends
1366	* to sink based on the type of encoder connected.
1367	*
1368	* Userspace will be responsible to do Tone mapping operation in case:
1369	* - Some layers are HDR and others are SDR
1370	* - HDR layers luminance is not same as sink
1371	*
1372	* It will even need to do colorspace conversion and get all layers
1373	* to one common colorspace for blending. It can use either GL, Media
1374	* or display engine to get this done based on the capabilities of the
1375	* associated hardware.
1376	*
1377	* Driver expects metadata to be put in &struct hdr_output_metadata
1378	* structure from userspace. This is received as blob and stored in
1379	* &drm_connector_state.hdr_output_metadata. It parses EDID and saves the
1380	* sink metadata in &struct hdr_sink_metadata, as
1381	* &drm_connector.hdr_sink_metadata. Driver uses
1382	* drm_hdmi_infoframe_set_hdr_metadata() helper to set the HDR metadata,
1383	* hdmi_drm_infoframe_pack() to pack the infoframe as per spec, in case of
1384	* HDMI encoder.
1385	*
1386	* max bpc:
1387	* This range property is used by userspace to limit the bit depth. When
1388	* used the driver would limit the bpc in accordance with the valid range
1389	* supported by the hardware and sink. Drivers to use the function
1390	* drm_connector_attach_max_bpc_property() to create and attach the
1391	* property to the connector during initialization.
1392	*
1393	* Connectors also have one standardized atomic property:
1394	*
1395	* CRTC_ID:
1396	* Mode object ID of the &drm_crtc this connector should be connected to.
1397	*
1398	* Connectors for LCD panels may also have one standardized property:
1399	*
1400	* panel orientation:
1401	* On some devices the LCD panel is mounted in the casing in such a way
1402	* that the up/top side of the panel does not match with the top side of
1403	* the device. Userspace can use this property to check for this.
1404	* Note that input coordinates from touchscreens (input devices with
1405	* INPUT_PROP_DIRECT) will still map 1:1 to the actual LCD panel
1406	* coordinates, so if userspace rotates the picture to adjust for
1407	* the orientation it must also apply the same transformation to the
1408	* touchscreen input coordinates. This property is initialized by calling
1409	* drm_connector_set_panel_orientation() or
1410	* drm_connector_set_panel_orientation_with_quirk()
1411	*
1412	* scaling mode:
1413	* This property defines how a non-native mode is upscaled to the native
1414	* mode of an LCD panel:
1415	*
1416	* None:
1417	* No upscaling happens, scaling is left to the panel. Not all
1418	* drivers expose this mode.
1419	* Full:
1420	* The output is upscaled to the full resolution of the panel,
1421	* ignoring the aspect ratio.
1422	* Center:
1423	* No upscaling happens, the output is centered within the native
1424	* resolution the panel.
1425	* Full aspect:
1426	* The output is upscaled to maximize either the width or height
1427	* while retaining the aspect ratio.
1428	*
1429	* This property should be set up by calling
1430	* drm_connector_attach_scaling_mode_property(). Note that drivers
1431	* can also expose this property to external outputs, in which case they
1432	* must support "None", which should be the default (since external screens
1433	* have a built-in scaler).
1434	*
1435	* subconnector:
1436	* This property is used by DVI-I, TVout and DisplayPort to indicate different
1437	* connector subtypes. Enum values more or less match with those from main
1438	* connector types.
1439	* For DVI-I and TVout there is also a matching property "select subconnector"
1440	* allowing to switch between signal types.
1441	* DP subconnector corresponds to a downstream port.
1442	*
1443	* privacy-screen sw-state, privacy-screen hw-state:
1444	* These 2 optional properties can be used to query the state of the
1445	* electronic privacy screen that is available on some displays; and in
1446	* some cases also control the state. If a driver implements these
1447	* properties then both properties must be present.
1448	*
1449	* "privacy-screen hw-state" is read-only and reflects the actual state
1450	* of the privacy-screen, possible values: "Enabled", "Disabled,
1451	* "Enabled-locked", "Disabled-locked". The locked states indicate
1452	* that the state cannot be changed through the DRM API. E.g. there
1453	* might be devices where the firmware-setup options, or a hardware
1454	* slider-switch, offer always on / off modes.
1455	*
1456	* "privacy-screen sw-state" can be set to change the privacy-screen state
1457	* when not locked. In this case the driver must update the hw-state
1458	* property to reflect the new state on completion of the commit of the
1459	* sw-state property. Setting the sw-state property when the hw-state is
1460	* locked must be interpreted by the driver as a request to change the
1461	* state to the set state when the hw-state becomes unlocked. E.g. if
1462	* "privacy-screen hw-state" is "Enabled-locked" and the sw-state
1463	* gets set to "Disabled" followed by the user unlocking the state by
1464	* changing the slider-switch position, then the driver must set the
1465	* state to "Disabled" upon receiving the unlock event.
1466	*
1467	* In some cases the privacy-screen's actual state might change outside of
1468	* control of the DRM code. E.g. there might be a firmware handled hotkey
1469	* which toggles the actual state, or the actual state might be changed
1470	* through another userspace API such as writing /proc/acpi/ibm/lcdshadow.
1471	* In this case the driver must update both the hw-state and the sw-state
1472	* to reflect the new value, overwriting any pending state requests in the
1473	* sw-state. Any pending sw-state requests are thus discarded.
1474	*
1475	* Note that the ability for the state to change outside of control of
1476	* the DRM master process means that userspace must not cache the value
1477	* of the sw-state. Caching the sw-state value and including it in later
1478	* atomic commits may lead to overriding a state change done through e.g.
1479	* a firmware handled hotkey. Therefor userspace must not include the
1480	* privacy-screen sw-state in an atomic commit unless it wants to change
1481	* its value.
1482	*
1483	* left margin, right margin, top margin, bottom margin:
1484	* Add margins to the connector's viewport. This is typically used to
1485	* mitigate overscan on TVs.
1486	*
1487	* The value is the size in pixels of the black border which will be
1488	* added. The attached CRTC's content will be scaled to fill the whole
1489	* area inside the margin.
1490	*
1491	* The margins configuration might be sent to the sink, e.g. via HDMI AVI
1492	* InfoFrames.
1493	*
1494	* Drivers can set up these properties by calling
1495	* drm_mode_create_tv_margin_properties().
1496	*/
1497
1498	int drm_connector_create_standard_properties(struct drm_device *dev)
1499	{
1500	struct drm_property *prop;
1501
1502	prop = drm_property_create(dev, DRM_MODE_PROP_BLOB |
1503	DRM_MODE_PROP_IMMUTABLE,
1504	name: "EDID", num_values: 0);
1505	if (!prop)
1506	return -ENOMEM;
1507	dev->mode_config.edid_property = prop;
1508
1509	prop = drm_property_create_enum(dev, flags: 0,
1510	name: "DPMS", props: drm_dpms_enum_list,
1511	ARRAY_SIZE(drm_dpms_enum_list));
1512	if (!prop)
1513	return -ENOMEM;
1514	dev->mode_config.dpms_property = prop;
1515
1516	prop = drm_property_create(dev,
1517	DRM_MODE_PROP_BLOB |
1518	DRM_MODE_PROP_IMMUTABLE,
1519	name: "PATH", num_values: 0);
1520	if (!prop)
1521	return -ENOMEM;
1522	dev->mode_config.path_property = prop;
1523
1524	prop = drm_property_create(dev,
1525	DRM_MODE_PROP_BLOB |
1526	DRM_MODE_PROP_IMMUTABLE,
1527	name: "TILE", num_values: 0);
1528	if (!prop)
1529	return -ENOMEM;
1530	dev->mode_config.tile_property = prop;
1531
1532	prop = drm_property_create_enum(dev, flags: 0, name: "link-status",
1533	props: drm_link_status_enum_list,
1534	ARRAY_SIZE(drm_link_status_enum_list));
1535	if (!prop)
1536	return -ENOMEM;
1537	dev->mode_config.link_status_property = prop;
1538
1539	prop = drm_property_create_bool(dev, DRM_MODE_PROP_IMMUTABLE, name: "non-desktop");
1540	if (!prop)
1541	return -ENOMEM;
1542	dev->mode_config.non_desktop_property = prop;
1543
1544	prop = drm_property_create(dev, DRM_MODE_PROP_BLOB,
1545	name: "HDR_OUTPUT_METADATA", num_values: 0);
1546	if (!prop)
1547	return -ENOMEM;
1548	dev->mode_config.hdr_output_metadata_property = prop;
1549
1550	return 0;
1551	}
1552
1553	/**
1554	* drm_mode_create_dvi_i_properties - create DVI-I specific connector properties
1555	* @dev: DRM device
1556	*
1557	* Called by a driver the first time a DVI-I connector is made.
1558	*
1559	* Returns: %0
1560	*/
1561	int drm_mode_create_dvi_i_properties(struct drm_device *dev)
1562	{
1563	struct drm_property *dvi_i_selector;
1564	struct drm_property *dvi_i_subconnector;
1565
1566	if (dev->mode_config.dvi_i_select_subconnector_property)
1567	return 0;
1568
1569	dvi_i_selector =
1570	drm_property_create_enum(dev, flags: 0,
1571	name: "select subconnector",
1572	props: drm_dvi_i_select_enum_list,
1573	ARRAY_SIZE(drm_dvi_i_select_enum_list));
1574	dev->mode_config.dvi_i_select_subconnector_property = dvi_i_selector;
1575
1576	dvi_i_subconnector = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
1577	name: "subconnector",
1578	props: drm_dvi_i_subconnector_enum_list,
1579	ARRAY_SIZE(drm_dvi_i_subconnector_enum_list));
1580	dev->mode_config.dvi_i_subconnector_property = dvi_i_subconnector;
1581
1582	return 0;
1583	}
1584	EXPORT_SYMBOL(drm_mode_create_dvi_i_properties);
1585
1586	/**
1587	* drm_connector_attach_dp_subconnector_property - create subconnector property for DP
1588	* @connector: drm_connector to attach property
1589	*
1590	* Called by a driver when DP connector is created.
1591	*/
1592	void drm_connector_attach_dp_subconnector_property(struct drm_connector *connector)
1593	{
1594	struct drm_mode_config *mode_config = &connector->dev->mode_config;
1595
1596	if (!mode_config->dp_subconnector_property)
1597	mode_config->dp_subconnector_property =
1598	drm_property_create_enum(dev: connector->dev,
1599	DRM_MODE_PROP_IMMUTABLE,
1600	name: "subconnector",
1601	props: drm_dp_subconnector_enum_list,
1602	ARRAY_SIZE(drm_dp_subconnector_enum_list));
1603
1604	drm_object_attach_property(obj: &connector->base,
1605	property: mode_config->dp_subconnector_property,
1606	init_val: DRM_MODE_SUBCONNECTOR_Unknown);
1607	}
1608	EXPORT_SYMBOL(drm_connector_attach_dp_subconnector_property);
1609
1610	/**
1611	* DOC: HDMI connector properties
1612	*
1613	* content type (HDMI specific):
1614	* Indicates content type setting to be used in HDMI infoframes to indicate
1615	* content type for the external device, so that it adjusts its display
1616	* settings accordingly.
1617	*
1618	* The value of this property can be one of the following:
1619	*
1620	* No Data:
1621	* Content type is unknown
1622	* Graphics:
1623	* Content type is graphics
1624	* Photo:
1625	* Content type is photo
1626	* Cinema:
1627	* Content type is cinema
1628	* Game:
1629	* Content type is game
1630	*
1631	* The meaning of each content type is defined in CTA-861-G table 15.
1632	*
1633	* Drivers can set up this property by calling
1634	* drm_connector_attach_content_type_property(). Decoding to
1635	* infoframe values is done through drm_hdmi_avi_infoframe_content_type().
1636	*/
1637
1638	/*
1639	* TODO: Document the properties:
1640	* - brightness
1641	* - contrast
1642	* - flicker reduction
1643	* - hue
1644	* - mode
1645	* - overscan
1646	* - saturation
1647	* - select subconnector
1648	*/
1649	/**
1650	* DOC: Analog TV Connector Properties
1651	*
1652	* TV Mode:
1653	* Indicates the TV Mode used on an analog TV connector. The value
1654	* of this property can be one of the following:
1655	*
1656	* NTSC:
1657	* TV Mode is CCIR System M (aka 525-lines) together with
1658	* the NTSC Color Encoding.
1659	*
1660	* NTSC-443:
1661	*
1662	* TV Mode is CCIR System M (aka 525-lines) together with
1663	* the NTSC Color Encoding, but with a color subcarrier
1664	* frequency of 4.43MHz
1665	*
1666	* NTSC-J:
1667	*
1668	* TV Mode is CCIR System M (aka 525-lines) together with
1669	* the NTSC Color Encoding, but with a black level equal to
1670	* the blanking level.
1671	*
1672	* PAL:
1673	*
1674	* TV Mode is CCIR System B (aka 625-lines) together with
1675	* the PAL Color Encoding.
1676	*
1677	* PAL-M:
1678	*
1679	* TV Mode is CCIR System M (aka 525-lines) together with
1680	* the PAL Color Encoding.
1681	*
1682	* PAL-N:
1683	*
1684	* TV Mode is CCIR System N together with the PAL Color
1685	* Encoding, a color subcarrier frequency of 3.58MHz, the
1686	* SECAM color space, and narrower channels than other PAL
1687	* variants.
1688	*
1689	* SECAM:
1690	*
1691	* TV Mode is CCIR System B (aka 625-lines) together with
1692	* the SECAM Color Encoding.
1693	*
1694	* Drivers can set up this property by calling
1695	* drm_mode_create_tv_properties().
1696	*/
1697
1698	/**
1699	* drm_connector_attach_content_type_property - attach content-type property
1700	* @connector: connector to attach content type property on.
1701	*
1702	* Called by a driver the first time a HDMI connector is made.
1703	*
1704	* Returns: %0
1705	*/
1706	int drm_connector_attach_content_type_property(struct drm_connector *connector)
1707	{
1708	if (!drm_mode_create_content_type_property(dev: connector->dev))
1709	drm_object_attach_property(obj: &connector->base,
1710	property: connector->dev->mode_config.content_type_property,
1711	DRM_MODE_CONTENT_TYPE_NO_DATA);
1712	return 0;
1713	}
1714	EXPORT_SYMBOL(drm_connector_attach_content_type_property);
1715
1716	/**
1717	* drm_connector_attach_tv_margin_properties - attach TV connector margin
1718	* properties
1719	* @connector: DRM connector
1720	*
1721	* Called by a driver when it needs to attach TV margin props to a connector.
1722	* Typically used on SDTV and HDMI connectors.
1723	*/
1724	void drm_connector_attach_tv_margin_properties(struct drm_connector *connector)
1725	{
1726	struct drm_device *dev = connector->dev;
1727
1728	drm_object_attach_property(obj: &connector->base,
1729	property: dev->mode_config.tv_left_margin_property,
1730	init_val: 0);
1731	drm_object_attach_property(obj: &connector->base,
1732	property: dev->mode_config.tv_right_margin_property,
1733	init_val: 0);
1734	drm_object_attach_property(obj: &connector->base,
1735	property: dev->mode_config.tv_top_margin_property,
1736	init_val: 0);
1737	drm_object_attach_property(obj: &connector->base,
1738	property: dev->mode_config.tv_bottom_margin_property,
1739	init_val: 0);
1740	}
1741	EXPORT_SYMBOL(drm_connector_attach_tv_margin_properties);
1742
1743	/**
1744	* drm_mode_create_tv_margin_properties - create TV connector margin properties
1745	* @dev: DRM device
1746	*
1747	* Called by a driver's HDMI connector initialization routine, this function
1748	* creates the TV margin properties for a given device. No need to call this
1749	* function for an SDTV connector, it's already called from
1750	* drm_mode_create_tv_properties_legacy().
1751	*
1752	* Returns:
1753	* 0 on success or a negative error code on failure.
1754	*/
1755	int drm_mode_create_tv_margin_properties(struct drm_device *dev)
1756	{
1757	if (dev->mode_config.tv_left_margin_property)
1758	return 0;
1759
1760	dev->mode_config.tv_left_margin_property =
1761	drm_property_create_range(dev, flags: 0, name: "left margin", min: 0, max: 100);
1762	if (!dev->mode_config.tv_left_margin_property)
1763	return -ENOMEM;
1764
1765	dev->mode_config.tv_right_margin_property =
1766	drm_property_create_range(dev, flags: 0, name: "right margin", min: 0, max: 100);
1767	if (!dev->mode_config.tv_right_margin_property)
1768	return -ENOMEM;
1769
1770	dev->mode_config.tv_top_margin_property =
1771	drm_property_create_range(dev, flags: 0, name: "top margin", min: 0, max: 100);
1772	if (!dev->mode_config.tv_top_margin_property)
1773	return -ENOMEM;
1774
1775	dev->mode_config.tv_bottom_margin_property =
1776	drm_property_create_range(dev, flags: 0, name: "bottom margin", min: 0, max: 100);
1777	if (!dev->mode_config.tv_bottom_margin_property)
1778	return -ENOMEM;
1779
1780	return 0;
1781	}
1782	EXPORT_SYMBOL(drm_mode_create_tv_margin_properties);
1783
1784	/**
1785	* drm_mode_create_tv_properties_legacy - create TV specific connector properties
1786	* @dev: DRM device
1787	* @num_modes: number of different TV formats (modes) supported
1788	* @modes: array of pointers to strings containing name of each format
1789	*
1790	* Called by a driver's TV initialization routine, this function creates
1791	* the TV specific connector properties for a given device. Caller is
1792	* responsible for allocating a list of format names and passing them to
1793	* this routine.
1794	*
1795	* NOTE: This functions registers the deprecated "mode" connector
1796	* property to select the analog TV mode (ie, NTSC, PAL, etc.). New
1797	* drivers must use drm_mode_create_tv_properties() instead.
1798	*
1799	* Returns:
1800	* 0 on success or a negative error code on failure.
1801	*/
1802	int drm_mode_create_tv_properties_legacy(struct drm_device *dev,
1803	unsigned int num_modes,
1804	const char * const modes[])
1805	{
1806	struct drm_property *tv_selector;
1807	struct drm_property *tv_subconnector;
1808	unsigned int i;
1809
1810	if (dev->mode_config.tv_select_subconnector_property)
1811	return 0;
1812
1813	/*
1814	* Basic connector properties
1815	*/
1816	tv_selector = drm_property_create_enum(dev, flags: 0,
1817	name: "select subconnector",
1818	props: drm_tv_select_enum_list,
1819	ARRAY_SIZE(drm_tv_select_enum_list));
1820	if (!tv_selector)
1821	goto nomem;
1822
1823	dev->mode_config.tv_select_subconnector_property = tv_selector;
1824
1825	tv_subconnector =
1826	drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
1827	name: "subconnector",
1828	props: drm_tv_subconnector_enum_list,
1829	ARRAY_SIZE(drm_tv_subconnector_enum_list));
1830	if (!tv_subconnector)
1831	goto nomem;
1832	dev->mode_config.tv_subconnector_property = tv_subconnector;
1833
1834	/*
1835	* Other, TV specific properties: margins & TV modes.
1836	*/
1837	if (drm_mode_create_tv_margin_properties(dev))
1838	goto nomem;
1839
1840	if (num_modes) {
1841	dev->mode_config.legacy_tv_mode_property =
1842	drm_property_create(dev, DRM_MODE_PROP_ENUM,
1843	name: "mode", num_values: num_modes);
1844	if (!dev->mode_config.legacy_tv_mode_property)
1845	goto nomem;
1846
1847	for (i = 0; i < num_modes; i++)
1848	drm_property_add_enum(property: dev->mode_config.legacy_tv_mode_property,
1849	value: i, name: modes[i]);
1850	}
1851
1852	dev->mode_config.tv_brightness_property =
1853	drm_property_create_range(dev, flags: 0, name: "brightness", min: 0, max: 100);
1854	if (!dev->mode_config.tv_brightness_property)
1855	goto nomem;
1856
1857	dev->mode_config.tv_contrast_property =
1858	drm_property_create_range(dev, flags: 0, name: "contrast", min: 0, max: 100);
1859	if (!dev->mode_config.tv_contrast_property)
1860	goto nomem;
1861
1862	dev->mode_config.tv_flicker_reduction_property =
1863	drm_property_create_range(dev, flags: 0, name: "flicker reduction", min: 0, max: 100);
1864	if (!dev->mode_config.tv_flicker_reduction_property)
1865	goto nomem;
1866
1867	dev->mode_config.tv_overscan_property =
1868	drm_property_create_range(dev, flags: 0, name: "overscan", min: 0, max: 100);
1869	if (!dev->mode_config.tv_overscan_property)
1870	goto nomem;
1871
1872	dev->mode_config.tv_saturation_property =
1873	drm_property_create_range(dev, flags: 0, name: "saturation", min: 0, max: 100);
1874	if (!dev->mode_config.tv_saturation_property)
1875	goto nomem;
1876
1877	dev->mode_config.tv_hue_property =
1878	drm_property_create_range(dev, flags: 0, name: "hue", min: 0, max: 100);
1879	if (!dev->mode_config.tv_hue_property)
1880	goto nomem;
1881
1882	return 0;
1883	nomem:
1884	return -ENOMEM;
1885	}
1886	EXPORT_SYMBOL(drm_mode_create_tv_properties_legacy);
1887
1888	/**
1889	* drm_mode_create_tv_properties - create TV specific connector properties
1890	* @dev: DRM device
1891	* @supported_tv_modes: Bitmask of TV modes supported (See DRM_MODE_TV_MODE_*)
1892	*
1893	* Called by a driver's TV initialization routine, this function creates
1894	* the TV specific connector properties for a given device.
1895	*
1896	* Returns:
1897	* 0 on success or a negative error code on failure.
1898	*/
1899	int drm_mode_create_tv_properties(struct drm_device *dev,
1900	unsigned int supported_tv_modes)
1901	{
1902	struct drm_prop_enum_list tv_mode_list[DRM_MODE_TV_MODE_MAX];
1903	struct drm_property *tv_mode;
1904	unsigned int i, len = 0;
1905
1906	if (dev->mode_config.tv_mode_property)
1907	return 0;
1908
1909	for (i = 0; i < DRM_MODE_TV_MODE_MAX; i++) {
1910	if (!(supported_tv_modes & BIT(i)))
1911	continue;
1912
1913	tv_mode_list[len].type = i;
1914	tv_mode_list[len].name = drm_get_tv_mode_name(val: i);
1915	len++;
1916	}
1917
1918	tv_mode = drm_property_create_enum(dev, flags: 0, name: "TV mode",
1919	props: tv_mode_list, num_values: len);
1920	if (!tv_mode)
1921	return -ENOMEM;
1922
1923	dev->mode_config.tv_mode_property = tv_mode;
1924
1925	return drm_mode_create_tv_properties_legacy(dev, 0, NULL);
1926	}
1927	EXPORT_SYMBOL(drm_mode_create_tv_properties);
1928
1929	/**
1930	* drm_mode_create_scaling_mode_property - create scaling mode property
1931	* @dev: DRM device
1932	*
1933	* Called by a driver the first time it's needed, must be attached to desired
1934	* connectors.
1935	*
1936	* Atomic drivers should use drm_connector_attach_scaling_mode_property()
1937	* instead to correctly assign &drm_connector_state.scaling_mode
1938	* in the atomic state.
1939	*
1940	* Returns: %0
1941	*/
1942	int drm_mode_create_scaling_mode_property(struct drm_device *dev)
1943	{
1944	struct drm_property *scaling_mode;
1945
1946	if (dev->mode_config.scaling_mode_property)
1947	return 0;
1948
1949	scaling_mode =
1950	drm_property_create_enum(dev, flags: 0, name: "scaling mode",
1951	props: drm_scaling_mode_enum_list,
1952	ARRAY_SIZE(drm_scaling_mode_enum_list));
1953
1954	dev->mode_config.scaling_mode_property = scaling_mode;
1955
1956	return 0;
1957	}
1958	EXPORT_SYMBOL(drm_mode_create_scaling_mode_property);
1959
1960	/**
1961	* DOC: Variable refresh properties
1962	*
1963	* Variable refresh rate capable displays can dynamically adjust their
1964	* refresh rate by extending the duration of their vertical front porch
1965	* until page flip or timeout occurs. This can reduce or remove stuttering
1966	* and latency in scenarios where the page flip does not align with the
1967	* vblank interval.
1968	*
1969	* An example scenario would be an application flipping at a constant rate
1970	* of 48Hz on a 60Hz display. The page flip will frequently miss the vblank
1971	* interval and the same contents will be displayed twice. This can be
1972	* observed as stuttering for content with motion.
1973	*
1974	* If variable refresh rate was active on a display that supported a
1975	* variable refresh range from 35Hz to 60Hz no stuttering would be observable
1976	* for the example scenario. The minimum supported variable refresh rate of
1977	* 35Hz is below the page flip frequency and the vertical front porch can
1978	* be extended until the page flip occurs. The vblank interval will be
1979	* directly aligned to the page flip rate.
1980	*
1981	* Not all userspace content is suitable for use with variable refresh rate.
1982	* Large and frequent changes in vertical front porch duration may worsen
1983	* perceived stuttering for input sensitive applications.
1984	*
1985	* Panel brightness will also vary with vertical front porch duration. Some
1986	* panels may have noticeable differences in brightness between the minimum
1987	* vertical front porch duration and the maximum vertical front porch duration.
1988	* Large and frequent changes in vertical front porch duration may produce
1989	* observable flickering for such panels.
1990	*
1991	* Userspace control for variable refresh rate is supported via properties
1992	* on the &drm_connector and &drm_crtc objects.
1993	*
1994	* "vrr_capable":
1995	* Optional &drm_connector boolean property that drivers should attach
1996	* with drm_connector_attach_vrr_capable_property() on connectors that
1997	* could support variable refresh rates. Drivers should update the
1998	* property value by calling drm_connector_set_vrr_capable_property().
1999	*
2000	* Absence of the property should indicate absence of support.
2001	*
2002	* "VRR_ENABLED":
2003	* Default &drm_crtc boolean property that notifies the driver that the
2004	* content on the CRTC is suitable for variable refresh rate presentation.
2005	* The driver will take this property as a hint to enable variable
2006	* refresh rate support if the receiver supports it, ie. if the
2007	* "vrr_capable" property is true on the &drm_connector object. The
2008	* vertical front porch duration will be extended until page-flip or
2009	* timeout when enabled.
2010	*
2011	* The minimum vertical front porch duration is defined as the vertical
2012	* front porch duration for the current mode.
2013	*
2014	* The maximum vertical front porch duration is greater than or equal to
2015	* the minimum vertical front porch duration. The duration is derived
2016	* from the minimum supported variable refresh rate for the connector.
2017	*
2018	* The driver may place further restrictions within these minimum
2019	* and maximum bounds.
2020	*/
2021
2022	/**
2023	* drm_connector_attach_vrr_capable_property - creates the
2024	* vrr_capable property
2025	* @connector: connector to create the vrr_capable property on.
2026	*
2027	* This is used by atomic drivers to add support for querying
2028	* variable refresh rate capability for a connector.
2029	*
2030	* Returns:
2031	* Zero on success, negative errno on failure.
2032	*/
2033	int drm_connector_attach_vrr_capable_property(
2034	struct drm_connector *connector)
2035	{
2036	struct drm_device *dev = connector->dev;
2037	struct drm_property *prop;
2038
2039	if (!connector->vrr_capable_property) {
2040	prop = drm_property_create_bool(dev, DRM_MODE_PROP_IMMUTABLE,
2041	name: "vrr_capable");
2042	if (!prop)
2043	return -ENOMEM;
2044
2045	connector->vrr_capable_property = prop;
2046	drm_object_attach_property(obj: &connector->base, property: prop, init_val: 0);
2047	}
2048
2049	return 0;
2050	}
2051	EXPORT_SYMBOL(drm_connector_attach_vrr_capable_property);
2052
2053	/**
2054	* drm_connector_attach_scaling_mode_property - attach atomic scaling mode property
2055	* @connector: connector to attach scaling mode property on.
2056	* @scaling_mode_mask: or'ed mask of BIT(%DRM_MODE_SCALE_\*).
2057	*
2058	* This is used to add support for scaling mode to atomic drivers.
2059	* The scaling mode will be set to &drm_connector_state.scaling_mode
2060	* and can be used from &drm_connector_helper_funcs->atomic_check for validation.
2061	*
2062	* This is the atomic version of drm_mode_create_scaling_mode_property().
2063	*
2064	* Returns:
2065	* Zero on success, negative errno on failure.
2066	*/
2067	int drm_connector_attach_scaling_mode_property(struct drm_connector *connector,
2068	u32 scaling_mode_mask)
2069	{
2070	struct drm_device *dev = connector->dev;
2071	struct drm_property *scaling_mode_property;
2072	int i;
2073	const unsigned valid_scaling_mode_mask =
2074	(1U << ARRAY_SIZE(drm_scaling_mode_enum_list)) - 1;
2075
2076	if (WARN_ON(hweight32(scaling_mode_mask) < 2 ||
2077	scaling_mode_mask & ~valid_scaling_mode_mask))
2078	return -EINVAL;
2079
2080	scaling_mode_property =
2081	drm_property_create(dev, DRM_MODE_PROP_ENUM, name: "scaling mode",
2082	hweight32(scaling_mode_mask));
2083
2084	if (!scaling_mode_property)
2085	return -ENOMEM;
2086
2087	for (i = 0; i < ARRAY_SIZE(drm_scaling_mode_enum_list); i++) {
2088	int ret;
2089
2090	if (!(BIT(i) & scaling_mode_mask))
2091	continue;
2092
2093	ret = drm_property_add_enum(property: scaling_mode_property,
2094	value: drm_scaling_mode_enum_list[i].type,
2095	name: drm_scaling_mode_enum_list[i].name);
2096
2097	if (ret) {
2098	drm_property_destroy(dev, property: scaling_mode_property);
2099
2100	return ret;
2101	}
2102	}
2103
2104	drm_object_attach_property(obj: &connector->base,
2105	property: scaling_mode_property, init_val: 0);
2106
2107	connector->scaling_mode_property = scaling_mode_property;
2108
2109	return 0;
2110	}
2111	EXPORT_SYMBOL(drm_connector_attach_scaling_mode_property);
2112
2113	/**
2114	* drm_mode_create_aspect_ratio_property - create aspect ratio property
2115	* @dev: DRM device
2116	*
2117	* Called by a driver the first time it's needed, must be attached to desired
2118	* connectors.
2119	*
2120	* Returns:
2121	* Zero on success, negative errno on failure.
2122	*/
2123	int drm_mode_create_aspect_ratio_property(struct drm_device *dev)
2124	{
2125	if (dev->mode_config.aspect_ratio_property)
2126	return 0;
2127
2128	dev->mode_config.aspect_ratio_property =
2129	drm_property_create_enum(dev, flags: 0, name: "aspect ratio",
2130	props: drm_aspect_ratio_enum_list,
2131	ARRAY_SIZE(drm_aspect_ratio_enum_list));
2132
2133	if (dev->mode_config.aspect_ratio_property == NULL)
2134	return -ENOMEM;
2135
2136	return 0;
2137	}
2138	EXPORT_SYMBOL(drm_mode_create_aspect_ratio_property);
2139
2140	/**
2141	* DOC: standard connector properties
2142	*
2143	* Colorspace:
2144	* This property helps select a suitable colorspace based on the sink
2145	* capability. Modern sink devices support wider gamut like BT2020.
2146	* This helps switch to BT2020 mode if the BT2020 encoded video stream
2147	* is being played by the user, same for any other colorspace. Thereby
2148	* giving a good visual experience to users.
2149	*
2150	* The expectation from userspace is that it should parse the EDID
2151	* and get supported colorspaces. Use this property and switch to the
2152	* one supported. Sink supported colorspaces should be retrieved by
2153	* userspace from EDID and driver will not explicitly expose them.
2154	*
2155	* Basically the expectation from userspace is:
2156	* - Set up CRTC DEGAMMA/CTM/GAMMA to convert to some sink
2157	* colorspace
2158	* - Set this new property to let the sink know what it
2159	* converted the CRTC output to.
2160	* - This property is just to inform sink what colorspace
2161	* source is trying to drive.
2162	*
2163	* Because between HDMI and DP have different colorspaces,
2164	* drm_mode_create_hdmi_colorspace_property() is used for HDMI connector and
2165	* drm_mode_create_dp_colorspace_property() is used for DP connector.
2166	*/
2167
2168	static int drm_mode_create_colorspace_property(struct drm_connector *connector,
2169	u32 supported_colorspaces)
2170	{
2171	struct drm_device *dev = connector->dev;
2172	u32 colorspaces = supported_colorspaces | BIT(DRM_MODE_COLORIMETRY_DEFAULT);
2173	struct drm_prop_enum_list enum_list[DRM_MODE_COLORIMETRY_COUNT];
2174	int i, len;
2175
2176	if (connector->colorspace_property)
2177	return 0;
2178
2179	if (!supported_colorspaces) {
2180	drm_err(dev, "No supported colorspaces provded on [CONNECTOR:%d:%s]\n",
2181	connector->base.id, connector->name);
2182	return -EINVAL;
2183	}
2184
2185	if ((supported_colorspaces & -BIT(DRM_MODE_COLORIMETRY_COUNT)) != 0) {
2186	drm_err(dev, "Unknown colorspace provded on [CONNECTOR:%d:%s]\n",
2187	connector->base.id, connector->name);
2188	return -EINVAL;
2189	}
2190
2191	len = 0;
2192	for (i = 0; i < DRM_MODE_COLORIMETRY_COUNT; i++) {
2193	if ((colorspaces & BIT(i)) == 0)
2194	continue;
2195
2196	enum_list[len].type = i;
2197	enum_list[len].name = colorspace_names[i];
2198	len++;
2199	}
2200
2201	connector->colorspace_property =
2202	drm_property_create_enum(dev, DRM_MODE_PROP_ENUM, name: "Colorspace",
2203	props: enum_list,
2204	num_values: len);
2205
2206	if (!connector->colorspace_property)
2207	return -ENOMEM;
2208
2209	return 0;
2210	}
2211
2212	/**
2213	* drm_mode_create_hdmi_colorspace_property - create hdmi colorspace property
2214	* @connector: connector to create the Colorspace property on.
2215	* @supported_colorspaces: bitmap of supported color spaces
2216	*
2217	* Called by a driver the first time it's needed, must be attached to desired
2218	* HDMI connectors.
2219	*
2220	* Returns:
2221	* Zero on success, negative errno on failure.
2222	*/
2223	int drm_mode_create_hdmi_colorspace_property(struct drm_connector *connector,
2224	u32 supported_colorspaces)
2225	{
2226	u32 colorspaces;
2227
2228	if (supported_colorspaces)
2229	colorspaces = supported_colorspaces & hdmi_colorspaces;
2230	else
2231	colorspaces = hdmi_colorspaces;
2232
2233	return drm_mode_create_colorspace_property(connector, supported_colorspaces: colorspaces);
2234	}
2235	EXPORT_SYMBOL(drm_mode_create_hdmi_colorspace_property);
2236
2237	/**
2238	* drm_mode_create_dp_colorspace_property - create dp colorspace property
2239	* @connector: connector to create the Colorspace property on.
2240	* @supported_colorspaces: bitmap of supported color spaces
2241	*
2242	* Called by a driver the first time it's needed, must be attached to desired
2243	* DP connectors.
2244	*
2245	* Returns:
2246	* Zero on success, negative errno on failure.
2247	*/
2248	int drm_mode_create_dp_colorspace_property(struct drm_connector *connector,
2249	u32 supported_colorspaces)
2250	{
2251	u32 colorspaces;
2252
2253	if (supported_colorspaces)
2254	colorspaces = supported_colorspaces & dp_colorspaces;
2255	else
2256	colorspaces = dp_colorspaces;
2257
2258	return drm_mode_create_colorspace_property(connector, supported_colorspaces: colorspaces);
2259	}
2260	EXPORT_SYMBOL(drm_mode_create_dp_colorspace_property);
2261
2262	/**
2263	* drm_mode_create_content_type_property - create content type property
2264	* @dev: DRM device
2265	*
2266	* Called by a driver the first time it's needed, must be attached to desired
2267	* connectors.
2268	*
2269	* Returns:
2270	* Zero on success, negative errno on failure.
2271	*/
2272	int drm_mode_create_content_type_property(struct drm_device *dev)
2273	{
2274	if (dev->mode_config.content_type_property)
2275	return 0;
2276
2277	dev->mode_config.content_type_property =
2278	drm_property_create_enum(dev, flags: 0, name: "content type",
2279	props: drm_content_type_enum_list,
2280	ARRAY_SIZE(drm_content_type_enum_list));
2281
2282	if (dev->mode_config.content_type_property == NULL)
2283	return -ENOMEM;
2284
2285	return 0;
2286	}
2287	EXPORT_SYMBOL(drm_mode_create_content_type_property);
2288
2289	/**
2290	* drm_mode_create_suggested_offset_properties - create suggests offset properties
2291	* @dev: DRM device
2292	*
2293	* Create the suggested x/y offset property for connectors.
2294	*
2295	* Returns:
2296	* 0 on success or a negative error code on failure.
2297	*/
2298	int drm_mode_create_suggested_offset_properties(struct drm_device *dev)
2299	{
2300	if (dev->mode_config.suggested_x_property && dev->mode_config.suggested_y_property)
2301	return 0;
2302
2303	dev->mode_config.suggested_x_property =
2304	drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE, name: "suggested X", min: 0, max: 0xffffffff);
2305
2306	dev->mode_config.suggested_y_property =
2307	drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE, name: "suggested Y", min: 0, max: 0xffffffff);
2308
2309	if (dev->mode_config.suggested_x_property == NULL ||
2310	dev->mode_config.suggested_y_property == NULL)
2311	return -ENOMEM;
2312	return 0;
2313	}
2314	EXPORT_SYMBOL(drm_mode_create_suggested_offset_properties);
2315
2316	/**
2317	* drm_connector_set_path_property - set tile property on connector
2318	* @connector: connector to set property on.
2319	* @path: path to use for property; must not be NULL.
2320	*
2321	* This creates a property to expose to userspace to specify a
2322	* connector path. This is mainly used for DisplayPort MST where
2323	* connectors have a topology and we want to allow userspace to give
2324	* them more meaningful names.
2325	*
2326	* Returns:
2327	* Zero on success, negative errno on failure.
2328	*/
2329	int drm_connector_set_path_property(struct drm_connector *connector,
2330	const char *path)
2331	{
2332	struct drm_device *dev = connector->dev;
2333	int ret;
2334
2335	ret = drm_property_replace_global_blob(dev,
2336	replace: &connector->path_blob_ptr,
2337	strlen(path) + 1,
2338	data: path,
2339	obj_holds_id: &connector->base,
2340	prop_holds_id: dev->mode_config.path_property);
2341	return ret;
2342	}
2343	EXPORT_SYMBOL(drm_connector_set_path_property);
2344
2345	/**
2346	* drm_connector_set_tile_property - set tile property on connector
2347	* @connector: connector to set property on.
2348	*
2349	* This looks up the tile information for a connector, and creates a
2350	* property for userspace to parse if it exists. The property is of
2351	* the form of 8 integers using ':' as a separator.
2352	* This is used for dual port tiled displays with DisplayPort SST
2353	* or DisplayPort MST connectors.
2354	*
2355	* Returns:
2356	* Zero on success, errno on failure.
2357	*/
2358	int drm_connector_set_tile_property(struct drm_connector *connector)
2359	{
2360	struct drm_device *dev = connector->dev;
2361	char tile[256];
2362	int ret;
2363
2364	if (!connector->has_tile) {
2365	ret = drm_property_replace_global_blob(dev,
2366	replace: &connector->tile_blob_ptr,
2367	length: 0,
2368	NULL,
2369	obj_holds_id: &connector->base,
2370	prop_holds_id: dev->mode_config.tile_property);
2371	return ret;
2372	}
2373
2374	snprintf(buf: tile, size: 256, fmt: "%d:%d:%d:%d:%d:%d:%d:%d",
2375	connector->tile_group->id, connector->tile_is_single_monitor,
2376	connector->num_h_tile, connector->num_v_tile,
2377	connector->tile_h_loc, connector->tile_v_loc,
2378	connector->tile_h_size, connector->tile_v_size);
2379
2380	ret = drm_property_replace_global_blob(dev,
2381	replace: &connector->tile_blob_ptr,
2382	strlen(tile) + 1,
2383	data: tile,
2384	obj_holds_id: &connector->base,
2385	prop_holds_id: dev->mode_config.tile_property);
2386	return ret;
2387	}
2388	EXPORT_SYMBOL(drm_connector_set_tile_property);
2389
2390	/**
2391	* drm_connector_set_link_status_property - Set link status property of a connector
2392	* @connector: drm connector
2393	* @link_status: new value of link status property (0: Good, 1: Bad)
2394	*
2395	* In usual working scenario, this link status property will always be set to
2396	* "GOOD". If something fails during or after a mode set, the kernel driver
2397	* may set this link status property to "BAD". The caller then needs to send a
2398	* hotplug uevent for userspace to re-check the valid modes through
2399	* GET_CONNECTOR_IOCTL and retry modeset.
2400	*
2401	* Note: Drivers cannot rely on userspace to support this property and
2402	* issue a modeset. As such, they may choose to handle issues (like
2403	* re-training a link) without userspace's intervention.
2404	*
2405	* The reason for adding this property is to handle link training failures, but
2406	* it is not limited to DP or link training. For example, if we implement
2407	* asynchronous setcrtc, this property can be used to report any failures in that.
2408	*/
2409	void drm_connector_set_link_status_property(struct drm_connector *connector,
2410	uint64_t link_status)
2411	{
2412	struct drm_device *dev = connector->dev;
2413
2414	drm_modeset_lock(lock: &dev->mode_config.connection_mutex, NULL);
2415	connector->state->link_status = link_status;
2416	drm_modeset_unlock(lock: &dev->mode_config.connection_mutex);
2417	}
2418	EXPORT_SYMBOL(drm_connector_set_link_status_property);
2419
2420	/**
2421	* drm_connector_attach_max_bpc_property - attach "max bpc" property
2422	* @connector: connector to attach max bpc property on.
2423	* @min: The minimum bit depth supported by the connector.
2424	* @max: The maximum bit depth supported by the connector.
2425	*
2426	* This is used to add support for limiting the bit depth on a connector.
2427	*
2428	* Returns:
2429	* Zero on success, negative errno on failure.
2430	*/
2431	int drm_connector_attach_max_bpc_property(struct drm_connector *connector,
2432	int min, int max)
2433	{
2434	struct drm_device *dev = connector->dev;
2435	struct drm_property *prop;
2436
2437	prop = connector->max_bpc_property;
2438	if (!prop) {
2439	prop = drm_property_create_range(dev, flags: 0, name: "max bpc", min, max);
2440	if (!prop)
2441	return -ENOMEM;
2442
2443	connector->max_bpc_property = prop;
2444	}
2445
2446	drm_object_attach_property(obj: &connector->base, property: prop, init_val: max);
2447	connector->state->max_requested_bpc = max;
2448	connector->state->max_bpc = max;
2449
2450	return 0;
2451	}
2452	EXPORT_SYMBOL(drm_connector_attach_max_bpc_property);
2453
2454	/**
2455	* drm_connector_attach_hdr_output_metadata_property - attach "HDR_OUTPUT_METADA" property
2456	* @connector: connector to attach the property on.
2457	*
2458	* This is used to allow the userspace to send HDR Metadata to the
2459	* driver.
2460	*
2461	* Returns:
2462	* Zero on success, negative errno on failure.
2463	*/
2464	int drm_connector_attach_hdr_output_metadata_property(struct drm_connector *connector)
2465	{
2466	struct drm_device *dev = connector->dev;
2467	struct drm_property *prop = dev->mode_config.hdr_output_metadata_property;
2468
2469	drm_object_attach_property(obj: &connector->base, property: prop, init_val: 0);
2470
2471	return 0;
2472	}
2473	EXPORT_SYMBOL(drm_connector_attach_hdr_output_metadata_property);
2474
2475	/**
2476	* drm_connector_attach_colorspace_property - attach "Colorspace" property
2477	* @connector: connector to attach the property on.
2478	*
2479	* This is used to allow the userspace to signal the output colorspace
2480	* to the driver.
2481	*
2482	* Returns:
2483	* Zero on success, negative errno on failure.
2484	*/
2485	int drm_connector_attach_colorspace_property(struct drm_connector *connector)
2486	{
2487	struct drm_property *prop = connector->colorspace_property;
2488
2489	drm_object_attach_property(obj: &connector->base, property: prop, init_val: DRM_MODE_COLORIMETRY_DEFAULT);
2490
2491	return 0;
2492	}
2493	EXPORT_SYMBOL(drm_connector_attach_colorspace_property);
2494
2495	/**
2496	* drm_connector_atomic_hdr_metadata_equal - checks if the hdr metadata changed
2497	* @old_state: old connector state to compare
2498	* @new_state: new connector state to compare
2499	*
2500	* This is used by HDR-enabled drivers to test whether the HDR metadata
2501	* have changed between two different connector state (and thus probably
2502	* requires a full blown mode change).
2503	*
2504	* Returns:
2505	* True if the metadata are equal, False otherwise
2506	*/
2507	bool drm_connector_atomic_hdr_metadata_equal(struct drm_connector_state *old_state,
2508	struct drm_connector_state *new_state)
2509	{
2510	struct drm_property_blob *old_blob = old_state->hdr_output_metadata;
2511	struct drm_property_blob *new_blob = new_state->hdr_output_metadata;
2512
2513	if (!old_blob || !new_blob)
2514	return old_blob == new_blob;
2515
2516	if (old_blob->length != new_blob->length)
2517	return false;
2518
2519	return !memcmp(p: old_blob->data, q: new_blob->data, size: old_blob->length);
2520	}
2521	EXPORT_SYMBOL(drm_connector_atomic_hdr_metadata_equal);
2522
2523	/**
2524	* drm_connector_set_vrr_capable_property - sets the variable refresh rate
2525	* capable property for a connector
2526	* @connector: drm connector
2527	* @capable: True if the connector is variable refresh rate capable
2528	*
2529	* Should be used by atomic drivers to update the indicated support for
2530	* variable refresh rate over a connector.
2531	*/
2532	void drm_connector_set_vrr_capable_property(
2533	struct drm_connector *connector, bool capable)
2534	{
2535	if (!connector->vrr_capable_property)
2536	return;
2537
2538	drm_object_property_set_value(obj: &connector->base,
2539	property: connector->vrr_capable_property,
2540	val: capable);
2541	}
2542	EXPORT_SYMBOL(drm_connector_set_vrr_capable_property);
2543
2544	/**
2545	* drm_connector_set_panel_orientation - sets the connector's panel_orientation
2546	* @connector: connector for which to set the panel-orientation property.
2547	* @panel_orientation: drm_panel_orientation value to set
2548	*
2549	* This function sets the connector's panel_orientation and attaches
2550	* a "panel orientation" property to the connector.
2551	*
2552	* Calling this function on a connector where the panel_orientation has
2553	* already been set is a no-op (e.g. the orientation has been overridden with
2554	* a kernel commandline option).
2555	*
2556	* It is allowed to call this function with a panel_orientation of
2557	* DRM_MODE_PANEL_ORIENTATION_UNKNOWN, in which case it is a no-op.
2558	*
2559	* The function shouldn't be called in panel after drm is registered (i.e.
2560	* drm_dev_register() is called in drm).
2561	*
2562	* Returns:
2563	* Zero on success, negative errno on failure.
2564	*/
2565	int drm_connector_set_panel_orientation(
2566	struct drm_connector *connector,
2567	enum drm_panel_orientation panel_orientation)
2568	{
2569	struct drm_device *dev = connector->dev;
2570	struct drm_display_info *info = &connector->display_info;
2571	struct drm_property *prop;
2572
2573	/* Already set? */
2574	if (info->panel_orientation != DRM_MODE_PANEL_ORIENTATION_UNKNOWN)
2575	return 0;
2576
2577	/* Don't attach the property if the orientation is unknown */
2578	if (panel_orientation == DRM_MODE_PANEL_ORIENTATION_UNKNOWN)
2579	return 0;
2580
2581	info->panel_orientation = panel_orientation;
2582
2583	prop = dev->mode_config.panel_orientation_property;
2584	if (!prop) {
2585	prop = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
2586	name: "panel orientation",
2587	props: drm_panel_orientation_enum_list,
2588	ARRAY_SIZE(drm_panel_orientation_enum_list));
2589	if (!prop)
2590	return -ENOMEM;
2591
2592	dev->mode_config.panel_orientation_property = prop;
2593	}
2594
2595	drm_object_attach_property(obj: &connector->base, property: prop,
2596	init_val: info->panel_orientation);
2597	return 0;
2598	}
2599	EXPORT_SYMBOL(drm_connector_set_panel_orientation);
2600
2601	/**
2602	* drm_connector_set_panel_orientation_with_quirk - set the
2603	* connector's panel_orientation after checking for quirks
2604	* @connector: connector for which to init the panel-orientation property.
2605	* @panel_orientation: drm_panel_orientation value to set
2606	* @width: width in pixels of the panel, used for panel quirk detection
2607	* @height: height in pixels of the panel, used for panel quirk detection
2608	*
2609	* Like drm_connector_set_panel_orientation(), but with a check for platform
2610	* specific (e.g. DMI based) quirks overriding the passed in panel_orientation.
2611	*
2612	* Returns:
2613	* Zero on success, negative errno on failure.
2614	*/
2615	int drm_connector_set_panel_orientation_with_quirk(
2616	struct drm_connector *connector,
2617	enum drm_panel_orientation panel_orientation,
2618	int width, int height)
2619	{
2620	int orientation_quirk;
2621
2622	orientation_quirk = drm_get_panel_orientation_quirk(width, height);
2623	if (orientation_quirk != DRM_MODE_PANEL_ORIENTATION_UNKNOWN)
2624	panel_orientation = orientation_quirk;
2625
2626	return drm_connector_set_panel_orientation(connector,
2627	panel_orientation);
2628	}
2629	EXPORT_SYMBOL(drm_connector_set_panel_orientation_with_quirk);
2630
2631	/**
2632	* drm_connector_set_orientation_from_panel -
2633	* set the connector's panel_orientation from panel's callback.
2634	* @connector: connector for which to init the panel-orientation property.
2635	* @panel: panel that can provide orientation information.
2636	*
2637	* Drm drivers should call this function before drm_dev_register().
2638	* Orientation is obtained from panel's .get_orientation() callback.
2639	*
2640	* Returns:
2641	* Zero on success, negative errno on failure.
2642	*/
2643	int drm_connector_set_orientation_from_panel(
2644	struct drm_connector *connector,
2645	struct drm_panel *panel)
2646	{
2647	enum drm_panel_orientation orientation;
2648
2649	if (panel && panel->funcs && panel->funcs->get_orientation)
2650	orientation = panel->funcs->get_orientation(panel);
2651	else
2652	orientation = DRM_MODE_PANEL_ORIENTATION_UNKNOWN;
2653
2654	return drm_connector_set_panel_orientation(connector, orientation);
2655	}
2656	EXPORT_SYMBOL(drm_connector_set_orientation_from_panel);
2657
2658	static const struct drm_prop_enum_list privacy_screen_enum[] = {
2659	{ .type: PRIVACY_SCREEN_DISABLED, .name: "Disabled" },
2660	{ PRIVACY_SCREEN_ENABLED, "Enabled" },
2661	{ PRIVACY_SCREEN_DISABLED_LOCKED, "Disabled-locked" },
2662	{ PRIVACY_SCREEN_ENABLED_LOCKED, "Enabled-locked" },
2663	};
2664
2665	/**
2666	* drm_connector_create_privacy_screen_properties - create the drm connecter's
2667	* privacy-screen properties.
2668	* @connector: connector for which to create the privacy-screen properties
2669	*
2670	* This function creates the "privacy-screen sw-state" and "privacy-screen
2671	* hw-state" properties for the connector. They are not attached.
2672	*/
2673	void
2674	drm_connector_create_privacy_screen_properties(struct drm_connector *connector)
2675	{
2676	if (connector->privacy_screen_sw_state_property)
2677	return;
2678
2679	/* Note sw-state only supports the first 2 values of the enum */
2680	connector->privacy_screen_sw_state_property =
2681	drm_property_create_enum(dev: connector->dev, DRM_MODE_PROP_ENUM,
2682	name: "privacy-screen sw-state",
2683	props: privacy_screen_enum, num_values: 2);
2684
2685	connector->privacy_screen_hw_state_property =
2686	drm_property_create_enum(dev: connector->dev,
2687	DRM_MODE_PROP_IMMUTABLE | DRM_MODE_PROP_ENUM,
2688	name: "privacy-screen hw-state",
2689	props: privacy_screen_enum,
2690	ARRAY_SIZE(privacy_screen_enum));
2691	}
2692	EXPORT_SYMBOL(drm_connector_create_privacy_screen_properties);
2693
2694	/**
2695	* drm_connector_attach_privacy_screen_properties - attach the drm connecter's
2696	* privacy-screen properties.
2697	* @connector: connector on which to attach the privacy-screen properties
2698	*
2699	* This function attaches the "privacy-screen sw-state" and "privacy-screen
2700	* hw-state" properties to the connector. The initial state of both is set
2701	* to "Disabled".
2702	*/
2703	void
2704	drm_connector_attach_privacy_screen_properties(struct drm_connector *connector)
2705	{
2706	if (!connector->privacy_screen_sw_state_property)
2707	return;
2708
2709	drm_object_attach_property(obj: &connector->base,
2710	property: connector->privacy_screen_sw_state_property,
2711	init_val: PRIVACY_SCREEN_DISABLED);
2712
2713	drm_object_attach_property(obj: &connector->base,
2714	property: connector->privacy_screen_hw_state_property,
2715	init_val: PRIVACY_SCREEN_DISABLED);
2716	}
2717	EXPORT_SYMBOL(drm_connector_attach_privacy_screen_properties);
2718
2719	static void drm_connector_update_privacy_screen_properties(
2720	struct drm_connector *connector, bool set_sw_state)
2721	{
2722	enum drm_privacy_screen_status sw_state, hw_state;
2723
2724	drm_privacy_screen_get_state(priv: connector->privacy_screen,
2725	sw_state_ret: &sw_state, hw_state_ret: &hw_state);
2726
2727	if (set_sw_state)
2728	connector->state->privacy_screen_sw_state = sw_state;
2729	drm_object_property_set_value(obj: &connector->base,
2730	property: connector->privacy_screen_hw_state_property, val: hw_state);
2731	}
2732
2733	static int drm_connector_privacy_screen_notifier(
2734	struct notifier_block *nb, unsigned long action, void *data)
2735	{
2736	struct drm_connector *connector =
2737	container_of(nb, struct drm_connector, privacy_screen_notifier);
2738	struct drm_device *dev = connector->dev;
2739
2740	drm_modeset_lock(lock: &dev->mode_config.connection_mutex, NULL);
2741	drm_connector_update_privacy_screen_properties(connector, set_sw_state: true);
2742	drm_modeset_unlock(lock: &dev->mode_config.connection_mutex);
2743
2744	drm_sysfs_connector_property_event(connector,
2745	property: connector->privacy_screen_sw_state_property);
2746	drm_sysfs_connector_property_event(connector,
2747	property: connector->privacy_screen_hw_state_property);
2748
2749	return NOTIFY_DONE;
2750	}
2751
2752	/**
2753	* drm_connector_attach_privacy_screen_provider - attach a privacy-screen to
2754	* the connector
2755	* @connector: connector to attach the privacy-screen to
2756	* @priv: drm_privacy_screen to attach
2757	*
2758	* Create and attach the standard privacy-screen properties and register
2759	* a generic notifier for generating sysfs-connector-status-events
2760	* on external changes to the privacy-screen status.
2761	* This function takes ownership of the passed in drm_privacy_screen and will
2762	* call drm_privacy_screen_put() on it when the connector is destroyed.
2763	*/
2764	void drm_connector_attach_privacy_screen_provider(
2765	struct drm_connector *connector, struct drm_privacy_screen *priv)
2766	{
2767	connector->privacy_screen = priv;
2768	connector->privacy_screen_notifier.notifier_call =
2769	drm_connector_privacy_screen_notifier;
2770
2771	drm_connector_create_privacy_screen_properties(connector);
2772	drm_connector_update_privacy_screen_properties(connector, set_sw_state: true);
2773	drm_connector_attach_privacy_screen_properties(connector);
2774	}
2775	EXPORT_SYMBOL(drm_connector_attach_privacy_screen_provider);
2776
2777	/**
2778	* drm_connector_update_privacy_screen - update connector's privacy-screen sw-state
2779	* @connector_state: connector-state to update the privacy-screen for
2780	*
2781	* This function calls drm_privacy_screen_set_sw_state() on the connector's
2782	* privacy-screen.
2783	*
2784	* If the connector has no privacy-screen, then this is a no-op.
2785	*/
2786	void drm_connector_update_privacy_screen(const struct drm_connector_state *connector_state)
2787	{
2788	struct drm_connector *connector = connector_state->connector;
2789	int ret;
2790
2791	if (!connector->privacy_screen)
2792	return;
2793
2794	ret = drm_privacy_screen_set_sw_state(priv: connector->privacy_screen,
2795	sw_state: connector_state->privacy_screen_sw_state);
2796	if (ret) {
2797	drm_err(connector->dev, "Error updating privacy-screen sw_state\n");
2798	return;
2799	}
2800
2801	/* The hw_state property value may have changed, update it. */
2802	drm_connector_update_privacy_screen_properties(connector, set_sw_state: false);
2803	}
2804	EXPORT_SYMBOL(drm_connector_update_privacy_screen);
2805
2806	int drm_connector_set_obj_prop(struct drm_mode_object *obj,
2807	struct drm_property *property,
2808	uint64_t value)
2809	{
2810	int ret = -EINVAL;
2811	struct drm_connector *connector = obj_to_connector(obj);
2812
2813	/* Do DPMS ourselves */
2814	if (property == connector->dev->mode_config.dpms_property) {
2815	ret = (*connector->funcs->dpms)(connector, (int)value);
2816	} else if (connector->funcs->set_property)
2817	ret = connector->funcs->set_property(connector, property, value);
2818
2819	if (!ret)
2820	drm_object_property_set_value(obj: &connector->base, property, val: value);
2821	return ret;
2822	}
2823
2824	int drm_connector_property_set_ioctl(struct drm_device *dev,
2825	void *data, struct drm_file *file_priv)
2826	{
2827	struct drm_mode_connector_set_property *conn_set_prop = data;
2828	struct drm_mode_obj_set_property obj_set_prop = {
2829	.value = conn_set_prop->value,
2830	.prop_id = conn_set_prop->prop_id,
2831	.obj_id = conn_set_prop->connector_id,
2832	.obj_type = DRM_MODE_OBJECT_CONNECTOR
2833	};
2834
2835	/* It does all the locking and checking we need */
2836	return drm_mode_obj_set_property_ioctl(dev, data: &obj_set_prop, file_priv);
2837	}
2838
2839	static struct drm_encoder *drm_connector_get_encoder(struct drm_connector *connector)
2840	{
2841	/* For atomic drivers only state objects are synchronously updated and
2842	* protected by modeset locks, so check those first.
2843	*/
2844	if (connector->state)
2845	return connector->state->best_encoder;
2846	return connector->encoder;
2847	}
2848
2849	static bool
2850	drm_mode_expose_to_userspace(const struct drm_display_mode *mode,
2851	const struct list_head *modes,
2852	const struct drm_file *file_priv)
2853	{
2854	/*
2855	* If user-space hasn't configured the driver to expose the stereo 3D
2856	* modes, don't expose them.
2857	*/
2858	if (!file_priv->stereo_allowed && drm_mode_is_stereo(mode))
2859	return false;
2860	/*
2861	* If user-space hasn't configured the driver to expose the modes
2862	* with aspect-ratio, don't expose them. However if such a mode
2863	* is unique, let it be exposed, but reset the aspect-ratio flags
2864	* while preparing the list of user-modes.
2865	*/
2866	if (!file_priv->aspect_ratio_allowed) {
2867	const struct drm_display_mode *mode_itr;
2868
2869	list_for_each_entry(mode_itr, modes, head) {
2870	if (mode_itr->expose_to_userspace &&
2871	drm_mode_match(mode1: mode_itr, mode2: mode,
2872	DRM_MODE_MATCH_TIMINGS |
2873	DRM_MODE_MATCH_CLOCK |
2874	DRM_MODE_MATCH_FLAGS |
2875	DRM_MODE_MATCH_3D_FLAGS))
2876	return false;
2877	}
2878	}
2879
2880	return true;
2881	}
2882
2883	int drm_mode_getconnector(struct drm_device *dev, void *data,
2884	struct drm_file *file_priv)
2885	{
2886	struct drm_mode_get_connector *out_resp = data;
2887	struct drm_connector *connector;
2888	struct drm_encoder *encoder;
2889	struct drm_display_mode *mode;
2890	int mode_count = 0;
2891	int encoders_count = 0;
2892	int ret = 0;
2893	int copied = 0;
2894	struct drm_mode_modeinfo u_mode;
2895	struct drm_mode_modeinfo __user *mode_ptr;
2896	uint32_t __user *encoder_ptr;
2897	bool is_current_master;
2898
2899	if (!drm_core_check_feature(dev, feature: DRIVER_MODESET))
2900	return -EOPNOTSUPP;
2901
2902	memset(&u_mode, 0, sizeof(struct drm_mode_modeinfo));
2903
2904	connector = drm_connector_lookup(dev, file_priv, id: out_resp->connector_id);
2905	if (!connector)
2906	return -ENOENT;
2907
2908	encoders_count = hweight32(connector->possible_encoders);
2909
2910	if ((out_resp->count_encoders >= encoders_count) && encoders_count) {
2911	copied = 0;
2912	encoder_ptr = (uint32_t __user *)(unsigned long)(out_resp->encoders_ptr);
2913
2914	drm_connector_for_each_possible_encoder(connector, encoder) {
2915	if (put_user(encoder->base.id, encoder_ptr + copied)) {
2916	ret = -EFAULT;
2917	goto out;
2918	}
2919	copied++;
2920	}
2921	}
2922	out_resp->count_encoders = encoders_count;
2923
2924	out_resp->connector_id = connector->base.id;
2925	out_resp->connector_type = connector->connector_type;
2926	out_resp->connector_type_id = connector->connector_type_id;
2927
2928	is_current_master = drm_is_current_master(fpriv: file_priv);
2929
2930	mutex_lock(&dev->mode_config.mutex);
2931	if (out_resp->count_modes == 0) {
2932	if (is_current_master)
2933	connector->funcs->fill_modes(connector,
2934	dev->mode_config.max_width,
2935	dev->mode_config.max_height);
2936	else
2937	drm_dbg_kms(dev, "User-space requested a forced probe on [CONNECTOR:%d:%s] but is not the DRM master, demoting to read-only probe",
2938	connector->base.id, connector->name);
2939	}
2940
2941	out_resp->mm_width = connector->display_info.width_mm;
2942	out_resp->mm_height = connector->display_info.height_mm;
2943	out_resp->subpixel = connector->display_info.subpixel_order;
2944	out_resp->connection = connector->status;
2945
2946	/* delayed so we get modes regardless of pre-fill_modes state */
2947	list_for_each_entry(mode, &connector->modes, head) {
2948	WARN_ON(mode->expose_to_userspace);
2949
2950	if (drm_mode_expose_to_userspace(mode, modes: &connector->modes,
2951	file_priv)) {
2952	mode->expose_to_userspace = true;
2953	mode_count++;
2954	}
2955	}
2956
2957	/*
2958	* This ioctl is called twice, once to determine how much space is
2959	* needed, and the 2nd time to fill it.
2960	*/
2961	if ((out_resp->count_modes >= mode_count) && mode_count) {
2962	copied = 0;
2963	mode_ptr = (struct drm_mode_modeinfo __user *)(unsigned long)out_resp->modes_ptr;
2964	list_for_each_entry(mode, &connector->modes, head) {
2965	if (!mode->expose_to_userspace)
2966	continue;
2967
2968	/* Clear the tag for the next time around */
2969	mode->expose_to_userspace = false;
2970
2971	drm_mode_convert_to_umode(out: &u_mode, in: mode);
2972	/*
2973	* Reset aspect ratio flags of user-mode, if modes with
2974	* aspect-ratio are not supported.
2975	*/
2976	if (!file_priv->aspect_ratio_allowed)
2977	u_mode.flags &= ~DRM_MODE_FLAG_PIC_AR_MASK;
2978	if (copy_to_user(to: mode_ptr + copied,
2979	from: &u_mode, n: sizeof(u_mode))) {
2980	ret = -EFAULT;
2981
2982	/*
2983	* Clear the tag for the rest of
2984	* the modes for the next time around.
2985	*/
2986	list_for_each_entry_continue(mode, &connector->modes, head)
2987	mode->expose_to_userspace = false;
2988
2989	mutex_unlock(lock: &dev->mode_config.mutex);
2990
2991	goto out;
2992	}
2993	copied++;
2994	}
2995	} else {
2996	/* Clear the tag for the next time around */
2997	list_for_each_entry(mode, &connector->modes, head)
2998	mode->expose_to_userspace = false;
2999	}
3000
3001	out_resp->count_modes = mode_count;
3002	mutex_unlock(lock: &dev->mode_config.mutex);
3003
3004	drm_modeset_lock(lock: &dev->mode_config.connection_mutex, NULL);
3005	encoder = drm_connector_get_encoder(connector);
3006	if (encoder)
3007	out_resp->encoder_id = encoder->base.id;
3008	else
3009	out_resp->encoder_id = 0;
3010
3011	/* Only grab properties after probing, to make sure EDID and other
3012	* properties reflect the latest status.
3013	*/
3014	ret = drm_mode_object_get_properties(obj: &connector->base, atomic: file_priv->atomic,
3015	prop_ptr: (uint32_t __user *)(unsigned long)(out_resp->props_ptr),
3016	prop_values: (uint64_t __user *)(unsigned long)(out_resp->prop_values_ptr),
3017	arg_count_props: &out_resp->count_props);
3018	drm_modeset_unlock(lock: &dev->mode_config.connection_mutex);
3019
3020	out:
3021	drm_connector_put(connector);
3022
3023	return ret;
3024	}
3025
3026	/**
3027	* drm_connector_find_by_fwnode - Find a connector based on the associated fwnode
3028	* @fwnode: fwnode for which to find the matching drm_connector
3029	*
3030	* This functions looks up a drm_connector based on its associated fwnode. When
3031	* a connector is found a reference to the connector is returned. The caller must
3032	* call drm_connector_put() to release this reference when it is done with the
3033	* connector.
3034	*
3035	* Returns: A reference to the found connector or an ERR_PTR().
3036	*/
3037	struct drm_connector *drm_connector_find_by_fwnode(struct fwnode_handle *fwnode)
3038	{
3039	struct drm_connector *connector, *found = ERR_PTR(error: -ENODEV);
3040
3041	if (!fwnode)
3042	return ERR_PTR(error: -ENODEV);
3043
3044	mutex_lock(&connector_list_lock);
3045
3046	list_for_each_entry(connector, &connector_list, global_connector_list_entry) {
3047	if (connector->fwnode == fwnode ||
3048	(connector->fwnode && connector->fwnode->secondary == fwnode)) {
3049	drm_connector_get(connector);
3050	found = connector;
3051	break;
3052	}
3053	}
3054
3055	mutex_unlock(lock: &connector_list_lock);
3056
3057	return found;
3058	}
3059
3060	/**
3061	* drm_connector_oob_hotplug_event - Report out-of-band hotplug event to connector
3062	* @connector_fwnode: fwnode_handle to report the event on
3063	* @status: hot plug detect logical state
3064	*
3065	* On some hardware a hotplug event notification may come from outside the display
3066	* driver / device. An example of this is some USB Type-C setups where the hardware
3067	* muxes the DisplayPort data and aux-lines but does not pass the altmode HPD
3068	* status bit to the GPU's DP HPD pin.
3069	*
3070	* This function can be used to report these out-of-band events after obtaining
3071	* a drm_connector reference through calling drm_connector_find_by_fwnode().
3072	*/
3073	void drm_connector_oob_hotplug_event(struct fwnode_handle *connector_fwnode,
3074	enum drm_connector_status status)
3075	{
3076	struct drm_connector *connector;
3077
3078	connector = drm_connector_find_by_fwnode(fwnode: connector_fwnode);
3079	if (IS_ERR(ptr: connector))
3080	return;
3081
3082	if (connector->funcs->oob_hotplug_event)
3083	connector->funcs->oob_hotplug_event(connector, status);
3084
3085	drm_connector_put(connector);
3086	}
3087	EXPORT_SYMBOL(drm_connector_oob_hotplug_event);
3088
3089
3090	/**
3091	* DOC: Tile group
3092	*
3093	* Tile groups are used to represent tiled monitors with a unique integer
3094	* identifier. Tiled monitors using DisplayID v1.3 have a unique 8-byte handle,
3095	* we store this in a tile group, so we have a common identifier for all tiles
3096	* in a monitor group. The property is called "TILE". Drivers can manage tile
3097	* groups using drm_mode_create_tile_group(), drm_mode_put_tile_group() and
3098	* drm_mode_get_tile_group(). But this is only needed for internal panels where
3099	* the tile group information is exposed through a non-standard way.
3100	*/
3101
3102	static void drm_tile_group_free(struct kref *kref)
3103	{
3104	struct drm_tile_group *tg = container_of(kref, struct drm_tile_group, refcount);
3105	struct drm_device *dev = tg->dev;
3106
3107	mutex_lock(&dev->mode_config.idr_mutex);
3108	idr_remove(&dev->mode_config.tile_idr, id: tg->id);
3109	mutex_unlock(lock: &dev->mode_config.idr_mutex);
3110	kfree(objp: tg);
3111	}
3112
3113	/**
3114	* drm_mode_put_tile_group - drop a reference to a tile group.
3115	* @dev: DRM device
3116	* @tg: tile group to drop reference to.
3117	*
3118	* drop reference to tile group and free if 0.
3119	*/
3120	void drm_mode_put_tile_group(struct drm_device *dev,
3121	struct drm_tile_group *tg)
3122	{
3123	kref_put(kref: &tg->refcount, release: drm_tile_group_free);
3124	}
3125	EXPORT_SYMBOL(drm_mode_put_tile_group);
3126
3127	/**
3128	* drm_mode_get_tile_group - get a reference to an existing tile group
3129	* @dev: DRM device
3130	* @topology: 8-bytes unique per monitor.
3131	*
3132	* Use the unique bytes to get a reference to an existing tile group.
3133	*
3134	* RETURNS:
3135	* tile group or NULL if not found.
3136	*/
3137	struct drm_tile_group *drm_mode_get_tile_group(struct drm_device *dev,
3138	const char topology[8])
3139	{
3140	struct drm_tile_group *tg;
3141	int id;
3142
3143	mutex_lock(&dev->mode_config.idr_mutex);
3144	idr_for_each_entry(&dev->mode_config.tile_idr, tg, id) {
3145	if (!memcmp(p: tg->group_data, q: topology, size: 8)) {
3146	if (!kref_get_unless_zero(kref: &tg->refcount))
3147	tg = NULL;
3148	mutex_unlock(lock: &dev->mode_config.idr_mutex);
3149	return tg;
3150	}
3151	}
3152	mutex_unlock(lock: &dev->mode_config.idr_mutex);
3153	return NULL;
3154	}
3155	EXPORT_SYMBOL(drm_mode_get_tile_group);
3156
3157	/**
3158	* drm_mode_create_tile_group - create a tile group from a displayid description
3159	* @dev: DRM device
3160	* @topology: 8-bytes unique per monitor.
3161	*
3162	* Create a tile group for the unique monitor, and get a unique
3163	* identifier for the tile group.
3164	*
3165	* RETURNS:
3166	* new tile group or NULL.
3167	*/
3168	struct drm_tile_group *drm_mode_create_tile_group(struct drm_device *dev,
3169	const char topology[8])
3170	{
3171	struct drm_tile_group *tg;
3172	int ret;
3173
3174	tg = kzalloc(size: sizeof(*tg), GFP_KERNEL);
3175	if (!tg)
3176	return NULL;
3177
3178	kref_init(kref: &tg->refcount);
3179	memcpy(tg->group_data, topology, 8);
3180	tg->dev = dev;
3181
3182	mutex_lock(&dev->mode_config.idr_mutex);
3183	ret = idr_alloc(&dev->mode_config.tile_idr, ptr: tg, start: 1, end: 0, GFP_KERNEL);
3184	if (ret >= 0) {
3185	tg->id = ret;
3186	} else {
3187	kfree(objp: tg);
3188	tg = NULL;
3189	}
3190
3191	mutex_unlock(lock: &dev->mode_config.idr_mutex);
3192	return tg;
3193	}
3194	EXPORT_SYMBOL(drm_mode_create_tile_group);
3195