#ifdef modem_control
        unsigned char control, status;
 
-       if (serial_paranoia_check(info, tty->name, __FUNCTION__))
+       if (serial_paranoia_check(info, tty->name, __func__))
                return -ENODEV;
 
        if (tty->flags & (1 << TTY_IO_ERROR))
        ser_info_t *info = (ser_info_t *)tty->driver_data;
        unsigned int arg;
 
-       if (serial_paranoia_check(info, tty->name, __FUNCTION__))
+       if (serial_paranoia_check(info, tty->name, __func__))
                return -ENODEV;
 
        if (tty->flags & (1 << TTY_IO_ERROR))
 
                port->membase = ioremap(port->mapbase, 64);
                if (!port->membase) {
                        printk(KERN_ERR "%s: Couldn't ioremap 0x%llx\n",
-                               __FUNCTION__,
+                               __func__,
                               (unsigned long long)port->mapbase);
                        return -ENOMEM;
                }
 
                break;
        default:
                printk(KERN_ERR "%s: word lengh not supported\n",
-                       __FUNCTION__);
+                       __func__);
        }
 
        if (termios->c_cflag & CSTOPB)
 
                *baud = get_sclk() / (16*(dll | dlh << 8));
        }
-       pr_debug("%s:baud = %d, parity = %c, bits= %d\n", __FUNCTION__, *baud, *parity, *bits);
+       pr_debug("%s:baud = %d, parity = %c, bits= %d\n", __func__, *baud, *parity, *bits);
 }
 #endif
 
 
 
        line = cpm_uart_id2nr(idx);
        if(line < 0) {
-               printk(KERN_ERR"%s(): port %d is not registered", __FUNCTION__, idx);
+               printk(KERN_ERR"%s(): port %d is not registered", __func__, idx);
                return -EINVAL;
        }
 
 
 
        if (info->recv_cnt + recvl > 65536) {
                printk(KERN_CRIT
-                      "%s: Too much pending incoming serial data! Dropping %u bytes.\n", __FUNCTION__, recvl);
+                      "%s: Too much pending incoming serial data! Dropping %u bytes.\n", __func__, recvl);
                return 0;
        }
 
        append_recv_buffer(info, buffer);
 
        if (!(buffer = alloc_recv_buffer(SERIAL_DESCR_BUF_SIZE)))
-               panic("%s: Failed to allocate memory for receive buffer!\n", __FUNCTION__);
+               panic("%s: Failed to allocate memory for receive buffer!\n", __func__);
 
        descr->buf = virt_to_phys(buffer->buffer);
 
        /* Set up the receiving descriptors */
        for (i = 0; i < SERIAL_RECV_DESCRIPTORS; i++) {
                if (!(buffer = alloc_recv_buffer(SERIAL_DESCR_BUF_SIZE)))
-                       panic("%s: Failed to allocate memory for receive buffer!\n", __FUNCTION__);
+                       panic("%s: Failed to allocate memory for receive buffer!\n", __func__);
 
                descr[i].ctrl = d_int;
                descr[i].buf = virt_to_phys(buffer->buffer);
 
        if (request_irq(SERIAL_IRQ_NBR, ser_interrupt,
                        IRQF_SHARED | IRQF_DISABLED, "serial ", driver))
-               panic("%s: Failed to request irq8", __FUNCTION__);
+               panic("%s: Failed to request irq8", __func__);
 
 #endif
 #endif /* CONFIG_SVINTO_SIM */
 
 #define DPRINT_CONFIG(_x...)   ;
 //#define DPRINT_CONFIG(_x...)  printk _x
 #define NOT_PROGRESS() ;
-//#define NOT_PROGRESS()       printk("%s : fails %d\n", __FUNCTION__, __LINE__)
+//#define NOT_PROGRESS()       printk("%s : fails %d\n", __func__, __LINE__)
 
 /* number of characters we want to transmit to the lower level at a time */
 #define MAX_CHARS              256
                sbbr_h = &idd->vma->sbbr_h;
                ring_pci_addr = (unsigned long __iomem)port->ip_dma_ringbuf;
                DPRINT_CONFIG(("%s: ring_pci_addr 0x%p\n",
-                              __FUNCTION__, (void *)ring_pci_addr));
+                              __func__, (void *)ring_pci_addr));
 
                writel((unsigned int)((uint64_t) ring_pci_addr >> 32), sbbr_h);
                writel((unsigned int)ring_pci_addr | BUF_SIZE_BIT, sbbr_l);
 
        DPRINT_CONFIG(("%s: line %d baud %d byte_size %d stop %d parenb %d "
                        "parodd %d\n",
-                      __FUNCTION__, ((struct uart_port *)port->ip_port)->line,
+                      __func__, ((struct uart_port *)port->ip_port)->line,
                        baud, byte_size, stop_bits, parenb, parodd));
 
        if (set_baud(port, baud))
        default:
        case PROTO_RS232:
                /* Clear the appropriate GIO pin */
