/drivers/include/ddk.h |
---|
10,7 → 10,7 |
#define OS_BASE 0x80000000 |
#define PG_SW 0x003 |
#define PG_NOCACHE 0x018 |
#define PG_NOCACHE 0x010 |
#define MANUAL_DESTROY 0x80000000 |
/drivers/include/drm/drm.h |
---|
702,6 → 702,9 |
#define DRM_IOCTL_MODE_CREATE_DUMB DRM_IOWR(0xB2, struct drm_mode_create_dumb) |
#define DRM_IOCTL_MODE_MAP_DUMB DRM_IOWR(0xB3, struct drm_mode_map_dumb) |
#define DRM_IOCTL_MODE_DESTROY_DUMB DRM_IOWR(0xB4, struct drm_mode_destroy_dumb) |
#define DRM_IOCTL_MODE_GETPLANERESOURCES DRM_IOWR(0xB5, struct drm_mode_get_plane_res) |
#define DRM_IOCTL_MODE_GETPLANE DRM_IOWR(0xB6, struct drm_mode_get_plane) |
#define DRM_IOCTL_MODE_SETPLANE DRM_IOWR(0xB7, struct drm_mode_set_plane) |
*/ |
/drivers/include/drm/drmP.h |
---|
36,17 → 36,15 |
#define _DRM_P_H_ |
#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/module.h> |
#include <linux/kernel.h> |
#include <errno-base.h> |
#include <linux/errno.h> |
#include <linux/kref.h> |
#include <linux/spinlock.h> |
#include <linux/wait.h> |
//#include <linux/miscdevice.h> |
//#include <linux/fs.h> |
54,7 → 52,7 |
//#include <linux/init.h> |
//#include <linux/file.h> |
#include <linux/pci.h> |
//#include <linux/jiffies.h> |
#include <linux/jiffies.h> |
//#include <linux/smp_lock.h> /* For (un)lock_kernel */ |
//#include <linux/dma-mapping.h> |
//#include <linux/mm.h> |
122,17 → 120,16 |
printk("[" DRM_NAME ":%s] " fmt , __func__ , ##args); \ |
} while(0) |
#define dev_err(dev, format, arg...) \ |
printk("Error %s " format, __func__ , ## arg) |
#define DRM_DEBUG_DRIVER(fmt, args...) \ |
do { \ |
printk("[" DRM_NAME ":%s] " fmt , __func__ , ##args); \ |
} while (0) |
#define dev_warn(dev, format, arg...) \ |
printk("Warning %s " format, __func__ , ## arg) |
#define DRM_LOG_KMS(fmt, args...) \ |
do { \ |
printk("[" DRM_NAME "]" fmt, ##args); \ |
} while (0) |
#define dev_info(dev, format, arg...) \ |
printk("Info %s " format , __func__, ## arg) |
static inline int drm_sysfs_connector_add(struct drm_connector *connector) |
{ return 0; }; |
160,8 → 157,11 |
#define DRIVER_IRQ_VBL2 0x800 |
#define DRIVER_GEM 0x1000 |
#define DRIVER_MODESET 0x2000 |
#define DRIVER_USE_PLATFORM_DEVICE 0x4000 |
#define DRIVER_BUS_PCI 0x1 |
#define DRIVER_BUS_PLATFORM 0x2 |
#define DRIVER_BUS_USB 0x3 |
/***********************************************************************/ |
/** \name Begin the DRM... */ |
/*@{*/ |
396,6 → 396,7 |
atomic_t wfh; /**< If waiting for high mark */ |
spinlock_t lock; |
}; |
#endif |
typedef struct drm_dma_handle { |
dma_addr_t busaddr; |
403,6 → 404,7 |
size_t size; |
} drm_dma_handle_t; |
#if 0 |
/** |
* Buffer entry. There is one of this for each buffer size order. |
*/ |
554,7 → 556,9 |
struct drm_hw_lock *lock; |
}; |
#endif |
/** |
* Kernel side of a mapping |
*/ |
570,6 → 574,7 |
typedef struct drm_local_map drm_local_map_t; |
#if 0 |
/** |
* Mappings list |
*/ |
638,7 → 643,6 |
struct file *filp; |
/* Mapping info for this object */ |
// struct drm_map_list map_list; |
/** |
* Size of the object, in bytes. Immutable over the object's |
673,8 → 677,6 |
void *driver_private; |
}; |
#if 0 |
#include "drm_crtc.h" |
/* per-master structure */ |
693,15 → 695,17 |
/** \name Authentication */ |
/*@{ */ |
struct drm_open_hash magiclist; |
struct list_head magicfree; |
// struct drm_open_hash magiclist; |
// struct list_head magicfree; |
/*@} */ |
struct drm_lock_data lock; /**< Information on hardware lock */ |
// struct drm_lock_data lock; /**< Information on hardware lock */ |
void *driver_priv; /**< Private structure for driver to use */ |
}; |
#if 0 |
/* Size of ringbuffer for vblank timestamps. Just double-buffer |
* in initial implementation. |
*/ |
841,7 → 845,7 |
* Specifically, the timestamp in @vblank_time should correspond as |
* closely as possible to the time when the first video scanline of |
* the video frame after the end of VBLANK will start scanning out, |
* the time immmediately after end of the VBLANK interval. If the |
* the time immediately after end of the VBLANK interval. If the |
* @crtc is currently inside VBLANK, this will be a time in the future. |
* If the @crtc is currently scanning out a frame, this will be the |
* past start time of the current scanout. This is meant to adhere |
908,10 → 912,23 |
*/ |
int (*gem_init_object) (struct drm_gem_object *obj); |
void (*gem_free_object) (struct drm_gem_object *obj); |
int (*gem_open_object) (struct drm_gem_object *, struct drm_file *); |
void (*gem_close_object) (struct drm_gem_object *, struct drm_file *); |
/* vga arb irq handler */ |
void (*vgaarb_irq)(struct drm_device *dev, bool state); |
/* dumb alloc support */ |
int (*dumb_create)(struct drm_file *file_priv, |
struct drm_device *dev, |
struct drm_mode_create_dumb *args); |
int (*dumb_map_offset)(struct drm_file *file_priv, |
struct drm_device *dev, uint32_t handle, |
uint64_t *offset); |
int (*dumb_destroy)(struct drm_file *file_priv, |
struct drm_device *dev, |
uint32_t handle); |
/* Driver private ops for this object */ |
struct vm_operations_struct *gem_vm_ops; |
926,12 → 943,20 |
int dev_priv_size; |
struct drm_ioctl_desc *ioctls; |
int num_ioctls; |
struct file_operations fops; |
struct pci_driver pci_driver; |
const struct file_operations *fops; |
union { |
struct pci_driver *pci; |
struct platform_device *platform_device; |
struct usb_driver *usb; |
} kdriver; |
struct drm_bus *bus; |
/* List of devices hanging off this driver */ |
struct list_head device_list; |
}; |
#endif |
#define DRM_MINOR_UNASSIGNED 0 |
#define DRM_MINOR_LEGACY 1 |
#define DRM_MINOR_CONTROL 2 |
944,7 → 969,7 |
*/ |
struct drm_debugfs_list { |
const char *name; /** file name */ |
int (*show)(struct seq_file*, void*); /** show callback */ |
// int (*show)(struct seq_file*, void*); /** show callback */ |
u32 driver_features; /**< Required driver features for this entry */ |
}; |
964,7 → 989,7 |
*/ |
struct drm_info_list { |
const char *name; /** file name */ |
int (*show)(struct seq_file*, void*); /** show callback */ |
// int (*show)(struct seq_file*, void*); /** show callback */ |
u32 driver_features; /**< Required driver features for this entry */ |
void *data; |
}; |
985,22 → 1010,20 |
struct drm_minor { |
int index; /**< Minor device number */ |
int type; /**< Control or render */ |
dev_t device; /**< Device number for mknod */ |
struct device kdev; /**< Linux device */ |
// dev_t device; /**< Device number for mknod */ |
// struct device kdev; /**< Linux device */ |
struct drm_device *dev; |
struct proc_dir_entry *proc_root; /**< proc directory entry */ |
struct drm_info_node proc_nodes; |
struct dentry *debugfs_root; |
struct drm_info_node debugfs_nodes; |
// struct proc_dir_entry *proc_root; /**< proc directory entry */ |
// struct drm_info_node proc_nodes; |
// struct dentry *debugfs_root; |
// struct drm_info_node debugfs_nodes; |
struct drm_master *master; /* currently active master for this node */ |
struct list_head master_list; |
struct drm_mode_group mode_group; |
// struct list_head master_list; |
// struct drm_mode_group mode_group; |
}; |
#endif |
/* mode specified on the command line */ |
struct drm_cmdline_mode { |
bool specified; |
1149,7 → 1172,7 |
// struct drm_local_map *agp_buffer_map; |
// unsigned int agp_buffer_token; |
// struct drm_minor *control; /**< Control node for card */ |
// struct drm_minor *primary; /**< render type primary screen head */ |
struct drm_minor *primary; /**< render type primary screen head */ |
struct drm_mode_config mode_config; /**< Current mode config */ |
1166,37 → 1189,12 |
#define DRM_SWITCH_POWER_CHANGING 2 |
static __inline__ int drm_device_is_agp(struct drm_device *dev) |
{ |
return pci_find_capability(dev->pdev, PCI_CAP_ID_AGP); |
} |
static __inline__ int drm_device_is_pcie(struct drm_device *dev) |
{ |
return pci_find_capability(dev->pdev, PCI_CAP_ID_EXP); |
} |
#if 0 |
static inline int drm_dev_to_irq(struct drm_device *dev) |
{ |
return dev->pdev->irq; |
} |
static __inline__ int drm_core_check_feature(struct drm_device *dev, |
int feature) |
{ |
return ((dev->driver->driver_features & feature) ? 1 : 0); |
} |
#if 0 |
#ifdef __alpha__ |
#define drm_get_pci_domain(dev) dev->hose->index |
1344,6 → 1342,7 |
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); |
1555,6 → 1554,8 |
static inline 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); |
1564,11 → 1565,14 |
size_t size); |
int drm_gem_object_init(struct drm_device *dev, |
struct drm_gem_object *obj, size_t size); |
int drm_gem_private_object_init(struct drm_device *dev, |
struct drm_gem_object *obj, size_t size); |
void drm_gem_object_handle_free(struct drm_gem_object *obj); |
void drm_gem_vm_open(struct vm_area_struct *vma); |
void drm_gem_vm_close(struct vm_area_struct *vma); |
int drm_gem_mmap(struct file *filp, struct vm_area_struct *vma); |
static inline void |
drm_gem_object_reference(struct drm_gem_object *obj) |
{ |
1578,11 → 1582,21 |
static inline void |
drm_gem_object_unreference(struct drm_gem_object *obj) |
{ |
if (obj == NULL) |
return; |
if (obj != NULL) |
kref_put(&obj->refcount, drm_gem_object_free); |
} |
#if 0 |
static inline void |
drm_gem_object_unreference_unlocked(struct drm_gem_object *obj) |
{ |
if (obj != NULL) { |
struct drm_device *dev = obj->dev; |
mutex_lock(&dev->struct_mutex); |
kref_put(&obj->refcount, drm_gem_object_free); |
mutex_unlock(&dev->struct_mutex); |
} |
} |
int drm_gem_handle_create(struct drm_file *file_priv, |
struct drm_gem_object *obj, |
1609,10 → 1623,32 |
* ref, in which case the object would disappear before we |
* checked for a name |
*/ |
kref_put(&obj->handlecount, drm_gem_object_handle_free); |
if (atomic_dec_and_test(&obj->handle_count)) |
drm_gem_object_handle_free(obj); |
drm_gem_object_unreference(obj); |
} |
static inline void |
drm_gem_object_handle_unreference_unlocked(struct drm_gem_object *obj) |
{ |
if (obj == NULL) |
return; |
if (atomic_read(&obj->handle_count) == 0) |
return; |
/* |
* Must bump handle count first as this may be the last |
* ref, in which case the object would disappear before we |
* checked for a name |
*/ |
if (atomic_dec_and_test(&obj->handle_count)) |
drm_gem_object_handle_free(obj); |
drm_gem_object_unreference_unlocked(obj); |
} |
struct drm_gem_object *drm_gem_object_lookup(struct drm_device *dev, |
struct drm_file *filp, |
u32 handle); |
1663,11 → 1699,18 |
vfree(ptr); |
} |
/*@}*/ |
#endif |
static __inline__ int drm_device_is_agp(struct drm_device *dev) |
{ |
return pci_find_capability(dev->pdev, PCI_CAP_ID_AGP); |
} |
static __inline__ int drm_device_is_pcie(struct drm_device *dev) |
{ |
return pci_find_capability(dev->pdev, PCI_CAP_ID_EXP); |
} |
#endif /* __KERNEL__ */ |
#endif |
/drivers/include/drm/drmP.hh |
---|
0,0 → 1,1694 |
/** |
* \file drmP.h |
* Private header for 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. |
* |
* 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. |
*/ |
#ifndef _DRM_P_H_ |
#define _DRM_P_H_ |
#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 <linux/module.h> |
#include <linux/kernel.h> |
#include <linux/miscdevice.h> |
#include <linux/fs.h> |
#include <linux/proc_fs.h> |
#include <linux/init.h> |
#include <linux/file.h> |
#include <linux/platform_device.h> |
#include <linux/pci.h> |
#include <linux/jiffies.h> |
#include <linux/dma-mapping.h> |
#include <linux/mm.h> |
#include <linux/cdev.h> |
#include <linux/mutex.h> |
#include <linux/slab.h> |
#if defined(__alpha__) || defined(__powerpc__) |
#include <asm/pgtable.h> /* For pte_wrprotect */ |
#endif |
#include <asm/io.h> |
#include <asm/mman.h> |
#include <asm/uaccess.h> |
#ifdef CONFIG_MTRR |
#include <asm/mtrr.h> |
#endif |
#if defined(CONFIG_AGP) || defined(CONFIG_AGP_MODULE) |
#include <linux/types.h> |
#include <linux/agp_backend.h> |
#endif |
#include <linux/workqueue.h> |
#include <linux/poll.h> |
#include <asm/pgalloc.h> |
#include "drm.h" |
#include <linux/idr.h> |
#define __OS_HAS_AGP (defined(CONFIG_AGP) || (defined(CONFIG_AGP_MODULE) && defined(MODULE))) |
#define __OS_HAS_MTRR (defined(CONFIG_MTRR)) |
struct drm_file; |
struct drm_device; |
#include "drm_os_linux.h" |
#include "drm_hashtab.h" |
#include "drm_mm.h" |
#define DRM_UT_CORE 0x01 |
#define DRM_UT_DRIVER 0x02 |
#define DRM_UT_KMS 0x04 |
/* |
* Three debug levels are defined. |
* drm_core, drm_driver, drm_kms |
* drm_core level can be used in the generic drm code. For example: |
* drm_ioctl, drm_mm, drm_memory |
* The macro definition of DRM_DEBUG is used. |
* DRM_DEBUG(fmt, args...) |
* The debug info by using the DRM_DEBUG can be obtained by adding |
* the boot option of "drm.debug=1". |
* |
* drm_driver level can be used in the specific drm driver. It is used |
* to add the debug info related with the drm driver. For example: |
* i915_drv, i915_dma, i915_gem, radeon_drv, |
* The macro definition of DRM_DEBUG_DRIVER can be used. |
* DRM_DEBUG_DRIVER(fmt, args...) |
* The debug info by using the DRM_DEBUG_DRIVER can be obtained by |
* adding the boot option of "drm.debug=0x02" |
* |
* drm_kms level can be used in the KMS code related with specific drm driver. |
* It is used to add the debug info related with KMS mode. For example: |
* the connector/crtc , |
* The macro definition of DRM_DEBUG_KMS can be used. |
* DRM_DEBUG_KMS(fmt, args...) |
* The debug info by using the DRM_DEBUG_KMS can be obtained by |
* adding the boot option of "drm.debug=0x04" |
* |
* If we add the boot option of "drm.debug=0x06", we can get the debug info by |
* using the DRM_DEBUG_KMS and DRM_DEBUG_DRIVER. |
* If we add the boot option of "drm.debug=0x05", we can get the debug info by |
* using the DRM_DEBUG_KMS and DRM_DEBUG. |
*/ |
extern __attribute__((format (printf, 4, 5))) |
void drm_ut_debug_printk(unsigned int request_level, |
const char *prefix, |
const char *function_name, |
const char *format, ...); |
extern __attribute__((format (printf, 2, 3))) |
int drm_err(const char *func, const char *format, ...); |
/***********************************************************************/ |
/** \name DRM template customization defaults */ |
/*@{*/ |
/* driver capabilities and requirements mask */ |
#define DRIVER_USE_AGP 0x1 |
#define DRIVER_REQUIRE_AGP 0x2 |
#define DRIVER_USE_MTRR 0x4 |
#define DRIVER_PCI_DMA 0x8 |
#define DRIVER_SG 0x10 |
#define DRIVER_HAVE_DMA 0x20 |
#define DRIVER_HAVE_IRQ 0x40 |
#define DRIVER_IRQ_SHARED 0x80 |
#define DRIVER_IRQ_VBL 0x100 |
#define DRIVER_DMA_QUEUE 0x200 |
#define DRIVER_FB_DMA 0x400 |
#define DRIVER_IRQ_VBL2 0x800 |
#define DRIVER_GEM 0x1000 |
#define DRIVER_MODESET 0x2000 |
#define DRIVER_BUS_PCI 0x1 |
#define DRIVER_BUS_PLATFORM 0x2 |
#define DRIVER_BUS_USB 0x3 |
/***********************************************************************/ |
/** \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_KERNEL_CONTEXT 0 /**< Change drm_resctx if changed */ |
#define DRM_RESERVED_CONTEXTS 1 /**< Change drm_resctx if changed */ |
#define DRM_LOOPING_LIMIT 5000000 |
#define DRM_TIME_SLICE (HZ/20) /**< Time slice for GLXContexts */ |
#define DRM_LOCK_SLICE 1 /**< Time slice for lock, in jiffies */ |
#define DRM_FLAG_DEBUG 0x01 |
#define DRM_MAX_CTXBITMAP (PAGE_SIZE * 8) |
#define DRM_MAP_HASH_OFFSET 0x10000000 |
/*@}*/ |
/***********************************************************************/ |
/** \name Macros to make printk easier */ |
/*@{*/ |
/** |
* Error output. |
* |
* \param fmt printf() like format string. |
* \param arg arguments |
*/ |
#define DRM_ERROR(fmt, ...) \ |
drm_err(__func__, fmt, ##__VA_ARGS__) |
#define DRM_INFO(fmt, ...) \ |
printk(KERN_INFO "[" DRM_NAME "] " fmt, ##__VA_ARGS__) |
/** |
* Debug output. |
* |
* \param fmt printf() like format string. |
* \param arg arguments |
*/ |
#if DRM_DEBUG_CODE |
#define DRM_DEBUG(fmt, args...) \ |
do { \ |
drm_ut_debug_printk(DRM_UT_CORE, DRM_NAME, \ |
__func__, fmt, ##args); \ |
} while (0) |
#define DRM_DEBUG_DRIVER(fmt, args...) \ |
do { \ |
drm_ut_debug_printk(DRM_UT_DRIVER, DRM_NAME, \ |
__func__, fmt, ##args); \ |
} while (0) |
#define DRM_DEBUG_KMS(fmt, args...) \ |
do { \ |
drm_ut_debug_printk(DRM_UT_KMS, DRM_NAME, \ |
__func__, fmt, ##args); \ |
} while (0) |
#define DRM_LOG(fmt, args...) \ |
do { \ |
drm_ut_debug_printk(DRM_UT_CORE, NULL, \ |
NULL, fmt, ##args); \ |
} while (0) |
#define DRM_LOG_KMS(fmt, args...) \ |
do { \ |
drm_ut_debug_printk(DRM_UT_KMS, NULL, \ |
NULL, fmt, ##args); \ |
} while (0) |
#define DRM_LOG_MODE(fmt, args...) \ |
do { \ |
drm_ut_debug_printk(DRM_UT_MODE, NULL, \ |
NULL, fmt, ##args); \ |
} while (0) |
#define DRM_LOG_DRIVER(fmt, args...) \ |
do { \ |
drm_ut_debug_printk(DRM_UT_DRIVER, NULL, \ |
NULL, fmt, ##args); \ |
} while (0) |
#else |
#define DRM_DEBUG_DRIVER(fmt, args...) do { } while (0) |
#define DRM_DEBUG_KMS(fmt, args...) do { } while (0) |
#define DRM_DEBUG(fmt, arg...) do { } while (0) |
#define DRM_LOG(fmt, arg...) do { } while (0) |
#define DRM_LOG_KMS(fmt, args...) do { } while (0) |
#define DRM_LOG_MODE(fmt, arg...) do { } while (0) |
#define DRM_LOG_DRIVER(fmt, arg...) do { } while (0) |
#endif |
/*@}*/ |
/***********************************************************************/ |
/** \name Internal types and structures */ |
/*@{*/ |
#define DRM_ARRAY_SIZE(x) ARRAY_SIZE(x) |
#define DRM_LEFTCOUNT(x) (((x)->rp + (x)->count - (x)->wp) % ((x)->count + 1)) |
#define DRM_BUFCOUNT(x) ((x)->count - DRM_LEFTCOUNT(x)) |
#define DRM_IF_VERSION(maj, min) (maj << 16 | min) |
/** |
* 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. |
* \param file_priv DRM file private pointer. |
* \param cmd command. |
* \param arg argument. |
*/ |
typedef int drm_ioctl_t(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
typedef int drm_ioctl_compat_t(struct file *filp, unsigned int cmd, |
unsigned long arg); |
#define DRM_IOCTL_NR(n) _IOC_NR(n) |
#define DRM_MAJOR 226 |
#define DRM_AUTH 0x1 |
#define DRM_MASTER 0x2 |
#define DRM_ROOT_ONLY 0x4 |
#define DRM_CONTROL_ALLOW 0x8 |
#define DRM_UNLOCKED 0x10 |
struct drm_ioctl_desc { |
unsigned int cmd; |
int flags; |
drm_ioctl_t *func; |
unsigned int cmd_drv; |
}; |
/** |
* Creates a driver or general drm_ioctl_desc array entry for the given |
* ioctl, for use by drm_ioctl(). |
*/ |
#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} |
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 */ |
wait_queue_head_t dma_wait; /**< Processes waiting */ |
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; |
}; |
struct drm_freelist { |
int initialized; /**< Freelist in use */ |
atomic_t count; /**< Number of free buffers */ |
struct drm_buf *next; /**< End pointer */ |
wait_queue_head_t waiting; /**< Processes waiting on free bufs */ |
int low_mark; /**< Low water mark */ |
int high_mark; /**< High water mark */ |
atomic_t wfh; /**< If waiting for high mark */ |
spinlock_t lock; |
}; |
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; |
struct drm_freelist freelist; |
}; |
/* Event queued up for userspace to read */ |
struct drm_pending_event { |
struct drm_event *event; |
struct list_head link; |
struct drm_file *file_priv; |
pid_t pid; /* pid of requester, no guarantee it's valid by the time |
we deliver the event, for tracing only */ |
void (*destroy)(struct drm_pending_event *event); |
}; |
/** File private data */ |
struct drm_file { |
int authenticated; |
pid_t pid; |
uid_t uid; |
drm_magic_t magic; |
unsigned long ioctl_count; |
struct list_head lhead; |
struct drm_minor *minor; |
unsigned long lock_count; |
/** Mapping of mm object handles to object pointers. */ |
struct idr object_idr; |
/** Lock for synchronization of access to object_idr. */ |
spinlock_t table_lock; |
struct file *filp; |
void *driver_priv; |
int is_master; /* this file private is a master for a minor */ |
struct drm_master *master; /* master this node is currently associated with |
N.B. not always minor->master */ |
struct list_head fbs; |
wait_queue_head_t event_wait; |
struct list_head event_list; |
int event_space; |
}; |
/** Wait queue */ |
struct drm_queue { |
atomic_t use_count; /**< Outstanding uses (+1) */ |
atomic_t finalization; /**< Finalization in progress */ |
atomic_t block_count; /**< Count of processes waiting */ |
atomic_t block_read; /**< Queue blocked for reads */ |
wait_queue_head_t read_queue; /**< Processes waiting on block_read */ |
atomic_t block_write; /**< Queue blocked for writes */ |
wait_queue_head_t write_queue; /**< Processes waiting on block_write */ |
atomic_t total_queued; /**< Total queued statistic */ |
atomic_t total_flushed; /**< Total flushes statistic */ |
atomic_t total_locks; /**< Total locks statistics */ |
enum drm_ctx_flags flags; /**< Context preserving and 2D-only */ |
struct drm_waitlist waitlist; /**< Pending buffers */ |
wait_queue_head_t flush_queue; /**< Processes waiting until flush */ |
}; |
/** |
* Lock data. |
*/ |
struct drm_lock_data { |
struct drm_hw_lock *hw_lock; /**< Hardware lock */ |
/** Private of lock holder's file (NULL=kernel) */ |
struct drm_file *file_priv; |
wait_queue_head_t lock_queue; /**< Queue of blocked processes */ |
unsigned long lock_time; /**< Time of last lock in jiffies */ |
spinlock_t spinlock; |
uint32_t kernel_waiters; |
uint32_t user_waiters; |
int idle_has_lock; |
}; |
/** |
* 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 */ |
DRM_AGP_MEM *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 { |
DRM_AGP_KERN 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; |
}; |
/** |
* 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; |
struct drm_mm_node *file_offset_node; /**< fake offset */ |
}; |
/** |
* Context handle list |
*/ |
struct drm_ctx_list { |
struct list_head head; /**< list head */ |
drm_context_t handle; /**< context handle */ |
struct drm_file *tag; /**< associated fd private data */ |
}; |
/* 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; |
}; |
/** |
* GEM specific mm private for tracking GEM objects |
*/ |
struct drm_gem_mm { |
struct drm_mm offset_manager; /**< Offset mgmt for buffer objects */ |
struct drm_open_hash offset_hash; /**< User token hash table for maps */ |
}; |
/** |
* 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 of this object. Each handle also holds a reference */ |
atomic_t handle_count; /* number of handles on this object */ |
/** Related drm device */ |
struct drm_device *dev; |
/** File representing the shmem storage */ |
struct file *filp; |
/* Mapping info for this object */ |
struct drm_map_list map_list; |
/** |
* 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; |
void *driver_private; |
}; |
#include "drm_crtc.h" |
/* per-master structure */ |
struct drm_master { |
struct kref refcount; /* refcount for this master */ |
struct list_head head; /**< each minor contains a list of masters */ |
struct drm_minor *minor; /**< link back to minor we are a master for */ |
char *unique; /**< Unique identifier: e.g., busid */ |
int unique_len; /**< Length of unique field */ |
int unique_size; /**< amount allocated */ |
int blocked; /**< Blocked due to VC switch? */ |
/** \name Authentication */ |
/*@{ */ |
struct drm_open_hash magiclist; |
struct list_head magicfree; |
/*@} */ |
struct drm_lock_data lock; /**< Information on hardware lock */ |
void *driver_priv; /**< Private structure for driver to use */ |
}; |
/* Size of ringbuffer for vblank timestamps. Just double-buffer |
* in initial implementation. |
*/ |
#define DRM_VBLANKTIME_RBSIZE 2 |
/* 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) |
struct drm_bus { |
int bus_type; |
int (*get_irq)(struct drm_device *dev); |
const char *(*get_name)(struct drm_device *dev); |
int (*set_busid)(struct drm_device *dev, struct drm_master *master); |
int (*set_unique)(struct drm_device *dev, struct drm_master *master, |
struct drm_unique *unique); |
int (*irq_by_busid)(struct drm_device *dev, struct drm_irq_busid *p); |
/* hooks that are for PCI */ |
int (*agp_init)(struct drm_device *dev); |
}; |
/** |
* DRM driver structure. This structure represent the common code for |
* a family of cards. There will one drm_device for each card present |
* in this family |
*/ |
struct drm_driver { |
int (*load) (struct drm_device *, unsigned long flags); |
int (*firstopen) (struct drm_device *); |
int (*open) (struct drm_device *, struct drm_file *); |
void (*preclose) (struct drm_device *, struct drm_file *file_priv); |
void (*postclose) (struct drm_device *, struct drm_file *); |
void (*lastclose) (struct drm_device *); |
int (*unload) (struct drm_device *); |
int (*suspend) (struct drm_device *, pm_message_t state); |
int (*resume) (struct drm_device *); |
int (*dma_ioctl) (struct drm_device *dev, void *data, struct drm_file *file_priv); |
int (*dma_quiescent) (struct drm_device *); |
int (*context_dtor) (struct drm_device *dev, int context); |
/** |
* get_vblank_counter - get raw hardware vblank counter |
* @dev: DRM device |
* @crtc: counter to fetch |
* |
* Driver callback for fetching a raw hardware vblank counter |
* for @crtc. If a device doesn't have a hardware counter, the |
* driver can simply return the value of drm_vblank_count and |
* make the enable_vblank() and disable_vblank() hooks into no-ops, |
* leaving interrupts enabled at all times. |
* |
* Wraparound handling and loss of events due to modesetting is dealt |
* with in the DRM core code. |
* |
* RETURNS |
* Raw vblank counter value. |
*/ |
u32 (*get_vblank_counter) (struct drm_device *dev, int crtc); |
/** |
* enable_vblank - enable vblank interrupt events |
* @dev: DRM device |
* @crtc: which irq to enable |
* |
* Enable vblank interrupts for @crtc. If the device doesn't have |
* a hardware vblank counter, this routine should be a no-op, since |
* interrupts will have to stay on to keep the count accurate. |
* |
* RETURNS |
* Zero on success, appropriate errno if the given @crtc's vblank |
* interrupt cannot be enabled. |
*/ |
int (*enable_vblank) (struct drm_device *dev, int crtc); |
/** |
* disable_vblank - disable vblank interrupt events |
* @dev: DRM device |
* @crtc: which irq to enable |
* |
* Disable vblank interrupts for @crtc. If the device doesn't have |
* a hardware vblank counter, this routine should be a no-op, since |
* interrupts will have to stay on to keep the count accurate. |
*/ |
void (*disable_vblank) (struct drm_device *dev, int crtc); |
/** |
* Called by \c drm_device_is_agp. Typically used to determine if a |
* card is really attached to AGP or not. |
* |
* \param dev DRM device handle |
* |
* \returns |
* One of three values is returned depending on whether or not the |
* card is absolutely \b not AGP (return of 0), absolutely \b is AGP |
* (return of 1), or may or may not be AGP (return of 2). |
*/ |
int (*device_is_agp) (struct drm_device *dev); |
/** |
* Called by vblank timestamping code. |
* |
* Return the current display scanout position from a crtc. |
* |
* \param dev DRM device. |
* \param crtc Id of the crtc to query. |
* \param *vpos Target location for current vertical scanout position. |
* \param *hpos Target location for current horizontal scanout position. |
* |
* Returns vpos as a positive number while in active scanout area. |
* Returns vpos as a negative number inside vblank, counting the number |
* of scanlines to go until end of vblank, e.g., -1 means "one scanline |
* until start of active scanout / end of vblank." |
* |
* \return Flags, or'ed together as follows: |
* |
* DRM_SCANOUTPOS_VALID = Query successful. |
* DRM_SCANOUTPOS_INVBL = Inside vblank. |
* DRM_SCANOUTPOS_ACCURATE = Returned position is accurate. A lack of |
* this flag means that returned position may be offset by a constant |
* but unknown small number of scanlines wrt. real scanout position. |
* |
*/ |
int (*get_scanout_position) (struct drm_device *dev, int crtc, |
int *vpos, int *hpos); |
/** |
* Called by \c drm_get_last_vbltimestamp. Should return a precise |
* timestamp when the most recent VBLANK interval ended or will end. |
* |
* Specifically, the timestamp in @vblank_time should correspond as |
* closely as possible to the time when the first video scanline of |
* the video frame after the end of VBLANK will start scanning out, |
* the time immmediately after end of the VBLANK interval. If the |
* @crtc is currently inside VBLANK, this will be a time in the future. |
* If the @crtc is currently scanning out a frame, this will be the |
* past start time of the current scanout. This is meant to adhere |
* to the OpenML OML_sync_control extension specification. |
* |
* \param dev dev DRM device handle. |
* \param crtc crtc for which timestamp should be returned. |
* \param *max_error Maximum allowable timestamp error in nanoseconds. |
* Implementation should strive to provide timestamp |
* with an error of at most *max_error nanoseconds. |
* Returns true upper bound on error for timestamp. |
* \param *vblank_time Target location for returned vblank timestamp. |
* \param flags 0 = Defaults, no special treatment needed. |
* \param DRM_CALLED_FROM_VBLIRQ = Function is called from vblank |
* irq handler. Some drivers need to apply some workarounds |
* for gpu-specific vblank irq quirks if flag is set. |
* |
* \returns |
* Zero if timestamping isn't supported in current display mode or a |
* negative number on failure. A positive status code on success, |
* which describes how the vblank_time timestamp was computed. |
*/ |
int (*get_vblank_timestamp) (struct drm_device *dev, int crtc, |
int *max_error, |
struct timeval *vblank_time, |
unsigned flags); |
/* these have to be filled in */ |
irqreturn_t(*irq_handler) (DRM_IRQ_ARGS); |
void (*irq_preinstall) (struct drm_device *dev); |
int (*irq_postinstall) (struct drm_device *dev); |
void (*irq_uninstall) (struct drm_device *dev); |
void (*reclaim_buffers) (struct drm_device *dev, |
struct drm_file * file_priv); |
void (*reclaim_buffers_locked) (struct drm_device *dev, |
struct drm_file *file_priv); |
void (*reclaim_buffers_idlelocked) (struct drm_device *dev, |
struct drm_file *file_priv); |
void (*set_version) (struct drm_device *dev, |
struct drm_set_version *sv); |
/* Master routines */ |
int (*master_create)(struct drm_device *dev, struct drm_master *master); |
void (*master_destroy)(struct drm_device *dev, struct drm_master *master); |
/** |
* master_set is called whenever the minor master is set. |
* master_drop is called whenever the minor master is dropped. |
*/ |
int (*master_set)(struct drm_device *dev, struct drm_file *file_priv, |
bool from_open); |
void (*master_drop)(struct drm_device *dev, struct drm_file *file_priv, |
bool from_release); |
int (*debugfs_init)(struct drm_minor *minor); |
void (*debugfs_cleanup)(struct drm_minor *minor); |
/** |
* Driver-specific constructor for drm_gem_objects, to set up |
* obj->driver_private. |
* |
* Returns 0 on success. |
*/ |
int (*gem_init_object) (struct drm_gem_object *obj); |
void (*gem_free_object) (struct drm_gem_object *obj); |
int (*gem_open_object) (struct drm_gem_object *, struct drm_file *); |
void (*gem_close_object) (struct drm_gem_object *, struct drm_file *); |
/* vga arb irq handler */ |
void (*vgaarb_irq)(struct drm_device *dev, bool state); |
/* dumb alloc support */ |
int (*dumb_create)(struct drm_file *file_priv, |
struct drm_device *dev, |
struct drm_mode_create_dumb *args); |
int (*dumb_map_offset)(struct drm_file *file_priv, |
struct drm_device *dev, uint32_t handle, |
uint64_t *offset); |
int (*dumb_destroy)(struct drm_file *file_priv, |
struct drm_device *dev, |
uint32_t handle); |
/* Driver private ops for this object */ |
struct vm_operations_struct *gem_vm_ops; |
int major; |
int minor; |
int patchlevel; |
char *name; |
char *desc; |
char *date; |
u32 driver_features; |
int dev_priv_size; |
struct drm_ioctl_desc *ioctls; |
int num_ioctls; |
struct file_operations fops; |
union { |
struct pci_driver *pci; |
struct platform_device *platform_device; |
struct usb_driver *usb; |
} kdriver; |
struct drm_bus *bus; |
/* List of devices hanging off this driver */ |
struct list_head device_list; |
}; |
#define DRM_MINOR_UNASSIGNED 0 |
#define DRM_MINOR_LEGACY 1 |
#define DRM_MINOR_CONTROL 2 |
#define DRM_MINOR_RENDER 3 |
/** |
* debugfs node list. This structure represents a debugfs file to |
* be created by the drm core |
*/ |
struct drm_debugfs_list { |
const char *name; /** file name */ |
int (*show)(struct seq_file*, void*); /** show callback */ |
u32 driver_features; /**< Required driver features for this entry */ |
}; |
/** |
* debugfs node structure. This structure represents a debugfs file. |
*/ |
struct drm_debugfs_node { |
struct list_head list; |
struct drm_minor *minor; |
struct drm_debugfs_list *debugfs_ent; |
struct dentry *dent; |
}; |
/** |
* Info file list entry. This structure represents a debugfs or proc file to |
* be created by the drm core |
*/ |
struct drm_info_list { |
const char *name; /** file name */ |
int (*show)(struct seq_file*, void*); /** show callback */ |
u32 driver_features; /**< Required driver features for this entry */ |
void *data; |
}; |
/** |
* debugfs node structure. This structure represents a debugfs file. |
*/ |
struct drm_info_node { |
struct list_head list; |
struct drm_minor *minor; |
struct drm_info_list *info_ent; |
struct dentry *dent; |
}; |
/** |
* DRM minor structure. This structure represents a drm minor number. |
*/ |
struct drm_minor { |
int index; /**< Minor device number */ |
int type; /**< Control or render */ |
dev_t device; /**< Device number for mknod */ |
struct device kdev; /**< Linux device */ |
struct drm_device *dev; |
struct proc_dir_entry *proc_root; /**< proc directory entry */ |
struct drm_info_node proc_nodes; |
struct dentry *debugfs_root; |
struct drm_info_node debugfs_nodes; |
struct drm_master *master; /* currently active master for this node */ |
struct list_head master_list; |
struct drm_mode_group mode_group; |
}; |
/* mode specified on the command line */ |
struct drm_cmdline_mode { |
bool specified; |
bool refresh_specified; |
bool bpp_specified; |
int xres, yres; |
int bpp; |
int refresh; |
bool rb; |
bool interlace; |
bool cvt; |
bool margins; |
enum drm_connector_force force; |
}; |
struct drm_pending_vblank_event { |
struct drm_pending_event base; |
int pipe; |
struct drm_event_vblank event; |
}; |
/** |
* DRM device structure. This structure represent a complete card that |
* may contain multiple heads. |
*/ |
struct drm_device { |
struct list_head driver_item; /**< list of devices per driver */ |
char *devname; /**< For /proc/interrupts */ |
int if_version; /**< Highest interface version set */ |
/** \name Locks */ |
/*@{ */ |
spinlock_t count_lock; /**< For inuse, drm_device::open_count, drm_device::buf_use */ |
struct mutex struct_mutex; /**< For others */ |
/*@} */ |
/** \name Usage Counters */ |
/*@{ */ |
int open_count; /**< Outstanding files open */ |
atomic_t ioctl_count; /**< Outstanding IOCTLs pending */ |
atomic_t vma_count; /**< Outstanding vma areas open */ |
int buf_use; /**< Buffers in use -- cannot alloc */ |
atomic_t buf_alloc; /**< Buffer allocation in progress */ |
/*@} */ |
/** \name Performance counters */ |
/*@{ */ |
unsigned long counters; |
enum drm_stat_type types[15]; |
atomic_t counts[15]; |
/*@} */ |
struct list_head filelist; |
/** \name Memory management */ |
/*@{ */ |
struct list_head maplist; /**< Linked list of regions */ |
int map_count; /**< Number of mappable regions */ |
struct drm_open_hash map_hash; /**< User token hash table for maps */ |
/** \name Context handle management */ |
/*@{ */ |
struct list_head ctxlist; /**< Linked list of context handles */ |
int ctx_count; /**< Number of context handles */ |
struct mutex ctxlist_mutex; /**< For ctxlist */ |
struct idr ctx_idr; |
struct list_head vmalist; /**< List of vmas (for debugging) */ |
/*@} */ |
/** \name DMA queues (contexts) */ |
/*@{ */ |
int queue_count; /**< Number of active DMA queues */ |
int queue_reserved; /**< Number of reserved DMA queues */ |
int queue_slots; /**< Actual length of queuelist */ |
struct drm_queue **queuelist; /**< Vector of pointers to DMA queues */ |
struct drm_device_dma *dma; /**< Optional pointer for DMA support */ |
/*@} */ |
/** \name Context support */ |
/*@{ */ |
int irq_enabled; /**< True if irq handler is enabled */ |
__volatile__ long context_flag; /**< Context swapping flag */ |
__volatile__ long interrupt_flag; /**< Interruption handler flag */ |
__volatile__ long dma_flag; /**< DMA dispatch flag */ |
wait_queue_head_t context_wait; /**< Processes waiting on ctx switch */ |
int last_checked; /**< Last context checked for DMA */ |
int last_context; /**< Last current context */ |
unsigned long last_switch; /**< jiffies at last context switch */ |
/*@} */ |
struct work_struct work; |
/** \name VBLANK IRQ support */ |
/*@{ */ |
/* |
* At load time, disabling the vblank interrupt won't be allowed since |
* old clients may not call the modeset ioctl and therefore misbehave. |
* Once the modeset ioctl *has* been called though, we can safely |
* disable them when unused. |
*/ |
int vblank_disable_allowed; |
wait_queue_head_t *vbl_queue; /**< VBLANK wait queue */ |
atomic_t *_vblank_count; /**< number of VBLANK interrupts (driver must alloc the right number of counters) */ |
struct timeval *_vblank_time; /**< timestamp of current vblank_count (drivers must alloc right number of fields) */ |
spinlock_t vblank_time_lock; /**< Protects vblank count and time updates during vblank enable/disable */ |
spinlock_t vbl_lock; |
atomic_t *vblank_refcount; /* number of users of vblank interruptsper crtc */ |
u32 *last_vblank; /* protected by dev->vbl_lock, used */ |
/* for wraparound handling */ |
int *vblank_enabled; /* so we don't call enable more than |
once per disable */ |
int *vblank_inmodeset; /* Display driver is setting mode */ |
u32 *last_vblank_wait; /* Last vblank seqno waited per CRTC */ |
struct timer_list vblank_disable_timer; |
u32 max_vblank_count; /**< size of vblank counter register */ |
/** |
* List of events |
*/ |
struct list_head vblank_event_list; |
spinlock_t event_lock; |
/*@} */ |
cycles_t ctx_start; |
cycles_t lck_start; |
struct fasync_struct *buf_async;/**< Processes waiting for SIGIO */ |
wait_queue_head_t buf_readers; /**< Processes waiting to read */ |
wait_queue_head_t buf_writers; /**< Processes waiting to ctx switch */ |
struct drm_agp_head *agp; /**< AGP data */ |
struct device *dev; /**< Device structure */ |
struct pci_dev *pdev; /**< PCI device structure */ |
int pci_vendor; /**< PCI vendor id */ |
int pci_device; /**< PCI device id */ |
#ifdef __alpha__ |
struct pci_controller *hose; |
#endif |
struct platform_device *platformdev; /**< Platform device struture */ |
struct usb_device *usbdev; |
struct drm_sg_mem *sg; /**< Scatter gather memory */ |
unsigned int num_crtcs; /**< Number of CRTCs on this device */ |
void *dev_private; /**< device private data */ |
void *mm_private; |
struct address_space *dev_mapping; |
struct drm_sigdata sigdata; /**< For block_all_signals */ |
sigset_t sigmask; |
struct drm_driver *driver; |
struct drm_local_map *agp_buffer_map; |
unsigned int agp_buffer_token; |
struct drm_minor *control; /**< Control node for card */ |
struct drm_minor *primary; /**< render type primary screen head */ |
struct drm_mode_config mode_config; /**< Current mode config */ |
/** \name GEM information */ |
/*@{ */ |
spinlock_t object_name_lock; |
struct idr object_name_idr; |
/*@} */ |
int switch_power_state; |
}; |
#define DRM_SWITCH_POWER_ON 0 |
#define DRM_SWITCH_POWER_OFF 1 |
#define DRM_SWITCH_POWER_CHANGING 2 |
static __inline__ int drm_core_check_feature(struct drm_device *dev, |
int feature) |
{ |
return ((dev->driver->driver_features & feature) ? 1 : 0); |
} |
static inline int drm_dev_to_irq(struct drm_device *dev) |
{ |
return dev->driver->bus->get_irq(dev); |
} |
#if __OS_HAS_AGP |
static inline int drm_core_has_AGP(struct drm_device *dev) |
{ |
return drm_core_check_feature(dev, DRIVER_USE_AGP); |
} |
#else |
#define drm_core_has_AGP(dev) (0) |
#endif |
#if __OS_HAS_MTRR |
static inline int drm_core_has_MTRR(struct drm_device *dev) |
{ |
return drm_core_check_feature(dev, DRIVER_USE_MTRR); |
} |
#define DRM_MTRR_WC MTRR_TYPE_WRCOMB |
static inline int drm_mtrr_add(unsigned long offset, unsigned long size, |
unsigned int flags) |
{ |
return mtrr_add(offset, size, flags, 1); |
} |
static inline int drm_mtrr_del(int handle, unsigned long offset, |
unsigned long size, unsigned int flags) |
{ |
return mtrr_del(handle, offset, size); |
} |
#else |
#define drm_core_has_MTRR(dev) (0) |
#define DRM_MTRR_WC 0 |
static inline int drm_mtrr_add(unsigned long offset, unsigned long size, |
unsigned int flags) |
{ |
return 0; |
} |
static inline int drm_mtrr_del(int handle, unsigned long offset, |
unsigned long size, unsigned int flags) |
{ |
return 0; |
} |
#endif |
/******************************************************************/ |
/** \name Internal function definitions */ |
/*@{*/ |
/* Driver support (drm_drv.h) */ |
extern long drm_ioctl(struct file *filp, |
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); |
/* Device support (drm_fops.h) */ |
extern struct mutex drm_global_mutex; |
extern int drm_open(struct inode *inode, struct file *filp); |
extern int drm_stub_open(struct inode *inode, struct file *filp); |
extern int drm_fasync(int fd, struct file *filp, int on); |
extern ssize_t drm_read(struct file *filp, char __user *buffer, |
size_t count, loff_t *offset); |
extern int drm_release(struct inode *inode, struct file *filp); |
/* 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 vm_area_struct *vma); |
extern void drm_vm_close_locked(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_memory.h" |
extern void drm_mem_init(void); |
extern int drm_mem_info(char *buf, char **start, off_t offset, |
int request, int *eof, void *data); |
extern void *drm_realloc(void *oldpt, size_t oldsize, size_t size, int area); |
extern void drm_free_agp(DRM_AGP_MEM * handle, int pages); |
extern int drm_bind_agp(DRM_AGP_MEM * handle, unsigned int start); |
extern DRM_AGP_MEM *drm_agp_bind_pages(struct drm_device *dev, |
struct page **pages, |
unsigned long num_pages, |
uint32_t gtt_offset, |
uint32_t type); |
extern int drm_unbind_agp(DRM_AGP_MEM * handle); |
/* Misc. IOCTL support (drm_ioctl.h) */ |
extern int drm_irq_by_busid(struct drm_device *dev, void *data, |
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_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); |
/* Context IOCTL support (drm_context.h) */ |
extern int drm_resctx(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_addctx(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_modctx(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_getctx(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_switchctx(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_newctx(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_rmctx(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_ctxbitmap_init(struct drm_device *dev); |
extern void drm_ctxbitmap_cleanup(struct drm_device *dev); |
extern void drm_ctxbitmap_free(struct drm_device *dev, int ctx_handle); |
extern int drm_setsareactx(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_getsareactx(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); |
/* Cache management (drm_cache.c) */ |
void drm_clflush_pages(struct page *pages[], unsigned long num_pages); |
/* 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_order(unsigned long size); |
/* DMA support (drm_dma.h) */ |
extern int drm_dma_setup(struct drm_device *dev); |
extern void drm_dma_takedown(struct drm_device *dev); |
extern 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 irqreturn_t drm_irq_handler(DRM_IRQ_ARGS); |
extern int drm_irq_install(struct drm_device *dev); |
extern int drm_irq_uninstall(struct drm_device *dev); |
extern void drm_driver_irq_preinstall(struct drm_device *dev); |
extern void drm_driver_irq_postinstall(struct drm_device *dev); |
extern void drm_driver_irq_uninstall(struct drm_device *dev); |
extern int drm_vblank_init(struct drm_device *dev, int num_crtcs); |
extern int drm_wait_vblank(struct drm_device *dev, void *data, |
struct drm_file *filp); |
extern int drm_vblank_wait(struct drm_device *dev, unsigned int *vbl_seq); |
extern u32 drm_vblank_count(struct drm_device *dev, int crtc); |
extern u32 drm_vblank_count_and_time(struct drm_device *dev, int crtc, |
struct timeval *vblanktime); |
extern bool drm_handle_vblank(struct drm_device *dev, int crtc); |
extern int drm_vblank_get(struct drm_device *dev, int crtc); |
extern void drm_vblank_put(struct drm_device *dev, int crtc); |
extern void drm_vblank_off(struct drm_device *dev, int 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, |
unsigned flags, |
struct drm_crtc *refcrtc); |
extern void drm_calc_timestamping_constants(struct drm_crtc *crtc); |
extern bool |
drm_mode_parse_command_line_for_connector(const char *mode_option, |
struct drm_connector *connector, |
struct drm_cmdline_mode *mode); |
extern struct drm_display_mode * |
drm_mode_create_from_cmdline_mode(struct drm_device *dev, |
struct drm_cmdline_mode *cmd); |
/* 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) */ |
extern struct drm_agp_head *drm_agp_init(struct drm_device *dev); |
extern int drm_agp_acquire(struct drm_device *dev); |
extern int drm_agp_acquire_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_agp_release(struct drm_device *dev); |
extern int drm_agp_release_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_agp_enable(struct drm_device *dev, struct drm_agp_mode mode); |
extern int drm_agp_enable_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_agp_info(struct drm_device *dev, struct drm_agp_info *info); |
extern int drm_agp_info_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_agp_alloc(struct drm_device *dev, struct drm_agp_buffer *request); |
extern int drm_agp_alloc_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_agp_free(struct drm_device *dev, struct drm_agp_buffer *request); |
extern int drm_agp_free_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_agp_unbind(struct drm_device *dev, struct drm_agp_binding *request); |
extern int drm_agp_unbind_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_agp_bind(struct drm_device *dev, struct drm_agp_binding *request); |
extern int drm_agp_bind_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
/* Stub support (drm_stub.h) */ |
extern int drm_setmaster_ioctl(struct drm_device *dev, void *data, |
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); |
extern void drm_put_dev(struct drm_device *dev); |
extern int drm_put_minor(struct drm_minor **minor); |
extern unsigned int drm_debug; |
extern unsigned int drm_vblank_offdelay; |
extern unsigned int drm_timestamp_precision; |
extern struct class *drm_class; |
extern struct proc_dir_entry *drm_proc_root; |
extern struct dentry *drm_debugfs_root; |
extern struct idr drm_minors_idr; |
extern struct drm_local_map *drm_getsarea(struct drm_device *dev); |
/* Proc support (drm_proc.h) */ |
extern int drm_proc_init(struct drm_minor *minor, int minor_id, |
struct proc_dir_entry *root); |
extern int drm_proc_cleanup(struct drm_minor *minor, struct proc_dir_entry *root); |
/* Debugfs support */ |
#if defined(CONFIG_DEBUG_FS) |
extern int drm_debugfs_init(struct drm_minor *minor, int minor_id, |
struct dentry *root); |
extern int drm_debugfs_create_files(struct drm_info_list *files, int count, |
struct dentry *root, struct drm_minor *minor); |
extern int drm_debugfs_remove_files(struct drm_info_list *files, int count, |
struct drm_minor *minor); |
extern int drm_debugfs_cleanup(struct drm_minor *minor); |
#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_queues_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); |
#if DRM_DEBUG_CODE |
extern int drm_vma_info(struct seq_file *m, void *data); |
#endif |
/* Scatter Gather Support (drm_scatter.h) */ |
extern void drm_sg_cleanup(struct drm_sg_mem * entry); |
extern int drm_sg_alloc_ioctl(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_sg_alloc(struct drm_device *dev, struct drm_scatter_gather * request); |
extern int drm_sg_free(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
/* 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, |
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); |
/* 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 int drm_sysfs_device_add(struct drm_minor *minor); |
extern void drm_sysfs_hotplug_event(struct drm_device *dev); |
extern void drm_sysfs_device_remove(struct drm_minor *minor); |
extern char *drm_get_connector_status_name(enum drm_connector_status status); |
extern int drm_sysfs_connector_add(struct drm_connector *connector); |
extern void drm_sysfs_connector_remove(struct drm_connector *connector); |
/* 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); |
struct drm_gem_object *drm_gem_object_alloc(struct drm_device *dev, |
size_t size); |
int drm_gem_object_init(struct drm_device *dev, |
struct drm_gem_object *obj, size_t size); |
int drm_gem_private_object_init(struct drm_device *dev, |
struct drm_gem_object *obj, size_t size); |
void drm_gem_object_handle_free(struct drm_gem_object *obj); |
void drm_gem_vm_open(struct vm_area_struct *vma); |
void drm_gem_vm_close(struct vm_area_struct *vma); |
int drm_gem_mmap(struct file *filp, struct vm_area_struct *vma); |
#include "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 != NULL) { |
struct drm_device *dev = obj->dev; |
mutex_lock(&dev->struct_mutex); |
kref_put(&obj->refcount, drm_gem_object_free); |
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); |
static inline void |
drm_gem_object_handle_reference(struct drm_gem_object *obj) |
{ |
drm_gem_object_reference(obj); |
atomic_inc(&obj->handle_count); |
} |
static inline void |
drm_gem_object_handle_unreference(struct drm_gem_object *obj) |
{ |
if (obj == NULL) |
return; |
if (atomic_read(&obj->handle_count) == 0) |
return; |
/* |
* Must bump handle count first as this may be the last |
* ref, in which case the object would disappear before we |
* checked for a name |
*/ |
if (atomic_dec_and_test(&obj->handle_count)) |
drm_gem_object_handle_free(obj); |
drm_gem_object_unreference(obj); |
} |
static inline void |
drm_gem_object_handle_unreference_unlocked(struct drm_gem_object *obj) |
{ |
if (obj == NULL) |
return; |
if (atomic_read(&obj->handle_count) == 0) |
return; |
/* |
* Must bump handle count first as this may be the last |
* ref, in which case the object would disappear before we |
* checked for a name |
*/ |
if (atomic_dec_and_test(&obj->handle_count)) |
drm_gem_object_handle_free(obj); |
drm_gem_object_unreference_unlocked(obj); |
} |
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_mem_util.h" |
extern int drm_fill_in_dev(struct drm_device *dev, |
const struct pci_device_id *ent, |
struct drm_driver *driver); |
int drm_get_minor(struct drm_device *dev, struct drm_minor **minor, int type); |
/*@}*/ |
/* PCI section */ |
static __inline__ int drm_pci_device_is_agp(struct drm_device *dev) |
{ |
if (dev->driver->device_is_agp != NULL) { |
int err = (*dev->driver->device_is_agp) (dev); |
if (err != 2) { |
return err; |
} |
} |
return pci_find_capability(dev->pdev, PCI_CAP_ID_AGP); |
} |
extern int drm_pci_init(struct drm_driver *driver, struct pci_driver *pdriver); |
extern void drm_pci_exit(struct drm_driver *driver, struct pci_driver *pdriver); |
extern int drm_get_pci_dev(struct pci_dev *pdev, |
const struct pci_device_id *ent, |
struct drm_driver *driver); |
/* platform section */ |
extern int drm_platform_init(struct drm_driver *driver, struct platform_device *platform_device); |
extern void drm_platform_exit(struct drm_driver *driver, struct platform_device *platform_device); |
extern int drm_get_platform_dev(struct platform_device *pdev, |
struct drm_driver *driver); |
#endif /* __KERNEL__ */ |
#endif |
/drivers/include/drm/drm_crtc.h |
---|
29,9 → 29,10 |
#include <linux/spinlock.h> |
#include <linux/types.h> |
#include <linux/idr.h> |
#include <linux/fb.h> |
#include <drm/drm_fourcc.h> |
struct drm_device; |
struct drm_mode_set; |
struct drm_framebuffer; |
44,6 → 45,7 |
#define DRM_MODE_OBJECT_PROPERTY 0xb0b0b0b0 |
#define DRM_MODE_OBJECT_FB 0xfbfbfbfb |
#define DRM_MODE_OBJECT_BLOB 0xbbbbbbbb |
#define DRM_MODE_OBJECT_PLANE 0xeeeeeeee |
struct drm_mode_object { |
uint32_t id; |
118,7 → 120,6 |
char name[DRM_DISPLAY_MODE_LEN]; |
int connector_count; |
enum drm_mode_status status; |
int type; |
238,7 → 239,8 |
struct list_head head; |
struct drm_mode_object base; |
const struct drm_framebuffer_funcs *funcs; |
unsigned int pitch; |
unsigned int pitches[4]; |
unsigned int offsets[4]; |
unsigned int width; |
unsigned int height; |
/* depth can be 15 or 16 */ |
245,6 → 247,7 |
unsigned int depth; |
int bits_per_pixel; |
int flags; |
uint32_t pixel_format; /* fourcc format */ |
struct list_head filp_head; |
/* if you are using the helper */ |
void *helper_private; |
278,6 → 281,7 |
struct drm_connector; |
struct drm_encoder; |
struct drm_pending_vblank_event; |
struct drm_plane; |
/** |
* drm_crtc_funcs - control CRTCs for a given device |
341,10 → 345,21 |
/** |
* drm_crtc - central CRTC control structure |
* @dev: parent DRM device |
* @head: list management |
* @base: base KMS object for ID tracking etc. |
* @enabled: is this CRTC enabled? |
* @mode: current mode timings |
* @hwmode: mode timings as programmed to hw regs |
* @x: x position on screen |
* @y: y position on screen |
* @funcs: CRTC control functions |
* @gamma_size: size of gamma ramp |
* @gamma_store: gamma ramp values |
* @framedur_ns: precise frame timing |
* @framedur_ns: precise line timing |
* @pixeldur_ns: precise pixel timing |
* @helper_private: mid-layer private data |
* |
* Each CRTC may have one or more connectors associated with it. This structure |
* allows the CRTC to be controlled. |
423,6 → 438,13 |
void (*force)(struct drm_connector *connector); |
}; |
/** |
* drm_encoder_funcs - encoder controls |
* @reset: reset state (e.g. at init or resume time) |
* @destroy: cleanup and free associated data |
* |
* Encoders sit between CRTCs and connectors. |
*/ |
struct drm_encoder_funcs { |
void (*reset)(struct drm_encoder *encoder); |
void (*destroy)(struct drm_encoder *encoder); |
431,10 → 453,22 |
#define DRM_CONNECTOR_MAX_UMODES 16 |
#define DRM_CONNECTOR_MAX_PROPERTY 16 |
#define DRM_CONNECTOR_LEN 32 |
#define DRM_CONNECTOR_MAX_ENCODER 2 |
#define DRM_CONNECTOR_MAX_ENCODER 3 |
/** |
* drm_encoder - central DRM encoder structure |
* @dev: parent DRM device |
* @head: list management |
* @base: base KMS object |
* @encoder_type: one of the %DRM_MODE_ENCODER_<foo> types in drm_mode.h |
* @possible_crtcs: bitmask of potential CRTC bindings |
* @possible_clones: bitmask of potential sibling encoders for cloning |
* @crtc: currently bound CRTC |
* @funcs: control functions |
* @helper_private: mid-layer private data |
* |
* CRTCs drive pixels to encoders, which convert them into signals |
* appropriate for a given connector or set of connectors. |
*/ |
struct drm_encoder { |
struct drm_device *dev; |
466,16 → 500,41 |
/* DACs should rarely do this without a lot of testing */ |
#define DRM_CONNECTOR_POLL_DISCONNECT (1 << 2) |
#define MAX_ELD_BYTES 128 |
/** |
* drm_connector - central DRM connector control structure |
* @crtc: CRTC this connector is currently connected to, NULL if none |
* @dev: parent DRM device |
* @kdev: kernel device for sysfs attributes |
* @attr: sysfs attributes |
* @head: list management |
* @base: base KMS object |
* @connector_type: one of the %DRM_MODE_CONNECTOR_<foo> types from drm_mode.h |
* @connector_type_id: index into connector type enum |
* @interlace_allowed: can this connector handle interlaced modes? |
* @doublescan_allowed: can this connector handle doublescan? |
* @available_modes: modes available on this connector (from get_modes() + user) |
* @initial_x: initial x position for this connector |
* @initial_y: initial y position for this connector |
* @status: connector connected? |
* @modes: modes available on this connector (from fill_modes() + user) |
* @status: one of the drm_connector_status enums (connected, not, or unknown) |
* @probed_modes: list of modes derived directly from the display |
* @display_info: information about attached display (e.g. from EDID) |
* @funcs: connector control functions |
* @user_modes: user added mode list |
* @edid_blob_ptr: DRM property containing EDID if present |
* @property_ids: property tracking for this connector |
* @property_values: value pointers or data for properties |
* @polled: a %DRM_CONNECTOR_POLL_<foo> value for core driven polling |
* @dpms: current dpms state |
* @helper_private: mid-layer private data |
* @force: a %DRM_FORCE_<foo> state for forced mode sets |
* @encoder_ids: valid encoders for this connector |
* @encoder: encoder driving this connector, if any |
* @eld: EDID-like data, if present |
* @dvi_dual: dual link DVI, if found |
* @max_tmds_clock: max clock rate, if found |
* @latency_present: AV delay info from ELD, if found |
* @video_latency: video latency info from ELD, if found |
* @audio_latency: audio latency info from ELD, if found |
* @null_edid_counter: track sinks that give us all zeros for the EDID |
* |
* Each connector may be connected to one or more CRTCs, or may be clonable by |
* another connector if they can share a CRTC. Each connector also has a specific |
496,7 → 555,6 |
bool doublescan_allowed; |
struct list_head modes; /* list of modes on this connector */ |
int initial_x, initial_y; |
enum drm_connector_status status; |
/* these are modes added by probing with DDC or the BIOS */ |
520,14 → 578,84 |
/* forced on connector */ |
enum drm_connector_force force; |
uint32_t encoder_ids[DRM_CONNECTOR_MAX_ENCODER]; |
uint32_t force_encoder_id; |
struct drm_encoder *encoder; /* currently active encoder */ |
/* EDID bits */ |
uint8_t eld[MAX_ELD_BYTES]; |
bool dvi_dual; |
int max_tmds_clock; /* in MHz */ |
bool latency_present[2]; |
int video_latency[2]; /* [0]: progressive, [1]: interlaced */ |
int audio_latency[2]; |
int null_edid_counter; /* needed to workaround some HW bugs where we get all 0s */ |
}; |
/** |
* struct drm_mode_set |
* drm_plane_funcs - driver plane control functions |
* @update_plane: update the plane configuration |
* @disable_plane: shut down the plane |
* @destroy: clean up plane resources |
*/ |
struct drm_plane_funcs { |
int (*update_plane)(struct drm_plane *plane, |
struct drm_crtc *crtc, struct drm_framebuffer *fb, |
int crtc_x, int crtc_y, |
unsigned int crtc_w, unsigned int crtc_h, |
uint32_t src_x, uint32_t src_y, |
uint32_t src_w, uint32_t src_h); |
int (*disable_plane)(struct drm_plane *plane); |
void (*destroy)(struct drm_plane *plane); |
}; |
/** |
* drm_plane - central DRM plane control structure |
* @dev: DRM device this plane belongs to |
* @head: for list management |
* @base: base mode object |
* @possible_crtcs: pipes this plane can be bound to |
* @format_types: array of formats supported by this plane |
* @format_count: number of formats supported |
* @crtc: currently bound CRTC |
* @fb: currently bound fb |
* @gamma_size: size of gamma table |
* @gamma_store: gamma correction table |
* @enabled: enabled flag |
* @funcs: helper functions |
* @helper_private: storage for drver layer |
*/ |
struct drm_plane { |
struct drm_device *dev; |
struct list_head head; |
struct drm_mode_object base; |
uint32_t possible_crtcs; |
uint32_t *format_types; |
uint32_t format_count; |
struct drm_crtc *crtc; |
struct drm_framebuffer *fb; |
/* CRTC gamma size for reporting to userspace */ |
uint32_t gamma_size; |
uint16_t *gamma_store; |
bool enabled; |
const struct drm_plane_funcs *funcs; |
void *helper_private; |
}; |
/** |
* drm_mode_set - new values for a CRTC config change |
* @head: list management |
* @fb: framebuffer to use for new config |
* @crtc: CRTC whose configuration we're about to change |
* @mode: mode timings to use |
* @x: position of this CRTC relative to @fb |
* @y: position of this CRTC relative to @fb |
* @connectors: array of connectors to drive with this CRTC if possible |
* @num_connectors: size of @connectors array |
* |
* Represents a single crtc the connectors that it drives with what mode |
* and from which framebuffer it scans out from. |
549,13 → 677,33 |
}; |
/** |
* struct drm_mode_config_funcs - configure CRTCs for a given screen layout |
* struct drm_mode_config_funcs - basic driver provided mode setting functions |
* @fb_create: create a new framebuffer object |
* @output_poll_changed: function to handle output configuration changes |
* |
* Some global (i.e. not per-CRTC, connector, etc) mode setting functions that |
* involve drivers. |
*/ |
struct drm_mode_config_funcs { |
struct drm_framebuffer *(*fb_create)(struct drm_device *dev, struct drm_file *file_priv, struct drm_mode_fb_cmd *mode_cmd); |
struct drm_framebuffer *(*fb_create)(struct drm_device *dev, |
struct drm_file *file_priv, |
struct drm_mode_fb_cmd2 *mode_cmd); |
void (*output_poll_changed)(struct drm_device *dev); |
}; |
/** |
* drm_mode_group - group of mode setting resources for potential sub-grouping |
* @num_crtcs: CRTC count |
* @num_encoders: encoder count |
* @num_connectors: connector count |
* @id_list: list of KMS object IDs in this group |
* |
* Currently this simply tracks the global mode setting state. But in the |
* future it could allow groups of objects to be set aside into independent |
* control groups for use by different user level processes (e.g. two X servers |
* running simultaneously on different heads, each with their own mode |
* configuration and freedom of mode setting). |
*/ |
struct drm_mode_group { |
uint32_t num_crtcs; |
uint32_t num_encoders; |
567,7 → 715,30 |
/** |
* drm_mode_config - Mode configuration control structure |
* @mutex: mutex protecting KMS related lists and structures |
* @idr_mutex: mutex for KMS ID allocation and management |
* @crtc_idr: main KMS ID tracking object |
* @num_fb: number of fbs available |
* @fb_list: list of framebuffers available |
* @num_connector: number of connectors on this device |
* @connector_list: list of connector objects |
* @num_encoder: number of encoders on this device |
* @encoder_list: list of encoder objects |
* @num_crtc: number of CRTCs on this device |
* @crtc_list: list of CRTC objects |
* @min_width: minimum pixel width on this device |
* @min_height: minimum pixel height on this device |
* @max_width: maximum pixel width on this device |
* @max_height: maximum pixel height on this device |
* @funcs: core driver provided mode setting functions |
* @fb_base: base address of the framebuffer |
* @poll_enabled: track polling status for this device |
* @output_poll_work: delayed work for polling in process context |
* @*_property: core property tracking |
* |
* Core mode resource tracking structure. All CRTC, encoders, and connectors |
* enumerated by the driver are added here, as are global properties. Some |
* global restrictions are also here, e.g. dimension restrictions. |
*/ |
struct drm_mode_config { |
struct mutex mutex; /* protects configuration (mode lists etc.) */ |
580,6 → 751,8 |
struct list_head connector_list; |
int num_encoder; |
struct list_head encoder_list; |
int num_plane; |
struct list_head plane_list; |
int num_crtc; |
struct list_head crtc_list; |
632,6 → 805,7 |
#define obj_to_fb(x) container_of(x, struct drm_framebuffer, base) |
#define obj_to_property(x) container_of(x, struct drm_property, base) |
#define obj_to_blob(x) container_of(x, struct drm_property_blob, base) |
#define obj_to_plane(x) container_of(x, struct drm_plane, base) |
extern void drm_crtc_init(struct drm_device *dev, |
651,6 → 825,14 |
const struct drm_encoder_funcs *funcs, |
int encoder_type); |
extern int drm_plane_init(struct drm_device *dev, |
struct drm_plane *plane, |
unsigned long possible_crtcs, |
const struct drm_plane_funcs *funcs, |
const uint32_t *formats, uint32_t format_count, |
bool priv); |
extern void drm_plane_cleanup(struct drm_plane *plane); |
extern void drm_encoder_cleanup(struct drm_encoder *encoder); |
extern char *drm_get_connector_name(struct drm_connector *connector); |
744,7 → 926,8 |
/* IOCTLs */ |
extern int drm_mode_getresources(struct drm_device *dev, |
void *data, struct drm_file *file_priv); |
extern int drm_mode_getplane_res(struct drm_device *dev, void *data, |
struct drm_file *file_priv); |
extern int drm_mode_getcrtc(struct drm_device *dev, |
void *data, struct drm_file *file_priv); |
extern int drm_mode_getconnector(struct drm_device *dev, |
751,10 → 934,17 |
void *data, struct drm_file *file_priv); |
extern int drm_mode_setcrtc(struct drm_device *dev, |
void *data, struct drm_file *file_priv); |
extern int drm_mode_getplane(struct drm_device *dev, |
void *data, struct drm_file *file_priv); |
extern int drm_mode_setplane(struct drm_device *dev, |
void *data, struct drm_file *file_priv); |
extern int drm_mode_cursor_ioctl(struct drm_device *dev, |
void *data, struct drm_file *file_priv); |
extern int drm_mode_addfb(struct drm_device *dev, |
void *data, struct drm_file *file_priv); |
extern int drm_mode_addfb2(struct drm_device *dev, |
void *data, struct drm_file *file_priv); |
extern uint32_t drm_mode_legacy_fb_format(uint32_t bpp, uint32_t depth); |
extern int drm_mode_rmfb(struct drm_device *dev, |
void *data, struct drm_file *file_priv); |
extern int drm_mode_getfb(struct drm_device *dev, |
/drivers/include/drm/drm_crtc_helper.h |
---|
117,7 → 117,7 |
extern void drm_helper_connector_dpms(struct drm_connector *connector, int mode); |
extern int drm_helper_mode_fill_fb_struct(struct drm_framebuffer *fb, |
struct drm_mode_fb_cmd *mode_cmd); |
struct drm_mode_fb_cmd2 *mode_cmd); |
static inline void drm_crtc_helper_add(struct drm_crtc *crtc, |
const struct drm_crtc_helper_funcs *funcs) |
144,4 → 144,7 |
extern void drm_kms_helper_poll_disable(struct drm_device *dev); |
extern void drm_kms_helper_poll_enable(struct drm_device *dev); |
extern int drm_format_num_planes(uint32_t format); |
#endif |
/drivers/include/drm/drm_dp_helper.h |
---|
72,8 → 72,23 |
#define DP_MAIN_LINK_CHANNEL_CODING 0x006 |
#define DP_EDP_CONFIGURATION_CAP 0x00d |
#define DP_TRAINING_AUX_RD_INTERVAL 0x00e |
#define DP_PSR_SUPPORT 0x070 |
# define DP_PSR_IS_SUPPORTED 1 |
#define DP_PSR_CAPS 0x071 |
# define DP_PSR_NO_TRAIN_ON_EXIT 1 |
# define DP_PSR_SETUP_TIME_330 (0 << 1) |
# define DP_PSR_SETUP_TIME_275 (1 << 1) |
# define DP_PSR_SETUP_TIME_220 (2 << 1) |
# define DP_PSR_SETUP_TIME_165 (3 << 1) |
# define DP_PSR_SETUP_TIME_110 (4 << 1) |
# define DP_PSR_SETUP_TIME_55 (5 << 1) |
# define DP_PSR_SETUP_TIME_0 (6 << 1) |
# define DP_PSR_SETUP_TIME_MASK (7 << 1) |
# define DP_PSR_SETUP_TIME_SHIFT 1 |
/* link configuration */ |
#define DP_LINK_BW_SET 0x100 |
# define DP_LINK_BW_1_62 0x06 |
133,6 → 148,20 |
#define DP_MAIN_LINK_CHANNEL_CODING_SET 0x108 |
# define DP_SET_ANSI_8B10B (1 << 0) |
#define DP_PSR_EN_CFG 0x170 |
# define DP_PSR_ENABLE (1 << 0) |
# define DP_PSR_MAIN_LINK_ACTIVE (1 << 1) |
# define DP_PSR_CRC_VERIFICATION (1 << 2) |
# define DP_PSR_FRAME_CAPTURE (1 << 3) |
#define DP_DEVICE_SERVICE_IRQ_VECTOR 0x201 |
# define DP_REMOTE_CONTROL_COMMAND_PENDING (1 << 0) |
# define DP_AUTOMATED_TEST_REQUEST (1 << 1) |
# define DP_CP_IRQ (1 << 2) |
# define DP_SINK_SPECIFIC_IRQ (1 << 6) |
#define DP_EDP_CONFIGURATION_SET 0x10a |
#define DP_LANE0_1_STATUS 0x202 |
#define DP_LANE2_3_STATUS 0x203 |
# define DP_LANE_CR_DONE (1 << 0) |
165,10 → 194,45 |
# define DP_ADJUST_PRE_EMPHASIS_LANE1_MASK 0xc0 |
# define DP_ADJUST_PRE_EMPHASIS_LANE1_SHIFT 6 |
#define DP_TEST_REQUEST 0x218 |
# define DP_TEST_LINK_TRAINING (1 << 0) |
# define DP_TEST_LINK_PATTERN (1 << 1) |
# define DP_TEST_LINK_EDID_READ (1 << 2) |
# define DP_TEST_LINK_PHY_TEST_PATTERN (1 << 3) /* DPCD >= 1.1 */ |
#define DP_TEST_LINK_RATE 0x219 |
# define DP_LINK_RATE_162 (0x6) |
# define DP_LINK_RATE_27 (0xa) |
#define DP_TEST_LANE_COUNT 0x220 |
#define DP_TEST_PATTERN 0x221 |
#define DP_TEST_RESPONSE 0x260 |
# define DP_TEST_ACK (1 << 0) |
# define DP_TEST_NAK (1 << 1) |
# define DP_TEST_EDID_CHECKSUM_WRITE (1 << 2) |
#define DP_SET_POWER 0x600 |
# define DP_SET_POWER_D0 0x1 |
# define DP_SET_POWER_D3 0x2 |
#define DP_PSR_ERROR_STATUS 0x2006 |
# define DP_PSR_LINK_CRC_ERROR (1 << 0) |
# define DP_PSR_RFB_STORAGE_ERROR (1 << 1) |
#define DP_PSR_ESI 0x2007 |
# define DP_PSR_CAPS_CHANGE (1 << 0) |
#define DP_PSR_STATUS 0x2008 |
# define DP_PSR_SINK_INACTIVE 0 |
# define DP_PSR_SINK_ACTIVE_SRC_SYNCED 1 |
# define DP_PSR_SINK_ACTIVE_RFB 2 |
# define DP_PSR_SINK_ACTIVE_SINK_SYNCED 3 |
# define DP_PSR_SINK_ACTIVE_RESYNC 4 |
# define DP_PSR_SINK_INTERNAL_ERROR 7 |
# define DP_PSR_SINK_STATE_MASK 0x07 |
#define MODE_I2C_START 1 |
#define MODE_I2C_WRITE 2 |
#define MODE_I2C_READ 4 |
/drivers/include/drm/drm_edid.h |
---|
230,4 → 230,13 |
#define EDID_PRODUCT_ID(e) ((e)->prod_code[0] | ((e)->prod_code[1] << 8)) |
struct drm_encoder; |
struct drm_connector; |
struct drm_display_mode; |
void drm_edid_to_eld(struct drm_connector *connector, struct edid *edid); |
int drm_av_sync_delay(struct drm_connector *connector, |
struct drm_display_mode *mode); |
struct drm_connector *drm_select_eld(struct drm_encoder *encoder, |
struct drm_display_mode *mode); |
#endif /* __DRM_EDID_H__ */ |
/drivers/include/drm/drm_fourcc.h |
---|
0,0 → 1,137 |
/* |
* Copyright 2011 Intel Corporation |
* |
* Permission is hereby granted, free of charge, to any person obtaining a |
* copy of this software and associated documentation files (the "Software"), |
* to deal in the Software without restriction, including without limitation |
* the rights to use, copy, modify, merge, publish, distribute, sublicense, |
* and/or sell copies of the Software, and to permit persons to whom the |
* Software is furnished to do so, subject to the following conditions: |
* |
* The above copyright notice and this permission notice (including the next |
* paragraph) shall be included in all copies or substantial portions of the |
* Software. |
* |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
* 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. |
*/ |
#ifndef DRM_FOURCC_H |
#define DRM_FOURCC_H |
#include <linux/types.h> |
#define fourcc_code(a, b, c, d) ((__u32)(a) | ((__u32)(b) << 8) | \ |
((__u32)(c) << 16) | ((__u32)(d) << 24)) |
#define DRM_FORMAT_BIG_ENDIAN (1<<31) /* format is big endian instead of little endian */ |
/* color index */ |
#define DRM_FORMAT_C8 fourcc_code('C', '8', ' ', ' ') /* [7:0] C */ |
/* 8 bpp RGB */ |
#define DRM_FORMAT_RGB332 fourcc_code('R', 'G', 'B', '8') /* [7:0] R:G:B 3:3:2 */ |
#define DRM_FORMAT_BGR233 fourcc_code('B', 'G', 'R', '8') /* [7:0] B:G:R 2:3:3 */ |
/* 16 bpp RGB */ |
#define DRM_FORMAT_XRGB4444 fourcc_code('X', 'R', '1', '2') /* [15:0] x:R:G:B 4:4:4:4 little endian */ |
#define DRM_FORMAT_XBGR4444 fourcc_code('X', 'B', '1', '2') /* [15:0] x:B:G:R 4:4:4:4 little endian */ |
#define DRM_FORMAT_RGBX4444 fourcc_code('R', 'X', '1', '2') /* [15:0] R:G:B:x 4:4:4:4 little endian */ |
#define DRM_FORMAT_BGRX4444 fourcc_code('B', 'X', '1', '2') /* [15:0] B:G:R:x 4:4:4:4 little endian */ |
#define DRM_FORMAT_ARGB4444 fourcc_code('A', 'R', '1', '2') /* [15:0] A:R:G:B 4:4:4:4 little endian */ |
#define DRM_FORMAT_ABGR4444 fourcc_code('A', 'B', '1', '2') /* [15:0] A:B:G:R 4:4:4:4 little endian */ |
#define DRM_FORMAT_RGBA4444 fourcc_code('R', 'A', '1', '2') /* [15:0] R:G:B:A 4:4:4:4 little endian */ |
#define DRM_FORMAT_BGRA4444 fourcc_code('B', 'A', '1', '2') /* [15:0] B:G:R:A 4:4:4:4 little endian */ |
#define DRM_FORMAT_XRGB1555 fourcc_code('X', 'R', '1', '5') /* [15:0] x:R:G:B 1:5:5:5 little endian */ |
#define DRM_FORMAT_XBGR1555 fourcc_code('X', 'B', '1', '5') /* [15:0] x:B:G:R 1:5:5:5 little endian */ |
#define DRM_FORMAT_RGBX5551 fourcc_code('R', 'X', '1', '5') /* [15:0] R:G:B:x 5:5:5:1 little endian */ |
#define DRM_FORMAT_BGRX5551 fourcc_code('B', 'X', '1', '5') /* [15:0] B:G:R:x 5:5:5:1 little endian */ |
#define DRM_FORMAT_ARGB1555 fourcc_code('A', 'R', '1', '5') /* [15:0] A:R:G:B 1:5:5:5 little endian */ |
#define DRM_FORMAT_ABGR1555 fourcc_code('A', 'B', '1', '5') /* [15:0] A:B:G:R 1:5:5:5 little endian */ |
#define DRM_FORMAT_RGBA5551 fourcc_code('R', 'A', '1', '5') /* [15:0] R:G:B:A 5:5:5:1 little endian */ |
#define DRM_FORMAT_BGRA5551 fourcc_code('B', 'A', '1', '5') /* [15:0] B:G:R:A 5:5:5:1 little endian */ |
#define DRM_FORMAT_RGB565 fourcc_code('R', 'G', '1', '6') /* [15:0] R:G:B 5:6:5 little endian */ |
#define DRM_FORMAT_BGR565 fourcc_code('B', 'G', '1', '6') /* [15:0] B:G:R 5:6:5 little endian */ |
/* 24 bpp RGB */ |
#define DRM_FORMAT_RGB888 fourcc_code('R', 'G', '2', '4') /* [23:0] R:G:B little endian */ |
#define DRM_FORMAT_BGR888 fourcc_code('B', 'G', '2', '4') /* [23:0] B:G:R little endian */ |
/* 32 bpp RGB */ |
#define DRM_FORMAT_XRGB8888 fourcc_code('X', 'R', '2', '4') /* [31:0] x:R:G:B 8:8:8:8 little endian */ |
#define DRM_FORMAT_XBGR8888 fourcc_code('X', 'B', '2', '4') /* [31:0] x:B:G:R 8:8:8:8 little endian */ |
#define DRM_FORMAT_RGBX8888 fourcc_code('R', 'X', '2', '4') /* [31:0] R:G:B:x 8:8:8:8 little endian */ |
#define DRM_FORMAT_BGRX8888 fourcc_code('B', 'X', '2', '4') /* [31:0] B:G:R:x 8:8:8:8 little endian */ |
#define DRM_FORMAT_ARGB8888 fourcc_code('A', 'R', '2', '4') /* [31:0] A:R:G:B 8:8:8:8 little endian */ |
#define DRM_FORMAT_ABGR8888 fourcc_code('A', 'B', '2', '4') /* [31:0] A:B:G:R 8:8:8:8 little endian */ |
#define DRM_FORMAT_RGBA8888 fourcc_code('R', 'A', '2', '4') /* [31:0] R:G:B:A 8:8:8:8 little endian */ |
#define DRM_FORMAT_BGRA8888 fourcc_code('B', 'A', '2', '4') /* [31:0] B:G:R:A 8:8:8:8 little endian */ |
#define DRM_FORMAT_XRGB2101010 fourcc_code('X', 'R', '3', '0') /* [31:0] x:R:G:B 2:10:10:10 little endian */ |
#define DRM_FORMAT_XBGR2101010 fourcc_code('X', 'B', '3', '0') /* [31:0] x:B:G:R 2:10:10:10 little endian */ |
#define DRM_FORMAT_RGBX1010102 fourcc_code('R', 'X', '3', '0') /* [31:0] R:G:B:x 10:10:10:2 little endian */ |
#define DRM_FORMAT_BGRX1010102 fourcc_code('B', 'X', '3', '0') /* [31:0] B:G:R:x 10:10:10:2 little endian */ |
#define DRM_FORMAT_ARGB2101010 fourcc_code('A', 'R', '3', '0') /* [31:0] A:R:G:B 2:10:10:10 little endian */ |
#define DRM_FORMAT_ABGR2101010 fourcc_code('A', 'B', '3', '0') /* [31:0] A:B:G:R 2:10:10:10 little endian */ |
#define DRM_FORMAT_RGBA1010102 fourcc_code('R', 'A', '3', '0') /* [31:0] R:G:B:A 10:10:10:2 little endian */ |
#define DRM_FORMAT_BGRA1010102 fourcc_code('B', 'A', '3', '0') /* [31:0] B:G:R:A 10:10:10:2 little endian */ |
/* packed YCbCr */ |
#define DRM_FORMAT_YUYV fourcc_code('Y', 'U', 'Y', 'V') /* [31:0] Cr0:Y1:Cb0:Y0 8:8:8:8 little endian */ |
#define DRM_FORMAT_YVYU fourcc_code('Y', 'V', 'Y', 'U') /* [31:0] Cb0:Y1:Cr0:Y0 8:8:8:8 little endian */ |
#define DRM_FORMAT_UYVY fourcc_code('U', 'Y', 'V', 'Y') /* [31:0] Y1:Cr0:Y0:Cb0 8:8:8:8 little endian */ |
#define DRM_FORMAT_VYUY fourcc_code('V', 'Y', 'U', 'Y') /* [31:0] Y1:Cb0:Y0:Cr0 8:8:8:8 little endian */ |
#define DRM_FORMAT_AYUV fourcc_code('A', 'Y', 'U', 'V') /* [31:0] A:Y:Cb:Cr 8:8:8:8 little endian */ |
/* |
* 2 plane YCbCr |
* index 0 = Y plane, [7:0] Y |
* index 1 = Cr:Cb plane, [15:0] Cr:Cb little endian |
* or |
* index 1 = Cb:Cr plane, [15:0] Cb:Cr little endian |
*/ |
#define DRM_FORMAT_NV12 fourcc_code('N', 'V', '1', '2') /* 2x2 subsampled Cr:Cb plane */ |
#define DRM_FORMAT_NV21 fourcc_code('N', 'V', '2', '1') /* 2x2 subsampled Cb:Cr plane */ |
#define DRM_FORMAT_NV16 fourcc_code('N', 'V', '1', '6') /* 2x1 subsampled Cr:Cb plane */ |
#define DRM_FORMAT_NV61 fourcc_code('N', 'V', '6', '1') /* 2x1 subsampled Cb:Cr plane */ |
/* 2 non contiguous plane YCbCr */ |
#define DRM_FORMAT_NV12M fourcc_code('N', 'M', '1', '2') /* 2x2 subsampled Cr:Cb plane */ |
#define DRM_FORMAT_NV12MT fourcc_code('T', 'M', '1', '2') /* 2x2 subsampled Cr:Cb plane 64x32 macroblocks */ |
/* |
* 3 plane YCbCr |
* index 0: Y plane, [7:0] Y |
* index 1: Cb plane, [7:0] Cb |
* index 2: Cr plane, [7:0] Cr |
* or |
* index 1: Cr plane, [7:0] Cr |
* index 2: Cb plane, [7:0] Cb |
*/ |
#define DRM_FORMAT_YUV410 fourcc_code('Y', 'U', 'V', '9') /* 4x4 subsampled Cb (1) and Cr (2) planes */ |
#define DRM_FORMAT_YVU410 fourcc_code('Y', 'V', 'U', '9') /* 4x4 subsampled Cr (1) and Cb (2) planes */ |
#define DRM_FORMAT_YUV411 fourcc_code('Y', 'U', '1', '1') /* 4x1 subsampled Cb (1) and Cr (2) planes */ |
#define DRM_FORMAT_YVU411 fourcc_code('Y', 'V', '1', '1') /* 4x1 subsampled Cr (1) and Cb (2) planes */ |
#define DRM_FORMAT_YUV420 fourcc_code('Y', 'U', '1', '2') /* 2x2 subsampled Cb (1) and Cr (2) planes */ |
#define DRM_FORMAT_YVU420 fourcc_code('Y', 'V', '1', '2') /* 2x2 subsampled Cr (1) and Cb (2) planes */ |
#define DRM_FORMAT_YUV422 fourcc_code('Y', 'U', '1', '6') /* 2x1 subsampled Cb (1) and Cr (2) planes */ |
#define DRM_FORMAT_YVU422 fourcc_code('Y', 'V', '1', '6') /* 2x1 subsampled Cr (1) and Cb (2) planes */ |
#define DRM_FORMAT_YUV444 fourcc_code('Y', 'U', '2', '4') /* non-subsampled Cb (1) and Cr (2) planes */ |
#define DRM_FORMAT_YVU444 fourcc_code('Y', 'V', '2', '4') /* non-subsampled Cr (1) and Cb (2) planes */ |
/* 3 non contiguous plane YCbCr */ |
#define DRM_FORMAT_YUV420M fourcc_code('Y', 'M', '1', '2') /* 2x2 subsampled Cb (1) and Cr (2) planes */ |
#endif /* DRM_FOURCC_H */ |
/drivers/include/drm/drm_mode.h |
---|
120,11 → 120,49 |
struct drm_mode_modeinfo mode; |
}; |
#define DRM_MODE_PRESENT_TOP_FIELD (1<<0) |
#define DRM_MODE_PRESENT_BOTTOM_FIELD (1<<1) |
/* Planes blend with or override other bits on the CRTC */ |
struct drm_mode_set_plane { |
__u32 plane_id; |
__u32 crtc_id; |
__u32 fb_id; /* fb object contains surface format type */ |
__u32 flags; /* see above flags */ |
/* Signed dest location allows it to be partially off screen */ |
__s32 crtc_x, crtc_y; |
__u32 crtc_w, crtc_h; |
/* Source values are 16.16 fixed point */ |
__u32 src_x, src_y; |
__u32 src_h, src_w; |
}; |
struct drm_mode_get_plane { |
__u32 plane_id; |
__u32 crtc_id; |
__u32 fb_id; |
__u32 possible_crtcs; |
__u32 gamma_size; |
__u32 count_format_types; |
__u64 format_type_ptr; |
}; |
struct drm_mode_get_plane_res { |
__u64 plane_id_ptr; |
__u32 count_planes; |
}; |
#define DRM_MODE_ENCODER_NONE 0 |
#define DRM_MODE_ENCODER_DAC 1 |
#define DRM_MODE_ENCODER_TMDS 2 |
#define DRM_MODE_ENCODER_LVDS 3 |
#define DRM_MODE_ENCODER_TVDAC 4 |
#define DRM_MODE_ENCODER_VIRTUAL 5 |
struct drm_mode_get_encoder { |
__u32 encoder_id; |
162,6 → 200,7 |
#define DRM_MODE_CONNECTOR_HDMIB 12 |
#define DRM_MODE_CONNECTOR_TV 13 |
#define DRM_MODE_CONNECTOR_eDP 14 |
#define DRM_MODE_CONNECTOR_VIRTUAL 15 |
struct drm_mode_get_connector { |
229,10 → 268,39 |
__u32 handle; |
}; |
#define DRM_MODE_FB_INTERLACED (1<<0) /* for interlaced framebuffers */ |
struct drm_mode_fb_cmd2 { |
__u32 fb_id; |
__u32 width, height; |
__u32 pixel_format; /* fourcc code from drm_fourcc.h */ |
__u32 flags; /* see above flags */ |
/* |
* In case of planar formats, this ioctl allows up to 4 |
* buffer objects with offets and pitches per plane. |
* The pitch and offset order is dictated by the fourcc, |
* e.g. NV12 (http://fourcc.org/yuv.php#NV12) is described as: |
* |
* YUV 4:2:0 image with a plane of 8 bit Y samples |
* followed by an interleaved U/V plane containing |
* 8 bit 2x2 subsampled colour difference samples. |
* |
* So it would consist of Y as offset[0] and UV as |
* offeset[1]. Note that offset[0] will generally |
* be 0. |
*/ |
__u32 handles[4]; |
__u32 pitches[4]; /* pitch for each plane */ |
__u32 offsets[4]; /* offset of each plane */ |
}; |
#define DRM_MODE_FB_DIRTY_ANNOTATE_COPY 0x01 |
#define DRM_MODE_FB_DIRTY_ANNOTATE_FILL 0x02 |
#define DRM_MODE_FB_DIRTY_FLAGS 0x03 |
#define DRM_MODE_FB_DIRTY_MAX_CLIPS 256 |
/* |
* Mark a region of a framebuffer as dirty. |
* |
/drivers/include/drm/drm_pciids.h |
---|
4,6 → 4,7 |
*/ |
#define radeon_PCI_IDS \ |
{0x1002, 0x3150, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY}, \ |
{0x1002, 0x3151, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x3152, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x3154, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x3155, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV380|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
55,6 → 56,7 |
{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}, \ |
180,8 → 182,11 |
{0x1002, 0x6748, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TURKS|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6749, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TURKS|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6750, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TURKS|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6751, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TURKS|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6758, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TURKS|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6759, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TURKS|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x675B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TURKS|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x675D, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TURKS|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x675F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TURKS|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6760, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_CAICOS|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6761, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_CAICOS|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
193,6 → 198,7 |
{0x1002, 0x6767, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_CAICOS|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6768, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_CAICOS|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6770, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_CAICOS|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6772, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_CAICOS|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6778, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_CAICOS|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6779, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_CAICOS|RADEON_NEW_MEMMAP}, \ |
{0x1002, 0x6880, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_CYPRESS|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \ |
/drivers/include/drm/intel-gtt.h |
---|
0,0 → 1,43 |
/* Common header for intel-gtt.ko and i915.ko */ |
#ifndef _DRM_INTEL_GTT_H |
#define _DRM_INTEL_GTT_H |
const struct intel_gtt { |
/* Size of memory reserved for graphics by the BIOS */ |
unsigned int stolen_size; |
/* Total number of gtt entries. */ |
unsigned int gtt_total_entries; |
/* Part of the gtt that is mappable by the cpu, for those chips where |
* this is not the full gtt. */ |
unsigned int gtt_mappable_entries; |
/* Whether i915 needs to use the dmar apis or not. */ |
unsigned int needs_dmar : 1; |
/* Whether we idle the gpu before mapping/unmapping */ |
unsigned int do_idle_maps : 1; |
} *intel_gtt_get(void); |
void intel_gtt_chipset_flush(void); |
void intel_gtt_unmap_memory(struct scatterlist *sg_list, int num_sg); |
void intel_gtt_clear_range(unsigned int first_entry, unsigned int num_entries); |
int intel_gtt_map_memory(struct page **pages, unsigned int num_entries, |
struct scatterlist **sg_list, int *num_sg); |
void intel_gtt_insert_sg_entries(struct scatterlist *sg_list, |
unsigned int sg_len, |
unsigned int pg_start, |
unsigned int flags); |
void intel_gtt_insert_pages(unsigned int first_entry, unsigned int num_entries, |
struct page **pages, unsigned int flags); |
/* Special gtt memory types */ |
#define AGP_DCACHE_MEMORY 1 |
#define AGP_PHYS_MEMORY 2 |
/* New caching attributes for gen6/sandybridge */ |
#define AGP_USER_CACHED_MEMORY_LLC_MLC (AGP_USER_TYPES + 2) |
#define AGP_USER_UNCACHED_MEMORY (AGP_USER_TYPES + 4) |
/* flag for GFDT type */ |
#define AGP_USER_CACHED_MEMORY_GFDT (1 << 3) |
#endif |
/drivers/include/drm/radeon_drm.h |
---|
550,6 → 550,7 |
#define DRM_IOCTL_RADEON_GEM_SET_TILING DRM_IOWR(DRM_COMMAND_BASE + DRM_RADEON_GEM_SET_TILING, struct drm_radeon_gem_set_tiling) |
#define DRM_IOCTL_RADEON_GEM_GET_TILING DRM_IOWR(DRM_COMMAND_BASE + DRM_RADEON_GEM_GET_TILING, struct drm_radeon_gem_get_tiling) |
#define DRM_IOCTL_RADEON_GEM_BUSY DRM_IOWR(DRM_COMMAND_BASE + DRM_RADEON_GEM_BUSY, struct drm_radeon_gem_busy) |
#define DRM_IOCTL_RADEON_GEM_VA DRM_IOWR(DRM_COMMAND_BASE + DRM_RADEON_GEM_VA, struct drm_radeon_gem_va) |
typedef struct drm_radeon_init { |
enum { |
872,9 → 873,40 |
uint64_t data_ptr; |
}; |
#define RADEON_VA_MAP 1 |
#define RADEON_VA_UNMAP 2 |
#define RADEON_VA_RESULT_OK 0 |
#define RADEON_VA_RESULT_ERROR 1 |
#define RADEON_VA_RESULT_VA_EXIST 2 |
#define RADEON_VM_PAGE_VALID (1 << 0) |
#define RADEON_VM_PAGE_READABLE (1 << 1) |
#define RADEON_VM_PAGE_WRITEABLE (1 << 2) |
#define RADEON_VM_PAGE_SYSTEM (1 << 3) |
#define RADEON_VM_PAGE_SNOOPED (1 << 4) |
struct drm_radeon_gem_va { |
uint32_t handle; |
uint32_t operation; |
uint32_t vm_id; |
uint32_t flags; |
uint64_t offset; |
}; |
#define RADEON_CHUNK_ID_RELOCS 0x01 |
#define RADEON_CHUNK_ID_IB 0x02 |
#define RADEON_CHUNK_ID_FLAGS 0x03 |
/* The first dword of RADEON_CHUNK_ID_FLAGS is a uint32 of these flags: */ |
#define RADEON_CS_KEEP_TILING_FLAGS 0x01 |
#define RADEON_CS_USE_VM 0x02 |
/* The second dword of RADEON_CHUNK_ID_FLAGS is a uint32 that sets the ring type */ |
#define RADEON_CS_RING_GFX 0 |
#define RADEON_CS_RING_COMPUTE 1 |
/* The third dword of RADEON_CHUNK_ID_FLAGS is a sint32 that sets the priority */ |
/* 0 = normal, + = higher priority, - = lower priority */ |
struct drm_radeon_cs_chunk { |
uint32_t chunk_id; |
uint32_t length_dw; |
881,6 → 913,9 |
uint64_t chunk_data; |
}; |
/* drm_radeon_cs_reloc.flags */ |
#define RADEON_RELOC_DONT_SYNC 0x01 |
struct drm_radeon_cs_reloc { |
uint32_t handle; |
uint32_t read_domains; |
912,6 → 947,10 |
#define RADEON_INFO_NUM_TILE_PIPES 0x0b /* tile pipes for r600+ */ |
#define RADEON_INFO_FUSION_GART_WORKING 0x0c /* fusion writes to GTT were broken before this */ |
#define RADEON_INFO_BACKEND_MAP 0x0d /* pipe to backend map, needed by mesa */ |
/* virtual address start, va < start are reserved by the kernel */ |
#define RADEON_INFO_VA_START 0x0e |
/* maximum size of ib using the virtual memory cs */ |
#define RADEON_INFO_IB_VM_MAX_SIZE 0x0f |
struct drm_radeon_info { |
uint32_t request; |
/drivers/include/linux/bitmap.h |
---|
144,7 → 144,9 |
extern void bitmap_release_region(unsigned long *bitmap, int pos, int order); |
extern int bitmap_allocate_region(unsigned long *bitmap, int pos, int order); |
extern void bitmap_copy_le(void *dst, const unsigned long *src, int nbits); |
extern int bitmap_ord_to_pos(const unsigned long *bitmap, int n, int bits); |
#define BITMAP_FIRST_WORD_MASK(start) (~0UL << ((start) % BITS_PER_LONG)) |
#define BITMAP_LAST_WORD_MASK(nbits) \ |
( \ |
((nbits) % BITS_PER_LONG) ? \ |
/drivers/include/linux/ctype.h |
---|
52,4 → 52,13 |
#define tolower(c) __tolower(c) |
#define toupper(c) __toupper(c) |
/* |
* Fast implementation of tolower() for internal usage. Do not use in your |
* code. |
*/ |
static inline char _tolower(const char c) |
{ |
return c | 0x20; |
} |
#endif |
/drivers/include/linux/errno.h |
---|
111,4 → 111,6 |
#define ERFKILL 132 /* Operation not possible due to RF-kill */ |
#define ENOTSUPP 524 /* Operation is not supported */ |
#endif |
/drivers/include/linux/i2c.h |
---|
280,9 → 280,6 |
/* Internal numbers to terminate lists */ |
#define I2C_CLIENT_END 0xfffeU |
/* The numbers to use to set I2C bus address */ |
#define ANY_I2C_BUS 0xffff |
/* Construct an I2C_CLIENT_END-terminated array of i2c addresses */ |
#define I2C_ADDRS(addr, addrs...) \ |
((const unsigned short []){ addr, ## addrs, I2C_CLIENT_END }) |
289,6 → 286,7 |
#endif /* __KERNEL__ */ |
/** |
* struct i2c_msg - an I2C transaction segment beginning with START |
* @addr: Slave address, either seven or ten bits. When this is a ten |
/drivers/include/linux/jiffies.h |
---|
0,0 → 1,307 |
#ifndef _LINUX_JIFFIES_H |
#define _LINUX_JIFFIES_H |
//#include <linux/math64.h> |
#include <linux/kernel.h> |
#include <linux/types.h> |
//#include <linux/time.h> |
//#include <linux/timex.h> |
//#include <asm/param.h> /* for HZ */ |
#define HZ 100 |
#define CLOCK_TICK_RATE 1193182ul |
/* |
* The following defines establish the engineering parameters of the PLL |
* model. The HZ variable establishes the timer interrupt frequency, 100 Hz |
* for the SunOS kernel, 256 Hz for the Ultrix kernel and 1024 Hz for the |
* OSF/1 kernel. The SHIFT_HZ define expresses the same value as the |
* nearest power of two in order to avoid hardware multiply operations. |
*/ |
#if HZ >= 12 && HZ < 24 |
# define SHIFT_HZ 4 |
#elif HZ >= 24 && HZ < 48 |
# define SHIFT_HZ 5 |
#elif HZ >= 48 && HZ < 96 |
# define SHIFT_HZ 6 |
#elif HZ >= 96 && HZ < 192 |
# define SHIFT_HZ 7 |
#elif HZ >= 192 && HZ < 384 |
# define SHIFT_HZ 8 |
#elif HZ >= 384 && HZ < 768 |
# define SHIFT_HZ 9 |
#elif HZ >= 768 && HZ < 1536 |
# define SHIFT_HZ 10 |
#elif HZ >= 1536 && HZ < 3072 |
# define SHIFT_HZ 11 |
#elif HZ >= 3072 && HZ < 6144 |
# define SHIFT_HZ 12 |
#elif HZ >= 6144 && HZ < 12288 |
# define SHIFT_HZ 13 |
#else |
# error Invalid value of HZ. |
#endif |
/* LATCH is used in the interval timer and ftape setup. */ |
#define LATCH ((CLOCK_TICK_RATE + HZ/2) / HZ) /* For divider */ |
/* Suppose we want to divide two numbers NOM and DEN: NOM/DEN, then we can |
* improve accuracy by shifting LSH bits, hence calculating: |
* (NOM << LSH) / DEN |
* This however means trouble for large NOM, because (NOM << LSH) may no |
* longer fit in 32 bits. The following way of calculating this gives us |
* some slack, under the following conditions: |
* - (NOM / DEN) fits in (32 - LSH) bits. |
* - (NOM % DEN) fits in (32 - LSH) bits. |
*/ |
#define SH_DIV(NOM,DEN,LSH) ( (((NOM) / (DEN)) << (LSH)) \ |
+ ((((NOM) % (DEN)) << (LSH)) + (DEN) / 2) / (DEN)) |
/* HZ is the requested value. ACTHZ is actual HZ ("<< 8" is for accuracy) */ |
#define ACTHZ (SH_DIV (CLOCK_TICK_RATE, LATCH, 8)) |
/* TICK_NSEC is the time between ticks in nsec assuming real ACTHZ */ |
#define TICK_NSEC (SH_DIV (1000000UL * 1000, ACTHZ, 8)) |
/* TICK_USEC is the time between ticks in usec assuming fake USER_HZ */ |
#define TICK_USEC ((1000000UL + USER_HZ/2) / USER_HZ) |
/* TICK_USEC_TO_NSEC is the time between ticks in nsec assuming real ACTHZ and */ |
/* a value TUSEC for TICK_USEC (can be set bij adjtimex) */ |
#define TICK_USEC_TO_NSEC(TUSEC) (SH_DIV (TUSEC * USER_HZ * 1000, ACTHZ, 8)) |
#define jiffies GetTimerTicks() |
#if (BITS_PER_LONG < 64) |
u64 get_jiffies_64(void); |
#else |
static inline u64 get_jiffies_64(void) |
{ |
return (u64)jiffies; |
} |
#endif |
/* |
* These inlines deal with timer wrapping correctly. You are |
* strongly encouraged to use them |
* 1. Because people otherwise forget |
* 2. Because if the timer wrap changes in future you won't have to |
* alter your driver code. |
* |
* time_after(a,b) returns true if the time a is after time b. |
* |
* Do this with "<0" and ">=0" to only test the sign of the result. A |
* good compiler would generate better code (and a really good compiler |
* wouldn't care). Gcc is currently neither. |
*/ |
#define time_after(a,b) \ |
(typecheck(unsigned long, a) && \ |
typecheck(unsigned long, b) && \ |
((long)(b) - (long)(a) < 0)) |
#define time_before(a,b) time_after(b,a) |
#define time_after_eq(a,b) \ |
(typecheck(unsigned long, a) && \ |
typecheck(unsigned long, b) && \ |
((long)(a) - (long)(b) >= 0)) |
#define time_before_eq(a,b) time_after_eq(b,a) |
/* |
* Calculate whether a is in the range of [b, c]. |
*/ |
#define time_in_range(a,b,c) \ |
(time_after_eq(a,b) && \ |
time_before_eq(a,c)) |
/* |
* Calculate whether a is in the range of [b, c). |
*/ |
#define time_in_range_open(a,b,c) \ |
(time_after_eq(a,b) && \ |
time_before(a,c)) |
/* Same as above, but does so with platform independent 64bit types. |
* These must be used when utilizing jiffies_64 (i.e. return value of |
* get_jiffies_64() */ |
#define time_after64(a,b) \ |
(typecheck(__u64, a) && \ |
typecheck(__u64, b) && \ |
((__s64)(b) - (__s64)(a) < 0)) |
#define time_before64(a,b) time_after64(b,a) |
#define time_after_eq64(a,b) \ |
(typecheck(__u64, a) && \ |
typecheck(__u64, b) && \ |
((__s64)(a) - (__s64)(b) >= 0)) |
#define time_before_eq64(a,b) time_after_eq64(b,a) |
/* |
* These four macros compare jiffies and 'a' for convenience. |
*/ |
/* time_is_before_jiffies(a) return true if a is before jiffies */ |
#define time_is_before_jiffies(a) time_after(jiffies, a) |
/* time_is_after_jiffies(a) return true if a is after jiffies */ |
#define time_is_after_jiffies(a) time_before(jiffies, a) |
/* time_is_before_eq_jiffies(a) return true if a is before or equal to jiffies*/ |
#define time_is_before_eq_jiffies(a) time_after_eq(jiffies, a) |
/* time_is_after_eq_jiffies(a) return true if a is after or equal to jiffies*/ |
#define time_is_after_eq_jiffies(a) time_before_eq(jiffies, a) |
/* |
* Have the 32 bit jiffies value wrap 5 minutes after boot |
* so jiffies wrap bugs show up earlier. |
*/ |
#define INITIAL_JIFFIES ((unsigned long)(unsigned int) (-300*HZ)) |
/* |
* Change timeval to jiffies, trying to avoid the |
* most obvious overflows.. |
* |
* And some not so obvious. |
* |
* Note that we don't want to return LONG_MAX, because |
* for various timeout reasons we often end up having |
* to wait "jiffies+1" in order to guarantee that we wait |
* at _least_ "jiffies" - so "jiffies+1" had better still |
* be positive. |
*/ |
#define MAX_JIFFY_OFFSET ((LONG_MAX >> 1)-1) |
extern unsigned long preset_lpj; |
/* |
* We want to do realistic conversions of time so we need to use the same |
* values the update wall clock code uses as the jiffies size. This value |
* is: TICK_NSEC (which is defined in timex.h). This |
* is a constant and is in nanoseconds. We will use scaled math |
* with a set of scales defined here as SEC_JIFFIE_SC, USEC_JIFFIE_SC and |
* NSEC_JIFFIE_SC. Note that these defines contain nothing but |
* constants and so are computed at compile time. SHIFT_HZ (computed in |
* timex.h) adjusts the scaling for different HZ values. |
* Scaled math??? What is that? |
* |
* Scaled math is a way to do integer math on values that would, |
* otherwise, either overflow, underflow, or cause undesired div |
* instructions to appear in the execution path. In short, we "scale" |
* up the operands so they take more bits (more precision, less |
* underflow), do the desired operation and then "scale" the result back |
* by the same amount. If we do the scaling by shifting we avoid the |
* costly mpy and the dastardly div instructions. |
* Suppose, for example, we want to convert from seconds to jiffies |
* where jiffies is defined in nanoseconds as NSEC_PER_JIFFIE. The |
* simple math is: jiff = (sec * NSEC_PER_SEC) / NSEC_PER_JIFFIE; We |
* observe that (NSEC_PER_SEC / NSEC_PER_JIFFIE) is a constant which we |
* might calculate at compile time, however, the result will only have |
* about 3-4 bits of precision (less for smaller values of HZ). |
* |
* So, we scale as follows: |
* jiff = (sec) * (NSEC_PER_SEC / NSEC_PER_JIFFIE); |
* jiff = ((sec) * ((NSEC_PER_SEC * SCALE)/ NSEC_PER_JIFFIE)) / SCALE; |
* Then we make SCALE a power of two so: |
* jiff = ((sec) * ((NSEC_PER_SEC << SCALE)/ NSEC_PER_JIFFIE)) >> SCALE; |
* Now we define: |
* #define SEC_CONV = ((NSEC_PER_SEC << SCALE)/ NSEC_PER_JIFFIE)) |
* jiff = (sec * SEC_CONV) >> SCALE; |
* |
* Often the math we use will expand beyond 32-bits so we tell C how to |
* do this and pass the 64-bit result of the mpy through the ">> SCALE" |
* which should take the result back to 32-bits. We want this expansion |
* to capture as much precision as possible. At the same time we don't |
* want to overflow so we pick the SCALE to avoid this. In this file, |
* that means using a different scale for each range of HZ values (as |
* defined in timex.h). |
* |
* For those who want to know, gcc will give a 64-bit result from a "*" |
* operator if the result is a long long AND at least one of the |
* operands is cast to long long (usually just prior to the "*" so as |
* not to confuse it into thinking it really has a 64-bit operand, |
* which, buy the way, it can do, but it takes more code and at least 2 |
* mpys). |
* We also need to be aware that one second in nanoseconds is only a |
* couple of bits away from overflowing a 32-bit word, so we MUST use |
* 64-bits to get the full range time in nanoseconds. |
*/ |
/* |
* Here are the scales we will use. One for seconds, nanoseconds and |
* microseconds. |
* |
* Within the limits of cpp we do a rough cut at the SEC_JIFFIE_SC and |
* check if the sign bit is set. If not, we bump the shift count by 1. |
* (Gets an extra bit of precision where we can use it.) |
* We know it is set for HZ = 1024 and HZ = 100 not for 1000. |
* Haven't tested others. |
* Limits of cpp (for #if expressions) only long (no long long), but |
* then we only need the most signicant bit. |
*/ |
#define SEC_JIFFIE_SC (31 - SHIFT_HZ) |
#if !((((NSEC_PER_SEC << 2) / TICK_NSEC) << (SEC_JIFFIE_SC - 2)) & 0x80000000) |
#undef SEC_JIFFIE_SC |
#define SEC_JIFFIE_SC (32 - SHIFT_HZ) |
#endif |
#define NSEC_JIFFIE_SC (SEC_JIFFIE_SC + 29) |
#define USEC_JIFFIE_SC (SEC_JIFFIE_SC + 19) |
#define SEC_CONVERSION ((unsigned long)((((u64)NSEC_PER_SEC << SEC_JIFFIE_SC) +\ |
TICK_NSEC -1) / (u64)TICK_NSEC)) |
#define NSEC_CONVERSION ((unsigned long)((((u64)1 << NSEC_JIFFIE_SC) +\ |
TICK_NSEC -1) / (u64)TICK_NSEC)) |
#define USEC_CONVERSION \ |
((unsigned long)((((u64)NSEC_PER_USEC << USEC_JIFFIE_SC) +\ |
TICK_NSEC -1) / (u64)TICK_NSEC)) |
/* |
* USEC_ROUND is used in the timeval to jiffie conversion. See there |
* for more details. It is the scaled resolution rounding value. Note |
* that it is a 64-bit value. Since, when it is applied, we are already |
* in jiffies (albit scaled), it is nothing but the bits we will shift |
* off. |
*/ |
#define USEC_ROUND (u64)(((u64)1 << USEC_JIFFIE_SC) - 1) |
/* |
* The maximum jiffie value is (MAX_INT >> 1). Here we translate that |
* into seconds. The 64-bit case will overflow if we are not careful, |
* so use the messy SH_DIV macro to do it. Still all constants. |
*/ |
#if BITS_PER_LONG < 64 |
# define MAX_SEC_IN_JIFFIES \ |
(long)((u64)((u64)MAX_JIFFY_OFFSET * TICK_NSEC) / NSEC_PER_SEC) |
#else /* take care of overflow on 64 bits machines */ |
# define MAX_SEC_IN_JIFFIES \ |
(SH_DIV((MAX_JIFFY_OFFSET >> SEC_JIFFIE_SC) * TICK_NSEC, NSEC_PER_SEC, 1) - 1) |
#endif |
/* |
* Convert various time units to each other: |
*/ |
extern unsigned int jiffies_to_msecs(const unsigned long j); |
extern unsigned int jiffies_to_usecs(const unsigned long j); |
extern unsigned long msecs_to_jiffies(const unsigned int m); |
extern unsigned long usecs_to_jiffies(const unsigned int u); |
extern unsigned long timespec_to_jiffies(const struct timespec *value); |
extern void jiffies_to_timespec(const unsigned long jiffies, |
struct timespec *value); |
extern unsigned long timeval_to_jiffies(const struct timeval *value); |
extern void jiffies_to_timeval(const unsigned long jiffies, |
struct timeval *value); |
extern clock_t jiffies_to_clock_t(unsigned long x); |
extern unsigned long clock_t_to_jiffies(unsigned long x); |
extern u64 jiffies_64_to_clock_t(u64 x); |
extern u64 nsec_to_clock_t(u64 x); |
extern u64 nsecs_to_jiffies64(u64 n); |
extern unsigned long nsecs_to_jiffies(u64 n); |
#define TIMESTAMP_SIZE 30 |
#endif |
/drivers/include/linux/kernel.h |
---|
13,6 → 13,10 |
#include <linux/compiler.h> |
#include <linux/bitops.h> |
#include <linux/typecheck.h> |
#define __init |
#define USHRT_MAX ((u16)(~0U)) |
#define SHRT_MAX ((s16)(USHRT_MAX>>1)) |
#define SHRT_MIN ((s16)(-SHRT_MAX - 1)) |
31,6 → 35,16 |
#define PTR_ALIGN(p, a) ((typeof(p))ALIGN((unsigned long)(p), (a))) |
#define IS_ALIGNED(x, a) (((x) & ((typeof(x))(a) - 1)) == 0) |
#define roundup(x, y) ((((x) + ((y) - 1)) / (y)) * (y)) |
#define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d)) |
#define DIV_ROUND_CLOSEST(x, divisor)( \ |
{ \ |
typeof(divisor) __divisor = divisor; \ |
(((x) + ((__divisor) / 2)) / (__divisor)); \ |
} \ |
) |
/** |
* upper_32_bits - return bits 32-63 of a number |
* @n: the number we're accessing |
220,6 → 234,119 |
typecheck(unsigned long, b) && \ |
((long)(b) - (long)(a) < 0)) |
struct tvec_base; |
struct timer_list { |
struct list_head entry; |
unsigned long expires; |
void (*function)(unsigned long); |
unsigned long data; |
// struct tvec_base *base; |
}; |
struct timespec { |
long tv_sec; /* seconds */ |
long tv_nsec; /* nanoseconds */ |
}; |
#define build_mmio_read(name, size, type, reg, barrier) \ |
static inline type name(const volatile void __iomem *addr) \ |
{ type ret; asm volatile("mov" size " %1,%0":reg (ret) \ |
:"m" (*(volatile type __force *)addr) barrier); return ret; } |
#define build_mmio_write(name, size, type, reg, barrier) \ |
static inline void name(type val, volatile void __iomem *addr) \ |
{ asm volatile("mov" size " %0,%1": :reg (val), \ |
"m" (*(volatile type __force *)addr) barrier); } |
build_mmio_read(readb, "b", unsigned char, "=q", :"memory") |
build_mmio_read(readw, "w", unsigned short, "=r", :"memory") |
build_mmio_read(readl, "l", unsigned int, "=r", :"memory") |
build_mmio_read(__readb, "b", unsigned char, "=q", ) |
build_mmio_read(__readw, "w", unsigned short, "=r", ) |
build_mmio_read(__readl, "l", unsigned int, "=r", ) |
build_mmio_write(writeb, "b", unsigned char, "q", :"memory") |
build_mmio_write(writew, "w", unsigned short, "r", :"memory") |
build_mmio_write(writel, "l", unsigned int, "r", :"memory") |
build_mmio_write(__writeb, "b", unsigned char, "q", ) |
build_mmio_write(__writew, "w", unsigned short, "r", ) |
build_mmio_write(__writel, "l", unsigned int, "r", ) |
#define readb_relaxed(a) __readb(a) |
#define readw_relaxed(a) __readw(a) |
#define readl_relaxed(a) __readl(a) |
#define __raw_readb __readb |
#define __raw_readw __readw |
#define __raw_readl __readl |
#define __raw_writeb __writeb |
#define __raw_writew __writew |
#define __raw_writel __writel |
static inline __u64 readq(const volatile void __iomem *addr) |
{ |
const volatile u32 __iomem *p = addr; |
u32 low, high; |
low = readl(p); |
high = readl(p + 1); |
return low + ((u64)high << 32); |
} |
static inline void writeq(__u64 val, volatile void __iomem *addr) |
{ |
writel(val, addr); |
writel(val >> 32, addr+4); |
} |
#define mmiowb() barrier() |
#define dev_err(dev, format, arg...) \ |
printk("Error %s " format, __func__ , ## arg) |
#define dev_warn(dev, format, arg...) \ |
printk("Warning %s " format, __func__ , ## arg) |
#define dev_info(dev, format, arg...) \ |
printk("Info %s " format , __func__, ## arg) |
#define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)])) |
struct scatterlist { |
unsigned long page_link; |
unsigned int offset; |
unsigned int length; |
dma_addr_t dma_address; |
unsigned int dma_length; |
}; |
struct page |
{ |
unsigned int addr; |
}; |
struct vm_fault { |
unsigned int flags; /* FAULT_FLAG_xxx flags */ |
pgoff_t pgoff; /* Logical page offset based on vma */ |
void __user *virtual_address; /* Faulting virtual address */ |
struct page *page; /* ->fault handlers should return a |
* page here, unless VM_FAULT_NOPAGE |
* is set (which is also implied by |
* VM_FAULT_ERROR). |
*/ |
}; |
#endif |
/drivers/include/linux/lockdep.h |
---|
542,7 → 542,7 |
#endif |
#ifdef CONFIG_PROVE_RCU |
extern void lockdep_rcu_dereference(const char *file, const int line); |
void lockdep_rcu_suspicious(const char *file, const int line, const char *s); |
#endif |
#endif /* __LINUX_LOCKDEP_H */ |
/drivers/include/linux/pci.h |
---|
625,14 → 625,18 |
int enum_pci_devices(void); |
struct pci_device_id* |
find_pci_device(pci_dev_t* pdev, struct pci_device_id *idlist); |
const struct pci_device_id* |
find_pci_device(pci_dev_t* pdev, const struct pci_device_id *idlist); |
#define DMA_BIT_MASK(n) (((n) == 64) ? ~0ULL : ((1ULL<<(n))-1)) |
int pci_set_dma_mask(struct pci_dev *dev, u64 mask); |
struct pci_dev *pci_get_bus_and_slot(unsigned int bus, unsigned int devfn); |
struct pci_dev *pci_get_class(unsigned int class, struct pci_dev *from); |
void __iomem *pci_map_rom(struct pci_dev *pdev, size_t *size); |
#define pci_name(x) "radeon" |
#endif //__PCI__H__ |
/drivers/include/linux/pci_regs.h |
---|
663,6 → 663,26 |
#define PCI_ATS_CTRL_STU(x) ((x) & 0x1f) /* Smallest Translation Unit */ |
#define PCI_ATS_MIN_STU 12 /* shift of minimum STU block */ |
/* Page Request Interface */ |
#define PCI_PRI_CAP 0x13 /* PRI capability ID */ |
#define PCI_PRI_CONTROL_OFF 0x04 /* Offset of control register */ |
#define PCI_PRI_STATUS_OFF 0x06 /* Offset of status register */ |
#define PCI_PRI_ENABLE 0x0001 /* Enable mask */ |
#define PCI_PRI_RESET 0x0002 /* Reset bit mask */ |
#define PCI_PRI_STATUS_RF 0x0001 /* Request Failure */ |
#define PCI_PRI_STATUS_UPRGI 0x0002 /* Unexpected PRG index */ |
#define PCI_PRI_STATUS_STOPPED 0x0100 /* PRI Stopped */ |
#define PCI_PRI_MAX_REQ_OFF 0x08 /* Cap offset for max reqs supported */ |
#define PCI_PRI_ALLOC_REQ_OFF 0x0c /* Cap offset for max reqs allowed */ |
/* PASID capability */ |
#define PCI_PASID_CAP 0x1b /* PASID capability ID */ |
#define PCI_PASID_CAP_OFF 0x04 /* PASID feature register */ |
#define PCI_PASID_CONTROL_OFF 0x06 /* PASID control register */ |
#define PCI_PASID_ENABLE 0x01 /* Enable/Supported bit */ |
#define PCI_PASID_EXEC 0x02 /* Exec permissions Enable/Supported */ |
#define PCI_PASID_PRIV 0x04 /* Priviledge Mode Enable/Support */ |
/* Single Root I/O Virtualization */ |
#define PCI_SRIOV_CAP 0x04 /* SR-IOV Capabilities */ |
#define PCI_SRIOV_CAP_VFM 0x01 /* VF Migration Capable */ |
/drivers/include/linux/poison.h |
---|
40,6 → 40,12 |
#define RED_INACTIVE 0x09F911029D74E35BULL /* when obj is inactive */ |
#define RED_ACTIVE 0xD84156C5635688C0ULL /* when obj is active */ |
#ifdef CONFIG_PHYS_ADDR_T_64BIT |
#define MEMBLOCK_INACTIVE 0x3a84fb0144c9e71bULL |
#else |
#define MEMBLOCK_INACTIVE 0x44c9e71bUL |
#endif |
#define SLUB_RED_INACTIVE 0xbb |
#define SLUB_RED_ACTIVE 0xcc |
/drivers/include/linux/string.h |
---|
114,6 → 114,7 |
#ifndef __HAVE_ARCH_MEMCHR |
extern void * memchr(const void *,int,__kernel_size_t); |
#endif |
void *memchr_inv(const void *s, int c, size_t n); |
extern char *kstrdup(const char *s, gfp_t gfp); |
extern char *kstrndup(const char *s, size_t len, gfp_t gfp); |
/drivers/include/linux/types.h |
---|
246,7 → 246,7 |
typedef unsigned char u8_t; |
typedef unsigned short u16_t; |
typedef unsigned int u32_t; |
typedef unsigned long u32_t; |
typedef unsigned long long u64_t; |
typedef unsigned int addr_t; |
/drivers/include/linux/wait.h |
---|
0,0 → 1,144 |
#ifndef _LINUX_WAIT_H |
#define _LINUX_WAIT_H |
typedef struct __wait_queue wait_queue_t; |
typedef struct __wait_queue_head wait_queue_head_t; |
struct __wait_queue |
{ |
struct list_head task_list; |
evhandle_t evnt; |
}; |
struct __wait_queue_head |
{ |
spinlock_t lock; |
struct list_head task_list; |
}; |
static inline void __add_wait_queue(wait_queue_head_t *head, wait_queue_t *new) |
{ |
list_add(&new->task_list, &head->task_list); |
} |
#define __wait_event(wq, condition) \ |
do { \ |
DEFINE_WAIT(__wait); \ |
\ |
for (;;) { \ |
prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE); \ |
if (condition) \ |
break; \ |
schedule(); \ |
} \ |
finish_wait(&wq, &__wait); \ |
} while (0) |
#define wait_event(wq, condition) \ |
do{ \ |
wait_queue_t __wait = { \ |
.task_list = LIST_HEAD_INIT(__wait.task_list), \ |
.evnt = CreateEvent(NULL, MANUAL_DESTROY), \ |
}; \ |
u32 flags; \ |
\ |
spin_lock_irqsave(&wq.lock, flags); \ |
if (list_empty(&__wait.task_list)) \ |
__add_wait_queue(&wq, &__wait); \ |
spin_unlock_irqrestore(&wq.lock, flags); \ |
\ |
for(;;){ \ |
if (condition) \ |
break; \ |
WaitEvent(__wait.evnt); \ |
}; \ |
if (!list_empty_careful(&__wait.task_list)) { \ |
spin_lock_irqsave(&wq.lock, flags); \ |
list_del_init(&__wait.task_list); \ |
spin_unlock_irqrestore(&wq.lock, flags); \ |
}; \ |
DestroyEvent(__wait.evnt); \ |
} while (0) |
static inline |
void wake_up_all(wait_queue_head_t *q) |
{ |
wait_queue_t *curr; |
unsigned long flags; |
spin_lock_irqsave(&q->lock, flags); |
list_for_each_entry(curr, &q->task_list, task_list) |
{ |
kevent_t event; |
event.code = -1; |
RaiseEvent(curr->evnt, 0, &event); |
} |
spin_unlock_irqrestore(&q->lock, flags); |
} |
static inline void |
init_waitqueue_head(wait_queue_head_t *q) |
{ |
spin_lock_init(&q->lock); |
INIT_LIST_HEAD(&q->task_list); |
}; |
/* |
* Workqueue flags and constants. For details, please refer to |
* Documentation/workqueue.txt. |
*/ |
enum { |
WQ_NON_REENTRANT = 1 << 0, /* guarantee non-reentrance */ |
WQ_UNBOUND = 1 << 1, /* not bound to any cpu */ |
WQ_FREEZABLE = 1 << 2, /* freeze during suspend */ |
WQ_MEM_RECLAIM = 1 << 3, /* may be used for memory reclaim */ |
WQ_HIGHPRI = 1 << 4, /* high priority */ |
WQ_CPU_INTENSIVE = 1 << 5, /* cpu instensive workqueue */ |
WQ_DRAINING = 1 << 6, /* internal: workqueue is draining */ |
WQ_RESCUER = 1 << 7, /* internal: workqueue has rescuer */ |
WQ_MAX_ACTIVE = 512, /* I like 512, better ideas? */ |
WQ_MAX_UNBOUND_PER_CPU = 4, /* 4 * #cpus for unbound wq */ |
WQ_DFL_ACTIVE = WQ_MAX_ACTIVE / 2, |
}; |
struct work_struct; |
struct workqueue_struct { |
spinlock_t lock; |
struct list_head worklist; |
}; |
typedef void (*work_func_t)(struct work_struct *work); |
struct work_struct { |
struct list_head entry; |
struct workqueue_struct *data; |
work_func_t func; |
}; |
struct delayed_work { |
struct work_struct work; |
}; |
struct workqueue_struct *alloc_workqueue_key(const char *fmt, |
unsigned int flags, int max_active); |
int queue_delayed_work(struct workqueue_struct *wq, |
struct delayed_work *dwork, unsigned long delay); |
#define INIT_DELAYED_WORK(_work, _func) \ |
do { \ |
INIT_LIST_HEAD(&(_work)->work.entry); \ |
(_work)->work.func = _func; \ |
} while (0) |
#endif |
/drivers/include/syscall.h |
---|
37,7 → 37,10 |
addr_t STDCALL AllocPage(void)__asm__("AllocPage"); |
addr_t STDCALL AllocPages(count_t count)__asm__("AllocPages"); |
void IMPORT __attribute__((regparm(1))) |
FreePage(addr_t page)__asm__("FreePage"); |
void* STDCALL CreateRingBuffer(size_t size, u32_t map)__asm__("CreateRingBuffer"); |
u32_t STDCALL RegService(char *name, srv_proc_t proc)__asm__("RegService"); |
51,6 → 54,9 |
addr_t IMPORT GetStackBase(void)__asm__("GetStackBase"); |
u32_t IMPORT GetPid(void)__asm__("GetPid"); |
u32 STDCALL TimerHs(u32 delay, u32 interval, |
void *fn, void *data)asm("TimerHs"); |
/////////////////////////////////////////////////////////////////////////////// |
void STDCALL SetMouseData(int btn, int x, int y, |
85,7 → 91,6 |
#define pciWriteLong(tag, reg, val) \ |
PciWrite32(PCI_BUS_FROM_TAG(tag),PCI_DFN_FROM_TAG(tag),(reg),(val)) |
/////////////////////////////////////////////////////////////////////////////// |
int dbg_open(char *path); |
125,6 → 130,14 |
__asm__ __volatile__ ("":::"ebx","ecx","edx","esi","edi"); |
}; |
static inline void DestroyEvent(evhandle_t evh) |
{ |
__asm__ __volatile__ ( |
"call *__imp__DestroyEvent" |
::"a"(evh.handle),"b"(evh.euid)); |
__asm__ __volatile__ ("":::"ebx","ecx","edx","esi","edi"); |
}; |
static inline u32_t GetEvent(kevent_t *ev) |
{ |
u32_t handle; |
175,7 → 188,7 |
__asm__ __volatile__ ( |
"call *__imp__GetPgAddr \n\t" |
:"=eax" (retval) |
:"=a" (retval) |
:"a" (mem) ); |
return retval; |
}; |
216,7 → 229,7 |
static inline void udelay(u32_t delay) |
{ |
if(!delay) delay++; |
delay*= 500; |
delay*= 100; |
while(delay--) |
{ |
298,7 → 311,7 |
( |
"pushl %%eax \n\t" |
"call *__imp__GetService" |
:"=eax" (handle) |
:"=a" (handle) |
:"a" (name) |
:"ebx","ecx","edx","esi", "edi" |
); |
417,7 → 430,7 |
static inline void __iomem *ioremap(uint32_t offset, size_t size) |
{ |
return (void __iomem*) MapIoMem(offset, size, 3); |
return (void __iomem*) MapIoMem(offset, size, PG_SW|PG_NOCACHE); |
} |
static inline void iounmap(void *addr) |