Skip to content
Navigation Menu
Toggle navigation
Sign in
In this repository
All GitHub Enterprise
↵
Jump to
↵
No suggested jump to results
In this repository
All GitHub Enterprise
↵
Jump to
↵
In this organization
All GitHub Enterprise
↵
Jump to
↵
In this repository
All GitHub Enterprise
↵
Jump to
↵
Sign in
Reseting focus
You signed in with another tab or window.
Reload
to refresh your session.
You signed out in another tab or window.
Reload
to refresh your session.
You switched accounts on another tab or window.
Reload
to refresh your session.
Dismiss alert
{{ message }}
mariux64
/
linux
Public
Notifications
You must be signed in to change notification settings
Fork
0
Star
0
Code
Issues
2
Pull requests
0
Actions
Projects
0
Wiki
Security
Insights
Additional navigation options
Code
Issues
Pull requests
Actions
Projects
Wiki
Security
Insights
Files
249c576
Documentation
LICENSES
arch
block
certs
crypto
drivers
accel
accessibility
acpi
acpica
apei
arm64
dptf
nfit
numa
pmic
riscv
x86
Kconfig
Makefile
ac.c
acpi_adxl.c
acpi_apd.c
acpi_configfs.c
acpi_dbg.c
acpi_extlog.c
acpi_ffh.c
acpi_fpdt.c
acpi_ipmi.c
acpi_lpat.c
acpi_lpit.c
acpi_memhotplug.c
acpi_pad.c
acpi_pcc.c
acpi_platform.c
acpi_pnp.c
acpi_processor.c
acpi_tad.c
acpi_video.c
acpi_watchdog.c
battery.c
bgrt.c
bus.c
button.c
container.c
cppc_acpi.c
debugfs.c
device_pm.c
device_sysfs.c
dock.c
ec.c
ec_sys.c
event.c
evged.c
fan.h
fan_attr.c
fan_core.c
fan_hwmon.c
glue.c
hed.c
internal.h
ioapic.c
irq.c
mipi-disco-img.c
nhlt.c
nvs.c
osi.c
osl.c
pci_irq.c
pci_link.c
pci_mcfg.c
pci_root.c
pci_slot.c
pfr_telemetry.c
pfr_update.c
platform_profile.c
power.c
pptt.c
prmt.c
proc.c
processor_core.c
processor_driver.c
processor_idle.c
processor_pdc.c
processor_perflib.c
processor_thermal.c
processor_throttling.c
property.c
reboot.c
resource.c
sbs.c
sbshc.c
sbshc.h
scan.c
sleep.c
sleep.h
spcr.c
sysfs.c
tables.c
thermal.c
thermal_lib.c
tiny-power-button.c
utils.c
video_detect.c
viot.c
wakeup.c
amba
android
ata
atm
auxdisplay
base
bcma
block
bluetooth
bus
cache
cdrom
cdx
char
clk
clocksource
comedi
connector
counter
cpufreq
cpuidle
crypto
cxl
dax
dca
devfreq
dio
dma-buf
dma
dpll
edac
eisa
extcon
firewire
firmware
fpga
fsi
gnss
gpio
gpu
greybus
hid
hsi
hte
hv
hwmon
hwspinlock
hwtracing
i2c
i3c
idle
iio
infiniband
input
interconnect
iommu
ipack
irqchip
isdn
leds
macintosh
mailbox
mcb
md
media
memory
memstick
message
mfd
misc
mmc
most
mtd
mux
net
nfc
ntb
nubus
nvdimm
nvme
nvmem
of
opp
parisc
parport
pci
pcmcia
peci
perf
phy
pinctrl
platform
pmdomain
pnp
power
powercap
pps
ps3
ptp
pwm
rapidio
ras
regulator
remoteproc
reset
rpmsg
rtc
s390
sbus
scsi
sh
siox
slimbus
soc
soundwire
spi
spmi
ssb
staging
target
tc
tee
thermal
thunderbolt
tty
ufs
uio
usb
vdpa
vfio
vhost
video
virt
virtio
w1
watchdog
xen
zorro
Kconfig
Makefile
fs
include
init
io_uring
ipc
kernel
lib
mm
net
rust
samples
scripts
security
sound
tools
usr
virt
.clang-format
.clippy.toml
.cocciconfig
.editorconfig
.get_maintainer.ignore
.gitattributes
.gitignore
.mailmap
.rustfmt.toml
COPYING
CREDITS
Kbuild
Kconfig
MAINTAINERS
Makefile
README
Breadcrumbs
linux
/
drivers
/
acpi
/
platform_profile.c
Blame
Blame
Latest commit
Kurt Borja
and
Ilpo Järvinen
ACPI: platform_profile: Let drivers set drvdata to the class device
Jan 16, 2025
249c576
·
Jan 16, 2025
History
History
580 lines (480 loc) · 14.2 KB
Breadcrumbs
linux
/
drivers
/
acpi
/
platform_profile.c
Top
File metadata and controls
Code
Blame
580 lines (480 loc) · 14.2 KB
Raw
// SPDX-License-Identifier: GPL-2.0-or-later /* Platform profile sysfs interface */ #include <linux/acpi.h> #include <linux/bits.h> #include <linux/init.h> #include <linux/mutex.h> #include <linux/platform_profile.h> #include <linux/sysfs.h> #define to_pprof_handler(d) (container_of(d, struct platform_profile_handler, class_dev)) 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", [PLATFORM_PROFILE_CUSTOM] = "custom", }; 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; } /** * _store_class_profile - Set the profile for a class device * @dev: The class device * @data: The profile to set * * Return: 0 on success, -errno on failure */ static int _store_class_profile(struct device *dev, void *data) { struct platform_profile_handler *handler; int *bit = (int *)data; lockdep_assert_held(&profile_lock); handler = to_pprof_handler(dev); if (!test_bit(*bit, handler->choices)) return -EOPNOTSUPP; return handler->profile_set(handler, *bit); } /** * _notify_class_profile - Notify the class device of a profile change * @dev: The class device * @data: Unused * * Return: 0 on success, -errno on failure */ static int _notify_class_profile(struct device *dev, void *data) { struct platform_profile_handler *handler = to_pprof_handler(dev); lockdep_assert_held(&profile_lock); sysfs_notify(&handler->class_dev.kobj, NULL, "profile"); kobject_uevent(&handler->class_dev.kobj, KOBJ_CHANGE); return 0; } /** * get_class_profile - Show the current profile for a class device * @dev: The class device * @profile: The profile to return * * Return: 0 on success, -errno on failure */ static int get_class_profile(struct device *dev, enum platform_profile_option *profile) { struct platform_profile_handler *handler; enum platform_profile_option val; int err; lockdep_assert_held(&profile_lock); handler = to_pprof_handler(dev); err = handler->profile_get(handler, &val); if (err) { pr_err("Failed to get profile for handler %s\n", handler->name); return err; } if (WARN_ON(val >= PLATFORM_PROFILE_LAST)) return -EINVAL; *profile = val; return 0; } /** * 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 = to_pprof_handler(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 = to_pprof_handler(dev); return _commmon_choices_show(handler->choices, buf); } static DEVICE_ATTR_RO(choices); /** * profile_show - Show the current profile for a class device * @dev: The device * @attr: The attribute * @buf: The buffer to write to * * Return: The number of bytes written */ static ssize_t profile_show(struct device *dev, struct device_attribute *attr, char *buf) { enum platform_profile_option profile = PLATFORM_PROFILE_LAST; int err; scoped_cond_guard(mutex_intr, return -ERESTARTSYS, &profile_lock) { err = get_class_profile(dev, &profile); if (err) return err; } return sysfs_emit(buf, "%s\n", profile_names[profile]); } /** * profile_store - Set the profile for a class device * @dev: The device * @attr: The attribute * @buf: The buffer to read from * @count: The number of bytes to read * * Return: The number of bytes read */ static ssize_t profile_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int index, ret; index = sysfs_match_string(profile_names, buf); if (index < 0) return -EINVAL; scoped_cond_guard(mutex_intr, return -ERESTARTSYS, &profile_lock) { ret = _store_class_profile(dev, &index); if (ret) return ret; } sysfs_notify(acpi_kobj, NULL, "platform_profile"); return count; } static DEVICE_ATTR_RW(profile); static struct attribute *profile_attrs[] = { &dev_attr_name.attr, &dev_attr_choices.attr, &dev_attr_profile.attr, NULL }; ATTRIBUTE_GROUPS(profile); static const struct class platform_profile_class = { .name = "platform-profile", .dev_groups = profile_groups, }; /** * _aggregate_choices - Aggregate the available profile choices * @dev: The device * @data: The available profile choices * * Return: 0 on success, -errno on failure */ static int _aggregate_choices(struct device *dev, void *data) { struct platform_profile_handler *handler; unsigned long *aggregate = data; lockdep_assert_held(&profile_lock); handler = to_pprof_handler(dev); if (test_bit(PLATFORM_PROFILE_LAST, aggregate)) bitmap_copy(aggregate, handler->choices, PLATFORM_PROFILE_LAST); else bitmap_and(aggregate, handler->choices, aggregate, PLATFORM_PROFILE_LAST); return 0; } /** * platform_profile_choices_show - Show the available profile choices for legacy sysfs interface * @dev: The device * @attr: The attribute * @buf: The buffer to write to * * Return: The number of bytes written */ static ssize_t platform_profile_choices_show(struct device *dev, struct device_attribute *attr, char *buf) { unsigned long aggregate[BITS_TO_LONGS(PLATFORM_PROFILE_LAST)]; int err; set_bit(PLATFORM_PROFILE_LAST, aggregate); scoped_cond_guard(mutex_intr, return -ERESTARTSYS, &profile_lock) { err = class_for_each_device(&platform_profile_class, NULL, aggregate, _aggregate_choices); if (err) return err; } /* no profile handler registered any more */ if (bitmap_empty(aggregate, PLATFORM_PROFILE_LAST)) return -EINVAL; return _commmon_choices_show(aggregate, buf); } /** * _aggregate_profiles - Aggregate the profiles for legacy sysfs interface * @dev: The device * @data: The profile to return * * Return: 0 on success, -errno on failure */ static int _aggregate_profiles(struct device *dev, void *data) { enum platform_profile_option *profile = data; enum platform_profile_option val; int err; err = get_class_profile(dev, &val); if (err) return err; if (*profile != PLATFORM_PROFILE_LAST && *profile != val) *profile = PLATFORM_PROFILE_CUSTOM; else *profile = val; return 0; } /** * _store_and_notify - Store and notify a class from legacy sysfs interface * @dev: The device * @data: The profile to return * * Return: 0 on success, -errno on failure */ static int _store_and_notify(struct device *dev, void *data) { enum platform_profile_option *profile = data; int err; err = _store_class_profile(dev, profile); if (err) return err; return _notify_class_profile(dev, NULL); } /** * platform_profile_show - Show the current profile for legacy sysfs interface * @dev: The device * @attr: The attribute * @buf: The buffer to write to * * Return: The number of bytes written */ static ssize_t platform_profile_show(struct device *dev, struct device_attribute *attr, char *buf) { enum platform_profile_option profile = PLATFORM_PROFILE_LAST; int err; scoped_cond_guard(mutex_intr, return -ERESTARTSYS, &profile_lock) { err = class_for_each_device(&platform_profile_class, NULL, &profile, _aggregate_profiles); if (err) return err; } /* no profile handler registered any more */ if (profile == PLATFORM_PROFILE_LAST) return -EINVAL; return sysfs_emit(buf, "%s\n", profile_names[profile]); } /** * platform_profile_store - Set the profile for legacy sysfs interface * @dev: The device * @attr: The attribute * @buf: The buffer to read from * @count: The number of bytes to read * * Return: The number of bytes read */ static ssize_t platform_profile_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { unsigned long choices[BITS_TO_LONGS(PLATFORM_PROFILE_LAST)]; int ret; int i; /* Scan for a matching profile */ i = sysfs_match_string(profile_names, buf); if (i < 0 || i == PLATFORM_PROFILE_CUSTOM) return -EINVAL; set_bit(PLATFORM_PROFILE_LAST, choices); scoped_cond_guard(mutex_intr, return -ERESTARTSYS, &profile_lock) { ret = class_for_each_device(&platform_profile_class, NULL, choices, _aggregate_choices); if (ret) return ret; if (!test_bit(i, choices)) return -EOPNOTSUPP; ret = class_for_each_device(&platform_profile_class, NULL, &i, _store_and_notify); if (ret) return ret; } 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) { scoped_cond_guard(mutex_intr, return, &profile_lock) { _notify_class_profile(&pprof->class_dev, NULL); } sysfs_notify(acpi_kobj, NULL, "platform_profile"); } EXPORT_SYMBOL_GPL(platform_profile_notify); int platform_profile_cycle(void) { enum platform_profile_option next = PLATFORM_PROFILE_LAST; enum platform_profile_option profile = PLATFORM_PROFILE_LAST; unsigned long choices[BITS_TO_LONGS(PLATFORM_PROFILE_LAST)]; int err; set_bit(PLATFORM_PROFILE_LAST, choices); scoped_cond_guard(mutex_intr, return -ERESTARTSYS, &profile_lock) { err = class_for_each_device(&platform_profile_class, NULL, &profile, _aggregate_profiles); if (err) return err; if (profile == PLATFORM_PROFILE_CUSTOM || profile == PLATFORM_PROFILE_LAST) return -EINVAL; err = class_for_each_device(&platform_profile_class, NULL, choices, _aggregate_choices); if (err) return err; /* never iterate into a custom if all drivers supported it */ clear_bit(PLATFORM_PROFILE_CUSTOM, choices); next = find_next_bit_wrap(choices, PLATFORM_PROFILE_LAST, profile + 1); err = class_for_each_device(&platform_profile_class, NULL, &next, _store_and_notify); 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, void *drvdata) { 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); /* 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.class = &platform_profile_class; pprof->class_dev.parent = pprof->dev; dev_set_drvdata(&pprof->class_dev, drvdata); dev_set_name(&pprof->class_dev, "platform-profile-%d", pprof->minor); err = device_register(&pprof->class_dev); if (err) { put_device(&pprof->class_dev); goto cleanup_ida; } sysfs_notify(acpi_kobj, NULL, "platform_profile"); err = sysfs_update_group(acpi_kobj, &platform_profile_group); if (err) goto cleanup_cur; return 0; cleanup_cur: 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); id = pprof->minor; device_unregister(&pprof->class_dev); ida_free(&platform_profile_ida, id); sysfs_notify(acpi_kobj, NULL, "platform_profile"); sysfs_update_group(acpi_kobj, &platform_profile_group); return 0; } EXPORT_SYMBOL_GPL(platform_profile_remove); static void devm_platform_profile_release(struct device *dev, void *res) { struct platform_profile_handler **pprof = res; platform_profile_remove(*pprof); } int devm_platform_profile_register(struct platform_profile_handler *pprof, void *drvdata) { struct platform_profile_handler **dr; int ret; dr = devres_alloc(devm_platform_profile_release, sizeof(*dr), GFP_KERNEL); if (!dr) return -ENOMEM; ret = platform_profile_register(pprof, drvdata); if (ret) { devres_free(dr); return ret; } *dr = pprof; devres_add(pprof->dev, dr); return 0; } EXPORT_SYMBOL_GPL(devm_platform_profile_register); 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 <markpearson@lenovo.com>"); MODULE_DESCRIPTION("ACPI platform profile sysfs interface"); MODULE_LICENSE("GPL");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
You can’t perform that action at this time.