if (wait_event_timeout(gsr_wq, (GSR | gsr_bits) & GSR_SDONE, 1) <= 0 &&
            !((GSR | gsr_bits) & GSR_SDONE)) {
                printk(KERN_ERR "%s: read error (ac97_reg=%d GSR=%#lx)\n",
-                               __FUNCTION__, reg, GSR | gsr_bits);
+                               __func__, reg, GSR | gsr_bits);
                val = -1;
                goto out;
        }
        if (wait_event_timeout(gsr_wq, (GSR | gsr_bits) & GSR_CDONE, 1) <= 0 &&
            !((GSR | gsr_bits) & GSR_CDONE))
                printk(KERN_ERR "%s: write error (ac97_reg=%d GSR=%#lx)\n",
-                               __FUNCTION__, reg, GSR | gsr_bits);
+                               __func__, reg, GSR | gsr_bits);
 
        mutex_unlock(&car_mutex);
 }
 
        if (!((GSR | gsr_bits) & (GSR_PCR | GSR_SCR))) {
                printk(KERN_INFO "%s: cold reset timeout (GSR=%#lx)\n",
-                                __FUNCTION__, gsr_bits);
+                                __func__, gsr_bits);
 
                /* let's try warm reset */
                gsr_bits = 0;
 
                if (!((GSR | gsr_bits) & (GSR_PCR | GSR_SCR)))
                        printk(KERN_INFO "%s: warm reset timeout (GSR=%#lx)\n",
-                                        __FUNCTION__, gsr_bits);
+                                        __func__, gsr_bits);
        }
 
        GCR &= ~(GCR_PRIRDY_IEN|GCR_SECRDY_IEN);
 
        if (likely(df))
                return df->disconnected_f_op->release(inode, file);
 
-       panic("%s(%p, %p) failed!", __FUNCTION__, inode, file);
+       panic("%s(%p, %p) failed!", __func__, inode, file);
 }
 
 static unsigned int snd_disconnect_poll(struct file * file, poll_table * wait)
 
                return -EFAULT;
        if ((file_h.name != RIFF_HEADER) ||
            (le32_to_cpu(file_h.len) >= SNDRV_SB_CSP_MAX_MICROCODE_FILE_SIZE - sizeof(file_h))) {
-               snd_printd("%s: Invalid RIFF header\n", __FUNCTION__);
+               snd_printd("%s: Invalid RIFF header\n", __func__);
                return -EINVAL;
        }
        data_ptr += sizeof(file_h);
        if (copy_from_user(&item_type, data_ptr, sizeof(item_type)))
                return -EFAULT;
        if (item_type != CSP__HEADER) {
-               snd_printd("%s: Invalid RIFF file type\n", __FUNCTION__);
+               snd_printd("%s: Invalid RIFF file type\n", __func__);
                return -EINVAL;
        }
        data_ptr += sizeof (item_type);
                                return -EFAULT;
 
                        if (code_h.name != MAIN_HEADER) {
-                               snd_printd("%s: Missing 'main' microcode\n", __FUNCTION__);
+                               snd_printd("%s: Missing 'main' microcode\n", __func__);
                                return -EINVAL;
                        }
                        data_ptr += sizeof(code_h);
                                p->acc_format = p->acc_width = p->acc_rates = 0;
                                p->mode = 0;
                                snd_printd("%s: Unsupported CSP codec type: 0x%04x\n",
-                                          __FUNCTION__,
+                                          __func__,
                                           le16_to_cpu(funcdesc_h.VOC_type));
                                return -EINVAL;
                        }
                        return 0;
                }
        }
