kb01/zmk
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

nitpicks

Browse source
This commit is contained in:
Megamind 2022-02-07 14:29:35 +08:00
parent 528fc96d60
commit 8e6b5f5bd8
3 changed files with 14 additions and 12 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
app/include/zmk/split/serial/common.h
View file

@ -9,12 +9,14 @@
#include <zephyr/types.h> #include <zephyr/types.h>
#include <init.h> #include <init.h>
/* Caller does/should not need to free `data`
* Data will be freed immediately after calling this callback */
typedef int (*rx_complete_t)(const uint8_t *data, size_t length); typedef int (*rx_complete_t)(const uint8_t *data, size_t length);
void split_serial_async_init(rx_complete_t complete_fn); void split_serial_async_init(rx_complete_t complete_fn);
void split_serial_async_send(uint8_t *data, size_t length); void split_serial_async_send(uint8_t *data, size_t length);
uint8_t *alloc_position_state_buffer(k_timeout_t timeout); uint8_t *alloc_split_serial_buffer(k_timeout_t timeout);
void free_position_state_buffer(const uint8_t *data); void free_split_serial_buffer(const uint8_t *data);

18
app/src/split/serial/common.c
View file

@ -37,7 +37,7 @@ static K_SEM_DEFINE(split_serial_tx_sem, 1, 1);
rx_complete_t split_serial_rx_complete_fn = NULL; rx_complete_t split_serial_rx_complete_fn = NULL;
uint8_t *alloc_position_state_buffer(k_timeout_t timeout) { uint8_t *alloc_split_serial_buffer(k_timeout_t timeout) {
uint8_t *block_ptr = NULL; uint8_t *block_ptr = NULL;
if (k_mem_slab_alloc(&split_memory_slab, (void **)&block_ptr, timeout) == 0) { if (k_mem_slab_alloc(&split_memory_slab, (void **)&block_ptr, timeout) == 0) {
memset(block_ptr, 0, SPLIT_DATA_LEN); memset(block_ptr, 0, SPLIT_DATA_LEN);
@ -47,14 +47,14 @@ uint8_t *alloc_position_state_buffer(k_timeout_t timeout) {
return block_ptr; return block_ptr;
} }
void free_position_state_buffer(const uint8_t *data) { void free_split_serial_buffer(const uint8_t *data) {
k_mem_slab_free(&split_memory_slab, (void **)&data); k_mem_slab_free(&split_memory_slab, (void **)&data);
} }
static void enable_rx(const struct device *dev) { static void enable_rx(const struct device *dev) {
int ret; int ret;
uint8_t *buf = NULL; uint8_t *buf = NULL;
while (!(buf = alloc_position_state_buffer(K_MSEC(100)))) { while (!(buf = alloc_split_serial_buffer(K_MSEC(100)))) {
}; };
while (0 != (ret = uart_rx_enable(serial_dev, buf, sizeof(split_data_t), SYS_FOREVER_MS))) { while (0 != (ret = uart_rx_enable(serial_dev, buf, sizeof(split_data_t), SYS_FOREVER_MS))) {
@ -75,12 +75,12 @@ static void uart_callback(const struct device *dev, struct uart_event *evt, void
case UART_RX_BUF_REQUEST: case UART_RX_BUF_REQUEST:
LOG_DBG("UART device:%s rx extra buf req", serial_dev->name); LOG_DBG("UART device:%s rx extra buf req", serial_dev->name);
buf = alloc_position_state_buffer(K_NO_WAIT); buf = alloc_split_serial_buffer(K_NO_WAIT);
if (NULL != buf) { if (NULL != buf) {
int ret = uart_rx_buf_rsp(serial_dev, buf, sizeof(split_data_t)); int ret = uart_rx_buf_rsp(serial_dev, buf, sizeof(split_data_t));
if (0 != ret) { if (0 != ret) {
LOG_WRN("UART device:%s rx extra buf req add failed: %d", serial_dev->name, ret); LOG_WRN("UART device:%s rx extra buf req add failed: %d", serial_dev->name, ret);
free_position_state_buffer(buf); free_split_serial_buffer(buf);
} }
} }
break; break;
@ -94,7 +94,7 @@ static void uart_callback(const struct device *dev, struct uart_event *evt, void
if (split_serial_rx_complete_fn) { if (split_serial_rx_complete_fn) {
split_serial_rx_complete_fn(evt->data.rx_buf.buf, sizeof(split_data_t)); split_serial_rx_complete_fn(evt->data.rx_buf.buf, sizeof(split_data_t));
} }
free_position_state_buffer(evt->data.rx_buf.buf); free_split_serial_buffer(evt->data.rx_buf.buf);
break; break;
case UART_RX_DISABLED: case UART_RX_DISABLED:
@ -104,7 +104,7 @@ static void uart_callback(const struct device *dev, struct uart_event *evt, void
case UART_TX_DONE: case UART_TX_DONE:
LOG_DBG("UART device:%s tx done", serial_dev->name); LOG_DBG("UART device:%s tx done", serial_dev->name);
free_position_state_buffer(evt->data.tx.buf); free_split_serial_buffer(evt->data.tx.buf);
k_sem_give(&split_serial_tx_sem); k_sem_give(&split_serial_tx_sem);
break; break;
@ -140,14 +140,14 @@ void split_serial_async_init(rx_complete_t rx_comp_fn) {
int ret = uart_callback_set(serial_dev, uart_callback, NULL); int ret = uart_callback_set(serial_dev, uart_callback, NULL);
if (ret == -ENOTSUP || ret == -ENOSYS) { if (ret == -ENOTSUP || ret == -ENOSYS) {
LOG_WRN("UART device:%s ASYNC not supported", serial_dev->name); LOG_ERR("UART device:%s ASYNC not supported", serial_dev->name);
return; return;
} }
split_serial_rx_complete_fn = rx_comp_fn; split_serial_rx_complete_fn = rx_comp_fn;
uart_ready = 1; uart_ready = 1;
LOG_ERR("UART device:%s ready", serial_dev->name); LOG_INF("UART device:%s ready", serial_dev->name);
enable_rx(serial_dev); enable_rx(serial_dev);
} }

2
app/src/split/serial/service.c
View file

@ -31,7 +31,7 @@ K_MSGQ_DEFINE(position_state_msgq, sizeof(char[SPLIT_DATA_LEN]),
static void send_position_state_callback(struct k_work *work) { static void send_position_state_callback(struct k_work *work) {
split_data_t *split_data = NULL; split_data_t *split_data = NULL;
while (!(split_data = (split_data_t *)alloc_position_state_buffer(K_MSEC(100)))) { while (!(split_data = (split_data_t *)alloc_split_serial_buffer(K_MSEC(100)))) {
}; };
memset(split_data, sizeof(split_data_t), 0); memset(split_data, sizeof(split_data_t), 0);