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 <board/acpi.h>
#include <common/debug.h>
uint8_t acpi_read(uint8_t addr) { uint8_t acpi_read(uint8_t addr) {
uint8_t data = 0; uint8_t data = 0;
//TODO DEBUG("acpi_read %02X = %02X\n", addr, data);
printf("acpi_read %02X = %02X\n", addr, data); switch (addr) {
//TODO
}
return data; return data;
} }
void acpi_write(uint8_t addr, uint8_t data) { void acpi_write(uint8_t addr, uint8_t data) {
//TODO DEBUG("acpi_write %02X = %02X\n", addr, data);
printf("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> #include <common/i2c.h>
int smbus_read(uint8_t address, uint8_t command, uint16_t * data) { int smbus_read(uint8_t address, uint8_t command, uint16_t * data) {
@ -46,22 +45,22 @@ void battery_debug(void) {
int res = 0; int res = 0;
#define command(N, A, V) { \ #define command(N, A, V) { \
printf(#N ": "); \ DEBUG(#N ": "); \
res = smbus_read(A, V, &data); \ res = smbus_read(A, V, &data); \
if (res < 0) { \ if (res < 0) { \
printf("ERROR %04X\n", -res); \ DEBUG("ERROR %04X\n", -res); \
} else { \ } else { \
printf("%04X\n", data); \ DEBUG("%04X\n", data); \
} \ } \
} }
printf("Battery:\n"); DEBUG("Battery:\n");
command(Temperature, 0x0B, 0x08); command(Temperature, 0x0B, 0x08);
command(Voltage, 0x0B, 0x09); command(Voltage, 0x0B, 0x09);
command(Current, 0x0B, 0x0A); command(Current, 0x0B, 0x0A);
command(Charge, 0x0B, 0x0D); command(Charge, 0x0B, 0x0D);
printf("Charger:\n"); DEBUG("Charger:\n");
command(ChargeOption0, 0x09, 0x12); command(ChargeOption0, 0x09, 0x12);
command(ChargeOption1, 0x09, 0x3B); command(ChargeOption1, 0x09, 0x3B);
command(ChargeOption2, 0x09, 0x38); command(ChargeOption2, 0x09, 0x38);

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

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

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

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

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

@ -1,9 +1,8 @@
#include <stdio.h>
#include <arch/delay.h> #include <arch/delay.h>
#include <board/kbc.h> #include <board/kbc.h>
#include <board/kbscan.h> #include <board/kbscan.h>
#include <board/keymap.h> #include <board/keymap.h>
#include <common/debug.h>
bool kbscan_enabled = false; bool kbscan_enabled = false;
@ -50,7 +49,7 @@ void kbscan_event(void) {
bool last_b = last & (1 << j); bool last_b = last & (1 << j);
if (new_b != last_b) { if (new_b != last_b) {
uint16_t key = keymap(i, j, kbscan_layer); 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) { if (kbscan_enabled && key) {
kbc_scancode(&KBC, key, new_b); 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 <board/keymap.h>
#include <common/debug.h>
uint16_t __code KEYMAP[KM_OUT][KM_IN][KM_LAY] = { uint16_t __code KEYMAP[KM_OUT][KM_IN][KM_LAY] = {
{ // 0 { // 0
@ -282,7 +281,7 @@ uint16_t keymap_translate(uint16_t key) {
case K_RIGHT: return (K_E0 | 0x4D); case K_RIGHT: return (K_E0 | 0x4D);
default: default:
printf("keymap_translate: unknown %02X\n", key); WARN("keymap_translate: unknown %02X\n", key);
return 0; return 0;
} }
} }

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

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