diff options
26 files changed, 2858 insertions, 1032 deletions
@@ -1,6 +1,6 @@ pkgbase = linux-g14 pkgdesc = Linux-g14 - pkgver = 6.8.1.arch1 + pkgver = 6.8.9.arch1 pkgrel = 1 url = https://gitlab.com/dragonn/linux-g14.git arch = x86_64 @@ -17,16 +17,16 @@ pkgbase = linux-g14 makedepends = xz options = !strip options = !debug - source = https://cdn.kernel.org/pub/linux/kernel/v6.x/linux-6.8.1.tar.xz - source = https://cdn.kernel.org/pub/linux/kernel/v6.x/linux-6.8.1.tar.sign - source = https://github.com/archlinux/linux/releases/download/v6.8.1-arch1/linux-v6.8.1-arch1.patch.zst - source = https://github.com/archlinux/linux/releases/download/v6.8.1-arch1/linux-v6.8.1-arch1.patch.zst.sig + source = https://cdn.kernel.org/pub/linux/kernel/v6.x/linux-6.8.9.tar.xz + source = https://cdn.kernel.org/pub/linux/kernel/v6.x/linux-6.8.9.tar.sign + source = https://github.com/archlinux/linux/releases/download/v6.8.9-arch1/linux-v6.8.9-arch1.patch.zst + source = https://github.com/archlinux/linux/releases/download/v6.8.9-arch1/linux-v6.8.9-arch1.patch.zst.sig source = config source = choose-gcc-optimization.sh source = sys-kernel_arch-sources-g14-6.8+--more-uarches-for-kernel.patch::https://raw.githubusercontent.com/graysky2/kernel_compiler_patch/master/more-uarches-for-kernel-6.8-rc4%2B.patch + source = 9999-fix-amdgpu-doorbell-regression.patch source = 0001-acpi-proc-idle-skip-dummy-wait.patch source = 0027-mt76_-mt7921_-Disable-powersave-features-by-default.patch - source = 0001-linux6.7.y-bore4.0.0.patch source = 0032-Bluetooth-btusb-Add-a-new-PID-VID-0489-e0f6-for-MT7922.patch source = 0035-Add_quirk_for_polling_the_KBD_port.patch source = 0001-ACPI-resource-Skip-IRQ-override-on-ASUS-TUF-Gaming-A.patch @@ -36,21 +36,35 @@ pkgbase = linux-g14 source = 0040-workaround_hardware_decoding_amdgpu.patch source = 0001-platform-x86-asus-wmi-Support-2023-ROG-X16-tablet-mo.patch source = amd-tablet-sfh.patch + source = 0001-v4-platform-x86-asus-wmi-add-support-for-2024-ROG-Mini-LED.patch + source = 0002-v4-platform-x86-asus-wmi-add-support-for-Vivobook-GPU-MUX.patch + source = 0003-v4-platform-x86-asus-wmi-add-support-variant-of-TUF-RGB.patch + source = 0004-v4-platform-x86-asus-wmi-support-toggling-POST-sound.patch + source = 0005-v4-platform-x86-asus-wmi-store-a-min-default-for-ppt-op.patch + source = 0006-v4-platform-x86-asus-wmi-adjust-formatting-of-ppt-fcts.patch + source = 0007-v4-platform-x86-asus-wmi-ROG-Ally-increase-wait-time.patch + source = 0008-v4-platform-x86-asus-wmi-add-support-for-MCU-powersave.patch + source = 0009-v4-platform-x86-asus-wmi-add-clean-up-structs.patch + source = 0001-HID-asus-fix-more-n-key-report-descriptors-if-n-key-.patch + source = 0001-platform-x86-asus-wmi-add-support-for-vivobook-fan-p.patch + source = 0002-HID-asus-make-asus_kbd_init-generic-remove-rog_nkey_.patch + source = 0003-HID-asus-add-ROG-Ally-N-Key-ID-and-keycodes.patch + source = 0004-HID-asus-add-ROG-Z13-lightbar.patch source = sys-kernel_arch-sources-g14_files-0047-asus-nb-wmi-Add-tablet_mode_sw-lid-flip.patch source = sys-kernel_arch-sources-g14_files-0048-asus-nb-wmi-fix-tablet_mode_sw_int.patch validpgpkeys = ABAF11C65A2970B130ABE3C479BE3E4300411886 validpgpkeys = 647F28654894E3BD457199BE38DBBDC86092693E validpgpkeys = 83BC8889351B5DEBBB68416EB8AC08600F108CDF - sha256sums = 8d0c8936e3140a0fbdf511ad7a9f21121598f3656743898f47bb9052d37cff68 + sha256sums = f905f1238ea7a8e85314bacf283302e8097006010d25fcea726d0de0ea5bc9b6 sha256sums = SKIP - sha256sums = 376db82b4613c3942932fde99d54c3dea1e4b29ab23d8b86daa6414327e6244d + sha256sums = 7a212eedb9fe3da99d6d5b63eb5f28c10ee4333e4d42ea1bb3842a15d3107bef sha256sums = SKIP - sha256sums = c2b00c84c4b543db431e06604d939a62f93107d18369f4d9860dc8062b01ab45 + sha256sums = e35c97eb1ab405b12489032225dfb07be591be03d292d8f2131f0df8481d91d8 sha256sums = 278118011d7a2eeca9971ac97b31bf0c55ab55e99c662ab9ae4717b55819c9a2 - sha256sums = d69232afd0dd6982ae941cf2d1f577f4be2011e3bb847d1db37952acf416b5d3 + sha256sums = f4e7fcd011f2691840d2c8c2361dca850a78ea33cc5c24d2e27c3e0294fd1dc5 + sha256sums = f196d51a0536cf0fd6a17cead8be24920a75f392595abbb4654a6caa7e1cc17b sha256sums = 0a7ea482fe20c403788d290826cec42fe395e5a6eab07b88845f8b9a9829998d sha256sums = ed242f4be3f8eaade2a1d42157c5c6c86281917a08ae43221b088fafdc775ee7 - sha256sums = 6e0b648637a0925df4bb43f5eb5144838415e02c43ff8fddbf82f6813b0f132c sha256sums = a8e1e11a4ab1995cc4975c9b134a43ddfe7054ef0c965e52a7d8f9223e15c3e0 sha256sums = 315d1839630b37894a626bbc2aea012618b2e1ccb6f9d8aa27c0a3ce5e90e99c sha256sums = a00b952d53df9d3617d93e8fba4146a4d6169ebe79f029b3a55cca68f738d8ea @@ -60,6 +74,20 @@ pkgbase = linux-g14 sha256sums = e41198b29cee4de7a5132d8df606f48c2d0f9c9076fe4230b00a33c7e0b22c71 sha256sums = 1edb362a762c8858374027e30ff58ae0014e117fdc05cc7db6da50f80e7aab87 sha256sums = 508f90cbe81a9a145cc540703470f1e6b5d21c7a7b9166d2ce6e56b401262b04 + sha256sums = feaf5f5fb62e25e2369f92f77e8327dcd4cb4cf4bc6d0c91d9c7bc40c0f4de46 + sha256sums = b9866121c69ce22b4651b3ef2a1956e6d0547e40a14d1224e2f367a4f716ca1a + sha256sums = 6f2f248a5ac9b1a37324cbce8d29a65b22a2b20d4b3564c0dc6063789ae733ba + sha256sums = 28f2b9bf5a1f4993bdc77d4d8ac32c1905edfeb3f4cce476f0f85a31b573bcd0 + sha256sums = fa8de80231c933ca294315168d985ae18261e04e77ef17482c815a0703d6c5fb + sha256sums = 62b297619e500b4453e2f3e0305c4dfb92185f69ebbdb67f99e8f76dad139f7a + sha256sums = c2c89baaf134c0151c3f7a3861d16194e32c91c7abc87f870733cab8c5b88389 + sha256sums = f5b560d988c47033c44307da0b584599d1f59cc0028a594f4df87affffc219d5 + sha256sums = de85da760f6692b284e39aa78479904d6ee78b349f1e98d1d210777f9ef17581 + sha256sums = 3be072ed798becd91bae66a75d09235c9cb5e84547b1f4eb7768e954ba109e92 + sha256sums = 93c9a77f6c25494cecbe6b236bd2179065d5f5db5589dabaa425134c1a8c3481 + sha256sums = c1d96328d96964c2ce3ef7609fb7c07e97eb136dfab9f6d4efcce072a5739838 + sha256sums = 2414dc71174c90b92f975a7d16cabc99ba509397d843132764ea9ee91b643dc0 + sha256sums = 107a08aa610d3ba3c7ecec301df2ea8f345bc74107fcf4dac96fe9e89a23dcf1 sha256sums = 15e912a66e4bbce1cf0450f1dc6610653df29df8dd6d5426f9c1b039490436c8 sha256sums = 444f2d86de8c2177655b01596f939f99c2e7abfa8efad8a509e0a334f42dfa85 diff --git a/0001-HID-asus-fix-more-n-key-report-descriptors-if-n-key-.patch b/0001-HID-asus-fix-more-n-key-report-descriptors-if-n-key-.patch new file mode 100644 index 000000000000..74081073ad56 --- /dev/null +++ b/0001-HID-asus-fix-more-n-key-report-descriptors-if-n-key-.patch @@ -0,0 +1,89 @@ +From 7c2c8cca4989bc7803aef60a4aeb3efe1d211a4b Mon Sep 17 00:00:00 2001 +From: "Luke D. Jones" <luke@ljones.dev> +Date: Sat, 2 Dec 2023 17:27:23 +1300 +Subject: [PATCH 1/4] HID: asus: fix more n-key report descriptors if n-key + quirked + +Adjusts the report descriptor for N-Key devices to +make the output count 0x01 which completely avoids +the need for a block of filtering. + +Signed-off-by: Luke D. Jones <luke@ljones.dev> +--- + drivers/hid/hid-asus.c | 49 ++++++++++++++++++++---------------------- + 1 file changed, 23 insertions(+), 26 deletions(-) + +diff --git a/drivers/hid/hid-asus.c b/drivers/hid/hid-asus.c +index 78cdfb8b9a7a..855972a4470f 100644 +--- a/drivers/hid/hid-asus.c ++++ b/drivers/hid/hid-asus.c +@@ -335,36 +335,20 @@ static int asus_raw_event(struct hid_device *hdev, + if (drvdata->quirks & QUIRK_MEDION_E1239T) + return asus_e1239t_event(drvdata, data, size); + +- if (drvdata->quirks & QUIRK_USE_KBD_BACKLIGHT) { ++ /* ++ * Skip these report ID, the device emits a continuous stream associated ++ * with the AURA mode it is in which looks like an 'echo'. ++ */ ++ if (report->id == FEATURE_KBD_LED_REPORT_ID1 || report->id == FEATURE_KBD_LED_REPORT_ID2) ++ return -1; ++ if (drvdata->quirks & QUIRK_ROG_NKEY_KEYBOARD) { + /* +- * Skip these report ID, the device emits a continuous stream associated +- * with the AURA mode it is in which looks like an 'echo'. ++ * G713 and G733 send these codes on some keypresses, depending on ++ * the key pressed it can trigger a shutdown event if not caught. + */ +- if (report->id == FEATURE_KBD_LED_REPORT_ID1 || +- report->id == FEATURE_KBD_LED_REPORT_ID2) { ++ if(data[0] == 0x02 && data[1] == 0x30) { + return -1; +- /* Additional report filtering */ +- } else if (report->id == FEATURE_KBD_REPORT_ID) { +- /* +- * G14 and G15 send these codes on some keypresses with no +- * discernable reason for doing so. We'll filter them out to avoid +- * unmapped warning messages later. +- */ +- if (data[1] == 0xea || data[1] == 0xec || data[1] == 0x02 || +- data[1] == 0x8a || data[1] == 0x9e) { +- return -1; +- } + } +- if (drvdata->quirks & QUIRK_ROG_NKEY_KEYBOARD) { +- /* +- * G713 and G733 send these codes on some keypresses, depending on +- * the key pressed it can trigger a shutdown event if not caught. +- */ +- if(data[0] == 0x02 && data[1] == 0x30) { +- return -1; +- } +- } +- + } + + if (drvdata->quirks & QUIRK_ROG_CLAYMORE_II_KEYBOARD) { +@@ -1250,6 +1234,19 @@ static __u8 *asus_report_fixup(struct hid_device *hdev, __u8 *rdesc, + rdesc[205] = 0x01; + } + ++ /* match many more n-key devices */ ++ if (drvdata->quirks & QUIRK_ROG_NKEY_KEYBOARD) { ++ for (int i = 0; i < *rsize + 1; i++) { ++ /* offset to the count from 0x5a report part always 14 */ ++ if (rdesc[i] == 0x85 && rdesc[i + 1] == 0x5a && ++ rdesc[i + 14] == 0x95 && rdesc[i + 15] == 0x05) { ++ hid_info(hdev, "Fixing up Asus N-Key report descriptor\n"); ++ rdesc[i + 15] = 0x01; ++ break; ++ } ++ } ++ } ++ + return rdesc; + } + +-- +2.44.0 + diff --git a/0001-linux6.7.y-bore4.0.0.patch b/0001-linux6.7.y-bore4.0.0.patch deleted file mode 100644 index 6d471fa9a783..000000000000 --- a/0001-linux6.7.y-bore4.0.0.patch +++ /dev/null @@ -1,668 +0,0 @@ -From fddf9e0e897d4b1a79755a042c5f3c66b2cdb949 Mon Sep 17 00:00:00 2001 -From: Masahito S <firelzrd@gmail.com> -Date: Sat, 6 Jan 2024 20:57:20 +0900 -Subject: [PATCH] linux6.7.y-bore4.0.0 - ---- - include/linux/sched.h | 11 ++ - init/Kconfig | 19 +++ - kernel/sched/core.c | 132 +++++++++++++++++++++ - kernel/sched/debug.c | 3 + - kernel/sched/fair.c | 253 +++++++++++++++++++++++++++++++++++++--- - kernel/sched/features.h | 4 + - 6 files changed, 404 insertions(+), 18 deletions(-) - -diff --git a/include/linux/sched.h b/include/linux/sched.h -index 292c316972..8a9e843ec5 100644 ---- a/include/linux/sched.h -+++ b/include/linux/sched.h -@@ -562,6 +562,17 @@ struct sched_entity { - u64 sum_exec_runtime; - u64 prev_sum_exec_runtime; - u64 vruntime; -+#ifdef CONFIG_SCHED_BORE -+ u64 burst_time; -+ u8 prev_burst_penalty; -+ u8 curr_burst_penalty; -+ u8 burst_penalty; -+ u8 slice_score; -+ u8 child_burst; -+ u16 child_burst_cnt; -+ u64 child_burst_last_cached; -+ u32 slice_load; -+#endif // CONFIG_SCHED_BORE - s64 vlag; - u64 slice; - -diff --git a/init/Kconfig b/init/Kconfig -index 9ffb103fc9..4492c5de88 100644 ---- a/init/Kconfig -+++ b/init/Kconfig -@@ -1258,6 +1258,25 @@ config CHECKPOINT_RESTORE - - If unsure, say N here. - -+config SCHED_BORE -+ bool "Burst-Oriented Response Enhancer" -+ default y -+ help -+ In Desktop and Mobile computing, one might prefer interactive -+ tasks to keep responsive no matter what they run in the background. -+ -+ Enabling this kernel feature modifies the scheduler to discriminate -+ tasks by their burst time (runtime since it last went sleeping or -+ yielding state) and prioritize those that run less bursty. -+ Such tasks usually include window compositor, widgets backend, -+ terminal emulator, video playback, games and so on. -+ With a little impact to scheduling fairness, it may improve -+ responsiveness especially under heavy background workload. -+ -+ You can turn it off by setting the sysctl kernel.sched_bore = 0. -+ -+ If unsure, say Y here. -+ - config SCHED_AUTOGROUP - bool "Automatic process group scheduling" - select CGROUPS -diff --git a/kernel/sched/core.c b/kernel/sched/core.c -index a708d225c2..7f2e796b77 100644 ---- a/kernel/sched/core.c -+++ b/kernel/sched/core.c -@@ -4480,6 +4480,127 @@ int wake_up_state(struct task_struct *p, unsigned int state) - return try_to_wake_up(p, state, 0); - } - -+#ifdef CONFIG_SCHED_BORE -+extern bool sched_bore; -+extern u8 sched_burst_fork_atavistic; -+extern uint sched_burst_cache_lifetime; -+ -+void __init sched_init_bore(void) { -+ init_task.se.burst_time = 0; -+ init_task.se.prev_burst_penalty = 0; -+ init_task.se.curr_burst_penalty = 0; -+ init_task.se.burst_penalty = 0; -+ init_task.se.slice_score = 0; -+ init_task.se.child_burst_last_cached = 0; -+ init_task.se.slice_load = 0; -+} -+ -+void inline sched_fork_bore(struct task_struct *p) { -+ p->se.burst_time = 0; -+ p->se.curr_burst_penalty = 0; -+ p->se.slice_score = 0; -+ p->se.child_burst_last_cached = 0; -+ p->se.slice_load = 0; -+} -+ -+static u32 count_child_tasks(struct task_struct *p) { -+ struct task_struct *child; -+ u32 cnt = 0; -+ list_for_each_entry(child, &p->children, sibling) {cnt++;} -+ return cnt; -+} -+ -+static inline bool child_burst_cache_expired(struct task_struct *p, u64 now) { -+ return (p->se.child_burst_last_cached + sched_burst_cache_lifetime < now); -+} -+ -+static void __update_child_burst_cache( -+ struct task_struct *p, u32 cnt, u32 sum, u64 now) { -+ u8 avg = 0; -+ if (cnt) avg = sum / cnt; -+ p->se.child_burst = max(avg, p->se.burst_penalty); -+ p->se.child_burst_cnt = cnt; -+ p->se.child_burst_last_cached = now; -+} -+ -+static void update_child_burst_cache(struct task_struct *p, u64 now) { -+ struct task_struct *child; -+ u32 cnt = 0; -+ u32 sum = 0; -+ -+ list_for_each_entry(child, &p->children, sibling) { -+ if (child->sched_class != &fair_sched_class) continue; -+ cnt++; -+ sum += child->se.burst_penalty; -+ } -+ -+ __update_child_burst_cache(p, cnt, sum, now); -+} -+ -+static void update_child_burst_cache_atavistic( -+ struct task_struct *p, u64 now, u32 depth, u32 *acnt, u32 *asum) { -+ struct task_struct *child, *dec; -+ u32 cnt = 0, dcnt = 0; -+ u32 sum = 0; -+ -+ list_for_each_entry(child, &p->children, sibling) { -+ dec = child; -+ while ((dcnt = count_child_tasks(dec)) == 1) -+ dec = list_first_entry(&dec->children, struct task_struct, sibling); -+ -+ if (!dcnt || !depth) { -+ if (dec->sched_class != &fair_sched_class) continue; -+ cnt++; -+ sum += dec->se.burst_penalty; -+ continue; -+ } -+ if (!child_burst_cache_expired(dec, now)) { -+ cnt += dec->se.child_burst_cnt; -+ sum += (u32)dec->se.child_burst * dec->se.child_burst_cnt; -+ continue; -+ } -+ update_child_burst_cache_atavistic(dec, now, depth - 1, &cnt, &sum); -+ } -+ -+ __update_child_burst_cache(p, cnt, sum, now); -+ *acnt += cnt; -+ *asum += sum; -+} -+ -+static void sched_post_fork_bore(struct task_struct *p) { -+ struct sched_entity *se = &p->se; -+ struct task_struct *anc; -+ u64 now; -+ u32 cnt = 0, sum = 0, depth; -+ u8 burst_cache; -+ -+ if (p->sched_class != &fair_sched_class) return; -+ -+ if (likely(sched_bore)) { -+ now = ktime_get_ns(); -+ read_lock(&tasklist_lock); -+ -+ anc = p->real_parent; -+ depth = sched_burst_fork_atavistic; -+ if (likely(depth)) { -+ while ((anc->real_parent != anc) && (count_child_tasks(anc) == 1)) -+ anc = anc->real_parent; -+ if (child_burst_cache_expired(anc, now)) -+ update_child_burst_cache_atavistic( -+ anc, now, depth - 1, &cnt, &sum); -+ } else -+ if (child_burst_cache_expired(anc, now)) -+ update_child_burst_cache(anc, now); -+ -+ burst_cache = anc->se.child_burst; -+ -+ read_unlock(&tasklist_lock); -+ se->prev_burst_penalty = max(se->prev_burst_penalty, burst_cache); -+ } -+ se->burst_penalty = se->prev_burst_penalty; -+} -+#endif // CONFIG_SCHED_BORE -+ - /* - * Perform scheduler related setup for a newly forked process p. - * p is forked by current. -@@ -4496,6 +4617,9 @@ static void __sched_fork(unsigned long clone_flags, struct task_struct *p) - p->se.prev_sum_exec_runtime = 0; - p->se.nr_migrations = 0; - p->se.vruntime = 0; -+#ifdef CONFIG_SCHED_BORE -+ sched_fork_bore(p); -+#endif // CONFIG_SCHED_BORE - p->se.vlag = 0; - p->se.slice = sysctl_sched_base_slice; - INIT_LIST_HEAD(&p->se.group_node); -@@ -4815,6 +4939,9 @@ void sched_cgroup_fork(struct task_struct *p, struct kernel_clone_args *kargs) - - void sched_post_fork(struct task_struct *p) - { -+#ifdef CONFIG_SCHED_BORE -+ sched_post_fork_bore(p); -+#endif // CONFIG_SCHED_BORE - uclamp_post_fork(p); - } - -@@ -9885,6 +10012,11 @@ void __init sched_init(void) - BUG_ON(&dl_sched_class != &stop_sched_class + 1); - #endif - -+#ifdef CONFIG_SCHED_BORE -+ sched_init_bore(); -+ printk(KERN_INFO "BORE (Burst-Oriented Response Enhancer) CPU Scheduler modification 4.0.0 by Masahito Suzuki"); -+#endif // CONFIG_SCHED_BORE -+ - wait_bit_init(); - - #ifdef CONFIG_FAIR_GROUP_SCHED -diff --git a/kernel/sched/debug.c b/kernel/sched/debug.c -index 4580a45070..cf2c694c94 100644 ---- a/kernel/sched/debug.c -+++ b/kernel/sched/debug.c -@@ -595,6 +595,9 @@ print_task(struct seq_file *m, struct rq *rq, struct task_struct *p) - SPLIT_NS(schedstat_val_or_zero(p->stats.sum_sleep_runtime)), - SPLIT_NS(schedstat_val_or_zero(p->stats.sum_block_runtime))); - -+#ifdef CONFIG_SCHED_BORE -+ SEQ_printf(m, " %2d", p->se.slice_score); -+#endif - #ifdef CONFIG_NUMA_BALANCING - SEQ_printf(m, " %d %d", task_node(p), task_numa_group_id(p)); - #endif -diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c -index d7a3c63a21..bfc1332995 100644 ---- a/kernel/sched/fair.c -+++ b/kernel/sched/fair.c -@@ -19,6 +19,9 @@ - * - * Adaptive scheduling granularity, math enhancements by Peter Zijlstra - * Copyright (C) 2007 Red Hat, Inc., Peter Zijlstra -+ * -+ * Burst-Oriented Response Enhancer (BORE) CPU Scheduler -+ * Copyright (C) 2021-2024 Masahito Suzuki <firelzrd@gmail.com> - */ - #include <linux/energy_model.h> - #include <linux/mmap_lock.h> -@@ -64,20 +67,122 @@ - * SCHED_TUNABLESCALING_LOG - scaled logarithmical, *1+ilog(ncpus) - * SCHED_TUNABLESCALING_LINEAR - scaled linear, *ncpus - * -- * (default SCHED_TUNABLESCALING_LOG = *(1+ilog(ncpus)) -+ * (BORE default SCHED_TUNABLESCALING_NONE = *1 constant) -+ * (EEVDF default SCHED_TUNABLESCALING_LOG = *(1+ilog(ncpus)) - */ -+#ifdef CONFIG_SCHED_BORE -+unsigned int sysctl_sched_tunable_scaling = SCHED_TUNABLESCALING_NONE; -+#else // CONFIG_SCHED_BORE - unsigned int sysctl_sched_tunable_scaling = SCHED_TUNABLESCALING_LOG; -+#endif // CONFIG_SCHED_BORE - - /* - * Minimal preemption granularity for CPU-bound tasks: - * -- * (default: 0.75 msec * (1 + ilog(ncpus)), units: nanoseconds) -+ * (BORE default: 3 msec constant, units: nanoseconds) -+ * (EEVDF default: 0.75 msec * (1 + ilog(ncpus)), units: nanoseconds) - */ -+#ifdef CONFIG_SCHED_BORE -+unsigned int sysctl_sched_base_slice = 3000000ULL; -+static unsigned int normalized_sysctl_sched_base_slice = 3000000ULL; -+#else // CONFIG_SCHED_BORE - unsigned int sysctl_sched_base_slice = 750000ULL; - static unsigned int normalized_sysctl_sched_base_slice = 750000ULL; -+#endif // CONFIG_SCHED_BORE - - const_debug unsigned int sysctl_sched_migration_cost = 500000UL; - -+#ifdef CONFIG_SCHED_BORE -+bool __read_mostly sched_bore = 1; -+bool __read_mostly sched_burst_score_rounding = 0; -+bool __read_mostly sched_burst_smoothness_long = 1; -+bool __read_mostly sched_burst_smoothness_short = 0; -+u8 __read_mostly sched_burst_fork_atavistic = 2; -+u8 __read_mostly sched_burst_penalty_offset = 22; -+uint __read_mostly sched_burst_penalty_scale = 1280; -+uint __read_mostly sched_burst_cache_lifetime = 60000000; -+static u8 sixty_four = 64; -+static uint maxval_12_bits = 4095; -+ -+#define MAX_BURST_PENALTY (39U <<2) -+ -+static inline u32 log2plus1_u64_u32f8(u64 v) { -+ u32 msb = fls64(v); -+ s32 excess_bits = msb - 9; -+ u8 fractional = (0 <= excess_bits)? v >> excess_bits: v << -excess_bits; -+ return msb << 8 | fractional; -+} -+ -+static inline u32 calc_burst_penalty(u64 burst_time) { -+ u32 greed, tolerance, penalty, scaled_penalty; -+ -+ greed = log2plus1_u64_u32f8(burst_time); -+ tolerance = sched_burst_penalty_offset << 8; -+ penalty = max(0, (s32)greed - (s32)tolerance); -+ scaled_penalty = penalty * sched_burst_penalty_scale >> 16; -+ -+ return min(MAX_BURST_PENALTY, scaled_penalty); -+} -+ -+static inline void update_burst_penalty(struct sched_entity *se) { -+ se->curr_burst_penalty = calc_burst_penalty(se->burst_time); -+ se->burst_penalty = max(se->prev_burst_penalty, se->curr_burst_penalty); -+} -+ -+static inline u64 scale_slice(u64 delta, struct sched_entity *se) { -+ return mul_u64_u32_shr(delta, sched_prio_to_wmult[se->slice_score], 22); -+} -+ -+static inline u64 __unscale_slice(u64 delta, u8 score) { -+ return mul_u64_u32_shr(delta, sched_prio_to_weight[score], 10); -+} -+ -+static inline u64 unscale_slice(u64 delta, struct sched_entity *se) { -+ return __unscale_slice(delta, se->slice_score); -+} -+ -+static void avg_vruntime_add(struct cfs_rq *cfs_rq, struct sched_entity *se); -+static void avg_vruntime_sub(struct cfs_rq *cfs_rq, struct sched_entity *se); -+ -+static void update_slice_score(struct sched_entity *se) { -+ struct cfs_rq *cfs_rq = cfs_rq_of(se); -+ u8 prev_score = se->slice_score; -+ u32 penalty = se->burst_penalty; -+ if (sched_burst_score_rounding) penalty += 0x2U; -+ se->slice_score = penalty >> 2; -+ -+ if (se->slice_score != prev_score && se->slice_load) { -+ avg_vruntime_sub(cfs_rq, se); -+ avg_vruntime_add(cfs_rq, se); -+ } -+} -+ -+static inline u32 binary_smooth(u32 new, u32 old) { -+ int increment = new - old; -+ return (0 <= increment)? -+ old + ( increment >> (int)sched_burst_smoothness_long): -+ old - (-increment >> (int)sched_burst_smoothness_short); -+} -+ -+static void restart_burst(struct sched_entity *se) { -+ se->burst_penalty = se->prev_burst_penalty = -+ binary_smooth(se->curr_burst_penalty, se->prev_burst_penalty); -+ se->curr_burst_penalty = 0; -+ se->burst_time = 0; -+ update_slice_score(se); -+} -+ -+static inline void restart_burst_rescale_deadline(struct sched_entity *se) { -+ u64 wremain, vremain = se->deadline - se->vruntime; -+ u8 prev_score = se->slice_score; -+ restart_burst(se); -+ if (prev_score > se->slice_score) { -+ wremain = __unscale_slice(vremain, prev_score); -+ se->deadline = se->vruntime + scale_slice(wremain, se); -+ } -+} -+#endif // CONFIG_SCHED_BORE -+ - int sched_thermal_decay_shift; - static int __init setup_sched_thermal_decay_shift(char *str) - { -@@ -137,6 +242,70 @@ static unsigned int sysctl_numa_balancing_promote_rate_limit = 65536; - - #ifdef CONFIG_SYSCTL - static struct ctl_table sched_fair_sysctls[] = { -+#ifdef CONFIG_SCHED_BORE -+ { -+ .procname = "sched_bore", -+ .data = &sched_bore, -+ .maxlen = sizeof(bool), -+ .mode = 0644, -+ .proc_handler = &proc_dobool, -+ }, -+ { -+ .procname = "sched_burst_cache_lifetime", -+ .data = &sched_burst_cache_lifetime, -+ .maxlen = sizeof(uint), -+ .mode = 0644, -+ .proc_handler = proc_douintvec, -+ }, -+ { -+ .procname = "sched_burst_fork_atavistic", -+ .data = &sched_burst_fork_atavistic, -+ .maxlen = sizeof(u8), -+ .mode = 0644, -+ .proc_handler = &proc_dou8vec_minmax, -+ .extra1 = SYSCTL_ZERO, -+ .extra2 = SYSCTL_THREE, -+ }, -+ { -+ .procname = "sched_burst_penalty_offset", -+ .data = &sched_burst_penalty_offset, -+ .maxlen = sizeof(u8), -+ .mode = 0644, -+ .proc_handler = &proc_dou8vec_minmax, -+ .extra1 = SYSCTL_ZERO, -+ .extra2 = &sixty_four, -+ }, -+ { -+ .procname = "sched_burst_penalty_scale", -+ .data = &sched_burst_penalty_scale, -+ .maxlen = sizeof(uint), -+ .mode = 0644, -+ .proc_handler = &proc_douintvec_minmax, -+ .extra1 = SYSCTL_ZERO, -+ .extra2 = &maxval_12_bits, -+ }, -+ { -+ .procname = "sched_burst_score_rounding", -+ .data = &sched_burst_score_rounding, -+ .maxlen = sizeof(bool), -+ .mode = 0644, -+ .proc_handler = &proc_dobool, -+ }, -+ { -+ .procname = "sched_burst_smoothness_long", -+ .data = &sched_burst_smoothness_long, -+ .maxlen = sizeof(bool), -+ .mode = 0644, -+ .proc_handler = &proc_dobool, -+ }, -+ { -+ .procname = "sched_burst_smoothness_short", -+ .data = &sched_burst_smoothness_short, -+ .maxlen = sizeof(bool), -+ .mode = 0644, -+ .proc_handler = &proc_dobool, -+ }, -+#endif // CONFIG_SCHED_BORE - #ifdef CONFIG_CFS_BANDWIDTH - { - .procname = "sched_cfs_bandwidth_slice_us", -@@ -298,6 +467,9 @@ static inline u64 calc_delta_fair(u64 delta, struct sched_entity *se) - if (unlikely(se->load.weight != NICE_0_LOAD)) - delta = __calc_delta(delta, NICE_0_LOAD, &se->load); - -+#ifdef CONFIG_SCHED_BORE -+ if (likely(sched_bore)) delta = scale_slice(delta, se); -+#endif // CONFIG_SCHED_BORE - return delta; - } - -@@ -620,10 +792,22 @@ static inline s64 entity_key(struct cfs_rq *cfs_rq, struct sched_entity *se) - * - * As measured, the max (key * weight) value was ~44 bits for a kernel build. - */ -+static unsigned long calc_avg_load_weight(struct sched_entity *se) { -+ unsigned long weight = scale_load_down(se->load.weight); -+#ifdef CONFIG_SCHED_BORE -+ weight <<= 5; -+ if (likely(sched_bore)) weight = unscale_slice(weight, se); -+#endif // CONFIG_SCHED_BORE -+ return weight; -+} -+ - static void - avg_vruntime_add(struct cfs_rq *cfs_rq, struct sched_entity *se) - { -- unsigned long weight = scale_load_down(se->load.weight); -+ unsigned long weight = calc_avg_load_weight(se); -+#ifdef CONFIG_SCHED_BORE -+ se->slice_load = weight; -+#endif // CONFIG_SCHED_BORE - s64 key = entity_key(cfs_rq, se); - - cfs_rq->avg_vruntime += key * weight; -@@ -633,7 +817,13 @@ avg_vruntime_add(struct cfs_rq *cfs_rq, struct sched_entity *se) - static void - avg_vruntime_sub(struct cfs_rq *cfs_rq, struct sched_entity *se) - { -- unsigned long weight = scale_load_down(se->load.weight); -+ unsigned long weight; -+#if !defined(CONFIG_SCHED_BORE) -+ weight = scale_load_down(se->load.weight); -+#else // CONFIG_SCHED_BORE -+ weight = se->slice_load; -+ se->slice_load = 0; -+#endif // CONFIG_SCHED_BORE - s64 key = entity_key(cfs_rq, se); - - cfs_rq->avg_vruntime -= key * weight; -@@ -653,14 +843,14 @@ void avg_vruntime_update(struct cfs_rq *cfs_rq, s64 delta) - * Specifically: avg_runtime() + 0 must result in entity_eligible() := true - * For this to be so, the result of this function must have a left bias. - */ --u64 avg_vruntime(struct cfs_rq *cfs_rq) -+static u64 avg_key(struct cfs_rq *cfs_rq) - { - struct sched_entity *curr = cfs_rq->curr; - s64 avg = cfs_rq->avg_vruntime; - long load = cfs_rq->avg_load; - - if (curr && curr->on_rq) { -- unsigned long weight = scale_load_down(curr->load.weight); -+ unsigned long weight = calc_avg_load_weight(curr); - - avg += entity_key(cfs_rq, curr) * weight; - load += weight; -@@ -673,7 +863,11 @@ u64 avg_vruntime(struct cfs_rq *cfs_rq) - avg = div_s64(avg, load); - } - -- return cfs_rq->min_vruntime + avg; -+ return avg; -+} -+ -+inline u64 avg_vruntime(struct cfs_rq *cfs_rq) { -+ return cfs_rq->min_vruntime + avg_key(cfs_rq); - } - - /* -@@ -694,13 +888,8 @@ u64 avg_vruntime(struct cfs_rq *cfs_rq) - */ - static void update_entity_lag(struct cfs_rq *cfs_rq, struct sched_entity *se) - { -- s64 lag, limit; -- - SCHED_WARN_ON(!se->on_rq); -- lag = avg_vruntime(cfs_rq) - se->vruntime; -- -- limit = calc_delta_fair(max_t(u64, 2*se->slice, TICK_NSEC), se); -- se->vlag = clamp(lag, -limit, limit); -+ se->vlag = avg_vruntime(cfs_rq) - se->vruntime; - } - - /* -@@ -727,7 +916,7 @@ int entity_eligible(struct cfs_rq *cfs_rq, struct sched_entity *se) - long load = cfs_rq->avg_load; - - if (curr && curr->on_rq) { -- unsigned long weight = scale_load_down(curr->load.weight); -+ unsigned long weight = calc_avg_load_weight(curr); - - avg += entity_key(cfs_rq, curr) * weight; - load += weight; -@@ -1016,6 +1205,9 @@ static void update_deadline(struct cfs_rq *cfs_rq, struct sched_entity *se) - /* - * EEVDF: vd_i = ve_i + r_i / w_i - */ -+#ifdef CONFIG_SCHED_BORE -+ update_slice_score(se); -+#endif // CONFIG_SCHED_BORE - se->deadline = se->vruntime + calc_delta_fair(se->slice, se); - - /* -@@ -1158,7 +1350,11 @@ static void update_curr(struct cfs_rq *cfs_rq) - curr->sum_exec_runtime += delta_exec; - schedstat_add(cfs_rq->exec_clock, delta_exec); - -- curr->vruntime += calc_delta_fair(delta_exec, curr); -+#ifdef CONFIG_SCHED_BORE -+ curr->burst_time += delta_exec; -+ update_burst_penalty(curr); -+#endif // CONFIG_SCHED_BORE -+ curr->vruntime += max(1ULL, calc_delta_fair(delta_exec, curr)); - update_deadline(cfs_rq, curr); - update_min_vruntime(cfs_rq); - -@@ -5131,7 +5327,12 @@ place_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags) - struct sched_entity *curr = cfs_rq->curr; - unsigned long load; - -- lag = se->vlag; -+ u64 limit = calc_delta_fair(max_t(u64, se->slice*2, TICK_NSEC), se); -+ s64 overmet = limit, undermet = limit; -+#ifdef CONFIG_SCHED_BORE -+ if (likely(sched_bore)) overmet /= 2; -+#endif // CONFIG_SCHED_BORE -+ lag = clamp(se->vlag, -overmet, undermet); - - /* - * If we want to place a task and preserve lag, we have to -@@ -5187,9 +5388,9 @@ place_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags) - */ - load = cfs_rq->avg_load; - if (curr && curr->on_rq) -- load += scale_load_down(curr->load.weight); -+ load += calc_avg_load_weight(curr); - -- lag *= load + scale_load_down(se->load.weight); -+ lag *= load + calc_avg_load_weight(se); - if (WARN_ON_ONCE(!load)) - load = 1; - lag = div_s64(lag, load); -@@ -6759,6 +6960,12 @@ static void dequeue_task_fair(struct rq *rq, struct task_struct *p, int flags) - bool was_sched_idle = sched_idle_rq(rq); - - util_est_dequeue(&rq->cfs, p); -+#ifdef CONFIG_SCHED_BORE -+ if (task_sleep) { -+ update_curr(cfs_rq_of(se)); -+ restart_burst(se); -+ } -+#endif // CONFIG_SCHED_BORE - - for_each_sched_entity(se) { - cfs_rq = cfs_rq_of(se); -@@ -8494,6 +8701,9 @@ static void yield_task_fair(struct rq *rq) - /* - * Are we the only task in the tree? - */ -+#ifdef CONFIG_SCHED_BORE -+ if (unlikely(!sched_bore)) -+#endif // CONFIG_SCHED_BORE - if (unlikely(rq->nr_running == 1)) - return; - -@@ -8510,6 +8720,10 @@ static void yield_task_fair(struct rq *rq) - * and double the fastpath cost. - */ - rq_clock_skip_update(rq); -+#ifdef CONFIG_SCHED_BORE -+ restart_burst_rescale_deadline(se); -+ if (unlikely(rq->nr_running == 1)) return; -+#endif // CONFIG_SCHED_BORE - - se->deadline += calc_delta_fair(se->slice, se); - } -@@ -12590,6 +12804,9 @@ static void task_fork_fair(struct task_struct *p) - curr = cfs_rq->curr; - if (curr) - update_curr(cfs_rq); -+#ifdef CONFIG_SCHED_BORE -+ update_slice_score(se); -+#endif // CONFIG_SCHED_BORE - place_entity(cfs_rq, se, ENQUEUE_INITIAL); - rq_unlock(rq, &rf); - } -diff --git a/kernel/sched/features.h b/kernel/sched/features.h -index a3ddf84de4..841a428579 100644 ---- a/kernel/sched/features.h -+++ b/kernel/sched/features.h -@@ -6,7 +6,11 @@ - */ - SCHED_FEAT(PLACE_LAG, true) - SCHED_FEAT(PLACE_DEADLINE_INITIAL, true) -+#ifdef CONFIG_SCHED_BORE -+SCHED_FEAT(RUN_TO_PARITY, false) -+#else // CONFIG_SCHED_BORE - SCHED_FEAT(RUN_TO_PARITY, true) -+#endif // CONFIG_SCHED_BORE - - /* - * Prefer to schedule the task we woke last (assuming it failed --- -2.25.1 diff --git a/0001-linux6.8.y-bore4.5.2.patch b/0001-linux6.8.y-bore4.5.2.patch new file mode 100644 index 000000000000..8685a1f63021 --- /dev/null +++ b/0001-linux6.8.y-bore4.5.2.patch @@ -0,0 +1,909 @@ +From a0fa22cd814b0b208fcb981db1b9482e6c6223d9 Mon Sep 17 00:00:00 2001 +From: Masahito S <firelzrd@gmail.com> +Date: Fri, 8 Mar 2024 04:20:57 +0900 +Subject: [PATCH] linux6.8.y-bore4.5.2 + +--- + include/linux/sched.h | 12 ++ + init/Kconfig | 19 +++ + kernel/sched/core.c | 148 +++++++++++++++++++ + kernel/sched/debug.c | 61 +++++++- + kernel/sched/fair.c | 306 ++++++++++++++++++++++++++++++++++++++-- + kernel/sched/features.h | 4 + + kernel/sched/sched.h | 7 + + 7 files changed, 542 insertions(+), 15 deletions(-) + +diff --git a/include/linux/sched.h b/include/linux/sched.h +index ffe8f618ab..7ac6163f90 100644 +--- a/include/linux/sched.h ++++ b/include/linux/sched.h +@@ -547,6 +547,18 @@ struct sched_entity { + u64 sum_exec_runtime; + u64 prev_sum_exec_runtime; + u64 vruntime; ++#ifdef CONFIG_SCHED_BORE ++ u64 burst_time; ++ u8 prev_burst_penalty; ++ u8 curr_burst_penalty; ++ u8 burst_penalty; ++ u8 burst_score; ++ u32 burst_load; ++ bool on_cfs_rq; ++ u8 child_burst; ++ u32 child_burst_cnt; ++ u64 child_burst_last_cached; ++#endif // CONFIG_SCHED_BORE + s64 vlag; + u64 slice; + +diff --git a/init/Kconfig b/init/Kconfig +index deda3d1413..9fa6b45c03 100644 +--- a/init/Kconfig ++++ b/init/Kconfig +@@ -1270,6 +1270,25 @@ config CHECKPOINT_RESTORE + + If unsure, say N here. + ++config SCHED_BORE ++ bool "Burst-Oriented Response Enhancer" ++ default y ++ help ++ In Desktop and Mobile computing, one might prefer interactive ++ tasks to keep responsive no matter what they run in the background. ++ ++ Enabling this kernel feature modifies the scheduler to discriminate ++ tasks by their burst time (runtime since it last went sleeping or ++ yielding state) and prioritize those that run less bursty. ++ Such tasks usually include window compositor, widgets backend, ++ terminal emulator, video playback, games and so on. ++ With a little impact to scheduling fairness, it may improve ++ responsiveness especially under heavy background workload. ++ ++ You can turn it off by setting the sysctl kernel.sched_bore = 0. ++ ++ If unsure, say Y here. ++ + config SCHED_AUTOGROUP + bool "Automatic process group scheduling" + select CGROUPS +diff --git a/kernel/sched/core.c b/kernel/sched/core.c +index 9116bcc903..43e4311dba 100644 +--- a/kernel/sched/core.c ++++ b/kernel/sched/core.c +@@ -4507,6 +4507,143 @@ int wake_up_state(struct task_struct *p, unsigned int state) + return try_to_wake_up(p, state, 0); + } + ++#ifdef CONFIG_SCHED_BORE ++extern bool sched_bore; ++extern u8 sched_burst_fork_atavistic; ++extern uint sched_burst_cache_lifetime; ++ ++static void __init sched_init_bore(void) { ++ init_task.se.burst_time = 0; ++ init_task.se.prev_burst_penalty = 0; ++ init_task.se.curr_burst_penalty = 0; ++ init_task.se.burst_penalty = 0; ++ init_task.se.burst_score = 0; ++ init_task.se.on_cfs_rq = false; ++ init_task.se.child_burst_last_cached = 0; ++ init_task.se.burst_load = 0; ++} ++ ++void inline sched_fork_bore(struct task_struct *p) { ++ p->se.burst_time = 0; ++ p->se.curr_burst_penalty = 0; ++ p->se.burst_score = 0; ++ p->se.on_cfs_rq = false; ++ p->se.child_burst_last_cached = 0; ++ p->se.burst_load = 0; ++} ++ ++static u32 count_child_tasks(struct task_struct *p) { ++ struct task_struct *child; ++ u32 cnt = 0; ++ list_for_each_entry(child, &p->children, sibling) {cnt++;} ++ return cnt; ++} ++ ++static inline bool task_is_inheritable(struct task_struct *p) { ++ return (p->sched_class == &fair_sched_class); ++} ++ ++static inline bool child_burst_cache_expired(struct task_struct *p, u64 now) { ++ u64 expiration_time = ++ p->se.child_burst_last_cached + sched_burst_cache_lifetime; ++ return ((s64)(expiration_time - now) < 0); ++} ++ ++static void __update_child_burst_cache( ++ struct task_struct *p, u32 cnt, u32 sum, u64 now) { ++ u8 avg = 0; ++ if (cnt) avg = sum / cnt; ++ p->se.child_burst = max(avg, p->se.burst_penalty); ++ p->se.child_burst_cnt = cnt; ++ p->se.child_burst_last_cached = now; ++} ++ ++static inline void update_child_burst_direct(struct task_struct *p, u64 now) { ++ struct task_struct *child; ++ u32 cnt = 0; ++ u32 sum = 0; ++ ++ list_for_each_entry(child, &p->children, sibling) { ++ if (!task_is_inheritable(child)) continue; ++ cnt++; ++ sum += child->se.burst_penalty; ++ } ++ ++ __update_child_burst_cache(p, cnt, sum, now); ++} ++ ++static inline u8 __inherit_burst_direct(struct task_struct *p, u64 now) { ++ struct task_struct *parent = p->real_parent; ++ if (child_burst_cache_expired(parent, now)) ++ update_child_burst_direct(parent, now); ++ ++ return parent->se.child_burst; ++} ++ ++static void update_child_burst_topological( ++ struct task_struct *p, u64 now, u32 depth, u32 *acnt, u32 *asum) { ++ struct task_struct *child, *dec; ++ u32 cnt = 0, dcnt = 0; ++ u32 sum = 0; ++ ++ list_for_each_entry(child, &p->children, sibling) { ++ dec = child; ++ while ((dcnt = count_child_tasks(dec)) == 1) ++ dec = list_first_entry(&dec->children, struct task_struct, sibling); ++ ++ if (!dcnt || !depth) { ++ if (!task_is_inheritable(dec)) continue; ++ cnt++; ++ sum += dec->se.burst_penalty; ++ continue; ++ } ++ if (!child_burst_cache_expired(dec, now)) { ++ cnt += dec->se.child_burst_cnt; ++ sum += (u32)dec->se.child_burst * dec->se.child_burst_cnt; ++ continue; ++ } ++ update_child_burst_topological(dec, now, depth - 1, &cnt, &sum); ++ } ++ ++ __update_child_burst_cache(p, cnt, sum, now); ++ *acnt += cnt; ++ *asum += sum; ++} ++ ++static inline u8 __inherit_burst_topological(struct task_struct *p, u64 now) { ++ struct task_struct *anc = p->real_parent; ++ u32 cnt = 0, sum = 0; ++ ++ while (anc->real_parent != anc && count_child_tasks(anc) == 1) ++ anc = anc->real_parent; ++ ++ if (child_burst_cache_expired(anc, now)) ++ update_child_burst_topological( ++ anc, now, sched_burst_fork_atavistic - 1, &cnt, &sum); ++ ++ return anc->se.child_burst; ++} ++ ++static inline void inherit_burst(struct task_struct *p) { ++ u8 burst_cache; ++ u64 now = ktime_get_ns(); ++ ++ read_lock(&tasklist_lock); ++ burst_cache = likely(sched_burst_fork_atavistic)? ++ __inherit_burst_topological(p, now): ++ __inherit_burst_direct(p, now); ++ read_unlock(&tasklist_lock); ++ ++ p->se.prev_burst_penalty = max(p->se.prev_burst_penalty, burst_cache); ++} ++ ++static void sched_post_fork_bore(struct task_struct *p) { ++ if (p->sched_class == &fair_sched_class && likely(sched_bore)) ++ inherit_burst(p); ++ p->se.burst_penalty = p->se.prev_burst_penalty; ++} ++#endif // CONFIG_SCHED_BORE ++ + /* + * Perform scheduler related setup for a newly forked process p. + * p is forked by current. +@@ -4523,6 +4660,9 @@ static void __sched_fork(unsigned long clone_flags, struct task_struct *p) + p->se.prev_sum_exec_runtime = 0; + p->se.nr_migrations = 0; + p->se.vruntime = 0; ++#ifdef CONFIG_SCHED_BORE ++ sched_fork_bore(p); ++#endif // CONFIG_SCHED_BORE + p->se.vlag = 0; + p->se.slice = sysctl_sched_base_slice; + INIT_LIST_HEAD(&p->se.group_node); +@@ -4839,6 +4979,9 @@ void sched_cgroup_fork(struct task_struct *p, struct kernel_clone_args *kargs) + + void sched_post_fork(struct task_struct *p) + { ++#ifdef CONFIG_SCHED_BORE ++ sched_post_fork_bore(p); ++#endif // CONFIG_SCHED_BORE + uclamp_post_fork(p); + } + +@@ -9910,6 +10053,11 @@ void __init sched_init(void) + BUG_ON(&dl_sched_class != &stop_sched_class + 1); + #endif + ++#ifdef CONFIG_SCHED_BORE ++ sched_init_bore(); ++ printk(KERN_INFO "BORE (Burst-Oriented Response Enhancer) CPU Scheduler modification 4.5.2 by Masahito Suzuki"); ++#endif // CONFIG_SCHED_BORE ++ + wait_bit_init(); + + #ifdef CONFIG_FAIR_GROUP_SCHED +diff --git a/kernel/sched/debug.c b/kernel/sched/debug.c +index 8d5d98a583..a565363fdd 100644 +--- a/kernel/sched/debug.c ++++ b/kernel/sched/debug.c +@@ -167,7 +167,52 @@ static const struct file_operations sched_feat_fops = { + }; + + #ifdef CONFIG_SMP ++#ifdef CONFIG_SCHED_BORE ++static ssize_t sched_min_base_slice_write(struct file *filp, const char __user *ubuf, ++ size_t cnt, loff_t *ppos) ++{ ++ char buf[16]; ++ unsigned int value; ++ ++ if (cnt > 15) ++ cnt = 15; ++ ++ if (copy_from_user(&buf, ubuf, cnt)) ++ return -EFAULT; ++ buf[cnt] = '\0'; ++ ++ if (kstrtouint(buf, 10, &value)) ++ return -EINVAL; + ++ if (!value) ++ return -EINVAL; ++ ++ sysctl_sched_min_base_slice = value; ++ sched_update_min_base_slice(); ++ ++ *ppos += cnt; ++ return cnt; ++} ++ ++static int sched_min_base_slice_show(struct seq_file *m, void *v) ++{ ++ seq_printf(m, "%d\n", sysctl_sched_min_base_slice); ++ return 0; ++} ++ ++static int sched_min_base_slice_open(struct inode *inode, struct file *filp) ++{ ++ return single_open(filp, sched_min_base_slice_show, NULL); ++} ++ ++static const struct file_operations sched_min_base_slice_fops = { ++ .open = sched_min_base_slice_open, ++ .write = sched_min_base_slice_write, ++ .read = seq_read, ++ .llseek = seq_lseek, ++ .release = single_release, ++}; ++#else // !CONFIG_SCHED_BORE + static ssize_t sched_scaling_write(struct file *filp, const char __user *ubuf, + size_t cnt, loff_t *ppos) + { +@@ -213,7 +258,7 @@ static const struct file_operations sched_scaling_fops = { + .llseek = seq_lseek, + .release = single_release, + }; +- ++#endif // CONFIG_SCHED_BORE + #endif /* SMP */ + + #ifdef CONFIG_PREEMPT_DYNAMIC +@@ -347,13 +392,20 @@ static __init int sched_init_debug(void) + debugfs_create_file("preempt", 0644, debugfs_sched, NULL, &sched_dynamic_fops); + #endif + ++#ifdef CONFIG_SCHED_BORE ++ debugfs_create_file("min_base_slice_ns", 0644, debugfs_sched, NULL, &sched_min_base_slice_fops); ++ debugfs_create_u32("base_slice_ns", 0400, debugfs_sched, &sysctl_sched_base_slice); ++#else // !CONFIG_SCHED_BORE + debugfs_create_u32("base_slice_ns", 0644, debugfs_sched, &sysctl_sched_base_slice); ++#endif // CONFIG_SCHED_BORE + + debugfs_create_u32("latency_warn_ms", 0644, debugfs_sched, &sysctl_resched_latency_warn_ms); + debugfs_create_u32("latency_warn_once", 0644, debugfs_sched, &sysctl_resched_latency_warn_once); + + #ifdef CONFIG_SMP ++#if !defined(CONFIG_SCHED_BORE) + debugfs_create_file("tunable_scaling", 0644, debugfs_sched, NULL, &sched_scaling_fops); ++#endif // CONFIG_SCHED_BORE + debugfs_create_u32("migration_cost_ns", 0644, debugfs_sched, &sysctl_sched_migration_cost); + debugfs_create_u32("nr_migrate", 0644, debugfs_sched, &sysctl_sched_nr_migrate); + +@@ -595,6 +647,9 @@ print_task(struct seq_file *m, struct rq *rq, struct task_struct *p) + SPLIT_NS(schedstat_val_or_zero(p->stats.sum_sleep_runtime)), + SPLIT_NS(schedstat_val_or_zero(p->stats.sum_block_runtime))); + ++#ifdef CONFIG_SCHED_BORE ++ SEQ_printf(m, " %2d", p->se.burst_score); ++#endif // CONFIG_SCHED_BORE + #ifdef CONFIG_NUMA_BALANCING + SEQ_printf(m, " %d %d", task_node(p), task_numa_group_id(p)); + #endif +@@ -1068,6 +1123,10 @@ void proc_sched_show_task(struct task_struct *p, struct pid_namespace *ns, + + P(se.load.weight); + #ifdef CONFIG_SMP ++#ifdef CONFIG_SCHED_BORE ++ P(se.burst_load); ++ P(se.burst_score); ++#endif // CONFIG_SCHED_BORE + P(se.avg.load_sum); + P(se.avg.runnable_sum); + P(se.avg.util_sum); +diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c +index 533547e3c9..3ee4e7e70e 100644 +--- a/kernel/sched/fair.c ++++ b/kernel/sched/fair.c +@@ -19,6 +19,9 @@ + * + * Adaptive scheduling granularity, math enhancements by Peter Zijlstra + * Copyright (C) 2007 Red Hat, Inc., Peter Zijlstra ++ * ++ * Burst-Oriented Response Enhancer (BORE) CPU Scheduler ++ * Copyright (C) 2021-2024 Masahito Suzuki <firelzrd@gmail.com> + */ + #include <linux/energy_model.h> + #include <linux/mmap_lock.h> +@@ -64,20 +67,129 @@ + * SCHED_TUNABLESCALING_LOG - scaled logarithmical, *1+ilog(ncpus) + * SCHED_TUNABLESCALING_LINEAR - scaled linear, *ncpus + * +- * (default SCHED_TUNABLESCALING_LOG = *(1+ilog(ncpus)) ++ * (BORE default SCHED_TUNABLESCALING_NONE = *1 constant) ++ * (EEVDF default SCHED_TUNABLESCALING_LOG = *(1+ilog(ncpus)) + */ ++#ifdef CONFIG_SCHED_BORE ++unsigned int sysctl_sched_tunable_scaling = SCHED_TUNABLESCALING_NONE; ++#else // !CONFIG_SCHED_BORE + unsigned int sysctl_sched_tunable_scaling = SCHED_TUNABLESCALING_LOG; ++#endif // CONFIG_SCHED_BORE + + /* + * Minimal preemption granularity for CPU-bound tasks: + * +- * (default: 0.75 msec * (1 + ilog(ncpus)), units: nanoseconds) ++ * (BORE default: max(1 sec / HZ, min_base_slice) constant, units: nanoseconds) ++ * (EEVDF default: 0.75 msec * (1 + ilog(ncpus)), units: nanoseconds) + */ ++#ifdef CONFIG_SCHED_BORE ++unsigned int sysctl_sched_base_slice = 1000000000ULL / HZ; ++static unsigned int configured_sched_base_slice = 1000000000ULL / HZ; ++unsigned int sysctl_sched_min_base_slice = 2000000ULL; ++#else // !CONFIG_SCHED_BORE + unsigned int sysctl_sched_base_slice = 750000ULL; + static unsigned int normalized_sysctl_sched_base_slice = 750000ULL; ++#endif // CONFIG_SCHED_BORE + + const_debug unsigned int sysctl_sched_migration_cost = 500000UL; + ++#ifdef CONFIG_SCHED_BORE ++u8 __read_mostly sched_bore = 1; ++u8 __read_mostly sched_burst_score_rounding = 0; ++u8 __read_mostly sched_burst_smoothness_long = 1; ++u8 __read_mostly sched_burst_smoothness_short = 0; ++u8 __read_mostly sched_burst_fork_atavistic = 2; ++u8 __read_mostly sched_burst_penalty_offset = 22; ++uint __read_mostly sched_burst_penalty_scale = 1280; ++uint __read_mostly sched_burst_cache_lifetime = 60000000; ++u8 __read_mostly sched_vlag_deviation_limit = 11; ++static int __maybe_unused thirty_two = 32; ++static int __maybe_unused sixty_four = 64; ++static int __maybe_unused maxval_12_bits = 4095; ++ ++#define MAX_BURST_PENALTY (39U <<2) ++ ++static inline u32 log2plus1_u64_u32f8(u64 v) { ++ u32 msb = fls64(v); ++ s32 excess_bits = msb - 9; ++ u8 fractional = (0 <= excess_bits)? v >> excess_bits: v << -excess_bits; ++ return msb << 8 | fractional; ++} ++ ++static inline u32 calc_burst_penalty(u64 burst_time) { ++ u32 greed, tolerance, penalty, scaled_penalty; ++ ++ greed = log2plus1_u64_u32f8(burst_time); ++ tolerance = sched_burst_penalty_offset << 8; ++ penalty = max(0, (s32)greed - (s32)tolerance); ++ scaled_penalty = penalty * sched_burst_penalty_scale >> 16; ++ ++ return min(MAX_BURST_PENALTY, scaled_penalty); ++} ++ ++static inline u64 scale_slice(u64 delta, struct sched_entity *se) { ++ return mul_u64_u32_shr(delta, sched_prio_to_wmult[se->burst_score], 22); ++} ++ ++static inline u64 __unscale_slice(u64 delta, u8 score) { ++ return mul_u64_u32_shr(delta, sched_prio_to_weight[score], 10); ++} ++ ++static inline u64 unscale_slice(u64 delta, struct sched_entity *se) { ++ return __unscale_slice(delta, se->burst_score); ++} ++ ++static void avg_vruntime_add(struct cfs_rq *cfs_rq, struct sched_entity *se); ++static void avg_vruntime_sub(struct cfs_rq *cfs_rq, struct sched_entity *se); ++ ++static void update_burst_score(struct sched_entity *se) { ++ struct cfs_rq *cfs_rq = cfs_rq_of(se); ++ u8 prev_score = se->burst_score; ++ u32 penalty = se->burst_penalty; ++ if (sched_burst_score_rounding) penalty += 0x2U; ++ se->burst_score = penalty >> 2; ++ ++ if ((se->burst_score != prev_score) && se->on_cfs_rq) { ++ avg_vruntime_sub(cfs_rq, se); ++ avg_vruntime_add(cfs_rq, se); ++ } ++} ++ ++static void update_burst_penalty(struct sched_entity *se) { ++ se->curr_burst_penalty = calc_burst_penalty(se->burst_time); ++ se->burst_penalty = max(se->prev_burst_penalty, se->curr_burst_penalty); ++ update_burst_score(se); ++} ++ ++static inline u32 binary_smooth(u32 new, u32 old) { ++ int increment = new - old; ++ return (0 <= increment)? ++ old + ( increment >> (int)sched_burst_smoothness_long): ++ old - (-increment >> (int)sched_burst_smoothness_short); ++} ++ ++static void restart_burst(struct sched_entity *se) { ++ se->burst_penalty = se->prev_burst_penalty = ++ binary_smooth(se->curr_burst_penalty, se->prev_burst_penalty); ++ se->curr_burst_penalty = 0; ++ se->burst_time = 0; ++ update_burst_score(se); ++} ++ ++static void restart_burst_rescale_deadline(struct sched_entity *se) { ++ s64 vscaled, wremain, vremain = se->deadline - se->vruntime; ++ u8 prev_score = se->burst_score; ++ restart_burst(se); ++ if (prev_score > se->burst_score) { ++ wremain = __unscale_slice(abs(vremain), prev_score); ++ vscaled = scale_slice(wremain, se); ++ if (unlikely(vremain < 0)) ++ vscaled = -vscaled; ++ se->deadline = se->vruntime + vscaled; ++ } ++} ++#endif // CONFIG_SCHED_BORE ++ + int sched_thermal_decay_shift; + static int __init setup_sched_thermal_decay_shift(char *str) + { +@@ -137,6 +249,87 @@ static unsigned int sysctl_numa_balancing_promote_rate_limit = 65536; + + #ifdef CONFIG_SYSCTL + static struct ctl_table sched_fair_sysctls[] = { ++#ifdef CONFIG_SCHED_BORE ++ { ++ .procname = "sched_bore", ++ .data = &sched_bore, ++ .maxlen = sizeof(u8), ++ .mode = 0644, ++ .proc_handler = proc_dou8vec_minmax, ++ .extra1 = SYSCTL_ZERO, ++ .extra2 = SYSCTL_ONE, ++ }, ++ { ++ .procname = "sched_burst_score_rounding", ++ .data = &sched_burst_score_rounding, ++ .maxlen = sizeof(u8), ++ .mode = 0644, ++ .proc_handler = proc_dou8vec_minmax, ++ .extra1 = SYSCTL_ZERO, ++ .extra2 = SYSCTL_ONE, ++ }, ++ { ++ .procname = "sched_burst_smoothness_long", ++ .data = &sched_burst_smoothness_long, ++ .maxlen = sizeof(u8), ++ .mode = 0644, ++ .proc_handler = proc_dou8vec_minmax, ++ .extra1 = SYSCTL_ZERO, ++ .extra2 = SYSCTL_ONE, ++ }, ++ { ++ .procname = "sched_burst_smoothness_short", ++ .data = &sched_burst_smoothness_short, ++ .maxlen = sizeof(u8), ++ .mode = 0644, ++ .proc_handler = proc_dou8vec_minmax, ++ .extra1 = SYSCTL_ZERO, ++ .extra2 = SYSCTL_ONE, ++ }, ++ { ++ .procname = "sched_burst_fork_atavistic", ++ .data = &sched_burst_fork_atavistic, ++ .maxlen = sizeof(u8), ++ .mode = 0644, ++ .proc_handler = proc_dou8vec_minmax, ++ .extra1 = SYSCTL_ZERO, ++ .extra2 = SYSCTL_THREE, ++ }, ++ { ++ .procname = "sched_burst_penalty_offset", ++ .data = &sched_burst_penalty_offset, ++ .maxlen = sizeof(u8), ++ .mode = 0644, ++ .proc_handler = proc_dou8vec_minmax, ++ .extra1 = SYSCTL_ZERO, ++ .extra2 = &sixty_four, ++ }, ++ { ++ .procname = "sched_burst_penalty_scale", ++ .data = &sched_burst_penalty_scale, ++ .maxlen = sizeof(uint), ++ .mode = 0644, ++ .proc_handler = proc_douintvec_minmax, ++ .extra1 = SYSCTL_ZERO, ++ .extra2 = &maxval_12_bits, ++ }, ++ { ++ .procname = "sched_burst_cache_lifetime", ++ .data = &sched_burst_cache_lifetime, ++ .maxlen = sizeof(uint), ++ .mode = 0644, ++ .proc_handler = proc_douintvec, ++ }, ++ { ++ .procname = "sched_vlag_deviation_limit", ++ .data = &sched_vlag_deviation_limit, ++ .maxlen = sizeof(u8), ++ .mode = 0644, ++ .proc_handler = proc_dou8vec_minmax, ++ .extra1 = SYSCTL_ZERO, ++ .extra2 = &thirty_two, ++ }, ++#endif // CONFIG_SCHED_BORE + #ifdef CONFIG_CFS_BANDWIDTH + { + .procname = "sched_cfs_bandwidth_slice_us", +@@ -195,6 +388,13 @@ static inline void update_load_set(struct load_weight *lw, unsigned long w) + * + * This idea comes from the SD scheduler of Con Kolivas: + */ ++#ifdef CONFIG_SCHED_BORE ++static void update_sysctl(void) { ++ sysctl_sched_base_slice = ++ max(sysctl_sched_min_base_slice, configured_sched_base_slice); ++} ++void sched_update_min_base_slice(void) { update_sysctl(); } ++#else // !CONFIG_SCHED_BORE + static unsigned int get_update_sysctl_factor(void) + { + unsigned int cpus = min_t(unsigned int, num_online_cpus(), 8); +@@ -225,6 +425,7 @@ static void update_sysctl(void) + SET_SYSCTL(sched_base_slice); + #undef SET_SYSCTL + } ++#endif // CONFIG_SCHED_BORE + + void __init sched_init_granularity(void) + { +@@ -298,6 +499,9 @@ static inline u64 calc_delta_fair(u64 delta, struct sched_entity *se) + if (unlikely(se->load.weight != NICE_0_LOAD)) + delta = __calc_delta(delta, NICE_0_LOAD, &se->load); + ++#ifdef CONFIG_SCHED_BORE ++ if (likely(sched_bore)) delta = scale_slice(delta, se); ++#endif // CONFIG_SCHED_BORE + return delta; + } + +@@ -624,10 +828,26 @@ static inline s64 entity_key(struct cfs_rq *cfs_rq, struct sched_entity *se) + * + * As measured, the max (key * weight) value was ~44 bits for a kernel build. + */ ++#if !defined(CONFIG_SCHED_BORE) ++#define entity_weight(se) scale_load_down(se->load.weight) ++#else // CONFIG_SCHED_BORE ++static unsigned long entity_weight(struct sched_entity *se) { ++ unsigned long weight = se->load.weight; ++ if (likely(sched_bore)) weight = unscale_slice(weight, se); ++#ifdef CONFIG_64BIT ++ weight >>= SCHED_FIXEDPOINT_SHIFT - 3; ++#endif // CONFIG_64BIT ++ return weight; ++} ++#endif // CONFIG_SCHED_BORE ++ + static void + avg_vruntime_add(struct cfs_rq *cfs_rq, struct sched_entity *se) + { +- unsigned long weight = scale_load_down(se->load.weight); ++ unsigned long weight = entity_weight(se); ++#ifdef CONFIG_SCHED_BORE ++ se->burst_load = weight; ++#endif // CONFIG_SCHED_BORE + s64 key = entity_key(cfs_rq, se); + + cfs_rq->avg_vruntime += key * weight; +@@ -637,7 +857,12 @@ avg_vruntime_add(struct cfs_rq *cfs_rq, struct sched_entity *se) + static void + avg_vruntime_sub(struct cfs_rq *cfs_rq, struct sched_entity *se) + { +- unsigned long weight = scale_load_down(se->load.weight); ++#if !defined(CONFIG_SCHED_BORE) ++ unsigned long weight = entity_weight(se); ++#else // CONFIG_SCHED_BORE ++ unsigned long weight = se->burst_load; ++ se->burst_load = 0; ++#endif // CONFIG_SCHED_BORE + s64 key = entity_key(cfs_rq, se); + + cfs_rq->avg_vruntime -= key * weight; +@@ -657,14 +882,14 @@ void avg_vruntime_update(struct cfs_rq *cfs_rq, s64 delta) + * Specifically: avg_runtime() + 0 must result in entity_eligible() := true + * For this to be so, the result of this function must have a left bias. + */ +-u64 avg_vruntime(struct cfs_rq *cfs_rq) ++static u64 avg_key(struct cfs_rq *cfs_rq) + { + struct sched_entity *curr = cfs_rq->curr; + s64 avg = cfs_rq->avg_vruntime; + long load = cfs_rq->avg_load; + + if (curr && curr->on_rq) { +- unsigned long weight = scale_load_down(curr->load.weight); ++ unsigned long weight = entity_weight(curr); + + avg += entity_key(cfs_rq, curr) * weight; + load += weight; +@@ -674,12 +899,15 @@ u64 avg_vruntime(struct cfs_rq *cfs_rq) + /* sign flips effective floor / ceil */ + if (avg < 0) + avg -= (load - 1); +- avg = div_s64(avg, load); ++ avg = div64_s64(avg, load); + } + +- return cfs_rq->min_vruntime + avg; ++ return avg; + } + ++u64 avg_vruntime(struct cfs_rq *cfs_rq) { ++ return cfs_rq->min_vruntime + avg_key(cfs_rq); ++} + /* + * lag_i = S - s_i = w_i * (V - v_i) + * +@@ -704,6 +932,9 @@ static void update_entity_lag(struct cfs_rq *cfs_rq, struct sched_entity *se) + lag = avg_vruntime(cfs_rq) - se->vruntime; + + limit = calc_delta_fair(max_t(u64, 2*se->slice, TICK_NSEC), se); ++#ifdef CONFIG_SCHED_BORE ++ if (likely(sched_bore)) limit >>= 1; ++#endif // CONFIG_SCHED_BORE + se->vlag = clamp(lag, -limit, limit); + } + +@@ -731,7 +962,7 @@ static int vruntime_eligible(struct cfs_rq *cfs_rq, u64 vruntime) + long load = cfs_rq->avg_load; + + if (curr && curr->on_rq) { +- unsigned long weight = scale_load_down(curr->load.weight); ++ unsigned long weight = entity_weight(curr); + + avg += entity_key(cfs_rq, curr) * weight; + load += weight; +@@ -827,10 +1058,16 @@ static void __enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se) + se->min_vruntime = se->vruntime; + rb_add_augmented_cached(&se->run_node, &cfs_rq->tasks_timeline, + __entity_less, &min_vruntime_cb); ++#ifdef CONFIG_SCHED_BORE ++ se->on_cfs_rq = true; ++#endif // CONFIG_SCHED_BORE + } + + static void __dequeue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se) + { ++#ifdef CONFIG_SCHED_BORE ++ se->on_cfs_rq = false; ++#endif // CONFIG_SCHED_BORE + rb_erase_augmented_cached(&se->run_node, &cfs_rq->tasks_timeline, + &min_vruntime_cb); + avg_vruntime_sub(cfs_rq, se); +@@ -955,6 +1192,7 @@ struct sched_entity *__pick_last_entity(struct cfs_rq *cfs_rq) + * Scheduling class statistics methods: + */ + #ifdef CONFIG_SMP ++#if !defined(CONFIG_SCHED_BORE) + int sched_update_scaling(void) + { + unsigned int factor = get_update_sysctl_factor(); +@@ -966,6 +1204,7 @@ int sched_update_scaling(void) + + return 0; + } ++#endif // CONFIG_SCHED_BORE + #endif + #endif + +@@ -1165,7 +1404,13 @@ static void update_curr(struct cfs_rq *cfs_rq) + if (unlikely(delta_exec <= 0)) + return; + ++#ifdef CONFIG_SCHED_BORE ++ curr->burst_time += delta_exec; ++ update_burst_penalty(curr); ++ curr->vruntime += max(1ULL, calc_delta_fair(delta_exec, curr)); ++#else // !CONFIG_SCHED_BORE + curr->vruntime += calc_delta_fair(delta_exec, curr); ++#endif // CONFIG_SCHED_BORE + update_deadline(cfs_rq, curr); + update_min_vruntime(cfs_rq); + +@@ -5157,8 +5402,8 @@ static inline void update_misfit_status(struct task_struct *p, struct rq *rq) {} + static void + place_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags) + { +- u64 vslice, vruntime = avg_vruntime(cfs_rq); +- s64 lag = 0; ++ s64 lag = 0, key = avg_key(cfs_rq); ++ u64 vslice, vruntime = cfs_rq->min_vruntime + key; + + se->slice = sysctl_sched_base_slice; + vslice = calc_delta_fair(se->slice, se); +@@ -5171,6 +5416,9 @@ place_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags) + * + * EEVDF: placement strategy #1 / #2 + */ ++#ifdef CONFIG_SCHED_BORE ++ if (unlikely(!sched_bore) || se->vlag) ++#endif // CONFIG_SCHED_BORE + if (sched_feat(PLACE_LAG) && cfs_rq->nr_running) { + struct sched_entity *curr = cfs_rq->curr; + unsigned long load; +@@ -5231,12 +5479,22 @@ place_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags) + */ + load = cfs_rq->avg_load; + if (curr && curr->on_rq) +- load += scale_load_down(curr->load.weight); ++ load += entity_weight(curr); + +- lag *= load + scale_load_down(se->load.weight); ++ lag *= load + entity_weight(se); ++#if !defined(CONFIG_SCHED_BORE) + if (WARN_ON_ONCE(!load)) ++#else // CONFIG_SCHED_BORE ++ if (unlikely(!load)) ++#endif // CONFIG_SCHED_BORE + load = 1; +- lag = div_s64(lag, load); ++ lag = div64_s64(lag, load); ++#ifdef CONFIG_SCHED_BORE ++ if (likely(sched_bore)) { ++ s64 limit = vslice << sched_vlag_deviation_limit; ++ lag = clamp(lag, -limit, limit); ++ } ++#endif // CONFIG_SCHED_BORE + } + + se->vruntime = vruntime - lag; +@@ -6803,6 +7061,14 @@ static void dequeue_task_fair(struct rq *rq, struct task_struct *p, int flags) + bool was_sched_idle = sched_idle_rq(rq); + + util_est_dequeue(&rq->cfs, p); ++#ifdef CONFIG_SCHED_BORE ++ if (task_sleep) { ++ cfs_rq = cfs_rq_of(se); ++ if (cfs_rq->curr == se) ++ update_curr(cfs_rq); ++ restart_burst(se); ++ } ++#endif // CONFIG_SCHED_BORE + + for_each_sched_entity(se) { + cfs_rq = cfs_rq_of(se); +@@ -8552,16 +8818,25 @@ static void yield_task_fair(struct rq *rq) + /* + * Are we the only task in the tree? + */ ++#if !defined(CONFIG_SCHED_BORE) + if (unlikely(rq->nr_running == 1)) + return; + + clear_buddies(cfs_rq, se); ++#endif // CONFIG_SCHED_BORE + + update_rq_clock(rq); + /* + * Update run-time statistics of the 'current'. + */ + update_curr(cfs_rq); ++#ifdef CONFIG_SCHED_BORE ++ restart_burst_rescale_deadline(se); ++ if (unlikely(rq->nr_running == 1)) ++ return; ++ ++ clear_buddies(cfs_rq, se); ++#endif // CONFIG_SCHED_BORE + /* + * Tell update_rq_clock() that we've just updated, + * so we don't do microscopic update in schedule() +@@ -12651,6 +12926,9 @@ static void task_fork_fair(struct task_struct *p) + curr = cfs_rq->curr; + if (curr) + update_curr(cfs_rq); ++#ifdef CONFIG_SCHED_BORE ++ update_burst_score(se); ++#endif // CONFIG_SCHED_BORE + place_entity(cfs_rq, se, ENQUEUE_INITIAL); + rq_unlock(rq, &rf); + } +diff --git a/kernel/sched/features.h b/kernel/sched/features.h +index 143f55df89..3f0fe409f5 100644 +--- a/kernel/sched/features.h ++++ b/kernel/sched/features.h +@@ -6,7 +6,11 @@ + */ + SCHED_FEAT(PLACE_LAG, true) + SCHED_FEAT(PLACE_DEADLINE_INITIAL, true) ++#ifdef CONFIG_SCHED_BORE ++SCHED_FEAT(RUN_TO_PARITY, false) ++#else // !CONFIG_SCHED_BORE + SCHED_FEAT(RUN_TO_PARITY, true) ++#endif // CONFIG_SCHED_BORE + + /* + * Prefer to schedule the task we woke last (assuming it failed +diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h +index 001fe047bd..da3ad1d4e1 100644 +--- a/kernel/sched/sched.h ++++ b/kernel/sched/sched.h +@@ -1965,7 +1965,11 @@ static inline void dirty_sched_domain_sysctl(int cpu) + } + #endif + ++#ifdef CONFIG_SCHED_BORE ++extern void sched_update_min_base_slice(void); ++#else // !CONFIG_SCHED_BORE + extern int sched_update_scaling(void); ++#endif // CONFIG_SCHED_BORE + + static inline const struct cpumask *task_user_cpus(struct task_struct *p) + { +@@ -2552,6 +2556,9 @@ extern const_debug unsigned int sysctl_sched_nr_migrate; + extern const_debug unsigned int sysctl_sched_migration_cost; + + extern unsigned int sysctl_sched_base_slice; ++#ifdef CONFIG_SCHED_BORE ++extern unsigned int sysctl_sched_min_base_slice; ++#endif // CONFIG_SCHED_BORE + + #ifdef CONFIG_SCHED_DEBUG + extern int sysctl_resched_latency_warn_ms; +-- +2.34.1 + + diff --git a/0001-platform-x86-asus-wmi-Add-safety-checks-to-dgpu-egpu.patch b/0001-platform-x86-asus-wmi-Add-safety-checks-to-dgpu-egpu.patch deleted file mode 100644 index cef15e44df06..000000000000 --- a/0001-platform-x86-asus-wmi-Add-safety-checks-to-dgpu-egpu.patch +++ /dev/null @@ -1,87 +0,0 @@ -From 9eccb147466f00a13c593ac078d8639e1eafe3a2 Mon Sep 17 00:00:00 2001 -From: "Luke D. Jones" <luke@ljones.dev> -Date: Fri, 14 Oct 2022 10:43:09 +1300 -Subject: [PATCH] platform/x86: asus-wmi: Add safety checks to dgpu/egpu/mux - methods - -The WMI methods for dgpu_disable, egpu_enable, and gpu_mux_mode have -no internal safety checks. This means it is possible for a user to -set the gpu mux to discreet mode and then disable the dgpu, resulting -in the user having no screen and very little chance of recovery. - -This commit adds checks to dgpu_disable and egpu_enable to ensure that -the dgpu can not be disabled if the MUX is in discreet mode, and a -check to gpu_mux_mode to prevent switching to discreet mode if -dgpu_disable is set. - -Signed-off-by: Luke D. Jones <luke@ljones.dev> ---- - drivers/platform/x86/asus-wmi.c | 38 +++++++++++++++++++++++++++++++++ - 1 file changed, 38 insertions(+) - -diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c -index 6e8e093f96b3..1afc4d40fa1a 100644 ---- a/drivers/platform/x86/asus-wmi.c -+++ b/drivers/platform/x86/asus-wmi.c -@@ -615,6 +615,18 @@ static ssize_t dgpu_disable_store(struct device *dev, - if (disable > 1) - return -EINVAL; - -+ /* -+ * The GPU MUX must be checked first, if it is in discreet mode the -+ * dgpu_disable cannot be set to on or users can end up with no screen. -+ */ -+ result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_GPU_MUX); -+ if (result < 0) -+ return result; -+ if (!result && disable) { -+ pr_warn("ASUS MUX is in discreet mode, can not set dgpu_disable on\n"); -+ return -EINVAL; -+ } -+ - err = asus_wmi_set_devstate(ASUS_WMI_DEVID_DGPU, disable, &result); - if (err) { - pr_warn("Failed to set dgpu disable: %d\n", err); -@@ -663,6 +675,19 @@ static ssize_t egpu_enable_store(struct device *dev, - if (enable > 1) - return -EINVAL; - -+ /* -+ * The GPU MUX must be checked first, if it is in discreet mode the -+ * egpu_enable cannot be set to on or users can end up with no screen. -+ * Note: egpu_enable method in WMI also sets dgpu_disable to on. -+ */ -+ result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_GPU_MUX); -+ if (result < 0) -+ return result; -+ if (!result && enable) { -+ pr_warn("ASUS MUX is in discreet mode, can not set egpu_enable on\n"); -+ return -EINVAL; -+ } -+ - err = asus_wmi_set_devstate(ASUS_WMI_DEVID_EGPU, enable, &result); - if (err) { - pr_warn("Failed to set egpu disable: %d\n", err); -@@ -709,6 +734,19 @@ static ssize_t gpu_mux_mode_store(struct device *dev, - if (optimus > 1) - return -EINVAL; - -+ /* -+ * The dgpu_disable must be checked first, if it is enabled the -+ * gpu MUX can not be set to 0 or users can end up with no screen. -+ * Note: egpu_enable also switches dgpu_disable to 1 if enabled. -+ */ -+ result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_DGPU); -+ if (result < 0) -+ return result; -+ if (result && !optimus) { -+ pr_warn("ASUS dgpu_disable is set, can not switch MUX to discreet mode\n"); -+ return -EINVAL; -+ } -+ - err = asus_wmi_set_devstate(ASUS_WMI_DEVID_GPU_MUX, optimus, &result); - if (err) { - dev_err(dev, "Failed to set GPU MUX mode: %d\n", err); --- -2.37.3 - diff --git a/0001-platform-x86-asus-wmi-add-support-for-vivobook-fan-p.patch b/0001-platform-x86-asus-wmi-add-support-for-vivobook-fan-p.patch new file mode 100644 index 000000000000..e4e3bf170841 --- /dev/null +++ b/0001-platform-x86-asus-wmi-add-support-for-vivobook-fan-p.patch @@ -0,0 +1,266 @@ +From 8cab59d3fb33f17e3b3fa4937c5d4bf0b59e6b12 Mon Sep 17 00:00:00 2001 +From: Mohamed Ghanmi <mohamed.ghanmi@supcom.tn> +Date: Fri, 12 Apr 2024 00:56:39 +0100 +Subject: [PATCH] platform/x86: asus-wmi: add support for vivobook fan profiles + +Add support for vivobook fan profiles wmi call on the ASUS VIVOBOOK +to adjust power limits. + +These fan profiles have a different device id than the ROG series. +and different order. This reorders the existing modes and adds a new +full speed mode available on these laptops. + +As part of keeping the patch clean the throttle_thermal_policy_available +boolean stored in the driver struct is removed and +throttle_thermal_policy_dev is used in place (as on init it is zeroed). + +Signed-off-by: Mohamed Ghanmi <mohamed.ghanmi@supcom.tn> +Co-developed-by: Luke D. Jones <luke@ljones.dev> +Signed-off-by: Luke D. Jones <luke@ljones.dev> +--- + drivers/platform/x86/asus-wmi.c | 100 +++++++++++---------- + include/linux/platform_data/x86/asus-wmi.h | 1 + + 2 files changed, 55 insertions(+), 46 deletions(-) + +diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c +index 2d2b4eca7fd8..439d330fb80b 100644 +--- a/drivers/platform/x86/asus-wmi.c ++++ b/drivers/platform/x86/asus-wmi.c +@@ -97,6 +97,11 @@ module_param(fnlock_default, bool, 0444); + #define ASUS_THROTTLE_THERMAL_POLICY_OVERBOOST 1 + #define ASUS_THROTTLE_THERMAL_POLICY_SILENT 2 + ++#define ASUS_THROTTLE_THERMAL_POLICY_DEFAULT_VIVO 0 ++#define ASUS_THROTTLE_THERMAL_POLICY_OVERBOOST_VIVO 2 ++#define ASUS_THROTTLE_THERMAL_POLICY_SILENT_VIVO 1 ++#define ASUS_THROTTLE_THERMAL_POLICY_FULLSPEED 3 ++ + #define USB_INTEL_XUSB2PR 0xD0 + #define PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_XHCI 0x9c31 + +@@ -285,8 +290,8 @@ struct asus_wmi { + u32 kbd_rgb_dev; + bool kbd_rgb_state_available; + +- bool throttle_thermal_policy_available; + u8 throttle_thermal_policy_mode; ++ u32 throttle_thermal_policy_dev; + + bool cpu_fan_curve_available; + bool gpu_fan_curve_available; +@@ -3153,7 +3158,7 @@ static int fan_curve_get_factory_default(struct asus_wmi *asus, u32 fan_dev) + int err, fan_idx; + u8 mode = 0; + +- if (asus->throttle_thermal_policy_available) ++ if (asus->throttle_thermal_policy_dev) + mode = asus->throttle_thermal_policy_mode; + /* DEVID_<C/G>PU_FAN_CURVE is switched for OVERBOOST vs SILENT */ + if (mode == 2) +@@ -3360,7 +3365,7 @@ static ssize_t fan_curve_enable_store(struct device *dev, + * For machines with throttle this is the only way to reset fans + * to default mode of operation (does not erase curve data). + */ +- if (asus->throttle_thermal_policy_available) { ++ if (asus->throttle_thermal_policy_dev) { + err = throttle_thermal_policy_write(asus); + if (err) + return err; +@@ -3577,8 +3582,8 @@ static const struct attribute_group asus_fan_curve_attr_group = { + __ATTRIBUTE_GROUPS(asus_fan_curve_attr); + + /* +- * Must be initialised after throttle_thermal_policy_check_present() as +- * we check the status of throttle_thermal_policy_available during init. ++ * Must be initialised after throttle_thermal_policy_dev is set as ++ * we check the status of throttle_thermal_policy_dev during init. + */ + static int asus_wmi_custom_fan_curve_init(struct asus_wmi *asus) + { +@@ -3619,38 +3624,31 @@ static int asus_wmi_custom_fan_curve_init(struct asus_wmi *asus) + } + + /* Throttle thermal policy ****************************************************/ +- +-static int throttle_thermal_policy_check_present(struct asus_wmi *asus) +-{ +- u32 result; +- int err; +- +- asus->throttle_thermal_policy_available = false; +- +- err = asus_wmi_get_devstate(asus, +- ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY, +- &result); +- if (err) { +- if (err == -ENODEV) +- return 0; +- return err; +- } +- +- if (result & ASUS_WMI_DSTS_PRESENCE_BIT) +- asus->throttle_thermal_policy_available = true; +- +- return 0; +-} +- + static int throttle_thermal_policy_write(struct asus_wmi *asus) + { +- int err; +- u8 value; ++ u8 value = asus->throttle_thermal_policy_mode; + u32 retval; ++ bool vivo; ++ int err; + +- value = asus->throttle_thermal_policy_mode; ++ vivo = asus->throttle_thermal_policy_dev == ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY_VIVO; ++ if (vivo) { ++ switch (value) { ++ case ASUS_THROTTLE_THERMAL_POLICY_DEFAULT: ++ value = ASUS_THROTTLE_THERMAL_POLICY_DEFAULT_VIVO; ++ break; ++ case ASUS_THROTTLE_THERMAL_POLICY_OVERBOOST: ++ value = ASUS_THROTTLE_THERMAL_POLICY_OVERBOOST_VIVO; ++ break; ++ case ASUS_THROTTLE_THERMAL_POLICY_SILENT: ++ value = ASUS_THROTTLE_THERMAL_POLICY_SILENT_VIVO; ++ break; ++ default: ++ break; ++ } ++ } + +- err = asus_wmi_set_devstate(ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY, ++ err = asus_wmi_set_devstate(asus->throttle_thermal_policy_dev, + value, &retval); + + sysfs_notify(&asus->platform_device->dev.kobj, NULL, +@@ -3680,7 +3678,7 @@ static int throttle_thermal_policy_write(struct asus_wmi *asus) + + static int throttle_thermal_policy_set_default(struct asus_wmi *asus) + { +- if (!asus->throttle_thermal_policy_available) ++ if (!asus->throttle_thermal_policy_dev) + return 0; + + asus->throttle_thermal_policy_mode = ASUS_THROTTLE_THERMAL_POLICY_DEFAULT; +@@ -3690,9 +3688,14 @@ static int throttle_thermal_policy_set_default(struct asus_wmi *asus) + static int throttle_thermal_policy_switch_next(struct asus_wmi *asus) + { + u8 new_mode = asus->throttle_thermal_policy_mode + 1; ++ bool vivo; + int err; + +- if (new_mode > ASUS_THROTTLE_THERMAL_POLICY_SILENT) ++ vivo = asus->throttle_thermal_policy_dev == ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY_VIVO; ++ if (!vivo && new_mode > ASUS_THROTTLE_THERMAL_POLICY_SILENT) ++ new_mode = ASUS_THROTTLE_THERMAL_POLICY_DEFAULT; ++ ++ if (vivo && new_mode > ASUS_THROTTLE_THERMAL_POLICY_FULLSPEED) + new_mode = ASUS_THROTTLE_THERMAL_POLICY_DEFAULT; + + asus->throttle_thermal_policy_mode = new_mode; +@@ -3725,13 +3728,17 @@ static ssize_t throttle_thermal_policy_store(struct device *dev, + struct asus_wmi *asus = dev_get_drvdata(dev); + u8 new_mode; + int result; ++ bool vivo; + int err; + + result = kstrtou8(buf, 10, &new_mode); + if (result < 0) + return result; + +- if (new_mode > ASUS_THROTTLE_THERMAL_POLICY_SILENT) ++ vivo = asus->throttle_thermal_policy_dev == ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY_VIVO; ++ if (vivo && new_mode > ASUS_THROTTLE_THERMAL_POLICY_FULLSPEED) ++ return -EINVAL; ++ else if (!vivo && new_mode > ASUS_THROTTLE_THERMAL_POLICY_SILENT) + return -EINVAL; + + asus->throttle_thermal_policy_mode = new_mode; +@@ -3748,7 +3755,10 @@ static ssize_t throttle_thermal_policy_store(struct device *dev, + return count; + } + +-// Throttle thermal policy: 0 - default, 1 - overboost, 2 - silent ++/* ++ * Throttle thermal policy: 0 - default, 1 - overboost, 2 - silent ++ * VIVOBOOK: 3 - fans full speed ++ */ + static DEVICE_ATTR_RW(throttle_thermal_policy); + + /* Platform profile ***********************************************************/ +@@ -3814,7 +3824,7 @@ static int platform_profile_setup(struct asus_wmi *asus) + * Not an error if a component platform_profile relies on is unavailable + * so early return, skipping the setup of platform_profile. + */ +- if (!asus->throttle_thermal_policy_available) ++ if (!asus->throttle_thermal_policy_dev) + return 0; + + dev_info(dev, "Using throttle_thermal_policy for platform_profile support\n"); +@@ -4229,7 +4239,7 @@ static void asus_wmi_handle_event_code(int code, struct asus_wmi *asus) + if (code == NOTIFY_KBD_FBM || code == NOTIFY_KBD_TTP) { + if (asus->fan_boost_mode_available) + fan_boost_mode_switch_next(asus); +- if (asus->throttle_thermal_policy_available) ++ if (asus->throttle_thermal_policy_dev) + throttle_thermal_policy_switch_next(asus); + return; + +@@ -4401,7 +4411,7 @@ static umode_t asus_sysfs_is_visible(struct kobject *kobj, + else if (attr == &dev_attr_fan_boost_mode.attr) + ok = asus->fan_boost_mode_available; + else if (attr == &dev_attr_throttle_thermal_policy.attr) +- ok = asus->throttle_thermal_policy_available; ++ ok = asus->throttle_thermal_policy_dev != 0; + else if (attr == &dev_attr_ppt_pl2_sppt.attr) + devid = ASUS_WMI_DEVID_PPT_PL2_SPPT; + else if (attr == &dev_attr_ppt_pl1_spl.attr) +@@ -4693,16 +4703,15 @@ static int asus_wmi_add(struct platform_device *pdev) + else if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_TUF_RGB_MODE2)) + asus->kbd_rgb_dev = ASUS_WMI_DEVID_TUF_RGB_MODE2; + ++ if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY)) ++ asus->throttle_thermal_policy_dev = ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY; ++ else if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY_VIVO)) ++ asus->throttle_thermal_policy_dev = ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY_VIVO; ++ + err = fan_boost_mode_check_present(asus); + if (err) + goto fail_fan_boost_mode; + +- err = throttle_thermal_policy_check_present(asus); +- if (err) +- goto fail_throttle_thermal_policy; +- else +- throttle_thermal_policy_set_default(asus); +- + err = platform_profile_setup(asus); + if (err) + goto fail_platform_profile_setup; +@@ -4797,7 +4806,6 @@ static int asus_wmi_add(struct platform_device *pdev) + fail_input: + asus_wmi_sysfs_exit(asus->platform_device); + fail_sysfs: +-fail_throttle_thermal_policy: + fail_custom_fan_curve: + fail_platform_profile_setup: + if (asus->platform_profile_support) +diff --git a/include/linux/platform_data/x86/asus-wmi.h b/include/linux/platform_data/x86/asus-wmi.h +index 3eb5cd6773ad..982a637744ec 100644 +--- a/include/linux/platform_data/x86/asus-wmi.h ++++ b/include/linux/platform_data/x86/asus-wmi.h +@@ -64,6 +64,7 @@ + #define ASUS_WMI_DEVID_SCREENPAD_LIGHT 0x00050032 + #define ASUS_WMI_DEVID_FAN_BOOST_MODE 0x00110018 + #define ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY 0x00120075 ++#define ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY_VIVO 0x00110019 + + /* Misc */ + #define ASUS_WMI_DEVID_PANEL_OD 0x00050019 +-- +2.44.0 + diff --git a/0001-v4-platform-x86-asus-wmi-add-support-for-2024-ROG-Mini-LED.patch b/0001-v4-platform-x86-asus-wmi-add-support-for-2024-ROG-Mini-LED.patch new file mode 100644 index 000000000000..cc5026904dd3 --- /dev/null +++ b/0001-v4-platform-x86-asus-wmi-add-support-for-2024-ROG-Mini-LED.patch @@ -0,0 +1,219 @@ +From: "Luke D. Jones" <luke@ljones.dev> +To: hdegoede@redhat.com +Cc: corentin.chary@gmail.com, ilpo.jarvinen@linux.intel.com, + platform-driver-x86@vger.kernel.org, + linux-kernel@vger.kernel.org, "Luke D. Jones" <luke@ljones.dev> +Subject: [PATCH v4 1/9] platform/x86: asus-wmi: add support for 2024 ROG Mini-LED +Date: Thu, 4 Apr 2024 13:16:44 +1300 [thread overview] +Message-ID: <20240404001652.86207-2-luke@ljones.dev> (raw) +In-Reply-To: <20240404001652.86207-1-luke@ljones.dev> + +Support the 2024 mini-led backlight and adjust the related functions +to select the relevant dev-id. Also add `available_mini_led_mode` to the +platform sysfs since the available mini-led levels can be different. + +Reviewed-by: Ilpo Järvinen <ilpo.jarvinen@linux.intel.com> +signed-off-by: Luke D. Jones <luke@ljones.dev> +--- + .../ABI/testing/sysfs-platform-asus-wmi | 8 ++ + drivers/platform/x86/asus-wmi.c | 96 +++++++++++++++++-- + include/linux/platform_data/x86/asus-wmi.h | 1 + + 3 files changed, 95 insertions(+), 10 deletions(-) + +diff --git a/Documentation/ABI/testing/sysfs-platform-asus-wmi b/Documentation/ABI/testing/sysfs-platform-asus-wmi +index 8a7e25bde085..ef1ac1a20a71 100644 +--- a/Documentation/ABI/testing/sysfs-platform-asus-wmi ++++ b/Documentation/ABI/testing/sysfs-platform-asus-wmi +@@ -126,6 +126,14 @@ Description: + Change the mini-LED mode: + * 0 - Single-zone, + * 1 - Multi-zone ++ * 2 - Multi-zone strong (available on newer generation mini-led) ++ ++What: /sys/devices/platform/<platform>/available_mini_led_mode ++Date: Apr 2024 ++KernelVersion: 6.10 ++Contact: "Luke Jones" <luke@ljones.dev> ++Description: ++ List the available mini-led modes. + + What: /sys/devices/platform/<platform>/ppt_pl1_spl + Date: Jun 2023 +diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c +index 3f07bbf809ef..aa2a3b402e33 100644 +--- a/drivers/platform/x86/asus-wmi.c ++++ b/drivers/platform/x86/asus-wmi.c +@@ -126,6 +126,17 @@ module_param(fnlock_default, bool, 0444); + #define ASUS_SCREENPAD_BRIGHT_MAX 255 + #define ASUS_SCREENPAD_BRIGHT_DEFAULT 60 + ++#define ASUS_MINI_LED_MODE_MASK 0x03 ++/* Standard modes for devices with only on/off */ ++#define ASUS_MINI_LED_OFF 0x00 ++#define ASUS_MINI_LED_ON 0x01 ++/* New mode on some devices, define here to clarify remapping later */ ++#define ASUS_MINI_LED_STRONG_MODE 0x02 ++/* New modes for devices with 3 mini-led mode types */ ++#define ASUS_MINI_LED_2024_WEAK 0x00 ++#define ASUS_MINI_LED_2024_STRONG 0x01 ++#define ASUS_MINI_LED_2024_OFF 0x02 ++ + /* Controls the power state of the USB0 hub on ROG Ally which input is on */ + #define ASUS_USB0_PWR_EC0_CSEE "\\_SB.PCI0.SBRG.EC0.CSEE" + /* 300ms so far seems to produce a reliable result on AC and battery */ +@@ -288,7 +299,7 @@ struct asus_wmi { + bool battery_rsoc_available; + + bool panel_overdrive_available; +- bool mini_led_mode_available; ++ u32 mini_led_dev_id; + + struct hotplug_slot hotplug_slot; + struct mutex hotplug_lock; +@@ -2108,13 +2119,33 @@ static ssize_t mini_led_mode_show(struct device *dev, + struct device_attribute *attr, char *buf) + { + struct asus_wmi *asus = dev_get_drvdata(dev); +- int result; ++ u32 value; ++ int err; + +- result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_MINI_LED_MODE); +- if (result < 0) +- return result; ++ err = asus_wmi_get_devstate(asus, asus->mini_led_dev_id, &value); ++ if (err < 0) ++ return err; ++ value = value & ASUS_MINI_LED_MODE_MASK; + +- return sysfs_emit(buf, "%d\n", result); ++ /* ++ * Remap the mode values to match previous generation mini-led. The last gen ++ * WMI 0 == off, while on this version WMI 2 ==off (flipped). ++ */ ++ if (asus->mini_led_dev_id == ASUS_WMI_DEVID_MINI_LED_MODE2) { ++ switch (value) { ++ case ASUS_MINI_LED_2024_WEAK: ++ value = ASUS_MINI_LED_ON; ++ break; ++ case ASUS_MINI_LED_2024_STRONG: ++ value = ASUS_MINI_LED_STRONG_MODE; ++ break; ++ case ASUS_MINI_LED_2024_OFF: ++ value = ASUS_MINI_LED_OFF; ++ break; ++ } ++ } ++ ++ return sysfs_emit(buf, "%d\n", value); + } + + static ssize_t mini_led_mode_store(struct device *dev, +@@ -2130,11 +2161,32 @@ static ssize_t mini_led_mode_store(struct device *dev, + if (result) + return result; + +- if (mode > 1) ++ if (asus->mini_led_dev_id == ASUS_WMI_DEVID_MINI_LED_MODE && ++ mode > ASUS_MINI_LED_ON) ++ return -EINVAL; ++ if (asus->mini_led_dev_id == ASUS_WMI_DEVID_MINI_LED_MODE2 && ++ mode > ASUS_MINI_LED_STRONG_MODE) + return -EINVAL; + +- err = asus_wmi_set_devstate(ASUS_WMI_DEVID_MINI_LED_MODE, mode, &result); ++ /* ++ * Remap the mode values so expected behaviour is the same as the last ++ * generation of mini-LED with 0 == off, 1 == on. ++ */ ++ if (asus->mini_led_dev_id == ASUS_WMI_DEVID_MINI_LED_MODE2) { ++ switch (mode) { ++ case ASUS_MINI_LED_OFF: ++ mode = ASUS_MINI_LED_2024_OFF; ++ break; ++ case ASUS_MINI_LED_ON: ++ mode = ASUS_MINI_LED_2024_WEAK; ++ break; ++ case ASUS_MINI_LED_STRONG_MODE: ++ mode = ASUS_MINI_LED_2024_STRONG; ++ break; ++ } ++ } + ++ err = asus_wmi_set_devstate(asus->mini_led_dev_id, mode, &result); + if (err) { + pr_warn("Failed to set mini-LED: %d\n", err); + return err; +@@ -2151,6 +2203,23 @@ static ssize_t mini_led_mode_store(struct device *dev, + } + static DEVICE_ATTR_RW(mini_led_mode); + ++static ssize_t available_mini_led_mode_show(struct device *dev, ++ struct device_attribute *attr, char *buf) ++{ ++ struct asus_wmi *asus = dev_get_drvdata(dev); ++ ++ switch (asus->mini_led_dev_id) { ++ case ASUS_WMI_DEVID_MINI_LED_MODE: ++ return sysfs_emit(buf, "0 1\n"); ++ case ASUS_WMI_DEVID_MINI_LED_MODE2: ++ return sysfs_emit(buf, "0 1 2\n"); ++ } ++ ++ return sysfs_emit(buf, "0\n"); ++} ++ ++static DEVICE_ATTR_RO(available_mini_led_mode); ++ + /* Quirks *********************************************************************/ + + static void asus_wmi_set_xusb2pr(struct asus_wmi *asus) +@@ -4139,6 +4208,7 @@ static struct attribute *platform_attributes[] = { + &dev_attr_nv_temp_target.attr, + &dev_attr_panel_od.attr, + &dev_attr_mini_led_mode.attr, ++ &dev_attr_available_mini_led_mode.attr, + NULL + }; + +@@ -4191,7 +4261,9 @@ static umode_t asus_sysfs_is_visible(struct kobject *kobj, + else if (attr == &dev_attr_panel_od.attr) + ok = asus->panel_overdrive_available; + else if (attr == &dev_attr_mini_led_mode.attr) +- ok = asus->mini_led_mode_available; ++ ok = asus->mini_led_dev_id != 0; ++ else if (attr == &dev_attr_available_mini_led_mode.attr) ++ ok = asus->mini_led_dev_id != 0; + + if (devid != -1) + ok = !(asus_wmi_get_devstate_simple(asus, devid) < 0); +@@ -4444,10 +4516,14 @@ static int asus_wmi_add(struct platform_device *pdev) + asus->nv_dyn_boost_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_NV_DYN_BOOST); + asus->nv_temp_tgt_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_NV_THERM_TARGET); + asus->panel_overdrive_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_PANEL_OD); +- asus->mini_led_mode_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_MINI_LED_MODE); + asus->ally_mcu_usb_switch = acpi_has_method(NULL, ASUS_USB0_PWR_EC0_CSEE) + && dmi_match(DMI_BOARD_NAME, "RC71L"); + ++ if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_MINI_LED_MODE)) ++ asus->mini_led_dev_id = ASUS_WMI_DEVID_MINI_LED_MODE; ++ else if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_MINI_LED_MODE2)) ++ asus->mini_led_dev_id = ASUS_WMI_DEVID_MINI_LED_MODE2; ++ + err = fan_boost_mode_check_present(asus); + if (err) + goto fail_fan_boost_mode; +diff --git a/include/linux/platform_data/x86/asus-wmi.h b/include/linux/platform_data/x86/asus-wmi.h +index ab1c7deff118..9cadce10ad9a 100644 +--- a/include/linux/platform_data/x86/asus-wmi.h ++++ b/include/linux/platform_data/x86/asus-wmi.h +@@ -71,6 +71,7 @@ + #define ASUS_WMI_DEVID_LID_FLIP 0x00060062 + #define ASUS_WMI_DEVID_LID_FLIP_ROG 0x00060077 + #define ASUS_WMI_DEVID_MINI_LED_MODE 0x0005001E ++#define ASUS_WMI_DEVID_MINI_LED_MODE2 0x0005002E + + /* Storage */ + #define ASUS_WMI_DEVID_CARDREADER 0x00080013 +-- +2.44.0 diff --git a/0002-HID-asus-make-asus_kbd_init-generic-remove-rog_nkey_.patch b/0002-HID-asus-make-asus_kbd_init-generic-remove-rog_nkey_.patch new file mode 100644 index 000000000000..680beffa5b82 --- /dev/null +++ b/0002-HID-asus-make-asus_kbd_init-generic-remove-rog_nkey_.patch @@ -0,0 +1,130 @@ +From de9b01c3b8869451d4cf44ab0baf55440e804fc6 Mon Sep 17 00:00:00 2001 +From: "Luke D. Jones" <luke@ljones.dev> +Date: Sat, 2 Dec 2023 17:47:59 +1300 +Subject: [PATCH 2/4] HID: asus: make asus_kbd_init() generic, remove + rog_nkey_led_init() + +Some of the n-key stuff is old and outdated, so +make asus_kbd_init() generic to use with other +report ID and remove rog_nkey_led_init(). + +Signed-off-by: Luke D. Jones <luke@ljones.dev> +--- + drivers/hid/hid-asus.c | 70 +++++++++++------------------------------- + 1 file changed, 18 insertions(+), 52 deletions(-) + +diff --git a/drivers/hid/hid-asus.c b/drivers/hid/hid-asus.c +index 855972a4470f..cdd998a761fe 100644 +--- a/drivers/hid/hid-asus.c ++++ b/drivers/hid/hid-asus.c +@@ -386,9 +386,9 @@ static int asus_kbd_set_report(struct hid_device *hdev, const u8 *buf, size_t bu + return ret; + } + +-static int asus_kbd_init(struct hid_device *hdev) ++static int asus_kbd_init(struct hid_device *hdev, u8 report_id) + { +- const u8 buf[] = { FEATURE_KBD_REPORT_ID, 0x41, 0x53, 0x55, 0x53, 0x20, 0x54, ++ const u8 buf[] = { report_id, 0x41, 0x53, 0x55, 0x53, 0x20, 0x54, + 0x65, 0x63, 0x68, 0x2e, 0x49, 0x6e, 0x63, 0x2e, 0x00 }; + int ret; + +@@ -400,9 +400,10 @@ static int asus_kbd_init(struct hid_device *hdev) + } + + static int asus_kbd_get_functions(struct hid_device *hdev, +- unsigned char *kbd_func) ++ unsigned char *kbd_func, ++ u8 report_id) + { +- const u8 buf[] = { FEATURE_KBD_REPORT_ID, 0x05, 0x20, 0x31, 0x00, 0x08 }; ++ const u8 buf[] = { report_id, 0x05, 0x20, 0x31, 0x00, 0x08 }; + u8 *readbuf; + int ret; + +@@ -431,51 +432,6 @@ static int asus_kbd_get_functions(struct hid_device *hdev, + return ret; + } + +-static int rog_nkey_led_init(struct hid_device *hdev) +-{ +- const u8 buf_init_start[] = { FEATURE_KBD_LED_REPORT_ID1, 0xB9 }; +- u8 buf_init2[] = { FEATURE_KBD_LED_REPORT_ID1, 0x41, 0x53, 0x55, 0x53, 0x20, +- 0x54, 0x65, 0x63, 0x68, 0x2e, 0x49, 0x6e, 0x63, 0x2e, 0x00 }; +- u8 buf_init3[] = { FEATURE_KBD_LED_REPORT_ID1, +- 0x05, 0x20, 0x31, 0x00, 0x08 }; +- int ret; +- +- hid_info(hdev, "Asus initialise N-KEY Device"); +- /* The first message is an init start */ +- ret = asus_kbd_set_report(hdev, buf_init_start, sizeof(buf_init_start)); +- if (ret < 0) { +- hid_warn(hdev, "Asus failed to send init start command: %d\n", ret); +- return ret; +- } +- /* Followed by a string */ +- ret = asus_kbd_set_report(hdev, buf_init2, sizeof(buf_init2)); +- if (ret < 0) { +- hid_warn(hdev, "Asus failed to send init command 1.0: %d\n", ret); +- return ret; +- } +- /* Followed by a string */ +- ret = asus_kbd_set_report(hdev, buf_init3, sizeof(buf_init3)); +- if (ret < 0) { +- hid_warn(hdev, "Asus failed to send init command 1.1: %d\n", ret); +- return ret; +- } +- +- /* begin second report ID with same data */ +- buf_init2[0] = FEATURE_KBD_LED_REPORT_ID2; +- buf_init3[0] = FEATURE_KBD_LED_REPORT_ID2; +- +- ret = asus_kbd_set_report(hdev, buf_init2, sizeof(buf_init2)); +- if (ret < 0) { +- hid_warn(hdev, "Asus failed to send init command 2.0: %d\n", ret); +- return ret; +- } +- ret = asus_kbd_set_report(hdev, buf_init3, sizeof(buf_init3)); +- if (ret < 0) +- hid_warn(hdev, "Asus failed to send init command 2.1: %d\n", ret); +- +- return ret; +-} +- + static void asus_schedule_work(struct asus_kbd_leds *led) + { + unsigned long flags; +@@ -558,17 +514,27 @@ static int asus_kbd_register_leds(struct hid_device *hdev) + int ret; + + if (drvdata->quirks & QUIRK_ROG_NKEY_KEYBOARD) { +- ret = rog_nkey_led_init(hdev); ++ /* Initialize keyboard */ ++ ret = asus_kbd_init(hdev, FEATURE_KBD_REPORT_ID); ++ if (ret < 0) ++ return ret; ++ ++ /* The LED endpoint is initialised in two HID */ ++ ret = asus_kbd_init(hdev, FEATURE_KBD_LED_REPORT_ID1); ++ if (ret < 0) ++ return ret; ++ ++ ret = asus_kbd_init(hdev, FEATURE_KBD_LED_REPORT_ID2); + if (ret < 0) + return ret; + } else { + /* Initialize keyboard */ +- ret = asus_kbd_init(hdev); ++ ret = asus_kbd_init(hdev, FEATURE_KBD_REPORT_ID); + if (ret < 0) + return ret; + + /* Get keyboard functions */ +- ret = asus_kbd_get_functions(hdev, &kbd_func); ++ ret = asus_kbd_get_functions(hdev, &kbd_func, FEATURE_KBD_REPORT_ID); + if (ret < 0) + return ret; + +-- +2.44.0 + diff --git a/0002-v4-platform-x86-asus-wmi-add-support-for-Vivobook-GPU-MUX.patch b/0002-v4-platform-x86-asus-wmi-add-support-for-Vivobook-GPU-MUX.patch new file mode 100644 index 000000000000..276d041715d9 --- /dev/null +++ b/0002-v4-platform-x86-asus-wmi-add-support-for-Vivobook-GPU-MUX.patch @@ -0,0 +1,120 @@ +From: "Luke D. Jones" <luke@ljones.dev> +To: hdegoede@redhat.com +Cc: corentin.chary@gmail.com, ilpo.jarvinen@linux.intel.com, + platform-driver-x86@vger.kernel.org, + linux-kernel@vger.kernel.org, "Luke D. Jones" <luke@ljones.dev> +Subject: [PATCH v4 2/9] platform/x86: asus-wmi: add support for Vivobook GPU MUX +Date: Thu, 4 Apr 2024 13:16:45 +1300 [thread overview] +Message-ID: <20240404001652.86207-3-luke@ljones.dev> (raw) +In-Reply-To: <20240404001652.86207-1-luke@ljones.dev> + +Add support for the Vivobook dgpu MUX available on the ASUS Viviobook +and some of the other ranges (Zen). + +This MUX functions exactly the same as the existing ROG MUX support so +the existing functionality now detects which MUX is available and uses +that for control. + +Reviewed-by: Ilpo Järvinen <ilpo.jarvinen@linux.intel.com> +Signed-off-by: Luke D. Jones <luke@ljones.dev> +--- + drivers/platform/x86/asus-wmi.c | 22 +++++++++++++--------- + include/linux/platform_data/x86/asus-wmi.h | 1 + + 2 files changed, 14 insertions(+), 9 deletions(-) + +diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c +index aa2a3b402e33..1ab4380e9771 100644 +--- a/drivers/platform/x86/asus-wmi.c ++++ b/drivers/platform/x86/asus-wmi.c +@@ -270,7 +270,7 @@ struct asus_wmi { + bool egpu_enable_available; + bool egpu_connect_available; + bool dgpu_disable_available; +- bool gpu_mux_mode_available; ++ u32 gpu_mux_dev; + + /* Tunables provided by ASUS for gaming laptops */ + bool ppt_pl2_sppt_available; +@@ -693,8 +693,8 @@ static ssize_t dgpu_disable_store(struct device *dev, + if (disable > 1) + return -EINVAL; + +- if (asus->gpu_mux_mode_available) { +- result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_GPU_MUX); ++ if (asus->gpu_mux_dev) { ++ result = asus_wmi_get_devstate_simple(asus, asus->gpu_mux_dev); + if (result < 0) + /* An error here may signal greater failure of GPU handling */ + return result; +@@ -759,8 +759,8 @@ static ssize_t egpu_enable_store(struct device *dev, + return err; + } + +- if (asus->gpu_mux_mode_available) { +- result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_GPU_MUX); ++ if (asus->gpu_mux_dev) { ++ result = asus_wmi_get_devstate_simple(asus, asus->gpu_mux_dev); + if (result < 0) { + /* An error here may signal greater failure of GPU handling */ + pr_warn("Failed to get gpu mux status: %d\n", result); +@@ -813,7 +813,7 @@ static ssize_t gpu_mux_mode_show(struct device *dev, + struct asus_wmi *asus = dev_get_drvdata(dev); + int result; + +- result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_GPU_MUX); ++ result = asus_wmi_get_devstate_simple(asus, asus->gpu_mux_dev); + if (result < 0) + return result; + +@@ -859,7 +859,7 @@ static ssize_t gpu_mux_mode_store(struct device *dev, + } + } + +- err = asus_wmi_set_devstate(ASUS_WMI_DEVID_GPU_MUX, optimus, &result); ++ err = asus_wmi_set_devstate(asus->gpu_mux_dev, optimus, &result); + if (err) { + dev_err(dev, "Failed to set GPU MUX mode: %d\n", err); + return err; +@@ -4239,7 +4239,7 @@ static umode_t asus_sysfs_is_visible(struct kobject *kobj, + else if (attr == &dev_attr_dgpu_disable.attr) + ok = asus->dgpu_disable_available; + else if (attr == &dev_attr_gpu_mux_mode.attr) +- ok = asus->gpu_mux_mode_available; ++ ok = asus->gpu_mux_dev != 0; + else if (attr == &dev_attr_fan_boost_mode.attr) + ok = asus->fan_boost_mode_available; + else if (attr == &dev_attr_throttle_thermal_policy.attr) +@@ -4505,7 +4505,6 @@ static int asus_wmi_add(struct platform_device *pdev) + asus->egpu_enable_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_EGPU); + asus->egpu_connect_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_EGPU_CONNECTED); + asus->dgpu_disable_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_DGPU); +- asus->gpu_mux_mode_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_GPU_MUX); + asus->kbd_rgb_mode_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_TUF_RGB_MODE); + asus->kbd_rgb_state_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_TUF_RGB_STATE); + asus->ppt_pl2_sppt_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_PPT_PL2_SPPT); +@@ -4524,6 +4523,11 @@ static int asus_wmi_add(struct platform_device *pdev) + else if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_MINI_LED_MODE2)) + asus->mini_led_dev_id = ASUS_WMI_DEVID_MINI_LED_MODE2; + ++ if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_GPU_MUX)) ++ asus->gpu_mux_dev = ASUS_WMI_DEVID_GPU_MUX; ++ else if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_GPU_MUX_VIVO)) ++ asus->gpu_mux_dev = ASUS_WMI_DEVID_GPU_MUX_VIVO; ++ + err = fan_boost_mode_check_present(asus); + if (err) + goto fail_fan_boost_mode; +diff --git a/include/linux/platform_data/x86/asus-wmi.h b/include/linux/platform_data/x86/asus-wmi.h +index 9cadce10ad9a..b48b024dd844 100644 +--- a/include/linux/platform_data/x86/asus-wmi.h ++++ b/include/linux/platform_data/x86/asus-wmi.h +@@ -128,6 +128,7 @@ + + /* gpu mux switch, 0 = dGPU, 1 = Optimus */ + #define ASUS_WMI_DEVID_GPU_MUX 0x00090016 ++#define ASUS_WMI_DEVID_GPU_MUX_VIVO 0x00090026 + + /* TUF laptop RGB modes/colours */ + #define ASUS_WMI_DEVID_TUF_RGB_MODE 0x00100056 +-- +2.44.0 diff --git a/0003-HID-asus-add-ROG-Ally-N-Key-ID-and-keycodes.patch b/0003-HID-asus-add-ROG-Ally-N-Key-ID-and-keycodes.patch new file mode 100644 index 000000000000..7824f70fcb11 --- /dev/null +++ b/0003-HID-asus-add-ROG-Ally-N-Key-ID-and-keycodes.patch @@ -0,0 +1,50 @@ +From fe9fe2bbb769c5ffe0d096d9732029f900c65872 Mon Sep 17 00:00:00 2001 +From: "Luke D. Jones" <luke@ljones.dev> +Date: Wed, 29 Nov 2023 22:18:11 +1300 +Subject: [PATCH 3/4] HID: asus: add ROG Ally N-Key ID and keycodes + +--- + drivers/hid/hid-asus.c | 7 +++++++ + drivers/hid/hid-ids.h | 1 + + 2 files changed, 8 insertions(+) + +diff --git a/drivers/hid/hid-asus.c b/drivers/hid/hid-asus.c +index cdd998a761fe..3a1a6024d299 100644 +--- a/drivers/hid/hid-asus.c ++++ b/drivers/hid/hid-asus.c +@@ -847,6 +847,10 @@ static int asus_input_mapping(struct hid_device *hdev, + case 0xb3: asus_map_key_clear(KEY_PROG3); break; /* Fn+Left next aura */ + case 0x6a: asus_map_key_clear(KEY_F13); break; /* Screenpad toggle */ + case 0x4b: asus_map_key_clear(KEY_F14); break; /* Arrows/Pg-Up/Dn toggle */ ++ case 0xa5: asus_map_key_clear(KEY_F15); break; /* ROG Ally left back */ ++ case 0xa6: asus_map_key_clear(KEY_F16); break; /* ROG Ally QAM button */ ++ case 0xa7: asus_map_key_clear(KEY_F17); break; /* ROG Ally ROG long-press */ ++ case 0xa8: asus_map_key_clear(KEY_F18); break; /* ROG Ally ROG long-press-release */ + + + default: +@@ -1239,6 +1243,9 @@ static const struct hid_device_id asus_devices[] = { + { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, + USB_DEVICE_ID_ASUSTEK_ROG_NKEY_KEYBOARD3), + QUIRK_USE_KBD_BACKLIGHT | QUIRK_ROG_NKEY_KEYBOARD }, ++ { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, ++ USB_DEVICE_ID_ASUSTEK_ROG_NKEY_ALLY), ++ QUIRK_USE_KBD_BACKLIGHT | QUIRK_ROG_NKEY_KEYBOARD }, + { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, + USB_DEVICE_ID_ASUSTEK_ROG_CLAYMORE_II_KEYBOARD), + QUIRK_ROG_CLAYMORE_II_KEYBOARD }, +diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h +index 8376fb5e2d0b..f1e508a7ef06 100644 +--- a/drivers/hid/hid-ids.h ++++ b/drivers/hid/hid-ids.h +@@ -208,6 +208,7 @@ + #define USB_DEVICE_ID_ASUSTEK_ROG_NKEY_KEYBOARD 0x1866 + #define USB_DEVICE_ID_ASUSTEK_ROG_NKEY_KEYBOARD2 0x19b6 + #define USB_DEVICE_ID_ASUSTEK_ROG_NKEY_KEYBOARD3 0x1a30 ++#define USB_DEVICE_ID_ASUSTEK_ROG_NKEY_ALLY 0x1abe + #define USB_DEVICE_ID_ASUSTEK_ROG_CLAYMORE_II_KEYBOARD 0x196b + #define USB_DEVICE_ID_ASUSTEK_FX503VD_KEYBOARD 0x1869 + +-- +2.44.0 + diff --git a/0003-v4-platform-x86-asus-wmi-add-support-variant-of-TUF-RGB.patch b/0003-v4-platform-x86-asus-wmi-add-support-variant-of-TUF-RGB.patch new file mode 100644 index 000000000000..7e606acbae39 --- /dev/null +++ b/0003-v4-platform-x86-asus-wmi-add-support-variant-of-TUF-RGB.patch @@ -0,0 +1,94 @@ +From: "Luke D. Jones" <luke@ljones.dev> +To: hdegoede@redhat.com +Cc: corentin.chary@gmail.com, ilpo.jarvinen@linux.intel.com, + platform-driver-x86@vger.kernel.org, + linux-kernel@vger.kernel.org, "Luke D. Jones" <luke@ljones.dev> +Subject: [PATCH v4 3/9] platform/x86: asus-wmi: add support variant of TUF RGB +Date: Thu, 4 Apr 2024 13:16:46 +1300 [thread overview] +Message-ID: <20240404001652.86207-4-luke@ljones.dev> (raw) +In-Reply-To: <20240404001652.86207-1-luke@ljones.dev> + +Adds support for a second TUF RGB wmi call that some versions of the TUF +laptop come with. Also adjusts existing support to select whichever is +available. + +Reviewed-by: Ilpo Järvinen <ilpo.jarvinen@linux.intel.com> +Signed-off-by: Luke D. Jones <luke@ljones.dev> +--- + drivers/platform/x86/asus-wmi.c | 13 +++++++++---- + include/linux/platform_data/x86/asus-wmi.h | 1 + + 2 files changed, 10 insertions(+), 4 deletions(-) + +diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c +index 1ab4380e9771..6896d056d227 100644 +--- a/drivers/platform/x86/asus-wmi.c ++++ b/drivers/platform/x86/asus-wmi.c +@@ -281,7 +281,7 @@ struct asus_wmi { + bool nv_dyn_boost_available; + bool nv_temp_tgt_available; + +- bool kbd_rgb_mode_available; ++ u32 kbd_rgb_dev; + bool kbd_rgb_state_available; + + bool throttle_thermal_policy_available; +@@ -881,6 +881,7 @@ static ssize_t kbd_rgb_mode_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) + { ++ struct asus_wmi *asus = dev_get_drvdata(dev); + u32 cmd, mode, r, g, b, speed; + int err; + +@@ -917,7 +918,7 @@ static ssize_t kbd_rgb_mode_store(struct device *dev, + speed = 0xeb; + } + +- err = asus_wmi_evaluate_method3(ASUS_WMI_METHODID_DEVS, ASUS_WMI_DEVID_TUF_RGB_MODE, ++ err = asus_wmi_evaluate_method3(ASUS_WMI_METHODID_DEVS, asus->kbd_rgb_dev, + cmd | (mode << 8) | (r << 16) | (g << 24), b | (speed << 8), NULL); + if (err) + return err; +@@ -1560,7 +1561,7 @@ static int asus_wmi_led_init(struct asus_wmi *asus) + { + int rv = 0, num_rgb_groups = 0, led_val; + +- if (asus->kbd_rgb_mode_available) ++ if (asus->kbd_rgb_dev) + kbd_rgb_mode_groups[num_rgb_groups++] = &kbd_rgb_mode_group; + if (asus->kbd_rgb_state_available) + kbd_rgb_mode_groups[num_rgb_groups++] = &kbd_rgb_state_group; +@@ -4505,7 +4506,6 @@ static int asus_wmi_add(struct platform_device *pdev) + asus->egpu_enable_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_EGPU); + asus->egpu_connect_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_EGPU_CONNECTED); + asus->dgpu_disable_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_DGPU); +- asus->kbd_rgb_mode_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_TUF_RGB_MODE); + asus->kbd_rgb_state_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_TUF_RGB_STATE); + asus->ppt_pl2_sppt_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_PPT_PL2_SPPT); + asus->ppt_pl1_spl_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_PPT_PL1_SPL); +@@ -4528,6 +4528,11 @@ static int asus_wmi_add(struct platform_device *pdev) + else if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_GPU_MUX_VIVO)) + asus->gpu_mux_dev = ASUS_WMI_DEVID_GPU_MUX_VIVO; + ++ if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_TUF_RGB_MODE)) ++ asus->kbd_rgb_dev = ASUS_WMI_DEVID_TUF_RGB_MODE; ++ else if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_TUF_RGB_MODE2)) ++ asus->kbd_rgb_dev = ASUS_WMI_DEVID_TUF_RGB_MODE2; ++ + err = fan_boost_mode_check_present(asus); + if (err) + goto fail_fan_boost_mode; +diff --git a/include/linux/platform_data/x86/asus-wmi.h b/include/linux/platform_data/x86/asus-wmi.h +index b48b024dd844..3e9a01467c67 100644 +--- a/include/linux/platform_data/x86/asus-wmi.h ++++ b/include/linux/platform_data/x86/asus-wmi.h +@@ -132,6 +132,7 @@ + + /* TUF laptop RGB modes/colours */ + #define ASUS_WMI_DEVID_TUF_RGB_MODE 0x00100056 ++#define ASUS_WMI_DEVID_TUF_RGB_MODE2 0x0010005A + + /* TUF laptop RGB power/state */ + #define ASUS_WMI_DEVID_TUF_RGB_STATE 0x00100057 +-- +2.44.0 diff --git a/0004-HID-asus-add-ROG-Z13-lightbar.patch b/0004-HID-asus-add-ROG-Z13-lightbar.patch new file mode 100644 index 000000000000..eff7127026bb --- /dev/null +++ b/0004-HID-asus-add-ROG-Z13-lightbar.patch @@ -0,0 +1,43 @@ +From d9a40306ea83c8799634b6ee8b497d3801967831 Mon Sep 17 00:00:00 2001 +From: "Luke D. Jones" <luke@ljones.dev> +Date: Tue, 2 Apr 2024 15:13:23 +1300 +Subject: [PATCH 4/4] HID: asus: add ROG Z13 lightbar + +Add init of the lightbar which is a small panel on the back of the ASUS +ROG Z13 and uses the same MCU as keyboards. + +Signed-off-by: Luke D. Jones <luke@ljones.dev> +--- + drivers/hid/hid-asus.c | 3 +++ + drivers/hid/hid-ids.h | 1 + + 2 files changed, 4 insertions(+) + +diff --git a/drivers/hid/hid-asus.c b/drivers/hid/hid-asus.c +index 3a1a6024d299..de0c13babc03 100644 +--- a/drivers/hid/hid-asus.c ++++ b/drivers/hid/hid-asus.c +@@ -1243,6 +1243,9 @@ static const struct hid_device_id asus_devices[] = { + { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, + USB_DEVICE_ID_ASUSTEK_ROG_NKEY_KEYBOARD3), + QUIRK_USE_KBD_BACKLIGHT | QUIRK_ROG_NKEY_KEYBOARD }, ++ { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, ++ USB_DEVICE_ID_ASUSTEK_ROG_Z13_LIGHTBAR), ++ QUIRK_USE_KBD_BACKLIGHT | QUIRK_ROG_NKEY_KEYBOARD }, + { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, + USB_DEVICE_ID_ASUSTEK_ROG_NKEY_ALLY), + QUIRK_USE_KBD_BACKLIGHT | QUIRK_ROG_NKEY_KEYBOARD }, +diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h +index f1e508a7ef06..94501dbdd463 100644 +--- a/drivers/hid/hid-ids.h ++++ b/drivers/hid/hid-ids.h +@@ -208,6 +208,7 @@ + #define USB_DEVICE_ID_ASUSTEK_ROG_NKEY_KEYBOARD 0x1866 + #define USB_DEVICE_ID_ASUSTEK_ROG_NKEY_KEYBOARD2 0x19b6 + #define USB_DEVICE_ID_ASUSTEK_ROG_NKEY_KEYBOARD3 0x1a30 ++#define USB_DEVICE_ID_ASUSTEK_ROG_Z13_LIGHTBAR 0x18c6 + #define USB_DEVICE_ID_ASUSTEK_ROG_NKEY_ALLY 0x1abe + #define USB_DEVICE_ID_ASUSTEK_ROG_CLAYMORE_II_KEYBOARD 0x196b + #define USB_DEVICE_ID_ASUSTEK_FX503VD_KEYBOARD 0x1869 +-- +2.44.0 + diff --git a/0004-v4-platform-x86-asus-wmi-support-toggling-POST-sound.patch b/0004-v4-platform-x86-asus-wmi-support-toggling-POST-sound.patch new file mode 100644 index 000000000000..4f0e085cc36f --- /dev/null +++ b/0004-v4-platform-x86-asus-wmi-support-toggling-POST-sound.patch @@ -0,0 +1,129 @@ +From: "Luke D. Jones" <luke@ljones.dev> +To: hdegoede@redhat.com +Cc: corentin.chary@gmail.com, ilpo.jarvinen@linux.intel.com, + platform-driver-x86@vger.kernel.org, + linux-kernel@vger.kernel.org, "Luke D. Jones" <luke@ljones.dev> +Subject: [PATCH v4 4/9] platform/x86: asus-wmi: support toggling POST sound +Date: Thu, 4 Apr 2024 13:16:47 +1300 [thread overview] +Message-ID: <20240404001652.86207-5-luke@ljones.dev> (raw) +In-Reply-To: <20240404001652.86207-1-luke@ljones.dev> + +Add support for toggling the BIOS POST sound on some ASUS laptops. + +Reviewed-by: Ilpo Järvinen <ilpo.jarvinen@linux.intel.com> +Signed-off-by: Luke D. Jones <luke@ljones.dev> +--- + .../ABI/testing/sysfs-platform-asus-wmi | 9 ++++ + drivers/platform/x86/asus-wmi.c | 51 +++++++++++++++++++ + include/linux/platform_data/x86/asus-wmi.h | 3 ++ + 3 files changed, 63 insertions(+) + +diff --git a/Documentation/ABI/testing/sysfs-platform-asus-wmi b/Documentation/ABI/testing/sysfs-platform-asus-wmi +index ef1ac1a20a71..72933527d2e4 100644 +--- a/Documentation/ABI/testing/sysfs-platform-asus-wmi ++++ b/Documentation/ABI/testing/sysfs-platform-asus-wmi +@@ -194,3 +194,12 @@ Contact: "Luke Jones" <luke@ljones.dev> + Description: + Set the target temperature limit of the Nvidia dGPU: + * min=75, max=87 ++ ++What: /sys/devices/platform/<platform>/boot_sound ++Date: Apr 2024 ++KernelVersion: 6.10 ++Contact: "Luke Jones" <luke@ljones.dev> ++Description: ++ Set if the BIOS POST sound is played on boot. ++ * 0 - False, ++ * 1 - True +diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c +index 6896d056d227..6c353b8e8da9 100644 +--- a/drivers/platform/x86/asus-wmi.c ++++ b/drivers/platform/x86/asus-wmi.c +@@ -2115,6 +2115,54 @@ static ssize_t panel_od_store(struct device *dev, + } + static DEVICE_ATTR_RW(panel_od); + ++/* Bootup sound ***************************************************************/ ++ ++static ssize_t boot_sound_show(struct device *dev, ++ struct device_attribute *attr, char *buf) ++{ ++ struct asus_wmi *asus = dev_get_drvdata(dev); ++ int result; ++ ++ result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_BOOT_SOUND); ++ if (result < 0) ++ return result; ++ ++ return sysfs_emit(buf, "%d\n", result); ++} ++ ++static ssize_t boot_sound_store(struct device *dev, ++ struct device_attribute *attr, ++ const char *buf, size_t count) ++{ ++ int result, err; ++ u32 snd; ++ ++ struct asus_wmi *asus = dev_get_drvdata(dev); ++ ++ result = kstrtou32(buf, 10, &snd); ++ if (result) ++ return result; ++ ++ if (snd > 1) ++ return -EINVAL; ++ ++ err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BOOT_SOUND, snd, &result); ++ if (err) { ++ pr_warn("Failed to set boot sound: %d\n", err); ++ return err; ++ } ++ ++ if (result > 1) { ++ pr_warn("Failed to set panel boot sound (result): 0x%x\n", result); ++ return -EIO; ++ } ++ ++ sysfs_notify(&asus->platform_device->dev.kobj, NULL, "boot_sound"); ++ ++ return count; ++} ++static DEVICE_ATTR_RW(boot_sound); ++ + /* Mini-LED mode **************************************************************/ + static ssize_t mini_led_mode_show(struct device *dev, + struct device_attribute *attr, char *buf) +@@ -4207,6 +4255,7 @@ static struct attribute *platform_attributes[] = { + &dev_attr_ppt_platform_sppt.attr, + &dev_attr_nv_dynamic_boost.attr, + &dev_attr_nv_temp_target.attr, ++ &dev_attr_boot_sound.attr, + &dev_attr_panel_od.attr, + &dev_attr_mini_led_mode.attr, + &dev_attr_available_mini_led_mode.attr, +@@ -4259,6 +4308,8 @@ static umode_t asus_sysfs_is_visible(struct kobject *kobj, + ok = asus->nv_dyn_boost_available; + else if (attr == &dev_attr_nv_temp_target.attr) + ok = asus->nv_temp_tgt_available; ++ else if (attr == &dev_attr_boot_sound.attr) ++ devid = ASUS_WMI_DEVID_BOOT_SOUND; + else if (attr == &dev_attr_panel_od.attr) + ok = asus->panel_overdrive_available; + else if (attr == &dev_attr_mini_led_mode.attr) +diff --git a/include/linux/platform_data/x86/asus-wmi.h b/include/linux/platform_data/x86/asus-wmi.h +index 3e9a01467c67..3eb5cd6773ad 100644 +--- a/include/linux/platform_data/x86/asus-wmi.h ++++ b/include/linux/platform_data/x86/asus-wmi.h +@@ -137,6 +137,9 @@ + /* TUF laptop RGB power/state */ + #define ASUS_WMI_DEVID_TUF_RGB_STATE 0x00100057 + ++/* Bootup sound control */ ++#define ASUS_WMI_DEVID_BOOT_SOUND 0x00130022 ++ + /* DSTS masks */ + #define ASUS_WMI_DSTS_STATUS_BIT 0x00000001 + #define ASUS_WMI_DSTS_UNKNOWN_BIT 0x00000002 +-- +2.44.0 diff --git a/0005-platform-x86-asus-wmi-don-t-allow-eGPU-switching-if-.patch b/0005-platform-x86-asus-wmi-don-t-allow-eGPU-switching-if-.patch deleted file mode 100644 index e4fbb7f01ab6..000000000000 --- a/0005-platform-x86-asus-wmi-don-t-allow-eGPU-switching-if-.patch +++ /dev/null @@ -1,37 +0,0 @@ -From 1bddf53ccac067e043857d28c1598401cd9db7f4 Mon Sep 17 00:00:00 2001 -From: "Luke D. Jones" <luke@ljones.dev> -Date: Tue, 20 Jun 2023 12:26:51 +1200 -Subject: [PATCH 05/13] platform/x86: asus-wmi: don't allow eGPU switching if - eGPU not connected - -Check the ASUS_WMI_DEVID_EGPU_CONNECTED method for eGPU connection -before allowing the ASUS_WMI_DEVID_EGPU method to run. - -Signed-off-by: Luke D. Jones <luke@ljones.dev> ---- - drivers/platform/x86/asus-wmi.c | 9 +++++++++ - 1 file changed, 9 insertions(+) - -diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c -index a65cf8599124..3cb7cee110e2 100644 ---- a/drivers/platform/x86/asus-wmi.c -+++ b/drivers/platform/x86/asus-wmi.c -@@ -693,6 +693,15 @@ static ssize_t egpu_enable_store(struct device *dev, - if (enable > 1) - return -EINVAL; - -+ err = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_EGPU_CONNECTED); -+ if (err < 0) -+ return err; -+ if (err < 1) { -+ err = -ENODEV; -+ pr_warn("Failed to set egpu disable: %d\n", err); -+ return err; -+ } -+ - err = asus_wmi_set_devstate(ASUS_WMI_DEVID_EGPU, enable, &result); - if (err) { - pr_warn("Failed to set egpu disable: %d\n", err); --- -2.41.0 - diff --git a/0005-v4-platform-x86-asus-wmi-store-a-min-default-for-ppt-op.patch b/0005-v4-platform-x86-asus-wmi-store-a-min-default-for-ppt-op.patch new file mode 100644 index 000000000000..13552ca342ef --- /dev/null +++ b/0005-v4-platform-x86-asus-wmi-store-a-min-default-for-ppt-op.patch @@ -0,0 +1,266 @@ +From: "Luke D. Jones" <luke@ljones.dev> +To: hdegoede@redhat.com +Cc: corentin.chary@gmail.com, ilpo.jarvinen@linux.intel.com, + platform-driver-x86@vger.kernel.org, + linux-kernel@vger.kernel.org, "Luke D. Jones" <luke@ljones.dev> +Subject: [PATCH v4 5/9] platform/x86: asus-wmi: store a min default for ppt options +Date: Thu, 4 Apr 2024 13:16:48 +1300 [thread overview] +Message-ID: <20240404001652.86207-6-luke@ljones.dev> (raw) +In-Reply-To: <20240404001652.86207-1-luke@ljones.dev> + +Laptops with any of the ppt or nv tunables default to the minimum setting +on boot so we can safely assume a stored value is correct. + +This patch adds storing of those values in the local struct, and enables +reading of those values back. To prevent creating a series of byte holes +in the struct the "<name>_available" bool is removed and +`asus_sysfs_is_visible()` uses the `ASUS_WMI_DEVID_<name>` directly. + +Reviewed-by: Ilpo Järvinen <ilpo.jarvinen@linux.intel.com> +Signed-off-by: Luke D. Jones <luke@ljones.dev> +--- + drivers/platform/x86/asus-wmi.c | 127 +++++++++++++++++++++++++------- + 1 file changed, 99 insertions(+), 28 deletions(-) + +diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c +index 6c353b8e8da9..f13606fc62e6 100644 +--- a/drivers/platform/x86/asus-wmi.c ++++ b/drivers/platform/x86/asus-wmi.c +@@ -273,13 +273,13 @@ struct asus_wmi { + u32 gpu_mux_dev; + + /* Tunables provided by ASUS for gaming laptops */ +- bool ppt_pl2_sppt_available; +- bool ppt_pl1_spl_available; +- bool ppt_apu_sppt_available; +- bool ppt_plat_sppt_available; +- bool ppt_fppt_available; +- bool nv_dyn_boost_available; +- bool nv_temp_tgt_available; ++ u32 ppt_pl2_sppt; ++ u32 ppt_pl1_spl; ++ u32 ppt_apu_sppt; ++ u32 ppt_platform_sppt; ++ u32 ppt_fppt; ++ u32 nv_dynamic_boost; ++ u32 nv_temp_target; + + u32 kbd_rgb_dev; + bool kbd_rgb_state_available; +@@ -1031,11 +1031,21 @@ static ssize_t ppt_pl2_sppt_store(struct device *dev, + return -EIO; + } + ++ asus->ppt_pl2_sppt = value; + sysfs_notify(&asus->platform_device->dev.kobj, NULL, "ppt_pl2_sppt"); + + return count; + } +-static DEVICE_ATTR_WO(ppt_pl2_sppt); ++ ++static ssize_t ppt_pl2_sppt_show(struct device *dev, ++ struct device_attribute *attr, ++ char *buf) ++{ ++ struct asus_wmi *asus = dev_get_drvdata(dev); ++ ++ return sysfs_emit(buf, "%u\n", asus->ppt_pl2_sppt); ++} ++static DEVICE_ATTR_RW(ppt_pl2_sppt); + + /* Tunable: PPT, Intel=PL1, AMD=SPL ******************************************/ + static ssize_t ppt_pl1_spl_store(struct device *dev, +@@ -1065,11 +1075,20 @@ static ssize_t ppt_pl1_spl_store(struct device *dev, + return -EIO; + } + ++ asus->ppt_pl1_spl = value; + sysfs_notify(&asus->platform_device->dev.kobj, NULL, "ppt_pl1_spl"); + + return count; + } +-static DEVICE_ATTR_WO(ppt_pl1_spl); ++static ssize_t ppt_pl1_spl_show(struct device *dev, ++ struct device_attribute *attr, ++ char *buf) ++{ ++ struct asus_wmi *asus = dev_get_drvdata(dev); ++ ++ return sysfs_emit(buf, "%u\n", asus->ppt_pl1_spl); ++} ++static DEVICE_ATTR_RW(ppt_pl1_spl); + + /* Tunable: PPT APU FPPT ******************************************************/ + static ssize_t ppt_fppt_store(struct device *dev, +@@ -1099,11 +1118,21 @@ static ssize_t ppt_fppt_store(struct device *dev, + return -EIO; + } + ++ asus->ppt_fppt = value; + sysfs_notify(&asus->platform_device->dev.kobj, NULL, "ppt_fpu_sppt"); + + return count; + } +-static DEVICE_ATTR_WO(ppt_fppt); ++ ++static ssize_t ppt_fppt_show(struct device *dev, ++ struct device_attribute *attr, ++ char *buf) ++{ ++ struct asus_wmi *asus = dev_get_drvdata(dev); ++ ++ return sysfs_emit(buf, "%u\n", asus->ppt_fppt); ++} ++static DEVICE_ATTR_RW(ppt_fppt); + + /* Tunable: PPT APU SPPT *****************************************************/ + static ssize_t ppt_apu_sppt_store(struct device *dev, +@@ -1133,11 +1162,21 @@ static ssize_t ppt_apu_sppt_store(struct device *dev, + return -EIO; + } + ++ asus->ppt_apu_sppt = value; + sysfs_notify(&asus->platform_device->dev.kobj, NULL, "ppt_apu_sppt"); + + return count; + } +-static DEVICE_ATTR_WO(ppt_apu_sppt); ++ ++static ssize_t ppt_apu_sppt_show(struct device *dev, ++ struct device_attribute *attr, ++ char *buf) ++{ ++ struct asus_wmi *asus = dev_get_drvdata(dev); ++ ++ return sysfs_emit(buf, "%u\n", asus->ppt_apu_sppt); ++} ++static DEVICE_ATTR_RW(ppt_apu_sppt); + + /* Tunable: PPT platform SPPT ************************************************/ + static ssize_t ppt_platform_sppt_store(struct device *dev, +@@ -1167,11 +1206,21 @@ static ssize_t ppt_platform_sppt_store(struct device *dev, + return -EIO; + } + ++ asus->ppt_platform_sppt = value; + sysfs_notify(&asus->platform_device->dev.kobj, NULL, "ppt_platform_sppt"); + + return count; + } +-static DEVICE_ATTR_WO(ppt_platform_sppt); ++ ++static ssize_t ppt_platform_sppt_show(struct device *dev, ++ struct device_attribute *attr, ++ char *buf) ++{ ++ struct asus_wmi *asus = dev_get_drvdata(dev); ++ ++ return sysfs_emit(buf, "%u\n", asus->ppt_platform_sppt); ++} ++static DEVICE_ATTR_RW(ppt_platform_sppt); + + /* Tunable: NVIDIA dynamic boost *********************************************/ + static ssize_t nv_dynamic_boost_store(struct device *dev, +@@ -1201,11 +1250,21 @@ static ssize_t nv_dynamic_boost_store(struct device *dev, + return -EIO; + } + ++ asus->nv_dynamic_boost = value; + sysfs_notify(&asus->platform_device->dev.kobj, NULL, "nv_dynamic_boost"); + + return count; + } +-static DEVICE_ATTR_WO(nv_dynamic_boost); ++ ++static ssize_t nv_dynamic_boost_show(struct device *dev, ++ struct device_attribute *attr, ++ char *buf) ++{ ++ struct asus_wmi *asus = dev_get_drvdata(dev); ++ ++ return sysfs_emit(buf, "%u\n", asus->nv_dynamic_boost); ++} ++static DEVICE_ATTR_RW(nv_dynamic_boost); + + /* Tunable: NVIDIA temperature target ****************************************/ + static ssize_t nv_temp_target_store(struct device *dev, +@@ -1235,11 +1294,21 @@ static ssize_t nv_temp_target_store(struct device *dev, + return -EIO; + } + ++ asus->nv_temp_target = value; + sysfs_notify(&asus->platform_device->dev.kobj, NULL, "nv_temp_target"); + + return count; + } +-static DEVICE_ATTR_WO(nv_temp_target); ++ ++static ssize_t nv_temp_target_show(struct device *dev, ++ struct device_attribute *attr, ++ char *buf) ++{ ++ struct asus_wmi *asus = dev_get_drvdata(dev); ++ ++ return sysfs_emit(buf, "%u\n", asus->nv_temp_target); ++} ++static DEVICE_ATTR_RW(nv_temp_target); + + /* Battery ********************************************************************/ + +@@ -4295,19 +4364,19 @@ static umode_t asus_sysfs_is_visible(struct kobject *kobj, + else if (attr == &dev_attr_throttle_thermal_policy.attr) + ok = asus->throttle_thermal_policy_available; + else if (attr == &dev_attr_ppt_pl2_sppt.attr) +- ok = asus->ppt_pl2_sppt_available; ++ devid = ASUS_WMI_DEVID_PPT_PL2_SPPT; + else if (attr == &dev_attr_ppt_pl1_spl.attr) +- ok = asus->ppt_pl1_spl_available; ++ devid = ASUS_WMI_DEVID_PPT_PL1_SPL; + else if (attr == &dev_attr_ppt_fppt.attr) +- ok = asus->ppt_fppt_available; ++ devid = ASUS_WMI_DEVID_PPT_FPPT; + else if (attr == &dev_attr_ppt_apu_sppt.attr) +- ok = asus->ppt_apu_sppt_available; ++ devid = ASUS_WMI_DEVID_PPT_APU_SPPT; + else if (attr == &dev_attr_ppt_platform_sppt.attr) +- ok = asus->ppt_plat_sppt_available; ++ devid = ASUS_WMI_DEVID_PPT_PLAT_SPPT; + else if (attr == &dev_attr_nv_dynamic_boost.attr) +- ok = asus->nv_dyn_boost_available; ++ devid = ASUS_WMI_DEVID_NV_DYN_BOOST; + else if (attr == &dev_attr_nv_temp_target.attr) +- ok = asus->nv_temp_tgt_available; ++ devid = ASUS_WMI_DEVID_NV_THERM_TARGET; + else if (attr == &dev_attr_boot_sound.attr) + devid = ASUS_WMI_DEVID_BOOT_SOUND; + else if (attr == &dev_attr_panel_od.attr) +@@ -4553,18 +4622,20 @@ static int asus_wmi_add(struct platform_device *pdev) + if (err) + goto fail_platform; + ++ /* ensure defaults for tunables */ ++ asus->ppt_pl2_sppt = 5; ++ asus->ppt_pl1_spl = 5; ++ asus->ppt_apu_sppt = 5; ++ asus->ppt_platform_sppt = 5; ++ asus->ppt_fppt = 5; ++ asus->nv_dynamic_boost = 5; ++ asus->nv_temp_target = 75; ++ + asus->charge_mode_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_CHARGE_MODE); + asus->egpu_enable_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_EGPU); + asus->egpu_connect_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_EGPU_CONNECTED); + asus->dgpu_disable_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_DGPU); + asus->kbd_rgb_state_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_TUF_RGB_STATE); +- asus->ppt_pl2_sppt_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_PPT_PL2_SPPT); +- asus->ppt_pl1_spl_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_PPT_PL1_SPL); +- asus->ppt_fppt_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_PPT_FPPT); +- asus->ppt_apu_sppt_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_PPT_APU_SPPT); +- asus->ppt_plat_sppt_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_PPT_PLAT_SPPT); +- asus->nv_dyn_boost_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_NV_DYN_BOOST); +- asus->nv_temp_tgt_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_NV_THERM_TARGET); + asus->panel_overdrive_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_PANEL_OD); + asus->ally_mcu_usb_switch = acpi_has_method(NULL, ASUS_USB0_PWR_EC0_CSEE) + && dmi_match(DMI_BOARD_NAME, "RC71L"); +-- +2.44.0 diff --git a/0006-platform-x86-asus-wmi-add-safety-checks-to-gpu-switc.patch b/0006-platform-x86-asus-wmi-add-safety-checks-to-gpu-switc.patch deleted file mode 100644 index c7563a02ca84..000000000000 --- a/0006-platform-x86-asus-wmi-add-safety-checks-to-gpu-switc.patch +++ /dev/null @@ -1,104 +0,0 @@ -From 64b96869a3ed4b7c9e41c1a3e8410c3ec2582ca9 Mon Sep 17 00:00:00 2001 -From: "Luke D. Jones" <luke@ljones.dev> -Date: Tue, 20 Jun 2023 12:48:31 +1200 -Subject: [PATCH 06/13] platform/x86: asus-wmi: add safety checks to gpu - switching - -Add safety checking to dgpu_disable, egpu_enable, gpu_mux_mode. - -These checks prevent users from doing such things as: -- disabling the dGPU while is muxed to drive the internal screen -- enabling the eGPU which also disables the dGPU, while muxed to - the internal screen -- switching the MUX to dGPU while the dGPU is disabled - -Signed-off-by: Luke D. Jones <luke@ljones.dev> ---- - drivers/platform/x86/asus-wmi.c | 50 ++++++++++++++++++++++++++++++++- - 1 file changed, 49 insertions(+), 1 deletion(-) - -diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c -index 3cb7cee110e2..7e80ea2a802a 100644 ---- a/drivers/platform/x86/asus-wmi.c -+++ b/drivers/platform/x86/asus-wmi.c -@@ -645,6 +645,18 @@ static ssize_t dgpu_disable_store(struct device *dev, - if (disable > 1) - return -EINVAL; - -+ if (asus->gpu_mux_mode_available) { -+ result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_GPU_MUX); -+ if (result < 0) -+ /* An error here may signal greater failure of GPU handling */ -+ return result; -+ if (!result && disable) { -+ err = -ENODEV; -+ pr_warn("Can not disable dGPU when the MUX is in dGPU mode: %d\n", err); -+ return err; -+ } -+ } -+ - err = asus_wmi_set_devstate(ASUS_WMI_DEVID_DGPU, disable, &result); - if (err) { - pr_warn("Failed to set dgpu disable: %d\n", err); -@@ -693,7 +705,7 @@ static ssize_t egpu_enable_store(struct device *dev, - if (enable > 1) - return -EINVAL; - -- err = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_EGPU_CONNECTED); -+ result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_EGPU_CONNECTED); - if (err < 0) - return err; - if (err < 1) { -@@ -702,6 +714,18 @@ static ssize_t egpu_enable_store(struct device *dev, - return err; - } - -+ if (asus->gpu_mux_mode_available) { -+ result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_GPU_MUX); -+ if (result < 0) -+ /* An error here may signal greater failure of GPU handling */ -+ return result; -+ if (!result && enable) { -+ err = -ENODEV; -+ pr_warn("Can not enable eGPU when the MUX is in dGPU mode: %d\n", err); -+ return err; -+ } -+ } -+ - err = asus_wmi_set_devstate(ASUS_WMI_DEVID_EGPU, enable, &result); - if (err) { - pr_warn("Failed to set egpu disable: %d\n", err); -@@ -764,6 +788,30 @@ static ssize_t gpu_mux_mode_store(struct device *dev, - if (optimus > 1) - return -EINVAL; - -+ if (asus->dgpu_disable_available) { -+ result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_DGPU); -+ if (result < 0) -+ /* An error here may signal greater failure of GPU handling */ -+ return result; -+ if (result && !optimus) { -+ err = -ENODEV; -+ pr_warn("Can not switch MUX to dGPU mode when dGPU is disabled: %d\n", err); -+ return err; -+ } -+ } -+ -+ if (asus->egpu_enable_available) { -+ result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_EGPU); -+ if (result < 0) -+ /* An error here may signal greater failure of GPU handling */ -+ return result; -+ if (result && !optimus) { -+ err = -ENODEV; -+ pr_warn("Can not switch MUX to dGPU mode when eGPU is enabled: %d\n", err); -+ return err; -+ } -+ } -+ - err = asus_wmi_set_devstate(ASUS_WMI_DEVID_GPU_MUX, optimus, &result); - if (err) { - dev_err(dev, "Failed to set GPU MUX mode: %d\n", err); --- -2.41.0 - diff --git a/0006-v4-platform-x86-asus-wmi-adjust-formatting-of-ppt-fcts.patch b/0006-v4-platform-x86-asus-wmi-adjust-formatting-of-ppt-fcts.patch new file mode 100644 index 000000000000..0e0dd878a4f2 --- /dev/null +++ b/0006-v4-platform-x86-asus-wmi-adjust-formatting-of-ppt-fcts.patch @@ -0,0 +1,116 @@ +From: "Luke D. Jones" <luke@ljones.dev> +To: hdegoede@redhat.com +Cc: corentin.chary@gmail.com, ilpo.jarvinen@linux.intel.com, + platform-driver-x86@vger.kernel.org, + linux-kernel@vger.kernel.org, "Luke D. Jones" <luke@ljones.dev> +Subject: [PATCH v4 6/9] platform/x86: asus-wmi: adjust formatting of ppt-<name>() functions +Date: Thu, 4 Apr 2024 13:16:49 +1300 [thread overview] +Message-ID: <20240404001652.86207-7-luke@ljones.dev> (raw) +In-Reply-To: <20240404001652.86207-1-luke@ljones.dev> + +Shift the call to dev_get_drvdata() up to top of the function block +in all of the ppt_<name>() functions as part of a minor cleanup. + +Reviewed-by: Ilpo Järvinen <ilpo.jarvinen@linux.intel.com> +Signed-off-by: Luke D. Jones <luke@ljones.dev> +--- + drivers/platform/x86/asus-wmi.c | 21 +++++++-------------- + 1 file changed, 7 insertions(+), 14 deletions(-) + +diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c +index f13606fc62e6..976e26c82f80 100644 +--- a/drivers/platform/x86/asus-wmi.c ++++ b/drivers/platform/x86/asus-wmi.c +@@ -1008,11 +1008,10 @@ static ssize_t ppt_pl2_sppt_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) + { ++ struct asus_wmi *asus = dev_get_drvdata(dev); + int result, err; + u32 value; + +- struct asus_wmi *asus = dev_get_drvdata(dev); +- + result = kstrtou32(buf, 10, &value); + if (result) + return result; +@@ -1052,11 +1051,10 @@ static ssize_t ppt_pl1_spl_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) + { ++ struct asus_wmi *asus = dev_get_drvdata(dev); + int result, err; + u32 value; + +- struct asus_wmi *asus = dev_get_drvdata(dev); +- + result = kstrtou32(buf, 10, &value); + if (result) + return result; +@@ -1095,11 +1093,10 @@ static ssize_t ppt_fppt_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) + { ++ struct asus_wmi *asus = dev_get_drvdata(dev); + int result, err; + u32 value; + +- struct asus_wmi *asus = dev_get_drvdata(dev); +- + result = kstrtou32(buf, 10, &value); + if (result) + return result; +@@ -1139,11 +1136,10 @@ static ssize_t ppt_apu_sppt_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) + { ++ struct asus_wmi *asus = dev_get_drvdata(dev); + int result, err; + u32 value; + +- struct asus_wmi *asus = dev_get_drvdata(dev); +- + result = kstrtou32(buf, 10, &value); + if (result) + return result; +@@ -1183,11 +1179,10 @@ static ssize_t ppt_platform_sppt_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) + { ++ struct asus_wmi *asus = dev_get_drvdata(dev); + int result, err; + u32 value; + +- struct asus_wmi *asus = dev_get_drvdata(dev); +- + result = kstrtou32(buf, 10, &value); + if (result) + return result; +@@ -1227,11 +1222,10 @@ static ssize_t nv_dynamic_boost_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) + { ++ struct asus_wmi *asus = dev_get_drvdata(dev); + int result, err; + u32 value; + +- struct asus_wmi *asus = dev_get_drvdata(dev); +- + result = kstrtou32(buf, 10, &value); + if (result) + return result; +@@ -1271,11 +1265,10 @@ static ssize_t nv_temp_target_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) + { ++ struct asus_wmi *asus = dev_get_drvdata(dev); + int result, err; + u32 value; + +- struct asus_wmi *asus = dev_get_drvdata(dev); +- + result = kstrtou32(buf, 10, &value); + if (result) + return result; +-- +2.44.0 diff --git a/0007-v4-platform-x86-asus-wmi-ROG-Ally-increase-wait-time.patch b/0007-v4-platform-x86-asus-wmi-ROG-Ally-increase-wait-time.patch new file mode 100644 index 000000000000..684263d500c6 --- /dev/null +++ b/0007-v4-platform-x86-asus-wmi-ROG-Ally-increase-wait-time.patch @@ -0,0 +1,73 @@ +From: "Luke D. Jones" <luke@ljones.dev> +To: hdegoede@redhat.com +Cc: corentin.chary@gmail.com, ilpo.jarvinen@linux.intel.com, + platform-driver-x86@vger.kernel.org, + linux-kernel@vger.kernel.org, "Luke D. Jones" <luke@ljones.dev> +Subject: [PATCH v4 7/9] platform/x86: asus-wmi: ROG Ally increase wait time, allow MCU powersave +Date: Thu, 4 Apr 2024 13:16:50 +1300 [thread overview] +Message-ID: <20240404001652.86207-8-luke@ljones.dev> (raw) +In-Reply-To: <20240404001652.86207-1-luke@ljones.dev> + +The previous work to allow the MCU to be resumed correctly after sleep +and resume tried to take the shortest possible time. However as work +continues in various other parts of the s2idle subsystems it has shown +that it wasn't entirely reliable. + +If the MCU disable/enable call is done correctly the MCU fully removes +its USB endpoints, and this shows as a full USB device reconnection on +resume. When we tried to short this as much as possible sometimes the +MCU doesn't get to complete what it needs to do before going to low-power +and this affected the reconnection. + +Through trial it is found that the minimum time required is approx 1200ms +to allow a proper disconnect and disable, and the same amount of time on +resume is required to prevent a rapid disconnect/reconnect happening on +seemingly random occasions. To be safe the time is now 1500ms for msleep. + +Reviewed-by: Ilpo Järvinen <ilpo.jarvinen@linux.intel.com> +Signed-off-by: Luke D. Jones <luke@ljones.dev> +--- + drivers/platform/x86/asus-wmi.c | 12 ++---------- + 1 file changed, 2 insertions(+), 10 deletions(-) + +diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c +index 976e26c82f80..ab98f91e573c 100644 +--- a/drivers/platform/x86/asus-wmi.c ++++ b/drivers/platform/x86/asus-wmi.c +@@ -140,7 +140,7 @@ module_param(fnlock_default, bool, 0444); + /* Controls the power state of the USB0 hub on ROG Ally which input is on */ + #define ASUS_USB0_PWR_EC0_CSEE "\\_SB.PCI0.SBRG.EC0.CSEE" + /* 300ms so far seems to produce a reliable result on AC and battery */ +-#define ASUS_USB0_PWR_EC0_CSEE_WAIT 300 ++#define ASUS_USB0_PWR_EC0_CSEE_WAIT 1500 + + static const char * const ashs_ids[] = { "ATK4001", "ATK4002", NULL }; + +@@ -4829,6 +4829,7 @@ static int asus_hotk_resume_early(struct device *device) + struct asus_wmi *asus = dev_get_drvdata(device); + + if (asus->ally_mcu_usb_switch) { ++ /* sleep required to prevent USB0 being yanked then reappearing rapidly */ + if (ACPI_FAILURE(acpi_execute_simple_method(NULL, ASUS_USB0_PWR_EC0_CSEE, 0xB8))) + dev_err(device, "ROG Ally MCU failed to connect USB dev\n"); + else +@@ -4840,17 +4841,8 @@ static int asus_hotk_resume_early(struct device *device) + static int asus_hotk_prepare(struct device *device) + { + struct asus_wmi *asus = dev_get_drvdata(device); +- int result, err; + + if (asus->ally_mcu_usb_switch) { +- /* When powersave is enabled it causes many issues with resume of USB hub */ +- result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_MCU_POWERSAVE); +- if (result == 1) { +- dev_warn(device, "MCU powersave enabled, disabling to prevent resume issues"); +- err = asus_wmi_set_devstate(ASUS_WMI_DEVID_MCU_POWERSAVE, 0, &result); +- if (err || result != 1) +- dev_err(device, "Failed to set MCU powersave mode: %d\n", err); +- } + /* sleep required to ensure USB0 is disabled before sleep continues */ + if (ACPI_FAILURE(acpi_execute_simple_method(NULL, ASUS_USB0_PWR_EC0_CSEE, 0xB7))) + dev_err(device, "ROG Ally MCU failed to disconnect USB dev\n"); +-- +2.44.0 diff --git a/0008-v4-platform-x86-asus-wmi-add-support-for-MCU-powersave.patch b/0008-v4-platform-x86-asus-wmi-add-support-for-MCU-powersave.patch new file mode 100644 index 000000000000..7e94b8b6cd60 --- /dev/null +++ b/0008-v4-platform-x86-asus-wmi-add-support-for-MCU-powersave.patch @@ -0,0 +1,115 @@ +From: "Luke D. Jones" <luke@ljones.dev> +To: hdegoede@redhat.com +Cc: corentin.chary@gmail.com, ilpo.jarvinen@linux.intel.com, + platform-driver-x86@vger.kernel.org, + linux-kernel@vger.kernel.org, "Luke D. Jones" <luke@ljones.dev> +Subject: [PATCH v4 8/9] platform/x86: asus-wmi: Add support for MCU powersave +Date: Thu, 4 Apr 2024 13:16:51 +1300 [thread overview] +Message-ID: <20240404001652.86207-9-luke@ljones.dev> (raw) +In-Reply-To: <20240404001652.86207-1-luke@ljones.dev> + +Add support for an MCU powersave WMI call. This is intended to set the +MCU in to a low-power mode when sleeping. This mode can cut sleep power +use by around half. + +Reviewed-by: Ilpo Järvinen <ilpo.jarvinen@linux.intel.com> +Signed-off-by: Luke D. Jones <luke@ljones.dev> +--- + .../ABI/testing/sysfs-platform-asus-wmi | 9 ++++ + drivers/platform/x86/asus-wmi.c | 50 +++++++++++++++++++ + 2 files changed, 59 insertions(+) + +diff --git a/Documentation/ABI/testing/sysfs-platform-asus-wmi b/Documentation/ABI/testing/sysfs-platform-asus-wmi +index 72933527d2e4..28144371a0f1 100644 +--- a/Documentation/ABI/testing/sysfs-platform-asus-wmi ++++ b/Documentation/ABI/testing/sysfs-platform-asus-wmi +@@ -203,3 +203,12 @@ Description: + Set if the BIOS POST sound is played on boot. + * 0 - False, + * 1 - True ++ ++What: /sys/devices/platform/<platform>/mcu_powersave ++Date: Apr 2024 ++KernelVersion: 6.10 ++Contact: "Luke Jones" <luke@ljones.dev> ++Description: ++ Set if the MCU can go in to low-power mode on system sleep ++ * 0 - False, ++ * 1 - True +diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c +index ab98f91e573c..d06d9e0c498c 100644 +--- a/drivers/platform/x86/asus-wmi.c ++++ b/drivers/platform/x86/asus-wmi.c +@@ -1303,6 +1303,53 @@ static ssize_t nv_temp_target_show(struct device *dev, + } + static DEVICE_ATTR_RW(nv_temp_target); + ++/* Ally MCU Powersave ********************************************************/ ++static ssize_t mcu_powersave_show(struct device *dev, ++ struct device_attribute *attr, char *buf) ++{ ++ struct asus_wmi *asus = dev_get_drvdata(dev); ++ int result; ++ ++ result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_MCU_POWERSAVE); ++ if (result < 0) ++ return result; ++ ++ return sysfs_emit(buf, "%d\n", result); ++} ++ ++static ssize_t mcu_powersave_store(struct device *dev, ++ struct device_attribute *attr, ++ const char *buf, size_t count) ++{ ++ int result, err; ++ u32 enable; ++ ++ struct asus_wmi *asus = dev_get_drvdata(dev); ++ ++ result = kstrtou32(buf, 10, &enable); ++ if (result) ++ return result; ++ ++ if (enable > 1) ++ return -EINVAL; ++ ++ err = asus_wmi_set_devstate(ASUS_WMI_DEVID_MCU_POWERSAVE, enable, &result); ++ if (err) { ++ pr_warn("Failed to set MCU powersave: %d\n", err); ++ return err; ++ } ++ ++ if (result > 1) { ++ pr_warn("Failed to set MCU powersave (result): 0x%x\n", result); ++ return -EIO; ++ } ++ ++ sysfs_notify(&asus->platform_device->dev.kobj, NULL, "mcu_powersave"); ++ ++ return count; ++} ++static DEVICE_ATTR_RW(mcu_powersave); ++ + /* Battery ********************************************************************/ + + /* The battery maximum charging percentage */ +@@ -4317,6 +4364,7 @@ static struct attribute *platform_attributes[] = { + &dev_attr_ppt_platform_sppt.attr, + &dev_attr_nv_dynamic_boost.attr, + &dev_attr_nv_temp_target.attr, ++ &dev_attr_mcu_powersave.attr, + &dev_attr_boot_sound.attr, + &dev_attr_panel_od.attr, + &dev_attr_mini_led_mode.attr, +@@ -4370,6 +4418,8 @@ static umode_t asus_sysfs_is_visible(struct kobject *kobj, + devid = ASUS_WMI_DEVID_NV_DYN_BOOST; + else if (attr == &dev_attr_nv_temp_target.attr) + devid = ASUS_WMI_DEVID_NV_THERM_TARGET; ++ else if (attr == &dev_attr_mcu_powersave.attr) ++ devid = ASUS_WMI_DEVID_MCU_POWERSAVE; + else if (attr == &dev_attr_boot_sound.attr) + devid = ASUS_WMI_DEVID_BOOT_SOUND; + else if (attr == &dev_attr_panel_od.attr) +-- +2.44.0 diff --git a/0009-v4-platform-x86-asus-wmi-add-clean-up-structs.patch b/0009-v4-platform-x86-asus-wmi-add-clean-up-structs.patch new file mode 100644 index 000000000000..27ea10404d76 --- /dev/null +++ b/0009-v4-platform-x86-asus-wmi-add-clean-up-structs.patch @@ -0,0 +1,92 @@ +From: "Luke D. Jones" <luke@ljones.dev> +To: hdegoede@redhat.com +Cc: corentin.chary@gmail.com, ilpo.jarvinen@linux.intel.com, + platform-driver-x86@vger.kernel.org, + linux-kernel@vger.kernel.org, "Luke D. Jones" <luke@ljones.dev> +Subject: [PATCH v4 9/9] platform/x86: asus-wmi: cleanup main struct to avoid some holes +Date: Thu, 4 Apr 2024 13:16:52 +1300 [thread overview] +Message-ID: <20240404001652.86207-10-luke@ljones.dev> (raw) +In-Reply-To: <20240404001652.86207-1-luke@ljones.dev> + +Reorganises some attr-available calls to remove a few unrequired +booleans in the main driver struct which combined with some +reorganisation prevents a series of large holes seen with pahole. + +Reviewed-by: Ilpo Järvinen <ilpo.jarvinen@linux.intel.com> +Signed-off-by: Luke D. Jones <luke@ljones.dev> +--- + drivers/platform/x86/asus-wmi.c | 17 ++++++----------- + 1 file changed, 6 insertions(+), 11 deletions(-) + +diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c +index d06d9e0c498c..2d2b4eca7fd8 100644 +--- a/drivers/platform/x86/asus-wmi.c ++++ b/drivers/platform/x86/asus-wmi.c +@@ -254,6 +254,9 @@ struct asus_wmi { + u32 tablet_switch_dev_id; + bool tablet_switch_inverted; + ++ /* The ROG Ally device requires the MCU USB device be disconnected before suspend */ ++ bool ally_mcu_usb_switch; ++ + enum fan_type fan_type; + enum fan_type gpu_fan_type; + enum fan_type mid_fan_type; +@@ -266,9 +269,7 @@ struct asus_wmi { + u8 fan_boost_mode_mask; + u8 fan_boost_mode; + +- bool charge_mode_available; + bool egpu_enable_available; +- bool egpu_connect_available; + bool dgpu_disable_available; + u32 gpu_mux_dev; + +@@ -309,9 +310,6 @@ struct asus_wmi { + + bool fnlock_locked; + +- /* The ROG Ally device requires the MCU USB device be disconnected before suspend */ +- bool ally_mcu_usb_switch; +- + struct asus_wmi_debug debug; + + struct asus_wmi_driver *driver; +@@ -4391,11 +4389,11 @@ static umode_t asus_sysfs_is_visible(struct kobject *kobj, + else if (attr == &dev_attr_als_enable.attr) + devid = ASUS_WMI_DEVID_ALS_ENABLE; + else if (attr == &dev_attr_charge_mode.attr) +- ok = asus->charge_mode_available; ++ devid = ASUS_WMI_DEVID_CHARGE_MODE; + else if (attr == &dev_attr_egpu_enable.attr) + ok = asus->egpu_enable_available; + else if (attr == &dev_attr_egpu_connected.attr) +- ok = asus->egpu_connect_available; ++ devid = ASUS_WMI_DEVID_EGPU_CONNECTED; + else if (attr == &dev_attr_dgpu_disable.attr) + ok = asus->dgpu_disable_available; + else if (attr == &dev_attr_gpu_mux_mode.attr) +@@ -4423,7 +4421,7 @@ static umode_t asus_sysfs_is_visible(struct kobject *kobj, + else if (attr == &dev_attr_boot_sound.attr) + devid = ASUS_WMI_DEVID_BOOT_SOUND; + else if (attr == &dev_attr_panel_od.attr) +- ok = asus->panel_overdrive_available; ++ devid = ASUS_WMI_DEVID_PANEL_OD; + else if (attr == &dev_attr_mini_led_mode.attr) + ok = asus->mini_led_dev_id != 0; + else if (attr == &dev_attr_available_mini_led_mode.attr) +@@ -4674,12 +4672,9 @@ static int asus_wmi_add(struct platform_device *pdev) + asus->nv_dynamic_boost = 5; + asus->nv_temp_target = 75; + +- asus->charge_mode_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_CHARGE_MODE); + asus->egpu_enable_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_EGPU); +- asus->egpu_connect_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_EGPU_CONNECTED); + asus->dgpu_disable_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_DGPU); + asus->kbd_rgb_state_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_TUF_RGB_STATE); +- asus->panel_overdrive_available = asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_PANEL_OD); + asus->ally_mcu_usb_switch = acpi_has_method(NULL, ASUS_USB0_PWR_EC0_CSEE) + && dmi_match(DMI_BOARD_NAME, "RC71L"); + +-- +2.44.0 diff --git a/9999-fix-amdgpu-doorbell-regression.patch b/9999-fix-amdgpu-doorbell-regression.patch new file mode 100644 index 000000000000..f4114e1c0c9f --- /dev/null +++ b/9999-fix-amdgpu-doorbell-regression.patch @@ -0,0 +1,39 @@ +From 1709dfb37341b16cc1b7415c7cb2483952108396 Mon Sep 17 00:00:00 2001 +From: Sasha Levin <sashal@kernel.org> +Date: Mon, 29 Apr 2024 14:29:47 +0200 +Subject: drm/amdgpu: fix doorbell regression + +From: Shashank Sharma <shashank.sharma@amd.com> + +[ Upstream commit 705d0480e6ae5a73ca3a9c04316d0678e19a46ed ] + +This patch adds a missed handling of PL domain doorbell while +handling VRAM faults. + +Cc: Christian Koenig <christian.koenig@amd.com> +Cc: Alex Deucher <alexander.deucher@amd.com> +Fixes: a6ff969fe9cb ("drm/amdgpu: fix visible VRAM handling during faults") +Reviewed-by: Christian Koenig <christian.koenig@amd.com> +Signed-off-by: Shashank Sharma <shashank.sharma@amd.com> +Signed-off-by: Arvind Yadav <arvind.yadav@amd.com> +Signed-off-by: Alex Deucher <alexander.deucher@amd.com> +Signed-off-by: Sasha Levin <sashal@kernel.org> +--- + drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c +index 851509c6e90eb..8d5413ffad301 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c +@@ -424,7 +424,7 @@ bool amdgpu_res_cpu_visible(struct amdgpu_device *adev, + return false; + + if (res->mem_type == TTM_PL_SYSTEM || res->mem_type == TTM_PL_TT || +- res->mem_type == AMDGPU_PL_PREEMPT) ++ res->mem_type == AMDGPU_PL_PREEMPT || res->mem_type == AMDGPU_PL_DOORBELL) + return true; + + if (res->mem_type != TTM_PL_VRAM) +-- +2.43.0 @@ -3,7 +3,7 @@ # Contributor: Jan Alexander Steffens (heftig) <jan.steffens@gmail.com> pkgbase=linux-g14 -pkgver=6.8.1.arch1 +pkgver=6.8.9.arch1 pkgrel=1 pkgdesc='Linux-g14' url="https://gitlab.com/dragonn/linux-g14.git" @@ -34,13 +34,14 @@ source=( "choose-gcc-optimization.sh" "sys-kernel_arch-sources-g14-6.8+--more-uarches-for-kernel.patch"::"https://raw.githubusercontent.com/graysky2/kernel_compiler_patch/master/more-uarches-for-kernel-6.8-rc4%2B.patch" + + 9999-fix-amdgpu-doorbell-regression.patch 0001-acpi-proc-idle-skip-dummy-wait.patch -# 0001-platform-x86-asus-wmi-Add-safety-checks-to-dgpu-egpu.patch 0027-mt76_-mt7921_-Disable-powersave-features-by-default.patch - 0001-linux6.7.y-bore4.0.0.patch + #0001-linux6.8.y-bore4.5.2.patch 0032-Bluetooth-btusb-Add-a-new-PID-VID-0489-e0f6-for-MT7922.patch 0035-Add_quirk_for_polling_the_KBD_port.patch @@ -49,16 +50,30 @@ source=( 0002-ACPI-resource-Skip-IRQ-override-on-ASUS-TUF-Gaming-A.patch v2-0005-platform-x86-asus-wmi-don-t-allow-eGPU-switching-.patch -# v2-0006-platform-x86-asus-wmi-add-safety-checks-to-gpu-sw.patch 0038-mediatek-pci-reset.patch 0040-workaround_hardware_decoding_amdgpu.patch -# 0005-platform-x86-asus-wmi-don-t-allow-eGPU-switching-if-.patch -# 0006-platform-x86-asus-wmi-add-safety-checks-to-gpu-switc.patch - 0001-platform-x86-asus-wmi-Support-2023-ROG-X16-tablet-mo.patch amd-tablet-sfh.patch + + 0001-v4-platform-x86-asus-wmi-add-support-for-2024-ROG-Mini-LED.patch + 0002-v4-platform-x86-asus-wmi-add-support-for-Vivobook-GPU-MUX.patch + 0003-v4-platform-x86-asus-wmi-add-support-variant-of-TUF-RGB.patch + 0004-v4-platform-x86-asus-wmi-support-toggling-POST-sound.patch + 0005-v4-platform-x86-asus-wmi-store-a-min-default-for-ppt-op.patch + 0006-v4-platform-x86-asus-wmi-adjust-formatting-of-ppt-fcts.patch + 0007-v4-platform-x86-asus-wmi-ROG-Ally-increase-wait-time.patch + 0008-v4-platform-x86-asus-wmi-add-support-for-MCU-powersave.patch + 0009-v4-platform-x86-asus-wmi-add-clean-up-structs.patch + + 0001-HID-asus-fix-more-n-key-report-descriptors-if-n-key-.patch + 0001-platform-x86-asus-wmi-add-support-for-vivobook-fan-p.patch + 0002-HID-asus-make-asus_kbd_init-generic-remove-rog_nkey_.patch + 0003-HID-asus-add-ROG-Ally-N-Key-ID-and-keycodes.patch + 0004-HID-asus-add-ROG-Z13-lightbar.patch + + #0060-ALSA_hda-realtek_Add_quirks_for_ASUS_Laptops_using_CS35L56.patch "sys-kernel_arch-sources-g14_files-0047-asus-nb-wmi-Add-tablet_mode_sw-lid-flip.patch" "sys-kernel_arch-sources-g14_files-0048-asus-nb-wmi-fix-tablet_mode_sw_int.patch" @@ -69,16 +84,16 @@ validpgpkeys=( 83BC8889351B5DEBBB68416EB8AC08600F108CDF # Jan Alexander Steffens (heftig) ) -sha256sums=('8d0c8936e3140a0fbdf511ad7a9f21121598f3656743898f47bb9052d37cff68' +sha256sums=('f905f1238ea7a8e85314bacf283302e8097006010d25fcea726d0de0ea5bc9b6' 'SKIP' - '376db82b4613c3942932fde99d54c3dea1e4b29ab23d8b86daa6414327e6244d' + '7a212eedb9fe3da99d6d5b63eb5f28c10ee4333e4d42ea1bb3842a15d3107bef' 'SKIP' - 'c2b00c84c4b543db431e06604d939a62f93107d18369f4d9860dc8062b01ab45' + 'e35c97eb1ab405b12489032225dfb07be591be03d292d8f2131f0df8481d91d8' '278118011d7a2eeca9971ac97b31bf0c55ab55e99c662ab9ae4717b55819c9a2' - 'd69232afd0dd6982ae941cf2d1f577f4be2011e3bb847d1db37952acf416b5d3' + 'f4e7fcd011f2691840d2c8c2361dca850a78ea33cc5c24d2e27c3e0294fd1dc5' + 'f196d51a0536cf0fd6a17cead8be24920a75f392595abbb4654a6caa7e1cc17b' '0a7ea482fe20c403788d290826cec42fe395e5a6eab07b88845f8b9a9829998d' 'ed242f4be3f8eaade2a1d42157c5c6c86281917a08ae43221b088fafdc775ee7' - '6e0b648637a0925df4bb43f5eb5144838415e02c43ff8fddbf82f6813b0f132c' 'a8e1e11a4ab1995cc4975c9b134a43ddfe7054ef0c965e52a7d8f9223e15c3e0' '315d1839630b37894a626bbc2aea012618b2e1ccb6f9d8aa27c0a3ce5e90e99c' 'a00b952d53df9d3617d93e8fba4146a4d6169ebe79f029b3a55cca68f738d8ea' @@ -88,6 +103,20 @@ sha256sums=('8d0c8936e3140a0fbdf511ad7a9f21121598f3656743898f47bb9052d37cff68' 'e41198b29cee4de7a5132d8df606f48c2d0f9c9076fe4230b00a33c7e0b22c71' '1edb362a762c8858374027e30ff58ae0014e117fdc05cc7db6da50f80e7aab87' '508f90cbe81a9a145cc540703470f1e6b5d21c7a7b9166d2ce6e56b401262b04' + 'feaf5f5fb62e25e2369f92f77e8327dcd4cb4cf4bc6d0c91d9c7bc40c0f4de46' + 'b9866121c69ce22b4651b3ef2a1956e6d0547e40a14d1224e2f367a4f716ca1a' + '6f2f248a5ac9b1a37324cbce8d29a65b22a2b20d4b3564c0dc6063789ae733ba' + '28f2b9bf5a1f4993bdc77d4d8ac32c1905edfeb3f4cce476f0f85a31b573bcd0' + 'fa8de80231c933ca294315168d985ae18261e04e77ef17482c815a0703d6c5fb' + '62b297619e500b4453e2f3e0305c4dfb92185f69ebbdb67f99e8f76dad139f7a' + 'c2c89baaf134c0151c3f7a3861d16194e32c91c7abc87f870733cab8c5b88389' + 'f5b560d988c47033c44307da0b584599d1f59cc0028a594f4df87affffc219d5' + 'de85da760f6692b284e39aa78479904d6ee78b349f1e98d1d210777f9ef17581' + '3be072ed798becd91bae66a75d09235c9cb5e84547b1f4eb7768e954ba109e92' + '93c9a77f6c25494cecbe6b236bd2179065d5f5db5589dabaa425134c1a8c3481' + 'c1d96328d96964c2ce3ef7609fb7c07e97eb136dfab9f6d4efcce072a5739838' + '2414dc71174c90b92f975a7d16cabc99ba509397d843132764ea9ee91b643dc0' + '107a08aa610d3ba3c7ecec301df2ea8f345bc74107fcf4dac96fe9e89a23dcf1' '15e912a66e4bbce1cf0450f1dc6610653df29df8dd6d5426f9c1b039490436c8' '444f2d86de8c2177655b01596f939f99c2e7abfa8efad8a509e0a334f42dfa85') diff --git a/chroot-build.sh b/chroot-build.sh index 7d98d468ba4e..f6045161f2b5 100755 --- a/chroot-build.sh +++ b/chroot-build.sh @@ -45,7 +45,7 @@ updpkgsums # # To send environment variable to a PKGBUILD call this script like this: -# `rbuild.sh -- {any makepkg flags} VAR=VALUE VAR2=VALUE etc..` +# `chroot-build.sh -- {any makepkg flags} VAR=VALUE VAR2=VALUE etc..` # # either use makechrootpkg ... @@ -54,5 +54,8 @@ updpkgsums # or clean-chroot-manager (AUR) sudo ccm s +# sync repos afterwards (again) +sudo pacman -Sy + rm PKGBUILD mv .PKGBUILD PKGBUILD @@ -1,8 +1,8 @@ # # Automatically generated file; DO NOT EDIT. -# Linux/x86 6.8.1-arch1 Kernel Configuration +# Linux/x86 6.8.9-arch1 Kernel Configuration # -CONFIG_CC_VERSION_TEXT="gcc (GCC) 13.2.1 20230801" +CONFIG_CC_VERSION_TEXT="gcc (GCC) 13.2.1 20240417" CONFIG_CC_IS_GCC=y CONFIG_GCC_VERSION=130201 CONFIG_CLANG_VERSION=0 @@ -471,7 +471,6 @@ CONFIG_X86_DIRECT_GBPAGES=y CONFIG_X86_CPA_STATISTICS=y CONFIG_X86_MEM_ENCRYPT=y CONFIG_AMD_MEM_ENCRYPT=y -# CONFIG_AMD_MEM_ENCRYPT_ACTIVE_BY_DEFAULT is not set CONFIG_NUMA=y CONFIG_AMD_NUMA=y CONFIG_X86_64_ACPI_NUMA=y @@ -554,7 +553,7 @@ CONFIG_CALL_PADDING=y CONFIG_HAVE_CALL_THUNKS=y CONFIG_CALL_THUNKS=y CONFIG_PREFIX_SYMBOLS=y -CONFIG_SPECULATION_MITIGATIONS=y +CONFIG_CPU_MITIGATIONS=y CONFIG_PAGE_TABLE_ISOLATION=y CONFIG_RETPOLINE=y CONFIG_RETHUNK=y @@ -567,6 +566,7 @@ CONFIG_CPU_SRSO=y CONFIG_SLS=y # CONFIG_GDS_FORCE_MITIGATION is not set CONFIG_MITIGATION_RFDS=y +CONFIG_MITIGATION_SPECTRE_BHI=y CONFIG_ARCH_HAS_ADD_PAGES=y # @@ -785,6 +785,8 @@ CONFIG_AS_SHA256_NI=y CONFIG_AS_TPAUSE=y CONFIG_AS_GFNI=y CONFIG_AS_WRUSS=y +CONFIG_ARCH_CONFIGURES_CPU_MITIGATIONS=y + # # General architecture-dependent options @@ -964,6 +966,7 @@ CONFIG_MODULE_SRCVERSION_ALL=y CONFIG_MODULE_SIG=y # CONFIG_MODULE_SIG_FORCE is not set CONFIG_MODULE_SIG_ALL=y +# CONFIG_MODULE_SIG_SHA1 is not set # CONFIG_MODULE_SIG_SHA256 is not set # CONFIG_MODULE_SIG_SHA384 is not set CONFIG_MODULE_SIG_SHA512=y @@ -1999,7 +2002,6 @@ CONFIG_BT_BNEP_MC_FILTER=y CONFIG_BT_BNEP_PROTO_FILTER=y CONFIG_BT_CMTP=m CONFIG_BT_HIDP=m -# CONFIG_BT_HS is not set CONFIG_BT_LE=y CONFIG_BT_LE_L2CAP_ECRED=y CONFIG_BT_6LOWPAN=m @@ -4615,7 +4617,7 @@ CONFIG_MOXA_INTELLIO=m CONFIG_MOXA_SMARTIO=m CONFIG_N_HDLC=m CONFIG_IPWIRELESS=m -CONFIG_N_GSM=m +# CONFIG_N_GSM is not set CONFIG_NOZOMI=m CONFIG_NULL_TTY=m CONFIG_HVC_DRIVER=y @@ -10454,9 +10456,9 @@ CONFIG_QFMT_V1=m CONFIG_QFMT_V2=m CONFIG_QUOTACTL=y CONFIG_AUTOFS_FS=y -CONFIG_FUSE_FS=m +CONFIG_FUSE_FS=y CONFIG_CUSE=m -CONFIG_VIRTIO_FS=m +CONFIG_VIRTIO_FS=y CONFIG_FUSE_DAX=y CONFIG_OVERLAY_FS=m CONFIG_OVERLAY_FS_REDIRECT_DIR=y diff --git a/fix_amd_eDP_HDR_flickering.patch b/fix_amd_eDP_HDR_flickering.patch new file mode 100644 index 000000000000..cbeeb2cdb2a0 --- /dev/null +++ b/fix_amd_eDP_HDR_flickering.patch @@ -0,0 +1,14 @@ +diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c +index 4e82ee4d74ac..9ac2c66a96a8 100644 +--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c ++++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c +@@ -6172,7 +6172,8 @@ create_stream_for_sink(struct amdgpu_dm_connector *aconnector, + mod_build_hf_vsif_infopacket(stream, &stream->vsp_infopacket); + else if (stream->signal == SIGNAL_TYPE_DISPLAY_PORT || + stream->signal == SIGNAL_TYPE_DISPLAY_PORT_MST || +- stream->signal == SIGNAL_TYPE_EDP) { ++ stream->link->psr_settings.psr_feature_enabled || ++ stream->link->replay_settings.replay_feature_enabled) { + // + // should decide stream support vsc sdp colorimetry capability + // before building vsc info packet diff --git a/v2-0006-platform-x86-asus-wmi-add-safety-checks-to-gpu-sw.patch b/v2-0006-platform-x86-asus-wmi-add-safety-checks-to-gpu-sw.patch deleted file mode 100644 index 124cfa02e5cd..000000000000 --- a/v2-0006-platform-x86-asus-wmi-add-safety-checks-to-gpu-sw.patch +++ /dev/null @@ -1,104 +0,0 @@ -From 391b0757f19890d67ec0ade558a255421588047e Mon Sep 17 00:00:00 2001 -From: "Luke D. Jones" <luke@ljones.dev> -Date: Tue, 20 Jun 2023 12:48:31 +1200 -Subject: [PATCH v2 6/8] platform/x86: asus-wmi: add safety checks to gpu - switching - -Add safety checking to dgpu_disable, egpu_enable, gpu_mux_mode. - -These checks prevent users from doing such things as: -- disabling the dGPU while is muxed to drive the internal screen -- enabling the eGPU which also disables the dGPU, while muxed to - the internal screen -- switching the MUX to dGPU while the dGPU is disabled - -Signed-off-by: Luke D. Jones <luke@ljones.dev> ---- - drivers/platform/x86/asus-wmi.c | 50 ++++++++++++++++++++++++++++++++- - 1 file changed, 49 insertions(+), 1 deletion(-) - -diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c -index 821addb284d7..602426a7fb41 100644 ---- a/drivers/platform/x86/asus-wmi.c -+++ b/drivers/platform/x86/asus-wmi.c -@@ -645,6 +645,18 @@ static ssize_t dgpu_disable_store(struct device *dev, - if (disable > 1) - return -EINVAL; - -+ if (asus->gpu_mux_mode_available) { -+ result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_GPU_MUX); -+ if (result < 0) -+ /* An error here may signal greater failure of GPU handling */ -+ return result; -+ if (!result && disable) { -+ err = -ENODEV; -+ pr_warn("Can not disable dGPU when the MUX is in dGPU mode: %d\n", err); -+ return err; -+ } -+ } -+ - err = asus_wmi_set_devstate(ASUS_WMI_DEVID_DGPU, disable, &result); - if (err) { - pr_warn("Failed to set dgpu disable: %d\n", err); -@@ -693,7 +705,7 @@ static ssize_t egpu_enable_store(struct device *dev, - if (enable > 1) - return -EINVAL; - -- err = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_EGPU_CONNECTED); -+ result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_EGPU_CONNECTED); - if (err < 0) - return err; - if (err < 1) { -@@ -702,6 +714,18 @@ static ssize_t egpu_enable_store(struct device *dev, - return err; - } - -+ if (asus->gpu_mux_mode_available) { -+ result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_GPU_MUX); -+ if (result < 0) -+ /* An error here may signal greater failure of GPU handling */ -+ return result; -+ if (!result && enable) { -+ err = -ENODEV; -+ pr_warn("Can not enable eGPU when the MUX is in dGPU mode: %d\n", err); -+ return err; -+ } -+ } -+ - err = asus_wmi_set_devstate(ASUS_WMI_DEVID_EGPU, enable, &result); - if (err) { - pr_warn("Failed to set egpu disable: %d\n", err); -@@ -764,6 +788,30 @@ static ssize_t gpu_mux_mode_store(struct device *dev, - if (optimus > 1) - return -EINVAL; - -+ if (asus->dgpu_disable_available) { -+ result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_DGPU); -+ if (result < 0) -+ /* An error here may signal greater failure of GPU handling */ -+ return result; -+ if (result && !optimus) { -+ err = -ENODEV; -+ pr_warn("Can not switch MUX to dGPU mode when dGPU is disabled: %d\n", err); -+ return err; -+ } -+ } -+ -+ if (asus->egpu_enable_available) { -+ result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_EGPU); -+ if (result < 0) -+ /* An error here may signal greater failure of GPU handling */ -+ return result; -+ if (result && !optimus) { -+ err = -ENODEV; -+ pr_warn("Can not switch MUX to dGPU mode when eGPU is enabled: %d\n", err); -+ return err; -+ } -+ } -+ - err = asus_wmi_set_devstate(ASUS_WMI_DEVID_GPU_MUX, optimus, &result); - if (err) { - dev_err(dev, "Failed to set GPU MUX mode: %d\n", err); --- -2.41.0 - |