-       snd_printd("%s: Function #%d not found\n", __FUNCTION__, info.func_req);
+       snd_printd("%s: Function #%d not found\n", __func__, info.func_req);
        return -EINVAL;
 }
 
 static int snd_sb_csp_check_version(struct snd_sb_csp * p)
 {
        if (p->version < 0x10 || p->version > 0x1f) {
-               snd_printd("%s: Invalid CSP version: 0x%x\n", __FUNCTION__, p->version);
+               snd_printd("%s: Invalid CSP version: 0x%x\n", __func__, p->version);
                return 1;
        }
        return 0;
        spin_lock_irqsave(&p->chip->reg_lock, flags);
        snd_sbdsp_command(p->chip, 0x01);       /* CSP download command */
        if (snd_sbdsp_get_byte(p->chip)) {
-               snd_printd("%s: Download command failed\n", __FUNCTION__);
+               snd_printd("%s: Download command failed\n", __func__);
                goto __fail;
        }
        /* Send CSP low byte (size - 1) */
                        udelay (10);
                }
                if (status != 0x55) {
-                       snd_printd("%s: Microcode initialization failed\n", __FUNCTION__);
+                       snd_printd("%s: Microcode initialization failed\n", __func__);
                        goto __fail;
                }
        } else {
        unsigned long flags;
 
        if (!(p->running & (SNDRV_SB_CSP_ST_LOADED | SNDRV_SB_CSP_ST_AUTO))) {
-               snd_printd("%s: Microcode not loaded\n", __FUNCTION__);
+               snd_printd("%s: Microcode not loaded\n", __func__);
                return -ENXIO;
        }
        if (p->running & SNDRV_SB_CSP_ST_RUNNING) {
-               snd_printd("%s: CSP already running\n", __FUNCTION__);
+               snd_printd("%s: CSP already running\n", __func__);
                return -EBUSY;
        }
        if (!(sample_width & p->acc_width)) {
-               snd_printd("%s: Unsupported PCM sample width\n", __FUNCTION__);
+               snd_printd("%s: Unsupported PCM sample width\n", __func__);
                return -EINVAL;
        }
        if (!(channels & p->acc_channels)) {
-               snd_printd("%s: Invalid number of channels\n", __FUNCTION__);
+               snd_printd("%s: Invalid number of channels\n", __func__);
                return -EINVAL;
        }
 
                s_type |= 0x22; /* 00dX 00dX    (d = 1 if 8 bit samples) */
 
        if (set_codec_parameter(p->chip, 0x81, s_type)) {
-               snd_printd("%s: Set sample type command failed\n", __FUNCTION__);
+               snd_printd("%s: Set sample type command failed\n", __func__);
                goto __fail;
        }
        if (set_codec_parameter(p->chip, 0x80, 0x00)) {
-               snd_printd("%s: Codec start command failed\n", __FUNCTION__);
+               snd_printd("%s: Codec start command failed\n", __func__);
                goto __fail;
        }
        p->run_width = sample_width;
 
                        outb(val, SBP(chip, COMMAND));
                        return 1;
                }
-       snd_printd("%s [0x%lx]: timeout (0x%x)\n", __FUNCTION__, chip->port, val);
+       snd_printd("%s [0x%lx]: timeout (0x%x)\n", __func__, chip->port, val);
        return 0;
 }
 
                        return val;
                }
        }
-       snd_printd("%s [0x%lx]: timeout\n", __FUNCTION__, chip->port);
+       snd_printd("%s [0x%lx]: timeout\n", __func__, chip->port);
        return -ENODEV;
 }
 
                        else
                                break;
                }
-       snd_printdd("%s [0x%lx] failed...\n", __FUNCTION__, chip->port);
+       snd_printdd("%s [0x%lx] failed...\n", __func__, chip->port);
        return -ENODEV;
 }
 
 
 #define VALIDATE_MAGIC(FOO,MAG)                                \
 ({                                                     \
        if (!(FOO) || (FOO)->magic != MAG) {            \
-               printk(invalid_magic,__FUNCTION__);     \
+               printk(invalid_magic,__func__); \
                return -ENXIO;                          \
        }                                               \
 })
 
  *     DBGRV   - debug print function return when verbose
  */
 
-#define ASSERT(e)      ((e) ? (void) 0 : dbgassert(__FUNCTION__, __LINE__, #e))
+#define ASSERT(e)      ((e) ? (void) 0 : dbgassert(__func__, __LINE__, #e))
 #define DBGDO(x)            x
 #define DBGX(fmt, args...)  (in_interrupt() ? 0 : printk(KERN_ERR fmt, ##args))
