blob: ac9d7d8e0e43a807e9fc9a0b66de5f26b49d3348 [file] [log] [blame]
Daniel Vetter52217192016-08-12 22:48:50 +02001/*
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#ifndef __DRM_CONNECTOR_H__
24#define __DRM_CONNECTOR_H__
25
26#include <linux/list.h>
27#include <linux/ctype.h>
Daniel Vetter949619f2016-08-29 10:27:51 +020028#include <drm/drm_mode_object.h>
Daniel Vetter52217192016-08-12 22:48:50 +020029
Daniel Vetter199e4e92016-08-31 18:09:05 +020030#include <uapi/drm/drm_mode.h>
31
32struct drm_device;
33
Daniel Vetter52217192016-08-12 22:48:50 +020034struct drm_connector_helper_funcs;
35struct drm_device;
36struct drm_crtc;
37struct drm_encoder;
38struct drm_property;
39struct drm_property_blob;
40struct edid;
41
42enum drm_connector_force {
43 DRM_FORCE_UNSPECIFIED,
44 DRM_FORCE_OFF,
45 DRM_FORCE_ON, /* force on analog part normally */
46 DRM_FORCE_ON_DIGITAL, /* for DVI-I use digital connector */
47};
48
Daniel Vetterae2a6da2016-08-12 22:48:53 +020049/**
50 * enum drm_connector_status - status for a &drm_connector
51 *
52 * This enum is used to track the connector status. There are no separate
53 * #defines for the uapi!
54 */
Daniel Vetter52217192016-08-12 22:48:50 +020055enum drm_connector_status {
Daniel Vetterae2a6da2016-08-12 22:48:53 +020056 /**
57 * @connector_status_connected: The connector is definitely connected to
58 * a sink device, and can be enabled.
59 */
Daniel Vetter52217192016-08-12 22:48:50 +020060 connector_status_connected = 1,
Daniel Vetterae2a6da2016-08-12 22:48:53 +020061 /**
62 * @connector_status_disconnected: The connector isn't connected to a
63 * sink device which can be autodetect. For digital outputs like DP or
64 * HDMI (which can be realiable probed) this means there's really
65 * nothing there. It is driver-dependent whether a connector with this
66 * status can be lit up or not.
67 */
Daniel Vetter52217192016-08-12 22:48:50 +020068 connector_status_disconnected = 2,
Daniel Vetterae2a6da2016-08-12 22:48:53 +020069 /**
70 * @connector_status_unknown: The connector's status could not be
71 * reliably detected. This happens when probing would either cause
72 * flicker (like load-detection when the connector is in use), or when a
73 * hardware resource isn't available (like when load-detection needs a
74 * free CRTC). It should be possible to light up the connector with one
75 * of the listed fallback modes. For default configuration userspace
76 * should only try to light up connectors with unknown status when
77 * there's not connector with @connector_status_connected.
78 */
Daniel Vetter52217192016-08-12 22:48:50 +020079 connector_status_unknown = 3,
80};
81
82enum subpixel_order {
83 SubPixelUnknown = 0,
84 SubPixelHorizontalRGB,
85 SubPixelHorizontalBGR,
86 SubPixelVerticalRGB,
87 SubPixelVerticalBGR,
88 SubPixelNone,
89};
90
Daniel Vetterb3c6c8b2016-08-12 22:48:55 +020091/**
92 * struct drm_display_info - runtime data about the connected sink
93 *
94 * Describes a given display (e.g. CRT or flat panel) and its limitations. For
95 * fixed display sinks like built-in panels there's not much difference between
96 * this and struct &drm_connector. But for sinks with a real cable this
97 * structure is meant to describe all the things at the other end of the cable.
98 *
99 * For sinks which provide an EDID this can be filled out by calling
100 * drm_add_edid_modes().
Daniel Vetter52217192016-08-12 22:48:50 +0200101 */
102struct drm_display_info {
Daniel Vetterb3c6c8b2016-08-12 22:48:55 +0200103 /**
104 * @name: Name of the display.
105 */
Daniel Vetter52217192016-08-12 22:48:50 +0200106 char name[DRM_DISPLAY_INFO_LEN];
107
Daniel Vetterb3c6c8b2016-08-12 22:48:55 +0200108 /**
109 * @width_mm: Physical width in mm.
110 */
Daniel Vetter52217192016-08-12 22:48:50 +0200111 unsigned int width_mm;
Daniel Vetterb3c6c8b2016-08-12 22:48:55 +0200112 /**
113 * @height_mm: Physical height in mm.
114 */
Daniel Vetter52217192016-08-12 22:48:50 +0200115 unsigned int height_mm;
116
Daniel Vetterb3c6c8b2016-08-12 22:48:55 +0200117 /**
118 * @pixel_clock: Maximum pixel clock supported by the sink, in units of
119 * 100Hz. This mismatches the clok in &drm_display_mode (which is in
120 * kHZ), because that's what the EDID uses as base unit.
121 */
Daniel Vetter52217192016-08-12 22:48:50 +0200122 unsigned int pixel_clock;
Daniel Vetterb3c6c8b2016-08-12 22:48:55 +0200123 /**
124 * @bpc: Maximum bits per color channel. Used by HDMI and DP outputs.
125 */
Daniel Vetter52217192016-08-12 22:48:50 +0200126 unsigned int bpc;
127
Daniel Vetterb3c6c8b2016-08-12 22:48:55 +0200128 /**
129 * @subpixel_order: Subpixel order of LCD panels.
130 */
Daniel Vetter52217192016-08-12 22:48:50 +0200131 enum subpixel_order subpixel_order;
132
133#define DRM_COLOR_FORMAT_RGB444 (1<<0)
134#define DRM_COLOR_FORMAT_YCRCB444 (1<<1)
135#define DRM_COLOR_FORMAT_YCRCB422 (1<<2)
136
Daniel Vetterb3c6c8b2016-08-12 22:48:55 +0200137 /**
138 * @color_formats: HDMI Color formats, selects between RGB and YCrCb
139 * modes. Used DRM_COLOR_FORMAT\_ defines, which are _not_ the same ones
140 * as used to describe the pixel format in framebuffers, and also don't
141 * match the formats in @bus_formats which are shared with v4l.
142 */
Daniel Vetter52217192016-08-12 22:48:50 +0200143 u32 color_formats;
144
Daniel Vetterb3c6c8b2016-08-12 22:48:55 +0200145 /**
146 * @bus_formats: Pixel data format on the wire, somewhat redundant with
147 * @color_formats. Array of size @num_bus_formats encoded using
148 * MEDIA_BUS_FMT\_ defines shared with v4l and media drivers.
149 */
Daniel Vetter52217192016-08-12 22:48:50 +0200150 const u32 *bus_formats;
Daniel Vetterb3c6c8b2016-08-12 22:48:55 +0200151 /**
152 * @num_bus_formats: Size of @bus_formats array.
153 */
Daniel Vetter52217192016-08-12 22:48:50 +0200154 unsigned int num_bus_formats;
155
156#define DRM_BUS_FLAG_DE_LOW (1<<0)
157#define DRM_BUS_FLAG_DE_HIGH (1<<1)
158/* drive data on pos. edge */
159#define DRM_BUS_FLAG_PIXDATA_POSEDGE (1<<2)
160/* drive data on neg. edge */
161#define DRM_BUS_FLAG_PIXDATA_NEGEDGE (1<<3)
162
Daniel Vetterb3c6c8b2016-08-12 22:48:55 +0200163 /**
164 * @bus_flags: Additional information (like pixel signal polarity) for
165 * the pixel data on the bus, using DRM_BUS_FLAGS\_ defines.
166 */
Daniel Vetter52217192016-08-12 22:48:50 +0200167 u32 bus_flags;
168
Daniel Vetterb3c6c8b2016-08-12 22:48:55 +0200169 /**
Ville Syrjälä2a272ca2016-09-28 16:51:37 +0300170 * @max_tmds_clock: Maximum TMDS clock rate supported by the
171 * sink in kHz. 0 means undefined.
172 */
173 int max_tmds_clock;
174
175 /**
176 * @dvi_dual: Dual-link DVI sink?
177 */
178 bool dvi_dual;
179
180 /**
Daniel Vetterb3c6c8b2016-08-12 22:48:55 +0200181 * @edid_hdmi_dc_modes: Mask of supported hdmi deep color modes. Even
182 * more stuff redundant with @bus_formats.
183 */
Daniel Vetter52217192016-08-12 22:48:50 +0200184 u8 edid_hdmi_dc_modes;
185
Daniel Vetterb3c6c8b2016-08-12 22:48:55 +0200186 /**
187 * @cea_rev: CEA revision of the HDMI sink.
188 */
Daniel Vetter52217192016-08-12 22:48:50 +0200189 u8 cea_rev;
190};
191
Daniel Vetterb3c6c8b2016-08-12 22:48:55 +0200192int drm_display_info_set_bus_formats(struct drm_display_info *info,
193 const u32 *formats,
194 unsigned int num_formats);
195
Daniel Vetter52217192016-08-12 22:48:50 +0200196/**
197 * struct drm_connector_state - mutable connector state
198 * @connector: backpointer to the connector
Daniel Vetter52217192016-08-12 22:48:50 +0200199 * @best_encoder: can be used by helpers and drivers to select the encoder
200 * @state: backpointer to global drm_atomic_state
201 */
202struct drm_connector_state {
203 struct drm_connector *connector;
204
Daniel Vetterafb21ea62016-08-31 18:09:04 +0200205 /**
206 * @crtc: CRTC to connect connector to, NULL if disabled.
207 *
208 * Do not change this directly, use drm_atomic_set_crtc_for_connector()
209 * instead.
210 */
211 struct drm_crtc *crtc;
Daniel Vetter52217192016-08-12 22:48:50 +0200212
213 struct drm_encoder *best_encoder;
214
215 struct drm_atomic_state *state;
216};
217
218/**
219 * struct drm_connector_funcs - control connectors on a given device
220 *
221 * Each CRTC may have one or more connectors attached to it. The functions
222 * below allow the core DRM code to control connectors, enumerate available modes,
223 * etc.
224 */
225struct drm_connector_funcs {
226 /**
227 * @dpms:
228 *
229 * Legacy entry point to set the per-connector DPMS state. Legacy DPMS
230 * is exposed as a standard property on the connector, but diverted to
231 * this callback in the drm core. Note that atomic drivers don't
232 * implement the 4 level DPMS support on the connector any more, but
233 * instead only have an on/off "ACTIVE" property on the CRTC object.
234 *
235 * Drivers implementing atomic modeset should use
236 * drm_atomic_helper_connector_dpms() to implement this hook.
237 *
238 * RETURNS:
239 *
240 * 0 on success or a negative error code on failure.
241 */
242 int (*dpms)(struct drm_connector *connector, int mode);
243
244 /**
245 * @reset:
246 *
247 * Reset connector hardware and software state to off. This function isn't
248 * called by the core directly, only through drm_mode_config_reset().
249 * It's not a helper hook only for historical reasons.
250 *
251 * Atomic drivers can use drm_atomic_helper_connector_reset() to reset
252 * atomic state using this hook.
253 */
254 void (*reset)(struct drm_connector *connector);
255
256 /**
257 * @detect:
258 *
259 * Check to see if anything is attached to the connector. The parameter
260 * force is set to false whilst polling, true when checking the
261 * connector due to a user request. force can be used by the driver to
262 * avoid expensive, destructive operations during automated probing.
263 *
264 * FIXME:
265 *
266 * Note that this hook is only called by the probe helper. It's not in
267 * the helper library vtable purely for historical reasons. The only DRM
268 * core entry point to probe connector state is @fill_modes.
269 *
270 * RETURNS:
271 *
272 * drm_connector_status indicating the connector's status.
273 */
274 enum drm_connector_status (*detect)(struct drm_connector *connector,
275 bool force);
276
277 /**
278 * @force:
279 *
280 * This function is called to update internal encoder state when the
281 * connector is forced to a certain state by userspace, either through
282 * the sysfs interfaces or on the kernel cmdline. In that case the
283 * @detect callback isn't called.
284 *
285 * FIXME:
286 *
287 * Note that this hook is only called by the probe helper. It's not in
288 * the helper library vtable purely for historical reasons. The only DRM
289 * core entry point to probe connector state is @fill_modes.
290 */
291 void (*force)(struct drm_connector *connector);
292
293 /**
294 * @fill_modes:
295 *
296 * Entry point for output detection and basic mode validation. The
297 * driver should reprobe the output if needed (e.g. when hotplug
298 * handling is unreliable), add all detected modes to connector->modes
299 * and filter out any the device can't support in any configuration. It
300 * also needs to filter out any modes wider or higher than the
301 * parameters max_width and max_height indicate.
302 *
303 * The drivers must also prune any modes no longer valid from
304 * connector->modes. Furthermore it must update connector->status and
305 * connector->edid. If no EDID has been received for this output
306 * connector->edid must be NULL.
307 *
308 * Drivers using the probe helpers should use
309 * drm_helper_probe_single_connector_modes() or
310 * drm_helper_probe_single_connector_modes_nomerge() to implement this
311 * function.
312 *
313 * RETURNS:
314 *
315 * The number of modes detected and filled into connector->modes.
316 */
317 int (*fill_modes)(struct drm_connector *connector, uint32_t max_width, uint32_t max_height);
318
319 /**
320 * @set_property:
321 *
322 * This is the legacy entry point to update a property attached to the
323 * connector.
324 *
325 * Drivers implementing atomic modeset should use
326 * drm_atomic_helper_connector_set_property() to implement this hook.
327 *
328 * This callback is optional if the driver does not support any legacy
329 * driver-private properties.
330 *
331 * RETURNS:
332 *
333 * 0 on success or a negative error code on failure.
334 */
335 int (*set_property)(struct drm_connector *connector, struct drm_property *property,
336 uint64_t val);
337
338 /**
339 * @late_register:
340 *
341 * This optional hook can be used to register additional userspace
342 * interfaces attached to the connector, light backlight control, i2c,
343 * DP aux or similar interfaces. It is called late in the driver load
344 * sequence from drm_connector_register() when registering all the
345 * core drm connector interfaces. Everything added from this callback
346 * should be unregistered in the early_unregister callback.
347 *
348 * Returns:
349 *
350 * 0 on success, or a negative error code on failure.
351 */
352 int (*late_register)(struct drm_connector *connector);
353
354 /**
355 * @early_unregister:
356 *
357 * This optional hook should be used to unregister the additional
358 * userspace interfaces attached to the connector from
Grazvydas Ignotas621a9992016-10-09 20:07:00 +0300359 * late_register(). It is called from drm_connector_unregister(),
Daniel Vetter52217192016-08-12 22:48:50 +0200360 * early in the driver unload sequence to disable userspace access
361 * before data structures are torndown.
362 */
363 void (*early_unregister)(struct drm_connector *connector);
364
365 /**
366 * @destroy:
367 *
368 * Clean up connector resources. This is called at driver unload time
369 * through drm_mode_config_cleanup(). It can also be called at runtime
370 * when a connector is being hot-unplugged for drivers that support
371 * connector hotplugging (e.g. DisplayPort MST).
372 */
373 void (*destroy)(struct drm_connector *connector);
374
375 /**
376 * @atomic_duplicate_state:
377 *
378 * Duplicate the current atomic state for this connector and return it.
Grazvydas Ignotas621a9992016-10-09 20:07:00 +0300379 * The core and helpers guarantee that any atomic state duplicated with
Daniel Vetter52217192016-08-12 22:48:50 +0200380 * this hook and still owned by the caller (i.e. not transferred to the
381 * driver by calling ->atomic_commit() from struct
382 * &drm_mode_config_funcs) will be cleaned up by calling the
383 * @atomic_destroy_state hook in this structure.
384 *
385 * Atomic drivers which don't subclass struct &drm_connector_state should use
386 * drm_atomic_helper_connector_duplicate_state(). Drivers that subclass the
387 * state structure to extend it with driver-private state should use
388 * __drm_atomic_helper_connector_duplicate_state() to make sure shared state is
389 * duplicated in a consistent fashion across drivers.
390 *
391 * It is an error to call this hook before connector->state has been
392 * initialized correctly.
393 *
394 * NOTE:
395 *
396 * If the duplicate state references refcounted resources this hook must
397 * acquire a reference for each of them. The driver must release these
398 * references again in @atomic_destroy_state.
399 *
400 * RETURNS:
401 *
402 * Duplicated atomic state or NULL when the allocation failed.
403 */
404 struct drm_connector_state *(*atomic_duplicate_state)(struct drm_connector *connector);
405
406 /**
407 * @atomic_destroy_state:
408 *
409 * Destroy a state duplicated with @atomic_duplicate_state and release
410 * or unreference all resources it references
411 */
412 void (*atomic_destroy_state)(struct drm_connector *connector,
413 struct drm_connector_state *state);
414
415 /**
416 * @atomic_set_property:
417 *
418 * Decode a driver-private property value and store the decoded value
419 * into the passed-in state structure. Since the atomic core decodes all
420 * standardized properties (even for extensions beyond the core set of
421 * properties which might not be implemented by all drivers) this
422 * requires drivers to subclass the state structure.
423 *
424 * Such driver-private properties should really only be implemented for
425 * truly hardware/vendor specific state. Instead it is preferred to
426 * standardize atomic extension and decode the properties used to expose
427 * such an extension in the core.
428 *
429 * Do not call this function directly, use
430 * drm_atomic_connector_set_property() instead.
431 *
432 * This callback is optional if the driver does not support any
433 * driver-private atomic properties.
434 *
435 * NOTE:
436 *
437 * This function is called in the state assembly phase of atomic
438 * modesets, which can be aborted for any reason (including on
439 * userspace's request to just check whether a configuration would be
440 * possible). Drivers MUST NOT touch any persistent state (hardware or
441 * software) or data structures except the passed in @state parameter.
442 *
443 * Also since userspace controls in which order properties are set this
444 * function must not do any input validation (since the state update is
445 * incomplete and hence likely inconsistent). Instead any such input
446 * validation must be done in the various atomic_check callbacks.
447 *
448 * RETURNS:
449 *
450 * 0 if the property has been found, -EINVAL if the property isn't
451 * implemented by the driver (which shouldn't ever happen, the core only
452 * asks for properties attached to this connector). No other validation
453 * is allowed by the driver. The core already checks that the property
454 * value is within the range (integer, valid enum value, ...) the driver
455 * set when registering the property.
456 */
457 int (*atomic_set_property)(struct drm_connector *connector,
458 struct drm_connector_state *state,
459 struct drm_property *property,
460 uint64_t val);
461
462 /**
463 * @atomic_get_property:
464 *
465 * Reads out the decoded driver-private property. This is used to
466 * implement the GETCONNECTOR IOCTL.
467 *
468 * Do not call this function directly, use
469 * drm_atomic_connector_get_property() instead.
470 *
471 * This callback is optional if the driver does not support any
472 * driver-private atomic properties.
473 *
474 * RETURNS:
475 *
476 * 0 on success, -EINVAL if the property isn't implemented by the
477 * driver (which shouldn't ever happen, the core only asks for
478 * properties attached to this connector).
479 */
480 int (*atomic_get_property)(struct drm_connector *connector,
481 const struct drm_connector_state *state,
482 struct drm_property *property,
483 uint64_t *val);
484};
485
486/* mode specified on the command line */
487struct drm_cmdline_mode {
488 bool specified;
489 bool refresh_specified;
490 bool bpp_specified;
491 int xres, yres;
492 int bpp;
493 int refresh;
494 bool rb;
495 bool interlace;
496 bool cvt;
497 bool margins;
498 enum drm_connector_force force;
499};
500
501/**
502 * struct drm_connector - central DRM connector control structure
503 * @dev: parent DRM device
504 * @kdev: kernel device for sysfs attributes
505 * @attr: sysfs attributes
506 * @head: list management
507 * @base: base KMS object
508 * @name: human readable name, can be overwritten by the driver
509 * @connector_type: one of the DRM_MODE_CONNECTOR_<foo> types from drm_mode.h
510 * @connector_type_id: index into connector type enum
511 * @interlace_allowed: can this connector handle interlaced modes?
512 * @doublescan_allowed: can this connector handle doublescan?
513 * @stereo_allowed: can this connector handle stereo modes?
514 * @registered: is this connector exposed (registered) with userspace?
515 * @modes: modes available on this connector (from fill_modes() + user)
516 * @status: one of the drm_connector_status enums (connected, not, or unknown)
517 * @probed_modes: list of modes derived directly from the display
Daniel Vetter52217192016-08-12 22:48:50 +0200518 * @funcs: connector control functions
519 * @edid_blob_ptr: DRM property containing EDID if present
520 * @properties: property tracking for this connector
Daniel Vetter52217192016-08-12 22:48:50 +0200521 * @dpms: current dpms state
522 * @helper_private: mid-layer private data
523 * @cmdline_mode: mode line parsed from the kernel cmdline for this connector
524 * @force: a DRM_FORCE_<foo> state for forced mode sets
525 * @override_edid: has the EDID been overwritten through debugfs for testing?
526 * @encoder_ids: valid encoders for this connector
527 * @encoder: encoder driving this connector, if any
528 * @eld: EDID-like data, if present
Daniel Vetter52217192016-08-12 22:48:50 +0200529 * @latency_present: AV delay info from ELD, if found
530 * @video_latency: video latency info from ELD, if found
531 * @audio_latency: audio latency info from ELD, if found
532 * @null_edid_counter: track sinks that give us all zeros for the EDID
533 * @bad_edid_counter: track sinks that give us an EDID with invalid checksum
534 * @edid_corrupt: indicates whether the last read EDID was corrupt
535 * @debugfs_entry: debugfs directory for this connector
536 * @state: current atomic state for this connector
537 * @has_tile: is this connector connected to a tiled monitor
538 * @tile_group: tile group for the connected monitor
539 * @tile_is_single_monitor: whether the tile is one monitor housing
540 * @num_h_tile: number of horizontal tiles in the tile group
541 * @num_v_tile: number of vertical tiles in the tile group
542 * @tile_h_loc: horizontal location of this tile
543 * @tile_v_loc: vertical location of this tile
544 * @tile_h_size: horizontal size of this tile.
545 * @tile_v_size: vertical size of this tile.
546 *
547 * Each connector may be connected to one or more CRTCs, or may be clonable by
548 * another connector if they can share a CRTC. Each connector also has a specific
549 * position in the broader display (referred to as a 'screen' though it could
550 * span multiple monitors).
551 */
552struct drm_connector {
553 struct drm_device *dev;
554 struct device *kdev;
555 struct device_attribute *attr;
556 struct list_head head;
557
558 struct drm_mode_object base;
559
560 char *name;
561
562 /**
563 * @index: Compacted connector index, which matches the position inside
564 * the mode_config.list for drivers not supporting hot-add/removing. Can
565 * be used as an array index. It is invariant over the lifetime of the
566 * connector.
567 */
568 unsigned index;
569
570 int connector_type;
571 int connector_type_id;
572 bool interlace_allowed;
573 bool doublescan_allowed;
574 bool stereo_allowed;
575 bool registered;
576 struct list_head modes; /* list of modes on this connector */
577
578 enum drm_connector_status status;
579
580 /* these are modes added by probing with DDC or the BIOS */
581 struct list_head probed_modes;
582
Daniel Vetterae2a6da2016-08-12 22:48:53 +0200583 /**
584 * @display_info: Display information is filled from EDID information
585 * when a display is detected. For non hot-pluggable displays such as
586 * flat panels in embedded systems, the driver should initialize the
587 * display_info.width_mm and display_info.height_mm fields with the
588 * physical size of the display.
589 */
Daniel Vetter52217192016-08-12 22:48:50 +0200590 struct drm_display_info display_info;
591 const struct drm_connector_funcs *funcs;
592
593 struct drm_property_blob *edid_blob_ptr;
594 struct drm_object_properties properties;
595
596 /**
597 * @path_blob_ptr:
598 *
599 * DRM blob property data for the DP MST path property.
600 */
601 struct drm_property_blob *path_blob_ptr;
602
603 /**
604 * @tile_blob_ptr:
605 *
606 * DRM blob property data for the tile property (used mostly by DP MST).
607 * This is meant for screens which are driven through separate display
608 * pipelines represented by &drm_crtc, which might not be running with
609 * genlocked clocks. For tiled panels which are genlocked, like
610 * dual-link LVDS or dual-link DSI, the driver should try to not expose
611 * the tiling and virtualize both &drm_crtc and &drm_plane if needed.
612 */
613 struct drm_property_blob *tile_blob_ptr;
614
615/* should we poll this connector for connects and disconnects */
616/* hot plug detectable */
617#define DRM_CONNECTOR_POLL_HPD (1 << 0)
618/* poll for connections */
619#define DRM_CONNECTOR_POLL_CONNECT (1 << 1)
620/* can cleanly poll for disconnections without flickering the screen */
621/* DACs should rarely do this without a lot of testing */
622#define DRM_CONNECTOR_POLL_DISCONNECT (1 << 2)
623
Daniel Vetterae2a6da2016-08-12 22:48:53 +0200624 /**
625 * @polled:
626 *
627 * Connector polling mode, a combination of
628 *
629 * DRM_CONNECTOR_POLL_HPD
630 * The connector generates hotplug events and doesn't need to be
631 * periodically polled. The CONNECT and DISCONNECT flags must not
632 * be set together with the HPD flag.
633 *
634 * DRM_CONNECTOR_POLL_CONNECT
635 * Periodically poll the connector for connection.
636 *
637 * DRM_CONNECTOR_POLL_DISCONNECT
638 * Periodically poll the connector for disconnection.
639 *
640 * Set to 0 for connectors that don't support connection status
641 * discovery.
642 */
643 uint8_t polled;
Daniel Vetter52217192016-08-12 22:48:50 +0200644
645 /* requested DPMS state */
646 int dpms;
647
648 const struct drm_connector_helper_funcs *helper_private;
649
650 /* forced on connector */
651 struct drm_cmdline_mode cmdline_mode;
652 enum drm_connector_force force;
653 bool override_edid;
654
655#define DRM_CONNECTOR_MAX_ENCODER 3
656 uint32_t encoder_ids[DRM_CONNECTOR_MAX_ENCODER];
657 struct drm_encoder *encoder; /* currently active encoder */
658
659#define MAX_ELD_BYTES 128
660 /* EDID bits */
661 uint8_t eld[MAX_ELD_BYTES];
Daniel Vetter52217192016-08-12 22:48:50 +0200662 bool latency_present[2];
663 int video_latency[2]; /* [0]: progressive, [1]: interlaced */
664 int audio_latency[2];
665 int null_edid_counter; /* needed to workaround some HW bugs where we get all 0s */
666 unsigned bad_edid_counter;
667
668 /* Flag for raw EDID header corruption - used in Displayport
669 * compliance testing - * Displayport Link CTS Core 1.2 rev1.1 4.2.2.6
670 */
671 bool edid_corrupt;
672
673 struct dentry *debugfs_entry;
674
675 struct drm_connector_state *state;
676
677 /* DisplayID bits */
678 bool has_tile;
679 struct drm_tile_group *tile_group;
680 bool tile_is_single_monitor;
681
682 uint8_t num_h_tile, num_v_tile;
683 uint8_t tile_h_loc, tile_v_loc;
684 uint16_t tile_h_size, tile_v_size;
685};
686
687#define obj_to_connector(x) container_of(x, struct drm_connector, base)
688
689int drm_connector_init(struct drm_device *dev,
690 struct drm_connector *connector,
691 const struct drm_connector_funcs *funcs,
692 int connector_type);
693int drm_connector_register(struct drm_connector *connector);
694void drm_connector_unregister(struct drm_connector *connector);
695int drm_mode_connector_attach_encoder(struct drm_connector *connector,
696 struct drm_encoder *encoder);
697
698void drm_connector_cleanup(struct drm_connector *connector);
699static inline unsigned drm_connector_index(struct drm_connector *connector)
700{
701 return connector->index;
702}
703
704/**
705 * drm_connector_lookup - lookup connector object
706 * @dev: DRM device
707 * @id: connector object id
708 *
709 * This function looks up the connector object specified by id
710 * add takes a reference to it.
711 */
712static inline struct drm_connector *drm_connector_lookup(struct drm_device *dev,
713 uint32_t id)
714{
715 struct drm_mode_object *mo;
716 mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_CONNECTOR);
717 return mo ? obj_to_connector(mo) : NULL;
718}
719
720/**
721 * drm_connector_reference - incr the connector refcnt
722 * @connector: connector
723 *
724 * This function increments the connector's refcount.
725 */
726static inline void drm_connector_reference(struct drm_connector *connector)
727{
728 drm_mode_object_reference(&connector->base);
729}
730
731/**
732 * drm_connector_unreference - unref a connector
733 * @connector: connector to unref
734 *
735 * This function decrements the connector's refcount and frees it if it drops to zero.
736 */
737static inline void drm_connector_unreference(struct drm_connector *connector)
738{
739 drm_mode_object_unreference(&connector->base);
740}
741
742const char *drm_get_connector_status_name(enum drm_connector_status status);
743const char *drm_get_subpixel_order_name(enum subpixel_order order);
744const char *drm_get_dpms_name(int val);
745const char *drm_get_dvi_i_subconnector_name(int val);
746const char *drm_get_dvi_i_select_name(int val);
747const char *drm_get_tv_subconnector_name(int val);
748const char *drm_get_tv_select_name(int val);
749
750int drm_mode_create_dvi_i_properties(struct drm_device *dev);
751int drm_mode_create_tv_properties(struct drm_device *dev,
752 unsigned int num_modes,
753 const char * const modes[]);
754int drm_mode_create_scaling_mode_property(struct drm_device *dev);
755int drm_mode_create_aspect_ratio_property(struct drm_device *dev);
756int drm_mode_create_suggested_offset_properties(struct drm_device *dev);
757
758int drm_mode_connector_set_path_property(struct drm_connector *connector,
759 const char *path);
760int drm_mode_connector_set_tile_property(struct drm_connector *connector);
761int drm_mode_connector_update_edid_property(struct drm_connector *connector,
762 const struct edid *edid);
Daniel Vetterafb21ea62016-08-31 18:09:04 +0200763
764/**
765 * drm_for_each_connector - iterate over all connectors
766 * @connector: the loop cursor
767 * @dev: the DRM device
768 *
769 * Iterate over all connectors of @dev.
770 */
771#define drm_for_each_connector(connector, dev) \
772 for (assert_drm_connector_list_read_locked(&(dev)->mode_config), \
773 connector = list_first_entry(&(dev)->mode_config.connector_list, \
774 struct drm_connector, head); \
775 &connector->head != (&(dev)->mode_config.connector_list); \
776 connector = list_next_entry(connector, head))
777
Daniel Vetter52217192016-08-12 22:48:50 +0200778#endif