[refactoring] Clean-up for stlink-lib

- Moved declarations for read/write functions to read_write.h .
- Checked & revised header includes
- Changed some datatypes for write_buffer_to_sram() to avoid explicit
casting.

SECURITY.md

@@ -7,7 +7,7 @@ The following versions of the stlink toolset are currently being supported.<br /
 | Version | Supported          |
 | ------- | ------------------ |
 | develop | :white_check_mark: |
-| 1.7.x   | :white_check_mark: |
+| 1.7.0   | :white_check_mark: |
 | 1.6.x   | :x:                |
 | 1.5.x   | :x:                |
 | 1.4.0   | :x:                |

inc/stlink.h

@@ -237,7 +237,7 @@ struct _stlink {
 /* Functions defined in common.c */
 
 int32_t stlink_enter_swd_mode(stlink_t *sl);
-int32_t stlink_enter_jtag_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);
@@ -246,17 +246,6 @@ 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);
@@ -265,23 +254,18 @@ 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, uint32_t size);
-int32_t stlink_parse_ihex(const char* path, uint8_t erased_pattern, uint8_t * * mem, uint32_t * size, uint32_t * begin);
+int32_t stlink_parse_ihex(const char* path, uint8_t erased_pattern, uint8_t* *mem, uint32_t* size, uint32_t* begin);
 uint8_t stlink_get_erased_pattern(stlink_t *sl);
 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_chip_id(stlink_t *sl, uint32_t *chip_id);
 int32_t stlink_cpu_id(stlink_t *sl, cortex_m3_cpuid_t *cpuid);
 uint32_t stlink_calculate_pagesize(stlink_t *sl, uint32_t flashaddr);
-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);
 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);
-int32_t write_buffer_to_sram(stlink_t *sl, flash_loader_t* fl, const uint8_t* buf, uint32_t size);
+int32_t write_buffer_to_sram(stlink_t *sl, flash_loader_t* fl, const uint8_t* buf, uint16_t size);
-int32_t write_loader_to_sram(stlink_t *sl, stm32_addr_t* addr, size_t* size);
+// int32_t write_loader_to_sram(stlink_t *sl, stm32_addr_t* addr, uint16_t* size);
 int32_t stlink_fread(stlink_t* sl, const char* path, bool is_ihex, stm32_addr_t addr, uint32_t size);
 int32_t stlink_load_device_params(stlink_t *sl);
 int32_t stlink_target_connect(stlink_t *sl, enum connect_type connect);

src/st-trace/trace.c

@@ -14,6 +14,7 @@
 
 #include <chipid.h>
 #include <logging.h>
+#include <read_write.h>
 #include <register.h>
 #include <usb.h>
 

src/st-util/gdb-server.c

@@ -36,6 +36,7 @@
 #include <flash_loader.h>
 #include <helper.h>
 #include <logging.h>
+#include <read_write.h>
 #include <register.h>
 #include <usb.h>
 

src/st-util/semihosting.c

@@ -8,9 +8,10 @@
 #include <unistd.h>
 
 #include <stlink.h>
+#include "semihosting.h"
 
 #include <logging.h>
