Subversion Repositories or1k

/* i810_dma.c -- DMA support for the i810 -*- 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 <keith@tungstengraphics.com>

 *

 */

#include <linux/config.h>

#include "i810.h"

#include "drmP.h"

#include "drm.h"

#include "i810_drm.h"

#include "i810_drv.h"

#include <linux/interrupt.h>    /* For task queue support */

#include <linux/delay.h>

#define DO_MUNMAP(m, a, l)      do_munmap(m, a, l)

#define I810_BUF_FREE           2

#define I810_BUF_CLIENT         1

#define I810_BUF_HARDWARE       0

#define I810_BUF_UNMAPPED 0

#define I810_BUF_MAPPED   1

#define RING_LOCALS     unsigned int outring, ringmask; volatile char *virt;

#define BEGIN_LP_RING(n) do {                                           \

        if (0) DRM_DEBUG("BEGIN_LP_RING(%d) in %s\n", n, __FUNCTION__);  \

        if (dev_priv->ring.space < n*4)                                 \

                i810_wait_ring(dev, n*4);                               \

        dev_priv->ring.space -= n*4;                                    \

        outring = dev_priv->ring.tail;                                  \

        ringmask = dev_priv->ring.tail_mask;                            \

        virt = dev_priv->ring.virtual_start;                            \

} while (0)

#define ADVANCE_LP_RING() do {                          \

        if (0) DRM_DEBUG("ADVANCE_LP_RING\n");                   \

        dev_priv->ring.tail = outring;                  \

        I810_WRITE(LP_RING + RING_TAIL, outring);       \

} while(0)

#define OUT_RING(n) do {                                \

        if (0) DRM_DEBUG("   OUT_RING %x\n", (int)(n));  \

        *(volatile unsigned int *)(virt + outring) = n; \

        outring += 4;                                   \

        outring &= ringmask;                            \

} while (0)

static inline void i810_print_status_page(drm_device_t *dev)

{

        drm_device_dma_t *dma = dev->dma;

        drm_i810_private_t *dev_priv = dev->dev_private;

        u32 *temp = (u32 *)dev_priv->hw_status_page;

        int i;

        DRM_DEBUG(  "hw_status: Interrupt Status : %x\n", temp[0]);

        DRM_DEBUG(  "hw_status: LpRing Head ptr : %x\n", temp[1]);

        DRM_DEBUG(  "hw_status: IRing Head ptr : %x\n", temp[2]);

        DRM_DEBUG(  "hw_status: Reserved : %x\n", temp[3]);

        DRM_DEBUG(  "hw_status: Last Render: %x\n", temp[4]);

        DRM_DEBUG(  "hw_status: Driver Counter : %d\n", temp[5]);

        for(i = 6; i < dma->buf_count + 6; i++) {

                DRM_DEBUG( "buffer status idx : %d used: %d\n", i - 6, temp[i]);

        }

}

static drm_buf_t *i810_freelist_get(drm_device_t *dev)

{

        drm_device_dma_t *dma = dev->dma;

        int              i;

        int              used;

        /* Linear search might not be the best solution */

        for (i = 0; i < dma->buf_count; i++) {

                drm_buf_t *buf = dma->buflist[ i ];

                drm_i810_buf_priv_t *buf_priv = buf->dev_private;

                /* In use is already a pointer */

                used = cmpxchg(buf_priv->in_use, I810_BUF_FREE,

                               I810_BUF_CLIENT);

                if(used == I810_BUF_FREE) {

                        return buf;

                }

        }

        return NULL;

}

/* This should only be called if the buffer is not sent to the hardware

 * yet, the hardware updates in use for us once its on the ring buffer.

 */

static int i810_freelist_put(drm_device_t *dev, drm_buf_t *buf)

{

        drm_i810_buf_priv_t *buf_priv = buf->dev_private;

        int used;

        /* In use is already a pointer */

        used = cmpxchg(buf_priv->in_use, I810_BUF_CLIENT, I810_BUF_FREE);

        if(used != I810_BUF_CLIENT) {

                DRM_ERROR("Freeing buffer thats not in use : %d\n", buf->idx);

                return -EINVAL;

        }

        return 0;

}

static struct file_operations i810_buffer_fops = {

        .open    = DRM(open),

        .flush   = DRM(flush),

        .release = DRM(release),

        .ioctl   = DRM(ioctl),

        .mmap    = i810_mmap_buffers,

