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

drivers/char: replace remaining __FUNCTION__ occurrences

__FUNCTION__ is gcc-specific, use __func__

Signed-off-by: Harvey Harrison <harvey.harrison@gmail.com>
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 bf9d8929 8e24eea7

+91 -91
+1 -1
drivers/char/agp/agp.h
··· 35 35 36 36 //#define AGP_DEBUG 1 37 37 #ifdef AGP_DEBUG 38 - #define DBG(x,y...) printk (KERN_DEBUG PFX "%s: " x "\n", __FUNCTION__ , ## y) 38 + #define DBG(x,y...) printk (KERN_DEBUG PFX "%s: " x "\n", __func__ , ## y) 39 39 #else 40 40 #define DBG(x,y...) do { } while (0) 41 41 #endif
+2 -2
drivers/char/cyclades.c
··· 3490 3490 struct BOARD_CTRL __iomem *board_ctrl; 3491 3491 struct CH_CTRL __iomem *ch_ctrl; 3492 3492 3493 - if (serial_paranoia_check(info, tty->name, __FUNCTION__)) 3493 + if (serial_paranoia_check(info, tty->name, __func__)) 3494 3494 return -ENODEV; 3495 3495 3496 3496 lock_kernel(); ··· 3561 3561 struct CH_CTRL __iomem *ch_ctrl; 3562 3562 int retval; 3563 3563 3564 - if (serial_paranoia_check(info, tty->name, __FUNCTION__)) 3564 + if (serial_paranoia_check(info, tty->name, __func__)) 3565 3565 return -ENODEV; 3566 3566 3567 3567 card = info->card;
+4 -4
drivers/char/drm/drmP.h
··· 160 160 * \param arg arguments 161 161 */ 162 162 #define DRM_ERROR(fmt, arg...) \ 163 - printk(KERN_ERR "[" DRM_NAME ":%s] *ERROR* " fmt , __FUNCTION__ , ##arg) 163 + printk(KERN_ERR "[" DRM_NAME ":%s] *ERROR* " fmt , __func__ , ##arg) 164 164 165 165 /** 166 166 * Memory error output. ··· 170 170 * \param arg arguments 171 171 */ 172 172 #define DRM_MEM_ERROR(area, fmt, arg...) \ 173 - printk(KERN_ERR "[" DRM_NAME ":%s:%s] *ERROR* " fmt , __FUNCTION__, \ 173 + printk(KERN_ERR "[" DRM_NAME ":%s:%s] *ERROR* " fmt , __func__, \ 174 174 drm_mem_stats[area].name , ##arg) 175 175 176 176 #define DRM_INFO(fmt, arg...) printk(KERN_INFO "[" DRM_NAME "] " fmt , ##arg) ··· 187 187 if ( drm_debug ) \ 188 188 printk(KERN_DEBUG \ 189 189 "[" DRM_NAME ":%s] " fmt , \ 190 - __FUNCTION__ , ##arg); \ 190 + __func__ , ##arg); \ 191 191 } while (0) 192 192 #else 193 193 #define DRM_DEBUG(fmt, arg...) do { } while (0) ··· 238 238 if ( !_DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ) || \ 239 239 dev->lock.file_priv != file_priv ) { \ 240 240 DRM_ERROR( "%s called without lock held, held %d owner %p %p\n",\ 241 - __FUNCTION__, _DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ),\ 241 + __func__, _DRM_LOCK_IS_HELD( dev->lock.hw_lock->lock ),\ 242 242 dev->lock.file_priv, file_priv ); \ 243 243 return -EINVAL; \ 244 244 } \
+1 -1
drivers/char/drm/drm_sysfs.c
··· 34 34 struct drm_minor *drm_minor = to_drm_minor(dev); 35 35 struct drm_device *drm_dev = drm_minor->dev; 36 36 37 - printk(KERN_ERR "%s\n", __FUNCTION__); 37 + printk(KERN_ERR "%s\n", __func__); 38 38 39 39 if (drm_dev->driver->suspend) 40 40 return drm_dev->driver->suspend(drm_dev, state);
+9 -9
drivers/char/drm/i830_dma.c
··· 692 692 drm_i830_sarea_t *sarea_priv = dev_priv->sarea_priv; 693 693 unsigned int dirty = sarea_priv->dirty; 694 694 695 - DRM_DEBUG("%s %x\n", __FUNCTION__, dirty); 695 + DRM_DEBUG("%s %x\n", __func__, dirty); 696 696 697 697 if (dirty & I830_UPLOAD_BUFFERS) { 698 698 i830EmitDestVerified(dev, sarea_priv->BufferState); ··· 1043 1043 RING_LOCALS; 1044 1044 1045 1045 DRM_DEBUG("%s: page=%d pfCurrentPage=%d\n", 1046 - __FUNCTION__, 1046 + __func__, 1047 1047 dev_priv->current_page, 1048 1048 dev_priv->sarea_priv->pf_current_page); 1049 1049 ··· 1206 1206 OUT_RING(0); 1207 1207 ADVANCE_LP_RING(); 1208 1208 1209 - i830_wait_ring(dev, dev_priv->ring.Size - 8, __FUNCTION__); 1209 + i830_wait_ring(dev, dev_priv->ring.Size - 8, __func__); 1210 1210 } 1211 1211 1212 1212 static int i830_flush_queue(struct drm_device * dev) ··· 1223 1223 OUT_RING(0); 1224 1224 ADVANCE_LP_RING(); 1225 1225 1226 - i830_wait_ring(dev, dev_priv->ring.Size - 8, __FUNCTION__); 1226 + i830_wait_ring(dev, dev_priv->ring.Size - 8, __func__); 1227 1227 1228 1228 for (i = 0; i < dma->buf_count; i++) { 1229 1229 struct drm_buf *buf = dma->buflist[i]; ··· 1344 1344 { 1345 1345 drm_i830_private_t *dev_priv = dev->dev_private; 1346 1346 1347 - DRM_DEBUG("%s\n", __FUNCTION__); 1347 + DRM_DEBUG("%s\n", __func__); 1348 1348 dev_priv->page_flipping = 1; 1349 1349 dev_priv->current_page = 0; 1350 1350 dev_priv->sarea_priv->pf_current_page = dev_priv->current_page; ··· 1354 1354 { 1355 1355 drm_i830_private_t *dev_priv = dev->dev_private; 1356 1356 1357 - DRM_DEBUG("%s\n", __FUNCTION__); 1357 + DRM_DEBUG("%s\n", __func__); 1358 1358 if (dev_priv->current_page != 0) 1359 1359 i830_dma_dispatch_flip(dev); 1360 1360 ··· 1367 1367 { 1368 1368 drm_i830_private_t *dev_priv = dev->dev_private; 1369 1369 1370 - DRM_DEBUG("%s\n", __FUNCTION__); 1370 + DRM_DEBUG("%s\n", __func__); 1371 1371 1372 1372 LOCK_TEST_WITH_RETURN(dev, file_priv); 1373 1373 ··· 1437 1437 int value; 1438 1438 1439 1439 if (!dev_priv) { 1440 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 1440 + DRM_ERROR("%s called with no initialization\n", __func__); 1441 1441 return -EINVAL; 1442 1442 } 1443 1443 ··· 1464 1464 drm_i830_setparam_t *param = data; 1465 1465 1466 1466 if (!dev_priv) { 1467 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 1467 + DRM_ERROR("%s called with no initialization\n", __func__); 1468 1468 return -EINVAL; 1469 1469 } 1470 1470
+1 -1
drivers/char/drm/i830_drv.h
··· 158 158 if (I830_VERBOSE) \ 159 159 printk("BEGIN_LP_RING(%d)\n", (n)); \ 160 160 if (dev_priv->ring.space < n*4) \ 161 - i830_wait_ring(dev, n*4, __FUNCTION__); \ 161 + i830_wait_ring(dev, n*4, __func__); \ 162 162 outcount = 0; \ 163 163 outring = dev_priv->ring.tail; \ 164 164 ringmask = dev_priv->ring.tail_mask; \
+4 -4
drivers/char/drm/i830_irq.c
··· 58 58 drm_i830_private_t *dev_priv = dev->dev_private; 59 59 RING_LOCALS; 60 60 61 - DRM_DEBUG("%s\n", __FUNCTION__); 61 + DRM_DEBUG("%s\n", __func__); 62 62 63 63 atomic_inc(&dev_priv->irq_emitted); 64 64 ··· 77 77 unsigned long end = jiffies + HZ * 3; 78 78 int ret = 0; 79 79 80 - DRM_DEBUG("%s\n", __FUNCTION__); 80 + DRM_DEBUG("%s\n", __func__); 81 81 82 82 if (atomic_read(&dev_priv->irq_received) >= irq_nr) 83 83 return 0; ··· 124 124 LOCK_TEST_WITH_RETURN(dev, file_priv); 125 125 126 126 if (!dev_priv) { 127 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 127 + DRM_ERROR("%s called with no initialization\n", __func__); 128 128 return -EINVAL; 129 129 } 130 130 ··· 147 147 drm_i830_irq_wait_t *irqwait = data; 148 148 149 149 if (!dev_priv) { 150 - DRM_ERROR("%s called with no initialization\n", __FUNCTION__); 150 + DRM_ERROR("%s called with no initialization\n", __func__); 151 151 return -EINVAL; 152 152 } 153 153
+2 -2
drivers/char/drm/i915_dma.c
··· 194 194 { 195 195 drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private; 196 196 197 - DRM_DEBUG("%s\n", __FUNCTION__); 197 + DRM_DEBUG("%s\n", __func__); 198 198 199 199 if (!dev_priv->sarea) { 200 200 DRM_ERROR("can not find sarea!\n"); ··· 609 609 drm_i915_private_t *dev_priv = dev->dev_private; 610 610 611 611 i915_kernel_lost_context(dev); 612 - return i915_wait_ring(dev, dev_priv->ring.Size - 8, __FUNCTION__); 612 + return i915_wait_ring(dev, dev_priv->ring.Size - 8, __func__); 613 613 } 614 614 615 615 static int i915_flush_ioctl(struct drm_device *dev, void *data,
+1 -1
drivers/char/drm/i915_drv.h
··· 272 272 if (I915_VERBOSE) \ 273 273 DRM_DEBUG("BEGIN_LP_RING(%d)\n", (n)); \ 274 274 if (dev_priv->ring.space < (n)*4) \ 275 - i915_wait_ring(dev, (n)*4, __FUNCTION__); \ 275 + i915_wait_ring(dev, (n)*4, __func__); \ 276 276 outcount = 0; \ 277 277 outring = dev_priv->ring.tail; \ 278 278 ringmask = dev_priv->ring.tail_mask; \
+1 -1
drivers/char/drm/radeon_cp.c
··· 894 894 #if RADEON_FIFO_DEBUG 895 895 static void radeon_status(drm_radeon_private_t * dev_priv) 896 896 { 897 - printk("%s:\n", __FUNCTION__); 897 + printk("%s:\n", __func__); 898 898 printk("RBBM_STATUS = 0x%08x\n", 899 899 (unsigned int)RADEON_READ(RADEON_RBBM_STATUS)); 900 900 printk("CP_RB_RTPR = 0x%08x\n",
+2 -2
drivers/char/esp.c
··· 1671 1671 unsigned char control, status; 1672 1672 unsigned long flags; 1673 1673 1674 - if (serial_paranoia_check(info, tty->name, __FUNCTION__)) 1674 + if (serial_paranoia_check(info, tty->name, __func__)) 1675 1675 return -ENODEV; 1676 1676 if (tty->flags & (1 << TTY_IO_ERROR)) 1677 1677 return -EIO; ··· 1697 1697 struct esp_struct *info = tty->driver_data; 1698 1698 unsigned long flags; 1699 1699 1700 - if (serial_paranoia_check(info, tty->name, __FUNCTION__)) 1700 + if (serial_paranoia_check(info, tty->name, __func__)) 1701 1701 return -ENODEV; 1702 1702 if (tty->flags & (1 << TTY_IO_ERROR)) 1703 1703 return -EIO;
+2 -2
drivers/char/generic_serial.c
··· 40 40 #define gs_dprintk(f, str...) /* nothing */ 41 41 #endif 42 42 43 - #define func_enter() gs_dprintk (GS_DEBUG_FLOW, "gs: enter %s\n", __FUNCTION__) 44 - #define func_exit() gs_dprintk (GS_DEBUG_FLOW, "gs: exit %s\n", __FUNCTION__) 43 + #define func_enter() gs_dprintk (GS_DEBUG_FLOW, "gs: enter %s\n", __func__) 44 + #define func_exit() gs_dprintk (GS_DEBUG_FLOW, "gs: exit %s\n", __func__) 45 45 46 46 #define RS_EVENT_WRITE_WAKEUP 1 47 47
+5 -5
drivers/char/hpet.c
··· 308 308 if (io_remap_pfn_range(vma, vma->vm_start, addr >> PAGE_SHIFT, 309 309 PAGE_SIZE, vma->vm_page_prot)) { 310 310 printk(KERN_ERR "%s: io_remap_pfn_range failed\n", 311 - __FUNCTION__); 311 + __func__); 312 312 return -EAGAIN; 313 313 } 314 314 ··· 748 748 */ 749 749 if (hpet_is_known(hdp)) { 750 750 printk(KERN_DEBUG "%s: duplicate HPET ignored\n", 751 - __FUNCTION__); 751 + __func__); 752 752 return 0; 753 753 } 754 754 ··· 869 869 870 870 if (hpet_is_known(hdp)) { 871 871 printk(KERN_DEBUG "%s: 0x%lx is busy\n", 872 - __FUNCTION__, hdp->hd_phys_address); 872 + __func__, hdp->hd_phys_address); 873 873 iounmap(hdp->hd_address); 874 874 return AE_ALREADY_EXISTS; 875 875 } ··· 886 886 887 887 if (hpet_is_known(hdp)) { 888 888 printk(KERN_DEBUG "%s: 0x%lx is busy\n", 889 - __FUNCTION__, hdp->hd_phys_address); 889 + __func__, hdp->hd_phys_address); 890 890 iounmap(hdp->hd_address); 891 891 return AE_ALREADY_EXISTS; 892 892 } ··· 925 925 return -ENODEV; 926 926 927 927 if (!data.hd_address || !data.hd_nirqs) { 928 - printk("%s: no address or irqs in _CRS\n", __FUNCTION__); 928 + printk("%s: no address or irqs in _CRS\n", __func__); 929 929 return -ENODEV; 930 930 } 931 931
+26 -26
drivers/char/hvsi.c
··· 246 246 { 247 247 int remaining = (int)(hp->inbuf_end - read_to); 248 248 249 - pr_debug("%s: %i chars remain\n", __FUNCTION__, remaining); 249 + pr_debug("%s: %i chars remain\n", __func__, remaining); 250 250 251 251 if (read_to != hp->inbuf) 252 252 memmove(hp->inbuf, read_to, remaining); ··· 365 365 packet.u.version = HVSI_VERSION; 366 366 packet.query_seqno = query_seqno+1; 367 367 368 - pr_debug("%s: sending %i bytes\n", __FUNCTION__, packet.len); 368 + pr_debug("%s: sending %i bytes\n", __func__, packet.len); 369 369 dbg_dump_hex((uint8_t*)&packet, packet.len); 370 370 371 371 wrote = hvc_put_chars(hp->vtermno, (char *)&packet, packet.len); ··· 437 437 return NULL; 438 438 439 439 if (overflow > 0) { 440 - pr_debug("%s: got >TTY_THRESHOLD_THROTTLE bytes\n", __FUNCTION__); 440 + pr_debug("%s: got >TTY_THRESHOLD_THROTTLE bytes\n", __func__); 441 441 datalen = TTY_THRESHOLD_THROTTLE; 442 442 } 443 443 ··· 448 448 * we still have more data to deliver, so we need to save off the 449 449 * overflow and send it later 450 450 */ 451 - pr_debug("%s: deferring overflow\n", __FUNCTION__); 451 + pr_debug("%s: deferring overflow\n", __func__); 452 452 memcpy(hp->throttle_buf, data + TTY_THRESHOLD_THROTTLE, overflow); 453 453 hp->n_throttle = overflow; 454 454 } ··· 474 474 475 475 chunklen = hvsi_read(hp, hp->inbuf_end, HVSI_MAX_READ); 476 476 if (chunklen == 0) { 477 - pr_debug("%s: 0-length read\n", __FUNCTION__); 477 + pr_debug("%s: 0-length read\n", __func__); 478 478 return 0; 479 479 } 480 480 481 - pr_debug("%s: got %i bytes\n", __FUNCTION__, chunklen); 481 + pr_debug("%s: got %i bytes\n", __func__, chunklen); 482 482 dbg_dump_hex(hp->inbuf_end, chunklen); 483 483 484 484 hp->inbuf_end += chunklen; ··· 495 495 continue; 496 496 } 497 497 498 - pr_debug("%s: handling %i-byte packet\n", __FUNCTION__, 498 + pr_debug("%s: handling %i-byte packet\n", __func__, 499 499 len_packet(packet)); 500 500 dbg_dump_packet(packet); 501 501 ··· 526 526 packet += len_packet(packet); 527 527 528 528 if (*hangup || *handshake) { 529 - pr_debug("%s: hangup or handshake\n", __FUNCTION__); 529 + pr_debug("%s: hangup or handshake\n", __func__); 530 530 /* 531 531 * we need to send the hangup now before receiving any more data. 532 532 * If we get "data, hangup, data", we can't deliver the second ··· 543 543 544 544 static void hvsi_send_overflow(struct hvsi_struct *hp) 545 545 { 546 - pr_debug("%s: delivering %i bytes overflow\n", __FUNCTION__, 546 + pr_debug("%s: delivering %i bytes overflow\n", __func__, 547 547 hp->n_throttle); 548 548 549 549 hvsi_insert_chars(hp, hp->throttle_buf, hp->n_throttle); ··· 563 563 unsigned long flags; 564 564 int again = 1; 565 565 566 - pr_debug("%s\n", __FUNCTION__); 566 + pr_debug("%s\n", __func__); 567 567 568 568 while (again) { 569 569 spin_lock_irqsave(&hp->lock, flags); ··· 647 647 packet.seqno = atomic_inc_return(&hp->seqno); 648 648 packet.verb = verb; 649 649 650 - pr_debug("%s: sending %i bytes\n", __FUNCTION__, packet.len); 650 + pr_debug("%s: sending %i bytes\n", __func__, packet.len); 651 651 dbg_dump_hex((uint8_t*)&packet, packet.len); 652 652 653 653 wrote = hvc_put_chars(hp->vtermno, (char *)&packet, packet.len); ··· 674 674 return ret; 675 675 } 676 676 677 - pr_debug("%s: mctrl 0x%x\n", __FUNCTION__, hp->mctrl); 677 + pr_debug("%s: mctrl 0x%x\n", __func__, hp->mctrl); 678 678 679 679 return 0; 680 680 } ··· 694 694 if (mctrl & TIOCM_DTR) 695 695 packet.word = HVSI_TSDTR; 696 696 697 - pr_debug("%s: sending %i bytes\n", __FUNCTION__, packet.len); 697 + pr_debug("%s: sending %i bytes\n", __func__, packet.len); 698 698 dbg_dump_hex((uint8_t*)&packet, packet.len); 699 699 700 700 wrote = hvc_put_chars(hp->vtermno, (char *)&packet, packet.len); ··· 790 790 packet.len = 6; 791 791 packet.verb = VSV_CLOSE_PROTOCOL; 792 792 793 - pr_debug("%s: sending %i bytes\n", __FUNCTION__, packet.len); 793 + pr_debug("%s: sending %i bytes\n", __func__, packet.len); 794 794 dbg_dump_hex((uint8_t*)&packet, packet.len); 795 795 796 796 hvc_put_chars(hp->vtermno, (char *)&packet, packet.len); ··· 803 803 int line = tty->index; 804 804 int ret; 805 805 806 - pr_debug("%s\n", __FUNCTION__); 806 + pr_debug("%s\n", __func__); 807 807 808 808 if (line < 0 || line >= hvsi_count) 809 809 return -ENODEV; ··· 868 868 struct hvsi_struct *hp = tty->driver_data; 869 869 unsigned long flags; 870 870 871 - pr_debug("%s\n", __FUNCTION__); 871 + pr_debug("%s\n", __func__); 872 872 873 873 if (tty_hung_up_p(filp)) 874 874 return; ··· 920 920 struct hvsi_struct *hp = tty->driver_data; 921 921 unsigned long flags; 922 922 923 - pr_debug("%s\n", __FUNCTION__); 923 + pr_debug("%s\n", __func__); 924 924 925 925 spin_lock_irqsave(&hp->lock, flags); 926 926 ··· 942 942 n = hvsi_put_chars(hp, hp->outbuf, hp->n_outbuf); 943 943 if (n > 0) { 944 944 /* success */ 945 - pr_debug("%s: wrote %i chars\n", __FUNCTION__, n); 945 + pr_debug("%s: wrote %i chars\n", __func__, n); 946 946 hp->n_outbuf = 0; 947 947 } else if (n == -EIO) { 948 948 __set_state(hp, HVSI_FSP_DIED); ··· 965 965 966 966 spin_lock_irqsave(&hp->lock, flags); 967 967 968 - pr_debug("%s: %i chars in buffer\n", __FUNCTION__, hp->n_outbuf); 968 + pr_debug("%s: %i chars in buffer\n", __func__, hp->n_outbuf); 969 969 970 970 if (!is_open(hp)) { 971 971 /* ··· 983 983 schedule_delayed_work(&hp->writer, 10); 984 984 else { 985 985 #ifdef DEBUG 986 - pr_debug("%s: outbuf emptied after %li jiffies\n", __FUNCTION__, 986 + pr_debug("%s: outbuf emptied after %li jiffies\n", __func__, 987 987 jiffies - start_j); 988 988 start_j = 0; 989 989 #endif /* DEBUG */ ··· 1020 1020 1021 1021 spin_lock_irqsave(&hp->lock, flags); 1022 1022 1023 - pr_debug("%s: %i chars in buffer\n", __FUNCTION__, hp->n_outbuf); 1023 + pr_debug("%s: %i chars in buffer\n", __func__, hp->n_outbuf); 1024 1024 1025 1025 if (!is_open(hp)) { 1026 1026 /* we're either closing or not yet open; don't accept data */ 1027 - pr_debug("%s: not open\n", __FUNCTION__); 1027 + pr_debug("%s: not open\n", __func__); 1028 1028 goto out; 1029 1029 } 1030 1030 ··· 1058 1058 spin_unlock_irqrestore(&hp->lock, flags); 1059 1059 1060 1060 if (total != origcount) 1061 - pr_debug("%s: wanted %i, only wrote %i\n", __FUNCTION__, origcount, 1061 + pr_debug("%s: wanted %i, only wrote %i\n", __func__, origcount, 1062 1062 total); 1063 1063 1064 1064 return total; ··· 1072 1072 { 1073 1073 struct hvsi_struct *hp = (struct hvsi_struct *)tty->driver_data; 1074 1074 1075 - pr_debug("%s\n", __FUNCTION__); 1075 + pr_debug("%s\n", __func__); 1076 1076 1077 1077 h_vio_signal(hp->vtermno, VIO_IRQ_DISABLE); 1078 1078 } ··· 1083 1083 unsigned long flags; 1084 1084 int shouldflip = 0; 1085 1085 1086 - pr_debug("%s\n", __FUNCTION__); 1086 + pr_debug("%s\n", __func__); 1087 1087 1088 1088 spin_lock_irqsave(&hp->lock, flags); 1089 1089 if (hp->n_throttle) { ··· 1302 1302 hp->virq = irq_create_mapping(NULL, irq[0]); 1303 1303 if (hp->virq == NO_IRQ) { 1304 1304 printk(KERN_ERR "%s: couldn't create irq mapping for 0x%x\n", 1305 - __FUNCTION__, irq[0]); 1305 + __func__, irq[0]); 1306 1306 continue; 1307 1307 } 1308 1308
+1 -1
drivers/char/nozomi.c
··· 73 73 char tmp[P_BUF_SIZE]; \ 74 74 snprintf(tmp, sizeof(tmp), ##args); \ 75 75 printk(_err_flag_ "[%d] %s(): %s\n", __LINE__, \ 76 - __FUNCTION__, tmp); \ 76 + __func__, tmp); \ 77 77 } while (0) 78 78 79 79 #define DBG1(args...) D_(0x01, ##args)
+1 -1
drivers/char/pcmcia/cm4000_cs.c
··· 53 53 #define DEBUGP(n, rdr, x, args...) do { \ 54 54 if (pc_debug >= (n)) \ 55 55 dev_printk(KERN_DEBUG, reader_to_dev(rdr), "%s:" x, \ 56 - __FUNCTION__ , ## args); \ 56 + __func__ , ## args); \ 57 57 } while (0) 58 58 #else 59 59 #define DEBUGP(n, rdr, x, args...)
+1 -1
drivers/char/pcmcia/cm4040_cs.c
··· 47 47 #define DEBUGP(n, rdr, x, args...) do { \ 48 48 if (pc_debug >= (n)) \ 49 49 dev_printk(KERN_DEBUG, reader_to_dev(rdr), "%s:" x, \ 50 - __FUNCTION__ , ##args); \ 50 + __func__ , ##args); \ 51 51 } while (0) 52 52 #else 53 53 #define DEBUGP(n, rdr, x, args...)
+3 -3
drivers/char/rio/rio_linux.h
··· 186 186 187 187 #ifdef DEBUG 188 188 #define rio_dprintk(f, str...) do { if (rio_debug & f) printk (str);} while (0) 189 - #define func_enter() rio_dprintk (RIO_DEBUG_FLOW, "rio: enter %s\n", __FUNCTION__) 190 - #define func_exit() rio_dprintk (RIO_DEBUG_FLOW, "rio: exit %s\n", __FUNCTION__) 191 - #define func_enter2() rio_dprintk (RIO_DEBUG_FLOW, "rio: enter %s (port %d)\n",__FUNCTION__, port->line) 189 + #define func_enter() rio_dprintk (RIO_DEBUG_FLOW, "rio: enter %s\n", __func__) 190 + #define func_exit() rio_dprintk (RIO_DEBUG_FLOW, "rio: exit %s\n", __func__) 191 + #define func_enter2() rio_dprintk (RIO_DEBUG_FLOW, "rio: enter %s (port %d)\n",__func__, port->line) 192 192 #else 193 193 #define rio_dprintk(f, str...) /* nothing */ 194 194 #define func_enter()
+2 -2
drivers/char/riscom8.c
··· 1222 1222 unsigned int result; 1223 1223 unsigned long flags; 1224 1224 1225 - if (rc_paranoia_check(port, tty->name, __FUNCTION__)) 1225 + if (rc_paranoia_check(port, tty->name, __func__)) 1226 1226 return -ENODEV; 1227 1227 1228 1228 bp = port_Board(port); ··· 1250 1250 unsigned long flags; 1251 1251 struct riscom_board *bp; 1252 1252 1253 - if (rc_paranoia_check(port, tty->name, __FUNCTION__)) 1253 + if (rc_paranoia_check(port, tty->name, __func__)) 1254 1254 return -ENODEV; 1255 1255 1256 1256 bp = port_Board(port);
+9 -9
drivers/char/snsc.c
··· 80 80 sd = kzalloc(sizeof (struct subch_data_s), GFP_KERNEL); 81 81 if (sd == NULL) { 82 82 printk("%s: couldn't allocate subchannel data\n", 83 - __FUNCTION__); 83 + __func__); 84 84 return -ENOMEM; 85 85 } 86 86 ··· 90 90 91 91 if (sd->sd_subch < 0) { 92 92 kfree(sd); 93 - printk("%s: couldn't allocate subchannel\n", __FUNCTION__); 93 + printk("%s: couldn't allocate subchannel\n", __func__); 94 94 return -EBUSY; 95 95 } 96 96 ··· 110 110 if (rv) { 111 111 ia64_sn_irtr_close(sd->sd_nasid, sd->sd_subch); 112 112 kfree(sd); 113 - printk("%s: irq request failed (%d)\n", __FUNCTION__, rv); 113 + printk("%s: irq request failed (%d)\n", __func__, rv); 114 114 return -EBUSY; 115 115 } 116 116 ··· 215 215 */ 216 216 if (count < len) { 217 217 pr_debug("%s: only accepting %d of %d bytes\n", 218 - __FUNCTION__, (int) count, len); 218 + __func__, (int) count, len); 219 219 } 220 220 len = min((int) count, len); 221 221 if (copy_to_user(buf, sd->sd_rb, len)) ··· 384 384 if (alloc_chrdev_region(&first_dev, 0, num_cnodes, 385 385 SYSCTL_BASENAME) < 0) { 386 386 printk("%s: failed to register SN system controller device\n", 387 - __FUNCTION__); 387 + __func__); 388 388 return -ENODEV; 389 389 } 390 390 snsc_class = class_create(THIS_MODULE, SYSCTL_BASENAME); ··· 403 403 GFP_KERNEL); 404 404 if (!scd) { 405 405 printk("%s: failed to allocate device info" 406 - "for %s/%s\n", __FUNCTION__, 406 + "for %s/%s\n", __func__, 407 407 SYSCTL_BASENAME, devname); 408 408 continue; 409 409 } ··· 412 412 scd->scd_nasid = cnodeid_to_nasid(cnode); 413 413 if (!(salbuf = kmalloc(SCDRV_BUFSZ, GFP_KERNEL))) { 414 414 printk("%s: failed to allocate driver buffer" 415 - "(%s%s)\n", __FUNCTION__, 415 + "(%s%s)\n", __func__, 416 416 SYSCTL_BASENAME, devname); 417 417 kfree(scd); 418 418 continue; ··· 424 424 ("%s: failed to initialize SAL for" 425 425 " system controller communication" 426 426 " (%s/%s): outdated PROM?\n", 427 - __FUNCTION__, SYSCTL_BASENAME, devname); 427 + __func__, SYSCTL_BASENAME, devname); 428 428 kfree(scd); 429 429 kfree(salbuf); 430 430 continue; ··· 435 435 if (cdev_add(&scd->scd_cdev, dev, 1)) { 436 436 printk("%s: failed to register system" 437 437 " controller device (%s%s)\n", 438 - __FUNCTION__, SYSCTL_BASENAME, devname); 438 + __func__, SYSCTL_BASENAME, devname); 439 439 kfree(scd); 440 440 kfree(salbuf); 441 441 continue;
+3 -3
drivers/char/snsc_event.c
··· 271 271 event_sd = kzalloc(sizeof (struct subch_data_s), GFP_KERNEL); 272 272 if (event_sd == NULL) { 273 273 printk(KERN_WARNING "%s: couldn't allocate subchannel info" 274 - " for event monitoring\n", __FUNCTION__); 274 + " for event monitoring\n", __func__); 275 275 return; 276 276 } 277 277 ··· 285 285 if (event_sd->sd_subch < 0) { 286 286 kfree(event_sd); 287 287 printk(KERN_WARNING "%s: couldn't open event subchannel\n", 288 - __FUNCTION__); 288 + __func__); 289 289 return; 290 290 } 291 291 ··· 295 295 "system controller events", event_sd); 296 296 if (rv) { 297 297 printk(KERN_WARNING "%s: irq request failed (%d)\n", 298 - __FUNCTION__, rv); 298 + __func__, rv); 299 299 ia64_sn_irtr_close(event_sd->sd_nasid, event_sd->sd_subch); 300 300 kfree(event_sd); 301 301 return;
+1 -1
drivers/char/sonypi.c
··· 506 506 while (--n && (command)) \ 507 507 udelay(1); \ 508 508 if (!n && (verbose || !quiet)) \ 509 - printk(KERN_WARNING "sonypi command failed at %s : %s (line %d)\n", __FILE__, __FUNCTION__, __LINE__); \ 509 + printk(KERN_WARNING "sonypi command failed at %s : %s (line %d)\n", __FILE__, __func__, __LINE__); \ 510 510 } 511 511 512 512 #ifdef CONFIG_ACPI
+5 -5
drivers/char/specialix.c
··· 131 131 #define SX_DEBUG_FIFO 0x0800 132 132 133 133 134 - #define func_enter() dprintk (SX_DEBUG_FLOW, "io8: enter %s\n",__FUNCTION__) 135 - #define func_exit() dprintk (SX_DEBUG_FLOW, "io8: exit %s\n", __FUNCTION__) 134 + #define func_enter() dprintk (SX_DEBUG_FLOW, "io8: enter %s\n",__func__) 135 + #define func_exit() dprintk (SX_DEBUG_FLOW, "io8: exit %s\n", __func__) 136 136 137 137 #define jiffies_from_ms(a) ((((a) * HZ)/1000)+1) 138 138 ··· 874 874 875 875 spin_lock_irqsave(&bp->lock, flags); 876 876 877 - dprintk (SX_DEBUG_FLOW, "enter %s port %d room: %ld\n", __FUNCTION__, port_No(sx_get_port(bp, "INT")), SERIAL_XMIT_SIZE - sx_get_port(bp, "ITN")->xmit_cnt - 1); 877 + dprintk (SX_DEBUG_FLOW, "enter %s port %d room: %ld\n", __func__, port_No(sx_get_port(bp, "INT")), SERIAL_XMIT_SIZE - sx_get_port(bp, "ITN")->xmit_cnt - 1); 878 878 if (!(bp->flags & SX_BOARD_ACTIVE)) { 879 879 dprintk (SX_DEBUG_IRQ, "sx: False interrupt. irq %d.\n", bp->irq); 880 880 spin_unlock_irqrestore(&bp->lock, flags); ··· 1802 1802 1803 1803 func_enter(); 1804 1804 1805 - if (sx_paranoia_check(port, tty->name, __FUNCTION__)) { 1805 + if (sx_paranoia_check(port, tty->name, __func__)) { 1806 1806 func_exit(); 1807 1807 return -ENODEV; 1808 1808 } ··· 1844 1844 1845 1845 func_enter(); 1846 1846 1847 - if (sx_paranoia_check(port, tty->name, __FUNCTION__)) { 1847 + if (sx_paranoia_check(port, tty->name, __func__)) { 1848 1848 func_exit(); 1849 1849 return -ENODEV; 1850 1850 }
+4 -4
drivers/char/sx.c
··· 384 384 #define sx_dprintk(f, str...) /* nothing */ 385 385 #endif 386 386 387 - #define func_enter() sx_dprintk(SX_DEBUG_FLOW, "sx: enter %s\n",__FUNCTION__) 388 - #define func_exit() sx_dprintk(SX_DEBUG_FLOW, "sx: exit %s\n",__FUNCTION__) 387 + #define func_enter() sx_dprintk(SX_DEBUG_FLOW, "sx: enter %s\n",__func__) 388 + #define func_exit() sx_dprintk(SX_DEBUG_FLOW, "sx: exit %s\n",__func__) 389 389 390 390 #define func_enter2() sx_dprintk(SX_DEBUG_FLOW, "sx: enter %s (port %d)\n", \ 391 - __FUNCTION__, port->line) 391 + __func__, port->line) 392 392 393 393 /* 394 394 * Firmware loader driver specific routines ··· 1574 1574 sx_dprintk(SX_DEBUG_CLOSE, "WARNING port count:%d\n", 1575 1575 port->gs.count); 1576 1576 /*printk("%s SETTING port count to zero: %p count: %d\n", 1577 - __FUNCTION__, port, port->gs.count); 1577 + __func__, port, port->gs.count); 1578 1578 port->gs.count = 0;*/ 1579 1579 } 1580 1580