+1 -1

hw/arm/nseries.c

··· 463 463 uint8_t ret; 464 464 465 465 if (len > 9) { 466 466 - hw_error("%s: FIXME: bad SPI word width %i\n", __FUNCTION__, len); 466 466 + hw_error("%s: FIXME: bad SPI word width %i\n", __func__, len); 467 467 } 468 468 469 469 if (s->p >= ARRAY_SIZE(s->resp)) {

+21 -21

hw/arm/omap1.c

··· 999 999 case omap1510: 1000 1000 return 0x03310115; 1001 1001 default: 1002 1002 - hw_error("%s: bad mpu model\n", __FUNCTION__); 1002 1002 + hw_error("%s: bad mpu model\n", __func__); 1003 1003 } 1004 1004 break; 1005 1005 ··· 1010 1010 case omap1510: 1011 1011 return 0xfb47002f; 1012 1012 default: 1013 1013 - hw_error("%s: bad mpu model\n", __FUNCTION__); 1013 1013 + hw_error("%s: bad mpu model\n", __func__); 1014 1014 } 1015 1015 break; 1016 1016 } ··· 1716 1716 case 0x18: /* ARM_SYSST */ 1717 1717 if ((s->clkm.clocking_scheme ^ (value >> 11)) & 7) { 1718 1718 s->clkm.clocking_scheme = (value >> 11) & 7; 1719 1719 - printf("%s: clocking scheme set to %s\n", __FUNCTION__, 1719 1719 + printf("%s: clocking scheme set to %s\n", __func__, 1720 1720 clkschemename[s->clkm.clocking_scheme]); 1721 1721 } 1722 1722 s->clkm.cold_start &= value & 0x3f; ··· 2129 2129 void omap_mpuio_out_set(struct omap_mpuio_s *s, int line, qemu_irq handler) 2130 2130 { 2131 2131 if (line >= 16 || line < 0) 2132 2132 - hw_error("%s: No GPIO line %i\n", __FUNCTION__, line); 2132 2132 + hw_error("%s: No GPIO line %i\n", __func__, line); 2133 2133 s->handler[line] = handler; 2134 2134 } 2135 2135 2136 2136 void omap_mpuio_key(struct omap_mpuio_s *s, int row, int col, int down) 2137 2137 { 2138 2138 if (row >= 5 || row < 0) 2139 2139 - hw_error("%s: No key %i-%i\n", __FUNCTION__, col, row); 2139 2139 + hw_error("%s: No key %i-%i\n", __func__, col, row); 2140 2140 2141 2141 if (down) 2142 2142 s->buttons[row] |= 1 << col; ··· 2313 2313 uWireSlave *slave, int chipselect) 2314 2314 { 2315 2315 if (chipselect < 0 || chipselect > 3) { 2316 2316 - fprintf(stderr, "%s: Bad chipselect %i\n", __FUNCTION__, chipselect); 2316 2316 + fprintf(stderr, "%s: Bad chipselect %i\n", __func__, chipselect); 2317 2317 exit(-1); 2318 2318 } 2319 2319 ··· 2335 2335 2336 2336 if (output != s->output) { 2337 2337 s->output = output; 2338 2338 - printf("%s: Backlight now at %i/256\n", __FUNCTION__, output); 2338 2338 + printf("%s: Backlight now at %i/256\n", __func__, output); 2339 2339 } 2340 2340 } 2341 2341 ··· 2473 2473 case 0x04: /* VRC */ 2474 2474 if ((value ^ s->vrc) & 1) { 2475 2475 if (value & 1) 2476 2476 - printf("%s: %iHz buzz on\n", __FUNCTION__, (int) 2476 2476 + printf("%s: %iHz buzz on\n", __func__, (int) 2477 2477 /* 1.5 MHz from a 12-MHz or 13-MHz PWT_CLK */ 2478 2478 ((omap_clk_getrate(s->clk) >> 3) / 2479 2479 /* Pre-multiplexer divider */ ··· 2490 2490 ((value & (1 << 5)) ? 80 : 127) / 2491 2491 (107 * 55 * 63 * 127))); 2492 2492 else 2493 2493 - printf("%s: silence!\n", __FUNCTION__); 2493 2493 + printf("%s: silence!\n", __func__); 2494 2494 } 2495 2495 s->vrc = value & 0x7f; 2496 2496 break; ··· 2562 2562 { 2563 2563 s->alarm_ti = mktimegm(&s->alarm_tm); 2564 2564 if (s->alarm_ti == -1) 2565 2565 - printf("%s: conversion failed\n", __FUNCTION__); 2565 2565 + printf("%s: conversion failed\n", __func__); 2566 2566 } 2567 2567 2568 2568 static uint64_t omap_rtc_read(void *opaque, hwaddr addr, ··· 3028 3028 if (!s->rx_rate) 3029 3029 return; 3030 3030 if (s->rx_req) 3031 3031 - printf("%s: Rx FIFO overrun\n", __FUNCTION__); 3031 3031 + printf("%s: Rx FIFO overrun\n", __func__); 3032 3032 3033 3033 s->rx_req = s->rx_rate << bps[(s->rcr[0] >> 5) & 7]; 3034 3034 ··· 3074 3074 if (!s->tx_rate) 3075 3075 return; 3076 3076 if (s->tx_req) 3077 3077 - printf("%s: Tx FIFO underrun\n", __FUNCTION__); 3077 3077 + printf("%s: Tx FIFO underrun\n", __func__); 3078 3078 3079 3079 s->tx_req = s->tx_rate << bps[(s->xcr[0] >> 5) & 7]; 3080 3080 ··· 3176 3176 /* Fall through. */ 3177 3177 case 0x02: /* DRR1 */ 3178 3178 if (s->rx_req < 2) { 3179 3179 - printf("%s: Rx FIFO underrun\n", __FUNCTION__); 3179 3179 + printf("%s: Rx FIFO underrun\n", __func__); 3180 3180 omap_mcbsp_rx_done(s); 3181 3181 } else { 3182 3182 s->tx_req -= 2; ··· 3282 3282 if (s->tx_req < 2) 3283 3283 omap_mcbsp_tx_done(s); 3284 3284 } else 3285 3285 - printf("%s: Tx FIFO overrun\n", __FUNCTION__); 3285 3285 + printf("%s: Tx FIFO overrun\n", __func__); 3286 3286 return; 3287 3287 3288 3288 case 0x08: /* SPCR2 */ ··· 3297 3297 s->spcr[0] &= 0x0006; 3298 3298 s->spcr[0] |= 0xf8f9 & value; 3299 3299 if (value & (1 << 15)) /* DLB */ 3300 3300 - printf("%s: Digital Loopback mode enable attempt\n", __FUNCTION__); 3300 3300 + printf("%s: Digital Loopback mode enable attempt\n", __func__); 3301 3301 if (~value & 1) { /* RRST */ 3302 3302 s->spcr[0] &= ~6; 3303 3303 s->rx_req = 0; ··· 3330 3330 s->mcr[1] = value & 0x03e3; 3331 3331 if (value & 3) /* XMCM */ 3332 3332 printf("%s: Tx channel selection mode enable attempt\n", 3333 3333 - __FUNCTION__); 3333 3333 + __func__); 3334 3334 return; 3335 3335 case 0x1a: /* MCR1 */ 3336 3336 s->mcr[0] = value & 0x03e1; 3337 3337 if (value & 1) /* RMCM */ 3338 3338 printf("%s: Rx channel selection mode enable attempt\n", 3339 3339 - __FUNCTION__); 3339 3339 + __func__); 3340 3340 return; 3341 3341 case 0x1c: /* RCERA */ 3342 3342 s->rcer[0] = value & 0xffff; ··· 3418 3418 if (s->tx_req < 4) 3419 3419 omap_mcbsp_tx_done(s); 3420 3420 } else 3421 3421 - printf("%s: Tx FIFO overrun\n", __FUNCTION__); 3421 3421 + printf("%s: Tx FIFO overrun\n", __func__); 3422 3422 return; 3423 3423 } 3424 3424 ··· 3536 3536 timer_mod(s->tm, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + s->on); 3537 3537 3538 3538 s->cycle = !s->cycle; 3539 3539 - printf("%s: LED is %s\n", __FUNCTION__, s->cycle ? "on" : "off"); 3539 3539 + printf("%s: LED is %s\n", __func__, s->cycle ? "on" : "off"); 3540 3540 } 3541 3541 3542 3542 static void omap_lpg_update(struct omap_lpg_s *s) ··· 3557 3557 3558 3558 timer_del(s->tm); 3559 3559 if (on == period && s->on < s->period) 3560 3560 - printf("%s: LED is on\n", __FUNCTION__); 3560 3560 + printf("%s: LED is on\n", __func__); 3561 3561 else if (on == 0 && s->on) 3562 3562 - printf("%s: LED is off\n", __FUNCTION__); 3562 3562 + printf("%s: LED is off\n", __func__); 3563 3563 else if (on && (on != s->on || period != s->period)) { 3564 3564 s->cycle = 0; 3565 3565 s->on = on;

+6 -6

hw/arm/omap2.c

··· 1312 1312 1313 1313 if (mode[0] == 1 || mode[0] == 2 || mode[1] == 1 || mode[1] == 2) 1314 1314 fprintf(stderr, "%s: bad EN_54M_PLL or bad EN_96M_PLL\n", 1315 1315 - __FUNCTION__); 1315 1315 + __func__); 1316 1316 } 1317 1317 1318 1318 static void omap_prcm_dpll_update(struct omap_prcm_s *s) ··· 1331 1331 s->dpll_lock = 0; 1332 1332 switch (mode) { 1333 1333 case 0: 1334 1334 - fprintf(stderr, "%s: bad EN_DPLL\n", __FUNCTION__); 1334 1334 + fprintf(stderr, "%s: bad EN_DPLL\n", __func__); 1335 1335 break; 1336 1336 case 1: /* Low-power bypass mode (Default) */ 1337 1337 case 2: /* Fast-relock bypass mode */ ··· 1358 1358 omap_clk_reparent(core, dpll_x2); 1359 1359 break; 1360 1360 case 3: 1361 1361 - fprintf(stderr, "%s: bad CORE_CLK_SRC\n", __FUNCTION__); 1361 1361 + fprintf(stderr, "%s: bad CORE_CLK_SRC\n", __func__); 1362 1362 break; 1363 1363 } 1364 1364 } ··· 1628 1628 case 0x500: /* CM_CLKEN_PLL */ 1629 1629 if (value & 0xffffff30) 1630 1630 fprintf(stderr, "%s: write 0s in CM_CLKEN_PLL for " 1631 1631 - "future compatibility\n", __FUNCTION__); 1631 1631 + "future compatibility\n", __func__); 1632 1632 if ((s->clken[9] ^ value) & 0xcc) { 1633 1633 s->clken[9] &= ~0xcc; 1634 1634 s->clken[9] |= value & 0xcc; ··· 1647 1647 case 0x540: /* CM_CLKSEL1_PLL */ 1648 1648 if (value & 0xfc4000d7) 1649 1649 fprintf(stderr, "%s: write 0s in CM_CLKSEL1_PLL for " 1650 1650 - "future compatibility\n", __FUNCTION__); 1650 1650 + "future compatibility\n", __func__); 1651 1651 if ((s->clksel[5] ^ value) & 0x003fff00) { 1652 1652 s->clksel[5] = value & 0x03bfff28; 1653 1653 omap_prcm_dpll_update(s); ··· 1659 1659 case 0x544: /* CM_CLKSEL2_PLL */ 1660 1660 if (value & ~3) 1661 1661 fprintf(stderr, "%s: write 0s in CM_CLKSEL2_PLL[31:2] for " 1662 1662 - "future compatibility\n", __FUNCTION__); 1662 1662 + "future compatibility\n", __func__); 1663 1663 if (s->clksel[6] != (value & 3)) { 1664 1664 s->clksel[6] = value & 3; 1665 1665 omap_prcm_dpll_update(s);

+7 -7

hw/arm/palm.c

··· 44 44 { 45 45 #ifdef SPY 46 46 printf("%s: value %08lx written at " PA_FMT "\n", 47 47 - __FUNCTION__, value, offset); 47 47 + __func__, value, offset); 48 48 #endif 49 49 } 50 50 ··· 127 127 switch (line) { 128 128 case 0: 129 129 printf("%s: current to MMC/SD card %sabled.\n", 130 130 - __FUNCTION__, level ? "dis" : "en"); 130 130 + __func__, level ? "dis" : "en"); 131 131 break; 132 132 case 1: 133 133 printf("%s: internal speaker amplifier %s.\n", 134 134 - __FUNCTION__, level ? "down" : "on"); 134 134 + __func__, level ? "down" : "on"); 135 135 break; 136 136 137 137 /* These LCD & Audio output signals have not been identified yet. */ ··· 139 139 case 3: 140 140 case 4: 141 141 printf("%s: LCD GPIO%i %s.\n", 142 142 - __FUNCTION__, line - 1, level ? "high" : "low"); 142 142 + __func__, line - 1, level ? "high" : "low"); 143 143 break; 144 144 case 5: 145 145 case 6: 146 146 printf("%s: Audio GPIO%i %s.\n", 147 147 - __FUNCTION__, line - 4, level ? "high" : "low"); 147 147 + __func__, line - 4, level ? "high" : "low"); 148 148 break; 149 149 } 150 150 } ··· 234 234 rom_size = get_image_size(option_rom[0].name); 235 235 if (rom_size > flash_size) { 236 236 fprintf(stderr, "%s: ROM image too big (%x > %x)\n", 237 237 - __FUNCTION__, rom_size, flash_size); 237 237 + __func__, rom_size, flash_size); 238 238 rom_size = 0; 239 239 } 240 240 if (rom_size > 0) { ··· 244 244 } 245 245 if (rom_size < 0) { 246 246 fprintf(stderr, "%s: error loading '%s'\n", 247 247 - __FUNCTION__, option_rom[0].name); 247 247 + __func__, option_rom[0].name); 248 248 } 249 249 } 250 250

+23 -23

hw/arm/pxa2xx.c

··· 107 107 return s->pm_regs[addr >> 2]; 108 108 default: 109 109 fail: 110 110 - printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr); 110 110 + printf("%s: Bad register " REG_FMT "\n", __func__, addr); 111 111 break; 112 112 } 113 113 return 0; ··· 139 139 break; 140 140 } 141 141 142 142 - printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr); 142 142 + printf("%s: Bad register " REG_FMT "\n", __func__, addr); 143 143 break; 144 144 } 145 145 } ··· 180 180 return s->cm_regs[CCCR >> 2] | (3 << 28); 181 181 182 182 default: 183 183 - printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr); 183 183 + printf("%s: Bad register " REG_FMT "\n", __func__, addr); 184 184 break; 185 185 } 186 186 return 0; ··· 205 205 break; 206 206 207 207 default: 208 208 - printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr); 208 208 + printf("%s: Bad register " REG_FMT "\n", __func__, addr); 209 209 break; 210 210 } 211 211 } ··· 410 410 return s->mm_regs[addr >> 2]; 411 411 412 412 default: 413 413 - printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr); 413 413 + printf("%s: Bad register " REG_FMT "\n", __func__, addr); 414 414 break; 415 415 } 416 416 return 0; ··· 429 429 } 430 430 431 431 default: 432 432 - printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr); 432 432 + printf("%s: Bad register " REG_FMT "\n", __func__, addr); 433 433 break; 434 434 } 435 435 } ··· 619 619 if (!s->enable) 620 620 return 0xffffffff; 621 621 if (s->rx_level < 1) { 622 622 - printf("%s: SSP Rx Underrun\n", __FUNCTION__); 622 622 + printf("%s: SSP Rx Underrun\n", __func__); 623 623 return 0xffffffff; 624 624 } 625 625 s->rx_level --; ··· 636 636 case SSACD: 637 637 return s->ssacd; 638 638 default: 639 639 - printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr); 639 639 + printf("%s: Bad register " REG_FMT "\n", __func__, addr); 640 640 break; 641 641 } 642 642 return 0; ··· 653 653 s->sscr[0] = value & 0xc7ffffff; 654 654 s->enable = value & SSCR0_SSE; 655 655 if (value & SSCR0_MOD) 656 656 - printf("%s: Attempt to use network mode\n", __FUNCTION__); 656 656 + printf("%s: Attempt to use network mode\n", __func__); 657 657 if (s->enable && SSCR0_DSS(value) < 4) 658 658 - printf("%s: Wrong data size: %i bits\n", __FUNCTION__, 658 658 + printf("%s: Wrong data size: %i bits\n", __func__, 659 659 SSCR0_DSS(value)); 660 660 if (!(value & SSCR0_SSE)) { 661 661 s->sssr = 0; ··· 668 668 case SSCR1: 669 669 s->sscr[1] = value; 670 670 if (value & (SSCR1_LBM | SSCR1_EFWR)) 671 671 - printf("%s: Attempt to use SSP test mode\n", __FUNCTION__); 671 671 + printf("%s: Attempt to use SSP test mode\n", __func__); 672 672 pxa2xx_ssp_fifo_update(s); 673 673 break; 674 674 ··· 728 728 break; 729 729 730 730 default: 731 731 - printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr); 731 731 + printf("%s: Bad register " REG_FMT "\n", __func__, addr); 732 732 break; 733 733 } 734 734 } ··· 990 990 else 991 991 return s->last_swcr; 992 992 default: 993 993 - printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr); 993 993 + printf("%s: Bad register " REG_FMT "\n", __func__, addr); 994 994 break; 995 995 } 996 996 return 0; ··· 1096 1096 break; 1097 1097 1098 1098 default: 1099 1099 - printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr); 1099 1099 + printf("%s: Bad register " REG_FMT "\n", __func__, addr); 1100 1100 } 1101 1101 } 1102 1102 ··· 1344 1344 s->ibmr = 0; 1345 1345 return s->ibmr; 1346 1346 default: 1347 1347 - printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr); 1347 1347 + printf("%s: Bad register " REG_FMT "\n", __func__, addr); 1348 1348 break; 1349 1349 } 1350 1350 return 0; ··· 1417 1417 break; 1418 1418 1419 1419 default: 1420 1420 - printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr); 1420 1420 + printf("%s: Bad register " REG_FMT "\n", __func__, addr); 1421 1421 } 1422 1422 } 1423 1423 ··· 1618 1618 } 1619 1619 return 0; 1620 1620 default: 1621 1621 - printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr); 1621 1621 + printf("%s: Bad register " REG_FMT "\n", __func__, addr); 1622 1622 break; 1623 1623 } 1624 1624 return 0; ··· 1641 1641 s->status &= ~(1 << 7); /* I2SOFF */ 1642 1642 } 1643 1643 if (value & (1 << 4)) /* EFWR */ 1644 1644 - printf("%s: Attempt to use special function\n", __FUNCTION__); 1644 1644 + printf("%s: Attempt to use special function\n", __func__); 1645 1645 s->enable = (value & 9) == 1; /* ENB && !RST*/ 1646 1646 pxa2xx_i2s_update(s); 1647 1647 break; 1648 1648 case SACR1: 1649 1649 s->control[1] = value & 0x0039; 1650 1650 if (value & (1 << 5)) /* ENLBF */ 1651 1651 - printf("%s: Attempt to use loopback function\n", __FUNCTION__); 1651 1651 + printf("%s: Attempt to use loopback function\n", __func__); 1652 1652 if (value & (1 << 4)) /* DPRL */ 1653 1653 s->fifo_len = 0; 1654 1654 pxa2xx_i2s_update(s); ··· 1675 1675 } 1676 1676 break; 1677 1677 default: 1678 1678 - printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr); 1678 1678 + printf("%s: Bad register " REG_FMT "\n", __func__, addr); 1679 1679 } 1680 1680 } 1681 1681 ··· 1851 1851 pxa2xx_fir_update(s); 1852 1852 return ret; 1853 1853 } 1854 1854 - printf("%s: Rx FIFO underrun.\n", __FUNCTION__); 1854 1854 + printf("%s: Rx FIFO underrun.\n", __func__); 1855 1855 break; 1856 1856 case ICSR0: 1857 1857 return s->status[0]; ··· 1860 1860 case ICFOR: 1861 1861 return s->rx_len; 1862 1862 default: 1863 1863 - printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr); 1863 1863 + printf("%s: Bad register " REG_FMT "\n", __func__, addr); 1864 1864 break; 1865 1865 } 1866 1866 return 0; ··· 1912 1912 case ICFOR: 1913 1913 break; 1914 1914 default: 1915 1915 - printf("%s: Bad register " REG_FMT "\n", __FUNCTION__, addr); 1915 1915 + printf("%s: Bad register " REG_FMT "\n", __func__, addr); 1916 1916 } 1917 1917 } 1918 1918

