Parse targets

Just grabbing first one for now
Expose crc
2025-08-21 11:00:52 +00:00 · 2022-09-26 22:20:50 +10:00 · 2022-09-26 22:20:30 +10:00 · 2022-09-26 22:20:05 +10:00 · 2022-09-26 21:40:04 +10:00 · 2022-09-26 21:22:05 +10:00
43 changed files with 361 additions and 10492 deletions
--- a/.clang-format
+++ b/.clang-format
@ -1,4 +1,58 @@
 ---
-BasedOnStyle: Chromium
+Language: Cpp
 BasedOnStyle: GNU
 IndentWidth: 4
 AllowShortBlocksOnASingleLine: Empty
 AllowShortFunctionsOnASingleLine: None
 BreakBeforeBraces: Custom
 BraceWrapping:
  AfterFunction: false
  AfterCaseLabel: false
  AfterEnum: false
  AfterControlStatement: Never
  AfterStruct : false
  AfterUnion : false
  AfterExternBlock : false
  BeforeElse : false
  BeforeWhile : false
 AlignAfterOpenBracket: Align
 AlignArrayOfStructures: Left
 AlignEscapedNewlines: Right
 AlignOperands: Align
 AllowShortEnumsOnASingleLine: False
 AllowShortIfStatementsOnASingleLine: Never
 AllowShortLoopsOnASingleLine : false
 AlwaysBreakAfterReturnType: AllDefinitions
 AlignTrailingComments : true
 AlignConsecutiveMacros: AcrossEmptyLines
 KeepEmptyLinesAtTheStartOfBlocks : false
 PointerAlignment : Left
 QualifierAlignment : Left
 ReferenceAlignment : Left
 RemoveBracesLLVM : false
 SpaceAfterCStyleCast : false
 SpaceAfterLogicalNot : false
 SpaceAfterTemplateKeyword : false
 SpaceAroundPointerQualifiers : Before
 SpaceBeforeAssignmentOperators : true
 SpaceBeforeCaseColon : false
 SpaceBeforeCpp11BracedList : false
 SpaceBeforeParens : ControlStatements
 SpaceBeforeParensOptions :
  AfterControlStatements : true
  AfterFunctionDeclarationName : false
  AfterFunctionDefinitionName : false
  AfterOverloadedOperator : false
 SpaceBeforeRangeBasedForLoopColon : false
 SpaceBeforeSquareBrackets : false
 SpaceInEmptyBlock : false
 SpaceInEmptyParentheses : false
 SpacesInCStyleCastParentheses : false
 SpacesInConditionalStatement : false
 SpacesInContainerLiterals : false
 SpacesInParentheses: false
 SpacesInSquareBrackets : false
 UseTab : Never
-...
+BitFieldColonSpacing: None
 BreakBeforeBinaryOperators: All
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@ -1,141 +0,0 @@
 name: Build
 on: [push, pull_request]
 jobs:
  build-windows:
    runs-on: windows-2022
    defaults:
      run:
        shell: cmd
    steps:
      - uses: actions/checkout@v3
        with:
          submodules: 'recursive'
      - uses: lukka/get-cmake@latest
      - name: Build blisp tool
        run: |
          mkdir build
          cd build
          cmake .. -DBLISP_BUILD_CLI=ON -DCMAKE_BUILD_TYPE=Release
          cmake --build . --config Release
      - name: Upload results
        uses: actions/upload-artifact@v3
        with:
          name: blips-windows-x86_64.zip
          path: |
            build/tools/blisp/Release/blisp.exe
          if-no-files-found: error
  build-macos:
    runs-on: macos-latest
    steps:
      - uses: actions/checkout@v3
        with:
          submodules: 'recursive'
      - uses: lukka/get-cmake@latest
      - name: Build blisp tool
        run: |
          mkdir build
          cd build
          cmake .. -DBLISP_BUILD_CLI=ON -DCMAKE_BUILD_TYPE=Release
          cmake --build .
      - name: Upload results
        uses: actions/upload-artifact@v3
        with:
          name: blips-apple-x86_64.zip
          path: |
            build/tools/blisp/blisp
          if-no-files-found: error
  build-linux:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
        with:
          submodules: 'recursive'
      - uses: lukka/get-cmake@latest
      - name: Build blisp tool
        run: |
          mkdir build
          cd build
          cmake .. -DBLISP_BUILD_CLI=ON -DCMAKE_BUILD_TYPE=Release
          cmake --build .
      - name: Upload results
        uses: actions/upload-artifact@v3
        with:
          name: blips-linux-x86_64.zip
          path: |
            build/tools/blisp/blisp
          if-no-files-found: error 
  build-linux-alternative-arch:
    runs-on: ubuntu-latest
    name: Build on ${{ matrix.distro }} ${{ matrix.arch }}
    # Run steps on a matrix of 4 arch/distro combinations
    strategy:
      matrix:
        include:
          - arch: aarch64
            distro: ubuntu_latest
          - arch: armv7
            distro: ubuntu_latest
          - arch: riscv64
            distro: ubuntu_latest
    steps:
      - uses: actions/checkout@v3
        with:
          submodules: 'recursive'
      - uses: uraimo/run-on-arch-action@v2
        name: Build artifact
        id: build
        with:
          arch: ${{ matrix.arch }}
          distro: ${{ matrix.distro }}
          # Create an artifacts directory
          setup: |
            mkdir -p "${PWD}/artifacts"
          # Mount the artifacts directory as /artifacts in the container
          dockerRunArgs: |
            --volume "${PWD}/artifacts:/artifacts"
          # Pass some environment variables to the container
          env: | # YAML, but pipe character is necessary
            artifact_name: blisp-linux-${{ matrix.arch }}
          # The shell to run commands with in the container
          shell: /bin/sh
          # Install some dependencies in the container. This speeds up builds if
          # you are also using githubToken. Any dependencies installed here will
          # be part of the container image that gets cached, so subsequent
          # builds don't have to re-install them. The image layer is cached
          # publicly in your project's package repository, so it is vital that
          # no secrets are present in the container state or logs.
          install: |
            case "${{ matrix.distro }}" in
              ubuntu*|jessie|stretch|buster|bullseye)
                apt-get update -q -y
                apt-get install -q -y git cmake build-essential
                ;;
            esac
          # Produce a binary artifact and place it in the mounted volume
          run: |
            git config --global --add safe.directory /home/runner/work/blisp/blisp
            mkdir build
            cd build
            cmake .. -DBLISP_BUILD_CLI=ON -DCMAKE_BUILD_TYPE=Release
            cmake --build . -j2
            cp ./tools/blisp/blisp "/artifacts/${artifact_name}"
            echo "Produced artifact at /artifacts/${artifact_name}"
      - name: Upload results
        uses: actions/upload-artifact@v3
        with:
          name: blisp-linux-${{ matrix.arch }}.zip
          path: |
            artifacts/blisp-*
          if-no-files-found: error 
--- a/.gitignore
+++ b/.gitignore
@ -75,6 +75,3 @@ fabric.properties
 # Android studio 3.1+ serialized cache file
 .idea/caches/build_file_checksums.ser
 build/
 .DS_Store
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -4,13 +4,11 @@ set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 set(CMAKE_C_STANDARD 23)
 option(BLISP_BUILD_CLI "Build CLI Tool" OFF)
 option(BLISP_USE_SYSTEM_LIBRARIES "Use system-installed libraries" "${CMAKE_USE_SYSTEM_LIBRARIES}")
 option(COMPILE_TESTS "Compile the tests" OFF)
 add_library(libblisp_obj OBJECT
        lib/blisp.c
-        lib/chip/blisp_chip_bl60x.c
+        lib/chip/blisp_chip_bl70x.c)
        lib/chip/blisp_chip_bl70x.c lib/blisp_easy.c)
 target_include_directories(libblisp_obj PRIVATE ${CMAKE_SOURCE_DIR}/include/)
@ -19,79 +17,42 @@ set_property(TARGET libblisp_obj PROPERTY POSITION_INDEPENDENT_CODE 1)
 add_library(libblisp SHARED $<TARGET_OBJECTS:libblisp_obj>)
 add_library(libblisp_static STATIC $<TARGET_OBJECTS:libblisp_obj>)
 set(BLISP_PUBLIC_HEADERS
    include/blisp.h
    include/blisp_easy.h
    include/blisp_chip.h
    include/blisp_struct.h
    include/blisp_util.h)
 set_target_properties(libblisp PROPERTIES
-        PUBLIC_HEADER "${BLISP_PUBLIC_HEADERS}"
+        PUBLIC_HEADER "include/blisp.h"
-        VERSION 0.0.3
+        VERSION 1.0
        SOVERSION 1
        LIBRARY_OUTPUT_DIRECTORY "shared"
        OUTPUT_NAME "blisp")
 set_target_properties(libblisp_static PROPERTIES
-        PUBLIC_HEADER "${BLISP_PUBLIC_HEADERS}"
+        PUBLIC_HEADER "include/blisp.h"
-        VERSION 0.0.3
+        VERSION 1.0
        SOVERSION 1
        ARCHIVE_OUTPUT_DIRECTORY "static"
        OUTPUT_NAME "blisp")
-if(BLISP_USE_SYSTEM_LIBRARIES)
+target_sources(libblisp_obj PRIVATE
    find_package(PkgConfig)
    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/timing.c)
