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

Start migration to error codes enum

Browse Source
This commit is contained in:
Ben V. Brown 2023-05-09 07:39:34 +10:00
parent 179a4ea267
commit fced48570a
3 changed files with 86 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
lib/blisp.c
View File

@ -19,15 +19,16 @@ static void drain(struct sp_port* port) {
#endif #endif
} }
int32_t blisp_device_init(struct blisp_device* device, blisp_return_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 0; return BLISP_OK;
} }
int32_t blisp_device_open(struct blisp_device* device, const char* port_name) { blisp_return_t blisp_device_open(struct blisp_device* device,
int ret; const char* port_name) {
blisp_return_t ret;
struct sp_port* serial_port = NULL; struct sp_port* serial_port = NULL;
if (port_name != NULL) { if (port_name != NULL) {
@ -69,8 +70,7 @@ int32_t blisp_device_open(struct blisp_device* device, const char* port_name) {
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_UNKNOWN; // TODO: Maybe this should be that it can't open return BLISP_ERR_CANT_OPEN_DEVICE;
// 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
@ -107,7 +107,7 @@ int32_t blisp_device_open(struct blisp_device* device, const char* port_name) {
return BLISP_OK; return BLISP_OK;
} }
int32_t blisp_send_command(struct blisp_device* device, blisp_return_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,
@ -141,7 +141,7 @@ int32_t blisp_send_command(struct blisp_device* device,
return BLISP_OK; return BLISP_OK;
} }
int32_t blisp_receive_response(struct blisp_device* device, blisp_return_t blisp_receive_response(struct blisp_device* device,
bool expect_payload) { bool expect_payload) {
// TODO: Check checksum // TODO: Check checksum
int ret; int ret;
@ -174,7 +174,8 @@ int32_t blisp_receive_response(struct blisp_device* device,
return BLISP_ERR_UNKNOWN; return BLISP_ERR_UNKNOWN;
} }
int32_t blisp_device_handshake(struct blisp_device* device, bool in_ef_loader) { blisp_return_t blisp_device_handshake(struct blisp_device* device,
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;
@ -221,15 +222,14 @@ int32_t blisp_device_handshake(struct blisp_device* device, bool in_ef_loader) {
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;
} }
int32_t blisp_device_get_boot_info(struct blisp_device* device, blisp_return_t blisp_device_get_boot_info(struct blisp_device* device,
struct blisp_boot_info* boot_info) { struct blisp_boot_info* boot_info) {
int ret; blisp_return_t 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,7 +240,8 @@ int32_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 4); // TODO: Endianess; this may break on big endian machines
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);
} }
@ -249,9 +250,9 @@ int32_t blisp_device_get_boot_info(struct blisp_device* device,
} }
// TODO: Use struct instead of uint8_t* // TODO: Use struct instead of uint8_t*
int32_t blisp_device_load_boot_header(struct blisp_device* device, blisp_return_t blisp_device_load_boot_header(struct blisp_device* device,
uint8_t* boot_header) { uint8_t* boot_header) {
int ret; blisp_return_t 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;
@ -262,10 +263,10 @@ int32_t blisp_device_load_boot_header(struct blisp_device* device,
return BLISP_OK; return BLISP_OK;
} }
int32_t blisp_device_load_segment_header( blisp_return_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) {
int ret; blisp_return_t 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;
@ -276,10 +277,10 @@ int32_t blisp_device_load_segment_header(
return BLISP_OK; return BLISP_OK;
} }
int32_t blisp_device_load_segment_data(struct blisp_device* device, blisp_return_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) {
int ret; blisp_return_t 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)
@ -291,8 +292,8 @@ int32_t blisp_device_load_segment_data(struct blisp_device* device,
return BLISP_OK; return BLISP_OK;
} }
int32_t blisp_device_check_image(struct blisp_device* device) { blisp_return_t blisp_device_check_image(struct blisp_device* device) {
int ret; blisp_return_t 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;
@ -303,11 +304,11 @@ int32_t blisp_device_check_image(struct blisp_device* device) {
return BLISP_OK; return BLISP_OK;
} }
int32_t blisp_device_write_memory(struct blisp_device* device, blisp_return_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) {
int ret; blisp_return_t 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
@ -323,8 +324,8 @@ int32_t blisp_device_write_memory(struct blisp_device* device,
return BLISP_OK; return BLISP_OK;
} }
int32_t blisp_device_run_image(struct blisp_device* device) { blisp_return_t blisp_device_run_image(struct blisp_device* device) {
int ret; blisp_return_t 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);
@ -351,14 +352,14 @@ int32_t blisp_device_run_image(struct blisp_device* device) {
return BLISP_OK; return BLISP_OK;
} }
int32_t blisp_device_flash_erase(struct blisp_device* device, blisp_return_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;
int ret = blisp_send_command(device, 0x30, payload, 8, true); blisp_return_t ret = blisp_send_command(device, 0x30, payload, 8, true);
if (ret < 0) if (ret < 0)
return ret; return ret;
do { do {
@ -368,7 +369,7 @@ int32_t blisp_device_flash_erase(struct blisp_device* device,
return 0; return 0;
} }
int32_t blisp_device_flash_write(struct blisp_device* device, blisp_return_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) {
@ -378,7 +379,8 @@ int32_t blisp_device_flash_write(struct blisp_device* device,
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);
int ret = blisp_send_command(device, 0x31, buffer, payload_size + 4, true); blisp_return_t ret =
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);
@ -387,7 +389,7 @@ exit1:
return ret; return ret;
} }
int32_t blisp_device_program_check(struct blisp_device* device) { blisp_return_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;
@ -395,11 +397,11 @@ int32_t blisp_device_program_check(struct blisp_device* device) {
if (ret < 0) if (ret < 0)
return ret; return ret;
return 0; return BLISP_OK;
} }
int32_t blisp_device_reset(struct blisp_device* device) { blisp_return_t blisp_device_reset(struct blisp_device* device) {
int ret = blisp_send_command(device, 0x21, NULL, 0, true); blisp_return_t 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);

15
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,12 +164,13 @@ void fill_up_boot_header(struct bfl_boot_header* boot_header) {
boot_header->crc32 = 0xDEADBEEF; boot_header->crc32 = 0xDEADBEEF;
} }
void blisp_flash_firmware() { blisp_return_t blisp_flash_firmware() {
struct blisp_device device; struct blisp_device device;
int32_t ret; blisp_return_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 != 0) {
return; return ret;
} }
if (blisp_common_prepare_flash(&device) != 0) { if (blisp_common_prepare_flash(&device) != 0) {

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

@ -3,23 +3,26 @@
#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, uint32_t max_value) { void blisp_common_progress_callback(uint32_t current_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));
} }
int32_t blisp_common_init_device(struct blisp_device* device, struct arg_str* port_name, struct arg_str* chip_type) blisp_return_t blisp_common_init_device(struct blisp_device* device,
{ 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 -1; return BLISP_ERR_INVALID_CHIP_TYPE;
} }
struct blisp_chip* chip = NULL; struct blisp_chip* chip = NULL;
@ -30,23 +33,25 @@ int32_t blisp_common_init_device(struct blisp_device* device, struct arg_str* po
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 -1; return BLISP_ERR_INVALID_CHIP_TYPE;
} }
int32_t ret; blisp_return_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 -1; return ret;
} }
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 ? "Device not found\n" : "Failed to open device.\n"); fprintf(stderr, ret == BLISP_ERR_DEVICE_NOT_FOUND
return -1; ? "Device not found\n"
: "Failed to open device.\n");
return ret;
} }
return 0; return BLISP_OK;
} }
/** /**
@ -93,12 +98,15 @@ int32_t blisp_common_prepare_flash(struct blisp_device* device) {
uint8_t* eflash_loader_buffer = NULL; uint8_t* eflash_loader_buffer = NULL;
// TODO: Error check // TODO: Error check
int64_t eflash_loader_buffer_length = device->chip->load_eflash_loader(0, &eflash_loader_buffer); int64_t eflash_loader_buffer_length =
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, eflash_loader_buffer_length); blisp_easy_transport_new_from_memory(eflash_loader_buffer,
eflash_loader_buffer_length);
ret = blisp_easy_load_ram_app(device, &eflash_loader_transport, blisp_common_progress_callback); ret = blisp_easy_load_ram_app(device, &eflash_loader_transport,
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);