+3 -3

hw/arm/pxa2xx_gpio.c

··· 107 107 uint32_t mask; 108 108 109 109 if (line >= s->lines) { 110 110 - printf("%s: No GPIO pin %i\n", __FUNCTION__, line); 110 110 + printf("%s: No GPIO pin %i\n", __func__, line); 111 111 return; 112 112 } 113 113 ··· 195 195 return s->status[bank]; 196 196 197 197 default: 198 198 - hw_error("%s: Bad offset " REG_FMT "\n", __FUNCTION__, offset); 198 198 + hw_error("%s: Bad offset " REG_FMT "\n", __func__, offset); 199 199 } 200 200 201 201 return 0; ··· 248 248 break; 249 249 250 250 default: 251 251 - hw_error("%s: Bad offset " REG_FMT "\n", __FUNCTION__, offset); 251 251 + hw_error("%s: Bad offset " REG_FMT "\n", __func__, offset); 252 252 } 253 253 } 254 254

+2 -2

hw/arm/pxa2xx_pic.c

··· 165 165 case ICHP: /* Highest Priority register */ 166 166 return pxa2xx_pic_highest(s); 167 167 default: 168 168 - printf("%s: Bad register offset " REG_FMT "\n", __FUNCTION__, offset); 168 168 + printf("%s: Bad register offset " REG_FMT "\n", __func__, offset); 169 169 return 0; 170 170 } 171 171 } ··· 198 198 s->priority[32 + ((offset - IPR32) >> 2)] = value & 0x8000003f; 199 199 break; 200 200 default: 201 201 - printf("%s: Bad register offset " REG_FMT "\n", __FUNCTION__, offset); 201 201 + printf("%s: Bad register offset " REG_FMT "\n", __func__, offset); 202 202 return; 203 203 } 204 204 pxa2xx_pic_update(opaque);

+5 -5

hw/arm/tosa.c

