/* SPDX-License-Identifier: GPL-2.0+ */ #ifndef _VKMS_DRV_H_ #define _VKMS_DRV_H_ #include #include #include #include #include #include #include #define XRES_MIN 10 #define YRES_MIN 10 #define XRES_DEF 1024 #define YRES_DEF 768 #define XRES_MAX 8192 #define YRES_MAX 8192 #define NUM_OVERLAY_PLANES 8 #define VKMS_LUT_SIZE 256 /** * struct vkms_frame_info - Structure to store the state of a frame * * @fb: backing drm framebuffer * @src: source rectangle of this frame in the source framebuffer, stored in 16.16 fixed-point form * @dst: destination rectangle in the crtc buffer, stored in whole pixel units * @map: see @drm_shadow_plane_state.data * @rotation: rotation applied to the source. * * @src and @dst should have the same size modulo the rotation. */ struct vkms_frame_info { struct drm_framebuffer *fb; struct drm_rect src, dst; struct drm_rect rotated; struct iosys_map map[DRM_FORMAT_MAX_PLANES]; unsigned int rotation; unsigned int offset; unsigned int pitch; unsigned int cpp; }; struct pixel_argb_u16 { u16 a, r, g, b; }; struct line_buffer { size_t n_pixels; struct pixel_argb_u16 *pixels; }; struct vkms_writeback_job { struct iosys_map data[DRM_FORMAT_MAX_PLANES]; struct vkms_frame_info wb_frame_info; void (*pixel_write)(u8 *dst_pixels, struct pixel_argb_u16 *in_pixel); }; /** * struct vkms_plane_state - Driver specific plane state * @base: base plane state * @frame_info: data required for composing computation * @pixel_read: function to read a pixel in this plane. The creator of a struct vkms_plane_state * must ensure that this pointer is valid */ struct vkms_plane_state { struct drm_shadow_plane_state base; struct vkms_frame_info *frame_info; void (*pixel_read)(u8 *src_buffer, struct pixel_argb_u16 *out_pixel); }; struct vkms_plane { struct drm_plane base; }; struct vkms_color_lut { struct drm_color_lut *base; size_t lut_length; s64 channel_value2index_ratio; }; /** * struct vkms_crtc_state - Driver specific CRTC state * * @base: base CRTC state * @composer_work: work struct to compose and add CRC entries * * @num_active_planes: Number of active planes * @active_planes: List containing all the active planes (counted by * @num_active_planes). They should be stored in z-order. * @active_writeback: Current active writeback job * @gamma_lut: Look up table for gamma used in this CRTC * @crc_pending: Protected by @vkms_output.composer_lock, true when the frame CRC is not computed * yet. Used by vblank to detect if the composer is too slow. * @wb_pending: Protected by @vkms_output.composer_lock, true when a writeback frame is requested. * @frame_start: Protected by @vkms_output.composer_lock, saves the frame number before the start * of the composition process. * @frame_end: Protected by @vkms_output.composer_lock, saves the last requested frame number. * This is used to generate enough CRC entries when the composition worker is too slow. */ struct vkms_crtc_state { struct drm_crtc_state base; struct work_struct composer_work; int num_active_planes; struct vkms_plane_state **active_planes; struct vkms_writeback_job *active_writeback; struct vkms_color_lut gamma_lut; bool crc_pending; bool wb_pending; u64 frame_start; u64 frame_end; }; /** * struct vkms_output - Internal representation of all output components in VKMS * * @crtc: Base CRTC in DRM * @encoder: DRM encoder used for this output * @connector: DRM connector used for this output * @wb_connecter: DRM writeback connector used for this output * @vblank_hrtimer: Timer used to trigger the vblank * @period_ns: vblank period, in nanoseconds, used to configure @vblank_hrtimer and to compute * vblank timestamps * @composer_workq: Ordered workqueue for @composer_state.composer_work. * @lock: Lock used to protect concurrent access to the composer * @composer_enabled: Protected by @lock, true when the VKMS composer is active (crc needed or * writeback) * @composer_state: Protected by @lock, current state of this VKMS output * @composer_lock: Lock used internally to protect @composer_state members */ struct vkms_output { struct drm_crtc crtc; struct drm_encoder encoder; struct drm_connector connector; struct drm_writeback_connector wb_connector; struct hrtimer vblank_hrtimer; ktime_t period_ns; struct workqueue_struct *composer_workq; spinlock_t lock; bool composer_enabled; struct vkms_crtc_state *composer_state; spinlock_t composer_lock; }; /** * struct vkms_config - General configuration for VKMS driver * * @writeback: If true, a writeback buffer can be attached to the CRTC * @cursor: If true, a cursor plane is created in the VKMS device * @overlay: If true, NUM_OVERLAY_PLANES will be created for the VKMS device * @dev: Used to store the current VKMS device. Only set when the device is instantiated. */ struct vkms_config { bool writeback; bool cursor; bool overlay; struct vkms_device *dev; }; /** * struct vkms_device - Description of a VKMS device * * @drm - Base device in DRM * @platform - Associated platform device * @output - Configuration and sub-components of the VKMS device * @config: Configuration used in this VKMS device */ struct vkms_device { struct drm_device drm; struct platform_device *platform; struct vkms_output output; const struct vkms_config *config; }; /* * The following helpers are used to convert a member of a struct into its parent. */ #define drm_crtc_to_vkms_output(target) \ container_of(target, struct vkms_output, crtc) #define drm_device_to_vkms_device(target) \ container_of(target, struct vkms_device, drm) #define to_vkms_crtc_state(target)\ container_of(target, struct vkms_crtc_state, base) #define to_vkms_plane_state(target)\ container_of(target, struct vkms_plane_state, base.base) /** * vkms_crtc_init() - Initialize a CRTC for VKMS * @dev: DRM device associated with the VKMS buffer * @crtc: uninitialized CRTC device * @primary: primary plane to attach to the CRTC * @cursor: plane to attach to the CRTC */ int vkms_crtc_init(struct drm_device *dev, struct drm_crtc *crtc, struct drm_plane *primary, struct drm_plane *cursor); /** * vkms_output_init() - Initialize all sub-components needed for a VKMS device. * * @vkmsdev: VKMS device to initialize * @index: CRTC which can be attached to the planes. The caller must ensure that * @index is positive and less or equals to 31. */ int vkms_output_init(struct vkms_device *vkmsdev, int index); /** * vkms_plane_init() - Initialize a plane * * @vkmsdev: VKMS device containing the plane * @type: type of plane to initialize * @index: CRTC which can be attached to the plane. The caller must ensure that * @index is positive and less or equals to 31. */ struct vkms_plane *vkms_plane_init(struct vkms_device *vkmsdev, enum drm_plane_type type, int index); /* CRC Support */ const char *const *vkms_get_crc_sources(struct drm_crtc *crtc, size_t *count); int vkms_set_crc_source(struct drm_crtc *crtc, const char *src_name); int vkms_verify_crc_source(struct drm_crtc *crtc, const char *source_name, size_t *values_cnt); /* Composer Support */ void vkms_composer_worker(struct work_struct *work); void vkms_set_composer(struct vkms_output *out, bool enabled); void vkms_compose_row(struct line_buffer *stage_buffer, struct vkms_plane_state *plane, int y); void vkms_writeback_row(struct vkms_writeback_job *wb, const struct line_buffer *src_buffer, int y); /* Writeback */ int vkms_enable_writeback_connector(struct vkms_device *vkmsdev); #endif /* _VKMS_DRV_H_ */