Quelle  leds-wm8350.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * LED driver for WM8350 driven LEDS.
 *
 * Copyright(C) 2007, 2008 Wolfson Microelectronics PLC.
 */

#include <linux/kernel.h>
#include <linux/platform_device.h>
#include <linux/leds.h>
#include <linux/err.h>
#include <linux/mfd/wm8350/pmic.h>
#include <linux/regulator/consumer.h>
#include <linux/slab.h>
#include <linux/module.h>

/* Microamps */
static const int isink_cur[] = {
 4,
 5,
 6,
 7,
 8,
 10,
 11,
 14,
 16,
 19,
 23,
 27,
 32,
 39,
 46,
 54,
 65,
 77,
 92,
 109,
 130,
 154,
 183,
 218,
 259,
 308,
 367,
 436,
 518,
 616,
 733,
 872,
 1037,
 1233,
 1466,
 1744,
 2073,
 2466,
 2933,
 3487,
 4147,
 4932,
 5865,
 6975,
 8294,
 9864,
 11730,
 13949,
 16589,
 19728,
 23460,
 27899,
 33178,
 39455,
 46920,
 55798,
 66355,
 78910,
 93840,
 111596,
 132710,
 157820,
 187681,
 223191
};

#define to_wm8350_led(led_cdev) \
 container_of(led_cdev, struct wm8350_led, cdev)

static int wm8350_led_enable(struct wm8350_led *led)
{
 int ret = 0;

 if (led->enabled)
  return ret;

 ret = regulator_enable(led->isink);
 if (ret != 0) {
  dev_err(led->cdev.dev, "Failed to enable ISINK: %d\n", ret);
  return ret;
 }

 ret = regulator_enable(led->dcdc);
 if (ret != 0) {
  dev_err(led->cdev.dev, "Failed to enable DCDC: %d\n", ret);
  regulator_disable(led->isink);
  return ret;
 }

 led->enabled = 1;

 return ret;
}

static int wm8350_led_disable(struct wm8350_led *led)
{
 int ret = 0;

 if (!led->enabled)
  return ret;

 ret = regulator_disable(led->dcdc);
 if (ret != 0) {
  dev_err(led->cdev.dev, "Failed to disable DCDC: %d\n", ret);
  return ret;
 }

 ret = regulator_disable(led->isink);
 if (ret != 0) {
  dev_err(led->cdev.dev, "Failed to disable ISINK: %d\n", ret);
  ret = regulator_enable(led->dcdc);
  if (ret != 0)
   dev_err(led->cdev.dev, "Failed to reenable DCDC: %d\n",
    ret);
  return ret;
 }

 led->enabled = 0;

 return ret;
}

static int wm8350_led_set(struct led_classdev *led_cdev,
      enum led_brightness value)
{
 struct wm8350_led *led = to_wm8350_led(led_cdev);
 unsigned long flags;
 int ret;
 int uA;

 led->value = value;

 spin_lock_irqsave(&led->value_lock, flags);

 if (led->value == LED_OFF) {
  spin_unlock_irqrestore(&led->value_lock, flags);
  return wm8350_led_disable(led);
 }

 /* This scales linearly into the index of valid current
 * settings which results in a linear scaling of perceived
 * brightness due to the non-linear current settings provided
 * by the hardware.
 */
 uA = (led->max_uA_index * led->value) / LED_FULL;
 spin_unlock_irqrestore(&led->value_lock, flags);
 BUG_ON(uA >= ARRAY_SIZE(isink_cur));

 ret = regulator_set_current_limit(led->isink, isink_cur[uA],
       isink_cur[uA]);
 if (ret != 0) {
  dev_err(led->cdev.dev, "Failed to set %duA: %d\n",
   isink_cur[uA], ret);
  return ret;
 }

 return wm8350_led_enable(led);
}

static void wm8350_led_shutdown(struct platform_device *pdev)
{
 struct wm8350_led *led = platform_get_drvdata(pdev);

 led->value = LED_OFF;
 wm8350_led_disable(led);
}

static int wm8350_led_probe(struct platform_device *pdev)
{
 struct regulator *isink, *dcdc;
 struct wm8350_led *led;
 struct wm8350_led_platform_data *pdata = dev_get_platdata(&pdev->dev);
 int i;

 if (pdata == NULL) {
  dev_err(&pdev->dev, "no platform data\n");
  return -ENODEV;
 }

 if (pdata->max_uA < isink_cur[0]) {
  dev_err(&pdev->dev, "Invalid maximum current %duA\n",
   pdata->max_uA);
  return -EINVAL;
 }

 isink = devm_regulator_get(&pdev->dev, "led_isink");
 if (IS_ERR(isink)) {
  dev_err(&pdev->dev, "%s: can't get ISINK\n", __func__);
  return PTR_ERR(isink);
 }

 dcdc = devm_regulator_get(&pdev->dev, "led_vcc");
 if (IS_ERR(dcdc)) {
  dev_err(&pdev->dev, "%s: can't get DCDC\n", __func__);
  return PTR_ERR(dcdc);
 }

 led = devm_kzalloc(&pdev->dev, sizeof(*led), GFP_KERNEL);
 if (led == NULL)
  return -ENOMEM;

 led->cdev.brightness_set_blocking = wm8350_led_set;
 led->cdev.default_trigger = pdata->default_trigger;
 led->cdev.name = pdata->name;
 led->cdev.flags |= LED_CORE_SUSPENDRESUME;
 led->enabled = regulator_is_enabled(isink);
 led->isink = isink;
 led->dcdc = dcdc;

 for (i = 0; i < ARRAY_SIZE(isink_cur) - 1; i++)
  if (isink_cur[i] >= pdata->max_uA)
   break;
 led->max_uA_index = i;
 if (pdata->max_uA != isink_cur[i])
  dev_warn(&pdev->dev,
    "Maximum current %duA is not directly supported,"
    " check platform data\n",
    pdata->max_uA);

 spin_lock_init(&led->value_lock);
 led->value = LED_OFF;
 platform_set_drvdata(pdev, led);

 return led_classdev_register(&pdev->dev, &led->cdev);
}

static void wm8350_led_remove(struct platform_device *pdev)
{
 struct wm8350_led *led = platform_get_drvdata(pdev);

 led_classdev_unregister(&led->cdev);
 wm8350_led_disable(led);
}

static struct platform_driver wm8350_led_driver = {
 .driver = {
     .name = "wm8350-led",
     },
 .probe = wm8350_led_probe,
 .remove = wm8350_led_remove,
 .shutdown = wm8350_led_shutdown,
};

module_platform_driver(wm8350_led_driver);

MODULE_AUTHOR("Mark Brown");
MODULE_DESCRIPTION("WM8350 LED driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:wm8350-led");