··· 159 159 s->buf[s->len] = data; 160 160 if (s->len ++ > 2) { 161 161 #ifdef VERBOSE 162 162 - fprintf(stderr, "%s: message too long (%i bytes)\n", __FUNCTION__, s->len); 162 162 + fprintf(stderr, "%s: message too long (%i bytes)\n", __func__, s->len); 163 163 #endif 164 164 return 1; 165 165 } ··· 181 181 case I2C_START_SEND: 182 182 break; 183 183 case I2C_START_RECV: 184 184 - printf("%s: recv not supported!!!\n", __FUNCTION__); 184 184 + printf("%s: recv not supported!!!\n", __func__); 185 185 break; 186 186 case I2C_FINISH: 187 187 #ifdef VERBOSE 188 188 if (s->len < 2) 189 189 - printf("%s: message too short (%i bytes)\n", __FUNCTION__, s->len); 189 189 + printf("%s: message too short (%i bytes)\n", __func__, s->len); 190 190 if (s->len > 2) 191 191 - printf("%s: message too long\n", __FUNCTION__); 191 191 + printf("%s: message too long\n", __func__); 192 192 #endif 193 193 break; 194 194 default: ··· 200 200 201 201 static int tosa_dac_recv(I2CSlave *s) 202 202 { 203 203 - printf("%s: recv not supported!!!\n", __FUNCTION__); 203 203 + printf("%s: recv not supported!!!\n", __func__); 204 204 return -1; 205 205 } 206 206

+5 -5

hw/audio/hda-codec.c

··· 316 316 goto fail; 317 317 } 318 318 dprint(a, 2, "%s: nid %d (%s), verb 0x%x, payload 0x%x\n", 319 319 - __FUNCTION__, nid, node->name, verb, payload); 319 319 + __func__, nid, node->name, verb, payload); 320 320 321 321 switch (verb) { 322 322 /* all nodes */ ··· 449 449 450 450 fail: 451 451 dprint(a, 1, "%s: not handled: nid %d (%s), verb 0x%x, payload 0x%x\n", 452 452 - __FUNCTION__, nid, node ? node->name : "?", verb, payload); 452 452 + __func__, nid, node ? node->name : "?", verb, payload); 453 453 hda_codec_response(hda, true, 0); 454 454 } 455 455 ··· 484 484 485 485 a->desc = desc; 486 486 a->name = object_get_typename(OBJECT(a)); 487 487 - dprint(a, 1, "%s: cad %d\n", __FUNCTION__, a->hda.cad); 487 487 + dprint(a, 1, "%s: cad %d\n", __func__, a->hda.cad); 488 488 489 489 AUD_register_card("hda", &a->card); 490 490 for (i = 0; i < a->desc->nnodes; i++) { ··· 526 526 HDAAudioStream *st; 527 527 int i; 528 528 529 529 - dprint(a, 1, "%s\n", __FUNCTION__); 529 529 + dprint(a, 1, "%s\n", __func__); 530 530 for (i = 0; i < ARRAY_SIZE(a->st); i++) { 531 531 st = a->st + i; 532 532 if (st->node == NULL) { ··· 547 547 HDAAudioStream *st; 548 548 int i; 549 549 550 550 - dprint(a, 1, "%s\n", __FUNCTION__); 550 550 + dprint(a, 1, "%s\n", __func__); 551 551 if (version == 1) { 552 552 /* assume running_compat[] is for output streams */ 553 553 for (i = 0; i < ARRAY_SIZE(a->running_compat); i++)

+14 -14

hw/audio/intel-hda.c

··· 265 265 } else { 266 266 level = 0; 267 267 } 268 268 - dprint(d, 2, "%s: level %d [%s]\n", __FUNCTION__, 268 268 + dprint(d, 2, "%s: level %d [%s]\n", __func__, 269 269 level, msi ? "msi" : "intx"); 270 270 if (msi) { 271 271 if (level) { ··· 285 285 cad = (verb >> 28) & 0x0f; 286 286 if (verb & (1 << 27)) { 287 287 /* indirect node addressing, not specified in HDA 1.0 */ 288 288 - dprint(d, 1, "%s: indirect node addressing (guest bug?)\n", __FUNCTION__); 288 288 + dprint(d, 1, "%s: indirect node addressing (guest bug?)\n", __func__); 289 289 return -1; 290 290 } 291 291 nid = (verb >> 20) & 0x7f; ··· 293 293 294 294 codec = hda_codec_find(&d->codecs, cad); 295 295 if (codec == NULL) { 296 296 - dprint(d, 1, "%s: addressed non-existing codec\n", __FUNCTION__); 296 296 + dprint(d, 1, "%s: addressed non-existing codec\n", __func__); 297 297 return -1; 298 298 } 299 299 cdc = HDA_CODEC_DEVICE_GET_CLASS(codec); ··· 307 307 uint32_t rp, verb; 308 308 309 309 if (d->ics & ICH6_IRS_BUSY) { 310 310 - dprint(d, 2, "%s: [icw] verb 0x%08x\n", __FUNCTION__, d->icw); 310 310 + dprint(d, 2, "%s: [icw] verb 0x%08x\n", __func__, d->icw); 311 311 intel_hda_send_command(d, d->icw); 312 312 return; 313 313 } 314 314 315 315 for (;;) { 316 316 if (!(d->corb_ctl & ICH6_CORBCTL_RUN)) { 317 317 - dprint(d, 2, "%s: !run\n", __FUNCTION__); 317 317 + dprint(d, 2, "%s: !run\n", __func__); 318 318 return; 319 319 } 320 320 if ((d->corb_rp & 0xff) == d->corb_wp) { 321 321 - dprint(d, 2, "%s: corb ring empty\n", __FUNCTION__); 321 321 + dprint(d, 2, "%s: corb ring empty\n", __func__); 322 322 return; 323 323 } 324 324 if (d->rirb_count == d->rirb_cnt) { 325 325 - dprint(d, 2, "%s: rirb count reached\n", __FUNCTION__); 325 325 + dprint(d, 2, "%s: rirb count reached\n", __func__); 326 326 return; 327 327 } 328 328 ··· 331 331 verb = ldl_le_pci_dma(&d->pci, addr + 4*rp); 332 332 d->corb_rp = rp; 333 333 334 334 - dprint(d, 2, "%s: [rp 0x%x] verb 0x%08x\n", __FUNCTION__, rp, verb); 334 334 + dprint(d, 2, "%s: [rp 0x%x] verb 0x%08x\n", __func__, rp, verb); 335 335 intel_hda_send_command(d, verb); 336 336 } 337 337 } ··· 345 345 346 346 if (d->ics & ICH6_IRS_BUSY) { 347 347 dprint(d, 2, "%s: [irr] response 0x%x, cad 0x%x\n", 348 348 - __FUNCTION__, response, dev->cad); 348 348 + __func__, response, dev->cad); 349 349 d->irr = response; 350 350 d->ics &= ~(ICH6_IRS_BUSY | 0xf0); 351 351 d->ics |= (ICH6_IRS_VALID | (dev->cad << 4)); ··· 353 353 } 354 354 355 355 if (!(d->rirb_ctl & ICH6_RBCTL_DMA_EN)) { 356 356 - dprint(d, 1, "%s: rirb dma disabled, drop codec response\n", __FUNCTION__); 356 356 + dprint(d, 1, "%s: rirb dma disabled, drop codec response\n", __func__); 357 357 return; 358 358 } 359 359 ··· 365 365 d->rirb_wp = wp; 366 366 367 367 dprint(d, 2, "%s: [wp 0x%x] response 0x%x, extra 0x%x\n", 368 368 - __FUNCTION__, wp, response, ex); 368 368 + __func__, wp, response, ex); 369 369 370 370 d->rirb_count++; 371 371 if (d->rirb_count == d->rirb_cnt) { 372 372 - dprint(d, 2, "%s: rirb count reached (%d)\n", __FUNCTION__, d->rirb_count); 372 372 + dprint(d, 2, "%s: rirb count reached (%d)\n", __func__, d->rirb_count); 373 373 if (d->rirb_ctl & ICH6_RBCTL_IRQ_EN) { 374 374 d->rirb_sts |= ICH6_RBSTS_IRQ; 375 375 intel_hda_update_irq(d); 376 376 } 377 377 } else if ((d->corb_rp & 0xff) == d->corb_wp) { 378 378 - dprint(d, 2, "%s: corb ring empty (%d/%d)\n", __FUNCTION__, 378 378 + dprint(d, 2, "%s: corb ring empty (%d/%d)\n", __func__, 379 379 d->rirb_count, d->rirb_cnt); 380 380 if (d->rirb_ctl & ICH6_RBCTL_IRQ_EN) { 381 381 d->rirb_sts |= ICH6_RBSTS_IRQ; ··· 1144 1144 IntelHDAState* d = opaque; 1145 1145 int i; 1146 1146 1147 1147 - dprint(d, 1, "%s\n", __FUNCTION__); 1147 1147 + dprint(d, 1, "%s\n", __func__); 1148 1148 for (i = 0; i < ARRAY_SIZE(d->st); i++) { 1149 1149 if (d->st[i].ctl & 0x02) { 1150 1150 intel_hda_parse_bdl(d, &d->st[i]);

+2 -2

hw/audio/wm8750.c

··· 315 315 #ifdef VERBOSE 316 316 if (s->i2c_len < 2) 317 317 printf("%s: message too short (%i bytes)\n", 318 318 - __FUNCTION__, s->i2c_len); 318 318 + __func__, s->i2c_len); 319 319 #endif 320 320 break; 321 321 default: ··· 555 555 556 556 #ifdef VERBOSE 557 557 default: 558 558 - printf("%s: unknown register %02x\n", __FUNCTION__, cmd); 558 558 + printf("%s: unknown register %02x\n", __func__, cmd); 559 559 #endif 560 560 } 561 561

+2 -2

hw/block/nand.c

··· 321 321 break; 322 322 323 323 default: 324 324 - printf("%s: Unknown NAND command 0x%02x\n", __FUNCTION__, s->cmd); 324 324 + printf("%s: Unknown NAND command 0x%02x\n", __func__, s->cmd); 325 325 } 326 326 } 327 327 ··· 640 640 DeviceState *dev; 641 641 642 642 if (nand_flash_ids[chip_id].size == 0) { 643 643 - hw_error("%s: Unsupported NAND chip ID.\n", __FUNCTION__); 643 643 + hw_error("%s: Unsupported NAND chip ID.\n", __func__); 644 644 } 645 645 dev = DEVICE(object_new(TYPE_NAND)); 646 646 qdev_prop_set_uint8(dev, "manufacturer_id", manf_id);

+4 -4

hw/block/onenand.c

··· 659 659 case 0xff02: /* ECC Result of spare area data */ 660 660 case 0xff03: /* ECC Result of main area data */ 661 661 case 0xff04: /* ECC Result of spare area data */ 662 662 - hw_error("%s: imeplement ECC\n", __FUNCTION__); 662 662 + hw_error("%s: imeplement ECC\n", __func__); 663 663 return 0x0000; 664 664 } 665 665 666 666 fprintf(stderr, "%s: unknown OneNAND register %x\n", 667 667 - __FUNCTION__, offset); 667 667 + __func__, offset); 668 668 return 0; 669 669 } 670 670 ··· 709 709 710 710 default: 711 711 fprintf(stderr, "%s: unknown OneNAND boot command %"PRIx64"\n", 712 712 - __FUNCTION__, value); 712 712 + __func__, value); 713 713 } 714 714 break; 715 715 ··· 760 760 761 761 default: 762 762 fprintf(stderr, "%s: unknown OneNAND register %x\n", 763 763 - __FUNCTION__, offset); 763 763 + __func__, offset); 764 764 } 765 765 } 766 766

+5 -5

hw/bt/core.c

··· 32 32 { 33 33 if (link->slave->reject_reason) 34 34 fprintf(stderr, "%s: stray LMP_not_accepted received, fixme\n", 35 35 - __FUNCTION__); 35 35 + __func__); 36 36 else 37 37 fprintf(stderr, "%s: stray LMP_accepted received, fixme\n", 38 38 - __FUNCTION__); 38 38 + __func__); 39 39 exit(-1); 40 40 } 41 41 42 42 static void bt_dummy_lmp_disconnect_master(struct bt_link_s *link) 43 43 { 44 44 - fprintf(stderr, "%s: stray LMP_detach received, fixme\n", __FUNCTION__); 44 44 + fprintf(stderr, "%s: stray LMP_detach received, fixme\n", __func__); 45 45 exit(-1); 46 46 } 47 47 48 48 static void bt_dummy_lmp_acl_resp(struct bt_link_s *link, 49 49 const uint8_t *data, int start, int len) 50 50 { 51 51 - fprintf(stderr, "%s: stray ACL response PDU, fixme\n", __FUNCTION__); 51 51 + fprintf(stderr, "%s: stray ACL response PDU, fixme\n", __func__); 52 52 exit(-1); 53 53 } 54 54 ··· 113 113 while (*p && *p != dev) 114 114 p = &(*p)->next; 115 115 if (*p != dev) { 116 116 - fprintf(stderr, "%s: bad bt device \"%s\"\n", __FUNCTION__, 116 116 + fprintf(stderr, "%s: bad bt device \"%s\"\n", __func__, 117 117 dev->lmp_name ?: "(null)"); 118 118 exit(-1); 119 119 }

+7 -7

hw/bt/hci-csr.c

··· 111 111 112 112 if (off < FIFO_LEN) { 113 113 if (off + len > FIFO_LEN && (s->out_size = off + len) > FIFO_LEN * 2) { 114 114 - fprintf(stderr, "%s: can't alloc %i bytes\n", __FUNCTION__, len); 114 114 + fprintf(stderr, "%s: can't alloc %i bytes\n", __func__, len); 115 115 exit(-1); 116 116 } 117 117 return s->outfifo + off; 118 118 } 119 119 120 120 if (s->out_len > s->out_size) { 121 121 - fprintf(stderr, "%s: can't alloc %i bytes\n", __FUNCTION__, len); 121 121 + fprintf(stderr, "%s: can't alloc %i bytes\n", __func__, len); 122 122 exit(-1); 123 123 } 124 124 ··· 169 169 170 170 s->hci->bdaddr_set(s->hci, s->bd_addr.b); 171 171 fprintf(stderr, "%s: bd_address loaded from firmware: " 172 172 - "%02x:%02x:%02x:%02x:%02x:%02x\n", __FUNCTION__, 172 172 + "%02x:%02x:%02x:%02x:%02x:%02x\n", __func__, 173 173 s->bd_addr.b[0], s->bd_addr.b[1], s->bd_addr.b[2], 174 174 s->bd_addr.b[3], s->bd_addr.b[4], s->bd_addr.b[5]); 175 175 } ··· 181 181 break; 182 182 183 183 default: 184 184 - fprintf(stderr, "%s: got a bad CMD packet\n", __FUNCTION__); 184 184 + fprintf(stderr, "%s: got a bad CMD packet\n", __func__); 185 185 return; 186 186 } 187 187 ··· 226 226 case H4_NEG_PKT: 227 227 if (s->in_hdr != sizeof(csrhci_neg_packet) || 228 228 memcmp(pkt - 1, csrhci_neg_packet, s->in_hdr)) { 229 229 - fprintf(stderr, "%s: got a bad NEG packet\n", __FUNCTION__); 229 229 + fprintf(stderr, "%s: got a bad NEG packet\n", __func__); 230 230 return; 231 231 } 232 232 pkt += 2; ··· 241 241 242 242 case H4_ALIVE_PKT: 243 243 if (s->in_hdr != 4 || pkt[1] != 0x55 || pkt[2] != 0x00) { 244 244 - fprintf(stderr, "%s: got a bad ALIVE packet\n", __FUNCTION__); 244 244 + fprintf(stderr, "%s: got a bad ALIVE packet\n", __func__); 245 245 return; 246 246 } 247 247 ··· 254 254 default: 255 255 bad_pkt: 256 256 /* TODO: error out */ 257 257 - fprintf(stderr, "%s: got a bad packet\n", __FUNCTION__); 257 257 + fprintf(stderr, "%s: got a bad packet\n", __func__); 258 258 break; 259 259 } 260 260

