jochen
1059f12ee0
The i3 and laptop READMEs each pointed at the other for 10-asus.conf and 20-g14.conf, so nobody owned them. The module now writes both (adopted paths, so no duplicate binding breaks i3's config check), ships the scripts they call, runs the media keys with notifications again, and brings back the touchpad reset after resume as a unit the sleep services want. zephyrus_keys answers what each custom key runs; the check flags as-user, thd's account and the resume unit. xorg-xinput is the xorg module's.
316 lines
11 KiB
Go
316 lines
11 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"math"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
stdio "git.novox.be/novox/mesh-sdk/go"
|
|
)
|
|
|
|
// Tools is the module's tools, over one machine and its switcher.
|
|
func Tools(m *Machine, sw *Switcher) []stdio.Tool {
|
|
ctx := context.Background
|
|
return []stdio.Tool{
|
|
{
|
|
Name: "zephyrus_brightness",
|
|
Description: "Read or set the internal panel's and the keyboard's backlight. With no argument, reads both. " +
|
|
"panel is a percentage (40) or a step (+5, -10), never below 1 %; keyboard is off, low, med, high, 0-3, + or -.",
|
|
Input: map[string]any{
|
|
"panel": map[string]any{"type": "string", "description": "percentage or step, e.g. 40, +5, -10"},
|
|
"keyboard": map[string]any{"type": "string", "description": "off, low, med, high, 0-3, + or -"},
|
|
},
|
|
Run: func(args map[string]any) (any, error) {
|
|
out := map[string]any{}
|
|
if p := str(args, "panel"); p != "" {
|
|
got, err := m.SetPanel(ctx(), p)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out["panel"] = got
|
|
} else if got, err := m.PanelBrightness(); err == nil {
|
|
out["panel"] = got
|
|
} else {
|
|
out["panel_error"] = err.Error()
|
|
}
|
|
if k := str(args, "keyboard"); k != "" {
|
|
got, err := m.SetKeyboard(ctx(), k)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out["keyboard"] = got
|
|
} else if got, err := m.KeyboardBrightness(); err == nil {
|
|
out["keyboard"] = got
|
|
} else {
|
|
out["keyboard_error"] = err.Error()
|
|
}
|
|
return out, nil
|
|
},
|
|
},
|
|
{
|
|
Name: "zephyrus_battery",
|
|
Description: "The battery: charge, energy, health (full against design), cycles, the charge limit, the power it gives or takes, and time left when discharging.",
|
|
Run: func(map[string]any) (any, error) {
|
|
return map[string]any{"source": PowerSource(m.Supplies()), "batteries": orEmpty(m.Batteries())}, nil
|
|
},
|
|
},
|
|
{
|
|
Name: "zephyrus_charge_limit",
|
|
Description: fmt.Sprintf("Read or set the battery charge limit through asusd. limit is 20-100; oneshot charges to full once "+
|
|
"and goes back to the limit. The module asserts %d %% again when its process next starts.", ChargeLimitPercent),
|
|
Input: map[string]any{
|
|
"limit": map[string]any{"type": "integer", "description": "20-100"},
|
|
"oneshot": map[string]any{"type": "boolean", "description": "charge to full once, keeping the limit"},
|
|
},
|
|
Run: func(args map[string]any) (any, error) { return ChargeLimitTool(ctx(), m, args) },
|
|
},
|
|
{
|
|
Name: "zephyrus_gpu_mode",
|
|
Description: "Read or set the hybrid GPU's mode through supergfxd: Integrated, Hybrid or AsusMuxDgpu as the machine supports. " +
|
|
"Answers the mode, the discrete GPU's power state, any pending mode and the action it waits for (a logout, a reboot), " +
|
|
"and whether asusd will switch it again on the next change of power source.",
|
|
Input: map[string]any{
|
|
"mode": map[string]any{"type": "string", "description": "a supported mode, e.g. Integrated or Hybrid"},
|
|
},
|
|
Run: func(args map[string]any) (any, error) { return GPUModeTool(ctx(), m, args) },
|
|
},
|
|
{
|
|
Name: "zephyrus_profile",
|
|
Description: "Read or set the platform profile (Quiet, Balanced, Performance) through asusd. A profile set here is held " +
|
|
fmt.Sprintf("for hold_minutes (default %d, 0 for none) before the module's switcher may move it; a change of power source ends the hold.", int(DefaultHold.Minutes())),
|
|
Input: map[string]any{
|
|
"profile": map[string]any{"type": "string", "enum": Profiles},
|
|
"hold_minutes": map[string]any{"type": "integer", "description": "how long the switcher leaves it (default 60, at most 1440)"},
|
|
},
|
|
Run: func(args map[string]any) (any, error) { return ProfileTool(ctx(), m, sw, args) },
|
|
},
|
|
{
|
|
Name: "zephyrus_thermals",
|
|
Description: "Every temperature and fan the hardware reports (°C, RPM), the hottest, the platform profile, and the discrete GPU's temperature when it is awake (it is not woken to be read).",
|
|
Run: func(map[string]any) (any, error) { return m.Thermals(ctx()), nil },
|
|
},
|
|
{
|
|
Name: "zephyrus_power_draw",
|
|
Description: "What the machine draws: the battery's flow in watts, the APU's package power, the discrete GPU's draw when awake, and the power source with the reason it was decided.",
|
|
Run: func(map[string]any) (any, error) { return m.PowerDraw(ctx()), nil },
|
|
},
|
|
{
|
|
Name: "zephyrus_profile_policy",
|
|
Description: "What the module's profile switcher would choose now and why: the power source, recent CPU load against the thresholds, " +
|
|
"the decision, the profile in force, any hold, what woke it, and what it asserted in asusd at start.",
|
|
Run: func(map[string]any) (any, error) { return PolicyTool(ctx(), m, sw), nil },
|
|
},
|
|
{
|
|
Name: "zephyrus_fan_curves",
|
|
Description: "The fan curves asusd holds for each profile (or one profile): per fan, eight points of temperature and duty.",
|
|
Input: map[string]any{
|
|
"profile": map[string]any{"type": "string", "enum": Profiles},
|
|
},
|
|
Run: func(args map[string]any) (any, error) { return FanCurvesTool(ctx(), m, args) },
|
|
},
|
|
{
|
|
Name: "zephyrus_keys",
|
|
Description: "Every custom key on the laptop: each triggerhappy trigger (the vendor keys that reach no X client), the module's own i3 lines " +
|
|
"(keys the firmware sends as ordinary presses, and what starts with the session), and the keys the firmware handles itself — " +
|
|
"what each runs and the file it is defined in. Warns when one key is bound in two trigger files, which fires it twice.",
|
|
Run: func(map[string]any) (any, error) { return m.Keys(), nil },
|
|
},
|
|
{
|
|
Name: "zephyrus_check",
|
|
Description: "Check what this module expects of the machine: the model, the vendor packages and daemons, the NVIDIA options in force, " +
|
|
"suspend and resume, the charge limit, one authority each over the profile and the GPU mode, and the predecessor's leftovers. Says what it did not check.",
|
|
Run: func(map[string]any) (any, error) { return m.Check(ctx(), sw), nil },
|
|
},
|
|
}
|
|
}
|
|
|
|
// ChargeLimitTool reads or sets the limit.
|
|
func ChargeLimitTool(ctx context.Context, m *Machine, args map[string]any) (any, error) {
|
|
out := map[string]any{"module_limit_percent": ChargeLimitPercent}
|
|
if v, given := args["limit"]; given && v != nil {
|
|
n, err := whole(v, "limit")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if n < 20 || n > 100 {
|
|
return nil, fmt.Errorf("limit %d is outside 20-100", n)
|
|
}
|
|
if _, err := m.Run(ctx, "asusctl", "battery", "limit", strconv.Itoa(n)); err != nil {
|
|
return nil, vendor("asusctl", err)
|
|
}
|
|
out["set"] = n
|
|
}
|
|
if b, _ := args["oneshot"].(bool); b {
|
|
if _, err := m.Run(ctx, "asusctl", "battery", "oneshot"); err != nil {
|
|
return nil, vendor("asusctl", err)
|
|
}
|
|
out["oneshot"] = "charging to full once; the limit returns after"
|
|
}
|
|
if n, err := m.ChargeLimit(ctx); err == nil {
|
|
out["asusd_limit_percent"] = n
|
|
} else {
|
|
out["asusd_error"] = err.Error()
|
|
}
|
|
for _, b := range m.Batteries() {
|
|
if b.LimitPercent != nil {
|
|
out["kernel_limit_percent"] = *b.LimitPercent
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// GPUModeTool reads or sets the GPU mode.
|
|
func GPUModeTool(ctx context.Context, m *Machine, args map[string]any) (any, error) {
|
|
g, err := m.GPU(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out := map[string]any{}
|
|
if want := str(args, "mode"); want != "" {
|
|
mode := ""
|
|
for _, s := range g.Supported {
|
|
if strings.EqualFold(s, want) {
|
|
mode = s
|
|
}
|
|
}
|
|
if mode == "" {
|
|
return nil, fmt.Errorf("mode %q is not one this machine supports (%s)", want, strings.Join(g.Supported, ", "))
|
|
}
|
|
said, err := m.Run(ctx, "supergfxctl", "-m", mode)
|
|
if err != nil {
|
|
return nil, vendor("supergfxctl", err)
|
|
}
|
|
out["requested"] = mode
|
|
if s := strings.TrimSpace(said); s != "" {
|
|
out["supergfxctl_said"] = s
|
|
}
|
|
if g, err = m.GPU(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
out["gpu"] = g
|
|
if c := m.Asusd(); c != nil && (c.ACCommand != "" || c.BatteryCommand != "") {
|
|
out["asusd_switches_it"] = map[string]string{"on_ac": c.ACCommand, "on_battery": c.BatteryCommand,
|
|
"note": "asusd runs these on every change of power source, so a mode set here lasts until the next one"}
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// ProfileTool reads or sets the profile.
|
|
func ProfileTool(ctx context.Context, m *Machine, sw *Switcher, args map[string]any) (any, error) {
|
|
out := map[string]any{}
|
|
if want := str(args, "profile"); want != "" {
|
|
p, err := canonicalProfile(want)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
hold := DefaultHold
|
|
if v, given := args["hold_minutes"]; given && v != nil {
|
|
n, err := whole(v, "hold_minutes")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if n < 0 {
|
|
return nil, fmt.Errorf("hold_minutes must not be negative")
|
|
}
|
|
hold = time.Duration(min(n, 1440)) * time.Minute
|
|
}
|
|
if err := m.SetProfile(ctx, p); err != nil {
|
|
return nil, err
|
|
}
|
|
out["set"] = p
|
|
if sw != nil {
|
|
if until := sw.Hold(p, hold); !until.IsZero() {
|
|
out["held_until"] = until
|
|
}
|
|
}
|
|
}
|
|
state, err := m.Profile(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out["profile"] = state
|
|
return out, nil
|
|
}
|
|
|
|
// PolicyTool reports the switcher and, independently of it, what the policy says now.
|
|
func PolicyTool(ctx context.Context, m *Machine, sw *Switcher) any {
|
|
out := map[string]any{
|
|
"thresholds": map[string]any{
|
|
"on_battery": ProfileOnBattery, "on_ac": ProfileOnAC, "under_load": ProfileUnderLoad,
|
|
"cpu_high_percent": CPUHighPercent, "cpu_low_percent": CPULowPercent,
|
|
"sample_every": SampleEvery.String(), "sustain_samples": SustainSamples, "relax_samples": RelaxSamples,
|
|
"set_by": "constants until settings exist (novox/hq issue 168)",
|
|
},
|
|
}
|
|
if sw != nil {
|
|
out["switcher"] = sw.Report()
|
|
} else {
|
|
var p Policy
|
|
out["decision_now"] = p.Decide(PowerSource(m.Supplies()))
|
|
}
|
|
if state, err := m.Profile(ctx); err == nil {
|
|
out["in_force"] = state
|
|
} else {
|
|
out["in_force_error"] = err.Error()
|
|
}
|
|
if pid, ok := m.predecessorProcess("auto-profile"); ok {
|
|
out["second_switcher"] = fmt.Sprintf("the predecessor's auto-profile still runs (pid %d) and overrides this every five seconds", pid)
|
|
}
|
|
return out
|
|
}
|
|
|
|
// FanCurvesTool reads asusd's fan curves.
|
|
func FanCurvesTool(ctx context.Context, m *Machine, args map[string]any) (any, error) {
|
|
profiles := Profiles
|
|
if want := str(args, "profile"); want != "" {
|
|
p, err := canonicalProfile(want)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
profiles = []string{p}
|
|
}
|
|
out := map[string]any{}
|
|
for _, p := range profiles {
|
|
said, err := m.Run(ctx, "asusctl", "fan-curve", "--mod-profile", strings.ToLower(p))
|
|
if err != nil {
|
|
return nil, vendor("asusctl", err)
|
|
}
|
|
out[p] = orEmpty(ParseFanCurves(said))
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func str(args map[string]any, key string) string {
|
|
s, _ := args[key].(string)
|
|
return strings.TrimSpace(s)
|
|
}
|
|
|
|
// whole is an integer argument given as a JSON number or a numeric string.
|
|
func whole(v any, key string) (int, error) {
|
|
switch n := v.(type) {
|
|
case float64:
|
|
if n != math.Trunc(n) {
|
|
return 0, fmt.Errorf("%s must be a whole number, not %v", key, n)
|
|
}
|
|
return int(n), nil
|
|
case string:
|
|
i, err := strconv.Atoi(strings.TrimSpace(n))
|
|
if err != nil {
|
|
return 0, fmt.Errorf("%s must be a whole number, not %q", key, n)
|
|
}
|
|
return i, nil
|
|
}
|
|
return 0, fmt.Errorf("%s must be a whole number", key)
|
|
}
|
|
|
|
func orEmpty[T any](s []T) []T {
|
|
if s == nil {
|
|
return []T{}
|
|
}
|
|
return s
|
|
}
|