}
 
        q->curr->vb.state = state;
-       do_gettimeofday(&q->curr->vb.ts);
+       v4l2_get_timestamp(&q->curr->vb.ts);
        wake_up(&q->curr->vb.done);
 
        q->curr = NULL;
 
 {
        struct timeval ts;
 
-       do_gettimeofday(&ts);
+       v4l2_get_timestamp(&ts);
 
        if (wakeup->top == wakeup->bottom) {
                if (NULL != wakeup->top && curr->top != wakeup->top) {
        if (NULL == wakeup)
                return;
 
-       do_gettimeofday(&ts);
+       v4l2_get_timestamp(&ts);
        wakeup->vb.ts = ts;
        wakeup->vb.field_count = btv->field_count;
        wakeup->vb.state = state;
        btv->curr.top = NULL;
        bttv_risc_hook(btv, RISC_SLOT_O_FIELD, NULL, 0);
 
-       do_gettimeofday(&wakeup->vb.ts);
+       v4l2_get_timestamp(&wakeup->vb.ts);
        wakeup->vb.field_count = btv->field_count;
        wakeup->vb.state = VIDEOBUF_DONE;
        wake_up(&wakeup->vb.done);
 
                if ((s16) (count - buf->count) < 0)
                        break;
 
-               do_gettimeofday(&buf->vb.ts);
+               v4l2_get_timestamp(&buf->vb.ts);
                dprintk(2, "[%p/%d] wakeup reg=%d buf=%d\n", buf, buf->vb.i,
                        count, buf->count);
                buf->vb.state = VIDEOBUF_DONE;
 
                if ((s16) (count - buf->count) < 0)
                        break;
 
-               do_gettimeofday(&buf->vb.ts);
+               v4l2_get_timestamp(&buf->vb.ts);
                dprintk(2, "[%p/%d] wakeup reg=%d buf=%d\n", buf, buf->vb.i,
                        count, buf->count);
                buf->vb.state = VIDEOBUF_DONE;
 
                if ((s16) (count - buf->count) < 0)
                        break;
 
-               do_gettimeofday(&buf->vb.ts);
+               v4l2_get_timestamp(&buf->vb.ts);
                buf->vb.state = VIDEOBUF_DONE;
                list_del(&buf->vb.queue);
                wake_up(&buf->vb.done);
 
                 * up to 32767 buffers in flight... */
                if ((s16) (count - buf->count) < 0)
                        break;
-               do_gettimeofday(&buf->vb.ts);
+               v4l2_get_timestamp(&buf->vb.ts);
                dprintk(2,"[%p/%d] wakeup reg=%d buf=%d\n",buf,buf->vb.i,
                        count, buf->count);
                buf->vb.state = VIDEOBUF_DONE;
 
                                      mchip_hsize() * mchip_vsize() * 2);
                meye.grab_buffer[reqnr].size = mchip_hsize() * mchip_vsize() * 2;
                meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
-               do_gettimeofday(&meye.grab_buffer[reqnr].timestamp);
+               v4l2_get_timestamp(&meye.grab_buffer[reqnr].timestamp);
                meye.grab_buffer[reqnr].sequence = sequence++;
                kfifo_in_locked(&meye.doneq, (unsigned char *)&reqnr,
                                sizeof(int), &meye.doneq_lock);
                       size);
                meye.grab_buffer[reqnr].size = size;
                meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
-               do_gettimeofday(&meye.grab_buffer[reqnr].timestamp);
+               v4l2_get_timestamp(&meye.grab_buffer[reqnr].timestamp);
                meye.grab_buffer[reqnr].sequence = sequence++;
                kfifo_in_locked(&meye.doneq, (unsigned char *)&reqnr,
                                sizeof(int), &meye.doneq_lock);
 
 
        /* finish current buffer */
        q->curr->vb.state = state;
-       do_gettimeofday(&q->curr->vb.ts);
+       v4l2_get_timestamp(&q->curr->vb.ts);
        wake_up(&q->curr->vb.done);
        q->curr = NULL;
 }
 
 
        REG_WRITE(vip, DVP_CTL, REG_READ(vip, DVP_CTL) & ~DVP_CTL_ENA);
        if (vip->active) {
-               do_gettimeofday(&vip->active->ts);
+               v4l2_get_timestamp(&vip->active->ts);
                vip->active->field_count++;
                vip->active->state = VIDEOBUF_DONE;
                wake_up(&vip->active->done);
 
                }
                frame = zr->jpg_pend[zr->jpg_dma_tail & BUZ_MASK_FRAME];
                buffer = &zr->jpg_buffers.buffer[frame];
