diff --git a/inc/backend.h b/inc/backend.h
index 75c569fcf..a9a7d6e03 100644
--- a/inc/backend.h
+++ b/inc/backend.h
@@ -1,37 +1,39 @@
 #ifndef BACKEND_H
 #define BACKEND_H
 
+#include <stdint.h>
+
     typedef struct _stlink_backend {
         void (*close) (stlink_t * sl);
-        int (*exit_debug_mode) (stlink_t * sl);
-        int (*enter_swd_mode) (stlink_t * sl);
-        int (*enter_jtag_mode) (stlink_t * stl);
-        int (*exit_dfu_mode) (stlink_t * stl);
-        int (*core_id) (stlink_t * stl);
-        int (*reset) (stlink_t * stl);
-        int (*jtag_reset) (stlink_t * stl, int value);
-        int (*run) (stlink_t * stl, enum run_type type);
-        int (*status) (stlink_t * stl);
-        int (*version) (stlink_t *sl);
-        int (*read_debug32) (stlink_t *sl, uint32_t addr, uint32_t *data);
-        int (*read_mem32) (stlink_t *sl, uint32_t addr, uint16_t len);
-        int (*write_debug32) (stlink_t *sl, uint32_t addr, uint32_t data);
-        int (*write_mem32) (stlink_t *sl, uint32_t addr, uint16_t len);
-        int (*write_mem8) (stlink_t *sl, uint32_t addr, uint16_t len);
-        int (*read_all_regs) (stlink_t *sl, struct stlink_reg * regp);
-        int (*read_reg) (stlink_t *sl, int r_idx, struct stlink_reg * regp);
-        int (*read_all_unsupported_regs) (stlink_t *sl, struct stlink_reg *regp);
-        int (*read_unsupported_reg) (stlink_t *sl, int r_idx, struct stlink_reg *regp);
-        int (*write_unsupported_reg) (stlink_t *sl, uint32_t value, int idx, struct stlink_reg *regp);
-        int (*write_reg) (stlink_t *sl, uint32_t reg, int idx);
-        int (*step) (stlink_t * stl);
-        int (*current_mode) (stlink_t * stl);
-        int (*force_debug) (stlink_t *sl);
+        int32_t (*exit_debug_mode) (stlink_t * sl);
+        int32_t (*enter_swd_mode) (stlink_t * sl);
+        int32_t (*enter_jtag_mode) (stlink_t * stl);
+        int32_t (*exit_dfu_mode) (stlink_t * stl);
+        int32_t (*core_id) (stlink_t * stl);
+        int32_t (*reset) (stlink_t * stl);
+        int32_t (*jtag_reset) (stlink_t * stl, int32_t value);
+        int32_t (*run) (stlink_t * stl, enum run_type type);
+        int32_t (*status) (stlink_t * stl);
+        int32_t (*version) (stlink_t *sl);
+        int32_t (*read_debug32) (stlink_t *sl, uint32_t addr, uint32_t *data);
+        int32_t (*read_mem32) (stlink_t *sl, uint32_t addr, uint16_t len);
+        int32_t (*write_debug32) (stlink_t *sl, uint32_t addr, uint32_t data);
+        int32_t (*write_mem32) (stlink_t *sl, uint32_t addr, uint16_t len);
+        int32_t (*write_mem8) (stlink_t *sl, uint32_t addr, uint16_t len);
+        int32_t (*read_all_regs) (stlink_t *sl, struct stlink_reg * regp);
+        int32_t (*read_reg) (stlink_t *sl, int32_t r_idx, struct stlink_reg * regp);
+        int32_t (*read_all_unsupported_regs) (stlink_t *sl, struct stlink_reg *regp);
+        int32_t (*read_unsupported_reg) (stlink_t *sl, int32_t r_idx, struct stlink_reg *regp);
+        int32_t (*write_unsupported_reg) (stlink_t *sl, uint32_t value, int32_t idx, struct stlink_reg *regp);
+        int32_t (*write_reg) (stlink_t *sl, uint32_t reg, int32_t idx);
+        int32_t (*step) (stlink_t * stl);
+        int32_t (*current_mode) (stlink_t * stl);
+        int32_t (*force_debug) (stlink_t *sl);
         int32_t (*target_voltage) (stlink_t *sl);
-        int (*set_swdclk) (stlink_t * stl, int freq_khz);
-        int (*trace_enable) (stlink_t * sl, uint32_t frequency);
-        int (*trace_disable) (stlink_t * sl);
-        int (*trace_read) (stlink_t * sl, uint8_t* buf, size_t size);
+        int32_t (*set_swdclk) (stlink_t * stl, int32_t freq_khz);
+        int32_t (*trace_enable) (stlink_t * sl, uint32_t frequency);
+        int32_t (*trace_disable) (stlink_t * sl);
+        int32_t (*trace_read) (stlink_t * sl, uint8_t* buf, size_t size);
     } stlink_backend_t;
 
 #endif // BACKEND_H
