forked from qmk/qmk_firmware
-
Notifications
You must be signed in to change notification settings - Fork 109
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
[Core] Split ChibiOS usart split driver in protocol and hardware driv…
…er part (qmk#16669)
- Loading branch information
Showing
8 changed files
with
292 additions
and
227 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
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
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 <ch.h> | ||
|
|
||
| #include "quantum.h" | ||
| #include "serial.h" | ||
| #include "serial_protocol.h" | ||
| #include "printf.h" | ||
| #include "synchronization_util.h" | ||
|
|
||
| static inline bool initiate_transaction(uint8_t transaction_id); | ||
| static inline bool react_to_transaction(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("split_protocol_tx_rx"); | ||
|
|
||
| while (true) { | ||
| split_shared_memory_lock(); | ||
| if (unlikely(!react_to_transaction())) { | ||
| /* Clear the receive queue, to start with a clean slate. | ||
| * Parts of failed transactions or spurious bytes could still be in it. */ | ||
| serial_transport_driver_clear(); | ||
| } | ||
| split_shared_memory_unlock(); | ||
| } | ||
| } | ||
|
|
||
| /** | ||
| * @brief Slave specific initializations. | ||
| */ | ||
| void soft_serial_target_init(void) { | ||
| serial_transport_driver_slave_init(); | ||
|
|
||
| /* Start transport thread. */ | ||
| chThdCreateStatic(waSlaveThread, sizeof(waSlaveThread), HIGHPRIO, SlaveThread, NULL); | ||
| } | ||
|
|
||
| /** | ||
| * @brief Master specific initializations. | ||
| */ | ||
| void soft_serial_initiator_init(void) { | ||
| serial_transport_driver_master_init(); | ||
| } | ||
|
|
||
| /** | ||
| * @brief React to transactions started by the master. | ||
| */ | ||
| static inline bool react_to_transaction(void) { | ||
| uint8_t transaction_id = 0; | ||
| /* Wait until there is a transaction for us. */ | ||
| if (unlikely(!serial_transport_receive_blocking(&transaction_id, sizeof(transaction_id)))) { | ||
| return false; | ||
| } | ||
|
|
||
| /* Sanity check that we are actually responding to a valid transaction. */ | ||
| if (unlikely(transaction_id >= NUM_TOTAL_TRANSACTIONS)) { | ||
| return false; | ||
| } | ||
|
|
||
| split_transaction_desc_t* transaction = &split_transaction_table[transaction_id]; | ||
|
|
||
| /* Send back the handshake which is XORed as a simple checksum, | ||
| to signal that the slave is ready to receive possible transaction buffers */ | ||
| transaction_id ^= NUM_TOTAL_TRANSACTIONS; | ||
| if (unlikely(!serial_transport_send(&transaction_id, sizeof(transaction_id)))) { | ||
| return false; | ||
| } | ||
|
|
||
| /* Receive transaction buffer from the master. If this transaction requires it.*/ | ||
| if (transaction->initiator2target_buffer_size) { | ||
| if (unlikely(!serial_transport_receive(split_trans_initiator2target_buffer(transaction), transaction->initiator2target_buffer_size))) { | ||
| return false; | ||
| } | ||
| } | ||
|
|
||
| /* Allow any slave processing to occur. */ | ||
| if (transaction->slave_callback) { | ||
| transaction->slave_callback(transaction->initiator2target_buffer_size, split_trans_initiator2target_buffer(transaction), transaction->initiator2target_buffer_size, split_trans_target2initiator_buffer(transaction)); | ||
| } | ||
|
|
||
| /* Send transaction buffer to the master. If this transaction requires it. */ | ||
| if (transaction->target2initiator_buffer_size) { | ||
| if (unlikely(!serial_transport_send(split_trans_target2initiator_buffer(transaction), transaction->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. */ | ||
| serial_transport_driver_clear(); | ||
| } | ||
|
|
||
| return result; | ||
| } | ||
|
|
||
| /** | ||
| * @brief Initiate transaction to slave half. | ||
| */ | ||
| static inline bool initiate_transaction(uint8_t transaction_id) { | ||
| /* Sanity check that we are actually starting a valid transaction. */ | ||
| if (unlikely(transaction_id >= NUM_TOTAL_TRANSACTIONS)) { | ||
| serial_dprintf("SPLIT: illegal transaction id\n"); | ||
| return false; | ||
| } | ||
|
|
||
| split_transaction_desc_t* transaction = &split_transaction_table[transaction_id]; | ||
|
|
||
| /* Send transaction table index to the slave, which doubles as basic handshake token. */ | ||
| if (unlikely(!serial_transport_send(&transaction_id, sizeof(transaction_id)))) { | ||
| serial_dprintf("SPLIT: sending handshake failed\n"); | ||
| return false; | ||
| } | ||
|
|
||
| uint8_t transaction_id_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(!serial_transport_receive(&transaction_id_shake, sizeof(transaction_id_shake)) || (transaction_id_shake != (transaction_id ^ NUM_TOTAL_TRANSACTIONS)))) { | ||
| serial_dprintf("SPLIT: receiving handshake failed\n"); | ||
| return false; | ||
| } | ||
|
|
||
| /* Send transaction buffer to the slave. If this transaction requires it. */ | ||
| if (transaction->initiator2target_buffer_size) { | ||
| if (unlikely(!serial_transport_send(split_trans_initiator2target_buffer(transaction), transaction->initiator2target_buffer_size))) { | ||
| serial_dprintf("SPLIT: sending buffer failed\n"); | ||
| return false; | ||
| } | ||
| } | ||
|
|
||
| /* Receive transaction buffer from the slave. If this transaction requires it. */ | ||
| if (transaction->target2initiator_buffer_size) { | ||
| if (unlikely(!serial_transport_receive(split_trans_target2initiator_buffer(transaction), transaction->target2initiator_buffer_size))) { | ||
| serial_dprintf("SPLIT: receiving buffer failed\n"); | ||
| 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,49 @@ | ||
| // Copyright 2022 Stefan Kerkmann | ||
| // SPDX-License-Identifier: GPL-2.0-or-later | ||
|
|
||
| #include <stddef.h> | ||
| #include <stdint.h> | ||
| #include <stdbool.h> | ||
|
|
||
| #pragma once | ||
|
|
||
| /** | ||
| * @brief Clears any intermediate sending or receiving state of the driver to a known good | ||
| * state. This happens after errors in the middle of transactions, to start with | ||
| * a clean slate. | ||
| */ | ||
| void serial_transport_driver_clear(void); | ||
|
|
||
| /** | ||
| * @brief Driver specific initialization on the slave half. | ||
| */ | ||
| void serial_transport_driver_slave_init(void); | ||
|
|
||
| /** | ||
| * @brief Driver specific specific initialization on the master half. | ||
| */ | ||
| void serial_transport_driver_master_init(void); | ||
|
|
||
| /** | ||
| * @brief Blocking receive of size * bytes. | ||
| * | ||
| * @return true Receive success. | ||
| * @return false Receive failed, e.g. by bit errors. | ||
| */ | ||
| bool __attribute__((nonnull, hot)) serial_transport_receive(uint8_t* destination, const size_t size); | ||
|
|
||
| /** | ||
| * @brief Blocking receive of size * bytes with an implicitly defined timeout. | ||
| * | ||
| * @return true Receive success. | ||
| * @return false Receive failed, e.g. by timeout or bit errors. | ||
| */ | ||
| bool __attribute__((nonnull, hot)) serial_transport_receive_blocking(uint8_t* destination, const size_t size); | ||
|
|
||
| /** | ||
| * @brief Blocking send of buffer with timeout. | ||
| * | ||
| * @return true Send success. | ||
| * @return false Send failed, e.g. by timeout or bit errors. | ||
| */ | ||
| bool __attribute__((nonnull, hot)) serial_transport_send(const uint8_t* source, const size_t size); |
Oops, something went wrong.