tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

drm: cleanup DRM_DEBUG() parameters

As DRM_DEBUG macro already prints out the __FUNCTION__ string (see
drivers/char/drm/drmP.h), it is not worth doing this again. At some
other places the ending "\n" was added.

airlied:- I cleaned up a few that this patch missed also

Signed-off-by: Dave Airlie <airlied@linux.ie>

authored by

Márton Németh and committed by
Dave Airlie 3e684eae 4d1f7888

+122 -145
+3 -3
drivers/char/drm/ati_pcigart.c
··· 41 41 struct page *page; 42 42 int i; 43 43 44 - DRM_DEBUG("%s: alloc %d order\n", __FUNCTION__, order); 44 + DRM_DEBUG("%d order\n", order); 45 45 46 46 address = __get_free_pages(GFP_KERNEL | __GFP_COMP, 47 47 order); ··· 54 54 for (i = 0; i < order; i++, page++) 55 55 SetPageReserved(page); 56 56 57 - DRM_DEBUG("%s: returning 0x%08lx\n", __FUNCTION__, address); 57 + DRM_DEBUG("returning 0x%08lx\n", address); 58 58 return (void *)address; 59 59 } 60 60 ··· 63 63 struct page *page; 64 64 int i; 65 65 int num_pages = 1 << order; 66 - DRM_DEBUG("%s\n", __FUNCTION__); 66 + DRM_DEBUG("\n"); 67 67 68 68 page = virt_to_page((unsigned long)address); 69 69
+2 -2
drivers/char/drm/drm_irq.c
··· 107 107 dev->irq_enabled = 1; 108 108 mutex_unlock(&dev->struct_mutex); 109 109 110 - DRM_DEBUG("%s: irq=%d\n", __FUNCTION__, dev->irq); 110 + DRM_DEBUG("irq=%d\n", dev->irq); 111 111 112 112 if (drm_core_check_feature(dev, DRIVER_IRQ_VBL)) { 113 113 init_waitqueue_head(&dev->vbl_queue); ··· 164 164 if (!irq_enabled) 165 165 return -EINVAL; 166 166 167 - DRM_DEBUG("%s: irq=%d\n", __FUNCTION__, dev->irq); 167 + DRM_DEBUG("irq=%d\n", dev->irq); 168 168 169 169 dev->driver->irq_uninstall(dev); 170 170
+5 -5
drivers/char/drm/drm_scatter.c
··· 67 67 struct drm_sg_mem *entry; 68 68 unsigned long pages, i, j; 69 69 70 - DRM_DEBUG("%s\n", __FUNCTION__); 70 + DRM_DEBUG("\n"); 71 71 72 72 if (!drm_core_check_feature(dev, DRIVER_SG)) 73 73 return -EINVAL; ··· 81 81 82 82 memset(entry, 0, sizeof(*entry)); 83 83 pages = (request->size + PAGE_SIZE - 1) / PAGE_SIZE; 84 - DRM_DEBUG("sg size=%ld pages=%ld\n", request->size, pages); 84 + DRM_DEBUG("size=%ld pages=%ld\n", request->size, pages); 85 85 86 86 entry->pages = pages; 87 87 entry->pagelist = drm_alloc(pages * sizeof(*entry->pagelist), ··· 122 122 123 123 entry->handle = ScatterHandle((unsigned long)entry->virtual); 124 124 125 - DRM_DEBUG("sg alloc handle = %08lx\n", entry->handle); 126 - DRM_DEBUG("sg alloc virtual = %p\n", entry->virtual); 125 + DRM_DEBUG("handle = %08lx\n", entry->handle); 126 + DRM_DEBUG("virtual = %p\n", entry->virtual); 127 127 128 128 for (i = (unsigned long)entry->virtual, j = 0; j < pages; 129 129 i += PAGE_SIZE, j++) { ··· 210 210 if (!entry || entry->handle != request->handle) 211 211 return -EINVAL; 212 212 213 - DRM_DEBUG("sg free virtual = %p\n", entry->virtual); 213 + DRM_DEBUG("virtual = %p\n", entry->virtual); 214 214 215 215 drm_sg_cleanup(entry); 216 216
+2 -2
drivers/char/drm/drm_vm.c
··· 180 180 return NOPAGE_SIGBUS; 181 181 get_page(page); 182 182 183 - DRM_DEBUG("shm_nopage 0x%lx\n", address); 183 + DRM_DEBUG("0x%lx\n", address); 184 184 return page; 185 185 } 186 186 ··· 294 294 295 295 get_page(page); 296 296 297 - DRM_DEBUG("dma_nopage 0x%lx (page %lu)\n", address, page_nr); 297 + DRM_DEBUG("0x%lx (page %lu)\n", address, page_nr); 298 298 return page; 299 299 } 300 300
+8 -14
drivers/char/drm/i810_dma.c
··· 570 570 drm_i810_sarea_t *sarea_priv = dev_priv->sarea_priv; 571 571 unsigned int dirty = sarea_priv->dirty; 572 572 573 - DRM_DEBUG("%s %x\n", __FUNCTION__, dirty); 573 + DRM_DEBUG("%x\n", dirty); 574 574 575 575 if (dirty & I810_UPLOAD_BUFFERS) { 576 576 i810EmitDestVerified(dev, sarea_priv->BufferState); ··· 802 802 int pitch = dev_priv->pitch; 803 803 RING_LOCALS; 804 804 805 - DRM_DEBUG("%s: page=%d pfCurrentPage=%d\n", 806 - __FUNCTION__, 805 + DRM_DEBUG("page=%d pfCurrentPage=%d\n", 807 806 dev_priv->current_page, 808 807 dev_priv->sarea_priv->pf_current_page); 809 808 ··· 847 848 drm_i810_private_t *dev_priv = dev->dev_private; 848 849 RING_LOCALS; 849 850 850 - /* printk("%s\n", __FUNCTION__); */ 851 - 852 851 i810_kernel_lost_context(dev); 853 852 854 853 BEGIN_LP_RING(4); ··· 865 868 struct drm_device_dma *dma = dev->dma; 866 869 int i, ret = 0; 867 870 RING_LOCALS; 868 - 869 - /* printk("%s\n", __FUNCTION__); */ 870 871 871 872 i810_kernel_lost_context(dev); 872 873 ··· 944 949 945 950 LOCK_TEST_WITH_RETURN(dev, file_priv); 946 951 947 - DRM_DEBUG("i810 dma vertex, idx %d used %d discard %d\n", 952 + DRM_DEBUG("idx %d used %d discard %d\n", 948 953 vertex->idx, vertex->used, vertex->discard); 949 954 950 955 if (vertex->idx < 0 || vertex->idx > dma->buf_count) ··· 982 987 static int i810_swap_bufs(struct drm_device *dev, void *data, 983 988 struct drm_file *file_priv) 984 989 { 985 - DRM_DEBUG("i810_swap_bufs\n"); 990 + DRM_DEBUG("\n"); 986 991 987 992 LOCK_TEST_WITH_RETURN(dev, file_priv); 988 993 ··· 1063 1068 1064 1069 sarea_priv->dirty = 0x7f; 1065 1070 1066 - DRM_DEBUG("dispatch mc addr 0x%lx, used 0x%x\n", address, used); 1071 + DRM_DEBUG("addr 0x%lx, used 0x%x\n", address, used); 1067 1072 1068 1073 dev_priv->counter++; 1069 1074 DRM_DEBUG("dispatch counter : %ld\n", dev_priv->counter); 1070 - DRM_DEBUG("i810_dma_dispatch_mc\n"); 1071 1075 DRM_DEBUG("start : %lx\n", start); 1072 1076 DRM_DEBUG("used : %d\n", used); 1073 1077 DRM_DEBUG("start + used - 4 : %ld\n", start + used - 4); ··· 1173 1179 { 1174 1180 drm_i810_private_t *dev_priv = dev->dev_private; 1175 1181 1176 - DRM_DEBUG("%s\n", __FUNCTION__); 1182 + DRM_DEBUG("\n"); 1177 1183 dev_priv->page_flipping = 1; 1178 1184 dev_priv->current_page = 0; 1179 1185 dev_priv->sarea_priv->pf_current_page = dev_priv->current_page; ··· 1183 1189 { 1184 1190 drm_i810_private_t *dev_priv = dev->dev_private; 1185 1191 1186 - DRM_DEBUG("%s\n", __FUNCTION__); 1192 + DRM_DEBUG("\n"); 1187 1193 if (dev_priv->current_page != 0) 1188 1194 i810_dma_dispatch_flip(dev); 1189 1195 ··· 1196 1202 { 1197 1203 drm_i810_private_t *dev_priv = dev->dev_private; 1198 1204 1199 - DRM_DEBUG("%s\n", __FUNCTION__); 1205 + DRM_DEBUG("\n"); 1200 1206 1201 1207 LOCK_TEST_WITH_RETURN(dev, file_priv); 1202 1208
+1 -1
drivers/char/drm/i810_drv.h
··· 145 145 146 146 #define BEGIN_LP_RING(n) do { \ 147 147 if (I810_VERBOSE) \ 148 - DRM_DEBUG("BEGIN_LP_RING(%d) in %s\n", n, __FUNCTION__); \ 148 + DRM_DEBUG("BEGIN_LP_RING(%d)\n", n); \ 149 149 if (dev_priv->ring.space < n*4) \ 150 150 i810_wait_ring(dev, n*4); \ 151 151 dev_priv->ring.space -= n*4; \
+1 -2
drivers/char/drm/i830_drv.h
··· 156 156 157 157 #define BEGIN_LP_RING(n) do { \ 158 158 if (I830_VERBOSE) \ 159 - printk("BEGIN_LP_RING(%d) in %s\n", \ 160 - n, __FUNCTION__); \ 159 + printk("BEGIN_LP_RING(%d)\n", (n)); \ 161 160 if (dev_priv->ring.space < n*4) \ 162 161 i830_wait_ring(dev, n*4, __FUNCTION__); \ 163 162 outcount = 0; \
+3 -3
drivers/char/drm/i915_dma.c
··· 657 657 int value; 658 658 659 659 if (!dev_priv) { 660 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 660 + DRM_ERROR("called with no initialization\n"); 661 661 return -EINVAL; 662 662 } 663 663 ··· 691 691 drm_i915_setparam_t *param = data; 692 692 693 693 if (!dev_priv) { 694 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 694 + DRM_ERROR("called with no initialization\n"); 695 695 return -EINVAL; 696 696 } 697 697 ··· 721 721 drm_i915_hws_addr_t *hws = data; 722 722 723 723 if (!dev_priv) { 724 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 724 + DRM_ERROR("called with no initialization\n"); 725 725 return -EINVAL; 726 726 } 727 727
+2 -3
drivers/char/drm/i915_drv.h
··· 253 253 254 254 #define BEGIN_LP_RING(n) do { \ 255 255 if (I915_VERBOSE) \ 256 - DRM_DEBUG("BEGIN_LP_RING(%d) in %s\n", \ 257 - (n), __FUNCTION__); \ 258 - if (dev_priv->ring.space < (n)*4) \ 256 + DRM_DEBUG("BEGIN_LP_RING(%d)\n", (n)); \ 257 + if (dev_priv->ring.space < (n)*4) \ 259 258 i915_wait_ring(dev, (n)*4, __FUNCTION__); \ 260 259 outcount = 0; \ 261 260 outring = dev_priv->ring.tail; \
+9 -11
drivers/char/drm/i915_irq.c
··· 276 276 277 277 i915_kernel_lost_context(dev); 278 278 279 - DRM_DEBUG("%s\n", __FUNCTION__); 279 + DRM_DEBUG("\n"); 280 280 281 281 dev_priv->sarea_priv->last_enqueue = ++dev_priv->counter; 282 282 ··· 300 300 drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private; 301 301 int ret = 0; 302 302 303 - DRM_DEBUG("%s irq_nr=%d breadcrumb=%d\n", __FUNCTION__, irq_nr, 303 + DRM_DEBUG("irq_nr=%d breadcrumb=%d\n", irq_nr, 304 304 READ_BREADCRUMB(dev_priv)); 305 305 306 306 if (READ_BREADCRUMB(dev_priv) >= irq_nr) ··· 312 312 READ_BREADCRUMB(dev_priv) >= irq_nr); 313 313 314 314 if (ret == -EBUSY) { 315 - DRM_ERROR("%s: EBUSY -- rec: %d emitted: %d\n", 316 - __FUNCTION__, 315 + DRM_ERROR("EBUSY -- rec: %d emitted: %d\n", 317 316 READ_BREADCRUMB(dev_priv), (int)dev_priv->counter); 318 317 } 319 318 ··· 328 329 int ret = 0; 329 330 330 331 if (!dev_priv) { 331 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 332 + DRM_ERROR("called with no initialization\n"); 332 333 return -EINVAL; 333 334 } 334 335 ··· 364 365 LOCK_TEST_WITH_RETURN(dev, file_priv); 365 366 366 367 if (!dev_priv) { 367 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 368 + DRM_ERROR("called with no initialization\n"); 368 369 return -EINVAL; 369 370 } 370 371 ··· 387 388 drm_i915_irq_wait_t *irqwait = data; 388 389 389 390 if (!dev_priv) { 390 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 391 + DRM_ERROR("called with no initialization\n"); 391 392 return -EINVAL; 392 393 } 393 394 ··· 417 418 drm_i915_vblank_pipe_t *pipe = data; 418 419 419 420 if (!dev_priv) { 420 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 421 + DRM_ERROR("called with no initialization\n"); 421 422 return -EINVAL; 422 423 } 423 424 424 425 if (pipe->pipe & ~(DRM_I915_VBLANK_PIPE_A|DRM_I915_VBLANK_PIPE_B)) { 425 - DRM_ERROR("%s called with invalid pipe 0x%x\n", 426 - __FUNCTION__, pipe->pipe); 426 + DRM_ERROR("called with invalid pipe 0x%x\n", pipe->pipe); 427 427 return -EINVAL; 428 428 } 429 429 ··· 441 443 u16 flag; 442 444 443 445 if (!dev_priv) { 444 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 446 + DRM_ERROR("called with no initialization\n"); 445 447 return -EINVAL; 446 448 } 447 449
+4 -4
drivers/char/drm/i915_mem.c
··· 276 276 struct mem_block *block, **heap; 277 277 278 278 if (!dev_priv) { 279 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 279 + DRM_ERROR("called with no initialization\n"); 280 280 return -EINVAL; 281 281 } 282 282 ··· 314 314 struct mem_block *block, **heap; 315 315 316 316 if (!dev_priv) { 317 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 317 + DRM_ERROR("called with no initialization\n"); 318 318 return -EINVAL; 319 319 } 320 320 ··· 342 342 struct mem_block **heap; 343 343 344 344 if (!dev_priv) { 345 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 345 + DRM_ERROR("called with no initialization\n"); 346 346 return -EINVAL; 347 347 } 348 348 ··· 366 366 struct mem_block **heap; 367 367 368 368 if ( !dev_priv ) { 369 - DRM_ERROR( "%s called with no initialization\n", __FUNCTION__ ); 369 + DRM_ERROR( "called with no initialization\n" ); 370 370 return -EINVAL; 371 371 } 372 372
+1 -1
drivers/char/drm/mga_dma.c
··· 1050 1050 #if MGA_DMA_DEBUG 1051 1051 int ret = mga_do_wait_for_idle(dev_priv); 1052 1052 if (ret < 0) 1053 - DRM_INFO("%s: -EBUSY\n", __FUNCTION__); 1053 + DRM_INFO("-EBUSY\n"); 1054 1054 return ret; 1055 1055 #else 1056 1056 return mga_do_wait_for_idle(dev_priv);
+5 -6
drivers/char/drm/mga_drv.h
··· 249 249 } else if ( dev_priv->prim.space < \ 250 250 dev_priv->prim.high_mark ) { \ 251 251 if ( MGA_DMA_DEBUG ) \ 252 - DRM_INFO( "%s: wrap...\n", __FUNCTION__ ); \ 252 + DRM_INFO( "wrap...\n"); \ 253 253 return -EBUSY; \ 254 254 } \ 255 255 } \ ··· 260 260 if ( test_bit( 0, &dev_priv->prim.wrapped ) ) { \ 261 261 if ( mga_do_wait_for_idle( dev_priv ) < 0 ) { \ 262 262 if ( MGA_DMA_DEBUG ) \ 263 - DRM_INFO( "%s: wrap...\n", __FUNCTION__ ); \ 263 + DRM_INFO( "wrap...\n"); \ 264 264 return -EBUSY; \ 265 265 } \ 266 266 mga_do_dma_wrap_end( dev_priv ); \ ··· 280 280 #define BEGIN_DMA( n ) \ 281 281 do { \ 282 282 if ( MGA_VERBOSE ) { \ 283 - DRM_INFO( "BEGIN_DMA( %d ) in %s\n", \ 284 - (n), __FUNCTION__ ); \ 283 + DRM_INFO( "BEGIN_DMA( %d )\n", (n) ); \ 285 284 DRM_INFO( " space=0x%x req=0x%Zx\n", \ 286 285 dev_priv->prim.space, (n) * DMA_BLOCK_SIZE ); \ 287 286 } \ ··· 291 292 #define BEGIN_DMA_WRAP() \ 292 293 do { \ 293 294 if ( MGA_VERBOSE ) { \ 294 - DRM_INFO( "BEGIN_DMA() in %s\n", __FUNCTION__ ); \ 295 + DRM_INFO( "BEGIN_DMA()\n" ); \ 295 296 DRM_INFO( " space=0x%x\n", dev_priv->prim.space ); \ 296 297 } \ 297 298 prim = dev_priv->prim.start; \ ··· 310 311 #define FLUSH_DMA() \ 311 312 do { \ 312 313 if ( 0 ) { \ 313 - DRM_INFO( "%s:\n", __FUNCTION__ ); \ 314 + DRM_INFO( "\n" ); \ 314 315 DRM_INFO( " tail=0x%06x head=0x%06lx\n", \ 315 316 dev_priv->prim.tail, \ 316 317 MGA_READ( MGA_PRIMADDRESS ) - \
+7 -7
drivers/char/drm/mga_state.c
··· 619 619 620 620 FLUSH_DMA(); 621 621 622 - DRM_DEBUG("%s... done.\n", __FUNCTION__); 622 + DRM_DEBUG("... done.\n"); 623 623 } 624 624 625 625 static void mga_dma_dispatch_vertex(struct drm_device * dev, struct drm_buf * buf) ··· 631 631 u32 length = (u32) buf->used; 632 632 int i = 0; 633 633 DMA_LOCALS; 634 - DRM_DEBUG("vertex: buf=%d used=%d\n", buf->idx, buf->used); 634 + DRM_DEBUG("buf=%d used=%d\n", buf->idx, buf->used); 635 635 636 636 if (buf->used) { 637 637 buf_priv->dispatched = 1; ··· 678 678 u32 address = (u32) buf->bus_address; 679 679 int i = 0; 680 680 DMA_LOCALS; 681 - DRM_DEBUG("indices: buf=%d start=%d end=%d\n", buf->idx, start, end); 681 + DRM_DEBUG("buf=%d start=%d end=%d\n", buf->idx, start, end); 682 682 683 683 if (start != end) { 684 684 buf_priv->dispatched = 1; ··· 955 955 #if 0 956 956 if (mga_do_wait_for_idle(dev_priv) < 0) { 957 957 if (MGA_DMA_DEBUG) 958 - DRM_INFO("%s: -EBUSY\n", __FUNCTION__); 958 + DRM_INFO("-EBUSY\n"); 959 959 return -EBUSY; 960 960 } 961 961 #endif ··· 1014 1014 int value; 1015 1015 1016 1016 if (!dev_priv) { 1017 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 1017 + DRM_ERROR("called with no initialization\n"); 1018 1018 return -EINVAL; 1019 1019 } 1020 1020 ··· 1046 1046 DMA_LOCALS; 1047 1047 1048 1048 if (!dev_priv) { 1049 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 1049 + DRM_ERROR("called with no initialization\n"); 1050 1050 return -EINVAL; 1051 1051 } 1052 1052 ··· 1075 1075 u32 *fence = data; 1076 1076 1077 1077 if (!dev_priv) { 1078 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 1078 + DRM_ERROR("called with no initialization\n"); 1079 1079 return -EINVAL; 1080 1080 } 1081 1081
+2 -2
drivers/char/drm/r128_cce.c
··· 651 651 LOCK_TEST_WITH_RETURN(dev, file_priv); 652 652 653 653 if (dev_priv->cce_running || dev_priv->cce_mode == R128_PM4_NONPM4) { 654 - DRM_DEBUG("%s while CCE running\n", __FUNCTION__); 654 + DRM_DEBUG("while CCE running\n"); 655 655 return 0; 656 656 } 657 657 ··· 710 710 LOCK_TEST_WITH_RETURN(dev, file_priv); 711 711 712 712 if (!dev_priv) { 713 - DRM_DEBUG("%s called before init done\n", __FUNCTION__); 713 + DRM_DEBUG("called before init done\n"); 714 714 return -EINVAL; 715 715 } 716 716
+1 -2
drivers/char/drm/r128_drv.h
··· 462 462 463 463 #define BEGIN_RING( n ) do { \ 464 464 if ( R128_VERBOSE ) { \ 465 - DRM_INFO( "BEGIN_RING( %d ) in %s\n", \ 466 - (n), __FUNCTION__ ); \ 465 + DRM_INFO( "BEGIN_RING( %d )\n", (n)); \ 467 466 } \ 468 467 if ( dev_priv->ring.space <= (n) * sizeof(u32) ) { \ 469 468 COMMIT_RING(); \
+21 -22
drivers/char/drm/r128_state.c
··· 42 42 { 43 43 u32 aux_sc_cntl = 0x00000000; 44 44 RING_LOCALS; 45 - DRM_DEBUG(" %s\n", __FUNCTION__); 45 + DRM_DEBUG("\n"); 46 46 47 47 BEGIN_RING((count < 3 ? count : 3) * 5 + 2); 48 48 ··· 85 85 drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv; 86 86 drm_r128_context_regs_t *ctx = &sarea_priv->context_state; 87 87 RING_LOCALS; 88 - DRM_DEBUG(" %s\n", __FUNCTION__); 88 + DRM_DEBUG("\n"); 89 89 90 90 BEGIN_RING(2); 91 91 ··· 100 100 drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv; 101 101 drm_r128_context_regs_t *ctx = &sarea_priv->context_state; 102 102 RING_LOCALS; 103 - DRM_DEBUG(" %s\n", __FUNCTION__); 103 + DRM_DEBUG("\n"); 104 104 105 105 BEGIN_RING(13); 106 106 ··· 126 126 drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv; 127 127 drm_r128_context_regs_t *ctx = &sarea_priv->context_state; 128 128 RING_LOCALS; 129 - DRM_DEBUG(" %s\n", __FUNCTION__); 129 + DRM_DEBUG("\n"); 130 130 131 131 BEGIN_RING(3); 132 132 ··· 142 142 drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv; 143 143 drm_r128_context_regs_t *ctx = &sarea_priv->context_state; 144 144 RING_LOCALS; 145 - DRM_DEBUG(" %s\n", __FUNCTION__); 145 + DRM_DEBUG("\n"); 146 146 147 147 BEGIN_RING(5); 148 148 ··· 161 161 drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv; 162 162 drm_r128_context_regs_t *ctx = &sarea_priv->context_state; 163 163 RING_LOCALS; 164 - DRM_DEBUG(" %s\n", __FUNCTION__); 164 + DRM_DEBUG("\n"); 165 165 166 166 BEGIN_RING(2); 167 167 ··· 178 178 drm_r128_texture_regs_t *tex = &sarea_priv->tex_state[0]; 179 179 int i; 180 180 RING_LOCALS; 181 - DRM_DEBUG(" %s\n", __FUNCTION__); 181 + DRM_DEBUG("\n"); 182 182 183 183 BEGIN_RING(7 + R128_MAX_TEXTURE_LEVELS); 184 184 ··· 204 204 drm_r128_texture_regs_t *tex = &sarea_priv->tex_state[1]; 205 205 int i; 206 206 RING_LOCALS; 207 - DRM_DEBUG(" %s\n", __FUNCTION__); 207 + DRM_DEBUG("\n"); 208 208 209 209 BEGIN_RING(5 + R128_MAX_TEXTURE_LEVELS); 210 210 ··· 226 226 drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv; 227 227 unsigned int dirty = sarea_priv->dirty; 228 228 229 - DRM_DEBUG("%s: dirty=0x%08x\n", __FUNCTION__, dirty); 229 + DRM_DEBUG("dirty=0x%08x\n", dirty); 230 230 231 231 if (dirty & R128_UPLOAD_CORE) { 232 232 r128_emit_core(dev_priv); ··· 362 362 unsigned int flags = clear->flags; 363 363 int i; 364 364 RING_LOCALS; 365 - DRM_DEBUG("%s\n", __FUNCTION__); 365 + DRM_DEBUG("\n"); 366 366 367 367 if (dev_priv->page_flipping && dev_priv->current_page == 1) { 368 368 unsigned int tmp = flags; ··· 466 466 struct drm_clip_rect *pbox = sarea_priv->boxes; 467 467 int i; 468 468 RING_LOCALS; 469 - DRM_DEBUG("%s\n", __FUNCTION__); 469 + DRM_DEBUG("\n"); 470 470 471 471 #if R128_PERFORMANCE_BOXES 472 472 /* Do some trivial performance monitoring... ··· 528 528 { 529 529 drm_r128_private_t *dev_priv = dev->dev_private; 530 530 RING_LOCALS; 531 - DRM_DEBUG("%s: page=%d pfCurrentPage=%d\n", 532 - __FUNCTION__, 531 + DRM_DEBUG("page=%d pfCurrentPage=%d\n", 533 532 dev_priv->current_page, dev_priv->sarea_priv->pfCurrentPage); 534 533 535 534 #if R128_PERFORMANCE_BOXES ··· 1155 1156 int count, *x, *y; 1156 1157 int i, xbuf_size, ybuf_size; 1157 1158 RING_LOCALS; 1158 - DRM_DEBUG("%s\n", __FUNCTION__); 1159 + DRM_DEBUG("\n"); 1159 1160 1160 1161 count = depth->n; 1161 1162 if (count > 4096 || count <= 0) ··· 1225 1226 drm_r128_private_t *dev_priv = dev->dev_private; 1226 1227 int i; 1227 1228 RING_LOCALS; 1228 - DRM_DEBUG("%s\n", __FUNCTION__); 1229 + DRM_DEBUG("\n"); 1229 1230 1230 1231 BEGIN_RING(33); 1231 1232 ··· 1308 1309 static int r128_cce_flip(struct drm_device *dev, void *data, struct drm_file *file_priv) 1309 1310 { 1310 1311 drm_r128_private_t *dev_priv = dev->dev_private; 1311 - DRM_DEBUG("%s\n", __FUNCTION__); 1312 + DRM_DEBUG("\n"); 1312 1313 1313 1314 LOCK_TEST_WITH_RETURN(dev, file_priv); 1314 1315 ··· 1327 1328 { 1328 1329 drm_r128_private_t *dev_priv = dev->dev_private; 1329 1330 drm_r128_sarea_t *sarea_priv = dev_priv->sarea_priv; 1330 - DRM_DEBUG("%s\n", __FUNCTION__); 1331 + DRM_DEBUG("\n"); 1331 1332 1332 1333 LOCK_TEST_WITH_RETURN(dev, file_priv); 1333 1334 ··· 1355 1356 LOCK_TEST_WITH_RETURN(dev, file_priv); 1356 1357 1357 1358 if (!dev_priv) { 1358 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 1359 + DRM_ERROR("called with no initialization\n"); 1359 1360 return -EINVAL; 1360 1361 } 1361 1362 ··· 1411 1412 LOCK_TEST_WITH_RETURN(dev, file_priv); 1412 1413 1413 1414 if (!dev_priv) { 1414 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 1415 + DRM_ERROR("called with no initialization\n"); 1415 1416 return -EINVAL; 1416 1417 } 1417 1418 ··· 1556 1557 LOCK_TEST_WITH_RETURN(dev, file_priv); 1557 1558 1558 1559 if (!dev_priv) { 1559 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 1560 + DRM_ERROR("called with no initialization\n"); 1560 1561 return -EINVAL; 1561 1562 } 1562 1563 1563 - DRM_DEBUG("indirect: idx=%d s=%d e=%d d=%d\n", 1564 + DRM_DEBUG("idx=%d s=%d e=%d d=%d\n", 1564 1565 indirect->idx, indirect->start, indirect->end, 1565 1566 indirect->discard); 1566 1567 ··· 1621 1622 int value; 1622 1623 1623 1624 if (!dev_priv) { 1624 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 1625 + DRM_ERROR("called with no initialization\n"); 1625 1626 return -EINVAL; 1626 1627 } 1627 1628
+4 -4
drivers/char/drm/radeon_cp.c
··· 1852 1852 LOCK_TEST_WITH_RETURN(dev, file_priv); 1853 1853 1854 1854 if (dev_priv->cp_running) { 1855 - DRM_DEBUG("%s while CP running\n", __FUNCTION__); 1855 + DRM_DEBUG("while CP running\n"); 1856 1856 return 0; 1857 1857 } 1858 1858 if (dev_priv->cp_mode == RADEON_CSQ_PRIDIS_INDDIS) { 1859 - DRM_DEBUG("%s called with bogus CP mode (%d)\n", 1860 - __FUNCTION__, dev_priv->cp_mode); 1859 + DRM_DEBUG("called with bogus CP mode (%d)\n", 1860 + dev_priv->cp_mode); 1861 1861 return 0; 1862 1862 } 1863 1863 ··· 1962 1962 LOCK_TEST_WITH_RETURN(dev, file_priv); 1963 1963 1964 1964 if (!dev_priv) { 1965 - DRM_DEBUG("%s called before init done\n", __FUNCTION__); 1965 + DRM_DEBUG("called before init done\n"); 1966 1966 return -EINVAL; 1967 1967 } 1968 1968
+1 -2
drivers/char/drm/radeon_drv.h
··· 1114 1114 1115 1115 #define BEGIN_RING( n ) do { \ 1116 1116 if ( RADEON_VERBOSE ) { \ 1117 - DRM_INFO( "BEGIN_RING( %d ) in %s\n", \ 1118 - n, __FUNCTION__ ); \ 1117 + DRM_INFO( "BEGIN_RING( %d )\n", (n)); \ 1119 1118 } \ 1120 1119 if ( dev_priv->ring.space <= (n) * sizeof(u32) ) { \ 1121 1120 COMMIT_RING(); \
+3 -3
drivers/char/drm/radeon_irq.c
··· 154 154 int ack = 0; 155 155 atomic_t *counter; 156 156 if (!dev_priv) { 157 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 157 + DRM_ERROR("called with no initialization\n"); 158 158 return -EINVAL; 159 159 } 160 160 ··· 205 205 LOCK_TEST_WITH_RETURN(dev, file_priv); 206 206 207 207 if (!dev_priv) { 208 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 208 + DRM_ERROR("called with no initialization\n"); 209 209 return -EINVAL; 210 210 } 211 211 ··· 227 227 drm_radeon_irq_wait_t *irqwait = data; 228 228 229 229 if (!dev_priv) { 230 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 230 + DRM_ERROR("called with no initialization\n"); 231 231 return -EINVAL; 232 232 } 233 233
+3 -3
drivers/char/drm/radeon_mem.c
··· 224 224 struct mem_block *block, **heap; 225 225 226 226 if (!dev_priv) { 227 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 227 + DRM_ERROR("called with no initialization\n"); 228 228 return -EINVAL; 229 229 } 230 230 ··· 259 259 struct mem_block *block, **heap; 260 260 261 261 if (!dev_priv) { 262 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 262 + DRM_ERROR("called with no initialization\n"); 263 263 return -EINVAL; 264 264 } 265 265 ··· 285 285 struct mem_block **heap; 286 286 287 287 if (!dev_priv) { 288 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 288 + DRM_ERROR("called with no initialization\n"); 289 289 return -EINVAL; 290 290 } 291 291
+7 -8
drivers/char/drm/radeon_state.c
··· 898 898 int w = pbox[i].x2 - x; 899 899 int h = pbox[i].y2 - y; 900 900 901 - DRM_DEBUG("dispatch clear %d,%d-%d,%d flags 0x%x\n", 901 + DRM_DEBUG("%d,%d-%d,%d flags 0x%x\n", 902 902 x, y, w, h, flags); 903 903 904 904 if (flags & RADEON_FRONT) { ··· 1368 1368 int w = pbox[i].x2 - x; 1369 1369 int h = pbox[i].y2 - y; 1370 1370 1371 - DRM_DEBUG("dispatch swap %d,%d-%d,%d\n", x, y, w, h); 1371 + DRM_DEBUG("%d,%d-%d,%d\n", x, y, w, h); 1372 1372 1373 1373 BEGIN_RING(9); 1374 1374 ··· 1422 1422 int offset = (dev_priv->sarea_priv->pfCurrentPage == 1) 1423 1423 ? dev_priv->front_offset : dev_priv->back_offset; 1424 1424 RING_LOCALS; 1425 - DRM_DEBUG("%s: pfCurrentPage=%d\n", 1426 - __FUNCTION__, 1425 + DRM_DEBUG("pfCurrentPage=%d\n", 1427 1426 dev_priv->sarea_priv->pfCurrentPage); 1428 1427 1429 1428 /* Do some trivial performance monitoring... ··· 1561 1562 { 1562 1563 drm_radeon_private_t *dev_priv = dev->dev_private; 1563 1564 RING_LOCALS; 1564 - DRM_DEBUG("indirect: buf=%d s=0x%x e=0x%x\n", buf->idx, start, end); 1565 + DRM_DEBUG("buf=%d s=0x%x e=0x%x\n", buf->idx, start, end); 1565 1566 1566 1567 if (start != end) { 1567 1568 int offset = (dev_priv->gart_buffers_offset ··· 1757 1758 buf = radeon_freelist_get(dev); 1758 1759 } 1759 1760 if (!buf) { 1760 - DRM_DEBUG("radeon_cp_dispatch_texture: EAGAIN\n"); 1761 + DRM_DEBUG("EAGAIN\n"); 1761 1762 if (DRM_COPY_TO_USER(tex->image, image, sizeof(*image))) 1762 1763 return -EFAULT; 1763 1764 return -EAGAIN; ··· 2412 2413 2413 2414 LOCK_TEST_WITH_RETURN(dev, file_priv); 2414 2415 2415 - DRM_DEBUG("indirect: idx=%d s=%d e=%d d=%d\n", 2416 + DRM_DEBUG("idx=%d s=%d e=%d d=%d\n", 2416 2417 indirect->idx, indirect->start, indirect->end, 2417 2418 indirect->discard); 2418 2419 ··· 2778 2779 drm_radeon_private_t *dev_priv = dev->dev_private; 2779 2780 RING_LOCALS; 2780 2781 2781 - DRM_DEBUG("%s: %x\n", __FUNCTION__, flags); 2782 + DRM_DEBUG("%x\n", flags); 2782 2783 switch (flags) { 2783 2784 case RADEON_WAIT_2D: 2784 2785 BEGIN_RING(2);
+2 -2
drivers/char/drm/sis_mm.c
··· 115 115 dev_priv->vram_offset = fb->offset; 116 116 117 117 mutex_unlock(&dev->struct_mutex); 118 - DRM_DEBUG("offset = %u, size = %u", fb->offset, fb->size); 118 + DRM_DEBUG("offset = %u, size = %u\n", fb->offset, fb->size); 119 119 120 120 return 0; 121 121 } ··· 205 205 dev_priv->agp_offset = agp->offset; 206 206 mutex_unlock(&dev->struct_mutex); 207 207 208 - DRM_DEBUG("offset = %u, size = %u", agp->offset, agp->size); 208 + DRM_DEBUG("offset = %u, size = %u\n", agp->offset, agp->size); 209 209 return 0; 210 210 } 211 211
+7 -13
drivers/char/drm/via_dma.c
··· 179 179 } 180 180 181 181 if (dev_priv->ring.virtual_start != NULL) { 182 - DRM_ERROR("%s called again without calling cleanup\n", 183 - __FUNCTION__); 182 + DRM_ERROR("called again without calling cleanup\n"); 184 183 return -EFAULT; 185 184 } 186 185 187 186 if (!dev->agp || !dev->agp->base) { 188 - DRM_ERROR("%s called with no agp memory available\n", 189 - __FUNCTION__); 187 + DRM_ERROR("called with no agp memory available\n"); 190 188 return -EFAULT; 191 189 } 192 190 ··· 265 267 dev_priv = (drm_via_private_t *) dev->dev_private; 266 268 267 269 if (dev_priv->ring.virtual_start == NULL) { 268 - DRM_ERROR("%s called without initializing AGP ring buffer.\n", 269 - __FUNCTION__); 270 + DRM_ERROR("called without initializing AGP ring buffer.\n"); 270 271 return -EFAULT; 271 272 } 272 273 ··· 334 337 335 338 LOCK_TEST_WITH_RETURN(dev, file_priv); 336 339 337 - DRM_DEBUG("via cmdbuffer, buf %p size %lu\n", cmdbuf->buf, 338 - cmdbuf->size); 340 + DRM_DEBUG("buf %p size %lu\n", cmdbuf->buf, cmdbuf->size); 339 341 340 342 ret = via_dispatch_cmdbuffer(dev, cmdbuf); 341 343 if (ret) { ··· 375 379 376 380 LOCK_TEST_WITH_RETURN(dev, file_priv); 377 381 378 - DRM_DEBUG("via_pci_cmdbuffer, buf %p size %lu\n", cmdbuf->buf, 379 - cmdbuf->size); 382 + DRM_DEBUG("buf %p size %lu\n", cmdbuf->buf, cmdbuf->size); 380 383 381 384 ret = via_dispatch_pci_cmdbuffer(dev, cmdbuf); 382 385 if (ret) { ··· 643 648 uint32_t tmp_size, count; 644 649 drm_via_private_t *dev_priv; 645 650 646 - DRM_DEBUG("via cmdbuf_size\n"); 651 + DRM_DEBUG("\n"); 647 652 LOCK_TEST_WITH_RETURN(dev, file_priv); 648 653 649 654 dev_priv = (drm_via_private_t *) dev->dev_private; 650 655 651 656 if (dev_priv->ring.virtual_start == NULL) { 652 - DRM_ERROR("%s called without initializing AGP ring buffer.\n", 653 - __FUNCTION__); 657 + DRM_ERROR("called without initializing AGP ring buffer.\n"); 654 658 return -EFAULT; 655 659 } 656 660
+12 -14
drivers/char/drm/via_irq.c
··· 169 169 unsigned int cur_vblank; 170 170 int ret = 0; 171 171 172 - DRM_DEBUG("viadrv_vblank_wait\n"); 172 + DRM_DEBUG("\n"); 173 173 if (!dev_priv) { 174 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 174 + DRM_ERROR("called with no initialization\n"); 175 175 return -EINVAL; 176 176 } 177 177 ··· 201 201 maskarray_t *masks; 202 202 int real_irq; 203 203 204 - DRM_DEBUG("%s\n", __FUNCTION__); 204 + DRM_DEBUG("\n"); 205 205 206 206 if (!dev_priv) { 207 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 207 + DRM_ERROR("called with no initialization\n"); 208 208 return -EINVAL; 209 209 } 210 210 211 211 if (irq >= drm_via_irq_num) { 212 - DRM_ERROR("%s Trying to wait on unknown irq %d\n", __FUNCTION__, 213 - irq); 212 + DRM_ERROR("Trying to wait on unknown irq %d\n", irq); 214 213 return -EINVAL; 215 214 } 216 215 217 216 real_irq = dev_priv->irq_map[irq]; 218 217 219 218 if (real_irq < 0) { 220 - DRM_ERROR("%s Video IRQ %d not available on this hardware.\n", 221 - __FUNCTION__, irq); 219 + DRM_ERROR("Video IRQ %d not available on this hardware.\n", 220 + irq); 222 221 return -EINVAL; 223 222 } 224 223 ··· 250 251 drm_via_irq_t *cur_irq; 251 252 int i; 252 253 253 - DRM_DEBUG("driver_irq_preinstall: dev_priv: %p\n", dev_priv); 254 + DRM_DEBUG("dev_priv: %p\n", dev_priv); 254 255 if (dev_priv) { 255 256 cur_irq = dev_priv->via_irqs; 256 257 ··· 297 298 drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private; 298 299 u32 status; 299 300 300 - DRM_DEBUG("via_driver_irq_postinstall\n"); 301 + DRM_DEBUG("\n"); 301 302 if (dev_priv) { 302 303 status = VIA_READ(VIA_REG_INTERRUPT); 303 304 VIA_WRITE(VIA_REG_INTERRUPT, status | VIA_IRQ_GLOBAL ··· 316 317 drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private; 317 318 u32 status; 318 319 319 - DRM_DEBUG("driver_irq_uninstall)\n"); 320 + DRM_DEBUG("\n"); 320 321 if (dev_priv) { 321 322 322 323 /* Some more magic, oh for some data sheets ! */ ··· 343 344 return -EINVAL; 344 345 345 346 if (irqwait->request.irq >= dev_priv->num_irqs) { 346 - DRM_ERROR("%s Trying to wait on unknown irq %d\n", __FUNCTION__, 347 + DRM_ERROR("Trying to wait on unknown irq %d\n", 347 348 irqwait->request.irq); 348 349 return -EINVAL; 349 350 } ··· 361 362 } 362 363 363 364 if (irqwait->request.type & VIA_IRQ_SIGNAL) { 364 - DRM_ERROR("%s Signals on Via IRQs not implemented yet.\n", 365 - __FUNCTION__); 365 + DRM_ERROR("Signals on Via IRQs not implemented yet.\n"); 366 366 return -EINVAL; 367 367 } 368 368
+2 -2
drivers/char/drm/via_map.c
··· 29 29 { 30 30 drm_via_private_t *dev_priv = dev->dev_private; 31 31 32 - DRM_DEBUG("%s\n", __FUNCTION__); 32 + DRM_DEBUG("\n"); 33 33 34 34 dev_priv->sarea = drm_getsarea(dev); 35 35 if (!dev_priv->sarea) { ··· 79 79 { 80 80 drm_via_init_t *init = data; 81 81 82 - DRM_DEBUG("%s\n", __FUNCTION__); 82 + DRM_DEBUG("\n"); 83 83 84 84 switch (init->func) { 85 85 case VIA_INIT_MAP:
+2 -2
drivers/char/drm/via_mm.c
··· 53 53 dev_priv->agp_offset = agp->offset; 54 54 mutex_unlock(&dev->struct_mutex); 55 55 56 - DRM_DEBUG("offset = %u, size = %u", agp->offset, agp->size); 56 + DRM_DEBUG("offset = %u, size = %u\n", agp->offset, agp->size); 57 57 return 0; 58 58 } 59 59 ··· 77 77 dev_priv->vram_offset = fb->offset; 78 78 79 79 mutex_unlock(&dev->struct_mutex); 80 - DRM_DEBUG("offset = %u, size = %u", fb->offset, fb->size); 80 + DRM_DEBUG("offset = %u, size = %u\n", fb->offset, fb->size); 81 81 82 82 return 0; 83 83
+2 -2
drivers/char/drm/via_video.c
··· 33 33 { 34 34 unsigned int i; 35 35 36 - DRM_DEBUG("%s\n", __FUNCTION__); 36 + DRM_DEBUG("\n"); 37 37 38 38 for (i = 0; i < VIA_NR_XVMC_LOCKS; ++i) { 39 39 DRM_INIT_WAITQUEUE(&(dev_priv->decoder_queue[i])); ··· 73 73 drm_via_sarea_t *sAPriv = dev_priv->sarea_priv; 74 74 int ret = 0; 75 75 76 - DRM_DEBUG("%s\n", __FUNCTION__); 76 + DRM_DEBUG("\n"); 77 77 78 78 if (fx->lock > VIA_NR_XVMC_LOCKS) 79 79 return -EFAULT;