mirror
/
stlink
kopia lustrzana https://github.com/stlink-org/stlink
1
0
Forkuj 0
Kod Zgłoszenia Packages Projekty Wydania Wiki Aktywność

[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.
pull/1332/head
nightwalker-87 2023-06-25 15:45:33 +02:00
rodzic 041517bd4a
commit 8fad9be9d0
18 zmienionych plików z 93 dodań i 60 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

2
SECURITY.md
Wyświetl plik

@ -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: |

24
inc/stlink.h
Wyświetl plik

@ -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_loader_to_sram(stlink_t *sl, stm32_addr_t* addr, size_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, 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);

1
src/st-trace/trace.c
Wyświetl plik

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

1
src/st-util/gdb-server.c
Wyświetl plik

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

3
src/st-util/semihosting.c
Wyświetl plik

@ -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;

1
src/stlink-gui/gui.c
Wyświetl plik

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

1
src/stlink-lib/calculate.c
Wyświetl plik

@ -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;

11
src/stlink-lib/common.c
Wyświetl plik

@ -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;
uint32_t rem = size & 0x3;
uint16_t chunk = 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);

1
src/stlink-lib/common_flash.c
Wyświetl plik

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

1
src/stlink-lib/flash_loader.c
Wyświetl plik

@ -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

2
src/stlink-lib/map_file.c
Wyświetl plik

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

1
src/stlink-lib/option_bytes.c
Wyświetl plik

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

73
src/stlink-lib/read_write.c
Wyświetl plik

@ -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) {
buf[0] = ui;
buf[1] = ui >> 8;
buf[2] = ui >> 16;
buf[3] = ui >> 24;
uint16_t read_uint16(const unsigned char *c, const int32_t pt) {
return ((uint16_t)c[pt]) | ((uint16_t)c[pt + 1] << 8);
}
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) {
return ((uint16_t)c[pt]) | ((uint16_t)c[pt + 1] << 8);
void write_uint32(unsigned char *buf, uint32_t ui) {
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));
}

27
src/stlink-lib/read_write.h 100644
Wyświetl plik

@ -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

1
src/stlink-lib/sg.c
Wyświetl plik

@ -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

1
src/stlink-lib/usb.c
Wyświetl plik

@ -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) {

1
tests/sg.c
Wyświetl plik

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

1
tests/usb.c
Wyświetl plik

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