mcu.h

Go to the documentation of this file.

/*
 * Copyright (c) 2023, 2024, 2025 Adrian "asie" Siekierka
 *
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 *
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 *
 * 3. This notice may not be removed or altered from any source distribution.
 */
 
#ifndef NILE_MCU_H_
#define NILE_MCU_H_
 
#include <wonderful.h>
#include "hardware.h"
 
#define NILE_MCU_BOOT_ACK          0x79
#define NILE_MCU_BOOT_NACK         0x1F
#define NILE_MCU_BOOT_START        0x5A
#define NILE_MCU_BOOT_GET          0x00
#define NILE_MCU_BOOT_GET_VERSION  0x01
#define NILE_MCU_BOOT_GET_ID       0x02
#define NILE_MCU_BOOT_READ_MEMORY  0x11
#define NILE_MCU_BOOT_JUMP         0x21
#define NILE_MCU_BOOT_WRITE_MEMORY 0x31
#define NILE_MCU_BOOT_ERASE_MEMORY 0x44
#define NILE_MCU_BOOT_SPECIAL      0x50
#define NILE_MCU_BOOT_EXT_SPECIAL  0x51
#define NILE_MCU_BOOT_WRITE_LOCK   0x63
#define NILE_MCU_BOOT_WRITE_UNLOCK 0x73
#define NILE_MCU_BOOT_READ_LOCK    0x82
#define NILE_MCU_BOOT_READ_UNLOCK  0x92
#define NILE_MCU_BOOT_GET_CRC      0xA1
 
#define NILE_MCU_BOOT_ERASE_ALL_SECTORS 0xFFFF
 
#define NILE_MCU_BOOT_FLAG_SIZE     0x01
#define NILE_MCU_BOOT_FLAG_CHECKSUM 0x02
 
#define NILE_MCU_FLASH_START 0x08000000
#define NILE_MCU_FLASH_PAGE_SIZE 2048
 
#define NILE_MCU_NATIVE_CMD(cmd, arg) (((cmd) & 0x7F) | ((arg) << 7))
 
#ifndef __ASSEMBLER__
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>

bool nile_mcu_reset(bool to_bootloader);
 
bool nile_mcu_boot_wait_ack(void);
bool nile_mcu_boot_send_cmd(uint8_t cmd);
bool nile_mcu_boot_send_data(const void __far *buffer, uint16_t len, uint8_t flags);
uint16_t nile_mcu_boot_recv_data(void __far* buffer, uint16_t buflen, uint8_t flags);

uint8_t nile_mcu_boot_get_version(void);

uint16_t nile_mcu_boot_get_id(void);

bool nile_mcu_boot_read_memory(uint32_t address, void __far* buffer, uint16_t buflen);

bool nile_mcu_boot_jump(uint32_t address);

bool nile_mcu_boot_write_memory(uint32_t address, const void __far* buffer, uint16_t buflen);

bool nile_mcu_boot_erase_memory(uint16_t sector_address, uint16_t sector_count);

static inline bool nile_mcu_boot_erase_all_memory(void) {
    return nile_mcu_boot_erase_memory(0, NILE_MCU_BOOT_ERASE_ALL_SECTORS);
}

#define NILE_MCU_NATIVE_ERROR_SPI -1

#define NILE_MCU_NATIVE_ERROR_MCU -2

static inline int16_t nile_mcu_native_send_cmd(uint16_t cmd, const void __far* buffer, int buflen) {
    int16_t __nile_mcu_native_send_cmd_async(uint16_t cmd, int buflen, const void __far* buffer);
    return __nile_mcu_native_send_cmd_async(cmd, buflen, buffer);
}
// int16_t nile_mcu_native_send_cmd(uint16_t cmd, const void __wf_cram* buffer, int buflen);

int16_t nile_mcu_native_recv_cmd(void __far* buffer, uint16_t buflen);

int16_t nile_mcu_native_recv_cmd_start(uint16_t resplen);

int16_t nile_mcu_native_recv_cmd_finish(void __far* buffer, uint16_t buflen);
 
static inline int16_t nile_mcu_native_recv_cmd_response_uint8(void) {
    int16_t result; uint8_t bytes;
    if ((result = nile_mcu_native_recv_cmd_finish(&bytes, 1)) < 0) return result;
    return bytes;
}
 
