remove obsolete files
parent
59c07e447b
commit
9ceabc585a
|
@ -1,568 +0,0 @@
|
|||
/* gamma_dma.c -- DMA support for GMX 2000 -*- linux-c -*-
|
||||
* Created: Fri Mar 19 14:30:16 1999 by faith@precisioninsight.com
|
||||
*
|
||||
* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
|
||||
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a
|
||||
* copy of this software and associated documentation files (the "Software"),
|
||||
* to deal in the Software without restriction, including without limitation
|
||||
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
* and/or sell copies of the Software, and to permit persons to whom the
|
||||
* Software is furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice (including the next
|
||||
* paragraph) shall be included in all copies or substantial portions of the
|
||||
* Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
* PRECISION INSIGHT 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.
|
||||
*
|
||||
* Authors:
|
||||
* Rickard E. (Rik) Faith <faith@valinux.com>
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
|
||||
#include "gamma.h"
|
||||
#include "drmP.h"
|
||||
#include "drm.h"
|
||||
#include "gamma_drm.h"
|
||||
#include "gamma_drv.h"
|
||||
|
||||
|
||||
static __inline__ void gamma_dma_dispatch(drm_device_t *dev, unsigned long address,
|
||||
unsigned long length)
|
||||
{
|
||||
drm_gamma_private_t *dev_priv =
|
||||
(drm_gamma_private_t *)dev->dev_private;
|
||||
|
||||
GAMMA_WRITE(GAMMA_DMAADDRESS, DRM_OS_VTOPHYS((void *)address));
|
||||
while (GAMMA_READ(GAMMA_GCOMMANDSTATUS) != 4)
|
||||
;
|
||||
GAMMA_WRITE(GAMMA_DMACOUNT, length / 4);
|
||||
}
|
||||
|
||||
void gamma_dma_quiescent_single(drm_device_t *dev)
|
||||
{
|
||||
drm_gamma_private_t *dev_priv =
|
||||
(drm_gamma_private_t *)dev->dev_private;
|
||||
|
||||
while (GAMMA_READ(GAMMA_DMACOUNT))
|
||||
;
|
||||
while (GAMMA_READ(GAMMA_INFIFOSPACE) < 3)
|
||||
;
|
||||
|
||||
GAMMA_WRITE(GAMMA_FILTERMODE, 1 << 10);
|
||||
GAMMA_WRITE(GAMMA_SYNC, 0);
|
||||
|
||||
do {
|
||||
while (!GAMMA_READ(GAMMA_OUTFIFOWORDS))
|
||||
;
|
||||
} while (GAMMA_READ(GAMMA_OUTPUTFIFO) != GAMMA_SYNC_TAG);
|
||||
}
|
||||
|
||||
void gamma_dma_quiescent_dual(drm_device_t *dev)
|
||||
{
|
||||
drm_gamma_private_t *dev_priv =
|
||||
(drm_gamma_private_t *)dev->dev_private;
|
||||
|
||||
while (GAMMA_READ(GAMMA_DMACOUNT))
|
||||
;
|
||||
while (GAMMA_READ(GAMMA_INFIFOSPACE) < 3)
|
||||
;
|
||||
|
||||
GAMMA_WRITE(GAMMA_BROADCASTMASK, 3);
|
||||
|
||||
GAMMA_WRITE(GAMMA_FILTERMODE, 1 << 10);
|
||||
GAMMA_WRITE(GAMMA_SYNC, 0);
|
||||
|
||||
/* Read from first MX */
|
||||
do {
|
||||
while (!GAMMA_READ(GAMMA_OUTFIFOWORDS))
|
||||
;
|
||||
} while (GAMMA_READ(GAMMA_OUTPUTFIFO) != GAMMA_SYNC_TAG);
|
||||
|
||||
/* Read from second MX */
|
||||
do {
|
||||
while (!GAMMA_READ(GAMMA_OUTFIFOWORDS + 0x10000))
|
||||
;
|
||||
} while (GAMMA_READ(GAMMA_OUTPUTFIFO + 0x10000) != GAMMA_SYNC_TAG);
|
||||
}
|
||||
|
||||
void gamma_dma_ready(drm_device_t *dev)
|
||||
{
|
||||
drm_gamma_private_t *dev_priv =
|
||||
(drm_gamma_private_t *)dev->dev_private;
|
||||
|
||||
while (GAMMA_READ(GAMMA_DMACOUNT))
|
||||
;
|
||||
}
|
||||
|
||||
static __inline__ int gamma_dma_is_ready(drm_device_t *dev)
|
||||
{
|
||||
drm_gamma_private_t *dev_priv =
|
||||
(drm_gamma_private_t *)dev->dev_private;
|
||||
|
||||
return !GAMMA_READ(GAMMA_DMACOUNT);
|
||||
}
|
||||
|
||||
void gamma_dma_service( DRM_OS_IRQ_ARGS)
|
||||
{
|
||||
drm_device_t *dev = (drm_device_t *)device;
|
||||
drm_device_dma_t *dma = dev->dma;
|
||||
drm_gamma_private_t *dev_priv =
|
||||
(drm_gamma_private_t *)dev->dev_private;
|
||||
|
||||
atomic_inc(&dev->counts[6]); /* _DRM_STAT_IRQ */
|
||||
GAMMA_WRITE(GAMMA_GDELAYTIMER, 0xc350/2); /* 0x05S */
|
||||
GAMMA_WRITE(GAMMA_GCOMMANDINTFLAGS, 8);
|
||||
GAMMA_WRITE(GAMMA_GINTFLAGS, 0x2001);
|
||||
if (gamma_dma_is_ready(dev)) {
|
||||
/* Free previous buffer */
|
||||
if (test_and_set_bit(0, &dev->dma_flag)) return;
|
||||
if (dma->this_buffer) {
|
||||
gamma_free_buffer(dev, dma->this_buffer);
|
||||
dma->this_buffer = NULL;
|
||||
}
|
||||
clear_bit(0, &dev->dma_flag);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
/* Only called by gamma_dma_schedule. */
|
||||
static int gamma_do_dma(drm_device_t *dev, int locked)
|
||||
{
|
||||
unsigned long address;
|
||||
unsigned long length;
|
||||
drm_buf_t *buf;
|
||||
int retcode = 0;
|
||||
drm_device_dma_t *dma = dev->dma;
|
||||
#if DRM_DMA_HISTOGRAM
|
||||
cycles_t dma_start, dma_stop;
|
||||
#endif
|
||||
|
||||
if (test_and_set_bit(0, &dev->dma_flag)) DRM_OS_RETURN( EBUSY );
|
||||
|
||||
#if DRM_DMA_HISTOGRAM
|
||||
dma_start = get_cycles();
|
||||
#endif
|
||||
|
||||
if (!dma->next_buffer) {
|
||||
DRM_ERROR("No next_buffer\n");
|
||||
clear_bit(0, &dev->dma_flag);
|
||||
DRM_OS_RETURN( EINVAL );
|
||||
}
|
||||
|
||||
buf = dma->next_buffer;
|
||||
address = (unsigned long)buf->address;
|
||||
length = buf->used;
|
||||
|
||||
DRM_DEBUG("context %d, buffer %d (%ld bytes)\n",
|
||||
buf->context, buf->idx, length);
|
||||
|
||||
if (buf->list == DRM_LIST_RECLAIM) {
|
||||
gamma_clear_next_buffer(dev);
|
||||
gamma_free_buffer(dev, buf);
|
||||
clear_bit(0, &dev->dma_flag);
|
||||
DRM_OS_RETURN( EINVAL );
|
||||
}
|
||||
|
||||
if (!length) {
|
||||
DRM_ERROR("0 length buffer\n");
|
||||
gamma_clear_next_buffer(dev);
|
||||
gamma_free_buffer(dev, buf);
|
||||
clear_bit(0, &dev->dma_flag);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!gamma_dma_is_ready(dev)) {
|
||||
clear_bit(0, &dev->dma_flag);
|
||||
DRM_OS_RETURN( EBUSY );
|
||||
}
|
||||
|
||||
if (buf->while_locked) {
|
||||
if (!_DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock)) {
|
||||
DRM_ERROR("Dispatching buffer %d from pid %d"
|
||||
" \"while locked\", but no lock held\n",
|
||||
buf->idx, buf->pid);
|
||||
}
|
||||
} else {
|
||||
if (!locked && !gamma_lock_take(&dev->lock.hw_lock->lock,
|
||||
DRM_KERNEL_CONTEXT)) {
|
||||
clear_bit(0, &dev->dma_flag);
|
||||
DRM_OS_RETURN( EBUSY );
|
||||
}
|
||||
}
|
||||
|
||||
if (dev->last_context != buf->context
|
||||
&& !(dev->queuelist[buf->context]->flags
|
||||
& _DRM_CONTEXT_PRESERVED)) {
|
||||
/* PRE: dev->last_context != buf->context */
|
||||
if (DRM(context_switch)(dev, dev->last_context,
|
||||
buf->context)) {
|
||||
DRM(clear_next_buffer)(dev);
|
||||
DRM(free_buffer)(dev, buf);
|
||||
}
|
||||
retcode = EBUSY;
|
||||
goto cleanup;
|
||||
|
||||
/* POST: we will wait for the context
|
||||
switch and will dispatch on a later call
|
||||
when dev->last_context == buf->context.
|
||||
NOTE WE HOLD THE LOCK THROUGHOUT THIS
|
||||
TIME! */
|
||||
}
|
||||
|
||||
gamma_clear_next_buffer(dev);
|
||||
buf->pending = 1;
|
||||
buf->waiting = 0;
|
||||
buf->list = DRM_LIST_PEND;
|
||||
#if DRM_DMA_HISTOGRAM
|
||||
buf->time_dispatched = get_cycles();
|
||||
#endif
|
||||
|
||||
gamma_dma_dispatch(dev, address, length);
|
||||
gamma_free_buffer(dev, dma->this_buffer);
|
||||
dma->this_buffer = buf;
|
||||
|
||||
atomic_inc(&dev->counts[7]); /* _DRM_STAT_DMA */
|
||||
atomic_add(length, &dev->counts[8]); /* _DRM_STAT_PRIMARY */
|
||||
|
||||
if (!buf->while_locked && !dev->context_flag && !locked) {
|
||||
if (gamma_lock_free(dev, &dev->lock.hw_lock->lock,
|
||||
DRM_KERNEL_CONTEXT)) {
|
||||
DRM_ERROR("\n");
|
||||
}
|
||||
}
|
||||
cleanup:
|
||||
|
||||
clear_bit(0, &dev->dma_flag);
|
||||
|
||||
#if DRM_DMA_HISTOGRAM
|
||||
dma_stop = get_cycles();
|
||||
atomic_inc(&dev->histo.dma[gamma_histogram_slot(dma_stop - dma_start)]);
|
||||
#endif
|
||||
|
||||
DRM_OS_RETURN( retcode );
|
||||
}
|
||||
|
||||
static void gamma_dma_timer_bh(unsigned long dev)
|
||||
{
|
||||
gamma_dma_schedule((drm_device_t *)dev, 0);
|
||||
}
|
||||
|
||||
void gamma_dma_immediate_bh(DRM_OS_TASKQUEUE_ARGS)
|
||||
{
|
||||
gamma_dma_schedule(dev, 0);
|
||||
}
|
||||
|
||||
int gamma_dma_schedule(drm_device_t *dev, int locked)
|
||||
{
|
||||
int next;
|
||||
drm_queue_t *q;
|
||||
drm_buf_t *buf;
|
||||
int retcode = 0;
|
||||
int processed = 0;
|
||||
int missed;
|
||||
int expire = 20;
|
||||
drm_device_dma_t *dma = dev->dma;
|
||||
#if DRM_DMA_HISTOGRAM
|
||||
cycles_t schedule_start;
|
||||
#endif
|
||||
|
||||
if (test_and_set_bit(0, &dev->interrupt_flag)) {
|
||||
/* Not reentrant */
|
||||
atomic_inc(&dev->counts[10]); /* _DRM_STAT_MISSED */
|
||||
DRM_OS_RETURN( EBUSY );
|
||||
}
|
||||
missed = atomic_read(&dev->counts[10]);
|
||||
|
||||
#if DRM_DMA_HISTOGRAM
|
||||
schedule_start = get_cycles();
|
||||
#endif
|
||||
|
||||
again:
|
||||
if (dev->context_flag) {
|
||||
clear_bit(0, &dev->interrupt_flag);
|
||||
DRM_OS_RETURN( EBUSY );
|
||||
}
|
||||
if (dma->next_buffer) {
|
||||
/* Unsent buffer that was previously
|
||||
selected, but that couldn't be sent
|
||||
because the lock could not be obtained
|
||||
or the DMA engine wasn't ready. Try
|
||||
again. */
|
||||
if (!(retcode = gamma_do_dma(dev, locked))) ++processed;
|
||||
} else {
|
||||
do {
|
||||
next = gamma_select_queue(dev, gamma_dma_timer_bh);
|
||||
if (next >= 0) {
|
||||
q = dev->queuelist[next];
|
||||
buf = gamma_waitlist_get(&q->waitlist);
|
||||
dma->next_buffer = buf;
|
||||
dma->next_queue = q;
|
||||
if (buf && buf->list == DRM_LIST_RECLAIM) {
|
||||
gamma_clear_next_buffer(dev);
|
||||
gamma_free_buffer(dev, buf);
|
||||
}
|
||||
}
|
||||
} while (next >= 0 && !dma->next_buffer);
|
||||
if (dma->next_buffer) {
|
||||
if (!(retcode = gamma_do_dma(dev, locked))) {
|
||||
++processed;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (--expire) {
|
||||
if (missed != atomic_read(&dev->counts[10])) {
|
||||
if (gamma_dma_is_ready(dev)) goto again;
|
||||
}
|
||||
if (processed && gamma_dma_is_ready(dev)) {
|
||||
processed = 0;
|
||||
goto again;
|
||||
}
|
||||
}
|
||||
|
||||
clear_bit(0, &dev->interrupt_flag);
|
||||
|
||||
#if DRM_DMA_HISTOGRAM
|
||||
atomic_inc(&dev->histo.schedule[gamma_histogram_slot(get_cycles()
|
||||
- schedule_start)]);
|
||||
#endif
|
||||
return retcode;
|
||||
}
|
||||
|
||||
static int gamma_dma_priority(drm_device_t *dev, drm_dma_t *d)
|
||||
{
|
||||
unsigned long address;
|
||||
unsigned long length;
|
||||
int must_free = 0;
|
||||
int retcode = 0;
|
||||
int i;
|
||||
int idx;
|
||||
drm_buf_t *buf;
|
||||
drm_buf_t *last_buf = NULL;
|
||||
drm_device_dma_t *dma = dev->dma;
|
||||
static int never;
|
||||
|
||||
/* Turn off interrupt handling */
|
||||
while (test_and_set_bit(0, &dev->interrupt_flag)) {
|
||||
retcode = tsleep(&never, PZERO|PCATCH, "gamp1", 1);
|
||||
if (retcode)
|
||||
return retcode;
|
||||
}
|
||||
if (!(d->flags & _DRM_DMA_WHILE_LOCKED)) {
|
||||
while (!gamma_lock_take(&dev->lock.hw_lock->lock,
|
||||
DRM_KERNEL_CONTEXT)) {
|
||||
retcode = tsleep(&never, PZERO|PCATCH, "gamp2", 1);
|
||||
if (retcode)
|
||||
return retcode;
|
||||
}
|
||||
++must_free;
|
||||
}
|
||||
|
||||
for (i = 0; i < d->send_count; i++) {
|
||||
idx = d->send_indices[i];
|
||||
if (idx < 0 || idx >= dma->buf_count) {
|
||||
DRM_ERROR("Index %d (of %d max)\n",
|
||||
d->send_indices[i], dma->buf_count - 1);
|
||||
continue;
|
||||
}
|
||||
buf = dma->buflist[ idx ];
|
||||
if (buf->pid != DRM_OS_CURRENTPID) {
|
||||
DRM_ERROR("Process %d using buffer owned by %d\n",
|
||||
DRM_OS_CURRENTPID, buf->pid);
|
||||
retcode = EINVAL;
|
||||
goto cleanup;
|
||||
}
|
||||
if (buf->list != DRM_LIST_NONE) {
|
||||
DRM_ERROR("Process %d using %d's buffer on list %d\n",
|
||||
DRM_OS_CURRENTPID, buf->pid, buf->list);
|
||||
retcode = EINVAL;
|
||||
goto cleanup;
|
||||
}
|
||||
/* This isn't a race condition on
|
||||
buf->list, since our concern is the
|
||||
buffer reclaim during the time the
|
||||
process closes the /dev/drm? handle, so
|
||||
it can't also be doing DMA. */
|
||||
buf->list = DRM_LIST_PRIO;
|
||||
buf->used = d->send_sizes[i];
|
||||
buf->context = d->context;
|
||||
buf->while_locked = d->flags & _DRM_DMA_WHILE_LOCKED;
|
||||
address = (unsigned long)buf->address;
|
||||
length = buf->used;
|
||||
if (!length) {
|
||||
DRM_ERROR("0 length buffer\n");
|
||||
}
|
||||
if (buf->pending) {
|
||||
DRM_ERROR("Sending pending buffer:"
|
||||
" buffer %d, offset %d\n",
|
||||
d->send_indices[i], i);
|
||||
retcode = EINVAL;
|
||||
goto cleanup;
|
||||
}
|
||||
if (buf->waiting) {
|
||||
DRM_ERROR("Sending waiting buffer:"
|
||||
" buffer %d, offset %d\n",
|
||||
d->send_indices[i], i);
|
||||
retcode = EINVAL;
|
||||
goto cleanup;
|
||||
}
|
||||
buf->pending = 1;
|
||||
|
||||
if (dev->last_context != buf->context
|
||||
&& !(dev->queuelist[buf->context]->flags
|
||||
& _DRM_CONTEXT_PRESERVED)) {
|
||||
/* PRE: dev->last_context != buf->context */
|
||||
DRM(context_switch)(dev, dev->last_context,
|
||||
buf->context);
|
||||
/* POST: we will wait for the context
|
||||
switch and will dispatch on a later call
|
||||
when dev->last_context == buf->context.
|
||||
NOTE WE HOLD THE LOCK THROUGHOUT THIS
|
||||
TIME! */
|
||||
retcode = tsleep(&dev->context_wait, PZERO|PCATCH,
|
||||
"gamctx", 0);
|
||||
if (retcode)
|
||||
goto cleanup;
|
||||
if (dev->last_context != buf->context) {
|
||||
DRM_ERROR("Context mismatch: %d %d\n",
|
||||
dev->last_context,
|
||||
buf->context);
|
||||
}
|
||||
}
|
||||
|
||||
#if DRM_DMA_HISTOGRAM
|
||||
buf->time_queued = get_cycles();
|
||||
buf->time_dispatched = buf->time_queued;
|
||||
#endif
|
||||
gamma_dma_dispatch(dev, address, length);
|
||||
atomic_inc(&dev->counts[9]); /* _DRM_STAT_SPECIAL */
|
||||
atomic_add(length, &dev->counts[8]); /* _DRM_STAT_PRIMARY */
|
||||
|
||||
if (last_buf) {
|
||||
gamma_free_buffer(dev, last_buf);
|
||||
}
|
||||
last_buf = buf;
|
||||
}
|
||||
|
||||
|
||||
cleanup:
|
||||
if (last_buf) {
|
||||
gamma_dma_ready(dev);
|
||||
gamma_free_buffer(dev, last_buf);
|
||||
}
|
||||
|
||||
if (must_free && !dev->context_flag) {
|
||||
if (gamma_lock_free(dev, &dev->lock.hw_lock->lock,
|
||||
DRM_KERNEL_CONTEXT)) {
|
||||
DRM_ERROR("\n");
|
||||
}
|
||||
}
|
||||
clear_bit(0, &dev->interrupt_flag);
|
||||
DRM_OS_RETURN( retcode );
|
||||
}
|
||||
|
||||
static int gamma_dma_send_buffers(drm_device_t *dev, drm_dma_t *d)
|
||||
{
|
||||
drm_buf_t *last_buf = NULL;
|
||||
int retcode = 0;
|
||||
drm_device_dma_t *dma = dev->dma;
|
||||
|
||||
if (d->flags & _DRM_DMA_BLOCK) {
|
||||
last_buf = dma->buflist[d->send_indices[d->send_count-1]];
|
||||
atomic_inc(&last_buf->dma_wait);
|
||||
}
|
||||
|
||||
if ((retcode = gamma_dma_enqueue(dev, d))) {
|
||||
if (d->flags & _DRM_DMA_BLOCK)
|
||||
atomic_dec(&last_buf->dma_wait);
|
||||
return retcode;
|
||||
}
|
||||
|
||||
gamma_dma_schedule(dev, 0);
|
||||
|
||||
if (d->flags & _DRM_DMA_BLOCK) {
|
||||
DRM_DEBUG("%d waiting\n", DRM_OS_CURRENTPID);
|
||||
for (;;) {
|
||||
retcode = tsleep(&last_buf->dma_wait, PZERO|PCATCH,
|
||||
"gamdw", 0);
|
||||
if (!last_buf->waiting
|
||||
&& !last_buf->pending)
|
||||
break; /* finished */
|
||||
if (retcode)
|
||||
break;
|
||||
}
|
||||
atomic_dec(&last_buf->dma_wait);
|
||||
DRM_DEBUG("%d running\n", DRM_OS_CURRENTPID);
|
||||
if (!retcode
|
||||
|| (last_buf->list==DRM_LIST_PEND && !last_buf->pending)) {
|
||||
if (!last_buf->dma_wait) {
|
||||
gamma_free_buffer(dev, last_buf);
|
||||
}
|
||||
}
|
||||
if (retcode) {
|
||||
DRM_ERROR("ctx%d w%d p%d c%d i%d l%d %d/%d\n",
|
||||
d->context,
|
||||
last_buf->waiting,
|
||||
last_buf->pending,
|
||||
DRM_WAITCOUNT(dev, d->context),
|
||||
last_buf->idx,
|
||||
last_buf->list,
|
||||
last_buf->pid,
|
||||
DRM_OS_CURRENTPID);
|
||||
}
|
||||
}
|
||||
DRM_OS_RETURN( retcode );
|
||||
}
|
||||
|
||||
int gamma_dma( DRM_OS_IOCTL )
|
||||
{
|
||||
DRM_OS_DEVICE;
|
||||
drm_device_dma_t *dma = dev->dma;
|
||||
int retcode = 0;
|
||||
drm_dma_t d;
|
||||
|
||||
DRM_OS_KRNFROMUSR(d, (drm_dma_t *) data, sizeof(d));
|
||||
|
||||
if (d.send_count < 0 || d.send_count > dma->buf_count) {
|
||||
DRM_ERROR("Process %d trying to send %d buffers (of %d max)\n",
|
||||
DRM_OS_CURRENTPID, d.send_count, dma->buf_count);
|
||||
DRM_OS_RETURN( EINVAL );
|
||||
}
|
||||
|
||||
if (d.request_count < 0 || d.request_count > dma->buf_count) {
|
||||
DRM_ERROR("Process %d trying to get %d buffers (of %d max)\n",
|
||||
DRM_OS_CURRENTPID, d.request_count, dma->buf_count);
|
||||
DRM_OS_RETURN( EINVAL );
|
||||
}
|
||||
|
||||
if (d.send_count) {
|
||||
if (d.flags & _DRM_DMA_PRIORITY)
|
||||
retcode = gamma_dma_priority(dev, &d);
|
||||
else
|
||||
retcode = gamma_dma_send_buffers(dev, &d);
|
||||
}
|
||||
|
||||
d.granted_count = 0;
|
||||
|
||||
if (!retcode && d.request_count) {
|
||||
retcode = gamma_dma_get_buffers(dev, &d);
|
||||
}
|
||||
|
||||
DRM_DEBUG("%d returning, granted = %d\n",
|
||||
DRM_OS_CURRENTPID, d.granted_count);
|
||||
DRM_OS_KRNTOUSR((drm_dma_t *) data, d, sizeof(d));
|
||||
|
||||
return retcode;
|
||||
}
|
|
@ -1,89 +0,0 @@
|
|||
/* gamma.c -- 3dlabs GMX 2000 driver -*- linux-c -*-
|
||||
* Created: Mon Jan 4 08:58:31 1999 by faith@precisioninsight.com
|
||||
*
|
||||
* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
|
||||
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a
|
||||
* copy of this software and associated documentation files (the "Software"),
|
||||
* to deal in the Software without restriction, including without limitation
|
||||
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
* and/or sell copies of the Software, and to permit persons to whom the
|
||||
* Software is furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice (including the next
|
||||
* paragraph) shall be included in all copies or substantial portions of the
|
||||
* Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
* PRECISION INSIGHT 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.
|
||||
*
|
||||
* Authors:
|
||||
* Rickard E. (Rik) Faith <faith@valinux.com>
|
||||
* Gareth Hughes <gareth@valinux.com>
|
||||
*/
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <sys/bus.h>
|
||||
#include <pci/pcivar.h>
|
||||
#include <opt_drm_linux.h>
|
||||
#include "gamma.h"
|
||||
#include "drmP.h"
|
||||
#include "drm.h"
|
||||
#include "gamma_drm.h"
|
||||
#include "gamma_drv.h"
|
||||
|
||||
#define DRIVER_AUTHOR "VA Linux Systems Inc."
|
||||
|
||||
#define DRIVER_NAME "gamma"
|
||||
#define DRIVER_DESC "3DLabs gamma"
|
||||
#define DRIVER_DATE "20010216"
|
||||
|
||||
#define DRIVER_MAJOR 1
|
||||
#define DRIVER_MINOR 0
|
||||
#define DRIVER_PATCHLEVEL 0
|
||||
|
||||
#define DRIVER_IOCTLS \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_DMA)] = { gamma_dma, 1, 0 }
|
||||
|
||||
/* List acquired from http://www.yourvote.com/pci/pcihdr.h and xc/xc/programs/Xserver/hw/xfree86/common/xf86PciInfo.h
|
||||
* Please report to anholt@teleport.com inaccuracies or if a chip you have works that is marked unsupported here.
|
||||
*/
|
||||
drm_chipinfo_t DRM(devicelist)[] = {
|
||||
{0x3d3d, 0x0008, 1, "3DLabs Gamma"},
|
||||
{0, 0, 0, NULL}
|
||||
};
|
||||
|
||||
|
||||
#define __HAVE_COUNTERS 5
|
||||
#define __HAVE_COUNTER6 _DRM_STAT_IRQ
|
||||
#define __HAVE_COUNTER7 _DRM_STAT_DMA
|
||||
#define __HAVE_COUNTER8 _DRM_STAT_PRIMARY
|
||||
#define __HAVE_COUNTER9 _DRM_STAT_SPECIAL
|
||||
#define __HAVE_COUNTER10 _DRM_STAT_MISSED
|
||||
|
||||
|
||||
#include "drm_auth.h"
|
||||
#include "drm_bufs.h"
|
||||
#include "drm_context.h"
|
||||
#include "drm_dma.h"
|
||||
#include "drm_drawable.h"
|
||||
#include "drm_drv.h"
|
||||
|
||||
|
||||
#include "drm_fops.h"
|
||||
#include "drm_init.h"
|
||||
#include "drm_ioctl.h"
|
||||
#include "drm_lists.h"
|
||||
#include "drm_lock.h"
|
||||
#include "drm_memory.h"
|
||||
#include "drm_vm.h"
|
||||
#include "drm_sysctl.h"
|
||||
|
||||
DRIVER_MODULE(gamma, pci, gamma_driver, gamma_devclass, 0, 0);
|
1223
bsd/i810/i810_dma.c
1223
bsd/i810/i810_dma.c
File diff suppressed because it is too large
Load Diff
|
@ -1,97 +0,0 @@
|
|||
/* i810_drv.c -- I810 driver -*- linux-c -*-
|
||||
* Created: Mon Dec 13 01:56:22 1999 by jhartmann@precisioninsight.com
|
||||
*
|
||||
* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
|
||||
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a
|
||||
* copy of this software and associated documentation files (the "Software"),
|
||||
* to deal in the Software without restriction, including without limitation
|
||||
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
* and/or sell copies of the Software, and to permit persons to whom the
|
||||
* Software is furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice (including the next
|
||||
* paragraph) shall be included in all copies or substantial portions of the
|
||||
* Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
* VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||||
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
* OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* Authors:
|
||||
* Rickard E. (Rik) Faith <faith@valinux.com>
|
||||
* Jeff Hartmann <jhartmann@valinux.com>
|
||||
* Gareth Hughes <gareth@valinux.com>
|
||||
*/
|
||||
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <sys/bus.h>
|
||||
#include <pci/pcivar.h>
|
||||
#include <opt_drm_linux.h>
|
||||
|
||||
#include "i810.h"
|
||||
#include "drmP.h"
|
||||
#include "drm.h"
|
||||
#include "i810_drm.h"
|
||||
#include "i810_drv.h"
|
||||
|
||||
#define DRIVER_AUTHOR "VA Linux Systems Inc."
|
||||
|
||||
#define DRIVER_NAME "i810"
|
||||
#define DRIVER_DESC "Intel i810"
|
||||
#define DRIVER_DATE "20010616"
|
||||
|
||||
#define DRIVER_MAJOR 1
|
||||
#define DRIVER_MINOR 2
|
||||
#define DRIVER_PATCHLEVEL 0
|
||||
|
||||
/* Device IDs unknown. Can someone help? anholt@teleport.com */
|
||||
drm_chipinfo_t DRM(devicelist)[] = {
|
||||
{0, 0, 0, NULL}
|
||||
};
|
||||
|
||||
#define DRIVER_IOCTLS \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_I810_INIT)] = { i810_dma_init, 1, 1 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_I810_VERTEX)] = { i810_dma_vertex, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_I810_CLEAR)] = { i810_clear_bufs, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_I810_FLUSH)] = { i810_flush_ioctl, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_I810_GETAGE)] = { i810_getage, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_I810_GETBUF)] = { i810_getbuf, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_I810_SWAP)] = { i810_swap_bufs, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_I810_COPY)] = { i810_copybuf, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_I810_DOCOPY)] = { i810_docopy, 1, 0 },
|
||||
|
||||
|
||||
#define __HAVE_COUNTERS 4
|
||||
#define __HAVE_COUNTER6 _DRM_STAT_IRQ
|
||||
#define __HAVE_COUNTER7 _DRM_STAT_PRIMARY
|
||||
#define __HAVE_COUNTER8 _DRM_STAT_SECONDARY
|
||||
#define __HAVE_COUNTER9 _DRM_STAT_DMA
|
||||
|
||||
|
||||
#include "drm_agpsupport.h"
|
||||
#include "drm_auth.h"
|
||||
#include "drm_bufs.h"
|
||||
#include "drm_context.h"
|
||||
#include "drm_dma.h"
|
||||
#include "drm_drawable.h"
|
||||
#include "drm_drv.h"
|
||||
|
||||
|
||||
#include "drm_fops.h"
|
||||
#include "drm_init.h"
|
||||
#include "drm_ioctl.h"
|
||||
#include "drm_lock.h"
|
||||
#include "drm_lists.h"
|
||||
#include "drm_memory.h"
|
||||
#include "drm_vm.h"
|
||||
#include "drm_sysctl.h"
|
||||
|
||||
DRIVER_MODULE(i810, pci, i810_driver, i810_devclass, 0, 0);
|
1420
bsd/i830/i830_dma.c
1420
bsd/i830/i830_dma.c
File diff suppressed because it is too large
Load Diff
|
@ -1,104 +0,0 @@
|
|||
/* i830_drv.c -- I810 driver -*- linux-c -*-
|
||||
* Created: Mon Dec 13 01:56:22 1999 by jhartmann@precisioninsight.com
|
||||
*
|
||||
* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
|
||||
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a
|
||||
* copy of this software and associated documentation files (the "Software"),
|
||||
* to deal in the Software without restriction, including without limitation
|
||||
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
* and/or sell copies of the Software, and to permit persons to whom the
|
||||
* Software is furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice (including the next
|
||||
* paragraph) shall be included in all copies or substantial portions of the
|
||||
* Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
* VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||||
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
* OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* Authors:
|
||||
* Rickard E. (Rik) Faith <faith@valinux.com>
|
||||
* Jeff Hartmann <jhartmann@valinux.com>
|
||||
* Gareth Hughes <gareth@valinux.com>
|
||||
* Abraham vd Merwe <abraham@2d3d.co.za>
|
||||
*/
|
||||
|
||||
#include <linux/config.h>
|
||||
#include "i830.h"
|
||||
#include "drmP.h"
|
||||
#include "drm.h"
|
||||
#include "i830_drm.h"
|
||||
#include "i830_drv.h"
|
||||
|
||||
#define DRIVER_AUTHOR "VA Linux Systems Inc."
|
||||
|
||||
#define DRIVER_NAME "i830"
|
||||
#define DRIVER_DESC "Intel 830M"
|
||||
#define DRIVER_DATE "20011004"
|
||||
|
||||
#define DRIVER_MAJOR 1
|
||||
#define DRIVER_MINOR 2
|
||||
#define DRIVER_PATCHLEVEL 0
|
||||
|
||||
#define DRIVER_IOCTLS \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_I830_INIT)] = { i830_dma_init, 1, 1 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_I830_VERTEX)] = { i830_dma_vertex, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_I830_CLEAR)] = { i830_clear_bufs, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_I830_FLUSH)] = { i830_flush_ioctl, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_I830_GETAGE)] = { i830_getage, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_I830_GETBUF)] = { i830_getbuf, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_I830_SWAP)] = { i830_swap_bufs, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_I830_COPY)] = { i830_copybuf, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_I830_DOCOPY)] = { i830_docopy, 1, 0 },
|
||||
|
||||
#define __HAVE_COUNTERS 4
|
||||
#define __HAVE_COUNTER6 _DRM_STAT_IRQ
|
||||
#define __HAVE_COUNTER7 _DRM_STAT_PRIMARY
|
||||
#define __HAVE_COUNTER8 _DRM_STAT_SECONDARY
|
||||
#define __HAVE_COUNTER9 _DRM_STAT_DMA
|
||||
|
||||
|
||||
#include "drm_agpsupport.h"
|
||||
#include "drm_auth.h"
|
||||
#include "drm_bufs.h"
|
||||
#include "drm_context.h"
|
||||
#include "drm_dma.h"
|
||||
#include "drm_drawable.h"
|
||||
#include "drm_drv.h"
|
||||
|
||||
#ifndef MODULE
|
||||
/* DRM(options) is called by the kernel to parse command-line options
|
||||
* passed via the boot-loader (e.g., LILO). It calls the insmod option
|
||||
* routine, drm_parse_drm.
|
||||
*/
|
||||
|
||||
/* JH- We have to hand expand the string ourselves because of the cpp. If
|
||||
* anyone can think of a way that we can fit into the __setup macro without
|
||||
* changing it, then please send the solution my way.
|
||||
*/
|
||||
static int __init i830_options( char *str )
|
||||
{
|
||||
DRM(parse_options)( str );
|
||||
return 1;
|
||||
}
|
||||
|
||||
__setup( DRIVER_NAME "=", i830_options );
|
||||
#endif
|
||||
|
||||
#include "drm_fops.h"
|
||||
#include "drm_init.h"
|
||||
#include "drm_ioctl.h"
|
||||
#include "drm_lock.h"
|
||||
#include "drm_lists.h"
|
||||
#include "drm_memory.h"
|
||||
#include "drm_proc.h"
|
||||
#include "drm_vm.h"
|
||||
#include "drm_stub.h"
|
|
@ -1,821 +0,0 @@
|
|||
/* mga_dma.c -- DMA support for mga g200/g400 -*- linux-c -*-
|
||||
* Created: Mon Dec 13 01:50:01 1999 by jhartmann@precisioninsight.com
|
||||
*
|
||||
* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
|
||||
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a
|
||||
* copy of this software and associated documentation files (the "Software"),
|
||||
* to deal in the Software without restriction, including without limitation
|
||||
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
* and/or sell copies of the Software, and to permit persons to whom the
|
||||
* Software is furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice (including the next
|
||||
* paragraph) shall be included in all copies or substantial portions of the
|
||||
* Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
* PRECISION INSIGHT 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.
|
||||
*
|
||||
* Authors:
|
||||
* Rickard E. (Rik) Faith <faith@valinux.com>
|
||||
* Jeff Hartmann <jhartmann@valinux.com>
|
||||
* Keith Whitwell <keithw@valinux.com>
|
||||
*
|
||||
* Rewritten by:
|
||||
* Gareth Hughes <gareth@valinux.com>
|
||||
*/
|
||||
|
||||
#define __NO_VERSION__
|
||||
#include "mga.h"
|
||||
#include "drmP.h"
|
||||
#include "drm.h"
|
||||
#include "mga_drm.h"
|
||||
#include "mga_drv.h"
|
||||
|
||||
|
||||
#define MGA_DEFAULT_USEC_TIMEOUT 10000
|
||||
#define MGA_FREELIST_DEBUG 0
|
||||
|
||||
|
||||
/* ================================================================
|
||||
* Engine control
|
||||
*/
|
||||
|
||||
int mga_do_wait_for_idle( drm_mga_private_t *dev_priv )
|
||||
{
|
||||
u32 status = 0;
|
||||
int i;
|
||||
DRM_DEBUG( "%s\n", __FUNCTION__ );
|
||||
|
||||
for ( i = 0 ; i < dev_priv->usec_timeout ; i++ ) {
|
||||
status = MGA_READ( MGA_STATUS ) & MGA_ENGINE_IDLE_MASK;
|
||||
if ( status == MGA_ENDPRDMASTS ) {
|
||||
MGA_WRITE8( MGA_CRTC_INDEX, 0 );
|
||||
return 0;
|
||||
}
|
||||
DRM_OS_DELAY( 1 );
|
||||
}
|
||||
|
||||
#if MGA_DMA_DEBUG
|
||||
DRM_ERROR( "failed!\n" );
|
||||
DRM_INFO( " status=0x%08x\n", status );
|
||||
#endif
|
||||
DRM_OS_RETURN(EBUSY);
|
||||
}
|
||||
|
||||
int mga_do_dma_idle( drm_mga_private_t *dev_priv )
|
||||
{
|
||||
u32 status = 0;
|
||||
int i;
|
||||
DRM_DEBUG( "%s\n", __FUNCTION__ );
|
||||
|
||||
for ( i = 0 ; i < dev_priv->usec_timeout ; i++ ) {
|
||||
status = MGA_READ( MGA_STATUS ) & MGA_DMA_IDLE_MASK;
|
||||
if ( status == MGA_ENDPRDMASTS ) return 0;
|
||||
DRM_OS_DELAY( 1 );
|
||||
}
|
||||
|
||||
#if MGA_DMA_DEBUG
|
||||
DRM_ERROR( "failed! status=0x%08x\n", status );
|
||||
#endif
|
||||
DRM_OS_RETURN(EBUSY);
|
||||
}
|
||||
|
||||
int mga_do_dma_reset( drm_mga_private_t *dev_priv )
|
||||
{
|
||||
drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
|
||||
drm_mga_primary_buffer_t *primary = &dev_priv->prim;
|
||||
|
||||
DRM_DEBUG( "%s\n", __FUNCTION__ );
|
||||
|
||||
/* The primary DMA stream should look like new right about now.
|
||||
*/
|
||||
primary->tail = 0;
|
||||
primary->space = primary->size;
|
||||
primary->last_flush = 0;
|
||||
|
||||
sarea_priv->last_wrap = 0;
|
||||
|
||||
/* FIXME: Reset counters, buffer ages etc...
|
||||
*/
|
||||
|
||||
/* FIXME: What else do we need to reinitialize? WARP stuff?
|
||||
*/
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mga_do_engine_reset( drm_mga_private_t *dev_priv )
|
||||
{
|
||||
DRM_DEBUG( "%s\n", __FUNCTION__ );
|
||||
|
||||
/* Okay, so we've completely screwed up and locked the engine.
|
||||
* How about we clean up after ourselves?
|
||||
*/
|
||||
MGA_WRITE( MGA_RST, MGA_SOFTRESET );
|
||||
DRM_OS_DELAY( 15 ); /* Wait at least 10 usecs */
|
||||
MGA_WRITE( MGA_RST, 0 );
|
||||
|
||||
/* Initialize the registers that get clobbered by the soft
|
||||
* reset. Many of the core register values survive a reset,
|
||||
* but the drawing registers are basically all gone.
|
||||
*
|
||||
* 3D clients should probably die after calling this. The X
|
||||
* server should reset the engine state to known values.
|
||||
*/
|
||||
#if 0
|
||||
MGA_WRITE( MGA_PRIMPTR,
|
||||
virt_to_bus((void *)dev_priv->prim.status_page) |
|
||||
MGA_PRIMPTREN0 |
|
||||
MGA_PRIMPTREN1 );
|
||||
#endif
|
||||
|
||||
MGA_WRITE( MGA_ICLEAR, MGA_SOFTRAPICLR );
|
||||
MGA_WRITE( MGA_IEN, MGA_SOFTRAPIEN );
|
||||
|
||||
/* The primary DMA stream should look like new right about now.
|
||||
*/
|
||||
mga_do_dma_reset( dev_priv );
|
||||
|
||||
/* This bad boy will never fail.
|
||||
*/
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/* ================================================================
|
||||
* Primary DMA stream
|
||||
*/
|
||||
|
||||
void mga_do_dma_flush( drm_mga_private_t *dev_priv )
|
||||
{
|
||||
drm_mga_primary_buffer_t *primary = &dev_priv->prim;
|
||||
u32 head, tail;
|
||||
DMA_LOCALS;
|
||||
DRM_DEBUG( "%s:\n", __FUNCTION__ );
|
||||
|
||||
if ( primary->tail == primary->last_flush ) {
|
||||
DRM_DEBUG( " bailing out...\n" );
|
||||
return;
|
||||
}
|
||||
|
||||
tail = primary->tail + dev_priv->primary->offset;
|
||||
|
||||
/* We need to pad the stream between flushes, as the card
|
||||
* actually (partially?) reads the first of these commands.
|
||||
* See page 4-16 in the G400 manual, middle of the page or so.
|
||||
*/
|
||||
BEGIN_DMA( 1 );
|
||||
|
||||
DMA_BLOCK( MGA_DMAPAD, 0x00000000,
|
||||
MGA_DMAPAD, 0x00000000,
|
||||
MGA_DMAPAD, 0x00000000,
|
||||
MGA_DMAPAD, 0x00000000 );
|
||||
|
||||
ADVANCE_DMA();
|
||||
|
||||
primary->last_flush = primary->tail;
|
||||
|
||||
head = MGA_READ( MGA_PRIMADDRESS );
|
||||
|
||||
if ( head <= tail ) {
|
||||
primary->space = primary->size - primary->tail;
|
||||
} else {
|
||||
primary->space = head - tail;
|
||||
}
|
||||
|
||||
DRM_DEBUG( " head = 0x%06lx\n", head - dev_priv->primary->offset );
|
||||
DRM_DEBUG( " tail = 0x%06lx\n", tail - dev_priv->primary->offset );
|
||||
DRM_DEBUG( " space = 0x%06x\n", primary->space );
|
||||
|
||||
mga_flush_write_combine();
|
||||
MGA_WRITE( MGA_PRIMEND, tail | MGA_PAGPXFER );
|
||||
|
||||
DRM_DEBUG( "%s: done.\n", __FUNCTION__ );
|
||||
}
|
||||
|
||||
void mga_do_dma_wrap_start( drm_mga_private_t *dev_priv )
|
||||
{
|
||||
drm_mga_primary_buffer_t *primary = &dev_priv->prim;
|
||||
u32 head, tail;
|
||||
DMA_LOCALS;
|
||||
DRM_DEBUG( "%s:\n", __FUNCTION__ );
|
||||
|
||||
BEGIN_DMA_WRAP();
|
||||
|
||||
DMA_BLOCK( MGA_DMAPAD, 0x00000000,
|
||||
MGA_DMAPAD, 0x00000000,
|
||||
MGA_DMAPAD, 0x00000000,
|
||||
MGA_DMAPAD, 0x00000000 );
|
||||
|
||||
ADVANCE_DMA();
|
||||
|
||||
tail = primary->tail + dev_priv->primary->offset;
|
||||
|
||||
primary->tail = 0;
|
||||
primary->last_flush = 0;
|
||||
primary->last_wrap++;
|
||||
|
||||
head = MGA_READ( MGA_PRIMADDRESS );
|
||||
|
||||
if ( head == dev_priv->primary->offset ) {
|
||||
primary->space = primary->size;
|
||||
} else {
|
||||
primary->space = head - dev_priv->primary->offset;
|
||||
}
|
||||
|
||||
DRM_DEBUG( " head = 0x%06lx\n",
|
||||
head - dev_priv->primary->offset );
|
||||
DRM_DEBUG( " tail = 0x%06x\n", primary->tail );
|
||||
DRM_DEBUG( " wrap = %d\n", primary->last_wrap );
|
||||
DRM_DEBUG( " space = 0x%06x\n", primary->space );
|
||||
|
||||
mga_flush_write_combine();
|
||||
MGA_WRITE( MGA_PRIMEND, tail | MGA_PAGPXFER );
|
||||
|
||||
set_bit( 0, &primary->wrapped );
|
||||
DRM_DEBUG( "%s: done.\n", __FUNCTION__ );
|
||||
}
|
||||
|
||||
void mga_do_dma_wrap_end( drm_mga_private_t *dev_priv )
|
||||
{
|
||||
drm_mga_primary_buffer_t *primary = &dev_priv->prim;
|
||||
drm_mga_sarea_t *sarea_priv = dev_priv->sarea_priv;
|
||||
u32 head = dev_priv->primary->offset;
|
||||
DRM_DEBUG( "%s:\n", __FUNCTION__ );
|
||||
|
||||
sarea_priv->last_wrap++;
|
||||
DRM_DEBUG( " wrap = %d\n", sarea_priv->last_wrap );
|
||||
|
||||
mga_flush_write_combine();
|
||||
MGA_WRITE( MGA_PRIMADDRESS, head | MGA_DMA_GENERAL );
|
||||
|
||||
clear_bit( 0, &primary->wrapped );
|
||||
DRM_DEBUG( "%s: done.\n", __FUNCTION__ );
|
||||
}
|
||||
|
||||
|
||||
/* ================================================================
|
||||
* Freelist management
|
||||
*/
|
||||
|
||||
#define MGA_BUFFER_USED ~0
|
||||
#define MGA_BUFFER_FREE 0
|
||||
|
||||
#if MGA_FREELIST_DEBUG
|
||||
static void mga_freelist_print( drm_device_t *dev )
|
||||
{
|
||||
drm_mga_private_t *dev_priv = dev->dev_private;
|
||||
drm_mga_freelist_t *entry;
|
||||
|
||||
DRM_INFO( "\n" );
|
||||
DRM_INFO( "current dispatch: last=0x%x done=0x%x\n",
|
||||
dev_priv->sarea_priv->last_dispatch,
|
||||
(unsigned int)(MGA_READ( MGA_PRIMADDRESS ) -
|
||||
dev_priv->primary->offset) );
|
||||
DRM_INFO( "current freelist:\n" );
|
||||
|
||||
for ( entry = dev_priv->head->next ; entry ; entry = entry->next ) {
|
||||
DRM_INFO( " %p idx=%2d age=0x%x 0x%06lx\n",
|
||||
entry, entry->buf->idx, entry->age.head,
|
||||
entry->age.head - dev_priv->primary->offset );
|
||||
}
|
||||
DRM_INFO( "\n" );
|
||||
}
|
||||
#endif
|
||||
|
||||
static int mga_freelist_init( drm_device_t *dev, drm_mga_private_t *dev_priv )
|
||||
{
|
||||
drm_device_dma_t *dma = dev->dma;
|
||||
drm_buf_t *buf;
|
||||
drm_mga_buf_priv_t *buf_priv;
|
||||
drm_mga_freelist_t *entry;
|
||||
int i;
|
||||
DRM_DEBUG( "%s: count=%d\n",
|
||||
__FUNCTION__, dma->buf_count );
|
||||
|
||||
dev_priv->head = DRM(alloc)( sizeof(drm_mga_freelist_t),
|
||||
DRM_MEM_DRIVER );
|
||||
if ( dev_priv->head == NULL )
|
||||
DRM_OS_RETURN(ENOMEM);
|
||||
|
||||
memset( dev_priv->head, 0, sizeof(drm_mga_freelist_t) );
|
||||
SET_AGE( &dev_priv->head->age, MGA_BUFFER_USED, 0 );
|
||||
|
||||
for ( i = 0 ; i < dma->buf_count ; i++ ) {
|
||||
buf = dma->buflist[i];
|
||||
buf_priv = buf->dev_private;
|
||||
|
||||
entry = DRM(alloc)( sizeof(drm_mga_freelist_t),
|
||||
DRM_MEM_DRIVER );
|
||||
if ( entry == NULL )
|
||||
DRM_OS_RETURN(ENOMEM);
|
||||
|
||||
memset( entry, 0, sizeof(drm_mga_freelist_t) );
|
||||
|
||||
entry->next = dev_priv->head->next;
|
||||
entry->prev = dev_priv->head;
|
||||
SET_AGE( &entry->age, MGA_BUFFER_FREE, 0 );
|
||||
entry->buf = buf;
|
||||
|
||||
if ( dev_priv->head->next != NULL )
|
||||
dev_priv->head->next->prev = entry;
|
||||
if ( entry->next == NULL )
|
||||
dev_priv->tail = entry;
|
||||
|
||||
buf_priv->list_entry = entry;
|
||||
buf_priv->discard = 0;
|
||||
buf_priv->dispatched = 0;
|
||||
|
||||
dev_priv->head->next = entry;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void mga_freelist_cleanup( drm_device_t *dev )
|
||||
{
|
||||
drm_mga_private_t *dev_priv = dev->dev_private;
|
||||
drm_mga_freelist_t *entry;
|
||||
drm_mga_freelist_t *next;
|
||||
DRM_DEBUG( "%s\n", __FUNCTION__ );
|
||||
|
||||
entry = dev_priv->head;
|
||||
while ( entry ) {
|
||||
next = entry->next;
|
||||
DRM(free)( entry, sizeof(drm_mga_freelist_t), DRM_MEM_DRIVER );
|
||||
entry = next;
|
||||
}
|
||||
|
||||
dev_priv->head = dev_priv->tail = NULL;
|
||||
}
|
||||
|
||||
#if 0
|
||||
/* FIXME: Still needed?
|
||||
*/
|
||||
static void mga_freelist_reset( drm_device_t *dev )
|
||||
{
|
||||
drm_device_dma_t *dma = dev->dma;
|
||||
drm_buf_t *buf;
|
||||
drm_mga_buf_priv_t *buf_priv;
|
||||
int i;
|
||||
|
||||
for ( i = 0 ; i < dma->buf_count ; i++ ) {
|
||||
buf = dma->buflist[i];
|
||||
buf_priv = buf->dev_private;
|
||||
SET_AGE( &buf_priv->list_entry->age,
|
||||
MGA_BUFFER_FREE, 0 );
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
static drm_buf_t *mga_freelist_get( drm_device_t *dev )
|
||||
{
|
||||
drm_mga_private_t *dev_priv = dev->dev_private;
|
||||
drm_mga_freelist_t *next;
|
||||
drm_mga_freelist_t *prev;
|
||||
drm_mga_freelist_t *tail = dev_priv->tail;
|
||||
u32 head, wrap;
|
||||
DRM_DEBUG( "%s:\n", __FUNCTION__ );
|
||||
|
||||
head = MGA_READ( MGA_PRIMADDRESS );
|
||||
wrap = dev_priv->sarea_priv->last_wrap;
|
||||
|
||||
DRM_DEBUG( " tail=0x%06lx %d\n",
|
||||
tail->age.head ?
|
||||
tail->age.head - dev_priv->primary->offset : 0,
|
||||
tail->age.wrap );
|
||||
DRM_DEBUG( " head=0x%06lx %d\n",
|
||||
head - dev_priv->primary->offset, wrap );
|
||||
|
||||
if ( TEST_AGE( &tail->age, head, wrap ) ) {
|
||||
prev = dev_priv->tail->prev;
|
||||
next = dev_priv->tail;
|
||||
prev->next = NULL;
|
||||
next->prev = next->next = NULL;
|
||||
dev_priv->tail = prev;
|
||||
SET_AGE( &next->age, MGA_BUFFER_USED, 0 );
|
||||
return next->buf;
|
||||
}
|
||||
|
||||
DRM_DEBUG( "returning NULL!\n" );
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int mga_freelist_put( drm_device_t *dev, drm_buf_t *buf )
|
||||
{
|
||||
drm_mga_private_t *dev_priv = dev->dev_private;
|
||||
drm_mga_buf_priv_t *buf_priv = buf->dev_private;
|
||||
drm_mga_freelist_t *head, *entry, *prev;
|
||||
|
||||
DRM_DEBUG( "%s: age=0x%06lx wrap=%d\n",
|
||||
__FUNCTION__,
|
||||
buf_priv->list_entry->age.head -
|
||||
dev_priv->primary->offset,
|
||||
buf_priv->list_entry->age.wrap );
|
||||
|
||||
entry = buf_priv->list_entry;
|
||||
head = dev_priv->head;
|
||||
|
||||
if ( buf_priv->list_entry->age.head == MGA_BUFFER_USED ) {
|
||||
SET_AGE( &entry->age, MGA_BUFFER_FREE, 0 );
|
||||
prev = dev_priv->tail;
|
||||
prev->next = entry;
|
||||
entry->prev = prev;
|
||||
entry->next = NULL;
|
||||
} else {
|
||||
prev = head->next;
|
||||
head->next = entry;
|
||||
prev->prev = entry;
|
||||
entry->prev = head;
|
||||
entry->next = prev;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/* ================================================================
|
||||
* DMA initialization, cleanup
|
||||
*/
|
||||
|
||||
static int mga_do_init_dma( drm_device_t *dev, drm_mga_init_t *init )
|
||||
{
|
||||
drm_mga_private_t *dev_priv;
|
||||
drm_map_list_entry_t *listentry;
|
||||
int ret;
|
||||
DRM_DEBUG( "%s\n", __FUNCTION__ );
|
||||
|
||||
dev_priv = DRM(alloc)( sizeof(drm_mga_private_t), DRM_MEM_DRIVER );
|
||||
if ( !dev_priv )
|
||||
DRM_OS_RETURN(ENOMEM);
|
||||
|
||||
memset( dev_priv, 0, sizeof(drm_mga_private_t) );
|
||||
|
||||
dev_priv->chipset = init->chipset;
|
||||
|
||||
dev_priv->usec_timeout = MGA_DEFAULT_USEC_TIMEOUT;
|
||||
|
||||
if ( init->sgram ) {
|
||||
dev_priv->clear_cmd = MGA_DWGCTL_CLEAR | MGA_ATYPE_BLK;
|
||||
} else {
|
||||
dev_priv->clear_cmd = MGA_DWGCTL_CLEAR | MGA_ATYPE_RSTR;
|
||||
}
|
||||
dev_priv->maccess = init->maccess;
|
||||
|
||||
dev_priv->fb_cpp = init->fb_cpp;
|
||||
dev_priv->front_offset = init->front_offset;
|
||||
dev_priv->front_pitch = init->front_pitch;
|
||||
dev_priv->back_offset = init->back_offset;
|
||||
dev_priv->back_pitch = init->back_pitch;
|
||||
|
||||
dev_priv->depth_cpp = init->depth_cpp;
|
||||
dev_priv->depth_offset = init->depth_offset;
|
||||
dev_priv->depth_pitch = init->depth_pitch;
|
||||
|
||||
/* FIXME: Need to support AGP textures...
|
||||
*/
|
||||
dev_priv->texture_offset = init->texture_offset[0];
|
||||
dev_priv->texture_size = init->texture_size[0];
|
||||
|
||||
TAILQ_FOREACH(listentry, dev->maplist, link) {
|
||||
drm_map_t *map = listentry->map;
|
||||
if (map->type == _DRM_SHM &&
|
||||
map->flags & _DRM_CONTAINS_LOCK) {
|
||||
dev_priv->sarea = map;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if(!dev_priv->sarea) {
|
||||
DRM_ERROR( "failed to find sarea!\n" );
|
||||
/* Assign dev_private so we can do cleanup. */
|
||||
dev->dev_private = (void *)dev_priv;
|
||||
mga_do_cleanup_dma( dev );
|
||||
DRM_OS_RETURN(EINVAL);
|
||||
}
|
||||
|
||||
|
||||
DRM_FIND_MAP( dev_priv->fb, init->fb_offset );
|
||||
if(!dev_priv->fb) {
|
||||
DRM_ERROR( "failed to find framebuffer!\n" );
|
||||
/* Assign dev_private so we can do cleanup. */
|
||||
dev->dev_private = (void *)dev_priv;
|
||||
mga_do_cleanup_dma( dev );
|
||||
DRM_OS_RETURN(EINVAL);
|
||||
}
|
||||
DRM_FIND_MAP( dev_priv->mmio, init->mmio_offset );
|
||||
if(!dev_priv->mmio) {
|
||||
DRM_ERROR( "failed to find mmio region!\n" );
|
||||
/* Assign dev_private so we can do cleanup. */
|
||||
dev->dev_private = (void *)dev_priv;
|
||||
mga_do_cleanup_dma( dev );
|
||||
DRM_OS_RETURN(EINVAL);
|
||||
}
|
||||
DRM_FIND_MAP( dev_priv->status, init->status_offset );
|
||||
if(!dev_priv->status) {
|
||||
DRM_ERROR( "failed to find status page!\n" );
|
||||
/* Assign dev_private so we can do cleanup. */
|
||||
dev->dev_private = (void *)dev_priv;
|
||||
mga_do_cleanup_dma( dev );
|
||||
DRM_OS_RETURN(EINVAL);
|
||||
}
|
||||
DRM_FIND_MAP( dev_priv->warp, init->warp_offset );
|
||||
if(!dev_priv->warp) {
|
||||
DRM_ERROR( "failed to find warp microcode region!\n" );
|
||||
/* Assign dev_private so we can do cleanup. */
|
||||
dev->dev_private = (void *)dev_priv;
|
||||
mga_do_cleanup_dma( dev );
|
||||
DRM_OS_RETURN(EINVAL);
|
||||
}
|
||||
DRM_FIND_MAP( dev_priv->primary, init->primary_offset );
|
||||
if(!dev_priv->primary) {
|
||||
DRM_ERROR( "failed to find primary dma region!\n" );
|
||||
/* Assign dev_private so we can do cleanup. */
|
||||
dev->dev_private = (void *)dev_priv;
|
||||
mga_do_cleanup_dma( dev );
|
||||
DRM_OS_RETURN(EINVAL);
|
||||
}
|
||||
DRM_FIND_MAP( dev_priv->buffers, init->buffers_offset );
|
||||
if(!dev_priv->buffers) {
|
||||
DRM_ERROR( "failed to find dma buffer region!\n" );
|
||||
/* Assign dev_private so we can do cleanup. */
|
||||
dev->dev_private = (void *)dev_priv;
|
||||
mga_do_cleanup_dma( dev );
|
||||
DRM_OS_RETURN(EINVAL);
|
||||
}
|
||||
|
||||
dev_priv->sarea_priv =
|
||||
(drm_mga_sarea_t *)((u8 *)dev_priv->sarea->handle +
|
||||
init->sarea_priv_offset);
|
||||
|
||||
DRM_IOREMAP( dev_priv->warp );
|
||||
DRM_IOREMAP( dev_priv->primary );
|
||||
DRM_IOREMAP( dev_priv->buffers );
|
||||
|
||||
if(!dev_priv->warp->handle ||
|
||||
!dev_priv->primary->handle ||
|
||||
!dev_priv->buffers->handle ) {
|
||||
DRM_ERROR( "failed to ioremap agp regions!\n" );
|
||||
/* Assign dev_private so we can do cleanup. */
|
||||
dev->dev_private = (void *)dev_priv;
|
||||
mga_do_cleanup_dma( dev );
|
||||
DRM_OS_RETURN(ENOMEM);
|
||||
}
|
||||
|
||||
ret = mga_warp_install_microcode( dev_priv );
|
||||
if ( ret < 0 ) {
|
||||
DRM_ERROR( "failed to install WARP ucode!\n" );
|
||||
/* Assign dev_private so we can do cleanup. */
|
||||
dev->dev_private = (void *)dev_priv;
|
||||
mga_do_cleanup_dma( dev );
|
||||
DRM_OS_RETURN(ret);
|
||||
}
|
||||
|
||||
ret = mga_warp_init( dev_priv );
|
||||
if ( ret < 0 ) {
|
||||
DRM_ERROR( "failed to init WARP engine!\n" );
|
||||
/* Assign dev_private so we can do cleanup. */
|
||||
dev->dev_private = (void *)dev_priv;
|
||||
mga_do_cleanup_dma( dev );
|
||||
DRM_OS_RETURN(ret);
|
||||
}
|
||||
|
||||
dev_priv->prim.status = (u32 *)dev_priv->status->handle;
|
||||
|
||||
mga_do_wait_for_idle( dev_priv );
|
||||
|
||||
/* Init the primary DMA registers.
|
||||
*/
|
||||
MGA_WRITE( MGA_PRIMADDRESS,
|
||||
dev_priv->primary->offset | MGA_DMA_GENERAL );
|
||||
#if 0
|
||||
MGA_WRITE( MGA_PRIMPTR,
|
||||
virt_to_bus((void *)dev_priv->prim.status) |
|
||||
MGA_PRIMPTREN0 | /* Soft trap, SECEND, SETUPEND */
|
||||
MGA_PRIMPTREN1 ); /* DWGSYNC */
|
||||
#endif
|
||||
|
||||
dev_priv->prim.start = (u8 *)dev_priv->primary->handle;
|
||||
dev_priv->prim.end = ((u8 *)dev_priv->primary->handle
|
||||
+ dev_priv->primary->size);
|
||||
dev_priv->prim.size = dev_priv->primary->size;
|
||||
|
||||
dev_priv->prim.tail = 0;
|
||||
dev_priv->prim.space = dev_priv->prim.size;
|
||||
dev_priv->prim.wrapped = 0;
|
||||
|
||||
dev_priv->prim.last_flush = 0;
|
||||
dev_priv->prim.last_wrap = 0;
|
||||
|
||||
dev_priv->prim.high_mark = 256 * DMA_BLOCK_SIZE;
|
||||
|
||||
|
||||
dev_priv->prim.status[0] = dev_priv->primary->offset;
|
||||
dev_priv->prim.status[1] = 0;
|
||||
|
||||
dev_priv->sarea_priv->last_wrap = 0;
|
||||
dev_priv->sarea_priv->last_frame.head = 0;
|
||||
dev_priv->sarea_priv->last_frame.wrap = 0;
|
||||
|
||||
if ( mga_freelist_init( dev, dev_priv ) < 0 ) {
|
||||
DRM_ERROR( "could not initialize freelist\n" );
|
||||
/* Assign dev_private so we can do cleanup. */
|
||||
dev->dev_private = (void *)dev_priv;
|
||||
mga_do_cleanup_dma( dev );
|
||||
DRM_OS_RETURN(ENOMEM);
|
||||
}
|
||||
|
||||
/* Make dev_private visable to others. */
|
||||
dev->dev_private = (void *)dev_priv;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mga_do_cleanup_dma( drm_device_t *dev )
|
||||
{
|
||||
DRM_DEBUG( "%s\n", __FUNCTION__ );
|
||||
|
||||
if ( dev->dev_private ) {
|
||||
drm_mga_private_t *dev_priv = dev->dev_private;
|
||||
|
||||
DRM_IOREMAPFREE( dev_priv->warp );
|
||||
DRM_IOREMAPFREE( dev_priv->primary );
|
||||
DRM_IOREMAPFREE( dev_priv->buffers );
|
||||
|
||||
if ( dev_priv->head != NULL ) {
|
||||
mga_freelist_cleanup( dev );
|
||||
}
|
||||
|
||||
DRM(free)( dev->dev_private, sizeof(drm_mga_private_t),
|
||||
DRM_MEM_DRIVER );
|
||||
dev->dev_private = NULL;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mga_dma_init( DRM_OS_IOCTL )
|
||||
{
|
||||
DRM_OS_DEVICE;
|
||||
drm_mga_init_t init;
|
||||
|
||||
DRM_OS_KRNFROMUSR( init, (drm_mga_init_t *) data, sizeof(init) );
|
||||
|
||||
switch ( init.func ) {
|
||||
case MGA_INIT_DMA:
|
||||
return mga_do_init_dma( dev, &init );
|
||||
case MGA_CLEANUP_DMA:
|
||||
return mga_do_cleanup_dma( dev );
|
||||
}
|
||||
|
||||
DRM_OS_RETURN( EINVAL );
|
||||
}
|
||||
|
||||
|
||||
/* ================================================================
|
||||
* Primary DMA stream management
|
||||
*/
|
||||
|
||||
int mga_dma_flush( DRM_OS_IOCTL )
|
||||
{
|
||||
DRM_OS_DEVICE;
|
||||
drm_mga_private_t *dev_priv = (drm_mga_private_t *)dev->dev_private;
|
||||
drm_lock_t lock;
|
||||
|
||||
LOCK_TEST_WITH_RETURN( dev );
|
||||
|
||||
DRM_OS_KRNFROMUSR( lock, (drm_lock_t *) data, sizeof(lock) );
|
||||
|
||||
DRM_DEBUG( "%s: %s%s%s\n",
|
||||
__FUNCTION__,
|
||||
(lock.flags & _DRM_LOCK_FLUSH) ? "flush, " : "",
|
||||
(lock.flags & _DRM_LOCK_FLUSH_ALL) ? "flush all, " : "",
|
||||
(lock.flags & _DRM_LOCK_QUIESCENT) ? "idle, " : "" );
|
||||
|
||||
WRAP_WAIT_WITH_RETURN( dev_priv );
|
||||
|
||||
if ( lock.flags & (_DRM_LOCK_FLUSH | _DRM_LOCK_FLUSH_ALL) ) {
|
||||
mga_do_dma_flush( dev_priv );
|
||||
}
|
||||
|
||||
if ( lock.flags & _DRM_LOCK_QUIESCENT ) {
|
||||
#if MGA_DMA_DEBUG
|
||||
int ret = mga_do_wait_for_idle( dev_priv );
|
||||
if ( ret )
|
||||
DRM_INFO( __FUNCTION__": -EBUSY\n" );
|
||||
return ret;
|
||||
#else
|
||||
return mga_do_wait_for_idle( dev_priv );
|
||||
#endif
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
int mga_dma_reset( DRM_OS_IOCTL )
|
||||
{
|
||||
DRM_OS_DEVICE;
|
||||
drm_mga_private_t *dev_priv = (drm_mga_private_t *)dev->dev_private;
|
||||
|
||||
LOCK_TEST_WITH_RETURN( dev );
|
||||
|
||||
return mga_do_dma_reset( dev_priv );
|
||||
}
|
||||
|
||||
|
||||
/* ================================================================
|
||||
* DMA buffer management
|
||||
*/
|
||||
|
||||
#if 0
|
||||
static int mga_dma_get_buffers( drm_device_t *dev, drm_dma_t *d )
|
||||
{
|
||||
drm_buf_t *buf;
|
||||
int i;
|
||||
|
||||
for ( i = d->granted_count ; i < d->request_count ; i++ ) {
|
||||
buf = mga_freelist_get( dev );
|
||||
if ( !buf )
|
||||
DRM_OS_RETURN( EAGAIN );
|
||||
|
||||
buf->pid = current->pid;
|
||||
|
||||
if ( DRM_OS_COPYTOUSR( &d->request_indices[i],
|
||||
&buf->idx, sizeof(buf->idx) ) )
|
||||
DRM_OS_RETURN( EFAULT );
|
||||
if ( DRM_OS_COPYTOUSR( &d->request_sizes[i],
|
||||
&buf->total, sizeof(buf->total) ) )
|
||||
DRM_OS_RETURN( EFAULT );
|
||||
|
||||
d->granted_count++;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
#endif /* 0 */
|
||||
|
||||
int mga_dma_buffers( DRM_OS_IOCTL )
|
||||
{
|
||||
DRM_OS_DEVICE;
|
||||
drm_device_dma_t *dma = dev->dma;
|
||||
drm_mga_private_t *dev_priv = (drm_mga_private_t *)dev->dev_private;
|
||||
drm_dma_t d;
|
||||
drm_buf_t *buf;
|
||||
int i;
|
||||
int ret = 0;
|
||||
|
||||
LOCK_TEST_WITH_RETURN( dev );
|
||||
|
||||
DRM_OS_KRNFROMUSR( d, (drm_dma_t *) data, sizeof(d) );
|
||||
|
||||
/* Please don't send us buffers.
|
||||
*/
|
||||
if ( d.send_count != 0 ) {
|
||||
DRM_ERROR( "Process %d trying to send %d buffers via drmDMA\n",
|
||||
DRM_OS_CURRENTPID, d.send_count );
|
||||
DRM_OS_RETURN( EINVAL );
|
||||
}
|
||||
|
||||
/* We'll send you buffers.
|
||||
*/
|
||||
if ( d.request_count < 0 || d.request_count > dma->buf_count ) {
|
||||
DRM_ERROR( "Process %d trying to get %d buffers (of %d max)\n",
|
||||
DRM_OS_CURRENTPID, d.request_count, dma->buf_count );
|
||||
DRM_OS_RETURN( EINVAL );
|
||||
}
|
||||
|
||||
WRAP_TEST_WITH_RETURN( dev_priv );
|
||||
|
||||
d.granted_count = 0;
|
||||
|
||||
if ( d.request_count ) {
|
||||
for ( i = d.granted_count ; i < d.request_count ; i++ ) {
|
||||
buf = mga_freelist_get( dev );
|
||||
if ( !buf )
|
||||
DRM_OS_RETURN( EAGAIN );
|
||||
|
||||
buf->pid = DRM_OS_CURRENTPID;
|
||||
|
||||
if ( DRM_OS_COPYTOUSR( &d.request_indices[i],
|
||||
&buf->idx, sizeof(buf->idx) ) )
|
||||
DRM_OS_RETURN( EFAULT );
|
||||
if ( DRM_OS_COPYTOUSR( &d.request_sizes[i],
|
||||
&buf->total, sizeof(buf->total) ) )
|
||||
DRM_OS_RETURN( EFAULT );
|
||||
|
||||
d.granted_count++;
|
||||
}
|
||||
ret = 0;
|
||||
}
|
||||
|
||||
DRM_OS_KRNTOUSR( (drm_dma_t *) data, d, sizeof(d) );
|
||||
|
||||
return ret;
|
||||
}
|
|
@ -1,100 +0,0 @@
|
|||
/* mga_drv.c -- Matrox G200/G400 driver -*- linux-c -*-
|
||||
* Created: Mon Dec 13 01:56:22 1999 by jhartmann@precisioninsight.com
|
||||
*
|
||||
* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
|
||||
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a
|
||||
* copy of this software and associated documentation files (the "Software"),
|
||||
* to deal in the Software without restriction, including without limitation
|
||||
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
* and/or sell copies of the Software, and to permit persons to whom the
|
||||
* Software is furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice (including the next
|
||||
* paragraph) shall be included in all copies or substantial portions of the
|
||||
* Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
* VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||||
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
* OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* Authors:
|
||||
* Rickard E. (Rik) Faith <faith@valinux.com>
|
||||
* Gareth Hughes <gareth@valinux.com>
|
||||
*/
|
||||
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <sys/bus.h>
|
||||
#include <pci/pcivar.h>
|
||||
#include <opt_drm_linux.h>
|
||||
|
||||
#include "mga.h"
|
||||
#include "drmP.h"
|
||||
#include "drm.h"
|
||||
#include "mga_drm.h"
|
||||
#include "mga_drv.h"
|
||||
|
||||
#define DRIVER_AUTHOR "Gareth Hughes, VA Linux Systems Inc."
|
||||
|
||||
#define DRIVER_NAME "mga"
|
||||
#define DRIVER_DESC "Matrox G200/G400"
|
||||
#define DRIVER_DATE "20010321"
|
||||
|
||||
#define DRIVER_MAJOR 3
|
||||
#define DRIVER_MINOR 0
|
||||
#define DRIVER_PATCHLEVEL 2
|
||||
|
||||
/* List acquired from http://www.yourvote.com/pci/pcihdr.h and xc/xc/programs/Xserver/hw/xfree86/common/xf86PciInfo.h
|
||||
* Please report to anholt@teleport.com inaccuracies or if a chip you have works that is marked unsupported here.
|
||||
*/
|
||||
drm_chipinfo_t DRM(devicelist)[] = {
|
||||
{0x102b, 0x0520, 0, "Matrox G200 (PCI)"},
|
||||
{0x102b, 0x0521, 1, "Matrox G200 (AGP)"},
|
||||
{0x102b, 0x0525, 1, "Matrox G400 (AGP)"},
|
||||
{0, 0, 0, NULL}
|
||||
};
|
||||
|
||||
#define DRIVER_IOCTLS \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_DMA)] = { mga_dma_buffers, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_MGA_INIT)] = { mga_dma_init, 1, 1 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_MGA_FLUSH)] = { mga_dma_flush, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_MGA_RESET)] = { mga_dma_reset, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_MGA_SWAP)] = { mga_dma_swap, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_MGA_CLEAR)] = { mga_dma_clear, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_MGA_VERTEX)] = { mga_dma_vertex, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_MGA_INDICES)] = { mga_dma_indices, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_MGA_ILOAD)] = { mga_dma_iload, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_MGA_BLIT)] = { mga_dma_blit, 1, 0 },
|
||||
|
||||
|
||||
#define __HAVE_COUNTERS 3
|
||||
#define __HAVE_COUNTER6 _DRM_STAT_IRQ
|
||||
#define __HAVE_COUNTER7 _DRM_STAT_PRIMARY
|
||||
#define __HAVE_COUNTER8 _DRM_STAT_SECONDARY
|
||||
|
||||
|
||||
#include "drm_agpsupport.h"
|
||||
#include "drm_auth.h"
|
||||
#include "drm_bufs.h"
|
||||
#include "drm_context.h"
|
||||
#include "drm_dma.h"
|
||||
#include "drm_drawable.h"
|
||||
#include "drm_drv.h"
|
||||
|
||||
|
||||
#include "drm_fops.h"
|
||||
#include "drm_init.h"
|
||||
#include "drm_ioctl.h"
|
||||
#include "drm_lock.h"
|
||||
#include "drm_memory.h"
|
||||
#include "drm_vm.h"
|
||||
#include "drm_sysctl.h"
|
||||
|
||||
DRIVER_MODULE(mga, pci, mga_driver, mga_devclass, 0, 0);
|
1076
bsd/mga/mga_state.c
1076
bsd/mga/mga_state.c
File diff suppressed because it is too large
Load Diff
|
@ -1,212 +0,0 @@
|
|||
/* mga_warp.c -- Matrox G200/G400 WARP engine management -*- linux-c -*-
|
||||
* Created: Thu Jan 11 21:29:32 2001 by gareth@valinux.com
|
||||
*
|
||||
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a
|
||||
* copy of this software and associated documentation files (the "Software"),
|
||||
* to deal in the Software without restriction, including without limitation
|
||||
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
* and/or sell copies of the Software, and to permit persons to whom the
|
||||
* Software is furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice (including the next
|
||||
* paragraph) shall be included in all copies or substantial portions of the
|
||||
* Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
* VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||||
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
* OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* Authors:
|
||||
* Gareth Hughes <gareth@valinux.com>
|
||||
*/
|
||||
|
||||
#define __NO_VERSION__
|
||||
#include "mga.h"
|
||||
#include "drmP.h"
|
||||
#include "drm.h"
|
||||
#include "mga_drm.h"
|
||||
#include "mga_drv.h"
|
||||
#include "mga_ucode.h"
|
||||
|
||||
|
||||
#define MGA_WARP_CODE_ALIGN 256 /* in bytes */
|
||||
|
||||
#define WARP_UCODE_SIZE( which ) \
|
||||
((sizeof(which) / MGA_WARP_CODE_ALIGN + 1) * MGA_WARP_CODE_ALIGN)
|
||||
|
||||
#define WARP_UCODE_INSTALL( which, where ) \
|
||||
do { \
|
||||
DRM_DEBUG( " pcbase = 0x%08lx vcbase = %p\n", pcbase, vcbase );\
|
||||
dev_priv->warp_pipe_phys[where] = pcbase; \
|
||||
memcpy( vcbase, which, sizeof(which) ); \
|
||||
pcbase += WARP_UCODE_SIZE( which ); \
|
||||
vcbase += WARP_UCODE_SIZE( which ); \
|
||||
} while (0)
|
||||
|
||||
|
||||
static unsigned int mga_warp_g400_microcode_size( drm_mga_private_t *dev_priv )
|
||||
{
|
||||
unsigned int size;
|
||||
|
||||
size = ( WARP_UCODE_SIZE( warp_g400_tgz ) +
|
||||
WARP_UCODE_SIZE( warp_g400_tgza ) +
|
||||
WARP_UCODE_SIZE( warp_g400_tgzaf ) +
|
||||
WARP_UCODE_SIZE( warp_g400_tgzf ) +
|
||||
WARP_UCODE_SIZE( warp_g400_tgzs ) +
|
||||
WARP_UCODE_SIZE( warp_g400_tgzsa ) +
|
||||
WARP_UCODE_SIZE( warp_g400_tgzsaf ) +
|
||||
WARP_UCODE_SIZE( warp_g400_tgzsf ) +
|
||||
WARP_UCODE_SIZE( warp_g400_t2gz ) +
|
||||
WARP_UCODE_SIZE( warp_g400_t2gza ) +
|
||||
WARP_UCODE_SIZE( warp_g400_t2gzaf ) +
|
||||
WARP_UCODE_SIZE( warp_g400_t2gzf ) +
|
||||
WARP_UCODE_SIZE( warp_g400_t2gzs ) +
|
||||
WARP_UCODE_SIZE( warp_g400_t2gzsa ) +
|
||||
WARP_UCODE_SIZE( warp_g400_t2gzsaf ) +
|
||||
WARP_UCODE_SIZE( warp_g400_t2gzsf ) );
|
||||
|
||||
size = PAGE_ALIGN( size );
|
||||
|
||||
DRM_DEBUG( "G400 ucode size = %d bytes\n", size );
|
||||
return size;
|
||||
}
|
||||
|
||||
static unsigned int mga_warp_g200_microcode_size( drm_mga_private_t *dev_priv )
|
||||
{
|
||||
unsigned int size;
|
||||
|
||||
size = ( WARP_UCODE_SIZE( warp_g200_tgz ) +
|
||||
WARP_UCODE_SIZE( warp_g200_tgza ) +
|
||||
WARP_UCODE_SIZE( warp_g200_tgzaf ) +
|
||||
WARP_UCODE_SIZE( warp_g200_tgzf ) +
|
||||
WARP_UCODE_SIZE( warp_g200_tgzs ) +
|
||||
WARP_UCODE_SIZE( warp_g200_tgzsa ) +
|
||||
WARP_UCODE_SIZE( warp_g200_tgzsaf ) +
|
||||
WARP_UCODE_SIZE( warp_g200_tgzsf ) );
|
||||
|
||||
size = PAGE_ALIGN( size );
|
||||
|
||||
DRM_DEBUG( "G200 ucode size = %d bytes\n", size );
|
||||
return size;
|
||||
}
|
||||
|
||||
static int mga_warp_install_g400_microcode( drm_mga_private_t *dev_priv )
|
||||
{
|
||||
unsigned char *vcbase = dev_priv->warp->handle;
|
||||
unsigned long pcbase = dev_priv->warp->offset;
|
||||
unsigned int size;
|
||||
|
||||
size = mga_warp_g400_microcode_size( dev_priv );
|
||||
if ( size > dev_priv->warp->size ) {
|
||||
DRM_ERROR( "microcode too large! (%u > %lu)\n",
|
||||
size, dev_priv->warp->size );
|
||||
DRM_OS_RETURN(ENOMEM);
|
||||
}
|
||||
|
||||
memset( dev_priv->warp_pipe_phys, 0,
|
||||
sizeof(dev_priv->warp_pipe_phys) );
|
||||
|
||||
WARP_UCODE_INSTALL( warp_g400_tgz, MGA_WARP_TGZ );
|
||||
WARP_UCODE_INSTALL( warp_g400_tgzf, MGA_WARP_TGZF );
|
||||
WARP_UCODE_INSTALL( warp_g400_tgza, MGA_WARP_TGZA );
|
||||
WARP_UCODE_INSTALL( warp_g400_tgzaf, MGA_WARP_TGZAF );
|
||||
WARP_UCODE_INSTALL( warp_g400_tgzs, MGA_WARP_TGZS );
|
||||
WARP_UCODE_INSTALL( warp_g400_tgzsf, MGA_WARP_TGZSF );
|
||||
WARP_UCODE_INSTALL( warp_g400_tgzsa, MGA_WARP_TGZSA );
|
||||
WARP_UCODE_INSTALL( warp_g400_tgzsaf, MGA_WARP_TGZSAF );
|
||||
|
||||
WARP_UCODE_INSTALL( warp_g400_t2gz, MGA_WARP_T2GZ );
|
||||
WARP_UCODE_INSTALL( warp_g400_t2gzf, MGA_WARP_T2GZF );
|
||||
WARP_UCODE_INSTALL( warp_g400_t2gza, MGA_WARP_T2GZA );
|
||||
WARP_UCODE_INSTALL( warp_g400_t2gzaf, MGA_WARP_T2GZAF );
|
||||
WARP_UCODE_INSTALL( warp_g400_t2gzs, MGA_WARP_T2GZS );
|
||||
WARP_UCODE_INSTALL( warp_g400_t2gzsf, MGA_WARP_T2GZSF );
|
||||
WARP_UCODE_INSTALL( warp_g400_t2gzsa, MGA_WARP_T2GZSA );
|
||||
WARP_UCODE_INSTALL( warp_g400_t2gzsaf, MGA_WARP_T2GZSAF );
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int mga_warp_install_g200_microcode( drm_mga_private_t *dev_priv )
|
||||
{
|
||||
unsigned char *vcbase = dev_priv->warp->handle;
|
||||
unsigned long pcbase = dev_priv->warp->offset;
|
||||
unsigned int size;
|
||||
|
||||
size = mga_warp_g200_microcode_size( dev_priv );
|
||||
if ( size > dev_priv->warp->size ) {
|
||||
DRM_ERROR( "microcode too large! (%u > %lu)\n",
|
||||
size, dev_priv->warp->size );
|
||||
DRM_OS_RETURN(ENOMEM);
|
||||
}
|
||||
|
||||
memset( dev_priv->warp_pipe_phys, 0,
|
||||
sizeof(dev_priv->warp_pipe_phys) );
|
||||
|
||||
WARP_UCODE_INSTALL( warp_g200_tgz, MGA_WARP_TGZ );
|
||||
WARP_UCODE_INSTALL( warp_g200_tgzf, MGA_WARP_TGZF );
|
||||
WARP_UCODE_INSTALL( warp_g200_tgza, MGA_WARP_TGZA );
|
||||
WARP_UCODE_INSTALL( warp_g200_tgzaf, MGA_WARP_TGZAF );
|
||||
WARP_UCODE_INSTALL( warp_g200_tgzs, MGA_WARP_TGZS );
|
||||
WARP_UCODE_INSTALL( warp_g200_tgzsf, MGA_WARP_TGZSF );
|
||||
WARP_UCODE_INSTALL( warp_g200_tgzsa, MGA_WARP_TGZSA );
|
||||
WARP_UCODE_INSTALL( warp_g200_tgzsaf, MGA_WARP_TGZSAF );
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mga_warp_install_microcode( drm_mga_private_t *dev_priv )
|
||||
{
|
||||
switch ( dev_priv->chipset ) {
|
||||
case MGA_CARD_TYPE_G400:
|
||||
return mga_warp_install_g400_microcode( dev_priv );
|
||||
case MGA_CARD_TYPE_G200:
|
||||
return mga_warp_install_g200_microcode( dev_priv );
|
||||
default:
|
||||
DRM_OS_RETURN(EINVAL);
|
||||
}
|
||||
}
|
||||
|
||||
#define WMISC_EXPECTED (MGA_WUCODECACHE_ENABLE | MGA_WMASTER_ENABLE)
|
||||
|
||||
int mga_warp_init( drm_mga_private_t *dev_priv )
|
||||
{
|
||||
u32 wmisc;
|
||||
|
||||
/* FIXME: Get rid of these damned magic numbers...
|
||||
*/
|
||||
switch ( dev_priv->chipset ) {
|
||||
case MGA_CARD_TYPE_G400:
|
||||
MGA_WRITE( MGA_WIADDR2, MGA_WMODE_SUSPEND );
|
||||
MGA_WRITE( MGA_WGETMSB, 0x00000E00 );
|
||||
MGA_WRITE( MGA_WVRTXSZ, 0x00001807 );
|
||||
MGA_WRITE( MGA_WACCEPTSEQ, 0x18000000 );
|
||||
break;
|
||||
case MGA_CARD_TYPE_G200:
|
||||
MGA_WRITE( MGA_WIADDR, MGA_WMODE_SUSPEND );
|
||||
MGA_WRITE( MGA_WGETMSB, 0x1606 );
|
||||
MGA_WRITE( MGA_WVRTXSZ, 7 );
|
||||
break;
|
||||
default:
|
||||
DRM_OS_RETURN(EINVAL);
|
||||
}
|
||||
|
||||
MGA_WRITE( MGA_WMISC, (MGA_WUCODECACHE_ENABLE |
|
||||
MGA_WMASTER_ENABLE |
|
||||
MGA_WCACHEFLUSH_ENABLE) );
|
||||
wmisc = MGA_READ( MGA_WMISC );
|
||||
if ( wmisc != WMISC_EXPECTED ) {
|
||||
DRM_ERROR( "WARP engine config failed! 0x%x != 0x%x\n",
|
||||
wmisc, WMISC_EXPECTED );
|
||||
DRM_OS_RETURN(EINVAL);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
1024
bsd/r128/r128_cce.c
1024
bsd/r128/r128_cce.c
File diff suppressed because it is too large
Load Diff
|
@ -1,153 +0,0 @@
|
|||
/* r128_drv.c -- ATI Rage 128 driver -*- linux-c -*-
|
||||
* Created: Mon Dec 13 09:47:27 1999 by faith@precisioninsight.com
|
||||
*
|
||||
* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
|
||||
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a
|
||||
* copy of this software and associated documentation files (the "Software"),
|
||||
* to deal in the Software without restriction, including without limitation
|
||||
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
* and/or sell copies of the Software, and to permit persons to whom the
|
||||
* Software is furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice (including the next
|
||||
* paragraph) shall be included in all copies or substantial portions of the
|
||||
* Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
* VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||||
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
* OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* Authors:
|
||||
* Rickard E. (Rik) Faith <faith@valinux.com>
|
||||
* Gareth Hughes <gareth@valinux.com>
|
||||
*/
|
||||
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <sys/bus.h>
|
||||
#include <pci/pcivar.h>
|
||||
#include <opt_drm_linux.h>
|
||||
|
||||
#include "r128.h"
|
||||
#include "drmP.h"
|
||||
#include "drm.h"
|
||||
#include "r128_drm.h"
|
||||
#include "r128_drv.h"
|
||||
#if __REALLY_HAVE_SG
|
||||
#include "ati_pcigart.h"
|
||||
#endif
|
||||
|
||||
#define DRIVER_AUTHOR "Gareth Hughes, VA Linux Systems Inc."
|
||||
|
||||
#define DRIVER_NAME "r128"
|
||||
#define DRIVER_DESC "ATI Rage 128"
|
||||
#define DRIVER_DATE "20010405"
|
||||
|
||||
#define DRIVER_MAJOR 2
|
||||
#define DRIVER_MINOR 2
|
||||
#define DRIVER_PATCHLEVEL 0
|
||||
|
||||
/* List acquired from http://www.yourvote.com/pci/pcihdr.h and xc/xc/programs/Xserver/hw/xfree86/common/xf86PciInfo.h
|
||||
* Please report to anholt@teleport.com inaccuracies or if a chip you have works that is marked unsupported here.
|
||||
*/
|
||||
drm_chipinfo_t DRM(devicelist)[] = {
|
||||
{0x1002, 0x4c45, 1, "ATI Rage 128 Mobility LE"},
|
||||
{0x1002, 0x4c46, 1, "ATI Rage 128 Mobility LF"},
|
||||
{0x1002, 0x4d46, 1, "ATI Rage 128 Mobility MF (AGP 4x)"},
|
||||
{0x1002, 0x4d4c, 1, "ATI Rage 128 Mobility ML"},
|
||||
{0x1002, 0x5041, 0, "ATI Rage 128 Pro PA (PCI)"},
|
||||
{0x1002, 0x5042, 1, "ATI Rage 128 Pro PB (AGP 2x)"},
|
||||
{0x1002, 0x5043, 1, "ATI Rage 128 Pro PC (AGP 4x)"},
|
||||
{0x1002, 0x5044, 0, "ATI Rage 128 Pro PD (PCI)"},
|
||||
{0x1002, 0x5045, 1, "ATI Rage 128 Pro PE (AGP 2x)"},
|
||||
{0x1002, 0x5046, 1, "ATI Rage 128 Pro PF (AGP 4x)"},
|
||||
{0x1002, 0x5047, 0, "ATI Rage 128 Pro PG (PCI)"},
|
||||
{0x1002, 0x5048, 1, "ATI Rage 128 Pro PH (AGP)"},
|
||||
{0x1002, 0x5049, 1, "ATI Rage 128 Pro PI (AGP)"},
|
||||
{0x1002, 0x504a, 0, "ATI Rage 128 Pro PJ (PCI)"},
|
||||
{0x1002, 0x504b, 1, "ATI Rage 128 Pro PK (AGP)"},
|
||||
{0x1002, 0x504c, 1, "ATI Rage 128 Pro PL (AGP)"},
|
||||
{0x1002, 0x504d, 0, "ATI Rage 128 Pro PM (PCI)"},
|
||||
{0x1002, 0x504e, 1, "ATI Rage 128 Pro PN (AGP)"},
|
||||
{0x1002, 0x505f, 1, "ATI Rage 128 Pro PO (AGP)"},
|
||||
{0x1002, 0x5050, 0, "ATI Rage 128 Pro PP (PCI)"},
|
||||
{0x1002, 0x5051, 1, "ATI Rage 128 Pro PQ (AGP)"},
|
||||
{0x1002, 0x5052, 1, "ATI Rage 128 Pro PR (AGP)"},
|
||||
{0x1002, 0x5053, 0, "ATI Rage 128 Pro PS (PCI)"},
|
||||
{0x1002, 0x5054, 1, "ATI Rage 128 Pro PT (AGP)"},
|
||||
{0x1002, 0x5055, 1, "ATI Rage 128 Pro PU (AGP)"},
|
||||
{0x1002, 0x5056, 0, "ATI Rage 128 Pro PV (PCI)"},
|
||||
{0x1002, 0x5057, 1, "ATI Rage 128 Pro PW (AGP)"},
|
||||
{0x1002, 0x5058, 1, "ATI Rage 128 Pro PX (AGP)"},
|
||||
{0x1002, 0x5245, 0, "ATI Rage 128 GL (PCI)"},
|
||||
{0x1002, 0x5246, 1, "ATI Rage 128 GL (AGP 2x)"},
|
||||
{0x1002, 0x524b, 0, "ATI Rage 128 VR (PCI)"},
|
||||
{0x1002, 0x524c, 1, "ATI Rage 128 VR (AGP 2x)"},
|
||||
{0x1002, 0x5345, 0, "ATI Rage 128 SE (PCI)"},
|
||||
{0x1002, 0x5346, 1, "ATI Rage 128 SF (AGP 2x)"},
|
||||
{0x1002, 0x5347, 1, "ATI Rage 128 SG (AGP 4x)"},
|
||||
{0x1002, 0x5348, 0, "ATI Rage 128 SH (unknown)"},
|
||||
{0x1002, 0x534b, 0, "ATI Rage 128 SK (PCI)"},
|
||||
{0x1002, 0x534c, 1, "ATI Rage 128 SL (AGP 2x)"},
|
||||
{0x1002, 0x534d, 1, "ATI Rage 128 SM (AGP 4x)"},
|
||||
{0x1002, 0x534e, 1, "ATI Rage 128 (AGP 4x?)"},
|
||||
{0, 0, 0, NULL}
|
||||
};
|
||||
|
||||
#define DRIVER_IOCTLS \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_DMA)] = { r128_cce_buffers, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_R128_INIT)] = { r128_cce_init, 1, 1 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_R128_CCE_START)] = { r128_cce_start, 1, 1 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_R128_CCE_STOP)] = { r128_cce_stop, 1, 1 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_R128_CCE_RESET)] = { r128_cce_reset, 1, 1 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_R128_CCE_IDLE)] = { r128_cce_idle, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_R128_RESET)] = { r128_engine_reset, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_R128_FULLSCREEN)] = { r128_fullscreen, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_R128_SWAP)] = { r128_cce_swap, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_R128_CLEAR)] = { r128_cce_clear, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_R128_VERTEX)] = { r128_cce_vertex, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_R128_INDICES)] = { r128_cce_indices, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_R128_BLIT)] = { r128_cce_blit, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_R128_DEPTH)] = { r128_cce_depth, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_R128_STIPPLE)] = { r128_cce_stipple, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_R128_INDIRECT)] = { r128_cce_indirect, 1, 1 },
|
||||
|
||||
|
||||
#if 0
|
||||
/* GH: Count data sent to card via ring or vertex/indirect buffers.
|
||||
*/
|
||||
#define __HAVE_COUNTERS 3
|
||||
#define __HAVE_COUNTER6 _DRM_STAT_IRQ
|
||||
#define __HAVE_COUNTER7 _DRM_STAT_PRIMARY
|
||||
#define __HAVE_COUNTER8 _DRM_STAT_SECONDARY
|
||||
#endif
|
||||
|
||||
|
||||
#include "drm_agpsupport.h"
|
||||
#include "drm_auth.h"
|
||||
#include "drm_bufs.h"
|
||||
#include "drm_context.h"
|
||||
#include "drm_dma.h"
|
||||
#include "drm_drawable.h"
|
||||
#include "drm_drv.h"
|
||||
|
||||
|
||||
#include "drm_fops.h"
|
||||
#include "drm_init.h"
|
||||
#include "drm_ioctl.h"
|
||||
#include "drm_lock.h"
|
||||
#include "drm_memory.h"
|
||||
#include "drm_sysctl.h"
|
||||
#include "drm_vm.h"
|
||||
#if __REALLY_HAVE_SG
|
||||
#include "drm_scatter.h"
|
||||
#endif
|
||||
|
||||
DRIVER_MODULE(r128, pci, r128_driver, r128_devclass, 0, 0);
|
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
@ -1,125 +0,0 @@
|
|||
/* radeon_drv.c -- ATI Radeon driver -*- linux-c -*-
|
||||
* Created: Wed Feb 14 17:10:04 2001 by gareth@valinux.com
|
||||
*
|
||||
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
|
||||
* All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a
|
||||
* copy of this software and associated documentation files (the "Software"),
|
||||
* to deal in the Software without restriction, including without limitation
|
||||
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
* and/or sell copies of the Software, and to permit persons to whom the
|
||||
* Software is furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice (including the next
|
||||
* paragraph) shall be included in all copies or substantial portions of the
|
||||
* Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
* VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||||
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
* OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* Authors:
|
||||
* Gareth Hughes <gareth@valinux.com>
|
||||
*/
|
||||
|
||||
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <sys/bus.h>
|
||||
#include <pci/pcivar.h>
|
||||
#include <opt_drm_linux.h>
|
||||
|
||||
#include "radeon.h"
|
||||
#include "drmP.h"
|
||||
#include "drm.h"
|
||||
#include "radeon_drm.h"
|
||||
#include "radeon_drv.h"
|
||||
#if __REALLY_HAVE_SG
|
||||
#include "ati_pcigart.h"
|
||||
#endif
|
||||
|
||||
#define DRIVER_AUTHOR "Gareth Hughes, VA Linux Systems Inc."
|
||||
|
||||
#define DRIVER_NAME "radeon"
|
||||
#define DRIVER_DESC "ATI Radeon"
|
||||
#define DRIVER_DATE "20010405"
|
||||
|
||||
#define DRIVER_MAJOR 1
|
||||
#define DRIVER_MINOR 2
|
||||
#define DRIVER_PATCHLEVEL 0
|
||||
|
||||
/* Interface history:
|
||||
*
|
||||
* 1.1 - ??
|
||||
* 1.2 - Add vertex2 ioctl (keith)
|
||||
* - Add stencil capability to clear ioctl (gareth, keith)
|
||||
* - Increase MAX_TEXTURE_LEVELS (brian)
|
||||
*/
|
||||
|
||||
/* List acquired from http://www.yourvote.com/pci/pcihdr.h and xc/xc/programs/Xserver/hw/xfree86/common/xf86PciInfo.h
|
||||
* Please report to anholt@teleport.com inaccuracies or if a chip you have works that is marked unsupported here.
|
||||
*/
|
||||
drm_chipinfo_t DRM(devicelist)[] = {
|
||||
{0x1002, 0x5144, 1, "ATI Radeon QD"},
|
||||
{0x1002, 0x5145, 1, "ATI Radeon QE"},
|
||||
{0x1002, 0x5146, 1, "ATI Radeon QF"},
|
||||
{0x1002, 0x5147, 1, "ATI Radeon QG"},
|
||||
{0x1002, 0x5159, 1, "ATI Radeon VE"},
|
||||
{0, 0, 0, NULL}
|
||||
};
|
||||
|
||||
#define DRIVER_IOCTLS \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_DMA)] = { radeon_cp_buffers, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_CP_INIT)] = { radeon_cp_init, 1, 1 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_CP_START)] = { radeon_cp_start, 1, 1 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_CP_STOP)] = { radeon_cp_stop, 1, 1 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_CP_RESET)] = { radeon_cp_reset, 1, 1 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_CP_IDLE)] = { radeon_cp_idle, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_RESET)] = { radeon_engine_reset, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_FULLSCREEN)] = { radeon_fullscreen, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_SWAP)] = { radeon_cp_swap, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_CLEAR)] = { radeon_cp_clear, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_VERTEX)] = { radeon_cp_vertex, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_INDICES)] = { radeon_cp_indices, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_TEXTURE)] = { radeon_cp_texture, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_STIPPLE)] = { radeon_cp_stipple, 1, 0 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_INDIRECT)] = { radeon_cp_indirect, 1, 1 }, \
|
||||
[DRM_IOCTL_NR(DRM_IOCTL_RADEON_VERTEX2)] = { radeon_cp_vertex2, 1, 0 },
|
||||
|
||||
|
||||
#if 0
|
||||
/* GH: Count data sent to card via ring or vertex/indirect buffers.
|
||||
*/
|
||||
#define __HAVE_COUNTERS 3
|
||||
#define __HAVE_COUNTER6 _DRM_STAT_IRQ
|
||||
#define __HAVE_COUNTER7 _DRM_STAT_PRIMARY
|
||||
#define __HAVE_COUNTER8 _DRM_STAT_SECONDARY
|
||||
#endif
|
||||
|
||||
|
||||
#include "drm_agpsupport.h"
|
||||
#include "drm_auth.h"
|
||||
#include "drm_bufs.h"
|
||||
#include "drm_context.h"
|
||||
#include "drm_dma.h"
|
||||
#include "drm_drawable.h"
|
||||
#include "drm_drv.h"
|
||||
|
||||
|
||||
#include "drm_fops.h"
|
||||
#include "drm_init.h"
|
||||
#include "drm_ioctl.h"
|
||||
#include "drm_lock.h"
|
||||
#include "drm_memory.h"
|
||||
#include "drm_vm.h"
|
||||
#include "drm_sysctl.h"
|
||||
#if __REALLY_HAVE_SG
|
||||
#include "drm_scatter.h"
|
||||
#endif
|
||||
|
||||
DRIVER_MODULE(radeon, pci, radeon_driver, radeon_devclass, 0, 0);
|
|
@ -1,733 +0,0 @@
|
|||
/* radeon_drv.h -- Private header for radeon driver -*- linux-c -*-
|
||||
*
|
||||
* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
|
||||
* Copyright 2000 VA Linux Systems, Inc., Fremont, California.
|
||||
* All rights reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a
|
||||
* copy of this software and associated documentation files (the "Software"),
|
||||
* to deal in the Software without restriction, including without limitation
|
||||
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
* and/or sell copies of the Software, and to permit persons to whom the
|
||||
* Software is furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice (including the next
|
||||
* paragraph) shall be included in all copies or substantial portions of the
|
||||
* Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
* PRECISION INSIGHT 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.
|
||||
*
|
||||
* Authors:
|
||||
* Kevin E. Martin <martin@valinux.com>
|
||||
* Gareth Hughes <gareth@valinux.com>
|
||||
*/
|
||||
|
||||
#ifndef __RADEON_DRV_H__
|
||||
#define __RADEON_DRV_H__
|
||||
|
||||
typedef struct drm_radeon_freelist {
|
||||
unsigned int age;
|
||||
drm_buf_t *buf;
|
||||
struct drm_radeon_freelist *next;
|
||||
struct drm_radeon_freelist *prev;
|
||||
} drm_radeon_freelist_t;
|
||||
|
||||
typedef struct drm_radeon_ring_buffer {
|
||||
u32 *start;
|
||||
u32 *end;
|
||||
int size;
|
||||
int size_l2qw;
|
||||
|
||||
volatile u32 *head;
|
||||
u32 tail;
|
||||
u32 tail_mask;
|
||||
int space;
|
||||
|
||||
int high_mark;
|
||||
} drm_radeon_ring_buffer_t;
|
||||
|
||||
typedef struct drm_radeon_depth_clear_t {
|
||||
u32 rb3d_cntl;
|
||||
u32 rb3d_zstencilcntl;
|
||||
u32 se_cntl;
|
||||
} drm_radeon_depth_clear_t;
|
||||
|
||||
typedef struct drm_radeon_private {
|
||||
drm_radeon_ring_buffer_t ring;
|
||||
drm_radeon_sarea_t *sarea_priv;
|
||||
|
||||
int agp_size;
|
||||
u32 agp_vm_start;
|
||||
unsigned long agp_buffers_offset;
|
||||
|
||||
int cp_mode;
|
||||
int cp_running;
|
||||
|
||||
drm_radeon_freelist_t *head;
|
||||
drm_radeon_freelist_t *tail;
|
||||
/* FIXME: ROTATE_BUFS is a hask to cycle through bufs until freelist
|
||||
code is used. Note this hides a problem with the scratch register
|
||||
(used to keep track of last buffer completed) being written to before
|
||||
the last buffer has actually completed rendering. */
|
||||
#define ROTATE_BUFS 1
|
||||
#if ROTATE_BUFS
|
||||
int last_buf;
|
||||
#endif
|
||||
volatile u32 *scratch;
|
||||
|
||||
int usec_timeout;
|
||||
int is_pci;
|
||||
unsigned long phys_pci_gart;
|
||||
#if __REALLY_HAVE_SG
|
||||
dma_addr_t bus_pci_gart;
|
||||
#endif
|
||||
|
||||
atomic_t idle_count;
|
||||
|
||||
int page_flipping;
|
||||
int current_page;
|
||||
u32 crtc_offset;
|
||||
u32 crtc_offset_cntl;
|
||||
|
||||
u32 color_fmt;
|
||||
unsigned int front_offset;
|
||||
unsigned int front_pitch;
|
||||
unsigned int back_offset;
|
||||
unsigned int back_pitch;
|
||||
|
||||
u32 depth_fmt;
|
||||
unsigned int depth_offset;
|
||||
unsigned int depth_pitch;
|
||||
|
||||
u32 front_pitch_offset;
|
||||
u32 back_pitch_offset;
|
||||
u32 depth_pitch_offset;
|
||||
|
||||
drm_radeon_depth_clear_t depth_clear;
|
||||
|
||||
drm_map_t *sarea;
|
||||
drm_map_t *fb;
|
||||
drm_map_t *mmio;
|
||||
drm_map_t *cp_ring;
|
||||
drm_map_t *ring_rptr;
|
||||
drm_map_t *buffers;
|
||||
drm_map_t *agp_textures;
|
||||
} drm_radeon_private_t;
|
||||
|
||||
typedef struct drm_radeon_buf_priv {
|
||||
u32 age;
|
||||
int prim;
|
||||
int discard;
|
||||
int dispatched;
|
||||
drm_radeon_freelist_t *list_entry;
|
||||
} drm_radeon_buf_priv_t;
|
||||
|
||||
/* radeon_cp.c */
|
||||
extern int radeon_cp_init( DRM_OS_IOCTL );
|
||||
extern int radeon_cp_start( DRM_OS_IOCTL );
|
||||
extern int radeon_cp_stop( DRM_OS_IOCTL );
|
||||
extern int radeon_cp_reset( DRM_OS_IOCTL );
|
||||
extern int radeon_cp_idle( DRM_OS_IOCTL );
|
||||
extern int radeon_engine_reset( DRM_OS_IOCTL );
|
||||
extern int radeon_fullscreen( DRM_OS_IOCTL );
|
||||
extern int radeon_cp_buffers( DRM_OS_IOCTL );
|
||||
|
||||
extern void radeon_freelist_reset( drm_device_t *dev );
|
||||
extern drm_buf_t *radeon_freelist_get( drm_device_t *dev );
|
||||
|
||||
extern int radeon_wait_ring( drm_radeon_private_t *dev_priv, int n );
|
||||
|
||||
static __inline__ void
|
||||
radeon_update_ring_snapshot( drm_radeon_ring_buffer_t *ring )
|
||||
{
|
||||
ring->space = (*(volatile int *)ring->head - ring->tail) * sizeof(u32);
|
||||
if ( ring->space <= 0 )
|
||||
ring->space += ring->size;
|
||||
}
|
||||
|
||||
extern int radeon_do_cp_idle( drm_radeon_private_t *dev_priv );
|
||||
extern int radeon_do_cleanup_cp( drm_device_t *dev );
|
||||
extern int radeon_do_cleanup_pageflip( drm_device_t *dev );
|
||||
|
||||
/* radeon_state.c */
|
||||
extern int radeon_cp_clear( DRM_OS_IOCTL );
|
||||
extern int radeon_cp_swap( DRM_OS_IOCTL );
|
||||
extern int radeon_cp_vertex( DRM_OS_IOCTL );
|
||||
extern int radeon_cp_indices( DRM_OS_IOCTL );
|
||||
extern int radeon_cp_texture( DRM_OS_IOCTL );
|
||||
extern int radeon_cp_stipple( DRM_OS_IOCTL );
|
||||
extern int radeon_cp_indirect( DRM_OS_IOCTL );
|
||||
extern int radeon_cp_vertex2( DRM_OS_IOCTL );
|
||||
|
||||
/* Register definitions, register access macros and drmAddMap constants
|
||||
* for Radeon kernel driver.
|
||||
*/
|
||||
|
||||
#define RADEON_AGP_COMMAND 0x0f60
|
||||
#define RADEON_AUX_SCISSOR_CNTL 0x26f0
|
||||
# define RADEON_EXCLUSIVE_SCISSOR_0 (1 << 24)
|
||||
# define RADEON_EXCLUSIVE_SCISSOR_1 (1 << 25)
|
||||
# define RADEON_EXCLUSIVE_SCISSOR_2 (1 << 26)
|
||||
# define RADEON_SCISSOR_0_ENABLE (1 << 28)
|
||||
# define RADEON_SCISSOR_1_ENABLE (1 << 29)
|
||||
# define RADEON_SCISSOR_2_ENABLE (1 << 30)
|
||||
|
||||
#define RADEON_BUS_CNTL 0x0030
|
||||
# define RADEON_BUS_MASTER_DIS (1 << 6)
|
||||
|
||||
#define RADEON_CLOCK_CNTL_DATA 0x000c
|
||||
# define RADEON_PLL_WR_EN (1 << 7)
|
||||
#define RADEON_CLOCK_CNTL_INDEX 0x0008
|
||||
#define RADEON_CONFIG_APER_SIZE 0x0108
|
||||
#define RADEON_CRTC_OFFSET 0x0224
|
||||
#define RADEON_CRTC_OFFSET_CNTL 0x0228
|
||||
# define RADEON_CRTC_TILE_EN (1 << 15)
|
||||
# define RADEON_CRTC_OFFSET_FLIP_CNTL (1 << 16)
|
||||
|
||||
#define RADEON_RB3D_COLORPITCH 0x1c48
|
||||
#define RADEON_RB3D_DEPTHCLEARVALUE 0x1c30
|
||||
#define RADEON_RB3D_DEPTHXY_OFFSET 0x1c60
|
||||
|
||||
#define RADEON_DP_GUI_MASTER_CNTL 0x146c
|
||||
# define RADEON_GMC_SRC_PITCH_OFFSET_CNTL (1 << 0)
|
||||
# define RADEON_GMC_DST_PITCH_OFFSET_CNTL (1 << 1)
|
||||
# define RADEON_GMC_BRUSH_SOLID_COLOR (13 << 4)
|
||||
# define RADEON_GMC_BRUSH_NONE (15 << 4)
|
||||
# define RADEON_GMC_DST_16BPP (4 << 8)
|
||||
# define RADEON_GMC_DST_24BPP (5 << 8)
|
||||
# define RADEON_GMC_DST_32BPP (6 << 8)
|
||||
# define RADEON_GMC_DST_DATATYPE_SHIFT 8
|
||||
# define RADEON_GMC_SRC_DATATYPE_COLOR (3 << 12)
|
||||
# define RADEON_DP_SRC_SOURCE_MEMORY (2 << 24)
|
||||
# define RADEON_DP_SRC_SOURCE_HOST_DATA (3 << 24)
|
||||
# define RADEON_GMC_CLR_CMP_CNTL_DIS (1 << 28)
|
||||
# define RADEON_GMC_WR_MSK_DIS (1 << 30)
|
||||
# define RADEON_ROP3_S 0x00cc0000
|
||||
# define RADEON_ROP3_P 0x00f00000
|
||||
#define RADEON_DP_WRITE_MASK 0x16cc
|
||||
#define RADEON_DST_PITCH_OFFSET 0x142c
|
||||
#define RADEON_DST_PITCH_OFFSET_C 0x1c80
|
||||
# define RADEON_DST_TILE_LINEAR (0 << 30)
|
||||
# define RADEON_DST_TILE_MACRO (1 << 30)
|
||||
# define RADEON_DST_TILE_MICRO (2 << 30)
|
||||
# define RADEON_DST_TILE_BOTH (3 << 30)
|
||||
|
||||
#define RADEON_SCRATCH_REG0 0x15e0
|
||||
#define RADEON_SCRATCH_REG1 0x15e4
|
||||
#define RADEON_SCRATCH_REG2 0x15e8
|
||||
#define RADEON_SCRATCH_REG3 0x15ec
|
||||
#define RADEON_SCRATCH_REG4 0x15f0
|
||||
#define RADEON_SCRATCH_REG5 0x15f4
|
||||
#define RADEON_SCRATCH_UMSK 0x0770
|
||||
#define RADEON_SCRATCH_ADDR 0x0774
|
||||
|
||||
#define RADEON_HOST_PATH_CNTL 0x0130
|
||||
# define RADEON_HDP_SOFT_RESET (1 << 26)
|
||||
# define RADEON_HDP_WC_TIMEOUT_MASK (7 << 28)
|
||||
# define RADEON_HDP_WC_TIMEOUT_28BCLK (7 << 28)
|
||||
|
||||
#define RADEON_ISYNC_CNTL 0x1724
|
||||
# define RADEON_ISYNC_ANY2D_IDLE3D (1 << 0)
|
||||
# define RADEON_ISYNC_ANY3D_IDLE2D (1 << 1)
|
||||
# define RADEON_ISYNC_TRIG2D_IDLE3D (1 << 2)
|
||||
# define RADEON_ISYNC_TRIG3D_IDLE2D (1 << 3)
|
||||
# define RADEON_ISYNC_WAIT_IDLEGUI (1 << 4)
|
||||
# define RADEON_ISYNC_CPSCRATCH_IDLEGUI (1 << 5)
|
||||
|
||||
#define RADEON_MC_AGP_LOCATION 0x014c
|
||||
#define RADEON_MC_FB_LOCATION 0x0148
|
||||
#define RADEON_MCLK_CNTL 0x0012
|
||||
# define RADEON_FORCEON_MCLKA (1 << 16)
|
||||
# define RADEON_FORCEON_MCLKB (1 << 17)
|
||||
# define RADEON_FORCEON_YCLKA (1 << 18)
|
||||
# define RADEON_FORCEON_YCLKB (1 << 19)
|
||||
# define RADEON_FORCEON_MC (1 << 20)
|
||||
# define RADEON_FORCEON_AIC (1 << 21)
|
||||
|
||||
#define RADEON_PP_BORDER_COLOR_0 0x1d40
|
||||
#define RADEON_PP_BORDER_COLOR_1 0x1d44
|
||||
#define RADEON_PP_BORDER_COLOR_2 0x1d48
|
||||
#define RADEON_PP_CNTL 0x1c38
|
||||
# define RADEON_SCISSOR_ENABLE (1 << 1)
|
||||
#define RADEON_PP_LUM_MATRIX 0x1d00
|
||||
#define RADEON_PP_MISC 0x1c14
|
||||
#define RADEON_PP_ROT_MATRIX_0 0x1d58
|
||||
#define RADEON_PP_TXFILTER_0 0x1c54
|
||||
#define RADEON_PP_TXFILTER_1 0x1c6c
|
||||
#define RADEON_PP_TXFILTER_2 0x1c84
|
||||
|
||||
#define RADEON_RB2D_DSTCACHE_CTLSTAT 0x342c
|
||||
# define RADEON_RB2D_DC_FLUSH (3 << 0)
|
||||
# define RADEON_RB2D_DC_FREE (3 << 2)
|
||||
# define RADEON_RB2D_DC_FLUSH_ALL 0xf
|
||||
# define RADEON_RB2D_DC_BUSY (1 << 31)
|
||||
#define RADEON_RB3D_CNTL 0x1c3c
|
||||
# define RADEON_ALPHA_BLEND_ENABLE (1 << 0)
|
||||
# define RADEON_PLANE_MASK_ENABLE (1 << 1)
|
||||
# define RADEON_DITHER_ENABLE (1 << 2)
|
||||
# define RADEON_ROUND_ENABLE (1 << 3)
|
||||
# define RADEON_SCALE_DITHER_ENABLE (1 << 4)
|
||||
# define RADEON_DITHER_INIT (1 << 5)
|
||||
# define RADEON_ROP_ENABLE (1 << 6)
|
||||
# define RADEON_STENCIL_ENABLE (1 << 7)
|
||||
# define RADEON_Z_ENABLE (1 << 8)
|
||||
# define RADEON_DEPTH_XZ_OFFEST_ENABLE (1 << 9)
|
||||
# define RADEON_ZBLOCK8 (0 << 15)
|
||||
# define RADEON_ZBLOCK16 (1 << 15)
|
||||
#define RADEON_RB3D_DEPTHOFFSET 0x1c24
|
||||
#define RADEON_RB3D_PLANEMASK 0x1d84
|
||||
#define RADEON_RB3D_STENCILREFMASK 0x1d7c
|
||||
#define RADEON_RB3D_ZCACHE_MODE 0x3250
|
||||
#define RADEON_RB3D_ZCACHE_CTLSTAT 0x3254
|
||||
# define RADEON_RB3D_ZC_FLUSH (1 << 0)
|
||||
# define RADEON_RB3D_ZC_FREE (1 << 2)
|
||||
# define RADEON_RB3D_ZC_FLUSH_ALL 0x5
|
||||
# define RADEON_RB3D_ZC_BUSY (1 << 31)
|
||||
#define RADEON_RB3D_ZSTENCILCNTL 0x1c2c
|
||||
# define RADEON_Z_TEST_MASK (7 << 4)
|
||||
# define RADEON_Z_TEST_ALWAYS (7 << 4)
|
||||
# define RADEON_STENCIL_TEST_ALWAYS (7 << 12)
|
||||
# define RADEON_STENCIL_S_FAIL_REPLACE (2 << 16)
|
||||
# define RADEON_STENCIL_ZPASS_REPLACE (2 << 20)
|
||||
# define RADEON_STENCIL_ZFAIL_REPLACE (2 << 24)
|
||||
# define RADEON_Z_WRITE_ENABLE (1 << 30)
|
||||
#define RADEON_RBBM_SOFT_RESET 0x00f0
|
||||
# define RADEON_SOFT_RESET_CP (1 << 0)
|
||||
# define RADEON_SOFT_RESET_HI (1 << 1)
|
||||
# define RADEON_SOFT_RESET_SE (1 << 2)
|
||||
# define RADEON_SOFT_RESET_RE (1 << 3)
|
||||
# define RADEON_SOFT_RESET_PP (1 << 4)
|
||||
# define RADEON_SOFT_RESET_E2 (1 << 5)
|
||||
# define RADEON_SOFT_RESET_RB (1 << 6)
|
||||
# define RADEON_SOFT_RESET_HDP (1 << 7)
|
||||
#define RADEON_RBBM_STATUS 0x0e40
|
||||
# define RADEON_RBBM_FIFOCNT_MASK 0x007f
|
||||
# define RADEON_RBBM_ACTIVE (1 << 31)
|
||||
#define RADEON_RE_LINE_PATTERN 0x1cd0
|
||||
#define RADEON_RE_MISC 0x26c4
|
||||
#define RADEON_RE_TOP_LEFT 0x26c0
|
||||
#define RADEON_RE_WIDTH_HEIGHT 0x1c44
|
||||
#define RADEON_RE_STIPPLE_ADDR 0x1cc8
|
||||
#define RADEON_RE_STIPPLE_DATA 0x1ccc
|
||||
|
||||
#define RADEON_SCISSOR_TL_0 0x1cd8
|
||||
#define RADEON_SCISSOR_BR_0 0x1cdc
|
||||
#define RADEON_SCISSOR_TL_1 0x1ce0
|
||||
#define RADEON_SCISSOR_BR_1 0x1ce4
|
||||
#define RADEON_SCISSOR_TL_2 0x1ce8
|
||||
#define RADEON_SCISSOR_BR_2 0x1cec
|
||||
#define RADEON_SE_COORD_FMT 0x1c50
|
||||
#define RADEON_SE_CNTL 0x1c4c
|
||||
# define RADEON_FFACE_CULL_CW (0 << 0)
|
||||
# define RADEON_BFACE_SOLID (3 << 1)
|
||||
# define RADEON_FFACE_SOLID (3 << 3)
|
||||
# define RADEON_FLAT_SHADE_VTX_LAST (3 << 6)
|
||||
# define RADEON_DIFFUSE_SHADE_FLAT (1 << 8)
|
||||
# define RADEON_DIFFUSE_SHADE_GOURAUD (2 << 8)
|
||||
# define RADEON_ALPHA_SHADE_FLAT (1 << 10)
|
||||
# define RADEON_ALPHA_SHADE_GOURAUD (2 << 10)
|
||||
# define RADEON_SPECULAR_SHADE_FLAT (1 << 12)
|
||||
# define RADEON_SPECULAR_SHADE_GOURAUD (2 << 12)
|
||||
# define RADEON_FOG_SHADE_FLAT (1 << 14)
|
||||
# define RADEON_FOG_SHADE_GOURAUD (2 << 14)
|
||||
# define RADEON_VPORT_XY_XFORM_ENABLE (1 << 24)
|
||||
# define RADEON_VPORT_Z_XFORM_ENABLE (1 << 25)
|
||||
# define RADEON_VTX_PIX_CENTER_OGL (1 << 27)
|
||||
# define RADEON_ROUND_MODE_TRUNC (0 << 28)
|
||||
# define RADEON_ROUND_PREC_8TH_PIX (1 << 30)
|
||||
#define RADEON_SE_CNTL_STATUS 0x2140
|
||||
#define RADEON_SE_LINE_WIDTH 0x1db8
|
||||
#define RADEON_SE_VPORT_XSCALE 0x1d98
|
||||
#define RADEON_SE_ZBIAS_FACTOR 0x1db0
|
||||
#define RADEON_SURFACE_ACCESS_FLAGS 0x0bf8
|
||||
#define RADEON_SURFACE_ACCESS_CLR 0x0bfc
|
||||
#define RADEON_SURFACE_CNTL 0x0b00
|
||||
# define RADEON_SURF_TRANSLATION_DIS (1 << 8)
|
||||
# define RADEON_NONSURF_AP0_SWP_MASK (3 << 20)
|
||||
# define RADEON_NONSURF_AP0_SWP_LITTLE (0 << 20)
|
||||
# define RADEON_NONSURF_AP0_SWP_BIG16 (1 << 20)
|
||||
# define RADEON_NONSURF_AP0_SWP_BIG32 (2 << 20)
|
||||
# define RADEON_NONSURF_AP1_SWP_MASK (3 << 22)
|
||||
# define RADEON_NONSURF_AP1_SWP_LITTLE (0 << 22)
|
||||
# define RADEON_NONSURF_AP1_SWP_BIG16 (1 << 22)
|
||||
# define RADEON_NONSURF_AP1_SWP_BIG32 (2 << 22)
|
||||
#define RADEON_SURFACE0_INFO 0x0b0c
|
||||
# define RADEON_SURF_PITCHSEL_MASK (0x1ff << 0)
|
||||
# define RADEON_SURF_TILE_MODE_MASK (3 << 16)
|
||||
# define RADEON_SURF_TILE_MODE_MACRO (0 << 16)
|
||||
# define RADEON_SURF_TILE_MODE_MICRO (1 << 16)
|
||||
# define RADEON_SURF_TILE_MODE_32BIT_Z (2 << 16)
|
||||
# define RADEON_SURF_TILE_MODE_16BIT_Z (3 << 16)
|
||||
#define RADEON_SURFACE0_LOWER_BOUND 0x0b04
|
||||
#define RADEON_SURFACE0_UPPER_BOUND 0x0b08
|
||||
#define RADEON_SURFACE1_INFO 0x0b1c
|
||||
#define RADEON_SURFACE1_LOWER_BOUND 0x0b14
|
||||
#define RADEON_SURFACE1_UPPER_BOUND 0x0b18
|
||||
#define RADEON_SURFACE2_INFO 0x0b2c
|
||||
#define RADEON_SURFACE2_LOWER_BOUND 0x0b24
|
||||
#define RADEON_SURFACE2_UPPER_BOUND 0x0b28
|
||||
#define RADEON_SURFACE3_INFO 0x0b3c
|
||||
#define RADEON_SURFACE3_LOWER_BOUND 0x0b34
|
||||
#define RADEON_SURFACE3_UPPER_BOUND 0x0b38
|
||||
#define RADEON_SURFACE4_INFO 0x0b4c
|
||||
#define RADEON_SURFACE4_LOWER_BOUND 0x0b44
|
||||
#define RADEON_SURFACE4_UPPER_BOUND 0x0b48
|
||||
#define RADEON_SURFACE5_INFO 0x0b5c
|
||||
#define RADEON_SURFACE5_LOWER_BOUND 0x0b54
|
||||
#define RADEON_SURFACE5_UPPER_BOUND 0x0b58
|
||||
#define RADEON_SURFACE6_INFO 0x0b6c
|
||||
#define RADEON_SURFACE6_LOWER_BOUND 0x0b64
|
||||
#define RADEON_SURFACE6_UPPER_BOUND 0x0b68
|
||||
#define RADEON_SURFACE7_INFO 0x0b7c
|
||||
#define RADEON_SURFACE7_LOWER_BOUND 0x0b74
|
||||
#define RADEON_SURFACE7_UPPER_BOUND 0x0b78
|
||||
#define RADEON_SW_SEMAPHORE 0x013c
|
||||
|
||||
#define RADEON_WAIT_UNTIL 0x1720
|
||||
# define RADEON_WAIT_CRTC_PFLIP (1 << 0)
|
||||
# define RADEON_WAIT_2D_IDLECLEAN (1 << 16)
|
||||
# define RADEON_WAIT_3D_IDLECLEAN (1 << 17)
|
||||
# define RADEON_WAIT_HOST_IDLECLEAN (1 << 18)
|
||||
|
||||
#define RADEON_RB3D_ZMASKOFFSET 0x1c34
|
||||
#define RADEON_RB3D_ZSTENCILCNTL 0x1c2c
|
||||
# define RADEON_DEPTH_FORMAT_16BIT_INT_Z (0 << 0)
|
||||
# define RADEON_DEPTH_FORMAT_24BIT_INT_Z (2 << 0)
|
||||
|
||||
|
||||
/* CP registers */
|
||||
#define RADEON_CP_ME_RAM_ADDR 0x07d4
|
||||
#define RADEON_CP_ME_RAM_RADDR 0x07d8
|
||||
#define RADEON_CP_ME_RAM_DATAH 0x07dc
|
||||
#define RADEON_CP_ME_RAM_DATAL 0x07e0
|
||||
|
||||
#define RADEON_CP_RB_BASE 0x0700
|
||||
#define RADEON_CP_RB_CNTL 0x0704
|
||||
#define RADEON_CP_RB_RPTR_ADDR 0x070c
|
||||
#define RADEON_CP_RB_RPTR 0x0710
|
||||
#define RADEON_CP_RB_WPTR 0x0714
|
||||
|
||||
#define RADEON_CP_RB_WPTR_DELAY 0x0718
|
||||
# define RADEON_PRE_WRITE_TIMER_SHIFT 0
|
||||
# define RADEON_PRE_WRITE_LIMIT_SHIFT 23
|
||||
|
||||
#define RADEON_CP_IB_BASE 0x0738
|
||||
|
||||
#define RADEON_CP_CSQ_CNTL 0x0740
|
||||
# define RADEON_CSQ_CNT_PRIMARY_MASK (0xff << 0)
|
||||
# define RADEON_CSQ_PRIDIS_INDDIS (0 << 28)
|
||||
# define RADEON_CSQ_PRIPIO_INDDIS (1 << 28)
|
||||
# define RADEON_CSQ_PRIBM_INDDIS (2 << 28)
|
||||
# define RADEON_CSQ_PRIPIO_INDBM (3 << 28)
|
||||
# define RADEON_CSQ_PRIBM_INDBM (4 << 28)
|
||||
# define RADEON_CSQ_PRIPIO_INDPIO (15 << 28)
|
||||
|
||||
#define RADEON_AIC_CNTL 0x01d0
|
||||
# define RADEON_PCIGART_TRANSLATE_EN (1 << 0)
|
||||
#define RADEON_AIC_STAT 0x01d4
|
||||
#define RADEON_AIC_PT_BASE 0x01d8
|
||||
#define RADEON_AIC_LO_ADDR 0x01dc
|
||||
#define RADEON_AIC_HI_ADDR 0x01e0
|
||||
#define RADEON_AIC_TLB_ADDR 0x01e4
|
||||
#define RADEON_AIC_TLB_DATA 0x01e8
|
||||
|
||||
/* CP command packets */
|
||||
#define RADEON_CP_PACKET0 0x00000000
|
||||
# define RADEON_ONE_REG_WR (1 << 15)
|
||||
#define RADEON_CP_PACKET1 0x40000000
|
||||
#define RADEON_CP_PACKET2 0x80000000
|
||||
#define RADEON_CP_PACKET3 0xC0000000
|
||||
# define RADEON_3D_RNDR_GEN_INDX_PRIM 0x00002300
|
||||
# define RADEON_WAIT_FOR_IDLE 0x00002600
|
||||
# define RADEON_3D_DRAW_IMMD 0x00002900
|
||||
# define RADEON_3D_CLEAR_ZMASK 0x00003200
|
||||
# define RADEON_CNTL_HOSTDATA_BLT 0x00009400
|
||||
# define RADEON_CNTL_PAINT_MULTI 0x00009A00
|
||||
# define RADEON_CNTL_BITBLT_MULTI 0x00009B00
|
||||
|
||||
#define RADEON_CP_PACKET_MASK 0xC0000000
|
||||
#define RADEON_CP_PACKET_COUNT_MASK 0x3fff0000
|
||||
#define RADEON_CP_PACKET0_REG_MASK 0x000007ff
|
||||
#define RADEON_CP_PACKET1_REG0_MASK 0x000007ff
|
||||
#define RADEON_CP_PACKET1_REG1_MASK 0x003ff800
|
||||
|
||||
#define RADEON_VTX_Z_PRESENT (1 << 31)
|
||||
|
||||
#define RADEON_PRIM_TYPE_NONE (0 << 0)
|
||||
#define RADEON_PRIM_TYPE_POINT (1 << 0)
|
||||
#define RADEON_PRIM_TYPE_LINE (2 << 0)
|
||||
#define RADEON_PRIM_TYPE_LINE_STRIP (3 << 0)
|
||||
#define RADEON_PRIM_TYPE_TRI_LIST (4 << 0)
|
||||
#define RADEON_PRIM_TYPE_TRI_FAN (5 << 0)
|
||||
#define RADEON_PRIM_TYPE_TRI_STRIP (6 << 0)
|
||||
#define RADEON_PRIM_TYPE_TRI_TYPE2 (7 << 0)
|
||||
#define RADEON_PRIM_TYPE_RECT_LIST (8 << 0)
|
||||
#define RADEON_PRIM_TYPE_3VRT_POINT_LIST (9 << 0)
|
||||
#define RADEON_PRIM_TYPE_3VRT_LINE_LIST (10 << 0)
|
||||
#define RADEON_PRIM_TYPE_MASK 0xf
|
||||
#define RADEON_PRIM_WALK_IND (1 << 4)
|
||||
#define RADEON_PRIM_WALK_LIST (2 << 4)
|
||||
#define RADEON_PRIM_WALK_RING (3 << 4)
|
||||
#define RADEON_COLOR_ORDER_BGRA (0 << 6)
|
||||
#define RADEON_COLOR_ORDER_RGBA (1 << 6)
|
||||
#define RADEON_MAOS_ENABLE (1 << 7)
|
||||
#define RADEON_VTX_FMT_R128_MODE (0 << 8)
|
||||
#define RADEON_VTX_FMT_RADEON_MODE (1 << 8)
|
||||
#define RADEON_NUM_VERTICES_SHIFT 16
|
||||
|
||||
#define RADEON_COLOR_FORMAT_CI8 2
|
||||
#define RADEON_COLOR_FORMAT_ARGB1555 3
|
||||
#define RADEON_COLOR_FORMAT_RGB565 4
|
||||
#define RADEON_COLOR_FORMAT_ARGB8888 6
|
||||
#define RADEON_COLOR_FORMAT_RGB332 7
|
||||
#define RADEON_COLOR_FORMAT_RGB8 9
|
||||
#define RADEON_COLOR_FORMAT_ARGB4444 15
|
||||
|
||||
#define RADEON_TXFORMAT_I8 0
|
||||
#define RADEON_TXFORMAT_AI88 1
|
||||
#define RADEON_TXFORMAT_RGB332 2
|
||||
#define RADEON_TXFORMAT_ARGB1555 3
|
||||
#define RADEON_TXFORMAT_RGB565 4
|
||||
#define RADEON_TXFORMAT_ARGB4444 5
|
||||
#define RADEON_TXFORMAT_ARGB8888 6
|
||||
#define RADEON_TXFORMAT_RGBA8888 7
|
||||
|
||||
/* Constants */
|
||||
#define RADEON_MAX_USEC_TIMEOUT 100000 /* 100 ms */
|
||||
|
||||
#define RADEON_LAST_FRAME_REG RADEON_SCRATCH_REG0
|
||||
#define RADEON_LAST_DISPATCH_REG RADEON_SCRATCH_REG1
|
||||
#define RADEON_LAST_CLEAR_REG RADEON_SCRATCH_REG2
|
||||
#define RADEON_LAST_DISPATCH 1
|
||||
|
||||
#define RADEON_MAX_VB_AGE 0x7fffffff
|
||||
#define RADEON_MAX_VB_VERTS (0xffff)
|
||||
|
||||
#define RADEON_RING_HIGH_MARK 128
|
||||
|
||||
|
||||
#define RADEON_BASE(reg) ((unsigned long)(dev_priv->mmio->handle))
|
||||
#define RADEON_ADDR(reg) (RADEON_BASE( reg ) + reg)
|
||||
|
||||
#define RADEON_DEREF(reg) *(volatile u32 *)RADEON_ADDR( reg )
|
||||
#ifdef __alpha__
|
||||
#define RADEON_READ(reg) (_RADEON_READ((u32 *)RADEON_ADDR( reg )))
|
||||
static inline u32 _RADEON_READ(u32 *addr)
|
||||
{
|
||||
DRM_OS_READMEMORYBARRIER;
|
||||
return *(volatile u32 *)addr;
|
||||
}
|
||||
#define RADEON_WRITE(reg,val) \
|
||||
do { \
|
||||
DRM_OS_WRITEMEMORYBARRIER; \
|
||||
RADEON_DEREF(reg) = val; \
|
||||
} while (0)
|
||||
#else
|
||||
#define RADEON_READ(reg) RADEON_DEREF( reg )
|
||||
#define RADEON_WRITE(reg, val) do { RADEON_DEREF( reg ) = val; } while (0)
|
||||
#endif
|
||||
|
||||
#define RADEON_DEREF8(reg) *(volatile u8 *)RADEON_ADDR( reg )
|
||||
#ifdef __alpha__
|
||||
#define RADEON_READ8(reg) _RADEON_READ8((u8 *)RADEON_ADDR( reg ))
|
||||
static inline u8 _RADEON_READ8(u8 *addr)
|
||||
{
|
||||
DRM_OS_READMEMORYBARRIER;
|
||||
return *(volatile u8 *)addr;
|
||||
}
|
||||
#define RADEON_WRITE8(reg,val) \
|
||||
do { \
|
||||
DRM_OS_WRITEMEMORYBARRIER; \
|
||||
RADEON_DEREF8( reg ) = val; \
|
||||
} while (0)
|
||||
#else
|
||||
#define RADEON_READ8(reg) RADEON_DEREF8( reg )
|
||||
#define RADEON_WRITE8(reg, val) do { RADEON_DEREF8( reg ) = val; } while (0)
|
||||
#endif
|
||||
|
||||
#define RADEON_WRITE_PLL( addr, val ) \
|
||||
do { \
|
||||
RADEON_WRITE8( RADEON_CLOCK_CNTL_INDEX, \
|
||||
((addr) & 0x1f) | RADEON_PLL_WR_EN ); \
|
||||
RADEON_WRITE( RADEON_CLOCK_CNTL_DATA, (val) ); \
|
||||
} while (0)
|
||||
|
||||
extern int RADEON_READ_PLL( drm_device_t *dev, int addr );
|
||||
|
||||
|
||||
#define CP_PACKET0( reg, n ) \
|
||||
(RADEON_CP_PACKET0 | ((n) << 16) | ((reg) >> 2))
|
||||
#define CP_PACKET0_TABLE( reg, n ) \
|
||||
(RADEON_CP_PACKET0 | RADEON_ONE_REG_WR | ((n) << 16) | ((reg) >> 2))
|
||||
#define CP_PACKET1( reg0, reg1 ) \
|
||||
(RADEON_CP_PACKET1 | (((reg1) >> 2) << 15) | ((reg0) >> 2))
|
||||
#define CP_PACKET2() \
|
||||
(RADEON_CP_PACKET2)
|
||||
#define CP_PACKET3( pkt, n ) \
|
||||
(RADEON_CP_PACKET3 | (pkt) | ((n) << 16))
|
||||
|
||||
|
||||
/* ================================================================
|
||||
* Engine control helper macros
|
||||
*/
|
||||
|
||||
#define RADEON_WAIT_UNTIL_2D_IDLE() do { \
|
||||
OUT_RING( CP_PACKET0( RADEON_WAIT_UNTIL, 0 ) ); \
|
||||
OUT_RING( (RADEON_WAIT_2D_IDLECLEAN | \
|
||||
RADEON_WAIT_HOST_IDLECLEAN) ); \
|
||||
} while (0)
|
||||
|
||||
#define RADEON_WAIT_UNTIL_3D_IDLE() do { \
|
||||
OUT_RING( CP_PACKET0( RADEON_WAIT_UNTIL, 0 ) ); \
|
||||
OUT_RING( (RADEON_WAIT_3D_IDLECLEAN | \
|
||||
RADEON_WAIT_HOST_IDLECLEAN) ); \
|
||||
} while (0)
|
||||
|
||||
#define RADEON_WAIT_UNTIL_IDLE() do { \
|
||||
OUT_RING( CP_PACKET0( RADEON_WAIT_UNTIL, 0 ) ); \
|
||||
OUT_RING( (RADEON_WAIT_2D_IDLECLEAN | \
|
||||
RADEON_WAIT_3D_IDLECLEAN | \
|
||||
RADEON_WAIT_HOST_IDLECLEAN) ); \
|
||||
} while (0)
|
||||
|
||||
#define RADEON_WAIT_UNTIL_PAGE_FLIPPED() do { \
|
||||
OUT_RING( CP_PACKET0( RADEON_WAIT_UNTIL, 0 ) ); \
|
||||
OUT_RING( RADEON_WAIT_CRTC_PFLIP ); \
|
||||
} while (0)
|
||||
|
||||
#define RADEON_FLUSH_CACHE() do { \
|
||||
OUT_RING( CP_PACKET0( RADEON_RB2D_DSTCACHE_CTLSTAT, 0 ) ); \
|
||||
OUT_RING( RADEON_RB2D_DC_FLUSH ); \
|
||||
} while (0)
|
||||
|
||||
#define RADEON_PURGE_CACHE() do { \
|
||||
OUT_RING( CP_PACKET0( RADEON_RB2D_DSTCACHE_CTLSTAT, 0 ) ); \
|
||||
OUT_RING( RADEON_RB2D_DC_FLUSH_ALL ); \
|
||||
} while (0)
|
||||
|
||||
#define RADEON_FLUSH_ZCACHE() do { \
|
||||
OUT_RING( CP_PACKET0( RADEON_RB3D_ZCACHE_CTLSTAT, 0 ) ); \
|
||||
OUT_RING( RADEON_RB3D_ZC_FLUSH ); \
|
||||
} while (0)
|
||||
|
||||
#define RADEON_PURGE_ZCACHE() do { \
|
||||
OUT_RING( CP_PACKET0( RADEON_RB3D_ZCACHE_CTLSTAT, 0 ) ); \
|
||||
OUT_RING( RADEON_RB3D_ZC_FLUSH_ALL ); \
|
||||
} while (0)
|
||||
|
||||
|
||||
/* ================================================================
|
||||
* Misc helper macros
|
||||
*/
|
||||
|
||||
#define LOCK_TEST_WITH_RETURN( dev ) \
|
||||
do { \
|
||||
if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) || \
|
||||
dev->lock.pid != DRM_OS_CURRENTPID ) { \
|
||||
DRM_ERROR( "%s called without lock held\n", \
|
||||
__FUNCTION__ ); \
|
||||
DRM_OS_RETURN( EINVAL ); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define RING_SPACE_TEST_WITH_RETURN( dev_priv ) \
|
||||
do { \
|
||||
drm_radeon_ring_buffer_t *ring = &dev_priv->ring; int i; \
|
||||
if ( ring->space < ring->high_mark ) { \
|
||||
for ( i = 0 ; i < dev_priv->usec_timeout ; i++ ) { \
|
||||
radeon_update_ring_snapshot( ring ); \
|
||||
if ( ring->space >= ring->high_mark ) \
|
||||
goto __ring_space_done; \
|
||||
DRM_OS_DELAY( 1 ); \
|
||||
} \
|
||||
DRM_ERROR( "ring space check failed!\n" ); \
|
||||
DRM_OS_RETURN( EBUSY ); \
|
||||
} \
|
||||
__ring_space_done: \
|
||||
} while (0)
|
||||
|
||||
#define VB_AGE_TEST_WITH_RETURN( dev_priv ) \
|
||||
do { \
|
||||
drm_radeon_sarea_t *sarea_priv = dev_priv->sarea_priv; \
|
||||
if ( sarea_priv->last_dispatch >= RADEON_MAX_VB_AGE ) { \
|
||||
int __ret = radeon_do_cp_idle( dev_priv ); \
|
||||
if ( __ret ) return __ret; \
|
||||
sarea_priv->last_dispatch = 0; \
|
||||
radeon_freelist_reset( dev ); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define RADEON_DISPATCH_AGE( age ) do { \
|
||||
OUT_RING( CP_PACKET0( RADEON_LAST_DISPATCH_REG, 0 ) ); \
|
||||
OUT_RING( age ); \
|
||||
} while (0)
|
||||
|
||||
#define RADEON_FRAME_AGE( age ) do { \
|
||||
OUT_RING( CP_PACKET0( RADEON_LAST_FRAME_REG, 0 ) ); \
|
||||
OUT_RING( age ); \
|
||||
} while (0)
|
||||
|
||||
#define RADEON_CLEAR_AGE( age ) do { \
|
||||
OUT_RING( CP_PACKET0( RADEON_LAST_CLEAR_REG, 0 ) ); \
|
||||
OUT_RING( age ); \
|
||||
} while (0)
|
||||
|
||||
|
||||
/* ================================================================
|
||||
* Ring control
|
||||
*/
|
||||
|
||||
#define radeon_flush_write_combine() DRM_OS_READMEMORYBARRIER
|
||||
|
||||
|
||||
#define RADEON_VERBOSE 0
|
||||
|
||||
#define RING_LOCALS int write; unsigned int mask; volatile u32 *ring;
|
||||
|
||||
#define BEGIN_RING( n ) do { \
|
||||
if ( RADEON_VERBOSE ) { \
|
||||
DRM_INFO( "BEGIN_RING( %d ) in %s\n", \
|
||||
n, __FUNCTION__ ); \
|
||||
} \
|
||||
if ( dev_priv->ring.space <= (n) * sizeof(u32) ) { \
|
||||
radeon_wait_ring( dev_priv, (n) * sizeof(u32) ); \
|
||||
} \
|
||||
dev_priv->ring.space -= (n) * sizeof(u32); \
|
||||
ring = dev_priv->ring.start; \
|
||||
write = dev_priv->ring.tail; \
|
||||
mask = dev_priv->ring.tail_mask; \
|
||||
} while (0)
|
||||
|
||||
#define ADVANCE_RING() do { \
|
||||
if ( RADEON_VERBOSE ) { \
|
||||
DRM_INFO( "ADVANCE_RING() wr=0x%06x tail=0x%06x\n", \
|
||||
write, dev_priv->ring.tail ); \
|
||||
} \
|
||||
radeon_flush_write_combine(); \
|
||||
dev_priv->ring.tail = write; \
|
||||
RADEON_WRITE( RADEON_CP_RB_WPTR, write ); \
|
||||
} while (0)
|
||||
|
||||
#define OUT_RING( x ) do { \
|
||||
if ( RADEON_VERBOSE ) { \
|
||||
DRM_INFO( " OUT_RING( 0x%08x ) at 0x%x\n", \
|
||||
(unsigned int)(x), write ); \
|
||||
} \
|
||||
ring[write++] = (x); \
|
||||
write &= mask; \
|
||||
} while (0)
|
||||
|
||||
#define OUT_RING_REG( reg, val ) do { \
|
||||
OUT_RING( CP_PACKET0( reg, 0 ) ); \
|
||||
OUT_RING( val ); \
|
||||
} while (0)
|
||||
|
||||
#define RADEON_PERFORMANCE_BOXES 0
|
||||
|
||||
#endif /* __RADEON_DRV_H__ */
|
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue