Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
fimc-capture.c
Go to the documentation of this file.
1 /*
2  * Samsung S5P/EXYNOS4 SoC series camera interface (camera capture) driver
3  *
4  * Copyright (C) 2010 - 2012 Samsung Electronics Co., Ltd.
5  * Sylwester Nawrocki <[email protected]>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  */
11 
12 #include <linux/module.h>
13 #include <linux/kernel.h>
14 #include <linux/types.h>
15 #include <linux/errno.h>
16 #include <linux/bug.h>
17 #include <linux/interrupt.h>
18 #include <linux/device.h>
19 #include <linux/pm_runtime.h>
20 #include <linux/list.h>
21 #include <linux/slab.h>
22 
23 #include <linux/videodev2.h>
24 #include <media/v4l2-device.h>
25 #include <media/v4l2-ioctl.h>
26 #include <media/v4l2-mem2mem.h>
27 #include <media/videobuf2-core.h>
29 
30 #include "fimc-mdevice.h"
31 #include "fimc-core.h"
32 #include "fimc-reg.h"
33 
34 static int fimc_capture_hw_init(struct fimc_dev *fimc)
35 {
36  struct fimc_ctx *ctx = fimc->vid_cap.ctx;
37  struct fimc_pipeline *p = &fimc->pipeline;
38  struct fimc_sensor_info *sensor;
39  unsigned long flags;
40  int ret = 0;
41 
42  if (p->subdevs[IDX_SENSOR] == NULL || ctx == NULL)
43  return -ENXIO;
44  if (ctx->s_frame.fmt == NULL)
45  return -EINVAL;
46 
47  sensor = v4l2_get_subdev_hostdata(p->subdevs[IDX_SENSOR]);
48 
49  spin_lock_irqsave(&fimc->slock, flags);
50  fimc_prepare_dma_offset(ctx, &ctx->d_frame);
51  fimc_set_yuv_order(ctx);
52 
53  fimc_hw_set_camera_polarity(fimc, &sensor->pdata);
54  fimc_hw_set_camera_type(fimc, &sensor->pdata);
55  fimc_hw_set_camera_source(fimc, &sensor->pdata);
57 
58  ret = fimc_set_scaler_info(ctx);
59  if (!ret) {
65  fimc_hw_set_effect(ctx);
68  if (fimc->variant->has_alpha)
71  }
72  spin_unlock_irqrestore(&fimc->slock, flags);
73  return ret;
74 }
75 
76 /*
77  * Reinitialize the driver so it is ready to start the streaming again.
78  * Set fimc->state to indicate stream off and the hardware shut down state.
79  * If not suspending (@suspend is false), return any buffers to videobuf2.
80  * Otherwise put any owned buffers onto the pending buffers queue, so they
81  * can be re-spun when the device is being resumed. Also perform FIMC
82  * software reset and disable streaming on the whole pipeline if required.
83  */
84 static int fimc_capture_state_cleanup(struct fimc_dev *fimc, bool suspend)
85 {
86  struct fimc_vid_cap *cap = &fimc->vid_cap;
87  struct fimc_vid_buffer *buf;
88  unsigned long flags;
89  bool streaming;
90 
91  spin_lock_irqsave(&fimc->slock, flags);
92  streaming = fimc->state & (1 << ST_CAPT_ISP_STREAM);
93 
94  fimc->state &= ~(1 << ST_CAPT_RUN | 1 << ST_CAPT_SHUT |
96  if (suspend)
97  fimc->state |= (1 << ST_CAPT_SUSPENDED);
98  else
99  fimc->state &= ~(1 << ST_CAPT_PEND | 1 << ST_CAPT_SUSPENDED);
100 
101  /* Release unused buffers */
102  while (!suspend && !list_empty(&cap->pending_buf_q)) {
103  buf = fimc_pending_queue_pop(cap);
105  }
106  /* If suspending put unused buffers onto pending queue */
107  while (!list_empty(&cap->active_buf_q)) {
108  buf = fimc_active_queue_pop(cap);
109  if (suspend)
110  fimc_pending_queue_add(cap, buf);
111  else
113  }
114 
115  fimc_hw_reset(fimc);
116  cap->buf_index = 0;
117 
118  spin_unlock_irqrestore(&fimc->slock, flags);
119 
120  if (streaming)
121  return fimc_pipeline_call(fimc, set_stream,
122  &fimc->pipeline, 0);
123  else
124  return 0;
125 }
126 
127 static int fimc_stop_capture(struct fimc_dev *fimc, bool suspend)
128 {
129  unsigned long flags;
130 
131  if (!fimc_capture_active(fimc))
132  return 0;
133 
134  spin_lock_irqsave(&fimc->slock, flags);
135  set_bit(ST_CAPT_SHUT, &fimc->state);
137  spin_unlock_irqrestore(&fimc->slock, flags);
138 
140  !test_bit(ST_CAPT_SHUT, &fimc->state),
141  (2*HZ/10)); /* 200 ms */
142 
143  return fimc_capture_state_cleanup(fimc, suspend);
144 }
145 
153 static int fimc_capture_config_update(struct fimc_ctx *ctx)
154 {
155  struct fimc_dev *fimc = ctx->fimc_dev;
156  int ret;
157 
158  fimc_hw_set_camera_offset(fimc, &ctx->s_frame);
159 
160  ret = fimc_set_scaler_info(ctx);
161  if (ret)
162  return ret;
163 
168  fimc_hw_set_effect(ctx);
169  fimc_prepare_dma_offset(ctx, &ctx->d_frame);
170  fimc_hw_set_out_dma(ctx);
171  if (fimc->variant->has_alpha)
173 
175  return ret;
176 }
177 
178 void fimc_capture_irq_handler(struct fimc_dev *fimc, int deq_buf)
179 {
180  struct v4l2_subdev *csis = fimc->pipeline.subdevs[IDX_CSIS];
181  struct fimc_vid_cap *cap = &fimc->vid_cap;
182  struct fimc_frame *f = &cap->ctx->d_frame;
183  struct fimc_vid_buffer *v_buf;
184  struct timeval *tv;
185  struct timespec ts;
186 
187  if (test_and_clear_bit(ST_CAPT_SHUT, &fimc->state)) {
188  wake_up(&fimc->irq_queue);
189  goto done;
190  }
191 
192  if (!list_empty(&cap->active_buf_q) &&
193  test_bit(ST_CAPT_RUN, &fimc->state) && deq_buf) {
194  ktime_get_real_ts(&ts);
195 
196  v_buf = fimc_active_queue_pop(cap);
197 
198  tv = &v_buf->vb.v4l2_buf.timestamp;
199  tv->tv_sec = ts.tv_sec;
200  tv->tv_usec = ts.tv_nsec / NSEC_PER_USEC;
201  v_buf->vb.v4l2_buf.sequence = cap->frame_count++;
202 
204  }
205 
206  if (!list_empty(&cap->pending_buf_q)) {
207 
208  v_buf = fimc_pending_queue_pop(cap);
209  fimc_hw_set_output_addr(fimc, &v_buf->paddr, cap->buf_index);
210  v_buf->index = cap->buf_index;
211 
212  /* Move the buffer to the capture active queue */
213  fimc_active_queue_add(cap, v_buf);
214 
215  dbg("next frame: %d, done frame: %d",
216  fimc_hw_get_frame_index(fimc), v_buf->index);
217 
218  if (++cap->buf_index >= FIMC_MAX_OUT_BUFS)
219  cap->buf_index = 0;
220  }
221  /*
222  * Set up a buffer at MIPI-CSIS if current image format
223  * requires the frame embedded data capture.
224  */
225  if (f->fmt->mdataplanes && !list_empty(&cap->active_buf_q)) {
226  unsigned int plane = ffs(f->fmt->mdataplanes) - 1;
227  unsigned int size = f->payload[plane];
229  void *vaddr;
230 
231  list_for_each_entry(v_buf, &cap->active_buf_q, list) {
232  if (v_buf->index != index)
233  continue;
234  vaddr = vb2_plane_vaddr(&v_buf->vb, plane);
235  v4l2_subdev_call(csis, video, s_rx_buffer,
236  vaddr, &size);
237  break;
238  }
239  }
240 
241  if (cap->active_buf_cnt == 0) {
242  if (deq_buf)
243  clear_bit(ST_CAPT_RUN, &fimc->state);
244 
245  if (++cap->buf_index >= FIMC_MAX_OUT_BUFS)
246  cap->buf_index = 0;
247  } else {
248  set_bit(ST_CAPT_RUN, &fimc->state);
249  }
250 
251  if (test_bit(ST_CAPT_APPLY_CFG, &fimc->state))
252  fimc_capture_config_update(cap->ctx);
253 done:
254  if (cap->active_buf_cnt == 1) {
256  clear_bit(ST_CAPT_STREAM, &fimc->state);
257  }
258 
259  dbg("frame: %d, active_buf_cnt: %d",
261 }
262 
263 
264 static int start_streaming(struct vb2_queue *q, unsigned int count)
265 {
266  struct fimc_ctx *ctx = q->drv_priv;
267  struct fimc_dev *fimc = ctx->fimc_dev;
268  struct fimc_vid_cap *vid_cap = &fimc->vid_cap;
269  int min_bufs;
270  int ret;
271 
272  vid_cap->frame_count = 0;
273 
274  ret = fimc_capture_hw_init(fimc);
275  if (ret) {
276  fimc_capture_state_cleanup(fimc, false);
277  return ret;
278  }
279 
280  set_bit(ST_CAPT_PEND, &fimc->state);
281 
282  min_bufs = fimc->vid_cap.reqbufs_count > 1 ? 2 : 1;
283 
284  if (vid_cap->active_buf_cnt >= min_bufs &&
287 
289  fimc_pipeline_call(fimc, set_stream,
290  &fimc->pipeline, 1);
291  }
292 
293  return 0;
294 }
295 
296 static int stop_streaming(struct vb2_queue *q)
297 {
298  struct fimc_ctx *ctx = q->drv_priv;
299  struct fimc_dev *fimc = ctx->fimc_dev;
300 
301  if (!fimc_capture_active(fimc))
302  return -EINVAL;
303 
304  return fimc_stop_capture(fimc, false);
305 }
306 
308 {
309  bool suspend = fimc_capture_busy(fimc);
310 
311  int ret = fimc_stop_capture(fimc, suspend);
312  if (ret)
313  return ret;
314  return fimc_pipeline_call(fimc, close, &fimc->pipeline);
315 }
316 
317 static void buffer_queue(struct vb2_buffer *vb);
318 
319 int fimc_capture_resume(struct fimc_dev *fimc)
320 {
321  struct fimc_vid_cap *vid_cap = &fimc->vid_cap;
322  struct fimc_vid_buffer *buf;
323  int i;
324 
326  return 0;
327 
328  INIT_LIST_HEAD(&fimc->vid_cap.active_buf_q);
329  vid_cap->buf_index = 0;
330  fimc_pipeline_call(fimc, open, &fimc->pipeline,
331  &vid_cap->vfd.entity, false);
332  fimc_capture_hw_init(fimc);
333 
335 
336  for (i = 0; i < vid_cap->reqbufs_count; i++) {
337  if (list_empty(&vid_cap->pending_buf_q))
338  break;
339  buf = fimc_pending_queue_pop(vid_cap);
340  buffer_queue(&buf->vb);
341  }
342  return 0;
343 
344 }
345 
346 static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *pfmt,
347  unsigned int *num_buffers, unsigned int *num_planes,
348  unsigned int sizes[], void *allocators[])
349 {
350  const struct v4l2_pix_format_mplane *pixm = NULL;
351  struct fimc_ctx *ctx = vq->drv_priv;
352  struct fimc_frame *frame = &ctx->d_frame;
353  struct fimc_fmt *fmt = frame->fmt;
354  unsigned long wh;
355  int i;
356 
357  if (pfmt) {
358  pixm = &pfmt->fmt.pix_mp;
359  fmt = fimc_find_format(&pixm->pixelformat, NULL,
361  wh = pixm->width * pixm->height;
362  } else {
363  wh = frame->f_width * frame->f_height;
364  }
365 
366  if (fmt == NULL)
367  return -EINVAL;
368 
369  *num_planes = fmt->memplanes;
370 
371  for (i = 0; i < fmt->memplanes; i++) {
372  unsigned int size = (wh * fmt->depth[i]) / 8;
373  if (pixm)
374  sizes[i] = max(size, pixm->plane_fmt[i].sizeimage);
375  else if (fimc_fmt_is_user_defined(fmt->color))
376  sizes[i] = frame->payload[i];
377  else
378  sizes[i] = max_t(u32, size, frame->payload[i]);
379 
380  allocators[i] = ctx->fimc_dev->alloc_ctx;
381  }
382 
383  return 0;
384 }
385 
386 static int buffer_prepare(struct vb2_buffer *vb)
387 {
388  struct vb2_queue *vq = vb->vb2_queue;
389  struct fimc_ctx *ctx = vq->drv_priv;
390  int i;
391 
392  if (ctx->d_frame.fmt == NULL)
393  return -EINVAL;
394 
395  for (i = 0; i < ctx->d_frame.fmt->memplanes; i++) {
396  unsigned long size = ctx->d_frame.payload[i];
397 
398  if (vb2_plane_size(vb, i) < size) {
399  v4l2_err(&ctx->fimc_dev->vid_cap.vfd,
400  "User buffer too small (%ld < %ld)\n",
401  vb2_plane_size(vb, i), size);
402  return -EINVAL;
403  }
404  vb2_set_plane_payload(vb, i, size);
405  }
406 
407  return 0;
408 }
409 
410 static void buffer_queue(struct vb2_buffer *vb)
411 {
412  struct fimc_vid_buffer *buf
413  = container_of(vb, struct fimc_vid_buffer, vb);
414  struct fimc_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
415  struct fimc_dev *fimc = ctx->fimc_dev;
416  struct fimc_vid_cap *vid_cap = &fimc->vid_cap;
417  unsigned long flags;
418  int min_bufs;
419 
420  spin_lock_irqsave(&fimc->slock, flags);
421  fimc_prepare_addr(ctx, &buf->vb, &ctx->d_frame, &buf->paddr);
422 
423  if (!test_bit(ST_CAPT_SUSPENDED, &fimc->state) &&
424  !test_bit(ST_CAPT_STREAM, &fimc->state) &&
425  vid_cap->active_buf_cnt < FIMC_MAX_OUT_BUFS) {
426  /* Setup the buffer directly for processing. */
427  int buf_id = (vid_cap->reqbufs_count == 1) ? -1 :
428  vid_cap->buf_index;
429 
430  fimc_hw_set_output_addr(fimc, &buf->paddr, buf_id);
431  buf->index = vid_cap->buf_index;
432  fimc_active_queue_add(vid_cap, buf);
433 
434  if (++vid_cap->buf_index >= FIMC_MAX_OUT_BUFS)
435  vid_cap->buf_index = 0;
436  } else {
437  fimc_pending_queue_add(vid_cap, buf);
438  }
439 
440  min_bufs = vid_cap->reqbufs_count > 1 ? 2 : 1;
441 
442 
443  if (vb2_is_streaming(&vid_cap->vbq) &&
444  vid_cap->active_buf_cnt >= min_bufs &&
447  spin_unlock_irqrestore(&fimc->slock, flags);
448 
450  fimc_pipeline_call(fimc, set_stream,
451  &fimc->pipeline, 1);
452  return;
453  }
454  spin_unlock_irqrestore(&fimc->slock, flags);
455 }
456 
457 static void fimc_lock(struct vb2_queue *vq)
458 {
459  struct fimc_ctx *ctx = vb2_get_drv_priv(vq);
460  mutex_lock(&ctx->fimc_dev->lock);
461 }
462 
463 static void fimc_unlock(struct vb2_queue *vq)
464 {
465  struct fimc_ctx *ctx = vb2_get_drv_priv(vq);
466  mutex_unlock(&ctx->fimc_dev->lock);
467 }
468 
469 static struct vb2_ops fimc_capture_qops = {
470  .queue_setup = queue_setup,
471  .buf_prepare = buffer_prepare,
472  .buf_queue = buffer_queue,
473  .wait_prepare = fimc_unlock,
474  .wait_finish = fimc_lock,
475  .start_streaming = start_streaming,
476  .stop_streaming = stop_streaming,
477 };
478 
487 {
488  struct fimc_vid_cap *vid_cap = &fimc->vid_cap;
489  int ret;
490 
491  if (WARN_ON(vid_cap->ctx == NULL))
492  return -ENXIO;
493  if (vid_cap->ctx->ctrls.ready)
494  return 0;
495 
496  ret = fimc_ctrls_create(vid_cap->ctx);
497  if (ret || vid_cap->user_subdev_api || !vid_cap->ctx->ctrls.ready)
498  return ret;
499 
500  return v4l2_ctrl_add_handler(&vid_cap->ctx->ctrls.handler,
501  fimc->pipeline.subdevs[IDX_SENSOR]->ctrl_handler, NULL);
502 }
503 
504 static int fimc_capture_set_default_format(struct fimc_dev *fimc);
505 
506 static int fimc_capture_open(struct file *file)
507 {
508  struct fimc_dev *fimc = video_drvdata(file);
509  int ret = -EBUSY;
510 
511  dbg("pid: %d, state: 0x%lx", task_pid_nr(current), fimc->state);
512 
513  if (mutex_lock_interruptible(&fimc->lock))
514  return -ERESTARTSYS;
515 
516  if (fimc_m2m_active(fimc))
517  goto unlock;
518 
519  set_bit(ST_CAPT_BUSY, &fimc->state);
520  ret = pm_runtime_get_sync(&fimc->pdev->dev);
521  if (ret < 0)
522  goto unlock;
523 
524  ret = v4l2_fh_open(file);
525  if (ret) {
526  pm_runtime_put(&fimc->pdev->dev);
527  goto unlock;
528  }
529 
530  if (++fimc->vid_cap.refcnt == 1) {
531  ret = fimc_pipeline_call(fimc, open, &fimc->pipeline,
532  &fimc->vid_cap.vfd.entity, true);
533 
534  if (!ret && !fimc->vid_cap.user_subdev_api)
535  ret = fimc_capture_set_default_format(fimc);
536 
537  if (!ret)
538  ret = fimc_capture_ctrls_create(fimc);
539 
540  if (ret < 0) {
541  clear_bit(ST_CAPT_BUSY, &fimc->state);
542  pm_runtime_put_sync(&fimc->pdev->dev);
543  fimc->vid_cap.refcnt--;
544  v4l2_fh_release(file);
545  }
546  }
547 unlock:
548  mutex_unlock(&fimc->lock);
549  return ret;
550 }
551 
552 static int fimc_capture_close(struct file *file)
553 {
554  struct fimc_dev *fimc = video_drvdata(file);
555  int ret;
556 
557  dbg("pid: %d, state: 0x%lx", task_pid_nr(current), fimc->state);
558 
559  mutex_lock(&fimc->lock);
560 
561  if (--fimc->vid_cap.refcnt == 0) {
562  clear_bit(ST_CAPT_BUSY, &fimc->state);
563  fimc_stop_capture(fimc, false);
564  fimc_pipeline_call(fimc, close, &fimc->pipeline);
566  }
567 
568  pm_runtime_put(&fimc->pdev->dev);
569 
570  if (fimc->vid_cap.refcnt == 0) {
571  vb2_queue_release(&fimc->vid_cap.vbq);
572  fimc_ctrls_delete(fimc->vid_cap.ctx);
573  }
574 
575  ret = v4l2_fh_release(file);
576 
577  mutex_unlock(&fimc->lock);
578  return ret;
579 }
580 
581 static unsigned int fimc_capture_poll(struct file *file,
582  struct poll_table_struct *wait)
583 {
584  struct fimc_dev *fimc = video_drvdata(file);
585  int ret;
586 
587  if (mutex_lock_interruptible(&fimc->lock))
588  return POLL_ERR;
589 
590  ret = vb2_poll(&fimc->vid_cap.vbq, file, wait);
591  mutex_unlock(&fimc->lock);
592 
593  return ret;
594 }
595 
596 static int fimc_capture_mmap(struct file *file, struct vm_area_struct *vma)
597 {
598  struct fimc_dev *fimc = video_drvdata(file);
599  int ret;
600 
601  if (mutex_lock_interruptible(&fimc->lock))
602  return -ERESTARTSYS;
603 
604  ret = vb2_mmap(&fimc->vid_cap.vbq, vma);
605  mutex_unlock(&fimc->lock);
606 
607  return ret;
608 }
609 
610 static const struct v4l2_file_operations fimc_capture_fops = {
611  .owner = THIS_MODULE,
612  .open = fimc_capture_open,
613  .release = fimc_capture_close,
614  .poll = fimc_capture_poll,
615  .unlocked_ioctl = video_ioctl2,
616  .mmap = fimc_capture_mmap,
617 };
618 
619 /*
620  * Format and crop negotiation helpers
621  */
622 
623 static struct fimc_fmt *fimc_capture_try_format(struct fimc_ctx *ctx,
624  u32 *width, u32 *height,
625  u32 *code, u32 *fourcc, int pad)
626 {
627  bool rotation = ctx->rotation == 90 || ctx->rotation == 270;
628  struct fimc_dev *fimc = ctx->fimc_dev;
629  struct fimc_variant *var = fimc->variant;
630  struct fimc_pix_limit *pl = var->pix_limit;
631  struct fimc_frame *dst = &ctx->d_frame;
632  u32 depth, min_w, max_w, min_h, align_h = 3;
634  struct fimc_fmt *ffmt;
635 
636  /* Conversion from/to JPEG or User Defined format is not supported */
637  if (code && ctx->s_frame.fmt && pad == FIMC_SD_PAD_SOURCE &&
638  fimc_fmt_is_user_defined(ctx->s_frame.fmt->color))
639  *code = ctx->s_frame.fmt->mbus_code;
640 
641  if (fourcc && *fourcc != V4L2_PIX_FMT_JPEG && pad != FIMC_SD_PAD_SINK)
642  mask |= FMT_FLAGS_M2M;
643 
644  ffmt = fimc_find_format(fourcc, code, mask, 0);
645  if (WARN_ON(!ffmt))
646  return NULL;
647  if (code)
648  *code = ffmt->mbus_code;
649  if (fourcc)
650  *fourcc = ffmt->fourcc;
651 
652  if (pad == FIMC_SD_PAD_SINK) {
653  max_w = fimc_fmt_is_user_defined(ffmt->color) ?
654  pl->scaler_dis_w : pl->scaler_en_w;
655  /* Apply the camera input interface pixel constraints */
656  v4l_bound_align_image(width, max_t(u32, *width, 32), max_w, 4,
657  height, max_t(u32, *height, 32),
660  3 : 1,
661  0);
662  return ffmt;
663  }
664  /* Can't scale or crop in transparent (JPEG) transfer mode */
665  if (fimc_fmt_is_user_defined(ffmt->color)) {
666  *width = ctx->s_frame.f_width;
667  *height = ctx->s_frame.f_height;
668  return ffmt;
669  }
670  /* Apply the scaler and the output DMA constraints */
671  max_w = rotation ? pl->out_rot_en_w : pl->out_rot_dis_w;
672  if (ctx->state & FIMC_COMPOSE) {
673  min_w = dst->offs_h + dst->width;
674  min_h = dst->offs_v + dst->height;
675  } else {
676  min_w = var->min_out_pixsize;
677  min_h = var->min_out_pixsize;
678  }
679  if (var->min_vsize_align == 1 && !rotation)
680  align_h = fimc_fmt_is_rgb(ffmt->color) ? 0 : 1;
681 
682  depth = fimc_get_format_depth(ffmt);
683  v4l_bound_align_image(width, min_w, max_w,
684  ffs(var->min_out_pixsize) - 1,
685  height, min_h, FIMC_CAMIF_MAX_HEIGHT,
686  align_h,
687  64/(ALIGN(depth, 8)));
688 
689  dbg("pad%d: code: 0x%x, %dx%d. dst fmt: %dx%d",
690  pad, code ? *code : 0, *width, *height,
691  dst->f_width, dst->f_height);
692 
693  return ffmt;
694 }
695 
696 static void fimc_capture_try_selection(struct fimc_ctx *ctx,
697  struct v4l2_rect *r,
698  int target)
699 {
700  bool rotate = ctx->rotation == 90 || ctx->rotation == 270;
701  struct fimc_dev *fimc = ctx->fimc_dev;
702  struct fimc_variant *var = fimc->variant;
703  struct fimc_pix_limit *pl = var->pix_limit;
704  struct fimc_frame *sink = &ctx->s_frame;
705  u32 max_w, max_h, min_w = 0, min_h = 0, min_sz;
706  u32 align_sz = 0, align_h = 4;
707  u32 max_sc_h, max_sc_v;
708 
709  /* In JPEG transparent transfer mode cropping is not supported */
710  if (fimc_fmt_is_user_defined(ctx->d_frame.fmt->color)) {
711  r->width = sink->f_width;
712  r->height = sink->f_height;
713  r->left = r->top = 0;
714  return;
715  }
716  if (target == V4L2_SEL_TGT_COMPOSE) {
717  if (ctx->rotation != 90 && ctx->rotation != 270)
718  align_h = 1;
719  max_sc_h = min(SCALER_MAX_HRATIO, 1 << (ffs(sink->width) - 3));
720  max_sc_v = min(SCALER_MAX_VRATIO, 1 << (ffs(sink->height) - 1));
721  min_sz = var->min_out_pixsize;
722  } else {
723  u32 depth = fimc_get_format_depth(sink->fmt);
724  align_sz = 64/ALIGN(depth, 8);
725  min_sz = var->min_inp_pixsize;
726  min_w = min_h = min_sz;
727  max_sc_h = max_sc_v = 1;
728  }
729  /*
730  * For the compose rectangle the following constraints must be met:
731  * - it must fit in the sink pad format rectangle (f_width/f_height);
732  * - maximum downscaling ratio is 64;
733  * - maximum crop size depends if the rotator is used or not;
734  * - the sink pad format width/height must be 4 multiple of the
735  * prescaler ratios determined by sink pad size and source pad crop,
736  * the prescaler ratio is returned by fimc_get_scaler_factor().
737  */
738  max_w = min_t(u32,
739  rotate ? pl->out_rot_en_w : pl->out_rot_dis_w,
740  rotate ? sink->f_height : sink->f_width);
741  max_h = min_t(u32, FIMC_CAMIF_MAX_HEIGHT, sink->f_height);
742 
743  if (target == V4L2_SEL_TGT_COMPOSE) {
744  min_w = min_t(u32, max_w, sink->f_width / max_sc_h);
745  min_h = min_t(u32, max_h, sink->f_height / max_sc_v);
746  if (rotate) {
747  swap(max_sc_h, max_sc_v);
748  swap(min_w, min_h);
749  }
750  }
751  v4l_bound_align_image(&r->width, min_w, max_w, ffs(min_sz) - 1,
752  &r->height, min_h, max_h, align_h,
753  align_sz);
754  /* Adjust left/top if crop/compose rectangle is out of bounds */
755  r->left = clamp_t(u32, r->left, 0, sink->f_width - r->width);
756  r->top = clamp_t(u32, r->top, 0, sink->f_height - r->height);
757  r->left = round_down(r->left, var->hor_offs_align);
758 
759  dbg("target %#x: (%d,%d)/%dx%d, sink fmt: %dx%d",
760  target, r->left, r->top, r->width, r->height,
761  sink->f_width, sink->f_height);
762 }
763 
764 /*
765  * The video node ioctl operations
766  */
767 static int fimc_vidioc_querycap_capture(struct file *file, void *priv,
768  struct v4l2_capability *cap)
769 {
770  struct fimc_dev *fimc = video_drvdata(file);
771 
772  strncpy(cap->driver, fimc->pdev->name, sizeof(cap->driver) - 1);
773  strncpy(cap->card, fimc->pdev->name, sizeof(cap->card) - 1);
774  cap->bus_info[0] = 0;
776 
777  return 0;
778 }
779 
780 static int fimc_cap_enum_fmt_mplane(struct file *file, void *priv,
781  struct v4l2_fmtdesc *f)
782 {
783  struct fimc_fmt *fmt;
784 
786  f->index);
787  if (!fmt)
788  return -EINVAL;
789  strncpy(f->description, fmt->name, sizeof(f->description) - 1);
790  f->pixelformat = fmt->fourcc;
791  if (fmt->fourcc == V4L2_MBUS_FMT_JPEG_1X8)
793  return 0;
794 }
795 
804 static int fimc_pipeline_try_format(struct fimc_ctx *ctx,
805  struct v4l2_mbus_framefmt *tfmt,
806  struct fimc_fmt **fmt_id,
807  bool set)
808 {
809  struct fimc_dev *fimc = ctx->fimc_dev;
810  struct v4l2_subdev *sd = fimc->pipeline.subdevs[IDX_SENSOR];
811  struct v4l2_subdev *csis = fimc->pipeline.subdevs[IDX_CSIS];
812  struct v4l2_subdev_format sfmt;
813  struct v4l2_mbus_framefmt *mf = &sfmt.format;
814  struct fimc_fmt *ffmt = NULL;
815  int ret, i = 0;
816 
817  if (WARN_ON(!sd || !tfmt))
818  return -EINVAL;
819 
820  memset(&sfmt, 0, sizeof(sfmt));
821  sfmt.format = *tfmt;
822 
824  while (1) {
825  ffmt = fimc_find_format(NULL, mf->code != 0 ? &mf->code : NULL,
826  FMT_FLAGS_CAM, i++);
827  if (ffmt == NULL) {
828  /*
829  * Notify user-space if common pixel code for
830  * host and sensor does not exist.
831  */
832  return -EINVAL;
833  }
834  mf->code = tfmt->code = ffmt->mbus_code;
835 
836  ret = v4l2_subdev_call(sd, pad, set_fmt, NULL, &sfmt);
837  if (ret)
838  return ret;
839  if (mf->code != tfmt->code) {
840  mf->code = 0;
841  continue;
842  }
843  if (mf->width != tfmt->width || mf->height != tfmt->height) {
844  u32 fcc = ffmt->fourcc;
845  tfmt->width = mf->width;
846  tfmt->height = mf->height;
847  ffmt = fimc_capture_try_format(ctx,
848  &tfmt->width, &tfmt->height,
849  NULL, &fcc, FIMC_SD_PAD_SOURCE);
850  if (ffmt && ffmt->mbus_code)
851  mf->code = ffmt->mbus_code;
852  if (mf->width != tfmt->width ||
853  mf->height != tfmt->height)
854  continue;
855  tfmt->code = mf->code;
856  }
857  if (csis)
858  ret = v4l2_subdev_call(csis, pad, set_fmt, NULL, &sfmt);
859 
860  if (mf->code == tfmt->code &&
861  mf->width == tfmt->width && mf->height == tfmt->height)
862  break;
863  }
864 
865  if (fmt_id && ffmt)
866  *fmt_id = ffmt;
867  *tfmt = *mf;
868 
869  dbg("code: 0x%x, %dx%d, %p", mf->code, mf->width, mf->height, ffmt);
870  return 0;
871 }
872 
881 static int fimc_get_sensor_frame_desc(struct v4l2_subdev *sensor,
883  unsigned int num_planes, bool try)
884 {
885  struct v4l2_mbus_frame_desc fd;
886  int i, ret;
887 
888  for (i = 0; i < num_planes; i++)
889  fd.entry[i].length = plane_fmt[i].sizeimage;
890 
891  if (try)
892  ret = v4l2_subdev_call(sensor, pad, set_frame_desc, 0, &fd);
893  else
894  ret = v4l2_subdev_call(sensor, pad, get_frame_desc, 0, &fd);
895 
896  if (ret < 0)
897  return ret;
898 
899  if (num_planes != fd.num_entries)
900  return -EINVAL;
901 
902  for (i = 0; i < num_planes; i++)
903  plane_fmt[i].sizeimage = fd.entry[i].length;
904 
905  if (fd.entry[0].length > FIMC_MAX_JPEG_BUF_SIZE) {
906  v4l2_err(sensor->v4l2_dev, "Unsupported buffer size: %u\n",
907  fd.entry[0].length);
908 
909  return -EINVAL;
910  }
911 
912  return 0;
913 }
914 
915 static int fimc_cap_g_fmt_mplane(struct file *file, void *fh,
916  struct v4l2_format *f)
917 {
918  struct fimc_dev *fimc = video_drvdata(file);
919  struct fimc_ctx *ctx = fimc->vid_cap.ctx;
920 
921  return fimc_fill_format(&ctx->d_frame, f);
922 }
923 
924 static int fimc_cap_try_fmt_mplane(struct file *file, void *fh,
925  struct v4l2_format *f)
926 {
927  struct v4l2_pix_format_mplane *pix = &f->fmt.pix_mp;
928  struct fimc_dev *fimc = video_drvdata(file);
929  struct fimc_ctx *ctx = fimc->vid_cap.ctx;
930  struct v4l2_mbus_framefmt mf;
931  struct fimc_fmt *ffmt = NULL;
932 
933  if (fimc_jpeg_fourcc(pix->pixelformat)) {
934  fimc_capture_try_format(ctx, &pix->width, &pix->height,
935  NULL, &pix->pixelformat,
937  ctx->s_frame.f_width = pix->width;
938  ctx->s_frame.f_height = pix->height;
939  }
940  ffmt = fimc_capture_try_format(ctx, &pix->width, &pix->height,
941  NULL, &pix->pixelformat,
943  if (!ffmt)
944  return -EINVAL;
945 
946  if (!fimc->vid_cap.user_subdev_api) {
947  mf.width = pix->width;
948  mf.height = pix->height;
949  mf.code = ffmt->mbus_code;
950  fimc_md_graph_lock(fimc);
951  fimc_pipeline_try_format(ctx, &mf, &ffmt, false);
952  fimc_md_graph_unlock(fimc);
953  pix->width = mf.width;
954  pix->height = mf.height;
955  if (ffmt)
956  pix->pixelformat = ffmt->fourcc;
957  }
958 
959  fimc_adjust_mplane_format(ffmt, pix->width, pix->height, pix);
960 
961  if (ffmt->flags & FMT_FLAGS_COMPRESSED)
962  fimc_get_sensor_frame_desc(fimc->pipeline.subdevs[IDX_SENSOR],
963  pix->plane_fmt, ffmt->memplanes, true);
964 
965  return 0;
966 }
967 
968 static void fimc_capture_mark_jpeg_xfer(struct fimc_ctx *ctx,
969  enum fimc_color_fmt color)
970 {
971  bool jpeg = fimc_fmt_is_user_defined(color);
972 
973  ctx->scaler.enabled = !jpeg;
974  fimc_ctrls_activate(ctx, !jpeg);
975 
976  if (jpeg)
977  set_bit(ST_CAPT_JPEG, &ctx->fimc_dev->state);
978  else
979  clear_bit(ST_CAPT_JPEG, &ctx->fimc_dev->state);
980 }
981 
982 static int fimc_capture_set_format(struct fimc_dev *fimc, struct v4l2_format *f)
983 {
984  struct fimc_ctx *ctx = fimc->vid_cap.ctx;
985  struct v4l2_pix_format_mplane *pix = &f->fmt.pix_mp;
986  struct v4l2_mbus_framefmt *mf = &fimc->vid_cap.mf;
987  struct fimc_frame *ff = &ctx->d_frame;
988  struct fimc_fmt *s_fmt = NULL;
989  int ret, i;
990 
991  if (vb2_is_busy(&fimc->vid_cap.vbq))
992  return -EBUSY;
993 
994  /* Pre-configure format at camera interface input, for JPEG only */
995  if (fimc_jpeg_fourcc(pix->pixelformat)) {
996  fimc_capture_try_format(ctx, &pix->width, &pix->height,
997  NULL, &pix->pixelformat,
999  ctx->s_frame.f_width = pix->width;
1000  ctx->s_frame.f_height = pix->height;
1001  }
1002  /* Try the format at the scaler and the DMA output */
1003  ff->fmt = fimc_capture_try_format(ctx, &pix->width, &pix->height,
1004  NULL, &pix->pixelformat,
1006  if (!ff->fmt)
1007  return -EINVAL;
1008 
1009  /* Update RGB Alpha control state and value range */
1011 
1012  /* Try to match format at the host and the sensor */
1013  if (!fimc->vid_cap.user_subdev_api) {
1014  mf->code = ff->fmt->mbus_code;
1015  mf->width = pix->width;
1016  mf->height = pix->height;
1017 
1018  fimc_md_graph_lock(fimc);
1019  ret = fimc_pipeline_try_format(ctx, mf, &s_fmt, true);
1020  fimc_md_graph_unlock(fimc);
1021  if (ret)
1022  return ret;
1023  pix->width = mf->width;
1024  pix->height = mf->height;
1025  }
1026 
1027  fimc_adjust_mplane_format(ff->fmt, pix->width, pix->height, pix);
1028 
1029  if (ff->fmt->flags & FMT_FLAGS_COMPRESSED) {
1030  ret = fimc_get_sensor_frame_desc(fimc->pipeline.subdevs[IDX_SENSOR],
1031  pix->plane_fmt, ff->fmt->memplanes,
1032  true);
1033  if (ret < 0)
1034  return ret;
1035  }
1036 
1037  for (i = 0; i < ff->fmt->memplanes; i++)
1038  ff->payload[i] = pix->plane_fmt[i].sizeimage;
1039 
1040  set_frame_bounds(ff, pix->width, pix->height);
1041  /* Reset the composition rectangle if not yet configured */
1042  if (!(ctx->state & FIMC_COMPOSE))
1043  set_frame_crop(ff, 0, 0, pix->width, pix->height);
1044 
1045  fimc_capture_mark_jpeg_xfer(ctx, ff->fmt->color);
1046 
1047  /* Reset cropping and set format at the camera interface input */
1048  if (!fimc->vid_cap.user_subdev_api) {
1049  ctx->s_frame.fmt = s_fmt;
1050  set_frame_bounds(&ctx->s_frame, pix->width, pix->height);
1051  set_frame_crop(&ctx->s_frame, 0, 0, pix->width, pix->height);
1052  }
1053 
1054  return ret;
1055 }
1056 
1057 static int fimc_cap_s_fmt_mplane(struct file *file, void *priv,
1058  struct v4l2_format *f)
1059 {
1060  struct fimc_dev *fimc = video_drvdata(file);
1061 
1062  return fimc_capture_set_format(fimc, f);
1063 }
1064 
1065 static int fimc_cap_enum_input(struct file *file, void *priv,
1066  struct v4l2_input *i)
1067 {
1068  struct fimc_dev *fimc = video_drvdata(file);
1069  struct v4l2_subdev *sd = fimc->pipeline.subdevs[IDX_SENSOR];
1070 
1071  if (i->index != 0)
1072  return -EINVAL;
1073 
1075  if (sd)
1076  strlcpy(i->name, sd->name, sizeof(i->name));
1077  return 0;
1078 }
1079 
1080 static int fimc_cap_s_input(struct file *file, void *priv, unsigned int i)
1081 {
1082  return i == 0 ? i : -EINVAL;
1083 }
1084 
1085 static int fimc_cap_g_input(struct file *file, void *priv, unsigned int *i)
1086 {
1087  *i = 0;
1088  return 0;
1089 }
1090 
1097 static int fimc_pipeline_validate(struct fimc_dev *fimc)
1098 {
1099  struct v4l2_subdev_format sink_fmt, src_fmt;
1100  struct fimc_vid_cap *vid_cap = &fimc->vid_cap;
1101  struct v4l2_subdev *sd;
1102  struct media_pad *pad;
1103  int ret;
1104 
1105  /* Start with the video capture node pad */
1106  pad = media_entity_remote_source(&vid_cap->vd_pad);
1107  if (pad == NULL)
1108  return -EPIPE;
1109  /* FIMC.{N} subdevice */
1111 
1112  while (1) {
1113  /* Retrieve format at the sink pad */
1114  pad = &sd->entity.pads[0];
1115  if (!(pad->flags & MEDIA_PAD_FL_SINK))
1116  break;
1117  /* Don't call FIMC subdev operation to avoid nested locking */
1118  if (sd == &fimc->vid_cap.subdev) {
1119  struct fimc_frame *ff = &vid_cap->ctx->s_frame;
1120  sink_fmt.format.width = ff->f_width;
1121  sink_fmt.format.height = ff->f_height;
1122  sink_fmt.format.code = ff->fmt ? ff->fmt->mbus_code : 0;
1123  } else {
1124  sink_fmt.pad = pad->index;
1125  sink_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
1126  ret = v4l2_subdev_call(sd, pad, get_fmt, NULL, &sink_fmt);
1127  if (ret < 0 && ret != -ENOIOCTLCMD)
1128  return -EPIPE;
1129  }
1130  /* Retrieve format at the source pad */
1131  pad = media_entity_remote_source(pad);
1132  if (pad == NULL ||
1133  media_entity_type(pad->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
1134  break;
1135 
1137  src_fmt.pad = pad->index;
1138  src_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
1139  ret = v4l2_subdev_call(sd, pad, get_fmt, NULL, &src_fmt);
1140  if (ret < 0 && ret != -ENOIOCTLCMD)
1141  return -EPIPE;
1142 
1143  if (src_fmt.format.width != sink_fmt.format.width ||
1144  src_fmt.format.height != sink_fmt.format.height ||
1145  src_fmt.format.code != sink_fmt.format.code)
1146  return -EPIPE;
1147 
1148  if (sd == fimc->pipeline.subdevs[IDX_SENSOR] &&
1149  fimc_user_defined_mbus_fmt(src_fmt.format.code)) {
1150  struct v4l2_plane_pix_format plane_fmt[FIMC_MAX_PLANES];
1151  struct fimc_frame *frame = &vid_cap->ctx->d_frame;
1152  unsigned int i;
1153 
1154  ret = fimc_get_sensor_frame_desc(sd, plane_fmt,
1155  frame->fmt->memplanes,
1156  false);
1157  if (ret < 0)
1158  return -EPIPE;
1159 
1160  for (i = 0; i < frame->fmt->memplanes; i++)
1161  if (frame->payload[i] < plane_fmt[i].sizeimage)
1162  return -EPIPE;
1163  }
1164  }
1165  return 0;
1166 }
1167 
1168 static int fimc_cap_streamon(struct file *file, void *priv,
1169  enum v4l2_buf_type type)
1170 {
1171  struct fimc_dev *fimc = video_drvdata(file);
1172  struct fimc_pipeline *p = &fimc->pipeline;
1173  struct v4l2_subdev *sd = p->subdevs[IDX_SENSOR];
1174  int ret;
1175 
1176  if (fimc_capture_active(fimc))
1177  return -EBUSY;
1178 
1179  ret = media_entity_pipeline_start(&sd->entity, p->m_pipeline);
1180  if (ret < 0)
1181  return ret;
1182 
1183  if (fimc->vid_cap.user_subdev_api) {
1184  ret = fimc_pipeline_validate(fimc);
1185  if (ret < 0) {
1186  media_entity_pipeline_stop(&sd->entity);
1187  return ret;
1188  }
1189  }
1190  return vb2_streamon(&fimc->vid_cap.vbq, type);
1191 }
1192 
1193 static int fimc_cap_streamoff(struct file *file, void *priv,
1194  enum v4l2_buf_type type)
1195 {
1196  struct fimc_dev *fimc = video_drvdata(file);
1197  struct v4l2_subdev *sd = fimc->pipeline.subdevs[IDX_SENSOR];
1198  int ret;
1199 
1200  ret = vb2_streamoff(&fimc->vid_cap.vbq, type);
1201  if (ret == 0)
1202  media_entity_pipeline_stop(&sd->entity);
1203  return ret;
1204 }
1205 
1206 static int fimc_cap_reqbufs(struct file *file, void *priv,
1207  struct v4l2_requestbuffers *reqbufs)
1208 {
1209  struct fimc_dev *fimc = video_drvdata(file);
1210  int ret = vb2_reqbufs(&fimc->vid_cap.vbq, reqbufs);
1211 
1212  if (!ret)
1213  fimc->vid_cap.reqbufs_count = reqbufs->count;
1214  return ret;
1215 }
1216 
1217 static int fimc_cap_querybuf(struct file *file, void *priv,
1218  struct v4l2_buffer *buf)
1219 {
1220  struct fimc_dev *fimc = video_drvdata(file);
1221 
1222  return vb2_querybuf(&fimc->vid_cap.vbq, buf);
1223 }
1224 
1225 static int fimc_cap_qbuf(struct file *file, void *priv,
1226  struct v4l2_buffer *buf)
1227 {
1228  struct fimc_dev *fimc = video_drvdata(file);
1229 
1230  return vb2_qbuf(&fimc->vid_cap.vbq, buf);
1231 }
1232 
1233 static int fimc_cap_dqbuf(struct file *file, void *priv,
1234  struct v4l2_buffer *buf)
1235 {
1236  struct fimc_dev *fimc = video_drvdata(file);
1237 
1238  return vb2_dqbuf(&fimc->vid_cap.vbq, buf, file->f_flags & O_NONBLOCK);
1239 }
1240 
1241 static int fimc_cap_create_bufs(struct file *file, void *priv,
1242  struct v4l2_create_buffers *create)
1243 {
1244  struct fimc_dev *fimc = video_drvdata(file);
1245 
1246  return vb2_create_bufs(&fimc->vid_cap.vbq, create);
1247 }
1248 
1249 static int fimc_cap_prepare_buf(struct file *file, void *priv,
1250  struct v4l2_buffer *b)
1251 {
1252  struct fimc_dev *fimc = video_drvdata(file);
1253 
1254  return vb2_prepare_buf(&fimc->vid_cap.vbq, b);
1255 }
1256 
1257 static int fimc_cap_g_selection(struct file *file, void *fh,
1258  struct v4l2_selection *s)
1259 {
1260  struct fimc_dev *fimc = video_drvdata(file);
1261  struct fimc_ctx *ctx = fimc->vid_cap.ctx;
1262  struct fimc_frame *f = &ctx->s_frame;
1263 
1265  return -EINVAL;
1266 
1267  switch (s->target) {
1270  f = &ctx->d_frame;
1273  s->r.left = 0;
1274  s->r.top = 0;
1275  s->r.width = f->o_width;
1276  s->r.height = f->o_height;
1277  return 0;
1278 
1279  case V4L2_SEL_TGT_COMPOSE:
1280  f = &ctx->d_frame;
1281  case V4L2_SEL_TGT_CROP:
1282  s->r.left = f->offs_h;
1283  s->r.top = f->offs_v;
1284  s->r.width = f->width;
1285  s->r.height = f->height;
1286  return 0;
1287  }
1288 
1289  return -EINVAL;
1290 }
1291 
1292 /* Return 1 if rectangle a is enclosed in rectangle b, or 0 otherwise. */
1293 static int enclosed_rectangle(struct v4l2_rect *a, struct v4l2_rect *b)
1294 {
1295  if (a->left < b->left || a->top < b->top)
1296  return 0;
1297  if (a->left + a->width > b->left + b->width)
1298  return 0;
1299  if (a->top + a->height > b->top + b->height)
1300  return 0;
1301 
1302  return 1;
1303 }
1304 
1305 static int fimc_cap_s_selection(struct file *file, void *fh,
1306  struct v4l2_selection *s)
1307 {
1308  struct fimc_dev *fimc = video_drvdata(file);
1309  struct fimc_ctx *ctx = fimc->vid_cap.ctx;
1310  struct v4l2_rect rect = s->r;
1311  struct fimc_frame *f;
1312  unsigned long flags;
1313 
1315  return -EINVAL;
1316 
1317  if (s->target == V4L2_SEL_TGT_COMPOSE)
1318  f = &ctx->d_frame;
1319  else if (s->target == V4L2_SEL_TGT_CROP)
1320  f = &ctx->s_frame;
1321  else
1322  return -EINVAL;
1323 
1324  fimc_capture_try_selection(ctx, &rect, s->target);
1325 
1326  if (s->flags & V4L2_SEL_FLAG_LE &&
1327  !enclosed_rectangle(&rect, &s->r))
1328  return -ERANGE;
1329 
1330  if (s->flags & V4L2_SEL_FLAG_GE &&
1331  !enclosed_rectangle(&s->r, &rect))
1332  return -ERANGE;
1333 
1334  s->r = rect;
1335  spin_lock_irqsave(&fimc->slock, flags);
1336  set_frame_crop(f, s->r.left, s->r.top, s->r.width,
1337  s->r.height);
1338  spin_unlock_irqrestore(&fimc->slock, flags);
1339 
1340  set_bit(ST_CAPT_APPLY_CFG, &fimc->state);
1341  return 0;
1342 }
1343 
1344 static const struct v4l2_ioctl_ops fimc_capture_ioctl_ops = {
1345  .vidioc_querycap = fimc_vidioc_querycap_capture,
1346 
1347  .vidioc_enum_fmt_vid_cap_mplane = fimc_cap_enum_fmt_mplane,
1348  .vidioc_try_fmt_vid_cap_mplane = fimc_cap_try_fmt_mplane,
1349  .vidioc_s_fmt_vid_cap_mplane = fimc_cap_s_fmt_mplane,
1350  .vidioc_g_fmt_vid_cap_mplane = fimc_cap_g_fmt_mplane,
1351 
1352  .vidioc_reqbufs = fimc_cap_reqbufs,
1353  .vidioc_querybuf = fimc_cap_querybuf,
1354 
1355  .vidioc_qbuf = fimc_cap_qbuf,
1356  .vidioc_dqbuf = fimc_cap_dqbuf,
1357 
1358  .vidioc_prepare_buf = fimc_cap_prepare_buf,
1359  .vidioc_create_bufs = fimc_cap_create_bufs,
1360 
1361  .vidioc_streamon = fimc_cap_streamon,
1362  .vidioc_streamoff = fimc_cap_streamoff,
1363 
1364  .vidioc_g_selection = fimc_cap_g_selection,
1365  .vidioc_s_selection = fimc_cap_s_selection,
1366 
1367  .vidioc_enum_input = fimc_cap_enum_input,
1368  .vidioc_s_input = fimc_cap_s_input,
1369  .vidioc_g_input = fimc_cap_g_input,
1370 };
1371 
1372 /* Capture subdev media entity operations */
1373 static int fimc_link_setup(struct media_entity *entity,
1374  const struct media_pad *local,
1375  const struct media_pad *remote, u32 flags)
1376 {
1377  struct v4l2_subdev *sd = media_entity_to_v4l2_subdev(entity);
1378  struct fimc_dev *fimc = v4l2_get_subdevdata(sd);
1379 
1380  if (media_entity_type(remote->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
1381  return -EINVAL;
1382 
1383  if (WARN_ON(fimc == NULL))
1384  return 0;
1385 
1386  dbg("%s --> %s, flags: 0x%x. input: 0x%x",
1387  local->entity->name, remote->entity->name, flags,
1388  fimc->vid_cap.input);
1389 
1390  if (flags & MEDIA_LNK_FL_ENABLED) {
1391  if (fimc->vid_cap.input != 0)
1392  return -EBUSY;
1393  fimc->vid_cap.input = sd->grp_id;
1394  return 0;
1395  }
1396 
1397  fimc->vid_cap.input = 0;
1398  return 0;
1399 }
1400 
1401 static const struct media_entity_operations fimc_sd_media_ops = {
1402  .link_setup = fimc_link_setup,
1403 };
1404 
1418 void fimc_sensor_notify(struct v4l2_subdev *sd, unsigned int notification,
1419  void *arg)
1420 {
1421  struct fimc_sensor_info *sensor;
1422  struct fimc_vid_buffer *buf;
1423  struct fimc_md *fmd;
1424  struct fimc_dev *fimc;
1425  unsigned long flags;
1426 
1427  if (sd == NULL)
1428  return;
1429 
1430  sensor = v4l2_get_subdev_hostdata(sd);
1431  fmd = entity_to_fimc_mdev(&sd->entity);
1432 
1433  spin_lock_irqsave(&fmd->slock, flags);
1434  fimc = sensor ? sensor->host : NULL;
1435 
1436  if (fimc && arg && notification == S5P_FIMC_TX_END_NOTIFY &&
1437  test_bit(ST_CAPT_PEND, &fimc->state)) {
1438  unsigned long irq_flags;
1439  spin_lock_irqsave(&fimc->slock, irq_flags);
1440  if (!list_empty(&fimc->vid_cap.active_buf_q)) {
1441  buf = list_entry(fimc->vid_cap.active_buf_q.next,
1442  struct fimc_vid_buffer, list);
1443  vb2_set_plane_payload(&buf->vb, 0, *((u32 *)arg));
1444  }
1445  fimc_capture_irq_handler(fimc, 1);
1447  spin_unlock_irqrestore(&fimc->slock, irq_flags);
1448  }
1449  spin_unlock_irqrestore(&fmd->slock, flags);
1450 }
1451 
1452 static int fimc_subdev_enum_mbus_code(struct v4l2_subdev *sd,
1453  struct v4l2_subdev_fh *fh,
1454  struct v4l2_subdev_mbus_code_enum *code)
1455 {
1456  struct fimc_fmt *fmt;
1457 
1458  fmt = fimc_find_format(NULL, NULL, FMT_FLAGS_CAM, code->index);
1459  if (!fmt)
1460  return -EINVAL;
1461  code->code = fmt->mbus_code;
1462  return 0;
1463 }
1464 
1465 static int fimc_subdev_get_fmt(struct v4l2_subdev *sd,
1466  struct v4l2_subdev_fh *fh,
1467  struct v4l2_subdev_format *fmt)
1468 {
1469  struct fimc_dev *fimc = v4l2_get_subdevdata(sd);
1470  struct fimc_ctx *ctx = fimc->vid_cap.ctx;
1471  struct v4l2_mbus_framefmt *mf;
1472  struct fimc_frame *ff;
1473 
1474  if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) {
1475  mf = v4l2_subdev_get_try_format(fh, fmt->pad);
1476  fmt->format = *mf;
1477  return 0;
1478  }
1479  mf = &fmt->format;
1480  mf->colorspace = V4L2_COLORSPACE_JPEG;
1481  ff = fmt->pad == FIMC_SD_PAD_SINK ? &ctx->s_frame : &ctx->d_frame;
1482 
1483  mutex_lock(&fimc->lock);
1484  /* The pixel code is same on both input and output pad */
1485  if (!WARN_ON(ctx->s_frame.fmt == NULL))
1486  mf->code = ctx->s_frame.fmt->mbus_code;
1487  mf->width = ff->f_width;
1488  mf->height = ff->f_height;
1489  mutex_unlock(&fimc->lock);
1490 
1491  return 0;
1492 }
1493 
1494 static int fimc_subdev_set_fmt(struct v4l2_subdev *sd,
1495  struct v4l2_subdev_fh *fh,
1496  struct v4l2_subdev_format *fmt)
1497 {
1498  struct fimc_dev *fimc = v4l2_get_subdevdata(sd);
1499  struct v4l2_mbus_framefmt *mf = &fmt->format;
1500  struct fimc_ctx *ctx = fimc->vid_cap.ctx;
1501  struct fimc_frame *ff;
1502  struct fimc_fmt *ffmt;
1503 
1504  dbg("pad%d: code: 0x%x, %dx%d",
1505  fmt->pad, mf->code, mf->width, mf->height);
1506 
1507  if (fmt->pad == FIMC_SD_PAD_SOURCE &&
1508  vb2_is_busy(&fimc->vid_cap.vbq))
1509  return -EBUSY;
1510 
1511  mutex_lock(&fimc->lock);
1512  ffmt = fimc_capture_try_format(ctx, &mf->width, &mf->height,
1513  &mf->code, NULL, fmt->pad);
1514  mutex_unlock(&fimc->lock);
1515  mf->colorspace = V4L2_COLORSPACE_JPEG;
1516 
1517  if (fmt->which == V4L2_SUBDEV_FORMAT_TRY) {
1518  mf = v4l2_subdev_get_try_format(fh, fmt->pad);
1519  *mf = fmt->format;
1520  return 0;
1521  }
1522  /* Update RGB Alpha control state and value range */
1524 
1525  fimc_capture_mark_jpeg_xfer(ctx, ffmt->color);
1526 
1527  ff = fmt->pad == FIMC_SD_PAD_SINK ?
1528  &ctx->s_frame : &ctx->d_frame;
1529 
1530  mutex_lock(&fimc->lock);
1531  set_frame_bounds(ff, mf->width, mf->height);
1532  fimc->vid_cap.mf = *mf;
1533  ff->fmt = ffmt;
1534 
1535  /* Reset the crop rectangle if required. */
1536  if (!(fmt->pad == FIMC_SD_PAD_SOURCE && (ctx->state & FIMC_COMPOSE)))
1537  set_frame_crop(ff, 0, 0, mf->width, mf->height);
1538 
1539  if (fmt->pad == FIMC_SD_PAD_SINK)
1540  ctx->state &= ~FIMC_COMPOSE;
1541  mutex_unlock(&fimc->lock);
1542  return 0;
1543 }
1544 
1545 static int fimc_subdev_get_selection(struct v4l2_subdev *sd,
1546  struct v4l2_subdev_fh *fh,
1547  struct v4l2_subdev_selection *sel)
1548 {
1549  struct fimc_dev *fimc = v4l2_get_subdevdata(sd);
1550  struct fimc_ctx *ctx = fimc->vid_cap.ctx;
1551  struct fimc_frame *f = &ctx->s_frame;
1552  struct v4l2_rect *r = &sel->r;
1553  struct v4l2_rect *try_sel;
1554 
1555  if (sel->pad != FIMC_SD_PAD_SINK)
1556  return -EINVAL;
1557 
1558  mutex_lock(&fimc->lock);
1559 
1560  switch (sel->target) {
1562  f = &ctx->d_frame;
1564  r->width = f->o_width;
1565  r->height = f->o_height;
1566  r->left = 0;
1567  r->top = 0;
1568  mutex_unlock(&fimc->lock);
1569  return 0;
1570 
1571  case V4L2_SEL_TGT_CROP:
1572  try_sel = v4l2_subdev_get_try_crop(fh, sel->pad);
1573  break;
1574  case V4L2_SEL_TGT_COMPOSE:
1575  try_sel = v4l2_subdev_get_try_compose(fh, sel->pad);
1576  f = &ctx->d_frame;
1577  break;
1578  default:
1579  mutex_unlock(&fimc->lock);
1580  return -EINVAL;
1581  }
1582 
1583  if (sel->which == V4L2_SUBDEV_FORMAT_TRY) {
1584  sel->r = *try_sel;
1585  } else {
1586  r->left = f->offs_h;
1587  r->top = f->offs_v;
1588  r->width = f->width;
1589  r->height = f->height;
1590  }
1591 
1592  dbg("target %#x: l:%d, t:%d, %dx%d, f_w: %d, f_h: %d",
1593  sel->pad, r->left, r->top, r->width, r->height,
1594  f->f_width, f->f_height);
1595 
1596  mutex_unlock(&fimc->lock);
1597  return 0;
1598 }
1599 
1600 static int fimc_subdev_set_selection(struct v4l2_subdev *sd,
1601  struct v4l2_subdev_fh *fh,
1602  struct v4l2_subdev_selection *sel)
1603 {
1604  struct fimc_dev *fimc = v4l2_get_subdevdata(sd);
1605  struct fimc_ctx *ctx = fimc->vid_cap.ctx;
1606  struct fimc_frame *f = &ctx->s_frame;
1607  struct v4l2_rect *r = &sel->r;
1608  struct v4l2_rect *try_sel;
1609  unsigned long flags;
1610 
1611  if (sel->pad != FIMC_SD_PAD_SINK)
1612  return -EINVAL;
1613 
1614  mutex_lock(&fimc->lock);
1615  fimc_capture_try_selection(ctx, r, V4L2_SEL_TGT_CROP);
1616 
1617  switch (sel->target) {
1619  f = &ctx->d_frame;
1621  r->width = f->o_width;
1622  r->height = f->o_height;
1623  r->left = 0;
1624  r->top = 0;
1625  mutex_unlock(&fimc->lock);
1626  return 0;
1627 
1628  case V4L2_SEL_TGT_CROP:
1629  try_sel = v4l2_subdev_get_try_crop(fh, sel->pad);
1630  break;
1631  case V4L2_SEL_TGT_COMPOSE:
1632  try_sel = v4l2_subdev_get_try_compose(fh, sel->pad);
1633  f = &ctx->d_frame;
1634  break;
1635  default:
1636  mutex_unlock(&fimc->lock);
1637  return -EINVAL;
1638  }
1639 
1640  if (sel->which == V4L2_SUBDEV_FORMAT_TRY) {
1641  *try_sel = sel->r;
1642  } else {
1643  spin_lock_irqsave(&fimc->slock, flags);
1644  set_frame_crop(f, r->left, r->top, r->width, r->height);
1645  set_bit(ST_CAPT_APPLY_CFG, &fimc->state);
1646  spin_unlock_irqrestore(&fimc->slock, flags);
1647  if (sel->target == V4L2_SEL_TGT_COMPOSE)
1648  ctx->state |= FIMC_COMPOSE;
1649  }
1650 
1651  dbg("target %#x: (%d,%d)/%dx%d", sel->target, r->left, r->top,
1652  r->width, r->height);
1653 
1654  mutex_unlock(&fimc->lock);
1655  return 0;
1656 }
1657 
1658 static struct v4l2_subdev_pad_ops fimc_subdev_pad_ops = {
1659  .enum_mbus_code = fimc_subdev_enum_mbus_code,
1660  .get_selection = fimc_subdev_get_selection,
1661  .set_selection = fimc_subdev_set_selection,
1662  .get_fmt = fimc_subdev_get_fmt,
1663  .set_fmt = fimc_subdev_set_fmt,
1664 };
1665 
1666 static struct v4l2_subdev_ops fimc_subdev_ops = {
1667  .pad = &fimc_subdev_pad_ops,
1668 };
1669 
1670 /* Set default format at the sensor and host interface */
1671 static int fimc_capture_set_default_format(struct fimc_dev *fimc)
1672 {
1673  struct v4l2_format fmt = {
1675  .fmt.pix_mp = {
1676  .width = 640,
1677  .height = 480,
1678  .pixelformat = V4L2_PIX_FMT_YUYV,
1679  .field = V4L2_FIELD_NONE,
1680  .colorspace = V4L2_COLORSPACE_JPEG,
1681  },
1682  };
1683 
1684  return fimc_capture_set_format(fimc, &fmt);
1685 }
1686 
1687 /* fimc->lock must be already initialized */
1688 static int fimc_register_capture_device(struct fimc_dev *fimc,
1689  struct v4l2_device *v4l2_dev)
1690 {
1691  struct video_device *vfd = &fimc->vid_cap.vfd;
1692  struct fimc_vid_cap *vid_cap;
1693  struct fimc_ctx *ctx;
1694  struct vb2_queue *q;
1695  int ret = -ENOMEM;
1696 
1697  ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
1698  if (!ctx)
1699  return -ENOMEM;
1700 
1701  ctx->fimc_dev = fimc;
1702  ctx->in_path = FIMC_IO_CAMERA;
1703  ctx->out_path = FIMC_IO_DMA;
1704  ctx->state = FIMC_CTX_CAP;
1705  ctx->s_frame.fmt = fimc_find_format(NULL, NULL, FMT_FLAGS_CAM, 0);
1706  ctx->d_frame.fmt = ctx->s_frame.fmt;
1707 
1708  memset(vfd, 0, sizeof(*vfd));
1709  snprintf(vfd->name, sizeof(vfd->name), "fimc.%d.capture", fimc->id);
1710 
1711  vfd->fops = &fimc_capture_fops;
1712  vfd->ioctl_ops = &fimc_capture_ioctl_ops;
1713  vfd->v4l2_dev = v4l2_dev;
1714  vfd->minor = -1;
1716  vfd->lock = &fimc->lock;
1717 
1718  video_set_drvdata(vfd, fimc);
1719 
1720  vid_cap = &fimc->vid_cap;
1721  vid_cap->active_buf_cnt = 0;
1722  vid_cap->reqbufs_count = 0;
1723  vid_cap->refcnt = 0;
1724 
1725  INIT_LIST_HEAD(&vid_cap->pending_buf_q);
1726  INIT_LIST_HEAD(&vid_cap->active_buf_q);
1727  vid_cap->ctx = ctx;
1728 
1729  q = &fimc->vid_cap.vbq;
1730  memset(q, 0, sizeof(*q));
1732  q->io_modes = VB2_MMAP | VB2_USERPTR;
1733  q->drv_priv = fimc->vid_cap.ctx;
1734  q->ops = &fimc_capture_qops;
1736  q->buf_struct_size = sizeof(struct fimc_vid_buffer);
1737 
1738  ret = vb2_queue_init(q);
1739  if (ret)
1740  goto err_ent;
1741 
1742  vid_cap->vd_pad.flags = MEDIA_PAD_FL_SINK;
1743  ret = media_entity_init(&vfd->entity, 1, &vid_cap->vd_pad, 0);
1744  if (ret)
1745  goto err_ent;
1746 
1747  ret = video_register_device(vfd, VFL_TYPE_GRABBER, -1);
1748  if (ret)
1749  goto err_vd;
1750 
1751  v4l2_info(v4l2_dev, "Registered %s as /dev/%s\n",
1752  vfd->name, video_device_node_name(vfd));
1753 
1754  vfd->ctrl_handler = &ctx->ctrls.handler;
1755  return 0;
1756 
1757 err_vd:
1758  media_entity_cleanup(&vfd->entity);
1759 err_ent:
1760  kfree(ctx);
1761  return ret;
1762 }
1763 
1764 static int fimc_capture_subdev_registered(struct v4l2_subdev *sd)
1765 {
1766  struct fimc_dev *fimc = v4l2_get_subdevdata(sd);
1767  int ret;
1768 
1769  if (fimc == NULL)
1770  return -ENXIO;
1771 
1772  ret = fimc_register_m2m_device(fimc, sd->v4l2_dev);
1773  if (ret)
1774  return ret;
1775 
1776  fimc->pipeline_ops = v4l2_get_subdev_hostdata(sd);
1777 
1778  ret = fimc_register_capture_device(fimc, sd->v4l2_dev);
1779  if (ret) {
1781  fimc->pipeline_ops = NULL;
1782  }
1783 
1784  return ret;
1785 }
1786 
1787 static void fimc_capture_subdev_unregistered(struct v4l2_subdev *sd)
1788 {
1789  struct fimc_dev *fimc = v4l2_get_subdevdata(sd);
1790 
1791  if (fimc == NULL)
1792  return;
1793 
1795 
1796  if (video_is_registered(&fimc->vid_cap.vfd)) {
1797  video_unregister_device(&fimc->vid_cap.vfd);
1798  media_entity_cleanup(&fimc->vid_cap.vfd.entity);
1799  fimc->pipeline_ops = NULL;
1800  }
1801  kfree(fimc->vid_cap.ctx);
1802  fimc->vid_cap.ctx = NULL;
1803 }
1804 
1805 static const struct v4l2_subdev_internal_ops fimc_capture_sd_internal_ops = {
1806  .registered = fimc_capture_subdev_registered,
1807  .unregistered = fimc_capture_subdev_unregistered,
1808 };
1809 
1811 {
1812  struct v4l2_subdev *sd = &fimc->vid_cap.subdev;
1813  int ret;
1814 
1815  v4l2_subdev_init(sd, &fimc_subdev_ops);
1817  snprintf(sd->name, sizeof(sd->name), "FIMC.%d", fimc->pdev->id);
1818 
1819  fimc->vid_cap.sd_pads[FIMC_SD_PAD_SINK].flags = MEDIA_PAD_FL_SINK;
1820  fimc->vid_cap.sd_pads[FIMC_SD_PAD_SOURCE].flags = MEDIA_PAD_FL_SOURCE;
1821  ret = media_entity_init(&sd->entity, FIMC_SD_PADS_NUM,
1822  fimc->vid_cap.sd_pads, 0);
1823  if (ret)
1824  return ret;
1825 
1826  sd->entity.ops = &fimc_sd_media_ops;
1827  sd->internal_ops = &fimc_capture_sd_internal_ops;
1828  v4l2_set_subdevdata(sd, fimc);
1829  return 0;
1830 }
1831 
1833 {
1834  struct v4l2_subdev *sd = &fimc->vid_cap.subdev;
1835 
1837  media_entity_cleanup(&sd->entity);
1838  v4l2_set_subdevdata(sd, NULL);
1839 }