+13 -13

hw/bt/hci.c

··· 458 458 459 459 if (len > 255) { 460 460 fprintf(stderr, "%s: HCI event params too long (%ib)\n", 461 461 - __FUNCTION__, len); 461 461 + __func__, len); 462 462 exit(-1); 463 463 } 464 464 ··· 589 589 bt_hci_inquiry_result_with_rssi(hci, slave); 590 590 return; 591 591 default: 592 592 - fprintf(stderr, "%s: bad inquiry mode %02x\n", __FUNCTION__, 592 592 + fprintf(stderr, "%s: bad inquiry mode %02x\n", __func__, 593 593 hci->lm.inquiry_mode); 594 594 exit(-1); 595 595 } ··· 1528 1528 "the Inquiry command has been issued, a Command " 1529 1529 "Status event has been received for the Inquiry " 1530 1530 "command, and before the Inquiry Complete event " 1531 1531 - "occurs", __FUNCTION__); 1531 1531 + "occurs", __func__); 1532 1532 bt_hci_event_complete_status(hci, HCI_COMMAND_DISALLOWED); 1533 1533 break; 1534 1534 } ··· 1567 1567 "the Inquiry command has been issued, a Command " 1568 1568 "Status event has been received for the Inquiry " 1569 1569 "command, and before the Inquiry Complete event " 1570 1570 - "occurs", __FUNCTION__); 1570 1570 + "occurs", __func__); 1571 1571 bt_hci_event_complete_status(hci, HCI_COMMAND_DISALLOWED); 1572 1572 break; 1573 1573 } ··· 1972 1972 1973 1973 short_hci: 1974 1974 fprintf(stderr, "%s: HCI packet too short (%iB)\n", 1975 1975 - __FUNCTION__, length); 1975 1975 + __func__, length); 1976 1976 bt_hci_event_status(hci, HCI_INVALID_PARAMETERS); 1977 1977 break; 1978 1978 } ··· 1992 1992 1993 1993 if (len + HCI_ACL_HDR_SIZE > sizeof(hci->acl_buf)) { 1994 1994 fprintf(stderr, "%s: can't take ACL packets %i bytes long\n", 1995 1995 - __FUNCTION__, len); 1995 1995 + __func__, len); 1996 1996 return; 1997 1997 } 1998 1998 memcpy(hci->acl_buf + HCI_ACL_HDR_SIZE, data, len); ··· 2030 2030 2031 2031 if (length < HCI_ACL_HDR_SIZE) { 2032 2032 fprintf(stderr, "%s: ACL packet too short (%iB)\n", 2033 2033 - __FUNCTION__, length); 2033 2033 + __func__, length); 2034 2034 return; 2035 2035 } 2036 2036 ··· 2042 2042 2043 2043 if (bt_hci_handle_bad(hci, handle)) { 2044 2044 fprintf(stderr, "%s: invalid ACL handle %03x\n", 2045 2045 - __FUNCTION__, handle); 2045 2045 + __func__, handle); 2046 2046 /* TODO: signal an error */ 2047 2047 return; 2048 2048 } ··· 2050 2050 2051 2051 if (datalen > length) { 2052 2052 fprintf(stderr, "%s: ACL packet too short (%iB < %iB)\n", 2053 2053 - __FUNCTION__, length, datalen); 2053 2053 + __func__, length, datalen); 2054 2054 return; 2055 2055 } 2056 2056 ··· 2061 2061 hci->asb_handle = handle; 2062 2062 else if (handle != hci->asb_handle) { 2063 2063 fprintf(stderr, "%s: Bad handle %03x in Active Slave Broadcast\n", 2064 2064 - __FUNCTION__, handle); 2064 2064 + __func__, handle); 2065 2065 /* TODO: signal an error */ 2066 2066 return; 2067 2067 } ··· 2074 2074 hci->psb_handle = handle; 2075 2075 else if (handle != hci->psb_handle) { 2076 2076 fprintf(stderr, "%s: Bad handle %03x in Parked Slave Broadcast\n", 2077 2077 - __FUNCTION__, handle); 2077 2077 + __func__, handle); 2078 2078 /* TODO: signal an error */ 2079 2079 return; 2080 2080 } ··· 2106 2106 2107 2107 if (bt_hci_handle_bad(hci, handle)) { 2108 2108 fprintf(stderr, "%s: invalid SCO handle %03x\n", 2109 2109 - __FUNCTION__, handle); 2109 2109 + __func__, handle); 2110 2110 return; 2111 2111 } 2112 2112 2113 2113 if (datalen > length) { 2114 2114 fprintf(stderr, "%s: SCO packet too short (%iB < %iB)\n", 2115 2115 - __FUNCTION__, length, datalen); 2115 2115 + __func__, length, datalen); 2116 2116 return; 2117 2117 } 2118 2118

+1 -1

hw/bt/hid.c

··· 420 420 return; 421 421 bad: 422 422 fprintf(stderr, "%s: bad transaction on Interrupt channel.\n", 423 423 - __FUNCTION__); 423 423 + __func__); 424 424 } 425 425 426 426 /* "Virtual cable" plug/unplug event. */

+11 -11

hw/bt/l2cap.c

··· 468 468 if (likely(ch)) { 469 469 if (ch->remote_cid != source_cid) { 470 470 fprintf(stderr, "%s: Ignoring a Disconnection Request with the " 471 471 - "invalid SCID %04x.\n", __FUNCTION__, source_cid); 471 471 + "invalid SCID %04x.\n", __func__, source_cid); 472 472 return; 473 473 } 474 474 ··· 791 791 /* TODO: do the IDs really have to be in sequence? */ 792 792 if (!id || (id != l2cap->last_id && id != l2cap->next_id)) { 793 793 fprintf(stderr, "%s: out of sequence command packet ignored.\n", 794 794 - __FUNCTION__); 794 794 + __func__); 795 795 return; 796 796 } 797 797 #else ··· 814 814 815 815 /* We never issue commands other than Command Reject currently. */ 816 816 fprintf(stderr, "%s: stray Command Reject (%02x, %04x) " 817 817 - "packet, ignoring.\n", __FUNCTION__, id, 817 817 + "packet, ignoring.\n", __func__, id, 818 818 le16_to_cpu(((l2cap_cmd_rej *) params)->reason)); 819 819 break; 820 820 ··· 837 837 838 838 /* We never issue Connection Requests currently. TODO */ 839 839 fprintf(stderr, "%s: unexpected Connection Response (%02x) " 840 840 - "packet, ignoring.\n", __FUNCTION__, id); 840 840 + "packet, ignoring.\n", __func__, id); 841 841 break; 842 842 843 843 case L2CAP_CONF_REQ: ··· 866 866 ((l2cap_conf_rsp *) params)->data, 867 867 len - L2CAP_CONF_RSP_SIZE(0))) 868 868 fprintf(stderr, "%s: unexpected Configure Response (%02x) " 869 869 - "packet, ignoring.\n", __FUNCTION__, id); 869 869 + "packet, ignoring.\n", __func__, id); 870 870 break; 871 871 872 872 case L2CAP_DISCONN_REQ: ··· 888 888 889 889 /* We never issue Disconnection Requests currently. TODO */ 890 890 fprintf(stderr, "%s: unexpected Disconnection Response (%02x) " 891 891 - "packet, ignoring.\n", __FUNCTION__, id); 891 891 + "packet, ignoring.\n", __func__, id); 892 892 break; 893 893 894 894 case L2CAP_ECHO_REQ: ··· 898 898 case L2CAP_ECHO_RSP: 899 899 /* We never issue Echo Requests currently. TODO */ 900 900 fprintf(stderr, "%s: unexpected Echo Response (%02x) " 901 901 - "packet, ignoring.\n", __FUNCTION__, id); 901 901 + "packet, ignoring.\n", __func__, id); 902 902 break; 903 903 904 904 case L2CAP_INFO_REQ: ··· 918 918 919 919 /* We never issue Information Requests currently. TODO */ 920 920 fprintf(stderr, "%s: unexpected Information Response (%02x) " 921 921 - "packet, ignoring.\n", __FUNCTION__, id); 921 921 + "packet, ignoring.\n", __func__, id); 922 922 break; 923 923 924 924 default: ··· 1067 1067 1068 1068 if (unlikely(cid >= L2CAP_CID_MAX || !l2cap->cid[cid])) { 1069 1069 fprintf(stderr, "%s: frame addressed to a non-existent L2CAP " 1070 1070 - "channel %04x received.\n", __FUNCTION__, cid); 1070 1070 + "channel %04x received.\n", __func__, cid); 1071 1071 return; 1072 1072 } 1073 1073 ··· 1129 1129 1130 1130 if (len > chan->params.remote_mtu) { 1131 1131 fprintf(stderr, "%s: B-Frame for CID %04x longer than %i octets.\n", 1132 1132 - __FUNCTION__, 1132 1132 + __func__, 1133 1133 chan->remote_cid, chan->params.remote_mtu); 1134 1134 exit(-1); 1135 1135 } ··· 1354 1354 1355 1355 if (new_psm) { 1356 1356 fprintf(stderr, "%s: PSM %04x already registered for device `%s'.\n", 1357 1357 - __FUNCTION__, psm, dev->device.lmp_name); 1357 1357 + __func__, psm, dev->device.lmp_name); 1358 1358 exit(-1); 1359 1359 } 1360 1360

+3 -3

hw/bt/sdp.c

··· 506 506 int rsp_len = 0; 507 507 508 508 if (len < 5) { 509 509 - fprintf(stderr, "%s: short SDP PDU (%iB).\n", __FUNCTION__, len); 509 509 + fprintf(stderr, "%s: short SDP PDU (%iB).\n", __func__, len); 510 510 return; 511 511 } 512 512 ··· 518 518 519 519 if (len != plen) { 520 520 fprintf(stderr, "%s: wrong SDP PDU length (%iB != %iB).\n", 521 521 - __FUNCTION__, plen, len); 521 521 + __func__, plen, len); 522 522 err = SDP_INVALID_PDU_SIZE; 523 523 goto respond; 524 524 } ··· 545 545 case SDP_SVC_SEARCH_ATTR_RSP: 546 546 default: 547 547 fprintf(stderr, "%s: unexpected SDP PDU ID %02x.\n", 548 548 - __FUNCTION__, pdu_id); 548 548 + __func__, pdu_id); 549 549 err = SDP_INVALID_SYNTAX; 550 550 break; 551 551 }

+9 -9

hw/display/blizzard.c

