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 <drm/drm_mode.h> 35 #include <drm/drm_fourcc.h> 36 37 struct drm_device; 38 struct drm_mode_set; 39 struct drm_framebuffer; 40 struct drm_object_properties; 41 struct drm_file; 42 struct drm_clip_rect; 43 44 #define DRM_MODE_OBJECT_CRTC 0xcccccccc 45 #define DRM_MODE_OBJECT_CONNECTOR 0xc0c0c0c0 46 #define DRM_MODE_OBJECT_ENCODER 0xe0e0e0e0 47 #define DRM_MODE_OBJECT_MODE 0xdededede 48 #define DRM_MODE_OBJECT_PROPERTY 0xb0b0b0b0 49 #define DRM_MODE_OBJECT_FB 0xfbfbfbfb 50 #define DRM_MODE_OBJECT_BLOB 0xbbbbbbbb 51 #define DRM_MODE_OBJECT_PLANE 0xeeeeeeee 52 #define DRM_MODE_OBJECT_BRIDGE 0xbdbdbdbd 53 54 struct drm_mode_object { 55 uint32_t id; 56 uint32_t type; 57 struct drm_object_properties *properties; 58 }; 59 60 #define DRM_OBJECT_MAX_PROPERTY 24 61 struct drm_object_properties { 62 int count; 63 uint32_t ids[DRM_OBJECT_MAX_PROPERTY]; 64 uint64_t values[DRM_OBJECT_MAX_PROPERTY]; 65 }; 66 67 enum drm_connector_force { 68 DRM_FORCE_UNSPECIFIED, 69 DRM_FORCE_OFF, 70 DRM_FORCE_ON, /* force on analog part normally */ 71 DRM_FORCE_ON_DIGITAL, /* for DVI-I use digital connector */ 72 }; 73 74 #include <drm/drm_modes.h> 75 76 enum drm_connector_status { 77 connector_status_connected = 1, 78 connector_status_disconnected = 2, 79 connector_status_unknown = 3, 80 }; 81 82 enum subpixel_order { 83 SubPixelUnknown = 0, 84 SubPixelHorizontalRGB, 85 SubPixelHorizontalBGR, 86 SubPixelVerticalRGB, 87 SubPixelVerticalBGR, 88 SubPixelNone, 89 }; 90 91 #define DRM_COLOR_FORMAT_RGB444 (1<<0) 92 #define DRM_COLOR_FORMAT_YCRCB444 (1<<1) 93 #define DRM_COLOR_FORMAT_YCRCB422 (1<<2) 94 /* 95 * Describes a given display (e.g. CRT or flat panel) and its limitations. 96 */ 97 struct drm_display_info { 98 char name[DRM_DISPLAY_INFO_LEN]; 99 100 /* Physical size */ 101 unsigned int width_mm; 102 unsigned int height_mm; 103 104 /* Clock limits FIXME: storage format */ 105 unsigned int min_vfreq, max_vfreq; 106 unsigned int min_hfreq, max_hfreq; 107 unsigned int pixel_clock; 108 unsigned int bpc; 109 110 enum subpixel_order subpixel_order; 111 u32 color_formats; 112 113 u8 cea_rev; 114 }; 115 116 struct drm_framebuffer_funcs { 117 /* note: use drm_framebuffer_remove() */ 118 void (*destroy)(struct drm_framebuffer *framebuffer); 119 int (*create_handle)(struct drm_framebuffer *fb, 120 struct drm_file *file_priv, 121 unsigned int *handle); 122 /** 123 * Optinal callback for the dirty fb ioctl. 124 * 125 * Userspace can notify the driver via this callback 126 * that a area of the framebuffer has changed and should 127 * be flushed to the display hardware. 128 * 129 * See documentation in drm_mode.h for the struct 130 * drm_mode_fb_dirty_cmd for more information as all 131 * the semantics and arguments have a one to one mapping 132 * on this function. 133 */ 134 int (*dirty)(struct drm_framebuffer *framebuffer, 135 struct drm_file *file_priv, unsigned flags, 136 unsigned color, struct drm_clip_rect *clips, 137 unsigned num_clips); 138 }; 139 140 struct drm_framebuffer { 141 struct drm_device *dev; 142 /* 143 * Note that the fb is refcounted for the benefit of driver internals, 144 * for example some hw, disabling a CRTC/plane is asynchronous, and 145 * scanout does not actually complete until the next vblank. So some 146 * cleanup (like releasing the reference(s) on the backing GEM bo(s)) 147 * should be deferred. In cases like this, the driver would like to 148 * hold a ref to the fb even though it has already been removed from 149 * userspace perspective. 150 */ 151 struct kref refcount; 152 /* 153 * Place on the dev->mode_config.fb_list, access protected by 154 * dev->mode_config.fb_lock. 155 */ 156 struct list_head head; 157 struct drm_mode_object base; 158 const struct drm_framebuffer_funcs *funcs; 159 unsigned int pitches[4]; 160 unsigned int offsets[4]; 161 unsigned int width; 162 unsigned int height; 163 /* depth can be 15 or 16 */ 164 unsigned int depth; 165 int bits_per_pixel; 166 int flags; 167 uint32_t pixel_format; /* fourcc format */ 168 struct list_head filp_head; 169 /* if you are using the helper */ 170 void *helper_private; 171 }; 172 173 struct drm_property_blob { 174 struct drm_mode_object base; 175 struct list_head head; 176 unsigned int length; 177 unsigned char data[]; 178 }; 179 180 struct drm_property_enum { 181 uint64_t value; 182 struct list_head head; 183 char name[DRM_PROP_NAME_LEN]; 184 }; 185 186 struct drm_property { 187 struct list_head head; 188 struct drm_mode_object base; 189 uint32_t flags; 190 char name[DRM_PROP_NAME_LEN]; 191 uint32_t num_values; 192 uint64_t *values; 193 194 struct list_head enum_blob_list; 195 }; 196 197 struct drm_crtc; 198 struct drm_connector; 199 struct drm_encoder; 200 struct drm_pending_vblank_event; 201 struct drm_plane; 202 struct drm_bridge; 203 204 /** 205 * drm_crtc_funcs - control CRTCs for a given device 206 * @save: save CRTC state 207 * @restore: restore CRTC state 208 * @reset: reset CRTC after state has been invalidated (e.g. resume) 209 * @cursor_set: setup the cursor 210 * @cursor_move: move the cursor 211 * @gamma_set: specify color ramp for CRTC 212 * @destroy: deinit and free object 213 * @set_property: called when a property is changed 214 * @set_config: apply a new CRTC configuration 215 * @page_flip: initiate a page flip 216 * 217 * The drm_crtc_funcs structure is the central CRTC management structure 218 * in the DRM. Each CRTC controls one or more connectors (note that the name 219 * CRTC is simply historical, a CRTC may control LVDS, VGA, DVI, TV out, etc. 220 * connectors, not just CRTs). 221 * 222 * Each driver is responsible for filling out this structure at startup time, 223 * in addition to providing other modesetting features, like i2c and DDC 224 * bus accessors. 225 */ 226 struct drm_crtc_funcs { 227 /* Save CRTC state */ 228 void (*save)(struct drm_crtc *crtc); /* suspend? */ 229 /* Restore CRTC state */ 230 void (*restore)(struct drm_crtc *crtc); /* resume? */ 231 /* Reset CRTC state */ 232 void (*reset)(struct drm_crtc *crtc); 233 234 /* cursor controls */ 235 int (*cursor_set)(struct drm_crtc *crtc, struct drm_file *file_priv, 236 uint32_t handle, uint32_t width, uint32_t height); 237 int (*cursor_set2)(struct drm_crtc *crtc, struct drm_file *file_priv, 238 uint32_t handle, uint32_t width, uint32_t height, 239 int32_t hot_x, int32_t hot_y); 240 int (*cursor_move)(struct drm_crtc *crtc, int x, int y); 241 242 /* Set gamma on the CRTC */ 243 void (*gamma_set)(struct drm_crtc *crtc, u16 *r, u16 *g, u16 *b, 244 uint32_t start, uint32_t size); 245 /* Object destroy routine */ 246 void (*destroy)(struct drm_crtc *crtc); 247 248 int (*set_config)(struct drm_mode_set *set); 249 250 /* 251 * Flip to the given framebuffer. This implements the page 252 * flip ioctl described in drm_mode.h, specifically, the 253 * implementation must return immediately and block all 254 * rendering to the current fb until the flip has completed. 255 * If userspace set the event flag in the ioctl, the event 256 * argument will point to an event to send back when the flip 257 * completes, otherwise it will be NULL. 258 */ 259 int (*page_flip)(struct drm_crtc *crtc, 260 struct drm_framebuffer *fb, 261 struct drm_pending_vblank_event *event, 262 uint32_t flags); 263 264 int (*set_property)(struct drm_crtc *crtc, 265 struct drm_property *property, uint64_t val); 266 }; 267 268 /** 269 * drm_crtc - central CRTC control structure 270 * @dev: parent DRM device 271 * @head: list management 272 * @base: base KMS object for ID tracking etc. 273 * @primary: primary plane for this CRTC 274 * @cursor: cursor plane for this CRTC 275 * @enabled: is this CRTC enabled? 276 * @mode: current mode timings 277 * @hwmode: mode timings as programmed to hw regs 278 * @invert_dimensions: for purposes of error checking crtc vs fb sizes, 279 * invert the width/height of the crtc. This is used if the driver 280 * is performing 90 or 270 degree rotated scanout 281 * @x: x position on screen 282 * @y: y position on screen 283 * @funcs: CRTC control functions 284 * @gamma_size: size of gamma ramp 285 * @gamma_store: gamma ramp values 286 * @framedur_ns: precise frame timing 287 * @framedur_ns: precise line timing 288 * @pixeldur_ns: precise pixel timing 289 * @helper_private: mid-layer private data 290 * @properties: property tracking for this CRTC 291 * 292 * Each CRTC may have one or more connectors associated with it. This structure 293 * allows the CRTC to be controlled. 294 */ 295 struct drm_crtc { 296 struct drm_device *dev; 297 struct list_head head; 298 299 /** 300 * crtc mutex 301 * 302 * This provides a read lock for the overall crtc state (mode, dpms 303 * state, ...) and a write lock for everything which can be update 304 * without a full modeset (fb, cursor data, ...) 305 */ 306 struct mutex mutex; 307 308 struct drm_mode_object base; 309 310 /* primary and cursor planes for CRTC */ 311 struct drm_plane *primary; 312 struct drm_plane *cursor; 313 314 /* Temporary tracking of the old fb while a modeset is ongoing. Used 315 * by drm_mode_set_config_internal to implement correct refcounting. */ 316 struct drm_framebuffer *old_fb; 317 318 bool enabled; 319 320 /* Requested mode from modesetting. */ 321 struct drm_display_mode mode; 322 323 /* Programmed mode in hw, after adjustments for encoders, 324 * crtc, panel scaling etc. Needed for timestamping etc. 325 */ 326 struct drm_display_mode hwmode; 327 328 bool invert_dimensions; 329 330 int x, y; 331 const struct drm_crtc_funcs *funcs; 332 333 /* CRTC gamma size for reporting to userspace */ 334 uint32_t gamma_size; 335 uint16_t *gamma_store; 336 337 /* Constants needed for precise vblank and swap timestamping. */ 338 int framedur_ns, linedur_ns, pixeldur_ns; 339 340 /* if you are using the helper */ 341 void *helper_private; 342 343 struct drm_object_properties properties; 344 }; 345 346 347 /** 348 * drm_connector_funcs - control connectors on a given device 349 * @dpms: set power state (see drm_crtc_funcs above) 350 * @save: save connector state 351 * @restore: restore connector state 352 * @reset: reset connector after state has been invalidated (e.g. resume) 353 * @detect: is this connector active? 354 * @fill_modes: fill mode list for this connector 355 * @set_property: property for this connector may need an update 356 * @destroy: make object go away 357 * @force: notify the driver that the connector is forced on 358 * 359 * Each CRTC may have one or more connectors attached to it. The functions 360 * below allow the core DRM code to control connectors, enumerate available modes, 361 * etc. 362 */ 363 struct drm_connector_funcs { 364 void (*dpms)(struct drm_connector *connector, int mode); 365 void (*save)(struct drm_connector *connector); 366 void (*restore)(struct drm_connector *connector); 367 void (*reset)(struct drm_connector *connector); 368 369 /* Check to see if anything is attached to the connector. 370 * @force is set to false whilst polling, true when checking the 371 * connector due to user request. @force can be used by the driver 372 * to avoid expensive, destructive operations during automated 373 * probing. 374 */ 375 enum drm_connector_status (*detect)(struct drm_connector *connector, 376 bool force); 377 int (*fill_modes)(struct drm_connector *connector, uint32_t max_width, uint32_t max_height); 378 int (*set_property)(struct drm_connector *connector, struct drm_property *property, 379 uint64_t val); 380 void (*destroy)(struct drm_connector *connector); 381 void (*force)(struct drm_connector *connector); 382 }; 383 384 /** 385 * drm_encoder_funcs - encoder controls 386 * @reset: reset state (e.g. at init or resume time) 387 * @destroy: cleanup and free associated data 388 * 389 * Encoders sit between CRTCs and connectors. 390 */ 391 struct drm_encoder_funcs { 392 void (*reset)(struct drm_encoder *encoder); 393 void (*destroy)(struct drm_encoder *encoder); 394 }; 395 396 #define DRM_CONNECTOR_MAX_ENCODER 3 397 398 /** 399 * drm_encoder - central DRM encoder structure 400 * @dev: parent DRM device 401 * @head: list management 402 * @base: base KMS object 403 * @encoder_type: one of the %DRM_MODE_ENCODER_<foo> types in drm_mode.h 404 * @possible_crtcs: bitmask of potential CRTC bindings 405 * @possible_clones: bitmask of potential sibling encoders for cloning 406 * @crtc: currently bound CRTC 407 * @bridge: bridge associated to the encoder 408 * @funcs: control functions 409 * @helper_private: mid-layer private data 410 * 411 * CRTCs drive pixels to encoders, which convert them into signals 412 * appropriate for a given connector or set of connectors. 413 */ 414 struct drm_encoder { 415 struct drm_device *dev; 416 struct list_head head; 417 418 struct drm_mode_object base; 419 int encoder_type; 420 uint32_t possible_crtcs; 421 uint32_t possible_clones; 422 423 struct drm_crtc *crtc; 424 struct drm_bridge *bridge; 425 const struct drm_encoder_funcs *funcs; 426 void *helper_private; 427 }; 428 429 /* should we poll this connector for connects and disconnects */ 430 /* hot plug detectable */ 431 #define DRM_CONNECTOR_POLL_HPD (1 << 0) 432 /* poll for connections */ 433 #define DRM_CONNECTOR_POLL_CONNECT (1 << 1) 434 /* can cleanly poll for disconnections without flickering the screen */ 435 /* DACs should rarely do this without a lot of testing */ 436 #define DRM_CONNECTOR_POLL_DISCONNECT (1 << 2) 437 438 #define MAX_ELD_BYTES 128 439 440 /** 441 * drm_connector - central DRM connector control structure 442 * @dev: parent DRM device 443 * @kdev: kernel device for sysfs attributes 444 * @attr: sysfs attributes 445 * @head: list management 446 * @base: base KMS object 447 * @connector_type: one of the %DRM_MODE_CONNECTOR_<foo> types from drm_mode.h 448 * @connector_type_id: index into connector type enum 449 * @interlace_allowed: can this connector handle interlaced modes? 450 * @doublescan_allowed: can this connector handle doublescan? 451 * @modes: modes available on this connector (from fill_modes() + user) 452 * @status: one of the drm_connector_status enums (connected, not, or unknown) 453 * @probed_modes: list of modes derived directly from the display 454 * @display_info: information about attached display (e.g. from EDID) 455 * @funcs: connector control functions 456 * @edid_blob_ptr: DRM property containing EDID if present 457 * @properties: property tracking for this connector 458 * @polled: a %DRM_CONNECTOR_POLL_<foo> value for core driven polling 459 * @dpms: current dpms state 460 * @helper_private: mid-layer private data 461 * @force: a %DRM_FORCE_<foo> state for forced mode sets 462 * @encoder_ids: valid encoders for this connector 463 * @encoder: encoder driving this connector, if any 464 * @eld: EDID-like data, if present 465 * @dvi_dual: dual link DVI, if found 466 * @max_tmds_clock: max clock rate, if found 467 * @latency_present: AV delay info from ELD, if found 468 * @video_latency: video latency info from ELD, if found 469 * @audio_latency: audio latency info from ELD, if found 470 * @null_edid_counter: track sinks that give us all zeros for the EDID 471 * 472 * Each connector may be connected to one or more CRTCs, or may be clonable by 473 * another connector if they can share a CRTC. Each connector also has a specific 474 * position in the broader display (referred to as a 'screen' though it could 475 * span multiple monitors). 476 */ 477 struct drm_connector { 478 struct drm_device *dev; 479 struct device *kdev; 480 struct device_attribute *attr; 481 struct list_head head; 482 483 struct drm_mode_object base; 484 485 int connector_type; 486 int connector_type_id; 487 bool interlace_allowed; 488 bool doublescan_allowed; 489 bool stereo_allowed; 490 struct list_head modes; /* list of modes on this connector */ 491 492 enum drm_connector_status status; 493 494 /* these are modes added by probing with DDC or the BIOS */ 495 struct list_head probed_modes; 496 497 struct drm_display_info display_info; 498 const struct drm_connector_funcs *funcs; 499 500 struct drm_property_blob *edid_blob_ptr; 501 struct drm_object_properties properties; 502 503 uint8_t polled; /* DRM_CONNECTOR_POLL_* */ 504 505 /* requested DPMS state */ 506 int dpms; 507 508 void *helper_private; 509 510 /* forced on connector */ 511 enum drm_connector_force force; 512 uint32_t encoder_ids[DRM_CONNECTOR_MAX_ENCODER]; 513 struct drm_encoder *encoder; /* currently active encoder */ 514 515 /* EDID bits */ 516 uint8_t eld[MAX_ELD_BYTES]; 517 bool dvi_dual; 518 int max_tmds_clock; /* in MHz */ 519 bool latency_present[2]; 520 int video_latency[2]; /* [0]: progressive, [1]: interlaced */ 521 int audio_latency[2]; 522 int null_edid_counter; /* needed to workaround some HW bugs where we get all 0s */ 523 unsigned bad_edid_counter; 524 }; 525 526 /** 527 * drm_plane_funcs - driver plane control functions 528 * @update_plane: update the plane configuration 529 * @disable_plane: shut down the plane 530 * @destroy: clean up plane resources 531 * @set_property: called when a property is changed 532 */ 533 struct drm_plane_funcs { 534 int (*update_plane)(struct drm_plane *plane, 535 struct drm_crtc *crtc, struct drm_framebuffer *fb, 536 int crtc_x, int crtc_y, 537 unsigned int crtc_w, unsigned int crtc_h, 538 uint32_t src_x, uint32_t src_y, 539 uint32_t src_w, uint32_t src_h); 540 int (*disable_plane)(struct drm_plane *plane); 541 void (*destroy)(struct drm_plane *plane); 542 543 int (*set_property)(struct drm_plane *plane, 544 struct drm_property *property, uint64_t val); 545 }; 546 547 enum drm_plane_type { 548 DRM_PLANE_TYPE_OVERLAY, 549 DRM_PLANE_TYPE_PRIMARY, 550 DRM_PLANE_TYPE_CURSOR, 551 }; 552 553 /** 554 * drm_plane - central DRM plane control structure 555 * @dev: DRM device this plane belongs to 556 * @head: for list management 557 * @base: base mode object 558 * @possible_crtcs: pipes this plane can be bound to 559 * @format_types: array of formats supported by this plane 560 * @format_count: number of formats supported 561 * @crtc: currently bound CRTC 562 * @fb: currently bound fb 563 * @funcs: helper functions 564 * @properties: property tracking for this plane 565 * @type: type of plane (overlay, primary, cursor) 566 */ 567 struct drm_plane { 568 struct drm_device *dev; 569 struct list_head head; 570 571 struct drm_mode_object base; 572 573 uint32_t possible_crtcs; 574 uint32_t *format_types; 575 uint32_t format_count; 576 577 struct drm_crtc *crtc; 578 struct drm_framebuffer *fb; 579 580 const struct drm_plane_funcs *funcs; 581 582 struct drm_object_properties properties; 583 584 enum drm_plane_type type; 585 }; 586 587 /** 588 * drm_bridge_funcs - drm_bridge control functions 589 * @mode_fixup: Try to fixup (or reject entirely) proposed mode for this bridge 590 * @disable: Called right before encoder prepare, disables the bridge 591 * @post_disable: Called right after encoder prepare, for lockstepped disable 592 * @mode_set: Set this mode to the bridge 593 * @pre_enable: Called right before encoder commit, for lockstepped commit 594 * @enable: Called right after encoder commit, enables the bridge 595 * @destroy: make object go away 596 */ 597 struct drm_bridge_funcs { 598 bool (*mode_fixup)(struct drm_bridge *bridge, 599 const struct drm_display_mode *mode, 600 struct drm_display_mode *adjusted_mode); 601 void (*disable)(struct drm_bridge *bridge); 602 void (*post_disable)(struct drm_bridge *bridge); 603 void (*mode_set)(struct drm_bridge *bridge, 604 struct drm_display_mode *mode, 605 struct drm_display_mode *adjusted_mode); 606 void (*pre_enable)(struct drm_bridge *bridge); 607 void (*enable)(struct drm_bridge *bridge); 608 void (*destroy)(struct drm_bridge *bridge); 609 }; 610 611 /** 612 * drm_bridge - central DRM bridge control structure 613 * @dev: DRM device this bridge belongs to 614 * @head: list management 615 * @base: base mode object 616 * @funcs: control functions 617 * @driver_private: pointer to the bridge driver's internal context 618 */ 619 struct drm_bridge { 620 struct drm_device *dev; 621 struct list_head head; 622 623 struct drm_mode_object base; 624 625 const struct drm_bridge_funcs *funcs; 626 void *driver_private; 627 }; 628 629 /** 630 * drm_mode_set - new values for a CRTC config change 631 * @head: list management 632 * @fb: framebuffer to use for new config 633 * @crtc: CRTC whose configuration we're about to change 634 * @mode: mode timings to use 635 * @x: position of this CRTC relative to @fb 636 * @y: position of this CRTC relative to @fb 637 * @connectors: array of connectors to drive with this CRTC if possible 638 * @num_connectors: size of @connectors array 639 * 640 * Represents a single crtc the connectors that it drives with what mode 641 * and from which framebuffer it scans out from. 642 * 643 * This is used to set modes. 644 */ 645 struct drm_mode_set { 646 struct drm_framebuffer *fb; 647 struct drm_crtc *crtc; 648 struct drm_display_mode *mode; 649 650 uint32_t x; 651 uint32_t y; 652 653 struct drm_connector **connectors; 654 size_t num_connectors; 655 }; 656 657 /** 658 * struct drm_mode_config_funcs - basic driver provided mode setting functions 659 * @fb_create: create a new framebuffer object 660 * @output_poll_changed: function to handle output configuration changes 661 * 662 * Some global (i.e. not per-CRTC, connector, etc) mode setting functions that 663 * involve drivers. 664 */ 665 struct drm_mode_config_funcs { 666 struct drm_framebuffer *(*fb_create)(struct drm_device *dev, 667 struct drm_file *file_priv, 668 struct drm_mode_fb_cmd2 *mode_cmd); 669 void (*output_poll_changed)(struct drm_device *dev); 670 }; 671 672 /** 673 * drm_mode_group - group of mode setting resources for potential sub-grouping 674 * @num_crtcs: CRTC count 675 * @num_encoders: encoder count 676 * @num_connectors: connector count 677 * @id_list: list of KMS object IDs in this group 678 * 679 * Currently this simply tracks the global mode setting state. But in the 680 * future it could allow groups of objects to be set aside into independent 681 * control groups for use by different user level processes (e.g. two X servers 682 * running simultaneously on different heads, each with their own mode 683 * configuration and freedom of mode setting). 684 */ 685 struct drm_mode_group { 686 uint32_t num_crtcs; 687 uint32_t num_encoders; 688 uint32_t num_connectors; 689 uint32_t num_bridges; 690 691 /* list of object IDs for this group */ 692 uint32_t *id_list; 693 }; 694 695 /** 696 * drm_mode_config - Mode configuration control structure 697 * @mutex: mutex protecting KMS related lists and structures 698 * @idr_mutex: mutex for KMS ID allocation and management 699 * @crtc_idr: main KMS ID tracking object 700 * @num_fb: number of fbs available 701 * @fb_list: list of framebuffers available 702 * @num_connector: number of connectors on this device 703 * @connector_list: list of connector objects 704 * @num_bridge: number of bridges on this device 705 * @bridge_list: list of bridge objects 706 * @num_encoder: number of encoders on this device 707 * @encoder_list: list of encoder objects 708 * @num_crtc: number of CRTCs on this device 709 * @crtc_list: list of CRTC objects 710 * @min_width: minimum pixel width on this device 711 * @min_height: minimum pixel height on this device 712 * @max_width: maximum pixel width on this device 713 * @max_height: maximum pixel height on this device 714 * @funcs: core driver provided mode setting functions 715 * @fb_base: base address of the framebuffer 716 * @poll_enabled: track polling status for this device 717 * @output_poll_work: delayed work for polling in process context 718 * @*_property: core property tracking 719 * 720 * Core mode resource tracking structure. All CRTC, encoders, and connectors 721 * enumerated by the driver are added here, as are global properties. Some 722 * global restrictions are also here, e.g. dimension restrictions. 723 */ 724 struct drm_mode_config { 725 struct mutex mutex; /* protects configuration (mode lists etc.) */ 726 struct mutex idr_mutex; /* for IDR management */ 727 struct idr crtc_idr; /* use this idr for all IDs, fb, crtc, connector, modes - just makes life easier */ 728 /* this is limited to one for now */ 729 730 731 /** 732 * fb_lock - mutex to protect fb state 733 * 734 * Besides the global fb list his also protects the fbs list in the 735 * file_priv 736 */ 737 struct mutex fb_lock; 738 int num_fb; 739 struct list_head fb_list; 740 741 int num_connector; 742 struct list_head connector_list; 743 int num_bridge; 744 struct list_head bridge_list; 745 int num_encoder; 746 struct list_head encoder_list; 747 748 /* 749 * Track # of overlay planes separately from # of total planes. By 750 * default we only advertise overlay planes to userspace; if userspace 751 * sets the "universal plane" capability bit, we'll go ahead and 752 * expose all planes. 753 */ 754 int num_overlay_plane; 755 int num_total_plane; 756 struct list_head plane_list; 757 758 int num_crtc; 759 struct list_head crtc_list; 760 761 struct list_head property_list; 762 763 int min_width, min_height; 764 int max_width, max_height; 765 const struct drm_mode_config_funcs *funcs; 766 resource_size_t fb_base; 767 768 /* output poll support */ 769 bool poll_enabled; 770 bool poll_running; 771 struct delayed_work output_poll_work; 772 773 /* pointers to standard properties */ 774 struct list_head property_blob_list; 775 struct drm_property *edid_property; 776 struct drm_property *dpms_property; 777 struct drm_property *plane_type_property; 778 779 /* DVI-I properties */ 780 struct drm_property *dvi_i_subconnector_property; 781 struct drm_property *dvi_i_select_subconnector_property; 782 783 /* TV properties */ 784 struct drm_property *tv_subconnector_property; 785 struct drm_property *tv_select_subconnector_property; 786 struct drm_property *tv_mode_property; 787 struct drm_property *tv_left_margin_property; 788 struct drm_property *tv_right_margin_property; 789 struct drm_property *tv_top_margin_property; 790 struct drm_property *tv_bottom_margin_property; 791 struct drm_property *tv_brightness_property; 792 struct drm_property *tv_contrast_property; 793 struct drm_property *tv_flicker_reduction_property; 794 struct drm_property *tv_overscan_property; 795 struct drm_property *tv_saturation_property; 796 struct drm_property *tv_hue_property; 797 798 /* Optional properties */ 799 struct drm_property *scaling_mode_property; 800 struct drm_property *dirty_info_property; 801 802 /* dumb ioctl parameters */ 803 uint32_t preferred_depth, prefer_shadow; 804 805 /* whether async page flip is supported or not */ 806 bool async_page_flip; 807 808 /* cursor size */ 809 uint32_t cursor_width, cursor_height; 810 }; 811 812 #define obj_to_crtc(x) container_of(x, struct drm_crtc, base) 813 #define obj_to_connector(x) container_of(x, struct drm_connector, base) 814 #define obj_to_encoder(x) container_of(x, struct drm_encoder, base) 815 #define obj_to_mode(x) container_of(x, struct drm_display_mode, base) 816 #define obj_to_fb(x) container_of(x, struct drm_framebuffer, base) 817 #define obj_to_property(x) container_of(x, struct drm_property, base) 818 #define obj_to_blob(x) container_of(x, struct drm_property_blob, base) 819 #define obj_to_plane(x) container_of(x, struct drm_plane, base) 820 821 struct drm_prop_enum_list { 822 int type; 823 char *name; 824 }; 825 826 extern void drm_modeset_lock_all(struct drm_device *dev); 827 extern void drm_modeset_unlock_all(struct drm_device *dev); 828 extern void drm_warn_on_modeset_not_all_locked(struct drm_device *dev); 829 830 extern int drm_crtc_init_with_planes(struct drm_device *dev, 831 struct drm_crtc *crtc, 832 struct drm_plane *primary, 833 void *cursor, 834 const struct drm_crtc_funcs *funcs); 835 extern int drm_crtc_init(struct drm_device *dev, 836 struct drm_crtc *crtc, 837 const struct drm_crtc_funcs *funcs); 838 extern void drm_crtc_cleanup(struct drm_crtc *crtc); 839 extern unsigned int drm_crtc_index(struct drm_crtc *crtc); 840 841 /** 842 * drm_crtc_mask - find the mask of a registered CRTC 843 * @crtc: CRTC to find mask for 844 * 845 * Given a registered CRTC, return the mask bit of that CRTC for an 846 * encoder's possible_crtcs field. 847 */ 848 static inline uint32_t drm_crtc_mask(struct drm_crtc *crtc) 849 { 850 return 1 << drm_crtc_index(crtc); 851 } 852 853 extern void drm_connector_ida_init(void); 854 extern void drm_connector_ida_destroy(void); 855 extern int drm_connector_init(struct drm_device *dev, 856 struct drm_connector *connector, 857 const struct drm_connector_funcs *funcs, 858 int connector_type); 859 860 extern void drm_connector_cleanup(struct drm_connector *connector); 861 /* helper to unplug all connectors from sysfs for device */ 862 extern void drm_connector_unplug_all(struct drm_device *dev); 863 864 extern int drm_bridge_init(struct drm_device *dev, struct drm_bridge *bridge, 865 const struct drm_bridge_funcs *funcs); 866 extern void drm_bridge_cleanup(struct drm_bridge *bridge); 867 868 extern int drm_encoder_init(struct drm_device *dev, 869 struct drm_encoder *encoder, 870 const struct drm_encoder_funcs *funcs, 871 int encoder_type); 872 873 /** 874 * drm_encoder_crtc_ok - can a given crtc drive a given encoder? 875 * @encoder: encoder to test 876 * @crtc: crtc to test 877 * 878 * Return false if @encoder can't be driven by @crtc, true otherwise. 879 */ 880 static inline bool drm_encoder_crtc_ok(struct drm_encoder *encoder, 881 struct drm_crtc *crtc) 882 { 883 return !!(encoder->possible_crtcs & drm_crtc_mask(crtc)); 884 } 885 886 extern int drm_universal_plane_init(struct drm_device *dev, 887 struct drm_plane *plane, 888 unsigned long possible_crtcs, 889 const struct drm_plane_funcs *funcs, 890 const uint32_t *formats, 891 uint32_t format_count, 892 enum drm_plane_type type); 893 extern int drm_plane_init(struct drm_device *dev, 894 struct drm_plane *plane, 895 unsigned long possible_crtcs, 896 const struct drm_plane_funcs *funcs, 897 const uint32_t *formats, uint32_t format_count, 898 bool is_primary); 899 extern void drm_plane_cleanup(struct drm_plane *plane); 900 extern void drm_plane_force_disable(struct drm_plane *plane); 901 extern int drm_crtc_check_viewport(const struct drm_crtc *crtc, 902 int x, int y, 903 const struct drm_display_mode *mode, 904 const struct drm_framebuffer *fb); 905 906 extern void drm_encoder_cleanup(struct drm_encoder *encoder); 907 908 extern const char *drm_get_connector_name(const struct drm_connector *connector); 909 extern const char *drm_get_connector_status_name(enum drm_connector_status status); 910 extern const char *drm_get_subpixel_order_name(enum subpixel_order order); 911 extern const char *drm_get_dpms_name(int val); 912 extern const char *drm_get_dvi_i_subconnector_name(int val); 913 extern const char *drm_get_dvi_i_select_name(int val); 914 extern const char *drm_get_tv_subconnector_name(int val); 915 extern const char *drm_get_tv_select_name(int val); 916 extern void drm_fb_release(struct drm_file *file_priv); 917 extern int drm_mode_group_init_legacy_group(struct drm_device *dev, struct drm_mode_group *group); 918 extern bool drm_probe_ddc(struct i2c_adapter *adapter); 919 extern struct edid *drm_get_edid(struct drm_connector *connector, 920 struct i2c_adapter *adapter); 921 extern struct edid *drm_edid_duplicate(const struct edid *edid); 922 extern int drm_add_edid_modes(struct drm_connector *connector, struct edid *edid); 923 extern void drm_mode_config_init(struct drm_device *dev); 924 extern void drm_mode_config_reset(struct drm_device *dev); 925 extern void drm_mode_config_cleanup(struct drm_device *dev); 926 927 extern int drm_mode_connector_update_edid_property(struct drm_connector *connector, 928 struct edid *edid); 929 extern int drm_object_property_set_value(struct drm_mode_object *obj, 930 struct drm_property *property, 931 uint64_t val); 932 extern int drm_object_property_get_value(struct drm_mode_object *obj, 933 struct drm_property *property, 934 uint64_t *value); 935 extern int drm_framebuffer_init(struct drm_device *dev, 936 struct drm_framebuffer *fb, 937 const struct drm_framebuffer_funcs *funcs); 938 extern struct drm_framebuffer *drm_framebuffer_lookup(struct drm_device *dev, 939 uint32_t id); 940 extern void drm_framebuffer_unreference(struct drm_framebuffer *fb); 941 extern void drm_framebuffer_reference(struct drm_framebuffer *fb); 942 extern void drm_framebuffer_remove(struct drm_framebuffer *fb); 943 extern void drm_framebuffer_cleanup(struct drm_framebuffer *fb); 944 extern void drm_framebuffer_unregister_private(struct drm_framebuffer *fb); 945 946 extern void drm_object_attach_property(struct drm_mode_object *obj, 947 struct drm_property *property, 948 uint64_t init_val); 949 extern struct drm_property *drm_property_create(struct drm_device *dev, int flags, 950 const char *name, int num_values); 951 extern struct drm_property *drm_property_create_enum(struct drm_device *dev, int flags, 952 const char *name, 953 const struct drm_prop_enum_list *props, 954 int num_values); 955 struct drm_property *drm_property_create_bitmask(struct drm_device *dev, 956 int flags, const char *name, 957 const struct drm_prop_enum_list *props, 958 int num_values); 959 struct drm_property *drm_property_create_range(struct drm_device *dev, int flags, 960 const char *name, 961 uint64_t min, uint64_t max); 962 extern void drm_property_destroy(struct drm_device *dev, struct drm_property *property); 963 extern int drm_property_add_enum(struct drm_property *property, int index, 964 uint64_t value, const char *name); 965 extern int drm_mode_create_dvi_i_properties(struct drm_device *dev); 966 extern int drm_mode_create_tv_properties(struct drm_device *dev, int num_formats, 967 char *formats[]); 968 extern int drm_mode_create_scaling_mode_property(struct drm_device *dev); 969 extern int drm_mode_create_dirty_info_property(struct drm_device *dev); 970 extern const char *drm_get_encoder_name(const struct drm_encoder *encoder); 971 972 extern int drm_mode_connector_attach_encoder(struct drm_connector *connector, 973 struct drm_encoder *encoder); 974 extern int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc, 975 int gamma_size); 976 extern struct drm_mode_object *drm_mode_object_find(struct drm_device *dev, 977 uint32_t id, uint32_t type); 978 /* IOCTLs */ 979 extern int drm_mode_getresources(struct drm_device *dev, 980 void *data, struct drm_file *file_priv); 981 extern int drm_mode_getplane_res(struct drm_device *dev, void *data, 982 struct drm_file *file_priv); 983 extern int drm_mode_getcrtc(struct drm_device *dev, 984 void *data, struct drm_file *file_priv); 985 extern int drm_mode_getconnector(struct drm_device *dev, 986 void *data, struct drm_file *file_priv); 987 extern int drm_mode_set_config_internal(struct drm_mode_set *set); 988 extern int drm_mode_setcrtc(struct drm_device *dev, 989 void *data, struct drm_file *file_priv); 990 extern int drm_mode_getplane(struct drm_device *dev, 991 void *data, struct drm_file *file_priv); 992 extern int drm_mode_setplane(struct drm_device *dev, 993 void *data, struct drm_file *file_priv); 994 extern int drm_mode_cursor_ioctl(struct drm_device *dev, 995 void *data, struct drm_file *file_priv); 996 extern int drm_mode_cursor2_ioctl(struct drm_device *dev, 997 void *data, struct drm_file *file_priv); 998 extern int drm_mode_addfb(struct drm_device *dev, 999 void *data, struct drm_file *file_priv); 1000 extern int drm_mode_addfb2(struct drm_device *dev, 1001 void *data, struct drm_file *file_priv); 1002 extern uint32_t drm_mode_legacy_fb_format(uint32_t bpp, uint32_t depth); 1003 extern int drm_mode_rmfb(struct drm_device *dev, 1004 void *data, struct drm_file *file_priv); 1005 extern int drm_mode_getfb(struct drm_device *dev, 1006 void *data, struct drm_file *file_priv); 1007 extern int drm_mode_dirtyfb_ioctl(struct drm_device *dev, 1008 void *data, struct drm_file *file_priv); 1009 1010 extern int drm_mode_getproperty_ioctl(struct drm_device *dev, 1011 void *data, struct drm_file *file_priv); 1012 extern int drm_mode_getblob_ioctl(struct drm_device *dev, 1013 void *data, struct drm_file *file_priv); 1014 extern int drm_mode_connector_property_set_ioctl(struct drm_device *dev, 1015 void *data, struct drm_file *file_priv); 1016 extern int drm_mode_getencoder(struct drm_device *dev, 1017 void *data, struct drm_file *file_priv); 1018 extern int drm_mode_gamma_get_ioctl(struct drm_device *dev, 1019 void *data, struct drm_file *file_priv); 1020 extern int drm_mode_gamma_set_ioctl(struct drm_device *dev, 1021 void *data, struct drm_file *file_priv); 1022 extern u8 drm_match_cea_mode(const struct drm_display_mode *to_match); 1023 extern bool drm_detect_hdmi_monitor(struct edid *edid); 1024 extern bool drm_detect_monitor_audio(struct edid *edid); 1025 extern bool drm_rgb_quant_range_selectable(struct edid *edid); 1026 extern int drm_mode_page_flip_ioctl(struct drm_device *dev, 1027 void *data, struct drm_file *file_priv); 1028 extern int drm_add_modes_noedid(struct drm_connector *connector, 1029 int hdisplay, int vdisplay); 1030 extern void drm_set_preferred_mode(struct drm_connector *connector, 1031 int hpref, int vpref); 1032 1033 extern int drm_edid_header_is_valid(const u8 *raw_edid); 1034 extern bool drm_edid_block_valid(u8 *raw_edid, int block, bool print_bad_edid); 1035 extern bool drm_edid_is_valid(struct edid *edid); 1036 struct drm_display_mode *drm_mode_find_dmt(struct drm_device *dev, 1037 int hsize, int vsize, int fresh, 1038 bool rb); 1039 1040 extern int drm_mode_create_dumb_ioctl(struct drm_device *dev, 1041 void *data, struct drm_file *file_priv); 1042 extern int drm_mode_mmap_dumb_ioctl(struct drm_device *dev, 1043 void *data, struct drm_file *file_priv); 1044 extern int drm_mode_destroy_dumb_ioctl(struct drm_device *dev, 1045 void *data, struct drm_file *file_priv); 1046 extern int drm_mode_obj_get_properties_ioctl(struct drm_device *dev, void *data, 1047 struct drm_file *file_priv); 1048 extern int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data, 1049 struct drm_file *file_priv); 1050 1051 extern void drm_fb_get_bpp_depth(uint32_t format, unsigned int *depth, 1052 int *bpp); 1053 extern int drm_format_num_planes(uint32_t format); 1054 extern int drm_format_plane_cpp(uint32_t format, int plane); 1055 extern int drm_format_horz_chroma_subsampling(uint32_t format); 1056 extern int drm_format_vert_chroma_subsampling(uint32_t format); 1057 extern const char *drm_get_format_name(uint32_t format); 1058 1059 /* Helpers */ 1060 static inline struct drm_crtc *drm_crtc_find(struct drm_device *dev, 1061 uint32_t id) 1062 { 1063 struct drm_mode_object *mo; 1064 mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_CRTC); 1065 return mo ? obj_to_crtc(mo) : NULL; 1066 } 1067 1068 static inline struct drm_encoder *drm_encoder_find(struct drm_device *dev, 1069 uint32_t id) 1070 { 1071 struct drm_mode_object *mo; 1072 mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_ENCODER); 1073 return mo ? obj_to_encoder(mo) : NULL; 1074 } 1075 1076 /* Plane list iterator for legacy (overlay only) planes. */ 1077 #define drm_for_each_legacy_plane(plane, planelist) \ 1078 list_for_each_entry(plane, planelist, head) \ 1079 if (plane->type == DRM_PLANE_TYPE_OVERLAY) 1080 1081 #endif /* __DRM_CRTC_H__ */ 1082