leds/flash/leds-sgm3140.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 // Copyright (C) 2020 Luca Weiss <luca@z3ntu.xyz>
0003
0004 #include <linux/gpio/consumer.h>
0005 #include <linux/led-class-flash.h>
0006 #include <linux/module.h>
0007 #include <linux/regulator/consumer.h>
0008 #include <linux/platform_device.h>
0009
0010 #include <media/v4l2-flash-led-class.h>
0011
0012 #define FLASH_TIMEOUT_DEFAULT       250000U /* 250ms */
0013 #define FLASH_MAX_TIMEOUT_DEFAULT   300000U /* 300ms */
0014
0015 struct sgm3140 {
0016     struct led_classdev_flash fled_cdev;
0017     struct v4l2_flash *v4l2_flash;
0018
0019     struct timer_list powerdown_timer;
0020
0021     struct gpio_desc *flash_gpio;
0022     struct gpio_desc *enable_gpio;
0023     struct regulator *vin_regulator;
0024
0025     bool enabled;
0026
0027     /* current timeout in us */
0028     u32 timeout;
0029     /* maximum timeout in us */
0030     u32 max_timeout;
0031 };
0032
0033 static struct sgm3140 *flcdev_to_sgm3140(struct led_classdev_flash *flcdev)
0034 {
0035     return container_of(flcdev, struct sgm3140, fled_cdev);
0036 }
0037
0038 static int sgm3140_strobe_set(struct led_classdev_flash *fled_cdev, bool state)
0039 {
0040     struct sgm3140 *priv = flcdev_to_sgm3140(fled_cdev);
0041     int ret;
0042
0043     if (priv->enabled == state)
0044         return 0;
0045
0046     if (state) {
0047         ret = regulator_enable(priv->vin_regulator);
0048         if (ret) {
0049             dev_err(fled_cdev->led_cdev.dev,
0050                 "failed to enable regulator: %d\n", ret);
0051             return ret;
0052         }
0053         gpiod_set_value_cansleep(priv->flash_gpio, 1);
0054         gpiod_set_value_cansleep(priv->enable_gpio, 1);
0055         mod_timer(&priv->powerdown_timer,
0056               jiffies + usecs_to_jiffies(priv->timeout));
0057     } else {
0058         del_timer_sync(&priv->powerdown_timer);
0059         gpiod_set_value_cansleep(priv->enable_gpio, 0);
0060         gpiod_set_value_cansleep(priv->flash_gpio, 0);
0061         ret = regulator_disable(priv->vin_regulator);
0062         if (ret) {
0063             dev_err(fled_cdev->led_cdev.dev,
0064                 "failed to disable regulator: %d\n", ret);
0065             return ret;
0066         }
0067     }
0068
0069     priv->enabled = state;
0070
0071     return 0;
0072 }
0073
0074 static int sgm3140_strobe_get(struct led_classdev_flash *fled_cdev, bool *state)
0075 {
0076     struct sgm3140 *priv = flcdev_to_sgm3140(fled_cdev);
0077
0078     *state = timer_pending(&priv->powerdown_timer);
0079
0080     return 0;
0081 }
0082
0083 static int sgm3140_timeout_set(struct led_classdev_flash *fled_cdev,
0084                    u32 timeout)
0085 {
0086     struct sgm3140 *priv = flcdev_to_sgm3140(fled_cdev);
0087
0088     priv->timeout = timeout;
0089
0090     return 0;
0091 }
0092
0093 static const struct led_flash_ops sgm3140_flash_ops = {
0094     .strobe_set = sgm3140_strobe_set,
0095     .strobe_get = sgm3140_strobe_get,
0096     .timeout_set = sgm3140_timeout_set,
0097 };
0098
0099 static int sgm3140_brightness_set(struct led_classdev *led_cdev,
0100                   enum led_brightness brightness)
0101 {
0102     struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev);
0103     struct sgm3140 *priv = flcdev_to_sgm3140(fled_cdev);
0104     bool enable = brightness == LED_ON;
0105     int ret;
0106
0107     if (priv->enabled == enable)
0108         return 0;
0109
0110     if (enable) {
0111         ret = regulator_enable(priv->vin_regulator);
0112         if (ret) {
0113             dev_err(led_cdev->dev,
0114                 "failed to enable regulator: %d\n", ret);
0115             return ret;
0116         }
0117         gpiod_set_value_cansleep(priv->enable_gpio, 1);
0118     } else {
0119         gpiod_set_value_cansleep(priv->enable_gpio, 0);
0120         ret = regulator_disable(priv->vin_regulator);
0121         if (ret) {
0122             dev_err(led_cdev->dev,
0123                 "failed to disable regulator: %d\n", ret);
0124             return ret;
0125         }
0126     }
0127
0128     priv->enabled = enable;
0129
0130     return 0;
0131 }
0132
0133 static void sgm3140_powerdown_timer(struct timer_list *t)
0134 {
0135     struct sgm3140 *priv = from_timer(priv, t, powerdown_timer);
0136
0137     gpiod_set_value(priv->enable_gpio, 0);
0138     gpiod_set_value(priv->flash_gpio, 0);
0139     regulator_disable(priv->vin_regulator);
0140
0141     priv->enabled = false;
0142 }
0143
0144 static void sgm3140_init_flash_timeout(struct sgm3140 *priv)
0145 {
0146     struct led_classdev_flash *fled_cdev = &priv->fled_cdev;
0147     struct led_flash_setting *s;
0148
0149     /* Init flash timeout setting */
0150     s = &fled_cdev->timeout;
0151     s->min = 1;
0152     s->max = priv->max_timeout;
0153     s->step = 1;
0154     s->val = FLASH_TIMEOUT_DEFAULT;
0155 }
0156
0157 #if IS_ENABLED(CONFIG_V4L2_FLASH_LED_CLASS)
0158 static void sgm3140_init_v4l2_flash_config(struct sgm3140 *priv,
0159                     struct v4l2_flash_config *v4l2_sd_cfg)
0160 {
0161     struct led_classdev *led_cdev = &priv->fled_cdev.led_cdev;
0162     struct led_flash_setting *s;
0163
0164     strscpy(v4l2_sd_cfg->dev_name, led_cdev->dev->kobj.name,
0165         sizeof(v4l2_sd_cfg->dev_name));
0166
0167     /* Init flash intensity setting */
0168     s = &v4l2_sd_cfg->intensity;
0169     s->min = 0;
0170     s->max = 1;
0171     s->step = 1;
0172     s->val = 1;
0173 }
0174
0175 #else
0176 static void sgm3140_init_v4l2_flash_config(struct sgm3140 *priv,
0177                     struct v4l2_flash_config *v4l2_sd_cfg)
0178 {
0179 }
0180 #endif
0181
0182 static int sgm3140_probe(struct platform_device *pdev)
0183 {
0184     struct sgm3140 *priv;
0185     struct led_classdev *led_cdev;
0186     struct led_classdev_flash *fled_cdev;
0187     struct led_init_data init_data = {};
0188     struct fwnode_handle *child_node;
0189     struct v4l2_flash_config v4l2_sd_cfg = {};
0190     int ret;
0191
0192     priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
0193     if (!priv)
0194         return -ENOMEM;
0195
0196     priv->flash_gpio = devm_gpiod_get(&pdev->dev, "flash", GPIOD_OUT_LOW);
0197     ret = PTR_ERR_OR_ZERO(priv->flash_gpio);
0198     if (ret)
0199         return dev_err_probe(&pdev->dev, ret,
0200                      "Failed to request flash gpio\n");
0201
0202     priv->enable_gpio = devm_gpiod_get(&pdev->dev, "enable", GPIOD_OUT_LOW);
0203     ret = PTR_ERR_OR_ZERO(priv->enable_gpio);
0204     if (ret)
0205         return dev_err_probe(&pdev->dev, ret,
0206                      "Failed to request enable gpio\n");
0207
0208     priv->vin_regulator = devm_regulator_get(&pdev->dev, "vin");
0209     ret = PTR_ERR_OR_ZERO(priv->vin_regulator);
0210     if (ret)
0211         return dev_err_probe(&pdev->dev, ret,
0212                      "Failed to request regulator\n");
0213
0214     child_node = fwnode_get_next_available_child_node(pdev->dev.fwnode,
0215                               NULL);
0216     if (!child_node) {
0217         dev_err(&pdev->dev,
0218             "No fwnode child node found for connected LED.\n");
0219         return -EINVAL;
0220     }
0221
0222     ret = fwnode_property_read_u32(child_node, "flash-max-timeout-us",
0223                        &priv->max_timeout);
0224     if (ret) {
0225         priv->max_timeout = FLASH_MAX_TIMEOUT_DEFAULT;
0226         dev_warn(&pdev->dev,
0227              "flash-max-timeout-us property missing\n");
0228     }
0229
0230     /*
0231      * Set default timeout to FLASH_DEFAULT_TIMEOUT except if max_timeout
0232      * from DT is lower.
0233      */
0234     priv->timeout = min(priv->max_timeout, FLASH_TIMEOUT_DEFAULT);
0235
0236     timer_setup(&priv->powerdown_timer, sgm3140_powerdown_timer, 0);
0237
0238     fled_cdev = &priv->fled_cdev;
0239     led_cdev = &fled_cdev->led_cdev;
0240
0241     fled_cdev->ops = &sgm3140_flash_ops;
0242
0243     led_cdev->brightness_set_blocking = sgm3140_brightness_set;
0244     led_cdev->max_brightness = LED_ON;
0245     led_cdev->flags |= LED_DEV_CAP_FLASH;
0246
0247     sgm3140_init_flash_timeout(priv);
0248
0249     init_data.fwnode = child_node;
0250
0251     platform_set_drvdata(pdev, priv);
0252
0253     /* Register in the LED subsystem */
0254     ret = devm_led_classdev_flash_register_ext(&pdev->dev,
0255                            fled_cdev, &init_data);
0256     if (ret) {
0257         dev_err(&pdev->dev, "Failed to register flash device: %d\n",
0258             ret);
0259         goto err;
0260     }
0261
0262     sgm3140_init_v4l2_flash_config(priv, &v4l2_sd_cfg);
0263
0264     /* Create V4L2 Flash subdev */
0265     priv->v4l2_flash = v4l2_flash_init(&pdev->dev,
0266                        child_node,
0267                        fled_cdev, NULL,
0268                        &v4l2_sd_cfg);
0269     if (IS_ERR(priv->v4l2_flash)) {
0270         ret = PTR_ERR(priv->v4l2_flash);
0271         goto err;
0272     }
0273
0274     return ret;
0275
0276 err:
0277     fwnode_handle_put(child_node);
0278     return ret;
0279 }
0280
0281 static int sgm3140_remove(struct platform_device *pdev)
0282 {
0283     struct sgm3140 *priv = platform_get_drvdata(pdev);
0284
0285     del_timer_sync(&priv->powerdown_timer);
0286
0287     v4l2_flash_release(priv->v4l2_flash);
0288
0289     return 0;
0290 }
0291
0292 static const struct of_device_id sgm3140_dt_match[] = {
0293     { .compatible = "ocs,ocp8110" },
0294     { .compatible = "sgmicro,sgm3140" },
0295     { /* sentinel */ }
0296 };
0297 MODULE_DEVICE_TABLE(of, sgm3140_dt_match);
0298
0299 static struct platform_driver sgm3140_driver = {
0300     .probe  = sgm3140_probe,
0301     .remove = sgm3140_remove,
0302     .driver = {
0303         .name   = "sgm3140",
0304         .of_match_table = sgm3140_dt_match,
0305     },
0306 };
0307
0308 module_platform_driver(sgm3140_driver);
0309
0310 MODULE_AUTHOR("Luca Weiss <luca@z3ntu.xyz>");
0311 MODULE_DESCRIPTION("SG Micro SGM3140 charge pump LED driver");
0312 MODULE_LICENSE("GPL v2");