nagai/kernel
3
0
Fork 0
forked from mirrors/linux
Code Pull requests Activity

Backlight for v6.16

Browse source 
* Framebuffer Subsystem (fbdev):
     * The display's blanking status is now tracked in `struct fb_info`
     * `framebuffer_alloc()` initializes the blank state to `FB_BLANK_UNBLANK`
     * `register_framebuffer()` sets the state to `FB_BLANK_POWERDOWN` if an `fb_blank`
       callback exists, ensuring `FB_EVENT_BLANK` listeners correctly see the display
       being turned on during the first modeset
     * The `FB_EVENT_BLANK` event data now includes both the new and the old blank states
   * Qualcomm WLED Backlight:
     * Added a NULL check after `devm_kasprintf()` in `wled_configure()` to prevent a
       potential NULL pointer dereference if memory allocation fails
 
   * Framebuffer Subsystem (fbdev):
     * `fb_blank()` has been reworked to return early on errors, without functional
       changes, in preparation for further state tracking improvements
     * Fbdev now calls dedicated functions in the backlight subsystems to notify them
       of blank state changes, instead of relying on fbdev event notifiers
     * For LCDs, fbdev also calls a dedicated function to notify of mode changes
   * Backlight Subsystem:
     * Implemented fbdev blank state tracking using the (newly enhanced) blank state
       information provided directly by `FB_EVENT_BLANK`
     * Removed internal blank state tracking fields (`fb_bl_on`) from
       `struct backlight_device`
     * Moved the handling of blank-state updates into a separate internal helper
       function, `backlight_notify_blank()`
     * Removed support for fbdev events and replaced it with a dedicated function call
       interface (`backlight_notify_blank()` and `backlight_notify_blank_all()`) for
       display drivers to update backlight status
   * LCD Subsystem:
     * Moved the handling of display updates (blank events and mode changes) from
       fbdev event notifiers to separate internal helper functions (`lcd_notify_blank`,
       `lcd_notify_mode_change`)
     * Removed support for fbdev events and replaced it with dedicated function call
       interfaces (`lcd_notify_blank_all()`, `lcd_notify_mode_change_all()`)
     * The LCD subsystem now maintains its own internal list of LCD devices instead of
       relying on fbdev notifiers
   * LED Backlight Trigger:
     * Moved the handling of blank-state updates into a separate internal helper,
       `ledtrig_backlight_notify_blank()`
     * Removed support for fbdev events and replaced it with a dedicated function call,
       `ledtrig_backlight_blank()`, for fbdev to notify trigger of blank state changes
     * The LED backlight trigger now maintains its own internal list of triggers
       instead of relying on fbdev notifiers
 
   * Framebuffer Subsystem (fbdev):
     * Removed the definitions for the unused fbdev event constants
       `FB_EVENT_MODE_CHANGE` and `FB_EVENT_BLANK` from the header file
 -----BEGIN PGP SIGNATURE-----
 
 iQIzBAABCgAdFiEEdrbJNaO+IJqU8IdIUa+KL4f8d2EFAmg+xqwACgkQUa+KL4f8
 d2EIgA//SGigE46rNLd1+s87V4latrf672BtTs+2sioAGY7f9nzEdntMjk7o9/2G
 U//hJXP2Qr5WLdPVUQOi2ZZUMCks7sMgVx0KfCFiiYW8W0Vwhvl+17ZF3HLOqCCf
 JdQ9m69B1ubdAuyxD91ad84lofZtYEjDw/gK95gNrTaLhx4s/T5G9MrDU+qlZs3y
 npDhrnoQCclFcawSSDDhTUjiRcJFs3V1h3jUGi0Pz8PL1K/maR4fwgvw4ovkDjsR
 5on6cBjpuQoxz1KqlauuSc6OKWZUq8OHrFl7T9YIbn5ACuq2z47XBO0uluCJjrip
 MLvDCpxb7BcDRwcKDMZff6PWJMm4czVnNMgeGlQIUeIvZ/oD4CLCbas9BRYLiDpG
 jIzQOk7TSLiZaPwZFNoxRMJFKdC63K9+dLmncpKuAGf9Lh7fYdDv2Ch605zy1Zxf
 wumU9Bw2rj32iLaIUrsQHN6liIj41tHocRJHOUDkKb2fqzxq17+6NAe2qriRMHoS
 n4Mp+FmKUeBothw5bgRUKRZP4ff8stM0mCDL7ChKxNqJi4Wal8ok+hg3jhNZfW+O
 8ulSwrhJW/hjLrW29RyQIyB2Bz19H4/ZKdRjxfHgWgUdXQZLH5zBhtE0IISbdrBC
 FiRtrDyeWN1btvatEp4CKeKi6gEO+ZktxsFr5Zi7IYIN685iyug=
 =jhYi
 -----END PGP SIGNATURE-----

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

