Use size_t for sizes in flash functions. Fix all sign compare warnings.

10 years ago · 6f5b1873d7
15 changed files with 73 additions and 72 deletions
--- a/src/Makefile
+++ b/src/Makefile
@ -10,7 +10,6 @@ endif
 BUILDDATE := `date +"%Y%m%d"`

 CFLAGS += -Wall -Wextra -Wno-char-subscripts\
-	-Wno-sign-compare \
 	-O2 -std=gnu99 -g3 -DBUILDDATE=\"$(BUILDDATE)\"\
 	-I. -Iinclude -Iplatforms/common -I$(PLATFORM_DIR) \
 	-DVERSION_SUFFIX=\"`../scripts/setlocalversion`\" -MD
--- a/src/cortexm.c
+++ b/src/cortexm.c
@ -757,13 +757,13 @@ static bool cortexm_vector_catch(target *t, int argc, char *argv[])
 	const char *vectors[] = {"reset", NULL, NULL, NULL, "mm", "nocp",
 				"chk", "stat", "bus", "int", "hard"};
 	uint32_t tmp = 0;
-	unsigned i, j;
+	unsigned i;

 	if ((argc < 3) || ((argv[1][0] != 'e') && (argv[1][0] != 'd'))) {
 		gdb_out("usage: monitor vector_catch (enable|disable) "
 			"(hard|int|bus|stat|chk|nocp|mm|reset)\n");
 	} else {
-		for (j = 0; j < argc; j++)
+		for (int j = 0; j < argc; j++)
 			for (i = 0; i < sizeof(vectors) / sizeof(char*); i++) {
 				if (vectors[i] && !strcmp(vectors[i], argv[j]))
 					tmp |= 1 << i;
--- a/src/include/target.h
+++ b/src/include/target.h
@ -180,9 +180,9 @@ struct target_s {

 	/* Flash memory access functions */
 	const char *xml_mem_map;
-	int (*flash_erase)(struct target_s *target, uint32_t addr, int len);
+	int (*flash_erase)(struct target_s *target, uint32_t addr, size_t len);
 	int (*flash_write)(struct target_s *target, uint32_t dest,
-				const uint8_t *src, int len);
+	                   const uint8_t *src, size_t len);

 	/* Host I/O support */
 	void (*hostio_reply)(target *t, int32_t retcode, uint32_t errcode);
--- a/src/kinetis.c
+++ b/src/kinetis.c
@ -54,9 +54,9 @@

 #define KL25_PAGESIZE 0x400

-static int kl25_flash_erase(struct target_s *target, uint32_t addr, int len);
+static int kl25_flash_erase(struct target_s *target, uint32_t addr, size_t len);
 static int kl25_flash_write(struct target_s *target, uint32_t dest,
-			  const uint8_t *src, int len);
+                            const uint8_t *src, size_t len);

 static const char kl25_xml_memory_map[] = "<?xml version=\"1.0\"?>"
 /*	"<!DOCTYPE memory-map "
@ -121,7 +121,7 @@ kl25_command(struct target_s *t, uint8_t cmd, uint32_t addr, const uint8_t data[
 	return true;
 }

-static int kl25_flash_erase(struct target_s *t, uint32_t addr, int len)
+static int kl25_flash_erase(struct target_s *t, uint32_t addr, size_t len)
 {
 	addr &= ~(KL25_PAGESIZE - 1);
 	len = (len + KL25_PAGESIZE - 1) & ~(KL25_PAGESIZE - 1);
@ -135,7 +135,7 @@ static int kl25_flash_erase(struct target_s *t, uint32_t addr, int len)
 }

 static int kl25_flash_write(struct target_s *t, uint32_t dest,
-			  const uint8_t *src, int len)
+			  const uint8_t *src, size_t len)
 {
 	/* FIXME handle misaligned start and end of sections */
 	if ((dest & 3) || (len & 3))
--- a/src/lmi.c
+++ b/src/lmi.c
@ -31,9 +31,9 @@
 #include "adiv5.h"
 #include "target.h"

-static int lmi_flash_erase(struct target_s *target, uint32_t addr, int len);
+static int lmi_flash_erase(struct target_s *target, uint32_t addr, size_t len);
 static int lmi_flash_write(struct target_s *target, uint32_t dest,
-			  const uint8_t *src, int len);
+			  const uint8_t *src, size_t len);

 static const char lmi_driver_str[] = "TI Stellaris/Tiva";

