struct page *page;
        int i;
 
-       DRM_DEBUG("%s: alloc %d order\n", __FUNCTION__, order);
+       DRM_DEBUG("%d order\n", order);
 
        address = __get_free_pages(GFP_KERNEL | __GFP_COMP,
                                   order);
        for (i = 0; i < order; i++, page++)
                SetPageReserved(page);
 
-       DRM_DEBUG("%s: returning 0x%08lx\n", __FUNCTION__, address);
+       DRM_DEBUG("returning 0x%08lx\n", address);
        return (void *)address;
 }
 
        struct page *page;
        int i;
        int num_pages = 1 << order;
-       DRM_DEBUG("%s\n", __FUNCTION__);
+       DRM_DEBUG("\n");
 
        page = virt_to_page((unsigned long)address);
 
 
        dev->irq_enabled = 1;
        mutex_unlock(&dev->struct_mutex);
 
-       DRM_DEBUG("%s: irq=%d\n", __FUNCTION__, dev->irq);
+       DRM_DEBUG("irq=%d\n", dev->irq);
 
        if (drm_core_check_feature(dev, DRIVER_IRQ_VBL)) {
                init_waitqueue_head(&dev->vbl_queue);
        if (!irq_enabled)
                return -EINVAL;
 
-       DRM_DEBUG("%s: irq=%d\n", __FUNCTION__, dev->irq);
+       DRM_DEBUG("irq=%d\n", dev->irq);
 
        dev->driver->irq_uninstall(dev);
 
 
        struct drm_sg_mem *entry;
        unsigned long pages, i, j;
 
-       DRM_DEBUG("%s\n", __FUNCTION__);
+       DRM_DEBUG("\n");
 
        if (!drm_core_check_feature(dev, DRIVER_SG))
                return -EINVAL;
 
        memset(entry, 0, sizeof(*entry));
        pages = (request->size + PAGE_SIZE - 1) / PAGE_SIZE;
-       DRM_DEBUG("sg size=%ld pages=%ld\n", request->size, pages);
+       DRM_DEBUG("size=%ld pages=%ld\n", request->size, pages);
 
        entry->pages = pages;
        entry->pagelist = drm_alloc(pages * sizeof(*entry->pagelist),
 
        entry->handle = ScatterHandle((unsigned long)entry->virtual);
 
-       DRM_DEBUG("sg alloc handle  = %08lx\n", entry->handle);
-       DRM_DEBUG("sg alloc virtual = %p\n", entry->virtual);
+       DRM_DEBUG("handle  = %08lx\n", entry->handle);
+       DRM_DEBUG("virtual = %p\n", entry->virtual);
 
        for (i = (unsigned long)entry->virtual, j = 0; j < pages;
             i += PAGE_SIZE, j++) {
        if (!entry || entry->handle != request->handle)
                return -EINVAL;
 
-       DRM_DEBUG("sg free virtual  = %p\n", entry->virtual);
+       DRM_DEBUG("virtual  = %p\n", entry->virtual);
 
        drm_sg_cleanup(entry);
 
 
                return NOPAGE_SIGBUS;
        get_page(page);
 
-       DRM_DEBUG("shm_nopage 0x%lx\n", address);
+       DRM_DEBUG("0x%lx\n", address);
        return page;
 }
 
 
        get_page(page);
 
-       DRM_DEBUG("dma_nopage 0x%lx (page %lu)\n", address, page_nr);
+       DRM_DEBUG("0x%lx (page %lu)\n", address, page_nr);
        return page;
 }
 
 
        drm_i810_sarea_t *sarea_priv = dev_priv->sarea_priv;
        unsigned int dirty = sarea_priv->dirty;
 
-       DRM_DEBUG("%s %x\n", __FUNCTION__, dirty);
+       DRM_DEBUG("%x\n", dirty);
 
        if (dirty & I810_UPLOAD_BUFFERS) {
                i810EmitDestVerified(dev, sarea_priv->BufferState);
        int pitch = dev_priv->pitch;
        RING_LOCALS;
 
-       DRM_DEBUG("%s: page=%d pfCurrentPage=%d\n",
-                 __FUNCTION__,
+       DRM_DEBUG("page=%d pfCurrentPage=%d\n",
                  dev_priv->current_page,
                  dev_priv->sarea_priv->pf_current_page);
 
        drm_i810_private_t *dev_priv = dev->dev_private;
        RING_LOCALS;
 
-/*     printk("%s\n", __FUNCTION__); */
-
        i810_kernel_lost_context(dev);
 
        BEGIN_LP_RING(4);
        int i, ret = 0;
        RING_LOCALS;
 
-/*     printk("%s\n", __FUNCTION__); */
-
        i810_kernel_lost_context(dev);
 
        BEGIN_LP_RING(2);
 
        LOCK_TEST_WITH_RETURN(dev, file_priv);
 
-       DRM_DEBUG("i810 dma vertex, idx %d used %d discard %d\n",
+       DRM_DEBUG("idx %d used %d discard %d\n",
                  vertex->idx, vertex->used, vertex->discard);
 
        if (vertex->idx < 0 || vertex->idx > dma->buf_count)
 static int i810_swap_bufs(struct drm_device *dev, void *data,
                          struct drm_file *file_priv)
 {
-       DRM_DEBUG("i810_swap_bufs\n");
+       DRM_DEBUG("\n");
 
        LOCK_TEST_WITH_RETURN(dev, file_priv);
 
 
        sarea_priv->dirty = 0x7f;
 
-       DRM_DEBUG("dispatch mc addr 0x%lx, used 0x%x\n", address, used);
+       DRM_DEBUG("addr 0x%lx, used 0x%x\n", address, used);
 
        dev_priv->counter++;
        DRM_DEBUG("dispatch counter : %ld\n", dev_priv->counter);
-       DRM_DEBUG("i810_dma_dispatch_mc\n");
        DRM_DEBUG("start : %lx\n", start);
        DRM_DEBUG("used : %d\n", used);
        DRM_DEBUG("start + used - 4 : %ld\n", start + used - 4);
 {
        drm_i810_private_t *dev_priv = dev->dev_private;
 
-       DRM_DEBUG("%s\n", __FUNCTION__);
+       DRM_DEBUG("\n");
        dev_priv->page_flipping = 1;
        dev_priv->current_page = 0;
        dev_priv->sarea_priv->pf_current_page = dev_priv->current_page;
 {
        drm_i810_private_t *dev_priv = dev->dev_private;
 
-       DRM_DEBUG("%s\n", __FUNCTION__);
+       DRM_DEBUG("\n");
        if (dev_priv->current_page != 0)
                i810_dma_dispatch_flip(dev);
 
 {
        drm_i810_private_t *dev_priv = dev->dev_private;
 
-       DRM_DEBUG("%s\n", __FUNCTION__);
+       DRM_DEBUG("\n");
 
        LOCK_TEST_WITH_RETURN(dev, file_priv);
 
 
 
 #define BEGIN_LP_RING(n) do {                                          \
        if (I810_VERBOSE)                                               \
-           DRM_DEBUG("BEGIN_LP_RING(%d) in %s\n", n, __FUNCTION__);    \
+               DRM_DEBUG("BEGIN_LP_RING(%d)\n", n);                    \
        if (dev_priv->ring.space < n*4)                                 \
                i810_wait_ring(dev, n*4);                               \
        dev_priv->ring.space -= n*4;                                    \
 
 
 #define BEGIN_LP_RING(n) do {                          \
        if (I830_VERBOSE)                               \
-               printk("BEGIN_LP_RING(%d) in %s\n",     \
-                         n, __FUNCTION__);             \
+               printk("BEGIN_LP_RING(%d)\n", (n));     \
        if (dev_priv->ring.space < n*4)                 \
                i830_wait_ring(dev, n*4, __FUNCTION__);         \
        outcount = 0;                                   \
 
        int value;
 
        if (!dev_priv) {
-               DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
+               DRM_ERROR("called with no initialization\n");
                return -EINVAL;
        }
 
        drm_i915_setparam_t *param = data;
 
        if (!dev_priv) {
-               DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
+               DRM_ERROR("called with no initialization\n");
                return -EINVAL;
        }
 
        drm_i915_hws_addr_t *hws = data;
 
        if (!dev_priv) {
-               DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
+               DRM_ERROR("called with no initialization\n");
                return -EINVAL;
        }
 
 
 
 #define BEGIN_LP_RING(n) do {                          \
        if (I915_VERBOSE)                               \
-               DRM_DEBUG("BEGIN_LP_RING(%d) in %s\n",  \
-                         (n), __FUNCTION__);           \
-       if (dev_priv->ring.space < (n)*4)                       \
+               DRM_DEBUG("BEGIN_LP_RING(%d)\n", (n));  \
+       if (dev_priv->ring.space < (n)*4)               \
                i915_wait_ring(dev, (n)*4, __FUNCTION__);               \
        outcount = 0;                                   \
        outring = dev_priv->ring.tail;                  \
 
 
        i915_kernel_lost_context(dev);
 
-       DRM_DEBUG("%s\n", __FUNCTION__);
+       DRM_DEBUG("\n");
 
        dev_priv->sarea_priv->last_enqueue = ++dev_priv->counter;
 
        drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
        int ret = 0;
 
-       DRM_DEBUG("%s irq_nr=%d breadcrumb=%d\n", __FUNCTION__, irq_nr,
+       DRM_DEBUG("irq_nr=%d breadcrumb=%d\n", irq_nr,
                  READ_BREADCRUMB(dev_priv));
 
        if (READ_BREADCRUMB(dev_priv) >= irq_nr)
                    READ_BREADCRUMB(dev_priv) >= irq_nr);
 
        if (ret == -EBUSY) {
-               DRM_ERROR("%s: EBUSY -- rec: %d emitted: %d\n",
-                         __FUNCTION__,
+               DRM_ERROR("EBUSY -- rec: %d emitted: %d\n",
                          READ_BREADCRUMB(dev_priv), (int)dev_priv->counter);
        }
 
        int ret = 0;
 
        if (!dev_priv) {
-               DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
+               DRM_ERROR("called with no initialization\n");
                return -EINVAL;
        }
 
        LOCK_TEST_WITH_RETURN(dev, file_priv);
 
        if (!dev_priv) {
-               DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
+               DRM_ERROR("called with no initialization\n");
                return -EINVAL;
        }
 
        drm_i915_irq_wait_t *irqwait = data;
 
        if (!dev_priv) {
-               DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
+               DRM_ERROR("called with no initialization\n");
                return -EINVAL;
        }
 
        drm_i915_vblank_pipe_t *pipe = data;
 
        if (!dev_priv) {
-               DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
+               DRM_ERROR("called with no initialization\n");
                return -EINVAL;
        }
 
        if (pipe->pipe & ~(DRM_I915_VBLANK_PIPE_A|DRM_I915_VBLANK_PIPE_B)) {
-               DRM_ERROR("%s called with invalid pipe 0x%x\n",
-                         __FUNCTION__, pipe->pipe);
+               DRM_ERROR("called with invalid pipe 0x%x\n", pipe->pipe);
                return -EINVAL;
        }
 
        u16 flag;
 
        if (!dev_priv) {
-               DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
+               DRM_ERROR("called with no initialization\n");
                return -EINVAL;
        }
 
 
        struct mem_block *block, **heap;
 
        if (!dev_priv) {
-               DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
+               DRM_ERROR("called with no initialization\n");
                return -EINVAL;
        }
 
        struct mem_block *block, **heap;
 
        if (!dev_priv) {
-               DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
+               DRM_ERROR("called with no initialization\n");
                return -EINVAL;
        }
 
        struct mem_block **heap;
 
        if (!dev_priv) {
-               DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
+               DRM_ERROR("called with no initialization\n");
                return -EINVAL;
        }
 
        struct mem_block **heap;
 
        if ( !dev_priv ) {
-               DRM_ERROR( "%s called with no initialization\n", __FUNCTION__ );
+               DRM_ERROR( "called with no initialization\n" );
                return -EINVAL;
        }
 
 
 #if MGA_DMA_DEBUG
                int ret = mga_do_wait_for_idle(dev_priv);
                if (ret < 0)
-                       DRM_INFO("%s: -EBUSY\n", __FUNCTION__);
+                       DRM_INFO("-EBUSY\n");
                return ret;
 #else
                return mga_do_wait_for_idle(dev_priv);
 
                } else if ( dev_priv->prim.space <                      \
                            dev_priv->prim.high_mark ) {                \
                        if ( MGA_DMA_DEBUG )                            \
-                               DRM_INFO( "%s: wrap...\n", __FUNCTION__ );      \
+                               DRM_INFO( "wrap...\n");         \
                        return -EBUSY;                  \
                }                                                       \
        }                                                               \
        if ( test_bit( 0, &dev_priv->prim.wrapped ) ) {                 \
                if ( mga_do_wait_for_idle( dev_priv ) < 0 ) {           \
                        if ( MGA_DMA_DEBUG )                            \
-                               DRM_INFO( "%s: wrap...\n", __FUNCTION__ );      \
+                               DRM_INFO( "wrap...\n");         \
                        return -EBUSY;                  \
                }                                                       \
                mga_do_dma_wrap_end( dev_priv );                        \
 #define BEGIN_DMA( n )                                                 \
 do {                                                                   \
        if ( MGA_VERBOSE ) {                                            \
-               DRM_INFO( "BEGIN_DMA( %d ) in %s\n",                    \
-                         (n), __FUNCTION__ );                          \
+               DRM_INFO( "BEGIN_DMA( %d )\n", (n) );           \
                DRM_INFO( "   space=0x%x req=0x%Zx\n",                  \
                          dev_priv->prim.space, (n) * DMA_BLOCK_SIZE ); \
        }                                                               \
 #define BEGIN_DMA_WRAP()                                               \
 do {                                                                   \
        if ( MGA_VERBOSE ) {                                            \
-               DRM_INFO( "BEGIN_DMA() in %s\n", __FUNCTION__ );                \
+               DRM_INFO( "BEGIN_DMA()\n" );                            \
                DRM_INFO( "   space=0x%x\n", dev_priv->prim.space );    \
        }                                                               \
        prim = dev_priv->prim.start;                                    \
 #define FLUSH_DMA()                                                    \
 do {                                                                   \
        if ( 0 ) {                                                      \
-               DRM_INFO( "%s:\n", __FUNCTION__ );                              \
+               DRM_INFO( "\n" );                                       \
                DRM_INFO( "   tail=0x%06x head=0x%06lx\n",              \
                          dev_priv->prim.tail,                          \
                          MGA_READ( MGA_PRIMADDRESS ) -                 \
 
 
        FLUSH_DMA();
 
-       DRM_DEBUG("%s... done.\n", __FUNCTION__);
+       DRM_DEBUG("... done.\n");
 }
 
 static void mga_dma_dispatch_vertex(struct drm_device * dev, struct drm_buf * buf)
        u32 length = (u32) buf->used;
        int i = 0;
        DMA_LOCALS;
-       DRM_DEBUG("vertex: buf=%d used=%d\n", buf->idx, buf->used);
+       DRM_DEBUG("buf=%d used=%d\n", buf->idx, buf->used);
 
        if (buf->used) {
                buf_priv->dispatched = 1;
        u32 address = (u32) buf->bus_address;
        int i = 0;
        DMA_LOCALS;
-       DRM_DEBUG("indices: buf=%d start=%d end=%d\n", buf->idx, start, end);
+       DRM_DEBUG("buf=%d start=%d end=%d\n", buf->idx, start, end);
 
        if (start != end) {
                buf_priv->dispatched = 1;
 #if 0
        if (mga_do_wait_for_idle(dev_priv) < 0) {
                if (MGA_DMA_DEBUG)
-                       DRM_INFO("%s: -EBUSY\n", __FUNCTION__);
+                       DRM_INFO("-EBUSY\n");
                return -EBUSY;
        }
 #endif
        int value;
 
        if (!dev_priv) {
-               DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
+               DRM_ERROR("called with no initialization\n");
                return -EINVAL;
        }
 
        DMA_LOCALS;
 
        if (!dev_priv) {
-               DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
+               DRM_ERROR("called with no initialization\n");
                return -EINVAL;
        }
 
        u32 *fence = data;
 
        if (!dev_priv) {
-               DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
+               DRM_ERROR("called with no initialization\n");
                return -EINVAL;
        }
 
 
        LOCK_TEST_WITH_RETURN(dev, file_priv);
 
        if (dev_priv->cce_running || dev_priv->cce_mode == R128_PM4_NONPM4) {
-               DRM_DEBUG("%s while CCE running\n", __FUNCTION__);
+               DRM_DEBUG("while CCE running\n");
                return 0;
        }
 
        LOCK_TEST_WITH_RETURN(dev, file_priv);
 
        if (!dev_priv) {
-               DRM_DEBUG("%s called before init done\n", __FUNCTION__);
+               DRM_DEBUG("called before init done\n");
                return -EINVAL;
        }
 
 
 
 #define BEGIN_RING( n ) do {                                           \
        if ( R128_VERBOSE ) {                                           \
-               DRM_INFO( "BEGIN_RING( %d ) in %s\n",                   \
-                          (n), __FUNCTION__ );                         \
+               DRM_INFO( "BEGIN_RING( %d )\n", (n));                   \
        }                                                               \
        if ( dev_priv->ring.space <= (n) * sizeof(u32) ) {              \
                COMMIT_RING();                                          \
 
 {
        u32 aux_sc_cntl = 0x00000000;
        RING_LOCALS;
-       DRM_DEBUG("    %s\n", __FUNCTION__);
+       DRM_DEBUG("\n");
 
        BEGIN_RING((count < 3 ? count : 3) * 5 + 2);
 
        drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
        drm_r128_context_regs_t *ctx = &sarea_priv->context_state;
        RING_LOCALS;
-       DRM_DEBUG("    %s\n", __FUNCTION__);
+       DRM_DEBUG("\n");
 
        BEGIN_RING(2);
 
        drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
        drm_r128_context_regs_t *ctx = &sarea_priv->context_state;
        RING_LOCALS;
-       DRM_DEBUG("    %s\n", __FUNCTION__);
+       DRM_DEBUG("\n");
 
        BEGIN_RING(13);
 
        drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
        drm_r128_context_regs_t *ctx = &sarea_priv->context_state;
        RING_LOCALS;
-       DRM_DEBUG("    %s\n", __FUNCTION__);
+       DRM_DEBUG("\n");
 
        BEGIN_RING(3);
 
        drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
        drm_r128_context_regs_t *ctx = &sarea_priv->context_state;
        RING_LOCALS;
-       DRM_DEBUG("    %s\n", __FUNCTION__);
+       DRM_DEBUG("\n");
 
        BEGIN_RING(5);
 
        drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
        drm_r128_context_regs_t *ctx = &sarea_priv->context_state;
        RING_LOCALS;
-       DRM_DEBUG("    %s\n", __FUNCTION__);
+       DRM_DEBUG("\n");
 
        BEGIN_RING(2);
 
        drm_r128_texture_regs_t *tex = &sarea_priv->tex_state[0];
        int i;
        RING_LOCALS;
-       DRM_DEBUG("    %s\n", __FUNCTION__);
+       DRM_DEBUG("\n");
 
        BEGIN_RING(7 + R128_MAX_TEXTURE_LEVELS);
 
        drm_r128_texture_regs_t *tex = &sarea_priv->tex_state[1];
        int i;
        RING_LOCALS;
-       DRM_DEBUG("    %s\n", __FUNCTION__);
+       DRM_DEBUG("\n");
 
        BEGIN_RING(5 + R128_MAX_TEXTURE_LEVELS);
 
        drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
        unsigned int dirty = sarea_priv->dirty;
 
-       DRM_DEBUG("%s: dirty=0x%08x\n", __FUNCTION__, dirty);
+       DRM_DEBUG("dirty=0x%08x\n", dirty);
 
        if (dirty & R128_UPLOAD_CORE) {
                r128_emit_core(dev_priv);
        unsigned int flags = clear->flags;
        int i;
        RING_LOCALS;
-       DRM_DEBUG("%s\n", __FUNCTION__);
+       DRM_DEBUG("\n");
 
        if (dev_priv->page_flipping && dev_priv->current_page == 1) {
                unsigned int tmp = flags;
        struct drm_clip_rect *pbox = sarea_priv->boxes;
        int i;
        RING_LOCALS;
-       DRM_DEBUG("%s\n", __FUNCTION__);
+       DRM_DEBUG("\n");
 
 #if R128_PERFORMANCE_BOXES
        /* Do some trivial performance monitoring...
 {
        drm_r128_private_t *dev_priv = dev->dev_private;
        RING_LOCALS;
-       DRM_DEBUG("%s: page=%d pfCurrentPage=%d\n",
-                 __FUNCTION__,
+       DRM_DEBUG("page=%d pfCurrentPage=%d\n",
                  dev_priv->current_page, dev_priv->sarea_priv->pfCurrentPage);
 
 #if R128_PERFORMANCE_BOXES
        int count, *x, *y;
        int i, xbuf_size, ybuf_size;
        RING_LOCALS;
-       DRM_DEBUG("%s\n", __FUNCTION__);
+       DRM_DEBUG("\n");
 
        count = depth->n;
        if (count > 4096 || count <= 0)
        drm_r128_private_t *dev_priv = dev->dev_private;
        int i;
        RING_LOCALS;
-       DRM_DEBUG("%s\n", __FUNCTION__);
+       DRM_DEBUG("\n");
 
        BEGIN_RING(33);
 
 static int r128_cce_flip(struct drm_device *dev, void *data, struct drm_file *file_priv)
 {
        drm_r128_private_t *dev_priv = dev->dev_private;
-       DRM_DEBUG("%s\n", __FUNCTION__);
+       DRM_DEBUG("\n");
 
        LOCK_TEST_WITH_RETURN(dev, file_priv);
 
 {
        drm_r128_private_t *dev_priv = dev->dev_private;
        drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv;
-       DRM_DEBUG("%s\n", __FUNCTION__);
+       DRM_DEBUG("\n");
 
        LOCK_TEST_WITH_RETURN(dev, file_priv);
 
        LOCK_TEST_WITH_RETURN(dev, file_priv);
 
        if (!dev_priv) {
-               DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
+               DRM_ERROR("called with no initialization\n");
                return -EINVAL;
        }
 
        LOCK_TEST_WITH_RETURN(dev, file_priv);
 
        if (!dev_priv) {
-               DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
+               DRM_ERROR("called with no initialization\n");
                return -EINVAL;
        }
 
        LOCK_TEST_WITH_RETURN(dev, file_priv);
 
        if (!dev_priv) {
-               DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
+               DRM_ERROR("called with no initialization\n");
                return -EINVAL;
        }
 
-       DRM_DEBUG("indirect: idx=%d s=%d e=%d d=%d\n",
+       DRM_DEBUG("idx=%d s=%d e=%d d=%d\n",
                  indirect->idx, indirect->start, indirect->end,
                  indirect->discard);
 
        int value;
 
        if (!dev_priv) {
-               DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
+               DRM_ERROR("called with no initialization\n");
                return -EINVAL;
        }
 
 
        LOCK_TEST_WITH_RETURN(dev, file_priv);
 
        if (dev_priv->cp_running) {
-               DRM_DEBUG("%s while CP running\n", __FUNCTION__);
+               DRM_DEBUG("while CP running\n");
                return 0;
        }
        if (dev_priv->cp_mode == RADEON_CSQ_PRIDIS_INDDIS) {
-               DRM_DEBUG("%s called with bogus CP mode (%d)\n",
-                         __FUNCTION__, dev_priv->cp_mode);
+               DRM_DEBUG("called with bogus CP mode (%d)\n",
+                         dev_priv->cp_mode);
                return 0;
        }
 
        LOCK_TEST_WITH_RETURN(dev, file_priv);
 
        if (!dev_priv) {
-               DRM_DEBUG("%s called before init done\n", __FUNCTION__);
+               DRM_DEBUG("called before init done\n");
                return -EINVAL;
        }
 
 
 
 #define BEGIN_RING( n ) do {                                           \
        if ( RADEON_VERBOSE ) {                                         \
-               DRM_INFO( "BEGIN_RING( %d ) in %s\n",                   \
-                          n, __FUNCTION__ );                           \
+               DRM_INFO( "BEGIN_RING( %d )\n", (n));                   \
        }                                                               \
        if ( dev_priv->ring.space <= (n) * sizeof(u32) ) {              \
                 COMMIT_RING();                                         \
 
        int ack = 0;
        atomic_t *counter;
        if (!dev_priv) {
-               DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
+               DRM_ERROR("called with no initialization\n");
                return -EINVAL;
        }
 
        LOCK_TEST_WITH_RETURN(dev, file_priv);
 
        if (!dev_priv) {
-               DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
+               DRM_ERROR("called with no initialization\n");
                return -EINVAL;
        }
 
        drm_radeon_irq_wait_t *irqwait = data;
 
        if (!dev_priv) {
-               DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
+               DRM_ERROR("called with no initialization\n");
                return -EINVAL;
        }
 
 
        struct mem_block *block, **heap;
 
        if (!dev_priv) {
-               DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
+               DRM_ERROR("called with no initialization\n");
                return -EINVAL;
        }
 
        struct mem_block *block, **heap;
 
        if (!dev_priv) {
-               DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
+               DRM_ERROR("called with no initialization\n");
                return -EINVAL;
        }
 
        struct mem_block **heap;
 
        if (!dev_priv) {
-               DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
+               DRM_ERROR("called with no initialization\n");
                return -EINVAL;
        }
 
 
                        int w = pbox[i].x2 - x;
                        int h = pbox[i].y2 - y;
 
-                       DRM_DEBUG("dispatch clear %d,%d-%d,%d flags 0x%x\n",
+                       DRM_DEBUG("%d,%d-%d,%d flags 0x%x\n",
                                  x, y, w, h, flags);
 
                        if (flags & RADEON_FRONT) {
                int w = pbox[i].x2 - x;
                int h = pbox[i].y2 - y;
 
-               DRM_DEBUG("dispatch swap %d,%d-%d,%d\n", x, y, w, h);
+               DRM_DEBUG("%d,%d-%d,%d\n", x, y, w, h);
 
                BEGIN_RING(9);
 
        int offset = (dev_priv->sarea_priv->pfCurrentPage == 1)
            ? dev_priv->front_offset : dev_priv->back_offset;
        RING_LOCALS;
-       DRM_DEBUG("%s: pfCurrentPage=%d\n",
-                 __FUNCTION__,
+       DRM_DEBUG("pfCurrentPage=%d\n",
                  dev_priv->sarea_priv->pfCurrentPage);
 
        /* Do some trivial performance monitoring...
 {
        drm_radeon_private_t *dev_priv = dev->dev_private;
        RING_LOCALS;
-       DRM_DEBUG("indirect: buf=%d s=0x%x e=0x%x\n", buf->idx, start, end);
+       DRM_DEBUG("buf=%d s=0x%x e=0x%x\n", buf->idx, start, end);
 
        if (start != end) {
                int offset = (dev_priv->gart_buffers_offset
                        buf = radeon_freelist_get(dev);
                }
                if (!buf) {
-                       DRM_DEBUG("radeon_cp_dispatch_texture: EAGAIN\n");
+                       DRM_DEBUG("EAGAIN\n");
                        if (DRM_COPY_TO_USER(tex->image, image, sizeof(*image)))
                                return -EFAULT;
                        return -EAGAIN;
 
        LOCK_TEST_WITH_RETURN(dev, file_priv);
 
-       DRM_DEBUG("indirect: idx=%d s=%d e=%d d=%d\n",
+       DRM_DEBUG("idx=%d s=%d e=%d d=%d\n",
                  indirect->idx, indirect->start, indirect->end,
                  indirect->discard);
 
        drm_radeon_private_t *dev_priv = dev->dev_private;
        RING_LOCALS;
 
-       DRM_DEBUG("%s: %x\n", __FUNCTION__, flags);
+       DRM_DEBUG("%x\n", flags);
        switch (flags) {
        case RADEON_WAIT_2D:
                BEGIN_RING(2);
 
        dev_priv->vram_offset = fb->offset;
 
        mutex_unlock(&dev->struct_mutex);
-       DRM_DEBUG("offset = %u, size = %u", fb->offset, fb->size);
+       DRM_DEBUG("offset = %u, size = %u\n", fb->offset, fb->size);
 
        return 0;
 }
        dev_priv->agp_offset = agp->offset;
        mutex_unlock(&dev->struct_mutex);
 
-       DRM_DEBUG("offset = %u, size = %u", agp->offset, agp->size);
+       DRM_DEBUG("offset = %u, size = %u\n", agp->offset, agp->size);
        return 0;
 }
 
 
        }
 
        if (dev_priv->ring.virtual_start != NULL) {
-               DRM_ERROR("%s called again without calling cleanup\n",
-                         __FUNCTION__);
+               DRM_ERROR("called again without calling cleanup\n");
                return -EFAULT;
        }
 
        if (!dev->agp || !dev->agp->base) {
-               DRM_ERROR("%s called with no agp memory available\n",
-                         __FUNCTION__);
+               DRM_ERROR("called with no agp memory available\n");
                return -EFAULT;
        }
 
        dev_priv = (drm_via_private_t *) dev->dev_private;
 
        if (dev_priv->ring.virtual_start == NULL) {
-               DRM_ERROR("%s called without initializing AGP ring buffer.\n",
-                         __FUNCTION__);
+               DRM_ERROR("called without initializing AGP ring buffer.\n");
                return -EFAULT;
        }
 
 
        LOCK_TEST_WITH_RETURN(dev, file_priv);
 
-       DRM_DEBUG("via cmdbuffer, buf %p size %lu\n", cmdbuf->buf,
-                 cmdbuf->size);
+       DRM_DEBUG("buf %p size %lu\n", cmdbuf->buf, cmdbuf->size);
 
        ret = via_dispatch_cmdbuffer(dev, cmdbuf);
        if (ret) {
 
        LOCK_TEST_WITH_RETURN(dev, file_priv);
 
-       DRM_DEBUG("via_pci_cmdbuffer, buf %p size %lu\n", cmdbuf->buf,
-                 cmdbuf->size);
+       DRM_DEBUG("buf %p size %lu\n", cmdbuf->buf, cmdbuf->size);
 
        ret = via_dispatch_pci_cmdbuffer(dev, cmdbuf);
        if (ret) {
        uint32_t tmp_size, count;
        drm_via_private_t *dev_priv;
 
-       DRM_DEBUG("via cmdbuf_size\n");
+       DRM_DEBUG("\n");
        LOCK_TEST_WITH_RETURN(dev, file_priv);
 
        dev_priv = (drm_via_private_t *) dev->dev_private;
 
        if (dev_priv->ring.virtual_start == NULL) {
-               DRM_ERROR("%s called without initializing AGP ring buffer.\n",
-                         __FUNCTION__);
+               DRM_ERROR("called without initializing AGP ring buffer.\n");
                return -EFAULT;
        }
 
 
        unsigned int cur_vblank;
        int ret = 0;
 
-       DRM_DEBUG("viadrv_vblank_wait\n");
+       DRM_DEBUG("\n");
        if (!dev_priv) {
-               DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
+               DRM_ERROR("called with no initialization\n");
                return -EINVAL;
        }
 
        maskarray_t *masks;
        int real_irq;
 
-       DRM_DEBUG("%s\n", __FUNCTION__);
+       DRM_DEBUG("\n");
 
        if (!dev_priv) {
-               DRM_ERROR("%s called with no initialization\n", __FUNCTION__);
+               DRM_ERROR("called with no initialization\n");
                return -EINVAL;
        }
 
        if (irq >= drm_via_irq_num) {
-               DRM_ERROR("%s Trying to wait on unknown irq %d\n", __FUNCTION__,
-                         irq);
+               DRM_ERROR("Trying to wait on unknown irq %d\n", irq);
                return -EINVAL;
        }
 
        real_irq = dev_priv->irq_map[irq];
 
        if (real_irq < 0) {
-               DRM_ERROR("%s Video IRQ %d not available on this hardware.\n",
-                         __FUNCTION__, irq);
+               DRM_ERROR("Video IRQ %d not available on this hardware.\n",
+                         irq);
                return -EINVAL;
        }
 
        drm_via_irq_t *cur_irq;
        int i;
 
-       DRM_DEBUG("driver_irq_preinstall: dev_priv: %p\n", dev_priv);
+       DRM_DEBUG("dev_priv: %p\n", dev_priv);
        if (dev_priv) {
                cur_irq = dev_priv->via_irqs;
 
        drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
        u32 status;
 
-       DRM_DEBUG("via_driver_irq_postinstall\n");
+       DRM_DEBUG("\n");
        if (dev_priv) {
                status = VIA_READ(VIA_REG_INTERRUPT);
                VIA_WRITE(VIA_REG_INTERRUPT, status | VIA_IRQ_GLOBAL
        drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
        u32 status;
 
-       DRM_DEBUG("driver_irq_uninstall)\n");
+       DRM_DEBUG("\n");
        if (dev_priv) {
 
                /* Some more magic, oh for some data sheets ! */
                return -EINVAL;
 
        if (irqwait->request.irq >= dev_priv->num_irqs) {
-               DRM_ERROR("%s Trying to wait on unknown irq %d\n", __FUNCTION__,
+               DRM_ERROR("Trying to wait on unknown irq %d\n",
                          irqwait->request.irq);
                return -EINVAL;
        }
        }
 
        if (irqwait->request.type & VIA_IRQ_SIGNAL) {
-               DRM_ERROR("%s Signals on Via IRQs not implemented yet.\n",
-                         __FUNCTION__);
+               DRM_ERROR("Signals on Via IRQs not implemented yet.\n");
                return -EINVAL;
        }
 
 
 {
        drm_via_private_t *dev_priv = dev->dev_private;
 
-       DRM_DEBUG("%s\n", __FUNCTION__);
+       DRM_DEBUG("\n");
 
        dev_priv->sarea = drm_getsarea(dev);
        if (!dev_priv->sarea) {
 {
        drm_via_init_t *init = data;
 
-       DRM_DEBUG("%s\n", __FUNCTION__);
+       DRM_DEBUG("\n");
 
        switch (init->func) {
        case VIA_INIT_MAP:
 
        dev_priv->agp_offset = agp->offset;
        mutex_unlock(&dev->struct_mutex);
 
-       DRM_DEBUG("offset = %u, size = %u", agp->offset, agp->size);
+       DRM_DEBUG("offset = %u, size = %u\n", agp->offset, agp->size);
        return 0;
 }
 
        dev_priv->vram_offset = fb->offset;
 
        mutex_unlock(&dev->struct_mutex);
-       DRM_DEBUG("offset = %u, size = %u", fb->offset, fb->size);
+       DRM_DEBUG("offset = %u, size = %u\n", fb->offset, fb->size);
 
        return 0;
 
 
 {
        unsigned int i;
 
-       DRM_DEBUG("%s\n", __FUNCTION__);
+       DRM_DEBUG("\n");
 
        for (i = 0; i < VIA_NR_XVMC_LOCKS; ++i) {
                DRM_INIT_WAITQUEUE(&(dev_priv->decoder_queue[i]));
        drm_via_sarea_t *sAPriv = dev_priv->sarea_priv;
        int ret = 0;
 
-       DRM_DEBUG("%s\n", __FUNCTION__);
+       DRM_DEBUG("\n");
 
        if (fx->lock > VIA_NR_XVMC_LOCKS)
                return -EFAULT;