/drivers/include/drm/drm.h |
---|
File deleted |
/drivers/include/drm/drm_memory.h |
---|
File deleted |
/drivers/include/drm/drmP.h |
---|
1,17 → 1,14 |
/** |
* \file drmP.h |
* Private header for Direct Rendering Manager |
/* |
* Internal Header for the Direct Rendering Manager |
* |
* \author Rickard E. (Rik) Faith <faith@valinux.com> |
* \author Gareth Hughes <gareth@valinux.com> |
*/ |
/* |
* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas. |
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California. |
* Copyright (c) 2009-2010, Code Aurora Forum. |
* All rights reserved. |
* |
* Author: Rickard E. (Rik) Faith <faith@valinux.com> |
* Author: Gareth Hughes <gareth@valinux.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 |
35,91 → 32,69 |
#ifndef _DRM_P_H_ |
#define _DRM_P_H_ |
#define iowrite32(v, addr) writel((v), (addr)) |
#ifdef __KERNEL__ |
#ifdef __alpha__ |
/* add include of current.h so that "current" is defined |
* before static inline funcs in wait.h. Doing this so we |
* can build the DRM (part of PI DRI). 4/21/2000 S + B */ |
#include <asm/current.h> |
#endif /* __alpha__ */ |
#include <syscall.h> |
#include <linux/agp_backend.h> |
#include <linux/dma-mapping.h> |
#include <linux/file.h> |
#include <linux/fs.h> |
#include <linux/idr.h> |
#include <linux/jiffies.h> |
#include <linux/kernel.h> |
#include <linux/export.h> |
#include <linux/errno.h> |
#include <linux/kref.h> |
#include <linux/mm.h> |
#include <linux/spinlock.h> |
#include <linux/wait.h> |
#include <linux/bug.h> |
#include <linux/mutex.h> |
#include <linux/pci.h> |
#include <linux/sched.h> |
#include <linux/firmware.h> |
#include <linux/err.h> |
#include <linux/fs.h> |
//#include <linux/init.h> |
#include <linux/file.h> |
#include <linux/pci.h> |
#include <linux/jiffies.h> |
#include <linux/dma-mapping.h> |
#include <linux/irqreturn.h> |
#include <linux/mutex.h> |
//#include <asm/io.h> |
#include <linux/slab.h> |
//#include <asm/uaccess.h> |
//#include <linux/workqueue.h> |
//#include <linux/poll.h> |
//#include <asm/pgalloc.h> |
#include <linux/types.h> |
#include <linux/vmalloc.h> |
#include <linux/workqueue.h> |
#include <uapi/drm/drm.h> |
#include <uapi/drm/drm_mode.h> |
#include <drm/drm.h> |
#include <drm/drm_agpsupport.h> |
#include <drm/drm_crtc.h> |
#include <drm/drm_global.h> |
#include <drm/drm_hashtab.h> |
#include <drm/drm_mem_util.h> |
#include <drm/drm_mm.h> |
#include <drm/drm_os_linux.h> |
#include <drm/drm_sarea.h> |
#include <drm/drm_vma_manager.h> |
#include <linux/idr.h> |
#define __OS_HAS_AGP (defined(CONFIG_AGP) || (defined(CONFIG_AGP_MODULE) && defined(MODULE))) |
struct module; |
struct drm_file; |
struct drm_device; |
struct drm_agp_head; |
struct drm_local_map; |
struct drm_device_dma; |
struct drm_dma_handle; |
struct drm_gem_object; |
struct device_node; |
struct videomode; |
struct reservation_object; |
struct dma_buf_attachment; |
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> |
#define KHZ2PICOS(a) (1000000000UL/(a)) |
/* Flags and return codes for get_vblank_timestamp() driver function. */ |
#define DRM_CALLED_FROM_VBLIRQ 1 |
#define DRM_VBLANKTIME_SCANOUTPOS_METHOD (1 << 0) |
#define DRM_VBLANKTIME_INVBL (1 << 1) |
/* get_scanout_position() return flags */ |
#define DRM_SCANOUTPOS_VALID (1 << 0) |
#define DRM_SCANOUTPOS_INVBL (1 << 1) |
#define DRM_SCANOUTPOS_ACCURATE (1 << 2) |
/* |
* 4 debug categories are defined: |
* |
156,8 → 131,8 |
extern __printf(2, 3) |
void drm_ut_debug_printk(const char *function_name, |
const char *format, ...); |
extern __printf(2, 3) |
int drm_err(const char *func, const char *format, ...); |
extern __printf(1, 2) |
void drm_err(const char *format, ...); |
/***********************************************************************/ |
/** \name DRM template customization defaults */ |
175,25 → 150,7 |
#define DRIVER_PRIME 0x4000 |
#define DRIVER_RENDER 0x8000 |
#define DRIVER_BUS_PCI 0x1 |
#define DRIVER_BUS_PLATFORM 0x2 |
#define DRIVER_BUS_USB 0x3 |
#define DRIVER_BUS_HOST1X 0x4 |
/***********************************************************************/ |
/** \name Begin the DRM... */ |
/*@{*/ |
#define DRM_DEBUG_CODE 2 /**< Include debugging code if > 1, then |
also include looping detection. */ |
#define DRM_MAGIC_HASH_ORDER 4 /**< Size of key hash table. Must be power of 2. */ |
#define DRM_MAP_HASH_OFFSET 0x10000000 |
/*@}*/ |
/***********************************************************************/ |
/** \name Macros to make printk easier */ |
/*@{*/ |
204,7 → 161,7 |
* \param arg arguments |
*/ |
#define DRM_ERROR(fmt, ...) \ |
drm_err(__func__, fmt, ##__VA_ARGS__) |
drm_err(fmt, ##__VA_ARGS__) |
/** |
* Rate limited error output. Like DRM_ERROR() but won't flood the log. |
219,7 → 176,7 |
DEFAULT_RATELIMIT_BURST); \ |
\ |
if (__ratelimit(&_rs)) \ |
drm_err(__func__, fmt, ##__VA_ARGS__); \ |
drm_err(fmt, ##__VA_ARGS__); \ |
}) |
#define DRM_INFO(fmt, ...) \ |
265,28 → 222,9 |
/** \name Internal types and structures */ |
/*@{*/ |
#define DRM_ARRAY_SIZE(x) ARRAY_SIZE(x) |
#define DRM_IF_VERSION(maj, min) (maj << 16 | min) |
/** |
* Test that the hardware lock is held by the caller, returning otherwise. |
* |
* \param dev DRM device. |
* \param filp file pointer of the caller. |
*/ |
#define LOCK_TEST_WITH_RETURN( dev, _file_priv ) \ |
do { \ |
if (!_DRM_LOCK_IS_HELD(_file_priv->master->lock.hw_lock->lock) || \ |
_file_priv->master->lock.file_priv != _file_priv) { \ |
DRM_ERROR( "%s called without lock held, held %d owner %p %p\n",\ |
__func__, _DRM_LOCK_IS_HELD(_file_priv->master->lock.hw_lock->lock),\ |
_file_priv->master->lock.file_priv, _file_priv); \ |
return -EINVAL; \ |
} \ |
} while (0) |
/** |
* Ioctl function type. |
* |
* \param inode device inode. |
326,83 → 264,6 |
#define DRM_IOCTL_DEF_DRV(ioctl, _func, _flags) \ |
[DRM_IOCTL_NR(DRM_##ioctl)] = {.cmd = DRM_##ioctl, .func = _func, .flags = _flags, .cmd_drv = DRM_IOCTL_##ioctl, .name = #ioctl} |
#if 0 |
struct drm_magic_entry { |
struct list_head head; |
struct drm_hash_item hash_item; |
struct drm_file *priv; |
}; |
struct drm_vma_entry { |
struct list_head head; |
struct vm_area_struct *vma; |
pid_t pid; |
}; |
/** |
* DMA buffer. |
*/ |
struct drm_buf { |
int idx; /**< Index into master buflist */ |
int total; /**< Buffer size */ |
int order; /**< log-base-2(total) */ |
int used; /**< Amount of buffer in use (for DMA) */ |
unsigned long offset; /**< Byte offset (used internally) */ |
void *address; /**< Address of buffer */ |
unsigned long bus_address; /**< Bus address of buffer */ |
struct drm_buf *next; /**< Kernel-only: used for free list */ |
__volatile__ int waiting; /**< On kernel DMA queue */ |
__volatile__ int pending; /**< On hardware DMA queue */ |
struct drm_file *file_priv; /**< Private of holding file descr */ |
int context; /**< Kernel queue for this buffer */ |
int while_locked; /**< Dispatch this buffer while locked */ |
enum { |
DRM_LIST_NONE = 0, |
DRM_LIST_FREE = 1, |
DRM_LIST_WAIT = 2, |
DRM_LIST_PEND = 3, |
DRM_LIST_PRIO = 4, |
DRM_LIST_RECLAIM = 5 |
} list; /**< Which list we're on */ |
int dev_priv_size; /**< Size of buffer private storage */ |
void *dev_private; /**< Per-buffer private storage */ |
}; |
/** bufs is one longer than it has to be */ |
struct drm_waitlist { |
int count; /**< Number of possible buffers */ |
struct drm_buf **bufs; /**< List of pointers to buffers */ |
struct drm_buf **rp; /**< Read pointer */ |
struct drm_buf **wp; /**< Write pointer */ |
struct drm_buf **end; /**< End pointer */ |
spinlock_t read_lock; |
spinlock_t write_lock; |
}; |
#endif |
typedef struct drm_dma_handle { |
dma_addr_t busaddr; |
void *vaddr; |
size_t size; |
} drm_dma_handle_t; |
/** |
* Buffer entry. There is one of this for each buffer size order. |
*/ |
struct drm_buf_entry { |
int buf_size; /**< size */ |
int buf_count; /**< number of buffers */ |
struct drm_buf *buflist; /**< buffer list */ |
int seg_count; |
int page_order; |
struct drm_dma_handle **seglist; |
int low_mark; /**< Low water mark */ |
int high_mark; /**< High water mark */ |
}; |
/* Event queued up for userspace to read */ |
struct drm_pending_event { |
struct drm_event *event; |
457,7 → 318,6 |
int event_space; |
}; |
#if 0 |
/** |
* Lock data. |
*/ |
474,192 → 334,6 |
}; |
/** |
* DMA data. |
*/ |
struct drm_device_dma { |
struct drm_buf_entry bufs[DRM_MAX_ORDER + 1]; /**< buffers, grouped by their size order */ |
int buf_count; /**< total number of buffers */ |
struct drm_buf **buflist; /**< Vector of pointers into drm_device_dma::bufs */ |
int seg_count; |
int page_count; /**< number of pages */ |
unsigned long *pagelist; /**< page list */ |
unsigned long byte_count; |
enum { |
_DRM_DMA_USE_AGP = 0x01, |
_DRM_DMA_USE_SG = 0x02, |
_DRM_DMA_USE_FB = 0x04, |
_DRM_DMA_USE_PCI_RO = 0x08 |
} flags; |
}; |
/** |
* AGP memory entry. Stored as a doubly linked list. |
*/ |
struct drm_agp_mem { |
unsigned long handle; /**< handle */ |
struct agp_memory *memory; |
unsigned long bound; /**< address */ |
int pages; |
struct list_head head; |
}; |
/** |
* AGP data. |
* |
* \sa drm_agp_init() and drm_device::agp. |
*/ |
struct drm_agp_head { |
struct agp_kern_info agp_info; /**< AGP device information */ |
struct list_head memory; |
unsigned long mode; /**< AGP mode */ |
struct agp_bridge_data *bridge; |
int enabled; /**< whether the AGP bus as been enabled */ |
int acquired; /**< whether the AGP device has been acquired */ |
unsigned long base; |
int agp_mtrr; |
int cant_use_aperture; |
unsigned long page_mask; |
}; |
/** |
* Scatter-gather memory. |
*/ |
struct drm_sg_mem { |
unsigned long handle; |
void *virtual; |
int pages; |
struct page **pagelist; |
dma_addr_t *busaddr; |
}; |
struct drm_sigdata { |
int context; |
struct drm_hw_lock *lock; |
}; |
#endif |
/** |
* Kernel side of a mapping |
*/ |
struct drm_local_map { |
resource_size_t offset; /**< Requested physical address (0 for SAREA)*/ |
unsigned long size; /**< Requested physical size (bytes) */ |
enum drm_map_type type; /**< Type of memory to map */ |
enum drm_map_flags flags; /**< Flags */ |
void *handle; /**< User-space: "Handle" to pass to mmap() */ |
/**< Kernel-space: kernel-virtual address */ |
int mtrr; /**< MTRR slot used */ |
}; |
typedef struct drm_local_map drm_local_map_t; |
/** |
* Mappings list |
*/ |
struct drm_map_list { |
struct list_head head; /**< list head */ |
struct drm_hash_item hash; |
struct drm_local_map *map; /**< mapping */ |
uint64_t user_token; |
struct drm_master *master; |
}; |
/* location of GART table */ |
#define DRM_ATI_GART_MAIN 1 |
#define DRM_ATI_GART_FB 2 |
#define DRM_ATI_GART_PCI 1 |
#define DRM_ATI_GART_PCIE 2 |
#define DRM_ATI_GART_IGP 3 |
struct drm_ati_pcigart_info { |
int gart_table_location; |
int gart_reg_if; |
void *addr; |
dma_addr_t bus_addr; |
dma_addr_t table_mask; |
struct drm_dma_handle *table_handle; |
struct drm_local_map mapping; |
int table_size; |
}; |
/** |
* This structure defines the drm_mm memory object, which will be used by the |
* DRM for its buffer objects. |
*/ |
struct drm_gem_object { |
/** Reference count of this object */ |
struct kref refcount; |
/** |
* 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; |
/** File representing the shmem storage */ |
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 |
* lifetime. |
*/ |
size_t size; |
/** |
* Global name for this object, starts at 1. 0 means unnamed. |
* Access is covered by the object_name_lock in the related drm_device |
*/ |
int name; |
/** |
* Memory domains. These monitor which caches contain read/write data |
* related to the object. When transitioning from one set of domains |
* to another, the driver is called to ensure that caches are suitably |
* flushed and invalidated |
*/ |
uint32_t read_domains; |
uint32_t write_domain; |
/** |
* While validating an exec operation, the |
* new read/write domain values are computed here. |
* They will be transferred to the above values |
* at the point that any cache flushing occurs |
*/ |
uint32_t pending_read_domains; |
uint32_t pending_write_domain; |
/** |
* dma_buf - dma buf associated with this GEM object |
* |
* Pointer to the dma-buf associated with this gem object (either |
* through importing or exporting). We break the resulting reference |
* loop when the last gem handle for this object is released. |
* |
* Protected by obj->object_name_lock |
*/ |
struct dma_buf *dma_buf; |
}; |
#include <drm/drm_crtc.h> |
/** |
* struct drm_master - drm master structure |
* |
* @refcount: Refcount for this master object. |
666,7 → 340,6 |
* @minor: Link back to minor char device we are master for. Immutable. |
* @unique: Unique identifier: e.g. busid. Protected by drm_global_mutex. |
* @unique_len: Length of unique field. Protected by drm_global_mutex. |
* @unique_size: Amount allocated. Protected by drm_global_mutex. |
* @magiclist: Hash of used authentication tokens. Protected by struct_mutex. |
* @magicfree: List of used authentication tokens. Protected by struct_mutex. |
* @lock: DRI lock information. |
677,10 → 350,9 |
struct drm_minor *minor; |
char *unique; |
int unique_len; |
int unique_size; |
// struct drm_open_hash magiclist; |
// struct list_head magicfree; |
// struct drm_lock_data lock; |
struct drm_open_hash magiclist; |
struct list_head magicfree; |
struct drm_lock_data lock; |
void *driver_priv; |
}; |
692,17 → 364,13 |
/* Flags and return codes for get_vblank_timestamp() driver function. */ |
#define DRM_CALLED_FROM_VBLIRQ 1 |
#define DRM_VBLANKTIME_SCANOUTPOS_METHOD (1 << 0) |
#define DRM_VBLANKTIME_INVBL (1 << 1) |
#define DRM_VBLANKTIME_IN_VBLANK (1 << 1) |
/* get_scanout_position() return flags */ |
#define DRM_SCANOUTPOS_VALID (1 << 0) |
#define DRM_SCANOUTPOS_INVBL (1 << 1) |
#define DRM_SCANOUTPOS_IN_VBLANK (1 << 1) |
#define DRM_SCANOUTPOS_ACCURATE (1 << 2) |
struct drm_bus { |
int (*set_busid)(struct drm_device *dev, struct drm_master *master); |
}; |
/** |
* DRM driver structure. This structure represent the common code for |
* a family of cards. There will one drm_device for each card present |
894,7 → 562,28 |
}; |
struct drm_pending_vblank_event { |
struct drm_pending_event base; |
int pipe; |
struct drm_event_vblank event; |
}; |
struct drm_vblank_crtc { |
struct drm_device *dev; /* pointer to the drm_device */ |
wait_queue_head_t queue; /**< VBLANK wait queue */ |
struct timeval time[DRM_VBLANKTIME_RBSIZE]; /**< timestamp of current count */ |
struct timer_list disable_timer; /* delayed disable timer */ |
atomic_t count; /**< number of VBLANK interrupts */ |
atomic_t refcount; /* number of users of vblank interruptsper crtc */ |
u32 last; /* protected by dev->vbl_lock, used */ |
/* for wraparound handling */ |
u32 last_wait; /* Last vblank seqno waited per CRTC */ |
unsigned int inmodeset; /* Display driver is setting mode */ |
int crtc; /* crtc index */ |
bool enabled; /* so we don't call enable more than |
once per disable */ |
}; |
/** |
* DRM device structure. This structure represent a complete card that |
* may contain multiple heads. |
903,6 → 592,9 |
struct list_head legacy_dev_list;/**< list of devices per driver for stealth attach cleanup */ |
int if_version; /**< Highest interface version set */ |
/** \name Lifetime Management */ |
/*@{ */ |
struct kref ref; /**< Object ref-count */ |
struct device *dev; /**< Device structure of bus-device */ |
struct drm_driver *driver; /**< DRM driver managing the device */ |
void *dev_private; /**< DRM driver private data */ |
964,6 → 656,16 |
*/ |
bool vblank_disable_allowed; |
/* |
* If true, vblank interrupt will be disabled immediately when the |
* refcount drops to zero, as opposed to via the vblank disable |
* timer. |
* This can be set to true it the hardware has a working vblank |
* counter and the driver uses drm_vblank_on() and drm_vblank_off() |
* appropriately. |
*/ |
bool vblank_disable_immediate; |
/* array of size num_crtcs */ |
struct drm_vblank_crtc *vblank; |
986,6 → 688,10 |
unsigned int num_crtcs; /**< Number of CRTCs on this device */ |
struct { |
int context; |
struct drm_hw_lock *lock; |
} sigdata; |
struct drm_mode_config mode_config; /**< Current mode config */ |
1032,11 → 738,9 |
unsigned int cmd, unsigned long arg); |
extern long drm_compat_ioctl(struct file *filp, |
unsigned int cmd, unsigned long arg); |
extern int drm_lastclose(struct drm_device *dev); |
extern bool drm_ioctl_flags(unsigned int nr, unsigned int *flags); |
/* Device support (drm_fops.h) */ |
extern struct mutex drm_global_mutex; |
extern int drm_open(struct inode *inode, struct file *filp); |
extern ssize_t drm_read(struct file *filp, char __user *buffer, |
size_t count, loff_t *offset); |
1043,101 → 747,23 |
extern int drm_release(struct inode *inode, struct file *filp); |
/* Mapping support (drm_vm.h) */ |
extern int drm_mmap(struct file *filp, struct vm_area_struct *vma); |
extern int drm_mmap_locked(struct file *filp, struct vm_area_struct *vma); |
extern void drm_vm_open_locked(struct drm_device *dev, struct vm_area_struct *vma); |
extern void drm_vm_close_locked(struct drm_device *dev, struct vm_area_struct *vma); |
extern unsigned int drm_poll(struct file *filp, struct poll_table_struct *wait); |
/* Memory management support (drm_memory.h) */ |
#include <drm/drm_memory.h> |
/* Misc. IOCTL support (drm_ioctl.h) */ |
extern int drm_irq_by_busid(struct drm_device *dev, void *data, |
/* Misc. IOCTL support (drm_ioctl.c) */ |
int drm_noop(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_getunique(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_setunique(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_getmap(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_getclient(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_getstats(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_getcap(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_setclientcap(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_setversion(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_noop(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
/* Authentication IOCTL support (drm_auth.h) */ |
extern int drm_getmagic(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_authmagic(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_remove_magic(struct drm_master *master, drm_magic_t magic); |
/* Cache management (drm_cache.c) */ |
void drm_clflush_pages(struct page *pages[], unsigned long num_pages); |
void drm_clflush_sg(struct sg_table *st); |
void drm_clflush_virt_range(void *addr, unsigned long length); |
/* Locking IOCTL support (drm_lock.h) */ |
extern int drm_lock(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_unlock(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_lock_free(struct drm_lock_data *lock_data, unsigned int context); |
extern void drm_idlelock_take(struct drm_lock_data *lock_data); |
extern void drm_idlelock_release(struct drm_lock_data *lock_data); |
/* |
* These are exported to drivers so that they can implement fencing using |
* DMA quiscent + idle. DMA quiescent usually requires the hardware lock. |
*/ |
extern int drm_i_have_hw_lock(struct drm_device *dev, struct drm_file *file_priv); |
/* Buffer management support (drm_bufs.h) */ |
extern int drm_addbufs_agp(struct drm_device *dev, struct drm_buf_desc * request); |
extern int drm_addbufs_pci(struct drm_device *dev, struct drm_buf_desc * request); |
extern int drm_addmap(struct drm_device *dev, resource_size_t offset, |
unsigned int size, enum drm_map_type type, |
enum drm_map_flags flags, struct drm_local_map **map_ptr); |
extern int drm_addmap_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_rmmap(struct drm_device *dev, struct drm_local_map *map); |
extern int drm_rmmap_locked(struct drm_device *dev, struct drm_local_map *map); |
extern int drm_rmmap_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_addbufs(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_infobufs(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_markbufs(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_freebufs(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_mapbufs(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_dma_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
/* DMA support (drm_dma.h) */ |
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); |
/* IRQ support (drm_irq.h) */ |
extern int drm_control(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_irq_install(struct drm_device *dev, int irq); |
extern int drm_irq_uninstall(struct drm_device *dev); |
1154,6 → 780,8 |
extern void drm_vblank_put(struct drm_device *dev, int crtc); |
extern int drm_crtc_vblank_get(struct drm_crtc *crtc); |
extern void drm_crtc_vblank_put(struct drm_crtc *crtc); |
extern void drm_wait_one_vblank(struct drm_device *dev, int crtc); |
extern void drm_crtc_wait_one_vblank(struct drm_crtc *crtc); |
extern void drm_vblank_off(struct drm_device *dev, int crtc); |
extern void drm_vblank_on(struct drm_device *dev, int crtc); |
extern void drm_crtc_vblank_off(struct drm_crtc *crtc); |
1160,8 → 788,6 |
extern void drm_crtc_vblank_on(struct drm_crtc *crtc); |
extern void drm_vblank_cleanup(struct drm_device *dev); |
extern u32 drm_get_last_vbltimestamp(struct drm_device *dev, int crtc, |
struct timeval *tvblank, unsigned flags); |
extern int drm_calc_vbltimestamp_from_scanoutpos(struct drm_device *dev, |
int crtc, int *max_error, |
struct timeval *vblank_time, |
1171,21 → 797,23 |
extern void drm_calc_timestamping_constants(struct drm_crtc *crtc, |
const struct drm_display_mode *mode); |
/** |
* drm_crtc_vblank_waitqueue - get vblank waitqueue for the CRTC |
* @crtc: which CRTC's vblank waitqueue to retrieve |
* |
* This function returns a pointer to the vblank waitqueue for the CRTC. |
* Drivers can use this to implement vblank waits using wait_event() & co. |
*/ |
static inline wait_queue_head_t *drm_crtc_vblank_waitqueue(struct drm_crtc *crtc) |
{ |
return &crtc->dev->vblank[drm_crtc_index(crtc)].queue; |
} |
/* Modesetting support */ |
extern void drm_vblank_pre_modeset(struct drm_device *dev, int crtc); |
extern void drm_vblank_post_modeset(struct drm_device *dev, int crtc); |
extern int drm_modeset_ctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
/* AGP/GART support (drm_agpsupport.h) */ |
/* Stub support (drm_stub.h) */ |
extern int drm_setmaster_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_dropmaster_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
struct drm_master *drm_master_create(struct drm_minor *minor); |
extern struct drm_master *drm_master_get(struct drm_master *master); |
extern void drm_master_put(struct drm_master **master); |
1193,34 → 821,14 |
extern void drm_unplug_dev(struct drm_device *dev); |
extern unsigned int drm_debug; |
#if 0 |
extern unsigned int drm_vblank_offdelay; |
extern unsigned int drm_timestamp_precision; |
extern unsigned int drm_timestamp_monotonic; |
extern struct class *drm_class; |
extern struct drm_local_map *drm_getsarea(struct drm_device *dev); |
#endif |
/* Debugfs support */ |
#if defined(CONFIG_DEBUG_FS) |
extern int drm_debugfs_init(struct drm_minor *minor, int minor_id, |
struct dentry *root); |
extern int drm_debugfs_create_files(const struct drm_info_list *files, |
int count, struct dentry *root, |
struct drm_minor *minor); |
extern int drm_debugfs_remove_files(const struct drm_info_list *files, |
int count, struct drm_minor *minor); |
extern int drm_debugfs_cleanup(struct drm_minor *minor); |
extern int drm_debugfs_connector_add(struct drm_connector *connector); |
extern void drm_debugfs_connector_remove(struct drm_connector *connector); |
#else |
static inline int drm_debugfs_init(struct drm_minor *minor, int minor_id, |
struct dentry *root) |
{ |
return 0; |
} |
static inline int drm_debugfs_create_files(const struct drm_info_list *files, |
int count, struct dentry *root, |
struct drm_minor *minor) |
1233,164 → 841,44 |
{ |
return 0; |
} |
static inline int drm_debugfs_cleanup(struct drm_minor *minor) |
{ |
return 0; |
} |
static inline int drm_debugfs_connector_add(struct drm_connector *connector) |
{ |
return 0; |
} |
static inline void drm_debugfs_connector_remove(struct drm_connector *connector) |
{ |
} |
#endif |
/* Info file support */ |
extern int drm_name_info(struct seq_file *m, void *data); |
extern int drm_vm_info(struct seq_file *m, void *data); |
extern int drm_bufs_info(struct seq_file *m, void *data); |
extern int drm_vblank_info(struct seq_file *m, void *data); |
extern int drm_clients_info(struct seq_file *m, void* data); |
extern int drm_gem_name_info(struct seq_file *m, void *data); |
extern struct dma_buf *drm_gem_prime_export(struct drm_device *dev, |
struct drm_gem_object *obj, int flags); |
extern int drm_gem_prime_handle_to_fd(struct drm_device *dev, |
struct drm_file *file_priv, uint32_t handle, uint32_t flags, |
int *prime_fd); |
extern struct drm_gem_object *drm_gem_prime_import(struct drm_device *dev, |
struct dma_buf *dma_buf); |
extern int drm_gem_prime_fd_to_handle(struct drm_device *dev, |
struct drm_file *file_priv, int prime_fd, uint32_t *handle); |
extern void drm_gem_dmabuf_release(struct dma_buf *dma_buf); |
#if DRM_DEBUG_CODE |
extern int drm_vma_info(struct seq_file *m, void *data); |
#endif |
extern int drm_prime_sg_to_page_addr_arrays(struct sg_table *sgt, struct page **pages, |
dma_addr_t *addrs, int max_pages); |
extern struct sg_table *drm_prime_pages_to_sg(struct page **pages, unsigned int nr_pages); |
extern void drm_prime_gem_destroy(struct drm_gem_object *obj, struct sg_table *sg); |
/* Scatter Gather Support (drm_scatter.h) */ |
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_free(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
/* ATI PCIGART support (ati_pcigart.h) */ |
extern int drm_ati_pcigart_init(struct drm_device *dev, |
struct drm_ati_pcigart_info * gart_info); |
extern int drm_ati_pcigart_cleanup(struct drm_device *dev, |
struct drm_ati_pcigart_info * gart_info); |
extern drm_dma_handle_t *drm_pci_alloc(struct drm_device *dev, size_t size, |
extern struct drm_dma_handle *drm_pci_alloc(struct drm_device *dev, size_t size, |
size_t align); |
extern void __drm_pci_free(struct drm_device *dev, drm_dma_handle_t * dmah); |
extern void drm_pci_free(struct drm_device *dev, drm_dma_handle_t * dmah); |
extern void drm_pci_free(struct drm_device *dev, struct drm_dma_handle * dmah); |
#if 0 |
/* sysfs support (drm_sysfs.c) */ |
struct drm_sysfs_class; |
extern struct class *drm_sysfs_create(struct module *owner, char *name); |
extern void drm_sysfs_destroy(void); |
extern struct device *drm_sysfs_minor_alloc(struct drm_minor *minor); |
extern void drm_sysfs_hotplug_event(struct drm_device *dev); |
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) */ |
int drm_gem_init(struct drm_device *dev); |
void drm_gem_destroy(struct drm_device *dev); |
void drm_gem_object_release(struct drm_gem_object *obj); |
void drm_gem_object_free(struct kref *kref); |
int drm_gem_object_init(struct drm_device *dev, |
struct drm_gem_object *obj, size_t size); |
void drm_gem_private_object_init(struct drm_device *dev, |
struct drm_gem_object *obj, size_t size); |
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) |
{ |
kref_get(&obj->refcount); |
} |
static inline void |
drm_gem_object_unreference(struct drm_gem_object *obj) |
{ |
if (obj != NULL) |
kref_put(&obj->refcount, drm_gem_object_free); |
} |
static inline void |
drm_gem_object_unreference_unlocked(struct drm_gem_object *obj) |
{ |
if (obj && !atomic_add_unless(&obj->refcount.refcount, -1, 1)) { |
struct drm_device *dev = obj->dev; |
mutex_lock(&dev->struct_mutex); |
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); |
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); |
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); |
int drm_gem_close_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
int drm_gem_flink_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
int drm_gem_open_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
void drm_gem_open(struct drm_device *dev, struct drm_file *file_private); |
void drm_gem_release(struct drm_device *dev, struct drm_file *file_private); |
extern void drm_core_ioremap(struct drm_local_map *map, struct drm_device *dev); |
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); |
static __inline__ struct drm_local_map *drm_core_findmap(struct drm_device *dev, |
unsigned int token) |
{ |
struct drm_map_list *_entry; |
list_for_each_entry(_entry, &dev->maplist, head) |
if (_entry->user_token == token) |
return _entry->map; |
return NULL; |
} |
static __inline__ void drm_core_dropmap(struct drm_local_map *map) |
{ |
} |
#include <drm/drm_mem_util.h> |
struct drm_device *drm_dev_alloc(struct drm_driver *driver, |
struct device *parent); |
void drm_dev_ref(struct drm_device *dev); |
void drm_dev_unref(struct drm_device *dev); |
int drm_dev_register(struct drm_device *dev, unsigned long flags); |
void drm_dev_unregister(struct drm_device *dev); |
int drm_dev_set_unique(struct drm_device *dev, const char *fmt, ...); |
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); |
struct drm_minor *drm_minor_acquire(unsigned int minor_id); |
void drm_minor_release(struct drm_minor *minor); |
/*@}*/ |
/* PCI section */ |
1420,11 → 908,7 |
{ |
return pci_find_capability(dev->pdev, PCI_CAP_ID_EXP); |
} |
#endif /* __KERNEL__ */ |
#define drm_sysfs_connector_add(connector) |
#define drm_sysfs_connector_remove(connector) |
#define LFB_SIZE 0x1000000 |
extern struct drm_device *main_device; |
extern struct drm_file *drm_file_handlers[256]; |
/drivers/include/drm/drm_agpsupport.h |
---|
0,0 → 1,199 |
#ifndef _DRM_AGPSUPPORT_H_ |
#define _DRM_AGPSUPPORT_H_ |
#include <linux/agp_backend.h> |
#include <linux/kernel.h> |
#include <linux/list.h> |
#include <linux/mm.h> |
#include <linux/mutex.h> |
#include <linux/types.h> |
#include <uapi/drm/drm.h> |
struct drm_device; |
struct drm_file; |
#define __OS_HAS_AGP (defined(CONFIG_AGP) || (defined(CONFIG_AGP_MODULE) && \ |
defined(MODULE))) |
struct drm_agp_head { |
struct agp_kern_info agp_info; |
struct list_head memory; |
unsigned long mode; |
struct agp_bridge_data *bridge; |
int enabled; |
int acquired; |
unsigned long base; |
int agp_mtrr; |
int cant_use_aperture; |
unsigned long page_mask; |
}; |
#if __OS_HAS_AGP |
void drm_free_agp(struct agp_memory * handle, int pages); |
int drm_bind_agp(struct agp_memory * handle, unsigned int start); |
int drm_unbind_agp(struct agp_memory * handle); |
struct agp_memory *drm_agp_bind_pages(struct drm_device *dev, |
struct page **pages, |
unsigned long num_pages, |
uint32_t gtt_offset, |
uint32_t type); |
struct drm_agp_head *drm_agp_init(struct drm_device *dev); |
void drm_agp_clear(struct drm_device *dev); |
int drm_agp_acquire(struct drm_device *dev); |
int drm_agp_acquire_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
int drm_agp_release(struct drm_device *dev); |
int drm_agp_release_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
int drm_agp_enable(struct drm_device *dev, struct drm_agp_mode mode); |
int drm_agp_enable_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
int drm_agp_info(struct drm_device *dev, struct drm_agp_info *info); |
int drm_agp_info_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
int drm_agp_alloc(struct drm_device *dev, struct drm_agp_buffer *request); |
int drm_agp_alloc_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
int drm_agp_free(struct drm_device *dev, struct drm_agp_buffer *request); |
int drm_agp_free_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
int drm_agp_unbind(struct drm_device *dev, struct drm_agp_binding *request); |
int drm_agp_unbind_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
int drm_agp_bind(struct drm_device *dev, struct drm_agp_binding *request); |
int drm_agp_bind_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
#else /* __OS_HAS_AGP */ |
static inline void drm_free_agp(struct agp_memory * handle, int pages) |
{ |
} |
static inline int drm_bind_agp(struct agp_memory * handle, unsigned int start) |
{ |
return -ENODEV; |
} |
static inline int drm_unbind_agp(struct agp_memory * handle) |
{ |
return -ENODEV; |
} |
static inline struct agp_memory *drm_agp_bind_pages(struct drm_device *dev, |
struct page **pages, |
unsigned long num_pages, |
uint32_t gtt_offset, |
uint32_t type) |
{ |
return NULL; |
} |
static inline struct drm_agp_head *drm_agp_init(struct drm_device *dev) |
{ |
return NULL; |
} |
static inline void drm_agp_clear(struct drm_device *dev) |
{ |
} |
static inline int drm_agp_acquire(struct drm_device *dev) |
{ |
return -ENODEV; |
} |
static inline int drm_agp_acquire_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv) |
{ |
return -ENODEV; |
} |
static inline int drm_agp_release(struct drm_device *dev) |
{ |
return -ENODEV; |
} |
static inline int drm_agp_release_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv) |
{ |
return -ENODEV; |
} |
static inline int drm_agp_enable(struct drm_device *dev, |
struct drm_agp_mode mode) |
{ |
return -ENODEV; |
} |
static inline int drm_agp_enable_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv) |
{ |
return -ENODEV; |
} |
static inline int drm_agp_info(struct drm_device *dev, |
struct drm_agp_info *info) |
{ |
return -ENODEV; |
} |
static inline int drm_agp_info_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv) |
{ |
return -ENODEV; |
} |
static inline int drm_agp_alloc(struct drm_device *dev, |
struct drm_agp_buffer *request) |
{ |
return -ENODEV; |
} |
static inline int drm_agp_alloc_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv) |
{ |
return -ENODEV; |
} |
static inline int drm_agp_free(struct drm_device *dev, |
struct drm_agp_buffer *request) |
{ |
return -ENODEV; |
} |
static inline int drm_agp_free_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv) |
{ |
return -ENODEV; |
} |
static inline int drm_agp_unbind(struct drm_device *dev, |
struct drm_agp_binding *request) |
{ |
return -ENODEV; |
} |
static inline int drm_agp_unbind_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv) |
{ |
return -ENODEV; |
} |
static inline int drm_agp_bind(struct drm_device *dev, |
struct drm_agp_binding *request) |
{ |
return -ENODEV; |
} |
static inline int drm_agp_bind_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv) |
{ |
return -ENODEV; |
} |
#endif /* __OS_HAS_AGP */ |
#endif /* _DRM_AGPSUPPORT_H_ */ |
/drivers/include/drm/drm_atomic.h |
---|
0,0 → 1,69 |
/* |
* Copyright (C) 2014 Red Hat |
* Copyright (C) 2014 Intel Corp. |
* |
* 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. |
* |
* Authors: |
* Rob Clark <robdclark@gmail.com> |
* Daniel Vetter <daniel.vetter@ffwll.ch> |
*/ |
#ifndef DRM_ATOMIC_H_ |
#define DRM_ATOMIC_H_ |
#include <drm/drm_crtc.h> |
struct drm_atomic_state * __must_check |
drm_atomic_state_alloc(struct drm_device *dev); |
void drm_atomic_state_clear(struct drm_atomic_state *state); |
void drm_atomic_state_free(struct drm_atomic_state *state); |
struct drm_crtc_state * __must_check |
drm_atomic_get_crtc_state(struct drm_atomic_state *state, |
struct drm_crtc *crtc); |
struct drm_plane_state * __must_check |
drm_atomic_get_plane_state(struct drm_atomic_state *state, |
struct drm_plane *plane); |
struct drm_connector_state * __must_check |
drm_atomic_get_connector_state(struct drm_atomic_state *state, |
struct drm_connector *connector); |
int __must_check |
drm_atomic_set_crtc_for_plane(struct drm_atomic_state *state, |
struct drm_plane *plane, struct drm_crtc *crtc); |
void drm_atomic_set_fb_for_plane(struct drm_plane_state *plane_state, |
struct drm_framebuffer *fb); |
int __must_check |
drm_atomic_set_crtc_for_connector(struct drm_connector_state *conn_state, |
struct drm_crtc *crtc); |
int __must_check |
drm_atomic_add_affected_connectors(struct drm_atomic_state *state, |
struct drm_crtc *crtc); |
int |
drm_atomic_connectors_for_crtc(struct drm_atomic_state *state, |
struct drm_crtc *crtc); |
void drm_atomic_legacy_backoff(struct drm_atomic_state *state); |
int __must_check drm_atomic_check_only(struct drm_atomic_state *state); |
int __must_check drm_atomic_commit(struct drm_atomic_state *state); |
int __must_check drm_atomic_async_commit(struct drm_atomic_state *state); |
#endif /* DRM_ATOMIC_H_ */ |
/drivers/include/drm/drm_atomic_helper.h |
---|
0,0 → 1,126 |
/* |
* Copyright (C) 2014 Red Hat |
* Copyright (C) 2014 Intel Corp. |
* |
* 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. |
* |
* Authors: |
* Rob Clark <robdclark@gmail.com> |
* Daniel Vetter <daniel.vetter@ffwll.ch> |
*/ |
#ifndef DRM_ATOMIC_HELPER_H_ |
#define DRM_ATOMIC_HELPER_H_ |
#include <drm/drm_crtc.h> |
int drm_atomic_helper_check(struct drm_device *dev, |
struct drm_atomic_state *state); |
int drm_atomic_helper_commit(struct drm_device *dev, |
struct drm_atomic_state *state, |
bool async); |
void drm_atomic_helper_wait_for_vblanks(struct drm_device *dev, |
struct drm_atomic_state *old_state); |
void drm_atomic_helper_commit_pre_planes(struct drm_device *dev, |
struct drm_atomic_state *state); |
void drm_atomic_helper_commit_post_planes(struct drm_device *dev, |
struct drm_atomic_state *old_state); |
int drm_atomic_helper_prepare_planes(struct drm_device *dev, |
struct drm_atomic_state *state); |
void drm_atomic_helper_commit_planes(struct drm_device *dev, |
struct drm_atomic_state *state); |
void drm_atomic_helper_cleanup_planes(struct drm_device *dev, |
struct drm_atomic_state *old_state); |
void drm_atomic_helper_swap_state(struct drm_device *dev, |
struct drm_atomic_state *state); |
/* implementations for legacy interfaces */ |
int drm_atomic_helper_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 drm_atomic_helper_disable_plane(struct drm_plane *plane); |
int drm_atomic_helper_set_config(struct drm_mode_set *set); |
int drm_atomic_helper_crtc_set_property(struct drm_crtc *crtc, |
struct drm_property *property, |
uint64_t val); |
int drm_atomic_helper_plane_set_property(struct drm_plane *plane, |
struct drm_property *property, |
uint64_t val); |
int drm_atomic_helper_connector_set_property(struct drm_connector *connector, |
struct drm_property *property, |
uint64_t val); |
int drm_atomic_helper_page_flip(struct drm_crtc *crtc, |
struct drm_framebuffer *fb, |
struct drm_pending_vblank_event *event, |
uint32_t flags); |
/* default implementations for state handling */ |
void drm_atomic_helper_crtc_reset(struct drm_crtc *crtc); |
struct drm_crtc_state * |
drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc); |
void drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc, |
struct drm_crtc_state *state); |
void drm_atomic_helper_plane_reset(struct drm_plane *plane); |
struct drm_plane_state * |
drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane); |
void drm_atomic_helper_plane_destroy_state(struct drm_plane *plane, |
struct drm_plane_state *state); |
void drm_atomic_helper_connector_reset(struct drm_connector *connector); |
struct drm_connector_state * |
drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector); |
void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector, |
struct drm_connector_state *state); |
/** |
* drm_atomic_crtc_for_each_plane - iterate over planes currently attached to CRTC |
* @plane: the loop cursor |
* @crtc: the crtc whose planes are iterated |
* |
* This iterates over the current state, useful (for example) when applying |
* atomic state after it has been checked and swapped. To iterate over the |
* planes which *will* be attached (for ->atomic_check()) see |
* drm_crtc_for_each_pending_plane() |
*/ |
#define drm_atomic_crtc_for_each_plane(plane, crtc) \ |
drm_for_each_plane_mask(plane, (crtc)->dev, (crtc)->state->plane_mask) |
/** |
* drm_crtc_atomic_state_for_each_plane - iterate over attached planes in new state |
* @plane: the loop cursor |
* @crtc_state: the incoming crtc-state |
* |
* Similar to drm_crtc_for_each_plane(), but iterates the planes that will be |
* attached if the specified state is applied. Useful during (for example) |
* ->atomic_check() operations, to validate the incoming state |
*/ |
#define drm_atomic_crtc_state_for_each_plane(plane, crtc_state) \ |
drm_for_each_plane_mask(plane, (crtc_state)->state->dev, (crtc_state)->plane_mask) |
#endif /* DRM_ATOMIC_HELPER_H_ */ |
/drivers/include/drm/drm_cache.h |
---|
0,0 → 1,38 |
/************************************************************************** |
* |
* Copyright 2009 Red Hat 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. |
* |
* |
**************************************************************************/ |
/* |
* Authors: |
* Dave Airlie <airlied@redhat.com> |
*/ |
#ifndef _DRM_CACHE_H_ |
#define _DRM_CACHE_H_ |
void drm_clflush_pages(struct page *pages[], unsigned long num_pages); |
#endif |
/drivers/include/drm/drm_crtc.h |
---|
31,8 → 31,8 |
#include <linux/idr.h> |
#include <linux/fb.h> |
#include <linux/hdmi.h> |
#include <drm/drm_mode.h> |
#include <drm/drm_fourcc.h> |
#include <uapi/drm/drm_mode.h> |
#include <uapi/drm/drm_fourcc.h> |
#include <drm/drm_modeset_lock.h> |
struct drm_device; |
42,6 → 42,7 |
struct drm_file; |
struct drm_clip_rect; |
struct device_node; |
struct fence; |
#define DRM_MODE_OBJECT_CRTC 0xcccccccc |
#define DRM_MODE_OBJECT_CONNECTOR 0xc0c0c0c0 |
136,6 → 137,14 |
u8 cea_rev; |
}; |
/* data corresponds to displayid vend/prod/serial */ |
struct drm_tile_group { |
struct kref refcount; |
struct drm_device *dev; |
int id; |
u8 group_data[8]; |
}; |
struct drm_framebuffer_funcs { |
/* note: use drm_framebuffer_remove() */ |
void (*destroy)(struct drm_framebuffer *framebuffer); |
142,8 → 151,8 |
int (*create_handle)(struct drm_framebuffer *fb, |
struct drm_file *file_priv, |
unsigned int *handle); |
/** |
* Optinal callback for the dirty fb ioctl. |
/* |
* Optional callback for the dirty fb ioctl. |
* |
* Userspace can notify the driver via this callback |
* that a area of the framebuffer has changed and should |
196,7 → 205,7 |
struct drm_property_blob { |
struct drm_mode_object base; |
struct list_head head; |
unsigned int length; |
size_t length; |
unsigned char data[]; |
}; |
215,13 → 224,9 |
uint64_t *values; |
struct drm_device *dev; |
struct list_head enum_blob_list; |
struct list_head enum_list; |
}; |
void drm_modeset_lock_all(struct drm_device *dev); |
void drm_modeset_unlock_all(struct drm_device *dev); |
void drm_warn_on_modeset_not_all_locked(struct drm_device *dev); |
struct drm_crtc; |
struct drm_connector; |
struct drm_encoder; |
228,13 → 233,56 |
struct drm_pending_vblank_event; |
struct drm_plane; |
struct drm_bridge; |
struct drm_atomic_state; |
/** |
* drm_crtc_funcs - control CRTCs for a given device |
* struct drm_crtc_state - mutable CRTC state |
* @enable: whether the CRTC should be enabled, gates all other state |
* @mode_changed: for use by helpers and drivers when computing state updates |
* @plane_mask: bitmask of (1 << drm_plane_index(plane)) of attached planes |
* @last_vblank_count: for helpers and drivers to capture the vblank of the |
* update to ensure framebuffer cleanup isn't done too early |
* @planes_changed: for use by helpers and drivers when computing state updates |
* @adjusted_mode: for use by helpers and drivers to compute adjusted mode timings |
* @mode: current mode timings |
* @event: optional pointer to a DRM event to signal upon completion of the |
* state update |
* @state: backpointer to global drm_atomic_state |
*/ |
struct drm_crtc_state { |
bool enable; |
/* computed state bits used by helpers and drivers */ |
bool planes_changed : 1; |
bool mode_changed : 1; |
/* attached planes bitmask: |
* WARNING: transitional helpers do not maintain plane_mask so |
* drivers not converted over to atomic helpers should not rely |
* on plane_mask being accurate! |
*/ |
u32 plane_mask; |
/* last_vblank_count: for vblank waits before cleanup */ |
u32 last_vblank_count; |
/* adjusted_mode: for use by helpers and drivers */ |
struct drm_display_mode adjusted_mode; |
struct drm_display_mode mode; |
struct drm_pending_vblank_event *event; |
struct drm_atomic_state *state; |
}; |
/** |
* struct drm_crtc_funcs - control CRTCs for a given device |
* @save: save CRTC state |
* @restore: restore CRTC state |
* @reset: reset CRTC after state has been invalidated (e.g. resume) |
* @cursor_set: setup the cursor |
* @cursor_set2: setup the cursor with hotspot, superseeds @cursor_set if set |
* @cursor_move: move the cursor |
* @gamma_set: specify color ramp for CRTC |
* @destroy: deinit and free object |
241,6 → 289,9 |
* @set_property: called when a property is changed |
* @set_config: apply a new CRTC configuration |
* @page_flip: initiate a page flip |
* @atomic_duplicate_state: duplicate the atomic state for this CRTC |
* @atomic_destroy_state: destroy an atomic state for this CRTC |
* @atomic_set_property: set a property on an atomic state for this CRTC |
* |
* The drm_crtc_funcs structure is the central CRTC management structure |
* in the DRM. Each CRTC controls one or more connectors (note that the name |
291,16 → 342,28 |
int (*set_property)(struct drm_crtc *crtc, |
struct drm_property *property, uint64_t val); |
/* atomic update handling */ |
struct drm_crtc_state *(*atomic_duplicate_state)(struct drm_crtc *crtc); |
void (*atomic_destroy_state)(struct drm_crtc *crtc, |
struct drm_crtc_state *state); |
int (*atomic_set_property)(struct drm_crtc *crtc, |
struct drm_crtc_state *state, |
struct drm_property *property, |
uint64_t val); |
}; |
/** |
* drm_crtc - central CRTC control structure |
* struct drm_crtc - central CRTC control structure |
* @dev: parent DRM device |
* @port: OF node used by drm_of_find_possible_crtcs() |
* @head: list management |
* @mutex: per-CRTC locking |
* @base: base KMS object for ID tracking etc. |
* @primary: primary plane for this CRTC |
* @cursor: cursor plane for this CRTC |
* @cursor_x: current x position of the cursor, used for universal cursor planes |
* @cursor_y: current y position of the cursor, used for universal cursor planes |
* @enabled: is this CRTC enabled? |
* @mode: current mode timings |
* @hwmode: mode timings as programmed to hw regs |
313,10 → 376,13 |
* @gamma_size: size of gamma ramp |
* @gamma_store: gamma ramp values |
* @framedur_ns: precise frame timing |
* @framedur_ns: precise line timing |
* @linedur_ns: precise line timing |
* @pixeldur_ns: precise pixel timing |
* @helper_private: mid-layer private data |
* @properties: property tracking for this CRTC |
* @state: current atomic state for this CRTC |
* @acquire_ctx: per-CRTC implicit acquire context used by atomic drivers for |
* legacy ioctls |
* |
* Each CRTC may have one or more connectors associated with it. This structure |
* allows the CRTC to be controlled. |
326,7 → 392,7 |
struct device_node *port; |
struct list_head head; |
/** |
/* |
* crtc mutex |
* |
* This provides a read lock for the overall crtc state (mode, dpms |
345,10 → 411,6 |
int cursor_x; |
int cursor_y; |
/* Temporary tracking of the old fb while a modeset is ongoing. Used |
* by drm_mode_set_config_internal to implement correct refcounting. */ |
struct drm_framebuffer *old_fb; |
bool enabled; |
/* Requested mode from modesetting. */ |
375,11 → 437,32 |
void *helper_private; |
struct drm_object_properties properties; |
struct drm_crtc_state *state; |
/* |
* For legacy crtc ioctls so that atomic drivers can get at the locking |
* acquire context. |
*/ |
struct drm_modeset_acquire_ctx *acquire_ctx; |
}; |
/** |
* struct drm_connector_state - mutable connector state |
* @crtc: CRTC to connect connector to, NULL if disabled |
* @best_encoder: can be used by helpers and drivers to select the encoder |
* @state: backpointer to global drm_atomic_state |
*/ |
struct drm_connector_state { |
struct drm_crtc *crtc; /* do not write directly, use drm_atomic_set_crtc_for_connector() */ |
struct drm_encoder *best_encoder; |
struct drm_atomic_state *state; |
}; |
/** |
* drm_connector_funcs - control connectors on a given device |
* struct drm_connector_funcs - control connectors on a given device |
* @dpms: set power state (see drm_crtc_funcs above) |
* @save: save connector state |
* @restore: restore connector state |
389,6 → 472,9 |
* @set_property: property for this connector may need an update |
* @destroy: make object go away |
* @force: notify the driver that the connector is forced on |
* @atomic_duplicate_state: duplicate the atomic state for this connector |
* @atomic_destroy_state: destroy an atomic state for this connector |
* @atomic_set_property: set a property on an atomic state for this connector |
* |
* Each CRTC may have one or more connectors attached to it. The functions |
* below allow the core DRM code to control connectors, enumerate available modes, |
413,10 → 499,19 |
uint64_t val); |
void (*destroy)(struct drm_connector *connector); |
void (*force)(struct drm_connector *connector); |
/* atomic update handling */ |
struct drm_connector_state *(*atomic_duplicate_state)(struct drm_connector *connector); |
void (*atomic_destroy_state)(struct drm_connector *connector, |
struct drm_connector_state *state); |
int (*atomic_set_property)(struct drm_connector *connector, |
struct drm_connector_state *state, |
struct drm_property *property, |
uint64_t val); |
}; |
/** |
* drm_encoder_funcs - encoder controls |
* struct drm_encoder_funcs - encoder controls |
* @reset: reset state (e.g. at init or resume time) |
* @destroy: cleanup and free associated data |
* |
430,7 → 525,7 |
#define DRM_CONNECTOR_MAX_ENCODER 3 |
/** |
* drm_encoder - central DRM encoder structure |
* struct drm_encoder - central DRM encoder structure |
* @dev: parent DRM device |
* @head: list management |
* @base: base KMS object |
474,7 → 569,7 |
#define MAX_ELD_BYTES 128 |
/** |
* drm_connector - central DRM connector control structure |
* struct drm_connector - central DRM connector control structure |
* @dev: parent DRM device |
* @kdev: kernel device for sysfs attributes |
* @attr: sysfs attributes |
485,6 → 580,7 |
* @connector_type_id: index into connector type enum |
* @interlace_allowed: can this connector handle interlaced modes? |
* @doublescan_allowed: can this connector handle doublescan? |
* @stereo_allowed: can this connector handle stereo modes? |
* @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 |
492,10 → 588,13 |
* @funcs: connector control functions |
* @edid_blob_ptr: DRM property containing EDID if present |
* @properties: property tracking for this connector |
* @path_blob_ptr: DRM blob property data for the DP MST path property |
* @polled: a %DRM_CONNECTOR_POLL_<foo> value for core driven polling |
* @dpms: current dpms state |
* @helper_private: mid-layer private data |
* @cmdline_mode: mode line parsed from the kernel cmdline for this connector |
* @force: a %DRM_FORCE_<foo> state for forced mode sets |
* @override_edid: has the EDID been overwritten through debugfs for testing? |
* @encoder_ids: valid encoders for this connector |
* @encoder: encoder driving this connector, if any |
* @eld: EDID-like data, if present |
505,6 → 604,18 |
* @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 |
* @bad_edid_counter: track sinks that give us an EDID with invalid checksum |
* @debugfs_entry: debugfs directory for this connector |
* @state: current atomic state for this connector |
* @has_tile: is this connector connected to a tiled monitor |
* @tile_group: tile group for the connected monitor |
* @tile_is_single_monitor: whether the tile is one monitor housing |
* @num_h_tile: number of horizontal tiles in the tile group |
* @num_v_tile: number of vertical tiles in the tile group |
* @tile_h_loc: horizontal location of this tile |
* @tile_v_loc: vertical location of this tile |
* @tile_h_size: horizontal size of this tile. |
* @tile_v_size: vertical size of this tile. |
* |
* 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 |
540,6 → 651,8 |
struct drm_property_blob *path_blob_ptr; |
struct drm_property_blob *tile_blob_ptr; |
uint8_t polled; /* DRM_CONNECTOR_POLL_* */ |
/* requested DPMS state */ |
548,6 → 661,7 |
void *helper_private; |
/* forced on connector */ |
struct drm_cmdline_mode cmdline_mode; |
enum drm_connector_force force; |
bool override_edid; |
uint32_t encoder_ids[DRM_CONNECTOR_MAX_ENCODER]; |
564,14 → 678,63 |
unsigned bad_edid_counter; |
struct dentry *debugfs_entry; |
struct drm_connector_state *state; |
/* DisplayID bits */ |
bool has_tile; |
struct drm_tile_group *tile_group; |
bool tile_is_single_monitor; |
uint8_t num_h_tile, num_v_tile; |
uint8_t tile_h_loc, tile_v_loc; |
uint16_t tile_h_size, tile_v_size; |
}; |
/** |
* drm_plane_funcs - driver plane control functions |
* struct drm_plane_state - mutable plane state |
* @crtc: currently bound CRTC, NULL if disabled |
* @fb: currently bound framebuffer |
* @fence: optional fence to wait for before scanning out @fb |
* @crtc_x: left position of visible portion of plane on crtc |
* @crtc_y: upper position of visible portion of plane on crtc |
* @crtc_w: width of visible portion of plane on crtc |
* @crtc_h: height of visible portion of plane on crtc |
* @src_x: left position of visible portion of plane within |
* plane (in 16.16) |
* @src_y: upper position of visible portion of plane within |
* plane (in 16.16) |
* @src_w: width of visible portion of plane (in 16.16) |
* @src_h: height of visible portion of plane (in 16.16) |
* @state: backpointer to global drm_atomic_state |
*/ |
struct drm_plane_state { |
struct drm_crtc *crtc; /* do not write directly, use drm_atomic_set_crtc_for_plane() */ |
struct drm_framebuffer *fb; /* do not write directly, use drm_atomic_set_fb_for_plane() */ |
struct fence *fence; |
/* Signed dest location allows it to be partially off screen */ |
int32_t crtc_x, crtc_y; |
uint32_t crtc_w, crtc_h; |
/* Source values are 16.16 fixed point */ |
uint32_t src_x, src_y; |
uint32_t src_h, src_w; |
struct drm_atomic_state *state; |
}; |
/** |
* struct drm_plane_funcs - driver plane control functions |
* @update_plane: update the plane configuration |
* @disable_plane: shut down the plane |
* @destroy: clean up plane resources |
* @reset: reset plane after state has been invalidated (e.g. resume) |
* @set_property: called when a property is changed |
* @atomic_duplicate_state: duplicate the atomic state for this plane |
* @atomic_destroy_state: destroy an atomic state for this plane |
* @atomic_set_property: set a property on an atomic state for this plane |
*/ |
struct drm_plane_funcs { |
int (*update_plane)(struct drm_plane *plane, |
582,9 → 745,19 |
uint32_t src_w, uint32_t src_h); |
int (*disable_plane)(struct drm_plane *plane); |
void (*destroy)(struct drm_plane *plane); |
void (*reset)(struct drm_plane *plane); |
int (*set_property)(struct drm_plane *plane, |
struct drm_property *property, uint64_t val); |
/* atomic update handling */ |
struct drm_plane_state *(*atomic_duplicate_state)(struct drm_plane *plane); |
void (*atomic_destroy_state)(struct drm_plane *plane, |
struct drm_plane_state *state); |
int (*atomic_set_property)(struct drm_plane *plane, |
struct drm_plane_state *state, |
struct drm_property *property, |
uint64_t val); |
}; |
enum drm_plane_type { |
594,7 → 767,7 |
}; |
/** |
* drm_plane - central DRM plane control structure |
* struct drm_plane - central DRM plane control structure |
* @dev: DRM device this plane belongs to |
* @head: for list management |
* @base: base mode object |
603,14 → 776,19 |
* @format_count: number of formats supported |
* @crtc: currently bound CRTC |
* @fb: currently bound fb |
* @old_fb: Temporary tracking of the old fb while a modeset is ongoing. Used by |
* drm_mode_set_config_internal() to implement correct refcounting. |
* @funcs: helper functions |
* @properties: property tracking for this plane |
* @type: type of plane (overlay, primary, cursor) |
* @state: current atomic state for this plane |
*/ |
struct drm_plane { |
struct drm_device *dev; |
struct list_head head; |
struct drm_modeset_lock mutex; |
struct drm_mode_object base; |
uint32_t possible_crtcs; |
620,15 → 798,21 |
struct drm_crtc *crtc; |
struct drm_framebuffer *fb; |
struct drm_framebuffer *old_fb; |
const struct drm_plane_funcs *funcs; |
struct drm_object_properties properties; |
enum drm_plane_type type; |
void *helper_private; |
struct drm_plane_state *state; |
}; |
/** |
* drm_bridge_funcs - drm_bridge control functions |
* struct 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 |
652,7 → 836,7 |
}; |
/** |
* drm_bridge - central DRM bridge control structure |
* struct drm_bridge - central DRM bridge control structure |
* @dev: DRM device this bridge belongs to |
* @head: list management |
* @base: base mode object |
670,8 → 854,35 |
}; |
/** |
* drm_mode_set - new values for a CRTC config change |
* @head: list management |
* struct struct drm_atomic_state - the global state object for atomic updates |
* @dev: parent DRM device |
* @flags: state flags like async update |
* @planes: pointer to array of plane pointers |
* @plane_states: pointer to array of plane states pointers |
* @crtcs: pointer to array of CRTC pointers |
* @crtc_states: pointer to array of CRTC states pointers |
* @num_connector: size of the @connectors and @connector_states arrays |
* @connectors: pointer to array of connector pointers |
* @connector_states: pointer to array of connector states pointers |
* @acquire_ctx: acquire context for this atomic modeset state update |
*/ |
struct drm_atomic_state { |
struct drm_device *dev; |
uint32_t flags; |
struct drm_plane **planes; |
struct drm_plane_state **plane_states; |
struct drm_crtc **crtcs; |
struct drm_crtc_state **crtc_states; |
int num_connector; |
struct drm_connector **connectors; |
struct drm_connector_state **connector_states; |
struct drm_modeset_acquire_ctx *acquire_ctx; |
}; |
/** |
* struct drm_mode_set - new values for a CRTC config change |
* @fb: framebuffer to use for new config |
* @crtc: CRTC whose configuration we're about to change |
* @mode: mode timings to use |
701,6 → 912,9 |
* 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 |
* @atomic_check: check whether a give atomic state update is possible |
* @atomic_commit: commit an atomic state update previously verified with |
* atomic_check() |
* |
* Some global (i.e. not per-CRTC, connector, etc) mode setting functions that |
* involve drivers. |
710,13 → 924,20 |
struct drm_file *file_priv, |
struct drm_mode_fb_cmd2 *mode_cmd); |
void (*output_poll_changed)(struct drm_device *dev); |
int (*atomic_check)(struct drm_device *dev, |
struct drm_atomic_state *a); |
int (*atomic_commit)(struct drm_device *dev, |
struct drm_atomic_state *a, |
bool async); |
}; |
/** |
* drm_mode_group - group of mode setting resources for potential sub-grouping |
* struct drm_mode_group - group of mode setting resources for potential sub-grouping |
* @num_crtcs: CRTC count |
* @num_encoders: encoder count |
* @num_connectors: connector count |
* @num_bridges: bridge count |
* @id_list: list of KMS object IDs in this group |
* |
* Currently this simply tracks the global mode setting state. But in the |
736,10 → 957,14 |
}; |
/** |
* drm_mode_config - Mode configuration control structure |
* struct drm_mode_config - Mode configuration control structure |
* @mutex: mutex protecting KMS related lists and structures |
* @connection_mutex: ww mutex protecting connector state and routing |
* @acquire_ctx: global implicit acquire context used by atomic drivers for |
* legacy ioctls |
* @idr_mutex: mutex for KMS ID allocation and management |
* @crtc_idr: main KMS ID tracking object |
* @fb_lock: mutex to protect fb state and lists |
* @num_fb: number of fbs available |
* @fb_list: list of framebuffers available |
* @num_connector: number of connectors on this device |
748,8 → 973,12 |
* @bridge_list: list of bridge objects |
* @num_encoder: number of encoders on this device |
* @encoder_list: list of encoder objects |
* @num_overlay_plane: number of overlay planes on this device |
* @num_total_plane: number of universal (i.e. with primary/curso) planes on this device |
* @plane_list: list of plane objects |
* @num_crtc: number of CRTCs on this device |
* @crtc_list: list of CRTC objects |
* @property_list: list of property 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 |
756,9 → 985,16 |
* @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 |
* @poll_enabled: track polling support for this device |
* @poll_running: track polling status for this device |
* @output_poll_work: delayed work for polling in process context |
* @property_blob_list: list of all the blob property objects |
* @*_property: core property tracking |
* @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? |
* @cursor_width: hint to userspace for max cursor width |
* @cursor_height: hint to userspace for max cursor height |
* |
* Core mode resource tracking structure. All CRTC, encoders, and connectors |
* enumerated by the driver are added here, as are global properties. Some |
770,16 → 1006,10 |
struct drm_modeset_acquire_ctx *acquire_ctx; /* for legacy _lock_all() / _unlock_all() */ |
struct mutex idr_mutex; /* for IDR management */ |
struct idr crtc_idr; /* use this idr for all IDs, fb, crtc, connector, modes - just makes life easier */ |
struct idr tile_idr; /* use this idr for all IDs, fb, crtc, connector, modes - just makes life easier */ |
/* this is limited to one for now */ |
/** |
* fb_lock - mutex to protect fb state |
* |
* Besides the global fb list his also protects the fbs list in the |
* file_priv |
*/ |
struct mutex fb_lock; |
struct mutex fb_lock; /* proctects global and per-file fb lists */ |
int num_fb; |
struct list_head fb_list; |
820,7 → 1050,9 |
struct drm_property *edid_property; |
struct drm_property *dpms_property; |
struct drm_property *path_property; |
struct drm_property *tile_property; |
struct drm_property *plane_type_property; |
struct drm_property *rotation_property; |
/* DVI-I properties */ |
struct drm_property *dvi_i_subconnector_property; |
846,6 → 1078,10 |
struct drm_property *aspect_ratio_property; |
struct drm_property *dirty_info_property; |
/* properties for virtual machine layout */ |
struct drm_property *suggested_x_property; |
struct drm_property *suggested_y_property; |
/* dumb ioctl parameters */ |
uint32_t preferred_depth, prefer_shadow; |
856,6 → 1092,19 |
uint32_t cursor_width, cursor_height; |
}; |
/** |
* drm_for_each_plane_mask - iterate over planes specified by bitmask |
* @plane: the loop cursor |
* @dev: the DRM device |
* @plane_mask: bitmask of plane indices |
* |
* Iterate over all planes specified by bitmask. |
*/ |
#define drm_for_each_plane_mask(plane, dev, plane_mask) \ |
list_for_each_entry((plane), &(dev)->mode_config.plane_list, head) \ |
if ((plane_mask) & (1 << drm_plane_index(plane))) |
#define obj_to_crtc(x) container_of(x, struct drm_crtc, base) |
#define obj_to_connector(x) container_of(x, struct drm_connector, base) |
#define obj_to_encoder(x) container_of(x, struct drm_encoder, base) |
875,9 → 1124,6 |
struct drm_plane *primary, |
struct drm_plane *cursor, |
const struct drm_crtc_funcs *funcs); |
extern int drm_crtc_init(struct drm_device *dev, |
struct drm_crtc *crtc, |
const struct drm_crtc_funcs *funcs); |
extern void drm_crtc_cleanup(struct drm_crtc *crtc); |
extern unsigned int drm_crtc_index(struct drm_crtc *crtc); |
903,6 → 1149,7 |
void drm_connector_unregister(struct drm_connector *connector); |
extern void drm_connector_cleanup(struct drm_connector *connector); |
extern unsigned int drm_connector_index(struct drm_connector *connector); |
/* helper to unplug all connectors from sysfs for device */ |
extern void drm_connector_unplug_all(struct drm_device *dev); |
942,6 → 1189,7 |
const uint32_t *formats, uint32_t format_count, |
bool is_primary); |
extern void drm_plane_cleanup(struct drm_plane *plane); |
extern unsigned int drm_plane_index(struct drm_plane *plane); |
extern void drm_plane_force_disable(struct drm_plane *plane); |
extern int drm_crtc_check_viewport(const struct drm_crtc *crtc, |
int x, int y, |
971,9 → 1219,10 |
extern void drm_mode_config_cleanup(struct drm_device *dev); |
extern int drm_mode_connector_set_path_property(struct drm_connector *connector, |
char *path); |
const char *path); |
int drm_mode_connector_set_tile_property(struct drm_connector *connector); |
extern int drm_mode_connector_update_edid_property(struct drm_connector *connector, |
struct edid *edid); |
const struct edid *edid); |
static inline bool drm_property_type_is(struct drm_property *property, |
uint32_t type) |
1034,11 → 1283,13 |
extern int drm_property_add_enum(struct drm_property *property, int index, |
uint64_t value, const char *name); |
extern int drm_mode_create_dvi_i_properties(struct drm_device *dev); |
extern int drm_mode_create_tv_properties(struct drm_device *dev, int num_formats, |
char *formats[]); |
extern int drm_mode_create_tv_properties(struct drm_device *dev, |
unsigned int num_modes, |
char *modes[]); |
extern int drm_mode_create_scaling_mode_property(struct drm_device *dev); |
extern int drm_mode_create_aspect_ratio_property(struct drm_device *dev); |
extern int drm_mode_create_dirty_info_property(struct drm_device *dev); |
extern int drm_mode_create_suggested_offset_properties(struct drm_device *dev); |
extern int drm_mode_connector_attach_encoder(struct drm_connector *connector, |
struct drm_encoder *encoder); |
1106,6 → 1357,13 |
extern int drm_edid_header_is_valid(const u8 *raw_edid); |
extern bool drm_edid_block_valid(u8 *raw_edid, int block, bool print_bad_edid); |
extern bool drm_edid_is_valid(struct edid *edid); |
extern struct drm_tile_group *drm_mode_create_tile_group(struct drm_device *dev, |
char topology[8]); |
extern struct drm_tile_group *drm_mode_get_tile_group(struct drm_device *dev, |
char topology[8]); |
extern void drm_mode_put_tile_group(struct drm_device *dev, |
struct drm_tile_group *tg); |
struct drm_display_mode *drm_mode_find_dmt(struct drm_device *dev, |
int hsize, int vsize, int fresh, |
bool rb); |
1120,6 → 1378,9 |
struct drm_file *file_priv); |
extern int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_mode_plane_set_obj_prop(struct drm_plane *plane, |
struct drm_property *property, |
uint64_t value); |
extern void drm_fb_get_bpp_depth(uint32_t format, unsigned int *depth, |
int *bpp); |
/drivers/include/drm/drm_crtc_helper.h |
---|
68,6 → 68,7 |
int (*mode_set)(struct drm_crtc *crtc, struct drm_display_mode *mode, |
struct drm_display_mode *adjusted_mode, int x, int y, |
struct drm_framebuffer *old_fb); |
void (*mode_set_nofb)(struct drm_crtc *crtc); |
/* Move the crtc on the current fb to the given position *optional* */ |
int (*mode_set_base)(struct drm_crtc *crtc, int x, int y, |
81,6 → 82,12 |
/* disable crtc when not in use - more explicit than dpms off */ |
void (*disable)(struct drm_crtc *crtc); |
/* atomic helpers */ |
int (*atomic_check)(struct drm_crtc *crtc, |
struct drm_crtc_state *state); |
void (*atomic_begin)(struct drm_crtc *crtc); |
void (*atomic_flush)(struct drm_crtc *crtc); |
}; |
/** |
161,6 → 168,12 |
extern void drm_helper_resume_force_mode(struct drm_device *dev); |
int drm_helper_crtc_mode_set(struct drm_crtc *crtc, struct drm_display_mode *mode, |
struct drm_display_mode *adjusted_mode, int x, int y, |
struct drm_framebuffer *old_fb); |
int drm_helper_crtc_mode_set_base(struct drm_crtc *crtc, int x, int y, |
struct drm_framebuffer *old_fb); |
/* drm_probe_helper.c */ |
extern int drm_helper_probe_single_connector_modes(struct drm_connector |
*connector, uint32_t maxX, |
/drivers/include/drm/drm_displayid.h |
---|
0,0 → 1,76 |
/* |
* Copyright © 2014 Red Hat Inc. |
* |
* 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_DISPLAYID_H |
#define DRM_DISPLAYID_H |
#define DATA_BLOCK_PRODUCT_ID 0x00 |
#define DATA_BLOCK_DISPLAY_PARAMETERS 0x01 |
#define DATA_BLOCK_COLOR_CHARACTERISTICS 0x02 |
#define DATA_BLOCK_TYPE_1_DETAILED_TIMING 0x03 |
#define DATA_BLOCK_TYPE_2_DETAILED_TIMING 0x04 |
#define DATA_BLOCK_TYPE_3_SHORT_TIMING 0x05 |
#define DATA_BLOCK_TYPE_4_DMT_TIMING 0x06 |
#define DATA_BLOCK_VESA_TIMING 0x07 |
#define DATA_BLOCK_CEA_TIMING 0x08 |
#define DATA_BLOCK_VIDEO_TIMING_RANGE 0x09 |
#define DATA_BLOCK_PRODUCT_SERIAL_NUMBER 0x0a |
#define DATA_BLOCK_GP_ASCII_STRING 0x0b |
#define DATA_BLOCK_DISPLAY_DEVICE_DATA 0x0c |
#define DATA_BLOCK_INTERFACE_POWER_SEQUENCING 0x0d |
#define DATA_BLOCK_TRANSFER_CHARACTERISTICS 0x0e |
#define DATA_BLOCK_DISPLAY_INTERFACE 0x0f |
#define DATA_BLOCK_STEREO_DISPLAY_INTERFACE 0x10 |
#define DATA_BLOCK_TILED_DISPLAY 0x12 |
#define DATA_BLOCK_VENDOR_SPECIFIC 0x7f |
#define PRODUCT_TYPE_EXTENSION 0 |
#define PRODUCT_TYPE_TEST 1 |
#define PRODUCT_TYPE_PANEL 2 |
#define PRODUCT_TYPE_MONITOR 3 |
#define PRODUCT_TYPE_TV 4 |
#define PRODUCT_TYPE_REPEATER 5 |
#define PRODUCT_TYPE_DIRECT_DRIVE 6 |
struct displayid_hdr { |
u8 rev; |
u8 bytes; |
u8 prod_id; |
u8 ext_count; |
} __packed; |
struct displayid_block { |
u8 tag; |
u8 rev; |
u8 num_bytes; |
} __packed; |
struct displayid_tiled_block { |
struct displayid_block base; |
u8 tile_cap; |
u8 topo[3]; |
u8 tile_size[4]; |
u8 tile_pixel_bezel[5]; |
u8 topology_id[8]; |
} __packed; |
#endif |
/drivers/include/drm/drm_dp_helper.h |
---|
190,16 → 190,16 |
# define DP_TRAIN_VOLTAGE_SWING_MASK 0x3 |
# define DP_TRAIN_VOLTAGE_SWING_SHIFT 0 |
# define DP_TRAIN_MAX_SWING_REACHED (1 << 2) |
# define DP_TRAIN_VOLTAGE_SWING_400 (0 << 0) |
# define DP_TRAIN_VOLTAGE_SWING_600 (1 << 0) |
# define DP_TRAIN_VOLTAGE_SWING_800 (2 << 0) |
# define DP_TRAIN_VOLTAGE_SWING_1200 (3 << 0) |
# define DP_TRAIN_VOLTAGE_SWING_LEVEL_0 (0 << 0) |
# define DP_TRAIN_VOLTAGE_SWING_LEVEL_1 (1 << 0) |
# define DP_TRAIN_VOLTAGE_SWING_LEVEL_2 (2 << 0) |
# define DP_TRAIN_VOLTAGE_SWING_LEVEL_3 (3 << 0) |
# define DP_TRAIN_PRE_EMPHASIS_MASK (3 << 3) |
# define DP_TRAIN_PRE_EMPHASIS_0 (0 << 3) |
# define DP_TRAIN_PRE_EMPHASIS_3_5 (1 << 3) |
# define DP_TRAIN_PRE_EMPHASIS_6 (2 << 3) |
# define DP_TRAIN_PRE_EMPHASIS_9_5 (3 << 3) |
# define DP_TRAIN_PRE_EMPH_LEVEL_0 (0 << 3) |
# define DP_TRAIN_PRE_EMPH_LEVEL_1 (1 << 3) |
# define DP_TRAIN_PRE_EMPH_LEVEL_2 (2 << 3) |
# define DP_TRAIN_PRE_EMPH_LEVEL_3 (3 << 3) |
# define DP_TRAIN_PRE_EMPHASIS_SHIFT 3 |
# define DP_TRAIN_MAX_PRE_EMPHASIS_REACHED (1 << 5) |
304,6 → 304,7 |
#define DP_TEST_SINK_MISC 0x246 |
#define DP_TEST_CRC_SUPPORTED (1 << 5) |
# define DP_TEST_COUNT_MASK 0x7 |
#define DP_TEST_RESPONSE 0x260 |
# define DP_TEST_ACK (1 << 0) |
404,26 → 405,6 |
#define MODE_I2C_READ 4 |
#define MODE_I2C_STOP 8 |
/** |
* struct i2c_algo_dp_aux_data - driver interface structure for i2c over dp |
* aux algorithm |
* @running: set by the algo indicating whether an i2c is ongoing or whether |
* the i2c bus is quiescent |
* @address: i2c target address for the currently ongoing transfer |
* @aux_ch: driver callback to transfer a single byte of the i2c payload |
*/ |
struct i2c_algo_dp_aux_data { |
bool running; |
u16 address; |
int (*aux_ch) (struct i2c_adapter *adapter, |
int mode, uint8_t write_byte, |
uint8_t *read_byte); |
}; |
int |
i2c_dp_aux_add_bus(struct i2c_adapter *adapter); |
#define DP_LINK_STATUS_SIZE 6 |
bool drm_dp_channel_eq_ok(const u8 link_status[DP_LINK_STATUS_SIZE], |
int lane_count); |
550,6 → 531,7 |
struct mutex hw_mutex; |
ssize_t (*transfer)(struct drm_dp_aux *aux, |
struct drm_dp_aux_msg *msg); |
unsigned i2c_nack_count, i2c_defer_count; |
}; |
ssize_t drm_dp_dpcd_read(struct drm_dp_aux *aux, unsigned int offset, |
/drivers/include/drm/drm_dp_mst_helper.h |
---|
28,7 → 28,7 |
struct drm_dp_mst_branch; |
/** |
* struct drm_dp_vcpi - Virtual Channel Payload Identifer |
* struct drm_dp_vcpi - Virtual Channel Payload Identifier |
* @vcpi: Virtual channel ID. |
* @pbn: Payload Bandwidth Number for this channel |
* @aligned_pbn: PBN aligned with slot size |
92,6 → 92,8 |
struct drm_dp_vcpi vcpi; |
struct drm_connector *connector; |
struct drm_dp_mst_topology_mgr *mgr; |
struct edid *cached_edid; /* for DP logical ports - make tiling work */ |
}; |
/** |
371,7 → 373,7 |
struct drm_dp_mst_topology_mgr; |
struct drm_dp_mst_topology_cbs { |
/* create a connector for a port */ |
struct drm_connector *(*add_connector)(struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port, char *path); |
struct drm_connector *(*add_connector)(struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port, const char *path); |
void (*destroy_connector)(struct drm_dp_mst_topology_mgr *mgr, |
struct drm_connector *connector); |
void (*hotplug)(struct drm_dp_mst_topology_mgr *mgr); |
388,6 → 390,7 |
int payload_state; |
int start_slot; |
int num_slots; |
int vcpi; |
}; |
/** |
454,6 → 457,7 |
struct drm_dp_vcpi **proposed_vcpis; |
struct drm_dp_payload *payloads; |
unsigned long payload_mask; |
unsigned long vcpi_mask; |
wait_queue_head_t tx_waitq; |
struct work_struct work; |
472,7 → 476,7 |
int drm_dp_mst_hpd_irq(struct drm_dp_mst_topology_mgr *mgr, u8 *esi, bool *handled); |
enum drm_connector_status drm_dp_mst_detect_port(struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port); |
enum drm_connector_status drm_dp_mst_detect_port(struct drm_connector *connector, struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port); |
struct edid *drm_dp_mst_get_edid(struct drm_connector *connector, struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port); |
/drivers/include/drm/drm_edid.h |
---|
27,6 → 27,7 |
#define EDID_LENGTH 128 |
#define DDC_ADDR 0x50 |
#define DDC_ADDR2 0x52 /* E-DDC 1.2 - where DisplayID can hide */ |
#define CEA_EXT 0x02 |
#define VTB_EXT 0x10 |
33,6 → 34,7 |
#define DI_EXT 0x40 |
#define LS_EXT 0x50 |
#define MI_EXT 0x60 |
#define DISPLAYID_EXT 0x70 |
struct est_timings { |
u8 t1; |
207,6 → 209,61 |
#define DRM_EDID_HDMI_DC_30 (1 << 4) |
#define DRM_EDID_HDMI_DC_Y444 (1 << 3) |
/* ELD Header Block */ |
#define DRM_ELD_HEADER_BLOCK_SIZE 4 |
#define DRM_ELD_VER 0 |
# define DRM_ELD_VER_SHIFT 3 |
# define DRM_ELD_VER_MASK (0x1f << 3) |
#define DRM_ELD_BASELINE_ELD_LEN 2 /* in dwords! */ |
/* ELD Baseline Block for ELD_Ver == 2 */ |
#define DRM_ELD_CEA_EDID_VER_MNL 4 |
# define DRM_ELD_CEA_EDID_VER_SHIFT 5 |
# define DRM_ELD_CEA_EDID_VER_MASK (7 << 5) |
# define DRM_ELD_CEA_EDID_VER_NONE (0 << 5) |
# define DRM_ELD_CEA_EDID_VER_CEA861 (1 << 5) |
# define DRM_ELD_CEA_EDID_VER_CEA861A (2 << 5) |
# define DRM_ELD_CEA_EDID_VER_CEA861BCD (3 << 5) |
# define DRM_ELD_MNL_SHIFT 0 |
# define DRM_ELD_MNL_MASK (0x1f << 0) |
#define DRM_ELD_SAD_COUNT_CONN_TYPE 5 |
# define DRM_ELD_SAD_COUNT_SHIFT 4 |
# define DRM_ELD_SAD_COUNT_MASK (0xf << 4) |
# define DRM_ELD_CONN_TYPE_SHIFT 2 |
# define DRM_ELD_CONN_TYPE_MASK (3 << 2) |
# define DRM_ELD_CONN_TYPE_HDMI (0 << 2) |
# define DRM_ELD_CONN_TYPE_DP (1 << 2) |
# define DRM_ELD_SUPPORTS_AI (1 << 1) |
# define DRM_ELD_SUPPORTS_HDCP (1 << 0) |
#define DRM_ELD_AUD_SYNCH_DELAY 6 /* in units of 2 ms */ |
# define DRM_ELD_AUD_SYNCH_DELAY_MAX 0xfa /* 500 ms */ |
#define DRM_ELD_SPEAKER 7 |
# define DRM_ELD_SPEAKER_RLRC (1 << 6) |
# define DRM_ELD_SPEAKER_FLRC (1 << 5) |
# define DRM_ELD_SPEAKER_RC (1 << 4) |
# define DRM_ELD_SPEAKER_RLR (1 << 3) |
# define DRM_ELD_SPEAKER_FC (1 << 2) |
# define DRM_ELD_SPEAKER_LFE (1 << 1) |
# define DRM_ELD_SPEAKER_FLR (1 << 0) |
#define DRM_ELD_PORT_ID 8 /* offsets 8..15 inclusive */ |
# define DRM_ELD_PORT_ID_LEN 8 |
#define DRM_ELD_MANUFACTURER_NAME0 16 |
#define DRM_ELD_MANUFACTURER_NAME1 17 |
#define DRM_ELD_PRODUCT_CODE0 18 |
#define DRM_ELD_PRODUCT_CODE1 19 |
#define DRM_ELD_MONITOR_NAME_STRING 20 /* offsets 20..(20+mnl-1) inclusive */ |
#define DRM_ELD_CEA_SAD(mnl, sad) (20 + (mnl) + 3 * (sad)) |
struct edid { |
u8 header[8]; |
/* Vendor & product info */ |
279,4 → 336,56 |
drm_hdmi_vendor_infoframe_from_display_mode(struct hdmi_vendor_infoframe *frame, |
const struct drm_display_mode *mode); |
/** |
* drm_eld_mnl - Get ELD monitor name length in bytes. |
* @eld: pointer to an eld memory structure with mnl set |
*/ |
static inline int drm_eld_mnl(const uint8_t *eld) |
{ |
return (eld[DRM_ELD_CEA_EDID_VER_MNL] & DRM_ELD_MNL_MASK) >> DRM_ELD_MNL_SHIFT; |
} |
/** |
* drm_eld_sad_count - Get ELD SAD count. |
* @eld: pointer to an eld memory structure with sad_count set |
*/ |
static inline int drm_eld_sad_count(const uint8_t *eld) |
{ |
return (eld[DRM_ELD_SAD_COUNT_CONN_TYPE] & DRM_ELD_SAD_COUNT_MASK) >> |
DRM_ELD_SAD_COUNT_SHIFT; |
} |
/** |
* drm_eld_calc_baseline_block_size - Calculate baseline block size in bytes |
* @eld: pointer to an eld memory structure with mnl and sad_count set |
* |
* This is a helper for determining the payload size of the baseline block, in |
* bytes, for e.g. setting the Baseline_ELD_Len field in the ELD header block. |
*/ |
static inline int drm_eld_calc_baseline_block_size(const uint8_t *eld) |
{ |
return DRM_ELD_MONITOR_NAME_STRING - DRM_ELD_HEADER_BLOCK_SIZE + |
drm_eld_mnl(eld) + drm_eld_sad_count(eld) * 3; |
} |
/** |
* drm_eld_size - Get ELD size in bytes |
* @eld: pointer to a complete eld memory structure |
* |
* The returned value does not include the vendor block. It's vendor specific, |
* and comprises of the remaining bytes in the ELD memory buffer after |
* drm_eld_size() bytes of header and baseline block. |
* |
* The returned value is guaranteed to be a multiple of 4. |
*/ |
static inline int drm_eld_size(const uint8_t *eld) |
{ |
return DRM_ELD_HEADER_BLOCK_SIZE + eld[DRM_ELD_BASELINE_ELD_LEN] * 4; |
} |
struct edid *drm_do_get_edid(struct drm_connector *connector, |
int (*get_edid_block)(void *data, u8 *buf, unsigned int block, |
size_t len), |
void *data); |
#endif /* __DRM_EDID_H__ */ |
/drivers/include/drm/drm_fb_helper.h |
---|
34,9 → 34,14 |
#include <linux/kgdb.h> |
struct drm_fb_offset { |
int x, y; |
}; |
struct drm_fb_helper_crtc { |
struct drm_mode_set mode_set; |
struct drm_display_mode *desired_mode; |
int x, y; |
}; |
struct drm_fb_helper_surface_size { |
72,12 → 77,12 |
bool (*initial_config)(struct drm_fb_helper *fb_helper, |
struct drm_fb_helper_crtc **crtcs, |
struct drm_display_mode **modes, |
struct drm_fb_offset *offsets, |
bool *enabled, int width, int height); |
}; |
struct drm_fb_helper_connector { |
struct drm_connector *connector; |
struct drm_cmdline_mode cmdline_mode; |
}; |
struct drm_fb_helper { |
/drivers/include/drm/drm_gem.h |
---|
0,0 → 1,190 |
#ifndef __DRM_GEM_H__ |
#define __DRM_GEM_H__ |
/* |
* GEM Graphics Execution Manager Driver Interfaces |
* |
* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas. |
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California. |
* Copyright (c) 2009-2010, Code Aurora Forum. |
* All rights reserved. |
* Copyright © 2014 Intel Corporation |
* Daniel Vetter <daniel.vetter@ffwll.ch> |
* |
* Author: Rickard E. (Rik) Faith <faith@valinux.com> |
* Author: Gareth Hughes <gareth@valinux.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 (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 |
* VA LINUX SYSTEMS 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. |
*/ |
/** |
* This structure defines the drm_mm memory object, which will be used by the |
* DRM for its buffer objects. |
*/ |
struct drm_gem_object { |
/** Reference count of this object */ |
struct kref refcount; |
/** |
* 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; |
/** File representing the shmem storage */ |
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 |
* lifetime. |
*/ |
size_t size; |
/** |
* Global name for this object, starts at 1. 0 means unnamed. |
* Access is covered by the object_name_lock in the related drm_device |
*/ |
int name; |
/** |
* Memory domains. These monitor which caches contain read/write data |
* related to the object. When transitioning from one set of domains |
* to another, the driver is called to ensure that caches are suitably |
* flushed and invalidated |
*/ |
uint32_t read_domains; |
uint32_t write_domain; |
/** |
* While validating an exec operation, the |
* new read/write domain values are computed here. |
* They will be transferred to the above values |
* at the point that any cache flushing occurs |
*/ |
uint32_t pending_read_domains; |
uint32_t pending_write_domain; |
/** |
* dma_buf - dma buf associated with this GEM object |
* |
* Pointer to the dma-buf associated with this gem object (either |
* through importing or exporting). We break the resulting reference |
* loop when the last gem handle for this object is released. |
* |
* Protected by obj->object_name_lock |
*/ |
struct dma_buf *dma_buf; |
/** |
* import_attach - dma buf attachment backing this object |
* |
* Any foreign dma_buf imported as a gem object has this set to the |
* attachment point for the device. This is invariant over the lifetime |
* of a gem object. |
* |
* The driver's ->gem_free_object callback is responsible for cleaning |
* up the dma_buf attachment and references acquired at import time. |
* |
* Note that the drm gem/prime core does not depend upon drivers setting |
* this field any more. So for drivers where this doesn't make sense |
* (e.g. virtual devices or a displaylink behind an usb bus) they can |
* simply leave it as NULL. |
*/ |
struct dma_buf_attachment *import_attach; |
/** |
* dumb - created as dumb buffer |
* Whether the gem object was created using the dumb buffer interface |
* as such it may not be used for GPU rendering. |
*/ |
bool dumb; |
}; |
void drm_gem_object_release(struct drm_gem_object *obj); |
void drm_gem_object_free(struct kref *kref); |
int drm_gem_object_init(struct drm_device *dev, |
struct drm_gem_object *obj, size_t size); |
void drm_gem_private_object_init(struct drm_device *dev, |
struct drm_gem_object *obj, size_t size); |
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); |
static inline void |
drm_gem_object_reference(struct drm_gem_object *obj) |
{ |
kref_get(&obj->refcount); |
} |
static inline void |
drm_gem_object_unreference(struct drm_gem_object *obj) |
{ |
if (obj != NULL) |
kref_put(&obj->refcount, drm_gem_object_free); |
} |
static inline void |
drm_gem_object_unreference_unlocked(struct drm_gem_object *obj) |
{ |
if (obj && !atomic_add_unless(&obj->refcount.refcount, -1, 1)) { |
struct drm_device *dev = obj->dev; |
mutex_lock(&dev->struct_mutex); |
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(struct drm_file *file_priv, |
struct drm_gem_object *obj, |
u32 *handlep); |
int drm_gem_handle_delete(struct drm_file *filp, u32 handle); |
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); |
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); |
int drm_gem_dumb_destroy(struct drm_file *file, |
struct drm_device *dev, |
uint32_t handle); |
#endif /* __DRM_GEM_H__ */ |
/drivers/include/drm/drm_legacy.h |
---|
0,0 → 1,203 |
#ifndef __DRM_DRM_LEGACY_H__ |
#define __DRM_DRM_LEGACY_H__ |
/* |
* Legacy driver interfaces for the Direct Rendering Manager |
* |
* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas. |
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California. |
* Copyright (c) 2009-2010, Code Aurora Forum. |
* All rights reserved. |
* Copyright © 2014 Intel Corporation |
* Daniel Vetter <daniel.vetter@ffwll.ch> |
* |
* Author: Rickard E. (Rik) Faith <faith@valinux.com> |
* Author: Gareth Hughes <gareth@valinux.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 (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 |
* VA LINUX SYSTEMS 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. |
*/ |
/* |
* Legacy Support for palateontologic DRM drivers |
* |
* If you add a new driver and it uses any of these functions or structures, |
* you're doing it terribly wrong. |
*/ |
/** |
* DMA buffer. |
*/ |
struct drm_buf { |
int idx; /**< Index into master buflist */ |
int total; /**< Buffer size */ |
int order; /**< log-base-2(total) */ |
int used; /**< Amount of buffer in use (for DMA) */ |
unsigned long offset; /**< Byte offset (used internally) */ |
void *address; /**< Address of buffer */ |
unsigned long bus_address; /**< Bus address of buffer */ |
struct drm_buf *next; /**< Kernel-only: used for free list */ |
__volatile__ int waiting; /**< On kernel DMA queue */ |
__volatile__ int pending; /**< On hardware DMA queue */ |
struct drm_file *file_priv; /**< Private of holding file descr */ |
int context; /**< Kernel queue for this buffer */ |
int while_locked; /**< Dispatch this buffer while locked */ |
enum { |
DRM_LIST_NONE = 0, |
DRM_LIST_FREE = 1, |
DRM_LIST_WAIT = 2, |
DRM_LIST_PEND = 3, |
DRM_LIST_PRIO = 4, |
DRM_LIST_RECLAIM = 5 |
} list; /**< Which list we're on */ |
int dev_priv_size; /**< Size of buffer private storage */ |
void *dev_private; /**< Per-buffer private storage */ |
}; |
typedef struct drm_dma_handle { |
dma_addr_t busaddr; |
void *vaddr; |
size_t size; |
} drm_dma_handle_t; |
/** |
* Buffer entry. There is one of this for each buffer size order. |
*/ |
struct drm_buf_entry { |
int buf_size; /**< size */ |
int buf_count; /**< number of buffers */ |
struct drm_buf *buflist; /**< buffer list */ |
int seg_count; |
int page_order; |
struct drm_dma_handle **seglist; |
int low_mark; /**< Low water mark */ |
int high_mark; /**< High water mark */ |
}; |
/** |
* DMA data. |
*/ |
struct drm_device_dma { |
struct drm_buf_entry bufs[DRM_MAX_ORDER + 1]; /**< buffers, grouped by their size order */ |
int buf_count; /**< total number of buffers */ |
struct drm_buf **buflist; /**< Vector of pointers into drm_device_dma::bufs */ |
int seg_count; |
int page_count; /**< number of pages */ |
unsigned long *pagelist; /**< page list */ |
unsigned long byte_count; |
enum { |
_DRM_DMA_USE_AGP = 0x01, |
_DRM_DMA_USE_SG = 0x02, |
_DRM_DMA_USE_FB = 0x04, |
_DRM_DMA_USE_PCI_RO = 0x08 |
} flags; |
}; |
/** |
* Scatter-gather memory. |
*/ |
struct drm_sg_mem { |
unsigned long handle; |
void *virtual; |
int pages; |
struct page **pagelist; |
dma_addr_t *busaddr; |
}; |
/** |
* Kernel side of a mapping |
*/ |
struct drm_local_map { |
resource_size_t offset; /**< Requested physical address (0 for SAREA)*/ |
unsigned long size; /**< Requested physical size (bytes) */ |
enum drm_map_type type; /**< Type of memory to map */ |
enum drm_map_flags flags; /**< Flags */ |
void *handle; /**< User-space: "Handle" to pass to mmap() */ |
/**< Kernel-space: kernel-virtual address */ |
int mtrr; /**< MTRR slot used */ |
}; |
typedef struct drm_local_map drm_local_map_t; |
/** |
* Mappings list |
*/ |
struct drm_map_list { |
struct list_head head; /**< list head */ |
struct drm_hash_item hash; |
struct drm_local_map *map; /**< mapping */ |
uint64_t user_token; |
struct drm_master *master; |
}; |
int drm_legacy_addmap(struct drm_device *d, resource_size_t offset, |
unsigned int size, enum drm_map_type type, |
enum drm_map_flags flags, struct drm_local_map **map_p); |
int drm_legacy_rmmap(struct drm_device *d, struct drm_local_map *map); |
int drm_legacy_rmmap_locked(struct drm_device *d, struct drm_local_map *map); |
struct drm_local_map *drm_legacy_getsarea(struct drm_device *dev); |
int drm_legacy_mmap(struct file *filp, struct vm_area_struct *vma); |
int drm_legacy_addbufs_agp(struct drm_device *d, struct drm_buf_desc *req); |
int drm_legacy_addbufs_pci(struct drm_device *d, struct drm_buf_desc *req); |
/** |
* Test that the hardware lock is held by the caller, returning otherwise. |
* |
* \param dev DRM device. |
* \param filp file pointer of the caller. |
*/ |
#define LOCK_TEST_WITH_RETURN( dev, _file_priv ) \ |
do { \ |
if (!_DRM_LOCK_IS_HELD(_file_priv->master->lock.hw_lock->lock) || \ |
_file_priv->master->lock.file_priv != _file_priv) { \ |
DRM_ERROR( "%s called without lock held, held %d owner %p %p\n",\ |
__func__, _DRM_LOCK_IS_HELD(_file_priv->master->lock.hw_lock->lock),\ |
_file_priv->master->lock.file_priv, _file_priv); \ |
return -EINVAL; \ |
} \ |
} while (0) |
void drm_legacy_idlelock_take(struct drm_lock_data *lock); |
void drm_legacy_idlelock_release(struct drm_lock_data *lock); |
/* drm_pci.c dma alloc wrappers */ |
void __drm_legacy_pci_free(struct drm_device *dev, drm_dma_handle_t * dmah); |
/* drm_memory.c */ |
void drm_legacy_ioremap(struct drm_local_map *map, struct drm_device *dev); |
void drm_legacy_ioremap_wc(struct drm_local_map *map, struct drm_device *dev); |
void drm_legacy_ioremapfree(struct drm_local_map *map, struct drm_device *dev); |
static __inline__ struct drm_local_map *drm_legacy_findmap(struct drm_device *dev, |
unsigned int token) |
{ |
struct drm_map_list *_entry; |
list_for_each_entry(_entry, &dev->maplist, head) |
if (_entry->user_token == token) |
return _entry->map; |
return NULL; |
} |
#endif /* __DRM_DRM_LEGACY_H__ */ |
/drivers/include/drm/drm_modeset_lock.h |
---|
29,10 → 29,11 |
struct drm_modeset_lock; |
/** |
* drm_modeset_acquire_ctx - locking context (see ww_acquire_ctx) |
* struct drm_modeset_acquire_ctx - locking context (see ww_acquire_ctx) |
* @ww_ctx: base acquire ctx |
* @contended: used internally for -EDEADLK handling |
* @locked: list of held locks |
* @trylock_only: trylock mode used in atomic contexts/panic notifiers |
* |
* Each thread competing for a set of locks must use one acquire |
* ctx. And if any lock fxn returns -EDEADLK, it must backoff and |
53,10 → 54,15 |
* list of held locks (drm_modeset_lock) |
*/ |
struct list_head locked; |
/** |
* Trylock mode, use only for panic handlers! |
*/ |
bool trylock_only; |
}; |
/** |
* drm_modeset_lock - used for locking modeset resources. |
* struct drm_modeset_lock - used for locking modeset resources. |
* @mutex: resource locking |
* @head: used to hold it's place on state->locked list when |
* part of an atomic update |
120,6 → 126,19 |
void drm_modeset_unlock(struct drm_modeset_lock *lock); |
struct drm_device; |
struct drm_crtc; |
struct drm_plane; |
void drm_modeset_lock_all(struct drm_device *dev); |
int __drm_modeset_lock_all(struct drm_device *dev, bool trylock); |
void drm_modeset_unlock_all(struct drm_device *dev); |
void drm_modeset_lock_crtc(struct drm_crtc *crtc, |
struct drm_plane *plane); |
void drm_modeset_unlock_crtc(struct drm_crtc *crtc); |
void drm_warn_on_modeset_not_all_locked(struct drm_device *dev); |
struct drm_modeset_acquire_ctx * |
drm_modeset_legacy_acquire_ctx(struct drm_crtc *crtc); |
int drm_modeset_lock_all_crtcs(struct drm_device *dev, |
struct drm_modeset_acquire_ctx *ctx); |
/drivers/include/drm/drm_os_linux.h |
---|
0,0 → 1,65 |
/** |
* \file drm_os_linux.h |
* OS abstraction macros. |
*/ |
//#include <linux/interrupt.h> /* For task queue support */ |
#include <linux/delay.h> |
#ifndef readq |
static inline u64 readq(void __iomem *reg) |
{ |
return ((u64) readl(reg)) | (((u64) readl(reg + 4UL)) << 32); |
} |
static inline void writeq(u64 val, void __iomem *reg) |
{ |
writel(val & 0xffffffff, reg); |
writel(val >> 32, reg + 0x4UL); |
} |
#endif |
/** Current process ID */ |
#define DRM_CURRENTPID task_pid_nr(current) |
#define DRM_UDELAY(d) udelay(d) |
/** Read a byte from a MMIO region */ |
#define DRM_READ8(map, offset) readb(((void __iomem *)(map)->handle) + (offset)) |
/** Read a word from a MMIO region */ |
#define DRM_READ16(map, offset) readw(((void __iomem *)(map)->handle) + (offset)) |
/** Read a dword from a MMIO region */ |
#define DRM_READ32(map, offset) readl(((void __iomem *)(map)->handle) + (offset)) |
/** Write a byte into a MMIO region */ |
#define DRM_WRITE8(map, offset, val) writeb(val, ((void __iomem *)(map)->handle) + (offset)) |
/** Write a word into a MMIO region */ |
#define DRM_WRITE16(map, offset, val) writew(val, ((void __iomem *)(map)->handle) + (offset)) |
/** Write a dword into a MMIO region */ |
#define DRM_WRITE32(map, offset, val) writel(val, ((void __iomem *)(map)->handle) + (offset)) |
/** Read a qword from a MMIO region - be careful using these unless you really understand them */ |
#define DRM_READ64(map, offset) readq(((void __iomem *)(map)->handle) + (offset)) |
/** Write a qword into a MMIO region */ |
#define DRM_WRITE64(map, offset, val) writeq(val, ((void __iomem *)(map)->handle) + (offset)) |
#define DRM_WAIT_ON( ret, queue, timeout, condition ) \ |
do { \ |
DECLARE_WAITQUEUE(entry, current); \ |
unsigned long end = jiffies + (timeout); \ |
add_wait_queue(&(queue), &entry); \ |
\ |
for (;;) { \ |
__set_current_state(TASK_INTERRUPTIBLE); \ |
if (condition) \ |
break; \ |
if (time_after_eq(jiffies, end)) { \ |
ret = -EBUSY; \ |
break; \ |
} \ |
schedule_timeout((HZ/100 > 1) ? HZ/100 : 1); \ |
if (signal_pending(current)) { \ |
ret = -EINTR; \ |
break; \ |
} \ |
} \ |
__set_current_state(TASK_RUNNING); \ |
remove_wait_queue(&(queue), &entry); \ |
} while (0) |
/drivers/include/drm/drm_pciids.h |
---|
17,6 → 17,7 |
{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, 0x1318, 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}, \ |
73,7 → 74,6 |
{0x1002, 0x4C64, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV250|RADEON_IS_MOBILITY}, \ |
{0x1002, 0x4C66, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV250|RADEON_IS_MOBILITY}, \ |
{0x1002, 0x4C67, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV250|RADEON_IS_MOBILITY}, \ |
{0x1002, 0x4C6E, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV280|RADEON_IS_MOBILITY}, \ |
{0x1002, 0x4E44, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R300}, \ |
{0x1002, 0x4E45, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R300}, \ |
{0x1002, 0x4E46, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R300}, \ |
164,8 → 164,11 |
{0x1002, 0x6601, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_OLAND|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6602, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_OLAND|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6603, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_OLAND|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6604, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_OLAND|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6605, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_OLAND|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6606, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_OLAND|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6607, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_OLAND|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6608, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_OLAND|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6610, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_OLAND|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6611, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_OLAND|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6613, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_OLAND|RADEON_NEW_MEMMAP}, \ |
175,6 → 178,8 |
{0x1002, 0x6631, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_OLAND|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6640, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_BONAIRE|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6641, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_BONAIRE|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6646, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_BONAIRE|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6647, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_BONAIRE|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6649, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_BONAIRE|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6650, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_BONAIRE|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6651, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_BONAIRE|RADEON_NEW_MEMMAP}, \ |
297,6 → 302,7 |
{0x1002, 0x6829, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_VERDE|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x682A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_VERDE|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x682B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_VERDE|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x682C, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_VERDE|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x682D, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_VERDE|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x682F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_VERDE|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6830, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_VERDE|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
/drivers/include/drm/drm_plane_helper.h |
---|
25,6 → 25,7 |
#define DRM_PLANE_HELPER_H |
#include <drm/drm_rect.h> |
#include <drm/drm_crtc.h> |
/* |
* Drivers that don't allow primary plane scaling may pass this macro in place |
42,6 → 43,37 |
* planes. |
*/ |
extern int drm_crtc_init(struct drm_device *dev, |
struct drm_crtc *crtc, |
const struct drm_crtc_funcs *funcs); |
/** |
* drm_plane_helper_funcs - helper operations for CRTCs |
* @prepare_fb: prepare a framebuffer for use by the plane |
* @cleanup_fb: cleanup a framebuffer when it's no longer used by the plane |
* @atomic_check: check that a given atomic state is valid and can be applied |
* @atomic_update: apply an atomic state to the plane |
* |
* The helper operations are called by the mid-layer CRTC helper. |
*/ |
struct drm_plane_helper_funcs { |
int (*prepare_fb)(struct drm_plane *plane, |
struct drm_framebuffer *fb); |
void (*cleanup_fb)(struct drm_plane *plane, |
struct drm_framebuffer *fb); |
int (*atomic_check)(struct drm_plane *plane, |
struct drm_plane_state *state); |
void (*atomic_update)(struct drm_plane *plane, |
struct drm_plane_state *old_state); |
}; |
static inline void drm_plane_helper_add(struct drm_plane *plane, |
const struct drm_plane_helper_funcs *funcs) |
{ |
plane->helper_private = (void *)funcs; |
} |
extern int drm_plane_helper_check_update(struct drm_plane *plane, |
struct drm_crtc *crtc, |
struct drm_framebuffer *fb, |
68,4 → 100,16 |
int num_formats); |
int drm_plane_helper_update(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 drm_plane_helper_disable(struct drm_plane *plane); |
/* For use by drm_crtc_helper.c */ |
int drm_plane_helper_commit(struct drm_plane *plane, |
struct drm_plane_state *plane_state, |
struct drm_framebuffer *old_fb); |
#endif |
/drivers/include/drm/i915_pciids.h |
---|
259,4 → 259,21 |
INTEL_VGA_DEVICE(0x22b2, info), \ |
INTEL_VGA_DEVICE(0x22b3, info) |
#define INTEL_SKL_IDS(info) \ |
INTEL_VGA_DEVICE(0x1916, info), /* ULT GT2 */ \ |
INTEL_VGA_DEVICE(0x1906, info), /* ULT GT1 */ \ |
INTEL_VGA_DEVICE(0x1926, info), /* ULT GT3 */ \ |
INTEL_VGA_DEVICE(0x1921, info), /* ULT GT2F */ \ |
INTEL_VGA_DEVICE(0x190E, info), /* ULX GT1 */ \ |
INTEL_VGA_DEVICE(0x191E, info), /* ULX GT2 */ \ |
INTEL_VGA_DEVICE(0x1912, info), /* DT GT2 */ \ |
INTEL_VGA_DEVICE(0x1902, info), /* DT GT1 */ \ |
INTEL_VGA_DEVICE(0x191B, info), /* Halo GT2 */ \ |
INTEL_VGA_DEVICE(0x192B, info), /* Halo GT3 */ \ |
INTEL_VGA_DEVICE(0x190B, info), /* Halo GT1 */ \ |
INTEL_VGA_DEVICE(0x191A, info), /* SRV GT2 */ \ |
INTEL_VGA_DEVICE(0x192A, info), /* SRV GT3 */ \ |
INTEL_VGA_DEVICE(0x190A, info), /* SRV GT1 */ \ |
INTEL_VGA_DEVICE(0x191D, info) /* WKS GT2 */ |
#endif /* _I915_PCIIDS_H */ |
/drivers/include/drm/intel-gtt.h |
---|
3,8 → 3,6 |
#ifndef _DRM_INTEL_GTT_H |
#define _DRM_INTEL_GTT_H |
struct agp_bridge_data; |
void intel_gtt_get(size_t *gtt_total, size_t *stolen_size, |
phys_addr_t *mappable_base, unsigned long *mappable_end); |
/drivers/include/drm/ttm/ttm_bo_api.h |
---|
45,12 → 45,24 |
struct drm_mm_node; |
/** |
* struct ttm_place |
* |
* @fpfn: first valid page frame number to put the object |
* @lpfn: last valid page frame number to put the object |
* @flags: memory domain and caching flags for the object |
* |
* Structure indicating a possible place to put an object. |
*/ |
struct ttm_place { |
unsigned fpfn; |
unsigned lpfn; |
uint32_t flags; |
}; |
/** |
* struct ttm_placement |
* |
* @fpfn: first valid page frame number to put the object |
* @lpfn: last valid page frame number to put the object |
* @num_placement: number of preferred placements |
* @placement: preferred placements |
* @num_busy_placement: number of preferred placements when need to evict buffer |
59,12 → 71,10 |
* Structure indicating the placement you request for an object. |
*/ |
struct ttm_placement { |
unsigned fpfn; |
unsigned lpfn; |
unsigned num_placement; |
const uint32_t *placement; |
const struct ttm_place *placement; |
unsigned num_busy_placement; |
const uint32_t *busy_placement; |
const struct ttm_place *busy_placement; |
}; |
/** |
163,7 → 173,6 |
* @lru: List head for the lru list. |
* @ddestroy: List head for the delayed destroy list. |
* @swap: List head for swap LRU list. |
* @sync_obj: Pointer to a synchronization object. |
* @priv_flags: Flags describing buffer object internal state. |
* @vma_node: Address space manager node. |
* @offset: The current GPU offset, which can have different meanings |
227,13 → 236,9 |
struct list_head io_reserve_lru; |
/** |
* Members protected by struct buffer_object_device::fence_lock |
* In addition, setting sync_obj to anything else |
* than NULL requires bo::reserved to be held. This allows for |
* checking NULL while reserved but not holding the mentioned lock. |
* Members protected by a bo reservation. |
*/ |
void *sync_obj; |
unsigned long priv_flags; |
struct drm_vma_offset_node vma_node; |
455,6 → 460,7 |
* point to the shmem object backing a GEM object if TTM is used to back a |
* GEM user interface. |
* @acc_size: Accounted size for this object. |
* @resv: Pointer to a reservation_object, or NULL to let ttm allocate one. |
* @destroy: Destroy function. Use NULL for kfree(). |
* |
* This function initializes a pre-allocated struct ttm_buffer_object. |
482,6 → 488,7 |
struct file *persistent_swap_storage, |
size_t acc_size, |
struct sg_table *sg, |
struct reservation_object *resv, |
void (*destroy) (struct ttm_buffer_object *)); |
/** |
519,20 → 526,6 |
struct ttm_buffer_object **p_bo); |
/** |
* ttm_bo_check_placement |
* |
* @bo: the buffer object. |
* @placement: placements |
* |
* Performs minimal validity checking on an intended change of |
* placement flags. |
* Returns |
* -EINVAL: Intended change is invalid or not allowed. |
*/ |
extern int ttm_bo_check_placement(struct ttm_buffer_object *bo, |
struct ttm_placement *placement); |
/** |
* ttm_bo_init_mm |
* |
* @bdev: Pointer to a ttm_bo_device struct. |
/drivers/include/drm/ttm/ttm_bo_driver.h |
---|
208,8 → 208,7 |
*/ |
int (*get_node)(struct ttm_mem_type_manager *man, |
struct ttm_buffer_object *bo, |
struct ttm_placement *placement, |
uint32_t flags, |
const struct ttm_place *place, |
struct ttm_mem_reg *mem); |
/** |
313,11 → 312,6 |
* @move: Callback for a driver to hook in accelerated functions to |
* move a buffer. |
* If set to NULL, a potentially slow memcpy() move is used. |
* @sync_obj_signaled: See ttm_fence_api.h |
* @sync_obj_wait: See ttm_fence_api.h |
* @sync_obj_flush: See ttm_fence_api.h |
* @sync_obj_unref: See ttm_fence_api.h |
* @sync_obj_ref: See ttm_fence_api.h |
*/ |
struct ttm_bo_driver { |
419,23 → 413,6 |
int (*verify_access) (struct ttm_buffer_object *bo, |
struct file *filp); |
/** |
* In case a driver writer dislikes the TTM fence objects, |
* the driver writer can replace those with sync objects of |
* his / her own. If it turns out that no driver writer is |
* using these. I suggest we remove these hooks and plug in |
* fences directly. The bo driver needs the following functionality: |
* See the corresponding functions in the fence object API |
* documentation. |
*/ |
bool (*sync_obj_signaled) (void *sync_obj); |
int (*sync_obj_wait) (void *sync_obj, |
bool lazy, bool interruptible); |
int (*sync_obj_flush) (void *sync_obj); |
void (*sync_obj_unref) (void **sync_obj); |
void *(*sync_obj_ref) (void *sync_obj); |
/* hook to notify driver about a driver move so it |
* can do tiling things */ |
void (*move_notify)(struct ttm_buffer_object *bo, |
522,8 → 499,6 |
* |
* @driver: Pointer to a struct ttm_bo_driver struct setup by the driver. |
* @man: An array of mem_type_managers. |
* @fence_lock: Protects the synchronizing members on *all* bos belonging |
* to this device. |
* @vma_manager: Address space manager |
* lru_lock: Spinlock that protects the buffer+device lru lists and |
* ddestroy lists. |
543,7 → 518,6 |
struct ttm_bo_global *glob; |
struct ttm_bo_driver *driver; |
struct ttm_mem_type_manager man[TTM_NUM_MEM_TYPES]; |
spinlock_t fence_lock; |
/* |
* Protected by internal locks. |
1022,7 → 996,7 |
* ttm_bo_move_accel_cleanup. |
* |
* @bo: A pointer to a struct ttm_buffer_object. |
* @sync_obj: A sync object that signals when moving is complete. |
* @fence: A fence object that signals when moving is complete. |
* @evict: This is an evict move. Don't return until the buffer is idle. |
* @no_wait_gpu: Return immediately if the GPU is busy. |
* @new_mem: struct ttm_mem_reg indicating where to move. |
1036,7 → 1010,7 |
*/ |
extern int ttm_bo_move_accel_cleanup(struct ttm_buffer_object *bo, |
void *sync_obj, |
struct fence *fence, |
bool evict, bool no_wait_gpu, |
struct ttm_mem_reg *new_mem); |
/** |
/drivers/include/drm/ttm/ttm_execbuf_util.h |
---|
39,19 → 39,13 |
* |
* @head: list head for thread-private list. |
* @bo: refcounted buffer object pointer. |
* @reserved: Indicates whether @bo has been reserved for validation. |
* @removed: Indicates whether @bo has been removed from lru lists. |
* @put_count: Number of outstanding references on bo::list_kref. |
* @old_sync_obj: Pointer to a sync object about to be unreferenced |
* @shared: should the fence be added shared? |
*/ |
struct ttm_validate_buffer { |
struct list_head head; |
struct ttm_buffer_object *bo; |
bool reserved; |
bool removed; |
int put_count; |
void *old_sync_obj; |
bool shared; |
}; |
/** |
73,6 → 67,8 |
* @ticket: [out] ww_acquire_ctx filled in by call, or NULL if only |
* non-blocking reserves should be tried. |
* @list: thread private list of ttm_validate_buffer structs. |
* @intr: should the wait be interruptible |
* @dups: [out] optional list of duplicates. |
* |
* Tries to reserve bos pointed to by the list entries for validation. |
* If the function returns 0, all buffers are marked as "unfenced", |
84,10 → 80,15 |
* CPU write reservations to be cleared, and for other threads to |
* unreserve their buffers. |
* |
* This function may return -ERESTART or -EAGAIN if the calling process |
* receives a signal while waiting. In that case, no buffers on the list |
* will be reserved upon return. |
* If intr is set to true, this function may return -ERESTARTSYS if the |
* calling process receives a signal while waiting. In that case, no |
* buffers on the list will be reserved upon return. |
* |
* If dups is non NULL all buffers already reserved by the current thread |
* (e.g. duplicates) are added to this list, otherwise -EALREADY is returned |
* on the first already reserved buffer and all buffers from the list are |
* unreserved again. |
* |
* Buffers reserved by this function should be unreserved by |
* a call to either ttm_eu_backoff_reservation() or |
* ttm_eu_fence_buffer_objects() when command submission is complete or |
95,7 → 96,8 |
*/ |
extern int ttm_eu_reserve_buffers(struct ww_acquire_ctx *ticket, |
struct list_head *list); |
struct list_head *list, bool intr, |
struct list_head *dups); |
/** |
* function ttm_eu_fence_buffer_objects. |
102,7 → 104,7 |
* |
* @ticket: ww_acquire_ctx from reserve call |
* @list: thread private list of ttm_validate_buffer structs. |
* @sync_obj: The new sync object for the buffers. |
* @fence: The new exclusive fence for the buffers. |
* |
* This function should be called when command submission is complete, and |
* it will add a new sync object to bos pointed to by entries on @list. |
111,6 → 113,7 |
*/ |
extern void ttm_eu_fence_buffer_objects(struct ww_acquire_ctx *ticket, |
struct list_head *list, void *sync_obj); |
struct list_head *list, |
struct fence *fence); |
#endif |