Skip to content

Commit

Permalink
Split serial driver in generic protocol and hardware driver part
Browse files Browse the repository at this point in the history
This allows other means of split communication to be implemented by
simply implementing the driver specific methods used in the serial protocol.
  • Loading branch information
KarlK90 committed Mar 18, 2022
1 parent eaff372 commit 6b2e599
Showing 5 changed files with 226 additions and 191 deletions.
1 change: 1 addition & 0 deletions builddefs/common_features.mk
Original file line number Diff line number Diff line change
@@ -619,6 +619,7 @@ ifeq ($(strip $(SPLIT_KEYBOARD)), yes)
ifeq ($(strip $(SERIAL_DRIVER)), bitbang)
QUANTUM_LIB_SRC += serial.c
else
QUANTUM_LIB_SRC += serial_protocol.c
QUANTUM_LIB_SRC += serial_$(strip $(SERIAL_DRIVER)).c
endif
endif
164 changes: 164 additions & 0 deletions platforms/chibios/drivers/serial_protocol.c
Original file line number Diff line number Diff line change
@@ -0,0 +1,164 @@
// Copyright 2022 Stefan Kerkmann
// SPDX-License-Identifier: GPL-2.0-or-later

#include "quantum.h"
#include "serial.h"
#include "serial_protocol.h"
#include "printf.h"
#include "synchronization_util.h"

#include <ch.h>

static const uint8_t HANDSHAKE_MAGIC = 7U;

static inline bool initiate_transaction(uint8_t sstd_index);
static inline bool react_to_transactions(void);

/**
* @brief This thread runs on the slave and responds to transactions initiated
* by the master.
*/
static THD_WORKING_AREA(waSlaveThread, 1024);
static THD_FUNCTION(SlaveThread, arg) {
(void)arg;
chRegSetThreadName("usart_tx_rx");

while (true) {
if (unlikely(!react_to_transactions())) {
/* Clear the receive queue, to start with a clean slate.
* Parts of failed transactions or spurious bytes could still be in it. */
driver_clear();
}
split_shared_memory_unlock();
}
}

/**
* @brief Slave specific initializations.
*/
void soft_serial_target_init(void) {
driver_slave_init();

/* Start transport thread. */
chThdCreateStatic(waSlaveThread, sizeof(waSlaveThread), HIGHPRIO, SlaveThread, NULL);
}

/**
* @brief Master specific initializations.
*/
void soft_serial_initiator_init(void) {
driver_master_init();
}

/**
* @brief React to transactions started by the master.
*/
static inline bool react_to_transactions(void) {
/* Wait until there is a transaction for us. */
uint8_t sstd_index = 0;
receive_blocking(&sstd_index, sizeof(sstd_index));

/* Sanity check that we are actually responding to a valid transaction. */
if (unlikely(sstd_index >= NUM_TOTAL_TRANSACTIONS)) {
return false;
}

split_shared_memory_lock();
split_transaction_desc_t* trans = &split_transaction_table[sstd_index];

/* Send back the handshake which is XORed as a simple checksum,
to signal that the slave is ready to receive possible transaction buffers */
sstd_index ^= HANDSHAKE_MAGIC;
if (unlikely(!send(&sstd_index, sizeof(sstd_index)))) {
return false;
}

/* Receive transaction buffer from the master. If this transaction requires it.*/
if (trans->initiator2target_buffer_size) {
if (unlikely(!receive(split_trans_initiator2target_buffer(trans), trans->initiator2target_buffer_size))) {
return false;
}
}

/* Allow any slave processing to occur. */
if (trans->slave_callback) {
trans->slave_callback(trans->initiator2target_buffer_size, split_trans_initiator2target_buffer(trans), trans->initiator2target_buffer_size, split_trans_target2initiator_buffer(trans));
}

/* Send transaction buffer to the master. If this transaction requires it. */
if (trans->target2initiator_buffer_size) {
if (unlikely(!send(split_trans_target2initiator_buffer(trans), trans->target2initiator_buffer_size))) {
return false;
}
}

return true;
}