        .read    = DRM(read),

        .fasync  = DRM(fasync),

        .poll    = DRM(poll),

};

int i810_mmap_buffers(struct file *filp, struct vm_area_struct *vma)

{

        drm_file_t          *priv         = filp->private_data;

        drm_device_t        *dev;

        drm_i810_private_t  *dev_priv;

        drm_buf_t           *buf;

        drm_i810_buf_priv_t *buf_priv;

        lock_kernel();

        dev      = priv->dev;

        dev_priv = dev->dev_private;

        buf      = dev_priv->mmap_buffer;

        buf_priv = buf->dev_private;

        vma->vm_flags |= (VM_IO | VM_DONTCOPY);

        vma->vm_file = filp;

        buf_priv->currently_mapped = I810_BUF_MAPPED;

        unlock_kernel();

        if (remap_page_range(DRM_RPR_ARG(vma) vma->vm_start,

                             VM_OFFSET(vma),

                             vma->vm_end - vma->vm_start,

                             vma->vm_page_prot)) return -EAGAIN;

        return 0;

}

static int i810_map_buffer(drm_buf_t *buf, struct file *filp)

{

        drm_file_t        *priv   = filp->private_data;

        drm_device_t      *dev    = priv->dev;

        drm_i810_buf_priv_t *buf_priv = buf->dev_private;

        drm_i810_private_t *dev_priv = dev->dev_private;

        struct file_operations *old_fops;

        int retcode = 0;

        if(buf_priv->currently_mapped == I810_BUF_MAPPED) return -EINVAL;

        down_write( &current->mm->mmap_sem );

        old_fops = filp->f_op;

        filp->f_op = &i810_buffer_fops;

        dev_priv->mmap_buffer = buf;

        buf_priv->virtual = (void *)do_mmap(filp, 0, buf->total,

                                            PROT_READ|PROT_WRITE,

                                            MAP_SHARED,

                                            buf->bus_address);

        dev_priv->mmap_buffer = NULL;

        filp->f_op = old_fops;

        if ((unsigned long)buf_priv->virtual > -1024UL) {

                /* Real error */

                DRM_DEBUG("mmap error\n");

                retcode = (signed int)buf_priv->virtual;

                buf_priv->virtual = 0;

        }

        up_write( &current->mm->mmap_sem );

        return retcode;

}

static int i810_unmap_buffer(drm_buf_t *buf)

{

        drm_i810_buf_priv_t *buf_priv = buf->dev_private;

        int retcode = 0;

        if(buf_priv->currently_mapped != I810_BUF_MAPPED)

                return -EINVAL;

        down_write( &current->mm->mmap_sem );

        retcode = DO_MUNMAP(current->mm,

                            (unsigned long)buf_priv->virtual,

                            (size_t) buf->total);

        up_write( &current->mm->mmap_sem );

        buf_priv->currently_mapped = I810_BUF_UNMAPPED;

        buf_priv->virtual = 0;

        return retcode;

}

static int i810_dma_get_buffer(drm_device_t *dev, drm_i810_dma_t *d,

                               struct file *filp)

{

        drm_file_t        *priv   = filp->private_data;

        drm_buf_t         *buf;

        drm_i810_buf_priv_t *buf_priv;

        int retcode = 0;

        buf = i810_freelist_get(dev);

        if (!buf) {

                retcode = -ENOMEM;

                DRM_DEBUG("retcode=%d\n", retcode);

                return retcode;

        }

        retcode = i810_map_buffer(buf, filp);

        if(retcode) {

                i810_freelist_put(dev, buf);

                DRM_DEBUG("mapbuf failed, retcode %d\n", retcode);

                return retcode;

        }

        buf->pid     = priv->pid;

        buf_priv = buf->dev_private;

        d->granted = 1;

        d->request_idx = buf->idx;

        d->request_size = buf->total;

        d->virtual = buf_priv->virtual;

        return retcode;

}

static int i810_dma_cleanup(drm_device_t *dev)

