| /drivers/include/drm/i915_powerwell.h |
|---|
| File deleted |
| /drivers/include/drm/drmP.h |
|---|
| 45,8 → 45,6 |
| #include <linux/kernel.h> |
| #include <linux/kref.h> |
| #include <linux/mm.h> |
| #include <linux/spinlock.h> |
| #include <linux/mutex.h> |
| #include <linux/pci.h> |
| #include <linux/sched.h> |
| 62,6 → 60,8 |
| #include <linux/vmalloc.h> |
| #include <linux/workqueue.h> |
| #include <asm/uaccess.h> |
| #include <uapi/drm/drm.h> |
| #include <uapi/drm/drm_mode.h> |
| 190,6 → 190,8 |
| drm_err(fmt, ##__VA_ARGS__); \ |
| }) |
| #if DRM_DEBUG_CODE |
| #define DRM_INFO(fmt, ...) \ |
| printk(KERN_INFO "[" DRM_NAME "] " fmt, ##__VA_ARGS__) |
| 202,7 → 204,6 |
| * \param fmt printf() like format string. |
| * \param arg arguments |
| */ |
| #if DRM_DEBUG_CODE |
| #define DRM_DEBUG(fmt, args...) \ |
| do { \ |
| printk(KERN_INFO "[" DRM_NAME "] " fmt, ##args); \ |
| 230,6 → 231,7 |
| } while (0) |
| #else |
| #define DRM_INFO(fmt, ...) do { } while (0) |
| #define DRM_DEBUG_DRIVER(fmt, args...) do { } while (0) |
| #define DRM_DEBUG_KMS(fmt, args...) do { } while (0) |
| #define DRM_DEBUG_PRIME(fmt, args...) do { } while (0) |
| 293,6 → 295,7 |
| struct drm_pending_event { |
| struct drm_event *event; |
| struct list_head link; |
| struct list_head pending_link; |
| struct drm_file *file_priv; |
| pid_t pid; /* pid of requester, no guarantee it's valid by the time |
| we deliver the event, for tracing only */ |
| 351,8 → 354,11 |
| struct list_head blobs; |
| wait_queue_head_t event_wait; |
| struct list_head pending_event_list; |
| struct list_head event_list; |
| int event_space; |
| struct mutex event_read_lock; |
| }; |
| /** |
| 801,16 → 807,26 |
| unsigned int cmd, unsigned long arg); |
| extern bool drm_ioctl_flags(unsigned int nr, unsigned int *flags); |
| /* Device support (drm_fops.h) */ |
| extern int drm_open(struct inode *inode, struct file *filp); |
| extern ssize_t drm_read(struct file *filp, char __user *buffer, |
| /* File Operations (drm_fops.c) */ |
| int drm_open(struct inode *inode, struct file *filp); |
| ssize_t drm_read(struct file *filp, char __user *buffer, |
| size_t count, loff_t *offset); |
| extern int drm_release(struct inode *inode, struct file *filp); |
| extern int drm_new_set_master(struct drm_device *dev, struct drm_file *fpriv); |
| int drm_release(struct inode *inode, struct file *filp); |
| int drm_new_set_master(struct drm_device *dev, struct drm_file *fpriv); |
| unsigned int drm_poll(struct file *filp, struct poll_table_struct *wait); |
| int drm_event_reserve_init_locked(struct drm_device *dev, |
| struct drm_file *file_priv, |
| struct drm_pending_event *p, |
| struct drm_event *e); |
| int drm_event_reserve_init(struct drm_device *dev, |
| struct drm_file *file_priv, |
| struct drm_pending_event *p, |
| struct drm_event *e); |
| void drm_event_cancel_free(struct drm_device *dev, |
| struct drm_pending_event *p); |
| void drm_send_event_locked(struct drm_device *dev, struct drm_pending_event *e); |
| void drm_send_event(struct drm_device *dev, struct drm_pending_event *e); |
| /* Mapping support (drm_vm.h) */ |
| extern unsigned int drm_poll(struct file *filp, struct poll_table_struct *wait); |
| /* Misc. IOCTL support (drm_ioctl.c) */ |
| int drm_noop(struct drm_device *dev, void *data, |
| struct drm_file *file_priv); |
| /drivers/include/drm/drm_atomic_helper.h |
|---|
| 146,6 → 146,9 |
| struct drm_connector_state *state); |
| void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector, |
| struct drm_connector_state *state); |
| void drm_atomic_helper_legacy_gamma_set(struct drm_crtc *crtc, |
| u16 *red, u16 *green, u16 *blue, |
| uint32_t start, uint32_t size); |
| /** |
| * drm_atomic_crtc_for_each_plane - iterate over planes currently attached to CRTC |
| /drivers/include/drm/drm_crtc.h |
|---|
| 305,12 → 305,20 |
| * @mode_changed: crtc_state->mode or crtc_state->enable has been changed |
| * @active_changed: crtc_state->active has been toggled. |
| * @connectors_changed: connectors to this crtc have been updated |
| * @color_mgmt_changed: color management properties have changed (degamma or |
| * gamma LUT or CSC matrix) |
| * @plane_mask: bitmask of (1 << drm_plane_index(plane)) of attached planes |
| * @connector_mask: bitmask of (1 << drm_connector_index(connector)) of attached connectors |
| * @encoder_mask: bitmask of (1 << drm_encoder_index(encoder)) of attached encoders |
| * @last_vblank_count: for helpers and drivers to capture the vblank of the |
| * update to ensure framebuffer cleanup isn't done too early |
| * @adjusted_mode: for use by helpers and drivers to compute adjusted mode timings |
| * @mode: current mode timings |
| * @degamma_lut: Lookup table for converting framebuffer pixel data |
| * before apply the conversion matrix |
| * @ctm: Transformation matrix |
| * @gamma_lut: Lookup table for converting pixel data after the |
| * conversion matrix |
| * @event: optional pointer to a DRM event to signal upon completion of the |
| * state update |
| * @state: backpointer to global drm_atomic_state |
| 332,6 → 340,7 |
| bool mode_changed : 1; |
| bool active_changed : 1; |
| bool connectors_changed : 1; |
| bool color_mgmt_changed : 1; |
| /* attached planes bitmask: |
| * WARNING: transitional helpers do not maintain plane_mask so |
| 341,6 → 350,7 |
| u32 plane_mask; |
| u32 connector_mask; |
| u32 encoder_mask; |
| /* last_vblank_count: for vblank waits before cleanup */ |
| u32 last_vblank_count; |
| 353,6 → 363,11 |
| /* blob property to expose current mode to atomic userspace */ |
| struct drm_property_blob *mode_blob; |
| /* blob property to expose color management to userspace */ |
| struct drm_property_blob *degamma_lut; |
| struct drm_property_blob *ctm; |
| struct drm_property_blob *gamma_lut; |
| struct drm_pending_vblank_event *event; |
| struct drm_atomic_state *state; |
| 755,7 → 770,7 |
| int x, y; |
| const struct drm_crtc_funcs *funcs; |
| /* CRTC gamma size for reporting to userspace */ |
| /* Legacy FB CRTC gamma size for reporting to userspace */ |
| uint32_t gamma_size; |
| uint16_t *gamma_store; |
| 1582,6 → 1597,8 |
| * |
| * The bridge can assume that the display pipe (i.e. clocks and timing |
| * signals) feeding it is still running when this callback is called. |
| * |
| * The disable callback is optional. |
| */ |
| void (*disable)(struct drm_bridge *bridge); |
| 1598,6 → 1615,8 |
| * The bridge must assume that the display pipe (i.e. clocks and timing |
| * singals) feeding it is no longer running when this callback is |
| * called. |
| * |
| * The post_disable callback is optional. |
| */ |
| void (*post_disable)(struct drm_bridge *bridge); |
| 1626,6 → 1645,8 |
| * will not yet be running when this callback is called. The bridge must |
| * not enable the display link feeding the next bridge in the chain (if |
| * there is one) when this callback is called. |
| * |
| * The pre_enable callback is optional. |
| */ |
| void (*pre_enable)(struct drm_bridge *bridge); |
| 1643,6 → 1664,8 |
| * signals) feeding it is running when this callback is called. This |
| * callback must enable the display link feeding the next bridge in the |
| * chain if there is one. |
| * |
| * The enable callback is optional. |
| */ |
| void (*enable)(struct drm_bridge *bridge); |
| }; |
| 1675,6 → 1698,7 |
| * @dev: parent DRM device |
| * @allow_modeset: allow full modeset |
| * @legacy_cursor_update: hint to enforce legacy cursor IOCTL semantics |
| * @legacy_set_config: Disable conflicting encoders instead of failing with -EINVAL. |
| * @planes: pointer to array of plane pointers |
| * @plane_states: pointer to array of plane states pointers |
| * @crtcs: pointer to array of CRTC pointers |
| 1688,6 → 1712,7 |
| struct drm_device *dev; |
| bool allow_modeset : 1; |
| bool legacy_cursor_update : 1; |
| bool legacy_set_config : 1; |
| struct drm_plane **planes; |
| struct drm_plane_state **plane_states; |
| struct drm_crtc **crtcs; |
| 2024,6 → 2049,15 |
| * @property_blob_list: list of all the blob property objects |
| * @blob_lock: mutex for blob property allocation and management |
| * @*_property: core property tracking |
| * @degamma_lut_property: LUT used to convert the framebuffer's colors to linear |
| * gamma |
| * @degamma_lut_size_property: size of the degamma LUT as supported by the |
| * driver (read-only) |
| * @ctm_property: Matrix used to convert colors after the lookup in the |
| * degamma LUT |
| * @gamma_lut_property: LUT used to convert the colors, after the CSC matrix, to |
| * the gamma space of the connected screen (read-only) |
| * @gamma_lut_size_property: size of the gamma LUT as supported by the driver |
| * @preferred_depth: preferred RBG pixel depth, used by fb helpers |
| * @prefer_shadow: hint to userspace to prefer shadow-fb rendering |
| * @async_page_flip: does this device support async flips on the primary plane? |
| 2126,6 → 2160,13 |
| struct drm_property *aspect_ratio_property; |
| struct drm_property *dirty_info_property; |
| /* Optional color correction properties */ |
| struct drm_property *degamma_lut_property; |
| struct drm_property *degamma_lut_size_property; |
| struct drm_property *ctm_property; |
| struct drm_property *gamma_lut_property; |
| struct drm_property *gamma_lut_size_property; |
| /* properties for virtual machine layout */ |
| struct drm_property *suggested_x_property; |
| struct drm_property *suggested_y_property; |
| 2155,6 → 2196,17 |
| list_for_each_entry((plane), &(dev)->mode_config.plane_list, head) \ |
| for_each_if ((plane_mask) & (1 << drm_plane_index(plane))) |
| /** |
| * drm_for_each_encoder_mask - iterate over encoders specified by bitmask |
| * @encoder: the loop cursor |
| * @dev: the DRM device |
| * @encoder_mask: bitmask of encoder indices |
| * |
| * Iterate over all encoders specified by bitmask. |
| */ |
| #define drm_for_each_encoder_mask(encoder, dev, encoder_mask) \ |
| list_for_each_entry((encoder), &(dev)->mode_config.encoder_list, head) \ |
| for_each_if ((encoder_mask) & (1 << drm_encoder_index(encoder))) |
| #define obj_to_crtc(x) container_of(x, struct drm_crtc, base) |
| #define obj_to_connector(x) container_of(x, struct drm_connector, base) |
| 2231,6 → 2283,7 |
| struct drm_encoder *encoder, |
| const struct drm_encoder_funcs *funcs, |
| int encoder_type, const char *name, ...); |
| extern unsigned int drm_encoder_index(struct drm_encoder *encoder); |
| /** |
| * drm_encoder_crtc_ok - can a given crtc drive a given encoder? |
| 2288,6 → 2341,8 |
| extern bool drm_probe_ddc(struct i2c_adapter *adapter); |
| extern struct edid *drm_get_edid(struct drm_connector *connector, |
| struct i2c_adapter *adapter); |
| extern struct edid *drm_get_edid_switcheroo(struct drm_connector *connector, |
| struct i2c_adapter *adapter); |
| extern struct edid *drm_edid_duplicate(const struct edid *edid); |
| extern int drm_add_edid_modes(struct drm_connector *connector, struct edid *edid); |
| extern void drm_mode_config_init(struct drm_device *dev); |
| 2488,6 → 2543,8 |
| extern int drm_format_plane_cpp(uint32_t format, int plane); |
| extern int drm_format_horz_chroma_subsampling(uint32_t format); |
| extern int drm_format_vert_chroma_subsampling(uint32_t format); |
| extern int drm_format_plane_width(int width, uint32_t format, int plane); |
| extern int drm_format_plane_height(int height, uint32_t format, int plane); |
| extern const char *drm_get_format_name(uint32_t format); |
| extern struct drm_property *drm_mode_create_rotation_property(struct drm_device *dev, |
| unsigned int supported_rotations); |
| 2536,6 → 2593,21 |
| return mo ? obj_to_property(mo) : NULL; |
| } |
| /* |
| * Extract a degamma/gamma LUT value provided by user and round it to the |
| * precision supported by the hardware. |
| */ |
| static inline uint32_t drm_color_lut_extract(uint32_t user_input, |
| uint32_t bit_precision) |
| { |
| uint32_t val = user_input + (1 << (16 - bit_precision - 1)); |
| uint32_t max = 0xffff >> (16 - bit_precision); |
| val >>= 16 - bit_precision; |
| return clamp_val(val, 0, max); |
| } |
| /* Plane list iterator for legacy (overlay only) planes. */ |
| #define drm_for_each_legacy_plane(plane, dev) \ |
| list_for_each_entry(plane, &(dev)->mode_config.plane_list, head) \ |
| /drivers/include/drm/drm_crtc_helper.h |
|---|
| 48,6 → 48,9 |
| struct drm_display_mode *mode, |
| int x, int y, |
| struct drm_framebuffer *old_fb); |
| extern void drm_helper_crtc_enable_color_mgmt(struct drm_crtc *crtc, |
| int degamma_lut_size, |
| int gamma_lut_size); |
| extern bool drm_helper_crtc_in_use(struct drm_crtc *crtc); |
| extern bool drm_helper_encoder_in_use(struct drm_encoder *encoder); |
| /drivers/include/drm/drm_dp_aux_dev.h |
|---|
| 0,0 → 1,62 |
| /* |
| * Copyright © 2015 Intel Corporation |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| * and/or sell copies of the Software, and to permit persons to whom the |
| * Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the next |
| * paragraph) shall be included in all copies or substantial portions of the |
| * Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| * IN THE SOFTWARE. |
| * |
| * Authors: |
| * Rafael Antognolli <rafael.antognolli@intel.com> |
| * |
| */ |
| #ifndef DRM_DP_AUX_DEV |
| #define DRM_DP_AUX_DEV |
| #include <drm/drm_dp_helper.h> |
| #ifdef CONFIG_DRM_DP_AUX_CHARDEV |
| int drm_dp_aux_dev_init(void); |
| void drm_dp_aux_dev_exit(void); |
| int drm_dp_aux_register_devnode(struct drm_dp_aux *aux); |
| void drm_dp_aux_unregister_devnode(struct drm_dp_aux *aux); |
| #else |
| static inline int drm_dp_aux_dev_init(void) |
| { |
| return 0; |
| } |
| static inline void drm_dp_aux_dev_exit(void) |
| { |
| } |
| static inline int drm_dp_aux_register_devnode(struct drm_dp_aux *aux) |
| { |
| return 0; |
| } |
| static inline void drm_dp_aux_unregister_devnode(struct drm_dp_aux *aux) |
| { |
| } |
| #endif |
| #endif |
| /drivers/include/drm/drm_dp_dual_mode_helper.h |
|---|
| 0,0 → 1,92 |
| /* |
| * Copyright © 2016 Intel Corporation |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| * and/or sell copies of the Software, and to permit persons to whom the |
| * Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in |
| * all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR |
| * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
| * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
| * OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| #ifndef DRM_DP_DUAL_MODE_HELPER_H |
| #define DRM_DP_DUAL_MODE_HELPER_H |
| #include <linux/types.h> |
| /* |
| * Optional for type 1 DVI adaptors |
| * Mandatory for type 1 HDMI and type 2 adaptors |
| */ |
| #define DP_DUAL_MODE_HDMI_ID 0x00 /* 00-0f */ |
| #define DP_DUAL_MODE_HDMI_ID_LEN 16 |
| /* |
| * Optional for type 1 adaptors |
| * Mandatory for type 2 adaptors |
| */ |
| #define DP_DUAL_MODE_ADAPTOR_ID 0x10 |
| #define DP_DUAL_MODE_REV_MASK 0x07 |
| #define DP_DUAL_MODE_REV_TYPE2 0x00 |
| #define DP_DUAL_MODE_TYPE_MASK 0xf0 |
| #define DP_DUAL_MODE_TYPE_TYPE2 0xa0 |
| #define DP_DUAL_MODE_IEEE_OUI 0x11 /* 11-13*/ |
| #define DP_DUAL_IEEE_OUI_LEN 3 |
| #define DP_DUAL_DEVICE_ID 0x14 /* 14-19 */ |
| #define DP_DUAL_DEVICE_ID_LEN 6 |
| #define DP_DUAL_MODE_HARDWARE_REV 0x1a |
| #define DP_DUAL_MODE_FIRMWARE_MAJOR_REV 0x1b |
| #define DP_DUAL_MODE_FIRMWARE_MINOR_REV 0x1c |
| #define DP_DUAL_MODE_MAX_TMDS_CLOCK 0x1d |
| #define DP_DUAL_MODE_I2C_SPEED_CAP 0x1e |
| #define DP_DUAL_MODE_TMDS_OEN 0x20 |
| #define DP_DUAL_MODE_TMDS_DISABLE 0x01 |
| #define DP_DUAL_MODE_HDMI_PIN_CTRL 0x21 |
| #define DP_DUAL_MODE_CEC_ENABLE 0x01 |
| #define DP_DUAL_MODE_I2C_SPEED_CTRL 0x22 |
| struct i2c_adapter; |
| ssize_t drm_dp_dual_mode_read(struct i2c_adapter *adapter, |
| u8 offset, void *buffer, size_t size); |
| ssize_t drm_dp_dual_mode_write(struct i2c_adapter *adapter, |
| u8 offset, const void *buffer, size_t size); |
| /** |
| * enum drm_dp_dual_mode_type - Type of the DP dual mode adaptor |
| * @DRM_DP_DUAL_MODE_NONE: No DP dual mode adaptor |
| * @DRM_DP_DUAL_MODE_UNKNOWN: Could be either none or type 1 DVI adaptor |
| * @DRM_DP_DUAL_MODE_TYPE1_DVI: Type 1 DVI adaptor |
| * @DRM_DP_DUAL_MODE_TYPE1_HDMI: Type 1 HDMI adaptor |
| * @DRM_DP_DUAL_MODE_TYPE2_DVI: Type 2 DVI adaptor |
| * @DRM_DP_DUAL_MODE_TYPE2_HDMI: Type 2 HDMI adaptor |
| */ |
| enum drm_dp_dual_mode_type { |
| DRM_DP_DUAL_MODE_NONE, |
| DRM_DP_DUAL_MODE_UNKNOWN, |
| DRM_DP_DUAL_MODE_TYPE1_DVI, |
| DRM_DP_DUAL_MODE_TYPE1_HDMI, |
| DRM_DP_DUAL_MODE_TYPE2_DVI, |
| DRM_DP_DUAL_MODE_TYPE2_HDMI, |
| }; |
| enum drm_dp_dual_mode_type drm_dp_dual_mode_detect(struct i2c_adapter *adapter); |
| int drm_dp_dual_mode_max_tmds_clock(enum drm_dp_dual_mode_type type, |
| struct i2c_adapter *adapter); |
| int drm_dp_dual_mode_get_tmds_output(enum drm_dp_dual_mode_type type, |
| struct i2c_adapter *adapter, bool *enabled); |
| int drm_dp_dual_mode_set_tmds_output(enum drm_dp_dual_mode_type type, |
| struct i2c_adapter *adapter, bool enable); |
| const char *drm_dp_get_dual_mode_type_name(enum drm_dp_dual_mode_type type); |
| #endif |
| /drivers/include/drm/drm_edid.h |
|---|
| 403,6 → 403,18 |
| return DRM_ELD_HEADER_BLOCK_SIZE + eld[DRM_ELD_BASELINE_ELD_LEN] * 4; |
| } |
| /** |
| * drm_eld_get_conn_type - Get device type hdmi/dp connected |
| * @eld: pointer to an ELD memory structure |
| * |
| * The caller need to use %DRM_ELD_CONN_TYPE_HDMI or %DRM_ELD_CONN_TYPE_DP to |
| * identify the display type connected. |
| */ |
| static inline u8 drm_eld_get_conn_type(const uint8_t *eld) |
| { |
| return eld[DRM_ELD_SAD_COUNT_CONN_TYPE] & DRM_ELD_CONN_TYPE_MASK; |
| } |
| struct edid *drm_do_get_edid(struct drm_connector *connector, |
| int (*get_edid_block)(void *data, u8 *buf, unsigned int block, |
| size_t len), |
| /drivers/include/drm/drm_fb_helper.h |
|---|
| 219,6 → 219,7 |
| }; |
| #ifdef CONFIG_DRM_FBDEV_EMULATION |
| int drm_fb_helper_modinit(void); |
| void drm_fb_helper_prepare(struct drm_device *dev, struct drm_fb_helper *helper, |
| const struct drm_fb_helper_funcs *funcs); |
| int drm_fb_helper_init(struct drm_device *dev, |
| 283,6 → 284,11 |
| int drm_fb_helper_remove_one_connector(struct drm_fb_helper *fb_helper, |
| struct drm_connector *connector); |
| #else |
| static inline int drm_fb_helper_modinit(void) |
| { |
| return 0; |
| } |
| static inline void drm_fb_helper_prepare(struct drm_device *dev, |
| struct drm_fb_helper *helper, |
| const struct drm_fb_helper_funcs *funcs) |
| /drivers/include/drm/drm_mipi_dsi.h |
|---|
| 96,14 → 96,17 |
| * struct mipi_dsi_host - DSI host device |
| * @dev: driver model device node for this DSI host |
| * @ops: DSI host operations |
| * @list: list management |
| */ |
| struct mipi_dsi_host { |
| struct device *dev; |
| const struct mipi_dsi_host_ops *ops; |
| struct list_head list; |
| }; |
| int mipi_dsi_host_register(struct mipi_dsi_host *host); |
| void mipi_dsi_host_unregister(struct mipi_dsi_host *host); |
| struct mipi_dsi_host *of_find_mipi_dsi_host_by_node(struct device_node *node); |
| /* DSI mode flags */ |
| 139,10 → 142,28 |
| MIPI_DSI_FMT_RGB565, |
| }; |
| #define DSI_DEV_NAME_SIZE 20 |
| /** |
| * struct mipi_dsi_device_info - template for creating a mipi_dsi_device |
| * @type: DSI peripheral chip type |
| * @channel: DSI virtual channel assigned to peripheral |
| * @node: pointer to OF device node or NULL |
| * |
| * This is populated and passed to mipi_dsi_device_new to create a new |
| * DSI device |
| */ |
| struct mipi_dsi_device_info { |
| char type[DSI_DEV_NAME_SIZE]; |
| u32 channel; |
| struct device_node *node; |
| }; |
| /** |
| * struct mipi_dsi_device - DSI peripheral device |
| * @host: DSI host for this peripheral |
| * @dev: driver model device node for this peripheral |
| * @name: DSI peripheral chip type |
| * @channel: virtual channel assigned to the peripheral |
| * @format: pixel format for video mode |
| * @lanes: number of active data lanes |
| 152,6 → 173,7 |
| struct mipi_dsi_host *host; |
| struct device dev; |
| char name[DSI_DEV_NAME_SIZE]; |
| unsigned int channel; |
| unsigned int lanes; |
| enum mipi_dsi_pixel_format format; |
| 188,6 → 210,10 |
| return -EINVAL; |
| } |
| struct mipi_dsi_device * |
| mipi_dsi_device_register_full(struct mipi_dsi_host *host, |
| const struct mipi_dsi_device_info *info); |
| void mipi_dsi_device_unregister(struct mipi_dsi_device *dsi); |
| struct mipi_dsi_device *of_find_mipi_dsi_device_by_node(struct device_node *np); |
| int mipi_dsi_attach(struct mipi_dsi_device *dsi); |
| int mipi_dsi_detach(struct mipi_dsi_device *dsi); |
| /drivers/include/drm/drm_modeset_helper_vtables.h |
|---|
| 439,7 → 439,7 |
| * can be modified by this callback and does not need to match mode. |
| * |
| * This function is used by both legacy CRTC helpers and atomic helpers. |
| * With atomic helpers it is optional. |
| * This hook is optional. |
| * |
| * NOTE: |
| * |
| /drivers/include/drm/i915_pciids.h |
|---|
| 277,7 → 277,9 |
| INTEL_VGA_DEVICE(0x191D, info) /* WKS GT2 */ |
| #define INTEL_SKL_GT3_IDS(info) \ |
| INTEL_VGA_DEVICE(0x1923, info), /* ULT GT3 */ \ |
| INTEL_VGA_DEVICE(0x1926, info), /* ULT GT3 */ \ |
| INTEL_VGA_DEVICE(0x1927, info), /* ULT GT3 */ \ |
| INTEL_VGA_DEVICE(0x192B, info), /* Halo GT3 */ \ |
| INTEL_VGA_DEVICE(0x192A, info) /* SRV GT3 */ |
| 296,7 → 298,9 |
| #define INTEL_BXT_IDS(info) \ |
| INTEL_VGA_DEVICE(0x0A84, info), \ |
| INTEL_VGA_DEVICE(0x1A84, info), \ |
| INTEL_VGA_DEVICE(0x5A84, info) |
| INTEL_VGA_DEVICE(0x1A85, info), \ |
| INTEL_VGA_DEVICE(0x5A84, info), /* APL HD Graphics 505 */ \ |
| INTEL_VGA_DEVICE(0x5A85, info) /* APL HD Graphics 500 */ |
| #define INTEL_KBL_GT1_IDS(info) \ |
| INTEL_VGA_DEVICE(0x5913, info), /* ULT GT1.5 */ \ |
| /drivers/include/drm/ttm/ttm_bo_api.h |
|---|
| 316,7 → 316,21 |
| */ |
| extern int ttm_bo_wait(struct ttm_buffer_object *bo, bool lazy, |
| bool interruptible, bool no_wait); |
| /** |
| * ttm_bo_mem_compat - Check if proposed placement is compatible with a bo |
| * |
| * @placement: Return immediately if buffer is busy. |
| * @mem: The struct ttm_mem_reg indicating the region where the bo resides |
| * @new_flags: Describes compatible placement found |
| * |
| * Returns true if the placement is compatible |
| */ |
| extern bool ttm_bo_mem_compat(struct ttm_placement *placement, |
| struct ttm_mem_reg *mem, |
| uint32_t *new_flags); |
| /** |
| * ttm_bo_validate |
| * |
| * @bo: The buffer object. |