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

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * V4L2 fwnode binding parsing library
   4  *
   5  * The origins of the V4L2 fwnode library are in V4L2 OF library that
   6  * formerly was located in v4l2-of.c.
   7  *
   8  * Copyright (c) 2016 Intel Corporation.
   9  * Author: Sakari Ailus <sakari.ailus@linux.intel.com>
  10  *
  11  * Copyright (C) 2012 - 2013 Samsung Electronics Co., Ltd.
  12  * Author: Sylwester Nawrocki <s.nawrocki@samsung.com>
  13  *
  14  * Copyright (C) 2012 Renesas Electronics Corp.
  15  * Author: Guennadi Liakhovetski <g.liakhovetski@gmx.de>
  16  */
  17 #include <linux/acpi.h>
  18 #include <linux/kernel.h>
  19 #include <linux/mm.h>
  20 #include <linux/module.h>
  21 #include <linux/of.h>
  22 #include <linux/property.h>
  23 #include <linux/slab.h>
  24 #include <linux/string.h>
  25 #include <linux/types.h>
  26
  27 #include <media/v4l2-async.h>
  28 #include <media/v4l2-fwnode.h>
  29 #include <media/v4l2-subdev.h>
  30
  31 static const struct v4l2_fwnode_bus_conv {
  32         enum v4l2_fwnode_bus_type fwnode_bus_type;
  33         enum v4l2_mbus_type mbus_type;
  34         const char *name;
  35 } buses[] = {
  36         {
  37                 V4L2_FWNODE_BUS_TYPE_GUESS,
  38                 V4L2_MBUS_UNKNOWN,
  39                 "not specified",
  40         }, {
  41                 V4L2_FWNODE_BUS_TYPE_CSI2_CPHY,
  42                 V4L2_MBUS_CSI2_CPHY,
  43                 "MIPI CSI-2 C-PHY",
  44         }, {
  45                 V4L2_FWNODE_BUS_TYPE_CSI1,
  46                 V4L2_MBUS_CSI1,
  47                 "MIPI CSI-1",
  48         }, {
  49                 V4L2_FWNODE_BUS_TYPE_CCP2,
  50                 V4L2_MBUS_CCP2,
  51                 "compact camera port 2",
  52         }, {
  53                 V4L2_FWNODE_BUS_TYPE_CSI2_DPHY,
  54                 V4L2_MBUS_CSI2_DPHY,
  55                 "MIPI CSI-2 D-PHY",
  56         }, {
  57                 V4L2_FWNODE_BUS_TYPE_PARALLEL,
  58                 V4L2_MBUS_PARALLEL,
  59                 "parallel",
  60         }, {
  61                 V4L2_FWNODE_BUS_TYPE_BT656,
  62                 V4L2_MBUS_BT656,
  63                 "Bt.656",
  64         }
  65 };
  66
  67 static const struct v4l2_fwnode_bus_conv *
  68 get_v4l2_fwnode_bus_conv_by_fwnode_bus(enum v4l2_fwnode_bus_type type)
  69 {
  70         unsigned int i;
  71
  72         for (i = 0; i < ARRAY_SIZE(buses); i++)
  73                 if (buses[i].fwnode_bus_type == type)
  74                         return &buses[i];
  75
  76         return NULL;
  77 }
  78
  79 static enum v4l2_mbus_type
  80 v4l2_fwnode_bus_type_to_mbus(enum v4l2_fwnode_bus_type type)
  81 {
  82         const struct v4l2_fwnode_bus_conv *conv =
  83                 get_v4l2_fwnode_bus_conv_by_fwnode_bus(type);
  84
  85         return conv ? conv->mbus_type : V4L2_MBUS_INVALID;
  86 }
  87
  88 static const char *
  89 v4l2_fwnode_bus_type_to_string(enum v4l2_fwnode_bus_type type)
  90 {
  91         const struct v4l2_fwnode_bus_conv *conv =
  92                 get_v4l2_fwnode_bus_conv_by_fwnode_bus(type);
  93
  94         return conv ? conv->name : "not found";
  95 }
  96
  97 static const struct v4l2_fwnode_bus_conv *
  98 get_v4l2_fwnode_bus_conv_by_mbus(enum v4l2_mbus_type type)
  99 {
 100         unsigned int i;
 101
 102         for (i = 0; i < ARRAY_SIZE(buses); i++)
 103                 if (buses[i].mbus_type == type)
 104                         return &buses[i];
 105
 106         return NULL;
 107 }
 108
 109 static const char *
 110 v4l2_fwnode_mbus_type_to_string(enum v4l2_mbus_type type)
 111 {
 112         const struct v4l2_fwnode_bus_conv *conv =
 113                 get_v4l2_fwnode_bus_conv_by_mbus(type);
 114
 115         return conv ? conv->name : "not found";
 116 }
 117
 118 static int v4l2_fwnode_endpoint_parse_csi2_bus(struct fwnode_handle *fwnode,
 119                                                struct v4l2_fwnode_endpoint *vep,
 120                                                enum v4l2_mbus_type bus_type)
 121 {
 122         struct v4l2_fwnode_bus_mipi_csi2 *bus = &vep->bus.mipi_csi2;
 123         bool have_clk_lane = false, have_data_lanes = false,
 124                 have_lane_polarities = false;
 125         unsigned int flags = 0, lanes_used = 0;
 126         u32 array[1 + V4L2_FWNODE_CSI2_MAX_DATA_LANES];
 127         u32 clock_lane = 0;
 128         unsigned int num_data_lanes = 0;
 129         bool use_default_lane_mapping = false;
 130         unsigned int i;
 131         u32 v;
 132         int rval;
 133
 134         if (bus_type == V4L2_MBUS_CSI2_DPHY ||
 135             bus_type == V4L2_MBUS_CSI2_CPHY) {
 136                 use_default_lane_mapping = true;
 137
 138                 num_data_lanes = min_t(u32, bus->num_data_lanes,
 139                                        V4L2_FWNODE_CSI2_MAX_DATA_LANES);
 140
 141                 clock_lane = bus->clock_lane;
 142                 if (clock_lane)
 143                         use_default_lane_mapping = false;
 144
 145                 for (i = 0; i < num_data_lanes; i++) {
 146                         array[i] = bus->data_lanes[i];
 147                         if (array[i])
 148                                 use_default_lane_mapping = false;
 149                 }
 150
 151                 if (use_default_lane_mapping)
 152                         pr_debug("no lane mapping given, using defaults\n");
 153         }
 154
 155         rval = fwnode_property_count_u32(fwnode, "data-lanes");
 156         if (rval > 0) {
 157                 num_data_lanes =
 158                         min_t(int, V4L2_FWNODE_CSI2_MAX_DATA_LANES, rval);
 159
 160                 fwnode_property_read_u32_array(fwnode, "data-lanes", array,
 161                                                num_data_lanes);
 162
 163                 have_data_lanes = true;
 164                 if (use_default_lane_mapping) {
 165                         pr_debug("data-lanes property exists; disabling default mapping\n");
 166                         use_default_lane_mapping = false;
 167                 }
 168         }
 169
 170         for (i = 0; i < num_data_lanes; i++) {
 171                 if (lanes_used & BIT(array[i])) {
 172                         if (have_data_lanes || !use_default_lane_mapping)
 173                                 pr_warn("duplicated lane %u in data-lanes, using defaults\n",
 174                                         array[i]);
 175                         use_default_lane_mapping = true;
 176                 }
 177                 lanes_used |= BIT(array[i]);
 178
 179                 if (have_data_lanes)
 180                         pr_debug("lane %u position %u\n", i, array[i]);
 181         }
 182
 183         rval = fwnode_property_count_u32(fwnode, "lane-polarities");
 184         if (rval > 0) {
 185                 if (rval != 1 + num_data_lanes /* clock+data */) {
 186                         pr_warn("invalid number of lane-polarities entries (need %u, got %u)\n",
 187                                 1 + num_data_lanes, rval);
 188                         return -EINVAL;
 189                 }
 190
 191                 have_lane_polarities = true;
 192         }
 193
 194         if (!fwnode_property_read_u32(fwnode, "clock-lanes", &v)) {
 195                 clock_lane = v;
 196                 pr_debug("clock lane position %u\n", v);
 197                 have_clk_lane = true;
 198         }
 199
 200         if (have_clk_lane && lanes_used & BIT(clock_lane) &&
 201             !use_default_lane_mapping) {
 202                 pr_warn("duplicated lane %u in clock-lanes, using defaults\n",
 203                         v);
 204                 use_default_lane_mapping = true;
 205         }
 206
 207         if (fwnode_property_present(fwnode, "clock-noncontinuous")) {
 208                 flags |= V4L2_MBUS_CSI2_NONCONTINUOUS_CLOCK;
 209                 pr_debug("non-continuous clock\n");
 210         } else {
 211                 flags |= V4L2_MBUS_CSI2_CONTINUOUS_CLOCK;
 212         }
 213
 214         if (bus_type == V4L2_MBUS_CSI2_DPHY ||
 215             bus_type == V4L2_MBUS_CSI2_CPHY || lanes_used ||
 216             have_clk_lane || (flags & ~V4L2_MBUS_CSI2_CONTINUOUS_CLOCK)) {
 217                 /* Only D-PHY has a clock lane. */
 218                 unsigned int dfl_data_lane_index =
 219                         bus_type == V4L2_MBUS_CSI2_DPHY;
 220
 221                 bus->flags = flags;
 222                 if (bus_type == V4L2_MBUS_UNKNOWN)
 223                         vep->bus_type = V4L2_MBUS_CSI2_DPHY;
 224                 bus->num_data_lanes = num_data_lanes;
 225
 226                 if (use_default_lane_mapping) {
 227                         bus->clock_lane = 0;
 228                         for (i = 0; i < num_data_lanes; i++)
 229                                 bus->data_lanes[i] = dfl_data_lane_index + i;
 230                 } else {
 231                         bus->clock_lane = clock_lane;
 232                         for (i = 0; i < num_data_lanes; i++)
 233                                 bus->data_lanes[i] = array[i];
 234                 }
 235
 236                 if (have_lane_polarities) {
 237                         fwnode_property_read_u32_array(fwnode,
 238                                                        "lane-polarities", array,
 239                                                        1 + num_data_lanes);
 240
 241                         for (i = 0; i < 1 + num_data_lanes; i++) {
 242                                 bus->lane_polarities[i] = array[i];
 243                                 pr_debug("lane %u polarity %sinverted",
 244                                          i, array[i] ? "" : "not ");
 245                         }
 246                 } else {
 247                         pr_debug("no lane polarities defined, assuming not inverted\n");
 248                 }
 249         }
 250
 251         return 0;
 252 }
 253
 254 #define PARALLEL_MBUS_FLAGS (V4L2_MBUS_HSYNC_ACTIVE_HIGH |      \
 255                              V4L2_MBUS_HSYNC_ACTIVE_LOW |       \
 256                              V4L2_MBUS_VSYNC_ACTIVE_HIGH |      \
 257                              V4L2_MBUS_VSYNC_ACTIVE_LOW |       \
 258                              V4L2_MBUS_FIELD_EVEN_HIGH |        \
 259                              V4L2_MBUS_FIELD_EVEN_LOW)
 260
 261 static void
 262 v4l2_fwnode_endpoint_parse_parallel_bus(struct fwnode_handle *fwnode,
 263                                         struct v4l2_fwnode_endpoint *vep,
 264                                         enum v4l2_mbus_type bus_type)
 265 {
 266         struct v4l2_fwnode_bus_parallel *bus = &vep->bus.parallel;
 267         unsigned int flags = 0;
 268         u32 v;
 269
 270         if (bus_type == V4L2_MBUS_PARALLEL || bus_type == V4L2_MBUS_BT656)
 271                 flags = bus->flags;
 272
 273         if (!fwnode_property_read_u32(fwnode, "hsync-active", &v)) {
 274                 flags &= ~(V4L2_MBUS_HSYNC_ACTIVE_HIGH |
 275                            V4L2_MBUS_HSYNC_ACTIVE_LOW);
 276                 flags |= v ? V4L2_MBUS_HSYNC_ACTIVE_HIGH :
 277                         V4L2_MBUS_HSYNC_ACTIVE_LOW;
 278                 pr_debug("hsync-active %s\n", v ? "high" : "low");
 279         }
 280
 281         if (!fwnode_property_read_u32(fwnode, "vsync-active", &v)) {
 282                 flags &= ~(V4L2_MBUS_VSYNC_ACTIVE_HIGH |
 283                            V4L2_MBUS_VSYNC_ACTIVE_LOW);
 284                 flags |= v ? V4L2_MBUS_VSYNC_ACTIVE_HIGH :
 285                         V4L2_MBUS_VSYNC_ACTIVE_LOW;
 286                 pr_debug("vsync-active %s\n", v ? "high" : "low");
 287         }
 288
 289         if (!fwnode_property_read_u32(fwnode, "field-even-active", &v)) {
 290                 flags &= ~(V4L2_MBUS_FIELD_EVEN_HIGH |
 291                            V4L2_MBUS_FIELD_EVEN_LOW);
 292                 flags |= v ? V4L2_MBUS_FIELD_EVEN_HIGH :
 293                         V4L2_MBUS_FIELD_EVEN_LOW;
 294                 pr_debug("field-even-active %s\n", v ? "high" : "low");
 295         }
 296
 297         if (!fwnode_property_read_u32(fwnode, "pclk-sample", &v)) {
 298                 flags &= ~(V4L2_MBUS_PCLK_SAMPLE_RISING |
 299                            V4L2_MBUS_PCLK_SAMPLE_FALLING);
 300                 flags |= v ? V4L2_MBUS_PCLK_SAMPLE_RISING :
 301                         V4L2_MBUS_PCLK_SAMPLE_FALLING;
 302                 pr_debug("pclk-sample %s\n", v ? "high" : "low");
 303         }
 304
 305         if (!fwnode_property_read_u32(fwnode, "data-active", &v)) {
 306                 flags &= ~(V4L2_MBUS_DATA_ACTIVE_HIGH |
 307                            V4L2_MBUS_DATA_ACTIVE_LOW);
 308                 flags |= v ? V4L2_MBUS_DATA_ACTIVE_HIGH :
 309                         V4L2_MBUS_DATA_ACTIVE_LOW;
 310                 pr_debug("data-active %s\n", v ? "high" : "low");
 311         }
 312
 313         if (fwnode_property_present(fwnode, "slave-mode")) {
 314                 pr_debug("slave mode\n");
 315                 flags &= ~V4L2_MBUS_MASTER;
 316                 flags |= V4L2_MBUS_SLAVE;
 317         } else {
 318                 flags &= ~V4L2_MBUS_SLAVE;
 319                 flags |= V4L2_MBUS_MASTER;
 320         }
 321
 322         if (!fwnode_property_read_u32(fwnode, "bus-width", &v)) {
 323                 bus->bus_width = v;
 324                 pr_debug("bus-width %u\n", v);
 325         }
 326
 327         if (!fwnode_property_read_u32(fwnode, "data-shift", &v)) {
 328                 bus->data_shift = v;
 329                 pr_debug("data-shift %u\n", v);
 330         }
 331
 332         if (!fwnode_property_read_u32(fwnode, "sync-on-green-active", &v)) {
 333                 flags &= ~(V4L2_MBUS_VIDEO_SOG_ACTIVE_HIGH |
 334                            V4L2_MBUS_VIDEO_SOG_ACTIVE_LOW);
 335                 flags |= v ? V4L2_MBUS_VIDEO_SOG_ACTIVE_HIGH :
 336                         V4L2_MBUS_VIDEO_SOG_ACTIVE_LOW;
 337                 pr_debug("sync-on-green-active %s\n", v ? "high" : "low");
 338         }
 339
 340         if (!fwnode_property_read_u32(fwnode, "data-enable-active", &v)) {
 341                 flags &= ~(V4L2_MBUS_DATA_ENABLE_HIGH |
 342                            V4L2_MBUS_DATA_ENABLE_LOW);
 343                 flags |= v ? V4L2_MBUS_DATA_ENABLE_HIGH :
 344                         V4L2_MBUS_DATA_ENABLE_LOW;
 345                 pr_debug("data-enable-active %s\n", v ? "high" : "low");
 346         }
 347
 348         switch (bus_type) {
 349         default:
 350                 bus->flags = flags;
 351                 if (flags & PARALLEL_MBUS_FLAGS)
 352                         vep->bus_type = V4L2_MBUS_PARALLEL;
 353                 else
 354                         vep->bus_type = V4L2_MBUS_BT656;
 355                 break;
 356         case V4L2_MBUS_PARALLEL:
 357                 vep->bus_type = V4L2_MBUS_PARALLEL;
 358                 bus->flags = flags;
 359                 break;
 360         case V4L2_MBUS_BT656:
 361                 vep->bus_type = V4L2_MBUS_BT656;
 362                 bus->flags = flags & ~PARALLEL_MBUS_FLAGS;
 363                 break;
 364         }
 365 }
 366
 367 static void
 368 v4l2_fwnode_endpoint_parse_csi1_bus(struct fwnode_handle *fwnode,
 369                                     struct v4l2_fwnode_endpoint *vep,
 370                                     enum v4l2_mbus_type bus_type)
 371 {
 372         struct v4l2_fwnode_bus_mipi_csi1 *bus = &vep->bus.mipi_csi1;
 373         u32 v;
 374
 375         if (!fwnode_property_read_u32(fwnode, "clock-inv", &v)) {
 376                 bus->clock_inv = v;
 377                 pr_debug("clock-inv %u\n", v);
 378         }
 379
 380         if (!fwnode_property_read_u32(fwnode, "strobe", &v)) {
 381                 bus->strobe = v;
 382                 pr_debug("strobe %u\n", v);
 383         }
 384
 385         if (!fwnode_property_read_u32(fwnode, "data-lanes", &v)) {
 386                 bus->data_lane = v;
 387                 pr_debug("data-lanes %u\n", v);
 388         }
 389
 390         if (!fwnode_property_read_u32(fwnode, "clock-lanes", &v)) {
 391                 bus->clock_lane = v;
 392                 pr_debug("clock-lanes %u\n", v);
 393         }
 394
 395         if (bus_type == V4L2_MBUS_CCP2)
 396                 vep->bus_type = V4L2_MBUS_CCP2;
 397         else
 398                 vep->bus_type = V4L2_MBUS_CSI1;
 399 }
 400
 401 static int __v4l2_fwnode_endpoint_parse(struct fwnode_handle *fwnode,
 402                                         struct v4l2_fwnode_endpoint *vep)
 403 {
 404         u32 bus_type = V4L2_FWNODE_BUS_TYPE_GUESS;
 405         enum v4l2_mbus_type mbus_type;
 406         int rval;
 407
 408         pr_debug("===== begin parsing endpoint %pfw\n", fwnode);
 409
 410         fwnode_property_read_u32(fwnode, "bus-type", &bus_type);
 411         pr_debug("fwnode video bus type %s (%u), mbus type %s (%u)\n",
 412                  v4l2_fwnode_bus_type_to_string(bus_type), bus_type,
 413                  v4l2_fwnode_mbus_type_to_string(vep->bus_type),
 414                  vep->bus_type);
 415         mbus_type = v4l2_fwnode_bus_type_to_mbus(bus_type);
 416         if (mbus_type == V4L2_MBUS_INVALID) {
 417                 pr_debug("unsupported bus type %u\n", bus_type);
 418                 return -EINVAL;
 419         }
 420
 421         if (vep->bus_type != V4L2_MBUS_UNKNOWN) {
 422                 if (mbus_type != V4L2_MBUS_UNKNOWN &&
 423                     vep->bus_type != mbus_type) {
 424                         pr_debug("expecting bus type %s\n",
 425                                  v4l2_fwnode_mbus_type_to_string(vep->bus_type));
 426                         return -ENXIO;
 427                 }
 428         } else {
 429                 vep->bus_type = mbus_type;
 430         }
 431
 432         switch (vep->bus_type) {
 433         case V4L2_MBUS_UNKNOWN:
 434                 rval = v4l2_fwnode_endpoint_parse_csi2_bus(fwnode, vep,
 435                                                            V4L2_MBUS_UNKNOWN);
 436                 if (rval)
 437                         return rval;
 438
 439                 if (vep->bus_type == V4L2_MBUS_UNKNOWN)
 440                         v4l2_fwnode_endpoint_parse_parallel_bus(fwnode, vep,
 441                                                                 V4L2_MBUS_UNKNOWN);
 442
 443                 pr_debug("assuming media bus type %s (%u)\n",
 444                          v4l2_fwnode_mbus_type_to_string(vep->bus_type),
 445                          vep->bus_type);
 446
 447                 break;
 448         case V4L2_MBUS_CCP2:
 449         case V4L2_MBUS_CSI1:
 450                 v4l2_fwnode_endpoint_parse_csi1_bus(fwnode, vep, vep->bus_type);
 451
 452                 break;
 453         case V4L2_MBUS_CSI2_DPHY:
 454         case V4L2_MBUS_CSI2_CPHY:
 455                 rval = v4l2_fwnode_endpoint_parse_csi2_bus(fwnode, vep,
 456                                                            vep->bus_type);
 457                 if (rval)
 458                         return rval;
 459
 460                 break;
 461         case V4L2_MBUS_PARALLEL:
 462         case V4L2_MBUS_BT656:
 463                 v4l2_fwnode_endpoint_parse_parallel_bus(fwnode, vep,
 464                                                         vep->bus_type);
 465
 466                 break;
 467         default:
 468                 pr_warn("unsupported bus type %u\n", mbus_type);
 469                 return -EINVAL;
 470         }
 471
 472         fwnode_graph_parse_endpoint(fwnode, &vep->base);
 473
 474         return 0;
 475 }
 476
 477 int v4l2_fwnode_endpoint_parse(struct fwnode_handle *fwnode,
 478                                struct v4l2_fwnode_endpoint *vep)
 479 {
 480         int ret;
 481
 482         ret = __v4l2_fwnode_endpoint_parse(fwnode, vep);
 483
 484         pr_debug("===== end parsing endpoint %pfw\n", fwnode);
 485
 486         return ret;
 487 }
 488 EXPORT_SYMBOL_GPL(v4l2_fwnode_endpoint_parse);
 489
 490 void v4l2_fwnode_endpoint_free(struct v4l2_fwnode_endpoint *vep)
 491 {
 492         if (IS_ERR_OR_NULL(vep))
 493                 return;
 494
 495         kfree(vep->link_frequencies);
 496         vep->link_frequencies = NULL;
 497 }
 498 EXPORT_SYMBOL_GPL(v4l2_fwnode_endpoint_free);
 499
 500 int v4l2_fwnode_endpoint_alloc_parse(struct fwnode_handle *fwnode,
 501                                      struct v4l2_fwnode_endpoint *vep)
 502 {
 503         int rval;
 504
 505         rval = __v4l2_fwnode_endpoint_parse(fwnode, vep);
 506         if (rval < 0)
 507                 return rval;
 508
 509         rval = fwnode_property_count_u64(fwnode, "link-frequencies");
 510         if (rval > 0) {
 511                 unsigned int i;
 512
 513                 vep->link_frequencies =
 514                         kmalloc_array(rval, sizeof(*vep->link_frequencies),
 515                                       GFP_KERNEL);
 516                 if (!vep->link_frequencies)
 517                         return -ENOMEM;
 518
 519                 vep->nr_of_link_frequencies = rval;
 520
 521                 rval = fwnode_property_read_u64_array(fwnode,
 522                                                       "link-frequencies",
 523                                                       vep->link_frequencies,
 524                                                       vep->nr_of_link_frequencies);
 525                 if (rval < 0) {
 526                         v4l2_fwnode_endpoint_free(vep);
 527                         return rval;
 528                 }
 529
 530                 for (i = 0; i < vep->nr_of_link_frequencies; i++)
 531                         pr_debug("link-frequencies %u value %llu\n", i,
 532                                  vep->link_frequencies[i]);
 533         }
 534
 535         pr_debug("===== end parsing endpoint %pfw\n", fwnode);
 536
 537         return 0;
 538 }
 539 EXPORT_SYMBOL_GPL(v4l2_fwnode_endpoint_alloc_parse);
 540
 541 int v4l2_fwnode_parse_link(struct fwnode_handle *fwnode,
 542                            struct v4l2_fwnode_link *link)
 543 {
 544         struct fwnode_endpoint fwep;
 545
 546         memset(link, 0, sizeof(*link));
 547
 548         fwnode_graph_parse_endpoint(fwnode, &fwep);
 549         link->local_id = fwep.id;
 550         link->local_port = fwep.port;
 551         link->local_node = fwnode_graph_get_port_parent(fwnode);
 552
 553         fwnode = fwnode_graph_get_remote_endpoint(fwnode);
 554         if (!fwnode) {
 555                 fwnode_handle_put(fwnode);
 556                 return -ENOLINK;
 557         }
 558
 559         fwnode_graph_parse_endpoint(fwnode, &fwep);
 560         link->remote_id = fwep.id;
 561         link->remote_port = fwep.port;
 562         link->remote_node = fwnode_graph_get_port_parent(fwnode);
 563
 564         return 0;
 565 }
 566 EXPORT_SYMBOL_GPL(v4l2_fwnode_parse_link);
 567
 568 void v4l2_fwnode_put_link(struct v4l2_fwnode_link *link)
 569 {
 570         fwnode_handle_put(link->local_node);
 571         fwnode_handle_put(link->remote_node);
 572 }
 573 EXPORT_SYMBOL_GPL(v4l2_fwnode_put_link);
 574
 575 static const struct v4l2_fwnode_connector_conv {
 576         enum v4l2_connector_type type;
 577         const char *compatible;
 578 } connectors[] = {
 579         {
 580                 .type = V4L2_CONN_COMPOSITE,
 581                 .compatible = "composite-video-connector",
 582         }, {
 583                 .type = V4L2_CONN_SVIDEO,
 584                 .compatible = "svideo-connector",
 585         },
 586 };
 587
 588 static enum v4l2_connector_type
 589 v4l2_fwnode_string_to_connector_type(const char *con_str)
 590 {
 591         unsigned int i;
 592
 593         for (i = 0; i < ARRAY_SIZE(connectors); i++)
 594                 if (!strcmp(con_str, connectors[i].compatible))
 595                         return connectors[i].type;
 596
 597         return V4L2_CONN_UNKNOWN;
 598 }
 599
 600 static void
 601 v4l2_fwnode_connector_parse_analog(struct fwnode_handle *fwnode,
 602                                    struct v4l2_fwnode_connector *vc)
 603 {
 604         u32 stds;
 605         int ret;
 606
 607         ret = fwnode_property_read_u32(fwnode, "sdtv-standards", &stds);
 608
 609         /* The property is optional. */
 610         vc->connector.analog.sdtv_stds = ret ? V4L2_STD_ALL : stds;
 611 }
 612
 613 void v4l2_fwnode_connector_free(struct v4l2_fwnode_connector *connector)
 614 {
 615         struct v4l2_connector_link *link, *tmp;
 616
 617         if (IS_ERR_OR_NULL(connector) || connector->type == V4L2_CONN_UNKNOWN)
 618                 return;
 619
 620         list_for_each_entry_safe(link, tmp, &connector->links, head) {
 621                 v4l2_fwnode_put_link(&link->fwnode_link);
 622                 list_del(&link->head);
 623                 kfree(link);
 624         }
 625
 626         kfree(connector->label);
 627         connector->label = NULL;
 628         connector->type = V4L2_CONN_UNKNOWN;
 629 }
 630 EXPORT_SYMBOL_GPL(v4l2_fwnode_connector_free);
 631
 632 static enum v4l2_connector_type
 633 v4l2_fwnode_get_connector_type(struct fwnode_handle *fwnode)
 634 {
 635         const char *type_name;
 636         int err;
 637
 638         if (!fwnode)
 639                 return V4L2_CONN_UNKNOWN;
 640
 641         /* The connector-type is stored within the compatible string. */
 642         err = fwnode_property_read_string(fwnode, "compatible", &type_name);
 643         if (err)
 644                 return V4L2_CONN_UNKNOWN;
 645
 646         return v4l2_fwnode_string_to_connector_type(type_name);
 647 }
 648
 649 int v4l2_fwnode_connector_parse(struct fwnode_handle *fwnode,
 650                                 struct v4l2_fwnode_connector *connector)
 651 {
 652         struct fwnode_handle *connector_node;
 653         enum v4l2_connector_type connector_type;
 654         const char *label;
 655         int err;
 656
 657         if (!fwnode)
 658                 return -EINVAL;
 659
 660         memset(connector, 0, sizeof(*connector));
 661
 662         INIT_LIST_HEAD(&connector->links);
 663
 664         connector_node = fwnode_graph_get_port_parent(fwnode);
 665         connector_type = v4l2_fwnode_get_connector_type(connector_node);
 666         if (connector_type == V4L2_CONN_UNKNOWN) {
 667                 fwnode_handle_put(connector_node);
 668                 connector_node = fwnode_graph_get_remote_port_parent(fwnode);
 669                 connector_type = v4l2_fwnode_get_connector_type(connector_node);
 670         }
 671
 672         if (connector_type == V4L2_CONN_UNKNOWN) {
 673                 pr_err("Unknown connector type\n");
 674                 err = -ENOTCONN;
 675                 goto out;
 676         }
 677
 678         connector->type = connector_type;
 679         connector->name = fwnode_get_name(connector_node);
 680         err = fwnode_property_read_string(connector_node, "label", &label);
 681         connector->label = err ? NULL : kstrdup_const(label, GFP_KERNEL);
 682
 683         /* Parse the connector specific properties. */
 684         switch (connector->type) {
 685         case V4L2_CONN_COMPOSITE:
 686         case V4L2_CONN_SVIDEO:
 687                 v4l2_fwnode_connector_parse_analog(connector_node, connector);
 688                 break;
 689         /* Avoid compiler warnings */
 690         case V4L2_CONN_UNKNOWN:
 691                 break;
 692         }
 693
 694 out:
 695         fwnode_handle_put(connector_node);
 696
 697         return err;
 698 }
 699 EXPORT_SYMBOL_GPL(v4l2_fwnode_connector_parse);
 700
 701 int v4l2_fwnode_connector_add_link(struct fwnode_handle *fwnode,
 702                                    struct v4l2_fwnode_connector *connector)
 703 {
 704         struct fwnode_handle *connector_ep;
 705         struct v4l2_connector_link *link;
 706         int err;
 707
 708         if (!fwnode || !connector || connector->type == V4L2_CONN_UNKNOWN)
 709                 return -EINVAL;
 710
 711         connector_ep = fwnode_graph_get_remote_endpoint(fwnode);
 712         if (!connector_ep)
 713                 return -ENOTCONN;
 714
 715         link = kzalloc(sizeof(*link), GFP_KERNEL);
 716         if (!link) {
 717                 err = -ENOMEM;
 718                 goto err;
 719         }
 720
 721         err = v4l2_fwnode_parse_link(connector_ep, &link->fwnode_link);
 722         if (err)
 723                 goto err;
 724
 725         fwnode_handle_put(connector_ep);
 726
 727         list_add(&link->head, &connector->links);
 728         connector->nr_of_links++;
 729
 730         return 0;
 731
 732 err:
 733         kfree(link);
 734         fwnode_handle_put(connector_ep);
 735
 736         return err;
 737 }
 738 EXPORT_SYMBOL_GPL(v4l2_fwnode_connector_add_link);
 739
 740 int v4l2_fwnode_device_parse(struct device *dev,
 741                              struct v4l2_fwnode_device_properties *props)
 742 {
 743         struct fwnode_handle *fwnode = dev_fwnode(dev);
 744         u32 val;
 745         int ret;
 746
 747         memset(props, 0, sizeof(*props));
 748
 749         props->orientation = V4L2_FWNODE_PROPERTY_UNSET;
 750         ret = fwnode_property_read_u32(fwnode, "orientation", &val);
 751         if (!ret) {
 752                 switch (val) {
 753                 case V4L2_FWNODE_ORIENTATION_FRONT:
 754                 case V4L2_FWNODE_ORIENTATION_BACK:
 755                 case V4L2_FWNODE_ORIENTATION_EXTERNAL:
 756                         break;
 757                 default:
 758                         dev_warn(dev, "Unsupported device orientation: %u\n", val);
 759                         return -EINVAL;
 760                 }
 761
 762                 props->orientation = val;
 763                 dev_dbg(dev, "device orientation: %u\n", val);
 764         }
 765
 766         props->rotation = V4L2_FWNODE_PROPERTY_UNSET;
 767         ret = fwnode_property_read_u32(fwnode, "rotation", &val);
 768         if (!ret) {
 769                 if (val >= 360) {
 770                         dev_warn(dev, "Unsupported device rotation: %u\n", val);
 771                         return -EINVAL;
 772                 }
 773
 774                 props->rotation = val;
 775                 dev_dbg(dev, "device rotation: %u\n", val);
 776         }
 777
 778         return 0;
 779 }
 780 EXPORT_SYMBOL_GPL(v4l2_fwnode_device_parse);
 781
 782 static int
 783 v4l2_async_notifier_fwnode_parse_endpoint(struct device *dev,
 784                                           struct v4l2_async_notifier *notifier,
 785                                           struct fwnode_handle *endpoint,
 786                                           unsigned int asd_struct_size,
 787                                           parse_endpoint_func parse_endpoint)
 788 {
 789         struct v4l2_fwnode_endpoint vep = { .bus_type = 0 };
 790         struct v4l2_async_subdev *asd;
 791         int ret;
 792
 793         asd = kzalloc(asd_struct_size, GFP_KERNEL);
 794         if (!asd)
 795                 return -ENOMEM;
 796
 797         asd->match_type = V4L2_ASYNC_MATCH_FWNODE;
 798         asd->match.fwnode =
 799                 fwnode_graph_get_remote_port_parent(endpoint);
 800         if (!asd->match.fwnode) {
 801                 dev_dbg(dev, "no remote endpoint found\n");
 802                 ret = -ENOTCONN;
 803                 goto out_err;
 804         }
 805
 806         ret = v4l2_fwnode_endpoint_alloc_parse(endpoint, &vep);
 807         if (ret) {
 808                 dev_warn(dev, "unable to parse V4L2 fwnode endpoint (%d)\n",
 809                          ret);
 810                 goto out_err;
 811         }
 812
 813         ret = parse_endpoint ? parse_endpoint(dev, &vep, asd) : 0;
 814         if (ret == -ENOTCONN)
 815                 dev_dbg(dev, "ignoring port@%u/endpoint@%u\n", vep.base.port,
 816                         vep.base.id);
 817         else if (ret < 0)
 818                 dev_warn(dev,
 819                          "driver could not parse port@%u/endpoint@%u (%d)\n",
 820                          vep.base.port, vep.base.id, ret);
 821         v4l2_fwnode_endpoint_free(&vep);
 822         if (ret < 0)
 823                 goto out_err;
 824
 825         ret = __v4l2_async_notifier_add_subdev(notifier, asd);
 826         if (ret < 0) {
 827                 /* not an error if asd already exists */
 828                 if (ret == -EEXIST)
 829                         ret = 0;
 830                 goto out_err;
 831         }
 832
 833         return 0;
 834
 835 out_err:
 836         fwnode_handle_put(asd->match.fwnode);
 837         kfree(asd);
 838
 839         return ret == -ENOTCONN ? 0 : ret;
 840 }
 841
 842 static int
 843 __v4l2_async_notifier_parse_fwnode_ep(struct device *dev,
 844                                       struct v4l2_async_notifier *notifier,
 845                                       size_t asd_struct_size,
 846                                       unsigned int port,
 847                                       bool has_port,
 848                                       parse_endpoint_func parse_endpoint)
 849 {
 850         struct fwnode_handle *fwnode;
 851         int ret = 0;
 852
 853         if (WARN_ON(asd_struct_size < sizeof(struct v4l2_async_subdev)))
 854                 return -EINVAL;
 855
 856         fwnode_graph_for_each_endpoint(dev_fwnode(dev), fwnode) {
 857                 struct fwnode_handle *dev_fwnode;
 858                 bool is_available;
 859
 860                 dev_fwnode = fwnode_graph_get_port_parent(fwnode);
 861                 is_available = fwnode_device_is_available(dev_fwnode);
 862                 fwnode_handle_put(dev_fwnode);
 863                 if (!is_available)
 864                         continue;
 865
 866                 if (has_port) {
 867                         struct fwnode_endpoint ep;
 868
 869                         ret = fwnode_graph_parse_endpoint(fwnode, &ep);
 870                         if (ret)
 871                                 break;
 872
 873                         if (ep.port != port)
 874                                 continue;
 875                 }
 876
 877                 ret = v4l2_async_notifier_fwnode_parse_endpoint(dev,
 878                                                                 notifier,
 879                                                                 fwnode,
 880                                                                 asd_struct_size,
 881                                                                 parse_endpoint);
 882                 if (ret < 0)
 883                         break;
 884         }
 885
 886         fwnode_handle_put(fwnode);
 887
 888         return ret;
 889 }
 890
 891 int
 892 v4l2_async_notifier_parse_fwnode_endpoints(struct device *dev,
 893                                            struct v4l2_async_notifier *notifier,
 894                                            size_t asd_struct_size,
 895                                            parse_endpoint_func parse_endpoint)
 896 {
 897         return __v4l2_async_notifier_parse_fwnode_ep(dev, notifier,
 898                                                      asd_struct_size, 0,
 899                                                      false, parse_endpoint);
 900 }
 901 EXPORT_SYMBOL_GPL(v4l2_async_notifier_parse_fwnode_endpoints);
 902
 903 /*
 904  * v4l2_fwnode_reference_parse - parse references for async sub-devices
 905  * @dev: the device node the properties of which are parsed for references
 906  * @notifier: the async notifier where the async subdevs will be added
 907  * @prop: the name of the property
 908  *
 909  * Return: 0 on success
 910  *         -ENOENT if no entries were found
 911  *         -ENOMEM if memory allocation failed
 912  *         -EINVAL if property parsing failed
 913  */
 914 static int v4l2_fwnode_reference_parse(struct device *dev,
 915                                        struct v4l2_async_notifier *notifier,
 916                                        const char *prop)
 917 {
 918         struct fwnode_reference_args args;
 919         unsigned int index;
 920         int ret;
 921
 922         for (index = 0;
 923              !(ret = fwnode_property_get_reference_args(dev_fwnode(dev),
 924                                                         prop, NULL, 0,
 925                                                         index, &args));
 926              index++)
 927                 fwnode_handle_put(args.fwnode);
 928
 929         if (!index)
 930                 return -ENOENT;
 931
 932         /*
 933          * Note that right now both -ENODATA and -ENOENT may signal
 934          * out-of-bounds access. Return the error in cases other than that.
 935          */
 936         if (ret != -ENOENT && ret != -ENODATA)
 937                 return ret;
 938
 939         for (index = 0;
 940              !fwnode_property_get_reference_args(dev_fwnode(dev), prop, NULL,
 941                                                  0, index, &args);
 942              index++) {
 943                 struct v4l2_async_subdev *asd;
 944
 945                 asd = v4l2_async_notifier_add_fwnode_subdev(notifier,
 946                                                             args.fwnode,
 947                                                             struct v4l2_async_subdev);
 948                 fwnode_handle_put(args.fwnode);
 949                 if (IS_ERR(asd)) {
 950                         /* not an error if asd already exists */
 951                         if (PTR_ERR(asd) == -EEXIST)
 952                                 continue;
 953
 954                         return PTR_ERR(asd);
 955                 }
 956         }
 957
 958         return 0;
 959 }
 960
 961 /*
 962  * v4l2_fwnode_reference_get_int_prop - parse a reference with integer
 963  *                                      arguments
 964  * @fwnode: fwnode to read @prop from
 965  * @notifier: notifier for @dev
 966  * @prop: the name of the property
 967  * @index: the index of the reference to get
 968  * @props: the array of integer property names
 969  * @nprops: the number of integer property names in @nprops
 970  *
 971  * First find an fwnode referred to by the reference at @index in @prop.
 972  *
 973  * Then under that fwnode, @nprops times, for each property in @props,
 974  * iteratively follow child nodes starting from fwnode such that they have the
 975  * property in @props array at the index of the child node distance from the
 976  * root node and the value of that property matching with the integer argument
 977  * of the reference, at the same index.
 978  *
 979  * The child fwnode reached at the end of the iteration is then returned to the
 980  * caller.
 981  *
 982  * The core reason for this is that you cannot refer to just any node in ACPI.
 983  * So to refer to an endpoint (easy in DT) you need to refer to a device, then
 984  * provide a list of (property name, property value) tuples where each tuple
 985  * uniquely identifies a child node. The first tuple identifies a child directly
 986  * underneath the device fwnode, the next tuple identifies a child node
 987  * underneath the fwnode identified by the previous tuple, etc. until you
 988  * reached the fwnode you need.
 989  *
 990  * THIS EXAMPLE EXISTS MERELY TO DOCUMENT THIS FUNCTION. DO NOT USE IT AS A
 991  * REFERENCE IN HOW ACPI TABLES SHOULD BE WRITTEN!! See documentation under
 992  * Documentation/firmware-guide/acpi/dsd/ instead and especially graph.txt,
 993  * data-node-references.txt and leds.txt .
 994  *
 995  *      Scope (\_SB.PCI0.I2C2)
 996  *      {
 997  *              Device (CAM0)
 998  *              {
 999  *                      Name (_DSD, Package () {
1000  *                              ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
1001  *                              Package () {
1002  *                                      Package () {
1003  *                                              "compatible",
1004  *                                              Package () { "nokia,smia" }
1005  *                                      },
1006  *                              },
1007  *                              ToUUID("dbb8e3e6-5886-4ba6-8795-1319f52a966b"),
1008  *                              Package () {
1009  *                                      Package () { "port0", "PRT0" },
1010  *                              }
1011  *                      })
1012  *                      Name (PRT0, Package() {
1013  *                              ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
1014  *                              Package () {
1015  *                                      Package () { "port", 0 },
1016  *                              },
1017  *                              ToUUID("dbb8e3e6-5886-4ba6-8795-1319f52a966b"),
1018  *                              Package () {
1019  *                                      Package () { "endpoint0", "EP00" },
1020  *                              }
1021  *                      })
1022  *                      Name (EP00, Package() {
1023  *                              ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
1024  *                              Package () {
1025  *                                      Package () { "endpoint", 0 },
1026  *                                      Package () {
1027  *                                              "remote-endpoint",
1028  *                                              Package() {
1029  *                                                      \_SB.PCI0.ISP, 4, 0
1030  *                                              }
1031  *                                      },
1032  *                              }
1033  *                      })
1034  *              }
1035  *      }
1036  *
1037  *      Scope (\_SB.PCI0)
1038  *      {
1039  *              Device (ISP)
1040  *              {
1041  *                      Name (_DSD, Package () {
1042  *                              ToUUID("dbb8e3e6-5886-4ba6-8795-1319f52a966b"),
1043  *                              Package () {
1044  *                                      Package () { "port4", "PRT4" },
1045  *                              }
1046  *                      })
1047  *
1048  *                      Name (PRT4, Package() {
1049  *                              ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
1050  *                              Package () {
1051  *                                      Package () { "port", 4 },
1052  *                              },
1053  *                              ToUUID("dbb8e3e6-5886-4ba6-8795-1319f52a966b"),
1054  *                              Package () {
1055  *                                      Package () { "endpoint0", "EP40" },
1056  *                              }
1057  *                      })
1058  *
1059  *                      Name (EP40, Package() {
1060  *                              ToUUID("daffd814-6eba-4d8c-8a91-bc9bbf4aa301"),
1061  *                              Package () {
1062  *                                      Package () { "endpoint", 0 },
1063  *                                      Package () {
1064  *                                              "remote-endpoint",
1065  *                                              Package () {
1066  *                                                      \_SB.PCI0.I2C2.CAM0,
1067  *                                                      0, 0
1068  *                                              }
1069  *                                      },
1070  *                              }
1071  *                      })
1072  *              }
1073  *      }
1074  *
1075  * From the EP40 node under ISP device, you could parse the graph remote
1076  * endpoint using v4l2_fwnode_reference_get_int_prop with these arguments:
1077  *
1078  *  @fwnode: fwnode referring to EP40 under ISP.
1079  *  @prop: "remote-endpoint"
1080  *  @index: 0
1081  *  @props: "port", "endpoint"
1082  *  @nprops: 2
1083  *
1084  * And you'd get back fwnode referring to EP00 under CAM0.
1085  *
1086  * The same works the other way around: if you use EP00 under CAM0 as the
1087  * fwnode, you'll get fwnode referring to EP40 under ISP.
1088  *
1089  * The same example in DT syntax would look like this:
1090  *
1091  * cam: cam0 {
1092  *      compatible = "nokia,smia";
1093  *
1094  *      port {
1095  *              port = <0>;
1096  *              endpoint {
1097  *                      endpoint = <0>;
1098  *                      remote-endpoint = <&isp 4 0>;
1099  *              };
1100  *      };
1101  * };
1102  *
1103  * isp: isp {
1104  *      ports {
1105  *              port@4 {
1106  *                      port = <4>;
1107  *                      endpoint {
1108  *                              endpoint = <0>;
1109  *                              remote-endpoint = <&cam 0 0>;
1110  *                      };
1111  *              };
1112  *      };
1113  * };
1114  *
1115  * Return: 0 on success
1116  *         -ENOENT if no entries (or the property itself) were found
1117  *         -EINVAL if property parsing otherwise failed
1118  *         -ENOMEM if memory allocation failed
1119  */
1120 static struct fwnode_handle *
1121 v4l2_fwnode_reference_get_int_prop(struct fwnode_handle *fwnode,
1122                                    const char *prop,
1123                                    unsigned int index,
1124                                    const char * const *props,
1125                                    unsigned int nprops)
1126 {
1127         struct fwnode_reference_args fwnode_args;
1128         u64 *args = fwnode_args.args;
1129         struct fwnode_handle *child;
1130         int ret;
1131
1132         /*
1133          * Obtain remote fwnode as well as the integer arguments.
1134          *
1135          * Note that right now both -ENODATA and -ENOENT may signal
1136          * out-of-bounds access. Return -ENOENT in that case.
1137          */
1138         ret = fwnode_property_get_reference_args(fwnode, prop, NULL, nprops,
1139                                                  index, &fwnode_args);
1140         if (ret)
1141                 return ERR_PTR(ret == -ENODATA ? -ENOENT : ret);
1142
1143         /*
1144          * Find a node in the tree under the referred fwnode corresponding to
1145          * the integer arguments.
1146          */
1147         fwnode = fwnode_args.fwnode;
1148         while (nprops--) {
1149                 u32 val;
1150
1151                 /* Loop over all child nodes under fwnode. */
1152                 fwnode_for_each_child_node(fwnode, child) {
1153                         if (fwnode_property_read_u32(child, *props, &val))
1154                                 continue;
1155
1156                         /* Found property, see if its value matches. */
1157                         if (val == *args)
1158                                 break;
1159                 }
1160
1161                 fwnode_handle_put(fwnode);
1162
1163                 /* No property found; return an error here. */
1164                 if (!child) {
1165                         fwnode = ERR_PTR(-ENOENT);
1166                         break;
1167                 }
1168
1169                 props++;
1170                 args++;
1171                 fwnode = child;
1172         }
1173
1174         return fwnode;
1175 }
1176
1177 struct v4l2_fwnode_int_props {
1178         const char *name;
1179         const char * const *props;
1180         unsigned int nprops;
1181 };
1182
1183 /*
1184  * v4l2_fwnode_reference_parse_int_props - parse references for async
1185  *                                         sub-devices
1186  * @dev: struct device pointer
1187  * @notifier: notifier for @dev
1188  * @prop: the name of the property
1189  * @props: the array of integer property names
1190  * @nprops: the number of integer properties
1191  *
1192  * Use v4l2_fwnode_reference_get_int_prop to find fwnodes through reference in
1193  * property @prop with integer arguments with child nodes matching in properties
1194  * @props. Then, set up V4L2 async sub-devices for those fwnodes in the notifier
1195  * accordingly.
1196  *
1197  * While it is technically possible to use this function on DT, it is only
1198  * meaningful on ACPI. On Device tree you can refer to any node in the tree but
1199  * on ACPI the references are limited to devices.
1200  *
1201  * Return: 0 on success
1202  *         -ENOENT if no entries (or the property itself) were found
1203  *         -EINVAL if property parsing otherwisefailed
1204  *         -ENOMEM if memory allocation failed
1205  */
1206 static int
1207 v4l2_fwnode_reference_parse_int_props(struct device *dev,
1208                                       struct v4l2_async_notifier *notifier,
1209                                       const struct v4l2_fwnode_int_props *p)
1210 {
1211         struct fwnode_handle *fwnode;
1212         unsigned int index;
1213         int ret;
1214         const char *prop = p->name;
1215         const char * const *props = p->props;
1216         unsigned int nprops = p->nprops;
1217
1218         index = 0;
1219         do {
1220                 fwnode = v4l2_fwnode_reference_get_int_prop(dev_fwnode(dev),
1221                                                             prop, index,
1222                                                             props, nprops);
1223                 if (IS_ERR(fwnode)) {
1224                         /*
1225                          * Note that right now both -ENODATA and -ENOENT may
1226                          * signal out-of-bounds access. Return the error in
1227                          * cases other than that.
1228                          */
1229                         if (PTR_ERR(fwnode) != -ENOENT &&
1230                             PTR_ERR(fwnode) != -ENODATA)
1231                                 return PTR_ERR(fwnode);
1232                         break;
1233                 }
1234                 fwnode_handle_put(fwnode);
1235                 index++;
1236         } while (1);
1237
1238         for (index = 0;
1239              !IS_ERR((fwnode = v4l2_fwnode_reference_get_int_prop(dev_fwnode(dev),
1240                                                                   prop, index,
1241                                                                   props,
1242                                                                   nprops)));
1243              index++) {
1244                 struct v4l2_async_subdev *asd;
1245
1246                 asd = v4l2_async_notifier_add_fwnode_subdev(notifier, fwnode,
1247                                                             struct v4l2_async_subdev);
1248                 fwnode_handle_put(fwnode);
1249                 if (IS_ERR(asd)) {
1250                         ret = PTR_ERR(asd);
1251                         /* not an error if asd already exists */
1252                         if (ret == -EEXIST)
1253                                 continue;
1254
1255                         return PTR_ERR(asd);
1256                 }
1257         }
1258
1259         return !fwnode || PTR_ERR(fwnode) == -ENOENT ? 0 : PTR_ERR(fwnode);
1260 }
1261
1262 /**
1263  * v4l2_async_notifier_parse_fwnode_sensor - parse common references on
1264  *                                           sensors for async sub-devices
1265  * @dev: the device node the properties of which are parsed for references
1266  * @notifier: the async notifier where the async subdevs will be added
1267  *
1268  * Parse common sensor properties for remote devices related to the
1269  * sensor and set up async sub-devices for them.
1270  *
1271  * Any notifier populated using this function must be released with a call to
1272  * v4l2_async_notifier_release() after it has been unregistered and the async
1273  * sub-devices are no longer in use, even in the case the function returned an
1274  * error.
1275  *
1276  * Return: 0 on success
1277  *         -ENOMEM if memory allocation failed
1278  *         -EINVAL if property parsing failed
1279  */
1280 static int
1281 v4l2_async_notifier_parse_fwnode_sensor(struct device *dev,
1282                                         struct v4l2_async_notifier *notifier)
1283 {
1284         static const char * const led_props[] = { "led" };
1285         static const struct v4l2_fwnode_int_props props[] = {
1286                 { "flash-leds", led_props, ARRAY_SIZE(led_props) },
1287                 { "lens-focus", NULL, 0 },
1288         };
1289         unsigned int i;
1290
1291         for (i = 0; i < ARRAY_SIZE(props); i++) {
1292                 int ret;
1293
1294                 if (props[i].props && is_acpi_node(dev_fwnode(dev)))
1295                         ret = v4l2_fwnode_reference_parse_int_props(dev,
1296                                                                     notifier,
1297                                                                     &props[i]);
1298                 else
1299                         ret = v4l2_fwnode_reference_parse(dev, notifier,
1300                                                           props[i].name);
1301                 if (ret && ret != -ENOENT) {
1302                         dev_warn(dev, "parsing property \"%s\" failed (%d)\n",
1303                                  props[i].name, ret);
1304                         return ret;
1305                 }
1306         }
1307
1308         return 0;
1309 }
1310
1311 int v4l2_async_register_subdev_sensor(struct v4l2_subdev *sd)
1312 {
1313         struct v4l2_async_notifier *notifier;
1314         int ret;
1315
1316         if (WARN_ON(!sd->dev))
1317                 return -ENODEV;
1318
1319         notifier = kzalloc(sizeof(*notifier), GFP_KERNEL);
1320         if (!notifier)
1321                 return -ENOMEM;
1322
1323         v4l2_async_notifier_init(notifier);
1324
1325         ret = v4l2_async_notifier_parse_fwnode_sensor(sd->dev, notifier);
1326         if (ret < 0)
1327                 goto out_cleanup;
1328
1329         ret = v4l2_async_subdev_notifier_register(sd, notifier);
1330         if (ret < 0)
1331                 goto out_cleanup;
1332
1333         ret = v4l2_async_register_subdev(sd);
1334         if (ret < 0)
1335                 goto out_unregister;
1336
1337         sd->subdev_notifier = notifier;
1338
1339         return 0;
1340
1341 out_unregister:
1342         v4l2_async_notifier_unregister(notifier);
1343
1344 out_cleanup:
1345         v4l2_async_notifier_cleanup(notifier);
1346         kfree(notifier);
1347
1348         return ret;
1349 }
1350 EXPORT_SYMBOL_GPL(v4l2_async_register_subdev_sensor);
1351
1352 MODULE_LICENSE("GPL");
1353 MODULE_AUTHOR("Sakari Ailus <sakari.ailus@linux.intel.com>");
1354 MODULE_AUTHOR("Sylwester Nawrocki <s.nawrocki@samsung.com>");
1355 MODULE_AUTHOR("Guennadi Liakhovetski <g.liakhovetski@gmx.de>");