{

        drm_device_dma_t *dma = dev->dma;

        if(dev->dev_private) {

                int i;

                drm_i810_private_t *dev_priv =

                        (drm_i810_private_t *) dev->dev_private;

                if(dev_priv->ring.virtual_start) {

                        DRM(ioremapfree)((void *) dev_priv->ring.virtual_start,

                                         dev_priv->ring.Size, dev);

                }

                if(dev_priv->hw_status_page != 0UL) {

                        pci_free_consistent(dev->pdev, PAGE_SIZE,

                                            (void *)dev_priv->hw_status_page,

                                            dev_priv->dma_status_page);

                        /* Need to rewrite hardware status page */

                        I810_WRITE(0x02080, 0x1ffff000);

                }

                DRM(free)(dev->dev_private, sizeof(drm_i810_private_t),

                         DRM_MEM_DRIVER);

                dev->dev_private = NULL;

                for (i = 0; i < dma->buf_count; i++) {

                        drm_buf_t *buf = dma->buflist[ i ];

                        drm_i810_buf_priv_t *buf_priv = buf->dev_private;

                        DRM(ioremapfree)(buf_priv->kernel_virtual, buf->total, dev);

                }

        }

        return 0;

}

static int i810_wait_ring(drm_device_t *dev, int n)

{

        drm_i810_private_t *dev_priv = dev->dev_private;

        drm_i810_ring_buffer_t *ring = &(dev_priv->ring);

        int iters = 0;

        unsigned long end;

        unsigned int last_head = I810_READ(LP_RING + RING_HEAD) & HEAD_ADDR;

        end = jiffies + (HZ*3);

        while (ring->space < n) {

                ring->head = I810_READ(LP_RING + RING_HEAD) & HEAD_ADDR;

                ring->space = ring->head - (ring->tail+8);

                if (ring->space < 0) ring->space += ring->Size;

                if (ring->head != last_head)

                   end = jiffies + (HZ*3);

                iters++;

                if(time_before(end, jiffies)) {

                        DRM_ERROR("space: %d wanted %d\n", ring->space, n);

                        DRM_ERROR("lockup\n");

                        goto out_wait_ring;

                }

                udelay(1);

        }

out_wait_ring:

        return iters;

}

static void i810_kernel_lost_context(drm_device_t *dev)

{

        drm_i810_private_t *dev_priv = dev->dev_private;

        drm_i810_ring_buffer_t *ring = &(dev_priv->ring);

        ring->head = I810_READ(LP_RING + RING_HEAD) & HEAD_ADDR;

        ring->tail = I810_READ(LP_RING + RING_TAIL);

        ring->space = ring->head - (ring->tail+8);

        if (ring->space < 0) ring->space += ring->Size;

}

static int i810_freelist_init(drm_device_t *dev, drm_i810_private_t *dev_priv)

{

        drm_device_dma_t *dma = dev->dma;

        int my_idx = 24;

        u32 *hw_status = (u32 *)(dev_priv->hw_status_page + my_idx);

        int i;

        if(dma->buf_count > 1019) {

                /* Not enough space in the status page for the freelist */

                return -EINVAL;

        }

        for (i = 0; i < dma->buf_count; i++) {

                drm_buf_t *buf = dma->buflist[ i ];

                drm_i810_buf_priv_t *buf_priv = buf->dev_private;

                buf_priv->in_use = hw_status++;

                buf_priv->my_use_idx = my_idx;

                my_idx += 4;

                *buf_priv->in_use = I810_BUF_FREE;

                buf_priv->kernel_virtual = DRM(ioremap)(buf->bus_address,

                                                        buf->total, dev);

        }

        return 0;

}

static int i810_dma_initialize(drm_device_t *dev,

                               drm_i810_private_t *dev_priv,

                               drm_i810_init_t *init)

