1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (C) 2018 Intel Corporation
3
4 #include <linux/module.h>
5 #include <linux/pm_runtime.h>
6
7 #include <media/v4l2-event.h>
8 #include <media/v4l2-ioctl.h>
9
10 #include "ipu3.h"
11 #include "ipu3-dmamap.h"
12
13 /******************** v4l2_subdev_ops ********************/
14
15 #define IPU3_RUNNING_MODE_VIDEO 0
16 #define IPU3_RUNNING_MODE_STILL 1
17
imgu_subdev_open(struct v4l2_subdev * sd,struct v4l2_subdev_fh * fh)18 static int imgu_subdev_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
19 {
20 struct imgu_v4l2_subdev *imgu_sd = container_of(sd,
21 struct imgu_v4l2_subdev,
22 subdev);
23 struct imgu_device *imgu = v4l2_get_subdevdata(sd);
24 struct imgu_media_pipe *imgu_pipe = &imgu->imgu_pipe[imgu_sd->pipe];
25 struct v4l2_rect try_crop = {
26 .top = 0,
27 .left = 0,
28 };
29 unsigned int i;
30
31 try_crop.width =
32 imgu_pipe->nodes[IMGU_NODE_IN].vdev_fmt.fmt.pix_mp.width;
33 try_crop.height =
34 imgu_pipe->nodes[IMGU_NODE_IN].vdev_fmt.fmt.pix_mp.height;
35
36 /* Initialize try_fmt */
37 for (i = 0; i < IMGU_NODE_NUM; i++) {
38 struct v4l2_mbus_framefmt *try_fmt =
39 v4l2_subdev_get_try_format(sd, fh->pad, i);
40
41 try_fmt->width = try_crop.width;
42 try_fmt->height = try_crop.height;
43 try_fmt->code = imgu_pipe->nodes[i].pad_fmt.code;
44 try_fmt->field = V4L2_FIELD_NONE;
45 }
46
47 *v4l2_subdev_get_try_crop(sd, fh->pad, IMGU_NODE_IN) = try_crop;
48 *v4l2_subdev_get_try_compose(sd, fh->pad, IMGU_NODE_IN) = try_crop;
49
50 return 0;
51 }
52
imgu_subdev_s_stream(struct v4l2_subdev * sd,int enable)53 static int imgu_subdev_s_stream(struct v4l2_subdev *sd, int enable)
54 {
55 int i;
56 unsigned int node;
57 int r = 0;
58 struct imgu_device *imgu = v4l2_get_subdevdata(sd);
59 struct imgu_v4l2_subdev *imgu_sd = container_of(sd,
60 struct imgu_v4l2_subdev,
61 subdev);
62 unsigned int pipe = imgu_sd->pipe;
63 struct device *dev = &imgu->pci_dev->dev;
64 struct v4l2_pix_format_mplane *fmts[IPU3_CSS_QUEUES] = { NULL };
65 struct v4l2_rect *rects[IPU3_CSS_RECTS] = { NULL };
66 struct imgu_css_pipe *css_pipe = &imgu->css.pipes[pipe];
67 struct imgu_media_pipe *imgu_pipe = &imgu->imgu_pipe[pipe];
68
69 dev_dbg(dev, "%s %d for pipe %u", __func__, enable, pipe);
70 /* grab ctrl after streamon and return after off */
71 v4l2_ctrl_grab(imgu_sd->ctrl, enable);
72
73 if (!enable) {
74 imgu_sd->active = false;
75 return 0;
76 }
77
78 for (i = 0; i < IMGU_NODE_NUM; i++)
79 imgu_pipe->queue_enabled[i] = imgu_pipe->nodes[i].enabled;
80
81 /* This is handled specially */
82 imgu_pipe->queue_enabled[IPU3_CSS_QUEUE_PARAMS] = false;
83
84 /* Initialize CSS formats */
85 for (i = 0; i < IPU3_CSS_QUEUES; i++) {
86 node = imgu_map_node(imgu, i);
87 /* No need to reconfig meta nodes */
88 if (node == IMGU_NODE_STAT_3A || node == IMGU_NODE_PARAMS)
89 continue;
90 fmts[i] = imgu_pipe->queue_enabled[node] ?
91 &imgu_pipe->nodes[node].vdev_fmt.fmt.pix_mp : NULL;
92 }
93
94 /* Enable VF output only when VF queue requested by user */
95 css_pipe->vf_output_en = false;
96 if (imgu_pipe->nodes[IMGU_NODE_VF].enabled)
97 css_pipe->vf_output_en = true;
98
99 if (atomic_read(&imgu_sd->running_mode) == IPU3_RUNNING_MODE_VIDEO)
100 css_pipe->pipe_id = IPU3_CSS_PIPE_ID_VIDEO;
101 else
102 css_pipe->pipe_id = IPU3_CSS_PIPE_ID_CAPTURE;
103
104 dev_dbg(dev, "IPU3 pipe %u pipe_id %u", pipe, css_pipe->pipe_id);
105
106 rects[IPU3_CSS_RECT_EFFECTIVE] = &imgu_sd->rect.eff;
107 rects[IPU3_CSS_RECT_BDS] = &imgu_sd->rect.bds;
108 rects[IPU3_CSS_RECT_GDC] = &imgu_sd->rect.gdc;
109
110 r = imgu_css_fmt_set(&imgu->css, fmts, rects, pipe);
111 if (r) {
112 dev_err(dev, "failed to set initial formats pipe %u with (%d)",
113 pipe, r);
114 return r;
115 }
116
117 imgu_sd->active = true;
118
119 return 0;
120 }
121
imgu_subdev_get_fmt(struct v4l2_subdev * sd,struct v4l2_subdev_pad_config * cfg,struct v4l2_subdev_format * fmt)122 static int imgu_subdev_get_fmt(struct v4l2_subdev *sd,
123 struct v4l2_subdev_pad_config *cfg,
124 struct v4l2_subdev_format *fmt)
125 {
126 struct imgu_device *imgu = v4l2_get_subdevdata(sd);
127 struct v4l2_mbus_framefmt *mf;
128 struct imgu_media_pipe *imgu_pipe;
129 u32 pad = fmt->pad;
130 struct imgu_v4l2_subdev *imgu_sd = container_of(sd,
131 struct imgu_v4l2_subdev,
132 subdev);
133 unsigned int pipe = imgu_sd->pipe;
134
135 imgu_pipe = &imgu->imgu_pipe[pipe];
136 if (fmt->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
137 fmt->format = imgu_pipe->nodes[pad].pad_fmt;
138 } else {
139 mf = v4l2_subdev_get_try_format(sd, cfg, pad);
140 fmt->format = *mf;
141 }
142
143 return 0;
144 }
145
imgu_subdev_set_fmt(struct v4l2_subdev * sd,struct v4l2_subdev_pad_config * cfg,struct v4l2_subdev_format * fmt)146 static int imgu_subdev_set_fmt(struct v4l2_subdev *sd,
147 struct v4l2_subdev_pad_config *cfg,
148 struct v4l2_subdev_format *fmt)
149 {
150 struct imgu_media_pipe *imgu_pipe;
151 struct imgu_device *imgu = v4l2_get_subdevdata(sd);
152 struct imgu_v4l2_subdev *imgu_sd = container_of(sd,
153 struct imgu_v4l2_subdev,
154 subdev);
155
156 struct v4l2_mbus_framefmt *mf;
157 u32 pad = fmt->pad;
158 unsigned int pipe = imgu_sd->pipe;
159
160 dev_dbg(&imgu->pci_dev->dev, "set subdev %u pad %u fmt to [%ux%u]",
161 pipe, pad, fmt->format.width, fmt->format.height);
162
163 imgu_pipe = &imgu->imgu_pipe[pipe];
164 if (fmt->which == V4L2_SUBDEV_FORMAT_TRY)
165 mf = v4l2_subdev_get_try_format(sd, cfg, pad);
166 else
167 mf = &imgu_pipe->nodes[pad].pad_fmt;
168
169 fmt->format.code = mf->code;
170 /* Clamp the w and h based on the hardware capabilities */
171 if (imgu_sd->subdev_pads[pad].flags & MEDIA_PAD_FL_SOURCE) {
172 fmt->format.width = clamp(fmt->format.width,
173 IPU3_OUTPUT_MIN_WIDTH,
174 IPU3_OUTPUT_MAX_WIDTH);
175 fmt->format.height = clamp(fmt->format.height,
176 IPU3_OUTPUT_MIN_HEIGHT,
177 IPU3_OUTPUT_MAX_HEIGHT);
178 } else {
179 fmt->format.width = clamp(fmt->format.width,
180 IPU3_INPUT_MIN_WIDTH,
181 IPU3_INPUT_MAX_WIDTH);
182 fmt->format.height = clamp(fmt->format.height,
183 IPU3_INPUT_MIN_HEIGHT,
184 IPU3_INPUT_MAX_HEIGHT);
185 }
186
187 *mf = fmt->format;
188
189 return 0;
190 }
191
imgu_subdev_get_selection(struct v4l2_subdev * sd,struct v4l2_subdev_pad_config * cfg,struct v4l2_subdev_selection * sel)192 static int imgu_subdev_get_selection(struct v4l2_subdev *sd,
193 struct v4l2_subdev_pad_config *cfg,
194 struct v4l2_subdev_selection *sel)
195 {
196 struct v4l2_rect *try_sel, *r;
197 struct imgu_v4l2_subdev *imgu_sd = container_of(sd,
198 struct imgu_v4l2_subdev,
199 subdev);
200
201 if (sel->pad != IMGU_NODE_IN)
202 return -EINVAL;
203
204 switch (sel->target) {
205 case V4L2_SEL_TGT_CROP:
206 try_sel = v4l2_subdev_get_try_crop(sd, cfg, sel->pad);
207 r = &imgu_sd->rect.eff;
208 break;
209 case V4L2_SEL_TGT_COMPOSE:
210 try_sel = v4l2_subdev_get_try_compose(sd, cfg, sel->pad);
211 r = &imgu_sd->rect.bds;
212 break;
213 default:
214 return -EINVAL;
215 }
216
217 if (sel->which == V4L2_SUBDEV_FORMAT_TRY)
218 sel->r = *try_sel;
219 else
220 sel->r = *r;
221
222 return 0;
223 }
224
imgu_subdev_set_selection(struct v4l2_subdev * sd,struct v4l2_subdev_pad_config * cfg,struct v4l2_subdev_selection * sel)225 static int imgu_subdev_set_selection(struct v4l2_subdev *sd,
226 struct v4l2_subdev_pad_config *cfg,
227 struct v4l2_subdev_selection *sel)
228 {
229 struct imgu_device *imgu = v4l2_get_subdevdata(sd);
230 struct imgu_v4l2_subdev *imgu_sd = container_of(sd,
231 struct imgu_v4l2_subdev,
232 subdev);
233 struct v4l2_rect *rect, *try_sel;
234
235 dev_dbg(&imgu->pci_dev->dev,
236 "set subdev %u sel which %u target 0x%4x rect [%ux%u]",
237 imgu_sd->pipe, sel->which, sel->target,
238 sel->r.width, sel->r.height);
239
240 if (sel->pad != IMGU_NODE_IN)
241 return -EINVAL;
242
243 switch (sel->target) {
244 case V4L2_SEL_TGT_CROP:
245 try_sel = v4l2_subdev_get_try_crop(sd, cfg, sel->pad);
246 rect = &imgu_sd->rect.eff;
247 break;
248 case V4L2_SEL_TGT_COMPOSE:
249 try_sel = v4l2_subdev_get_try_compose(sd, cfg, sel->pad);
250 rect = &imgu_sd->rect.bds;
251 break;
252 default:
253 return -EINVAL;
254 }
255
256 if (sel->which == V4L2_SUBDEV_FORMAT_TRY)
257 *try_sel = sel->r;
258 else
259 *rect = sel->r;
260
261 return 0;
262 }
263
264 /******************** media_entity_operations ********************/
265
imgu_link_setup(struct media_entity * entity,const struct media_pad * local,const struct media_pad * remote,u32 flags)266 static int imgu_link_setup(struct media_entity *entity,
267 const struct media_pad *local,
268 const struct media_pad *remote, u32 flags)
269 {
270 struct imgu_media_pipe *imgu_pipe;
271 struct v4l2_subdev *sd = container_of(entity, struct v4l2_subdev,
272 entity);
273 struct imgu_device *imgu = v4l2_get_subdevdata(sd);
274 struct imgu_v4l2_subdev *imgu_sd = container_of(sd,
275 struct imgu_v4l2_subdev,
276 subdev);
277 unsigned int pipe = imgu_sd->pipe;
278 u32 pad = local->index;
279
280 WARN_ON(pad >= IMGU_NODE_NUM);
281
282 dev_dbg(&imgu->pci_dev->dev, "pipe %u pad %u is %s", pipe, pad,
283 flags & MEDIA_LNK_FL_ENABLED ? "enabled" : "disabled");
284
285 imgu_pipe = &imgu->imgu_pipe[pipe];
286 imgu_pipe->nodes[pad].enabled = flags & MEDIA_LNK_FL_ENABLED;
287
288 /* enable input node to enable the pipe */
289 if (pad != IMGU_NODE_IN)
290 return 0;
291
292 if (flags & MEDIA_LNK_FL_ENABLED)
293 __set_bit(pipe, imgu->css.enabled_pipes);
294 else
295 __clear_bit(pipe, imgu->css.enabled_pipes);
296
297 dev_dbg(&imgu->pci_dev->dev, "pipe %u is %s", pipe,
298 flags & MEDIA_LNK_FL_ENABLED ? "enabled" : "disabled");
299
300 return 0;
301 }
302
303 /******************** vb2_ops ********************/
304
imgu_vb2_buf_init(struct vb2_buffer * vb)305 static int imgu_vb2_buf_init(struct vb2_buffer *vb)
306 {
307 struct sg_table *sg = vb2_dma_sg_plane_desc(vb, 0);
308 struct imgu_device *imgu = vb2_get_drv_priv(vb->vb2_queue);
309 struct imgu_buffer *buf = container_of(vb,
310 struct imgu_buffer, vid_buf.vbb.vb2_buf);
311 struct imgu_video_device *node =
312 container_of(vb->vb2_queue, struct imgu_video_device, vbq);
313 unsigned int queue = imgu_node_to_queue(node->id);
314
315 if (queue == IPU3_CSS_QUEUE_PARAMS)
316 return 0;
317
318 return imgu_dmamap_map_sg(imgu, sg->sgl, sg->nents, &buf->map);
319 }
320
321 /* Called when each buffer is freed */
imgu_vb2_buf_cleanup(struct vb2_buffer * vb)322 static void imgu_vb2_buf_cleanup(struct vb2_buffer *vb)
323 {
324 struct imgu_device *imgu = vb2_get_drv_priv(vb->vb2_queue);
325 struct imgu_buffer *buf = container_of(vb,
326 struct imgu_buffer, vid_buf.vbb.vb2_buf);
327 struct imgu_video_device *node =
328 container_of(vb->vb2_queue, struct imgu_video_device, vbq);
329 unsigned int queue = imgu_node_to_queue(node->id);
330
331 if (queue == IPU3_CSS_QUEUE_PARAMS)
332 return;
333
334 imgu_dmamap_unmap(imgu, &buf->map);
335 }
336
337 /* Transfer buffer ownership to me */
imgu_vb2_buf_queue(struct vb2_buffer * vb)338 static void imgu_vb2_buf_queue(struct vb2_buffer *vb)
339 {
340 struct imgu_device *imgu = vb2_get_drv_priv(vb->vb2_queue);
341 struct imgu_video_device *node =
342 container_of(vb->vb2_queue, struct imgu_video_device, vbq);
343 unsigned int queue = imgu_node_to_queue(node->id);
344 struct imgu_buffer *buf = container_of(vb, struct imgu_buffer,
345 vid_buf.vbb.vb2_buf);
346 unsigned long need_bytes;
347 unsigned long payload = vb2_get_plane_payload(vb, 0);
348
349 if (vb->vb2_queue->type == V4L2_BUF_TYPE_META_CAPTURE ||
350 vb->vb2_queue->type == V4L2_BUF_TYPE_META_OUTPUT)
351 need_bytes = node->vdev_fmt.fmt.meta.buffersize;
352 else
353 need_bytes = node->vdev_fmt.fmt.pix_mp.plane_fmt[0].sizeimage;
354
355 if (queue == IPU3_CSS_QUEUE_PARAMS && payload && payload < need_bytes) {
356 dev_err(&imgu->pci_dev->dev, "invalid data size for params.");
357 vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
358 return;
359 }
360
361 mutex_lock(&imgu->lock);
362 if (queue != IPU3_CSS_QUEUE_PARAMS)
363 imgu_css_buf_init(&buf->css_buf, queue, buf->map.daddr);
364
365 list_add_tail(&buf->vid_buf.list, &node->buffers);
366 mutex_unlock(&imgu->lock);
367
368 vb2_set_plane_payload(vb, 0, need_bytes);
369
370 mutex_lock(&imgu->streaming_lock);
371 if (imgu->streaming)
372 imgu_queue_buffers(imgu, false, node->pipe);
373 mutex_unlock(&imgu->streaming_lock);
374
375 dev_dbg(&imgu->pci_dev->dev, "%s for pipe %u node %u", __func__,
376 node->pipe, node->id);
377 }
378
imgu_vb2_queue_setup(struct vb2_queue * vq,unsigned int * num_buffers,unsigned int * num_planes,unsigned int sizes[],struct device * alloc_devs[])379 static int imgu_vb2_queue_setup(struct vb2_queue *vq,
380 unsigned int *num_buffers,
381 unsigned int *num_planes,
382 unsigned int sizes[],
383 struct device *alloc_devs[])
384 {
385 struct imgu_device *imgu = vb2_get_drv_priv(vq);
386 struct imgu_video_device *node =
387 container_of(vq, struct imgu_video_device, vbq);
388 const struct v4l2_format *fmt = &node->vdev_fmt;
389 unsigned int size;
390
391 *num_buffers = clamp_val(*num_buffers, 1, VB2_MAX_FRAME);
392 alloc_devs[0] = &imgu->pci_dev->dev;
393
394 if (vq->type == V4L2_BUF_TYPE_META_CAPTURE ||
395 vq->type == V4L2_BUF_TYPE_META_OUTPUT)
396 size = fmt->fmt.meta.buffersize;
397 else
398 size = fmt->fmt.pix_mp.plane_fmt[0].sizeimage;
399
400 if (*num_planes) {
401 if (sizes[0] < size)
402 return -EINVAL;
403 size = sizes[0];
404 }
405
406 *num_planes = 1;
407 sizes[0] = size;
408
409 /* Initialize buffer queue */
410 INIT_LIST_HEAD(&node->buffers);
411
412 return 0;
413 }
414
415 /* Check if all enabled video nodes are streaming, exception ignored */
imgu_all_nodes_streaming(struct imgu_device * imgu,struct imgu_video_device * except)416 static bool imgu_all_nodes_streaming(struct imgu_device *imgu,
417 struct imgu_video_device *except)
418 {
419 unsigned int i, pipe, p;
420 struct imgu_video_device *node;
421 struct device *dev = &imgu->pci_dev->dev;
422
423 pipe = except->pipe;
424 if (!test_bit(pipe, imgu->css.enabled_pipes)) {
425 dev_warn(&imgu->pci_dev->dev,
426 "pipe %u link is not ready yet", pipe);
427 return false;
428 }
429
430 for_each_set_bit(p, imgu->css.enabled_pipes, IMGU_MAX_PIPE_NUM) {
431 for (i = 0; i < IMGU_NODE_NUM; i++) {
432 node = &imgu->imgu_pipe[p].nodes[i];
433 dev_dbg(dev, "%s pipe %u queue %u name %s enabled = %u",
434 __func__, p, i, node->name, node->enabled);
435 if (node == except)
436 continue;
437 if (node->enabled && !vb2_start_streaming_called(&node->vbq))
438 return false;
439 }
440 }
441
442 return true;
443 }
444
imgu_return_all_buffers(struct imgu_device * imgu,struct imgu_video_device * node,enum vb2_buffer_state state)445 static void imgu_return_all_buffers(struct imgu_device *imgu,
446 struct imgu_video_device *node,
447 enum vb2_buffer_state state)
448 {
449 struct imgu_vb2_buffer *b, *b0;
450
451 /* Return all buffers */
452 mutex_lock(&imgu->lock);
453 list_for_each_entry_safe(b, b0, &node->buffers, list) {
454 list_del(&b->list);
455 vb2_buffer_done(&b->vbb.vb2_buf, state);
456 }
457 mutex_unlock(&imgu->lock);
458 }
459
imgu_vb2_start_streaming(struct vb2_queue * vq,unsigned int count)460 static int imgu_vb2_start_streaming(struct vb2_queue *vq, unsigned int count)
461 {
462 struct imgu_media_pipe *imgu_pipe;
463 struct imgu_device *imgu = vb2_get_drv_priv(vq);
464 struct device *dev = &imgu->pci_dev->dev;
465 struct imgu_video_device *node =
466 container_of(vq, struct imgu_video_device, vbq);
467 int r;
468 unsigned int pipe;
469
470 dev_dbg(dev, "%s node name %s pipe %u id %u", __func__,
471 node->name, node->pipe, node->id);
472
473 mutex_lock(&imgu->streaming_lock);
474 if (imgu->streaming) {
475 r = -EBUSY;
476 mutex_unlock(&imgu->streaming_lock);
477 goto fail_return_bufs;
478 }
479 mutex_unlock(&imgu->streaming_lock);
480
481 if (!node->enabled) {
482 dev_err(dev, "IMGU node is not enabled");
483 r = -EINVAL;
484 goto fail_return_bufs;
485 }
486
487 pipe = node->pipe;
488 imgu_pipe = &imgu->imgu_pipe[pipe];
489 r = media_pipeline_start(&node->vdev.entity, &imgu_pipe->pipeline);
490 if (r < 0)
491 goto fail_return_bufs;
492
493
494 if (!imgu_all_nodes_streaming(imgu, node))
495 return 0;
496
497 for_each_set_bit(pipe, imgu->css.enabled_pipes, IMGU_MAX_PIPE_NUM) {
498 r = v4l2_subdev_call(&imgu->imgu_pipe[pipe].imgu_sd.subdev,
499 video, s_stream, 1);
500 if (r < 0)
501 goto fail_stop_pipeline;
502 }
503
504 /* Start streaming of the whole pipeline now */
505 dev_dbg(dev, "IMGU streaming is ready to start");
506 mutex_lock(&imgu->streaming_lock);
507 r = imgu_s_stream(imgu, true);
508 if (!r)
509 imgu->streaming = true;
510 mutex_unlock(&imgu->streaming_lock);
511
512 return 0;
513
514 fail_stop_pipeline:
515 media_pipeline_stop(&node->vdev.entity);
516 fail_return_bufs:
517 imgu_return_all_buffers(imgu, node, VB2_BUF_STATE_QUEUED);
518
519 return r;
520 }
521
imgu_vb2_stop_streaming(struct vb2_queue * vq)522 static void imgu_vb2_stop_streaming(struct vb2_queue *vq)
523 {
524 struct imgu_media_pipe *imgu_pipe;
525 struct imgu_device *imgu = vb2_get_drv_priv(vq);
526 struct device *dev = &imgu->pci_dev->dev;
527 struct imgu_video_device *node =
528 container_of(vq, struct imgu_video_device, vbq);
529 int r;
530 unsigned int pipe;
531
532 WARN_ON(!node->enabled);
533
534 pipe = node->pipe;
535 dev_dbg(dev, "Try to stream off node [%u][%u]", pipe, node->id);
536 imgu_pipe = &imgu->imgu_pipe[pipe];
537 r = v4l2_subdev_call(&imgu_pipe->imgu_sd.subdev, video, s_stream, 0);
538 if (r)
539 dev_err(&imgu->pci_dev->dev,
540 "failed to stop subdev streaming\n");
541
542 mutex_lock(&imgu->streaming_lock);
543 /* Was this the first node with streaming disabled? */
544 if (imgu->streaming && imgu_all_nodes_streaming(imgu, node)) {
545 /* Yes, really stop streaming now */
546 dev_dbg(dev, "IMGU streaming is ready to stop");
547 r = imgu_s_stream(imgu, false);
548 if (!r)
549 imgu->streaming = false;
550 }
551
552 imgu_return_all_buffers(imgu, node, VB2_BUF_STATE_ERROR);
553 mutex_unlock(&imgu->streaming_lock);
554
555 media_pipeline_stop(&node->vdev.entity);
556 }
557
558 /******************** v4l2_ioctl_ops ********************/
559
560 #define VID_CAPTURE 0
561 #define VID_OUTPUT 1
562 #define DEF_VID_CAPTURE 0
563 #define DEF_VID_OUTPUT 1
564
565 struct imgu_fmt {
566 u32 fourcc;
567 u16 type; /* VID_CAPTURE or VID_OUTPUT not both */
568 };
569
570 /* format descriptions for capture and preview */
571 static const struct imgu_fmt formats[] = {
572 { V4L2_PIX_FMT_NV12, VID_CAPTURE },
573 { V4L2_PIX_FMT_IPU3_SGRBG10, VID_OUTPUT },
574 { V4L2_PIX_FMT_IPU3_SBGGR10, VID_OUTPUT },
575 { V4L2_PIX_FMT_IPU3_SGBRG10, VID_OUTPUT },
576 { V4L2_PIX_FMT_IPU3_SRGGB10, VID_OUTPUT },
577 };
578
579 /* Find the first matched format, return default if not found */
find_format(struct v4l2_format * f,u32 type)580 static const struct imgu_fmt *find_format(struct v4l2_format *f, u32 type)
581 {
582 unsigned int i;
583
584 for (i = 0; i < ARRAY_SIZE(formats); i++) {
585 if (formats[i].fourcc == f->fmt.pix_mp.pixelformat &&
586 formats[i].type == type)
587 return &formats[i];
588 }
589
590 return type == VID_CAPTURE ? &formats[DEF_VID_CAPTURE] :
591 &formats[DEF_VID_OUTPUT];
592 }
593
imgu_vidioc_querycap(struct file * file,void * fh,struct v4l2_capability * cap)594 static int imgu_vidioc_querycap(struct file *file, void *fh,
595 struct v4l2_capability *cap)
596 {
597 struct imgu_device *imgu = video_drvdata(file);
598
599 strscpy(cap->driver, IMGU_NAME, sizeof(cap->driver));
600 strscpy(cap->card, IMGU_NAME, sizeof(cap->card));
601 snprintf(cap->bus_info, sizeof(cap->bus_info), "PCI:%s",
602 pci_name(imgu->pci_dev));
603
604 return 0;
605 }
606
enum_fmts(struct v4l2_fmtdesc * f,u32 type)607 static int enum_fmts(struct v4l2_fmtdesc *f, u32 type)
608 {
609 unsigned int i, j;
610
611 for (i = j = 0; i < ARRAY_SIZE(formats); ++i) {
612 if (formats[i].type == type) {
613 if (j == f->index)
614 break;
615 ++j;
616 }
617 }
618
619 if (i < ARRAY_SIZE(formats)) {
620 f->pixelformat = formats[i].fourcc;
621 return 0;
622 }
623
624 return -EINVAL;
625 }
626
vidioc_enum_fmt_vid_cap(struct file * file,void * priv,struct v4l2_fmtdesc * f)627 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
628 struct v4l2_fmtdesc *f)
629 {
630 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
631 return -EINVAL;
632
633 return enum_fmts(f, VID_CAPTURE);
634 }
635
vidioc_enum_fmt_vid_out(struct file * file,void * priv,struct v4l2_fmtdesc * f)636 static int vidioc_enum_fmt_vid_out(struct file *file, void *priv,
637 struct v4l2_fmtdesc *f)
638 {
639 if (f->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
640 return -EINVAL;
641
642 return enum_fmts(f, VID_OUTPUT);
643 }
644
645 /* Propagate forward always the format from the CIO2 subdev */
imgu_vidioc_g_fmt(struct file * file,void * fh,struct v4l2_format * f)646 static int imgu_vidioc_g_fmt(struct file *file, void *fh,
647 struct v4l2_format *f)
648 {
649 struct imgu_video_device *node = file_to_intel_imgu_node(file);
650
651 f->fmt = node->vdev_fmt.fmt;
652
653 return 0;
654 }
655
656 /*
657 * Set input/output format. Unless it is just a try, this also resets
658 * selections (ie. effective and BDS resolutions) to defaults.
659 */
imgu_fmt(struct imgu_device * imgu,unsigned int pipe,int node,struct v4l2_format * f,bool try)660 static int imgu_fmt(struct imgu_device *imgu, unsigned int pipe, int node,
661 struct v4l2_format *f, bool try)
662 {
663 struct device *dev = &imgu->pci_dev->dev;
664 struct v4l2_pix_format_mplane *fmts[IPU3_CSS_QUEUES] = { NULL };
665 struct v4l2_rect *rects[IPU3_CSS_RECTS] = { NULL };
666 struct v4l2_mbus_framefmt pad_fmt;
667 unsigned int i, css_q;
668 int ret;
669 struct imgu_css_pipe *css_pipe = &imgu->css.pipes[pipe];
670 struct imgu_media_pipe *imgu_pipe = &imgu->imgu_pipe[pipe];
671 struct imgu_v4l2_subdev *imgu_sd = &imgu_pipe->imgu_sd;
672
673 dev_dbg(dev, "set fmt node [%u][%u](try = %u)", pipe, node, try);
674
675 for (i = 0; i < IMGU_NODE_NUM; i++)
676 dev_dbg(dev, "IMGU pipe %u node %u enabled = %u",
677 pipe, i, imgu_pipe->nodes[i].enabled);
678
679 if (imgu_pipe->nodes[IMGU_NODE_VF].enabled)
680 css_pipe->vf_output_en = true;
681
682 if (atomic_read(&imgu_sd->running_mode) == IPU3_RUNNING_MODE_VIDEO)
683 css_pipe->pipe_id = IPU3_CSS_PIPE_ID_VIDEO;
684 else
685 css_pipe->pipe_id = IPU3_CSS_PIPE_ID_CAPTURE;
686
687 dev_dbg(dev, "IPU3 pipe %u pipe_id = %u", pipe, css_pipe->pipe_id);
688
689 css_q = imgu_node_to_queue(node);
690 for (i = 0; i < IPU3_CSS_QUEUES; i++) {
691 unsigned int inode = imgu_map_node(imgu, i);
692
693 /* Skip the meta node */
694 if (inode == IMGU_NODE_STAT_3A || inode == IMGU_NODE_PARAMS)
695 continue;
696
697 /* CSS expects some format on OUT queue */
698 if (i != IPU3_CSS_QUEUE_OUT &&
699 !imgu_pipe->nodes[inode].enabled && !try) {
700 fmts[i] = NULL;
701 continue;
702 }
703
704 if (i == css_q) {
705 fmts[i] = &f->fmt.pix_mp;
706 continue;
707 }
708
709 if (try) {
710 fmts[i] = kmemdup(&imgu_pipe->nodes[inode].vdev_fmt.fmt.pix_mp,
711 sizeof(struct v4l2_pix_format_mplane),
712 GFP_KERNEL);
713 if (!fmts[i]) {
714 ret = -ENOMEM;
715 goto out;
716 }
717 } else {
718 fmts[i] = &imgu_pipe->nodes[inode].vdev_fmt.fmt.pix_mp;
719 }
720
721 }
722
723 if (!try) {
724 /* eff and bds res got by imgu_s_sel */
725 struct imgu_v4l2_subdev *imgu_sd = &imgu_pipe->imgu_sd;
726
727 rects[IPU3_CSS_RECT_EFFECTIVE] = &imgu_sd->rect.eff;
728 rects[IPU3_CSS_RECT_BDS] = &imgu_sd->rect.bds;
729 rects[IPU3_CSS_RECT_GDC] = &imgu_sd->rect.gdc;
730
731 /* suppose that pad fmt was set by subdev s_fmt before */
732 pad_fmt = imgu_pipe->nodes[IMGU_NODE_IN].pad_fmt;
733 rects[IPU3_CSS_RECT_GDC]->width = pad_fmt.width;
734 rects[IPU3_CSS_RECT_GDC]->height = pad_fmt.height;
735 }
736
737 if (!fmts[css_q]) {
738 ret = -EINVAL;
739 goto out;
740 }
741
742 if (try)
743 ret = imgu_css_fmt_try(&imgu->css, fmts, rects, pipe);
744 else
745 ret = imgu_css_fmt_set(&imgu->css, fmts, rects, pipe);
746
747 /* ret is the binary number in the firmware blob */
748 if (ret < 0)
749 goto out;
750
751 /*
752 * imgu doesn't set the node to the value given by user
753 * before we return success from this function, so set it here.
754 */
755 if (!try)
756 imgu_pipe->nodes[node].vdev_fmt.fmt.pix_mp = f->fmt.pix_mp;
757
758 out:
759 if (try) {
760 for (i = 0; i < IPU3_CSS_QUEUES; i++)
761 if (i != css_q)
762 kfree(fmts[i]);
763 }
764
765 return ret;
766 }
767
imgu_try_fmt(struct file * file,void * fh,struct v4l2_format * f)768 static int imgu_try_fmt(struct file *file, void *fh, struct v4l2_format *f)
769 {
770 struct v4l2_pix_format_mplane *pixm = &f->fmt.pix_mp;
771 const struct imgu_fmt *fmt;
772
773 if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
774 fmt = find_format(f, VID_CAPTURE);
775 else if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
776 fmt = find_format(f, VID_OUTPUT);
777 else
778 return -EINVAL;
779
780 pixm->pixelformat = fmt->fourcc;
781
782 memset(pixm->plane_fmt[0].reserved, 0,
783 sizeof(pixm->plane_fmt[0].reserved));
784
785 return 0;
786 }
787
imgu_vidioc_try_fmt(struct file * file,void * fh,struct v4l2_format * f)788 static int imgu_vidioc_try_fmt(struct file *file, void *fh,
789 struct v4l2_format *f)
790 {
791 struct imgu_device *imgu = video_drvdata(file);
792 struct device *dev = &imgu->pci_dev->dev;
793 struct imgu_video_device *node = file_to_intel_imgu_node(file);
794 struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp;
795 int r;
796
797 dev_dbg(dev, "%s [%ux%u] for node %u\n", __func__,
798 pix_mp->width, pix_mp->height, node->id);
799
800 r = imgu_try_fmt(file, fh, f);
801 if (r)
802 return r;
803
804 return imgu_fmt(imgu, node->pipe, node->id, f, true);
805 }
806
imgu_vidioc_s_fmt(struct file * file,void * fh,struct v4l2_format * f)807 static int imgu_vidioc_s_fmt(struct file *file, void *fh, struct v4l2_format *f)
808 {
809 struct imgu_device *imgu = video_drvdata(file);
810 struct device *dev = &imgu->pci_dev->dev;
811 struct imgu_video_device *node = file_to_intel_imgu_node(file);
812 struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp;
813 int r;
814
815 dev_dbg(dev, "%s [%ux%u] for node %u\n", __func__,
816 pix_mp->width, pix_mp->height, node->id);
817
818 r = imgu_try_fmt(file, fh, f);
819 if (r)
820 return r;
821
822 return imgu_fmt(imgu, node->pipe, node->id, f, false);
823 }
824
825 struct imgu_meta_fmt {
826 __u32 fourcc;
827 char *name;
828 };
829
830 /* From drivers/media/v4l2-core/v4l2-ioctl.c */
831 static const struct imgu_meta_fmt meta_fmts[] = {
832 { V4L2_META_FMT_IPU3_PARAMS, "IPU3 processing parameters" },
833 { V4L2_META_FMT_IPU3_STAT_3A, "IPU3 3A statistics" },
834 };
835
imgu_meta_enum_format(struct file * file,void * fh,struct v4l2_fmtdesc * fmt)836 static int imgu_meta_enum_format(struct file *file, void *fh,
837 struct v4l2_fmtdesc *fmt)
838 {
839 struct imgu_video_device *node = file_to_intel_imgu_node(file);
840 unsigned int i = fmt->type == V4L2_BUF_TYPE_META_OUTPUT ? 0 : 1;
841
842 /* Each node is dedicated to only one meta format */
843 if (fmt->index > 0 || fmt->type != node->vbq.type)
844 return -EINVAL;
845
846 strscpy(fmt->description, meta_fmts[i].name, sizeof(fmt->description));
847 fmt->pixelformat = meta_fmts[i].fourcc;
848
849 return 0;
850 }
851
imgu_vidioc_g_meta_fmt(struct file * file,void * fh,struct v4l2_format * f)852 static int imgu_vidioc_g_meta_fmt(struct file *file, void *fh,
853 struct v4l2_format *f)
854 {
855 struct imgu_video_device *node = file_to_intel_imgu_node(file);
856
857 if (f->type != node->vbq.type)
858 return -EINVAL;
859
860 f->fmt = node->vdev_fmt.fmt;
861
862 return 0;
863 }
864
imgu_vidioc_enum_input(struct file * file,void * fh,struct v4l2_input * input)865 static int imgu_vidioc_enum_input(struct file *file, void *fh,
866 struct v4l2_input *input)
867 {
868 if (input->index > 0)
869 return -EINVAL;
870 strscpy(input->name, "camera", sizeof(input->name));
871 input->type = V4L2_INPUT_TYPE_CAMERA;
872
873 return 0;
874 }
875
imgu_vidioc_g_input(struct file * file,void * fh,unsigned int * input)876 static int imgu_vidioc_g_input(struct file *file, void *fh, unsigned int *input)
877 {
878 *input = 0;
879
880 return 0;
881 }
882
imgu_vidioc_s_input(struct file * file,void * fh,unsigned int input)883 static int imgu_vidioc_s_input(struct file *file, void *fh, unsigned int input)
884 {
885 return input == 0 ? 0 : -EINVAL;
886 }
887
imgu_vidioc_enum_output(struct file * file,void * fh,struct v4l2_output * output)888 static int imgu_vidioc_enum_output(struct file *file, void *fh,
889 struct v4l2_output *output)
890 {
891 if (output->index > 0)
892 return -EINVAL;
893 strscpy(output->name, "camera", sizeof(output->name));
894 output->type = V4L2_INPUT_TYPE_CAMERA;
895
896 return 0;
897 }
898
imgu_vidioc_g_output(struct file * file,void * fh,unsigned int * output)899 static int imgu_vidioc_g_output(struct file *file, void *fh,
900 unsigned int *output)
901 {
902 *output = 0;
903
904 return 0;
905 }
906
imgu_vidioc_s_output(struct file * file,void * fh,unsigned int output)907 static int imgu_vidioc_s_output(struct file *file, void *fh,
908 unsigned int output)
909 {
910 return output == 0 ? 0 : -EINVAL;
911 }
912
913 /******************** function pointers ********************/
914
915 static struct v4l2_subdev_internal_ops imgu_subdev_internal_ops = {
916 .open = imgu_subdev_open,
917 };
918
919 static const struct v4l2_subdev_core_ops imgu_subdev_core_ops = {
920 .subscribe_event = v4l2_ctrl_subdev_subscribe_event,
921 .unsubscribe_event = v4l2_event_subdev_unsubscribe,
922 };
923
924 static const struct v4l2_subdev_video_ops imgu_subdev_video_ops = {
925 .s_stream = imgu_subdev_s_stream,
926 };
927
928 static const struct v4l2_subdev_pad_ops imgu_subdev_pad_ops = {
929 .link_validate = v4l2_subdev_link_validate_default,
930 .get_fmt = imgu_subdev_get_fmt,
931 .set_fmt = imgu_subdev_set_fmt,
932 .get_selection = imgu_subdev_get_selection,
933 .set_selection = imgu_subdev_set_selection,
934 };
935
936 static const struct v4l2_subdev_ops imgu_subdev_ops = {
937 .core = &imgu_subdev_core_ops,
938 .video = &imgu_subdev_video_ops,
939 .pad = &imgu_subdev_pad_ops,
940 };
941
942 static const struct media_entity_operations imgu_media_ops = {
943 .link_setup = imgu_link_setup,
944 .link_validate = v4l2_subdev_link_validate,
945 };
946
947 /****************** vb2_ops of the Q ********************/
948
949 static const struct vb2_ops imgu_vb2_ops = {
950 .buf_init = imgu_vb2_buf_init,
951 .buf_cleanup = imgu_vb2_buf_cleanup,
952 .buf_queue = imgu_vb2_buf_queue,
953 .queue_setup = imgu_vb2_queue_setup,
954 .start_streaming = imgu_vb2_start_streaming,
955 .stop_streaming = imgu_vb2_stop_streaming,
956 .wait_prepare = vb2_ops_wait_prepare,
957 .wait_finish = vb2_ops_wait_finish,
958 };
959
960 /****************** v4l2_file_operations *****************/
961
962 static const struct v4l2_file_operations imgu_v4l2_fops = {
963 .unlocked_ioctl = video_ioctl2,
964 .open = v4l2_fh_open,
965 .release = vb2_fop_release,
966 .poll = vb2_fop_poll,
967 .mmap = vb2_fop_mmap,
968 };
969
970 /******************** v4l2_ioctl_ops ********************/
971
972 static const struct v4l2_ioctl_ops imgu_v4l2_ioctl_ops = {
973 .vidioc_querycap = imgu_vidioc_querycap,
974
975 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
976 .vidioc_g_fmt_vid_cap_mplane = imgu_vidioc_g_fmt,
977 .vidioc_s_fmt_vid_cap_mplane = imgu_vidioc_s_fmt,
978 .vidioc_try_fmt_vid_cap_mplane = imgu_vidioc_try_fmt,
979
980 .vidioc_enum_fmt_vid_out = vidioc_enum_fmt_vid_out,
981 .vidioc_g_fmt_vid_out_mplane = imgu_vidioc_g_fmt,
982 .vidioc_s_fmt_vid_out_mplane = imgu_vidioc_s_fmt,
983 .vidioc_try_fmt_vid_out_mplane = imgu_vidioc_try_fmt,
984
985 .vidioc_enum_output = imgu_vidioc_enum_output,
986 .vidioc_g_output = imgu_vidioc_g_output,
987 .vidioc_s_output = imgu_vidioc_s_output,
988
989 .vidioc_enum_input = imgu_vidioc_enum_input,
990 .vidioc_g_input = imgu_vidioc_g_input,
991 .vidioc_s_input = imgu_vidioc_s_input,
992
993 /* buffer queue management */
994 .vidioc_reqbufs = vb2_ioctl_reqbufs,
995 .vidioc_create_bufs = vb2_ioctl_create_bufs,
996 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
997 .vidioc_querybuf = vb2_ioctl_querybuf,
998 .vidioc_qbuf = vb2_ioctl_qbuf,
999 .vidioc_dqbuf = vb2_ioctl_dqbuf,
1000 .vidioc_streamon = vb2_ioctl_streamon,
1001 .vidioc_streamoff = vb2_ioctl_streamoff,
1002 .vidioc_expbuf = vb2_ioctl_expbuf,
1003 };
1004
1005 static const struct v4l2_ioctl_ops imgu_v4l2_meta_ioctl_ops = {
1006 .vidioc_querycap = imgu_vidioc_querycap,
1007
1008 /* meta capture */
1009 .vidioc_enum_fmt_meta_cap = imgu_meta_enum_format,
1010 .vidioc_g_fmt_meta_cap = imgu_vidioc_g_meta_fmt,
1011 .vidioc_s_fmt_meta_cap = imgu_vidioc_g_meta_fmt,
1012 .vidioc_try_fmt_meta_cap = imgu_vidioc_g_meta_fmt,
1013
1014 /* meta output */
1015 .vidioc_enum_fmt_meta_out = imgu_meta_enum_format,
1016 .vidioc_g_fmt_meta_out = imgu_vidioc_g_meta_fmt,
1017 .vidioc_s_fmt_meta_out = imgu_vidioc_g_meta_fmt,
1018 .vidioc_try_fmt_meta_out = imgu_vidioc_g_meta_fmt,
1019
1020 .vidioc_reqbufs = vb2_ioctl_reqbufs,
1021 .vidioc_create_bufs = vb2_ioctl_create_bufs,
1022 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
1023 .vidioc_querybuf = vb2_ioctl_querybuf,
1024 .vidioc_qbuf = vb2_ioctl_qbuf,
1025 .vidioc_dqbuf = vb2_ioctl_dqbuf,
1026 .vidioc_streamon = vb2_ioctl_streamon,
1027 .vidioc_streamoff = vb2_ioctl_streamoff,
1028 .vidioc_expbuf = vb2_ioctl_expbuf,
1029 };
1030
imgu_sd_s_ctrl(struct v4l2_ctrl * ctrl)1031 static int imgu_sd_s_ctrl(struct v4l2_ctrl *ctrl)
1032 {
1033 struct imgu_v4l2_subdev *imgu_sd =
1034 container_of(ctrl->handler, struct imgu_v4l2_subdev, ctrl_handler);
1035 struct imgu_device *imgu = v4l2_get_subdevdata(&imgu_sd->subdev);
1036 struct device *dev = &imgu->pci_dev->dev;
1037
1038 dev_dbg(dev, "set val %d to ctrl 0x%8x for subdev %u",
1039 ctrl->val, ctrl->id, imgu_sd->pipe);
1040
1041 switch (ctrl->id) {
1042 case V4L2_CID_INTEL_IPU3_MODE:
1043 atomic_set(&imgu_sd->running_mode, ctrl->val);
1044 return 0;
1045 default:
1046 return -EINVAL;
1047 }
1048 }
1049
1050 static const struct v4l2_ctrl_ops imgu_subdev_ctrl_ops = {
1051 .s_ctrl = imgu_sd_s_ctrl,
1052 };
1053
1054 static const char * const imgu_ctrl_mode_strings[] = {
1055 "Video mode",
1056 "Still mode",
1057 };
1058
1059 static const struct v4l2_ctrl_config imgu_subdev_ctrl_mode = {
1060 .ops = &imgu_subdev_ctrl_ops,
1061 .id = V4L2_CID_INTEL_IPU3_MODE,
1062 .name = "IPU3 Pipe Mode",
1063 .type = V4L2_CTRL_TYPE_MENU,
1064 .max = ARRAY_SIZE(imgu_ctrl_mode_strings) - 1,
1065 .def = IPU3_RUNNING_MODE_VIDEO,
1066 .qmenu = imgu_ctrl_mode_strings,
1067 };
1068
1069 /******************** Framework registration ********************/
1070
1071 /* helper function to config node's video properties */
imgu_node_to_v4l2(u32 node,struct video_device * vdev,struct v4l2_format * f)1072 static void imgu_node_to_v4l2(u32 node, struct video_device *vdev,
1073 struct v4l2_format *f)
1074 {
1075 u32 cap;
1076
1077 /* Should not happen */
1078 WARN_ON(node >= IMGU_NODE_NUM);
1079
1080 switch (node) {
1081 case IMGU_NODE_IN:
1082 cap = V4L2_CAP_VIDEO_OUTPUT_MPLANE;
1083 f->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
1084 vdev->ioctl_ops = &imgu_v4l2_ioctl_ops;
1085 break;
1086 case IMGU_NODE_PARAMS:
1087 cap = V4L2_CAP_META_OUTPUT;
1088 f->type = V4L2_BUF_TYPE_META_OUTPUT;
1089 f->fmt.meta.dataformat = V4L2_META_FMT_IPU3_PARAMS;
1090 vdev->ioctl_ops = &imgu_v4l2_meta_ioctl_ops;
1091 imgu_css_meta_fmt_set(&f->fmt.meta);
1092 break;
1093 case IMGU_NODE_STAT_3A:
1094 cap = V4L2_CAP_META_CAPTURE;
1095 f->type = V4L2_BUF_TYPE_META_CAPTURE;
1096 f->fmt.meta.dataformat = V4L2_META_FMT_IPU3_STAT_3A;
1097 vdev->ioctl_ops = &imgu_v4l2_meta_ioctl_ops;
1098 imgu_css_meta_fmt_set(&f->fmt.meta);
1099 break;
1100 default:
1101 cap = V4L2_CAP_VIDEO_CAPTURE_MPLANE;
1102 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
1103 vdev->ioctl_ops = &imgu_v4l2_ioctl_ops;
1104 }
1105
1106 vdev->device_caps = V4L2_CAP_STREAMING | cap;
1107 }
1108
imgu_v4l2_subdev_register(struct imgu_device * imgu,struct imgu_v4l2_subdev * imgu_sd,unsigned int pipe)1109 static int imgu_v4l2_subdev_register(struct imgu_device *imgu,
1110 struct imgu_v4l2_subdev *imgu_sd,
1111 unsigned int pipe)
1112 {
1113 int i, r;
1114 struct v4l2_ctrl_handler *hdl = &imgu_sd->ctrl_handler;
1115 struct imgu_media_pipe *imgu_pipe = &imgu->imgu_pipe[pipe];
1116
1117 /* Initialize subdev media entity */
1118 imgu_sd->subdev.entity.ops = &imgu_media_ops;
1119 for (i = 0; i < IMGU_NODE_NUM; i++) {
1120 imgu_sd->subdev_pads[i].flags = imgu_pipe->nodes[i].output ?
1121 MEDIA_PAD_FL_SINK : MEDIA_PAD_FL_SOURCE;
1122 }
1123 r = media_entity_pads_init(&imgu_sd->subdev.entity, IMGU_NODE_NUM,
1124 imgu_sd->subdev_pads);
1125 if (r) {
1126 dev_err(&imgu->pci_dev->dev,
1127 "failed initialize subdev media entity (%d)\n", r);
1128 return r;
1129 }
1130
1131 /* Initialize subdev */
1132 v4l2_subdev_init(&imgu_sd->subdev, &imgu_subdev_ops);
1133 imgu_sd->subdev.entity.function = MEDIA_ENT_F_PROC_VIDEO_STATISTICS;
1134 imgu_sd->subdev.internal_ops = &imgu_subdev_internal_ops;
1135 imgu_sd->subdev.flags = V4L2_SUBDEV_FL_HAS_DEVNODE |
1136 V4L2_SUBDEV_FL_HAS_EVENTS;
1137 snprintf(imgu_sd->subdev.name, sizeof(imgu_sd->subdev.name),
1138 "%s %u", IMGU_NAME, pipe);
1139 v4l2_set_subdevdata(&imgu_sd->subdev, imgu);
1140 atomic_set(&imgu_sd->running_mode, IPU3_RUNNING_MODE_VIDEO);
1141 v4l2_ctrl_handler_init(hdl, 1);
1142 imgu_sd->subdev.ctrl_handler = hdl;
1143 imgu_sd->ctrl = v4l2_ctrl_new_custom(hdl, &imgu_subdev_ctrl_mode, NULL);
1144 if (hdl->error) {
1145 r = hdl->error;
1146 dev_err(&imgu->pci_dev->dev,
1147 "failed to create subdev v4l2 ctrl with err %d", r);
1148 goto fail_subdev;
1149 }
1150 r = v4l2_device_register_subdev(&imgu->v4l2_dev, &imgu_sd->subdev);
1151 if (r) {
1152 dev_err(&imgu->pci_dev->dev,
1153 "failed initialize subdev (%d)\n", r);
1154 goto fail_subdev;
1155 }
1156
1157 imgu_sd->pipe = pipe;
1158 return 0;
1159
1160 fail_subdev:
1161 v4l2_ctrl_handler_free(imgu_sd->subdev.ctrl_handler);
1162 media_entity_cleanup(&imgu_sd->subdev.entity);
1163
1164 return r;
1165 }
1166
imgu_v4l2_node_setup(struct imgu_device * imgu,unsigned int pipe,int node_num)1167 static int imgu_v4l2_node_setup(struct imgu_device *imgu, unsigned int pipe,
1168 int node_num)
1169 {
1170 int r;
1171 u32 flags;
1172 struct v4l2_mbus_framefmt def_bus_fmt = { 0 };
1173 struct v4l2_pix_format_mplane def_pix_fmt = { 0 };
1174 struct device *dev = &imgu->pci_dev->dev;
1175 struct imgu_media_pipe *imgu_pipe = &imgu->imgu_pipe[pipe];
1176 struct v4l2_subdev *sd = &imgu_pipe->imgu_sd.subdev;
1177 struct imgu_video_device *node = &imgu_pipe->nodes[node_num];
1178 struct video_device *vdev = &node->vdev;
1179 struct vb2_queue *vbq = &node->vbq;
1180
1181 /* Initialize formats to default values */
1182 def_bus_fmt.width = 1920;
1183 def_bus_fmt.height = 1080;
1184 def_bus_fmt.code = MEDIA_BUS_FMT_FIXED;
1185 def_bus_fmt.field = V4L2_FIELD_NONE;
1186 def_bus_fmt.colorspace = V4L2_COLORSPACE_RAW;
1187 def_bus_fmt.ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
1188 def_bus_fmt.quantization = V4L2_QUANTIZATION_DEFAULT;
1189 def_bus_fmt.xfer_func = V4L2_XFER_FUNC_DEFAULT;
1190
1191 def_pix_fmt.width = def_bus_fmt.width;
1192 def_pix_fmt.height = def_bus_fmt.height;
1193 def_pix_fmt.field = def_bus_fmt.field;
1194 def_pix_fmt.num_planes = 1;
1195 def_pix_fmt.plane_fmt[0].bytesperline = def_pix_fmt.width * 2;
1196 def_pix_fmt.plane_fmt[0].sizeimage =
1197 def_pix_fmt.height * def_pix_fmt.plane_fmt[0].bytesperline;
1198 def_pix_fmt.flags = 0;
1199 def_pix_fmt.colorspace = def_bus_fmt.colorspace;
1200 def_pix_fmt.ycbcr_enc = def_bus_fmt.ycbcr_enc;
1201 def_pix_fmt.quantization = def_bus_fmt.quantization;
1202 def_pix_fmt.xfer_func = def_bus_fmt.xfer_func;
1203
1204 /* Initialize miscellaneous variables */
1205 mutex_init(&node->lock);
1206 INIT_LIST_HEAD(&node->buffers);
1207
1208 /* Initialize formats to default values */
1209 node->pad_fmt = def_bus_fmt;
1210 node->id = node_num;
1211 node->pipe = pipe;
1212 imgu_node_to_v4l2(node_num, vdev, &node->vdev_fmt);
1213 if (node->vdev_fmt.type ==
1214 V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE ||
1215 node->vdev_fmt.type ==
1216 V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1217 def_pix_fmt.pixelformat = node->output ?
1218 V4L2_PIX_FMT_IPU3_SGRBG10 :
1219 V4L2_PIX_FMT_NV12;
1220 node->vdev_fmt.fmt.pix_mp = def_pix_fmt;
1221 }
1222
1223 /* Initialize media entities */
1224 node->vdev_pad.flags = node->output ?
1225 MEDIA_PAD_FL_SOURCE : MEDIA_PAD_FL_SINK;
1226 vdev->entity.ops = NULL;
1227 r = media_entity_pads_init(&vdev->entity, 1, &node->vdev_pad);
1228 if (r) {
1229 dev_err(dev, "failed initialize media entity (%d)\n", r);
1230 mutex_destroy(&node->lock);
1231 return r;
1232 }
1233
1234 /* Initialize vbq */
1235 vbq->type = node->vdev_fmt.type;
1236 vbq->io_modes = VB2_USERPTR | VB2_MMAP | VB2_DMABUF;
1237 vbq->ops = &imgu_vb2_ops;
1238 vbq->mem_ops = &vb2_dma_sg_memops;
1239 if (imgu->buf_struct_size <= 0)
1240 imgu->buf_struct_size =
1241 sizeof(struct imgu_vb2_buffer);
1242 vbq->buf_struct_size = imgu->buf_struct_size;
1243 vbq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1244 /* can streamon w/o buffers */
1245 vbq->min_buffers_needed = 0;
1246 vbq->drv_priv = imgu;
1247 vbq->lock = &node->lock;
1248 r = vb2_queue_init(vbq);
1249 if (r) {
1250 dev_err(dev, "failed to initialize video queue (%d)", r);
1251 media_entity_cleanup(&vdev->entity);
1252 return r;
1253 }
1254
1255 /* Initialize vdev */
1256 snprintf(vdev->name, sizeof(vdev->name), "%s %u %s",
1257 IMGU_NAME, pipe, node->name);
1258 vdev->release = video_device_release_empty;
1259 vdev->fops = &imgu_v4l2_fops;
1260 vdev->lock = &node->lock;
1261 vdev->v4l2_dev = &imgu->v4l2_dev;
1262 vdev->queue = &node->vbq;
1263 vdev->vfl_dir = node->output ? VFL_DIR_TX : VFL_DIR_RX;
1264 video_set_drvdata(vdev, imgu);
1265 r = video_register_device(vdev, VFL_TYPE_GRABBER, -1);
1266 if (r) {
1267 dev_err(dev, "failed to register video device (%d)", r);
1268 media_entity_cleanup(&vdev->entity);
1269 return r;
1270 }
1271
1272 /* Create link between video node and the subdev pad */
1273 flags = 0;
1274 if (node->enabled)
1275 flags |= MEDIA_LNK_FL_ENABLED;
1276 if (node->output) {
1277 r = media_create_pad_link(&vdev->entity, 0, &sd->entity,
1278 node_num, flags);
1279 } else {
1280 r = media_create_pad_link(&sd->entity, node_num, &vdev->entity,
1281 0, flags);
1282 }
1283 if (r) {
1284 dev_err(dev, "failed to create pad link (%d)", r);
1285 video_unregister_device(vdev);
1286 return r;
1287 }
1288
1289 return 0;
1290 }
1291
imgu_v4l2_nodes_cleanup_pipe(struct imgu_device * imgu,unsigned int pipe,int node)1292 static void imgu_v4l2_nodes_cleanup_pipe(struct imgu_device *imgu,
1293 unsigned int pipe, int node)
1294 {
1295 int i;
1296 struct imgu_media_pipe *imgu_pipe = &imgu->imgu_pipe[pipe];
1297
1298 for (i = 0; i < node; i++) {
1299 video_unregister_device(&imgu_pipe->nodes[i].vdev);
1300 media_entity_cleanup(&imgu_pipe->nodes[i].vdev.entity);
1301 mutex_destroy(&imgu_pipe->nodes[i].lock);
1302 }
1303 }
1304
imgu_v4l2_nodes_setup_pipe(struct imgu_device * imgu,int pipe)1305 static int imgu_v4l2_nodes_setup_pipe(struct imgu_device *imgu, int pipe)
1306 {
1307 int i, r;
1308
1309 for (i = 0; i < IMGU_NODE_NUM; i++) {
1310 r = imgu_v4l2_node_setup(imgu, pipe, i);
1311 if (r)
1312 goto cleanup;
1313 }
1314
1315 return 0;
1316
1317 cleanup:
1318 imgu_v4l2_nodes_cleanup_pipe(imgu, pipe, i);
1319 return r;
1320 }
1321
imgu_v4l2_subdev_cleanup(struct imgu_device * imgu,unsigned int i)1322 static void imgu_v4l2_subdev_cleanup(struct imgu_device *imgu, unsigned int i)
1323 {
1324 struct imgu_media_pipe *imgu_pipe = &imgu->imgu_pipe[i];
1325
1326 v4l2_device_unregister_subdev(&imgu_pipe->imgu_sd.subdev);
1327 v4l2_ctrl_handler_free(imgu_pipe->imgu_sd.subdev.ctrl_handler);
1328 media_entity_cleanup(&imgu_pipe->imgu_sd.subdev.entity);
1329 }
1330
imgu_v4l2_cleanup_pipes(struct imgu_device * imgu,unsigned int pipe)1331 static void imgu_v4l2_cleanup_pipes(struct imgu_device *imgu, unsigned int pipe)
1332 {
1333 int i;
1334
1335 for (i = 0; i < pipe; i++) {
1336 imgu_v4l2_nodes_cleanup_pipe(imgu, i, IMGU_NODE_NUM);
1337 imgu_v4l2_subdev_cleanup(imgu, i);
1338 }
1339 }
1340
imgu_v4l2_register_pipes(struct imgu_device * imgu)1341 static int imgu_v4l2_register_pipes(struct imgu_device *imgu)
1342 {
1343 struct imgu_media_pipe *imgu_pipe;
1344 int i, r;
1345
1346 for (i = 0; i < IMGU_MAX_PIPE_NUM; i++) {
1347 imgu_pipe = &imgu->imgu_pipe[i];
1348 r = imgu_v4l2_subdev_register(imgu, &imgu_pipe->imgu_sd, i);
1349 if (r) {
1350 dev_err(&imgu->pci_dev->dev,
1351 "failed to register subdev%u ret (%d)\n", i, r);
1352 goto pipes_cleanup;
1353 }
1354 r = imgu_v4l2_nodes_setup_pipe(imgu, i);
1355 if (r) {
1356 imgu_v4l2_subdev_cleanup(imgu, i);
1357 goto pipes_cleanup;
1358 }
1359 }
1360
1361 return 0;
1362
1363 pipes_cleanup:
1364 imgu_v4l2_cleanup_pipes(imgu, i);
1365 return r;
1366 }
1367
imgu_v4l2_register(struct imgu_device * imgu)1368 int imgu_v4l2_register(struct imgu_device *imgu)
1369 {
1370 int r;
1371
1372 /* Initialize miscellaneous variables */
1373 imgu->streaming = false;
1374
1375 /* Set up media device */
1376 media_device_pci_init(&imgu->media_dev, imgu->pci_dev, IMGU_NAME);
1377
1378 /* Set up v4l2 device */
1379 imgu->v4l2_dev.mdev = &imgu->media_dev;
1380 imgu->v4l2_dev.ctrl_handler = NULL;
1381 r = v4l2_device_register(&imgu->pci_dev->dev, &imgu->v4l2_dev);
1382 if (r) {
1383 dev_err(&imgu->pci_dev->dev,
1384 "failed to register V4L2 device (%d)\n", r);
1385 goto fail_v4l2_dev;
1386 }
1387
1388 r = imgu_v4l2_register_pipes(imgu);
1389 if (r) {
1390 dev_err(&imgu->pci_dev->dev,
1391 "failed to register pipes (%d)\n", r);
1392 goto fail_v4l2_pipes;
1393 }
1394
1395 r = v4l2_device_register_subdev_nodes(&imgu->v4l2_dev);
1396 if (r) {
1397 dev_err(&imgu->pci_dev->dev,
1398 "failed to register subdevs (%d)\n", r);
1399 goto fail_subdevs;
1400 }
1401
1402 r = media_device_register(&imgu->media_dev);
1403 if (r) {
1404 dev_err(&imgu->pci_dev->dev,
1405 "failed to register media device (%d)\n", r);
1406 goto fail_subdevs;
1407 }
1408
1409 return 0;
1410
1411 fail_subdevs:
1412 imgu_v4l2_cleanup_pipes(imgu, IMGU_MAX_PIPE_NUM);
1413 fail_v4l2_pipes:
1414 v4l2_device_unregister(&imgu->v4l2_dev);
1415 fail_v4l2_dev:
1416 media_device_cleanup(&imgu->media_dev);
1417
1418 return r;
1419 }
1420
imgu_v4l2_unregister(struct imgu_device * imgu)1421 int imgu_v4l2_unregister(struct imgu_device *imgu)
1422 {
1423 media_device_unregister(&imgu->media_dev);
1424 imgu_v4l2_cleanup_pipes(imgu, IMGU_MAX_PIPE_NUM);
1425 v4l2_device_unregister(&imgu->v4l2_dev);
1426 media_device_cleanup(&imgu->media_dev);
1427
1428 return 0;
1429 }
1430
imgu_v4l2_buffer_done(struct vb2_buffer * vb,enum vb2_buffer_state state)1431 void imgu_v4l2_buffer_done(struct vb2_buffer *vb,
1432 enum vb2_buffer_state state)
1433 {
1434 struct imgu_vb2_buffer *b =
1435 container_of(vb, struct imgu_vb2_buffer, vbb.vb2_buf);
1436
1437 list_del(&b->list);
1438 vb2_buffer_done(&b->vbb.vb2_buf, state);
1439 }
1440