/* ErrorCode */
 #define ERROR_FLICKER_BELOW_MIN_EXP     0x01 /*flicker exposure got below minimum exposure */
 #define ALOG(fmt,args...) printk(fmt, ##args)
-#define LOG(fmt,args...) ALOG(KERN_INFO __FILE__ ":%s(%d):" fmt, __FUNCTION__ , __LINE__ , ##args)
+#define LOG(fmt,args...) ALOG(KERN_INFO __FILE__ ":%s(%d):" fmt, __func__ , __LINE__ , ##args)
 
 #ifdef _CPIA_DEBUG_
 #define ADBG(fmt,args...) printk(fmt, jiffies, ##args)
-#define DBG(fmt,args...) ADBG(KERN_DEBUG __FILE__" (%ld):%s(%d):" fmt, __FUNCTION__, __LINE__ , ##args)
+#define DBG(fmt,args...) ADBG(KERN_DEBUG __FILE__" (%ld):%s(%d):" fmt, __func__, __LINE__ , ##args)
 #else
 #define DBG(fmn,args...) do {} while(0)
 #endif
 
        /* resubmit */
        urb->dev = ucpia->dev;
        if ((i = usb_submit_urb(urb, GFP_ATOMIC)) != 0)
-               printk(KERN_ERR "%s: usb_submit_urb ret %d\n", __FUNCTION__,  i);
+               printk(KERN_ERR "%s: usb_submit_urb ret %d\n", __func__,  i);
 }
 
 static int cpia_usb_open(void *privdata)
 
        }
 
        if(buf[0] !=0 || buf[1] !=0 || buf[2] !=0 || buf[3] != 0)
-               dprintk(2, "%s: 0x%2x 0x%2x 0x%2x 0x%2x\n", __FUNCTION__,
+               dprintk(2, "%s: 0x%2x 0x%2x 0x%2x 0x%2x\n", __func__,
                        buf[0], buf[1], buf[2], buf[3]);
 
        /* no key pressed or signal from other ir remote */
 
                                             struct i2c_adapter* i2c_adap,
                                             u8 i2c_addr)
 {
-       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
        return NULL;
 }
 #endif
 
        int ret;
 
        /* Disable chip, synchronous option update */
