SecBSD/src
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

sync with OpenBSD -current

Browse source
This commit is contained in:
purplerain 2024-08-06 04:33:39 +00:00
parent 04f8de21b3
commit 174ac28011
Signed by: purplerain
GPG key ID: F42C07F07E2E35B7
16 changed files with 313 additions and 118 deletions
Download patch file Download diff file Expand all files Collapse all files

10
sys/dev/acpi/acpibat.c
View file

@ -1,4 +1,4 @@
/* $OpenBSD: acpibat.c,v 1.71 2024/06/24 15:56:07 mglocker Exp $ */
/* $OpenBSD: acpibat.c,v 1.72 2024/08/05 18:37:29 kettenis Exp $ */
/*
* Copyright (c) 2005 Marco Peereboom <marco@openbsd.org>
*
@ -279,13 +279,11 @@ acpibat_refresh(void *arg)
else if (sc->sc_bst.bst_state & BST_CHARGE)
strlcpy(sc->sc_sens[4].desc, "battery charging",
sizeof(sc->sc_sens[4].desc));
else if (sc->sc_bst.bst_state & BST_CRITICAL) {
strlcpy(sc->sc_sens[4].desc, "battery critical",
sizeof(sc->sc_sens[4].desc));
sc->sc_sens[4].status = SENSOR_S_CRIT;
} else
else
strlcpy(sc->sc_sens[4].desc, "battery idle",
sizeof(sc->sc_sens[4].desc));
if (sc->sc_bst.bst_state & BST_CRITICAL)
sc->sc_sens[4].status = SENSOR_S_CRIT;
sc->sc_sens[4].value = sc->sc_bst.bst_state;
if (sc->sc_bst.bst_rate == BST_UNKNOWN) {

10
sys/dev/fdt/mvgicp.c
View file

@ -1,4 +1,4 @@
/* $OpenBSD: mvgicp.c,v 1.5 2021/10/24 17:52:26 mpi Exp $ */
/* $OpenBSD: mvgicp.c,v 1.6 2024/08/05 18:39:34 kettenis Exp $ */
/*
* Copyright (c) 2019 Patrick Wildt <patrick@blueri.se>
*
@ -74,7 +74,7 @@ mvgicp_attach(struct device *parent, struct device *self, void *aux)
struct mvgicp_softc *sc = (struct mvgicp_softc *)self;
struct fdt_attach_args *faa = aux;
struct interrupt_controller *ic;
uint32_t phandle;
int node;
if (faa->fa_nreg < 1) {
printf(": no registers\n");
@ -100,11 +100,11 @@ mvgicp_attach(struct device *parent, struct device *self, void *aux)
return;
}
extern uint32_t fdt_intr_get_parent(int);
phandle = fdt_intr_get_parent(faa->fa_node);
extern int fdt_intr_get_parent(int);
node = fdt_intr_get_parent(faa->fa_node);
extern LIST_HEAD(, interrupt_controller) interrupt_controllers;
LIST_FOREACH(ic, &interrupt_controllers, ic_list) {
if (ic->ic_phandle == phandle)
if (ic->ic_node == node)
break;
}
sc->sc_parent_ic = ic;

275
sys/dev/fdt/qcpas.c
View file

@ -1,4 +1,4 @@
/* $OpenBSD: qcpas.c,v 1.5 2024/08/04 20:10:38 mglocker Exp $ */
/* $OpenBSD: qcpas.c,v 1.6 2024/08/05 18:36:28 kettenis Exp $ */
/*
* Copyright (c) 2023 Patrick Wildt <patrick@blueri.se>
*
@ -21,6 +21,7 @@
#include <sys/malloc.h>
#include <sys/atomic.h>
#include <sys/exec_elf.h>
#include <sys/sensors.h>
#include <sys/task.h>
#include <machine/apmvar.h>
@ -102,6 +103,14 @@ struct qcpas_softc {
struct task sc_glink_rx;
uint32_t sc_glink_max_channel;
TAILQ_HEAD(,qcpas_glink_channel) sc_glink_channels;
#ifndef SMALL_KERNEL
uint32_t sc_last_full_capacity;
uint32_t sc_warning_capacity;
uint32_t sc_low_capacity;
struct ksensor sc_sens[11];
struct ksensordev sc_sensdev;
#endif
};
int qcpas_match(struct device *, void *, void *);
@ -271,6 +280,77 @@ qcpas_mountroot(struct device *self)
node = OF_getnodebyname(sc->sc_node, "glink-edge");
if (node)
qcpas_glink_attach(sc, node);
#ifndef SMALL_KERNEL
strlcpy(sc->sc_sensdev.xname, sc->sc_dev.dv_xname,
sizeof(sc->sc_sensdev.xname));
strlcpy(sc->sc_sens[0].desc, "last full capacity",
sizeof(sc->sc_sens[0].desc));
sc->sc_sens[0].type = SENSOR_WATTHOUR;
sc->sc_sens[0].flags = SENSOR_FUNKNOWN;
sensor_attach(&sc->sc_sensdev, &sc->sc_sens[0]);
strlcpy(sc->sc_sens[1].desc, "warning capacity",
sizeof(sc->sc_sens[1].desc));
sc->sc_sens[1].type = SENSOR_WATTHOUR;
sc->sc_sens[1].flags = SENSOR_FUNKNOWN;
sensor_attach(&sc->sc_sensdev, &sc->sc_sens[1]);
strlcpy(sc->sc_sens[2].desc, "low capacity",
sizeof(sc->sc_sens[2].desc));
sc->sc_sens[2].type = SENSOR_WATTHOUR;
sc->sc_sens[2].flags = SENSOR_FUNKNOWN;
sensor_attach(&sc->sc_sensdev, &sc->sc_sens[2]);
strlcpy(sc->sc_sens[3].desc, "voltage", sizeof(sc->sc_sens[3].desc));
sc->sc_sens[3].type = SENSOR_VOLTS_DC;
sc->sc_sens[3].flags = SENSOR_FUNKNOWN;
sensor_attach(&sc->sc_sensdev, &sc->sc_sens[3]);
strlcpy(sc->sc_sens[4].desc, "battery unknown",
sizeof(sc->sc_sens[4].desc));
sc->sc_sens[4].type = SENSOR_INTEGER;
sc->sc_sens[4].flags = SENSOR_FUNKNOWN;
sensor_attach(&sc->sc_sensdev, &sc->sc_sens[4]);
strlcpy(sc->sc_sens[5].desc, "rate", sizeof(sc->sc_sens[5].desc));
sc->sc_sens[5].type =SENSOR_WATTS;
sc->sc_sens[5].flags = SENSOR_FUNKNOWN;
sensor_attach(&sc->sc_sensdev, &sc->sc_sens[5]);
strlcpy(sc->sc_sens[6].desc, "remaining capacity",
sizeof(sc->sc_sens[6].desc));
sc->sc_sens[6].type = SENSOR_WATTHOUR;
sc->sc_sens[6].flags = SENSOR_FUNKNOWN;
sensor_attach(&sc->sc_sensdev, &sc->sc_sens[6]);
strlcpy(sc->sc_sens[7].desc, "current voltage",
sizeof(sc->sc_sens[7].desc));
sc->sc_sens[7].type = SENSOR_VOLTS_DC;
sc->sc_sens[7].flags = SENSOR_FUNKNOWN;
sensor_attach(&sc->sc_sensdev, &sc->sc_sens[7]);
strlcpy(sc->sc_sens[8].desc, "design capacity",
sizeof(sc->sc_sens[8].desc));
sc->sc_sens[8].type = SENSOR_WATTHOUR;
sc->sc_sens[8].flags = SENSOR_FUNKNOWN;
sensor_attach(&sc->sc_sensdev, &sc->sc_sens[8]);
strlcpy(sc->sc_sens[9].desc, "discharge cycles",
sizeof(sc->sc_sens[9].desc));
sc->sc_sens[9].type = SENSOR_INTEGER;
sc->sc_sens[9].flags = SENSOR_FUNKNOWN;
sensor_attach(&sc->sc_sensdev, &sc->sc_sens[9]);
strlcpy(sc->sc_sens[10].desc, "temperature",
sizeof(sc->sc_sens[10].desc));
sc->sc_sens[10].type = SENSOR_TEMP;
sc->sc_sens[10].flags = SENSOR_FUNKNOWN;
sensor_attach(&sc->sc_sensdev, &sc->sc_sens[10]);
sensordev_install(&sc->sc_sensdev);
#endif
}
int
@ -1178,6 +1258,12 @@ struct battmgr_bat_status {
uint32_t temperature;
};
void qcpas_pmic_rtr_refresh(void *);
void qcpas_pmic_rtr_bat_info(struct qcpas_softc *,
struct battmgr_bat_info *);
void qcpas_pmic_rtr_bat_status(struct qcpas_softc *,
struct battmgr_bat_status *);
void
qcpas_pmic_rtr_battmgr_req_info(void *cookie)
{
@ -1227,6 +1313,9 @@ qcpas_pmic_rtr_init(void *cookie)
qcpas_pmic_rtr_apm_cookie = cookie;
apm_setinfohook(qcpas_pmic_rtr_apminfo);
#endif
#ifndef SMALL_KERNEL
sensor_task_register(cookie, qcpas_pmic_rtr_refresh, 5);
#endif
return 0;
}
@ -1234,12 +1323,10 @@ qcpas_pmic_rtr_init(void *cookie)
int
qcpas_pmic_rtr_recv(void *cookie, uint8_t *buf, int len)
{
#if NAPM > 0
static uint32_t last_full_capacity;
#endif
struct qcpas_glink_channel *ch = cookie;
struct qcpas_softc *sc = ch->ch_sc;
struct pmic_glink_hdr hdr;
uint32_t notification;
extern int hw_power;
if (len < sizeof(hdr)) {
printf("%s: pmic glink message too small\n",
@ -1282,67 +1369,21 @@ qcpas_pmic_rtr_recv(void *cookie, uint8_t *buf, int len)
return 0;
}
bat = malloc(sizeof(*bat), M_TEMP, M_WAITOK);
memcpy((void *)bat, buf + sizeof(hdr), sizeof(*bat));
#if NAPM > 0
last_full_capacity = bat->last_full_capacity;
#endif
memcpy(bat, buf + sizeof(hdr), sizeof(*bat));
qcpas_pmic_rtr_bat_info(sc, bat);
free(bat, M_TEMP, sizeof(*bat));
break;
}
case BATTMGR_OPCODE_BAT_STATUS: {
struct battmgr_bat_status *bat;
#if NAPM > 0
struct apm_power_info *info;
uint32_t delta;
#endif
if (len - sizeof(hdr) != sizeof(*bat)) {
printf("%s: invalid battgmr bat status\n",
__func__);
return 0;
}
#if NAPM > 0
/* Needs BAT_INFO fist */
if (last_full_capacity == 0) {
wakeup(&qcpas_pmic_rtr_apm_power_info);
return 0;
}
#endif
bat = malloc(sizeof(*bat), M_TEMP, M_WAITOK);
memcpy((void *)bat, buf + sizeof(hdr), sizeof(*bat));
#if NAPM > 0
info = &qcpas_pmic_rtr_apm_power_info;
info->battery_life = ((bat->capacity * 100) /
last_full_capacity);
if (info->battery_life > 50)
info->battery_state = APM_BATT_HIGH;
else if (info->battery_life > 25)
info->battery_state = APM_BATT_LOW;
else
info->battery_state = APM_BATT_CRITICAL;
if (bat->battery_state & BATTMGR_BAT_STATE_CHARGING)
info->battery_state = APM_BATT_CHARGING;
else if (bat->battery_state & BATTMGR_BAT_STATE_CRITICAL_LOW)
info->battery_state = APM_BATT_CRITICAL;
if (bat->rate < 0)
delta = bat->capacity;
else
delta = last_full_capacity - bat->capacity;
if (bat->rate == 0)
info->minutes_left = -1;
else
info->minutes_left =
(60 * delta) / abs(bat->rate);
if (bat->power_state & BATTMGR_PWR_STATE_AC_ON) {
info->ac_state = APM_AC_ON;
hw_power = 1;
} else {
info->ac_state = APM_AC_OFF;
hw_power = 0;
}
wakeup(&qcpas_pmic_rtr_apm_power_info);
#endif
memcpy(bat, buf + sizeof(hdr), sizeof(*bat));
qcpas_pmic_rtr_bat_status(sc, bat);
free(bat, M_TEMP, sizeof(*bat));
break;
}
@ -1377,3 +1418,127 @@ qcpas_pmic_rtr_apminfo(struct apm_power_info *info)
return 0;
}
#endif
void
qcpas_pmic_rtr_refresh(void *arg)
{
qcpas_pmic_rtr_battmgr_req_status(arg);
}
void
qcpas_pmic_rtr_bat_info(struct qcpas_softc *sc, struct battmgr_bat_info *bat)
{
#ifndef SMALL_KERNEL
sc->sc_last_full_capacity = bat->last_full_capacity;
sc->sc_warning_capacity = bat->capacity_warning;
sc->sc_low_capacity = bat->capacity_low;
sc->sc_sens[0].value = bat->last_full_capacity * 1000;
sc->sc_sens[0].flags &= ~SENSOR_FUNKNOWN;
sc->sc_sens[1].value = bat->capacity_warning * 1000;
sc->sc_sens[1].flags &= ~SENSOR_FUNKNOWN;
sc->sc_sens[2].value = bat->capacity_low * 1000;
sc->sc_sens[2].flags &= ~SENSOR_FUNKNOWN;
sc->sc_sens[3].value = bat->design_voltage * 1000;
sc->sc_sens[3].flags &= ~SENSOR_FUNKNOWN;
sc->sc_sens[8].value = bat->design_capacity * 1000;
sc->sc_sens[8].flags &= ~SENSOR_FUNKNOWN;
sc->sc_sens[9].value = bat->cycle_count;
sc->sc_sens[9].flags &= ~SENSOR_FUNKNOWN;
#endif
}
void
qcpas_pmic_rtr_bat_status(struct qcpas_softc *sc,
struct battmgr_bat_status *bat)
{
#if NAPM > 0
extern int hw_power;
struct apm_power_info *info = &qcpas_pmic_rtr_apm_power_info;
uint32_t delta;
#endif
#ifndef SMALL_KERNEL
if (bat->capacity >= sc->sc_last_full_capacity)
strlcpy(sc->sc_sens[4].desc, "battery full",
sizeof(sc->sc_sens[4].desc));
else if (bat->battery_state & BATTMGR_BAT_STATE_DISCHARGE)
strlcpy(sc->sc_sens[4].desc, "battery discharging",
sizeof(sc->sc_sens[4].desc));
else if (bat->battery_state & BATTMGR_BAT_STATE_CHARGING)
strlcpy(sc->sc_sens[4].desc, "battery charging",
sizeof(sc->sc_sens[4].desc));
else
strlcpy(sc->sc_sens[4].desc, "battery idle",
sizeof(sc->sc_sens[4].desc));
if (bat->battery_state & BATTMGR_BAT_STATE_CRITICAL_LOW)
sc->sc_sens[4].status = SENSOR_S_CRIT;
else
sc->sc_sens[4].status = SENSOR_S_OK;
sc->sc_sens[4].value = bat->battery_state;
sc->sc_sens[4].flags &= ~SENSOR_FUNKNOWN;
sc->sc_sens[5].value = abs(bat->rate) * 1000;
sc->sc_sens[5].flags &= ~SENSOR_FUNKNOWN;
sc->sc_sens[6].value = bat->capacity * 1000;
if (bat->capacity < sc->sc_low_capacity)
sc->sc_sens[6].status = SENSOR_S_CRIT;
else if (bat->capacity < sc->sc_warning_capacity)
sc->sc_sens[6].status = SENSOR_S_WARN;
else
sc->sc_sens[6].status = SENSOR_S_OK;
sc->sc_sens[6].flags &= ~SENSOR_FUNKNOWN;
sc->sc_sens[7].value = bat->battery_voltage * 1000;
sc->sc_sens[7].flags &= ~SENSOR_FUNKNOWN;
sc->sc_sens[10].value = (bat->temperature * 10000) + 273150000;
sc->sc_sens[10].flags &= ~SENSOR_FUNKNOWN;
#endif
#if NAPM > 0
/* Needs BAT_INFO fist */
if (sc->sc_last_full_capacity == 0) {
wakeup(&qcpas_pmic_rtr_apm_power_info);
return;
}
info->battery_life =
((bat->capacity * 100) / sc->sc_last_full_capacity);
if (info->battery_life > 50)
info->battery_state = APM_BATT_HIGH;
else if (info->battery_life > 25)
info->battery_state = APM_BATT_LOW;
else
info->battery_state = APM_BATT_CRITICAL;
if (bat->battery_state & BATTMGR_BAT_STATE_CHARGING)
info->battery_state = APM_BATT_CHARGING;
else if (bat->battery_state & BATTMGR_BAT_STATE_CRITICAL_LOW)
info->battery_state = APM_BATT_CRITICAL;
if (bat->rate < 0)
delta = bat->capacity;
else
delta = sc->sc_last_full_capacity - bat->capacity;
if (bat->rate == 0)
info->minutes_left = -1;
else
info->minutes_left = (60 * delta) / abs(bat->rate);
if (bat->power_state & BATTMGR_PWR_STATE_AC_ON) {
info->ac_state = APM_AC_ON;
hw_power = 1;
} else {
info->ac_state = APM_AC_OFF;
hw_power = 0;
}
wakeup(&qcpas_pmic_rtr_apm_power_info);
#endif
}