-               do_gettimeofday(&buffer->bs.timestamp);
+               v4l2_get_timestamp(&buffer->bs.timestamp);
 
                if (zr->codec_mode == BUZ_MODE_MOTION_COMPRESS) {
                        buffer->bs.length = (stat_com & 0x7fffff) >> 1;
 
                                                zr->v4l_buffers.buffer[zr->v4l_grab_frame].state = BUZ_STATE_DONE;
                                                zr->v4l_buffers.buffer[zr->v4l_grab_frame].bs.seq = zr->v4l_grab_seq;
-                                               do_gettimeofday(&zr->v4l_buffers.buffer[zr->v4l_grab_frame].bs.timestamp);
+                                               v4l2_get_timestamp(&zr->v4l_buffers.buffer[zr->v4l_grab_frame].bs.timestamp);
                                                zr->v4l_grab_frame = NO_GRAB_ACTIVE;
                                                zr->v4l_pend_tail++;
                                        }
 
 {
        struct ppi_if *ppi = dev_id;
        struct bcap_device *bcap_dev = ppi->priv;
-       struct timeval timevalue;
        struct vb2_buffer *vb = &bcap_dev->cur_frm->vb;
        dma_addr_t addr;
 
        spin_lock(&bcap_dev->lock);
 
        if (bcap_dev->cur_frm != bcap_dev->next_frm) {
-               do_gettimeofday(&timevalue);
-               vb->v4l2_buf.timestamp = timevalue;
+               v4l2_get_timestamp(&vb->v4l2_buf.timestamp);
                vb2_buffer_done(vb, VB2_BUF_STATE_DONE);
                bcap_dev->cur_frm = bcap_dev->next_frm;
        }
 
 
 static void vpfe_process_buffer_complete(struct vpfe_device *vpfe_dev)
 {
-       struct timeval timevalue;
-
-       do_gettimeofday(&timevalue);
-       vpfe_dev->cur_frm->ts = timevalue;
+       v4l2_get_timestamp(&vpfe_dev->cur_frm->ts);
        vpfe_dev->cur_frm->state = VIDEOBUF_DONE;
        vpfe_dev->cur_frm->size = vpfe_dev->fmt.fmt.pix.sizeimage;
        wake_up_interruptible(&vpfe_dev->cur_frm->done);
 
  */
 static void vpif_process_buffer_complete(struct common_obj *common)
 {
-       do_gettimeofday(&common->cur_frm->vb.v4l2_buf.timestamp);
+       v4l2_get_timestamp(&common->cur_frm->vb.v4l2_buf.timestamp);
        vb2_buffer_done(&common->cur_frm->vb,
                                            VB2_BUF_STATE_DONE);
        /* Make curFrm pointing to nextFrm */
 
                /* one frame is displayed If next frame is
                 *  available, release cur_frm and move on */
                /* Copy frame display time */
-               do_gettimeofday(&common->cur_frm->vb.v4l2_buf.timestamp);
+               v4l2_get_timestamp(&common->cur_frm->vb.v4l2_buf.timestamp);
                /* Change status of the cur_frm */
                vb2_buffer_done(&common->cur_frm->vb,
                                            VB2_BUF_STATE_DONE);
                        if (!channel_first_int[i][channel_id]) {
                                /* Mark status of the cur_frm to
                                 * done and unlock semaphore on it */
-                               do_gettimeofday(&common->cur_frm->vb.
-                                               v4l2_buf.timestamp);
+                               v4l2_get_timestamp(&common->cur_frm->vb.
+                                                  v4l2_buf.timestamp);
                                vb2_buffer_done(&common->cur_frm->vb,
                                            VB2_BUF_STATE_DONE);
                                /* Make cur_frm pointing to next_frm */
 
 
                if (waitqueue_active(&buf->vb.done)) {
                        list_del(&buf->vb.queue);
-                       do_gettimeofday(&buf->vb.ts);
+                       v4l2_get_timestamp(&buf->vb.ts);
                        buf->vb.state = VIDEOBUF_DONE;
                        buf->vb.field_count++;
                        wake_up(&buf->vb.done);
 
                return;
 
        spin_lock(&vout->vbq_lock);
-       do_gettimeofday(&timevalue);
+       v4l2_get_timestamp(&timevalue);
 
        switch (cur_display->type) {
        case OMAP_DISPLAY_TYPE_DSI:
 
                omap24xxcam_core_disable(cam);
        spin_unlock_irqrestore(&cam->core_enable_disable_lock, flags);
 
-       do_gettimeofday(&vb->ts);
+       v4l2_get_timestamp(&vb->ts);
        vb->field_count = atomic_add_return(2, &fh->field_count);
        if (csr & csr_error) {
                vb->state = VIDEOBUF_ERROR;
 
        list_del(&vb->queue);
 
        vb->state = VIDEOBUF_DONE;
-       do_gettimeofday(&vb->ts);
+       v4l2_get_timestamp(&vb->ts);
        vb->field_count++;
        wake_up(&vb->done);
 
 
                struct frame_buffer *buf = isi->active;
 
                list_del_init(&buf->list);
-               do_gettimeofday(&vb->v4l2_buf.timestamp);
+               v4l2_get_timestamp(&vb->v4l2_buf.timestamp);
                vb->v4l2_buf.sequence = isi->sequence++;
                vb2_buffer_done(vb, VB2_BUF_STATE_DONE);
        }
 
        /* _init is used to debug races, see comment in mx1_camera_reqbufs() */
        list_del_init(&vb->queue);
        vb->state = VIDEOBUF_DONE;
-       do_gettimeofday(&vb->ts);
+       v4l2_get_timestamp(&vb->ts);
        vb->field_count++;
        wake_up(&vb->done);
 
 
        dev_dbg(pcdev->dev, "%s (vb=0x%p) 0x%p %lu\n", __func__,
                vb, vb2_plane_vaddr(vb, 0), vb2_get_plane_payload(vb, 0));
 
-       do_gettimeofday(&vb->v4l2_buf.timestamp);
+       v4l2_get_timestamp(&vb->v4l2_buf.timestamp);
        vb->v4l2_buf.sequence++;
        vb2_buffer_done(vb, VB2_BUF_STATE_DONE);
 
                                vb2_get_plane_payload(vb, 0));
 
                list_del_init(&buf->internal.queue);
-               do_gettimeofday(&vb->v4l2_buf.timestamp);
+               v4l2_get_timestamp(&vb->v4l2_buf.timestamp);
                vb->v4l2_buf.sequence = pcdev->frame_count;
                if (err)
                        vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
 
                struct mx3_camera_buffer *buf = to_mx3_vb(vb);
 
                list_del_init(&buf->queue);
-               do_gettimeofday(&vb->v4l2_buf.timestamp);
+               v4l2_get_timestamp(&vb->v4l2_buf.timestamp);
                vb->v4l2_buf.field = mx3_cam->field;
                vb->v4l2_buf.sequence = mx3_cam->sequence++;
                vb2_buffer_done(vb, VB2_BUF_STATE_DONE);
 
                        suspend_capture(pcdev);
                }
                vb->state = result;
-               do_gettimeofday(&vb->ts);
+               v4l2_get_timestamp(&vb->ts);
                if (result != VIDEOBUF_ERROR)
                        vb->field_count++;
                wake_up(&vb->done);
 
        /* _init is used to debug races, see comment in pxa_camera_reqbufs() */
        list_del_init(&vb->queue);
        vb->state = VIDEOBUF_DONE;
-       do_gettimeofday(&vb->ts);
+       v4l2_get_timestamp(&vb->ts);
        vb->field_count++;
        wake_up(&vb->done);
        dev_dbg(pcdev->soc_host.v4l2_dev.dev, "%s dequeud buffer (vb=0x%p)\n",
 
                pcdev->active = NULL;
 
        ret = sh_mobile_ceu_capture(pcdev);
-       do_gettimeofday(&vb->v4l2_buf.timestamp);
+       v4l2_get_timestamp(&vb->v4l2_buf.timestamp);
        if (!ret) {
                vb->v4l2_buf.field = pcdev->field;
                vb->v4l2_buf.sequence = pcdev->sequence++;
 
 
        if (vb->state != VIDEOBUF_ERROR) {
                list_del(&vb->queue);
-               do_gettimeofday(&vb->ts);
+               v4l2_get_timestamp(&vb->ts);
                vb->field_count = fh->frame_count * 2;
                vb->state = VIDEOBUF_DONE;
 
 
 
                if ((!handled_a) && (done_a || skip_a)) {
                        if (!skip_a) {
-                               do_gettimeofday(&vino_drvdata->
-                                               a.int_data.timestamp);
+                               v4l2_get_timestamp(
+                                       &vino_drvdata->a.int_data.timestamp);
                                vino_drvdata->a.int_data.frame_counter = fc_a;
                        }
                        vino_drvdata->a.int_data.skip = skip_a;
 
                if ((!handled_b) && (done_b || skip_b)) {
                        if (!skip_b) {
-                               do_gettimeofday(&vino_drvdata->
-                                               b.int_data.timestamp);
+                               v4l2_get_timestamp(
+                                       &vino_drvdata->b.int_data.timestamp);
                                vino_drvdata->b.int_data.frame_counter = fc_b;
                        }
                        vino_drvdata->b.int_data.skip = skip_b;
 
 {
        int wmax = dev->width;
        int hmax = dev->height;
-       struct timeval ts;
        void *vbuf = vb2_plane_vaddr(&buf->vb, 0);
        unsigned ms;
        char str[100];
        buf->vb.v4l2_buf.field = V4L2_FIELD_INTERLACED;
        dev->field_count++;
        buf->vb.v4l2_buf.sequence = dev->field_count >> 1;
-       do_gettimeofday(&ts);
-       buf->vb.v4l2_buf.timestamp = ts;
+       v4l2_get_timestamp(&buf->vb.v4l2_buf.timestamp);
 }
 
 static void vivi_thread_tick(struct vivi_dev *dev)
        list_del(&buf->list);
        spin_unlock_irqrestore(&dev->slock, flags);
 
-       do_gettimeofday(&buf->vb.v4l2_buf.timestamp);
+       v4l2_get_timestamp(&buf->vb.v4l2_buf.timestamp);
 
        /* Fill buffer */
        vivi_fillbuff(dev, buf);
 
 
        buf->vb.state = VIDEOBUF_DONE;
        buf->vb.field_count++;
-       do_gettimeofday(&buf->vb.ts);
+       v4l2_get_timestamp(&buf->vb.ts);
 
        dev->isoc_ctl.buf = NULL;
 
 
        buf->vb.state = VIDEOBUF_DONE;
        buf->vb.field_count++;
-       do_gettimeofday(&buf->vb.ts);
+       v4l2_get_timestamp(&buf->vb.ts);
 
        dev->isoc_ctl.vbi_buf = NULL;
 
 
                                continue;
                        }
                        DBG("Start of frame pattern found\n");
-                       do_gettimeofday(&cam->workbuff->timestamp);
+                       v4l2_get_timestamp(&cam->workbuff->timestamp);
                        cam->workbuff->seq = cam->frame_count++;
                        cam->workbuff->data[0] = 0xFF;
                        cam->workbuff->data[1] = 0xD8;
 
 
                        buf->vb.state = VIDEOBUF_DONE;
                        buf->vb.field_count++;
-                       do_gettimeofday(&buf->vb.ts);
+                       v4l2_get_timestamp(&buf->vb.ts);
                        list_del(&buf->vb.queue);
                        wake_up(&buf->vb.done);
                        dma_q->mpeg_buffer_completed = 0;
                memcpy(vbuf, data, len);
                buf->vb.state = VIDEOBUF_DONE;
                buf->vb.field_count++;
-               do_gettimeofday(&buf->vb.ts);
+               v4l2_get_timestamp(&buf->vb.ts);
                list_del(&buf->vb.queue);
                wake_up(&buf->vb.done);
 
 
 
        buf->vb.state = VIDEOBUF_DONE;
        buf->vb.field_count++;
-       do_gettimeofday(&buf->vb.ts);
+       v4l2_get_timestamp(&buf->vb.ts);
 
        dev->vbi_mode.bulk_ctl.buf = NULL;
 
 
        cx231xx_isocdbg("[%p/%d] wakeup\n", buf, buf->vb.i);
        buf->vb.state = VIDEOBUF_DONE;
        buf->vb.field_count++;
-       do_gettimeofday(&buf->vb.ts);
+       v4l2_get_timestamp(&buf->vb.ts);
 
        if (dev->USE_ISO)
                dev->video_mode.isoc_ctl.buf = NULL;
 
        em28xx_isocdbg("[%p/%d] wakeup\n", buf, buf->vb.i);
        buf->vb.state = VIDEOBUF_DONE;
        buf->vb.field_count++;
-       do_gettimeofday(&buf->vb.ts);
+       v4l2_get_timestamp(&buf->vb.ts);
 
        dev->isoc_ctl.vid_buf = NULL;
 
 
        buf->vb.state = VIDEOBUF_DONE;
        buf->vb.field_count++;
-       do_gettimeofday(&buf->vb.ts);
+       v4l2_get_timestamp(&buf->vb.ts);
 
        dev->isoc_ctl.vbi_buf = NULL;
 
 
                        struct pwc_frame_buf *fbuf = pdev->fill_buf;
 
                        if (pdev->vsync == 1) {
-                               do_gettimeofday(&fbuf->vb.v4l2_buf.timestamp);
+                               v4l2_get_timestamp(
+                                       &fbuf->vb.v4l2_buf.timestamp);
                                pdev->vsync = 2;
                        }
 
 
        buf = list_entry(dma_q->active.next,
                         struct s2255_buffer, vb.queue);
        list_del(&buf->vb.queue);
-       do_gettimeofday(&buf->vb.ts);
+       v4l2_get_timestamp(&buf->vb.ts);
        s2255_fillbuff(channel, buf, jpgsize);
        wake_up(&buf->vb.done);
        dprintk(2, "%s: [buf/i] [%p/%d]\n", __func__, buf, buf->vb.i);
                           struct s2255_buffer *buf, int jpgsize)
 {
        int pos = 0;
-       struct timeval ts;
        const char *tmpbuf;
        char *vbuf = videobuf_to_vmalloc(&buf->vb);
        unsigned long last_frame;
        /* tell v4l buffer was filled */
 
        buf->vb.field_count = channel->frame_count * 2;
-       do_gettimeofday(&ts);
-       buf->vb.ts = ts;
+       v4l2_get_timestamp(&buf->vb.ts);
        buf->vb.state = VIDEOBUF_DONE;
 }
 
 
                                       img);
 
                                if ((*f)->buf.bytesused == 0)
-                                       do_gettimeofday(&(*f)->buf.timestamp);
+                                       v4l2_get_timestamp(
+                                               &(*f)->buf.timestamp);
 
                                (*f)->buf.bytesused += img;
 
 
        buf->vb.v4l2_buf.sequence = dev->field_count >> 1;
        buf->vb.v4l2_buf.field = V4L2_FIELD_INTERLACED;
        buf->vb.v4l2_buf.bytesused = buf->bytesused;
-       do_gettimeofday(&buf->vb.v4l2_buf.timestamp);
+       v4l2_get_timestamp(&buf->vb.v4l2_buf.timestamp);
 
        vb2_set_plane_payload(&buf->vb, 0, buf->bytesused);
        vb2_buffer_done(&buf->vb, VB2_BUF_STATE_DONE);
 
        sbuf->v4lbuf.flags &= ~V4L2_BUF_FLAG_QUEUED;
        sbuf->v4lbuf.flags |= V4L2_BUF_FLAG_DONE;
        sbuf->v4lbuf.sequence = ++dev->sequence;
-       do_gettimeofday(&sbuf->v4lbuf.timestamp);
+       v4l2_get_timestamp(&sbuf->v4lbuf.timestamp);
 
        *buf = sbuf->v4lbuf;
        return 0;
 
        front->curr_frame       = NULL;
        vb->state               = VIDEOBUF_DONE;
        vb->field_count++;
-       do_gettimeofday(&vb->ts);
+       v4l2_get_timestamp(&vb->ts);
 
        wake_up(&vb->done);
 }
 
        dprintk(dev, V4L2_DEBUG_ISOC, "[%p/%d] wakeup\n", buf, buf->vb.i);
        buf->vb.state = VIDEOBUF_DONE;
        buf->vb.field_count++;
-       do_gettimeofday(&buf->vb.ts);
+       v4l2_get_timestamp(&buf->vb.ts);
 
        list_del(&buf->vb.queue);
        wake_up(&buf->vb.done);
 
 
        if (newstate == parse_state_next_frame) {
                frame->grabstate = frame_state_done;
-               do_gettimeofday(&(frame->timestamp));
+               v4l2_get_timestamp(&(frame->timestamp));
                frame->sequence = usbvision->frame_num;
 
                spin_lock_irqsave(&usbvision->queue_lock, lock_flags);
 
                             int jpgsize)
 {
        int pos = 0;
-       struct timeval ts;
        const char *tmpbuf;
        char *vbuf = videobuf_to_vmalloc(&buf->vb);
        unsigned long last_frame;
        /* tell v4l buffer was filled */
 
        buf->vb.field_count = cam->frame_count * 2;
-       do_gettimeofday(&ts);
-       buf->vb.ts = ts;
+       v4l2_get_timestamp(&buf->vb.ts);
        buf->vb.state = VIDEOBUF_DONE;
 }
 
                goto unlock;
        }
        list_del(&buf->vb.queue);
-       do_gettimeofday(&buf->vb.ts);
+       v4l2_get_timestamp(&buf->vb.ts);
        DBG("[%p/%d] wakeup\n", buf, buf->vb.i);
        zr364xx_fillbuff(cam, buf, jpgsize);
        wake_up(&buf->vb.done);