-       dev_dbg(icd->vdev->dev, "%s\n", __FUNCTION__);
+       dev_dbg(icd->vdev->dev, "%s\n", __func__);
 
        ret = reg_write(icd, MT9M001_RESET, 1);
        if (ret >= 0)
 
 #ifdef OV511_DEBUG
        #define PDEBUG(level, fmt, args...) \
                if (debug >= (level)) info("[%s:%d] " fmt, \
-               __FUNCTION__, __LINE__ , ## args)
+               __func__, __LINE__ , ## args)
 #else
        #define PDEBUG(level, fmt, args...) do {} while(0)
 #endif
 
 
        BUG_ON(in_interrupt());
 
-       dev_dbg(&icd->dev, "%s (vb=0x%p) 0x%08lx %d\n", __FUNCTION__,
+       dev_dbg(&icd->dev, "%s (vb=0x%p) 0x%08lx %d\n", __func__,
                &buf->vb, buf->vb.baddr, buf->vb.bsize);
 
        /* This waits until this buffer is out of danger, i.e., until it is no
        struct pxa_buffer *buf = container_of(vb, struct pxa_buffer, vb);
        int i, ret;
 
-       dev_dbg(&icd->dev, "%s (vb=0x%p) 0x%08lx %d\n", __FUNCTION__,
+       dev_dbg(&icd->dev, "%s (vb=0x%p) 0x%08lx %d\n", __func__,
                vb, vb->baddr, vb->bsize);
 
        /* Added list head initialization on alloc */
        int nents = dma->sglen;
        unsigned long flags;
 
-       dev_dbg(&icd->dev, "%s (vb=0x%p) 0x%08lx %d\n", __FUNCTION__,
+       dev_dbg(&icd->dev, "%s (vb=0x%p) 0x%08lx %d\n", __func__,
                vb, vb->baddr, vb->bsize);
        spin_lock_irqsave(&pcdev->lock, flags);
 
 #ifdef DEBUG
        struct soc_camera_device *icd = vq->priv_data;
 
-       dev_dbg(&icd->dev, "%s (vb=0x%p) 0x%08lx %d\n", __FUNCTION__,
+       dev_dbg(&icd->dev, "%s (vb=0x%p) 0x%08lx %d\n", __func__,
                vb, vb->baddr, vb->bsize);
 
        switch (vb->state) {
        case VIDEOBUF_ACTIVE:
-               dev_dbg(&icd->dev, "%s (active)\n", __FUNCTION__);
+               dev_dbg(&icd->dev, "%s (active)\n", __func__);
                break;
        case VIDEOBUF_QUEUED:
-               dev_dbg(&icd->dev, "%s (queued)\n", __FUNCTION__);
+               dev_dbg(&icd->dev, "%s (queued)\n", __func__);
                break;
        case VIDEOBUF_PREPARED:
-               dev_dbg(&icd->dev, "%s (prepared)\n", __FUNCTION__);
+               dev_dbg(&icd->dev, "%s (prepared)\n", __func__);
                break;
        default:
-               dev_dbg(&icd->dev, "%s (unknown)\n", __FUNCTION__);
+               dev_dbg(&icd->dev, "%s (unknown)\n", __func__);
                break;
        }
 #endif
        vb = &pcdev->active->vb;
        buf = container_of(vb, struct pxa_buffer, vb);
        WARN_ON(buf->inwork || list_empty(&vb->queue));
-       dev_dbg(pcdev->dev, "%s (vb=0x%p) 0x%08lx %d\n", __FUNCTION__,
+       dev_dbg(pcdev->dev, "%s (vb=0x%p) 0x%08lx %d\n", __func__,
                vb, vb->baddr, vb->bsize);
 
        /* _init is used to debug races, see comment in pxa_camera_reqbufs() */
                pcdev, pdata);
 
        if (pdata && pdata->init) {
-               dev_dbg(pcdev->dev, "%s: Init gpios\n", __FUNCTION__);
+               dev_dbg(pcdev->dev, "%s: Init gpios\n", __func__);
                pdata->init(pcdev->dev);
        }
 
        if (pdata && pdata->power) {
-               dev_dbg(pcdev->dev, "%s: Power on camera\n", __FUNCTION__);
+               dev_dbg(pcdev->dev, "%s: Power on camera\n", __func__);
                pdata->power(pcdev->dev, 1);
        }
 
        if (pdata && pdata->reset) {
                dev_dbg(pcdev->dev, "%s: Releasing camera reset\n",
-                       __FUNCTION__);
+                       __func__);
                pdata->reset(pcdev->dev, 1);
        }
 
 
        if (board && board->reset) {
                dev_dbg(pcdev->dev, "%s: Asserting camera reset\n",
-                       __FUNCTION__);
+                       __func__);
                board->reset(pcdev->dev, 0);
        }
 
        if (board && board->power) {
-               dev_dbg(pcdev->dev, "%s: Power off camera\n", __FUNCTION__);
+               dev_dbg(pcdev->dev, "%s: Power off camera\n", __func__);
                board->power(pcdev->dev, 0);
        }
 }
 
        case -ENOENT:
        case -ESHUTDOWN:
                /* this urb is terminated, clean up */
-               dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status);
+               dbg("%s - urb shutting down with status: %d", __func__, urb->status);
                return;
        default:
