Re: via agp patches

From: Greg KH
Date: Fri May 30 2008 - 20:37:31 EST

Next message: Pascal BrÃckner: "Re: [PATCH] libata: Handle bay devices in dock stations"
Previous message: Greg KH: "Re: via agp patches"
In reply to: Alan Cox: "Re: via agp patches"
Next in thread: Dave Airlie: "Re: via agp patches"
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]

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(&current->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@xxxxxxxxxxxxxxxxxxxx>
* Thomas Hellstrom <unichrome@xxxxxxxxxxxx>
*
- * 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@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/

Next message: Pascal BrÃckner: "Re: [PATCH] libata: Handle bay devices in dock stations"
Previous message: Greg KH: "Re: via agp patches"
In reply to: Alan Cox: "Re: via agp patches"
Next in thread: Dave Airlie: "Re: via agp patches"
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]