-               DPRINT_CONFIG(("%s: rs232\n", __FUNCTION__));
+               DPRINT_CONFIG(("%s: rs232\n", __func__));
                writel(0, (&port->ip_idd->vma->gppr[0]
                                        + hooks->rs422_select_pin));
                break;
 
        case PROTO_RS422:
                /* Set the appropriate GIO pin */
-               DPRINT_CONFIG(("%s: rs422\n", __FUNCTION__));
+               DPRINT_CONFIG(("%s: rs422\n", __func__));
                writel(1, (&port->ip_idd->vma->gppr[0]
                                        + hooks->rs422_select_pin));
                break;
        }
        baud = uart_get_baud_rate(the_port, new_termios, old_termios,
                                  MIN_BAUD_SUPPORTED, MAX_BAUD_SUPPORTED);
-       DPRINT_CONFIG(("%s: returned baud %d for line %d\n", __FUNCTION__, baud,
+       DPRINT_CONFIG(("%s: returned baud %d for line %d\n", __func__, baud,
                                the_port->line));
 
        if (!the_port->fifosize)
        DPRINT_CONFIG(("%s : port 0x%p line %d cflag 0%o "
                       "config_port(baud %d data %d stop %d penable %d "
                        " parity %d), notification 0x%x\n",
-                      __FUNCTION__, (void *)port, the_port->line, cflag, baud,
+                      __func__, (void *)port, the_port->line, cflag, baud,
                       new_data, new_stop, new_parity_enable, new_parity,
                       the_port->ignore_status_mask));
 
        struct pci_dev *pdev = idd->pdev;
 
        DPRINT_CONFIG(("%s: attach pdev 0x%p - card_ptr 0x%p\n",
-                      __FUNCTION__, pdev, (void *)card_ptr));
+                      __func__, pdev, (void *)card_ptr));
 
        if (!card_ptr)
                return -ENODEV;
                port->ip_port = the_port;
 
                DPRINT_CONFIG(("%s: attach the_port 0x%p / port 0x%p [%d/%d]\n",
-                       __FUNCTION__, (void *)the_port, (void *)port,
+                       __func__, (void *)the_port, (void *)port,
                                phys_port, ii));
 
                /* membase, iobase and mapbase just need to be non-0 */
                if (uart_add_one_port(&ioc3_uart, the_port) < 0) {
                        printk(KERN_WARNING
                          "%s: unable to add port %d bus %d\n",
-                              __FUNCTION__, the_port->line, pdev->bus->number);
+                              __func__, the_port->line, pdev->bus->number);
                } else {
                        DPRINT_CONFIG(("IOC3 serial port %d irq %d bus %d\n",
                          the_port->line, the_port->irq, pdev->bus->number));
        struct ioc3_port *ports[PORTS_PER_CARD];
        int phys_port;
 
-       DPRINT_CONFIG(("%s (0x%p, 0x%p)\n", __FUNCTION__, is, idd));
+       DPRINT_CONFIG(("%s (0x%p, 0x%p)\n", __func__, is, idd));
 
        card_ptr = kzalloc(sizeof(struct ioc3_card), GFP_KERNEL);
        if (!card_ptr) {
 
                        DPRINT_CONFIG(("%s : Port A ip_serial_regs 0x%p "
                                       "ip_uart_regs 0x%p\n",
-                                      __FUNCTION__,
+                                      __func__,
                                       (void *)port->ip_serial_regs,
                                       (void *)port->ip_uart_regs));
 
                        DPRINT_CONFIG(("%s : Port A ip_cpu_ringbuf 0x%p "
                                       "ip_dma_ringbuf 0x%p, ip_inring 0x%p "
                                        "ip_outring 0x%p\n",
-                                      __FUNCTION__,
+                                      __func__,
                                       (void *)port->ip_cpu_ringbuf,
                                       (void *)port->ip_dma_ringbuf,
                                       (void *)port->ip_inring,
 
                        DPRINT_CONFIG(("%s : Port B ip_serial_regs 0x%p "
                                       "ip_uart_regs 0x%p\n",
-                                      __FUNCTION__,
+                                      __func__,
                                       (void *)port->ip_serial_regs,
                                       (void *)port->ip_uart_regs));
 
                        DPRINT_CONFIG(("%s : Port B ip_cpu_ringbuf 0x%p "
                                       "ip_dma_ringbuf 0x%p, ip_inring 0x%p "
                                        "ip_outring 0x%p\n",
-                                      __FUNCTION__,
+                                      __func__,
                                       (void *)port->ip_cpu_ringbuf,
                                       (void *)port->ip_dma_ringbuf,
                                       (void *)port->ip_inring,
                }
 
                DPRINT_CONFIG(("%s : port %d [addr 0x%p] card_ptr 0x%p",
-                              __FUNCTION__,
+                              __func__,
                               phys_port, (void *)port, (void *)card_ptr));
                DPRINT_CONFIG((" ip_serial_regs 0x%p ip_uart_regs 0x%p\n",
                               (void *)port->ip_serial_regs,
 
                DPRINT_CONFIG(("%s: phys_port %d port 0x%p inring 0x%p "
                               "outring 0x%p\n",
-                              __FUNCTION__,
+                              __func__,
                               phys_port, (void *)port,
                               (void *)port->ip_inring,
                               (void *)port->ip_outring));
        if ((ret = uart_register_driver(&ioc3_uart)) < 0) {
                printk(KERN_WARNING
                       "%s: Couldn't register IOC3 uart serial driver\n",
-                      __FUNCTION__);
+                      __func__);
                return ret;
        }
        ret = ioc3_register_submodule(&ioc3uart_submodule);
 
 
                ring_pci_addr = (unsigned long __iomem)port->ip_dma_ringbuf;
                DPRINT_CONFIG(("%s: ring_pci_addr 0x%lx\n",
-                                       __FUNCTION__, ring_pci_addr));
+                                       __func__, ring_pci_addr));
 
                writel((unsigned int)((uint64_t)ring_pci_addr >> 32), sbbr_h);
                writel((unsigned int)ring_pci_addr | IOC4_BUF_SIZE_BIT, sbbr_l);
                spin_lock_irqsave(&soft->is_ir_lock, flag);
                printk ("%s : %d : mem 0x%p sio_ir 0x%x sio_ies 0x%x "
                                "other_ir 0x%x other_ies 0x%x mask 0x%x\n",
-                    __FUNCTION__, __LINE__,
+                    __func__, __LINE__,
                     (void *)mem, readl(&mem->sio_ir.raw),
                     readl(&mem->sio_ies.raw),
                     readl(&mem->other_ir.raw),
                                (TOTAL_RING_BUF_SIZE - 1)) == 0));
                        DPRINT_CONFIG(("%s : ip_cpu_ringbuf 0x%p "
                                                "ip_dma_ringbuf 0x%p\n",
-                                       __FUNCTION__,
+                                       __func__,
                                        (void *)port->ip_cpu_ringbuf,
                                        (void *)port->ip_dma_ringbuf));
                        port->ip_inring = RING(port, RX_0_OR_2);
                        port->ip_outring = RING(port, TX_0_OR_2);
                }
                DPRINT_CONFIG(("%s : port %d [addr 0x%p] control 0x%p",
-                               __FUNCTION__,
+                               __func__,
                                port_number, (void *)port, (void *)control));
                DPRINT_CONFIG((" ip_serial_regs 0x%p ip_uart_regs 0x%p\n",
                                (void *)port->ip_serial_regs,
 
                DPRINT_CONFIG(("%s: port_number %d port 0x%p inring 0x%p "
                                                "outring 0x%p\n",
-                               __FUNCTION__,
+                               __func__,
                                port_number, (void *)port,
                                (void *)port->ip_inring,
                                (void *)port->ip_outring));
        int spiniter = 0;
 
        DPRINT_CONFIG(("%s: baud %d byte_size %d stop %d parenb %d parodd %d\n",
-               __FUNCTION__, baud, byte_size, stop_bits, parenb, parodd));
+               __func__, baud, byte_size, stop_bits, parenb, parodd));
 
        if (set_baud(port, baud))
                return 1;
        }
        baud = uart_get_baud_rate(the_port, new_termios, old_termios,
                                MIN_BAUD_SUPPORTED, MAX_BAUD_SUPPORTED);