-               dbg("%s - nonzero urb status received: %d", __FUNCTION__, urb->status);
+               dbg("%s - nonzero urb status received: %d", __func__, urb->status);
                goto exit;
        }
 
        status = usb_submit_urb (urb, GFP_ATOMIC);
        if (status)
                err ("%s - usb_submit_urb failed with result %d",
-                    __FUNCTION__, status);
+                    __func__, status);
 }
 
 static void se401_video_irq(struct urb *urb)
 
 
        WARN_ON(priv != file->private_data);
 
-       dev_dbg(&icd->dev, "%s: %d\n", __FUNCTION__, p->memory);
+       dev_dbg(&icd->dev, "%s: %d\n", __func__, p->memory);
 
        ret = videobuf_reqbufs(&icf->vb_vidq, p);
        if (ret < 0)
 
        WARN_ON(priv != file->private_data);
 
-       dev_dbg(&icd->dev, "%s\n", __FUNCTION__);
+       dev_dbg(&icd->dev, "%s\n", __func__);
 
        if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
                return -EINVAL;
 
        WARN_ON(priv != file->private_data);
 
-       dev_dbg(&icd->dev, "%s\n", __FUNCTION__);
+       dev_dbg(&icd->dev, "%s\n", __func__);
 
        if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
                return -EINVAL;
 {
        struct video_device *vdev = icd->vdev;
 
-       dev_dbg(&icd->dev, "%s\n", __FUNCTION__);
+       dev_dbg(&icd->dev, "%s\n", __func__);
 
        if (!icd->dev.parent || !vdev)
                return;
 
                        && i < ARRAY_SIZE(stk_sizes))
                i++;
        if (i == ARRAY_SIZE(stk_sizes)) {
-               STK_ERROR("Something is broken in %s\n", __FUNCTION__);
+               STK_ERROR("Something is broken in %s\n", __func__);
                return -EFAULT;
        }
        /* This registers controls some timings, not sure of what. */
 
 #define PDEBUG(level, fmt, args...) \
        do { \
        if (debug >= level)     \
-               info("[%s:%d] " fmt, __FUNCTION__, __LINE__ , ## args); \
+               info("[%s:%d] " fmt, __func__, __LINE__ , ## args);     \
        } while (0)
 
 
 
        rval = i2c_add_driver(&tcm825x_i2c_driver);
        if (rval)
                printk(KERN_INFO "%s: failed registering " TCM825X_NAME "\n",
-                      __FUNCTION__);
+                      __func__);
 
        return rval;
 }
 
 
        set_audio(fe, params);
 
-       tuner_dbg("%s: freq = %d\n", __FUNCTION__, params->frequency);
+       tuner_dbg("%s: freq = %d\n", __func__, params->frequency);
 
        tda8295_power(fe, 1);
        tda8295_agc1_out(fe, 1);
        if (tda8290_id[1] == TDA8290_ID) {
                if (debug)
                        printk(KERN_DEBUG "%s: tda8290 detected @ %d-%04x\n",
-                              __FUNCTION__, i2c_adapter_id(i2c_props->adap),
+                              __func__, i2c_adapter_id(i2c_props->adap),
                               i2c_props->addr);
                return 0;
        }
        if (tda8295_id[1] == TDA8295_ID) {
                if (debug)
                        printk(KERN_DEBUG "%s: tda8295 detected @ %d-%04x\n",
-                              __FUNCTION__, i2c_adapter_id(i2c_props->adap),
+                              __func__, i2c_adapter_id(i2c_props->adap),
                               i2c_props->addr);
                return 0;
        }
 
 #else
 static inline int tda829x_probe(struct i2c_adapter *i2c_adap, u8 i2c_addr)
 {
-       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
        return -EINVAL;
 }
 
                                                  struct tda829x_config *cfg)
 {
        printk(KERN_INFO "%s: not probed - driver disabled by Kconfig\n",
-              __FUNCTION__);
+              __func__);
        return NULL;
 }
 #endif
 
 module_param(debug, int, 0644);
 MODULE_PARM_DESC(debug, "Turn on/off device debugging (default:off).");
 #define dprintk(args...) \
