1 /* 2 * Copyright © 2006 Keith Packard 3 * Copyright © 2007-2008 Dave Airlie 4 * Copyright © 2007-2008 Intel Corporation 5 * Jesse Barnes <jesse.barnes@intel.com> 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining a 8 * copy of this software and associated documentation files (the "Software"), 9 * to deal in the Software without restriction, including without limitation 10 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 11 * and/or sell copies of the Software, and to permit persons to whom the 12 * Software is furnished to do so, subject to the following conditions: 13 * 14 * The above copyright notice and this permission notice shall be included in 15 * all copies or substantial portions of the Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 20 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR 21 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 22 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 23 * OTHER DEALINGS IN THE SOFTWARE. 24 */ 25 #ifndef __DRM_CRTC_H__ 26 #define __DRM_CRTC_H__ 27 28 #include <linux/i2c.h> 29 #include <linux/spinlock.h> 30 #include <linux/types.h> 31 #include <linux/idr.h> 32 #include <linux/fb.h> 33 #include <linux/hdmi.h> 34 #include <linux/media-bus-format.h> 35 #include <uapi/drm/drm_mode.h> 36 #include <uapi/drm/drm_fourcc.h> 37 #include <drm/drm_modeset_lock.h> 38 39 struct drm_device; 40 struct drm_mode_set; 41 struct drm_framebuffer; 42 struct drm_object_properties; 43 struct drm_file; 44 struct drm_clip_rect; 45 struct device_node; 46 struct fence; 47 48 #define DRM_MODE_OBJECT_CRTC 0xcccccccc 49 #define DRM_MODE_OBJECT_CONNECTOR 0xc0c0c0c0 50 #define DRM_MODE_OBJECT_ENCODER 0xe0e0e0e0 51 #define DRM_MODE_OBJECT_MODE 0xdededede 52 #define DRM_MODE_OBJECT_PROPERTY 0xb0b0b0b0 53 #define DRM_MODE_OBJECT_FB 0xfbfbfbfb 54 #define DRM_MODE_OBJECT_BLOB 0xbbbbbbbb 55 #define DRM_MODE_OBJECT_PLANE 0xeeeeeeee 56 #define DRM_MODE_OBJECT_BRIDGE 0xbdbdbdbd 57 #define DRM_MODE_OBJECT_ANY 0 58 59 struct drm_mode_object { 60 uint32_t id; 61 uint32_t type; 62 struct drm_object_properties *properties; 63 }; 64 65 #define DRM_OBJECT_MAX_PROPERTY 24 66 struct drm_object_properties { 67 int count, atomic_count; 68 /* NOTE: if we ever start dynamically destroying properties (ie. 69 * not at drm_mode_config_cleanup() time), then we'd have to do 70 * a better job of detaching property from mode objects to avoid 71 * dangling property pointers: 72 */ 73 struct drm_property *properties[DRM_OBJECT_MAX_PROPERTY]; 74 /* do not read/write values directly, but use drm_object_property_get_value() 75 * and drm_object_property_set_value(): 76 */ 77 uint64_t values[DRM_OBJECT_MAX_PROPERTY]; 78 }; 79 80 static inline int64_t U642I64(uint64_t val) 81 { 82 return (int64_t)*((int64_t *)&val); 83 } 84 static inline uint64_t I642U64(int64_t val) 85 { 86 return (uint64_t)*((uint64_t *)&val); 87 } 88 89 /* rotation property bits */ 90 #define DRM_ROTATE_0 0 91 #define DRM_ROTATE_90 1 92 #define DRM_ROTATE_180 2 93 #define DRM_ROTATE_270 3 94 #define DRM_REFLECT_X 4 95 #define DRM_REFLECT_Y 5 96 97 enum drm_connector_force { 98 DRM_FORCE_UNSPECIFIED, 99 DRM_FORCE_OFF, 100 DRM_FORCE_ON, /* force on analog part normally */ 101 DRM_FORCE_ON_DIGITAL, /* for DVI-I use digital connector */ 102 }; 103 104 #include <drm/drm_modes.h> 105 106 enum drm_connector_status { 107 connector_status_connected = 1, 108 connector_status_disconnected = 2, 109 connector_status_unknown = 3, 110 }; 111 112 enum subpixel_order { 113 SubPixelUnknown = 0, 114 SubPixelHorizontalRGB, 115 SubPixelHorizontalBGR, 116 SubPixelVerticalRGB, 117 SubPixelVerticalBGR, 118 SubPixelNone, 119 }; 120 121 #define DRM_COLOR_FORMAT_RGB444 (1<<0) 122 #define DRM_COLOR_FORMAT_YCRCB444 (1<<1) 123 #define DRM_COLOR_FORMAT_YCRCB422 (1<<2) 124 /* 125 * Describes a given display (e.g. CRT or flat panel) and its limitations. 126 */ 127 struct drm_display_info { 128 char name[DRM_DISPLAY_INFO_LEN]; 129 130 /* Physical size */ 131 unsigned int width_mm; 132 unsigned int height_mm; 133 134 /* Clock limits FIXME: storage format */ 135 unsigned int min_vfreq, max_vfreq; 136 unsigned int min_hfreq, max_hfreq; 137 unsigned int pixel_clock; 138 unsigned int bpc; 139 140 enum subpixel_order subpixel_order; 141 u32 color_formats; 142 143 const u32 *bus_formats; 144 unsigned int num_bus_formats; 145 146 /* Mask of supported hdmi deep color modes */ 147 u8 edid_hdmi_dc_modes; 148 149 u8 cea_rev; 150 }; 151 152 /* data corresponds to displayid vend/prod/serial */ 153 struct drm_tile_group { 154 struct kref refcount; 155 struct drm_device *dev; 156 int id; 157 u8 group_data[8]; 158 }; 159 160 struct drm_framebuffer_funcs { 161 /* note: use drm_framebuffer_remove() */ 162 void (*destroy)(struct drm_framebuffer *framebuffer); 163 int (*create_handle)(struct drm_framebuffer *fb, 164 struct drm_file *file_priv, 165 unsigned int *handle); 166 /* 167 * Optional callback for the dirty fb ioctl. 168 * 169 * Userspace can notify the driver via this callback 170 * that a area of the framebuffer has changed and should 171 * be flushed to the display hardware. 172 * 173 * See documentation in drm_mode.h for the struct 174 * drm_mode_fb_dirty_cmd for more information as all 175 * the semantics and arguments have a one to one mapping 176 * on this function. 177 */ 178 int (*dirty)(struct drm_framebuffer *framebuffer, 179 struct drm_file *file_priv, unsigned flags, 180 unsigned color, struct drm_clip_rect *clips, 181 unsigned num_clips); 182 }; 183 184 struct drm_framebuffer { 185 struct drm_device *dev; 186 /* 187 * Note that the fb is refcounted for the benefit of driver internals, 188 * for example some hw, disabling a CRTC/plane is asynchronous, and 189 * scanout does not actually complete until the next vblank. So some 190 * cleanup (like releasing the reference(s) on the backing GEM bo(s)) 191 * should be deferred. In cases like this, the driver would like to 192 * hold a ref to the fb even though it has already been removed from 193 * userspace perspective. 194 */ 195 struct kref refcount; 196 /* 197 * Place on the dev->mode_config.fb_list, access protected by 198 * dev->mode_config.fb_lock. 199 */ 200 struct list_head head; 201 struct drm_mode_object base; 202 const struct drm_framebuffer_funcs *funcs; 203 unsigned int pitches[4]; 204 unsigned int offsets[4]; 205 unsigned int width; 206 unsigned int height; 207 /* depth can be 15 or 16 */ 208 unsigned int depth; 209 int bits_per_pixel; 210 int flags; 211 uint32_t pixel_format; /* fourcc format */ 212 struct list_head filp_head; 213 /* if you are using the helper */ 214 void *helper_private; 215 }; 216 217 struct drm_property_blob { 218 struct drm_mode_object base; 219 struct list_head head; 220 size_t length; 221 unsigned char data[]; 222 }; 223 224 struct drm_property_enum { 225 uint64_t value; 226 struct list_head head; 227 char name[DRM_PROP_NAME_LEN]; 228 }; 229 230 struct drm_property { 231 struct list_head head; 232 struct drm_mode_object base; 233 uint32_t flags; 234 char name[DRM_PROP_NAME_LEN]; 235 uint32_t num_values; 236 uint64_t *values; 237 struct drm_device *dev; 238 239 struct list_head enum_list; 240 }; 241 242 struct drm_crtc; 243 struct drm_connector; 244 struct drm_encoder; 245 struct drm_pending_vblank_event; 246 struct drm_plane; 247 struct drm_bridge; 248 struct drm_atomic_state; 249 250 /** 251 * struct drm_crtc_state - mutable CRTC state 252 * @crtc: backpointer to the CRTC 253 * @enable: whether the CRTC should be enabled, gates all other state 254 * @active: whether the CRTC is actively displaying (used for DPMS) 255 * @mode_changed: for use by helpers and drivers when computing state updates 256 * @plane_mask: bitmask of (1 << drm_plane_index(plane)) of attached planes 257 * @last_vblank_count: for helpers and drivers to capture the vblank of the 258 * update to ensure framebuffer cleanup isn't done too early 259 * @planes_changed: for use by helpers and drivers when computing state updates 260 * @adjusted_mode: for use by helpers and drivers to compute adjusted mode timings 261 * @mode: current mode timings 262 * @event: optional pointer to a DRM event to signal upon completion of the 263 * state update 264 * @state: backpointer to global drm_atomic_state 265 * 266 * Note that the distinction between @enable and @active is rather subtile: 267 * Flipping @active while @enable is set without changing anything else may 268 * never return in a failure from the ->atomic_check callback. Userspace assumes 269 * that a DPMS On will always succeed. In other words: @enable controls resource 270 * assignment, @active controls the actual hardware state. 271 */ 272 struct drm_crtc_state { 273 struct drm_crtc *crtc; 274 275 bool enable; 276 bool active; 277 278 /* computed state bits used by helpers and drivers */ 279 bool planes_changed : 1; 280 bool mode_changed : 1; 281 282 /* attached planes bitmask: 283 * WARNING: transitional helpers do not maintain plane_mask so 284 * drivers not converted over to atomic helpers should not rely 285 * on plane_mask being accurate! 286 */ 287 u32 plane_mask; 288 289 /* last_vblank_count: for vblank waits before cleanup */ 290 u32 last_vblank_count; 291 292 /* adjusted_mode: for use by helpers and drivers */ 293 struct drm_display_mode adjusted_mode; 294 295 struct drm_display_mode mode; 296 297 struct drm_pending_vblank_event *event; 298 299 struct drm_atomic_state *state; 300 }; 301 302 /** 303 * struct drm_crtc_funcs - control CRTCs for a given device 304 * @save: save CRTC state 305 * @restore: restore CRTC state 306 * @reset: reset CRTC after state has been invalidated (e.g. resume) 307 * @cursor_set: setup the cursor 308 * @cursor_set2: setup the cursor with hotspot, superseeds @cursor_set if set 309 * @cursor_move: move the cursor 310 * @gamma_set: specify color ramp for CRTC 311 * @destroy: deinit and free object 312 * @set_property: called when a property is changed 313 * @set_config: apply a new CRTC configuration 314 * @page_flip: initiate a page flip 315 * @atomic_duplicate_state: duplicate the atomic state for this CRTC 316 * @atomic_destroy_state: destroy an atomic state for this CRTC 317 * @atomic_set_property: set a property on an atomic state for this CRTC 318 * (do not call directly, use drm_atomic_crtc_set_property()) 319 * @atomic_get_property: get a property on an atomic state for this CRTC 320 * (do not call directly, use drm_atomic_crtc_get_property()) 321 * 322 * The drm_crtc_funcs structure is the central CRTC management structure 323 * in the DRM. Each CRTC controls one or more connectors (note that the name 324 * CRTC is simply historical, a CRTC may control LVDS, VGA, DVI, TV out, etc. 325 * connectors, not just CRTs). 326 * 327 * Each driver is responsible for filling out this structure at startup time, 328 * in addition to providing other modesetting features, like i2c and DDC 329 * bus accessors. 330 */ 331 struct drm_crtc_funcs { 332 /* Save CRTC state */ 333 void (*save)(struct drm_crtc *crtc); /* suspend? */ 334 /* Restore CRTC state */ 335 void (*restore)(struct drm_crtc *crtc); /* resume? */ 336 /* Reset CRTC state */ 337 void (*reset)(struct drm_crtc *crtc); 338 339 /* cursor controls */ 340 int (*cursor_set)(struct drm_crtc *crtc, struct drm_file *file_priv, 341 uint32_t handle, uint32_t width, uint32_t height); 342 int (*cursor_set2)(struct drm_crtc *crtc, struct drm_file *file_priv, 343 uint32_t handle, uint32_t width, uint32_t height, 344 int32_t hot_x, int32_t hot_y); 345 int (*cursor_move)(struct drm_crtc *crtc, int x, int y); 346 347 /* Set gamma on the CRTC */ 348 void (*gamma_set)(struct drm_crtc *crtc, u16 *r, u16 *g, u16 *b, 349 uint32_t start, uint32_t size); 350 /* Object destroy routine */ 351 void (*destroy)(struct drm_crtc *crtc); 352 353 int (*set_config)(struct drm_mode_set *set); 354 355 /* 356 * Flip to the given framebuffer. This implements the page 357 * flip ioctl described in drm_mode.h, specifically, the 358 * implementation must return immediately and block all 359 * rendering to the current fb until the flip has completed. 360 * If userspace set the event flag in the ioctl, the event 361 * argument will point to an event to send back when the flip 362 * completes, otherwise it will be NULL. 363 */ 364 int (*page_flip)(struct drm_crtc *crtc, 365 struct drm_framebuffer *fb, 366 struct drm_pending_vblank_event *event, 367 uint32_t flags); 368 369 int (*set_property)(struct drm_crtc *crtc, 370 struct drm_property *property, uint64_t val); 371 372 /* atomic update handling */ 373 struct drm_crtc_state *(*atomic_duplicate_state)(struct drm_crtc *crtc); 374 void (*atomic_destroy_state)(struct drm_crtc *crtc, 375 struct drm_crtc_state *state); 376 int (*atomic_set_property)(struct drm_crtc *crtc, 377 struct drm_crtc_state *state, 378 struct drm_property *property, 379 uint64_t val); 380 int (*atomic_get_property)(struct drm_crtc *crtc, 381 const struct drm_crtc_state *state, 382 struct drm_property *property, 383 uint64_t *val); 384 }; 385 386 /** 387 * struct drm_crtc - central CRTC control structure 388 * @dev: parent DRM device 389 * @port: OF node used by drm_of_find_possible_crtcs() 390 * @head: list management 391 * @mutex: per-CRTC locking 392 * @base: base KMS object for ID tracking etc. 393 * @primary: primary plane for this CRTC 394 * @cursor: cursor plane for this CRTC 395 * @cursor_x: current x position of the cursor, used for universal cursor planes 396 * @cursor_y: current y position of the cursor, used for universal cursor planes 397 * @enabled: is this CRTC enabled? 398 * @mode: current mode timings 399 * @hwmode: mode timings as programmed to hw regs 400 * @invert_dimensions: for purposes of error checking crtc vs fb sizes, 401 * invert the width/height of the crtc. This is used if the driver 402 * is performing 90 or 270 degree rotated scanout 403 * @x: x position on screen 404 * @y: y position on screen 405 * @funcs: CRTC control functions 406 * @gamma_size: size of gamma ramp 407 * @gamma_store: gamma ramp values 408 * @framedur_ns: precise frame timing 409 * @linedur_ns: precise line timing 410 * @pixeldur_ns: precise pixel timing 411 * @helper_private: mid-layer private data 412 * @properties: property tracking for this CRTC 413 * @state: current atomic state for this CRTC 414 * @acquire_ctx: per-CRTC implicit acquire context used by atomic drivers for 415 * legacy ioctls 416 * 417 * Each CRTC may have one or more connectors associated with it. This structure 418 * allows the CRTC to be controlled. 419 */ 420 struct drm_crtc { 421 struct drm_device *dev; 422 struct device_node *port; 423 struct list_head head; 424 425 /* 426 * crtc mutex 427 * 428 * This provides a read lock for the overall crtc state (mode, dpms 429 * state, ...) and a write lock for everything which can be update 430 * without a full modeset (fb, cursor data, ...) 431 */ 432 struct drm_modeset_lock mutex; 433 434 struct drm_mode_object base; 435 436 /* primary and cursor planes for CRTC */ 437 struct drm_plane *primary; 438 struct drm_plane *cursor; 439 440 /* position of cursor plane on crtc */ 441 int cursor_x; 442 int cursor_y; 443 444 bool enabled; 445 446 /* Requested mode from modesetting. */ 447 struct drm_display_mode mode; 448 449 /* Programmed mode in hw, after adjustments for encoders, 450 * crtc, panel scaling etc. Needed for timestamping etc. 451 */ 452 struct drm_display_mode hwmode; 453 454 bool invert_dimensions; 455 456 int x, y; 457 const struct drm_crtc_funcs *funcs; 458 459 /* CRTC gamma size for reporting to userspace */ 460 uint32_t gamma_size; 461 uint16_t *gamma_store; 462 463 /* Constants needed for precise vblank and swap timestamping. */ 464 int framedur_ns, linedur_ns, pixeldur_ns; 465 466 /* if you are using the helper */ 467 void *helper_private; 468 469 struct drm_object_properties properties; 470 471 struct drm_crtc_state *state; 472 473 /* 474 * For legacy crtc ioctls so that atomic drivers can get at the locking 475 * acquire context. 476 */ 477 struct drm_modeset_acquire_ctx *acquire_ctx; 478 }; 479 480 /** 481 * struct drm_connector_state - mutable connector state 482 * @connector: backpointer to the connector 483 * @crtc: CRTC to connect connector to, NULL if disabled 484 * @best_encoder: can be used by helpers and drivers to select the encoder 485 * @state: backpointer to global drm_atomic_state 486 */ 487 struct drm_connector_state { 488 struct drm_connector *connector; 489 490 struct drm_crtc *crtc; /* do not write directly, use drm_atomic_set_crtc_for_connector() */ 491 492 struct drm_encoder *best_encoder; 493 494 struct drm_atomic_state *state; 495 }; 496 497 /** 498 * struct drm_connector_funcs - control connectors on a given device 499 * @dpms: set power state 500 * @save: save connector state 501 * @restore: restore connector state 502 * @reset: reset connector after state has been invalidated (e.g. resume) 503 * @detect: is this connector active? 504 * @fill_modes: fill mode list for this connector 505 * @set_property: property for this connector may need an update 506 * @destroy: make object go away 507 * @force: notify the driver that the connector is forced on 508 * @atomic_duplicate_state: duplicate the atomic state for this connector 509 * @atomic_destroy_state: destroy an atomic state for this connector 510 * @atomic_set_property: set a property on an atomic state for this connector 511 * (do not call directly, use drm_atomic_connector_set_property()) 512 * @atomic_get_property: get a property on an atomic state for this connector 513 * (do not call directly, use drm_atomic_connector_get_property()) 514 * 515 * Each CRTC may have one or more connectors attached to it. The functions 516 * below allow the core DRM code to control connectors, enumerate available modes, 517 * etc. 518 */ 519 struct drm_connector_funcs { 520 void (*dpms)(struct drm_connector *connector, int mode); 521 void (*save)(struct drm_connector *connector); 522 void (*restore)(struct drm_connector *connector); 523 void (*reset)(struct drm_connector *connector); 524 525 /* Check to see if anything is attached to the connector. 526 * @force is set to false whilst polling, true when checking the 527 * connector due to user request. @force can be used by the driver 528 * to avoid expensive, destructive operations during automated 529 * probing. 530 */ 531 enum drm_connector_status (*detect)(struct drm_connector *connector, 532 bool force); 533 int (*fill_modes)(struct drm_connector *connector, uint32_t max_width, uint32_t max_height); 534 int (*set_property)(struct drm_connector *connector, struct drm_property *property, 535 uint64_t val); 536 void (*destroy)(struct drm_connector *connector); 537 void (*force)(struct drm_connector *connector); 538 539 /* atomic update handling */ 540 struct drm_connector_state *(*atomic_duplicate_state)(struct drm_connector *connector); 541 void (*atomic_destroy_state)(struct drm_connector *connector, 542 struct drm_connector_state *state); 543 int (*atomic_set_property)(struct drm_connector *connector, 544 struct drm_connector_state *state, 545 struct drm_property *property, 546 uint64_t val); 547 int (*atomic_get_property)(struct drm_connector *connector, 548 const struct drm_connector_state *state, 549 struct drm_property *property, 550 uint64_t *val); 551 }; 552 553 /** 554 * struct drm_encoder_funcs - encoder controls 555 * @reset: reset state (e.g. at init or resume time) 556 * @destroy: cleanup and free associated data 557 * 558 * Encoders sit between CRTCs and connectors. 559 */ 560 struct drm_encoder_funcs { 561 void (*reset)(struct drm_encoder *encoder); 562 void (*destroy)(struct drm_encoder *encoder); 563 }; 564 565 #define DRM_CONNECTOR_MAX_ENCODER 3 566 567 /** 568 * struct drm_encoder - central DRM encoder structure 569 * @dev: parent DRM device 570 * @head: list management 571 * @base: base KMS object 572 * @name: encoder name 573 * @encoder_type: one of the %DRM_MODE_ENCODER_<foo> types in drm_mode.h 574 * @possible_crtcs: bitmask of potential CRTC bindings 575 * @possible_clones: bitmask of potential sibling encoders for cloning 576 * @crtc: currently bound CRTC 577 * @bridge: bridge associated to the encoder 578 * @funcs: control functions 579 * @helper_private: mid-layer private data 580 * 581 * CRTCs drive pixels to encoders, which convert them into signals 582 * appropriate for a given connector or set of connectors. 583 */ 584 struct drm_encoder { 585 struct drm_device *dev; 586 struct list_head head; 587 588 struct drm_mode_object base; 589 char *name; 590 int encoder_type; 591 uint32_t possible_crtcs; 592 uint32_t possible_clones; 593 594 struct drm_crtc *crtc; 595 struct drm_bridge *bridge; 596 const struct drm_encoder_funcs *funcs; 597 void *helper_private; 598 }; 599 600 /* should we poll this connector for connects and disconnects */ 601 /* hot plug detectable */ 602 #define DRM_CONNECTOR_POLL_HPD (1 << 0) 603 /* poll for connections */ 604 #define DRM_CONNECTOR_POLL_CONNECT (1 << 1) 605 /* can cleanly poll for disconnections without flickering the screen */ 606 /* DACs should rarely do this without a lot of testing */ 607 #define DRM_CONNECTOR_POLL_DISCONNECT (1 << 2) 608 609 #define MAX_ELD_BYTES 128 610 611 /** 612 * struct drm_connector - central DRM connector control structure 613 * @dev: parent DRM device 614 * @kdev: kernel device for sysfs attributes 615 * @attr: sysfs attributes 616 * @head: list management 617 * @base: base KMS object 618 * @name: connector name 619 * @connector_type: one of the %DRM_MODE_CONNECTOR_<foo> types from drm_mode.h 620 * @connector_type_id: index into connector type enum 621 * @interlace_allowed: can this connector handle interlaced modes? 622 * @doublescan_allowed: can this connector handle doublescan? 623 * @stereo_allowed: can this connector handle stereo modes? 624 * @modes: modes available on this connector (from fill_modes() + user) 625 * @status: one of the drm_connector_status enums (connected, not, or unknown) 626 * @probed_modes: list of modes derived directly from the display 627 * @display_info: information about attached display (e.g. from EDID) 628 * @funcs: connector control functions 629 * @edid_blob_ptr: DRM property containing EDID if present 630 * @properties: property tracking for this connector 631 * @path_blob_ptr: DRM blob property data for the DP MST path property 632 * @polled: a %DRM_CONNECTOR_POLL_<foo> value for core driven polling 633 * @dpms: current dpms state 634 * @helper_private: mid-layer private data 635 * @cmdline_mode: mode line parsed from the kernel cmdline for this connector 636 * @force: a %DRM_FORCE_<foo> state for forced mode sets 637 * @override_edid: has the EDID been overwritten through debugfs for testing? 638 * @encoder_ids: valid encoders for this connector 639 * @encoder: encoder driving this connector, if any 640 * @eld: EDID-like data, if present 641 * @dvi_dual: dual link DVI, if found 642 * @max_tmds_clock: max clock rate, if found 643 * @latency_present: AV delay info from ELD, if found 644 * @video_latency: video latency info from ELD, if found 645 * @audio_latency: audio latency info from ELD, if found 646 * @null_edid_counter: track sinks that give us all zeros for the EDID 647 * @bad_edid_counter: track sinks that give us an EDID with invalid checksum 648 * @debugfs_entry: debugfs directory for this connector 649 * @state: current atomic state for this connector 650 * @has_tile: is this connector connected to a tiled monitor 651 * @tile_group: tile group for the connected monitor 652 * @tile_is_single_monitor: whether the tile is one monitor housing 653 * @num_h_tile: number of horizontal tiles in the tile group 654 * @num_v_tile: number of vertical tiles in the tile group 655 * @tile_h_loc: horizontal location of this tile 656 * @tile_v_loc: vertical location of this tile 657 * @tile_h_size: horizontal size of this tile. 658 * @tile_v_size: vertical size of this tile. 659 * 660 * Each connector may be connected to one or more CRTCs, or may be clonable by 661 * another connector if they can share a CRTC. Each connector also has a specific 662 * position in the broader display (referred to as a 'screen' though it could 663 * span multiple monitors). 664 */ 665 struct drm_connector { 666 struct drm_device *dev; 667 struct device *kdev; 668 struct device_attribute *attr; 669 struct list_head head; 670 671 struct drm_mode_object base; 672 673 char *name; 674 int connector_type; 675 int connector_type_id; 676 bool interlace_allowed; 677 bool doublescan_allowed; 678 bool stereo_allowed; 679 struct list_head modes; /* list of modes on this connector */ 680 681 enum drm_connector_status status; 682 683 /* these are modes added by probing with DDC or the BIOS */ 684 struct list_head probed_modes; 685 686 struct drm_display_info display_info; 687 const struct drm_connector_funcs *funcs; 688 689 struct drm_property_blob *edid_blob_ptr; 690 struct drm_object_properties properties; 691 692 struct drm_property_blob *path_blob_ptr; 693 694 struct drm_property_blob *tile_blob_ptr; 695 696 uint8_t polled; /* DRM_CONNECTOR_POLL_* */ 697 698 /* requested DPMS state */ 699 int dpms; 700 701 void *helper_private; 702 703 /* forced on connector */ 704 struct drm_cmdline_mode cmdline_mode; 705 enum drm_connector_force force; 706 bool override_edid; 707 uint32_t encoder_ids[DRM_CONNECTOR_MAX_ENCODER]; 708 struct drm_encoder *encoder; /* currently active encoder */ 709 710 /* EDID bits */ 711 uint8_t eld[MAX_ELD_BYTES]; 712 bool dvi_dual; 713 int max_tmds_clock; /* in MHz */ 714 bool latency_present[2]; 715 int video_latency[2]; /* [0]: progressive, [1]: interlaced */ 716 int audio_latency[2]; 717 int null_edid_counter; /* needed to workaround some HW bugs where we get all 0s */ 718 unsigned bad_edid_counter; 719 720 struct dentry *debugfs_entry; 721 722 struct drm_connector_state *state; 723 724 /* DisplayID bits */ 725 bool has_tile; 726 struct drm_tile_group *tile_group; 727 bool tile_is_single_monitor; 728 729 uint8_t num_h_tile, num_v_tile; 730 uint8_t tile_h_loc, tile_v_loc; 731 uint16_t tile_h_size, tile_v_size; 732 }; 733 734 /** 735 * struct drm_plane_state - mutable plane state 736 * @plane: backpointer to the plane 737 * @crtc: currently bound CRTC, NULL if disabled 738 * @fb: currently bound framebuffer 739 * @fence: optional fence to wait for before scanning out @fb 740 * @crtc_x: left position of visible portion of plane on crtc 741 * @crtc_y: upper position of visible portion of plane on crtc 742 * @crtc_w: width of visible portion of plane on crtc 743 * @crtc_h: height of visible portion of plane on crtc 744 * @src_x: left position of visible portion of plane within 745 * plane (in 16.16) 746 * @src_y: upper position of visible portion of plane within 747 * plane (in 16.16) 748 * @src_w: width of visible portion of plane (in 16.16) 749 * @src_h: height of visible portion of plane (in 16.16) 750 * @state: backpointer to global drm_atomic_state 751 */ 752 struct drm_plane_state { 753 struct drm_plane *plane; 754 755 struct drm_crtc *crtc; /* do not write directly, use drm_atomic_set_crtc_for_plane() */ 756 struct drm_framebuffer *fb; /* do not write directly, use drm_atomic_set_fb_for_plane() */ 757 struct fence *fence; 758 759 /* Signed dest location allows it to be partially off screen */ 760 int32_t crtc_x, crtc_y; 761 uint32_t crtc_w, crtc_h; 762 763 /* Source values are 16.16 fixed point */ 764 uint32_t src_x, src_y; 765 uint32_t src_h, src_w; 766 767 struct drm_atomic_state *state; 768 }; 769 770 771 /** 772 * struct drm_plane_funcs - driver plane control functions 773 * @update_plane: update the plane configuration 774 * @disable_plane: shut down the plane 775 * @destroy: clean up plane resources 776 * @reset: reset plane after state has been invalidated (e.g. resume) 777 * @set_property: called when a property is changed 778 * @atomic_duplicate_state: duplicate the atomic state for this plane 779 * @atomic_destroy_state: destroy an atomic state for this plane 780 * @atomic_set_property: set a property on an atomic state for this plane 781 * (do not call directly, use drm_atomic_plane_set_property()) 782 * @atomic_get_property: get a property on an atomic state for this plane 783 * (do not call directly, use drm_atomic_plane_get_property()) 784 */ 785 struct drm_plane_funcs { 786 int (*update_plane)(struct drm_plane *plane, 787 struct drm_crtc *crtc, struct drm_framebuffer *fb, 788 int crtc_x, int crtc_y, 789 unsigned int crtc_w, unsigned int crtc_h, 790 uint32_t src_x, uint32_t src_y, 791 uint32_t src_w, uint32_t src_h); 792 int (*disable_plane)(struct drm_plane *plane); 793 void (*destroy)(struct drm_plane *plane); 794 void (*reset)(struct drm_plane *plane); 795 796 int (*set_property)(struct drm_plane *plane, 797 struct drm_property *property, uint64_t val); 798 799 /* atomic update handling */ 800 struct drm_plane_state *(*atomic_duplicate_state)(struct drm_plane *plane); 801 void (*atomic_destroy_state)(struct drm_plane *plane, 802 struct drm_plane_state *state); 803 int (*atomic_set_property)(struct drm_plane *plane, 804 struct drm_plane_state *state, 805 struct drm_property *property, 806 uint64_t val); 807 int (*atomic_get_property)(struct drm_plane *plane, 808 const struct drm_plane_state *state, 809 struct drm_property *property, 810 uint64_t *val); 811 }; 812 813 enum drm_plane_type { 814 DRM_PLANE_TYPE_OVERLAY, 815 DRM_PLANE_TYPE_PRIMARY, 816 DRM_PLANE_TYPE_CURSOR, 817 }; 818 819 /** 820 * struct drm_plane - central DRM plane control structure 821 * @dev: DRM device this plane belongs to 822 * @head: for list management 823 * @base: base mode object 824 * @possible_crtcs: pipes this plane can be bound to 825 * @format_types: array of formats supported by this plane 826 * @format_count: number of formats supported 827 * @crtc: currently bound CRTC 828 * @fb: currently bound fb 829 * @old_fb: Temporary tracking of the old fb while a modeset is ongoing. Used by 830 * drm_mode_set_config_internal() to implement correct refcounting. 831 * @funcs: helper functions 832 * @properties: property tracking for this plane 833 * @type: type of plane (overlay, primary, cursor) 834 * @state: current atomic state for this plane 835 */ 836 struct drm_plane { 837 struct drm_device *dev; 838 struct list_head head; 839 840 struct drm_modeset_lock mutex; 841 842 struct drm_mode_object base; 843 844 uint32_t possible_crtcs; 845 uint32_t *format_types; 846 uint32_t format_count; 847 848 struct drm_crtc *crtc; 849 struct drm_framebuffer *fb; 850 851 struct drm_framebuffer *old_fb; 852 853 const struct drm_plane_funcs *funcs; 854 855 struct drm_object_properties properties; 856 857 enum drm_plane_type type; 858 859 void *helper_private; 860 861 struct drm_plane_state *state; 862 }; 863 864 /** 865 * struct drm_bridge_funcs - drm_bridge control functions 866 * @mode_fixup: Try to fixup (or reject entirely) proposed mode for this bridge 867 * @disable: Called right before encoder prepare, disables the bridge 868 * @post_disable: Called right after encoder prepare, for lockstepped disable 869 * @mode_set: Set this mode to the bridge 870 * @pre_enable: Called right before encoder commit, for lockstepped commit 871 * @enable: Called right after encoder commit, enables the bridge 872 * @destroy: make object go away 873 */ 874 struct drm_bridge_funcs { 875 bool (*mode_fixup)(struct drm_bridge *bridge, 876 const struct drm_display_mode *mode, 877 struct drm_display_mode *adjusted_mode); 878 void (*disable)(struct drm_bridge *bridge); 879 void (*post_disable)(struct drm_bridge *bridge); 880 void (*mode_set)(struct drm_bridge *bridge, 881 struct drm_display_mode *mode, 882 struct drm_display_mode *adjusted_mode); 883 void (*pre_enable)(struct drm_bridge *bridge); 884 void (*enable)(struct drm_bridge *bridge); 885 void (*destroy)(struct drm_bridge *bridge); 886 }; 887 888 /** 889 * struct drm_bridge - central DRM bridge control structure 890 * @dev: DRM device this bridge belongs to 891 * @head: list management 892 * @base: base mode object 893 * @funcs: control functions 894 * @driver_private: pointer to the bridge driver's internal context 895 */ 896 struct drm_bridge { 897 struct drm_device *dev; 898 struct list_head head; 899 900 struct drm_mode_object base; 901 902 const struct drm_bridge_funcs *funcs; 903 void *driver_private; 904 }; 905 906 /** 907 * struct struct drm_atomic_state - the global state object for atomic updates 908 * @dev: parent DRM device 909 * @allow_modeset: allow full modeset 910 * @planes: pointer to array of plane pointers 911 * @plane_states: pointer to array of plane states pointers 912 * @crtcs: pointer to array of CRTC pointers 913 * @crtc_states: pointer to array of CRTC states pointers 914 * @num_connector: size of the @connectors and @connector_states arrays 915 * @connectors: pointer to array of connector pointers 916 * @connector_states: pointer to array of connector states pointers 917 * @acquire_ctx: acquire context for this atomic modeset state update 918 */ 919 struct drm_atomic_state { 920 struct drm_device *dev; 921 bool allow_modeset : 1; 922 struct drm_plane **planes; 923 struct drm_plane_state **plane_states; 924 struct drm_crtc **crtcs; 925 struct drm_crtc_state **crtc_states; 926 int num_connector; 927 struct drm_connector **connectors; 928 struct drm_connector_state **connector_states; 929 930 struct drm_modeset_acquire_ctx *acquire_ctx; 931 }; 932 933 934 /** 935 * struct drm_mode_set - new values for a CRTC config change 936 * @fb: framebuffer to use for new config 937 * @crtc: CRTC whose configuration we're about to change 938 * @mode: mode timings to use 939 * @x: position of this CRTC relative to @fb 940 * @y: position of this CRTC relative to @fb 941 * @connectors: array of connectors to drive with this CRTC if possible 942 * @num_connectors: size of @connectors array 943 * 944 * Represents a single crtc the connectors that it drives with what mode 945 * and from which framebuffer it scans out from. 946 * 947 * This is used to set modes. 948 */ 949 struct drm_mode_set { 950 struct drm_framebuffer *fb; 951 struct drm_crtc *crtc; 952 struct drm_display_mode *mode; 953 954 uint32_t x; 955 uint32_t y; 956 957 struct drm_connector **connectors; 958 size_t num_connectors; 959 }; 960 961 /** 962 * struct drm_mode_config_funcs - basic driver provided mode setting functions 963 * @fb_create: create a new framebuffer object 964 * @output_poll_changed: function to handle output configuration changes 965 * @atomic_check: check whether a give atomic state update is possible 966 * @atomic_commit: commit an atomic state update previously verified with 967 * atomic_check() 968 * 969 * Some global (i.e. not per-CRTC, connector, etc) mode setting functions that 970 * involve drivers. 971 */ 972 struct drm_mode_config_funcs { 973 struct drm_framebuffer *(*fb_create)(struct drm_device *dev, 974 struct drm_file *file_priv, 975 struct drm_mode_fb_cmd2 *mode_cmd); 976 void (*output_poll_changed)(struct drm_device *dev); 977 978 int (*atomic_check)(struct drm_device *dev, 979 struct drm_atomic_state *a); 980 int (*atomic_commit)(struct drm_device *dev, 981 struct drm_atomic_state *a, 982 bool async); 983 }; 984 985 /** 986 * struct drm_mode_group - group of mode setting resources for potential sub-grouping 987 * @num_crtcs: CRTC count 988 * @num_encoders: encoder count 989 * @num_connectors: connector count 990 * @num_bridges: bridge count 991 * @id_list: list of KMS object IDs in this group 992 * 993 * Currently this simply tracks the global mode setting state. But in the 994 * future it could allow groups of objects to be set aside into independent 995 * control groups for use by different user level processes (e.g. two X servers 996 * running simultaneously on different heads, each with their own mode 997 * configuration and freedom of mode setting). 998 */ 999 struct drm_mode_group { 1000 uint32_t num_crtcs; 1001 uint32_t num_encoders; 1002 uint32_t num_connectors; 1003 uint32_t num_bridges; 1004 1005 /* list of object IDs for this group */ 1006 uint32_t *id_list; 1007 }; 1008 1009 /** 1010 * struct drm_mode_config - Mode configuration control structure 1011 * @mutex: mutex protecting KMS related lists and structures 1012 * @connection_mutex: ww mutex protecting connector state and routing 1013 * @acquire_ctx: global implicit acquire context used by atomic drivers for 1014 * legacy ioctls 1015 * @idr_mutex: mutex for KMS ID allocation and management 1016 * @crtc_idr: main KMS ID tracking object 1017 * @fb_lock: mutex to protect fb state and lists 1018 * @num_fb: number of fbs available 1019 * @fb_list: list of framebuffers available 1020 * @num_connector: number of connectors on this device 1021 * @connector_list: list of connector objects 1022 * @num_bridge: number of bridges on this device 1023 * @bridge_list: list of bridge objects 1024 * @num_encoder: number of encoders on this device 1025 * @encoder_list: list of encoder objects 1026 * @num_overlay_plane: number of overlay planes on this device 1027 * @num_total_plane: number of universal (i.e. with primary/curso) planes on this device 1028 * @plane_list: list of plane objects 1029 * @num_crtc: number of CRTCs on this device 1030 * @crtc_list: list of CRTC objects 1031 * @property_list: list of property objects 1032 * @min_width: minimum pixel width on this device 1033 * @min_height: minimum pixel height on this device 1034 * @max_width: maximum pixel width on this device 1035 * @max_height: maximum pixel height on this device 1036 * @funcs: core driver provided mode setting functions 1037 * @fb_base: base address of the framebuffer 1038 * @poll_enabled: track polling support for this device 1039 * @poll_running: track polling status for this device 1040 * @output_poll_work: delayed work for polling in process context 1041 * @property_blob_list: list of all the blob property objects 1042 * @*_property: core property tracking 1043 * @preferred_depth: preferred RBG pixel depth, used by fb helpers 1044 * @prefer_shadow: hint to userspace to prefer shadow-fb rendering 1045 * @async_page_flip: does this device support async flips on the primary plane? 1046 * @cursor_width: hint to userspace for max cursor width 1047 * @cursor_height: hint to userspace for max cursor height 1048 * 1049 * Core mode resource tracking structure. All CRTC, encoders, and connectors 1050 * enumerated by the driver are added here, as are global properties. Some 1051 * global restrictions are also here, e.g. dimension restrictions. 1052 */ 1053 struct drm_mode_config { 1054 struct mutex mutex; /* protects configuration (mode lists etc.) */ 1055 struct drm_modeset_lock connection_mutex; /* protects connector->encoder and encoder->crtc links */ 1056 struct drm_modeset_acquire_ctx *acquire_ctx; /* for legacy _lock_all() / _unlock_all() */ 1057 struct mutex idr_mutex; /* for IDR management */ 1058 struct idr crtc_idr; /* use this idr for all IDs, fb, crtc, connector, modes - just makes life easier */ 1059 struct idr tile_idr; /* use this idr for all IDs, fb, crtc, connector, modes - just makes life easier */ 1060 /* this is limited to one for now */ 1061 1062 struct mutex fb_lock; /* proctects global and per-file fb lists */ 1063 int num_fb; 1064 struct list_head fb_list; 1065 1066 int num_connector; 1067 struct list_head connector_list; 1068 int num_bridge; 1069 struct list_head bridge_list; 1070 int num_encoder; 1071 struct list_head encoder_list; 1072 1073 /* 1074 * Track # of overlay planes separately from # of total planes. By 1075 * default we only advertise overlay planes to userspace; if userspace 1076 * sets the "universal plane" capability bit, we'll go ahead and 1077 * expose all planes. 1078 */ 1079 int num_overlay_plane; 1080 int num_total_plane; 1081 struct list_head plane_list; 1082 1083 int num_crtc; 1084 struct list_head crtc_list; 1085 1086 struct list_head property_list; 1087 1088 int min_width, min_height; 1089 int max_width, max_height; 1090 const struct drm_mode_config_funcs *funcs; 1091 resource_size_t fb_base; 1092 1093 /* output poll support */ 1094 bool poll_enabled; 1095 bool poll_running; 1096 struct delayed_work output_poll_work; 1097 1098 /* pointers to standard properties */ 1099 struct list_head property_blob_list; 1100 struct drm_property *edid_property; 1101 struct drm_property *dpms_property; 1102 struct drm_property *path_property; 1103 struct drm_property *tile_property; 1104 struct drm_property *plane_type_property; 1105 struct drm_property *rotation_property; 1106 struct drm_property *prop_src_x; 1107 struct drm_property *prop_src_y; 1108 struct drm_property *prop_src_w; 1109 struct drm_property *prop_src_h; 1110 struct drm_property *prop_crtc_x; 1111 struct drm_property *prop_crtc_y; 1112 struct drm_property *prop_crtc_w; 1113 struct drm_property *prop_crtc_h; 1114 struct drm_property *prop_fb_id; 1115 struct drm_property *prop_crtc_id; 1116 1117 /* DVI-I properties */ 1118 struct drm_property *dvi_i_subconnector_property; 1119 struct drm_property *dvi_i_select_subconnector_property; 1120 1121 /* TV properties */ 1122 struct drm_property *tv_subconnector_property; 1123 struct drm_property *tv_select_subconnector_property; 1124 struct drm_property *tv_mode_property; 1125 struct drm_property *tv_left_margin_property; 1126 struct drm_property *tv_right_margin_property; 1127 struct drm_property *tv_top_margin_property; 1128 struct drm_property *tv_bottom_margin_property; 1129 struct drm_property *tv_brightness_property; 1130 struct drm_property *tv_contrast_property; 1131 struct drm_property *tv_flicker_reduction_property; 1132 struct drm_property *tv_overscan_property; 1133 struct drm_property *tv_saturation_property; 1134 struct drm_property *tv_hue_property; 1135 1136 /* Optional properties */ 1137 struct drm_property *scaling_mode_property; 1138 struct drm_property *aspect_ratio_property; 1139 struct drm_property *dirty_info_property; 1140 1141 /* properties for virtual machine layout */ 1142 struct drm_property *suggested_x_property; 1143 struct drm_property *suggested_y_property; 1144 1145 /* dumb ioctl parameters */ 1146 uint32_t preferred_depth, prefer_shadow; 1147 1148 /* whether async page flip is supported or not */ 1149 bool async_page_flip; 1150 1151 /* cursor size */ 1152 uint32_t cursor_width, cursor_height; 1153 }; 1154 1155 /** 1156 * drm_for_each_plane_mask - iterate over planes specified by bitmask 1157 * @plane: the loop cursor 1158 * @dev: the DRM device 1159 * @plane_mask: bitmask of plane indices 1160 * 1161 * Iterate over all planes specified by bitmask. 1162 */ 1163 #define drm_for_each_plane_mask(plane, dev, plane_mask) \ 1164 list_for_each_entry((plane), &(dev)->mode_config.plane_list, head) \ 1165 if ((plane_mask) & (1 << drm_plane_index(plane))) 1166 1167 1168 #define obj_to_crtc(x) container_of(x, struct drm_crtc, base) 1169 #define obj_to_connector(x) container_of(x, struct drm_connector, base) 1170 #define obj_to_encoder(x) container_of(x, struct drm_encoder, base) 1171 #define obj_to_mode(x) container_of(x, struct drm_display_mode, base) 1172 #define obj_to_fb(x) container_of(x, struct drm_framebuffer, base) 1173 #define obj_to_property(x) container_of(x, struct drm_property, base) 1174 #define obj_to_blob(x) container_of(x, struct drm_property_blob, base) 1175 #define obj_to_plane(x) container_of(x, struct drm_plane, base) 1176 1177 struct drm_prop_enum_list { 1178 int type; 1179 char *name; 1180 }; 1181 1182 extern int drm_crtc_init_with_planes(struct drm_device *dev, 1183 struct drm_crtc *crtc, 1184 struct drm_plane *primary, 1185 struct drm_plane *cursor, 1186 const struct drm_crtc_funcs *funcs); 1187 extern void drm_crtc_cleanup(struct drm_crtc *crtc); 1188 extern unsigned int drm_crtc_index(struct drm_crtc *crtc); 1189 1190 /** 1191 * drm_crtc_mask - find the mask of a registered CRTC 1192 * @crtc: CRTC to find mask for 1193 * 1194 * Given a registered CRTC, return the mask bit of that CRTC for an 1195 * encoder's possible_crtcs field. 1196 */ 1197 static inline uint32_t drm_crtc_mask(struct drm_crtc *crtc) 1198 { 1199 return 1 << drm_crtc_index(crtc); 1200 } 1201 1202 extern void drm_connector_ida_init(void); 1203 extern void drm_connector_ida_destroy(void); 1204 extern int drm_connector_init(struct drm_device *dev, 1205 struct drm_connector *connector, 1206 const struct drm_connector_funcs *funcs, 1207 int connector_type); 1208 int drm_connector_register(struct drm_connector *connector); 1209 void drm_connector_unregister(struct drm_connector *connector); 1210 1211 extern void drm_connector_cleanup(struct drm_connector *connector); 1212 extern unsigned int drm_connector_index(struct drm_connector *connector); 1213 /* helper to unplug all connectors from sysfs for device */ 1214 extern void drm_connector_unplug_all(struct drm_device *dev); 1215 1216 extern int drm_bridge_init(struct drm_device *dev, struct drm_bridge *bridge, 1217 const struct drm_bridge_funcs *funcs); 1218 extern void drm_bridge_cleanup(struct drm_bridge *bridge); 1219 1220 extern int drm_encoder_init(struct drm_device *dev, 1221 struct drm_encoder *encoder, 1222 const struct drm_encoder_funcs *funcs, 1223 int encoder_type); 1224 1225 /** 1226 * drm_encoder_crtc_ok - can a given crtc drive a given encoder? 1227 * @encoder: encoder to test 1228 * @crtc: crtc to test 1229 * 1230 * Return false if @encoder can't be driven by @crtc, true otherwise. 1231 */ 1232 static inline bool drm_encoder_crtc_ok(struct drm_encoder *encoder, 1233 struct drm_crtc *crtc) 1234 { 1235 return !!(encoder->possible_crtcs & drm_crtc_mask(crtc)); 1236 } 1237 1238 extern int drm_universal_plane_init(struct drm_device *dev, 1239 struct drm_plane *plane, 1240 unsigned long possible_crtcs, 1241 const struct drm_plane_funcs *funcs, 1242 const uint32_t *formats, 1243 uint32_t format_count, 1244 enum drm_plane_type type); 1245 extern int drm_plane_init(struct drm_device *dev, 1246 struct drm_plane *plane, 1247 unsigned long possible_crtcs, 1248 const struct drm_plane_funcs *funcs, 1249 const uint32_t *formats, uint32_t format_count, 1250 bool is_primary); 1251 extern void drm_plane_cleanup(struct drm_plane *plane); 1252 extern unsigned int drm_plane_index(struct drm_plane *plane); 1253 extern void drm_plane_force_disable(struct drm_plane *plane); 1254 extern void drm_crtc_get_hv_timing(const struct drm_display_mode *mode, 1255 int *hdisplay, int *vdisplay); 1256 extern int drm_crtc_check_viewport(const struct drm_crtc *crtc, 1257 int x, int y, 1258 const struct drm_display_mode *mode, 1259 const struct drm_framebuffer *fb); 1260 1261 extern void drm_encoder_cleanup(struct drm_encoder *encoder); 1262 1263 extern const char *drm_get_connector_status_name(enum drm_connector_status status); 1264 extern const char *drm_get_subpixel_order_name(enum subpixel_order order); 1265 extern const char *drm_get_dpms_name(int val); 1266 extern const char *drm_get_dvi_i_subconnector_name(int val); 1267 extern const char *drm_get_dvi_i_select_name(int val); 1268 extern const char *drm_get_tv_subconnector_name(int val); 1269 extern const char *drm_get_tv_select_name(int val); 1270 extern void drm_fb_release(struct drm_file *file_priv); 1271 extern int drm_mode_group_init_legacy_group(struct drm_device *dev, struct drm_mode_group *group); 1272 extern void drm_mode_group_destroy(struct drm_mode_group *group); 1273 extern void drm_reinit_primary_mode_group(struct drm_device *dev); 1274 extern bool drm_probe_ddc(struct i2c_adapter *adapter); 1275 extern struct edid *drm_get_edid(struct drm_connector *connector, 1276 struct i2c_adapter *adapter); 1277 extern struct edid *drm_edid_duplicate(const struct edid *edid); 1278 extern int drm_add_edid_modes(struct drm_connector *connector, struct edid *edid); 1279 extern void drm_mode_config_init(struct drm_device *dev); 1280 extern void drm_mode_config_reset(struct drm_device *dev); 1281 extern void drm_mode_config_cleanup(struct drm_device *dev); 1282 1283 extern int drm_mode_connector_set_path_property(struct drm_connector *connector, 1284 const char *path); 1285 int drm_mode_connector_set_tile_property(struct drm_connector *connector); 1286 extern int drm_mode_connector_update_edid_property(struct drm_connector *connector, 1287 const struct edid *edid); 1288 1289 extern int drm_display_info_set_bus_formats(struct drm_display_info *info, 1290 const u32 *formats, 1291 unsigned int num_formats); 1292 1293 static inline bool drm_property_type_is(struct drm_property *property, 1294 uint32_t type) 1295 { 1296 /* instanceof for props.. handles extended type vs original types: */ 1297 if (property->flags & DRM_MODE_PROP_EXTENDED_TYPE) 1298 return (property->flags & DRM_MODE_PROP_EXTENDED_TYPE) == type; 1299 return property->flags & type; 1300 } 1301 1302 static inline bool drm_property_type_valid(struct drm_property *property) 1303 { 1304 if (property->flags & DRM_MODE_PROP_EXTENDED_TYPE) 1305 return !(property->flags & DRM_MODE_PROP_LEGACY_TYPE); 1306 return !!(property->flags & DRM_MODE_PROP_LEGACY_TYPE); 1307 } 1308 1309 extern int drm_object_property_set_value(struct drm_mode_object *obj, 1310 struct drm_property *property, 1311 uint64_t val); 1312 extern int drm_object_property_get_value(struct drm_mode_object *obj, 1313 struct drm_property *property, 1314 uint64_t *value); 1315 extern int drm_framebuffer_init(struct drm_device *dev, 1316 struct drm_framebuffer *fb, 1317 const struct drm_framebuffer_funcs *funcs); 1318 extern struct drm_framebuffer *drm_framebuffer_lookup(struct drm_device *dev, 1319 uint32_t id); 1320 extern void drm_framebuffer_unreference(struct drm_framebuffer *fb); 1321 extern void drm_framebuffer_reference(struct drm_framebuffer *fb); 1322 extern void drm_framebuffer_remove(struct drm_framebuffer *fb); 1323 extern void drm_framebuffer_cleanup(struct drm_framebuffer *fb); 1324 extern void drm_framebuffer_unregister_private(struct drm_framebuffer *fb); 1325 1326 extern void drm_object_attach_property(struct drm_mode_object *obj, 1327 struct drm_property *property, 1328 uint64_t init_val); 1329 extern struct drm_property *drm_property_create(struct drm_device *dev, int flags, 1330 const char *name, int num_values); 1331 extern struct drm_property *drm_property_create_enum(struct drm_device *dev, int flags, 1332 const char *name, 1333 const struct drm_prop_enum_list *props, 1334 int num_values); 1335 struct drm_property *drm_property_create_bitmask(struct drm_device *dev, 1336 int flags, const char *name, 1337 const struct drm_prop_enum_list *props, 1338 int num_props, 1339 uint64_t supported_bits); 1340 struct drm_property *drm_property_create_range(struct drm_device *dev, int flags, 1341 const char *name, 1342 uint64_t min, uint64_t max); 1343 struct drm_property *drm_property_create_signed_range(struct drm_device *dev, 1344 int flags, const char *name, 1345 int64_t min, int64_t max); 1346 struct drm_property *drm_property_create_object(struct drm_device *dev, 1347 int flags, const char *name, uint32_t type); 1348 extern void drm_property_destroy(struct drm_device *dev, struct drm_property *property); 1349 extern int drm_property_add_enum(struct drm_property *property, int index, 1350 uint64_t value, const char *name); 1351 extern int drm_mode_create_dvi_i_properties(struct drm_device *dev); 1352 extern int drm_mode_create_tv_properties(struct drm_device *dev, 1353 unsigned int num_modes, 1354 char *modes[]); 1355 extern int drm_mode_create_scaling_mode_property(struct drm_device *dev); 1356 extern int drm_mode_create_aspect_ratio_property(struct drm_device *dev); 1357 extern int drm_mode_create_dirty_info_property(struct drm_device *dev); 1358 extern int drm_mode_create_suggested_offset_properties(struct drm_device *dev); 1359 extern bool drm_property_change_valid_get(struct drm_property *property, 1360 uint64_t value, struct drm_mode_object **ref); 1361 extern void drm_property_change_valid_put(struct drm_property *property, 1362 struct drm_mode_object *ref); 1363 1364 extern int drm_mode_connector_attach_encoder(struct drm_connector *connector, 1365 struct drm_encoder *encoder); 1366 extern int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc, 1367 int gamma_size); 1368 extern struct drm_mode_object *drm_mode_object_find(struct drm_device *dev, 1369 uint32_t id, uint32_t type); 1370 1371 /* IOCTLs */ 1372 extern int drm_mode_getresources(struct drm_device *dev, 1373 void *data, struct drm_file *file_priv); 1374 extern int drm_mode_getplane_res(struct drm_device *dev, void *data, 1375 struct drm_file *file_priv); 1376 extern int drm_mode_getcrtc(struct drm_device *dev, 1377 void *data, struct drm_file *file_priv); 1378 extern int drm_mode_getconnector(struct drm_device *dev, 1379 void *data, struct drm_file *file_priv); 1380 extern int drm_mode_set_config_internal(struct drm_mode_set *set); 1381 extern int drm_mode_setcrtc(struct drm_device *dev, 1382 void *data, struct drm_file *file_priv); 1383 extern int drm_mode_getplane(struct drm_device *dev, 1384 void *data, struct drm_file *file_priv); 1385 extern int drm_mode_setplane(struct drm_device *dev, 1386 void *data, struct drm_file *file_priv); 1387 extern int drm_mode_cursor_ioctl(struct drm_device *dev, 1388 void *data, struct drm_file *file_priv); 1389 extern int drm_mode_cursor2_ioctl(struct drm_device *dev, 1390 void *data, struct drm_file *file_priv); 1391 extern int drm_mode_addfb(struct drm_device *dev, 1392 void *data, struct drm_file *file_priv); 1393 extern int drm_mode_addfb2(struct drm_device *dev, 1394 void *data, struct drm_file *file_priv); 1395 extern uint32_t drm_mode_legacy_fb_format(uint32_t bpp, uint32_t depth); 1396 extern int drm_mode_rmfb(struct drm_device *dev, 1397 void *data, struct drm_file *file_priv); 1398 extern int drm_mode_getfb(struct drm_device *dev, 1399 void *data, struct drm_file *file_priv); 1400 extern int drm_mode_dirtyfb_ioctl(struct drm_device *dev, 1401 void *data, struct drm_file *file_priv); 1402 1403 extern int drm_mode_getproperty_ioctl(struct drm_device *dev, 1404 void *data, struct drm_file *file_priv); 1405 extern int drm_mode_getblob_ioctl(struct drm_device *dev, 1406 void *data, struct drm_file *file_priv); 1407 extern int drm_mode_connector_property_set_ioctl(struct drm_device *dev, 1408 void *data, struct drm_file *file_priv); 1409 extern int drm_mode_getencoder(struct drm_device *dev, 1410 void *data, struct drm_file *file_priv); 1411 extern int drm_mode_gamma_get_ioctl(struct drm_device *dev, 1412 void *data, struct drm_file *file_priv); 1413 extern int drm_mode_gamma_set_ioctl(struct drm_device *dev, 1414 void *data, struct drm_file *file_priv); 1415 extern u8 drm_match_cea_mode(const struct drm_display_mode *to_match); 1416 extern enum hdmi_picture_aspect drm_get_cea_aspect_ratio(const u8 video_code); 1417 extern bool drm_detect_hdmi_monitor(struct edid *edid); 1418 extern bool drm_detect_monitor_audio(struct edid *edid); 1419 extern bool drm_rgb_quant_range_selectable(struct edid *edid); 1420 extern int drm_mode_page_flip_ioctl(struct drm_device *dev, 1421 void *data, struct drm_file *file_priv); 1422 extern int drm_add_modes_noedid(struct drm_connector *connector, 1423 int hdisplay, int vdisplay); 1424 extern void drm_set_preferred_mode(struct drm_connector *connector, 1425 int hpref, int vpref); 1426 1427 extern int drm_edid_header_is_valid(const u8 *raw_edid); 1428 extern bool drm_edid_block_valid(u8 *raw_edid, int block, bool print_bad_edid); 1429 extern bool drm_edid_is_valid(struct edid *edid); 1430 1431 extern struct drm_tile_group *drm_mode_create_tile_group(struct drm_device *dev, 1432 char topology[8]); 1433 extern struct drm_tile_group *drm_mode_get_tile_group(struct drm_device *dev, 1434 char topology[8]); 1435 extern void drm_mode_put_tile_group(struct drm_device *dev, 1436 struct drm_tile_group *tg); 1437 struct drm_display_mode *drm_mode_find_dmt(struct drm_device *dev, 1438 int hsize, int vsize, int fresh, 1439 bool rb); 1440 1441 extern int drm_mode_create_dumb_ioctl(struct drm_device *dev, 1442 void *data, struct drm_file *file_priv); 1443 extern int drm_mode_mmap_dumb_ioctl(struct drm_device *dev, 1444 void *data, struct drm_file *file_priv); 1445 extern int drm_mode_destroy_dumb_ioctl(struct drm_device *dev, 1446 void *data, struct drm_file *file_priv); 1447 extern int drm_mode_obj_get_properties_ioctl(struct drm_device *dev, void *data, 1448 struct drm_file *file_priv); 1449 extern int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data, 1450 struct drm_file *file_priv); 1451 extern int drm_mode_plane_set_obj_prop(struct drm_plane *plane, 1452 struct drm_property *property, 1453 uint64_t value); 1454 extern int drm_mode_atomic_ioctl(struct drm_device *dev, 1455 void *data, struct drm_file *file_priv); 1456 1457 extern void drm_fb_get_bpp_depth(uint32_t format, unsigned int *depth, 1458 int *bpp); 1459 extern int drm_format_num_planes(uint32_t format); 1460 extern int drm_format_plane_cpp(uint32_t format, int plane); 1461 extern int drm_format_horz_chroma_subsampling(uint32_t format); 1462 extern int drm_format_vert_chroma_subsampling(uint32_t format); 1463 extern const char *drm_get_format_name(uint32_t format); 1464 extern struct drm_property *drm_mode_create_rotation_property(struct drm_device *dev, 1465 unsigned int supported_rotations); 1466 extern unsigned int drm_rotation_simplify(unsigned int rotation, 1467 unsigned int supported_rotations); 1468 1469 /* Helpers */ 1470 1471 static inline struct drm_plane *drm_plane_find(struct drm_device *dev, 1472 uint32_t id) 1473 { 1474 struct drm_mode_object *mo; 1475 mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_PLANE); 1476 return mo ? obj_to_plane(mo) : NULL; 1477 } 1478 1479 static inline struct drm_crtc *drm_crtc_find(struct drm_device *dev, 1480 uint32_t id) 1481 { 1482 struct drm_mode_object *mo; 1483 mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_CRTC); 1484 return mo ? obj_to_crtc(mo) : NULL; 1485 } 1486 1487 static inline struct drm_encoder *drm_encoder_find(struct drm_device *dev, 1488 uint32_t id) 1489 { 1490 struct drm_mode_object *mo; 1491 mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_ENCODER); 1492 return mo ? obj_to_encoder(mo) : NULL; 1493 } 1494 1495 static inline struct drm_connector *drm_connector_find(struct drm_device *dev, 1496 uint32_t id) 1497 { 1498 struct drm_mode_object *mo; 1499 mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_CONNECTOR); 1500 return mo ? obj_to_connector(mo) : NULL; 1501 } 1502 1503 static inline struct drm_property *drm_property_find(struct drm_device *dev, 1504 uint32_t id) 1505 { 1506 struct drm_mode_object *mo; 1507 mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_PROPERTY); 1508 return mo ? obj_to_property(mo) : NULL; 1509 } 1510 1511 static inline struct drm_property_blob * 1512 drm_property_blob_find(struct drm_device *dev, uint32_t id) 1513 { 1514 struct drm_mode_object *mo; 1515 mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_BLOB); 1516 return mo ? obj_to_blob(mo) : NULL; 1517 } 1518 1519 /* Plane list iterator for legacy (overlay only) planes. */ 1520 #define drm_for_each_legacy_plane(plane, planelist) \ 1521 list_for_each_entry(plane, planelist, head) \ 1522 if (plane->type == DRM_PLANE_TYPE_OVERLAY) 1523 1524 #endif /* __DRM_CRTC_H__ */ 1525