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

video: replace remaining __FUNCTION__ occurrences

__FUNCTION__ is gcc-specific, use __func__

Signed-off-by: Harvey Harrison <harvey.harrison@gmail.com>
Cc: "Antonino A. Daplas" <adaplas@pol.net>
Cc: Krzysztof Helt <krzysztof.h1@wp.pl>
Cc: Antonino Daplas <adaplas@gmail.com>
Cc: Antonino A. Daplas <adaplas@gmail.com>
Cc: Antonino Daplas <adaplas@pol.net>
Cc: Richard Purdie <rpurdie@rpsys.net>
Cc: Jean Delvare <khali@linux-fr.org>
Cc: Adrian Bunk <bunk@stusta.de>
Cc: Russell King <rmk+kernel@arm.linux.org.uk>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Ben Dooks <ben-linux@fluff.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

authored by

Harvey Harrison and committed by
Linus Torvalds 5ae12170 e7a05aa9

+106 -106
+1 -1
drivers/video/amifb.c
··· 96 96 #endif 97 97 98 98 #ifdef DEBUG 99 - # define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt, __FUNCTION__ , ## args) 99 + # define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt, __func__ , ## args) 100 100 #else 101 101 # define DPRINTK(fmt, args...) 102 102 #endif
+1 -1
drivers/video/aty/aty128fb.c
··· 91 91 #undef DEBUG 92 92 93 93 #ifdef DEBUG 94 - #define DBG(fmt, args...) printk(KERN_DEBUG "aty128fb: %s " fmt, __FUNCTION__, ##args); 94 + #define DBG(fmt, args...) printk(KERN_DEBUG "aty128fb: %s " fmt, __func__, ##args); 95 95 #else 96 96 #define DBG(fmt, args...) 97 97 #endif
+8 -8
drivers/video/aty/mach64_ct.c
··· 197 197 pll->dsp_config = (dsp_precision << 20) | (pll->dsp_loop_latency << 16) | dsp_xclks; 198 198 #ifdef DEBUG 199 199 printk("atyfb(%s): dsp_config 0x%08x, dsp_on_off 0x%08x\n", 200 - __FUNCTION__, pll->dsp_config, pll->dsp_on_off); 200 + __func__, pll->dsp_config, pll->dsp_on_off); 201 201 #endif 202 202 return 0; 203 203 } ··· 225 225 (par->ref_clk_per * pll->pll_ref_div); 226 226 #ifdef DEBUG 227 227 printk("atyfb(%s): pllvclk=%d MHz, vclk=%d MHz\n", 228 - __FUNCTION__, pllvclk, pllvclk / pll->vclk_post_div_real); 228 + __func__, pllvclk, pllvclk / pll->vclk_post_div_real); 229 229 #endif 230 230 pll->pll_vclk_cntl = 0x03; /* VCLK = PLL_VCLK/VCLKx_POST */ 231 231 ··· 269 269 } 270 270 #endif 271 271 #ifdef DEBUG 272 - printk("atyfb(%s): calculated 0x%08X(%i)\n", __FUNCTION__, ret, ret); 272 + printk("atyfb(%s): calculated 0x%08X(%i)\n", __func__, ret, ret); 273 273 #endif 274 274 return ret; 275 275 } ··· 284 284 #ifdef DEBUG 285 285 printk("atyfb(%s): about to program:\n" 286 286 "pll_ext_cntl=0x%02x pll_gen_cntl=0x%02x pll_vclk_cntl=0x%02x\n", 287 - __FUNCTION__, 287 + __func__, 288 288 pll->ct.pll_ext_cntl, pll->ct.pll_gen_cntl, pll->ct.pll_vclk_cntl); 289 289 290 290 printk("atyfb(%s): setting clock %lu for FeedBackDivider %i, ReferenceDivider %i, PostDivider %i(%i)\n", 291 - __FUNCTION__, 291 + __func__, 292 292 par->clk_wr_offset, pll->ct.vclk_fb_div, 293 293 pll->ct.pll_ref_div, pll->ct.vclk_post_div, pll->ct.vclk_post_div_real); 294 294 #endif ··· 428 428 429 429 #ifdef DEBUG 430 430 printk("atyfb(%s): mclk_fb_mult=%d, xclk_post_div=%d\n", 431 - __FUNCTION__, pll->ct.mclk_fb_mult, pll->ct.xclk_post_div); 431 + __func__, pll->ct.mclk_fb_mult, pll->ct.xclk_post_div); 432 432 #endif 433 433 434 434 memcntl = aty_ld_le32(MEM_CNTL, par); ··· 540 540 pllmclk = (1000000 * pll->ct.mclk_fb_mult * pll->ct.mclk_fb_div) / 541 541 (par->ref_clk_per * pll->ct.pll_ref_div); 542 542 printk("atyfb(%s): pllmclk=%d MHz, xclk=%d MHz\n", 543 - __FUNCTION__, pllmclk, pllmclk / pll->ct.xclk_post_div_real); 543 + __func__, pllmclk, pllmclk / pll->ct.xclk_post_div_real); 544 544 #endif 545 545 546 546 if (M64_HAS(SDRAM_MAGIC_PLL) && (par->ram_type >= SDRAM)) ··· 581 581 pllsclk = (1000000 * 2 * pll->ct.sclk_fb_div) / 582 582 (par->ref_clk_per * pll->ct.pll_ref_div); 583 583 printk("atyfb(%s): use sclk, pllsclk=%d MHz, sclk=mclk=%d MHz\n", 584 - __FUNCTION__, pllsclk, pllsclk / sclk_post_div_real); 584 + __func__, pllsclk, pllsclk / sclk_post_div_real); 585 585 #endif 586 586 } 587 587
+3 -3
drivers/video/bf54x-lq043fb.c
··· 336 336 { 337 337 338 338 if (var->bits_per_pixel != LCD_BPP) { 339 - pr_debug("%s: depth not supported: %u BPP\n", __FUNCTION__, 339 + pr_debug("%s: depth not supported: %u BPP\n", __func__, 340 340 var->bits_per_pixel); 341 341 return -EINVAL; 342 342 } ··· 345 345 info->var.xres_virtual != var->xres_virtual || 346 346 info->var.yres_virtual != var->yres_virtual) { 347 347 pr_debug("%s: Resolution not supported: X%u x Y%u \n", 348 - __FUNCTION__, var->xres, var->yres); 348 + __func__, var->xres, var->yres); 349 349 return -EINVAL; 350 350 } 351 351 ··· 355 355 356 356 if ((info->fix.line_length * var->yres_virtual) > info->fix.smem_len) { 357 357 pr_debug("%s: Memory Limit requested yres_virtual = %u\n", 358 - __FUNCTION__, var->yres_virtual); 358 + __func__, var->yres_virtual); 359 359 return -ENOMEM; 360 360 } 361 361
+1 -1
drivers/video/cfbimgblt.c
··· 38 38 #define DEBUG 39 39 40 40 #ifdef DEBUG 41 - #define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt,__FUNCTION__,## args) 41 + #define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt,__func__,## args) 42 42 #else 43 43 #define DPRINTK(fmt, args...) 44 44 #endif
+2 -2
drivers/video/cirrusfb.c
··· 81 81 /* debug output */ 82 82 #ifdef CIRRUSFB_DEBUG 83 83 #define DPRINTK(fmt, args...) \ 84 - printk(KERN_DEBUG "%s: " fmt, __FUNCTION__ , ## args) 84 + printk(KERN_DEBUG "%s: " fmt, __func__ , ## args) 85 85 #else 86 86 #define DPRINTK(fmt, args...) 87 87 #endif ··· 91 91 #define assert(expr) \ 92 92 if (!(expr)) { \ 93 93 printk("Assertion failed! %s,%s,%s,line=%d\n", \ 94 - #expr, __FILE__, __FUNCTION__, __LINE__); \ 94 + #expr, __FILE__, __func__, __LINE__); \ 95 95 } 96 96 #else 97 97 #define assert(expr)
+1 -1
drivers/video/console/fbcon.c
··· 92 92 #include "fbcon.h" 93 93 94 94 #ifdef FBCONDEBUG 95 - # define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt, __FUNCTION__ , ## args) 95 + # define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt, __func__ , ## args) 96 96 #else 97 97 # define DPRINTK(fmt, args...) 98 98 #endif
+1 -1
drivers/video/imsttfb.c
··· 1478 1478 1479 1479 dp = pci_device_to_OF_node(pdev); 1480 1480 if(dp) 1481 - printk(KERN_INFO "%s: OF name %s\n",__FUNCTION__, dp->name); 1481 + printk(KERN_INFO "%s: OF name %s\n",__func__, dp->name); 1482 1482 else 1483 1483 printk(KERN_ERR "imsttfb: no OF node for pci device\n"); 1484 1484 #endif /* CONFIG_PPC_OF */
+3 -3
drivers/video/imxfb.c
··· 415 415 static int imxfb_suspend(struct platform_device *dev, pm_message_t state) 416 416 { 417 417 struct imxfb_info *fbi = platform_get_drvdata(dev); 418 - pr_debug("%s\n",__FUNCTION__); 418 + pr_debug("%s\n",__func__); 419 419 420 420 imxfb_disable_controller(fbi); 421 421 return 0; ··· 424 424 static int imxfb_resume(struct platform_device *dev) 425 425 { 426 426 struct imxfb_info *fbi = platform_get_drvdata(dev); 427 - pr_debug("%s\n",__FUNCTION__); 427 + pr_debug("%s\n",__func__); 428 428 429 429 imxfb_enable_controller(fbi); 430 430 return 0; ··· 440 440 struct fb_info *info = dev_get_drvdata(dev); 441 441 struct imxfb_info *fbi = info->par; 442 442 443 - pr_debug("%s\n",__FUNCTION__); 443 + pr_debug("%s\n",__func__); 444 444 445 445 info->pseudo_palette = kmalloc( sizeof(u32) * 16, GFP_KERNEL); 446 446 if (!info->pseudo_palette)
+18 -18
drivers/video/matrox/matroxfb_DAC1064.c
··· 37 37 unsigned int fvco; 38 38 unsigned int p; 39 39 40 - DBG(__FUNCTION__) 40 + DBG(__func__) 41 41 42 42 /* only for devices older than G450 */ 43 43 ··· 83 83 static void DAC1064_setpclk(WPMINFO unsigned long fout) { 84 84 unsigned int m, n, p; 85 85 86 - DBG(__FUNCTION__) 86 + DBG(__func__) 87 87 88 88 DAC1064_calcclock(PMINFO fout, ACCESS_FBINFO(max_pixel_clock), &m, &n, &p); 89 89 ACCESS_FBINFO(hw).DACclk[0] = m; ··· 95 95 u_int32_t mx; 96 96 struct matrox_hw_state* hw = &ACCESS_FBINFO(hw); 97 97 98 - DBG(__FUNCTION__) 98 + DBG(__func__) 99 99 100 100 if (ACCESS_FBINFO(devflags.noinit)) { 101 101 /* read MCLK and give up... */ ··· 338 338 static int DAC1064_init_1(WPMINFO struct my_timming* m) { 339 339 struct matrox_hw_state* hw = &ACCESS_FBINFO(hw); 340 340 341 - DBG(__FUNCTION__) 341 + DBG(__func__) 342 342 343 343 memcpy(hw->DACreg, MGA1064_DAC, sizeof(MGA1064_DAC_regs)); 344 344 switch (ACCESS_FBINFO(fbcon).var.bits_per_pixel) { ··· 374 374 static int DAC1064_init_2(WPMINFO struct my_timming* m) { 375 375 struct matrox_hw_state* hw = &ACCESS_FBINFO(hw); 376 376 377 - DBG(__FUNCTION__) 377 + DBG(__func__) 378 378 379 379 if (ACCESS_FBINFO(fbcon).var.bits_per_pixel > 16) { /* 256 entries */ 380 380 int i; ··· 418 418 419 419 CRITFLAGS 420 420 421 - DBG(__FUNCTION__) 421 + DBG(__func__) 422 422 423 423 CRITBEGIN 424 424 ··· 448 448 unsigned int i; 449 449 #endif 450 450 451 - DBG(__FUNCTION__) 451 + DBG(__func__) 452 452 453 453 #ifdef DEBUG 454 454 dprintk(KERN_DEBUG "DAC1064regs "); ··· 521 521 static int MGA1064_init(WPMINFO struct my_timming* m) { 522 522 struct matrox_hw_state* hw = &ACCESS_FBINFO(hw); 523 523 524 - DBG(__FUNCTION__) 524 + DBG(__func__) 525 525 526 526 if (DAC1064_init_1(PMINFO m)) return 1; 527 527 if (matroxfb_vgaHWinit(PMINFO m)) return 1; ··· 543 543 static int MGAG100_init(WPMINFO struct my_timming* m) { 544 544 struct matrox_hw_state* hw = &ACCESS_FBINFO(hw); 545 545 546 - DBG(__FUNCTION__) 546 + DBG(__func__) 547 547 548 548 if (DAC1064_init_1(PMINFO m)) return 1; 549 549 hw->MXoptionReg &= ~0x2000; ··· 565 565 #ifdef CONFIG_FB_MATROX_MYSTIQUE 566 566 static void MGA1064_ramdac_init(WPMINFO2) { 567 567 568 - DBG(__FUNCTION__) 568 + DBG(__func__) 569 569 570 570 /* ACCESS_FBINFO(features.DAC1064.vco_freq_min) = 120000; */ 571 571 ACCESS_FBINFO(features.pll.vco_freq_min) = 62000; ··· 594 594 int selClk; 595 595 int clk; 596 596 597 - DBG(__FUNCTION__) 597 + DBG(__func__) 598 598 599 599 outDAC1064(PMINFO M1064_XPIXCLKCTRL, inDAC1064(PMINFO M1064_XPIXCLKCTRL) | M1064_XPIXCLKCTRL_DIS | 600 600 M1064_XPIXCLKCTRL_PLL_UP); ··· 636 636 static void MGAG100_setPixClock(CPMINFO int flags, int freq) { 637 637 unsigned int m, n, p; 638 638 639 - DBG(__FUNCTION__) 639 + DBG(__func__) 640 640 641 641 DAC1064_calcclock(PMINFO freq, ACCESS_FBINFO(max_pixel_clock), &m, &n, &p); 642 642 MGAG100_progPixClock(PMINFO flags, m, n, p); ··· 650 650 2048, 0}; 651 651 struct matrox_hw_state* hw = &ACCESS_FBINFO(hw); 652 652 653 - DBG(__FUNCTION__) 653 + DBG(__func__) 654 654 655 655 /* ACCESS_FBINFO(capable.cfb4) = 0; ... preinitialized by 0 */ 656 656 ACCESS_FBINFO(capable.text) = 1; ··· 683 683 684 684 static void MGA1064_reset(WPMINFO2) { 685 685 686 - DBG(__FUNCTION__); 686 + DBG(__func__); 687 687 688 688 MGA1064_ramdac_init(PMINFO2); 689 689 } ··· 819 819 u_int32_t q; 820 820 #endif 821 821 822 - DBG(__FUNCTION__) 822 + DBG(__func__) 823 823 824 824 /* there are some instabilities if in_div > 19 && vco < 61000 */ 825 825 if (ACCESS_FBINFO(devflags.g450dac)) { ··· 956 956 u_int8_t b; 957 957 struct matrox_hw_state* hw = &ACCESS_FBINFO(hw); 958 958 959 - DBG(__FUNCTION__) 959 + DBG(__func__) 960 960 961 961 { 962 962 #ifdef G100_BROKEN_IBM_82351 ··· 1015 1015 1016 1016 CRITFLAGS 1017 1017 1018 - DBG(__FUNCTION__) 1018 + DBG(__func__) 1019 1019 1020 1020 CRITBEGIN 1021 1021 ··· 1041 1041 1042 1042 CRITFLAGS 1043 1043 1044 - DBG(__FUNCTION__) 1044 + DBG(__func__) 1045 1045 1046 1046 CRITBEGIN 1047 1047
+8 -8
drivers/video/matrox/matroxfb_Ti3026.c
··· 283 283 unsigned int fvco; 284 284 unsigned int lin, lfeed, lpost; 285 285 286 - DBG(__FUNCTION__) 286 + DBG(__func__) 287 287 288 288 fvco = PLL_calcclock(PMINFO freq, fmax, &lin, &lfeed, &lpost); 289 289 fvco >>= (*post = lpost); ··· 297 297 unsigned int pixfeed, pixin, pixpost; 298 298 struct matrox_hw_state* hw = &ACCESS_FBINFO(hw); 299 299 300 - DBG(__FUNCTION__) 300 + DBG(__func__) 301 301 302 302 f_pll = Ti3026_calcclock(PMINFO clk, ACCESS_FBINFO(max_pixel_clock), &pixin, &pixfeed, &pixpost); 303 303 ··· 365 365 u_int8_t muxctrl = isInterleave(MINFO) ? TVP3026_XMUXCTRL_MEMORY_64BIT : TVP3026_XMUXCTRL_MEMORY_32BIT; 366 366 struct matrox_hw_state* hw = &ACCESS_FBINFO(hw); 367 367 368 - DBG(__FUNCTION__) 368 + DBG(__func__) 369 369 370 370 memcpy(hw->DACreg, MGADACbpp32, sizeof(hw->DACreg)); 371 371 switch (ACCESS_FBINFO(fbcon).var.bits_per_pixel) { ··· 440 440 unsigned int rfhcnt, mclk_ctl; 441 441 int tmout; 442 442 443 - DBG(__FUNCTION__) 443 + DBG(__func__) 444 444 445 445 f_pll = Ti3026_calcclock(PMINFO fout, ACCESS_FBINFO(max_pixel_clock), &mclk_n, &mclk_m, &mclk_p); 446 446 ··· 534 534 535 535 static void ti3026_ramdac_init(WPMINFO2) { 536 536 537 - DBG(__FUNCTION__) 537 + DBG(__func__) 538 538 539 539 ACCESS_FBINFO(features.pll.vco_freq_min) = 110000; 540 540 ACCESS_FBINFO(features.pll.ref_freq) = 114545; ··· 554 554 struct matrox_hw_state* hw = &ACCESS_FBINFO(hw); 555 555 CRITFLAGS 556 556 557 - DBG(__FUNCTION__) 557 + DBG(__func__) 558 558 559 559 #ifdef DEBUG 560 560 dprintk(KERN_INFO "EXTVGA regs: "); ··· 662 662 663 663 static void Ti3026_reset(WPMINFO2) { 664 664 665 - DBG(__FUNCTION__) 665 + DBG(__func__) 666 666 667 667 ti3026_ramdac_init(PMINFO2); 668 668 } ··· 680 680 2048, 0}; 681 681 struct matrox_hw_state* hw = &ACCESS_FBINFO(hw); 682 682 683 - DBG(__FUNCTION__) 683 + DBG(__func__) 684 684 685 685 ACCESS_FBINFO(millenium) = 1; 686 686 ACCESS_FBINFO(milleniumII) = (ACCESS_FBINFO(pcidev)->device != PCI_DEVICE_ID_MATROX_MIL);
+7 -7
drivers/video/matrox/matroxfb_accel.c
··· 113 113 u_int32_t mopmode; 114 114 int accel; 115 115 116 - DBG(__FUNCTION__) 116 + DBG(__func__) 117 117 118 118 mpitch = ACCESS_FBINFO(fbcon).var.xres_virtual; 119 119 ··· 199 199 int start, end; 200 200 CRITFLAGS 201 201 202 - DBG(__FUNCTION__) 202 + DBG(__func__) 203 203 204 204 CRITBEGIN 205 205 ··· 235 235 int start, end; 236 236 CRITFLAGS 237 237 238 - DBG(__FUNCTION__) 238 + DBG(__func__) 239 239 240 240 CRITBEGIN 241 241 ··· 287 287 int width) { 288 288 CRITFLAGS 289 289 290 - DBG(__FUNCTION__) 290 + DBG(__func__) 291 291 292 292 CRITBEGIN 293 293 ··· 315 315 int whattodo; 316 316 CRITFLAGS 317 317 318 - DBG(__FUNCTION__) 318 + DBG(__func__) 319 319 320 320 CRITBEGIN 321 321 ··· 388 388 int easy; 389 389 CRITFLAGS 390 390 391 - DBG_HEAVY(__FUNCTION__); 391 + DBG_HEAVY(__func__); 392 392 393 393 step = (width + 7) >> 3; 394 394 charcell = height * step; ··· 469 469 static void matroxfb_imageblit(struct fb_info* info, const struct fb_image* image) { 470 470 MINFO_FROM_INFO(info); 471 471 472 - DBG_HEAVY(__FUNCTION__); 472 + DBG_HEAVY(__func__); 473 473 474 474 if (image->depth == 1) { 475 475 u_int32_t fgx, bgx;
+21 -21
drivers/video/matrox/matroxfb_base.c
··· 312 312 313 313 CRITFLAGS 314 314 315 - DBG(__FUNCTION__) 315 + DBG(__func__) 316 316 317 317 if (ACCESS_FBINFO(dead)) 318 318 return; ··· 392 392 { 393 393 MINFO_FROM_INFO(info); 394 394 395 - DBG_LOOP(__FUNCTION__) 395 + DBG_LOOP(__func__) 396 396 397 397 if (ACCESS_FBINFO(dead)) { 398 398 return -ENXIO; ··· 408 408 { 409 409 MINFO_FROM_INFO(info); 410 410 411 - DBG_LOOP(__FUNCTION__) 411 + DBG_LOOP(__func__) 412 412 413 413 if (user) { 414 414 if (0 == --ACCESS_FBINFO(userusecount)) { ··· 425 425 struct fb_info* info) { 426 426 MINFO_FROM_INFO(info); 427 427 428 - DBG(__FUNCTION__) 428 + DBG(__func__) 429 429 430 430 matrox_pan_var(PMINFO var); 431 431 return 0; ··· 434 434 static int matroxfb_get_final_bppShift(CPMINFO int bpp) { 435 435 int bppshft2; 436 436 437 - DBG(__FUNCTION__) 437 + DBG(__func__) 438 438 439 439 bppshft2 = bpp; 440 440 if (!bppshft2) { ··· 451 451 int over; 452 452 int rounding; 453 453 454 - DBG(__FUNCTION__) 454 + DBG(__func__) 455 455 456 456 switch (bpp) { 457 457 case 0: return xres; ··· 482 482 const int* width; 483 483 int xres_new; 484 484 485 - DBG(__FUNCTION__) 485 + DBG(__func__) 486 486 487 487 if (!bpp) return xres; 488 488 ··· 504 504 505 505 static int matroxfb_get_cmap_len(struct fb_var_screeninfo *var) { 506 506 507 - DBG(__FUNCTION__) 507 + DBG(__func__) 508 508 509 509 switch (var->bits_per_pixel) { 510 510 case 4: ··· 548 548 unsigned int vramlen; 549 549 unsigned int memlen; 550 550 551 - DBG(__FUNCTION__) 551 + DBG(__func__) 552 552 553 553 switch (bpp) { 554 554 case 4: if (!ACCESS_FBINFO(capable.cfb4)) return -EINVAL; ··· 648 648 struct matrox_fb_info* minfo = container_of(fb_info, struct matrox_fb_info, fbcon); 649 649 #endif 650 650 651 - DBG(__FUNCTION__) 651 + DBG(__func__) 652 652 653 653 /* 654 654 * Set a single color register. The values supplied are ··· 707 707 static void matroxfb_init_fix(WPMINFO2) 708 708 { 709 709 struct fb_fix_screeninfo *fix = &ACCESS_FBINFO(fbcon).fix; 710 - DBG(__FUNCTION__) 710 + DBG(__func__) 711 711 712 712 strcpy(fix->id,"MATROX"); 713 713 ··· 722 722 static void matroxfb_update_fix(WPMINFO2) 723 723 { 724 724 struct fb_fix_screeninfo *fix = &ACCESS_FBINFO(fbcon).fix; 725 - DBG(__FUNCTION__) 725 + DBG(__func__) 726 726 727 727 fix->smem_start = ACCESS_FBINFO(video.base) + ACCESS_FBINFO(curr.ydstorg.bytes); 728 728 fix->smem_len = ACCESS_FBINFO(video.len_usable) - ACCESS_FBINFO(curr.ydstorg.bytes); ··· 753 753 struct fb_var_screeninfo *var; 754 754 MINFO_FROM_INFO(info); 755 755 756 - DBG(__FUNCTION__) 756 + DBG(__func__) 757 757 758 758 if (ACCESS_FBINFO(dead)) { 759 759 return -ENXIO; ··· 876 876 void __user *argp = (void __user *)arg; 877 877 MINFO_FROM_INFO(info); 878 878 879 - DBG(__FUNCTION__) 879 + DBG(__func__) 880 880 881 881 if (ACCESS_FBINFO(dead)) { 882 882 return -ENXIO; ··· 1175 1175 CRITFLAGS 1176 1176 MINFO_FROM_INFO(info); 1177 1177 1178 - DBG(__FUNCTION__) 1178 + DBG(__func__) 1179 1179 1180 1180 if (ACCESS_FBINFO(dead)) 1181 1181 return 1; ··· 1287 1287 unsigned char bytes[32]; 1288 1288 unsigned char* tmp; 1289 1289 1290 - DBG(__FUNCTION__) 1290 + DBG(__func__) 1291 1291 1292 1292 vm = ACCESS_FBINFO(video.vbase); 1293 1293 maxSize &= ~0x1FFFFF; /* must be X*2MB (really it must be 2 or X*4MB) */ ··· 1593 1593 { }, 1594 1594 }; 1595 1595 1596 - DBG(__FUNCTION__) 1596 + DBG(__func__) 1597 1597 1598 1598 /* set default values... */ 1599 1599 vesafb_defined.accel_flags = FB_ACCELF_TEXT; ··· 2006 2006 #ifndef CONFIG_FB_MATROX_MULTIHEAD 2007 2007 static int registered = 0; 2008 2008 #endif 2009 - DBG(__FUNCTION__) 2009 + DBG(__func__) 2010 2010 2011 2011 svid = pdev->subsystem_vendor; 2012 2012 sid = pdev->subsystem_device; ··· 2301 2301 static int __init matroxfb_setup(char *options) { 2302 2302 char *this_opt; 2303 2303 2304 - DBG(__FUNCTION__) 2304 + DBG(__func__) 2305 2305 2306 2306 if (!options || !*options) 2307 2307 return 0; ··· 2444 2444 char *option = NULL; 2445 2445 int err = 0; 2446 2446 2447 - DBG(__FUNCTION__) 2447 + DBG(__func__) 2448 2448 2449 2449 if (fb_get_options("matroxfb", &option)) 2450 2450 return -ENODEV; ··· 2556 2556 2557 2557 int __init init_module(void){ 2558 2558 2559 - DBG(__FUNCTION__) 2559 + DBG(__func__) 2560 2560 2561 2561 if (disabled) 2562 2562 return -ENXIO;
+1 -1
drivers/video/matrox/matroxfb_crtc2.c
··· 420 420 #define m2info (container_of(info, struct matroxfb_dh_fb_info, fbcon)) 421 421 MINFO_FROM(m2info->primary_dev); 422 422 423 - DBG(__FUNCTION__) 423 + DBG(__func__) 424 424 425 425 switch (cmd) { 426 426 case FBIOGET_VBLANK:
+1 -1
drivers/video/matrox/matroxfb_maven.c
··· 220 220 unsigned int scrlen; 221 221 unsigned int fmax; 222 222 223 - DBG(__FUNCTION__) 223 + DBG(__func__) 224 224 225 225 scrlen = htotal * (vtotal - 1); 226 226 fwant = htotal * vtotal;
+6 -6
drivers/video/matrox/matroxfb_misc.c
··· 90 90 #include <linux/matroxfb.h> 91 91 92 92 void matroxfb_DAC_out(CPMINFO int reg, int val) { 93 - DBG_REG(__FUNCTION__) 93 + DBG_REG(__func__) 94 94 mga_outb(M_RAMDAC_BASE+M_X_INDEX, reg); 95 95 mga_outb(M_RAMDAC_BASE+M_X_DATAREG, val); 96 96 } 97 97 98 98 int matroxfb_DAC_in(CPMINFO int reg) { 99 - DBG_REG(__FUNCTION__) 99 + DBG_REG(__func__) 100 100 mga_outb(M_RAMDAC_BASE+M_X_INDEX, reg); 101 101 return mga_inb(M_RAMDAC_BASE+M_X_DATAREG); 102 102 } ··· 104 104 void matroxfb_var2my(struct fb_var_screeninfo* var, struct my_timming* mt) { 105 105 unsigned int pixclock = var->pixclock; 106 106 107 - DBG(__FUNCTION__) 107 + DBG(__func__) 108 108 109 109 if (!pixclock) pixclock = 10000; /* 10ns = 100MHz */ 110 110 mt->pixclock = 1000000000 / pixclock; ··· 131 131 unsigned int fwant; 132 132 unsigned int p; 133 133 134 - DBG(__FUNCTION__) 134 + DBG(__func__) 135 135 136 136 fwant = freq; 137 137 ··· 192 192 int i; 193 193 struct matrox_hw_state * const hw = &ACCESS_FBINFO(hw); 194 194 195 - DBG(__FUNCTION__) 195 + DBG(__func__) 196 196 197 197 hw->SEQ[0] = 0x00; 198 198 hw->SEQ[1] = 0x01; /* or 0x09 */ ··· 336 336 struct matrox_hw_state * const hw = &ACCESS_FBINFO(hw); 337 337 CRITFLAGS 338 338 339 - DBG(__FUNCTION__) 339 + DBG(__func__) 340 340 341 341 dprintk(KERN_INFO "MiscOutReg: %02X\n", hw->MiscOutReg); 342 342 dprintk(KERN_INFO "SEQ regs: ");
+1 -1
drivers/video/modedb.c
··· 22 22 ((v).xres == (x) && (v).yres == (y)) 23 23 24 24 #ifdef DEBUG 25 - #define DPRINTK(fmt, args...) printk("modedb %s: " fmt, __FUNCTION__ , ## args) 25 + #define DPRINTK(fmt, args...) printk("modedb %s: " fmt, __func__ , ## args) 26 26 #else 27 27 #define DPRINTK(fmt, args...) 28 28 #endif
+3 -3
drivers/video/nvidia/nvidia.c
··· 43 43 #define NVTRACE if (0) printk 44 44 #endif 45 45 46 - #define NVTRACE_ENTER(...) NVTRACE("%s START\n", __FUNCTION__) 47 - #define NVTRACE_LEAVE(...) NVTRACE("%s END\n", __FUNCTION__) 46 + #define NVTRACE_ENTER(...) NVTRACE("%s START\n", __func__) 47 + #define NVTRACE_LEAVE(...) NVTRACE("%s END\n", __func__) 48 48 49 49 #ifdef CONFIG_FB_NVIDIA_DEBUG 50 50 #define assert(expr) \ 51 51 if (!(expr)) { \ 52 52 printk( "Assertion failed! %s,%s,%s,line=%d\n",\ 53 - #expr,__FILE__,__FUNCTION__,__LINE__); \ 53 + #expr,__FILE__,__func__,__LINE__); \ 54 54 BUG(); \ 55 55 } 56 56 #else
+1 -1
drivers/video/pm2fb.c
··· 56 56 #undef PM2FB_MASTER_DEBUG 57 57 #ifdef PM2FB_MASTER_DEBUG 58 58 #define DPRINTK(a, b...) \ 59 - printk(KERN_DEBUG "pm2fb: %s: " a, __FUNCTION__ , ## b) 59 + printk(KERN_DEBUG "pm2fb: %s: " a, __func__ , ## b) 60 60 #else 61 61 #define DPRINTK(a, b...) 62 62 #endif
+1 -1
drivers/video/pm3fb.c
··· 45 45 #undef PM3FB_MASTER_DEBUG 46 46 #ifdef PM3FB_MASTER_DEBUG 47 47 #define DPRINTK(a, b...) \ 48 - printk(KERN_DEBUG "pm3fb: %s: " a, __FUNCTION__ , ## b) 48 + printk(KERN_DEBUG "pm3fb: %s: " a, __func__ , ## b) 49 49 #else 50 50 #define DPRINTK(a, b...) 51 51 #endif
+3 -3
drivers/video/riva/fbdev.c
··· 70 70 #define NVTRACE if(0) printk 71 71 #endif 72 72 73 - #define NVTRACE_ENTER(...) NVTRACE("%s START\n", __FUNCTION__) 74 - #define NVTRACE_LEAVE(...) NVTRACE("%s END\n", __FUNCTION__) 73 + #define NVTRACE_ENTER(...) NVTRACE("%s START\n", __func__) 74 + #define NVTRACE_LEAVE(...) NVTRACE("%s END\n", __func__) 75 75 76 76 #ifdef CONFIG_FB_RIVA_DEBUG 77 77 #define assert(expr) \ 78 78 if(!(expr)) { \ 79 79 printk( "Assertion failed! %s,%s,%s,line=%d\n",\ 80 - #expr,__FILE__,__FUNCTION__,__LINE__); \ 80 + #expr,__FILE__,__func__,__LINE__); \ 81 81 BUG(); \ 82 82 } 83 83 #else
+3 -3
drivers/video/s3c2410fb.c
··· 430 430 struct fb_var_screeninfo *var = &info->var; 431 431 int clkdiv = s3c2410fb_calc_pixclk(fbi, var->pixclock) / 2; 432 432 433 - dprintk("%s: var->xres = %d\n", __FUNCTION__, var->xres); 434 - dprintk("%s: var->yres = %d\n", __FUNCTION__, var->yres); 435 - dprintk("%s: var->bpp = %d\n", __FUNCTION__, var->bits_per_pixel); 433 + dprintk("%s: var->xres = %d\n", __func__, var->xres); 434 + dprintk("%s: var->yres = %d\n", __func__, var->yres); 435 + dprintk("%s: var->bpp = %d\n", __func__, var->bits_per_pixel); 436 436 437 437 if (type == S3C2410_LCDCON1_TFT) { 438 438 s3c2410fb_calculate_tft_lcd_regs(info, &fbi->regs);
+1 -1
drivers/video/sa1100fb.h
··· 132 132 * Debug macros 133 133 */ 134 134 #if DEBUG 135 - # define DPRINTK(fmt, args...) printk("%s: " fmt, __FUNCTION__ , ## args) 135 + # define DPRINTK(fmt, args...) printk("%s: " fmt, __func__ , ## args) 136 136 #else 137 137 # define DPRINTK(fmt, args...) 138 138 #endif
+1 -1
drivers/video/sis/sis.h
··· 55 55 #undef SISFBDEBUG 56 56 57 57 #ifdef SISFBDEBUG 58 - #define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt, __FUNCTION__ , ## args) 58 + #define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt, __func__ , ## args) 59 59 #define TWDEBUG(x) printk(KERN_INFO x "\n"); 60 60 #else 61 61 #define DPRINTK(fmt, args...)
+5 -5
drivers/video/sstfb.c
··· 1006 1006 break; 1007 1007 default: 1008 1008 dprintk("%s: wrong clock code '%d'\n", 1009 - __FUNCTION__, clock); 1009 + __func__, clock); 1010 1010 return 0; 1011 1011 } 1012 1012 udelay(300); ··· 1048 1048 break; 1049 1049 default: 1050 1050 dprintk("%s: wrong clock code '%d'\n", 1051 - __FUNCTION__, clock); 1051 + __func__, clock); 1052 1052 return 0; 1053 1053 } 1054 1054 udelay(300); ··· 1079 1079 sst_dac_write(DACREG_RMR, (cr0 & 0x0f) | DACREG_CR0_16BPP); 1080 1080 break; 1081 1081 default: 1082 - dprintk("%s: bad depth '%u'\n", __FUNCTION__, bpp); 1082 + dprintk("%s: bad depth '%u'\n", __func__, bpp); 1083 1083 break; 1084 1084 } 1085 1085 } ··· 1093 1093 sst_dac_write(DACREG_ICS_CMD, DACREG_ICS_CMD_16BPP); 1094 1094 break; 1095 1095 default: 1096 - dprintk("%s: bad depth '%u'\n", __FUNCTION__, bpp); 1096 + dprintk("%s: bad depth '%u'\n", __func__, bpp); 1097 1097 break; 1098 1098 } 1099 1099 } ··· 1133 1133 } 1134 1134 if (!ret) 1135 1135 return 0; 1136 - f_dprintk("%s found %s\n", __FUNCTION__, dacs[i].name); 1136 + f_dprintk("%s found %s\n", __func__, dacs[i].name); 1137 1137 par->dac_sw = dacs[i]; 1138 1138 return 1; 1139 1139 }
+2 -2
drivers/video/stifb.c
··· 164 164 # define DEBUG_ON() debug_on=1 165 165 # define WRITE_BYTE(value,fb,reg) do { if (debug_on) \ 166 166 printk(KERN_DEBUG "%30s: WRITE_BYTE(0x%06x) = 0x%02x (old=0x%02x)\n", \ 167 - __FUNCTION__, reg, value, READ_BYTE(fb,reg)); \ 167 + __func__, reg, value, READ_BYTE(fb,reg)); \ 168 168 gsc_writeb((value),(fb)->info.fix.mmio_start + (reg)); } while (0) 169 169 # define WRITE_WORD(value,fb,reg) do { if (debug_on) \ 170 170 printk(KERN_DEBUG "%30s: WRITE_WORD(0x%06x) = 0x%08x (old=0x%08x)\n", \ 171 - __FUNCTION__, reg, value, READ_WORD(fb,reg)); \ 171 + __func__, reg, value, READ_WORD(fb,reg)); \ 172 172 gsc_writel((value),(fb)->info.fix.mmio_start + (reg)); } while (0) 173 173 #endif /* DEBUG_STIFB_REGS */ 174 174
+1 -1
drivers/video/sysimgblt.c
··· 18 18 #define DEBUG 19 19 20 20 #ifdef DEBUG 21 - #define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt,__FUNCTION__,## args) 21 + #define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt,__func__,## args) 22 22 #else 23 23 #define DPRINTK(fmt, args...) 24 24 #endif
+1 -1
drivers/video/tdfxfb.c
··· 70 70 71 71 #include <video/tdfx.h> 72 72 73 - #define DPRINTK(a, b...) pr_debug("fb: %s: " a, __FUNCTION__ , ## b) 73 + #define DPRINTK(a, b...) pr_debug("fb: %s: " a, __func__ , ## b) 74 74 75 75 #ifdef CONFIG_MTRR 76 76 #include <asm/mtrr.h>