··· 474 474 return s->gpio_pdown; 475 475 476 476 default: 477 477 - fprintf(stderr, "%s: unknown register %02x\n", __FUNCTION__, reg); 477 477 + fprintf(stderr, "%s: unknown register %02x\n", __func__, reg); 478 478 return 0; 479 479 } 480 480 } ··· 502 502 s->pll_mode = value & 0x77; 503 503 if ((value & 3) == 0 || (value & 3) == 3) 504 504 fprintf(stderr, "%s: wrong PLL Control bits (%i)\n", 505 505 - __FUNCTION__, value & 3); 505 505 + __func__, value & 3); 506 506 break; 507 507 508 508 case 0x0e: /* Clock-Source Select */ ··· 541 541 case 0x28: /* LCD Panel Configuration */ 542 542 s->lcd_config = value & 0xff; 543 543 if (value & (1 << 7)) 544 544 - fprintf(stderr, "%s: data swap not supported!\n", __FUNCTION__); 544 544 + fprintf(stderr, "%s: data swap not supported!\n", __func__); 545 545 break; 546 546 547 547 case 0x2a: /* LCD Horizontal Display Width */ ··· 586 586 s->hssi_config[1] = value; 587 587 if (((value >> 4) & 3) == 3) 588 588 fprintf(stderr, "%s: Illegal active-data-links value\n", 589 589 - __FUNCTION__); 589 589 + __func__); 590 590 break; 591 591 case 0x42: /* High-speed Serial Interface Tx Mode */ 592 592 s->hssi_config[2] = value & 0xbd; ··· 641 641 s->enable = value & 1; 642 642 s->blank = (value >> 1) & 1; 643 643 if (value & (1 << 4)) 644 644 - fprintf(stderr, "%s: Macrovision enable attempt!\n", __FUNCTION__); 644 644 + fprintf(stderr, "%s: Macrovision enable attempt!\n", __func__); 645 645 break; 646 646 647 647 case 0x6a: /* Special Effects */ ··· 718 718 s->bpp = blizzard_iformat_bpp[s->iformat]; 719 719 if (!s->bpp) 720 720 fprintf(stderr, "%s: Illegal or unsupported input format %x\n", 721 721 - __FUNCTION__, s->iformat); 721 721 + __func__, s->iformat); 722 722 break; 723 723 case 0x8e: /* Data Source Select */ 724 724 s->source = value & 7; ··· 730 730 !((s->ix[1] - s->ix[0]) & (s->iy[1] - s->iy[0]) & 731 731 (s->ox[1] - s->ox[0]) & (s->oy[1] - s->oy[0]) & 1)) 732 732 fprintf(stderr, "%s: Illegal input/output window positions\n", 733 733 - __FUNCTION__); 733 733 + __func__); 734 734 735 735 blizzard_transfer_setup(s); 736 736 break; ··· 784 784 s->pm = value & 0x83; 785 785 if (value & s->mode & 1) 786 786 fprintf(stderr, "%s: The display must be disabled before entering " 787 787 - "Standby Mode\n", __FUNCTION__); 787 787 + "Standby Mode\n", __func__); 788 788 break; 789 789 case 0xe8: /* Non-display Period Control / Status */ 790 790 s->status = value & 0x1b; ··· 815 815 break; 816 816 817 817 default: 818 818 - fprintf(stderr, "%s: unknown register %02x\n", __FUNCTION__, reg); 818 818 + fprintf(stderr, "%s: unknown register %02x\n", __func__, reg); 819 819 break; 820 820 } 821 821 }

+3 -3

hw/display/omap_dss.c

··· 526 526 s->dispc.l[0].attr = value & 0x7ff; 527 527 if (value & (3 << 9)) 528 528 fprintf(stderr, "%s: Big-endian pixel format not supported\n", 529 529 - __FUNCTION__); 529 529 + __func__); 530 530 s->dispc.l[0].enable = value & 1; 531 531 s->dispc.l[0].bpp = (value >> 1) & 0xf; 532 532 s->dispc.invalidate = 1; ··· 617 617 if (s->rfbi.control & (1 << 1)) { /* BYPASS */ 618 618 /* TODO: in non-Bypass mode we probably need to just assert the 619 619 * DRQ and wait for DMA to write the pixels. */ 620 620 - fprintf(stderr, "%s: Bypass mode unimplemented\n", __FUNCTION__); 620 620 + fprintf(stderr, "%s: Bypass mode unimplemented\n", __func__); 621 621 return; 622 622 } 623 623 ··· 1086 1086 void omap_rfbi_attach(struct omap_dss_s *s, int cs, struct rfbi_chip_s *chip) 1087 1087 { 1088 1088 if (cs < 0 || cs > 1) 1089 1089 - hw_error("%s: wrong CS %i\n", __FUNCTION__, cs); 1089 1089 + hw_error("%s: wrong CS %i\n", __func__, cs); 1090 1090 s->rfbi.chip[cs] = chip; 1091 1091 }

+7 -7

hw/display/pxa2xx_lcd.c

··· 405 405 406 406 default: 407 407 fail: 408 408 - hw_error("%s: Bad offset " REG_FMT "\n", __FUNCTION__, offset); 408 408 + hw_error("%s: Bad offset " REG_FMT "\n", __func__, offset); 409 409 } 410 410 411 411 return 0; ··· 424 424 s->status[0] |= LCSR0_QD; 425 425 426 426 if (!(s->control[0] & LCCR0_LCDT) && (value & LCCR0_LCDT)) 427 427 - printf("%s: internal frame buffer unsupported\n", __FUNCTION__); 427 427 + printf("%s: internal frame buffer unsupported\n", __func__); 428 428 429 429 if ((s->control[3] & LCCR3_API) && 430 430 (value & LCCR0_ENB) && !(value & LCCR0_LCDT)) ··· 460 460 461 461 case OVL1C1: 462 462 if (!(s->ovl1c[0] & OVLC1_EN) && (value & OVLC1_EN)) 463 463 - printf("%s: Overlay 1 not supported\n", __FUNCTION__); 463 463 + printf("%s: Overlay 1 not supported\n", __func__); 464 464 465 465 s->ovl1c[0] = value & 0x80ffffff; 466 466 s->dma_ch[1].up = (value & OVLC1_EN) || (s->control[0] & LCCR0_SDS); ··· 472 472 473 473 case OVL2C1: 474 474 if (!(s->ovl2c[0] & OVLC1_EN) && (value & OVLC1_EN)) 475 475 - printf("%s: Overlay 2 not supported\n", __FUNCTION__); 475 475 + printf("%s: Overlay 2 not supported\n", __func__); 476 476 477 477 s->ovl2c[0] = value & 0x80ffffff; 478 478 s->dma_ch[2].up = !!(value & OVLC1_EN); ··· 486 486 487 487 case CCR: 488 488 if (!(s->ccr & CCR_CEN) && (value & CCR_CEN)) 489 489 - printf("%s: Hardware cursor unimplemented\n", __FUNCTION__); 489 489 + printf("%s: Hardware cursor unimplemented\n", __func__); 490 490 491 491 s->ccr = value & 0x81ffffe7; 492 492 s->dma_ch[5].up = !!(value & CCR_CEN); ··· 560 560 561 561 default: 562 562 fail: 563 563 - hw_error("%s: Bad offset " REG_FMT "\n", __FUNCTION__, offset); 563 563 + hw_error("%s: Bad offset " REG_FMT "\n", __func__, offset); 564 564 } 565 565 } 566 566 ··· 1050 1050 s->dest_width = 4; 1051 1051 break; 1052 1052 default: 1053 1053 - fprintf(stderr, "%s: Bad color depth\n", __FUNCTION__); 1053 1053 + fprintf(stderr, "%s: Bad color depth\n", __func__); 1054 1054 exit(1); 1055 1055 } 1056 1056

+3 -3

hw/display/qxl-render.c

··· 78 78 qxl->guest_primary.bits_pp = 32; 79 79 break; 80 80 default: 81 81 - fprintf(stderr, "%s: unhandled format: %x\n", __FUNCTION__, 81 81 + fprintf(stderr, "%s: unhandled format: %x\n", __func__, 82 82 qxl->guest_primary.surface.format); 83 83 qxl->guest_primary.bytes_pp = 4; 84 84 qxl->guest_primary.bits_pp = 32; ··· 248 248 break; 249 249 default: 250 250 fprintf(stderr, "%s: not implemented: type %d\n", 251 251 - __FUNCTION__, cursor->header.type); 251 251 + __func__, cursor->header.type); 252 252 goto fail; 253 253 } 254 254 return c; ··· 275 275 } 276 276 277 277 if (qxl->debug > 1 && cmd->type != QXL_CURSOR_MOVE) { 278 278 - fprintf(stderr, "%s", __FUNCTION__); 278 278 + fprintf(stderr, "%s", __func__); 279 279 qxl_log_cmd_cursor(qxl, cmd, ext->group_id); 280 280 fprintf(stderr, "\n"); 281 281 }

+1 -1

hw/display/qxl.h

··· 132 132 #define PCI_QXL(obj) OBJECT_CHECK(PCIQXLDevice, (obj), TYPE_PCI_QXL) 133 133 134 134 #define PANIC_ON(x) if ((x)) { \ 135 135 - printf("%s: PANIC %s failed\n", __FUNCTION__, #x); \ 135 135 + printf("%s: PANIC %s failed\n", __func__, #x); \ 136 136 abort(); \ 137 137 } 138 138

+1 -1

hw/display/tc6393xb.c

··· 148 148 // TC6393xbState *s = opaque; 149 149 150 150 if (line > TC6393XB_GPIOS) { 151 151 - printf("%s: No GPIO pin %i\n", __FUNCTION__, line); 151 151 + printf("%s: No GPIO pin %i\n", __func__, line); 152 152 return; 153 153 } 154 154

+1 -1

hw/display/xenfb.c

··· 662 662 } 663 663 if (oops) /* should not happen */ 664 664 xen_pv_printf(&xenfb->c.xendev, 0, "%s: oops: convert %d -> %d bpp?\n", 665 665 - __FUNCTION__, xenfb->depth, bpp); 665 665 + __func__, xenfb->depth, bpp); 666 666 667 667 dpy_gfx_update(xenfb->con, x, y, w, h); 668 668 }

+13 -13

hw/dma/omap_dma.c

··· 161 161 a->pck_element = 0; 162 162 163 163 if (unlikely(!ch->elements || !ch->frames)) { 164 164 - printf("%s: bad DMA request\n", __FUNCTION__); 164 164 + printf("%s: bad DMA request\n", __func__); 165 165 return; 166 166 } 167 167 ··· 519 519 continue; 520 520 #endif 521 521 printf("%s: Bus time-out in DMA%i operation\n", 522 522 - __FUNCTION__, dma->num); 522 522 + __func__, dma->num); 523 523 } 524 524 525 525 min_elems = INT_MAX; ··· 879 879 ch->pack[0] = (value & 0x0040) >> 6; 880 880 ch->port[0] = (enum omap_dma_port) ((value & 0x003c) >> 2); 881 881 if (ch->port[0] >= __omap_dma_port_last) 882 882 - printf("%s: invalid DMA port %i\n", __FUNCTION__, 882 882 + printf("%s: invalid DMA port %i\n", __func__, 883 883 ch->port[0]); 884 884 if (ch->port[1] >= __omap_dma_port_last) 885 885 - printf("%s: invalid DMA port %i\n", __FUNCTION__, 885 885 + printf("%s: invalid DMA port %i\n", __func__, 886 886 ch->port[1]); 887 887 ch->data_type = 1 << (value & 3); 888 888 if ((value & 3) == 3) { 889 889 - printf("%s: bad data_type for DMA channel\n", __FUNCTION__); 889 889 + printf("%s: bad data_type for DMA channel\n", __func__); 890 890 ch->data_type >>= 1; 891 891 } 892 892 break; ··· 1440 1440 case 0x482: /* DMA_PCh1_SR */ 1441 1441 case 0x4c0: /* DMA_PChD_SR_0 */ 1442 1442 printf("%s: Physical Channel Status Registers not implemented.\n", 1443 1443 - __FUNCTION__); 1443 1443 + __func__); 1444 1444 *ret = 0xff; 1445 1445 break; 1446 1446 ··· 1898 1898 omap_dma_reset(s->dma); 1899 1899 s->ocp = value & 0x3321; 1900 1900 if (((s->ocp >> 12) & 3) == 3) /* MIDLEMODE */ 1901 1901 - fprintf(stderr, "%s: invalid DMA power mode\n", __FUNCTION__); 1901 1901 + fprintf(stderr, "%s: invalid DMA power mode\n", __func__); 1902 1902 return; 1903 1903 1904 1904 case 0x78: /* DMA4_GCR */ 1905 1905 s->gcr = value & 0x00ff00ff; 1906 1906 if ((value & 0xff) == 0x00) /* MAX_CHANNEL_FIFO_DEPTH */ 1907 1907 - fprintf(stderr, "%s: wrong FIFO depth in GCR\n", __FUNCTION__); 1907 1907 + fprintf(stderr, "%s: wrong FIFO depth in GCR\n", __func__); 1908 1908 return; 1909 1909 1910 1910 case 0x80 ... 0xfff: ··· 1935 1935 ch->src_sync = (value >> 24) & 1; /* XXX For CamDMA must be 1 */ 1936 1936 if (ch->buf_disable && !ch->src_sync) 1937 1937 fprintf(stderr, "%s: Buffering disable is not allowed in " 1938 1938 - "destination synchronised mode\n", __FUNCTION__); 1938 1938 + "destination synchronised mode\n", __func__); 1939 1939 ch->prefetch = (value >> 23) & 1; 1940 1940 ch->bs = (value >> 18) & 1; 1941 1941 ch->transparent_copy = (value >> 17) & 1; ··· 1947 1947 ch->fs = (value & 0x0020) >> 5; 1948 1948 if (ch->fs && ch->bs && ch->mode[0] && ch->mode[1]) 1949 1949 fprintf(stderr, "%s: For a packet transfer at least one port " 1950 1950 - "must be constant-addressed\n", __FUNCTION__); 1950 1950 + "must be constant-addressed\n", __func__); 1951 1951 ch->sync = (value & 0x001f) | ((value >> 14) & 0x0060); 1952 1952 /* XXX must be 0x01 for CamDMA */ 1953 1953 ··· 1978 1978 ch->endian_lock[1] =(value >> 18) & 1; 1979 1979 if (ch->endian[0] != ch->endian[1]) 1980 1980 fprintf(stderr, "%s: DMA endianness conversion enable attempt\n", 1981 1981 - __FUNCTION__); 1981 1981 + __func__); 1982 1982 ch->write_mode = (value >> 16) & 3; 1983 1983 ch->burst[1] = (value & 0xc000) >> 14; 1984 1984 ch->pack[1] = (value & 0x2000) >> 13; ··· 1988 1988 ch->translate[0] = (value & 0x003c) >> 2; 1989 1989 if (ch->translate[0] | ch->translate[1]) 1990 1990 fprintf(stderr, "%s: bad MReqAddressTranslate sideband signal\n", 1991 1991 - __FUNCTION__); 1991 1991 + __func__); 1992 1992 ch->data_type = 1 << (value & 3); 1993 1993 if ((value & 3) == 3) { 1994 1994 - printf("%s: bad data_type for DMA channel\n", __FUNCTION__); 1994 1994 + printf("%s: bad data_type for DMA channel\n", __func__); 1995 1995 ch->data_type >>= 1; 1996 1996 } 1997 1997 break;

