tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge tag 'backlight-next-6.11' of git://git.kernel.org/pub/scm/linux/kernel/git/lee/backlight

Pull backlight updates from Lee Jones:
"New Drivers:
- Texas Instruments LM3509 Backlight Driver

Fix-ups:
- Device Tree binding adaptions/conversions/creation
- Drop i2c_device_id::driver_data where the value is unused
- Make use of the new *_scoped() guard APIs
- Decouple from fbdev by providing Backlight with its own
BACKLIGHT_POWER_* constrains

Bug Fixes:
- Correctly assess return values (NULL vs IS_ERR())
- Supply a bunch of MODULE_DESCRIPTIONs to silence modpost warnings"

* tag 'backlight-next-6.11' of git://git.kernel.org/pub/scm/linux/kernel/git/lee/backlight: (23 commits)
backlight: sky81452-backlight: Use backlight power constants
backlight: rave-sp-backlight: Use backlight power constants
backlight: pwm-backlight: Use backlight power constants
backlight: pcf50633-backlight: Use backlight power constants
backlight: pandora-backlight: Use backlight power constants
backlight: mp3309c: Use backlight power constants
backlight: lm3533-backlight: Use backlight power constants
backlight: led-backlight: Use backlight power constants
backlight: ktd253-backlight: Use backlight power constants
backlight: kb3886-bl: Use backlight power constants
backlight: journada_bl: Use backlight power constants
backlight: ipaq-micro-backlight: Use backlight power constants
backlight: gpio-backlight: Use backlight power constants
backlight: corgi-lcd: Use backlight power constants
backlight: ams369fb06: Use backlight power constants
backlight: aat2870-backlight: Use blacklight power constants
backlight: Add BACKLIGHT_POWER_ constants for power states
backlight: lm3509_bl: Fix early returns in for_each_child_of_node()
backlight: Drop explicit initialization of struct i2c_device_id::driver_data to 0
backlight: Add missing MODULE_DESCRIPTION() macros
...

Linus Torvalds e0d97b04 1200af3a