-#include "semihosting.h"
+#include <read_write.h>
 
 static int32_t mem_read_u8(stlink_t *sl, uint32_t addr, uint8_t *data) {
     int32_t offset = addr % 4;

src/stlink-gui/gui.c

@@ -9,6 +9,7 @@
 
 #include <chipid.h>
 #include <common_flash.h>
+#include <read_write.h>
 #include <usb.h>
 
 #define MEM_READ_SIZE 1024

src/stlink-lib/calculate.c

@@ -10,6 +10,7 @@
 #include "calculate.h"
 
 #include "common_flash.h"
+#include "read_write.h"
 
 uint32_t calculate_F4_sectornum(uint32_t flashaddr) {
   uint32_t offset = 0;

src/stlink-lib/common.c

@@ -25,6 +25,7 @@
 #include "logging.h"
 #include "map_file.h"
 #include "md5.h"
+#include "read_write.h"
 #include "register.h"
 #include "usb.h"
 
@@ -808,20 +809,20 @@ int32_t stlink_fread(stlink_t *sl, const char *path, bool is_ihex, stm32_addr_t
 }
 
 // 300
-int32_t write_buffer_to_sram(stlink_t *sl, flash_loader_t *fl, const uint8_t *buf, uint32_t size) {
+int32_t write_buffer_to_sram(stlink_t *sl, flash_loader_t *fl, const uint8_t *buf, uint16_t size) {
   // write the buffer right after the loader
   int32_t ret = 0;
-  uint32_t chunk = size & ~0x3;
+  uint16_t chunk = size & ~0x3;
-  uint32_t rem = size & 0x3;
+  uint16_t rem = size & 0x3;
 
   if (chunk) {
     memcpy(sl->q_buf, buf, chunk);
-    ret = stlink_write_mem32(sl, fl->buf_addr, (uint16_t)chunk);
+    ret = stlink_write_mem32(sl, fl->buf_addr, chunk);
   }
 
   if (rem && !ret) {
     memcpy(sl->q_buf, buf + chunk, rem);
-    ret = stlink_write_mem8(sl, (fl->buf_addr) + chunk, (uint16_t)rem);
+    ret = stlink_write_mem8(sl, (fl->buf_addr) + chunk, rem);
   }
 
   return (ret);

src/stlink-lib/common_flash.c

@@ -18,6 +18,7 @@
 #include "logging.h"
 #include "map_file.h"
 #include "md5.h"
+#include "read_write.h"
 
 #define DEBUG_FLASH 0
 

src/stlink-lib/flash_loader.c

@@ -16,6 +16,7 @@
 #include "common_flash.h"
 #include "helper.h"
 #include "logging.h"
+#include "read_write.h"
 #include "register.h"
 
 #define FLASH_REGS_BANK2_OFS      0x40

src/stlink-lib/map_file.c

@@ -15,6 +15,8 @@
 #include <stlink.h>
 #include "map_file.h"
 
+#include "read_write.h"
+
 #ifndef O_BINARY
 #define O_BINARY 0
 #endif

src/stlink-lib/option_bytes.c

@@ -16,6 +16,7 @@
 #include "logging.h"
 #include "map_file.h"
 #include "md5.h"
+#include "read_write.h"
 
 /**
  * Read option control register F0

src/stlink-lib/read_write.c

@@ -1,8 +1,15 @@
+/*
+ * File: read_write.c
+ *
+ * Read and write operations
+ */
+
 #include <stdint.h>
 #include <stdio.h>
 #include <string.h>
 
 #include <stlink.h>
+#include "read_write.h"
 
 #include "logging.h"
 
@@ -10,11 +17,8 @@
 // https://commandcenter.blogspot.com/2012/04/byte-order-fallacy.html
 // These functions encode and decode little endian uint16 and uint32 values.
 
-void write_uint32(unsigned char *buf, uint32_t ui) {
+uint16_t read_uint16(const unsigned char *c, const int32_t pt) {
-  buf[0] = ui;
+  return ((uint16_t)c[pt]) | ((uint16_t)c[pt + 1] << 8);
-  buf[1] = ui >> 8;
-  buf[2] = ui >> 16;
-  buf[3] = ui >> 24;
 }
 
 void write_uint16(unsigned char *buf, uint16_t ui) {
@@ -27,8 +31,11 @@ uint32_t read_uint32(const unsigned char *c, const int32_t pt) {
          ((uint32_t)c[pt + 2] << 16) | ((uint32_t)c[pt + 3] << 24);
 }
 
-uint16_t read_uint16(const unsigned char *c, const int32_t pt) {
+void write_uint32(unsigned char *buf, uint32_t ui) {
-  return ((uint16_t)c[pt]) | ((uint16_t)c[pt + 1] << 8);
+  buf[0] = ui;
+  buf[1] = ui >> 8;
+  buf[2] = ui >> 16;
+  buf[3] = ui >> 24;
 }
 
 int32_t stlink_read_debug32(stlink_t *sl, uint32_t addr, uint32_t *data) {
@@ -46,17 +53,6 @@ int32_t stlink_write_debug32(stlink_t *sl, uint32_t addr, uint32_t data) {
   return sl->backend->write_debug32(sl, addr, data);
 }
 
-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) {
-    ELOG("Data length doesn't have a 32 bit alignment: +%d byte.\n", len % 4);
-    return (-1);
-  }
-
-  return (sl->backend->write_mem32(sl, addr, len));
-}
-
 int32_t stlink_read_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
   DLOG("*** stlink_read_mem32 ***\n");
 
@@ -68,26 +64,22 @@ int32_t stlink_read_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
   return (sl->backend->read_mem32(sl, addr, 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) {
+    ELOG("Data length doesn't have a 32 bit alignment: +%d byte.\n", len % 4);
+    return (-1);
+  }
+
+  return (sl->backend->write_mem32(sl, addr, 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));
 }
 
-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));
-}
-
-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));
-}
-
-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));
-}
-
 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);
