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