Added some debug printk's for shares_write problems that Steve is seeing

[linux-2.6.git] / drivers / char / drm / r128_cce.c

diff --git a/drivers/char/drm/r128_cce.c b/drivers/char/drm/r128_cce.c
index d0394a0..22d38b7 100644 (file)
--- a/drivers/char/drm/r128_cce.c
+++ b/drivers/char/drm/r128_cce.c
@@ -212,7 +212,7 @@ int r128_do_cce_idle( drm_r128_private_t *dev_priv )
        int i;
 
        for ( i = 0 ; i < dev_priv->usec_timeout ; i++ ) {
-               if ( GET_RING_HEAD( &dev_priv->ring ) == dev_priv->ring.tail ) {
+               if ( GET_RING_HEAD( dev_priv ) == dev_priv->ring.tail ) {
                        int pm4stat = R128_READ( R128_PM4_STAT );
                        if ( ( (pm4stat & R128_PM4_FIFOCNT_MASK) >=
                               dev_priv->cce_fifo_size ) &&
@@ -238,7 +238,8 @@ static void r128_do_cce_start( drm_r128_private_t *dev_priv )
        r128_do_wait_for_idle( dev_priv );
 
        R128_WRITE( R128_PM4_BUFFER_CNTL,
-                   dev_priv->cce_mode | dev_priv->ring.size_l2qw );
+                   dev_priv->cce_mode | dev_priv->ring.size_l2qw
+                   | R128_PM4_BUFFER_CNTL_NOUPDATE );
        R128_READ( R128_PM4_BUFFER_ADDR ); /* as per the sample code */
        R128_WRITE( R128_PM4_MICRO_CNTL, R128_PM4_MICRO_FREERUN );
 
@@ -253,7 +254,6 @@ static void r128_do_cce_reset( drm_r128_private_t *dev_priv )
 {
        R128_WRITE( R128_PM4_BUFFER_DL_WPTR, 0 );
        R128_WRITE( R128_PM4_BUFFER_DL_RPTR, 0 );
-       SET_RING_HEAD( &dev_priv->ring, 0 );
        dev_priv->ring.tail = 0;
 }
 
@@ -264,7 +264,8 @@ static void r128_do_cce_reset( drm_r128_private_t *dev_priv )
 static void r128_do_cce_stop( drm_r128_private_t *dev_priv )
 {
        R128_WRITE( R128_PM4_MICRO_CNTL, 0 );
-       R128_WRITE( R128_PM4_BUFFER_CNTL, R128_PM4_NONPM4 );
+       R128_WRITE( R128_PM4_BUFFER_CNTL,
+                   R128_PM4_NONPM4 | R128_PM4_BUFFER_CNTL_NOUPDATE );
 
        dev_priv->cce_running = 0;
 }
@@ -333,26 +334,6 @@ static void r128_cce_init_ring_buffer( drm_device_t *dev,
        R128_WRITE( R128_PM4_BUFFER_DL_WPTR, 0 );
        R128_WRITE( R128_PM4_BUFFER_DL_RPTR, 0 );
 
-       /* DL_RPTR_ADDR is a physical address in AGP space. */
-       SET_RING_HEAD( &dev_priv->ring, 0 );
-
-       if ( !dev_priv->is_pci ) {
-               R128_WRITE( R128_PM4_BUFFER_DL_RPTR_ADDR,
-                           dev_priv->ring_rptr->offset );
-       } else {
-               drm_sg_mem_t *entry = dev->sg;
-               unsigned long tmp_ofs, page_ofs;
-
-               tmp_ofs = dev_priv->ring_rptr->offset - dev->sg->handle;
-               page_ofs = tmp_ofs >> PAGE_SHIFT;
-
-               R128_WRITE( R128_PM4_BUFFER_DL_RPTR_ADDR,
-                           entry->busaddr[page_ofs]);
-               DRM_DEBUG( "ring rptr: offset=0x%08lx handle=0x%08lx\n",
-                          (unsigned long) entry->busaddr[page_ofs],
-                          entry->handle + tmp_ofs );
-       }
-
        /* Set watermark control */
        R128_WRITE( R128_PM4_BUFFER_WM_CNTL,
                    ((R128_WATERMARK_L/4) << R128_WMA_SHIFT)
@@ -486,13 +467,6 @@ static int r128_do_init_cce( drm_device_t *dev, drm_r128_init_t *init )
                return DRM_ERR(EINVAL);
        }
 
-       DRM_FIND_MAP( dev_priv->fb, init->fb_offset );
-       if(!dev_priv->fb) {
-               DRM_ERROR("could not find framebuffer!\n");
-               dev->dev_private = (void *)dev_priv;
-               r128_do_cleanup_cce( dev );
-               return DRM_ERR(EINVAL);
-       }
        DRM_FIND_MAP( dev_priv->mmio, init->mmio_offset );
        if(!dev_priv->mmio) {
                DRM_ERROR("could not find mmio region!\n");
@@ -567,9 +541,6 @@ static int r128_do_init_cce( drm_device_t *dev, drm_r128_init_t *init )
 #endif
                dev_priv->cce_buffers_offset = dev->sg->handle;
 
-       dev_priv->ring.head = ((__volatile__ u32 *)
-                              dev_priv->ring_rptr->handle);
-
        dev_priv->ring.start = (u32 *)dev_priv->cce_ring->handle;
        dev_priv->ring.end = ((u32 *)dev_priv->cce_ring->handle
                              + init->ring_size / sizeof(u32));
@@ -580,7 +551,6 @@ static int r128_do_init_cce( drm_device_t *dev, drm_r128_init_t *init )
                (dev_priv->ring.size / sizeof(u32)) - 1;
 
        dev_priv->ring.high_mark = 128;
-       dev_priv->ring.ring_rptr = dev_priv->ring_rptr;
 
        dev_priv->sarea_priv->last_frame = 0;
        R128_WRITE( R128_LAST_FRAME_REG, dev_priv->sarea_priv->last_frame );
@@ -589,8 +559,9 @@ static int r128_do_init_cce( drm_device_t *dev, drm_r128_init_t *init )
        R128_WRITE( R128_LAST_DISPATCH_REG,
                    dev_priv->sarea_priv->last_dispatch );
 
-#if __REALLY_HAVE_SG
+#if __REALLY_HAVE_AGP
        if ( dev_priv->is_pci ) {
+#endif
                if (!DRM(ati_pcigart_init)( dev, &dev_priv->phys_pci_gart,
                                            &dev_priv->bus_pci_gart) ) {
                        DRM_ERROR( "failed to init PCI GART!\n" );
@@ -599,6 +570,7 @@ static int r128_do_init_cce( drm_device_t *dev, drm_r128_init_t *init )
                        return DRM_ERR(ENOMEM);
                }
                R128_WRITE( R128_PCI_GART_PAGE, dev_priv->bus_pci_gart );
+#if __REALLY_HAVE_AGP
        }
 #endif
 
@@ -615,12 +587,12 @@ static int r128_do_init_cce( drm_device_t *dev, drm_r128_init_t *init )
 int r128_do_cleanup_cce( drm_device_t *dev )
 {
 
-#if _HAVE_DMA_IRQ
+#if __HAVE_IRQ
        /* Make sure interrupts are disabled here because the uninstall ioctl
         * may not have been called from userspace and after dev_private
         * is freed, it's too late.
         */
-       if ( dev->irq ) DRM(irq_uninstall)(dev);
+       if ( dev->irq_enabled ) DRM(irq_uninstall)(dev);
 #endif
 
        if ( dev->dev_private ) {
@@ -660,7 +632,7 @@ int r128_cce_init( DRM_IOCTL_ARGS )
 
        LOCK_TEST_WITH_RETURN( dev, filp );
 
-       DRM_COPY_FROM_USER_IOCTL( init, (drm_r128_init_t *)data, sizeof(init) );
+       DRM_COPY_FROM_USER_IOCTL( init, (drm_r128_init_t __user *)data, sizeof(init) );
 
        switch ( init.func ) {
        case R128_INIT_CCE:
@@ -703,7 +675,7 @@ int r128_cce_stop( DRM_IOCTL_ARGS )
 
        LOCK_TEST_WITH_RETURN( dev, filp );
 
-       DRM_COPY_FROM_USER_IOCTL(stop, (drm_r128_cce_stop_t *)data, sizeof(stop) );
+       DRM_COPY_FROM_USER_IOCTL(stop, (drm_r128_cce_stop_t __user *)data, sizeof(stop) );
 
        /* Flush any pending CCE commands.  This ensures any outstanding
         * commands are exectuted by the engine before we turn it off.
@@ -901,7 +873,7 @@ int r128_wait_ring( drm_r128_private_t *dev_priv, int n )
        int i;
 
        for ( i = 0 ; i < dev_priv->usec_timeout ; i++ ) {
-               r128_update_ring_snapshot( ring );
+               r128_update_ring_snapshot( dev_priv );
                if ( ring->space >= n )
                        return 0;
                DRM_UDELAY( 1 );
@@ -940,11 +912,12 @@ int r128_cce_buffers( DRM_IOCTL_ARGS )
        DRM_DEVICE;
        drm_device_dma_t *dma = dev->dma;
        int ret = 0;
+       drm_dma_t __user *argp = (void __user *)data;
        drm_dma_t d;
 
        LOCK_TEST_WITH_RETURN( dev, filp );
 
-       DRM_COPY_FROM_USER_IOCTL( d, (drm_dma_t *) data, sizeof(d) );
+       DRM_COPY_FROM_USER_IOCTL( d, argp, sizeof(d) );
 
        /* Please don't send us buffers.
         */
@@ -968,7 +941,7 @@ int r128_cce_buffers( DRM_IOCTL_ARGS )
                ret = r128_cce_get_buffers( filp, dev, &d );
        }
 
-       DRM_COPY_TO_USER_IOCTL((drm_dma_t *) data, d, sizeof(d) );
+       DRM_COPY_TO_USER_IOCTL(argp, d, sizeof(d) );
 
        return ret;
 }