-           do { if (debug) { printk("%s: %s()[%d]: ", KBUILD_MODNAME, __FUNCTION__, __LINE__); printk(args); } } while (0)
+           do { if (debug) { printk("%s: %s()[%d]: ", KBUILD_MODNAME, __func__, __LINE__); printk(args); } } while (0)
 
 #define        SWITCH          0x00
 #define        LEVEL_ADJUST    0x02
 
                                                  struct i2c_adapter *i2c_adap,
                                                  u8 i2c_addr)
 {
-       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
        return NULL;
 }
 #endif
 
                                        u8 i2c_addr)
 {
        printk(KERN_INFO "%s: not probed - driver disabled by Kconfig\n",
-              __FUNCTION__);
+              __func__);
        return -EINVAL;
 }
 
                                                   struct i2c_adapter* i2c_adap,
                                                   u8 i2c_addr)
 {
-       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
        return NULL;
 }
 #endif
 
                                        u8 i2c_addr)
 {
        printk(KERN_INFO "%s: not probed - driver disabled by Kconfig\n",
-              __FUNCTION__);
+              __func__);
        return -EINVAL;
 }
 
                                                   struct i2c_adapter* i2c_adap,
                                                   u8 i2c_addr)
 {
-       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
        return NULL;
 }
 #endif
 
 module_param(debug, int, 0644);
 MODULE_PARM_DESC(debug, "Turn on/off device debugging (default:off).");
 #define dprintk(args...) \
-           do { if (debug) { printk("%s: %s()[%d]: ", KBUILD_MODNAME, __FUNCTION__, __LINE__); printk(args); } } while (0)
+           do { if (debug) { printk("%s: %s()[%d]: ", KBUILD_MODNAME, __func__, __LINE__); printk(args); } } while (0)
 
 #define TEA6415C_NUM_INPUTS    8
 #define TEA6415C_NUM_OUTPUTS   6
 
 module_param(debug, int, 0644);
 MODULE_PARM_DESC(debug, "Turn on/off device debugging (default:off).");
 #define dprintk(args...) \
-           do { if (debug) { printk("%s: %s()[%d]: ", KBUILD_MODNAME, __FUNCTION__, __LINE__); printk(args); } } while (0)
+           do { if (debug) { printk("%s: %s()[%d]: ", KBUILD_MODNAME, __func__, __LINE__); printk(args); } } while (0)
 
 /* addresses to scan, found only at 0x4c and/or 0x4d (7-Bit) */
 static unsigned short normal_i2c[] = { I2C_ADDR_TEA6420_1, I2C_ADDR_TEA6420_2, I2C_CLIENT_END };
 
 
        if (type >= tuner_count) {
                printk(KERN_WARNING "%s: invalid tuner type: %d (max: %d)\n",
-                      __FUNCTION__, type, tuner_count-1);
+                      __func__, type, tuner_count-1);
                return NULL;
        }
 
 
                                                       u8 i2c_addr,
                                                       unsigned int type)
 {
-       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__);
        return NULL;
 }
 #endif
 
        unsigned char buf[2];
        unsigned char ibuf[2];
 
-       tuner_dbg("%s %04x called\n", __FUNCTION__, reg);
+       tuner_dbg("%s %04x called\n", __func__, reg);
 
        buf[0] = reg >> 8;
        buf[1] = (unsigned char) reg;
        char                  name[33];
        char                  *fname;
 
-       tuner_dbg("%s called\n", __FUNCTION__);
+       tuner_dbg("%s called\n", __func__);
 
        if (!firmware_name[0])
                fname = priv->ctrl.fname;
        int                 i, best_i = -1, best_nr_matches = 0;
        unsigned int        ign_firm_type_mask = 0;
 
