drivers/media/v4l2-core/v4l2-subdev.c

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