-	target_include_directories(libblisp_obj PRIVATE ${CMAKE_SOURCE_DIR}/vendor/libserialport)
+if(WIN32)
-	endif()
+    target_link_libraries(libblisp_obj PRIVATE Setupapi.lib)
-
+    target_compile_definitions(libblisp_obj PRIVATE LIBSERIALPORT_MSBUILD)
-    if(WIN32)
+    target_sources(libblisp_obj PRIVATE
-        target_link_libraries(libblisp PRIVATE Setupapi.lib)
+            ${CMAKE_SOURCE_DIR}/vendor/libserialport/windows.c)
-        target_link_libraries(libblisp_static PRIVATE Setupapi.lib)
+elseif(UNIX AND NOT APPLE)
-        target_compile_definitions(libblisp_obj PRIVATE LIBSERIALPORT_MSBUILD)
+    target_sources(libblisp_obj PRIVATE
-        target_sources(libblisp_obj PRIVATE
+            ${CMAKE_SOURCE_DIR}/vendor/libserialport/linux.c
-                ${CMAKE_SOURCE_DIR}/vendor/libserialport/windows.c)
+            ${CMAKE_SOURCE_DIR}/vendor/libserialport/linux_termios.c)
-    elseif(UNIX AND NOT APPLE AND NOT ${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
+    target_compile_definitions(libblisp_obj PRIVATE
-        target_sources(libblisp_obj PRIVATE
+            LIBSERIALPORT_ATBUILD
-                ${CMAKE_SOURCE_DIR}/vendor/libserialport/linux.c
+            "SP_API=__attribute__((visibility(\"default\")))"
-                ${CMAKE_SOURCE_DIR}/vendor/libserialport/linux_termios.c)
+            "SP_PRIV=__attribute__((visibility(\"hidden\")))")
-        target_compile_definitions(libblisp_obj PRIVATE
+    target_include_directories(libblisp_obj PRIVATE ${CMAKE_SOURCE_DIR}/vendor/libserialport)
-                LIBSERIALPORT_ATBUILD
+    write_file(${CMAKE_SOURCE_DIR}/vendor/libserialport/config.h "// bypass errors.")
                HAVE_TERMIOS2_SPEED
                HAVE_STRUCT_TERMIOS2
                HAVE_DECL_BOTHER
                "SP_API=__attribute__((visibility(\"default\")))"
                "SP_PRIV=__attribute__((visibility(\"hidden\")))")
        write_file(${CMAKE_SOURCE_DIR}/vendor/libserialport/config.h "// bypass errors.")
    elseif(UNIX AND ${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
        target_include_directories(libblisp_obj PRIVATE /usr/local/include/)
        target_link_libraries(libblisp PRIVATE -L/usr/local/lib usb serialport)
        target_link_libraries(libblisp_static PRIVATE -L/usr/local/lib usb serialport)
    elseif(APPLE)
        target_sources(libblisp_obj PRIVATE
                ${CMAKE_SOURCE_DIR}/vendor/libserialport/macosx.c)
        target_link_libraries(libblisp PRIVATE "-framework IOKit" "-framework CoreFoundation")
        target_compile_definitions(libblisp_obj PRIVATE
                LIBSERIALPORT_ATBUILD
                "SP_PRIV=__attribute__((visibility(\"hidden\")))"
                "SP_API=__attribute__((visibility(\"default\")))")
        target_include_directories(libblisp_obj PRIVATE ${CMAKE_SOURCE_DIR}/vendor/libserialport)
        write_file(${CMAKE_SOURCE_DIR}/vendor/libserialport/config.h "// bypass errors.")
    endif()
 endif()
 install(TARGETS libblisp libblisp_static DESTINATION lib)
 if(BLISP_BUILD_CLI)
    add_subdirectory(tools/blisp)
 endif()
--- a/21
+++ b/21
@ -1,21 +0,0 @@
 MIT License
 Copyright (c) 2022 Marek Kraus <gamelaster@outlook.com>
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE. 
--- a/README.md
+++ b/README.md
@ -1,96 +1,17 @@
-[![Hits](https://hits.seeyoufarm.com/api/count/incr/badge.svg?url=https%3A%2F%2Fgithub.com%2Fpine64%2Fblisp&count_bg=%235791AC&title_bg=%23555555&icon=airplayaudio.svg&icon_color=%23D2D9DD&title=hits&edge_flat=false)](https://github.com/pine64/blisp/wiki/Update-Pinecil-V2)
+# Bouffalo Labs ISP tool & library
 [![GitHub all downloads](https://img.shields.io/github/downloads/pine64/blisp/total?color=5791ac&logo=docusign&logoColor=white)](https://github.com/pine64/blisp/releases/tag/v0.0.3)
 [![Discord](https://img.shields.io/discord/463237927984693259?color=5791ac&logo=discord&logoColor=white)](https://discord.com/invite/pine64)
 [![GitHub release](https://img.shields.io/github/v/release/pine64/blisp?color=5791ac)](https://github.com/pine64/blisp/releases/tag/v0.0.3)
-<img src="./img/Gradient-white-blue-03.png" align="left" width="60" > <br clear="left" />
+Tool and library for flashing their RISC-V MCUs.
 # BLISP 
-Bouffalo Labs ISP (in-system-programming) tool & library: an open source tool to flash Bouffalo RISC-V MCUs.
+# Supported MCUs
-**NOTE:** Library API and `blisp` tool cli arguments are not stable yet.
+- [ ] BL602 / BL604
-<br>
+- [X] BL702 / BL704 / BL706
 - [ ] BL606P
 - [ ] BL616 / BL618
 - [ ] BL808
-## Supported MCUs
+# To Do
 - [x] `bl60x` - BL602 / BL604 / TG7100C / LF686 / LF688
 - [x] `bl70x` - BL702 / BL704 / BL706
 <br>
-## Supported Devices 
+- [ ] Another code style
- | System  | <img width="15" src="https://cdn.simpleicons.org/Windows11/5791ac" /> Windows | <img width="15" src="https://cdn.simpleicons.org/Apple/5791ac" /> MacOS| <img width="17" src="https://cdn.simpleicons.org/Linux/5791ac" /> Linux| <img width="15" src="https://cdn.simpleicons.org/Freebsd/5791ac" /> FreeBSD |
+- [ ] Finalize API
- | :-----: | :------: | :------: | :------: | :------: |
+- [ ] SDIO and JTAG support
 | Pinecil V2  |<img width="22" src="https://cdn.simpleicons.org/cachet/5791ac" />|<img width="22" src="https://cdn.simpleicons.org/cachet/5791ac" />| <img width="22" src="https://cdn.simpleicons.org/cachet/5791ac" />| <img width="22" src="https://cdn.simpleicons.org/cachet/5791ac" /> |
 | Pinecone  |<img width="22" src="https://cdn.simpleicons.org/cachet/5791ac" />|<img width="22" src="https://cdn.simpleicons.org/cachet/5791ac" />|<img width="22" src="https://cdn.simpleicons.org/cachet/5791ac" />| <img width="22" src="https://cdn.simpleicons.org/cachet/5791ac" /> |
 <br>
 ## How to update Pinecil V2
 Download the newest release of [Blisp updater here](https://github.com/pine64/blisp/releases/).
 Check out the [wiki page](https://github.com/pine64/blisp/wiki/Update-Pinecil-V2) for install instructions.
 <br><br>
 ## Building from code
 ### Clone repository
 If you have not cloned this repository locally; clone the git repository locally by running
 ```bash
 git clone --recursive https://github.com/pine64/blisp.git
 cd blisp
 git submodule update --init --recursive
 ```
 If vendor/argtable3 and vendor/libserialport/ are empty, this last step has
 failed and should be investigated.
 ### Build the library and command line utility
 For building `blisp` command line tool, use following commands:
 ```bash
 mkdir build && cd build
 cmake -DBLISP_BUILD_CLI=ON ..
 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).
 ## Usage
 For BL70X, BL61X, BL808 and BL606P, connected via USB, you can use following command, which will auto-detect serial port on Windows:
 ```bash
 .\blisp.exe write --chip=bl70x --reset .\name_of_firmware.bin
 or
 .\blisp.exe write -c bl70x --reset .\name_of_firmware.bin
 ```
 For BL60X, you need to specify also the serial port path:
 ```bash
 blisp write --chip bl60x --reset -p /dev/ttyUSB0 name_of_firmware.bin
 ```
 If you wish to see additional debugging, set the environmental
 variable LIBSERIALPORT_DEBUG before running. You can either export this
 in your shell or change it for a single run via
 ```bash
  LIBSERIALPORT_DEBUG=y ./a.out write -c bl70x -p /dev/tty.usbmodem0000000200001
 ```
 Because this is done at the lowest level of serial communication, the
 displays aren't packet-aware or know about the chip's command set or such.
 This is really only useful for debugging systems-level issues withing
 the device or blisp itself.
--- a/data/bl60x_eflash_loader.h
+++ b/data/bl60x_eflash_loader.h
--- a/data/bl70x_eflash_loader.h
+++ b/data/bl70x_eflash_loader.h
--- a/img/Gradient-white-blue-03.png
+++ b/img/Gradient-white-blue-03.png
--- a/include/blisp.h
+++ b/include/blisp.h
@ -1,64 +1,29 @@
 // SPDX-License-Identifier: MIT
 #ifndef _LIBBLISP_H
 #define _LIBBLISP_H
 #include <stdint.h>
 #include "blisp_chip.h"
 #include "error_codes.h"
-struct blisp_segment_header {
+#include "blisp_chip.h"
  uint32_t dest_addr;
  uint32_t length;
  uint32_t reserved;
  uint32_t crc32;
 };
 struct blisp_device {
-  struct blisp_chip* chip;
+    struct blisp_chip* chip;
-  void* serial_port;
+    void* serial_port;
-  bool is_usb;
+    bool is_usb;
-  uint32_t current_baud_rate;
+    uint32_t current_baud_rate;
-  uint8_t rx_buffer[5000];  // TODO:
+    uint8_t rx_buffer[5000]; // TODO:
-  uint8_t tx_buffer[5000];
+    uint8_t tx_buffer[5000];
-  uint16_t error_code;
+    uint16_t error_code;
 };
 struct blisp_boot_info {
-  uint8_t boot_rom_version[4];
+    uint8_t boot_rom_version[4];
-  uint8_t chip_id[8];  // TODO: BL60X only 6 bytes
+    uint8_t chip_id[8]; // TODO: BL60X only 6 bytes
 };
 // TODO: Refactor variable names, so all will follow same semantic, like
 // image_run, image_check etc.
 int32_t blisp_device_init(struct blisp_device* device, struct blisp_chip* chip);
 int32_t blisp_device_open(struct blisp_device* device, const char* port_name);
-int32_t blisp_device_handshake(struct blisp_device* device, bool in_ef_loader);
+int32_t blisp_device_handshake(struct blisp_device* device);
-int32_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);
 int32_t blisp_device_load_boot_header(struct blisp_device* device,
                                      uint8_t* boot_header);
 int32_t blisp_device_load_segment_header(
    struct blisp_device* device,
    struct blisp_segment_header* segment_header);
 int32_t blisp_device_load_segment_data(struct blisp_device* device,
                                       uint8_t* segment_data,
                                       uint32_t segment_data_length);
 int32_t blisp_device_write_memory(struct blisp_device* device,
                                  uint32_t address,
                                  uint32_t value,
                                  bool wait_for_res);
 int32_t blisp_device_check_image(struct blisp_device* device);
 int32_t blisp_device_run_image(struct blisp_device* device);
 int32_t blisp_device_flash_erase(struct blisp_device* device,
                                 uint32_t start_address,
                                 uint32_t end_address);
 int32_t blisp_device_flash_write(struct blisp_device* device,
                                 uint32_t start_address,
                                 uint8_t* payload,
                                 uint32_t payload_size);
 int32_t blisp_device_program_check(struct blisp_device* device);
 int32_t blisp_device_reset(struct blisp_device* device);
 void blisp_device_close(struct blisp_device* device);
 #endif
--- a/include/blisp_chip.h
+++ b/include/blisp_chip.h
@ -1,31 +1,18 @@
 // SPDX-License-Identifier: MIT
 #ifndef _BLISP_CHIP_H
 #define _BLISP_CHIP_H
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdbool.h>
 enum blisp_chip_type {
-  BLISP_CHIP_BL60X,
+    BLISP_CHIP_BL70X
  BLISP_CHIP_BL70X,
  BLISP_CHIP_BL606P,
  BLISP_CHIP_BL808,
  BLISP_CHIP_BL61X,
 };
-struct blisp_chip {  // TODO: Move elsewhere?
+struct blisp_chip { // TODO: Move elsewhere?
-  enum blisp_chip_type type;
+    enum blisp_chip_type type;
-  const char* type_str;
+    bool usb_isp_available;
  bool usb_isp_available;
  float handshake_byte_multiplier;
  const char* default_xtal;  // TODO: Make this selectable
  int64_t (*load_eflash_loader)(uint8_t clk_type, uint8_t** firmware_buf_ptr);
  uint32_t tcm_address;
 };
 extern struct blisp_chip blisp_chip_bl60x;
 extern struct blisp_chip blisp_chip_bl70x;
 extern struct blisp_chip blisp_chip_bl808;
 extern struct blisp_chip blisp_chip_bl61x;
 #endif
--- a/include/blisp_easy.h
+++ b/include/blisp_easy.h
@ -1,54 +0,0 @@
 // SPDX-License-Identifier: MIT
 #ifndef BLISP_BLISP_EASY_H
 #define BLISP_BLISP_EASY_H
 #include <stdio.h>
 #include "blisp.h"
 struct blisp_easy_transport {
  uint8_t type;  // 0 - memory, 1 - FILE file_handle
  union {
    FILE* file_handle;
    struct {
      void* data_location;
      uint32_t data_size;
      uint32_t current_position;
    } memory;
  } data;
 };
 enum blisp_easy_error {
  BLISP_EASY_ERR_TRANSPORT_ERROR = -100,
  BLISP_EASY_ERR_CHECK_IMAGE_FAILED = -101
 };
 typedef void (*blisp_easy_progress_callback)(uint32_t current_value,
                                             uint32_t max_value);
 struct blisp_easy_transport blisp_easy_transport_new_from_file(FILE* file);
 struct blisp_easy_transport blisp_easy_transport_new_from_memory(
    void* data_location,
    uint32_t data_size);
 int32_t blisp_easy_load_segment_data(
    struct blisp_device* device,
    uint32_t segment_size,
    struct blisp_easy_transport* segment_transport,
    blisp_easy_progress_callback progress_callback);
 int32_t blisp_easy_load_ram_image(
    struct blisp_device* device,
    struct blisp_easy_transport* image_transport,
    blisp_easy_progress_callback progress_callback);
 int32_t blisp_easy_load_ram_app(struct blisp_device* device,
                                struct blisp_easy_transport* app_transport,
                                blisp_easy_progress_callback progress_callback);
 int32_t blisp_easy_flash_write(struct blisp_device* device,
                               struct blisp_easy_transport* data_transport,
                               uint32_t flash_location,
                               uint32_t data_size,
                               blisp_easy_progress_callback progress_callback);
 #endif  // BLISP_BLISP_EASY_H
--- a/include/blisp_struct.h
+++ b/include/blisp_struct.h
@ -1,172 +0,0 @@
 /*
 * Some parts of this source code belongs to Bouffalo Labs
 * COPYRIGHT(c) 2020 Bouffalo Lab , License: Apache
 */
 #ifndef _LIBBLISP_STRUCT_H
 #define _LIBBLISP_STRUCT_H
 #include <assert.h>
 #include <stdint.h>
 #pragma pack(push, 1)
 typedef struct {
  uint8_t ioMode; /*!< Serail flash interface mode,bit0-3:IF mode,bit4:unwrap */
  uint8_t cReadSupport;  /*!< Support continuous read mode,bit0:continuous read
                            mode support,bit1:read mode cfg */
  uint8_t clkDelay;      /*!< SPI clock delay,bit0-3:delay,bit4-6:pad delay */
  uint8_t clkInvert;     /*!< SPI clock phase invert,bit0:clck invert,bit1:rx
                            invert,bit2-4:pad delay,bit5-7:pad delay */
  uint8_t resetEnCmd;    /*!< Flash enable reset command */
  uint8_t resetCmd;      /*!< Flash reset command */
  uint8_t resetCreadCmd; /*!< Flash reset continuous read command */
  uint8_t resetCreadCmdSize;   /*!< Flash reset continuous read command size */
  uint8_t jedecIdCmd;          /*!< JEDEC ID command */
  uint8_t jedecIdCmdDmyClk;    /*!< JEDEC ID command dummy clock */
  uint8_t qpiJedecIdCmd;       /*!< QPI JEDEC ID comamnd */
  uint8_t qpiJedecIdCmdDmyClk; /*!< QPI JEDEC ID command dummy clock */
  uint8_t sectorSize;          /*!< *1024bytes */
  uint8_t mid;                 /*!< Manufacturer ID */
  uint16_t pageSize;           /*!< Page size */
  uint8_t chipEraseCmd;        /*!< Chip erase cmd */
  uint8_t sectorEraseCmd;      /*!< Sector erase command */
  uint8_t blk32EraseCmd; /*!< Block 32K erase command,some Micron not support */
  uint8_t blk64EraseCmd; /*!< Block 64K erase command */
  uint8_t writeEnableCmd;      /*!< Need before every erase or program */
  uint8_t pageProgramCmd;      /*!< Page program cmd */
  uint8_t qpageProgramCmd;     /*!< QIO page program cmd */
  uint8_t qppAddrMode;         /*!< QIO page program address mode */
  uint8_t fastReadCmd;         /*!< Fast read command */
  uint8_t frDmyClk;            /*!< Fast read command dummy clock */
  uint8_t qpiFastReadCmd;      /*!< QPI fast read command */
  uint8_t qpiFrDmyClk;         /*!< QPI fast read command dummy clock */
  uint8_t fastReadDoCmd;       /*!< Fast read dual output command */
  uint8_t frDoDmyClk;          /*!< Fast read dual output command dummy clock */
  uint8_t fastReadDioCmd;      /*!< Fast read dual io comamnd */
  uint8_t frDioDmyClk;         /*!< Fast read dual io command dummy clock */
  uint8_t fastReadQoCmd;       /*!< Fast read quad output comamnd */
  uint8_t frQoDmyClk;          /*!< Fast read quad output comamnd dummy clock */
  uint8_t fastReadQioCmd;      /*!< Fast read quad io comamnd */
  uint8_t frQioDmyClk;         /*!< Fast read quad io comamnd dummy clock */
  uint8_t qpiFastReadQioCmd;   /*!< QPI fast read quad io comamnd */
  uint8_t qpiFrQioDmyClk;      /*!< QPI fast read QIO dummy clock */
  uint8_t qpiPageProgramCmd;   /*!< QPI program command */
  uint8_t writeVregEnableCmd;  /*!< Enable write reg */
  uint8_t wrEnableIndex;       /*!< Write enable register index */
  uint8_t qeIndex;             /*!< Quad mode enable register index */
  uint8_t busyIndex;           /*!< Busy status register index */
  uint8_t wrEnableBit;         /*!< Write enable bit pos */
  uint8_t qeBit;               /*!< Quad enable bit pos */
  uint8_t busyBit;             /*!< Busy status bit pos */
  uint8_t wrEnableWriteRegLen; /*!< Register length of write enable */
  uint8_t wrEnableReadRegLen;  /*!< Register length of write enable status */
  uint8_t qeWriteRegLen;       /*!< Register length of contain quad enable */
  uint8_t qeReadRegLen; /*!< Register length of contain quad enable status */
  uint8_t releasePowerDown;   /*!< Release power down command */
  uint8_t busyReadRegLen;     /*!< Register length of contain busy status */
  uint8_t readRegCmd[4];      /*!< Read register command buffer */
  uint8_t writeRegCmd[4];     /*!< Write register command buffer */
  uint8_t enterQpi;           /*!< Enter qpi command */
  uint8_t exitQpi;            /*!< Exit qpi command */
  uint8_t cReadMode;          /*!< Config data for continuous read mode */
  uint8_t cRExit;             /*!< Config data for exit continuous read mode */
  uint8_t burstWrapCmd;       /*!< Enable burst wrap command */
  uint8_t burstWrapCmdDmyClk; /*!< Enable burst wrap command dummy clock */
  uint8_t burstWrapDataMode;  /*!< Data and address mode for this command */
  uint8_t burstWrapData;      /*!< Data to enable burst wrap */
  uint8_t deBurstWrapCmd;     /*!< Disable burst wrap command */
  uint8_t deBurstWrapCmdDmyClk; /*!< Disable burst wrap command dummy clock */
  uint8_t deBurstWrapDataMode;  /*!< Data and address mode for this command */
  uint8_t deBurstWrapData;      /*!< Data to disable burst wrap */
  uint16_t timeEsector;         /*!< 4K erase time */
  uint16_t timeE32k;            /*!< 32K erase time */
  uint16_t timeE64k;            /*!< 64K erase time */
  uint16_t timePagePgm;         /*!< Page program time */
  uint16_t timeCe;              /*!< Chip erase time in ms */
  uint8_t pdDelay; /*!< Release power down command delay time for wake up */
  uint8_t qeData;  /*!< QE set data */
 } SPI_Flash_Cfg_Type;
 #define BFLB_BOOTROM_HASH_SIZE 256 / 8
 struct boot_flash_cfg_t {
  char magiccode[4]; /*'FCFG'*/
  SPI_Flash_Cfg_Type cfg;
  uint32_t crc32;
 };
 struct sys_clk_cfg_t {
  uint8_t xtal_type;
  uint8_t pll_clk;
  uint8_t hclk_div;
  uint8_t bclk_div;
  uint8_t flash_clk_type;
  uint8_t flash_clk_div;
  uint8_t rsvd[2];
 };
 struct boot_clk_cfg_t {
  char magiccode[4]; /*'PCFG'*/
  struct sys_clk_cfg_t cfg;
  uint32_t crc32;
 };
 struct bfl_boot_header {
  char magiccode[4]; /*'BFXP'*/
  uint32_t revison;
  struct boot_flash_cfg_t flashCfg;
  struct boot_clk_cfg_t clkCfg;
  union {
    struct {
      uint32_t sign : 2;         /* [1: 0]  for sign*/
      uint32_t encrypt_type : 2; /* [3: 2]  for encrypt */
      uint32_t key_sel : 2;      /* [5: 4]  for key sel in boot interface*/
      uint32_t rsvd6_7 : 2;      /* [7: 6]  for encrypt*/
      uint32_t no_segment : 1;   /* [8]     no segment info */
      uint32_t cache_enable : 1; /* [9]     for cache */
      uint32_t
          notload_in_bootrom : 1;     /* [10]    not load this img in bootrom */
      uint32_t aes_region_lock : 1;   /* [11]    aes region lock */
      uint32_t cache_way_disable : 4; /* [15: 12]  cache way disable info*/
      uint32_t crc_ignore : 1;        /* [16]    ignore crc */
      uint32_t hash_ignore : 1;       /* [17]    hash crc */
      uint32_t halt_ap : 1;           /* [18]    halt ap */
      uint32_t rsvd19_31 : 13;        /* [31:19]  rsvd */
    } bval;
    uint32_t wval;
  } bootcfg;
  union {
    uint32_t segment_cnt;
    uint32_t img_length;
  } segment_info;
  uint32_t bootentry; /* entry point of the image*/
  uint32_t flashoffset;
  uint8_t hash[BFLB_BOOTROM_HASH_SIZE]; /*hash of the image*/
  uint32_t rsv1;
  uint32_t rsv2;
  uint32_t crc32;
 };
 static_assert(sizeof(struct bfl_boot_header) == 176,
              "Bootheader have wrong size");
 struct blflash_segment_header {
  uint32_t destaddr;
  uint32_t len;
  uint32_t rsvd;
  uint32_t crc32;
 };
 static_assert(sizeof(struct blflash_segment_header) == 16,
              "Segment header have wrong size");
 #pragma pack(pop)
 #endif
--- a/include/blisp_util.h
+++ b/include/blisp_util.h
@ -1,98 +0,0 @@
 // SPDX-License-Identifier: MIT
 #ifndef _BLISP_UTIL_H
 #define _BLISP_UTIL_H
 #include <stdarg.h>
 #include <stdio.h>
 #ifdef WIN32
 #include <windows.h>
 #else
 #include <time.h>
 #endif
 static void blisp_dlog(const char* format, ...)
 {
  fflush(stdout);
  va_list args;
  va_start(args, format);
  vfprintf(stderr, format, args);
  va_end(args);
  fputc('\n', stderr);
 }
 static void sleep_ms(int milliseconds) {
 #ifdef WIN32
  Sleep(milliseconds);
 #else
  struct timespec ts;
  ts.tv_sec = milliseconds / 1000;
  ts.tv_nsec = (milliseconds % 1000) * 1000000;
  nanosleep(&ts, NULL);
 #endif
 }
 /**
 * * Generated on Mon Jan  9 19:56:36 2023
 * by pycrc vunknown, https://pycrc.org
 * using the configuration:
 *  - Width         = 32
 *  - Poly          = 0x04c11db7
 *  - XorIn         = 0xffffffff
 *  - ReflectIn     = True
 *  - XorOut        = 0xffffffff
 *  - ReflectOut    = True
 *  - Algorithm     = table-driven
 */
 static const uint32_t crc_table[256] = {
    0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
    0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
    0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
    0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
    0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
    0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
    0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
    0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
    0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
    0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
    0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
    0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
    0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
    0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
    0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
    0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
    0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
    0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
    0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
    0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
    0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
    0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
    0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
    0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
    0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
    0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
    0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
    0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
    0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
    0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
    0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
    0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
 };
 static uint32_t crc32_calculate(const void *data, size_t data_len)
 {
  uint32_t crc = 0xffffffff;
  const unsigned char *d = (const unsigned char *)data;
  unsigned int tbl_idx;
  while (data_len--) {
    tbl_idx = (crc ^ *d) & 0xff;
    crc = (crc_table[tbl_idx] ^ (crc >> 8)) & 0xffffffff;
    d++;
  }
  return (crc & 0xffffffff) ^ 0xffffffff;
 }
 #endif
--- a/include/error_codes.h
+++ b/include/error_codes.h
@ -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
--- a/lib/blisp.c
+++ b/lib/blisp.c
@ -1,417 +1,148 @@
 // SPDX-License-Identifier: MIT
 #include <blisp.h>
 #include <blisp_util.h>
 #include <libserialport.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#ifdef __linux__
+int32_t blisp_device_init(struct blisp_device* device, struct blisp_chip* chip)
-#include <linux/serial.h>
+{
-#include <sys/ioctl.h>
+    device->chip = chip;
-#endif
+    device->is_usb = false;
-
+    return 0;
 #define DEBUG
 static void drain(struct sp_port* port) {
 #if defined(__APPLE__) || defined(__FreeBSD__)
  sp_drain(port);
 #endif
 }
-blisp_return_t blisp_device_init(struct blisp_device* device,
+int32_t blisp_device_open(struct blisp_device* device, const char* port_name)
-                                 struct blisp_chip* chip) {
+{
-  device->chip = chip;
+    int ret;
-  device->is_usb = false;
+    struct sp_port* serial_port = NULL;
  return BLISP_OK;
 }
-blisp_return_t blisp_device_open(struct blisp_device* device,
+    if (port_name != NULL) {
-                                 const char* port_name) {
+        ret = sp_get_port_by_name(port_name, &serial_port);
  blisp_return_t ret;
  struct sp_port* serial_port = NULL;
  if (port_name != NULL) {
    ret = sp_get_port_by_name(port_name, &serial_port);
    if (ret != SP_OK) {
      blisp_dlog("Couldn't open device, err: %d", ret);
      return BLISP_ERR_CANT_OPEN_DEVICE;
    }
  } else {
    if (!device->chip->usb_isp_available) {
      return BLISP_ERR_NO_AUTO_FIND_AVAILABLE;
    }
    struct sp_port** port_list;
    ret = sp_list_ports(&port_list);
    if (ret != SP_OK) {
      blisp_dlog("Couldn't list ports, err: %d", ret);
      return BLISP_ERR_DEVICE_NOT_FOUND;
    }
    for (int i = 0; port_list[i] != NULL; i++) {
      struct sp_port* port = port_list[i];
      int vid, pid;
      sp_get_port_usb_vid_pid(port, &vid, &pid);
      if (vid == 0xFFFF && pid == 0xFFFF) {
        ret = sp_get_port_by_name(sp_get_port_name(port), &serial_port);
        if (ret != SP_OK) {
-          blisp_dlog("Couldn't open device, err: %d", ret);
+            return -1; // TODO: Improve error codes
-          return BLISP_ERR_CANT_OPEN_DEVICE;
+        }
    } else {
        if (!device->chip->usb_isp_available) {
            return -2; // Can't auto-find device due it doesn't have native USB
        }
        struct sp_port **port_list;
        ret = sp_list_ports(&port_list);
        if (ret != SP_OK) {
            return -1; // TODO: Improve error codes
        }
        for (int i = 0; port_list[i] != NULL; i++) {
            struct sp_port *port = port_list[i];
            int vid, pid;
            sp_get_port_usb_vid_pid(port, &vid, &pid);
            if (vid == 0xFFFF && pid == 0xFFFF) {
                ret = sp_get_port_by_name(sp_get_port_name(port), &serial_port);
                if (ret != SP_OK) {
                    return -1; // TODO: Improve error codes
                }
                break;
            }
        }
        sp_free_port_list(port_list);
        if (serial_port == NULL) {
            return -3; // Device not found
        }
        break;
      }
    }
-    sp_free_port_list(port_list);
+
-    if (serial_port == NULL) {
+    ret = sp_open(serial_port, SP_MODE_READ_WRITE);
-      return BLISP_ERR_DEVICE_NOT_FOUND;
+    if (ret != SP_OK) { // TODO: Handle not found
        return -1;
    }
-  }
+    sp_set_bits(serial_port, 8);
-
+    sp_set_parity(serial_port, SP_PARITY_NONE);
-  ret = sp_open(serial_port, SP_MODE_READ_WRITE);
+    sp_set_stopbits(serial_port, 1);
-  if (ret != SP_OK) {
+    sp_set_flowcontrol(serial_port, SP_FLOWCONTROL_NONE);
-    blisp_dlog("SP open failed: %d", ret);
+    uint32_t vid, pid;
-    return BLISP_ERR_CANT_OPEN_DEVICE;
+    sp_get_port_usb_vid_pid(serial_port, &vid, &pid);
-  }
+    device->is_usb = pid == 0xFFFF;
-  // TODO: Handle errors in following functions, although, none of them *should*
+    if (device->is_usb) {
-  // fail
+        device->current_baud_rate = 2000000;
-  sp_set_bits(serial_port, 8);
+    } else {
-  sp_set_parity(serial_port, SP_PARITY_NONE);
+        device->current_baud_rate = 500000;
-  sp_set_stopbits(serial_port, 1);
+    }
-  sp_set_flowcontrol(serial_port, SP_FLOWCONTROL_NONE);
+    sp_set_baudrate(serial_port, device->current_baud_rate);
-
+    device->serial_port = serial_port;
-  int vid, pid;
+    return 0;
  sp_get_port_usb_vid_pid(serial_port, &vid, &pid);
  device->is_usb = pid == 0xFFFF;
  //  if (device->is_usb) {
  //    device->current_baud_rate = 2000000;
  //  } else {
  device->current_baud_rate = 460800;
  //  }
 #if 0
    int fd;
    sp_get_port_handle(serial_port, &fd);
    struct serial_struct serial;
    ioctl(fd, TIOCGSERIAL, &serial);
 //    serial.flags &= ~(ASYNC_LOW_LATENCY);
    serial.flags |= ASYNC_LOW_LATENCY;
    ioctl(fd, TIOCSSERIAL, &serial);
 #endif
  ret = sp_set_baudrate(serial_port, device->current_baud_rate);
  if (ret != SP_OK) {
    blisp_dlog("Set baud rate failed: %d... Also hello MacOS user :)", ret);
    return BLISP_ERR_API_ERROR;
  }
  device->serial_port = serial_port;
  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, void* payload, uint16_t payload_size, bool add_checksum)
-                                  uint8_t command,
+{
-                                  void* payload,
+    int ret;
-                                  uint16_t payload_size,
+    struct sp_port* serial_port = device->serial_port;
                                  bool add_checksum) {
  int ret;
  struct sp_port* serial_port = device->serial_port;
-  device->tx_buffer[0] = command;
+    device->tx_buffer[0] = command;
-  device->tx_buffer[1] = 0;
+    device->tx_buffer[1] = 0;
-  device->tx_buffer[2] = payload_size & 0xFF;
+    device->tx_buffer[2] = (payload_size >> 8) & 0xFF;
-  device->tx_buffer[3] = (payload_size >> 8) & 0xFF;
+    device->tx_buffer[3] = payload_size & 0xFF;
-  if (add_checksum) {
+    if (add_checksum) {
-    uint32_t checksum = 0;
+        uint32_t checksum = 0;
-    checksum += device->tx_buffer[2] + device->tx_buffer[3];
+        checksum += device->tx_buffer[2] + device->tx_buffer[3];
-    for (uint16_t i = 0; i < payload_size; i++) {
+        for (uint16_t i = 0; i < payload_size; i++) {
-      checksum += *(uint8_t*)((uint8_t*)payload + i);
+            checksum += *(uint8_t*)(payload + i);
        }
        device->tx_buffer[1] = checksum & 0xFF;
    }
-    device->tx_buffer[1] = checksum & 0xFF;
+    if (payload_size != 0) {
-  }
+        memcpy(&device->tx_buffer[4], payload, payload_size);
-  if (payload_size != 0) {
+    }
-    memcpy(&device->tx_buffer[4], payload, payload_size);
+    ret = sp_blocking_write(serial_port, device->tx_buffer, 4 + payload_size, 1000);
-  }
+    if (ret != (4 + payload_size)) {
-  ret =
+        return -1;
      sp_blocking_write(serial_port, device->tx_buffer, 4 + payload_size, 1000);
  if (ret != (4 + payload_size)) {
    blisp_dlog("Received error or not written all data: %d", ret);
    return BLISP_ERR_API_ERROR;
  }
  drain(serial_port);
  return BLISP_OK;
 }
 blisp_return_t blisp_receive_response(struct blisp_device* device,
                                      bool expect_payload) {
  // TODO: Check checksum
  int ret;
  struct sp_port* serial_port = device->serial_port;
  ret = sp_blocking_read(serial_port, &device->rx_buffer[0], 2, 1000);
  if (ret < 2) {
    blisp_dlog("Failed to receive response, ret: %d", ret);
    return BLISP_ERR_NO_RESPONSE;
  } else if (device->rx_buffer[0] == 'O' && device->rx_buffer[1] == 'K') {
    if (expect_payload) {
      sp_blocking_read(serial_port, &device->rx_buffer[2], 2,
                       100);  // TODO: Check if really we received the data.
      uint16_t data_length =
          (device->rx_buffer[3] << 8) | (device->rx_buffer[2]);
      sp_blocking_read(serial_port, &device->rx_buffer[0], data_length, 100);
      return data_length;
    }
    return 0;
  } else if (device->rx_buffer[0] == 'P' && device->rx_buffer[1] == 'D') {
    return BLISP_ERR_PENDING;  // TODO: This might be rather positive return
                               // number?
  } else if (device->rx_buffer[0] == 'F' && device->rx_buffer[1] == 'L') {
    sp_blocking_read(serial_port, &device->rx_buffer[2], 2, 100);
    device->error_code = (device->rx_buffer[3] << 8) | (device->rx_buffer[2]);
    blisp_dlog("Chip returned error: %d", device->error_code);
    return BLISP_ERR_CHIP_ERR;
  }
  blisp_dlog("Failed to receive any response (err: %d, %d - %d)", ret,
             device->rx_buffer[0], device->rx_buffer[1]);
  return BLISP_ERR_NO_RESPONSE;
 }
-blisp_return_t blisp_device_handshake(struct blisp_device* device,
+int32_t blisp_receive_response(struct blisp_device* device, bool expect_payload) {
-                                      bool in_ef_loader) {
+    int ret;
-  int ret;
+    struct sp_port* serial_port = device->serial_port;
-  uint8_t handshake_buffer[600];
+    ret = sp_blocking_read(serial_port, &device->rx_buffer[0], 2, 300);
-  struct sp_port* serial_port = device->serial_port;
+    if (ret < 2) {
        return -1;
    }
-  if (!in_ef_loader && !device->is_usb) {
+}
    sp_set_rts(serial_port, SP_RTS_ON);
    sp_set_dtr(serial_port, SP_DTR_ON);
    sleep_ms(50);
    sp_set_dtr(serial_port, SP_DTR_OFF);
    sleep_ms(100);
    sp_set_rts(serial_port, SP_RTS_OFF);
    sleep_ms(50);  // Wait a bit so BootROM can init
  }
-  uint32_t bytes_count = device->chip->handshake_byte_multiplier *
+int32_t blisp_device_handshake(struct blisp_device* device)
-                         (float)device->current_baud_rate / 10.0f;
+{
-  if (bytes_count > 600)
+    int ret;
-    bytes_count = 600;
+    uint8_t handshake_buffer[600];
-  memset(handshake_buffer, 'U', bytes_count);
+    struct sp_port* serial_port = device->serial_port;
-  for (uint8_t i = 0; i < 5; i++) {
+    if (device->is_usb) {
    if (!in_ef_loader) {
      if (device->is_usb) {
        sp_blocking_write(serial_port, "BOUFFALOLAB5555RESET\0\0", 22, 100);
        drain(serial_port);
      }
    }
-    ret = sp_blocking_write(serial_port, handshake_buffer, bytes_count, 500);
+    uint32_t bytes_count = 0.003f * (float)device->current_baud_rate / 10.0f; // TODO: 0.003f is only for BL70X!
-    // not sure about Apple part, but FreeBSD needs it
+    if (bytes_count > 600) bytes_count = 600;
-    drain(serial_port);
+    memset(handshake_buffer, 'U', bytes_count);
    ret = sp_blocking_write(serial_port, handshake_buffer, bytes_count, 100);
    if (ret < 0) {
-      blisp_dlog("Handshake write failed, ret %d", ret);
+        return -1;
      return BLISP_ERR_API_ERROR;
    }
-
+    ret = sp_blocking_read(serial_port, device->rx_buffer, 2, 100);
-    if (!in_ef_loader && !device->is_usb) {
+    if (ret < 2 || device->rx_buffer[0] != 'O' || device->rx_buffer[1] != 'K') {
-      sp_drain(serial_port);                // Wait for write to send all data
+        return -4; // didn't received response
      sp_flush(serial_port, SP_BUF_INPUT);  // Flush garbage out of RX
    }
-
+    return 0;
    ret = sp_blocking_read(serial_port, device->rx_buffer, 2, 50);
    if (ret >= 2) {
      if (device->rx_buffer[0] == 'O' && device->rx_buffer[1] == 'K') {
        return BLISP_OK;
      }
    }
  }
  blisp_dlog("Received no response from chip.");
  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) return ret;
    return ret;
-  ret = blisp_receive_response(device, true);
+    ret = blisp_receive_response(device, true);
  if (ret < 0)
    return ret;
-  memcpy(boot_info->boot_rom_version, &device->rx_buffer[0],
+    return 0;
         4);  // TODO: Endianess; this may break on big endian machines
  if (device->chip->type == BLISP_CHIP_BL70X) {
    memcpy(boot_info->chip_id, &device->rx_buffer[16], 8);
  }
  // TODO: BL60X
  return BLISP_OK;
 }
-// TODO: Use struct instead of uint8_t*
+void blisp_device_close(struct blisp_device* device)
-blisp_return_t blisp_device_load_boot_header(struct blisp_device* device,
+{
-                                             uint8_t* boot_header) {
+    struct sp_port* serial_port = device->serial_port;
-  blisp_return_t ret;
+    sp_close(serial_port);
  ret = blisp_send_command(device, 0x11, boot_header, 176, false);
  if (ret < 0)
    return ret;
  ret = blisp_receive_response(device, false);
  if (ret < 0)
    return ret;
  return BLISP_OK;
 }
 blisp_return_t blisp_device_load_segment_header(
    struct blisp_device* device,
    struct blisp_segment_header* segment_header) {
  blisp_return_t ret;
  ret = blisp_send_command(device, 0x17, segment_header, 16, false);
  if (ret < 0)
    return ret;
  ret = blisp_receive_response(device, true);  // TODO: Handle response
  if (ret < 0)
    return ret;
  return BLISP_OK;
 }
 blisp_return_t blisp_device_load_segment_data(struct blisp_device* device,
                                              uint8_t* segment_data,
                                              uint32_t segment_data_length) {
  blisp_return_t ret;
  ret = blisp_send_command(device, 0x18, segment_data, segment_data_length,
                           false);
  if (ret < 0)
    return ret;
  ret = blisp_receive_response(device, false);
  if (ret < 0)
    return ret;
  return BLISP_OK;
 }
 blisp_return_t blisp_device_check_image(struct blisp_device* device) {
  blisp_return_t ret;
  ret = blisp_send_command(device, 0x19, NULL, 0, false);
  if (ret < 0)
    return ret;
  ret = blisp_receive_response(device, false);
  if (ret < 0)
    return ret;
  return BLISP_OK;
 }
 blisp_return_t blisp_device_write_memory(struct blisp_device* device,
                                         uint32_t address,
                                         uint32_t value,
                                         bool wait_for_res) {
  blisp_return_t ret;
  uint8_t payload[8];
  *(uint32_t*)(payload) = address;
  *(uint32_t*)(payload + 4) = value;  // TODO: Endianness
  ret = blisp_send_command(device, 0x50, payload, 8, true);
  if (ret < 0)
    return ret;
  if (wait_for_res) {
    ret = blisp_receive_response(device, false);
    if (ret < 0)
      return ret;
  }
  return BLISP_OK;
 }
 blisp_return_t blisp_device_run_image(struct blisp_device* device) {
  blisp_return_t ret;
  if (device->chip->type == BLISP_CHIP_BL70X) {  // ERRATA
    ret = blisp_device_write_memory(device, 0x4000F100, 0x4E424845, true);
    if (ret < 0)
      return ret;
    ret = blisp_device_write_memory(device, 0x4000F104, 0x22010000, true);
    if (ret < 0)
      return ret;
    //        ret = blisp_device_write_memory(device, 0x40000018, 0x00000000);
    //        if (ret < 0) return ret;
    ret = blisp_device_write_memory(device, 0x40000018, 0x00000002, false);
    if (ret < 0)
      return ret;
    return BLISP_OK;
  }
  ret = blisp_send_command(device, 0x1A, NULL, 0, false);
  if (ret < 0)
    return ret;
  ret = blisp_receive_response(device, false);
  if (ret < 0)
    return ret;
  return BLISP_OK;
 }
 blisp_return_t blisp_device_flash_erase(struct blisp_device* device,
                                        uint32_t start_address,
                                        uint32_t end_address) {
  uint8_t payload[8];
  *(uint32_t*)(payload + 0) = start_address;
  *(uint32_t*)(payload + 4) = end_address;
  blisp_return_t ret = blisp_send_command(device, 0x30, payload, 8, true);
  if (ret < 0)
    return ret;
  do {
    ret = blisp_receive_response(device, false);
  } while (ret == BLISP_ERR_PENDING);
  return 0;
 }
 blisp_return_t blisp_device_flash_write(struct blisp_device* device,
                                        uint32_t start_address,
                                        uint8_t* payload,
                                        uint32_t payload_size) {
  // TODO: Add max payload size (8184?)
  // TODO: Don't use malloc + add check
  uint8_t* buffer = malloc(4 + payload_size);
  *((uint32_t*)(buffer)) = start_address;
  memcpy(buffer + 4, payload, payload_size);
  blisp_return_t ret =
      blisp_send_command(device, 0x31, buffer, payload_size + 4, true);
  if (ret < 0)
    goto exit1;
  ret = blisp_receive_response(device, false);
 exit1:
  free(buffer);
  return ret;
 }
 blisp_return_t blisp_device_program_check(struct blisp_device* device) {
  int ret = blisp_send_command(device, 0x3A, NULL, 0, true);
  if (ret < 0)
    return ret;
  ret = blisp_receive_response(device, false);
  if (ret < 0)
    return ret;
  return BLISP_OK;
 }
 blisp_return_t blisp_device_reset(struct blisp_device* device) {
  blisp_return_t ret = blisp_send_command(device, 0x21, NULL, 0, true);
  if (ret < 0)
    return ret;
  ret = blisp_receive_response(device, false);
  if (ret < 0)
    return ret;
  return BLISP_OK;
 }
 void blisp_device_close(struct blisp_device* device) {
  struct sp_port* serial_port = device->serial_port;
  sp_close(serial_port);
 }
--- a/lib/blisp_easy.c
+++ b/lib/blisp_easy.c
@ -1,370 +0,0 @@
 // SPDX-License-Identifier: MIT
 #include "blisp_easy.h"
 #include "blisp_struct.h"
 #include "blisp_util.h"
 #include <inttypes.h>
 #include <string.h>
 static blisp_return_t blisp_easy_transport_read(
    struct blisp_easy_transport* transport,
    void* buffer,
    uint32_t size) {
  if (transport->type == 0) {
    // TODO: Implement reading more than available
    memcpy(buffer,
           (uint8_t*)transport->data.memory.data_location +
               transport->data.memory.current_position,
           size);
    transport->data.memory.current_position += size;
    return size;
  } else {
    return fread(buffer, size, 1, transport->data.file_handle);
  }
 }
 static blisp_return_t blisp_easy_transport_size(
    struct blisp_easy_transport* transport) {
  if (transport->type == 0) {
    return transport->data.memory.data_size;
  } else {
    // TODO: Implement
    printf("%s() Warning: calling non-implemented function\n", __func__);
    return BLISP_ERR_NOT_IMPLEMENTED;
  }
 }
 static void blisp_easy_report_progress(blisp_easy_progress_callback callback,
                                       uint32_t current_value,
                                       uint32_t max_value) {
  if (callback != NULL) {
    callback(current_value, max_value);
  }
 }
 struct blisp_easy_transport blisp_easy_transport_new_from_file(FILE* file) {
  struct blisp_easy_transport transport = {.type = 1, .data.file_handle = file};
  return transport;
 }
 struct blisp_easy_transport blisp_easy_transport_new_from_memory(
    void* data_location,
    uint32_t data_size) {
  struct blisp_easy_transport transport = {
      .type = 0,
      .data.memory.data_location = data_location,
      .data.memory.data_size = data_size,
      .data.memory.current_position = 0};
  return transport;
 }
 int32_t blisp_easy_load_segment_data(
    struct blisp_device* device,
    uint32_t segment_size,
    struct blisp_easy_transport* segment_transport,
    blisp_easy_progress_callback progress_callback) {
  int32_t ret;
 #ifdef __APPLE__
  const uint16_t buffer_max_size = 252 * 16;
 #else
  const uint16_t buffer_max_size = 4092;
 #endif
  uint32_t sent_data = 0;
  uint32_t buffer_size = 0;
 #ifdef _WIN32
  uint8_t buffer[4092];
 #else
  uint8_t buffer[buffer_max_size];
 #endif
  blisp_easy_report_progress(progress_callback, 0, segment_size);
  while (sent_data < segment_size) {
    buffer_size = segment_size - sent_data;
    if (buffer_size > buffer_max_size) {
      buffer_size = buffer_max_size;
    }
    blisp_easy_transport_read(segment_transport, buffer,
                              buffer_size);  // TODO: Error Handling
    ret = blisp_device_load_segment_data(device, buffer, buffer_size);
    if (ret < BLISP_OK) {
      // TODO: Error logging fprintf(stderr, "Failed to load segment data. (ret
      // %d)\n", ret);
      return ret;
    }
    sent_data += buffer_size;
    blisp_easy_report_progress(progress_callback, sent_data, segment_size);
  }
  return BLISP_OK;
 }
 int32_t blisp_easy_load_ram_image(
    struct blisp_device* device,
    struct blisp_easy_transport* image_transport,
    blisp_easy_progress_callback progress_callback) {
  int32_t ret;
  struct bfl_boot_header image_boot_header;
  // TODO: Error handling
  blisp_easy_transport_read(image_transport, &image_boot_header, 176);
  ret = blisp_device_load_boot_header(device, (uint8_t*)&image_boot_header);
  if (ret != BLISP_OK) {
    // TODO: Error printing: fprintf(stderr, "Failed to load boot header.\n");
    return ret;
  }
  {
    for (uint8_t seg_index = 0;
         seg_index < image_boot_header.segment_info.segment_cnt; seg_index++) {
      struct blisp_segment_header segment_header = {0};
      blisp_easy_transport_read(image_transport, &segment_header,
                                16);  // TODO: Error handling
      ret = blisp_device_load_segment_header(device, &segment_header);
      if (ret != 0) {
        // TODO: Error printing: fprintf(stderr, "Failed to load segment
        // header.");
        return ret;
      }
      // TODO: Info printing: printf("Flashing %d. segment\n", seg_index + 1);
      ret = blisp_easy_load_segment_data(device, segment_header.length,
                                         image_transport, progress_callback);
      if (ret != 0) {
        return ret;
      }
    }
  }
  ret = blisp_device_check_image(device);
  if (ret != BLISP_OK) {
    // TODO: Error printing: fprintf(stderr, "Failed to check image.\n");
    return BLISP_EASY_ERR_CHECK_IMAGE_FAILED;
  }
  return BLISP_OK;
 }
 int32_t blisp_easy_load_ram_app(
    struct blisp_device* device,
    struct blisp_easy_transport* app_transport,
    blisp_easy_progress_callback progress_callback) {
  int32_t ret;
  // TODO: Rework
  // region boot header fill
  struct bfl_boot_header boot_header;
  memcpy(boot_header.magiccode, "BFNP", 4);
  memcpy(boot_header.flashCfg.magiccode, "FCFG", 4);
  boot_header.revison = 0x01;
  boot_header.flashCfg.cfg.ioMode = 0x04;
  boot_header.flashCfg.cfg.cReadSupport = 0x01;
  boot_header.flashCfg.cfg.clkDelay = 0x01;
  boot_header.flashCfg.cfg.clkInvert = 0x01;
  boot_header.flashCfg.cfg.resetEnCmd = 0x66;
  boot_header.flashCfg.cfg.resetCmd = 0x99;
  boot_header.flashCfg.cfg.resetCreadCmd = 0xFF;
  boot_header.flashCfg.cfg.resetCreadCmdSize = 0x03;
  boot_header.flashCfg.cfg.jedecIdCmd = 0x9F;
  boot_header.flashCfg.cfg.jedecIdCmdDmyClk = 0x00;
  boot_header.flashCfg.cfg.qpiJedecIdCmd = 0x9F;
  boot_header.flashCfg.cfg.qpiJedecIdCmdDmyClk = 0x00;
  boot_header.flashCfg.cfg.sectorSize = 0x04;
  boot_header.flashCfg.cfg.mid = 0xEF;
  boot_header.flashCfg.cfg.pageSize = 0x100;
  boot_header.flashCfg.cfg.chipEraseCmd = 0xC7;
  boot_header.flashCfg.cfg.sectorEraseCmd = 0x20;
  boot_header.flashCfg.cfg.blk32EraseCmd = 0x52;
  boot_header.flashCfg.cfg.blk64EraseCmd = 0xD8;
  boot_header.flashCfg.cfg.writeEnableCmd = 0x06;
  boot_header.flashCfg.cfg.pageProgramCmd = 0x02;
  boot_header.flashCfg.cfg.qpageProgramCmd = 0x32;
  boot_header.flashCfg.cfg.qppAddrMode = 0x00;
  boot_header.flashCfg.cfg.fastReadCmd = 0x0B;
  boot_header.flashCfg.cfg.frDmyClk = 0x01;
  boot_header.flashCfg.cfg.qpiFastReadCmd = 0x0B;
  boot_header.flashCfg.cfg.qpiFrDmyClk = 0x01;
  boot_header.flashCfg.cfg.fastReadDoCmd = 0x3B;
  boot_header.flashCfg.cfg.frDoDmyClk = 0x01;
  boot_header.flashCfg.cfg.fastReadDioCmd = 0xBB;
  boot_header.flashCfg.cfg.frDioDmyClk = 0x00;
  boot_header.flashCfg.cfg.fastReadQoCmd = 0x6B;
  boot_header.flashCfg.cfg.frQoDmyClk = 0x01;
  boot_header.flashCfg.cfg.fastReadQioCmd = 0xEB;
  boot_header.flashCfg.cfg.frQioDmyClk = 0x02;
  boot_header.flashCfg.cfg.qpiFastReadQioCmd = 0xEB;
  boot_header.flashCfg.cfg.qpiFrQioDmyClk = 0x02;
  boot_header.flashCfg.cfg.qpiPageProgramCmd = 0x02;
  boot_header.flashCfg.cfg.writeVregEnableCmd = 0x50;
  boot_header.flashCfg.cfg.wrEnableIndex = 0x00;
  boot_header.flashCfg.cfg.qeIndex = 0x01;
  boot_header.flashCfg.cfg.busyIndex = 0x00;
  boot_header.flashCfg.cfg.wrEnableBit = 0x01;
  boot_header.flashCfg.cfg.qeBit = 0x01;
  boot_header.flashCfg.cfg.busyBit = 0x00;
  boot_header.flashCfg.cfg.wrEnableWriteRegLen = 0x02;
  boot_header.flashCfg.cfg.wrEnableReadRegLen = 0x01;
  boot_header.flashCfg.cfg.qeWriteRegLen = 0x01;
  boot_header.flashCfg.cfg.qeReadRegLen = 0x01;
  boot_header.flashCfg.cfg.releasePowerDown = 0xAB;
  boot_header.flashCfg.cfg.busyReadRegLen = 0x01;
  boot_header.flashCfg.cfg.readRegCmd[0] = 0x05;
  boot_header.flashCfg.cfg.readRegCmd[1] = 0x35;
  boot_header.flashCfg.cfg.readRegCmd[2] = 0x00;
  boot_header.flashCfg.cfg.readRegCmd[3] = 0x00;
  boot_header.flashCfg.cfg.writeRegCmd[0] = 0x01;
  boot_header.flashCfg.cfg.writeRegCmd[1] = 0x31;
  boot_header.flashCfg.cfg.writeRegCmd[2] = 0x00;
  boot_header.flashCfg.cfg.writeRegCmd[3] = 0x00;
  boot_header.flashCfg.cfg.enterQpi = 0x38;
  boot_header.flashCfg.cfg.exitQpi = 0xFF;
  boot_header.flashCfg.cfg.cReadMode = 0x20;
  boot_header.flashCfg.cfg.cRExit = 0xFF;
  boot_header.flashCfg.cfg.burstWrapCmd = 0x77;
  boot_header.flashCfg.cfg.burstWrapCmdDmyClk = 0x03;
  boot_header.flashCfg.cfg.burstWrapDataMode = 0x02;
  boot_header.flashCfg.cfg.burstWrapData = 0x40;
  boot_header.flashCfg.cfg.deBurstWrapCmd = 0x77;
  boot_header.flashCfg.cfg.deBurstWrapCmdDmyClk = 0x03;
  boot_header.flashCfg.cfg.deBurstWrapDataMode = 0x02;
  boot_header.flashCfg.cfg.deBurstWrapData = 0xF0;
  boot_header.flashCfg.cfg.timeEsector = 0x12C;
  boot_header.flashCfg.cfg.timeE32k = 0x4B0;
  boot_header.flashCfg.cfg.timeE64k = 0x4B0;
  boot_header.flashCfg.cfg.timePagePgm = 0x05;
  boot_header.flashCfg.cfg.timeCe = 0xD40;
  boot_header.flashCfg.cfg.pdDelay = 0x03;
  boot_header.flashCfg.cfg.qeData = 0x00;
  boot_header.flashCfg.crc32 = 0xC4BDD748;
  boot_header.clkCfg.cfg.xtal_type = 0x04;
  boot_header.clkCfg.cfg.pll_clk = 0x04;
  boot_header.clkCfg.cfg.hclk_div = 0x00;
  boot_header.clkCfg.cfg.bclk_div = 0x01;
  boot_header.clkCfg.cfg.flash_clk_type = 0x02;
  boot_header.clkCfg.cfg.flash_clk_div = 0x00;
  boot_header.clkCfg.crc32 = 0x824E14BB;
  boot_header.bootcfg.bval.sign = 0x00;
  boot_header.bootcfg.bval.encrypt_type = 0x00;
  boot_header.bootcfg.bval.key_sel = 0x00;
  boot_header.bootcfg.bval.rsvd6_7 = 0x00;
  boot_header.bootcfg.bval.no_segment = 0x01;
  boot_header.bootcfg.bval.cache_enable = 0x01;
  boot_header.bootcfg.bval.notload_in_bootrom = 0x00;
  boot_header.bootcfg.bval.aes_region_lock = 0x00;
  boot_header.bootcfg.bval.cache_way_disable = 0x00;
  boot_header.bootcfg.bval.crc_ignore = 0x01;
  boot_header.bootcfg.bval.hash_ignore = 0x01;
  boot_header.bootcfg.bval.halt_ap = 0x00;
  boot_header.bootcfg.bval.rsvd19_31 = 0x00;
  boot_header.segment_info.segment_cnt = 0x01;
  boot_header.bootentry = 0x00;
  boot_header.flashoffset = device->chip->tcm_address;
  boot_header.hash[0x00] = 0xEF;
  boot_header.hash[0x01] = 0xBE;
  boot_header.hash[0x02] = 0xAD;
  boot_header.hash[0x03] = 0xDE;
  boot_header.hash[0x04] = 0x00;
  boot_header.hash[0x05] = 0x00;
  boot_header.hash[0x06] = 0x00;
  boot_header.hash[0x07] = 0x00;
  boot_header.hash[0x08] = 0x00;
  boot_header.hash[0x09] = 0x00;
  boot_header.hash[0x0a] = 0x00;
  boot_header.hash[0x0b] = 0x00;
  boot_header.hash[0x0c] = 0x00;
  boot_header.hash[0x0d] = 0x00;
  boot_header.hash[0x0e] = 0x00;
  boot_header.hash[0x0f] = 0x00;
  boot_header.hash[0x10] = 0x00;
  boot_header.hash[0x11] = 0x00;
  boot_header.hash[0x12] = 0x00;
  boot_header.hash[0x13] = 0x00;
  boot_header.hash[0x14] = 0x00;
  boot_header.hash[0x15] = 0x00;
  boot_header.hash[0x16] = 0x00;
  boot_header.hash[0x17] = 0x00;
  boot_header.hash[0x18] = 0x00;
  boot_header.hash[0x19] = 0x00;
  boot_header.hash[0x1a] = 0x00;
  boot_header.hash[0x1b] = 0x00;
  boot_header.hash[0x1c] = 0x00;
  boot_header.hash[0x1d] = 0x00;
  boot_header.hash[0x1e] = 0x00;
  boot_header.hash[0x1f] = 0x00;
  boot_header.rsv1 = 0x00;
  boot_header.rsv2 = 0x00;
  boot_header.crc32 = 0xDEADBEEF;
  // endregion
  ret = blisp_device_load_boot_header(device, (uint8_t*)&boot_header);
  if (ret != BLISP_OK) {
    blisp_dlog("Failed to load boot header, ret: %d.", ret);
    return ret;
  }
  struct blisp_segment_header segment_header = {
      .dest_addr = device->chip->tcm_address,
      .length = blisp_easy_transport_size(app_transport),
      .reserved = 0,
      .crc32 = 0};
  segment_header.crc32 = crc32_calculate(
      &segment_header, 3 * sizeof(uint32_t));  // TODO: Make function
  ret = blisp_device_load_segment_header(device, &segment_header);
  if (ret != 0) {
    blisp_dlog("Failed to load segment header, ret: %d.", ret);
    return ret;
  }
  ret = blisp_easy_load_segment_data(device,
                                     blisp_easy_transport_size(app_transport),
                                     app_transport, progress_callback);
  if (ret != 0) {
    // TODO: Error printing
    return ret;
  }
  return BLISP_OK;
 }
 int32_t blisp_easy_flash_write(struct blisp_device* device,
                               struct blisp_easy_transport* data_transport,
                               uint32_t flash_location,
                               uint32_t data_size,
                               blisp_easy_progress_callback progress_callback) {
  int32_t ret;
 #if defined(__APPLE__) || defined(__FreeBSD__)
  const uint16_t buffer_max_size = 372 * 1;
 #else
  const uint16_t buffer_max_size = 2052;
 #endif
  uint32_t sent_data = 0;
  uint32_t buffer_size = 0;
 #ifdef _WIN32
  uint8_t buffer[2052];
 #else
  uint8_t buffer[buffer_max_size];
 #endif
  blisp_easy_report_progress(progress_callback, 0, data_size);
  while (sent_data < data_size) {
    buffer_size = data_size - sent_data;
    if (buffer_size > buffer_max_size) {
      buffer_size = buffer_max_size;
    }
    blisp_easy_transport_read(data_transport, buffer,
                              buffer_size);  // TODO: Error Handling
    ret = blisp_device_flash_write(device, flash_location + sent_data, buffer,
                                   buffer_size);
    if (ret < BLISP_OK) {
      // TODO: Error logigng:  fprintf(stderr, "Failed to write firmware! (ret:
      // %d)\n", ret);
      return ret;
    }
    sent_data += buffer_size;
    blisp_easy_report_progress(progress_callback, sent_data, data_size);
  }
  return BLISP_OK;
 }
--- a/lib/chip/blisp_chip_bl60x.c
+++ b/lib/chip/blisp_chip_bl60x.c
@ -1,24 +0,0 @@
 // SPDX-License-Identifier: MIT
 #include <stdlib.h>
 #include <string.h>
 #include "../../data/bl60x_eflash_loader.h"
 #include "blisp.h"
 int64_t blisp_chip_bl60x_get_eflash_loader(uint8_t clk_type, uint8_t** firmware_buf_ptr)
 {
  uint8_t* firmware_buf = malloc(sizeof(bl60x_eflash_loader_bin));
  memcpy(firmware_buf, bl60x_eflash_loader_bin, sizeof(bl60x_eflash_loader_bin));
  *(firmware_buf + 0xE0) = 4; // TODO: 40 MHz clock
  *firmware_buf_ptr = firmware_buf;
  return sizeof(bl60x_eflash_loader_bin);
 }
 struct blisp_chip blisp_chip_bl60x = {
    .type = BLISP_CHIP_BL60X,
    .type_str = "bl60x",
    .usb_isp_available = false,
    .default_xtal = "40m",
    .handshake_byte_multiplier = 0.006f,
    .load_eflash_loader = blisp_chip_bl60x_get_eflash_loader,
    .tcm_address = 0x22010000
 };
--- a/lib/chip/blisp_chip_bl61x.c
+++ b/lib/chip/blisp_chip_bl61x.c
@ -1,11 +0,0 @@
 // SPDX-License-Identifier: MIT
 #include "blisp.h"
 struct blisp_chip blisp_chip_bl61x = {
    .type = BLISP_CHIP_BL61X,
    .type_str = "bl808",
    .usb_isp_available = true,
    .default_xtal = "-", // ?
    .handshake_byte_multiplier = 0.003f,
    .get_eflash_loader = NULL
 };
--- a/lib/chip/blisp_chip_bl70x.c
+++ b/lib/chip/blisp_chip_bl70x.c
@ -1,25 +1,6 @@
 // SPDX-License-Identifier: MIT
 #include <stdlib.h>
 #include <string.h>
 #include "../../data/bl70x_eflash_loader.h"
 #include "blisp.h"
 int64_t blisp_chip_bl70x_get_eflash_loader(uint8_t clk_type, uint8_t** firmware_buf_ptr)
 {
  uint8_t* firmware_buf = malloc(sizeof(bl70x_eflash_loader_bin));
  memcpy(firmware_buf, bl70x_eflash_loader_bin, sizeof(bl70x_eflash_loader_bin));
  *(firmware_buf + 0xE0) = 1; // TODO: 32 MHz clock
  *firmware_buf_ptr = firmware_buf;
  return sizeof(bl70x_eflash_loader_bin);
 }
 struct blisp_chip blisp_chip_bl70x = {
    .type = BLISP_CHIP_BL70X,
-    .type_str = "bl70x",
+    .usb_isp_available = true
    .usb_isp_available = true,
    .default_xtal = "32m",
    .handshake_byte_multiplier = 0.003f,
    .load_eflash_loader = blisp_chip_bl70x_get_eflash_loader,
    .tcm_address = 0x22010000
 };
--- a/lib/chip/blisp_chip_bl808.c
+++ b/lib/chip/blisp_chip_bl808.c
@ -1,11 +0,0 @@
 // SPDX-License-Identifier: MIT
 #include "blisp.h"
 struct blisp_chip blisp_chip_bl808 = {
    .type = BLISP_CHIP_BL808,
    .type_str = "bl808",
    .usb_isp_available = true, // TODO: Only for BL808D :-(
    .default_xtal = "-", // ?
    .handshake_byte_multiplier = 0.003f,
    .get_eflash_loader = NULL
 };
--- a/tools/blisp/CMakeLists.txt
+++ b/tools/blisp/CMakeLists.txt
@ -1,32 +1,12 @@
-set(ARGTABLE3_ENABLE_TESTS OFF CACHE BOOL "Enable unit tests")
+add_subdirectory(${CMAKE_SOURCE_DIR}/vendor/argtable3 ${CMAKE_CURRENT_BINARY_DIR}/argtable3)
 set(ARGTABLE3_ENABLE_EXAMPLES OFF CACHE BOOL "Enable examples")
 #set(ARGTABLE3_REPLACE_GETOPT OFF CACHE BOOL "Replace getopt in the system C library")
-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/cmd/dfu/dfu_file.c src/cmd/dfu/dfu_crc.c)
 add_subdirectory(src/file_parsers)
 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
-        "${CMAKE_SOURCE_DIR}/include")
+        "${CMAKE_SOURCE_DIR}/include"
        "${CMAKE_SOURCE_DIR}/vendor/argtable3/src")
 target_link_libraries(blisp PRIVATE
        argtable3
-        libblisp_static file_parsers)
+        libblisp_static)
 if (WIN32)
    target_link_libraries(blisp PRIVATE Setupapi.lib)
 elseif (APPLE)
    target_link_libraries(blisp PRIVATE "-framework IOKit" "-framework CoreFoundation")
 endif ()
 install(TARGETS blisp DESTINATION bin)
--- a/tools/blisp/src/cmd.h
+++ b/tools/blisp/src/cmd.h
@ -1,18 +1,16 @@
 // SPDX-License-Identifier: MIT
 #ifndef BLISP_CMD_H
 #define BLISP_CMD_H
 #include <stdint.h>
-#include "error_codes.h"
+
 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)();
 };
 extern struct cmd cmd_write;
 extern struct cmd cmd_iot;
-#endif  // BLISP_CMD_H
+#endif // BLISP_CMD_H
--- a/tools/blisp/src/file_parsers/dfu/dfu_crc.c
+++ b/tools/blisp/src/file_parsers/dfu/dfu_crc.c
--- a/tools/blisp/src/file_parsers/dfu/dfu_file.c
+++ b/tools/blisp/src/file_parsers/dfu/dfu_file.c
--- a/tools/blisp/src/file_parsers/dfu/dfu_file.h
+++ b/tools/blisp/src/file_parsers/dfu/dfu_file.h
@ -13,11 +13,9 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-// Parse the dfu file and returns 0 if ok, or -ve on error parsing
+
-int dfu_file_parse(const char* file_path_on_disk,
+int dfu_file_parse(const char* file_path_on_disk, uint8_t** payload,
-                   uint8_t** payload,
+                   size_t* payload_length, size_t* payload_address);
                   size_t* payload_length,
                   size_t* payload_address);
 // Internal
 uint32_t crc32_byte(uint32_t accum, uint8_t delta);
@ -25,4 +23,4 @@ uint32_t crc32_byte(uint32_t accum, uint8_t delta);
 };
 #endif
-#endif  // BLISP_DFU_FILE_H
+#endif // BLISP_DFU_FILE_H
--- a/tools/blisp/src/file_parsers/dfu/tests/CMakeLists.txt
+++ b/tools/blisp/src/file_parsers/dfu/tests/CMakeLists.txt
--- a/tools/blisp/src/file_parsers/dfu/tests/Config.h.in
+++ b/tools/blisp/src/file_parsers/dfu/tests/Config.h.in
--- a/tools/blisp/src/file_parsers/dfu/tests/test.dfu
+++ b/tools/blisp/src/file_parsers/dfu/tests/test.dfu
--- a/tools/blisp/src/file_parsers/dfu/tests/test_dfu_file.cpp
+++ b/tools/blisp/src/file_parsers/dfu/tests/test_dfu_file.cpp
--- a/tools/blisp/src/cmd/iot.c
+++ b/tools/blisp/src/cmd/iot.c
@ -1,147 +0,0 @@
 #include <argtable3.h>
 #include <blisp_easy.h>
 #include "../cmd.h"
 #include "../common.h"
 #define REG_EXTENDED 1
 #define REG_ICASE (REG_EXTENDED << 1)
 static struct arg_rex* cmd;
 static struct arg_file* single_download;
 static struct arg_int* single_download_location;
 static struct arg_str *port_name, *chip_type;  // TODO: Make this common
 static struct arg_lit* reset;
 static struct arg_end* end;
 static void* cmd_iot_argtable[7];
 blisp_return_t blisp_single_download() {
  struct blisp_device device;
  blisp_return_t ret;
  ret = blisp_common_init_device(&device, port_name, chip_type);
  if (ret != BLISP_OK) {
    return ret;
  }
  ret = blisp_common_prepare_flash(&device);
  if (ret != BLISP_OK) {
    // TODO: Error handling
    goto exit1;
  }
  FILE* data_file = fopen(single_download->filename[0], "rb");
  if (data_file == NULL) {
    fprintf(stderr, "Failed to open data file \"%s\".\n",
            single_download->filename[0]);
    ret = BLISP_ERR_CANT_OPEN_FILE;
    goto exit1;
  }
  fseek(data_file, 0, SEEK_END);
  int64_t data_file_size = ftell(data_file);
  rewind(data_file);
  printf("Erasing the area, this might take a while...\n");
  ret = blisp_device_flash_erase(
      &device, *single_download_location->ival,
      *single_download_location->ival + data_file_size + 1);
  if (ret != BLISP_OK) {
    fprintf(stderr, "Failed to erase.\n");
    goto exit2;
  }
  printf("Writing the data...\n");
  struct blisp_easy_transport data_transport =
      blisp_easy_transport_new_from_file(data_file);
  ret = blisp_easy_flash_write(&device, &data_transport,
                               *single_download_location->ival, data_file_size,
                               blisp_common_progress_callback);
  if (ret < BLISP_OK) {
    fprintf(stderr, "Failed to write data to flash.\n");
    goto exit2;
  }
  printf("Checking program...\n");
  ret = blisp_device_program_check(&device);
  if (ret != BLISP_OK) {
    fprintf(stderr, "Failed to check program.\n");
    goto exit2;
  }
  printf("Program OK!\n");
  if (reset->count > 0) {  // TODO: could be common
    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");
  }
 exit2:
  if (data_file != NULL)
    fclose(data_file);
 exit1:
  blisp_device_close(&device);
  return ret;
 }
 blisp_return_t cmd_iot_args_init() {
  cmd_iot_argtable[0] = cmd =
      arg_rex1(NULL, NULL, "iot", NULL, REG_ICASE, NULL);
  cmd_iot_argtable[1] = chip_type =
      arg_str1("c", "chip", "<chip_type>", "Chip Type");
  cmd_iot_argtable[2] = port_name =
      arg_str0("p", "port", "<port_name>",
               "Name/Path to the Serial Port (empty for search)");
  cmd_iot_argtable[3] = reset =
      arg_lit0(NULL, "reset", "Reset chip after write");
  cmd_iot_argtable[4] = single_download =
      arg_file0("s", "single-down", "<file>", "Single download file");
  cmd_iot_argtable[5] = single_download_location =
      arg_int0("l", "single-down-loc", NULL, "Single download offset");
  cmd_iot_argtable[6] = end = arg_end(10);
  if (arg_nullcheck(cmd_iot_argtable) != 0) {
    fprintf(stderr, "insufficient memory\n");
    return BLISP_ERR_OUT_OF_MEMORY;
  }
  return BLISP_OK;
 }
 void cmd_iot_args_print_glossary() {
  fputs("Usage: blisp", stdout);
  arg_print_syntax(stdout, cmd_iot_argtable, "\n");
  puts("Flashes firmware as Bouffalo's DevCube");
  arg_print_glossary(stdout, cmd_iot_argtable, "  %-25s %s\n");
 }
 blisp_return_t cmd_iot_parse_exec(int argc, char** argv) {
  int errors = arg_parse(argc, argv, cmd_iot_argtable);
  if (errors == 0) {
    if (single_download->count == 1 && single_download_location->count == 1) {
      return blisp_single_download();
    } else {
      return BLISP_ERR_INVALID_COMMAND;
    }
  } else if (cmd->count == 1) {
    cmd_iot_args_print_glossary();
    return BLISP_OK;
  }
  return BLISP_ERR_INVALID_COMMAND;
 }
 void cmd_iot_args_print_syntax() {
  arg_print_syntax(stdout, cmd_iot_argtable, "\n");
 }
 void cmd_iot_free() {
  arg_freetable(cmd_iot_argtable,
                sizeof(cmd_iot_argtable) / sizeof(cmd_iot_argtable[0]));
 }
 struct cmd cmd_iot = {"iot", cmd_iot_args_init, cmd_iot_parse_exec,
                      cmd_iot_args_print_syntax, cmd_iot_free};
--- a/tools/blisp/src/cmd/write.c
+++ b/tools/blisp/src/cmd/write.c
@ -1,313 +1,85 @@
 // SPDX-License-Identifier: MIT
 #include <argtable3.h>
 #include <blisp.h>
 #include <blisp_easy.h>
 #include <blisp_struct.h>
 #include <inttypes.h>
 #include <stdlib.h>
 #include <string.h>
 #include "../cmd.h"
-#include "../common.h"
+#include "argtable3.h"
-#include "../util.h"
+#include <blisp.h>
 #define REG_EXTENDED 1
-#define REG_ICASE (REG_EXTENDED << 1)
+#define REG_ICASE    (REG_EXTENDED << 1)
 static struct arg_rex* cmd;
 static struct arg_file* binary_to_write;
-static struct arg_str *port_name, *chip_type;
+static struct arg_str* port_name;
 static struct arg_lit* reset;
 static struct arg_end* end;
-static void* cmd_write_argtable[6];
+static void* cmd_write_argtable[4];
-void fill_up_boot_header(struct bfl_boot_header* boot_header) {
+void blisp_flash_firmware() {
-  memcpy(boot_header->magiccode, "BFNP", 4);
+    struct blisp_device device;
-
+    uint32_t ret;
-  boot_header->revison = 0x01;
+    ret = blisp_device_init(&device, &blisp_chip_bl70x);
-  memcpy(boot_header->flashCfg.magiccode, "FCFG", 4);
+    if (ret != 0) {
-  boot_header->flashCfg.cfg.ioMode = 0x11;
+        fprintf(stderr, "Failed to init device.\n");
-  boot_header->flashCfg.cfg.cReadSupport = 0x00;
+        return;
-  boot_header->flashCfg.cfg.clkDelay = 0x01;
+    }
-  boot_header->flashCfg.cfg.clkInvert = 0x01;
+    ret = blisp_device_open(&device, port_name->count == 1 ? port_name->sval[0] : NULL);
-  boot_header->flashCfg.cfg.resetEnCmd = 0x66;
+    if (ret != 0) {
-  boot_header->flashCfg.cfg.resetCmd = 0x99;
+        fprintf(stderr, "Failed to open device.\n");
-  boot_header->flashCfg.cfg.resetCreadCmd = 0xFF;
+        return;
-  boot_header->flashCfg.cfg.resetCreadCmdSize = 0x03;
+    }
-  boot_header->flashCfg.cfg.jedecIdCmd = 0x9F;
+    printf("Sending a handshake...");
-  boot_header->flashCfg.cfg.jedecIdCmdDmyClk = 0x00;
+    ret = blisp_device_handshake(&device);
-  boot_header->flashCfg.cfg.qpiJedecIdCmd = 0x9F;
+    if (ret != 0) {
-  boot_header->flashCfg.cfg.qpiJedecIdCmdDmyClk = 0x00;
+        fprintf(stderr, "\nFailed to handshake with device.\n");
-  boot_header->flashCfg.cfg.sectorSize = 0x04;
+        return;
-  boot_header->flashCfg.cfg.mid = 0xC2;
+    }
-  boot_header->flashCfg.cfg.pageSize = 0x100;
+    printf(" OK\n");
-  boot_header->flashCfg.cfg.chipEraseCmd = 0xC7;
+    blisp_device_close(&device);
  boot_header->flashCfg.cfg.sectorEraseCmd = 0x20;
  boot_header->flashCfg.cfg.blk32EraseCmd = 0x52;
  boot_header->flashCfg.cfg.blk64EraseCmd = 0xD8;
  boot_header->flashCfg.cfg.writeEnableCmd = 0x06;
  boot_header->flashCfg.cfg.pageProgramCmd = 0x02;
  boot_header->flashCfg.cfg.qpageProgramCmd = 0x32;
  boot_header->flashCfg.cfg.qppAddrMode = 0x00;
  boot_header->flashCfg.cfg.fastReadCmd = 0x0B;
  boot_header->flashCfg.cfg.frDmyClk = 0x01;
  boot_header->flashCfg.cfg.qpiFastReadCmd = 0x0B;
  boot_header->flashCfg.cfg.qpiFrDmyClk = 0x01;
  boot_header->flashCfg.cfg.fastReadDoCmd = 0x3B;
  boot_header->flashCfg.cfg.frDoDmyClk = 0x01;
  boot_header->flashCfg.cfg.fastReadDioCmd = 0xBB;
  boot_header->flashCfg.cfg.frDioDmyClk = 0x00;
  boot_header->flashCfg.cfg.fastReadQoCmd = 0x6B;
  boot_header->flashCfg.cfg.frQoDmyClk = 0x01;
  boot_header->flashCfg.cfg.fastReadQioCmd = 0xEB;
  boot_header->flashCfg.cfg.frQioDmyClk = 0x02;
  boot_header->flashCfg.cfg.qpiFastReadQioCmd = 0xEB;
  boot_header->flashCfg.cfg.qpiFrQioDmyClk = 0x02;
  boot_header->flashCfg.cfg.qpiPageProgramCmd = 0x02;
  boot_header->flashCfg.cfg.writeVregEnableCmd = 0x50;
  boot_header->flashCfg.cfg.wrEnableIndex = 0x00;
  boot_header->flashCfg.cfg.qeIndex = 0x01;
  boot_header->flashCfg.cfg.busyIndex = 0x00;
  boot_header->flashCfg.cfg.wrEnableBit = 0x01;
  boot_header->flashCfg.cfg.qeBit = 0x01;
  boot_header->flashCfg.cfg.busyBit = 0x00;
  boot_header->flashCfg.cfg.wrEnableWriteRegLen = 0x02;
  boot_header->flashCfg.cfg.wrEnableReadRegLen = 0x01;
  boot_header->flashCfg.cfg.qeWriteRegLen = 0x02;
  boot_header->flashCfg.cfg.qeReadRegLen = 0x01;
  boot_header->flashCfg.cfg.releasePowerDown = 0xAB;
  boot_header->flashCfg.cfg.busyReadRegLen = 0x01;
  boot_header->flashCfg.cfg.readRegCmd[0] = 0x05;
  boot_header->flashCfg.cfg.readRegCmd[1] = 0x00;
  boot_header->flashCfg.cfg.readRegCmd[2] = 0x00;
  boot_header->flashCfg.cfg.readRegCmd[3] = 0x00;
  boot_header->flashCfg.cfg.writeRegCmd[0] = 0x01;
  boot_header->flashCfg.cfg.writeRegCmd[1] = 0x00;
  boot_header->flashCfg.cfg.writeRegCmd[2] = 0x00;
  boot_header->flashCfg.cfg.writeRegCmd[3] = 0x00;
  boot_header->flashCfg.cfg.enterQpi = 0x38;
  boot_header->flashCfg.cfg.exitQpi = 0xFF;
  boot_header->flashCfg.cfg.cReadMode = 0x00;
  boot_header->flashCfg.cfg.cRExit = 0xFF;
  boot_header->flashCfg.cfg.burstWrapCmd = 0x77;
  boot_header->flashCfg.cfg.burstWrapCmdDmyClk = 0x03;
  boot_header->flashCfg.cfg.burstWrapDataMode = 0x02;
  boot_header->flashCfg.cfg.burstWrapData = 0x40;
  boot_header->flashCfg.cfg.deBurstWrapCmd = 0x77;
  boot_header->flashCfg.cfg.deBurstWrapCmdDmyClk = 0x03;
  boot_header->flashCfg.cfg.deBurstWrapDataMode = 0x02;
  boot_header->flashCfg.cfg.deBurstWrapData = 0xF0;
  boot_header->flashCfg.cfg.timeEsector = 0x12C;
  boot_header->flashCfg.cfg.timeE32k = 0x4B0;
  boot_header->flashCfg.cfg.timeE64k = 0x4B0;
  boot_header->flashCfg.cfg.timePagePgm = 0x05;
  boot_header->flashCfg.cfg.timeCe = 0xFFFF;
  boot_header->flashCfg.cfg.pdDelay = 0x14;
  boot_header->flashCfg.cfg.qeData = 0x00;
  boot_header->flashCfg.crc32 = 0xE43C762A;
  boot_header->clkCfg.cfg.xtal_type = 0x01;
  boot_header->clkCfg.cfg.pll_clk = 0x04;
  boot_header->clkCfg.cfg.hclk_div = 0x00;
  boot_header->clkCfg.cfg.bclk_div = 0x01;
  boot_header->clkCfg.cfg.flash_clk_type = 0x03;
  boot_header->clkCfg.cfg.flash_clk_div = 0x00;
  boot_header->clkCfg.crc32 = 0x72127DBA;
  boot_header->bootcfg.bval.sign = 0x00;
  boot_header->bootcfg.bval.encrypt_type = 0x00;
  boot_header->bootcfg.bval.key_sel = 0x00;
  boot_header->bootcfg.bval.rsvd6_7 = 0x00;
  boot_header->bootcfg.bval.no_segment = 0x01;
  boot_header->bootcfg.bval.cache_enable = 0x01;
  boot_header->bootcfg.bval.notload_in_bootrom = 0x00;
  boot_header->bootcfg.bval.aes_region_lock = 0x00;
  boot_header->bootcfg.bval.cache_way_disable = 0x00;
  boot_header->bootcfg.bval.crc_ignore = 0x01;
  boot_header->bootcfg.bval.hash_ignore = 0x01;
  boot_header->bootcfg.bval.halt_ap = 0x00;
  boot_header->bootcfg.bval.rsvd19_31 = 0x00;
  boot_header->segment_info.segment_cnt = 0xCDA8;
  boot_header->bootentry = 0x00;
  boot_header->flashoffset = 0x2000;
  boot_header->hash[0x00] = 0xEF;
  boot_header->hash[0x01] = 0xBE;
  boot_header->hash[0x02] = 0xAD;
  boot_header->hash[0x03] = 0xDE;
  boot_header->hash[0x04] = 0x00;
  boot_header->hash[0x05] = 0x00;
  boot_header->hash[0x06] = 0x00;
  boot_header->hash[0x07] = 0x00;
  boot_header->hash[0x08] = 0x00;
  boot_header->hash[0x09] = 0x00;
  boot_header->hash[0x0a] = 0x00;
  boot_header->hash[0x0b] = 0x00;
  boot_header->hash[0x0c] = 0x00;
  boot_header->hash[0x0d] = 0x00;
  boot_header->hash[0x0e] = 0x00;
  boot_header->hash[0x0f] = 0x00;
  boot_header->hash[0x10] = 0x00;
  boot_header->hash[0x11] = 0x00;
  boot_header->hash[0x12] = 0x00;
  boot_header->hash[0x13] = 0x00;
  boot_header->hash[0x14] = 0x00;
  boot_header->hash[0x15] = 0x00;
  boot_header->hash[0x16] = 0x00;
  boot_header->hash[0x17] = 0x00;
  boot_header->hash[0x18] = 0x00;
  boot_header->hash[0x19] = 0x00;
  boot_header->hash[0x1a] = 0x00;
  boot_header->hash[0x1b] = 0x00;
  boot_header->hash[0x1c] = 0x00;
  boot_header->hash[0x1d] = 0x00;
  boot_header->hash[0x1e] = 0x00;
  boot_header->hash[0x1f] = 0x00;
  boot_header->rsv1 = 0x1000;
  boot_header->rsv2 = 0x2000;
  boot_header->crc32 = 0xDEADBEEF;
 }
-blisp_return_t blisp_flash_firmware() {
+int8_t
-  struct blisp_device device;
+cmd_write_args_init() {
-  blisp_return_t ret;
+    cmd_write_argtable[0] = cmd
-  ret = blisp_common_init_device(&device, port_name, chip_type);
+        = arg_rex1(NULL, NULL, "write", NULL, REG_ICASE, NULL);
    cmd_write_argtable[1] = binary_to_write
        = arg_file1(NULL, NULL, "<input>", "Binary to write");
    cmd_write_argtable[2] = port_name
        = arg_str0("p", "port", "<port_name>", "Name/Path to the Serial Port (empty for search)");
    cmd_write_argtable[3] = end = arg_end(10);
-  if (ret != 0) {
+    if (arg_nullcheck(cmd_write_argtable) != 0) {
-    return ret;
+        fprintf(stderr, "insufficient memory\n");
-  }
+        return -1;
-
+    }
-  if (blisp_common_prepare_flash(&device) != 0) {
+    return 0;
    // TODO: Error handling
    goto exit1;
  }
  // Open the file to be flashed; to determine the size of the section of flash
  // to erase
  int64_t firmware_file_size = 0;
  const uint32_t firmware_base_address_offset =
      0x2000;  // Firmware files start 0x2000 offset into flash to skip the boot
               // header
  int64_t firmware_file_start_address = 0;
  FILE* firmware_file = fopen(binary_to_write->filename[0], "rb");
  if (firmware_file == NULL) {
    fprintf(stderr, "Failed to open firmware file \"%s\".\n",
            binary_to_write->filename[0]);
    goto exit1;
  }
  fseek(firmware_file, 0, SEEK_END);
  firmware_file_size = ftell(firmware_file);
  rewind(firmware_file);
  // Create a default boot header section in ram to be written out
  struct bfl_boot_header boot_header;
  fill_up_boot_header(&boot_header);
  const uint32_t firmware_base_address = 0x2000;
  printf("Erasing flash, this might take a while...\n");
  ret =
      blisp_device_flash_erase(&device, firmware_base_address,
                               firmware_base_address + firmware_file_size + 1);
  if (ret != BLISP_OK) {
    fprintf(stderr, "Failed to erase flash.\n");
    goto exit2;
  }
  ret =
      blisp_device_flash_erase(&device, 0x0000, sizeof(struct bfl_boot_header));
  if (ret != BLISP_OK) {
    fprintf(stderr, "Failed to erase flash.\n");
    goto exit2;
  }
  printf("Flashing boot header...\n");
  ret = blisp_device_flash_write(&device, 0x0000, (uint8_t*)&boot_header,
                                 sizeof(struct bfl_boot_header));
  if (ret != BLISP_OK) {
    fprintf(stderr, "Failed to write boot header.\n");
    goto exit2;
  }
  printf("Flashing the firmware...\n");
  struct blisp_easy_transport data_transport =
      blisp_easy_transport_new_from_file(firmware_file);
  ret = blisp_easy_flash_write(&device, &data_transport, firmware_base_address,
                               firmware_file_size,
                               blisp_common_progress_callback);
  if (ret < BLISP_OK) {
    fprintf(stderr, "Failed to write app to flash.\n");
    goto exit2;
  }
  printf("Checking program...\n");
  ret = blisp_device_program_check(&device);
  if (ret != BLISP_OK) {
    fprintf(stderr, "Failed to check program.\n");
    goto exit2;
  }
  printf("Program OK!\n");
  if (reset->count > 0) {
    blisp_device_reset(&device);
    printf("Resetting the chip.\n");
    // TODO: It seems that GPIO peripheral is not reset after resetting the chip
  }
  printf("Flash complete!\n");
 exit2:
  if (firmware_file != NULL)
    fclose(firmware_file);
 exit1:
  blisp_device_close(&device);
 }
 blisp_return_t cmd_write_args_init() {
  cmd_write_argtable[0] = cmd =
      arg_rex1(NULL, NULL, "write", NULL, REG_ICASE, NULL);
  cmd_write_argtable[1] = chip_type =
      arg_str1("c", "chip", "<chip_type>", "Chip Type");
  cmd_write_argtable[2] = port_name =
      arg_str0("p", "port", "<port_name>",
               "Name/Path to the Serial Port (empty for search)");
  cmd_write_argtable[3] = reset =
      arg_lit0(NULL, "reset", "Reset chip after write");
  cmd_write_argtable[4] = binary_to_write =
      arg_file1(NULL, NULL, "<input>", "Binary to write");
  cmd_write_argtable[5] = end = arg_end(10);
  if (arg_nullcheck(cmd_write_argtable) != 0) {
    fprintf(stderr, "insufficient memory\n");
    return BLISP_ERR_OUT_OF_MEMORY;
  }
  return BLISP_OK;
 }
 void cmd_write_args_print_glossary() {
-  fputs("Usage: blisp", stdout);
+    fputs("Usage: blisp", stdout);
-  arg_print_syntax(stdout, cmd_write_argtable, "\n");
+    arg_print_syntax(stdout,cmd_write_argtable,"\n");
-  puts("Writes firmware to SPI Flash");
+    puts("Writes firmware to SPI Flash");
-  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
-  int errors = arg_parse(argc, argv, cmd_write_argtable);
+cmd_write_parse_exec(int argc, char** argv) {
-  if (errors == 0) {
+    int errors = arg_parse(argc, argv, cmd_write_argtable);
-    return blisp_flash_firmware();  // TODO: Error code?
+    if (errors == 0) {
-
+        blisp_flash_firmware(); // TODO: Error code?
-  } else if (cmd->count == 1) {
+        return 1;
-    cmd_write_args_print_glossary();
+    } else if (cmd->count == 1) {
-    return BLISP_OK;
+        cmd_write_args_print_glossary();
-  }
+        return 1;
-  return BLISP_ERR_INVALID_COMMAND;
+    }
    return 0;
 }
 void cmd_write_args_print_syntax() {
-  arg_print_syntax(stdout, cmd_write_argtable, "\n");
+    arg_print_syntax(stdout,cmd_write_argtable,"\n");
 }
-void cmd_write_free() {
+void
-  arg_freetable(cmd_write_argtable,
+cmd_write_free() {
-                sizeof(cmd_write_argtable) / sizeof(cmd_write_argtable[0]));
+    arg_freetable(cmd_write_argtable,
                  sizeof(cmd_write_argtable) / sizeof(cmd_write_argtable[0]));
 }
-struct cmd cmd_write = {"write", cmd_write_args_init, cmd_write_parse_exec,
+struct cmd cmd_write
-                        cmd_write_args_print_syntax, cmd_write_free};
+    = { "write", cmd_write_args_init, cmd_write_parse_exec, cmd_write_args_print_syntax, cmd_write_free };
--- a/tools/blisp/src/common.c
+++ b/tools/blisp/src/common.c
@ -1,144 +0,0 @@
 // SPDX-License-Identifier: MIT
 #include "common.h"
 #include <argtable3.h>
 #include <blisp.h>
 #include <inttypes.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "blisp_easy.h"
 #include "error_codes.h"
 #include "util.h"
 void blisp_common_progress_callback(uint32_t current_value,
                                    uint32_t max_value) {
  printf("%" PRIu32 "b / %u (%.2f%%)\n", current_value, max_value,
         (((float)current_value / (float)max_value) * 100.0f));
 }
 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) {
    fprintf(stderr, "Chip type is invalid.\n");
    return BLISP_ERR_INVALID_CHIP_TYPE;
  }
  struct blisp_chip* chip = NULL;
  if (strcmp(chip_type->sval[0], "bl70x") == 0) {
    chip = &blisp_chip_bl70x;
  } else if (strcmp(chip_type->sval[0], "bl60x") == 0) {
    chip = &blisp_chip_bl60x;
  } else {
    fprintf(stderr, "Chip type is invalid.\n");
    return BLISP_ERR_INVALID_CHIP_TYPE;
  }
  blisp_return_t ret;
  ret = blisp_device_init(device, chip);
  if (ret != BLISP_OK) {
    fprintf(stderr, "Failed to init device.\n");
    return ret;
  }
  ret = blisp_device_open(device,
                          port_name->count == 1 ? port_name->sval[0] : NULL);
  if (ret != BLISP_OK) {
    fprintf(stderr, ret == BLISP_ERR_DEVICE_NOT_FOUND
                        ? "Device not found\n"
                        : "Failed to open device.\n");
    return ret;
  }
  return BLISP_OK;
 }
 /**
 * Prepares chip to access flash
 * this means performing handshake, and loading eflash_loader if needed.
 */
 blisp_return_t blisp_common_prepare_flash(struct blisp_device* device) {
  blisp_return_t ret = 0;
  printf("Sending a handshake...\n");
  ret = blisp_device_handshake(device, false);
  if (ret != BLISP_OK) {
    fprintf(stderr, "Failed to handshake with device.\n");
    return ret;
  }
  printf("Handshake successful!\nGetting chip info...\n");
  struct blisp_boot_info boot_info;
  ret = blisp_device_get_boot_info(device, &boot_info);
  if (ret != BLISP_OK) {
    fprintf(stderr, "Failed to get boot info.\n");
    return ret;
  }
  printf(
      "BootROM version %d.%d.%d.%d, ChipID: "
      "%02X%02X%02X%02X%02X%02X%02X%02X\n",
      boot_info.boot_rom_version[0], boot_info.boot_rom_version[1],
      boot_info.boot_rom_version[2], boot_info.boot_rom_version[3],
      boot_info.chip_id[0], boot_info.chip_id[1], boot_info.chip_id[2],
      boot_info.chip_id[3], boot_info.chip_id[4], boot_info.chip_id[5],
      boot_info.chip_id[6], boot_info.chip_id[7]);
  if (device->chip->load_eflash_loader == NULL) {
    return BLISP_OK;
  }
  if (boot_info.boot_rom_version[0] == 255 &&
      boot_info.boot_rom_version[1] == 255 &&
      boot_info.boot_rom_version[2] == 255 &&
      boot_info.boot_rom_version[3] == 255) {
    printf("Device already in eflash_loader.\n");
    return BLISP_OK;
  }
  uint8_t* eflash_loader_buffer = NULL;
  // TODO: Error check
  int64_t eflash_loader_buffer_length =
      device->chip->load_eflash_loader(0, &eflash_loader_buffer);
  struct blisp_easy_transport eflash_loader_transport =
      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);
  if (ret != BLISP_OK) {
    fprintf(stderr, "Failed to load eflash_loader, ret: %d\n", ret);
    goto exit1;
  }
  free(eflash_loader_buffer);
  eflash_loader_buffer = NULL;
  ret = blisp_device_check_image(device);
  if (ret != 0) {
    fprintf(stderr, "Failed to check image.\n");
    goto exit1;
  }
  ret = blisp_device_run_image(device);
  if (ret != BLISP_OK) {
    fprintf(stderr, "Failed to run image.\n");
    goto exit1;
  }
  printf("Sending a handshake...\n");
  ret = blisp_device_handshake(device, true);
  if (ret != BLISP_OK) {
    fprintf(stderr, "Failed to handshake with device.\n");
    goto exit1;
  }
  printf("Handshake with eflash_loader successful.\n");
 exit1:
  if (eflash_loader_buffer != NULL)
    free(eflash_loader_buffer);
  return ret;
 }
--- a/tools/blisp/src/common.h
+++ b/tools/blisp/src/common.h
@ -1,13 +0,0 @@
 // SPDX-License-Identifier: MIT
 #ifndef BLISP_COMMON_H
 #define BLISP_COMMON_H
 #include <stdint.h>
 #include <blisp.h>
 #include <argtable3.h>
 int32_t blisp_common_prepare_flash(struct blisp_device* device);
 void blisp_common_progress_callback(uint32_t current_value, uint32_t max_value);
 int32_t blisp_common_init_device(struct blisp_device* device, struct arg_str* port_name, struct arg_str* chip_type);
 #endif  // BLISP_COMMON_H
--- a/tools/blisp/src/file_parsers/CMakeLists.txt
+++ b/tools/blisp/src/file_parsers/CMakeLists.txt
@ -1,23 +0,0 @@
 list(APPEND ADD_INCLUDE
 "${CMAKE_CURRENT_SOURCE_DIR}/bin"
 "${CMAKE_CURRENT_SOURCE_DIR}/dfu"
 "${CMAKE_CURRENT_SOURCE_DIR}"
 )
 file(GLOB_RECURSE sources
 )
 list(APPEND ADD_SRCS  ${sources})
 add_library(file_parsers 
 "${CMAKE_CURRENT_SOURCE_DIR}/bin/bin_file.c"
 "${CMAKE_CURRENT_SOURCE_DIR}/dfu/dfu_file.c"
 "${CMAKE_CURRENT_SOURCE_DIR}/dfu/dfu_crc.c"
 "${CMAKE_CURRENT_SOURCE_DIR}/parse_file.c"
 )
 target_include_directories(file_parsers PUBLIC
 ${CMAKE_CURRENT_SOURCE_DIR}/bin
 ${CMAKE_CURRENT_SOURCE_DIR}/dfu
 ${CMAKE_CURRENT_SOURCE_DIR}
 )
--- a/tools/blisp/src/file_parsers/bin/bin_file.c
+++ b/tools/blisp/src/file_parsers/bin/bin_file.c
--- a/tools/blisp/src/file_parsers/bin/bin_file.h
+++ b/tools/blisp/src/file_parsers/bin/bin_file.h
@ -1,25 +0,0 @@
 //
 // Created by ralim on 01/08/23.
 //
 #ifndef BLISP_BIN_FILE_H
 #define BLISP_BIN_FILE_H
 #include <malloc.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <string.h>
 #ifdef __cplusplus
 extern "C" {
 #endif
 int bin_file_parse(const char* file_path_on_disk,
                   uint8_t** payload,
                   size_t* payload_length,
                   size_t* payload_address);
 #ifdef __cplusplus
 };
 #endif
 #endif  // BLISP_BIN_FILE_H
--- a/tools/blisp/src/file_parsers/parse_file.c
+++ b/tools/blisp/src/file_parsers/parse_file.c
@ -1,29 +0,0 @@
 #include "parse_file.h"
 #include <string.h>
 #include "dfu_file.h"
 const char* get_filename_ext(const char* filename) {
  const char* dot = strrchr(filename, '.');
  if (!dot || dot == filename)
    return "";
  return dot + 1;
 }
 int parse_firmware_file(const char* file_path_on_disk,
                        parsed_firmware_file_t* parsed_results) {
  // Switchcase on the extension of the file
  const char* ext = get_filename_ext(file_path_on_disk);
  if (strncmp(ext, "dfu", 3) == 0 || strncmp(ext, "DFU", 3) == 0) {
    printf("Input file identified as a .dfu file\r\n");
    // Handle as a .dfu file
    return dfu_file_parse("test.dfu", &parsed_results->payload,
                          &parsed_results->payload_length,
                          &parsed_results->payload_address);
  } else if (strncmp(ext, "bin", 3) == 0 || strncmp(ext, "BIN", 3) == 0) {
    printf("Input file identified as a .bin file\r\n");
    // Raw binary file
  }
  // TODO: Hex files?
  return PARSED_ERROR_INVALID_FILETYPE;
 }
--- a/tools/blisp/src/file_parsers/parse_file.h
+++ b/tools/blisp/src/file_parsers/parse_file.h
@ -1,14 +0,0 @@
 #pragma once
 #include "parsed_firmware_file.h"
 #define PARSED_ERROR_INVALID_FILETYPE -0x1000
 #define PARSED_ERROR_TOO_BIG -0x1001 /* Input expands to be too big */
 #define PARSED_ERROR_BAD_DFU -0x1002 /* DFU file provided but not valid */
 // This attempts to parse the given file, and returns the parsed version of that
 // file. This will handle any repacking required to create one contigious file
 // Eg if the input file has holes,they will be 0x00 filled
 // And headers etc are parsed to determine start position
 int parse_firmware_file(const char* file_path_on_disk,
                        parsed_firmware_file_t* parsed_results);
--- a/tools/blisp/src/file_parsers/parsed_firmware_file.h
+++ b/tools/blisp/src/file_parsers/parsed_firmware_file.h
@ -1,14 +0,0 @@
 #pragma once
 #include <stdint.h>
 #include <stdio.h>
 // Parsed firmware file is a generic struct that we parse from a user input
 // firmware file This is used so that we can (relatively) seamlessly handle
 // .bin, .hex and .def files
 typedef struct {
  bool needs_boot_struct;  // If true, boot struct should be generated
  uint8_t* payload;        // The main firmware payload
  size_t payload_length;   // Size of the payload
  size_t payload_address;  // Start address of the payload
 } parsed_firmware_file_t;
--- a/tools/blisp/src/main.c
+++ b/tools/blisp/src/main.c
@ -1,11 +1,12 @@
-// SPDX-License-Identifier: MIT
+#include "argtable3.h"
 #include "cmd.h"
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
 #include "argtable3.h"
 #include "cmd.h"
-struct cmd* cmds[] = {&cmd_write, &cmd_iot};
+struct cmd* cmds[] = {
    &cmd_write
 };
 static uint8_t cmds_count = sizeof(cmds) / sizeof(cmds[0]);
@ -14,90 +15,84 @@ static struct arg_lit* version;
 static struct arg_end* end;
 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");
+    argtable[2] = end = arg_end(20);
  argtable[2] = end = arg_end(20);
-  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() {
-  puts("Usage:");
+    puts("Usage:");
-  for (uint8_t i = 0; i < cmds_count; i++) {
+    for (uint8_t i = 0; i < cmds_count; i++) {
        fputs("  blisp", stdout);
        cmds[i]->args_print_syntax();
    }
    fputs("  blisp", stdout);
-    cmds[i]->args_print_syntax();
+    arg_print_syntax(stdout, argtable,"\n");
  }
  fputs("  blisp", stdout);
  arg_print_syntax(stdout, argtable, "\n");
 }
 int8_t args_parse_exec(int argc, char** argv) {
-  int error = arg_parse(argc, argv, argtable);
+    int error = arg_parse(argc, argv, argtable);
-  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.4\n");
+            printf("blisp 1.0.0\n");
-      printf("Copyright (C) 2023 Marek Kraus and PINE64 Community\n");
+            printf("Copyright (C) 2022 Marek Kraus and PINE64 Community\n");
-      return BLISP_OK;
+            return 1;
        }
    }
-  }
+    return 0;
  return BLISP_ERR_INVALID_COMMAND;
 }
 void args_free() {
-  arg_freetable(argtable, sizeof(argtable) / sizeof(argtable[0]));
+    arg_freetable(argtable, sizeof(argtable) / sizeof(argtable[0]));
 }
-int main(int argc, char** argv) {
+int
-  blisp_return_t ret = args_init();
+main(int argc, char** argv) {
-  if (ret != 0) {
+    int exit_code = 0;
    goto exit;
  }
-  for (uint8_t i = 0; i < cmds_count; i++) {
+    if (args_init() != 0) {
-    ret = cmds[i]->args_init();
+        exit_code = -1;
-    if (ret != BLISP_OK) {
+        goto exit;
      goto exit;
    }
  }
  // Try and parse as a help request
  {
    ret = args_parse_exec(argc, argv);
    if (ret == BLISP_OK) {
      goto exit;
    }
  }
-  uint8_t command_found = false;
+    for (uint8_t i = 0; i < cmds_count; i++) {
-  for (uint8_t i = 0; i < cmds_count; i++) {
+        if (cmds[i]->args_init() != 0) {
-    ret = cmds[i]->args_parse_exec(argc, argv);
+            exit_code = -1;
-    if (ret != BLISP_ERR_INVALID_COMMAND) {
+            goto exit;
-      command_found = true;
+        }
      break;
    }
  }
-  if (!command_found) {
+    if (args_parse_exec(argc, argv)) {
-    print_help();
+        goto exit;
-  }
+    }
    uint8_t command_found = false;
    for (uint8_t i = 0; i < cmds_count; i++) {
        if (cmds[i]->args_parse_exec(argc, argv)) {
            command_found = true;
            break;
        }
    }
    if (!command_found) {
        print_help();
    }
 exit:
-  for (uint8_t i = 0; i < cmds_count; i++) {
+    for (uint8_t i = 0; i < cmds_count; i++) {
-    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;
 }
--- a/tools/blisp/src/util.c
+++ b/tools/blisp/src/util.c
@ -1,51 +0,0 @@
 // SPDX-License-Identifier: MIT
 #include "util.h"
 #include <stdio.h>
 #include <stdint.h>
 #include <string.h>
 #ifdef __APPLE__
 // Ugh. This stuff is just so messy without C++17 or Qt...
 // These are not thread safe, but it doesn't place the responsibility
 // to free an allocated buffer on the caller.nn
 #include <stdlib.h>
 static void util_get_executable_path(char* buffer_out, uint32_t max_size) {
  assert(max_size >= PATH_MAX);  // n.b. 1024 on MacOS. 4K on most Linux.
  char raw_path_name[PATH_MAX];   // $HOME/../../var/tmp/x
  char real_path_name[PATH_MAX];  // /var/tmp/x
  uint32_t raw_path_size = sizeof(raw_path_name);
  if (!_NSGetExecutablePath(raw_path_name, &raw_path_size)) {
    realpath(raw_path_name, real_path_name);
  }
  // *real_path_name  is appropriately sized and null terminated.
  strcpy(buffer_out, real_path_name);
 }
 #endif
 ssize_t util_get_binary_folder(char* buffer, uint32_t buffer_size) {
 #ifdef __linux__
  if (readlink("/proc/self/exe", buffer, buffer_size) <= 0) {
    return -1;
  }
  char* pos = strrchr(buffer, '/');
 #elif defined(__APPLE__)
  util_get_executable_path(buffer, buffer_size);
  char* pos = strrchr(buffer, '/');
 #elif __FreeBSD__
  if (readlink("/proc/curproc/file", buffer, buffer_size) <= 0) {
    return -1;
  }
  char* pos = strrchr(buffer, '/');
 #else
  if (GetModuleFileName(NULL, buffer, buffer_size) <= 0) {
    return -1;
  }
  char* pos = strrchr(buffer, '\\');
 #endif
  pos[0] = '\0';
  return pos - buffer;
 }
--- a/tools/blisp/src/util.h
+++ b/tools/blisp/src/util.h
@ -1,23 +0,0 @@
 // SPDX-License-Identifier: MIT
 #ifndef BLISP_UTIL_H
 #define BLISP_UTIL_H
 #include <stdint.h>
 #if defined(_MSC_VER)
 #include <BaseTsd.h>
 typedef SSIZE_T ssize_t;
 #include <windows.h>
 #define PATH_MAX MAX_PATH
 #elif defined(__APPLE__)
 #include <sys/syslimits.h>
 #include <assert.h>
 #include <sys/types.h>
 #else
 #include <unistd.h>
 #endif
 ssize_t util_get_binary_folder(char* buffer, uint32_t buffer_size);
 #endif
Author	SHA1	Message	Date
Ben V. Brown	0713783a30	Parse targets Just grabbing first one for now	2022-09-26 22:20:50 +10:00
Ben V. Brown	a0bcc10c17	Expose crc Update CMakeLists.txt	2022-09-26 22:20:30 +10:00
Ben V. Brown	ea41715519	Test DFU file	2022-09-26 22:20:05 +10:00
Ben V. Brown	4af7b8bbee	Split crc function	2022-09-26 21:40:04 +10:00
Ben V. Brown	7fa6cad080	Fixup Zero init struct Dont null the pointer 🤦 correct fread	2022-09-26 21:22:05 +10:00
Ben V. Brown	24acefe8fe	Adding tests	2022-09-26 21:21:17 +10:00
Ben V. Brown	44e1da7b80	Create dfu_file.h	2022-09-26 21:00:25 +10:00
Ben V. Brown	d104f9ea44	Format	2022-09-26 21:00:18 +10:00
Ben V. Brown	120551b2d2	Scratching out more parsing	2022-09-25 21:46:04 +10:00
Ben V. Brown	dec938c353	Basic port parser	2022-09-25 21:34:20 +10:00
Ben V. Brown	ecd3babe8e	Scratching fread wrapper	2022-09-25 21:00:00 +10:00