Pull backlight updates from Lee Jones:
 "Framebuffer Subsystem (fbdev):
   - The display's blanking status is now tracked in 'struct fb_info'
   - 'framebuffer_alloc()' initializes the blank state to FB_BLANK_UNBLANK
   - 'register_framebuffer()' sets the state to 'FB_BLANK_POWERDOWN' if
     an 'fb_blank' callback exists, ensuring 'FB_EVENT_BLANK' listeners
     correctly see the display being turned on during the first modeset
   - The 'FB_EVENT_BLANK' event data now includes both the new and the
     old blank states
   - 'fb_blank()' has been reworked to return early on errors, without
     functional changes, in preparation for further state tracking
     improvements
   - Fbdev now calls dedicated functions in the backlight subsystems to
     notify them of blank state changes, instead of relying on fbdev
     event notifiers
   - For LCDs, fbdev also calls a dedicated function to notify of mode
     changes
   - Removed the definitions for the unused fbdev event constants
     'FB_EVENT_MODE_CHANGE' and 'FB_EVENT_BLANK' from the header file

  Backlight Subsystem:
   - Implemented fbdev blank state tracking using the (newly enhanced)
     blank state information provided directly by 'FB_EVENT_BLANK'
   - Removed internal blank state tracking fields ('fb_bl_on') from
     'struct backlight_device'
   - Moved the handling of blank-state updates into a separate internal
     helper function, 'backlight_notify_blank()'
   - Removed support for fbdev events and replaced it with a dedicated
     function call interface ('backlight_notify_blank()' and
     'backlight_notify_blank_all()') for display drivers to update
     backlight status

  LCD Subsystem:
   - Moved the handling of display updates (blank events and mode
     changes) from fbdev event notifiers to separate internal helper
     functions ('lcd_notify_blank',
     'lcd_notify_mode_change')
   - Removed support for fbdev events and replaced it with dedicated
     function call interfaces ('lcd_notify_blank_all()',
     'lcd_notify_mode_change_all()')
   - The LCD subsystem now maintains its own internal list of LCD
     devices instead of relying on fbdev notifiers

  LED Backlight Trigger:
   - Moved the handling of blank-state updates into a separate internal
     helper, 'ledtrig_backlight_notify_blank()'
   - Removed support for fbdev events and replaced it with a dedicated
     function call, 'ledtrig_backlight_blank()', for fbdev to notify
     trigger of blank state changes
   - The LED backlight trigger now maintains its own internal list of
     triggers instead of relying on fbdev notifiers

  Qualcomm WLED Backlight:
   - Added a NULL check after 'devm_kasprintf()' in 'wled_configure()'
     to prevent a potential NULL pointer dereference if memory
     allocation fails"

* tag 'backlight-next-6.16' of git://git.kernel.org/pub/scm/linux/kernel/git/lee/backlight:
  backlight: pm8941: Add NULL check in wled_configure()
  fbdev: Remove constants of unused events
  leds: backlight trigger: Replace fb events with a dedicated function call
  leds: backlight trigger: Move blank-state handling into helper
  backlight: lcd: Replace fb events with a dedicated function call
  backlight: lcd: Move event handling into helpers
  backlight: Replace fb events with a dedicated function call
  backlight: Move blank-state handling into helper
  backlight: Implement fbdev tracking with blank state from event
  fbdev: Send old blank state in FB_EVENT_BLANK
  fbdev: Track display blanking state
  fbdev: Rework fb_blank()
