video/backlight/88pm860x_bl.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Backlight driver for Marvell Semiconductor 88PM8606
0004  *
0005  * Copyright (C) 2009 Marvell International Ltd.
0006  *  Haojian Zhuang <haojian.zhuang@marvell.com>
0007  */
0008
0009 #include <linux/init.h>
0010 #include <linux/kernel.h>
0011 #include <linux/of.h>
0012 #include <linux/platform_device.h>
0013 #include <linux/slab.h>
0014 #include <linux/fb.h>
0015 #include <linux/i2c.h>
0016 #include <linux/backlight.h>
0017 #include <linux/mfd/88pm860x.h>
0018 #include <linux/module.h>
0019
0020 #define MAX_BRIGHTNESS      (0xFF)
0021 #define MIN_BRIGHTNESS      (0)
0022
0023 #define CURRENT_BITMASK     (0x1F << 1)
0024
0025 struct pm860x_backlight_data {
0026     struct pm860x_chip *chip;
0027     struct i2c_client *i2c;
0028     int current_brightness;
0029     int port;
0030     int pwm;
0031     int iset;
0032     int reg_duty_cycle;
0033     int reg_always_on;
0034     int reg_current;
0035 };
0036
0037 static int backlight_power_set(struct pm860x_chip *chip, int port,
0038         int on)
0039 {
0040     int ret = -EINVAL;
0041
0042     switch (port) {
0043     case 0:
0044         ret = on ? pm8606_osc_enable(chip, WLED1_DUTY) :
0045             pm8606_osc_disable(chip, WLED1_DUTY);
0046         break;
0047     case 1:
0048         ret = on ? pm8606_osc_enable(chip, WLED2_DUTY) :
0049             pm8606_osc_disable(chip, WLED2_DUTY);
0050         break;
0051     case 2:
0052         ret = on ? pm8606_osc_enable(chip, WLED3_DUTY) :
0053             pm8606_osc_disable(chip, WLED3_DUTY);
0054         break;
0055     }
0056     return ret;
0057 }
0058
0059 static int pm860x_backlight_set(struct backlight_device *bl, int brightness)
0060 {
0061     struct pm860x_backlight_data *data = bl_get_data(bl);
0062     struct pm860x_chip *chip = data->chip;
0063     unsigned char value;
0064     int ret;
0065
0066     if (brightness > MAX_BRIGHTNESS)
0067         value = MAX_BRIGHTNESS;
0068     else
0069         value = brightness;
0070
0071     if (brightness)
0072         backlight_power_set(chip, data->port, 1);
0073
0074     ret = pm860x_reg_write(data->i2c, data->reg_duty_cycle, value);
0075     if (ret < 0)
0076         goto out;
0077
0078     if ((data->current_brightness == 0) && brightness) {
0079         if (data->iset) {
0080             ret = pm860x_set_bits(data->i2c, data->reg_current,
0081                           CURRENT_BITMASK, data->iset);
0082             if (ret < 0)
0083                 goto out;
0084         }
0085         if (data->pwm) {
0086             ret = pm860x_set_bits(data->i2c, PM8606_PWM,
0087                           PM8606_PWM_FREQ_MASK, data->pwm);
0088             if (ret < 0)
0089                 goto out;
0090         }
0091         if (brightness == MAX_BRIGHTNESS) {
0092             /* set WLED_ON bit as 100% */
0093             ret = pm860x_set_bits(data->i2c, data->reg_always_on,
0094                           PM8606_WLED_ON, PM8606_WLED_ON);
0095         }
0096     } else {
0097         if (brightness == MAX_BRIGHTNESS) {
0098             /* set WLED_ON bit as 100% */
0099             ret = pm860x_set_bits(data->i2c, data->reg_always_on,
0100                           PM8606_WLED_ON, PM8606_WLED_ON);
0101         } else {
0102             /* clear WLED_ON bit since it's not 100% */
0103             ret = pm860x_set_bits(data->i2c, data->reg_always_on,
0104                           PM8606_WLED_ON, 0);
0105         }
0106     }
0107     if (ret < 0)
0108         goto out;
0109
0110     if (brightness == 0)
0111         backlight_power_set(chip, data->port, 0);
0112
0113     dev_dbg(chip->dev, "set brightness %d\n", value);
0114     data->current_brightness = value;
0115     return 0;
0116 out:
0117     dev_dbg(chip->dev, "set brightness %d failure with return value: %d\n",
0118         value, ret);
0119     return ret;
0120 }
0121
0122 static int pm860x_backlight_update_status(struct backlight_device *bl)
0123 {
0124     return pm860x_backlight_set(bl, backlight_get_brightness(bl));
0125 }
0126
0127 static int pm860x_backlight_get_brightness(struct backlight_device *bl)
0128 {
0129     struct pm860x_backlight_data *data = bl_get_data(bl);
0130     struct pm860x_chip *chip = data->chip;
0131     int ret;
0132
0133     ret = pm860x_reg_read(data->i2c, data->reg_duty_cycle);
0134     if (ret < 0)
0135         goto out;
0136     data->current_brightness = ret;
0137     dev_dbg(chip->dev, "get brightness %d\n", data->current_brightness);
0138     return data->current_brightness;
0139 out:
0140     return -EINVAL;
0141 }
0142
0143 static const struct backlight_ops pm860x_backlight_ops = {
0144     .options    = BL_CORE_SUSPENDRESUME,
0145     .update_status  = pm860x_backlight_update_status,
0146     .get_brightness = pm860x_backlight_get_brightness,
0147 };
0148
0149 #ifdef CONFIG_OF
0150 static int pm860x_backlight_dt_init(struct platform_device *pdev,
0151                     struct pm860x_backlight_data *data,
0152                     char *name)
0153 {
0154     struct device_node *nproot, *np;
0155     int iset = 0;
0156
0157     nproot = of_get_child_by_name(pdev->dev.parent->of_node, "backlights");
0158     if (!nproot) {
0159         dev_err(&pdev->dev, "failed to find backlights node\n");
0160         return -ENODEV;
0161     }
0162     for_each_child_of_node(nproot, np) {
0163         if (of_node_name_eq(np, name)) {
0164             of_property_read_u32(np, "marvell,88pm860x-iset",
0165                          &iset);
0166             data->iset = PM8606_WLED_CURRENT(iset);
0167             of_property_read_u32(np, "marvell,88pm860x-pwm",
0168                          &data->pwm);
0169             of_node_put(np);
0170             break;
0171         }
0172     }
0173     of_node_put(nproot);
0174     return 0;
0175 }
0176 #else
0177 #define pm860x_backlight_dt_init(x, y, z)   (-1)
0178 #endif
0179
0180 static int pm860x_backlight_probe(struct platform_device *pdev)
0181 {
0182     struct pm860x_chip *chip = dev_get_drvdata(pdev->dev.parent);
0183     struct pm860x_backlight_pdata *pdata = dev_get_platdata(&pdev->dev);
0184     struct pm860x_backlight_data *data;
0185     struct backlight_device *bl;
0186     struct resource *res;
0187     struct backlight_properties props;
0188     char name[MFD_NAME_SIZE];
0189     int ret = 0;
0190
0191     data = devm_kzalloc(&pdev->dev, sizeof(struct pm860x_backlight_data),
0192                 GFP_KERNEL);
0193     if (data == NULL)
0194         return -ENOMEM;
0195     res = platform_get_resource_byname(pdev, IORESOURCE_REG, "duty cycle");
0196     if (!res) {
0197         dev_err(&pdev->dev, "No REG resource for duty cycle\n");
0198         return -ENXIO;
0199     }
0200     data->reg_duty_cycle = res->start;
0201     res = platform_get_resource_byname(pdev, IORESOURCE_REG, "always on");
0202     if (!res) {
0203         dev_err(&pdev->dev, "No REG resource for always on\n");
0204         return -ENXIO;
0205     }
0206     data->reg_always_on = res->start;
0207     res = platform_get_resource_byname(pdev, IORESOURCE_REG, "current");
0208     if (!res) {
0209         dev_err(&pdev->dev, "No REG resource for current\n");
0210         return -ENXIO;
0211     }
0212     data->reg_current = res->start;
0213
0214     memset(name, 0, MFD_NAME_SIZE);
0215     sprintf(name, "backlight-%d", pdev->id);
0216     data->port = pdev->id;
0217     data->chip = chip;
0218     data->i2c = (chip->id == CHIP_PM8606) ? chip->client : chip->companion;
0219     data->current_brightness = MAX_BRIGHTNESS;
0220     if (pm860x_backlight_dt_init(pdev, data, name)) {
0221         if (pdata) {
0222             data->pwm = pdata->pwm;
0223             data->iset = pdata->iset;
0224         }
0225     }
0226
0227     memset(&props, 0, sizeof(struct backlight_properties));
0228     props.type = BACKLIGHT_RAW;
0229     props.max_brightness = MAX_BRIGHTNESS;
0230     bl = devm_backlight_device_register(&pdev->dev, name, &pdev->dev, data,
0231                     &pm860x_backlight_ops, &props);
0232     if (IS_ERR(bl)) {
0233         dev_err(&pdev->dev, "failed to register backlight\n");
0234         return PTR_ERR(bl);
0235     }
0236     bl->props.brightness = MAX_BRIGHTNESS;
0237
0238     platform_set_drvdata(pdev, bl);
0239
0240     /* read current backlight */
0241     ret = pm860x_backlight_get_brightness(bl);
0242     if (ret < 0)
0243         return ret;
0244
0245     backlight_update_status(bl);
0246     return 0;
0247 }
0248
0249 static struct platform_driver pm860x_backlight_driver = {
0250     .driver     = {
0251         .name   = "88pm860x-backlight",
0252     },
0253     .probe      = pm860x_backlight_probe,
0254 };
0255
0256 module_platform_driver(pm860x_backlight_driver);
0257
0258 MODULE_DESCRIPTION("Backlight Driver for Marvell Semiconductor 88PM8606");
0259 MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
0260 MODULE_LICENSE("GPL");
0261 MODULE_ALIAS("platform:88pm860x-backlight");