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 <[email protected]>
   8  *          Sakari Ailus <[email protected]>
   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         if (!is_media_entity_v4l2_subdev(link->sink->entity) ||
1447             !is_media_entity_v4l2_subdev(link->source->entity)) {
1448                 pr_warn_once("%s of link '%s':%u->'%s':%u is not a V4L2 sub-device, driver bug!\n",
1449                              !is_media_entity_v4l2_subdev(link->sink->entity) ?
1450                              "sink" : "source",
1451                              link->source->entity->name, link->source->index,
1452                              link->sink->entity->name, link->sink->index);
1453                 return 0;
1454         }
1455
1456         sink_sd = media_entity_to_v4l2_subdev(link->sink->entity);
1457         source_sd = media_entity_to_v4l2_subdev(link->source->entity);
1458
1459         sink_state = v4l2_subdev_get_unlocked_active_state(sink_sd);
1460         source_state = v4l2_subdev_get_unlocked_active_state(source_sd);
1461
1462         states_locked = sink_state && source_state;
1463
1464         if (states_locked)
1465                 v4l2_subdev_lock_states(sink_state, source_state);
1466
1467         ret = v4l2_subdev_link_validate_locked(link, states_locked);
1468
1469         if (states_locked)
1470                 v4l2_subdev_unlock_states(sink_state, source_state);
1471
1472         return ret;
1473 }
1474 EXPORT_SYMBOL_GPL(v4l2_subdev_link_validate);
1475
1476 bool v4l2_subdev_has_pad_interdep(struct media_entity *entity,
1477                                   unsigned int pad0, unsigned int pad1)
1478 {
1479         struct v4l2_subdev *sd = media_entity_to_v4l2_subdev(entity);
1480         struct v4l2_subdev_krouting *routing;
1481         struct v4l2_subdev_state *state;
1482         unsigned int i;
1483
1484         state = v4l2_subdev_lock_and_get_active_state(sd);
1485
1486         routing = &state->routing;
1487
1488         for (i = 0; i < routing->num_routes; ++i) {
1489                 struct v4l2_subdev_route *route = &routing->routes[i];
1490
1491                 if (!(route->flags & V4L2_SUBDEV_ROUTE_FL_ACTIVE))
1492                         continue;
1493
1494                 if ((route->sink_pad == pad0 && route->source_pad == pad1) ||
1495                     (route->source_pad == pad0 && route->sink_pad == pad1)) {
1496                         v4l2_subdev_unlock_state(state);
1497                         return true;
1498                 }
1499         }
1500
1501         v4l2_subdev_unlock_state(state);
1502
1503         return false;
1504 }
1505 EXPORT_SYMBOL_GPL(v4l2_subdev_has_pad_interdep);
1506
1507 struct v4l2_subdev_state *
1508 __v4l2_subdev_state_alloc(struct v4l2_subdev *sd, const char *lock_name,
1509                           struct lock_class_key *lock_key)
1510 {
1511         struct v4l2_subdev_state *state;
1512         int ret;
1513
1514         state = kzalloc(sizeof(*state), GFP_KERNEL);
1515         if (!state)
1516                 return ERR_PTR(-ENOMEM);
1517
1518         __mutex_init(&state->_lock, lock_name, lock_key);
1519         if (sd->state_lock)
1520                 state->lock = sd->state_lock;
1521         else
1522                 state->lock = &state->_lock;
1523
1524         state->sd = sd;
1525
1526         /* Drivers that support streams do not need the legacy pad config */
1527         if (!(sd->flags & V4L2_SUBDEV_FL_STREAMS) && sd->entity.num_pads) {
1528                 state->pads = kvcalloc(sd->entity.num_pads,
1529                                        sizeof(*state->pads), GFP_KERNEL);
1530                 if (!state->pads) {
1531                         ret = -ENOMEM;
1532                         goto err;
1533                 }
1534         }
1535
1536         if (sd->internal_ops && sd->internal_ops->init_state) {
1537                 /*
1538                  * There can be no race at this point, but we lock the state
1539                  * anyway to satisfy lockdep checks.
1540                  */
1541                 v4l2_subdev_lock_state(state);
1542                 ret = sd->internal_ops->init_state(sd, state);
1543                 v4l2_subdev_unlock_state(state);
1544
1545                 if (ret)
1546                         goto err;
1547         }
1548
1549         return state;
1550
1551 err:
1552         if (state && state->pads)
1553                 kvfree(state->pads);
1554
1555         kfree(state);
1556
1557         return ERR_PTR(ret);
1558 }
1559 EXPORT_SYMBOL_GPL(__v4l2_subdev_state_alloc);
1560
1561 void __v4l2_subdev_state_free(struct v4l2_subdev_state *state)
1562 {
1563         if (!state)
1564                 return;
1565
1566         mutex_destroy(&state->_lock);
1567
1568         kfree(state->routing.routes);
1569         kvfree(state->stream_configs.configs);
1570         kvfree(state->pads);
1571         kfree(state);
1572 }
1573 EXPORT_SYMBOL_GPL(__v4l2_subdev_state_free);
1574
1575 int __v4l2_subdev_init_finalize(struct v4l2_subdev *sd, const char *name,
1576                                 struct lock_class_key *key)
1577 {
1578         struct v4l2_subdev_state *state;
1579         struct device *dev = sd->dev;
1580         bool has_disable_streams;
1581         bool has_enable_streams;
1582         bool has_s_stream;
1583
1584         /* Check that the subdevice implements the required features */
1585
1586         has_s_stream = v4l2_subdev_has_op(sd, video, s_stream);
1587         has_enable_streams = v4l2_subdev_has_op(sd, pad, enable_streams);
1588         has_disable_streams = v4l2_subdev_has_op(sd, pad, disable_streams);
1589
1590         if (has_enable_streams != has_disable_streams) {
1591                 dev_err(dev,
1592                         "subdev '%s' must implement both or neither of .enable_streams() and .disable_streams()\n",
1593                         sd->name);
1594                 return -EINVAL;
1595         }
1596
1597         if (sd->flags & V4L2_SUBDEV_FL_STREAMS) {
1598                 if (has_s_stream && !has_enable_streams) {
1599                         dev_err(dev,
1600                                 "subdev '%s' must implement .enable/disable_streams()\n",
1601                                 sd->name);
1602
1603                         return -EINVAL;
1604                 }
1605         }
1606
1607         state = __v4l2_subdev_state_alloc(sd, name, key);
1608         if (IS_ERR(state))
1609                 return PTR_ERR(state);
1610
1611         sd->active_state = state;
1612
1613         return 0;
1614 }
1615 EXPORT_SYMBOL_GPL(__v4l2_subdev_init_finalize);
1616
1617 void v4l2_subdev_cleanup(struct v4l2_subdev *sd)
1618 {
1619         struct v4l2_async_subdev_endpoint *ase, *ase_tmp;
1620
1621         __v4l2_subdev_state_free(sd->active_state);
1622         sd->active_state = NULL;
1623
1624         /* Uninitialised sub-device, bail out here. */
1625         if (!sd->async_subdev_endpoint_list.next)
1626                 return;
1627
1628         list_for_each_entry_safe(ase, ase_tmp, &sd->async_subdev_endpoint_list,
1629                                  async_subdev_endpoint_entry) {
1630                 list_del(&ase->async_subdev_endpoint_entry);
1631
1632                 kfree(ase);
1633         }
1634 }
1635 EXPORT_SYMBOL_GPL(v4l2_subdev_cleanup);
1636
1637 struct v4l2_mbus_framefmt *
1638 __v4l2_subdev_state_get_format(struct v4l2_subdev_state *state,
1639                                unsigned int pad, u32 stream)
1640 {
1641         struct v4l2_subdev_stream_configs *stream_configs;
1642         unsigned int i;
1643
1644         if (WARN_ON_ONCE(!state))
1645                 return NULL;
1646
1647         if (state->pads) {
1648                 if (stream)
1649                         return NULL;
1650
1651                 if (pad >= state->sd->entity.num_pads)
1652                         return NULL;
1653
1654                 return &state->pads[pad].format;
1655         }
1656
1657         lockdep_assert_held(state->lock);
1658
1659         stream_configs = &state->stream_configs;
1660
1661         for (i = 0; i < stream_configs->num_configs; ++i) {
1662                 if (stream_configs->configs[i].pad == pad &&
1663                     stream_configs->configs[i].stream == stream)
1664                         return &stream_configs->configs[i].fmt;
1665         }
1666
1667         return NULL;
1668 }
1669 EXPORT_SYMBOL_GPL(__v4l2_subdev_state_get_format);
1670
1671 struct v4l2_rect *
1672 __v4l2_subdev_state_get_crop(struct v4l2_subdev_state *state, unsigned int pad,
1673                              u32 stream)
1674 {
1675         struct v4l2_subdev_stream_configs *stream_configs;
1676         unsigned int i;
1677
1678         if (WARN_ON_ONCE(!state))
1679                 return NULL;
1680
1681         if (state->pads) {
1682                 if (stream)
1683                         return NULL;
1684
1685                 if (pad >= state->sd->entity.num_pads)
1686                         return NULL;
1687
1688                 return &state->pads[pad].crop;
1689         }
1690
1691         lockdep_assert_held(state->lock);
1692
1693         stream_configs = &state->stream_configs;
1694
1695         for (i = 0; i < stream_configs->num_configs; ++i) {
1696                 if (stream_configs->configs[i].pad == pad &&
1697                     stream_configs->configs[i].stream == stream)
1698                         return &stream_configs->configs[i].crop;
1699         }
1700
1701         return NULL;
1702 }
1703 EXPORT_SYMBOL_GPL(__v4l2_subdev_state_get_crop);
1704
1705 struct v4l2_rect *
1706 __v4l2_subdev_state_get_compose(struct v4l2_subdev_state *state,
1707                                 unsigned int pad, u32 stream)
1708 {
1709         struct v4l2_subdev_stream_configs *stream_configs;
1710         unsigned int i;
1711
1712         if (WARN_ON_ONCE(!state))
1713                 return NULL;
1714
1715         if (state->pads) {
1716                 if (stream)
1717                         return NULL;
1718
1719                 if (pad >= state->sd->entity.num_pads)
1720                         return NULL;
1721
1722                 return &state->pads[pad].compose;
1723         }
1724
1725         lockdep_assert_held(state->lock);
1726
1727         stream_configs = &state->stream_configs;
1728
1729         for (i = 0; i < stream_configs->num_configs; ++i) {
1730                 if (stream_configs->configs[i].pad == pad &&
1731                     stream_configs->configs[i].stream == stream)
1732                         return &stream_configs->configs[i].compose;
1733         }
1734
1735         return NULL;
1736 }
1737 EXPORT_SYMBOL_GPL(__v4l2_subdev_state_get_compose);
1738
1739 struct v4l2_fract *
1740 __v4l2_subdev_state_get_interval(struct v4l2_subdev_state *state,
1741                                  unsigned int pad, u32 stream)
1742 {
1743         struct v4l2_subdev_stream_configs *stream_configs;
1744         unsigned int i;
1745
1746         if (WARN_ON(!state))
1747                 return NULL;
1748
1749         lockdep_assert_held(state->lock);
1750
1751         if (state->pads) {
1752                 if (stream)
1753                         return NULL;
1754
1755                 if (pad >= state->sd->entity.num_pads)
1756                         return NULL;
1757
1758                 return &state->pads[pad].interval;
1759         }
1760
1761         lockdep_assert_held(state->lock);
1762
1763         stream_configs = &state->stream_configs;
1764
1765         for (i = 0; i < stream_configs->num_configs; ++i) {
1766                 if (stream_configs->configs[i].pad == pad &&
1767                     stream_configs->configs[i].stream == stream)
1768                         return &stream_configs->configs[i].interval;
1769         }
1770
1771         return NULL;
1772 }
1773 EXPORT_SYMBOL_GPL(__v4l2_subdev_state_get_interval);
1774
1775 #if defined(CONFIG_VIDEO_V4L2_SUBDEV_API)
1776
1777 static int
1778 v4l2_subdev_init_stream_configs(struct v4l2_subdev_stream_configs *stream_configs,
1779                                 const struct v4l2_subdev_krouting *routing)
1780 {
1781         struct v4l2_subdev_stream_configs new_configs = { 0 };
1782         struct v4l2_subdev_route *route;
1783         u32 idx;
1784
1785         /* Count number of formats needed */
1786         for_each_active_route(routing, route) {
1787                 /*
1788                  * Each route needs a format on both ends of the route.
1789                  */
1790                 new_configs.num_configs += 2;
1791         }
1792
1793         if (new_configs.num_configs) {
1794                 new_configs.configs = kvcalloc(new_configs.num_configs,
1795                                                sizeof(*new_configs.configs),
1796                                                GFP_KERNEL);
1797
1798                 if (!new_configs.configs)
1799                         return -ENOMEM;
1800         }
1801
1802         /*
1803          * Fill in the 'pad' and stream' value for each item in the array from
1804          * the routing table
1805          */
1806         idx = 0;
1807
1808         for_each_active_route(routing, route) {
1809                 new_configs.configs[idx].pad = route->sink_pad;
1810                 new_configs.configs[idx].stream = route->sink_stream;
1811
1812                 idx++;
1813
1814                 new_configs.configs[idx].pad = route->source_pad;
1815                 new_configs.configs[idx].stream = route->source_stream;
1816
1817                 idx++;
1818         }
1819
1820         kvfree(stream_configs->configs);
1821         *stream_configs = new_configs;
1822
1823         return 0;
1824 }
1825
1826 int v4l2_subdev_get_fmt(struct v4l2_subdev *sd, struct v4l2_subdev_state *state,
1827                         struct v4l2_subdev_format *format)
1828 {
1829         struct v4l2_mbus_framefmt *fmt;
1830
1831         fmt = v4l2_subdev_state_get_format(state, format->pad, format->stream);
1832         if (!fmt)
1833                 return -EINVAL;
1834
1835         format->format = *fmt;
1836
1837         return 0;
1838 }
1839 EXPORT_SYMBOL_GPL(v4l2_subdev_get_fmt);
1840
1841 int v4l2_subdev_get_frame_interval(struct v4l2_subdev *sd,
1842                                    struct v4l2_subdev_state *state,
1843                                    struct v4l2_subdev_frame_interval *fi)
1844 {
1845         struct v4l2_fract *interval;
1846
1847         interval = v4l2_subdev_state_get_interval(state, fi->pad, fi->stream);
1848         if (!interval)
1849                 return -EINVAL;
1850
1851         fi->interval = *interval;
1852
1853         return 0;
1854 }
1855 EXPORT_SYMBOL_GPL(v4l2_subdev_get_frame_interval);
1856
1857 int v4l2_subdev_set_routing(struct v4l2_subdev *sd,
1858                             struct v4l2_subdev_state *state,
1859                             const struct v4l2_subdev_krouting *routing)
1860 {
1861         struct v4l2_subdev_krouting *dst = &state->routing;
1862         const struct v4l2_subdev_krouting *src = routing;
1863         struct v4l2_subdev_krouting new_routing = { 0 };
1864         size_t bytes;
1865         int r;
1866
1867         if (unlikely(check_mul_overflow((size_t)src->num_routes,
1868                                         sizeof(*src->routes), &bytes)))
1869                 return -EOVERFLOW;
1870
1871         lockdep_assert_held(state->lock);
1872
1873         if (src->num_routes > 0) {
1874                 new_routing.routes = kmemdup(src->routes, bytes, GFP_KERNEL);
1875                 if (!new_routing.routes)
1876                         return -ENOMEM;
1877         }
1878
1879         new_routing.num_routes = src->num_routes;
1880
1881         r = v4l2_subdev_init_stream_configs(&state->stream_configs,
1882                                             &new_routing);
1883         if (r) {
1884                 kfree(new_routing.routes);
1885                 return r;
1886         }
1887
1888         kfree(dst->routes);
1889         *dst = new_routing;
1890
1891         return 0;
1892 }
1893 EXPORT_SYMBOL_GPL(v4l2_subdev_set_routing);
1894
1895 struct v4l2_subdev_route *
1896 __v4l2_subdev_next_active_route(const struct v4l2_subdev_krouting *routing,
1897                                 struct v4l2_subdev_route *route)
1898 {
1899         if (route)
1900                 ++route;
1901         else
1902                 route = &routing->routes[0];
1903
1904         for (; route < routing->routes + routing->num_routes; ++route) {
1905                 if (!(route->flags & V4L2_SUBDEV_ROUTE_FL_ACTIVE))
1906                         continue;
1907
1908                 return route;
1909         }
1910
1911         return NULL;
1912 }
1913 EXPORT_SYMBOL_GPL(__v4l2_subdev_next_active_route);
1914
1915 int v4l2_subdev_set_routing_with_fmt(struct v4l2_subdev *sd,
1916                                      struct v4l2_subdev_state *state,
1917                                      const struct v4l2_subdev_krouting *routing,
1918                                      const struct v4l2_mbus_framefmt *fmt)
1919 {
1920         struct v4l2_subdev_stream_configs *stream_configs;
1921         unsigned int i;
1922         int ret;
1923
1924         ret = v4l2_subdev_set_routing(sd, state, routing);
1925         if (ret)
1926                 return ret;
1927
1928         stream_configs = &state->stream_configs;
1929
1930         for (i = 0; i < stream_configs->num_configs; ++i)
1931                 stream_configs->configs[i].fmt = *fmt;
1932
1933         return 0;
1934 }
1935 EXPORT_SYMBOL_GPL(v4l2_subdev_set_routing_with_fmt);
1936
1937 int v4l2_subdev_routing_find_opposite_end(const struct v4l2_subdev_krouting *routing,
1938                                           u32 pad, u32 stream, u32 *other_pad,
1939                                           u32 *other_stream)
1940 {
1941         unsigned int i;
1942
1943         for (i = 0; i < routing->num_routes; ++i) {
1944                 struct v4l2_subdev_route *route = &routing->routes[i];
1945
1946                 if (route->source_pad == pad &&
1947                     route->source_stream == stream) {
1948                         if (other_pad)
1949                                 *other_pad = route->sink_pad;
1950                         if (other_stream)
1951                                 *other_stream = route->sink_stream;
1952                         return 0;
1953                 }
1954
1955                 if (route->sink_pad == pad && route->sink_stream == stream) {
1956                         if (other_pad)
1957                                 *other_pad = route->source_pad;
1958                         if (other_stream)
1959                                 *other_stream = route->source_stream;
1960                         return 0;
1961                 }
1962         }
1963
1964         return -EINVAL;
1965 }
1966 EXPORT_SYMBOL_GPL(v4l2_subdev_routing_find_opposite_end);
1967
1968 struct v4l2_mbus_framefmt *
1969 v4l2_subdev_state_get_opposite_stream_format(struct v4l2_subdev_state *state,
1970                                              u32 pad, u32 stream)
1971 {
1972         u32 other_pad, other_stream;
1973         int ret;
1974
1975         ret = v4l2_subdev_routing_find_opposite_end(&state->routing,
1976                                                     pad, stream,
1977                                                     &other_pad, &other_stream);
1978         if (ret)
1979                 return NULL;
1980
1981         return v4l2_subdev_state_get_format(state, other_pad, other_stream);
1982 }
1983 EXPORT_SYMBOL_GPL(v4l2_subdev_state_get_opposite_stream_format);
1984
1985 u64 v4l2_subdev_state_xlate_streams(const struct v4l2_subdev_state *state,
1986                                     u32 pad0, u32 pad1, u64 *streams)
1987 {
1988         const struct v4l2_subdev_krouting *routing = &state->routing;
1989         struct v4l2_subdev_route *route;
1990         u64 streams0 = 0;
1991         u64 streams1 = 0;
1992
1993         for_each_active_route(routing, route) {
1994                 if (route->sink_pad == pad0 && route->source_pad == pad1 &&
1995                     (*streams & BIT_ULL(route->sink_stream))) {
1996                         streams0 |= BIT_ULL(route->sink_stream);
1997                         streams1 |= BIT_ULL(route->source_stream);
1998                 }
1999                 if (route->source_pad == pad0 && route->sink_pad == pad1 &&
2000                     (*streams & BIT_ULL(route->source_stream))) {
2001                         streams0 |= BIT_ULL(route->source_stream);
2002                         streams1 |= BIT_ULL(route->sink_stream);
2003                 }
2004         }
2005
2006         *streams = streams0;
2007         return streams1;
2008 }
2009 EXPORT_SYMBOL_GPL(v4l2_subdev_state_xlate_streams);
2010
2011 int v4l2_subdev_routing_validate(struct v4l2_subdev *sd,
2012                                  const struct v4l2_subdev_krouting *routing,
2013                                  enum v4l2_subdev_routing_restriction disallow)
2014 {
2015         u32 *remote_pads = NULL;
2016         unsigned int i, j;
2017         int ret = -EINVAL;
2018
2019         if (disallow & (V4L2_SUBDEV_ROUTING_NO_STREAM_MIX |
2020                         V4L2_SUBDEV_ROUTING_NO_MULTIPLEXING)) {
2021                 remote_pads = kcalloc(sd->entity.num_pads, sizeof(*remote_pads),
2022                                       GFP_KERNEL);
2023                 if (!remote_pads)
2024                         return -ENOMEM;
2025
2026                 for (i = 0; i < sd->entity.num_pads; ++i)
2027                         remote_pads[i] = U32_MAX;
2028         }
2029
2030         for (i = 0; i < routing->num_routes; ++i) {
2031                 const struct v4l2_subdev_route *route = &routing->routes[i];
2032
2033                 /* Validate the sink and source pad numbers. */
2034                 if (route->sink_pad >= sd->entity.num_pads ||
2035                     !(sd->entity.pads[route->sink_pad].flags & MEDIA_PAD_FL_SINK)) {
2036                         dev_dbg(sd->dev, "route %u sink (%u) is not a sink pad\n",
2037                                 i, route->sink_pad);
2038                         goto out;
2039                 }
2040
2041                 if (route->source_pad >= sd->entity.num_pads ||
2042                     !(sd->entity.pads[route->source_pad].flags & MEDIA_PAD_FL_SOURCE)) {
2043                         dev_dbg(sd->dev, "route %u source (%u) is not a source pad\n",
2044                                 i, route->source_pad);
2045                         goto out;
2046                 }
2047
2048                 /*
2049                  * V4L2_SUBDEV_ROUTING_NO_SINK_STREAM_MIX: all streams from a
2050                  * sink pad must be routed to a single source pad.
2051                  */
2052                 if (disallow & V4L2_SUBDEV_ROUTING_NO_SINK_STREAM_MIX) {
2053                         if (remote_pads[route->sink_pad] != U32_MAX &&
2054                             remote_pads[route->sink_pad] != route->source_pad) {
2055                                 dev_dbg(sd->dev,
2056                                         "route %u attempts to mix %s streams\n",
2057                                         i, "sink");
2058                                 goto out;
2059                         }
2060                 }
2061
2062                 /*
2063                  * V4L2_SUBDEV_ROUTING_NO_SOURCE_STREAM_MIX: all streams on a
2064                  * source pad must originate from a single sink pad.
2065                  */
2066                 if (disallow & V4L2_SUBDEV_ROUTING_NO_SOURCE_STREAM_MIX) {
2067                         if (remote_pads[route->source_pad] != U32_MAX &&
2068                             remote_pads[route->source_pad] != route->sink_pad) {
2069                                 dev_dbg(sd->dev,
2070                                         "route %u attempts to mix %s streams\n",
2071                                         i, "source");
2072                                 goto out;
2073                         }
2074                 }
2075
2076                 /*
2077                  * V4L2_SUBDEV_ROUTING_NO_SINK_MULTIPLEXING: Pads on the sink
2078                  * side can not do stream multiplexing, i.e. there can be only
2079                  * a single stream in a sink pad.
2080                  */
2081                 if (disallow & V4L2_SUBDEV_ROUTING_NO_SINK_MULTIPLEXING) {
2082                         if (remote_pads[route->sink_pad] != U32_MAX) {
2083                                 dev_dbg(sd->dev,
2084                                         "route %u attempts to multiplex on %s pad %u\n",
2085                                         i, "sink", route->sink_pad);
2086                                 goto out;
2087                         }
2088                 }
2089
2090                 /*
2091                  * V4L2_SUBDEV_ROUTING_NO_SOURCE_MULTIPLEXING: Pads on the
2092                  * source side can not do stream multiplexing, i.e. there can
2093                  * be only a single stream in a source pad.
2094                  */
2095                 if (disallow & V4L2_SUBDEV_ROUTING_NO_SOURCE_MULTIPLEXING) {
2096                         if (remote_pads[route->source_pad] != U32_MAX) {
2097                                 dev_dbg(sd->dev,
2098                                         "route %u attempts to multiplex on %s pad %u\n",
2099                                         i, "source", route->source_pad);
2100                                 goto out;
2101                         }
2102                 }
2103
2104                 if (remote_pads) {
2105                         remote_pads[route->sink_pad] = route->source_pad;
2106                         remote_pads[route->source_pad] = route->sink_pad;
2107                 }
2108
2109                 for (j = i + 1; j < routing->num_routes; ++j) {
2110                         const struct v4l2_subdev_route *r = &routing->routes[j];
2111
2112                         /*
2113                          * V4L2_SUBDEV_ROUTING_NO_1_TO_N: No two routes can
2114                          * originate from the same (sink) stream.
2115                          */
2116                         if ((disallow & V4L2_SUBDEV_ROUTING_NO_1_TO_N) &&
2117                             route->sink_pad == r->sink_pad &&
2118                             route->sink_stream == r->sink_stream) {
2119                                 dev_dbg(sd->dev,
2120                                         "routes %u and %u originate from same sink (%u/%u)\n",
2121                                         i, j, route->sink_pad,
2122                                         route->sink_stream);
2123                                 goto out;
2124                         }
2125
2126                         /*
2127                          * V4L2_SUBDEV_ROUTING_NO_N_TO_1: No two routes can end
2128                          * at the same (source) stream.
2129                          */
2130                         if ((disallow & V4L2_SUBDEV_ROUTING_NO_N_TO_1) &&
2131                             route->source_pad == r->source_pad &&
2132                             route->source_stream == r->source_stream) {
2133                                 dev_dbg(sd->dev,
2134                                         "routes %u and %u end at same source (%u/%u)\n",
2135                                         i, j, route->source_pad,
2136                                         route->source_stream);
2137                                 goto out;
2138                         }
2139                 }
2140         }
2141
2142         ret = 0;
2143
2144 out:
2145         kfree(remote_pads);
2146         return ret;
2147 }
2148 EXPORT_SYMBOL_GPL(v4l2_subdev_routing_validate);
2149
2150 static void v4l2_subdev_collect_streams(struct v4l2_subdev *sd,
2151                                         struct v4l2_subdev_state *state,
2152                                         u32 pad, u64 streams_mask,
2153                                         u64 *found_streams,
2154                                         u64 *enabled_streams)
2155 {
2156         if (!(sd->flags & V4L2_SUBDEV_FL_STREAMS)) {
2157                 *found_streams = BIT_ULL(0);
2158                 *enabled_streams =
2159                         (sd->enabled_pads & BIT_ULL(pad)) ? BIT_ULL(0) : 0;
2160                 return;
2161         }
2162
2163         *found_streams = 0;
2164         *enabled_streams = 0;
2165
2166         for (unsigned int i = 0; i < state->stream_configs.num_configs; ++i) {
2167                 const struct v4l2_subdev_stream_config *cfg =
2168                         &state->stream_configs.configs[i];
2169
2170                 if (cfg->pad != pad || !(streams_mask & BIT_ULL(cfg->stream)))
2171                         continue;
2172
2173                 *found_streams |= BIT_ULL(cfg->stream);
2174                 if (cfg->enabled)
2175                         *enabled_streams |= BIT_ULL(cfg->stream);
2176         }
2177 }
2178
2179 static void v4l2_subdev_set_streams_enabled(struct v4l2_subdev *sd,
2180                                             struct v4l2_subdev_state *state,
2181                                             u32 pad, u64 streams_mask,
2182                                             bool enabled)
2183 {
2184         if (!(sd->flags & V4L2_SUBDEV_FL_STREAMS)) {
2185                 if (enabled)
2186                         sd->enabled_pads |= BIT_ULL(pad);
2187                 else
2188                         sd->enabled_pads &= ~BIT_ULL(pad);
2189                 return;
2190         }
2191
2192         for (unsigned int i = 0; i < state->stream_configs.num_configs; ++i) {
2193                 struct v4l2_subdev_stream_config *cfg =
2194                         &state->stream_configs.configs[i];
2195
2196                 if (cfg->pad == pad && (streams_mask & BIT_ULL(cfg->stream)))
2197                         cfg->enabled = enabled;
2198         }
2199 }
2200
2201 int v4l2_subdev_enable_streams(struct v4l2_subdev *sd, u32 pad,
2202                                u64 streams_mask)
2203 {
2204         struct device *dev = sd->entity.graph_obj.mdev->dev;
2205         struct v4l2_subdev_state *state;
2206         bool already_streaming;
2207         u64 enabled_streams;
2208         u64 found_streams;
2209         bool use_s_stream;
2210         int ret;
2211
2212         /* A few basic sanity checks first. */
2213         if (pad >= sd->entity.num_pads)
2214                 return -EINVAL;
2215
2216         if (!(sd->entity.pads[pad].flags & MEDIA_PAD_FL_SOURCE))
2217                 return -EOPNOTSUPP;
2218
2219         /*
2220          * We use a 64-bit bitmask for tracking enabled pads, so only subdevices
2221          * with 64 pads or less can be supported.
2222          */
2223         if (pad >= sizeof(sd->enabled_pads) * BITS_PER_BYTE)
2224                 return -EOPNOTSUPP;
2225
2226         if (!streams_mask)
2227                 return 0;
2228
2229         /* Fallback on .s_stream() if .enable_streams() isn't available. */
2230         use_s_stream = !v4l2_subdev_has_op(sd, pad, enable_streams);
2231
2232         if (!use_s_stream)
2233                 state = v4l2_subdev_lock_and_get_active_state(sd);
2234         else
2235                 state = NULL;
2236
2237         /*
2238          * Verify that the requested streams exist and that they are not
2239          * already enabled.
2240          */
2241
2242         v4l2_subdev_collect_streams(sd, state, pad, streams_mask,
2243                                     &found_streams, &enabled_streams);
2244
2245         if (found_streams != streams_mask) {
2246                 dev_dbg(dev, "streams 0x%llx not found on %s:%u\n",
2247                         streams_mask & ~found_streams, sd->entity.name, pad);
2248                 ret = -EINVAL;
2249                 goto done;
2250         }
2251
2252         if (enabled_streams) {
2253                 dev_dbg(dev, "streams 0x%llx already enabled on %s:%u\n",
2254                         enabled_streams, sd->entity.name, pad);
2255                 ret = -EALREADY;
2256                 goto done;
2257         }
2258
2259         dev_dbg(dev, "enable streams %u:%#llx\n", pad, streams_mask);
2260
2261         already_streaming = v4l2_subdev_is_streaming(sd);
2262
2263         if (!use_s_stream) {
2264                 /* Call the .enable_streams() operation. */
2265                 ret = v4l2_subdev_call(sd, pad, enable_streams, state, pad,
2266                                        streams_mask);
2267         } else {
2268                 /* Start streaming when the first pad is enabled. */
2269                 if (!already_streaming)
2270                         ret = v4l2_subdev_call(sd, video, s_stream, 1);
2271                 else
2272                         ret = 0;
2273         }
2274
2275         if (ret) {
2276                 dev_dbg(dev, "enable streams %u:%#llx failed: %d\n", pad,
2277                         streams_mask, ret);
2278                 goto done;
2279         }
2280
2281         /* Mark the streams as enabled. */
2282         v4l2_subdev_set_streams_enabled(sd, state, pad, streams_mask, true);
2283
2284         /*
2285          * TODO: When all the drivers have been changed to use
2286          * v4l2_subdev_enable_streams() and v4l2_subdev_disable_streams(),
2287          * instead of calling .s_stream() operation directly, we can remove
2288          * the privacy LED handling from call_s_stream() and do it here
2289          * for all cases.
2290          */
2291         if (!use_s_stream && !already_streaming)
2292                 v4l2_subdev_enable_privacy_led(sd);
2293
2294 done:
2295         if (!use_s_stream)
2296                 v4l2_subdev_unlock_state(state);
2297
2298         return ret;
2299 }
2300 EXPORT_SYMBOL_GPL(v4l2_subdev_enable_streams);
2301
2302 int v4l2_subdev_disable_streams(struct v4l2_subdev *sd, u32 pad,
2303                                 u64 streams_mask)
2304 {
2305         struct device *dev = sd->entity.graph_obj.mdev->dev;
2306         struct v4l2_subdev_state *state;
2307         u64 enabled_streams;
2308         u64 found_streams;
2309         bool use_s_stream;
2310         int ret;
2311
2312         /* A few basic sanity checks first. */
2313         if (pad >= sd->entity.num_pads)
2314                 return -EINVAL;
2315
2316         if (!(sd->entity.pads[pad].flags & MEDIA_PAD_FL_SOURCE))
2317                 return -EOPNOTSUPP;
2318
2319         /*
2320          * We use a 64-bit bitmask for tracking enabled pads, so only subdevices
2321          * with 64 pads or less can be supported.
2322          */
2323         if (pad >= sizeof(sd->enabled_pads) * BITS_PER_BYTE)
2324                 return -EOPNOTSUPP;
2325
2326         if (!streams_mask)
2327                 return 0;
2328
2329         /* Fallback on .s_stream() if .disable_streams() isn't available. */
2330         use_s_stream = !v4l2_subdev_has_op(sd, pad, disable_streams);
2331
2332         if (!use_s_stream)
2333                 state = v4l2_subdev_lock_and_get_active_state(sd);
2334         else
2335                 state = NULL;
2336
2337         /*
2338          * Verify that the requested streams exist and that they are not
2339          * already disabled.
2340          */
2341
2342         v4l2_subdev_collect_streams(sd, state, pad, streams_mask,
2343                                     &found_streams, &enabled_streams);
2344
2345         if (found_streams != streams_mask) {
2346                 dev_dbg(dev, "streams 0x%llx not found on %s:%u\n",
2347                         streams_mask & ~found_streams, sd->entity.name, pad);
2348                 ret = -EINVAL;
2349                 goto done;
2350         }
2351
2352         if (enabled_streams != streams_mask) {
2353                 dev_dbg(dev, "streams 0x%llx already disabled on %s:%u\n",
2354                         streams_mask & ~enabled_streams, sd->entity.name, pad);
2355                 ret = -EALREADY;
2356                 goto done;
2357         }
2358
2359         dev_dbg(dev, "disable streams %u:%#llx\n", pad, streams_mask);
2360
2361         if (!use_s_stream) {
2362                 /* Call the .disable_streams() operation. */
2363                 ret = v4l2_subdev_call(sd, pad, disable_streams, state, pad,
2364                                        streams_mask);
2365         } else {
2366                 /* Stop streaming when the last streams are disabled. */
2367
2368                 if (!(sd->enabled_pads & ~BIT_ULL(pad)))
2369                         ret = v4l2_subdev_call(sd, video, s_stream, 0);
2370                 else
2371                         ret = 0;
2372         }
2373
2374         if (ret) {
2375                 dev_dbg(dev, "disable streams %u:%#llx failed: %d\n", pad,
2376                         streams_mask, ret);
2377                 goto done;
2378         }
2379
2380         v4l2_subdev_set_streams_enabled(sd, state, pad, streams_mask, false);
2381
2382 done:
2383         if (!use_s_stream) {
2384                 if (!v4l2_subdev_is_streaming(sd))
2385                         v4l2_subdev_disable_privacy_led(sd);
2386
2387                 v4l2_subdev_unlock_state(state);
2388         }
2389
2390         return ret;
2391 }
2392 EXPORT_SYMBOL_GPL(v4l2_subdev_disable_streams);
2393
2394 int v4l2_subdev_s_stream_helper(struct v4l2_subdev *sd, int enable)
2395 {
2396         struct v4l2_subdev_state *state;
2397         struct v4l2_subdev_route *route;
2398         struct media_pad *pad;
2399         u64 source_mask = 0;
2400         int pad_index = -1;
2401
2402         /*
2403          * Find the source pad. This helper is meant for subdevs that have a
2404          * single source pad, so failures shouldn't happen, but catch them
2405          * loudly nonetheless as they indicate a driver bug.
2406          */
2407         media_entity_for_each_pad(&sd->entity, pad) {
2408                 if (pad->flags & MEDIA_PAD_FL_SOURCE) {
2409                         pad_index = pad->index;
2410                         break;
2411                 }
2412         }
2413
2414         if (WARN_ON(pad_index == -1))
2415                 return -EINVAL;
2416
2417         if (sd->flags & V4L2_SUBDEV_FL_STREAMS) {
2418                 /*
2419                  * As there's a single source pad, just collect all the source
2420                  * streams.
2421                  */
2422                 state = v4l2_subdev_lock_and_get_active_state(sd);
2423
2424                 for_each_active_route(&state->routing, route)
2425                         source_mask |= BIT_ULL(route->source_stream);
2426
2427                 v4l2_subdev_unlock_state(state);
2428         } else {
2429                 /*
2430                  * For non-streams subdevices, there's a single implicit stream
2431                  * per pad.
2432                  */
2433                 source_mask = BIT_ULL(0);
2434         }
2435
2436         if (enable)
2437                 return v4l2_subdev_enable_streams(sd, pad_index, source_mask);
2438         else
2439                 return v4l2_subdev_disable_streams(sd, pad_index, source_mask);
2440 }
2441 EXPORT_SYMBOL_GPL(v4l2_subdev_s_stream_helper);
2442
2443 #endif /* CONFIG_VIDEO_V4L2_SUBDEV_API */
2444
2445 #endif /* CONFIG_MEDIA_CONTROLLER */
2446
2447 void v4l2_subdev_init(struct v4l2_subdev *sd, const struct v4l2_subdev_ops *ops)
2448 {
2449         INIT_LIST_HEAD(&sd->list);
2450         BUG_ON(!ops);
2451         sd->ops = ops;
2452         sd->v4l2_dev = NULL;
2453         sd->flags = 0;
2454         sd->name[0] = '\0';
2455         sd->grp_id = 0;
2456         sd->dev_priv = NULL;
2457         sd->host_priv = NULL;
2458         sd->privacy_led = NULL;
2459         INIT_LIST_HEAD(&sd->async_subdev_endpoint_list);
2460 #if defined(CONFIG_MEDIA_CONTROLLER)
2461         sd->entity.name = sd->name;
2462         sd->entity.obj_type = MEDIA_ENTITY_TYPE_V4L2_SUBDEV;
2463         sd->entity.function = MEDIA_ENT_F_V4L2_SUBDEV_UNKNOWN;
2464 #endif
2465 }
2466 EXPORT_SYMBOL(v4l2_subdev_init);
2467
2468 void v4l2_subdev_notify_event(struct v4l2_subdev *sd,
2469                               const struct v4l2_event *ev)
2470 {
2471         v4l2_event_queue(sd->devnode, ev);
2472         v4l2_subdev_notify(sd, V4L2_DEVICE_NOTIFY_EVENT, (void *)ev);
2473 }
2474 EXPORT_SYMBOL_GPL(v4l2_subdev_notify_event);
2475
2476 bool v4l2_subdev_is_streaming(struct v4l2_subdev *sd)
2477 {
2478         struct v4l2_subdev_state *state;
2479
2480         if (!v4l2_subdev_has_op(sd, pad, enable_streams))
2481                 return sd->s_stream_enabled;
2482
2483         if (!(sd->flags & V4L2_SUBDEV_FL_STREAMS))
2484                 return !!sd->enabled_pads;
2485
2486         state = v4l2_subdev_get_locked_active_state(sd);
2487
2488         for (unsigned int i = 0; i < state->stream_configs.num_configs; ++i) {
2489                 const struct v4l2_subdev_stream_config *cfg;
2490
2491                 cfg = &state->stream_configs.configs[i];
2492
2493                 if (cfg->enabled)
2494                         return true;
2495         }
2496
2497         return false;
2498 }
2499 EXPORT_SYMBOL_GPL(v4l2_subdev_is_streaming);
2500
2501 int v4l2_subdev_get_privacy_led(struct v4l2_subdev *sd)
2502 {
2503 #if IS_REACHABLE(CONFIG_LEDS_CLASS)
2504         sd->privacy_led = led_get(sd->dev, "privacy-led");
2505         if (IS_ERR(sd->privacy_led) && PTR_ERR(sd->privacy_led) != -ENOENT)
2506                 return dev_err_probe(sd->dev, PTR_ERR(sd->privacy_led),
2507                                      "getting privacy LED\n");
2508
2509         if (!IS_ERR_OR_NULL(sd->privacy_led)) {
2510                 mutex_lock(&sd->privacy_led->led_access);
2511                 led_sysfs_disable(sd->privacy_led);
2512                 led_trigger_remove(sd->privacy_led);
2513                 led_set_brightness(sd->privacy_led, 0);
2514                 mutex_unlock(&sd->privacy_led->led_access);
2515         }
2516 #endif
2517         return 0;
2518 }
2519 EXPORT_SYMBOL_GPL(v4l2_subdev_get_privacy_led);
2520
2521 void v4l2_subdev_put_privacy_led(struct v4l2_subdev *sd)
2522 {
2523 #if IS_REACHABLE(CONFIG_LEDS_CLASS)
2524         if (!IS_ERR_OR_NULL(sd->privacy_led)) {
2525                 mutex_lock(&sd->privacy_led->led_access);
2526                 led_sysfs_enable(sd->privacy_led);
2527                 mutex_unlock(&sd->privacy_led->led_access);
2528                 led_put(sd->privacy_led);
2529         }
2530 #endif
2531 }
2532 EXPORT_SYMBOL_GPL(v4l2_subdev_put_privacy_led);