tm->tm_yday = rtc_year_days(tm->tm_mday, tm->tm_mon, tm->tm_year);
        tm->tm_year = tm->tm_year - 1900;
 
-       pr_debug("%s(): %4d-%02d-%02d %02d:%02d:%02d\n", __FUNCTION__,
+       pr_debug("%s(): %4d-%02d-%02d %02d:%02d:%02d\n", __func__,
                1900 + tm->tm_year, tm->tm_mon, tm->tm_mday,
                tm->tm_hour, tm->tm_min, tm->tm_sec);
 
 {
        unsigned long cr;
 
-       pr_debug("%s(): %4d-%02d-%02d %02d:%02d:%02d\n", __FUNCTION__,
+       pr_debug("%s(): %4d-%02d-%02d %02d:%02d:%02d\n", __func__,
                1900 + tm->tm_year, tm->tm_mon, tm->tm_mday,
                tm->tm_hour, tm->tm_min, tm->tm_sec);
 
        alrm->enabled = (at91_sys_read(AT91_RTC_IMR) & AT91_RTC_ALARM)
                        ? 1 : 0;
 
-       pr_debug("%s(): %4d-%02d-%02d %02d:%02d:%02d\n", __FUNCTION__,
+       pr_debug("%s(): %4d-%02d-%02d %02d:%02d:%02d\n", __func__,
                1900 + tm->tm_year, tm->tm_mon, tm->tm_mday,
                tm->tm_hour, tm->tm_min, tm->tm_sec);
 
        if (alrm->enabled)
                at91_sys_write(AT91_RTC_IER, AT91_RTC_ALARM);
 
-       pr_debug("%s(): %4d-%02d-%02d %02d:%02d:%02d\n", __FUNCTION__,
+       pr_debug("%s(): %4d-%02d-%02d %02d:%02d:%02d\n", __func__,
                at91_alarm_year, tm.tm_mon, tm.tm_mday, tm.tm_hour,
                tm.tm_min, tm.tm_sec);
 
 {
        int ret = 0;
 
-       pr_debug("%s(): cmd=%08x, arg=%08lx.\n", __FUNCTION__, cmd, arg);
+       pr_debug("%s(): cmd=%08x, arg=%08lx.\n", __func__, cmd, arg);
 
        switch (cmd) {
        case RTC_AIE_OFF:       /* alarm off */
 
                rtc_update_irq(rtc, 1, events);
 
-               pr_debug("%s(): num=%ld, events=0x%02lx\n", __FUNCTION__,
+               pr_debug("%s(): num=%ld, events=0x%02lx\n", __func__,
                        events >> 8, events & 0x000000FF);
 
                return IRQ_HANDLED;
 
 
        rtc_update_irq(rtc->rtcdev, 1, events);
 
-       pr_debug("%s: num=%ld, events=0x%02lx\n", __FUNCTION__,
+       pr_debug("%s: num=%ld, events=0x%02lx\n", __func__,
                events >> 8, events & 0x000000FF);
 
        return IRQ_HANDLED;
 
 
        dev_dbg(dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
                "mday=%d, mon=%d, year=%d, wday=%d\n",
-               __FUNCTION__,
+               __func__,
                tm->tm_sec, tm->tm_min, tm->tm_hour,
                tm->tm_mday, tm->tm_mon + 1, tm->tm_year, tm->tm_wday);
 
 
 
        /* read date registers */
        if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) {
-               dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
+               dev_err(&client->dev, "%s: read error\n", __func__);
                return -EIO;
        }
 
        dev_dbg(&client->dev,
                "%s: raw read data - counters=%02x,%02x,%02x,%02x\n",
-               __FUNCTION__, buf[0], buf[1], buf[2], buf[3]);
+               __func__, buf[0], buf[1], buf[2], buf[3]);
 
        time = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
 
 
        dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
                "mday=%d, mon=%d, year=%d, wday=%d\n",
-               __FUNCTION__, tm->tm_sec, tm->tm_min, tm->tm_hour,
+               __func__, tm->tm_sec, tm->tm_min, tm->tm_hour,
                tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
 
        return 0;
 
        xfer = i2c_master_send(client, buf, 6);
        if (xfer != 6) {
-               dev_err(&client->dev, "%s: send: %d\n", __FUNCTION__, xfer);
+               dev_err(&client->dev, "%s: send: %d\n", __func__, xfer);
                return -EIO;
        }
 
        dev_dbg(&client->dev,
                "%s: secs=%d, mins=%d, hours=%d, "
                "mday=%d, mon=%d, year=%d, wday=%d\n",
-               __FUNCTION__,
+               __func__,
                tm->tm_sec, tm->tm_min, tm->tm_hour,
                tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
 
 
        /* read control register */
        if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) {
-               dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
+               dev_err(&client->dev, "%s: read error\n", __func__);
                return -EIO;
        }
 
        struct i2c_client *client;
        struct rtc_device *rtc;
 
-       dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
+       dev_dbg(&adapter->dev, "%s\n", __func__);
 
        if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
                err = -ENODEV;
 
        rc = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
        if (rc != ARRAY_SIZE(msgs)) {
                dev_err(&client->dev, "%s: register read failed\n",
-                       __FUNCTION__);
+                       __func__);
                return -EIO;
        }
        return 0;
 
 write_failed:
        dev_err(&client->dev, "%s: register write failed\n",
-               __FUNCTION__);
+               __func__);
        return -EIO;
 }
 
        rc = i2c_smbus_write_byte_data (client, MAX6900_REG_CONTROL_WRITE, 0);
        if (rc < 0) {
                dev_err(&client->dev, "%s: control register write failed\n",
-                       __FUNCTION__);
+                       __func__);
                return -EIO;
        }
        return 0;
 
        dt->tm_year -= 1900;
 
 #ifdef MAX6902_DEBUG
-       printk("\n%s : Read RTC values\n",__FUNCTION__);
+       printk("\n%s : Read RTC values\n",__func__);
        printk("tm_hour: %i\n",dt->tm_hour);
        printk("tm_min : %i\n",dt->tm_min);
        printk("tm_sec : %i\n",dt->tm_sec);
        dt->tm_year = dt->tm_year+1900;
 
 #ifdef MAX6902_DEBUG
-       printk("\n%s : Setting RTC values\n",__FUNCTION__);
+       printk("\n%s : Setting RTC values\n",__func__);
        printk("tm_sec : %i\n",dt->tm_sec);
        printk("tm_min : %i\n",dt->tm_min);
        printk("tm_hour: %i\n",dt->tm_hour);
 
 
        /* read registers */
        if ((i2c_transfer(client->adapter, msgs, 2)) != 2) {
-               dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
+               dev_err(&client->dev, "%s: read error\n", __func__);
                return -EIO;
        }
 
        dev_dbg(&client->dev,
                "%s: raw data is st1=%02x, st2=%02x, sec=%02x, min=%02x, hr=%02x, "
                "mday=%02x, wday=%02x, mon=%02x, year=%02x\n",
-               __FUNCTION__,
+               __func__,
                buf[0], buf[1], buf[2], buf[3],
                buf[4], buf[5], buf[6], buf[7],
                buf[8]);
 
        dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
                "mday=%d, mon=%d, year=%d, wday=%d\n",
-               __FUNCTION__,
+               __func__,
                tm->tm_sec, tm->tm_min, tm->tm_hour,
                tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
 
 
        dev_dbg(&client->dev, "%s: secs=%d, mins=%d, hours=%d, "
                "mday=%d, mon=%d, year=%d, wday=%d\n",
-               __FUNCTION__,
+               __func__,
                tm->tm_sec, tm->tm_min, tm->tm_hour,
                tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
 
                if (err != sizeof(data)) {
                        dev_err(&client->dev,
                                "%s: err=%d addr=%02x, data=%02x\n",
-                               __FUNCTION__, err, data[0], data[1]);
+                               __func__, err, data[0], data[1]);
                        return -EIO;
                }
        };
                if (xfer != ARRAY_SIZE(msgs)) {
                        dev_err(&client->dev,
                                "%s: could not read register 0x%02X\n",
-                               __FUNCTION__, pattern[i].reg);
+                               __func__, pattern[i].reg);
 
                        return -EIO;
                }
                        dev_dbg(&client->dev,
                                "%s: pattern=%d, reg=%x, mask=0x%02x, min=%d, "
                                "max=%d, value=%d, raw=0x%02X\n",
-                               __FUNCTION__, i, pattern[i].reg, pattern[i].mask,
+                               __func__, i, pattern[i].reg, pattern[i].mask,
                                pattern[i].min, pattern[i].max,
                                value, buf);
 
 
                ndelay(700);    /* CE:L */
 
                if (cnt++ > 100) {
-                       dev_err(dev, "%s: timeout error\n", __FUNCTION__);
+                       dev_err(dev, "%s: timeout error\n", __func__);
                        return -EIO;
                }
        }
                ndelay(700);    /* CE:L */
 
                if (cnt++ > 100) {
-                       dev_err(dev, "%s: timeout error\n", __FUNCTION__);
+                       dev_err(dev, "%s: timeout error\n", __func__);
                        return -EIO;
                }
        }
 
 
        dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
                "mday=%d, mon=%d, year=%d, wday=%d\n",