This commit is contained in:
Linus Torvalds 2025-06-03 12:52:25 -07:00
commit a9dfb7db96
12 changed files with 222 additions and 213 deletions
repo.diff.show_diff_stats Download patch file Download diff file Expand all files Collapse all files

50
drivers/leds/trigger/ledtrig-backlight.c
View file

@ -10,7 +10,6 @@
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/fb.h>
#include <linux/leds.h>
#include "../leds.h"
@ -21,29 +20,20 @@ struct bl_trig_notifier {
struct led_classdev *led;
int brightness;
int old_status;
struct notifier_block notifier;
unsigned invert;
struct list_head entry;
};
static int fb_notifier_callback(struct notifier_block *p,
unsigned long event, void *data)
static DEFINE_MUTEX(ledtrig_backlight_list_mutex);
static LIST_HEAD(ledtrig_backlight_list);
static void ledtrig_backlight_notify_blank(struct bl_trig_notifier *n, int new_status)
{
struct bl_trig_notifier *n = container_of(p,
struct bl_trig_notifier, notifier);
struct led_classdev *led = n->led;
struct fb_event *fb_event = data;
int *blank;
int new_status;
/* If we aren't interested in this event, skip it immediately ... */
if (event != FB_EVENT_BLANK)
return 0;
blank = fb_event->data;
new_status = *blank ? BLANK : UNBLANK;
if (new_status == n->old_status)
return 0;
return;
if ((n->old_status == UNBLANK) ^ n->invert) {
n->brightness = led->brightness;
@ -53,10 +43,20 @@ static int fb_notifier_callback(struct notifier_block *p,
}
n->old_status = new_status;
return 0;
}
void ledtrig_backlight_blank(bool blank)
{
struct bl_trig_notifier *n;
int new_status = blank ? BLANK : UNBLANK;
guard(mutex)(&ledtrig_backlight_list_mutex);
list_for_each_entry(n, &ledtrig_backlight_list, entry)
ledtrig_backlight_notify_blank(n, new_status);
}
EXPORT_SYMBOL(ledtrig_backlight_blank);
static ssize_t bl_trig_invert_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
@ -100,8 +100,6 @@ ATTRIBUTE_GROUPS(bl_trig);
static int bl_trig_activate(struct led_classdev *led)
{
int ret;
struct bl_trig_notifier *n;
n = kzalloc(sizeof(struct bl_trig_notifier), GFP_KERNEL);
@ -112,11 +110,9 @@ static int bl_trig_activate(struct led_classdev *led)
n->led = led;
n->brightness = led->brightness;
n->old_status = UNBLANK;
n->notifier.notifier_call = fb_notifier_callback;
ret = fb_register_client(&n->notifier);
if (ret)
dev_err(led->dev, "unable to register backlight trigger\n");
guard(mutex)(&ledtrig_backlight_list_mutex);
list_add(&n->entry, &ledtrig_backlight_list);
return 0;
}
@ -125,7 +121,9 @@ static void bl_trig_deactivate(struct led_classdev *led)
{
struct bl_trig_notifier *n = led_get_trigger_data(led);
fb_unregister_client(&n->notifier);
guard(mutex)(&ledtrig_backlight_list_mutex);
list_del(&n->entry);
kfree(n);
}

91
drivers/video/backlight/backlight.c
View file

@ -15,7 +15,6 @@
#include <linux/notifier.h>
#include <linux/ctype.h>
#include <linux/err.h>
#include <linux/fb.h>
#include <linux/slab.h>
#ifdef CONFIG_PMAC_BACKLIGHT
@ -57,10 +56,10 @@
* a hot-key to adjust backlight, the driver must notify the backlight
* core that brightness has changed using backlight_force_update().
*
* The backlight driver core receives notifications from fbdev and
* if the event is FB_EVENT_BLANK and if the value of blank, from the
* FBIOBLANK ioctrl, results in a change in the backlight state the
* update_status() operation is called.
* Display drives can control the backlight device's status using
* backlight_notify_blank() and backlight_notify_blank_all(). If this
* results in a change in the backlight state the functions call the
* update_status() operation.
*/
static struct list_head backlight_dev_list;
@ -78,85 +77,40 @@ static const char *const backlight_scale_types[] = {
[BACKLIGHT_SCALE_NON_LINEAR] = "non-linear",
};
#if defined(CONFIG_FB_CORE) || (defined(CONFIG_FB_CORE_MODULE) && \
defined(CONFIG_BACKLIGHT_CLASS_DEVICE_MODULE))
/*
* fb_notifier_callback
*
* This callback gets called when something important happens inside a
* framebuffer driver. The backlight core only cares about FB_BLANK_UNBLANK
* which is reported to the driver using backlight_update_status()
* as a state change.
*
* There may be several fbdev's connected to the backlight device,
* in which case they are kept track of. A state change is only reported
* if there is a change in backlight for the specified fbdev.
*/
static int fb_notifier_callback(struct notifier_block *self,
unsigned long event, void *data)
void backlight_notify_blank(struct backlight_device *bd, struct device *display_dev,
bool fb_on, bool prev_fb_on)
{
struct backlight_device *bd;
struct fb_event *evdata = data;
struct fb_info *info = evdata->info;
struct backlight_device *fb_bd = fb_bl_device(info);
int node = info->node;
int fb_blank = 0;
/* If we aren't interested in this event, skip it immediately ... */
if (event != FB_EVENT_BLANK)
return 0;
bd = container_of(self, struct backlight_device, fb_notif);
mutex_lock(&bd->ops_lock);
guard(mutex)(&bd->ops_lock);
if (!bd->ops)
goto out;
if (bd->ops->controls_device && !bd->ops->controls_device(bd, info->device))
goto out;
if (fb_bd && fb_bd != bd)
goto out;
return;
if (bd->ops->controls_device && !bd->ops->controls_device(bd, display_dev))
return;
fb_blank = *(int *)evdata->data;
if (fb_blank == FB_BLANK_UNBLANK && !bd->fb_bl_on[node]) {
bd->fb_bl_on[node] = true;
if (fb_on && (!prev_fb_on || !bd->use_count)) {
if (!bd->use_count++) {
bd->props.state &= ~BL_CORE_FBBLANK;
backlight_update_status(bd);
}
} else if (fb_blank != FB_BLANK_UNBLANK && bd->fb_bl_on[node]) {
bd->fb_bl_on[node] = false;
} else if (!fb_on && prev_fb_on && bd->use_count) {
if (!(--bd->use_count)) {
bd->props.state |= BL_CORE_FBBLANK;
backlight_update_status(bd);
}
}
out:
mutex_unlock(&bd->ops_lock);
return 0;
}
EXPORT_SYMBOL(backlight_notify_blank);
static int backlight_register_fb(struct backlight_device *bd)
void backlight_notify_blank_all(struct device *display_dev, bool fb_on, bool prev_fb_on)
{
memset(&bd->fb_notif, 0, sizeof(bd->fb_notif));
bd->fb_notif.notifier_call = fb_notifier_callback;
struct backlight_device *bd;
return fb_register_client(&bd->fb_notif);
}
guard(mutex)(&backlight_dev_list_mutex);
static void backlight_unregister_fb(struct backlight_device *bd)
{
fb_unregister_client(&bd->fb_notif);
list_for_each_entry(bd, &backlight_dev_list, entry)
backlight_notify_blank(bd, display_dev, fb_on, prev_fb_on);
}
#else
static inline int backlight_register_fb(struct backlight_device *bd)
{
return 0;
}
static inline void backlight_unregister_fb(struct backlight_device *bd)
{
}
#endif /* CONFIG_FB_CORE */
EXPORT_SYMBOL(backlight_notify_blank_all);
static void backlight_generate_event(struct backlight_device *bd,
enum backlight_update_reason reason)
@ -447,12 +401,6 @@ struct backlight_device *backlight_device_register(const char *name,
return ERR_PTR(rc);
}
rc = backlight_register_fb(new_bd);
if (rc) {
device_unregister(&new_bd->dev);
return ERR_PTR(rc);
}
new_bd->ops = ops;
#ifdef CONFIG_PMAC_BACKLIGHT
@ -539,7 +487,6 @@ void backlight_device_unregister(struct backlight_device *bd)
bd->ops = NULL;
mutex_unlock(&bd->ops_lock);
backlight_unregister_fb(bd);
device_unregister(&bd->dev);
}
EXPORT_SYMBOL(backlight_device_unregister);