static inline int16_t nile_mcu_native_recv_cmd_response_int16(void) {
    int16_t result, bytes;
    if ((result = nile_mcu_native_recv_cmd_finish(&bytes, 2)) < 0) return result;
    return bytes;
}
 
typedef enum {
    NILE_MCU_NATIVE_MODE_CMD = 0x00, 
    NILE_MCU_NATIVE_MODE_EEPROM = 0x01, 
    NILE_MCU_NATIVE_MODE_RTC = 0x02, 
    NILE_MCU_NATIVE_MODE_CDC = 0x03, 
    NILE_MCU_NATIVE_MODE_STANDBY = 0xFF 
} nile_mcu_native_mode_t;

static inline int16_t nile_mcu_native_mcu_switch_mode(uint8_t mode) {
    return nile_mcu_native_send_cmd(NILE_MCU_NATIVE_CMD(0x01, mode), NULL, 0);
}

static inline int16_t nile_mcu_native_mcu_spi_set_speed_sync(uint8_t speed) {
    int16_t result;
    uint8_t op_result;
    if ((result = nile_mcu_native_send_cmd(NILE_MCU_NATIVE_CMD(0x02, speed), NULL, 0)) < 0) return result;
    if ((result = nile_mcu_native_recv_cmd(&op_result, 1)) < 0) return result;
    return op_result;
}
 
static inline int16_t nile_mcu_native_mcu_get_uuid_sync(void __far* buffer, uint16_t buflen) {
    int16_t result;
    if ((result = nile_mcu_native_send_cmd(NILE_MCU_NATIVE_CMD(0x03, 0), NULL, 0)) < 0) return result;
    return nile_mcu_native_recv_cmd(buffer, buflen);
}
 
static inline int16_t nile_mcu_native_cdc_read_sync(void __far* buffer, uint16_t buflen) {
    int16_t result;
    if ((result = nile_mcu_native_send_cmd(NILE_MCU_NATIVE_CMD(0x40, buflen), NULL, 0)) < 0) return result;
    return nile_mcu_native_recv_cmd(buffer, buflen);
}
 
static inline int16_t nile_mcu_native_cdc_write_sync(const void __wf_cram* buffer, uint16_t buflen) {
    int16_t result, bytes;
    if ((result = nile_mcu_native_send_cmd(NILE_MCU_NATIVE_CMD(0x41, buflen), buffer, buflen)) < 0) return result;
    if ((result = nile_mcu_native_recv_cmd(&bytes, 2)) < 0) return result;
    return bytes;
}
 
static inline int16_t nile_mcu_native_cdc_write_async_start(const void __wf_cram* buffer, uint16_t buflen) {
    int16_t result;
    if ((result = nile_mcu_native_send_cmd(NILE_MCU_NATIVE_CMD(0x41, buflen), buffer, buflen)) < 0) return result;
    return nile_mcu_native_recv_cmd_start(2);
}
#define nile_mcu_native_cdc_write_async_finish nile_mcu_native_recv_cmd_response_int16
 
static inline int16_t nile_mcu_native_cdc_available_sync(void) {
    int16_t result, bytes;
    if ((result = nile_mcu_native_send_cmd(NILE_MCU_NATIVE_CMD(0x43, 0), NULL, 0)) < 0) return result;
    if ((result = nile_mcu_native_recv_cmd(&bytes, 2)) < 0) return result;
    return bytes;
}
 
static inline int16_t nile_mcu_native_cdc_available_async_start(const void __wf_cram* buffer, uint16_t buflen) {
    int16_t result;
    if ((result = nile_mcu_native_send_cmd(NILE_MCU_NATIVE_CMD(0x43, 0), buffer, buflen)) < 0) return result;
    return nile_mcu_native_recv_cmd_start(2);
}
#define nile_mcu_native_cdc_available_async_finish nile_mcu_native_recv_cmd_response_int16
 
static inline int16_t nile_mcu_native_cdc_clear_sync(void) {
    int16_t result;
    if ((result = nile_mcu_native_send_cmd(NILE_MCU_NATIVE_CMD(0x44, 0xFF), NULL, 0)) < 0) return result;
    return nile_mcu_native_recv_cmd(NULL, 0);
}
 
#endif /* __ASSEMBLER__ */
 
#endif /* NILE_MCU_H_ */