+7 -7

hw/dma/pxa2xx_dma.c

··· 169 169 s->chan[ch].dest &= ~3; 170 170 171 171 if (s->chan[ch].cmd & (DCMD_CMPEN | DCMD_FLYBYS | DCMD_FLYBYT)) 172 172 - printf("%s: unsupported mode in channel %i\n", __FUNCTION__, ch); 172 172 + printf("%s: unsupported mode in channel %i\n", __func__, ch); 173 173 174 174 if (s->chan[ch].cmd & DCMD_STARTIRQEN) 175 175 s->chan[ch].state |= DCSR_STARTINTR; ··· 264 264 unsigned int channel; 265 265 266 266 if (size != 4) { 267 267 - hw_error("%s: Bad access width\n", __FUNCTION__); 267 267 + hw_error("%s: Bad access width\n", __func__); 268 268 return 5; 269 269 } 270 270 ··· 312 312 } 313 313 } 314 314 315 315 - hw_error("%s: Bad offset 0x" TARGET_FMT_plx "\n", __FUNCTION__, offset); 315 315 + hw_error("%s: Bad offset 0x" TARGET_FMT_plx "\n", __func__, offset); 316 316 return 7; 317 317 } 318 318 ··· 323 323 unsigned int channel; 324 324 325 325 if (size != 4) { 326 326 - hw_error("%s: Bad access width\n", __FUNCTION__); 326 326 + hw_error("%s: Bad access width\n", __func__); 327 327 return; 328 328 } 329 329 ··· 337 337 if (value & DRCMR_MAPVLD) 338 338 if ((value & DRCMR_CHLNUM) > s->channels) 339 339 hw_error("%s: Bad DMA channel %i\n", 340 340 - __FUNCTION__, (unsigned)value & DRCMR_CHLNUM); 340 340 + __func__, (unsigned)value & DRCMR_CHLNUM); 341 341 342 342 s->req[channel] = value; 343 343 break; ··· 416 416 break; 417 417 } 418 418 fail: 419 419 - hw_error("%s: Bad offset " TARGET_FMT_plx "\n", __FUNCTION__, offset); 419 419 + hw_error("%s: Bad offset " TARGET_FMT_plx "\n", __func__, offset); 420 420 } 421 421 } 422 422 ··· 431 431 PXA2xxDMAState *s = opaque; 432 432 int ch; 433 433 if (req_num < 0 || req_num >= PXA2XX_DMA_NUM_REQUESTS) 434 434 - hw_error("%s: Bad DMA request %i\n", __FUNCTION__, req_num); 434 434 + hw_error("%s: Bad DMA request %i\n", __func__, req_num); 435 435 436 436 if (!(s->req[req_num] & DRCMR_MAPVLD)) 437 437 return;

+4 -4

hw/gpio/max7310.c

··· 67 67 68 68 default: 69 69 #ifdef VERBOSE 70 70 - printf("%s: unknown register %02x\n", __FUNCTION__, s->command); 70 70 + printf("%s: unknown register %02x\n", __func__, s->command); 71 71 #endif 72 72 break; 73 73 } ··· 82 82 83 83 if (s->len ++ > 1) { 84 84 #ifdef VERBOSE 85 85 - printf("%s: message too long (%i bytes)\n", __FUNCTION__, s->len); 85 85 + printf("%s: message too long (%i bytes)\n", __func__, s->len); 86 86 #endif 87 87 return 1; 88 88 } ··· 121 121 break; 122 122 default: 123 123 #ifdef VERBOSE 124 124 - printf("%s: unknown register %02x\n", __FUNCTION__, s->command); 124 124 + printf("%s: unknown register %02x\n", __func__, s->command); 125 125 #endif 126 126 return 1; 127 127 } ··· 141 141 case I2C_FINISH: 142 142 #ifdef VERBOSE 143 143 if (s->len == 1) 144 144 - printf("%s: message too short (%i bytes)\n", __FUNCTION__, s->len); 144 144 + printf("%s: message too short (%i bytes)\n", __func__, s->len); 145 145 #endif 146 146 break; 147 147 default:

+1 -1

hw/gpio/omap_gpio.c

··· 399 399 400 400 case 0x10: /* GPIO_SYSCONFIG */ 401 401 if (((value >> 3) & 3) == 3) 402 402 - fprintf(stderr, "%s: bad IDLEMODE value\n", __FUNCTION__); 402 402 + fprintf(stderr, "%s: bad IDLEMODE value\n", __func__); 403 403 if (value & 2) 404 404 omap2_gpio_module_reset(s); 405 405 s->config[0] = value & 0x1d;

+3 -3

hw/i2c/omap_i2c.c

··· 341 341 } 342 342 if ((value & (1 << 15)) && !(value & (1 << 10))) { /* MST */ 343 343 fprintf(stderr, "%s: I^2C slave mode not supported\n", 344 344 - __FUNCTION__); 344 344 + __func__); 345 345 break; 346 346 } 347 347 if ((value & (1 << 15)) && value & (1 << 8)) { /* XA */ 348 348 fprintf(stderr, "%s: 10-bit addressing mode not supported\n", 349 349 - __FUNCTION__); 349 349 + __func__); 350 350 break; 351 351 } 352 352 if ((value & (1 << 15)) && value & (1 << 0)) { /* STT */ ··· 393 393 omap_i2c_interrupts_update(s); 394 394 } 395 395 if (value & (1 << 15)) /* ST_EN */ 396 396 - fprintf(stderr, "%s: System Test not supported\n", __FUNCTION__); 396 396 + fprintf(stderr, "%s: System Test not supported\n", __func__); 397 397 break; 398 398 399 399 default:

+1 -1

hw/ide/ahci.c

··· 1052 1052 g_assert(is_ncq(ncq_fis->command)); 1053 1053 if (ncq_tfs->used) { 1054 1054 /* error - already in use */ 1055 1055 - fprintf(stderr, "%s: tag %d already used\n", __FUNCTION__, tag); 1055 1055 + fprintf(stderr, "%s: tag %d already used\n", __func__, tag); 1056 1056 return; 1057 1057 } 1058 1058

+2 -2

hw/ide/microdrive.c

··· 155 155 return 0x00; 156 156 #ifdef VERBOSE 157 157 default: 158 158 - printf("%s: Bad attribute space register %02x\n", __FUNCTION__, at); 158 158 + printf("%s: Bad attribute space register %02x\n", __func__, at); 159 159 #endif 160 160 } 161 161 ··· 192 192 case 0x06: /* Socket and Copy Register */ 193 193 break; 194 194 default: 195 195 - printf("%s: Bad attribute space register %02x\n", __FUNCTION__, at); 195 195 + printf("%s: Bad attribute space register %02x\n", __func__, at); 196 196 } 197 197 } 198 198

+3 -3

hw/input/lm832x.c

··· 239 239 240 240 default: 241 241 lm_kbd_error(s, ERR_CMDUNK); 242 242 - fprintf(stderr, "%s: unknown command %02x\n", __FUNCTION__, reg); 242 242 + fprintf(stderr, "%s: unknown command %02x\n", __func__, reg); 243 243 return 0x00; 244 244 } 245 245 ··· 331 331 if ((value & 3) && (value & 3) != 3) { 332 332 lm_kbd_error(s, ERR_BADPAR); 333 333 fprintf(stderr, "%s: invalid clock setting in RCPWM\n", 334 334 - __FUNCTION__); 334 334 + __func__); 335 335 } 336 336 /* TODO: Validate that the command is only issued once */ 337 337 break; ··· 378 378 break; 379 379 default: 380 380 lm_kbd_error(s, ERR_CMDUNK); 381 381 - fprintf(stderr, "%s: unknown command %02x\n", __FUNCTION__, reg); 381 381 + fprintf(stderr, "%s: unknown command %02x\n", __func__, reg); 382 382 break; 383 383 } 384 384 }

+3 -3

hw/input/pxa2xx_keypad.c

··· 231 231 return s->kpkdi; 232 232 break; 233 233 default: 234 234 - hw_error("%s: Bad offset " REG_FMT "\n", __FUNCTION__, offset); 234 234 + hw_error("%s: Bad offset " REG_FMT "\n", __func__, offset); 235 235 } 236 236 237 237 return 0; ··· 278 278 break; 279 279 280 280 default: 281 281 - hw_error("%s: Bad offset " REG_FMT "\n", __FUNCTION__, offset); 281 281 + hw_error("%s: Bad offset " REG_FMT "\n", __func__, offset); 282 282 } 283 283 } 284 284 ··· 326 326 const struct keymap *map, int size) 327 327 { 328 328 if(!map || size < 0x80) { 329 329 - fprintf(stderr, "%s - No PXA keypad map defined\n", __FUNCTION__); 329 329 + fprintf(stderr, "%s - No PXA keypad map defined\n", __func__); 330 330 exit(-1); 331 331 } 332 332

+4 -4

hw/input/tsc2005.c

··· 201 201 if (s->enabled != !(data & 0x4000)) { 202 202 s->enabled = !(data & 0x4000); 203 203 fprintf(stderr, "%s: touchscreen sense %sabled\n", 204 204 - __FUNCTION__, s->enabled ? "en" : "dis"); 204 204 + __func__, s->enabled ? "en" : "dis"); 205 205 if (s->busy && !s->enabled) 206 206 timer_del(s->timer); 207 207 s->busy = s->busy && s->enabled; ··· 210 210 s->timing[0] = data & 0x1fff; 211 211 if ((s->timing[0] >> 11) == 3) 212 212 fprintf(stderr, "%s: illegal conversion clock setting\n", 213 213 - __FUNCTION__); 213 213 + __func__); 214 214 break; 215 215 case 0xd: /* CFR1 */ 216 216 s->timing[1] = data & 0xf07; ··· 222 222 223 223 default: 224 224 fprintf(stderr, "%s: write into read-only register %x\n", 225 225 - __FUNCTION__, reg); 225 225 + __func__, reg); 226 226 } 227 227 } 228 228 ··· 338 338 if (s->enabled != !(value & 1)) { 339 339 s->enabled = !(value & 1); 340 340 fprintf(stderr, "%s: touchscreen sense %sabled\n", 341 341 - __FUNCTION__, s->enabled ? "en" : "dis"); 341 341 + __func__, s->enabled ? "en" : "dis"); 342 342 if (s->busy && !s->enabled) 343 343 timer_del(s->timer); 344 344 s->busy = s->busy && s->enabled;

+2 -2

hw/input/tsc210x.c