@ -119,7 +119,7 @@ bool lmi_probe(struct target_s *target)
 	return false;
 }

-int lmi_flash_erase(struct target_s *target, uint32_t addr, int len)
+int lmi_flash_erase(struct target_s *target, uint32_t addr, size_t len)
 {
 	ADIv5_AP_t *ap = adiv5_target_ap(target);
 	uint32_t tmp;
@ -151,7 +151,7 @@ int lmi_flash_erase(struct target_s *target, uint32_t addr, int len)
 }

 int lmi_flash_write(struct target_s *target, uint32_t dest,
-			  const uint8_t *src, int len)
+                    const uint8_t *src, size_t len)
 {
 	uint32_t data[(len>>2)+2];
 	data[0] = dest;
--- a/src/lpc11xx.c
+++ b/src/lpc11xx.c
@ -63,9 +63,9 @@ static const char lpc8xx_driver[] = "lpc8xx";
 static const char lpc11xx_driver[] = "lpc11xx";
 static void lpc11x_iap_call(struct target_s *target, struct flash_param *param, unsigned param_len);
 static int lpc11xx_flash_prepare(struct target_s *target, uint32_t addr, int len);
-static int lpc11xx_flash_erase(struct target_s *target, uint32_t addr, int len);
+static int lpc11xx_flash_erase(struct target_s *target, uint32_t addr, size_t len);
 static int lpc11xx_flash_write(struct target_s *target, uint32_t dest, const uint8_t *src,
-			  int len);
+			  size_t len);

 /*
 * Note that this memory map is actually for the largest of the lpc11xx devices;
@ -220,7 +220,7 @@ lpc11xx_flash_prepare(struct target_s *target, uint32_t addr, int len)
 }

 static int
-lpc11xx_flash_erase(struct target_s *target, uint32_t addr, int len)
+lpc11xx_flash_erase(struct target_s *target, uint32_t addr, size_t len)
 {

 	if (addr % flash_page_size(target))
@ -249,7 +249,7 @@ lpc11xx_flash_erase(struct target_s *target, uint32_t addr, int len)
 }

 static int
-lpc11xx_flash_write(struct target_s *target, uint32_t dest, const uint8_t *src, int len)
+lpc11xx_flash_write(struct target_s *target, uint32_t dest, const uint8_t *src, size_t len)
 {
 	unsigned first_chunk = dest / IAP_PGM_CHUNKSIZE;
 	unsigned last_chunk = (dest + len - 1) / IAP_PGM_CHUNKSIZE;
@ -258,7 +258,7 @@ lpc11xx_flash_write(struct target_s *target, uint32_t dest, const uint8_t *src,

 	for (chunk = first_chunk; chunk <= last_chunk; chunk++) {

-		DEBUG("chunk %u len %d\n", chunk, len);
+		DEBUG("chunk %u len %zu\n", chunk, len);
 		/* first and last chunk may require special handling */
 		if ((chunk == first_chunk) || (chunk == last_chunk)) {

@ -266,7 +266,7 @@ lpc11xx_flash_write(struct target_s *target, uint32_t dest, const uint8_t *src,
 			memset(flash_pgm.data, 0xff, sizeof(flash_pgm.data));

 			/* copy as much as fits */
-			int copylen = IAP_PGM_CHUNKSIZE - chunk_offset;
+			size_t copylen = IAP_PGM_CHUNKSIZE - chunk_offset;
 			if (copylen > len)
 				copylen = len;
 			memcpy(&flash_pgm.data[chunk_offset], src, copylen);
--- a/src/lpc43xx.c
+++ b/src/lpc43xx.c
@ -127,9 +127,9 @@ static void lpc43xx_iap_call(struct target_s *target, struct flash_param *param,
                             unsigned param_len);
 static int lpc43xx_flash_prepare(struct target_s *target,
                                 uint32_t addr, int len);
-static int lpc43xx_flash_erase(struct target_s *target, uint32_t addr, int len);
+static int lpc43xx_flash_erase(struct target_s *target, uint32_t addr, size_t len);
 static int lpc43xx_flash_write(struct target_s *target,
-                               uint32_t dest, const uint8_t *src, int len);
+                               uint32_t dest, const uint8_t *src, size_t len);
 static void lpc43xx_set_internal_clock(struct target_s *target);
 static void lpc43xx_wdt_set_period(struct target_s *target);
 static void lpc43xx_wdt_pet(struct target_s *target);
@ -384,7 +384,7 @@ static int lpc43xx_flash_prepare(struct target_s *target, uint32_t addr, int len
 	return 0;
 }

-static int lpc43xx_flash_erase(struct target_s *target, uint32_t addr, int len)
+static int lpc43xx_flash_erase(struct target_s *target, uint32_t addr, size_t len)
 {
 	struct flash_program flash_pgm;

@ -433,7 +433,7 @@ static void lpc43xx_set_internal_clock(struct target_s *target)
 }

 static int lpc43xx_flash_write(struct target_s *target,
-                               uint32_t dest, const uint8_t *src, int len)
+                               uint32_t dest, const uint8_t *src, size_t len)
 {
 	unsigned first_chunk = dest / IAP_PGM_CHUNKSIZE;
 	unsigned last_chunk = (dest + len - 1) / IAP_PGM_CHUNKSIZE;
@ -455,7 +455,7 @@ static int lpc43xx_flash_write(struct target_s *target,
 			memset(flash_pgm.data, 0xff, sizeof(flash_pgm.data));

 			/* copy as much as fits */
-			int copylen = IAP_PGM_CHUNKSIZE - chunk_offset;
+			size_t copylen = IAP_PGM_CHUNKSIZE - chunk_offset;
 			if (copylen > len)
 				copylen = len;

--- a/src/nrf51.c
+++ b/src/nrf51.c
@ -27,9 +27,9 @@
 #include "command.h"
 #include "gdb_packet.h"

-static int nrf51_flash_erase(struct target_s *target, uint32_t addr, int len);
+static int nrf51_flash_erase(struct target_s *target, uint32_t addr, size_t len);
 static int nrf51_flash_write(struct target_s *target, uint32_t dest,
-			const uint8_t *src, int len);
+                             const uint8_t *src, size_t len);

 static bool nrf51_cmd_erase_all(target *t);
 static bool nrf51_cmd_read_hwid(target *t);
@ -163,7 +163,7 @@ bool nrf51_probe(struct target_s *target)
 	return false;
 }

