src/backlight/backlight.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2013 Lennart Poettering
   5
   6   systemd is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as published by
   8   the Free Software Foundation; either version 2.1 of the License, or
   9   (at your option) any later version.
  10
  11   systemd is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   Lesser General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  18 ***/
  19
  20 #include "libudev.h"
  21
  22 #include "alloc-util.h"
  23 #include "def.h"
  24 #include "escape.h"
  25 #include "fileio.h"
  26 #include "mkdir.h"
  27 #include "parse-util.h"
  28 #include "proc-cmdline.h"
  29 #include "string-util.h"
  30 #include "udev-util.h"
  31 #include "util.h"
  32
  33 static struct udev_device *find_pci_or_platform_parent(struct udev_device *device) {
  34         struct udev_device *parent;
  35         const char *subsystem, *sysname;
  36
  37         assert(device);
  38
  39         parent = udev_device_get_parent(device);
  40         if (!parent)
  41                 return NULL;
  42
  43         subsystem = udev_device_get_subsystem(parent);
  44         if (!subsystem)
  45                 return NULL;
  46
  47         sysname = udev_device_get_sysname(parent);
  48         if (!sysname)
  49                 return NULL;
  50
  51         if (streq(subsystem, "drm")) {
  52                 const char *c;
  53
  54                 c = startswith(sysname, "card");
  55                 if (!c)
  56                         return NULL;
  57
  58                 c += strspn(c, DIGITS);
  59                 if (*c == '-') {
  60                         /* A connector DRM device, let's ignore all but LVDS and eDP! */
  61
  62                         if (!startswith(c, "-LVDS-") &&
  63                             !startswith(c, "-Embedded DisplayPort-"))
  64                                 return NULL;
  65                 }
  66
  67         } else if (streq(subsystem, "pci")) {
  68                 const char *value;
  69
  70                 value = udev_device_get_sysattr_value(parent, "class");
  71                 if (value) {
  72                         unsigned long class = 0;
  73
  74                         if (safe_atolu(value, &class) < 0) {
  75                                 log_warning("Cannot parse PCI class %s of device %s:%s.",
  76                                             value, subsystem, sysname);
  77                                 return NULL;
  78                         }
  79
  80                         /* Graphics card */
  81                         if (class == 0x30000)
  82                                 return parent;
  83                 }
  84
  85         } else if (streq(subsystem, "platform"))
  86                 return parent;
  87
  88         return find_pci_or_platform_parent(parent);
  89 }
  90
  91 static bool same_device(struct udev_device *a, struct udev_device *b) {
  92         assert(a);
  93         assert(b);
  94
  95         if (!streq_ptr(udev_device_get_subsystem(a), udev_device_get_subsystem(b)))
  96                 return false;
  97
  98         if (!streq_ptr(udev_device_get_sysname(a), udev_device_get_sysname(b)))
  99                 return false;
 100
 101         return true;
 102 }
 103
 104 static bool validate_device(struct udev *udev, struct udev_device *device) {
 105         _cleanup_udev_enumerate_unref_ struct udev_enumerate *enumerate = NULL;
 106         struct udev_list_entry *item = NULL, *first = NULL;
 107         struct udev_device *parent;
 108         const char *v, *subsystem;
 109         int r;
 110
 111         assert(udev);
 112         assert(device);
 113
 114         /* Verify whether we should actually care for a specific
 115          * backlight device. For backlight devices there might be
 116          * multiple ways to access the same control: "firmware"
 117          * (i.e. ACPI), "platform" (i.e. via the machine's EC) and
 118          * "raw" (via the graphics card). In general we should prefer
 119          * "firmware" (i.e. ACPI) or "platform" access over "raw"
 120          * access, in order not to confuse the BIOS/EC, and
 121          * compatibility with possible low-level hotkey handling of
 122          * screen brightness. The kernel will already make sure to
 123          * expose only one of "firmware" and "platform" for the same
 124          * device to userspace. However, we still need to make sure
 125          * that we use "raw" only if no "firmware" or "platform"
 126          * device for the same device exists. */
 127
 128         subsystem = udev_device_get_subsystem(device);
 129         if (!streq_ptr(subsystem, "backlight"))
 130                 return true;
 131
 132         v = udev_device_get_sysattr_value(device, "type");
 133         if (!streq_ptr(v, "raw"))
 134                 return true;
 135
 136         parent = find_pci_or_platform_parent(device);
 137         if (!parent)
 138                 return true;
 139
 140         subsystem = udev_device_get_subsystem(parent);
 141         if (!subsystem)
 142                 return true;
 143
 144         enumerate = udev_enumerate_new(udev);
 145         if (!enumerate)
 146                 return true;
 147
 148         r = udev_enumerate_add_match_subsystem(enumerate, "backlight");
 149         if (r < 0)
 150                 return true;
 151
 152         r = udev_enumerate_scan_devices(enumerate);
 153         if (r < 0)
 154                 return true;
 155
 156         first = udev_enumerate_get_list_entry(enumerate);
 157         udev_list_entry_foreach(item, first) {
 158                 _cleanup_udev_device_unref_ struct udev_device *other;
 159                 struct udev_device *other_parent;
 160                 const char *other_subsystem;
 161
 162                 other = udev_device_new_from_syspath(udev, udev_list_entry_get_name(item));
 163                 if (!other)
 164                         return true;
 165
 166                 if (same_device(device, other))
 167                         continue;
 168
 169                 v = udev_device_get_sysattr_value(other, "type");
 170                 if (!streq_ptr(v, "platform") && !streq_ptr(v, "firmware"))
 171                         continue;
 172
 173                 /* OK, so there's another backlight device, and it's a
 174                  * platform or firmware device, so, let's see if we
 175                  * can verify it belongs to the same device as
 176                  * ours. */
 177                 other_parent = find_pci_or_platform_parent(other);
 178                 if (!other_parent)
 179                         continue;
 180
 181                 if (same_device(parent, other_parent)) {
 182                         /* Both have the same PCI parent, that means
 183                          * we are out. */
 184                         log_debug("Skipping backlight device %s, since device %s is on same PCI device and takes precedence.",
 185                                   udev_device_get_sysname(device),
 186                                   udev_device_get_sysname(other));
 187                         return false;
 188                 }
 189
 190                 other_subsystem = udev_device_get_subsystem(other_parent);
 191                 if (streq_ptr(other_subsystem, "platform") && streq_ptr(subsystem, "pci")) {
 192                         /* The other is connected to the platform bus
 193                          * and we are a PCI device, that also means we
 194                          * are out. */
 195                         log_debug("Skipping backlight device %s, since device %s is a platform device and takes precedence.",
 196                                   udev_device_get_sysname(device),
 197                                   udev_device_get_sysname(other));
 198                         return false;
 199                 }
 200         }
 201
 202         return true;
 203 }
 204
 205 static unsigned get_max_brightness(struct udev_device *device) {
 206         int r;
 207         const char *max_brightness_str;
 208         unsigned max_brightness;
 209
 210         max_brightness_str = udev_device_get_sysattr_value(device, "max_brightness");
 211         if (!max_brightness_str) {
 212                 log_warning("Failed to read 'max_brightness' attribute.");
 213                 return 0;
 214         }
 215
 216         r = safe_atou(max_brightness_str, &max_brightness);
 217         if (r < 0) {
 218                 log_warning_errno(r, "Failed to parse 'max_brightness' \"%s\": %m", max_brightness_str);
 219                 return 0;
 220         }
 221
 222         if (max_brightness <= 0) {
 223                 log_warning("Maximum brightness is 0, ignoring device.");
 224                 return 0;
 225         }
 226
 227         return max_brightness;
 228 }
 229
 230 /* Some systems turn the backlight all the way off at the lowest levels.
 231  * clamp_brightness clamps the saved brightness to at least 1 or 5% of
 232  * max_brightness in case of 'backlight' subsystem. This avoids preserving
 233  * an unreadably dim screen, which would otherwise force the user to
 234  * disable state restoration. */
 235 static void clamp_brightness(struct udev_device *device, char **value, unsigned max_brightness) {
 236         int r;
 237         unsigned brightness, new_brightness, min_brightness;
 238         const char *subsystem;
 239
 240         r = safe_atou(*value, &brightness);
 241         if (r < 0) {
 242                 log_warning_errno(r, "Failed to parse brightness \"%s\": %m", *value);
 243                 return;
 244         }
 245
 246         subsystem = udev_device_get_subsystem(device);
 247         if (streq_ptr(subsystem, "backlight"))
 248                 min_brightness = MAX(1U, max_brightness/20);
 249         else
 250                 min_brightness = 0;
 251
 252         new_brightness = CLAMP(brightness, min_brightness, max_brightness);
 253         if (new_brightness != brightness) {
 254                 char *old_value = *value;
 255
 256                 r = asprintf(value, "%u", new_brightness);
 257                 if (r < 0) {
 258                         log_oom();
 259                         return;
 260                 }
 261
 262                 log_info("Saved brightness %s %s to %s.", old_value,
 263                          new_brightness > brightness ?
 264                          "too low; increasing" : "too high; decreasing",
 265                          *value);
 266
 267                 free(old_value);
 268         }
 269 }
 270
 271 int main(int argc, char *argv[]) {
 272         _cleanup_udev_unref_ struct udev *udev = NULL;
 273         _cleanup_udev_device_unref_ struct udev_device *device = NULL;
 274         _cleanup_free_ char *saved = NULL, *ss = NULL, *escaped_ss = NULL, *escaped_sysname = NULL, *escaped_path_id = NULL;
 275         const char *sysname, *path_id;
 276         unsigned max_brightness;
 277         int r;
 278
 279         if (argc != 3) {
 280                 log_error("This program requires two arguments.");
 281                 return EXIT_FAILURE;
 282         }
 283
 284         log_set_target(LOG_TARGET_AUTO);
 285         log_parse_environment();
 286         log_open();
 287
 288         umask(0022);
 289
 290         r = mkdir_p("/var/lib/systemd/backlight", 0755);
 291         if (r < 0) {
 292                 log_error_errno(r, "Failed to create backlight directory /var/lib/systemd/backlight: %m");
 293                 return EXIT_FAILURE;
 294         }
 295
 296         udev = udev_new();
 297         if (!udev) {
 298                 log_oom();
 299                 return EXIT_FAILURE;
 300         }
 301
 302         sysname = strchr(argv[2], ':');
 303         if (!sysname) {
 304                 log_error("Requires a subsystem and sysname pair specifying a backlight device.");
 305                 return EXIT_FAILURE;
 306         }
 307
 308         ss = strndup(argv[2], sysname - argv[2]);
 309         if (!ss) {
 310                 log_oom();
 311                 return EXIT_FAILURE;
 312         }
 313
 314         sysname++;
 315
 316         if (!streq(ss, "backlight") && !streq(ss, "leds")) {
 317                 log_error("Not a backlight or LED device: '%s:%s'", ss, sysname);
 318                 return EXIT_FAILURE;
 319         }
 320
 321         errno = 0;
 322         device = udev_device_new_from_subsystem_sysname(udev, ss, sysname);
 323         if (!device) {
 324                 if (errno > 0)
 325                         log_error_errno(errno, "Failed to get backlight or LED device '%s:%s': %m", ss, sysname);
 326                 else
 327                         log_oom();
 328
 329                 return EXIT_FAILURE;
 330         }
 331
 332         /* If max_brightness is 0, then there is no actual backlight
 333          * device. This happens on desktops with Asus mainboards
 334          * that load the eeepc-wmi module.
 335          */
 336         max_brightness = get_max_brightness(device);
 337         if (max_brightness == 0)
 338                 return EXIT_SUCCESS;
 339
 340         escaped_ss = cescape(ss);
 341         if (!escaped_ss) {
 342                 log_oom();
 343                 return EXIT_FAILURE;
 344         }
 345
 346         escaped_sysname = cescape(sysname);
 347         if (!escaped_sysname) {
 348                 log_oom();
 349                 return EXIT_FAILURE;
 350         }
 351
 352         path_id = udev_device_get_property_value(device, "ID_PATH");
 353         if (path_id) {
 354                 escaped_path_id = cescape(path_id);
 355                 if (!escaped_path_id) {
 356                         log_oom();
 357                         return EXIT_FAILURE;
 358                 }
 359
 360                 saved = strjoin("/var/lib/systemd/backlight/", escaped_path_id, ":", escaped_ss, ":", escaped_sysname, NULL);
 361         } else
 362                 saved = strjoin("/var/lib/systemd/backlight/", escaped_ss, ":", escaped_sysname, NULL);
 363
 364         if (!saved) {
 365                 log_oom();
 366                 return EXIT_FAILURE;
 367         }
 368
 369         /* If there are multiple conflicting backlight devices, then
 370          * their probing at boot-time might happen in any order. This
 371          * means the validity checking of the device then is not
 372          * reliable, since it might not see other devices conflicting
 373          * with a specific backlight. To deal with this, we will
 374          * actively delete backlight state files at shutdown (where
 375          * device probing should be complete), so that the validity
 376          * check at boot time doesn't have to be reliable. */
 377
 378         if (streq(argv[1], "load")) {
 379                 _cleanup_free_ char *value = NULL;
 380                 const char *clamp;
 381
 382                 if (shall_restore_state() == 0)
 383                         return EXIT_SUCCESS;
 384
 385                 if (!validate_device(udev, device))
 386                         return EXIT_SUCCESS;
 387
 388                 r = read_one_line_file(saved, &value);
 389                 if (r < 0) {
 390
 391                         if (r == -ENOENT)
 392                                 return EXIT_SUCCESS;
 393
 394                         log_error_errno(r, "Failed to read %s: %m", saved);
 395                         return EXIT_FAILURE;
 396                 }
 397
 398                 clamp = udev_device_get_property_value(device, "ID_BACKLIGHT_CLAMP");
 399                 if (!clamp || parse_boolean(clamp) != 0) /* default to clamping */
 400                         clamp_brightness(device, &value, max_brightness);
 401
 402                 r = udev_device_set_sysattr_value(device, "brightness", value);
 403                 if (r < 0) {
 404                         log_error_errno(r, "Failed to write system 'brightness' attribute: %m");
 405                         return EXIT_FAILURE;
 406                 }
 407
 408         } else if (streq(argv[1], "save")) {
 409                 const char *value;
 410
 411                 if (!validate_device(udev, device)) {
 412                         unlink(saved);
 413                         return EXIT_SUCCESS;
 414                 }
 415
 416                 value = udev_device_get_sysattr_value(device, "brightness");
 417                 if (!value) {
 418                         log_error("Failed to read system 'brightness' attribute");
 419                         return EXIT_FAILURE;
 420                 }
 421
 422                 r = write_string_file(saved, value, WRITE_STRING_FILE_CREATE);
 423                 if (r < 0) {
 424                         log_error_errno(r, "Failed to write %s: %m", saved);
 425                         return EXIT_FAILURE;
 426                 }
 427
 428         } else {
 429                 log_error("Unknown verb %s.", argv[1]);
 430                 return EXIT_FAILURE;
 431         }
 432
 433         return EXIT_SUCCESS;
 434 }