-
-
Notifications
You must be signed in to change notification settings - Fork 39.8k
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Split serial driver in generic protocol and hardware driver part
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
Showing
5 changed files
with
226 additions
and
191 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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; | ||
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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 |
Oops, something went wrong.