[PATCH v2 02/27] drm/connector: add vrr_display_mode connector property

[Nicolas Frattaroli <nicolas.frattaroli@collabora.com>]

It's common to want to keep a VRR-capable display in a specific VRR mode
regardless of whether a CRTC uses VRR presentation, to avoid screen
blanking during switching of the VRR mode. On the other hand, it's also
not always desired to keep a display in VRR mode even when nothing does
VRR presentation, for example in battery-powered systems.

To let userspace control this explicitly, instead of relying on implicit
driver policy, introduce a new connector KMS property: vrr_display_mode.

It defaults to "Game", which matches the behaviour of dGPU drivers,
wherein a VRR-capable display will always be in Game mode. However, it
also has an "Off" mode, with which userspace can explicitly request that
VRR be disabled on the display sink.

The associated connector state member uses an u8 rather than the enum
type in order to fit into the existing 2 bytes of padding there. Once
the kernel mandates compiler versions that have backported C23 features,
the enum can be given an explicit small backing type and the member can
be changed to use the enum type.

Signed-off-by: Nicolas Frattaroli <nicolas.frattaroli@collabora.com>
---
 drivers/gpu/drm/drm_atomic_uapi.c |  4 ++
 drivers/gpu/drm/drm_connector.c   | 77 +++++++++++++++++++++++++++++++++++++++
 include/drm/drm_connector.h       | 29 +++++++++++++++
 3 files changed, 110 insertions(+)