114
drivers/video/backlight/lcd.c
View file

@ -15,86 +15,59 @@
#include <linux/notifier.h>
#include <linux/ctype.h>
#include <linux/err.h>
#include <linux/fb.h>
#include <linux/slab.h>
#if defined(CONFIG_FB) || (defined(CONFIG_FB_MODULE) && \
defined(CONFIG_LCD_CLASS_DEVICE_MODULE))
static int to_lcd_power(int fb_blank)
{
switch (fb_blank) {
case FB_BLANK_UNBLANK:
return LCD_POWER_ON;
/* deprecated; TODO: should become 'off' */
case FB_BLANK_NORMAL:
return LCD_POWER_REDUCED;
case FB_BLANK_VSYNC_SUSPEND:
return LCD_POWER_REDUCED_VSYNC_SUSPEND;
/* 'off' */
case FB_BLANK_HSYNC_SUSPEND:
case FB_BLANK_POWERDOWN:
default:
return LCD_POWER_OFF;
}
}
static DEFINE_MUTEX(lcd_dev_list_mutex);
static LIST_HEAD(lcd_dev_list);
/* This callback gets called when something important happens inside a
* framebuffer driver. We're looking if that important event is blanking,
* and if it is, we're switching lcd power as well ...
*/
static int fb_notifier_callback(struct notifier_block *self,
unsigned long event, void *data)
static void lcd_notify_blank(struct lcd_device *ld, struct device *display_dev,
int power)
{
struct lcd_device *ld = container_of(self, struct lcd_device, fb_notif);
struct fb_event *evdata = data;
struct fb_info *info = evdata->info;
struct lcd_device *fb_lcd = fb_lcd_device(info);
guard(mutex)(&ld->ops_lock);
if (!ld->ops)
return 0;
if (ld->ops->controls_device && !ld->ops->controls_device(ld, info->device))
return 0;
if (fb_lcd && fb_lcd != ld)
return 0;
if (!ld->ops || !ld->ops->set_power)
return;
if (ld->ops->controls_device && !ld->ops->controls_device(ld, display_dev))
return;
if (event == FB_EVENT_BLANK) {
int power = to_lcd_power(*(int *)evdata->data);
if (ld->ops->set_power)
ld->ops->set_power(ld, power);
} else {
const struct fb_videomode *videomode = evdata->data;
if (ld->ops->set_mode)
ld->ops->set_mode(ld, videomode->xres, videomode->yres);
}
return 0;
ld->ops->set_power(ld, power);
}
static int lcd_register_fb(struct lcd_device *ld)
void lcd_notify_blank_all(struct device *display_dev, int power)
{
memset(&ld->fb_notif, 0, sizeof(ld->fb_notif));
ld->fb_notif.notifier_call = fb_notifier_callback;
return fb_register_client(&ld->fb_notif);
struct lcd_device *ld;
guard(mutex)(&lcd_dev_list_mutex);
list_for_each_entry(ld, &lcd_dev_list, entry)
lcd_notify_blank(ld, display_dev, power);
}
EXPORT_SYMBOL(lcd_notify_blank_all);
static void lcd_notify_mode_change(struct lcd_device *ld, struct device *display_dev,
unsigned int width, unsigned int height)
{
guard(mutex)(&ld->ops_lock);
if (!ld->ops || !ld->ops->set_mode)
return;
if (ld->ops->controls_device && !ld->ops->controls_device(ld, display_dev))
return;
ld->ops->set_mode(ld, width, height);
}
static void lcd_unregister_fb(struct lcd_device *ld)
void lcd_notify_mode_change_all(struct device *display_dev,
unsigned int width, unsigned int height)
{
fb_unregister_client(&ld->fb_notif);
}
#else
static int lcd_register_fb(struct lcd_device *ld)
{
return 0;
}
struct lcd_device *ld;
static inline void lcd_unregister_fb(struct lcd_device *ld)
{
guard(mutex)(&lcd_dev_list_mutex);
list_for_each_entry(ld, &lcd_dev_list, entry)
lcd_notify_mode_change(ld, display_dev, width, height);
}
#endif /* CONFIG_FB */
EXPORT_SYMBOL(lcd_notify_mode_change_all);
static ssize_t lcd_power_show(struct device *dev, struct device_attribute *attr,
char *buf)
@ -245,11 +218,8 @@ struct lcd_device *lcd_device_register(const char *name, struct device *parent,
return ERR_PTR(rc);
}
rc = lcd_register_fb(new_ld);
if (rc) {
device_unregister(&new_ld->dev);
return ERR_PTR(rc);
}
guard(mutex)(&lcd_dev_list_mutex);
list_add(&new_ld->entry, &lcd_dev_list);
return new_ld;
}
@ -266,10 +236,12 @@ void lcd_device_unregister(struct lcd_device *ld)
if (!ld)
return;
guard(mutex)(&lcd_dev_list_mutex);
list_del(&ld->entry);
mutex_lock(&ld->ops_lock);
ld->ops = NULL;
mutex_unlock(&ld->ops_lock);
lcd_unregister_fb(ld);
device_unregister(&ld->dev);
}

