Commit a9dfb7db authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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()
parents b546608e e12d3e16

drivers/leds/trigger/ledtrig-backlight.c

+23 −25
Original line number Diff line number Diff line
@@ -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,9 +43,19 @@ 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);

}

drivers/video/backlight/backlight.c

+20 −73
Original line number Diff line number Diff line
@@ -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;



	fb_blank = *(int *)evdata->data;

	if (fb_blank == FB_BLANK_UNBLANK && !bd->fb_bl_on[node]) {

		bd->fb_bl_on[node] = true;

		return;

	if (bd->ops->controls_device && !bd->ops->controls_device(bd, display_dev))

		return;



	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);

}

#else

static inline int backlight_register_fb(struct backlight_device *bd)

{

	return 0;

	list_for_each_entry(bd, &backlight_dev_list, entry)

		backlight_notify_blank(bd, display_dev, fb_on, prev_fb_on);

}



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);

drivers/video/backlight/lcd.c

+40 −68
Original line number Diff line number Diff line
@@ -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 (event == FB_EVENT_BLANK) {

		int power = to_lcd_power(*(int *)evdata->data);

	if (!ld->ops || !ld->ops->set_power)

		return;

	if (ld->ops->controls_device && !ld->ops->controls_device(ld, display_dev))

		return;



		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;

}



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;



static void lcd_unregister_fb(struct lcd_device *ld)

{

	fb_unregister_client(&ld->fb_notif);

	guard(mutex)(&lcd_dev_list_mutex);



	list_for_each_entry(ld, &lcd_dev_list, entry)

		lcd_notify_blank(ld, display_dev, power);

}

#else

static int lcd_register_fb(struct lcd_device *ld)

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)

{

	return 0;

	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 inline void lcd_unregister_fb(struct lcd_device *ld)

void lcd_notify_mode_change_all(struct device *display_dev,

				unsigned int width, unsigned int height)

{

	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);

}

drivers/video/backlight/qcom-wled.c

+4 −2
Original line number Diff line number Diff line
@@ -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;

drivers/video/fbdev/core/fb_backlight.c

+12 −0
Original line number Diff line number Diff line 
// 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