993 lines · c
1/*2 * Copyright (c) 2016 Intel Corporation3 *4 * Permission to use, copy, modify, distribute, and sell this software and its5 * documentation for any purpose is hereby granted without fee, provided that6 * the above copyright notice appear in all copies and that both that copyright7 * notice and this permission notice appear in supporting documentation, and8 * that the name of the copyright holders not be used in advertising or9 * publicity pertaining to distribution of the software without specific,10 * written prior permission. The copyright holders make no representations11 * about the suitability of this software for any purpose. It is provided "as12 * is" without express or implied warranty.13 *14 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,15 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO16 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR17 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,18 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER19 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE20 * OF THIS SOFTWARE.21 */22 23#ifndef __DRM_PLANE_H__24#define __DRM_PLANE_H__25 26#include <linux/list.h>27#include <linux/ctype.h>28#include <linux/kmsg_dump.h>29#include <drm/drm_mode_object.h>30#include <drm/drm_color_mgmt.h>31#include <drm/drm_rect.h>32#include <drm/drm_modeset_lock.h>33#include <drm/drm_util.h>34 35struct drm_crtc;36struct drm_plane_size_hint;37struct drm_printer;38struct drm_modeset_acquire_ctx;39 40enum drm_scaling_filter {41 DRM_SCALING_FILTER_DEFAULT,42 DRM_SCALING_FILTER_NEAREST_NEIGHBOR,43};44 45/**46 * struct drm_plane_state - mutable plane state47 *48 * Please note that the destination coordinates @crtc_x, @crtc_y, @crtc_h and49 * @crtc_w and the source coordinates @src_x, @src_y, @src_h and @src_w are the50 * raw coordinates provided by userspace. Drivers should use51 * drm_atomic_helper_check_plane_state() and only use the derived rectangles in52 * @src and @dst to program the hardware.53 */54struct drm_plane_state {55 /** @plane: backpointer to the plane */56 struct drm_plane *plane;57 58 /**59 * @crtc:60 *61 * Currently bound CRTC, NULL if disabled. Do not write this directly,62 * use drm_atomic_set_crtc_for_plane()63 */64 struct drm_crtc *crtc;65 66 /**67 * @fb:68 *69 * Currently bound framebuffer. Do not write this directly, use70 * drm_atomic_set_fb_for_plane()71 */72 struct drm_framebuffer *fb;73 74 /**75 * @fence:76 *77 * Optional fence to wait for before scanning out @fb. The core atomic78 * code will set this when userspace is using explicit fencing. Do not79 * write this field directly for a driver's implicit fence.80 *81 * Drivers should store any implicit fence in this from their82 * &drm_plane_helper_funcs.prepare_fb callback. See83 * drm_gem_plane_helper_prepare_fb() for a suitable helper.84 */85 struct dma_fence *fence;86 87 /**88 * @crtc_x:89 *90 * Left position of visible portion of plane on crtc, signed dest91 * location allows it to be partially off screen.92 */93 94 int32_t crtc_x;95 /**96 * @crtc_y:97 *98 * Upper position of visible portion of plane on crtc, signed dest99 * location allows it to be partially off screen.100 */101 int32_t crtc_y;102 103 /** @crtc_w: width of visible portion of plane on crtc */104 /** @crtc_h: height of visible portion of plane on crtc */105 uint32_t crtc_w, crtc_h;106 107 /**108 * @src_x: left position of visible portion of plane within plane (in109 * 16.16 fixed point).110 */111 uint32_t src_x;112 /**113 * @src_y: upper position of visible portion of plane within plane (in114 * 16.16 fixed point).115 */116 uint32_t src_y;117 /** @src_w: width of visible portion of plane (in 16.16) */118 /** @src_h: height of visible portion of plane (in 16.16) */119 uint32_t src_h, src_w;120 121 /** @hotspot_x: x offset to mouse cursor hotspot */122 /** @hotspot_y: y offset to mouse cursor hotspot */123 int32_t hotspot_x, hotspot_y;124 125 /**126 * @alpha:127 * Opacity of the plane with 0 as completely transparent and 0xffff as128 * completely opaque. See drm_plane_create_alpha_property() for more129 * details.130 */131 u16 alpha;132 133 /**134 * @pixel_blend_mode:135 * The alpha blending equation selection, describing how the pixels from136 * the current plane are composited with the background. Value can be137 * one of DRM_MODE_BLEND_*138 */139 uint16_t pixel_blend_mode;140 141 /**142 * @rotation:143 * Rotation of the plane. See drm_plane_create_rotation_property() for144 * more details.145 */146 unsigned int rotation;147 148 /**149 * @zpos:150 * Priority of the given plane on crtc (optional).151 *152 * User-space may set mutable zpos properties so that multiple active153 * planes on the same CRTC have identical zpos values. This is a154 * user-space bug, but drivers can solve the conflict by comparing the155 * plane object IDs; the plane with a higher ID is stacked on top of a156 * plane with a lower ID.157 *158 * See drm_plane_create_zpos_property() and159 * drm_plane_create_zpos_immutable_property() for more details.160 */161 unsigned int zpos;162 163 /**164 * @normalized_zpos:165 * Normalized value of zpos: unique, range from 0 to N-1 where N is the166 * number of active planes for given crtc. Note that the driver must set167 * &drm_mode_config.normalize_zpos or call drm_atomic_normalize_zpos() to168 * update this before it can be trusted.169 */170 unsigned int normalized_zpos;171 172 /**173 * @color_encoding:174 *175 * Color encoding for non RGB formats176 */177 enum drm_color_encoding color_encoding;178 179 /**180 * @color_range:181 *182 * Color range for non RGB formats183 */184 enum drm_color_range color_range;185 186 /**187 * @fb_damage_clips:188 *189 * Blob representing damage (area in plane framebuffer that changed190 * since last plane update) as an array of &drm_mode_rect in framebuffer191 * coodinates of the attached framebuffer. Note that unlike plane src,192 * damage clips are not in 16.16 fixed point.193 *194 * See drm_plane_get_damage_clips() and195 * drm_plane_get_damage_clips_count() for accessing these.196 */197 struct drm_property_blob *fb_damage_clips;198 199 /**200 * @ignore_damage_clips:201 *202 * Set by drivers to indicate the drm_atomic_helper_damage_iter_init()203 * helper that the @fb_damage_clips blob property should be ignored.204 *205 * See :ref:`damage_tracking_properties` for more information.206 */207 bool ignore_damage_clips;208 209 /**210 * @src:211 *212 * source coordinates of the plane (in 16.16).213 *214 * When using drm_atomic_helper_check_plane_state(),215 * the coordinates are clipped, but the driver may choose216 * to use unclipped coordinates instead when the hardware217 * performs the clipping automatically.218 */219 /**220 * @dst:221 *222 * clipped destination coordinates of the plane.223 *224 * When using drm_atomic_helper_check_plane_state(),225 * the coordinates are clipped, but the driver may choose226 * to use unclipped coordinates instead when the hardware227 * performs the clipping automatically.228 */229 struct drm_rect src, dst;230 231 /**232 * @visible:233 *234 * Visibility of the plane. This can be false even if fb!=NULL and235 * crtc!=NULL, due to clipping.236 */237 bool visible;238 239 /**240 * @scaling_filter:241 *242 * Scaling filter to be applied243 */244 enum drm_scaling_filter scaling_filter;245 246 /**247 * @commit: Tracks the pending commit to prevent use-after-free conditions,248 * and for async plane updates.249 *250 * May be NULL.251 */252 struct drm_crtc_commit *commit;253 254 /** @state: backpointer to global drm_atomic_state */255 struct drm_atomic_state *state;256 257 /**258 * @color_mgmt_changed: Color management properties have changed. Used259 * by the atomic helpers and drivers to steer the atomic commit control260 * flow.261 */262 bool color_mgmt_changed : 1;263};264 265static inline struct drm_rect266drm_plane_state_src(const struct drm_plane_state *state)267{268 struct drm_rect src = {269 .x1 = state->src_x,270 .y1 = state->src_y,271 .x2 = state->src_x + state->src_w,272 .y2 = state->src_y + state->src_h,273 };274 return src;275}276 277static inline struct drm_rect278drm_plane_state_dest(const struct drm_plane_state *state)279{280 struct drm_rect dest = {281 .x1 = state->crtc_x,282 .y1 = state->crtc_y,283 .x2 = state->crtc_x + state->crtc_w,284 .y2 = state->crtc_y + state->crtc_h,285 };286 return dest;287}288 289/**290 * struct drm_plane_funcs - driver plane control functions291 */292struct drm_plane_funcs {293 /**294 * @update_plane:295 *296 * This is the legacy entry point to enable and configure the plane for297 * the given CRTC and framebuffer. It is never called to disable the298 * plane, i.e. the passed-in crtc and fb paramters are never NULL.299 *300 * The source rectangle in frame buffer memory coordinates is given by301 * the src_x, src_y, src_w and src_h parameters (as 16.16 fixed point302 * values). Devices that don't support subpixel plane coordinates can303 * ignore the fractional part.304 *305 * The destination rectangle in CRTC coordinates is given by the306 * crtc_x, crtc_y, crtc_w and crtc_h parameters (as integer values).307 * Devices scale the source rectangle to the destination rectangle. If308 * scaling is not supported, and the source rectangle size doesn't match309 * the destination rectangle size, the driver must return a310 * -<errorname>EINVAL</errorname> error.311 *312 * Drivers implementing atomic modeset should use313 * drm_atomic_helper_update_plane() to implement this hook.314 *315 * RETURNS:316 *317 * 0 on success or a negative error code on failure.318 */319 int (*update_plane)(struct drm_plane *plane,320 struct drm_crtc *crtc, struct drm_framebuffer *fb,321 int crtc_x, int crtc_y,322 unsigned int crtc_w, unsigned int crtc_h,323 uint32_t src_x, uint32_t src_y,324 uint32_t src_w, uint32_t src_h,325 struct drm_modeset_acquire_ctx *ctx);326 327 /**328 * @disable_plane:329 *330 * This is the legacy entry point to disable the plane. The DRM core331 * calls this method in response to a DRM_IOCTL_MODE_SETPLANE IOCTL call332 * with the frame buffer ID set to 0. Disabled planes must not be333 * processed by the CRTC.334 *335 * Drivers implementing atomic modeset should use336 * drm_atomic_helper_disable_plane() to implement this hook.337 *338 * RETURNS:339 *340 * 0 on success or a negative error code on failure.341 */342 int (*disable_plane)(struct drm_plane *plane,343 struct drm_modeset_acquire_ctx *ctx);344 345 /**346 * @destroy:347 *348 * Clean up plane resources. This is only called at driver unload time349 * through drm_mode_config_cleanup() since a plane cannot be hotplugged350 * in DRM.351 */352 void (*destroy)(struct drm_plane *plane);353 354 /**355 * @reset:356 *357 * Reset plane hardware and software state to off. This function isn't358 * called by the core directly, only through drm_mode_config_reset().359 * It's not a helper hook only for historical reasons.360 *361 * Atomic drivers can use drm_atomic_helper_plane_reset() to reset362 * atomic state using this hook.363 */364 void (*reset)(struct drm_plane *plane);365 366 /**367 * @set_property:368 *369 * This is the legacy entry point to update a property attached to the370 * plane.371 *372 * This callback is optional if the driver does not support any legacy373 * driver-private properties. For atomic drivers it is not used because374 * property handling is done entirely in the DRM core.375 *376 * RETURNS:377 *378 * 0 on success or a negative error code on failure.379 */380 int (*set_property)(struct drm_plane *plane,381 struct drm_property *property, uint64_t val);382 383 /**384 * @atomic_duplicate_state:385 *386 * Duplicate the current atomic state for this plane and return it.387 * The core and helpers guarantee that any atomic state duplicated with388 * this hook and still owned by the caller (i.e. not transferred to the389 * driver by calling &drm_mode_config_funcs.atomic_commit) will be390 * cleaned up by calling the @atomic_destroy_state hook in this391 * structure.392 *393 * This callback is mandatory for atomic drivers.394 *395 * Atomic drivers which don't subclass &struct drm_plane_state should use396 * drm_atomic_helper_plane_duplicate_state(). Drivers that subclass the397 * state structure to extend it with driver-private state should use398 * __drm_atomic_helper_plane_duplicate_state() to make sure shared state is399 * duplicated in a consistent fashion across drivers.400 *401 * It is an error to call this hook before &drm_plane.state has been402 * initialized correctly.403 *404 * NOTE:405 *406 * If the duplicate state references refcounted resources this hook must407 * acquire a reference for each of them. The driver must release these408 * references again in @atomic_destroy_state.409 *410 * RETURNS:411 *412 * Duplicated atomic state or NULL when the allocation failed.413 */414 struct drm_plane_state *(*atomic_duplicate_state)(struct drm_plane *plane);415 416 /**417 * @atomic_destroy_state:418 *419 * Destroy a state duplicated with @atomic_duplicate_state and release420 * or unreference all resources it references421 *422 * This callback is mandatory for atomic drivers.423 */424 void (*atomic_destroy_state)(struct drm_plane *plane,425 struct drm_plane_state *state);426 427 /**428 * @atomic_set_property:429 *430 * Decode a driver-private property value and store the decoded value431 * into the passed-in state structure. Since the atomic core decodes all432 * standardized properties (even for extensions beyond the core set of433 * properties which might not be implemented by all drivers) this434 * requires drivers to subclass the state structure.435 *436 * Such driver-private properties should really only be implemented for437 * truly hardware/vendor specific state. Instead it is preferred to438 * standardize atomic extension and decode the properties used to expose439 * such an extension in the core.440 *441 * Do not call this function directly, use442 * drm_atomic_plane_set_property() instead.443 *444 * This callback is optional if the driver does not support any445 * driver-private atomic properties.446 *447 * NOTE:448 *449 * This function is called in the state assembly phase of atomic450 * modesets, which can be aborted for any reason (including on451 * userspace's request to just check whether a configuration would be452 * possible). Drivers MUST NOT touch any persistent state (hardware or453 * software) or data structures except the passed in @state parameter.454 *455 * Also since userspace controls in which order properties are set this456 * function must not do any input validation (since the state update is457 * incomplete and hence likely inconsistent). Instead any such input458 * validation must be done in the various atomic_check callbacks.459 *460 * RETURNS:461 *462 * 0 if the property has been found, -EINVAL if the property isn't463 * implemented by the driver (which shouldn't ever happen, the core only464 * asks for properties attached to this plane). No other validation is465 * allowed by the driver. The core already checks that the property466 * value is within the range (integer, valid enum value, ...) the driver467 * set when registering the property.468 */469 int (*atomic_set_property)(struct drm_plane *plane,470 struct drm_plane_state *state,471 struct drm_property *property,472 uint64_t val);473 474 /**475 * @atomic_get_property:476 *477 * Reads out the decoded driver-private property. This is used to478 * implement the GETPLANE IOCTL.479 *480 * Do not call this function directly, use481 * drm_atomic_plane_get_property() instead.482 *483 * This callback is optional if the driver does not support any484 * driver-private atomic properties.485 *486 * RETURNS:487 *488 * 0 on success, -EINVAL if the property isn't implemented by the489 * driver (which should never happen, the core only asks for490 * properties attached to this plane).491 */492 int (*atomic_get_property)(struct drm_plane *plane,493 const struct drm_plane_state *state,494 struct drm_property *property,495 uint64_t *val);496 /**497 * @late_register:498 *499 * This optional hook can be used to register additional userspace500 * interfaces attached to the plane like debugfs interfaces.501 * It is called late in the driver load sequence from drm_dev_register().502 * Everything added from this callback should be unregistered in503 * the early_unregister callback.504 *505 * Returns:506 *507 * 0 on success, or a negative error code on failure.508 */509 int (*late_register)(struct drm_plane *plane);510 511 /**512 * @early_unregister:513 *514 * This optional hook should be used to unregister the additional515 * userspace interfaces attached to the plane from516 * @late_register. It is called from drm_dev_unregister(),517 * early in the driver unload sequence to disable userspace access518 * before data structures are torndown.519 */520 void (*early_unregister)(struct drm_plane *plane);521 522 /**523 * @atomic_print_state:524 *525 * If driver subclasses &struct drm_plane_state, it should implement526 * this optional hook for printing additional driver specific state.527 *528 * Do not call this directly, use drm_atomic_plane_print_state()529 * instead.530 */531 void (*atomic_print_state)(struct drm_printer *p,532 const struct drm_plane_state *state);533 534 /**535 * @format_mod_supported:536 *537 * This optional hook is used for the DRM to determine if the given538 * format/modifier combination is valid for the plane. This allows the539 * DRM to generate the correct format bitmask (which formats apply to540 * which modifier), and to validate modifiers at atomic_check time.541 *542 * If not present, then any modifier in the plane's modifier543 * list is allowed with any of the plane's formats.544 *545 * Returns:546 *547 * True if the given modifier is valid for that format on the plane.548 * False otherwise.549 */550 bool (*format_mod_supported)(struct drm_plane *plane, uint32_t format,551 uint64_t modifier);552};553 554/**555 * enum drm_plane_type - uapi plane type enumeration556 *557 * For historical reasons not all planes are made the same. This enumeration is558 * used to tell the different types of planes apart to implement the different559 * uapi semantics for them. For userspace which is universal plane aware and560 * which is using that atomic IOCTL there's no difference between these planes561 * (beyong what the driver and hardware can support of course).562 *563 * For compatibility with legacy userspace, only overlay planes are made564 * available to userspace by default. Userspace clients may set the565 * &DRM_CLIENT_CAP_UNIVERSAL_PLANES client capability bit to indicate that they566 * wish to receive a universal plane list containing all plane types. See also567 * drm_for_each_legacy_plane().568 *569 * In addition to setting each plane's type, drivers need to setup the570 * &drm_crtc.primary and optionally &drm_crtc.cursor pointers for legacy571 * IOCTLs. See drm_crtc_init_with_planes().572 *573 * WARNING: The values of this enum is UABI since they're exposed in the "type"574 * property.575 */576enum drm_plane_type {577 /**578 * @DRM_PLANE_TYPE_OVERLAY:579 *580 * Overlay planes represent all non-primary, non-cursor planes. Some581 * drivers refer to these types of planes as "sprites" internally.582 */583 DRM_PLANE_TYPE_OVERLAY,584 585 /**586 * @DRM_PLANE_TYPE_PRIMARY:587 *588 * A primary plane attached to a CRTC is the most likely to be able to589 * light up the CRTC when no scaling/cropping is used and the plane590 * covers the whole CRTC.591 */592 DRM_PLANE_TYPE_PRIMARY,593 594 /**595 * @DRM_PLANE_TYPE_CURSOR:596 *597 * A cursor plane attached to a CRTC is more likely to be able to be598 * enabled when no scaling/cropping is used and the framebuffer has the599 * size indicated by &drm_mode_config.cursor_width and600 * &drm_mode_config.cursor_height. Additionally, if the driver doesn't601 * support modifiers, the framebuffer should have a linear layout.602 */603 DRM_PLANE_TYPE_CURSOR,604};605 606 607/**608 * struct drm_plane - central DRM plane control structure609 *610 * Planes represent the scanout hardware of a display block. They receive their611 * input data from a &drm_framebuffer and feed it to a &drm_crtc. Planes control612 * the color conversion, see `Plane Composition Properties`_ for more details,613 * and are also involved in the color conversion of input pixels, see `Color614 * Management Properties`_ for details on that.615 */616struct drm_plane {617 /** @dev: DRM device this plane belongs to */618 struct drm_device *dev;619 620 /**621 * @head:622 *623 * List of all planes on @dev, linked from &drm_mode_config.plane_list.624 * Invariant over the lifetime of @dev and therefore does not need625 * locking.626 */627 struct list_head head;628 629 /** @name: human readable name, can be overwritten by the driver */630 char *name;631 632 /**633 * @mutex:634 *635 * Protects modeset plane state, together with the &drm_crtc.mutex of636 * CRTC this plane is linked to (when active, getting activated or637 * getting disabled).638 *639 * For atomic drivers specifically this protects @state.640 */641 struct drm_modeset_lock mutex;642 643 /** @base: base mode object */644 struct drm_mode_object base;645 646 /**647 * @possible_crtcs: pipes this plane can be bound to constructed from648 * drm_crtc_mask()649 */650 uint32_t possible_crtcs;651 /** @format_types: array of formats supported by this plane */652 uint32_t *format_types;653 /** @format_count: Size of the array pointed at by @format_types. */654 unsigned int format_count;655 /**656 * @format_default: driver hasn't supplied supported formats for the657 * plane. Used by the non-atomic driver compatibility wrapper only.658 */659 bool format_default;660 661 /** @modifiers: array of modifiers supported by this plane */662 uint64_t *modifiers;663 /** @modifier_count: Size of the array pointed at by @modifier_count. */664 unsigned int modifier_count;665 666 /**667 * @crtc:668 *669 * Currently bound CRTC, only meaningful for non-atomic drivers. For670 * atomic drivers this is forced to be NULL, atomic drivers should671 * instead check &drm_plane_state.crtc.672 */673 struct drm_crtc *crtc;674 675 /**676 * @fb:677 *678 * Currently bound framebuffer, only meaningful for non-atomic drivers.679 * For atomic drivers this is forced to be NULL, atomic drivers should680 * instead check &drm_plane_state.fb.681 */682 struct drm_framebuffer *fb;683 684 /**685 * @old_fb:686 *687 * Temporary tracking of the old fb while a modeset is ongoing. Only688 * used by non-atomic drivers, forced to be NULL for atomic drivers.689 */690 struct drm_framebuffer *old_fb;691 692 /** @funcs: plane control functions */693 const struct drm_plane_funcs *funcs;694 695 /** @properties: property tracking for this plane */696 struct drm_object_properties properties;697 698 /** @type: Type of plane, see &enum drm_plane_type for details. */699 enum drm_plane_type type;700 701 /**702 * @index: Position inside the mode_config.list, can be used as an array703 * index. It is invariant over the lifetime of the plane.704 */705 unsigned index;706 707 /** @helper_private: mid-layer private data */708 const struct drm_plane_helper_funcs *helper_private;709 710 /**711 * @state:712 *713 * Current atomic state for this plane.714 *715 * This is protected by @mutex. Note that nonblocking atomic commits716 * access the current plane state without taking locks. Either by going717 * through the &struct drm_atomic_state pointers, see718 * for_each_oldnew_plane_in_state(), for_each_old_plane_in_state() and719 * for_each_new_plane_in_state(). Or through careful ordering of atomic720 * commit operations as implemented in the atomic helpers, see721 * &struct drm_crtc_commit.722 */723 struct drm_plane_state *state;724 725 /**726 * @alpha_property:727 * Optional alpha property for this plane. See728 * drm_plane_create_alpha_property().729 */730 struct drm_property *alpha_property;731 /**732 * @zpos_property:733 * Optional zpos property for this plane. See734 * drm_plane_create_zpos_property().735 */736 struct drm_property *zpos_property;737 /**738 * @rotation_property:739 * Optional rotation property for this plane. See740 * drm_plane_create_rotation_property().741 */742 struct drm_property *rotation_property;743 /**744 * @blend_mode_property:745 * Optional "pixel blend mode" enum property for this plane.746 * Blend mode property represents the alpha blending equation selection,747 * describing how the pixels from the current plane are composited with748 * the background.749 */750 struct drm_property *blend_mode_property;751 752 /**753 * @color_encoding_property:754 *755 * Optional "COLOR_ENCODING" enum property for specifying756 * color encoding for non RGB formats.757 * See drm_plane_create_color_properties().758 */759 struct drm_property *color_encoding_property;760 /**761 * @color_range_property:762 *763 * Optional "COLOR_RANGE" enum property for specifying764 * color range for non RGB formats.765 * See drm_plane_create_color_properties().766 */767 struct drm_property *color_range_property;768 769 /**770 * @scaling_filter_property: property to apply a particular filter while771 * scaling.772 */773 struct drm_property *scaling_filter_property;774 775 /**776 * @hotspot_x_property: property to set mouse hotspot x offset.777 */778 struct drm_property *hotspot_x_property;779 780 /**781 * @hotspot_y_property: property to set mouse hotspot y offset.782 */783 struct drm_property *hotspot_y_property;784 785 /**786 * @kmsg_panic: Used to register a panic notifier for this plane787 */788 struct kmsg_dumper kmsg_panic;789};790 791#define obj_to_plane(x) container_of(x, struct drm_plane, base)792 793__printf(9, 10)794int drm_universal_plane_init(struct drm_device *dev,795 struct drm_plane *plane,796 uint32_t possible_crtcs,797 const struct drm_plane_funcs *funcs,798 const uint32_t *formats,799 unsigned int format_count,800 const uint64_t *format_modifiers,801 enum drm_plane_type type,802 const char *name, ...);803void drm_plane_cleanup(struct drm_plane *plane);804 805__printf(10, 11)806void *__drmm_universal_plane_alloc(struct drm_device *dev,807 size_t size, size_t offset,808 uint32_t possible_crtcs,809 const struct drm_plane_funcs *funcs,810 const uint32_t *formats,811 unsigned int format_count,812 const uint64_t *format_modifiers,813 enum drm_plane_type plane_type,814 const char *name, ...);815 816/**817 * drmm_universal_plane_alloc - Allocate and initialize an universal plane object818 * @dev: DRM device819 * @type: the type of the struct which contains struct &drm_plane820 * @member: the name of the &drm_plane within @type821 * @possible_crtcs: bitmask of possible CRTCs822 * @funcs: callbacks for the new plane823 * @formats: array of supported formats (DRM_FORMAT\_\*)824 * @format_count: number of elements in @formats825 * @format_modifiers: array of struct drm_format modifiers terminated by826 * DRM_FORMAT_MOD_INVALID827 * @plane_type: type of plane (overlay, primary, cursor)828 * @name: printf style format string for the plane name, or NULL for default name829 *830 * Allocates and initializes a plane object of type @type. Cleanup is831 * automatically handled through registering drm_plane_cleanup() with832 * drmm_add_action().833 *834 * The @drm_plane_funcs.destroy hook must be NULL.835 *836 * Drivers that only support the DRM_FORMAT_MOD_LINEAR modifier support may set837 * @format_modifiers to NULL. The plane will advertise the linear modifier.838 *839 * Returns:840 * Pointer to new plane, or ERR_PTR on failure.841 */842#define drmm_universal_plane_alloc(dev, type, member, possible_crtcs, funcs, formats, \843 format_count, format_modifiers, plane_type, name, ...) \844 ((type *)__drmm_universal_plane_alloc(dev, sizeof(type), \845 offsetof(type, member), \846 possible_crtcs, funcs, formats, \847 format_count, format_modifiers, \848 plane_type, name, ##__VA_ARGS__))849 850__printf(10, 11)851void *__drm_universal_plane_alloc(struct drm_device *dev,852 size_t size, size_t offset,853 uint32_t possible_crtcs,854 const struct drm_plane_funcs *funcs,855 const uint32_t *formats,856 unsigned int format_count,857 const uint64_t *format_modifiers,858 enum drm_plane_type plane_type,859 const char *name, ...);860 861/**862 * drm_universal_plane_alloc() - Allocate and initialize an universal plane object863 * @dev: DRM device864 * @type: the type of the struct which contains struct &drm_plane865 * @member: the name of the &drm_plane within @type866 * @possible_crtcs: bitmask of possible CRTCs867 * @funcs: callbacks for the new plane868 * @formats: array of supported formats (DRM_FORMAT\_\*)869 * @format_count: number of elements in @formats870 * @format_modifiers: array of struct drm_format modifiers terminated by871 * DRM_FORMAT_MOD_INVALID872 * @plane_type: type of plane (overlay, primary, cursor)873 * @name: printf style format string for the plane name, or NULL for default name874 *875 * Allocates and initializes a plane object of type @type. The caller876 * is responsible for releasing the allocated memory with kfree().877 *878 * Drivers are encouraged to use drmm_universal_plane_alloc() instead.879 *880 * Drivers that only support the DRM_FORMAT_MOD_LINEAR modifier support may set881 * @format_modifiers to NULL. The plane will advertise the linear modifier.882 *883 * Returns:884 * Pointer to new plane, or ERR_PTR on failure.885 */886#define drm_universal_plane_alloc(dev, type, member, possible_crtcs, funcs, formats, \887 format_count, format_modifiers, plane_type, name, ...) \888 ((type *)__drm_universal_plane_alloc(dev, sizeof(type), \889 offsetof(type, member), \890 possible_crtcs, funcs, formats, \891 format_count, format_modifiers, \892 plane_type, name, ##__VA_ARGS__))893 894/**895 * drm_plane_index - find the index of a registered plane896 * @plane: plane to find index for897 *898 * Given a registered plane, return the index of that plane within a DRM899 * device's list of planes.900 */901static inline unsigned int drm_plane_index(const struct drm_plane *plane)902{903 return plane->index;904}905 906/**907 * drm_plane_mask - find the mask of a registered plane908 * @plane: plane to find mask for909 */910static inline u32 drm_plane_mask(const struct drm_plane *plane)911{912 return 1 << drm_plane_index(plane);913}914 915struct drm_plane * drm_plane_from_index(struct drm_device *dev, int idx);916void drm_plane_force_disable(struct drm_plane *plane);917 918int drm_mode_plane_set_obj_prop(struct drm_plane *plane,919 struct drm_property *property,920 uint64_t value);921 922/**923 * drm_plane_find - find a &drm_plane924 * @dev: DRM device925 * @file_priv: drm file to check for lease against.926 * @id: plane id927 *928 * Returns the plane with @id, NULL if it doesn't exist. Simple wrapper around929 * drm_mode_object_find().930 */931static inline struct drm_plane *drm_plane_find(struct drm_device *dev,932 struct drm_file *file_priv,933 uint32_t id)934{935 struct drm_mode_object *mo;936 mo = drm_mode_object_find(dev, file_priv, id, DRM_MODE_OBJECT_PLANE);937 return mo ? obj_to_plane(mo) : NULL;938}939 940/**941 * drm_for_each_plane_mask - iterate over planes specified by bitmask942 * @plane: the loop cursor943 * @dev: the DRM device944 * @plane_mask: bitmask of plane indices945 *946 * Iterate over all planes specified by bitmask.947 */948#define drm_for_each_plane_mask(plane, dev, plane_mask) \949 list_for_each_entry((plane), &(dev)->mode_config.plane_list, head) \950 for_each_if ((plane_mask) & drm_plane_mask(plane))951 952/**953 * drm_for_each_legacy_plane - iterate over all planes for legacy userspace954 * @plane: the loop cursor955 * @dev: the DRM device956 *957 * Iterate over all legacy planes of @dev, excluding primary and cursor planes.958 * This is useful for implementing userspace apis when userspace is not959 * universal plane aware. See also &enum drm_plane_type.960 */961#define drm_for_each_legacy_plane(plane, dev) \962 list_for_each_entry(plane, &(dev)->mode_config.plane_list, head) \963 for_each_if (plane->type == DRM_PLANE_TYPE_OVERLAY)964 965/**966 * drm_for_each_plane - iterate over all planes967 * @plane: the loop cursor968 * @dev: the DRM device969 *970 * Iterate over all planes of @dev, include primary and cursor planes.971 */972#define drm_for_each_plane(plane, dev) \973 list_for_each_entry(plane, &(dev)->mode_config.plane_list, head)974 975bool drm_plane_has_format(struct drm_plane *plane,976 u32 format, u64 modifier);977bool drm_any_plane_has_format(struct drm_device *dev,978 u32 format, u64 modifier);979 980void drm_plane_enable_fb_damage_clips(struct drm_plane *plane);981unsigned int982drm_plane_get_damage_clips_count(const struct drm_plane_state *state);983struct drm_mode_rect *984drm_plane_get_damage_clips(const struct drm_plane_state *state);985 986int drm_plane_create_scaling_filter_property(struct drm_plane *plane,987 unsigned int supported_filters);988int drm_plane_add_size_hints_property(struct drm_plane *plane,989 const struct drm_plane_size_hint *hints,990 int num_hints);991 992#endif993