1 /* SPDX-License-Identifier: LGPL-2.1+ */
9 #include "alloc-util.h"
10 #include "device-util.h"
13 #include "main-func.h"
15 #include "parse-util.h"
16 #include "proc-cmdline.h"
17 #include "string-util.h"
21 static int find_pci_or_platform_parent(sd_device
*device
, sd_device
**ret
) {
22 const char *subsystem
, *sysname
, *value
;
29 r
= sd_device_get_parent(device
, &parent
);
33 r
= sd_device_get_subsystem(parent
, &subsystem
);
37 r
= sd_device_get_sysname(parent
, &sysname
);
41 if (streq(subsystem
, "drm")) {
44 c
= startswith(sysname
, "card");
48 c
+= strspn(c
, DIGITS
);
50 /* A connector DRM device, let's ignore all but LVDS and eDP! */
51 if (!STARTSWITH_SET(c
, "-LVDS-", "-Embedded DisplayPort-"))
55 } else if (streq(subsystem
, "pci") &&
56 sd_device_get_sysattr_value(parent
, "class", &value
) >= 0) {
57 unsigned long class = 0;
59 r
= safe_atolu(value
, &class);
61 return log_warning_errno(r
, "Cannot parse PCI class '%s' of device %s:%s: %m",
62 value
, subsystem
, sysname
);
65 if (class == 0x30000) {
70 } else if (streq(subsystem
, "platform")) {
75 return find_pci_or_platform_parent(parent
, ret
);
78 static int same_device(sd_device
*a
, sd_device
*b
) {
79 const char *a_val
, *b_val
;
85 r
= sd_device_get_subsystem(a
, &a_val
);
89 r
= sd_device_get_subsystem(b
, &b_val
);
93 if (!streq(a_val
, b_val
))
96 r
= sd_device_get_sysname(a
, &a_val
);
100 r
= sd_device_get_sysname(b
, &b_val
);
104 return streq(a_val
, b_val
);
107 static int validate_device(sd_device
*device
) {
108 _cleanup_(sd_device_enumerator_unrefp
) sd_device_enumerator
*enumerate
= NULL
;
109 const char *v
, *subsystem
;
110 sd_device
*parent
, *other
;
115 /* Verify whether we should actually care for a specific
116 * backlight device. For backlight devices there might be
117 * multiple ways to access the same control: "firmware"
118 * (i.e. ACPI), "platform" (i.e. via the machine's EC) and
119 * "raw" (via the graphics card). In general we should prefer
120 * "firmware" (i.e. ACPI) or "platform" access over "raw"
121 * access, in order not to confuse the BIOS/EC, and
122 * compatibility with possible low-level hotkey handling of
123 * screen brightness. The kernel will already make sure to
124 * expose only one of "firmware" and "platform" for the same
125 * device to userspace. However, we still need to make sure
126 * that we use "raw" only if no "firmware" or "platform"
127 * device for the same device exists. */
129 r
= sd_device_get_subsystem(device
, &subsystem
);
132 if (!streq(subsystem
, "backlight"))
135 r
= sd_device_get_sysattr_value(device
, "type", &v
);
138 if (!streq(v
, "raw"))
141 r
= find_pci_or_platform_parent(device
, &parent
);
145 r
= sd_device_get_subsystem(parent
, &subsystem
);
149 r
= sd_device_enumerator_new(&enumerate
);
153 r
= sd_device_enumerator_allow_uninitialized(enumerate
);
157 r
= sd_device_enumerator_add_match_subsystem(enumerate
, "backlight", true);
161 FOREACH_DEVICE(enumerate
, other
) {
162 const char *other_subsystem
;
163 sd_device
*other_parent
;
165 if (same_device(device
, other
) > 0)
168 if (sd_device_get_sysattr_value(other
, "type", &v
) < 0 ||
169 !STR_IN_SET(v
, "platform", "firmware"))
172 /* OK, so there's another backlight device, and it's a
173 * platform or firmware device, so, let's see if we
174 * can verify it belongs to the same device as ours. */
175 if (find_pci_or_platform_parent(other
, &other_parent
) < 0)
178 if (same_device(parent
, other_parent
)) {
179 const char *device_sysname
= NULL
, *other_sysname
= NULL
;
181 /* Both have the same PCI parent, that means we are out. */
183 (void) sd_device_get_sysname(device
, &device_sysname
);
184 (void) sd_device_get_sysname(other
, &other_sysname
);
186 log_debug("Skipping backlight device %s, since device %s is on same PCI device and takes precedence.",
187 device_sysname
, other_sysname
);
191 if (sd_device_get_subsystem(other_parent
, &other_subsystem
) < 0)
194 if (streq(other_subsystem
, "platform") && streq(subsystem
, "pci")) {
195 const char *device_sysname
= NULL
, *other_sysname
= NULL
;
197 /* The other is connected to the platform bus and we are a PCI device, that also means we are out. */
199 (void) sd_device_get_sysname(device
, &device_sysname
);
200 (void) sd_device_get_sysname(other
, &other_sysname
);
202 log_debug("Skipping backlight device %s, since device %s is a platform device and takes precedence.",
203 device_sysname
, other_sysname
);
211 static int get_max_brightness(sd_device
*device
, unsigned *ret
) {
212 const char *max_brightness_str
;
213 unsigned max_brightness
;
219 r
= sd_device_get_sysattr_value(device
, "max_brightness", &max_brightness_str
);
221 return log_device_warning_errno(device
, r
, "Failed to read 'max_brightness' attribute: %m");
223 r
= safe_atou(max_brightness_str
, &max_brightness
);
225 return log_device_warning_errno(device
, r
, "Failed to parse 'max_brightness' \"%s\": %m", max_brightness_str
);
227 if (max_brightness
<= 0) {
228 log_device_warning(device
, "Maximum brightness is 0, ignoring device.");
232 *ret
= max_brightness
;
236 /* Some systems turn the backlight all the way off at the lowest levels.
237 * clamp_brightness clamps the saved brightness to at least 1 or 5% of
238 * max_brightness in case of 'backlight' subsystem. This avoids preserving
239 * an unreadably dim screen, which would otherwise force the user to
240 * disable state restoration. */
241 static int clamp_brightness(sd_device
*device
, char **value
, unsigned max_brightness
) {
242 unsigned brightness
, new_brightness
, min_brightness
;
243 const char *subsystem
;
249 r
= safe_atou(*value
, &brightness
);
251 return log_device_warning_errno(device
, r
, "Failed to parse brightness \"%s\": %m", *value
);
253 r
= sd_device_get_subsystem(device
, &subsystem
);
255 return log_device_warning_errno(device
, r
, "Failed to get device subsystem: %m");
257 if (streq(subsystem
, "backlight"))
258 min_brightness
= MAX(1U, max_brightness
/20);
262 new_brightness
= CLAMP(brightness
, min_brightness
, max_brightness
);
263 if (new_brightness
!= brightness
) {
266 r
= asprintf(&new_value
, "%u", new_brightness
);
270 log_device_info(device
, "Saved brightness %s %s to %s.", *value
,
271 new_brightness
> brightness
?
272 "too low; increasing" : "too high; decreasing",
275 free_and_replace(*value
, new_value
);
281 static bool shall_clamp(sd_device
*d
) {
287 r
= sd_device_get_property_value(d
, "ID_BACKLIGHT_CLAMP", &s
);
289 log_device_debug_errno(d
, r
, "Failed to get ID_BACKLIGHT_CLAMP property, ignoring: %m");
293 r
= parse_boolean(s
);
295 log_device_debug_errno(d
, r
, "Failed to parse ID_BACKLIGHT_CLAMP property, ignoring: %m");
302 static int run(int argc
, char *argv
[]) {
303 _cleanup_(sd_device_unrefp
) sd_device
*device
= NULL
;
304 _cleanup_free_
char *escaped_ss
= NULL
, *escaped_sysname
= NULL
, *escaped_path_id
= NULL
;
305 const char *sysname
, *path_id
, *ss
, *saved
;
306 unsigned max_brightness
;
310 log_error("This program requires two arguments.");
318 r
= mkdir_p("/var/lib/systemd/backlight", 0755);
320 return log_error_errno(r
, "Failed to create backlight directory /var/lib/systemd/backlight: %m");
322 sysname
= strchr(argv
[2], ':');
324 log_error("Requires a subsystem and sysname pair specifying a backlight device.");
328 ss
= strndupa(argv
[2], sysname
- argv
[2]);
332 if (!STR_IN_SET(ss
, "backlight", "leds")) {
333 log_error("Not a backlight or LED device: '%s:%s'", ss
, sysname
);
337 r
= sd_device_new_from_subsystem_sysname(&device
, ss
, sysname
);
339 return log_error_errno(r
, "Failed to get backlight or LED device '%s:%s': %m", ss
, sysname
);
341 /* If max_brightness is 0, then there is no actual backlight
342 * device. This happens on desktops with Asus mainboards
343 * that load the eeepc-wmi module. */
344 if (get_max_brightness(device
, &max_brightness
) < 0)
347 escaped_ss
= cescape(ss
);
351 escaped_sysname
= cescape(sysname
);
352 if (!escaped_sysname
)
355 if (sd_device_get_property_value(device
, "ID_PATH", &path_id
) >= 0) {
356 escaped_path_id
= cescape(path_id
);
357 if (!escaped_path_id
)
360 saved
= strjoina("/var/lib/systemd/backlight/", escaped_path_id
, ":", escaped_ss
, ":", escaped_sysname
);
362 saved
= strjoina("/var/lib/systemd/backlight/", escaped_ss
, ":", escaped_sysname
);
364 /* If there are multiple conflicting backlight devices, then
365 * their probing at boot-time might happen in any order. This
366 * means the validity checking of the device then is not
367 * reliable, since it might not see other devices conflicting
368 * with a specific backlight. To deal with this, we will
369 * actively delete backlight state files at shutdown (where
370 * device probing should be complete), so that the validity
371 * check at boot time doesn't have to be reliable. */
373 if (streq(argv
[1], "load")) {
374 _cleanup_free_
char *value
= NULL
;
377 if (shall_restore_state() == 0)
380 if (validate_device(device
) == 0)
383 clamp
= shall_clamp(device
);
385 r
= read_one_line_file(saved
, &value
);
386 if (IN_SET(r
, -ENOENT
, 0)) {
389 /* Fallback to clamping current brightness or exit early if
390 * clamping is not supported/enabled. */
394 r
= sd_device_get_sysattr_value(device
, "brightness", &curval
);
396 return log_device_warning_errno(device
, r
, "Failed to read 'brightness' attribute: %m");
398 value
= strdup(curval
);
402 return log_error_errno(r
, "Failed to read %s: %m", saved
);
405 (void) clamp_brightness(device
, &value
, max_brightness
);
407 r
= sd_device_set_sysattr_value(device
, "brightness", value
);
409 return log_device_error_errno(device
, r
, "Failed to write system 'brightness' attribute: %m");
411 } else if (streq(argv
[1], "save")) {
414 if (validate_device(device
) == 0) {
415 (void) unlink(saved
);
419 r
= sd_device_get_sysattr_value(device
, "brightness", &value
);
421 return log_device_error_errno(device
, r
, "Failed to read system 'brightness' attribute: %m");
423 r
= write_string_file(saved
, value
, WRITE_STRING_FILE_CREATE
);
425 return log_device_error_errno(device
, r
, "Failed to write %s: %m", saved
);
428 log_error("Unknown verb %s.", argv
[1]);
435 DEFINE_MAIN_FUNCTION(run
);