/**
* @brief Start transaction from the master half to the slave half.
*
* @param index Transaction Table index of the transaction to start.
* @return bool Indicates success of transaction.
*/
bool soft_serial_transaction(int index) {
split_shared_memory_lock();
bool result = initiate_transaction((uint8_t)index);
split_shared_memory_unlock();

if (unlikely(!result)) {
/* Clear the receive queue, to start with a clean slate.
* Parts of failed transactions or spurious bytes could still be in it. */
driver_clear();
}

return result;
}

/**
* @brief Initiate transaction to slave half.
*/
static inline bool initiate_transaction(uint8_t sstd_index) {
/* Sanity check that we are actually starting a valid transaction. */
if (unlikely(sstd_index >= NUM_TOTAL_TRANSACTIONS)) {
dprintln("USART: Illegal transaction Id.");
return false;
}

split_transaction_desc_t* trans = &split_transaction_table[sstd_index];

/* Send transaction table index to the slave, which doubles as basic handshake token. */
if (unlikely(!send(&sstd_index, sizeof(sstd_index)))) {
dprintln("USART: Send Handshake failed.");
return false;
}

uint8_t sstd_index_shake = 0xFF;

/* Which we always read back first so that we can error out correctly.
* - due to the half duplex limitations on return codes, we always have to read *something*.
* - without the read, write only transactions *always* succeed, even during the boot process where the slave is not ready.
*/
if (unlikely(!receive(&sstd_index_shake, sizeof(sstd_index_shake)) || (sstd_index_shake != (sstd_index ^ HANDSHAKE_MAGIC)))) {
dprintln("USART: Handshake failed.");
return false;
}

/* Send transaction buffer to the slave. If this transaction requires it. */
if (trans->initiator2target_buffer_size) {
if (unlikely(!send(split_trans_initiator2target_buffer(trans), trans->initiator2target_buffer_size))) {
dprintln("USART: Send failed.");
return false;
}
}

/* Receive transaction buffer from the slave. If this transaction requires it. */
if (trans->target2initiator_buffer_size) {
if (unlikely(!receive(split_trans_target2initiator_buffer(trans), trans->target2initiator_buffer_size))) {
dprintln("USART: Receive failed.");
return false;
}
}

return true;
}
53 changes: 53 additions & 0 deletions platforms/chibios/drivers/serial_protocol.h
Original file line number Diff line number Diff line change
@@ -0,0 +1,53 @@
// Copyright 2022 Stefan Kerkmann
// SPDX-License-Identifier: GPL-2.0-or-later

#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>

#pragma once

void driver_clear(void);
void driver_master_init(void);
void driver_slave_init(void);
bool __attribute__((nonnull)) receive(uint8_t* destination, const size_t size);
bool __attribute__((nonnull)) receive_blocking(uint8_t* destination, const size_t size);
bool __attribute__((nonnull)) send(const uint8_t* source, const size_t size);

#if defined(SOFT_SERIAL_PIN)
# define SERIAL_USART_TX_PIN SOFT_SERIAL_PIN
#endif

#if !defined(SERIAL_USART_TX_PIN)
# define SERIAL_USART_TX_PIN A9
#endif

#if !defined(SERIAL_USART_RX_PIN)
# define SERIAL_USART_RX_PIN A10
#endif

#if !defined(SELECT_SOFT_SERIAL_SPEED)
# define SELECT_SOFT_SERIAL_SPEED 1
#endif

#if defined(SERIAL_USART_SPEED)
// Allow advanced users to directly set SERIAL_USART_SPEED
#elif SELECT_SOFT_SERIAL_SPEED == 0
# define SERIAL_USART_SPEED 460800
#elif SELECT_SOFT_SERIAL_SPEED == 1
# define SERIAL_USART_SPEED 230400
#elif SELECT_SOFT_SERIAL_SPEED == 2
# define SERIAL_USART_SPEED 115200
#elif SELECT_SOFT_SERIAL_SPEED == 3
# define SERIAL_USART_SPEED 57600
#elif SELECT_SOFT_SERIAL_SPEED == 4
# define SERIAL_USART_SPEED 38400
#elif SELECT_SOFT_SERIAL_SPEED == 5
# define SERIAL_USART_SPEED 19200
#else
# error invalid SELECT_SOFT_SERIAL_SPEED value
#endif

#if !defined(SERIAL_USART_TIMEOUT)
# define SERIAL_USART_TIMEOUT 20
#endif
Loading

0 comments on commit 6b2e599

Please sign in to comment.