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