6
drivers/video/backlight/qcom-wled.c
View file

@ -1406,9 +1406,11 @@ static int wled_configure(struct wled *wled)
wled->ctrl_addr = be32_to_cpu(*prop_addr);
rc = of_property_read_string(dev->of_node, "label", &wled->name);
if (rc)
if (rc) {
wled->name = devm_kasprintf(dev, GFP_KERNEL, "%pOFn", dev->of_node);
if (!wled->name)
return -ENOMEM;
}
switch (wled->version) {
case 3:
u32_opts = wled3_opts;

12
drivers/video/fbdev/core/fb_backlight.c
View file

@ -1,5 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-or-later
#include <linux/backlight.h>
#include <linux/export.h>
#include <linux/fb.h>
#include <linux/mutex.h>
@ -36,4 +37,15 @@ struct backlight_device *fb_bl_device(struct fb_info *info)
return info->bl_dev;
}
EXPORT_SYMBOL(fb_bl_device);
void fb_bl_notify_blank(struct fb_info *info, int old_blank)
{
bool on = info->blank == FB_BLANK_UNBLANK;
bool prev_on = old_blank == FB_BLANK_UNBLANK;
if (info->bl_dev)
backlight_notify_blank(info->bl_dev, info->device, on, prev_on);
else
backlight_notify_blank_all(info->device, on, prev_on);
}
#endif