diff --git a/drivers/gpu/drm/drm_atomic_uapi.c b/drivers/gpu/drm/drm_atomic_uapi.c
index 1eebcf6f5e05..127bdd77802b 100644
--- a/drivers/gpu/drm/drm_atomic_uapi.c
+++ b/drivers/gpu/drm/drm_atomic_uapi.c
@@ -969,6 +969,8 @@ static int drm_atomic_connector_set_property(struct drm_connector *connector,
 		state->hdmi.broadcast_rgb = val;
 	} else if (property == connector->color_format_property) {
 		state->color_format = val;
+	} else if (property == connector->vrr_display_mode_property) {
+		state->vrr_display_mode = val;
 	} else if (connector->funcs->atomic_set_property) {
 		return connector->funcs->atomic_set_property(connector,
 				state, property, val);
@@ -1056,6 +1058,8 @@ drm_atomic_connector_get_property(struct drm_connector *connector,
 		*val = state->hdmi.broadcast_rgb;
 	} else if (property == connector->color_format_property) {
 		*val = state->color_format;
+	} else if (property == connector->vrr_display_mode_property) {
+		*val = state->vrr_display_mode;
 	} else if (connector->funcs->atomic_get_property) {
 		return connector->funcs->atomic_get_property(connector,
 				state, property, val);
diff --git a/drivers/gpu/drm/drm_connector.c b/drivers/gpu/drm/drm_connector.c
index 893716a9e489..65c14b6e47a6 100644
--- a/drivers/gpu/drm/drm_connector.c
+++ b/drivers/gpu/drm/drm_connector.c
@@ -1434,6 +1434,12 @@ static const struct drm_prop_enum_list drm_tv_mode_enum_list[] = {
 };
 DRM_ENUM_NAME_FN(drm_get_tv_mode_name, drm_tv_mode_enum_list)
 
+static const struct drm_prop_enum_list drm_vrr_mode_enum_list[] = {
+	{ VRR_DISPLAY_MODE_GAME,   "Game" },
+	{ VRR_DISPLAY_MODE_OFF,    "Off" },
+};
+DRM_ENUM_NAME_FN(drm_get_vrr_mode_name, drm_vrr_mode_enum_list)
+
 /**
  * drm_get_tv_mode_from_name - Translates a TV mode name into its enum value
  * @name: TV Mode name we want to convert
@@ -2560,6 +2566,14 @@ EXPORT_SYMBOL(drm_mode_create_scaling_mode_property);
  *
  *	The driver may place further restrictions within these minimum
  *	and maximum bounds.
+ *
+ * "vrr_display_mode":
+ *	Optional &drm_connector enum property that controls which VRR mode, if
+ *	any, a display is in. Possible values::
+ *
+ *	    - Game - set display to game mode if display supports it,
+ *	      regardless of CRTC state
+ *	    - Off - set display to VRR disabled mode, regardless of CRTC state
  */
 
 /**
@@ -2593,6 +2607,69 @@ int drm_connector_attach_vrr_capable_property(
 }
 EXPORT_SYMBOL(drm_connector_attach_vrr_capable_property);
 
+/**
+ * drm_connector_attach_vrr_display_mode_property - creates and attaches VRR
+ * display mode property
+ * @connector: pointer to the &struct drm_connector to attach the property to
+ * @supported_vrr_modes: bitmask of VRR modes the connector supports regardless
+ *			 of sink
+ *
+ * Creates and attaches the "vrr_display_mode" property to @connector. The
+ * property must not already exist on it. @supported_vrr_modes is a bitmask
+ * wherein BIT(VRR_DISPLAY_MODE_FOO) indicates VRR_DISPLAY_MODE_FOO is supported
+ * by the connector.
+ *
+ * Returns:
+ * Zero on success, negative errno on failure.
+ */
+int drm_connector_attach_vrr_display_mode_property(struct drm_connector *connector,
+						   unsigned int supported_vrr_modes)
+{
+	struct drm_device *dev = connector->dev;
+	struct drm_prop_enum_list enum_list[VRR_DISPLAY_MODE_COUNT];
+	unsigned int num_enums = 0;
+	struct drm_property *prop;
+	int i;
+
+	if (supported_vrr_modes & ~(BIT(VRR_DISPLAY_MODE_COUNT) - 1)) {
+		drm_err(dev, "Unknown VRR modes provided on [CONNECTOR:%d:%s]\n",
+			connector->base.id, connector->name);
+		return -EINVAL;
+	}
+
+	if (connector->vrr_display_mode_property) {
+		drm_err(dev, "[CONNECTOR:%d:%s] already has a 'vrr_display_mode' property\n",
+			connector->base.id, connector->name);
+		return -EEXIST;
+	}
+
+	if (!(supported_vrr_modes & BIT(VRR_DISPLAY_MODE_GAME))) {
+		drm_err(dev, "Missing default VRR mode on [CONNECTOR:%d:%s]\n",
+			connector->base.id, connector->name);
+		return -EINVAL;
+	}
+
+	for (i = 0; i < VRR_DISPLAY_MODE_COUNT; i++) {
+		if (BIT(i) & supported_vrr_modes) {
+			enum_list[num_enums].name = drm_get_vrr_mode_name(i);
+			enum_list[num_enums].type = i;
+			num_enums++;
+		}
+	}
+
+	prop = drm_property_create_enum(dev, DRM_MODE_PROP_ENUM, "vrr_display_mode",
+					enum_list, num_enums);
+
+	if (!prop)
+		return -ENOMEM;
+
+	connector->vrr_display_mode_property = prop;
+	drm_object_attach_property(&connector->base, prop, VRR_DISPLAY_MODE_GAME);
+
+	return 0;
+}
+EXPORT_SYMBOL(drm_connector_attach_vrr_display_mode_property);
+
 /**
  * drm_connector_attach_scaling_mode_property - attach atomic scaling mode property
  * @connector: connector to attach scaling mode property on.
diff --git a/include/drm/drm_connector.h b/include/drm/drm_connector.h
index 2ee7c59329aa..8699f35cafcb 100644
--- a/include/drm/drm_connector.h
+++ b/include/drm/drm_connector.h
@@ -809,6 +809,15 @@ enum drm_bus_flags {
 	DRM_BUS_FLAG_SHARP_SIGNALS = BIT(8),
 };
 
+enum vrr_display_mode {
+	/** @VRR_DISPLAY_MODE_GAME: Set the display to VRR "Game" mode */
+	VRR_DISPLAY_MODE_GAME = 0,
+	/** @VRR_DISPLAY_MODE_OFF: Turn off VRR on the display */
+	VRR_DISPLAY_MODE_OFF,
+	/** @VRR_DISPLAY_MODE_COUNT: Sentinel, not a valid mode, keep last */
+	VRR_DISPLAY_MODE_COUNT
+};
+
 /**
  * struct drm_amd_vsdb_info - AMD-specific VSDB information
  *
@@ -1352,6 +1361,12 @@ struct drm_connector_state {
 	 */
 	u8 max_bpc;
 
+	/**
+	 * @vrr_display_mode: One of &enum vrr_display_mode to indicate the VRR
+	 * type to use on a VRR-capable display.
+	 */
+	u8 vrr_display_mode;
+
 	/**
 	 * @privacy_screen_sw_state: See :ref:`Standard Connector
 	 * Properties<standard_connector_properties>`
@@ -2454,6 +2469,17 @@ struct drm_connector {
 	 */
 	struct drm_property *vrr_capable_property;
 
+	/**
+	 * @vrr_display_mode_property: Optional property for userspace to set
+	 * a connected display to a specific VRR mode, regardless of the
+	 * connected CRTC's VRR_ENABLED property. Drivers can create and attach
+	 * the property to a connector by calling
+	 * drm_connector_attach_vrr_display_mode_property(). Implementations can
+	 * then read the set display mode (&enum vrr_display_mode) from
+	 * &drm_connector_state.vrr_display_mode.
+	 */
+	struct drm_property *vrr_display_mode_property;
+
 	/**
 	 * @colorspace_property: Connector property to set the suitable
 	 * colorspace supported by the sink.
@@ -2859,6 +2885,7 @@ const char *drm_get_dpms_name(int val);
 const char *drm_get_dvi_i_subconnector_name(int val);
 const char *drm_get_dvi_i_select_name(int val);
 const char *drm_get_tv_mode_name(int val);
+const char *drm_get_vrr_mode_name(int val);
 const char *drm_get_tv_subconnector_name(int val);
 const char *drm_get_tv_select_name(int val);
 const char *drm_get_dp_subconnector_name(int val);
@@ -2883,6 +2910,8 @@ int drm_connector_attach_scaling_mode_property(struct drm_connector *connector,
 					       u32 scaling_mode_mask);
 int drm_connector_attach_vrr_capable_property(
 		struct drm_connector *connector);
+int drm_connector_attach_vrr_display_mode_property(struct drm_connector *connector,
+						   unsigned int supported_vrr_modes);
 void drm_connector_attach_panel_type_property(struct drm_connector *connector);
 int drm_connector_attach_broadcast_rgb_property(struct drm_connector *connector);
 int drm_connector_attach_colorspace_property(struct drm_connector *connector);

-- 
2.56.0