-#define DBGP(fmt, args...)  (DBGX("%s: " fmt, __FUNCTION__ , ##args))
-#define DBGE(fmt, args...)  (DBGX("%s" fmt, __FUNCTION__ , ##args))
+#define DBGP(fmt, args...)  (DBGX("%s: " fmt, __func__ , ##args))
+#define DBGE(fmt, args...)  (DBGX("%s" fmt, __func__ , ##args))
 #define DBGC(rtn)           (DBGP("calling %s\n", rtn))
 #define DBGR()              (DBGP("returning\n"))
 #define DBGXV(fmt, args...) (shut_up ? 0 : DBGX(fmt, ##args))
 
                mdelay(1);
        if (!retry) {
                snd_printk(KERN_ERR PFX "[%s] Link is not ready.\n",
-                      __FUNCTION__);
+                      __func__);
                return -EIO;
        }
-       ad1889_debug("[%s] ready after %d ms\n", __FUNCTION__, 400 - retry);
+       ad1889_debug("[%s] ready after %d ms\n", __func__, 400 - retry);
 
        return 0;
 }
 
 
 #if DEBUG_CALLS
 #define snd_als300_dbgcalls(format, args...) printk(format, ##args)
-#define snd_als300_dbgcallenter() printk(KERN_ERR "--> %s\n", __FUNCTION__)
-#define snd_als300_dbgcallleave() printk(KERN_ERR "<-- %s\n", __FUNCTION__)
+#define snd_als300_dbgcallenter() printk(KERN_ERR "--> %s\n", __func__)
+#define snd_als300_dbgcallleave() printk(KERN_ERR "<-- %s\n", __func__)
 #else
 #define snd_als300_dbgcalls(format, args...)
 #define snd_als300_dbgcallenter()
 
 
 #if DEBUG_CALLS
 #define snd_azf3328_dbgcalls(format, args...) printk(format, ##args)
-#define snd_azf3328_dbgcallenter() printk(KERN_ERR "--> %s\n", __FUNCTION__)
-#define snd_azf3328_dbgcallleave() printk(KERN_ERR "<-- %s\n", __FUNCTION__)
+#define snd_azf3328_dbgcallenter() printk(KERN_ERR "--> %s\n", __func__)
+#define snd_azf3328_dbgcallleave() printk(KERN_ERR "<-- %s\n", __func__)
 #else
 #define snd_azf3328_dbgcalls(format, args...)
 #define snd_azf3328_dbgcallenter()
 
        t = stop_time.tv_sec - start_time.tv_sec;
        t *= 1000000;
        t += stop_time.tv_usec - start_time.tv_usec;
-       printk(KERN_INFO "%s: measured %lu usecs\n", __FUNCTION__, t);
+       printk(KERN_INFO "%s: measured %lu usecs\n", __func__, t);
        if (t == 0) {
                snd_printk(KERN_ERR "?? calculation error..\n");
                return;
 
        wait_event_timeout(gsr_wq, (GSR | gsr_bits) & GSR_SDONE, 1);
        if (!((GSR | gsr_bits) & GSR_SDONE)) {
                printk(KERN_ERR "%s: read error (ac97_reg=%x GSR=%#lx)\n",
-                               __FUNCTION__, reg, GSR | gsr_bits);
+                               __func__, reg, GSR | gsr_bits);
                val = -1;
                goto out;
        }
        wait_event_timeout(gsr_wq, (GSR | gsr_bits) & GSR_CDONE, 1);
        if (!((GSR | gsr_bits) & GSR_CDONE))
                printk(KERN_ERR "%s: write error (ac97_reg=%x GSR=%#lx)\n",
-                               __FUNCTION__, reg, GSR | gsr_bits);
+                               __func__, reg, GSR | gsr_bits);
 
        mutex_unlock(&car_mutex);
 }
 
        if (!((GSR | gsr_bits) & (GSR_PCR | GSR_SCR)))
                printk(KERN_INFO "%s: warm reset timeout (GSR=%#lx)\n",
-                                __FUNCTION__, gsr_bits);
+                                __func__, gsr_bits);
 
        GCR &= ~(GCR_PRIRDY_IEN|GCR_SECRDY_IEN);
        GCR |= GCR_SDONE_IE|GCR_CDONE_IE;
 
        if (!((GSR | gsr_bits) & (GSR_PCR | GSR_SCR)))
                printk(KERN_INFO "%s: cold reset timeout (GSR=%#lx)\n",
-                                __FUNCTION__, gsr_bits);
+                                __func__, gsr_bits);
 
        GCR &= ~(GCR_PRIRDY_IEN|GCR_SECRDY_IEN);
        GCR |= GCR_SDONE_IE|GCR_CDONE_IE;
 
        u32 iiscon;
        u32 iismod;
 
