| 29,9 → 29,10 |
|---|
| #include <linux/spinlock.h> |
| #include <linux/types.h> |
| #include <linux/idr.h> |
| |
| #include <linux/fb.h> |
| |
| #include <drm/drm_fourcc.h> |
| |
| struct drm_device; |
| struct drm_mode_set; |
| struct drm_framebuffer; |
| 44,6 → 45,7 |
|---|
| #define DRM_MODE_OBJECT_PROPERTY 0xb0b0b0b0 |
| #define DRM_MODE_OBJECT_FB 0xfbfbfbfb |
| #define DRM_MODE_OBJECT_BLOB 0xbbbbbbbb |
| #define DRM_MODE_OBJECT_PLANE 0xeeeeeeee |
| |
| struct drm_mode_object { |
| uint32_t id; |
| 118,7 → 120,6 |
|---|
| |
| char name[DRM_DISPLAY_MODE_LEN]; |
| |
| int connector_count; |
| enum drm_mode_status status; |
| int type; |
| |
| 238,7 → 239,8 |
|---|
| struct list_head head; |
| struct drm_mode_object base; |
| const struct drm_framebuffer_funcs *funcs; |
| unsigned int pitch; |
| unsigned int pitches[4]; |
| unsigned int offsets[4]; |
| unsigned int width; |
| unsigned int height; |
| /* depth can be 15 or 16 */ |
| 245,6 → 247,7 |
|---|
| unsigned int depth; |
| int bits_per_pixel; |
| int flags; |
| uint32_t pixel_format; /* fourcc format */ |
| struct list_head filp_head; |
| /* if you are using the helper */ |
| void *helper_private; |
| 278,6 → 281,7 |
|---|
| struct drm_connector; |
| struct drm_encoder; |
| struct drm_pending_vblank_event; |
| struct drm_plane; |
| |
| /** |
| * drm_crtc_funcs - control CRTCs for a given device |
| 341,10 → 345,21 |
|---|
| |
| /** |
| * drm_crtc - central CRTC control structure |
| * @dev: parent DRM device |
| * @head: list management |
| * @base: base KMS object for ID tracking etc. |
| * @enabled: is this CRTC enabled? |
| * @mode: current mode timings |
| * @hwmode: mode timings as programmed to hw regs |
| * @x: x position on screen |
| * @y: y position on screen |
| * @funcs: CRTC control functions |
| * @gamma_size: size of gamma ramp |
| * @gamma_store: gamma ramp values |
| * @framedur_ns: precise frame timing |
| * @framedur_ns: precise line timing |
| * @pixeldur_ns: precise pixel timing |
| * @helper_private: mid-layer private data |
| * |
| * Each CRTC may have one or more connectors associated with it. This structure |
| * allows the CRTC to be controlled. |
| 423,6 → 438,13 |
|---|
| void (*force)(struct drm_connector *connector); |
| }; |
| |
| /** |
| * drm_encoder_funcs - encoder controls |
| * @reset: reset state (e.g. at init or resume time) |
| * @destroy: cleanup and free associated data |
| * |
| * Encoders sit between CRTCs and connectors. |
| */ |
| struct drm_encoder_funcs { |
| void (*reset)(struct drm_encoder *encoder); |
| void (*destroy)(struct drm_encoder *encoder); |
| 431,10 → 453,22 |
|---|
| #define DRM_CONNECTOR_MAX_UMODES 16 |
| #define DRM_CONNECTOR_MAX_PROPERTY 16 |
| #define DRM_CONNECTOR_LEN 32 |
| #define DRM_CONNECTOR_MAX_ENCODER 2 |
| #define DRM_CONNECTOR_MAX_ENCODER 3 |
| |
| /** |
| * drm_encoder - central DRM encoder structure |
| * @dev: parent DRM device |
| * @head: list management |
| * @base: base KMS object |
| * @encoder_type: one of the %DRM_MODE_ENCODER_<foo> types in drm_mode.h |
| * @possible_crtcs: bitmask of potential CRTC bindings |
| * @possible_clones: bitmask of potential sibling encoders for cloning |
| * @crtc: currently bound CRTC |
| * @funcs: control functions |
| * @helper_private: mid-layer private data |
| * |
| * CRTCs drive pixels to encoders, which convert them into signals |
| * appropriate for a given connector or set of connectors. |
| */ |
| struct drm_encoder { |
| struct drm_device *dev; |
| 466,16 → 500,41 |
|---|
| /* DACs should rarely do this without a lot of testing */ |
| #define DRM_CONNECTOR_POLL_DISCONNECT (1 << 2) |
| |
| #define MAX_ELD_BYTES 128 |
| |
| /** |
| * drm_connector - central DRM connector control structure |
| * @crtc: CRTC this connector is currently connected to, NULL if none |
| * @dev: parent DRM device |
| * @kdev: kernel device for sysfs attributes |
| * @attr: sysfs attributes |
| * @head: list management |
| * @base: base KMS object |
| * @connector_type: one of the %DRM_MODE_CONNECTOR_<foo> types from drm_mode.h |
| * @connector_type_id: index into connector type enum |
| * @interlace_allowed: can this connector handle interlaced modes? |
| * @doublescan_allowed: can this connector handle doublescan? |
| * @available_modes: modes available on this connector (from get_modes() + user) |
| * @initial_x: initial x position for this connector |
| * @initial_y: initial y position for this connector |
| * @status: connector connected? |
| * @modes: modes available on this connector (from fill_modes() + user) |
| * @status: one of the drm_connector_status enums (connected, not, or unknown) |
| * @probed_modes: list of modes derived directly from the display |
| * @display_info: information about attached display (e.g. from EDID) |
| * @funcs: connector control functions |
| * @user_modes: user added mode list |
| * @edid_blob_ptr: DRM property containing EDID if present |
| * @property_ids: property tracking for this connector |
| * @property_values: value pointers or data for properties |
| * @polled: a %DRM_CONNECTOR_POLL_<foo> value for core driven polling |
| * @dpms: current dpms state |
| * @helper_private: mid-layer private data |
| * @force: a %DRM_FORCE_<foo> state for forced mode sets |
| * @encoder_ids: valid encoders for this connector |
| * @encoder: encoder driving this connector, if any |
| * @eld: EDID-like data, if present |
| * @dvi_dual: dual link DVI, if found |
| * @max_tmds_clock: max clock rate, if found |
| * @latency_present: AV delay info from ELD, if found |
| * @video_latency: video latency info from ELD, if found |
| * @audio_latency: audio latency info from ELD, if found |
| * @null_edid_counter: track sinks that give us all zeros for the EDID |
| * |
| * Each connector may be connected to one or more CRTCs, or may be clonable by |
| * another connector if they can share a CRTC. Each connector also has a specific |
| 496,7 → 555,6 |
|---|
| bool doublescan_allowed; |
| struct list_head modes; /* list of modes on this connector */ |
| |
| int initial_x, initial_y; |
| enum drm_connector_status status; |
| |
| /* these are modes added by probing with DDC or the BIOS */ |
| 520,14 → 578,84 |
|---|
| /* forced on connector */ |
| enum drm_connector_force force; |
| uint32_t encoder_ids[DRM_CONNECTOR_MAX_ENCODER]; |
| uint32_t force_encoder_id; |
| struct drm_encoder *encoder; /* currently active encoder */ |
| |
| /* EDID bits */ |
| uint8_t eld[MAX_ELD_BYTES]; |
| bool dvi_dual; |
| int max_tmds_clock; /* in MHz */ |
| bool latency_present[2]; |
| int video_latency[2]; /* [0]: progressive, [1]: interlaced */ |
| int audio_latency[2]; |
| int null_edid_counter; /* needed to workaround some HW bugs where we get all 0s */ |
| }; |
| |
| /** |
| * struct drm_mode_set |
| * drm_plane_funcs - driver plane control functions |
| * @update_plane: update the plane configuration |
| * @disable_plane: shut down the plane |
| * @destroy: clean up plane resources |
| */ |
| struct drm_plane_funcs { |
| int (*update_plane)(struct drm_plane *plane, |
| struct drm_crtc *crtc, struct drm_framebuffer *fb, |
| int crtc_x, int crtc_y, |
| unsigned int crtc_w, unsigned int crtc_h, |
| uint32_t src_x, uint32_t src_y, |
| uint32_t src_w, uint32_t src_h); |
| int (*disable_plane)(struct drm_plane *plane); |
| void (*destroy)(struct drm_plane *plane); |
| }; |
| |
| /** |
| * drm_plane - central DRM plane control structure |
| * @dev: DRM device this plane belongs to |
| * @head: for list management |
| * @base: base mode object |
| * @possible_crtcs: pipes this plane can be bound to |
| * @format_types: array of formats supported by this plane |
| * @format_count: number of formats supported |
| * @crtc: currently bound CRTC |
| * @fb: currently bound fb |
| * @gamma_size: size of gamma table |
| * @gamma_store: gamma correction table |
| * @enabled: enabled flag |
| * @funcs: helper functions |
| * @helper_private: storage for drver layer |
| */ |
| struct drm_plane { |
| struct drm_device *dev; |
| struct list_head head; |
| |
| struct drm_mode_object base; |
| |
| uint32_t possible_crtcs; |
| uint32_t *format_types; |
| uint32_t format_count; |
| |
| struct drm_crtc *crtc; |
| struct drm_framebuffer *fb; |
| |
| /* CRTC gamma size for reporting to userspace */ |
| uint32_t gamma_size; |
| uint16_t *gamma_store; |
| |
| bool enabled; |
| |
| const struct drm_plane_funcs *funcs; |
| void *helper_private; |
| }; |
| |
| /** |
| * drm_mode_set - new values for a CRTC config change |
| * @head: list management |
| * @fb: framebuffer to use for new config |
| * @crtc: CRTC whose configuration we're about to change |
| * @mode: mode timings to use |
| * @x: position of this CRTC relative to @fb |
| * @y: position of this CRTC relative to @fb |
| * @connectors: array of connectors to drive with this CRTC if possible |
| * @num_connectors: size of @connectors array |
| * |
| * Represents a single crtc the connectors that it drives with what mode |
| * and from which framebuffer it scans out from. |
| 549,13 → 677,33 |
|---|
| }; |
| |
| /** |
| * struct drm_mode_config_funcs - configure CRTCs for a given screen layout |
| * struct drm_mode_config_funcs - basic driver provided mode setting functions |
| * @fb_create: create a new framebuffer object |
| * @output_poll_changed: function to handle output configuration changes |
| * |
| * Some global (i.e. not per-CRTC, connector, etc) mode setting functions that |
| * involve drivers. |
| */ |
| struct drm_mode_config_funcs { |
| struct drm_framebuffer *(*fb_create)(struct drm_device *dev, struct drm_file *file_priv, struct drm_mode_fb_cmd *mode_cmd); |
| struct drm_framebuffer *(*fb_create)(struct drm_device *dev, |
| struct drm_file *file_priv, |
| struct drm_mode_fb_cmd2 *mode_cmd); |
| void (*output_poll_changed)(struct drm_device *dev); |
| }; |
| |
| /** |
| * drm_mode_group - group of mode setting resources for potential sub-grouping |
| * @num_crtcs: CRTC count |
| * @num_encoders: encoder count |
| * @num_connectors: connector count |
| * @id_list: list of KMS object IDs in this group |
| * |
| * Currently this simply tracks the global mode setting state. But in the |
| * future it could allow groups of objects to be set aside into independent |
| * control groups for use by different user level processes (e.g. two X servers |
| * running simultaneously on different heads, each with their own mode |
| * configuration and freedom of mode setting). |
| */ |
| struct drm_mode_group { |
| uint32_t num_crtcs; |
| uint32_t num_encoders; |
| 567,7 → 715,30 |
|---|
| |
| /** |
| * drm_mode_config - Mode configuration control structure |
| * @mutex: mutex protecting KMS related lists and structures |
| * @idr_mutex: mutex for KMS ID allocation and management |
| * @crtc_idr: main KMS ID tracking object |
| * @num_fb: number of fbs available |
| * @fb_list: list of framebuffers available |
| * @num_connector: number of connectors on this device |
| * @connector_list: list of connector objects |
| * @num_encoder: number of encoders on this device |
| * @encoder_list: list of encoder objects |
| * @num_crtc: number of CRTCs on this device |
| * @crtc_list: list of CRTC objects |
| * @min_width: minimum pixel width on this device |
| * @min_height: minimum pixel height on this device |
| * @max_width: maximum pixel width on this device |
| * @max_height: maximum pixel height on this device |
| * @funcs: core driver provided mode setting functions |
| * @fb_base: base address of the framebuffer |
| * @poll_enabled: track polling status for this device |
| * @output_poll_work: delayed work for polling in process context |
| * @*_property: core property tracking |
| * |
| * Core mode resource tracking structure. All CRTC, encoders, and connectors |
| * enumerated by the driver are added here, as are global properties. Some |
| * global restrictions are also here, e.g. dimension restrictions. |
| */ |
| struct drm_mode_config { |
| struct mutex mutex; /* protects configuration (mode lists etc.) */ |
| 580,6 → 751,8 |
|---|
| struct list_head connector_list; |
| int num_encoder; |
| struct list_head encoder_list; |
| int num_plane; |
| struct list_head plane_list; |
| |
| int num_crtc; |
| struct list_head crtc_list; |
| 632,6 → 805,7 |
|---|
| #define obj_to_fb(x) container_of(x, struct drm_framebuffer, base) |
| #define obj_to_property(x) container_of(x, struct drm_property, base) |
| #define obj_to_blob(x) container_of(x, struct drm_property_blob, base) |
| #define obj_to_plane(x) container_of(x, struct drm_plane, base) |
| |
| |
| extern void drm_crtc_init(struct drm_device *dev, |
| 651,6 → 825,14 |
|---|
| const struct drm_encoder_funcs *funcs, |
| int encoder_type); |
| |
| extern int drm_plane_init(struct drm_device *dev, |
| struct drm_plane *plane, |
| unsigned long possible_crtcs, |
| const struct drm_plane_funcs *funcs, |
| const uint32_t *formats, uint32_t format_count, |
| bool priv); |
| extern void drm_plane_cleanup(struct drm_plane *plane); |
| |
| extern void drm_encoder_cleanup(struct drm_encoder *encoder); |
| |
| extern char *drm_get_connector_name(struct drm_connector *connector); |
| 744,7 → 926,8 |
|---|
| /* IOCTLs */ |
| extern int drm_mode_getresources(struct drm_device *dev, |
| void *data, struct drm_file *file_priv); |
| |
| extern int drm_mode_getplane_res(struct drm_device *dev, void *data, |
| struct drm_file *file_priv); |
| extern int drm_mode_getcrtc(struct drm_device *dev, |
| void *data, struct drm_file *file_priv); |
| extern int drm_mode_getconnector(struct drm_device *dev, |
| 751,10 → 934,17 |
|---|
| void *data, struct drm_file *file_priv); |
| extern int drm_mode_setcrtc(struct drm_device *dev, |
| void *data, struct drm_file *file_priv); |
| extern int drm_mode_getplane(struct drm_device *dev, |
| void *data, struct drm_file *file_priv); |
| extern int drm_mode_setplane(struct drm_device *dev, |
| void *data, struct drm_file *file_priv); |
| extern int drm_mode_cursor_ioctl(struct drm_device *dev, |
| void *data, struct drm_file *file_priv); |
| extern int drm_mode_addfb(struct drm_device *dev, |
| void *data, struct drm_file *file_priv); |
| extern int drm_mode_addfb2(struct drm_device *dev, |
| void *data, struct drm_file *file_priv); |
| extern uint32_t drm_mode_legacy_fb_format(uint32_t bpp, uint32_t depth); |
| extern int drm_mode_rmfb(struct drm_device *dev, |
| void *data, struct drm_file *file_priv); |
| extern int drm_mode_getfb(struct drm_device *dev, |