··· 287 287 rate->fsref == ((s->audio_ctrl3 >> 13) & 1))/* REFFS */ 288 288 break; 289 289 if (!rate->rate) { 290 290 - printf("%s: unknown sampling rate configured\n", __FUNCTION__); 290 290 + printf("%s: unknown sampling rate configured\n", __func__); 291 291 return; 292 292 } 293 293 ··· 913 913 uint32_t ret = 0; 914 914 915 915 if (len != 16) 916 916 - hw_error("%s: FIXME: bad SPI word width %i\n", __FUNCTION__, len); 916 916 + hw_error("%s: FIXME: bad SPI word width %i\n", __func__, len); 917 917 918 918 /* TODO: sequential reads etc - how do we make sure the host doesn't 919 919 * unintentionally read out a conversion result from a register while

+1 -1

hw/intc/omap_intc.c

··· 540 540 * for every register, see Chapter 3 and 4 for privileged mode. */ 541 541 if (value & 1) 542 542 fprintf(stderr, "%s: protection mode enable attempt\n", 543 543 - __FUNCTION__); 543 543 + __func__); 544 544 return; 545 545 546 546 case 0x50: /* INTC_IDLE */

+1 -1

hw/isa/vt82c686.c

··· 29 29 //#define DEBUG_VT82C686B 30 30 31 31 #ifdef DEBUG_VT82C686B 32 32 - #define DPRINTF(fmt, ...) fprintf(stderr, "%s: " fmt, __FUNCTION__, ##__VA_ARGS__) 32 32 + #define DPRINTF(fmt, ...) fprintf(stderr, "%s: " fmt, __func__, ##__VA_ARGS__) 33 33 #else 34 34 #define DPRINTF(fmt, ...) 35 35 #endif

+1 -1

hw/mips/gt64xxx_pci.c

··· 33 33 //#define DEBUG 34 34 35 35 #ifdef DEBUG 36 36 - #define DPRINTF(fmt, ...) fprintf(stderr, "%s: " fmt, __FUNCTION__, ##__VA_ARGS__) 36 36 + #define DPRINTF(fmt, ...) fprintf(stderr, "%s: " fmt, __func__, ##__VA_ARGS__) 37 37 #else 38 38 #define DPRINTF(fmt, ...) 39 39 #endif

+6 -6

hw/misc/cbus.c

··· 62 62 s->slave[s->addr]->io(s->slave[s->addr]->opaque, 63 63 s->rw, s->reg, &s->val); 64 64 else 65 65 - hw_error("%s: bad slave address %i\n", __FUNCTION__, s->addr); 65 65 + hw_error("%s: bad slave address %i\n", __func__, s->addr); 66 66 } 67 67 68 68 static void cbus_cycle(CBusPriv *s) ··· 299 299 return 0x0000; 300 300 301 301 default: 302 302 - hw_error("%s: bad register %02x\n", __FUNCTION__, reg); 302 302 + hw_error("%s: bad register %02x\n", __func__, reg); 303 303 } 304 304 } 305 305 ··· 372 372 break; 373 373 374 374 default: 375 375 - hw_error("%s: bad register %02x\n", __FUNCTION__, reg); 375 375 + hw_error("%s: bad register %02x\n", __func__, reg); 376 376 } 377 377 } 378 378 ··· 538 538 return 0x0000; 539 539 540 540 default: 541 541 - hw_error("%s: bad register %02x\n", __FUNCTION__, reg); 541 541 + hw_error("%s: bad register %02x\n", __func__, reg); 542 542 } 543 543 } 544 544 ··· 567 567 if (s->backlight != (val & 0x7f)) { 568 568 s->backlight = val & 0x7f; 569 569 printf("%s: LCD backlight now at %i / 127\n", 570 570 - __FUNCTION__, s->backlight); 570 570 + __func__, s->backlight); 571 571 } 572 572 break; 573 573 ··· 588 588 break; 589 589 590 590 default: 591 591 - hw_error("%s: bad register %02x\n", __FUNCTION__, reg); 591 591 + hw_error("%s: bad register %02x\n", __func__, reg); 592 592 } 593 593 } 594 594

+2 -2

hw/misc/omap_clk.c

··· 1109 1109 for (i = mpu->clks; i->name; i ++) 1110 1110 if (!strcmp(i->name, name) || (i->alias && !strcmp(i->alias, name))) 1111 1111 return i; 1112 1112 - hw_error("%s: %s not found\n", __FUNCTION__, name); 1112 1112 + hw_error("%s: %s not found\n", __func__, name); 1113 1113 } 1114 1114 1115 1115 void omap_clk_get(struct clk *clk) ··· 1120 1120 void omap_clk_put(struct clk *clk) 1121 1121 { 1122 1122 if (!(clk->usecount --)) 1123 1123 - hw_error("%s: %s is not in use\n", __FUNCTION__, clk->name); 1123 1123 + hw_error("%s: %s is not in use\n", __func__, clk->name); 1124 1124 } 1125 1125 1126 1126 static void omap_clk_update(struct clk *clk)

+3 -3

hw/misc/omap_gpmc.c

··· 643 643 case 0x010: /* GPMC_SYSCONFIG */ 644 644 if ((value >> 3) == 0x3) 645 645 fprintf(stderr, "%s: bad SDRAM idle mode %"PRIi64"\n", 646 646 - __FUNCTION__, value >> 3); 646 646 + __func__, value >> 3); 647 647 if (value & 2) 648 648 omap_gpmc_reset(s); 649 649 s->sysconfig = value & 0x19; ··· 806 806 break; 807 807 case 0x230: /* GPMC_TESTMODE_CTRL */ 808 808 if (value & 7) 809 809 - fprintf(stderr, "%s: test mode enable attempt\n", __FUNCTION__); 809 809 + fprintf(stderr, "%s: test mode enable attempt\n", __func__); 810 810 break; 811 811 812 812 default: ··· 864 864 assert(iomem); 865 865 866 866 if (cs < 0 || cs >= 8) { 867 867 - fprintf(stderr, "%s: bad chip-select %i\n", __FUNCTION__, cs); 867 867 + fprintf(stderr, "%s: bad chip-select %i\n", __func__, cs); 868 868 exit(-1); 869 869 } 870 870 f = &s->cs_file[cs];

+2 -2

hw/misc/omap_l4.c

··· 126 126 break; 127 127 } 128 128 if (!ta) { 129 129 - fprintf(stderr, "%s: bad target agent (%i)\n", __FUNCTION__, cs); 129 129 + fprintf(stderr, "%s: bad target agent (%i)\n", __func__, cs); 130 130 exit(-1); 131 131 } 132 132 ··· 151 151 hwaddr base; 152 152 153 153 if (region < 0 || region >= ta->regions) { 154 154 - fprintf(stderr, "%s: bad io region (%i)\n", __FUNCTION__, region); 154 154 + fprintf(stderr, "%s: bad io region (%i)\n", __func__, region); 155 155 exit(-1); 156 156 } 157 157

+1 -1

hw/misc/omap_sdrc.c

··· 109 109 case 0x10: /* SDRC_SYSCONFIG */ 110 110 if ((value >> 3) != 0x2) 111 111 fprintf(stderr, "%s: bad SDRAM idle mode %i\n", 112 112 - __FUNCTION__, (unsigned)value >> 3); 112 112 + __func__, (unsigned)value >> 3); 113 113 if (value & 2) 114 114 omap_sdrc_reset(s); 115 115 s->config = value & 0x18;

+3 -3

hw/misc/omap_tap.c

··· 44 44 case omap3430: 45 45 return 0x1b7ae02f; /* ES 2 */ 46 46 default: 47 47 - hw_error("%s: Bad mpu model\n", __FUNCTION__); 47 47 + hw_error("%s: Bad mpu model\n", __func__); 48 48 } 49 49 50 50 case 0x208: /* PRODUCTION_ID_reg for OMAP2 */ ··· 61 61 case omap3430: 62 62 return 0x000000f0; 63 63 default: 64 64 - hw_error("%s: Bad mpu model\n", __FUNCTION__); 64 64 + hw_error("%s: Bad mpu model\n", __func__); 65 65 } 66 66 67 67 case 0x20c: ··· 75 75 case omap3430: 76 76 return 0xcafeb7ae; /* ES 2 */ 77 77 default: 78 78 - hw_error("%s: Bad mpu model\n", __FUNCTION__); 78 78 + hw_error("%s: Bad mpu model\n", __func__); 79 79 } 80 80 81 81 case 0x218: /* DIE_ID_reg */

+1 -1

hw/misc/tmp105.c

··· 131 131 132 132 case TMP105_REG_CONFIG: 133 133 if (s->buf[0] & ~s->config & (1 << 0)) /* SD */ 134 134 - printf("%s: TMP105 shutdown\n", __FUNCTION__); 134 134 + printf("%s: TMP105 shutdown\n", __func__); 135 135 s->config = s->buf[0]; 136 136 s->faults = tmp105_faultq[(s->config >> 3) & 3]; /* F */ 137 137 tmp105_alarm_update(s);

+1 -1

hw/pci-host/bonito.c

··· 50 50 //#define DEBUG_BONITO 51 51 52 52 #ifdef DEBUG_BONITO 53 53 - #define DPRINTF(fmt, ...) fprintf(stderr, "%s: " fmt, __FUNCTION__, ##__VA_ARGS__) 53 53 + #define DPRINTF(fmt, ...) fprintf(stderr, "%s: " fmt, __func__, ##__VA_ARGS__) 54 54 #else 55 55 #define DPRINTF(fmt, ...) 56 56 #endif

+3 -3

hw/ssi/omap_spi.c

··· 295 295 if ((value ^ s->ch[ch].config) & (3 << 14)) /* DMAR | DMAW */ 296 296 omap_mcspi_dmarequest_update(s->ch + ch); 297 297 if (((value >> 12) & 3) == 3) /* TRM */ 298 298 - fprintf(stderr, "%s: invalid TRM value (3)\n", __FUNCTION__); 298 298 + fprintf(stderr, "%s: invalid TRM value (3)\n", __func__); 299 299 if (((value >> 7) & 0x1f) < 3) /* WL */ 300 300 fprintf(stderr, "%s: invalid WL value (%" PRIx64 ")\n", 301 301 - __FUNCTION__, (value >> 7) & 0x1f); 301 301 + __func__, (value >> 7) & 0x1f); 302 302 s->ch[ch].config = value & 0x7fffff; 303 303 break; 304 304 ··· 367 367 int chipselect) 368 368 { 369 369 if (chipselect < 0 || chipselect >= s->chnum) 370 370 - hw_error("%s: Bad chipselect %i\n", __FUNCTION__, chipselect); 370 370 + hw_error("%s: Bad chipselect %i\n", __func__, chipselect); 371 371 372 372 s->ch[chipselect].txrx = txrx; 373 373 s->ch[chipselect].opaque = opaque;

+3 -3

hw/timer/omap_gptimer.c

··· 357 357 s->config = value & 0x33d; 358 358 if (((value >> 3) & 3) == 3) /* IDLEMODE */ 359 359 fprintf(stderr, "%s: illegal IDLEMODE value in TIOCP_CFG\n", 360 360 - __FUNCTION__); 360 360 + __func__); 361 361 if (value & 2) /* SOFTRESET */ 362 362 omap_gp_timer_reset(s); 363 363 break; ··· 395 395 s->st = (value >> 0) & 1; 396 396 if (s->inout && s->trigger != gpt_trigger_none) 397 397 fprintf(stderr, "%s: GP timer pin must be an output " 398 398 - "for this trigger mode\n", __FUNCTION__); 398 398 + "for this trigger mode\n", __func__); 399 399 if (!s->inout && s->capture != gpt_capture_none) 400 400 fprintf(stderr, "%s: GP timer pin must be an input " 401 401 - "for this capture mode\n", __FUNCTION__); 401 401 + "for this capture mode\n", __func__); 402 402 if (s->trigger == gpt_trigger_none) 403 403 omap_gp_timer_out(s, s->scpwm); 404 404 /* TODO: make sure this doesn't overflow 32-bits */

+3 -3

hw/timer/twl92230.c

··· 403 403 404 404 default: 405 405 #ifdef VERBOSE 406 406 - printf("%s: unknown register %02x\n", __FUNCTION__, addr); 406 406 + printf("%s: unknown register %02x\n", __func__, addr); 407 407 #endif 408 408 break; 409 409 } ··· 615 615 rtc_badness: 616 616 default: 617 617 fprintf(stderr, "%s: bad RTC_UPDATE value %02x\n", 618 618 - __FUNCTION__, value); 618 618 + __func__, value); 619 619 s->status |= 1 << 10; /* RTCERR */ 620 620 menelaus_update(s); 621 621 } ··· 708 708 709 709 default: 710 710 #ifdef VERBOSE 711 711 - printf("%s: unknown register %02x\n", __FUNCTION__, addr); 711 711 + printf("%s: unknown register %02x\n", __func__, addr); 712 712 #endif 713 713 } 714 714 }

