/** * \file drm_proc.h * /proc support for DRM * * \author Rickard E. (Rik) Faith * \author Gareth Hughes * * \par Acknowledgements: * Matthew J Sottek sent in a patch to fix * the problem with the proc files not outputting all their information. */ /* * Created: Mon Jan 11 09:48:47 1999 by faith@valinux.com * * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas. * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California. * All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice (including the next * paragraph) shall be included in all copies or substantial portions of the * Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ #include "drmP.h" static int DRM(name_info)(char *buf, char **start, off_t offset, int request, int *eof, void *data); static int DRM(vm_info)(char *buf, char **start, off_t offset, int request, int *eof, void *data); static int DRM(clients_info)(char *buf, char **start, off_t offset, int request, int *eof, void *data); static int DRM(queues_info)(char *buf, char **start, off_t offset, int request, int *eof, void *data); static int DRM(bufs_info)(char *buf, char **start, off_t offset, int request, int *eof, void *data); #if DRM_DEBUG_CODE static int DRM(vma_info)(char *buf, char **start, off_t offset, int request, int *eof, void *data); #endif /** * Proc file list. */ struct drm_proc_list { const char *name; /**< file name */ int (*f)(char *, char **, off_t, int, int *, void *); /**< proc callback*/ } DRM(proc_list)[] = { { "name", DRM(name_info) }, { "mem", DRM(mem_info) }, { "vm", DRM(vm_info) }, { "clients", DRM(clients_info) }, { "queues", DRM(queues_info) }, { "bufs", DRM(bufs_info) }, #if DRM_DEBUG_CODE { "vma", DRM(vma_info) }, #endif }; #define DRM_PROC_ENTRIES (sizeof(DRM(proc_list))/sizeof(DRM(proc_list)[0])) /** * Initialize the DRI proc filesystem for a device. * * \param dev DRM device. * \param minor device minor number. * \param root DRI proc dir entry. * \param dev_root resulting DRI device proc dir entry. * \return root entry pointer on success, or NULL on failure. * * Create the DRI proc root entry "/proc/dri", the device proc root entry * "/proc/dri/%minor%/", and each entry in proc_list as * "/proc/dri/%minor%/%name%". */ int DRM(proc_init)(drm_device_t *dev, int minor, struct proc_dir_entry *root, struct proc_dir_entry **dev_root) { struct proc_dir_entry *ent; int i, j; char name[64]; sprintf(name, "%d", minor); *dev_root = create_proc_entry(name, S_IFDIR, root); if (!*dev_root) { DRM_ERROR("Cannot create /proc/dri/%s\n", name); return -1; } for (i = 0; i < DRM_PROC_ENTRIES; i++) { ent = create_proc_entry(DRM(proc_list)[i].name, S_IFREG|S_IRUGO, *dev_root); if (!ent) { DRM_ERROR("Cannot create /proc/dri/%s/%s\n", name, DRM(proc_list)[i].name); for (j = 0; j < i; j++) remove_proc_entry(DRM(proc_list)[i].name, *dev_root); remove_proc_entry(name, root); return -1; } ent->read_proc = DRM(proc_list)[i].f; ent->data = dev; } return 0; } /** * Cleanup the proc filesystem resources. * * \param minor device minor number. * \param root DRI proc dir entry. * \param dev_root DRI device proc dir entry. * \return always zero. * * Remove all proc entries created by proc_init(). */ int DRM(proc_cleanup)(int minor, struct proc_dir_entry *root, struct proc_dir_entry *dev_root) { int i; char name[64]; if (!root || !dev_root) return 0; for (i = 0; i < DRM_PROC_ENTRIES; i++) remove_proc_entry(DRM(proc_list)[i].name, dev_root); sprintf(name, "%d", minor); remove_proc_entry(name, root); return 0; } /** * Called when "/proc/dri/.../name" is read. * * \param buf output buffer. * \param start start of output data. * \param offset requested start offset. * \param request requested number of bytes. * \param eof whether there is no more data to return. * \param data private data. * \return number of written bytes. * * Prints the device name together with the bus id if available. */ static int DRM(name_info)(char *buf, char **start, off_t offset, int request, int *eof, void *data) { drm_device_t *dev = (drm_device_t *)data; int len = 0; if (offset > DRM_PROC_LIMIT) { *eof = 1; return 0; } *start = &buf[offset]; *eof = 0; if (dev->unique) { DRM_PROC_PRINT("%s 0x%lx %s\n", dev->name, (long)old_encode_dev(dev->device), dev->unique); } else { DRM_PROC_PRINT("%s 0x%lx\n", dev->name, (long)old_encode_dev(dev->device)); } if (len > request + offset) return request; *eof = 1; return len - offset; } /** * Called when "/proc/dri/.../vm" is read. * * \param buf output buffer. * \param start start of output data. * \param offset requested start offset. * \param request requested number of bytes. * \param eof whether there is no more data to return. * \param data private data. * \return number of written bytes. * * Prints information about all mappings in drm_device::maplist. */ static int DRM(_vm_info)(char *buf, char **start, off_t offset, int request, int *eof, void *data) { drm_device_t *dev = (drm_device_t *)data; int len = 0; drm_map_t *map; drm_map_list_t *r_list; struct list_head *list; /* Hardcoded from _DRM_FRAME_BUFFER, _DRM_REGISTERS, _DRM_SHM, _DRM_AGP, and _DRM_SCATTER_GATHER. */ const char *types[] = { "FB", "REG", "SHM", "AGP", "SG" }; const char *type; int i; if (offset > DRM_PROC_LIMIT) { *eof = 1; return 0; } *start = &buf[offset]; *eof = 0; DRM_PROC_PRINT("slot offset size type flags " "address mtrr\n\n"); i = 0; if (dev->maplist != NULL) list_for_each(list, &dev->maplist->head) { r_list = list_entry(list, drm_map_list_t, head); map = r_list->map; if(!map) continue; if (map->type < 0 || map->type > 4) type = "??"; else type = types[map->type]; DRM_PROC_PRINT("%4d 0x%08lx 0x%08lx %4.4s 0x%02x 0x%08lx ", i, map->offset, map->size, type, map->flags, (unsigned long)map->handle); if (map->mtrr < 0) { DRM_PROC_PRINT("none\n"); } else { DRM_PROC_PRINT("%4d\n", map->mtrr); } i++; } if (len > request + offset) return request; *eof = 1; return len - offset; } /** * Simply calls _vm_info() while holding the drm_device::struct_sem lock. */ static int DRM(vm_info)(char *buf, char **start, off_t offset, int request, int *eof, void *data) { drm_device_t *dev = (drm_device_t *)data; int ret; down(&dev->struct_sem); ret = DRM(_vm_info)(buf, start, offset, request, eof, data); up(&dev->struct_sem); return ret; } /** * Called when "/proc/dri/.../queues" is read. * * \param buf output buffer. * \param start start of output data. * \param offset requested start offset. * \param request requested number of bytes. * \param eof whether there is no more data to return. * \param data private data. * \return number of written bytes. */ static int DRM(_queues_info)(char *buf, char **start, off_t offset, int request, int *eof, void *data) { drm_device_t *dev = (drm_device_t *)data; int len = 0; int i; drm_queue_t *q; if (offset > DRM_PROC_LIMIT) { *eof = 1; return 0; } *start = &buf[offset]; *eof = 0; DRM_PROC_PRINT(" ctx/flags use fin" " blk/rw/rwf wait flushed queued" " locks\n\n"); for (i = 0; i < dev->queue_count; i++) { q = dev->queuelist[i]; atomic_inc(&q->use_count); DRM_PROC_PRINT_RET(atomic_dec(&q->use_count), "%5d/0x%03x %5d %5d" " %5d/%c%c/%c%c%c %5Zd\n", i, q->flags, atomic_read(&q->use_count), atomic_read(&q->finalization), atomic_read(&q->block_count), atomic_read(&q->block_read) ? 'r' : '-', atomic_read(&q->block_write) ? 'w' : '-', waitqueue_active(&q->read_queue) ? 'r':'-', waitqueue_active(&q->write_queue) ? 'w':'-', waitqueue_active(&q->flush_queue) ? 'f':'-', DRM_BUFCOUNT(&q->waitlist)); atomic_dec(&q->use_count); } if (len > request + offset) return request; *eof = 1; return len - offset; } /** * Simply calls _queues_info() while holding the drm_device::struct_sem lock. */ static int DRM(queues_info)(char *buf, char **start, off_t offset, int request, int *eof, void *data) { drm_device_t *dev = (drm_device_t *)data; int ret; down(&dev->struct_sem); ret = DRM(_queues_info)(buf, start, offset, request, eof, data); up(&dev->struct_sem); return ret; } /** * Called when "/proc/dri/.../bufs" is read. * * \param buf output buffer. * \param start start of output data. * \param offset requested start offset. * \param request requested number of bytes. * \param eof whether there is no more data to return. * \param data private data. * \return number of written bytes. */ static int DRM(_bufs_info)(char *buf, char **start, off_t offset, int request, int *eof, void *data) { drm_device_t *dev = (drm_device_t *)data; int len = 0; drm_device_dma_t *dma = dev->dma; int i; if (!dma || offset > DRM_PROC_LIMIT) { *eof = 1; return 0; } *start = &buf[offset]; *eof = 0; DRM_PROC_PRINT(" o size count free segs pages kB\n\n"); for (i = 0; i <= DRM_MAX_ORDER; i++) { if (dma->bufs[i].buf_count) DRM_PROC_PRINT("%2d %8d %5d %5d %5d %5d %5ld\n", i, dma->bufs[i].buf_size, dma->bufs[i].buf_count, atomic_read(&dma->bufs[i] .freelist.count), dma->bufs[i].seg_count, dma->bufs[i].seg_count *(1 << dma->bufs[i].page_order), (dma->bufs[i].seg_count * (1 << dma->bufs[i].page_order)) * PAGE_SIZE / 1024); } DRM_PROC_PRINT("\n"); for (i = 0; i < dma->buf_count; i++) { if (i && !(i%32)) DRM_PROC_PRINT("\n"); DRM_PROC_PRINT(" %d", dma->buflist[i]->list); } DRM_PROC_PRINT("\n"); if (len > request + offset) return request; *eof = 1; return len - offset; } /** * Simply calls _bufs_info() while holding the drm_device::struct_sem lock. */ static int DRM(bufs_info)(char *buf, char **start, off_t offset, int request, int *eof, void *data) { drm_device_t *dev = (drm_device_t *)data; int ret; down(&dev->struct_sem); ret = DRM(_bufs_info)(buf, start, offset, request, eof, data); up(&dev->struct_sem); return ret; } /** * Called when "/proc/dri/.../clients" is read. * * \param buf output buffer. * \param start start of output data. * \param offset requested start offset. * \param request requested number of bytes. * \param eof whether there is no more data to return. * \param data private data. * \return number of written bytes. */ static int DRM(_clients_info)(char *buf, char **start, off_t offset, int request, int *eof, void *data) { drm_device_t *dev = (drm_device_t *)data; int len = 0; drm_file_t *priv; if (offset > DRM_PROC_LIMIT) { *eof = 1; return 0; } *start = &buf[offset]; *eof = 0; DRM_PROC_PRINT("a dev pid uid magic ioctls\n\n"); for (priv = dev->file_first; priv; priv = priv->next) { DRM_PROC_PRINT("%c %3d %5d %5d %10u %10lu\n", priv->authenticated ? 'y' : 'n', priv->minor, priv->pid, priv->uid, priv->magic, priv->ioctl_count); } if (len > request + offset) return request; *eof = 1; return len - offset; } /** * Simply calls _clients_info() while holding the drm_device::struct_sem lock. */ static int DRM(clients_info)(char *buf, char **start, off_t offset, int request, int *eof, void *data) { drm_device_t *dev = (drm_device_t *)data; int ret; down(&dev->struct_sem); ret = DRM(_clients_info)(buf, start, offset, request, eof, data); up(&dev->struct_sem); return ret; } #if DRM_DEBUG_CODE static int DRM(_vma_info)(char *buf, char **start, off_t offset, int request, int *eof, void *data) { drm_device_t *dev = (drm_device_t *)data; int len = 0; drm_vma_entry_t *pt; struct vm_area_struct *vma; #if defined(__i386__) unsigned int pgprot; #endif if (offset > DRM_PROC_LIMIT) { *eof = 1; return 0; } *start = &buf[offset]; *eof = 0; DRM_PROC_PRINT("vma use count: %d, high_memory = %p, 0x%08lx\n", atomic_read(&dev->vma_count), high_memory, virt_to_phys(high_memory)); for (pt = dev->vmalist; pt; pt = pt->next) { if (!(vma = pt->vma)) continue; DRM_PROC_PRINT("\n%5d 0x%08lx-0x%08lx %c%c%c%c%c%c 0x%08lx", pt->pid, vma->vm_start, vma->vm_end, vma->vm_flags & VM_READ ? 'r' : '-', vma->vm_flags & VM_WRITE ? 'w' : '-', vma->vm_flags & VM_EXEC ? 'x' : '-', vma->vm_flags & VM_MAYSHARE ? 's' : 'p', vma->vm_flags & VM_LOCKED ? 'l' : '-', vma->vm_flags & VM_IO ? 'i' : '-', VM_OFFSET(vma)); #if defined(__i386__) pgprot = pgprot_val(vma->vm_page_prot); DRM_PROC_PRINT(" %c%c%c%c%c%c%c%c%c", pgprot & _PAGE_PRESENT ? 'p' : '-', pgprot & _PAGE_RW ? 'w' : 'r', pgprot & _PAGE_USER ? 'u' : 's', pgprot & _PAGE_PWT ? 't' : 'b', pgprot & _PAGE_PCD ? 'u' : 'c', pgprot & _PAGE_ACCESSED ? 'a' : '-', pgprot & _PAGE_DIRTY ? 'd' : '-', pgprot & _PAGE_PSE ? 'm' : 'k', pgprot & _PAGE_GLOBAL ? 'g' : 'l' ); #endif DRM_PROC_PRINT("\n"); } if (len > request + offset) return request; *eof = 1; return len - offset; } static int DRM(vma_info)(char *buf, char **start, off_t offset, int request, int *eof, void *data) { drm_device_t *dev = (drm_device_t *)data; int ret; down(&dev->struct_sem); ret = DRM(_vma_info)(buf, start, offset, request, eof, data); up(&dev->struct_sem); return ret; } #endif clude "via_drmclient.h" #endif /* * With the arrival of libdrm there is a need to version this file. * As usual, bump MINOR for new features, MAJOR for changes that create * backwards incompatibilities, (which should be avoided whenever possible). */ #define VIA_DRM_DRIVER_DATE "20060616" #define VIA_DRM_DRIVER_MAJOR 2 #define VIA_DRM_DRIVER_MINOR 10 #define VIA_DRM_DRIVER_PATCHLEVEL 2 #define VIA_DRM_DRIVER_VERSION (((VIA_DRM_DRIVER_MAJOR) << 16) | (VIA_DRM_DRIVER_MINOR)) #define VIA_NR_SAREA_CLIPRECTS 8 #define VIA_NR_XVMC_PORTS 10 #define VIA_NR_XVMC_LOCKS 5 #define VIA_MAX_CACHELINE_SIZE 64 #define XVMCLOCKPTR(saPriv,lockNo) \ ((volatile drm_hw_lock_t *)(((((unsigned long) (saPriv)->XvMCLockArea) + \ (VIA_MAX_CACHELINE_SIZE - 1)) & \ ~(VIA_MAX_CACHELINE_SIZE - 1)) + \ VIA_MAX_CACHELINE_SIZE*(lockNo))) /* Each region is a minimum of 64k, and there are at most 64 of them. */ #define VIA_NR_TEX_REGIONS 64 #define VIA_LOG_MIN_TEX_REGION_SIZE 16 #endif #define VIA_UPLOAD_TEX0IMAGE 0x1 /* handled clientside */ #define VIA_UPLOAD_TEX1IMAGE 0x2 /* handled clientside */ #define VIA_UPLOAD_CTX 0x4 #define VIA_UPLOAD_BUFFERS 0x8 #define VIA_UPLOAD_TEX0 0x10 #define VIA_UPLOAD_TEX1 0x20 #define VIA_UPLOAD_CLIPRECTS 0x40 #define VIA_UPLOAD_ALL 0xff /* VIA specific ioctls */ #define DRM_VIA_ALLOCMEM 0x00 #define DRM_VIA_FREEMEM 0x01 #define DRM_VIA_AGP_INIT 0x02 #define DRM_VIA_FB_INIT 0x03 #define DRM_VIA_MAP_INIT 0x04 #define DRM_VIA_DEC_FUTEX 0x05 #define NOT_USED #define DRM_VIA_DMA_INIT 0x07 #define DRM_VIA_CMDBUFFER 0x08 #define DRM_VIA_FLUSH 0x09 #define DRM_VIA_PCICMD 0x0a #define DRM_VIA_CMDBUF_SIZE 0x0b #define NOT_USED #define DRM_VIA_WAIT_IRQ 0x0d #define DRM_VIA_DMA_BLIT 0x0e #define DRM_VIA_BLIT_SYNC 0x0f #define DRM_IOCTL_VIA_ALLOCMEM DRM_IOWR(DRM_COMMAND_BASE + DRM_VIA_ALLOCMEM, drm_via_mem_t) #define DRM_IOCTL_VIA_FREEMEM DRM_IOW( DRM_COMMAND_BASE + DRM_VIA_FREEMEM, drm_via_mem_t) #define DRM_IOCTL_VIA_AGP_INIT DRM_IOWR(DRM_COMMAND_BASE + DRM_VIA_AGP_INIT, drm_via_agp_t) #define DRM_IOCTL_VIA_FB_INIT DRM_IOWR(DRM_COMMAND_BASE + DRM_VIA_FB_INIT, drm_via_fb_t) #define DRM_IOCTL_VIA_MAP_INIT DRM_IOWR(DRM_COMMAND_BASE + DRM_VIA_MAP_INIT, drm_via_init_t) #define DRM_IOCTL_VIA_DEC_FUTEX DRM_IOW( DRM_COMMAND_BASE + DRM_VIA_DEC_FUTEX, drm_via_futex_t) #define DRM_IOCTL_VIA_DMA_INIT DRM_IOWR(DRM_COMMAND_BASE + DRM_VIA_DMA_INIT, drm_via_dma_init_t) #define DRM_IOCTL_VIA_CMDBUFFER DRM_IOW( DRM_COMMAND_BASE + DRM_VIA_CMDBUFFER, drm_via_cmdbuffer_t) #define DRM_IOCTL_VIA_FLUSH DRM_IO( DRM_COMMAND_BASE + DRM_VIA_FLUSH) #define DRM_IOCTL_VIA_PCICMD DRM_IOW( DRM_COMMAND_BASE + DRM_VIA_PCICMD, drm_via_cmdbuffer_t) #define DRM_IOCTL_VIA_CMDBUF_SIZE DRM_IOWR( DRM_COMMAND_BASE + DRM_VIA_CMDBUF_SIZE, \ drm_via_cmdbuf_size_t) #define DRM_IOCTL_VIA_WAIT_IRQ DRM_IOWR( DRM_COMMAND_BASE + DRM_VIA_WAIT_IRQ, drm_via_irqwait_t) #define DRM_IOCTL_VIA_DMA_BLIT DRM_IOW(DRM_COMMAND_BASE + DRM_VIA_DMA_BLIT, drm_via_dmablit_t) #define DRM_IOCTL_VIA_BLIT_SYNC DRM_IOW(DRM_COMMAND_BASE + DRM_VIA_BLIT_SYNC, drm_via_blitsync_t) /* Indices into buf.Setup where various bits of state are mirrored per * context and per buffer. These can be fired at the card as a unit, * or in a piecewise fashion as required. */ #define VIA_TEX_SETUP_SIZE 8 /* Flags for clear ioctl */ #define VIA_FRONT 0x1 #define VIA_BACK 0x2 #define VIA_DEPTH 0x4 #define VIA_STENCIL 0x8 #define VIA_MEM_VIDEO 0 /* matches drm constant */ #define VIA_MEM_AGP 1 /* matches drm constant */ #define VIA_MEM_SYSTEM 2 #define VIA_MEM_MIXED 3 #define VIA_MEM_UNKNOWN 4 typedef struct { uint32_t offset; uint32_t size; } drm_via_agp_t; typedef struct { uint32_t offset; uint32_t size; } drm_via_fb_t; typedef struct { uint32_t context; uint32_t type; uint32_t size; unsigned long index; unsigned long offset; } drm_via_mem_t; typedef struct _drm_via_init { enum { VIA_INIT_MAP = 0x01, VIA_CLEANUP_MAP = 0x02 } func; unsigned long sarea_priv_offset; unsigned long fb_offset; unsigned long mmio_offset; unsigned long agpAddr; } drm_via_init_t; typedef struct _drm_via_futex { enum { VIA_FUTEX_WAIT = 0x00, VIA_FUTEX_WAKE = 0X01 } func; uint32_t ms; uint32_t lock; uint32_t val; } drm_via_futex_t; typedef struct _drm_via_dma_init { enum { VIA_INIT_DMA = 0x01, VIA_CLEANUP_DMA = 0x02, VIA_DMA_INITIALIZED = 0x03 } func; unsigned long offset; unsigned long size; unsigned long reg_pause_addr; } drm_via_dma_init_t; typedef struct _drm_via_cmdbuffer { char __user *buf; unsigned long size; } drm_via_cmdbuffer_t; /* Warning: If you change the SAREA structure you must change the Xserver * structure as well */ typedef struct _drm_via_tex_region { unsigned char next, prev; /* indices to form a circular LRU */ unsigned char inUse; /* owned by a client, or free? */ int age; /* tracked by clients to update local LRU's */ } drm_via_tex_region_t; typedef struct _drm_via_sarea { unsigned int dirty; unsigned int nbox; drm_clip_rect_t boxes[VIA_NR_SAREA_CLIPRECTS]; drm_via_tex_region_t texList[VIA_NR_TEX_REGIONS + 1]; int texAge; /* last time texture was uploaded */ int ctxOwner; /* last context to upload state */ int vertexPrim; /* * Below is for XvMC. * We want the lock integers alone on, and aligned to, a cache line. * Therefore this somewhat strange construct. */ char XvMCLockArea[VIA_MAX_CACHELINE_SIZE * (VIA_NR_XVMC_LOCKS + 1)]; unsigned int XvMCDisplaying[VIA_NR_XVMC_PORTS]; unsigned int XvMCSubPicOn[VIA_NR_XVMC_PORTS]; unsigned int XvMCCtxNoGrabbed; /* Last context to hold decoder */ /* Used by the 3d driver only at this point, for pageflipping: */ unsigned int pfCurrentOffset; } drm_via_sarea_t; typedef struct _drm_via_cmdbuf_size { enum { VIA_CMDBUF_SPACE = 0x01, VIA_CMDBUF_LAG = 0x02 } func; int wait; uint32_t size; } drm_via_cmdbuf_size_t; typedef enum { VIA_IRQ_ABSOLUTE = 0x0, VIA_IRQ_RELATIVE = 0x1, VIA_IRQ_SIGNAL = 0x10000000, VIA_IRQ_FORCE_SEQUENCE = 0x20000000 } via_irq_seq_type_t; #define VIA_IRQ_FLAGS_MASK 0xF0000000 enum drm_via_irqs{ drm_via_irq_hqv0 = 0, drm_via_irq_hqv1, drm_via_irq_dma0_dd, drm_via_irq_dma0_td, drm_via_irq_dma1_dd, drm_via_irq_dma1_td, drm_via_irq_num }; struct drm_via_wait_irq_request{ unsigned irq; via_irq_seq_type_t type; uint32_t sequence; uint32_t signal; }; typedef union drm_via_irqwait { struct drm_via_wait_irq_request request; struct drm_wait_vblank_reply reply; } drm_via_irqwait_t; typedef struct drm_via_blitsync { uint32_t sync_handle; unsigned engine; } drm_via_blitsync_t; /* * Below,"flags" is currently unused but will be used for possible future * extensions like kernel space bounce buffers for bad alignments and * blit engine busy-wait polling for better latency in the absence of * interrupts. */ typedef struct drm_via_dmablit { uint32_t num_lines; uint32_t line_length; uint32_t fb_addr; uint32_t fb_stride; unsigned char *mem_addr; uint32_t mem_stride; uint32_t flags;