drivers/leds/leds-88pm860x.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * LED driver for Marvell 88PM860x
0004  *
0005  * Copyright (C) 2009 Marvell International Ltd.
0006  *  Haojian Zhuang <haojian.zhuang@marvell.com>
0007  */
0008
0009 #include <linux/kernel.h>
0010 #include <linux/of.h>
0011 #include <linux/platform_device.h>
0012 #include <linux/i2c.h>
0013 #include <linux/leds.h>
0014 #include <linux/slab.h>
0015 #include <linux/mfd/88pm860x.h>
0016 #include <linux/module.h>
0017
0018 #define LED_PWM_MASK        (0x1F)
0019 #define LED_CURRENT_MASK    (0x07 << 5)
0020
0021 #define LED_BLINK_MASK      (0x7F)
0022
0023 #define LED_ON_CONTINUOUS   (0x0F << 3)
0024
0025 #define LED1_BLINK_EN       (1 << 1)
0026 #define LED2_BLINK_EN       (1 << 2)
0027
0028 struct pm860x_led {
0029     struct led_classdev cdev;
0030     struct i2c_client *i2c;
0031     struct pm860x_chip *chip;
0032     struct mutex lock;
0033     char name[MFD_NAME_SIZE];
0034
0035     int port;
0036     int iset;
0037     unsigned char brightness;
0038     unsigned char current_brightness;
0039
0040     int reg_control;
0041     int reg_blink;
0042     int blink_mask;
0043 };
0044
0045 static int led_power_set(struct pm860x_chip *chip, int port, int on)
0046 {
0047     int ret = -EINVAL;
0048
0049     switch (port) {
0050     case 0:
0051     case 1:
0052     case 2:
0053         ret = on ? pm8606_osc_enable(chip, RGB1_ENABLE) :
0054             pm8606_osc_disable(chip, RGB1_ENABLE);
0055         break;
0056     case 3:
0057     case 4:
0058     case 5:
0059         ret = on ? pm8606_osc_enable(chip, RGB2_ENABLE) :
0060             pm8606_osc_disable(chip, RGB2_ENABLE);
0061         break;
0062     }
0063     return ret;
0064 }
0065
0066 static int pm860x_led_set(struct led_classdev *cdev,
0067                enum led_brightness value)
0068 {
0069     struct pm860x_led *led = container_of(cdev, struct pm860x_led, cdev);
0070     struct pm860x_chip *chip;
0071     unsigned char buf[3];
0072     int ret;
0073
0074     chip = led->chip;
0075     mutex_lock(&led->lock);
0076     led->brightness = value >> 3;
0077
0078     if ((led->current_brightness == 0) && led->brightness) {
0079         led_power_set(chip, led->port, 1);
0080         if (led->iset) {
0081             pm860x_set_bits(led->i2c, led->reg_control,
0082                     LED_CURRENT_MASK, led->iset);
0083         }
0084         pm860x_set_bits(led->i2c, led->reg_blink,
0085                 LED_BLINK_MASK, LED_ON_CONTINUOUS);
0086         pm860x_set_bits(led->i2c, PM8606_WLED3B, led->blink_mask,
0087                 led->blink_mask);
0088     }
0089     pm860x_set_bits(led->i2c, led->reg_control, LED_PWM_MASK,
0090             led->brightness);
0091
0092     if (led->brightness == 0) {
0093         pm860x_bulk_read(led->i2c, led->reg_control, 3, buf);
0094         ret = buf[0] & LED_PWM_MASK;
0095         ret |= buf[1] & LED_PWM_MASK;
0096         ret |= buf[2] & LED_PWM_MASK;
0097         if (ret == 0) {
0098             /* unset current since no led is lighting */
0099             pm860x_set_bits(led->i2c, led->reg_control,
0100                     LED_CURRENT_MASK, 0);
0101             pm860x_set_bits(led->i2c, PM8606_WLED3B,
0102                     led->blink_mask, 0);
0103             led_power_set(chip, led->port, 0);
0104         }
0105     }
0106     led->current_brightness = led->brightness;
0107     dev_dbg(chip->dev, "Update LED. (reg:%d, brightness:%d)\n",
0108         led->reg_control, led->brightness);
0109     mutex_unlock(&led->lock);
0110
0111     return 0;
0112 }
0113
0114 #ifdef CONFIG_OF
0115 static int pm860x_led_dt_init(struct platform_device *pdev,
0116                   struct pm860x_led *data)
0117 {
0118     struct device_node *nproot, *np;
0119     int iset = 0;
0120
0121     if (!dev_of_node(pdev->dev.parent))
0122         return -ENODEV;
0123     nproot = of_get_child_by_name(dev_of_node(pdev->dev.parent), "leds");
0124     if (!nproot) {
0125         dev_err(&pdev->dev, "failed to find leds node\n");
0126         return -ENODEV;
0127     }
0128     for_each_available_child_of_node(nproot, np) {
0129         if (of_node_name_eq(np, data->name)) {
0130             of_property_read_u32(np, "marvell,88pm860x-iset",
0131                          &iset);
0132             data->iset = PM8606_LED_CURRENT(iset);
0133             of_node_put(np);
0134             break;
0135         }
0136     }
0137     of_node_put(nproot);
0138     return 0;
0139 }
0140 #else
0141 #define pm860x_led_dt_init(x, y)    (-1)
0142 #endif
0143
0144 static int pm860x_led_probe(struct platform_device *pdev)
0145 {
0146     struct pm860x_chip *chip = dev_get_drvdata(pdev->dev.parent);
0147     struct pm860x_led_pdata *pdata = dev_get_platdata(&pdev->dev);
0148     struct pm860x_led *data;
0149     struct resource *res;
0150     int ret = 0;
0151
0152     data = devm_kzalloc(&pdev->dev, sizeof(struct pm860x_led), GFP_KERNEL);
0153     if (data == NULL)
0154         return -ENOMEM;
0155     res = platform_get_resource_byname(pdev, IORESOURCE_REG, "control");
0156     if (!res) {
0157         dev_err(&pdev->dev, "No REG resource for control\n");
0158         return -ENXIO;
0159     }
0160     data->reg_control = res->start;
0161     res = platform_get_resource_byname(pdev, IORESOURCE_REG, "blink");
0162     if (!res) {
0163         dev_err(&pdev->dev, "No REG resource for blink\n");
0164         return -ENXIO;
0165     }
0166     data->reg_blink = res->start;
0167     memset(data->name, 0, MFD_NAME_SIZE);
0168     switch (pdev->id) {
0169     case 0:
0170         data->blink_mask = LED1_BLINK_EN;
0171         sprintf(data->name, "led0-red");
0172         break;
0173     case 1:
0174         data->blink_mask = LED1_BLINK_EN;
0175         sprintf(data->name, "led0-green");
0176         break;
0177     case 2:
0178         data->blink_mask = LED1_BLINK_EN;
0179         sprintf(data->name, "led0-blue");
0180         break;
0181     case 3:
0182         data->blink_mask = LED2_BLINK_EN;
0183         sprintf(data->name, "led1-red");
0184         break;
0185     case 4:
0186         data->blink_mask = LED2_BLINK_EN;
0187         sprintf(data->name, "led1-green");
0188         break;
0189     case 5:
0190         data->blink_mask = LED2_BLINK_EN;
0191         sprintf(data->name, "led1-blue");
0192         break;
0193     }
0194     data->chip = chip;
0195     data->i2c = (chip->id == CHIP_PM8606) ? chip->client : chip->companion;
0196     data->port = pdev->id;
0197     if (pm860x_led_dt_init(pdev, data))
0198         if (pdata)
0199             data->iset = pdata->iset;
0200
0201     data->current_brightness = 0;
0202     data->cdev.name = data->name;
0203     data->cdev.brightness_set_blocking = pm860x_led_set;
0204     mutex_init(&data->lock);
0205
0206     ret = led_classdev_register(chip->dev, &data->cdev);
0207     if (ret < 0) {
0208         dev_err(&pdev->dev, "Failed to register LED: %d\n", ret);
0209         return ret;
0210     }
0211     pm860x_led_set(&data->cdev, 0);
0212
0213     platform_set_drvdata(pdev, data);
0214
0215     return 0;
0216 }
0217
0218 static int pm860x_led_remove(struct platform_device *pdev)
0219 {
0220     struct pm860x_led *data = platform_get_drvdata(pdev);
0221
0222     led_classdev_unregister(&data->cdev);
0223
0224     return 0;
0225 }
0226
0227 static struct platform_driver pm860x_led_driver = {
0228     .driver = {
0229         .name   = "88pm860x-led",
0230     },
0231     .probe  = pm860x_led_probe,
0232     .remove = pm860x_led_remove,
0233 };
0234
0235 module_platform_driver(pm860x_led_driver);
0236
0237 MODULE_DESCRIPTION("LED driver for Marvell PM860x");
0238 MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
0239 MODULE_LICENSE("GPL");
0240 MODULE_ALIAS("platform:88pm860x-led");