-       tuner_dbg("%s called, want type=", __FUNCTION__);
+       tuner_dbg("%s called, want type=", __func__);
        if (debug) {
                dump_firm_type(type);
                printk("(%x), id %016llx.\n", type, (unsigned long long)*id);
        int                pos, rc;
        unsigned char      *p, *endp, buf[priv->ctrl.max_len];
 
-       tuner_dbg("%s called\n", __FUNCTION__);
+       tuner_dbg("%s called\n", __func__);
 
        pos = seek_firmware(fe, type, id);
        if (pos < 0)
        int                pos, rc;
        unsigned char      *p;
 
-       tuner_dbg("%s called\n", __FUNCTION__);
+       tuner_dbg("%s called\n", __func__);
 
        if (!int_freq) {
                pos = seek_firmware(fe, type, id);
        u16                        version, hwmodel;
        v4l2_std_id                std0;
 
-       tuner_dbg("%s called\n", __FUNCTION__);
+       tuner_dbg("%s called\n", __func__);
 
        if (!priv->firm) {
                if (!priv->ctrl.fname) {
        u16                 frq_lock, signal = 0;
        int                 rc;
 
-       tuner_dbg("%s called\n", __FUNCTION__);
+       tuner_dbg("%s called\n", __func__);
 
        mutex_lock(&priv->lock);
 
        unsigned char      buf[4];
        u32                div, offset = 0;
 
-       tuner_dbg("%s called\n", __FUNCTION__);
+       tuner_dbg("%s called\n", __func__);
 
        mutex_lock(&priv->lock);
 
        struct xc2028_data *priv = fe->tuner_priv;
        unsigned int       type=0;
 
-       tuner_dbg("%s called\n", __FUNCTION__);
+       tuner_dbg("%s called\n", __func__);
 
        if (p->mode == V4L2_TUNER_RADIO) {
                type |= FM;
        fe_bandwidth_t     bw = BANDWIDTH_8_MHZ;
        u16                demod = 0;
 
-       tuner_dbg("%s called\n", __FUNCTION__);
+       tuner_dbg("%s called\n", __func__);
 
        if (priv->ctrl.d2633)
                type |= D2633;
        struct xc2028_data *priv = fe->tuner_priv;
        int rc = 0;
 
-       tuner_dbg("%s called\n", __FUNCTION__);
+       tuner_dbg("%s called\n", __func__);
 
        mutex_lock(&priv->lock);
 
 {
        struct xc2028_data *priv = fe->tuner_priv;
 
-       tuner_dbg("%s called\n", __FUNCTION__);
+       tuner_dbg("%s called\n", __func__);
 
        mutex_lock(&xc2028_list_mutex);
 
 {
        struct xc2028_data *priv = fe->tuner_priv;
 
-       tuner_dbg("%s called\n", __FUNCTION__);
+       tuner_dbg("%s called\n", __func__);
 
        *frequency = priv->frequency;
 
        struct xc2028_ctrl *p    = priv_cfg;
        int                 rc   = 0;
 
-       tuner_dbg("%s called\n", __FUNCTION__);
+       tuner_dbg("%s called\n", __func__);
 
        mutex_lock(&priv->lock);
 
 
                                                 struct xc2028_config *cfg)
 {
        printk(KERN_INFO "%s: not probed - driver disabled by Kconfig\n",
-              __FUNCTION__);
+              __func__);
        return NULL;
 }
 #endif
 
 
        MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
 
-       dprintk(2, "%s\n", __FUNCTION__);
+       dprintk(2, "%s\n", __func__);
        mutex_lock(&q->vb_lock);
        retval = -EBUSY;
        if (q->streaming)
 
                                        dma->nr_pages, dma->direction);
                if (0 == dma->sglen) {
                        printk(KERN_WARNING
-                              "%s: videobuf_map_sg failed\n",__FUNCTION__);
+                              "%s: videobuf_map_sg failed\n",__func__);
                        kfree(dma->sglist);
                        dma->sglist = NULL;
                        dma->sglen = 0;
        videobuf_dma_init(&mem->dma);
 
        dprintk(1,"%s: allocated at %p(%ld+%ld) & %p(%ld)\n",
-               __FUNCTION__,vb,(long)sizeof(*vb),(long)size-sizeof(*vb),
+               __func__,vb,(long)sizeof(*vb),(long)size-sizeof(*vb),
                mem,(long)sizeof(*mem));
 
        return vb;
 
        mem->magic=MAGIC_VMAL_MEM;
 
        dprintk(1,"%s: allocated at %p(%ld+%ld) & %p(%ld)\n",
-               __FUNCTION__,vb,(long)sizeof(*vb),(long)size-sizeof(*vb),
+               __func__,vb,(long)sizeof(*vb),(long)size-sizeof(*vb),
                mem,(long)sizeof(*mem));
 
        return vb;
 
                        break;
                default:
                        printk(KERN_ERR "%s called with unknown type: %d\n",
-                              __FUNCTION__, type);
+                              __func__, type);
                        return -1;
        }
 
        ret = device_register(&vfd->class_dev);
        if (ret < 0) {
                printk(KERN_ERR "%s: device_register failed\n",
-                      __FUNCTION__);
+                      __func__);
                goto fail_minor;
        }
 
 
        int timeout;
        DECLARE_WAITQUEUE(wait, current);
 
-       dprintk(dev, 1, "%s dma_q=0x%08lx\n", __FUNCTION__,
+       dprintk(dev, 1, "%s dma_q=0x%08lx\n", __func__,
                (unsigned long)dma_q);
 
        add_wait_queue(&dma_q->wq, &wait);
        dma_q->frame = 0;
        dma_q->ini_jiffies = jiffies;
 
-       dprintk(dev, 1, "%s\n", __FUNCTION__);
+       dprintk(dev, 1, "%s\n", __func__);
 
        dma_q->kthread = kthread_run(vivi_thread, fh, "vivi");
 
        /* Wakes thread */
        wake_up_interruptible(&dma_q->wq);
 
-       dprintk(dev, 1, "returning from %s\n", __FUNCTION__);
+       dprintk(dev, 1, "returning from %s\n", __func__);
        return 0;
 }
 
 {
        struct vivi_dev *dev = container_of(dma_q, struct vivi_dev, vidq);
 
-       dprintk(dev, 1, "%s\n", __FUNCTION__);
+       dprintk(dev, 1, "%s\n", __func__);
        /* shutdown control thread */
        if (dma_q->kthread) {
                kthread_stop(dma_q->kthread);
        while (*size * *count > vid_limit * 1024 * 1024)
                (*count)--;
 
-       dprintk(dev, 1, "%s, count=%d, size=%d\n", __FUNCTION__,
+       dprintk(dev, 1, "%s, count=%d, size=%d\n", __func__,
                *count, *size);
 
        return 0;
        struct vivi_fh  *fh = vq->priv_data;
        struct vivi_dev *dev  = fh->dev;
 
-       dprintk(dev, 1, "%s, state: %i\n", __FUNCTION__, buf->vb.state);
+       dprintk(dev, 1, "%s, state: %i\n", __func__, buf->vb.state);
 
        if (in_interrupt())
                BUG();
        struct vivi_buffer *buf = container_of(vb, struct vivi_buffer, vb);
        int rc;
 
-       dprintk(dev, 1, "%s, field=%d\n", __FUNCTION__, field);
+       dprintk(dev, 1, "%s, field=%d\n", __func__, field);
 
        BUG_ON(NULL == fh->fmt);
 
        struct vivi_dev       *dev  = fh->dev;
        struct vivi_dmaqueue *vidq = &dev->vidq;
 
-       dprintk(dev, 1, "%s\n", __FUNCTION__);
+       dprintk(dev, 1, "%s\n", __func__);
 
        buf->vb.state = VIDEOBUF_QUEUED;
        list_add_tail(&buf->vb.queue, &vidq->active);
        struct vivi_fh       *fh   = vq->priv_data;
        struct vivi_dev      *dev  = (struct vivi_dev *)fh->dev;
 
-       dprintk(dev, 1, "%s\n", __FUNCTION__);
+       dprintk(dev, 1, "%s\n", __func__);
 
        free_buffer(vq, buf);
 }
        mutex_lock(&q->vb_lock);
 
        if (videobuf_queue_is_busy(&fh->vb_vidq)) {
-               dprintk(fh->dev, 1, "%s queue busy\n", __FUNCTION__);
+               dprintk(fh->dev, 1, "%s queue busy\n", __func__);
                ret = -EBUSY;
                goto out;
        }
        struct vivi_dev       *dev = fh->dev;
        struct videobuf_queue *q = &fh->vb_vidq;
 
-       dprintk(dev, 1, "%s\n", __FUNCTION__);
+       dprintk(dev, 1, "%s\n", __func__);
 
        if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
                return POLLERR;
 
 /*#define DEBUG*/                              /* Undef me for production */
 
 #ifdef DEBUG
-#define DPRINTF(x, a...) printk(KERN_DEBUG "W9966: %s(): "x, __FUNCTION__ , ##a)
+#define DPRINTF(x, a...) printk(KERN_DEBUG "W9966: %s(): "x, __func__ , ##a)
 #else
 #define DPRINTF(x...)
 #endif
 
                        dev_warn(&cam->dev, fmt "\n", ## args);               \
                else if ((level) >= 5)                                        \
                        dev_info(&cam->dev, "[%s:%d] " fmt "\n",              \
-                                __FUNCTION__, __LINE__ , ## args);           \
+                                __func__, __LINE__ , ## args);           \
        }                                                                     \
 }
 /* For generic kernel (not device specific) messages */
                if ((level) >= 1 && (level) <= 4)                             \
                        pr_info("w9968cf: " fmt "\n", ## args);               \
                else if ((level) >= 5)                                        \
-                       pr_debug("w9968cf: [%s:%d] " fmt "\n", __FUNCTION__,  \
+                       pr_debug("w9968cf: [%s:%d] " fmt "\n", __func__,  \
                                 __LINE__ , ## args);                         \
        }                                                                     \
 }
 
 #undef PDBG
 #define PDBG(fmt, args...)                                                    \
-dev_info(&cam->dev, "[%s:%d] " fmt "\n", __FUNCTION__, __LINE__ , ## args);
+dev_info(&cam->dev, "[%s:%d] " fmt "\n", __func__, __LINE__ , ## args);
 
 #undef PDBGG
 #define PDBGG(fmt, args...) do {;} while(0); /* nothing: it's a placeholder */
 
                dprintk(3,
                        KERN_DEBUG
                        "%s: %s() raw - active=%c, sync_tail=%lu/%c, pend_tail=%lu, pend_head=%lu\n",
-                       ZR_DEVNAME(zr), __FUNCTION__,
+                       ZR_DEVNAME(zr), __func__,
                        "FAL"[fh->v4l_buffers.active], zr->v4l_sync_tail,
                        "UPMD"[zr->v4l_buffers.buffer[frame].state],
                        zr->v4l_pend_tail, zr->v4l_pend_head);
                dprintk(3,
                        KERN_DEBUG
                        "%s: %s() jpg - active=%c, que_tail=%lu/%c, que_head=%lu, dma=%lu/%lu\n",
-                       ZR_DEVNAME(zr), __FUNCTION__,
+                       ZR_DEVNAME(zr), __func__,
                        "FAL"[fh->jpg_buffers.active], zr->jpg_que_tail,
                        "UPMD"[zr->jpg_buffers.buffer[frame].state],
                        zr->jpg_que_head, zr->jpg_dma_tail, zr->jpg_dma_head);