drivers/media/v4l2-core/v4l2-flash-led-class.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * V4L2 flash LED sub-device registration helpers.
   4  *
   5  *      Copyright (C) 2015 Samsung Electronics Co., Ltd
   6  *      Author: Jacek Anaszewski <j.anaszewski@samsung.com>
   7  */
   8
   9 #include <linux/led-class-flash.h>
  10 #include <linux/module.h>
  11 #include <linux/mutex.h>
  12 #include <linux/property.h>
  13 #include <linux/slab.h>
  14 #include <linux/types.h>
  15 #include <media/v4l2-flash-led-class.h>
  16
  17 #define has_flash_op(v4l2_flash, op)                            \
  18         (v4l2_flash && v4l2_flash->ops && v4l2_flash->ops->op)
  19
  20 #define call_flash_op(v4l2_flash, op, arg)                      \
  21                 (has_flash_op(v4l2_flash, op) ?                 \
  22                         v4l2_flash->ops->op(v4l2_flash, arg) :  \
  23                         -EINVAL)
  24
  25 enum ctrl_init_data_id {
  26         LED_MODE,
  27         TORCH_INTENSITY,
  28         FLASH_INTENSITY,
  29         INDICATOR_INTENSITY,
  30         FLASH_TIMEOUT,
  31         STROBE_SOURCE,
  32         /*
  33          * Only above values are applicable to
  34          * the 'ctrls' array in the struct v4l2_flash.
  35          */
  36         FLASH_STROBE,
  37         STROBE_STOP,
  38         STROBE_STATUS,
  39         FLASH_FAULT,
  40         NUM_FLASH_CTRLS,
  41 };
  42
  43 static enum led_brightness __intensity_to_led_brightness(
  44                                         struct v4l2_ctrl *ctrl, s32 intensity)
  45 {
  46         intensity -= ctrl->minimum;
  47         intensity /= (u32) ctrl->step;
  48
  49         /*
  50          * Indicator LEDs, unlike torch LEDs, are turned on/off basing on
  51          * the state of V4L2_CID_FLASH_INDICATOR_INTENSITY control only.
  52          * Therefore it must be possible to set it to 0 level which in
  53          * the LED subsystem reflects LED_OFF state.
  54          */
  55         if (ctrl->minimum)
  56                 ++intensity;
  57
  58         return intensity;
  59 }
  60
  61 static s32 __led_brightness_to_intensity(struct v4l2_ctrl *ctrl,
  62                                          enum led_brightness brightness)
  63 {
  64         /*
  65          * Indicator LEDs, unlike torch LEDs, are turned on/off basing on
  66          * the state of V4L2_CID_FLASH_INDICATOR_INTENSITY control only.
  67          * Do not decrement brightness read from the LED subsystem for
  68          * indicator LED as it may equal 0. For torch LEDs this function
  69          * is called only when V4L2_FLASH_LED_MODE_TORCH is set and the
  70          * brightness read is guaranteed to be greater than 0. In the mode
  71          * V4L2_FLASH_LED_MODE_NONE the cached torch intensity value is used.
  72          */
  73         if (ctrl->id != V4L2_CID_FLASH_INDICATOR_INTENSITY)
  74                 --brightness;
  75
  76         return (brightness * ctrl->step) + ctrl->minimum;
  77 }
  78
  79 static int v4l2_flash_set_led_brightness(struct v4l2_flash *v4l2_flash,
  80                                          struct v4l2_ctrl *ctrl)
  81 {
  82         struct v4l2_ctrl **ctrls = v4l2_flash->ctrls;
  83         struct led_classdev *led_cdev;
  84         enum led_brightness brightness;
  85
  86         if (has_flash_op(v4l2_flash, intensity_to_led_brightness))
  87                 brightness = call_flash_op(v4l2_flash,
  88                                         intensity_to_led_brightness,
  89                                         ctrl->val);
  90         else
  91                 brightness = __intensity_to_led_brightness(ctrl, ctrl->val);
  92         /*
  93          * In case a LED Flash class driver provides ops for custom
  94          * brightness <-> intensity conversion, it also must have defined
  95          * related v4l2 control step == 1. In such a case a backward conversion
  96          * from led brightness to v4l2 intensity is required to find out the
  97          * aligned intensity value.
  98          */
  99         if (has_flash_op(v4l2_flash, led_brightness_to_intensity))
 100                 ctrl->val = call_flash_op(v4l2_flash,
 101                                         led_brightness_to_intensity,
 102                                         brightness);
 103
 104         if (ctrl == ctrls[TORCH_INTENSITY]) {
 105                 if (ctrls[LED_MODE]->val != V4L2_FLASH_LED_MODE_TORCH)
 106                         return 0;
 107
 108                 if (WARN_ON_ONCE(!v4l2_flash->fled_cdev))
 109                         return -EINVAL;
 110
 111                 led_cdev = &v4l2_flash->fled_cdev->led_cdev;
 112         } else {
 113                 if (WARN_ON_ONCE(!v4l2_flash->iled_cdev))
 114                         return -EINVAL;
 115
 116                 led_cdev = v4l2_flash->iled_cdev;
 117         }
 118
 119         return led_set_brightness_sync(led_cdev, brightness);
 120 }
 121
 122 static int v4l2_flash_update_led_brightness(struct v4l2_flash *v4l2_flash,
 123                                         struct v4l2_ctrl *ctrl)
 124 {
 125         struct v4l2_ctrl **ctrls = v4l2_flash->ctrls;
 126         struct led_classdev *led_cdev;
 127         int ret;
 128
 129         if (ctrl == ctrls[TORCH_INTENSITY]) {
 130                 /*
 131                  * Update torch brightness only if in TORCH_MODE. In other modes
 132                  * torch led is turned off, which would spuriously inform the
 133                  * user space that V4L2_CID_FLASH_TORCH_INTENSITY control value
 134                  * has changed to 0.
 135                  */
 136                 if (ctrls[LED_MODE]->val != V4L2_FLASH_LED_MODE_TORCH)
 137                         return 0;
 138
 139                 if (WARN_ON_ONCE(!v4l2_flash->fled_cdev))
 140                         return -EINVAL;
 141
 142                 led_cdev = &v4l2_flash->fled_cdev->led_cdev;
 143         } else {
 144                 if (WARN_ON_ONCE(!v4l2_flash->iled_cdev))
 145                         return -EINVAL;
 146
 147                 led_cdev = v4l2_flash->iled_cdev;
 148         }
 149
 150         ret = led_update_brightness(led_cdev);
 151         if (ret < 0)
 152                 return ret;
 153
 154         if (has_flash_op(v4l2_flash, led_brightness_to_intensity))
 155                 ctrl->val = call_flash_op(v4l2_flash,
 156                                                 led_brightness_to_intensity,
 157                                                 led_cdev->brightness);
 158         else
 159                 ctrl->val = __led_brightness_to_intensity(ctrl,
 160                                                 led_cdev->brightness);
 161
 162         return 0;
 163 }
 164
 165 static int v4l2_flash_g_volatile_ctrl(struct v4l2_ctrl *c)
 166 {
 167         struct v4l2_flash *v4l2_flash = v4l2_ctrl_to_v4l2_flash(c);
 168         struct led_classdev_flash *fled_cdev = v4l2_flash->fled_cdev;
 169         bool is_strobing;
 170         int ret;
 171
 172         switch (c->id) {
 173         case V4L2_CID_FLASH_TORCH_INTENSITY:
 174         case V4L2_CID_FLASH_INDICATOR_INTENSITY:
 175                 return v4l2_flash_update_led_brightness(v4l2_flash, c);
 176         }
 177
 178         if (!fled_cdev)
 179                 return -EINVAL;
 180
 181         switch (c->id) {
 182         case V4L2_CID_FLASH_INTENSITY:
 183                 ret = led_update_flash_brightness(fled_cdev);
 184                 if (ret < 0)
 185                         return ret;
 186                 /*
 187                  * No conversion is needed as LED Flash class also uses
 188                  * microamperes for flash intensity units.
 189                  */
 190                 c->val = fled_cdev->brightness.val;
 191                 return 0;
 192         case V4L2_CID_FLASH_STROBE_STATUS:
 193                 ret = led_get_flash_strobe(fled_cdev, &is_strobing);
 194                 if (ret < 0)
 195                         return ret;
 196                 c->val = is_strobing;
 197                 return 0;
 198         case V4L2_CID_FLASH_FAULT:
 199                 /* LED faults map directly to V4L2 flash faults */
 200                 return led_get_flash_fault(fled_cdev, &c->val);
 201         default:
 202                 return -EINVAL;
 203         }
 204 }
 205
 206 static bool __software_strobe_mode_inactive(struct v4l2_ctrl **ctrls)
 207 {
 208         return ((ctrls[LED_MODE]->val != V4L2_FLASH_LED_MODE_FLASH) ||
 209                 (ctrls[STROBE_SOURCE] && (ctrls[STROBE_SOURCE]->val !=
 210                                 V4L2_FLASH_STROBE_SOURCE_SOFTWARE)));
 211 }
 212
 213 static int v4l2_flash_s_ctrl(struct v4l2_ctrl *c)
 214 {
 215         struct v4l2_flash *v4l2_flash = v4l2_ctrl_to_v4l2_flash(c);
 216         struct led_classdev_flash *fled_cdev = v4l2_flash->fled_cdev;
 217         struct led_classdev *led_cdev;
 218         struct v4l2_ctrl **ctrls = v4l2_flash->ctrls;
 219         bool external_strobe;
 220         int ret = 0;
 221
 222         switch (c->id) {
 223         case V4L2_CID_FLASH_TORCH_INTENSITY:
 224         case V4L2_CID_FLASH_INDICATOR_INTENSITY:
 225                 return v4l2_flash_set_led_brightness(v4l2_flash, c);
 226         }
 227
 228         if (!fled_cdev)
 229                 return -EINVAL;
 230
 231         led_cdev = &fled_cdev->led_cdev;
 232
 233         switch (c->id) {
 234         case V4L2_CID_FLASH_LED_MODE:
 235                 switch (c->val) {
 236                 case V4L2_FLASH_LED_MODE_NONE:
 237                         led_set_brightness_sync(led_cdev, LED_OFF);
 238                         return led_set_flash_strobe(fled_cdev, false);
 239                 case V4L2_FLASH_LED_MODE_FLASH:
 240                         /* Turn the torch LED off */
 241                         led_set_brightness_sync(led_cdev, LED_OFF);
 242                         if (ctrls[STROBE_SOURCE]) {
 243                                 external_strobe = (ctrls[STROBE_SOURCE]->val ==
 244                                         V4L2_FLASH_STROBE_SOURCE_EXTERNAL);
 245
 246                                 ret = call_flash_op(v4l2_flash,
 247                                                 external_strobe_set,
 248                                                 external_strobe);
 249                         }
 250                         return ret;
 251                 case V4L2_FLASH_LED_MODE_TORCH:
 252                         if (ctrls[STROBE_SOURCE]) {
 253                                 ret = call_flash_op(v4l2_flash,
 254                                                 external_strobe_set,
 255                                                 false);
 256                                 if (ret < 0)
 257                                         return ret;
 258                         }
 259                         /* Stop flash strobing */
 260                         ret = led_set_flash_strobe(fled_cdev, false);
 261                         if (ret < 0)
 262                                 return ret;
 263
 264                         return v4l2_flash_set_led_brightness(v4l2_flash,
 265                                                              ctrls[TORCH_INTENSITY]);
 266                 }
 267                 break;
 268         case V4L2_CID_FLASH_STROBE_SOURCE:
 269                 external_strobe = (c->val == V4L2_FLASH_STROBE_SOURCE_EXTERNAL);
 270                 /*
 271                  * For some hardware arrangements setting strobe source may
 272                  * affect torch mode. Therefore, if not in the flash mode,
 273                  * cache only this setting. It will be applied upon switching
 274                  * to flash mode.
 275                  */
 276                 if (ctrls[LED_MODE]->val != V4L2_FLASH_LED_MODE_FLASH)
 277                         return 0;
 278
 279                 return call_flash_op(v4l2_flash, external_strobe_set,
 280                                         external_strobe);
 281         case V4L2_CID_FLASH_STROBE:
 282                 if (__software_strobe_mode_inactive(ctrls))
 283                         return -EBUSY;
 284                 return led_set_flash_strobe(fled_cdev, true);
 285         case V4L2_CID_FLASH_STROBE_STOP:
 286                 if (__software_strobe_mode_inactive(ctrls))
 287                         return -EBUSY;
 288                 return led_set_flash_strobe(fled_cdev, false);
 289         case V4L2_CID_FLASH_TIMEOUT:
 290                 /*
 291                  * No conversion is needed as LED Flash class also uses
 292                  * microseconds for flash timeout units.
 293                  */
 294                 return led_set_flash_timeout(fled_cdev, c->val);
 295         case V4L2_CID_FLASH_INTENSITY:
 296                 /*
 297                  * No conversion is needed as LED Flash class also uses
 298                  * microamperes for flash intensity units.
 299                  */
 300                 return led_set_flash_brightness(fled_cdev, c->val);
 301         }
 302
 303         return -EINVAL;
 304 }
 305
 306 static const struct v4l2_ctrl_ops v4l2_flash_ctrl_ops = {
 307         .g_volatile_ctrl = v4l2_flash_g_volatile_ctrl,
 308         .s_ctrl = v4l2_flash_s_ctrl,
 309 };
 310
 311 static void __lfs_to_v4l2_ctrl_config(struct led_flash_setting *s,
 312                                 struct v4l2_ctrl_config *c)
 313 {
 314         c->min = s->min;
 315         c->max = s->max;
 316         c->step = s->step;
 317         c->def = s->val;
 318 }
 319
 320 static void __fill_ctrl_init_data(struct v4l2_flash *v4l2_flash,
 321                           struct v4l2_flash_config *flash_cfg,
 322                           struct v4l2_flash_ctrl_data *ctrl_init_data)
 323 {
 324         struct led_classdev_flash *fled_cdev = v4l2_flash->fled_cdev;
 325         struct led_classdev *led_cdev = fled_cdev ? &fled_cdev->led_cdev : NULL;
 326         struct v4l2_ctrl_config *ctrl_cfg;
 327         u32 mask;
 328
 329         /* Init INDICATOR_INTENSITY ctrl data */
 330         if (v4l2_flash->iled_cdev) {
 331                 ctrl_init_data[INDICATOR_INTENSITY].cid =
 332                                         V4L2_CID_FLASH_INDICATOR_INTENSITY;
 333                 ctrl_cfg = &ctrl_init_data[INDICATOR_INTENSITY].config;
 334                 __lfs_to_v4l2_ctrl_config(&flash_cfg->intensity,
 335                                           ctrl_cfg);
 336                 ctrl_cfg->id = V4L2_CID_FLASH_INDICATOR_INTENSITY;
 337                 ctrl_cfg->min = 0;
 338                 ctrl_cfg->flags = V4L2_CTRL_FLAG_VOLATILE |
 339                                   V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
 340         }
 341
 342         if (!led_cdev || WARN_ON(!(led_cdev->flags & LED_DEV_CAP_FLASH)))
 343                 return;
 344
 345         /* Init FLASH_FAULT ctrl data */
 346         if (flash_cfg->flash_faults) {
 347                 ctrl_init_data[FLASH_FAULT].cid = V4L2_CID_FLASH_FAULT;
 348                 ctrl_cfg = &ctrl_init_data[FLASH_FAULT].config;
 349                 ctrl_cfg->id = V4L2_CID_FLASH_FAULT;
 350                 ctrl_cfg->max = flash_cfg->flash_faults;
 351                 ctrl_cfg->flags = V4L2_CTRL_FLAG_VOLATILE |
 352                                   V4L2_CTRL_FLAG_READ_ONLY;
 353         }
 354
 355         /* Init FLASH_LED_MODE ctrl data */
 356         mask = 1 << V4L2_FLASH_LED_MODE_NONE |
 357                1 << V4L2_FLASH_LED_MODE_TORCH;
 358         if (led_cdev->flags & LED_DEV_CAP_FLASH)
 359                 mask |= 1 << V4L2_FLASH_LED_MODE_FLASH;
 360
 361         ctrl_init_data[LED_MODE].cid = V4L2_CID_FLASH_LED_MODE;
 362         ctrl_cfg = &ctrl_init_data[LED_MODE].config;
 363         ctrl_cfg->id = V4L2_CID_FLASH_LED_MODE;
 364         ctrl_cfg->max = V4L2_FLASH_LED_MODE_TORCH;
 365         ctrl_cfg->menu_skip_mask = ~mask;
 366         ctrl_cfg->def = V4L2_FLASH_LED_MODE_NONE;
 367         ctrl_cfg->flags = 0;
 368
 369         /* Init TORCH_INTENSITY ctrl data */
 370         ctrl_init_data[TORCH_INTENSITY].cid = V4L2_CID_FLASH_TORCH_INTENSITY;
 371         ctrl_cfg = &ctrl_init_data[TORCH_INTENSITY].config;
 372         __lfs_to_v4l2_ctrl_config(&flash_cfg->intensity, ctrl_cfg);
 373         ctrl_cfg->id = V4L2_CID_FLASH_TORCH_INTENSITY;
 374         ctrl_cfg->flags = V4L2_CTRL_FLAG_VOLATILE |
 375                           V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
 376
 377         /* Init FLASH_STROBE ctrl data */
 378         ctrl_init_data[FLASH_STROBE].cid = V4L2_CID_FLASH_STROBE;
 379         ctrl_cfg = &ctrl_init_data[FLASH_STROBE].config;
 380         ctrl_cfg->id = V4L2_CID_FLASH_STROBE;
 381
 382         /* Init STROBE_STOP ctrl data */
 383         ctrl_init_data[STROBE_STOP].cid = V4L2_CID_FLASH_STROBE_STOP;
 384         ctrl_cfg = &ctrl_init_data[STROBE_STOP].config;
 385         ctrl_cfg->id = V4L2_CID_FLASH_STROBE_STOP;
 386
 387         /* Init FLASH_STROBE_SOURCE ctrl data */
 388         if (flash_cfg->has_external_strobe) {
 389                 mask = (1 << V4L2_FLASH_STROBE_SOURCE_SOFTWARE) |
 390                        (1 << V4L2_FLASH_STROBE_SOURCE_EXTERNAL);
 391                 ctrl_init_data[STROBE_SOURCE].cid =
 392                                         V4L2_CID_FLASH_STROBE_SOURCE;
 393                 ctrl_cfg = &ctrl_init_data[STROBE_SOURCE].config;
 394                 ctrl_cfg->id = V4L2_CID_FLASH_STROBE_SOURCE;
 395                 ctrl_cfg->max = V4L2_FLASH_STROBE_SOURCE_EXTERNAL;
 396                 ctrl_cfg->menu_skip_mask = ~mask;
 397                 ctrl_cfg->def = V4L2_FLASH_STROBE_SOURCE_SOFTWARE;
 398         }
 399
 400         /* Init STROBE_STATUS ctrl data */
 401         if (has_flash_op(fled_cdev, strobe_get)) {
 402                 ctrl_init_data[STROBE_STATUS].cid =
 403                                         V4L2_CID_FLASH_STROBE_STATUS;
 404                 ctrl_cfg = &ctrl_init_data[STROBE_STATUS].config;
 405                 ctrl_cfg->id = V4L2_CID_FLASH_STROBE_STATUS;
 406                 ctrl_cfg->flags = V4L2_CTRL_FLAG_VOLATILE |
 407                                   V4L2_CTRL_FLAG_READ_ONLY;
 408         }
 409
 410         /* Init FLASH_TIMEOUT ctrl data */
 411         if (has_flash_op(fled_cdev, timeout_set)) {
 412                 ctrl_init_data[FLASH_TIMEOUT].cid = V4L2_CID_FLASH_TIMEOUT;
 413                 ctrl_cfg = &ctrl_init_data[FLASH_TIMEOUT].config;
 414                 __lfs_to_v4l2_ctrl_config(&fled_cdev->timeout, ctrl_cfg);
 415                 ctrl_cfg->id = V4L2_CID_FLASH_TIMEOUT;
 416         }
 417
 418         /* Init FLASH_INTENSITY ctrl data */
 419         if (has_flash_op(fled_cdev, flash_brightness_set)) {
 420                 ctrl_init_data[FLASH_INTENSITY].cid = V4L2_CID_FLASH_INTENSITY;
 421                 ctrl_cfg = &ctrl_init_data[FLASH_INTENSITY].config;
 422                 __lfs_to_v4l2_ctrl_config(&fled_cdev->brightness, ctrl_cfg);
 423                 ctrl_cfg->id = V4L2_CID_FLASH_INTENSITY;
 424                 ctrl_cfg->flags = V4L2_CTRL_FLAG_VOLATILE |
 425                                   V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;
 426         }
 427 }
 428
 429 static int v4l2_flash_init_controls(struct v4l2_flash *v4l2_flash,
 430                                 struct v4l2_flash_config *flash_cfg)
 431
 432 {
 433         struct v4l2_flash_ctrl_data *ctrl_init_data;
 434         struct v4l2_ctrl *ctrl;
 435         struct v4l2_ctrl_config *ctrl_cfg;
 436         int i, ret, num_ctrls = 0;
 437
 438         v4l2_flash->ctrls = devm_kcalloc(v4l2_flash->sd.dev,
 439                                         STROBE_SOURCE + 1,
 440                                         sizeof(*v4l2_flash->ctrls),
 441                                         GFP_KERNEL);
 442         if (!v4l2_flash->ctrls)
 443                 return -ENOMEM;
 444
 445         /* allocate memory dynamically so as not to exceed stack frame size */
 446         ctrl_init_data = kcalloc(NUM_FLASH_CTRLS, sizeof(*ctrl_init_data),
 447                                         GFP_KERNEL);
 448         if (!ctrl_init_data)
 449                 return -ENOMEM;
 450
 451         __fill_ctrl_init_data(v4l2_flash, flash_cfg, ctrl_init_data);
 452
 453         for (i = 0; i < NUM_FLASH_CTRLS; ++i)
 454                 if (ctrl_init_data[i].cid)
 455                         ++num_ctrls;
 456
 457         v4l2_ctrl_handler_init(&v4l2_flash->hdl, num_ctrls);
 458
 459         for (i = 0; i < NUM_FLASH_CTRLS; ++i) {
 460                 ctrl_cfg = &ctrl_init_data[i].config;
 461                 if (!ctrl_init_data[i].cid)
 462                         continue;
 463
 464                 if (ctrl_cfg->id == V4L2_CID_FLASH_LED_MODE ||
 465                     ctrl_cfg->id == V4L2_CID_FLASH_STROBE_SOURCE)
 466                         ctrl = v4l2_ctrl_new_std_menu(&v4l2_flash->hdl,
 467                                                 &v4l2_flash_ctrl_ops,
 468                                                 ctrl_cfg->id,
 469                                                 ctrl_cfg->max,
 470                                                 ctrl_cfg->menu_skip_mask,
 471                                                 ctrl_cfg->def);
 472                 else
 473                         ctrl = v4l2_ctrl_new_std(&v4l2_flash->hdl,
 474                                                 &v4l2_flash_ctrl_ops,
 475                                                 ctrl_cfg->id,
 476                                                 ctrl_cfg->min,
 477                                                 ctrl_cfg->max,
 478                                                 ctrl_cfg->step,
 479                                                 ctrl_cfg->def);
 480
 481                 if (ctrl)
 482                         ctrl->flags |= ctrl_cfg->flags;
 483
 484                 if (i <= STROBE_SOURCE)
 485                         v4l2_flash->ctrls[i] = ctrl;
 486         }
 487
 488         kfree(ctrl_init_data);
 489
 490         if (v4l2_flash->hdl.error) {
 491                 ret = v4l2_flash->hdl.error;
 492                 goto error_free_handler;
 493         }
 494
 495         v4l2_ctrl_handler_setup(&v4l2_flash->hdl);
 496
 497         v4l2_flash->sd.ctrl_handler = &v4l2_flash->hdl;
 498
 499         return 0;
 500
 501 error_free_handler:
 502         v4l2_ctrl_handler_free(&v4l2_flash->hdl);
 503         return ret;
 504 }
 505
 506 static int __sync_device_with_v4l2_controls(struct v4l2_flash *v4l2_flash)
 507 {
 508         struct led_classdev_flash *fled_cdev = v4l2_flash->fled_cdev;
 509         struct v4l2_ctrl **ctrls = v4l2_flash->ctrls;
 510         int ret = 0;
 511
 512         if (ctrls[TORCH_INTENSITY]) {
 513                 ret = v4l2_flash_set_led_brightness(v4l2_flash,
 514                                                     ctrls[TORCH_INTENSITY]);
 515                 if (ret < 0)
 516                         return ret;
 517         }
 518
 519         if (ctrls[INDICATOR_INTENSITY]) {
 520                 ret = v4l2_flash_set_led_brightness(v4l2_flash,
 521                                                     ctrls[INDICATOR_INTENSITY]);
 522                 if (ret < 0)
 523                         return ret;
 524         }
 525
 526         if (ctrls[FLASH_TIMEOUT]) {
 527                 if (WARN_ON_ONCE(!fled_cdev))
 528                         return -EINVAL;
 529
 530                 ret = led_set_flash_timeout(fled_cdev,
 531                                         ctrls[FLASH_TIMEOUT]->val);
 532                 if (ret < 0)
 533                         return ret;
 534         }
 535
 536         if (ctrls[FLASH_INTENSITY]) {
 537                 if (WARN_ON_ONCE(!fled_cdev))
 538                         return -EINVAL;
 539
 540                 ret = led_set_flash_brightness(fled_cdev,
 541                                         ctrls[FLASH_INTENSITY]->val);
 542                 if (ret < 0)
 543                         return ret;
 544         }
 545
 546         /*
 547          * For some hardware arrangements setting strobe source may affect
 548          * torch mode. Synchronize strobe source setting only if not in torch
 549          * mode. For torch mode case it will get synchronized upon switching
 550          * to flash mode.
 551          */
 552         if (ctrls[STROBE_SOURCE] &&
 553             ctrls[LED_MODE]->val != V4L2_FLASH_LED_MODE_TORCH)
 554                 ret = call_flash_op(v4l2_flash, external_strobe_set,
 555                                         ctrls[STROBE_SOURCE]->val);
 556
 557         return ret;
 558 }
 559
 560 /*
 561  * V4L2 subdev internal operations
 562  */
 563
 564 static int v4l2_flash_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
 565 {
 566         struct v4l2_flash *v4l2_flash = v4l2_subdev_to_v4l2_flash(sd);
 567         struct led_classdev_flash *fled_cdev = v4l2_flash->fled_cdev;
 568         struct led_classdev *led_cdev = fled_cdev ? &fled_cdev->led_cdev : NULL;
 569         struct led_classdev *led_cdev_ind = v4l2_flash->iled_cdev;
 570         int ret = 0;
 571
 572         if (!v4l2_fh_is_singular(&fh->vfh))
 573                 return 0;
 574
 575         if (led_cdev) {
 576                 mutex_lock(&led_cdev->led_access);
 577
 578                 led_sysfs_disable(led_cdev);
 579                 led_trigger_remove(led_cdev);
 580
 581                 mutex_unlock(&led_cdev->led_access);
 582         }
 583
 584         if (led_cdev_ind) {
 585                 mutex_lock(&led_cdev_ind->led_access);
 586
 587                 led_sysfs_disable(led_cdev_ind);
 588                 led_trigger_remove(led_cdev_ind);
 589
 590                 mutex_unlock(&led_cdev_ind->led_access);
 591         }
 592
 593         ret = __sync_device_with_v4l2_controls(v4l2_flash);
 594         if (ret < 0)
 595                 goto out_sync_device;
 596
 597         return 0;
 598 out_sync_device:
 599         if (led_cdev) {
 600                 mutex_lock(&led_cdev->led_access);
 601                 led_sysfs_enable(led_cdev);
 602                 mutex_unlock(&led_cdev->led_access);
 603         }
 604
 605         if (led_cdev_ind) {
 606                 mutex_lock(&led_cdev_ind->led_access);
 607                 led_sysfs_enable(led_cdev_ind);
 608                 mutex_unlock(&led_cdev_ind->led_access);
 609         }
 610
 611         return ret;
 612 }
 613
 614 static int v4l2_flash_close(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
 615 {
 616         struct v4l2_flash *v4l2_flash = v4l2_subdev_to_v4l2_flash(sd);
 617         struct led_classdev_flash *fled_cdev = v4l2_flash->fled_cdev;
 618         struct led_classdev *led_cdev = fled_cdev ? &fled_cdev->led_cdev : NULL;
 619         struct led_classdev *led_cdev_ind = v4l2_flash->iled_cdev;
 620         int ret = 0;
 621
 622         if (!v4l2_fh_is_singular(&fh->vfh))
 623                 return 0;
 624
 625         if (led_cdev) {
 626                 mutex_lock(&led_cdev->led_access);
 627
 628                 if (v4l2_flash->ctrls[STROBE_SOURCE])
 629                         ret = v4l2_ctrl_s_ctrl(
 630                                 v4l2_flash->ctrls[STROBE_SOURCE],
 631                                 V4L2_FLASH_STROBE_SOURCE_SOFTWARE);
 632                 led_sysfs_enable(led_cdev);
 633
 634                 mutex_unlock(&led_cdev->led_access);
 635         }
 636
 637         if (led_cdev_ind) {
 638                 mutex_lock(&led_cdev_ind->led_access);
 639                 led_sysfs_enable(led_cdev_ind);
 640                 mutex_unlock(&led_cdev_ind->led_access);
 641         }
 642
 643         return ret;
 644 }
 645
 646 static const struct v4l2_subdev_internal_ops v4l2_flash_subdev_internal_ops = {
 647         .open = v4l2_flash_open,
 648         .close = v4l2_flash_close,
 649 };
 650
 651 static const struct v4l2_subdev_ops v4l2_flash_subdev_ops;
 652
 653 static struct v4l2_flash *__v4l2_flash_init(
 654         struct device *dev, struct fwnode_handle *fwn,
 655         struct led_classdev_flash *fled_cdev, struct led_classdev *iled_cdev,
 656         const struct v4l2_flash_ops *ops, struct v4l2_flash_config *config)
 657 {
 658         struct v4l2_flash *v4l2_flash;
 659         struct v4l2_subdev *sd;
 660         int ret;
 661
 662         if (!config)
 663                 return ERR_PTR(-EINVAL);
 664
 665         v4l2_flash = devm_kzalloc(dev, sizeof(*v4l2_flash), GFP_KERNEL);
 666         if (!v4l2_flash)
 667                 return ERR_PTR(-ENOMEM);
 668
 669         sd = &v4l2_flash->sd;
 670         v4l2_flash->fled_cdev = fled_cdev;
 671         v4l2_flash->iled_cdev = iled_cdev;
 672         v4l2_flash->ops = ops;
 673         sd->dev = dev;
 674         sd->fwnode = fwn ? fwn : dev_fwnode(dev);
 675         v4l2_subdev_init(sd, &v4l2_flash_subdev_ops);
 676         sd->internal_ops = &v4l2_flash_subdev_internal_ops;
 677         sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
 678         strscpy(sd->name, config->dev_name, sizeof(sd->name));
 679
 680         ret = media_entity_pads_init(&sd->entity, 0, NULL);
 681         if (ret < 0)
 682                 return ERR_PTR(ret);
 683
 684         sd->entity.function = MEDIA_ENT_F_FLASH;
 685
 686         ret = v4l2_flash_init_controls(v4l2_flash, config);
 687         if (ret < 0)
 688                 goto err_init_controls;
 689
 690         fwnode_handle_get(sd->fwnode);
 691
 692         ret = v4l2_async_register_subdev(sd);
 693         if (ret < 0)
 694                 goto err_async_register_sd;
 695
 696         return v4l2_flash;
 697
 698 err_async_register_sd:
 699         fwnode_handle_put(sd->fwnode);
 700         v4l2_ctrl_handler_free(sd->ctrl_handler);
 701 err_init_controls:
 702         media_entity_cleanup(&sd->entity);
 703
 704         return ERR_PTR(ret);
 705 }
 706
 707 struct v4l2_flash *v4l2_flash_init(
 708         struct device *dev, struct fwnode_handle *fwn,
 709         struct led_classdev_flash *fled_cdev,
 710         const struct v4l2_flash_ops *ops,
 711         struct v4l2_flash_config *config)
 712 {
 713         return __v4l2_flash_init(dev, fwn, fled_cdev, NULL, ops, config);
 714 }
 715 EXPORT_SYMBOL_GPL(v4l2_flash_init);
 716
 717 struct v4l2_flash *v4l2_flash_indicator_init(
 718         struct device *dev, struct fwnode_handle *fwn,
 719         struct led_classdev *iled_cdev,
 720         struct v4l2_flash_config *config)
 721 {
 722         return __v4l2_flash_init(dev, fwn, NULL, iled_cdev, NULL, config);
 723 }
 724 EXPORT_SYMBOL_GPL(v4l2_flash_indicator_init);
 725
 726 void v4l2_flash_release(struct v4l2_flash *v4l2_flash)
 727 {
 728         struct v4l2_subdev *sd;
 729
 730         if (IS_ERR_OR_NULL(v4l2_flash))
 731                 return;
 732
 733         sd = &v4l2_flash->sd;
 734
 735         v4l2_async_unregister_subdev(sd);
 736
 737         fwnode_handle_put(sd->fwnode);
 738
 739         v4l2_ctrl_handler_free(sd->ctrl_handler);
 740         media_entity_cleanup(&sd->entity);
 741 }
 742 EXPORT_SYMBOL_GPL(v4l2_flash_release);
 743
 744 MODULE_AUTHOR("Jacek Anaszewski <j.anaszewski@samsung.com>");
 745 MODULE_DESCRIPTION("V4L2 Flash sub-device helpers");
 746 MODULE_LICENSE("GPL v2");