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

Mark pointers as const

Browse Source 
Resulting binaries are identical.

Signed-off-by: Tim Crawford <tcrawford@system76.com>
This commit is contained in:
Tim Crawford
2024-03-01 07:59:13 -07:00
committed by Jeremy Soller
parent d60a8e4c8e
commit 9fb08ffa46
38 changed files with 213 additions and 147 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/arch/avr/gpio.c
View File

@ -2,7 +2,7 @@
#include <arch/gpio.h> #include <arch/gpio.h>
bool gpio_get_dir(struct Gpio *gpio) { bool gpio_get_dir(struct Gpio *const gpio) {
if (*gpio->ddr & gpio->value) { if (*gpio->ddr & gpio->value) {
return true; return true;
} else { } else {
@ -10,7 +10,7 @@ bool gpio_get_dir(struct Gpio *gpio) {
} }
} }
void gpio_set_dir(struct Gpio *gpio, bool value) { void gpio_set_dir(struct Gpio *const gpio, bool value) {
if (value) { if (value) {
*gpio->ddr |= gpio->value; *gpio->ddr |= gpio->value;
} else { } else {
@ -18,7 +18,7 @@ void gpio_set_dir(struct Gpio *gpio, bool value) {
} }
} }
bool gpio_get(struct Gpio *gpio) { bool gpio_get(struct Gpio *const gpio) {
if (*gpio->pin & gpio->value) { if (*gpio->pin & gpio->value) {
return true; return true;
} else { } else {
@ -26,7 +26,7 @@ bool gpio_get(struct Gpio *gpio) {
} }
} }
void gpio_set(struct Gpio *gpio, bool value) { void gpio_set(struct Gpio *const gpio, bool value) {
if (value) { if (value) {
*gpio->port |= gpio->value; *gpio->port |= gpio->value;
} else { } else {

8
src/arch/avr/i2c.c
View File

@ -10,7 +10,7 @@
#define TIMEOUT (F_CPU / 1000) #define TIMEOUT (F_CPU / 1000)
int16_t i2c_start(struct I2C *i2c, uint8_t addr, bool read) { int16_t i2c_start(struct I2C *const i2c, uint8_t addr, bool read) {
uint32_t count; uint32_t count;
// reset TWI control register // reset TWI control register
@ -47,12 +47,12 @@ int16_t i2c_start(struct I2C *i2c, uint8_t addr, bool read) {
return 0; return 0;
} }
void i2c_stop(struct I2C *i2c) { void i2c_stop(struct I2C *const i2c) {
// transmit STOP condition // transmit STOP condition
TWCR = BIT(TWINT) | BIT(TWEN) | BIT(TWSTO); TWCR = BIT(TWINT) | BIT(TWEN) | BIT(TWSTO);
} }
int16_t i2c_write(struct I2C *i2c, uint8_t *data, uint16_t length) { int16_t i2c_write(struct I2C *const i2c, uint8_t *const data, uint16_t length) {
uint16_t i; uint16_t i;
for (i = 0; i < length; i++) { for (i = 0; i < length; i++) {
// load data into data register // load data into data register
@ -74,7 +74,7 @@ int16_t i2c_write(struct I2C *i2c, uint8_t *data, uint16_t length) {
return i; return i;
} }
int16_t i2c_read(struct I2C *i2c, uint8_t *data, uint16_t length) { int16_t i2c_read(struct I2C *const i2c, uint8_t *const data, uint16_t length) {
uint16_t i; uint16_t i;
for (i = 0; i < length; i++) { for (i = 0; i < length; i++) {
if ((i + 1) < length) { if ((i + 1) < length) {

8
src/arch/avr/include/arch/gpio.h
View File

@ -25,9 +25,9 @@ struct Gpio {
} }
// clang-format on // clang-format on
bool gpio_get(struct Gpio *gpio); bool gpio_get(struct Gpio *const gpio);
void gpio_set(struct Gpio *gpio, bool value); void gpio_set(struct Gpio *const gpio, bool value);
bool gpio_get_dir(struct Gpio *gpio); bool gpio_get_dir(struct Gpio *const gpio);
void gpio_set_dir(struct Gpio *gpio, bool value); void gpio_set_dir(struct Gpio *const gpio, bool value);
#endif // _ARCH_GPIO_H #endif // _ARCH_GPIO_H

10
src/arch/avr/include/arch/uart.h
View File

@ -19,16 +19,16 @@ struct Uart {
uint8_t c_init; uint8_t c_init;
}; };
void uart_init(struct Uart *uart, uint32_t baud); void uart_init(struct Uart *const uart, uint32_t baud);
int16_t uart_count(void); int16_t uart_count(void);
struct Uart *uart_new(int16_t num); struct Uart *uart_new(int16_t num);
uint8_t uart_can_read(struct Uart *uart); uint8_t uart_can_read(struct Uart *const uart);
uint8_t uart_can_write(struct Uart *uart); uint8_t uart_can_write(struct Uart *const uart);
uint8_t uart_read(struct Uart *uart); uint8_t uart_read(struct Uart *const uart);
void uart_write(struct Uart *uart, uint8_t data); void uart_write(struct Uart *const uart, uint8_t data);
extern struct Uart *uart_stdio; extern struct Uart *uart_stdio;
void uart_stdio_init(int16_t num, uint32_t baud); void uart_stdio_init(int16_t num, uint32_t baud);

10
src/arch/avr/uart.c
View File

@ -54,7 +54,7 @@ struct Uart *uart_new(int16_t num) {
} }
} }
void uart_init(struct Uart *uart, uint32_t baud) { void uart_init(struct Uart *const uart, uint32_t baud) {
uint32_t baud_prescale = (F_CPU / (baud * 16UL)) - 1; uint32_t baud_prescale = (F_CPU / (baud * 16UL)) - 1;
*(uart->baud_h) = (uint8_t)(baud_prescale >> 8); *(uart->baud_h) = (uint8_t)(baud_prescale >> 8);
*(uart->baud_l) = (uint8_t)(baud_prescale); *(uart->baud_l) = (uint8_t)(baud_prescale);
@ -63,20 +63,20 @@ void uart_init(struct Uart *uart, uint32_t baud) {
*(uart->c) = uart->c_init; *(uart->c) = uart->c_init;
} }
uint8_t uart_can_read(struct Uart *uart) { uint8_t uart_can_read(struct Uart *const uart) {
return (*(uart->a)) & uart->a_read; return (*(uart->a)) & uart->a_read;
} }
uint8_t uart_read(struct Uart *uart) { uint8_t uart_read(struct Uart *const uart) {
while (!uart_can_read(uart)) {} while (!uart_can_read(uart)) {}
return *(uart->data); return *(uart->data);
} }
uint8_t uart_can_write(struct Uart *uart) { uint8_t uart_can_write(struct Uart *const uart) {
return (*(uart->a)) & uart->a_write; return (*(uart->a)) & uart->a_write;
} }
void uart_write(struct Uart *uart, uint8_t data) { void uart_write(struct Uart *const uart, uint8_t data) {
while (!uart_can_write(uart)) {} while (!uart_can_write(uart)) {}
*(uart->data) = data; *(uart->data) = data;
} }

2
src/board/arduino/mega2560/battery.c
View File

@ -4,7 +4,7 @@
#include <common/i2c.h> #include <common/i2c.h>
int16_t smbus_read(uint8_t address, uint8_t command, uint16_t *data) { int16_t smbus_read(uint8_t address, uint8_t command, uint16_t *const data) {
return i2c_get(NULL, address, command, (uint8_t *)data, 2); return i2c_get(NULL, address, command, (uint8_t *)data, 2);
} }

47
src/board/arduino/mega2560/parallel.c
View File

@ -117,7 +117,7 @@ static struct Parallel PORT = {
// clang-format on // clang-format on
// Set port to all high-impedance inputs // Set port to all high-impedance inputs
void parallel_hiz(struct Parallel *port) { void parallel_hiz(struct Parallel *const port) {
#define PIN(N, P) \ #define PIN(N, P) \
gpio_set_dir(port->N, false); \ gpio_set_dir(port->N, false); \
gpio_set(port->N, false); gpio_set(port->N, false);
@ -126,7 +126,7 @@ void parallel_hiz(struct Parallel *port) {
} }
// Place all data lines in high or low impendance state // Place all data lines in high or low impendance state
void parallel_data_dir(struct Parallel *port, bool dir) { void parallel_data_dir(struct Parallel *const port, bool dir) {
#define DATA_BIT(B) gpio_set_dir(port->d##B, dir); #define DATA_BIT(B) gpio_set_dir(port->d##B, dir);
DATA_BITS DATA_BITS
#undef DATA_BIT #undef DATA_BIT
@ -134,7 +134,7 @@ void parallel_data_dir(struct Parallel *port, bool dir) {
#define parallel_data_forward(P) parallel_data_dir(P, true) #define parallel_data_forward(P) parallel_data_dir(P, true)
#define parallel_data_reverse(P) parallel_data_dir(P, false) #define parallel_data_reverse(P) parallel_data_dir(P, false)
void parallel_data_set_high(struct Parallel *port, uint8_t byte) { void parallel_data_set_high(struct Parallel *const port, uint8_t byte) {
// By convention all lines are high, so only set the ones needed // By convention all lines are high, so only set the ones needed
#define DATA_BIT(B) \ #define DATA_BIT(B) \
if (!(byte & (1 << B))) \ if (!(byte & (1 << B))) \
@ -144,7 +144,7 @@ void parallel_data_set_high(struct Parallel *port, uint8_t byte) {
} }
// Set port to initial state required before being able to perform cycles // Set port to initial state required before being able to perform cycles
void parallel_reset(struct Parallel *port, bool host) { void parallel_reset(struct Parallel *const port, bool host) {
parallel_hiz(port); parallel_hiz(port);
// nRESET: output on host, input on peripherals // nRESET: output on host, input on peripherals
@ -183,7 +183,7 @@ void parallel_reset(struct Parallel *port, bool host) {
} }
} }
void parallel_state(struct Parallel *port, enum ParallelState state) { void parallel_state(struct Parallel *const port, enum ParallelState state) {
if (port->state != state) { if (port->state != state) {
switch (state) { switch (state) {
case PARALLEL_STATE_UNKNOWN: case PARALLEL_STATE_UNKNOWN:
@ -202,7 +202,7 @@ void parallel_state(struct Parallel *port, enum ParallelState state) {
} }
} }
uint8_t parallel_read_data(struct Parallel *port) { uint8_t parallel_read_data(struct Parallel *const port) {
uint8_t byte = 0; uint8_t byte = 0;
#define DATA_BIT(B) \ #define DATA_BIT(B) \
if (gpio_get(port->d##B)) \ if (gpio_get(port->d##B)) \
@ -212,7 +212,7 @@ uint8_t parallel_read_data(struct Parallel *port) {
return byte; return byte;
} }
void parallel_write_data(struct Parallel *port, uint8_t byte) { void parallel_write_data(struct Parallel *const port, uint8_t byte) {
// By convention all lines are high, so only set the ones needed // By convention all lines are high, so only set the ones needed
#define DATA_BIT(B) \ #define DATA_BIT(B) \
@ -224,8 +224,8 @@ void parallel_write_data(struct Parallel *port, uint8_t byte) {
//TODO: timeout //TODO: timeout
int16_t parallel_transaction( int16_t parallel_transaction(
struct Parallel *port, struct Parallel *const port,
uint8_t *data, uint8_t *const data,
int16_t length, int16_t length,
bool read, bool read,
bool addr bool addr
@ -299,7 +299,12 @@ int16_t parallel_transaction(
// host write -> peripheral read // host write -> peripheral read
// host read -> peripheral write // host read -> peripheral write
bool parallel_peripheral_cycle(struct Parallel *port, uint8_t *data, bool *read, bool *addr) { bool parallel_peripheral_cycle(
struct Parallel *const port,
uint8_t *const data,
bool *const read,
bool *const addr
) {
if (!gpio_get(port->reset_n)) { if (!gpio_get(port->reset_n)) {
// XXX: Give host some time to get ready // XXX: Give host some time to get ready
_delay_ms(1); _delay_ms(1);
@ -351,7 +356,12 @@ static uint8_t ZERO = 0x00;
static uint8_t SPI_ENABLE = 0xFE; static uint8_t SPI_ENABLE = 0xFE;
static uint8_t SPI_DATA = 0xFD; static uint8_t SPI_DATA = 0xFD;
int16_t parallel_ecms_read(struct Parallel *port, uint16_t addr, uint8_t *data, int16_t length) { int16_t parallel_ecms_read(
struct Parallel *const port,
uint16_t addr,
uint8_t *const data,
int16_t length
) {
int16_t res; int16_t res;
res = parallel_set_address(port, &ADDRESS_ECMSADDR1, 1); res = parallel_set_address(port, &ADDRESS_ECMSADDR1, 1);
@ -378,7 +388,7 @@ int16_t parallel_ecms_read(struct Parallel *port, uint16_t addr, uint8_t *data,
} }
// Disable chip // Disable chip
int16_t parallel_spi_reset(struct Parallel *port) { int16_t parallel_spi_reset(struct Parallel *const port) {
int16_t res; int16_t res;
res = parallel_set_address(port, &ADDRESS_INDAR1, 1); res = parallel_set_address(port, &ADDRESS_INDAR1, 1);
@ -397,7 +407,12 @@ int16_t parallel_spi_reset(struct Parallel *port) {
} }
// Enable chip and read or write data // Enable chip and read or write data
int16_t parallel_spi_transaction(struct Parallel *port, uint8_t *data, int16_t length, bool read) { int16_t parallel_spi_transaction(
struct Parallel *const port,
uint8_t *const data,
int16_t length,
bool read
) {
int16_t res; int16_t res;
res = parallel_set_address(port, &ADDRESS_INDAR1, 1); res = parallel_set_address(port, &ADDRESS_INDAR1, 1);
@ -420,8 +435,8 @@ int16_t parallel_spi_transaction(struct Parallel *port, uint8_t *data, int16_t l
// "Hardware" accelerated SPI programming, requires ECINDARs to be set // "Hardware" accelerated SPI programming, requires ECINDARs to be set
int16_t parallel_spi_program( int16_t parallel_spi_program(
struct Parallel *port, struct Parallel *const port,
uint8_t *data, uint8_t *const data,
int16_t length, int16_t length,
bool initialized bool initialized
) { ) {
@ -483,7 +498,7 @@ int16_t parallel_spi_program(
return i; return i;
} }
int16_t serial_transaction(uint8_t *data, int16_t length, bool read) { int16_t serial_transaction(uint8_t *const data, int16_t length, bool read) {
int16_t i; int16_t i;
for (i = 0; i < length; i++) { for (i = 0; i < length; i++) {
if (read) { if (read) {

38
src/board/arduino/uno/parallel.c
View File

@ -85,7 +85,7 @@ static struct Parallel PORT = {
}; };
// Set port to all high-impedance inputs // Set port to all high-impedance inputs
void parallel_hiz(struct Parallel *port) { void parallel_hiz(struct Parallel *const port) {
#define PIN(N, P) \ #define PIN(N, P) \
gpio_set_dir(port->N, false); \ gpio_set_dir(port->N, false); \
gpio_set(port->N, false); gpio_set(port->N, false);
@ -94,7 +94,7 @@ void parallel_hiz(struct Parallel *port) {
} }
// Place all data lines in high or low impendance state // Place all data lines in high or low impendance state
void parallel_data_dir(struct Parallel *port, bool dir) { void parallel_data_dir(struct Parallel *const port, bool dir) {
#define DATA_BIT(B) gpio_set_dir(port->d##B, dir); #define DATA_BIT(B) gpio_set_dir(port->d##B, dir);
DATA_BITS DATA_BITS
#undef DATA_BIT #undef DATA_BIT
@ -102,7 +102,7 @@ void parallel_data_dir(struct Parallel *port, bool dir) {
#define parallel_data_forward(P) parallel_data_dir(P, true) #define parallel_data_forward(P) parallel_data_dir(P, true)
#define parallel_data_reverse(P) parallel_data_dir(P, false) #define parallel_data_reverse(P) parallel_data_dir(P, false)
void parallel_data_set_high(struct Parallel *port, uint8_t byte) { void parallel_data_set_high(struct Parallel *const port, uint8_t byte) {
// By convention all lines are high, so only set the ones needed // By convention all lines are high, so only set the ones needed
#define DATA_BIT(B) \ #define DATA_BIT(B) \
if (!(byte & (1 << B))) \ if (!(byte & (1 << B))) \
@ -112,7 +112,7 @@ void parallel_data_set_high(struct Parallel *port, uint8_t byte) {
} }
// Set port to initial state required before being able to perform cycles // Set port to initial state required before being able to perform cycles
void parallel_reset(struct Parallel *port, bool host) { void parallel_reset(struct Parallel *const port, bool host) {
parallel_hiz(port); parallel_hiz(port);
// nRESET: output on host, input on peripherals // nRESET: output on host, input on peripherals
@ -151,7 +151,7 @@ void parallel_reset(struct Parallel *port, bool host) {
} }
} }
uint8_t parallel_read_data(struct Parallel *port) { uint8_t parallel_read_data(struct Parallel *const port) {
uint8_t byte = 0; uint8_t byte = 0;
#define DATA_BIT(B) \ #define DATA_BIT(B) \
if (gpio_get(port->d##B)) \ if (gpio_get(port->d##B)) \
@ -161,7 +161,7 @@ uint8_t parallel_read_data(struct Parallel *port) {
return byte; return byte;
} }
void parallel_write_data(struct Parallel *port, uint8_t byte) { void parallel_write_data(struct Parallel *const port, uint8_t byte) {
// By convention all lines are high, so only set the ones needed // By convention all lines are high, so only set the ones needed
#define DATA_BIT(B) \ #define DATA_BIT(B) \
if (!(byte & (1 << B))) \ if (!(byte & (1 << B))) \
@ -172,8 +172,8 @@ void parallel_write_data(struct Parallel *port, uint8_t byte) {
//TODO: timeout //TODO: timeout
int16_t parallel_transaction( int16_t parallel_transaction(
struct Parallel *port, struct Parallel *const port,
uint8_t *data, uint8_t *const data,
int16_t length, int16_t length,
bool read, bool read,
bool addr bool addr
@ -248,7 +248,12 @@ int16_t parallel_transaction(
// host write -> peripheral read // host write -> peripheral read
// host read -> peripheral write // host read -> peripheral write
bool parallel_peripheral_cycle(struct Parallel *port, uint8_t *data, bool *read, bool *addr) { bool parallel_peripheral_cycle(
struct Parallel *const port,
uint8_t *const data,
bool *const read,
bool *const addr
) {
if (!gpio_get(port->reset_n)) { if (!gpio_get(port->reset_n)) {
// XXX: Give host some time to get ready // XXX: Give host some time to get ready
_delay_ms(1); _delay_ms(1);
@ -293,7 +298,7 @@ static uint8_t SPI_ENABLE = 0xFE;
static uint8_t SPI_DATA = 0xFD; static uint8_t SPI_DATA = 0xFD;
// Disable chip // Disable chip
int16_t parallel_spi_reset(struct Parallel *port) { int16_t parallel_spi_reset(struct Parallel *const port) {
int16_t res; int16_t res;
res = parallel_set_address(port, &ADDRESS_INDAR1, 1); res = parallel_set_address(port, &ADDRESS_INDAR1, 1);
@ -312,7 +317,12 @@ int16_t parallel_spi_reset(struct Parallel *port) {
} }
// Enable chip and read or write data // Enable chip and read or write data
int16_t parallel_spi_transaction(struct Parallel *port, uint8_t *data, int16_t length, bool read) { int16_t parallel_spi_transaction(
struct Parallel *const port,
uint8_t *const data,
int16_t length,
bool read
) {
int16_t res; int16_t res;
res = parallel_set_address(port, &ADDRESS_INDAR1, 1); res = parallel_set_address(port, &ADDRESS_INDAR1, 1);
@ -335,8 +345,8 @@ int16_t parallel_spi_transaction(struct Parallel *port, uint8_t *data, int16_t l
// "Hardware" accelerated SPI programming, requires ECINDARs to be set // "Hardware" accelerated SPI programming, requires ECINDARs to be set
int16_t parallel_spi_program( int16_t parallel_spi_program(
struct Parallel *port, struct Parallel *const port,
uint8_t *data, uint8_t *const data,
int16_t length, int16_t length,
bool initialized bool initialized
) { ) {
@ -398,7 +408,7 @@ int16_t parallel_spi_program(
return i; return i;
} }
int16_t serial_transaction(uint8_t *data, int16_t length, bool read) { int16_t serial_transaction(uint8_t *const data, int16_t length, bool read) {
int16_t i; int16_t i;
for (i = 0; i < length; i++) { for (i = 0; i < length; i++) {
if (read) { if (read) {

6
src/board/system76/common/fan.c
View File

@ -25,7 +25,7 @@ void fan_reset(void) {
// Get duty cycle based on temperature, adapted from // Get duty cycle based on temperature, adapted from
// https://github.com/pop-os/system76-power/blob/master/src/fan.rs // https://github.com/pop-os/system76-power/blob/master/src/fan.rs
uint8_t fan_duty(const struct Fan *fan, int16_t temp) __reentrant { uint8_t fan_duty(const struct Fan *const fan, int16_t temp) __reentrant {
for (uint8_t i = 0; i < fan->points_size; i++) { for (uint8_t i = 0; i < fan->points_size; i++) {
const struct FanPoint *cur = &fan->points[i]; const struct FanPoint *cur = &fan->points[i];
@ -85,7 +85,7 @@ void fan_duty_set(uint8_t peci_fan_duty, uint8_t dgpu_fan_duty) __reentrant {
} }
} }
uint8_t fan_heatup(const struct Fan *fan, uint8_t duty) __reentrant { uint8_t fan_heatup(const struct Fan *const fan, uint8_t duty) __reentrant {
uint8_t lowest = duty; uint8_t lowest = duty;
uint8_t i; uint8_t i;
@ -101,7 +101,7 @@ uint8_t fan_heatup(const struct Fan *fan, uint8_t duty) __reentrant {
return lowest; return lowest;
} }
uint8_t fan_cooldown(const struct Fan *fan, uint8_t duty) __reentrant { uint8_t fan_cooldown(const struct Fan *const fan, uint8_t duty) __reentrant {
uint8_t highest = duty; uint8_t highest = duty;
uint8_t i; uint8_t i;

6
src/board/system76/common/flash/wrapper.c
View File

@ -15,7 +15,7 @@ uint8_t __code __at(FLASH_OFFSET) flash_rom[] = {
#include <flash.h> #include <flash.h>
}; };
static void flash_api(uint32_t addr, uint8_t *data, uint32_t length, uint8_t command) { static void flash_api(uint32_t addr, uint8_t *const data, uint32_t length, uint8_t command) {
// Use DMA mapping to copy flash ROM to scratch ROM // Use DMA mapping to copy flash ROM to scratch ROM
SCARH = 0x80; SCARH = 0x80;
SCARL = (uint8_t)(FLASH_OFFSET); SCARL = (uint8_t)(FLASH_OFFSET);
@ -29,7 +29,7 @@ static void flash_api(uint32_t addr, uint8_t *data, uint32_t length, uint8_t com
SCARH = 0x07; SCARH = 0x07;
} }
void flash_read(uint32_t addr, __xdata uint8_t *data, uint32_t length) { void flash_read(uint32_t addr, __xdata uint8_t *const data, uint32_t length) {
flash_api(addr, data, length, FLASH_COMMAND_READ); flash_api(addr, data, length, FLASH_COMMAND_READ);
} }
@ -57,7 +57,7 @@ uint8_t flash_read_u8(uint32_t addr) {
return data; return data;
} }
void flash_write(uint32_t addr, __xdata uint8_t *data, uint32_t length) { void flash_write(uint32_t addr, __xdata uint8_t *const data, uint32_t length) {
flash_api(addr, data, length, FLASH_COMMAND_WRITE); flash_api(addr, data, length, FLASH_COMMAND_WRITE);
} }

6
src/board/system76/common/include/board/fan.h
View File

@ -50,10 +50,10 @@ extern bool fan_max;
void fan_reset(void); void fan_reset(void);
uint8_t fan_duty(const struct Fan *fan, int16_t temp) __reentrant; uint8_t fan_duty(const struct Fan *const fan, int16_t temp) __reentrant;
void fan_duty_set(uint8_t peci_fan_duty, uint8_t dgpu_fan_duty) __reentrant; void fan_duty_set(uint8_t peci_fan_duty, uint8_t dgpu_fan_duty) __reentrant;
uint8_t fan_heatup(const struct Fan *fan, uint8_t duty) __reentrant; uint8_t fan_heatup(const struct Fan *const fan, uint8_t duty) __reentrant;
uint8_t fan_cooldown(const struct Fan *fan, uint8_t duty) __reentrant; uint8_t fan_cooldown(const struct Fan *const fan, uint8_t duty) __reentrant;
uint8_t fan_smooth(uint8_t last_duty, uint8_t duty) __reentrant; uint8_t fan_smooth(uint8_t last_duty, uint8_t duty) __reentrant;
#endif // _BOARD_FAN_H #endif // _BOARD_FAN_H

4
src/board/system76/common/include/board/flash.h
View File

@ -26,7 +26,7 @@
* \param[out] data The memory area to copy to. * \param[out] data The memory area to copy to.
* \param[in] length The number of bytes to copy. * \param[in] length The number of bytes to copy.
*/ */
void flash_read(uint32_t addr, __xdata uint8_t *data, uint32_t length); void flash_read(uint32_t addr, __xdata uint8_t *const data, uint32_t length);
/** /**
* Read a single byte from flash. * Read a single byte from flash.
@ -62,7 +62,7 @@ uint32_t flash_read_u32(uint32_t addr);
* \param[in] data The memory area to copy from. * \param[in] data The memory area to copy from.
* \param[in] length The number of bytes to copy. * \param[in] length The number of bytes to copy.
*/ */
void flash_write(uint32_t addr, __xdata uint8_t *data, uint32_t length); void flash_write(uint32_t addr, __xdata uint8_t *const data, uint32_t length);
/** /**
* Write a single byte to flash. * Write a single byte to flash.

2
src/board/system76/common/include/board/kbc.h
View File

@ -12,6 +12,6 @@ extern uint8_t kbc_leds;
void kbc_init(void); void kbc_init(void);
void kbc_reset(void); void kbc_reset(void);
bool kbc_scancode(uint16_t key, bool pressed); bool kbc_scancode(uint16_t key, bool pressed);
void kbc_event(struct Kbc *kbc); void kbc_event(struct Kbc *const kbc);
#endif // _BOARD_KBC_H #endif // _BOARD_KBC_H

2
src/board/system76/common/include/board/parallel.h
View File

@ -8,6 +8,6 @@
extern bool parallel_debug; extern bool parallel_debug;
bool parallel_init(void); bool parallel_init(void);
int16_t parallel_write(uint8_t *data, uint16_t length); int16_t parallel_write(uint8_t *const data, uint16_t length);
#endif // _BOARD_PARALLEL_H #endif // _BOARD_PARALLEL_H

4
src/board/system76/common/include/board/pmc.h
View File

@ -6,8 +6,8 @@
#include <ec/pmc.h> #include <ec/pmc.h>
void pmc_init(void); void pmc_init(void);
bool pmc_sci(struct Pmc *pmc, uint8_t sci); bool pmc_sci(struct Pmc *const pmc, uint8_t sci);
void pmc_swi(void); void pmc_swi(void);
void pmc_event(struct Pmc *pmc); void pmc_event(struct Pmc *const pmc);
#endif // _BOARD_PMC_H #endif // _BOARD_PMC_H

2
src/board/system76/common/include/board/smbus.h
View File

@ -6,7 +6,7 @@
#include <ec/smbus.h> #include <ec/smbus.h>
void smbus_init(void); void smbus_init(void);
int16_t smbus_read(uint8_t address, uint8_t command, uint16_t *data); int16_t smbus_read(uint8_t address, uint8_t command, uint16_t *const data);
int16_t smbus_write(uint8_t address, uint8_t command, uint16_t data); int16_t smbus_write(uint8_t address, uint8_t command, uint16_t data);
#endif // _BOARD_SMBUS_H #endif // _BOARD_SMBUS_H

14
src/board/system76/common/kbc.c
View File

@ -83,7 +83,7 @@ static uint8_t kbc_buffer[16] = { 0 };
static uint8_t kbc_buffer_head = 0; static uint8_t kbc_buffer_head = 0;
static uint8_t kbc_buffer_tail = 0; static uint8_t kbc_buffer_tail = 0;
static bool kbc_buffer_pop(uint8_t *scancode) { static bool kbc_buffer_pop(uint8_t *const scancode) {
if (kbc_buffer_head == kbc_buffer_tail) { if (kbc_buffer_head == kbc_buffer_tail) {
return false; return false;
} }
@ -92,7 +92,7 @@ static bool kbc_buffer_pop(uint8_t *scancode) {
return true; return true;
} }
static bool kbc_buffer_push(uint8_t *scancodes, uint8_t len) { static bool kbc_buffer_push(uint8_t *const scancodes, uint8_t len) {
//TODO: make this test more efficient //TODO: make this test more efficient
for (uint8_t i = 0; i < len; i++) { for (uint8_t i = 0; i < len; i++) {
if ((kbc_buffer_tail + i + 1U) % ARRAY_SIZE(kbc_buffer) == kbc_buffer_head) { if ((kbc_buffer_tail + i + 1U) % ARRAY_SIZE(kbc_buffer) == kbc_buffer_head) {
@ -165,13 +165,13 @@ static uint8_t state_data = 0;
static enum KbcState state_next = KBC_STATE_NORMAL; static enum KbcState state_next = KBC_STATE_NORMAL;
// Clear output buffer // Clear output buffer
static void kbc_clear_output(struct Kbc *kbc) { static void kbc_clear_output(struct Kbc *const kbc) {
*(kbc->control) |= BIT(5); *(kbc->control) |= BIT(5);
*(kbc->control) |= BIT(6); *(kbc->control) |= BIT(6);
*(kbc->control) &= ~BIT(5); *(kbc->control) &= ~BIT(5);
} }
static void kbc_on_input_command(struct Kbc *kbc, uint8_t data) { static void kbc_on_input_command(struct Kbc *const kbc, uint8_t data) {
TRACE("kbc cmd: %02X\n", data); TRACE("kbc cmd: %02X\n", data);
// Controller commands always reset the state // Controller commands always reset the state
state = KBC_STATE_NORMAL; state = KBC_STATE_NORMAL;
@ -254,7 +254,7 @@ static void kbc_on_input_command(struct Kbc *kbc, uint8_t data) {
} }
} }
static void kbc_on_input_data(struct Kbc *kbc, uint8_t data) { static void kbc_on_input_data(struct Kbc *const kbc, uint8_t data) {
TRACE("kbc data: %02X\n", data); TRACE("kbc data: %02X\n", data);
switch (state) { switch (state) {
case KBC_STATE_TOUCHPAD: case KBC_STATE_TOUCHPAD:
@ -415,7 +415,7 @@ static void kbc_on_input_data(struct Kbc *kbc, uint8_t data) {
} }
} }
static void kbc_on_output_empty(struct Kbc *kbc) { static void kbc_on_output_empty(struct Kbc *const kbc) {
switch (state) { switch (state) {
case KBC_STATE_KEYBOARD: case KBC_STATE_KEYBOARD:
TRACE("kbc keyboard: %02X\n", state_data); TRACE("kbc keyboard: %02X\n", state_data);
@ -454,7 +454,7 @@ static void kbc_on_output_empty(struct Kbc *kbc) {
} }
} }
void kbc_event(struct Kbc *kbc) { void kbc_event(struct Kbc *const kbc) {
uint8_t sts; uint8_t sts;
// Read from scancode buffer when possible // Read from scancode buffer when possible

6
src/board/system76/common/kbscan.c
View File

@ -86,7 +86,7 @@ static inline uint8_t kbscan_get_row(void) {
} }
#if KM_NKEY #if KM_NKEY
static bool kbscan_row_has_ghost(uint8_t *matrix, uint8_t col) { static bool kbscan_row_has_ghost(uint8_t *const matrix, uint8_t col) {
(void)matrix; (void)matrix;
(void)col; (void)col;
return false; return false;
@ -96,7 +96,7 @@ static inline bool popcount_more_than_one(uint8_t rowdata) {
return rowdata & (rowdata - 1); return rowdata & (rowdata - 1);
} }
static bool kbscan_row_has_ghost(uint8_t *matrix, uint8_t col) { static bool kbscan_row_has_ghost(uint8_t *const matrix, uint8_t col) {
uint8_t rowdata = matrix[col]; uint8_t rowdata = matrix[col];
// No ghosts exist when less than 2 keys in the row are active. // No ghosts exist when less than 2 keys in the row are active.
@ -155,7 +155,7 @@ static void hardware_hotkey(uint16_t key) {
} }
} }
bool kbscan_press(uint16_t key, bool pressed, uint8_t *layer) { bool kbscan_press(uint16_t key, bool pressed, uint8_t *const layer) {
// Wake from sleep on keypress // Wake from sleep on keypress
if (pressed && (power_state == POWER_STATE_S3)) { if (pressed && (power_state == POWER_STATE_S3)) {
pmc_swi(); pmc_swi();

2
src/board/system76/common/keymap.c
View File

@ -69,7 +69,7 @@ bool keymap_save_config(void) {
return flash_read_u16(CONFIG_ADDR) == CONFIG_SIGNATURE; return flash_read_u16(CONFIG_ADDR) == CONFIG_SIGNATURE;
} }
bool keymap_get(uint8_t layer, uint8_t output, uint8_t input, uint16_t *value) { bool keymap_get(uint8_t layer, uint8_t output, uint8_t input, uint16_t *const value) {
if (layer < KM_LAY && output < KM_OUT && input < KM_IN) { if (layer < KM_LAY && output < KM_OUT && input < KM_IN) {
if (keymap_fnlock && keymap_is_f_key(output, input)) if (keymap_fnlock && keymap_is_f_key(output, input))
layer ^= 1; layer ^= 1;

2
src/board/system76/common/parallel.c
View File

@ -84,7 +84,7 @@ bool parallel_init(void) {
return parallel_wait_peripheral(STS_WAIT, 0); return parallel_wait_peripheral(STS_WAIT, 0);
} }
int16_t parallel_write(uint8_t *data, uint16_t length) { int16_t parallel_write(uint8_t *const data, uint16_t length) {
// Assert nWRITE // Assert nWRITE
KSIGDAT &= ~CTL_WRITE; KSIGDAT &= ~CTL_WRITE;

4
src/board/system76/common/peci.c
View File

@ -96,7 +96,7 @@ bool peci_available(void) {
void peci_init(void) {} void peci_init(void) {}
// Returns true on success, false on error // Returns true on success, false on error
bool peci_get_temp(int16_t *data) { bool peci_get_temp(int16_t *const data) {
//TODO: Wait for completion? //TODO: Wait for completion?
// Clear upstream status // Clear upstream status
ESUCTRL0 = ESUCTRL0; ESUCTRL0 = ESUCTRL0;
@ -289,7 +289,7 @@ void peci_init(void) {
} }
// Returns true on success, false on error // Returns true on success, false on error
bool peci_get_temp(int16_t *data) { bool peci_get_temp(int16_t *const data) {
// Wait for any in-progress transaction to complete // Wait for any in-progress transaction to complete
uint32_t start = time_get(); uint32_t start = time_get();
while (HOSTAR & BIT(0)) { while (HOSTAR & BIT(0)) {

8
src/board/system76/common/pmc.c
View File

@ -54,7 +54,7 @@ static void pmc_sci_interrupt(void) {
#endif // CONFIG_BUS_ESPI #endif // CONFIG_BUS_ESPI
} }
bool pmc_sci(struct Pmc *pmc, uint8_t sci) { bool pmc_sci(struct Pmc *const pmc, uint8_t sci) {
// Set SCI pending bit // Set SCI pending bit
pmc_set_status(pmc, pmc_status(pmc) | BIT(5)); pmc_set_status(pmc, pmc_status(pmc) | BIT(5));
@ -101,7 +101,7 @@ void pmc_swi(void) {
static enum PmcState state = PMC_STATE_DEFAULT; static enum PmcState state = PMC_STATE_DEFAULT;
static uint8_t state_data = 0; static uint8_t state_data = 0;
static void pmc_on_input_command(struct Pmc *pmc, uint8_t data) { static void pmc_on_input_command(struct Pmc *const pmc, uint8_t data) {
TRACE("pmc cmd: %02X\n", data); TRACE("pmc cmd: %02X\n", data);
state = PMC_STATE_DEFAULT; state = PMC_STATE_DEFAULT;
switch (data) { switch (data) {
@ -169,7 +169,7 @@ static void pmc_on_input_data(uint8_t data) {
} }
} }
static void pmc_on_output_empty(struct Pmc *pmc) { static void pmc_on_output_empty(struct Pmc *const pmc) {
switch (state) { switch (state) {
case PMC_STATE_WRITE: case PMC_STATE_WRITE:
TRACE("pmc write: %02X\n", state_data); TRACE("pmc write: %02X\n", state_data);
@ -181,7 +181,7 @@ static void pmc_on_output_empty(struct Pmc *pmc) {
} }
} }
void pmc_event(struct Pmc *pmc) { void pmc_event(struct Pmc *const pmc) {
uint8_t sts; uint8_t sts;
// Read command/data if available // Read command/data if available

6
src/board/system76/common/smbus.c
View File

@ -22,10 +22,10 @@ void smbus_init(void) {
i2c_reset(&I2C_SMBUS, true); i2c_reset(&I2C_SMBUS, true);
} }
int16_t smbus_read(uint8_t address, uint8_t command, uint16_t *data) { int16_t smbus_read(uint8_t address, uint8_t command, uint16_t *const data) {
return i2c_get(&I2C_SMBUS, address, command, (uint8_t *)data, 2); return i2c_get(&I2C_SMBUS, address, command, (uint8_t *const)data, 2);
} }
int16_t smbus_write(uint8_t address, uint8_t command, uint16_t data) { int16_t smbus_write(uint8_t address, uint8_t command, uint16_t data) {
return i2c_set(&I2C_SMBUS, address, command, (uint8_t *)&data, 2); return i2c_set(&I2C_SMBUS, address, command, (uint8_t *const)&data, 2);
} }

26
src/common/i2c.c
View File

@ -2,7 +2,9 @@
#include <common/i2c.h> #include <common/i2c.h>
int16_t i2c_recv(struct I2C *i2c, uint8_t addr, uint8_t *data, uint16_t length) __reentrant { // clang-format off
int16_t i2c_recv(struct I2C *const i2c, uint8_t addr, uint8_t *const data, uint16_t length) __reentrant {
// clang-format on
int16_t res = 0; int16_t res = 0;
res = i2c_start(i2c, addr, true); res = i2c_start(i2c, addr, true);
@ -18,7 +20,9 @@ int16_t i2c_recv(struct I2C *i2c, uint8_t addr, uint8_t *data, uint16_t length)
return res; return res;
} }
int16_t i2c_send(struct I2C *i2c, uint8_t addr, uint8_t *data, uint16_t length) __reentrant { // clang-format off
int16_t i2c_send(struct I2C *const i2c, uint8_t addr, uint8_t *const data, uint16_t length) __reentrant {
// clang-format on
int16_t res = 0; int16_t res = 0;
res = i2c_start(i2c, addr, false); res = i2c_start(i2c, addr, false);
@ -34,8 +38,13 @@ int16_t i2c_send(struct I2C *i2c, uint8_t addr, uint8_t *data, uint16_t length)
return res; return res;
} }
int16_t i2c_get(struct I2C *i2c, uint8_t addr, uint8_t reg, uint8_t *data, uint16_t length) int16_t i2c_get(
__reentrant { struct I2C *const i2c,
uint8_t addr,
uint8_t reg,
uint8_t *const data,
uint16_t length
) __reentrant {
int16_t res = 0; int16_t res = 0;
res = i2c_start(i2c, addr, false); res = i2c_start(i2c, addr, false);
@ -49,8 +58,13 @@ int16_t i2c_get(struct I2C *i2c, uint8_t addr, uint8_t reg, uint8_t *data, uint1
return i2c_recv(i2c, addr, data, length); return i2c_recv(i2c, addr, data, length);
} }
int16_t i2c_set(struct I2C *i2c, uint8_t addr, uint8_t reg, uint8_t *data, uint16_t length) int16_t i2c_set(
__reentrant { struct I2C *const i2c,
uint8_t addr,
uint8_t reg,
uint8_t *const data,
uint16_t length
) __reentrant {
int16_t res = 0; int16_t res = 0;
res = i2c_start(i2c, addr, false); res = i2c_start(i2c, addr, false);

50
src/common/include/common/i2c.h
View File

@ -16,34 +16,56 @@ struct I2C;
// Start i2c transaction // Start i2c transaction
// Must be defined by arch, board, or ec // Must be defined by arch, board, or ec
int16_t i2c_start(struct I2C *i2c, uint8_t addr, bool read) __reentrant; int16_t i2c_start(struct I2C *const i2c, uint8_t addr, bool read) __reentrant;
// Stop i2c transaction // Stop i2c transaction
// Must be defined by arch, board, or ec // Must be defined by arch, board, or ec
void i2c_stop(struct I2C *i2c) __reentrant; void i2c_stop(struct I2C *const i2c) __reentrant;
// Send a byte on i2c bus // Send a byte on i2c bus
// Must be defined by arch, board, or ec // Must be defined by arch, board, or ec
int16_t i2c_write(struct I2C *i2c, uint8_t *data, uint16_t length) __reentrant; int16_t i2c_write(struct I2C *const i2c, uint8_t *const data, uint16_t length) __reentrant;
// Read bytes from bus // Read bytes from bus
// Must be defined by arch, board, or ec // Must be defined by arch, board, or ec
int16_t i2c_read(struct I2C *i2c, uint8_t *data, uint16_t length) __reentrant; int16_t i2c_read(struct I2C *const i2c, uint8_t *const data, uint16_t length) __reentrant;
// Read multiple bytes from address in one transaction
int16_t i2c_recv(struct I2C *i2c, uint8_t addr, uint8_t *data, uint16_t length) __reentrant;
// Write multiple bytes to address in one transaction
int16_t i2c_send(struct I2C *i2c, uint8_t addr, uint8_t *data, uint16_t length) __reentrant;
// clang-format off // clang-format off
// Read multiple bytes from a register in one transaction // Read multiple bytes from address in one transaction
int16_t i2c_get(struct I2C *i2c, uint8_t addr, uint8_t reg, uint8_t *data, uint16_t length) __reentrant; int16_t i2c_recv(
struct I2C *const i2c,
uint8_t addr,
uint8_t *const data,
uint16_t length
) __reentrant;
// Write multiple bytes to a register in one transaction // Write multiple bytes to address in one transaction
int16_t i2c_set(struct I2C *i2c, uint8_t addr, uint8_t reg, uint8_t *data, uint16_t length) __reentrant; int16_t i2c_send(
struct I2C *const i2c,
uint8_t addr,
uint8_t *const data,
uint16_t length
) __reentrant;
// clang-format on // clang-format on
// Read multiple bytes from a register in one transaction
int16_t i2c_get(
struct I2C *const i2c,
uint8_t addr,
uint8_t reg,
uint8_t *const data,
uint16_t length
) __reentrant;
// Write multiple bytes to a register in one transaction
int16_t i2c_set(
struct I2C *const i2c,
uint8_t addr,
uint8_t reg,
uint8_t *const data,
uint16_t length
) __reentrant;
#endif // _COMMON_I2C_H #endif // _COMMON_I2C_H

2
src/common/include/common/keymap.h
View File

@ -30,7 +30,7 @@ bool keymap_load_config(void);
// Save dynamic keymap to flash // Save dynamic keymap to flash
bool keymap_save_config(void); bool keymap_save_config(void);
// Get a keycode from the dynamic keymap // Get a keycode from the dynamic keymap
bool keymap_get(uint8_t layer, uint8_t output, uint8_t input, uint16_t *value); bool keymap_get(uint8_t layer, uint8_t output, uint8_t input, uint16_t *const value);
// Set a keycode in the dynamic keymap // Set a keycode in the dynamic keymap
bool keymap_set(uint8_t layer, uint8_t output, uint8_t input, uint16_t value); bool keymap_set(uint8_t layer, uint8_t output, uint8_t input, uint16_t value);
#endif #endif

4
src/ec/ite/espi.c
View File

@ -37,7 +37,7 @@ struct VirtualWire __code VW_SUS_PWRDN_ACK = VIRTUAL_WIRE(41, 1);
// Index 47 - AP to EC (platform specific) // Index 47 - AP to EC (platform specific)
struct VirtualWire __code VW_HOST_C10 = VIRTUAL_WIRE(47, 0); struct VirtualWire __code VW_HOST_C10 = VIRTUAL_WIRE(47, 0);
enum VirtualWireState vw_get(struct VirtualWire *vw) __critical { enum VirtualWireState vw_get(struct VirtualWire *const vw) __critical {
uint8_t index = *vw->index; uint8_t index = *vw->index;
if (index & vw->valid_mask) { if (index & vw->valid_mask) {
if (index & vw->data_mask) { if (index & vw->data_mask) {
@ -50,7 +50,7 @@ enum VirtualWireState vw_get(struct VirtualWire *vw) __critical {
} }
} }
void vw_set(struct VirtualWire *vw, enum VirtualWireState state) __critical { void vw_set(struct VirtualWire *const vw, enum VirtualWireState state) __critical {
uint8_t index = *vw->index; uint8_t index = *vw->index;
switch (state) { switch (state) {
case VWS_LOW: case VWS_LOW:

8
src/ec/ite/gpio.c
View File

@ -3,7 +3,7 @@
#include <ec/gpio.h> #include <ec/gpio.h>
#include <common/debug.h> #include <common/debug.h>
bool gpio_get(struct Gpio *gpio) { bool gpio_get(struct Gpio *const gpio) {
if (*(gpio->data) & gpio->value) { if (*(gpio->data) & gpio->value) {
return true; return true;
} else { } else {
@ -11,7 +11,7 @@ bool gpio_get(struct Gpio *gpio) {
} }
} }
void gpio_set(struct Gpio *gpio, bool value) { void gpio_set(struct Gpio *const gpio, bool value) {
if (value) { if (value) {
*(gpio->data) |= gpio->value; *(gpio->data) |= gpio->value;
} else { } else {
@ -21,11 +21,11 @@ void gpio_set(struct Gpio *gpio, bool value) {
#ifdef GPIO_DEBUG #ifdef GPIO_DEBUG
static void gpio_debug_bank( static void gpio_debug_bank(
char *bank, char *const bank,
uint8_t data, uint8_t data,
uint8_t mirror, uint8_t mirror,
uint8_t pot, uint8_t pot,
volatile uint8_t *control volatile uint8_t *const control
) { ) {
for (char i = 0; i < 8; i++) { for (char i = 0; i < 8; i++) {
DEBUG( DEBUG(

17
src/ec/ite/i2c.c
View File

@ -42,7 +42,7 @@ struct I2C __code I2C_4 = {
}; };
#endif #endif
void i2c_reset(struct I2C *i2c, bool kill) { void i2c_reset(struct I2C *const i2c, bool kill) {
if (*(i2c->hosta) & HOSTA_BUSY) { if (*(i2c->hosta) & HOSTA_BUSY) {
// Set kill bit // Set kill bit
if (kill) if (kill)
@ -58,7 +58,7 @@ void i2c_reset(struct I2C *i2c, bool kill) {
*(i2c->hoctl2) = 0; *(i2c->hoctl2) = 0;
} }
int16_t i2c_start(struct I2C *i2c, uint8_t addr, bool read) __reentrant { int16_t i2c_start(struct I2C *const i2c, uint8_t addr, bool read) __reentrant {
// If we are already in a transaction // If we are already in a transaction
if (*(i2c->hosta) & HOSTA_BYTE_DONE) { if (*(i2c->hosta) & HOSTA_BYTE_DONE) {
// If we are switching direction // If we are switching direction
@ -86,7 +86,7 @@ int16_t i2c_start(struct I2C *i2c, uint8_t addr, bool read) __reentrant {
return 0; return 0;
} }
void i2c_stop(struct I2C *i2c) { void i2c_stop(struct I2C *const i2c) {
// Disable i2c compatibility // Disable i2c compatibility
*(i2c->hoctl2) &= ~BIT(1); *(i2c->hoctl2) &= ~BIT(1);
// Clear status // Clear status
@ -95,7 +95,12 @@ void i2c_stop(struct I2C *i2c) {
i2c_reset(i2c, false); i2c_reset(i2c, false);
} }
static int16_t i2c_transaction(struct I2C *i2c, uint8_t *data, uint16_t length, bool read) { static int16_t i2c_transaction(
struct I2C *const i2c,
uint8_t *const data,
uint16_t length,
bool read
) {
uint16_t i; uint16_t i;
for (i = 0; i < length; i++) { for (i = 0; i < length; i++) {
if (read) { if (read) {
@ -154,10 +159,10 @@ static int16_t i2c_transaction(struct I2C *i2c, uint8_t *data, uint16_t length,
return i; return i;
} }
int16_t i2c_read(struct I2C *i2c, uint8_t *data, uint16_t length) __reentrant { int16_t i2c_read(struct I2C *const i2c, uint8_t *const data, uint16_t length) __reentrant {
return i2c_transaction(i2c, data, length, true); return i2c_transaction(i2c, data, length, true);
} }
int16_t i2c_write(struct I2C *i2c, uint8_t *data, uint16_t length) __reentrant { int16_t i2c_write(struct I2C *const i2c, uint8_t *const data, uint16_t length) __reentrant {
return i2c_transaction(i2c, data, length, false); return i2c_transaction(i2c, data, length, false);
} }

4
src/ec/ite/include/ec/espi.h
View File

@ -27,9 +27,9 @@ enum VirtualWireState {
VWS_HIGH = 0x11, VWS_HIGH = 0x11,
}; };
enum VirtualWireState vw_get(struct VirtualWire *vw) __critical; enum VirtualWireState vw_get(struct VirtualWire *const vw) __critical;
void vw_set(struct VirtualWire *vw, enum VirtualWireState state) __critical; void vw_set(struct VirtualWire *const vw, enum VirtualWireState state) __critical;
// Not all wires are defined or implemented // Not all wires are defined or implemented
// Index 2 - AP to EC // Index 2 - AP to EC

4
src/ec/ite/include/ec/gpio.h
View File

@ -32,8 +32,8 @@ struct Gpio {
} }
// clang-format on // clang-format on
bool gpio_get(struct Gpio *gpio); bool gpio_get(struct Gpio *const gpio);
void gpio_set(struct Gpio *gpio, bool value); void gpio_set(struct Gpio *const gpio, bool value);
#ifdef GPIO_DEBUG #ifdef GPIO_DEBUG
void gpio_debug(void); void gpio_debug(void);

2
src/ec/ite/include/ec/i2c.h
View File

@ -11,6 +11,6 @@ extern struct I2C __code I2C_1;
extern struct I2C __code I2C_4; extern struct I2C __code I2C_4;
#endif #endif
void i2c_reset(struct I2C *i2c, bool kill); void i2c_reset(struct I2C *const i2c, bool kill);
#endif // _EC_I2C_H #endif // _EC_I2C_H

8
src/ec/ite/include/ec/kbc.h
View File

@ -29,10 +29,10 @@ extern struct Kbc __code KBC;
#define KBC_STS_IBF BIT(1) #define KBC_STS_IBF BIT(1)
#define KBC_STS_CMD BIT(3) #define KBC_STS_CMD BIT(3)
uint8_t kbc_status(struct Kbc *kbc); uint8_t kbc_status(struct Kbc *const kbc);
uint8_t kbc_read(struct Kbc *kbc); uint8_t kbc_read(struct Kbc *const kbc);
bool kbc_keyboard(struct Kbc *kbc, uint8_t data, uint16_t timeout); bool kbc_keyboard(struct Kbc *const kbc, uint8_t data, uint16_t timeout);
bool kbc_mouse(struct Kbc *kbc, uint8_t data, uint16_t timeout); bool kbc_mouse(struct Kbc *const kbc, uint8_t data, uint16_t timeout);
volatile uint8_t __xdata __at(0x1300) KBHICR; volatile uint8_t __xdata __at(0x1300) KBHICR;
volatile uint8_t __xdata __at(0x1302) KBIRQR; volatile uint8_t __xdata __at(0x1302) KBIRQR;

8
src/ec/ite/include/ec/pmc.h
View File

@ -33,10 +33,10 @@ extern struct Pmc __code PMC_5;
#define PMC_STS_IBF BIT(1) #define PMC_STS_IBF BIT(1)
#define PMC_STS_CMD BIT(3) #define PMC_STS_CMD BIT(3)
uint8_t pmc_status(struct Pmc *pmc); uint8_t pmc_status(struct Pmc *const pmc);
void pmc_set_status(struct Pmc *pmc, uint8_t status); void pmc_set_status(struct Pmc *const pmc, uint8_t status);
uint8_t pmc_read(struct Pmc *pmc); uint8_t pmc_read(struct Pmc *const pmc);
void pmc_write(struct Pmc *pmc, uint8_t data); void pmc_write(struct Pmc *const pmc, uint8_t data);
volatile uint8_t __xdata __at(0x1500) PM1STS; volatile uint8_t __xdata __at(0x1500) PM1STS;
volatile uint8_t __xdata __at(0x1501) PM1DO; volatile uint8_t __xdata __at(0x1501) PM1DO;

2
src/ec/ite/include/ec/ps2.h
View File

@ -22,7 +22,7 @@ extern struct Ps2 __code PS2_1;
extern struct Ps2 __code PS2_2; extern struct Ps2 __code PS2_2;
extern struct Ps2 __code PS2_3; extern struct Ps2 __code PS2_3;
void ps2_reset(struct Ps2 *ps2); void ps2_reset(struct Ps2 *const ps2);
volatile uint8_t __xdata __at(0x1700) PSCTL1; volatile uint8_t __xdata __at(0x1700) PSCTL1;
volatile uint8_t __xdata __at(0x1701) PSCTL2; volatile uint8_t __xdata __at(0x1701) PSCTL2;

10
src/ec/ite/kbc.c
View File

@ -12,15 +12,15 @@ struct Kbc __code KBC = {
.data_in = &KBHIDIR, .data_in = &KBHIDIR,
}; };
uint8_t kbc_status(struct Kbc *kbc) { uint8_t kbc_status(struct Kbc *const kbc) {
return *(kbc->status); return *(kbc->status);
} }
uint8_t kbc_read(struct Kbc *kbc) { uint8_t kbc_read(struct Kbc *const kbc) {
return *(kbc->data_in); return *(kbc->data_in);
} }
static bool kbc_wait(struct Kbc *kbc, uint16_t timeout) { static bool kbc_wait(struct Kbc *const kbc, uint16_t timeout) {
while (*(kbc->status) & KBC_STS_OBF) { while (*(kbc->status) & KBC_STS_OBF) {
if (timeout == 0) if (timeout == 0)
return false; return false;
@ -30,7 +30,7 @@ static bool kbc_wait(struct Kbc *kbc, uint16_t timeout) {
return true; return true;
} }
bool kbc_keyboard(struct Kbc *kbc, uint8_t data, uint16_t timeout) { bool kbc_keyboard(struct Kbc *const kbc, uint8_t data, uint16_t timeout) {
if (!kbc_wait(kbc, timeout)) if (!kbc_wait(kbc, timeout))
return false; return false;
*(kbc->status) &= ~0x20; *(kbc->status) &= ~0x20;
@ -38,7 +38,7 @@ bool kbc_keyboard(struct Kbc *kbc, uint8_t data, uint16_t timeout) {
return true; return true;
} }
bool kbc_mouse(struct Kbc *kbc, uint8_t data, uint16_t timeout) { bool kbc_mouse(struct Kbc *const kbc, uint8_t data, uint16_t timeout) {
if (!kbc_wait(kbc, timeout)) if (!kbc_wait(kbc, timeout))
return false; return false;
*(kbc->status) |= 0x20; *(kbc->status) |= 0x20;

8
src/ec/ite/pmc.c
View File

@ -19,18 +19,18 @@ struct Pmc __code PMC_3 = PMC(3);
struct Pmc __code PMC_4 = PMC(4); struct Pmc __code PMC_4 = PMC(4);
struct Pmc __code PMC_5 = PMC(5); struct Pmc __code PMC_5 = PMC(5);
uint8_t pmc_status(struct Pmc *pmc) { uint8_t pmc_status(struct Pmc *const pmc) {
return *(pmc->status); return *(pmc->status);
} }
void pmc_set_status(struct Pmc *pmc, uint8_t status) { void pmc_set_status(struct Pmc *const pmc, uint8_t status) {
*(pmc->status) = status; *(pmc->status) = status;
} }
uint8_t pmc_read(struct Pmc *pmc) { uint8_t pmc_read(struct Pmc *const pmc) {
return *(pmc->data_in); return *(pmc->data_in);
} }
void pmc_write(struct Pmc *pmc, uint8_t data) { void pmc_write(struct Pmc *const pmc, uint8_t data) {
*(pmc->data_out) = data; *(pmc->data_out) = data;
} }

2
src/ec/ite/ps2.c
View File

@ -15,7 +15,7 @@ struct Ps2 __code PS2_1 = PS2(1);
struct Ps2 __code PS2_2 = PS2(2); struct Ps2 __code PS2_2 = PS2(2);
struct Ps2 __code PS2_3 = PS2(3); struct Ps2 __code PS2_3 = PS2(3);
void ps2_reset(struct Ps2 *ps2) { void ps2_reset(struct Ps2 *const ps2) {
// Reset interface to defaults // Reset interface to defaults
*(ps2->control) = 1; *(ps2->control) = 1;
// Clear status // Clear status