neil/blisp
1
0
Fork 0
mirror of https://github.com/pine64/blisp.git synced 2025-06-25 04:54:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: neil:048a72408218788d519a87bcdfb23bcf9ed91a84
Branches Tags
neil:master
neil:feature/run-in-ram
neil:ralim
neil:multi-build
neil:error_codes
neil:write
neil:errors
neil:feature/bl808
neil:feature/rts_dtr
neil:readme
neil:v0.0.4
neil:v0.0.3
neil:v0.0.2
neil:v0.0.1
..
compare: neil:2e931f80db37d21883c5897b8920b1a0e54e0d64
Branches Tags
neil:master
neil:feature/run-in-ram
neil:ralim
neil:multi-build
neil:error_codes
neil:write
neil:errors
neil:feature/bl808
neil:feature/rts_dtr
neil:readme
neil:v0.0.4
neil:v0.0.3
neil:v0.0.2
neil:v0.0.1

No commits in common. "048a72408218788d519a87bcdfb23bcf9ed91a84" and "2e931f80db37d21883c5897b8920b1a0e54e0d64" have entirely different histories.
048a724082 ... 2e931f80db

12 changed files with 221 additions and 290 deletions
Show Stats Expand all files Collapse all files

81
CMakeLists.txt
View File

@ -4,7 +4,6 @@ project(blisp C)
set(CMAKE_C_STANDARD 23) set(CMAKE_C_STANDARD 23)
option(BLISP_BUILD_CLI "Build CLI Tool" OFF) option(BLISP_BUILD_CLI "Build CLI Tool" OFF)
option(BLISP_USE_SYSTEM_LIBRARIES "Use system-installed libraries" "${CMAKE_USE_SYSTEM_LIBRARIES}")
add_library(libblisp_obj OBJECT add_library(libblisp_obj OBJECT
lib/blisp.c lib/blisp.c
@ -39,54 +38,46 @@ set_target_properties(libblisp_static PROPERTIES
ARCHIVE_OUTPUT_DIRECTORY "static" ARCHIVE_OUTPUT_DIRECTORY "static"
OUTPUT_NAME "blisp") OUTPUT_NAME "blisp")
if(BLISP_USE_SYSTEM_LIBRARIES) if(NOT ${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
find_package(PkgConfig) target_sources(libblisp_obj PRIVATE
pkg_search_module(LIBSERIALPORT REQUIRED libserialport)
target_link_libraries(libblisp PUBLIC ${LIBSERIALPORT_LIBRARIES})
target_link_libraries(libblisp_static PUBLIC ${LIBSERIALPORT_LIBRARIES})
target_include_directories(libblisp_obj PUBLIC ${LIBSERIALPORT_INCLUDE_DIRS})
else()
if(NOT ${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
target_sources(libblisp_obj PRIVATE
${CMAKE_SOURCE_DIR}/vendor/libserialport/serialport.c ${CMAKE_SOURCE_DIR}/vendor/libserialport/serialport.c
${CMAKE_SOURCE_DIR}/vendor/libserialport/timing.c) ${CMAKE_SOURCE_DIR}/vendor/libserialport/timing.c)
target_include_directories(libblisp_obj PRIVATE ${CMAKE_SOURCE_DIR}/vendor/libserialport) target_include_directories(libblisp_obj PRIVATE ${CMAKE_SOURCE_DIR}/vendor/libserialport)
endif() endif()
if(WIN32) if(WIN32)
target_link_libraries(libblisp PRIVATE Setupapi.lib) target_link_libraries(libblisp PRIVATE Setupapi.lib)
target_link_libraries(libblisp_static PRIVATE Setupapi.lib) target_link_libraries(libblisp_static PRIVATE Setupapi.lib)
target_compile_definitions(libblisp_obj PRIVATE LIBSERIALPORT_MSBUILD) target_compile_definitions(libblisp_obj PRIVATE LIBSERIALPORT_MSBUILD)
target_sources(libblisp_obj PRIVATE target_sources(libblisp_obj PRIVATE
${CMAKE_SOURCE_DIR}/vendor/libserialport/windows.c) ${CMAKE_SOURCE_DIR}/vendor/libserialport/windows.c)
elseif(UNIX AND NOT APPLE AND NOT ${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD") elseif(UNIX AND NOT APPLE AND NOT ${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
target_sources(libblisp_obj PRIVATE target_sources(libblisp_obj PRIVATE
${CMAKE_SOURCE_DIR}/vendor/libserialport/linux.c ${CMAKE_SOURCE_DIR}/vendor/libserialport/linux.c
${CMAKE_SOURCE_DIR}/vendor/libserialport/linux_termios.c) ${CMAKE_SOURCE_DIR}/vendor/libserialport/linux_termios.c)
target_compile_definitions(libblisp_obj PRIVATE target_compile_definitions(libblisp_obj PRIVATE
LIBSERIALPORT_ATBUILD LIBSERIALPORT_ATBUILD
HAVE_TERMIOS2_SPEED HAVE_TERMIOS2_SPEED
HAVE_STRUCT_TERMIOS2 HAVE_STRUCT_TERMIOS2
HAVE_DECL_BOTHER HAVE_DECL_BOTHER
"SP_API=__attribute__((visibility(\"default\")))" "SP_API=__attribute__((visibility(\"default\")))"
"SP_PRIV=__attribute__((visibility(\"hidden\")))") "SP_PRIV=__attribute__((visibility(\"hidden\")))")
write_file(${CMAKE_SOURCE_DIR}/vendor/libserialport/config.h "// bypass errors.") write_file(${CMAKE_SOURCE_DIR}/vendor/libserialport/config.h "// bypass errors.")
elseif(UNIX AND ${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD") elseif(UNIX AND ${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
target_include_directories(libblisp_obj PRIVATE /usr/local/include/) target_include_directories(libblisp_obj PRIVATE /usr/local/include/)
target_link_libraries(libblisp PRIVATE -L/usr/local/lib usb serialport) target_link_libraries(libblisp PRIVATE -L/usr/local/lib usb serialport)
target_link_libraries(libblisp_static PRIVATE -L/usr/local/lib usb serialport) target_link_libraries(libblisp_static PRIVATE -L/usr/local/lib usb serialport)
elseif(APPLE) elseif(APPLE)
target_sources(libblisp_obj PRIVATE target_sources(libblisp_obj PRIVATE
${CMAKE_SOURCE_DIR}/vendor/libserialport/macosx.c) ${CMAKE_SOURCE_DIR}/vendor/libserialport/macosx.c)
target_link_libraries(libblisp PRIVATE "-framework IOKit" "-framework CoreFoundation") target_link_libraries(libblisp PRIVATE "-framework IOKit" "-framework CoreFoundation")
target_compile_definitions(libblisp_obj PRIVATE target_compile_definitions(libblisp_obj PRIVATE
LIBSERIALPORT_ATBUILD LIBSERIALPORT_ATBUILD
"SP_PRIV=__attribute__((visibility(\"hidden\")))" "SP_PRIV=__attribute__((visibility(\"hidden\")))"
"SP_API=__attribute__((visibility(\"default\")))") "SP_API=__attribute__((visibility(\"default\")))")
target_include_directories(libblisp_obj PRIVATE ${CMAKE_SOURCE_DIR}/vendor/libserialport) target_include_directories(libblisp_obj PRIVATE ${CMAKE_SOURCE_DIR}/vendor/libserialport)
write_file(${CMAKE_SOURCE_DIR}/vendor/libserialport/config.h "// bypass errors.") write_file(${CMAKE_SOURCE_DIR}/vendor/libserialport/config.h "// bypass errors.")
endif()
endif() endif()
install(TARGETS libblisp libblisp_static DESTINATION lib) install(TARGETS libblisp libblisp_static DESTINATION lib)

10
README.md
View File

@ -54,16 +54,6 @@ mkdir build && cd build
cmake -DBLISP_BUILD_CLI=ON .. cmake -DBLISP_BUILD_CLI=ON ..
cmake --build . cmake --build .
``` ```
For building against preinstalled system libraries of the used vendor
libraries (e.g. for use by system maintainers), additionally define
`BLISP_USE_SYSTEM_LIBRARIES`, e.g. using following commands:
```bash
mkdir build && cd build
cmake -DBLISP_USE_SYSTEM_LIBRARIES=ON -DBLISP_BUILD_CLI=ON ..
cmake --build .
```
#### Need more build details? [See here](https://github.com/pine64/blisp/wiki/Update-Pinecil-V2#build-blisp-flasher-from-code). #### Need more build details? [See here](https://github.com/pine64/blisp/wiki/Update-Pinecil-V2#build-blisp-flasher-from-code).
## Usage ## Usage

14
include/blisp.h
View File

@ -3,8 +3,20 @@
#define _LIBBLISP_H #define _LIBBLISP_H
#include <stdint.h> #include <stdint.h>
#include "blisp_chip.h" #include "blisp_chip.h"
#include "error_codes.h"
enum blisp_return {
BLISP_OK = 0,
BLISP_ERR_UNKNOWN = -1,
BLISP_ERR_NO_RESPONSE = -2,
BLISP_ERR_DEVICE_NOT_FOUND = -3,
BLISP_ERR_CANT_OPEN_DEVICE = -4,
// Can't auto-find device due it doesn't have native USB
BLISP_ERR_NO_AUTO_FIND_AVAILABLE = -5,
BLISP_ERR_PENDING = -6,
BLISP_ERR_CHIP_ERR = -7
};
struct blisp_segment_header { struct blisp_segment_header {
uint32_t dest_addr; uint32_t dest_addr;

30
include/error_codes.h
View File

@ -1,30 +0,0 @@
#ifndef BLISP_S_RC_ERROR_CODES_H_
#define BLISP_S_RC_ERROR_CODES_H_
typedef enum {
BLISP_OK = 0,
// All error states must be <0.
// Generic error return; for when we are unsure what failed
BLISP_ERR_UNKNOWN = -1,
// Device did not respond, if serial link, could be that its not in boot
// loader
BLISP_ERR_NO_RESPONSE = -2,
// Failed to open a device, likely libusb or permissions
BLISP_ERR_DEVICE_NOT_FOUND = -3, // We could not find a device
BLISP_ERR_CANT_OPEN_DEVICE =
-4, // Couldn't open device; could it be permissions or its in use?
// Can't auto-find device due it doesn't have native USB
BLISP_ERR_NO_AUTO_FIND_AVAILABLE = -5,
BLISP_ERR_PENDING = -6, // Internal error for device is busy and to come back
BLISP_ERR_CHIP_ERR = -7, // Chip returned an error to us
BLISP_ERR_INVALID_CHIP_TYPE = -8, // unsupported chip type provided
BLISP_ERR_OUT_OF_MEMORY =
-9, // System could not allocate enough ram (highly unlikely)
BLISP_ERR_INVALID_COMMAND = -10, // Invalid user command provided
BLISP_ERR_CANT_OPEN_FILE = -11, // Cant open the firmware file to flash
BLISP_ERR_NOT_IMPLEMENTED = -12, // Non implemented function called
BLISP_ERR_API_ERROR = -13, // Errors outside our control from api's we
// integrate (Generally serial port/OS related)
} blisp_return_t;
#endif

124
lib/blisp.c
View File

@ -15,20 +15,19 @@
static void drain(struct sp_port* port) { static void drain(struct sp_port* port) {
#if defined(__APPLE__) || defined(__FreeBSD__) #if defined(__APPLE__) || defined(__FreeBSD__)
sp_drain(port); sp_drain(port);
#endif #endif
} }
blisp_return_t blisp_device_init(struct blisp_device* device, int32_t blisp_device_init(struct blisp_device* device,
struct blisp_chip* chip) { struct blisp_chip* chip) {
device->chip = chip; device->chip = chip;
device->is_usb = false; device->is_usb = false;
return BLISP_OK; return 0;
} }
blisp_return_t blisp_device_open(struct blisp_device* device, int32_t blisp_device_open(struct blisp_device* device, const char* port_name) {
const char* port_name) { int ret;
blisp_return_t ret;
struct sp_port* serial_port = NULL; struct sp_port* serial_port = NULL;
if (port_name != NULL) { if (port_name != NULL) {
@ -45,7 +44,7 @@ blisp_return_t blisp_device_open(struct blisp_device* device,
ret = sp_list_ports(&port_list); ret = sp_list_ports(&port_list);
if (ret != SP_OK) { if (ret != SP_OK) {
blisp_dlog("Couldn't list ports, err: %d", ret); blisp_dlog("Couldn't list ports, err: %d", ret);
return BLISP_ERR_DEVICE_NOT_FOUND; return BLISP_ERR_UNKNOWN;
} }
for (int i = 0; port_list[i] != NULL; i++) { for (int i = 0; port_list[i] != NULL; i++) {
struct sp_port* port = port_list[i]; struct sp_port* port = port_list[i];
@ -70,7 +69,8 @@ blisp_return_t blisp_device_open(struct blisp_device* device,
ret = sp_open(serial_port, SP_MODE_READ_WRITE); ret = sp_open(serial_port, SP_MODE_READ_WRITE);
if (ret != SP_OK) { if (ret != SP_OK) {
blisp_dlog("SP open failed: %d", ret); blisp_dlog("SP open failed: %d", ret);
return BLISP_ERR_CANT_OPEN_DEVICE; return BLISP_ERR_UNKNOWN; // TODO: Maybe this should be that it can't open
// device?
} }
// TODO: Handle errors in following functions, although, none of them *should* // TODO: Handle errors in following functions, although, none of them *should*
// fail // fail
@ -99,19 +99,19 @@ blisp_return_t blisp_device_open(struct blisp_device* device,
#endif #endif
ret = sp_set_baudrate(serial_port, device->current_baud_rate); ret = sp_set_baudrate(serial_port, device->current_baud_rate);
if (ret != SP_OK) { if (ret != SP_OK) {
blisp_dlog("Set baud rate failed: %d... Also hello MacOS user :)", ret); blisp_dlog("Set baud rate failed: %d... Also hello macOS user :)", ret);
return BLISP_ERR_API_ERROR; return BLISP_ERR_UNKNOWN;
} }
device->serial_port = serial_port; device->serial_port = serial_port;
return BLISP_OK; return BLISP_OK;
} }
blisp_return_t blisp_send_command(struct blisp_device* device, int32_t blisp_send_command(struct blisp_device* device,
uint8_t command, uint8_t command,
void* payload, void* payload,
uint16_t payload_size, uint16_t payload_size,
bool add_checksum) { bool add_checksum) {
int ret; int ret;
struct sp_port* serial_port = device->serial_port; struct sp_port* serial_port = device->serial_port;
@ -134,22 +134,22 @@ blisp_return_t blisp_send_command(struct blisp_device* device,
sp_blocking_write(serial_port, device->tx_buffer, 4 + payload_size, 1000); sp_blocking_write(serial_port, device->tx_buffer, 4 + payload_size, 1000);
if (ret != (4 + payload_size)) { if (ret != (4 + payload_size)) {
blisp_dlog("Received error or not written all data: %d", ret); blisp_dlog("Received error or not written all data: %d", ret);
return BLISP_ERR_API_ERROR; return BLISP_ERR_UNKNOWN;
} }
drain(serial_port); drain(serial_port);
return BLISP_OK; return BLISP_OK;
} }
blisp_return_t blisp_receive_response(struct blisp_device* device, int32_t blisp_receive_response(struct blisp_device* device,
bool expect_payload) { bool expect_payload) {
// TODO: Check checksum // TODO: Check checksum
int ret; int ret;
struct sp_port* serial_port = device->serial_port; struct sp_port* serial_port = device->serial_port;
ret = sp_blocking_read(serial_port, &device->rx_buffer[0], 2, 1000); ret = sp_blocking_read(serial_port, &device->rx_buffer[0], 2, 1000);
if (ret < 2) { if (ret < 2) {
blisp_dlog("Failed to receive response, ret: %d", ret); blisp_dlog("Failed to receive response, ret: %d", ret);
return BLISP_ERR_NO_RESPONSE; return BLISP_ERR_UNKNOWN; // TODO: Terrible
} else if (device->rx_buffer[0] == 'O' && device->rx_buffer[1] == 'K') { } else if (device->rx_buffer[0] == 'O' && device->rx_buffer[1] == 'K') {
if (expect_payload) { if (expect_payload) {
sp_blocking_read(serial_port, &device->rx_buffer[2], 2, sp_blocking_read(serial_port, &device->rx_buffer[2], 2,
@ -171,11 +171,10 @@ blisp_return_t blisp_receive_response(struct blisp_device* device,
} }
blisp_dlog("Failed to receive any response (err: %d, %d - %d)", ret, blisp_dlog("Failed to receive any response (err: %d, %d - %d)", ret,
device->rx_buffer[0], device->rx_buffer[1]); device->rx_buffer[0], device->rx_buffer[1]);
return BLISP_ERR_NO_RESPONSE; return BLISP_ERR_UNKNOWN;
} }
blisp_return_t blisp_device_handshake(struct blisp_device* device, int32_t blisp_device_handshake(struct blisp_device* device, bool in_ef_loader) {
bool in_ef_loader) {
int ret; int ret;
uint8_t handshake_buffer[600]; uint8_t handshake_buffer[600];
struct sp_port* serial_port = device->serial_port; struct sp_port* serial_port = device->serial_port;
@ -204,11 +203,11 @@ blisp_return_t blisp_device_handshake(struct blisp_device* device,
} }
} }
ret = sp_blocking_write(serial_port, handshake_buffer, bytes_count, 500); ret = sp_blocking_write(serial_port, handshake_buffer, bytes_count, 500);
// not sure about Apple part, but FreeBSD needs it // not sure about Apple part, but FreeBSD needs it
drain(serial_port); drain(serial_port);
if (ret < 0) { if (ret < 0) {
blisp_dlog("Handshake write failed, ret %d", ret); blisp_dlog("Handshake write failed, ret %d", ret);
return BLISP_ERR_API_ERROR; return BLISP_ERR_UNKNOWN;
} }
if (!in_ef_loader && !device->is_usb) { if (!in_ef_loader && !device->is_usb) {
@ -222,14 +221,15 @@ blisp_return_t blisp_device_handshake(struct blisp_device* device,
return BLISP_OK; return BLISP_OK;
} }
} }
} }
blisp_dlog("Received no response from chip."); blisp_dlog("Received no response from chip.");
return BLISP_ERR_NO_RESPONSE; return BLISP_ERR_NO_RESPONSE;
} }
blisp_return_t blisp_device_get_boot_info(struct blisp_device* device, int32_t blisp_device_get_boot_info(struct blisp_device* device,
struct blisp_boot_info* boot_info) { struct blisp_boot_info* boot_info) {
blisp_return_t ret; int ret;
ret = blisp_send_command(device, 0x10, NULL, 0, false); ret = blisp_send_command(device, 0x10, NULL, 0, false);
if (ret < 0) if (ret < 0)
@ -240,8 +240,7 @@ blisp_return_t blisp_device_get_boot_info(struct blisp_device* device,
return ret; return ret;
memcpy(boot_info->boot_rom_version, &device->rx_buffer[0], memcpy(boot_info->boot_rom_version, &device->rx_buffer[0],
4); // TODO: Endianess; this may break on big endian machines 4); // TODO: Endianess
if (device->chip->type == BLISP_CHIP_BL70X) { if (device->chip->type == BLISP_CHIP_BL70X) {
memcpy(boot_info->chip_id, &device->rx_buffer[16], 8); memcpy(boot_info->chip_id, &device->rx_buffer[16], 8);
} }
@ -250,9 +249,9 @@ blisp_return_t blisp_device_get_boot_info(struct blisp_device* device,
} }
// TODO: Use struct instead of uint8_t* // TODO: Use struct instead of uint8_t*
blisp_return_t blisp_device_load_boot_header(struct blisp_device* device, int32_t blisp_device_load_boot_header(struct blisp_device* device,
uint8_t* boot_header) { uint8_t* boot_header) {
blisp_return_t ret; int ret;
ret = blisp_send_command(device, 0x11, boot_header, 176, false); ret = blisp_send_command(device, 0x11, boot_header, 176, false);
if (ret < 0) if (ret < 0)
return ret; return ret;
@ -263,10 +262,10 @@ blisp_return_t blisp_device_load_boot_header(struct blisp_device* device,
return BLISP_OK; return BLISP_OK;
} }
blisp_return_t blisp_device_load_segment_header( int32_t blisp_device_load_segment_header(
struct blisp_device* device, struct blisp_device* device,
struct blisp_segment_header* segment_header) { struct blisp_segment_header* segment_header) {
blisp_return_t ret; int ret;
ret = blisp_send_command(device, 0x17, segment_header, 16, false); ret = blisp_send_command(device, 0x17, segment_header, 16, false);
if (ret < 0) if (ret < 0)
return ret; return ret;
@ -277,10 +276,10 @@ blisp_return_t blisp_device_load_segment_header(
return BLISP_OK; return BLISP_OK;
} }
blisp_return_t blisp_device_load_segment_data(struct blisp_device* device, int32_t blisp_device_load_segment_data(struct blisp_device* device,
uint8_t* segment_data, uint8_t* segment_data,
uint32_t segment_data_length) { uint32_t segment_data_length) {
blisp_return_t ret; int ret;
ret = blisp_send_command(device, 0x18, segment_data, segment_data_length, ret = blisp_send_command(device, 0x18, segment_data, segment_data_length,
false); false);
if (ret < 0) if (ret < 0)
@ -292,8 +291,8 @@ blisp_return_t blisp_device_load_segment_data(struct blisp_device* device,
return BLISP_OK; return BLISP_OK;
} }
blisp_return_t blisp_device_check_image(struct blisp_device* device) { int32_t blisp_device_check_image(struct blisp_device* device) {
blisp_return_t ret; int ret;
ret = blisp_send_command(device, 0x19, NULL, 0, false); ret = blisp_send_command(device, 0x19, NULL, 0, false);
if (ret < 0) if (ret < 0)
return ret; return ret;
@ -304,11 +303,11 @@ blisp_return_t blisp_device_check_image(struct blisp_device* device) {
return BLISP_OK; return BLISP_OK;
} }
blisp_return_t blisp_device_write_memory(struct blisp_device* device, int32_t blisp_device_write_memory(struct blisp_device* device,
uint32_t address, uint32_t address,
uint32_t value, uint32_t value,
bool wait_for_res) { bool wait_for_res) {
blisp_return_t ret; int ret;
uint8_t payload[8]; uint8_t payload[8];
*(uint32_t*)(payload) = address; *(uint32_t*)(payload) = address;
*(uint32_t*)(payload + 4) = value; // TODO: Endianness *(uint32_t*)(payload + 4) = value; // TODO: Endianness
@ -324,8 +323,8 @@ blisp_return_t blisp_device_write_memory(struct blisp_device* device,
return BLISP_OK; return BLISP_OK;
} }
blisp_return_t blisp_device_run_image(struct blisp_device* device) { int32_t blisp_device_run_image(struct blisp_device* device) {
blisp_return_t ret; int ret;
if (device->chip->type == BLISP_CHIP_BL70X) { // ERRATA if (device->chip->type == BLISP_CHIP_BL70X) { // ERRATA
ret = blisp_device_write_memory(device, 0x4000F100, 0x4E424845, true); ret = blisp_device_write_memory(device, 0x4000F100, 0x4E424845, true);
@ -352,14 +351,14 @@ blisp_return_t blisp_device_run_image(struct blisp_device* device) {
return BLISP_OK; return BLISP_OK;
} }
blisp_return_t blisp_device_flash_erase(struct blisp_device* device, int32_t blisp_device_flash_erase(struct blisp_device* device,
uint32_t start_address, uint32_t start_address,
uint32_t end_address) { uint32_t end_address) {
uint8_t payload[8]; uint8_t payload[8];
*(uint32_t*)(payload + 0) = start_address; *(uint32_t*)(payload + 0) = start_address;
*(uint32_t*)(payload + 4) = end_address; *(uint32_t*)(payload + 4) = end_address;
blisp_return_t ret = blisp_send_command(device, 0x30, payload, 8, true); int ret = blisp_send_command(device, 0x30, payload, 8, true);
if (ret < 0) if (ret < 0)
return ret; return ret;
do { do {
@ -369,18 +368,17 @@ blisp_return_t blisp_device_flash_erase(struct blisp_device* device,
return 0; return 0;
} }
blisp_return_t blisp_device_flash_write(struct blisp_device* device, int32_t blisp_device_flash_write(struct blisp_device* device,
uint32_t start_address, uint32_t start_address,
uint8_t* payload, uint8_t* payload,
uint32_t payload_size) { uint32_t payload_size) {
// TODO: Add max payload size (8184?) // TODO: Add max payload size (8184?)
// TODO: Don't use malloc + add check // TODO: Don't use malloc + add check
uint8_t* buffer = malloc(4 + payload_size); uint8_t* buffer = malloc(4 + payload_size);
*((uint32_t*)(buffer)) = start_address; *((uint32_t*)(buffer)) = start_address;
memcpy(buffer + 4, payload, payload_size); memcpy(buffer + 4, payload, payload_size);
blisp_return_t ret = int ret = blisp_send_command(device, 0x31, buffer, payload_size + 4, true);
blisp_send_command(device, 0x31, buffer, payload_size + 4, true);
if (ret < 0) if (ret < 0)
goto exit1; goto exit1;
ret = blisp_receive_response(device, false); ret = blisp_receive_response(device, false);
@ -389,7 +387,7 @@ exit1:
return ret; return ret;
} }
blisp_return_t blisp_device_program_check(struct blisp_device* device) { int32_t blisp_device_program_check(struct blisp_device* device) {
int ret = blisp_send_command(device, 0x3A, NULL, 0, true); int ret = blisp_send_command(device, 0x3A, NULL, 0, true);
if (ret < 0) if (ret < 0)
return ret; return ret;
@ -397,11 +395,11 @@ blisp_return_t blisp_device_program_check(struct blisp_device* device) {
if (ret < 0) if (ret < 0)
return ret; return ret;
return BLISP_OK; return 0;
} }
blisp_return_t blisp_device_reset(struct blisp_device* device) { int32_t blisp_device_reset(struct blisp_device* device) {
blisp_return_t ret = blisp_send_command(device, 0x21, NULL, 0, true); int ret = blisp_send_command(device, 0x21, NULL, 0, true);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = blisp_receive_response(device, false); ret = blisp_receive_response(device, false);

43
lib/blisp_easy.c
View File

@ -6,16 +6,12 @@
#include <inttypes.h> #include <inttypes.h>
#include <string.h> #include <string.h>
static blisp_return_t blisp_easy_transport_read( static int64_t blisp_easy_transport_read(struct blisp_easy_transport* transport,
struct blisp_easy_transport* transport, void* buffer,
void* buffer, uint32_t size) {
uint32_t size) {
if (transport->type == 0) { if (transport->type == 0) {
// TODO: Implement reading more than available // TODO: Implement reading more than available
memcpy(buffer, memcpy(buffer, (uint8_t*)transport->data.memory.data_location + transport->data.memory.current_position, size);
(uint8_t*)transport->data.memory.data_location +
transport->data.memory.current_position,
size);
transport->data.memory.current_position += size; transport->data.memory.current_position += size;
return size; return size;
} else { } else {
@ -23,14 +19,13 @@ static blisp_return_t blisp_easy_transport_read(
} }
} }
static blisp_return_t blisp_easy_transport_size( static int64_t blisp_easy_transport_size(struct blisp_easy_transport* transport) {
struct blisp_easy_transport* transport) {
if (transport->type == 0) { if (transport->type == 0) {
return transport->data.memory.data_size; return transport->data.memory.data_size;
} else { } else {
// TODO: Implement // TODO: Implement
printf("%s() Warning: calling non-implemented function\n", __func__); printf("%s() Warning: calling non-implemented function\n", __func__);
return BLISP_ERR_NOT_IMPLEMENTED; return -1;
} }
} }
@ -70,6 +65,7 @@ int32_t blisp_easy_load_segment_data(
const uint16_t buffer_max_size = 4092; const uint16_t buffer_max_size = 4092;
#endif #endif
uint32_t sent_data = 0; uint32_t sent_data = 0;
uint32_t buffer_size = 0; uint32_t buffer_size = 0;
#ifdef _WIN32 #ifdef _WIN32
@ -96,7 +92,7 @@ int32_t blisp_easy_load_segment_data(
sent_data += buffer_size; sent_data += buffer_size;
blisp_easy_report_progress(progress_callback, sent_data, segment_size); blisp_easy_report_progress(progress_callback, sent_data, segment_size);
} }
return BLISP_OK; return 0;
} }
int32_t blisp_easy_load_ram_image( int32_t blisp_easy_load_ram_image(
@ -147,10 +143,10 @@ int32_t blisp_easy_load_ram_image(
return BLISP_OK; return BLISP_OK;
} }
int32_t blisp_easy_load_ram_app( int32_t blisp_easy_load_ram_app(struct blisp_device* device,
struct blisp_device* device, struct blisp_easy_transport* app_transport,
struct blisp_easy_transport* app_transport, blisp_easy_progress_callback progress_callback)
blisp_easy_progress_callback progress_callback) { {
int32_t ret; int32_t ret;
// TODO: Rework // TODO: Rework
// region boot header fill // region boot header fill
@ -297,6 +293,7 @@ int32_t blisp_easy_load_ram_app(
boot_header.crc32 = 0xDEADBEEF; boot_header.crc32 = 0xDEADBEEF;
// endregion // endregion
ret = blisp_device_load_boot_header(device, (uint8_t*)&boot_header); ret = blisp_device_load_boot_header(device, (uint8_t*)&boot_header);
if (ret != BLISP_OK) { if (ret != BLISP_OK) {
blisp_dlog("Failed to load boot header, ret: %d.", ret); blisp_dlog("Failed to load boot header, ret: %d.", ret);
@ -307,9 +304,9 @@ int32_t blisp_easy_load_ram_app(
.dest_addr = device->chip->tcm_address, .dest_addr = device->chip->tcm_address,
.length = blisp_easy_transport_size(app_transport), .length = blisp_easy_transport_size(app_transport),
.reserved = 0, .reserved = 0,
.crc32 = 0}; .crc32 = 0
segment_header.crc32 = crc32_calculate( };
&segment_header, 3 * sizeof(uint32_t)); // TODO: Make function segment_header.crc32 = crc32_calculate(&segment_header, 3 * sizeof(uint32_t)); // TODO: Make function
ret = blisp_device_load_segment_header(device, &segment_header); ret = blisp_device_load_segment_header(device, &segment_header);
if (ret != 0) { if (ret != 0) {
@ -317,14 +314,14 @@ int32_t blisp_easy_load_ram_app(
return ret; return ret;
} }
ret = blisp_easy_load_segment_data(device, ret = blisp_easy_load_segment_data(device, blisp_easy_transport_size(app_transport),
blisp_easy_transport_size(app_transport),
app_transport, progress_callback); app_transport, progress_callback);
if (ret != 0) { if (ret != 0) {
// TODO: Error printing // TODO: Error printing
return ret; return ret;
} }
return BLISP_OK; return BLISP_OK;
} }
@ -334,7 +331,7 @@ int32_t blisp_easy_flash_write(struct blisp_device* device,
uint32_t data_size, uint32_t data_size,
blisp_easy_progress_callback progress_callback) { blisp_easy_progress_callback progress_callback) {
int32_t ret; int32_t ret;
#if defined(__APPLE__) || defined(__FreeBSD__) #if defined (__APPLE__) || defined (__FreeBSD__)
const uint16_t buffer_max_size = 372 * 1; const uint16_t buffer_max_size = 372 * 1;
#else #else
const uint16_t buffer_max_size = 2052; const uint16_t buffer_max_size = 2052;

13
tools/blisp/CMakeLists.txt
View File

@ -1,20 +1,13 @@
set(ARGTABLE3_ENABLE_TESTS OFF CACHE BOOL "Enable unit tests") set(ARGTABLE3_ENABLE_TESTS OFF CACHE BOOL "Enable unit tests")
set(ARGTABLE3_ENABLE_EXAMPLES OFF CACHE BOOL "Enable examples") set(ARGTABLE3_ENABLE_EXAMPLES OFF CACHE BOOL "Enable examples")
#set(ARGTABLE3_REPLACE_GETOPT OFF CACHE BOOL "Replace getopt in the system C library") #set(ARGTABLE3_REPLACE_GETOPT OFF CACHE BOOL "Replace getopt in the system C library")
add_subdirectory(${CMAKE_SOURCE_DIR}/vendor/argtable3 ${CMAKE_CURRENT_BINARY_DIR}/argtable3)
add_executable(blisp src/main.c src/cmd/write.c src/util.c src/common.c src/cmd/iot.c) add_executable(blisp src/main.c src/cmd/write.c src/util.c src/common.c src/cmd/iot.c)
if(BLISP_USE_SYSTEM_LIBRARIES)
find_package(Argtable3 REQUIRED)
else()
add_subdirectory(${CMAKE_SOURCE_DIR}/vendor/argtable3 ${CMAKE_CURRENT_BINARY_DIR}/argtable3)
target_include_directories(blisp PRIVATE
"${CMAKE_SOURCE_DIR}/vendor/argtable3/src")
endif()
target_include_directories(blisp PRIVATE target_include_directories(blisp PRIVATE
"${CMAKE_SOURCE_DIR}/include") "${CMAKE_SOURCE_DIR}/include"
"${CMAKE_SOURCE_DIR}/vendor/argtable3/src")
target_link_libraries(blisp PRIVATE target_link_libraries(blisp PRIVATE
argtable3 argtable3

6
tools/blisp/src/cmd.h
View File

@ -3,11 +3,11 @@
#define BLISP_CMD_H #define BLISP_CMD_H
#include <stdint.h> #include <stdint.h>
#include "error_codes.h"
struct cmd { struct cmd {
const char* name; const char* name;
blisp_return_t (*args_init)(); int8_t (*args_init)();
blisp_return_t (*args_parse_exec)(int argc, char** argv); uint8_t (*args_parse_exec)(int argc, char** argv);
void (*args_print_syntax)(); void (*args_print_syntax)();
void (*args_free)(); void (*args_free)();
}; };

63
tools/blisp/src/cmd/iot.c
View File

@ -1,7 +1,7 @@
#include <argtable3.h>
#include <blisp_easy.h> #include <blisp_easy.h>
#include "../cmd.h" #include "../cmd.h"
#include "../common.h" #include "../common.h"
#include <argtable3.h>
#define REG_EXTENDED 1 #define REG_EXTENDED 1
#define REG_ICASE (REG_EXTENDED << 1) #define REG_ICASE (REG_EXTENDED << 1)
@ -9,21 +9,21 @@
static struct arg_rex* cmd; static struct arg_rex* cmd;
static struct arg_file* single_download; static struct arg_file* single_download;
static struct arg_int* single_download_location; static struct arg_int* single_download_location;
static struct arg_str *port_name, *chip_type; // TODO: Make this common static struct arg_str *port_name, *chip_type; // TODO: Make this common
static struct arg_lit* reset; static struct arg_lit* reset;
static struct arg_end* end; static struct arg_end* end;
static void* cmd_iot_argtable[7]; static void* cmd_iot_argtable[7];
blisp_return_t blisp_single_download() { void blisp_single_download()
{
struct blisp_device device; struct blisp_device device;
blisp_return_t ret; int32_t ret;
ret = blisp_common_init_device(&device, port_name, chip_type); if (blisp_common_init_device(&device, port_name, chip_type) != 0) {
if (ret != BLISP_OK) { return;
return ret;
} }
ret = blisp_common_prepare_flash(&device);
if (ret != BLISP_OK) { if (blisp_common_prepare_flash(&device) != 0) {
// TODO: Error handling // TODO: Error handling
goto exit1; goto exit1;
} }
@ -32,7 +32,6 @@ blisp_return_t blisp_single_download() {
if (data_file == NULL) { if (data_file == NULL) {
fprintf(stderr, "Failed to open data file \"%s\".\n", fprintf(stderr, "Failed to open data file \"%s\".\n",
single_download->filename[0]); single_download->filename[0]);
ret = BLISP_ERR_CANT_OPEN_FILE;
goto exit1; goto exit1;
} }
fseek(data_file, 0, SEEK_END); fseek(data_file, 0, SEEK_END);
@ -40,9 +39,9 @@ blisp_return_t blisp_single_download() {
rewind(data_file); rewind(data_file);
printf("Erasing the area, this might take a while...\n"); printf("Erasing the area, this might take a while...\n");
ret = blisp_device_flash_erase( ret =
&device, *single_download_location->ival, blisp_device_flash_erase(&device, *single_download_location->ival,
*single_download_location->ival + data_file_size + 1); *single_download_location->ival + data_file_size + 1);
if (ret != BLISP_OK) { if (ret != BLISP_OK) {
fprintf(stderr, "Failed to erase.\n"); fprintf(stderr, "Failed to erase.\n");
goto exit2; goto exit2;
@ -52,8 +51,8 @@ blisp_return_t blisp_single_download() {
struct blisp_easy_transport data_transport = struct blisp_easy_transport data_transport =
blisp_easy_transport_new_from_file(data_file); blisp_easy_transport_new_from_file(data_file);
ret = blisp_easy_flash_write(&device, &data_transport, ret = blisp_easy_flash_write(&device, &data_transport, *single_download_location->ival,
*single_download_location->ival, data_file_size, data_file_size,
blisp_common_progress_callback); blisp_common_progress_callback);
if (ret < BLISP_OK) { if (ret < BLISP_OK) {
fprintf(stderr, "Failed to write data to flash.\n"); fprintf(stderr, "Failed to write data to flash.\n");
@ -68,28 +67,21 @@ blisp_return_t blisp_single_download() {
} }
printf("Program OK!\n"); printf("Program OK!\n");
if (reset->count > 0) { // TODO: could be common if (reset->count > 0) { // TODO: could be common
blisp_device_reset(&device);
printf("Resetting the chip.\n"); printf("Resetting the chip.\n");
ret = blisp_device_reset(&device);
if (ret != BLISP_OK) {
fprintf(stderr, "Failed to reset chip.\n");
goto exit2;
}
}
if (ret == BLISP_OK) {
printf("Download complete!\n");
} }
printf("Download complete!\n");
exit2: exit2:
if (data_file != NULL) if (data_file != NULL)
fclose(data_file); fclose(data_file);
exit1: exit1:
blisp_device_close(&device); blisp_device_close(&device);
return ret;
} }
blisp_return_t cmd_iot_args_init() { int8_t cmd_iot_args_init() {
cmd_iot_argtable[0] = cmd = cmd_iot_argtable[0] = cmd =
arg_rex1(NULL, NULL, "iot", NULL, REG_ICASE, NULL); arg_rex1(NULL, NULL, "iot", NULL, REG_ICASE, NULL);
cmd_iot_argtable[1] = chip_type = cmd_iot_argtable[1] = chip_type =
@ -107,9 +99,9 @@ blisp_return_t cmd_iot_args_init() {
if (arg_nullcheck(cmd_iot_argtable) != 0) { if (arg_nullcheck(cmd_iot_argtable) != 0) {
fprintf(stderr, "insufficient memory\n"); fprintf(stderr, "insufficient memory\n");
return BLISP_ERR_OUT_OF_MEMORY; return -1;
} }
return BLISP_OK; return 0;
} }
void cmd_iot_args_print_glossary() { void cmd_iot_args_print_glossary() {
@ -119,19 +111,20 @@ void cmd_iot_args_print_glossary() {
arg_print_glossary(stdout, cmd_iot_argtable, " %-25s %s\n"); arg_print_glossary(stdout, cmd_iot_argtable, " %-25s %s\n");
} }
blisp_return_t cmd_iot_parse_exec(int argc, char** argv) { uint8_t cmd_iot_parse_exec(int argc, char** argv) {
int errors = arg_parse(argc, argv, cmd_iot_argtable); int errors = arg_parse(argc, argv, cmd_iot_argtable);
if (errors == 0) { if (errors == 0) {
if (single_download->count == 1 && single_download_location->count == 1) { if (single_download->count == 1 && single_download_location->count == 1) {
return blisp_single_download(); blisp_single_download();
return 1;
} else { } else {
return BLISP_ERR_INVALID_COMMAND; return 0;
} }
} else if (cmd->count == 1) { } else if (cmd->count == 1) {
cmd_iot_args_print_glossary(); cmd_iot_args_print_glossary();
return BLISP_OK; return 1;
} }
return BLISP_ERR_INVALID_COMMAND; return 0;
} }
void cmd_iot_args_print_syntax() { void cmd_iot_args_print_syntax() {
@ -144,4 +137,4 @@ void cmd_iot_free() {
} }
struct cmd cmd_iot = {"iot", cmd_iot_args_init, cmd_iot_parse_exec, struct cmd cmd_iot = {"iot", cmd_iot_args_init, cmd_iot_parse_exec,
cmd_iot_args_print_syntax, cmd_iot_free}; cmd_iot_args_print_syntax, cmd_iot_free};

31
tools/blisp/src/cmd/write.c
View File

@ -1,14 +1,14 @@
// SPDX-License-Identifier: MIT // SPDX-License-Identifier: MIT
#include <argtable3.h>
#include <blisp.h> #include <blisp.h>
#include <blisp_easy.h>
#include <blisp_struct.h>
#include <inttypes.h> #include <inttypes.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include "../cmd.h" #include "../cmd.h"
#include "../common.h" #include "../common.h"
#include "../util.h" #include "../util.h"
#include <argtable3.h>
#include <blisp_easy.h>
#include <blisp_struct.h>
#define REG_EXTENDED 1 #define REG_EXTENDED 1
#define REG_ICASE (REG_EXTENDED << 1) #define REG_ICASE (REG_EXTENDED << 1)
@ -164,13 +164,12 @@ void fill_up_boot_header(struct bfl_boot_header* boot_header) {
boot_header->crc32 = 0xDEADBEEF; boot_header->crc32 = 0xDEADBEEF;
} }
blisp_return_t blisp_flash_firmware() { void blisp_flash_firmware() {
struct blisp_device device; struct blisp_device device;
blisp_return_t ret; int32_t ret;
ret = blisp_common_init_device(&device, port_name, chip_type);
if (ret != 0) { if (blisp_common_init_device(&device, port_name, chip_type) != 0) {
return ret; return;
} }
if (blisp_common_prepare_flash(&device) != 0) { if (blisp_common_prepare_flash(&device) != 0) {
@ -249,7 +248,7 @@ exit1:
blisp_device_close(&device); blisp_device_close(&device);
} }
blisp_return_t cmd_write_args_init() { int8_t cmd_write_args_init() {
cmd_write_argtable[0] = cmd = cmd_write_argtable[0] = cmd =
arg_rex1(NULL, NULL, "write", NULL, REG_ICASE, NULL); arg_rex1(NULL, NULL, "write", NULL, REG_ICASE, NULL);
cmd_write_argtable[1] = chip_type = cmd_write_argtable[1] = chip_type =
@ -265,9 +264,9 @@ blisp_return_t cmd_write_args_init() {
if (arg_nullcheck(cmd_write_argtable) != 0) { if (arg_nullcheck(cmd_write_argtable) != 0) {
fprintf(stderr, "insufficient memory\n"); fprintf(stderr, "insufficient memory\n");
return BLISP_ERR_OUT_OF_MEMORY; return -1;
} }
return BLISP_OK; return 0;
} }
void cmd_write_args_print_glossary() { void cmd_write_args_print_glossary() {
@ -277,16 +276,16 @@ void cmd_write_args_print_glossary() {
arg_print_glossary(stdout, cmd_write_argtable, " %-25s %s\n"); arg_print_glossary(stdout, cmd_write_argtable, " %-25s %s\n");
} }
blisp_return_t cmd_write_parse_exec(int argc, char** argv) { uint8_t cmd_write_parse_exec(int argc, char** argv) {
int errors = arg_parse(argc, argv, cmd_write_argtable); int errors = arg_parse(argc, argv, cmd_write_argtable);
if (errors == 0) { if (errors == 0) {
return blisp_flash_firmware(); // TODO: Error code? blisp_flash_firmware(); // TODO: Error code?
return 1;
} else if (cmd->count == 1) { } else if (cmd->count == 1) {
cmd_write_args_print_glossary(); cmd_write_args_print_glossary();
return BLISP_OK; return 1;
} }
return BLISP_ERR_INVALID_COMMAND; return 0;
} }
void cmd_write_args_print_syntax() { void cmd_write_args_print_syntax() {

54
tools/blisp/src/common.c
View File

@ -3,26 +3,23 @@
#include <argtable3.h> #include <argtable3.h>
#include <blisp.h> #include <blisp.h>
#include <inttypes.h> #include <inttypes.h>
#include <stdlib.h>
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h>
#include <string.h> #include <string.h>
#include "blisp_easy.h" #include "blisp_easy.h"
#include "error_codes.h"
#include "util.h" #include "util.h"
void blisp_common_progress_callback(uint32_t current_value, void blisp_common_progress_callback(uint32_t current_value, uint32_t max_value) {
uint32_t max_value) {
printf("%" PRIu32 "b / %u (%.2f%%)\n", current_value, max_value, printf("%" PRIu32 "b / %u (%.2f%%)\n", current_value, max_value,
(((float)current_value / (float)max_value) * 100.0f)); (((float)current_value / (float)max_value) * 100.0f));
} }
blisp_return_t blisp_common_init_device(struct blisp_device* device, int32_t blisp_common_init_device(struct blisp_device* device, struct arg_str* port_name, struct arg_str* chip_type)
struct arg_str* port_name, {
struct arg_str* chip_type) {
if (chip_type->count == 0) { if (chip_type->count == 0) {
fprintf(stderr, "Chip type is invalid.\n"); fprintf(stderr, "Chip type is invalid.\n");
return BLISP_ERR_INVALID_CHIP_TYPE; return -1;
} }
struct blisp_chip* chip = NULL; struct blisp_chip* chip = NULL;
@ -33,46 +30,44 @@ blisp_return_t blisp_common_init_device(struct blisp_device* device,
chip = &blisp_chip_bl60x; chip = &blisp_chip_bl60x;
} else { } else {
fprintf(stderr, "Chip type is invalid.\n"); fprintf(stderr, "Chip type is invalid.\n");
return BLISP_ERR_INVALID_CHIP_TYPE; return -1;
} }
blisp_return_t ret; int32_t ret;
ret = blisp_device_init(device, chip); ret = blisp_device_init(device, chip);
if (ret != BLISP_OK) { if (ret != BLISP_OK) {
fprintf(stderr, "Failed to init device.\n"); fprintf(stderr, "Failed to init device.\n");
return ret; return -1;
} }
ret = blisp_device_open(device, ret = blisp_device_open(device,
port_name->count == 1 ? port_name->sval[0] : NULL); port_name->count == 1 ? port_name->sval[0] : NULL);
if (ret != BLISP_OK) { if (ret != BLISP_OK) {
fprintf(stderr, ret == BLISP_ERR_DEVICE_NOT_FOUND fprintf(stderr, ret == BLISP_ERR_DEVICE_NOT_FOUND ? "Device not found\n" : "Failed to open device.\n");
? "Device not found\n" return -1;
: "Failed to open device.\n");
return ret;
} }
return BLISP_OK; return 0;
} }
/** /**
* Prepares chip to access flash * Prepares chip to access flash
* this means performing handshake, and loading eflash_loader if needed. * this means performing handshake, and loading eflash_loader if needed.
*/ */
blisp_return_t blisp_common_prepare_flash(struct blisp_device* device) { int32_t blisp_common_prepare_flash(struct blisp_device* device) {
blisp_return_t ret = 0; int32_t ret = 0;
printf("Sending a handshake...\n"); printf("Sending a handshake...\n");
ret = blisp_device_handshake(device, false); ret = blisp_device_handshake(device, false);
if (ret != BLISP_OK) { if (ret != BLISP_OK) {
fprintf(stderr, "Failed to handshake with device.\n"); fprintf(stderr, "Failed to handshake with device.\n");
return ret; return -1;
} }
printf("Handshake successful!\nGetting chip info...\n"); printf("Handshake successful!\nGetting chip info...\n");
struct blisp_boot_info boot_info; struct blisp_boot_info boot_info;
ret = blisp_device_get_boot_info(device, &boot_info); ret = blisp_device_get_boot_info(device, &boot_info);
if (ret != BLISP_OK) { if (ret != BLISP_OK) {
fprintf(stderr, "Failed to get boot info.\n"); fprintf(stderr, "Failed to get boot info.\n");
return ret; return -1;
} }
printf( printf(
@ -85,7 +80,7 @@ blisp_return_t blisp_common_prepare_flash(struct blisp_device* device) {
boot_info.chip_id[6], boot_info.chip_id[7]); boot_info.chip_id[6], boot_info.chip_id[7]);
if (device->chip->load_eflash_loader == NULL) { if (device->chip->load_eflash_loader == NULL) {
return BLISP_OK; return 0;
} }
if (boot_info.boot_rom_version[0] == 255 && if (boot_info.boot_rom_version[0] == 255 &&
@ -93,24 +88,21 @@ blisp_return_t blisp_common_prepare_flash(struct blisp_device* device) {
boot_info.boot_rom_version[2] == 255 && boot_info.boot_rom_version[2] == 255 &&
boot_info.boot_rom_version[3] == 255) { boot_info.boot_rom_version[3] == 255) {
printf("Device already in eflash_loader.\n"); printf("Device already in eflash_loader.\n");
return BLISP_OK; return 0;
} }
uint8_t* eflash_loader_buffer = NULL; uint8_t* eflash_loader_buffer = NULL;
// TODO: Error check // TODO: Error check
int64_t eflash_loader_buffer_length = int64_t eflash_loader_buffer_length = device->chip->load_eflash_loader(0, &eflash_loader_buffer);
device->chip->load_eflash_loader(0, &eflash_loader_buffer);
struct blisp_easy_transport eflash_loader_transport = struct blisp_easy_transport eflash_loader_transport =
blisp_easy_transport_new_from_memory(eflash_loader_buffer, blisp_easy_transport_new_from_memory(eflash_loader_buffer, eflash_loader_buffer_length);
eflash_loader_buffer_length);
ret = blisp_easy_load_ram_app(device, &eflash_loader_transport, ret = blisp_easy_load_ram_app(device, &eflash_loader_transport, blisp_common_progress_callback);
blisp_common_progress_callback);
if (ret != BLISP_OK) { if (ret != BLISP_OK) {
fprintf(stderr, "Failed to load eflash_loader, ret: %d\n", ret); fprintf(stderr, "Failed to load eflash_loader, ret: %d\n", ret);
ret = -1;
goto exit1; goto exit1;
} }
@ -120,12 +112,14 @@ blisp_return_t blisp_common_prepare_flash(struct blisp_device* device) {
ret = blisp_device_check_image(device); ret = blisp_device_check_image(device);
if (ret != 0) { if (ret != 0) {
fprintf(stderr, "Failed to check image.\n"); fprintf(stderr, "Failed to check image.\n");
ret = -1;
goto exit1; goto exit1;
} }
ret = blisp_device_run_image(device); ret = blisp_device_run_image(device);
if (ret != BLISP_OK) { if (ret != BLISP_OK) {
fprintf(stderr, "Failed to run image.\n"); fprintf(stderr, "Failed to run image.\n");
ret = -1;
goto exit1; goto exit1;
} }
@ -133,12 +127,12 @@ blisp_return_t blisp_common_prepare_flash(struct blisp_device* device) {
ret = blisp_device_handshake(device, true); ret = blisp_device_handshake(device, true);
if (ret != BLISP_OK) { if (ret != BLISP_OK) {
fprintf(stderr, "Failed to handshake with device.\n"); fprintf(stderr, "Failed to handshake with device.\n");
ret = -1;
goto exit1; goto exit1;
} }
printf("Handshake with eflash_loader successful.\n"); printf("Handshake with eflash_loader successful.\n");
exit1: exit1:
if (eflash_loader_buffer != NULL) if (eflash_loader_buffer != NULL)
free(eflash_loader_buffer); free(eflash_loader_buffer);
return ret; return ret;
} }

42
tools/blisp/src/main.c
View File

@ -14,7 +14,7 @@ static struct arg_lit* version;
static struct arg_end* end; static struct arg_end* end;
static void* argtable[3]; static void* argtable[3];
blisp_return_t args_init() { int8_t args_init() {
argtable[0] = help = arg_lit0(NULL, "help", "print this help and exit"); argtable[0] = help = arg_lit0(NULL, "help", "print this help and exit");
argtable[1] = version = argtable[1] = version =
arg_lit0(NULL, "version", "print version information and exit"); arg_lit0(NULL, "version", "print version information and exit");
@ -22,10 +22,10 @@ blisp_return_t args_init() {
if (arg_nullcheck(argtable) != 0) { if (arg_nullcheck(argtable) != 0) {
fprintf(stderr, "insufficient memory\n"); fprintf(stderr, "insufficient memory\n");
return BLISP_ERR_OUT_OF_MEMORY; return -1;
} }
return BLISP_OK; return 0;
} }
void print_help() { void print_help() {
@ -43,14 +43,14 @@ int8_t args_parse_exec(int argc, char** argv) {
if (error == 0) { if (error == 0) {
if (help->count) { if (help->count) {
print_help(); print_help();
return BLISP_OK; return 1;
} else if (version->count) { } else if (version->count) {
printf("blisp v0.0.3\n"); printf("blisp v0.0.3\n");
printf("Copyright (C) 2023 Marek Kraus and PINE64 Community\n"); printf("Copyright (C) 2023 Marek Kraus and PINE64 Community\n");
return BLISP_OK; return 1;
} }
} }
return BLISP_ERR_INVALID_COMMAND; return 0;
} }
void args_free() { void args_free() {
@ -58,29 +58,27 @@ void args_free() {
} }
int main(int argc, char** argv) { int main(int argc, char** argv) {
blisp_return_t ret = args_init(); int exit_code = 0;
if (ret != 0) {
if (args_init() != 0) {
exit_code = -1;
goto exit; goto exit;
} }
for (uint8_t i = 0; i < cmds_count; i++) { for (uint8_t i = 0; i < cmds_count; i++) {
ret = cmds[i]->args_init(); if (cmds[i]->args_init() != 0) {
if (ret != BLISP_OK) { exit_code = -1;
goto exit;
}
}
// Try and parse as a help request
{
ret = args_parse_exec(argc, argv);
if (ret == BLISP_OK) {
goto exit; goto exit;
} }
} }
if (args_parse_exec(argc, argv)) {
goto exit;
}
uint8_t command_found = false; uint8_t command_found = false;
for (uint8_t i = 0; i < cmds_count; i++) { for (uint8_t i = 0; i < cmds_count; i++) {
ret = cmds[i]->args_parse_exec(argc, argv); if (cmds[i]->args_parse_exec(argc, argv)) {
if (ret != BLISP_ERR_INVALID_COMMAND) {
command_found = true; command_found = true;
break; break;
} }
@ -95,9 +93,5 @@ exit:
cmds[i]->args_free(); cmds[i]->args_free();
} }
args_free(); args_free();
// Make error codes more intuitive, but converting to +ve mirror return exit_code;
if (ret < 0) {
ret = -ret;
}
return ret;
} }