sravan/system76-embedded-controller
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add debug levels

Browse Source
This commit is contained in:
Jeremy Soller 2019-11-18 09:22:21 -07:00
parent e0e17258a3
commit 93e35d2cc5
No known key found for this signature in database
GPG Key ID: E988B49EE78A7FB1
10 changed files with 167 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
src/board/system76/galp3-c/acpi.c
View File

@ -1,15 +1,18 @@
#include <stdio.h>
#include <board/acpi.h>
#include <common/debug.h>
uint8_t acpi_read(uint8_t addr) {
uint8_t data = 0;
//TODO
printf("acpi_read %02X = %02X\n", addr, data);
DEBUG("acpi_read %02X = %02X\n", addr, data);
switch (addr) {
//TODO
}
return data;
}
void acpi_write(uint8_t addr, uint8_t data) {
//TODO
printf("acpi_write %02X = %02X\n", addr, data);
DEBUG("acpi_write %02X = %02X\n", addr, data);
switch (addr) {
//TODO
}
}

13
src/board/system76/galp3-c/battery.c
View File

@ -1,5 +1,4 @@
#include <stdio.h>
#include <common/debug.h>
#include <common/i2c.h>
int smbus_read(uint8_t address, uint8_t command, uint16_t * data) {
@ -46,22 +45,22 @@ void battery_debug(void) {
int res = 0;
#define command(N, A, V) { \
printf(#N ": "); \
DEBUG(#N ": "); \
res = smbus_read(A, V, &data); \
if (res < 0) { \
printf("ERROR %04X\n", -res); \
DEBUG("ERROR %04X\n", -res); \
} else { \
printf("%04X\n", data); \
DEBUG("%04X\n", data); \
} \
}
printf("Battery:\n");
DEBUG("Battery:\n");
command(Temperature, 0x0B, 0x08);
command(Voltage, 0x0B, 0x09);
command(Current, 0x0B, 0x0A);
command(Charge, 0x0B, 0x0D);
printf("Charger:\n");
DEBUG("Charger:\n");
command(ChargeOption0, 0x09, 0x12);
command(ChargeOption1, 0x09, 0x3B);
command(ChargeOption2, 0x09, 0x38);

3
src/board/system76/galp3-c/board.mk
View File

@ -1 +1,4 @@
EC=it8587e
# Set debug level to debug
CFLAGS+=-DLEVEL=4

5
src/board/system76/galp3-c/gpio.c
View File

@ -1,6 +1,5 @@
#include <stdio.h>
#include <board/gpio.h>
#include <common/debug.h>
void gpio_init() {
// Enable LPC reset on GPD2
@ -117,7 +116,7 @@ void gpio_debug_bank(
volatile uint8_t * control
) {
for(char i = 0; i < 8; i++) {
printf(
DEBUG(
"%s%d:\n\tdata %d\n\tmirror %d\n\tpot %d\n\tcontrol %02X\n",
bank,
i,

71
src/board/system76/galp3-c/kbc.c
View File

@ -1,8 +1,7 @@
#include <stdio.h>
#include <board/kbc.h>
#include <board/kbscan.h>
#include <board/keymap.h>
#include <common/debug.h>
#include <ec/ps2.h>
void kbc_init(void) {
@ -31,7 +30,7 @@ bool kbc_scancode(struct Kbc * kbc, uint16_t key, bool pressed) {
if (!key) return true;
switch (key & 0xFF00) {
case K_E0:
printf(" E0\n");
DEBUG(" E0\n");
if (!kbc_keyboard(kbc, 0xE0, KBC_TIMEOUT)) return false;
key &= 0xFF;
// Fall through
@ -40,11 +39,11 @@ bool kbc_scancode(struct Kbc * kbc, uint16_t key, bool pressed) {
if (kbc_translate) {
key |= 0x80;
} else {
printf(" F0\n");
DEBUG(" F0\n");
if (!kbc_keyboard(kbc, 0xF0, KBC_TIMEOUT)) return false;
}
}
printf(" %02X\n", key);
DEBUG(" %02X\n", key);
if (!kbc_keyboard(kbc, (uint8_t)key, KBC_TIMEOUT)) return false;
break;
}
@ -70,12 +69,12 @@ void kbc_event(struct Kbc * kbc) {
if (sts & KBC_STS_IBF) {
uint8_t data = kbc_read(kbc);
if (sts & KBC_STS_CMD) {
printf("kbc cmd: %02X\n", data);
DEBUG("kbc cmd: %02X\n", data);
state = KBC_STATE_NORMAL;
switch (data) {
case 0x20:
printf(" read configuration byte\n");
DEBUG(" read configuration byte\n");
uint8_t config = *kbc->control & 0x03;
if (kbc_system) {
config |= (1 << 2);
@ -92,81 +91,81 @@ void kbc_event(struct Kbc * kbc) {
kbc_keyboard(kbc, config, KBC_TIMEOUT);
break;
case 0x60:
printf(" write configuration byte\n");
DEBUG(" write configuration byte\n");
state = KBC_STATE_WRITE_CONFIG;
break;
case 0xA7:
printf(" disable second port\n");
DEBUG(" disable second port\n");
kbc_second = false;
break;
case 0xA8:
printf(" enable second port\n");
DEBUG(" enable second port\n");
kbc_second = true;
break;
case 0xA9:
printf(" test second port\n");
DEBUG(" test second port\n");
// TODO: communicate with touchpad?
kbc_keyboard(kbc, 0x00, KBC_TIMEOUT);
break;
case 0xAA:
printf(" test controller\n");
DEBUG(" test controller\n");
// Why not pass the test?
kbc_keyboard(kbc, 0x55, KBC_TIMEOUT);
break;
case 0xAB:
printf(" test first port\n");
DEBUG(" test first port\n");
// We _ARE_ the keyboard, so everything is good.
kbc_keyboard(kbc, 0x00, KBC_TIMEOUT);
break;
case 0xAD:
printf(" disable first port\n");
DEBUG(" disable first port\n");
kbc_first = false;
break;
case 0xAE:
printf(" enable first port\n");
DEBUG(" enable first port\n");
kbc_first = true;
break;
case 0xD1:
printf(" write port byte\n");
DEBUG(" write port byte\n");
state = KBC_STATE_WRITE_PORT;
break;
case 0xD2:
printf(" write first port output\n");
DEBUG(" write first port output\n");
state = KBC_STATE_FIRST_PORT_OUTPUT;
break;
case 0xD3:
printf(" write second port output\n");
DEBUG(" write second port output\n");
state = KBC_STATE_SECOND_PORT_OUTPUT;
break;
case 0xD4:
printf(" write second port input\n");
DEBUG(" write second port input\n");
state = KBC_STATE_SECOND_PORT_INPUT;
break;
}
} else {
printf("kbc data: %02X\n", data);
DEBUG("kbc data: %02X\n", data);
switch (state) {
case KBC_STATE_NORMAL:
printf(" keyboard command\n");
DEBUG(" keyboard command\n");
switch (data) {
case 0xED:
printf(" set leds\n");
DEBUG(" set leds\n");
state = KBC_STATE_SET_LEDS;
kbc_keyboard(kbc, 0xFA, KBC_TIMEOUT);
break;
case 0xEE:
printf(" echo\n");
DEBUG(" echo\n");
// Hey, this is easy. I like easy commands
kbc_keyboard(kbc, 0xEE, KBC_TIMEOUT);
break;
case 0xF0:
printf(" get/set scancode\n");
DEBUG(" get/set scancode\n");
state = KBC_STATE_SCANCODE;
kbc_keyboard(kbc, 0xFA, KBC_TIMEOUT);
break;
case 0xF2:
printf(" identify keyboard\n");
DEBUG(" identify keyboard\n");
if (kbc_keyboard(kbc, 0xFA, KBC_TIMEOUT)) {
if (kbc_keyboard(kbc, 0xAB, KBC_TIMEOUT)) {
kbc_keyboard(kbc, 0x83, KBC_TIMEOUT);
@ -174,17 +173,17 @@ void kbc_event(struct Kbc * kbc) {
}
break;
case 0xF4:
printf(" enable scanning\n");
DEBUG(" enable scanning\n");
kbscan_enabled = true;
kbc_keyboard(kbc, 0xFA, KBC_TIMEOUT);
break;
case 0xF5:
printf(" disable scanning\n");
DEBUG(" disable scanning\n");
kbscan_enabled = false;
kbc_keyboard(kbc, 0xFA, KBC_TIMEOUT);
break;
case 0xFF:
printf(" self test\n");
DEBUG(" self test\n");
if (kbc_keyboard(kbc, 0xFA, KBC_TIMEOUT)) {
// Yep, everything is still good, I promise
kbc_keyboard(kbc, 0xAA, KBC_TIMEOUT);
@ -193,7 +192,7 @@ void kbc_event(struct Kbc * kbc) {
}
break;
case KBC_STATE_WRITE_CONFIG:
printf(" write configuration byte\n");
DEBUG(" write configuration byte\n");
state = KBC_STATE_NORMAL;
uint8_t control = *kbc->control;
if (data & 1) {
@ -213,36 +212,36 @@ void kbc_event(struct Kbc * kbc) {
*kbc->control = control;
break;
case KBC_STATE_SET_LEDS:
printf(" set leds\n");
DEBUG(" set leds\n");
state = KBC_STATE_NORMAL;
kbc_keyboard(kbc, 0xFA, KBC_TIMEOUT);
break;
case KBC_STATE_SCANCODE:
printf(" get/set scancode\n");
DEBUG(" get/set scancode\n");
state = KBC_STATE_NORMAL;
switch (data) {
case 0x02:
printf(" set scancode set 2\n");
DEBUG(" set scancode set 2\n");
break;
}
kbc_keyboard(kbc, 0xFA, KBC_TIMEOUT);
break;
case KBC_STATE_WRITE_PORT:
printf(" write port byte\n");
DEBUG(" write port byte\n");
state = KBC_STATE_NORMAL;
break;
case KBC_STATE_FIRST_PORT_OUTPUT:
printf(" write first port output\n");
DEBUG(" write first port output\n");
state = KBC_STATE_NORMAL;
kbc_keyboard(kbc, data, KBC_TIMEOUT);
break;
case KBC_STATE_SECOND_PORT_OUTPUT:
printf(" write second port output\n");
DEBUG(" write second port output\n");
state = KBC_STATE_NORMAL;
kbc_mouse(kbc, data, KBC_TIMEOUT);
break;
case KBC_STATE_SECOND_PORT_INPUT:
printf(" write second port input\n");
DEBUG(" write second port input\n");
state = KBC_STATE_NORMAL;
ps2_write(&PS2_3, &data, 1);
break;

5
src/board/system76/galp3-c/kbscan.c
View File

@ -1,9 +1,8 @@
#include <stdio.h>
#include <arch/delay.h>
#include <board/kbc.h>
#include <board/kbscan.h>
#include <board/keymap.h>
#include <common/debug.h>
bool kbscan_enabled = false;
@ -50,7 +49,7 @@ void kbscan_event(void) {
bool last_b = last & (1 << j);
if (new_b != last_b) {
uint16_t key = keymap(i, j, kbscan_layer);
printf("KB %d, %d, %d = 0x%04X, %d\n", i, j, kbscan_layer, key, new_b);
TRACE("KB %d, %d, %d = 0x%04X, %d\n", i, j, kbscan_layer, key, new_b);
if (kbscan_enabled && key) {
kbc_scancode(&KBC, key, new_b);
}

5
src/board/system76/galp3-c/keymap.c
View File

@ -1,6 +1,5 @@
#include <stdio.h>
#include <board/keymap.h>
#include <common/debug.h>
uint16_t __code KEYMAP[KM_OUT][KM_IN][KM_LAY] = {
{ // 0
@ -282,7 +281,7 @@ uint16_t keymap_translate(uint16_t key) {
case K_RIGHT: return (K_E0 | 0x4D);
default:
printf("keymap_translate: unknown %02X\n", key);
WARN("keymap_translate: unknown %02X\n", key);
return 0;
}
}

112
src/board/system76/galp3-c/main.c
View File

@ -12,30 +12,31 @@
#include <board/ps2.h>
#include <board/pwm.h>
#include <board/smbus.h>
#include <common/debug.h>
#include <common/macro.h>
void external_0(void) __interrupt(0) {
printf("external_0\n");
TRACE("external_0\n");
}
void timer_0(void) __interrupt(1) {
printf("timer_0\n");
TRACE("timer_0\n");
}
void external_1(void) __interrupt(2) {
printf("external_1\n");
TRACE("external_1\n");
}
void timer_1(void) __interrupt(3) {
printf("timer_1\n");
TRACE("timer_1\n");
}
void serial(void) __interrupt(4) {
printf("serial\n");
TRACE("serial\n");
}
void timer_2(void) __interrupt(5) {
printf("timer_2\n");
TRACE("timer_2\n");
}
void init(void) {
@ -122,7 +123,7 @@ void peci_event(void) {
if (duty != DCR2) {
DCR2 = duty;
printf("PECI offset=%d, temp=%d = %d\n", offset, temp, duty);
DEBUG("PECI offset=%d, temp=%d = %d\n", offset, temp, duty);
}
} else {
// Default to 50% if there is an error
@ -143,12 +144,12 @@ void ac_adapter() {
// If there has been a change, print
if (new != last) {
printf("Power adapter ");
DEBUG("Power adapter ");
if (new) {
printf("unplugged\n");
DEBUG("unplugged\n");
battery_charger_disable();
} else {
printf("plugged in\n");
DEBUG("plugged in\n");
battery_charger_enable();
}
battery_debug();
@ -178,7 +179,11 @@ void pnp_write(uint8_t reg, uint8_t data) {
}
void pnp_enable() {
printf("Enable PNP devices\n");
DEBUG("Enable PNP devices\n");
// Enable PMC
pnp_write(0x07, 0x11);
pnp_write(0x30, 0x01);
// Enable KBC keyboard
pnp_write(0x07, 0x06);
@ -223,65 +228,61 @@ void power_button() {
// Ensure press is not spurious
delay_ms(100);
if (gpio_get(&PWR_SW_N) != new) {
printf("Spurious press\n");
DEBUG("Spurious press\n");
return;
}
printf("Power switch press\n");
DEBUG("Power switch press\n");
power = !power;
if (power) {
printf("Enabling S5 power\n");
DEBUG("Enabling S5 power\n");
// We assume that VCCRTC has already been stable, RTCRST# is
// already set, and VCCDSW_3P3 is stable
// Enable battery charger - also provides correct power levels for
// system boot sourced from the AC adapter
// battery_charger_enable();
// Make sure VCCDSW is stable for at least 10 ms (tPCH02)
delay_ms(10 + 5);
// Assert DSW_PWROK
printf("PCH_DPWROK_EC: %d\n", power);
TRACE("PCH_DPWROK_EC: %d\n", power);
gpio_set(&PCH_DPWROK_EC, power);
// Wait for SLP_SUS# (tPCH32)
delay_ms(95);
for (;;) {
bool value = gpio_get(&SLP_SUS_N);
printf("SLP_SUS_N: %d\n", value);
TRACE("SLP_SUS_N: %d\n", value);
if (value) break;
delay_ms(1);
}
// Enable VCCPRIM_* planes - must be enabled prior to USB power
// in order to avoid leakage
printf("VA_EC_EN: %d\n", power);
TRACE("VA_EC_EN: %d\n", power);
gpio_set(&VA_EC_EN, power);
// Make sure VCCPRIM_* is stable for at least 10 ms (tPCH03)
delay_ms(10 + 5);
// Enable VDD5
printf("DD_ON: %d\n", power);
TRACE("DD_ON: %d\n", power);
gpio_set(&DD_ON, power);
// Assert RSMRST#
printf("EC_RSMRST_N: %d\n", power);
TRACE("EC_RSMRST_N: %d\n", power);
gpio_set(&EC_RSMRST_N, power);
// Allow processor to control SUSB# and SUSC#
printf("EC_EN: %d\n", power);
TRACE("EC_EN: %d\n", power);
gpio_set(&EC_EN, power);
// Assert SUS_ACK#
printf("SUS_PWR_ACK: %d\n", power);
TRACE("SUS_PWR_ACK: %d\n", power);
gpio_set(&SUS_PWR_ACK, power);
// printf("VR_ON: %d\n", power);
// DEBUG("VR_ON: %d\n", power);
// gpio_set(&VR_ON, power);
}
}
@ -291,35 +292,35 @@ void power_button() {
if (!new && last) {
if (power) {
printf("Enabling S0 power\n");
DEBUG("Enabling S0 power\n");
// Wait for ALL_SYS_PWRGD
for (;;) {
bool value = gpio_get(&ALL_SYS_PWRGD);
printf("ALL_SYS_PWRGD: %d\n", value);
TRACE("ALL_SYS_PWRGD: %d\n", value);
if (value) break;
delay_ms(1);
}
// Assert VR_ON
printf("VR_ON: %d\n", power);
TRACE("VR_ON: %d\n", power);
gpio_set(&VR_ON, power);
// Assert PM_PWEROK, PCH_PWROK will be asserted when H_VR_READY is
printf("PM_PWROK: %d\n", power);
TRACE("PM_PWROK: %d\n", power);
gpio_set(&PM_PWROK, power);
// OEM defined delay from ALL_SYS_PWRGD to SYS_PWROK - TODO
delay_ms(10);
// Assert PCH_PWEROK_EC, SYS_PWEROK will be asserted
printf("PCH_PWROK_EC: %d\n", power);
TRACE("PCH_PWROK_EC: %d\n", power);
gpio_set(&PCH_PWROK_EC, power);
// Wait for PLT_RST#
for (;;) {
bool value = gpio_get(&BUF_PLT_RST_N);
printf("BUF_PLT_RST_N: %d\n", value);
TRACE("BUF_PLT_RST_N: %d\n", value);
if (value) break;
delay_ms(1);
}
@ -327,66 +328,61 @@ void power_button() {
// enable pnp devices
pnp_enable();
} else {
printf("Disabling power\n");
DEBUG("Disabling power\n");
// De-assert SUS_ACK#
printf("SUS_PWR_ACK: %d\n", power);
TRACE("SUS_PWR_ACK: %d\n", power);
gpio_set(&SUS_PWR_ACK, power);
// De-assert PCH_PWEROK_EC, SYS_PWEROK will be de-asserted
printf("PCH_PWROK_EC: %d\n", power);
TRACE("PCH_PWROK_EC: %d\n", power);
gpio_set(&PCH_PWROK_EC, power);
// De-assert PM_PWEROK, PCH_PWROK will be de-asserted
printf("PM_PWROK: %d\n", power);
TRACE("PM_PWROK: %d\n", power);
gpio_set(&PM_PWROK, power);
// De-assert VR_ON
printf("VR_ON: %d\n", power);
TRACE("VR_ON: %d\n", power);
gpio_set(&VR_ON, power);
// Block processor from controlling SUSB# and SUSC#
printf("EC_EN: %d\n", power);
TRACE("EC_EN: %d\n", power);
gpio_set(&EC_EN, power);
// De-assert RSMRST#
printf("EC_RSMRST_N: %d\n", power);
TRACE("EC_RSMRST_N: %d\n", power);
gpio_set(&EC_RSMRST_N, power);
// Disable VDD5
printf("DD_ON: %d\n", power);
TRACE("DD_ON: %d\n", power);
gpio_set(&DD_ON, power);
// Wait a minimum of 400 ns (tPCH12)
delay_ms(1);
// Disable VCCPRIM_* planes
printf("VA_EC_EN: %d\n", power);
TRACE("VA_EC_EN: %d\n", power);
gpio_set(&VA_EC_EN, power);
// De-assert DSW_PWROK
printf("PCH_DPWROK_EC: %d\n", power);
TRACE("PCH_DPWROK_EC: %d\n", power);
gpio_set(&PCH_DPWROK_EC, power);
// Wait a minimum of 400 ns (tPCH14)
delay_ms(1);
// Disable battery charger
// battery_charger_disable();
}
printf("LED_PWR: %d\n", power);
TRACE("LED_PWR: %d\n", power);
gpio_set(&LED_PWR, power);
} else if (new && !last) {
printf("Power switch release\n");
DEBUG("Power switch release\n");
printf("SUSWARN_N: %d\n", gpio_get(&SUSWARN_N));
printf("SUSC_N_PCH: %d\n", gpio_get(&SUSC_N_PCH));
printf("SUSB_N_PCH: %d\n", gpio_get(&SUSB_N_PCH));
printf("ALL_SYS_PWRGD: %d\n", gpio_get(&ALL_SYS_PWRGD));
printf("BUF_PLT_RST_N: %d\n", gpio_get(&BUF_PLT_RST_N));
// battery_debug();
TRACE("SUSWARN_N: %d\n", gpio_get(&SUSWARN_N));
TRACE("SUSC_N_PCH: %d\n", gpio_get(&SUSC_N_PCH));
TRACE("SUSB_N_PCH: %d\n", gpio_get(&SUSB_N_PCH));
TRACE("ALL_SYS_PWRGD: %d\n", gpio_get(&ALL_SYS_PWRGD));
TRACE("BUF_PLT_RST_N: %d\n", gpio_get(&BUF_PLT_RST_N));
}
last = new;
@ -403,7 +399,7 @@ void touchpad_event(struct Ps2 * ps2) {
*(ps2->status) = status;
if (status & (1 << 3)) {
uint8_t data = *(ps2->data);
//printf("touchpad: %02X\n", data);
TRACE("touchpad: %02X\n", data);
kbc_mouse(&KBC, data, 1000);
}
}
@ -414,7 +410,7 @@ struct Gpio __code LED_AIRPLANE_N = GPIO(G, 6);
void main(void) {
init();
printf("\n");
INFO("\n");
static struct Gpio __code LED_BAT_CHG = GPIO(A, 5);
static struct Gpio __code LED_BAT_FULL = GPIO(A, 6);
@ -450,13 +446,13 @@ void main(void) {
// Set the battery full LED (to know our firmware is loaded)
gpio_set(&LED_BAT_FULL, true);
printf("Hello from System76 EC for %s!\n", xstr(__BOARD__));
INFO("Hello from System76 EC for %s!\n", xstr(__BOARD__));
for(;;) {
peci_event();
ac_adapter();
power_button();
kbscan_event();
//kbscan_event();
touchpad_event(&PS2_3);
kbc_event(&KBC);
pmc_event(&PMC_1);

48
src/common/include/common/debug.h Normal file
View File

@ -0,0 +1,48 @@
#ifndef _COMMON_DEBUG_H
#define _COMMON_DEBUG_H
#include <stdio.h>
#define LEVEL_TRACE 5
#define LEVEL_DEBUG 4
#define LEVEL_INFO 3
#define LEVEL_WARN 2
#define LEVEL_ERROR 1
#define LEVEL_NONE 0
// This is the user-configurable log level
#ifndef LEVEL
#define LEVEL LEVEL_INFO
#endif
#if LEVEL >= LEVEL_TRACE
#define TRACE(...) printf(__VA_ARGS__)
#else
#define TRACE(...)
#endif
#if LEVEL >= LEVEL_DEBUG
#define DEBUG(...) printf(__VA_ARGS__)
#else
#define DEBUG(...)
#endif
#if LEVEL >= LEVEL_INFO
#define INFO(...) printf(__VA_ARGS__)
#else
#define INFO(...)
#endif
#if LEVEL >= LEVEL_WARN
#define WARN(...) printf(__VA_ARGS__)
#else
#define WARN(...)
#endif
#if LEVEL >= LEVEL_ERROR
#define ERROR(...) printf(__VA_ARGS__)
#else
#define ERROR(...)
#endif
#endif // _COMMON_DEBUG_H

13
src/ec/it8587e/pmc.c
View File

@ -1,6 +1,5 @@
#include <stdio.h>
#include <board/acpi.h>
#include <common/debug.h>
#include <ec/pmc.h>
#define PMC(NUM) { \
@ -52,7 +51,7 @@ void pmc_event(struct Pmc * pmc) {
if (sts & PMC_STS_IBF) {
uint8_t data = pmc_read(pmc);
if (sts & PMC_STS_CMD) {
printf("pmc cmd: %02X\n", data);
DEBUG("pmc cmd: %02X\n", data);
state = PMC_STATE_DEFAULT;
switch (data) {
@ -63,22 +62,22 @@ void pmc_event(struct Pmc * pmc) {
state = PMC_STATE_ACPI_WRITE;
break;
case 0x82:
printf(" burst enable\n");
DEBUG(" burst enable\n");
// TODO: figure out what burst is
pmc_write(pmc, 0x90, PMC_TIMEOUT);
break;
case 0x83:
printf(" burst disable\n");
DEBUG(" burst disable\n");
// TODO: figure out what burst is
break;
case 0x84:
printf(" SCI queue\n");
DEBUG(" SCI queue\n");
// TODO: queue is always empty
pmc_write(pmc, 0, PMC_TIMEOUT);
break;
}
} else {
printf("pmc data: %02X\n", data);
DEBUG("pmc data: %02X\n", data);
switch (state) {
case PMC_STATE_ACPI_READ: