Merge branch 'drm-patches' of ssh://master.kernel.org/pub/scm/linux/kernel/git/airlied/drm-2.6
* 'drm-patches' of ssh://master.kernel.org/pub/scm/linux/kernel/git/airlied/drm-2.6: via invalid device ids removal radeon: Commit the ring after each partial texture upload blit. i915: fix vbl swap allocation size. drm: Replace DRM_IOCTL_ARGS with (dev, data, file_priv) and remove DRM_DEVICE. drm: remove XFREE86_VERSION macros. drm: Replace filp in ioctl arguments with drm_file *file_priv. drm: Remove DRM_ERR OS macro.
This commit is contained in:
commit
13626cb91f
|
@ -63,27 +63,9 @@
|
|||
#define DRM_IOC(dir, group, nr, size) _IOC(dir, group, nr, size)
|
||||
#endif
|
||||
|
||||
#define XFREE86_VERSION(major,minor,patch,snap) \
|
||||
((major << 16) | (minor << 8) | patch)
|
||||
|
||||
#ifndef CONFIG_XFREE86_VERSION
|
||||
#define CONFIG_XFREE86_VERSION XFREE86_VERSION(4,1,0,0)
|
||||
#endif
|
||||
|
||||
#if CONFIG_XFREE86_VERSION < XFREE86_VERSION(4,1,0,0)
|
||||
#define DRM_PROC_DEVICES "/proc/devices"
|
||||
#define DRM_PROC_MISC "/proc/misc"
|
||||
#define DRM_PROC_DRM "/proc/drm"
|
||||
#define DRM_DEV_DRM "/dev/drm"
|
||||
#define DRM_DEV_MODE (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP)
|
||||
#define DRM_DEV_UID 0
|
||||
#define DRM_DEV_GID 0
|
||||
#endif
|
||||
|
||||
#if CONFIG_XFREE86_VERSION >= XFREE86_VERSION(4,1,0,0)
|
||||
#define DRM_MAJOR 226
|
||||
#define DRM_MAX_MINOR 15
|
||||
#endif
|
||||
|
||||
#define DRM_NAME "drm" /**< Name in kernel, /dev, and /proc */
|
||||
#define DRM_MIN_ORDER 5 /**< At least 2^5 bytes = 32 bytes */
|
||||
#define DRM_MAX_ORDER 22 /**< Up to 2^22 bytes = 4MB */
|
||||
|
|
|
@ -80,6 +80,9 @@
|
|||
#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"
|
||||
|
||||
|
@ -231,12 +234,13 @@
|
|||
* \param dev DRM device.
|
||||
* \param filp file pointer of the caller.
|
||||
*/
|
||||
#define LOCK_TEST_WITH_RETURN( dev, filp ) \
|
||||
#define LOCK_TEST_WITH_RETURN( dev, file_priv ) \
|
||||
do { \
|
||||
if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) || \
|
||||
dev->lock.filp != filp ) { \
|
||||
DRM_ERROR( "%s called without lock held\n", \
|
||||
__FUNCTION__ ); \
|
||||
dev->lock.file_priv != file_priv ) { \
|
||||
DRM_ERROR( "%s called without lock held, held %d owner %p %p\n",\
|
||||
__FUNCTION__, _DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ),\
|
||||
dev->lock.file_priv, file_priv ); \
|
||||
return -EINVAL; \
|
||||
} \
|
||||
} while (0)
|
||||
|
@ -257,12 +261,12 @@ do { \
|
|||
* Ioctl function type.
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private pointer.
|
||||
* \param cmd command.
|
||||
* \param arg argument.
|
||||
*/
|
||||
typedef int drm_ioctl_t(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
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);
|
||||
|
@ -271,10 +275,18 @@ typedef int drm_ioctl_compat_t(struct file *filp, unsigned int cmd,
|
|||
#define DRM_MASTER 0x2
|
||||
#define DRM_ROOT_ONLY 0x4
|
||||
|
||||
typedef struct drm_ioctl_desc {
|
||||
struct drm_ioctl_desc {
|
||||
unsigned int cmd;
|
||||
drm_ioctl_t *func;
|
||||
int flags;
|
||||
} drm_ioctl_desc_t;
|
||||
};
|
||||
|
||||
/**
|
||||
* Creates a driver or general drm_ioctl_desc array entry for the given
|
||||
* ioctl, for use by drm_ioctl().
|
||||
*/
|
||||
#define DRM_IOCTL_DEF(ioctl, func, flags) \
|
||||
[DRM_IOCTL_NR(ioctl)] = {ioctl, func, flags}
|
||||
|
||||
struct drm_magic_entry {
|
||||
struct list_head head;
|
||||
|
@ -304,7 +316,7 @@ struct drm_buf {
|
|||
__volatile__ int waiting; /**< On kernel DMA queue */
|
||||
__volatile__ int pending; /**< On hardware DMA queue */
|
||||
wait_queue_head_t dma_wait; /**< Processes waiting */
|
||||
struct file *filp; /**< Pointer to holding file descr */
|
||||
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 {
|
||||
|
@ -377,6 +389,7 @@ struct drm_file {
|
|||
int remove_auth_on_close;
|
||||
unsigned long lock_count;
|
||||
void *driver_priv;
|
||||
struct file *filp;
|
||||
};
|
||||
|
||||
/** Wait queue */
|
||||
|
@ -403,7 +416,7 @@ struct drm_queue {
|
|||
*/
|
||||
struct drm_lock_data {
|
||||
struct drm_hw_lock *hw_lock; /**< Hardware lock */
|
||||
struct file *filp; /**< File descr of lock holder (0=kernel) */
|
||||
struct drm_file *file_priv; /**< File descr of lock holder (0=kernel) */
|
||||
wait_queue_head_t lock_queue; /**< Queue of blocked processes */
|
||||
unsigned long lock_time; /**< Time of last lock in jiffies */
|
||||
spinlock_t spinlock;
|
||||
|
@ -552,11 +565,11 @@ 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 file * filp);
|
||||
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 (*dma_ioctl) (DRM_IOCTL_ARGS);
|
||||
int (*dma_ioctl) (struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
void (*dma_ready) (struct drm_device *);
|
||||
int (*dma_quiescent) (struct drm_device *);
|
||||
int (*context_ctor) (struct drm_device *dev, int context);
|
||||
|
@ -587,11 +600,12 @@ struct drm_driver {
|
|||
void (*irq_preinstall) (struct drm_device *dev);
|
||||
void (*irq_postinstall) (struct drm_device *dev);
|
||||
void (*irq_uninstall) (struct drm_device *dev);
|
||||
void (*reclaim_buffers) (struct drm_device *dev, struct file * filp);
|
||||
void (*reclaim_buffers) (struct drm_device *dev,
|
||||
struct drm_file * file_priv);
|
||||
void (*reclaim_buffers_locked) (struct drm_device *dev,
|
||||
struct file *filp);
|
||||
struct drm_file *file_priv);
|
||||
void (*reclaim_buffers_idlelocked) (struct drm_device *dev,
|
||||
struct file * filp);
|
||||
struct drm_file *file_priv);
|
||||
unsigned long (*get_map_ofs) (struct drm_map * map);
|
||||
unsigned long (*get_reg_ofs) (struct drm_device *dev);
|
||||
void (*set_version) (struct drm_device *dev,
|
||||
|
@ -606,7 +620,7 @@ struct drm_driver {
|
|||
|
||||
u32 driver_features;
|
||||
int dev_priv_size;
|
||||
drm_ioctl_desc_t *ioctls;
|
||||
struct drm_ioctl_desc *ioctls;
|
||||
int num_ioctls;
|
||||
struct file_operations fops;
|
||||
struct pci_driver pci_driver;
|
||||
|
@ -850,70 +864,70 @@ extern int drm_bind_agp(DRM_AGP_MEM * handle, unsigned int start);
|
|||
extern int drm_unbind_agp(DRM_AGP_MEM * handle);
|
||||
|
||||
/* Misc. IOCTL support (drm_ioctl.h) */
|
||||
extern int drm_irq_by_busid(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_getunique(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_setunique(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_getmap(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_getclient(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_getstats(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_setversion(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_noop(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
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_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 inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_addctx(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_modctx(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_getctx(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_switchctx(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_newctx(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_rmctx(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
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 inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_getsareactx(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
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);
|
||||
|
||||
/* Drawable IOCTL support (drm_drawable.h) */
|
||||
extern int drm_adddraw(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_rmdraw(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_update_drawable_info(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_adddraw(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv);
|
||||
extern int drm_rmdraw(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv);
|
||||
extern int drm_update_drawable_info(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv);
|
||||
extern struct drm_drawable_info *drm_get_drawable_info(struct drm_device *dev,
|
||||
drm_drawable_t id);
|
||||
extern void drm_drawable_free_all(struct drm_device *dev);
|
||||
|
||||
/* Authentication IOCTL support (drm_auth.h) */
|
||||
extern int drm_getmagic(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_authmagic(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
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);
|
||||
|
||||
/* Locking IOCTL support (drm_lock.h) */
|
||||
extern int drm_lock(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_unlock(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
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_take(struct drm_lock_data *lock_data, unsigned int context);
|
||||
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);
|
||||
|
@ -924,8 +938,7 @@ extern void drm_idlelock_release(struct drm_lock_data *lock_data);
|
|||
* DMA quiscent + idle. DMA quiescent usually requires the hardware lock.
|
||||
*/
|
||||
|
||||
extern int drm_i_have_hw_lock(struct file *filp);
|
||||
extern int drm_kernel_take_hw_lock(struct file *filp);
|
||||
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);
|
||||
|
@ -933,24 +946,23 @@ extern int drm_addbufs_pci(struct drm_device *dev, struct drm_buf_desc * request
|
|||
extern int drm_addmap(struct drm_device *dev, unsigned int offset,
|
||||
unsigned int size, enum drm_map_type type,
|
||||
enum drm_map_flags flags, drm_local_map_t ** map_ptr);
|
||||
extern int drm_addmap_ioctl(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_rmmap(struct drm_device *dev, drm_local_map_t * map);
|
||||
extern int drm_rmmap_locked(struct drm_device *dev, drm_local_map_t * map);
|
||||
extern int drm_rmmap_ioctl(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
|
||||
extern int drm_addmap_ioctl(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv);
|
||||
extern int drm_rmmap(struct drm_device *dev, drm_local_map_t *map);
|
||||
extern int drm_rmmap_locked(struct drm_device *dev, drm_local_map_t *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);
|
||||
extern int drm_addbufs(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_infobufs(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_markbufs(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_freebufs(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_mapbufs(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern unsigned long drm_get_resource_start(struct drm_device *dev,
|
||||
unsigned int resource);
|
||||
extern unsigned long drm_get_resource_len(struct drm_device *dev,
|
||||
|
@ -960,19 +972,20 @@ extern unsigned long drm_get_resource_len(struct drm_device *dev,
|
|||
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 file *filp);
|
||||
extern void drm_core_reclaim_buffers(struct drm_device *dev,
|
||||
struct drm_file *filp);
|
||||
|
||||
/* IRQ support (drm_irq.h) */
|
||||
extern int drm_control(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
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_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_wait_vblank(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_wait_vblank(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv);
|
||||
extern int drm_vblank_wait(struct drm_device *dev, unsigned int *vbl_seq);
|
||||
extern void drm_vbl_send_signals(struct drm_device *dev);
|
||||
extern void drm_locked_tasklet(struct drm_device *dev, void(*func)(struct drm_device*));
|
||||
|
@ -980,31 +993,30 @@ extern void drm_locked_tasklet(struct drm_device *dev, void(*func)(struct drm_de
|
|||
/* 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 inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
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 inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
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 inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_agp_info(struct drm_device *dev, struct drm_agp_info * info);
|
||||
extern int drm_agp_info_ioctl(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
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 inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
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 inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
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 inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
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 inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern DRM_AGP_MEM *drm_agp_allocate_memory(struct agp_bridge_data *bridge,
|
||||
size_t pages, u32 type);
|
||||
extern int drm_agp_bind_ioctl(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv);
|
||||
extern DRM_AGP_MEM *drm_agp_allocate_memory(struct agp_bridge_data *bridge, size_t pages, u32 type);
|
||||
extern int drm_agp_free_memory(DRM_AGP_MEM * handle);
|
||||
extern int drm_agp_bind_memory(DRM_AGP_MEM * handle, off_t start);
|
||||
extern int drm_agp_unbind_memory(DRM_AGP_MEM * handle);
|
||||
|
@ -1033,10 +1045,11 @@ extern int drm_proc_cleanup(int minor,
|
|||
|
||||
/* Scatter Gather Support (drm_scatter.h) */
|
||||
extern void drm_sg_cleanup(struct drm_sg_mem * entry);
|
||||
extern int drm_sg_alloc(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int drm_sg_free(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
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,
|
||||
|
|
|
@ -40,7 +40,7 @@
|
|||
* Get AGP information.
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg pointer to a (output) drm_agp_info structure.
|
||||
* \return zero on success or a negative number on failure.
|
||||
|
@ -71,20 +71,16 @@ int drm_agp_info(struct drm_device *dev, struct drm_agp_info *info)
|
|||
|
||||
EXPORT_SYMBOL(drm_agp_info);
|
||||
|
||||
int drm_agp_info_ioctl(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_agp_info_ioctl(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_agp_info info;
|
||||
struct drm_agp_info *info = data;
|
||||
int err;
|
||||
|
||||
err = drm_agp_info(dev, &info);
|
||||
err = drm_agp_info(dev, info);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
if (copy_to_user((struct drm_agp_info __user *) arg, &info, sizeof(info)))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -115,7 +111,7 @@ EXPORT_SYMBOL(drm_agp_acquire);
|
|||
* Acquire the AGP device (ioctl).
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg user argument.
|
||||
* \return zero on success or a negative number on failure.
|
||||
|
@ -123,12 +119,10 @@ EXPORT_SYMBOL(drm_agp_acquire);
|
|||
* Verifies the AGP device hasn't been acquired before and calls
|
||||
* \c agp_backend_acquire.
|
||||
*/
|
||||
int drm_agp_acquire_ioctl(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_agp_acquire_ioctl(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
|
||||
return drm_agp_acquire((struct drm_device *) priv->head->dev);
|
||||
return drm_agp_acquire((struct drm_device *) file_priv->head->dev);
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -149,12 +143,9 @@ int drm_agp_release(struct drm_device * dev)
|
|||
}
|
||||
EXPORT_SYMBOL(drm_agp_release);
|
||||
|
||||
int drm_agp_release_ioctl(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_agp_release_ioctl(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
|
||||
return drm_agp_release(dev);
|
||||
}
|
||||
|
||||
|
@ -182,24 +173,19 @@ int drm_agp_enable(struct drm_device * dev, struct drm_agp_mode mode)
|
|||
|
||||
EXPORT_SYMBOL(drm_agp_enable);
|
||||
|
||||
int drm_agp_enable_ioctl(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_agp_enable_ioctl(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_agp_mode mode;
|
||||
struct drm_agp_mode *mode = data;
|
||||
|
||||
if (copy_from_user(&mode, (struct drm_agp_mode __user *) arg, sizeof(mode)))
|
||||
return -EFAULT;
|
||||
|
||||
return drm_agp_enable(dev, mode);
|
||||
return drm_agp_enable(dev, *mode);
|
||||
}
|
||||
|
||||
/**
|
||||
* Allocate AGP memory.
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv file private pointer.
|
||||
* \param cmd command.
|
||||
* \param arg pointer to a drm_agp_buffer structure.
|
||||
* \return zero on success or a negative number on failure.
|
||||
|
@ -241,35 +227,13 @@ int drm_agp_alloc(struct drm_device *dev, struct drm_agp_buffer *request)
|
|||
}
|
||||
EXPORT_SYMBOL(drm_agp_alloc);
|
||||
|
||||
int drm_agp_alloc_ioctl(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
|
||||
int drm_agp_alloc_ioctl(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_agp_buffer request;
|
||||
struct drm_agp_buffer __user *argp = (void __user *)arg;
|
||||
int err;
|
||||
struct drm_agp_buffer *request = data;
|
||||
|
||||
if (copy_from_user(&request, argp, sizeof(request)))
|
||||
return -EFAULT;
|
||||
|
||||
err = drm_agp_alloc(dev, &request);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
if (copy_to_user(argp, &request, sizeof(request))) {
|
||||
struct drm_agp_mem *entry;
|
||||
list_for_each_entry(entry, &dev->agp->memory, head) {
|
||||
if (entry->handle == request.handle)
|
||||
break;
|
||||
}
|
||||
list_del(&entry->head);
|
||||
drm_free_agp(entry->memory, entry->pages);
|
||||
drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
return 0;
|
||||
return drm_agp_alloc(dev, request);
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -297,7 +261,7 @@ static struct drm_agp_mem *drm_agp_lookup_entry(struct drm_device * dev,
|
|||
* Unbind AGP memory from the GATT (ioctl).
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg pointer to a drm_agp_binding structure.
|
||||
* \return zero on success or a negative number on failure.
|
||||
|
@ -323,25 +287,20 @@ int drm_agp_unbind(struct drm_device *dev, struct drm_agp_binding *request)
|
|||
}
|
||||
EXPORT_SYMBOL(drm_agp_unbind);
|
||||
|
||||
int drm_agp_unbind_ioctl(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
|
||||
int drm_agp_unbind_ioctl(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_agp_binding request;
|
||||
struct drm_agp_binding *request = data;
|
||||
|
||||
if (copy_from_user
|
||||
(&request, (struct drm_agp_binding __user *) arg, sizeof(request)))
|
||||
return -EFAULT;
|
||||
|
||||
return drm_agp_unbind(dev, &request);
|
||||
return drm_agp_unbind(dev, request);
|
||||
}
|
||||
|
||||
/**
|
||||
* Bind AGP memory into the GATT (ioctl)
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg pointer to a drm_agp_binding structure.
|
||||
* \return zero on success or a negative number on failure.
|
||||
|
@ -372,25 +331,20 @@ int drm_agp_bind(struct drm_device *dev, struct drm_agp_binding *request)
|
|||
}
|
||||
EXPORT_SYMBOL(drm_agp_bind);
|
||||
|
||||
int drm_agp_bind_ioctl(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
|
||||
int drm_agp_bind_ioctl(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_agp_binding request;
|
||||
struct drm_agp_binding *request = data;
|
||||
|
||||
if (copy_from_user
|
||||
(&request, (struct drm_agp_binding __user *) arg, sizeof(request)))
|
||||
return -EFAULT;
|
||||
|
||||
return drm_agp_bind(dev, &request);
|
||||
return drm_agp_bind(dev, request);
|
||||
}
|
||||
|
||||
/**
|
||||
* Free AGP memory (ioctl).
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg pointer to a drm_agp_buffer structure.
|
||||
* \return zero on success or a negative number on failure.
|
||||
|
@ -419,18 +373,14 @@ int drm_agp_free(struct drm_device *dev, struct drm_agp_buffer *request)
|
|||
}
|
||||
EXPORT_SYMBOL(drm_agp_free);
|
||||
|
||||
int drm_agp_free_ioctl(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
|
||||
|
||||
int drm_agp_free_ioctl(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_agp_buffer request;
|
||||
struct drm_agp_buffer *request = data;
|
||||
|
||||
if (copy_from_user
|
||||
(&request, (struct drm_agp_buffer __user *) arg, sizeof(request)))
|
||||
return -EFAULT;
|
||||
|
||||
return drm_agp_free(dev, &request);
|
||||
return drm_agp_free(dev, request);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
@ -128,42 +128,38 @@ static int drm_remove_magic(struct drm_device * dev, drm_magic_t magic)
|
|||
* Get a unique magic number (ioctl).
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg pointer to a resulting drm_auth structure.
|
||||
* \return zero on success, or a negative number on failure.
|
||||
*
|
||||
* If there is a magic number in drm_file::magic then use it, otherwise
|
||||
* searches an unique non-zero magic number and add it associating it with \p
|
||||
* filp.
|
||||
* file_priv.
|
||||
*/
|
||||
int drm_getmagic(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_getmagic(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
static drm_magic_t sequence = 0;
|
||||
static DEFINE_SPINLOCK(lock);
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_auth auth;
|
||||
struct drm_auth *auth = data;
|
||||
|
||||
/* Find unique magic */
|
||||
if (priv->magic) {
|
||||
auth.magic = priv->magic;
|
||||
if (file_priv->magic) {
|
||||
auth->magic = file_priv->magic;
|
||||
} else {
|
||||
do {
|
||||
spin_lock(&lock);
|
||||
if (!sequence)
|
||||
++sequence; /* reserve 0 */
|
||||
auth.magic = sequence++;
|
||||
auth->magic = sequence++;
|
||||
spin_unlock(&lock);
|
||||
} while (drm_find_file(dev, auth.magic));
|
||||
priv->magic = auth.magic;
|
||||
drm_add_magic(dev, priv, auth.magic);
|
||||
} while (drm_find_file(dev, auth->magic));
|
||||
file_priv->magic = auth->magic;
|
||||
drm_add_magic(dev, file_priv, auth->magic);
|
||||
}
|
||||
|
||||
DRM_DEBUG("%u\n", auth.magic);
|
||||
if (copy_to_user((struct drm_auth __user *) arg, &auth, sizeof(auth)))
|
||||
return -EFAULT;
|
||||
DRM_DEBUG("%u\n", auth->magic);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -171,27 +167,23 @@ int drm_getmagic(struct inode *inode, struct file *filp,
|
|||
* Authenticate with a magic.
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg pointer to a drm_auth structure.
|
||||
* \return zero if authentication successed, or a negative number otherwise.
|
||||
*
|
||||
* Checks if \p filp is associated with the magic number passed in \arg.
|
||||
* Checks if \p file_priv is associated with the magic number passed in \arg.
|
||||
*/
|
||||
int drm_authmagic(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_authmagic(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_auth auth;
|
||||
struct drm_auth *auth = data;
|
||||
struct drm_file *file;
|
||||
|
||||
if (copy_from_user(&auth, (struct drm_auth __user *) arg, sizeof(auth)))
|
||||
return -EFAULT;
|
||||
DRM_DEBUG("%u\n", auth.magic);
|
||||
if ((file = drm_find_file(dev, auth.magic))) {
|
||||
DRM_DEBUG("%u\n", auth->magic);
|
||||
if ((file = drm_find_file(dev, auth->magic))) {
|
||||
file->authenticated = 1;
|
||||
drm_remove_magic(dev, auth.magic);
|
||||
drm_remove_magic(dev, auth->magic);
|
||||
return 0;
|
||||
}
|
||||
return -EINVAL;
|
||||
|
|
|
@ -92,7 +92,7 @@ static int drm_map_handle(struct drm_device *dev, struct drm_hash_item *hash,
|
|||
* Ioctl to specify a range of memory that is available for mapping by a non-root process.
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg pointer to a drm_map structure.
|
||||
* \return zero on success or a negative value on error.
|
||||
|
@ -332,38 +332,24 @@ int drm_addmap(struct drm_device * dev, unsigned int offset,
|
|||
|
||||
EXPORT_SYMBOL(drm_addmap);
|
||||
|
||||
int drm_addmap_ioctl(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_addmap_ioctl(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_map map;
|
||||
struct drm_map *map = data;
|
||||
struct drm_map_list *maplist;
|
||||
struct drm_map __user *argp = (void __user *)arg;
|
||||
int err;
|
||||
|
||||
if (!(filp->f_mode & 3))
|
||||
return -EACCES; /* Require read/write */
|
||||
|
||||
if (copy_from_user(&map, argp, sizeof(map))) {
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
if (!(capable(CAP_SYS_ADMIN) || map.type == _DRM_AGP))
|
||||
if (!(capable(CAP_SYS_ADMIN) || map->type == _DRM_AGP))
|
||||
return -EPERM;
|
||||
|
||||
err = drm_addmap_core(dev, map.offset, map.size, map.type, map.flags,
|
||||
&maplist);
|
||||
err = drm_addmap_core(dev, map->offset, map->size, map->type,
|
||||
map->flags, &maplist);
|
||||
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
if (copy_to_user(argp, maplist->map, sizeof(struct drm_map)))
|
||||
return -EFAULT;
|
||||
|
||||
/* avoid a warning on 64-bit, this casting isn't very nice, but the API is set so too late */
|
||||
if (put_user((void *)(unsigned long)maplist->user_token, &argp->handle))
|
||||
return -EFAULT;
|
||||
map->handle = (void *)(unsigned long)maplist->user_token;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -372,7 +358,7 @@ int drm_addmap_ioctl(struct inode *inode, struct file *filp,
|
|||
* isn't in use.
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg pointer to a struct drm_map structure.
|
||||
* \return zero on success or a negative value on error.
|
||||
|
@ -453,24 +439,18 @@ int drm_rmmap(struct drm_device *dev, drm_local_map_t *map)
|
|||
* gets used by drivers that the server doesn't need to care about. This seems
|
||||
* unlikely.
|
||||
*/
|
||||
int drm_rmmap_ioctl(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_rmmap_ioctl(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_map request;
|
||||
struct drm_map *request = data;
|
||||
drm_local_map_t *map = NULL;
|
||||
struct drm_map_list *r_list;
|
||||
int ret;
|
||||
|
||||
if (copy_from_user(&request, (struct drm_map __user *) arg, sizeof(request))) {
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
mutex_lock(&dev->struct_mutex);
|
||||
list_for_each_entry(r_list, &dev->maplist, head) {
|
||||
if (r_list->map &&
|
||||
r_list->user_token == (unsigned long)request.handle &&
|
||||
r_list->user_token == (unsigned long)request->handle &&
|
||||
r_list->map->flags & _DRM_REMOVABLE) {
|
||||
map = r_list->map;
|
||||
break;
|
||||
|
@ -661,7 +641,7 @@ int drm_addbufs_agp(struct drm_device * dev, struct drm_buf_desc * request)
|
|||
buf->waiting = 0;
|
||||
buf->pending = 0;
|
||||
init_waitqueue_head(&buf->dma_wait);
|
||||
buf->filp = NULL;
|
||||
buf->file_priv = NULL;
|
||||
|
||||
buf->dev_priv_size = dev->driver->dev_priv_size;
|
||||
buf->dev_private = drm_alloc(buf->dev_priv_size, DRM_MEM_BUFS);
|
||||
|
@ -872,7 +852,7 @@ int drm_addbufs_pci(struct drm_device * dev, struct drm_buf_desc * request)
|
|||
buf->waiting = 0;
|
||||
buf->pending = 0;
|
||||
init_waitqueue_head(&buf->dma_wait);
|
||||
buf->filp = NULL;
|
||||
buf->file_priv = NULL;
|
||||
|
||||
buf->dev_priv_size = dev->driver->dev_priv_size;
|
||||
buf->dev_private = drm_alloc(buf->dev_priv_size,
|
||||
|
@ -1050,7 +1030,7 @@ static int drm_addbufs_sg(struct drm_device * dev, struct drm_buf_desc * request
|
|||
buf->waiting = 0;
|
||||
buf->pending = 0;
|
||||
init_waitqueue_head(&buf->dma_wait);
|
||||
buf->filp = NULL;
|
||||
buf->file_priv = NULL;
|
||||
|
||||
buf->dev_priv_size = dev->driver->dev_priv_size;
|
||||
buf->dev_private = drm_alloc(buf->dev_priv_size, DRM_MEM_BUFS);
|
||||
|
@ -1211,7 +1191,7 @@ static int drm_addbufs_fb(struct drm_device * dev, struct drm_buf_desc * request
|
|||
buf->waiting = 0;
|
||||
buf->pending = 0;
|
||||
init_waitqueue_head(&buf->dma_wait);
|
||||
buf->filp = NULL;
|
||||
buf->file_priv = NULL;
|
||||
|
||||
buf->dev_priv_size = dev->driver->dev_priv_size;
|
||||
buf->dev_private = drm_alloc(buf->dev_priv_size, DRM_MEM_BUFS);
|
||||
|
@ -1275,7 +1255,7 @@ static int drm_addbufs_fb(struct drm_device * dev, struct drm_buf_desc * request
|
|||
* Add buffers for DMA transfers (ioctl).
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg pointer to a struct drm_buf_desc request.
|
||||
* \return zero on success or a negative number on failure.
|
||||
|
@ -1285,38 +1265,27 @@ static int drm_addbufs_fb(struct drm_device * dev, struct drm_buf_desc * request
|
|||
* addbufs_sg() or addbufs_pci() for AGP, scatter-gather or consistent
|
||||
* PCI memory respectively.
|
||||
*/
|
||||
int drm_addbufs(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_addbufs(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_buf_desc request;
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_buf_desc *request = data;
|
||||
int ret;
|
||||
|
||||
if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
|
||||
return -EINVAL;
|
||||
|
||||
if (copy_from_user(&request, (struct drm_buf_desc __user *) arg,
|
||||
sizeof(request)))
|
||||
return -EFAULT;
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
if (request.flags & _DRM_AGP_BUFFER)
|
||||
ret = drm_addbufs_agp(dev, &request);
|
||||
if (request->flags & _DRM_AGP_BUFFER)
|
||||
ret = drm_addbufs_agp(dev, request);
|
||||
else
|
||||
#endif
|
||||
if (request.flags & _DRM_SG_BUFFER)
|
||||
ret = drm_addbufs_sg(dev, &request);
|
||||
else if (request.flags & _DRM_FB_BUFFER)
|
||||
ret = drm_addbufs_fb(dev, &request);
|
||||
if (request->flags & _DRM_SG_BUFFER)
|
||||
ret = drm_addbufs_sg(dev, request);
|
||||
else if (request->flags & _DRM_FB_BUFFER)
|
||||
ret = drm_addbufs_fb(dev, request);
|
||||
else
|
||||
ret = drm_addbufs_pci(dev, &request);
|
||||
ret = drm_addbufs_pci(dev, request);
|
||||
|
||||
if (ret == 0) {
|
||||
if (copy_to_user((void __user *)arg, &request, sizeof(request))) {
|
||||
ret = -EFAULT;
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
@ -1328,7 +1297,7 @@ int drm_addbufs(struct inode *inode, struct file *filp,
|
|||
* large buffers can be used for image transfer).
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg pointer to a drm_buf_info structure.
|
||||
* \return zero on success or a negative number on failure.
|
||||
|
@ -1337,14 +1306,11 @@ int drm_addbufs(struct inode *inode, struct file *filp,
|
|||
* lock, preventing of allocating more buffers after this call. Information
|
||||
* about each requested buffer is then copied into user space.
|
||||
*/
|
||||
int drm_infobufs(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_infobufs(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_device_dma *dma = dev->dma;
|
||||
struct drm_buf_info request;
|
||||
struct drm_buf_info __user *argp = (void __user *)arg;
|
||||
struct drm_buf_info *request = data;
|
||||
int i;
|
||||
int count;
|
||||
|
||||
|
@ -1362,9 +1328,6 @@ int drm_infobufs(struct inode *inode, struct file *filp,
|
|||
++dev->buf_use; /* Can't allocate more after this call */
|
||||
spin_unlock(&dev->count_lock);
|
||||
|
||||
if (copy_from_user(&request, argp, sizeof(request)))
|
||||
return -EFAULT;
|
||||
|
||||
for (i = 0, count = 0; i < DRM_MAX_ORDER + 1; i++) {
|
||||
if (dma->bufs[i].buf_count)
|
||||
++count;
|
||||
|
@ -1372,11 +1335,11 @@ int drm_infobufs(struct inode *inode, struct file *filp,
|
|||
|
||||
DRM_DEBUG("count = %d\n", count);
|
||||
|
||||
if (request.count >= count) {
|
||||
if (request->count >= count) {
|
||||
for (i = 0, count = 0; i < DRM_MAX_ORDER + 1; i++) {
|
||||
if (dma->bufs[i].buf_count) {
|
||||
struct drm_buf_desc __user *to =
|
||||
&request.list[count];
|
||||
&request->list[count];
|
||||
struct drm_buf_entry *from = &dma->bufs[i];
|
||||
struct drm_freelist *list = &dma->bufs[i].freelist;
|
||||
if (copy_to_user(&to->count,
|
||||
|
@ -1403,10 +1366,7 @@ int drm_infobufs(struct inode *inode, struct file *filp,
|
|||
}
|
||||
}
|
||||
}
|
||||
request.count = count;
|
||||
|
||||
if (copy_to_user(argp, &request, sizeof(request)))
|
||||
return -EFAULT;
|
||||
request->count = count;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
@ -1415,7 +1375,7 @@ int drm_infobufs(struct inode *inode, struct file *filp,
|
|||
* Specifies a low and high water mark for buffer allocation
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg a pointer to a drm_buf_desc structure.
|
||||
* \return zero on success or a negative number on failure.
|
||||
|
@ -1425,13 +1385,11 @@ int drm_infobufs(struct inode *inode, struct file *filp,
|
|||
*
|
||||
* \note This ioctl is deprecated and mostly never used.
|
||||
*/
|
||||
int drm_markbufs(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_markbufs(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_device_dma *dma = dev->dma;
|
||||
struct drm_buf_desc request;
|
||||
struct drm_buf_desc *request = data;
|
||||
int order;
|
||||
struct drm_buf_entry *entry;
|
||||
|
||||
|
@ -1441,24 +1399,20 @@ int drm_markbufs(struct inode *inode, struct file *filp,
|
|||
if (!dma)
|
||||
return -EINVAL;
|
||||
|
||||
if (copy_from_user(&request,
|
||||
(struct drm_buf_desc __user *) arg, sizeof(request)))
|
||||
return -EFAULT;
|
||||
|
||||
DRM_DEBUG("%d, %d, %d\n",
|
||||
request.size, request.low_mark, request.high_mark);
|
||||
order = drm_order(request.size);
|
||||
request->size, request->low_mark, request->high_mark);
|
||||
order = drm_order(request->size);
|
||||
if (order < DRM_MIN_ORDER || order > DRM_MAX_ORDER)
|
||||
return -EINVAL;
|
||||
entry = &dma->bufs[order];
|
||||
|
||||
if (request.low_mark < 0 || request.low_mark > entry->buf_count)
|
||||
if (request->low_mark < 0 || request->low_mark > entry->buf_count)
|
||||
return -EINVAL;
|
||||
if (request.high_mark < 0 || request.high_mark > entry->buf_count)
|
||||
if (request->high_mark < 0 || request->high_mark > entry->buf_count)
|
||||
return -EINVAL;
|
||||
|
||||
entry->freelist.low_mark = request.low_mark;
|
||||
entry->freelist.high_mark = request.high_mark;
|
||||
entry->freelist.low_mark = request->low_mark;
|
||||
entry->freelist.high_mark = request->high_mark;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
@ -1467,7 +1421,7 @@ int drm_markbufs(struct inode *inode, struct file *filp,
|
|||
* Unreserve the buffers in list, previously reserved using drmDMA.
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg pointer to a drm_buf_free structure.
|
||||
* \return zero on success or a negative number on failure.
|
||||
|
@ -1475,13 +1429,11 @@ int drm_markbufs(struct inode *inode, struct file *filp,
|
|||
* Calls free_buffer() for each used buffer.
|
||||
* This function is primarily used for debugging.
|
||||
*/
|
||||
int drm_freebufs(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_freebufs(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_device_dma *dma = dev->dma;
|
||||
struct drm_buf_free request;
|
||||
struct drm_buf_free *request = data;
|
||||
int i;
|
||||
int idx;
|
||||
struct drm_buf *buf;
|
||||
|
@ -1492,13 +1444,9 @@ int drm_freebufs(struct inode *inode, struct file *filp,
|
|||
if (!dma)
|
||||
return -EINVAL;
|
||||
|
||||
if (copy_from_user(&request,
|
||||
(struct drm_buf_free __user *) arg, sizeof(request)))
|
||||
return -EFAULT;
|
||||
|
||||
DRM_DEBUG("%d\n", request.count);
|
||||
for (i = 0; i < request.count; i++) {
|
||||
if (copy_from_user(&idx, &request.list[i], sizeof(idx)))
|
||||
DRM_DEBUG("%d\n", request->count);
|
||||
for (i = 0; i < request->count; i++) {
|
||||
if (copy_from_user(&idx, &request->list[i], sizeof(idx)))
|
||||
return -EFAULT;
|
||||
if (idx < 0 || idx >= dma->buf_count) {
|
||||
DRM_ERROR("Index %d (of %d max)\n",
|
||||
|
@ -1506,7 +1454,7 @@ int drm_freebufs(struct inode *inode, struct file *filp,
|
|||
return -EINVAL;
|
||||
}
|
||||
buf = dma->buflist[idx];
|
||||
if (buf->filp != filp) {
|
||||
if (buf->file_priv != file_priv) {
|
||||
DRM_ERROR("Process %d freeing buffer not owned\n",
|
||||
current->pid);
|
||||
return -EINVAL;
|
||||
|
@ -1521,7 +1469,7 @@ int drm_freebufs(struct inode *inode, struct file *filp,
|
|||
* Maps all of the DMA buffers into client-virtual space (ioctl).
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg pointer to a drm_buf_map structure.
|
||||
* \return zero on success or a negative number on failure.
|
||||
|
@ -1531,18 +1479,15 @@ int drm_freebufs(struct inode *inode, struct file *filp,
|
|||
* offset equal to 0, which drm_mmap() interpretes as PCI buffers and calls
|
||||
* drm_mmap_dma().
|
||||
*/
|
||||
int drm_mapbufs(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_mapbufs(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_device_dma *dma = dev->dma;
|
||||
struct drm_buf_map __user *argp = (void __user *)arg;
|
||||
int retcode = 0;
|
||||
const int zero = 0;
|
||||
unsigned long virtual;
|
||||
unsigned long address;
|
||||
struct drm_buf_map request;
|
||||
struct drm_buf_map *request = data;
|
||||
int i;
|
||||
|
||||
if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA))
|
||||
|
@ -1559,10 +1504,7 @@ int drm_mapbufs(struct inode *inode, struct file *filp,
|
|||
dev->buf_use++; /* Can't allocate more after this call */
|
||||
spin_unlock(&dev->count_lock);
|
||||
|
||||
if (copy_from_user(&request, argp, sizeof(request)))
|
||||
return -EFAULT;
|
||||
|
||||
if (request.count >= dma->buf_count) {
|
||||
if (request->count >= dma->buf_count) {
|
||||
if ((drm_core_has_AGP(dev) && (dma->flags & _DRM_DMA_USE_AGP))
|
||||
|| (drm_core_check_feature(dev, DRIVER_SG)
|
||||
&& (dma->flags & _DRM_DMA_USE_SG))
|
||||
|
@ -1575,15 +1517,15 @@ int drm_mapbufs(struct inode *inode, struct file *filp,
|
|||
retcode = -EINVAL;
|
||||
goto done;
|
||||
}
|
||||
|
||||
down_write(¤t->mm->mmap_sem);
|
||||
virtual = do_mmap(filp, 0, map->size,
|
||||
virtual = do_mmap(file_priv->filp, 0, map->size,
|
||||
PROT_READ | PROT_WRITE,
|
||||
MAP_SHARED, token);
|
||||
MAP_SHARED,
|
||||
token);
|
||||
up_write(¤t->mm->mmap_sem);
|
||||
} else {
|
||||
down_write(¤t->mm->mmap_sem);
|
||||
virtual = do_mmap(filp, 0, dma->byte_count,
|
||||
virtual = do_mmap(file_priv->filp, 0, dma->byte_count,
|
||||
PROT_READ | PROT_WRITE,
|
||||
MAP_SHARED, 0);
|
||||
up_write(¤t->mm->mmap_sem);
|
||||
|
@ -1593,28 +1535,28 @@ int drm_mapbufs(struct inode *inode, struct file *filp,
|
|||
retcode = (signed long)virtual;
|
||||
goto done;
|
||||
}
|
||||
request.virtual = (void __user *)virtual;
|
||||
request->virtual = (void __user *)virtual;
|
||||
|
||||
for (i = 0; i < dma->buf_count; i++) {
|
||||
if (copy_to_user(&request.list[i].idx,
|
||||
if (copy_to_user(&request->list[i].idx,
|
||||
&dma->buflist[i]->idx,
|
||||
sizeof(request.list[0].idx))) {
|
||||
sizeof(request->list[0].idx))) {
|
||||
retcode = -EFAULT;
|
||||
goto done;
|
||||
}
|
||||
if (copy_to_user(&request.list[i].total,
|
||||
if (copy_to_user(&request->list[i].total,
|
||||
&dma->buflist[i]->total,
|
||||
sizeof(request.list[0].total))) {
|
||||
sizeof(request->list[0].total))) {
|
||||
retcode = -EFAULT;
|
||||
goto done;
|
||||
}
|
||||
if (copy_to_user(&request.list[i].used,
|
||||
if (copy_to_user(&request->list[i].used,
|
||||
&zero, sizeof(zero))) {
|
||||
retcode = -EFAULT;
|
||||
goto done;
|
||||
}
|
||||
address = virtual + dma->buflist[i]->offset; /* *** */
|
||||
if (copy_to_user(&request.list[i].address,
|
||||
if (copy_to_user(&request->list[i].address,
|
||||
&address, sizeof(address))) {
|
||||
retcode = -EFAULT;
|
||||
goto done;
|
||||
|
@ -1622,11 +1564,8 @@ int drm_mapbufs(struct inode *inode, struct file *filp,
|
|||
}
|
||||
}
|
||||
done:
|
||||
request.count = dma->buf_count;
|
||||
DRM_DEBUG("%d buffers, retcode = %d\n", request.count, retcode);
|
||||
|
||||
if (copy_to_user(argp, &request, sizeof(request)))
|
||||
return -EFAULT;
|
||||
request->count = dma->buf_count;
|
||||
DRM_DEBUG("%d buffers, retcode = %d\n", request->count, retcode);
|
||||
|
||||
return retcode;
|
||||
}
|
||||
|
|
|
@ -131,7 +131,7 @@ void drm_ctxbitmap_cleanup(struct drm_device * dev)
|
|||
* Get per-context SAREA.
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg user argument pointing to a drm_ctx_priv_map structure.
|
||||
* \return zero on success or a negative number on failure.
|
||||
|
@ -139,22 +139,16 @@ void drm_ctxbitmap_cleanup(struct drm_device * dev)
|
|||
* Gets the map from drm_device::ctx_idr with the handle specified and
|
||||
* returns its handle.
|
||||
*/
|
||||
int drm_getsareactx(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_getsareactx(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_ctx_priv_map __user *argp = (void __user *)arg;
|
||||
struct drm_ctx_priv_map request;
|
||||
struct drm_ctx_priv_map *request = data;
|
||||
struct drm_map *map;
|
||||
struct drm_map_list *_entry;
|
||||
|
||||
if (copy_from_user(&request, argp, sizeof(request)))
|
||||
return -EFAULT;
|
||||
|
||||
mutex_lock(&dev->struct_mutex);
|
||||
|
||||
map = idr_find(&dev->ctx_idr, request.ctx_id);
|
||||
map = idr_find(&dev->ctx_idr, request->ctx_id);
|
||||
if (!map) {
|
||||
mutex_unlock(&dev->struct_mutex);
|
||||
return -EINVAL;
|
||||
|
@ -162,19 +156,17 @@ int drm_getsareactx(struct inode *inode, struct file *filp,
|
|||
|
||||
mutex_unlock(&dev->struct_mutex);
|
||||
|
||||
request.handle = NULL;
|
||||
request->handle = NULL;
|
||||
list_for_each_entry(_entry, &dev->maplist, head) {
|
||||
if (_entry->map == map) {
|
||||
request.handle =
|
||||
request->handle =
|
||||
(void *)(unsigned long)_entry->user_token;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (request.handle == NULL)
|
||||
if (request->handle == NULL)
|
||||
return -EINVAL;
|
||||
|
||||
if (copy_to_user(argp, &request, sizeof(request)))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -182,7 +174,7 @@ int drm_getsareactx(struct inode *inode, struct file *filp,
|
|||
* Set per-context SAREA.
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg user argument pointing to a drm_ctx_priv_map structure.
|
||||
* \return zero on success or a negative number on failure.
|
||||
|
@ -190,24 +182,17 @@ int drm_getsareactx(struct inode *inode, struct file *filp,
|
|||
* Searches the mapping specified in \p arg and update the entry in
|
||||
* drm_device::ctx_idr with it.
|
||||
*/
|
||||
int drm_setsareactx(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_setsareactx(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_ctx_priv_map request;
|
||||
struct drm_ctx_priv_map *request = data;
|
||||
struct drm_map *map = NULL;
|
||||
struct drm_map_list *r_list = NULL;
|
||||
|
||||
if (copy_from_user(&request,
|
||||
(struct drm_ctx_priv_map __user *) arg,
|
||||
sizeof(request)))
|
||||
return -EFAULT;
|
||||
|
||||
mutex_lock(&dev->struct_mutex);
|
||||
list_for_each_entry(r_list, &dev->maplist, head) {
|
||||
if (r_list->map
|
||||
&& r_list->user_token == (unsigned long)request.handle)
|
||||
&& r_list->user_token == (unsigned long) request->handle)
|
||||
goto found;
|
||||
}
|
||||
bad:
|
||||
|
@ -219,10 +204,11 @@ int drm_setsareactx(struct inode *inode, struct file *filp,
|
|||
if (!map)
|
||||
goto bad;
|
||||
|
||||
if (IS_ERR(idr_replace(&dev->ctx_idr, map, request.ctx_id)))
|
||||
if (IS_ERR(idr_replace(&dev->ctx_idr, map, request->ctx_id)))
|
||||
goto bad;
|
||||
|
||||
mutex_unlock(&dev->struct_mutex);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -292,34 +278,28 @@ static int drm_context_switch_complete(struct drm_device * dev, int new)
|
|||
* Reserve contexts.
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg user argument pointing to a drm_ctx_res structure.
|
||||
* \return zero on success or a negative number on failure.
|
||||
*/
|
||||
int drm_resctx(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_resctx(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_ctx_res res;
|
||||
struct drm_ctx_res __user *argp = (void __user *)arg;
|
||||
struct drm_ctx_res *res = data;
|
||||
struct drm_ctx ctx;
|
||||
int i;
|
||||
|
||||
if (copy_from_user(&res, argp, sizeof(res)))
|
||||
return -EFAULT;
|
||||
|
||||
if (res.count >= DRM_RESERVED_CONTEXTS) {
|
||||
if (res->count >= DRM_RESERVED_CONTEXTS) {
|
||||
memset(&ctx, 0, sizeof(ctx));
|
||||
for (i = 0; i < DRM_RESERVED_CONTEXTS; i++) {
|
||||
ctx.handle = i;
|
||||
if (copy_to_user(&res.contexts[i], &ctx, sizeof(ctx)))
|
||||
if (copy_to_user(&res->contexts[i], &ctx, sizeof(ctx)))
|
||||
return -EFAULT;
|
||||
}
|
||||
}
|
||||
res.count = DRM_RESERVED_CONTEXTS;
|
||||
res->count = DRM_RESERVED_CONTEXTS;
|
||||
|
||||
if (copy_to_user(argp, &res, sizeof(res)))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -327,40 +307,34 @@ int drm_resctx(struct inode *inode, struct file *filp,
|
|||
* Add context.
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg user argument pointing to a drm_ctx structure.
|
||||
* \return zero on success or a negative number on failure.
|
||||
*
|
||||
* Get a new handle for the context and copy to userspace.
|
||||
*/
|
||||
int drm_addctx(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_addctx(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_ctx_list *ctx_entry;
|
||||
struct drm_ctx __user *argp = (void __user *)arg;
|
||||
struct drm_ctx ctx;
|
||||
struct drm_ctx *ctx = data;
|
||||
|
||||
if (copy_from_user(&ctx, argp, sizeof(ctx)))
|
||||
return -EFAULT;
|
||||
|
||||
ctx.handle = drm_ctxbitmap_next(dev);
|
||||
if (ctx.handle == DRM_KERNEL_CONTEXT) {
|
||||
ctx->handle = drm_ctxbitmap_next(dev);
|
||||
if (ctx->handle == DRM_KERNEL_CONTEXT) {
|
||||
/* Skip kernel's context and get a new one. */
|
||||
ctx.handle = drm_ctxbitmap_next(dev);
|
||||
ctx->handle = drm_ctxbitmap_next(dev);
|
||||
}
|
||||
DRM_DEBUG("%d\n", ctx.handle);
|
||||
if (ctx.handle == -1) {
|
||||
DRM_DEBUG("%d\n", ctx->handle);
|
||||
if (ctx->handle == -1) {
|
||||
DRM_DEBUG("Not enough free contexts.\n");
|
||||
/* Should this return -EBUSY instead? */
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
if (ctx.handle != DRM_KERNEL_CONTEXT) {
|
||||
if (ctx->handle != DRM_KERNEL_CONTEXT) {
|
||||
if (dev->driver->context_ctor)
|
||||
if (!dev->driver->context_ctor(dev, ctx.handle)) {
|
||||
if (!dev->driver->context_ctor(dev, ctx->handle)) {
|
||||
DRM_DEBUG("Running out of ctxs or memory.\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
@ -373,21 +347,18 @@ int drm_addctx(struct inode *inode, struct file *filp,
|
|||
}
|
||||
|
||||
INIT_LIST_HEAD(&ctx_entry->head);
|
||||
ctx_entry->handle = ctx.handle;
|
||||
ctx_entry->tag = priv;
|
||||
ctx_entry->handle = ctx->handle;
|
||||
ctx_entry->tag = file_priv;
|
||||
|
||||
mutex_lock(&dev->ctxlist_mutex);
|
||||
list_add(&ctx_entry->head, &dev->ctxlist);
|
||||
++dev->ctx_count;
|
||||
mutex_unlock(&dev->ctxlist_mutex);
|
||||
|
||||
if (copy_to_user(argp, &ctx, sizeof(ctx)))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int drm_modctx(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_modctx(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
/* This does nothing */
|
||||
return 0;
|
||||
|
@ -397,25 +368,18 @@ int drm_modctx(struct inode *inode, struct file *filp,
|
|||
* Get context.
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg user argument pointing to a drm_ctx structure.
|
||||
* \return zero on success or a negative number on failure.
|
||||
*/
|
||||
int drm_getctx(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_getctx(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_ctx __user *argp = (void __user *)arg;
|
||||
struct drm_ctx ctx;
|
||||
|
||||
if (copy_from_user(&ctx, argp, sizeof(ctx)))
|
||||
return -EFAULT;
|
||||
struct drm_ctx *ctx = data;
|
||||
|
||||
/* This is 0, because we don't handle any context flags */
|
||||
ctx.flags = 0;
|
||||
ctx->flags = 0;
|
||||
|
||||
if (copy_to_user(argp, &ctx, sizeof(ctx)))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -423,50 +387,40 @@ int drm_getctx(struct inode *inode, struct file *filp,
|
|||
* Switch context.
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg user argument pointing to a drm_ctx structure.
|
||||
* \return zero on success or a negative number on failure.
|
||||
*
|
||||
* Calls context_switch().
|
||||
*/
|
||||
int drm_switchctx(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_switchctx(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_ctx ctx;
|
||||
struct drm_ctx *ctx = data;
|
||||
|
||||
if (copy_from_user(&ctx, (struct drm_ctx __user *) arg, sizeof(ctx)))
|
||||
return -EFAULT;
|
||||
|
||||
DRM_DEBUG("%d\n", ctx.handle);
|
||||
return drm_context_switch(dev, dev->last_context, ctx.handle);
|
||||
DRM_DEBUG("%d\n", ctx->handle);
|
||||
return drm_context_switch(dev, dev->last_context, ctx->handle);
|
||||
}
|
||||
|
||||
/**
|
||||
* New context.
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg user argument pointing to a drm_ctx structure.
|
||||
* \return zero on success or a negative number on failure.
|
||||
*
|
||||
* Calls context_switch_complete().
|
||||
*/
|
||||
int drm_newctx(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_newctx(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_ctx ctx;
|
||||
struct drm_ctx *ctx = data;
|
||||
|
||||
if (copy_from_user(&ctx, (struct drm_ctx __user *) arg, sizeof(ctx)))
|
||||
return -EFAULT;
|
||||
|
||||
DRM_DEBUG("%d\n", ctx.handle);
|
||||
drm_context_switch_complete(dev, ctx.handle);
|
||||
DRM_DEBUG("%d\n", ctx->handle);
|
||||
drm_context_switch_complete(dev, ctx->handle);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
@ -475,31 +429,26 @@ int drm_newctx(struct inode *inode, struct file *filp,
|
|||
* Remove context.
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg user argument pointing to a drm_ctx structure.
|
||||
* \return zero on success or a negative number on failure.
|
||||
*
|
||||
* If not the special kernel context, calls ctxbitmap_free() to free the specified context.
|
||||
*/
|
||||
int drm_rmctx(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_rmctx(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_ctx ctx;
|
||||
struct drm_ctx *ctx = data;
|
||||
|
||||
if (copy_from_user(&ctx, (struct drm_ctx __user *) arg, sizeof(ctx)))
|
||||
return -EFAULT;
|
||||
|
||||
DRM_DEBUG("%d\n", ctx.handle);
|
||||
if (ctx.handle == DRM_KERNEL_CONTEXT + 1) {
|
||||
priv->remove_auth_on_close = 1;
|
||||
DRM_DEBUG("%d\n", ctx->handle);
|
||||
if (ctx->handle == DRM_KERNEL_CONTEXT + 1) {
|
||||
file_priv->remove_auth_on_close = 1;
|
||||
}
|
||||
if (ctx.handle != DRM_KERNEL_CONTEXT) {
|
||||
if (ctx->handle != DRM_KERNEL_CONTEXT) {
|
||||
if (dev->driver->context_dtor)
|
||||
dev->driver->context_dtor(dev, ctx.handle);
|
||||
drm_ctxbitmap_free(dev, ctx.handle);
|
||||
dev->driver->context_dtor(dev, ctx->handle);
|
||||
drm_ctxbitmap_free(dev, ctx->handle);
|
||||
}
|
||||
|
||||
mutex_lock(&dev->ctxlist_mutex);
|
||||
|
@ -507,7 +456,7 @@ int drm_rmctx(struct inode *inode, struct file *filp,
|
|||
struct drm_ctx_list *pos, *n;
|
||||
|
||||
list_for_each_entry_safe(pos, n, &dev->ctxlist, head) {
|
||||
if (pos->handle == ctx.handle) {
|
||||
if (pos->handle == ctx->handle) {
|
||||
list_del(&pos->head);
|
||||
drm_free(pos, sizeof(*pos), DRM_MEM_CTXLIST);
|
||||
--dev->ctx_count;
|
||||
|
|
|
@ -136,7 +136,7 @@ void drm_free_buffer(struct drm_device *dev, struct drm_buf * buf)
|
|||
|
||||
buf->waiting = 0;
|
||||
buf->pending = 0;
|
||||
buf->filp = NULL;
|
||||
buf->file_priv = NULL;
|
||||
buf->used = 0;
|
||||
|
||||
if (drm_core_check_feature(dev, DRIVER_DMA_QUEUE)
|
||||
|
@ -148,11 +148,12 @@ void drm_free_buffer(struct drm_device *dev, struct drm_buf * buf)
|
|||
/**
|
||||
* Reclaim the buffers.
|
||||
*
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
*
|
||||
* Frees each buffer associated with \p filp not already on the hardware.
|
||||
* Frees each buffer associated with \p file_priv not already on the hardware.
|
||||
*/
|
||||
void drm_core_reclaim_buffers(struct drm_device *dev, struct file *filp)
|
||||
void drm_core_reclaim_buffers(struct drm_device *dev,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_device_dma *dma = dev->dma;
|
||||
int i;
|
||||
|
@ -160,7 +161,7 @@ void drm_core_reclaim_buffers(struct drm_device *dev, struct file *filp)
|
|||
if (!dma)
|
||||
return;
|
||||
for (i = 0; i < dma->buf_count; i++) {
|
||||
if (dma->buflist[i]->filp == filp) {
|
||||
if (dma->buflist[i]->file_priv == file_priv) {
|
||||
switch (dma->buflist[i]->list) {
|
||||
case DRM_LIST_NONE:
|
||||
drm_free_buffer(dev, dma->buflist[i]);
|
||||
|
|
|
@ -40,11 +40,10 @@
|
|||
/**
|
||||
* Allocate drawable ID and memory to store information about it.
|
||||
*/
|
||||
int drm_adddraw(DRM_IOCTL_ARGS)
|
||||
int drm_adddraw(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
unsigned long irqflags;
|
||||
struct drm_draw draw;
|
||||
struct drm_draw *draw = data;
|
||||
int new_id = 0;
|
||||
int ret;
|
||||
|
||||
|
@ -63,11 +62,9 @@ again:
|
|||
|
||||
spin_unlock_irqrestore(&dev->drw_lock, irqflags);
|
||||
|
||||
draw.handle = new_id;
|
||||
draw->handle = new_id;
|
||||
|
||||
DRM_DEBUG("%d\n", draw.handle);
|
||||
|
||||
DRM_COPY_TO_USER_IOCTL((struct drm_draw __user *)data, draw, sizeof(draw));
|
||||
DRM_DEBUG("%d\n", draw->handle);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
@ -75,72 +72,64 @@ again:
|
|||
/**
|
||||
* Free drawable ID and memory to store information about it.
|
||||
*/
|
||||
int drm_rmdraw(DRM_IOCTL_ARGS)
|
||||
int drm_rmdraw(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
struct drm_draw draw;
|
||||
struct drm_draw *draw = data;
|
||||
unsigned long irqflags;
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(draw, (struct drm_draw __user *) data,
|
||||
sizeof(draw));
|
||||
|
||||
spin_lock_irqsave(&dev->drw_lock, irqflags);
|
||||
|
||||
drm_free(drm_get_drawable_info(dev, draw.handle),
|
||||
drm_free(drm_get_drawable_info(dev, draw->handle),
|
||||
sizeof(struct drm_drawable_info), DRM_MEM_BUFS);
|
||||
|
||||
idr_remove(&dev->drw_idr, draw.handle);
|
||||
idr_remove(&dev->drw_idr, draw->handle);
|
||||
|
||||
spin_unlock_irqrestore(&dev->drw_lock, irqflags);
|
||||
DRM_DEBUG("%d\n", draw.handle);
|
||||
DRM_DEBUG("%d\n", draw->handle);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int drm_update_drawable_info(DRM_IOCTL_ARGS)
|
||||
int drm_update_drawable_info(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
struct drm_update_draw update;
|
||||
struct drm_update_draw *update = data;
|
||||
unsigned long irqflags;
|
||||
struct drm_clip_rect *rects;
|
||||
struct drm_drawable_info *info;
|
||||
int err;
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(update, (struct drm_update_draw __user *) data,
|
||||
sizeof(update));
|
||||
|
||||
info = idr_find(&dev->drw_idr, update.handle);
|
||||
info = idr_find(&dev->drw_idr, update->handle);
|
||||
if (!info) {
|
||||
info = drm_calloc(1, sizeof(*info), DRM_MEM_BUFS);
|
||||
if (!info)
|
||||
return -ENOMEM;
|
||||
if (IS_ERR(idr_replace(&dev->drw_idr, info, update.handle))) {
|
||||
DRM_ERROR("No such drawable %d\n", update.handle);
|
||||
if (IS_ERR(idr_replace(&dev->drw_idr, info, update->handle))) {
|
||||
DRM_ERROR("No such drawable %d\n", update->handle);
|
||||
drm_free(info, sizeof(*info), DRM_MEM_BUFS);
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
switch (update.type) {
|
||||
switch (update->type) {
|
||||
case DRM_DRAWABLE_CLIPRECTS:
|
||||
if (update.num != info->num_rects) {
|
||||
rects = drm_alloc(update.num * sizeof(struct drm_clip_rect),
|
||||
if (update->num != info->num_rects) {
|
||||
rects = drm_alloc(update->num * sizeof(struct drm_clip_rect),
|
||||
DRM_MEM_BUFS);
|
||||
} else
|
||||
rects = info->rects;
|
||||
|
||||
if (update.num && !rects) {
|
||||
if (update->num && !rects) {
|
||||
DRM_ERROR("Failed to allocate cliprect memory\n");
|
||||
err = DRM_ERR(ENOMEM);
|
||||
err = -ENOMEM;
|
||||
goto error;
|
||||
}
|
||||
|
||||
if (update.num && DRM_COPY_FROM_USER(rects,
|
||||
if (update->num && DRM_COPY_FROM_USER(rects,
|
||||
(struct drm_clip_rect __user *)
|
||||
(unsigned long)update.data,
|
||||
update.num *
|
||||
(unsigned long)update->data,
|
||||
update->num *
|
||||
sizeof(*rects))) {
|
||||
DRM_ERROR("Failed to copy cliprects from userspace\n");
|
||||
err = DRM_ERR(EFAULT);
|
||||
err = -EFAULT;
|
||||
goto error;
|
||||
}
|
||||
|
||||
|
@ -152,23 +141,23 @@ int drm_update_drawable_info(DRM_IOCTL_ARGS)
|
|||
}
|
||||
|
||||
info->rects = rects;
|
||||
info->num_rects = update.num;
|
||||
info->num_rects = update->num;
|
||||
|
||||
spin_unlock_irqrestore(&dev->drw_lock, irqflags);
|
||||
|
||||
DRM_DEBUG("Updated %d cliprects for drawable %d\n",
|
||||
info->num_rects, update.handle);
|
||||
info->num_rects, update->handle);
|
||||
break;
|
||||
default:
|
||||
DRM_ERROR("Invalid update type %d\n", update.type);
|
||||
return DRM_ERR(EINVAL);
|
||||
DRM_ERROR("Invalid update type %d\n", update->type);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
error:
|
||||
if (rects != info->rects)
|
||||
drm_free(rects, update.num * sizeof(struct drm_clip_rect),
|
||||
drm_free(rects, update->num * sizeof(struct drm_clip_rect),
|
||||
DRM_MEM_BUFS);
|
||||
|
||||
return err;
|
||||
|
|
|
@ -49,73 +49,74 @@
|
|||
#include "drmP.h"
|
||||
#include "drm_core.h"
|
||||
|
||||
static int drm_version(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
static int drm_version(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv);
|
||||
|
||||
/** Ioctl table */
|
||||
static drm_ioctl_desc_t drm_ioctls[] = {
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_VERSION)] = {drm_version, 0},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_GET_UNIQUE)] = {drm_getunique, 0},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_GET_MAGIC)] = {drm_getmagic, 0},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_IRQ_BUSID)] = {drm_irq_by_busid, DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_GET_MAP)] = {drm_getmap, 0},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_GET_CLIENT)] = {drm_getclient, 0},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_GET_STATS)] = {drm_getstats, 0},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_SET_VERSION)] = {drm_setversion, DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_SET_UNIQUE)] = {drm_setunique, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_BLOCK)] = {drm_noop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_UNBLOCK)] = {drm_noop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_AUTH_MAGIC)] = {drm_authmagic, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
static struct drm_ioctl_desc drm_ioctls[] = {
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_VERSION, drm_version, 0),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_GET_UNIQUE, drm_getunique, 0),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_GET_MAGIC, drm_getmagic, 0),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_IRQ_BUSID, drm_irq_by_busid, DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_GET_MAP, drm_getmap, 0),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_GET_CLIENT, drm_getclient, 0),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_GET_STATS, drm_getstats, 0),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_SET_VERSION, drm_setversion, DRM_MASTER|DRM_ROOT_ONLY),
|
||||
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_ADD_MAP)] = {drm_addmap_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_RM_MAP)] = {drm_rmmap_ioctl, DRM_AUTH},
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_SET_UNIQUE, drm_setunique, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_BLOCK, drm_noop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_UNBLOCK, drm_noop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_AUTH_MAGIC, drm_authmagic, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_SET_SAREA_CTX)] = {drm_setsareactx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_GET_SAREA_CTX)] = {drm_getsareactx, DRM_AUTH},
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_ADD_MAP, drm_addmap_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_RM_MAP, drm_rmmap_ioctl, DRM_AUTH),
|
||||
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_ADD_CTX)] = {drm_addctx, DRM_AUTH|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_RM_CTX)] = {drm_rmctx, DRM_AUTH|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_MOD_CTX)] = {drm_modctx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_GET_CTX)] = {drm_getctx, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_SWITCH_CTX)] = {drm_switchctx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_NEW_CTX)] = {drm_newctx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_RES_CTX)] = {drm_resctx, DRM_AUTH},
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_SET_SAREA_CTX, drm_setsareactx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_GET_SAREA_CTX, drm_getsareactx, DRM_AUTH),
|
||||
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_ADD_DRAW)] = {drm_adddraw, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_RM_DRAW)] = {drm_rmdraw, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_ADD_CTX, drm_addctx, DRM_AUTH|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_RM_CTX, drm_rmctx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_MOD_CTX, drm_modctx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_GET_CTX, drm_getctx, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_SWITCH_CTX, drm_switchctx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_NEW_CTX, drm_newctx, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_RES_CTX, drm_resctx, DRM_AUTH),
|
||||
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_LOCK)] = {drm_lock, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_UNLOCK)] = {drm_unlock, DRM_AUTH},
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_ADD_DRAW, drm_adddraw, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_RM_DRAW, drm_rmdraw, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_FINISH)] = {drm_noop, DRM_AUTH},
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_LOCK, drm_lock, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_UNLOCK, drm_unlock, DRM_AUTH),
|
||||
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_ADD_BUFS)] = {drm_addbufs, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_MARK_BUFS)] = {drm_markbufs, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_INFO_BUFS)] = {drm_infobufs, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_MAP_BUFS)] = {drm_mapbufs, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_FREE_BUFS)] = {drm_freebufs, DRM_AUTH},
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_FINISH, drm_noop, DRM_AUTH),
|
||||
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_ADD_BUFS, drm_addbufs, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_MARK_BUFS, drm_markbufs, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_INFO_BUFS, drm_infobufs, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_MAP_BUFS, drm_mapbufs, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_FREE_BUFS, drm_freebufs, DRM_AUTH),
|
||||
/* The DRM_IOCTL_DMA ioctl should be defined by the driver. */
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_DMA)] = {NULL, DRM_AUTH},
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_DMA, NULL, DRM_AUTH),
|
||||
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_CONTROL)] = {drm_control, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_CONTROL, drm_control, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
|
||||
#if __OS_HAS_AGP
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_AGP_ACQUIRE)] = {drm_agp_acquire_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_AGP_RELEASE)] = {drm_agp_release_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_AGP_ENABLE)] = {drm_agp_enable_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_AGP_INFO)] = {drm_agp_info_ioctl, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_AGP_ALLOC)] = {drm_agp_alloc_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_AGP_FREE)] = {drm_agp_free_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_AGP_BIND)] = {drm_agp_bind_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_AGP_UNBIND)] = {drm_agp_unbind_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_AGP_ACQUIRE, drm_agp_acquire_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_AGP_RELEASE, drm_agp_release_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_AGP_ENABLE, drm_agp_enable_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_AGP_INFO, drm_agp_info_ioctl, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_AGP_ALLOC, drm_agp_alloc_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_AGP_FREE, drm_agp_free_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_AGP_BIND, drm_agp_bind_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_AGP_UNBIND, drm_agp_unbind_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
#endif
|
||||
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_SG_ALLOC)] = {drm_sg_alloc, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_SG_FREE)] = {drm_sg_free, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_SG_ALLOC, drm_sg_alloc_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_SG_FREE, drm_sg_free, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_WAIT_VBLANK)] = {drm_wait_vblank, 0},
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_WAIT_VBLANK, drm_wait_vblank, 0),
|
||||
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_UPDATE_DRAW)] = {drm_update_drawable_info, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
DRM_IOCTL_DEF(DRM_IOCTL_UPDATE_DRAW, drm_update_drawable_info, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
};
|
||||
|
||||
#define DRM_CORE_IOCTL_COUNT ARRAY_SIZE( drm_ioctls )
|
||||
|
@ -224,7 +225,7 @@ int drm_lastclose(struct drm_device * dev)
|
|||
|
||||
if (dev->lock.hw_lock) {
|
||||
dev->sigdata.lock = dev->lock.hw_lock = NULL; /* SHM removed */
|
||||
dev->lock.filp = NULL;
|
||||
dev->lock.file_priv = NULL;
|
||||
wake_up_interruptible(&dev->lock.lock_queue);
|
||||
}
|
||||
mutex_unlock(&dev->struct_mutex);
|
||||
|
@ -418,27 +419,19 @@ module_exit(drm_core_exit);
|
|||
*
|
||||
* Fills in the version information in \p arg.
|
||||
*/
|
||||
static int drm_version(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
static int drm_version(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_version __user *argp = (void __user *)arg;
|
||||
struct drm_version version;
|
||||
struct drm_version *version = data;
|
||||
int len;
|
||||
|
||||
if (copy_from_user(&version, argp, sizeof(version)))
|
||||
return -EFAULT;
|
||||
version->version_major = dev->driver->major;
|
||||
version->version_minor = dev->driver->minor;
|
||||
version->version_patchlevel = dev->driver->patchlevel;
|
||||
DRM_COPY(version->name, dev->driver->name);
|
||||
DRM_COPY(version->date, dev->driver->date);
|
||||
DRM_COPY(version->desc, dev->driver->desc);
|
||||
|
||||
version.version_major = dev->driver->major;
|
||||
version.version_minor = dev->driver->minor;
|
||||
version.version_patchlevel = dev->driver->patchlevel;
|
||||
DRM_COPY(version.name, dev->driver->name);
|
||||
DRM_COPY(version.date, dev->driver->date);
|
||||
DRM_COPY(version.desc, dev->driver->desc);
|
||||
|
||||
if (copy_to_user(argp, &version, sizeof(version)))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -446,7 +439,7 @@ static int drm_version(struct inode *inode, struct file *filp,
|
|||
* Called whenever a process performs an ioctl on /dev/drm.
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg user argument.
|
||||
* \return zero on success or negative number on failure.
|
||||
|
@ -457,21 +450,22 @@ static int drm_version(struct inode *inode, struct file *filp,
|
|||
int drm_ioctl(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
drm_ioctl_desc_t *ioctl;
|
||||
struct drm_file *file_priv = filp->private_data;
|
||||
struct drm_device *dev = file_priv->head->dev;
|
||||
struct drm_ioctl_desc *ioctl;
|
||||
drm_ioctl_t *func;
|
||||
unsigned int nr = DRM_IOCTL_NR(cmd);
|
||||
int retcode = -EINVAL;
|
||||
char *kdata = NULL;
|
||||
|
||||
atomic_inc(&dev->ioctl_count);
|
||||
atomic_inc(&dev->counts[_DRM_STAT_IOCTLS]);
|
||||
++priv->ioctl_count;
|
||||
++file_priv->ioctl_count;
|
||||
|
||||
DRM_DEBUG("pid=%d, cmd=0x%02x, nr=0x%02x, dev 0x%lx, auth=%d\n",
|
||||
current->pid, cmd, nr,
|
||||
(long)old_encode_dev(priv->head->device),
|
||||
priv->authenticated);
|
||||
(long)old_encode_dev(file_priv->head->device),
|
||||
file_priv->authenticated);
|
||||
|
||||
if ((nr >= DRM_CORE_IOCTL_COUNT) &&
|
||||
((nr < DRM_COMMAND_BASE) || (nr >= DRM_COMMAND_END)))
|
||||
|
@ -489,18 +483,40 @@ int drm_ioctl(struct inode *inode, struct file *filp,
|
|||
if ((nr == DRM_IOCTL_NR(DRM_IOCTL_DMA)) && dev->driver->dma_ioctl)
|
||||
func = dev->driver->dma_ioctl;
|
||||
|
||||
|
||||
if (!func) {
|
||||
DRM_DEBUG("no function\n");
|
||||
retcode = -EINVAL;
|
||||
} else if (((ioctl->flags & DRM_ROOT_ONLY) && !capable(CAP_SYS_ADMIN)) ||
|
||||
((ioctl->flags & DRM_AUTH) && !priv->authenticated) ||
|
||||
((ioctl->flags & DRM_MASTER) && !priv->master)) {
|
||||
((ioctl->flags & DRM_AUTH) && !file_priv->authenticated) ||
|
||||
((ioctl->flags & DRM_MASTER) && !file_priv->master)) {
|
||||
retcode = -EACCES;
|
||||
} else {
|
||||
retcode = func(inode, filp, cmd, arg);
|
||||
if (cmd & (IOC_IN | IOC_OUT)) {
|
||||
kdata = kmalloc(_IOC_SIZE(cmd), GFP_KERNEL);
|
||||
if (!kdata)
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
if (cmd & IOC_IN) {
|
||||
if (copy_from_user(kdata, (void __user *)arg,
|
||||
_IOC_SIZE(cmd)) != 0) {
|
||||
retcode = -EACCES;
|
||||
goto err_i1;
|
||||
}
|
||||
}
|
||||
retcode = func(dev, kdata, file_priv);
|
||||
|
||||
if (cmd & IOC_OUT) {
|
||||
if (copy_to_user((void __user *)arg, kdata,
|
||||
_IOC_SIZE(cmd)) != 0)
|
||||
retcode = -EACCES;
|
||||
}
|
||||
}
|
||||
|
||||
err_i1:
|
||||
if (kdata)
|
||||
kfree(kdata);
|
||||
atomic_dec(&dev->ioctl_count);
|
||||
if (retcode)
|
||||
DRM_DEBUG("ret = %x\n", retcode);
|
||||
|
|
|
@ -242,6 +242,7 @@ static int drm_open_helper(struct inode *inode, struct file *filp,
|
|||
|
||||
memset(priv, 0, sizeof(*priv));
|
||||
filp->private_data = priv;
|
||||
priv->filp = filp;
|
||||
priv->uid = current->euid;
|
||||
priv->pid = current->pid;
|
||||
priv->minor = minor;
|
||||
|
@ -312,7 +313,7 @@ EXPORT_SYMBOL(drm_fasync);
|
|||
* Release file.
|
||||
*
|
||||
* \param inode device inode
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \return zero on success or a negative number on failure.
|
||||
*
|
||||
* If the hardware lock is held then free it, and take it again for the kernel
|
||||
|
@ -322,29 +323,28 @@ EXPORT_SYMBOL(drm_fasync);
|
|||
*/
|
||||
int drm_release(struct inode *inode, struct file *filp)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev;
|
||||
struct drm_file *file_priv = filp->private_data;
|
||||
struct drm_device *dev = file_priv->head->dev;
|
||||
int retcode = 0;
|
||||
|
||||
lock_kernel();
|
||||
dev = priv->head->dev;
|
||||
|
||||
DRM_DEBUG("open_count = %d\n", dev->open_count);
|
||||
|
||||
if (dev->driver->preclose)
|
||||
dev->driver->preclose(dev, filp);
|
||||
dev->driver->preclose(dev, file_priv);
|
||||
|
||||
/* ========================================================
|
||||
* Begin inline drm_release
|
||||
*/
|
||||
|
||||
DRM_DEBUG("pid = %d, device = 0x%lx, open_count = %d\n",
|
||||
current->pid, (long)old_encode_dev(priv->head->device),
|
||||
current->pid, (long)old_encode_dev(file_priv->head->device),
|
||||
dev->open_count);
|
||||
|
||||
if (dev->driver->reclaim_buffers_locked && dev->lock.hw_lock) {
|
||||
if (drm_i_have_hw_lock(filp)) {
|
||||
dev->driver->reclaim_buffers_locked(dev, filp);
|
||||
if (drm_i_have_hw_lock(dev, file_priv)) {
|
||||
dev->driver->reclaim_buffers_locked(dev, file_priv);
|
||||
} else {
|
||||
unsigned long _end=jiffies + 3*DRM_HZ;
|
||||
int locked = 0;
|
||||
|
@ -370,7 +370,7 @@ int drm_release(struct inode *inode, struct file *filp)
|
|||
"\tI will go on reclaiming the buffers anyway.\n");
|
||||
}
|
||||
|
||||
dev->driver->reclaim_buffers_locked(dev, filp);
|
||||
dev->driver->reclaim_buffers_locked(dev, file_priv);
|
||||
drm_idlelock_release(&dev->lock);
|
||||
}
|
||||
}
|
||||
|
@ -378,12 +378,12 @@ int drm_release(struct inode *inode, struct file *filp)
|
|||
if (dev->driver->reclaim_buffers_idlelocked && dev->lock.hw_lock) {
|
||||
|
||||
drm_idlelock_take(&dev->lock);
|
||||
dev->driver->reclaim_buffers_idlelocked(dev, filp);
|
||||
dev->driver->reclaim_buffers_idlelocked(dev, file_priv);
|
||||
drm_idlelock_release(&dev->lock);
|
||||
|
||||
}
|
||||
|
||||
if (drm_i_have_hw_lock(filp)) {
|
||||
if (drm_i_have_hw_lock(dev, file_priv)) {
|
||||
DRM_DEBUG("File %p released, freeing lock for context %d\n",
|
||||
filp, _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock));
|
||||
|
||||
|
@ -394,7 +394,7 @@ int drm_release(struct inode *inode, struct file *filp)
|
|||
|
||||
if (drm_core_check_feature(dev, DRIVER_HAVE_DMA) &&
|
||||
!dev->driver->reclaim_buffers_locked) {
|
||||
dev->driver->reclaim_buffers(dev, filp);
|
||||
dev->driver->reclaim_buffers(dev, file_priv);
|
||||
}
|
||||
|
||||
drm_fasync(-1, filp, 0);
|
||||
|
@ -404,7 +404,7 @@ int drm_release(struct inode *inode, struct file *filp)
|
|||
struct drm_ctx_list *pos, *n;
|
||||
|
||||
list_for_each_entry_safe(pos, n, &dev->ctxlist, head) {
|
||||
if (pos->tag == priv &&
|
||||
if (pos->tag == file_priv &&
|
||||
pos->handle != DRM_KERNEL_CONTEXT) {
|
||||
if (dev->driver->context_dtor)
|
||||
dev->driver->context_dtor(dev,
|
||||
|
@ -421,18 +421,18 @@ int drm_release(struct inode *inode, struct file *filp)
|
|||
mutex_unlock(&dev->ctxlist_mutex);
|
||||
|
||||
mutex_lock(&dev->struct_mutex);
|
||||
if (priv->remove_auth_on_close == 1) {
|
||||
if (file_priv->remove_auth_on_close == 1) {
|
||||
struct drm_file *temp;
|
||||
|
||||
list_for_each_entry(temp, &dev->filelist, lhead)
|
||||
temp->authenticated = 0;
|
||||
}
|
||||
list_del(&priv->lhead);
|
||||
list_del(&file_priv->lhead);
|
||||
mutex_unlock(&dev->struct_mutex);
|
||||
|
||||
if (dev->driver->postclose)
|
||||
dev->driver->postclose(dev, priv);
|
||||
drm_free(priv, sizeof(*priv), DRM_MEM_FILES);
|
||||
dev->driver->postclose(dev, file_priv);
|
||||
drm_free(file_priv, sizeof(*file_priv), DRM_MEM_FILES);
|
||||
|
||||
/* ========================================================
|
||||
* End inline drm_release
|
||||
|
|
|
@ -1040,7 +1040,7 @@ drm_ioctl_compat_t *drm_compat_ioctls[] = {
|
|||
* Called whenever a 32-bit process running under a 64-bit kernel
|
||||
* performs an ioctl on /dev/drm.
|
||||
*
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg user argument.
|
||||
* \return zero on success or negative number on failure.
|
||||
|
|
|
@ -42,30 +42,24 @@
|
|||
* Get the bus id.
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg user argument, pointing to a drm_unique structure.
|
||||
* \return zero on success or a negative number on failure.
|
||||
*
|
||||
* Copies the bus id from drm_device::unique into user space.
|
||||
*/
|
||||
int drm_getunique(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_getunique(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_unique __user *argp = (void __user *)arg;
|
||||
struct drm_unique u;
|
||||
struct drm_unique *u = data;
|
||||
|
||||
if (copy_from_user(&u, argp, sizeof(u)))
|
||||
return -EFAULT;
|
||||
if (u.unique_len >= dev->unique_len) {
|
||||
if (copy_to_user(u.unique, dev->unique, dev->unique_len))
|
||||
if (u->unique_len >= dev->unique_len) {
|
||||
if (copy_to_user(u->unique, dev->unique, dev->unique_len))
|
||||
return -EFAULT;
|
||||
}
|
||||
u.unique_len = dev->unique_len;
|
||||
if (copy_to_user(argp, &u, sizeof(u)))
|
||||
return -EFAULT;
|
||||
u->unique_len = dev->unique_len;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -73,7 +67,7 @@ int drm_getunique(struct inode *inode, struct file *filp,
|
|||
* Set the bus id.
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg user argument, pointing to a drm_unique structure.
|
||||
* \return zero on success or a negative number on failure.
|
||||
|
@ -83,28 +77,23 @@ int drm_getunique(struct inode *inode, struct file *filp,
|
|||
* in interface version 1.1 and will return EBUSY when setversion has requested
|
||||
* version 1.1 or greater.
|
||||
*/
|
||||
int drm_setunique(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_setunique(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_unique u;
|
||||
struct drm_unique *u = data;
|
||||
int domain, bus, slot, func, ret;
|
||||
|
||||
if (dev->unique_len || dev->unique)
|
||||
return -EBUSY;
|
||||
|
||||
if (copy_from_user(&u, (struct drm_unique __user *) arg, sizeof(u)))
|
||||
return -EFAULT;
|
||||
|
||||
if (!u.unique_len || u.unique_len > 1024)
|
||||
if (!u->unique_len || u->unique_len > 1024)
|
||||
return -EINVAL;
|
||||
|
||||
dev->unique_len = u.unique_len;
|
||||
dev->unique = drm_alloc(u.unique_len + 1, DRM_MEM_DRIVER);
|
||||
dev->unique_len = u->unique_len;
|
||||
dev->unique = drm_alloc(u->unique_len + 1, DRM_MEM_DRIVER);
|
||||
if (!dev->unique)
|
||||
return -ENOMEM;
|
||||
if (copy_from_user(dev->unique, u.unique, dev->unique_len))
|
||||
if (copy_from_user(dev->unique, u->unique, dev->unique_len))
|
||||
return -EFAULT;
|
||||
|
||||
dev->unique[dev->unique_len] = '\0';
|
||||
|
@ -123,7 +112,7 @@ int drm_setunique(struct inode *inode, struct file *filp,
|
|||
*/
|
||||
ret = sscanf(dev->unique, "PCI:%d:%d:%d", &bus, &slot, &func);
|
||||
if (ret != 3)
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
domain = bus >> 8;
|
||||
bus &= 0xff;
|
||||
|
||||
|
@ -172,7 +161,7 @@ static int drm_set_busid(struct drm_device * dev)
|
|||
* Get a mapping information.
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg user argument, pointing to a drm_map structure.
|
||||
*
|
||||
|
@ -181,21 +170,16 @@ static int drm_set_busid(struct drm_device * dev)
|
|||
* Searches for the mapping with the specified offset and copies its information
|
||||
* into userspace
|
||||
*/
|
||||
int drm_getmap(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_getmap(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_map __user *argp = (void __user *)arg;
|
||||
struct drm_map map;
|
||||
struct drm_map *map = data;
|
||||
struct drm_map_list *r_list = NULL;
|
||||
struct list_head *list;
|
||||
int idx;
|
||||
int i;
|
||||
|
||||
if (copy_from_user(&map, argp, sizeof(map)))
|
||||
return -EFAULT;
|
||||
idx = map.offset;
|
||||
idx = map->offset;
|
||||
|
||||
mutex_lock(&dev->struct_mutex);
|
||||
if (idx < 0) {
|
||||
|
@ -216,16 +200,14 @@ int drm_getmap(struct inode *inode, struct file *filp,
|
|||
return -EINVAL;
|
||||
}
|
||||
|
||||
map.offset = r_list->map->offset;
|
||||
map.size = r_list->map->size;
|
||||
map.type = r_list->map->type;
|
||||
map.flags = r_list->map->flags;
|
||||
map.handle = (void *)(unsigned long)r_list->user_token;
|
||||
map.mtrr = r_list->map->mtrr;
|
||||
map->offset = r_list->map->offset;
|
||||
map->size = r_list->map->size;
|
||||
map->type = r_list->map->type;
|
||||
map->flags = r_list->map->flags;
|
||||
map->handle = (void *)(unsigned long) r_list->user_token;
|
||||
map->mtrr = r_list->map->mtrr;
|
||||
mutex_unlock(&dev->struct_mutex);
|
||||
|
||||
if (copy_to_user(argp, &map, sizeof(map)))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -233,7 +215,7 @@ int drm_getmap(struct inode *inode, struct file *filp,
|
|||
* Get client information.
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg user argument, pointing to a drm_client structure.
|
||||
*
|
||||
|
@ -242,20 +224,15 @@ int drm_getmap(struct inode *inode, struct file *filp,
|
|||
* Searches for the client with the specified index and copies its information
|
||||
* into userspace
|
||||
*/
|
||||
int drm_getclient(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_getclient(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_client __user *argp = (struct drm_client __user *)arg;
|
||||
struct drm_client client;
|
||||
struct drm_client *client = data;
|
||||
struct drm_file *pt;
|
||||
int idx;
|
||||
int i;
|
||||
|
||||
if (copy_from_user(&client, argp, sizeof(client)))
|
||||
return -EFAULT;
|
||||
idx = client.idx;
|
||||
idx = client->idx;
|
||||
mutex_lock(&dev->struct_mutex);
|
||||
|
||||
if (list_empty(&dev->filelist)) {
|
||||
|
@ -269,15 +246,13 @@ int drm_getclient(struct inode *inode, struct file *filp,
|
|||
break;
|
||||
}
|
||||
|
||||
client.auth = pt->authenticated;
|
||||
client.pid = pt->pid;
|
||||
client.uid = pt->uid;
|
||||
client.magic = pt->magic;
|
||||
client.iocs = pt->ioctl_count;
|
||||
client->auth = pt->authenticated;
|
||||
client->pid = pt->pid;
|
||||
client->uid = pt->uid;
|
||||
client->magic = pt->magic;
|
||||
client->iocs = pt->ioctl_count;
|
||||
mutex_unlock(&dev->struct_mutex);
|
||||
|
||||
if (copy_to_user(argp, &client, sizeof(client)))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -285,39 +260,35 @@ int drm_getclient(struct inode *inode, struct file *filp,
|
|||
* Get statistics information.
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg user argument, pointing to a drm_stats structure.
|
||||
*
|
||||
* \return zero on success or a negative number on failure.
|
||||
*/
|
||||
int drm_getstats(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_getstats(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_stats stats;
|
||||
struct drm_stats *stats = data;
|
||||
int i;
|
||||
|
||||
memset(&stats, 0, sizeof(stats));
|
||||
memset(stats, 0, sizeof(stats));
|
||||
|
||||
mutex_lock(&dev->struct_mutex);
|
||||
|
||||
for (i = 0; i < dev->counters; i++) {
|
||||
if (dev->types[i] == _DRM_STAT_LOCK)
|
||||
stats.data[i].value
|
||||
= (dev->lock.hw_lock ? dev->lock.hw_lock->lock : 0);
|
||||
stats->data[i].value =
|
||||
(dev->lock.hw_lock ? dev->lock.hw_lock->lock : 0);
|
||||
else
|
||||
stats.data[i].value = atomic_read(&dev->counts[i]);
|
||||
stats.data[i].type = dev->types[i];
|
||||
stats->data[i].value = atomic_read(&dev->counts[i]);
|
||||
stats->data[i].type = dev->types[i];
|
||||
}
|
||||
|
||||
stats.count = dev->counters;
|
||||
stats->count = dev->counters;
|
||||
|
||||
mutex_unlock(&dev->struct_mutex);
|
||||
|
||||
if (copy_to_user((struct drm_stats __user *) arg, &stats, sizeof(stats)))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -325,64 +296,59 @@ int drm_getstats(struct inode *inode, struct file *filp,
|
|||
* Setversion ioctl.
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg user argument, pointing to a drm_lock structure.
|
||||
* \return zero on success or negative number on failure.
|
||||
*
|
||||
* Sets the requested interface version
|
||||
*/
|
||||
int drm_setversion(DRM_IOCTL_ARGS)
|
||||
int drm_setversion(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
struct drm_set_version sv;
|
||||
struct drm_set_version retv;
|
||||
int if_version;
|
||||
struct drm_set_version __user *argp = (void __user *)data;
|
||||
int ret;
|
||||
struct drm_set_version *sv = data;
|
||||
int if_version, retcode = 0;
|
||||
|
||||
if (copy_from_user(&sv, argp, sizeof(sv)))
|
||||
return -EFAULT;
|
||||
|
||||
retv.drm_di_major = DRM_IF_MAJOR;
|
||||
retv.drm_di_minor = DRM_IF_MINOR;
|
||||
retv.drm_dd_major = dev->driver->major;
|
||||
retv.drm_dd_minor = dev->driver->minor;
|
||||
|
||||
if (copy_to_user(argp, &retv, sizeof(retv)))
|
||||
return -EFAULT;
|
||||
|
||||
if (sv.drm_di_major != -1) {
|
||||
if (sv.drm_di_major != DRM_IF_MAJOR ||
|
||||
sv.drm_di_minor < 0 || sv.drm_di_minor > DRM_IF_MINOR)
|
||||
return -EINVAL;
|
||||
if_version = DRM_IF_VERSION(sv.drm_di_major, sv.drm_di_minor);
|
||||
if (sv->drm_di_major != -1) {
|
||||
if (sv->drm_di_major != DRM_IF_MAJOR ||
|
||||
sv->drm_di_minor < 0 || sv->drm_di_minor > DRM_IF_MINOR) {
|
||||
retcode = -EINVAL;
|
||||
goto done;
|
||||
}
|
||||
if_version = DRM_IF_VERSION(sv->drm_di_major,
|
||||
sv->drm_di_minor);
|
||||
dev->if_version = max(if_version, dev->if_version);
|
||||
if (sv.drm_di_minor >= 1) {
|
||||
if (sv->drm_di_minor >= 1) {
|
||||
/*
|
||||
* Version 1.1 includes tying of DRM to specific device
|
||||
*/
|
||||
ret = drm_set_busid(dev);
|
||||
if (ret)
|
||||
return ret;
|
||||
drm_set_busid(dev);
|
||||
}
|
||||
}
|
||||
|
||||
if (sv.drm_dd_major != -1) {
|
||||
if (sv.drm_dd_major != dev->driver->major ||
|
||||
sv.drm_dd_minor < 0
|
||||
|| sv.drm_dd_minor > dev->driver->minor)
|
||||
return -EINVAL;
|
||||
if (sv->drm_dd_major != -1) {
|
||||
if (sv->drm_dd_major != dev->driver->major ||
|
||||
sv->drm_dd_minor < 0 || sv->drm_dd_minor >
|
||||
dev->driver->minor) {
|
||||
retcode = -EINVAL;
|
||||
goto done;
|
||||
}
|
||||
|
||||
if (dev->driver->set_version)
|
||||
dev->driver->set_version(dev, &sv);
|
||||
dev->driver->set_version(dev, sv);
|
||||
}
|
||||
return 0;
|
||||
|
||||
done:
|
||||
sv->drm_di_major = DRM_IF_MAJOR;
|
||||
sv->drm_di_minor = DRM_IF_MINOR;
|
||||
sv->drm_dd_major = dev->driver->major;
|
||||
sv->drm_dd_minor = dev->driver->minor;
|
||||
|
||||
return retcode;
|
||||
}
|
||||
|
||||
/** No-op ioctl. */
|
||||
int drm_noop(struct inode *inode, struct file *filp, unsigned int cmd,
|
||||
unsigned long arg)
|
||||
int drm_noop(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEBUG("\n");
|
||||
return 0;
|
||||
|
|
|
@ -41,7 +41,7 @@
|
|||
* Get interrupt from bus id.
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg user argument, pointing to a drm_irq_busid structure.
|
||||
* \return zero on success or a negative number on failure.
|
||||
|
@ -50,30 +50,24 @@
|
|||
* This IOCTL is deprecated, and will now return EINVAL for any busid not equal
|
||||
* to that of the device that this DRM instance attached to.
|
||||
*/
|
||||
int drm_irq_by_busid(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_irq_by_busid(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_irq_busid __user *argp = (void __user *)arg;
|
||||
struct drm_irq_busid p;
|
||||
struct drm_irq_busid *p = data;
|
||||
|
||||
if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
|
||||
return -EINVAL;
|
||||
|
||||
if (copy_from_user(&p, argp, sizeof(p)))
|
||||
return -EFAULT;
|
||||
|
||||
if ((p.busnum >> 8) != drm_get_pci_domain(dev) ||
|
||||
(p.busnum & 0xff) != dev->pdev->bus->number ||
|
||||
p.devnum != PCI_SLOT(dev->pdev->devfn) || p.funcnum != PCI_FUNC(dev->pdev->devfn))
|
||||
if ((p->busnum >> 8) != drm_get_pci_domain(dev) ||
|
||||
(p->busnum & 0xff) != dev->pdev->bus->number ||
|
||||
p->devnum != PCI_SLOT(dev->pdev->devfn) || p->funcnum != PCI_FUNC(dev->pdev->devfn))
|
||||
return -EINVAL;
|
||||
|
||||
p.irq = dev->irq;
|
||||
p->irq = dev->irq;
|
||||
|
||||
DRM_DEBUG("%d:%d:%d => IRQ %d\n", p->busnum, p->devnum, p->funcnum,
|
||||
p->irq);
|
||||
|
||||
DRM_DEBUG("%d:%d:%d => IRQ %d\n", p.busnum, p.devnum, p.funcnum, p.irq);
|
||||
if (copy_to_user(argp, &p, sizeof(p)))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -187,31 +181,27 @@ EXPORT_SYMBOL(drm_irq_uninstall);
|
|||
* IRQ control ioctl.
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg user argument, pointing to a drm_control structure.
|
||||
* \return zero on success or a negative number on failure.
|
||||
*
|
||||
* Calls irq_install() or irq_uninstall() according to \p arg.
|
||||
*/
|
||||
int drm_control(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_control(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_control ctl;
|
||||
struct drm_control *ctl = data;
|
||||
|
||||
/* if we haven't irq we fallback for compatibility reasons - this used to be a separate function in drm_dma.h */
|
||||
|
||||
if (copy_from_user(&ctl, (struct drm_control __user *) arg, sizeof(ctl)))
|
||||
return -EFAULT;
|
||||
|
||||
switch (ctl.func) {
|
||||
switch (ctl->func) {
|
||||
case DRM_INST_HANDLER:
|
||||
if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
|
||||
return 0;
|
||||
if (dev->if_version < DRM_IF_VERSION(1, 2) &&
|
||||
ctl.irq != dev->irq)
|
||||
ctl->irq != dev->irq)
|
||||
return -EINVAL;
|
||||
return drm_irq_install(dev);
|
||||
case DRM_UNINST_HANDLER:
|
||||
|
@ -227,7 +217,7 @@ int drm_control(struct inode *inode, struct file *filp,
|
|||
* Wait for VBLANK.
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param data user argument, pointing to a drm_wait_vblank structure.
|
||||
* \return zero on success or a negative number on failure.
|
||||
|
@ -242,31 +232,25 @@ int drm_control(struct inode *inode, struct file *filp,
|
|||
*
|
||||
* If a signal is not requested, then calls vblank_wait().
|
||||
*/
|
||||
int drm_wait_vblank(DRM_IOCTL_ARGS)
|
||||
int drm_wait_vblank(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
union drm_wait_vblank __user *argp = (void __user *)data;
|
||||
union drm_wait_vblank vblwait;
|
||||
union drm_wait_vblank *vblwait = data;
|
||||
struct timeval now;
|
||||
int ret = 0;
|
||||
unsigned int flags, seq;
|
||||
|
||||
if (!dev->irq)
|
||||
if ((!dev->irq) || (!dev->irq_enabled))
|
||||
return -EINVAL;
|
||||
|
||||
if (copy_from_user(&vblwait, argp, sizeof(vblwait)))
|
||||
return -EFAULT;
|
||||
|
||||
if (vblwait.request.type &
|
||||
if (vblwait->request.type &
|
||||
~(_DRM_VBLANK_TYPES_MASK | _DRM_VBLANK_FLAGS_MASK)) {
|
||||
DRM_ERROR("Unsupported type value 0x%x, supported mask 0x%x\n",
|
||||
vblwait.request.type,
|
||||
vblwait->request.type,
|
||||
(_DRM_VBLANK_TYPES_MASK | _DRM_VBLANK_FLAGS_MASK));
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
flags = vblwait.request.type & _DRM_VBLANK_FLAGS_MASK;
|
||||
flags = vblwait->request.type & _DRM_VBLANK_FLAGS_MASK;
|
||||
|
||||
if (!drm_core_check_feature(dev, (flags & _DRM_VBLANK_SECONDARY) ?
|
||||
DRIVER_IRQ_VBL2 : DRIVER_IRQ_VBL))
|
||||
|
@ -275,10 +259,10 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
|
|||
seq = atomic_read((flags & _DRM_VBLANK_SECONDARY) ? &dev->vbl_received2
|
||||
: &dev->vbl_received);
|
||||
|
||||
switch (vblwait.request.type & _DRM_VBLANK_TYPES_MASK) {
|
||||
switch (vblwait->request.type & _DRM_VBLANK_TYPES_MASK) {
|
||||
case _DRM_VBLANK_RELATIVE:
|
||||
vblwait.request.sequence += seq;
|
||||
vblwait.request.type &= ~_DRM_VBLANK_RELATIVE;
|
||||
vblwait->request.sequence += seq;
|
||||
vblwait->request.type &= ~_DRM_VBLANK_RELATIVE;
|
||||
case _DRM_VBLANK_ABSOLUTE:
|
||||
break;
|
||||
default:
|
||||
|
@ -286,8 +270,8 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
|
|||
}
|
||||
|
||||
if ((flags & _DRM_VBLANK_NEXTONMISS) &&
|
||||
(seq - vblwait.request.sequence) <= (1<<23)) {
|
||||
vblwait.request.sequence = seq + 1;
|
||||
(seq - vblwait->request.sequence) <= (1<<23)) {
|
||||
vblwait->request.sequence = seq + 1;
|
||||
}
|
||||
|
||||
if (flags & _DRM_VBLANK_SIGNAL) {
|
||||
|
@ -303,12 +287,13 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
|
|||
* that case
|
||||
*/
|
||||
list_for_each_entry(vbl_sig, vbl_sigs, head) {
|
||||
if (vbl_sig->sequence == vblwait.request.sequence
|
||||
&& vbl_sig->info.si_signo == vblwait.request.signal
|
||||
if (vbl_sig->sequence == vblwait->request.sequence
|
||||
&& vbl_sig->info.si_signo ==
|
||||
vblwait->request.signal
|
||||
&& vbl_sig->task == current) {
|
||||
spin_unlock_irqrestore(&dev->vbl_lock,
|
||||
irqflags);
|
||||
vblwait.reply.sequence = seq;
|
||||
vblwait->reply.sequence = seq;
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
|
@ -330,8 +315,8 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
|
|||
|
||||
memset((void *)vbl_sig, 0, sizeof(*vbl_sig));
|
||||
|
||||
vbl_sig->sequence = vblwait.request.sequence;
|
||||
vbl_sig->info.si_signo = vblwait.request.signal;
|
||||
vbl_sig->sequence = vblwait->request.sequence;
|
||||
vbl_sig->info.si_signo = vblwait->request.signal;
|
||||
vbl_sig->task = current;
|
||||
|
||||
spin_lock_irqsave(&dev->vbl_lock, irqflags);
|
||||
|
@ -340,25 +325,22 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
|
|||
|
||||
spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
|
||||
|
||||
vblwait.reply.sequence = seq;
|
||||
vblwait->reply.sequence = seq;
|
||||
} else {
|
||||
if (flags & _DRM_VBLANK_SECONDARY) {
|
||||
if (dev->driver->vblank_wait2)
|
||||
ret = dev->driver->vblank_wait2(dev, &vblwait.request.sequence);
|
||||
ret = dev->driver->vblank_wait2(dev, &vblwait->request.sequence);
|
||||
} else if (dev->driver->vblank_wait)
|
||||
ret =
|
||||
dev->driver->vblank_wait(dev,
|
||||
&vblwait.request.sequence);
|
||||
&vblwait->request.sequence);
|
||||
|
||||
do_gettimeofday(&now);
|
||||
vblwait.reply.tval_sec = now.tv_sec;
|
||||
vblwait.reply.tval_usec = now.tv_usec;
|
||||
vblwait->reply.tval_sec = now.tv_sec;
|
||||
vblwait->reply.tval_usec = now.tv_usec;
|
||||
}
|
||||
|
||||
done:
|
||||
if (copy_to_user(argp, &vblwait, sizeof(vblwait)))
|
||||
return -EFAULT;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
|
@ -41,39 +41,33 @@ static int drm_notifier(void *priv);
|
|||
* Lock ioctl.
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg user argument, pointing to a drm_lock structure.
|
||||
* \return zero on success or negative number on failure.
|
||||
*
|
||||
* Add the current task to the lock wait queue, and attempt to take to lock.
|
||||
*/
|
||||
int drm_lock(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_lock(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
DECLARE_WAITQUEUE(entry, current);
|
||||
struct drm_lock lock;
|
||||
struct drm_lock *lock = data;
|
||||
int ret = 0;
|
||||
|
||||
++priv->lock_count;
|
||||
++file_priv->lock_count;
|
||||
|
||||
if (copy_from_user(&lock, (struct drm_lock __user *) arg, sizeof(lock)))
|
||||
return -EFAULT;
|
||||
|
||||
if (lock.context == DRM_KERNEL_CONTEXT) {
|
||||
if (lock->context == DRM_KERNEL_CONTEXT) {
|
||||
DRM_ERROR("Process %d using kernel context %d\n",
|
||||
current->pid, lock.context);
|
||||
current->pid, lock->context);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
DRM_DEBUG("%d (pid %d) requests lock (0x%08x), flags = 0x%08x\n",
|
||||
lock.context, current->pid,
|
||||
dev->lock.hw_lock->lock, lock.flags);
|
||||
lock->context, current->pid,
|
||||
dev->lock.hw_lock->lock, lock->flags);
|
||||
|
||||
if (drm_core_check_feature(dev, DRIVER_DMA_QUEUE))
|
||||
if (lock.context < 0)
|
||||
if (lock->context < 0)
|
||||
return -EINVAL;
|
||||
|
||||
add_wait_queue(&dev->lock.lock_queue, &entry);
|
||||
|
@ -87,8 +81,8 @@ int drm_lock(struct inode *inode, struct file *filp,
|
|||
ret = -EINTR;
|
||||
break;
|
||||
}
|
||||
if (drm_lock_take(&dev->lock, lock.context)) {
|
||||
dev->lock.filp = filp;
|
||||
if (drm_lock_take(&dev->lock, lock->context)) {
|
||||
dev->lock.file_priv = file_priv;
|
||||
dev->lock.lock_time = jiffies;
|
||||
atomic_inc(&dev->counts[_DRM_STAT_LOCKS]);
|
||||
break; /* Got lock */
|
||||
|
@ -107,7 +101,8 @@ int drm_lock(struct inode *inode, struct file *filp,
|
|||
__set_current_state(TASK_RUNNING);
|
||||
remove_wait_queue(&dev->lock.lock_queue, &entry);
|
||||
|
||||
DRM_DEBUG( "%d %s\n", lock.context, ret ? "interrupted" : "has lock" );
|
||||
DRM_DEBUG("%d %s\n", lock->context,
|
||||
ret ? "interrupted" : "has lock");
|
||||
if (ret) return ret;
|
||||
|
||||
sigemptyset(&dev->sigmask);
|
||||
|
@ -115,24 +110,26 @@ int drm_lock(struct inode *inode, struct file *filp,
|
|||
sigaddset(&dev->sigmask, SIGTSTP);
|
||||
sigaddset(&dev->sigmask, SIGTTIN);
|
||||
sigaddset(&dev->sigmask, SIGTTOU);
|
||||
dev->sigdata.context = lock.context;
|
||||
dev->sigdata.context = lock->context;
|
||||
dev->sigdata.lock = dev->lock.hw_lock;
|
||||
block_all_signals(drm_notifier, &dev->sigdata, &dev->sigmask);
|
||||
|
||||
if (dev->driver->dma_ready && (lock.flags & _DRM_LOCK_READY))
|
||||
if (dev->driver->dma_ready && (lock->flags & _DRM_LOCK_READY))
|
||||
dev->driver->dma_ready(dev);
|
||||
|
||||
if (dev->driver->dma_quiescent && (lock.flags & _DRM_LOCK_QUIESCENT)) {
|
||||
if (dev->driver->dma_quiescent && (lock->flags & _DRM_LOCK_QUIESCENT))
|
||||
{
|
||||
if (dev->driver->dma_quiescent(dev)) {
|
||||
DRM_DEBUG("%d waiting for DMA quiescent\n", lock.context);
|
||||
return DRM_ERR(EBUSY);
|
||||
DRM_DEBUG("%d waiting for DMA quiescent\n",
|
||||
lock->context);
|
||||
return -EBUSY;
|
||||
}
|
||||
}
|
||||
|
||||
if (dev->driver->kernel_context_switch &&
|
||||
dev->last_context != lock.context) {
|
||||
dev->last_context != lock->context) {
|
||||
dev->driver->kernel_context_switch(dev, dev->last_context,
|
||||
lock.context);
|
||||
lock->context);
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
@ -142,27 +139,21 @@ int drm_lock(struct inode *inode, struct file *filp,
|
|||
* Unlock ioctl.
|
||||
*
|
||||
* \param inode device inode.
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param cmd command.
|
||||
* \param arg user argument, pointing to a drm_lock structure.
|
||||
* \return zero on success or negative number on failure.
|
||||
*
|
||||
* Transfer and free the lock.
|
||||
*/
|
||||
int drm_unlock(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_unlock(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_lock lock;
|
||||
struct drm_lock *lock = data;
|
||||
unsigned long irqflags;
|
||||
|
||||
if (copy_from_user(&lock, (struct drm_lock __user *) arg, sizeof(lock)))
|
||||
return -EFAULT;
|
||||
|
||||
if (lock.context == DRM_KERNEL_CONTEXT) {
|
||||
if (lock->context == DRM_KERNEL_CONTEXT) {
|
||||
DRM_ERROR("Process %d using kernel context %d\n",
|
||||
current->pid, lock.context);
|
||||
current->pid, lock->context);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
|
@ -184,7 +175,7 @@ int drm_unlock(struct inode *inode, struct file *filp,
|
|||
if (dev->driver->kernel_context_switch_unlock)
|
||||
dev->driver->kernel_context_switch_unlock(dev);
|
||||
else {
|
||||
if (drm_lock_free(&dev->lock,lock.context)) {
|
||||
if (drm_lock_free(&dev->lock,lock->context)) {
|
||||
/* FIXME: Should really bail out here. */
|
||||
}
|
||||
}
|
||||
|
@ -257,7 +248,7 @@ static int drm_lock_transfer(struct drm_lock_data *lock_data,
|
|||
unsigned int old, new, prev;
|
||||
volatile unsigned int *lock = &lock_data->hw_lock->lock;
|
||||
|
||||
lock_data->filp = NULL;
|
||||
lock_data->file_priv = NULL;
|
||||
do {
|
||||
old = *lock;
|
||||
new = context | _DRM_LOCK_HELD;
|
||||
|
@ -390,13 +381,11 @@ void drm_idlelock_release(struct drm_lock_data *lock_data)
|
|||
EXPORT_SYMBOL(drm_idlelock_release);
|
||||
|
||||
|
||||
int drm_i_have_hw_lock(struct file *filp)
|
||||
int drm_i_have_hw_lock(struct drm_device *dev, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
|
||||
return (priv->lock_count && dev->lock.hw_lock &&
|
||||
return (file_priv->lock_count && dev->lock.hw_lock &&
|
||||
_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock) &&
|
||||
dev->lock.filp == filp);
|
||||
dev->lock.file_priv == file_priv);
|
||||
}
|
||||
|
||||
EXPORT_SYMBOL(drm_i_have_hw_lock);
|
||||
|
|
|
@ -6,11 +6,6 @@
|
|||
#include <linux/interrupt.h> /* For task queue support */
|
||||
#include <linux/delay.h>
|
||||
|
||||
/** File pointer type */
|
||||
#define DRMFILE struct file *
|
||||
/** Ioctl arguments */
|
||||
#define DRM_IOCTL_ARGS struct inode *inode, struct file *filp, unsigned int cmd, unsigned long data
|
||||
#define DRM_ERR(d) -(d)
|
||||
/** Current process ID */
|
||||
#define DRM_CURRENTPID current->pid
|
||||
#define DRM_SUSER(p) capable(CAP_SYS_ADMIN)
|
||||
|
@ -33,9 +28,6 @@
|
|||
#define DRM_WRITEMEMORYBARRIER() wmb()
|
||||
/** Read/write memory barrier */
|
||||
#define DRM_MEMORYBARRIER() mb()
|
||||
/** DRM device local declaration */
|
||||
#define DRM_DEVICE struct drm_file *priv = filp->private_data; \
|
||||
struct drm_device *dev = priv->head->dev
|
||||
|
||||
/** IRQ handler arguments and return type and values */
|
||||
#define DRM_IRQ_ARGS int irq, void *arg
|
||||
|
@ -94,8 +86,6 @@ static __inline__ int mtrr_del(int reg, unsigned long base, unsigned long size)
|
|||
#define DRM_GET_USER_UNCHECKED(val, uaddr) \
|
||||
__get_user(val, uaddr)
|
||||
|
||||
#define DRM_GET_PRIV_WITH_RETURN(_priv, _filp) _priv = _filp->private_data
|
||||
|
||||
#define DRM_HZ HZ
|
||||
|
||||
#define DRM_WAIT_ON( ret, queue, timeout, condition ) \
|
||||
|
|
|
@ -236,10 +236,8 @@
|
|||
{0x1106, 0x3022, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
|
||||
{0x1106, 0x3118, PCI_ANY_ID, PCI_ANY_ID, 0, 0, VIA_PRO_GROUP_A}, \
|
||||
{0x1106, 0x3122, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
|
||||
{0x1106, 0x7204, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
|
||||
{0x1106, 0x7205, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
|
||||
{0x1106, 0x3108, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
|
||||
{0x1106, 0x3304, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
|
||||
{0x1106, 0x3344, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
|
||||
{0x1106, 0x3343, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
|
||||
{0x1106, 0x3230, PCI_ANY_ID, PCI_ANY_ID, 0, 0, VIA_DX9_0}, \
|
||||
|
|
|
@ -62,13 +62,8 @@ void drm_sg_cleanup(struct drm_sg_mem * entry)
|
|||
# define ScatterHandle(x) (unsigned int)(x)
|
||||
#endif
|
||||
|
||||
int drm_sg_alloc(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
int drm_sg_alloc(struct drm_device *dev, struct drm_scatter_gather * request)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_scatter_gather __user *argp = (void __user *)arg;
|
||||
struct drm_scatter_gather request;
|
||||
struct drm_sg_mem *entry;
|
||||
unsigned long pages, i, j;
|
||||
|
||||
|
@ -80,17 +75,13 @@ int drm_sg_alloc(struct inode *inode, struct file *filp,
|
|||
if (dev->sg)
|
||||
return -EINVAL;
|
||||
|
||||
if (copy_from_user(&request, argp, sizeof(request)))
|
||||
return -EFAULT;
|
||||
|
||||
entry = drm_alloc(sizeof(*entry), DRM_MEM_SGLISTS);
|
||||
if (!entry)
|
||||
return -ENOMEM;
|
||||
|
||||
memset(entry, 0, sizeof(*entry));
|
||||
|
||||
pages = (request.size + PAGE_SIZE - 1) / PAGE_SIZE;
|
||||
DRM_DEBUG("sg size=%ld pages=%ld\n", request.size, pages);
|
||||
pages = (request->size + PAGE_SIZE - 1) / PAGE_SIZE;
|
||||
DRM_DEBUG("sg size=%ld pages=%ld\n", request->size, pages);
|
||||
|
||||
entry->pages = pages;
|
||||
entry->pagelist = drm_alloc(pages * sizeof(*entry->pagelist),
|
||||
|
@ -142,12 +133,7 @@ int drm_sg_alloc(struct inode *inode, struct file *filp,
|
|||
SetPageReserved(entry->pagelist[j]);
|
||||
}
|
||||
|
||||
request.handle = entry->handle;
|
||||
|
||||
if (copy_to_user(argp, &request, sizeof(request))) {
|
||||
drm_sg_cleanup(entry);
|
||||
return -EFAULT;
|
||||
}
|
||||
request->handle = entry->handle;
|
||||
|
||||
dev->sg = entry;
|
||||
|
||||
|
@ -197,27 +183,31 @@ int drm_sg_alloc(struct inode *inode, struct file *filp,
|
|||
drm_sg_cleanup(entry);
|
||||
return -ENOMEM;
|
||||
}
|
||||
EXPORT_SYMBOL(drm_sg_alloc);
|
||||
|
||||
int drm_sg_free(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
|
||||
int drm_sg_alloc_ioctl(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_scatter_gather request;
|
||||
struct drm_scatter_gather *request = data;
|
||||
|
||||
return drm_sg_alloc(dev, request);
|
||||
|
||||
}
|
||||
|
||||
int drm_sg_free(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_scatter_gather *request = data;
|
||||
struct drm_sg_mem *entry;
|
||||
|
||||
if (!drm_core_check_feature(dev, DRIVER_SG))
|
||||
return -EINVAL;
|
||||
|
||||
if (copy_from_user(&request,
|
||||
(struct drm_scatter_gather __user *) arg,
|
||||
sizeof(request)))
|
||||
return -EFAULT;
|
||||
|
||||
entry = dev->sg;
|
||||
dev->sg = NULL;
|
||||
|
||||
if (!entry || entry->handle != request.handle)
|
||||
if (!entry || entry->handle != request->handle)
|
||||
return -EINVAL;
|
||||
|
||||
DRM_DEBUG("sg free virtual = %p\n", entry->virtual);
|
||||
|
|
|
@ -463,7 +463,7 @@ static void drm_vm_close(struct vm_area_struct *vma)
|
|||
/**
|
||||
* mmap DMA memory.
|
||||
*
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param vma virtual memory area.
|
||||
* \return zero on success or a negative number on failure.
|
||||
*
|
||||
|
@ -533,7 +533,7 @@ EXPORT_SYMBOL(drm_core_get_reg_ofs);
|
|||
/**
|
||||
* mmap DMA memory.
|
||||
*
|
||||
* \param filp file pointer.
|
||||
* \param file_priv DRM file private.
|
||||
* \param vma virtual memory area.
|
||||
* \return zero on success or a negative number on failure.
|
||||
*
|
||||
|
|
|
@ -120,10 +120,9 @@ static const struct file_operations i810_buffer_fops = {
|
|||
.fasync = drm_fasync,
|
||||
};
|
||||
|
||||
static int i810_map_buffer(struct drm_buf * buf, struct file *filp)
|
||||
static int i810_map_buffer(struct drm_buf * buf, struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_device *dev = file_priv->head->dev;
|
||||
drm_i810_buf_priv_t *buf_priv = buf->dev_private;
|
||||
drm_i810_private_t *dev_priv = dev->dev_private;
|
||||
const struct file_operations *old_fops;
|
||||
|
@ -133,14 +132,14 @@ static int i810_map_buffer(struct drm_buf * buf, struct file *filp)
|
|||
return -EINVAL;
|
||||
|
||||
down_write(¤t->mm->mmap_sem);
|
||||
old_fops = filp->f_op;
|
||||
filp->f_op = &i810_buffer_fops;
|
||||
old_fops = file_priv->filp->f_op;
|
||||
file_priv->filp->f_op = &i810_buffer_fops;
|
||||
dev_priv->mmap_buffer = buf;
|
||||
buf_priv->virtual = (void *)do_mmap(filp, 0, buf->total,
|
||||
buf_priv->virtual = (void *)do_mmap(file_priv->filp, 0, buf->total,
|
||||
PROT_READ | PROT_WRITE,
|
||||
MAP_SHARED, buf->bus_address);
|
||||
dev_priv->mmap_buffer = NULL;
|
||||
filp->f_op = old_fops;
|
||||
file_priv->filp->f_op = old_fops;
|
||||
if (IS_ERR(buf_priv->virtual)) {
|
||||
/* Real error */
|
||||
DRM_ERROR("mmap error\n");
|
||||
|
@ -173,7 +172,7 @@ static int i810_unmap_buffer(struct drm_buf * buf)
|
|||
}
|
||||
|
||||
static int i810_dma_get_buffer(struct drm_device * dev, drm_i810_dma_t * d,
|
||||
struct file *filp)
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_buf *buf;
|
||||
drm_i810_buf_priv_t *buf_priv;
|
||||
|
@ -186,13 +185,13 @@ static int i810_dma_get_buffer(struct drm_device * dev, drm_i810_dma_t * d,
|
|||
return retcode;
|
||||
}
|
||||
|
||||
retcode = i810_map_buffer(buf, filp);
|
||||
retcode = i810_map_buffer(buf, file_priv);
|
||||
if (retcode) {
|
||||
i810_freelist_put(dev, buf);
|
||||
DRM_ERROR("mapbuf failed, retcode %d\n", retcode);
|
||||
return retcode;
|
||||
}
|
||||
buf->filp = filp;
|
||||
buf->file_priv = file_priv;
|
||||
buf_priv = buf->dev_private;
|
||||
d->granted = 1;
|
||||
d->request_idx = buf->idx;
|
||||
|
@ -380,7 +379,7 @@ static int i810_dma_initialize(struct drm_device * dev,
|
|||
i810_dma_cleanup(dev);
|
||||
DRM_ERROR("can not ioremap virtual address for"
|
||||
" ring buffer\n");
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
dev_priv->ring.virtual_start = dev_priv->ring.map.handle;
|
||||
|
@ -430,99 +429,29 @@ static int i810_dma_initialize(struct drm_device * dev,
|
|||
return 0;
|
||||
}
|
||||
|
||||
/* i810 DRM version 1.1 used a smaller init structure with different
|
||||
* ordering of values than is currently used (drm >= 1.2). There is
|
||||
* no defined way to detect the XFree version to correct this problem,
|
||||
* however by checking using this procedure we can detect the correct
|
||||
* thing to do.
|
||||
*
|
||||
* #1 Read the Smaller init structure from user-space
|
||||
* #2 Verify the overlay_physical is a valid physical address, or NULL
|
||||
* If it isn't then we have a v1.1 client. Fix up params.
|
||||
* If it is, then we have a 1.2 client... get the rest of the data.
|
||||
*/
|
||||
static int i810_dma_init_compat(drm_i810_init_t * init, unsigned long arg)
|
||||
static int i810_dma_init(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
|
||||
/* Get v1.1 init data */
|
||||
if (copy_from_user(init, (drm_i810_pre12_init_t __user *) arg,
|
||||
sizeof(drm_i810_pre12_init_t))) {
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
if ((!init->overlay_physical) || (init->overlay_physical > 4096)) {
|
||||
|
||||
/* This is a v1.2 client, just get the v1.2 init data */
|
||||
DRM_INFO("Using POST v1.2 init.\n");
|
||||
if (copy_from_user(init, (drm_i810_init_t __user *) arg,
|
||||
sizeof(drm_i810_init_t))) {
|
||||
return -EFAULT;
|
||||
}
|
||||
} else {
|
||||
|
||||
/* This is a v1.1 client, fix the params */
|
||||
DRM_INFO("Using PRE v1.2 init.\n");
|
||||
init->pitch_bits = init->h;
|
||||
init->pitch = init->w;
|
||||
init->h = init->overlay_physical;
|
||||
init->w = init->overlay_offset;
|
||||
init->overlay_physical = 0;
|
||||
init->overlay_offset = 0;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int i810_dma_init(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
drm_i810_private_t *dev_priv;
|
||||
drm_i810_init_t init;
|
||||
drm_i810_init_t *init = data;
|
||||
int retcode = 0;
|
||||
|
||||
/* Get only the init func */
|
||||
if (copy_from_user
|
||||
(&init, (void __user *)arg, sizeof(drm_i810_init_func_t)))
|
||||
return -EFAULT;
|
||||
|
||||
switch (init.func) {
|
||||
case I810_INIT_DMA:
|
||||
/* This case is for backward compatibility. It
|
||||
* handles XFree 4.1.0 and 4.2.0, and has to
|
||||
* do some parameter checking as described below.
|
||||
* It will someday go away.
|
||||
*/
|
||||
retcode = i810_dma_init_compat(&init, arg);
|
||||
if (retcode)
|
||||
return retcode;
|
||||
|
||||
dev_priv = drm_alloc(sizeof(drm_i810_private_t),
|
||||
DRM_MEM_DRIVER);
|
||||
if (dev_priv == NULL)
|
||||
return -ENOMEM;
|
||||
retcode = i810_dma_initialize(dev, dev_priv, &init);
|
||||
break;
|
||||
|
||||
default:
|
||||
switch (init->func) {
|
||||
case I810_INIT_DMA_1_4:
|
||||
DRM_INFO("Using v1.4 init.\n");
|
||||
if (copy_from_user(&init, (drm_i810_init_t __user *) arg,
|
||||
sizeof(drm_i810_init_t))) {
|
||||
return -EFAULT;
|
||||
}
|
||||
dev_priv = drm_alloc(sizeof(drm_i810_private_t),
|
||||
DRM_MEM_DRIVER);
|
||||
if (dev_priv == NULL)
|
||||
return -ENOMEM;
|
||||
retcode = i810_dma_initialize(dev, dev_priv, &init);
|
||||
retcode = i810_dma_initialize(dev, dev_priv, init);
|
||||
break;
|
||||
|
||||
case I810_CLEANUP_DMA:
|
||||
DRM_INFO("DMA Cleanup\n");
|
||||
retcode = i810_dma_cleanup(dev);
|
||||
break;
|
||||
default:
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
return retcode;
|
||||
|
@ -968,7 +897,8 @@ static int i810_flush_queue(struct drm_device * dev)
|
|||
}
|
||||
|
||||
/* Must be called with the lock held */
|
||||
static void i810_reclaim_buffers(struct drm_device * dev, struct file *filp)
|
||||
static void i810_reclaim_buffers(struct drm_device * dev,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_device_dma *dma = dev->dma;
|
||||
int i;
|
||||
|
@ -986,7 +916,7 @@ static void i810_reclaim_buffers(struct drm_device * dev, struct file *filp)
|
|||
struct drm_buf *buf = dma->buflist[i];
|
||||
drm_i810_buf_priv_t *buf_priv = buf->dev_private;
|
||||
|
||||
if (buf->filp == filp && buf_priv) {
|
||||
if (buf->file_priv == file_priv && buf_priv) {
|
||||
int used = cmpxchg(buf_priv->in_use, I810_BUF_CLIENT,
|
||||
I810_BUF_FREE);
|
||||
|
||||
|
@ -998,47 +928,38 @@ static void i810_reclaim_buffers(struct drm_device * dev, struct file *filp)
|
|||
}
|
||||
}
|
||||
|
||||
static int i810_flush_ioctl(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
static int i810_flush_ioctl(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
i810_flush_queue(dev);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int i810_dma_vertex(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
static int i810_dma_vertex(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_device_dma *dma = dev->dma;
|
||||
drm_i810_private_t *dev_priv = (drm_i810_private_t *) dev->dev_private;
|
||||
u32 *hw_status = dev_priv->hw_status_page;
|
||||
drm_i810_sarea_t *sarea_priv = (drm_i810_sarea_t *)
|
||||
dev_priv->sarea_priv;
|
||||
drm_i810_vertex_t vertex;
|
||||
drm_i810_vertex_t *vertex = data;
|
||||
|
||||
if (copy_from_user
|
||||
(&vertex, (drm_i810_vertex_t __user *) arg, sizeof(vertex)))
|
||||
return -EFAULT;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
DRM_DEBUG("i810 dma vertex, idx %d used %d discard %d\n",
|
||||
vertex.idx, vertex.used, vertex.discard);
|
||||
vertex->idx, vertex->used, vertex->discard);
|
||||
|
||||
if (vertex.idx < 0 || vertex.idx > dma->buf_count)
|
||||
if (vertex->idx < 0 || vertex->idx > dma->buf_count)
|
||||
return -EINVAL;
|
||||
|
||||
i810_dma_dispatch_vertex(dev,
|
||||
dma->buflist[vertex.idx],
|
||||
vertex.discard, vertex.used);
|
||||
dma->buflist[vertex->idx],
|
||||
vertex->discard, vertex->used);
|
||||
|
||||
atomic_add(vertex.used, &dev->counts[_DRM_STAT_SECONDARY]);
|
||||
atomic_add(vertex->used, &dev->counts[_DRM_STAT_SECONDARY]);
|
||||
atomic_inc(&dev->counts[_DRM_STAT_DMA]);
|
||||
sarea_priv->last_enqueue = dev_priv->counter - 1;
|
||||
sarea_priv->last_dispatch = (int)hw_status[5];
|
||||
|
@ -1046,48 +967,37 @@ static int i810_dma_vertex(struct inode *inode, struct file *filp,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int i810_clear_bufs(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
static int i810_clear_bufs(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
drm_i810_clear_t clear;
|
||||
drm_i810_clear_t *clear = data;
|
||||
|
||||
if (copy_from_user
|
||||
(&clear, (drm_i810_clear_t __user *) arg, sizeof(clear)))
|
||||
return -EFAULT;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
/* GH: Someone's doing nasty things... */
|
||||
if (!dev->dev_private) {
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
i810_dma_dispatch_clear(dev, clear.flags,
|
||||
clear.clear_color, clear.clear_depth);
|
||||
i810_dma_dispatch_clear(dev, clear->flags,
|
||||
clear->clear_color, clear->clear_depth);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int i810_swap_bufs(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
static int i810_swap_bufs(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
|
||||
DRM_DEBUG("i810_swap_bufs\n");
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
i810_dma_dispatch_swap(dev);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int i810_getage(struct inode *inode, struct file *filp, unsigned int cmd,
|
||||
unsigned long arg)
|
||||
static int i810_getage(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
drm_i810_private_t *dev_priv = (drm_i810_private_t *) dev->dev_private;
|
||||
u32 *hw_status = dev_priv->hw_status_page;
|
||||
drm_i810_sarea_t *sarea_priv = (drm_i810_sarea_t *)
|
||||
|
@ -1097,46 +1007,39 @@ static int i810_getage(struct inode *inode, struct file *filp, unsigned int cmd,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int i810_getbuf(struct inode *inode, struct file *filp, unsigned int cmd,
|
||||
unsigned long arg)
|
||||
static int i810_getbuf(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
int retcode = 0;
|
||||
drm_i810_dma_t d;
|
||||
drm_i810_dma_t *d = data;
|
||||
drm_i810_private_t *dev_priv = (drm_i810_private_t *) dev->dev_private;
|
||||
u32 *hw_status = dev_priv->hw_status_page;
|
||||
drm_i810_sarea_t *sarea_priv = (drm_i810_sarea_t *)
|
||||
dev_priv->sarea_priv;
|
||||
|
||||
if (copy_from_user(&d, (drm_i810_dma_t __user *) arg, sizeof(d)))
|
||||
return -EFAULT;
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
d->granted = 0;
|
||||
|
||||
d.granted = 0;
|
||||
|
||||
retcode = i810_dma_get_buffer(dev, &d, filp);
|
||||
retcode = i810_dma_get_buffer(dev, d, file_priv);
|
||||
|
||||
DRM_DEBUG("i810_dma: %d returning %d, granted = %d\n",
|
||||
current->pid, retcode, d.granted);
|
||||
current->pid, retcode, d->granted);
|
||||
|
||||
if (copy_to_user((void __user *) arg, &d, sizeof(d)))
|
||||
return -EFAULT;
|
||||
sarea_priv->last_dispatch = (int)hw_status[5];
|
||||
|
||||
return retcode;
|
||||
}
|
||||
|
||||
static int i810_copybuf(struct inode *inode,
|
||||
struct file *filp, unsigned int cmd, unsigned long arg)
|
||||
static int i810_copybuf(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
/* Never copy - 2.4.x doesn't need it */
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int i810_docopy(struct inode *inode, struct file *filp, unsigned int cmd,
|
||||
unsigned long arg)
|
||||
static int i810_docopy(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
/* Never copy - 2.4.x doesn't need it */
|
||||
return 0;
|
||||
|
@ -1202,30 +1105,25 @@ static void i810_dma_dispatch_mc(struct drm_device * dev, struct drm_buf * buf,
|
|||
ADVANCE_LP_RING();
|
||||
}
|
||||
|
||||
static int i810_dma_mc(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
static int i810_dma_mc(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_device_dma *dma = dev->dma;
|
||||
drm_i810_private_t *dev_priv = (drm_i810_private_t *) dev->dev_private;
|
||||
u32 *hw_status = dev_priv->hw_status_page;
|
||||
drm_i810_sarea_t *sarea_priv = (drm_i810_sarea_t *)
|
||||
dev_priv->sarea_priv;
|
||||
drm_i810_mc_t mc;
|
||||
drm_i810_mc_t *mc = data;
|
||||
|
||||
if (copy_from_user(&mc, (drm_i810_mc_t __user *) arg, sizeof(mc)))
|
||||
return -EFAULT;
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
|
||||
if (mc.idx >= dma->buf_count || mc.idx < 0)
|
||||
if (mc->idx >= dma->buf_count || mc->idx < 0)
|
||||
return -EINVAL;
|
||||
|
||||
i810_dma_dispatch_mc(dev, dma->buflist[mc.idx], mc.used,
|
||||
mc.last_render);
|
||||
i810_dma_dispatch_mc(dev, dma->buflist[mc->idx], mc->used,
|
||||
mc->last_render);
|
||||
|
||||
atomic_add(mc.used, &dev->counts[_DRM_STAT_SECONDARY]);
|
||||
atomic_add(mc->used, &dev->counts[_DRM_STAT_SECONDARY]);
|
||||
atomic_inc(&dev->counts[_DRM_STAT_DMA]);
|
||||
sarea_priv->last_enqueue = dev_priv->counter - 1;
|
||||
sarea_priv->last_dispatch = (int)hw_status[5];
|
||||
|
@ -1233,52 +1131,41 @@ static int i810_dma_mc(struct inode *inode, struct file *filp,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int i810_rstatus(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
static int i810_rstatus(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
drm_i810_private_t *dev_priv = (drm_i810_private_t *) dev->dev_private;
|
||||
|
||||
return (int)(((u32 *) (dev_priv->hw_status_page))[4]);
|
||||
}
|
||||
|
||||
static int i810_ov0_info(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
static int i810_ov0_info(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
drm_i810_private_t *dev_priv = (drm_i810_private_t *) dev->dev_private;
|
||||
drm_i810_overlay_t data;
|
||||
drm_i810_overlay_t *ov = data;
|
||||
|
||||
ov->offset = dev_priv->overlay_offset;
|
||||
ov->physical = dev_priv->overlay_physical;
|
||||
|
||||
data.offset = dev_priv->overlay_offset;
|
||||
data.physical = dev_priv->overlay_physical;
|
||||
if (copy_to_user
|
||||
((drm_i810_overlay_t __user *) arg, &data, sizeof(data)))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int i810_fstatus(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
static int i810_fstatus(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
drm_i810_private_t *dev_priv = (drm_i810_private_t *) dev->dev_private;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
return I810_READ(0x30008);
|
||||
}
|
||||
|
||||
static int i810_ov0_flip(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
static int i810_ov0_flip(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
drm_i810_private_t *dev_priv = (drm_i810_private_t *) dev->dev_private;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
//Tell the overlay to update
|
||||
I810_WRITE(0x30000, dev_priv->overlay_physical | 0x80000000);
|
||||
|
@ -1310,16 +1197,14 @@ static int i810_do_cleanup_pageflip(struct drm_device * dev)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int i810_flip_bufs(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
static int i810_flip_bufs(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
drm_i810_private_t *dev_priv = dev->dev_private;
|
||||
|
||||
DRM_DEBUG("%s\n", __FUNCTION__);
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
if (!dev_priv->page_flipping)
|
||||
i810_do_init_pageflip(dev);
|
||||
|
@ -1345,7 +1230,7 @@ void i810_driver_lastclose(struct drm_device * dev)
|
|||
i810_dma_cleanup(dev);
|
||||
}
|
||||
|
||||
void i810_driver_preclose(struct drm_device * dev, DRMFILE filp)
|
||||
void i810_driver_preclose(struct drm_device * dev, struct drm_file *file_priv)
|
||||
{
|
||||
if (dev->dev_private) {
|
||||
drm_i810_private_t *dev_priv = dev->dev_private;
|
||||
|
@ -1355,9 +1240,10 @@ void i810_driver_preclose(struct drm_device * dev, DRMFILE filp)
|
|||
}
|
||||
}
|
||||
|
||||
void i810_driver_reclaim_buffers_locked(struct drm_device * dev, struct file *filp)
|
||||
void i810_driver_reclaim_buffers_locked(struct drm_device * dev,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
i810_reclaim_buffers(dev, filp);
|
||||
i810_reclaim_buffers(dev, file_priv);
|
||||
}
|
||||
|
||||
int i810_driver_dma_quiescent(struct drm_device * dev)
|
||||
|
@ -1366,22 +1252,22 @@ int i810_driver_dma_quiescent(struct drm_device * dev)
|
|||
return 0;
|
||||
}
|
||||
|
||||
drm_ioctl_desc_t i810_ioctls[] = {
|
||||
[DRM_IOCTL_NR(DRM_I810_INIT)] = {i810_dma_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_I810_VERTEX)] = {i810_dma_vertex, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I810_CLEAR)] = {i810_clear_bufs, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I810_FLUSH)] = {i810_flush_ioctl, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I810_GETAGE)] = {i810_getage, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I810_GETBUF)] = {i810_getbuf, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I810_SWAP)] = {i810_swap_bufs, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I810_COPY)] = {i810_copybuf, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I810_DOCOPY)] = {i810_docopy, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I810_OV0INFO)] = {i810_ov0_info, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I810_FSTATUS)] = {i810_fstatus, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I810_OV0FLIP)] = {i810_ov0_flip, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I810_MC)] = {i810_dma_mc, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_I810_RSTATUS)] = {i810_rstatus, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I810_FLIP)] = {i810_flip_bufs, DRM_AUTH}
|
||||
struct drm_ioctl_desc i810_ioctls[] = {
|
||||
DRM_IOCTL_DEF(DRM_I810_INIT, i810_dma_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_I810_VERTEX, i810_dma_vertex, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I810_CLEAR, i810_clear_bufs, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I810_FLUSH, i810_flush_ioctl, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I810_GETAGE, i810_getage, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I810_GETBUF, i810_getbuf, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I810_SWAP, i810_swap_bufs, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I810_COPY, i810_copybuf, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I810_DOCOPY, i810_docopy, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I810_OV0INFO, i810_ov0_info, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I810_FSTATUS, i810_fstatus, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I810_OV0FLIP, i810_ov0_flip, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I810_MC, i810_dma_mc, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_I810_RSTATUS, i810_rstatus, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I810_FLIP, i810_flip_bufs, DRM_AUTH)
|
||||
};
|
||||
|
||||
int i810_max_ioctl = DRM_ARRAY_SIZE(i810_ioctls);
|
||||
|
|
|
@ -102,13 +102,8 @@ typedef enum _drm_i810_init_func {
|
|||
/* This is the init structure after v1.2 */
|
||||
typedef struct _drm_i810_init {
|
||||
drm_i810_init_func_t func;
|
||||
#if CONFIG_XFREE86_VERSION < XFREE86_VERSION(4,1,0,0)
|
||||
int ring_map_idx;
|
||||
int buffer_map_idx;
|
||||
#else
|
||||
unsigned int mmio_offset;
|
||||
unsigned int buffers_offset;
|
||||
#endif
|
||||
int sarea_priv_offset;
|
||||
unsigned int ring_start;
|
||||
unsigned int ring_end;
|
||||
|
|
|
@ -117,15 +117,16 @@ typedef struct drm_i810_private {
|
|||
/* i810_dma.c */
|
||||
extern int i810_driver_dma_quiescent(struct drm_device * dev);
|
||||
extern void i810_driver_reclaim_buffers_locked(struct drm_device * dev,
|
||||
struct file *filp);
|
||||
struct drm_file *file_priv);
|
||||
extern int i810_driver_load(struct drm_device *, unsigned long flags);
|
||||
extern void i810_driver_lastclose(struct drm_device * dev);
|
||||
extern void i810_driver_preclose(struct drm_device * dev, DRMFILE filp);
|
||||
extern void i810_driver_preclose(struct drm_device * dev,
|
||||
struct drm_file *file_priv);
|
||||
extern void i810_driver_reclaim_buffers_locked(struct drm_device * dev,
|
||||
struct file *filp);
|
||||
struct drm_file *file_priv);
|
||||
extern int i810_driver_device_is_agp(struct drm_device * dev);
|
||||
|
||||
extern drm_ioctl_desc_t i810_ioctls[];
|
||||
extern struct drm_ioctl_desc i810_ioctls[];
|
||||
extern int i810_max_ioctl;
|
||||
|
||||
#define I810_BASE(reg) ((unsigned long) \
|
||||
|
|
|
@ -122,10 +122,9 @@ static const struct file_operations i830_buffer_fops = {
|
|||
.fasync = drm_fasync,
|
||||
};
|
||||
|
||||
static int i830_map_buffer(struct drm_buf * buf, struct file *filp)
|
||||
static int i830_map_buffer(struct drm_buf * buf, struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_device *dev = file_priv->head->dev;
|
||||
drm_i830_buf_priv_t *buf_priv = buf->dev_private;
|
||||
drm_i830_private_t *dev_priv = dev->dev_private;
|
||||
const struct file_operations *old_fops;
|
||||
|
@ -136,13 +135,13 @@ static int i830_map_buffer(struct drm_buf * buf, struct file *filp)
|
|||
return -EINVAL;
|
||||
|
||||
down_write(¤t->mm->mmap_sem);
|
||||
old_fops = filp->f_op;
|
||||
filp->f_op = &i830_buffer_fops;
|
||||
old_fops = file_priv->filp->f_op;
|
||||
file_priv->filp->f_op = &i830_buffer_fops;
|
||||
dev_priv->mmap_buffer = buf;
|
||||
virtual = do_mmap(filp, 0, buf->total, PROT_READ | PROT_WRITE,
|
||||
virtual = do_mmap(file_priv->filp, 0, buf->total, PROT_READ | PROT_WRITE,
|
||||
MAP_SHARED, buf->bus_address);
|
||||
dev_priv->mmap_buffer = NULL;
|
||||
filp->f_op = old_fops;
|
||||
file_priv->filp->f_op = old_fops;
|
||||
if (IS_ERR((void *)virtual)) { /* ugh */
|
||||
/* Real error */
|
||||
DRM_ERROR("mmap error\n");
|
||||
|
@ -177,7 +176,7 @@ static int i830_unmap_buffer(struct drm_buf * buf)
|
|||
}
|
||||
|
||||
static int i830_dma_get_buffer(struct drm_device * dev, drm_i830_dma_t * d,
|
||||
struct file *filp)
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_buf *buf;
|
||||
drm_i830_buf_priv_t *buf_priv;
|
||||
|
@ -190,13 +189,13 @@ static int i830_dma_get_buffer(struct drm_device * dev, drm_i830_dma_t * d,
|
|||
return retcode;
|
||||
}
|
||||
|
||||
retcode = i830_map_buffer(buf, filp);
|
||||
retcode = i830_map_buffer(buf, file_priv);
|
||||
if (retcode) {
|
||||
i830_freelist_put(dev, buf);
|
||||
DRM_ERROR("mapbuf failed, retcode %d\n", retcode);
|
||||
return retcode;
|
||||
}
|
||||
buf->filp = filp;
|
||||
buf->file_priv = file_priv;
|
||||
buf_priv = buf->dev_private;
|
||||
d->granted = 1;
|
||||
d->request_idx = buf->idx;
|
||||
|
@ -389,7 +388,7 @@ static int i830_dma_initialize(struct drm_device * dev,
|
|||
i830_dma_cleanup(dev);
|
||||
DRM_ERROR("can not ioremap virtual address for"
|
||||
" ring buffer\n");
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
dev_priv->ring.virtual_start = dev_priv->ring.map.handle;
|
||||
|
@ -451,25 +450,20 @@ static int i830_dma_initialize(struct drm_device * dev,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int i830_dma_init(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
static int i830_dma_init(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
drm_i830_private_t *dev_priv;
|
||||
drm_i830_init_t init;
|
||||
drm_i830_init_t *init = data;
|
||||
int retcode = 0;
|
||||
|
||||
if (copy_from_user(&init, (void *__user)arg, sizeof(init)))
|
||||
return -EFAULT;
|
||||
|
||||
switch (init.func) {
|
||||
switch (init->func) {
|
||||
case I830_INIT_DMA:
|
||||
dev_priv = drm_alloc(sizeof(drm_i830_private_t),
|
||||
DRM_MEM_DRIVER);
|
||||
if (dev_priv == NULL)
|
||||
return -ENOMEM;
|
||||
retcode = i830_dma_initialize(dev, dev_priv, &init);
|
||||
retcode = i830_dma_initialize(dev, dev_priv, init);
|
||||
break;
|
||||
case I830_CLEANUP_DMA:
|
||||
retcode = i830_dma_cleanup(dev);
|
||||
|
@ -1248,7 +1242,7 @@ static int i830_flush_queue(struct drm_device * dev)
|
|||
}
|
||||
|
||||
/* Must be called with the lock held */
|
||||
static void i830_reclaim_buffers(struct drm_device * dev, struct file *filp)
|
||||
static void i830_reclaim_buffers(struct drm_device * dev, struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_device_dma *dma = dev->dma;
|
||||
int i;
|
||||
|
@ -1266,7 +1260,7 @@ static void i830_reclaim_buffers(struct drm_device * dev, struct file *filp)
|
|||
struct drm_buf *buf = dma->buflist[i];
|
||||
drm_i830_buf_priv_t *buf_priv = buf->dev_private;
|
||||
|
||||
if (buf->filp == filp && buf_priv) {
|
||||
if (buf->file_priv == file_priv && buf_priv) {
|
||||
int used = cmpxchg(buf_priv->in_use, I830_BUF_CLIENT,
|
||||
I830_BUF_FREE);
|
||||
|
||||
|
@ -1278,45 +1272,36 @@ static void i830_reclaim_buffers(struct drm_device * dev, struct file *filp)
|
|||
}
|
||||
}
|
||||
|
||||
static int i830_flush_ioctl(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
static int i830_flush_ioctl(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
i830_flush_queue(dev);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int i830_dma_vertex(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
static int i830_dma_vertex(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
struct drm_device_dma *dma = dev->dma;
|
||||
drm_i830_private_t *dev_priv = (drm_i830_private_t *) dev->dev_private;
|
||||
u32 *hw_status = dev_priv->hw_status_page;
|
||||
drm_i830_sarea_t *sarea_priv = (drm_i830_sarea_t *)
|
||||
dev_priv->sarea_priv;
|
||||
drm_i830_vertex_t vertex;
|
||||
drm_i830_vertex_t *vertex = data;
|
||||
|
||||
if (copy_from_user
|
||||
(&vertex, (drm_i830_vertex_t __user *) arg, sizeof(vertex)))
|
||||
return -EFAULT;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
DRM_DEBUG("i830 dma vertex, idx %d used %d discard %d\n",
|
||||
vertex.idx, vertex.used, vertex.discard);
|
||||
vertex->idx, vertex->used, vertex->discard);
|
||||
|
||||
if (vertex.idx < 0 || vertex.idx > dma->buf_count)
|
||||
if (vertex->idx < 0 || vertex->idx > dma->buf_count)
|
||||
return -EINVAL;
|
||||
|
||||
i830_dma_dispatch_vertex(dev,
|
||||
dma->buflist[vertex.idx],
|
||||
vertex.discard, vertex.used);
|
||||
dma->buflist[vertex->idx],
|
||||
vertex->discard, vertex->used);
|
||||
|
||||
sarea_priv->last_enqueue = dev_priv->counter - 1;
|
||||
sarea_priv->last_dispatch = (int)hw_status[5];
|
||||
|
@ -1324,39 +1309,30 @@ static int i830_dma_vertex(struct inode *inode, struct file *filp,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int i830_clear_bufs(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
static int i830_clear_bufs(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
drm_i830_clear_t clear;
|
||||
drm_i830_clear_t *clear = data;
|
||||
|
||||
if (copy_from_user
|
||||
(&clear, (drm_i830_clear_t __user *) arg, sizeof(clear)))
|
||||
return -EFAULT;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
/* GH: Someone's doing nasty things... */
|
||||
if (!dev->dev_private) {
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
i830_dma_dispatch_clear(dev, clear.flags,
|
||||
clear.clear_color,
|
||||
clear.clear_depth, clear.clear_depthmask);
|
||||
i830_dma_dispatch_clear(dev, clear->flags,
|
||||
clear->clear_color,
|
||||
clear->clear_depth, clear->clear_depthmask);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int i830_swap_bufs(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
static int i830_swap_bufs(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
|
||||
DRM_DEBUG("i830_swap_bufs\n");
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
i830_dma_dispatch_swap(dev);
|
||||
return 0;
|
||||
|
@ -1386,16 +1362,14 @@ static int i830_do_cleanup_pageflip(struct drm_device * dev)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int i830_flip_bufs(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
static int i830_flip_bufs(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
drm_i830_private_t *dev_priv = dev->dev_private;
|
||||
|
||||
DRM_DEBUG("%s\n", __FUNCTION__);
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
if (!dev_priv->page_flipping)
|
||||
i830_do_init_pageflip(dev);
|
||||
|
@ -1404,11 +1378,9 @@ static int i830_flip_bufs(struct inode *inode, struct file *filp,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int i830_getage(struct inode *inode, struct file *filp, unsigned int cmd,
|
||||
unsigned long arg)
|
||||
static int i830_getage(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
drm_i830_private_t *dev_priv = (drm_i830_private_t *) dev->dev_private;
|
||||
u32 *hw_status = dev_priv->hw_status_page;
|
||||
drm_i830_sarea_t *sarea_priv = (drm_i830_sarea_t *)
|
||||
|
@ -1418,58 +1390,50 @@ static int i830_getage(struct inode *inode, struct file *filp, unsigned int cmd,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int i830_getbuf(struct inode *inode, struct file *filp, unsigned int cmd,
|
||||
unsigned long arg)
|
||||
static int i830_getbuf(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
int retcode = 0;
|
||||
drm_i830_dma_t d;
|
||||
drm_i830_dma_t *d = data;
|
||||
drm_i830_private_t *dev_priv = (drm_i830_private_t *) dev->dev_private;
|
||||
u32 *hw_status = dev_priv->hw_status_page;
|
||||
drm_i830_sarea_t *sarea_priv = (drm_i830_sarea_t *)
|
||||
dev_priv->sarea_priv;
|
||||
|
||||
DRM_DEBUG("getbuf\n");
|
||||
if (copy_from_user(&d, (drm_i830_dma_t __user *) arg, sizeof(d)))
|
||||
return -EFAULT;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
d.granted = 0;
|
||||
d->granted = 0;
|
||||
|
||||
retcode = i830_dma_get_buffer(dev, &d, filp);
|
||||
retcode = i830_dma_get_buffer(dev, d, file_priv);
|
||||
|
||||
DRM_DEBUG("i830_dma: %d returning %d, granted = %d\n",
|
||||
current->pid, retcode, d.granted);
|
||||
current->pid, retcode, d->granted);
|
||||
|
||||
if (copy_to_user((void __user *) arg, &d, sizeof(d)))
|
||||
return -EFAULT;
|
||||
sarea_priv->last_dispatch = (int)hw_status[5];
|
||||
|
||||
return retcode;
|
||||
}
|
||||
|
||||
static int i830_copybuf(struct inode *inode,
|
||||
struct file *filp, unsigned int cmd, unsigned long arg)
|
||||
static int i830_copybuf(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
/* Never copy - 2.4.x doesn't need it */
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int i830_docopy(struct inode *inode, struct file *filp, unsigned int cmd,
|
||||
unsigned long arg)
|
||||
static int i830_docopy(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int i830_getparam(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
static int i830_getparam(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
drm_i830_private_t *dev_priv = dev->dev_private;
|
||||
drm_i830_getparam_t param;
|
||||
drm_i830_getparam_t *param = data;
|
||||
int value;
|
||||
|
||||
if (!dev_priv) {
|
||||
|
@ -1477,11 +1441,7 @@ static int i830_getparam(struct inode *inode, struct file *filp,
|
|||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (copy_from_user
|
||||
(¶m, (drm_i830_getparam_t __user *) arg, sizeof(param)))
|
||||
return -EFAULT;
|
||||
|
||||
switch (param.param) {
|
||||
switch (param->param) {
|
||||
case I830_PARAM_IRQ_ACTIVE:
|
||||
value = dev->irq_enabled;
|
||||
break;
|
||||
|
@ -1489,7 +1449,7 @@ static int i830_getparam(struct inode *inode, struct file *filp,
|
|||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (copy_to_user(param.value, &value, sizeof(int))) {
|
||||
if (copy_to_user(param->value, &value, sizeof(int))) {
|
||||
DRM_ERROR("copy_to_user\n");
|
||||
return -EFAULT;
|
||||
}
|
||||
|
@ -1497,26 +1457,20 @@ static int i830_getparam(struct inode *inode, struct file *filp,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int i830_setparam(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg)
|
||||
static int i830_setparam(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
drm_i830_private_t *dev_priv = dev->dev_private;
|
||||
drm_i830_setparam_t param;
|
||||
drm_i830_setparam_t *param = data;
|
||||
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (copy_from_user
|
||||
(¶m, (drm_i830_setparam_t __user *) arg, sizeof(param)))
|
||||
return -EFAULT;
|
||||
|
||||
switch (param.param) {
|
||||
switch (param->param) {
|
||||
case I830_SETPARAM_USE_MI_BATCHBUFFER_START:
|
||||
dev_priv->use_mi_batchbuffer_start = param.value;
|
||||
dev_priv->use_mi_batchbuffer_start = param->value;
|
||||
break;
|
||||
default:
|
||||
return -EINVAL;
|
||||
|
@ -1542,7 +1496,7 @@ void i830_driver_lastclose(struct drm_device * dev)
|
|||
i830_dma_cleanup(dev);
|
||||
}
|
||||
|
||||
void i830_driver_preclose(struct drm_device * dev, DRMFILE filp)
|
||||
void i830_driver_preclose(struct drm_device * dev, struct drm_file *file_priv)
|
||||
{
|
||||
if (dev->dev_private) {
|
||||
drm_i830_private_t *dev_priv = dev->dev_private;
|
||||
|
@ -1552,9 +1506,9 @@ void i830_driver_preclose(struct drm_device * dev, DRMFILE filp)
|
|||
}
|
||||
}
|
||||
|
||||
void i830_driver_reclaim_buffers_locked(struct drm_device * dev, struct file *filp)
|
||||
void i830_driver_reclaim_buffers_locked(struct drm_device * dev, struct drm_file *file_priv)
|
||||
{
|
||||
i830_reclaim_buffers(dev, filp);
|
||||
i830_reclaim_buffers(dev, file_priv);
|
||||
}
|
||||
|
||||
int i830_driver_dma_quiescent(struct drm_device * dev)
|
||||
|
@ -1563,21 +1517,21 @@ int i830_driver_dma_quiescent(struct drm_device * dev)
|
|||
return 0;
|
||||
}
|
||||
|
||||
drm_ioctl_desc_t i830_ioctls[] = {
|
||||
[DRM_IOCTL_NR(DRM_I830_INIT)] = {i830_dma_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_I830_VERTEX)] = {i830_dma_vertex, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I830_CLEAR)] = {i830_clear_bufs, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I830_FLUSH)] = {i830_flush_ioctl, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I830_GETAGE)] = {i830_getage, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I830_GETBUF)] = {i830_getbuf, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I830_SWAP)] = {i830_swap_bufs, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I830_COPY)] = {i830_copybuf, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I830_DOCOPY)] = {i830_docopy, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I830_FLIP)] = {i830_flip_bufs, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I830_IRQ_EMIT)] = {i830_irq_emit, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I830_IRQ_WAIT)] = {i830_irq_wait, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I830_GETPARAM)] = {i830_getparam, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I830_SETPARAM)] = {i830_setparam, DRM_AUTH}
|
||||
struct drm_ioctl_desc i830_ioctls[] = {
|
||||
DRM_IOCTL_DEF(DRM_I830_INIT, i830_dma_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_I830_VERTEX, i830_dma_vertex, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I830_CLEAR, i830_clear_bufs, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I830_FLUSH, i830_flush_ioctl, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I830_GETAGE, i830_getage, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I830_GETBUF, i830_getbuf, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I830_SWAP, i830_swap_bufs, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I830_COPY, i830_copybuf, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I830_DOCOPY, i830_docopy, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I830_FLIP, i830_flip_bufs, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I830_IRQ_EMIT, i830_irq_emit, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I830_IRQ_WAIT, i830_irq_wait, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I830_GETPARAM, i830_getparam, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I830_SETPARAM, i830_setparam, DRM_AUTH)
|
||||
};
|
||||
|
||||
int i830_max_ioctl = DRM_ARRAY_SIZE(i830_ioctls);
|
||||
|
|
|
@ -122,24 +122,25 @@ typedef struct drm_i830_private {
|
|||
|
||||
} drm_i830_private_t;
|
||||
|
||||
extern drm_ioctl_desc_t i830_ioctls[];
|
||||
extern struct drm_ioctl_desc i830_ioctls[];
|
||||
extern int i830_max_ioctl;
|
||||
|
||||
/* i830_irq.c */
|
||||
extern int i830_irq_emit(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int i830_irq_wait(struct inode *inode, struct file *filp,
|
||||
unsigned int cmd, unsigned long arg);
|
||||
extern int i830_irq_emit(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv);
|
||||
extern int i830_irq_wait(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv);
|
||||
|
||||
extern irqreturn_t i830_driver_irq_handler(DRM_IRQ_ARGS);
|
||||
extern void i830_driver_irq_preinstall(struct drm_device * dev);
|
||||
extern void i830_driver_irq_postinstall(struct drm_device * dev);
|
||||
extern void i830_driver_irq_uninstall(struct drm_device * dev);
|
||||
extern int i830_driver_load(struct drm_device *, unsigned long flags);
|
||||
extern void i830_driver_preclose(struct drm_device * dev, DRMFILE filp);
|
||||
extern void i830_driver_preclose(struct drm_device * dev,
|
||||
struct drm_file *file_priv);
|
||||
extern void i830_driver_lastclose(struct drm_device * dev);
|
||||
extern void i830_driver_reclaim_buffers_locked(struct drm_device * dev,
|
||||
struct file *filp);
|
||||
struct drm_file *file_priv);
|
||||
extern int i830_driver_dma_quiescent(struct drm_device * dev);
|
||||
extern int i830_driver_device_is_agp(struct drm_device * dev);
|
||||
|
||||
|
|
|
@ -114,29 +114,23 @@ static int i830_wait_irq(struct drm_device * dev, int irq_nr)
|
|||
|
||||
/* Needs the lock as it touches the ring.
|
||||
*/
|
||||
int i830_irq_emit(struct inode *inode, struct file *filp, unsigned int cmd,
|
||||
unsigned long arg)
|
||||
int i830_irq_emit(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
drm_i830_private_t *dev_priv = dev->dev_private;
|
||||
drm_i830_irq_emit_t emit;
|
||||
drm_i830_irq_emit_t *emit = data;
|
||||
int result;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (copy_from_user
|
||||
(&emit, (drm_i830_irq_emit_t __user *) arg, sizeof(emit)))
|
||||
return -EFAULT;
|
||||
|
||||
result = i830_emit_irq(dev);
|
||||
|
||||
if (copy_to_user(emit.irq_seq, &result, sizeof(int))) {
|
||||
if (copy_to_user(emit->irq_seq, &result, sizeof(int))) {
|
||||
DRM_ERROR("copy_to_user\n");
|
||||
return -EFAULT;
|
||||
}
|
||||
|
@ -146,24 +140,18 @@ int i830_irq_emit(struct inode *inode, struct file *filp, unsigned int cmd,
|
|||
|
||||
/* Doesn't need the hardware lock.
|
||||
*/
|
||||
int i830_irq_wait(struct inode *inode, struct file *filp, unsigned int cmd,
|
||||
unsigned long arg)
|
||||
int i830_irq_wait(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_file *priv = filp->private_data;
|
||||
struct drm_device *dev = priv->head->dev;
|
||||
drm_i830_private_t *dev_priv = dev->dev_private;
|
||||
drm_i830_irq_wait_t irqwait;
|
||||
drm_i830_irq_wait_t *irqwait = data;
|
||||
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (copy_from_user(&irqwait, (drm_i830_irq_wait_t __user *) arg,
|
||||
sizeof(irqwait)))
|
||||
return -EFAULT;
|
||||
|
||||
return i830_wait_irq(dev, irqwait.irq_seq);
|
||||
return i830_wait_irq(dev, irqwait->irq_seq);
|
||||
}
|
||||
|
||||
/* drm_dma.h hooks
|
||||
|
|
|
@ -70,7 +70,7 @@ int i915_wait_ring(struct drm_device * dev, int n, const char *caller)
|
|||
last_head = ring->head;
|
||||
}
|
||||
|
||||
return DRM_ERR(EBUSY);
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
void i915_kernel_lost_context(struct drm_device * dev)
|
||||
|
@ -137,7 +137,7 @@ static int i915_initialize(struct drm_device * dev,
|
|||
DRM_ERROR("can not find sarea!\n");
|
||||
dev->dev_private = (void *)dev_priv;
|
||||
i915_dma_cleanup(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
dev_priv->mmio_map = drm_core_findmap(dev, init->mmio_offset);
|
||||
|
@ -145,7 +145,7 @@ static int i915_initialize(struct drm_device * dev,
|
|||
dev->dev_private = (void *)dev_priv;
|
||||
i915_dma_cleanup(dev);
|
||||
DRM_ERROR("can not find mmio map!\n");
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
dev_priv->sarea_priv = (drm_i915_sarea_t *)
|
||||
|
@ -169,7 +169,7 @@ static int i915_initialize(struct drm_device * dev,
|
|||
i915_dma_cleanup(dev);
|
||||
DRM_ERROR("can not ioremap virtual address for"
|
||||
" ring buffer\n");
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
dev_priv->ring.virtual_start = dev_priv->ring.map.handle;
|
||||
|
@ -200,7 +200,7 @@ static int i915_initialize(struct drm_device * dev,
|
|||
dev->dev_private = (void *)dev_priv;
|
||||
i915_dma_cleanup(dev);
|
||||
DRM_ERROR("Can not allocate hardware status page\n");
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
dev_priv->hw_status_page = dev_priv->status_page_dmah->vaddr;
|
||||
dev_priv->dma_status_page = dev_priv->status_page_dmah->busaddr;
|
||||
|
@ -221,24 +221,24 @@ static int i915_dma_resume(struct drm_device * dev)
|
|||
|
||||
if (!dev_priv->sarea) {
|
||||
DRM_ERROR("can not find sarea!\n");
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (!dev_priv->mmio_map) {
|
||||
DRM_ERROR("can not find mmio map!\n");
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (dev_priv->ring.map.handle == NULL) {
|
||||
DRM_ERROR("can not ioremap virtual address for"
|
||||
" ring buffer\n");
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
/* Program Hardware Status Page */
|
||||
if (!dev_priv->hw_status_page) {
|
||||
DRM_ERROR("Can not find hardware status page\n");
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
DRM_DEBUG("hw status page @ %p\n", dev_priv->hw_status_page);
|
||||
|
||||
|
@ -251,23 +251,20 @@ static int i915_dma_resume(struct drm_device * dev)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int i915_dma_init(DRM_IOCTL_ARGS)
|
||||
static int i915_dma_init(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_i915_private_t *dev_priv;
|
||||
drm_i915_init_t init;
|
||||
drm_i915_init_t *init = data;
|
||||
int retcode = 0;
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(init, (drm_i915_init_t __user *) data,
|
||||
sizeof(init));
|
||||
|
||||
switch (init.func) {
|
||||
switch (init->func) {
|
||||
case I915_INIT_DMA:
|
||||
dev_priv = drm_alloc(sizeof(drm_i915_private_t),
|
||||
DRM_MEM_DRIVER);
|
||||
if (dev_priv == NULL)
|
||||
return DRM_ERR(ENOMEM);
|
||||
retcode = i915_initialize(dev, dev_priv, &init);
|
||||
return -ENOMEM;
|
||||
retcode = i915_initialize(dev, dev_priv, init);
|
||||
break;
|
||||
case I915_CLEANUP_DMA:
|
||||
retcode = i915_dma_cleanup(dev);
|
||||
|
@ -276,7 +273,7 @@ static int i915_dma_init(DRM_IOCTL_ARGS)
|
|||
retcode = i915_dma_resume(dev);
|
||||
break;
|
||||
default:
|
||||
retcode = DRM_ERR(EINVAL);
|
||||
retcode = -EINVAL;
|
||||
break;
|
||||
}
|
||||
|
||||
|
@ -366,7 +363,7 @@ static int i915_emit_cmds(struct drm_device * dev, int __user * buffer, int dwor
|
|||
RING_LOCALS;
|
||||
|
||||
if ((dwords+1) * sizeof(int) >= dev_priv->ring.Size - 8)
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
|
||||
BEGIN_LP_RING((dwords+1)&~1);
|
||||
|
||||
|
@ -374,17 +371,17 @@ static int i915_emit_cmds(struct drm_device * dev, int __user * buffer, int dwor
|
|||
int cmd, sz;
|
||||
|
||||
if (DRM_COPY_FROM_USER_UNCHECKED(&cmd, &buffer[i], sizeof(cmd)))
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
|
||||
if ((sz = validate_cmd(cmd)) == 0 || i + sz > dwords)
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
|
||||
OUT_RING(cmd);
|
||||
|
||||
while (++i, --sz) {
|
||||
if (DRM_COPY_FROM_USER_UNCHECKED(&cmd, &buffer[i],
|
||||
sizeof(cmd))) {
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
OUT_RING(cmd);
|
||||
}
|
||||
|
@ -407,13 +404,13 @@ static int i915_emit_box(struct drm_device * dev,
|
|||
RING_LOCALS;
|
||||
|
||||
if (DRM_COPY_FROM_USER_UNCHECKED(&box, &boxes[i], sizeof(box))) {
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
if (box.y2 <= box.y1 || box.x2 <= box.x1 || box.y2 <= 0 || box.x2 <= 0) {
|
||||
DRM_ERROR("Bad box %d,%d..%d,%d\n",
|
||||
box.x1, box.y1, box.x2, box.y2);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (IS_I965G(dev)) {
|
||||
|
@ -467,7 +464,7 @@ static int i915_dispatch_cmdbuffer(struct drm_device * dev,
|
|||
|
||||
if (cmd->sz & 0x3) {
|
||||
DRM_ERROR("alignment");
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
i915_kernel_lost_context(dev);
|
||||
|
@ -502,7 +499,7 @@ static int i915_dispatch_batchbuffer(struct drm_device * dev,
|
|||
|
||||
if ((batch->start | batch->used) & 0x7) {
|
||||
DRM_ERROR("alignment");
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
i915_kernel_lost_context(dev);
|
||||
|
@ -598,76 +595,69 @@ static int i915_quiescent(struct drm_device * dev)
|
|||
return i915_wait_ring(dev, dev_priv->ring.Size - 8, __FUNCTION__);
|
||||
}
|
||||
|
||||
static int i915_flush_ioctl(DRM_IOCTL_ARGS)
|
||||
static int i915_flush_ioctl(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
return i915_quiescent(dev);
|
||||
}
|
||||
|
||||
static int i915_batchbuffer(DRM_IOCTL_ARGS)
|
||||
static int i915_batchbuffer(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
|
||||
u32 *hw_status = dev_priv->hw_status_page;
|
||||
drm_i915_sarea_t *sarea_priv = (drm_i915_sarea_t *)
|
||||
dev_priv->sarea_priv;
|
||||
drm_i915_batchbuffer_t batch;
|
||||
drm_i915_batchbuffer_t *batch = data;
|
||||
int ret;
|
||||
|
||||
if (!dev_priv->allow_batchbuffer) {
|
||||
DRM_ERROR("Batchbuffer ioctl disabled\n");
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(batch, (drm_i915_batchbuffer_t __user *) data,
|
||||
sizeof(batch));
|
||||
|
||||
DRM_DEBUG("i915 batchbuffer, start %x used %d cliprects %d\n",
|
||||
batch.start, batch.used, batch.num_cliprects);
|
||||
batch->start, batch->used, batch->num_cliprects);
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
if (batch.num_cliprects && DRM_VERIFYAREA_READ(batch.cliprects,
|
||||
batch.num_cliprects *
|
||||
if (batch->num_cliprects && DRM_VERIFYAREA_READ(batch->cliprects,
|
||||
batch->num_cliprects *
|
||||
sizeof(struct drm_clip_rect)))
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
|
||||
ret = i915_dispatch_batchbuffer(dev, &batch);
|
||||
ret = i915_dispatch_batchbuffer(dev, batch);
|
||||
|
||||
sarea_priv->last_dispatch = (int)hw_status[5];
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int i915_cmdbuffer(DRM_IOCTL_ARGS)
|
||||
static int i915_cmdbuffer(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
|
||||
u32 *hw_status = dev_priv->hw_status_page;
|
||||
drm_i915_sarea_t *sarea_priv = (drm_i915_sarea_t *)
|
||||
dev_priv->sarea_priv;
|
||||
drm_i915_cmdbuffer_t cmdbuf;
|
||||
drm_i915_cmdbuffer_t *cmdbuf = data;
|
||||
int ret;
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(cmdbuf, (drm_i915_cmdbuffer_t __user *) data,
|
||||
sizeof(cmdbuf));
|
||||
|
||||
DRM_DEBUG("i915 cmdbuffer, buf %p sz %d cliprects %d\n",
|
||||
cmdbuf.buf, cmdbuf.sz, cmdbuf.num_cliprects);
|
||||
cmdbuf->buf, cmdbuf->sz, cmdbuf->num_cliprects);
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
if (cmdbuf.num_cliprects &&
|
||||
DRM_VERIFYAREA_READ(cmdbuf.cliprects,
|
||||
cmdbuf.num_cliprects *
|
||||
if (cmdbuf->num_cliprects &&
|
||||
DRM_VERIFYAREA_READ(cmdbuf->cliprects,
|
||||
cmdbuf->num_cliprects *
|
||||
sizeof(struct drm_clip_rect))) {
|
||||
DRM_ERROR("Fault accessing cliprects\n");
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
ret = i915_dispatch_cmdbuffer(dev, &cmdbuf);
|
||||
ret = i915_dispatch_cmdbuffer(dev, cmdbuf);
|
||||
if (ret) {
|
||||
DRM_ERROR("i915_dispatch_cmdbuffer failed\n");
|
||||
return ret;
|
||||
|
@ -677,33 +667,29 @@ static int i915_cmdbuffer(DRM_IOCTL_ARGS)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int i915_flip_bufs(DRM_IOCTL_ARGS)
|
||||
static int i915_flip_bufs(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
|
||||
DRM_DEBUG("%s\n", __FUNCTION__);
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
return i915_dispatch_flip(dev);
|
||||
}
|
||||
|
||||
static int i915_getparam(DRM_IOCTL_ARGS)
|
||||
static int i915_getparam(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_i915_private_t *dev_priv = dev->dev_private;
|
||||
drm_i915_getparam_t param;
|
||||
drm_i915_getparam_t *param = data;
|
||||
int value;
|
||||
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(param, (drm_i915_getparam_t __user *) data,
|
||||
sizeof(param));
|
||||
|
||||
switch (param.param) {
|
||||
switch (param->param) {
|
||||
case I915_PARAM_IRQ_ACTIVE:
|
||||
value = dev->irq ? 1 : 0;
|
||||
break;
|
||||
|
@ -714,68 +700,64 @@ static int i915_getparam(DRM_IOCTL_ARGS)
|
|||
value = READ_BREADCRUMB(dev_priv);
|
||||
break;
|
||||
default:
|
||||
DRM_ERROR("Unknown parameter %d\n", param.param);
|
||||
return DRM_ERR(EINVAL);
|
||||
DRM_ERROR("Unknown parameter %d\n", param->param);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (DRM_COPY_TO_USER(param.value, &value, sizeof(int))) {
|
||||
if (DRM_COPY_TO_USER(param->value, &value, sizeof(int))) {
|
||||
DRM_ERROR("DRM_COPY_TO_USER failed\n");
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int i915_setparam(DRM_IOCTL_ARGS)
|
||||
static int i915_setparam(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_i915_private_t *dev_priv = dev->dev_private;
|
||||
drm_i915_setparam_t param;
|
||||
drm_i915_setparam_t *param = data;
|
||||
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(param, (drm_i915_setparam_t __user *) data,
|
||||
sizeof(param));
|
||||
|
||||
switch (param.param) {
|
||||
switch (param->param) {
|
||||
case I915_SETPARAM_USE_MI_BATCHBUFFER_START:
|
||||
if (!IS_I965G(dev))
|
||||
dev_priv->use_mi_batchbuffer_start = param.value;
|
||||
dev_priv->use_mi_batchbuffer_start = param->value;
|
||||
break;
|
||||
case I915_SETPARAM_TEX_LRU_LOG_GRANULARITY:
|
||||
dev_priv->tex_lru_log_granularity = param.value;
|
||||
dev_priv->tex_lru_log_granularity = param->value;
|
||||
break;
|
||||
case I915_SETPARAM_ALLOW_BATCHBUFFER:
|
||||
dev_priv->allow_batchbuffer = param.value;
|
||||
dev_priv->allow_batchbuffer = param->value;
|
||||
break;
|
||||
default:
|
||||
DRM_ERROR("unknown parameter %d\n", param.param);
|
||||
return DRM_ERR(EINVAL);
|
||||
DRM_ERROR("unknown parameter %d\n", param->param);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int i915_set_status_page(DRM_IOCTL_ARGS)
|
||||
static int i915_set_status_page(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_i915_private_t *dev_priv = dev->dev_private;
|
||||
drm_i915_hws_addr_t hws;
|
||||
drm_i915_hws_addr_t *hws = data;
|
||||
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
DRM_COPY_FROM_USER_IOCTL(hws, (drm_i915_hws_addr_t __user *) data,
|
||||
sizeof(hws));
|
||||
printk(KERN_DEBUG "set status page addr 0x%08x\n", (u32)hws.addr);
|
||||
|
||||
dev_priv->status_gfx_addr = hws.addr & (0x1ffff<<12);
|
||||
printk(KERN_DEBUG "set status page addr 0x%08x\n", (u32)hws->addr);
|
||||
|
||||
dev_priv->hws_map.offset = dev->agp->agp_info.aper_base + hws.addr;
|
||||
dev_priv->status_gfx_addr = hws->addr & (0x1ffff<<12);
|
||||
|
||||
dev_priv->hws_map.offset = dev->agp->agp_info.aper_base + hws->addr;
|
||||
dev_priv->hws_map.size = 4*1024;
|
||||
dev_priv->hws_map.type = 0;
|
||||
dev_priv->hws_map.flags = 0;
|
||||
|
@ -788,7 +770,7 @@ static int i915_set_status_page(DRM_IOCTL_ARGS)
|
|||
dev_priv->status_gfx_addr = 0;
|
||||
DRM_ERROR("can not ioremap virtual address for"
|
||||
" G33 hw status page\n");
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
dev_priv->hw_status_page = dev_priv->hws_map.handle;
|
||||
|
||||
|
@ -821,32 +803,32 @@ void i915_driver_lastclose(struct drm_device * dev)
|
|||
i915_dma_cleanup(dev);
|
||||
}
|
||||
|
||||
void i915_driver_preclose(struct drm_device * dev, DRMFILE filp)
|
||||
void i915_driver_preclose(struct drm_device * dev, struct drm_file *file_priv)
|
||||
{
|
||||
if (dev->dev_private) {
|
||||
drm_i915_private_t *dev_priv = dev->dev_private;
|
||||
i915_mem_release(dev, filp, dev_priv->agp_heap);
|
||||
i915_mem_release(dev, file_priv, dev_priv->agp_heap);
|
||||
}
|
||||
}
|
||||
|
||||
drm_ioctl_desc_t i915_ioctls[] = {
|
||||
[DRM_IOCTL_NR(DRM_I915_INIT)] = {i915_dma_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_I915_FLUSH)] = {i915_flush_ioctl, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I915_FLIP)] = {i915_flip_bufs, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I915_BATCHBUFFER)] = {i915_batchbuffer, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I915_IRQ_EMIT)] = {i915_irq_emit, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I915_IRQ_WAIT)] = {i915_irq_wait, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I915_GETPARAM)] = {i915_getparam, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I915_SETPARAM)] = {i915_setparam, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_I915_ALLOC)] = {i915_mem_alloc, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I915_FREE)] = {i915_mem_free, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I915_INIT_HEAP)] = {i915_mem_init_heap, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_I915_CMDBUFFER)] = {i915_cmdbuffer, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I915_DESTROY_HEAP)] = { i915_mem_destroy_heap, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY },
|
||||
[DRM_IOCTL_NR(DRM_I915_SET_VBLANK_PIPE)] = { i915_vblank_pipe_set, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY },
|
||||
[DRM_IOCTL_NR(DRM_I915_GET_VBLANK_PIPE)] = { i915_vblank_pipe_get, DRM_AUTH },
|
||||
[DRM_IOCTL_NR(DRM_I915_VBLANK_SWAP)] = {i915_vblank_swap, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_I915_HWS_ADDR)] = {i915_set_status_page, DRM_AUTH},
|
||||
struct drm_ioctl_desc i915_ioctls[] = {
|
||||
DRM_IOCTL_DEF(DRM_I915_INIT, i915_dma_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_I915_FLUSH, i915_flush_ioctl, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I915_FLIP, i915_flip_bufs, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I915_BATCHBUFFER, i915_batchbuffer, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I915_IRQ_EMIT, i915_irq_emit, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I915_IRQ_WAIT, i915_irq_wait, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I915_GETPARAM, i915_getparam, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I915_SETPARAM, i915_setparam, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_I915_ALLOC, i915_mem_alloc, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I915_FREE, i915_mem_free, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I915_INIT_HEAP, i915_mem_init_heap, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_I915_CMDBUFFER, i915_cmdbuffer, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I915_DESTROY_HEAP, i915_mem_destroy_heap, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY ),
|
||||
DRM_IOCTL_DEF(DRM_I915_SET_VBLANK_PIPE, i915_vblank_pipe_set, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY ),
|
||||
DRM_IOCTL_DEF(DRM_I915_GET_VBLANK_PIPE, i915_vblank_pipe_get, DRM_AUTH ),
|
||||
DRM_IOCTL_DEF(DRM_I915_VBLANK_SWAP, i915_vblank_swap, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_I915_HWS_ADDR, i915_set_status_page, DRM_AUTH),
|
||||
};
|
||||
|
||||
int i915_max_ioctl = DRM_ARRAY_SIZE(i915_ioctls);
|
||||
|
|
|
@ -70,7 +70,7 @@ struct mem_block {
|
|||
struct mem_block *prev;
|
||||
int start;
|
||||
int size;
|
||||
DRMFILE filp; /* 0: free, -1: heap, other: real files */
|
||||
struct drm_file *file_priv; /* NULL: free, -1: heap, other: real files */
|
||||
};
|
||||
|
||||
typedef struct _drm_i915_vbl_swap {
|
||||
|
@ -116,21 +116,24 @@ typedef struct drm_i915_private {
|
|||
unsigned int swaps_pending;
|
||||
} drm_i915_private_t;
|
||||
|
||||
extern drm_ioctl_desc_t i915_ioctls[];
|
||||
extern struct drm_ioctl_desc i915_ioctls[];
|
||||
extern int i915_max_ioctl;
|
||||
|
||||
/* i915_dma.c */
|
||||
extern void i915_kernel_lost_context(struct drm_device * dev);
|
||||
extern int i915_driver_load(struct drm_device *, unsigned long flags);
|
||||
extern void i915_driver_lastclose(struct drm_device * dev);
|
||||
extern void i915_driver_preclose(struct drm_device * dev, DRMFILE filp);
|
||||
extern void i915_driver_preclose(struct drm_device *dev,
|
||||
struct drm_file *file_priv);
|
||||
extern int i915_driver_device_is_agp(struct drm_device * dev);
|
||||
extern long i915_compat_ioctl(struct file *filp, unsigned int cmd,
|
||||
unsigned long arg);
|
||||
|
||||
/* i915_irq.c */
|
||||
extern int i915_irq_emit(DRM_IOCTL_ARGS);
|
||||
extern int i915_irq_wait(DRM_IOCTL_ARGS);
|
||||
extern int i915_irq_emit(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv);
|
||||
extern int i915_irq_wait(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv);
|
||||
|
||||
extern int i915_driver_vblank_wait(struct drm_device *dev, unsigned int *sequence);
|
||||
extern int i915_driver_vblank_wait2(struct drm_device *dev, unsigned int *sequence);
|
||||
|
@ -138,18 +141,25 @@ extern irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS);
|
|||
extern void i915_driver_irq_preinstall(struct drm_device * dev);
|
||||
extern void i915_driver_irq_postinstall(struct drm_device * dev);
|
||||
extern void i915_driver_irq_uninstall(struct drm_device * dev);
|
||||
extern int i915_vblank_pipe_set(DRM_IOCTL_ARGS);
|
||||
extern int i915_vblank_pipe_get(DRM_IOCTL_ARGS);
|
||||
extern int i915_vblank_swap(DRM_IOCTL_ARGS);
|
||||
extern int i915_vblank_pipe_set(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv);
|
||||
extern int i915_vblank_pipe_get(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv);
|
||||
extern int i915_vblank_swap(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv);
|
||||
|
||||
/* i915_mem.c */
|
||||
extern int i915_mem_alloc(DRM_IOCTL_ARGS);
|
||||
extern int i915_mem_free(DRM_IOCTL_ARGS);
|
||||
extern int i915_mem_init_heap(DRM_IOCTL_ARGS);
|
||||
extern int i915_mem_destroy_heap(DRM_IOCTL_ARGS);
|
||||
extern int i915_mem_alloc(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv);
|
||||
extern int i915_mem_free(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv);
|
||||
extern int i915_mem_init_heap(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv);
|
||||
extern int i915_mem_destroy_heap(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv);
|
||||
extern void i915_mem_takedown(struct mem_block **heap);
|
||||
extern void i915_mem_release(struct drm_device * dev,
|
||||
DRMFILE filp, struct mem_block *heap);
|
||||
struct drm_file *file_priv, struct mem_block *heap);
|
||||
|
||||
#define I915_READ(reg) DRM_READ32(dev_priv->mmio_map, (reg))
|
||||
#define I915_WRITE(reg,val) DRM_WRITE32(dev_priv->mmio_map, (reg), (val))
|
||||
|
|
|
@ -311,7 +311,7 @@ static int i915_wait_irq(struct drm_device * dev, int irq_nr)
|
|||
DRM_WAIT_ON(ret, dev_priv->irq_queue, 3 * DRM_HZ,
|
||||
READ_BREADCRUMB(dev_priv) >= irq_nr);
|
||||
|
||||
if (ret == DRM_ERR(EBUSY)) {
|
||||
if (ret == -EBUSY) {
|
||||
DRM_ERROR("%s: EBUSY -- rec: %d emitted: %d\n",
|
||||
__FUNCTION__,
|
||||
READ_BREADCRUMB(dev_priv), (int)dev_priv->counter);
|
||||
|
@ -330,7 +330,7 @@ static int i915_driver_vblank_do_wait(struct drm_device *dev, unsigned int *sequ
|
|||
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
DRM_WAIT_ON(ret, dev->vbl_queue, 3 * DRM_HZ,
|
||||
|
@ -355,28 +355,25 @@ int i915_driver_vblank_wait2(struct drm_device *dev, unsigned int *sequence)
|
|||
|
||||
/* Needs the lock as it touches the ring.
|
||||
*/
|
||||
int i915_irq_emit(DRM_IOCTL_ARGS)
|
||||
int i915_irq_emit(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_i915_private_t *dev_priv = dev->dev_private;
|
||||
drm_i915_irq_emit_t emit;
|
||||
drm_i915_irq_emit_t *emit = data;
|
||||
int result;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(emit, (drm_i915_irq_emit_t __user *) data,
|
||||
sizeof(emit));
|
||||
|
||||
result = i915_emit_irq(dev);
|
||||
|
||||
if (DRM_COPY_TO_USER(emit.irq_seq, &result, sizeof(int))) {
|
||||
if (DRM_COPY_TO_USER(emit->irq_seq, &result, sizeof(int))) {
|
||||
DRM_ERROR("copy_to_user\n");
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
@ -384,21 +381,18 @@ int i915_irq_emit(DRM_IOCTL_ARGS)
|
|||
|
||||
/* Doesn't need the hardware lock.
|
||||
*/
|
||||
int i915_irq_wait(DRM_IOCTL_ARGS)
|
||||
int i915_irq_wait(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_i915_private_t *dev_priv = dev->dev_private;
|
||||
drm_i915_irq_wait_t irqwait;
|
||||
drm_i915_irq_wait_t *irqwait = data;
|
||||
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(irqwait, (drm_i915_irq_wait_t __user *) data,
|
||||
sizeof(irqwait));
|
||||
|
||||
return i915_wait_irq(dev, irqwait.irq_seq);
|
||||
return i915_wait_irq(dev, irqwait->irq_seq);
|
||||
}
|
||||
|
||||
static void i915_enable_interrupt (struct drm_device *dev)
|
||||
|
@ -417,64 +411,60 @@ static void i915_enable_interrupt (struct drm_device *dev)
|
|||
|
||||
/* Set the vblank monitor pipe
|
||||
*/
|
||||
int i915_vblank_pipe_set(DRM_IOCTL_ARGS)
|
||||
int i915_vblank_pipe_set(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_i915_private_t *dev_priv = dev->dev_private;
|
||||
drm_i915_vblank_pipe_t pipe;
|
||||
drm_i915_vblank_pipe_t *pipe = data;
|
||||
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(pipe, (drm_i915_vblank_pipe_t __user *) data,
|
||||
sizeof(pipe));
|
||||
|
||||
if (pipe.pipe & ~(DRM_I915_VBLANK_PIPE_A|DRM_I915_VBLANK_PIPE_B)) {
|
||||
if (pipe->pipe & ~(DRM_I915_VBLANK_PIPE_A|DRM_I915_VBLANK_PIPE_B)) {
|
||||
DRM_ERROR("%s called with invalid pipe 0x%x\n",
|
||||
__FUNCTION__, pipe.pipe);
|
||||
return DRM_ERR(EINVAL);
|
||||
__FUNCTION__, pipe->pipe);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
dev_priv->vblank_pipe = pipe.pipe;
|
||||
dev_priv->vblank_pipe = pipe->pipe;
|
||||
|
||||
i915_enable_interrupt (dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int i915_vblank_pipe_get(DRM_IOCTL_ARGS)
|
||||
int i915_vblank_pipe_get(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_i915_private_t *dev_priv = dev->dev_private;
|
||||
drm_i915_vblank_pipe_t pipe;
|
||||
drm_i915_vblank_pipe_t *pipe = data;
|
||||
u16 flag;
|
||||
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
flag = I915_READ(I915REG_INT_ENABLE_R);
|
||||
pipe.pipe = 0;
|
||||
pipe->pipe = 0;
|
||||
if (flag & VSYNC_PIPEA_FLAG)
|
||||
pipe.pipe |= DRM_I915_VBLANK_PIPE_A;
|
||||
pipe->pipe |= DRM_I915_VBLANK_PIPE_A;
|
||||
if (flag & VSYNC_PIPEB_FLAG)
|
||||
pipe.pipe |= DRM_I915_VBLANK_PIPE_B;
|
||||
DRM_COPY_TO_USER_IOCTL((drm_i915_vblank_pipe_t __user *) data, pipe,
|
||||
sizeof(pipe));
|
||||
pipe->pipe |= DRM_I915_VBLANK_PIPE_B;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Schedule buffer swap at given vertical blank.
|
||||
*/
|
||||
int i915_vblank_swap(DRM_IOCTL_ARGS)
|
||||
int i915_vblank_swap(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_i915_private_t *dev_priv = dev->dev_private;
|
||||
drm_i915_vblank_swap_t swap;
|
||||
drm_i915_vblank_swap_t *swap = data;
|
||||
drm_i915_vbl_swap_t *vbl_swap;
|
||||
unsigned int pipe, seqtype, curseq;
|
||||
unsigned long irqflags;
|
||||
|
@ -482,38 +472,35 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
|
|||
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("%s called with no initialization\n", __func__);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (dev_priv->sarea_priv->rotation) {
|
||||
DRM_DEBUG("Rotation not supported\n");
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(swap, (drm_i915_vblank_swap_t __user *) data,
|
||||
sizeof(swap));
|
||||
|
||||
if (swap.seqtype & ~(_DRM_VBLANK_RELATIVE | _DRM_VBLANK_ABSOLUTE |
|
||||
if (swap->seqtype & ~(_DRM_VBLANK_RELATIVE | _DRM_VBLANK_ABSOLUTE |
|
||||
_DRM_VBLANK_SECONDARY | _DRM_VBLANK_NEXTONMISS)) {
|
||||
DRM_ERROR("Invalid sequence type 0x%x\n", swap.seqtype);
|
||||
return DRM_ERR(EINVAL);
|
||||
DRM_ERROR("Invalid sequence type 0x%x\n", swap->seqtype);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
pipe = (swap.seqtype & _DRM_VBLANK_SECONDARY) ? 1 : 0;
|
||||
pipe = (swap->seqtype & _DRM_VBLANK_SECONDARY) ? 1 : 0;
|
||||
|
||||
seqtype = swap.seqtype & (_DRM_VBLANK_RELATIVE | _DRM_VBLANK_ABSOLUTE);
|
||||
seqtype = swap->seqtype & (_DRM_VBLANK_RELATIVE | _DRM_VBLANK_ABSOLUTE);
|
||||
|
||||
if (!(dev_priv->vblank_pipe & (1 << pipe))) {
|
||||
DRM_ERROR("Invalid pipe %d\n", pipe);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
spin_lock_irqsave(&dev->drw_lock, irqflags);
|
||||
|
||||
if (!drm_get_drawable_info(dev, swap.drawable)) {
|
||||
if (!drm_get_drawable_info(dev, swap->drawable)) {
|
||||
spin_unlock_irqrestore(&dev->drw_lock, irqflags);
|
||||
DRM_DEBUG("Invalid drawable ID %d\n", swap.drawable);
|
||||
return DRM_ERR(EINVAL);
|
||||
DRM_DEBUG("Invalid drawable ID %d\n", swap->drawable);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
spin_unlock_irqrestore(&dev->drw_lock, irqflags);
|
||||
|
@ -521,14 +508,14 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
|
|||
curseq = atomic_read(pipe ? &dev->vbl_received2 : &dev->vbl_received);
|
||||
|
||||
if (seqtype == _DRM_VBLANK_RELATIVE)
|
||||
swap.sequence += curseq;
|
||||
swap->sequence += curseq;
|
||||
|
||||
if ((curseq - swap.sequence) <= (1<<23)) {
|
||||
if (swap.seqtype & _DRM_VBLANK_NEXTONMISS) {
|
||||
swap.sequence = curseq + 1;
|
||||
if ((curseq - swap->sequence) <= (1<<23)) {
|
||||
if (swap->seqtype & _DRM_VBLANK_NEXTONMISS) {
|
||||
swap->sequence = curseq + 1;
|
||||
} else {
|
||||
DRM_DEBUG("Missed target sequence\n");
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -537,9 +524,9 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
|
|||
list_for_each(list, &dev_priv->vbl_swaps.head) {
|
||||
vbl_swap = list_entry(list, drm_i915_vbl_swap_t, head);
|
||||
|
||||
if (vbl_swap->drw_id == swap.drawable &&
|
||||
if (vbl_swap->drw_id == swap->drawable &&
|
||||
vbl_swap->pipe == pipe &&
|
||||
vbl_swap->sequence == swap.sequence) {
|
||||
vbl_swap->sequence == swap->sequence) {
|
||||
spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
|
||||
DRM_DEBUG("Already scheduled\n");
|
||||
return 0;
|
||||
|
@ -550,21 +537,21 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
|
|||
|
||||
if (dev_priv->swaps_pending >= 100) {
|
||||
DRM_DEBUG("Too many swaps queued\n");
|
||||
return DRM_ERR(EBUSY);
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
vbl_swap = drm_calloc(1, sizeof(vbl_swap), DRM_MEM_DRIVER);
|
||||
vbl_swap = drm_calloc(1, sizeof(*vbl_swap), DRM_MEM_DRIVER);
|
||||
|
||||
if (!vbl_swap) {
|
||||
DRM_ERROR("Failed to allocate memory to queue swap\n");
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
DRM_DEBUG("\n");
|
||||
|
||||
vbl_swap->drw_id = swap.drawable;
|
||||
vbl_swap->drw_id = swap->drawable;
|
||||
vbl_swap->pipe = pipe;
|
||||
vbl_swap->sequence = swap.sequence;
|
||||
vbl_swap->sequence = swap->sequence;
|
||||
|
||||
spin_lock_irqsave(&dev_priv->swaps_lock, irqflags);
|
||||
|
||||
|
@ -573,9 +560,6 @@ int i915_vblank_swap(DRM_IOCTL_ARGS)
|
|||
|
||||
spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
|
||||
|
||||
DRM_COPY_TO_USER_IOCTL((drm_i915_vblank_swap_t __user *) data, swap,
|
||||
sizeof(swap));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
@ -89,7 +89,7 @@ static void mark_block(struct drm_device * dev, struct mem_block *p, int in_use)
|
|||
*/
|
||||
|
||||
static struct mem_block *split_block(struct mem_block *p, int start, int size,
|
||||
DRMFILE filp)
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
/* Maybe cut off the start of an existing block */
|
||||
if (start > p->start) {
|
||||
|
@ -99,7 +99,7 @@ static struct mem_block *split_block(struct mem_block *p, int start, int size,
|
|||
goto out;
|
||||
newblock->start = start;
|
||||
newblock->size = p->size - (start - p->start);
|
||||
newblock->filp = NULL;
|
||||
newblock->file_priv = NULL;
|
||||
newblock->next = p->next;
|
||||
newblock->prev = p;
|
||||
p->next->prev = newblock;
|
||||
|
@ -116,7 +116,7 @@ static struct mem_block *split_block(struct mem_block *p, int start, int size,
|
|||
goto out;
|
||||
newblock->start = start + size;
|
||||
newblock->size = p->size - size;
|
||||
newblock->filp = NULL;
|
||||
newblock->file_priv = NULL;
|
||||
newblock->next = p->next;
|
||||
newblock->prev = p;
|
||||
p->next->prev = newblock;
|
||||
|
@ -126,20 +126,20 @@ static struct mem_block *split_block(struct mem_block *p, int start, int size,
|
|||
|
||||
out:
|
||||
/* Our block is in the middle */
|
||||
p->filp = filp;
|
||||
p->file_priv = file_priv;
|
||||
return p;
|
||||
}
|
||||
|
||||
static struct mem_block *alloc_block(struct mem_block *heap, int size,
|
||||
int align2, DRMFILE filp)
|
||||
int align2, struct drm_file *file_priv)
|
||||
{
|
||||
struct mem_block *p;
|
||||
int mask = (1 << align2) - 1;
|
||||
|
||||
for (p = heap->next; p != heap; p = p->next) {
|
||||
int start = (p->start + mask) & ~mask;
|
||||
if (p->filp == NULL && start + size <= p->start + p->size)
|
||||
return split_block(p, start, size, filp);
|
||||
if (p->file_priv == NULL && start + size <= p->start + p->size)
|
||||
return split_block(p, start, size, file_priv);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
|
@ -158,12 +158,12 @@ static struct mem_block *find_block(struct mem_block *heap, int start)
|
|||
|
||||
static void free_block(struct mem_block *p)
|
||||
{
|
||||
p->filp = NULL;
|
||||
p->file_priv = NULL;
|
||||
|
||||
/* Assumes a single contiguous range. Needs a special filp in
|
||||
/* Assumes a single contiguous range. Needs a special file_priv in
|
||||
* 'heap' to stop it being subsumed.
|
||||
*/
|
||||
if (p->next->filp == NULL) {
|
||||
if (p->next->file_priv == NULL) {
|
||||
struct mem_block *q = p->next;
|
||||
p->size += q->size;
|
||||
p->next = q->next;
|
||||
|
@ -171,7 +171,7 @@ static void free_block(struct mem_block *p)
|
|||
drm_free(q, sizeof(*q), DRM_MEM_BUFLISTS);
|
||||
}
|
||||
|
||||
if (p->prev->filp == NULL) {
|
||||
if (p->prev->file_priv == NULL) {
|
||||
struct mem_block *q = p->prev;
|
||||
q->size += p->size;
|
||||
q->next = p->next;
|
||||
|
@ -197,18 +197,19 @@ static int init_heap(struct mem_block **heap, int start, int size)
|
|||
|
||||
blocks->start = start;
|
||||
blocks->size = size;
|
||||
blocks->filp = NULL;
|
||||
blocks->file_priv = NULL;
|
||||
blocks->next = blocks->prev = *heap;
|
||||
|
||||
memset(*heap, 0, sizeof(**heap));
|
||||
(*heap)->filp = (DRMFILE) - 1;
|
||||
(*heap)->file_priv = (struct drm_file *) - 1;
|
||||
(*heap)->next = (*heap)->prev = blocks;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Free all blocks associated with the releasing file.
|
||||
*/
|
||||
void i915_mem_release(struct drm_device * dev, DRMFILE filp, struct mem_block *heap)
|
||||
void i915_mem_release(struct drm_device * dev, struct drm_file *file_priv,
|
||||
struct mem_block *heap)
|
||||
{
|
||||
struct mem_block *p;
|
||||
|
||||
|
@ -216,17 +217,17 @@ void i915_mem_release(struct drm_device * dev, DRMFILE filp, struct mem_block *h
|
|||
return;
|
||||
|
||||
for (p = heap->next; p != heap; p = p->next) {
|
||||
if (p->filp == filp) {
|
||||
p->filp = NULL;
|
||||
if (p->file_priv == file_priv) {
|
||||
p->file_priv = NULL;
|
||||
mark_block(dev, p, 0);
|
||||
}
|
||||
}
|
||||
|
||||
/* Assumes a single contiguous range. Needs a special filp in
|
||||
/* Assumes a single contiguous range. Needs a special file_priv in
|
||||
* 'heap' to stop it being subsumed.
|
||||
*/
|
||||
for (p = heap->next; p != heap; p = p->next) {
|
||||
while (p->filp == NULL && p->next->filp == NULL) {
|
||||
while (p->file_priv == NULL && p->next->file_priv == NULL) {
|
||||
struct mem_block *q = p->next;
|
||||
p->size += q->size;
|
||||
p->next = q->next;
|
||||
|
@ -267,129 +268,117 @@ static struct mem_block **get_heap(drm_i915_private_t * dev_priv, int region)
|
|||
|
||||
/* IOCTL HANDLERS */
|
||||
|
||||
int i915_mem_alloc(DRM_IOCTL_ARGS)
|
||||
int i915_mem_alloc(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_i915_private_t *dev_priv = dev->dev_private;
|
||||
drm_i915_mem_alloc_t alloc;
|
||||
drm_i915_mem_alloc_t *alloc = data;
|
||||
struct mem_block *block, **heap;
|
||||
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(alloc, (drm_i915_mem_alloc_t __user *) data,
|
||||
sizeof(alloc));
|
||||
|
||||
heap = get_heap(dev_priv, alloc.region);
|
||||
heap = get_heap(dev_priv, alloc->region);
|
||||
if (!heap || !*heap)
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
|
||||
/* Make things easier on ourselves: all allocations at least
|
||||
* 4k aligned.
|
||||
*/
|
||||
if (alloc.alignment < 12)
|
||||
alloc.alignment = 12;
|
||||
if (alloc->alignment < 12)
|
||||
alloc->alignment = 12;
|
||||
|
||||
block = alloc_block(*heap, alloc.size, alloc.alignment, filp);
|
||||
block = alloc_block(*heap, alloc->size, alloc->alignment, file_priv);
|
||||
|
||||
if (!block)
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
|
||||
mark_block(dev, block, 1);
|
||||
|
||||
if (DRM_COPY_TO_USER(alloc.region_offset, &block->start, sizeof(int))) {
|
||||
if (DRM_COPY_TO_USER(alloc->region_offset, &block->start,
|
||||
sizeof(int))) {
|
||||
DRM_ERROR("copy_to_user\n");
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int i915_mem_free(DRM_IOCTL_ARGS)
|
||||
int i915_mem_free(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_i915_private_t *dev_priv = dev->dev_private;
|
||||
drm_i915_mem_free_t memfree;
|
||||
drm_i915_mem_free_t *memfree = data;
|
||||
struct mem_block *block, **heap;
|
||||
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(memfree, (drm_i915_mem_free_t __user *) data,
|
||||
sizeof(memfree));
|
||||
|
||||
heap = get_heap(dev_priv, memfree.region);
|
||||
heap = get_heap(dev_priv, memfree->region);
|
||||
if (!heap || !*heap)
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
|
||||
block = find_block(*heap, memfree.region_offset);
|
||||
block = find_block(*heap, memfree->region_offset);
|
||||
if (!block)
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
|
||||
if (block->filp != filp)
|
||||
return DRM_ERR(EPERM);
|
||||
if (block->file_priv != file_priv)
|
||||
return -EPERM;
|
||||
|
||||
mark_block(dev, block, 0);
|
||||
free_block(block);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int i915_mem_init_heap(DRM_IOCTL_ARGS)
|
||||
int i915_mem_init_heap(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_i915_private_t *dev_priv = dev->dev_private;
|
||||
drm_i915_mem_init_heap_t initheap;
|
||||
drm_i915_mem_init_heap_t *initheap = data;
|
||||
struct mem_block **heap;
|
||||
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(initheap,
|
||||
(drm_i915_mem_init_heap_t __user *) data,
|
||||
sizeof(initheap));
|
||||
|
||||
heap = get_heap(dev_priv, initheap.region);
|
||||
heap = get_heap(dev_priv, initheap->region);
|
||||
if (!heap)
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
|
||||
if (*heap) {
|
||||
DRM_ERROR("heap already initialized?");
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
return init_heap(heap, initheap.start, initheap.size);
|
||||
return init_heap(heap, initheap->start, initheap->size);
|
||||
}
|
||||
|
||||
int i915_mem_destroy_heap( DRM_IOCTL_ARGS )
|
||||
int i915_mem_destroy_heap( struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv )
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_i915_private_t *dev_priv = dev->dev_private;
|
||||
drm_i915_mem_destroy_heap_t destroyheap;
|
||||
drm_i915_mem_destroy_heap_t *destroyheap = data;
|
||||
struct mem_block **heap;
|
||||
|
||||
if ( !dev_priv ) {
|
||||
DRM_ERROR( "%s called with no initialization\n", __FUNCTION__ );
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL( destroyheap, (drm_i915_mem_destroy_heap_t *)data,
|
||||
sizeof(destroyheap) );
|
||||
|
||||
heap = get_heap( dev_priv, destroyheap.region );
|
||||
heap = get_heap( dev_priv, destroyheap->region );
|
||||
if (!heap) {
|
||||
DRM_ERROR("get_heap failed");
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
if (!*heap) {
|
||||
DRM_ERROR("heap not initialized?");
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
i915_mem_takedown( heap );
|
||||
|
|
|
@ -71,7 +71,7 @@ int mga_do_wait_for_idle(drm_mga_private_t * dev_priv)
|
|||
DRM_ERROR("failed!\n");
|
||||
DRM_INFO(" status=0x%08x\n", status);
|
||||
#endif
|
||||
return DRM_ERR(EBUSY);
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
static int mga_do_dma_reset(drm_mga_private_t * dev_priv)
|
||||
|
@ -256,7 +256,7 @@ static int mga_freelist_init(struct drm_device * dev, drm_mga_private_t * dev_pr
|
|||
|
||||
dev_priv->head = drm_alloc(sizeof(drm_mga_freelist_t), DRM_MEM_DRIVER);
|
||||
if (dev_priv->head == NULL)
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
|
||||
memset(dev_priv->head, 0, sizeof(drm_mga_freelist_t));
|
||||
SET_AGE(&dev_priv->head->age, MGA_BUFFER_USED, 0);
|
||||
|
@ -267,7 +267,7 @@ static int mga_freelist_init(struct drm_device * dev, drm_mga_private_t * dev_pr
|
|||
|
||||
entry = drm_alloc(sizeof(drm_mga_freelist_t), DRM_MEM_DRIVER);
|
||||
if (entry == NULL)
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
|
||||
memset(entry, 0, sizeof(drm_mga_freelist_t));
|
||||
|
||||
|
@ -399,7 +399,7 @@ int mga_driver_load(struct drm_device * dev, unsigned long flags)
|
|||
|
||||
dev_priv = drm_alloc(sizeof(drm_mga_private_t), DRM_MEM_DRIVER);
|
||||
if (!dev_priv)
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
|
||||
dev->dev_private = (void *)dev_priv;
|
||||
memset(dev_priv, 0, sizeof(drm_mga_private_t));
|
||||
|
@ -578,7 +578,7 @@ static int mga_do_agp_dma_bootstrap(struct drm_device * dev,
|
|||
DRM_ERROR("failed to ioremap agp regions! (%p, %p, %p)\n",
|
||||
dev_priv->warp->handle, dev_priv->primary->handle,
|
||||
dev->agp_buffer_map->handle);
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
dev_priv->dma_access = MGA_PAGPXFER;
|
||||
|
@ -622,7 +622,7 @@ static int mga_do_pci_dma_bootstrap(struct drm_device * dev,
|
|||
|
||||
if (dev->dma == NULL) {
|
||||
DRM_ERROR("dev->dma is NULL\n");
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
/* Make drm_addbufs happy by not trying to create a mapping for less
|
||||
|
@ -656,7 +656,7 @@ static int mga_do_pci_dma_bootstrap(struct drm_device * dev,
|
|||
|
||||
if (err != 0) {
|
||||
DRM_ERROR("Unable to allocate primary DMA region: %d\n", err);
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
if (dev_priv->primary->size != dma_bs->primary_size) {
|
||||
|
@ -759,36 +759,30 @@ static int mga_do_dma_bootstrap(struct drm_device * dev,
|
|||
return err;
|
||||
}
|
||||
|
||||
int mga_dma_bootstrap(DRM_IOCTL_ARGS)
|
||||
int mga_dma_bootstrap(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_mga_dma_bootstrap_t bootstrap;
|
||||
drm_mga_dma_bootstrap_t *bootstrap = data;
|
||||
int err;
|
||||
static const int modes[] = { 0, 1, 2, 2, 4, 4, 4, 4 };
|
||||
const drm_mga_private_t *const dev_priv =
|
||||
(drm_mga_private_t *) dev->dev_private;
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(bootstrap,
|
||||
(drm_mga_dma_bootstrap_t __user *) data,
|
||||
sizeof(bootstrap));
|
||||
|
||||
err = mga_do_dma_bootstrap(dev, &bootstrap);
|
||||
err = mga_do_dma_bootstrap(dev, bootstrap);
|
||||
if (err) {
|
||||
mga_do_cleanup_dma(dev, FULL_CLEANUP);
|
||||
return err;
|
||||
}
|
||||
|
||||
if (dev_priv->agp_textures != NULL) {
|
||||
bootstrap.texture_handle = dev_priv->agp_textures->offset;
|
||||
bootstrap.texture_size = dev_priv->agp_textures->size;
|
||||
bootstrap->texture_handle = dev_priv->agp_textures->offset;
|
||||
bootstrap->texture_size = dev_priv->agp_textures->size;
|
||||
} else {
|
||||
bootstrap.texture_handle = 0;
|
||||
bootstrap.texture_size = 0;
|
||||
bootstrap->texture_handle = 0;
|
||||
bootstrap->texture_size = 0;
|
||||
}
|
||||
|
||||
bootstrap.agp_mode = modes[bootstrap.agp_mode & 0x07];
|
||||
DRM_COPY_TO_USER_IOCTL((drm_mga_dma_bootstrap_t __user *)data,
|
||||
bootstrap, sizeof(bootstrap));
|
||||
bootstrap->agp_mode = modes[bootstrap->agp_mode & 0x07];
|
||||
|
||||
return err;
|
||||
}
|
||||
|
@ -826,7 +820,7 @@ static int mga_do_init_dma(struct drm_device * dev, drm_mga_init_t * init)
|
|||
dev_priv->sarea = drm_getsarea(dev);
|
||||
if (!dev_priv->sarea) {
|
||||
DRM_ERROR("failed to find sarea!\n");
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (!dev_priv->used_new_dma_init) {
|
||||
|
@ -837,29 +831,29 @@ static int mga_do_init_dma(struct drm_device * dev, drm_mga_init_t * init)
|
|||
dev_priv->status = drm_core_findmap(dev, init->status_offset);
|
||||
if (!dev_priv->status) {
|
||||
DRM_ERROR("failed to find status page!\n");
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
dev_priv->mmio = drm_core_findmap(dev, init->mmio_offset);
|
||||
if (!dev_priv->mmio) {
|
||||
DRM_ERROR("failed to find mmio region!\n");
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
dev_priv->warp = drm_core_findmap(dev, init->warp_offset);
|
||||
if (!dev_priv->warp) {
|
||||
DRM_ERROR("failed to find warp microcode region!\n");
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
dev_priv->primary = drm_core_findmap(dev, init->primary_offset);
|
||||
if (!dev_priv->primary) {
|
||||
DRM_ERROR("failed to find primary dma region!\n");
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
dev->agp_buffer_token = init->buffers_offset;
|
||||
dev->agp_buffer_map =
|
||||
drm_core_findmap(dev, init->buffers_offset);
|
||||
if (!dev->agp_buffer_map) {
|
||||
DRM_ERROR("failed to find dma buffer region!\n");
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
drm_core_ioremap(dev_priv->warp, dev);
|
||||
|
@ -877,7 +871,7 @@ static int mga_do_init_dma(struct drm_device * dev, drm_mga_init_t * init)
|
|||
((dev->agp_buffer_map == NULL) ||
|
||||
(dev->agp_buffer_map->handle == NULL)))) {
|
||||
DRM_ERROR("failed to ioremap agp regions!\n");
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
ret = mga_warp_install_microcode(dev_priv);
|
||||
|
@ -927,7 +921,7 @@ static int mga_do_init_dma(struct drm_device * dev, drm_mga_init_t * init)
|
|||
|
||||
if (mga_freelist_init(dev, dev_priv) < 0) {
|
||||
DRM_ERROR("could not initialize freelist\n");
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
@ -1007,20 +1001,17 @@ static int mga_do_cleanup_dma(struct drm_device *dev, int full_cleanup)
|
|||
return 0;
|
||||
}
|
||||
|
||||
int mga_dma_init(DRM_IOCTL_ARGS)
|
||||
int mga_dma_init(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_mga_init_t init;
|
||||
drm_mga_init_t *init = data;
|
||||
int err;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(init, (drm_mga_init_t __user *) data,
|
||||
sizeof(init));
|
||||
|
||||
switch (init.func) {
|
||||
switch (init->func) {
|
||||
case MGA_INIT_DMA:
|
||||
err = mga_do_init_dma(dev, &init);
|
||||
err = mga_do_init_dma(dev, init);
|
||||
if (err) {
|
||||
(void)mga_do_cleanup_dma(dev, FULL_CLEANUP);
|
||||
}
|
||||
|
@ -1029,36 +1020,33 @@ int mga_dma_init(DRM_IOCTL_ARGS)
|
|||
return mga_do_cleanup_dma(dev, FULL_CLEANUP);
|
||||
}
|
||||
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* ================================================================
|
||||
* Primary DMA stream management
|
||||
*/
|
||||
|
||||
int mga_dma_flush(DRM_IOCTL_ARGS)
|
||||
int mga_dma_flush(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_mga_private_t *dev_priv = (drm_mga_private_t *) dev->dev_private;
|
||||
struct drm_lock lock;
|
||||
struct drm_lock *lock = data;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(lock, (struct drm_lock __user *) data,
|
||||
sizeof(lock));
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
DRM_DEBUG("%s%s%s\n",
|
||||
(lock.flags & _DRM_LOCK_FLUSH) ? "flush, " : "",
|
||||
(lock.flags & _DRM_LOCK_FLUSH_ALL) ? "flush all, " : "",
|
||||
(lock.flags & _DRM_LOCK_QUIESCENT) ? "idle, " : "");
|
||||
(lock->flags & _DRM_LOCK_FLUSH) ? "flush, " : "",
|
||||
(lock->flags & _DRM_LOCK_FLUSH_ALL) ? "flush all, " : "",
|
||||
(lock->flags & _DRM_LOCK_QUIESCENT) ? "idle, " : "");
|
||||
|
||||
WRAP_WAIT_WITH_RETURN(dev_priv);
|
||||
|
||||
if (lock.flags & (_DRM_LOCK_FLUSH | _DRM_LOCK_FLUSH_ALL)) {
|
||||
if (lock->flags & (_DRM_LOCK_FLUSH | _DRM_LOCK_FLUSH_ALL)) {
|
||||
mga_do_dma_flush(dev_priv);
|
||||
}
|
||||
|
||||
if (lock.flags & _DRM_LOCK_QUIESCENT) {
|
||||
if (lock->flags & _DRM_LOCK_QUIESCENT) {
|
||||
#if MGA_DMA_DEBUG
|
||||
int ret = mga_do_wait_for_idle(dev_priv);
|
||||
if (ret < 0)
|
||||
|
@ -1072,12 +1060,12 @@ int mga_dma_flush(DRM_IOCTL_ARGS)
|
|||
}
|
||||
}
|
||||
|
||||
int mga_dma_reset(DRM_IOCTL_ARGS)
|
||||
int mga_dma_reset(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_mga_private_t *dev_priv = (drm_mga_private_t *) dev->dev_private;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
return mga_do_dma_reset(dev_priv);
|
||||
}
|
||||
|
@ -1086,7 +1074,8 @@ int mga_dma_reset(DRM_IOCTL_ARGS)
|
|||
* DMA buffer management
|
||||
*/
|
||||
|
||||
static int mga_dma_get_buffers(DRMFILE filp, struct drm_device * dev, struct drm_dma * d)
|
||||
static int mga_dma_get_buffers(struct drm_device * dev,
|
||||
struct drm_file *file_priv, struct drm_dma * d)
|
||||
{
|
||||
struct drm_buf *buf;
|
||||
int i;
|
||||
|
@ -1094,61 +1083,56 @@ static int mga_dma_get_buffers(DRMFILE filp, struct drm_device * dev, struct drm
|
|||
for (i = d->granted_count; i < d->request_count; i++) {
|
||||
buf = mga_freelist_get(dev);
|
||||
if (!buf)
|
||||
return DRM_ERR(EAGAIN);
|
||||
return -EAGAIN;
|
||||
|
||||
buf->filp = filp;
|
||||
buf->file_priv = file_priv;
|
||||
|
||||
if (DRM_COPY_TO_USER(&d->request_indices[i],
|
||||
&buf->idx, sizeof(buf->idx)))
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
if (DRM_COPY_TO_USER(&d->request_sizes[i],
|
||||
&buf->total, sizeof(buf->total)))
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
|
||||
d->granted_count++;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mga_dma_buffers(DRM_IOCTL_ARGS)
|
||||
int mga_dma_buffers(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
struct drm_device_dma *dma = dev->dma;
|
||||
drm_mga_private_t *dev_priv = (drm_mga_private_t *) dev->dev_private;
|
||||
struct drm_dma __user *argp = (void __user *)data;
|
||||
struct drm_dma d;
|
||||
struct drm_dma *d = data;
|
||||
int ret = 0;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(d, argp, sizeof(d));
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
/* Please don't send us buffers.
|
||||
*/
|
||||
if (d.send_count != 0) {
|
||||
if (d->send_count != 0) {
|
||||
DRM_ERROR("Process %d trying to send %d buffers via drmDMA\n",
|
||||
DRM_CURRENTPID, d.send_count);
|
||||
return DRM_ERR(EINVAL);
|
||||
DRM_CURRENTPID, d->send_count);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* We'll send you buffers.
|
||||
*/
|
||||
if (d.request_count < 0 || d.request_count > dma->buf_count) {
|
||||
if (d->request_count < 0 || d->request_count > dma->buf_count) {
|
||||
DRM_ERROR("Process %d trying to get %d buffers (of %d max)\n",
|
||||
DRM_CURRENTPID, d.request_count, dma->buf_count);
|
||||
return DRM_ERR(EINVAL);
|
||||
DRM_CURRENTPID, d->request_count, dma->buf_count);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
WRAP_TEST_WITH_RETURN(dev_priv);
|
||||
|
||||
d.granted_count = 0;
|
||||
d->granted_count = 0;
|
||||
|
||||
if (d.request_count) {
|
||||
ret = mga_dma_get_buffers(filp, dev, &d);
|
||||
if (d->request_count) {
|
||||
ret = mga_dma_get_buffers(dev, file_priv, d);
|
||||
}
|
||||
|
||||
DRM_COPY_TO_USER_IOCTL(argp, d, sizeof(d));
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
|
@ -148,15 +148,20 @@ typedef struct drm_mga_private {
|
|||
unsigned int agp_size;
|
||||
} drm_mga_private_t;
|
||||
|
||||
extern drm_ioctl_desc_t mga_ioctls[];
|
||||
extern struct drm_ioctl_desc mga_ioctls[];
|
||||
extern int mga_max_ioctl;
|
||||
|
||||
/* mga_dma.c */
|
||||
extern int mga_dma_bootstrap(DRM_IOCTL_ARGS);
|
||||
extern int mga_dma_init(DRM_IOCTL_ARGS);
|
||||
extern int mga_dma_flush(DRM_IOCTL_ARGS);
|
||||
extern int mga_dma_reset(DRM_IOCTL_ARGS);
|
||||
extern int mga_dma_buffers(DRM_IOCTL_ARGS);
|
||||
extern int mga_dma_bootstrap(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv);
|
||||
extern int mga_dma_init(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv);
|
||||
extern int mga_dma_flush(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv);
|
||||
extern int mga_dma_reset(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv);
|
||||
extern int mga_dma_buffers(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv);
|
||||
extern int mga_driver_load(struct drm_device *dev, unsigned long flags);
|
||||
extern int mga_driver_unload(struct drm_device * dev);
|
||||
extern void mga_driver_lastclose(struct drm_device * dev);
|
||||
|
@ -245,7 +250,7 @@ do { \
|
|||
dev_priv->prim.high_mark ) { \
|
||||
if ( MGA_DMA_DEBUG ) \
|
||||
DRM_INFO( "%s: wrap...\n", __FUNCTION__ ); \
|
||||
return DRM_ERR(EBUSY); \
|
||||
return -EBUSY; \
|
||||
} \
|
||||
} \
|
||||
} while (0)
|
||||
|
@ -256,7 +261,7 @@ do { \
|
|||
if ( mga_do_wait_for_idle( dev_priv ) < 0 ) { \
|
||||
if ( MGA_DMA_DEBUG ) \
|
||||
DRM_INFO( "%s: wrap...\n", __FUNCTION__ ); \
|
||||
return DRM_ERR(EBUSY); \
|
||||
return -EBUSY; \
|
||||
} \
|
||||
mga_do_dma_wrap_end( dev_priv ); \
|
||||
} \
|
||||
|
|
|
@ -392,7 +392,7 @@ static int mga_verify_context(drm_mga_private_t * dev_priv)
|
|||
ctx->dstorg, dev_priv->front_offset,
|
||||
dev_priv->back_offset);
|
||||
ctx->dstorg = 0;
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
@ -411,7 +411,7 @@ static int mga_verify_tex(drm_mga_private_t * dev_priv, int unit)
|
|||
if (org == (MGA_TEXORGMAP_SYSMEM | MGA_TEXORGACC_PCI)) {
|
||||
DRM_ERROR("*** bad TEXORG: 0x%x, unit %d\n", tex->texorg, unit);
|
||||
tex->texorg = 0;
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
@ -453,13 +453,13 @@ static int mga_verify_iload(drm_mga_private_t * dev_priv,
|
|||
dstorg + length > (dev_priv->texture_offset +
|
||||
dev_priv->texture_size)) {
|
||||
DRM_ERROR("*** bad iload DSTORG: 0x%x\n", dstorg);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (length & MGA_ILOAD_MASK) {
|
||||
DRM_ERROR("*** bad iload length: 0x%x\n",
|
||||
length & MGA_ILOAD_MASK);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
@ -471,7 +471,7 @@ static int mga_verify_blit(drm_mga_private_t * dev_priv,
|
|||
if ((srcorg & 0x3) == (MGA_SRCACC_PCI | MGA_SRCMAP_SYSMEM) ||
|
||||
(dstorg & 0x3) == (MGA_SRCACC_PCI | MGA_SRCMAP_SYSMEM)) {
|
||||
DRM_ERROR("*** bad blit: src=0x%x dst=0x%x\n", srcorg, dstorg);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
@ -828,24 +828,20 @@ static void mga_dma_dispatch_blit(struct drm_device * dev, drm_mga_blit_t * blit
|
|||
*
|
||||
*/
|
||||
|
||||
static int mga_dma_clear(DRM_IOCTL_ARGS)
|
||||
static int mga_dma_clear(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_mga_private_t *dev_priv = dev->dev_private;
|
||||
drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
|
||||
drm_mga_clear_t clear;
|
||||
drm_mga_clear_t *clear = data;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(clear, (drm_mga_clear_t __user *) data,
|
||||
sizeof(clear));
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
if (sarea_priv->nbox > MGA_NR_SAREA_CLIPRECTS)
|
||||
sarea_priv->nbox = MGA_NR_SAREA_CLIPRECTS;
|
||||
|
||||
WRAP_TEST_WITH_RETURN(dev_priv);
|
||||
|
||||
mga_dma_dispatch_clear(dev, &clear);
|
||||
mga_dma_dispatch_clear(dev, clear);
|
||||
|
||||
/* Make sure we restore the 3D state next time.
|
||||
*/
|
||||
|
@ -854,13 +850,12 @@ static int mga_dma_clear(DRM_IOCTL_ARGS)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int mga_dma_swap(DRM_IOCTL_ARGS)
|
||||
static int mga_dma_swap(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_mga_private_t *dev_priv = dev->dev_private;
|
||||
drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
if (sarea_priv->nbox > MGA_NR_SAREA_CLIPRECTS)
|
||||
sarea_priv->nbox = MGA_NR_SAREA_CLIPRECTS;
|
||||
|
@ -876,37 +871,32 @@ static int mga_dma_swap(DRM_IOCTL_ARGS)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int mga_dma_vertex(DRM_IOCTL_ARGS)
|
||||
static int mga_dma_vertex(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_mga_private_t *dev_priv = dev->dev_private;
|
||||
struct drm_device_dma *dma = dev->dma;
|
||||
struct drm_buf *buf;
|
||||
drm_mga_buf_priv_t *buf_priv;
|
||||
drm_mga_vertex_t vertex;
|
||||
drm_mga_vertex_t *vertex = data;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(vertex,
|
||||
(drm_mga_vertex_t __user *) data,
|
||||
sizeof(vertex));
|
||||
|
||||
if (vertex.idx < 0 || vertex.idx > dma->buf_count)
|
||||
return DRM_ERR(EINVAL);
|
||||
buf = dma->buflist[vertex.idx];
|
||||
if (vertex->idx < 0 || vertex->idx > dma->buf_count)
|
||||
return -EINVAL;
|
||||
buf = dma->buflist[vertex->idx];
|
||||
buf_priv = buf->dev_private;
|
||||
|
||||
buf->used = vertex.used;
|
||||
buf_priv->discard = vertex.discard;
|
||||
buf->used = vertex->used;
|
||||
buf_priv->discard = vertex->discard;
|
||||
|
||||
if (!mga_verify_state(dev_priv)) {
|
||||
if (vertex.discard) {
|
||||
if (vertex->discard) {
|
||||
if (buf_priv->dispatched == 1)
|
||||
AGE_BUFFER(buf_priv);
|
||||
buf_priv->dispatched = 0;
|
||||
mga_freelist_put(dev, buf);
|
||||
}
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
WRAP_TEST_WITH_RETURN(dev_priv);
|
||||
|
@ -916,82 +906,73 @@ static int mga_dma_vertex(DRM_IOCTL_ARGS)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int mga_dma_indices(DRM_IOCTL_ARGS)
|
||||
static int mga_dma_indices(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_mga_private_t *dev_priv = dev->dev_private;
|
||||
struct drm_device_dma *dma = dev->dma;
|
||||
struct drm_buf *buf;
|
||||
drm_mga_buf_priv_t *buf_priv;
|
||||
drm_mga_indices_t indices;
|
||||
drm_mga_indices_t *indices = data;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(indices,
|
||||
(drm_mga_indices_t __user *) data,
|
||||
sizeof(indices));
|
||||
if (indices->idx < 0 || indices->idx > dma->buf_count)
|
||||
return -EINVAL;
|
||||
|
||||
if (indices.idx < 0 || indices.idx > dma->buf_count)
|
||||
return DRM_ERR(EINVAL);
|
||||
|
||||
buf = dma->buflist[indices.idx];
|
||||
buf = dma->buflist[indices->idx];
|
||||
buf_priv = buf->dev_private;
|
||||
|
||||
buf_priv->discard = indices.discard;
|
||||
buf_priv->discard = indices->discard;
|
||||
|
||||
if (!mga_verify_state(dev_priv)) {
|
||||
if (indices.discard) {
|
||||
if (indices->discard) {
|
||||
if (buf_priv->dispatched == 1)
|
||||
AGE_BUFFER(buf_priv);
|
||||
buf_priv->dispatched = 0;
|
||||
mga_freelist_put(dev, buf);
|
||||
}
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
WRAP_TEST_WITH_RETURN(dev_priv);
|
||||
|
||||
mga_dma_dispatch_indices(dev, buf, indices.start, indices.end);
|
||||
mga_dma_dispatch_indices(dev, buf, indices->start, indices->end);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int mga_dma_iload(DRM_IOCTL_ARGS)
|
||||
static int mga_dma_iload(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
struct drm_device_dma *dma = dev->dma;
|
||||
drm_mga_private_t *dev_priv = dev->dev_private;
|
||||
struct drm_buf *buf;
|
||||
drm_mga_buf_priv_t *buf_priv;
|
||||
drm_mga_iload_t iload;
|
||||
drm_mga_iload_t *iload = data;
|
||||
DRM_DEBUG("\n");
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(iload, (drm_mga_iload_t __user *) data,
|
||||
sizeof(iload));
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
#if 0
|
||||
if (mga_do_wait_for_idle(dev_priv) < 0) {
|
||||
if (MGA_DMA_DEBUG)
|
||||
DRM_INFO("%s: -EBUSY\n", __FUNCTION__);
|
||||
return DRM_ERR(EBUSY);
|
||||
return -EBUSY;
|
||||
}
|
||||
#endif
|
||||
if (iload.idx < 0 || iload.idx > dma->buf_count)
|
||||
return DRM_ERR(EINVAL);
|
||||
if (iload->idx < 0 || iload->idx > dma->buf_count)
|
||||
return -EINVAL;
|
||||
|
||||
buf = dma->buflist[iload.idx];
|
||||
buf = dma->buflist[iload->idx];
|
||||
buf_priv = buf->dev_private;
|
||||
|
||||
if (mga_verify_iload(dev_priv, iload.dstorg, iload.length)) {
|
||||
if (mga_verify_iload(dev_priv, iload->dstorg, iload->length)) {
|
||||
mga_freelist_put(dev, buf);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
WRAP_TEST_WITH_RETURN(dev_priv);
|
||||
|
||||
mga_dma_dispatch_iload(dev, buf, iload.dstorg, iload.length);
|
||||
mga_dma_dispatch_iload(dev, buf, iload->dstorg, iload->length);
|
||||
|
||||
/* Make sure we restore the 3D state next time.
|
||||
*/
|
||||
|
@ -1000,28 +981,24 @@ static int mga_dma_iload(DRM_IOCTL_ARGS)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int mga_dma_blit(DRM_IOCTL_ARGS)
|
||||
static int mga_dma_blit(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_mga_private_t *dev_priv = dev->dev_private;
|
||||
drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
|
||||
drm_mga_blit_t blit;
|
||||
drm_mga_blit_t *blit = data;
|
||||
DRM_DEBUG("\n");
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(blit, (drm_mga_blit_t __user *) data,
|
||||
sizeof(blit));
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
if (sarea_priv->nbox > MGA_NR_SAREA_CLIPRECTS)
|
||||
sarea_priv->nbox = MGA_NR_SAREA_CLIPRECTS;
|
||||
|
||||
if (mga_verify_blit(dev_priv, blit.srcorg, blit.dstorg))
|
||||
return DRM_ERR(EINVAL);
|
||||
if (mga_verify_blit(dev_priv, blit->srcorg, blit->dstorg))
|
||||
return -EINVAL;
|
||||
|
||||
WRAP_TEST_WITH_RETURN(dev_priv);
|
||||
|
||||
mga_dma_dispatch_blit(dev, &blit);
|
||||
mga_dma_dispatch_blit(dev, blit);
|
||||
|
||||
/* Make sure we restore the 3D state next time.
|
||||
*/
|
||||
|
@ -1030,24 +1007,20 @@ static int mga_dma_blit(DRM_IOCTL_ARGS)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int mga_getparam(DRM_IOCTL_ARGS)
|
||||
static int mga_getparam(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_mga_private_t *dev_priv = dev->dev_private;
|
||||
drm_mga_getparam_t param;
|
||||
drm_mga_getparam_t *param = data;
|
||||
int value;
|
||||
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(param, (drm_mga_getparam_t __user *) data,
|
||||
sizeof(param));
|
||||
|
||||
DRM_DEBUG("pid=%d\n", DRM_CURRENTPID);
|
||||
|
||||
switch (param.param) {
|
||||
switch (param->param) {
|
||||
case MGA_PARAM_IRQ_NR:
|
||||
value = dev->irq;
|
||||
break;
|
||||
|
@ -1055,36 +1028,35 @@ static int mga_getparam(DRM_IOCTL_ARGS)
|
|||
value = dev_priv->chipset;
|
||||
break;
|
||||
default:
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (DRM_COPY_TO_USER(param.value, &value, sizeof(int))) {
|
||||
if (DRM_COPY_TO_USER(param->value, &value, sizeof(int))) {
|
||||
DRM_ERROR("copy_to_user\n");
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int mga_set_fence(DRM_IOCTL_ARGS)
|
||||
static int mga_set_fence(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_mga_private_t *dev_priv = dev->dev_private;
|
||||
u32 temp;
|
||||
u32 *fence = data;
|
||||
DMA_LOCALS;
|
||||
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
DRM_DEBUG("pid=%d\n", DRM_CURRENTPID);
|
||||
|
||||
/* I would normal do this assignment in the declaration of temp,
|
||||
/* I would normal do this assignment in the declaration of fence,
|
||||
* but dev_priv may be NULL.
|
||||
*/
|
||||
|
||||
temp = dev_priv->next_fence_to_post;
|
||||
*fence = dev_priv->next_fence_to_post;
|
||||
dev_priv->next_fence_to_post++;
|
||||
|
||||
BEGIN_DMA(1);
|
||||
|
@ -1093,53 +1065,40 @@ static int mga_set_fence(DRM_IOCTL_ARGS)
|
|||
MGA_DMAPAD, 0x00000000, MGA_SOFTRAP, 0x00000000);
|
||||
ADVANCE_DMA();
|
||||
|
||||
if (DRM_COPY_TO_USER((u32 __user *) data, &temp, sizeof(u32))) {
|
||||
DRM_ERROR("copy_to_user\n");
|
||||
return DRM_ERR(EFAULT);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int mga_wait_fence(DRM_IOCTL_ARGS)
|
||||
static int mga_wait_fence(struct drm_device *dev, void *data, struct drm_file *
|
||||
file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_mga_private_t *dev_priv = dev->dev_private;
|
||||
u32 fence;
|
||||
u32 *fence = data;
|
||||
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(fence, (u32 __user *) data, sizeof(u32));
|
||||
|
||||
DRM_DEBUG("pid=%d\n", DRM_CURRENTPID);
|
||||
|
||||
mga_driver_fence_wait(dev, &fence);
|
||||
|
||||
if (DRM_COPY_TO_USER((u32 __user *) data, &fence, sizeof(u32))) {
|
||||
DRM_ERROR("copy_to_user\n");
|
||||
return DRM_ERR(EFAULT);
|
||||
}
|
||||
|
||||
mga_driver_fence_wait(dev, fence);
|
||||
return 0;
|
||||
}
|
||||
|
||||
drm_ioctl_desc_t mga_ioctls[] = {
|
||||
[DRM_IOCTL_NR(DRM_MGA_INIT)] = {mga_dma_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_MGA_FLUSH)] = {mga_dma_flush, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_MGA_RESET)] = {mga_dma_reset, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_MGA_SWAP)] = {mga_dma_swap, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_MGA_CLEAR)] = {mga_dma_clear, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_MGA_VERTEX)] = {mga_dma_vertex, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_MGA_INDICES)] = {mga_dma_indices, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_MGA_ILOAD)] = {mga_dma_iload, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_MGA_BLIT)] = {mga_dma_blit, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_MGA_GETPARAM)] = {mga_getparam, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_MGA_SET_FENCE)] = {mga_set_fence, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_MGA_WAIT_FENCE)] = {mga_wait_fence, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_MGA_DMA_BOOTSTRAP)] = {mga_dma_bootstrap, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
struct drm_ioctl_desc mga_ioctls[] = {
|
||||
DRM_IOCTL_DEF(DRM_MGA_INIT, mga_dma_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_MGA_FLUSH, mga_dma_flush, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_MGA_RESET, mga_dma_reset, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_MGA_SWAP, mga_dma_swap, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_MGA_CLEAR, mga_dma_clear, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_MGA_VERTEX, mga_dma_vertex, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_MGA_INDICES, mga_dma_indices, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_MGA_ILOAD, mga_dma_iload, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_MGA_BLIT, mga_dma_blit, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_MGA_GETPARAM, mga_getparam, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_MGA_SET_FENCE, mga_set_fence, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_MGA_WAIT_FENCE, mga_wait_fence, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_MGA_DMA_BOOTSTRAP, mga_dma_bootstrap, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
};
|
||||
|
||||
int mga_max_ioctl = DRM_ARRAY_SIZE(mga_ioctls);
|
||||
|
|
|
@ -141,7 +141,7 @@ int mga_warp_install_microcode(drm_mga_private_t * dev_priv)
|
|||
if (size > dev_priv->warp->size) {
|
||||
DRM_ERROR("microcode too large! (%u > %lu)\n",
|
||||
size, dev_priv->warp->size);
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
switch (dev_priv->chipset) {
|
||||
|
@ -151,7 +151,7 @@ int mga_warp_install_microcode(drm_mga_private_t * dev_priv)
|
|||
case MGA_CARD_TYPE_G200:
|
||||
return mga_warp_install_g200_microcode(dev_priv);
|
||||
default:
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -177,7 +177,7 @@ int mga_warp_init(drm_mga_private_t * dev_priv)
|
|||
MGA_WRITE(MGA_WVRTXSZ, 7);
|
||||
break;
|
||||
default:
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
MGA_WRITE(MGA_WMISC, (MGA_WUCODECACHE_ENABLE |
|
||||
|
@ -186,7 +186,7 @@ int mga_warp_init(drm_mga_private_t * dev_priv)
|
|||
if (wmisc != WMISC_EXPECTED) {
|
||||
DRM_ERROR("WARP engine config failed! 0x%x != 0x%x\n",
|
||||
wmisc, WMISC_EXPECTED);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
|
|
@ -129,7 +129,7 @@ static int r128_do_pixcache_flush(drm_r128_private_t * dev_priv)
|
|||
#if R128_FIFO_DEBUG
|
||||
DRM_ERROR("failed!\n");
|
||||
#endif
|
||||
return DRM_ERR(EBUSY);
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
static int r128_do_wait_for_fifo(drm_r128_private_t * dev_priv, int entries)
|
||||
|
@ -146,7 +146,7 @@ static int r128_do_wait_for_fifo(drm_r128_private_t * dev_priv, int entries)
|
|||
#if R128_FIFO_DEBUG
|
||||
DRM_ERROR("failed!\n");
|
||||
#endif
|
||||
return DRM_ERR(EBUSY);
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
static int r128_do_wait_for_idle(drm_r128_private_t * dev_priv)
|
||||
|
@ -168,7 +168,7 @@ static int r128_do_wait_for_idle(drm_r128_private_t * dev_priv)
|
|||
#if R128_FIFO_DEBUG
|
||||
DRM_ERROR("failed!\n");
|
||||
#endif
|
||||
return DRM_ERR(EBUSY);
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
/* ================================================================
|
||||
|
@ -227,7 +227,7 @@ int r128_do_cce_idle(drm_r128_private_t * dev_priv)
|
|||
DRM_ERROR("failed!\n");
|
||||
r128_status(dev_priv);
|
||||
#endif
|
||||
return DRM_ERR(EBUSY);
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
/* Start the Concurrent Command Engine.
|
||||
|
@ -355,7 +355,7 @@ static int r128_do_init_cce(struct drm_device * dev, drm_r128_init_t * init)
|
|||
|
||||
dev_priv = drm_alloc(sizeof(drm_r128_private_t), DRM_MEM_DRIVER);
|
||||
if (dev_priv == NULL)
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
|
||||
memset(dev_priv, 0, sizeof(drm_r128_private_t));
|
||||
|
||||
|
@ -365,7 +365,7 @@ static int r128_do_init_cce(struct drm_device * dev, drm_r128_init_t * init)
|
|||
DRM_ERROR("PCI GART memory not allocated!\n");
|
||||
dev->dev_private = (void *)dev_priv;
|
||||
r128_do_cleanup_cce(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
dev_priv->usec_timeout = init->usec_timeout;
|
||||
|
@ -374,7 +374,7 @@ static int r128_do_init_cce(struct drm_device * dev, drm_r128_init_t * init)
|
|||
DRM_DEBUG("TIMEOUT problem!\n");
|
||||
dev->dev_private = (void *)dev_priv;
|
||||
r128_do_cleanup_cce(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
dev_priv->cce_mode = init->cce_mode;
|
||||
|
@ -394,7 +394,7 @@ static int r128_do_init_cce(struct drm_device * dev, drm_r128_init_t * init)
|
|||
DRM_DEBUG("Bad cce_mode!\n");
|
||||
dev->dev_private = (void *)dev_priv;
|
||||
r128_do_cleanup_cce(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
switch (init->cce_mode) {
|
||||
|
@ -461,7 +461,7 @@ static int r128_do_init_cce(struct drm_device * dev, drm_r128_init_t * init)
|
|||
DRM_ERROR("could not find sarea!\n");
|
||||
dev->dev_private = (void *)dev_priv;
|
||||
r128_do_cleanup_cce(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
dev_priv->mmio = drm_core_findmap(dev, init->mmio_offset);
|
||||
|
@ -469,21 +469,21 @@ static int r128_do_init_cce(struct drm_device * dev, drm_r128_init_t * init)
|
|||
DRM_ERROR("could not find mmio region!\n");
|
||||
dev->dev_private = (void *)dev_priv;
|
||||
r128_do_cleanup_cce(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
dev_priv->cce_ring = drm_core_findmap(dev, init->ring_offset);
|
||||
if (!dev_priv->cce_ring) {
|
||||
DRM_ERROR("could not find cce ring region!\n");
|
||||
dev->dev_private = (void *)dev_priv;
|
||||
r128_do_cleanup_cce(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
dev_priv->ring_rptr = drm_core_findmap(dev, init->ring_rptr_offset);
|
||||
if (!dev_priv->ring_rptr) {
|
||||
DRM_ERROR("could not find ring read pointer!\n");
|
||||
dev->dev_private = (void *)dev_priv;
|
||||
r128_do_cleanup_cce(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
dev->agp_buffer_token = init->buffers_offset;
|
||||
dev->agp_buffer_map = drm_core_findmap(dev, init->buffers_offset);
|
||||
|
@ -491,7 +491,7 @@ static int r128_do_init_cce(struct drm_device * dev, drm_r128_init_t * init)
|
|||
DRM_ERROR("could not find dma buffer region!\n");
|
||||
dev->dev_private = (void *)dev_priv;
|
||||
r128_do_cleanup_cce(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (!dev_priv->is_pci) {
|
||||
|
@ -501,7 +501,7 @@ static int r128_do_init_cce(struct drm_device * dev, drm_r128_init_t * init)
|
|||
DRM_ERROR("could not find agp texture region!\n");
|
||||
dev->dev_private = (void *)dev_priv;
|
||||
r128_do_cleanup_cce(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -520,7 +520,7 @@ static int r128_do_init_cce(struct drm_device * dev, drm_r128_init_t * init)
|
|||
DRM_ERROR("Could not ioremap agp regions!\n");
|
||||
dev->dev_private = (void *)dev_priv;
|
||||
r128_do_cleanup_cce(dev);
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
} else
|
||||
#endif
|
||||
|
@ -567,7 +567,7 @@ static int r128_do_init_cce(struct drm_device * dev, drm_r128_init_t * init)
|
|||
DRM_ERROR("failed to init PCI GART!\n");
|
||||
dev->dev_private = (void *)dev_priv;
|
||||
r128_do_cleanup_cce(dev);
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
R128_WRITE(R128_PCI_GART_PAGE, dev_priv->gart_info.bus_addr);
|
||||
#if __OS_HAS_AGP
|
||||
|
@ -625,35 +625,30 @@ int r128_do_cleanup_cce(struct drm_device * dev)
|
|||
return 0;
|
||||
}
|
||||
|
||||
int r128_cce_init(DRM_IOCTL_ARGS)
|
||||
int r128_cce_init(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_r128_init_t init;
|
||||
drm_r128_init_t *init = data;
|
||||
|
||||
DRM_DEBUG("\n");
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(init, (drm_r128_init_t __user *) data,
|
||||
sizeof(init));
|
||||
|
||||
switch (init.func) {
|
||||
switch (init->func) {
|
||||
case R128_INIT_CCE:
|
||||
return r128_do_init_cce(dev, &init);
|
||||
return r128_do_init_cce(dev, init);
|
||||
case R128_CLEANUP_CCE:
|
||||
return r128_do_cleanup_cce(dev);
|
||||
}
|
||||
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
int r128_cce_start(DRM_IOCTL_ARGS)
|
||||
int r128_cce_start(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_r128_private_t *dev_priv = dev->dev_private;
|
||||
DRM_DEBUG("\n");
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
if (dev_priv->cce_running || dev_priv->cce_mode == R128_PM4_NONPM4) {
|
||||
DRM_DEBUG("%s while CCE running\n", __FUNCTION__);
|
||||
|
@ -668,30 +663,26 @@ int r128_cce_start(DRM_IOCTL_ARGS)
|
|||
/* Stop the CCE. The engine must have been idled before calling this
|
||||
* routine.
|
||||
*/
|
||||
int r128_cce_stop(DRM_IOCTL_ARGS)
|
||||
int r128_cce_stop(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_r128_private_t *dev_priv = dev->dev_private;
|
||||
drm_r128_cce_stop_t stop;
|
||||
drm_r128_cce_stop_t *stop = data;
|
||||
int ret;
|
||||
DRM_DEBUG("\n");
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(stop, (drm_r128_cce_stop_t __user *) data,
|
||||
sizeof(stop));
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
/* Flush any pending CCE commands. This ensures any outstanding
|
||||
* commands are exectuted by the engine before we turn it off.
|
||||
*/
|
||||
if (stop.flush) {
|
||||
if (stop->flush) {
|
||||
r128_do_cce_flush(dev_priv);
|
||||
}
|
||||
|
||||
/* If we fail to make the engine go idle, we return an error
|
||||
* code so that the DRM ioctl wrapper can try again.
|
||||
*/
|
||||
if (stop.idle) {
|
||||
if (stop->idle) {
|
||||
ret = r128_do_cce_idle(dev_priv);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
@ -711,17 +702,16 @@ int r128_cce_stop(DRM_IOCTL_ARGS)
|
|||
|
||||
/* Just reset the CCE ring. Called as part of an X Server engine reset.
|
||||
*/
|
||||
int r128_cce_reset(DRM_IOCTL_ARGS)
|
||||
int r128_cce_reset(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_r128_private_t *dev_priv = dev->dev_private;
|
||||
DRM_DEBUG("\n");
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
if (!dev_priv) {
|
||||
DRM_DEBUG("%s called before init done\n", __FUNCTION__);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
r128_do_cce_reset(dev_priv);
|
||||
|
@ -732,13 +722,12 @@ int r128_cce_reset(DRM_IOCTL_ARGS)
|
|||
return 0;
|
||||
}
|
||||
|
||||
int r128_cce_idle(DRM_IOCTL_ARGS)
|
||||
int r128_cce_idle(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_r128_private_t *dev_priv = dev->dev_private;
|
||||
DRM_DEBUG("\n");
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
if (dev_priv->cce_running) {
|
||||
r128_do_cce_flush(dev_priv);
|
||||
|
@ -747,19 +736,18 @@ int r128_cce_idle(DRM_IOCTL_ARGS)
|
|||
return r128_do_cce_idle(dev_priv);
|
||||
}
|
||||
|
||||
int r128_engine_reset(DRM_IOCTL_ARGS)
|
||||
int r128_engine_reset(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
DRM_DEBUG("\n");
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
return r128_do_engine_reset(dev);
|
||||
}
|
||||
|
||||
int r128_fullscreen(DRM_IOCTL_ARGS)
|
||||
int r128_fullscreen(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* ================================================================
|
||||
|
@ -780,7 +768,7 @@ static int r128_freelist_init(struct drm_device * dev)
|
|||
|
||||
dev_priv->head = drm_alloc(sizeof(drm_r128_freelist_t), DRM_MEM_DRIVER);
|
||||
if (dev_priv->head == NULL)
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
|
||||
memset(dev_priv->head, 0, sizeof(drm_r128_freelist_t));
|
||||
dev_priv->head->age = R128_BUFFER_USED;
|
||||
|
@ -791,7 +779,7 @@ static int r128_freelist_init(struct drm_device * dev)
|
|||
|
||||
entry = drm_alloc(sizeof(drm_r128_freelist_t), DRM_MEM_DRIVER);
|
||||
if (!entry)
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
|
||||
entry->age = R128_BUFFER_FREE;
|
||||
entry->buf = buf;
|
||||
|
@ -828,7 +816,7 @@ static struct drm_buf *r128_freelist_get(struct drm_device * dev)
|
|||
for (i = 0; i < dma->buf_count; i++) {
|
||||
buf = dma->buflist[i];
|
||||
buf_priv = buf->dev_private;
|
||||
if (buf->filp == 0)
|
||||
if (buf->file_priv == 0)
|
||||
return buf;
|
||||
}
|
||||
|
||||
|
@ -883,10 +871,12 @@ int r128_wait_ring(drm_r128_private_t * dev_priv, int n)
|
|||
|
||||
/* FIXME: This is being ignored... */
|
||||
DRM_ERROR("failed!\n");
|
||||
return DRM_ERR(EBUSY);
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
static int r128_cce_get_buffers(DRMFILE filp, struct drm_device * dev, struct drm_dma * d)
|
||||
static int r128_cce_get_buffers(struct drm_device * dev,
|
||||
struct drm_file *file_priv,
|
||||
struct drm_dma * d)
|
||||
{
|
||||
int i;
|
||||
struct drm_buf *buf;
|
||||
|
@ -894,57 +884,51 @@ static int r128_cce_get_buffers(DRMFILE filp, struct drm_device * dev, struct dr
|
|||
for (i = d->granted_count; i < d->request_count; i++) {
|
||||
buf = r128_freelist_get(dev);
|
||||
if (!buf)
|
||||
return DRM_ERR(EAGAIN);
|
||||
return -EAGAIN;
|
||||
|
||||
buf->filp = filp;
|
||||
buf->file_priv = file_priv;
|
||||
|
||||
if (DRM_COPY_TO_USER(&d->request_indices[i], &buf->idx,
|
||||
sizeof(buf->idx)))
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
if (DRM_COPY_TO_USER(&d->request_sizes[i], &buf->total,
|
||||
sizeof(buf->total)))
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
|
||||
d->granted_count++;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int r128_cce_buffers(DRM_IOCTL_ARGS)
|
||||
int r128_cce_buffers(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
struct drm_device_dma *dma = dev->dma;
|
||||
int ret = 0;
|
||||
struct drm_dma __user *argp = (void __user *)data;
|
||||
struct drm_dma d;
|
||||
struct drm_dma *d = data;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(d, argp, sizeof(d));
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
/* Please don't send us buffers.
|
||||
*/
|
||||
if (d.send_count != 0) {
|
||||
if (d->send_count != 0) {
|
||||
DRM_ERROR("Process %d trying to send %d buffers via drmDMA\n",
|
||||
DRM_CURRENTPID, d.send_count);
|
||||
return DRM_ERR(EINVAL);
|
||||
DRM_CURRENTPID, d->send_count);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* We'll send you buffers.
|
||||
*/
|
||||
if (d.request_count < 0 || d.request_count > dma->buf_count) {
|
||||
if (d->request_count < 0 || d->request_count > dma->buf_count) {
|
||||
DRM_ERROR("Process %d trying to get %d buffers (of %d max)\n",
|
||||
DRM_CURRENTPID, d.request_count, dma->buf_count);
|
||||
return DRM_ERR(EINVAL);
|
||||
DRM_CURRENTPID, d->request_count, dma->buf_count);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
d.granted_count = 0;
|
||||
d->granted_count = 0;
|
||||
|
||||
if (d.request_count) {
|
||||
ret = r128_cce_get_buffers(filp, dev, &d);
|
||||
if (d->request_count) {
|
||||
ret = r128_cce_get_buffers(dev, file_priv, d);
|
||||
}
|
||||
|
||||
DRM_COPY_TO_USER_IOCTL(argp, d, sizeof(d));
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
|
@ -222,11 +222,7 @@ typedef struct drm_r128_init {
|
|||
R128_INIT_CCE = 0x01,
|
||||
R128_CLEANUP_CCE = 0x02
|
||||
} func;
|
||||
#if CONFIG_XFREE86_VERSION < XFREE86_VERSION(4,1,0,0)
|
||||
int sarea_priv_offset;
|
||||
#else
|
||||
unsigned long sarea_priv_offset;
|
||||
#endif
|
||||
int is_pci;
|
||||
int cce_mode;
|
||||
int cce_secure;
|
||||
|
@ -240,21 +236,12 @@ typedef struct drm_r128_init {
|
|||
unsigned int depth_offset, depth_pitch;
|
||||
unsigned int span_offset;
|
||||
|
||||
#if CONFIG_XFREE86_VERSION < XFREE86_VERSION(4,1,0,0)
|
||||
unsigned int fb_offset;
|
||||
unsigned int mmio_offset;
|
||||
unsigned int ring_offset;
|
||||
unsigned int ring_rptr_offset;
|
||||
unsigned int buffers_offset;
|
||||
unsigned int agp_textures_offset;
|
||||
#else
|
||||
unsigned long fb_offset;
|
||||
unsigned long mmio_offset;
|
||||
unsigned long ring_offset;
|
||||
unsigned long ring_rptr_offset;
|
||||
unsigned long buffers_offset;
|
||||
unsigned long agp_textures_offset;
|
||||
#endif
|
||||
} drm_r128_init_t;
|
||||
|
||||
typedef struct drm_r128_cce_stop {
|
||||
|
@ -264,15 +251,10 @@ typedef struct drm_r128_cce_stop {
|
|||
|
||||
typedef struct drm_r128_clear {
|
||||
unsigned int flags;
|
||||
#if CONFIG_XFREE86_VERSION < XFREE86_VERSION(4,1,0,0)
|
||||
int x, y, w, h;
|
||||
#endif
|
||||
unsigned int clear_color;
|
||||
unsigned int clear_depth;
|
||||
#if CONFIG_XFREE86_VERSION >= XFREE86_VERSION(4,1,0,0)
|
||||
unsigned int color_mask;
|
||||
unsigned int depth_mask;
|
||||
#endif
|
||||
} drm_r128_clear_t;
|
||||
|
||||
typedef struct drm_r128_vertex {
|
||||
|
|
|
@ -129,18 +129,18 @@ typedef struct drm_r128_buf_priv {
|
|||
drm_r128_freelist_t *list_entry;
|
||||
} drm_r128_buf_priv_t;
|
||||
|
||||
extern drm_ioctl_desc_t r128_ioctls[];
|
||||
extern struct drm_ioctl_desc r128_ioctls[];
|
||||
extern int r128_max_ioctl;
|
||||
|
||||
/* r128_cce.c */
|
||||
extern int r128_cce_init(DRM_IOCTL_ARGS);
|
||||
extern int r128_cce_start(DRM_IOCTL_ARGS);
|
||||
extern int r128_cce_stop(DRM_IOCTL_ARGS);
|
||||
extern int r128_cce_reset(DRM_IOCTL_ARGS);
|
||||
extern int r128_cce_idle(DRM_IOCTL_ARGS);
|
||||
extern int r128_engine_reset(DRM_IOCTL_ARGS);
|
||||
extern int r128_fullscreen(DRM_IOCTL_ARGS);
|
||||
extern int r128_cce_buffers(DRM_IOCTL_ARGS);
|
||||
extern int r128_cce_init(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
extern int r128_cce_start(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
extern int r128_cce_stop(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
extern int r128_cce_reset(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
extern int r128_cce_idle(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
extern int r128_engine_reset(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
extern int r128_fullscreen(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
extern int r128_cce_buffers(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
|
||||
extern void r128_freelist_reset(struct drm_device * dev);
|
||||
|
||||
|
@ -156,7 +156,8 @@ extern void r128_driver_irq_preinstall(struct drm_device * dev);
|
|||
extern void r128_driver_irq_postinstall(struct drm_device * dev);
|
||||
extern void r128_driver_irq_uninstall(struct drm_device * dev);
|
||||
extern void r128_driver_lastclose(struct drm_device * dev);
|
||||
extern void r128_driver_preclose(struct drm_device * dev, DRMFILE filp);
|
||||
extern void r128_driver_preclose(struct drm_device * dev,
|
||||
struct drm_file *file_priv);
|
||||
|
||||
extern long r128_compat_ioctl(struct file *filp, unsigned int cmd,
|
||||
unsigned long arg);
|
||||
|
@ -428,7 +429,7 @@ do { \
|
|||
DRM_UDELAY(1); \
|
||||
} \
|
||||
DRM_ERROR( "ring space check failed!\n" ); \
|
||||
return DRM_ERR(EBUSY); \
|
||||
return -EBUSY; \
|
||||
} \
|
||||
__ring_space_done: \
|
||||
; \
|
||||
|
|
|
@ -776,8 +776,9 @@ static void r128_cce_dispatch_indices(struct drm_device * dev,
|
|||
sarea_priv->nbox = 0;
|
||||
}
|
||||
|
||||
static int r128_cce_dispatch_blit(DRMFILE filp,
|
||||
struct drm_device * dev, drm_r128_blit_t * blit)
|
||||
static int r128_cce_dispatch_blit(struct drm_device * dev,
|
||||
struct drm_file *file_priv,
|
||||
drm_r128_blit_t * blit)
|
||||
{
|
||||
drm_r128_private_t *dev_priv = dev->dev_private;
|
||||
struct drm_device_dma *dma = dev->dma;
|
||||
|
@ -809,7 +810,7 @@ static int r128_cce_dispatch_blit(DRMFILE filp,
|
|||
break;
|
||||
default:
|
||||
DRM_ERROR("invalid blit format %d\n", blit->format);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* Flush the pixel cache, and mark the contents as Read Invalid.
|
||||
|
@ -829,14 +830,14 @@ static int r128_cce_dispatch_blit(DRMFILE filp,
|
|||
buf = dma->buflist[blit->idx];
|
||||
buf_priv = buf->dev_private;
|
||||
|
||||
if (buf->filp != filp) {
|
||||
if (buf->file_priv != file_priv) {
|
||||
DRM_ERROR("process %d using buffer owned by %p\n",
|
||||
DRM_CURRENTPID, buf->filp);
|
||||
return DRM_ERR(EINVAL);
|
||||
DRM_CURRENTPID, buf->file_priv);
|
||||
return -EINVAL;
|
||||
}
|
||||
if (buf->pending) {
|
||||
DRM_ERROR("sending pending buffer %d\n", blit->idx);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
buf_priv->discard = 1;
|
||||
|
@ -900,22 +901,22 @@ static int r128_cce_dispatch_write_span(struct drm_device * dev,
|
|||
|
||||
count = depth->n;
|
||||
if (count > 4096 || count <= 0)
|
||||
return DRM_ERR(EMSGSIZE);
|
||||
return -EMSGSIZE;
|
||||
|
||||
if (DRM_COPY_FROM_USER(&x, depth->x, sizeof(x))) {
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
if (DRM_COPY_FROM_USER(&y, depth->y, sizeof(y))) {
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
buffer_size = depth->n * sizeof(u32);
|
||||
buffer = drm_alloc(buffer_size, DRM_MEM_BUFS);
|
||||
if (buffer == NULL)
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
if (DRM_COPY_FROM_USER(buffer, depth->buffer, buffer_size)) {
|
||||
drm_free(buffer, buffer_size, DRM_MEM_BUFS);
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
mask_size = depth->n * sizeof(u8);
|
||||
|
@ -923,12 +924,12 @@ static int r128_cce_dispatch_write_span(struct drm_device * dev,
|
|||
mask = drm_alloc(mask_size, DRM_MEM_BUFS);
|
||||
if (mask == NULL) {
|
||||
drm_free(buffer, buffer_size, DRM_MEM_BUFS);
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
if (DRM_COPY_FROM_USER(mask, depth->mask, mask_size)) {
|
||||
drm_free(buffer, buffer_size, DRM_MEM_BUFS);
|
||||
drm_free(mask, mask_size, DRM_MEM_BUFS);
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
for (i = 0; i < count; i++, x++) {
|
||||
|
@ -996,28 +997,28 @@ static int r128_cce_dispatch_write_pixels(struct drm_device * dev,
|
|||
|
||||
count = depth->n;
|
||||
if (count > 4096 || count <= 0)
|
||||
return DRM_ERR(EMSGSIZE);
|
||||
return -EMSGSIZE;
|
||||
|
||||
xbuf_size = count * sizeof(*x);
|
||||
ybuf_size = count * sizeof(*y);
|
||||
x = drm_alloc(xbuf_size, DRM_MEM_BUFS);
|
||||
if (x == NULL) {
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
y = drm_alloc(ybuf_size, DRM_MEM_BUFS);
|
||||
if (y == NULL) {
|
||||
drm_free(x, xbuf_size, DRM_MEM_BUFS);
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
if (DRM_COPY_FROM_USER(x, depth->x, xbuf_size)) {
|
||||
drm_free(x, xbuf_size, DRM_MEM_BUFS);
|
||||
drm_free(y, ybuf_size, DRM_MEM_BUFS);
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
if (DRM_COPY_FROM_USER(y, depth->y, xbuf_size)) {
|
||||
drm_free(x, xbuf_size, DRM_MEM_BUFS);
|
||||
drm_free(y, ybuf_size, DRM_MEM_BUFS);
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
buffer_size = depth->n * sizeof(u32);
|
||||
|
@ -1025,13 +1026,13 @@ static int r128_cce_dispatch_write_pixels(struct drm_device * dev,
|
|||
if (buffer == NULL) {
|
||||
drm_free(x, xbuf_size, DRM_MEM_BUFS);
|
||||
drm_free(y, ybuf_size, DRM_MEM_BUFS);
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
if (DRM_COPY_FROM_USER(buffer, depth->buffer, buffer_size)) {
|
||||
drm_free(x, xbuf_size, DRM_MEM_BUFS);
|
||||
drm_free(y, ybuf_size, DRM_MEM_BUFS);
|
||||
drm_free(buffer, buffer_size, DRM_MEM_BUFS);
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
if (depth->mask) {
|
||||
|
@ -1041,14 +1042,14 @@ static int r128_cce_dispatch_write_pixels(struct drm_device * dev,
|
|||
drm_free(x, xbuf_size, DRM_MEM_BUFS);
|
||||
drm_free(y, ybuf_size, DRM_MEM_BUFS);
|
||||
drm_free(buffer, buffer_size, DRM_MEM_BUFS);
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
if (DRM_COPY_FROM_USER(mask, depth->mask, mask_size)) {
|
||||
drm_free(x, xbuf_size, DRM_MEM_BUFS);
|
||||
drm_free(y, ybuf_size, DRM_MEM_BUFS);
|
||||
drm_free(buffer, buffer_size, DRM_MEM_BUFS);
|
||||
drm_free(mask, mask_size, DRM_MEM_BUFS);
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
for (i = 0; i < count; i++) {
|
||||
|
@ -1115,13 +1116,13 @@ static int r128_cce_dispatch_read_span(struct drm_device * dev,
|
|||
|
||||
count = depth->n;
|
||||
if (count > 4096 || count <= 0)
|
||||
return DRM_ERR(EMSGSIZE);
|
||||
return -EMSGSIZE;
|
||||
|
||||
if (DRM_COPY_FROM_USER(&x, depth->x, sizeof(x))) {
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
if (DRM_COPY_FROM_USER(&y, depth->y, sizeof(y))) {
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
BEGIN_RING(7);
|
||||
|
@ -1159,7 +1160,7 @@ static int r128_cce_dispatch_read_pixels(struct drm_device * dev,
|
|||
|
||||
count = depth->n;
|
||||
if (count > 4096 || count <= 0)
|
||||
return DRM_ERR(EMSGSIZE);
|
||||
return -EMSGSIZE;
|
||||
|
||||
if (count > dev_priv->depth_pitch) {
|
||||
count = dev_priv->depth_pitch;
|
||||
|
@ -1169,22 +1170,22 @@ static int r128_cce_dispatch_read_pixels(struct drm_device * dev,
|
|||
ybuf_size = count * sizeof(*y);
|
||||
x = drm_alloc(xbuf_size, DRM_MEM_BUFS);
|
||||
if (x == NULL) {
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
y = drm_alloc(ybuf_size, DRM_MEM_BUFS);
|
||||
if (y == NULL) {
|
||||
drm_free(x, xbuf_size, DRM_MEM_BUFS);
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
if (DRM_COPY_FROM_USER(x, depth->x, xbuf_size)) {
|
||||
drm_free(x, xbuf_size, DRM_MEM_BUFS);
|
||||
drm_free(y, ybuf_size, DRM_MEM_BUFS);
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
if (DRM_COPY_FROM_USER(y, depth->y, ybuf_size)) {
|
||||
drm_free(x, xbuf_size, DRM_MEM_BUFS);
|
||||
drm_free(y, ybuf_size, DRM_MEM_BUFS);
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
for (i = 0; i < count; i++) {
|
||||
|
@ -1241,25 +1242,21 @@ static void r128_cce_dispatch_stipple(struct drm_device * dev, u32 * stipple)
|
|||
* IOCTL functions
|
||||
*/
|
||||
|
||||
static int r128_cce_clear(DRM_IOCTL_ARGS)
|
||||
static int r128_cce_clear(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_r128_private_t *dev_priv = dev->dev_private;
|
||||
drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
|
||||
drm_r128_clear_t clear;
|
||||
drm_r128_clear_t *clear = data;
|
||||
DRM_DEBUG("\n");
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(clear, (drm_r128_clear_t __user *) data,
|
||||
sizeof(clear));
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
RING_SPACE_TEST_WITH_RETURN(dev_priv);
|
||||
|
||||
if (sarea_priv->nbox > R128_NR_SAREA_CLIPRECTS)
|
||||
sarea_priv->nbox = R128_NR_SAREA_CLIPRECTS;
|
||||
|
||||
r128_cce_dispatch_clear(dev, &clear);
|
||||
r128_cce_dispatch_clear(dev, clear);
|
||||
COMMIT_RING();
|
||||
|
||||
/* Make sure we restore the 3D state next time.
|
||||
|
@ -1309,13 +1306,12 @@ static int r128_do_cleanup_pageflip(struct drm_device * dev)
|
|||
* They can & should be intermixed to support multiple 3d windows.
|
||||
*/
|
||||
|
||||
static int r128_cce_flip(DRM_IOCTL_ARGS)
|
||||
static int r128_cce_flip(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_r128_private_t *dev_priv = dev->dev_private;
|
||||
DRM_DEBUG("%s\n", __FUNCTION__);
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
RING_SPACE_TEST_WITH_RETURN(dev_priv);
|
||||
|
||||
|
@ -1328,14 +1324,13 @@ static int r128_cce_flip(DRM_IOCTL_ARGS)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int r128_cce_swap(DRM_IOCTL_ARGS)
|
||||
static int r128_cce_swap(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_r128_private_t *dev_priv = dev->dev_private;
|
||||
drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
|
||||
DRM_DEBUG("%s\n", __FUNCTION__);
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
RING_SPACE_TEST_WITH_RETURN(dev_priv);
|
||||
|
||||
|
@ -1350,58 +1345,54 @@ static int r128_cce_swap(DRM_IOCTL_ARGS)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int r128_cce_vertex(DRM_IOCTL_ARGS)
|
||||
static int r128_cce_vertex(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_r128_private_t *dev_priv = dev->dev_private;
|
||||
struct drm_device_dma *dma = dev->dma;
|
||||
struct drm_buf *buf;
|
||||
drm_r128_buf_priv_t *buf_priv;
|
||||
drm_r128_vertex_t vertex;
|
||||
drm_r128_vertex_t *vertex = data;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(vertex, (drm_r128_vertex_t __user *) data,
|
||||
sizeof(vertex));
|
||||
|
||||
DRM_DEBUG("pid=%d index=%d count=%d discard=%d\n",
|
||||
DRM_CURRENTPID, vertex.idx, vertex.count, vertex.discard);
|
||||
DRM_CURRENTPID, vertex->idx, vertex->count, vertex->discard);
|
||||
|
||||
if (vertex.idx < 0 || vertex.idx >= dma->buf_count) {
|
||||
if (vertex->idx < 0 || vertex->idx >= dma->buf_count) {
|
||||
DRM_ERROR("buffer index %d (of %d max)\n",
|
||||
vertex.idx, dma->buf_count - 1);
|
||||
return DRM_ERR(EINVAL);
|
||||
vertex->idx, dma->buf_count - 1);
|
||||
return -EINVAL;
|
||||
}
|
||||
if (vertex.prim < 0 ||
|
||||
vertex.prim > R128_CCE_VC_CNTL_PRIM_TYPE_TRI_TYPE2) {
|
||||
DRM_ERROR("buffer prim %d\n", vertex.prim);
|
||||
return DRM_ERR(EINVAL);
|
||||
if (vertex->prim < 0 ||
|
||||
vertex->prim > R128_CCE_VC_CNTL_PRIM_TYPE_TRI_TYPE2) {
|
||||
DRM_ERROR("buffer prim %d\n", vertex->prim);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
RING_SPACE_TEST_WITH_RETURN(dev_priv);
|
||||
VB_AGE_TEST_WITH_RETURN(dev_priv);
|
||||
|
||||
buf = dma->buflist[vertex.idx];
|
||||
buf = dma->buflist[vertex->idx];
|
||||
buf_priv = buf->dev_private;
|
||||
|
||||
if (buf->filp != filp) {
|
||||
if (buf->file_priv != file_priv) {
|
||||
DRM_ERROR("process %d using buffer owned by %p\n",
|
||||
DRM_CURRENTPID, buf->filp);
|
||||
return DRM_ERR(EINVAL);
|
||||
DRM_CURRENTPID, buf->file_priv);
|
||||
return -EINVAL;
|
||||
}
|
||||
if (buf->pending) {
|
||||
DRM_ERROR("sending pending buffer %d\n", vertex.idx);
|
||||
return DRM_ERR(EINVAL);
|
||||
DRM_ERROR("sending pending buffer %d\n", vertex->idx);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
buf->used = vertex.count;
|
||||
buf_priv->prim = vertex.prim;
|
||||
buf_priv->discard = vertex.discard;
|
||||
buf->used = vertex->count;
|
||||
buf_priv->prim = vertex->prim;
|
||||
buf_priv->discard = vertex->discard;
|
||||
|
||||
r128_cce_dispatch_vertex(dev, buf);
|
||||
|
||||
|
@ -1409,134 +1400,123 @@ static int r128_cce_vertex(DRM_IOCTL_ARGS)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int r128_cce_indices(DRM_IOCTL_ARGS)
|
||||
static int r128_cce_indices(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_r128_private_t *dev_priv = dev->dev_private;
|
||||
struct drm_device_dma *dma = dev->dma;
|
||||
struct drm_buf *buf;
|
||||
drm_r128_buf_priv_t *buf_priv;
|
||||
drm_r128_indices_t elts;
|
||||
drm_r128_indices_t *elts = data;
|
||||
int count;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(elts, (drm_r128_indices_t __user *) data,
|
||||
sizeof(elts));
|
||||
|
||||
DRM_DEBUG("pid=%d buf=%d s=%d e=%d d=%d\n", DRM_CURRENTPID,
|
||||
elts.idx, elts.start, elts.end, elts.discard);
|
||||
elts->idx, elts->start, elts->end, elts->discard);
|
||||
|
||||
if (elts.idx < 0 || elts.idx >= dma->buf_count) {
|
||||
if (elts->idx < 0 || elts->idx >= dma->buf_count) {
|
||||
DRM_ERROR("buffer index %d (of %d max)\n",
|
||||
elts.idx, dma->buf_count - 1);
|
||||
return DRM_ERR(EINVAL);
|
||||
elts->idx, dma->buf_count - 1);
|
||||
return -EINVAL;
|
||||
}
|
||||
if (elts.prim < 0 || elts.prim > R128_CCE_VC_CNTL_PRIM_TYPE_TRI_TYPE2) {
|
||||
DRM_ERROR("buffer prim %d\n", elts.prim);
|
||||
return DRM_ERR(EINVAL);
|
||||
if (elts->prim < 0 ||
|
||||
elts->prim > R128_CCE_VC_CNTL_PRIM_TYPE_TRI_TYPE2) {
|
||||
DRM_ERROR("buffer prim %d\n", elts->prim);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
RING_SPACE_TEST_WITH_RETURN(dev_priv);
|
||||
VB_AGE_TEST_WITH_RETURN(dev_priv);
|
||||
|
||||
buf = dma->buflist[elts.idx];
|
||||
buf = dma->buflist[elts->idx];
|
||||
buf_priv = buf->dev_private;
|
||||
|
||||
if (buf->filp != filp) {
|
||||
if (buf->file_priv != file_priv) {
|
||||
DRM_ERROR("process %d using buffer owned by %p\n",
|
||||
DRM_CURRENTPID, buf->filp);
|
||||
return DRM_ERR(EINVAL);
|
||||
DRM_CURRENTPID, buf->file_priv);
|
||||
return -EINVAL;
|
||||
}
|
||||
if (buf->pending) {
|
||||
DRM_ERROR("sending pending buffer %d\n", elts.idx);
|
||||
return DRM_ERR(EINVAL);
|
||||
DRM_ERROR("sending pending buffer %d\n", elts->idx);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
count = (elts.end - elts.start) / sizeof(u16);
|
||||
elts.start -= R128_INDEX_PRIM_OFFSET;
|
||||
count = (elts->end - elts->start) / sizeof(u16);
|
||||
elts->start -= R128_INDEX_PRIM_OFFSET;
|
||||
|
||||
if (elts.start & 0x7) {
|
||||
DRM_ERROR("misaligned buffer 0x%x\n", elts.start);
|
||||
return DRM_ERR(EINVAL);
|
||||
if (elts->start & 0x7) {
|
||||
DRM_ERROR("misaligned buffer 0x%x\n", elts->start);
|
||||
return -EINVAL;
|
||||
}
|
||||
if (elts.start < buf->used) {
|
||||
DRM_ERROR("no header 0x%x - 0x%x\n", elts.start, buf->used);
|
||||
return DRM_ERR(EINVAL);
|
||||
if (elts->start < buf->used) {
|
||||
DRM_ERROR("no header 0x%x - 0x%x\n", elts->start, buf->used);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
buf->used = elts.end;
|
||||
buf_priv->prim = elts.prim;
|
||||
buf_priv->discard = elts.discard;
|
||||
buf->used = elts->end;
|
||||
buf_priv->prim = elts->prim;
|
||||
buf_priv->discard = elts->discard;
|
||||
|
||||
r128_cce_dispatch_indices(dev, buf, elts.start, elts.end, count);
|
||||
r128_cce_dispatch_indices(dev, buf, elts->start, elts->end, count);
|
||||
|
||||
COMMIT_RING();
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int r128_cce_blit(DRM_IOCTL_ARGS)
|
||||
static int r128_cce_blit(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
struct drm_device_dma *dma = dev->dma;
|
||||
drm_r128_private_t *dev_priv = dev->dev_private;
|
||||
drm_r128_blit_t blit;
|
||||
drm_r128_blit_t *blit = data;
|
||||
int ret;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(blit, (drm_r128_blit_t __user *) data,
|
||||
sizeof(blit));
|
||||
DRM_DEBUG("pid=%d index=%d\n", DRM_CURRENTPID, blit->idx);
|
||||
|
||||
DRM_DEBUG("pid=%d index=%d\n", DRM_CURRENTPID, blit.idx);
|
||||
|
||||
if (blit.idx < 0 || blit.idx >= dma->buf_count) {
|
||||
if (blit->idx < 0 || blit->idx >= dma->buf_count) {
|
||||
DRM_ERROR("buffer index %d (of %d max)\n",
|
||||
blit.idx, dma->buf_count - 1);
|
||||
return DRM_ERR(EINVAL);
|
||||
blit->idx, dma->buf_count - 1);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
RING_SPACE_TEST_WITH_RETURN(dev_priv);
|
||||
VB_AGE_TEST_WITH_RETURN(dev_priv);
|
||||
|
||||
ret = r128_cce_dispatch_blit(filp, dev, &blit);
|
||||
ret = r128_cce_dispatch_blit(dev, file_priv, blit);
|
||||
|
||||
COMMIT_RING();
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int r128_cce_depth(DRM_IOCTL_ARGS)
|
||||
static int r128_cce_depth(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_r128_private_t *dev_priv = dev->dev_private;
|
||||
drm_r128_depth_t depth;
|
||||
drm_r128_depth_t *depth = data;
|
||||
int ret;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(depth, (drm_r128_depth_t __user *) data,
|
||||
sizeof(depth));
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
RING_SPACE_TEST_WITH_RETURN(dev_priv);
|
||||
|
||||
ret = DRM_ERR(EINVAL);
|
||||
switch (depth.func) {
|
||||
ret = -EINVAL;
|
||||
switch (depth->func) {
|
||||
case R128_WRITE_SPAN:
|
||||
ret = r128_cce_dispatch_write_span(dev, &depth);
|
||||
ret = r128_cce_dispatch_write_span(dev, depth);
|
||||
break;
|
||||
case R128_WRITE_PIXELS:
|
||||
ret = r128_cce_dispatch_write_pixels(dev, &depth);
|
||||
ret = r128_cce_dispatch_write_pixels(dev, depth);
|
||||
break;
|
||||
case R128_READ_SPAN:
|
||||
ret = r128_cce_dispatch_read_span(dev, &depth);
|
||||
ret = r128_cce_dispatch_read_span(dev, depth);
|
||||
break;
|
||||
case R128_READ_PIXELS:
|
||||
ret = r128_cce_dispatch_read_pixels(dev, &depth);
|
||||
ret = r128_cce_dispatch_read_pixels(dev, depth);
|
||||
break;
|
||||
}
|
||||
|
||||
|
@ -1544,20 +1524,16 @@ static int r128_cce_depth(DRM_IOCTL_ARGS)
|
|||
return ret;
|
||||
}
|
||||
|
||||
static int r128_cce_stipple(DRM_IOCTL_ARGS)
|
||||
static int r128_cce_stipple(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_r128_private_t *dev_priv = dev->dev_private;
|
||||
drm_r128_stipple_t stipple;
|
||||
drm_r128_stipple_t *stipple = data;
|
||||
u32 mask[32];
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(stipple, (drm_r128_stipple_t __user *) data,
|
||||
sizeof(stipple));
|
||||
|
||||
if (DRM_COPY_FROM_USER(&mask, stipple.mask, 32 * sizeof(u32)))
|
||||
return DRM_ERR(EFAULT);
|
||||
if (DRM_COPY_FROM_USER(&mask, stipple->mask, 32 * sizeof(u32)))
|
||||
return -EFAULT;
|
||||
|
||||
RING_SPACE_TEST_WITH_RETURN(dev_priv);
|
||||
|
||||
|
@ -1567,61 +1543,58 @@ static int r128_cce_stipple(DRM_IOCTL_ARGS)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int r128_cce_indirect(DRM_IOCTL_ARGS)
|
||||
static int r128_cce_indirect(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_r128_private_t *dev_priv = dev->dev_private;
|
||||
struct drm_device_dma *dma = dev->dma;
|
||||
struct drm_buf *buf;
|
||||
drm_r128_buf_priv_t *buf_priv;
|
||||
drm_r128_indirect_t indirect;
|
||||
drm_r128_indirect_t *indirect = data;
|
||||
#if 0
|
||||
RING_LOCALS;
|
||||
#endif
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(indirect, (drm_r128_indirect_t __user *) data,
|
||||
sizeof(indirect));
|
||||
|
||||
DRM_DEBUG("indirect: idx=%d s=%d e=%d d=%d\n",
|
||||
indirect.idx, indirect.start, indirect.end, indirect.discard);
|
||||
indirect->idx, indirect->start, indirect->end,
|
||||
indirect->discard);
|
||||
|
||||
if (indirect.idx < 0 || indirect.idx >= dma->buf_count) {
|
||||
if (indirect->idx < 0 || indirect->idx >= dma->buf_count) {
|
||||
DRM_ERROR("buffer index %d (of %d max)\n",
|
||||
indirect.idx, dma->buf_count - 1);
|
||||
return DRM_ERR(EINVAL);
|
||||
indirect->idx, dma->buf_count - 1);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
buf = dma->buflist[indirect.idx];
|
||||
buf = dma->buflist[indirect->idx];
|
||||
buf_priv = buf->dev_private;
|
||||
|
||||
if (buf->filp != filp) {
|
||||
if (buf->file_priv != file_priv) {
|
||||
DRM_ERROR("process %d using buffer owned by %p\n",
|
||||
DRM_CURRENTPID, buf->filp);
|
||||
return DRM_ERR(EINVAL);
|
||||
DRM_CURRENTPID, buf->file_priv);
|
||||
return -EINVAL;
|
||||
}
|
||||
if (buf->pending) {
|
||||
DRM_ERROR("sending pending buffer %d\n", indirect.idx);
|
||||
return DRM_ERR(EINVAL);
|
||||
DRM_ERROR("sending pending buffer %d\n", indirect->idx);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (indirect.start < buf->used) {
|
||||
if (indirect->start < buf->used) {
|
||||
DRM_ERROR("reusing indirect: start=0x%x actual=0x%x\n",
|
||||
indirect.start, buf->used);
|
||||
return DRM_ERR(EINVAL);
|
||||
indirect->start, buf->used);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
RING_SPACE_TEST_WITH_RETURN(dev_priv);
|
||||
VB_AGE_TEST_WITH_RETURN(dev_priv);
|
||||
|
||||
buf->used = indirect.end;
|
||||
buf_priv->discard = indirect.discard;
|
||||
buf->used = indirect->end;
|
||||
buf_priv->discard = indirect->discard;
|
||||
|
||||
#if 0
|
||||
/* Wait for the 3D stream to idle before the indirect buffer
|
||||
|
@ -1636,46 +1609,42 @@ static int r128_cce_indirect(DRM_IOCTL_ARGS)
|
|||
* X server. This is insecure and is thus only available to
|
||||
* privileged clients.
|
||||
*/
|
||||
r128_cce_dispatch_indirect(dev, buf, indirect.start, indirect.end);
|
||||
r128_cce_dispatch_indirect(dev, buf, indirect->start, indirect->end);
|
||||
|
||||
COMMIT_RING();
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int r128_getparam(DRM_IOCTL_ARGS)
|
||||
static int r128_getparam(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_r128_private_t *dev_priv = dev->dev_private;
|
||||
drm_r128_getparam_t param;
|
||||
drm_r128_getparam_t *param = data;
|
||||
int value;
|
||||
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(param, (drm_r128_getparam_t __user *) data,
|
||||
sizeof(param));
|
||||
|
||||
DRM_DEBUG("pid=%d\n", DRM_CURRENTPID);
|
||||
|
||||
switch (param.param) {
|
||||
switch (param->param) {
|
||||
case R128_PARAM_IRQ_NR:
|
||||
value = dev->irq;
|
||||
break;
|
||||
default:
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (DRM_COPY_TO_USER(param.value, &value, sizeof(int))) {
|
||||
if (DRM_COPY_TO_USER(param->value, &value, sizeof(int))) {
|
||||
DRM_ERROR("copy_to_user\n");
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void r128_driver_preclose(struct drm_device * dev, DRMFILE filp)
|
||||
void r128_driver_preclose(struct drm_device * dev, struct drm_file *file_priv)
|
||||
{
|
||||
if (dev->dev_private) {
|
||||
drm_r128_private_t *dev_priv = dev->dev_private;
|
||||
|
@ -1690,24 +1659,24 @@ void r128_driver_lastclose(struct drm_device * dev)
|
|||
r128_do_cleanup_cce(dev);
|
||||
}
|
||||
|
||||
drm_ioctl_desc_t r128_ioctls[] = {
|
||||
[DRM_IOCTL_NR(DRM_R128_INIT)] = {r128_cce_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_R128_CCE_START)] = {r128_cce_start, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_R128_CCE_STOP)] = {r128_cce_stop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_R128_CCE_RESET)] = {r128_cce_reset, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_R128_CCE_IDLE)] = {r128_cce_idle, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_R128_RESET)] = {r128_engine_reset, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_R128_FULLSCREEN)] = {r128_fullscreen, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_R128_SWAP)] = {r128_cce_swap, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_R128_FLIP)] = {r128_cce_flip, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_R128_CLEAR)] = {r128_cce_clear, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_R128_VERTEX)] = {r128_cce_vertex, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_R128_INDICES)] = {r128_cce_indices, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_R128_BLIT)] = {r128_cce_blit, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_R128_DEPTH)] = {r128_cce_depth, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_R128_STIPPLE)] = {r128_cce_stipple, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_R128_INDIRECT)] = {r128_cce_indirect, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_R128_GETPARAM)] = {r128_getparam, DRM_AUTH},
|
||||
struct drm_ioctl_desc r128_ioctls[] = {
|
||||
DRM_IOCTL_DEF(DRM_R128_INIT, r128_cce_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_R128_CCE_START, r128_cce_start, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_R128_CCE_STOP, r128_cce_stop, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_R128_CCE_RESET, r128_cce_reset, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_R128_CCE_IDLE, r128_cce_idle, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_R128_RESET, r128_engine_reset, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_R128_FULLSCREEN, r128_fullscreen, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_R128_SWAP, r128_cce_swap, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_R128_FLIP, r128_cce_flip, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_R128_CLEAR, r128_cce_clear, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_R128_VERTEX, r128_cce_vertex, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_R128_INDICES, r128_cce_indices, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_R128_BLIT, r128_cce_blit, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_R128_DEPTH, r128_cce_depth, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_R128_STIPPLE, r128_cce_stipple, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_R128_INDIRECT, r128_cce_indirect, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_R128_GETPARAM, r128_getparam, DRM_AUTH),
|
||||
};
|
||||
|
||||
int r128_max_ioctl = DRM_ARRAY_SIZE(r128_ioctls);
|
||||
|
|
|
@ -74,7 +74,7 @@ static int r300_emit_cliprects(drm_radeon_private_t *dev_priv,
|
|||
if (DRM_COPY_FROM_USER_UNCHECKED
|
||||
(&box, &cmdbuf->boxes[n + i], sizeof(box))) {
|
||||
DRM_ERROR("copy cliprect faulted\n");
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
box.x1 =
|
||||
|
@ -263,7 +263,7 @@ static __inline__ int r300_emit_carefully_checked_packet0(drm_radeon_private_t *
|
|||
DRM_ERROR
|
||||
("Cannot emit more than 64 values at a time (reg=%04x sz=%d)\n",
|
||||
reg, sz);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
for (i = 0; i < sz; i++) {
|
||||
values[i] = ((int *)cmdbuf->buf)[i];
|
||||
|
@ -275,13 +275,13 @@ static __inline__ int r300_emit_carefully_checked_packet0(drm_radeon_private_t *
|
|||
DRM_ERROR
|
||||
("Offset failed range check (reg=%04x sz=%d)\n",
|
||||
reg, sz);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
DRM_ERROR("Register %04x failed check as flag=%02x\n",
|
||||
reg + i * 4, r300_reg_flags[(reg >> 2) + i]);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -317,12 +317,12 @@ static __inline__ int r300_emit_packet0(drm_radeon_private_t *dev_priv,
|
|||
return 0;
|
||||
|
||||
if (sz * 4 > cmdbuf->bufsz)
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
|
||||
if (reg + sz * 4 >= 0x10000) {
|
||||
DRM_ERROR("No such registers in hardware reg=%04x sz=%d\n", reg,
|
||||
sz);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (r300_check_range(reg, sz)) {
|
||||
|
@ -362,7 +362,7 @@ static __inline__ int r300_emit_vpu(drm_radeon_private_t *dev_priv,
|
|||
if (!sz)
|
||||
return 0;
|
||||
if (sz * 16 > cmdbuf->bufsz)
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
|
||||
BEGIN_RING(5 + sz * 4);
|
||||
/* Wait for VAP to come to senses.. */
|
||||
|
@ -391,7 +391,7 @@ static __inline__ int r300_emit_clear(drm_radeon_private_t *dev_priv,
|
|||
RING_LOCALS;
|
||||
|
||||
if (8 * 4 > cmdbuf->bufsz)
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
|
||||
BEGIN_RING(10);
|
||||
OUT_RING(CP_PACKET3(R200_3D_DRAW_IMMD_2, 8));
|
||||
|
@ -421,7 +421,7 @@ static __inline__ int r300_emit_3d_load_vbpntr(drm_radeon_private_t *dev_priv,
|
|||
if ((count + 1) > MAX_ARRAY_PACKET) {
|
||||
DRM_ERROR("Too large payload in 3D_LOAD_VBPNTR (count=%d)\n",
|
||||
count);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
memset(payload, 0, MAX_ARRAY_PACKET * 4);
|
||||
memcpy(payload, cmdbuf->buf + 4, (count + 1) * 4);
|
||||
|
@ -437,7 +437,7 @@ static __inline__ int r300_emit_3d_load_vbpntr(drm_radeon_private_t *dev_priv,
|
|||
DRM_ERROR
|
||||
("Offset failed range check (k=%d i=%d) while processing 3D_LOAD_VBPNTR packet.\n",
|
||||
k, i);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
k++;
|
||||
i++;
|
||||
|
@ -448,7 +448,7 @@ static __inline__ int r300_emit_3d_load_vbpntr(drm_radeon_private_t *dev_priv,
|
|||
DRM_ERROR
|
||||
("Offset failed range check (k=%d i=%d) while processing 3D_LOAD_VBPNTR packet.\n",
|
||||
k, i);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
k++;
|
||||
i++;
|
||||
|
@ -458,7 +458,7 @@ static __inline__ int r300_emit_3d_load_vbpntr(drm_radeon_private_t *dev_priv,
|
|||
DRM_ERROR
|
||||
("Malformed 3D_LOAD_VBPNTR packet (k=%d i=%d narrays=%d count+1=%d).\n",
|
||||
k, i, narrays, count + 1);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* all clear, output packet */
|
||||
|
@ -492,7 +492,7 @@ static __inline__ int r300_emit_bitblt_multi(drm_radeon_private_t *dev_priv,
|
|||
ret = !radeon_check_offset(dev_priv, offset);
|
||||
if (ret) {
|
||||
DRM_ERROR("Invalid bitblt first offset is %08X\n", offset);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -502,7 +502,7 @@ static __inline__ int r300_emit_bitblt_multi(drm_radeon_private_t *dev_priv,
|
|||
ret = !radeon_check_offset(dev_priv, offset);
|
||||
if (ret) {
|
||||
DRM_ERROR("Invalid bitblt second offset is %08X\n", offset);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -530,12 +530,12 @@ static __inline__ int r300_emit_indx_buffer(drm_radeon_private_t *dev_priv,
|
|||
|
||||
if ((cmd[1] & 0x8000ffff) != 0x80000810) {
|
||||
DRM_ERROR("Invalid indx_buffer reg address %08X\n", cmd[1]);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
ret = !radeon_check_offset(dev_priv, cmd[2]);
|
||||
if (ret) {
|
||||
DRM_ERROR("Invalid indx_buffer offset is %08X\n", cmd[2]);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
BEGIN_RING(count+2);
|
||||
|
@ -557,7 +557,7 @@ static __inline__ int r300_emit_raw_packet3(drm_radeon_private_t *dev_priv,
|
|||
RING_LOCALS;
|
||||
|
||||
if (4 > cmdbuf->bufsz)
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
|
||||
/* Fixme !! This simply emits a packet without much checking.
|
||||
We need to be smarter. */
|
||||
|
@ -568,7 +568,7 @@ static __inline__ int r300_emit_raw_packet3(drm_radeon_private_t *dev_priv,
|
|||
/* Is it packet 3 ? */
|
||||
if ((header >> 30) != 0x3) {
|
||||
DRM_ERROR("Not a packet3 header (0x%08x)\n", header);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
count = (header >> 16) & 0x3fff;
|
||||
|
@ -578,7 +578,7 @@ static __inline__ int r300_emit_raw_packet3(drm_radeon_private_t *dev_priv,
|
|||
DRM_ERROR
|
||||
("Expected packet3 of length %d but have only %d bytes left\n",
|
||||
(count + 2) * 4, cmdbuf->bufsz);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* Is it a packet type we know about ? */
|
||||
|
@ -600,7 +600,7 @@ static __inline__ int r300_emit_raw_packet3(drm_radeon_private_t *dev_priv,
|
|||
break;
|
||||
default:
|
||||
DRM_ERROR("Unknown packet3 header (0x%08x)\n", header);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
BEGIN_RING(count + 2);
|
||||
|
@ -664,7 +664,7 @@ static __inline__ int r300_emit_packet3(drm_radeon_private_t *dev_priv,
|
|||
DRM_ERROR("bad packet3 type %i at %p\n",
|
||||
header.packet3.packet,
|
||||
cmdbuf->buf - sizeof(header));
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
n += R300_SIMULTANEOUS_CLIPRECTS;
|
||||
|
@ -726,11 +726,11 @@ static int r300_scratch(drm_radeon_private_t *dev_priv,
|
|||
|
||||
if (cmdbuf->bufsz <
|
||||
(sizeof(u64) + header.scratch.n_bufs * sizeof(buf_idx))) {
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (header.scratch.reg >= 5) {
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
dev_priv->scratch_ages[header.scratch.reg]++;
|
||||
|
@ -745,21 +745,21 @@ static int r300_scratch(drm_radeon_private_t *dev_priv,
|
|||
buf_idx *= 2; /* 8 bytes per buf */
|
||||
|
||||
if (DRM_COPY_TO_USER(ref_age_base + buf_idx, &dev_priv->scratch_ages[header.scratch.reg], sizeof(u32))) {
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (DRM_COPY_FROM_USER(&h_pending, ref_age_base + buf_idx + 1, sizeof(u32))) {
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (h_pending == 0) {
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
h_pending--;
|
||||
|
||||
if (DRM_COPY_TO_USER(ref_age_base + buf_idx + 1, &h_pending, sizeof(u32))) {
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
cmdbuf->buf += sizeof(buf_idx);
|
||||
|
@ -780,8 +780,7 @@ static int r300_scratch(drm_radeon_private_t *dev_priv,
|
|||
* Called by the ioctl handler function radeon_cp_cmdbuf.
|
||||
*/
|
||||
int r300_do_cp_cmdbuf(struct drm_device *dev,
|
||||
DRMFILE filp,
|
||||
struct drm_file *filp_priv,
|
||||
struct drm_file *file_priv,
|
||||
drm_radeon_kcmd_buffer_t *cmdbuf)
|
||||
{
|
||||
drm_radeon_private_t *dev_priv = dev->dev_private;
|
||||
|
@ -879,15 +878,16 @@ int r300_do_cp_cmdbuf(struct drm_device *dev,
|
|||
if (idx < 0 || idx >= dma->buf_count) {
|
||||
DRM_ERROR("buffer index %d (of %d max)\n",
|
||||
idx, dma->buf_count - 1);
|
||||
ret = DRM_ERR(EINVAL);
|
||||
ret = -EINVAL;
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
buf = dma->buflist[idx];
|
||||
if (buf->filp != filp || buf->pending) {
|
||||
if (buf->file_priv != file_priv || buf->pending) {
|
||||
DRM_ERROR("bad buffer %p %p %d\n",
|
||||
buf->filp, filp, buf->pending);
|
||||
ret = DRM_ERR(EINVAL);
|
||||
buf->file_priv, file_priv,
|
||||
buf->pending);
|
||||
ret = -EINVAL;
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
|
@ -924,7 +924,7 @@ int r300_do_cp_cmdbuf(struct drm_device *dev,
|
|||
DRM_ERROR("bad cmd_type %i at %p\n",
|
||||
header.header.cmd_type,
|
||||
cmdbuf->buf - sizeof(header));
|
||||
ret = DRM_ERR(EINVAL);
|
||||
ret = -EINVAL;
|
||||
goto cleanup;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -889,7 +889,7 @@ static int radeon_do_pixcache_flush(drm_radeon_private_t * dev_priv)
|
|||
DRM_ERROR("failed!\n");
|
||||
radeon_status(dev_priv);
|
||||
#endif
|
||||
return DRM_ERR(EBUSY);
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
static int radeon_do_wait_for_fifo(drm_radeon_private_t * dev_priv, int entries)
|
||||
|
@ -910,7 +910,7 @@ static int radeon_do_wait_for_fifo(drm_radeon_private_t * dev_priv, int entries)
|
|||
DRM_ERROR("failed!\n");
|
||||
radeon_status(dev_priv);
|
||||
#endif
|
||||
return DRM_ERR(EBUSY);
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
static int radeon_do_wait_for_idle(drm_radeon_private_t * dev_priv)
|
||||
|
@ -936,7 +936,7 @@ static int radeon_do_wait_for_idle(drm_radeon_private_t * dev_priv)
|
|||
DRM_ERROR("failed!\n");
|
||||
radeon_status(dev_priv);
|
||||
#endif
|
||||
return DRM_ERR(EBUSY);
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
/* ================================================================
|
||||
|
@ -1394,7 +1394,7 @@ static int radeon_do_init_cp(struct drm_device * dev, drm_radeon_init_t * init)
|
|||
if ((dev_priv->flags & RADEON_NEW_MEMMAP) && !dev_priv->new_memmap) {
|
||||
DRM_ERROR("Cannot initialise DRM on this card\nThis card requires a new X.org DDX for 3D\n");
|
||||
radeon_do_cleanup_cp(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (init->is_pci && (dev_priv->flags & RADEON_IS_AGP)) {
|
||||
|
@ -1409,7 +1409,7 @@ static int radeon_do_init_cp(struct drm_device * dev, drm_radeon_init_t * init)
|
|||
if ((!(dev_priv->flags & RADEON_IS_AGP)) && !dev->sg) {
|
||||
DRM_ERROR("PCI GART memory not allocated!\n");
|
||||
radeon_do_cleanup_cp(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
dev_priv->usec_timeout = init->usec_timeout;
|
||||
|
@ -1417,7 +1417,7 @@ static int radeon_do_init_cp(struct drm_device * dev, drm_radeon_init_t * init)
|
|||
dev_priv->usec_timeout > RADEON_MAX_USEC_TIMEOUT) {
|
||||
DRM_DEBUG("TIMEOUT problem!\n");
|
||||
radeon_do_cleanup_cp(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* Enable vblank on CRTC1 for older X servers
|
||||
|
@ -1446,7 +1446,7 @@ static int radeon_do_init_cp(struct drm_device * dev, drm_radeon_init_t * init)
|
|||
(init->cp_mode != RADEON_CSQ_PRIBM_INDBM)) {
|
||||
DRM_DEBUG("BAD cp_mode (%x)!\n", init->cp_mode);
|
||||
radeon_do_cleanup_cp(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
switch (init->fb_bpp) {
|
||||
|
@ -1515,27 +1515,27 @@ static int radeon_do_init_cp(struct drm_device * dev, drm_radeon_init_t * init)
|
|||
if (!dev_priv->sarea) {
|
||||
DRM_ERROR("could not find sarea!\n");
|
||||
radeon_do_cleanup_cp(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
dev_priv->cp_ring = drm_core_findmap(dev, init->ring_offset);
|
||||
if (!dev_priv->cp_ring) {
|
||||
DRM_ERROR("could not find cp ring region!\n");
|
||||
radeon_do_cleanup_cp(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
dev_priv->ring_rptr = drm_core_findmap(dev, init->ring_rptr_offset);
|
||||
if (!dev_priv->ring_rptr) {
|
||||
DRM_ERROR("could not find ring read pointer!\n");
|
||||
radeon_do_cleanup_cp(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
dev->agp_buffer_token = init->buffers_offset;
|
||||
dev->agp_buffer_map = drm_core_findmap(dev, init->buffers_offset);
|
||||
if (!dev->agp_buffer_map) {
|
||||
DRM_ERROR("could not find dma buffer region!\n");
|
||||
radeon_do_cleanup_cp(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (init->gart_textures_offset) {
|
||||
|
@ -1544,7 +1544,7 @@ static int radeon_do_init_cp(struct drm_device * dev, drm_radeon_init_t * init)
|
|||
if (!dev_priv->gart_textures) {
|
||||
DRM_ERROR("could not find GART texture region!\n");
|
||||
radeon_do_cleanup_cp(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1562,7 +1562,7 @@ static int radeon_do_init_cp(struct drm_device * dev, drm_radeon_init_t * init)
|
|||
!dev->agp_buffer_map->handle) {
|
||||
DRM_ERROR("could not find ioremap agp regions!\n");
|
||||
radeon_do_cleanup_cp(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
} else
|
||||
#endif
|
||||
|
@ -1710,14 +1710,14 @@ static int radeon_do_init_cp(struct drm_device * dev, drm_radeon_init_t * init)
|
|||
DRM_ERROR
|
||||
("Cannot use PCI Express without GART in FB memory\n");
|
||||
radeon_do_cleanup_cp(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
if (!drm_ati_pcigart_init(dev, &dev_priv->gart_info)) {
|
||||
DRM_ERROR("failed to init PCI GART!\n");
|
||||
radeon_do_cleanup_cp(dev);
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
/* Turn on PCI GART */
|
||||
|
@ -1797,7 +1797,7 @@ static int radeon_do_resume_cp(struct drm_device * dev)
|
|||
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("Called with no initialization\n");
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
DRM_DEBUG("Starting radeon_do_resume_cp()\n");
|
||||
|
@ -1823,38 +1823,33 @@ static int radeon_do_resume_cp(struct drm_device * dev)
|
|||
return 0;
|
||||
}
|
||||
|
||||
int radeon_cp_init(DRM_IOCTL_ARGS)
|
||||
int radeon_cp_init(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_radeon_init_t init;
|
||||
drm_radeon_init_t *init = data;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(init, (drm_radeon_init_t __user *) data,
|
||||
sizeof(init));
|
||||
|
||||
if (init.func == RADEON_INIT_R300_CP)
|
||||
if (init->func == RADEON_INIT_R300_CP)
|
||||
r300_init_reg_flags();
|
||||
|
||||
switch (init.func) {
|
||||
switch (init->func) {
|
||||
case RADEON_INIT_CP:
|
||||
case RADEON_INIT_R200_CP:
|
||||
case RADEON_INIT_R300_CP:
|
||||
return radeon_do_init_cp(dev, &init);
|
||||
return radeon_do_init_cp(dev, init);
|
||||
case RADEON_CLEANUP_CP:
|
||||
return radeon_do_cleanup_cp(dev);
|
||||
}
|
||||
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
int radeon_cp_start(DRM_IOCTL_ARGS)
|
||||
int radeon_cp_start(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_radeon_private_t *dev_priv = dev->dev_private;
|
||||
DRM_DEBUG("\n");
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
if (dev_priv->cp_running) {
|
||||
DRM_DEBUG("%s while CP running\n", __FUNCTION__);
|
||||
|
@ -1874,18 +1869,14 @@ int radeon_cp_start(DRM_IOCTL_ARGS)
|
|||
/* Stop the CP. The engine must have been idled before calling this
|
||||
* routine.
|
||||
*/
|
||||
int radeon_cp_stop(DRM_IOCTL_ARGS)
|
||||
int radeon_cp_stop(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_radeon_private_t *dev_priv = dev->dev_private;
|
||||
drm_radeon_cp_stop_t stop;
|
||||
drm_radeon_cp_stop_t *stop = data;
|
||||
int ret;
|
||||
DRM_DEBUG("\n");
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(stop, (drm_radeon_cp_stop_t __user *) data,
|
||||
sizeof(stop));
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
if (!dev_priv->cp_running)
|
||||
return 0;
|
||||
|
@ -1893,14 +1884,14 @@ int radeon_cp_stop(DRM_IOCTL_ARGS)
|
|||
/* Flush any pending CP commands. This ensures any outstanding
|
||||
* commands are exectuted by the engine before we turn it off.
|
||||
*/
|
||||
if (stop.flush) {
|
||||
if (stop->flush) {
|
||||
radeon_do_cp_flush(dev_priv);
|
||||
}
|
||||
|
||||
/* If we fail to make the engine go idle, we return an error
|
||||
* code so that the DRM ioctl wrapper can try again.
|
||||
*/
|
||||
if (stop.idle) {
|
||||
if (stop->idle) {
|
||||
ret = radeon_do_cp_idle(dev_priv);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
@ -1963,17 +1954,16 @@ void radeon_do_release(struct drm_device * dev)
|
|||
|
||||
/* Just reset the CP ring. Called as part of an X Server engine reset.
|
||||
*/
|
||||
int radeon_cp_reset(DRM_IOCTL_ARGS)
|
||||
int radeon_cp_reset(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_radeon_private_t *dev_priv = dev->dev_private;
|
||||
DRM_DEBUG("\n");
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
if (!dev_priv) {
|
||||
DRM_DEBUG("%s called before init done\n", __FUNCTION__);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
radeon_do_cp_reset(dev_priv);
|
||||
|
@ -1984,32 +1974,29 @@ int radeon_cp_reset(DRM_IOCTL_ARGS)
|
|||
return 0;
|
||||
}
|
||||
|
||||
int radeon_cp_idle(DRM_IOCTL_ARGS)
|
||||
int radeon_cp_idle(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_radeon_private_t *dev_priv = dev->dev_private;
|
||||
DRM_DEBUG("\n");
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
return radeon_do_cp_idle(dev_priv);
|
||||
}
|
||||
|
||||
/* Added by Charl P. Botha to call radeon_do_resume_cp().
|
||||
*/
|
||||
int radeon_cp_resume(DRM_IOCTL_ARGS)
|
||||
int radeon_cp_resume(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
|
||||
return radeon_do_resume_cp(dev);
|
||||
}
|
||||
|
||||
int radeon_engine_reset(DRM_IOCTL_ARGS)
|
||||
int radeon_engine_reset(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
DRM_DEBUG("\n");
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
return radeon_do_engine_reset(dev);
|
||||
}
|
||||
|
@ -2020,7 +2007,7 @@ int radeon_engine_reset(DRM_IOCTL_ARGS)
|
|||
|
||||
/* KW: Deprecated to say the least:
|
||||
*/
|
||||
int radeon_fullscreen(DRM_IOCTL_ARGS)
|
||||
int radeon_fullscreen(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
@ -2066,8 +2053,9 @@ struct drm_buf *radeon_freelist_get(struct drm_device * dev)
|
|||
for (i = start; i < dma->buf_count; i++) {
|
||||
buf = dma->buflist[i];
|
||||
buf_priv = buf->dev_private;
|
||||
if (buf->filp == 0 || (buf->pending &&
|
||||
buf_priv->age <= done_age)) {
|
||||
if (buf->file_priv == NULL || (buf->pending &&
|
||||
buf_priv->age <=
|
||||
done_age)) {
|
||||
dev_priv->stats.requested_bufs++;
|
||||
buf->pending = 0;
|
||||
return buf;
|
||||
|
@ -2106,8 +2094,9 @@ struct drm_buf *radeon_freelist_get(struct drm_device * dev)
|
|||
for (i = start; i < dma->buf_count; i++) {
|
||||
buf = dma->buflist[i];
|
||||
buf_priv = buf->dev_private;
|
||||
if (buf->filp == 0 || (buf->pending &&
|
||||
buf_priv->age <= done_age)) {
|
||||
if (buf->file_priv == 0 || (buf->pending &&
|
||||
buf_priv->age <=
|
||||
done_age)) {
|
||||
dev_priv->stats.requested_bufs++;
|
||||
buf->pending = 0;
|
||||
return buf;
|
||||
|
@ -2167,10 +2156,11 @@ int radeon_wait_ring(drm_radeon_private_t * dev_priv, int n)
|
|||
radeon_status(dev_priv);
|
||||
DRM_ERROR("failed!\n");
|
||||
#endif
|
||||
return DRM_ERR(EBUSY);
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
static int radeon_cp_get_buffers(DRMFILE filp, struct drm_device * dev,
|
||||
static int radeon_cp_get_buffers(struct drm_device *dev,
|
||||
struct drm_file *file_priv,
|
||||
struct drm_dma * d)
|
||||
{
|
||||
int i;
|
||||
|
@ -2179,58 +2169,52 @@ static int radeon_cp_get_buffers(DRMFILE filp, struct drm_device * dev,
|
|||
for (i = d->granted_count; i < d->request_count; i++) {
|
||||
buf = radeon_freelist_get(dev);
|
||||
if (!buf)
|
||||
return DRM_ERR(EBUSY); /* NOTE: broken client */
|
||||
return -EBUSY; /* NOTE: broken client */
|
||||
|
||||
buf->filp = filp;
|
||||
buf->file_priv = file_priv;
|
||||
|
||||
if (DRM_COPY_TO_USER(&d->request_indices[i], &buf->idx,
|
||||
sizeof(buf->idx)))
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
if (DRM_COPY_TO_USER(&d->request_sizes[i], &buf->total,
|
||||
sizeof(buf->total)))
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
|
||||
d->granted_count++;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int radeon_cp_buffers(DRM_IOCTL_ARGS)
|
||||
int radeon_cp_buffers(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
struct drm_device_dma *dma = dev->dma;
|
||||
int ret = 0;
|
||||
struct drm_dma __user *argp = (void __user *)data;
|
||||
struct drm_dma d;
|
||||
struct drm_dma *d = data;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(d, argp, sizeof(d));
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
/* Please don't send us buffers.
|
||||
*/
|
||||
if (d.send_count != 0) {
|
||||
if (d->send_count != 0) {
|
||||
DRM_ERROR("Process %d trying to send %d buffers via drmDMA\n",
|
||||
DRM_CURRENTPID, d.send_count);
|
||||
return DRM_ERR(EINVAL);
|
||||
DRM_CURRENTPID, d->send_count);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* We'll send you buffers.
|
||||
*/
|
||||
if (d.request_count < 0 || d.request_count > dma->buf_count) {
|
||||
if (d->request_count < 0 || d->request_count > dma->buf_count) {
|
||||
DRM_ERROR("Process %d trying to get %d buffers (of %d max)\n",
|
||||
DRM_CURRENTPID, d.request_count, dma->buf_count);
|
||||
return DRM_ERR(EINVAL);
|
||||
DRM_CURRENTPID, d->request_count, dma->buf_count);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
d.granted_count = 0;
|
||||
d->granted_count = 0;
|
||||
|
||||
if (d.request_count) {
|
||||
ret = radeon_cp_get_buffers(filp, dev, &d);
|
||||
if (d->request_count) {
|
||||
ret = radeon_cp_get_buffers(dev, file_priv, d);
|
||||
}
|
||||
|
||||
DRM_COPY_TO_USER_IOCTL(argp, d, sizeof(d));
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
@ -2241,7 +2225,7 @@ int radeon_driver_load(struct drm_device *dev, unsigned long flags)
|
|||
|
||||
dev_priv = drm_alloc(sizeof(drm_radeon_private_t), DRM_MEM_DRIVER);
|
||||
if (dev_priv == NULL)
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
|
||||
memset(dev_priv, 0, sizeof(drm_radeon_private_t));
|
||||
dev->dev_private = (void *)dev_priv;
|
||||
|
|
|
@ -188,7 +188,7 @@ struct mem_block {
|
|||
struct mem_block *prev;
|
||||
int start;
|
||||
int size;
|
||||
DRMFILE filp; /* 0: free, -1: heap, other: real files */
|
||||
struct drm_file *file_priv; /* NULL: free, -1: heap, other: real files */
|
||||
};
|
||||
|
||||
struct radeon_surface {
|
||||
|
@ -203,7 +203,7 @@ struct radeon_virt_surface {
|
|||
u32 lower;
|
||||
u32 upper;
|
||||
u32 flags;
|
||||
DRMFILE filp;
|
||||
struct drm_file *file_priv;
|
||||
};
|
||||
|
||||
typedef struct drm_radeon_private {
|
||||
|
@ -307,7 +307,7 @@ typedef struct drm_radeon_kcmd_buffer {
|
|||
} drm_radeon_kcmd_buffer_t;
|
||||
|
||||
extern int radeon_no_wb;
|
||||
extern drm_ioctl_desc_t radeon_ioctls[];
|
||||
extern struct drm_ioctl_desc radeon_ioctls[];
|
||||
extern int radeon_max_ioctl;
|
||||
|
||||
/* Check whether the given hardware address is inside the framebuffer or the
|
||||
|
@ -326,15 +326,15 @@ static __inline__ int radeon_check_offset(drm_radeon_private_t *dev_priv,
|
|||
}
|
||||
|
||||
/* radeon_cp.c */
|
||||
extern int radeon_cp_init(DRM_IOCTL_ARGS);
|
||||
extern int radeon_cp_start(DRM_IOCTL_ARGS);
|
||||
extern int radeon_cp_stop(DRM_IOCTL_ARGS);
|
||||
extern int radeon_cp_reset(DRM_IOCTL_ARGS);
|
||||
extern int radeon_cp_idle(DRM_IOCTL_ARGS);
|
||||
extern int radeon_cp_resume(DRM_IOCTL_ARGS);
|
||||
extern int radeon_engine_reset(DRM_IOCTL_ARGS);
|
||||
extern int radeon_fullscreen(DRM_IOCTL_ARGS);
|
||||
extern int radeon_cp_buffers(DRM_IOCTL_ARGS);
|
||||
extern int radeon_cp_init(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
extern int radeon_cp_start(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
extern int radeon_cp_stop(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
extern int radeon_cp_reset(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
extern int radeon_cp_idle(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
extern int radeon_cp_resume(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
extern int radeon_engine_reset(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
extern int radeon_fullscreen(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
extern int radeon_cp_buffers(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
|
||||
extern void radeon_freelist_reset(struct drm_device * dev);
|
||||
extern struct drm_buf *radeon_freelist_get(struct drm_device * dev);
|
||||
|
@ -347,15 +347,16 @@ extern int radeon_driver_preinit(struct drm_device *dev, unsigned long flags);
|
|||
extern int radeon_presetup(struct drm_device *dev);
|
||||
extern int radeon_driver_postcleanup(struct drm_device *dev);
|
||||
|
||||
extern int radeon_mem_alloc(DRM_IOCTL_ARGS);
|
||||
extern int radeon_mem_free(DRM_IOCTL_ARGS);
|
||||
extern int radeon_mem_init_heap(DRM_IOCTL_ARGS);
|
||||
extern int radeon_mem_alloc(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
extern int radeon_mem_free(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
extern int radeon_mem_init_heap(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
extern void radeon_mem_takedown(struct mem_block **heap);
|
||||
extern void radeon_mem_release(DRMFILE filp, struct mem_block *heap);
|
||||
extern void radeon_mem_release(struct drm_file *file_priv,
|
||||
struct mem_block *heap);
|
||||
|
||||
/* radeon_irq.c */
|
||||
extern int radeon_irq_emit(DRM_IOCTL_ARGS);
|
||||
extern int radeon_irq_wait(DRM_IOCTL_ARGS);
|
||||
extern int radeon_irq_emit(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
extern int radeon_irq_wait(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
|
||||
extern void radeon_do_release(struct drm_device * dev);
|
||||
extern int radeon_driver_vblank_wait(struct drm_device * dev,
|
||||
|
@ -372,7 +373,7 @@ extern int radeon_vblank_crtc_set(struct drm_device *dev, int64_t value);
|
|||
extern int radeon_driver_load(struct drm_device *dev, unsigned long flags);
|
||||
extern int radeon_driver_unload(struct drm_device *dev);
|
||||
extern int radeon_driver_firstopen(struct drm_device *dev);
|
||||
extern void radeon_driver_preclose(struct drm_device * dev, DRMFILE filp);
|
||||
extern void radeon_driver_preclose(struct drm_device * dev, struct drm_file *file_priv);
|
||||
extern void radeon_driver_postclose(struct drm_device * dev, struct drm_file * filp);
|
||||
extern void radeon_driver_lastclose(struct drm_device * dev);
|
||||
extern int radeon_driver_open(struct drm_device * dev, struct drm_file * filp_priv);
|
||||
|
@ -382,8 +383,8 @@ extern long radeon_compat_ioctl(struct file *filp, unsigned int cmd,
|
|||
/* r300_cmdbuf.c */
|
||||
extern void r300_init_reg_flags(void);
|
||||
|
||||
extern int r300_do_cp_cmdbuf(struct drm_device * dev, DRMFILE filp,
|
||||
struct drm_file * filp_priv,
|
||||
extern int r300_do_cp_cmdbuf(struct drm_device * dev,
|
||||
struct drm_file *file_priv,
|
||||
drm_radeon_kcmd_buffer_t * cmdbuf);
|
||||
|
||||
/* Flags for stats.boxes
|
||||
|
|
|
@ -155,7 +155,7 @@ int radeon_driver_vblank_do_wait(struct drm_device * dev, unsigned int *sequence
|
|||
atomic_t *counter;
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (crtc == DRM_RADEON_VBLANK_CRTC1) {
|
||||
|
@ -165,7 +165,7 @@ int radeon_driver_vblank_do_wait(struct drm_device * dev, unsigned int *sequence
|
|||
counter = &dev->vbl_received2;
|
||||
ack |= RADEON_CRTC2_VBLANK_STAT;
|
||||
} else
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
|
||||
radeon_acknowledge_irqs(dev_priv, ack);
|
||||
|
||||
|
@ -196,28 +196,24 @@ int radeon_driver_vblank_wait2(struct drm_device *dev, unsigned int *sequence)
|
|||
|
||||
/* Needs the lock as it touches the ring.
|
||||
*/
|
||||
int radeon_irq_emit(DRM_IOCTL_ARGS)
|
||||
int radeon_irq_emit(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_radeon_private_t *dev_priv = dev->dev_private;
|
||||
drm_radeon_irq_emit_t emit;
|
||||
drm_radeon_irq_emit_t *emit = data;
|
||||
int result;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(emit, (drm_radeon_irq_emit_t __user *) data,
|
||||
sizeof(emit));
|
||||
|
||||
result = radeon_emit_irq(dev);
|
||||
|
||||
if (DRM_COPY_TO_USER(emit.irq_seq, &result, sizeof(int))) {
|
||||
if (DRM_COPY_TO_USER(emit->irq_seq, &result, sizeof(int))) {
|
||||
DRM_ERROR("copy_to_user\n");
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
@ -225,21 +221,17 @@ int radeon_irq_emit(DRM_IOCTL_ARGS)
|
|||
|
||||
/* Doesn't need the hardware lock.
|
||||
*/
|
||||
int radeon_irq_wait(DRM_IOCTL_ARGS)
|
||||
int radeon_irq_wait(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_radeon_private_t *dev_priv = dev->dev_private;
|
||||
drm_radeon_irq_wait_t irqwait;
|
||||
drm_radeon_irq_wait_t *irqwait = data;
|
||||
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(irqwait, (drm_radeon_irq_wait_t __user *) data,
|
||||
sizeof(irqwait));
|
||||
|
||||
return radeon_wait_irq(dev, irqwait.irq_seq);
|
||||
return radeon_wait_irq(dev, irqwait->irq_seq);
|
||||
}
|
||||
|
||||
static void radeon_enable_interrupt(struct drm_device *dev)
|
||||
|
@ -320,7 +312,7 @@ int radeon_vblank_crtc_set(struct drm_device *dev, int64_t value)
|
|||
drm_radeon_private_t *dev_priv = (drm_radeon_private_t *) dev->dev_private;
|
||||
if (value & ~(DRM_RADEON_VBLANK_CRTC1 | DRM_RADEON_VBLANK_CRTC2)) {
|
||||
DRM_ERROR("called with invalid crtc 0x%x\n", (unsigned int)value);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
dev_priv->vblank_crtc = (unsigned int)value;
|
||||
radeon_enable_interrupt(dev);
|
||||
|
|
|
@ -39,7 +39,7 @@
|
|||
*/
|
||||
|
||||
static struct mem_block *split_block(struct mem_block *p, int start, int size,
|
||||
DRMFILE filp)
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
/* Maybe cut off the start of an existing block */
|
||||
if (start > p->start) {
|
||||
|
@ -49,7 +49,7 @@ static struct mem_block *split_block(struct mem_block *p, int start, int size,
|
|||
goto out;
|
||||
newblock->start = start;
|
||||
newblock->size = p->size - (start - p->start);
|
||||
newblock->filp = NULL;
|
||||
newblock->file_priv = NULL;
|
||||
newblock->next = p->next;
|
||||
newblock->prev = p;
|
||||
p->next->prev = newblock;
|
||||
|
@ -66,7 +66,7 @@ static struct mem_block *split_block(struct mem_block *p, int start, int size,
|
|||
goto out;
|
||||
newblock->start = start + size;
|
||||
newblock->size = p->size - size;
|
||||
newblock->filp = NULL;
|
||||
newblock->file_priv = NULL;
|
||||
newblock->next = p->next;
|
||||
newblock->prev = p;
|
||||
p->next->prev = newblock;
|
||||
|
@ -76,20 +76,20 @@ static struct mem_block *split_block(struct mem_block *p, int start, int size,
|
|||
|
||||
out:
|
||||
/* Our block is in the middle */
|
||||
p->filp = filp;
|
||||
p->file_priv = file_priv;
|
||||
return p;
|
||||
}
|
||||
|
||||
static struct mem_block *alloc_block(struct mem_block *heap, int size,
|
||||
int align2, DRMFILE filp)
|
||||
int align2, struct drm_file *file_priv)
|
||||
{
|
||||
struct mem_block *p;
|
||||
int mask = (1 << align2) - 1;
|
||||
|
||||
list_for_each(p, heap) {
|
||||
int start = (p->start + mask) & ~mask;
|
||||
if (p->filp == 0 && start + size <= p->start + p->size)
|
||||
return split_block(p, start, size, filp);
|
||||
if (p->file_priv == 0 && start + size <= p->start + p->size)
|
||||
return split_block(p, start, size, file_priv);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
|
@ -108,12 +108,12 @@ static struct mem_block *find_block(struct mem_block *heap, int start)
|
|||
|
||||
static void free_block(struct mem_block *p)
|
||||
{
|
||||
p->filp = NULL;
|
||||
p->file_priv = NULL;
|
||||
|
||||
/* Assumes a single contiguous range. Needs a special filp in
|
||||
/* Assumes a single contiguous range. Needs a special file_priv in
|
||||
* 'heap' to stop it being subsumed.
|
||||
*/
|
||||
if (p->next->filp == 0) {
|
||||
if (p->next->file_priv == 0) {
|
||||
struct mem_block *q = p->next;
|
||||
p->size += q->size;
|
||||
p->next = q->next;
|
||||
|
@ -121,7 +121,7 @@ static void free_block(struct mem_block *p)
|
|||
drm_free(q, sizeof(*q), DRM_MEM_BUFS);
|
||||
}
|
||||
|
||||
if (p->prev->filp == 0) {
|
||||
if (p->prev->file_priv == 0) {
|
||||
struct mem_block *q = p->prev;
|
||||
q->size += p->size;
|
||||
q->next = p->next;
|
||||
|
@ -137,28 +137,28 @@ static int init_heap(struct mem_block **heap, int start, int size)
|
|||
struct mem_block *blocks = drm_alloc(sizeof(*blocks), DRM_MEM_BUFS);
|
||||
|
||||
if (!blocks)
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
|
||||
*heap = drm_alloc(sizeof(**heap), DRM_MEM_BUFS);
|
||||
if (!*heap) {
|
||||
drm_free(blocks, sizeof(*blocks), DRM_MEM_BUFS);
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
blocks->start = start;
|
||||
blocks->size = size;
|
||||
blocks->filp = NULL;
|
||||
blocks->file_priv = NULL;
|
||||
blocks->next = blocks->prev = *heap;
|
||||
|
||||
memset(*heap, 0, sizeof(**heap));
|
||||
(*heap)->filp = (DRMFILE) - 1;
|
||||
(*heap)->file_priv = (struct drm_file *) - 1;
|
||||
(*heap)->next = (*heap)->prev = blocks;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Free all blocks associated with the releasing file.
|
||||
*/
|
||||
void radeon_mem_release(DRMFILE filp, struct mem_block *heap)
|
||||
void radeon_mem_release(struct drm_file *file_priv, struct mem_block *heap)
|
||||
{
|
||||
struct mem_block *p;
|
||||
|
||||
|
@ -166,15 +166,15 @@ void radeon_mem_release(DRMFILE filp, struct mem_block *heap)
|
|||
return;
|
||||
|
||||
list_for_each(p, heap) {
|
||||
if (p->filp == filp)
|
||||
p->filp = NULL;
|
||||
if (p->file_priv == file_priv)
|
||||
p->file_priv = NULL;
|
||||
}
|
||||
|
||||
/* Assumes a single contiguous range. Needs a special filp in
|
||||
/* Assumes a single contiguous range. Needs a special file_priv in
|
||||
* 'heap' to stop it being subsumed.
|
||||
*/
|
||||
list_for_each(p, heap) {
|
||||
while (p->filp == 0 && p->next->filp == 0) {
|
||||
while (p->file_priv == 0 && p->next->file_priv == 0) {
|
||||
struct mem_block *q = p->next;
|
||||
p->size += q->size;
|
||||
p->next = q->next;
|
||||
|
@ -217,98 +217,86 @@ static struct mem_block **get_heap(drm_radeon_private_t * dev_priv, int region)
|
|||
}
|
||||
}
|
||||
|
||||
int radeon_mem_alloc(DRM_IOCTL_ARGS)
|
||||
int radeon_mem_alloc(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_radeon_private_t *dev_priv = dev->dev_private;
|
||||
drm_radeon_mem_alloc_t alloc;
|
||||
drm_radeon_mem_alloc_t *alloc = data;
|
||||
struct mem_block *block, **heap;
|
||||
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(alloc, (drm_radeon_mem_alloc_t __user *) data,
|
||||
sizeof(alloc));
|
||||
|
||||
heap = get_heap(dev_priv, alloc.region);
|
||||
heap = get_heap(dev_priv, alloc->region);
|
||||
if (!heap || !*heap)
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
|
||||
/* Make things easier on ourselves: all allocations at least
|
||||
* 4k aligned.
|
||||
*/
|
||||
if (alloc.alignment < 12)
|
||||
alloc.alignment = 12;
|
||||
if (alloc->alignment < 12)
|
||||
alloc->alignment = 12;
|
||||
|
||||
block = alloc_block(*heap, alloc.size, alloc.alignment, filp);
|
||||
block = alloc_block(*heap, alloc->size, alloc->alignment, file_priv);
|
||||
|
||||
if (!block)
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
|
||||
if (DRM_COPY_TO_USER(alloc.region_offset, &block->start, sizeof(int))) {
|
||||
if (DRM_COPY_TO_USER(alloc->region_offset, &block->start,
|
||||
sizeof(int))) {
|
||||
DRM_ERROR("copy_to_user\n");
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int radeon_mem_free(DRM_IOCTL_ARGS)
|
||||
int radeon_mem_free(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_radeon_private_t *dev_priv = dev->dev_private;
|
||||
drm_radeon_mem_free_t memfree;
|
||||
drm_radeon_mem_free_t *memfree = data;
|
||||
struct mem_block *block, **heap;
|
||||
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(memfree, (drm_radeon_mem_free_t __user *) data,
|
||||
sizeof(memfree));
|
||||
|
||||
heap = get_heap(dev_priv, memfree.region);
|
||||
heap = get_heap(dev_priv, memfree->region);
|
||||
if (!heap || !*heap)
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
|
||||
block = find_block(*heap, memfree.region_offset);
|
||||
block = find_block(*heap, memfree->region_offset);
|
||||
if (!block)
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
|
||||
if (block->filp != filp)
|
||||
return DRM_ERR(EPERM);
|
||||
if (block->file_priv != file_priv)
|
||||
return -EPERM;
|
||||
|
||||
free_block(block);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int radeon_mem_init_heap(DRM_IOCTL_ARGS)
|
||||
int radeon_mem_init_heap(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_radeon_private_t *dev_priv = dev->dev_private;
|
||||
drm_radeon_mem_init_heap_t initheap;
|
||||
drm_radeon_mem_init_heap_t *initheap = data;
|
||||
struct mem_block **heap;
|
||||
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(initheap,
|
||||
(drm_radeon_mem_init_heap_t __user *) data,
|
||||
sizeof(initheap));
|
||||
|
||||
heap = get_heap(dev_priv, initheap.region);
|
||||
heap = get_heap(dev_priv, initheap->region);
|
||||
if (!heap)
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
|
||||
if (*heap) {
|
||||
DRM_ERROR("heap already initialized?");
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
return init_heap(heap, initheap.start, initheap.size);
|
||||
return init_heap(heap, initheap->start, initheap->size);
|
||||
}
|
||||
|
|
File diff suppressed because it is too large
Load diff
|
@ -60,7 +60,7 @@ savage_bci_wait_fifo_shadow(drm_savage_private_t * dev_priv, unsigned int n)
|
|||
DRM_ERROR("failed!\n");
|
||||
DRM_INFO(" status=0x%08x, threshold=0x%08x\n", status, threshold);
|
||||
#endif
|
||||
return DRM_ERR(EBUSY);
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
static int
|
||||
|
@ -81,7 +81,7 @@ savage_bci_wait_fifo_s3d(drm_savage_private_t * dev_priv, unsigned int n)
|
|||
DRM_ERROR("failed!\n");
|
||||
DRM_INFO(" status=0x%08x\n", status);
|
||||
#endif
|
||||
return DRM_ERR(EBUSY);
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
static int
|
||||
|
@ -102,7 +102,7 @@ savage_bci_wait_fifo_s4(drm_savage_private_t * dev_priv, unsigned int n)
|
|||
DRM_ERROR("failed!\n");
|
||||
DRM_INFO(" status=0x%08x\n", status);
|
||||
#endif
|
||||
return DRM_ERR(EBUSY);
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -136,7 +136,7 @@ savage_bci_wait_event_shadow(drm_savage_private_t * dev_priv, uint16_t e)
|
|||
DRM_INFO(" status=0x%08x, e=0x%04x\n", status, e);
|
||||
#endif
|
||||
|
||||
return DRM_ERR(EBUSY);
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
static int
|
||||
|
@ -158,7 +158,7 @@ savage_bci_wait_event_reg(drm_savage_private_t * dev_priv, uint16_t e)
|
|||
DRM_INFO(" status=0x%08x, e=0x%04x\n", status, e);
|
||||
#endif
|
||||
|
||||
return DRM_ERR(EBUSY);
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
uint16_t savage_bci_emit_event(drm_savage_private_t * dev_priv,
|
||||
|
@ -301,7 +301,7 @@ static int savage_dma_init(drm_savage_private_t * dev_priv)
|
|||
dev_priv->dma_pages = drm_alloc(sizeof(drm_savage_dma_page_t) *
|
||||
dev_priv->nr_dma_pages, DRM_MEM_DRIVER);
|
||||
if (dev_priv->dma_pages == NULL)
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
|
||||
for (i = 0; i < dev_priv->nr_dma_pages; ++i) {
|
||||
SET_AGE(&dev_priv->dma_pages[i].age, 0, 0);
|
||||
|
@ -541,7 +541,7 @@ int savage_driver_load(struct drm_device *dev, unsigned long chipset)
|
|||
|
||||
dev_priv = drm_alloc(sizeof(drm_savage_private_t), DRM_MEM_DRIVER);
|
||||
if (dev_priv == NULL)
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
|
||||
memset(dev_priv, 0, sizeof(drm_savage_private_t));
|
||||
dev->dev_private = (void *)dev_priv;
|
||||
|
@ -682,16 +682,16 @@ static int savage_do_init_bci(struct drm_device * dev, drm_savage_init_t * init)
|
|||
|
||||
if (init->fb_bpp != 16 && init->fb_bpp != 32) {
|
||||
DRM_ERROR("invalid frame buffer bpp %d!\n", init->fb_bpp);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
if (init->depth_bpp != 16 && init->depth_bpp != 32) {
|
||||
DRM_ERROR("invalid depth buffer bpp %d!\n", init->fb_bpp);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
if (init->dma_type != SAVAGE_DMA_AGP &&
|
||||
init->dma_type != SAVAGE_DMA_PCI) {
|
||||
DRM_ERROR("invalid dma memory type %d!\n", init->dma_type);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
dev_priv->cob_size = init->cob_size;
|
||||
|
@ -715,14 +715,14 @@ static int savage_do_init_bci(struct drm_device * dev, drm_savage_init_t * init)
|
|||
if (!dev_priv->sarea) {
|
||||
DRM_ERROR("could not find sarea!\n");
|
||||
savage_do_cleanup_bci(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
if (init->status_offset != 0) {
|
||||
dev_priv->status = drm_core_findmap(dev, init->status_offset);
|
||||
if (!dev_priv->status) {
|
||||
DRM_ERROR("could not find shadow status region!\n");
|
||||
savage_do_cleanup_bci(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
} else {
|
||||
dev_priv->status = NULL;
|
||||
|
@ -734,13 +734,13 @@ static int savage_do_init_bci(struct drm_device * dev, drm_savage_init_t * init)
|
|||
if (!dev->agp_buffer_map) {
|
||||
DRM_ERROR("could not find DMA buffer region!\n");
|
||||
savage_do_cleanup_bci(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
drm_core_ioremap(dev->agp_buffer_map, dev);
|
||||
if (!dev->agp_buffer_map) {
|
||||
DRM_ERROR("failed to ioremap DMA buffer region!\n");
|
||||
savage_do_cleanup_bci(dev);
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
}
|
||||
if (init->agp_textures_offset) {
|
||||
|
@ -749,7 +749,7 @@ static int savage_do_init_bci(struct drm_device * dev, drm_savage_init_t * init)
|
|||
if (!dev_priv->agp_textures) {
|
||||
DRM_ERROR("could not find agp texture region!\n");
|
||||
savage_do_cleanup_bci(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
} else {
|
||||
dev_priv->agp_textures = NULL;
|
||||
|
@ -760,39 +760,39 @@ static int savage_do_init_bci(struct drm_device * dev, drm_savage_init_t * init)
|
|||
DRM_ERROR("command DMA not supported on "
|
||||
"Savage3D/MX/IX.\n");
|
||||
savage_do_cleanup_bci(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
if (dev->dma && dev->dma->buflist) {
|
||||
DRM_ERROR("command and vertex DMA not supported "
|
||||
"at the same time.\n");
|
||||
savage_do_cleanup_bci(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
dev_priv->cmd_dma = drm_core_findmap(dev, init->cmd_dma_offset);
|
||||
if (!dev_priv->cmd_dma) {
|
||||
DRM_ERROR("could not find command DMA region!\n");
|
||||
savage_do_cleanup_bci(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
if (dev_priv->dma_type == SAVAGE_DMA_AGP) {
|
||||
if (dev_priv->cmd_dma->type != _DRM_AGP) {
|
||||
DRM_ERROR("AGP command DMA region is not a "
|
||||
"_DRM_AGP map!\n");
|
||||
savage_do_cleanup_bci(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
drm_core_ioremap(dev_priv->cmd_dma, dev);
|
||||
if (!dev_priv->cmd_dma->handle) {
|
||||
DRM_ERROR("failed to ioremap command "
|
||||
"DMA region!\n");
|
||||
savage_do_cleanup_bci(dev);
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
} else if (dev_priv->cmd_dma->type != _DRM_CONSISTENT) {
|
||||
DRM_ERROR("PCI command DMA region is not a "
|
||||
"_DRM_CONSISTENT map!\n");
|
||||
savage_do_cleanup_bci(dev);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
} else {
|
||||
dev_priv->cmd_dma = NULL;
|
||||
|
@ -809,7 +809,7 @@ static int savage_do_init_bci(struct drm_device * dev, drm_savage_init_t * init)
|
|||
if (!dev_priv->fake_dma.handle) {
|
||||
DRM_ERROR("could not allocate faked DMA buffer!\n");
|
||||
savage_do_cleanup_bci(dev);
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
dev_priv->cmd_dma = &dev_priv->fake_dma;
|
||||
dev_priv->dma_flush = savage_fake_dma_flush;
|
||||
|
@ -886,13 +886,13 @@ static int savage_do_init_bci(struct drm_device * dev, drm_savage_init_t * init)
|
|||
if (savage_freelist_init(dev) < 0) {
|
||||
DRM_ERROR("could not initialize freelist\n");
|
||||
savage_do_cleanup_bci(dev);
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
if (savage_dma_init(dev_priv) < 0) {
|
||||
DRM_ERROR("could not initialize command DMA\n");
|
||||
savage_do_cleanup_bci(dev);
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
@ -928,51 +928,41 @@ static int savage_do_cleanup_bci(struct drm_device * dev)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int savage_bci_init(DRM_IOCTL_ARGS)
|
||||
static int savage_bci_init(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_savage_init_t init;
|
||||
drm_savage_init_t *init = data;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(init, (drm_savage_init_t __user *) data,
|
||||
sizeof(init));
|
||||
|
||||
switch (init.func) {
|
||||
switch (init->func) {
|
||||
case SAVAGE_INIT_BCI:
|
||||
return savage_do_init_bci(dev, &init);
|
||||
return savage_do_init_bci(dev, init);
|
||||
case SAVAGE_CLEANUP_BCI:
|
||||
return savage_do_cleanup_bci(dev);
|
||||
}
|
||||
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
static int savage_bci_event_emit(DRM_IOCTL_ARGS)
|
||||
static int savage_bci_event_emit(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_savage_private_t *dev_priv = dev->dev_private;
|
||||
drm_savage_event_emit_t event;
|
||||
drm_savage_event_emit_t *event = data;
|
||||
|
||||
DRM_DEBUG("\n");
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(event, (drm_savage_event_emit_t __user *) data,
|
||||
sizeof(event));
|
||||
event->count = savage_bci_emit_event(dev_priv, event->flags);
|
||||
event->count |= dev_priv->event_wrap << 16;
|
||||
|
||||
event.count = savage_bci_emit_event(dev_priv, event.flags);
|
||||
event.count |= dev_priv->event_wrap << 16;
|
||||
DRM_COPY_TO_USER_IOCTL((drm_savage_event_emit_t __user *) data,
|
||||
event, sizeof(event));
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int savage_bci_event_wait(DRM_IOCTL_ARGS)
|
||||
static int savage_bci_event_wait(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_savage_private_t *dev_priv = dev->dev_private;
|
||||
drm_savage_event_wait_t event;
|
||||
drm_savage_event_wait_t *event = data;
|
||||
unsigned int event_e, hw_e;
|
||||
unsigned int event_w, hw_w;
|
||||
|
||||
|
@ -990,8 +980,8 @@ static int savage_bci_event_wait(DRM_IOCTL_ARGS)
|
|||
if (hw_e > dev_priv->event_counter)
|
||||
hw_w--; /* hardware hasn't passed the last wrap yet */
|
||||
|
||||
event_e = event.count & 0xffff;
|
||||
event_w = event.count >> 16;
|
||||
event_e = event->count & 0xffff;
|
||||
event_w = event->count >> 16;
|
||||
|
||||
/* Don't need to wait if
|
||||
* - event counter wrapped since the event was emitted or
|
||||
|
@ -1007,7 +997,9 @@ static int savage_bci_event_wait(DRM_IOCTL_ARGS)
|
|||
* DMA buffer management
|
||||
*/
|
||||
|
||||
static int savage_bci_get_buffers(DRMFILE filp, struct drm_device *dev, struct drm_dma *d)
|
||||
static int savage_bci_get_buffers(struct drm_device *dev,
|
||||
struct drm_file *file_priv,
|
||||
struct drm_dma *d)
|
||||
{
|
||||
struct drm_buf *buf;
|
||||
int i;
|
||||
|
@ -1015,61 +1007,56 @@ static int savage_bci_get_buffers(DRMFILE filp, struct drm_device *dev, struct d
|
|||
for (i = d->granted_count; i < d->request_count; i++) {
|
||||
buf = savage_freelist_get(dev);
|
||||
if (!buf)
|
||||
return DRM_ERR(EAGAIN);
|
||||
return -EAGAIN;
|
||||
|
||||
buf->filp = filp;
|
||||
buf->file_priv = file_priv;
|
||||
|
||||
if (DRM_COPY_TO_USER(&d->request_indices[i],
|
||||
&buf->idx, sizeof(buf->idx)))
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
if (DRM_COPY_TO_USER(&d->request_sizes[i],
|
||||
&buf->total, sizeof(buf->total)))
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
|
||||
d->granted_count++;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int savage_bci_buffers(DRM_IOCTL_ARGS)
|
||||
int savage_bci_buffers(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
struct drm_device_dma *dma = dev->dma;
|
||||
struct drm_dma d;
|
||||
struct drm_dma *d = data;
|
||||
int ret = 0;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(d, (struct drm_dma __user *) data, sizeof(d));
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
/* Please don't send us buffers.
|
||||
*/
|
||||
if (d.send_count != 0) {
|
||||
if (d->send_count != 0) {
|
||||
DRM_ERROR("Process %d trying to send %d buffers via drmDMA\n",
|
||||
DRM_CURRENTPID, d.send_count);
|
||||
return DRM_ERR(EINVAL);
|
||||
DRM_CURRENTPID, d->send_count);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* We'll send you buffers.
|
||||
*/
|
||||
if (d.request_count < 0 || d.request_count > dma->buf_count) {
|
||||
if (d->request_count < 0 || d->request_count > dma->buf_count) {
|
||||
DRM_ERROR("Process %d trying to get %d buffers (of %d max)\n",
|
||||
DRM_CURRENTPID, d.request_count, dma->buf_count);
|
||||
return DRM_ERR(EINVAL);
|
||||
DRM_CURRENTPID, d->request_count, dma->buf_count);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
d.granted_count = 0;
|
||||
d->granted_count = 0;
|
||||
|
||||
if (d.request_count) {
|
||||
ret = savage_bci_get_buffers(filp, dev, &d);
|
||||
if (d->request_count) {
|
||||
ret = savage_bci_get_buffers(dev, file_priv, d);
|
||||
}
|
||||
|
||||
DRM_COPY_TO_USER_IOCTL((struct drm_dma __user *) data, d, sizeof(d));
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
void savage_reclaim_buffers(struct drm_device *dev, DRMFILE filp)
|
||||
void savage_reclaim_buffers(struct drm_device *dev, struct drm_file *file_priv)
|
||||
{
|
||||
struct drm_device_dma *dma = dev->dma;
|
||||
drm_savage_private_t *dev_priv = dev->dev_private;
|
||||
|
@ -1088,7 +1075,7 @@ void savage_reclaim_buffers(struct drm_device *dev, DRMFILE filp)
|
|||
struct drm_buf *buf = dma->buflist[i];
|
||||
drm_savage_buf_priv_t *buf_priv = buf->dev_private;
|
||||
|
||||
if (buf->filp == filp && buf_priv &&
|
||||
if (buf->file_priv == file_priv && buf_priv &&
|
||||
buf_priv->next == NULL && buf_priv->prev == NULL) {
|
||||
uint16_t event;
|
||||
DRM_DEBUG("reclaimed from client\n");
|
||||
|
@ -1098,14 +1085,14 @@ void savage_reclaim_buffers(struct drm_device *dev, DRMFILE filp)
|
|||
}
|
||||
}
|
||||
|
||||
drm_core_reclaim_buffers(dev, filp);
|
||||
drm_core_reclaim_buffers(dev, file_priv);
|
||||
}
|
||||
|
||||
drm_ioctl_desc_t savage_ioctls[] = {
|
||||
[DRM_IOCTL_NR(DRM_SAVAGE_BCI_INIT)] = {savage_bci_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_SAVAGE_BCI_CMDBUF)] = {savage_bci_cmdbuf, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_SAVAGE_BCI_EVENT_EMIT)] = {savage_bci_event_emit, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_SAVAGE_BCI_EVENT_WAIT)] = {savage_bci_event_wait, DRM_AUTH},
|
||||
struct drm_ioctl_desc savage_ioctls[] = {
|
||||
DRM_IOCTL_DEF(DRM_SAVAGE_BCI_INIT, savage_bci_init, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_SAVAGE_BCI_CMDBUF, savage_bci_cmdbuf, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_SAVAGE_BCI_EVENT_EMIT, savage_bci_event_emit, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_SAVAGE_BCI_EVENT_WAIT, savage_bci_event_wait, DRM_AUTH),
|
||||
};
|
||||
|
||||
int savage_max_ioctl = DRM_ARRAY_SIZE(savage_ioctls);
|
||||
|
|
|
@ -104,7 +104,7 @@ enum savage_family {
|
|||
S3_LAST
|
||||
};
|
||||
|
||||
extern drm_ioctl_desc_t savage_ioctls[];
|
||||
extern struct drm_ioctl_desc savage_ioctls[];
|
||||
extern int savage_max_ioctl;
|
||||
|
||||
#define S3_SAVAGE3D_SERIES(chip) ((chip>=S3_SAVAGE3D) && (chip<=S3_SAVAGE_MX))
|
||||
|
@ -197,8 +197,8 @@ typedef struct drm_savage_private {
|
|||
} drm_savage_private_t;
|
||||
|
||||
/* ioctls */
|
||||
extern int savage_bci_cmdbuf(DRM_IOCTL_ARGS);
|
||||
extern int savage_bci_buffers(DRM_IOCTL_ARGS);
|
||||
extern int savage_bci_cmdbuf(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
extern int savage_bci_buffers(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
|
||||
/* BCI functions */
|
||||
extern uint16_t savage_bci_emit_event(drm_savage_private_t * dev_priv,
|
||||
|
@ -212,7 +212,8 @@ extern int savage_driver_load(struct drm_device *dev, unsigned long chipset);
|
|||
extern int savage_driver_firstopen(struct drm_device *dev);
|
||||
extern void savage_driver_lastclose(struct drm_device *dev);
|
||||
extern int savage_driver_unload(struct drm_device *dev);
|
||||
extern void savage_reclaim_buffers(struct drm_device * dev, DRMFILE filp);
|
||||
extern void savage_reclaim_buffers(struct drm_device *dev,
|
||||
struct drm_file *file_priv);
|
||||
|
||||
/* state functions */
|
||||
extern void savage_emit_clip_rect_s3d(drm_savage_private_t * dev_priv,
|
||||
|
|
|
@ -83,7 +83,7 @@ static int savage_verify_texaddr(drm_savage_private_t * dev_priv, int unit,
|
|||
{
|
||||
if ((addr & 6) != 2) { /* reserved bits */
|
||||
DRM_ERROR("bad texAddr%d %08x (reserved bits)\n", unit, addr);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
if (!(addr & 1)) { /* local */
|
||||
addr &= ~7;
|
||||
|
@ -92,13 +92,13 @@ static int savage_verify_texaddr(drm_savage_private_t * dev_priv, int unit,
|
|||
DRM_ERROR
|
||||
("bad texAddr%d %08x (local addr out of range)\n",
|
||||
unit, addr);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
} else { /* AGP */
|
||||
if (!dev_priv->agp_textures) {
|
||||
DRM_ERROR("bad texAddr%d %08x (AGP not available)\n",
|
||||
unit, addr);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
addr &= ~7;
|
||||
if (addr < dev_priv->agp_textures->offset ||
|
||||
|
@ -107,7 +107,7 @@ static int savage_verify_texaddr(drm_savage_private_t * dev_priv, int unit,
|
|||
DRM_ERROR
|
||||
("bad texAddr%d %08x (AGP addr out of range)\n",
|
||||
unit, addr);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
|
@ -133,7 +133,7 @@ static int savage_verify_state_s3d(drm_savage_private_t * dev_priv,
|
|||
start + count - 1 > SAVAGE_DESTTEXRWWATERMARK_S3D) {
|
||||
DRM_ERROR("invalid register range (0x%04x-0x%04x)\n",
|
||||
start, start + count - 1);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
SAVE_STATE_MASK(SAVAGE_SCSTART_S3D, s3d.new_scstart,
|
||||
|
@ -165,7 +165,7 @@ static int savage_verify_state_s4(drm_savage_private_t * dev_priv,
|
|||
start + count - 1 > SAVAGE_TEXBLENDCOLOR_S4) {
|
||||
DRM_ERROR("invalid register range (0x%04x-0x%04x)\n",
|
||||
start, start + count - 1);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
SAVE_STATE_MASK(SAVAGE_DRAWCTRL0_S4, s4.new_drawctrl0,
|
||||
|
@ -289,7 +289,7 @@ static int savage_dispatch_dma_prim(drm_savage_private_t * dev_priv,
|
|||
|
||||
if (!dmabuf) {
|
||||
DRM_ERROR("called without dma buffers!\n");
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (!n)
|
||||
|
@ -303,7 +303,7 @@ static int savage_dispatch_dma_prim(drm_savage_private_t * dev_priv,
|
|||
if (n % 3 != 0) {
|
||||
DRM_ERROR("wrong number of vertices %u in TRILIST\n",
|
||||
n);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
break;
|
||||
case SAVAGE_PRIM_TRISTRIP:
|
||||
|
@ -312,18 +312,18 @@ static int savage_dispatch_dma_prim(drm_savage_private_t * dev_priv,
|
|||
DRM_ERROR
|
||||
("wrong number of vertices %u in TRIFAN/STRIP\n",
|
||||
n);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
DRM_ERROR("invalid primitive type %u\n", prim);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (S3_SAVAGE3D_SERIES(dev_priv->chipset)) {
|
||||
if (skip != 0) {
|
||||
DRM_ERROR("invalid skip flags 0x%04x for DMA\n", skip);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
} else {
|
||||
unsigned int size = 10 - (skip & 1) - (skip >> 1 & 1) -
|
||||
|
@ -331,18 +331,18 @@ static int savage_dispatch_dma_prim(drm_savage_private_t * dev_priv,
|
|||
(skip >> 5 & 1) - (skip >> 6 & 1) - (skip >> 7 & 1);
|
||||
if (skip > SAVAGE_SKIP_ALL_S4 || size != 8) {
|
||||
DRM_ERROR("invalid skip flags 0x%04x for DMA\n", skip);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
if (reorder) {
|
||||
DRM_ERROR("TRILIST_201 used on Savage4 hardware\n");
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
if (start + n > dmabuf->total / 32) {
|
||||
DRM_ERROR("vertex indices (%u-%u) out of range (0-%u)\n",
|
||||
start, start + n - 1, dmabuf->total / 32);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* Vertex DMA doesn't work with command DMA at the same time,
|
||||
|
@ -440,7 +440,7 @@ static int savage_dispatch_vb_prim(drm_savage_private_t * dev_priv,
|
|||
if (n % 3 != 0) {
|
||||
DRM_ERROR("wrong number of vertices %u in TRILIST\n",
|
||||
n);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
break;
|
||||
case SAVAGE_PRIM_TRISTRIP:
|
||||
|
@ -449,24 +449,24 @@ static int savage_dispatch_vb_prim(drm_savage_private_t * dev_priv,
|
|||
DRM_ERROR
|
||||
("wrong number of vertices %u in TRIFAN/STRIP\n",
|
||||
n);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
DRM_ERROR("invalid primitive type %u\n", prim);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (S3_SAVAGE3D_SERIES(dev_priv->chipset)) {
|
||||
if (skip > SAVAGE_SKIP_ALL_S3D) {
|
||||
DRM_ERROR("invalid skip flags 0x%04x\n", skip);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
vtx_size = 8; /* full vertex */
|
||||
} else {
|
||||
if (skip > SAVAGE_SKIP_ALL_S4) {
|
||||
DRM_ERROR("invalid skip flags 0x%04x\n", skip);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
vtx_size = 10; /* full vertex */
|
||||
}
|
||||
|
@ -478,13 +478,13 @@ static int savage_dispatch_vb_prim(drm_savage_private_t * dev_priv,
|
|||
if (vtx_size > vb_stride) {
|
||||
DRM_ERROR("vertex size greater than vb stride (%u > %u)\n",
|
||||
vtx_size, vb_stride);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (start + n > vb_size / (vb_stride * 4)) {
|
||||
DRM_ERROR("vertex indices (%u-%u) out of range (0-%u)\n",
|
||||
start, start + n - 1, vb_size / (vb_stride * 4));
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
prim <<= 25;
|
||||
|
@ -547,7 +547,7 @@ static int savage_dispatch_dma_idx(drm_savage_private_t * dev_priv,
|
|||
|
||||
if (!dmabuf) {
|
||||
DRM_ERROR("called without dma buffers!\n");
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (!n)
|
||||
|
@ -560,7 +560,7 @@ static int savage_dispatch_dma_idx(drm_savage_private_t * dev_priv,
|
|||
case SAVAGE_PRIM_TRILIST:
|
||||
if (n % 3 != 0) {
|
||||
DRM_ERROR("wrong number of indices %u in TRILIST\n", n);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
break;
|
||||
case SAVAGE_PRIM_TRISTRIP:
|
||||
|
@ -568,18 +568,18 @@ static int savage_dispatch_dma_idx(drm_savage_private_t * dev_priv,
|
|||
if (n < 3) {
|
||||
DRM_ERROR
|
||||
("wrong number of indices %u in TRIFAN/STRIP\n", n);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
DRM_ERROR("invalid primitive type %u\n", prim);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (S3_SAVAGE3D_SERIES(dev_priv->chipset)) {
|
||||
if (skip != 0) {
|
||||
DRM_ERROR("invalid skip flags 0x%04x for DMA\n", skip);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
} else {
|
||||
unsigned int size = 10 - (skip & 1) - (skip >> 1 & 1) -
|
||||
|
@ -587,11 +587,11 @@ static int savage_dispatch_dma_idx(drm_savage_private_t * dev_priv,
|
|||
(skip >> 5 & 1) - (skip >> 6 & 1) - (skip >> 7 & 1);
|
||||
if (skip > SAVAGE_SKIP_ALL_S4 || size != 8) {
|
||||
DRM_ERROR("invalid skip flags 0x%04x for DMA\n", skip);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
if (reorder) {
|
||||
DRM_ERROR("TRILIST_201 used on Savage4 hardware\n");
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -628,7 +628,7 @@ static int savage_dispatch_dma_idx(drm_savage_private_t * dev_priv,
|
|||
if (idx[i] > dmabuf->total / 32) {
|
||||
DRM_ERROR("idx[%u]=%u out of range (0-%u)\n",
|
||||
i, idx[i], dmabuf->total / 32);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -698,7 +698,7 @@ static int savage_dispatch_vb_idx(drm_savage_private_t * dev_priv,
|
|||
case SAVAGE_PRIM_TRILIST:
|
||||
if (n % 3 != 0) {
|
||||
DRM_ERROR("wrong number of indices %u in TRILIST\n", n);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
break;
|
||||
case SAVAGE_PRIM_TRISTRIP:
|
||||
|
@ -706,24 +706,24 @@ static int savage_dispatch_vb_idx(drm_savage_private_t * dev_priv,
|
|||
if (n < 3) {
|
||||
DRM_ERROR
|
||||
("wrong number of indices %u in TRIFAN/STRIP\n", n);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
DRM_ERROR("invalid primitive type %u\n", prim);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (S3_SAVAGE3D_SERIES(dev_priv->chipset)) {
|
||||
if (skip > SAVAGE_SKIP_ALL_S3D) {
|
||||
DRM_ERROR("invalid skip flags 0x%04x\n", skip);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
vtx_size = 8; /* full vertex */
|
||||
} else {
|
||||
if (skip > SAVAGE_SKIP_ALL_S4) {
|
||||
DRM_ERROR("invalid skip flags 0x%04x\n", skip);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
vtx_size = 10; /* full vertex */
|
||||
}
|
||||
|
@ -735,7 +735,7 @@ static int savage_dispatch_vb_idx(drm_savage_private_t * dev_priv,
|
|||
if (vtx_size > vb_stride) {
|
||||
DRM_ERROR("vertex size greater than vb stride (%u > %u)\n",
|
||||
vtx_size, vb_stride);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
prim <<= 25;
|
||||
|
@ -748,7 +748,7 @@ static int savage_dispatch_vb_idx(drm_savage_private_t * dev_priv,
|
|||
if (idx[i] > vb_size / (vb_stride * 4)) {
|
||||
DRM_ERROR("idx[%u]=%u out of range (0-%u)\n",
|
||||
i, idx[i], vb_size / (vb_stride * 4));
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -942,7 +942,7 @@ static int savage_dispatch_draw(drm_savage_private_t * dev_priv,
|
|||
DRM_ERROR("IMPLEMENTATION ERROR: "
|
||||
"non-drawing-command %d\n",
|
||||
cmd_header.cmd.cmd);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (ret != 0)
|
||||
|
@ -953,13 +953,12 @@ static int savage_dispatch_draw(drm_savage_private_t * dev_priv,
|
|||
return 0;
|
||||
}
|
||||
|
||||
int savage_bci_cmdbuf(DRM_IOCTL_ARGS)
|
||||
int savage_bci_cmdbuf(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_savage_private_t *dev_priv = dev->dev_private;
|
||||
struct drm_device_dma *dma = dev->dma;
|
||||
struct drm_buf *dmabuf;
|
||||
drm_savage_cmdbuf_t cmdbuf;
|
||||
drm_savage_cmdbuf_t *cmdbuf = data;
|
||||
drm_savage_cmd_header_t *kcmd_addr = NULL;
|
||||
drm_savage_cmd_header_t *first_draw_cmd;
|
||||
unsigned int *kvb_addr = NULL;
|
||||
|
@ -969,19 +968,16 @@ int savage_bci_cmdbuf(DRM_IOCTL_ARGS)
|
|||
|
||||
DRM_DEBUG("\n");
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(cmdbuf, (drm_savage_cmdbuf_t __user *) data,
|
||||
sizeof(cmdbuf));
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
if (dma && dma->buflist) {
|
||||
if (cmdbuf.dma_idx > dma->buf_count) {
|
||||
if (cmdbuf->dma_idx > dma->buf_count) {
|
||||
DRM_ERROR
|
||||
("vertex buffer index %u out of range (0-%u)\n",
|
||||
cmdbuf.dma_idx, dma->buf_count - 1);
|
||||
return DRM_ERR(EINVAL);
|
||||
cmdbuf->dma_idx, dma->buf_count - 1);
|
||||
return -EINVAL;
|
||||
}
|
||||
dmabuf = dma->buflist[cmdbuf.dma_idx];
|
||||
dmabuf = dma->buflist[cmdbuf->dma_idx];
|
||||
} else {
|
||||
dmabuf = NULL;
|
||||
}
|
||||
|
@ -991,47 +987,47 @@ int savage_bci_cmdbuf(DRM_IOCTL_ARGS)
|
|||
* COPY_FROM_USER_UNCHECKED when done in other drivers, and is correct
|
||||
* for locking on FreeBSD.
|
||||
*/
|
||||
if (cmdbuf.size) {
|
||||
kcmd_addr = drm_alloc(cmdbuf.size * 8, DRM_MEM_DRIVER);
|
||||
if (cmdbuf->size) {
|
||||
kcmd_addr = drm_alloc(cmdbuf->size * 8, DRM_MEM_DRIVER);
|
||||
if (kcmd_addr == NULL)
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
|
||||
if (DRM_COPY_FROM_USER(kcmd_addr, cmdbuf.cmd_addr,
|
||||
cmdbuf.size * 8))
|
||||
if (DRM_COPY_FROM_USER(kcmd_addr, cmdbuf->cmd_addr,
|
||||
cmdbuf->size * 8))
|
||||
{
|
||||
drm_free(kcmd_addr, cmdbuf.size * 8, DRM_MEM_DRIVER);
|
||||
return DRM_ERR(EFAULT);
|
||||
drm_free(kcmd_addr, cmdbuf->size * 8, DRM_MEM_DRIVER);
|
||||
return -EFAULT;
|
||||
}
|
||||
cmdbuf.cmd_addr = kcmd_addr;
|
||||
cmdbuf->cmd_addr = kcmd_addr;
|
||||
}
|
||||
if (cmdbuf.vb_size) {
|
||||
kvb_addr = drm_alloc(cmdbuf.vb_size, DRM_MEM_DRIVER);
|
||||
if (cmdbuf->vb_size) {
|
||||
kvb_addr = drm_alloc(cmdbuf->vb_size, DRM_MEM_DRIVER);
|
||||
if (kvb_addr == NULL) {
|
||||
ret = DRM_ERR(ENOMEM);
|
||||
ret = -ENOMEM;
|
||||
goto done;
|
||||
}
|
||||
|
||||
if (DRM_COPY_FROM_USER(kvb_addr, cmdbuf.vb_addr,
|
||||
cmdbuf.vb_size)) {
|
||||
ret = DRM_ERR(EFAULT);
|
||||
if (DRM_COPY_FROM_USER(kvb_addr, cmdbuf->vb_addr,
|
||||
cmdbuf->vb_size)) {
|
||||
ret = -EFAULT;
|
||||
goto done;
|
||||
}
|
||||
cmdbuf.vb_addr = kvb_addr;
|
||||
cmdbuf->vb_addr = kvb_addr;
|
||||
}
|
||||
if (cmdbuf.nbox) {
|
||||
kbox_addr = drm_alloc(cmdbuf.nbox * sizeof(struct drm_clip_rect),
|
||||
if (cmdbuf->nbox) {
|
||||
kbox_addr = drm_alloc(cmdbuf->nbox * sizeof(struct drm_clip_rect),
|
||||
DRM_MEM_DRIVER);
|
||||
if (kbox_addr == NULL) {
|
||||
ret = DRM_ERR(ENOMEM);
|
||||
ret = -ENOMEM;
|
||||
goto done;
|
||||
}
|
||||
|
||||
if (DRM_COPY_FROM_USER(kbox_addr, cmdbuf.box_addr,
|
||||
cmdbuf.nbox * sizeof(struct drm_clip_rect))) {
|
||||
ret = DRM_ERR(EFAULT);
|
||||
if (DRM_COPY_FROM_USER(kbox_addr, cmdbuf->box_addr,
|
||||
cmdbuf->nbox * sizeof(struct drm_clip_rect))) {
|
||||
ret = -EFAULT;
|
||||
goto done;
|
||||
}
|
||||
cmdbuf.box_addr = kbox_addr;
|
||||
cmdbuf->box_addr = kbox_addr;
|
||||
}
|
||||
|
||||
/* Make sure writes to DMA buffers are finished before sending
|
||||
|
@ -1044,10 +1040,10 @@ int savage_bci_cmdbuf(DRM_IOCTL_ARGS)
|
|||
|
||||
i = 0;
|
||||
first_draw_cmd = NULL;
|
||||
while (i < cmdbuf.size) {
|
||||
while (i < cmdbuf->size) {
|
||||
drm_savage_cmd_header_t cmd_header;
|
||||
cmd_header = *(drm_savage_cmd_header_t *)cmdbuf.cmd_addr;
|
||||
cmdbuf.cmd_addr++;
|
||||
cmd_header = *(drm_savage_cmd_header_t *)cmdbuf->cmd_addr;
|
||||
cmdbuf->cmd_addr++;
|
||||
i++;
|
||||
|
||||
/* Group drawing commands with same state to minimize
|
||||
|
@ -1057,28 +1053,28 @@ int savage_bci_cmdbuf(DRM_IOCTL_ARGS)
|
|||
case SAVAGE_CMD_DMA_IDX:
|
||||
case SAVAGE_CMD_VB_IDX:
|
||||
j = (cmd_header.idx.count + 3) / 4;
|
||||
if (i + j > cmdbuf.size) {
|
||||
if (i + j > cmdbuf->size) {
|
||||
DRM_ERROR("indexed drawing command extends "
|
||||
"beyond end of command buffer\n");
|
||||
DMA_FLUSH();
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
/* fall through */
|
||||
case SAVAGE_CMD_DMA_PRIM:
|
||||
case SAVAGE_CMD_VB_PRIM:
|
||||
if (!first_draw_cmd)
|
||||
first_draw_cmd = cmdbuf.cmd_addr - 1;
|
||||
cmdbuf.cmd_addr += j;
|
||||
first_draw_cmd = cmdbuf->cmd_addr - 1;
|
||||
cmdbuf->cmd_addr += j;
|
||||
i += j;
|
||||
break;
|
||||
default:
|
||||
if (first_draw_cmd) {
|
||||
ret = savage_dispatch_draw(
|
||||
dev_priv, first_draw_cmd,
|
||||
cmdbuf.cmd_addr - 1,
|
||||
dmabuf, cmdbuf.vb_addr, cmdbuf.vb_size,
|
||||
cmdbuf.vb_stride,
|
||||
cmdbuf.nbox, cmdbuf.box_addr);
|
||||
cmdbuf->cmd_addr - 1,
|
||||
dmabuf, cmdbuf->vb_addr, cmdbuf->vb_size,
|
||||
cmdbuf->vb_stride,
|
||||
cmdbuf->nbox, cmdbuf->box_addr);
|
||||
if (ret != 0)
|
||||
return ret;
|
||||
first_draw_cmd = NULL;
|
||||
|
@ -1090,40 +1086,42 @@ int savage_bci_cmdbuf(DRM_IOCTL_ARGS)
|
|||
switch (cmd_header.cmd.cmd) {
|
||||
case SAVAGE_CMD_STATE:
|
||||
j = (cmd_header.state.count + 1) / 2;
|
||||
if (i + j > cmdbuf.size) {
|
||||
if (i + j > cmdbuf->size) {
|
||||
DRM_ERROR("command SAVAGE_CMD_STATE extends "
|
||||
"beyond end of command buffer\n");
|
||||
DMA_FLUSH();
|
||||
ret = DRM_ERR(EINVAL);
|
||||
ret = -EINVAL;
|
||||
goto done;
|
||||
}
|
||||
ret = savage_dispatch_state(dev_priv, &cmd_header,
|
||||
(const uint32_t *)cmdbuf.cmd_addr);
|
||||
cmdbuf.cmd_addr += j;
|
||||
(const uint32_t *)cmdbuf->cmd_addr);
|
||||
cmdbuf->cmd_addr += j;
|
||||
i += j;
|
||||
break;
|
||||
case SAVAGE_CMD_CLEAR:
|
||||
if (i + 1 > cmdbuf.size) {
|
||||
if (i + 1 > cmdbuf->size) {
|
||||
DRM_ERROR("command SAVAGE_CMD_CLEAR extends "
|
||||
"beyond end of command buffer\n");
|
||||
DMA_FLUSH();
|
||||
ret = DRM_ERR(EINVAL);
|
||||
ret = -EINVAL;
|
||||
goto done;
|
||||
}
|
||||
ret = savage_dispatch_clear(dev_priv, &cmd_header,
|
||||
cmdbuf.cmd_addr,
|
||||
cmdbuf.nbox, cmdbuf.box_addr);
|
||||
cmdbuf.cmd_addr++;
|
||||
cmdbuf->cmd_addr,
|
||||
cmdbuf->nbox,
|
||||
cmdbuf->box_addr);
|
||||
cmdbuf->cmd_addr++;
|
||||
i++;
|
||||
break;
|
||||
case SAVAGE_CMD_SWAP:
|
||||
ret = savage_dispatch_swap(dev_priv, cmdbuf.nbox,
|
||||
cmdbuf.box_addr);
|
||||
ret = savage_dispatch_swap(dev_priv, cmdbuf->nbox,
|
||||
cmdbuf->box_addr);
|
||||
break;
|
||||
default:
|
||||
DRM_ERROR("invalid command 0x%x\n", cmd_header.cmd.cmd);
|
||||
DRM_ERROR("invalid command 0x%x\n",
|
||||
cmd_header.cmd.cmd);
|
||||
DMA_FLUSH();
|
||||
ret = DRM_ERR(EINVAL);
|
||||
ret = -EINVAL;
|
||||
goto done;
|
||||
}
|
||||
|
||||
|
@ -1135,9 +1133,9 @@ int savage_bci_cmdbuf(DRM_IOCTL_ARGS)
|
|||
|
||||
if (first_draw_cmd) {
|
||||
ret = savage_dispatch_draw (
|
||||
dev_priv, first_draw_cmd, cmdbuf.cmd_addr, dmabuf,
|
||||
cmdbuf.vb_addr, cmdbuf.vb_size, cmdbuf.vb_stride,
|
||||
cmdbuf.nbox, cmdbuf.box_addr);
|
||||
dev_priv, first_draw_cmd, cmdbuf->cmd_addr, dmabuf,
|
||||
cmdbuf->vb_addr, cmdbuf->vb_size, cmdbuf->vb_stride,
|
||||
cmdbuf->nbox, cmdbuf->box_addr);
|
||||
if (ret != 0) {
|
||||
DMA_FLUSH();
|
||||
goto done;
|
||||
|
@ -1146,7 +1144,7 @@ int savage_bci_cmdbuf(DRM_IOCTL_ARGS)
|
|||
|
||||
DMA_FLUSH();
|
||||
|
||||
if (dmabuf && cmdbuf.discard) {
|
||||
if (dmabuf && cmdbuf->discard) {
|
||||
drm_savage_buf_priv_t *buf_priv = dmabuf->dev_private;
|
||||
uint16_t event;
|
||||
event = savage_bci_emit_event(dev_priv, SAVAGE_WAIT_3D);
|
||||
|
@ -1156,9 +1154,9 @@ int savage_bci_cmdbuf(DRM_IOCTL_ARGS)
|
|||
|
||||
done:
|
||||
/* If we didn't need to allocate them, these'll be NULL */
|
||||
drm_free(kcmd_addr, cmdbuf.size * 8, DRM_MEM_DRIVER);
|
||||
drm_free(kvb_addr, cmdbuf.vb_size, DRM_MEM_DRIVER);
|
||||
drm_free(kbox_addr, cmdbuf.nbox * sizeof(struct drm_clip_rect),
|
||||
drm_free(kcmd_addr, cmdbuf->size * 8, DRM_MEM_DRIVER);
|
||||
drm_free(kvb_addr, cmdbuf->vb_size, DRM_MEM_DRIVER);
|
||||
drm_free(kbox_addr, cmdbuf->nbox * sizeof(struct drm_clip_rect),
|
||||
DRM_MEM_DRIVER);
|
||||
|
||||
return ret;
|
||||
|
|
|
@ -42,7 +42,7 @@ static int sis_driver_load(struct drm_device *dev, unsigned long chipset)
|
|||
|
||||
dev_priv = drm_calloc(1, sizeof(drm_sis_private_t), DRM_MEM_DRIVER);
|
||||
if (dev_priv == NULL)
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
|
||||
dev->dev_private = (void *)dev_priv;
|
||||
dev_priv->chipset = chipset;
|
||||
|
|
|
@ -63,10 +63,11 @@ typedef struct drm_sis_private {
|
|||
} drm_sis_private_t;
|
||||
|
||||
extern int sis_idle(struct drm_device *dev);
|
||||
extern void sis_reclaim_buffers_locked(struct drm_device *dev, struct file *filp);
|
||||
extern void sis_reclaim_buffers_locked(struct drm_device *dev,
|
||||
struct drm_file *file_priv);
|
||||
extern void sis_lastclose(struct drm_device *dev);
|
||||
|
||||
extern drm_ioctl_desc_t sis_ioctls[];
|
||||
extern struct drm_ioctl_desc sis_ioctls[];
|
||||
extern int sis_max_ioctl;
|
||||
|
||||
#endif
|
||||
|
|
|
@ -82,15 +82,12 @@ static unsigned long sis_sman_mm_offset(void *private, void *ref)
|
|||
|
||||
#endif /* CONFIG_FB_SIS */
|
||||
|
||||
static int sis_fb_init(DRM_IOCTL_ARGS)
|
||||
static int sis_fb_init(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_sis_private_t *dev_priv = dev->dev_private;
|
||||
drm_sis_fb_t fb;
|
||||
drm_sis_fb_t *fb = data;
|
||||
int ret;
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(fb, (drm_sis_fb_t __user *) data, sizeof(fb));
|
||||
|
||||
mutex_lock(&dev->struct_mutex);
|
||||
#if defined(CONFIG_FB_SIS)
|
||||
{
|
||||
|
@ -105,7 +102,7 @@ static int sis_fb_init(DRM_IOCTL_ARGS)
|
|||
}
|
||||
#else
|
||||
ret = drm_sman_set_range(&dev_priv->sman, VIDEO_TYPE, 0,
|
||||
fb.size >> SIS_MM_ALIGN_SHIFT);
|
||||
fb->size >> SIS_MM_ALIGN_SHIFT);
|
||||
#endif
|
||||
|
||||
if (ret) {
|
||||
|
@ -115,98 +112,87 @@ static int sis_fb_init(DRM_IOCTL_ARGS)
|
|||
}
|
||||
|
||||
dev_priv->vram_initialized = 1;
|
||||
dev_priv->vram_offset = fb.offset;
|
||||
dev_priv->vram_offset = fb->offset;
|
||||
|
||||
mutex_unlock(&dev->struct_mutex);
|
||||
DRM_DEBUG("offset = %u, size = %u", fb.offset, fb.size);
|
||||
DRM_DEBUG("offset = %u, size = %u", fb->offset, fb->size);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int sis_drm_alloc(struct drm_device *dev, struct drm_file * priv,
|
||||
unsigned long data, int pool)
|
||||
static int sis_drm_alloc(struct drm_device *dev, struct drm_file *file_priv,
|
||||
void *data, int pool)
|
||||
{
|
||||
drm_sis_private_t *dev_priv = dev->dev_private;
|
||||
drm_sis_mem_t __user *argp = (drm_sis_mem_t __user *) data;
|
||||
drm_sis_mem_t mem;
|
||||
drm_sis_mem_t *mem = data;
|
||||
int retval = 0;
|
||||
struct drm_memblock_item *item;
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(mem, argp, sizeof(mem));
|
||||
|
||||
mutex_lock(&dev->struct_mutex);
|
||||
|
||||
if (0 == ((pool == 0) ? dev_priv->vram_initialized :
|
||||
dev_priv->agp_initialized)) {
|
||||
DRM_ERROR
|
||||
("Attempt to allocate from uninitialized memory manager.\n");
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
mem.size = (mem.size + SIS_MM_ALIGN_MASK) >> SIS_MM_ALIGN_SHIFT;
|
||||
item = drm_sman_alloc(&dev_priv->sman, pool, mem.size, 0,
|
||||
(unsigned long)priv);
|
||||
mem->size = (mem->size + SIS_MM_ALIGN_MASK) >> SIS_MM_ALIGN_SHIFT;
|
||||
item = drm_sman_alloc(&dev_priv->sman, pool, mem->size, 0,
|
||||
(unsigned long)file_priv);
|
||||
|
||||
mutex_unlock(&dev->struct_mutex);
|
||||
if (item) {
|
||||
mem.offset = ((pool == 0) ?
|
||||
mem->offset = ((pool == 0) ?
|
||||
dev_priv->vram_offset : dev_priv->agp_offset) +
|
||||
(item->mm->
|
||||
offset(item->mm, item->mm_info) << SIS_MM_ALIGN_SHIFT);
|
||||
mem.free = item->user_hash.key;
|
||||
mem.size = mem.size << SIS_MM_ALIGN_SHIFT;
|
||||
mem->free = item->user_hash.key;
|
||||
mem->size = mem->size << SIS_MM_ALIGN_SHIFT;
|
||||
} else {
|
||||
mem.offset = 0;
|
||||
mem.size = 0;
|
||||
mem.free = 0;
|
||||
retval = DRM_ERR(ENOMEM);
|
||||
mem->offset = 0;
|
||||
mem->size = 0;
|
||||
mem->free = 0;
|
||||
retval = -ENOMEM;
|
||||
}
|
||||
|
||||
DRM_COPY_TO_USER_IOCTL(argp, mem, sizeof(mem));
|
||||
|
||||
DRM_DEBUG("alloc %d, size = %d, offset = %d\n", pool, mem.size,
|
||||
mem.offset);
|
||||
DRM_DEBUG("alloc %d, size = %d, offset = %d\n", pool, mem->size,
|
||||
mem->offset);
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
static int sis_drm_free(DRM_IOCTL_ARGS)
|
||||
static int sis_drm_free(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_sis_private_t *dev_priv = dev->dev_private;
|
||||
drm_sis_mem_t mem;
|
||||
drm_sis_mem_t *mem = data;
|
||||
int ret;
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(mem, (drm_sis_mem_t __user *) data,
|
||||
sizeof(mem));
|
||||
|
||||
mutex_lock(&dev->struct_mutex);
|
||||
ret = drm_sman_free_key(&dev_priv->sman, mem.free);
|
||||
ret = drm_sman_free_key(&dev_priv->sman, mem->free);
|
||||
mutex_unlock(&dev->struct_mutex);
|
||||
DRM_DEBUG("free = 0x%lx\n", mem.free);
|
||||
DRM_DEBUG("free = 0x%lx\n", mem->free);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int sis_fb_alloc(DRM_IOCTL_ARGS)
|
||||
static int sis_fb_alloc(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
return sis_drm_alloc(dev, priv, data, VIDEO_TYPE);
|
||||
return sis_drm_alloc(dev, file_priv, data, VIDEO_TYPE);
|
||||
}
|
||||
|
||||
static int sis_ioctl_agp_init(DRM_IOCTL_ARGS)
|
||||
static int sis_ioctl_agp_init(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_sis_private_t *dev_priv = dev->dev_private;
|
||||
drm_sis_agp_t agp;
|
||||
drm_sis_agp_t *agp = data;
|
||||
int ret;
|
||||
dev_priv = dev->dev_private;
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(agp, (drm_sis_agp_t __user *) data,
|
||||
sizeof(agp));
|
||||
mutex_lock(&dev->struct_mutex);
|
||||
ret = drm_sman_set_range(&dev_priv->sman, AGP_TYPE, 0,
|
||||
agp.size >> SIS_MM_ALIGN_SHIFT);
|
||||
agp->size >> SIS_MM_ALIGN_SHIFT);
|
||||
|
||||
if (ret) {
|
||||
DRM_ERROR("AGP memory manager initialisation error\n");
|
||||
|
@ -215,18 +201,18 @@ static int sis_ioctl_agp_init(DRM_IOCTL_ARGS)
|
|||
}
|
||||
|
||||
dev_priv->agp_initialized = 1;
|
||||
dev_priv->agp_offset = agp.offset;
|
||||
dev_priv->agp_offset = agp->offset;
|
||||
mutex_unlock(&dev->struct_mutex);
|
||||
|
||||
DRM_DEBUG("offset = %u, size = %u", agp.offset, agp.size);
|
||||
DRM_DEBUG("offset = %u, size = %u", agp->offset, agp->size);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int sis_ioctl_agp_alloc(DRM_IOCTL_ARGS)
|
||||
static int sis_ioctl_agp_alloc(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
|
||||
return sis_drm_alloc(dev, priv, data, AGP_TYPE);
|
||||
return sis_drm_alloc(dev, file_priv, data, AGP_TYPE);
|
||||
}
|
||||
|
||||
static drm_local_map_t *sis_reg_init(struct drm_device *dev)
|
||||
|
@ -314,13 +300,13 @@ void sis_lastclose(struct drm_device *dev)
|
|||
mutex_unlock(&dev->struct_mutex);
|
||||
}
|
||||
|
||||
void sis_reclaim_buffers_locked(struct drm_device * dev, struct file *filp)
|
||||
void sis_reclaim_buffers_locked(struct drm_device * dev,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
drm_sis_private_t *dev_priv = dev->dev_private;
|
||||
struct drm_file *priv = filp->private_data;
|
||||
|
||||
mutex_lock(&dev->struct_mutex);
|
||||
if (drm_sman_owner_clean(&dev_priv->sman, (unsigned long)priv)) {
|
||||
if (drm_sman_owner_clean(&dev_priv->sman, (unsigned long)file_priv)) {
|
||||
mutex_unlock(&dev->struct_mutex);
|
||||
return;
|
||||
}
|
||||
|
@ -329,20 +315,18 @@ void sis_reclaim_buffers_locked(struct drm_device * dev, struct file *filp)
|
|||
dev->driver->dma_quiescent(dev);
|
||||
}
|
||||
|
||||
drm_sman_owner_cleanup(&dev_priv->sman, (unsigned long)priv);
|
||||
drm_sman_owner_cleanup(&dev_priv->sman, (unsigned long)file_priv);
|
||||
mutex_unlock(&dev->struct_mutex);
|
||||
return;
|
||||
}
|
||||
|
||||
drm_ioctl_desc_t sis_ioctls[] = {
|
||||
[DRM_IOCTL_NR(DRM_SIS_FB_ALLOC)] = {sis_fb_alloc, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_SIS_FB_FREE)] = {sis_drm_free, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_SIS_AGP_INIT)] =
|
||||
{sis_ioctl_agp_init, DRM_AUTH | DRM_MASTER | DRM_ROOT_ONLY},
|
||||
[DRM_IOCTL_NR(DRM_SIS_AGP_ALLOC)] = {sis_ioctl_agp_alloc, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_SIS_AGP_FREE)] = {sis_drm_free, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_SIS_FB_INIT)] =
|
||||
{sis_fb_init, DRM_AUTH | DRM_MASTER | DRM_ROOT_ONLY}
|
||||
struct drm_ioctl_desc sis_ioctls[] = {
|
||||
DRM_IOCTL_DEF(DRM_SIS_FB_ALLOC, sis_fb_alloc, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_SIS_FB_FREE, sis_drm_free, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_SIS_AGP_INIT, sis_ioctl_agp_init, DRM_AUTH | DRM_MASTER | DRM_ROOT_ONLY),
|
||||
DRM_IOCTL_DEF(DRM_SIS_AGP_ALLOC, sis_ioctl_agp_alloc, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_SIS_AGP_FREE, sis_drm_free, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_SIS_FB_INIT, sis_fb_init, DRM_AUTH | DRM_MASTER | DRM_ROOT_ONLY),
|
||||
};
|
||||
|
||||
int sis_max_ioctl = DRM_ARRAY_SIZE(sis_ioctls);
|
||||
|
|
|
@ -175,24 +175,24 @@ static int via_initialize(struct drm_device * dev,
|
|||
{
|
||||
if (!dev_priv || !dev_priv->mmio) {
|
||||
DRM_ERROR("via_dma_init called before via_map_init\n");
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
if (dev_priv->ring.virtual_start != NULL) {
|
||||
DRM_ERROR("%s called again without calling cleanup\n",
|
||||
__FUNCTION__);
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
if (!dev->agp || !dev->agp->base) {
|
||||
DRM_ERROR("%s called with no agp memory available\n",
|
||||
__FUNCTION__);
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
if (dev_priv->chipset == VIA_DX9_0) {
|
||||
DRM_ERROR("AGP DMA is not supported on this chip\n");
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
dev_priv->ring.map.offset = dev->agp->base + init->offset;
|
||||
|
@ -207,7 +207,7 @@ static int via_initialize(struct drm_device * dev,
|
|||
via_dma_cleanup(dev);
|
||||
DRM_ERROR("can not ioremap virtual address for"
|
||||
" ring buffer\n");
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
dev_priv->ring.virtual_start = dev_priv->ring.map.handle;
|
||||
|
@ -227,35 +227,31 @@ static int via_initialize(struct drm_device * dev,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int via_dma_init(DRM_IOCTL_ARGS)
|
||||
static int via_dma_init(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
|
||||
drm_via_dma_init_t init;
|
||||
drm_via_dma_init_t *init = data;
|
||||
int retcode = 0;
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(init, (drm_via_dma_init_t __user *) data,
|
||||
sizeof(init));
|
||||
|
||||
switch (init.func) {
|
||||
switch (init->func) {
|
||||
case VIA_INIT_DMA:
|
||||
if (!DRM_SUSER(DRM_CURPROC))
|
||||
retcode = DRM_ERR(EPERM);
|
||||
retcode = -EPERM;
|
||||
else
|
||||
retcode = via_initialize(dev, dev_priv, &init);
|
||||
retcode = via_initialize(dev, dev_priv, init);
|
||||
break;
|
||||
case VIA_CLEANUP_DMA:
|
||||
if (!DRM_SUSER(DRM_CURPROC))
|
||||
retcode = DRM_ERR(EPERM);
|
||||
retcode = -EPERM;
|
||||
else
|
||||
retcode = via_dma_cleanup(dev);
|
||||
break;
|
||||
case VIA_DMA_INITIALIZED:
|
||||
retcode = (dev_priv->ring.virtual_start != NULL) ?
|
||||
0 : DRM_ERR(EFAULT);
|
||||
0 : -EFAULT;
|
||||
break;
|
||||
default:
|
||||
retcode = DRM_ERR(EINVAL);
|
||||
retcode = -EINVAL;
|
||||
break;
|
||||
}
|
||||
|
||||
|
@ -273,15 +269,15 @@ static int via_dispatch_cmdbuffer(struct drm_device * dev, drm_via_cmdbuffer_t *
|
|||
if (dev_priv->ring.virtual_start == NULL) {
|
||||
DRM_ERROR("%s called without initializing AGP ring buffer.\n",
|
||||
__FUNCTION__);
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
if (cmd->size > VIA_PCI_BUF_SIZE) {
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
if (DRM_COPY_FROM_USER(dev_priv->pci_buf, cmd->buf, cmd->size))
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
|
||||
/*
|
||||
* Running this function on AGP memory is dead slow. Therefore
|
||||
|
@ -297,7 +293,7 @@ static int via_dispatch_cmdbuffer(struct drm_device * dev, drm_via_cmdbuffer_t *
|
|||
|
||||
vb = via_check_dma(dev_priv, (cmd->size < 0x100) ? 0x102 : cmd->size);
|
||||
if (vb == NULL) {
|
||||
return DRM_ERR(EAGAIN);
|
||||
return -EAGAIN;
|
||||
}
|
||||
|
||||
memcpy(vb, dev_priv->pci_buf, cmd->size);
|
||||
|
@ -321,34 +317,30 @@ int via_driver_dma_quiescent(struct drm_device * dev)
|
|||
drm_via_private_t *dev_priv = dev->dev_private;
|
||||
|
||||
if (!via_wait_idle(dev_priv)) {
|
||||
return DRM_ERR(EBUSY);
|
||||
return -EBUSY;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int via_flush_ioctl(DRM_IOCTL_ARGS)
|
||||
static int via_flush_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
return via_driver_dma_quiescent(dev);
|
||||
}
|
||||
|
||||
static int via_cmdbuffer(DRM_IOCTL_ARGS)
|
||||
static int via_cmdbuffer(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_via_cmdbuffer_t cmdbuf;
|
||||
drm_via_cmdbuffer_t *cmdbuf = data;
|
||||
int ret;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(cmdbuf, (drm_via_cmdbuffer_t __user *) data,
|
||||
sizeof(cmdbuf));
|
||||
DRM_DEBUG("via cmdbuffer, buf %p size %lu\n", cmdbuf->buf,
|
||||
cmdbuf->size);
|
||||
|
||||
DRM_DEBUG("via cmdbuffer, buf %p size %lu\n", cmdbuf.buf, cmdbuf.size);
|
||||
|
||||
ret = via_dispatch_cmdbuffer(dev, &cmdbuf);
|
||||
ret = via_dispatch_cmdbuffer(dev, cmdbuf);
|
||||
if (ret) {
|
||||
return ret;
|
||||
}
|
||||
|
@ -363,10 +355,10 @@ static int via_dispatch_pci_cmdbuffer(struct drm_device * dev,
|
|||
int ret;
|
||||
|
||||
if (cmd->size > VIA_PCI_BUF_SIZE) {
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
if (DRM_COPY_FROM_USER(dev_priv->pci_buf, cmd->buf, cmd->size))
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
|
||||
if ((ret =
|
||||
via_verify_command_stream((uint32_t *) dev_priv->pci_buf,
|
||||
|
@ -380,21 +372,17 @@ static int via_dispatch_pci_cmdbuffer(struct drm_device * dev,
|
|||
return ret;
|
||||
}
|
||||
|
||||
static int via_pci_cmdbuffer(DRM_IOCTL_ARGS)
|
||||
static int via_pci_cmdbuffer(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_via_cmdbuffer_t cmdbuf;
|
||||
drm_via_cmdbuffer_t *cmdbuf = data;
|
||||
int ret;
|
||||
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(cmdbuf, (drm_via_cmdbuffer_t __user *) data,
|
||||
sizeof(cmdbuf));
|
||||
DRM_DEBUG("via_pci_cmdbuffer, buf %p size %lu\n", cmdbuf->buf,
|
||||
cmdbuf->size);
|
||||
|
||||
DRM_DEBUG("via_pci_cmdbuffer, buf %p size %lu\n", cmdbuf.buf,
|
||||
cmdbuf.size);
|
||||
|
||||
ret = via_dispatch_pci_cmdbuffer(dev, &cmdbuf);
|
||||
ret = via_dispatch_pci_cmdbuffer(dev, cmdbuf);
|
||||
if (ret) {
|
||||
return ret;
|
||||
}
|
||||
|
@ -653,80 +641,74 @@ static void via_cmdbuf_reset(drm_via_private_t * dev_priv)
|
|||
* User interface to the space and lag functions.
|
||||
*/
|
||||
|
||||
static int via_cmdbuf_size(DRM_IOCTL_ARGS)
|
||||
static int via_cmdbuf_size(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_via_cmdbuf_size_t d_siz;
|
||||
drm_via_cmdbuf_size_t *d_siz = data;
|
||||
int ret = 0;
|
||||
uint32_t tmp_size, count;
|
||||
drm_via_private_t *dev_priv;
|
||||
|
||||
DRM_DEBUG("via cmdbuf_size\n");
|
||||
LOCK_TEST_WITH_RETURN(dev, filp);
|
||||
LOCK_TEST_WITH_RETURN(dev, file_priv);
|
||||
|
||||
dev_priv = (drm_via_private_t *) dev->dev_private;
|
||||
|
||||
if (dev_priv->ring.virtual_start == NULL) {
|
||||
DRM_ERROR("%s called without initializing AGP ring buffer.\n",
|
||||
__FUNCTION__);
|
||||
return DRM_ERR(EFAULT);
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(d_siz, (drm_via_cmdbuf_size_t __user *) data,
|
||||
sizeof(d_siz));
|
||||
|
||||
count = 1000000;
|
||||
tmp_size = d_siz.size;
|
||||
switch (d_siz.func) {
|
||||
tmp_size = d_siz->size;
|
||||
switch (d_siz->func) {
|
||||
case VIA_CMDBUF_SPACE:
|
||||
while (((tmp_size = via_cmdbuf_space(dev_priv)) < d_siz.size)
|
||||
while (((tmp_size = via_cmdbuf_space(dev_priv)) < d_siz->size)
|
||||
&& count--) {
|
||||
if (!d_siz.wait) {
|
||||
if (!d_siz->wait) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!count) {
|
||||
DRM_ERROR("VIA_CMDBUF_SPACE timed out.\n");
|
||||
ret = DRM_ERR(EAGAIN);
|
||||
ret = -EAGAIN;
|
||||
}
|
||||
break;
|
||||
case VIA_CMDBUF_LAG:
|
||||
while (((tmp_size = via_cmdbuf_lag(dev_priv)) > d_siz.size)
|
||||
while (((tmp_size = via_cmdbuf_lag(dev_priv)) > d_siz->size)
|
||||
&& count--) {
|
||||
if (!d_siz.wait) {
|
||||
if (!d_siz->wait) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!count) {
|
||||
DRM_ERROR("VIA_CMDBUF_LAG timed out.\n");
|
||||
ret = DRM_ERR(EAGAIN);
|
||||
ret = -EAGAIN;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
ret = DRM_ERR(EFAULT);
|
||||
ret = -EFAULT;
|
||||
}
|
||||
d_siz.size = tmp_size;
|
||||
d_siz->size = tmp_size;
|
||||
|
||||
DRM_COPY_TO_USER_IOCTL((drm_via_cmdbuf_size_t __user *) data, d_siz,
|
||||
sizeof(d_siz));
|
||||
return ret;
|
||||
}
|
||||
|
||||
drm_ioctl_desc_t via_ioctls[] = {
|
||||
[DRM_IOCTL_NR(DRM_VIA_ALLOCMEM)] = {via_mem_alloc, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_VIA_FREEMEM)] = {via_mem_free, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_VIA_AGP_INIT)] = {via_agp_init, DRM_AUTH|DRM_MASTER},
|
||||
[DRM_IOCTL_NR(DRM_VIA_FB_INIT)] = {via_fb_init, DRM_AUTH|DRM_MASTER},
|
||||
[DRM_IOCTL_NR(DRM_VIA_MAP_INIT)] = {via_map_init, DRM_AUTH|DRM_MASTER},
|
||||
[DRM_IOCTL_NR(DRM_VIA_DEC_FUTEX)] = {via_decoder_futex, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_VIA_DMA_INIT)] = {via_dma_init, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_VIA_CMDBUFFER)] = {via_cmdbuffer, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_VIA_FLUSH)] = {via_flush_ioctl, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_VIA_PCICMD)] = {via_pci_cmdbuffer, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_VIA_CMDBUF_SIZE)] = {via_cmdbuf_size, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_VIA_WAIT_IRQ)] = {via_wait_irq, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_VIA_DMA_BLIT)] = {via_dma_blit, DRM_AUTH},
|
||||
[DRM_IOCTL_NR(DRM_VIA_BLIT_SYNC)] = {via_dma_blit_sync, DRM_AUTH}
|
||||
struct drm_ioctl_desc via_ioctls[] = {
|
||||
DRM_IOCTL_DEF(DRM_VIA_ALLOCMEM, via_mem_alloc, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_VIA_FREEMEM, via_mem_free, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_VIA_AGP_INIT, via_agp_init, DRM_AUTH|DRM_MASTER),
|
||||
DRM_IOCTL_DEF(DRM_VIA_FB_INIT, via_fb_init, DRM_AUTH|DRM_MASTER),
|
||||
DRM_IOCTL_DEF(DRM_VIA_MAP_INIT, via_map_init, DRM_AUTH|DRM_MASTER),
|
||||
DRM_IOCTL_DEF(DRM_VIA_DEC_FUTEX, via_decoder_futex, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_VIA_DMA_INIT, via_dma_init, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_VIA_CMDBUFFER, via_cmdbuffer, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_VIA_FLUSH, via_flush_ioctl, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_VIA_PCICMD, via_pci_cmdbuffer, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_VIA_CMDBUF_SIZE, via_cmdbuf_size, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_VIA_WAIT_IRQ, via_wait_irq, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_VIA_DMA_BLIT, via_dma_blit, DRM_AUTH),
|
||||
DRM_IOCTL_DEF(DRM_VIA_BLIT_SYNC, via_dma_blit_sync, DRM_AUTH)
|
||||
};
|
||||
|
||||
int via_max_ioctl = DRM_ARRAY_SIZE(via_ioctls);
|
||||
|
|
|
@ -237,7 +237,7 @@ via_lock_all_dma_pages(drm_via_sg_info_t *vsg, drm_via_dmablit_t *xfer)
|
|||
first_pfn + 1;
|
||||
|
||||
if (NULL == (vsg->pages = vmalloc(sizeof(struct page *) * vsg->num_pages)))
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
memset(vsg->pages, 0, sizeof(struct page *) * vsg->num_pages);
|
||||
down_read(¤t->mm->mmap_sem);
|
||||
ret = get_user_pages(current, current->mm,
|
||||
|
@ -251,7 +251,7 @@ via_lock_all_dma_pages(drm_via_sg_info_t *vsg, drm_via_dmablit_t *xfer)
|
|||
if (ret < 0)
|
||||
return ret;
|
||||
vsg->state = dr_via_pages_locked;
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
vsg->state = dr_via_pages_locked;
|
||||
DRM_DEBUG("DMA pages locked\n");
|
||||
|
@ -274,13 +274,13 @@ via_alloc_desc_pages(drm_via_sg_info_t *vsg)
|
|||
vsg->descriptors_per_page;
|
||||
|
||||
if (NULL == (vsg->desc_pages = kcalloc(vsg->num_desc_pages, sizeof(void *), GFP_KERNEL)))
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
|
||||
vsg->state = dr_via_desc_pages_alloc;
|
||||
for (i=0; i<vsg->num_desc_pages; ++i) {
|
||||
if (NULL == (vsg->desc_pages[i] =
|
||||
(drm_via_descriptor_t *) __get_free_page(GFP_KERNEL)))
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
DRM_DEBUG("Allocated %d pages for %d descriptors.\n", vsg->num_desc_pages,
|
||||
vsg->num_desc);
|
||||
|
@ -593,7 +593,7 @@ via_build_sg_info(struct drm_device *dev, drm_via_sg_info_t *vsg, drm_via_dmabli
|
|||
|
||||
if (xfer->num_lines <= 0 || xfer->line_length <= 0) {
|
||||
DRM_ERROR("Zero size bitblt.\n");
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -606,7 +606,7 @@ via_build_sg_info(struct drm_device *dev, drm_via_sg_info_t *vsg, drm_via_dmabli
|
|||
if ((xfer->mem_stride - xfer->line_length) >= PAGE_SIZE) {
|
||||
DRM_ERROR("Too large system memory stride. Stride: %d, "
|
||||
"Length: %d\n", xfer->mem_stride, xfer->line_length);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if ((xfer->mem_stride == xfer->line_length) &&
|
||||
|
@ -624,7 +624,7 @@ via_build_sg_info(struct drm_device *dev, drm_via_sg_info_t *vsg, drm_via_dmabli
|
|||
|
||||
if (xfer->num_lines > 2048 || (xfer->num_lines*xfer->mem_stride > (2048*2048*4))) {
|
||||
DRM_ERROR("Too large PCI DMA bitblt.\n");
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -635,7 +635,7 @@ via_build_sg_info(struct drm_device *dev, drm_via_sg_info_t *vsg, drm_via_dmabli
|
|||
if (xfer->mem_stride < xfer->line_length ||
|
||||
abs(xfer->fb_stride) < xfer->line_length) {
|
||||
DRM_ERROR("Invalid frame-buffer / memory stride.\n");
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -648,7 +648,7 @@ via_build_sg_info(struct drm_device *dev, drm_via_sg_info_t *vsg, drm_via_dmabli
|
|||
if ((((unsigned long)xfer->mem_addr & 3) != ((unsigned long)xfer->fb_addr & 3)) ||
|
||||
((xfer->num_lines > 1) && ((xfer->mem_stride & 3) != (xfer->fb_stride & 3)))) {
|
||||
DRM_ERROR("Invalid DRM bitblt alignment.\n");
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
#else
|
||||
if ((((unsigned long)xfer->mem_addr & 15) ||
|
||||
|
@ -656,7 +656,7 @@ via_build_sg_info(struct drm_device *dev, drm_via_sg_info_t *vsg, drm_via_dmabli
|
|||
((xfer->num_lines > 1) &&
|
||||
((xfer->mem_stride & 15) || (xfer->fb_stride & 3)))) {
|
||||
DRM_ERROR("Invalid DRM bitblt alignment.\n");
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
@ -696,7 +696,7 @@ via_dmablit_grab_slot(drm_via_blitq_t *blitq, int engine)
|
|||
|
||||
DRM_WAIT_ON(ret, blitq->busy_queue, DRM_HZ, blitq->num_free > 0);
|
||||
if (ret) {
|
||||
return (DRM_ERR(EINTR) == ret) ? DRM_ERR(EAGAIN) : ret;
|
||||
return (-EINTR == ret) ? -EAGAIN : ret;
|
||||
}
|
||||
|
||||
spin_lock_irqsave(&blitq->blit_lock, irqsave);
|
||||
|
@ -740,7 +740,7 @@ via_dmablit(struct drm_device *dev, drm_via_dmablit_t *xfer)
|
|||
|
||||
if (dev_priv == NULL) {
|
||||
DRM_ERROR("Called without initialization.\n");
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
engine = (xfer->to_fb) ? 0 : 1;
|
||||
|
@ -750,7 +750,7 @@ via_dmablit(struct drm_device *dev, drm_via_dmablit_t *xfer)
|
|||
}
|
||||
if (NULL == (vsg = kmalloc(sizeof(*vsg), GFP_KERNEL))) {
|
||||
via_dmablit_release_slot(blitq);
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
}
|
||||
if (0 != (ret = via_build_sg_info(dev, vsg, xfer))) {
|
||||
via_dmablit_release_slot(blitq);
|
||||
|
@ -781,21 +781,18 @@ via_dmablit(struct drm_device *dev, drm_via_dmablit_t *xfer)
|
|||
*/
|
||||
|
||||
int
|
||||
via_dma_blit_sync( DRM_IOCTL_ARGS )
|
||||
via_dma_blit_sync( struct drm_device *dev, void *data, struct drm_file *file_priv )
|
||||
{
|
||||
drm_via_blitsync_t sync;
|
||||
drm_via_blitsync_t *sync = data;
|
||||
int err;
|
||||
DRM_DEVICE;
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(sync, (drm_via_blitsync_t *)data, sizeof(sync));
|
||||
if (sync->engine >= VIA_NUM_BLIT_ENGINES)
|
||||
return -EINVAL;
|
||||
|
||||
if (sync.engine >= VIA_NUM_BLIT_ENGINES)
|
||||
return DRM_ERR(EINVAL);
|
||||
err = via_dmablit_sync(dev, sync->sync_handle, sync->engine);
|
||||
|
||||
err = via_dmablit_sync(dev, sync.sync_handle, sync.engine);
|
||||
|
||||
if (DRM_ERR(EINTR) == err)
|
||||
err = DRM_ERR(EAGAIN);
|
||||
if (-EINTR == err)
|
||||
err = -EAGAIN;
|
||||
|
||||
return err;
|
||||
}
|
||||
|
@ -808,17 +805,12 @@ via_dma_blit_sync( DRM_IOCTL_ARGS )
|
|||
*/
|
||||
|
||||
int
|
||||
via_dma_blit( DRM_IOCTL_ARGS )
|
||||
via_dma_blit( struct drm_device *dev, void *data, struct drm_file *file_priv )
|
||||
{
|
||||
drm_via_dmablit_t xfer;
|
||||
drm_via_dmablit_t *xfer = data;
|
||||
int err;
|
||||
DRM_DEVICE;
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(xfer, (drm_via_dmablit_t __user *)data, sizeof(xfer));
|
||||
|
||||
err = via_dmablit(dev, &xfer);
|
||||
|
||||
DRM_COPY_TO_USER_IOCTL((void __user *)data, xfer, sizeof(xfer));
|
||||
err = via_dmablit(dev, xfer);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
|
|
@ -110,18 +110,18 @@ enum via_family {
|
|||
#define VIA_READ8(reg) DRM_READ8(VIA_BASE, reg)
|
||||
#define VIA_WRITE8(reg,val) DRM_WRITE8(VIA_BASE, reg, val)
|
||||
|
||||
extern drm_ioctl_desc_t via_ioctls[];
|
||||
extern struct drm_ioctl_desc via_ioctls[];
|
||||
extern int via_max_ioctl;
|
||||
|
||||
extern int via_fb_init(DRM_IOCTL_ARGS);
|
||||
extern int via_mem_alloc(DRM_IOCTL_ARGS);
|
||||
extern int via_mem_free(DRM_IOCTL_ARGS);
|
||||
extern int via_agp_init(DRM_IOCTL_ARGS);
|
||||
extern int via_map_init(DRM_IOCTL_ARGS);
|
||||
extern int via_decoder_futex(DRM_IOCTL_ARGS);
|
||||
extern int via_wait_irq(DRM_IOCTL_ARGS);
|
||||
extern int via_dma_blit_sync( DRM_IOCTL_ARGS );
|
||||
extern int via_dma_blit( DRM_IOCTL_ARGS );
|
||||
extern int via_fb_init(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
extern int via_mem_alloc(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
extern int via_mem_free(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
extern int via_agp_init(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
extern int via_map_init(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
extern int via_decoder_futex(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
extern int via_wait_irq(struct drm_device *dev, void *data, struct drm_file *file_priv);
|
||||
extern int via_dma_blit_sync( struct drm_device *dev, void *data, struct drm_file *file_priv );
|
||||
extern int via_dma_blit( struct drm_device *dev, void *data, struct drm_file *file_priv );
|
||||
|
||||
extern int via_driver_load(struct drm_device *dev, unsigned long chipset);
|
||||
extern int via_driver_unload(struct drm_device *dev);
|
||||
|
@ -144,7 +144,7 @@ extern void via_init_futex(drm_via_private_t * dev_priv);
|
|||
extern void via_cleanup_futex(drm_via_private_t * dev_priv);
|
||||
extern void via_release_futex(drm_via_private_t * dev_priv, int context);
|
||||
|
||||
extern void via_reclaim_buffers_locked(struct drm_device *dev, struct file *filp);
|
||||
extern void via_reclaim_buffers_locked(struct drm_device *dev, struct drm_file *file_priv);
|
||||
extern void via_lastclose(struct drm_device *dev);
|
||||
|
||||
extern void via_dmablit_handler(struct drm_device *dev, int engine, int from_irq);
|
||||
|
|
|
@ -205,13 +205,13 @@ via_driver_irq_wait(struct drm_device * dev, unsigned int irq, int force_sequenc
|
|||
|
||||
if (!dev_priv) {
|
||||
DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (irq >= drm_via_irq_num) {
|
||||
DRM_ERROR("%s Trying to wait on unknown irq %d\n", __FUNCTION__,
|
||||
irq);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
real_irq = dev_priv->irq_map[irq];
|
||||
|
@ -219,7 +219,7 @@ via_driver_irq_wait(struct drm_device * dev, unsigned int irq, int force_sequenc
|
|||
if (real_irq < 0) {
|
||||
DRM_ERROR("%s Video IRQ %d not available on this hardware.\n",
|
||||
__FUNCTION__, irq);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
masks = dev_priv->irq_masks;
|
||||
|
@ -331,11 +331,9 @@ void via_driver_irq_uninstall(struct drm_device * dev)
|
|||
}
|
||||
}
|
||||
|
||||
int via_wait_irq(DRM_IOCTL_ARGS)
|
||||
int via_wait_irq(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_via_irqwait_t __user *argp = (void __user *)data;
|
||||
drm_via_irqwait_t irqwait;
|
||||
drm_via_irqwait_t *irqwait = data;
|
||||
struct timeval now;
|
||||
int ret = 0;
|
||||
drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
|
||||
|
@ -343,42 +341,39 @@ int via_wait_irq(DRM_IOCTL_ARGS)
|
|||
int force_sequence;
|
||||
|
||||
if (!dev->irq)
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(irqwait, argp, sizeof(irqwait));
|
||||
if (irqwait.request.irq >= dev_priv->num_irqs) {
|
||||
if (irqwait->request.irq >= dev_priv->num_irqs) {
|
||||
DRM_ERROR("%s Trying to wait on unknown irq %d\n", __FUNCTION__,
|
||||
irqwait.request.irq);
|
||||
return DRM_ERR(EINVAL);
|
||||
irqwait->request.irq);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
cur_irq += irqwait.request.irq;
|
||||
cur_irq += irqwait->request.irq;
|
||||
|
||||
switch (irqwait.request.type & ~VIA_IRQ_FLAGS_MASK) {
|
||||
switch (irqwait->request.type & ~VIA_IRQ_FLAGS_MASK) {
|
||||
case VIA_IRQ_RELATIVE:
|
||||
irqwait.request.sequence += atomic_read(&cur_irq->irq_received);
|
||||
irqwait.request.type &= ~_DRM_VBLANK_RELATIVE;
|
||||
irqwait->request.sequence += atomic_read(&cur_irq->irq_received);
|
||||
irqwait->request.type &= ~_DRM_VBLANK_RELATIVE;
|
||||
case VIA_IRQ_ABSOLUTE:
|
||||
break;
|
||||
default:
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (irqwait.request.type & VIA_IRQ_SIGNAL) {
|
||||
if (irqwait->request.type & VIA_IRQ_SIGNAL) {
|
||||
DRM_ERROR("%s Signals on Via IRQs not implemented yet.\n",
|
||||
__FUNCTION__);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
force_sequence = (irqwait.request.type & VIA_IRQ_FORCE_SEQUENCE);
|
||||
force_sequence = (irqwait->request.type & VIA_IRQ_FORCE_SEQUENCE);
|
||||
|
||||
ret = via_driver_irq_wait(dev, irqwait.request.irq, force_sequence,
|
||||
&irqwait.request.sequence);
|
||||
ret = via_driver_irq_wait(dev, irqwait->request.irq, force_sequence,
|
||||
&irqwait->request.sequence);
|
||||
do_gettimeofday(&now);
|
||||
irqwait.reply.tval_sec = now.tv_sec;
|
||||
irqwait.reply.tval_usec = now.tv_usec;
|
||||
|
||||
DRM_COPY_TO_USER_IOCTL(argp, irqwait, sizeof(irqwait));
|
||||
irqwait->reply.tval_sec = now.tv_sec;
|
||||
irqwait->reply.tval_usec = now.tv_usec;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
|
@ -75,19 +75,15 @@ int via_do_cleanup_map(struct drm_device * dev)
|
|||
return 0;
|
||||
}
|
||||
|
||||
int via_map_init(DRM_IOCTL_ARGS)
|
||||
int via_map_init(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_via_init_t init;
|
||||
drm_via_init_t *init = data;
|
||||
|
||||
DRM_DEBUG("%s\n", __FUNCTION__);
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(init, (drm_via_init_t __user *) data,
|
||||
sizeof(init));
|
||||
|
||||
switch (init.func) {
|
||||
switch (init->func) {
|
||||
case VIA_INIT_MAP:
|
||||
return via_do_init_map(dev, &init);
|
||||
return via_do_init_map(dev, init);
|
||||
case VIA_CLEANUP_MAP:
|
||||
return via_do_cleanup_map(dev);
|
||||
}
|
||||
|
@ -102,7 +98,7 @@ int via_driver_load(struct drm_device *dev, unsigned long chipset)
|
|||
|
||||
dev_priv = drm_calloc(1, sizeof(drm_via_private_t), DRM_MEM_DRIVER);
|
||||
if (dev_priv == NULL)
|
||||
return DRM_ERR(ENOMEM);
|
||||
return -ENOMEM;
|
||||
|
||||
dev->dev_private = (void *)dev_priv;
|
||||
|
||||
|
|
|
@ -33,18 +33,15 @@
|
|||
#define VIA_MM_ALIGN_SHIFT 4
|
||||
#define VIA_MM_ALIGN_MASK ( (1 << VIA_MM_ALIGN_SHIFT) - 1)
|
||||
|
||||
int via_agp_init(DRM_IOCTL_ARGS)
|
||||
int via_agp_init(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_via_agp_t agp;
|
||||
drm_via_agp_t *agp = data;
|
||||
drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
|
||||
int ret;
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(agp, (drm_via_agp_t __user *) data,
|
||||
sizeof(agp));
|
||||
mutex_lock(&dev->struct_mutex);
|
||||
ret = drm_sman_set_range(&dev_priv->sman, VIA_MEM_AGP, 0,
|
||||
agp.size >> VIA_MM_ALIGN_SHIFT);
|
||||
agp->size >> VIA_MM_ALIGN_SHIFT);
|
||||
|
||||
if (ret) {
|
||||
DRM_ERROR("AGP memory manager initialisation error\n");
|
||||
|
@ -53,25 +50,22 @@ int via_agp_init(DRM_IOCTL_ARGS)
|
|||
}
|
||||
|
||||
dev_priv->agp_initialized = 1;
|
||||
dev_priv->agp_offset = agp.offset;
|
||||
dev_priv->agp_offset = agp->offset;
|
||||
mutex_unlock(&dev->struct_mutex);
|
||||
|
||||
DRM_DEBUG("offset = %u, size = %u", agp.offset, agp.size);
|
||||
DRM_DEBUG("offset = %u, size = %u", agp->offset, agp->size);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int via_fb_init(DRM_IOCTL_ARGS)
|
||||
int via_fb_init(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_via_fb_t fb;
|
||||
drm_via_fb_t *fb = data;
|
||||
drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
|
||||
int ret;
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(fb, (drm_via_fb_t __user *) data, sizeof(fb));
|
||||
|
||||
mutex_lock(&dev->struct_mutex);
|
||||
ret = drm_sman_set_range(&dev_priv->sman, VIA_MEM_VIDEO, 0,
|
||||
fb.size >> VIA_MM_ALIGN_SHIFT);
|
||||
fb->size >> VIA_MM_ALIGN_SHIFT);
|
||||
|
||||
if (ret) {
|
||||
DRM_ERROR("VRAM memory manager initialisation error\n");
|
||||
|
@ -80,10 +74,10 @@ int via_fb_init(DRM_IOCTL_ARGS)
|
|||
}
|
||||
|
||||
dev_priv->vram_initialized = 1;
|
||||
dev_priv->vram_offset = fb.offset;
|
||||
dev_priv->vram_offset = fb->offset;
|
||||
|
||||
mutex_unlock(&dev->struct_mutex);
|
||||
DRM_DEBUG("offset = %u, size = %u", fb.offset, fb.size);
|
||||
DRM_DEBUG("offset = %u, size = %u", fb->offset, fb->size);
|
||||
|
||||
return 0;
|
||||
|
||||
|
@ -121,80 +115,71 @@ void via_lastclose(struct drm_device *dev)
|
|||
mutex_unlock(&dev->struct_mutex);
|
||||
}
|
||||
|
||||
int via_mem_alloc(DRM_IOCTL_ARGS)
|
||||
int via_mem_alloc(struct drm_device *dev, void *data,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
|
||||
drm_via_mem_t mem;
|
||||
drm_via_mem_t *mem = data;
|
||||
int retval = 0;
|
||||
struct drm_memblock_item *item;
|
||||
drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
|
||||
unsigned long tmpSize;
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(mem, (drm_via_mem_t __user *) data,
|
||||
sizeof(mem));
|
||||
|
||||
if (mem.type > VIA_MEM_AGP) {
|
||||
if (mem->type > VIA_MEM_AGP) {
|
||||
DRM_ERROR("Unknown memory type allocation\n");
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
mutex_lock(&dev->struct_mutex);
|
||||
if (0 == ((mem.type == VIA_MEM_VIDEO) ? dev_priv->vram_initialized :
|
||||
if (0 == ((mem->type == VIA_MEM_VIDEO) ? dev_priv->vram_initialized :
|
||||
dev_priv->agp_initialized)) {
|
||||
DRM_ERROR
|
||||
("Attempt to allocate from uninitialized memory manager.\n");
|
||||
mutex_unlock(&dev->struct_mutex);
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
tmpSize = (mem.size + VIA_MM_ALIGN_MASK) >> VIA_MM_ALIGN_SHIFT;
|
||||
item = drm_sman_alloc(&dev_priv->sman, mem.type, tmpSize, 0,
|
||||
(unsigned long)priv);
|
||||
tmpSize = (mem->size + VIA_MM_ALIGN_MASK) >> VIA_MM_ALIGN_SHIFT;
|
||||
item = drm_sman_alloc(&dev_priv->sman, mem->type, tmpSize, 0,
|
||||
(unsigned long)file_priv);
|
||||
mutex_unlock(&dev->struct_mutex);
|
||||
if (item) {
|
||||
mem.offset = ((mem.type == VIA_MEM_VIDEO) ?
|
||||
mem->offset = ((mem->type == VIA_MEM_VIDEO) ?
|
||||
dev_priv->vram_offset : dev_priv->agp_offset) +
|
||||
(item->mm->
|
||||
offset(item->mm, item->mm_info) << VIA_MM_ALIGN_SHIFT);
|
||||
mem.index = item->user_hash.key;
|
||||
mem->index = item->user_hash.key;
|
||||
} else {
|
||||
mem.offset = 0;
|
||||
mem.size = 0;
|
||||
mem.index = 0;
|
||||
mem->offset = 0;
|
||||
mem->size = 0;
|
||||
mem->index = 0;
|
||||
DRM_DEBUG("Video memory allocation failed\n");
|
||||
retval = DRM_ERR(ENOMEM);
|
||||
retval = -ENOMEM;
|
||||
}
|
||||
DRM_COPY_TO_USER_IOCTL((drm_via_mem_t __user *) data, mem, sizeof(mem));
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
int via_mem_free(DRM_IOCTL_ARGS)
|
||||
int via_mem_free(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_via_private_t *dev_priv = dev->dev_private;
|
||||
drm_via_mem_t mem;
|
||||
drm_via_mem_t *mem = data;
|
||||
int ret;
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(mem, (drm_via_mem_t __user *) data,
|
||||
sizeof(mem));
|
||||
|
||||
mutex_lock(&dev->struct_mutex);
|
||||
ret = drm_sman_free_key(&dev_priv->sman, mem.index);
|
||||
ret = drm_sman_free_key(&dev_priv->sman, mem->index);
|
||||
mutex_unlock(&dev->struct_mutex);
|
||||
DRM_DEBUG("free = 0x%lx\n", mem.index);
|
||||
DRM_DEBUG("free = 0x%lx\n", mem->index);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
void via_reclaim_buffers_locked(struct drm_device * dev, struct file *filp)
|
||||
void via_reclaim_buffers_locked(struct drm_device * dev,
|
||||
struct drm_file *file_priv)
|
||||
{
|
||||
drm_via_private_t *dev_priv = dev->dev_private;
|
||||
struct drm_file *priv = filp->private_data;
|
||||
|
||||
mutex_lock(&dev->struct_mutex);
|
||||
if (drm_sman_owner_clean(&dev_priv->sman, (unsigned long)priv)) {
|
||||
if (drm_sman_owner_clean(&dev_priv->sman, (unsigned long)file_priv)) {
|
||||
mutex_unlock(&dev->struct_mutex);
|
||||
return;
|
||||
}
|
||||
|
@ -203,7 +188,7 @@ void via_reclaim_buffers_locked(struct drm_device * dev, struct file *filp)
|
|||
dev->driver->dma_quiescent(dev);
|
||||
}
|
||||
|
||||
drm_sman_owner_cleanup(&dev_priv->sman, (unsigned long)priv);
|
||||
drm_sman_owner_cleanup(&dev_priv->sman, (unsigned long)file_priv);
|
||||
mutex_unlock(&dev->struct_mutex);
|
||||
return;
|
||||
}
|
||||
|
|
|
@ -1026,12 +1026,12 @@ via_verify_command_stream(const uint32_t * buf, unsigned int size,
|
|||
case state_error:
|
||||
default:
|
||||
*hc_state = saved_state;
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
if (state == state_error) {
|
||||
*hc_state = saved_state;
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
@ -1082,11 +1082,11 @@ via_parse_command_stream(struct drm_device * dev, const uint32_t * buf,
|
|||
break;
|
||||
case state_error:
|
||||
default:
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
if (state == state_error) {
|
||||
return DRM_ERR(EINVAL);
|
||||
return -EINVAL;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -65,10 +65,9 @@ void via_release_futex(drm_via_private_t * dev_priv, int context)
|
|||
}
|
||||
}
|
||||
|
||||
int via_decoder_futex(DRM_IOCTL_ARGS)
|
||||
int via_decoder_futex(struct drm_device *dev, void *data, struct drm_file *file_priv)
|
||||
{
|
||||
DRM_DEVICE;
|
||||
drm_via_futex_t fx;
|
||||
drm_via_futex_t *fx = data;
|
||||
volatile int *lock;
|
||||
drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
|
||||
drm_via_sarea_t *sAPriv = dev_priv->sarea_priv;
|
||||
|
@ -76,21 +75,18 @@ int via_decoder_futex(DRM_IOCTL_ARGS)
|
|||
|
||||
DRM_DEBUG("%s\n", __FUNCTION__);
|
||||
|
||||
DRM_COPY_FROM_USER_IOCTL(fx, (drm_via_futex_t __user *) data,
|
||||
sizeof(fx));
|
||||
|
||||
if (fx.lock > VIA_NR_XVMC_LOCKS)
|
||||
if (fx->lock > VIA_NR_XVMC_LOCKS)
|
||||
return -EFAULT;
|
||||
|
||||
lock = (volatile int *)XVMCLOCKPTR(sAPriv, fx.lock);
|
||||
lock = (volatile int *)XVMCLOCKPTR(sAPriv, fx->lock);
|
||||
|
||||
switch (fx.func) {
|
||||
switch (fx->func) {
|
||||
case VIA_FUTEX_WAIT:
|
||||
DRM_WAIT_ON(ret, dev_priv->decoder_queue[fx.lock],
|
||||
(fx.ms / 10) * (DRM_HZ / 100), *lock != fx.val);
|
||||
DRM_WAIT_ON(ret, dev_priv->decoder_queue[fx->lock],
|
||||
(fx->ms / 10) * (DRM_HZ / 100), *lock != fx->val);
|
||||
return ret;
|
||||
case VIA_FUTEX_WAKE:
|
||||
DRM_WAKEUP(&(dev_priv->decoder_queue[fx.lock]));
|
||||
DRM_WAKEUP(&(dev_priv->decoder_queue[fx->lock]));
|
||||
return 0;
|
||||
}
|
||||
return 0;
|
||||
|
|
Loading…
Reference in a new issue