{

        struct list_head *list;

        memset(dev_priv, 0, sizeof(drm_i810_private_t));

        list_for_each(list, &dev->maplist->head) {

                drm_map_list_t *r_list = (drm_map_list_t *)list;

                if( r_list->map &&

                    r_list->map->type == _DRM_SHM &&

                    r_list->map->flags & _DRM_CONTAINS_LOCK ) {

                        dev_priv->sarea_map = r_list->map;

                        break;

                }

        }

        if(!dev_priv->sarea_map) {

                dev->dev_private = (void *)dev_priv;

                i810_dma_cleanup(dev);

                DRM_ERROR("can not find sarea!\n");

                return -EINVAL;

        }

        DRM_FIND_MAP( dev_priv->mmio_map, init->mmio_offset );

        if(!dev_priv->mmio_map) {

                dev->dev_private = (void *)dev_priv;

                i810_dma_cleanup(dev);

                DRM_ERROR("can not find mmio map!\n");

                return -EINVAL;

        }

        DRM_FIND_MAP( dev_priv->buffer_map, init->buffers_offset );

        if(!dev_priv->buffer_map) {

                dev->dev_private = (void *)dev_priv;

                i810_dma_cleanup(dev);

                DRM_ERROR("can not find dma buffer map!\n");

                return -EINVAL;

        }

        dev_priv->sarea_priv = (drm_i810_sarea_t *)

                ((u8 *)dev_priv->sarea_map->handle +

                 init->sarea_priv_offset);

        dev_priv->ring.Start = init->ring_start;

        dev_priv->ring.End = init->ring_end;

        dev_priv->ring.Size = init->ring_size;

        dev_priv->ring.virtual_start = DRM(ioremap)(dev->agp->base +

                                                    init->ring_start,

                                                    init->ring_size, dev);

        if (dev_priv->ring.virtual_start == NULL) {

                dev->dev_private = (void *) dev_priv;

                i810_dma_cleanup(dev);

                DRM_ERROR("can not ioremap virtual address for"

                          " ring buffer\n");

                return -ENOMEM;

        }

        dev_priv->ring.tail_mask = dev_priv->ring.Size - 1;

        dev_priv->w = init->w;

        dev_priv->h = init->h;

        dev_priv->pitch = init->pitch;

        dev_priv->back_offset = init->back_offset;

        dev_priv->depth_offset = init->depth_offset;

        dev_priv->overlay_offset = init->overlay_offset;

        dev_priv->overlay_physical = init->overlay_physical;

        dev_priv->front_di1 = init->front_offset | init->pitch_bits;

        dev_priv->back_di1 = init->back_offset | init->pitch_bits;

        dev_priv->zi1 = init->depth_offset | init->pitch_bits;

        /* Program Hardware Status Page */

        dev_priv->hw_status_page =

                (unsigned long) pci_alloc_consistent(dev->pdev, PAGE_SIZE,

                                                &dev_priv->dma_status_page);

        if(dev_priv->hw_status_page == 0UL) {

                dev->dev_private = (void *)dev_priv;

                i810_dma_cleanup(dev);

                DRM_ERROR("Can not allocate hardware status page\n");

                return -ENOMEM;

        }

        memset((void *) dev_priv->hw_status_page, 0, PAGE_SIZE);

        DRM_DEBUG("hw status page @ %lx\n", dev_priv->hw_status_page);

        I810_WRITE(0x02080, dev_priv->dma_status_page);

        DRM_DEBUG("Enabled hardware status page\n");

        /* Now we need to init our freelist */

        if(i810_freelist_init(dev, dev_priv) != 0) {

                dev->dev_private = (void *)dev_priv;

                i810_dma_cleanup(dev);

                DRM_ERROR("Not enough space in the status page for"

                          " the freelist\n");

                return -ENOMEM;

        }

        dev->dev_private = (void *)dev_priv;

        return 0;

}

#ifdef CONFIG_DRM_I810_XFREE_41

int xfreeversion = 41;

#else

int xfreeversion = -1;

#endif

MODULE_PARM(xfreeversion, "i");

MODULE_PARM_DESC(xfreeversion, "The version of XFree86 that needs to be supported");

int i810_dma_init(struct inode *inode, struct file *filp,

                  unsigned int cmd, unsigned long arg)

{

        drm_file_t *priv = filp->private_data;

        drm_device_t *dev = priv->dev;

        drm_i810_private_t *dev_priv;

        drm_i810_init_t init;

        int retcode = 0;

        if (copy_from_user(&init, (drm_i810_init_t *)arg, sizeof(init)))

                return -EFAULT;

        if ((xfreeversion == 41) ||

            ((xfreeversion == -1) && (init.pitch == 0))) {

                /*

                 * Ok we have a problem here.  Someone decided it was

                 * funny to add two fields in the middle of the

                 * drm_i810_init_it structure in the transition between

                 * XFree86 4.1.0 and 4.2.0.

                 *

                 * The code below tries to fix this ABI breakage up as

                 * good as possible, unfortionatly it's impossible to

                 * autodetect which interface the user wants, hence the

                 * module parameter -- Arjan

                 */

                init.pitch_bits = init.h;

                init.pitch = init.w;

                init.h = init.overlay_physical;

                init.w = init.overlay_offset;

                init.overlay_physical = 0;

                init.overlay_offset = 0;

        }

        switch(init.func) {

                case I810_INIT_DMA:

                        dev_priv = DRM(alloc)(sizeof(drm_i810_private_t),

                                             DRM_MEM_DRIVER);

                        if(dev_priv == NULL) return -ENOMEM;

                        retcode = i810_dma_initialize(dev, dev_priv, &init);

                break;

                case I810_CLEANUP_DMA:

                        retcode = i810_dma_cleanup(dev);

                break;

                default:

                        retcode = -EINVAL;

                break;

        }

        return retcode;

}

