1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright (C) 2019 Laurent Pinchart <laurent.pinchart@ideasonboard.com> 4 */ 5 6 #include <linux/kernel.h> 7 #include <linux/module.h> 8 #include <linux/slab.h> 9 10 #include <drm/drm_atomic_state_helper.h> 11 #include <drm/drm_bridge.h> 12 #include <drm/drm_bridge_connector.h> 13 #include <drm/drm_connector.h> 14 #include <drm/drm_device.h> 15 #include <drm/drm_edid.h> 16 #include <drm/drm_modeset_helper_vtables.h> 17 #include <drm/drm_probe_helper.h> 18 19 /** 20 * DOC: overview 21 * 22 * The DRM bridge connector helper object provides a DRM connector 23 * implementation that wraps a chain of &struct drm_bridge. The connector 24 * operations are fully implemented based on the operations of the bridges in 25 * the chain, and don't require any intervention from the display controller 26 * driver at runtime. 27 * 28 * To use the helper, display controller drivers create a bridge connector with 29 * a call to drm_bridge_connector_init(). This associates the newly created 30 * connector with the chain of bridges passed to the function and registers it 31 * with the DRM device. At that point the connector becomes fully usable, no 32 * further operation is needed. 33 * 34 * The DRM bridge connector operations are implemented based on the operations 35 * provided by the bridges in the chain. Each connector operation is delegated 36 * to the bridge closest to the connector (at the end of the chain) that 37 * provides the relevant functionality. 38 * 39 * To make use of this helper, all bridges in the chain shall report bridge 40 * operation flags (&drm_bridge->ops) and bridge output type 41 * (&drm_bridge->type), as well as the DRM_BRIDGE_ATTACH_NO_CONNECTOR attach 42 * flag (none of the bridges shall create a DRM connector directly). 43 */ 44 45 /** 46 * struct drm_bridge_connector - A connector backed by a chain of bridges 47 */ 48 struct drm_bridge_connector { 49 /** 50 * @base: The base DRM connector 51 */ 52 struct drm_connector base; 53 /** 54 * @encoder: 55 * 56 * The encoder at the start of the bridges chain. 57 */ 58 struct drm_encoder *encoder; 59 /** 60 * @bridge_edid: 61 * 62 * The last bridge in the chain (closest to the connector) that provides 63 * EDID read support, if any (see &DRM_BRIDGE_OP_EDID). 64 */ 65 struct drm_bridge *bridge_edid; 66 /** 67 * @bridge_hpd: 68 * 69 * The last bridge in the chain (closest to the connector) that provides 70 * hot-plug detection notification, if any (see &DRM_BRIDGE_OP_HPD). 71 */ 72 struct drm_bridge *bridge_hpd; 73 /** 74 * @bridge_detect: 75 * 76 * The last bridge in the chain (closest to the connector) that provides 77 * connector detection, if any (see &DRM_BRIDGE_OP_DETECT). 78 */ 79 struct drm_bridge *bridge_detect; 80 /** 81 * @bridge_modes: 82 * 83 * The last bridge in the chain (closest to the connector) that provides 84 * connector modes detection, if any (see &DRM_BRIDGE_OP_MODES). 85 */ 86 struct drm_bridge *bridge_modes; 87 }; 88 89 #define to_drm_bridge_connector(x) \ 90 container_of(x, struct drm_bridge_connector, base) 91 92 /* ----------------------------------------------------------------------------- 93 * Bridge Connector Hot-Plug Handling 94 */ 95 96 static void drm_bridge_connector_hpd_notify(struct drm_connector *connector, 97 enum drm_connector_status status) 98 { 99 struct drm_bridge_connector *bridge_connector = 100 to_drm_bridge_connector(connector); 101 struct drm_bridge *bridge; 102 103 /* Notify all bridges in the pipeline of hotplug events. */ 104 drm_for_each_bridge_in_chain(bridge_connector->encoder, bridge) { 105 if (bridge->funcs->hpd_notify) 106 bridge->funcs->hpd_notify(bridge, status); 107 } 108 } 109 110 static void drm_bridge_connector_hpd_cb(void *cb_data, 111 enum drm_connector_status status) 112 { 113 struct drm_bridge_connector *drm_bridge_connector = cb_data; 114 struct drm_connector *connector = &drm_bridge_connector->base; 115 struct drm_device *dev = connector->dev; 116 enum drm_connector_status old_status; 117 118 mutex_lock(&dev->mode_config.mutex); 119 old_status = connector->status; 120 connector->status = status; 121 mutex_unlock(&dev->mode_config.mutex); 122 123 if (old_status == status) 124 return; 125 126 drm_bridge_connector_hpd_notify(connector, status); 127 128 drm_kms_helper_hotplug_event(dev); 129 } 130 131 /** 132 * drm_bridge_connector_enable_hpd - Enable hot-plug detection for the connector 133 * @connector: The DRM bridge connector 134 * 135 * This function enables hot-plug detection for the given bridge connector. 136 * This is typically used by display drivers in their resume handler. 137 */ 138 void drm_bridge_connector_enable_hpd(struct drm_connector *connector) 139 { 140 struct drm_bridge_connector *bridge_connector = 141 to_drm_bridge_connector(connector); 142 struct drm_bridge *hpd = bridge_connector->bridge_hpd; 143 144 if (hpd) 145 drm_bridge_hpd_enable(hpd, drm_bridge_connector_hpd_cb, 146 bridge_connector); 147 } 148 EXPORT_SYMBOL_GPL(drm_bridge_connector_enable_hpd); 149 150 /** 151 * drm_bridge_connector_disable_hpd - Disable hot-plug detection for the 152 * connector 153 * @connector: The DRM bridge connector 154 * 155 * This function disables hot-plug detection for the given bridge connector. 156 * This is typically used by display drivers in their suspend handler. 157 */ 158 void drm_bridge_connector_disable_hpd(struct drm_connector *connector) 159 { 160 struct drm_bridge_connector *bridge_connector = 161 to_drm_bridge_connector(connector); 162 struct drm_bridge *hpd = bridge_connector->bridge_hpd; 163 164 if (hpd) 165 drm_bridge_hpd_disable(hpd); 166 } 167 EXPORT_SYMBOL_GPL(drm_bridge_connector_disable_hpd); 168 169 /* ----------------------------------------------------------------------------- 170 * Bridge Connector Functions 171 */ 172 173 static enum drm_connector_status 174 drm_bridge_connector_detect(struct drm_connector *connector, bool force) 175 { 176 struct drm_bridge_connector *bridge_connector = 177 to_drm_bridge_connector(connector); 178 struct drm_bridge *detect = bridge_connector->bridge_detect; 179 enum drm_connector_status status; 180 181 if (detect) { 182 status = detect->funcs->detect(detect); 183 184 drm_bridge_connector_hpd_notify(connector, status); 185 } else { 186 switch (connector->connector_type) { 187 case DRM_MODE_CONNECTOR_DPI: 188 case DRM_MODE_CONNECTOR_LVDS: 189 case DRM_MODE_CONNECTOR_DSI: 190 case DRM_MODE_CONNECTOR_eDP: 191 status = connector_status_connected; 192 break; 193 default: 194 status = connector_status_unknown; 195 break; 196 } 197 } 198 199 return status; 200 } 201 202 static void drm_bridge_connector_destroy(struct drm_connector *connector) 203 { 204 struct drm_bridge_connector *bridge_connector = 205 to_drm_bridge_connector(connector); 206 207 if (bridge_connector->bridge_hpd) { 208 struct drm_bridge *hpd = bridge_connector->bridge_hpd; 209 210 drm_bridge_hpd_disable(hpd); 211 } 212 213 drm_connector_unregister(connector); 214 drm_connector_cleanup(connector); 215 216 kfree(bridge_connector); 217 } 218 219 static void drm_bridge_connector_debugfs_init(struct drm_connector *connector, 220 struct dentry *root) 221 { 222 struct drm_bridge_connector *bridge_connector = 223 to_drm_bridge_connector(connector); 224 struct drm_encoder *encoder = bridge_connector->encoder; 225 struct drm_bridge *bridge; 226 227 list_for_each_entry(bridge, &encoder->bridge_chain, chain_node) { 228 if (bridge->funcs->debugfs_init) 229 bridge->funcs->debugfs_init(bridge, root); 230 } 231 } 232 233 static const struct drm_connector_funcs drm_bridge_connector_funcs = { 234 .reset = drm_atomic_helper_connector_reset, 235 .detect = drm_bridge_connector_detect, 236 .fill_modes = drm_helper_probe_single_connector_modes, 237 .destroy = drm_bridge_connector_destroy, 238 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, 239 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, 240 .debugfs_init = drm_bridge_connector_debugfs_init, 241 }; 242 243 /* ----------------------------------------------------------------------------- 244 * Bridge Connector Helper Functions 245 */ 246 247 static int drm_bridge_connector_get_modes_edid(struct drm_connector *connector, 248 struct drm_bridge *bridge) 249 { 250 enum drm_connector_status status; 251 struct edid *edid; 252 int n; 253 254 status = drm_bridge_connector_detect(connector, false); 255 if (status != connector_status_connected) 256 goto no_edid; 257 258 edid = bridge->funcs->get_edid(bridge, connector); 259 if (!drm_edid_is_valid(edid)) { 260 kfree(edid); 261 goto no_edid; 262 } 263 264 drm_connector_update_edid_property(connector, edid); 265 n = drm_add_edid_modes(connector, edid); 266 267 kfree(edid); 268 return n; 269 270 no_edid: 271 drm_connector_update_edid_property(connector, NULL); 272 return 0; 273 } 274 275 static int drm_bridge_connector_get_modes(struct drm_connector *connector) 276 { 277 struct drm_bridge_connector *bridge_connector = 278 to_drm_bridge_connector(connector); 279 struct drm_bridge *bridge; 280 281 /* 282 * If display exposes EDID, then we parse that in the normal way to 283 * build table of supported modes. 284 */ 285 bridge = bridge_connector->bridge_edid; 286 if (bridge) 287 return drm_bridge_connector_get_modes_edid(connector, bridge); 288 289 /* 290 * Otherwise if the display pipeline reports modes (e.g. with a fixed 291 * resolution panel or an analog TV output), query it. 292 */ 293 bridge = bridge_connector->bridge_modes; 294 if (bridge) 295 return bridge->funcs->get_modes(bridge, connector); 296 297 /* 298 * We can't retrieve modes, which can happen for instance for a DVI or 299 * VGA output with the DDC bus unconnected. The KMS core will add the 300 * default modes. 301 */ 302 return 0; 303 } 304 305 static const struct drm_connector_helper_funcs drm_bridge_connector_helper_funcs = { 306 .get_modes = drm_bridge_connector_get_modes, 307 /* No need for .mode_valid(), the bridges are checked by the core. */ 308 }; 309 310 /* ----------------------------------------------------------------------------- 311 * Bridge Connector Initialisation 312 */ 313 314 /** 315 * drm_bridge_connector_init - Initialise a connector for a chain of bridges 316 * @drm: the DRM device 317 * @encoder: the encoder where the bridge chain starts 318 * 319 * Allocate, initialise and register a &drm_bridge_connector with the @drm 320 * device. The connector is associated with a chain of bridges that starts at 321 * the @encoder. All bridges in the chain shall report bridge operation flags 322 * (&drm_bridge->ops) and bridge output type (&drm_bridge->type), and none of 323 * them may create a DRM connector directly. 324 * 325 * Returns a pointer to the new connector on success, or a negative error 326 * pointer otherwise. 327 */ 328 struct drm_connector *drm_bridge_connector_init(struct drm_device *drm, 329 struct drm_encoder *encoder) 330 { 331 struct drm_bridge_connector *bridge_connector; 332 struct drm_connector *connector; 333 struct i2c_adapter *ddc = NULL; 334 struct drm_bridge *bridge, *panel_bridge = NULL; 335 int connector_type; 336 337 bridge_connector = kzalloc(sizeof(*bridge_connector), GFP_KERNEL); 338 if (!bridge_connector) 339 return ERR_PTR(-ENOMEM); 340 341 bridge_connector->encoder = encoder; 342 343 /* 344 * TODO: Handle doublescan_allowed, stereo_allowed and 345 * ycbcr_420_allowed. 346 */ 347 connector = &bridge_connector->base; 348 connector->interlace_allowed = true; 349 350 /* 351 * Initialise connector status handling. First locate the furthest 352 * bridges in the pipeline that support HPD and output detection. Then 353 * initialise the connector polling mode, using HPD if available and 354 * falling back to polling if supported. If neither HPD nor output 355 * detection are available, we don't support hotplug detection at all. 356 */ 357 connector_type = DRM_MODE_CONNECTOR_Unknown; 358 drm_for_each_bridge_in_chain(encoder, bridge) { 359 if (!bridge->interlace_allowed) 360 connector->interlace_allowed = false; 361 362 if (bridge->ops & DRM_BRIDGE_OP_EDID) 363 bridge_connector->bridge_edid = bridge; 364 if (bridge->ops & DRM_BRIDGE_OP_HPD) 365 bridge_connector->bridge_hpd = bridge; 366 if (bridge->ops & DRM_BRIDGE_OP_DETECT) 367 bridge_connector->bridge_detect = bridge; 368 if (bridge->ops & DRM_BRIDGE_OP_MODES) 369 bridge_connector->bridge_modes = bridge; 370 371 if (!drm_bridge_get_next_bridge(bridge)) 372 connector_type = bridge->type; 373 374 if (bridge->ddc) 375 ddc = bridge->ddc; 376 377 if (drm_bridge_is_panel(bridge)) 378 panel_bridge = bridge; 379 } 380 381 if (connector_type == DRM_MODE_CONNECTOR_Unknown) { 382 kfree(bridge_connector); 383 return ERR_PTR(-EINVAL); 384 } 385 386 drm_connector_init_with_ddc(drm, connector, &drm_bridge_connector_funcs, 387 connector_type, ddc); 388 drm_connector_helper_add(connector, &drm_bridge_connector_helper_funcs); 389 390 if (bridge_connector->bridge_hpd) { 391 connector->polled = DRM_CONNECTOR_POLL_HPD; 392 drm_bridge_connector_enable_hpd(connector); 393 } 394 else if (bridge_connector->bridge_detect) 395 connector->polled = DRM_CONNECTOR_POLL_CONNECT 396 | DRM_CONNECTOR_POLL_DISCONNECT; 397 398 if (panel_bridge) 399 drm_panel_bridge_set_orientation(connector, panel_bridge); 400 401 return connector; 402 } 403 EXPORT_SYMBOL_GPL(drm_bridge_connector_init); 404