@@ -100,6 +92,11 @@ int32_t stlink_read_reg(stlink_t *sl, int32_t r_idx, struct stlink_reg *regp) {
   return (sl->backend->read_reg(sl, r_idx, regp));
 }
 
+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));
+}
+
 int32_t stlink_read_unsupported_reg(stlink_t *sl, int32_t r_idx,
                                 struct stlink_reg *regp) {
   int32_t r_convert;
@@ -145,3 +142,13 @@ int32_t stlink_write_unsupported_reg(stlink_t *sl, uint32_t val, int32_t r_idx,
 
   return (sl->backend->write_unsupported_reg(sl, val, r_convert, 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));
+}
+
+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));
+}

src/stlink-lib/read_write.h

@@ -0,0 +1,27 @@
+/*
+ * File: read_write.h
+ *
+ * Read and write operations
+ */
+
+#ifndef READ_WRITE_H
+#define READ_WRITE_H
+
+uint16_t read_uint16(const unsigned char *c, const int32_t pt);
+void write_uint16(unsigned char *buf, uint16_t ui);
+uint32_t read_uint32(const unsigned char *c, const int32_t pt);
+void write_uint32(unsigned char *buf, uint32_t ui);
+
+int32_t stlink_read_debug32(stlink_t *sl, uint32_t addr, uint32_t *data);
+int32_t stlink_write_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_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_reg(stlink_t *sl, 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_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_read_all_regs(stlink_t *sl, struct stlink_reg *regp);
+int32_t stlink_read_all_unsupported_regs(stlink_t *sl, struct stlink_reg *regp);
+
+#endif // READ_WRITE_H

src/stlink-lib/sg.c

@@ -95,6 +95,7 @@
 
 #include "commands.h"
 #include "logging.h"
+#include "read_write.h"
 #include "register.h"
 #include "usb.h"
 // #include <stlink.h>    // TODO: Check use

src/stlink-lib/usb.c

@@ -27,6 +27,7 @@
 
 #include "commands.h"
 #include "logging.h"
+#include "read_write.h"
 #include "register.h"
 
 static inline uint32_t le_to_h_u32(const uint8_t* buf) {

tests/sg.c

@@ -8,6 +8,7 @@
 #include <stlink.h>
 
 #include <logging.h>
+#include <read_write.h>
 #include <sg.h>
 
 #if defined(_MSC_VER)

tests/usb.c

@@ -6,6 +6,7 @@
 
 #include <stlink.h>
 
+#include <read_write.h>
 #include <register.h>
 #include <usb.h>