Lines Matching defs:connector
58 * objects and initialized by setting the following fields. The connector is
60 * &struct drm_connector_funcs and a connector type, and then exposed to
64 * connectors to encoders 1:1, the connector should be attached at
77 * Global connector list for drm_connector_find_by_fwnode().
78 * Note drm_connector_[un]register() first take connector->lock and then
134 * drm_get_connector_type_name - return a string for connector type
135 * @type: The connector type (DRM_MODE_CONNECTOR_*)
137 * Returns: the name of the connector type, or NULL if the type is not valid.
150 * @connector: connector to query
152 * The kernel supports per-connector configuration of its consoles through
155 * particular connector. This is typically only used during the early fbdev
158 static void drm_connector_get_cmdline_mode(struct drm_connector *connector)
160 struct drm_cmdline_mode *mode = &connector->cmdline_mode;
163 option = video_get_options(connector->name);
168 connector,
173 DRM_INFO("forcing %s connector %s\n", connector->name,
175 connector->force = mode->force;
179 DRM_INFO("cmdline forces connector %s panel_orientation to %d\n",
180 connector->name, mode->panel_orientation);
181 drm_connector_set_panel_orientation(connector,
185 DRM_DEBUG_KMS("cmdline mode for connector %s %s %dx%d@%dHz%s%s%s\n",
186 connector->name, mode->name,
196 struct drm_connector *connector =
198 struct drm_device *dev = connector->dev;
200 drm_mode_object_unregister(dev, &connector->base);
201 connector->funcs->destroy(connector);
206 struct drm_connector *connector, *n;
217 llist_for_each_entry_safe(connector, n, freed, free_node) {
218 drm_mode_object_unregister(dev, &connector->base);
219 connector->funcs->destroy(connector);
224 struct drm_connector *connector,
238 ret = __drm_mode_object_add(dev, &connector->base,
244 connector->base.properties = &connector->properties;
245 connector->dev = dev;
246 connector->funcs = funcs;
248 /* connector index is used with 32bit bitmasks */
251 DRM_DEBUG_KMS("Failed to allocate %s connector index: %d\n",
256 connector->index = ret;
259 connector->connector_type = connector_type;
260 connector->connector_type_id =
262 if (connector->connector_type_id < 0) {
263 ret = connector->connector_type_id;
266 connector->name =
269 connector->connector_type_id);
270 if (!connector->name) {
276 connector->ddc = ddc;
278 INIT_LIST_HEAD(&connector->head);
279 INIT_LIST_HEAD(&connector->global_connector_list_entry);
280 INIT_LIST_HEAD(&connector->probed_modes);
281 INIT_LIST_HEAD(&connector->modes);
282 mutex_init(&connector->mutex);
283 mutex_init(&connector->cec.mutex);
284 mutex_init(&connector->eld_mutex);
285 mutex_init(&connector->edid_override_mutex);
286 mutex_init(&connector->hdmi.infoframes.lock);
287 mutex_init(&connector->hdmi_audio.lock);
288 connector->edid_blob_ptr = NULL;
289 connector->epoch_counter = 0;
290 connector->tile_blob_ptr = NULL;
291 connector->status = connector_status_unknown;
292 connector->display_info.panel_orientation =
295 drm_connector_get_cmdline_mode(connector);
299 drm_connector_attach_edid_property(connector);
301 drm_object_attach_property(&connector->base,
304 drm_object_attach_property(&connector->base,
308 drm_object_attach_property(&connector->base,
311 drm_object_attach_property(&connector->base,
316 drm_object_attach_property(&connector->base, config->prop_crtc_id, 0);
319 connector->debugfs_entry = NULL;
322 ida_free(connector_ida, connector->connector_type_id);
325 ida_free(&config->connector_ida, connector->index);
328 drm_mode_object_unregister(dev, &connector->base);
333 static void drm_connector_add(struct drm_connector *connector)
335 struct drm_device *dev = connector->dev;
338 if (drm_WARN_ON(dev, !list_empty(&connector->head)))
342 list_add_tail(&connector->head, &config->connector_list);
347 static void drm_connector_remove(struct drm_connector *connector)
349 struct drm_device *dev = connector->dev;
353 * before the connector is registered and added to the list.
355 if (list_empty(&connector->head))
359 list_del_init(&connector->head);
365 struct drm_connector *connector,
372 ret = drm_connector_init_only(dev, connector, funcs, connector_type, ddc);
376 drm_connector_add(connector);
382 * drm_connector_init - Init a preallocated connector
384 * @connector: the connector to init
385 * @funcs: callbacks for this connector
386 * @connector_type: user visible type of the connector
388 * Initialises a preallocated connector. Connectors should be
389 * subclassed as part of driver connector objects.
392 * should call drm_connector_cleanup() and free the connector structure.
393 * The connector structure should not be allocated with devm_kzalloc().
403 struct drm_connector *connector,
410 return drm_connector_init_and_add(dev, connector, funcs, connector_type, NULL);
415 * drm_connector_dynamic_init - Init a preallocated dynamic connector
417 * @connector: the connector to init
418 * @funcs: callbacks for this connector
419 * @connector_type: user visible type of the connector
422 * Initialises a preallocated dynamic connector. Connectors should be
423 * subclassed as part of driver connector objects. The connector
434 * To remove the connector the driver must call drm_connector_unregister()
437 * drm_connector_cleanup() and free the connector structure.
443 struct drm_connector *connector,
451 return drm_connector_init_only(dev, connector, funcs, connector_type, ddc);
456 * drm_connector_init_with_ddc - Init a preallocated connector
458 * @connector: the connector to init
459 * @funcs: callbacks for this connector
460 * @connector_type: user visible type of the connector
463 * Initialises a preallocated connector. Connectors should be
464 * subclassed as part of driver connector objects.
467 * should call drm_connector_cleanup() and free the connector structure.
468 * The connector structure should not be allocated with devm_kzalloc().
470 * Ensures that the ddc field of the connector is correctly set.
480 struct drm_connector *connector,
488 return drm_connector_init_and_add(dev, connector, funcs, connector_type, ddc);
495 struct drm_connector *connector = ptr;
497 drm_connector_cleanup(connector);
501 * drmm_connector_init - Init a preallocated connector
503 * @connector: the connector to init
504 * @funcs: callbacks for this connector
505 * @connector_type: user visible type of the connector
508 * Initialises a preallocated connector. Connectors should be
509 * subclassed as part of driver connector objects.
514 * The connector structure should be allocated with drmm_kzalloc().
522 struct drm_connector *connector,
532 ret = drm_connector_init_and_add(dev, connector, funcs, connector_type, ddc);
537 connector);
546 * drmm_connector_hdmi_init - Init a preallocated HDMI connector
548 * @connector: A pointer to the HDMI connector to init
551 * @funcs: callbacks for this connector
552 * @hdmi_funcs: HDMI-related callbacks for this connector
553 * @connector_type: user visible type of the connector
556 * @max_bpc: Maximum bits per char the HDMI connector supports
558 * Initialises a preallocated HDMI connector. Connectors can be
559 * subclassed as part of driver connector objects.
564 * The connector structure should be allocated with drmm_kzalloc().
572 struct drm_connector *connector,
597 if (connector->ycbcr_420_allowed != !!(supported_formats & BIT(HDMI_COLORSPACE_YUV420)))
603 ret = drmm_connector_init(dev, connector, funcs, connector_type, ddc);
607 connector->hdmi.supported_formats = supported_formats;
608 strtomem_pad(connector->hdmi.vendor, vendor, 0);
609 strtomem_pad(connector->hdmi.product, product, 0);
613 * connector to have a state.
615 if (connector->funcs->reset)
616 connector->funcs->reset(connector);
618 drm_connector_attach_max_bpc_property(connector, 8, max_bpc);
619 connector->max_bpc = max_bpc;
622 drm_connector_attach_hdr_output_metadata_property(connector);
624 connector->hdmi.funcs = hdmi_funcs;
632 * @connector: the connector
634 * Some connector types like DRM_MODE_CONNECTOR_VIRTUAL do not get a
638 void drm_connector_attach_edid_property(struct drm_connector *connector)
640 struct drm_mode_config *config = &connector->dev->mode_config;
642 drm_object_attach_property(&connector->base,
649 * drm_connector_attach_encoder - attach a connector to an encoder
650 * @connector: connector to attach
651 * @encoder: encoder to attach @connector to
653 * This function links up a connector to an encoder. Note that the routing
660 int drm_connector_attach_encoder(struct drm_connector *connector,
665 * of connector to encoder in simple connector/encoder devices using a
666 * direct assignment of connector->encoder = encoder. This connection
674 if (WARN_ON(connector->encoder))
677 connector->possible_encoders |= drm_encoder_mask(encoder);
684 * drm_connector_has_possible_encoder - check if the connector and encoder are
686 * @connector: the connector
690 * True if @encoder is one of the possible encoders for @connector.
692 bool drm_connector_has_possible_encoder(struct drm_connector *connector,
695 return connector->possible_encoders & drm_encoder_mask(encoder);
699 static void drm_mode_remove(struct drm_connector *connector,
703 drm_mode_destroy(connector->dev, mode);
708 * @connector: connector undergoing CEC operation
710 * Invalidated CEC physical address set for this DRM connector.
712 void drm_connector_cec_phys_addr_invalidate(struct drm_connector *connector)
714 mutex_lock(&connector->cec.mutex);
716 if (connector->cec.funcs &&
717 connector->cec.funcs->phys_addr_invalidate)
718 connector->cec.funcs->phys_addr_invalidate(connector);
720 mutex_unlock(&connector->cec.mutex);
726 * @connector: connector undergoing CEC operation
728 * Propagate CEC physical address from the display_info to this DRM connector.
730 void drm_connector_cec_phys_addr_set(struct drm_connector *connector)
734 mutex_lock(&connector->cec.mutex);
736 addr = connector->display_info.source_physical_address;
738 if (connector->cec.funcs &&
739 connector->cec.funcs->phys_addr_set)
740 connector->cec.funcs->phys_addr_set(connector, addr);
742 mutex_unlock(&connector->cec.mutex);
747 * drm_connector_cleanup - cleans up an initialised connector
748 * @connector: connector to cleanup
750 * Cleans up the connector but doesn't free the object.
752 void drm_connector_cleanup(struct drm_connector *connector)
754 struct drm_device *dev = connector->dev;
757 /* The connector should have been removed from userspace long before
760 if (WARN_ON(connector->registration_state ==
762 drm_connector_unregister(connector);
764 platform_device_unregister(connector->hdmi_audio.codec_pdev);
766 if (connector->privacy_screen) {
767 drm_privacy_screen_put(connector->privacy_screen);
768 connector->privacy_screen = NULL;
771 if (connector->tile_group) {
772 drm_mode_put_tile_group(dev, connector->tile_group);
773 connector->tile_group = NULL;
776 list_for_each_entry_safe(mode, t, &connector->probed_modes, head)
777 drm_mode_remove(connector, mode);
779 list_for_each_entry_safe(mode, t, &connector->modes, head)
780 drm_mode_remove(connector, mode);
782 ida_free(&drm_connector_enum_list[connector->connector_type].ida,
783 connector->connector_type_id);
785 ida_free(&dev->mode_config.connector_ida, connector->index);
787 kfree(connector->display_info.bus_formats);
788 kfree(connector->display_info.vics);
789 drm_mode_object_unregister(dev, &connector->base);
790 kfree(connector->name);
791 connector->name = NULL;
792 fwnode_handle_put(connector->fwnode);
793 connector->fwnode = NULL;
795 drm_connector_remove(connector);
797 WARN_ON(connector->state && !connector->funcs->atomic_destroy_state);
798 if (connector->state && connector->funcs->atomic_destroy_state)
799 connector->funcs->atomic_destroy_state(connector,
800 connector->state);
802 mutex_destroy(&connector->hdmi_audio.lock);
803 mutex_destroy(&connector->hdmi.infoframes.lock);
804 mutex_destroy(&connector->mutex);
806 memset(connector, 0, sizeof(*connector));
814 * drm_connector_register - register a connector
815 * @connector: the connector to register
817 * Register userspace interfaces for a connector. Drivers shouldn't call this
822 * When the connector is no longer available, callers must call
831 int drm_connector_register(struct drm_connector *connector)
835 if (!connector->dev->registered)
838 mutex_lock(&connector->mutex);
839 if (connector->registration_state != DRM_CONNECTOR_INITIALIZING)
842 ret = drm_sysfs_connector_add(connector);
846 drm_debugfs_connector_add(connector);
848 if (connector->funcs->late_register) {
849 ret = connector->funcs->late_register(connector);
854 ret = drm_sysfs_connector_add_late(connector);
858 drm_mode_object_register(connector->dev, &connector->base);
860 connector->registration_state = DRM_CONNECTOR_REGISTERED;
862 /* Let userspace know we have a new connector */
863 drm_sysfs_connector_hotplug_event(connector);
865 if (connector->privacy_screen)
866 drm_privacy_screen_register_notifier(connector->privacy_screen,
867 &connector->privacy_screen_notifier);
870 list_add_tail(&connector->global_connector_list_entry, &connector_list);
875 if (connector->funcs->early_unregister)
876 connector->funcs->early_unregister(connector);
878 drm_debugfs_connector_remove(connector);
879 drm_sysfs_connector_remove(connector);
881 mutex_unlock(&connector->mutex);
887 * drm_connector_dynamic_register - register a dynamic connector
888 * @connector: the connector to register
890 * Register userspace interfaces for a connector. Only call this for connectors
894 * When the connector is no longer available the driver must call
900 int drm_connector_dynamic_register(struct drm_connector *connector)
902 /* Was the connector inited already? */
903 if (WARN_ON(!(connector->funcs && connector->funcs->destroy)))
906 drm_connector_add(connector);
908 return drm_connector_register(connector);
913 * drm_connector_unregister - unregister a connector
914 * @connector: the connector to unregister
916 * Unregister userspace interfaces for a connector. Drivers should call this
925 void drm_connector_unregister(struct drm_connector *connector)
927 mutex_lock(&connector->mutex);
928 if (connector->registration_state != DRM_CONNECTOR_REGISTERED) {
929 mutex_unlock(&connector->mutex);
934 list_del_init(&connector->global_connector_list_entry);
937 if (connector->privacy_screen)
939 connector->privacy_screen,
940 &connector->privacy_screen_notifier);
942 drm_sysfs_connector_remove_early(connector);
944 if (connector->funcs->early_unregister)
945 connector->funcs->early_unregister(connector);
947 drm_debugfs_connector_remove(connector);
948 drm_sysfs_connector_remove(connector);
950 connector->registration_state = DRM_CONNECTOR_UNREGISTERED;
951 mutex_unlock(&connector->mutex);
957 struct drm_connector *connector;
961 drm_for_each_connector_iter(connector, &conn_iter)
962 drm_connector_unregister(connector);
968 struct drm_connector *connector;
973 drm_for_each_connector_iter(connector, &conn_iter) {
974 ret = drm_connector_register(connector);
986 * drm_get_connector_status_name - return a string for connector status
987 * @status: connector status to compute name of
992 * Returns: connector status string
1006 * drm_get_connector_force_name - return a string for connector force
1007 * @force: connector force to get name of
1053 * Extra-safe connector put function that works in any context. Should only be
1055 * actually release the connector when dropping our final reference.
1072 * drm_connector_list_iter_next - return next connector
1075 * Returns: the next connector for @iter, or NULL when the list walk has
1098 /* loop until it's not a zombie connector */
1207 /* Optional connector properties. */
1406 * drm_hdmi_connector_get_broadcast_rgb_name - Return a string for HDMI connector RGB broadcast selection
1430 * drm_hdmi_connector_get_output_format_name() - Return a string for HDMI connector output format
1447 * DOC: standard connector properties
1464 * Legacy property for setting the power state of the connector. For atomic
1467 * connector is linked to. Drivers should never set this property directly,
1488 * connector is connected to a CRTC. In atomic the DRM core enforces that
1495 * Summarizing: Only set "DPMS" when the connector is known to be enabled,
1507 * parent connector and ``<ports>`` is a hyphen-separated list of DP MST
1511 * Connector tile group property to indicate how a set of DRM connector
1532 * "GOOD" to re-enable the connector.
1538 * When user-space performs an atomic commit on a connector with a "BAD"
1587 * - Kernel sends uevent with the connector id and property id through
1700 * property to the connector during initialization.
1705 * Mode object ID of the &drm_crtc this connector should be connected to.
1746 * connector subtypes. Enum values more or less match with those from main
1747 * connector types.
1793 * Add margins to the connector's viewport. This is typically used to
1863 * drm_mode_create_dvi_i_properties - create DVI-I specific connector properties
1866 * Called by a driver the first time a DVI-I connector is made.
1897 * @connector: drm_connector to attach property
1899 * Called by a driver when DP connector is created.
1901 void drm_connector_attach_dp_subconnector_property(struct drm_connector *connector)
1903 struct drm_mode_config *mode_config = &connector->dev->mode_config;
1907 drm_property_create_enum(connector->dev,
1913 drm_object_attach_property(&connector->base,
1920 * DOC: HDMI connector properties
1930 * The CRTC attached to the connector must be configured by user-space to
1994 * Indicates the TV Mode used on an analog TV connector. The value
2047 * @connector: connector to attach content type property on.
2049 * Called by a driver the first time a HDMI connector is made.
2053 int drm_connector_attach_content_type_property(struct drm_connector *connector)
2055 if (!drm_mode_create_content_type_property(connector->dev))
2056 drm_object_attach_property(&connector->base,
2057 connector->dev->mode_config.content_type_property,
2064 * drm_connector_attach_tv_margin_properties - attach TV connector margin
2066 * @connector: DRM connector
2068 * Called by a driver when it needs to attach TV margin props to a connector.
2071 void drm_connector_attach_tv_margin_properties(struct drm_connector *connector)
2073 struct drm_device *dev = connector->dev;
2075 drm_object_attach_property(&connector->base,
2078 drm_object_attach_property(&connector->base,
2081 drm_object_attach_property(&connector->base,
2084 drm_object_attach_property(&connector->base,
2091 * drm_mode_create_tv_margin_properties - create TV connector margin properties
2094 * Called by a driver's HDMI connector initialization routine, this function
2096 * function for an SDTV connector, it's already called from
2132 * drm_mode_create_tv_properties_legacy - create TV specific connector properties
2138 * the TV specific connector properties for a given device. Caller is
2142 * NOTE: This functions registers the deprecated "mode" connector
2161 * Basic connector properties
2236 * drm_mode_create_tv_properties - create TV specific connector properties
2241 * the TV specific connector properties for a given device.
2363 * from the minimum supported variable refresh rate for the connector.
2372 * @connector: connector to create the vrr_capable property on.
2375 * variable refresh rate capability for a connector.
2381 struct drm_connector *connector)
2383 struct drm_device *dev = connector->dev;
2386 if (!connector->vrr_capable_property) {
2392 connector->vrr_capable_property = prop;
2393 drm_object_attach_property(&connector->base, prop, 0);
2402 * @connector: connector to attach scaling mode property on.
2414 int drm_connector_attach_scaling_mode_property(struct drm_connector *connector,
2417 struct drm_device *dev = connector->dev;
2451 drm_object_attach_property(&connector->base,
2454 connector->scaling_mode_property = scaling_mode_property;
2488 * DOC: standard connector properties
2558 * drm_mode_create_hdmi_colorspace_property() is used for HDMI connector and
2559 * drm_mode_create_dp_colorspace_property() is used for DP connector.
2562 static int drm_mode_create_colorspace_property(struct drm_connector *connector,
2565 struct drm_device *dev = connector->dev;
2570 if (connector->colorspace_property)
2575 connector->base.id, connector->name);
2581 connector->base.id, connector->name);
2595 connector->colorspace_property =
2600 if (!connector->colorspace_property)
2608 * @connector: connector to create the Colorspace property on.
2617 int drm_mode_create_hdmi_colorspace_property(struct drm_connector *connector,
2627 return drm_mode_create_colorspace_property(connector, colorspaces);
2633 * @connector: connector to create the Colorspace property on.
2642 int drm_mode_create_dp_colorspace_property(struct drm_connector *connector,
2652 return drm_mode_create_colorspace_property(connector, colorspaces);
2711 * drm_connector_set_path_property - set tile property on connector
2712 * @connector: connector to set property on.
2716 * connector path. This is mainly used for DisplayPort MST where
2723 int drm_connector_set_path_property(struct drm_connector *connector,
2726 struct drm_device *dev = connector->dev;
2730 &connector->path_blob_ptr,
2733 &connector->base,
2740 * drm_connector_set_tile_property - set tile property on connector
2741 * @connector: connector to set property on.
2743 * This looks up the tile information for a connector, and creates a
2752 int drm_connector_set_tile_property(struct drm_connector *connector)
2754 struct drm_device *dev = connector->dev;
2758 if (!connector->has_tile) {
2760 &connector->tile_blob_ptr,
2763 &connector->base,
2769 connector->tile_group->id, connector->tile_is_single_monitor,
2770 connector->num_h_tile, connector->num_v_tile,
2771 connector->tile_h_loc, connector->tile_v_loc,
2772 connector->tile_h_size, connector->tile_v_size);
2775 &connector->tile_blob_ptr,
2778 &connector->base,
2785 * drm_connector_set_link_status_property - Set link status property of a connector
2786 * @connector: drm connector
2803 void drm_connector_set_link_status_property(struct drm_connector *connector,
2806 struct drm_device *dev = connector->dev;
2809 connector->state->link_status = link_status;
2816 * @connector: connector to attach max bpc property on.
2817 * @min: The minimum bit depth supported by the connector.
2818 * @max: The maximum bit depth supported by the connector.
2820 * This is used to add support for limiting the bit depth on a connector.
2825 int drm_connector_attach_max_bpc_property(struct drm_connector *connector,
2828 struct drm_device *dev = connector->dev;
2831 prop = connector->max_bpc_property;
2837 connector->max_bpc_property = prop;
2840 drm_object_attach_property(&connector->base, prop, max);
2841 connector->state->max_requested_bpc = max;
2842 connector->state->max_bpc = max;
2850 * @connector: connector to attach the property on.
2858 int drm_connector_attach_hdr_output_metadata_property(struct drm_connector *connector)
2860 struct drm_device *dev = connector->dev;
2863 drm_object_attach_property(&connector->base, prop, 0);
2871 * @connector: connector to attach the property on.
2873 * This is used to add support for forcing the RGB range on a connector
2878 int drm_connector_attach_broadcast_rgb_property(struct drm_connector *connector)
2880 struct drm_device *dev = connector->dev;
2883 prop = connector->broadcast_rgb_property;
2892 connector->broadcast_rgb_property = prop;
2895 drm_object_attach_property(&connector->base, prop,
2904 * @connector: connector to attach the property on.
2912 int drm_connector_attach_colorspace_property(struct drm_connector *connector)
2914 struct drm_property *prop = connector->colorspace_property;
2916 drm_object_attach_property(&connector->base, prop, DRM_MODE_COLORIMETRY_DEFAULT);
2924 * @old_state: old connector state to compare
2925 * @new_state: new connector state to compare
2928 * have changed between two different connector state (and thus probably
2952 * capable property for a connector
2953 * @connector: drm connector
2954 * @capable: True if the connector is variable refresh rate capable
2957 * variable refresh rate over a connector.
2960 struct drm_connector *connector, bool capable)
2962 if (!connector->vrr_capable_property)
2965 drm_object_property_set_value(&connector->base,
2966 connector->vrr_capable_property,
2972 * drm_connector_set_panel_orientation - sets the connector's panel_orientation
2973 * @connector: connector for which to set the panel-orientation property.
2976 * This function sets the connector's panel_orientation and attaches
2977 * a "panel orientation" property to the connector.
2979 * Calling this function on a connector where the panel_orientation has
2993 struct drm_connector *connector,
2996 struct drm_device *dev = connector->dev;
2997 struct drm_display_info *info = &connector->display_info;
3022 drm_object_attach_property(&connector->base, prop,
3030 * connector's panel_orientation after checking for quirks
3031 * @connector: connector for which to init the panel-orientation property.
3043 struct drm_connector *connector,
3053 return drm_connector_set_panel_orientation(connector,
3060 * set the connector's panel_orientation from panel's callback.
3061 * @connector: connector for which to init the panel-orientation property.
3071 struct drm_connector *connector,
3081 return drm_connector_set_panel_orientation(connector, orientation);
3095 * @connector: connector for which to create the privacy-screen properties
3098 * hw-state" properties for the connector. They are not attached.
3101 drm_connector_create_privacy_screen_properties(struct drm_connector *connector)
3103 if (connector->privacy_screen_sw_state_property)
3107 connector->privacy_screen_sw_state_property =
3108 drm_property_create_enum(connector->dev, DRM_MODE_PROP_ENUM,
3112 connector->privacy_screen_hw_state_property =
3113 drm_property_create_enum(connector->dev,
3124 * @connector: connector on which to attach the privacy-screen properties
3127 * hw-state" properties to the connector. The initial state of both is set
3131 drm_connector_attach_privacy_screen_properties(struct drm_connector *connector)
3133 if (!connector->privacy_screen_sw_state_property)
3136 drm_object_attach_property(&connector->base,
3137 connector->privacy_screen_sw_state_property,
3140 drm_object_attach_property(&connector->base,
3141 connector->privacy_screen_hw_state_property,
3147 struct drm_connector *connector, bool set_sw_state)
3151 drm_privacy_screen_get_state(connector->privacy_screen,
3155 connector->state->privacy_screen_sw_state = sw_state;
3156 drm_object_property_set_value(&connector->base,
3157 connector->privacy_screen_hw_state_property, hw_state);
3163 struct drm_connector *connector =
3165 struct drm_device *dev = connector->dev;
3168 drm_connector_update_privacy_screen_properties(connector, true);
3171 drm_sysfs_connector_property_event(connector,
3172 connector->privacy_screen_sw_state_property);
3173 drm_sysfs_connector_property_event(connector,
3174 connector->privacy_screen_hw_state_property);
3181 * the connector
3182 * @connector: connector to attach the privacy-screen to
3186 * a generic notifier for generating sysfs-connector-status-events
3189 * call drm_privacy_screen_put() on it when the connector is destroyed.
3192 struct drm_connector *connector, struct drm_privacy_screen *priv)
3194 connector->privacy_screen = priv;
3195 connector->privacy_screen_notifier.notifier_call =
3198 drm_connector_create_privacy_screen_properties(connector);
3199 drm_connector_update_privacy_screen_properties(connector, true);
3200 drm_connector_attach_privacy_screen_properties(connector);
3205 * drm_connector_update_privacy_screen - update connector's privacy-screen sw-state
3206 * @connector_state: connector-state to update the privacy-screen for
3208 * This function calls drm_privacy_screen_set_sw_state() on the connector's
3211 * If the connector has no privacy-screen, then this is a no-op.
3215 struct drm_connector *connector = connector_state->connector;
3218 if (!connector->privacy_screen)
3221 ret = drm_privacy_screen_set_sw_state(connector->privacy_screen,
3224 drm_err(connector->dev, "Error updating privacy-screen sw_state\n");
3229 drm_connector_update_privacy_screen_properties(connector, false);
3238 struct drm_connector *connector = obj_to_connector(obj);
3241 if (property == connector->dev->mode_config.dpms_property) {
3242 ret = (*connector->funcs->dpms)(connector, (int)value);
3243 } else if (connector->funcs->set_property)
3244 ret = connector->funcs->set_property(connector, property, value);
3247 drm_object_property_set_value(&connector->base, property, value);
3266 static struct drm_encoder *drm_connector_get_encoder(struct drm_connector *connector)
3271 if (connector->state)
3272 return connector->state->best_encoder;
3273 return connector->encoder;
3314 struct drm_connector *connector;
3331 connector = drm_connector_lookup(dev, file_priv, out_resp->connector_id);
3332 if (!connector)
3335 encoders_count = hweight32(connector->possible_encoders);
3341 drm_connector_for_each_possible_encoder(connector, encoder) {
3351 out_resp->connector_id = connector->base.id;
3352 out_resp->connector_type = connector->connector_type;
3353 out_resp->connector_type_id = connector->connector_type_id;
3360 connector->funcs->fill_modes(connector,
3365 connector->base.id, connector->name);
3368 out_resp->mm_width = connector->display_info.width_mm;
3369 out_resp->mm_height = connector->display_info.height_mm;
3370 out_resp->subpixel = connector->display_info.subpixel_order;
3371 out_resp->connection = connector->status;
3374 list_for_each_entry(mode, &connector->modes, head) {
3377 if (drm_mode_expose_to_userspace(mode, &connector->modes,
3391 list_for_each_entry(mode, &connector->modes, head) {
3413 list_for_each_entry_continue(mode, &connector->modes, head)
3424 list_for_each_entry(mode, &connector->modes, head)
3432 encoder = drm_connector_get_encoder(connector);
3441 ret = drm_mode_object_get_properties(&connector->base, file_priv->atomic,
3448 drm_connector_put(connector);
3454 * drm_connector_find_by_fwnode - Find a connector based on the associated fwnode
3458 * a connector is found a reference to the connector is returned. The caller must
3460 * connector.
3462 * Returns: A reference to the found connector or an ERR_PTR().
3466 struct drm_connector *connector, *found = ERR_PTR(-ENODEV);
3473 list_for_each_entry(connector, &connector_list, global_connector_list_entry) {
3474 if (connector->fwnode == fwnode ||
3475 (connector->fwnode && connector->fwnode->secondary == fwnode)) {
3476 drm_connector_get(connector);
3477 found = connector;
3488 * drm_connector_oob_hotplug_event - Report out-of-band hotplug event to connector
3503 struct drm_connector *connector;
3505 connector = drm_connector_find_by_fwnode(connector_fwnode);
3506 if (IS_ERR(connector))
3509 if (connector->funcs->oob_hotplug_event)
3510 connector->funcs->oob_hotplug_event(connector, status);
3512 drm_connector_put(connector);