diff --git a/inc/stlink.h b/inc/stlink.h
index b9379e03d..ca07a6a89 100644
--- a/inc/stlink.h
+++ b/inc/stlink.h
@@ -196,17 +196,17 @@ struct _stlink {
     unsigned char c_buf[C_BUF_LEN];
     // data transferred from or to device
     unsigned char q_buf[Q_BUF_LEN];
-    int q_len;
+    int32_t q_len;
 
     // transport layer verboseness: 0 for no debug info, 10 for lots
-    int verbose;
-    int opt;
+    int32_t verbose;
+    int32_t opt;
     uint32_t core_id;            // set by stlink_core_id(), result from STLINK_DEBUGREADCOREID
     uint32_t chip_id;            // set by stlink_load_device_params(), used to identify flash and sram
     enum target_state core_stat; // set by stlink_status()
 
     char serial[STLINK_SERIAL_BUFFER_SIZE];
-    int freq;                    // set by stlink_open_usb(), values: STLINK_SWDCLK_xxx_DIVISOR
+    int32_t freq;                    // set by stlink_open_usb(), values: STLINK_SWDCLK_xxx_DIVISOR
 
     enum stm32_flash_type flash_type;
     // stlink_chipid_params.flash_type, set by stlink_load_device_params(), values: STM32_FLASH_TYPE_xx
@@ -236,67 +236,67 @@ struct _stlink {
     uint32_t max_trace_freq;     // set by stlink_open_usb()
 };
 
-int stlink_enter_swd_mode(stlink_t *sl);
-int stlink_enter_jtag_mode(stlink_t *sl);
-int stlink_exit_debug_mode(stlink_t *sl);
-int stlink_exit_dfu_mode(stlink_t *sl);
+int32_t stlink_enter_swd_mode(stlink_t *sl);
+int32_t stlink_enter_jtag_mode(stlink_t *sl);
+int32_t stlink_exit_debug_mode(stlink_t *sl);
+int32_t stlink_exit_dfu_mode(stlink_t *sl);
 void stlink_close(stlink_t *sl);
-int stlink_core_id(stlink_t *sl);
-int stlink_reset(stlink_t *sl, enum reset_type type);
-int stlink_run(stlink_t *sl, enum run_type type);
-int stlink_status(stlink_t *sl);
-int stlink_version(stlink_t *sl);
-int stlink_read_debug32(stlink_t *sl, uint32_t addr, uint32_t *data);
-int stlink_read_mem32(stlink_t *sl, uint32_t addr, uint16_t len);
-int stlink_write_debug32(stlink_t *sl, uint32_t addr, uint32_t data);
-int stlink_write_mem32(stlink_t *sl, uint32_t addr, uint16_t len);
-int stlink_write_mem8(stlink_t *sl, uint32_t addr, uint16_t len);
-int stlink_read_all_regs(stlink_t *sl, struct stlink_reg *regp);
-int stlink_read_all_unsupported_regs(stlink_t *sl, struct stlink_reg *regp);
-int stlink_read_reg(stlink_t *sl, int r_idx, struct stlink_reg *regp);
-int stlink_read_unsupported_reg(stlink_t *sl, int r_idx, struct stlink_reg *regp);
-int stlink_write_unsupported_reg(stlink_t *sl, uint32_t value, int r_idx, struct stlink_reg *regp);
-int stlink_write_reg(stlink_t *sl, uint32_t reg, int idx);
-int stlink_step(stlink_t *sl);
-int stlink_current_mode(stlink_t *sl);
-int stlink_force_debug(stlink_t *sl);
-int stlink_target_voltage(stlink_t *sl);
-int stlink_set_swdclk(stlink_t *sl, int freq_khz);
-int stlink_trace_enable(stlink_t* sl, uint32_t frequency);
-int stlink_trace_disable(stlink_t* sl);
-int stlink_trace_read(stlink_t* sl, uint8_t* buf, size_t size);
-int stlink_erase_flash_mass(stlink_t* sl);
-int stlink_erase_flash_section(stlink_t *sl, stm32_addr_t base_addr, size_t size, bool align_size);
-int stlink_write_flash(stlink_t* sl, stm32_addr_t address, uint8_t* data, uint32_t length, uint8_t eraseonly);
-int stlink_parse_ihex(const char* path, uint8_t erased_pattern, uint8_t * * mem, size_t * size, uint32_t * begin);
+int32_t stlink_core_id(stlink_t *sl);
+int32_t stlink_reset(stlink_t *sl, enum reset_type type);
+int32_t stlink_run(stlink_t *sl, enum run_type type);
+int32_t stlink_status(stlink_t *sl);
+int32_t stlink_version(stlink_t *sl);
+int32_t stlink_read_debug32(stlink_t *sl, uint32_t addr, uint32_t *data);
+int32_t stlink_read_mem32(stlink_t *sl, uint32_t addr, uint16_t len);
+int32_t stlink_write_debug32(stlink_t *sl, uint32_t addr, uint32_t data);
+int32_t stlink_write_mem32(stlink_t *sl, uint32_t addr, uint16_t len);
+int32_t stlink_write_mem8(stlink_t *sl, uint32_t addr, uint16_t len);
+int32_t stlink_read_all_regs(stlink_t *sl, struct stlink_reg *regp);
+int32_t stlink_read_all_unsupported_regs(stlink_t *sl, struct stlink_reg *regp);
+int32_t stlink_read_reg(stlink_t *sl, int32_t r_idx, struct stlink_reg *regp);
+int32_t stlink_read_unsupported_reg(stlink_t *sl, int32_t r_idx, struct stlink_reg *regp);
+int32_t stlink_write_unsupported_reg(stlink_t *sl, uint32_t value, int32_t r_idx, struct stlink_reg *regp);
+int32_t stlink_write_reg(stlink_t *sl, uint32_t reg, int32_t idx);
+int32_t stlink_step(stlink_t *sl);
+int32_t stlink_current_mode(stlink_t *sl);
+int32_t stlink_force_debug(stlink_t *sl);
+int32_t stlink_target_voltage(stlink_t *sl);
+int32_t stlink_set_swdclk(stlink_t *sl, int32_t freq_khz);
+int32_t stlink_trace_enable(stlink_t* sl, uint32_t frequency);
+int32_t stlink_trace_disable(stlink_t* sl);
+int32_t stlink_trace_read(stlink_t* sl, uint8_t* buf, size_t size);
+int32_t stlink_erase_flash_mass(stlink_t* sl);
+int32_t stlink_erase_flash_section(stlink_t *sl, stm32_addr_t base_addr, size_t size, bool align_size);
+int32_t stlink_write_flash(stlink_t* sl, stm32_addr_t address, uint8_t* data, uint32_t length, uint8_t eraseonly);
+int32_t stlink_parse_ihex(const char* path, uint8_t erased_pattern, uint8_t * * mem, size_t * size, uint32_t * begin);
 uint8_t stlink_get_erased_pattern(stlink_t *sl);
-int stlink_mwrite_flash(stlink_t *sl, uint8_t* data, uint32_t length, stm32_addr_t addr);
-int stlink_fwrite_flash(stlink_t *sl, const char* path, stm32_addr_t addr);
-int stlink_mwrite_sram(stlink_t *sl, uint8_t* data, uint32_t length, stm32_addr_t addr);
-int stlink_fwrite_sram(stlink_t *sl, const char* path, stm32_addr_t addr);
-int stlink_verify_write_flash(stlink_t *sl, stm32_addr_t address, uint8_t *data, uint32_t length);
+int32_t stlink_mwrite_flash(stlink_t *sl, uint8_t* data, uint32_t length, stm32_addr_t addr);
+int32_t stlink_fwrite_flash(stlink_t *sl, const char* path, stm32_addr_t addr);
+int32_t stlink_mwrite_sram(stlink_t *sl, uint8_t* data, uint32_t length, stm32_addr_t addr);
+int32_t stlink_fwrite_sram(stlink_t *sl, const char* path, stm32_addr_t addr);
+int32_t stlink_verify_write_flash(stlink_t *sl, stm32_addr_t address, uint8_t *data, uint32_t length);
 
-//int stlink_chip_id(stlink_t *sl, uint32_t *chip_id);
-int stlink_cpu_id(stlink_t *sl, cortex_m3_cpuid_t *cpuid);
+//int32_t stlink_chip_id(stlink_t *sl, uint32_t *chip_id);
+int32_t stlink_cpu_id(stlink_t *sl, cortex_m3_cpuid_t *cpuid);
 
-int stlink_erase_flash_page(stlink_t* sl, stm32_addr_t flashaddr);
+int32_t stlink_erase_flash_page(stlink_t* sl, stm32_addr_t flashaddr);
 uint32_t stlink_calculate_pagesize(stlink_t *sl, uint32_t flashaddr);
-int stlink_check_address_range_validity(stlink_t *sl, stm32_addr_t addr, size_t size);
-int stlink_check_address_alignment(stlink_t *sl, stm32_addr_t addr);
-uint16_t read_uint16(const unsigned char *c, const int pt);
+int32_t stlink_check_address_range_validity(stlink_t *sl, stm32_addr_t addr, size_t size);
+int32_t stlink_check_address_alignment(stlink_t *sl, stm32_addr_t addr);
+uint16_t read_uint16(const unsigned char *c, const int32_t pt);
 //void stlink_core_stat(stlink_t *sl);
 void stlink_print_data(stlink_t *sl);
-unsigned int is_bigendian(void);
-uint32_t read_uint32(const unsigned char *c, const int pt);
+uint32_t is_bigendian(void);
+uint32_t read_uint32(const unsigned char *c, const int32_t pt);
 void write_uint32(unsigned char* buf, uint32_t ui);
 void write_uint16(unsigned char* buf, uint16_t ui);
 bool stlink_is_core_halted(stlink_t *sl);
-int write_buffer_to_sram(stlink_t *sl, flash_loader_t* fl, const uint8_t* buf, size_t size);
-int write_loader_to_sram(stlink_t *sl, stm32_addr_t* addr, size_t* size);
-int stlink_fread(stlink_t* sl, const char* path, bool is_ihex, stm32_addr_t addr, size_t size);
-int stlink_load_device_params(stlink_t *sl);
+int32_t write_buffer_to_sram(stlink_t *sl, flash_loader_t* fl, const uint8_t* buf, size_t size);
+int32_t write_loader_to_sram(stlink_t *sl, stm32_addr_t* addr, size_t* size);
+int32_t stlink_fread(stlink_t* sl, const char* path, bool is_ihex, stm32_addr_t addr, size_t size);
+int32_t stlink_load_device_params(stlink_t *sl);
 
-int stlink_target_connect(stlink_t *sl, enum connect_type connect);
+int32_t stlink_target_connect(stlink_t *sl, enum connect_type connect);
 
 #include <sg.h>
 #include <usb.h>
diff --git a/inc/stm32.h b/inc/stm32.h
index f91269a34..eee1b0433 100644
--- a/inc/stm32.h
+++ b/inc/stm32.h
@@ -7,6 +7,8 @@
 #ifndef STM32_H
 #define STM32_H
 
+#include <stdint.h>
+
 /* STM32 Cortex-M core ids (CPUTAPID) */
 enum stm32_core_id {
     STM32_CORE_ID_M0_SWD        = 0x0bb11477,   // (RM0091 Section 32.5.3) F0 SW-DP
diff --git a/inc/stm32flash.h b/inc/stm32flash.h
index 5cb0ee1df..69c6206ee 100644
--- a/inc/stm32flash.h
+++ b/inc/stm32flash.h
@@ -1,6 +1,8 @@
 #ifndef STM32FLASH_H
 #define STM32FLASH_H
 
+#include <stdint.h>
+
 /* STM32Fx FPEC flash controller interface, PM0063 manual */
 // STM32F05x is identical, based on RM0091 (DM00031936, Doc ID 018940 Rev.2, Aug 2012)
 #define FLASH_REGS_ADDR 0x40022000
diff --git a/src/st-flash/flash.c b/src/st-flash/flash.c
index bbb52d80c..6b4a10cfc 100644
--- a/src/st-flash/flash.c
+++ b/src/st-flash/flash.c
@@ -1,6 +1,7 @@
 /* Simple wrapper around the stlink_flash_write function */
 
 #include <stdio.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -20,7 +21,7 @@
 
 static stlink_t *connected_stlink = NULL;
 
-static void cleanup(int signum) {
+static void cleanup(int32_t signum) {
     (void)signum;
 
     if (connected_stlink) { // switch back to mass storage mode before closing
@@ -52,10 +53,10 @@ static void usage(void) {
     puts("example write option control register1 byte:  ./st-flash --area=optcr1 write 0xXXXXXXXX");
 }
 
-int main(int ac, char** av) {
+int32_t main(int32_t ac, char** av) {
     stlink_t* sl = NULL;
     struct flash_opts o;
-    int err = -1;
+    int32_t err = -1;
     uint8_t * mem = NULL;
 
     o.size = 0;
@@ -82,7 +83,7 @@ int main(int ac, char** av) {
 
     if ( o.flash_size != 0u && o.flash_size != sl->flash_size ) {
         sl->flash_size = o.flash_size;
-        printf("Forcing flash size: --flash=0x%08X\n", (unsigned int)sl->flash_size);
+        printf("Forcing flash size: --flash=0x%08X\n", (uint32_t)sl->flash_size);
     }
 
     sl->verbose = o.log_level;
@@ -222,8 +223,8 @@ int main(int ac, char** av) {
         } else if (o.area == FLASH_OPTION_BYTES) {
             size_t remaining_option_length = sl->option_size / 4;
             DLOG("@@@@ Read %u (%#x) option bytes from %#10x\n",
-                (unsigned)remaining_option_length,
-                (unsigned)remaining_option_length,
+                (uint32_t)remaining_option_length,
+                (uint32_t)remaining_option_length,
                 sl->option_base);
 
             uint32_t option_byte = 0;
@@ -232,7 +233,7 @@ int main(int ac, char** av) {
                 printf("could not read option bytes (%d)\n", err);
                 goto on_error;
             } else if (NULL != o.filename) {
-                int fd = open(o.filename, O_RDWR | O_TRUNC | O_CREAT | O_BINARY, 00700);
+                int32_t fd = open(o.filename, O_RDWR | O_TRUNC | O_CREAT | O_BINARY, 00700);
                 if (fd == -1) {
                     fprintf(stderr, "open(%s) == -1\n", o.filename);
                     goto on_error;
diff --git a/src/st-flash/flash.h b/src/st-flash/flash.h
index 4aa6033f8..1a509a660 100644
--- a/src/st-flash/flash.h
+++ b/src/st-flash/flash.h
@@ -18,19 +18,19 @@ struct flash_opts {
     const char* filename;
     stm32_addr_t addr;
     size_t size;
-    int reset;
-    int log_level;
+    int32_t reset;
+    int32_t log_level;
     enum flash_format format;
     enum flash_area area;
     uint32_t val;
     size_t flash_size;  // --flash=n[k, M]
-    int opt;            // enable empty tail data drop optimization
-    int freq;           // --freq=n[k, M] frequency of JTAG/SWD
+    int32_t opt;            // enable empty tail data drop optimization
+    int32_t freq;           // --freq=n[k, M] frequency of JTAG/SWD
     enum connect_type connect;
 };
 
 #define FLASH_OPTS_INITIALIZER {0, { 0 }, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 
-int flash_get_opts(struct flash_opts* o, int ac, char** av);
+int32_t flash_get_opts(struct flash_opts* o, int32_t ac, char** av);
 
 #endif // FLASH_H
diff --git a/src/st-flash/flash_opts.c b/src/st-flash/flash_opts.c
index 984156aa3..e133d52c7 100644
--- a/src/st-flash/flash_opts.c
+++ b/src/st-flash/flash_opts.c
@@ -1,3 +1,4 @@
+#include <stdint.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
@@ -18,7 +19,7 @@ static bool starts_with(const char * str, const char * prefix) {
 // support decimal, hexadecimal, octal, binary format like 0xff 12 1k 1M, 0b1001
 // negative numbers are not supported
 // return 0 if success else return -1
-static int get_long_integer_from_char_array (const char *const str, uint64_t *read_value) {
+static int32_t get_long_integer_from_char_array (const char *const str, uint64_t *read_value) {
     uint64_t value;
     char *tail;
 
@@ -50,9 +51,9 @@ static int get_long_integer_from_char_array (const char *const str, uint64_t *re
 // support decimal, hexadecimal, octal, binary format like 0xff 12 1k 1M, 0b1001
 // negative numbers are not supported
 // return 0 if success else return -1
-static int get_integer_from_char_array (const char *const str, uint32_t *read_value) {
+static int32_t get_integer_from_char_array (const char *const str, uint32_t *read_value) {
     uint64_t value;
-    int result = get_long_integer_from_char_array (str, &value);
+    int32_t result = get_long_integer_from_char_array (str, &value);
 
     if (result != 0) {
         return(result);
@@ -65,24 +66,24 @@ static int get_integer_from_char_array (const char *const str, uint32_t *read_va
     }
 }
 
-static int invalid_args(const char *expected) {
+static int32_t invalid_args(const char *expected) {
     fprintf(stderr, "*** Error: Expected args for this command: %s\n", expected);
     return(-1);
 }
 
-static int bad_arg(const char *arg) {
+static int32_t bad_arg(const char *arg) {
     fprintf(stderr, "*** Error: Invalid value for %s\n", arg);
     return(-1);
 }
 
-int flash_get_opts(struct flash_opts* o, int ac, char** av) {
+int32_t flash_get_opts(struct flash_opts* o, int32_t ac, char** av) {
 
     // defaults
     memset(o, 0, sizeof(*o));
     o->log_level = STND_LOG_LEVEL;
 
     // options
-    int result;
+    int32_t result;
 
     while (ac >= 1) {
         if (strcmp(av[0], "--version") == 0) {
diff --git a/src/st-info/info.c b/src/st-info/info.c
index 9963606e3..86a1c2d8f 100644
--- a/src/st-info/info.c
+++ b/src/st-info/info.c
@@ -1,4 +1,5 @@
 #include <stdio.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
@@ -42,26 +43,26 @@ static void stlink_print_info(stlink_t *sl) {
     if (params) { printf("  dev-type:   %s\n", params->dev_type); }
 }
 
-static void stlink_probe(enum connect_type connect, int freq) {
+static void stlink_probe(enum connect_type connect, int32_t freq) {
     stlink_t **stdevs;
     size_t size;
 
     size = stlink_probe_usb(&stdevs, connect, freq);
 
-    printf("Found %u stlink programmers\n", (unsigned int)size);
+    printf("Found %u stlink programmers\n", (uint32_t)size);
 
     for (size_t n = 0; n < size; n++) {
-        if (size > 1) printf("%u.\n", (unsigned int)n+1);
+        if (size > 1) printf("%u.\n", (uint32_t)n+1);
         stlink_print_info(stdevs[n]);
     }
 
     stlink_probe_usb_free(&stdevs, size);
 }
 
-static int print_data(int ac, char **av) {
+static int32_t print_data(int32_t ac, char **av) {
     stlink_t* sl = NULL;
     enum connect_type connect = CONNECT_NORMAL;
-    int freq = 0;
+    int32_t freq = 0;
 
     if (strcmp(av[1], "--version") == 0) {
         printf("v%s\n", STLINK_VERSION);
@@ -70,7 +71,7 @@ static int print_data(int ac, char **av) {
 
     init_chipids(STLINK_CHIPS_DIR);
 
-    for (int i=2; i<ac; i++) {
+    for (int32_t i=2; i<ac; i++) {
         
         if (strcmp(av[i], "--connect-under-reset") == 0) {
             connect = CONNECT_UNDER_RESET;
@@ -128,8 +129,8 @@ static int print_data(int ac, char **av) {
     return(0);
 }
 
-int main(int ac, char** av) {
-    int err = -1;
+int32_t main(int32_t ac, char** av) {
+    int32_t err = -1;
 
     if (ac < 2) {
         usage();
diff --git a/src/st-trace/trace.c b/src/st-trace/trace.c
index 8c6e3c62b..8b148f463 100644
--- a/src/st-trace/trace.c
+++ b/src/st-trace/trace.c
@@ -3,6 +3,7 @@
 #include <signal.h>
 #include <stdbool.h>
 #include <stdio.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
@@ -41,7 +42,7 @@
 typedef struct {
   bool show_help;
   bool show_version;
-  int logging_level;
+  int32_t logging_level;
   uint32_t core_frequency;
   uint32_t trace_frequency;
   bool reset_board;
@@ -144,7 +145,7 @@ static bool parse_frequency(char* text, uint32_t* result)
   return true;
 }
 
-bool parse_options(int argc, char **argv, st_settings_t *settings) {
+bool parse_options(int32_t argc, char **argv, st_settings_t *settings) {
 
   static struct option long_options[] = {
       {"help", no_argument, NULL, 'h'},
@@ -157,8 +158,8 @@ bool parse_options(int argc, char **argv, st_settings_t *settings) {
       {"force", no_argument, NULL, 'f'},
       {0, 0, 0, 0},
   };
-  int option_index = 0;
-  int c;
+  int32_t option_index = 0;
+  int32_t c;
   bool error = false;
 
   settings->show_help = false;
@@ -421,7 +422,7 @@ static trace_state update_trace(st_trace_t *trace, uint8_t c) {
 
 static bool read_trace(stlink_t *stlink, st_trace_t *trace) {
   uint8_t buffer[STLINK_TRACE_BUF_LEN];
-  int length = stlink_trace_read(stlink, buffer, sizeof(buffer));
+  int32_t length = stlink_trace_read(stlink, buffer, sizeof(buffer));
 
   if (length < 0) {
     ELOG("Error reading trace (%d)\n", length);
@@ -441,7 +442,7 @@ static bool read_trace(stlink_t *stlink, st_trace_t *trace) {
     trace->state = TRACE_STATE_UNKNOWN;
   }
 
-  for (int i = 0; i < length; i++) {
+  for (int32_t i = 0; i < length; i++) {
     trace->state = update_trace(trace, buffer[i]);
   }
 
@@ -531,7 +532,7 @@ static void check_for_configuration_error(stlink_t *stlink, st_trace_t *trace,
   WLOG("****\n");
 }
 
-int main(int argc, char **argv) {
+int32_t main(int32_t argc, char **argv) {
 #if defined(_WIN32)
   SetConsoleCtrlHandler((PHANDLER_ROUTINE)CtrlHandler, TRUE);
 #else
diff --git a/src/st-util/gdb-remote.c b/src/st-util/gdb-remote.c
index bdf8afd24..7d0f2c731 100644
--- a/src/st-util/gdb-remote.c
+++ b/src/st-util/gdb-remote.c
@@ -5,8 +5,8 @@
 
 #include <stdio.h>
 #include <string.h>
-#include <stdlib.h>
 #include <stdint.h>
+#include <stdlib.h>
 
 #if defined(_WIN32)
 #include <win32_socket.h>
@@ -19,9 +19,9 @@
 
 static const char hex[] = "0123456789abcdef";
 
-int gdb_send_packet(int fd, char* data) {
-    unsigned int data_length = (unsigned int)strlen(data);
-    int length = data_length + 4;
+int32_t gdb_send_packet(int32_t fd, char* data) {
+    uint32_t data_length = (uint32_t)strlen(data);
+    int32_t length = data_length + 4;
     char* packet = malloc(length); // '$' data (hex) '#' cksum (hex)
 
     memset(packet, 0, length);
@@ -30,7 +30,7 @@ int gdb_send_packet(int fd, char* data) {
 
     uint8_t cksum = 0;
 
-    for (unsigned int i = 0; i < data_length; i++) {
+    for (uint32_t i = 0; i < data_length; i++) {
         packet[i + 1] = data[i];
         cksum += data[i];
     }
@@ -61,12 +61,12 @@ int gdb_send_packet(int fd, char* data) {
 
 #define ALLOC_STEP 1024
 
-int gdb_recv_packet(int fd, char** buffer) {
-    unsigned packet_size = ALLOC_STEP + 1, packet_idx = 0;
+int32_t gdb_recv_packet(int32_t fd, char** buffer) {
+    uint32_t packet_size = ALLOC_STEP + 1, packet_idx = 0;
     uint8_t cksum = 0;
     char recv_cksum[3] = {0};
     char* packet_buffer = malloc(packet_size);
-    unsigned state;
+    uint32_t state;
 
     if (packet_buffer == NULL) {
         return(-2);
@@ -167,7 +167,7 @@ int gdb_recv_packet(int fd, char** buffer) {
  * As we use the mode with ACK, in a (very unlikely) situation of a packet lost
  * because of this skipping, it will be resent anyway.
  */
-int gdb_check_for_interrupt(int fd) {
+int32_t gdb_check_for_interrupt(int32_t fd) {
     struct pollfd pfd;
     pfd.fd = fd;
     pfd.events = POLLIN;
diff --git a/src/st-util/gdb-remote.h b/src/st-util/gdb-remote.h
index 03d6aea10..ec990455b 100644
--- a/src/st-util/gdb-remote.h
+++ b/src/st-util/gdb-remote.h
@@ -1,8 +1,10 @@
 #ifndef GDB_REMOTE_H
 #define GDB_REMOTE_H
 
-int gdb_send_packet(int fd, char* data);
-int gdb_recv_packet(int fd, char** buffer);
-int gdb_check_for_interrupt(int fd);
+#include <stdint.h>
+
+int32_t gdb_send_packet(int32_t fd, char* data);
+int32_t gdb_recv_packet(int32_t fd, char** buffer);
+int32_t gdb_check_for_interrupt(int32_t fd);
 
 #endif // GDB_REMOTE_H
diff --git a/src/st-util/gdb-server.c b/src/st-util/gdb-server.c
index 99cc0170b..557a24f5f 100644
--- a/src/st-util/gdb-server.c
+++ b/src/st-util/gdb-server.c
@@ -8,6 +8,7 @@
 #include <signal.h>
 #include <stdio.h>
 #include <string.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <sys/types.h>
 
@@ -57,18 +58,18 @@ static const char hex[] = "0123456789abcdef";
 
 typedef struct _st_state_t {
     // things from command line, bleh
-    int logging_level;
-    int listen_port;
-    int persistent;
+    int32_t logging_level;
+    int32_t listen_port;
+    int32_t persistent;
     enum connect_type connect_mode;
-    int freq;
+    int32_t freq;
     char serialnumber[STLINK_SERIAL_BUFFER_SIZE];
     bool semihosting;
     const char* current_memory_map;
 } st_state_t;
 
 
-int serve(stlink_t *sl, st_state_t *st);
+int32_t serve(stlink_t *sl, st_state_t *st);
 char* make_memory_map(stlink_t *sl);
 static void init_cache(stlink_t *sl);
 
@@ -81,7 +82,7 @@ static void _cleanup() {
     }
 }
 
-static void cleanup(int signum) {
+static void cleanup(int32_t signum) {
     printf("Receive signal %i. Exiting...\n", signum);
     _cleanup();
     exit(1);
@@ -90,13 +91,13 @@ static void cleanup(int signum) {
 
 #if defined(_WIN32)
 BOOL WINAPI CtrlHandler(DWORD fdwCtrlType) {
-    printf("Receive signal %i. Exiting...\r\n", (int)fdwCtrlType);
+    printf("Receive signal %i. Exiting...\r\n", (int32_t)fdwCtrlType);
     _cleanup();
     return FALSE;
 }
 #endif
 
-int parse_options(int argc, char** argv, st_state_t *st) {
+int32_t parse_options(int32_t argc, char** argv, st_state_t *st) {
     static struct option long_options[] = {
         {"help", no_argument, NULL, 'h'},
         {"verbose", optional_argument, NULL, 'v'},
@@ -139,9 +140,9 @@ int parse_options(int argc, char** argv, st_state_t *st) {
     ;
 
 
-    int option_index = 0;
-    int c;
-    int q;
+    int32_t option_index = 0;
+    int32_t c;
+    int32_t q;
 
     while ((c = getopt_long(argc, argv, "hv::p:mn", long_options, &option_index)) != -1)
         switch (c) {
@@ -211,7 +212,7 @@ int parse_options(int argc, char** argv, st_state_t *st) {
     return(0);
 }
 
-int main(int argc, char** argv) {
+int32_t main(int32_t argc, char** argv) {
     stlink_t *sl = NULL;
     st_state_t state;
     memset(&state, 0, sizeof(state));
@@ -564,42 +565,42 @@ char* make_memory_map(stlink_t *sl) {
         strcpy(map, memory_map_template_F4_DE);
     } else if (sl->core_id == STM32_CORE_ID_M7F_SWD) {
         snprintf(map, sz, memory_map_template_F7,
-                 (unsigned int)sl->sram_size);
+                 (uint32_t)sl->sram_size);
     } else if (sl->chip_id == STM32_CHIPID_H74xxx) {
         snprintf(map, sz, memory_map_template_H7,
-                 (unsigned int)sl->flash_size,
-                 (unsigned int)sl->flash_pgsz);
+                 (uint32_t)sl->flash_size,
+                 (uint32_t)sl->flash_pgsz);
     } else if (sl->chip_id == STM32_CHIPID_F4_HD) {
         strcpy(map, memory_map_template_F4_HD);
     } else if (sl->chip_id == STM32_CHIPID_F2) {
         snprintf(map, sz, memory_map_template_F2,
-                 (unsigned int)sl->flash_size,
-                 (unsigned int)sl->sram_size,
-                 (unsigned int)sl->flash_size - 0x20000,
-                 (unsigned int)sl->sys_base,
-                 (unsigned int)sl->sys_size);
+                 (uint32_t)sl->flash_size,
+                 (uint32_t)sl->sram_size,
+                 (uint32_t)sl->flash_size - 0x20000,
+                 (uint32_t)sl->sys_base,
+                 (uint32_t)sl->sys_size);
     } else if ((sl->chip_id == STM32_CHIPID_L4) ||
                (sl->chip_id == STM32_CHIPID_L43x_L44x) ||
                (sl->chip_id == STM32_CHIPID_L45x_L46x)) {
         snprintf(map, sz, memory_map_template_L4,
-                 (unsigned int)sl->flash_size,
-                 (unsigned int)sl->flash_size);
+                 (uint32_t)sl->flash_size,
+                 (uint32_t)sl->flash_size);
     } else if (sl->chip_id == STM32_CHIPID_L496x_L4A6x) {
         snprintf(map, sz, memory_map_template_L496,
-                 (unsigned int)sl->flash_size,
-                 (unsigned int)sl->flash_size);
+                 (uint32_t)sl->flash_size,
+                 (uint32_t)sl->flash_size);
     } else if (sl->chip_id == STM32_CHIPID_H72x) {
         snprintf(map, sz, memory_map_template_H72x3x,
-                 (unsigned int)sl->flash_size,
-                 (unsigned int)sl->flash_pgsz);
+                 (uint32_t)sl->flash_size,
+                 (uint32_t)sl->flash_pgsz);
 	} else {
         snprintf(map, sz, memory_map_template,
-                 (unsigned int)sl->flash_size,
-                 (unsigned int)sl->sram_size,
-                 (unsigned int)sl->flash_size,
-                 (unsigned int)sl->flash_pgsz,
-                 (unsigned int)sl->sys_base,
-                 (unsigned int)sl->sys_size);
+                 (uint32_t)sl->flash_size,
+                 (uint32_t)sl->sram_size,
+                 (uint32_t)sl->flash_size,
+                 (uint32_t)sl->flash_pgsz,
+                 (uint32_t)sl->sys_base,
+                 (uint32_t)sl->sys_size);
     }
 
     return(map);
@@ -627,14 +628,14 @@ static void init_data_watchpoints(stlink_t *sl) {
     stlink_write_debug32(sl, STLINK_REG_CM3_DEMCR, data);
 
     // make sure all watchpoints are cleared
-    for (int i = 0; i < DATA_WATCH_NUM; i++) {
+    for (int32_t i = 0; i < DATA_WATCH_NUM; i++) {
         data_watches[i].fun = WATCHDISABLED;
         stlink_write_debug32(sl, STLINK_REG_CM3_DWT_FUNn(i), 0);
     }
 }
 
-static int add_data_watchpoint(stlink_t *sl, enum watchfun wf, stm32_addr_t addr, unsigned int len) {
-    int i = 0;
+static int32_t add_data_watchpoint(stlink_t *sl, enum watchfun wf, stm32_addr_t addr, uint32_t len) {
+    int32_t i = 0;
     uint32_t mask, dummy;
 
     // computer mask
@@ -678,8 +679,8 @@ static int add_data_watchpoint(stlink_t *sl, enum watchfun wf, stm32_addr_t addr
     return(-1);
 }
 
-static int delete_data_watchpoint(stlink_t *sl, stm32_addr_t addr) {
-    int i;
+static int32_t delete_data_watchpoint(stlink_t *sl, stm32_addr_t addr) {
+    int32_t i;
 
     for (i = 0; i < DATA_WATCH_NUM; i++) {
         if ((data_watches[i].addr == addr) && (data_watches[i].fun != WATCHDISABLED)) {
@@ -697,9 +698,9 @@ static int delete_data_watchpoint(stlink_t *sl, stm32_addr_t addr) {
     return(-1);
 }
 
-static int code_break_num;
-static int code_lit_num;
-static int code_break_rev;
+static int32_t code_break_num;
+static int32_t code_lit_num;
+static int32_t code_break_rev;
 #define CODE_BREAK_NUM_MAX 15
 #define CODE_BREAK_LOW     0x01
 #define CODE_BREAK_HIGH    0x02
@@ -709,13 +710,13 @@ static int code_break_rev;
 
 struct code_hw_breakpoint {
     stm32_addr_t addr;
-    int type;
+    int32_t type;
 };
 
 static struct code_hw_breakpoint code_breaks[CODE_BREAK_NUM_MAX];
 
 static void init_code_breakpoints(stlink_t *sl) {
-    unsigned int val;
+    uint32_t val;
     memset(sl->q_buf, 0, 4);
     stlink_write_debug32(sl, STLINK_REG_CM3_FP_CTRL, 0x03 /* KEY | ENABLE */);
     stlink_read_debug32(sl, STLINK_REG_CM3_FP_CTRL, &val);
@@ -732,22 +733,22 @@ static void init_code_breakpoints(stlink_t *sl) {
         stlink_write_debug32(sl, STLINK_REG_CM7_FP_LAR, STLINK_REG_CM7_FP_LAR_KEY);
     }
 
-    for (int i = 0; i < code_break_num; i++) {
+    for (int32_t i = 0; i < code_break_num; i++) {
         code_breaks[i].type = 0;
         stlink_write_debug32(sl, STLINK_REG_CM3_FP_COMPn(i), 0);
     }
 }
 
-static int has_breakpoint(stm32_addr_t addr) {
-    for (int i = 0; i < code_break_num; i++)
+static int32_t has_breakpoint(stm32_addr_t addr) {
+    for (int32_t i = 0; i < code_break_num; i++)
         if (code_breaks[i].addr == addr) { return(1); }
 
     return(0);
 }
 
-static int update_code_breakpoint(stlink_t *sl, stm32_addr_t addr, int set) {
+static int32_t update_code_breakpoint(stlink_t *sl, stm32_addr_t addr, int32_t set) {
     uint32_t mask;
-    int type;
+    int32_t type;
     stm32_addr_t fpb_addr;
 
     if (addr & 1) {
@@ -763,8 +764,8 @@ static int update_code_breakpoint(stlink_t *sl, stm32_addr_t addr, int set) {
         fpb_addr = addr;
     }
 
-    int id = -1;
-    for (int i = 0; i < code_break_num; i++)
+    int32_t id = -1;
+    for (int32_t i = 0; i < code_break_num; i++)
         if (fpb_addr == code_breaks[i].addr || (set && code_breaks[i].type == 0)) {
             id = i;
             break;
@@ -802,7 +803,7 @@ static int update_code_breakpoint(stlink_t *sl, stm32_addr_t addr, int set) {
 
 struct flash_block {
     stm32_addr_t addr;
-    unsigned length;
+    uint32_t length;
     uint8_t*     data;
 
     struct flash_block* next;
@@ -810,7 +811,7 @@ struct flash_block {
 
 static struct flash_block* flash_root;
 
-static int flash_add_block(stm32_addr_t addr, unsigned length, stlink_t *sl) {
+static int32_t flash_add_block(stm32_addr_t addr, uint32_t length, stlink_t *sl) {
 
     if (addr < FLASH_BASE || addr + length > FLASH_BASE + sl->flash_size) {
         ELOG("flash_add_block: incorrect bounds\n");
@@ -835,8 +836,8 @@ static int flash_add_block(stm32_addr_t addr, unsigned length, stlink_t *sl) {
     return(0);
 }
 
-static int flash_populate(stm32_addr_t addr, uint8_t* data, unsigned length) {
-    unsigned int fit_blocks = 0, fit_length = 0;
+static int32_t flash_populate(stm32_addr_t addr, uint8_t* data, uint32_t length) {
+    uint32_t fit_blocks = 0, fit_length = 0;
 
     for (struct flash_block* fb = flash_root; fb; fb = fb->next) {
         /*
@@ -848,13 +849,13 @@ static int flash_populate(stm32_addr_t addr, uint8_t* data, unsigned length) {
          *  a < Y && b > x
          */
 
-        unsigned X = fb->addr, Y = fb->addr + fb->length;
-        unsigned a = addr, b = addr + length;
+        uint32_t X = fb->addr, Y = fb->addr + fb->length;
+        uint32_t a = addr, b = addr + length;
 
         if (a < Y && b > X) {
             // from start of the block
-            unsigned start = (a > X ? a : X) - X;
-            unsigned end   = (b > Y ? Y : b) - X;
+            uint32_t start = (a > X ? a : X) - X;
+            uint32_t end   = (b > Y ? Y : b) - X;
 
             memcpy(fb->data + start, data, end - start);
 
@@ -876,9 +877,9 @@ static int flash_populate(stm32_addr_t addr, uint8_t* data, unsigned length) {
     return(0);
 }
 
-static int flash_go(stlink_t *sl, st_state_t *st) {
-    int error = -1;
-    int ret;
+static int32_t flash_go(stlink_t *sl, st_state_t *st) {
+    int32_t error = -1;
+    int32_t ret;
     flash_loader_t fl;
 
     stlink_target_connect(sl, st->connect_mode);
@@ -904,13 +905,13 @@ static int flash_go(stlink_t *sl, st_state_t *st) {
         ILOG("flash_do: block %08x -> %04x\n", fb->addr, fb->length);
 
         for (stm32_addr_t page = fb->addr; page < fb->addr + fb->length; page += (uint32_t)FLASH_PAGE) {
-            unsigned length = fb->length - (page - fb->addr);
+            uint32_t length = fb->length - (page - fb->addr);
 
             // update FLASH_PAGE
             stlink_calculate_pagesize(sl, page);
 
             ILOG("flash_do: page %08x\n", page);
-            unsigned len = (length > FLASH_PAGE) ? (unsigned int)FLASH_PAGE : length;
+            uint32_t len = (length > FLASH_PAGE) ? (uint32_t)FLASH_PAGE : length;
             ret = stlink_flashloader_write(sl, &fl, page, fb->data + (page - fb->addr), len);
             if (ret) { goto error; }
         }
@@ -933,21 +934,21 @@ static int flash_go(stlink_t *sl, st_state_t *st) {
 }
 
 struct cache_level_desc {
-    unsigned int nsets;
-    unsigned int nways;
-    unsigned int log2_nways;
-    unsigned int width;
+    uint32_t nsets;
+    uint32_t nways;
+    uint32_t log2_nways;
+    uint32_t width;
 };
 
 struct cache_desc_t {
-    unsigned used;
+    uint32_t used;
 
     // minimal line size in bytes
-    unsigned int dminline;
-    unsigned int iminline;
+    uint32_t dminline;
+    uint32_t iminline;
 
     // last level of unification (uniprocessor)
-    unsigned int louu;
+    uint32_t louu;
 
     struct cache_level_desc icache[7];
     struct cache_level_desc dcache[7];
@@ -956,8 +957,8 @@ struct cache_desc_t {
 static struct cache_desc_t cache_desc;
 
 // return the smallest R so that V <= (1 << R); not performance critical
-static unsigned ceil_log2(unsigned v) {
-    unsigned res;
+static uint32_t ceil_log2(uint32_t v) {
+    uint32_t res;
 
     for (res = 0; (1U << res) < v; res++);
 
@@ -965,8 +966,8 @@ static unsigned ceil_log2(unsigned v) {
 }
 
 static void read_cache_level_desc(stlink_t *sl, struct cache_level_desc *desc) {
-    unsigned int ccsidr;
-    unsigned int log2_nsets;
+    uint32_t ccsidr;
+    uint32_t log2_nsets;
 
     stlink_read_debug32(sl, STLINK_REG_CM7_CCSIDR, &ccsidr);
     desc->nsets = ((ccsidr >> 13) & 0x3fff) + 1;
@@ -979,10 +980,10 @@ static void read_cache_level_desc(stlink_t *sl, struct cache_level_desc *desc) {
 }
 
 static void init_cache (stlink_t *sl) {
-    unsigned int clidr;
-    unsigned int ccr;
-    unsigned int ctr;
-    int i;
+    uint32_t clidr;
+    uint32_t ccr;
+    uint32_t ctr;
+    int32_t i;
 
     // Check have cache
     stlink_read_debug32(sl, STLINK_REG_CM7_CTR, &ctr);
@@ -1006,7 +1007,7 @@ static void init_cache (stlink_t *sl) {
          cache_desc.dminline, cache_desc.iminline);
 
     for (i = 0; i < 7; i++) {
-        unsigned int ct = (clidr >> (3 * i)) & 0x07;
+        uint32_t ct = (clidr >> (3 * i)) & 0x07;
         cache_desc.dcache[i].width = 0;
         cache_desc.icache[i].width = 0;
 
@@ -1024,19 +1025,19 @@ static void init_cache (stlink_t *sl) {
     }
 }
 
-static void cache_flush(stlink_t *sl, unsigned ccr) {
-    int level;
+static void cache_flush(stlink_t *sl, uint32_t ccr) {
+    int32_t level;
 
     if (ccr & STLINK_REG_CM7_CCR_DC) {
         for (level = cache_desc.louu - 1; level >= 0; level--) {
             struct cache_level_desc *desc = &cache_desc.dcache[level];
-            unsigned addr;
-            unsigned max_addr = 1 << desc->width;
-            unsigned way_sh = 32 - desc->log2_nways;
+            uint32_t addr;
+            uint32_t max_addr = 1 << desc->width;
+            uint32_t way_sh = 32 - desc->log2_nways;
 
             // D-cache clean by set-ways.
             for (addr = (level << 1); addr < max_addr; addr += cache_desc.dminline) {
-                unsigned int way;
+                uint32_t way;
 
                 for (way = 0; way < desc->nways; way++) {
                     stlink_write_debug32(sl, STLINK_REG_CM7_DCCSW, addr | (way << way_sh));
@@ -1051,9 +1052,9 @@ static void cache_flush(stlink_t *sl, unsigned ccr) {
     }
 }
 
-static int cache_modified;
+static int32_t cache_modified;
 
-static void cache_change(stm32_addr_t start, unsigned count) {
+static void cache_change(stm32_addr_t start, uint32_t count) {
     if (count == 0) { return; }
 
     (void)start;
@@ -1061,7 +1062,7 @@ static void cache_change(stm32_addr_t start, unsigned count) {
 }
 
 static void cache_sync(stlink_t *sl) {
-    unsigned ccr;
+    uint32_t ccr;
 
     if (!cache_desc.used) { return; }
 
@@ -1074,7 +1075,7 @@ static void cache_sync(stlink_t *sl) {
 
 static size_t unhexify(const char *in, char *out, size_t out_count) {
     size_t i;
-    unsigned int c;
+    uint32_t c;
 
     for (i = 0; i < out_count; i++) {
         if (sscanf(in + (2 * i), "%02x", &c) != 1) { return(i); }
@@ -1085,7 +1086,7 @@ static size_t unhexify(const char *in, char *out, size_t out_count) {
     return(i);
 }
 
-int serve(stlink_t *sl, st_state_t *st) {
+int32_t serve(stlink_t *sl, st_state_t *st) {
     SOCKET sock = socket(AF_INET, SOCK_STREAM, 0);
 
     if (!IS_SOCK_VALID(sock)) {
@@ -1093,7 +1094,7 @@ int serve(stlink_t *sl, st_state_t *st) {
         return(1);
     }
 
-    unsigned int val = 1;
+    uint32_t val = 1;
     setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val));
 
     struct sockaddr_in serv_addr;
@@ -1149,16 +1150,16 @@ int serve(stlink_t *sl, st_state_t *st) {
      * To allow resetting the chip from GDB it is required to emulate attaching
      * and detaching to target.
      */
-    unsigned int attached = 1;
+    uint32_t attached = 1;
     // if a critical error is detected, break from the loop
-    int critical_error = 0;
-    int ret;
+    int32_t critical_error = 0;
+    int32_t ret;
 
     while (1) {
         ret = 0;
         char* packet;
 
-        int status = gdb_recv_packet(client, &packet);
+        int32_t status = gdb_recv_packet(client, &packet);
 
         if (status < 0) {
             ELOG("cannot recv: %d\n", status);
@@ -1186,7 +1187,7 @@ int serve(stlink_t *sl, st_state_t *st) {
                 params = separator + 1;
             }
 
-            unsigned queryNameLength = (unsigned int)(separator - &packet[1]);
+            uint32_t queryNameLength = (uint32_t)(separator - &packet[1]);
             char* queryName = calloc(queryNameLength + 1, 1);
             strncpy(queryName, &packet[1], queryNameLength);
 
@@ -1205,8 +1206,8 @@ int serve(stlink_t *sl, st_state_t *st) {
                 __s_addr = strsep(&tok, ",");
                 s_length = tok;
 
-                unsigned addr = (unsigned int)strtoul(__s_addr, NULL, 16),
-                         length = (unsigned int)strtoul(s_length, NULL, 16);
+                uint32_t addr = (uint32_t)strtoul(__s_addr, NULL, 16),
+                         length = (uint32_t)strtoul(s_length, NULL, 16);
 
                 DLOG("Xfer: type:%s;op:%s;annex:%s;addr:%d;length:%d\n",
                      type, op, annex, addr, length);
@@ -1223,7 +1224,7 @@ int serve(stlink_t *sl, st_state_t *st) {
                 }
 
                 if (data) {
-                    unsigned data_length = (unsigned int)strlen(data);
+                    uint32_t data_length = (uint32_t)strlen(data);
 
                     if (addr + length > data_length) { length = data_length - addr; }
 
@@ -1366,8 +1367,8 @@ int serve(stlink_t *sl, st_state_t *st) {
                 __s_addr   = strsep(&tok, ",");
                 s_length = tok;
 
-                unsigned addr = (unsigned int)strtoul(__s_addr, NULL, 16),
-                         length = (unsigned int)strtoul(s_length, NULL, 16);
+                uint32_t addr = (uint32_t)strtoul(__s_addr, NULL, 16),
+                         length = (uint32_t)strtoul(s_length, NULL, 16);
 
                 DLOG("FlashErase: addr:%08x,len:%04x\n",
                      addr, length);
@@ -1384,15 +1385,15 @@ int serve(stlink_t *sl, st_state_t *st) {
                 __s_addr = strsep(&tok, ":");
                 data   = tok;
 
-                unsigned addr = (unsigned int)strtoul(__s_addr, NULL, 16);
-                unsigned data_length = status - (unsigned int)(data - packet);
+                uint32_t addr = (uint32_t)strtoul(__s_addr, NULL, 16);
+                uint32_t data_length = status - (uint32_t)(data - packet);
 
                 // Length of decoded data cannot be more than encoded, as escapes are removed.
                 // Additional byte is reserved for alignment fix.
                 uint8_t *decoded = calloc(data_length + 1, 1);
-                unsigned dec_index = 0;
+                uint32_t dec_index = 0;
 
-                for (unsigned int i = 0; i < data_length; i++) {
+                for (uint32_t i = 0; i < data_length; i++) {
                     if (data[i] == 0x7d) {
                         i++;
                         decoded[dec_index++] = data[i] ^ 0x20;
@@ -1457,7 +1458,7 @@ int serve(stlink_t *sl, st_state_t *st) {
                     struct stlink_reg reg;
                     stm32_addr_t pc;
                     stm32_addr_t addr;
-                    int offset = 0;
+                    int32_t offset = 0;
                     uint16_t insn;
 
                     if (!st->semihosting) { break; }
@@ -1547,15 +1548,15 @@ int serve(stlink_t *sl, st_state_t *st) {
 
             reply = calloc(8 * 16 + 1, 1);
 
-            for (int i = 0; i < 16; i++) {
+            for (int32_t i = 0; i < 16; i++) {
                 sprintf(&reply[i * 8], "%08x", (uint32_t)htonl(regp.r[i]));
             }
 
             break;
 
         case 'p': {
-            unsigned id = (unsigned int)strtoul(&packet[1], NULL, 16);
-            unsigned myreg = 0xDEADDEAD;
+            uint32_t id = (uint32_t)strtoul(&packet[1], NULL, 16);
+            uint32_t myreg = 0xDEADDEAD;
 
             if (id < 16) {
                 ret = stlink_read_reg(sl, id, &regp);
@@ -1607,8 +1608,8 @@ int serve(stlink_t *sl, st_state_t *st) {
             char* s_reg = &packet[1];
             char* s_value = strstr(&packet[1], "=") + 1;
 
-            unsigned reg   = (unsigned int)strtoul(s_reg,   NULL, 16);
-            unsigned value = (unsigned int)strtoul(s_value, NULL, 16);
+            uint32_t reg   = (uint32_t)strtoul(s_reg,   NULL, 16);
+            uint32_t value = (uint32_t)strtoul(s_value, NULL, 16);
 
 
             if (reg < 16) {
@@ -1645,7 +1646,7 @@ int serve(stlink_t *sl, st_state_t *st) {
 
         case 'G':
 
-            for (int i = 0; i < 16; i++) {
+            for (int32_t i = 0; i < 16; i++) {
                 char str[9] = {0};
                 strncpy(str, &packet[1 + i * 8], 8);
                 uint32_t reg = (uint32_t)strtoul(str, NULL, 16);
@@ -1662,12 +1663,12 @@ int serve(stlink_t *sl, st_state_t *st) {
             char* s_count = strstr(&packet[1], ",") + 1;
 
             stm32_addr_t start = (stm32_addr_t)strtoul(s_start, NULL, 16);
-            unsigned count = (unsigned int)strtoul(s_count, NULL, 16);
+            uint32_t count = (uint32_t)strtoul(s_count, NULL, 16);
 
-            unsigned adj_start = start % 4;
-            unsigned count_rnd = (count + adj_start + 4 - 1) / 4 * 4;
+            uint32_t adj_start = start % 4;
+            uint32_t count_rnd = (count + adj_start + 4 - 1) / 4 * 4;
 
-            if (count_rnd > sl->flash_pgsz) { count_rnd = (unsigned int)sl->flash_pgsz; }
+            if (count_rnd > sl->flash_pgsz) { count_rnd = (uint32_t)sl->flash_pgsz; }
 
             if (count_rnd > 0x1800) { count_rnd = 0x1800; }
 
@@ -1679,7 +1680,7 @@ int serve(stlink_t *sl, st_state_t *st) {
 
             reply = calloc(count * 2 + 1, 1);
 
-            for (unsigned int i = 0; i < count; i++) {
+            for (uint32_t i = 0; i < count; i++) {
                 reply[i * 2 + 0] = hex[sl->q_buf[i + adj_start] >> 4];
                 reply[i * 2 + 1] = hex[sl->q_buf[i + adj_start] & 0xf];
             }
@@ -1693,15 +1694,15 @@ int serve(stlink_t *sl, st_state_t *st) {
             char* hexdata = strstr(packet, ":") + 1;
 
             stm32_addr_t start = (stm32_addr_t)strtoul(s_start, NULL, 16);
-            unsigned count = (unsigned int)strtoul(s_count, NULL, 16);
-            int err = 0;
+            uint32_t count = (uint32_t)strtoul(s_count, NULL, 16);
+            int32_t err = 0;
 
             if (start % 4) {
-                unsigned align_count = 4 - start % 4;
+                uint32_t align_count = 4 - start % 4;
 
                 if (align_count > count) { align_count = count; }
 
-                for (unsigned int i = 0; i < align_count; i++) {
+                for (uint32_t i = 0; i < align_count; i++) {
                     char hextmp[3] = { hexdata[i * 2], hexdata[i * 2 + 1], 0 };
                     uint8_t byte = (uint8_t)strtoul(hextmp, NULL, 16);
                     sl->q_buf[i] = byte;
@@ -1715,9 +1716,9 @@ int serve(stlink_t *sl, st_state_t *st) {
             }
 
             if (count - count % 4) {
-                unsigned aligned_count = count - count % 4;
+                uint32_t aligned_count = count - count % 4;
 
-                for (unsigned int i = 0; i < aligned_count; i++) {
+                for (uint32_t i = 0; i < aligned_count; i++) {
                     char hextmp[3] = { hexdata[i * 2], hexdata[i * 2 + 1], 0 };
                     uint8_t byte = (uint8_t)strtoul(hextmp, NULL, 16);
                     sl->q_buf[i] = byte;
@@ -1731,7 +1732,7 @@ int serve(stlink_t *sl, st_state_t *st) {
             }
 
             if (count) {
-                for (unsigned int i = 0; i < count; i++) {
+                for (uint32_t i = 0; i < count; i++) {
                     char hextmp[3] = { hexdata[i * 2], hexdata[i * 2 + 1], 0 };
                     uint8_t byte = (uint8_t)strtoul(hextmp, NULL, 16);
                     sl->q_buf[i] = byte;
@@ -1871,7 +1872,7 @@ int serve(stlink_t *sl, st_state_t *st) {
         if (reply) {
             DLOG("send: %s\n", reply);
 
-            int result = gdb_send_packet(client, reply);
+            int32_t result = gdb_send_packet(client, reply);
 
             if (result != 0) {
                 ELOG("cannot send: %d\n", result);
diff --git a/src/st-util/semihosting.c b/src/st-util/semihosting.c
index f603f6224..93a6cf7cc 100644
--- a/src/st-util/semihosting.c
+++ b/src/st-util/semihosting.c
@@ -1,4 +1,5 @@
 #include <stdio.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -11,9 +12,9 @@
 #include <logging.h>
 #include "semihosting.h"
 
-static int mem_read_u8(stlink_t *sl, uint32_t addr, uint8_t *data) {
-    int offset = addr % 4;
-    int len = 4;
+static int32_t mem_read_u8(stlink_t *sl, uint32_t addr, uint8_t *data) {
+    int32_t offset = addr % 4;
+    int32_t len = 4;
 
     if (sl == NULL || data == NULL) { return(-1); }
 
@@ -25,9 +26,9 @@ static int mem_read_u8(stlink_t *sl, uint32_t addr, uint8_t *data) {
 }
 
 #ifdef UNUSED
-static int mem_read_u16(stlink_t *sl, uint32_t addr, uint16_t *data) {
-    int offset = addr % 4;
-    int len = (offset > 2 ? 8 : 4);
+static int32_t mem_read_u16(stlink_t *sl, uint32_t addr, uint16_t *data) {
+    int32_t offset = addr % 4;
+    int32_t len = (offset > 2 ? 8 : 4);
 
     if (sl == NULL || data == NULL) { return(-1); }
 
@@ -38,9 +39,9 @@ static int mem_read_u16(stlink_t *sl, uint32_t addr, uint16_t *data) {
     return(0);
 }
 
-static int mem_read_u32(stlink_t *sl, uint32_t addr, uint32_t *data) {
-    int offset = addr % 4;
-    int len = (offset > 0 ? 8 : 4);
+static int32_t mem_read_u32(stlink_t *sl, uint32_t addr, uint32_t *data) {
+    int32_t offset = addr % 4;
+    int32_t len = (offset > 0 ? 8 : 4);
 
     if (sl == NULL || data == NULL) { return(-1); }
 
@@ -52,9 +53,9 @@ static int mem_read_u32(stlink_t *sl, uint32_t addr, uint32_t *data) {
 }
 #endif
 
-static int mem_read(stlink_t *sl, uint32_t addr, void *data, uint16_t len) {
-    int offset = addr % 4;
-    int read_len = len + offset;
+static int32_t mem_read(stlink_t *sl, uint32_t addr, void *data, uint16_t len) {
+    int32_t offset = addr % 4;
+    int32_t read_len = len + offset;
 
     if (sl == NULL || data == NULL) { return(-1); }
 
@@ -68,7 +69,7 @@ static int mem_read(stlink_t *sl, uint32_t addr, void *data, uint16_t len) {
     return(0);
 }
 
-static int mem_write(stlink_t *sl, uint32_t addr, void *data, uint16_t len) {
+static int32_t mem_write(stlink_t *sl, uint32_t addr, void *data, uint16_t len) {
     /* Note: this function can write more than it is asked to!
      * If addr is not an even 32 bit boundary, or len is not a multiple of 4.
      * If only 32 bit values can be written to the target, then this function should read
@@ -78,8 +79,8 @@ static int mem_write(stlink_t *sl, uint32_t addr, void *data, uint16_t len) {
      * Just return when the length is zero avoiding unneeded work. */
     if (len == 0) { return(0); }
 
-    int offset = addr % 4;
-    int write_len = len + offset;
+    int32_t offset = addr % 4;
+    int32_t write_len = len + offset;
 
     if (sl == NULL || data == NULL) { return(-1); }
 
@@ -112,7 +113,7 @@ static int mem_write(stlink_t *sl, uint32_t addr, void *data, uint16_t len) {
 #define O_BINARY 0
 #endif
 
-static int open_mode_flags[12] = {
+static int32_t open_mode_flags[12] = {
     O_RDONLY,
     O_RDONLY | O_BINARY,
     O_RDWR,
@@ -127,9 +128,9 @@ static int open_mode_flags[12] = {
     O_RDWR   | O_CREAT | O_APPEND | O_BINARY
 };
 
-static int saved_errno = 0;
+static int32_t saved_errno = 0;
 
-int do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
+int32_t do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
 
     if (sl == NULL || ret == NULL) { return(-1); }
 
@@ -200,7 +201,7 @@ int do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
     case SEMIHOST_SYS_CLOSE:
     {
         uint32_t args[1];
-        int fd;
+        int32_t fd;
 
         if (mem_read(sl, r1, args, sizeof(args)) != 0) {
             DLOG("Semihosting SYS_CLOSE error: cannot read args from target memory\n");
@@ -208,7 +209,7 @@ int do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
             return(-1);
         }
 
-        fd = (int)args[0];
+        fd = (int32_t)args[0];
 
         DLOG("Semihosting: close(%d)\n", fd);
 
@@ -222,7 +223,7 @@ int do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
     {
         uint32_t args[3];
         uint32_t buffer_address;
-        int fd;
+        int32_t fd;
         uint32_t buffer_len;
         void    *buffer;
 
@@ -232,7 +233,7 @@ int do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
             return(-1);
         }
 
-        fd             = (int)args[0];
+        fd             = (int32_t)args[0];
         buffer_address = args[1];
         buffer_len     = args[2];
 
@@ -277,7 +278,7 @@ int do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
     {
         uint32_t args[3];
         uint32_t buffer_address;
-        int fd;
+        int32_t fd;
         uint32_t buffer_len;
         void    *buffer;
         ssize_t read_result;
@@ -288,7 +289,7 @@ int do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
             return(-1);
         }
 
-        fd             = (int)args[0];
+        fd             = (int32_t)args[0];
         buffer_address = args[1];
         buffer_len     = args[2];
 
@@ -388,7 +389,7 @@ int do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
     case SEMIHOST_SYS_SEEK:
     {
         uint32_t args[2];
-        int fd;
+        int32_t fd;
         off_t offset;
 
         if (mem_read(sl, r1, args, sizeof(args)) != 0) {
@@ -397,10 +398,10 @@ int do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
             return(-1);
         }
 
-        fd = (int)args[0];
+        fd = (int32_t)args[0];
         offset = (off_t)args[1];
 
-        DLOG("Semihosting: lseek(%d, %d, SEEK_SET)\n", fd, (int)offset);
+        DLOG("Semihosting: lseek(%d, %d, SEEK_SET)\n", fd, (int32_t)offset);
         *ret = (uint32_t)lseek(fd, offset, SEEK_SET);
         saved_errno = errno;
 
@@ -437,7 +438,7 @@ int do_semihosting (stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret) {
                 return(-1);
             }
 
-            for (int i = 0; i < WRITE0_BUFFER_SIZE; i++) {
+            for (int32_t i = 0; i < WRITE0_BUFFER_SIZE; i++) {
                 if (buf[i] == 0) { return(0); }
 
                 fprintf(stderr, "%c", buf[i]);
diff --git a/src/st-util/semihosting.h b/src/st-util/semihosting.h
index e7ddfcd97..fd3990ba2 100644
--- a/src/st-util/semihosting.h
+++ b/src/st-util/semihosting.h
@@ -1,6 +1,8 @@
 #ifndef SEMIHOSTING_H
 #define SEMIHOSTING_H
 
+#include <stdint.h>
+
 #include <stlink.h>
 
 #define SEMIHOST_SYS_OPEN     0x01
@@ -29,6 +31,6 @@
 #define SEMIHOST_SYS_ELAPSED  0x30
 #define SEMIHOST_SYS_TICKFREQ 0x31
 
-int do_semihosting(stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret);
+int32_t do_semihosting(stlink_t *sl, uint32_t r0, uint32_t r1, uint32_t *ret);
 
 #endif // SEMIHOSTING_H
diff --git a/src/stlink-gui/gui.c b/src/stlink-gui/gui.c
index 2bf1f9d32..f0426f577 100644
--- a/src/stlink-gui/gui.c
+++ b/src/stlink-gui/gui.c
@@ -263,7 +263,7 @@ static gpointer stlink_gui_populate_filemem_view(gpointer data) {
         uint8_t* mem   = NULL;
         size_t size    = 0;
         uint32_t begin = 0;
-        int res = stlink_parse_ihex(gui->filename, 0, &mem, &size, &begin);
+        int32_t res = stlink_parse_ihex(gui->filename, 0, &mem, &size, &begin);
 
         if (res == 0) {
             if (gui->file_mem.memory) {
@@ -440,7 +440,7 @@ static gchar *dev_format_chip_id(guint32 chip_id) {
 }
 
 static gchar *dev_format_mem_size(gsize flash_size) {
-    return(g_strdup_printf("%u kB", (unsigned int)(flash_size / 1024)));
+    return(g_strdup_printf("%u kB", (uint32_t)(flash_size / 1024)));
 }
 
 
@@ -640,7 +640,7 @@ static void flash_button_cb(GtkWidget *widget, gpointer data) {
     }
 }
 
-int export_to_file(const char*filename, const struct mem_t flash_mem) {
+int32_t export_to_file(const char*filename, const struct mem_t flash_mem) {
     printf("%s\n", filename);
     FILE * f = fopen(filename, "w");
 
@@ -885,7 +885,7 @@ static void stlink_gui_build_ui(STlinkGUI *gui) {
     stlink_gui_set_disconnected(gui);
 }
 
-int main(int argc, char **argv) {
+int32_t main(int32_t argc, char **argv) {
     STlinkGUI *gui;
 
     gtk_init(&argc, &argv);
diff --git a/src/stlink-gui/gui.h b/src/stlink-gui/gui.h
index 08519ea56..2d7f31913 100644
--- a/src/stlink-gui/gui.h
+++ b/src/stlink-gui/gui.h
@@ -1,6 +1,7 @@
 #ifndef GUI_H
 #define GUI_H
 
+#include <stdint.h>
 #include <glib-object.h>
 
 #define STLINK_TYPE_GUI             (stlink_gui_get_type())
@@ -87,6 +88,6 @@ struct _STlinkGUIClass {
 };
 
 GType stlink_gui_get_type(void);
-int export_to_file(const char*filename, const struct mem_t flash_mem);
+int32_t export_to_file(const char*filename, const struct mem_t flash_mem);
 
 #endif // GUI_H
diff --git a/src/stlink-lib/calculate.c b/src/stlink-lib/calculate.c
index ddab5ed08..132875a66 100644
--- a/src/stlink-lib/calculate.c
+++ b/src/stlink-lib/calculate.c
@@ -1,3 +1,5 @@
+#include <stdint.h>
+
 #include <stlink.h>
 #include "calculate.h"
 #include "common_flash.h"
@@ -39,7 +41,7 @@ uint32_t calculate_F7_sectornum(uint32_t flashaddr) {
 }
 
 uint32_t calculate_H7_sectornum(stlink_t *sl, uint32_t flashaddr,
-                                unsigned bank) {
+                                uint32_t bank) {
   flashaddr &=
       ~((bank == BANK_1)
             ? STM32_FLASH_BASE
diff --git a/src/stlink-lib/calculate.h b/src/stlink-lib/calculate.h
index 64dfb51b2..bdff782ae 100644
--- a/src/stlink-lib/calculate.h
+++ b/src/stlink-lib/calculate.h
@@ -7,6 +7,8 @@
 #ifndef CALCULATE_H
 #define CALCULATE_H
 
+#include <stdint.h>
+
 uint32_t calculate_F4_sectornum(uint32_t);
 uint32_t calculate_F7_sectornum(uint32_t);
 uint32_t calculate_H7_sectornum(stlink_t *, uint32_t, unsigned);
diff --git a/src/stlink-lib/chipid.c b/src/stlink-lib/chipid.c
index 347d89e14..7e99a8730 100644
--- a/src/stlink-lib/chipid.c
+++ b/src/stlink-lib/chipid.c
@@ -1,13 +1,14 @@
-#include "chipid.h"
-#include <stlink.h>
-#include <stm32.h>
-
 #include <ctype.h>
 #include <errno.h>
 #include <stdio.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
+#include "chipid.h"
+#include <stlink.h>
+#include <stm32.h>
+
 static struct stlink_chipid_params *devicelist;
 
 void dump_a_chip(struct stlink_chipid_params *dev) {
@@ -43,7 +44,7 @@ void process_chipfile(char *fname) {
   char *p, buf[256];
   char word[64], value[64];
   struct stlink_chipid_params *ts;
-  int nc;
+  int32_t nc;
 
   // fprintf (stderr, "processing chip-id file %s.\n", fname);
   fp = fopen(fname, "r");
diff --git a/src/stlink-lib/chipid.h b/src/stlink-lib/chipid.h
index d6afc4525..9eaac722d 100644
--- a/src/stlink-lib/chipid.h
+++ b/src/stlink-lib/chipid.h
@@ -1,6 +1,8 @@
 #ifndef CHIPID_H
 #define CHIPID_H
 
+#include <stdint.h>
+
 #include <stm32.h>
 #include <stlink.h>
 
diff --git a/src/stlink-lib/common.c b/src/stlink-lib/common.c
index 8e4b9a716..cb87f5f36 100644
--- a/src/stlink-lib/common.c
+++ b/src/stlink-lib/common.c
@@ -1,16 +1,15 @@
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-
+#include <unistd.h>
 #include <fcntl.h>
 #include <helper.h>
 #include <sys/stat.h>
 #include <sys/types.h>
-#include <unistd.h>
 
 #include <stlink.h>
 #include <stm32.h>
-
 #include "calculate.h"
 #include "common_flash.h"
 #include "map_file.h"
@@ -28,7 +27,7 @@
 
 // Private structs and functions defines
 struct stlink_fread_worker_arg {
-  int fd;
+  int32_t fd;
 };
 
 struct stlink_fread_ihex_worker_arg {
@@ -42,12 +41,12 @@ struct stlink_fread_ihex_worker_arg {
 typedef bool (*save_block_fn)(void *arg, uint8_t *block, ssize_t len);
 
 static void stop_wdg_in_debug(stlink_t *);
-int stlink_jtag_reset(stlink_t *, int);
-int stlink_soft_reset(stlink_t *, int);
+int32_t stlink_jtag_reset(stlink_t *, int);
+int32_t stlink_soft_reset(stlink_t *, int);
 void _parse_version(stlink_t *, stlink_version_t *);
 static uint8_t stlink_parse_hex(const char *);
-static int stlink_read(stlink_t *, stm32_addr_t, size_t, save_block_fn, void *);
-static bool stlink_fread_ihex_init(struct stlink_fread_ihex_worker_arg *, int, stm32_addr_t);
+static int32_t stlink_read(stlink_t *, stm32_addr_t, size_t, save_block_fn, void *);
+static bool stlink_fread_ihex_init(struct stlink_fread_ihex_worker_arg *, int32_t, stm32_addr_t);
 static bool stlink_fread_ihex_worker(void *, uint8_t *, ssize_t);
 static bool stlink_fread_ihex_finalize(struct stlink_fread_ihex_worker_arg *);
 static bool stlink_fread_worker(void *, uint8_t *, ssize_t);
@@ -67,7 +66,7 @@ void stlink_close(stlink_t *sl) {
 }
 
 // 250
-int stlink_exit_debug_mode(stlink_t *sl) {
+int32_t stlink_exit_debug_mode(stlink_t *sl) {
   DLOG("*** stlink_exit_debug_mode ***\n");
 
   if (sl->flash_type != STM32_FLASH_TYPE_UNKNOWN &&
@@ -80,16 +79,16 @@ int stlink_exit_debug_mode(stlink_t *sl) {
 }
 
 //248
-int stlink_enter_swd_mode(stlink_t *sl) {
+int32_t stlink_enter_swd_mode(stlink_t *sl) {
   DLOG("*** stlink_enter_swd_mode ***\n");
   return (sl->backend->enter_swd_mode(sl));
 }
 
 // 271
 // Force the core into the debug mode -> halted state.
-int stlink_force_debug(stlink_t *sl) {
+int32_t stlink_force_debug(stlink_t *sl) {
   DLOG("*** stlink_force_debug_mode ***\n");
-  int res = sl->backend->force_debug(sl);
+  int32_t res = sl->backend->force_debug(sl);
   if (res) {
      return (res);
   }
@@ -99,14 +98,14 @@ int stlink_force_debug(stlink_t *sl) {
 }
 
 // 251
-int stlink_exit_dfu_mode(stlink_t *sl) {
+int32_t stlink_exit_dfu_mode(stlink_t *sl) {
   DLOG("*** stlink_exit_dfu_mode ***\n");
   return (sl->backend->exit_dfu_mode(sl));
 }
 
 // 253
-int stlink_core_id(stlink_t *sl) {
-  int ret;
+int32_t stlink_core_id(stlink_t *sl) {
+  int32_t ret;
 
   DLOG("*** stlink_core_id ***\n");
   ret = sl->backend->core_id(sl);
@@ -127,8 +126,8 @@ int stlink_core_id(stlink_t *sl) {
 // 287
 // stlink_chip_id() is called by stlink_load_device_params()
 // do not call this procedure directly.
-int stlink_chip_id(stlink_t *sl, uint32_t *chip_id) {
-  int ret;
+int32_t stlink_chip_id(stlink_t *sl, uint32_t *chip_id) {
+  int32_t ret;
   cortex_m3_cpuid_t cpu_id;
 
   // Read the CPU ID to determine where to read the core id
@@ -193,7 +192,7 @@ int stlink_chip_id(stlink_t *sl, uint32_t *chip_id) {
  * @param sl stlink context
  * @param cpuid pointer to the result object
  */
-int stlink_cpu_id(stlink_t *sl, cortex_m3_cpuid_t *cpuid) {
+int32_t stlink_cpu_id(stlink_t *sl, cortex_m3_cpuid_t *cpuid) {
   uint32_t raw;
 
   if (stlink_read_debug32(sl, STLINK_REG_CM3_CPUID, &raw)) {
@@ -217,7 +216,7 @@ int stlink_cpu_id(stlink_t *sl, cortex_m3_cpuid_t *cpuid) {
  * @param sl
  * @return 0 for success, or -1 for unsupported core type.
  */
-int stlink_load_device_params(stlink_t *sl) {
+int32_t stlink_load_device_params(stlink_t *sl) {
   // This seems to normally work so is unnecessary info for a normal user.
   // Demoted to debug. -- REW
   DLOG("Loading device parameters....\n");
@@ -312,17 +311,17 @@ int stlink_load_device_params(stlink_t *sl) {
   }
 
   ILOG("%s: %u KiB SRAM, %u KiB flash in at least %u %s pages.\n",
-      params->dev_type, (unsigned)(sl->sram_size / 1024), (unsigned)(sl->flash_size / 1024),
-      (sl->flash_pgsz < 1024) ? (unsigned)(sl->flash_pgsz) : (unsigned)(sl->flash_pgsz / 1024),
+      params->dev_type, (uint32_t)(sl->sram_size / 1024), (uint32_t)(sl->flash_size / 1024),
+      (sl->flash_pgsz < 1024) ? (uint32_t)(sl->flash_pgsz) : (uint32_t)(sl->flash_pgsz / 1024),
       (sl->flash_pgsz < 1024) ? "byte" : "KiB");
 
   return (0);
 }
 
 // 254
-int stlink_reset(stlink_t *sl, enum reset_type type) {
+int32_t stlink_reset(stlink_t *sl, enum reset_type type) {
   uint32_t dhcsr;
-  unsigned timeout;
+  uint32_t timeout;
 
   DLOG("*** stlink_reset ***\n");
 
@@ -352,7 +351,7 @@ int stlink_reset(stlink_t *sl, enum reset_type type) {
      */
 
     dhcsr = 0;
-    int res = stlink_read_debug32(sl, STLINK_REG_DHCSR, &dhcsr);
+    int32_t res = stlink_read_debug32(sl, STLINK_REG_DHCSR, &dhcsr);
     if ((dhcsr & STLINK_REG_DHCSR_S_RESET_ST) == 0 && !res) {
       // reset not done yet --> try reset through AIRCR so that NRST does not need to be connected
       ILOG("NRST is not connected --> using software reset via AIRCR\n");
@@ -380,9 +379,9 @@ int stlink_reset(stlink_t *sl, enum reset_type type) {
   return (0);
 }
 
-int stlink_soft_reset(stlink_t *sl, int halt_on_reset) {
-  int ret;
-  unsigned timeout;
+int32_t stlink_soft_reset(stlink_t *sl, int32_t halt_on_reset) {
+  int32_t ret;
+  uint32_t timeout;
   uint32_t dhcsr, dfsr;
 
   DLOG("*** stlink_soft_reset %s***\n", halt_on_reset ? "(halt) " : "");
@@ -455,7 +454,7 @@ int stlink_soft_reset(stlink_t *sl, int halt_on_reset) {
 }
 
 // 255
-int stlink_run(stlink_t *sl, enum run_type type) {
+int32_t stlink_run(stlink_t *sl, enum run_type type) {
   struct stlink_reg rr;
   DLOG("*** stlink_run ***\n");
 
@@ -472,7 +471,7 @@ int stlink_run(stlink_t *sl, enum run_type type) {
 }
 
 // 273
-int stlink_set_swdclk(stlink_t *sl, int freq_khz) {
+int32_t stlink_set_swdclk(stlink_t *sl, int32_t freq_khz) {
   DLOG("*** set_swdclk ***\n");
   return (sl->backend->set_swdclk(sl, freq_khz));
 }
@@ -500,8 +499,8 @@ void stlink_core_stat(stlink_t *sl) {
 }
 
 // 256
-int stlink_status(stlink_t *sl) {
-  int ret;
+int32_t stlink_status(stlink_t *sl) {
+  int32_t ret;
 
   DLOG("*** stlink_status ***\n");
   ret = sl->backend->status(sl);
@@ -510,7 +509,7 @@ int stlink_status(stlink_t *sl) {
 }
 
 // 257
-int stlink_version(stlink_t *sl) {
+int32_t stlink_version(stlink_t *sl) {
   DLOG("*** looking up stlink version ***\n");
 
   if (sl->backend->version(sl)) {
@@ -534,8 +533,8 @@ int stlink_version(stlink_t *sl) {
 }
 
 // 272
-int stlink_target_voltage(stlink_t *sl) {
-  int voltage = -1;
+int32_t stlink_target_voltage(stlink_t *sl) {
+  int32_t voltage = -1;
   DLOG("*** reading target voltage\n");
 
   if (sl->backend->target_voltage != NULL) {
@@ -560,14 +559,14 @@ bool stlink_is_core_halted(stlink_t *sl) {
 }
 
 // 269
-int stlink_step(stlink_t *sl) {
+int32_t stlink_step(stlink_t *sl) {
   DLOG("*** stlink_step ***\n");
   return (sl->backend->step(sl));
 }
 
 // 270
-int stlink_current_mode(stlink_t *sl) {
-  int mode = sl->backend->current_mode(sl);
+int32_t stlink_current_mode(stlink_t *sl) {
+  int32_t mode = sl->backend->current_mode(sl);
 
   switch (mode) {
   case STLINK_DEV_DFU_MODE:
@@ -586,19 +585,19 @@ int stlink_current_mode(stlink_t *sl) {
 }
 
 // 274
-int stlink_trace_enable(stlink_t *sl, uint32_t frequency) {
+int32_t stlink_trace_enable(stlink_t *sl, uint32_t frequency) {
   DLOG("*** stlink_trace_enable ***\n");
   return (sl->backend->trace_enable(sl, frequency));
 }
 
 // 275
-int stlink_trace_disable(stlink_t *sl) {
+int32_t stlink_trace_disable(stlink_t *sl) {
   DLOG("*** stlink_trace_disable ***\n");
   return (sl->backend->trace_disable(sl));
 }
 
 // 276
-int stlink_trace_read(stlink_t *sl, uint8_t *buf, size_t size) {
+int32_t stlink_trace_read(stlink_t *sl, uint8_t *buf, size_t size) {
   return (sl->backend->trace_read(sl, buf, size));
 }
 
@@ -612,7 +611,7 @@ void stlink_print_data(stlink_t *sl) {
     DLOG("data_len = %d 0x%x\n", sl->q_len, sl->q_len);
   }
 
-  for (int i = 0; i < sl->q_len; i++) {
+  for (int32_t i = 0; i < sl->q_len; i++) {
     if (i % 16 == 0) {
       /*
       if (sl->q_data_dir == Q_DATA_OUT) {
@@ -622,18 +621,18 @@ void stlink_print_data(stlink_t *sl) {
       }
       */
     }
-    // DLOG(" %02x", (unsigned int) sl->q_buf[i]);
-    fprintf(stderr, " %02x", (unsigned int)sl->q_buf[i]);
+    // DLOG(" %02x", (uint32_t) sl->q_buf[i]);
+    fprintf(stderr, " %02x", (uint32_t)sl->q_buf[i]);
   }
   // DLOG("\n\n");
   fprintf(stderr, "\n");
 }
 
 // 283
-int stlink_mwrite_sram(stlink_t *sl, uint8_t *data, uint32_t length, stm32_addr_t addr) {
+int32_t stlink_mwrite_sram(stlink_t *sl, uint8_t *data, uint32_t length, stm32_addr_t addr) {
   // write the file in sram at addr
 
-  int error = -1;
+  int32_t error = -1;
   size_t off;
   size_t len;
 
@@ -688,10 +687,10 @@ int stlink_mwrite_sram(stlink_t *sl, uint8_t *data, uint32_t length, stm32_addr_
 }
 
 //284
-int stlink_fwrite_sram(stlink_t *sl, const char *path, stm32_addr_t addr) {
+int32_t stlink_fwrite_sram(stlink_t *sl, const char *path, stm32_addr_t addr) {
   // write the file in sram at addr
 
-  int error = -1;
+  int32_t error = -1;
   size_t off;
   size_t len;
   mapped_file_t mf = MAPPED_FILE_INITIALIZER;
@@ -763,12 +762,12 @@ int stlink_fwrite_sram(stlink_t *sl, const char *path, stm32_addr_t addr) {
 }
 
 // 302
-int stlink_fread(stlink_t *sl, const char *path, bool is_ihex, stm32_addr_t addr, size_t size) {
+int32_t stlink_fread(stlink_t *sl, const char *path, bool is_ihex, stm32_addr_t addr, size_t size) {
   // read size bytes from addr to file
-  ILOG("read from address %#010x size %u\n", addr, (unsigned)size);
+  ILOG("read from address %#010x size %u\n", addr, (uint32_t)size);
 
-  int error;
-  int fd = open(path, O_RDWR | O_TRUNC | O_CREAT | O_BINARY, 00700);
+  int32_t error;
+  int32_t fd = open(path, O_RDWR | O_TRUNC | O_CREAT | O_BINARY, 00700);
 
   if (fd == -1) {
     fprintf(stderr, "open(%s) == -1\n", path);
@@ -797,9 +796,9 @@ int stlink_fread(stlink_t *sl, const char *path, bool is_ihex, stm32_addr_t addr
 }
 
 // 300
-int write_buffer_to_sram(stlink_t *sl, flash_loader_t *fl, const uint8_t *buf, size_t size) {
+int32_t write_buffer_to_sram(stlink_t *sl, flash_loader_t *fl, const uint8_t *buf, size_t size) {
   // write the buffer right after the loader
-  int ret = 0;
+  int32_t ret = 0;
   size_t chunk = size & ~0x3;
   size_t rem = size & 0x3;
 
@@ -858,15 +857,15 @@ uint32_t stlink_calculate_pagesize(stlink_t *sl, uint32_t flashaddr) {
 }
 
 // 279
-int stlink_parse_ihex(const char *path, uint8_t erased_pattern, uint8_t **mem,
+int32_t stlink_parse_ihex(const char *path, uint8_t erased_pattern, uint8_t **mem,
                       size_t *size, uint32_t *begin) {
-  int res = 0;
+  int32_t res = 0;
   *begin = UINT32_MAX;
   uint8_t *data = NULL;
   uint32_t end = 0;
   bool eof_found = false;
 
-  for (int scan = 0; (res == 0) && (scan < 2); ++scan) {
+  for (int32_t scan = 0; (res == 0) && (scan < 2); ++scan) {
     // parse file two times - first to find memory range, second - to fill it
     if (scan == 1) {
       if (!eof_found) {
@@ -885,7 +884,7 @@ int stlink_parse_ihex(const char *path, uint8_t erased_pattern, uint8_t **mem,
       data = calloc(*size, 1); // use calloc to get NULL if out of memory
 
       if (!data) {
-        ELOG("Cannot allocate %u bytes\n", (unsigned)(*size));
+        ELOG("Cannot allocate %u bytes\n", (uint32_t)(*size));
         res = -1;
         break;
       }
@@ -1029,7 +1028,7 @@ uint8_t stlink_get_erased_pattern(stlink_t *sl) {
 }
 
 // 322
-int stlink_target_connect(stlink_t *sl, enum connect_type connect) {
+int32_t stlink_target_connect(stlink_t *sl, enum connect_type connect) {
   if (connect == CONNECT_UNDER_RESET) {
     stlink_enter_swd_mode(sl);
 
@@ -1045,7 +1044,7 @@ int stlink_target_connect(stlink_t *sl, enum connect_type connect) {
     stlink_jtag_reset(sl, STLINK_DEBUG_APIV2_DRIVE_NRST_HIGH);
 
     // try to halt the core after reset
-    unsigned timeout = time_ms() + 10;
+    uint32_t timeout = time_ms() + 10;
     while (time_ms() < timeout) {
       sl->backend->force_debug(sl);
       usleep(100);
@@ -1128,7 +1127,7 @@ static void stop_wdg_in_debug(stlink_t *sl) {
   }
 }
 
-int stlink_jtag_reset(stlink_t *sl, int value) {
+int32_t stlink_jtag_reset(stlink_t *sl, int32_t value) {
   DLOG("*** stlink_jtag_reset %d ***\n", value);
   return (sl->backend->jtag_reset(sl, value));
 }
@@ -1207,7 +1206,7 @@ void stlink_run_at(stlink_t *sl, stm32_addr_t addr) {
 /* Limit the block size to compare to 0x1800 as anything larger will stall the
  * STLINK2 Maybe STLINK V1 needs smaller value!
  */
-int check_file(stlink_t *sl, mapped_file_t *mf, stm32_addr_t addr) {
+int32_t check_file(stlink_t *sl, mapped_file_t *mf, stm32_addr_t addr) {
   size_t off;
   size_t n_cmp = sl->flash_pgsz;
 
@@ -1249,7 +1248,7 @@ void md5_calculate(mapped_file_t *mf) {
   Md5Finalise(&md5Context, &md5Hash);
   printf("md5 checksum: ");
 
-  for (int i = 0; i < (int)sizeof(md5Hash); i++) {
+  for (int32_t i = 0; i < (int32_t)sizeof(md5Hash); i++) {
     printf("%x", md5Hash.bytes[i]);
   }
 
@@ -1269,17 +1268,17 @@ void stlink_checksum(mapped_file_t *mp) {
 }
 
 void stlink_fwrite_finalize(stlink_t *sl, stm32_addr_t addr) {
-  unsigned int val;
+  uint32_t val;
   // set PC to the reset routine
   stlink_read_debug32(sl, addr + 4, &val);
   stlink_write_reg(sl, val, 15);
   stlink_run(sl, RUN_NORMAL);
 }
 
-static int stlink_read(stlink_t *sl, stm32_addr_t addr, size_t size,
+static int32_t stlink_read(stlink_t *sl, stm32_addr_t addr, size_t size,
                        save_block_fn fn, void *fn_arg) {
 
-  int error = -1;
+  int32_t error = -1;
 
   if (size < 1) {
     size = sl->flash_size;
@@ -1333,7 +1332,7 @@ static bool stlink_fread_worker(void *arg, uint8_t *block, ssize_t len) {
 static uint8_t stlink_parse_hex(const char *hex) {
   uint8_t d[2];
 
-  for (int i = 0; i < 2; ++i) {
+  for (int32_t i = 0; i < 2; ++i) {
     char c = *(hex + i);
 
     if (c >= '0' && c <= '9') {
@@ -1406,7 +1405,7 @@ static bool stlink_fread_ihex_writeline(struct stlink_fread_ihex_worker_arg *the
 }
 
 static bool stlink_fread_ihex_init(struct stlink_fread_ihex_worker_arg *the_arg,
-                                   int fd, stm32_addr_t addr) {
+                                   int32_t fd, stm32_addr_t addr) {
   the_arg->file = fdopen(fd, "w");
   the_arg->addr = addr;
   the_arg->lba = 0;
diff --git a/src/stlink-lib/common.h b/src/stlink-lib/common.h
index dd6cf95b2..c60b49199 100644
--- a/src/stlink-lib/common.h
+++ b/src/stlink-lib/common.h
@@ -7,7 +7,12 @@
 #ifndef COMMON_H
 #define COMMON_H
 
-int check_file(stlink_t *, mapped_file_t *, stm32_addr_t);
+#include <stdint.h>
+
+#include "map_file.h"
+#include "md5.h"
+
+int32_t check_file(stlink_t *, mapped_file_t *, stm32_addr_t);
 void md5_calculate(mapped_file_t *);
 void stlink_checksum(mapped_file_t *);
 void stlink_fwrite_finalize(stlink_t *, stm32_addr_t);
diff --git a/src/stlink-lib/common_flash.c b/src/stlink-lib/common_flash.c
index a74d88b16..e2a394946 100644
--- a/src/stlink-lib/common_flash.c
+++ b/src/stlink-lib/common_flash.c
@@ -1,7 +1,9 @@
+#include <stdint.h>
 #include <stdio.h>
-#include <stlink.h>
 #include <unistd.h>
 #include <string.h>
+
+#include <stlink.h>
 #include "calculate.h"
 #include "flash_loader.h"
 #include "common_flash.h"
@@ -31,7 +33,7 @@ uint32_t get_stm32l0_flash_base(stlink_t *sl) {
   }
 }
 
-uint32_t read_flash_cr(stlink_t *sl, unsigned bank) {
+uint32_t read_flash_cr(stlink_t *sl, uint32_t bank) {
   uint32_t reg, res;
 
   if (sl->flash_type == STM32_FLASH_TYPE_F2_F4) {
@@ -117,7 +119,7 @@ void lock_flash(stlink_t *sl) {
   }
 }
 
-static inline int write_flash_sr(stlink_t *sl, unsigned bank, uint32_t val) {
+static inline int32_t write_flash_sr(stlink_t *sl, uint32_t bank, uint32_t val) {
   uint32_t sr_reg;
 
   if ((sl->flash_type == STM32_FLASH_TYPE_F0_F1_F3) ||
@@ -190,7 +192,7 @@ void clear_flash_error(stlink_t *sl) {
   }
 }
 
-uint32_t read_flash_sr(stlink_t *sl, unsigned bank) {
+uint32_t read_flash_sr(stlink_t *sl, uint32_t bank) {
   uint32_t res, sr_reg;
 
   if ((sl->flash_type == STM32_FLASH_TYPE_F0_F1_F3) ||
@@ -222,9 +224,9 @@ uint32_t read_flash_sr(stlink_t *sl, unsigned bank) {
   return (res);
 }
 
-unsigned int is_flash_busy(stlink_t *sl) {
+uint32_t is_flash_busy(stlink_t *sl) {
   uint32_t sr_busy_shift;
-  unsigned int res;
+  uint32_t res;
 
   if ((sl->flash_type == STM32_FLASH_TYPE_F0_F1_F3) ||
       (sl->flash_type == STM32_FLASH_TYPE_F1_XL) ||
@@ -267,7 +269,7 @@ void wait_flash_busy(stlink_t *sl) {
     ;
 }
 
-int check_flash_error(stlink_t *sl) {
+int32_t check_flash_error(stlink_t *sl) {
   uint32_t res = 0;
   uint32_t WRPERR, PROGERR, PGAERR;
 
@@ -361,7 +363,7 @@ int check_flash_error(stlink_t *sl) {
   return (0);
 }
 
-static inline unsigned int is_flash_locked(stlink_t *sl) {
+static inline uint32_t is_flash_locked(stlink_t *sl) {
   /* return non zero for true */
   uint32_t cr_lock_shift;
   uint32_t cr_reg;
@@ -463,7 +465,7 @@ static void unlock_flash(stlink_t *sl) {
 }
 
 /* unlock flash if already locked */
-int unlock_flash_if(stlink_t *sl) {
+int32_t unlock_flash_if(stlink_t *sl) {
   if (is_flash_locked(sl)) {
     unlock_flash(sl);
 
@@ -477,9 +479,9 @@ int unlock_flash_if(stlink_t *sl) {
   return (0);
 }
 
-int lock_flash_option(stlink_t *sl) {
+int32_t lock_flash_option(stlink_t *sl) {
   uint32_t optlock_shift, optcr_reg, n, optcr2_reg = 0;
-  int active_bit_level = 1;
+  int32_t active_bit_level = 1;
 
   switch (sl->flash_type) {
   case STM32_FLASH_TYPE_F0_F1_F3:
@@ -555,7 +557,7 @@ int lock_flash_option(stlink_t *sl) {
 
 static bool is_flash_option_locked(stlink_t *sl) {
   uint32_t optlock_shift, optcr_reg;
-  int active_bit_level = 1;
+  int32_t active_bit_level = 1;
   uint32_t n;
 
   switch (sl->flash_type) {
@@ -612,7 +614,7 @@ static bool is_flash_option_locked(stlink_t *sl) {
   return (n & (1u << optlock_shift));
 }
 
-static int unlock_flash_option(stlink_t *sl) {
+static int32_t unlock_flash_option(stlink_t *sl) {
   uint32_t optkey_reg, optkey2_reg = 0;
   uint32_t optkey1 = FLASH_OPTKEY1;
   uint32_t optkey2 = FLASH_OPTKEY2;
@@ -669,7 +671,7 @@ static int unlock_flash_option(stlink_t *sl) {
   return (0);
 }
 
-int unlock_flash_option_if(stlink_t *sl) {
+int32_t unlock_flash_option_if(stlink_t *sl) {
   if (is_flash_option_locked(sl)) {
     if (unlock_flash_option(sl)) {
       ELOG("Could not unlock flash option!\n");
@@ -687,7 +689,7 @@ int unlock_flash_option_if(stlink_t *sl) {
 }
 
 void write_flash_cr_psiz(stlink_t *sl, uint32_t n,
-                                       unsigned bank) {
+                                       uint32_t bank) {
   uint32_t cr_reg, psize_shift;
   uint32_t x = read_flash_cr(sl, bank);
 
@@ -707,7 +709,7 @@ void write_flash_cr_psiz(stlink_t *sl, uint32_t n,
   stlink_write_debug32(sl, cr_reg, x);
 }
 
-void clear_flash_cr_pg(stlink_t *sl, unsigned bank) {
+void clear_flash_cr_pg(stlink_t *sl, uint32_t bank) {
   uint32_t cr_reg, n;
   uint32_t bit = FLASH_CR_PG;
 
@@ -737,7 +739,7 @@ void clear_flash_cr_pg(stlink_t *sl, unsigned bank) {
 /* ------------------------------------------------------------------------ */
 
 static void wait_flash_busy_progress(stlink_t *sl) {
-  int i = 0;
+  int32_t i = 0;
   fprintf(stdout, "Mass erasing...");
   fflush(stdout);
 
@@ -754,11 +756,11 @@ static void wait_flash_busy_progress(stlink_t *sl) {
   fprintf(stdout, "\n");
 }
 
-static inline void write_flash_ar(stlink_t *sl, uint32_t n, unsigned bank) {
+static inline void write_flash_ar(stlink_t *sl, uint32_t n, uint32_t bank) {
   stlink_write_debug32(sl, (bank == BANK_1) ? FLASH_AR : FLASH_AR2, n);
 }
 
-static inline void write_flash_cr_snb(stlink_t *sl, uint32_t n, unsigned bank) {
+static inline void write_flash_cr_snb(stlink_t *sl, uint32_t n, uint32_t bank) {
   uint32_t cr_reg, snb_mask, snb_shift, ser_shift;
   uint32_t x = read_flash_cr(sl, bank);
 
@@ -783,7 +785,7 @@ static inline void write_flash_cr_snb(stlink_t *sl, uint32_t n, unsigned bank) {
   stlink_write_debug32(sl, cr_reg, x);
 }
 
-static void set_flash_cr_per(stlink_t *sl, unsigned bank) {
+static void set_flash_cr_per(stlink_t *sl, uint32_t bank) {
   uint32_t cr_reg, val;
 
   if (sl->flash_type == STM32_FLASH_TYPE_G0 ||
@@ -802,7 +804,7 @@ static void set_flash_cr_per(stlink_t *sl, unsigned bank) {
   stlink_write_debug32(sl, cr_reg, val);
 }
 
-static void clear_flash_cr_per(stlink_t *sl, unsigned bank) {
+static void clear_flash_cr_per(stlink_t *sl, uint32_t bank) {
   uint32_t cr_reg;
 
   if (sl->flash_type == STM32_FLASH_TYPE_G0 ||
@@ -836,7 +838,7 @@ static inline void write_flash_cr_bker_pnb(stlink_t *sl, uint32_t n) {
   stlink_write_debug32(sl, FLASH_L4_CR, x);
 }
 
-static void set_flash_cr_strt(stlink_t *sl, unsigned bank) {
+static void set_flash_cr_strt(stlink_t *sl, uint32_t bank) {
   uint32_t val, cr_reg, cr_strt;
 
   if (sl->flash_type == STM32_FLASH_TYPE_F2_F4) {
@@ -871,7 +873,7 @@ static void set_flash_cr_strt(stlink_t *sl, unsigned bank) {
   stlink_write_debug32(sl, cr_reg, val);
 }
 
-static void set_flash_cr_mer(stlink_t *sl, bool v, unsigned bank) {
+static void set_flash_cr_mer(stlink_t *sl, bool v, uint32_t bank) {
   uint32_t val, cr_reg, cr_mer, cr_pg;
 
   if (sl->flash_type == STM32_FLASH_TYPE_F2_F4) {
@@ -936,7 +938,7 @@ static void set_flash_cr_mer(stlink_t *sl, bool v, unsigned bank) {
  * @param flashaddr an address in the flash page to erase
  * @return 0 on success -ve on failure
  */
-int stlink_erase_flash_page(stlink_t *sl, stm32_addr_t flashaddr) {
+int32_t stlink_erase_flash_page(stlink_t *sl, stm32_addr_t flashaddr) {
   // wait for ongoing op to finish
   wait_flash_busy(sl);
   // clear flash IO errors
@@ -1108,7 +1110,7 @@ int stlink_erase_flash_page(stlink_t *sl, stm32_addr_t flashaddr) {
     lock_flash(sl);
   } else if (sl->flash_type == STM32_FLASH_TYPE_F0_F1_F3 ||
              sl->flash_type == STM32_FLASH_TYPE_F1_XL) {
-    unsigned bank = (flashaddr < STM32_F1_FLASH_BANK2_BASE) ? BANK_1 : BANK_2;
+    uint32_t bank = (flashaddr < STM32_F1_FLASH_BANK2_BASE) ? BANK_1 : BANK_2;
     unlock_flash_if(sl);
     clear_flash_cr_pg(sl, bank);         // clear the pg bit
     set_flash_cr_per(sl, bank);          // set the page erase bit
@@ -1119,7 +1121,7 @@ int stlink_erase_flash_page(stlink_t *sl, stm32_addr_t flashaddr) {
     clear_flash_cr_per(sl, bank); // clear the page erase bit
     lock_flash(sl);
   } else if (sl->flash_type == STM32_FLASH_TYPE_H7) {
-    unsigned bank = (flashaddr < STM32_H7_FLASH_BANK2_BASE) ? BANK_1 : BANK_2;
+    uint32_t bank = (flashaddr < STM32_H7_FLASH_BANK2_BASE) ? BANK_1 : BANK_2;
     unlock_flash_if(sl); // unlock if locked
     uint32_t sector = calculate_H7_sectornum(
         sl, flashaddr, bank); // calculate the actual page from the address
@@ -1135,7 +1137,7 @@ int stlink_erase_flash_page(stlink_t *sl, stm32_addr_t flashaddr) {
   return check_flash_error(sl);
 }
 
-int stlink_erase_flash_section(stlink_t *sl, stm32_addr_t base_addr, size_t size, bool align_size) {
+int32_t stlink_erase_flash_section(stlink_t *sl, stm32_addr_t base_addr, size_t size, bool align_size) {
   // Check the address and size validity
   if (stlink_check_address_range_validity(sl, base_addr, size) < 0) {
     return -1;
@@ -1149,11 +1151,11 @@ int stlink_erase_flash_section(stlink_t *sl, stm32_addr_t base_addr, size_t size
 
   stm32_addr_t addr = base_addr;
   do {
-    long unsigned int page_size = stlink_calculate_pagesize(sl, addr);
+    uint32_t page_size = stlink_calculate_pagesize(sl, addr);
 
     // Check if size is aligned with a page, unless we want to completely erase the last page
     if ((addr + page_size) > (base_addr + size) && !align_size) {
-      ELOG("Invalid size (not aligned with a page). Page size at address %#x is %#lx\n", addr, page_size);
+      ELOG("Invalid size (not aligned with a page). Page size at address %#x is %#x\n", addr, page_size);
       return (-1);
     }
 
@@ -1162,7 +1164,7 @@ int stlink_erase_flash_section(stlink_t *sl, stm32_addr_t base_addr, size_t size
       return (-1);
     }
 
-    fprintf(stdout, "-> Flash page at %#x erased (size: %#lx)\n", addr, page_size);
+    fprintf(stdout, "-> Flash page at %#x erased (size: %#x)\n", addr, page_size);
     fflush(stdout);
 
     // check the next page is within the range to erase
@@ -1173,8 +1175,8 @@ int stlink_erase_flash_section(stlink_t *sl, stm32_addr_t base_addr, size_t size
   return 0;
 }
 
-int stlink_erase_flash_mass(stlink_t *sl) {
-  int err = 0;
+int32_t stlink_erase_flash_mass(stlink_t *sl) {
+  int32_t err = 0;
 
   // TODO: User MER bit to mass-erase WB series.
   if (sl->flash_type == STM32_FLASH_TYPE_L0_L1 ||
@@ -1224,11 +1226,11 @@ int stlink_erase_flash_mass(stlink_t *sl) {
   return (err);
 }
 
-int stlink_mwrite_flash(stlink_t *sl, uint8_t *data, uint32_t length,
+int32_t stlink_mwrite_flash(stlink_t *sl, uint8_t *data, uint32_t length,
                         stm32_addr_t addr) {
   /* Write the block in flash at addr */
-  int err;
-  unsigned int num_empty, idx;
+  int32_t err;
+  uint32_t num_empty, idx;
   uint8_t erased_pattern = stlink_get_erased_pattern(sl);
 
   /*
@@ -1236,7 +1238,7 @@ int stlink_mwrite_flash(stlink_t *sl, uint8_t *data, uint32_t length,
    * Therfore it is turned off by default.
    */
   if (sl->opt) {
-    idx = (unsigned int)length;
+    idx = (uint32_t)length;
 
     for (num_empty = 0; num_empty != length; ++num_empty)
       if (data[--idx] != erased_pattern) {
@@ -1273,10 +1275,10 @@ int stlink_mwrite_flash(stlink_t *sl, uint8_t *data, uint32_t length,
  * @param addr where to start writing
  * @return 0 on success, -ve on failure.
  */
-int stlink_fwrite_flash(stlink_t *sl, const char *path, stm32_addr_t addr) {
+int32_t stlink_fwrite_flash(stlink_t *sl, const char *path, stm32_addr_t addr) {
   /* Write the file in flash at addr */
-  int err;
-  unsigned int num_empty, idx;
+  int32_t err;
+  uint32_t num_empty, idx;
   uint8_t erased_pattern = stlink_get_erased_pattern(sl);
   mapped_file_t mf = MAPPED_FILE_INITIALIZER;
 
@@ -1290,7 +1292,7 @@ int stlink_fwrite_flash(stlink_t *sl, const char *path, stm32_addr_t addr) {
   stlink_checksum(&mf);
 
   if (sl->opt) {
-    idx = (unsigned int)mf.len;
+    idx = (uint32_t)mf.len;
 
     for (num_empty = 0; num_empty != mf.len; ++num_empty) {
       if (mf.base[--idx] != erased_pattern) {
@@ -1323,10 +1325,10 @@ int stlink_fwrite_flash(stlink_t *sl, const char *path, stm32_addr_t addr) {
 }
 
 
-int stlink_fcheck_flash(stlink_t *sl, const char *path, stm32_addr_t addr) {
+int32_t stlink_fcheck_flash(stlink_t *sl, const char *path, stm32_addr_t addr) {
   // check the contents of path are at addr
 
-  int res;
+  int32_t res;
   mapped_file_t mf = MAPPED_FILE_INITIALIZER;
 
   if (map_file(&mf, path) == -1) {
@@ -1346,8 +1348,8 @@ int stlink_fcheck_flash(stlink_t *sl, const char *path, stm32_addr_t addr) {
  * @param length how much
  * @return 0 for success, -ve for failure
  */
-int stlink_verify_write_flash(stlink_t *sl, stm32_addr_t address, uint8_t *data,
-                              unsigned length) {
+int32_t stlink_verify_write_flash(stlink_t *sl, stm32_addr_t address, uint8_t *data,
+                              uint32_t length) {
   size_t off;
   size_t cmp_size = (sl->flash_pgsz > 0x1800) ? 0x1800 : sl->flash_pgsz;
   ILOG("Starting verification of write complete\n");
@@ -1369,7 +1371,7 @@ int stlink_verify_write_flash(stlink_t *sl, stm32_addr_t address, uint8_t *data,
     stlink_read_mem32(sl, address + (uint32_t)off, (uint16_t)aligned_size);
 
     if (memcmp(sl->q_buf, data + off, cmp_size)) {
-      ELOG("Verification of flash failed at offset: %u\n", (unsigned int)off);
+      ELOG("Verification of flash failed at offset: %u\n", (uint32_t)off);
       return (-1);
     }
   }
@@ -1379,23 +1381,23 @@ int stlink_verify_write_flash(stlink_t *sl, stm32_addr_t address, uint8_t *data,
 }
 
 // Check if an address and size are within the flash
-int stlink_check_address_range_validity(stlink_t *sl, stm32_addr_t addr, size_t size) {
-  long unsigned int logvar;
+int32_t stlink_check_address_range_validity(stlink_t *sl, stm32_addr_t addr, size_t size) {
+  uint32_t logvar;
   if (addr < sl->flash_base || addr >= (sl->flash_base + sl->flash_size)) {
     logvar = sl->flash_base + sl->flash_size - 1;
-    ELOG("Invalid address, it should be within 0x%08x - 0x%08lx\n", sl->flash_base, logvar);
+    ELOG("Invalid address, it should be within 0x%08x - 0x%08x\n", sl->flash_base, logvar);
     return (-1);
   }
   if ((addr + size) > (sl->flash_base + sl->flash_size)) {
     logvar = sl->flash_base + sl->flash_size - addr;
-    ELOG("The size exceeds the size of the flash (0x%08lx bytes available)\n", logvar);
+    ELOG("The size exceeds the size of the flash (0x%08x bytes available)\n", logvar);
     return (-1);
   }
   return 0;
 }
 
 // Check if an address is aligned with the beginning of a page
-int stlink_check_address_alignment(stlink_t *sl, stm32_addr_t addr) {
+int32_t stlink_check_address_alignment(stlink_t *sl, stm32_addr_t addr) {
   stm32_addr_t page = sl->flash_base;
 
   while (page < addr) {
@@ -1409,9 +1411,9 @@ int stlink_check_address_alignment(stlink_t *sl, stm32_addr_t addr) {
   return 0;
 }
 
-int stlink_write_flash(stlink_t *sl, stm32_addr_t addr, uint8_t *base,
+int32_t stlink_write_flash(stlink_t *sl, stm32_addr_t addr, uint8_t *base,
                        uint32_t len, uint8_t eraseonly) {
-  int ret;
+  int32_t ret;
   flash_loader_t fl;
   ILOG("Attempting to write %d (%#x) bytes to stm32 address: %u (%#x)\n", len,
        len, addr, addr);
@@ -1428,7 +1430,7 @@ int stlink_write_flash(stlink_t *sl, stm32_addr_t addr, uint8_t *base,
     ELOG("addr not a multiple of current pagesize (%u bytes), not supported, "
          "check page start address and compare with flash module organisation "
          "in related ST reference manual of your device.\n",
-         (unsigned)(sl->flash_pgsz));
+         (uint32_t)(sl->flash_pgsz));
     return (-1);
   }
 
diff --git a/src/stlink-lib/common_flash.h b/src/stlink-lib/common_flash.h
index aa92b2143..04e9134b5 100644
--- a/src/stlink-lib/common_flash.h
+++ b/src/stlink-lib/common_flash.h
@@ -7,13 +7,15 @@
 #ifndef COMMON_FLASH_H
 #define COMMON_FLASH_H
 
+#include <stdint.h>
+
 void lock_flash(stlink_t *);
 void clear_flash_error(stlink_t *);
 void wait_flash_busy(stlink_t *);
-int check_flash_error(stlink_t *);
-int unlock_flash_if(stlink_t *);
-int lock_flash_option(stlink_t *);
-int unlock_flash_option_if(stlink_t *);
+int32_t check_flash_error(stlink_t *);
+int32_t unlock_flash_if(stlink_t *);
+int32_t lock_flash_option(stlink_t *);
+int32_t unlock_flash_option_if(stlink_t *);
 void write_flash_cr_psiz(stlink_t *, uint32_t, unsigned);
 void clear_flash_cr_pg(stlink_t *, unsigned);
 
diff --git a/src/stlink-lib/flash_loader.c b/src/stlink-lib/flash_loader.c
index 231a5d4d6..99a8260f7 100644
--- a/src/stlink-lib/flash_loader.c
+++ b/src/stlink-lib/flash_loader.c
@@ -1,3 +1,4 @@
+#include <stdint.h>
 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
@@ -151,7 +152,7 @@ static const uint8_t loader_code_stm32f7_lv[] = {
 };
 
 
-int stlink_flash_loader_init(stlink_t *sl, flash_loader_t *fl) {
+int32_t stlink_flash_loader_init(stlink_t *sl, flash_loader_t *fl) {
     size_t size = 0;
     uint32_t dfsr, cfsr, hfsr;
 
@@ -199,18 +200,18 @@ int stlink_flash_loader_init(stlink_t *sl, flash_loader_t *fl) {
     return(0);
 }
 
-static int loader_v_dependent_assignment(stlink_t *sl,
+static int32_t loader_v_dependent_assignment(stlink_t *sl,
                                          const uint8_t **loader_code, size_t *loader_size,
                                          const uint8_t *high_v_loader, size_t high_v_loader_size,
                                          const uint8_t *low_v_loader, size_t low_v_loader_size) {
-    int retval = 0;
+    int32_t retval = 0;
 
     if ( sl->version.stlink_v == 1) {
         printf("STLINK V1 cannot read voltage, defaulting to 32-bit writes\n");
         *loader_code = high_v_loader;
         *loader_size = high_v_loader_size;
     } else {
-        int voltage = stlink_target_voltage(sl);
+        int32_t voltage = stlink_target_voltage(sl);
 
         if (voltage == -1) {
             retval = -1;
@@ -229,7 +230,7 @@ static int loader_v_dependent_assignment(stlink_t *sl,
     return(retval);
 }
 
-int stlink_flash_loader_write_to_sram(stlink_t *sl, stm32_addr_t* addr, size_t* size) {
+int32_t stlink_flash_loader_write_to_sram(stlink_t *sl, stm32_addr_t* addr, size_t* size) {
     const uint8_t* loader_code;
     size_t loader_size;
 
@@ -270,7 +271,7 @@ int stlink_flash_loader_write_to_sram(stlink_t *sl, stm32_addr_t* addr, size_t*
                sl->chip_id == STM32_CHIPID_F412 ||
                sl->chip_id == STM32_CHIPID_F413 ||
                sl->chip_id == STM32_CHIPID_F446) {
-        int retval;
+        int32_t retval;
         retval = loader_v_dependent_assignment(sl,
                                                &loader_code, &loader_size,
                                                loader_code_stm32f4, sizeof(loader_code_stm32f4),
@@ -281,7 +282,7 @@ int stlink_flash_loader_write_to_sram(stlink_t *sl, stm32_addr_t* addr, size_t*
                sl->chip_id == STM32_CHIPID_F7 ||
                sl->chip_id == STM32_CHIPID_F76xxx ||
                sl->chip_id == STM32_CHIPID_F72xxx) {
-        int retval;
+        int32_t retval;
         retval = loader_v_dependent_assignment(sl,
                                                &loader_code, &loader_size,
                                                loader_code_stm32f7, sizeof(loader_code_stm32f7),
@@ -310,7 +311,7 @@ int stlink_flash_loader_write_to_sram(stlink_t *sl, stm32_addr_t* addr, size_t*
     }
 
     memcpy(sl->q_buf, loader_code, loader_size);
-    int ret = stlink_write_mem32(sl, sl->sram_base, (uint16_t)loader_size);
+    int32_t ret = stlink_write_mem32(sl, sl->sram_base, (uint16_t)loader_size);
 
     if (ret) { return(ret); }
 
@@ -320,13 +321,13 @@ int stlink_flash_loader_write_to_sram(stlink_t *sl, stm32_addr_t* addr, size_t*
     return(0); // success
 }
 
-int stlink_flash_loader_run(stlink_t *sl, flash_loader_t* fl, stm32_addr_t target, const uint8_t* buf, size_t size) {
+int32_t stlink_flash_loader_run(stlink_t *sl, flash_loader_t* fl, stm32_addr_t target, const uint8_t* buf, size_t size) {
     struct stlink_reg rr;
-    unsigned timeout;
+    uint32_t timeout;
     uint32_t flash_base = 0;
     uint32_t dhcsr, dfsr, cfsr, hfsr;
 
-    DLOG("Running flash loader, write address:%#x, size: %u\n", target, (unsigned int)size);
+    DLOG("Running flash loader, write address:%#x, size: %u\n", target, (uint32_t)size);
 
     if (write_buffer_to_sram(sl, fl, buf, size) == -1) {
         ELOG("write_buffer_to_sram() == -1\n");
@@ -423,15 +424,15 @@ int stlink_flash_loader_run(stlink_t *sl, flash_loader_t* fl, stm32_addr_t targe
 #define L1_WRITE_BLOCK_SIZE 0x80
 #define L0_WRITE_BLOCK_SIZE 0x40
 
-int stm32l1_write_half_pages(stlink_t *sl, stm32_addr_t addr, uint8_t *base,
+int32_t stm32l1_write_half_pages(stlink_t *sl, stm32_addr_t addr, uint8_t *base,
                              uint32_t len, uint32_t pagesize) {
-  unsigned int count, off;
-  unsigned int num_half_pages = len / pagesize;
+  uint32_t count, off;
+  uint32_t num_half_pages = len / pagesize;
   uint32_t val;
   uint32_t flash_regs_base = get_stm32l0_flash_base(sl);
   flash_loader_t fl;
   bool use_loader = true;
-  int ret = 0;
+  int32_t ret = 0;
 
   // enable half page write
   stlink_read_debug32(sl, flash_regs_base + FLASH_PECR_OFF, &val);
@@ -483,7 +484,7 @@ int stm32l1_write_half_pages(stlink_t *sl, stm32_addr_t addr, uint8_t *base,
   return (ret);
 }
 
-static void set_flash_cr_pg(stlink_t *sl, unsigned bank) {
+static void set_flash_cr_pg(stlink_t *sl, uint32_t bank) {
   uint32_t cr_reg, x;
 
   x = read_flash_cr(sl, bank);
@@ -519,7 +520,7 @@ static void set_flash_cr_pg(stlink_t *sl, unsigned bank) {
   stlink_write_debug32(sl, cr_reg, x);
 }
 
-static void set_dma_state(stlink_t *sl, flash_loader_t *fl, int bckpRstr) {
+static void set_dma_state(stlink_t *sl, flash_loader_t *fl, int32_t bckpRstr) {
   uint32_t rcc, rcc_dma_mask, value;
 
   rcc = rcc_dma_mask = value = 0;
@@ -580,7 +581,7 @@ static void set_dma_state(stlink_t *sl, flash_loader_t *fl, int bckpRstr) {
   }
 }
 
-int stlink_flashloader_start(stlink_t *sl, flash_loader_t *fl) {
+int32_t stlink_flashloader_start(stlink_t *sl, flash_loader_t *fl) {
   // disable DMA
   set_dma_state(sl, fl, 0);
 
@@ -602,7 +603,7 @@ int stlink_flashloader_start(stlink_t *sl, flash_loader_t *fl) {
 
     unlock_flash_if(sl); // first unlock the cr
 
-    int voltage;
+    int32_t voltage;
     if (sl->version.stlink_v == 1) {
       WLOG("STLINK V1 cannot read voltage, use default voltage 3.2V\n");
       voltage = 3200;
@@ -721,7 +722,7 @@ int stlink_flashloader_start(stlink_t *sl, flash_loader_t *fl) {
   return (0);
 }
 
-int stlink_flashloader_write(stlink_t *sl, flash_loader_t *fl,
+int32_t stlink_flashloader_write(stlink_t *sl, flash_loader_t *fl,
                              stm32_addr_t addr, uint8_t *base, uint32_t len) {
   size_t off;
   if ((sl->flash_type == STM32_FLASH_TYPE_F2_F4) ||
@@ -733,7 +734,7 @@ int stlink_flashloader_write(stlink_t *sl, flash_loader_t *fl,
       if (stlink_flash_loader_run(sl, fl, addr + (uint32_t)off, base + off,
                                   size) == -1) {
         ELOG("stlink_flash_loader_run(%#x) failed! == -1\n",
-             (unsigned)(addr + off));
+             (uint32_t)(addr + off));
         check_flash_error(sl);
         return (-1);
       }
@@ -744,14 +745,14 @@ int stlink_flashloader_write(stlink_t *sl, flash_loader_t *fl,
              sl->flash_type == STM32_FLASH_TYPE_G0 ||
              sl->flash_type == STM32_FLASH_TYPE_G4 ||
              sl->flash_type == STM32_FLASH_TYPE_L5_U5) {
-    DLOG("Starting %3u page write\r\n", (unsigned int)(len / sl->flash_pgsz));
+    DLOG("Starting %3u page write\r\n", (uint32_t)(len / sl->flash_pgsz));
     for (off = 0; off < len; off += sizeof(uint32_t)) {
       uint32_t data;
 
       if ((off % sl->flash_pgsz) > (sl->flash_pgsz - 5)) {
         fprintf(stdout, "\r%3u/%3u pages written",
-                (unsigned int)(off / sl->flash_pgsz + 1),
-                (unsigned int)(len / sl->flash_pgsz));
+                (uint32_t)(off / sl->flash_pgsz + 1),
+                (uint32_t)(len / sl->flash_pgsz));
         fflush(stdout);
       }
 
@@ -773,7 +774,7 @@ int stlink_flashloader_write(stlink_t *sl, flash_loader_t *fl,
     uint32_t pagesize = (flash_regs_base == FLASH_L0_REGS_ADDR)?
                                 L0_WRITE_BLOCK_SIZE:L1_WRITE_BLOCK_SIZE;
 
-    DLOG("Starting %3u page write\r\n", (unsigned int)(len / sl->flash_pgsz));
+    DLOG("Starting %3u page write\r\n", (uint32_t)(len / sl->flash_pgsz));
 
     off = 0;
 
@@ -791,8 +792,8 @@ int stlink_flashloader_write(stlink_t *sl, flash_loader_t *fl,
 
       if ((off % sl->flash_pgsz) > (sl->flash_pgsz - 5)) {
         fprintf(stdout, "\r%3u/%3u pages written",
-                (unsigned int)(off / sl->flash_pgsz + 1),
-                (unsigned int)(len / sl->flash_pgsz));
+                (uint32_t)(off / sl->flash_pgsz + 1),
+                (uint32_t)(len / sl->flash_pgsz));
         fflush(stdout);
       }
 
@@ -809,7 +810,7 @@ int stlink_flashloader_write(stlink_t *sl, flash_loader_t *fl,
     fprintf(stdout, "\n");
   } else if ((sl->flash_type == STM32_FLASH_TYPE_F0_F1_F3) ||
              (sl->flash_type == STM32_FLASH_TYPE_F1_XL)) {
-    int write_block_count = 0;
+    int32_t write_block_count = 0;
     for (off = 0; off < len; off += sl->flash_pgsz) {
       // adjust last write size
       size_t size = len - off > sl->flash_pgsz ? sl->flash_pgsz : len - off;
@@ -822,7 +823,7 @@ int stlink_flashloader_write(stlink_t *sl, flash_loader_t *fl,
       if (stlink_flash_loader_run(sl, fl, addr + (uint32_t)off, base + off,
                                   size) == -1) {
         ELOG("stlink_flash_loader_run(%#x) failed! == -1\n",
-             (unsigned)(addr + off));
+             (uint32_t)(addr + off));
         check_flash_error(sl);
         return (-1);
       }
@@ -833,7 +834,7 @@ int stlink_flashloader_write(stlink_t *sl, flash_loader_t *fl,
         // show progress; writing procedure is slow and previous errors are
         // misleading
         fprintf(stdout, "\r%3u/%3u pages written", ++write_block_count,
-                (unsigned int)((len + sl->flash_pgsz - 1) / sl->flash_pgsz));
+                (uint32_t)((len + sl->flash_pgsz - 1) / sl->flash_pgsz));
         fflush(stdout);
       }
     }
@@ -852,8 +853,8 @@ int stlink_flashloader_write(stlink_t *sl, flash_loader_t *fl,
 
       if (sl->verbose >= 1) {
         // show progress
-        fprintf(stdout, "\r%u/%u bytes written", (unsigned int)off,
-                (unsigned int)len);
+        fprintf(stdout, "\r%u/%u bytes written", (uint32_t)off,
+                (uint32_t)len);
         fflush(stdout);
       }
     }
@@ -867,7 +868,7 @@ int stlink_flashloader_write(stlink_t *sl, flash_loader_t *fl,
   return check_flash_error(sl);
 }
 
-int stlink_flashloader_stop(stlink_t *sl, flash_loader_t *fl) {
+int32_t stlink_flashloader_stop(stlink_t *sl, flash_loader_t *fl) {
   uint32_t dhcsr;
 
   if ((sl->flash_type == STM32_FLASH_TYPE_F0_F1_F3) ||
diff --git a/src/stlink-lib/flash_loader.h b/src/stlink-lib/flash_loader.h
index 51448395f..5b7b0945d 100644
--- a/src/stlink-lib/flash_loader.h
+++ b/src/stlink-lib/flash_loader.h
@@ -7,18 +7,18 @@
 #ifndef FLASH_LOADER_H
 #define FLASH_LOADER_H
 
-#include <stdio.h>
 #include <stdint.h>
+#include <stdio.h>
 #include <stddef.h>
 
 #include <stlink.h>
 
-int stlink_flash_loader_init(stlink_t *sl, flash_loader_t* fl);
-int stlink_flash_loader_write_to_sram(stlink_t *sl, stm32_addr_t* addr, size_t* size);
-int stlink_flash_loader_run(stlink_t *sl, flash_loader_t* fl, stm32_addr_t target, const uint8_t* buf, size_t size);
+int32_t stlink_flash_loader_init(stlink_t *sl, flash_loader_t* fl);
+int32_t stlink_flash_loader_write_to_sram(stlink_t *sl, stm32_addr_t* addr, size_t* size);
+int32_t stlink_flash_loader_run(stlink_t *sl, flash_loader_t* fl, stm32_addr_t target, const uint8_t* buf, size_t size);
 
-int stlink_flashloader_start(stlink_t *sl, flash_loader_t *fl);
-int stlink_flashloader_write(stlink_t *sl, flash_loader_t *fl, stm32_addr_t addr, uint8_t* base, uint32_t len);
-int stlink_flashloader_stop(stlink_t *sl, flash_loader_t *fl);
+int32_t stlink_flashloader_start(stlink_t *sl, flash_loader_t *fl);
+int32_t stlink_flashloader_write(stlink_t *sl, flash_loader_t *fl, stm32_addr_t addr, uint8_t* base, uint32_t len);
+int32_t stlink_flashloader_stop(stlink_t *sl, flash_loader_t *fl);
 
 #endif // FLASH_LOADER_H
diff --git a/src/stlink-lib/helper.c b/src/stlink-lib/helper.c
index 15e6397bf..a6155925f 100644
--- a/src/stlink-lib/helper.c
+++ b/src/stlink-lib/helper.c
@@ -1,23 +1,24 @@
-#include <helper.h>
-
 #include <stddef.h>
+#include <stdint.h>
 #include <stdlib.h>
 
+#include "helper.h"
+
 #ifdef STLINK_HAVE_SYS_TIME_H
 #include <sys/time.h>
 #else
 #include <sys_time.h>
 #endif
 
-unsigned time_ms() {
+uint32_t time_ms() {
     struct timeval tv;
     gettimeofday(&tv, NULL);
-    return (unsigned)(tv.tv_sec * 1000 + tv.tv_usec / 1000);
+    return (uint32_t)(tv.tv_sec * 1000 + tv.tv_usec / 1000);
 }
 
-int arg_parse_freq(const char *str) {
+int32_t arg_parse_freq(const char *str) {
     char *tail;
-    int value = (int)strtol(str, &tail, 10);
+    int32_t value = (int32_t)strtol(str, &tail, 10);
 
     if (tail[0] == 'M' && tail[1] == '\0') {
         value = value*1000;
diff --git a/src/stlink-lib/helper.h b/src/stlink-lib/helper.h
index cf45bbf43..dbd760a52 100644
--- a/src/stlink-lib/helper.h
+++ b/src/stlink-lib/helper.h
@@ -1,8 +1,10 @@
 #ifndef HELPER_H
 #define HELPER_H
 
-unsigned time_ms();
+#include <stdint.h>
 
-int arg_parse_freq(const char *str);
+uint32_t time_ms();
+
+int32_t arg_parse_freq(const char *str);
 
 #endif // HELPER_H
diff --git a/src/stlink-lib/logging.c b/src/stlink-lib/logging.c
index 79924fc20..a64ec4ef2 100644
--- a/src/stlink-lib/logging.c
+++ b/src/stlink-lib/logging.c
@@ -7,6 +7,7 @@
 
 #include <stdarg.h>
 #include <stddef.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #define __STDC_WANT_LIB_EXT1__ 1
@@ -14,14 +15,14 @@
 
 #include "logging.h"
 
-static int max_level = UDEBUG;
+static int32_t max_level = UDEBUG;
 
-int ugly_init(int maximum_threshold) {
+int32_t ugly_init(int32_t maximum_threshold) {
   max_level = maximum_threshold;
   return (0);
 }
 
-int ugly_log(int level, const char *tag, const char *format, ...) {
+int32_t ugly_log(int32_t level, const char *tag, const char *format, ...) {
   if (level > max_level) {
     return (0);
   }
@@ -84,7 +85,7 @@ int ugly_log(int level, const char *tag, const char *format, ...) {
  *  - LIBUSB_LOG_LEVEL_DEBUG (4)   : debug and informational messages are
  * printed to stderr
  */
-int ugly_libusb_log_level(enum ugly_loglevel v) {
+int32_t ugly_libusb_log_level(enum ugly_loglevel v) {
 #ifdef __FreeBSD__
   // FreeBSD includes its own reimplementation of libusb.
   // Its libusb_set_debug() function expects a lib_debug_level
diff --git a/src/stlink-lib/logging.h b/src/stlink-lib/logging.h
index 893a02c24..471933096 100644
--- a/src/stlink-lib/logging.h
+++ b/src/stlink-lib/logging.h
@@ -5,6 +5,8 @@
 #ifndef LOGGING_H
 #define LOGGING_H
 
+#include <stdint.h>
+
 #ifdef  __cplusplus
 extern "C" {
 #endif
@@ -22,9 +24,9 @@ enum ugly_loglevel {
 #define PRINTF_ARRT
 #endif
 
-int ugly_init(int maximum_threshold);
-int ugly_log(int level, const char *tag, const char *format, ...) PRINTF_ARRT;
-int ugly_libusb_log_level(enum ugly_loglevel v);
+int32_t ugly_init(int32_t maximum_threshold);
+int32_t ugly_log(int32_t level, const char *tag, const char *format, ...) PRINTF_ARRT;
+int32_t ugly_libusb_log_level(enum ugly_loglevel v);
 
 #define UGLY_LOG_FILE (strstr(__FILE__, "/") != NULL ? \
                        strrchr(__FILE__, '/')  + 1 : strstr(__FILE__, "\\") != NULL ? \
diff --git a/src/stlink-lib/map_file.c b/src/stlink-lib/map_file.c
index 3bb7555d5..bb83ff7be 100644
--- a/src/stlink-lib/map_file.c
+++ b/src/stlink-lib/map_file.c
@@ -1,11 +1,12 @@
 #include <fcntl.h>
-#include <sys/stat.h>
-#include <md5.h>
+#include <stdint.h>
 #include <unistd.h>
-#include <stlink.h>
-#include <logging.h>
+#include <sys/stat.h>
 
+#include <stlink.h>
+#include "logging.h"
 #include "map_file.h"
+#include "md5.h"
 
 #ifndef O_BINARY
 #define O_BINARY 0
@@ -15,11 +16,11 @@
 #define MAX_FILE_SIZE (1<<20) // 1 GB max file size
 #endif
 
-int map_file(mapped_file_t *mf, const char *path) {
-  int error = -1;
+int32_t map_file(mapped_file_t *mf, const char *path) {
+  int32_t error = -1;
   struct stat st;
 
-  const int fd = open(path, O_RDONLY | O_BINARY);
+  const int32_t fd = open(path, O_RDONLY | O_BINARY);
 
   if (fd == -1) {
     fprintf(stderr, "open(%s) == -1\n", path);
diff --git a/src/stlink-lib/map_file.h b/src/stlink-lib/map_file.h
index f50a201f0..b33ebf5db 100644
--- a/src/stlink-lib/map_file.h
+++ b/src/stlink-lib/map_file.h
@@ -7,6 +7,8 @@
 #ifndef MAP_FILE_H
 #define MAP_FILE_H
 
+#include <stdint.h>
+
 #ifndef O_BINARY
 #define O_BINARY 0
 #endif
@@ -26,7 +28,7 @@ typedef struct mapped_file {
 #define MAPPED_FILE_INITIALIZER                                                \
   { NULL, 0 }
 
-int map_file(mapped_file_t *, const char *);
+int32_t map_file(mapped_file_t *, const char *);
 void unmap_file(mapped_file_t *);
 
 #endif // MAP_FILE_H
diff --git a/src/stlink-lib/md5.c b/src/stlink-lib/md5.c
index 4c353bfd6..19ec86b91 100644
--- a/src/stlink-lib/md5.c
+++ b/src/stlink-lib/md5.c
@@ -5,6 +5,7 @@
  * This is free and unencumbered software released into the public domain - June 2013 - waterjuice.org
  */
 
+#include <stdint.h>
 #include <memory.h>
 
 #include "md5.h"
@@ -205,7 +206,7 @@ void Md5Update(Md5Context* Context /* [in out] */, void const* Buffer /* [in] */
     }
 
     if ( BufferSize >= 64 ) {
-        Buffer = TransformFunction( Context, Buffer, BufferSize & ~(unsigned long)0x3f );
+        Buffer = TransformFunction( Context, Buffer, BufferSize & ~(uint32_t)0x3f );
         BufferSize &= 0x3f;
     }
 
diff --git a/src/stlink-lib/option_bytes.c b/src/stlink-lib/option_bytes.c
index f5932a7b9..e2d966b7a 100644
--- a/src/stlink-lib/option_bytes.c
+++ b/src/stlink-lib/option_bytes.c
@@ -1,10 +1,12 @@
+#include <stdint.h>
 #include <stdio.h>
 #include <string.h>
+
 #include <stlink.h>
-#include "option_bytes.h"
+#include "common.h"
 #include "common_flash.h"
 #include "map_file.h"
-#include "common.h"
+#include "option_bytes.h"
 
 
 /**
@@ -13,7 +15,7 @@
  * @param option_byte
  * @return 0 on success, -ve on failure.
  */
-int stlink_read_option_control_register_f0(stlink_t *sl, uint32_t *option_byte) {
+int32_t stlink_read_option_control_register_f0(stlink_t *sl, uint32_t *option_byte) {
   DLOG("@@@@ Read option control register byte from %#10x\n", FLASH_OBR);
   return stlink_read_debug32(sl, FLASH_OBR, option_byte);
 }
@@ -26,8 +28,8 @@ int stlink_read_option_control_register_f0(stlink_t *sl, uint32_t *option_byte)
  * @param len of option bytes
  * @return 0 on success, -ve on failure.
  */
-static int stlink_write_option_bytes_f0(stlink_t *sl, stm32_addr_t addr, uint8_t* base, uint32_t len) {
-  int ret = 0;
+static int32_t stlink_write_option_bytes_f0(stlink_t *sl, stm32_addr_t addr, uint8_t* base, uint32_t len) {
+  int32_t ret = 0;
 
   if (len < 12 || addr != STM32_F0_OPTION_BYTES_BASE) {
 	WLOG("Only full write of option bytes area is supported\n");
@@ -81,12 +83,12 @@ static int stlink_write_option_bytes_f0(stlink_t *sl, stm32_addr_t addr, uint8_t
  * @param option_cr
  * @return 0 on success, -ve on failure.
  */
-static int stlink_write_option_control_register_f0(stlink_t *sl, uint32_t option_cr) {
-  int ret = 0;
+static int32_t stlink_write_option_control_register_f0(stlink_t *sl, uint32_t option_cr) {
+  int32_t ret = 0;
   uint16_t opt_val[8];
-  unsigned protection, optiondata;
+  uint32_t protection, optiondata;
   uint16_t user_options, user_data, rdp;
-  unsigned option_offset, user_data_offset;
+  uint32_t option_offset, user_data_offset;
 
   ILOG("Asked to write option control register %#10x to %#010x.\n", option_cr, FLASH_OBR);
 
@@ -166,7 +168,7 @@ static int stlink_write_option_control_register_f0(stlink_t *sl, uint32_t option
  * @param option_byte
  * @return 0 on success, -ve on failure.
  */
-int stlink_read_option_control_register_f2(stlink_t *sl, uint32_t *option_byte) {
+int32_t stlink_read_option_control_register_f2(stlink_t *sl, uint32_t *option_byte) {
   return stlink_read_debug32(sl, FLASH_F2_OPT_CR, option_byte);
 }
 
@@ -176,7 +178,7 @@ int stlink_read_option_control_register_f2(stlink_t *sl, uint32_t *option_byte)
  * @param option_byte
  * @return 0 on success, -ve on failure.
  */
-int stlink_read_option_bytes_f2(stlink_t *sl, uint32_t *option_byte) {
+int32_t stlink_read_option_bytes_f2(stlink_t *sl, uint32_t *option_byte) {
   return stlink_read_option_control_register_f2(sl, option_byte);
 }
 
@@ -186,7 +188,7 @@ int stlink_read_option_bytes_f2(stlink_t *sl, uint32_t *option_byte) {
  * @param option_byte
  * @return 0 on success, -ve on failure.
  */
-int stlink_read_option_control_register_f4(stlink_t *sl, uint32_t *option_byte) {
+int32_t stlink_read_option_control_register_f4(stlink_t *sl, uint32_t *option_byte) {
   return stlink_read_debug32(sl, FLASH_F4_OPTCR, option_byte);
 }
 
@@ -196,7 +198,7 @@ int stlink_read_option_control_register_f4(stlink_t *sl, uint32_t *option_byte)
  * @param option_byte
  * @return 0 on success, -ve on failure.
  */
-int stlink_read_option_bytes_f4(stlink_t *sl, uint32_t *option_byte) {
+int32_t stlink_read_option_bytes_f4(stlink_t *sl, uint32_t *option_byte) {
   return stlink_read_option_control_register_f4(sl, option_byte);
 }
 
@@ -208,9 +210,9 @@ int stlink_read_option_bytes_f4(stlink_t *sl, uint32_t *option_byte) {
  * @param len of option bytes
  * @return 0 on success, -ve on failure.
  */
-static int stlink_write_option_bytes_f4(stlink_t *sl, stm32_addr_t addr, uint8_t *base, uint32_t len) {
+static int32_t stlink_write_option_bytes_f4(stlink_t *sl, stm32_addr_t addr, uint8_t *base, uint32_t len) {
   uint32_t option_byte;
-  int ret = 0;
+  int32_t ret = 0;
   (void)addr;
   (void)len;
 
@@ -237,10 +239,10 @@ static int stlink_write_option_bytes_f4(stlink_t *sl, stm32_addr_t addr, uint8_t
  * @param option_byte
  * @return 0 on success, -ve on failure.
  */
-// Since multiple bytes can be read, we read and print all, but one here
+// Since multiple bytes can be read, we read and print32_t all, but one here
 // and then return the last one just like other devices.
-int stlink_read_option_bytes_f7(stlink_t *sl, uint32_t *option_byte) {
-  int err = -1;
+int32_t stlink_read_option_bytes_f7(stlink_t *sl, uint32_t *option_byte) {
+  int32_t err = -1;
   for (uint32_t counter = 0; counter < (sl->option_size / 4 - 1); counter++) {
     err = stlink_read_debug32(sl, sl->option_base + counter * sizeof(uint32_t), option_byte);
     if (err == -1) {
@@ -264,9 +266,9 @@ int stlink_read_option_bytes_f7(stlink_t *sl, uint32_t *option_byte) {
  * @param len of option bytes
  * @return 0 on success, -ve on failure.
  */
-static int stlink_write_option_bytes_f7(stlink_t *sl, stm32_addr_t addr, uint8_t *base, uint32_t len) {
+static int32_t stlink_write_option_bytes_f7(stlink_t *sl, stm32_addr_t addr, uint8_t *base, uint32_t len) {
   uint32_t option_byte;
-  int ret = 0;
+  int32_t ret = 0;
 
   // Clear errors
   clear_flash_error(sl);
@@ -317,7 +319,7 @@ static int stlink_write_option_bytes_f7(stlink_t *sl, stm32_addr_t addr, uint8_t
  * @param option_byte
  * @return 0 on success, -ve on failure.
  */
-int stlink_read_option_control_register_f7(stlink_t *sl, uint32_t *option_byte) {
+int32_t stlink_read_option_control_register_f7(stlink_t *sl, uint32_t *option_byte) {
   DLOG("@@@@ Read option control register byte from %#10x\n", FLASH_F7_OPTCR);
   return stlink_read_debug32(sl, FLASH_F7_OPTCR, option_byte);
 }
@@ -328,8 +330,8 @@ int stlink_read_option_control_register_f7(stlink_t *sl, uint32_t *option_byte)
  * @param option_cr
  * @return 0 on success, -ve on failure.
  */
-static int stlink_write_option_control_register_f7(stlink_t *sl, uint32_t option_cr) {
-  int ret = 0;
+static int32_t stlink_write_option_control_register_f7(stlink_t *sl, uint32_t option_cr) {
+  int32_t ret = 0;
 
   // Clear errors
   clear_flash_error(sl);
@@ -358,7 +360,7 @@ static int stlink_write_option_control_register_f7(stlink_t *sl, uint32_t option
  * @param option_byte
  * @return 0 on success, -ve on failure.
  */
-int stlink_read_option_control_register1_f7(stlink_t *sl, uint32_t *option_byte) {
+int32_t stlink_read_option_control_register1_f7(stlink_t *sl, uint32_t *option_byte) {
   DLOG("@@@@ Read option control register 1 byte from %#10x\n",
        FLASH_F7_OPTCR1);
   return stlink_read_debug32(sl, FLASH_F7_OPTCR1, option_byte);
@@ -370,8 +372,8 @@ int stlink_read_option_control_register1_f7(stlink_t *sl, uint32_t *option_byte)
  * @param option_cr1
  * @return 0 on success, -ve on failure.
  */
-static int stlink_write_option_control_register1_f7(stlink_t *sl, uint32_t option_cr1) {
-  int ret = 0;
+static int32_t stlink_write_option_control_register1_f7(stlink_t *sl, uint32_t option_cr1) {
+  int32_t ret = 0;
 
   // Clear errors
   clear_flash_error(sl);
@@ -405,7 +407,7 @@ static int stlink_write_option_control_register1_f7(stlink_t *sl, uint32_t optio
  * @param option_byte
  * @return 0 on success, -ve on failure.
  */
-int stlink_read_option_bytes_boot_add_f7(stlink_t *sl, uint32_t *option_byte) {
+int32_t stlink_read_option_bytes_boot_add_f7(stlink_t *sl, uint32_t *option_byte) {
   DLOG("@@@@ Read option byte boot address\n");
   return stlink_read_option_control_register1_f7(sl, option_byte);
 }
@@ -428,7 +430,7 @@ stlink_write_option_bytes_boot_add_f7(stlink_t *sl, uint32_t option_byte_boot_ad
  * @param option_byte
  * @return 0 on success, -ve on failure.
  */
-int stlink_read_option_control_register_gx(stlink_t *sl, uint32_t *option_byte) {
+int32_t stlink_read_option_control_register_gx(stlink_t *sl, uint32_t *option_byte) {
   return stlink_read_debug32(sl, FLASH_Gx_OPTR, option_byte);
 }
 
@@ -438,7 +440,7 @@ int stlink_read_option_control_register_gx(stlink_t *sl, uint32_t *option_byte)
  * @param option_byte
  * @return 0 on success, -ve on failure.
  */
-int stlink_read_option_bytes_gx(stlink_t *sl, uint32_t *option_byte) {
+int32_t stlink_read_option_bytes_gx(stlink_t *sl, uint32_t *option_byte) {
   return stlink_read_option_control_register_gx(sl, option_byte);
 }
 
@@ -450,10 +452,10 @@ int stlink_read_option_bytes_gx(stlink_t *sl, uint32_t *option_byte) {
  * @param len of option bytes
  * @return 0 on success, -ve on failure.
  */
-static int stlink_write_option_bytes_gx(stlink_t *sl, stm32_addr_t addr, uint8_t *base, uint32_t len) {
+static int32_t stlink_write_option_bytes_gx(stlink_t *sl, stm32_addr_t addr, uint8_t *base, uint32_t len) {
   /* Write options bytes */
   uint32_t val;
-  int ret = 0;
+  int32_t ret = 0;
   (void)len;
   uint32_t data;
 
@@ -488,7 +490,7 @@ static int stlink_write_option_bytes_gx(stlink_t *sl, stm32_addr_t addr, uint8_t
  * @param len of option bytes
  * @return 0 on success, -ve on failure.
  */
-static int stlink_write_option_bytes_h7(stlink_t *sl, stm32_addr_t addr, uint8_t *base, uint32_t len) {
+static int32_t stlink_write_option_bytes_h7(stlink_t *sl, stm32_addr_t addr, uint8_t *base, uint32_t len) {
   uint32_t val;
   uint32_t data;
 
@@ -556,11 +558,11 @@ static int stlink_write_option_bytes_h7(stlink_t *sl, stm32_addr_t addr, uint8_t
  * @param len of option bytes
  * @return 0 on success, -ve on failure.
  */
-static int stlink_write_option_bytes_l0(stlink_t *sl, stm32_addr_t addr, uint8_t *base, uint32_t len) {
+static int32_t stlink_write_option_bytes_l0(stlink_t *sl, stm32_addr_t addr, uint8_t *base, uint32_t len) {
   uint32_t flash_base = get_stm32l0_flash_base(sl);
   uint32_t val;
   uint32_t data;
-  int ret = 0;
+  int32_t ret = 0;
 
   // Clear errors
   clear_flash_error(sl);
@@ -598,10 +600,10 @@ static int stlink_write_option_bytes_l0(stlink_t *sl, stm32_addr_t addr, uint8_t
  * @param len of option bytes
  * @return 0 on success, -ve on failure.
  */
-static int stlink_write_option_bytes_l4(stlink_t *sl, stm32_addr_t addr, uint8_t *base, uint32_t len) {
+static int32_t stlink_write_option_bytes_l4(stlink_t *sl, stm32_addr_t addr, uint8_t *base, uint32_t len) {
 
   uint32_t val;
-  int ret = 0;
+  int32_t ret = 0;
   (void)addr;
   (void)len;
 
@@ -638,10 +640,10 @@ static int stlink_write_option_bytes_l4(stlink_t *sl, stm32_addr_t addr, uint8_t
  * @param len of option bytes
  * @return 0 on success, -ve on failure.
  */
-static int stlink_write_option_bytes_wb(stlink_t *sl, stm32_addr_t addr, uint8_t *base, uint32_t len) {
+static int32_t stlink_write_option_bytes_wb(stlink_t *sl, stm32_addr_t addr, uint8_t *base, uint32_t len) {
   /* Write options bytes */
   uint32_t val;
-  int ret = 0;
+  int32_t ret = 0;
   (void)len;
   uint32_t data;
 
@@ -686,7 +688,7 @@ static int stlink_write_option_bytes_wb(stlink_t *sl, stm32_addr_t addr, uint8_t
  * @param option_byte
  * @return 0 on success, -ve on failure.
  */
-int stlink_read_option_control_register_wb(stlink_t *sl, uint32_t *option_byte) {
+int32_t stlink_read_option_control_register_wb(stlink_t *sl, uint32_t *option_byte) {
   DLOG("@@@@ Read option control register byte from %#10x\n", FLASH_WB_OPTR);
   return stlink_read_debug32(sl, FLASH_WB_OPTR, option_byte);
 }
@@ -697,8 +699,8 @@ int stlink_read_option_control_register_wb(stlink_t *sl, uint32_t *option_byte)
  * @param option_cr
  * @return 0 on success, -ve on failure.
  */
-static int stlink_write_option_control_register_wb(stlink_t *sl, uint32_t option_cr) {
-  int ret = 0;
+static int32_t stlink_write_option_control_register_wb(stlink_t *sl, uint32_t option_cr) {
+  int32_t ret = 0;
 
   // Clear errors
   clear_flash_error(sl);
@@ -730,7 +732,7 @@ static int stlink_write_option_control_register_wb(stlink_t *sl, uint32_t option
  * @param option_byte
  * @return 0 on success, -ve on failure.
  */
-int stlink_read_option_bytes_generic(stlink_t *sl, uint32_t *option_byte) {
+int32_t stlink_read_option_bytes_generic(stlink_t *sl, uint32_t *option_byte) {
   DLOG("@@@@ Read option bytes boot address from %#10x\n", sl->option_base);
   return stlink_read_debug32(sl, sl->option_base, option_byte);
 }
@@ -744,8 +746,8 @@ int stlink_read_option_bytes_generic(stlink_t *sl, uint32_t *option_byte) {
  * @param len of option bytes
  * @return 0 on success, -ve on failure.
  */
-int stlink_write_option_bytes(stlink_t *sl, stm32_addr_t addr, uint8_t *base, uint32_t len) {
-  int ret = -1;
+int32_t stlink_write_option_bytes(stlink_t *sl, stm32_addr_t addr, uint8_t *base, uint32_t len) {
+  int32_t ret = -1;
 
   if (sl->option_base == 0) {
     ELOG("Option bytes writing is currently not supported for connected chip\n");
@@ -826,9 +828,9 @@ int stlink_write_option_bytes(stlink_t *sl, stm32_addr_t addr, uint8_t *base, ui
  * @param addr of the memory mapped option bytes
  * @return 0 on success, -ve on failure.
  */
-int stlink_fwrite_option_bytes(stlink_t *sl, const char *path, stm32_addr_t addr) {
+int32_t stlink_fwrite_option_bytes(stlink_t *sl, const char *path, stm32_addr_t addr) {
   /* Write the file in flash at addr */
-  int err;
+  int32_t err;
   mapped_file_t mf = MAPPED_FILE_INITIALIZER;
 
   if (map_file(&mf, path) == -1) {
@@ -853,7 +855,7 @@ int stlink_fwrite_option_bytes(stlink_t *sl, const char *path, stm32_addr_t addr
  * @param option_byte
  * @return 0 on success, -ve on failure.
  */
-int stlink_read_option_control_register32(stlink_t *sl, uint32_t *option_byte) {
+int32_t stlink_read_option_control_register32(stlink_t *sl, uint32_t *option_byte) {
   if (sl->option_base == 0) {
     ELOG("Option bytes read is currently not supported for connected chip\n");
     return -1;
@@ -878,8 +880,8 @@ int stlink_read_option_control_register32(stlink_t *sl, uint32_t *option_byte) {
  * @param option_cr
  * @return 0 on success, -ve on failure.
  */
-int stlink_write_option_control_register32(stlink_t *sl, uint32_t option_cr) {
-  int ret = -1;
+int32_t stlink_write_option_control_register32(stlink_t *sl, uint32_t option_cr) {
+  int32_t ret = -1;
 
   wait_flash_busy(sl);
 
@@ -928,7 +930,7 @@ int stlink_write_option_control_register32(stlink_t *sl, uint32_t option_cr) {
  * @param option_byte
  * @return 0 on success, -ve on failure.
  */
-int stlink_read_option_control_register1_32(stlink_t *sl, uint32_t *option_byte) {
+int32_t stlink_read_option_control_register1_32(stlink_t *sl, uint32_t *option_byte) {
   if (sl->option_base == 0) {
     ELOG("Option bytes read is currently not supported for connected chip\n");
     return -1;
@@ -949,8 +951,8 @@ int stlink_read_option_control_register1_32(stlink_t *sl, uint32_t *option_byte)
  * @param option_cr
  * @return 0 on success, -ve on failure.
  */
-int stlink_write_option_control_register1_32(stlink_t *sl, uint32_t option_cr1) {
-  int ret = -1;
+int32_t stlink_write_option_control_register1_32(stlink_t *sl, uint32_t option_cr1) {
+  int32_t ret = -1;
 
   wait_flash_busy(sl);
 
@@ -992,7 +994,7 @@ int stlink_write_option_control_register1_32(stlink_t *sl, uint32_t option_cr1)
  * @param option_byte
  * @return 0 on success, -ve on failure.
  */
-int stlink_read_option_bytes32(stlink_t *sl, uint32_t *option_byte) {
+int32_t stlink_read_option_bytes32(stlink_t *sl, uint32_t *option_byte) {
   if (sl->option_base == 0) {
     ELOG("Option bytes read is currently not supported for connected chip\n");
     return (-1);
@@ -1022,7 +1024,7 @@ int stlink_read_option_bytes32(stlink_t *sl, uint32_t *option_byte) {
  * @param option_byte
  * @return 0 on success, -ve on failure.
  */
-int stlink_write_option_bytes32(stlink_t *sl, uint32_t option_byte) {
+int32_t stlink_write_option_bytes32(stlink_t *sl, uint32_t option_byte) {
   WLOG("About to write option byte %#10x to %#10x.\n", option_byte,
        sl->option_base);
   return stlink_write_option_bytes(sl, sl->option_base, (uint8_t *)&option_byte, 4);
@@ -1034,7 +1036,7 @@ int stlink_write_option_bytes32(stlink_t *sl, uint32_t option_byte) {
  * @param option_byte
  * @return 0 on success, -ve on failure.
  */
-int stlink_read_option_bytes_boot_add32(stlink_t *sl, uint32_t *option_byte) {
+int32_t stlink_read_option_bytes_boot_add32(stlink_t *sl, uint32_t *option_byte) {
   if (sl->option_base == 0) {
     ELOG("Option bytes boot address read is currently not supported for connected chip\n");
     return -1;
@@ -1055,8 +1057,8 @@ int stlink_read_option_bytes_boot_add32(stlink_t *sl, uint32_t *option_byte) {
  * @param option_bytes_boot_add
  * @return 0 on success, -ve on failure.
  */
-int stlink_write_option_bytes_boot_add32(stlink_t *sl, uint32_t option_bytes_boot_add) {
-  int ret = -1;
+int32_t stlink_write_option_bytes_boot_add32(stlink_t *sl, uint32_t option_bytes_boot_add) {
+  int32_t ret = -1;
 
   wait_flash_busy(sl);
 
diff --git a/src/stlink-lib/option_bytes.h b/src/stlink-lib/option_bytes.h
index 9c81fba8a..c0a1c9a6d 100644
--- a/src/stlink-lib/option_bytes.h
+++ b/src/stlink-lib/option_bytes.h
@@ -7,20 +7,22 @@
 #ifndef OPTION_BYTES_H
 #define OPTION_BYTES_H
 
+#include <stdint.h>
 #include <stdio.h>
+
 #include <stlink.h>
 
-int stlink_read_option_bytes32(stlink_t *sl, uint32_t* option_byte);
-int stlink_read_option_bytes_boot_add32(stlink_t *sl, uint32_t* option_byte);
-int stlink_read_option_control_register32(stlink_t *sl, uint32_t* option_byte);
-int stlink_read_option_control_register1_32(stlink_t *sl, uint32_t* option_byte);
+int32_t stlink_read_option_bytes32(stlink_t *sl, uint32_t* option_byte);
+int32_t stlink_read_option_bytes_boot_add32(stlink_t *sl, uint32_t* option_byte);
+int32_t stlink_read_option_control_register32(stlink_t *sl, uint32_t* option_byte);
+int32_t stlink_read_option_control_register1_32(stlink_t *sl, uint32_t* option_byte);
 
-int stlink_write_option_bytes32(stlink_t *sl, uint32_t option_byte);
-int stlink_write_option_bytes_boot_add32(stlink_t *sl, uint32_t option_bytes_boot_add);
-int stlink_write_option_control_register32(stlink_t *sl, uint32_t option_cr);
-int stlink_write_option_control_register1_32(stlink_t *sl, uint32_t option_cr1);
+int32_t stlink_write_option_bytes32(stlink_t *sl, uint32_t option_byte);
+int32_t stlink_write_option_bytes_boot_add32(stlink_t *sl, uint32_t option_bytes_boot_add);
+int32_t stlink_write_option_control_register32(stlink_t *sl, uint32_t option_cr);
+int32_t stlink_write_option_control_register1_32(stlink_t *sl, uint32_t option_cr1);
 
-int stlink_write_option_bytes(stlink_t *sl, stm32_addr_t addr, uint8_t* base, uint32_t len);
-int stlink_fwrite_option_bytes(stlink_t *sl, const char* path, stm32_addr_t addr);
+int32_t stlink_write_option_bytes(stlink_t *sl, stm32_addr_t addr, uint8_t* base, uint32_t len);
+int32_t stlink_fwrite_option_bytes(stlink_t *sl, const char* path, stm32_addr_t addr);
 
 #endif // OPTION_BYTES_H
\ No newline at end of file
diff --git a/src/stlink-lib/read_write.c b/src/stlink-lib/read_write.c
index efaa5a25f..f9c060bb2 100644
--- a/src/stlink-lib/read_write.c
+++ b/src/stlink-lib/read_write.c
@@ -1,5 +1,7 @@
+#include <stdint.h>
 #include <stdio.h>
 #include <string.h>
+
 #include <stlink.h>
 
 // Endianness
@@ -18,17 +20,17 @@ void write_uint16(unsigned char *buf, uint16_t ui) {
   buf[1] = (uint8_t)(ui >> 8);
 }
 
-uint32_t read_uint32(const unsigned char *c, const int pt) {
+uint32_t read_uint32(const unsigned char *c, const int32_t pt) {
   return ((uint32_t)c[pt]) | ((uint32_t)c[pt + 1] << 8) |
          ((uint32_t)c[pt + 2] << 16) | ((uint32_t)c[pt + 3] << 24);
 }
 
-uint16_t read_uint16(const unsigned char *c, const int pt) {
+uint16_t read_uint16(const unsigned char *c, const int32_t pt) {
   return ((uint16_t)c[pt]) | ((uint16_t)c[pt + 1] << 8);
 }
 
-int stlink_read_debug32(stlink_t *sl, uint32_t addr, uint32_t *data) {
-  int ret;
+int32_t stlink_read_debug32(stlink_t *sl, uint32_t addr, uint32_t *data) {
+  int32_t ret;
 
   ret = sl->backend->read_debug32(sl, addr, data);
   if (!ret)
@@ -37,12 +39,12 @@ int stlink_read_debug32(stlink_t *sl, uint32_t addr, uint32_t *data) {
   return (ret);
 }
 
-int stlink_write_debug32(stlink_t *sl, uint32_t addr, uint32_t data) {
+int32_t stlink_write_debug32(stlink_t *sl, uint32_t addr, uint32_t data) {
   DLOG("*** stlink_write_debug32 %#010x to %#010x\n", data, addr);
   return sl->backend->write_debug32(sl, addr, data);
 }
 
-int stlink_write_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
+int32_t stlink_write_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
   DLOG("*** stlink_write_mem32 %u bytes to %#x\n", len, addr);
 
   if (len % 4 != 0) {
@@ -53,7 +55,7 @@ int stlink_write_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
   return (sl->backend->write_mem32(sl, addr, len));
 }
 
-int stlink_read_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
+int32_t stlink_read_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
   DLOG("*** stlink_read_mem32 ***\n");
 
   if (len % 4 != 0) { // !!! never ever: fw gives just wrong values
@@ -64,27 +66,27 @@ int stlink_read_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
   return (sl->backend->read_mem32(sl, addr, len));
 }
 
-int stlink_write_mem8(stlink_t *sl, uint32_t addr, uint16_t len) {
+int32_t stlink_write_mem8(stlink_t *sl, uint32_t addr, uint16_t len) {
   DLOG("*** stlink_write_mem8 ***\n");
   return (sl->backend->write_mem8(sl, addr, len));
 }
 
-int stlink_read_all_regs(stlink_t *sl, struct stlink_reg *regp) {
+int32_t stlink_read_all_regs(stlink_t *sl, struct stlink_reg *regp) {
   DLOG("*** stlink_read_all_regs ***\n");
   return (sl->backend->read_all_regs(sl, regp));
 }
 
-int stlink_read_all_unsupported_regs(stlink_t *sl, struct stlink_reg *regp) {
+int32_t stlink_read_all_unsupported_regs(stlink_t *sl, struct stlink_reg *regp) {
   DLOG("*** stlink_read_all_unsupported_regs ***\n");
   return (sl->backend->read_all_unsupported_regs(sl, regp));
 }
 
-int stlink_write_reg(stlink_t *sl, uint32_t reg, int idx) {
+int32_t stlink_write_reg(stlink_t *sl, uint32_t reg, int32_t idx) {
   DLOG("*** stlink_write_reg\n");
   return (sl->backend->write_reg(sl, reg, idx));
 }
 
-int stlink_read_reg(stlink_t *sl, int r_idx, struct stlink_reg *regp) {
+int32_t stlink_read_reg(stlink_t *sl, int32_t r_idx, struct stlink_reg *regp) {
   DLOG("*** stlink_read_reg\n");
   DLOG(" (%d) ***\n", r_idx);
 
@@ -96,9 +98,9 @@ int stlink_read_reg(stlink_t *sl, int r_idx, struct stlink_reg *regp) {
   return (sl->backend->read_reg(sl, r_idx, regp));
 }
 
-int stlink_read_unsupported_reg(stlink_t *sl, int r_idx,
+int32_t stlink_read_unsupported_reg(stlink_t *sl, int32_t r_idx,
                                 struct stlink_reg *regp) {
-  int r_convert;
+  int32_t r_convert;
 
   DLOG("*** stlink_read_unsupported_reg\n");
   DLOG(" (%d) ***\n", r_idx);
@@ -119,9 +121,9 @@ int stlink_read_unsupported_reg(stlink_t *sl, int r_idx,
   return (sl->backend->read_unsupported_reg(sl, r_convert, regp));
 }
 
-int stlink_write_unsupported_reg(stlink_t *sl, uint32_t val, int r_idx,
+int32_t stlink_write_unsupported_reg(stlink_t *sl, uint32_t val, int32_t r_idx,
                                  struct stlink_reg *regp) {
-  int r_convert;
+  int32_t r_convert;
 
   DLOG("*** stlink_write_unsupported_reg\n");
   DLOG(" (%d) ***\n", r_idx);
diff --git a/src/stlink-lib/sg.c b/src/stlink-lib/sg.c
index feab40c13..c0f79c7cf 100644
--- a/src/stlink-lib/sg.c
+++ b/src/stlink-lib/sg.c
@@ -75,10 +75,12 @@
  */
 
 #define __USE_GNU
+
 #include <assert.h>
+#include <stdint.h>
 #include <stdio.h>
-#include <string.h>
 #include <stdlib.h>
+#include <string.h>
 #include <sys/types.h>
 
 #include <stlink.h>
@@ -109,12 +111,12 @@ void _stlink_sg_close(stlink_t *sl) {
     }
 }
 
-static int get_usb_mass_storage_status(libusb_device_handle *handle, uint8_t endpoint, uint32_t *tag) {
+static int32_t get_usb_mass_storage_status(libusb_device_handle *handle, uint8_t endpoint, uint32_t *tag) {
     unsigned char csw[13];
     memset(csw, 0, sizeof(csw));
-    int transferred;
-    int ret;
-    int try = 0;
+    int32_t transferred;
+    int32_t ret;
+    int32_t try = 0;
 
     do {
         ret = libusb_bulk_transfer(handle, endpoint, (unsigned char *)&csw, sizeof(csw),
@@ -150,13 +152,13 @@ static int get_usb_mass_storage_status(libusb_device_handle *handle, uint8_t end
     return(rstatus);
 }
 
-static int dump_CDB_command(uint8_t *cdb, uint8_t cdb_len) {
+static int32_t dump_CDB_command(uint8_t *cdb, uint8_t cdb_len) {
     char dbugblah[100];
     char *dbugp = dbugblah;
     dbugp += sprintf(dbugp, "Sending CDB [");
 
     for (uint8_t i = 0; i < cdb_len; i++) {
-        dbugp += sprintf(dbugp, " %#02x", (unsigned int)cdb[i]);
+        dbugp += sprintf(dbugp, " %#02x", (uint32_t)cdb[i]);
     }
 
     sprintf(dbugp, "]\n");
@@ -175,7 +177,7 @@ static int dump_CDB_command(uint8_t *cdb, uint8_t cdb_len) {
  * @param expected_rx_size
  * @return
  */
-int send_usb_mass_storage_command(libusb_device_handle *handle, uint8_t endpoint_out,
+int32_t send_usb_mass_storage_command(libusb_device_handle *handle, uint8_t endpoint_out,
                                   uint8_t *cdb, uint8_t cdb_length,
                                   uint8_t lun, uint8_t flags, uint32_t expected_rx_size) {
     DLOG("Sending usb m-s cmd: cdblen:%d, rxsize=%d\n", cdb_length, expected_rx_size);
@@ -185,10 +187,10 @@ int send_usb_mass_storage_command(libusb_device_handle *handle, uint8_t endpoint
 
     if (tag == 0) { tag = 1; }
 
-    int try = 0;
-    int ret = 0;
-    int real_transferred;
-    int i = 0;
+    int32_t try = 0;
+    int32_t ret = 0;
+    int32_t real_transferred;
+    int32_t i = 0;
 
     uint8_t c_buf[STLINK_SG_SIZE];
     // tag is allegedly ignored... TODO - verify
@@ -209,7 +211,7 @@ int send_usb_mass_storage_command(libusb_device_handle *handle, uint8_t endpoint
     assert(cdb_length <= CDB_SL);
     memcpy(&(c_buf[i]), cdb, cdb_length);
 
-    int sending_length = STLINK_SG_SIZE;
+    int32_t sending_length = STLINK_SG_SIZE;
 
     // send....
     do {
@@ -254,9 +256,9 @@ static void get_sense(libusb_device_handle *handle, uint8_t endpoint_in, uint8_t
     }
 
     unsigned char sense[REQUEST_SENSE_LENGTH];
-    int transferred;
-    int ret;
-    int try = 0;
+    int32_t transferred;
+    int32_t ret;
+    int32_t try = 0;
 
     do {
         ret = libusb_bulk_transfer(handle, endpoint_in, sense, sizeof(sense),
@@ -273,11 +275,11 @@ static void get_sense(libusb_device_handle *handle, uint8_t endpoint_in, uint8_t
     }
 
     if (transferred != sizeof(sense)) {
-        WLOG("received unexpected amount of sense: %d != %u\n", transferred, (unsigned)sizeof(sense));
+        WLOG("received unexpected amount of sense: %d != %u\n", transferred, (uint32_t)sizeof(sense));
     }
 
     uint32_t received_tag;
-    int status = get_usb_mass_storage_status(handle, endpoint_in, &received_tag);
+    int32_t status = get_usb_mass_storage_status(handle, endpoint_in, &received_tag);
 
     if (status != 0) {
         WLOG("receiving sense failed with status: %02x\n", status);
@@ -301,11 +303,11 @@ static void get_sense(libusb_device_handle *handle, uint8_t endpoint_in, uint8_t
  * @param length how much to send
  * @return number of bytes actually sent, or -1 for failures.
  */
-int send_usb_data_only(libusb_device_handle *handle, unsigned char endpoint_out,
-                       unsigned char endpoint_in, unsigned char *cbuf, unsigned int length) {
-    int ret;
-    int real_transferred;
-    int try = 0;
+int32_t send_usb_data_only(libusb_device_handle *handle, unsigned char endpoint_out,
+                       unsigned char endpoint_in, unsigned char *cbuf, uint32_t length) {
+    int32_t ret;
+    int32_t real_transferred;
+    int32_t try = 0;
 
     do {
         ret = libusb_bulk_transfer(handle, endpoint_out, cbuf, length,
@@ -324,7 +326,7 @@ int send_usb_data_only(libusb_device_handle *handle, unsigned char endpoint_out,
     // now, swallow up the status, so that things behave nicely...
     uint32_t received_tag;
     // -ve is for my errors, 0 is good, +ve is libusb sense status bytes
-    int status = get_usb_mass_storage_status(handle, endpoint_in, &received_tag);
+    int32_t status = get_usb_mass_storage_status(handle, endpoint_in, &received_tag);
 
     if (status < 0) {
         WLOG("receiving status failed: %d\n", status);
@@ -343,7 +345,7 @@ int send_usb_data_only(libusb_device_handle *handle, unsigned char endpoint_out,
     return(real_transferred);
 }
 
-int stlink_q(stlink_t *sl) {
+int32_t stlink_q(stlink_t *sl) {
     struct stlink_libsg* sg = sl->backend_data;
     // uint8_t cdb_len = 6;  // FIXME varies!!!
     uint8_t cdb_len = 10;  // FIXME varies!!!
@@ -355,10 +357,10 @@ int stlink_q(stlink_t *sl) {
 
     // now wait for our response...
     // length copied from stlink-usb...
-    int rx_length = sl->q_len;
-    int try = 0;
-    int real_transferred;
-    int ret;
+    int32_t rx_length = sl->q_len;
+    int32_t try = 0;
+    int32_t real_transferred;
+    int32_t ret;
 
     if (rx_length > 0) {
         do {
@@ -382,7 +384,7 @@ int stlink_q(stlink_t *sl) {
 
     uint32_t received_tag;
     // -ve is for my errors, 0 is good, +ve is libusb sense status bytes
-    int status = get_usb_mass_storage_status(sg->usb_handle, sg->ep_rep, &received_tag);
+    int32_t status = get_usb_mass_storage_status(sg->usb_handle, sg->ep_rep, &received_tag);
 
     if (status < 0) {
         WLOG("receiving status failed: %d\n", status);
@@ -428,7 +430,7 @@ void stlink_stat(stlink_t *stl, char *txt) {
     }
 }
 
-int _stlink_sg_version(stlink_t *stl) {
+int32_t _stlink_sg_version(stlink_t *stl) {
     struct stlink_libsg *sl = stl->backend_data;
     clear_cdb(sl);
     sl->cdb_cmd_blk[0] = STLINK_GET_VERSION;
@@ -440,7 +442,7 @@ int _stlink_sg_version(stlink_t *stl) {
 // Get stlink mode:
 // STLINK_DEV_DFU_MODE || STLINK_DEV_MASS_MODE || STLINK_DEV_DEBUG_MODE
 // usb dfu             || usb mass             || jtag or swd
-int _stlink_sg_current_mode(stlink_t *stl) {
+int32_t _stlink_sg_current_mode(stlink_t *stl) {
     struct stlink_libsg *sl = stl->backend_data;
     clear_cdb(sl);
     sl->cdb_cmd_blk[0] = STLINK_GET_CURRENT_MODE;
@@ -453,7 +455,7 @@ int _stlink_sg_current_mode(stlink_t *stl) {
 }
 
 // exit the mass mode and enter the swd debug mode.
-int _stlink_sg_enter_swd_mode(stlink_t *sl) {
+int32_t _stlink_sg_enter_swd_mode(stlink_t *sl) {
     struct stlink_libsg *sg = sl->backend_data;
     clear_cdb(sg);
     sg->cdb_cmd_blk[1] = STLINK_DEBUG_APIV1_ENTER;
@@ -464,7 +466,7 @@ int _stlink_sg_enter_swd_mode(stlink_t *sl) {
 
 // exit the mass mode and enter the jtag debug mode.
 // (jtag is disabled in the discovery's stlink firmware)
-int _stlink_sg_enter_jtag_mode(stlink_t *sl) {
+int32_t _stlink_sg_enter_jtag_mode(stlink_t *sl) {
     struct stlink_libsg *sg = sl->backend_data;
     DLOG("\n*** stlink_enter_jtag_mode ***\n");
     clear_cdb(sg);
@@ -476,7 +478,7 @@ int _stlink_sg_enter_jtag_mode(stlink_t *sl) {
 
 // XXX kernel driver performs reset, the device temporally disappears
 // Suspect this is no longer the case when we have ignore on? RECHECK
-int _stlink_sg_exit_dfu_mode(stlink_t *sl) {
+int32_t _stlink_sg_exit_dfu_mode(stlink_t *sl) {
     struct stlink_libsg *sg = sl->backend_data;
     DLOG("\n*** stlink_exit_dfu_mode ***\n");
     clear_cdb(sg);
@@ -529,9 +531,9 @@ int _stlink_sg_exit_dfu_mode(stlink_t *sl) {
      */
 }
 
-int _stlink_sg_core_id(stlink_t *sl) {
+int32_t _stlink_sg_core_id(stlink_t *sl) {
     struct stlink_libsg *sg = sl->backend_data;
-    int ret;
+    int32_t ret;
     clear_cdb(sg);
     sg->cdb_cmd_blk[1] = STLINK_DEBUG_READCOREID;
     sl->q_len = 4;
@@ -545,7 +547,7 @@ int _stlink_sg_core_id(stlink_t *sl) {
 }
 
 // arm-core reset -> halted state.
-int _stlink_sg_reset(stlink_t *sl) {
+int32_t _stlink_sg_reset(stlink_t *sl) {
     struct stlink_libsg *sg = sl->backend_data;
     clear_cdb(sg);
     sg->cdb_cmd_blk[1] = STLINK_DEBUG_APIV1_RESETSYS;
@@ -566,7 +568,7 @@ int _stlink_sg_reset(stlink_t *sl) {
 }
 
 // arm-core reset -> halted state.
-int _stlink_sg_jtag_reset(stlink_t *sl, int value) {
+int32_t _stlink_sg_jtag_reset(stlink_t *sl, int32_t value) {
     struct stlink_libsg *sg = sl->backend_data;
     clear_cdb(sg);
     sg->cdb_cmd_blk[1] = STLINK_DEBUG_APIV2_DRIVE_NRST;
@@ -582,7 +584,7 @@ int _stlink_sg_jtag_reset(stlink_t *sl, int value) {
 }
 
 // arm-core status: halted or running.
-int _stlink_sg_status(stlink_t *sl) {
+int32_t _stlink_sg_status(stlink_t *sl) {
     struct stlink_libsg *sg = sl->backend_data;
     clear_cdb(sg);
     sg->cdb_cmd_blk[1] = STLINK_DEBUG_GETSTATUS;
@@ -592,7 +594,7 @@ int _stlink_sg_status(stlink_t *sl) {
 }
 
 // force the core into the debug mode -> halted state.
-int _stlink_sg_force_debug(stlink_t *sl) {
+int32_t _stlink_sg_force_debug(stlink_t *sl) {
     struct stlink_libsg *sg = sl->backend_data;
     clear_cdb(sg);
     sg->cdb_cmd_blk[1] = STLINK_DEBUG_FORCEDEBUG;
@@ -606,7 +608,7 @@ int _stlink_sg_force_debug(stlink_t *sl) {
 }
 
 // read all arm-core registers.
-int _stlink_sg_read_all_regs(stlink_t *sl, struct stlink_reg *regp) {
+int32_t _stlink_sg_read_all_regs(stlink_t *sl, struct stlink_reg *regp) {
     struct stlink_libsg *sg = sl->backend_data;
 
     clear_cdb(sg);
@@ -622,7 +624,7 @@ int _stlink_sg_read_all_regs(stlink_t *sl, struct stlink_reg *regp) {
 
     // 0-3 | 4-7 | ... | 60-63 | 64-67 | 68-71   | 72-75      | 76-79 | 80-83
     // r0  | r1  | ... | r15   | xpsr  | main_sp | process_sp | rw    | rw2
-    for (int i = 0; i < 16; i++) {
+    for (int32_t i = 0; i < 16; i++) {
         regp->r[i] = read_uint32(sl->q_buf, 4 * i);
 
         if (sl->verbose > 1) { DLOG("r%2d = 0x%08x\n", i, regp->r[i]); }
@@ -649,7 +651,7 @@ int _stlink_sg_read_all_regs(stlink_t *sl, struct stlink_reg *regp) {
 //  0  |  1  | ... |  15   |  16   |   17    |   18       |  19   |  20
 // r0  | r1  | ... | r15   | xpsr  | main_sp | process_sp | rw    | rw2
 
-int _stlink_sg_read_reg(stlink_t *sl, int r_idx, struct stlink_reg *regp) {
+int32_t _stlink_sg_read_reg(stlink_t *sl, int32_t r_idx, struct stlink_reg *regp) {
     struct stlink_libsg *sg = sl->backend_data;
     clear_cdb(sg);
     sg->cdb_cmd_blk[1] = STLINK_DEBUG_APIV1_READREG;
@@ -694,7 +696,7 @@ int _stlink_sg_read_reg(stlink_t *sl, int r_idx, struct stlink_reg *regp) {
 //  0  |  1  | ... |  15   |  16   |   17    |   18       |  19   |  20
 // r0  | r1  | ... | r15   | xpsr  | main_sp | process_sp | rw    | rw2
 
-int _stlink_sg_write_reg(stlink_t *sl, uint32_t reg, int idx) {
+int32_t _stlink_sg_write_reg(stlink_t *sl, uint32_t reg, int32_t idx) {
     struct stlink_libsg *sg = sl->backend_data;
     clear_cdb(sg);
     sg->cdb_cmd_blk[1] = STLINK_DEBUG_APIV1_WRITEREG;
@@ -730,7 +732,7 @@ void stlink_write_dreg(stlink_t *sl, uint32_t reg, uint32_t addr) {
 }
 
 // force the core exit the debug mode.
-int _stlink_sg_run(stlink_t *sl, enum run_type type) {
+int32_t _stlink_sg_run(stlink_t *sl, enum run_type type) {
     struct stlink_libsg *sg = sl->backend_data;
     (void)(type); //unused
     clear_cdb(sg);
@@ -746,7 +748,7 @@ int _stlink_sg_run(stlink_t *sl, enum run_type type) {
 }
 
 // step the arm-core.
-int _stlink_sg_step(stlink_t *sl) {
+int32_t _stlink_sg_step(stlink_t *sl) {
     struct stlink_libsg *sg = sl->backend_data;
     clear_cdb(sg);
     sg->cdb_cmd_blk[1] = STLINK_DEBUG_STEPCORE;
@@ -761,7 +763,7 @@ int _stlink_sg_step(stlink_t *sl) {
 
 // TODO: test and make delegate!
 // see Cortex-M3 Technical Reference Manual
-void stlink_set_hw_bp(stlink_t *sl, int fp_nr, uint32_t addr, int fp) {
+void stlink_set_hw_bp(stlink_t *sl, int32_t fp_nr, uint32_t addr, int32_t fp) {
     DLOG("\n*** stlink_set_hw_bp ***\n");
     struct stlink_libsg *sg = sl->backend_data;
     clear_cdb(sg);
@@ -779,7 +781,7 @@ void stlink_set_hw_bp(stlink_t *sl, int fp_nr, uint32_t addr, int fp) {
 }
 
 // TODO: test and make delegate!
-void stlink_clr_hw_bp(stlink_t *sl, int fp_nr) {
+void stlink_clr_hw_bp(stlink_t *sl, int32_t fp_nr) {
     struct stlink_libsg *sg = sl->backend_data;
     DLOG("\n*** stlink_clr_hw_bp ***\n");
     clear_cdb(sg);
@@ -792,7 +794,7 @@ void stlink_clr_hw_bp(stlink_t *sl, int fp_nr) {
 }
 
 // read a "len" bytes to the sl->q_buf from the memory, max 6kB (6144 bytes)
-int _stlink_sg_read_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
+int32_t _stlink_sg_read_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
     struct stlink_libsg *sg = sl->backend_data;
     clear_cdb(sg);
     sg->cdb_cmd_blk[1] = STLINK_DEBUG_READMEM_32BIT;
@@ -816,9 +818,9 @@ int _stlink_sg_read_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
 }
 
 // write a "len" bytes from the sl->q_buf to the memory, max 64 Bytes.
-int _stlink_sg_write_mem8(stlink_t *sl, uint32_t addr, uint16_t len) {
+int32_t _stlink_sg_write_mem8(stlink_t *sl, uint32_t addr, uint16_t len) {
     struct stlink_libsg *sg = sl->backend_data;
-    int ret;
+    int32_t ret;
 
     clear_cdb(sg);
     sg->cdb_cmd_blk[1] = STLINK_DEBUG_WRITEMEM_8BIT;
@@ -844,9 +846,9 @@ int _stlink_sg_write_mem8(stlink_t *sl, uint32_t addr, uint16_t len) {
 }
 
 // write a "len" bytes from the sl->q_buf to the memory, max Q_BUF_LEN bytes.
-int _stlink_sg_write_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
+int32_t _stlink_sg_write_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
     struct stlink_libsg *sg = sl->backend_data;
-    int ret;
+    int32_t ret;
 
     clear_cdb(sg);
     sg->cdb_cmd_blk[1] = STLINK_DEBUG_WRITEMEM_32BIT;
@@ -872,7 +874,7 @@ int _stlink_sg_write_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
 }
 
 // write one DWORD data to memory
-int _stlink_sg_write_debug32(stlink_t *sl, uint32_t addr, uint32_t data) {
+int32_t _stlink_sg_write_debug32(stlink_t *sl, uint32_t addr, uint32_t data) {
     struct stlink_libsg *sg = sl->backend_data;
     clear_cdb(sg);
     sg->cdb_cmd_blk[1] = STLINK_DEBUG_APIV2_WRITEDEBUGREG;
@@ -884,7 +886,7 @@ int _stlink_sg_write_debug32(stlink_t *sl, uint32_t addr, uint32_t data) {
 }
 
 // read one DWORD data from memory
-int _stlink_sg_read_debug32(stlink_t *sl, uint32_t addr, uint32_t *data) {
+int32_t _stlink_sg_read_debug32(stlink_t *sl, uint32_t addr, uint32_t *data) {
     struct stlink_libsg *sg = sl->backend_data;
     clear_cdb(sg);
     sg->cdb_cmd_blk[1] = STLINK_DEBUG_APIV2_READDEBUGREG;
@@ -899,7 +901,7 @@ int _stlink_sg_read_debug32(stlink_t *sl, uint32_t addr, uint32_t *data) {
 }
 
 // exit the jtag or swd mode and enter the mass mode.
-int _stlink_sg_exit_debug_mode(stlink_t *stl) {
+int32_t _stlink_sg_exit_debug_mode(stlink_t *stl) {
     if (stl) {
         struct stlink_libsg* sl = stl->backend_data;
         clear_cdb(sl);
@@ -950,7 +952,7 @@ static stlink_backend_t _stlink_sg_backend = {
     NULL,                   // trace_read
 };
 
-static stlink_t* stlink_open(const int verbose) {
+static stlink_t* stlink_open(const int32_t verbose) {
     stlink_t *sl = malloc(sizeof(stlink_t));
     struct stlink_libsg *slsg = malloc(sizeof(struct stlink_libsg));
 
@@ -993,7 +995,7 @@ static stlink_t* stlink_open(const int verbose) {
     // TODO: Could read the interface config descriptor, and assert lots of the assumptions
     // assumption: numInterfaces is always 1...
     if (libusb_kernel_driver_active(slsg->usb_handle, 0) == 1) {
-        int r = libusb_detach_kernel_driver(slsg->usb_handle, 0);
+        int32_t r = libusb_detach_kernel_driver(slsg->usb_handle, 0);
 
         if (r < 0) {
             WLOG("libusb_detach_kernel_driver(() error %s\n", strerror(-r));
@@ -1007,7 +1009,7 @@ static stlink_t* stlink_open(const int verbose) {
         DLOG("Kernel driver was successfully detached\n");
     }
 
-    int config;
+    int32_t config;
 
     if (libusb_get_configuration(slsg->usb_handle, &config)) {
         /* this may fail for a previous configured device */
@@ -1062,7 +1064,7 @@ static stlink_t* stlink_open(const int verbose) {
 }
 
 
-stlink_t* stlink_v1_open_inner(const int verbose) {
+stlink_t* stlink_v1_open_inner(const int32_t verbose) {
     ugly_init(verbose);
     stlink_t *sl = stlink_open(verbose);
 
@@ -1105,7 +1107,7 @@ stlink_t* stlink_v1_open_inner(const int verbose) {
     return(sl);
 }
 
-stlink_t* stlink_v1_open(const int verbose, int reset) {
+stlink_t* stlink_v1_open(const int32_t verbose, int32_t reset) {
     stlink_t *sl = stlink_v1_open_inner(verbose);
 
     if (sl == NULL) { return(NULL); }
diff --git a/src/stlink-lib/sg.h b/src/stlink-lib/sg.h
index 5ba809f59..d4792c49a 100644
--- a/src/stlink-lib/sg.h
+++ b/src/stlink-lib/sg.h
@@ -6,8 +6,10 @@
 #ifndef SG_H
 #define SG_H
 
+#include <stdint.h>
+
 #include <stlink.h>
-#include <libusb_settings.h>
+#include "libusb_settings.h"
 
 /* Device access */
 #define RDWR        0
@@ -35,15 +37,15 @@
 struct stlink_libsg {
     libusb_context* libusb_ctx;
     libusb_device_handle *usb_handle;
-    unsigned ep_rep;
-    unsigned ep_req;
+    uint32_t ep_rep;
+    uint32_t ep_req;
 
-    int sg_fd;
-    int do_scsi_pt_err;
+    int32_t sg_fd;
+    int32_t do_scsi_pt_err;
 
     unsigned char cdb_cmd_blk[CDB_SL];
 
-    int q_data_dir; // Q_DATA_IN, Q_DATA_OUT
+    int32_t q_data_dir; // Q_DATA_IN, Q_DATA_OUT
     // the start of the query data in the device memory space
     uint32_t q_addr;
 
@@ -54,6 +56,6 @@ struct stlink_libsg {
     struct stlink_reg reg;
 };
 
-stlink_t* stlink_v1_open(const int verbose, int reset);
+stlink_t* stlink_v1_open(const int32_t verbose, int32_t reset);
 
 #endif // SG_H
diff --git a/src/stlink-lib/usb.c b/src/stlink-lib/usb.c
index 2e99e82be..d404c2e94 100644
--- a/src/stlink-lib/usb.c
+++ b/src/stlink-lib/usb.c
@@ -1,8 +1,8 @@
+#include <limits.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <stdint.h>
-#include <limits.h>
 
 #if !defined(_MSC_VER)
 #include <sys/time.h>
@@ -17,7 +17,7 @@
 #endif
 
 #include <stlink.h>
-#include <helper.h>
+#include "helper.h"
 #include "usb.h"
 
 enum SCSI_Generic_Direction {SG_DXFER_TO_DEV = 0, SG_DXFER_FROM_DEV = 0x80};
@@ -26,11 +26,11 @@ static inline uint32_t le_to_h_u32(const uint8_t* buf) {
     return((uint32_t)((uint32_t)buf[0] | (uint32_t)buf[1] << 8 | (uint32_t)buf[2] << 16 | (uint32_t)buf[3] << 24));
 }
 
-static int _stlink_match_speed_map(const uint32_t *map, unsigned int map_size, uint32_t khz) {
-    unsigned int i;
-    int speed_index = -1;
-    int speed_diff = INT_MAX;
-    int last_valid_speed = -1;
+static int32_t _stlink_match_speed_map(const uint32_t *map, uint32_t map_size, uint32_t khz) {
+    uint32_t i;
+    int32_t speed_index = -1;
+    int32_t speed_diff = INT_MAX;
+    int32_t last_valid_speed = -1;
     bool match = true;
 
     for (i = 0; i < map_size; i++) {
@@ -42,7 +42,7 @@ static int _stlink_match_speed_map(const uint32_t *map, unsigned int map_size, u
             speed_index = i;
             break;
         } else {
-            int current_diff = khz - map[i];
+            int32_t current_diff = khz - map[i];
             // get abs value for comparison
             current_diff = (current_diff > 0) ? current_diff : -current_diff;
 
@@ -83,26 +83,26 @@ void _stlink_usb_close(stlink_t* sl) {
     }
 }
 
-ssize_t send_recv(struct stlink_libusb* handle, int terminate,
+ssize_t send_recv(struct stlink_libusb* handle, int32_t terminate,
                   unsigned char* txbuf, size_t txsize, unsigned char* rxbuf, 
-                  size_t rxsize, int check_error, const char *cmd) {
+                  size_t rxsize, int32_t check_error, const char *cmd) {
     // Note: txbuf and rxbuf can point to the same area
-    int res, t, retry = 0;
+    int32_t res, t, retry = 0;
 
     while (1) {
         res = 0;
-        t = libusb_bulk_transfer(handle->usb_handle, handle->ep_req, txbuf, (int)txsize, &res, 3000);
+        t = libusb_bulk_transfer(handle->usb_handle, handle->ep_req, txbuf, (int32_t)txsize, &res, 3000);
 
         if (t) {
             ELOG("%s send request failed: %s\n", cmd, libusb_error_name(t));
             return(-1);
         } else if ((size_t)res != txsize) {
             ELOG("%s send request wrote %u bytes, instead of %u\n",
-                   cmd, (unsigned int)res, (unsigned int)txsize);
+                   cmd, (uint32_t)res, (uint32_t)txsize);
         }
 
         if (rxsize != 0) {
-            t = libusb_bulk_transfer(handle->usb_handle, handle->ep_rep, rxbuf, (int)rxsize, &res, 3000);
+            t = libusb_bulk_transfer(handle->usb_handle, handle->ep_rep, rxbuf, (int32_t)rxsize, &res, 3000);
 
             if (t) {
                 ELOG("%s read reply failed: %s\n", cmd, libusb_error_name(t));
@@ -116,7 +116,7 @@ ssize_t send_recv(struct stlink_libusb* handle, int terminate,
                 case STLINK_DEBUG_ERR_AP_WAIT:
                 case STLINK_DEBUG_ERR_DP_WAIT:
                     if (check_error == CMD_CHECK_RETRY && retry < 3) {
-                        unsigned int delay_us = (1<<retry) * 1000;
+                        uint32_t delay_us = (1<<retry) * 1000;
                         DLOG("%s wait error (0x%02X), delaying %u us and retry\n", cmd, rxbuf[0], delay_us);
                         usleep(delay_us);
                         retry++;
@@ -137,7 +137,7 @@ ssize_t send_recv(struct stlink_libusb* handle, int terminate,
                 return(-1);
             }
 
-            if (check_error == CMD_CHECK_REP_LEN && res != (int)rxsize) {
+            if (check_error == CMD_CHECK_REP_LEN && res != (int32_t)rxsize) {
                 ELOG("%s wrong reply length\n", cmd);
                 res = -1;
             }
@@ -161,17 +161,17 @@ ssize_t send_recv(struct stlink_libusb* handle, int terminate,
     }
 }
 
-static inline int send_only(struct stlink_libusb* handle, int terminate,
+static inline int32_t send_only(struct stlink_libusb* handle, int32_t terminate,
                             unsigned char* txbuf, size_t txsize,
                             const char *cmd) {
-    return((int)send_recv(handle, terminate, txbuf, txsize, NULL, 0, CMD_CHECK_NO, cmd));
+    return((int32_t)send_recv(handle, terminate, txbuf, txsize, NULL, 0, CMD_CHECK_NO, cmd));
 }
 
 
-static int fill_command(stlink_t * sl, enum SCSI_Generic_Direction dir, uint32_t len) {
+static int32_t fill_command(stlink_t * sl, enum SCSI_Generic_Direction dir, uint32_t len) {
     struct stlink_libusb * const slu = sl->backend_data;
     unsigned char* const cmd = sl->c_buf;
-    int i = 0;
+    int32_t i = 0;
     memset(cmd, 0, sizeof(sl->c_buf));
 
     if (slu->protocoll == 1) {
@@ -189,13 +189,13 @@ static int fill_command(stlink_t * sl, enum SCSI_Generic_Direction dir, uint32_t
     return(i);
 }
 
-int _stlink_usb_version(stlink_t *sl) {
+int32_t _stlink_usb_version(stlink_t *sl) {
     struct stlink_libusb * const slu = sl->backend_data;
     unsigned char* const data = sl->q_buf;
     unsigned char* const cmd  = sl->c_buf;
     ssize_t size;
     uint32_t rep_len;
-    int i;
+    int32_t i;
 
     if (sl->version.stlink_v == 3) {
         // STLINK-V3 version is determined by another command 
@@ -219,9 +219,9 @@ int32_t _stlink_usb_target_voltage(stlink_t *sl) {
     unsigned char* const cmd  = sl->c_buf;
     ssize_t size;
     uint32_t rep_len = 8;
-    int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
+    int32_t i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
     uint32_t factor, reading;
-    int voltage;
+    int32_t voltage;
 
     cmd[i++] = STLINK_GET_TARGET_VOLTAGE;
 
@@ -238,14 +238,14 @@ int32_t _stlink_usb_target_voltage(stlink_t *sl) {
     return(voltage);
 }
 
-int _stlink_usb_read_debug32(stlink_t *sl, uint32_t addr, uint32_t *data) {
+int32_t _stlink_usb_read_debug32(stlink_t *sl, uint32_t addr, uint32_t *data) {
     struct stlink_libusb * const slu = sl->backend_data;
     unsigned char* const rdata = sl->q_buf;
     unsigned char* const cmd  = sl->c_buf;
     ssize_t size;
-    const int rep_len = 8;
+    const int32_t rep_len = 8;
 
-    int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
+    int32_t i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
     cmd[i++] = STLINK_DEBUG_COMMAND;
     cmd[i++] = STLINK_DEBUG_APIV2_READDEBUGREG;
     write_uint32(&cmd[i], addr);
@@ -260,14 +260,14 @@ int _stlink_usb_read_debug32(stlink_t *sl, uint32_t addr, uint32_t *data) {
     return(0);
 }
 
-int _stlink_usb_write_debug32(stlink_t *sl, uint32_t addr, uint32_t data) {
+int32_t _stlink_usb_write_debug32(stlink_t *sl, uint32_t addr, uint32_t data) {
     struct stlink_libusb * const slu = sl->backend_data;
     unsigned char* const rdata = sl->q_buf;
     unsigned char* const cmd  = sl->c_buf;
     ssize_t size;
-    const int rep_len = 2;
+    const int32_t rep_len = 2;
 
-    int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
+    int32_t i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
     cmd[i++] = STLINK_DEBUG_COMMAND;
     cmd[i++] = STLINK_DEBUG_APIV2_WRITEDEBUGREG;
     write_uint32(&cmd[i], addr);
@@ -277,13 +277,13 @@ int _stlink_usb_write_debug32(stlink_t *sl, uint32_t addr, uint32_t data) {
     return(size<0?-1:0);
 }
 
-int _stlink_usb_get_rw_status(stlink_t *sl) {
+int32_t _stlink_usb_get_rw_status(stlink_t *sl) {
     if (sl->version.jtag_api == STLINK_JTAG_API_V1) { return(0); }
 
     unsigned char* const rdata = sl->q_buf;
     struct stlink_libusb * const slu = sl->backend_data;
     unsigned char* const cmd  = sl->c_buf;
-    int i;
+    int32_t i;
     int16_t ret = 0;
 
     i = fill_command(sl, SG_DXFER_FROM_DEV, 12);
@@ -300,11 +300,11 @@ int _stlink_usb_get_rw_status(stlink_t *sl) {
     return(ret<0?-1:0);
 }
 
-int _stlink_usb_write_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
+int32_t _stlink_usb_write_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
     struct stlink_libusb * const slu = sl->backend_data;
     unsigned char* const data = sl->q_buf;
     unsigned char* const cmd  = sl->c_buf;
-    int i, ret;
+    int32_t i, ret;
 
     i = fill_command(sl, SG_DXFER_TO_DEV, len);
     cmd[i++] = STLINK_DEBUG_COMMAND;
@@ -322,11 +322,11 @@ int _stlink_usb_write_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
     return(_stlink_usb_get_rw_status(sl));
 }
 
-int _stlink_usb_write_mem8(stlink_t *sl, uint32_t addr, uint16_t len) {
+int32_t _stlink_usb_write_mem8(stlink_t *sl, uint32_t addr, uint16_t len) {
     struct stlink_libusb * const slu = sl->backend_data;
     unsigned char* const data = sl->q_buf;
     unsigned char* const cmd  = sl->c_buf;
-    int i, ret;
+    int32_t i, ret;
 
     if ((sl->version.jtag_api < STLINK_JTAG_API_V3 && len > 64) ||
         (sl->version.jtag_api >= STLINK_JTAG_API_V3 && len > 512)) {
@@ -351,13 +351,13 @@ int _stlink_usb_write_mem8(stlink_t *sl, uint32_t addr, uint16_t len) {
 }
 
 
-int _stlink_usb_current_mode(stlink_t * sl) {
+int32_t _stlink_usb_current_mode(stlink_t * sl) {
     struct stlink_libusb * const slu = sl->backend_data;
     unsigned char* const cmd  = sl->c_buf;
     unsigned char* const data = sl->q_buf;
     ssize_t size;
-    int rep_len = 2;
-    int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
+    int32_t rep_len = 2;
+    int32_t i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
 
     cmd[i++] = STLINK_GET_CURRENT_MODE;
     size = send_recv(slu, 1, cmd,  slu->cmd_len, data, rep_len, CMD_CHECK_NO, "GET_CURRENT_MODE");
@@ -369,13 +369,13 @@ int _stlink_usb_current_mode(stlink_t * sl) {
     return(sl->q_buf[0]);
 }
 
-int _stlink_usb_core_id(stlink_t * sl) {
+int32_t _stlink_usb_core_id(stlink_t * sl) {
     struct stlink_libusb * const slu = sl->backend_data;
     unsigned char* const cmd  = sl->c_buf;
     unsigned char* const data = sl->q_buf;
     ssize_t size;
-    int offset, rep_len = sl->version.jtag_api == STLINK_JTAG_API_V1 ? 4 : 12;
-    int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
+    int32_t offset, rep_len = sl->version.jtag_api == STLINK_JTAG_API_V1 ? 4 : 12;
+    int32_t i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
 
     cmd[i++] = STLINK_DEBUG_COMMAND;
 
@@ -398,8 +398,8 @@ int _stlink_usb_core_id(stlink_t * sl) {
     return(0);
 }
 
-int _stlink_usb_status_v2(stlink_t *sl) {
-    int result;
+int32_t _stlink_usb_status_v2(stlink_t *sl) {
+    int32_t result;
     uint32_t status = 0;
 
     result = _stlink_usb_read_debug32(sl, STLINK_REG_DHCSR, &status);
@@ -420,15 +420,15 @@ int _stlink_usb_status_v2(stlink_t *sl) {
     return(result);
 }
 
-int _stlink_usb_status(stlink_t * sl) {
+int32_t _stlink_usb_status(stlink_t * sl) {
     if (sl->version.jtag_api != STLINK_JTAG_API_V1) { return(_stlink_usb_status_v2(sl)); }
 
     struct stlink_libusb * const slu = sl->backend_data;
     unsigned char* const data = sl->q_buf;
     unsigned char* const cmd  = sl->c_buf;
     ssize_t size;
-    int rep_len = 2;
-    int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
+    int32_t rep_len = 2;
+    int32_t i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
 
     cmd[i++] = STLINK_DEBUG_COMMAND;
     cmd[i++] = STLINK_DEBUG_GETSTATUS;
@@ -449,10 +449,10 @@ int _stlink_usb_status(stlink_t * sl) {
     return(size<0?-1:0);
 }
 
-int _stlink_usb_force_debug(stlink_t *sl) {
+int32_t _stlink_usb_force_debug(stlink_t *sl) {
     struct stlink_libusb *slu = sl->backend_data;
 
-    int res;
+    int32_t res;
 
     if (sl->version.jtag_api != STLINK_JTAG_API_V1) {
         res = _stlink_usb_write_debug32(sl, STLINK_REG_DHCSR, STLINK_REG_DHCSR_DBGKEY | STLINK_REG_DHCSR_C_HALT | STLINK_REG_DHCSR_C_DEBUGEN);
@@ -462,8 +462,8 @@ int _stlink_usb_force_debug(stlink_t *sl) {
     unsigned char* const data = sl->q_buf;
     unsigned char* const cmd  = sl->c_buf;
     ssize_t size;
-    int rep_len = 2;
-    int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
+    int32_t rep_len = 2;
+    int32_t i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
 
     cmd[i++] = STLINK_DEBUG_COMMAND;
     cmd[i++] = STLINK_DEBUG_FORCEDEBUG;
@@ -472,13 +472,13 @@ int _stlink_usb_force_debug(stlink_t *sl) {
     return(size<0?-1:0);
 }
 
-int _stlink_usb_enter_swd_mode(stlink_t * sl) {
+int32_t _stlink_usb_enter_swd_mode(stlink_t * sl) {
     struct stlink_libusb * const slu = sl->backend_data;
     unsigned char* const cmd  = sl->c_buf;
     ssize_t size;
     unsigned char* const data = sl->q_buf;
     const uint32_t rep_len = sl->version.jtag_api == STLINK_JTAG_API_V1 ? 0 : 2;
-    int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
+    int32_t i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
 
     cmd[i++] = STLINK_DEBUG_COMMAND;
     // select correct API-Version for entering SWD mode: V1 API (0x20) or V2 API (0x30).
@@ -489,11 +489,11 @@ int _stlink_usb_enter_swd_mode(stlink_t * sl) {
     return(size<0?-1:0);
 }
 
-int _stlink_usb_exit_dfu_mode(stlink_t* sl) {
+int32_t _stlink_usb_exit_dfu_mode(stlink_t* sl) {
     struct stlink_libusb * const slu = sl->backend_data;
     unsigned char* const cmd = sl->c_buf;
     ssize_t size;
-    int i = fill_command(sl, SG_DXFER_FROM_DEV, 0);
+    int32_t i = fill_command(sl, SG_DXFER_FROM_DEV, 0);
 
     cmd[i++] = STLINK_DFU_COMMAND;
     cmd[i++] = STLINK_DFU_EXIT;
@@ -503,12 +503,12 @@ int _stlink_usb_exit_dfu_mode(stlink_t* sl) {
 }
 
 
-int _stlink_usb_reset(stlink_t * sl) {
+int32_t _stlink_usb_reset(stlink_t * sl) {
     struct stlink_libusb * const slu = sl->backend_data;
     unsigned char* const data = sl->q_buf;
     unsigned char* const cmd = sl->c_buf;
     ssize_t size;
-    int i, rep_len = 2;
+    int32_t i, rep_len = 2;
 
     // send reset command
     i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
@@ -525,13 +525,13 @@ int _stlink_usb_reset(stlink_t * sl) {
     return(size<0?-1:0);
 }
 
-int _stlink_usb_jtag_reset(stlink_t * sl, int value) {
+int32_t _stlink_usb_jtag_reset(stlink_t * sl, int32_t value) {
     struct stlink_libusb * const slu = sl->backend_data;
     unsigned char* const data = sl->q_buf;
     unsigned char* const cmd = sl->c_buf;
     ssize_t size;
-    int rep_len = 2;
-    int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
+    int32_t rep_len = 2;
+    int32_t i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
 
     cmd[i++] = STLINK_DEBUG_COMMAND;
     cmd[i++] = STLINK_DEBUG_APIV2_DRIVE_NRST;
@@ -542,7 +542,7 @@ int _stlink_usb_jtag_reset(stlink_t * sl, int value) {
 }
 
 
-int _stlink_usb_step(stlink_t* sl) {
+int32_t _stlink_usb_step(stlink_t* sl) {
     struct stlink_libusb * const slu = sl->backend_data;
 
     if (sl->version.jtag_api != STLINK_JTAG_API_V1) {
@@ -558,8 +558,8 @@ int _stlink_usb_step(stlink_t* sl) {
     unsigned char* const data = sl->q_buf;
     unsigned char* const cmd = sl->c_buf;
     ssize_t size;
-    int rep_len = 2;
-    int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
+    int32_t rep_len = 2;
+    int32_t i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
 
     cmd[i++] = STLINK_DEBUG_COMMAND;
     cmd[i++] = STLINK_DEBUG_STEPCORE;
@@ -573,10 +573,10 @@ int _stlink_usb_step(stlink_t* sl) {
  * @param sl
  * @param type
  */
-int _stlink_usb_run(stlink_t* sl, enum run_type type) {
+int32_t _stlink_usb_run(stlink_t* sl, enum run_type type) {
     struct stlink_libusb * const slu = sl->backend_data;
 
-    int res;
+    int32_t res;
 
     if (sl->version.jtag_api != STLINK_JTAG_API_V1) {
         res = _stlink_usb_write_debug32(sl, STLINK_REG_DHCSR, 
@@ -589,8 +589,8 @@ int _stlink_usb_run(stlink_t* sl, enum run_type type) {
     unsigned char* const data = sl->q_buf;
     unsigned char* const cmd = sl->c_buf;
     ssize_t size;
-    int rep_len = 2;
-    int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
+    int32_t rep_len = 2;
+    int32_t i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
 
     cmd[i++] = STLINK_DEBUG_COMMAND;
     cmd[i++] = STLINK_DEBUG_RUNCORE;
@@ -599,20 +599,20 @@ int _stlink_usb_run(stlink_t* sl, enum run_type type) {
     return(size<0?-1:0);
 }
 
-int _stlink_usb_set_swdclk(stlink_t* sl, int clk_freq) {
+int32_t _stlink_usb_set_swdclk(stlink_t* sl, int32_t clk_freq) {
     struct stlink_libusb * const slu = sl->backend_data;
     unsigned char* const data = sl->q_buf;
     unsigned char* const cmd = sl->c_buf;
     ssize_t size;
-    int rep_len = 2;
-    int i;
+    int32_t rep_len = 2;
+    int32_t i;
 
     // clock speed only supported by stlink/v2 and for firmware >= 22
     if (sl->version.stlink_v == 2 && sl->version.jtag_v >= 22) {
         uint16_t clk_divisor;
         if (clk_freq) {
             const uint32_t map[] = {5, 15, 25, 50, 100, 125, 240, 480, 950, 1200, 1800, 4000};
-            int speed_index = _stlink_match_speed_map(map, STLINK_ARRAY_SIZE(map), clk_freq);
+            int32_t speed_index = _stlink_match_speed_map(map, STLINK_ARRAY_SIZE(map), clk_freq);
             switch (map[speed_index]) {
             case 5:   clk_divisor = STLINK_SWDCLK_5KHZ_DIVISOR; break;
             case 15:  clk_divisor = STLINK_SWDCLK_15KHZ_DIVISOR; break;
@@ -641,7 +641,7 @@ int _stlink_usb_set_swdclk(stlink_t* sl, int clk_freq) {
 
         return(size<0?-1:0);
     } else if (sl->version.stlink_v == 3) {
-        int speed_index;
+        int32_t speed_index;
         uint32_t map[STLINK_V3_MAX_FREQ_NB];
         i = fill_command(sl, SG_DXFER_FROM_DEV, 16);
 
@@ -654,7 +654,7 @@ int _stlink_usb_set_swdclk(stlink_t* sl, int clk_freq) {
             return(-1);
         }
 
-        int speeds_size = data[8];
+        int32_t speeds_size = data[8];
         if (speeds_size > STLINK_V3_MAX_FREQ_NB) {
             speeds_size = STLINK_V3_MAX_FREQ_NB;
         }
@@ -688,11 +688,11 @@ int _stlink_usb_set_swdclk(stlink_t* sl, int clk_freq) {
     return(-1);
 }
 
-int _stlink_usb_exit_debug_mode(stlink_t *sl) {
+int32_t _stlink_usb_exit_debug_mode(stlink_t *sl) {
     struct stlink_libusb * const slu = sl->backend_data;
     unsigned char* const cmd = sl->c_buf;
     ssize_t size;
-    int i = fill_command(sl, SG_DXFER_FROM_DEV, 0);
+    int32_t i = fill_command(sl, SG_DXFER_FROM_DEV, 0);
 
     cmd[i++] = STLINK_DEBUG_COMMAND;
     cmd[i++] = STLINK_DEBUG_EXIT;
@@ -702,12 +702,12 @@ int _stlink_usb_exit_debug_mode(stlink_t *sl) {
     return(size<0?-1:0);
 }
 
-int _stlink_usb_read_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
+int32_t _stlink_usb_read_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
     struct stlink_libusb * const slu = sl->backend_data;
     unsigned char* const data = sl->q_buf;
     unsigned char* const cmd = sl->c_buf;
     ssize_t size;
-    int i = fill_command(sl, SG_DXFER_FROM_DEV, len);
+    int32_t i = fill_command(sl, SG_DXFER_FROM_DEV, len);
 
     cmd[i++] = STLINK_DEBUG_COMMAND;
     cmd[i++] = STLINK_DEBUG_READMEM_32BIT;
@@ -719,19 +719,19 @@ int _stlink_usb_read_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
         return(-1);
     }
 
-    sl->q_len = (int)size;
+    sl->q_len = (int32_t)size;
     stlink_print_data(sl);
 
     return(0);
 }
 
-int _stlink_usb_read_all_regs(stlink_t *sl, struct stlink_reg *regp) {
+int32_t _stlink_usb_read_all_regs(stlink_t *sl, struct stlink_reg *regp) {
     struct stlink_libusb * const slu = sl->backend_data;
     unsigned char* const cmd = sl->c_buf;
     unsigned char* const data = sl->q_buf;
     ssize_t size;
     uint32_t rep_len = sl->version.jtag_api == STLINK_JTAG_API_V1 ? 84 : 88;
-    int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
+    int32_t i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
 
     cmd[i++] = STLINK_DEBUG_COMMAND;
 
@@ -749,8 +749,8 @@ int _stlink_usb_read_all_regs(stlink_t *sl, struct stlink_reg *regp) {
 
     /* V1: regs data from offset 0 */
     /* V2: status at offset 0, regs data from offset 4 */
-    int reg_offset = sl->version.jtag_api == STLINK_JTAG_API_V1 ? 0 : 4;
-    sl->q_len = (int)size;
+    int32_t reg_offset = sl->version.jtag_api == STLINK_JTAG_API_V1 ? 0 : 4;
+    sl->q_len = (int32_t)size;
     stlink_print_data(sl);
 
     for (i = 0; i < 16; i++) regp->r[i] = read_uint32(sl->q_buf, reg_offset + i * 4);
@@ -772,15 +772,15 @@ int _stlink_usb_read_all_regs(stlink_t *sl, struct stlink_reg *regp) {
     return(0);
 }
 
-int _stlink_usb_read_reg(stlink_t *sl, int r_idx, struct stlink_reg *regp) {
+int32_t _stlink_usb_read_reg(stlink_t *sl, int32_t r_idx, struct stlink_reg *regp) {
     struct stlink_libusb * const slu = sl->backend_data;
     unsigned char* const data = sl->q_buf;
     unsigned char* const cmd  = sl->c_buf;
     ssize_t size;
     uint32_t r;
     uint32_t rep_len = sl->version.jtag_api == STLINK_JTAG_API_V1 ? 4 : 8;
-    int reg_offset = sl->version.jtag_api == STLINK_JTAG_API_V1 ? 0 : 4;
-    int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
+    int32_t reg_offset = sl->version.jtag_api == STLINK_JTAG_API_V1 ? 0 : 4;
+    int32_t i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
 
     cmd[i++] = STLINK_DEBUG_COMMAND;
 
@@ -797,7 +797,7 @@ int _stlink_usb_read_reg(stlink_t *sl, int r_idx, struct stlink_reg *regp) {
         return(-1);
     }
 
-    sl->q_len = (int)size;
+    sl->q_len = (int32_t)size;
     stlink_print_data(sl);
     r = read_uint32(sl->q_buf, reg_offset);
     DLOG("r_idx (%2d) = 0x%08x\n", r_idx, r);
@@ -826,13 +826,13 @@ int _stlink_usb_read_reg(stlink_t *sl, int r_idx, struct stlink_reg *regp) {
 }
 
 /* See section C1.6 of the ARMv7-M Architecture Reference Manual */
-int _stlink_usb_read_unsupported_reg(stlink_t *sl, int r_idx, struct stlink_reg *regp) {
+int32_t _stlink_usb_read_unsupported_reg(stlink_t *sl, int32_t r_idx, struct stlink_reg *regp) {
     uint32_t r;
-    int ret;
+    int32_t ret;
 
     sl->q_buf[0] = (unsigned char)r_idx;
 
-    for (int i = 1; i < 4; i++) sl->q_buf[i] = 0;
+    for (int32_t i = 1; i < 4; i++) sl->q_buf[i] = 0;
 
     ret = _stlink_usb_write_mem32(sl, STLINK_REG_DCRSR, 4);
 
@@ -863,8 +863,8 @@ int _stlink_usb_read_unsupported_reg(stlink_t *sl, int r_idx, struct stlink_reg
     return(0);
 }
 
-int _stlink_usb_read_all_unsupported_regs(stlink_t *sl, struct stlink_reg *regp) {
-    int ret;
+int32_t _stlink_usb_read_all_unsupported_regs(stlink_t *sl, struct stlink_reg *regp) {
+    int32_t ret;
 
     ret = _stlink_usb_read_unsupported_reg(sl, 0x14, regp);
 
@@ -874,7 +874,7 @@ int _stlink_usb_read_all_unsupported_regs(stlink_t *sl, struct stlink_reg *regp)
 
     if (ret == -1) { return(ret); }
 
-    for (int i = 0; i < 32; i++) {
+    for (int32_t i = 0; i < 32; i++) {
         ret = _stlink_usb_read_unsupported_reg(sl, 0x40 + i, regp);
 
         if (ret == -1) { return(ret); }
@@ -884,8 +884,8 @@ int _stlink_usb_read_all_unsupported_regs(stlink_t *sl, struct stlink_reg *regp)
 }
 
 /* See section C1.6 of the ARMv7-M Architecture Reference Manual */
-int _stlink_usb_write_unsupported_reg(stlink_t *sl, uint32_t val, int r_idx, struct stlink_reg *regp) {
-    int ret;
+int32_t _stlink_usb_write_unsupported_reg(stlink_t *sl, uint32_t val, int32_t r_idx, struct stlink_reg *regp) {
+    int32_t ret;
 
     if (r_idx >= 0x1C && r_idx <= 0x1F) { // primask, basepri, faultmask, or control
         /* These are held in the same register */
@@ -939,13 +939,13 @@ int _stlink_usb_write_unsupported_reg(stlink_t *sl, uint32_t val, int r_idx, str
     return(_stlink_usb_write_mem32(sl, STLINK_REG_DCRSR, 4));
 }
 
-int _stlink_usb_write_reg(stlink_t *sl, uint32_t reg, int idx) {
+int32_t _stlink_usb_write_reg(stlink_t *sl, uint32_t reg, int32_t idx) {
     struct stlink_libusb * const slu = sl->backend_data;
     unsigned char* const data = sl->q_buf;
     unsigned char* const cmd  = sl->c_buf;
     ssize_t size;
     uint32_t rep_len = 2;
-    int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
+    int32_t i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
 
     cmd[i++] = STLINK_DEBUG_COMMAND;
 
@@ -962,14 +962,14 @@ int _stlink_usb_write_reg(stlink_t *sl, uint32_t reg, int idx) {
     return(size<0?-1:0);
 }
 
-int _stlink_usb_enable_trace(stlink_t* sl, uint32_t frequency) {
+int32_t _stlink_usb_enable_trace(stlink_t* sl, uint32_t frequency) {
     struct stlink_libusb * const slu = sl->backend_data;
     unsigned char* const data = sl->q_buf;
     unsigned char* const cmd  = sl->c_buf;
     ssize_t size;
     uint32_t rep_len = 2;
 
-    int i = fill_command(sl, SG_DXFER_TO_DEV, rep_len);
+    int32_t i = fill_command(sl, SG_DXFER_TO_DEV, rep_len);
     cmd[i++] = STLINK_DEBUG_COMMAND;
     cmd[i++] = STLINK_DEBUG_APIV2_START_TRACE_RX;
     write_uint16(&cmd[i + 0], 2 * STLINK_TRACE_BUF_LEN);
@@ -980,14 +980,14 @@ int _stlink_usb_enable_trace(stlink_t* sl, uint32_t frequency) {
     return(size<0?-1:0);
 }
 
-int _stlink_usb_disable_trace(stlink_t* sl) {
+int32_t _stlink_usb_disable_trace(stlink_t* sl) {
     struct stlink_libusb * const slu = sl->backend_data;
     unsigned char* const data = sl->q_buf;
     unsigned char* const cmd  = sl->c_buf;
     ssize_t size;
     uint32_t rep_len = 2;
 
-    int i = fill_command(sl, SG_DXFER_TO_DEV, rep_len);
+    int32_t i = fill_command(sl, SG_DXFER_TO_DEV, rep_len);
     cmd[i++] = STLINK_DEBUG_COMMAND;
     cmd[i++] = STLINK_DEBUG_APIV2_STOP_TRACE_RX;
 
@@ -996,12 +996,12 @@ int _stlink_usb_disable_trace(stlink_t* sl) {
     return(size<0?-1:0);
 }
 
-int _stlink_usb_read_trace(stlink_t* sl, uint8_t* buf, size_t size) {
+int32_t _stlink_usb_read_trace(stlink_t* sl, uint8_t* buf, size_t size) {
     struct stlink_libusb * const slu = sl->backend_data;
     unsigned char* const data = sl->q_buf;
     unsigned char* const cmd  = sl->c_buf;
     uint32_t rep_len = 2;
-    int i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
+    int32_t i = fill_command(sl, SG_DXFER_FROM_DEV, rep_len);
 
     cmd[i++] = STLINK_DEBUG_COMMAND;
     cmd[i++] = STLINK_DEBUG_APIV2_GET_TRACE_NB;
@@ -1010,7 +1010,7 @@ int _stlink_usb_read_trace(stlink_t* sl, uint8_t* buf, size_t size) {
     if (send_size < 0) {
         return(-1);
     } else if (send_size != 2) {
-        ELOG("STLINK_DEBUG_APIV2_GET_TRACE_NB reply size %d\n", (int)send_size);
+        ELOG("STLINK_DEBUG_APIV2_GET_TRACE_NB reply size %d\n", (int32_t)send_size);
         return(-1);
     }
 
@@ -1022,10 +1022,10 @@ int _stlink_usb_read_trace(stlink_t* sl, uint8_t* buf, size_t size) {
     }
 
     if (trace_count != 0) {
-        int res = 0;
-        int t = libusb_bulk_transfer(slu->usb_handle, slu->ep_trace, buf, trace_count, &res, 3000);
+        int32_t res = 0;
+        int32_t t = libusb_bulk_transfer(slu->usb_handle, slu->ep_trace, buf, trace_count, &res, 3000);
 
-        if (t || res != (int)trace_count) {
+        if (t || res != (int32_t)trace_count) {
             ELOG("read_trace read error %d\n", t);
             return(-1);
         }
@@ -1075,7 +1075,7 @@ size_t stlink_serial(struct libusb_device_handle *handle, struct libusb_device_d
 	serial[0] = '\0';
 
 	/* get the LANGID from String Descriptor Zero */
-	int ret = libusb_get_string_descriptor(handle, 0, 0, desc_serial, sizeof(desc_serial));
+	int32_t ret = libusb_get_string_descriptor(handle, 0, 0, desc_serial, sizeof(desc_serial));
 	if (ret < 4) return 0;
 
 	uint32_t langid = desc_serial[2] | (desc_serial[3] << 8);
@@ -1094,7 +1094,7 @@ size_t stlink_serial(struct libusb_device_handle *handle, struct libusb_device_d
 		if (ret < 0) return 0;
 	} else if (len == ((STLINK_SERIAL_LENGTH / 2 + 1) * 2)) { /* len == 26 */
 		/* fix-up the buggy serial */
-		for (unsigned int i = 0; i < STLINK_SERIAL_LENGTH; i += 2)
+		for (uint32_t i = 0; i < STLINK_SERIAL_LENGTH; i += 2)
 			sprintf(serial + i, "%02X", desc_serial[i + 2]);
 		serial[STLINK_SERIAL_LENGTH] = '\0';
 	} else {
@@ -1104,11 +1104,11 @@ size_t stlink_serial(struct libusb_device_handle *handle, struct libusb_device_d
 	return strlen(serial);
 }
 
-stlink_t *stlink_open_usb(enum ugly_loglevel verbose, enum connect_type connect, char serial[STLINK_SERIAL_BUFFER_SIZE], int freq) {
+stlink_t *stlink_open_usb(enum ugly_loglevel verbose, enum connect_type connect, char serial[STLINK_SERIAL_BUFFER_SIZE], int32_t freq) {
     stlink_t* sl = NULL;
     struct stlink_libusb* slu = NULL;
-    int ret = -1;
-    int config;
+    int32_t ret = -1;
+    int32_t config;
 
     sl = calloc(1, sizeof(stlink_t));
     if (sl == NULL) { goto on_malloc_error; }
@@ -1246,7 +1246,7 @@ stlink_t *stlink_open_usb(enum ugly_loglevel verbose, enum connect_type connect,
     // initialize stlink version (sl->version)
     stlink_version(sl);
 
-    int mode = stlink_current_mode(sl);
+    int32_t mode = stlink_current_mode(sl);
     if (mode == STLINK_DEV_DFU_MODE) {
         DLOG("-- exit_dfu_mode\n");
         _stlink_usb_exit_dfu_mode(sl);
@@ -1288,17 +1288,17 @@ stlink_t *stlink_open_usb(enum ugly_loglevel verbose, enum connect_type connect,
     return(NULL);
 }
 
-static size_t stlink_probe_usb_devs(libusb_device **devs, stlink_t **sldevs[], enum connect_type connect, int freq) {
+static size_t stlink_probe_usb_devs(libusb_device **devs, stlink_t **sldevs[], enum connect_type connect, int32_t freq) {
     stlink_t **_sldevs;
     libusb_device *dev;
-    int i = 0;
+    int32_t i = 0;
     size_t slcnt = 0;
     size_t slcur = 0;
 
     /* Count STLINKs */
     while ((dev = devs[i++]) != NULL) {
         struct libusb_device_descriptor desc;
-        int ret = libusb_get_device_descriptor(dev, &desc);
+        int32_t ret = libusb_get_device_descriptor(dev, &desc);
 
         if (ret < 0) {
             WLOG("failed to get libusb device descriptor (libusb error: %d)\n", ret);
@@ -1327,7 +1327,7 @@ static size_t stlink_probe_usb_devs(libusb_device **devs, stlink_t **sldevs[], e
 
     while ((dev = devs[i++]) != NULL) {
         struct libusb_device_descriptor desc;
-        int ret = libusb_get_device_descriptor(dev, &desc);
+        int32_t ret = libusb_get_device_descriptor(dev, &desc);
 
         if (ret < 0) {
             WLOG("failed to get libusb device descriptor (libusb error: %d)\n", ret);
@@ -1372,12 +1372,12 @@ static size_t stlink_probe_usb_devs(libusb_device **devs, stlink_t **sldevs[], e
     return(slcur);
 }
 
-size_t stlink_probe_usb(stlink_t **stdevs[], enum connect_type connect, int freq) {
+size_t stlink_probe_usb(stlink_t **stdevs[], enum connect_type connect, int32_t freq) {
     libusb_device **devs;
     stlink_t **sldevs;
 
     size_t slcnt = 0;
-    int r;
+    int32_t r;
     ssize_t cnt;
 
     r = libusb_init(NULL);
diff --git a/src/stlink-lib/usb.h b/src/stlink-lib/usb.h
index 8c98bcaf4..b5c1835ec 100644
--- a/src/stlink-lib/usb.h
+++ b/src/stlink-lib/usb.h
@@ -7,9 +7,10 @@
 #define USB_H
 
 #include <stdbool.h>
+#include <stdint.h>
 
 #include <stlink.h>
-#include <libusb_settings.h>
+#include "libusb_settings.h"
 #include "logging.h"
 
 #define STLINK_USB_VID_ST                   0x0483
@@ -49,12 +50,12 @@
 struct stlink_libusb {
     libusb_context* libusb_ctx;
     libusb_device_handle* usb_handle;
-    unsigned int ep_req;
-    unsigned int ep_rep;
-    unsigned int ep_trace;
-    int protocoll;
-    unsigned int sg_transfer_idx;
-    unsigned int cmd_len;
+    uint32_t ep_req;
+    uint32_t ep_rep;
+    uint32_t ep_trace;
+    int32_t protocoll;
+    uint32_t sg_transfer_idx;
+    uint32_t cmd_len;
 };
 
 /**
@@ -66,8 +67,8 @@ struct stlink_libusb {
  * @retval !NULL  Stlink found and ready to use
  */
  
-stlink_t *stlink_open_usb(enum ugly_loglevel verbose, enum connect_type connect, char serial[STLINK_SERIAL_BUFFER_SIZE], int freq);
-size_t stlink_probe_usb(stlink_t **stdevs[], enum connect_type connect, int freq);
+stlink_t *stlink_open_usb(enum ugly_loglevel verbose, enum connect_type connect, char serial[STLINK_SERIAL_BUFFER_SIZE], int32_t freq);
+size_t stlink_probe_usb(stlink_t **stdevs[], enum connect_type connect, int32_t freq);
 void stlink_probe_usb_free(stlink_t **stdevs[], size_t size);
 
 #endif // USB_H
diff --git a/src/win32/getopt/getopt.c b/src/win32/getopt/getopt.c
index ff0a2fd91..7bc8d2d20 100644
--- a/src/win32/getopt/getopt.c
+++ b/src/win32/getopt/getopt.c
@@ -1,18 +1,19 @@
 #include <stddef.h>
+#include <stdint.h>
 #include <string.h>
 
 #include "getopt.h"
 
 #if !defined(_MSC_VER)
-const int no_argument = 0;
-const int required_argument = 1;
-const int optional_argument = 2;
+const int32_t no_argument = 0;
+const int32_t required_argument = 1;
+const int32_t optional_argument = 2;
 #endif
 
 char* optarg;
-int optopt;
-int optind = 1; // The variable optind [...] shall be initialized to 1 by the system
-int opterr;
+int32_t optopt;
+int32_t optind = 1; // The variable optind [...] shall be initialized to 1 by the system
+int32_t opterr;
 
 static char* optcursor = NULL;
 
@@ -24,8 +25,8 @@ static char* optcursor = NULL;
  * [2] http://www.kernel.org/doc/man-pages/online/pages/man3/getopt.3.html
  * [3] http://www.freebsd.org/cgi/man.cgi?query=getopt&sektion=3&manpath=FreeBSD+9.0-RELEASE
  */
-int getopt(int argc, char* const argv[], const char* optstring) {
-    int optchar = -1;
+int32_t getopt(int32_t argc, char* const argv[], const char* optstring) {
+    int32_t optchar = -1;
     const char* optdecl = NULL;
 
     optarg = NULL;
@@ -125,17 +126,17 @@ int getopt(int argc, char* const argv[], const char* optstring) {
 }
 
 /* Implementation based on http://www.kernel.org/doc/man-pages/online/pages/man3/getopt.3.html */
-int getopt_long(int argc,
+int32_t getopt_long(int32_t argc,
                 char* const argv[],
                 const char* optstring,
                 const struct option* longopts,
                 int* longindex) {
     const struct option* o = longopts;
     const struct option* match = NULL;
-    int num_matches = 0;
+    int32_t num_matches = 0;
     size_t argument_name_length = 0;
     const char* current_argument = NULL;
-    int retval = -1;
+    int32_t retval = -1;
 
     optarg = NULL;
     optopt = 0;
diff --git a/src/win32/getopt/getopt.h b/src/win32/getopt/getopt.h
index b1dd35ef1..4f21e69dc 100644
--- a/src/win32/getopt/getopt.h
+++ b/src/win32/getopt/getopt.h
@@ -1,6 +1,8 @@
 #ifndef GETOPT_H
 #define GETOPT_H
 
+#include <stdint.h>
+
 #if defined(__cplusplus)
 extern "C" {
 #endif
@@ -11,24 +13,24 @@ extern "C" {
 #define required_argument  1
 #define optional_argument  2
 #else
-extern const int no_argument;
-extern const int required_argument;
-extern const int optional_argument;
+extern const int32_t no_argument;
+extern const int32_t required_argument;
+extern const int32_t optional_argument;
 #endif
 
 extern char* optarg;
-extern int optind, opterr, optopt;
+extern int32_t optind, opterr, optopt;
 
 struct option {
     const char* name;
-    int has_arg;
+    int32_t has_arg;
     int* flag;
-    int val;
+    int32_t val;
 };
 
-int getopt(int argc, char* const argv[], const char* optstring);
+int32_t getopt(int32_t argc, char* const argv[], const char* optstring);
 
-int getopt_long(int argc,
+int32_t getopt_long(int32_t argc,
                 char* const argv[],
                 const char* optstring,
                 const struct option* longopts,
diff --git a/src/win32/mmap.c b/src/win32/mmap.c
index d702a78f6..ea8a3cb37 100644
--- a/src/win32/mmap.c
+++ b/src/win32/mmap.c
@@ -1,11 +1,12 @@
-#include <string.h>
-#include <sys/types.h>
+#include <stdint.h>
 #include <stdlib.h>
+#include <string.h>
 #include <unistd.h>
+#include <sys/types.h>
 
 #include "mmap.h"
 
-void *mmap (void *addr, size_t len, int prot, int flags, int fd, long long offset) {
+void *mmap (void *addr, size_t len, int32_t prot, int32_t flags, int32_t fd, int64_t offset) {
     void *buf;
     ssize_t count;
 
@@ -31,7 +32,7 @@ void *mmap (void *addr, size_t len, int prot, int flags, int fd, long long offse
     (void)flags;
 }
 
-int munmap (void *addr, size_t len) {
+int32_t munmap (void *addr, size_t len) {
     free (addr);
     return(0);
     (void)len;
diff --git a/src/win32/mmap.h b/src/win32/mmap.h
index c6390aede..e8bbab0bc 100644
--- a/src/win32/mmap.h
+++ b/src/win32/mmap.h
@@ -1,6 +1,8 @@
 #ifndef MMAP_H
 #define MMAP_H
 
+#include <stdint.h>
+
 #ifdef STLINK_HAVE_SYS_MMAN_H
 #include <sys/mman.h>
 #else
@@ -13,8 +15,8 @@
 #define MAP_ANONYMOUS (1 << 5)
 #define MAP_FAILED    ((void *)-1)
 
-void *mmap(void *addr, size_t len, int prot, int flags, int fd, long long offset);
-int munmap(void *addr, size_t len);
+void *mmap(void *addr, size_t len, int32_t prot, int32_t flags, int32_t fd, int64_t offset);
+int32_t munmap(void *addr, size_t len);
 
 #endif // STLINK_HAVE_SYS_MMAN_H
 
diff --git a/src/win32/sys_time.c b/src/win32/sys_time.c
index 422731b3f..a09d8df67 100644
--- a/src/win32/sys_time.c
+++ b/src/win32/sys_time.c
@@ -1,3 +1,5 @@
+#include <stdint.h>
+
 #include "sys_time.h"
 
 #ifndef STLINK_HAVE_SYS_TIME_H
@@ -5,18 +7,18 @@
 #include <time.h>
 
 /* Simple gettimeofday implementation without converting Windows time to Linux time */
-int gettimeofday(struct timeval *tv, struct timezone *tz) {
+int32_t gettimeofday(struct timeval *tv, struct timezone *tz) {
     FILETIME ftime;
     ULARGE_INTEGER ulint;
-    static int tzflag = 0;
+    static int32_t tzflag = 0;
 
     if(NULL != tv) {
         GetSystemTimeAsFileTime(&ftime);
         ulint.LowPart = ftime.dwLowDateTime;
         ulint.HighPart = ftime.dwHighDateTime;
 
-        tv->tv_sec = (long)(ulint.QuadPart / 10000000L);
-        tv->tv_usec = (long)(ulint.QuadPart % 10000000L);
+        tv->tv_sec = (int32_t)(ulint.QuadPart / 10000000L);
+        tv->tv_usec = (int32_t)(ulint.QuadPart % 10000000L);
     }
 
     if(NULL != tz) {
diff --git a/src/win32/sys_time.h b/src/win32/sys_time.h
index 98ecaddfc..ca6e0a761 100644
--- a/src/win32/sys_time.h
+++ b/src/win32/sys_time.h
@@ -1,6 +1,8 @@
 #ifndef SYS_TIME_H
 #define SYS_TIME_H
 
+#include <stdint.h>
+
 #ifdef STLINK_HAVE_SYS_TIME_H
 
 #include <sys/time.h>
@@ -10,11 +12,11 @@
 #include <windows.h>
 
 struct timezone {
-    int tz_minuteswest;
-    int tz_dsttime;
+    int32_t tz_minuteswest;
+    int32_t tz_dsttime;
 };
 
-int gettimeofday(struct timeval *tv, struct timezone *tz);
+int32_t gettimeofday(struct timeval *tv, struct timezone *tz);
 
 #endif // STLINK_HAVE_SYS_TIME_H
 
diff --git a/src/win32/unistd/unistd.h b/src/win32/unistd/unistd.h
index 5f2b5433b..d61b75b67 100644
--- a/src/win32/unistd/unistd.h
+++ b/src/win32/unistd/unistd.h
@@ -6,8 +6,9 @@
  * Please add functionality as needed.
  */
 
-#include <stdlib.h>
+#include <stdint.h>
 #include <stdio.h>
+#include <stdlib.h>
 
 #if defined(_MSC_VER)
 #pragma warning(push)
@@ -69,7 +70,7 @@ typedef unsigned __int32 uint32_t;
 typedef unsigned __int64 uint64_t;
 
 #ifndef STLINK_HAVE_UNISTD_H
-int usleep(unsigned int waitTime);
+int32_t usleep(uint32_t waitTime);
 #endif
 
 #endif // UNISTD_H
diff --git a/src/win32/win32_socket.c b/src/win32/win32_socket.c
index 3f4d28bbd..46b4532a7 100644
--- a/src/win32/win32_socket.c
+++ b/src/win32/win32_socket.c
@@ -1,5 +1,7 @@
 #if defined(_WIN32)
 
+#include <stdint.h>
+
 #include "win32_socket.h"
 
 #undef socket
@@ -11,11 +13,11 @@
 #include <errno.h>
 #include <assert.h>
 
-int win32_poll(struct pollfd *fds, unsigned int nfds, int timo) {
+int32_t win32_poll(struct pollfd *fds, uint32_t nfds, int32_t timo) {
     struct timeval timeout, *toptr;
     fd_set ifds, ofds, efds, *ip, *op;
-    unsigned int i;
-    int rc;
+    uint32_t i;
+    int32_t rc;
 
 #ifdef _MSC_VER
 #pragma warning(disable: 4548)
@@ -99,7 +101,7 @@ int win32_poll(struct pollfd *fds, unsigned int nfds, int timo) {
     return(rc);
 }
 
-static void set_connect_errno(int winsock_err) {
+static void set_connect_errno(int32_t winsock_err) {
     switch (winsock_err) {
     case WSAEINVAL:
     case WSAEALREADY:
@@ -112,7 +114,7 @@ static void set_connect_errno(int winsock_err) {
     }
 }
 
-static void set_socket_errno(int winsock_err) {
+static void set_socket_errno(int32_t winsock_err) {
     switch (winsock_err) {
     case WSAEWOULDBLOCK:
         errno = EAGAIN;
@@ -128,7 +130,7 @@ static void set_socket_errno(int winsock_err) {
  * The purpose of this wrapper is to ensure that the global errno symbol is set if an error occurs,
  * even if we are using winsock.
  */
-SOCKET win32_socket(int domain, int type, int protocol) {
+SOCKET win32_socket(int32_t domain, int32_t type, int32_t protocol) {
     SOCKET fd = socket(domain, type, protocol);
 
     if (fd == INVALID_SOCKET) { set_socket_errno(WSAGetLastError()); }
@@ -141,8 +143,8 @@ SOCKET win32_socket(int domain, int type, int protocol) {
  * The purpose of this wrapper is to ensure that the global errno symbol is set if an error occurs,
  * even if we are using winsock.
  */
-int win32_connect(SOCKET fd, struct sockaddr *addr, socklen_t addr_len) {
-    int rc = connect(fd, addr, addr_len);
+int32_t win32_connect(SOCKET fd, struct sockaddr *addr, socklen_t addr_len) {
+    int32_t rc = connect(fd, addr, addr_len);
     assert(rc == 0 || rc == SOCKET_ERROR);
 
     if (rc == SOCKET_ERROR) { set_connect_errno(WSAGetLastError()); }
@@ -169,8 +171,8 @@ SOCKET win32_accept(SOCKET fd, struct sockaddr *addr, socklen_t *addr_len) {
  * The purpose of this wrapper is to ensure that the global errno symbol is set if an error occurs,
  * even if we are using winsock.
  */
-int win32_shutdown(SOCKET fd, int mode) {
-    int rc = shutdown(fd, mode);
+int32_t win32_shutdown(SOCKET fd, int32_t mode) {
+    int32_t rc = shutdown(fd, mode);
     assert(rc == 0 || rc == SOCKET_ERROR);
 
     if (rc == SOCKET_ERROR) { set_socket_errno(WSAGetLastError()); }
@@ -178,24 +180,24 @@ int win32_shutdown(SOCKET fd, int mode) {
     return(rc);
 }
 
-int win32_close_socket(SOCKET fd) {
-    int rc = closesocket(fd);
+int32_t win32_close_socket(SOCKET fd) {
+    int32_t rc = closesocket(fd);
 
     if (rc == SOCKET_ERROR) { set_socket_errno(WSAGetLastError()); }
 
     return(rc);
 }
 
-ssize_t win32_write_socket(SOCKET fd, void *buf, int n) {
-    int rc = send(fd, buf, n, 0);
+ssize_t win32_write_socket(SOCKET fd, void *buf, int32_t n) {
+    int32_t rc = send(fd, buf, n, 0);
 
     if (rc == SOCKET_ERROR) { set_socket_errno(WSAGetLastError()); }
 
     return(rc);
 }
 
-ssize_t win32_read_socket(SOCKET fd, void *buf, int n) {
-    int rc = recv(fd, buf, n, 0);
+ssize_t win32_read_socket(SOCKET fd, void *buf, int32_t n) {
+    int32_t rc = recv(fd, buf, n, 0);
 
     if (rc == SOCKET_ERROR) { set_socket_errno(WSAGetLastError()); }
 
@@ -205,7 +207,7 @@ ssize_t win32_read_socket(SOCKET fd, void *buf, int n) {
 
 char * win32_strtok_r(char *s, const char *delim, char **lasts) {
     register char *spanp;
-    register int c, sc;
+    register int32_t c, sc;
     char *tok;
 
 
@@ -254,7 +256,7 @@ char * win32_strtok_r(char *s, const char *delim, char **lasts) {
 char *win32_strsep (char **stringp, const char *delim) {
     register char *s;
     register const char *spanp;
-    register int c, sc;
+    register int32_t c, sc;
     char *tok;
 
     if ((s = *stringp) == NULL) {
@@ -284,7 +286,7 @@ char *win32_strsep (char **stringp, const char *delim) {
 }
 
 #ifndef STLINK_HAVE_UNISTD_H
-int usleep(unsigned int waitTime) {
+int32_t usleep(uint32_t waitTime) {
     if (waitTime >= 1000) {
         /* Don't do long busy-waits.
          * However much it seems like the QPC code would be more accurate,
diff --git a/src/win32/win32_socket.h b/src/win32/win32_socket.h
index 614046a6f..e7ea398e9 100644
--- a/src/win32/win32_socket.h
+++ b/src/win32/win32_socket.h
@@ -1,5 +1,7 @@
 #if defined(_WIN32)
 
+#include <stdint.h>
+
 #define _USE_W32_SOCKETS 1
 
 #if defined(_MSC_VER)
@@ -35,8 +37,8 @@
 #define POLLNVAL    0x0020    /* Invalid request: fd not open */
 struct pollfd {
     SOCKET fd;        /* file descriptor */
-    short events;     /* requested events */
-    short revents;    /* returned events */
+    int16_t events;     /* requested events */
+    int16_t revents;    /* returned events */
 };
 #endif
 #define poll(x, y, z)     win32_poll(x, y, z)
@@ -54,15 +56,15 @@ struct pollfd {
 #define read(x, y, z)     win32_read_socket(x, y, z)
 #define write(x, y, z)    win32_write_socket(x, y, z)
 
-/* Winsock uses int instead of the usual socklen_t */
-typedef int socklen_t;
+/* Winsock uses int32_t instead of the usual socklen_t */
+typedef int32_t socklen_t;
 
-int     win32_poll(struct pollfd *, unsigned int, int);
-SOCKET  win32_socket(int, int, int);
-int     win32_connect(SOCKET, struct sockaddr*, socklen_t);
+int32_t win32_poll(struct pollfd *, uint32_t, int);
+SOCKET  win32_socket(int32_t, int32_t, int);
+int32_t win32_connect(SOCKET, struct sockaddr*, socklen_t);
 SOCKET  win32_accept(SOCKET, struct sockaddr*, socklen_t *);
-int     win32_shutdown(SOCKET, int);
-int     win32_close_socket(SOCKET fd);
+int32_t win32_shutdown(SOCKET, int);
+int32_t win32_close_socket(SOCKET fd);
 
 #define strtok_r(x, y, z) win32_strtok_r(x, y, z)
 #define strsep(x,y)       win32_strsep(x,y)
@@ -70,7 +72,7 @@ int     win32_close_socket(SOCKET fd);
 char *win32_strtok_r(char *s, const char *delim, char **lasts);
 char *win32_strsep(char **stringp, const char *delim);
 
-ssize_t win32_read_socket(SOCKET fd, void *buf, int n);
-ssize_t win32_write_socket(SOCKET fd, void *buf, int n);
+ssize_t win32_read_socket(SOCKET fd, void *buf, int32_t n);
+ssize_t win32_write_socket(SOCKET fd, void *buf, int32_t n);
 
 #endif // defined(_WIN32)
diff --git a/tests/flash.c b/tests/flash.c
index 1140566af..f66428dcd 100644
--- a/tests/flash.c
+++ b/tests/flash.c
@@ -1,3 +1,4 @@
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -11,7 +12,7 @@
 
 struct Test {
     const char * cmd_line;
-    int res;
+    int32_t res;
     struct flash_opts opts;
 };
 
@@ -32,7 +33,7 @@ static bool cmp_mem(const uint8_t * s1, const uint8_t * s2, size_t size) {
 }
 
 static bool execute_test(const struct Test * test) {
-    int ac = 0;
+    int32_t ac = 0;
     char* av[32];
 
     /* parse (tokenize) the test command line */
@@ -53,7 +54,7 @@ static bool execute_test(const struct Test * test) {
 
     /* Call */
     struct flash_opts opts;
-    int res = flash_get_opts(&opts, ac, av);
+    int32_t res = flash_get_opts(&opts, ac, av);
 
     /* Compare results */
     bool ret = (res == test->res);
@@ -225,7 +226,7 @@ static struct Test tests[] = {
     },
 };
 
-int main() {
+int32_t main() {
     bool allOk = true;
 
     for (size_t i = 0; i < sizeof(tests) / sizeof(tests[0]); ++i)
diff --git a/tests/sg.c b/tests/sg.c
index d88fbe760..cd601b6d6 100644
--- a/tests/sg.c
+++ b/tests/sg.c
@@ -1,3 +1,4 @@
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -24,7 +25,7 @@ static void __attribute__((unused)) mark_buf(stlink_t *sl) {
 }
 
 
-int main(void) { // main() ripped out of old stlink-hw.c
+int32_t main(void) { // main() ripped out of old stlink-hw.c
     /* Avoid unused parameter warning */
     // set scpi lib debug level: 0 for no debug info, 10 for lots
     fputs(
@@ -81,7 +82,7 @@ int main(void) { // main() ripped out of old stlink-hw.c
 
     memset(sl->q_buf, 0, sizeof(sl->q_buf));
 
-    for (int i = 0; i < 100; i++) {
+    for (int32_t i = 0; i < 100; i++) {
         write_uint32(sl->q_buf, LED_BLUE | LED_GREEN);
         stlink_write_mem32(sl, GPIOC_ODR, 4);
         // stlink_read_mem32(sl, 0x4001100c, 4);
@@ -184,7 +185,7 @@ int main(void) { // main() ripped out of old stlink-hw.c
 #if 0 /* check file contents */
     fputs("\n+++++++ check flash memory\n\n", stderr);
     {
-        const int res = stlink_fcheck_flash(sl, "/tmp/foobar", 0x08000000);
+        const int32_t res = stlink_fcheck_flash(sl, "/tmp/foobar", 0x08000000);
         printf("_____ stlink_fcheck_flash() == %d\n", res);
     }
 #endif
diff --git a/tests/usb.c b/tests/usb.c
index 742f5c578..2d928e5f0 100644
--- a/tests/usb.c
+++ b/tests/usb.c
@@ -1,17 +1,18 @@
+#include <stdint.h>
 #include <stdio.h>
+#include <string.h>
 
 #include <stlink.h>
-#include <string.h>
 
 static void usage(void) {
     puts("test-usb --reset");
     puts("test-usb --no-reset");
 }
 
-int main(int ac, char** av) {
+int32_t main(int32_t ac, char** av) {
     stlink_t* sl;
     struct stlink_reg regs;
-    int reset = 0;
+    int32_t reset = 0;
 
     if (ac == 2) {
         if (strcmp(av[1], "--reset") == 0)