// SPDX-License-Identifier: GPL-2.0-or-later /* Platform profile sysfs interface */ #include #include #include #include #include #include #include static struct platform_profile_handler *cur_profile; static DEFINE_MUTEX(profile_lock); static const char * const profile_names[] = { [PLATFORM_PROFILE_LOW_POWER] = "low-power", [PLATFORM_PROFILE_COOL] = "cool", [PLATFORM_PROFILE_QUIET] = "quiet", [PLATFORM_PROFILE_BALANCED] = "balanced", [PLATFORM_PROFILE_BALANCED_PERFORMANCE] = "balanced-performance", [PLATFORM_PROFILE_PERFORMANCE] = "performance", }; static_assert(ARRAY_SIZE(profile_names) == PLATFORM_PROFILE_LAST); static DEFINE_IDA(platform_profile_ida); /** * _commmon_choices_show - Show the available profile choices * @choices: The available profile choices * @buf: The buffer to write to * * Return: The number of bytes written */ static ssize_t _commmon_choices_show(unsigned long *choices, char *buf) { int i, len = 0; for_each_set_bit(i, choices, PLATFORM_PROFILE_LAST) { if (len == 0) len += sysfs_emit_at(buf, len, "%s", profile_names[i]); else len += sysfs_emit_at(buf, len, " %s", profile_names[i]); } len += sysfs_emit_at(buf, len, "\n"); return len; } /** * name_show - Show the name of the profile handler * @dev: The device * @attr: The attribute * @buf: The buffer to write to * * Return: The number of bytes written */ static ssize_t name_show(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_profile_handler *handler = dev_get_drvdata(dev); return sysfs_emit(buf, "%s\n", handler->name); } static DEVICE_ATTR_RO(name); /** * choices_show - Show the available profile choices * @dev: The device * @attr: The attribute * @buf: The buffer to write to * * Return: The number of bytes written */ static ssize_t choices_show(struct device *dev, struct device_attribute *attr, char *buf) { struct platform_profile_handler *handler = dev_get_drvdata(dev); return _commmon_choices_show(handler->choices, buf); } static DEVICE_ATTR_RO(choices); static struct attribute *profile_attrs[] = { &dev_attr_name.attr, &dev_attr_choices.attr, NULL }; ATTRIBUTE_GROUPS(profile); static const struct class platform_profile_class = { .name = "platform-profile", .dev_groups = profile_groups, }; static ssize_t platform_profile_choices_show(struct device *dev, struct device_attribute *attr, char *buf) { int len = 0; int i; scoped_cond_guard(mutex_intr, return -ERESTARTSYS, &profile_lock) { if (!cur_profile) return -ENODEV; for_each_set_bit(i, cur_profile->choices, PLATFORM_PROFILE_LAST) len += sysfs_emit_at(buf, len, len ? " %s": "%s", profile_names[i]); } len += sysfs_emit_at(buf, len, "\n"); return len; } static ssize_t platform_profile_show(struct device *dev, struct device_attribute *attr, char *buf) { enum platform_profile_option profile = PLATFORM_PROFILE_BALANCED; int err; scoped_cond_guard(mutex_intr, return -ERESTARTSYS, &profile_lock) { if (!cur_profile) return -ENODEV; err = cur_profile->profile_get(cur_profile, &profile); if (err) return err; } /* Check that profile is valid index */ if (WARN_ON((profile < 0) || (profile >= ARRAY_SIZE(profile_names)))) return -EIO; return sysfs_emit(buf, "%s\n", profile_names[profile]); } static ssize_t platform_profile_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int err, i; /* Scan for a matching profile */ i = sysfs_match_string(profile_names, buf); if (i < 0) return -EINVAL; scoped_cond_guard(mutex_intr, return -ERESTARTSYS, &profile_lock) { if (!cur_profile) return -ENODEV; /* Check that platform supports this profile choice */ if (!test_bit(i, cur_profile->choices)) return -EOPNOTSUPP; err = cur_profile->profile_set(cur_profile, i); if (err) return err; } sysfs_notify(acpi_kobj, NULL, "platform_profile"); return count; } static DEVICE_ATTR_RO(platform_profile_choices); static DEVICE_ATTR_RW(platform_profile); static struct attribute *platform_profile_attrs[] = { &dev_attr_platform_profile_choices.attr, &dev_attr_platform_profile.attr, NULL }; static int profile_class_registered(struct device *dev, const void *data) { return 1; } static umode_t profile_class_is_visible(struct kobject *kobj, struct attribute *attr, int idx) { if (!class_find_device(&platform_profile_class, NULL, NULL, profile_class_registered)) return 0; return attr->mode; } static const struct attribute_group platform_profile_group = { .attrs = platform_profile_attrs, .is_visible = profile_class_is_visible, }; void platform_profile_notify(struct platform_profile_handler *pprof) { if (!cur_profile) return; sysfs_notify(acpi_kobj, NULL, "platform_profile"); } EXPORT_SYMBOL_GPL(platform_profile_notify); int platform_profile_cycle(void) { enum platform_profile_option profile; enum platform_profile_option next; int err; scoped_cond_guard(mutex_intr, return -ERESTARTSYS, &profile_lock) { if (!cur_profile) return -ENODEV; err = cur_profile->profile_get(cur_profile, &profile); if (err) return err; next = find_next_bit_wrap(cur_profile->choices, PLATFORM_PROFILE_LAST, profile + 1); if (WARN_ON(next == PLATFORM_PROFILE_LAST)) return -EINVAL; err = cur_profile->profile_set(cur_profile, next); if (err) return err; } sysfs_notify(acpi_kobj, NULL, "platform_profile"); return 0; } EXPORT_SYMBOL_GPL(platform_profile_cycle); int platform_profile_register(struct platform_profile_handler *pprof) { int err; /* Sanity check the profile handler */ if (!pprof || bitmap_empty(pprof->choices, PLATFORM_PROFILE_LAST) || !pprof->profile_set || !pprof->profile_get) { pr_err("platform_profile: handler is invalid\n"); return -EINVAL; } guard(mutex)(&profile_lock); /* We can only have one active profile */ if (cur_profile) return -EEXIST; /* create class interface for individual handler */ pprof->minor = ida_alloc(&platform_profile_ida, GFP_KERNEL); if (pprof->minor < 0) return pprof->minor; pprof->class_dev = device_create(&platform_profile_class, pprof->dev, MKDEV(0, 0), pprof, "platform-profile-%d", pprof->minor); if (IS_ERR(pprof->class_dev)) { err = PTR_ERR(pprof->class_dev); goto cleanup_ida; } cur_profile = pprof; err = sysfs_update_group(acpi_kobj, &platform_profile_group); if (err) goto cleanup_cur; return 0; cleanup_cur: cur_profile = NULL; device_unregister(pprof->class_dev); cleanup_ida: ida_free(&platform_profile_ida, pprof->minor); return err; } EXPORT_SYMBOL_GPL(platform_profile_register); int platform_profile_remove(struct platform_profile_handler *pprof) { int id; guard(mutex)(&profile_lock); cur_profile = NULL; id = pprof->minor; device_unregister(pprof->class_dev); ida_free(&platform_profile_ida, id); sysfs_update_group(acpi_kobj, &platform_profile_group); return 0; } EXPORT_SYMBOL_GPL(platform_profile_remove); static int __init platform_profile_init(void) { int err; err = class_register(&platform_profile_class); if (err) return err; err = sysfs_create_group(acpi_kobj, &platform_profile_group); if (err) class_unregister(&platform_profile_class); return err; } static void __exit platform_profile_exit(void) { sysfs_remove_group(acpi_kobj, &platform_profile_group); class_unregister(&platform_profile_class); } module_init(platform_profile_init); module_exit(platform_profile_exit); MODULE_AUTHOR("Mark Pearson "); MODULE_DESCRIPTION("ACPI platform profile sysfs interface"); MODULE_LICENSE("GPL");