1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * V4L2 sub-device 4 * 5 * Copyright (C) 2010 Nokia Corporation 6 * 7 * Contact: Laurent Pinchart <laurent.pinchart@ideasonboard.com> 8 * Sakari Ailus <sakari.ailus@iki.fi> 9 */ 10 11 #include <linux/export.h> 12 #include <linux/ioctl.h> 13 #include <linux/leds.h> 14 #include <linux/mm.h> 15 #include <linux/module.h> 16 #include <linux/overflow.h> 17 #include <linux/slab.h> 18 #include <linux/string.h> 19 #include <linux/types.h> 20 #include <linux/version.h> 21 #include <linux/videodev2.h> 22 23 #include <media/v4l2-ctrls.h> 24 #include <media/v4l2-device.h> 25 #include <media/v4l2-event.h> 26 #include <media/v4l2-fh.h> 27 #include <media/v4l2-ioctl.h> 28 29 #if defined(CONFIG_VIDEO_V4L2_SUBDEV_API) 30 /* 31 * The Streams API is an experimental feature. To use the Streams API, set 32 * 'v4l2_subdev_enable_streams_api' to 1 below. 33 */ 34 35 static bool v4l2_subdev_enable_streams_api; 36 #endif 37 38 /* 39 * Maximum stream ID is 63 for now, as we use u64 bitmask to represent a set 40 * of streams. 41 * 42 * Note that V4L2_FRAME_DESC_ENTRY_MAX is related: V4L2_FRAME_DESC_ENTRY_MAX 43 * restricts the total number of streams in a pad, although the stream ID is 44 * not restricted. 45 */ 46 #define V4L2_SUBDEV_MAX_STREAM_ID 63 47 48 #include "v4l2-subdev-priv.h" 49 50 #if defined(CONFIG_VIDEO_V4L2_SUBDEV_API) 51 static int subdev_fh_init(struct v4l2_subdev_fh *fh, struct v4l2_subdev *sd) 52 { 53 struct v4l2_subdev_state *state; 54 static struct lock_class_key key; 55 56 state = __v4l2_subdev_state_alloc(sd, "fh->state->lock", &key); 57 if (IS_ERR(state)) 58 return PTR_ERR(state); 59 60 fh->state = state; 61 62 return 0; 63 } 64 65 static void subdev_fh_free(struct v4l2_subdev_fh *fh) 66 { 67 __v4l2_subdev_state_free(fh->state); 68 fh->state = NULL; 69 } 70 71 static int subdev_open(struct file *file) 72 { 73 struct video_device *vdev = video_devdata(file); 74 struct v4l2_subdev *sd = vdev_to_v4l2_subdev(vdev); 75 struct v4l2_subdev_fh *subdev_fh; 76 int ret; 77 78 subdev_fh = kzalloc(sizeof(*subdev_fh), GFP_KERNEL); 79 if (subdev_fh == NULL) 80 return -ENOMEM; 81 82 ret = subdev_fh_init(subdev_fh, sd); 83 if (ret) { 84 kfree(subdev_fh); 85 return ret; 86 } 87 88 v4l2_fh_init(&subdev_fh->vfh, vdev); 89 v4l2_fh_add(&subdev_fh->vfh); 90 file->private_data = &subdev_fh->vfh; 91 92 if (sd->v4l2_dev->mdev && sd->entity.graph_obj.mdev->dev) { 93 struct module *owner; 94 95 owner = sd->entity.graph_obj.mdev->dev->driver->owner; 96 if (!try_module_get(owner)) { 97 ret = -EBUSY; 98 goto err; 99 } 100 subdev_fh->owner = owner; 101 } 102 103 if (sd->internal_ops && sd->internal_ops->open) { 104 ret = sd->internal_ops->open(sd, subdev_fh); 105 if (ret < 0) 106 goto err; 107 } 108 109 return 0; 110 111 err: 112 module_put(subdev_fh->owner); 113 v4l2_fh_del(&subdev_fh->vfh); 114 v4l2_fh_exit(&subdev_fh->vfh); 115 subdev_fh_free(subdev_fh); 116 kfree(subdev_fh); 117 118 return ret; 119 } 120 121 static int subdev_close(struct file *file) 122 { 123 struct video_device *vdev = video_devdata(file); 124 struct v4l2_subdev *sd = vdev_to_v4l2_subdev(vdev); 125 struct v4l2_fh *vfh = file->private_data; 126 struct v4l2_subdev_fh *subdev_fh = to_v4l2_subdev_fh(vfh); 127 128 if (sd->internal_ops && sd->internal_ops->close) 129 sd->internal_ops->close(sd, subdev_fh); 130 module_put(subdev_fh->owner); 131 v4l2_fh_del(vfh); 132 v4l2_fh_exit(vfh); 133 subdev_fh_free(subdev_fh); 134 kfree(subdev_fh); 135 file->private_data = NULL; 136 137 return 0; 138 } 139 #else /* CONFIG_VIDEO_V4L2_SUBDEV_API */ 140 static int subdev_open(struct file *file) 141 { 142 return -ENODEV; 143 } 144 145 static int subdev_close(struct file *file) 146 { 147 return -ENODEV; 148 } 149 #endif /* CONFIG_VIDEO_V4L2_SUBDEV_API */ 150 151 static void v4l2_subdev_enable_privacy_led(struct v4l2_subdev *sd) 152 { 153 #if IS_REACHABLE(CONFIG_LEDS_CLASS) 154 if (!IS_ERR_OR_NULL(sd->privacy_led)) 155 led_set_brightness(sd->privacy_led, 156 sd->privacy_led->max_brightness); 157 #endif 158 } 159 160 static void v4l2_subdev_disable_privacy_led(struct v4l2_subdev *sd) 161 { 162 #if IS_REACHABLE(CONFIG_LEDS_CLASS) 163 if (!IS_ERR_OR_NULL(sd->privacy_led)) 164 led_set_brightness(sd->privacy_led, 0); 165 #endif 166 } 167 168 static inline int check_which(u32 which) 169 { 170 if (which != V4L2_SUBDEV_FORMAT_TRY && 171 which != V4L2_SUBDEV_FORMAT_ACTIVE) 172 return -EINVAL; 173 174 return 0; 175 } 176 177 static inline int check_pad(struct v4l2_subdev *sd, u32 pad) 178 { 179 #if defined(CONFIG_MEDIA_CONTROLLER) 180 if (sd->entity.num_pads) { 181 if (pad >= sd->entity.num_pads) 182 return -EINVAL; 183 return 0; 184 } 185 #endif 186 /* allow pad 0 on subdevices not registered as media entities */ 187 if (pad > 0) 188 return -EINVAL; 189 return 0; 190 } 191 192 static int check_state(struct v4l2_subdev *sd, struct v4l2_subdev_state *state, 193 u32 which, u32 pad, u32 stream) 194 { 195 if (sd->flags & V4L2_SUBDEV_FL_STREAMS) { 196 #if defined(CONFIG_VIDEO_V4L2_SUBDEV_API) 197 if (!v4l2_subdev_state_get_format(state, pad, stream)) 198 return -EINVAL; 199 return 0; 200 #else 201 return -EINVAL; 202 #endif 203 } 204 205 if (stream != 0) 206 return -EINVAL; 207 208 if (which == V4L2_SUBDEV_FORMAT_TRY && (!state || !state->pads)) 209 return -EINVAL; 210 211 return 0; 212 } 213 214 static inline int check_format(struct v4l2_subdev *sd, 215 struct v4l2_subdev_state *state, 216 struct v4l2_subdev_format *format) 217 { 218 if (!format) 219 return -EINVAL; 220 221 return check_which(format->which) ? : check_pad(sd, format->pad) ? : 222 check_state(sd, state, format->which, format->pad, format->stream); 223 } 224 225 static int call_get_fmt(struct v4l2_subdev *sd, 226 struct v4l2_subdev_state *state, 227 struct v4l2_subdev_format *format) 228 { 229 return check_format(sd, state, format) ? : 230 sd->ops->pad->get_fmt(sd, state, format); 231 } 232 233 static int call_set_fmt(struct v4l2_subdev *sd, 234 struct v4l2_subdev_state *state, 235 struct v4l2_subdev_format *format) 236 { 237 return check_format(sd, state, format) ? : 238 sd->ops->pad->set_fmt(sd, state, format); 239 } 240 241 static int call_enum_mbus_code(struct v4l2_subdev *sd, 242 struct v4l2_subdev_state *state, 243 struct v4l2_subdev_mbus_code_enum *code) 244 { 245 if (!code) 246 return -EINVAL; 247 248 return check_which(code->which) ? : check_pad(sd, code->pad) ? : 249 check_state(sd, state, code->which, code->pad, code->stream) ? : 250 sd->ops->pad->enum_mbus_code(sd, state, code); 251 } 252 253 static int call_enum_frame_size(struct v4l2_subdev *sd, 254 struct v4l2_subdev_state *state, 255 struct v4l2_subdev_frame_size_enum *fse) 256 { 257 if (!fse) 258 return -EINVAL; 259 260 return check_which(fse->which) ? : check_pad(sd, fse->pad) ? : 261 check_state(sd, state, fse->which, fse->pad, fse->stream) ? : 262 sd->ops->pad->enum_frame_size(sd, state, fse); 263 } 264 265 static int call_enum_frame_interval(struct v4l2_subdev *sd, 266 struct v4l2_subdev_state *state, 267 struct v4l2_subdev_frame_interval_enum *fie) 268 { 269 if (!fie) 270 return -EINVAL; 271 272 return check_which(fie->which) ? : check_pad(sd, fie->pad) ? : 273 check_state(sd, state, fie->which, fie->pad, fie->stream) ? : 274 sd->ops->pad->enum_frame_interval(sd, state, fie); 275 } 276 277 static inline int check_selection(struct v4l2_subdev *sd, 278 struct v4l2_subdev_state *state, 279 struct v4l2_subdev_selection *sel) 280 { 281 if (!sel) 282 return -EINVAL; 283 284 return check_which(sel->which) ? : check_pad(sd, sel->pad) ? : 285 check_state(sd, state, sel->which, sel->pad, sel->stream); 286 } 287 288 static int call_get_selection(struct v4l2_subdev *sd, 289 struct v4l2_subdev_state *state, 290 struct v4l2_subdev_selection *sel) 291 { 292 return check_selection(sd, state, sel) ? : 293 sd->ops->pad->get_selection(sd, state, sel); 294 } 295 296 static int call_set_selection(struct v4l2_subdev *sd, 297 struct v4l2_subdev_state *state, 298 struct v4l2_subdev_selection *sel) 299 { 300 return check_selection(sd, state, sel) ? : 301 sd->ops->pad->set_selection(sd, state, sel); 302 } 303 304 static inline int check_frame_interval(struct v4l2_subdev *sd, 305 struct v4l2_subdev_state *state, 306 struct v4l2_subdev_frame_interval *fi) 307 { 308 if (!fi) 309 return -EINVAL; 310 311 return check_which(fi->which) ? : check_pad(sd, fi->pad) ? : 312 check_state(sd, state, fi->which, fi->pad, fi->stream); 313 } 314 315 static int call_get_frame_interval(struct v4l2_subdev *sd, 316 struct v4l2_subdev_state *state, 317 struct v4l2_subdev_frame_interval *fi) 318 { 319 return check_frame_interval(sd, state, fi) ? : 320 sd->ops->pad->get_frame_interval(sd, state, fi); 321 } 322 323 static int call_set_frame_interval(struct v4l2_subdev *sd, 324 struct v4l2_subdev_state *state, 325 struct v4l2_subdev_frame_interval *fi) 326 { 327 return check_frame_interval(sd, state, fi) ? : 328 sd->ops->pad->set_frame_interval(sd, state, fi); 329 } 330 331 static int call_get_frame_desc(struct v4l2_subdev *sd, unsigned int pad, 332 struct v4l2_mbus_frame_desc *fd) 333 { 334 unsigned int i; 335 int ret; 336 337 memset(fd, 0, sizeof(*fd)); 338 339 ret = sd->ops->pad->get_frame_desc(sd, pad, fd); 340 if (ret) 341 return ret; 342 343 dev_dbg(sd->dev, "Frame descriptor on pad %u, type %s\n", pad, 344 fd->type == V4L2_MBUS_FRAME_DESC_TYPE_PARALLEL ? "parallel" : 345 fd->type == V4L2_MBUS_FRAME_DESC_TYPE_CSI2 ? "CSI-2" : 346 "unknown"); 347 348 for (i = 0; i < fd->num_entries; i++) { 349 struct v4l2_mbus_frame_desc_entry *entry = &fd->entry[i]; 350 char buf[20] = ""; 351 352 if (fd->type == V4L2_MBUS_FRAME_DESC_TYPE_CSI2) 353 WARN_ON(snprintf(buf, sizeof(buf), 354 ", vc %u, dt 0x%02x", 355 entry->bus.csi2.vc, 356 entry->bus.csi2.dt) >= sizeof(buf)); 357 358 dev_dbg(sd->dev, 359 "\tstream %u, code 0x%04x, length %u, flags 0x%04x%s\n", 360 entry->stream, entry->pixelcode, entry->length, 361 entry->flags, buf); 362 } 363 364 return 0; 365 } 366 367 static inline int check_edid(struct v4l2_subdev *sd, 368 struct v4l2_subdev_edid *edid) 369 { 370 if (!edid) 371 return -EINVAL; 372 373 if (edid->blocks && edid->edid == NULL) 374 return -EINVAL; 375 376 return check_pad(sd, edid->pad); 377 } 378 379 static int call_get_edid(struct v4l2_subdev *sd, struct v4l2_subdev_edid *edid) 380 { 381 return check_edid(sd, edid) ? : sd->ops->pad->get_edid(sd, edid); 382 } 383 384 static int call_set_edid(struct v4l2_subdev *sd, struct v4l2_subdev_edid *edid) 385 { 386 return check_edid(sd, edid) ? : sd->ops->pad->set_edid(sd, edid); 387 } 388 389 static int call_s_dv_timings(struct v4l2_subdev *sd, unsigned int pad, 390 struct v4l2_dv_timings *timings) 391 { 392 if (!timings) 393 return -EINVAL; 394 395 return check_pad(sd, pad) ? : 396 sd->ops->pad->s_dv_timings(sd, pad, timings); 397 } 398 399 static int call_g_dv_timings(struct v4l2_subdev *sd, unsigned int pad, 400 struct v4l2_dv_timings *timings) 401 { 402 if (!timings) 403 return -EINVAL; 404 405 return check_pad(sd, pad) ? : 406 sd->ops->pad->g_dv_timings(sd, pad, timings); 407 } 408 409 static int call_query_dv_timings(struct v4l2_subdev *sd, unsigned int pad, 410 struct v4l2_dv_timings *timings) 411 { 412 if (!timings) 413 return -EINVAL; 414 415 return check_pad(sd, pad) ? : 416 sd->ops->pad->query_dv_timings(sd, pad, timings); 417 } 418 419 static int call_dv_timings_cap(struct v4l2_subdev *sd, 420 struct v4l2_dv_timings_cap *cap) 421 { 422 if (!cap) 423 return -EINVAL; 424 425 return check_pad(sd, cap->pad) ? : 426 sd->ops->pad->dv_timings_cap(sd, cap); 427 } 428 429 static int call_enum_dv_timings(struct v4l2_subdev *sd, 430 struct v4l2_enum_dv_timings *dvt) 431 { 432 if (!dvt) 433 return -EINVAL; 434 435 return check_pad(sd, dvt->pad) ? : 436 sd->ops->pad->enum_dv_timings(sd, dvt); 437 } 438 439 static int call_get_mbus_config(struct v4l2_subdev *sd, unsigned int pad, 440 struct v4l2_mbus_config *config) 441 { 442 return check_pad(sd, pad) ? : 443 sd->ops->pad->get_mbus_config(sd, pad, config); 444 } 445 446 static int call_s_stream(struct v4l2_subdev *sd, int enable) 447 { 448 int ret; 449 450 /* 451 * The .s_stream() operation must never be called to start or stop an 452 * already started or stopped subdev. Catch offenders but don't return 453 * an error yet to avoid regressions. 454 */ 455 if (WARN_ON(sd->s_stream_enabled == !!enable)) 456 return 0; 457 458 ret = sd->ops->video->s_stream(sd, enable); 459 460 if (!enable && ret < 0) { 461 dev_warn(sd->dev, "disabling streaming failed (%d)\n", ret); 462 ret = 0; 463 } 464 465 if (!ret) { 466 sd->s_stream_enabled = enable; 467 468 if (enable) 469 v4l2_subdev_enable_privacy_led(sd); 470 else 471 v4l2_subdev_disable_privacy_led(sd); 472 } 473 474 return ret; 475 } 476 477 #ifdef CONFIG_MEDIA_CONTROLLER 478 /* 479 * Create state-management wrapper for pad ops dealing with subdev state. The 480 * wrapper handles the case where the caller does not provide the called 481 * subdev's state. This should be removed when all the callers are fixed. 482 */ 483 #define DEFINE_STATE_WRAPPER(f, arg_type) \ 484 static int call_##f##_state(struct v4l2_subdev *sd, \ 485 struct v4l2_subdev_state *_state, \ 486 arg_type *arg) \ 487 { \ 488 struct v4l2_subdev_state *state = _state; \ 489 int ret; \ 490 if (!_state) \ 491 state = v4l2_subdev_lock_and_get_active_state(sd); \ 492 ret = call_##f(sd, state, arg); \ 493 if (!_state && state) \ 494 v4l2_subdev_unlock_state(state); \ 495 return ret; \ 496 } 497 498 #else /* CONFIG_MEDIA_CONTROLLER */ 499 500 #define DEFINE_STATE_WRAPPER(f, arg_type) \ 501 static int call_##f##_state(struct v4l2_subdev *sd, \ 502 struct v4l2_subdev_state *state, \ 503 arg_type *arg) \ 504 { \ 505 return call_##f(sd, state, arg); \ 506 } 507 508 #endif /* CONFIG_MEDIA_CONTROLLER */ 509 510 DEFINE_STATE_WRAPPER(get_fmt, struct v4l2_subdev_format); 511 DEFINE_STATE_WRAPPER(set_fmt, struct v4l2_subdev_format); 512 DEFINE_STATE_WRAPPER(enum_mbus_code, struct v4l2_subdev_mbus_code_enum); 513 DEFINE_STATE_WRAPPER(enum_frame_size, struct v4l2_subdev_frame_size_enum); 514 DEFINE_STATE_WRAPPER(enum_frame_interval, struct v4l2_subdev_frame_interval_enum); 515 DEFINE_STATE_WRAPPER(get_selection, struct v4l2_subdev_selection); 516 DEFINE_STATE_WRAPPER(set_selection, struct v4l2_subdev_selection); 517 518 static const struct v4l2_subdev_pad_ops v4l2_subdev_call_pad_wrappers = { 519 .get_fmt = call_get_fmt_state, 520 .set_fmt = call_set_fmt_state, 521 .enum_mbus_code = call_enum_mbus_code_state, 522 .enum_frame_size = call_enum_frame_size_state, 523 .enum_frame_interval = call_enum_frame_interval_state, 524 .get_selection = call_get_selection_state, 525 .set_selection = call_set_selection_state, 526 .get_frame_interval = call_get_frame_interval, 527 .set_frame_interval = call_set_frame_interval, 528 .get_edid = call_get_edid, 529 .set_edid = call_set_edid, 530 .s_dv_timings = call_s_dv_timings, 531 .g_dv_timings = call_g_dv_timings, 532 .query_dv_timings = call_query_dv_timings, 533 .dv_timings_cap = call_dv_timings_cap, 534 .enum_dv_timings = call_enum_dv_timings, 535 .get_frame_desc = call_get_frame_desc, 536 .get_mbus_config = call_get_mbus_config, 537 }; 538 539 static const struct v4l2_subdev_video_ops v4l2_subdev_call_video_wrappers = { 540 .s_stream = call_s_stream, 541 }; 542 543 const struct v4l2_subdev_ops v4l2_subdev_call_wrappers = { 544 .pad = &v4l2_subdev_call_pad_wrappers, 545 .video = &v4l2_subdev_call_video_wrappers, 546 }; 547 EXPORT_SYMBOL(v4l2_subdev_call_wrappers); 548 549 #if defined(CONFIG_VIDEO_V4L2_SUBDEV_API) 550 551 static struct v4l2_subdev_state * 552 subdev_ioctl_get_state(struct v4l2_subdev *sd, struct v4l2_subdev_fh *subdev_fh, 553 unsigned int cmd, void *arg) 554 { 555 u32 which; 556 557 switch (cmd) { 558 default: 559 return NULL; 560 case VIDIOC_SUBDEV_G_FMT: 561 case VIDIOC_SUBDEV_S_FMT: 562 which = ((struct v4l2_subdev_format *)arg)->which; 563 break; 564 case VIDIOC_SUBDEV_G_CROP: 565 case VIDIOC_SUBDEV_S_CROP: 566 which = ((struct v4l2_subdev_crop *)arg)->which; 567 break; 568 case VIDIOC_SUBDEV_ENUM_MBUS_CODE: 569 which = ((struct v4l2_subdev_mbus_code_enum *)arg)->which; 570 break; 571 case VIDIOC_SUBDEV_ENUM_FRAME_SIZE: 572 which = ((struct v4l2_subdev_frame_size_enum *)arg)->which; 573 break; 574 case VIDIOC_SUBDEV_ENUM_FRAME_INTERVAL: 575 which = ((struct v4l2_subdev_frame_interval_enum *)arg)->which; 576 break; 577 case VIDIOC_SUBDEV_G_SELECTION: 578 case VIDIOC_SUBDEV_S_SELECTION: 579 which = ((struct v4l2_subdev_selection *)arg)->which; 580 break; 581 case VIDIOC_SUBDEV_G_FRAME_INTERVAL: 582 case VIDIOC_SUBDEV_S_FRAME_INTERVAL: { 583 struct v4l2_subdev_frame_interval *fi = arg; 584 585 if (!(subdev_fh->client_caps & 586 V4L2_SUBDEV_CLIENT_CAP_INTERVAL_USES_WHICH)) 587 fi->which = V4L2_SUBDEV_FORMAT_ACTIVE; 588 589 which = fi->which; 590 break; 591 } 592 case VIDIOC_SUBDEV_G_ROUTING: 593 case VIDIOC_SUBDEV_S_ROUTING: 594 which = ((struct v4l2_subdev_routing *)arg)->which; 595 break; 596 } 597 598 return which == V4L2_SUBDEV_FORMAT_TRY ? 599 subdev_fh->state : 600 v4l2_subdev_get_unlocked_active_state(sd); 601 } 602 603 static long subdev_do_ioctl(struct file *file, unsigned int cmd, void *arg, 604 struct v4l2_subdev_state *state) 605 { 606 struct video_device *vdev = video_devdata(file); 607 struct v4l2_subdev *sd = vdev_to_v4l2_subdev(vdev); 608 struct v4l2_fh *vfh = file->private_data; 609 struct v4l2_subdev_fh *subdev_fh = to_v4l2_subdev_fh(vfh); 610 bool ro_subdev = test_bit(V4L2_FL_SUBDEV_RO_DEVNODE, &vdev->flags); 611 bool streams_subdev = sd->flags & V4L2_SUBDEV_FL_STREAMS; 612 bool client_supports_streams = subdev_fh->client_caps & 613 V4L2_SUBDEV_CLIENT_CAP_STREAMS; 614 int rval; 615 616 /* 617 * If the streams API is not enabled, remove V4L2_SUBDEV_CAP_STREAMS. 618 * Remove this when the API is no longer experimental. 619 */ 620 if (!v4l2_subdev_enable_streams_api) 621 streams_subdev = false; 622 623 switch (cmd) { 624 case VIDIOC_SUBDEV_QUERYCAP: { 625 struct v4l2_subdev_capability *cap = arg; 626 627 memset(cap->reserved, 0, sizeof(cap->reserved)); 628 cap->version = LINUX_VERSION_CODE; 629 cap->capabilities = 630 (ro_subdev ? V4L2_SUBDEV_CAP_RO_SUBDEV : 0) | 631 (streams_subdev ? V4L2_SUBDEV_CAP_STREAMS : 0); 632 633 return 0; 634 } 635 636 case VIDIOC_QUERYCTRL: 637 /* 638 * TODO: this really should be folded into v4l2_queryctrl (this 639 * currently returns -EINVAL for NULL control handlers). 640 * However, v4l2_queryctrl() is still called directly by 641 * drivers as well and until that has been addressed I believe 642 * it is safer to do the check here. The same is true for the 643 * other control ioctls below. 644 */ 645 if (!vfh->ctrl_handler) 646 return -ENOTTY; 647 return v4l2_queryctrl(vfh->ctrl_handler, arg); 648 649 case VIDIOC_QUERY_EXT_CTRL: 650 if (!vfh->ctrl_handler) 651 return -ENOTTY; 652 return v4l2_query_ext_ctrl(vfh->ctrl_handler, arg); 653 654 case VIDIOC_QUERYMENU: 655 if (!vfh->ctrl_handler) 656 return -ENOTTY; 657 return v4l2_querymenu(vfh->ctrl_handler, arg); 658 659 case VIDIOC_G_CTRL: 660 if (!vfh->ctrl_handler) 661 return -ENOTTY; 662 return v4l2_g_ctrl(vfh->ctrl_handler, arg); 663 664 case VIDIOC_S_CTRL: 665 if (!vfh->ctrl_handler) 666 return -ENOTTY; 667 return v4l2_s_ctrl(vfh, vfh->ctrl_handler, arg); 668 669 case VIDIOC_G_EXT_CTRLS: 670 if (!vfh->ctrl_handler) 671 return -ENOTTY; 672 return v4l2_g_ext_ctrls(vfh->ctrl_handler, 673 vdev, sd->v4l2_dev->mdev, arg); 674 675 case VIDIOC_S_EXT_CTRLS: 676 if (!vfh->ctrl_handler) 677 return -ENOTTY; 678 return v4l2_s_ext_ctrls(vfh, vfh->ctrl_handler, 679 vdev, sd->v4l2_dev->mdev, arg); 680 681 case VIDIOC_TRY_EXT_CTRLS: 682 if (!vfh->ctrl_handler) 683 return -ENOTTY; 684 return v4l2_try_ext_ctrls(vfh->ctrl_handler, 685 vdev, sd->v4l2_dev->mdev, arg); 686 687 case VIDIOC_DQEVENT: 688 if (!(sd->flags & V4L2_SUBDEV_FL_HAS_EVENTS)) 689 return -ENOIOCTLCMD; 690 691 return v4l2_event_dequeue(vfh, arg, file->f_flags & O_NONBLOCK); 692 693 case VIDIOC_SUBSCRIBE_EVENT: 694 return v4l2_subdev_call(sd, core, subscribe_event, vfh, arg); 695 696 case VIDIOC_UNSUBSCRIBE_EVENT: 697 return v4l2_subdev_call(sd, core, unsubscribe_event, vfh, arg); 698 699 #ifdef CONFIG_VIDEO_ADV_DEBUG 700 case VIDIOC_DBG_G_REGISTER: 701 { 702 struct v4l2_dbg_register *p = arg; 703 704 if (!capable(CAP_SYS_ADMIN)) 705 return -EPERM; 706 return v4l2_subdev_call(sd, core, g_register, p); 707 } 708 case VIDIOC_DBG_S_REGISTER: 709 { 710 struct v4l2_dbg_register *p = arg; 711 712 if (!capable(CAP_SYS_ADMIN)) 713 return -EPERM; 714 return v4l2_subdev_call(sd, core, s_register, p); 715 } 716 case VIDIOC_DBG_G_CHIP_INFO: 717 { 718 struct v4l2_dbg_chip_info *p = arg; 719 720 if (p->match.type != V4L2_CHIP_MATCH_SUBDEV || p->match.addr) 721 return -EINVAL; 722 if (sd->ops->core && sd->ops->core->s_register) 723 p->flags |= V4L2_CHIP_FL_WRITABLE; 724 if (sd->ops->core && sd->ops->core->g_register) 725 p->flags |= V4L2_CHIP_FL_READABLE; 726 strscpy(p->name, sd->name, sizeof(p->name)); 727 return 0; 728 } 729 #endif 730 731 case VIDIOC_LOG_STATUS: { 732 int ret; 733 734 pr_info("%s: ================= START STATUS =================\n", 735 sd->name); 736 ret = v4l2_subdev_call(sd, core, log_status); 737 pr_info("%s: ================== END STATUS ==================\n", 738 sd->name); 739 return ret; 740 } 741 742 case VIDIOC_SUBDEV_G_FMT: { 743 struct v4l2_subdev_format *format = arg; 744 745 if (!client_supports_streams) 746 format->stream = 0; 747 748 memset(format->reserved, 0, sizeof(format->reserved)); 749 memset(format->format.reserved, 0, sizeof(format->format.reserved)); 750 return v4l2_subdev_call(sd, pad, get_fmt, state, format); 751 } 752 753 case VIDIOC_SUBDEV_S_FMT: { 754 struct v4l2_subdev_format *format = arg; 755 756 if (format->which != V4L2_SUBDEV_FORMAT_TRY && ro_subdev) 757 return -EPERM; 758 759 if (!client_supports_streams) 760 format->stream = 0; 761 762 memset(format->reserved, 0, sizeof(format->reserved)); 763 memset(format->format.reserved, 0, sizeof(format->format.reserved)); 764 return v4l2_subdev_call(sd, pad, set_fmt, state, format); 765 } 766 767 case VIDIOC_SUBDEV_G_CROP: { 768 struct v4l2_subdev_crop *crop = arg; 769 struct v4l2_subdev_selection sel; 770 771 if (!client_supports_streams) 772 crop->stream = 0; 773 774 memset(crop->reserved, 0, sizeof(crop->reserved)); 775 memset(&sel, 0, sizeof(sel)); 776 sel.which = crop->which; 777 sel.pad = crop->pad; 778 sel.stream = crop->stream; 779 sel.target = V4L2_SEL_TGT_CROP; 780 781 rval = v4l2_subdev_call( 782 sd, pad, get_selection, state, &sel); 783 784 crop->rect = sel.r; 785 786 return rval; 787 } 788 789 case VIDIOC_SUBDEV_S_CROP: { 790 struct v4l2_subdev_crop *crop = arg; 791 struct v4l2_subdev_selection sel; 792 793 if (crop->which != V4L2_SUBDEV_FORMAT_TRY && ro_subdev) 794 return -EPERM; 795 796 if (!client_supports_streams) 797 crop->stream = 0; 798 799 memset(crop->reserved, 0, sizeof(crop->reserved)); 800 memset(&sel, 0, sizeof(sel)); 801 sel.which = crop->which; 802 sel.pad = crop->pad; 803 sel.stream = crop->stream; 804 sel.target = V4L2_SEL_TGT_CROP; 805 sel.r = crop->rect; 806 807 rval = v4l2_subdev_call( 808 sd, pad, set_selection, state, &sel); 809 810 crop->rect = sel.r; 811 812 return rval; 813 } 814 815 case VIDIOC_SUBDEV_ENUM_MBUS_CODE: { 816 struct v4l2_subdev_mbus_code_enum *code = arg; 817 818 if (!client_supports_streams) 819 code->stream = 0; 820 821 memset(code->reserved, 0, sizeof(code->reserved)); 822 return v4l2_subdev_call(sd, pad, enum_mbus_code, state, 823 code); 824 } 825 826 case VIDIOC_SUBDEV_ENUM_FRAME_SIZE: { 827 struct v4l2_subdev_frame_size_enum *fse = arg; 828 829 if (!client_supports_streams) 830 fse->stream = 0; 831 832 memset(fse->reserved, 0, sizeof(fse->reserved)); 833 return v4l2_subdev_call(sd, pad, enum_frame_size, state, 834 fse); 835 } 836 837 case VIDIOC_SUBDEV_G_FRAME_INTERVAL: { 838 struct v4l2_subdev_frame_interval *fi = arg; 839 840 if (!client_supports_streams) 841 fi->stream = 0; 842 843 memset(fi->reserved, 0, sizeof(fi->reserved)); 844 return v4l2_subdev_call(sd, pad, get_frame_interval, state, fi); 845 } 846 847 case VIDIOC_SUBDEV_S_FRAME_INTERVAL: { 848 struct v4l2_subdev_frame_interval *fi = arg; 849 850 if (!client_supports_streams) 851 fi->stream = 0; 852 853 if (fi->which != V4L2_SUBDEV_FORMAT_TRY && ro_subdev) 854 return -EPERM; 855 856 memset(fi->reserved, 0, sizeof(fi->reserved)); 857 return v4l2_subdev_call(sd, pad, set_frame_interval, state, fi); 858 } 859 860 case VIDIOC_SUBDEV_ENUM_FRAME_INTERVAL: { 861 struct v4l2_subdev_frame_interval_enum *fie = arg; 862 863 if (!client_supports_streams) 864 fie->stream = 0; 865 866 memset(fie->reserved, 0, sizeof(fie->reserved)); 867 return v4l2_subdev_call(sd, pad, enum_frame_interval, state, 868 fie); 869 } 870 871 case VIDIOC_SUBDEV_G_SELECTION: { 872 struct v4l2_subdev_selection *sel = arg; 873 874 if (!client_supports_streams) 875 sel->stream = 0; 876 877 memset(sel->reserved, 0, sizeof(sel->reserved)); 878 return v4l2_subdev_call( 879 sd, pad, get_selection, state, sel); 880 } 881 882 case VIDIOC_SUBDEV_S_SELECTION: { 883 struct v4l2_subdev_selection *sel = arg; 884 885 if (sel->which != V4L2_SUBDEV_FORMAT_TRY && ro_subdev) 886 return -EPERM; 887 888 if (!client_supports_streams) 889 sel->stream = 0; 890 891 memset(sel->reserved, 0, sizeof(sel->reserved)); 892 return v4l2_subdev_call( 893 sd, pad, set_selection, state, sel); 894 } 895 896 case VIDIOC_G_EDID: { 897 struct v4l2_subdev_edid *edid = arg; 898 899 return v4l2_subdev_call(sd, pad, get_edid, edid); 900 } 901 902 case VIDIOC_S_EDID: { 903 struct v4l2_subdev_edid *edid = arg; 904 905 return v4l2_subdev_call(sd, pad, set_edid, edid); 906 } 907 908 case VIDIOC_SUBDEV_DV_TIMINGS_CAP: { 909 struct v4l2_dv_timings_cap *cap = arg; 910 911 return v4l2_subdev_call(sd, pad, dv_timings_cap, cap); 912 } 913 914 case VIDIOC_SUBDEV_ENUM_DV_TIMINGS: { 915 struct v4l2_enum_dv_timings *dvt = arg; 916 917 return v4l2_subdev_call(sd, pad, enum_dv_timings, dvt); 918 } 919 920 case VIDIOC_SUBDEV_QUERY_DV_TIMINGS: 921 return v4l2_subdev_call(sd, pad, query_dv_timings, 0, arg); 922 923 case VIDIOC_SUBDEV_G_DV_TIMINGS: 924 return v4l2_subdev_call(sd, pad, g_dv_timings, 0, arg); 925 926 case VIDIOC_SUBDEV_S_DV_TIMINGS: 927 if (ro_subdev) 928 return -EPERM; 929 930 return v4l2_subdev_call(sd, pad, s_dv_timings, 0, arg); 931 932 case VIDIOC_SUBDEV_G_STD: 933 return v4l2_subdev_call(sd, video, g_std, arg); 934 935 case VIDIOC_SUBDEV_S_STD: { 936 v4l2_std_id *std = arg; 937 938 if (ro_subdev) 939 return -EPERM; 940 941 return v4l2_subdev_call(sd, video, s_std, *std); 942 } 943 944 case VIDIOC_SUBDEV_ENUMSTD: { 945 struct v4l2_standard *p = arg; 946 v4l2_std_id id; 947 948 if (v4l2_subdev_call(sd, video, g_tvnorms, &id)) 949 return -EINVAL; 950 951 return v4l_video_std_enumstd(p, id); 952 } 953 954 case VIDIOC_SUBDEV_QUERYSTD: 955 return v4l2_subdev_call(sd, video, querystd, arg); 956 957 case VIDIOC_SUBDEV_G_ROUTING: { 958 struct v4l2_subdev_routing *routing = arg; 959 struct v4l2_subdev_krouting *krouting; 960 961 if (!v4l2_subdev_enable_streams_api) 962 return -ENOIOCTLCMD; 963 964 if (!(sd->flags & V4L2_SUBDEV_FL_STREAMS)) 965 return -ENOIOCTLCMD; 966 967 memset(routing->reserved, 0, sizeof(routing->reserved)); 968 969 krouting = &state->routing; 970 971 memcpy((struct v4l2_subdev_route *)(uintptr_t)routing->routes, 972 krouting->routes, 973 min(krouting->num_routes, routing->len_routes) * 974 sizeof(*krouting->routes)); 975 routing->num_routes = krouting->num_routes; 976 977 return 0; 978 } 979 980 case VIDIOC_SUBDEV_S_ROUTING: { 981 struct v4l2_subdev_routing *routing = arg; 982 struct v4l2_subdev_route *routes = 983 (struct v4l2_subdev_route *)(uintptr_t)routing->routes; 984 struct v4l2_subdev_krouting krouting = {}; 985 unsigned int i; 986 987 if (!v4l2_subdev_enable_streams_api) 988 return -ENOIOCTLCMD; 989 990 if (!(sd->flags & V4L2_SUBDEV_FL_STREAMS)) 991 return -ENOIOCTLCMD; 992 993 if (routing->which != V4L2_SUBDEV_FORMAT_TRY && ro_subdev) 994 return -EPERM; 995 996 if (routing->num_routes > routing->len_routes) 997 return -EINVAL; 998 999 memset(routing->reserved, 0, sizeof(routing->reserved)); 1000 1001 for (i = 0; i < routing->num_routes; ++i) { 1002 const struct v4l2_subdev_route *route = &routes[i]; 1003 const struct media_pad *pads = sd->entity.pads; 1004 1005 if (route->sink_stream > V4L2_SUBDEV_MAX_STREAM_ID || 1006 route->source_stream > V4L2_SUBDEV_MAX_STREAM_ID) 1007 return -EINVAL; 1008 1009 if (route->sink_pad >= sd->entity.num_pads) 1010 return -EINVAL; 1011 1012 if (!(pads[route->sink_pad].flags & 1013 MEDIA_PAD_FL_SINK)) 1014 return -EINVAL; 1015 1016 if (route->source_pad >= sd->entity.num_pads) 1017 return -EINVAL; 1018 1019 if (!(pads[route->source_pad].flags & 1020 MEDIA_PAD_FL_SOURCE)) 1021 return -EINVAL; 1022 } 1023 1024 /* 1025 * If the driver doesn't support setting routing, just return 1026 * the routing table. 1027 */ 1028 if (!v4l2_subdev_has_op(sd, pad, set_routing)) { 1029 memcpy((struct v4l2_subdev_route *)(uintptr_t)routing->routes, 1030 state->routing.routes, 1031 min(state->routing.num_routes, routing->len_routes) * 1032 sizeof(*state->routing.routes)); 1033 routing->num_routes = state->routing.num_routes; 1034 1035 return 0; 1036 } 1037 1038 krouting.num_routes = routing->num_routes; 1039 krouting.len_routes = routing->len_routes; 1040 krouting.routes = routes; 1041 1042 rval = v4l2_subdev_call(sd, pad, set_routing, state, 1043 routing->which, &krouting); 1044 if (rval < 0) 1045 return rval; 1046 1047 memcpy((struct v4l2_subdev_route *)(uintptr_t)routing->routes, 1048 state->routing.routes, 1049 min(state->routing.num_routes, routing->len_routes) * 1050 sizeof(*state->routing.routes)); 1051 routing->num_routes = state->routing.num_routes; 1052 1053 return 0; 1054 } 1055 1056 case VIDIOC_SUBDEV_G_CLIENT_CAP: { 1057 struct v4l2_subdev_client_capability *client_cap = arg; 1058 1059 client_cap->capabilities = subdev_fh->client_caps; 1060 1061 return 0; 1062 } 1063 1064 case VIDIOC_SUBDEV_S_CLIENT_CAP: { 1065 struct v4l2_subdev_client_capability *client_cap = arg; 1066 1067 /* 1068 * Clear V4L2_SUBDEV_CLIENT_CAP_STREAMS if streams API is not 1069 * enabled. Remove this when streams API is no longer 1070 * experimental. 1071 */ 1072 if (!v4l2_subdev_enable_streams_api) 1073 client_cap->capabilities &= ~V4L2_SUBDEV_CLIENT_CAP_STREAMS; 1074 1075 /* Filter out unsupported capabilities */ 1076 client_cap->capabilities &= (V4L2_SUBDEV_CLIENT_CAP_STREAMS | 1077 V4L2_SUBDEV_CLIENT_CAP_INTERVAL_USES_WHICH); 1078 1079 subdev_fh->client_caps = client_cap->capabilities; 1080 1081 return 0; 1082 } 1083 1084 default: 1085 return v4l2_subdev_call(sd, core, ioctl, cmd, arg); 1086 } 1087 1088 return 0; 1089 } 1090 1091 static long subdev_do_ioctl_lock(struct file *file, unsigned int cmd, void *arg) 1092 { 1093 struct video_device *vdev = video_devdata(file); 1094 struct mutex *lock = vdev->lock; 1095 long ret = -ENODEV; 1096 1097 if (lock && mutex_lock_interruptible(lock)) 1098 return -ERESTARTSYS; 1099 1100 if (video_is_registered(vdev)) { 1101 struct v4l2_subdev *sd = vdev_to_v4l2_subdev(vdev); 1102 struct v4l2_fh *vfh = file->private_data; 1103 struct v4l2_subdev_fh *subdev_fh = to_v4l2_subdev_fh(vfh); 1104 struct v4l2_subdev_state *state; 1105 1106 state = subdev_ioctl_get_state(sd, subdev_fh, cmd, arg); 1107 1108 if (state) 1109 v4l2_subdev_lock_state(state); 1110 1111 ret = subdev_do_ioctl(file, cmd, arg, state); 1112 1113 if (state) 1114 v4l2_subdev_unlock_state(state); 1115 } 1116 1117 if (lock) 1118 mutex_unlock(lock); 1119 return ret; 1120 } 1121 1122 static long subdev_ioctl(struct file *file, unsigned int cmd, 1123 unsigned long arg) 1124 { 1125 return video_usercopy(file, cmd, arg, subdev_do_ioctl_lock); 1126 } 1127 1128 #ifdef CONFIG_COMPAT 1129 static long subdev_compat_ioctl32(struct file *file, unsigned int cmd, 1130 unsigned long arg) 1131 { 1132 struct video_device *vdev = video_devdata(file); 1133 struct v4l2_subdev *sd = vdev_to_v4l2_subdev(vdev); 1134 1135 return v4l2_subdev_call(sd, core, compat_ioctl32, cmd, arg); 1136 } 1137 #endif 1138 1139 #else /* CONFIG_VIDEO_V4L2_SUBDEV_API */ 1140 static long subdev_ioctl(struct file *file, unsigned int cmd, 1141 unsigned long arg) 1142 { 1143 return -ENODEV; 1144 } 1145 1146 #ifdef CONFIG_COMPAT 1147 static long subdev_compat_ioctl32(struct file *file, unsigned int cmd, 1148 unsigned long arg) 1149 { 1150 return -ENODEV; 1151 } 1152 #endif 1153 #endif /* CONFIG_VIDEO_V4L2_SUBDEV_API */ 1154 1155 static __poll_t subdev_poll(struct file *file, poll_table *wait) 1156 { 1157 struct video_device *vdev = video_devdata(file); 1158 struct v4l2_subdev *sd = vdev_to_v4l2_subdev(vdev); 1159 struct v4l2_fh *fh = file->private_data; 1160 1161 if (!(sd->flags & V4L2_SUBDEV_FL_HAS_EVENTS)) 1162 return EPOLLERR; 1163 1164 poll_wait(file, &fh->wait, wait); 1165 1166 if (v4l2_event_pending(fh)) 1167 return EPOLLPRI; 1168 1169 return 0; 1170 } 1171 1172 const struct v4l2_file_operations v4l2_subdev_fops = { 1173 .owner = THIS_MODULE, 1174 .open = subdev_open, 1175 .unlocked_ioctl = subdev_ioctl, 1176 #ifdef CONFIG_COMPAT 1177 .compat_ioctl32 = subdev_compat_ioctl32, 1178 #endif 1179 .release = subdev_close, 1180 .poll = subdev_poll, 1181 }; 1182 1183 #ifdef CONFIG_MEDIA_CONTROLLER 1184 1185 int v4l2_subdev_get_fwnode_pad_1_to_1(struct media_entity *entity, 1186 struct fwnode_endpoint *endpoint) 1187 { 1188 struct fwnode_handle *fwnode; 1189 struct v4l2_subdev *sd; 1190 1191 if (!is_media_entity_v4l2_subdev(entity)) 1192 return -EINVAL; 1193 1194 sd = media_entity_to_v4l2_subdev(entity); 1195 1196 fwnode = fwnode_graph_get_port_parent(endpoint->local_fwnode); 1197 fwnode_handle_put(fwnode); 1198 1199 if (device_match_fwnode(sd->dev, fwnode)) 1200 return endpoint->port; 1201 1202 return -ENXIO; 1203 } 1204 EXPORT_SYMBOL_GPL(v4l2_subdev_get_fwnode_pad_1_to_1); 1205 1206 int v4l2_subdev_link_validate_default(struct v4l2_subdev *sd, 1207 struct media_link *link, 1208 struct v4l2_subdev_format *source_fmt, 1209 struct v4l2_subdev_format *sink_fmt) 1210 { 1211 bool pass = true; 1212 1213 /* The width, height and code must match. */ 1214 if (source_fmt->format.width != sink_fmt->format.width) { 1215 dev_dbg(sd->entity.graph_obj.mdev->dev, 1216 "%s: width does not match (source %u, sink %u)\n", 1217 __func__, 1218 source_fmt->format.width, sink_fmt->format.width); 1219 pass = false; 1220 } 1221 1222 if (source_fmt->format.height != sink_fmt->format.height) { 1223 dev_dbg(sd->entity.graph_obj.mdev->dev, 1224 "%s: height does not match (source %u, sink %u)\n", 1225 __func__, 1226 source_fmt->format.height, sink_fmt->format.height); 1227 pass = false; 1228 } 1229 1230 if (source_fmt->format.code != sink_fmt->format.code) { 1231 dev_dbg(sd->entity.graph_obj.mdev->dev, 1232 "%s: media bus code does not match (source 0x%8.8x, sink 0x%8.8x)\n", 1233 __func__, 1234 source_fmt->format.code, sink_fmt->format.code); 1235 pass = false; 1236 } 1237 1238 /* The field order must match, or the sink field order must be NONE 1239 * to support interlaced hardware connected to bridges that support 1240 * progressive formats only. 1241 */ 1242 if (source_fmt->format.field != sink_fmt->format.field && 1243 sink_fmt->format.field != V4L2_FIELD_NONE) { 1244 dev_dbg(sd->entity.graph_obj.mdev->dev, 1245 "%s: field does not match (source %u, sink %u)\n", 1246 __func__, 1247 source_fmt->format.field, sink_fmt->format.field); 1248 pass = false; 1249 } 1250 1251 if (pass) 1252 return 0; 1253 1254 dev_dbg(sd->entity.graph_obj.mdev->dev, 1255 "%s: link was \"%s\":%u -> \"%s\":%u\n", __func__, 1256 link->source->entity->name, link->source->index, 1257 link->sink->entity->name, link->sink->index); 1258 1259 return -EPIPE; 1260 } 1261 EXPORT_SYMBOL_GPL(v4l2_subdev_link_validate_default); 1262 1263 static int 1264 v4l2_subdev_link_validate_get_format(struct media_pad *pad, u32 stream, 1265 struct v4l2_subdev_format *fmt, 1266 bool states_locked) 1267 { 1268 struct v4l2_subdev_state *state; 1269 struct v4l2_subdev *sd; 1270 int ret; 1271 1272 sd = media_entity_to_v4l2_subdev(pad->entity); 1273 1274 fmt->which = V4L2_SUBDEV_FORMAT_ACTIVE; 1275 fmt->pad = pad->index; 1276 fmt->stream = stream; 1277 1278 if (states_locked) 1279 state = v4l2_subdev_get_locked_active_state(sd); 1280 else 1281 state = v4l2_subdev_lock_and_get_active_state(sd); 1282 1283 ret = v4l2_subdev_call(sd, pad, get_fmt, state, fmt); 1284 1285 if (!states_locked && state) 1286 v4l2_subdev_unlock_state(state); 1287 1288 return ret; 1289 } 1290 1291 #if defined(CONFIG_VIDEO_V4L2_SUBDEV_API) 1292 1293 static void __v4l2_link_validate_get_streams(struct media_pad *pad, 1294 u64 *streams_mask, 1295 bool states_locked) 1296 { 1297 struct v4l2_subdev_route *route; 1298 struct v4l2_subdev_state *state; 1299 struct v4l2_subdev *subdev; 1300 1301 subdev = media_entity_to_v4l2_subdev(pad->entity); 1302 1303 *streams_mask = 0; 1304 1305 if (states_locked) 1306 state = v4l2_subdev_get_locked_active_state(subdev); 1307 else 1308 state = v4l2_subdev_lock_and_get_active_state(subdev); 1309 1310 if (WARN_ON(!state)) 1311 return; 1312 1313 for_each_active_route(&state->routing, route) { 1314 u32 route_pad; 1315 u32 route_stream; 1316 1317 if (pad->flags & MEDIA_PAD_FL_SOURCE) { 1318 route_pad = route->source_pad; 1319 route_stream = route->source_stream; 1320 } else { 1321 route_pad = route->sink_pad; 1322 route_stream = route->sink_stream; 1323 } 1324 1325 if (route_pad != pad->index) 1326 continue; 1327 1328 *streams_mask |= BIT_ULL(route_stream); 1329 } 1330 1331 if (!states_locked) 1332 v4l2_subdev_unlock_state(state); 1333 } 1334 1335 #endif /* CONFIG_VIDEO_V4L2_SUBDEV_API */ 1336 1337 static void v4l2_link_validate_get_streams(struct media_pad *pad, 1338 u64 *streams_mask, 1339 bool states_locked) 1340 { 1341 struct v4l2_subdev *subdev = media_entity_to_v4l2_subdev(pad->entity); 1342 1343 if (!(subdev->flags & V4L2_SUBDEV_FL_STREAMS)) { 1344 /* Non-streams subdevs have an implicit stream 0 */ 1345 *streams_mask = BIT_ULL(0); 1346 return; 1347 } 1348 1349 #if defined(CONFIG_VIDEO_V4L2_SUBDEV_API) 1350 __v4l2_link_validate_get_streams(pad, streams_mask, states_locked); 1351 #else 1352 /* This shouldn't happen */ 1353 *streams_mask = 0; 1354 #endif 1355 } 1356 1357 static int v4l2_subdev_link_validate_locked(struct media_link *link, bool states_locked) 1358 { 1359 struct v4l2_subdev *sink_subdev = 1360 media_entity_to_v4l2_subdev(link->sink->entity); 1361 struct device *dev = sink_subdev->entity.graph_obj.mdev->dev; 1362 u64 source_streams_mask; 1363 u64 sink_streams_mask; 1364 u64 dangling_sink_streams; 1365 u32 stream; 1366 int ret; 1367 1368 dev_dbg(dev, "validating link \"%s\":%u -> \"%s\":%u\n", 1369 link->source->entity->name, link->source->index, 1370 link->sink->entity->name, link->sink->index); 1371 1372 v4l2_link_validate_get_streams(link->source, &source_streams_mask, states_locked); 1373 v4l2_link_validate_get_streams(link->sink, &sink_streams_mask, states_locked); 1374 1375 /* 1376 * It is ok to have more source streams than sink streams as extra 1377 * source streams can just be ignored by the receiver, but having extra 1378 * sink streams is an error as streams must have a source. 1379 */ 1380 dangling_sink_streams = (source_streams_mask ^ sink_streams_mask) & 1381 sink_streams_mask; 1382 if (dangling_sink_streams) { 1383 dev_err(dev, "Dangling sink streams: mask %#llx\n", 1384 dangling_sink_streams); 1385 return -EINVAL; 1386 } 1387 1388 /* Validate source and sink stream formats */ 1389 1390 for (stream = 0; stream < sizeof(sink_streams_mask) * 8; ++stream) { 1391 struct v4l2_subdev_format sink_fmt, source_fmt; 1392 1393 if (!(sink_streams_mask & BIT_ULL(stream))) 1394 continue; 1395 1396 dev_dbg(dev, "validating stream \"%s\":%u:%u -> \"%s\":%u:%u\n", 1397 link->source->entity->name, link->source->index, stream, 1398 link->sink->entity->name, link->sink->index, stream); 1399 1400 ret = v4l2_subdev_link_validate_get_format(link->source, stream, 1401 &source_fmt, states_locked); 1402 if (ret < 0) { 1403 dev_dbg(dev, 1404 "Failed to get format for \"%s\":%u:%u (but that's ok)\n", 1405 link->source->entity->name, link->source->index, 1406 stream); 1407 continue; 1408 } 1409 1410 ret = v4l2_subdev_link_validate_get_format(link->sink, stream, 1411 &sink_fmt, states_locked); 1412 if (ret < 0) { 1413 dev_dbg(dev, 1414 "Failed to get format for \"%s\":%u:%u (but that's ok)\n", 1415 link->sink->entity->name, link->sink->index, 1416 stream); 1417 continue; 1418 } 1419 1420 /* TODO: add stream number to link_validate() */ 1421 ret = v4l2_subdev_call(sink_subdev, pad, link_validate, link, 1422 &source_fmt, &sink_fmt); 1423 if (!ret) 1424 continue; 1425 1426 if (ret != -ENOIOCTLCMD) 1427 return ret; 1428 1429 ret = v4l2_subdev_link_validate_default(sink_subdev, link, 1430 &source_fmt, &sink_fmt); 1431 1432 if (ret) 1433 return ret; 1434 } 1435 1436 return 0; 1437 } 1438 1439 int v4l2_subdev_link_validate(struct media_link *link) 1440 { 1441 struct v4l2_subdev *source_sd, *sink_sd; 1442 struct v4l2_subdev_state *source_state, *sink_state; 1443 bool states_locked; 1444 int ret; 1445 1446 /* 1447 * Links are validated in the context of the sink entity. Usage of this 1448 * helper on a sink that is not a subdev is a clear driver bug. 1449 */ 1450 if (WARN_ON_ONCE(!is_media_entity_v4l2_subdev(link->sink->entity))) 1451 return -EINVAL; 1452 1453 /* 1454 * If the source is a video device, delegate link validation to it. This 1455 * allows usage of this helper for subdev connected to a video output 1456 * device, provided that the driver implement the video output device's 1457 * .link_validate() operation. 1458 */ 1459 if (is_media_entity_v4l2_video_device(link->source->entity)) { 1460 struct media_entity *source = link->source->entity; 1461 1462 if (!source->ops || !source->ops->link_validate) { 1463 /* 1464 * Many existing drivers do not implement the required 1465 * .link_validate() operation for their video devices. 1466 * Print a warning to get the drivers fixed, and return 1467 * 0 to avoid breaking userspace. This should 1468 * eventually be turned into a WARN_ON() when all 1469 * drivers will have been fixed. 1470 */ 1471 pr_warn_once("video device '%s' does not implement .link_validate(), driver bug!\n", 1472 source->name); 1473 return 0; 1474 } 1475 1476 /* 1477 * Avoid infinite loops in case a video device incorrectly uses 1478 * this helper function as its .link_validate() handler. 1479 */ 1480 if (WARN_ON(source->ops->link_validate == v4l2_subdev_link_validate)) 1481 return -EINVAL; 1482 1483 return source->ops->link_validate(link); 1484 } 1485 1486 /* 1487 * If the source is still not a subdev, usage of this helper is a clear 1488 * driver bug. 1489 */ 1490 if (WARN_ON(!is_media_entity_v4l2_subdev(link->source->entity))) 1491 return -EINVAL; 1492 1493 sink_sd = media_entity_to_v4l2_subdev(link->sink->entity); 1494 source_sd = media_entity_to_v4l2_subdev(link->source->entity); 1495 1496 sink_state = v4l2_subdev_get_unlocked_active_state(sink_sd); 1497 source_state = v4l2_subdev_get_unlocked_active_state(source_sd); 1498 1499 states_locked = sink_state && source_state; 1500 1501 if (states_locked) 1502 v4l2_subdev_lock_states(sink_state, source_state); 1503 1504 ret = v4l2_subdev_link_validate_locked(link, states_locked); 1505 1506 if (states_locked) 1507 v4l2_subdev_unlock_states(sink_state, source_state); 1508 1509 return ret; 1510 } 1511 EXPORT_SYMBOL_GPL(v4l2_subdev_link_validate); 1512 1513 bool v4l2_subdev_has_pad_interdep(struct media_entity *entity, 1514 unsigned int pad0, unsigned int pad1) 1515 { 1516 struct v4l2_subdev *sd = media_entity_to_v4l2_subdev(entity); 1517 struct v4l2_subdev_krouting *routing; 1518 struct v4l2_subdev_state *state; 1519 unsigned int i; 1520 1521 state = v4l2_subdev_lock_and_get_active_state(sd); 1522 1523 routing = &state->routing; 1524 1525 for (i = 0; i < routing->num_routes; ++i) { 1526 struct v4l2_subdev_route *route = &routing->routes[i]; 1527 1528 if (!(route->flags & V4L2_SUBDEV_ROUTE_FL_ACTIVE)) 1529 continue; 1530 1531 if ((route->sink_pad == pad0 && route->source_pad == pad1) || 1532 (route->source_pad == pad0 && route->sink_pad == pad1)) { 1533 v4l2_subdev_unlock_state(state); 1534 return true; 1535 } 1536 } 1537 1538 v4l2_subdev_unlock_state(state); 1539 1540 return false; 1541 } 1542 EXPORT_SYMBOL_GPL(v4l2_subdev_has_pad_interdep); 1543 1544 struct v4l2_subdev_state * 1545 __v4l2_subdev_state_alloc(struct v4l2_subdev *sd, const char *lock_name, 1546 struct lock_class_key *lock_key) 1547 { 1548 struct v4l2_subdev_state *state; 1549 int ret; 1550 1551 state = kzalloc(sizeof(*state), GFP_KERNEL); 1552 if (!state) 1553 return ERR_PTR(-ENOMEM); 1554 1555 __mutex_init(&state->_lock, lock_name, lock_key); 1556 if (sd->state_lock) 1557 state->lock = sd->state_lock; 1558 else 1559 state->lock = &state->_lock; 1560 1561 state->sd = sd; 1562 1563 /* Drivers that support streams do not need the legacy pad config */ 1564 if (!(sd->flags & V4L2_SUBDEV_FL_STREAMS) && sd->entity.num_pads) { 1565 state->pads = kvcalloc(sd->entity.num_pads, 1566 sizeof(*state->pads), GFP_KERNEL); 1567 if (!state->pads) { 1568 ret = -ENOMEM; 1569 goto err; 1570 } 1571 } 1572 1573 if (sd->internal_ops && sd->internal_ops->init_state) { 1574 /* 1575 * There can be no race at this point, but we lock the state 1576 * anyway to satisfy lockdep checks. 1577 */ 1578 v4l2_subdev_lock_state(state); 1579 ret = sd->internal_ops->init_state(sd, state); 1580 v4l2_subdev_unlock_state(state); 1581 1582 if (ret) 1583 goto err; 1584 } 1585 1586 return state; 1587 1588 err: 1589 if (state && state->pads) 1590 kvfree(state->pads); 1591 1592 kfree(state); 1593 1594 return ERR_PTR(ret); 1595 } 1596 EXPORT_SYMBOL_GPL(__v4l2_subdev_state_alloc); 1597 1598 void __v4l2_subdev_state_free(struct v4l2_subdev_state *state) 1599 { 1600 if (!state) 1601 return; 1602 1603 mutex_destroy(&state->_lock); 1604 1605 kfree(state->routing.routes); 1606 kvfree(state->stream_configs.configs); 1607 kvfree(state->pads); 1608 kfree(state); 1609 } 1610 EXPORT_SYMBOL_GPL(__v4l2_subdev_state_free); 1611 1612 int __v4l2_subdev_init_finalize(struct v4l2_subdev *sd, const char *name, 1613 struct lock_class_key *key) 1614 { 1615 struct v4l2_subdev_state *state; 1616 struct device *dev = sd->dev; 1617 bool has_disable_streams; 1618 bool has_enable_streams; 1619 bool has_s_stream; 1620 1621 /* Check that the subdevice implements the required features */ 1622 1623 has_s_stream = v4l2_subdev_has_op(sd, video, s_stream); 1624 has_enable_streams = v4l2_subdev_has_op(sd, pad, enable_streams); 1625 has_disable_streams = v4l2_subdev_has_op(sd, pad, disable_streams); 1626 1627 if (has_enable_streams != has_disable_streams) { 1628 dev_err(dev, 1629 "subdev '%s' must implement both or neither of .enable_streams() and .disable_streams()\n", 1630 sd->name); 1631 return -EINVAL; 1632 } 1633 1634 if (sd->flags & V4L2_SUBDEV_FL_STREAMS) { 1635 if (has_s_stream && !has_enable_streams) { 1636 dev_err(dev, 1637 "subdev '%s' must implement .enable/disable_streams()\n", 1638 sd->name); 1639 1640 return -EINVAL; 1641 } 1642 } 1643 1644 state = __v4l2_subdev_state_alloc(sd, name, key); 1645 if (IS_ERR(state)) 1646 return PTR_ERR(state); 1647 1648 sd->active_state = state; 1649 1650 return 0; 1651 } 1652 EXPORT_SYMBOL_GPL(__v4l2_subdev_init_finalize); 1653 1654 void v4l2_subdev_cleanup(struct v4l2_subdev *sd) 1655 { 1656 struct v4l2_async_subdev_endpoint *ase, *ase_tmp; 1657 1658 __v4l2_subdev_state_free(sd->active_state); 1659 sd->active_state = NULL; 1660 1661 /* Uninitialised sub-device, bail out here. */ 1662 if (!sd->async_subdev_endpoint_list.next) 1663 return; 1664 1665 list_for_each_entry_safe(ase, ase_tmp, &sd->async_subdev_endpoint_list, 1666 async_subdev_endpoint_entry) { 1667 list_del(&ase->async_subdev_endpoint_entry); 1668 1669 kfree(ase); 1670 } 1671 } 1672 EXPORT_SYMBOL_GPL(v4l2_subdev_cleanup); 1673 1674 struct v4l2_mbus_framefmt * 1675 __v4l2_subdev_state_get_format(struct v4l2_subdev_state *state, 1676 unsigned int pad, u32 stream) 1677 { 1678 struct v4l2_subdev_stream_configs *stream_configs; 1679 unsigned int i; 1680 1681 if (WARN_ON_ONCE(!state)) 1682 return NULL; 1683 1684 if (state->pads) { 1685 if (stream) 1686 return NULL; 1687 1688 if (pad >= state->sd->entity.num_pads) 1689 return NULL; 1690 1691 return &state->pads[pad].format; 1692 } 1693 1694 lockdep_assert_held(state->lock); 1695 1696 stream_configs = &state->stream_configs; 1697 1698 for (i = 0; i < stream_configs->num_configs; ++i) { 1699 if (stream_configs->configs[i].pad == pad && 1700 stream_configs->configs[i].stream == stream) 1701 return &stream_configs->configs[i].fmt; 1702 } 1703 1704 return NULL; 1705 } 1706 EXPORT_SYMBOL_GPL(__v4l2_subdev_state_get_format); 1707 1708 struct v4l2_rect * 1709 __v4l2_subdev_state_get_crop(struct v4l2_subdev_state *state, unsigned int pad, 1710 u32 stream) 1711 { 1712 struct v4l2_subdev_stream_configs *stream_configs; 1713 unsigned int i; 1714 1715 if (WARN_ON_ONCE(!state)) 1716 return NULL; 1717 1718 if (state->pads) { 1719 if (stream) 1720 return NULL; 1721 1722 if (pad >= state->sd->entity.num_pads) 1723 return NULL; 1724 1725 return &state->pads[pad].crop; 1726 } 1727 1728 lockdep_assert_held(state->lock); 1729 1730 stream_configs = &state->stream_configs; 1731 1732 for (i = 0; i < stream_configs->num_configs; ++i) { 1733 if (stream_configs->configs[i].pad == pad && 1734 stream_configs->configs[i].stream == stream) 1735 return &stream_configs->configs[i].crop; 1736 } 1737 1738 return NULL; 1739 } 1740 EXPORT_SYMBOL_GPL(__v4l2_subdev_state_get_crop); 1741 1742 struct v4l2_rect * 1743 __v4l2_subdev_state_get_compose(struct v4l2_subdev_state *state, 1744 unsigned int pad, u32 stream) 1745 { 1746 struct v4l2_subdev_stream_configs *stream_configs; 1747 unsigned int i; 1748 1749 if (WARN_ON_ONCE(!state)) 1750 return NULL; 1751 1752 if (state->pads) { 1753 if (stream) 1754 return NULL; 1755 1756 if (pad >= state->sd->entity.num_pads) 1757 return NULL; 1758 1759 return &state->pads[pad].compose; 1760 } 1761 1762 lockdep_assert_held(state->lock); 1763 1764 stream_configs = &state->stream_configs; 1765 1766 for (i = 0; i < stream_configs->num_configs; ++i) { 1767 if (stream_configs->configs[i].pad == pad && 1768 stream_configs->configs[i].stream == stream) 1769 return &stream_configs->configs[i].compose; 1770 } 1771 1772 return NULL; 1773 } 1774 EXPORT_SYMBOL_GPL(__v4l2_subdev_state_get_compose); 1775 1776 struct v4l2_fract * 1777 __v4l2_subdev_state_get_interval(struct v4l2_subdev_state *state, 1778 unsigned int pad, u32 stream) 1779 { 1780 struct v4l2_subdev_stream_configs *stream_configs; 1781 unsigned int i; 1782 1783 if (WARN_ON(!state)) 1784 return NULL; 1785 1786 lockdep_assert_held(state->lock); 1787 1788 if (state->pads) { 1789 if (stream) 1790 return NULL; 1791 1792 if (pad >= state->sd->entity.num_pads) 1793 return NULL; 1794 1795 return &state->pads[pad].interval; 1796 } 1797 1798 lockdep_assert_held(state->lock); 1799 1800 stream_configs = &state->stream_configs; 1801 1802 for (i = 0; i < stream_configs->num_configs; ++i) { 1803 if (stream_configs->configs[i].pad == pad && 1804 stream_configs->configs[i].stream == stream) 1805 return &stream_configs->configs[i].interval; 1806 } 1807 1808 return NULL; 1809 } 1810 EXPORT_SYMBOL_GPL(__v4l2_subdev_state_get_interval); 1811 1812 #if defined(CONFIG_VIDEO_V4L2_SUBDEV_API) 1813 1814 static int 1815 v4l2_subdev_init_stream_configs(struct v4l2_subdev_stream_configs *stream_configs, 1816 const struct v4l2_subdev_krouting *routing) 1817 { 1818 struct v4l2_subdev_stream_configs new_configs = { 0 }; 1819 struct v4l2_subdev_route *route; 1820 u32 idx; 1821 1822 /* Count number of formats needed */ 1823 for_each_active_route(routing, route) { 1824 /* 1825 * Each route needs a format on both ends of the route. 1826 */ 1827 new_configs.num_configs += 2; 1828 } 1829 1830 if (new_configs.num_configs) { 1831 new_configs.configs = kvcalloc(new_configs.num_configs, 1832 sizeof(*new_configs.configs), 1833 GFP_KERNEL); 1834 1835 if (!new_configs.configs) 1836 return -ENOMEM; 1837 } 1838 1839 /* 1840 * Fill in the 'pad' and stream' value for each item in the array from 1841 * the routing table 1842 */ 1843 idx = 0; 1844 1845 for_each_active_route(routing, route) { 1846 new_configs.configs[idx].pad = route->sink_pad; 1847 new_configs.configs[idx].stream = route->sink_stream; 1848 1849 idx++; 1850 1851 new_configs.configs[idx].pad = route->source_pad; 1852 new_configs.configs[idx].stream = route->source_stream; 1853 1854 idx++; 1855 } 1856 1857 kvfree(stream_configs->configs); 1858 *stream_configs = new_configs; 1859 1860 return 0; 1861 } 1862 1863 int v4l2_subdev_get_fmt(struct v4l2_subdev *sd, struct v4l2_subdev_state *state, 1864 struct v4l2_subdev_format *format) 1865 { 1866 struct v4l2_mbus_framefmt *fmt; 1867 1868 fmt = v4l2_subdev_state_get_format(state, format->pad, format->stream); 1869 if (!fmt) 1870 return -EINVAL; 1871 1872 format->format = *fmt; 1873 1874 return 0; 1875 } 1876 EXPORT_SYMBOL_GPL(v4l2_subdev_get_fmt); 1877 1878 int v4l2_subdev_get_frame_interval(struct v4l2_subdev *sd, 1879 struct v4l2_subdev_state *state, 1880 struct v4l2_subdev_frame_interval *fi) 1881 { 1882 struct v4l2_fract *interval; 1883 1884 interval = v4l2_subdev_state_get_interval(state, fi->pad, fi->stream); 1885 if (!interval) 1886 return -EINVAL; 1887 1888 fi->interval = *interval; 1889 1890 return 0; 1891 } 1892 EXPORT_SYMBOL_GPL(v4l2_subdev_get_frame_interval); 1893 1894 int v4l2_subdev_set_routing(struct v4l2_subdev *sd, 1895 struct v4l2_subdev_state *state, 1896 const struct v4l2_subdev_krouting *routing) 1897 { 1898 struct v4l2_subdev_krouting *dst = &state->routing; 1899 const struct v4l2_subdev_krouting *src = routing; 1900 struct v4l2_subdev_krouting new_routing = { 0 }; 1901 size_t bytes; 1902 int r; 1903 1904 if (unlikely(check_mul_overflow((size_t)src->num_routes, 1905 sizeof(*src->routes), &bytes))) 1906 return -EOVERFLOW; 1907 1908 lockdep_assert_held(state->lock); 1909 1910 if (src->num_routes > 0) { 1911 new_routing.routes = kmemdup(src->routes, bytes, GFP_KERNEL); 1912 if (!new_routing.routes) 1913 return -ENOMEM; 1914 } 1915 1916 new_routing.num_routes = src->num_routes; 1917 1918 r = v4l2_subdev_init_stream_configs(&state->stream_configs, 1919 &new_routing); 1920 if (r) { 1921 kfree(new_routing.routes); 1922 return r; 1923 } 1924 1925 kfree(dst->routes); 1926 *dst = new_routing; 1927 1928 return 0; 1929 } 1930 EXPORT_SYMBOL_GPL(v4l2_subdev_set_routing); 1931 1932 struct v4l2_subdev_route * 1933 __v4l2_subdev_next_active_route(const struct v4l2_subdev_krouting *routing, 1934 struct v4l2_subdev_route *route) 1935 { 1936 if (route) 1937 ++route; 1938 else 1939 route = &routing->routes[0]; 1940 1941 for (; route < routing->routes + routing->num_routes; ++route) { 1942 if (!(route->flags & V4L2_SUBDEV_ROUTE_FL_ACTIVE)) 1943 continue; 1944 1945 return route; 1946 } 1947 1948 return NULL; 1949 } 1950 EXPORT_SYMBOL_GPL(__v4l2_subdev_next_active_route); 1951 1952 int v4l2_subdev_set_routing_with_fmt(struct v4l2_subdev *sd, 1953 struct v4l2_subdev_state *state, 1954 const struct v4l2_subdev_krouting *routing, 1955 const struct v4l2_mbus_framefmt *fmt) 1956 { 1957 struct v4l2_subdev_stream_configs *stream_configs; 1958 unsigned int i; 1959 int ret; 1960 1961 ret = v4l2_subdev_set_routing(sd, state, routing); 1962 if (ret) 1963 return ret; 1964 1965 stream_configs = &state->stream_configs; 1966 1967 for (i = 0; i < stream_configs->num_configs; ++i) 1968 stream_configs->configs[i].fmt = *fmt; 1969 1970 return 0; 1971 } 1972 EXPORT_SYMBOL_GPL(v4l2_subdev_set_routing_with_fmt); 1973 1974 int v4l2_subdev_routing_find_opposite_end(const struct v4l2_subdev_krouting *routing, 1975 u32 pad, u32 stream, u32 *other_pad, 1976 u32 *other_stream) 1977 { 1978 unsigned int i; 1979 1980 for (i = 0; i < routing->num_routes; ++i) { 1981 struct v4l2_subdev_route *route = &routing->routes[i]; 1982 1983 if (route->source_pad == pad && 1984 route->source_stream == stream) { 1985 if (other_pad) 1986 *other_pad = route->sink_pad; 1987 if (other_stream) 1988 *other_stream = route->sink_stream; 1989 return 0; 1990 } 1991 1992 if (route->sink_pad == pad && route->sink_stream == stream) { 1993 if (other_pad) 1994 *other_pad = route->source_pad; 1995 if (other_stream) 1996 *other_stream = route->source_stream; 1997 return 0; 1998 } 1999 } 2000 2001 return -EINVAL; 2002 } 2003 EXPORT_SYMBOL_GPL(v4l2_subdev_routing_find_opposite_end); 2004 2005 struct v4l2_mbus_framefmt * 2006 v4l2_subdev_state_get_opposite_stream_format(struct v4l2_subdev_state *state, 2007 u32 pad, u32 stream) 2008 { 2009 u32 other_pad, other_stream; 2010 int ret; 2011 2012 ret = v4l2_subdev_routing_find_opposite_end(&state->routing, 2013 pad, stream, 2014 &other_pad, &other_stream); 2015 if (ret) 2016 return NULL; 2017 2018 return v4l2_subdev_state_get_format(state, other_pad, other_stream); 2019 } 2020 EXPORT_SYMBOL_GPL(v4l2_subdev_state_get_opposite_stream_format); 2021 2022 u64 v4l2_subdev_state_xlate_streams(const struct v4l2_subdev_state *state, 2023 u32 pad0, u32 pad1, u64 *streams) 2024 { 2025 const struct v4l2_subdev_krouting *routing = &state->routing; 2026 struct v4l2_subdev_route *route; 2027 u64 streams0 = 0; 2028 u64 streams1 = 0; 2029 2030 for_each_active_route(routing, route) { 2031 if (route->sink_pad == pad0 && route->source_pad == pad1 && 2032 (*streams & BIT_ULL(route->sink_stream))) { 2033 streams0 |= BIT_ULL(route->sink_stream); 2034 streams1 |= BIT_ULL(route->source_stream); 2035 } 2036 if (route->source_pad == pad0 && route->sink_pad == pad1 && 2037 (*streams & BIT_ULL(route->source_stream))) { 2038 streams0 |= BIT_ULL(route->source_stream); 2039 streams1 |= BIT_ULL(route->sink_stream); 2040 } 2041 } 2042 2043 *streams = streams0; 2044 return streams1; 2045 } 2046 EXPORT_SYMBOL_GPL(v4l2_subdev_state_xlate_streams); 2047 2048 int v4l2_subdev_routing_validate(struct v4l2_subdev *sd, 2049 const struct v4l2_subdev_krouting *routing, 2050 enum v4l2_subdev_routing_restriction disallow) 2051 { 2052 u32 *remote_pads = NULL; 2053 unsigned int i, j; 2054 int ret = -EINVAL; 2055 2056 if (disallow & (V4L2_SUBDEV_ROUTING_NO_STREAM_MIX | 2057 V4L2_SUBDEV_ROUTING_NO_MULTIPLEXING)) { 2058 remote_pads = kcalloc(sd->entity.num_pads, sizeof(*remote_pads), 2059 GFP_KERNEL); 2060 if (!remote_pads) 2061 return -ENOMEM; 2062 2063 for (i = 0; i < sd->entity.num_pads; ++i) 2064 remote_pads[i] = U32_MAX; 2065 } 2066 2067 for (i = 0; i < routing->num_routes; ++i) { 2068 const struct v4l2_subdev_route *route = &routing->routes[i]; 2069 2070 /* Validate the sink and source pad numbers. */ 2071 if (route->sink_pad >= sd->entity.num_pads || 2072 !(sd->entity.pads[route->sink_pad].flags & MEDIA_PAD_FL_SINK)) { 2073 dev_dbg(sd->dev, "route %u sink (%u) is not a sink pad\n", 2074 i, route->sink_pad); 2075 goto out; 2076 } 2077 2078 if (route->source_pad >= sd->entity.num_pads || 2079 !(sd->entity.pads[route->source_pad].flags & MEDIA_PAD_FL_SOURCE)) { 2080 dev_dbg(sd->dev, "route %u source (%u) is not a source pad\n", 2081 i, route->source_pad); 2082 goto out; 2083 } 2084 2085 /* 2086 * V4L2_SUBDEV_ROUTING_NO_SINK_STREAM_MIX: all streams from a 2087 * sink pad must be routed to a single source pad. 2088 */ 2089 if (disallow & V4L2_SUBDEV_ROUTING_NO_SINK_STREAM_MIX) { 2090 if (remote_pads[route->sink_pad] != U32_MAX && 2091 remote_pads[route->sink_pad] != route->source_pad) { 2092 dev_dbg(sd->dev, 2093 "route %u attempts to mix %s streams\n", 2094 i, "sink"); 2095 goto out; 2096 } 2097 } 2098 2099 /* 2100 * V4L2_SUBDEV_ROUTING_NO_SOURCE_STREAM_MIX: all streams on a 2101 * source pad must originate from a single sink pad. 2102 */ 2103 if (disallow & V4L2_SUBDEV_ROUTING_NO_SOURCE_STREAM_MIX) { 2104 if (remote_pads[route->source_pad] != U32_MAX && 2105 remote_pads[route->source_pad] != route->sink_pad) { 2106 dev_dbg(sd->dev, 2107 "route %u attempts to mix %s streams\n", 2108 i, "source"); 2109 goto out; 2110 } 2111 } 2112 2113 /* 2114 * V4L2_SUBDEV_ROUTING_NO_SINK_MULTIPLEXING: Pads on the sink 2115 * side can not do stream multiplexing, i.e. there can be only 2116 * a single stream in a sink pad. 2117 */ 2118 if (disallow & V4L2_SUBDEV_ROUTING_NO_SINK_MULTIPLEXING) { 2119 if (remote_pads[route->sink_pad] != U32_MAX) { 2120 dev_dbg(sd->dev, 2121 "route %u attempts to multiplex on %s pad %u\n", 2122 i, "sink", route->sink_pad); 2123 goto out; 2124 } 2125 } 2126 2127 /* 2128 * V4L2_SUBDEV_ROUTING_NO_SOURCE_MULTIPLEXING: Pads on the 2129 * source side can not do stream multiplexing, i.e. there can 2130 * be only a single stream in a source pad. 2131 */ 2132 if (disallow & V4L2_SUBDEV_ROUTING_NO_SOURCE_MULTIPLEXING) { 2133 if (remote_pads[route->source_pad] != U32_MAX) { 2134 dev_dbg(sd->dev, 2135 "route %u attempts to multiplex on %s pad %u\n", 2136 i, "source", route->source_pad); 2137 goto out; 2138 } 2139 } 2140 2141 if (remote_pads) { 2142 remote_pads[route->sink_pad] = route->source_pad; 2143 remote_pads[route->source_pad] = route->sink_pad; 2144 } 2145 2146 for (j = i + 1; j < routing->num_routes; ++j) { 2147 const struct v4l2_subdev_route *r = &routing->routes[j]; 2148 2149 /* 2150 * V4L2_SUBDEV_ROUTING_NO_1_TO_N: No two routes can 2151 * originate from the same (sink) stream. 2152 */ 2153 if ((disallow & V4L2_SUBDEV_ROUTING_NO_1_TO_N) && 2154 route->sink_pad == r->sink_pad && 2155 route->sink_stream == r->sink_stream) { 2156 dev_dbg(sd->dev, 2157 "routes %u and %u originate from same sink (%u/%u)\n", 2158 i, j, route->sink_pad, 2159 route->sink_stream); 2160 goto out; 2161 } 2162 2163 /* 2164 * V4L2_SUBDEV_ROUTING_NO_N_TO_1: No two routes can end 2165 * at the same (source) stream. 2166 */ 2167 if ((disallow & V4L2_SUBDEV_ROUTING_NO_N_TO_1) && 2168 route->source_pad == r->source_pad && 2169 route->source_stream == r->source_stream) { 2170 dev_dbg(sd->dev, 2171 "routes %u and %u end at same source (%u/%u)\n", 2172 i, j, route->source_pad, 2173 route->source_stream); 2174 goto out; 2175 } 2176 } 2177 } 2178 2179 ret = 0; 2180 2181 out: 2182 kfree(remote_pads); 2183 return ret; 2184 } 2185 EXPORT_SYMBOL_GPL(v4l2_subdev_routing_validate); 2186 2187 static void v4l2_subdev_collect_streams(struct v4l2_subdev *sd, 2188 struct v4l2_subdev_state *state, 2189 u32 pad, u64 streams_mask, 2190 u64 *found_streams, 2191 u64 *enabled_streams) 2192 { 2193 if (!(sd->flags & V4L2_SUBDEV_FL_STREAMS)) { 2194 *found_streams = BIT_ULL(0); 2195 *enabled_streams = 2196 (sd->enabled_pads & BIT_ULL(pad)) ? BIT_ULL(0) : 0; 2197 return; 2198 } 2199 2200 *found_streams = 0; 2201 *enabled_streams = 0; 2202 2203 for (unsigned int i = 0; i < state->stream_configs.num_configs; ++i) { 2204 const struct v4l2_subdev_stream_config *cfg = 2205 &state->stream_configs.configs[i]; 2206 2207 if (cfg->pad != pad || !(streams_mask & BIT_ULL(cfg->stream))) 2208 continue; 2209 2210 *found_streams |= BIT_ULL(cfg->stream); 2211 if (cfg->enabled) 2212 *enabled_streams |= BIT_ULL(cfg->stream); 2213 } 2214 } 2215 2216 static void v4l2_subdev_set_streams_enabled(struct v4l2_subdev *sd, 2217 struct v4l2_subdev_state *state, 2218 u32 pad, u64 streams_mask, 2219 bool enabled) 2220 { 2221 if (!(sd->flags & V4L2_SUBDEV_FL_STREAMS)) { 2222 if (enabled) 2223 sd->enabled_pads |= BIT_ULL(pad); 2224 else 2225 sd->enabled_pads &= ~BIT_ULL(pad); 2226 return; 2227 } 2228 2229 for (unsigned int i = 0; i < state->stream_configs.num_configs; ++i) { 2230 struct v4l2_subdev_stream_config *cfg = 2231 &state->stream_configs.configs[i]; 2232 2233 if (cfg->pad == pad && (streams_mask & BIT_ULL(cfg->stream))) 2234 cfg->enabled = enabled; 2235 } 2236 } 2237 2238 int v4l2_subdev_enable_streams(struct v4l2_subdev *sd, u32 pad, 2239 u64 streams_mask) 2240 { 2241 struct device *dev = sd->entity.graph_obj.mdev->dev; 2242 struct v4l2_subdev_state *state; 2243 bool already_streaming; 2244 u64 enabled_streams; 2245 u64 found_streams; 2246 bool use_s_stream; 2247 int ret; 2248 2249 /* A few basic sanity checks first. */ 2250 if (pad >= sd->entity.num_pads) 2251 return -EINVAL; 2252 2253 if (!(sd->entity.pads[pad].flags & MEDIA_PAD_FL_SOURCE)) 2254 return -EOPNOTSUPP; 2255 2256 /* 2257 * We use a 64-bit bitmask for tracking enabled pads, so only subdevices 2258 * with 64 pads or less can be supported. 2259 */ 2260 if (pad >= sizeof(sd->enabled_pads) * BITS_PER_BYTE) 2261 return -EOPNOTSUPP; 2262 2263 if (!streams_mask) 2264 return 0; 2265 2266 /* Fallback on .s_stream() if .enable_streams() isn't available. */ 2267 use_s_stream = !v4l2_subdev_has_op(sd, pad, enable_streams); 2268 2269 if (!use_s_stream) 2270 state = v4l2_subdev_lock_and_get_active_state(sd); 2271 else 2272 state = NULL; 2273 2274 /* 2275 * Verify that the requested streams exist and that they are not 2276 * already enabled. 2277 */ 2278 2279 v4l2_subdev_collect_streams(sd, state, pad, streams_mask, 2280 &found_streams, &enabled_streams); 2281 2282 if (found_streams != streams_mask) { 2283 dev_dbg(dev, "streams 0x%llx not found on %s:%u\n", 2284 streams_mask & ~found_streams, sd->entity.name, pad); 2285 ret = -EINVAL; 2286 goto done; 2287 } 2288 2289 if (enabled_streams) { 2290 dev_dbg(dev, "streams 0x%llx already enabled on %s:%u\n", 2291 enabled_streams, sd->entity.name, pad); 2292 ret = -EALREADY; 2293 goto done; 2294 } 2295 2296 dev_dbg(dev, "enable streams %u:%#llx\n", pad, streams_mask); 2297 2298 already_streaming = v4l2_subdev_is_streaming(sd); 2299 2300 if (!use_s_stream) { 2301 /* Call the .enable_streams() operation. */ 2302 ret = v4l2_subdev_call(sd, pad, enable_streams, state, pad, 2303 streams_mask); 2304 } else { 2305 /* Start streaming when the first pad is enabled. */ 2306 if (!already_streaming) 2307 ret = v4l2_subdev_call(sd, video, s_stream, 1); 2308 else 2309 ret = 0; 2310 } 2311 2312 if (ret) { 2313 dev_dbg(dev, "enable streams %u:%#llx failed: %d\n", pad, 2314 streams_mask, ret); 2315 goto done; 2316 } 2317 2318 /* Mark the streams as enabled. */ 2319 v4l2_subdev_set_streams_enabled(sd, state, pad, streams_mask, true); 2320 2321 /* 2322 * TODO: When all the drivers have been changed to use 2323 * v4l2_subdev_enable_streams() and v4l2_subdev_disable_streams(), 2324 * instead of calling .s_stream() operation directly, we can remove 2325 * the privacy LED handling from call_s_stream() and do it here 2326 * for all cases. 2327 */ 2328 if (!use_s_stream && !already_streaming) 2329 v4l2_subdev_enable_privacy_led(sd); 2330 2331 done: 2332 if (!use_s_stream) 2333 v4l2_subdev_unlock_state(state); 2334 2335 return ret; 2336 } 2337 EXPORT_SYMBOL_GPL(v4l2_subdev_enable_streams); 2338 2339 int v4l2_subdev_disable_streams(struct v4l2_subdev *sd, u32 pad, 2340 u64 streams_mask) 2341 { 2342 struct device *dev = sd->entity.graph_obj.mdev->dev; 2343 struct v4l2_subdev_state *state; 2344 u64 enabled_streams; 2345 u64 found_streams; 2346 bool use_s_stream; 2347 int ret; 2348 2349 /* A few basic sanity checks first. */ 2350 if (pad >= sd->entity.num_pads) 2351 return -EINVAL; 2352 2353 if (!(sd->entity.pads[pad].flags & MEDIA_PAD_FL_SOURCE)) 2354 return -EOPNOTSUPP; 2355 2356 /* 2357 * We use a 64-bit bitmask for tracking enabled pads, so only subdevices 2358 * with 64 pads or less can be supported. 2359 */ 2360 if (pad >= sizeof(sd->enabled_pads) * BITS_PER_BYTE) 2361 return -EOPNOTSUPP; 2362 2363 if (!streams_mask) 2364 return 0; 2365 2366 /* Fallback on .s_stream() if .disable_streams() isn't available. */ 2367 use_s_stream = !v4l2_subdev_has_op(sd, pad, disable_streams); 2368 2369 if (!use_s_stream) 2370 state = v4l2_subdev_lock_and_get_active_state(sd); 2371 else 2372 state = NULL; 2373 2374 /* 2375 * Verify that the requested streams exist and that they are not 2376 * already disabled. 2377 */ 2378 2379 v4l2_subdev_collect_streams(sd, state, pad, streams_mask, 2380 &found_streams, &enabled_streams); 2381 2382 if (found_streams != streams_mask) { 2383 dev_dbg(dev, "streams 0x%llx not found on %s:%u\n", 2384 streams_mask & ~found_streams, sd->entity.name, pad); 2385 ret = -EINVAL; 2386 goto done; 2387 } 2388 2389 if (enabled_streams != streams_mask) { 2390 dev_dbg(dev, "streams 0x%llx already disabled on %s:%u\n", 2391 streams_mask & ~enabled_streams, sd->entity.name, pad); 2392 ret = -EALREADY; 2393 goto done; 2394 } 2395 2396 dev_dbg(dev, "disable streams %u:%#llx\n", pad, streams_mask); 2397 2398 if (!use_s_stream) { 2399 /* Call the .disable_streams() operation. */ 2400 ret = v4l2_subdev_call(sd, pad, disable_streams, state, pad, 2401 streams_mask); 2402 } else { 2403 /* Stop streaming when the last streams are disabled. */ 2404 2405 if (!(sd->enabled_pads & ~BIT_ULL(pad))) 2406 ret = v4l2_subdev_call(sd, video, s_stream, 0); 2407 else 2408 ret = 0; 2409 } 2410 2411 if (ret) { 2412 dev_dbg(dev, "disable streams %u:%#llx failed: %d\n", pad, 2413 streams_mask, ret); 2414 goto done; 2415 } 2416 2417 v4l2_subdev_set_streams_enabled(sd, state, pad, streams_mask, false); 2418 2419 done: 2420 if (!use_s_stream) { 2421 if (!v4l2_subdev_is_streaming(sd)) 2422 v4l2_subdev_disable_privacy_led(sd); 2423 2424 v4l2_subdev_unlock_state(state); 2425 } 2426 2427 return ret; 2428 } 2429 EXPORT_SYMBOL_GPL(v4l2_subdev_disable_streams); 2430 2431 int v4l2_subdev_s_stream_helper(struct v4l2_subdev *sd, int enable) 2432 { 2433 struct v4l2_subdev_state *state; 2434 struct v4l2_subdev_route *route; 2435 struct media_pad *pad; 2436 u64 source_mask = 0; 2437 int pad_index = -1; 2438 2439 /* 2440 * Find the source pad. This helper is meant for subdevs that have a 2441 * single source pad, so failures shouldn't happen, but catch them 2442 * loudly nonetheless as they indicate a driver bug. 2443 */ 2444 media_entity_for_each_pad(&sd->entity, pad) { 2445 if (pad->flags & MEDIA_PAD_FL_SOURCE) { 2446 pad_index = pad->index; 2447 break; 2448 } 2449 } 2450 2451 if (WARN_ON(pad_index == -1)) 2452 return -EINVAL; 2453 2454 if (sd->flags & V4L2_SUBDEV_FL_STREAMS) { 2455 /* 2456 * As there's a single source pad, just collect all the source 2457 * streams. 2458 */ 2459 state = v4l2_subdev_lock_and_get_active_state(sd); 2460 2461 for_each_active_route(&state->routing, route) 2462 source_mask |= BIT_ULL(route->source_stream); 2463 2464 v4l2_subdev_unlock_state(state); 2465 } else { 2466 /* 2467 * For non-streams subdevices, there's a single implicit stream 2468 * per pad. 2469 */ 2470 source_mask = BIT_ULL(0); 2471 } 2472 2473 if (enable) 2474 return v4l2_subdev_enable_streams(sd, pad_index, source_mask); 2475 else 2476 return v4l2_subdev_disable_streams(sd, pad_index, source_mask); 2477 } 2478 EXPORT_SYMBOL_GPL(v4l2_subdev_s_stream_helper); 2479 2480 #endif /* CONFIG_VIDEO_V4L2_SUBDEV_API */ 2481 2482 #endif /* CONFIG_MEDIA_CONTROLLER */ 2483 2484 void v4l2_subdev_init(struct v4l2_subdev *sd, const struct v4l2_subdev_ops *ops) 2485 { 2486 INIT_LIST_HEAD(&sd->list); 2487 BUG_ON(!ops); 2488 sd->ops = ops; 2489 sd->v4l2_dev = NULL; 2490 sd->flags = 0; 2491 sd->name[0] = '\0'; 2492 sd->grp_id = 0; 2493 sd->dev_priv = NULL; 2494 sd->host_priv = NULL; 2495 sd->privacy_led = NULL; 2496 INIT_LIST_HEAD(&sd->async_subdev_endpoint_list); 2497 #if defined(CONFIG_MEDIA_CONTROLLER) 2498 sd->entity.name = sd->name; 2499 sd->entity.obj_type = MEDIA_ENTITY_TYPE_V4L2_SUBDEV; 2500 sd->entity.function = MEDIA_ENT_F_V4L2_SUBDEV_UNKNOWN; 2501 #endif 2502 } 2503 EXPORT_SYMBOL(v4l2_subdev_init); 2504 2505 void v4l2_subdev_notify_event(struct v4l2_subdev *sd, 2506 const struct v4l2_event *ev) 2507 { 2508 v4l2_event_queue(sd->devnode, ev); 2509 v4l2_subdev_notify(sd, V4L2_DEVICE_NOTIFY_EVENT, (void *)ev); 2510 } 2511 EXPORT_SYMBOL_GPL(v4l2_subdev_notify_event); 2512 2513 bool v4l2_subdev_is_streaming(struct v4l2_subdev *sd) 2514 { 2515 struct v4l2_subdev_state *state; 2516 2517 if (!v4l2_subdev_has_op(sd, pad, enable_streams)) 2518 return sd->s_stream_enabled; 2519 2520 if (!(sd->flags & V4L2_SUBDEV_FL_STREAMS)) 2521 return !!sd->enabled_pads; 2522 2523 state = v4l2_subdev_get_locked_active_state(sd); 2524 2525 for (unsigned int i = 0; i < state->stream_configs.num_configs; ++i) { 2526 const struct v4l2_subdev_stream_config *cfg; 2527 2528 cfg = &state->stream_configs.configs[i]; 2529 2530 if (cfg->enabled) 2531 return true; 2532 } 2533 2534 return false; 2535 } 2536 EXPORT_SYMBOL_GPL(v4l2_subdev_is_streaming); 2537 2538 int v4l2_subdev_get_privacy_led(struct v4l2_subdev *sd) 2539 { 2540 #if IS_REACHABLE(CONFIG_LEDS_CLASS) 2541 sd->privacy_led = led_get(sd->dev, "privacy-led"); 2542 if (IS_ERR(sd->privacy_led) && PTR_ERR(sd->privacy_led) != -ENOENT) 2543 return dev_err_probe(sd->dev, PTR_ERR(sd->privacy_led), 2544 "getting privacy LED\n"); 2545 2546 if (!IS_ERR_OR_NULL(sd->privacy_led)) { 2547 mutex_lock(&sd->privacy_led->led_access); 2548 led_sysfs_disable(sd->privacy_led); 2549 led_trigger_remove(sd->privacy_led); 2550 led_set_brightness(sd->privacy_led, 0); 2551 mutex_unlock(&sd->privacy_led->led_access); 2552 } 2553 #endif 2554 return 0; 2555 } 2556 EXPORT_SYMBOL_GPL(v4l2_subdev_get_privacy_led); 2557 2558 void v4l2_subdev_put_privacy_led(struct v4l2_subdev *sd) 2559 { 2560 #if IS_REACHABLE(CONFIG_LEDS_CLASS) 2561 if (!IS_ERR_OR_NULL(sd->privacy_led)) { 2562 mutex_lock(&sd->privacy_led->led_access); 2563 led_sysfs_enable(sd->privacy_led); 2564 mutex_unlock(&sd->privacy_led->led_access); 2565 led_put(sd->privacy_led); 2566 } 2567 #endif 2568 } 2569 EXPORT_SYMBOL_GPL(v4l2_subdev_put_privacy_led); 2570