-       DPRINT_CONFIG(("%s: returned baud %d\n", __FUNCTION__, baud));
+       DPRINT_CONFIG(("%s: returned baud %d\n", __func__, baud));
 
        /* default is 9600 */
        if (!baud)
        DPRINT_CONFIG(("%s : port 0x%p cflag 0%o "
                "config_port(baud %d data %d stop %d p enable %d parity %d),"
                " notification 0x%x\n",
-            __FUNCTION__, (void *)port, cflag, baud, new_data, new_stop,
+            __func__, (void *)port, cflag, baud, new_data, new_stop,
             new_parity_enable, new_parity, the_port->ignore_status_mask));
 
        if ((config_port(port, baud,            /* baud */
 
 
        DPRINT_CONFIG(("%s: attach pdev 0x%p - control 0x%p\n",
-                       __FUNCTION__, pdev, (void *)control));
+                       __func__, pdev, (void *)control));
 
        if (!control)
                return -ENODEV;
                port->ip_all_ports[port_type_idx] = the_port;
 
                DPRINT_CONFIG(("%s: attach the_port 0x%p / port 0x%p : type %s\n",
-                               __FUNCTION__, (void *)the_port,
+                               __func__, (void *)the_port,
                                (void *)port,
                                port_type == PROTO_RS232 ? "rs232" : "rs422"));
 
                if (uart_add_one_port(u_driver, the_port) < 0) {
                        printk(KERN_WARNING
                           "%s: unable to add port %d bus %d\n",
-                              __FUNCTION__, the_port->line, pdev->bus->number);
+                              __func__, the_port->line, pdev->bus->number);
                } else {
                        DPRINT_CONFIG(
                            ("IOC4 serial port %d irq = %d, bus %d\n",
        int ret = 0;
 
 
-       DPRINT_CONFIG(("%s (0x%p, 0x%p)\n", __FUNCTION__, idd->idd_pdev,
+       DPRINT_CONFIG(("%s (0x%p, 0x%p)\n", __func__, idd->idd_pdev,
                                                        idd->idd_pci_id));
 
        /* PCI-RT does not bring out serial connections.
                goto out2;
        }
        DPRINT_CONFIG(("%s : mem 0x%p, serial 0x%p\n",
-                               __FUNCTION__, (void *)idd->idd_misc_regs,
+                               __func__, (void *)idd->idd_misc_regs,
                                (void *)serial));
 
        /* Get memory for the new card */
        } else {
                printk(KERN_WARNING
                    "%s : request_irq fails for IRQ 0x%x\n ",
-                       __FUNCTION__, idd->idd_pdev->irq);
+                       __func__, idd->idd_pdev->irq);
        }
        ret = ioc4_attach_local(idd);
        if (ret)
        if ((ret = uart_register_driver(&ioc4_uart_rs232)) < 0) {
                printk(KERN_WARNING
                        "%s: Couldn't register rs232 IOC4 serial driver\n",
-                       __FUNCTION__);
+                       __func__);
                return ret;
        }
        if ((ret = uart_register_driver(&ioc4_uart_rs422)) < 0) {
                printk(KERN_WARNING
                        "%s: Couldn't register rs422 IOC4 serial driver\n",
-                       __FUNCTION__);
+                       __func__);
                return ret;
        }
 
 
        ourport = &s3c24xx_serial_ports[probe_index];
        probe_index++;
 
-       dbg("%s: initialising port %p...\n", __FUNCTION__, ourport);
+       dbg("%s: initialising port %p...\n", __func__, ourport);
 
        ret = s3c24xx_serial_init_port(ourport, info, dev);
        if (ret < 0)
                goto probe_err;
 
-       dbg("%s: adding port\n", __FUNCTION__);
+       dbg("%s: adding port\n", __func__);
        uart_add_one_port(&s3c24xx_uart_drv, &ourport->port);
        platform_set_drvdata(dev, &ourport->port);
 
        unsigned long ucon = rd_regl(port, S3C2410_UCON);
 
        dbg("%s: port=%p (%08lx), cfg=%p\n",
-           __FUNCTION__, port, port->mapbase, cfg);
+           __func__, port, port->mapbase, cfg);
 
        /* ensure we don't change the clock settings... */
 
 
 void __init sa1100_register_uart(int idx, int port)
 {
        if (idx >= NR_PORTS) {
-               printk(KERN_ERR "%s: bad index number %d\n", __FUNCTION__, idx);
+               printk(KERN_ERR "%s: bad index number %d\n", __func__, idx);
                return;
        }
 
                break;
 
        default:
-               printk(KERN_ERR "%s: bad port number %d\n", __FUNCTION__, port);
+               printk(KERN_ERR "%s: bad port number %d\n", __func__, port);
        }
 }
 
 
 
                printk(KERN_INFO "%s: got a postchange notification "
                       "for cpu %d (old %d, new %d)\n",
-                      __FUNCTION__, freqs->cpu, freqs->old, freqs->new);
+                      __func__, freqs->cpu, freqs->old, freqs->new);
        }
 
        return NOTIFY_OK;
 
 
        if (uart_add_one_port(&sal_console_uart, &sal_console_port.sc_port) < 0) {
                /* error - not sure what I'd do - so I'll do nothing */
-               printk(KERN_ERR "%s: unable to add port\n", __FUNCTION__);
+               printk(KERN_ERR "%s: unable to add port\n", __func__);
        }
 
        /* when this driver is compiled in, the console initialization
 
        const unsigned int *id;
        int irq, rc;
 
-       dev_dbg(&op->dev, "%s(%p, %p)\n", __FUNCTION__, op, match);
+       dev_dbg(&op->dev, "%s(%p, %p)\n", __func__, op, match);
 
        rc = of_address_to_resource(op->node, 0, &res);
        if (rc) {
 
                return qe_port->bd_dma_addr + (addr - qe_port->bd_virt);
 
        /* something nasty happened */
-       printk(KERN_ERR "%s: addr=%p\n", __FUNCTION__, addr);
+       printk(KERN_ERR "%s: addr=%p\n", __func__, addr);
        BUG();
        return 0;
 }
                return qe_port->bd_virt + (addr - qe_port->bd_dma_addr);
 
        /* something nasty happened */
-       printk(KERN_ERR "%s: addr=%x\n", __FUNCTION__, addr);
+       printk(KERN_ERR "%s: addr=%x\n", __func__, addr);
        BUG();
        return NULL;
 }