/* Most efficient way to verify state for the i810 is as it is

 * emitted.  Non-conformant state is silently dropped.

 */

static void i810EmitContextVerified( drm_device_t *dev,

                                     unsigned int *code )

{

        drm_i810_private_t *dev_priv = dev->dev_private;

        int i, j = 0;

        RING_LOCALS;

        BEGIN_LP_RING( I810_CTX_SETUP_SIZE );

        OUT_RING( GFX_OP_COLOR_FACTOR );

        OUT_RING( code[I810_CTXREG_CF1] );

        OUT_RING( GFX_OP_STIPPLE );

        OUT_RING( code[I810_CTXREG_ST1] );

        for ( i = 4 ; i < I810_CTX_SETUP_SIZE ; i++ ) {

                if ((code[i] & (7<<29)) == (3<<29) &&

                    (code[i] & (0x1f<<24)) < (0x1d<<24))

                {

                        OUT_RING( code[i] );

                        j++;

                }

                else printk("constext state dropped!!!\n");

        }

        if (j & 1)

                OUT_RING( 0 );

        ADVANCE_LP_RING();

}

static void i810EmitTexVerified( drm_device_t *dev,

                                 volatile unsigned int *code )

{

        drm_i810_private_t *dev_priv = dev->dev_private;

        int i, j = 0;

        RING_LOCALS;

        BEGIN_LP_RING( I810_TEX_SETUP_SIZE );

        OUT_RING( GFX_OP_MAP_INFO );

        OUT_RING( code[I810_TEXREG_MI1] );

        OUT_RING( code[I810_TEXREG_MI2] );

        OUT_RING( code[I810_TEXREG_MI3] );

        for ( i = 4 ; i < I810_TEX_SETUP_SIZE ; i++ ) {

                if ((code[i] & (7<<29)) == (3<<29) &&

                    (code[i] & (0x1f<<24)) < (0x1d<<24))

                {

                        OUT_RING( code[i] );

                        j++;

                }

                else printk("texture state dropped!!!\n");

        }

        if (j & 1)

                OUT_RING( 0 );

        ADVANCE_LP_RING();

}

/* Need to do some additional checking when setting the dest buffer.

 */

static void i810EmitDestVerified( drm_device_t *dev,

                                  volatile unsigned int *code )

{

        drm_i810_private_t *dev_priv = dev->dev_private;

        unsigned int tmp;

        RING_LOCALS;

        BEGIN_LP_RING( I810_DEST_SETUP_SIZE + 2 );

        tmp = code[I810_DESTREG_DI1];

        if (tmp == dev_priv->front_di1 || tmp == dev_priv->back_di1) {

                OUT_RING( CMD_OP_DESTBUFFER_INFO );

                OUT_RING( tmp );

        }

        else

           printk("buffer state dropped\n");

        /* invarient:

         */

        OUT_RING( CMD_OP_Z_BUFFER_INFO );

        OUT_RING( dev_priv->zi1 );

        OUT_RING( GFX_OP_DESTBUFFER_VARS );

        OUT_RING( code[I810_DESTREG_DV1] );

        OUT_RING( GFX_OP_DRAWRECT_INFO );

        OUT_RING( code[I810_DESTREG_DR1] );

        OUT_RING( code[I810_DESTREG_DR2] );

        OUT_RING( code[I810_DESTREG_DR3] );

        OUT_RING( code[I810_DESTREG_DR4] );

        OUT_RING( 0 );

        ADVANCE_LP_RING();

}

static void i810EmitState( drm_device_t *dev )

{

        drm_i810_private_t *dev_priv = dev->dev_private;

        drm_i810_sarea_t *sarea_priv = dev_priv->sarea_priv;

        unsigned int dirty = sarea_priv->dirty;

        if (dirty & I810_UPLOAD_BUFFERS) {

                i810EmitDestVerified( dev, sarea_priv->BufferState );

                sarea_priv->dirty &= ~I810_UPLOAD_BUFFERS;

        }

        if (dirty & I810_UPLOAD_CTX) {