| /drivers/include/drm/drmP.h |
|---|
| 81,12 → 81,12 |
| #include <linux/workqueue.h> |
| #include "drm.h" |
| #include <drm/drm.h> |
| #include <drm/drm_vma_manager.h> |
| #include <linux/idr.h> |
| #define __OS_HAS_AGP (defined(CONFIG_AGP) || (defined(CONFIG_AGP_MODULE) && defined(MODULE))) |
| #define __OS_HAS_MTRR (defined(CONFIG_MTRR)) |
| struct module; |
| 95,6 → 95,14 |
| struct device_node; |
| struct videomode; |
| struct inode; |
| struct poll_table_struct; |
| struct drm_lock_data; |
| struct sg_table; |
| struct dma_buf; |
| //#include <drm/drm_os_linux.h> |
| #include <drm/drm_hashtab.h> |
| #include <drm/drm_mm.h> |
| 159,19 → 167,15 |
| /* driver capabilities and requirements mask */ |
| #define DRIVER_USE_AGP 0x1 |
| #define DRIVER_REQUIRE_AGP 0x2 |
| #define DRIVER_USE_MTRR 0x4 |
| #define DRIVER_PCI_DMA 0x8 |
| #define DRIVER_SG 0x10 |
| #define DRIVER_HAVE_DMA 0x20 |
| #define DRIVER_HAVE_IRQ 0x40 |
| #define DRIVER_IRQ_SHARED 0x80 |
| #define DRIVER_IRQ_VBL 0x100 |
| #define DRIVER_DMA_QUEUE 0x200 |
| #define DRIVER_FB_DMA 0x400 |
| #define DRIVER_IRQ_VBL2 0x800 |
| #define DRIVER_GEM 0x1000 |
| #define DRIVER_MODESET 0x2000 |
| #define DRIVER_PRIME 0x4000 |
| #define DRIVER_RENDER 0x8000 |
| #define DRIVER_BUS_PCI 0x1 |
| #define DRIVER_BUS_PLATFORM 0x2 |
| 274,9 → 278,6 |
| #define DRM_ARRAY_SIZE(x) ARRAY_SIZE(x) |
| #define DRM_LEFTCOUNT(x) (((x)->rp + (x)->count - (x)->wp) % ((x)->count + 1)) |
| #define DRM_BUFCOUNT(x) ((x)->count - DRM_LEFTCOUNT(x)) |
| #define DRM_IF_VERSION(maj, min) (maj << 16 | min) |
| /** |
| 319,6 → 320,7 |
| #define DRM_ROOT_ONLY 0x4 |
| #define DRM_CONTROL_ALLOW 0x8 |
| #define DRM_UNLOCKED 0x10 |
| #define DRM_RENDER_ALLOW 0x20 |
| struct drm_ioctl_desc { |
| unsigned int cmd; |
| 574,7 → 576,6 |
| typedef struct drm_local_map drm_local_map_t; |
| #if 0 |
| /** |
| * Mappings list |
| */ |
| 584,7 → 585,6 |
| struct drm_local_map *map; /**< mapping */ |
| uint64_t user_token; |
| struct drm_master *master; |
| struct drm_mm_node *file_offset_node; /**< fake offset */ |
| }; |
| /** |
| 619,12 → 619,9 |
| * GEM specific mm private for tracking GEM objects |
| */ |
| struct drm_gem_mm { |
| struct drm_mm offset_manager; /**< Offset mgmt for buffer objects */ |
| struct drm_open_hash offset_hash; /**< User token hash table for maps */ |
| struct drm_vma_offset_manager vma_manager; |
| }; |
| #endif |
| /** |
| * This structure defines the drm_mm memory object, which will be used by the |
| * DRM for its buffer objects. |
| 633,8 → 630,16 |
| /** Reference count of this object */ |
| struct kref refcount; |
| /** Handle count of this object. Each handle also holds a reference */ |
| atomic_t handle_count; /* number of handles on this object */ |
| /** |
| * handle_count - gem file_priv handle count of this object |
| * |
| * Each handle also holds a reference. Note that when the handle_count |
| * drops to 0 any global names (e.g. the id in the flink namespace) will |
| * be cleared. |
| * |
| * Protected by dev->object_name_lock. |
| * */ |
| unsigned handle_count; |
| /** Related drm device */ |
| struct drm_device *dev; |
| 643,6 → 648,7 |
| struct file *filp; |
| /* Mapping info for this object */ |
| struct drm_vma_offset_node vma_node; |
| /** |
| * Size of the object, in bytes. Immutable over the object's |
| 731,6 → 737,7 |
| int (*irq_by_busid)(struct drm_device *dev, struct drm_irq_busid *p); |
| /* hooks that are for PCI */ |
| int (*agp_init)(struct drm_device *dev); |
| void (*agp_destroy)(struct drm_device *dev); |
| }; |
| 879,8 → 886,6 |
| void (*irq_preinstall) (struct drm_device *dev); |
| int (*irq_postinstall) (struct drm_device *dev); |
| void (*irq_uninstall) (struct drm_device *dev); |
| void (*set_version) (struct drm_device *dev, |
| struct drm_set_version *sv); |
| /* Master routines */ |
| int (*master_create)(struct drm_device *dev, struct drm_master *master); |
| 949,7 → 954,7 |
| u32 driver_features; |
| int dev_priv_size; |
| struct drm_ioctl_desc *ioctls; |
| const struct drm_ioctl_desc *ioctls; |
| int num_ioctls; |
| const struct file_operations *fops; |
| union { |
| 968,6 → 973,7 |
| #define DRM_IRQ_ARGS int irq, void *arg |
| struct drm_driver { |
| int (*load) (struct drm_device *, unsigned long flags); |
| int (*open) (struct drm_device *, struct drm_file *); |
| irqreturn_t (*irq_handler) (DRM_IRQ_ARGS); |
| 1126,12 → 1132,7 |
| /*@{ */ |
| int irq_enabled; /**< True if irq handler is enabled */ |
| __volatile__ long context_flag; /**< Context swapping flag */ |
| __volatile__ long interrupt_flag; /**< Interruption handler flag */ |
| __volatile__ long dma_flag; /**< DMA dispatch flag */ |
| // wait_queue_head_t context_wait; /**< Processes waiting on ctx switch */ |
| int last_checked; /**< Last context checked for DMA */ |
| int last_context; /**< Last current context */ |
| unsigned long last_switch; /**< jiffies at last context switch */ |
| /*@} */ |
| // struct work_struct work; |
| 1169,13 → 1170,7 |
| spinlock_t event_lock; |
| /*@} */ |
| // cycles_t ctx_start; |
| // cycles_t lck_start; |
| // struct fasync_struct *buf_async;/**< Processes waiting for SIGIO */ |
| // wait_queue_head_t buf_readers; /**< Processes waiting to read */ |
| // wait_queue_head_t buf_writers; /**< Processes waiting to ctx switch */ |
| // struct drm_agp_head *agp; /**< AGP data */ |
| struct device *dev; /**< Device structure */ |
| 1199,7 → 1194,7 |
| /** \name GEM information */ |
| /*@{ */ |
| spinlock_t object_name_lock; |
| struct mutex object_name_lock; |
| struct idr object_name_idr; |
| /*@} */ |
| int switch_power_state; |
| 1210,6 → 1205,7 |
| #define DRM_SWITCH_POWER_ON 0 |
| #define DRM_SWITCH_POWER_OFF 1 |
| #define DRM_SWITCH_POWER_CHANGING 2 |
| #define DRM_SWITCH_POWER_DYNAMIC_OFF 3 |
| static __inline__ int drm_core_check_feature(struct drm_device *dev, |
| int feature) |
| 1222,26 → 1218,6 |
| return dev->pdev->irq; |
| } |
| #if 0 |
| #if __OS_HAS_AGP |
| static inline int drm_core_has_AGP(struct drm_device *dev) |
| { |
| return drm_core_check_feature(dev, DRIVER_USE_AGP); |
| } |
| #else |
| #define drm_core_has_AGP(dev) (0) |
| #endif |
| #if __OS_HAS_MTRR |
| static inline int drm_core_has_MTRR(struct drm_device *dev) |
| { |
| return drm_core_check_feature(dev, DRIVER_USE_MTRR); |
| } |
| #else |
| #define drm_core_has_MTRR(dev) (0) |
| #endif |
| static inline void drm_device_set_unplugged(struct drm_device *dev) |
| { |
| smp_wmb(); |
| 1275,7 → 1251,6 |
| extern struct mutex drm_global_mutex; |
| extern int drm_open(struct inode *inode, struct file *filp); |
| extern int drm_stub_open(struct inode *inode, struct file *filp); |
| extern int drm_fasync(int fd, struct file *filp, int on); |
| extern 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); |
| 1289,14 → 1264,6 |
| /* Memory management support (drm_memory.h) */ |
| #include <drm/drm_memory.h> |
| extern void drm_free_agp(DRM_AGP_MEM * handle, int pages); |
| extern int drm_bind_agp(DRM_AGP_MEM * handle, unsigned int start); |
| extern DRM_AGP_MEM *drm_agp_bind_pages(struct drm_device *dev, |
| struct page **pages, |
| unsigned long num_pages, |
| uint32_t gtt_offset, |
| uint32_t type); |
| extern int drm_unbind_agp(DRM_AGP_MEM * handle); |
| /* Misc. IOCTL support (drm_ioctl.h) */ |
| extern int drm_irq_by_busid(struct drm_device *dev, void *data, |
| 1323,8 → 1290,6 |
| struct drm_file *file_priv); |
| extern int drm_addctx(struct drm_device *dev, void *data, |
| struct drm_file *file_priv); |
| extern int drm_modctx(struct drm_device *dev, void *data, |
| struct drm_file *file_priv); |
| extern int drm_getctx(struct drm_device *dev, void *data, |
| struct drm_file *file_priv); |
| extern int drm_switchctx(struct drm_device *dev, void *data, |
| 1396,8 → 1361,8 |
| extern int drm_order(unsigned long size); |
| /* DMA support (drm_dma.h) */ |
| extern int drm_dma_setup(struct drm_device *dev); |
| extern void drm_dma_takedown(struct drm_device *dev); |
| extern int drm_legacy_dma_setup(struct drm_device *dev); |
| extern void drm_legacy_dma_takedown(struct drm_device *dev); |
| extern void drm_free_buffer(struct drm_device *dev, struct drm_buf * buf); |
| extern void drm_core_reclaim_buffers(struct drm_device *dev, |
| struct drm_file *filp); |
| 1411,7 → 1376,6 |
| extern int drm_vblank_init(struct drm_device *dev, int num_crtcs); |
| extern int drm_wait_vblank(struct drm_device *dev, void *data, |
| struct drm_file *filp); |
| extern int drm_vblank_wait(struct drm_device *dev, unsigned int *vbl_seq); |
| extern u32 drm_vblank_count(struct drm_device *dev, int crtc); |
| extern u32 drm_vblank_count_and_time(struct drm_device *dev, int crtc, |
| struct timeval *vblanktime); |
| 1453,31 → 1417,6 |
| struct drm_file *file_priv); |
| /* AGP/GART support (drm_agpsupport.h) */ |
| extern struct drm_agp_head *drm_agp_init(struct drm_device *dev); |
| extern int drm_agp_acquire(struct drm_device *dev); |
| extern int drm_agp_acquire_ioctl(struct drm_device *dev, void *data, |
| struct drm_file *file_priv); |
| extern int drm_agp_release(struct drm_device *dev); |
| extern int drm_agp_release_ioctl(struct drm_device *dev, void *data, |
| struct drm_file *file_priv); |
| extern int drm_agp_enable(struct drm_device *dev, struct drm_agp_mode mode); |
| extern int drm_agp_enable_ioctl(struct drm_device *dev, void *data, |
| struct drm_file *file_priv); |
| extern int drm_agp_info(struct drm_device *dev, struct drm_agp_info *info); |
| extern int drm_agp_info_ioctl(struct drm_device *dev, void *data, |
| struct drm_file *file_priv); |
| extern int drm_agp_alloc(struct drm_device *dev, struct drm_agp_buffer *request); |
| extern int drm_agp_alloc_ioctl(struct drm_device *dev, void *data, |
| struct drm_file *file_priv); |
| extern int drm_agp_free(struct drm_device *dev, struct drm_agp_buffer *request); |
| extern int drm_agp_free_ioctl(struct drm_device *dev, void *data, |
| struct drm_file *file_priv); |
| extern int drm_agp_unbind(struct drm_device *dev, struct drm_agp_binding *request); |
| extern int drm_agp_unbind_ioctl(struct drm_device *dev, void *data, |
| struct drm_file *file_priv); |
| extern int drm_agp_bind(struct drm_device *dev, struct drm_agp_binding *request); |
| extern int drm_agp_bind_ioctl(struct drm_device *dev, void *data, |
| struct drm_file *file_priv); |
| /* Stub support (drm_stub.h) */ |
| extern int drm_setmaster_ioctl(struct drm_device *dev, void *data, |
| 1491,9 → 1430,8 |
| extern void drm_put_dev(struct drm_device *dev); |
| extern int drm_put_minor(struct drm_minor **minor); |
| extern void drm_unplug_dev(struct drm_device *dev); |
| #endif |
| extern unsigned int drm_debug; |
| extern unsigned int drm_rnodes; |
| #if 0 |
| extern unsigned int drm_vblank_offdelay; |
| 1501,7 → 1439,6 |
| extern unsigned int drm_timestamp_monotonic; |
| extern struct class *drm_class; |
| extern struct proc_dir_entry *drm_proc_root; |
| extern struct dentry *drm_debugfs_root; |
| extern struct idr drm_minors_idr; |
| 1508,10 → 1445,6 |
| extern struct drm_local_map *drm_getsarea(struct drm_device *dev); |
| /* Proc support (drm_proc.h) */ |
| extern int drm_proc_init(struct drm_minor *minor, struct proc_dir_entry *root); |
| extern int drm_proc_cleanup(struct drm_minor *minor, struct proc_dir_entry *root); |
| /* Debugfs support */ |
| #if defined(CONFIG_DEBUG_FS) |
| extern int drm_debugfs_init(struct drm_minor *minor, int minor_id, |
| 1536,10 → 1469,9 |
| #endif |
| /* Scatter Gather Support (drm_scatter.h) */ |
| extern void drm_sg_cleanup(struct drm_sg_mem * entry); |
| extern int drm_sg_alloc_ioctl(struct drm_device *dev, void *data, |
| extern void drm_legacy_sg_cleanup(struct drm_device *dev); |
| extern int drm_sg_alloc(struct drm_device *dev, void *data, |
| struct drm_file *file_priv); |
| extern int drm_sg_alloc(struct drm_device *dev, struct drm_scatter_gather * request); |
| extern int drm_sg_free(struct drm_device *dev, void *data, |
| struct drm_file *file_priv); |
| 1563,14 → 1495,8 |
| extern int drm_sysfs_device_add(struct drm_minor *minor); |
| extern void drm_sysfs_hotplug_event(struct drm_device *dev); |
| extern void drm_sysfs_device_remove(struct drm_minor *minor); |
| extern char *drm_get_connector_status_name(enum drm_connector_status status); |
| static inline int drm_sysfs_connector_add(struct drm_connector *connector) |
| { return 0; }; |
| static inline void drm_sysfs_connector_remove(struct drm_connector *connector) |
| { }; |
| extern int drm_sysfs_connector_add(struct drm_connector *connector); |
| extern void drm_sysfs_connector_remove(struct drm_connector *connector); |
| #endif |
| /* Graphics Execution Manager library functions (drm_gem.c) */ |
| 1582,13 → 1508,15 |
| size_t size); |
| int drm_gem_object_init(struct drm_device *dev, |
| struct drm_gem_object *obj, size_t size); |
| int drm_gem_private_object_init(struct drm_device *dev, |
| void drm_gem_private_object_init(struct drm_device *dev, |
| struct drm_gem_object *obj, size_t size); |
| void drm_gem_object_handle_free(struct drm_gem_object *obj); |
| void drm_gem_vm_open(struct vm_area_struct *vma); |
| void drm_gem_vm_close(struct vm_area_struct *vma); |
| int drm_gem_mmap_obj(struct drm_gem_object *obj, unsigned long obj_size, |
| struct vm_area_struct *vma); |
| int drm_gem_mmap(struct file *filp, struct vm_area_struct *vma); |
| #include <drm/drm_global.h> |
| static inline void |
| drm_gem_object_reference(struct drm_gem_object *obj) |
| 1606,67 → 1534,33 |
| static inline void |
| drm_gem_object_unreference_unlocked(struct drm_gem_object *obj) |
| { |
| if (obj != NULL) { |
| if (obj && !atomic_add_unless(&obj->refcount.refcount, -1, 1)) { |
| struct drm_device *dev = obj->dev; |
| mutex_lock(&dev->struct_mutex); |
| kref_put(&obj->refcount, drm_gem_object_free); |
| if (likely(atomic_dec_and_test(&obj->refcount.refcount))) |
| drm_gem_object_free(&obj->refcount); |
| mutex_unlock(&dev->struct_mutex); |
| } |
| } |
| int drm_gem_handle_create_tail(struct drm_file *file_priv, |
| struct drm_gem_object *obj, |
| u32 *handlep); |
| int drm_gem_handle_create(struct drm_file *file_priv, |
| struct drm_gem_object *obj, |
| u32 *handlep); |
| int drm_gem_handle_delete(struct drm_file *filp, u32 handle); |
| static inline void |
| drm_gem_object_handle_reference(struct drm_gem_object *obj) |
| { |
| drm_gem_object_reference(obj); |
| atomic_inc(&obj->handle_count); |
| } |
| static inline void |
| drm_gem_object_handle_unreference(struct drm_gem_object *obj) |
| { |
| if (obj == NULL) |
| return; |
| if (atomic_read(&obj->handle_count) == 0) |
| return; |
| /* |
| * Must bump handle count first as this may be the last |
| * ref, in which case the object would disappear before we |
| * checked for a name |
| */ |
| if (atomic_dec_and_test(&obj->handle_count)) |
| drm_gem_object_handle_free(obj); |
| drm_gem_object_unreference(obj); |
| } |
| static inline void |
| drm_gem_object_handle_unreference_unlocked(struct drm_gem_object *obj) |
| { |
| if (obj == NULL) |
| return; |
| if (atomic_read(&obj->handle_count) == 0) |
| return; |
| /* |
| * Must bump handle count first as this may be the last |
| * ref, in which case the object would disappear before we |
| * checked for a name |
| */ |
| if (atomic_dec_and_test(&obj->handle_count)) |
| drm_gem_object_handle_free(obj); |
| drm_gem_object_unreference_unlocked(obj); |
| } |
| void drm_gem_free_mmap_offset(struct drm_gem_object *obj); |
| int drm_gem_create_mmap_offset(struct drm_gem_object *obj); |
| int drm_gem_create_mmap_offset_size(struct drm_gem_object *obj, size_t size); |
| struct page **drm_gem_get_pages(struct drm_gem_object *obj, gfp_t gfpmask); |
| void drm_gem_put_pages(struct drm_gem_object *obj, struct page **pages, |
| bool dirty, bool accessed); |
| struct drm_gem_object *drm_gem_object_lookup(struct drm_device *dev, |
| struct drm_file *filp, |
| u32 handle); |
| 1683,8 → 1577,6 |
| extern void drm_core_ioremap_wc(struct drm_local_map *map, struct drm_device *dev); |
| extern void drm_core_ioremapfree(struct drm_local_map *map, struct drm_device *dev); |
| #if 0 |
| static __inline__ struct drm_local_map *drm_core_findmap(struct drm_device *dev, |
| unsigned int token) |
| { |
| 1699,30 → 1591,20 |
| { |
| } |
| //#include <drm/drm_mem_util.h> |
| extern int drm_fill_in_dev(struct drm_device *dev, |
| const struct pci_device_id *ent, |
| struct drm_driver *driver); |
| int drm_get_minor(struct drm_device *dev, struct drm_minor **minor, int type); |
| /*@}*/ |
| static __inline__ void *drm_calloc_large(size_t nmemb, size_t size) |
| { |
| if (size * nmemb <= PAGE_SIZE) |
| return kcalloc(nmemb, size, GFP_KERNEL); |
| if (size != 0 && nmemb > ULONG_MAX / size) |
| return NULL; |
| return __vmalloc(size * nmemb, |
| GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO, PAGE_KERNEL); |
| } |
| extern int drm_get_pci_dev(struct pci_dev *pdev, |
| const struct pci_device_id *ent, |
| struct drm_driver *driver); |
| static __inline void drm_free_large(void *ptr) |
| { |
| if (!is_vmalloc_addr(ptr)) |
| return kfree(ptr); |
| vfree(ptr); |
| } |
| #endif |
| #define DRM_PCIE_SPEED_25 1 |
| #define DRM_PCIE_SPEED_50 2 |
| #define DRM_PCIE_SPEED_80 4 |
| 1744,5 → 1626,7 |
| #define drm_sysfs_connector_remove(connector) |
| #define LFB_SIZE 0xC00000 |
| extern struct drm_device *main_device; |
| extern struct drm_file *drm_file_handlers[256]; |
| #endif |
| /drivers/include/drm/drm_core.h |
|---|
| 0,0 → 1,34 |
| /* |
| * Copyright 2004 Jon Smirl <jonsmirl@gmail.com> |
| * |
| * 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, sub license, |
| * 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 NON-INFRINGEMENT. IN NO EVENT SHALL |
| * VIA, S3 GRAPHICS, AND/OR ITS SUPPLIERS 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. |
| */ |
| #define CORE_AUTHOR "Gareth Hughes, Leif Delgass, José Fonseca, Jon Smirl" |
| #define CORE_NAME "drm" |
| #define CORE_DESC "DRM shared core routines" |
| #define CORE_DATE "20060810" |
| #define DRM_IF_MAJOR 1 |
| #define DRM_IF_MINOR 4 |
| #define CORE_MAJOR 1 |
| #define CORE_MINOR 1 |
| #define CORE_PATCHLEVEL 0 |
| /drivers/include/drm/drm_crtc.h |
|---|
| 49,6 → 49,7 |
| #define DRM_MODE_OBJECT_FB 0xfbfbfbfb |
| #define DRM_MODE_OBJECT_BLOB 0xbbbbbbbb |
| #define DRM_MODE_OBJECT_PLANE 0xeeeeeeee |
| #define DRM_MODE_OBJECT_BRIDGE 0xbdbdbdbd |
| struct drm_mode_object { |
| uint32_t id; |
| 305,6 → 306,7 |
| struct drm_encoder; |
| struct drm_pending_vblank_event; |
| struct drm_plane; |
| struct drm_bridge; |
| /** |
| * drm_crtc_funcs - control CRTCs for a given device |
| 363,7 → 365,8 |
| */ |
| int (*page_flip)(struct drm_crtc *crtc, |
| struct drm_framebuffer *fb, |
| struct drm_pending_vblank_event *event); |
| struct drm_pending_vblank_event *event, |
| uint32_t flags); |
| int (*set_property)(struct drm_crtc *crtc, |
| struct drm_property *property, uint64_t val); |
| 494,8 → 497,6 |
| void (*destroy)(struct drm_encoder *encoder); |
| }; |
| #define DRM_CONNECTOR_MAX_UMODES 16 |
| #define DRM_CONNECTOR_LEN 32 |
| #define DRM_CONNECTOR_MAX_ENCODER 3 |
| /** |
| 507,6 → 508,7 |
| * @possible_crtcs: bitmask of potential CRTC bindings |
| * @possible_clones: bitmask of potential sibling encoders for cloning |
| * @crtc: currently bound CRTC |
| * @bridge: bridge associated to the encoder |
| * @funcs: control functions |
| * @helper_private: mid-layer private data |
| * |
| 523,6 → 525,7 |
| uint32_t possible_clones; |
| struct drm_crtc *crtc; |
| struct drm_bridge *bridge; |
| const struct drm_encoder_funcs *funcs; |
| void *helper_private; |
| }; |
| 683,6 → 686,48 |
| }; |
| /** |
| * drm_bridge_funcs - drm_bridge control functions |
| * @mode_fixup: Try to fixup (or reject entirely) proposed mode for this bridge |
| * @disable: Called right before encoder prepare, disables the bridge |
| * @post_disable: Called right after encoder prepare, for lockstepped disable |
| * @mode_set: Set this mode to the bridge |
| * @pre_enable: Called right before encoder commit, for lockstepped commit |
| * @enable: Called right after encoder commit, enables the bridge |
| * @destroy: make object go away |
| */ |
| struct drm_bridge_funcs { |
| bool (*mode_fixup)(struct drm_bridge *bridge, |
| const struct drm_display_mode *mode, |
| struct drm_display_mode *adjusted_mode); |
| void (*disable)(struct drm_bridge *bridge); |
| void (*post_disable)(struct drm_bridge *bridge); |
| void (*mode_set)(struct drm_bridge *bridge, |
| struct drm_display_mode *mode, |
| struct drm_display_mode *adjusted_mode); |
| void (*pre_enable)(struct drm_bridge *bridge); |
| void (*enable)(struct drm_bridge *bridge); |
| void (*destroy)(struct drm_bridge *bridge); |
| }; |
| /** |
| * drm_bridge - central DRM bridge control structure |
| * @dev: DRM device this bridge belongs to |
| * @head: list management |
| * @base: base mode object |
| * @funcs: control functions |
| * @driver_private: pointer to the bridge driver's internal context |
| */ |
| struct drm_bridge { |
| struct drm_device *dev; |
| struct list_head head; |
| struct drm_mode_object base; |
| const struct drm_bridge_funcs *funcs; |
| void *driver_private; |
| }; |
| /** |
| * drm_mode_set - new values for a CRTC config change |
| * @head: list management |
| * @fb: framebuffer to use for new config |
| 742,6 → 787,7 |
| uint32_t num_crtcs; |
| uint32_t num_encoders; |
| uint32_t num_connectors; |
| uint32_t num_bridges; |
| /* list of object IDs for this group */ |
| uint32_t *id_list; |
| 756,6 → 802,8 |
| * @fb_list: list of framebuffers available |
| * @num_connector: number of connectors on this device |
| * @connector_list: list of connector objects |
| * @num_bridge: number of bridges on this device |
| * @bridge_list: list of bridge objects |
| * @num_encoder: number of encoders on this device |
| * @encoder_list: list of encoder objects |
| * @num_crtc: number of CRTCs on this device |
| 793,6 → 841,8 |
| int num_connector; |
| struct list_head connector_list; |
| int num_bridge; |
| struct list_head bridge_list; |
| int num_encoder; |
| struct list_head encoder_list; |
| int num_plane; |
| 839,11 → 889,13 |
| /* Optional properties */ |
| struct drm_property *scaling_mode_property; |
| struct drm_property *dithering_mode_property; |
| struct drm_property *dirty_info_property; |
| /* dumb ioctl parameters */ |
| uint32_t preferred_depth, prefer_shadow; |
| /* whether async page flip is supported or not */ |
| bool async_page_flip; |
| }; |
| #define obj_to_crtc(x) container_of(x, struct drm_crtc, base) |
| 869,6 → 921,8 |
| const struct drm_crtc_funcs *funcs); |
| extern void drm_crtc_cleanup(struct drm_crtc *crtc); |
| extern void drm_connector_ida_init(void); |
| extern void drm_connector_ida_destroy(void); |
| extern int drm_connector_init(struct drm_device *dev, |
| struct drm_connector *connector, |
| const struct drm_connector_funcs *funcs, |
| 878,6 → 932,10 |
| /* helper to unplug all connectors from sysfs for device */ |
| extern void drm_connector_unplug_all(struct drm_device *dev); |
| extern int drm_bridge_init(struct drm_device *dev, struct drm_bridge *bridge, |
| const struct drm_bridge_funcs *funcs); |
| extern void drm_bridge_cleanup(struct drm_bridge *bridge); |
| extern int drm_encoder_init(struct drm_device *dev, |
| struct drm_encoder *encoder, |
| const struct drm_encoder_funcs *funcs, |
| 908,7 → 966,6 |
| struct i2c_adapter *adapter); |
| extern int drm_add_edid_modes(struct drm_connector *connector, struct edid *edid); |
| extern void drm_mode_probed_add(struct drm_connector *connector, struct drm_display_mode *mode); |
| extern void drm_mode_remove(struct drm_connector *connector, struct drm_display_mode *mode); |
| extern void drm_mode_copy(struct drm_display_mode *dst, const struct drm_display_mode *src); |
| extern struct drm_display_mode *drm_mode_duplicate(struct drm_device *dev, |
| const struct drm_display_mode *mode); |
| 925,14 → 982,9 |
| /* for us by fb module */ |
| extern struct drm_display_mode *drm_mode_create(struct drm_device *dev); |
| extern void drm_mode_destroy(struct drm_device *dev, struct drm_display_mode *mode); |
| extern void drm_mode_list_concat(struct list_head *head, |
| struct list_head *new); |
| extern void drm_mode_validate_size(struct drm_device *dev, |
| struct list_head *mode_list, |
| int maxX, int maxY, int maxPitch); |
| extern void drm_mode_validate_clocks(struct drm_device *dev, |
| struct list_head *mode_list, |
| int *min, int *max, int n_ranges); |
| extern void drm_mode_prune_invalid(struct drm_device *dev, |
| struct list_head *mode_list, bool verbose); |
| extern void drm_mode_sort(struct list_head *mode_list); |
| 949,9 → 1001,6 |
| extern int drm_object_property_get_value(struct drm_mode_object *obj, |
| struct drm_property *property, |
| uint64_t *value); |
| extern struct drm_display_mode *drm_crtc_mode_create(struct drm_device *dev); |
| extern void drm_framebuffer_set_object(struct drm_device *dev, |
| unsigned long handle); |
| extern int drm_framebuffer_init(struct drm_device *dev, |
| struct drm_framebuffer *fb, |
| const struct drm_framebuffer_funcs *funcs); |
| 962,10 → 1011,6 |
| extern void drm_framebuffer_remove(struct drm_framebuffer *fb); |
| extern void drm_framebuffer_cleanup(struct drm_framebuffer *fb); |
| extern void drm_framebuffer_unregister_private(struct drm_framebuffer *fb); |
| extern int drmfb_probe(struct drm_device *dev, struct drm_crtc *crtc); |
| extern int drmfb_remove(struct drm_device *dev, struct drm_framebuffer *fb); |
| extern void drm_crtc_probe_connector_modes(struct drm_device *dev, int maxX, int maxY); |
| extern bool drm_crtc_in_use(struct drm_crtc *crtc); |
| extern void drm_object_attach_property(struct drm_mode_object *obj, |
| struct drm_property *property, |
| 990,7 → 1035,6 |
| extern int drm_mode_create_tv_properties(struct drm_device *dev, int num_formats, |
| char *formats[]); |
| extern int drm_mode_create_scaling_mode_property(struct drm_device *dev); |
| extern int drm_mode_create_dithering_property(struct drm_device *dev); |
| extern int drm_mode_create_dirty_info_property(struct drm_device *dev); |
| extern const char *drm_get_encoder_name(const struct drm_encoder *encoder); |
| 1040,10 → 1084,6 |
| void *data, struct drm_file *file_priv); |
| extern int drm_mode_connector_property_set_ioctl(struct drm_device *dev, |
| void *data, struct drm_file *file_priv); |
| extern int drm_mode_hotplug_ioctl(struct drm_device *dev, |
| void *data, struct drm_file *file_priv); |
| extern int drm_mode_replacefb(struct drm_device *dev, |
| void *data, struct drm_file *file_priv); |
| extern int drm_mode_getencoder(struct drm_device *dev, |
| void *data, struct drm_file *file_priv); |
| extern int drm_mode_gamma_get_ioctl(struct drm_device *dev, |
| 1050,7 → 1090,6 |
| void *data, struct drm_file *file_priv); |
| extern int drm_mode_gamma_set_ioctl(struct drm_device *dev, |
| void *data, struct drm_file *file_priv); |
| extern u8 *drm_find_cea_extension(struct edid *edid); |
| extern u8 drm_match_cea_mode(const struct drm_display_mode *to_match); |
| extern bool drm_detect_hdmi_monitor(struct edid *edid); |
| extern bool drm_detect_monitor_audio(struct edid *edid); |
| /drivers/include/drm/drm_dp_helper.h |
|---|
| 343,6 → 343,8 |
| int lane); |
| #define DP_RECEIVER_CAP_SIZE 0xf |
| #define EDP_PSR_RECEIVER_CAP_SIZE 2 |
| void drm_dp_link_train_clock_recovery_delay(u8 dpcd[DP_RECEIVER_CAP_SIZE]); |
| void drm_dp_link_train_channel_eq_delay(u8 dpcd[DP_RECEIVER_CAP_SIZE]); |
| 349,6 → 351,33 |
| u8 drm_dp_link_rate_to_bw_code(int link_rate); |
| int drm_dp_bw_code_to_link_rate(u8 link_bw); |
| struct edp_sdp_header { |
| u8 HB0; /* Secondary Data Packet ID */ |
| u8 HB1; /* Secondary Data Packet Type */ |
| u8 HB2; /* 7:5 reserved, 4:0 revision number */ |
| u8 HB3; /* 7:5 reserved, 4:0 number of valid data bytes */ |
| } __packed; |
| #define EDP_SDP_HEADER_REVISION_MASK 0x1F |
| #define EDP_SDP_HEADER_VALID_PAYLOAD_BYTES 0x1F |
| struct edp_vsc_psr { |
| struct edp_sdp_header sdp_header; |
| u8 DB0; /* Stereo Interface */ |
| u8 DB1; /* 0 - PSR State; 1 - Update RFB; 2 - CRC Valid */ |
| u8 DB2; /* CRC value bits 7:0 of the R or Cr component */ |
| u8 DB3; /* CRC value bits 15:8 of the R or Cr component */ |
| u8 DB4; /* CRC value bits 7:0 of the G or Y component */ |
| u8 DB5; /* CRC value bits 15:8 of the G or Y component */ |
| u8 DB6; /* CRC value bits 7:0 of the B or Cb component */ |
| u8 DB7; /* CRC value bits 15:8 of the B or Cb component */ |
| u8 DB8_31[24]; /* Reserved */ |
| } __packed; |
| #define EDP_VSC_PSR_STATE_ACTIVE (1<<0) |
| #define EDP_VSC_PSR_UPDATE_RFB (1<<1) |
| #define EDP_VSC_PSR_CRC_VALUES_VALID (1<<2) |
| static inline int |
| drm_dp_max_link_rate(u8 dpcd[DP_RECEIVER_CAP_SIZE]) |
| { |
| /drivers/include/drm/drm_edid.h |
|---|
| 256,9 → 256,11 |
| struct drm_connector; |
| struct drm_display_mode; |
| struct hdmi_avi_infoframe; |
| struct hdmi_vendor_infoframe; |
| void drm_edid_to_eld(struct drm_connector *connector, struct edid *edid); |
| int drm_edid_to_sad(struct edid *edid, struct cea_sad **sads); |
| int drm_edid_to_speaker_allocation(struct edid *edid, u8 **sadb); |
| int drm_av_sync_delay(struct drm_connector *connector, |
| struct drm_display_mode *mode); |
| struct drm_connector *drm_select_eld(struct drm_encoder *encoder, |
| 268,5 → 270,8 |
| int |
| drm_hdmi_avi_infoframe_from_display_mode(struct hdmi_avi_infoframe *frame, |
| const struct drm_display_mode *mode); |
| int |
| drm_hdmi_vendor_infoframe_from_display_mode(struct hdmi_vendor_infoframe *frame, |
| const struct drm_display_mode *mode); |
| #endif /* __DRM_EDID_H__ */ |
| /drivers/include/drm/drm_fixed.h |
|---|
| 20,11 → 20,13 |
| * OTHER DEALINGS IN THE SOFTWARE. |
| * |
| * Authors: Dave Airlie |
| * Christian Konig |
| * Christian König |
| */ |
| #ifndef DRM_FIXED_H |
| #define DRM_FIXED_H |
| #include <linux/math64.h> |
| typedef union dfixed { |
| u32 full; |
| } fixed20_12; |
| /drivers/include/drm/drm_mm.h |
|---|
| 41,6 → 41,11 |
| #include <linux/seq_file.h> |
| #endif |
| enum drm_mm_search_flags { |
| DRM_MM_SEARCH_DEFAULT = 0, |
| DRM_MM_SEARCH_BEST = 1 << 0, |
| }; |
| struct drm_mm_node { |
| struct list_head node_list; |
| struct list_head hole_stack; |
| 62,9 → 67,6 |
| /* head_node.node_list is the list of all memory nodes, ordered |
| * according to the (increasing) start address of the memory node. */ |
| struct drm_mm_node head_node; |
| struct list_head unused_nodes; |
| int num_unused; |
| spinlock_t unused_lock; |
| unsigned int scan_check_range : 1; |
| unsigned scan_alignment; |
| unsigned long scan_color; |
| 115,13 → 117,6 |
| #define drm_mm_for_each_node(entry, mm) list_for_each_entry(entry, \ |
| &(mm)->head_node.node_list, \ |
| node_list) |
| #define drm_mm_for_each_scanned_node_reverse(entry, n, mm) \ |
| for (entry = (mm)->prev_scanned_node, \ |
| next = entry ? list_entry(entry->node_list.next, \ |
| struct drm_mm_node, node_list) : NULL; \ |
| entry != NULL; entry = next, \ |
| next = entry ? list_entry(entry->node_list.next, \ |
| struct drm_mm_node, node_list) : NULL) \ |
| /* Note that we need to unroll list_for_each_entry in order to inline |
| * setting hole_start and hole_end on each iteration and keep the |
| 138,71 → 133,23 |
| /* |
| * Basic range manager support (drm_mm.c) |
| */ |
| extern struct drm_mm_node *drm_mm_create_block(struct drm_mm *mm, |
| unsigned long start, |
| extern int drm_mm_reserve_node(struct drm_mm *mm, struct drm_mm_node *node); |
| extern int drm_mm_insert_node_generic(struct drm_mm *mm, |
| struct drm_mm_node *node, |
| unsigned long size, |
| bool atomic); |
| extern struct drm_mm_node *drm_mm_get_block_generic(struct drm_mm_node *node, |
| unsigned long size, |
| unsigned alignment, |
| unsigned long color, |
| int atomic); |
| extern struct drm_mm_node *drm_mm_get_block_range_generic( |
| enum drm_mm_search_flags flags); |
| static inline int drm_mm_insert_node(struct drm_mm *mm, |
| struct drm_mm_node *node, |
| unsigned long size, |
| unsigned alignment, |
| unsigned long color, |
| unsigned long start, |
| unsigned long end, |
| int atomic); |
| static inline struct drm_mm_node *drm_mm_get_block(struct drm_mm_node *parent, |
| unsigned long size, |
| unsigned alignment) |
| enum drm_mm_search_flags flags) |
| { |
| return drm_mm_get_block_generic(parent, size, alignment, 0, 0); |
| return drm_mm_insert_node_generic(mm, node, size, alignment, 0, flags); |
| } |
| static inline struct drm_mm_node *drm_mm_get_block_atomic(struct drm_mm_node *parent, |
| unsigned long size, |
| unsigned alignment) |
| { |
| return drm_mm_get_block_generic(parent, size, alignment, 0, 1); |
| } |
| static inline struct drm_mm_node *drm_mm_get_block_range( |
| struct drm_mm_node *parent, |
| unsigned long size, |
| unsigned alignment, |
| unsigned long start, |
| unsigned long end) |
| { |
| return drm_mm_get_block_range_generic(parent, size, alignment, 0, |
| start, end, 0); |
| } |
| static inline struct drm_mm_node *drm_mm_get_block_atomic_range( |
| struct drm_mm_node *parent, |
| unsigned long size, |
| unsigned alignment, |
| unsigned long start, |
| unsigned long end) |
| { |
| return drm_mm_get_block_range_generic(parent, size, alignment, 0, |
| start, end, 1); |
| } |
| extern int drm_mm_insert_node(struct drm_mm *mm, |
| struct drm_mm_node *node, |
| unsigned long size, |
| unsigned alignment); |
| extern int drm_mm_insert_node_in_range(struct drm_mm *mm, |
| struct drm_mm_node *node, |
| unsigned long size, |
| unsigned alignment, |
| unsigned long start, |
| unsigned long end); |
| extern int drm_mm_insert_node_generic(struct drm_mm *mm, |
| struct drm_mm_node *node, |
| unsigned long size, |
| unsigned alignment, |
| unsigned long color); |
| extern int drm_mm_insert_node_in_range_generic(struct drm_mm *mm, |
| struct drm_mm_node *node, |
| unsigned long size, |
| 209,54 → 156,28 |
| unsigned alignment, |
| unsigned long color, |
| unsigned long start, |
| unsigned long end); |
| extern void drm_mm_put_block(struct drm_mm_node *cur); |
| extern void drm_mm_remove_node(struct drm_mm_node *node); |
| extern void drm_mm_replace_node(struct drm_mm_node *old, struct drm_mm_node *new); |
| extern struct drm_mm_node *drm_mm_search_free_generic(const struct drm_mm *mm, |
| unsigned long size, |
| unsigned alignment, |
| unsigned long color, |
| bool best_match); |
| extern struct drm_mm_node *drm_mm_search_free_in_range_generic( |
| const struct drm_mm *mm, |
| unsigned long size, |
| unsigned alignment, |
| unsigned long color, |
| unsigned long start, |
| unsigned long end, |
| bool best_match); |
| static inline struct drm_mm_node *drm_mm_search_free(const struct drm_mm *mm, |
| enum drm_mm_search_flags flags); |
| static inline int drm_mm_insert_node_in_range(struct drm_mm *mm, |
| struct drm_mm_node *node, |
| unsigned long size, |
| unsigned alignment, |
| bool best_match) |
| { |
| return drm_mm_search_free_generic(mm,size, alignment, 0, best_match); |
| } |
| static inline struct drm_mm_node *drm_mm_search_free_in_range( |
| const struct drm_mm *mm, |
| unsigned long size, |
| unsigned alignment, |
| unsigned long start, |
| unsigned long end, |
| bool best_match) |
| enum drm_mm_search_flags flags) |
| { |
| return drm_mm_search_free_in_range_generic(mm, size, alignment, 0, |
| start, end, best_match); |
| return drm_mm_insert_node_in_range_generic(mm, node, size, alignment, |
| 0, start, end, flags); |
| } |
| extern void drm_mm_remove_node(struct drm_mm_node *node); |
| extern void drm_mm_replace_node(struct drm_mm_node *old, struct drm_mm_node *new); |
| extern void drm_mm_init(struct drm_mm *mm, |
| unsigned long start, |
| unsigned long size); |
| extern void drm_mm_takedown(struct drm_mm *mm); |
| extern int drm_mm_clean(struct drm_mm *mm); |
| extern int drm_mm_pre_get(struct drm_mm *mm); |
| static inline struct drm_mm *drm_get_mm(struct drm_mm_node *block) |
| { |
| return block->mm; |
| } |
| void drm_mm_init_scan(struct drm_mm *mm, |
| unsigned long size, |
| unsigned alignment, |
| /drivers/include/drm/drm_pciids.h |
|---|
| 1,4 → 1,25 |
| #define radeon_PCI_IDS \ |
| {0x1002, 0x1304, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_KAVERI|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \ |
| {0x1002, 0x1305, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_KAVERI|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \ |
| {0x1002, 0x1306, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_KAVERI|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \ |
| {0x1002, 0x1307, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_KAVERI|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \ |
| {0x1002, 0x1309, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_KAVERI|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \ |
| {0x1002, 0x130A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_KAVERI|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \ |
| {0x1002, 0x130B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_KAVERI|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \ |
| {0x1002, 0x130C, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_KAVERI|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \ |
| {0x1002, 0x130D, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_KAVERI|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \ |
| {0x1002, 0x130E, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_KAVERI|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \ |
| {0x1002, 0x130F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_KAVERI|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \ |
| {0x1002, 0x1310, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_KAVERI|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \ |
| {0x1002, 0x1311, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_KAVERI|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \ |
| {0x1002, 0x1312, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_KAVERI|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \ |
| {0x1002, 0x1313, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_KAVERI|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \ |
| {0x1002, 0x1315, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_KAVERI|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \ |
| {0x1002, 0x1316, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_KAVERI|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \ |
| {0x1002, 0x1317, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_KAVERI|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \ |
| {0x1002, 0x131B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_KAVERI|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \ |
| {0x1002, 0x131C, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_KAVERI|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \ |
| {0x1002, 0x131D, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_KAVERI|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \ |
| {0x1002, 0x3150, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY}, \ |
| {0x1002, 0x3151, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
| {0x1002, 0x3152, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
| /drivers/include/drm/drm_vma_manager.h |
|---|
| 0,0 → 1,257 |
| #ifndef __DRM_VMA_MANAGER_H__ |
| #define __DRM_VMA_MANAGER_H__ |
| /* |
| * Copyright (c) 2013 David Herrmann <dh.herrmann@gmail.com> |
| * |
| * 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. |
| */ |
| #include <drm/drm_mm.h> |
| //#include <linux/fs.h> |
| #include <linux/mm.h> |
| #include <linux/module.h> |
| #include <linux/rbtree.h> |
| #include <linux/spinlock.h> |
| #include <linux/types.h> |
| struct drm_vma_offset_file { |
| struct rb_node vm_rb; |
| struct file *vm_filp; |
| unsigned long vm_count; |
| }; |
| struct drm_vma_offset_node { |
| rwlock_t vm_lock; |
| struct drm_mm_node vm_node; |
| struct rb_node vm_rb; |
| struct rb_root vm_files; |
| }; |
| struct drm_vma_offset_manager { |
| rwlock_t vm_lock; |
| struct rb_root vm_addr_space_rb; |
| struct drm_mm vm_addr_space_mm; |
| }; |
| void drm_vma_offset_manager_init(struct drm_vma_offset_manager *mgr, |
| unsigned long page_offset, unsigned long size); |
| void drm_vma_offset_manager_destroy(struct drm_vma_offset_manager *mgr); |
| struct drm_vma_offset_node *drm_vma_offset_lookup(struct drm_vma_offset_manager *mgr, |
| unsigned long start, |
| unsigned long pages); |
| struct drm_vma_offset_node *drm_vma_offset_lookup_locked(struct drm_vma_offset_manager *mgr, |
| unsigned long start, |
| unsigned long pages); |
| int drm_vma_offset_add(struct drm_vma_offset_manager *mgr, |
| struct drm_vma_offset_node *node, unsigned long pages); |
| void drm_vma_offset_remove(struct drm_vma_offset_manager *mgr, |
| struct drm_vma_offset_node *node); |
| int drm_vma_node_allow(struct drm_vma_offset_node *node, struct file *filp); |
| void drm_vma_node_revoke(struct drm_vma_offset_node *node, struct file *filp); |
| bool drm_vma_node_is_allowed(struct drm_vma_offset_node *node, |
| struct file *filp); |
| /** |
| * drm_vma_offset_exact_lookup() - Look up node by exact address |
| * @mgr: Manager object |
| * @start: Start address (page-based, not byte-based) |
| * @pages: Size of object (page-based) |
| * |
| * Same as drm_vma_offset_lookup() but does not allow any offset into the node. |
| * It only returns the exact object with the given start address. |
| * |
| * RETURNS: |
| * Node at exact start address @start. |
| */ |
| static inline struct drm_vma_offset_node * |
| drm_vma_offset_exact_lookup(struct drm_vma_offset_manager *mgr, |
| unsigned long start, |
| unsigned long pages) |
| { |
| struct drm_vma_offset_node *node; |
| node = drm_vma_offset_lookup(mgr, start, pages); |
| return (node && node->vm_node.start == start) ? node : NULL; |
| } |
| /** |
| * drm_vma_offset_lock_lookup() - Lock lookup for extended private use |
| * @mgr: Manager object |
| * |
| * Lock VMA manager for extended lookups. Only *_locked() VMA function calls |
| * are allowed while holding this lock. All other contexts are blocked from VMA |
| * until the lock is released via drm_vma_offset_unlock_lookup(). |
| * |
| * Use this if you need to take a reference to the objects returned by |
| * drm_vma_offset_lookup_locked() before releasing this lock again. |
| * |
| * This lock must not be used for anything else than extended lookups. You must |
| * not call any other VMA helpers while holding this lock. |
| * |
| * Note: You're in atomic-context while holding this lock! |
| * |
| * Example: |
| * drm_vma_offset_lock_lookup(mgr); |
| * node = drm_vma_offset_lookup_locked(mgr); |
| * if (node) |
| * kref_get_unless_zero(container_of(node, sth, entr)); |
| * drm_vma_offset_unlock_lookup(mgr); |
| */ |
| static inline void drm_vma_offset_lock_lookup(struct drm_vma_offset_manager *mgr) |
| { |
| read_lock(&mgr->vm_lock); |
| } |
| /** |
| * drm_vma_offset_unlock_lookup() - Unlock lookup for extended private use |
| * @mgr: Manager object |
| * |
| * Release lookup-lock. See drm_vma_offset_lock_lookup() for more information. |
| */ |
| static inline void drm_vma_offset_unlock_lookup(struct drm_vma_offset_manager *mgr) |
| { |
| read_unlock(&mgr->vm_lock); |
| } |
| /** |
| * drm_vma_node_reset() - Initialize or reset node object |
| * @node: Node to initialize or reset |
| * |
| * Reset a node to its initial state. This must be called before using it with |
| * any VMA offset manager. |
| * |
| * This must not be called on an already allocated node, or you will leak |
| * memory. |
| */ |
| static inline void drm_vma_node_reset(struct drm_vma_offset_node *node) |
| { |
| memset(node, 0, sizeof(*node)); |
| node->vm_files = RB_ROOT; |
| rwlock_init(&node->vm_lock); |
| } |
| /** |
| * drm_vma_node_start() - Return start address for page-based addressing |
| * @node: Node to inspect |
| * |
| * Return the start address of the given node. This can be used as offset into |
| * the linear VM space that is provided by the VMA offset manager. Note that |
| * this can only be used for page-based addressing. If you need a proper offset |
| * for user-space mappings, you must apply "<< PAGE_SHIFT" or use the |
| * drm_vma_node_offset_addr() helper instead. |
| * |
| * RETURNS: |
| * Start address of @node for page-based addressing. 0 if the node does not |
| * have an offset allocated. |
| */ |
| static inline unsigned long drm_vma_node_start(struct drm_vma_offset_node *node) |
| { |
| return node->vm_node.start; |
| } |
| /** |
| * drm_vma_node_size() - Return size (page-based) |
| * @node: Node to inspect |
| * |
| * Return the size as number of pages for the given node. This is the same size |
| * that was passed to drm_vma_offset_add(). If no offset is allocated for the |
| * node, this is 0. |
| * |
| * RETURNS: |
| * Size of @node as number of pages. 0 if the node does not have an offset |
| * allocated. |
| */ |
| static inline unsigned long drm_vma_node_size(struct drm_vma_offset_node *node) |
| { |
| return node->vm_node.size; |
| } |
| /** |
| * drm_vma_node_has_offset() - Check whether node is added to offset manager |
| * @node: Node to be checked |
| * |
| * RETURNS: |
| * true iff the node was previously allocated an offset and added to |
| * an vma offset manager. |
| */ |
| static inline bool drm_vma_node_has_offset(struct drm_vma_offset_node *node) |
| { |
| return drm_mm_node_allocated(&node->vm_node); |
| } |
| /** |
| * drm_vma_node_offset_addr() - Return sanitized offset for user-space mmaps |
| * @node: Linked offset node |
| * |
| * Same as drm_vma_node_start() but returns the address as a valid offset that |
| * can be used for user-space mappings during mmap(). |
| * This must not be called on unlinked nodes. |
| * |
| * RETURNS: |
| * Offset of @node for byte-based addressing. 0 if the node does not have an |
| * object allocated. |
| */ |
| static inline __u64 drm_vma_node_offset_addr(struct drm_vma_offset_node *node) |
| { |
| return ((__u64)node->vm_node.start) << PAGE_SHIFT; |
| } |
| /** |
| * drm_vma_node_unmap() - Unmap offset node |
| * @node: Offset node |
| * @file_mapping: Address space to unmap @node from |
| * |
| * Unmap all userspace mappings for a given offset node. The mappings must be |
| * associated with the @file_mapping address-space. If no offset exists or |
| * the address-space is invalid, nothing is done. |
| * |
| * This call is unlocked. The caller must guarantee that drm_vma_offset_remove() |
| * is not called on this node concurrently. |
| */ |
| static inline void drm_vma_node_unmap(struct drm_vma_offset_node *node, |
| struct address_space *file_mapping) |
| { |
| if (file_mapping && drm_vma_node_has_offset(node)) |
| unmap_mapping_range(file_mapping, |
| drm_vma_node_offset_addr(node), |
| drm_vma_node_size(node) << PAGE_SHIFT, 1); |
| } |
| /** |
| * drm_vma_node_verify_access() - Access verification helper for TTM |
| * @node: Offset node |
| * @filp: Open-file |
| * |
| * This checks whether @filp is granted access to @node. It is the same as |
| * drm_vma_node_is_allowed() but suitable as drop-in helper for TTM |
| * verify_access() callbacks. |
| * |
| * RETURNS: |
| * 0 if access is granted, -EACCES otherwise. |
| */ |
| static inline int drm_vma_node_verify_access(struct drm_vma_offset_node *node, |
| struct file *filp) |
| { |
| return drm_vma_node_is_allowed(node, filp) ? 0 : -EACCES; |
| } |
| #endif /* __DRM_VMA_MANAGER_H__ */ |
| /drivers/include/drm/i915_drm.h |
|---|
| 26,6 → 26,7 |
| #ifndef _I915_DRM_H_ |
| #define _I915_DRM_H_ |
| #include <drm/i915_pciids.h> |
| #include <uapi/drm/i915_drm.h> |
| /* For use by IPS driver */ |
| 34,4 → 35,37 |
| extern bool i915_gpu_lower(void); |
| extern bool i915_gpu_busy(void); |
| extern bool i915_gpu_turbo_disable(void); |
| /* |
| * The Bridge device's PCI config space has information about the |
| * fb aperture size and the amount of pre-reserved memory. |
| * This is all handled in the intel-gtt.ko module. i915.ko only |
| * cares about the vga bit for the vga rbiter. |
| */ |
| #define INTEL_GMCH_CTRL 0x52 |
| #define INTEL_GMCH_VGA_DISABLE (1 << 1) |
| #define SNB_GMCH_CTRL 0x50 |
| #define SNB_GMCH_GGMS_SHIFT 8 /* GTT Graphics Memory Size */ |
| #define SNB_GMCH_GGMS_MASK 0x3 |
| #define SNB_GMCH_GMS_SHIFT 3 /* Graphics Mode Select */ |
| #define SNB_GMCH_GMS_MASK 0x1f |
| #define I830_GMCH_CTRL 0x52 |
| #define I855_GMCH_GMS_MASK 0xF0 |
| #define I855_GMCH_GMS_STOLEN_0M 0x0 |
| #define I855_GMCH_GMS_STOLEN_1M (0x1 << 4) |
| #define I855_GMCH_GMS_STOLEN_4M (0x2 << 4) |
| #define I855_GMCH_GMS_STOLEN_8M (0x3 << 4) |
| #define I855_GMCH_GMS_STOLEN_16M (0x4 << 4) |
| #define I855_GMCH_GMS_STOLEN_32M (0x5 << 4) |
| #define I915_GMCH_GMS_STOLEN_48M (0x6 << 4) |
| #define I915_GMCH_GMS_STOLEN_64M (0x7 << 4) |
| #define G33_GMCH_GMS_STOLEN_128M (0x8 << 4) |
| #define G33_GMCH_GMS_STOLEN_256M (0x9 << 4) |
| #define INTEL_GMCH_GMS_STOLEN_96M (0xa << 4) |
| #define INTEL_GMCH_GMS_STOLEN_160M (0xb << 4) |
| #define INTEL_GMCH_GMS_STOLEN_224M (0xc << 4) |
| #define INTEL_GMCH_GMS_STOLEN_352M (0xd << 4) |
| #endif /* _I915_DRM_H_ */ |
| /drivers/include/drm/i915_pciids.h |
|---|
| 0,0 → 1,211 |
| /* |
| * Copyright 2013 Intel Corporation |
| * All Rights Reserved. |
| * |
| * 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, sub license, 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. |
| */ |
| #ifndef _I915_PCIIDS_H |
| #define _I915_PCIIDS_H |
| /* |
| * A pci_device_id struct { |
| * __u32 vendor, device; |
| * __u32 subvendor, subdevice; |
| * __u32 class, class_mask; |
| * kernel_ulong_t driver_data; |
| * }; |
| * Don't use C99 here because "class" is reserved and we want to |
| * give userspace flexibility. |
| */ |
| #define INTEL_VGA_DEVICE(id, info) { \ |
| 0x8086, id, \ |
| ~0, ~0, \ |
| 0x030000, 0xff0000, \ |
| (unsigned long) info } |
| #define INTEL_QUANTA_VGA_DEVICE(info) { \ |
| 0x8086, 0x16a, \ |
| 0x152d, 0x8990, \ |
| 0x030000, 0xff0000, \ |
| (unsigned long) info } |
| #define INTEL_I830_IDS(info) \ |
| INTEL_VGA_DEVICE(0x3577, info) |
| #define INTEL_I845G_IDS(info) \ |
| INTEL_VGA_DEVICE(0x2562, info) |
| #define INTEL_I85X_IDS(info) \ |
| INTEL_VGA_DEVICE(0x3582, info), /* I855_GM */ \ |
| INTEL_VGA_DEVICE(0x358e, info) |
| #define INTEL_I865G_IDS(info) \ |
| INTEL_VGA_DEVICE(0x2572, info) /* I865_G */ |
| #define INTEL_I915G_IDS(info) \ |
| INTEL_VGA_DEVICE(0x2582, info), /* I915_G */ \ |
| INTEL_VGA_DEVICE(0x258a, info) /* E7221_G */ |
| #define INTEL_I915GM_IDS(info) \ |
| INTEL_VGA_DEVICE(0x2592, info) /* I915_GM */ |
| #define INTEL_I945G_IDS(info) \ |
| INTEL_VGA_DEVICE(0x2772, info) /* I945_G */ |
| #define INTEL_I945GM_IDS(info) \ |
| INTEL_VGA_DEVICE(0x27a2, info), /* I945_GM */ \ |
| INTEL_VGA_DEVICE(0x27ae, info) /* I945_GME */ |
| #define INTEL_I965G_IDS(info) \ |
| INTEL_VGA_DEVICE(0x2972, info), /* I946_GZ */ \ |
| INTEL_VGA_DEVICE(0x2982, info), /* G35_G */ \ |
| INTEL_VGA_DEVICE(0x2992, info), /* I965_Q */ \ |
| INTEL_VGA_DEVICE(0x29a2, info) /* I965_G */ |
| #define INTEL_G33_IDS(info) \ |
| INTEL_VGA_DEVICE(0x29b2, info), /* Q35_G */ \ |
| INTEL_VGA_DEVICE(0x29c2, info), /* G33_G */ \ |
| INTEL_VGA_DEVICE(0x29d2, info) /* Q33_G */ |
| #define INTEL_I965GM_IDS(info) \ |
| INTEL_VGA_DEVICE(0x2a02, info), /* I965_GM */ \ |
| INTEL_VGA_DEVICE(0x2a12, info) /* I965_GME */ |
| #define INTEL_GM45_IDS(info) \ |
| INTEL_VGA_DEVICE(0x2a42, info) /* GM45_G */ |
| #define INTEL_G45_IDS(info) \ |
| INTEL_VGA_DEVICE(0x2e02, info), /* IGD_E_G */ \ |
| INTEL_VGA_DEVICE(0x2e12, info), /* Q45_G */ \ |
| INTEL_VGA_DEVICE(0x2e22, info), /* G45_G */ \ |
| INTEL_VGA_DEVICE(0x2e32, info), /* G41_G */ \ |
| INTEL_VGA_DEVICE(0x2e42, info), /* B43_G */ \ |
| INTEL_VGA_DEVICE(0x2e92, info) /* B43_G.1 */ |
| #define INTEL_PINEVIEW_IDS(info) \ |
| INTEL_VGA_DEVICE(0xa001, info), \ |
| INTEL_VGA_DEVICE(0xa011, info) |
| #define INTEL_IRONLAKE_D_IDS(info) \ |
| INTEL_VGA_DEVICE(0x0042, info) |
| #define INTEL_IRONLAKE_M_IDS(info) \ |
| INTEL_VGA_DEVICE(0x0046, info) |
| #define INTEL_SNB_D_IDS(info) \ |
| INTEL_VGA_DEVICE(0x0102, info), \ |
| INTEL_VGA_DEVICE(0x0112, info), \ |
| INTEL_VGA_DEVICE(0x0122, info), \ |
| INTEL_VGA_DEVICE(0x010A, info) |
| #define INTEL_SNB_M_IDS(info) \ |
| INTEL_VGA_DEVICE(0x0106, info), \ |
| INTEL_VGA_DEVICE(0x0116, info), \ |
| INTEL_VGA_DEVICE(0x0126, info) |
| #define INTEL_IVB_M_IDS(info) \ |
| INTEL_VGA_DEVICE(0x0156, info), /* GT1 mobile */ \ |
| INTEL_VGA_DEVICE(0x0166, info) /* GT2 mobile */ |
| #define INTEL_IVB_D_IDS(info) \ |
| INTEL_VGA_DEVICE(0x0152, info), /* GT1 desktop */ \ |
| INTEL_VGA_DEVICE(0x0162, info), /* GT2 desktop */ \ |
| INTEL_VGA_DEVICE(0x015a, info), /* GT1 server */ \ |
| INTEL_VGA_DEVICE(0x016a, info) /* GT2 server */ |
| #define INTEL_IVB_Q_IDS(info) \ |
| INTEL_QUANTA_VGA_DEVICE(info) /* Quanta transcode */ |
| #define INTEL_HSW_D_IDS(info) \ |
| INTEL_VGA_DEVICE(0x0402, info), /* GT1 desktop */ \ |
| INTEL_VGA_DEVICE(0x0412, info), /* GT2 desktop */ \ |
| INTEL_VGA_DEVICE(0x0422, info), /* GT3 desktop */ \ |
| INTEL_VGA_DEVICE(0x040a, info), /* GT1 server */ \ |
| INTEL_VGA_DEVICE(0x041a, info), /* GT2 server */ \ |
| INTEL_VGA_DEVICE(0x042a, info), /* GT3 server */ \ |
| INTEL_VGA_DEVICE(0x040B, info), /* GT1 reserved */ \ |
| INTEL_VGA_DEVICE(0x041B, info), /* GT2 reserved */ \ |
| INTEL_VGA_DEVICE(0x042B, info), /* GT3 reserved */ \ |
| INTEL_VGA_DEVICE(0x040E, info), /* GT1 reserved */ \ |
| INTEL_VGA_DEVICE(0x041E, info), /* GT2 reserved */ \ |
| INTEL_VGA_DEVICE(0x042E, info), /* GT3 reserved */ \ |
| INTEL_VGA_DEVICE(0x0C02, info), /* SDV GT1 desktop */ \ |
| INTEL_VGA_DEVICE(0x0C12, info), /* SDV GT2 desktop */ \ |
| INTEL_VGA_DEVICE(0x0C22, info), /* SDV GT3 desktop */ \ |
| INTEL_VGA_DEVICE(0x0C0A, info), /* SDV GT1 server */ \ |
| INTEL_VGA_DEVICE(0x0C1A, info), /* SDV GT2 server */ \ |
| INTEL_VGA_DEVICE(0x0C2A, info), /* SDV GT3 server */ \ |
| INTEL_VGA_DEVICE(0x0C0B, info), /* SDV GT1 reserved */ \ |
| INTEL_VGA_DEVICE(0x0C1B, info), /* SDV GT2 reserved */ \ |
| INTEL_VGA_DEVICE(0x0C2B, info), /* SDV GT3 reserved */ \ |
| INTEL_VGA_DEVICE(0x0C0E, info), /* SDV GT1 reserved */ \ |
| INTEL_VGA_DEVICE(0x0C1E, info), /* SDV GT2 reserved */ \ |
| INTEL_VGA_DEVICE(0x0C2E, info), /* SDV GT3 reserved */ \ |
| INTEL_VGA_DEVICE(0x0A02, info), /* ULT GT1 desktop */ \ |
| INTEL_VGA_DEVICE(0x0A12, info), /* ULT GT2 desktop */ \ |
| INTEL_VGA_DEVICE(0x0A22, info), /* ULT GT3 desktop */ \ |
| INTEL_VGA_DEVICE(0x0A0A, info), /* ULT GT1 server */ \ |
| INTEL_VGA_DEVICE(0x0A1A, info), /* ULT GT2 server */ \ |
| INTEL_VGA_DEVICE(0x0A2A, info), /* ULT GT3 server */ \ |
| INTEL_VGA_DEVICE(0x0A0B, info), /* ULT GT1 reserved */ \ |
| INTEL_VGA_DEVICE(0x0A1B, info), /* ULT GT2 reserved */ \ |
| INTEL_VGA_DEVICE(0x0A2B, info), /* ULT GT3 reserved */ \ |
| INTEL_VGA_DEVICE(0x0D02, info), /* CRW GT1 desktop */ \ |
| INTEL_VGA_DEVICE(0x0D12, info), /* CRW GT2 desktop */ \ |
| INTEL_VGA_DEVICE(0x0D22, info), /* CRW GT3 desktop */ \ |
| INTEL_VGA_DEVICE(0x0D0A, info), /* CRW GT1 server */ \ |
| INTEL_VGA_DEVICE(0x0D1A, info), /* CRW GT2 server */ \ |
| INTEL_VGA_DEVICE(0x0D2A, info), /* CRW GT3 server */ \ |
| INTEL_VGA_DEVICE(0x0D0B, info), /* CRW GT1 reserved */ \ |
| INTEL_VGA_DEVICE(0x0D1B, info), /* CRW GT2 reserved */ \ |
| INTEL_VGA_DEVICE(0x0D2B, info), /* CRW GT3 reserved */ \ |
| INTEL_VGA_DEVICE(0x0D0E, info), /* CRW GT1 reserved */ \ |
| INTEL_VGA_DEVICE(0x0D1E, info), /* CRW GT2 reserved */ \ |
| INTEL_VGA_DEVICE(0x0D2E, info) /* CRW GT3 reserved */ \ |
| #define INTEL_HSW_M_IDS(info) \ |
| INTEL_VGA_DEVICE(0x0406, info), /* GT1 mobile */ \ |
| INTEL_VGA_DEVICE(0x0416, info), /* GT2 mobile */ \ |
| INTEL_VGA_DEVICE(0x0426, info), /* GT2 mobile */ \ |
| INTEL_VGA_DEVICE(0x0C06, info), /* SDV GT1 mobile */ \ |
| INTEL_VGA_DEVICE(0x0C16, info), /* SDV GT2 mobile */ \ |
| INTEL_VGA_DEVICE(0x0C26, info), /* SDV GT3 mobile */ \ |
| INTEL_VGA_DEVICE(0x0A06, info), /* ULT GT1 mobile */ \ |
| INTEL_VGA_DEVICE(0x0A16, info), /* ULT GT2 mobile */ \ |
| INTEL_VGA_DEVICE(0x0A26, info), /* ULT GT3 mobile */ \ |
| INTEL_VGA_DEVICE(0x0A0E, info), /* ULT GT1 reserved */ \ |
| INTEL_VGA_DEVICE(0x0A1E, info), /* ULT GT2 reserved */ \ |
| INTEL_VGA_DEVICE(0x0A2E, info), /* ULT GT3 reserved */ \ |
| INTEL_VGA_DEVICE(0x0D06, info), /* CRW GT1 mobile */ \ |
| INTEL_VGA_DEVICE(0x0D16, info), /* CRW GT2 mobile */ \ |
| INTEL_VGA_DEVICE(0x0D26, info) /* CRW GT3 mobile */ |
| #define INTEL_VLV_M_IDS(info) \ |
| INTEL_VGA_DEVICE(0x0f30, info), \ |
| INTEL_VGA_DEVICE(0x0f31, info), \ |
| INTEL_VGA_DEVICE(0x0f32, info), \ |
| INTEL_VGA_DEVICE(0x0f33, info), \ |
| INTEL_VGA_DEVICE(0x0157, info) |
| #define INTEL_VLV_D_IDS(info) \ |
| INTEL_VGA_DEVICE(0x0155, info) |
| #endif /* _I915_PCIIDS_H */ |
| /drivers/include/drm/i915_powerwell.h |
|---|
| 0,0 → 1,36 |
| /************************************************************************** |
| * |
| * Copyright 2013 Intel Inc. |
| * All Rights Reserved. |
| * |
| * 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, sub license, 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 NON-INFRINGEMENT. IN NO EVENT SHALL |
| * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS 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 _I915_POWERWELL_H_ |
| #define _I915_POWERWELL_H_ |
| /* For use by hda_i915 driver */ |
| extern void i915_request_power_well(void); |
| extern void i915_release_power_well(void); |
| #endif /* _I915_POWERWELL_H_ */ |
| /drivers/include/drm/ttm/ttm_bo_api.h |
|---|
| 148,7 → 148,6 |
| * @type: The bo type. |
| * @destroy: Destruction function. If NULL, kfree is used. |
| * @num_pages: Actual number of pages. |
| * @addr_space_offset: Address space offset. |
| * @acc_size: Accounted size for this object. |
| * @kref: Reference count of this buffer object. When this refcount reaches |
| * zero, the object is put on the delayed delete list. |
| 169,8 → 168,7 |
| * @swap: List head for swap LRU list. |
| * @sync_obj: Pointer to a synchronization object. |
| * @priv_flags: Flags describing buffer object internal state. |
| * @vm_rb: Rb node for the vm rb tree. |
| * @vm_node: Address space manager node. |
| * @vma_node: Address space manager node. |
| * @offset: The current GPU offset, which can have different meanings |
| * depending on the memory type. For SYSTEM type memory, it should be 0. |
| * @cur_placement: Hint of current placement. |
| /drivers/include/drm/ttm/ttm_bo_driver.h |
|---|
| 520,7 → 520,7 |
| * @man: An array of mem_type_managers. |
| * @fence_lock: Protects the synchronizing members on *all* bos belonging |
| * to this device. |
| * @addr_space_mm: Range manager for the device address space. |
| * @vma_manager: Address space manager |
| * lru_lock: Spinlock that protects the buffer+device lru lists and |
| * ddestroy lists. |
| * @val_seq: Current validation sequence. |
| 774,8 → 774,58 |
| bool interruptible); |
| extern void ttm_mem_io_unlock(struct ttm_mem_type_manager *man); |
| extern void ttm_bo_del_sub_from_lru(struct ttm_buffer_object *bo); |
| extern void ttm_bo_add_to_lru(struct ttm_buffer_object *bo); |
| /** |
| * ttm_bo_reserve_nolru: |
| * |
| * @bo: A pointer to a struct ttm_buffer_object. |
| * @interruptible: Sleep interruptible if waiting. |
| * @no_wait: Don't sleep while trying to reserve, rather return -EBUSY. |
| * @use_ticket: If @bo is already reserved, Only sleep waiting for |
| * it to become unreserved if @ticket->stamp is older. |
| * |
| * Will not remove reserved buffers from the lru lists. |
| * Otherwise identical to ttm_bo_reserve. |
| * |
| * Returns: |
| * -EDEADLK: The reservation may cause a deadlock. |
| * Release all buffer reservations, wait for @bo to become unreserved and |
| * try again. (only if use_sequence == 1). |
| * -ERESTARTSYS: A wait for the buffer to become unreserved was interrupted by |
| * a signal. Release all buffer reservations and return to user-space. |
| * -EBUSY: The function needed to sleep, but @no_wait was true |
| * -EALREADY: Bo already reserved using @ticket. This error code will only |
| * be returned if @use_ticket is set to true. |
| */ |
| static inline int ttm_bo_reserve_nolru(struct ttm_buffer_object *bo, |
| bool interruptible, |
| bool no_wait, bool use_ticket, |
| struct ww_acquire_ctx *ticket) |
| { |
| int ret = 0; |
| /* |
| if (no_wait) { |
| bool success; |
| if (WARN_ON(ticket)) |
| return -EBUSY; |
| success = ww_mutex_trylock(&bo->resv->lock); |
| return success ? 0 : -EBUSY; |
| } |
| if (interruptible) |
| ret = ww_mutex_lock_interruptible(&bo->resv->lock, ticket); |
| else |
| ret = ww_mutex_lock(&bo->resv->lock, ticket); |
| if (ret == -EINTR) |
| return -ERESTARTSYS; |
| */ |
| return ret; |
| } |
| /** |
| * ttm_bo_reserve: |
| * |
| * @bo: A pointer to a struct ttm_buffer_object. |
| 884,7 → 934,7 |
| ttm_bo_add_to_lru(bo); |
| spin_unlock(&bo->glob->lru_lock); |
| } |
| ww_mutex_unlock(&bo->resv->lock); |
| // ww_mutex_unlock(&bo->resv->lock); |
| } |
| /** |