| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| Joshua Grisham | 5841 | 100.00% | 3 | 100.00% |
| Total | 5841 | 3 |
// SPDX-License-Identifier: GPL-2.0-or-later /* * Samsung Galaxy Book driver * * Copyright (c) 2025 Joshua Grisham <josh@joshuagrisham.com> * * With contributions to the SCAI ACPI device interface: * Copyright (c) 2024 Giulio Girardi <giulio.girardi@protechgroup.it> * * Implementation inspired by existing x86 platform drivers. * Thank you to the authors! */ #include <linux/acpi.h> #include <linux/bits.h> #include <linux/err.h> #include <linux/i8042.h> #include <linux/init.h> #include <linux/input.h> #include <linux/kernel.h> #include <linux/leds.h> #include <linux/module.h> #include <linux/mutex.h> #include <linux/platform_device.h> #include <linux/platform_profile.h> #include <linux/serio.h> #include <linux/sysfs.h> #include <linux/uuid.h> #include <linux/workqueue.h> #include <acpi/battery.h> #include "firmware_attributes_class.h" #define DRIVER_NAME "samsung-galaxybook" struct samsung_galaxybook { struct platform_device *platform; struct acpi_device *acpi; struct device *fw_attrs_dev; struct kset *fw_attrs_kset; /* block in case firmware attributes are updated in multiple threads */ struct mutex fw_attr_lock; bool has_kbd_backlight; bool has_block_recording; bool has_performance_mode; struct led_classdev kbd_backlight; struct work_struct kbd_backlight_hotkey_work; /* block in case brightness updated using hotkey and another thread */ struct mutex kbd_backlight_lock; void *i8042_filter_ptr; struct work_struct block_recording_hotkey_work; struct input_dev *camera_lens_cover_switch; struct acpi_battery_hook battery_hook; u8 profile_performance_modes[PLATFORM_PROFILE_LAST]; }; enum galaxybook_fw_attr_id { GB_ATTR_POWER_ON_LID_OPEN, GB_ATTR_USB_CHARGING, GB_ATTR_BLOCK_RECORDING, }; static const char * const galaxybook_fw_attr_name[] = { [GB_ATTR_POWER_ON_LID_OPEN] = "power_on_lid_open", [GB_ATTR_USB_CHARGING] = "usb_charging", [GB_ATTR_BLOCK_RECORDING] = "block_recording", }; static const char * const galaxybook_fw_attr_desc[] = { [GB_ATTR_POWER_ON_LID_OPEN] = "Power On Lid Open", [GB_ATTR_USB_CHARGING] = "USB Charging", [GB_ATTR_BLOCK_RECORDING] = "Block Recording", }; #define GB_ATTR_LANGUAGE_CODE "en_US.UTF-8" struct galaxybook_fw_attr { struct samsung_galaxybook *galaxybook; enum galaxybook_fw_attr_id fw_attr_id; struct attribute_group attr_group; struct kobj_attribute display_name; struct kobj_attribute current_value; int (*get_value)(struct samsung_galaxybook *galaxybook, bool *value); int (*set_value)(struct samsung_galaxybook *galaxybook, const bool value); }; struct sawb { u16 safn; u16 sasb; u8 rflg; union { struct { u8 gunm; u8 guds[250]; } __packed; struct { u8 caid[16]; u8 fncn; u8 subn; u8 iob0; u8 iob1; u8 iob2; u8 iob3; u8 iob4; u8 iob5; u8 iob6; u8 iob7; u8 iob8; u8 iob9; } __packed; struct { u8 iob_prefix[18]; u8 iobs[10]; } __packed; } __packed; } __packed; #define GB_SAWB_LEN_SETTINGS 0x15 #define GB_SAWB_LEN_PERFORMANCE_MODE 0x100 #define GB_SAFN 0x5843 #define GB_SASB_KBD_BACKLIGHT 0x78 #define GB_SASB_POWER_MANAGEMENT 0x7a #define GB_SASB_USB_CHARGING_GET 0x67 #define GB_SASB_USB_CHARGING_SET 0x68 #define GB_SASB_NOTIFICATIONS 0x86 #define GB_SASB_BLOCK_RECORDING 0x8a #define GB_SASB_PERFORMANCE_MODE 0x91 #define GB_SAWB_RFLG_POS 4 #define GB_SAWB_GB_GUNM_POS 5 #define GB_RFLG_SUCCESS 0xaa #define GB_GUNM_FAIL 0xff #define GB_GUNM_FEATURE_ENABLE 0xbb #define GB_GUNM_FEATURE_ENABLE_SUCCESS 0xdd #define GB_GUDS_FEATURE_ENABLE 0xaa #define GB_GUDS_FEATURE_ENABLE_SUCCESS 0xcc #define GB_GUNM_GET 0x81 #define GB_GUNM_SET 0x82 #define GB_GUNM_POWER_MANAGEMENT 0x82 #define GB_GUNM_USB_CHARGING_GET 0x80 #define GB_GUNM_USB_CHARGING_ON 0x81 #define GB_GUNM_USB_CHARGING_OFF 0x80 #define GB_GUDS_POWER_ON_LID_OPEN 0xa3 #define GB_GUDS_POWER_ON_LID_OPEN_GET 0x81 #define GB_GUDS_POWER_ON_LID_OPEN_SET 0x80 #define GB_GUDS_BATTERY_CHARGE_CONTROL 0xe9 #define GB_GUDS_BATTERY_CHARGE_CONTROL_GET 0x91 #define GB_GUDS_BATTERY_CHARGE_CONTROL_SET 0x90 #define GB_GUNM_ACPI_NOTIFY_ENABLE 0x80 #define GB_GUDS_ACPI_NOTIFY_ENABLE 0x02 #define GB_BLOCK_RECORDING_ON 0x0 #define GB_BLOCK_RECORDING_OFF 0x1 #define GB_FNCN_PERFORMANCE_MODE 0x51 #define GB_SUBN_PERFORMANCE_MODE_LIST 0x01 #define GB_SUBN_PERFORMANCE_MODE_GET 0x02 #define GB_SUBN_PERFORMANCE_MODE_SET 0x03 /* guid 8246028d-8bca-4a55-ba0f-6f1e6b921b8f */ static const guid_t performance_mode_guid = GUID_INIT(0x8246028d, 0x8bca, 0x4a55, 0xba, 0x0f, 0x6f, 0x1e, 0x6b, 0x92, 0x1b, 0x8f); #define GB_PERFORMANCE_MODE_GUID performance_mode_guid #define GB_PERFORMANCE_MODE_FANOFF 0xb #define GB_PERFORMANCE_MODE_LOWNOISE 0xa #define GB_PERFORMANCE_MODE_OPTIMIZED 0x0 #define GB_PERFORMANCE_MODE_OPTIMIZED_V2 0x2 #define GB_PERFORMANCE_MODE_PERFORMANCE 0x1 #define GB_PERFORMANCE_MODE_PERFORMANCE_V2 0x15 #define GB_PERFORMANCE_MODE_ULTRA 0x16 #define GB_PERFORMANCE_MODE_IGNORE1 0x14 #define GB_PERFORMANCE_MODE_IGNORE2 0xc #define GB_ACPI_METHOD_ENABLE "SDLS" #define GB_ACPI_METHOD_ENABLE_ON 1 #define GB_ACPI_METHOD_ENABLE_OFF 0 #define GB_ACPI_METHOD_SETTINGS "CSFI" #define GB_ACPI_METHOD_PERFORMANCE_MODE "CSXI" #define GB_KBD_BACKLIGHT_MAX_BRIGHTNESS 3 #define GB_ACPI_NOTIFY_BATTERY_STATE_CHANGED 0x61 #define GB_ACPI_NOTIFY_DEVICE_ON_TABLE 0x6c #define GB_ACPI_NOTIFY_DEVICE_OFF_TABLE 0x6d #define GB_ACPI_NOTIFY_HOTKEY_PERFORMANCE_MODE 0x70 #define GB_KEY_KBD_BACKLIGHT_KEYDOWN 0x2c #define GB_KEY_KBD_BACKLIGHT_KEYUP 0xac #define GB_KEY_BLOCK_RECORDING_KEYDOWN 0x1f #define GB_KEY_BLOCK_RECORDING_KEYUP 0x9f #define GB_KEY_BATTERY_NOTIFY_KEYUP 0xf #define GB_KEY_BATTERY_NOTIFY_KEYDOWN 0x8f /* * Optional features which have been determined as not supported on a particular * device will return GB_NOT_SUPPORTED from their init function. Positive * EOPNOTSUPP is used as the underlying value instead of negative to * differentiate this return code from valid upstream failures. */ #define GB_NOT_SUPPORTED EOPNOTSUPP /* Galaxy Book feature not supported */ /* * ACPI method handling */ static int galaxybook_acpi_method(struct samsung_galaxybook *galaxybook, acpi_string method, struct sawb *buf, size_t len) { struct acpi_buffer output = {ACPI_ALLOCATE_BUFFER, NULL}; union acpi_object in_obj, *out_obj; struct acpi_object_list input; acpi_status status; int err; in_obj.type = ACPI_TYPE_BUFFER; in_obj.buffer.length = len; in_obj.buffer.pointer = (u8 *)buf; input.count = 1; input.pointer = &in_obj; status = acpi_evaluate_object_typed(galaxybook->acpi->handle, method, &input, &output, ACPI_TYPE_BUFFER); if (ACPI_FAILURE(status)) { dev_err(&galaxybook->acpi->dev, "failed to execute method %s; got %s\n", method, acpi_format_exception(status)); return -EIO; } out_obj = output.pointer; if (out_obj->buffer.length != len || out_obj->buffer.length < GB_SAWB_GB_GUNM_POS + 1) { dev_err(&galaxybook->acpi->dev, "failed to execute %s; response length mismatch\n", method); err = -EPROTO; goto out_free; } if (out_obj->buffer.pointer[GB_SAWB_RFLG_POS] != GB_RFLG_SUCCESS) { dev_err(&galaxybook->acpi->dev, "failed to execute %s; device did not respond with success code 0x%x\n", method, GB_RFLG_SUCCESS); err = -ENXIO; goto out_free; } if (out_obj->buffer.pointer[GB_SAWB_GB_GUNM_POS] == GB_GUNM_FAIL) { dev_err(&galaxybook->acpi->dev, "failed to execute %s; device responded with failure code 0x%x\n", method, GB_GUNM_FAIL); err = -ENXIO; goto out_free; } memcpy(buf, out_obj->buffer.pointer, len); err = 0; out_free: kfree(out_obj); return err; } static int galaxybook_enable_acpi_feature(struct samsung_galaxybook *galaxybook, const u16 sasb) { struct sawb buf = {}; int err; buf.safn = GB_SAFN; buf.sasb = sasb; buf.gunm = GB_GUNM_FEATURE_ENABLE; buf.guds[0] = GB_GUDS_FEATURE_ENABLE; err = galaxybook_acpi_method(galaxybook, GB_ACPI_METHOD_SETTINGS, &buf, GB_SAWB_LEN_SETTINGS); if (err) return err; if (buf.gunm != GB_GUNM_FEATURE_ENABLE_SUCCESS && buf.guds[0] != GB_GUDS_FEATURE_ENABLE_SUCCESS) return -ENODEV; return 0; } /* * Keyboard Backlight */ static int kbd_backlight_acpi_get(struct samsung_galaxybook *galaxybook, enum led_brightness *brightness) { struct sawb buf = {}; int err; buf.safn = GB_SAFN; buf.sasb = GB_SASB_KBD_BACKLIGHT; buf.gunm = GB_GUNM_GET; err = galaxybook_acpi_method(galaxybook, GB_ACPI_METHOD_SETTINGS, &buf, GB_SAWB_LEN_SETTINGS); if (err) return err; *brightness = buf.gunm; return 0; } static int kbd_backlight_acpi_set(struct samsung_galaxybook *galaxybook, const enum led_brightness brightness) { struct sawb buf = {}; buf.safn = GB_SAFN; buf.sasb = GB_SASB_KBD_BACKLIGHT; buf.gunm = GB_GUNM_SET; buf.guds[0] = brightness; return galaxybook_acpi_method(galaxybook, GB_ACPI_METHOD_SETTINGS, &buf, GB_SAWB_LEN_SETTINGS); } static enum led_brightness kbd_backlight_show(struct led_classdev *led) { struct samsung_galaxybook *galaxybook = container_of(led, struct samsung_galaxybook, kbd_backlight); enum led_brightness brightness; int err; err = kbd_backlight_acpi_get(galaxybook, &brightness); if (err) return err; return brightness; } static int kbd_backlight_store(struct led_classdev *led, const enum led_brightness brightness) { struct samsung_galaxybook *galaxybook = container_of_const(led, struct samsung_galaxybook, kbd_backlight); return kbd_backlight_acpi_set(galaxybook, brightness); } static int galaxybook_kbd_backlight_init(struct samsung_galaxybook *galaxybook) { struct led_init_data init_data = {}; enum led_brightness brightness; int err; err = devm_mutex_init(&galaxybook->platform->dev, &galaxybook->kbd_backlight_lock); if (err) return err; err = galaxybook_enable_acpi_feature(galaxybook, GB_SASB_KBD_BACKLIGHT); if (err) { dev_dbg(&galaxybook->platform->dev, "failed to enable kbd_backlight feature, error %d\n", err); return GB_NOT_SUPPORTED; } err = kbd_backlight_acpi_get(galaxybook, &brightness); if (err) { dev_dbg(&galaxybook->platform->dev, "failed to get initial kbd_backlight brightness, error %d\n", err); return GB_NOT_SUPPORTED; } init_data.devicename = DRIVER_NAME; init_data.default_label = ":" LED_FUNCTION_KBD_BACKLIGHT; init_data.devname_mandatory = true; galaxybook->kbd_backlight.brightness_get = kbd_backlight_show; galaxybook->kbd_backlight.brightness_set_blocking = kbd_backlight_store; galaxybook->kbd_backlight.flags = LED_BRIGHT_HW_CHANGED; galaxybook->kbd_backlight.max_brightness = GB_KBD_BACKLIGHT_MAX_BRIGHTNESS; return devm_led_classdev_register_ext(&galaxybook->platform->dev, &galaxybook->kbd_backlight, &init_data); } /* * Battery Extension (adds charge_control_end_threshold to the battery device) */ static int charge_control_end_threshold_acpi_get(struct samsung_galaxybook *galaxybook, u8 *value) { struct sawb buf = {}; int err; buf.safn = GB_SAFN; buf.sasb = GB_SASB_POWER_MANAGEMENT; buf.gunm = GB_GUNM_POWER_MANAGEMENT; buf.guds[0] = GB_GUDS_BATTERY_CHARGE_CONTROL; buf.guds[1] = GB_GUDS_BATTERY_CHARGE_CONTROL_GET; err = galaxybook_acpi_method(galaxybook, GB_ACPI_METHOD_SETTINGS, &buf, GB_SAWB_LEN_SETTINGS); if (err) return err; *value = buf.guds[1]; return 0; } static int charge_control_end_threshold_acpi_set(struct samsung_galaxybook *galaxybook, u8 value) { struct sawb buf = {}; buf.safn = GB_SAFN; buf.sasb = GB_SASB_POWER_MANAGEMENT; buf.gunm = GB_GUNM_POWER_MANAGEMENT; buf.guds[0] = GB_GUDS_BATTERY_CHARGE_CONTROL; buf.guds[1] = GB_GUDS_BATTERY_CHARGE_CONTROL_SET; buf.guds[2] = value; return galaxybook_acpi_method(galaxybook, GB_ACPI_METHOD_SETTINGS, &buf, GB_SAWB_LEN_SETTINGS); } static int galaxybook_battery_ext_property_get(struct power_supply *psy, const struct power_supply_ext *ext, void *ext_data, enum power_supply_property psp, union power_supply_propval *val) { struct samsung_galaxybook *galaxybook = ext_data; int err; if (psp != POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD) return -EINVAL; err = charge_control_end_threshold_acpi_get(galaxybook, (u8 *)&val->intval); if (err) return err; /* * device stores "no end threshold" as 0 instead of 100; * if device has 0, report 100 */ if (val->intval == 0) val->intval = 100; return 0; } static int galaxybook_battery_ext_property_set(struct power_supply *psy, const struct power_supply_ext *ext, void *ext_data, enum power_supply_property psp, const union power_supply_propval *val) { struct samsung_galaxybook *galaxybook = ext_data; u8 value; if (psp != POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD) return -EINVAL; value = val->intval; if (value < 1 || value > 100) return -EINVAL; /* * device stores "no end threshold" as 0 instead of 100; * if setting to 100, send 0 */ if (value == 100) value = 0; return charge_control_end_threshold_acpi_set(galaxybook, value); } static int galaxybook_battery_ext_property_is_writeable(struct power_supply *psy, const struct power_supply_ext *ext, void *ext_data, enum power_supply_property psp) { if (psp == POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD) return true; return false; } static const enum power_supply_property galaxybook_battery_properties[] = { POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD, }; static const struct power_supply_ext galaxybook_battery_ext = { .name = DRIVER_NAME, .properties = galaxybook_battery_properties, .num_properties = ARRAY_SIZE(galaxybook_battery_properties), .get_property = galaxybook_battery_ext_property_get, .set_property = galaxybook_battery_ext_property_set, .property_is_writeable = galaxybook_battery_ext_property_is_writeable, }; static int galaxybook_battery_add(struct power_supply *battery, struct acpi_battery_hook *hook) { struct samsung_galaxybook *galaxybook = container_of(hook, struct samsung_galaxybook, battery_hook); return power_supply_register_extension(battery, &galaxybook_battery_ext, &battery->dev, galaxybook); } static int galaxybook_battery_remove(struct power_supply *battery, struct acpi_battery_hook *hook) { power_supply_unregister_extension(battery, &galaxybook_battery_ext); return 0; } static int galaxybook_battery_threshold_init(struct samsung_galaxybook *galaxybook) { u8 value; int err; err = charge_control_end_threshold_acpi_get(galaxybook, &value); if (err) { dev_dbg(&galaxybook->platform->dev, "failed to get initial battery charge end threshold, error %d\n", err); return 0; } galaxybook->battery_hook.add_battery = galaxybook_battery_add; galaxybook->battery_hook.remove_battery = galaxybook_battery_remove; galaxybook->battery_hook.name = "Samsung Galaxy Book Battery Extension"; return devm_battery_hook_register(&galaxybook->platform->dev, &galaxybook->battery_hook); } /* * Platform Profile / Performance mode */ static int performance_mode_acpi_get(struct samsung_galaxybook *galaxybook, u8 *performance_mode) { struct sawb buf = {}; int err; buf.safn = GB_SAFN; buf.sasb = GB_SASB_PERFORMANCE_MODE; export_guid(buf.caid, &GB_PERFORMANCE_MODE_GUID); buf.fncn = GB_FNCN_PERFORMANCE_MODE; buf.subn = GB_SUBN_PERFORMANCE_MODE_GET; err = galaxybook_acpi_method(galaxybook, GB_ACPI_METHOD_PERFORMANCE_MODE, &buf, GB_SAWB_LEN_PERFORMANCE_MODE); if (err) return err; *performance_mode = buf.iob0; return 0; } static int performance_mode_acpi_set(struct samsung_galaxybook *galaxybook, const u8 performance_mode) { struct sawb buf = {}; buf.safn = GB_SAFN; buf.sasb = GB_SASB_PERFORMANCE_MODE; export_guid(buf.caid, &GB_PERFORMANCE_MODE_GUID); buf.fncn = GB_FNCN_PERFORMANCE_MODE; buf.subn = GB_SUBN_PERFORMANCE_MODE_SET; buf.iob0 = performance_mode; return galaxybook_acpi_method(galaxybook, GB_ACPI_METHOD_PERFORMANCE_MODE, &buf, GB_SAWB_LEN_PERFORMANCE_MODE); } static int get_performance_mode_profile(struct samsung_galaxybook *galaxybook, const u8 performance_mode, enum platform_profile_option *profile) { switch (performance_mode) { case GB_PERFORMANCE_MODE_FANOFF: *profile = PLATFORM_PROFILE_LOW_POWER; break; case GB_PERFORMANCE_MODE_LOWNOISE: *profile = PLATFORM_PROFILE_QUIET; break; case GB_PERFORMANCE_MODE_OPTIMIZED: case GB_PERFORMANCE_MODE_OPTIMIZED_V2: *profile = PLATFORM_PROFILE_BALANCED; break; case GB_PERFORMANCE_MODE_PERFORMANCE: case GB_PERFORMANCE_MODE_PERFORMANCE_V2: case GB_PERFORMANCE_MODE_ULTRA: *profile = PLATFORM_PROFILE_PERFORMANCE; break; case GB_PERFORMANCE_MODE_IGNORE1: case GB_PERFORMANCE_MODE_IGNORE2: return -EOPNOTSUPP; default: dev_warn(&galaxybook->platform->dev, "unrecognized performance mode 0x%x\n", performance_mode); return -EOPNOTSUPP; } return 0; } static int galaxybook_platform_profile_get(struct device *dev, enum platform_profile_option *profile) { struct samsung_galaxybook *galaxybook = dev_get_drvdata(dev); u8 performance_mode; int err; err = performance_mode_acpi_get(galaxybook, &performance_mode); if (err) return err; return get_performance_mode_profile(galaxybook, performance_mode, profile); } static int galaxybook_platform_profile_set(struct device *dev, enum platform_profile_option profile) { struct samsung_galaxybook *galaxybook = dev_get_drvdata(dev); return performance_mode_acpi_set(galaxybook, galaxybook->profile_performance_modes[profile]); } static int galaxybook_platform_profile_probe(void *drvdata, unsigned long *choices) { struct samsung_galaxybook *galaxybook = drvdata; u8 *perfmodes = galaxybook->profile_performance_modes; enum platform_profile_option profile; struct sawb buf = {}; unsigned int i; int err; buf.safn = GB_SAFN; buf.sasb = GB_SASB_PERFORMANCE_MODE; export_guid(buf.caid, &GB_PERFORMANCE_MODE_GUID); buf.fncn = GB_FNCN_PERFORMANCE_MODE; buf.subn = GB_SUBN_PERFORMANCE_MODE_LIST; err = galaxybook_acpi_method(galaxybook, GB_ACPI_METHOD_PERFORMANCE_MODE, &buf, GB_SAWB_LEN_PERFORMANCE_MODE); if (err) { dev_dbg(&galaxybook->platform->dev, "failed to get supported performance modes, error %d\n", err); return err; } /* set initial default profile performance mode values */ perfmodes[PLATFORM_PROFILE_LOW_POWER] = GB_PERFORMANCE_MODE_FANOFF; perfmodes[PLATFORM_PROFILE_QUIET] = GB_PERFORMANCE_MODE_LOWNOISE; perfmodes[PLATFORM_PROFILE_BALANCED] = GB_PERFORMANCE_MODE_OPTIMIZED; perfmodes[PLATFORM_PROFILE_PERFORMANCE] = GB_PERFORMANCE_MODE_PERFORMANCE; /* * Value returned in iob0 will have the number of supported performance * modes per device. The performance mode values will then be given as a * list after this (iob1-iobX). Loop through the supported values and * enable their mapped platform_profile choice, overriding "legacy" * values along the way if a non-legacy value exists. */ for (i = 1; i <= buf.iob0; i++) { err = get_performance_mode_profile(galaxybook, buf.iobs[i], &profile); if (err) { dev_dbg(&galaxybook->platform->dev, "ignoring unmapped performance mode 0x%x\n", buf.iobs[i]); continue; } switch (buf.iobs[i]) { case GB_PERFORMANCE_MODE_OPTIMIZED_V2: perfmodes[profile] = GB_PERFORMANCE_MODE_OPTIMIZED_V2; break; case GB_PERFORMANCE_MODE_PERFORMANCE_V2: /* only update if not already overwritten by Ultra */ if (perfmodes[profile] != GB_PERFORMANCE_MODE_ULTRA) perfmodes[profile] = GB_PERFORMANCE_MODE_PERFORMANCE_V2; break; case GB_PERFORMANCE_MODE_ULTRA: perfmodes[profile] = GB_PERFORMANCE_MODE_ULTRA; break; default: break; } set_bit(profile, choices); dev_dbg(&galaxybook->platform->dev, "setting platform profile %d to use performance mode 0x%x\n", profile, perfmodes[profile]); } /* initialize performance_mode using balanced's mapped value */ if (test_bit(PLATFORM_PROFILE_BALANCED, choices)) return performance_mode_acpi_set(galaxybook, perfmodes[PLATFORM_PROFILE_BALANCED]); return 0; } static const struct platform_profile_ops galaxybook_platform_profile_ops = { .probe = galaxybook_platform_profile_probe, .profile_get = galaxybook_platform_profile_get, .profile_set = galaxybook_platform_profile_set, }; static int galaxybook_platform_profile_init(struct samsung_galaxybook *galaxybook) { struct device *platform_profile_dev; u8 performance_mode; int err; err = performance_mode_acpi_get(galaxybook, &performance_mode); if (err) { dev_dbg(&galaxybook->platform->dev, "failed to get initial performance mode, error %d\n", err); return GB_NOT_SUPPORTED; } platform_profile_dev = devm_platform_profile_register(&galaxybook->platform->dev, DRIVER_NAME, galaxybook, &galaxybook_platform_profile_ops); return PTR_ERR_OR_ZERO(platform_profile_dev); } /* * Firmware Attributes */ /* Power on lid open (device should power on when lid is opened) */ static int power_on_lid_open_acpi_get(struct samsung_galaxybook *galaxybook, bool *value) { struct sawb buf = {}; int err; buf.safn = GB_SAFN; buf.sasb = GB_SASB_POWER_MANAGEMENT; buf.gunm = GB_GUNM_POWER_MANAGEMENT; buf.guds[0] = GB_GUDS_POWER_ON_LID_OPEN; buf.guds[1] = GB_GUDS_POWER_ON_LID_OPEN_GET; err = galaxybook_acpi_method(galaxybook, GB_ACPI_METHOD_SETTINGS, &buf, GB_SAWB_LEN_SETTINGS); if (err) return err; *value = buf.guds[1]; return 0; } static int power_on_lid_open_acpi_set(struct samsung_galaxybook *galaxybook, const bool value) { struct sawb buf = {}; lockdep_assert_held(&galaxybook->fw_attr_lock); buf.safn = GB_SAFN; buf.sasb = GB_SASB_POWER_MANAGEMENT; buf.gunm = GB_GUNM_POWER_MANAGEMENT; buf.guds[0] = GB_GUDS_POWER_ON_LID_OPEN; buf.guds[1] = GB_GUDS_POWER_ON_LID_OPEN_SET; buf.guds[2] = value ? 1 : 0; return galaxybook_acpi_method(galaxybook, GB_ACPI_METHOD_SETTINGS, &buf, GB_SAWB_LEN_SETTINGS); } /* USB Charging (USB ports can provide power when device is powered off) */ static int usb_charging_acpi_get(struct samsung_galaxybook *galaxybook, bool *value) { struct sawb buf = {}; int err; buf.safn = GB_SAFN; buf.sasb = GB_SASB_USB_CHARGING_GET; buf.gunm = GB_GUNM_USB_CHARGING_GET; err = galaxybook_acpi_method(galaxybook, GB_ACPI_METHOD_SETTINGS, &buf, GB_SAWB_LEN_SETTINGS); if (err) return err; *value = buf.gunm == 1; return 0; } static int usb_charging_acpi_set(struct samsung_galaxybook *galaxybook, const bool value) { struct sawb buf = {}; lockdep_assert_held(&galaxybook->fw_attr_lock); buf.safn = GB_SAFN; buf.sasb = GB_SASB_USB_CHARGING_SET; buf.gunm = value ? GB_GUNM_USB_CHARGING_ON : GB_GUNM_USB_CHARGING_OFF; return galaxybook_acpi_method(galaxybook, GB_ACPI_METHOD_SETTINGS, &buf, GB_SAWB_LEN_SETTINGS); } /* Block recording (blocks access to camera and microphone) */ static int block_recording_acpi_get(struct samsung_galaxybook *galaxybook, bool *value) { struct sawb buf = {}; int err; buf.safn = GB_SAFN; buf.sasb = GB_SASB_BLOCK_RECORDING; buf.gunm = GB_GUNM_GET; err = galaxybook_acpi_method(galaxybook, GB_ACPI_METHOD_SETTINGS, &buf, GB_SAWB_LEN_SETTINGS); if (err) return err; *value = buf.gunm == GB_BLOCK_RECORDING_ON; return 0; } static int block_recording_acpi_set(struct samsung_galaxybook *galaxybook, const bool value) { struct sawb buf = {}; int err; lockdep_assert_held(&galaxybook->fw_attr_lock); buf.safn = GB_SAFN; buf.sasb = GB_SASB_BLOCK_RECORDING; buf.gunm = GB_GUNM_SET; buf.guds[0] = value ? GB_BLOCK_RECORDING_ON : GB_BLOCK_RECORDING_OFF; err = galaxybook_acpi_method(galaxybook, GB_ACPI_METHOD_SETTINGS, &buf, GB_SAWB_LEN_SETTINGS); if (err) return err; input_report_switch(galaxybook->camera_lens_cover_switch, SW_CAMERA_LENS_COVER, value ? 1 : 0); input_sync(galaxybook->camera_lens_cover_switch); return 0; } static int galaxybook_block_recording_init(struct samsung_galaxybook *galaxybook) { bool value; int err; err = galaxybook_enable_acpi_feature(galaxybook, GB_SASB_BLOCK_RECORDING); if (err) { dev_dbg(&galaxybook->platform->dev, "failed to initialize block_recording, error %d\n", err); return GB_NOT_SUPPORTED; } guard(mutex)(&galaxybook->fw_attr_lock); err = block_recording_acpi_get(galaxybook, &value); if (err) { dev_dbg(&galaxybook->platform->dev, "failed to get initial block_recording state, error %d\n", err); return GB_NOT_SUPPORTED; } galaxybook->camera_lens_cover_switch = devm_input_allocate_device(&galaxybook->platform->dev); if (!galaxybook->camera_lens_cover_switch) return -ENOMEM; galaxybook->camera_lens_cover_switch->name = "Samsung Galaxy Book Camera Lens Cover"; galaxybook->camera_lens_cover_switch->phys = DRIVER_NAME "/input0"; galaxybook->camera_lens_cover_switch->id.bustype = BUS_HOST; input_set_capability(galaxybook->camera_lens_cover_switch, EV_SW, SW_CAMERA_LENS_COVER); err = input_register_device(galaxybook->camera_lens_cover_switch); if (err) return err; input_report_switch(galaxybook->camera_lens_cover_switch, SW_CAMERA_LENS_COVER, value ? 1 : 0); input_sync(galaxybook->camera_lens_cover_switch); return 0; } /* Firmware Attributes setup */ static ssize_t type_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf) { return sysfs_emit(buf, "enumeration\n"); } static struct kobj_attribute fw_attr_type = __ATTR_RO(type); static ssize_t default_value_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf) { return sysfs_emit(buf, "0\n"); } static struct kobj_attribute fw_attr_default_value = __ATTR_RO(default_value); static ssize_t possible_values_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf) { return sysfs_emit(buf, "0;1\n"); } static struct kobj_attribute fw_attr_possible_values = __ATTR_RO(possible_values); static ssize_t display_name_language_code_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf) { return sysfs_emit(buf, "%s\n", GB_ATTR_LANGUAGE_CODE); } static struct kobj_attribute fw_attr_display_name_language_code = __ATTR_RO(display_name_language_code); static ssize_t display_name_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf) { struct galaxybook_fw_attr *fw_attr = container_of(attr, struct galaxybook_fw_attr, display_name); return sysfs_emit(buf, "%s\n", galaxybook_fw_attr_desc[fw_attr->fw_attr_id]); } static ssize_t current_value_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf) { struct galaxybook_fw_attr *fw_attr = container_of(attr, struct galaxybook_fw_attr, current_value); bool value; int err; err = fw_attr->get_value(fw_attr->galaxybook, &value); if (err) return err; return sysfs_emit(buf, "%u\n", value); } static ssize_t current_value_store(struct kobject *kobj, struct kobj_attribute *attr, const char *buf, size_t count) { struct galaxybook_fw_attr *fw_attr = container_of(attr, struct galaxybook_fw_attr, current_value); struct samsung_galaxybook *galaxybook = fw_attr->galaxybook; bool value; int err; if (!count) return -EINVAL; err = kstrtobool(buf, &value); if (err) return err; guard(mutex)(&galaxybook->fw_attr_lock); err = fw_attr->set_value(galaxybook, value); if (err) return err; return count; } #define NUM_FW_ATTR_ENUM_ATTRS 6 static int galaxybook_fw_attr_init(struct samsung_galaxybook *galaxybook, const enum galaxybook_fw_attr_id fw_attr_id, int (*get_value)(struct samsung_galaxybook *galaxybook, bool *value), int (*set_value)(struct samsung_galaxybook *galaxybook, const bool value)) { struct galaxybook_fw_attr *fw_attr; struct attribute **attrs; fw_attr = devm_kzalloc(&galaxybook->platform->dev, sizeof(*fw_attr), GFP_KERNEL); if (!fw_attr) return -ENOMEM; attrs = devm_kcalloc(&galaxybook->platform->dev, NUM_FW_ATTR_ENUM_ATTRS + 1, sizeof(*attrs), GFP_KERNEL); if (!attrs) return -ENOMEM; attrs[0] = &fw_attr_type.attr; attrs[1] = &fw_attr_default_value.attr; attrs[2] = &fw_attr_possible_values.attr; attrs[3] = &fw_attr_display_name_language_code.attr; sysfs_attr_init(&fw_attr->display_name.attr); fw_attr->display_name.attr.name = "display_name"; fw_attr->display_name.attr.mode = 0444; fw_attr->display_name.show = display_name_show; attrs[4] = &fw_attr->display_name.attr; sysfs_attr_init(&fw_attr->current_value.attr); fw_attr->current_value.attr.name = "current_value"; fw_attr->current_value.attr.mode = 0644; fw_attr->current_value.show = current_value_show; fw_attr->current_value.store = current_value_store; attrs[5] = &fw_attr->current_value.attr; attrs[6] = NULL; fw_attr->galaxybook = galaxybook; fw_attr->fw_attr_id = fw_attr_id; fw_attr->attr_group.name = galaxybook_fw_attr_name[fw_attr_id]; fw_attr->attr_group.attrs = attrs; fw_attr->get_value = get_value; fw_attr->set_value = set_value; return sysfs_create_group(&galaxybook->fw_attrs_kset->kobj, &fw_attr->attr_group); } static void galaxybook_kset_unregister(void *data) { struct kset *kset = data; kset_unregister(kset); } static void galaxybook_fw_attrs_dev_unregister(void *data) { struct device *fw_attrs_dev = data; device_unregister(fw_attrs_dev); } static int galaxybook_fw_attrs_init(struct samsung_galaxybook *galaxybook) { bool value; int err; err = devm_mutex_init(&galaxybook->platform->dev, &galaxybook->fw_attr_lock); if (err) return err; galaxybook->fw_attrs_dev = device_create(&firmware_attributes_class, NULL, MKDEV(0, 0), NULL, "%s", DRIVER_NAME); if (IS_ERR(galaxybook->fw_attrs_dev)) return PTR_ERR(galaxybook->fw_attrs_dev); err = devm_add_action_or_reset(&galaxybook->platform->dev, galaxybook_fw_attrs_dev_unregister, galaxybook->fw_attrs_dev); if (err) return err; galaxybook->fw_attrs_kset = kset_create_and_add("attributes", NULL, &galaxybook->fw_attrs_dev->kobj); if (!galaxybook->fw_attrs_kset) return -ENOMEM; err = devm_add_action_or_reset(&galaxybook->platform->dev, galaxybook_kset_unregister, galaxybook->fw_attrs_kset); if (err) return err; err = power_on_lid_open_acpi_get(galaxybook, &value); if (!err) { err = galaxybook_fw_attr_init(galaxybook, GB_ATTR_POWER_ON_LID_OPEN, &power_on_lid_open_acpi_get, &power_on_lid_open_acpi_set); if (err) return err; } err = usb_charging_acpi_get(galaxybook, &value); if (!err) { err = galaxybook_fw_attr_init(galaxybook, GB_ATTR_USB_CHARGING, &usb_charging_acpi_get, &usb_charging_acpi_set); if (err) return err; } err = galaxybook_block_recording_init(galaxybook); if (err == GB_NOT_SUPPORTED) return 0; else if (err) return err; galaxybook->has_block_recording = true; return galaxybook_fw_attr_init(galaxybook, GB_ATTR_BLOCK_RECORDING, &block_recording_acpi_get, &block_recording_acpi_set); } /* * Hotkeys and notifications */ static void galaxybook_kbd_backlight_hotkey_work(struct work_struct *work) { struct samsung_galaxybook *galaxybook = from_work(galaxybook, work, kbd_backlight_hotkey_work); int brightness; int err; guard(mutex)(&galaxybook->kbd_backlight_lock); brightness = galaxybook->kbd_backlight.brightness; if (brightness < galaxybook->kbd_backlight.max_brightness) brightness++; else brightness = 0; err = led_set_brightness_sync(&galaxybook->kbd_backlight, brightness); if (err) { dev_err(&galaxybook->platform->dev, "failed to set kbd_backlight brightness, error %d\n", err); return; } led_classdev_notify_brightness_hw_changed(&galaxybook->kbd_backlight, brightness); } static void galaxybook_block_recording_hotkey_work(struct work_struct *work) { struct samsung_galaxybook *galaxybook = from_work(galaxybook, work, block_recording_hotkey_work); bool value; int err; guard(mutex)(&galaxybook->fw_attr_lock); err = block_recording_acpi_get(galaxybook, &value); if (err) { dev_err(&galaxybook->platform->dev, "failed to get block_recording, error %d\n", err); return; } err = block_recording_acpi_set(galaxybook, !value); if (err) dev_err(&galaxybook->platform->dev, "failed to set block_recording, error %d\n", err); } static bool galaxybook_i8042_filter(unsigned char data, unsigned char str, struct serio *port, void *context) { struct samsung_galaxybook *galaxybook = context; static bool extended; if (str & I8042_STR_AUXDATA) return false; if (data == 0xe0) { extended = true; return true; } else if (extended) { extended = false; switch (data) { case GB_KEY_KBD_BACKLIGHT_KEYDOWN: return true; case GB_KEY_KBD_BACKLIGHT_KEYUP: if (galaxybook->has_kbd_backlight) schedule_work(&galaxybook->kbd_backlight_hotkey_work); return true; case GB_KEY_BLOCK_RECORDING_KEYDOWN: return true; case GB_KEY_BLOCK_RECORDING_KEYUP: if (galaxybook->has_block_recording) schedule_work(&galaxybook->block_recording_hotkey_work); return true; /* battery notification already sent to battery + SCAI device */ case GB_KEY_BATTERY_NOTIFY_KEYUP: case GB_KEY_BATTERY_NOTIFY_KEYDOWN: return true; default: /* * Report the previously filtered e0 before continuing * with the next non-filtered byte. */ serio_interrupt(port, 0xe0, 0); return false; } } return false; } static void galaxybook_i8042_filter_remove(void *data) { struct samsung_galaxybook *galaxybook = data; i8042_remove_filter(galaxybook_i8042_filter); cancel_work_sync(&galaxybook->kbd_backlight_hotkey_work); cancel_work_sync(&galaxybook->block_recording_hotkey_work); } static int galaxybook_i8042_filter_install(struct samsung_galaxybook *galaxybook) { int err; if (!galaxybook->has_kbd_backlight && !galaxybook->has_block_recording) return 0; INIT_WORK(&galaxybook->kbd_backlight_hotkey_work, galaxybook_kbd_backlight_hotkey_work); INIT_WORK(&galaxybook->block_recording_hotkey_work, galaxybook_block_recording_hotkey_work); err = i8042_install_filter(galaxybook_i8042_filter, galaxybook); if (err) return err; return devm_add_action_or_reset(&galaxybook->platform->dev, galaxybook_i8042_filter_remove, galaxybook); } /* * ACPI device setup */ static void galaxybook_acpi_notify(acpi_handle handle, u32 event, void *data) { struct samsung_galaxybook *galaxybook = data; switch (event) { case GB_ACPI_NOTIFY_BATTERY_STATE_CHANGED: case GB_ACPI_NOTIFY_DEVICE_ON_TABLE: case GB_ACPI_NOTIFY_DEVICE_OFF_TABLE: break; case GB_ACPI_NOTIFY_HOTKEY_PERFORMANCE_MODE: if (galaxybook->has_performance_mode) platform_profile_cycle(); break; default: dev_warn(&galaxybook->platform->dev, "unknown ACPI notification event: 0x%x\n", event); } acpi_bus_generate_netlink_event(DRIVER_NAME, dev_name(&galaxybook->platform->dev), event, 1); } static int galaxybook_enable_acpi_notify(struct samsung_galaxybook *galaxybook) { struct sawb buf = {}; int err; err = galaxybook_enable_acpi_feature(galaxybook, GB_SASB_NOTIFICATIONS); if (err) return err; buf.safn = GB_SAFN; buf.sasb = GB_SASB_NOTIFICATIONS; buf.gunm = GB_GUNM_ACPI_NOTIFY_ENABLE; buf.guds[0] = GB_GUDS_ACPI_NOTIFY_ENABLE; return galaxybook_acpi_method(galaxybook, GB_ACPI_METHOD_SETTINGS, &buf, GB_SAWB_LEN_SETTINGS); } static void galaxybook_acpi_remove_notify_handler(void *data) { struct samsung_galaxybook *galaxybook = data; acpi_remove_notify_handler(galaxybook->acpi->handle, ACPI_ALL_NOTIFY, galaxybook_acpi_notify); } static void galaxybook_acpi_disable(void *data) { struct samsung_galaxybook *galaxybook = data; acpi_execute_simple_method(galaxybook->acpi->handle, GB_ACPI_METHOD_ENABLE, GB_ACPI_METHOD_ENABLE_OFF); } static int galaxybook_acpi_init(struct samsung_galaxybook *galaxybook) { acpi_status status; int err; status = acpi_execute_simple_method(galaxybook->acpi->handle, GB_ACPI_METHOD_ENABLE, GB_ACPI_METHOD_ENABLE_ON); if (ACPI_FAILURE(status)) return -EIO; err = devm_add_action_or_reset(&galaxybook->platform->dev, galaxybook_acpi_disable, galaxybook); if (err) return err; status = acpi_install_notify_handler(galaxybook->acpi->handle, ACPI_ALL_NOTIFY, galaxybook_acpi_notify, galaxybook); if (ACPI_FAILURE(status)) return -EIO; err = devm_add_action_or_reset(&galaxybook->platform->dev, galaxybook_acpi_remove_notify_handler, galaxybook); if (err) return err; err = galaxybook_enable_acpi_notify(galaxybook); if (err) dev_dbg(&galaxybook->platform->dev, "failed to enable ACPI notifications; " "some hotkeys will not be supported\n"); err = galaxybook_enable_acpi_feature(galaxybook, GB_SASB_POWER_MANAGEMENT); if (err) dev_dbg(&galaxybook->platform->dev, "failed to initialize ACPI power management features; " "many features of this driver will not be available\n"); return 0; } /* * Platform driver */ static int galaxybook_probe(struct platform_device *pdev) { struct acpi_device *adev = ACPI_COMPANION(&pdev->dev); struct samsung_galaxybook *galaxybook; int err; if (!adev) return -ENODEV; galaxybook = devm_kzalloc(&pdev->dev, sizeof(*galaxybook), GFP_KERNEL); if (!galaxybook) return -ENOMEM; galaxybook->platform = pdev; galaxybook->acpi = adev; /* * Features must be enabled and initialized in the following order to * avoid failures seen on certain devices: * - GB_SASB_POWER_MANAGEMENT (including performance mode) * - GB_SASB_KBD_BACKLIGHT * - GB_SASB_BLOCK_RECORDING (as part of fw_attrs init) */ err = galaxybook_acpi_init(galaxybook); if (err) return dev_err_probe(&galaxybook->platform->dev, err, "failed to initialize ACPI device\n"); err = galaxybook_platform_profile_init(galaxybook); if (!err) galaxybook->has_performance_mode = true; else if (err != GB_NOT_SUPPORTED) return dev_err_probe(&galaxybook->platform->dev, err, "failed to initialize platform profile\n"); err = galaxybook_battery_threshold_init(galaxybook); if (err) return dev_err_probe(&galaxybook->platform->dev, err, "failed to initialize battery threshold\n"); err = galaxybook_kbd_backlight_init(galaxybook); if (!err) galaxybook->has_kbd_backlight = true; else if (err != GB_NOT_SUPPORTED) return dev_err_probe(&galaxybook->platform->dev, err, "failed to initialize kbd_backlight\n"); err = galaxybook_fw_attrs_init(galaxybook); if (err) return dev_err_probe(&galaxybook->platform->dev, err, "failed to initialize firmware-attributes\n"); err = galaxybook_i8042_filter_install(galaxybook); if (err) return dev_err_probe(&galaxybook->platform->dev, err, "failed to initialize i8042_filter\n"); return 0; } static const struct acpi_device_id galaxybook_device_ids[] = { { "SAM0426" }, { "SAM0427" }, { "SAM0428" }, { "SAM0429" }, { "SAM0430" }, {} }; MODULE_DEVICE_TABLE(acpi, galaxybook_device_ids); static struct platform_driver galaxybook_platform_driver = { .driver = { .name = DRIVER_NAME, .acpi_match_table = galaxybook_device_ids, }, .probe = galaxybook_probe, }; module_platform_driver(galaxybook_platform_driver); MODULE_AUTHOR("Joshua Grisham <josh@joshuagrisham.com>"); MODULE_DESCRIPTION("Samsung Galaxy Book driver"); MODULE_LICENSE("GPL");
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1