+1 -1

hw/usb/desc.c

··· 688 688 break; 689 689 690 690 default: 691 691 - fprintf(stderr, "%s: %d unknown type %d (len %zd)\n", __FUNCTION__, 691 691 + fprintf(stderr, "%s: %d unknown type %d (len %zd)\n", __func__, 692 692 dev->addr, type, len); 693 693 break; 694 694 }

+2 -2

hw/usb/dev-bluetooth.c

··· 274 274 if (off <= DFIFO_LEN_MASK) { 275 275 if (off + len > DFIFO_LEN_MASK + 1 && 276 276 (fifo->dsize = off + len) > (DFIFO_LEN_MASK + 1) * 2) { 277 277 - fprintf(stderr, "%s: can't alloc %i bytes\n", __FUNCTION__, len); 277 277 + fprintf(stderr, "%s: can't alloc %i bytes\n", __func__, len); 278 278 exit(-1); 279 279 } 280 280 buf = fifo->data + off; 281 281 } else { 282 282 if (fifo->dlen > fifo->dsize) { 283 283 - fprintf(stderr, "%s: can't alloc %i bytes\n", __FUNCTION__, len); 283 283 + fprintf(stderr, "%s: can't alloc %i bytes\n", __func__, len); 284 284 exit(-1); 285 285 } 286 286 buf = fifo->data + off - fifo->dsize;

+2 -2

hw/usb/hcd-musb.c

··· 253 253 /* #define MUSB_DEBUG */ 254 254 255 255 #ifdef MUSB_DEBUG 256 256 - #define TRACE(fmt,...) fprintf(stderr, "%s@%d: " fmt "\n", __FUNCTION__, \ 257 257 - __LINE__, ##__VA_ARGS__) 256 256 + #define TRACE(fmt, ...) fprintf(stderr, "%s@%d: " fmt "\n", __func__, \ 257 257 + __LINE__, ##__VA_ARGS__) 258 258 #else 259 259 #define TRACE(...) 260 260 #endif

+7 -7

hw/usb/tusb6010.c

··· 296 296 } 297 297 298 298 printf("%s: unknown register at %03x\n", 299 299 - __FUNCTION__, (int) (addr & 0xfff)); 299 299 + __func__, (int) (addr & 0xfff)); 300 300 return 0; 301 301 } 302 302 ··· 313 313 } 314 314 315 315 printf("%s: unknown register at %03x\n", 316 316 - __FUNCTION__, (int) (addr & 0xfff)); 316 316 + __func__, (int) (addr & 0xfff)); 317 317 return 0; 318 318 } 319 319 ··· 436 436 return 0x54059adf; 437 437 } 438 438 439 439 - printf("%s: unknown register at %03x\n", __FUNCTION__, offset); 439 439 + printf("%s: unknown register at %03x\n", __func__, offset); 440 440 return 0; 441 441 } 442 442 ··· 456 456 457 457 default: 458 458 printf("%s: unknown register at %03x\n", 459 459 - __FUNCTION__, (int) (addr & 0xfff)); 459 459 + __func__, (int) (addr & 0xfff)); 460 460 return; 461 461 } 462 462 } ··· 477 477 478 478 default: 479 479 printf("%s: unknown register at %03x\n", 480 480 - __FUNCTION__, (int) (addr & 0xfff)); 480 480 + __func__, (int) (addr & 0xfff)); 481 481 return; 482 482 } 483 483 } ··· 505 505 s->dev_config = value; 506 506 s->host_mode = (value & TUSB_DEV_CONF_USB_HOST_MODE); 507 507 if (value & TUSB_DEV_CONF_PROD_TEST_MODE) 508 508 - hw_error("%s: Product Test mode not allowed\n", __FUNCTION__); 508 508 + hw_error("%s: Product Test mode not allowed\n", __func__); 509 509 break; 510 510 511 511 case TUSB_PHY_OTG_CTRL_ENABLE: ··· 636 636 break; 637 637 638 638 default: 639 639 - printf("%s: unknown register at %03x\n", __FUNCTION__, offset); 639 639 + printf("%s: unknown register at %03x\n", __func__, offset); 640 640 return; 641 641 } 642 642 }

+8 -8

hw/xenpv/xen_domainbuild.c

··· 25 25 int i; 26 26 27 27 if (!xs_mkdir(xenstore, 0, path)) { 28 28 - fprintf(stderr, "%s: xs_mkdir %s: failed\n", __FUNCTION__, path); 28 28 + fprintf(stderr, "%s: xs_mkdir %s: failed\n", __func__, path); 29 29 return -1; 30 30 } 31 31 if (!xs_set_permissions(xenstore, 0, path, perms_ro, 2)) { 32 32 - fprintf(stderr, "%s: xs_set_permissions failed\n", __FUNCTION__); 32 32 + fprintf(stderr, "%s: xs_set_permissions failed\n", __func__); 33 33 return -1; 34 34 } 35 35 36 36 for (i = 0; writable[i]; i++) { 37 37 snprintf(subpath, sizeof(subpath), "%s/%s", path, writable[i]); 38 38 if (!xs_mkdir(xenstore, 0, subpath)) { 39 39 - fprintf(stderr, "%s: xs_mkdir %s: failed\n", __FUNCTION__, subpath); 39 39 + fprintf(stderr, "%s: xs_mkdir %s: failed\n", __func__, subpath); 40 40 return -1; 41 41 } 42 42 if (!xs_set_permissions(xenstore, 0, subpath, perms_rw, 2)) { 43 43 - fprintf(stderr, "%s: xs_set_permissions failed\n", __FUNCTION__); 43 43 + fprintf(stderr, "%s: xs_set_permissions failed\n", __func__); 44 44 return -1; 45 45 } 46 46 } ··· 158 158 char byte; 159 159 160 160 if (pipe(fd) != 0) { 161 161 - qemu_log("%s: Huh? pipe error: %s\n", __FUNCTION__, strerror(errno)); 161 161 + qemu_log("%s: Huh? pipe error: %s\n", __func__, strerror(errno)); 162 162 return -1; 163 163 } 164 164 if (fork() != 0) ··· 190 190 case -1: 191 191 if (errno == EINTR) 192 192 continue; 193 193 - qemu_log("%s: Huh? read error: %s\n", __FUNCTION__, strerror(errno)); 193 193 + qemu_log("%s: Huh? read error: %s\n", __func__, strerror(errno)); 194 194 qemu_running = 0; 195 195 break; 196 196 case 0: ··· 198 198 qemu_running = 0; 199 199 break; 200 200 default: 201 201 - qemu_log("%s: Huh? data on the watch pipe?\n", __FUNCTION__); 201 201 + qemu_log("%s: Huh? data on the watch pipe?\n", __func__); 202 202 break; 203 203 } 204 204 } 205 205 206 206 /* cleanup */ 207 207 - qemu_log("%s: destroy domain %d\n", __FUNCTION__, xen_domid); 207 207 + qemu_log("%s: destroy domain %d\n", __func__, xen_domid); 208 208 xc_domain_destroy(xen_xc, xen_domid); 209 209 _exit(0); 210 210 }

+1 -1

hw/xenpv/xen_machine_pv.c

··· 36 36 37 37 /* Initialize backend core & drivers */ 38 38 if (xen_be_init() != 0) { 39 39 - fprintf(stderr, "%s: xen backend core setup failed\n", __FUNCTION__); 39 39 + fprintf(stderr, "%s: xen backend core setup failed\n", __func__); 40 40 exit(1); 41 41 } 42 42

+5 -5

include/hw/arm/omap.h

··· 960 960 961 961 # define OMAP_BAD_REG(paddr) \ 962 962 fprintf(stderr, "%s: Bad register " OMAP_FMT_plx "\n", \ 963 963 - __FUNCTION__, paddr) 963 963 + __func__, paddr) 964 964 # define OMAP_RO_REG(paddr) \ 965 965 fprintf(stderr, "%s: Read-only register " OMAP_FMT_plx "\n", \ 966 966 - __FUNCTION__, paddr) 966 966 + __func__, paddr) 967 967 968 968 /* OMAP-specific Linux bootloader tags for the ATAG_BOARD area 969 969 (Board-specifc tags are not here) */ ··· 998 998 # ifdef TCMI_VERBOSE 999 999 # define OMAP_8B_REG(paddr) \ 1000 1000 fprintf(stderr, "%s: 8-bit register " OMAP_FMT_plx "\n", \ 1001 1001 - __FUNCTION__, paddr) 1001 1001 + __func__, paddr) 1002 1002 # define OMAP_16B_REG(paddr) \ 1003 1003 fprintf(stderr, "%s: 16-bit register " OMAP_FMT_plx "\n", \ 1004 1004 - __FUNCTION__, paddr) 1004 1004 + __func__, paddr) 1005 1005 # define OMAP_32B_REG(paddr) \ 1006 1006 fprintf(stderr, "%s: 32-bit register " OMAP_FMT_plx "\n", \ 1007 1007 - __FUNCTION__, paddr) 1007 1007 + __func__, paddr) 1008 1008 # else 1009 1009 # define OMAP_8B_REG(paddr) 1010 1010 # define OMAP_16B_REG(paddr)

+1 -1

include/hw/arm/sharpsl.h

··· 7 7 #define QEMU_SHARPSL_H 8 8 9 9 #define zaurus_printf(format, ...) \ 10 10 - fprintf(stderr, "%s: " format, __FUNCTION__, ##__VA_ARGS__) 10 10 + fprintf(stderr, "%s: " format, __func__, ##__VA_ARGS__) 11 11 12 12 /* zaurus.c */ 13 13

+1 -1

memory_mapping.c

··· 256 256 257 257 #ifdef DEBUG_GUEST_PHYS_REGION_ADD 258 258 fprintf(stderr, "%s: target_start=" TARGET_FMT_plx " target_end=" 259 259 - TARGET_FMT_plx ": %s (count: %u)\n", __FUNCTION__, target_start, 259 259 + TARGET_FMT_plx ": %s (count: %u)\n", __func__, target_start, 260 260 target_end, predecessor ? "joined" : "added", g->list->num); 261 261 #endif 262 262 }

+2 -2

migration/block.c

··· 631 631 int ret = 0; 632 632 633 633 DPRINTF("%s Enter submitted %d read_done %d transferred %d\n", 634 634 - __FUNCTION__, block_mig_state.submitted, block_mig_state.read_done, 634 634 + __func__, block_mig_state.submitted, block_mig_state.read_done, 635 635 block_mig_state.transferred); 636 636 637 637 blk_mig_lock(); ··· 658 658 } 659 659 blk_mig_unlock(); 660 660 661 661 - DPRINTF("%s Exit submitted %d read_done %d transferred %d\n", __FUNCTION__, 661 661 + DPRINTF("%s Exit submitted %d read_done %d transferred %d\n", __func__, 662 662 block_mig_state.submitted, block_mig_state.read_done, 663 663 block_mig_state.transferred); 664 664 return ret;

+3 -3

ui/cursor.c

··· 19 19 if (sscanf(xpm[line], "%u %u %u %u", 20 20 &width, &height, &colors, &chars) != 4) { 21 21 fprintf(stderr, "%s: header parse error: \"%s\"\n", 22 22 - __FUNCTION__, xpm[line]); 22 22 + __func__, xpm[line]); 23 23 return NULL; 24 24 } 25 25 if (chars != 1) { 26 26 - fprintf(stderr, "%s: chars != 1 not supported\n", __FUNCTION__); 26 26 + fprintf(stderr, "%s: chars != 1 not supported\n", __func__); 27 27 return NULL; 28 28 } 29 29 line++; ··· 41 41 } 42 42 } 43 43 fprintf(stderr, "%s: color parse error: \"%s\"\n", 44 44 - __FUNCTION__, xpm[line]); 44 44 + __func__, xpm[line]); 45 45 return NULL; 46 46 } 47 47

+2 -2

ui/spice-display.c

··· 629 629 630 630 static void interface_notify_update(QXLInstance *sin, uint32_t update_id) 631 631 { 632 632 - fprintf(stderr, "%s: abort()\n", __FUNCTION__); 632 632 + fprintf(stderr, "%s: abort()\n", __func__); 633 633 abort(); 634 634 } 635 635 636 636 static int interface_flush_resources(QXLInstance *sin) 637 637 { 638 638 - fprintf(stderr, "%s: abort()\n", __FUNCTION__); 638 638 + fprintf(stderr, "%s: abort()\n", __func__); 639 639 abort(); 640 640 return 0; 641 641 }