-               __FUNCTION__,
+               __func__,
                tm->tm_sec, tm->tm_min, tm->tm_hour,
                tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
 
 
        dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d "
                "mday=%d, mon=%d, year=%d, wday=%d\n",
-               __FUNCTION__,
+               __func__,
                tm->tm_sec, tm->tm_min, tm->tm_hour,
                tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
 
        buf[7] = BIN2BCD(tm->tm_year - 100);
 
        if ((i2c_master_send(client, buf, 8)) != 8) {
-               dev_err(&client->dev, "%s: write error\n", __FUNCTION__);
+               dev_err(&client->dev, "%s: write error\n", __func__);
                return -EIO;
        }
 
                *osc = (tmp & RS5C372_TRIM_XSL) ? 32000 : 32768;
 
        if (trim) {
-               dev_dbg(&client->dev, "%s: raw trim=%x\n", __FUNCTION__, tmp);
+               dev_dbg(&client->dev, "%s: raw trim=%x\n", __func__, tmp);
                tmp &= RS5C372_TRIM_MASK;
                if (tmp & 0x3e) {
                        int t = tmp & 0x3f;
        struct rs5c372 *rs5c372;
        struct rtc_time tm;
 
-       dev_dbg(&client->dev, "%s\n", __FUNCTION__);
+       dev_dbg(&client->dev, "%s\n", __func__);
 
        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
                err = -ENODEV;
 
 {
        unsigned int tmp;
 
-       pr_debug("%s: aie=%d\n", __FUNCTION__, to);
+       pr_debug("%s: aie=%d\n", __func__, to);
 
        tmp = readb(s3c_rtc_base + S3C2410_RTCALM) & ~S3C2410_RTCALM_ALMEN;
 
 {
        unsigned int tmp;
 
-       pr_debug("%s: pie=%d\n", __FUNCTION__, to);
+       pr_debug("%s: pie=%d\n", __func__, to);
 
        spin_lock_irq(&s3c_rtc_pie_lock);
        tmp = readb(s3c_rtc_base + S3C2410_TICNT) & ~S3C2410_TICNT_ENABLE;
        struct resource *res;
        int ret;
 
-       pr_debug("%s: probe=%p\n", __FUNCTION__, pdev);
+       pr_debug("%s: probe=%p\n", __func__, pdev);
 
        /* find the IRQs */
 
 
 
        dev_dbg(dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
                "mday=%d, mon=%d, year=%d, wday=%d\n",
-               __FUNCTION__,
+               __func__,
                tm->tm_sec, tm->tm_min, tm->tm_hour,
                tm->tm_mday, tm->tm_mon + 1, tm->tm_year, tm->tm_wday);
 
 
        dt->tm_year = BCD2BIN(tmp)+100;
 
 #ifdef DEBUG
-       printk("\n%s : Read RTC values\n",__FUNCTION__);
+       printk("\n%s : Read RTC values\n",__func__);
        printk("tm_hour: %i\n",dt->tm_hour);
        printk("tm_min : %i\n",dt->tm_min);
        printk("tm_sec : %i\n",dt->tm_sec);
        struct v3020 *chip = dev_get_drvdata(dev);
 
 #ifdef DEBUG
-       printk("\n%s : Setting RTC values\n",__FUNCTION__);
+       printk("\n%s : Setting RTC values\n",__func__);
        printk("tm_sec : %i\n",dt->tm_sec);
        printk("tm_min : %i\n",dt->tm_min);
        printk("tm_hour: %i\n",dt->tm_hour);
 
 
        /* read date registers */
        if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) {
-               dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
+               dev_err(&client->dev, "%s: read error\n", __func__);
                return -EIO;
        }
 
        dev_dbg(&client->dev,
                "%s: raw read data - sec=%02x, min=%02x, hr=%02x, "
                "mday=%02x, mon=%02x, year=%02x, wday=%02x, y2k=%02x\n",
-               __FUNCTION__,
+               __func__,
                buf[0], buf[1], buf[2], buf[3],
                buf[4], buf[5], buf[6], buf[7]);
 
 
        dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
                "mday=%d, mon=%d, year=%d, wday=%d\n",
-               __FUNCTION__,
+               __func__,
                tm->tm_sec, tm->tm_min, tm->tm_hour,
                tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
 
 
        /* read status register */
        if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) {
-               dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
+               dev_err(&client->dev, "%s: read error\n", __func__);
                return -EIO;
        }
 
 
        dev_dbg(&client->dev,
                "%s: secs=%d, mins=%d, hours=%d\n",
-               __FUNCTION__,
+               __func__,
                tm->tm_sec, tm->tm_min, tm->tm_hour);
 
        buf[CCR_SEC] = BIN2BCD(tm->tm_sec);
        if (datetoo) {
                dev_dbg(&client->dev,
                        "%s: mday=%d, mon=%d, year=%d, wday=%d\n",
-                       __FUNCTION__,
+                       __func__,
                        tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
 
                buf[CCR_MDAY] = BIN2BCD(tm->tm_mday);
 
        /* this sequence is required to unlock the chip */
        if ((xfer = i2c_master_send(client, wel, 3)) != 3) {
-               dev_err(&client->dev, "%s: wel - %d\n", __FUNCTION__, xfer);
+               dev_err(&client->dev, "%s: wel - %d\n", __func__, xfer);
                return -EIO;
        }
 
        if ((xfer = i2c_master_send(client, rwel, 3)) != 3) {
-               dev_err(&client->dev, "%s: rwel - %d\n", __FUNCTION__, xfer);
+               dev_err(&client->dev, "%s: rwel - %d\n", __func__, xfer);
                return -EIO;
        }
 
                if (xfer != 3) {
                        dev_err(&client->dev,
                                "%s: xfer=%d addr=%02x, data=%02x\n",
-                               __FUNCTION__,
+                               __func__,
                                 xfer, rdata[1], rdata[2]);
                        return -EIO;
                }
 
        /* disable further writes */
        if ((xfer = i2c_master_send(client, diswe, 3)) != 3) {
-               dev_err(&client->dev, "%s: diswe - %d\n", __FUNCTION__, xfer);
+               dev_err(&client->dev, "%s: diswe - %d\n", __func__, xfer);
                return -EIO;
        }
 
 
        /* read dtr register */
        if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) {
-               dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
+               dev_err(&client->dev, "%s: read error\n", __func__);
                return -EIO;
        }
 
-       dev_dbg(&client->dev, "%s: raw dtr=%x\n", __FUNCTION__, dtr);
+       dev_dbg(&client->dev, "%s: raw dtr=%x\n", __func__, dtr);
 
        *trim = 0;
 
 
        /* read atr register */
        if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) {
-               dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
+               dev_err(&client->dev, "%s: read error\n", __func__);
                return -EIO;
        }
 
-       dev_dbg(&client->dev, "%s: raw atr=%x\n", __FUNCTION__, atr);
+       dev_dbg(&client->dev, "%s: raw atr=%x\n", __func__, atr);
 
        /* atr is a two's complement value on 6 bits,
         * perform sign extension. The formula is
        if (atr & 0x20)
                atr |= 0xC0;
 
-       dev_dbg(&client->dev, "%s: raw atr=%x (%d)\n", __FUNCTION__, atr, atr);
+       dev_dbg(&client->dev, "%s: raw atr=%x (%d)\n", __func__, atr, atr);
 
        *trim = (atr * 250) + 11000;
 
-       dev_dbg(&client->dev, "%s: real=%d\n", __FUNCTION__, *trim);
+       dev_dbg(&client->dev, "%s: real=%d\n", __func__, *trim);
 
        return 0;
 }
                if ((xfer = i2c_transfer(client->adapter, msgs, 2)) != 2) {
                        dev_err(&client->dev,
                                "%s: could not read register %x\n",
-                               __FUNCTION__, probe_zero_pattern[i]);
+                               __func__, probe_zero_pattern[i]);
 
                        return -EIO;
                }
                if ((buf & probe_zero_pattern[i+1]) != 0) {
                        dev_err(&client->dev,
                                "%s: register=%02x, zero pattern=%d, value=%x\n",
-                               __FUNCTION__, probe_zero_pattern[i], i, buf);
+                               __func__, probe_zero_pattern[i], i, buf);
 
                        return -ENODEV;
                }
                if ((xfer = i2c_transfer(client->adapter, msgs, 2)) != 2) {
                        dev_err(&client->dev,
                                "%s: could not read register %x\n",
-                               __FUNCTION__, probe_limits_pattern[i].reg);
+                               __func__, probe_limits_pattern[i].reg);
 
                        return -EIO;
                }
                        value < probe_limits_pattern[i].min) {
                        dev_dbg(&client->dev,
                                "%s: register=%x, lim pattern=%d, value=%d\n",
-                               __FUNCTION__, probe_limits_pattern[i].reg,
+                               __func__, probe_limits_pattern[i].reg,
                                i, value);
 
                        return -ENODEV;