-       DBG("Entered %s\n", __FUNCTION__);
+       DBG("Entered %s\n", __func__);
 
        iisfcon = readl(s3c24xx_i2s.regs + S3C2410_IISFCON);
        iiscon  = readl(s3c24xx_i2s.regs + S3C2410_IISCON);
        u32 iiscon;
        u32 iismod;
 
-       DBG("Entered %s\n", __FUNCTION__);
+       DBG("Entered %s\n", __func__);
 
        iisfcon = readl(s3c24xx_i2s.regs + S3C2410_IISFCON);
        iiscon  = readl(s3c24xx_i2s.regs + S3C2410_IISCON);
        u32 iiscon;
        unsigned long timeout = jiffies + msecs_to_jiffies(5);
 
-       DBG("Entered %s\n", __FUNCTION__);
+       DBG("Entered %s\n", __func__);
 
        while (1) {
                iiscon = readl(s3c24xx_i2s.regs + S3C2410_IISCON);
  */
 static inline int s3c24xx_snd_is_clkmaster(void)
 {
-       DBG("Entered %s\n", __FUNCTION__);
+       DBG("Entered %s\n", __func__);
 
        return (readl(s3c24xx_i2s.regs + S3C2410_IISMOD) & S3C2410_IISMOD_SLAVE) ? 0:1;
 }
 {
        u32 iismod;
 
-       DBG("Entered %s\n", __FUNCTION__);
+       DBG("Entered %s\n", __func__);
 
        iismod = readl(s3c24xx_i2s.regs + S3C2410_IISMOD);
        DBG("hw_params r: IISMOD: %lx \n", iismod);
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
        u32 iismod;
 
-       DBG("Entered %s\n", __FUNCTION__);
+       DBG("Entered %s\n", __func__);
 
        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
                rtd->dai->cpu_dai->dma_data = &s3c24xx_i2s_pcm_stereo_out;
 {
        int ret = 0;
 
-       DBG("Entered %s\n", __FUNCTION__);
+       DBG("Entered %s\n", __func__);
 
        switch (cmd) {
        case SNDRV_PCM_TRIGGER_START:
 {
        u32 iismod = readl(s3c24xx_i2s.regs + S3C2410_IISMOD);
 
-       DBG("Entered %s\n", __FUNCTION__);
+       DBG("Entered %s\n", __func__);
 
        iismod &= ~S3C2440_IISMOD_MPLL;
 
 {
        u32 reg;
 
-       DBG("Entered %s\n", __FUNCTION__);
+       DBG("Entered %s\n", __func__);
 
        switch (div_id) {
        case S3C24XX_DIV_BCLK:
 
 static int s3c24xx_i2s_probe(struct platform_device *pdev)
 {
-       DBG("Entered %s\n", __FUNCTION__);
+       DBG("Entered %s\n", __func__);
 
        s3c24xx_i2s.regs = ioremap(S3C2410_PA_IIS, 0x100);
        if (s3c24xx_i2s.regs == NULL)
 
        dma_addr_t pos = prtd->dma_pos;
        int ret;
 
-       DBG("Entered %s\n", __FUNCTION__);
+       DBG("Entered %s\n", __func__);
 
        while (prtd->dma_loaded < prtd->dma_limit) {
                unsigned long len = prtd->dma_period;
                if ((pos + len) > prtd->dma_end) {
                        len  = prtd->dma_end - pos;
                        DBG(KERN_DEBUG "%s: corrected dma len %ld\n",
-                              __FUNCTION__, len);
+                              __func__, len);
                }
 
                ret = s3c2410_dma_enqueue(prtd->params->channel, 
        struct snd_pcm_substream *substream = dev_id;
        struct s3c24xx_runtime_data *prtd;
 
-       DBG("Entered %s\n", __FUNCTION__);
+       DBG("Entered %s\n", __func__);
 
        if (result == S3C2410_RES_ABORT || result == S3C2410_RES_ERR)
                return;
        unsigned long totbytes = params_buffer_bytes(params);
        int ret=0;
 
-       DBG("Entered %s\n", __FUNCTION__);
+       DBG("Entered %s\n", __func__);
 
        /* return if this is a bufferless transfer e.g.
         * codec <--> BT codec or GSM modem -- lg FIXME */
 {
        struct s3c24xx_runtime_data *prtd = substream->runtime->private_data;
 
-       DBG("Entered %s\n", __FUNCTION__);
+       DBG("Entered %s\n", __func__);
 
        /* TODO - do we need to ensure DMA flushed */
        snd_pcm_set_runtime_buffer(substream, NULL);
        struct s3c24xx_runtime_data *prtd = substream->runtime->private_data;
        int ret = 0;
 
-       DBG("Entered %s\n", __FUNCTION__);
+       DBG("Entered %s\n", __func__);
 
        /* return if this is a bufferless transfer e.g.
         * codec <--> BT codec or GSM modem -- lg FIXME */
        struct s3c24xx_runtime_data *prtd = substream->runtime->private_data;
        int ret = 0;
 
-       DBG("Entered %s\n", __FUNCTION__);
+       DBG("Entered %s\n", __func__);
 
        spin_lock(&prtd->lock);
 
        unsigned long res;
        dma_addr_t src, dst;
 
-       DBG("Entered %s\n", __FUNCTION__);
+       DBG("Entered %s\n", __func__);
 
        spin_lock(&prtd->lock);
        s3c2410_dma_getposition(prtd->params->channel, &src, &dst);
        struct snd_pcm_runtime *runtime = substream->runtime;
        struct s3c24xx_runtime_data *prtd;
 
-       DBG("Entered %s\n", __FUNCTION__);
+       DBG("Entered %s\n", __func__);
 
        snd_soc_set_runtime_hwparams(substream, &s3c24xx_pcm_hardware);
 
        struct snd_pcm_runtime *runtime = substream->runtime;
        struct s3c24xx_runtime_data *prtd = runtime->private_data;
 
-       DBG("Entered %s\n", __FUNCTION__);
+       DBG("Entered %s\n", __func__);
 
        if (prtd)
                kfree(prtd);
 {
        struct snd_pcm_runtime *runtime = substream->runtime;
 
-       DBG("Entered %s\n", __FUNCTION__);
+       DBG("Entered %s\n", __func__);
 
        return dma_mmap_writecombine(substream->pcm->card->dev, vma,
                                      runtime->dma_area,
        struct snd_dma_buffer *buf = &substream->dma_buffer;
        size_t size = s3c24xx_pcm_hardware.buffer_bytes_max;
 
-       DBG("Entered %s\n", __FUNCTION__);
+       DBG("Entered %s\n", __func__);
 
        buf->dev.type = SNDRV_DMA_TYPE_DEV;
        buf->dev.dev = pcm->card->dev;
        struct snd_dma_buffer *buf;
        int stream;
 
-       DBG("Entered %s\n", __FUNCTION__);
+       DBG("Entered %s\n", __func__);
 
        for (stream = 0; stream < 2; stream++) {
                substream = pcm->streams[stream].substream;
 {
        int ret = 0;
 
-       DBG("Entered %s\n", __FUNCTION__);
+       DBG("Entered %s\n", __func__);
 
        if (!card->dev->dma_mask)
                card->dev->dma_mask = &s3c24xx_pcm_dmamask;
 
        mutex_unlock(&codec->mutex);
 
        dapm_power_widgets(codec, event);
-       dump_dapm(codec, __FUNCTION__);
+       dump_dapm(codec, __func__);
        return 0;
 }
 EXPORT_SYMBOL_GPL(snd_soc_dapm_stream_event);