-static int nrf51_flash_erase(struct target_s *target, uint32_t addr, int len)
+static int nrf51_flash_erase(struct target_s *target, uint32_t addr, size_t len)
 {

 	ADIv5_AP_t *ap = adiv5_target_ap(target);
@ -210,7 +210,7 @@ static int nrf51_flash_erase(struct target_s *target, uint32_t addr, int len)
 }

 static int nrf51_flash_write(struct target_s *target, uint32_t dest,
-			  const uint8_t *src, int len)
+                             const uint8_t *src, size_t len)
 {
 	ADIv5_AP_t *ap = adiv5_target_ap(target);
 	uint32_t offset = dest % 4;
--- a/src/platforms/libftdi/platform.c
+++ b/src/platforms/libftdi/platform.c
@ -121,7 +121,7 @@ void platform_init(int argc, char **argv)
 {
 	int err;
 	int c;
-	int index = 0;
+	unsigned index = 0;
 	char *serial = NULL;
 	char * cablename =  "ftdi";
 	uint8_t ftdi_init[9] = {TCK_DIVISOR, 0x01, 0x00, SET_BITS_LOW, 0,0,
--- a/src/sam3x.c
+++ b/src/sam3x.c
@ -28,9 +28,9 @@
 #include "command.h"
 #include "gdb_packet.h"

-static int sam3x_flash_erase(struct target_s *target, uint32_t addr, int len);
+static int sam3x_flash_erase(struct target_s *target, uint32_t addr, size_t len);
 static int sam3x_flash_write(struct target_s *target, uint32_t dest,
-			const uint8_t *src, int len);
+                             const uint8_t *src, size_t len);

 static bool sam3x_cmd_gpnvm_get(target *t);
 static bool sam3x_cmd_gpnvm_set(target *t, int argc, char *argv[]);
@ -285,7 +285,7 @@ sam3x_flash_base(struct target_s *target, uint32_t addr, uint32_t *offset)
 	return SAM3N_EEFC_BASE;
 }

-static int sam3x_flash_erase(struct target_s *target, uint32_t addr, int len)
+static int sam3x_flash_erase(struct target_s *target, uint32_t addr, size_t len)
 {
 	uint32_t offset;
 	uint32_t base = sam3x_flash_base(target, addr, &offset);
@ -341,7 +341,7 @@ static int sam3x_flash_erase(struct target_s *target, uint32_t addr, int len)
 }

 static int sam3x_flash_write(struct target_s *target, uint32_t dest,
-			  const uint8_t *src, int len)
+                             const uint8_t *src, size_t len)
 {
 	unsigned page_size;
 	if (strcmp(target->driver, "Atmel SAM4S") == 0) {
@ -359,7 +359,7 @@ static int sam3x_flash_write(struct target_s *target, uint32_t dest,

 	for (unsigned chunk = first_chunk; chunk <= last_chunk; chunk++) {

-		DEBUG("chunk %u len %d\n", chunk, len);
+		DEBUG("chunk %u len %zu\n", chunk, len);
 		/* first and last chunk may require special handling */
 		if ((chunk == first_chunk) || (chunk == last_chunk)) {

@ -367,7 +367,7 @@ static int sam3x_flash_write(struct target_s *target, uint32_t dest,
 			memset(buf, 0xff, sizeof(buf));

 			/* copy as much as fits */
-			int copylen = page_size - offset;
+			size_t copylen = page_size - offset;
 			if (copylen > len)
 				copylen = len;
 			memcpy(&buf[offset], src, copylen);
--- a/src/samd.c
+++ b/src/samd.c
@ -40,9 +40,9 @@
 #include "gdb_packet.h"
 #include "cortexm.h"

-static int samd_flash_erase(struct target_s *target, uint32_t addr, int len);
+static int samd_flash_erase(struct target_s *target, uint32_t addr, size_t len);
 static int samd_flash_write(struct target_s *target, uint32_t dest,
-			const uint8_t *src, int len);
+                            const uint8_t *src, size_t len);

 static bool samd_cmd_erase_all(target *t);
 static bool samd_cmd_lock_flash(target *t);
@ -479,7 +479,7 @@ static void samd_unlock_current_address(struct target_s *target)
 /**
 * Erase flash row by row
 */
-static int samd_flash_erase(struct target_s *target, uint32_t addr, int len)
+static int samd_flash_erase(struct target_s *target, uint32_t addr, size_t len)
 {
 	ADIv5_AP_t *ap = adiv5_target_ap(target);

@ -515,7 +515,7 @@ static int samd_flash_erase(struct target_s *target, uint32_t addr, int len)
 * Write flash page by page
 */
 static int samd_flash_write(struct target_s *target, uint32_t dest,
-			  const uint8_t *src, int len)
+                            const uint8_t *src, size_t len)
 {
 	ADIv5_AP_t *ap = adiv5_target_ap(target);

--- a/src/stm32f1.c
+++ b/src/stm32f1.c
@ -45,12 +45,12 @@ const struct command_s stm32f1_cmd_list[] = {
 };


-static int stm32md_flash_erase(struct target_s *target, uint32_t addr, int len);
-static int stm32hd_flash_erase(struct target_s *target, uint32_t addr, int len);
-static int stm32f1_flash_erase(struct target_s *target, uint32_t addr, int len,
+static int stm32md_flash_erase(struct target_s *target, uint32_t addr, size_t len);
+static int stm32hd_flash_erase(struct target_s *target, uint32_t addr, size_t len);
+static int stm32f1_flash_erase(struct target_s *target, uint32_t addr, size_t len,
 				uint32_t pagesize);
 static int stm32f1_flash_write(struct target_s *target, uint32_t dest,
-			const uint8_t *src, int len);
+                               const uint8_t *src, size_t len);

 static const char stm32f1_driver_str[] = "STM32, Medium density.";
 static const char stm32hd_driver_str[] = "STM32, High density.";
@ -229,7 +229,8 @@ static void stm32f1_flash_unlock(ADIv5_AP_t *ap)
 	adiv5_ap_mem_write(ap, FLASH_KEYR, KEY2);
 }

-static int stm32f1_flash_erase(struct target_s *target, uint32_t addr, int len, uint32_t pagesize)
+static int stm32f1_flash_erase(struct target_s *target, uint32_t addr,
+                               size_t len, uint32_t pagesize)
 {
 	ADIv5_AP_t *ap = adiv5_target_ap(target);
 	uint16_t sr;
@ -264,18 +265,18 @@ static int stm32f1_flash_erase(struct target_s *target, uint32_t addr, int len,
 	return 0;
 }

-static int stm32hd_flash_erase(struct target_s *target, uint32_t addr, int len)
+static int stm32hd_flash_erase(struct target_s *target, uint32_t addr, size_t len)
 {
 	return stm32f1_flash_erase(target, addr, len, 0x800);
 }

-static int stm32md_flash_erase(struct target_s *target, uint32_t addr, int len)
+static int stm32md_flash_erase(struct target_s *target, uint32_t addr, size_t len)
 {
 	return stm32f1_flash_erase(target, addr, len, 0x400);
 }

 static int stm32f1_flash_write(struct target_s *target, uint32_t dest,
-			  const uint8_t *src, int len)
+                               const uint8_t *src, size_t len)
 {
 	ADIv5_AP_t *ap = adiv5_target_ap(target);
 	uint32_t offset = dest % 4;
--- a/src/stm32f4.c
+++ b/src/stm32f4.c
@ -46,9 +46,9 @@ const struct command_s stm32f4_cmd_list[] = {
 };


-static int stm32f4_flash_erase(struct target_s *target, uint32_t addr, int len);
+static int stm32f4_flash_erase(struct target_s *target, uint32_t addr, size_t len);
 static int stm32f4_flash_write(struct target_s *target, uint32_t dest,
-			const uint8_t *src, int len);
+                               const uint8_t *src, size_t len);

 static const char stm32f4_driver_str[] = "STM32F4xx";

@ -189,7 +189,7 @@ static void stm32f4_flash_unlock(ADIv5_AP_t *ap)
 	}
 }

-static int stm32f4_flash_erase(struct target_s *target, uint32_t addr, int len)
+static int stm32f4_flash_erase(struct target_s *target, uint32_t addr, size_t len)
 {
 	ADIv5_AP_t *ap = adiv5_target_ap(target);
 	uint16_t sr;
@ -237,7 +237,7 @@ static int stm32f4_flash_erase(struct target_s *target, uint32_t addr, int len)
 }

 static int stm32f4_flash_write(struct target_s *target, uint32_t dest,
-			  const uint8_t *src, int len)
+                               const uint8_t *src, size_t len)
 {
 	ADIv5_AP_t *ap = adiv5_target_ap(target);
 	uint32_t offset = dest % 4;
--- a/src/stm32l0.c
+++ b/src/stm32l0.c
@ -125,32 +125,32 @@
 static int inhibit_stubs;       /* Local option to force non-stub flash IO */

 static int stm32lx_nvm_erase(struct target_s* target,
-                             uint32_t addr, int len);
+                             uint32_t addr, size_t len);
 static int stm32lx_nvm_write(struct target_s* target,
                             uint32_t destination,
                             const uint8_t* source,
-                             int size);
+                             size_t size);

 static int stm32lx_nvm_prog_erase(struct target_s* target,
-                                  uint32_t addr, int len);
+                                  uint32_t addr, size_t len);
 static int stm32lx_nvm_prog_write(struct target_s* target,
                                  uint32_t destination,
                                  const uint8_t* source,
-                                  int size);
+                                  size_t size);

 static int stm32lx_nvm_prog_erase_stubbed(struct target_s* target,
-                                          uint32_t addr, int len);
+                                          uint32_t addr, size_t len);
 static int stm32lx_nvm_prog_write_stubbed(struct target_s* target,
                                          uint32_t destination,
                                          const uint8_t* source,
-                                          int size);
+                                          size_t size);

 static int stm32lx_nvm_data_erase(struct target_s* target,
-                                  uint32_t addr, int len);
+                                  uint32_t addr, size_t len);
 static int stm32lx_nvm_data_write(struct target_s* target,
                                  uint32_t destination,
                                  const uint8_t* source,
-                                  int size);
+                                  size_t size);

 static bool stm32lx_cmd_option     (target* t, int argc, char** argv);
 static bool stm32lx_cmd_eeprom     (target* t, int argc, char** argv);