+550 -64
+4 -3
Documentation/ABI/stable/sysfs-class-backlight
··· 3 3 KernelVersion: 2.6.12 4 4 Contact: Richard Purdie <rpurdie@rpsys.net> 5 5 Description: 6 - Control BACKLIGHT power, values are FB_BLANK_* from fb.h 6 + Control BACKLIGHT power, values are compatible with 7 + FB_BLANK_* from fb.h 7 8 8 - - FB_BLANK_UNBLANK (0) : power on. 9 - - FB_BLANK_POWERDOWN (4) : power off 9 + - 0 (FB_BLANK_UNBLANK) : power on. 10 + - 4 (FB_BLANK_POWERDOWN) : power off 10 11 Users: HAL 11 12 12 13 What: /sys/class/backlight/<backlight>/brightness
+136
Documentation/devicetree/bindings/leds/backlight/ti,lm3509.yaml
··· 1 + # SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause) 2 + %YAML 1.2 3 + --- 4 + $id: http://devicetree.org/schemas/leds/backlight/ti,lm3509.yaml# 5 + $schema: http://devicetree.org/meta-schemas/core.yaml# 6 + 7 + title: TI LM3509 High Efficiency Boost for White LED's and/or OLED Displays 8 + 9 + maintainers: 10 + - Patrick Gansterer <paroga@paroga.com> 11 + 12 + description: 13 + The LM3509 current mode boost converter offers two separate outputs. 14 + https://www.ti.com/product/LM3509 15 + 16 + properties: 17 + compatible: 18 + const: ti,lm3509 19 + 20 + reg: 21 + maxItems: 1 22 + 23 + "#address-cells": 24 + const: 1 25 + 26 + "#size-cells": 27 + const: 0 28 + 29 + reset-gpios: 30 + maxItems: 1 31 + 32 + ti,brightness-rate-of-change-us: 33 + description: Brightness Rate of Change in microseconds. 34 + enum: [51, 13000, 26000, 52000] 35 + 36 + ti,oled-mode: 37 + description: Enable OLED mode. 38 + type: boolean 39 + 40 + patternProperties: 41 + "^led@[01]$": 42 + type: object 43 + description: Properties for a string of connected LEDs. 44 + $ref: common.yaml# 45 + 46 + properties: 47 + reg: 48 + description: 49 + The control register that is used to program the two current sinks. 50 + The LM3509 has two registers (BMAIN and BSUB) and are represented 51 + as 0 or 1 in this property. The two current sinks can be controlled 52 + independently with both registers, or register BMAIN can be 53 + configured to control both sinks with the led-sources property. 54 + minimum: 0 55 + maximum: 1 56 + 57 + label: true 58 + 59 + led-sources: 60 + minItems: 1 61 + maxItems: 2 62 + items: 63 + minimum: 0 64 + maximum: 1 65 + 66 + default-brightness: 67 + minimum: 0 68 + maximum: 31 69 + default: 18 70 + 71 + max-brightness: 72 + minimum: 0 73 + maximum: 31 74 + default: 31 75 + 76 + required: 77 + - reg 78 + 79 + additionalProperties: false 80 + 81 + required: 82 + - compatible 83 + - reg 84 + 85 + additionalProperties: false 86 + 87 + examples: 88 + - | 89 + #include <dt-bindings/gpio/gpio.h> 90 + i2c { 91 + #address-cells = <1>; 92 + #size-cells = <0>; 93 + 94 + backlight@36 { 95 + compatible = "ti,lm3509"; 96 + reg = <0x36>; 97 + reset-gpios = <&gpio2 5 GPIO_ACTIVE_LOW>; 98 + 99 + ti,oled-mode; 100 + ti,brightness-rate-of-change-us = <52000>; 101 + 102 + #address-cells = <1>; 103 + #size-cells = <0>; 104 + 105 + led@0 { 106 + reg = <0>; 107 + led-sources = <0 1>; 108 + label = "lcd-backlight"; 109 + default-brightness = <12>; 110 + max-brightness = <31>; 111 + }; 112 + }; 113 + }; 114 + - | 115 + i2c { 116 + #address-cells = <1>; 117 + #size-cells = <0>; 118 + 119 + backlight@36 { 120 + compatible = "ti,lm3509"; 121 + reg = <0x36>; 122 + 123 + #address-cells = <1>; 124 + #size-cells = <0>; 125 + 126 + led@0 { 127 + reg = <0>; 128 + default-brightness = <12>; 129 + }; 130 + 131 + led@1 { 132 + reg = <1>; 133 + default-brightness = <15>; 134 + }; 135 + }; 136 + };
+7
drivers/video/backlight/Kconfig
··· 373 373 If you have a AnalogicTech AAT2870 say Y to enable the 374 374 backlight driver. 375 375 376 + config BACKLIGHT_LM3509 377 + tristate "Backlight Driver for LM3509" 378 + depends on I2C 379 + select REGMAP_I2C 380 + help 381 + This supports TI LM3509 Backlight Driver 382 + 376 383 config BACKLIGHT_LM3630A 377 384 tristate "Backlight Driver for LM3630A" 378 385 depends on I2C && PWM
+1
drivers/video/backlight/Makefile
··· 36 36 obj-$(CONFIG_BACKLIGHT_KTD253) += ktd253-backlight.o 37 37 obj-$(CONFIG_BACKLIGHT_KTD2801) += ktd2801-backlight.o 38 38 obj-$(CONFIG_BACKLIGHT_KTZ8866) += ktz8866.o 39 + obj-$(CONFIG_BACKLIGHT_LM3509) += lm3509_bl.o 39 40 obj-$(CONFIG_BACKLIGHT_LM3533) += lm3533_bl.o 40 41 obj-$(CONFIG_BACKLIGHT_LM3630A) += lm3630a_bl.o 41 42 obj-$(CONFIG_BACKLIGHT_LM3639) += lm3639_bl.o
+2 -2
drivers/video/backlight/aat2870_bl.c
··· 156 156 bd->props.max_brightness = 255; 157 157 158 158 aat2870_bl->brightness = 0; 159 - bd->props.power = FB_BLANK_UNBLANK; 159 + bd->props.power = BACKLIGHT_POWER_ON; 160 160 bd->props.brightness = bd->props.max_brightness; 161 161 162 162 ret = aat2870_bl_update_status(bd); ··· 176 176 struct aat2870_bl_driver_data *aat2870_bl = platform_get_drvdata(pdev); 177 177 struct backlight_device *bd = aat2870_bl->bd; 178 178 179 - bd->props.power = FB_BLANK_POWERDOWN; 179 + bd->props.power = BACKLIGHT_POWER_OFF; 180 180 bd->props.brightness = 0; 181 181 backlight_update_status(bd); 182 182 }
+1 -1
drivers/video/backlight/adp8870_bl.c
··· 963 963 adp8870_i2c_resume); 964 964 965 965 static const struct i2c_device_id adp8870_id[] = { 966 - { "adp8870", 0 }, 966 + { "adp8870" }, 967 967 { } 968 968 }; 969 969 MODULE_DEVICE_TABLE(i2c, adp8870_id);
+11 -12
drivers/video/backlight/ams369fg06.c
··· 10 10 11 11 #include <linux/backlight.h> 12 12 #include <linux/delay.h> 13 - #include <linux/fb.h> 14 13 #include <linux/lcd.h> 15 14 #include <linux/module.h> 16 15 #include <linux/spi/spi.h> ··· 299 300 300 301 static int ams369fg06_power_is_on(int power) 301 302 { 302 - return power <= FB_BLANK_NORMAL; 303 + return power <= BACKLIGHT_POWER_REDUCED; 303 304 } 304 305 305 306 static int ams369fg06_power_on(struct ams369fg06 *lcd) ··· 395 396 { 396 397 struct ams369fg06 *lcd = lcd_get_data(ld); 397 398 398 - if (power != FB_BLANK_UNBLANK && power != FB_BLANK_POWERDOWN && 399 - power != FB_BLANK_NORMAL) { 399 + if (power != BACKLIGHT_POWER_ON && power != BACKLIGHT_POWER_OFF && 400 + power != BACKLIGHT_POWER_REDUCED) { 400 401 dev_err(lcd->dev, "power value should be 0, 1 or 4.\n"); 401 402 return -EINVAL; 402 403 } ··· 491 492 * current lcd status is powerdown and then 492 493 * it enables lcd panel. 493 494 */ 494 - lcd->power = FB_BLANK_POWERDOWN; 495 + lcd->power = BACKLIGHT_POWER_OFF; 495 496 496 - ams369fg06_power(lcd, FB_BLANK_UNBLANK); 497 + ams369fg06_power(lcd, BACKLIGHT_POWER_ON); 497 498 } else { 498 - lcd->power = FB_BLANK_UNBLANK; 499 + lcd->power = BACKLIGHT_POWER_ON; 499 500 } 500 501 501 502 spi_set_drvdata(spi, lcd); ··· 509 510 { 510 511 struct ams369fg06 *lcd = spi_get_drvdata(spi); 511 512 512 - ams369fg06_power(lcd, FB_BLANK_POWERDOWN); 513 + ams369fg06_power(lcd, BACKLIGHT_POWER_OFF); 513 514 } 514 515 515 516 #ifdef CONFIG_PM_SLEEP ··· 523 524 * when lcd panel is suspend, lcd panel becomes off 524 525 * regardless of status. 525 526 */ 526 - return ams369fg06_power(lcd, FB_BLANK_POWERDOWN); 527 + return ams369fg06_power(lcd, BACKLIGHT_POWER_OFF); 527 528 } 528 529 529 530 static int ams369fg06_resume(struct device *dev) 530 531 { 531 532 struct ams369fg06 *lcd = dev_get_drvdata(dev); 532 533 533 - lcd->power = FB_BLANK_POWERDOWN; 534 + lcd->power = BACKLIGHT_POWER_OFF; 534 535 535 - return ams369fg06_power(lcd, FB_BLANK_UNBLANK); 536 + return ams369fg06_power(lcd, BACKLIGHT_POWER_ON); 536 537 } 537 538 #endif 538 539 ··· 543 544 { 544 545 struct ams369fg06 *lcd = spi_get_drvdata(spi); 545 546 546 - ams369fg06_power(lcd, FB_BLANK_POWERDOWN); 547 + ams369fg06_power(lcd, BACKLIGHT_POWER_OFF); 547 548 } 548 549 549 550 static struct spi_driver ams369fg06_driver = {
+1 -1
drivers/video/backlight/bd6107.c
··· 180 180 } 181 181 182 182 static const struct i2c_device_id bd6107_ids[] = { 183 - { "bd6107", 0 }, 183 + { "bd6107" }, 184 184 { } 185 185 }; 186 186 MODULE_DEVICE_TABLE(i2c, bd6107_ids);
+2 -2
drivers/video/backlight/corgi_lcd.c
··· 526 526 return PTR_ERR(lcd->bl_dev); 527 527 528 528 lcd->bl_dev->props.brightness = pdata->default_intensity; 529 - lcd->bl_dev->props.power = FB_BLANK_UNBLANK; 529 + lcd->bl_dev->props.power = BACKLIGHT_POWER_ON; 530 530 531 531 ret = setup_gpio_backlight(lcd, pdata); 532 532 if (ret) ··· 547 547 { 548 548 struct corgi_lcd *lcd = spi_get_drvdata(spi); 549 549 550 - lcd->bl_dev->props.power = FB_BLANK_UNBLANK; 550 + lcd->bl_dev->props.power = BACKLIGHT_POWER_ON; 551 551 lcd->bl_dev->props.brightness = 0; 552 552 backlight_update_status(lcd->bl_dev); 553 553 corgi_lcd_set_power(lcd->lcd_dev, FB_BLANK_POWERDOWN);
+4 -5
drivers/video/backlight/gpio_backlight.c
··· 5 5 6 6 #include <linux/backlight.h> 7 7 #include <linux/err.h> 8 - #include <linux/fb.h> 9 8 #include <linux/gpio/consumer.h> 10 9 #include <linux/init.h> 11 10 #include <linux/kernel.h> ··· 80 81 /* Set the initial power state */ 81 82 if (!of_node || !of_node->phandle) 82 83 /* Not booted with device tree or no phandle link to the node */ 83 - bl->props.power = def_value ? FB_BLANK_UNBLANK 84 - : FB_BLANK_POWERDOWN; 84 + bl->props.power = def_value ? BACKLIGHT_POWER_ON 85 + : BACKLIGHT_POWER_OFF; 85 86 else if (gpiod_get_value_cansleep(gbl->gpiod) == 0) 86 - bl->props.power = FB_BLANK_POWERDOWN; 87 + bl->props.power = BACKLIGHT_POWER_OFF; 87 88 else 88 - bl->props.power = FB_BLANK_UNBLANK; 89 + bl->props.power = BACKLIGHT_POWER_ON; 89 90 90 91 bl->props.brightness = 1; 91 92
+1 -2
drivers/video/backlight/ipaq_micro_bl.c
··· 7 7 8 8 #include <linux/backlight.h> 9 9 #include <linux/err.h> 10 - #include <linux/fb.h> 11 10 #include <linux/init.h> 12 11 #include <linux/mfd/ipaq-micro.h> 13 12 #include <linux/module.h> ··· 41 42 static const struct backlight_properties micro_bl_props = { 42 43 .type = BACKLIGHT_RAW, 43 44 .max_brightness = 255, 44 - .power = FB_BLANK_UNBLANK, 45 + .power = BACKLIGHT_POWER_ON, 45 46 .brightness = 64, 46 47 }; 47 48
+1 -2
drivers/video/backlight/jornada720_bl.c
··· 7 7 8 8 #include <linux/backlight.h> 9 9 #include <linux/device.h> 10 - #include <linux/fb.h> 11 10 #include <linux/kernel.h> 12 11 #include <linux/module.h> 13 12 #include <linux/platform_device.h> ··· 120 121 return ret; 121 122 } 122 123 123 - bd->props.power = FB_BLANK_UNBLANK; 124 + bd->props.power = BACKLIGHT_POWER_ON; 124 125 bd->props.brightness = BL_DEF_BRIGHT; 125 126 /* 126 127 * note. make sure max brightness is set otherwise
+2 -2
drivers/video/backlight/kb3886_bl.c
··· 10 10 #include <linux/module.h> 11 11 #include <linux/kernel.h> 12 12 #include <linux/init.h> 13 + #include <linux/io.h> 13 14 #include <linux/platform_device.h> 14 15 #include <linux/mutex.h> 15 - #include <linux/fb.h> 16 16 #include <linux/backlight.h> 17 17 #include <linux/delay.h> 18 18 #include <linux/dmi.h> ··· 151 151 152 152 platform_set_drvdata(pdev, kb3886_backlight_device); 153 153 154 - kb3886_backlight_device->props.power = FB_BLANK_UNBLANK; 154 + kb3886_backlight_device->props.power = BACKLIGHT_POWER_ON; 155 155 kb3886_backlight_device->props.brightness = machinfo->default_intensity; 156 156 backlight_update_status(kb3886_backlight_device); 157 157
+2 -3
drivers/video/backlight/ktd253-backlight.c
··· 7 7 #include <linux/backlight.h> 8 8 #include <linux/delay.h> 9 9 #include <linux/err.h> 10 - #include <linux/fb.h> 11 10 #include <linux/gpio/consumer.h> 12 11 #include <linux/init.h> 13 12 #include <linux/kernel.h> ··· 189 190 /* When we just enable the GPIO line we set max brightness */ 190 191 if (brightness) { 191 192 bl->props.brightness = brightness; 192 - bl->props.power = FB_BLANK_UNBLANK; 193 + bl->props.power = BACKLIGHT_POWER_ON; 193 194 } else { 194 195 bl->props.brightness = 0; 195 - bl->props.power = FB_BLANK_POWERDOWN; 196 + bl->props.power = BACKLIGHT_POWER_OFF; 196 197 } 197 198 198 199 ktd253->bl = bl;
+2 -2
drivers/video/backlight/ktz8866.c
··· 179 179 } 180 180 181 181 static const struct i2c_device_id ktz8866_ids[] = { 182 - { "ktz8866", 0 }, 183 - {}, 182 + { "ktz8866" }, 183 + {} 184 184 }; 185 185 MODULE_DEVICE_TABLE(i2c, ktz8866_ids); 186 186
+2 -2
drivers/video/backlight/led_bl.c
··· 200 200 props.type = BACKLIGHT_RAW; 201 201 props.max_brightness = priv->max_brightness; 202 202 props.brightness = priv->default_brightness; 203 - props.power = (priv->default_brightness > 0) ? FB_BLANK_POWERDOWN : 204 - FB_BLANK_UNBLANK; 203 + props.power = (priv->default_brightness > 0) ? BACKLIGHT_POWER_OFF : 204 + BACKLIGHT_POWER_ON; 205 205 priv->bl_dev = backlight_device_register(dev_name(&pdev->dev), 206 206 &pdev->dev, priv, &led_bl_ops, &props); 207 207 if (IS_ERR(priv->bl_dev)) {
+343
drivers/video/backlight/lm3509_bl.c
··· 1 + // SPDX-License-Identifier: GPL-2.0-or-later 2 + #include <linux/backlight.h> 3 + #include <linux/delay.h> 4 + #include <linux/gpio/consumer.h> 5 + #include <linux/i2c.h> 6 + #include <linux/module.h> 7 + #include <linux/regmap.h> 8 + 9 + #define LM3509_NAME "lm3509_bl" 10 + 11 + #define LM3509_SINK_MAIN 0 12 + #define LM3509_SINK_SUB 1 13 + #define LM3509_NUM_SINKS 2 14 + 15 + #define LM3509_DEF_BRIGHTNESS 0x12 16 + #define LM3509_MAX_BRIGHTNESS 0x1F 17 + 18 + #define REG_GP 0x10 19 + #define REG_BMAIN 0xA0 20 + #define REG_BSUB 0xB0 21 + #define REG_MAX 0xFF 22 + 23 + enum { 24 + REG_GP_ENM_BIT = 0, 25 + REG_GP_ENS_BIT, 26 + REG_GP_UNI_BIT, 27 + REG_GP_RMP0_BIT, 28 + REG_GP_RMP1_BIT, 29 + REG_GP_OLED_BIT, 30 + }; 31 + 32 + struct lm3509_bl { 33 + struct regmap *regmap; 34 + struct backlight_device *bl_main; 35 + struct backlight_device *bl_sub; 36 + struct gpio_desc *reset_gpio; 37 + }; 38 + 39 + struct lm3509_bl_led_data { 40 + const char *label; 41 + int led_sources; 42 + u32 brightness; 43 + u32 max_brightness; 44 + }; 45 + 46 + static void lm3509_reset(struct lm3509_bl *data) 47 + { 48 + if (data->reset_gpio) { 49 + gpiod_set_value(data->reset_gpio, 1); 50 + udelay(1); 51 + gpiod_set_value(data->reset_gpio, 0); 52 + udelay(10); 53 + } 54 + } 55 + 56 + static int lm3509_update_status(struct backlight_device *bl, 57 + unsigned int en_mask, unsigned int br_reg) 58 + { 59 + struct lm3509_bl *data = bl_get_data(bl); 60 + int ret; 61 + bool en; 62 + 63 + ret = regmap_write(data->regmap, br_reg, backlight_get_brightness(bl)); 64 + if (ret < 0) 65 + return ret; 66 + 67 + en = !backlight_is_blank(bl); 68 + return regmap_update_bits(data->regmap, REG_GP, en_mask, 69 + en ? en_mask : 0); 70 + } 71 + 72 + static int lm3509_main_update_status(struct backlight_device *bl) 73 + { 74 + return lm3509_update_status(bl, BIT(REG_GP_ENM_BIT), REG_BMAIN); 75 + } 76 + 77 + static const struct backlight_ops lm3509_main_ops = { 78 + .options = BL_CORE_SUSPENDRESUME, 79 + .update_status = lm3509_main_update_status, 80 + }; 81 + 82 + static int lm3509_sub_update_status(struct backlight_device *bl) 83 + { 84 + return lm3509_update_status(bl, BIT(REG_GP_ENS_BIT), REG_BSUB); 85 + } 86 + 87 + static const struct backlight_ops lm3509_sub_ops = { 88 + .options = BL_CORE_SUSPENDRESUME, 89 + .update_status = lm3509_sub_update_status, 90 + }; 91 + 92 + static struct backlight_device * 93 + lm3509_backlight_register(struct device *dev, const char *name_suffix, 94 + struct lm3509_bl *data, 95 + const struct backlight_ops *ops, 96 + const struct lm3509_bl_led_data *led_data) 97 + 98 + { 99 + struct backlight_device *bd; 100 + struct backlight_properties props; 101 + const char *label = led_data->label; 102 + char name[64]; 103 + 104 + memset(&props, 0, sizeof(props)); 105 + props.type = BACKLIGHT_RAW; 106 + props.brightness = led_data->brightness; 107 + props.max_brightness = led_data->max_brightness; 108 + props.scale = BACKLIGHT_SCALE_NON_LINEAR; 109 + 110 + if (!label) { 111 + snprintf(name, sizeof(name), "lm3509-%s-%s", dev_name(dev), 112 + name_suffix); 113 + label = name; 114 + } 115 + 116 + bd = devm_backlight_device_register(dev, label, dev, data, ops, &props); 117 + if (IS_ERR(bd)) 118 + return bd; 119 + 120 + backlight_update_status(bd); 121 + return bd; 122 + } 123 + 124 + static const struct regmap_config lm3509_regmap = { 125 + .reg_bits = 8, 126 + .val_bits = 8, 127 + .max_register = REG_MAX, 128 + }; 129 + 130 + static int lm3509_parse_led_sources(struct device_node *node, 131 + int default_led_sources) 132 + { 133 + u32 sources[LM3509_NUM_SINKS]; 134 + int ret, num_sources, i; 135 + 136 + num_sources = of_property_count_u32_elems(node, "led-sources"); 137 + if (num_sources < 0) 138 + return default_led_sources; 139 + else if (num_sources > ARRAY_SIZE(sources)) 140 + return -EINVAL; 141 + 142 + ret = of_property_read_u32_array(node, "led-sources", sources, 143 + num_sources); 144 + if (ret) 145 + return ret; 146 + 147 + for (i = 0; i < num_sources; i++) { 148 + if (sources[i] >= LM3509_NUM_SINKS) 149 + return -EINVAL; 150 + 151 + ret |= BIT(sources[i]); 152 + } 153 + 154 + return ret; 155 + } 156 + 157 + static int lm3509_parse_dt_node(struct device *dev, 158 + struct lm3509_bl_led_data *led_data) 159 + { 160 + int seen_led_sources = 0; 161 + 162 + for_each_child_of_node_scoped(dev->of_node, child) { 163 + struct lm3509_bl_led_data *ld; 164 + int ret; 165 + u32 reg; 166 + int valid_led_sources; 167 + 168 + ret = of_property_read_u32(child, "reg", &reg); 169 + if (ret < 0) 170 + return ret; 171 + if (reg >= LM3509_NUM_SINKS) 172 + return -EINVAL; 173 + ld = &led_data[reg]; 174 + 175 + ld->led_sources = lm3509_parse_led_sources(child, BIT(reg)); 176 + if (ld->led_sources < 0) 177 + return ld->led_sources; 178 + 179 + if (reg == 0) 180 + valid_led_sources = BIT(LM3509_SINK_MAIN) | 181 + BIT(LM3509_SINK_SUB); 182 + else 183 + valid_led_sources = BIT(LM3509_SINK_SUB); 184 + 185 + if (ld->led_sources != (ld->led_sources & valid_led_sources)) 186 + return -EINVAL; 187 + 188 + if (seen_led_sources & ld->led_sources) 189 + return -EINVAL; 190 + 191 + seen_led_sources |= ld->led_sources; 192 + 193 + ld->label = NULL; 194 + of_property_read_string(child, "label", &ld->label); 195 + 196 + ld->max_brightness = LM3509_MAX_BRIGHTNESS; 197 + of_property_read_u32(child, "max-brightness", 198 + &ld->max_brightness); 199 + ld->max_brightness = 200 + min_t(u32, ld->max_brightness, LM3509_MAX_BRIGHTNESS); 201 + 202 + ld->brightness = LM3509_DEF_BRIGHTNESS; 203 + of_property_read_u32(child, "default-brightness", 204 + &ld->brightness); 205 + ld->brightness = min_t(u32, ld->brightness, ld->max_brightness); 206 + } 207 + 208 + return 0; 209 + } 210 + 211 + static int lm3509_probe(struct i2c_client *client) 212 + { 213 + struct lm3509_bl *data; 214 + struct device *dev = &client->dev; 215 + int ret; 216 + bool oled_mode = false; 217 + unsigned int reg_gp_val = 0; 218 + struct lm3509_bl_led_data led_data[LM3509_NUM_SINKS]; 219 + u32 rate_of_change = 0; 220 + 221 + if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 222 + dev_err(dev, "i2c functionality check failed\n"); 223 + return -EOPNOTSUPP; 224 + } 225 + 226 + data = devm_kzalloc(dev, sizeof(struct lm3509_bl), GFP_KERNEL); 227 + if (!data) 228 + return -ENOMEM; 229 + 230 + data->regmap = devm_regmap_init_i2c(client, &lm3509_regmap); 231 + if (IS_ERR(data->regmap)) 232 + return PTR_ERR(data->regmap); 233 + i2c_set_clientdata(client, data); 234 + 235 + data->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_LOW); 236 + if (IS_ERR(data->reset_gpio)) 237 + return dev_err_probe(dev, PTR_ERR(data->reset_gpio), 238 + "Failed to get 'reset' gpio\n"); 239 + 240 + lm3509_reset(data); 241 + 242 + memset(led_data, 0, sizeof(led_data)); 243 + ret = lm3509_parse_dt_node(dev, led_data); 244 + if (ret) 245 + return ret; 246 + 247 + oled_mode = of_property_read_bool(dev->of_node, "ti,oled-mode"); 248 + 249 + if (!of_property_read_u32(dev->of_node, 250 + "ti,brightness-rate-of-change-us", 251 + &rate_of_change)) { 252 + switch (rate_of_change) { 253 + case 51: 254 + reg_gp_val = 0; 255 + break; 256 + case 13000: 257 + reg_gp_val = BIT(REG_GP_RMP1_BIT); 258 + break; 259 + case 26000: 260 + reg_gp_val = BIT(REG_GP_RMP0_BIT); 261 + break; 262 + case 52000: 263 + reg_gp_val = BIT(REG_GP_RMP0_BIT) | 264 + BIT(REG_GP_RMP1_BIT); 265 + break; 266 + default: 267 + dev_warn(dev, "invalid rate of change %u\n", 268 + rate_of_change); 269 + break; 270 + } 271 + } 272 + 273 + if (led_data[0].led_sources == 274 + (BIT(LM3509_SINK_MAIN) | BIT(LM3509_SINK_SUB))) 275 + reg_gp_val |= BIT(REG_GP_UNI_BIT); 276 + if (oled_mode) 277 + reg_gp_val |= BIT(REG_GP_OLED_BIT); 278 + 279 + ret = regmap_write(data->regmap, REG_GP, reg_gp_val); 280 + if (ret < 0) 281 + return dev_err_probe(dev, ret, "failed to write register\n"); 282 + 283 + if (led_data[0].led_sources) { 284 + data->bl_main = lm3509_backlight_register( 285 + dev, "main", data, &lm3509_main_ops, &led_data[0]); 286 + if (IS_ERR(data->bl_main)) { 287 + return dev_err_probe( 288 + dev, PTR_ERR(data->bl_main), 289 + "failed to register main backlight\n"); 290 + } 291 + } 292 + 293 + if (led_data[1].led_sources) { 294 + data->bl_sub = lm3509_backlight_register( 295 + dev, "sub", data, &lm3509_sub_ops, &led_data[1]); 296 + if (IS_ERR(data->bl_sub)) { 297 + return dev_err_probe( 298 + dev, PTR_ERR(data->bl_sub), 299 + "failed to register secondary backlight\n"); 300 + } 301 + } 302 + 303 + return 0; 304 + } 305 + 306 + static void lm3509_remove(struct i2c_client *client) 307 + { 308 + struct lm3509_bl *data = i2c_get_clientdata(client); 309 + 310 + regmap_write(data->regmap, REG_GP, 0x00); 311 + } 312 + 313 + static const struct i2c_device_id lm3509_id[] = { 314 + { LM3509_NAME }, 315 + {} 316 + }; 317 + 318 + MODULE_DEVICE_TABLE(i2c, lm3509_id); 319 + 320 + static const struct of_device_id lm3509_match_table[] = { 321 + { 322 + .compatible = "ti,lm3509", 323 + }, 324 + {}, 325 + }; 326 + 327 + MODULE_DEVICE_TABLE(of, lm3509_match_table); 328 + 329 + static struct i2c_driver lm3509_i2c_driver = { 330 + .driver = { 331 + .name = LM3509_NAME, 332 + .of_match_table = lm3509_match_table, 333 + }, 334 + .probe = lm3509_probe, 335 + .remove = lm3509_remove, 336 + .id_table = lm3509_id, 337 + }; 338 + 339 + module_i2c_driver(lm3509_i2c_driver); 340 + 341 + MODULE_DESCRIPTION("Texas Instruments Backlight driver for LM3509"); 342 + MODULE_AUTHOR("Patrick Gansterer <paroga@paroga.com>"); 343 + MODULE_LICENSE("GPL");
+1 -2
drivers/video/backlight/lm3533_bl.c
··· 11 11 #include <linux/init.h> 12 12 #include <linux/platform_device.h> 13 13 #include <linux/backlight.h> 14 - #include <linux/fb.h> 15 14 #include <linux/slab.h> 16 15 17 16 #include <linux/mfd/lm3533.h> ··· 343 344 344 345 dev_dbg(&bd->dev, "%s\n", __func__); 345 346 346 - bd->props.power = FB_BLANK_POWERDOWN; 347 + bd->props.power = BACKLIGHT_POWER_OFF; 347 348 bd->props.brightness = 0; 348 349 349 350 lm3533_ctrlbank_disable(&bl->cb);
+1 -1
drivers/video/backlight/lm3630a_bl.c
··· 596 596 } 597 597 598 598 static const struct i2c_device_id lm3630a_id[] = { 599 - {LM3630A_NAME, 0}, 599 + { LM3630A_NAME }, 600 600 {} 601 601 }; 602 602
+1 -1
drivers/video/backlight/lm3639_bl.c
··· 403 403 } 404 404 405 405 static const struct i2c_device_id lm3639_id[] = { 406 - {LM3639_NAME, 0}, 406 + { LM3639_NAME }, 407 407 {} 408 408 }; 409 409
+1 -1
drivers/video/backlight/lv5207lp.c
··· 132 132 } 133 133 134 134 static const struct i2c_device_id lv5207lp_ids[] = { 135 - { "lv5207lp", 0 }, 135 + { "lv5207lp" }, 136 136 { } 137 137 }; 138 138 MODULE_DEVICE_TABLE(i2c, lv5207lp_ids);
+3 -3
drivers/video/backlight/mp3309c.c
··· 358 358 props.max_brightness = pdata->max_brightness; 359 359 props.scale = BACKLIGHT_SCALE_LINEAR; 360 360 props.type = BACKLIGHT_RAW; 361 - props.power = FB_BLANK_UNBLANK; 361 + props.power = BACKLIGHT_POWER_ON; 362 362 chip->bl = devm_backlight_device_register(dev, "mp3309c", dev, chip, 363 363 &mp3309c_bl_ops, &props); 364 364 if (IS_ERR(chip->bl)) ··· 388 388 struct mp3309c_chip *chip = i2c_get_clientdata(client); 389 389 struct backlight_device *bl = chip->bl; 390 390 391 - bl->props.power = FB_BLANK_POWERDOWN; 391 + bl->props.power = BACKLIGHT_POWER_OFF; 392 392 bl->props.brightness = 0; 393 393 backlight_update_status(chip->bl); 394 394 } ··· 400 400 MODULE_DEVICE_TABLE(of, mp3309c_match_table); 401 401 402 402 static const struct i2c_device_id mp3309c_id[] = { 403 - { "mp3309c", 0 }, 403 + { "mp3309c" }, 404 404 { } 405 405 }; 406 406 MODULE_DEVICE_TABLE(i2c, mp3309c_id);
+1 -2
drivers/video/backlight/pandora_bl.c
··· 11 11 #include <linux/kernel.h> 12 12 #include <linux/platform_device.h> 13 13 #include <linux/delay.h> 14 - #include <linux/fb.h> 15 14 #include <linux/backlight.h> 16 15 #include <linux/mfd/twl.h> 17 16 #include <linux/err.h> ··· 42 43 struct pandora_private *priv = bl_get_data(bl); 43 44 u8 r; 44 45 45 - if (bl->props.power != FB_BLANK_UNBLANK) 46 + if (bl->props.power != BACKLIGHT_POWER_ON) 46 47 brightness = 0; 47 48 if (bl->props.state & BL_CORE_FBBLANK) 48 49 brightness = 0;
+2 -3
drivers/video/backlight/pcf50633-backlight.c
··· 10 10 #include <linux/platform_device.h> 11 11 12 12 #include <linux/backlight.h> 13 - #include <linux/fb.h> 14 13 15 14 #include <linux/mfd/pcf50633/core.h> 16 15 #include <linux/mfd/pcf50633/backlight.h> ··· 52 53 53 54 54 55 if (bl->props.state & (BL_CORE_SUSPENDED | BL_CORE_FBBLANK) || 55 - bl->props.power != FB_BLANK_UNBLANK) 56 + bl->props.power != BACKLIGHT_POWER_ON) 56 57 new_brightness = 0; 57 58 else if (bl->props.brightness < pcf_bl->brightness_limit) 58 59 new_brightness = bl->props.brightness; ··· 105 106 memset(&bl_props, 0, sizeof(bl_props)); 106 107 bl_props.type = BACKLIGHT_RAW; 107 108 bl_props.max_brightness = 0x3f; 108 - bl_props.power = FB_BLANK_UNBLANK; 109 + bl_props.power = BACKLIGHT_POWER_ON; 109 110 110 111 if (pdata) { 111 112 bl_props.brightness = pdata->default_brightness;
+1
drivers/video/backlight/platform_lcd.c
··· 143 143 module_platform_driver(platform_lcd_driver); 144 144 145 145 MODULE_AUTHOR("Ben Dooks <ben-linux@fluff.org>"); 146 + MODULE_DESCRIPTION("Generic platform-device LCD power control interface"); 146 147 MODULE_LICENSE("GPL v2"); 147 148 MODULE_ALIAS("platform:platform-lcd");
+2 -2
drivers/video/backlight/pwm_bl.c
··· 426 426 427 427 /* Not booted with device tree or no phandle link to the node */ 428 428 if (!node || !node->phandle) 429 - return FB_BLANK_UNBLANK; 429 + return BACKLIGHT_POWER_ON; 430 430 431 431 /* 432 432 * If the driver is probed from the device tree and there is a ··· 434 434 * assume that another driver will enable the backlight at the 435 435 * appropriate time. Therefore, if it is disabled, keep it so. 436 436 */ 437 - return active ? FB_BLANK_UNBLANK: FB_BLANK_POWERDOWN; 437 + return active ? BACKLIGHT_POWER_ON : BACKLIGHT_POWER_OFF; 438 438 } 439 439 440 440 static int pwm_backlight_probe(struct platform_device *pdev)
+1 -1
drivers/video/backlight/rave-sp-backlight.c
··· 19 19 { 20 20 const struct backlight_properties *p = &bd->props; 21 21 const u8 intensity = 22 - (p->power == FB_BLANK_UNBLANK) ? p->brightness : 0; 22 + (p->power == BACKLIGHT_POWER_ON) ? p->brightness : 0; 23 23 struct rave_sp *sp = dev_get_drvdata(&bd->dev); 24 24 u8 cmd[] = { 25 25 [0] = RAVE_SP_CMD_SET_BACKLIGHT,
+1
drivers/video/backlight/rt4831-backlight.c
··· 229 229 module_platform_driver(rt4831_bl_driver); 230 230 231 231 MODULE_AUTHOR("ChiYuan Huang <cy_huang@richtek.com>"); 232 + MODULE_DESCRIPTION("Richtek RT4831 Backlight Driver"); 232 233 MODULE_LICENSE("GPL v2");
+1 -1
drivers/video/backlight/sky81452-backlight.c
··· 315 315 316 316 sysfs_remove_group(&bd->dev.kobj, &sky81452_bl_attr_group); 317 317 318 - bd->props.power = FB_BLANK_UNBLANK; 318 + bd->props.power = BACKLIGHT_POWER_ON; 319 319 bd->props.brightness = 0; 320 320 backlight_update_status(bd); 321 321
+12 -8
include/linux/backlight.h
··· 209 209 * attribute: /sys/class/backlight/<backlight>/bl_power 210 210 * When the power property is updated update_status() is called. 211 211 * 212 - * The possible values are: (0: full on, 1 to 3: power saving 213 - * modes; 4: full off), see FB_BLANK_XXX. 212 + * The possible values are: (0: full on, 4: full off), see 213 + * BACKLIGHT_POWER constants. 214 214 * 215 - * When the backlight device is enabled @power is set 216 - * to FB_BLANK_UNBLANK. When the backlight device is disabled 217 - * @power is set to FB_BLANK_POWERDOWN. 215 + * When the backlight device is enabled, @power is set to 216 + * BACKLIGHT_POWER_ON. When the backlight device is disabled, 217 + * @power is set to BACKLIGHT_POWER_OFF. 218 218 */ 219 219 int power; 220 + 221 + #define BACKLIGHT_POWER_ON (0) 222 + #define BACKLIGHT_POWER_OFF (4) 223 + #define BACKLIGHT_POWER_REDUCED (1) // deprecated; don't use in new code 220 224 221 225 /** 222 226 * @type: The type of backlight supported. ··· 350 346 if (!bd) 351 347 return 0; 352 348 353 - bd->props.power = FB_BLANK_UNBLANK; 349 + bd->props.power = BACKLIGHT_POWER_ON; 354 350 bd->props.state &= ~BL_CORE_FBBLANK; 355 351 356 352 return backlight_update_status(bd); ··· 365 361 if (!bd) 366 362 return 0; 367 363 368 - bd->props.power = FB_BLANK_POWERDOWN; 364 + bd->props.power = BACKLIGHT_POWER_OFF; 369 365 bd->props.state |= BL_CORE_FBBLANK; 370 366 371 367 return backlight_update_status(bd); ··· 384 380 */ 385 381 static inline bool backlight_is_blank(const struct backlight_device *bd) 386 382 { 387 - return bd->props.power != FB_BLANK_UNBLANK || 383 + return bd->props.power != BACKLIGHT_POWER_ON || 388 384 bd->props.state & (BL_CORE_SUSPENDED | BL_CORE_FBBLANK); 389 385 } 390 386