1
drivers/video/fbdev/core/fb_info.c
View file

@ -42,6 +42,7 @@ struct fb_info *framebuffer_alloc(size_t size, struct device *dev)
info->device = dev;
info->fbcon_rotate_hint = -1;
info->blank = FB_BLANK_UNBLANK;
#if IS_ENABLED(CONFIG_FB_BACKLIGHT)
mutex_init(&info->bl_curve_mutex);

82
drivers/video/fbdev/core/fbmem.c
View file

@ -15,6 +15,8 @@
#include <linux/export.h>
#include <linux/fb.h>
#include <linux/fbcon.h>
#include <linux/lcd.h>
#include <linux/leds.h>
#include <video/nomodeset.h>
@ -220,6 +222,12 @@ static int fb_check_caps(struct fb_info *info, struct fb_var_screeninfo *var,
return err;
}
static void fb_lcd_notify_mode_change(struct fb_info *info,
struct fb_videomode *mode)
{
lcd_notify_mode_change_all(info->device, mode->xres, mode->yres);
}
int
fb_set_var(struct fb_info *info, struct fb_var_screeninfo *var)
{
@ -227,7 +235,6 @@ fb_set_var(struct fb_info *info, struct fb_var_screeninfo *var)
u32 activate;
struct fb_var_screeninfo old_var;
struct fb_videomode mode;
struct fb_event event;
u32 unused;
if (var->activate & FB_ACTIVATE_INV_MODE) {
@ -333,32 +340,71 @@ fb_set_var(struct fb_info *info, struct fb_var_screeninfo *var)
return ret;
}
event.info = info;
event.data = &mode;
fb_notifier_call_chain(FB_EVENT_MODE_CHANGE, &event);
fb_lcd_notify_mode_change(info, &mode);
return 0;
}
EXPORT_SYMBOL(fb_set_var);
int
fb_blank(struct fb_info *info, int blank)
static void fb_lcd_notify_blank(struct fb_info *info)
{
struct fb_event event;
int ret = -EINVAL;
int power;
switch (info->blank) {
case FB_BLANK_UNBLANK:
power = LCD_POWER_ON;
break;
/* deprecated; TODO: should become 'off' */
case FB_BLANK_NORMAL:
power = LCD_POWER_REDUCED;
break;
case FB_BLANK_VSYNC_SUSPEND:
power = LCD_POWER_REDUCED_VSYNC_SUSPEND;
break;
/* 'off' */
case FB_BLANK_HSYNC_SUSPEND:
case FB_BLANK_POWERDOWN:
default:
power = LCD_POWER_OFF;
break;
}
lcd_notify_blank_all(info->device, power);
}
static void fb_ledtrig_backlight_notify_blank(struct fb_info *info)
{
if (info->blank == FB_BLANK_UNBLANK)
ledtrig_backlight_blank(false);
else
ledtrig_backlight_blank(true);
}
int fb_blank(struct fb_info *info, int blank)
{
int old_blank = info->blank;
int ret;
if (!info->fbops->fb_blank)
return -EINVAL;
if (blank > FB_BLANK_POWERDOWN)
blank = FB_BLANK_POWERDOWN;
event.info = info;
event.data = &blank;
info->blank = blank;
if (info->fbops->fb_blank)
ret = info->fbops->fb_blank(blank, info);
ret = info->fbops->fb_blank(blank, info);
if (ret)
goto err;
if (!ret)
fb_notifier_call_chain(FB_EVENT_BLANK, &event);
fb_bl_notify_blank(info, old_blank);
fb_lcd_notify_blank(info);
fb_ledtrig_backlight_notify_blank(info);
return 0;
err:
info->blank = old_blank;
return ret;
}
EXPORT_SYMBOL(fb_blank);
@ -416,6 +462,14 @@ static int do_register_framebuffer(struct fb_info *fb_info)
mutex_init(&fb_info->lock);
mutex_init(&fb_info->mm_lock);
/*
* With an fb_blank callback present, we assume that the
* display is blank, so that fb_blank() enables it on the
* first modeset.
*/
if (fb_info->fbops->fb_blank)
fb_info->blank = FB_BLANK_POWERDOWN;
fb_device_create(fb_info);
if (fb_info->pixmap.addr == NULL) {

8
drivers/video/fbdev/core/fbsysfs.c
View file

@ -242,11 +242,11 @@ static ssize_t store_blank(struct device *device,
return count;
}
static ssize_t show_blank(struct device *device,
struct device_attribute *attr, char *buf)
static ssize_t show_blank(struct device *device, struct device_attribute *attr, char *buf)
{
// struct fb_info *fb_info = dev_get_drvdata(device);
return 0;
struct fb_info *fb_info = dev_get_drvdata(device);
return sysfs_emit(buf, "%d\n", fb_info->blank);
}
static ssize_t store_console(struct device *device,

32
include/linux/backlight.h
View file

@ -12,7 +12,6 @@
#include <linux/device.h>
#include <linux/fb.h>
#include <linux/mutex.h>
#include <linux/notifier.h>
#include <linux/types.h>
/**
@ -278,11 +277,6 @@ struct backlight_device {
*/
const struct backlight_ops *ops;
/**
* @fb_notif: The framebuffer notifier block
*/
struct notifier_block fb_notif;
/**
* @entry: List entry of all registered backlight devices
*/
@ -294,15 +288,7 @@ struct backlight_device {
struct device dev;
/**
* @fb_bl_on: The state of individual fbdev's.
*
* Multiple fbdev's may share one backlight device. The fb_bl_on
* records the state of the individual fbdev.
*/
bool fb_bl_on[FB_MAX];
/**
* @use_count: The number of uses of fb_bl_on.
* @use_count: The number of unblanked displays.
*/
int use_count;
};
@ -408,6 +394,22 @@ struct backlight_device *backlight_device_get_by_type(enum backlight_type type);
int backlight_device_set_brightness(struct backlight_device *bd,
unsigned long brightness);
#if IS_REACHABLE(CONFIG_BACKLIGHT_CLASS_DEVICE)
void backlight_notify_blank(struct backlight_device *bd,
struct device *display_dev,
bool fb_on, bool prev_fb_on);
void backlight_notify_blank_all(struct device *display_dev,
bool fb_on, bool prev_fb_on);
#else
static inline void backlight_notify_blank(struct backlight_device *bd,
struct device *display_dev,
bool fb_on, bool prev_fb_on)
{ }
static inline void backlight_notify_blank_all(struct device *display_dev,
bool fb_on, bool prev_fb_on)
{ }
#endif
#define to_backlight_device(obj) container_of(obj, struct backlight_device, dev)
/**

12
include/linux/fb.h
View file

@ -129,18 +129,12 @@ struct fb_cursor_user {
* Register/unregister for framebuffer events
*/
/* The resolution of the passed in fb_info about to change */
#define FB_EVENT_MODE_CHANGE 0x01
#ifdef CONFIG_GUMSTIX_AM200EPD
/* only used by mach-pxa/am200epd.c */
#define FB_EVENT_FB_REGISTERED 0x05
#define FB_EVENT_FB_UNREGISTERED 0x06
#endif
/* A display blank is requested */
#define FB_EVENT_BLANK 0x09
struct fb_event {
struct fb_info *info;
void *data;
@ -472,6 +466,8 @@ struct fb_info {
struct list_head modelist; /* mode list */
struct fb_videomode *mode; /* current mode */
int blank; /* current blanking; see FB_BLANK_ constants */
#if IS_ENABLED(CONFIG_FB_BACKLIGHT)
/* assigned backlight device */
/* set before framebuffer registration,
@ -756,11 +752,15 @@ extern void fb_bl_default_curve(struct fb_info *fb_info, u8 off, u8 min, u8 max)
#if IS_ENABLED(CONFIG_FB_BACKLIGHT)
struct backlight_device *fb_bl_device(struct fb_info *info);
void fb_bl_notify_blank(struct fb_info *info, int old_blank);
#else
static inline struct backlight_device *fb_bl_device(struct fb_info *info)
{
return NULL;
}
static inline void fb_bl_notify_blank(struct fb_info *info, int old_blank)
{ }
#endif
static inline struct lcd_device *fb_lcd_device(struct fb_info *info)

21
include/linux/lcd.h
View file

@ -11,7 +11,6 @@
#include <linux/device.h>
#include <linux/mutex.h>
#include <linux/notifier.h>
#define LCD_POWER_ON (0)
#define LCD_POWER_REDUCED (1) // deprecated; don't use in new code
@ -79,8 +78,11 @@ struct lcd_device {
const struct lcd_ops *ops;
/* Serialise access to set_power method */
struct mutex update_lock;
/* The framebuffer notifier block */
struct notifier_block fb_notif;
/**
* @entry: List entry of all registered lcd devices
*/
struct list_head entry;
struct device dev;
};
@ -125,6 +127,19 @@ extern void lcd_device_unregister(struct lcd_device *ld);
extern void devm_lcd_device_unregister(struct device *dev,
struct lcd_device *ld);
#if IS_REACHABLE(CONFIG_LCD_CLASS_DEVICE)
void lcd_notify_blank_all(struct device *display_dev, int power);
void lcd_notify_mode_change_all(struct device *display_dev,
unsigned int width, unsigned int height);
#else
static inline void lcd_notify_blank_all(struct device *display_dev, int power)
{}
static inline void lcd_notify_mode_change_all(struct device *display_dev,
unsigned int width, unsigned int height)
{}
#endif
#define to_lcd_device(obj) container_of(obj, struct lcd_device, dev)
static inline void * lcd_get_data(struct lcd_device *ld_dev)

6
include/linux/leds.h
View file

@ -640,6 +640,12 @@ static inline void ledtrig_flash_ctrl(bool on) {}
static inline void ledtrig_torch_ctrl(bool on) {}
#endif
#if IS_REACHABLE(CONFIG_LEDS_TRIGGER_BACKLIGHT)
void ledtrig_backlight_blank(bool blank);
#else
static inline void ledtrig_backlight_blank(bool blank) {}
#endif
/*
* Generic LED platform data for describing LED names and default triggers.
*/