@ -371,7 +371,7 @@ static bool stm32lx_nvm_opt_unlock(ADIv5_AP_t* ap, uint32_t nvm)
    when the MCU hasn't entered a fault state(see NOTES).  The flash
    array is erased for all pages from addr to addr+len inclusive. */
 static int stm32lx_nvm_prog_erase_stubbed(struct target_s* target,
-                                          uint32_t addr, int size)
+                                          uint32_t addr, size_t size)
 {
        struct stm32lx_nvm_stub_info info;
        const uint32_t nvm = stm32lx_nvm_phys(target);
@ -417,7 +417,7 @@ static int stm32lx_nvm_prog_erase_stubbed(struct target_s* target,
 static int stm32lx_nvm_prog_write_stubbed(struct target_s* target,
                                          uint32_t destination,
                                          const uint8_t* source,
-                                          int size)
+                                          size_t size)
 {
        struct stm32lx_nvm_stub_info info;
        const uint32_t nvm = stm32lx_nvm_phys(target);
@ -491,7 +491,7 @@ static int stm32lx_nvm_prog_write_stubbed(struct target_s* target,
 /** Erase a region of NVM for STM32Lx.  This is the lead function and
    it will invoke an implementation, stubbed or not depending on the
    options and the range of addresses. */
-static int stm32lx_nvm_erase(struct target_s* target, uint32_t addr, int size)
+static int stm32lx_nvm_erase(struct target_s* target, uint32_t addr, size_t size)
 {
        if (addr >= STM32Lx_NVM_EEPROM_PHYS)
                return stm32lx_nvm_data_erase(target, addr, size);
@ -515,7 +515,7 @@ static int stm32lx_nvm_erase(struct target_s* target, uint32_t addr, int size)
 static int stm32lx_nvm_write(struct target_s* target,
                             uint32_t destination,
                             const uint8_t* source,
-                             int size)
+                             size_t size)
 {
        if (destination >= STM32Lx_NVM_EEPROM_PHYS)
                return stm32lx_nvm_data_write(target, destination, source,
@ -556,7 +556,7 @@ static int stm32lx_nvm_write(struct target_s* target,
    flash array is erased for all pages from addr to addr+len
    inclusive.  NVM register file address chosen from target. */
 static int stm32lx_nvm_prog_erase(struct target_s* target,
-                                  uint32_t addr, int len)
+                                  uint32_t addr, size_t len)
 {
        ADIv5_AP_t* ap = adiv5_target_ap(target);
        const size_t page_size = stm32lx_nvm_prog_page_size(target);
@ -617,7 +617,7 @@ static int stm32lx_nvm_prog_erase(struct target_s* target,
 static int stm32lx_nvm_prog_write(struct target_s* target,
                                  uint32_t destination,
                                  const uint8_t* source_8,
-                                  int size)
+                                  size_t size)
 {
        ADIv5_AP_t*    ap         = adiv5_target_ap(target);
        const uint32_t nvm        = stm32lx_nvm_phys(target);
@ -705,7 +705,7 @@ static int stm32lx_nvm_prog_write(struct target_s* target,
    addr+len, inclusive, on a word boundary.  NVM register file
    address chosen from target. */
 static int stm32lx_nvm_data_erase(struct target_s* target,
-                                  uint32_t addr, int len)
+                                  uint32_t addr, size_t len)
 {
        ADIv5_AP_t* ap = adiv5_target_ap(target);
        const size_t page_size = stm32lx_nvm_data_page_size(target);
@ -763,7 +763,7 @@ static int stm32lx_nvm_data_erase(struct target_s* target,
 static int stm32lx_nvm_data_write(struct target_s* target,
                                  uint32_t destination,
                                  const uint8_t* source_8,
-                                  int size)
+                                  size_t size)
 {
        ADIv5_AP_t*    ap         = adiv5_target_ap(target);
        const uint32_t nvm        = stm32lx_nvm_phys(target);
@ -933,7 +933,7 @@ static bool stm32lx_cmd_option(target* t, int argc, char** argv)
                goto usage;

        /* Report the current option values */
-        for(int i = 0; i < opt_size; i += sizeof(uint32_t)) {
+        for(unsigned i = 0; i < opt_size; i += sizeof(uint32_t)) {
                uint32_t addr = STM32Lx_NVM_OPT_PHYS + i;
                uint32_t val = adiv5_ap_mem_read(ap, addr);
                gdb_outf("0x%08x: 0x%04x 0x%04x %s\n",
--- a/src/stm32l1.c
+++ b/src/stm32l1.c
@ -35,9 +35,10 @@
 #include "command.h"
 #include "gdb_packet.h"

-static int stm32l1_flash_erase(struct target_s *target, uint32_t addr, int len);
+static int stm32l1_flash_erase(struct target_s *target, uint32_t addr,
+                               size_t len);
 static int stm32l1_flash_write(struct target_s *target, uint32_t dest,
-			const uint8_t *src, int len);
+                               const uint8_t *src, size_t len);

 static const char stm32l1_driver_str[] = "STM32L1xx";

@ -112,7 +113,7 @@ static void stm32l1_flash_unlock(ADIv5_AP_t *ap)
 	adiv5_ap_mem_write(ap, STM32L1_FLASH_PRGKEYR, STM32L1_PRGKEY2);
 }

-static int stm32l1_flash_erase(struct target_s *target, uint32_t addr, int len)
+static int stm32l1_flash_erase(struct target_s *target, uint32_t addr, size_t len)
 {
 	ADIv5_AP_t *ap = adiv5_target_ap(target);
 	uint16_t sr;
@ -150,7 +151,7 @@ static int stm32l1_flash_erase(struct target_s *target, uint32_t addr, int len)
 }

 static int stm32l1_flash_write(struct target_s *target, uint32_t dest,
-			  const uint8_t *src, int len)
+			  const uint8_t *src, size_t len)
 {
 	ADIv5_AP_t *ap = adiv5_target_ap(target);
 	uint16_t sr;