| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Date: Fri, 30 May 2008 17:34:58 -0700
From: Greg KH <gregkh@...e.de>
To: linux-kernel@...r.kernel.org
Subject: Re: via agp patches
This primarily looks like coding style cleanup, removing some typedefs
and fixing lines that are longer than 80 characters.
If there are any real code changes in here, I didn't notice them.
---
drivers/char/drm/via_3d_reg.h | 12 -
drivers/char/drm/via_dma.c | 353 +++++++++++++++++++++++++++-------------
drivers/char/drm/via_dmablit.c | 325 +++++++++++++++++++++---------------
drivers/char/drm/via_dmablit.h | 22 +-
drivers/char/drm/via_drm.h | 142 ++++++++++------
drivers/char/drm/via_drv.c | 13 +
drivers/char/drm/via_drv.h | 93 ++++++----
drivers/char/drm/via_irq.c | 66 ++++---
drivers/char/drm/via_map.c | 75 +++++++-
drivers/char/drm/via_mm.c | 249 ++++++++++++++++++++++------
drivers/char/drm/via_verifier.c | 269 +++++++++++++++---------------
drivers/char/drm/via_verifier.h | 64 +++----
drivers/char/drm/via_video.c | 70 ++++---
13 files changed, 1111 insertions(+), 642 deletions(-)
--- a/drivers/char/drm/via_3d_reg.h
+++ b/drivers/char/drm/via_3d_reg.h
@@ -1605,18 +1605,18 @@
#define HC_ACMD_H4COUNT_MASK 0x01fffe00
#define HC_ACMD_H4COUNT_SHIFT 9
-/********************************************************************************
+/******************************************************************************
** Define Header
-********************************************************************************/
+*******************************************************************************/
#define HC_HEADER2 0xF210F110
-/********************************************************************************
+/******************************************************************************
** Define Dummy Value
-********************************************************************************/
+*******************************************************************************/
#define HC_DUMMY 0xCCCCCCCC
-/********************************************************************************
+/******************************************************************************
** Define for DMA use
-********************************************************************************/
+*******************************************************************************/
#define HALCYON_HEADER2 0XF210F110
#define HALCYON_FIRECMD 0XEE100000
#define HALCYON_FIREMASK 0XFFF00000
--- a/drivers/char/drm/via_dmablit.c
+++ b/drivers/char/drm/via_dmablit.c
@@ -30,8 +30,8 @@
/*
* Unmaps the DMA mappings.
* FIXME: Is this a NoOp on x86? Also
- * FIXME: What happens if this one is called and a pending blit has previously done
- * the same DMA mappings?
+ * FIXME: What happens if this one is called and a pending
+ * blit has previously done the same DMA mappings?
*/
#include "drmP.h"
@@ -45,12 +45,12 @@
#define VIA_PGOFF(x) (((unsigned long)(x)) & ~PAGE_MASK)
#define VIA_PFN(x) ((unsigned long)(x) >> PAGE_SHIFT)
-typedef struct _drm_via_descriptor {
+struct drm_via_descriptor {
uint32_t mem_addr;
uint32_t dev_addr;
uint32_t size;
uint32_t next;
-} drm_via_descriptor_t;
+} ;
/*
@@ -60,24 +60,26 @@ typedef struct _drm_via_descriptor {
static void
-via_unmap_blit_from_device(struct pci_dev *pdev, drm_via_sg_info_t *vsg)
+via_unmap_blit_from_device(struct pci_dev *pdev, struct drm_via_sg_info *vsg)
{
int num_desc = vsg->num_desc;
unsigned cur_descriptor_page = num_desc / vsg->descriptors_per_page;
unsigned descriptor_this_page = num_desc % vsg->descriptors_per_page;
- drm_via_descriptor_t *desc_ptr = vsg->desc_pages[cur_descriptor_page] +
- descriptor_this_page;
+ struct drm_via_descriptor *desc_ptr =
+ vsg->desc_pages[cur_descriptor_page] + descriptor_this_page;
dma_addr_t next = vsg->chain_start;
- while(num_desc--) {
+ while (num_desc--) {
if (descriptor_this_page-- == 0) {
cur_descriptor_page--;
descriptor_this_page = vsg->descriptors_per_page - 1;
desc_ptr = vsg->desc_pages[cur_descriptor_page] +
descriptor_this_page;
}
- dma_unmap_single(&pdev->dev, next, sizeof(*desc_ptr), DMA_TO_DEVICE);
- dma_unmap_page(&pdev->dev, desc_ptr->mem_addr, desc_ptr->size, vsg->direction);
+ dma_unmap_single(&pdev->dev, next, sizeof(*desc_ptr),
+ DMA_TO_DEVICE);
+ dma_unmap_page(&pdev->dev, desc_ptr->mem_addr, desc_ptr->size,
+ vsg->direction);
next = (dma_addr_t) desc_ptr->next;
desc_ptr--;
}
@@ -85,15 +87,16 @@ via_unmap_blit_from_device(struct pci_de
/*
* If mode = 0, count how many descriptors are needed.
- * If mode = 1, Map the DMA pages for the device, put together and map also the descriptors.
- * Descriptors are run in reverse order by the hardware because we are not allowed to update the
- * 'next' field without syncing calls when the descriptor is already mapped.
+ * If mode = 1, Map the DMA pages for the device, put together and
+ * map also the descriptors. Descriptors are run in reverse order
+ * by the hardware because we are not allowed to update the 'next'
+ * field without syncing calls when the descriptor is already mapped.
*/
static void
via_map_blit_for_device(struct pci_dev *pdev,
- const drm_via_dmablit_t *xfer,
- drm_via_sg_info_t *vsg,
+ const struct drm_via_dmablit *xfer,
+ struct drm_via_sg_info *vsg,
int mode)
{
unsigned cur_descriptor_page = 0;
@@ -108,7 +111,7 @@ via_map_blit_for_device(struct pci_dev *
int num_desc = 0;
int cur_line;
dma_addr_t next = 0 | VIA_DMA_DPR_EC;
- drm_via_descriptor_t *desc_ptr = NULL;
+ struct drm_via_descriptor *desc_ptr = NULL;
if (mode == 1)
desc_ptr = vsg->desc_pages[cur_descriptor_page];
@@ -121,26 +124,29 @@ via_map_blit_for_device(struct pci_dev *
while (line_len > 0) {
- remaining_len = min(PAGE_SIZE-VIA_PGOFF(cur_mem), line_len);
+ remaining_len = min(PAGE_SIZE-VIA_PGOFF(cur_mem),
+ line_len);
line_len -= remaining_len;
if (mode == 1) {
desc_ptr->mem_addr =
dma_map_page(&pdev->dev,
- vsg->pages[VIA_PFN(cur_mem) -
- VIA_PFN(first_addr)],
- VIA_PGOFF(cur_mem), remaining_len,
- vsg->direction);
+ vsg->pages[VIA_PFN(cur_mem) -
+ VIA_PFN(first_addr)],
+ VIA_PGOFF(cur_mem), remaining_len,
+ vsg->direction);
desc_ptr->dev_addr = cur_fb;
desc_ptr->size = remaining_len;
desc_ptr->next = (uint32_t) next;
- next = dma_map_single(&pdev->dev, desc_ptr, sizeof(*desc_ptr),
- DMA_TO_DEVICE);
+ next = dma_map_single(&pdev->dev, desc_ptr,
+ sizeof(*desc_ptr), DMA_TO_DEVICE);
desc_ptr++;
- if (++num_descriptors_this_page >= vsg->descriptors_per_page) {
+ if (++num_descriptors_this_page >=
+ vsg->descriptors_per_page) {
num_descriptors_this_page = 0;
- desc_ptr = vsg->desc_pages[++cur_descriptor_page];
+ desc_ptr =
+ vsg->desc_pages[++cur_descriptor_page];
}
}
@@ -162,30 +168,31 @@ via_map_blit_for_device(struct pci_dev *
/*
* Function that frees up all resources for a blit. It is usable even if the
- * blit info has only been partially built as long as the status enum is consistent
- * with the actual status of the used resources.
+ * blit info has only been partially built as long as the status enum is
+ * consistent with the actual status of the used resources.
*/
-
static void
-via_free_sg_info(struct pci_dev *pdev, drm_via_sg_info_t *vsg)
+via_free_sg_info(struct pci_dev *pdev, struct drm_via_sg_info *vsg)
{
struct page *page;
int i;
- switch(vsg->state) {
+ switch (vsg->state) {
case dr_via_device_mapped:
via_unmap_blit_from_device(pdev, vsg);
case dr_via_desc_pages_alloc:
- for (i=0; i<vsg->num_desc_pages; ++i) {
+ for (i = 0; i < vsg->num_desc_pages; ++i) {
if (vsg->desc_pages[i] != NULL)
free_page((unsigned long)vsg->desc_pages[i]);
}
kfree(vsg->desc_pages);
case dr_via_pages_locked:
- for (i=0; i<vsg->num_pages; ++i) {
- if ( NULL != (page = vsg->pages[i])) {
- if (! PageReserved(page) && (DMA_FROM_DEVICE == vsg->direction))
+ for (i = 0; i < vsg->num_pages; ++i) {
+ page = vsg->pages[i];
+ if (NULL != page) {
+ if (!PageReserved(page) &&
+ (DMA_FROM_DEVICE == vsg->direction))
SetPageDirty(page);
page_cache_release(page);
}
@@ -207,36 +214,44 @@ via_free_sg_info(struct pci_dev *pdev, d
*/
static void
-via_fire_dmablit(struct drm_device *dev, drm_via_sg_info_t *vsg, int engine)
+via_fire_dmablit(struct drm_device *dev, struct drm_via_sg_info *vsg,
+ int engine)
{
- drm_via_private_t *dev_priv = (drm_via_private_t *)dev->dev_private;
+ struct drm_via_private *dev_priv =
+ (struct drm_via_private *)dev->dev_private;
VIA_WRITE(VIA_PCI_DMA_MAR0 + engine*0x10, 0);
VIA_WRITE(VIA_PCI_DMA_DAR0 + engine*0x10, 0);
- VIA_WRITE(VIA_PCI_DMA_CSR0 + engine*0x04, VIA_DMA_CSR_DD | VIA_DMA_CSR_TD |
- VIA_DMA_CSR_DE);
- VIA_WRITE(VIA_PCI_DMA_MR0 + engine*0x04, VIA_DMA_MR_CM | VIA_DMA_MR_TDIE);
+ VIA_WRITE(VIA_PCI_DMA_CSR0 + engine*0x04,
+ VIA_DMA_CSR_DD | VIA_DMA_CSR_TD | VIA_DMA_CSR_DE);
+ VIA_WRITE(VIA_PCI_DMA_MR0 + engine*0x04,
+ VIA_DMA_MR_CM | VIA_DMA_MR_TDIE);
VIA_WRITE(VIA_PCI_DMA_BCR0 + engine*0x10, 0);
VIA_WRITE(VIA_PCI_DMA_DPR0 + engine*0x10, vsg->chain_start);
DRM_WRITEMEMORYBARRIER();
- VIA_WRITE(VIA_PCI_DMA_CSR0 + engine*0x04, VIA_DMA_CSR_DE | VIA_DMA_CSR_TS);
+ VIA_WRITE(VIA_PCI_DMA_CSR0 + engine*0x04,
+ VIA_DMA_CSR_DE | VIA_DMA_CSR_TS);
VIA_READ(VIA_PCI_DMA_CSR0 + engine*0x04);
}
/*
- * Obtain a page pointer array and lock all pages into system memory. A segmentation violation will
- * occur here if the calling user does not have access to the submitted address.
+ * Obtain a page pointer array and lock all pages into system memory.
+ * A segmentation violation will occur here if the calling user
+ * does not have access to the submitted address.
*/
static int
-via_lock_all_dma_pages(drm_via_sg_info_t *vsg, drm_via_dmablit_t *xfer)
+via_lock_all_dma_pages(struct drm_via_sg_info *vsg,
+ struct drm_via_dmablit *xfer)
{
int ret;
unsigned long first_pfn = VIA_PFN(xfer->mem_addr);
- vsg->num_pages = VIA_PFN(xfer->mem_addr + (xfer->num_lines * xfer->mem_stride -1)) -
+ vsg->num_pages = VIA_PFN(xfer->mem_addr +
+ (xfer->num_lines * xfer->mem_stride - 1)) -
first_pfn + 1;
-
- if (NULL == (vsg->pages = vmalloc(sizeof(struct page *) * vsg->num_pages)))
+ vsg->pages = vmalloc(sizeof(struct page *) *
+ vsg->num_pages);
+ if (NULL == vsg->pages)
return -ENOMEM;
memset(vsg->pages, 0, sizeof(struct page *) * vsg->num_pages);
down_read(¤t->mm->mmap_sem);
@@ -259,38 +274,42 @@ via_lock_all_dma_pages(drm_via_sg_info_t
}
/*
- * Allocate DMA capable memory for the blit descriptor chain, and an array that keeps track of the
- * pages we allocate. We don't want to use kmalloc for the descriptor chain because it may be
- * quite large for some blits, and pages don't need to be contingous.
+ * Allocate DMA capable memory for the blit descriptor chain, and an
+ * array that keeps track of the pages we allocate. We don't want
+ * to use kmalloc for the descriptor chain because it may be
*/
static int
-via_alloc_desc_pages(drm_via_sg_info_t *vsg)
+via_alloc_desc_pages(struct drm_via_sg_info *vsg)
{
int i;
- vsg->descriptors_per_page = PAGE_SIZE / sizeof( drm_via_descriptor_t);
+ vsg->descriptors_per_page = PAGE_SIZE /
+ sizeof(struct drm_via_descriptor);
vsg->num_desc_pages = (vsg->num_desc + vsg->descriptors_per_page - 1) /
vsg->descriptors_per_page;
-
- if (NULL == (vsg->desc_pages = kcalloc(vsg->num_desc_pages, sizeof(void *), GFP_KERNEL)))
+ vsg->desc_pages = kcalloc(vsg->num_desc_pages,
+ sizeof(void *), GFP_KERNEL);
+ if (NULL == vsg->desc_pages)
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)))
+ for (i = 0; i < vsg->num_desc_pages; ++i) {
+ vsg->desc_pages[i] =
+ (struct drm_via_descriptor *) __get_free_page(GFP_KERNEL);
+ if (NULL == vsg->desc_pages[i])
return -ENOMEM;
}
- DRM_DEBUG("Allocated %d pages for %d descriptors.\n", vsg->num_desc_pages,
- vsg->num_desc);
+ DRM_DEBUG("Allocated %d pages for %d descriptors.\n", \
+ vsg->num_desc_pages, vsg->num_desc);
return 0;
}
static void
via_abort_dmablit(struct drm_device *dev, int engine)
{
- drm_via_private_t *dev_priv = (drm_via_private_t *)dev->dev_private;
+ struct drm_via_private *dev_priv =
+ (struct drm_via_private *)dev->dev_private;
VIA_WRITE(VIA_PCI_DMA_CSR0 + engine*0x04, VIA_DMA_CSR_TA);
}
@@ -298,32 +317,36 @@ via_abort_dmablit(struct drm_device *dev
static void
via_dmablit_engine_off(struct drm_device *dev, int engine)
{
- drm_via_private_t *dev_priv = (drm_via_private_t *)dev->dev_private;
+ struct drm_via_private *dev_priv =
+ (struct drm_via_private *)dev->dev_private;
- VIA_WRITE(VIA_PCI_DMA_CSR0 + engine*0x04, VIA_DMA_CSR_TD | VIA_DMA_CSR_DD);
+ VIA_WRITE(VIA_PCI_DMA_CSR0 + engine*0x04,
+ VIA_DMA_CSR_TD | VIA_DMA_CSR_DD);
}
/*
- * The dmablit part of the IRQ handler. Trying to do only reasonably fast things here.
- * The rest, like unmapping and freeing memory for done blits is done in a separate workqueue
- * task. Basically the task of the interrupt handler is to submit a new blit to the engine, while
+ * The dmablit part of the IRQ handler. Trying to do only reasonably
+ * fast things here. The rest, like unmapping and freeing memory for
+ * done blits is done in a separate workqueue task. Basically the
+ * task of the interrupt handler is to submit a new blit to the engine, while
* the workqueue task takes care of processing associated with the old blit.
*/
void
via_dmablit_handler(struct drm_device *dev, int engine, int from_irq)
{
- drm_via_private_t *dev_priv = (drm_via_private_t *)dev->dev_private;
- drm_via_blitq_t *blitq = dev_priv->blit_queues + engine;
+ struct drm_via_private *dev_priv =
+ (struct drm_via_private *)dev->dev_private;
+ struct drm_via_blitq *blitq = dev_priv->blit_queues + engine;
int cur;
int done_transfer;
- unsigned long irqsave=0;
+ unsigned long irqsave = 0;
uint32_t status = 0;
- DRM_DEBUG("DMA blit handler called. engine = %d, from_irq = %d, blitq = 0x%lx\n",
- engine, from_irq, (unsigned long) blitq);
+ DRM_DEBUG("DMA blit handler called. engine = %d, from_irq = %d, "
+ "blitq = 0x%lx\n", engine, from_irq, (unsigned long) blitq);
if (from_irq) {
spin_lock(&blitq->blit_lock);
@@ -332,8 +355,10 @@ via_dmablit_handler(struct drm_device *d
}
done_transfer = blitq->is_active &&
- (( status = VIA_READ(VIA_PCI_DMA_CSR0 + engine*0x04)) & VIA_DMA_CSR_TD);
- done_transfer = done_transfer || ( blitq->aborting && !(status & VIA_DMA_CSR_DE));
+ ((status = VIA_READ(VIA_PCI_DMA_CSR0 + engine*0x04)) &
+ VIA_DMA_CSR_TD);
+ done_transfer = done_transfer || (blitq->aborting &&
+ !(status & VIA_DMA_CSR_DE));
cur = blitq->cur;
if (done_transfer) {
@@ -357,7 +382,8 @@ via_dmablit_handler(struct drm_device *d
blitq->aborting = 0;
schedule_work(&blitq->wq);
- } else if (blitq->is_active && time_after_eq(jiffies, blitq->end)) {
+ } else if (blitq->is_active &&
+ time_after_eq(jiffies, blitq->end)) {
/*
* Abort transfer after one second.
@@ -378,9 +404,8 @@ via_dmablit_handler(struct drm_device *d
if (!timer_pending(&blitq->poll_timer))
mod_timer(&blitq->poll_timer, jiffies + 1);
} else {
- if (timer_pending(&blitq->poll_timer)) {
+ if (timer_pending(&blitq->poll_timer))
del_timer(&blitq->poll_timer);
- }
via_dmablit_engine_off(dev, engine);
}
}
@@ -399,7 +424,8 @@ via_dmablit_handler(struct drm_device *d
*/
static int
-via_dmablit_active(drm_via_blitq_t *blitq, int engine, uint32_t handle, wait_queue_head_t **queue)
+via_dmablit_active(struct drm_via_blitq *blitq, int engine, uint32_t handle,
+wait_queue_head_t **queue)
{
unsigned long irqsave;
uint32_t slot;
@@ -415,10 +441,10 @@ via_dmablit_active(drm_via_blitq_t *blit
((blitq->cur_blit_handle - handle) <= (1 << 23));
if (queue && active) {
- slot = handle - blitq->done_blit_handle + blitq->cur -1;
- if (slot >= VIA_NUM_BLIT_SLOTS) {
+ slot = handle - blitq->done_blit_handle + blitq->cur - 1;
+ if (slot >= VIA_NUM_BLIT_SLOTS)
slot -= VIA_NUM_BLIT_SLOTS;
- }
+
*queue = blitq->blit_queue + slot;
}
@@ -435,28 +461,32 @@ static int
via_dmablit_sync(struct drm_device *dev, uint32_t handle, int engine)
{
- drm_via_private_t *dev_priv = (drm_via_private_t *)dev->dev_private;
- drm_via_blitq_t *blitq = dev_priv->blit_queues + engine;
+ struct drm_via_private *dev_priv =
+ (struct drm_via_private *)dev->dev_private;
+ struct drm_via_blitq *blitq = dev_priv->blit_queues + engine;
wait_queue_head_t *queue;
int ret = 0;
if (via_dmablit_active(blitq, engine, handle, &queue)) {
DRM_WAIT_ON(ret, *queue, 3 * DRM_HZ,
- !via_dmablit_active(blitq, engine, handle, NULL));
+ !via_dmablit_active(blitq, engine, handle, NULL));
}
- DRM_DEBUG("DMA blit sync handle 0x%x engine %d returned %d\n",
- handle, engine, ret);
+ DRM_DEBUG("DMA blit sync handle 0x%x engine %d returned %d\n", \
+ handle, engine, ret);
return ret;
}
/*
- * A timer that regularly polls the blit engine in cases where we don't have interrupts:
- * a) Broken hardware (typically those that don't have any video capture facility).
- * b) Blit abort. The hardware doesn't send an interrupt when a blit is aborted.
- * The timer and hardware IRQ's can and do work in parallel. If the hardware has
- * irqs, it will shorten the latency somewhat.
+ * A timer that regularly polls the blit engine in cases where
+ * we don't have interrupts:
+ * a) Broken hardware (typically those that don't have any
+ * video capture facility).
+ * b) Blit abort. The hardware doesn't send an interrupt
+ * when a blit is aborted.
+ * The timer and hardware IRQ's can and do work in parallel.
+ * If the hardware has irqs, it will shorten the latency somewhat.
*/
@@ -464,10 +494,10 @@ via_dmablit_sync(struct drm_device *dev,
static void
via_dmablit_timer(unsigned long data)
{
- drm_via_blitq_t *blitq = (drm_via_blitq_t *) data;
+ struct drm_via_blitq *blitq = (struct drm_via_blitq *) data;
struct drm_device *dev = blitq->dev;
int engine = (int)
- (blitq - ((drm_via_private_t *)dev->dev_private)->blit_queues);
+ (blitq - ((struct drm_via_private *)dev->dev_private)->blit_queues);
DRM_DEBUG("Polling timer called for engine %d, jiffies %lu\n", engine,
(unsigned long) jiffies);
@@ -482,7 +512,7 @@ via_dmablit_timer(unsigned long data)
* to shorten abort latency. This is a little nasty.
*/
- via_dmablit_handler(dev, engine, 0);
+ via_dmablit_handler(dev, engine, 0);
}
}
@@ -500,19 +530,21 @@ via_dmablit_timer(unsigned long data)
static void
via_dmablit_workqueue(struct work_struct *work)
{
- drm_via_blitq_t *blitq = container_of(work, drm_via_blitq_t, wq);
+ struct drm_via_blitq *blitq =
+ container_of(work, struct drm_via_blitq, wq);
struct drm_device *dev = blitq->dev;
unsigned long irqsave;
- drm_via_sg_info_t *cur_sg;
+ struct drm_via_sg_info *cur_sg;
int cur_released;
- DRM_DEBUG("Workqueue task called for blit engine %ld\n",(unsigned long)
- (blitq - ((drm_via_private_t *)dev->dev_private)->blit_queues));
+ DRM_DEBUG("Workqueue task called for blit engine %ld\n",
+ (unsigned long)(blitq -
+ ((struct drm_via_private *)dev->dev_private)->blit_queues));
spin_lock_irqsave(&blitq->blit_lock, irqsave);
- while(blitq->serviced != blitq->cur) {
+ while (blitq->serviced != blitq->cur) {
cur_released = blitq->serviced++;
@@ -546,13 +578,14 @@ via_dmablit_workqueue(struct work_struct
void
via_init_dmablit(struct drm_device *dev)
{
- int i,j;
- drm_via_private_t *dev_priv = (drm_via_private_t *)dev->dev_private;
- drm_via_blitq_t *blitq;
+ int i, j;
+ struct drm_via_private *dev_priv =
+ (struct drm_via_private *)dev->dev_private;
+ struct drm_via_blitq *blitq;
pci_set_master(dev->pdev);
- for (i=0; i< VIA_NUM_BLIT_ENGINES; ++i) {
+ for (i = 0; i < VIA_NUM_BLIT_ENGINES; ++i) {
blitq = dev_priv->blit_queues + i;
blitq->dev = dev;
blitq->cur_blit_handle = 0;
@@ -565,9 +598,9 @@ via_init_dmablit(struct drm_device *dev)
blitq->is_active = 0;
blitq->aborting = 0;
spin_lock_init(&blitq->blit_lock);
- for (j=0; j<VIA_NUM_BLIT_SLOTS; ++j) {
+ for (j = 0; j < VIA_NUM_BLIT_SLOTS; ++j)
DRM_INIT_WAITQUEUE(blitq->blit_queue + j);
- }
+
DRM_INIT_WAITQUEUE(&blitq->busy_queue);
INIT_WORK(&blitq->wq, via_dmablit_workqueue);
setup_timer(&blitq->poll_timer, via_dmablit_timer,
@@ -581,7 +614,8 @@ via_init_dmablit(struct drm_device *dev)
static int
-via_build_sg_info(struct drm_device *dev, drm_via_sg_info_t *vsg, drm_via_dmablit_t *xfer)
+via_build_sg_info(struct drm_device *dev, struct drm_via_sg_info *vsg,
+ struct drm_via_dmablit *xfer)
{
int draw = xfer->to_fb;
int ret = 0;
@@ -622,7 +656,8 @@ via_build_sg_info(struct drm_device *dev
* DOS security hole.
*/
- if (xfer->num_lines > 2048 || (xfer->num_lines*xfer->mem_stride > (2048*2048*4))) {
+ if (xfer->num_lines > 2048 ||
+ (xfer->num_lines*xfer->mem_stride > (2048*2048*4))) {
DRM_ERROR("Too large PCI DMA bitblt.\n");
return -EINVAL;
}
@@ -639,14 +674,17 @@ via_build_sg_info(struct drm_device *dev
}
/*
- * A hardware bug seems to be worked around if system memory addresses start on
- * 16 byte boundaries. This seems a bit restrictive however. VIA is contacted
- * about this. Meanwhile, impose the following restrictions:
+ * A hardware bug seems to be worked around if system memory
+ * addresses start on 16 byte boundaries. This seems a bit
+ * restrictive however. VIA is contacted about this.
+ * Meanwhile, impose the following restrictions:
*/
#ifdef VIA_BUGFREE
- 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)))) {
+ 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 -EINVAL;
}
@@ -654,20 +692,21 @@ via_build_sg_info(struct drm_device *dev
if ((((unsigned long)xfer->mem_addr & 15) ||
((unsigned long)xfer->fb_addr & 3)) ||
((xfer->num_lines > 1) &&
- ((xfer->mem_stride & 15) || (xfer->fb_stride & 3)))) {
+ ((xfer->mem_stride & 15) || (xfer->fb_stride & 3)))) {
DRM_ERROR("Invalid DRM bitblt alignment.\n");
return -EINVAL;
}
#endif
-
- if (0 != (ret = via_lock_all_dma_pages(vsg, xfer))) {
+ ret = via_lock_all_dma_pages(vsg, xfer);
+ if (0 != ret) {
DRM_ERROR("Could not lock DMA pages.\n");
via_free_sg_info(dev->pdev, vsg);
return ret;
}
via_map_blit_for_device(dev->pdev, xfer, vsg, 0);
- if (0 != (ret = via_alloc_desc_pages(vsg))) {
+ ret = via_alloc_desc_pages(vsg);
+ if (0 != ret) {
DRM_ERROR("Could not allocate DMA descriptor pages.\n");
via_free_sg_info(dev->pdev, vsg);
return ret;
@@ -684,20 +723,21 @@ via_build_sg_info(struct drm_device *dev
*/
static int
-via_dmablit_grab_slot(drm_via_blitq_t *blitq, int engine)
+via_dmablit_grab_slot(struct drm_via_blitq *blitq, int engine)
{
- int ret=0;
+ int ret = 0;
unsigned long irqsave;
DRM_DEBUG("Num free is %d\n", blitq->num_free);
spin_lock_irqsave(&blitq->blit_lock, irqsave);
+ while (blitq->num_free == 0) {
while(blitq->num_free == 0) {
spin_unlock_irqrestore(&blitq->blit_lock, irqsave);
- DRM_WAIT_ON(ret, blitq->busy_queue, DRM_HZ, blitq->num_free > 0);
- if (ret) {
+ DRM_WAIT_ON(ret, blitq->busy_queue, DRM_HZ,
+ blitq->num_free > 0);
+ if (ret)
return (-EINTR == ret) ? -EAGAIN : ret;
- }
spin_lock_irqsave(&blitq->blit_lock, irqsave);
}
@@ -713,14 +753,14 @@ via_dmablit_grab_slot(drm_via_blitq_t *b
*/
static void
-via_dmablit_release_slot(drm_via_blitq_t *blitq)
+via_dmablit_release_slot(struct drm_via_blitq *blitq)
{
unsigned long irqsave;
spin_lock_irqsave(&blitq->blit_lock, irqsave);
blitq->num_free++;
spin_unlock_irqrestore(&blitq->blit_lock, irqsave);
- DRM_WAKEUP( &blitq->busy_queue );
+ DRM_WAKEUP(&blitq->busy_queue);
}
/*
@@ -729,11 +769,12 @@ via_dmablit_release_slot(drm_via_blitq_t
static int
-via_dmablit(struct drm_device *dev, drm_via_dmablit_t *xfer)
+via_dmablit(struct drm_device *dev, struct drm_via_dmablit *xfer)
{
- drm_via_private_t *dev_priv = (drm_via_private_t *)dev->dev_private;
- drm_via_sg_info_t *vsg;
- drm_via_blitq_t *blitq;
+ struct drm_via_private *dev_priv =
+ (struct drm_via_private *)dev->dev_private;
+ struct drm_via_sg_info *vsg;
+ struct drm_via_blitq *blitq;
int ret;
int engine;
unsigned long irqsave;
@@ -745,14 +786,16 @@ via_dmablit(struct drm_device *dev, drm_
engine = (xfer->to_fb) ? 0 : 1;
blitq = dev_priv->blit_queues + engine;
- if (0 != (ret = via_dmablit_grab_slot(blitq, engine))) {
+ ret = via_dmablit_grab_slot(blitq, engine);
+ if (0 != ret)
return ret;
- }
- if (NULL == (vsg = kmalloc(sizeof(*vsg), GFP_KERNEL))) {
+ vsg = kmalloc(sizeof(*vsg), GFP_KERNEL);
+ if (NULL == vsg) {
via_dmablit_release_slot(blitq);
return -ENOMEM;
}
- if (0 != (ret = via_build_sg_info(dev, vsg, xfer))) {
+ ret = via_build_sg_info(dev, vsg, xfer);
+ if (0 != ret) {
via_dmablit_release_slot(blitq);
kfree(vsg);
return ret;
@@ -774,16 +817,19 @@ via_dmablit(struct drm_device *dev, drm_
}
/*
- * Sync on a previously submitted blit. Note that the X server use signals extensively, and
- * that there is a very big probability that this IOCTL will be interrupted by a signal. In that
- * case it returns with -EAGAIN for the signal to be delivered.
- * The caller should then reissue the IOCTL. This is similar to what is being done for drmGetLock().
+ * Sync on a previously submitted blit. Note that the X
+ * server use signals extensively, and that there is a very
+ * big probability that this IOCTL will be interrupted by a signal.
+ * In that case it returns with -EAGAIN for the signal to be delivered.
+ * The caller should then reissue the IOCTL. This is similar to
+ * what is being done for drmGetLock().
*/
int
-via_dma_blit_sync( struct drm_device *dev, void *data, struct drm_file *file_priv )
+via_dma_blit_sync(struct drm_device *dev, void *data,
+ struct drm_file *file_priv)
{
- drm_via_blitsync_t *sync = data;
+ struct drm_via_blitsync *sync = data;
int err;
if (sync->engine >= VIA_NUM_BLIT_ENGINES)
@@ -799,15 +845,16 @@ via_dma_blit_sync( struct drm_device *de
/*
- * Queue a blit and hand back a handle to be used for sync. This IOCTL may be interrupted by a signal
- * while waiting for a free slot in the blit queue. In that case it returns with -EAGAIN and should
- * be reissued. See the above IOCTL code.
+ * Queue a blit and hand back a handle to be used for sync.
+ * This IOCTL may be interrupted by a signal while waiting for
+ * a free slot in the blit queue. In that case it returns with
+ * -EAGAIN and should be reissued. See the above IOCTL code.
*/
int
-via_dma_blit( struct drm_device *dev, void *data, struct drm_file *file_priv )
+via_dma_blit(struct drm_device *dev, void *data, struct drm_file *file_priv)
{
- drm_via_dmablit_t *xfer = data;
+ struct drm_via_dmablit *xfer = data;
int err;
err = via_dmablit(dev, xfer);
--- a/drivers/char/drm/via_dmablit.h
+++ b/drivers/char/drm/via_dmablit.h
@@ -35,30 +35,30 @@
#define VIA_NUM_BLIT_ENGINES 2
#define VIA_NUM_BLIT_SLOTS 8
-struct _drm_via_descriptor;
+struct drm_via_descriptor;
-typedef struct _drm_via_sg_info {
+struct drm_via_sg_info {
struct page **pages;
unsigned long num_pages;
- struct _drm_via_descriptor **desc_pages;
+ struct drm_via_descriptor **desc_pages;
int num_desc_pages;
int num_desc;
enum dma_data_direction direction;
unsigned char *bounce_buffer;
- dma_addr_t chain_start;
+ dma_addr_t chain_start;
uint32_t free_on_sequence;
- unsigned int descriptors_per_page;
+ unsigned int descriptors_per_page;
int aborted;
enum {
- dr_via_device_mapped,
+ dr_via_device_mapped,
dr_via_desc_pages_alloc,
dr_via_pages_locked,
dr_via_pages_alloc,
dr_via_sg_init
} state;
-} drm_via_sg_info_t;
+};
-typedef struct _drm_via_blitq {
+struct drm_via_blitq {
struct drm_device *dev;
uint32_t cur_blit_handle;
uint32_t done_blit_handle;
@@ -68,15 +68,15 @@ typedef struct _drm_via_blitq {
unsigned num_free;
unsigned num_outstanding;
unsigned long end;
- int aborting;
+ int aborting;
int is_active;
- drm_via_sg_info_t *blits[VIA_NUM_BLIT_SLOTS];
+ struct drm_via_sg_info *blits[VIA_NUM_BLIT_SLOTS];
spinlock_t blit_lock;
wait_queue_head_t blit_queue[VIA_NUM_BLIT_SLOTS];
wait_queue_head_t busy_queue;
struct work_struct wq;
struct timer_list poll_timer;
-} drm_via_blitq_t;
+};
/*
--- a/drivers/char/drm/via_dma.c
+++ b/drivers/char/drm/via_dma.c
@@ -58,28 +58,31 @@
*((uint32_t *)(vb)) = ((nReg) >> 2) | HALCYON_HEADER1; \
*((uint32_t *)(vb) + 1) = (nData); \
vb = ((uint32_t *)vb) + 2; \
- dev_priv->dma_low +=8; \
+ dev_priv->dma_low += 8; \
}
#define via_flush_write_combine() DRM_MEMORYBARRIER()
#define VIA_OUT_RING_QW(w1,w2) \
+ do { \
*vb++ = (w1); \
*vb++ = (w2); \
- dev_priv->dma_low += 8;
+ dev_priv->dma_low += 8; \
+ } while (0);
+
+static void via_cmdbuf_start(struct drm_via_private *dev_priv);
+static void via_cmdbuf_pause(struct drm_via_private *dev_priv);
+static void via_cmdbuf_reset(struct drm_via_private *dev_priv);
+static void via_cmdbuf_rewind(struct drm_via_private *dev_priv);
+static int via_wait_idle(struct drm_via_private *dev_priv);
+static void via_pad_cache(struct drm_via_private *dev_priv, int qwords);
-static void via_cmdbuf_start(drm_via_private_t * dev_priv);
-static void via_cmdbuf_pause(drm_via_private_t * dev_priv);
-static void via_cmdbuf_reset(drm_via_private_t * dev_priv);
-static void via_cmdbuf_rewind(drm_via_private_t * dev_priv);
-static int via_wait_idle(drm_via_private_t * dev_priv);
-static void via_pad_cache(drm_via_private_t * dev_priv, int qwords);
/*
* Free space in command buffer.
*/
-static uint32_t via_cmdbuf_space(drm_via_private_t * dev_priv)
+static uint32_t via_cmdbuf_space(struct drm_via_private *dev_priv)
{
uint32_t agp_base = dev_priv->dma_offset + (uint32_t) dev_priv->agpAddr;
uint32_t hw_addr = *(dev_priv->hw_addr_ptr) - agp_base;
@@ -93,7 +96,7 @@ static uint32_t via_cmdbuf_space(drm_via
* How much does the command regulator lag behind?
*/
-static uint32_t via_cmdbuf_lag(drm_via_private_t * dev_priv)
+static uint32_t via_cmdbuf_lag(struct drm_via_private *dev_priv)
{
uint32_t agp_base = dev_priv->dma_offset + (uint32_t) dev_priv->agpAddr;
uint32_t hw_addr = *(dev_priv->hw_addr_ptr) - agp_base;
@@ -108,7 +111,7 @@ static uint32_t via_cmdbuf_lag(drm_via_p
*/
static inline int
-via_cmdbuf_wait(drm_via_private_t * dev_priv, unsigned int size)
+via_cmdbuf_wait(struct drm_via_private *dev_priv, unsigned int size)
{
uint32_t agp_base = dev_priv->dma_offset + (uint32_t) dev_priv->agpAddr;
uint32_t cur_addr, hw_addr, next_addr;
@@ -122,7 +125,7 @@ via_cmdbuf_wait(drm_via_private_t * dev_
hw_addr = *hw_addr_ptr - agp_base;
if (count-- == 0) {
DRM_ERROR
- ("via_cmdbuf_wait timed out hw %x cur_addr %x next_addr %x\n",
+ ("via_cmdbuf_wait timed out hw %x cur_addr %x next_addr %x\n",
hw_addr, cur_addr, next_addr);
return -1;
}
@@ -139,25 +142,25 @@ via_cmdbuf_wait(drm_via_private_t * dev_
* Returns virtual pointer to ring buffer.
*/
-static inline uint32_t *via_check_dma(drm_via_private_t * dev_priv,
+static inline uint32_t *via_check_dma(struct drm_via_private *dev_priv,
unsigned int size)
{
if ((dev_priv->dma_low + size + 4 * CMDBUF_ALIGNMENT_SIZE) >
- dev_priv->dma_high) {
+ dev_priv->dma_high)
via_cmdbuf_rewind(dev_priv);
- }
- if (via_cmdbuf_wait(dev_priv, size) != 0) {
+
+ if (via_cmdbuf_wait(dev_priv, size) != 0)
return NULL;
- }
+
return (uint32_t *) (dev_priv->dma_ptr + dev_priv->dma_low);
}
-int via_dma_cleanup(struct drm_device * dev)
+int via_dma_cleanup(struct drm_device *dev)
{
if (dev->dev_private) {
- drm_via_private_t *dev_priv =
- (drm_via_private_t *) dev->dev_private;
+ struct drm_via_private *dev_priv =
+ (struct drm_via_private *) dev->dev_private;
if (dev_priv->ring.virtual_start) {
via_cmdbuf_reset(dev_priv);
@@ -171,9 +174,9 @@ int via_dma_cleanup(struct drm_device *
return 0;
}
-static int via_initialize(struct drm_device * dev,
- drm_via_private_t * dev_priv,
- drm_via_dma_init_t * init)
+static int via_initialize(struct drm_device *dev,
+ struct drm_via_private *dev_priv,
+ struct drm_via_dma_init *init)
{
if (!dev_priv || !dev_priv->mmio) {
DRM_ERROR("via_dma_init called before via_map_init\n");
@@ -227,10 +230,12 @@ static int via_initialize(struct drm_dev
return 0;
}
-static int via_dma_init(struct drm_device *dev, void *data, struct drm_file *file_priv)
+static int via_dma_init(struct drm_device *dev, void *data,
+ struct drm_file *file_priv)
{
- drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
- drm_via_dma_init_t *init = data;
+ struct drm_via_private *dev_priv =
+ (struct drm_via_private *) dev->dev_private;
+ struct drm_via_dma_init *init = data;
int retcode = 0;
switch (init->func) {
@@ -258,44 +263,26 @@ static int via_dma_init(struct drm_devic
return retcode;
}
-static int via_dispatch_cmdbuffer(struct drm_device * dev, drm_via_cmdbuffer_t * cmd)
+static int via_dispatch_cmdbuffer(struct drm_device *dev,
+ struct drm_via_cmdbuffer *cmd)
{
- drm_via_private_t *dev_priv;
+ struct drm_via_private *dev_priv;
uint32_t *vb;
- int ret;
- dev_priv = (drm_via_private_t *) dev->dev_private;
+ dev_priv = (struct drm_via_private *) dev->dev_private;
if (dev_priv->ring.virtual_start == NULL) {
DRM_ERROR("called without initializing AGP ring buffer.\n");
return -EFAULT;
}
- if (cmd->size > VIA_PCI_BUF_SIZE) {
- return -ENOMEM;
- }
-
- if (DRM_COPY_FROM_USER(dev_priv->pci_buf, cmd->buf, cmd->size))
- return -EFAULT;
-
- /*
- * Running this function on AGP memory is dead slow. Therefore
- * we run it on a temporary cacheable system memory buffer and
- * copy it to AGP memory when ready.
- */
-
- if ((ret =
- via_verify_command_stream((uint32_t *) dev_priv->pci_buf,
- cmd->size, dev, 1))) {
- return ret;
- }
-
vb = via_check_dma(dev_priv, (cmd->size < 0x100) ? 0x102 : cmd->size);
- if (vb == NULL) {
+ if (vb == NULL)
return -EAGAIN;
- }
- memcpy(vb, dev_priv->pci_buf, cmd->size);
+
+ if (DRM_COPY_FROM_USER(vb, cmd->buf, cmd->size))
+ return -EFAULT;
dev_priv->dma_low += cmd->size;
@@ -311,17 +298,18 @@ static int via_dispatch_cmdbuffer(struct
return 0;
}
-int via_driver_dma_quiescent(struct drm_device * dev)
+int via_driver_dma_quiescent(struct drm_device *dev)
{
- drm_via_private_t *dev_priv = dev->dev_private;
+ struct drm_via_private *dev_priv = dev->dev_private;
- if (!via_wait_idle(dev_priv)) {
+ if (!via_wait_idle(dev_priv))
return -EBUSY;
- }
+
return 0;
}
-static int via_flush_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv)
+static int via_flush_ioctl(struct drm_device *dev, void *data,
+ struct drm_file *file_priv)
{
LOCK_TEST_WITH_RETURN(dev, file_priv);
@@ -329,9 +317,10 @@ static int via_flush_ioctl(struct drm_de
return via_driver_dma_quiescent(dev);
}
-static int via_cmdbuffer(struct drm_device *dev, void *data, struct drm_file *file_priv)
+static int via_cmdbuffer(struct drm_device *dev, void *data,
+ struct drm_file *file_priv)
{
- drm_via_cmdbuffer_t *cmdbuf = data;
+ struct drm_via_cmdbuffer *cmdbuf = data;
int ret;
LOCK_TEST_WITH_RETURN(dev, file_priv);
@@ -339,30 +328,31 @@ static int via_cmdbuffer(struct drm_devi
DRM_DEBUG("buf %p size %lu\n", cmdbuf->buf, cmdbuf->size);
ret = via_dispatch_cmdbuffer(dev, cmdbuf);
- if (ret) {
+ if (ret)
return ret;
- }
+
return 0;
}
-static int via_dispatch_pci_cmdbuffer(struct drm_device * dev,
- drm_via_cmdbuffer_t * cmd)
+static int via_dispatch_pci_cmdbuffer(struct drm_device *dev,
+ struct drm_via_cmdbuffer *cmd)
{
- drm_via_private_t *dev_priv = dev->dev_private;
+ struct drm_via_private *dev_priv = dev->dev_private;
int ret;
- if (cmd->size > VIA_PCI_BUF_SIZE) {
+ if (cmd->size > VIA_PCI_BUF_SIZE)
return -ENOMEM;
- }
+
if (DRM_COPY_FROM_USER(dev_priv->pci_buf, cmd->buf, cmd->size))
return -EFAULT;
-
- if ((ret =
+ ret =
via_verify_command_stream((uint32_t *) dev_priv->pci_buf,
- cmd->size, dev, 0))) {
+ cmd->size, dev, 0);
+
+ if (ret)
return ret;
- }
+
ret =
via_parse_command_stream(dev, (const uint32_t *)dev_priv->pci_buf,
@@ -370,9 +360,10 @@ static int via_dispatch_pci_cmdbuffer(st
return ret;
}
-static int via_pci_cmdbuffer(struct drm_device *dev, void *data, struct drm_file *file_priv)
+static int via_pci_cmdbuffer(struct drm_device *dev, void *data,
+ struct drm_file *file_priv)
{
- drm_via_cmdbuffer_t *cmdbuf = data;
+ struct drm_via_cmdbuffer *cmdbuf = data;
int ret;
LOCK_TEST_WITH_RETURN(dev, file_priv);
@@ -380,19 +371,19 @@ static int via_pci_cmdbuffer(struct drm_
DRM_DEBUG("buf %p size %lu\n", cmdbuf->buf, cmdbuf->size);
ret = via_dispatch_pci_cmdbuffer(dev, cmdbuf);
- if (ret) {
+ if (ret)
return ret;
- }
+
return 0;
}
-static inline uint32_t *via_align_buffer(drm_via_private_t * dev_priv,
- uint32_t * vb, int qw_count)
+static inline uint32_t *via_align_buffer(struct drm_via_private *dev_priv,
+ uint32_t *vb, int qw_count)
{
- for (; qw_count > 0; --qw_count) {
+ for (; qw_count > 0; --qw_count)
VIA_OUT_RING_QW(HC_DUMMY, HC_DUMMY);
- }
+
return vb;
}
@@ -401,7 +392,7 @@ static inline uint32_t *via_align_buffer
*
* Returns virtual pointer to ring buffer.
*/
-static inline uint32_t *via_get_dma(drm_via_private_t * dev_priv)
+static inline uint32_t *via_get_dma(struct drm_via_private *dev_priv)
{
return (uint32_t *) (dev_priv->dma_ptr + dev_priv->dma_low);
}
@@ -411,18 +402,18 @@ static inline uint32_t *via_get_dma(drm_
* modifying the pause address stored in the buffer itself. If
* the regulator has already paused, restart it.
*/
-static int via_hook_segment(drm_via_private_t * dev_priv,
+static int via_hook_segment(struct drm_via_private *dev_priv,
uint32_t pause_addr_hi, uint32_t pause_addr_lo,
int no_pci_fire)
{
int paused, count;
volatile uint32_t *paused_at = dev_priv->last_pause_ptr;
- uint32_t reader,ptr;
+ uint32_t reader, ptr;
uint32_t diff;
paused = 0;
via_flush_write_combine();
- (void) *(volatile uint32_t *)(via_get_dma(dev_priv) -1);
+ (void) *(volatile uint32_t *)(via_get_dma(dev_priv) - 1);
*paused_at = pause_addr_lo;
via_flush_write_combine();
@@ -443,7 +434,7 @@ static int via_hook_segment(drm_via_priv
diff = (uint32_t) (ptr - reader) - dev_priv->dma_diff;
count = 10000000;
- while(diff == 0 && count--) {
+ while (diff == 0 && count--) {
paused = (VIA_READ(0x41c) & 0x80000000);
if (paused)
break;
@@ -463,9 +454,9 @@ static int via_hook_segment(drm_via_priv
ptr, reader, dev_priv->dma_diff);
} else if (diff == 0) {
/*
- * There is a concern that these writes may stall the PCI bus
- * if the GPU is not idle. However, idling the GPU first
- * doesn't make a difference.
+ * There is a concern that these writes may stall
+ * the PCI bus if the GPU is not idle. However,
+ * idling the GPU first doesn't make a difference.
*/
VIA_WRITE(VIA_REG_TRANSET, (HC_ParaType_PreCR << 16));
@@ -477,7 +468,7 @@ static int via_hook_segment(drm_via_priv
return paused;
}
-static int via_wait_idle(drm_via_private_t * dev_priv)
+static int via_wait_idle(struct drm_via_private *dev_priv)
{
int count = 10000000;
@@ -489,9 +480,9 @@ static int via_wait_idle(drm_via_private
return count;
}
-static uint32_t *via_align_cmd(drm_via_private_t * dev_priv, uint32_t cmd_type,
- uint32_t addr, uint32_t * cmd_addr_hi,
- uint32_t * cmd_addr_lo, int skip_wait)
+static uint32_t *via_align_cmd(struct drm_via_private *dev_priv,
+ uint32_t cmd_type, uint32_t addr, uint32_t *cmd_addr_hi,
+ uint32_t *cmd_addr_lo, int skip_wait)
{
uint32_t agp_base;
uint32_t cmd_addr, addr_lo, addr_hi;
@@ -519,7 +510,7 @@ static uint32_t *via_align_cmd(drm_via_p
return vb;
}
-static void via_cmdbuf_start(drm_via_private_t * dev_priv)
+static void via_cmdbuf_start(struct drm_via_private *dev_priv)
{
uint32_t pause_addr_lo, pause_addr_hi;
uint32_t start_addr, start_addr_lo;
@@ -578,7 +569,7 @@ static void via_cmdbuf_start(drm_via_pri
dev_priv->dma_diff = ptr - reader;
}
-static void via_pad_cache(drm_via_private_t * dev_priv, int qwords)
+static void via_pad_cache(struct drm_via_private *dev_priv, int qwords)
{
uint32_t *vb;
@@ -588,7 +579,7 @@ static void via_pad_cache(drm_via_privat
via_align_buffer(dev_priv, vb, qwords);
}
-static inline void via_dummy_bitblt(drm_via_private_t * dev_priv)
+static inline void via_dummy_bitblt(struct drm_via_private *dev_priv)
{
uint32_t *vb = via_get_dma(dev_priv);
SetReg2DAGP(0x0C, (0 | (0 << 16)));
@@ -596,7 +587,7 @@ static inline void via_dummy_bitblt(drm_
SetReg2DAGP(0x0, 0x1 | 0x2000 | 0xAA000000);
}
-static void via_cmdbuf_jump(drm_via_private_t * dev_priv)
+static void via_cmdbuf_jump(struct drm_via_private *dev_priv)
{
uint32_t agp_base;
uint32_t pause_addr_lo, pause_addr_hi;
@@ -615,9 +606,9 @@ static void via_cmdbuf_jump(drm_via_priv
*/
dev_priv->dma_low = 0;
- if (via_cmdbuf_wait(dev_priv, CMDBUF_ALIGNMENT_SIZE) != 0) {
+ if (via_cmdbuf_wait(dev_priv, CMDBUF_ALIGNMENT_SIZE) != 0)
DRM_ERROR("via_cmdbuf_jump failed\n");
- }
+
via_dummy_bitblt(dev_priv);
via_dummy_bitblt(dev_priv);
@@ -655,12 +646,13 @@ static void via_cmdbuf_jump(drm_via_priv
}
-static void via_cmdbuf_rewind(drm_via_private_t * dev_priv)
+static void via_cmdbuf_rewind(struct drm_via_private *dev_priv)
{
via_cmdbuf_jump(dev_priv);
}
-static void via_cmdbuf_flush(drm_via_private_t * dev_priv, uint32_t cmd_type)
+static void via_cmdbuf_flush(struct drm_via_private *dev_priv,
+ uint32_t cmd_type)
{
uint32_t pause_addr_lo, pause_addr_hi;
@@ -668,12 +660,12 @@ static void via_cmdbuf_flush(drm_via_pri
via_hook_segment(dev_priv, pause_addr_hi, pause_addr_lo, 0);
}
-static void via_cmdbuf_pause(drm_via_private_t * dev_priv)
+static void via_cmdbuf_pause(struct drm_via_private *dev_priv)
{
via_cmdbuf_flush(dev_priv, HC_HAGPBpID_PAUSE);
}
-static void via_cmdbuf_reset(drm_via_private_t * dev_priv)
+static void via_cmdbuf_reset(struct drm_via_private *dev_priv)
{
via_cmdbuf_flush(dev_priv, HC_HAGPBpID_STOP);
via_wait_idle(dev_priv);
@@ -683,17 +675,18 @@ static void via_cmdbuf_reset(drm_via_pri
* User interface to the space and lag functions.
*/
-static int via_cmdbuf_size(struct drm_device *dev, void *data, struct drm_file *file_priv)
+static int via_cmdbuf_size(struct drm_device *dev, void *data,
+ struct drm_file *file_priv)
{
- drm_via_cmdbuf_size_t *d_siz = data;
+ struct drm_via_cmdbuf_size *d_siz = data;
int ret = 0;
uint32_t tmp_size, count;
- drm_via_private_t *dev_priv;
+ struct drm_via_private *dev_priv;
- DRM_DEBUG("\n");
+ DRM_DEBUG("via cmdbuf_size\n");
LOCK_TEST_WITH_RETURN(dev, file_priv);
- dev_priv = (drm_via_private_t *) dev->dev_private;
+ dev_priv = (struct drm_via_private *) dev->dev_private;
if (dev_priv->ring.virtual_start == NULL) {
DRM_ERROR("called without initializing AGP ring buffer.\n");
@@ -706,9 +699,9 @@ static int via_cmdbuf_size(struct drm_de
case VIA_CMDBUF_SPACE:
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");
@@ -718,9 +711,9 @@ static int via_cmdbuf_size(struct drm_de
case VIA_CMDBUF_LAG:
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");
@@ -735,6 +728,144 @@ static int via_cmdbuf_size(struct drm_de
return ret;
}
+/*The following functions are for ACPI*/
+
+static void initialize3Dengine(struct drm_via_private *dev_priv)
+{
+ int i = 0;
+
+ VIA_WRITE(0x43C, 0x00010000);
+
+ for (i = 0; i <= 0x7D; i++)
+ VIA_WRITE(0x440, (unsigned long) i << 24);
+
+
+ VIA_WRITE(0x43C, 0x00020000);
+
+ for (i = 0; i <= 0x94; i++)
+ VIA_WRITE(0x440, (unsigned long) i << 24);
+
+
+ VIA_WRITE(0x440, 0x82400000);
+ VIA_WRITE(0x43C, 0x01020000);
+
+
+ for (i = 0; i <= 0x94; i++)
+ VIA_WRITE(0x440, (unsigned long) i << 24);
+
+
+ VIA_WRITE(0x440, 0x82400000);
+ VIA_WRITE(0x43C, 0xfe020000);
+
+ for (i = 0; i <= 0x03; i++)
+ VIA_WRITE(0x440, (unsigned long) i << 24);
+
+
+ VIA_WRITE(0x43C, 0x00030000);
+
+ for (i = 0; i <= 0xff; i++)
+ VIA_WRITE(0x440, 0);
+
+ VIA_WRITE(0x43C, 0x00100000);
+ VIA_WRITE(0x440, 0x00333004);
+ VIA_WRITE(0x440, 0x10000002);
+ VIA_WRITE(0x440, 0x60000000);
+ VIA_WRITE(0x440, 0x61000000);
+ VIA_WRITE(0x440, 0x62000000);
+ VIA_WRITE(0x440, 0x63000000);
+ VIA_WRITE(0x440, 0x64000000);
+
+ VIA_WRITE(0x43C, 0x00fe0000);
+ VIA_WRITE(0x440, 0x40008c0f);
+ VIA_WRITE(0x440, 0x44000000);
+ VIA_WRITE(0x440, 0x45080C04);
+ VIA_WRITE(0x440, 0x46800408);
+ VIA_WRITE(0x440, 0x50000000);
+ VIA_WRITE(0x440, 0x51000000);
+ VIA_WRITE(0x440, 0x52000000);
+ VIA_WRITE(0x440, 0x53000000);
+
+
+ VIA_WRITE(0x43C, 0x00fe0000);
+ VIA_WRITE(0x440, 0x08000001);
+ VIA_WRITE(0x440, 0x0A000183);
+ VIA_WRITE(0x440, 0x0B00019F);
+ VIA_WRITE(0x440, 0x0C00018B);
+ VIA_WRITE(0x440, 0x0D00019B);
+ VIA_WRITE(0x440, 0x0E000000);
+ VIA_WRITE(0x440, 0x0F000000);
+ VIA_WRITE(0x440, 0x10000000);
+ VIA_WRITE(0x440, 0x11000000);
+ VIA_WRITE(0x440, 0x20000000);
+}
+
+
+/* For acpi case, when system resume from suspend or hibernate,
+ * need to re-initialize dma info into HW
+ */
+int via_drm_resume(struct pci_dev *pci)
+{
+ struct drm_device *dev = (struct drm_device *)pci_get_drvdata(pci);
+ struct drm_via_private *dev_priv =
+ (struct drm_via_private *) dev->dev_private;
+ struct drm_via_video_save_head *pnode = 0;
+
+ /* when resume, initialize 3d registers */
+ initialize3Dengine(dev_priv);
+
+ /* here we need to restore some video memory content */
+ for (pnode = via_video_save_head; pnode; pnode = pnode->next)
+ memcpy(pnode->pvideomem, pnode->psystemmem, pnode->size);
+
+
+ /* if pci path, return */
+ if (!dev_priv->ring.virtual_start)
+ return 0;
+
+ dev_priv->dma_ptr = dev_priv->ring.virtual_start;
+ dev_priv->dma_low = 0;
+ dev_priv->dma_high = 0x1000000;
+ dev_priv->dma_wrap = 0x1000000;
+ dev_priv->dma_offset = 0x0;
+ dev_priv->last_pause_ptr = NULL;
+ dev_priv->hw_addr_ptr = dev_priv->mmio->handle + 0x418;
+
+ via_cmdbuf_start(dev_priv);
+
+ return 0;
+}
+
+int via_drm_suspend(struct pci_dev *pci, pm_message_t state)
+{
+ struct drm_device *dev = (struct drm_device *)pci_get_drvdata(pci);
+ struct drm_via_private *dev_priv =
+ (struct drm_via_private *) dev->dev_private;
+
+ struct drm_via_video_save_head *pnode = 0;
+
+ /*here we need to save some video mem information into system memory,
+ to keep the system consistent between suspend *before* and *after*
+ 1.save only necessary */
+ for (pnode = via_video_save_head; pnode; pnode =
+ (struct drm_via_video_save_head *)pnode->next)
+ memcpy(pnode->psystemmem, pnode->pvideomem, pnode->size);
+
+
+ /* Only agp path need to flush the cmd */
+ if (dev_priv->ring.virtual_start)
+ via_cmdbuf_reset(dev_priv);
+
+
+ return 0;
+}
+
+int via_drm_authmagic(struct drm_device *dev, void *data,
+ struct drm_file *file_priv)
+{
+ return 0;
+}
+
+
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),
@@ -742,6 +873,7 @@ struct drm_ioctl_desc via_ioctls[] = {
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_GET_INFO, via_get_drm_info, 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),
@@ -749,7 +881,8 @@ struct drm_ioctl_desc via_ioctls[] = {
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)
+ DRM_IOCTL_DEF(DRM_VIA_BLIT_SYNC, via_dma_blit_sync, DRM_AUTH),
+ DRM_IOCTL_DEF(DRM_VIA_AUTH_MAGIC, via_drm_authmagic, 0)
};
int via_max_ioctl = DRM_ARRAY_SIZE(via_ioctls);
--- a/drivers/char/drm/via_drm.h
+++ b/drivers/char/drm/via_drm.h
@@ -40,7 +40,8 @@
#define VIA_NR_XVMC_LOCKS 5
#define VIA_MAX_CACHELINE_SIZE 64
#define XVMCLOCKPTR(saPriv,lockNo) \
- ((volatile struct drm_hw_lock *)(((((unsigned long) (saPriv)->XvMCLockArea) + \
+ ((volatile struct drm_hw_lock *)(((((unsigned long) \
+ (saPriv)->XvMCLockArea) + \
(VIA_MAX_CACHELINE_SIZE - 1)) & \
~(VIA_MAX_CACHELINE_SIZE - 1)) + \
VIA_MAX_CACHELINE_SIZE*(lockNo)))
@@ -51,6 +52,13 @@
#define VIA_LOG_MIN_TEX_REGION_SIZE 16
#endif
+struct drm_via_info{
+ unsigned long AgpHandle;
+ unsigned long AgpSize;
+ unsigned long RegHandle;
+ unsigned long RegSize;
+};
+
#define VIA_UPLOAD_TEX0IMAGE 0x1 /* handled clientside */
#define VIA_UPLOAD_TEX1IMAGE 0x2 /* handled clientside */
#define VIA_UPLOAD_CTX 0x4
@@ -67,7 +75,7 @@
#define DRM_VIA_FB_INIT 0x03
#define DRM_VIA_MAP_INIT 0x04
#define DRM_VIA_DEC_FUTEX 0x05
-#define NOT_USED
+#define DRM_VIA_GET_INFO 0x06
#define DRM_VIA_DMA_INIT 0x07
#define DRM_VIA_CMDBUFFER 0x08
#define DRM_VIA_FLUSH 0x09
@@ -77,22 +85,39 @@
#define DRM_VIA_WAIT_IRQ 0x0d
#define DRM_VIA_DMA_BLIT 0x0e
#define DRM_VIA_BLIT_SYNC 0x0f
+#define DRM_VIA_AUTH_MAGIC 0x11
-#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)
+#define DRM_IOCTL_VIA_ALLOCMEM DRM_IOWR(DRM_COMMAND_BASE + \
+ DRM_VIA_ALLOCMEM, struct drm_via_mem)
+#define DRM_IOCTL_VIA_FREEMEM DRM_IOW(DRM_COMMAND_BASE + \
+ DRM_VIA_FREEMEM, struct drm_via_mem)
+#define DRM_IOCTL_VIA_AGP_INIT DRM_IOWR(DRM_COMMAND_BASE + \
+ DRM_VIA_AGP_INIT, struct drm_via_agp)
+#define DRM_IOCTL_VIA_FB_INIT DRM_IOWR(DRM_COMMAND_BASE + \
+ DRM_VIA_FB_INIT, struct drm_via_fb)
+#define DRM_IOCTL_VIA_MAP_INIT DRM_IOWR(DRM_COMMAND_BASE + \
+ DRM_VIA_MAP_INIT, struct drm_via_init)
+#define DRM_IOCTL_VIA_DEC_FUTEX DRM_IOW(DRM_COMMAND_BASE + \
+ DRM_VIA_DEC_FUTEX, struct drm_via_futex)
+#define DRM_IOCTL_VIA_GET_INFO DRM_IOW(DRM_COMMAND_BASE + \
+ DRM_VIA_GET_INFO, struct drm_via_info)
+#define DRM_IOCTL_VIA_DMA_INIT DRM_IOWR(DRM_COMMAND_BASE + \
+ DRM_VIA_DMA_INIT, struct drm_via_dma_init)
+#define DRM_IOCTL_VIA_CMDBUFFER DRM_IOW(DRM_COMMAND_BASE + \
+ DRM_VIA_CMDBUFFER, struct drm_via_cmdbuffer)
+#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, struct drm_via_cmdbuffer)
+#define DRM_IOCTL_VIA_CMDBUF_SIZE DRM_IOWR(DRM_COMMAND_BASE + \
+ DRM_VIA_CMDBUF_SIZE, struct drm_via_cmdbuf_size)
+#define DRM_IOCTL_VIA_WAIT_IRQ DRM_IOWR(DRM_COMMAND_BASE + \
+ DRM_VIA_WAIT_IRQ, union drm_via_irqwait)
+#define DRM_IOCTL_VIA_DMA_BLIT DRM_IOW(DRM_COMMAND_BASE + \
+ DRM_VIA_DMA_BLIT, struct drm_via_dmablit)
+#define DRM_IOCTL_VIA_BLIT_SYNC DRM_IOW(DRM_COMMAND_BASE + \
+ DRM_VIA_BLIT_SYNC, struct drm_via_blitsync)
+#define DRM_IOCTL_VIA_AUTH_MAGIC DRM_IOW(DRM_COMMAND_BASE + \
+ DRM_VIA_AUTH_MAGIC, struct drm_auth)
/* 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,
@@ -113,25 +138,33 @@
#define VIA_MEM_MIXED 3
#define VIA_MEM_UNKNOWN 4
-typedef struct {
+#define VIA_MEM_VIDEO_SAVE 2 /*For video memory need to be saved in ACPI */
+
+enum drm_agp_type {
+ AGP_RING_BUFFER,
+ AGP_DOUBLE_BUFFER,
+ DISABLED
+};
+
+struct drm_via_agp {
uint32_t offset;
uint32_t size;
-} drm_via_agp_t;
+};
-typedef struct {
+struct drm_via_fb {
uint32_t offset;
uint32_t size;
-} drm_via_fb_t;
+};
-typedef struct {
+struct drm_via_mem {
uint32_t context;
uint32_t type;
uint32_t size;
unsigned long index;
unsigned long offset;
-} drm_via_mem_t;
+};
-typedef struct _drm_via_init {
+struct drm_via_init {
enum {
VIA_INIT_MAP = 0x01,
VIA_CLEANUP_MAP = 0x02
@@ -141,9 +174,11 @@ typedef struct _drm_via_init {
unsigned long fb_offset;
unsigned long mmio_offset;
unsigned long agpAddr;
-} drm_via_init_t;
+ unsigned long agp_offset;
+ enum drm_agp_type agp_type;
+};
-typedef struct _drm_via_futex {
+struct drm_via_futex {
enum {
VIA_FUTEX_WAIT = 0x00,
VIA_FUTEX_WAKE = 0X01
@@ -151,9 +186,9 @@ typedef struct _drm_via_futex {
uint32_t ms;
uint32_t lock;
uint32_t val;
-} drm_via_futex_t;
+};
-typedef struct _drm_via_dma_init {
+struct drm_via_dma_init {
enum {
VIA_INIT_DMA = 0x01,
VIA_CLEANUP_DMA = 0x02,
@@ -163,27 +198,27 @@ typedef struct _drm_via_dma_init {
unsigned long offset;
unsigned long size;
unsigned long reg_pause_addr;
-} drm_via_dma_init_t;
+};
-typedef struct _drm_via_cmdbuffer {
+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 {
+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 {
+struct drm_via_sarea {
unsigned int dirty;
unsigned int nbox;
struct drm_clip_rect boxes[VIA_NR_SAREA_CLIPRECTS];
- drm_via_tex_region_t texList[VIA_NR_TEX_REGIONS + 1];
+ struct drm_via_tex_region texList[VIA_NR_TEX_REGIONS + 1];
int texAge; /* last time texture was uploaded */
int ctxOwner; /* last context to upload state */
int vertexPrim;
@@ -203,23 +238,23 @@ typedef struct _drm_via_sarea {
/* Used by the 3d driver only at this point, for pageflipping:
*/
unsigned int pfCurrentOffset;
-} drm_via_sarea_t;
+};
-typedef struct _drm_via_cmdbuf_size {
+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 {
+enum via_irq_seq_type {
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
@@ -235,20 +270,20 @@ enum drm_via_irqs {
struct drm_via_wait_irq_request {
unsigned irq;
- via_irq_seq_type_t type;
+ enum via_irq_seq_type type;
uint32_t sequence;
uint32_t signal;
};
-typedef union drm_via_irqwait {
+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 {
+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
@@ -256,7 +291,7 @@ typedef struct drm_via_blitsync {
* interrupts.
*/
-typedef struct drm_via_dmablit {
+struct drm_via_dmablit {
uint32_t num_lines;
uint32_t line_length;
@@ -269,7 +304,18 @@ typedef struct drm_via_dmablit {
uint32_t flags;
int to_fb;
- drm_via_blitsync_t sync;
-} drm_via_dmablit_t;
+ struct drm_via_blitsync sync;
+};
+
+struct drm_via_video_save_head {
+ void *pvideomem;
+ void *psystemmem;
+ int size;
+ /* token used to identify this video memory */
+ unsigned long token;
+ void *next;
+};
+
+extern struct drm_via_video_save_head *via_video_save_head;
#endif /* _VIA_DRM_H_ */
--- a/drivers/char/drm/via_drv.c
+++ b/drivers/char/drm/via_drv.c
@@ -37,10 +37,17 @@ static struct pci_device_id pciidlist[]
viadrv_PCI_IDS
};
+int via_driver_open(struct drm_device *dev, struct drm_file *priv)
+{
+ priv->authenticated = 1;
+ return 0;
+}
+
static struct drm_driver driver = {
.driver_features =
DRIVER_USE_AGP | DRIVER_USE_MTRR | DRIVER_HAVE_IRQ |
DRIVER_IRQ_SHARED | DRIVER_IRQ_VBL,
+ .open = via_driver_open,
.load = via_driver_load,
.unload = via_driver_unload,
.context_dtor = via_final_context,
@@ -68,8 +75,10 @@ static struct drm_driver driver = {
.fasync = drm_fasync,
},
.pci_driver = {
- .name = DRIVER_NAME,
- .id_table = pciidlist,
+ .name = DRIVER_NAME,
+ .id_table = pciidlist,
+ .suspend = via_drm_suspend,
+ .resume = via_drm_resume,
},
.name = DRIVER_NAME,
--- a/drivers/char/drm/via_drv.h
+++ b/drivers/char/drm/via_drv.h
@@ -43,25 +43,29 @@
#define VIA_FIRE_BUF_SIZE 1024
#define VIA_NUM_IRQS 4
-typedef struct drm_via_ring_buffer {
+struct drm_via_ring_buffer {
drm_local_map_t map;
char *virtual_start;
-} drm_via_ring_buffer_t;
+};
typedef uint32_t maskarray_t[5];
-typedef struct drm_via_irq {
+struct drm_via_irq {
atomic_t irq_received;
uint32_t pending_mask;
uint32_t enable_mask;
wait_queue_head_t irq_queue;
-} drm_via_irq_t;
+};
-typedef struct drm_via_private {
- drm_via_sarea_t *sarea_priv;
+struct drm_via_private {
+ struct drm_via_sarea *sarea_priv;
drm_local_map_t *sarea;
drm_local_map_t *fb;
drm_local_map_t *mmio;
+ /* support managing agp in our own prev data structure */
+ drm_local_map_t *agp;
+ enum drm_agp_type agptype;
+ /* end */
unsigned long agpAddr;
wait_queue_head_t decoder_queue[VIA_NR_XVMC_LOCKS];
char *dma_ptr;
@@ -71,16 +75,16 @@ typedef struct drm_via_private {
uint32_t dma_wrap;
volatile uint32_t *last_pause_ptr;
volatile uint32_t *hw_addr_ptr;
- drm_via_ring_buffer_t ring;
+ struct drm_via_ring_buffer ring;
struct timeval last_vblank;
int last_vblank_valid;
unsigned usec_per_vblank;
- drm_via_state_t hc_state;
+ struct drm_via_state hc_state;
char pci_buf[VIA_PCI_BUF_SIZE];
const uint32_t *fire_offsets[VIA_FIRE_BUF_SIZE];
uint32_t num_fire_offsets;
int chipset;
- drm_via_irq_t via_irqs[VIA_NUM_IRQS];
+ struct drm_via_irq via_irqs[VIA_NUM_IRQS];
unsigned num_irqs;
maskarray_t *irq_masks;
uint32_t irq_enable_mask;
@@ -92,9 +96,9 @@ typedef struct drm_via_private {
int agp_initialized;
unsigned long vram_offset;
unsigned long agp_offset;
- drm_via_blitq_t blit_queues[VIA_NUM_BLIT_ENGINES];
+ struct drm_via_blitq blit_queues[VIA_NUM_BLIT_ENGINES];
uint32_t dma_diff;
-} drm_via_private_t;
+};
enum via_family {
VIA_OTHER = 0, /* Baseline */
@@ -106,48 +110,65 @@ enum via_family {
#define VIA_BASE ((dev_priv->mmio))
#define VIA_READ(reg) DRM_READ32(VIA_BASE, reg)
-#define VIA_WRITE(reg,val) DRM_WRITE32(VIA_BASE, reg, val)
+#define VIA_WRITE(reg, val) DRM_WRITE32(VIA_BASE, reg, val)
#define VIA_READ8(reg) DRM_READ8(VIA_BASE, reg)
-#define VIA_WRITE8(reg,val) DRM_WRITE8(VIA_BASE, reg, val)
+#define VIA_WRITE8(reg, val) DRM_WRITE8(VIA_BASE, reg, val)
extern struct drm_ioctl_desc via_ioctls[];
extern int via_max_ioctl;
-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_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_get_drm_info(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);
-extern int via_init_context(struct drm_device * dev, int context);
-extern int via_final_context(struct drm_device * dev, int context);
+extern int via_init_context(struct drm_device *dev, int context);
+extern int via_final_context(struct drm_device *dev, int context);
-extern int via_do_cleanup_map(struct drm_device * dev);
-extern int via_driver_vblank_wait(struct drm_device * dev, unsigned int *sequence);
+extern int via_do_cleanup_map(struct drm_device *dev);
+extern int via_driver_vblank_wait(struct drm_device *dev,
+ unsigned int *sequence);
extern irqreturn_t via_driver_irq_handler(DRM_IRQ_ARGS);
-extern void via_driver_irq_preinstall(struct drm_device * dev);
-extern void via_driver_irq_postinstall(struct drm_device * dev);
-extern void via_driver_irq_uninstall(struct drm_device * dev);
+extern void via_driver_irq_preinstall(struct drm_device *dev);
+extern void via_driver_irq_postinstall(struct drm_device *dev);
+extern void via_driver_irq_uninstall(struct drm_device *dev);
-extern int via_dma_cleanup(struct drm_device * dev);
+extern int via_dma_cleanup(struct drm_device *dev);
extern void via_init_command_verifier(void);
-extern int via_driver_dma_quiescent(struct drm_device * dev);
-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 int via_driver_dma_quiescent(struct drm_device *dev);
+extern void via_init_futex(struct drm_via_private *dev_priv);
+extern void via_cleanup_futex(struct drm_via_private *dev_priv);
+extern void via_release_futex(struct drm_via_private *dev_priv, int context);
-extern void via_reclaim_buffers_locked(struct drm_device *dev, struct drm_file *file_priv);
+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);
+extern void via_dmablit_handler(struct drm_device *dev, int engine,
+ int from_irq);
extern void via_init_dmablit(struct drm_device *dev);
+extern int via_drm_resume(struct pci_dev *dev);
+extern int via_drm_suspend(struct pci_dev *dev, pm_message_t state);
+
#endif
--- a/drivers/char/drm/via_irq.c
+++ b/drivers/char/drm/via_irq.c
@@ -30,9 +30,10 @@
* Keith Whitwell <keith@...gstengraphics.com>
* Thomas Hellstrom <unichrome@...pmail.org>
*
- * This code provides standard DRM access to the Via Unichrome / Pro Vertical blank
- * interrupt, as well as an infrastructure to handle other interrupts of the chip.
- * The refresh rate is also calculated for video playback sync purposes.
+ * This code provides standard DRM access to the Via Unichrome
+ * / Pro Vertical blank interrupt, as well as an infrastructure
+ * to handle other interrupts of the chip. The refresh rate is
+ * also calculated for video playback sync purposes.
*/
#include "drmP.h"
@@ -99,11 +100,12 @@ static unsigned time_diff(struct timeval
irqreturn_t via_driver_irq_handler(DRM_IRQ_ARGS)
{
struct drm_device *dev = (struct drm_device *) arg;
- drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
+ struct drm_via_private *dev_priv =
+ (struct drm_via_private *) dev->dev_private;
u32 status;
int handled = 0;
struct timeval cur_vblank;
- drm_via_irq_t *cur_irq = dev_priv->via_irqs;
+ struct drm_via_irq *cur_irq = dev_priv->via_irqs;
int i;
status = VIA_READ(VIA_REG_INTERRUPT);
@@ -133,11 +135,12 @@ irqreturn_t via_driver_irq_handler(DRM_I
atomic_inc(&cur_irq->irq_received);
DRM_WAKEUP(&cur_irq->irq_queue);
handled = 1;
- if (dev_priv->irq_map[drm_via_irq_dma0_td] == i) {
+ if (dev_priv->irq_map[drm_via_irq_dma0_td] == i)
via_dmablit_handler(dev, 0, 1);
- } else if (dev_priv->irq_map[drm_via_irq_dma1_td] == i) {
+ else if (dev_priv->irq_map[drm_via_irq_dma1_td] ==
+ i)
via_dmablit_handler(dev, 1, 1);
- }
+
}
cur_irq++;
}
@@ -151,7 +154,8 @@ irqreturn_t via_driver_irq_handler(DRM_I
return IRQ_NONE;
}
-static __inline__ void viadrv_acknowledge_irqs(drm_via_private_t * dev_priv)
+static inline void
+viadrv_acknowledge_irqs(struct drm_via_private *dev_priv)
{
u32 status;
@@ -163,9 +167,10 @@ static __inline__ void viadrv_acknowledg
}
}
-int via_driver_vblank_wait(struct drm_device * dev, unsigned int *sequence)
+int via_driver_vblank_wait(struct drm_device *dev, unsigned int *sequence)
{
- drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
+ struct drm_via_private *dev_priv =
+ (struct drm_via_private *) dev->dev_private;
unsigned int cur_vblank;
int ret = 0;
@@ -191,12 +196,13 @@ int via_driver_vblank_wait(struct drm_de
}
static int
-via_driver_irq_wait(struct drm_device * dev, unsigned int irq, int force_sequence,
- unsigned int *sequence)
+via_driver_irq_wait(struct drm_device *dev, unsigned int irq,
+ int force_sequence, unsigned int *sequence)
{
- drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
+ struct drm_via_private *dev_priv =
+ (struct drm_via_private *) dev->dev_private;
unsigned int cur_irq_sequence;
- drm_via_irq_t *cur_irq;
+ struct drm_via_irq *cur_irq;
int ret = 0;
maskarray_t *masks;
int real_irq;
@@ -243,11 +249,12 @@ via_driver_irq_wait(struct drm_device *
* drm_dma.h hooks
*/
-void via_driver_irq_preinstall(struct drm_device * dev)
+void via_driver_irq_preinstall(struct drm_device *dev)
{
- drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
+ struct drm_via_private *dev_priv =
+ (struct drm_via_private *) dev->dev_private;
u32 status;
- drm_via_irq_t *cur_irq;
+ struct drm_via_irq *cur_irq;
int i;
DRM_DEBUG("dev_priv: %p\n", dev_priv);
@@ -292,9 +299,10 @@ void via_driver_irq_preinstall(struct dr
}
}
-void via_driver_irq_postinstall(struct drm_device * dev)
+void via_driver_irq_postinstall(struct drm_device *dev)
{
- drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
+ struct drm_via_private *dev_priv =
+ (struct drm_via_private *) dev->dev_private;
u32 status;
DRM_DEBUG("\n");
@@ -311,9 +319,10 @@ void via_driver_irq_postinstall(struct d
}
}
-void via_driver_irq_uninstall(struct drm_device * dev)
+void via_driver_irq_uninstall(struct drm_device *dev)
{
- drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
+ struct drm_via_private *dev_priv =
+ (struct drm_via_private *) dev->dev_private;
u32 status;
DRM_DEBUG("\n");
@@ -330,13 +339,15 @@ void via_driver_irq_uninstall(struct drm
}
}
-int via_wait_irq(struct drm_device *dev, void *data, struct drm_file *file_priv)
+int via_wait_irq(struct drm_device *dev, void *data,
+ struct drm_file *file_priv)
{
- drm_via_irqwait_t *irqwait = data;
+ union drm_via_irqwait *irqwait = data;
struct timeval now;
int ret = 0;
- drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
- drm_via_irq_t *cur_irq = dev_priv->via_irqs;
+ struct drm_via_private *dev_priv =
+ (struct drm_via_private *) dev->dev_private;
+ struct drm_via_irq *cur_irq = dev_priv->via_irqs;
int force_sequence;
if (!dev->irq)
@@ -352,7 +363,8 @@ int via_wait_irq(struct drm_device *dev,
switch (irqwait->request.type & ~VIA_IRQ_FLAGS_MASK) {
case VIA_IRQ_RELATIVE:
- irqwait->request.sequence += atomic_read(&cur_irq->irq_received);
+ irqwait->request.sequence +=
+ atomic_read(&cur_irq->irq_received);
irqwait->request.type &= ~_DRM_VBLANK_RELATIVE;
case VIA_IRQ_ABSOLUTE:
break;
--- a/drivers/char/drm/via_map.c
+++ b/drivers/char/drm/via_map.c
@@ -25,9 +25,11 @@
#include "via_drm.h"
#include "via_drv.h"
-static int via_do_init_map(struct drm_device * dev, drm_via_init_t * init)
+static int associate;
+
+static int via_do_init_map(struct drm_device *dev, struct drm_via_init *init)
{
- drm_via_private_t *dev_priv = dev->dev_private;
+ struct drm_via_private *dev_priv = dev->dev_private;
DRM_DEBUG("\n");
@@ -55,7 +57,7 @@ static int via_do_init_map(struct drm_de
}
dev_priv->sarea_priv =
- (drm_via_sarea_t *) ((u8 *) dev_priv->sarea->handle +
+ (struct drm_via_sarea *) ((u8 *) dev_priv->sarea->handle +
init->sarea_priv_offset);
dev_priv->agpAddr = init->agpAddr;
@@ -65,19 +67,43 @@ static int via_do_init_map(struct drm_de
via_init_dmablit(dev);
dev->dev_private = (void *)dev_priv;
+
+ /* from doing this, we has the stuff
+ *in prev data structure to manage agp
+ */
+ if (init->agp_type != DISABLED) {
+ dev_priv->agp = drm_core_findmap(dev, init->agp_offset);
+
+ if (!dev_priv->agp) {
+ DRM_ERROR("failed to find dma buffer region!\n");
+ return -EINVAL;
+ }
+
+ if (init->agp_type == AGP_DOUBLE_BUFFER)
+ dev_priv->agptype = AGP_DOUBLE_BUFFER;
+
+ if (init->agp_type == AGP_RING_BUFFER)
+ dev_priv->agptype = AGP_RING_BUFFER;
+ } else {
+ dev_priv->agptype = DISABLED;
+ dev_priv->agp = 0;
+ }
+ /* end */
+
return 0;
}
-int via_do_cleanup_map(struct drm_device * dev)
+int via_do_cleanup_map(struct drm_device *dev)
{
via_dma_cleanup(dev);
return 0;
}
-int via_map_init(struct drm_device *dev, void *data, struct drm_file *file_priv)
+int via_map_init(struct drm_device *dev, void *data,
+ struct drm_file *file_priv)
{
- drm_via_init_t *init = data;
+ struct drm_via_init *init = data;
DRM_DEBUG("\n");
@@ -93,10 +119,17 @@ int via_map_init(struct drm_device *dev,
int via_driver_load(struct drm_device *dev, unsigned long chipset)
{
- drm_via_private_t *dev_priv;
+ struct drm_via_private *dev_priv;
int ret = 0;
- dev_priv = drm_calloc(1, sizeof(drm_via_private_t), DRM_MEM_DRIVER);
+ if (!associate) {
+ pci_set_drvdata(dev->pdev, dev);
+ dev->pdev->driver = &dev->driver->pci_driver;
+ associate = 1;
+ }
+
+ dev_priv = drm_calloc(1,
+ sizeof(struct drm_via_private), DRM_MEM_DRIVER);
if (dev_priv == NULL)
return -ENOMEM;
@@ -105,19 +138,37 @@ int via_driver_load(struct drm_device *d
dev_priv->chipset = chipset;
ret = drm_sman_init(&dev_priv->sman, 2, 12, 8);
- if (ret) {
+ if (ret)
drm_free(dev_priv, sizeof(*dev_priv), DRM_MEM_DRIVER);
- }
+
return ret;
}
int via_driver_unload(struct drm_device *dev)
{
- drm_via_private_t *dev_priv = dev->dev_private;
+ struct drm_via_private *dev_priv = dev->dev_private;
drm_sman_takedown(&dev_priv->sman);
- drm_free(dev_priv, sizeof(drm_via_private_t), DRM_MEM_DRIVER);
+ drm_free(dev_priv, sizeof(struct drm_via_private), DRM_MEM_DRIVER);
+
+ return 0;
+}
+int via_get_drm_info(struct drm_device *dev, void *data,
+ struct drm_file *file_priv)
+{
+ struct drm_via_private *dev_priv =
+ (struct drm_via_private *)dev->dev_private;
+ struct drm_via_info info;
+
+ if (copy_from_user(&info, data, sizeof(info)))
+ return -EFAULT;
+ info.RegSize = dev_priv->mmio->size;
+ info.AgpSize = dev_priv->agp->size;
+ info.RegHandle = dev_priv->mmio->offset;
+ info.AgpHandle = dev_priv->agp->offset;
+ if (copy_to_user((struct drm_via_info *)data, &info, sizeof(info)))
+ return -EFAULT;
return 0;
}
--- a/drivers/char/drm/via_mm.c
+++ b/drivers/char/drm/via_mm.c
@@ -1,42 +1,47 @@
/*
- * Copyright 2006 Tungsten Graphics Inc., Bismarck, ND., USA.
- * All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sub license,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS AND/OR THEIR 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.
- */
+* Copyright 2006 Tungsten Graphics Inc., Bismarck, ND., USA.
+* All rights reserved.
+*
+* Permission is hereby granted, free of charge, to any person obtaining a
+* copy of this software and associated documentation files (the "Software"),
+* to deal in the Software without restriction, including without limitation
+* the rights to use, copy, modify, merge, publish, distribute, sub license,
+* and/or sell copies of the Software, and to permit persons to whom the
+* Software is furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice (including the
+* next paragraph) shall be included in all copies or substantial portions
+* of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+* THE AUTHORS OR COPYRIGHT HOLDERS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY
+* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
+* THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
/*
- * Authors: Thomas Hellström <thomas-at-tungstengraphics-dot-com>
- */
+* Authors: Thomas Hellström <thomas-at-tungstengraphics-dot-com>
+*/
#include "drmP.h"
#include "via_drm.h"
#include "via_drv.h"
#include "drm_sman.h"
+struct drm_via_video_save_head *via_video_save_head;
+
#define VIA_MM_ALIGN_SHIFT 4
-#define VIA_MM_ALIGN_MASK ( (1 << VIA_MM_ALIGN_SHIFT) - 1)
+#define VIA_MM_ALIGN_MASK ((1 << VIA_MM_ALIGN_SHIFT) - 1)
-int via_agp_init(struct drm_device *dev, void *data, struct drm_file *file_priv)
+int via_agp_init(struct drm_device *dev, void *data,
+struct drm_file *file_priv)
{
- drm_via_agp_t *agp = data;
- drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
+ struct drm_via_agp *agp = data;
+ struct drm_via_private *dev_priv =
+ (struct drm_via_private *) dev->dev_private;
int ret;
mutex_lock(&dev->struct_mutex);
@@ -57,10 +62,16 @@ int via_agp_init(struct drm_device *dev,
return 0;
}
+/*Henry:For via_fb_alloc/free used by video*/
+static void *global_dev;
+static void *global_file_priv;
+/*Henry:End*/
+
int via_fb_init(struct drm_device *dev, void *data, struct drm_file *file_priv)
{
- drm_via_fb_t *fb = data;
- drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
+ struct drm_via_fb *fb = data;
+ struct drm_via_private *dev_priv =
+ (struct drm_via_private *) dev->dev_private;
int ret;
mutex_lock(&dev->struct_mutex);
@@ -79,13 +90,19 @@ int via_fb_init(struct drm_device *dev,
mutex_unlock(&dev->struct_mutex);
DRM_DEBUG("offset = %u, size = %u\n", fb->offset, fb->size);
+ /*Henry:For via_fb_alloc/free used by video*/
+ global_dev = dev;
+ global_file_priv = file_priv;
+ /*Henry:End*/
+
return 0;
}
int via_final_context(struct drm_device *dev, int context)
{
- drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
+ struct drm_via_private *dev_priv =
+ (struct drm_via_private *) dev->dev_private;
via_release_futex(dev_priv, context);
@@ -103,7 +120,8 @@ int via_final_context(struct drm_device
void via_lastclose(struct drm_device *dev)
{
- drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
+ struct drm_via_private *dev_priv =
+ (struct drm_via_private *) dev->dev_private;
if (!dev_priv)
return;
@@ -115,38 +133,134 @@ void via_lastclose(struct drm_device *de
mutex_unlock(&dev->struct_mutex);
}
+static int via_videomem_presave_ok(struct drm_via_private *dev_priv,
+ struct drm_via_mem *mem)
+{
+ void *pvideomem = 0, *psystemmem = 0;
+ struct drm_via_video_save_head *pnode = 0;
+
+ if (!mem || !mem->size || (mem->type != VIA_MEM_VIDEO_SAVE))
+ return 0;
+
+ /* here the mem->offset is the absolute address,
+ *not the offset within videomem
+ */
+ pvideomem =
+ (void *)ioremap(dev_priv->fb->offset+mem->offset, mem->size);
+ if (!pvideomem)
+ return 0;
+ psystemmem = kmalloc(mem->size, GFP_KERNEL);
+ if (!psystemmem) {
+ iounmap(pvideomem);
+ return 0;
+ }
+
+ /* map success, then save this information into
+ * a data structure for later saving usage
+ */
+ pnode = kmalloc(sizeof(struct drm_via_video_save_head), GFP_KERNEL);
+
+ if (!pnode) {
+ iounmap(pvideomem);
+ kfree(psystemmem);
+ return 0;
+ }
+
+ pnode->next = 0;
+ pnode->psystemmem = psystemmem;
+ pnode->pvideomem = pvideomem;
+ pnode->size = mem->size;
+ pnode->token = mem->offset;
+
+ /* insert this node into list */
+ if (!via_video_save_head)
+ via_video_save_head = pnode;
+ else {
+ pnode->next = via_video_save_head;
+ via_video_save_head = pnode;
+ }
+
+ return 1;
+
+}
+
+static int via_videomem_housekeep_ok(struct drm_via_mem *mem)
+{
+ struct drm_via_video_save_head **ppnode = 0;
+ struct drm_via_video_save_head *tmpnode = 0;
+
+ /* if this mem's token match with one node of the list */
+
+ for (ppnode = &via_video_save_head; *ppnode;
+ ppnode = (struct drm_via_video_save_head **)
+ (&((*ppnode)->next))) {
+ if ((*ppnode)->token == mem->offset)
+ break;
+
+ }
+
+ if (*ppnode == 0)
+
+ /* not found, the user may specify the wrong mem node to free */
+ return 0;
+
+ /* delete this node from the list and then free
+ * all the mem to avoid memory leak
+ */
+ tmpnode = *ppnode;
+ *ppnode = (*ppnode)->next;
+ iounmap(tmpnode->pvideomem);
+ kfree(tmpnode->psystemmem);
+ kfree(tmpnode);
+
+ return 1;
+}
+
int via_mem_alloc(struct drm_device *dev, void *data,
struct drm_file *file_priv)
{
- drm_via_mem_t *mem = data;
+ struct drm_via_mem *mem = data;
int retval = 0;
struct drm_memblock_item *item;
- drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
+ struct drm_via_private *dev_priv =
+ (struct drm_via_private *) dev->dev_private;
unsigned long tmpSize;
- if (mem->type > VIA_MEM_AGP) {
+ if (mem->type > VIA_MEM_VIDEO_SAVE) {
DRM_ERROR("Unknown memory type allocation\n");
return -EINVAL;
}
mutex_lock(&dev->struct_mutex);
- 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");
+ if (0 ==
+ ((mem->type == VIA_MEM_VIDEO || mem->type == VIA_MEM_VIDEO_SAVE) ?
+ dev_priv->vram_initialized : dev_priv->agp_initialized)) {
+ DRM_ERROR("Attempt to allocate from \
+ uninitialized memory manager.\n");
mutex_unlock(&dev->struct_mutex);
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)file_priv);
+ item = drm_sman_alloc(&dev_priv->sman,
+ (mem->type == VIA_MEM_VIDEO_SAVE?VIA_MEM_VIDEO:mem->type),
+ tmpSize, 0, (unsigned long)file_priv);
mutex_unlock(&dev->struct_mutex);
if (item) {
- 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->offset =
+ ((mem->type == VIA_MEM_VIDEO ||
+ mem->type == VIA_MEM_VIDEO_SAVE) ?
+ 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;
+ if (mem->type == VIA_MEM_VIDEO_SAVE) {
+ if (!via_videomem_presave_ok(dev_priv, mem)) {
+ mutex_lock(&dev->struct_mutex);
+ drm_sman_free_key(&dev_priv->sman, mem->index);
+ mutex_unlock(&dev->struct_mutex);
+ retval = -ENOMEM;
+ }
+ }
} else {
mem->offset = 0;
mem->size = 0;
@@ -158,14 +272,20 @@ int via_mem_alloc(struct drm_device *dev
return retval;
}
-int via_mem_free(struct drm_device *dev, void *data, struct drm_file *file_priv)
+int via_mem_free(struct drm_device *dev, void *data,
+ struct drm_file *file_priv)
{
- drm_via_private_t *dev_priv = dev->dev_private;
- drm_via_mem_t *mem = data;
+ struct drm_via_private *dev_priv = dev->dev_private;
+ struct drm_via_mem *mem = data;
int ret;
mutex_lock(&dev->struct_mutex);
ret = drm_sman_free_key(&dev_priv->sman, mem->index);
+ if (mem->type == VIA_MEM_VIDEO_SAVE) {
+ if (!via_videomem_housekeep_ok(mem))
+ ret = -EINVAL;
+ }
+
mutex_unlock(&dev->struct_mutex);
DRM_DEBUG("free = 0x%lx\n", mem->index);
@@ -173,10 +293,10 @@ int via_mem_free(struct drm_device *dev,
}
-void via_reclaim_buffers_locked(struct drm_device * dev,
+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_via_private *dev_priv = dev->dev_private;
mutex_lock(&dev->struct_mutex);
if (drm_sman_owner_clean(&dev_priv->sman, (unsigned long)file_priv)) {
@@ -184,11 +304,36 @@ void via_reclaim_buffers_locked(struct d
return;
}
- if (dev->driver->dma_quiescent) {
+ if (dev->driver->dma_quiescent)
dev->driver->dma_quiescent(dev);
- }
+
drm_sman_owner_cleanup(&dev_priv->sman, (unsigned long)file_priv);
mutex_unlock(&dev->struct_mutex);
return;
}
+
+/*Henry:For via_fb_alloc/free used by video*/
+static int via_fb_alloc(struct drm_via_mem *mem)
+{
+ struct drm_device *dev = global_dev;
+ struct drm_file *file_priv = global_file_priv;
+
+ if (dev && file_priv)
+ return via_mem_alloc(dev, mem, file_priv);
+ else
+ return -EINVAL;
+}
+EXPORT_SYMBOL(via_fb_alloc);
+
+static int via_fb_free(struct drm_via_mem *mem)
+{
+ struct drm_device *dev = global_dev;
+ struct drm_file *file_priv = global_file_priv;
+
+ if (dev && file_priv)
+ return via_mem_free(dev, mem, file_priv);
+ else
+ return -EINVAL;
+}
+EXPORT_SYMBOL(via_fb_free);
--- a/drivers/char/drm/via_verifier.c
+++ b/drivers/char/drm/via_verifier.c
@@ -1,32 +1,32 @@
/*
- * Copyright 2004 The Unichrome Project. All Rights Reserved.
- * Copyright 2005 Thomas Hellstrom. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sub license,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHOR(S), AND/OR THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- *
- * Author: Thomas Hellstrom 2004, 2005.
- * This code was written using docs obtained under NDA from VIA Inc.
- *
- * Don't run this code directly on an AGP buffer. Due to cache problems it will
- * be very slow.
- */
+* Copyright 2004 The Unichrome Project. All Rights Reserved.
+* Copyright 2005 Thomas Hellstrom. All Rights Reserved.
+*
+* Permission is hereby granted, free of charge, to any person obtaining a
+* copy of this software and associated documentation files (the "Software"),
+* to deal in the Software without restriction, including without limitation
+* the rights to use, copy, modify, merge, publish, distribute, sub license,
+* and/or sell copies of the Software, and to permit persons to whom the
+* Software is furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice (including the
+* next paragraph) shall be included in all copies or substantial portions
+* of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+* THE AUTHOR(S), AND/OR THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES
+* OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+* DEALINGS IN THE SOFTWARE.
+*
+* Author: Thomas Hellstrom 2004, 2005.
+* This code was written using docs obtained under NDA from VIA Inc.
+*
+* Don't run this code directly on an AGP buffer. Due to cache problems it will
+* be very slow.
+*/
#include "via_3d_reg.h"
#include "drmP.h"
@@ -35,16 +35,16 @@
#include "via_verifier.h"
#include "via_drv.h"
-typedef enum {
+enum verifier_state {
state_command,
state_header2,
state_header1,
state_vheader5,
state_vheader6,
state_error
-} verifier_state_t;
+};
-typedef enum {
+enum hazard {
no_check = 0,
check_for_header2,
check_for_header1,
@@ -72,7 +72,7 @@ typedef enum {
check_for_vertex_count,
check_number_texunits,
forbidden_command
-} hazard_t;
+};
/*
* Associates each hazard above with a possible multi-command
@@ -81,7 +81,7 @@ typedef enum {
* that does not include any part of the address.
*/
-static drm_via_sequence_t seqs[] = {
+static enum drm_via_sequence seqs[] = {
no_sequence,
no_sequence,
no_sequence,
@@ -109,12 +109,12 @@ static drm_via_sequence_t seqs[] = {
no_sequence
};
-typedef struct {
+struct hz_init {
unsigned int code;
- hazard_t hz;
-} hz_init_t;
+ enum hazard hz;
+};
-static hz_init_t init_table1[] = {
+static struct hz_init init_table1[] = {
{0xf2, check_for_header2_err},
{0xf0, check_for_header1_err},
{0xee, check_for_fire},
@@ -165,7 +165,7 @@ static hz_init_t init_table1[] = {
{0x7D, check_for_vertex_count}
};
-static hz_init_t init_table2[] = {
+static struct hz_init init_table2[] = {
{0xf2, check_for_header2_err},
{0xf0, check_for_header1_err},
{0xee, check_for_fire},
@@ -223,19 +223,19 @@ static hz_init_t init_table2[] = {
{0x93, no_check}
};
-static hz_init_t init_table3[] = {
+static struct hz_init init_table3[] = {
{0xf2, check_for_header2_err},
{0xf0, check_for_header1_err},
{0xcc, check_for_dummy},
{0x00, check_number_texunits}
};
-static hazard_t table1[256];
-static hazard_t table2[256];
-static hazard_t table3[256];
+static enum hazard table1[256];
+static enum hazard table2[256];
+static enum hazard table3[256];
-static __inline__ int
-eat_words(const uint32_t ** buf, const uint32_t * buf_end, unsigned num_words)
+static inline int
+eat_words(const uint32_t **buf, const uint32_t *buf_end, unsigned num_words)
{
if ((buf_end - *buf) >= num_words) {
*buf += num_words;
@@ -249,18 +249,16 @@ eat_words(const uint32_t ** buf, const u
* Partially stolen from drm_memory.h
*/
-static __inline__ drm_local_map_t *via_drm_lookup_agp_map(drm_via_state_t *seq,
- unsigned long offset,
- unsigned long size,
- struct drm_device * dev)
+static inline drm_local_map_t *via_drm_lookup_agp_map(
+struct drm_via_state *seq, unsigned long offset, unsigned long size,
+struct drm_device *dev)
{
struct drm_map_list *r_list;
drm_local_map_t *map = seq->map_cache;
if (map && map->offset <= offset
- && (offset + size) <= (map->offset + map->size)) {
- return map;
- }
+ && (offset + size) <= (map->offset + map->size))
+ return map;
list_for_each_entry(r_list, &dev->maplist, head) {
map = r_list->map;
@@ -286,7 +284,7 @@ static __inline__ drm_local_map_t *via_d
* very little CPU time.
*/
-static __inline__ int finish_current_sequence(drm_via_state_t * cur_seq)
+static inline int finish_current_sequence(struct drm_via_state *cur_seq)
{
switch (cur_seq->unfinished) {
case z_address:
@@ -343,14 +341,14 @@ static __inline__ int finish_current_seq
return 0;
}
-static __inline__ int
-investigate_hazard(uint32_t cmd, hazard_t hz, drm_via_state_t * cur_seq)
+static inline int
+investigate_hazard(uint32_t cmd, enum hazard hz, struct drm_via_state *cur_seq)
{
register uint32_t tmp, *tmp_addr;
if (cur_seq->unfinished && (cur_seq->unfinished != seqs[hz])) {
- int ret;
- if ((ret = finish_current_sequence(cur_seq)))
+ int ret = finish_current_sequence(cur_seq);
+ if (ret)
return ret;
}
@@ -453,11 +451,11 @@ investigate_hazard(uint32_t cmd, hazard_
cur_seq->tex_npot[cur_seq->texture] = 1;
} else {
cur_seq->pitch[cur_seq->texture][tmp] =
- (cmd & HC_HTXnLnPitE_MASK) >> HC_HTXnLnPitE_SHIFT;
+ (cmd & HC_HTXnLnPitE_MASK) >> HC_HTXnLnPitE_SHIFT;
cur_seq->tex_npot[cur_seq->texture] = 0;
if (cmd & 0x000FFFFF) {
DRM_ERROR
- ("Unimplemented texture level 0 pitch mode.\n");
+ ("Unimplemented texture level 0 pitch mode.\n");
return 2;
}
}
@@ -494,7 +492,8 @@ investigate_hazard(uint32_t cmd, hazard_
return 0;
case check_texture_addr_mode:
cur_seq->unfinished = tex_address;
- if (2 == (tmp = cmd & 0x00000003)) {
+ tmp = cmd & 0x00000003;
+ if (2 == tmp) {
DRM_ERROR
("Attempt to fetch texture from system memory.\n");
return 2;
@@ -516,12 +515,12 @@ investigate_hazard(uint32_t cmd, hazard_
return 2;
}
-static __inline__ int
-via_check_prim_list(uint32_t const **buffer, const uint32_t * buf_end,
- drm_via_state_t * cur_seq)
+static inline int
+via_check_prim_list(uint32_t const **buffer, const uint32_t *buf_end,
+ struct drm_via_state *cur_seq)
{
- drm_via_private_t *dev_priv =
- (drm_via_private_t *) cur_seq->dev->dev_private;
+ struct drm_via_private *dev_priv =
+ (struct drm_via_private *) cur_seq->dev->dev_private;
uint32_t a_fire, bcmd, dw_count;
int ret = 0;
int have_fire;
@@ -596,12 +595,13 @@ via_check_prim_list(uint32_t const **buf
if ((*buf == HALCYON_HEADER2) ||
((*buf & HALCYON_FIREMASK) == HALCYON_FIRECMD)) {
DRM_ERROR("Missing Vertex Fire command, "
- "Stray Vertex Fire command or verifier "
+ "Stray Vertex Fire command or verifier "
"lost sync.\n");
ret = 1;
break;
}
- if ((ret = eat_words(&buf, buf_end, dw_count)))
+ ret = eat_words(&buf, buf_end, dw_count);
+ if (ret)
break;
}
if (buf >= buf_end && !have_fire) {
@@ -620,15 +620,15 @@ via_check_prim_list(uint32_t const **buf
return ret;
}
-static __inline__ verifier_state_t
-via_check_header2(uint32_t const **buffer, const uint32_t * buf_end,
- drm_via_state_t * hc_state)
+static inline enum verifier_state
+via_check_header2(uint32_t const **buffer, const uint32_t *buf_end,
+ struct drm_via_state *hc_state)
{
uint32_t cmd;
int hz_mode;
- hazard_t hz;
+ enum hazard hz;
const uint32_t *buf = *buffer;
- const hazard_t *hz_table;
+ const enum hazard *hz_table;
if ((buf_end - buf) < 2) {
DRM_ERROR
@@ -693,8 +693,10 @@ via_check_header2(uint32_t const **buffe
while (buf < buf_end) {
cmd = *buf++;
- if ((hz = hz_table[cmd >> 24])) {
- if ((hz_mode = investigate_hazard(cmd, hz, hc_state))) {
+ hz = hz_table[cmd >> 24];
+ if (hz) {
+ hz_mode = investigate_hazard(cmd, hz, hc_state);
+ if (hz_mode) {
if (hz_mode == 1) {
buf--;
break;
@@ -702,20 +704,19 @@ via_check_header2(uint32_t const **buffe
return state_error;
}
} else if (hc_state->unfinished &&
- finish_current_sequence(hc_state)) {
+ finish_current_sequence(hc_state))
return state_error;
- }
+
}
- if (hc_state->unfinished && finish_current_sequence(hc_state)) {
+ if (hc_state->unfinished && finish_current_sequence(hc_state))
return state_error;
- }
*buffer = buf;
return state_command;
}
-static __inline__ verifier_state_t
-via_parse_header2(drm_via_private_t * dev_priv, uint32_t const **buffer,
- const uint32_t * buf_end, int *fire_count)
+static inline enum verifier_state
+via_parse_header2(struct drm_via_private *dev_priv, uint32_t const **buffer,
+ const uint32_t *buf_end, int *fire_count)
{
uint32_t cmd;
const uint32_t *buf = *buffer;
@@ -762,7 +763,7 @@ via_parse_header2(drm_via_private_t * de
return state_command;
}
-static __inline__ int verify_mmio_address(uint32_t address)
+static inline int verify_mmio_address(uint32_t address)
{
if ((address > 0x3FF) && (address < 0xC00)) {
DRM_ERROR("Invalid VIDEO DMA command. "
@@ -780,8 +781,8 @@ static __inline__ int verify_mmio_addres
return 0;
}
-static __inline__ int
-verify_video_tail(uint32_t const **buffer, const uint32_t * buf_end,
+static inline int
+verify_video_tail(uint32_t const **buffer, const uint32_t *buf_end,
uint32_t dwords)
{
const uint32_t *buf = *buffer;
@@ -800,12 +801,12 @@ verify_video_tail(uint32_t const **buffe
return 0;
}
-static __inline__ verifier_state_t
-via_check_header1(uint32_t const **buffer, const uint32_t * buf_end)
+static inline enum verifier_state
+via_check_header1(uint32_t const **buffer, const uint32_t *buf_end)
{
uint32_t cmd;
const uint32_t *buf = *buffer;
- verifier_state_t ret = state_command;
+ enum verifier_state ret = state_command;
while (buf < buf_end) {
cmd = *buf;
@@ -813,14 +814,15 @@ via_check_header1(uint32_t const **buffe
(cmd < ((0xC00 >> 2) | HALCYON_HEADER1))) {
if ((cmd & HALCYON_HEADER1MASK) != HALCYON_HEADER1)
break;
- DRM_ERROR("Invalid HALCYON_HEADER1 command. "
- "Attempt to access 3D- or command burst area.\n");
+ DRM_ERROR("Invalid HALCYON_HEADER1 command. " \
+ "Attempt to access 3D- or command burst \
+ area.\n");
ret = state_error;
break;
} else if (cmd > ((0xCFF >> 2) | HALCYON_HEADER1)) {
if ((cmd & HALCYON_HEADER1MASK) != HALCYON_HEADER1)
break;
- DRM_ERROR("Invalid HALCYON_HEADER1 command. "
+ DRM_ERROR("Invalid HALCYON_HEADER1 command. " \
"Attempt to access VGA registers.\n");
ret = state_error;
break;
@@ -832,9 +834,9 @@ via_check_header1(uint32_t const **buffe
return ret;
}
-static __inline__ verifier_state_t
-via_parse_header1(drm_via_private_t * dev_priv, uint32_t const **buffer,
- const uint32_t * buf_end)
+static inline enum verifier_state
+via_parse_header1(struct drm_via_private *dev_priv, uint32_t const **buffer,
+ const uint32_t *buf_end)
{
register uint32_t cmd;
const uint32_t *buf = *buffer;
@@ -850,8 +852,8 @@ via_parse_header1(drm_via_private_t * de
return state_command;
}
-static __inline__ verifier_state_t
-via_check_vheader5(uint32_t const **buffer, const uint32_t * buf_end)
+static inline enum verifier_state
+via_check_vheader5(uint32_t const **buffer, const uint32_t *buf_end)
{
uint32_t data;
const uint32_t *buf = *buffer;
@@ -883,9 +885,9 @@ via_check_vheader5(uint32_t const **buff
}
-static __inline__ verifier_state_t
-via_parse_vheader5(drm_via_private_t * dev_priv, uint32_t const **buffer,
- const uint32_t * buf_end)
+static inline enum verifier_state
+via_parse_vheader5(struct drm_via_private *dev_priv,
+ uint32_t const **buffer, const uint32_t *buf_end)
{
uint32_t addr, count, i;
const uint32_t *buf = *buffer;
@@ -893,17 +895,17 @@ via_parse_vheader5(drm_via_private_t * d
addr = *buf++ & ~VIA_VIDEOMASK;
i = count = *buf;
buf += 3;
- while (i--) {
+ while (i--)
VIA_WRITE(addr, *buf++);
- }
+
if (count & 3)
buf += 4 - (count & 3);
*buffer = buf;
return state_command;
}
-static __inline__ verifier_state_t
-via_check_vheader6(uint32_t const **buffer, const uint32_t * buf_end)
+static inline enum verifier_state
+via_check_vheader6(uint32_t const **buffer, const uint32_t *buf_end)
{
uint32_t data;
const uint32_t *buf = *buffer;
@@ -939,9 +941,9 @@ via_check_vheader6(uint32_t const **buff
return state_command;
}
-static __inline__ verifier_state_t
-via_parse_vheader6(drm_via_private_t * dev_priv, uint32_t const **buffer,
- const uint32_t * buf_end)
+static inline enum verifier_state
+via_parse_vheader6(struct drm_via_private *dev_priv,
+ uint32_t const **buffer, const uint32_t *buf_end)
{
uint32_t addr, count, i;
@@ -961,16 +963,17 @@ via_parse_vheader6(drm_via_private_t * d
}
int
-via_verify_command_stream(const uint32_t * buf, unsigned int size,
- struct drm_device * dev, int agp)
+via_verify_command_stream(const uint32_t *buf, unsigned int size,
+ struct drm_device *dev, int agp)
{
- drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
- drm_via_state_t *hc_state = &dev_priv->hc_state;
- drm_via_state_t saved_state = *hc_state;
+ struct drm_via_private *dev_priv =
+ (struct drm_via_private *) dev->dev_private;
+ struct drm_via_state *hc_state = &dev_priv->hc_state;
+ struct drm_via_state saved_state = *hc_state;
uint32_t cmd;
const uint32_t *buf_end = buf + (size >> 2);
- verifier_state_t state = state_command;
+ enum verifier_state state = state_command;
int cme_video;
int supported_3d;
@@ -1002,8 +1005,8 @@ via_verify_command_stream(const uint32_t
state = via_check_vheader6(&buf, buf_end);
break;
case state_command:
- if ((HALCYON_HEADER2 == (cmd = *buf)) &&
- supported_3d)
+ cmd = *buf;
+ if ((HALCYON_HEADER2 == cmd) && supported_3d)
state = state_header2;
else if ((cmd & HALCYON_HEADER1MASK) == HALCYON_HEADER1)
state = state_header1;
@@ -1014,12 +1017,12 @@ via_verify_command_stream(const uint32_t
&& (cmd & VIA_VIDEOMASK) == VIA_VIDEO_HEADER6)
state = state_vheader6;
else if ((cmd == HALCYON_HEADER2) && !supported_3d) {
- DRM_ERROR("Accelerated 3D is not supported on this chipset yet.\n");
+ DRM_ERROR("Accelerated 3D is not \
+ supported on this chipset yet.\n");
state = state_error;
} else {
- DRM_ERROR
- ("Invalid / Unimplemented DMA HEADER command. 0x%x\n",
- cmd);
+ DRM_ERROR("Invalid / Unimplemented DMA \
+ HEADER command. 0x%x\n", cmd);
state = state_error;
}
break;
@@ -1037,14 +1040,15 @@ via_verify_command_stream(const uint32_t
}
int
-via_parse_command_stream(struct drm_device * dev, const uint32_t * buf,
+via_parse_command_stream(struct drm_device *dev, const uint32_t *buf,
unsigned int size)
{
- drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
+ struct drm_via_private *dev_priv =
+ (struct drm_via_private *) dev->dev_private;
uint32_t cmd;
const uint32_t *buf_end = buf + (size >> 2);
- verifier_state_t state = state_command;
+ enum verifier_state state = state_command;
int fire_count = 0;
while (buf < buf_end) {
@@ -1065,7 +1069,8 @@ via_parse_command_stream(struct drm_devi
state = via_parse_vheader6(dev_priv, &buf, buf_end);
break;
case state_command:
- if (HALCYON_HEADER2 == (cmd = *buf))
+ cmd = *buf;
+ if (HALCYON_HEADER2 == cmd)
state = state_header2;
else if ((cmd & HALCYON_HEADER1MASK) == HALCYON_HEADER1)
state = state_header1;
@@ -1074,9 +1079,8 @@ via_parse_command_stream(struct drm_devi
else if ((cmd & VIA_VIDEOMASK) == VIA_VIDEO_HEADER6)
state = state_vheader6;
else {
- DRM_ERROR
- ("Invalid / Unimplemented DMA HEADER command. 0x%x\n",
- cmd);
+ DRM_ERROR("Invalid / Unimplemented DMA \
+ HEADER command. 0x%x\n", cmd);
state = state_error;
}
break;
@@ -1085,32 +1089,31 @@ via_parse_command_stream(struct drm_devi
return -EINVAL;
}
}
- if (state == state_error) {
+ if (state == state_error)
return -EINVAL;
- }
+
return 0;
}
static void
-setup_hazard_table(hz_init_t init_table[], hazard_t table[], int size)
+setup_hazard_table(struct hz_init init_table[], enum hazard table[], int size)
{
int i;
- for (i = 0; i < 256; ++i) {
+ for (i = 0; i < 256; ++i)
table[i] = forbidden_command;
- }
- for (i = 0; i < size; ++i) {
+ for (i = 0; i < size; ++i)
table[init_table[i].code] = init_table[i].hz;
- }
+
}
void via_init_command_verifier(void)
{
setup_hazard_table(init_table1, table1,
- sizeof(init_table1) / sizeof(hz_init_t));
+ sizeof(init_table1) / sizeof(struct hz_init));
setup_hazard_table(init_table2, table2,
- sizeof(init_table2) / sizeof(hz_init_t));
+ sizeof(init_table2) / sizeof(struct hz_init));
setup_hazard_table(init_table3, table3,
- sizeof(init_table3) / sizeof(hz_init_t));
+ sizeof(init_table3) / sizeof(struct hz_init));
}
--- a/drivers/char/drm/via_verifier.h
+++ b/drivers/char/drm/via_verifier.h
@@ -1,39 +1,39 @@
/*
- * Copyright 2004 The Unichrome Project. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sub license,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
- * THE UNICHROME PROJECT, 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.
- *
- * Author: Thomas Hellström 2004.
- */
+* Copyright 2004 The Unichrome Project. All Rights Reserved.
+*
+* Permission is hereby granted, free of charge, to any person obtaining a
+* copy of this software and associated documentation files (the "Software"),
+* to deal in the Software without restriction, including without limitation
+* the rights to use, copy, modify, merge, publish, distribute, sub license,
+* and/or sell copies of the Software, and to permit persons to whom the
+* Software is furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice (including the
+* next paragraph) shall be included in all copies or substantial portions
+* of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+* THE UNICHROME PROJECT, 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.
+*
+* Author: Thomas Hellström 2004.
+*/
#ifndef _VIA_VERIFIER_H_
#define _VIA_VERIFIER_H_
-typedef enum {
+enum drm_via_sequence {
no_sequence = 0,
z_address,
dest_address,
tex_address
-} drm_via_sequence_t;
+};
-typedef struct {
+struct drm_via_state {
unsigned texture;
uint32_t z_addr;
uint32_t d_addr;
@@ -44,7 +44,7 @@ typedef struct {
uint32_t tex_level_hi[2];
uint32_t tex_palette_size[2];
uint32_t tex_npot[2];
- drm_via_sequence_t unfinished;
+ enum drm_via_sequence unfinished;
int agp_texture;
int multitex;
struct drm_device *dev;
@@ -52,11 +52,11 @@ typedef struct {
uint32_t vertex_count;
int agp;
const uint32_t *buf_start;
-} drm_via_state_t;
+};
-extern int via_verify_command_stream(const uint32_t * buf, unsigned int size,
- struct drm_device * dev, int agp);
-extern int via_parse_command_stream(struct drm_device *dev, const uint32_t *buf,
- unsigned int size);
+extern int via_verify_command_stream(const uint32_t *buf,
+ unsigned int size, struct drm_device *dev, int agp);
+extern int via_parse_command_stream(struct drm_device *dev,
+ const uint32_t *buf, unsigned int size);
#endif
--- a/drivers/char/drm/via_video.c
+++ b/drivers/char/drm/via_video.c
@@ -1,35 +1,35 @@
/*
- * Copyright 2005 Thomas Hellstrom. All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sub license,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHOR(S), AND/OR THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- *
- * Author: Thomas Hellstrom 2005.
- *
- * Video and XvMC related functions.
- */
+* Copyright 2005 Thomas Hellstrom. All Rights Reserved.
+*
+* Permission is hereby granted, free of charge, to any person obtaining a
+* copy of this software and associated documentation files (the "Software"),
+* to deal in the Software without restriction, including without limitation
+* the rights to use, copy, modify, merge, publish, distribute, sub license,
+* and/or sell copies of the Software, and to permit persons to whom the
+* Software is furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice (including the
+* next paragraph) shall be included in all copies or substantial portions
+* of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+* THE AUTHOR(S), AND/OR THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES
+* OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+* DEALINGS IN THE SOFTWARE.
+*
+* Author: Thomas Hellstrom 2005.
+*
+* Video and XvMC related functions.
+*/
#include "drmP.h"
#include "via_drm.h"
#include "via_drv.h"
-void via_init_futex(drm_via_private_t * dev_priv)
+void via_init_futex(struct drm_via_private *dev_priv)
{
unsigned int i;
@@ -41,11 +41,11 @@ void via_init_futex(drm_via_private_t *
}
}
-void via_cleanup_futex(drm_via_private_t * dev_priv)
+void via_cleanup_futex(struct drm_via_private *dev_priv)
{
}
-void via_release_futex(drm_via_private_t * dev_priv, int context)
+void via_release_futex(struct drm_via_private *dev_priv, int context)
{
unsigned int i;
volatile int *lock;
@@ -57,20 +57,22 @@ void via_release_futex(drm_via_private_t
lock = (volatile int *)XVMCLOCKPTR(dev_priv->sarea_priv, i);
if ((_DRM_LOCKING_CONTEXT(*lock) == context)) {
if (_DRM_LOCK_IS_HELD(*lock)
- && (*lock & _DRM_LOCK_CONT)) {
+ && (*lock & _DRM_LOCK_CONT))
DRM_WAKEUP(&(dev_priv->decoder_queue[i]));
- }
+
*lock = 0;
}
}
}
-int via_decoder_futex(struct drm_device *dev, void *data, struct drm_file *file_priv)
+int via_decoder_futex(struct drm_device *dev, void *data,
+ struct drm_file *file_priv)
{
- drm_via_futex_t *fx = data;
+ struct drm_via_futex *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;
+ struct drm_via_private *dev_priv =
+ (struct drm_via_private *) dev->dev_private;
+ struct drm_via_sarea *sAPriv = dev_priv->sarea_priv;
int ret = 0;
DRM_DEBUG("\n");
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@...r.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
Powered by blists - more mailing lists