Fix some C99 format specifiers

[openocd.git] / src / flash / nor / at91samd.c

diff --git a/src/flash/nor/at91samd.c b/src/flash/nor/at91samd.c
index 5af61ab4ddcc337e5a64a1ac37bf340b2884aaab..17bc8b99cbcafed2b6bee3a609a32580e99a4576 100644 (file)
--- a/src/flash/nor/at91samd.c
+++ b/src/flash/nor/at91samd.c
@@ -26,7 +26,7 @@
 
 #define SAMD_NUM_SECTORS       16
 
-#define SAMD_FLASH                     0x00000000      /* physical Flash memory */
+#define SAMD_FLASH                     ((uint32_t)0x00000000)  /* physical Flash memory */
 #define SAMD_DSU                       0x41002000      /* Device Service Unit */
 #define SAMD_NVMCTRL           0x41004000      /* Non-volatile memory controller */
 
@@ -218,7 +218,7 @@ static int samd_probe(struct flash_bank *bank)
         * multiplied by the number of pages. */
        if (bank->size != chip->num_pages * chip->page_size) {
                LOG_WARNING("SAMD: bank size doesn't match NVM parameters. "
-                               "Identified %uKB Flash but NVMCTRL reports %u %uB pages",
+                               "Identified %" PRIu32 "KB Flash but NVMCTRL reports %u %" PRIu32 "B pages",
                                part->flash_kb, chip->num_pages, chip->page_size);
        }
 
@@ -243,7 +243,7 @@ static int samd_probe(struct flash_bank *bank)
        /* Done */
        chip->probed = true;
 
-       LOG_INFO("SAMD MCU: %s (%uKB Flash, %uKB RAM)", part->name,
+       LOG_INFO("SAMD MCU: %s (%" PRIu32 "KB Flash, %" PRIu32 "KB RAM)", part->name,
                        part->flash_kb, part->ram_kb);
 
        return ERROR_OK;
@@ -254,24 +254,33 @@ static int samd_protect(struct flash_bank *bank, int set, int first, int last)
        int res;
        struct samd_info *chip = (struct samd_info *)bank->driver_priv;
 
+       res = ERROR_OK;
+
        for (int s = first; s <= last; s++) {
-               /* Load an address that is within this sector (we use offset 0) */
-               res = target_write_u32(bank->target, SAMD_NVMCTRL + SAMD_NVMCTRL_ADDR,
-                               s * chip->sector_size);
-               if (res != ERROR_OK)
-                       return res;
+               if (set != bank->sectors[s].is_protected) {
+                       /* Load an address that is within this sector (we use offset 0) */
+                       res = target_write_u32(bank->target, SAMD_NVMCTRL + SAMD_NVMCTRL_ADDR,
+                                              s * chip->sector_size);
+                       if (res != ERROR_OK)
+                               goto exit;
 
-               /* Tell the controller to lock that sector */
-               res = target_write_u16(bank->target,
-                               SAMD_NVMCTRL + SAMD_NVMCTRL_CTRLA,
-                               SAMD_NVM_CMD(SAMD_NVM_CMD_LR));
-               if (res != ERROR_OK)
-                       return res;
-       }
+                       /* Tell the controller to lock that sector */
+
+                       uint16_t cmd = (set) ?
+                               SAMD_NVM_CMD(SAMD_NVM_CMD_LR) :
+                               SAMD_NVM_CMD(SAMD_NVM_CMD_UR);
 
+                       res = target_write_u16(bank->target,
+                                              SAMD_NVMCTRL + SAMD_NVMCTRL_CTRLA,
+                                              cmd);
+                       if (res != ERROR_OK)
+                               goto exit;
+               }
+       }
+exit:
        samd_protect_check(bank);
 
-       return ERROR_OK;
+       return res;
 }
 
 static bool samd_check_error(struct flash_bank *bank)
@@ -328,7 +337,7 @@ static int samd_erase_row(struct flash_bank *bank, uint32_t address)
        }
 
        if (res != ERROR_OK || error)  {
-               LOG_ERROR("Failed to erase row containing %08X" PRIx32, address);
+               LOG_ERROR("Failed to erase row containing %08" PRIx32, address);
                return ERROR_FAIL;
        }
 
@@ -352,13 +361,6 @@ static int samd_erase(struct flash_bank *bank, int first, int last)
                        return ERROR_FLASH_BANK_NOT_PROBED;
        }
 
-       /* Make sure the sectors make sense. */
-       if (first >= bank->num_sectors || last >= bank->num_sectors) {
-               LOG_ERROR("Erase range %d - %d not valid (%d sectors total)",
-                               first, last, bank->num_sectors);
-               return ERROR_FAIL;
-       }
-
        /* The SAMD NVM has row erase granularity.  There are four pages in a row
         * and the number of rows in a sector depends on the sector size, which in
         * turn depends on the Flash capacity as there is a fixed number of
@@ -367,21 +369,40 @@ static int samd_erase(struct flash_bank *bank, int first, int last)
 
        /* For each sector to be erased */
        for (int s = first; s <= last; s++) {
-               /* For each row in that sector */
-               for (int r = s * rows_in_sector; r < (s + 1) * rows_in_sector; r++) {
-                       res = samd_erase_row(bank, r * chip->page_size * 4);
-                       if (res != ERROR_OK) {
-                               LOG_ERROR("SAMD: failed to erase sector %d", s);
-                               return res;
-                       }
+               if (bank->sectors[s].is_protected) {
+                       LOG_ERROR("SAMD: failed to erase sector %d. That sector is write-protected", s);
+                       return ERROR_FLASH_OPERATION_FAILED;
                }
 
-               bank->sectors[s].is_erased = 1;
+               if (!bank->sectors[s].is_erased) {
+                       /* For each row in that sector */
+                       for (int r = s * rows_in_sector; r < (s + 1) * rows_in_sector; r++) {
+                               res = samd_erase_row(bank, r * chip->page_size * 4);
+                               if (res != ERROR_OK) {
+                                       LOG_ERROR("SAMD: failed to erase sector %d", s);
+                                       return res;
+                               }
+                       }
+
+                       bank->sectors[s].is_erased = 1;
+               }
        }
 
        return ERROR_OK;
 }
 
+static struct flash_sector *samd_find_sector_by_address(struct flash_bank *bank, uint32_t address)
+{
+       struct samd_info *chip = (struct samd_info *)bank->driver_priv;
+
+       for (int i = 0; i < bank->num_sectors; i++) {
+               if (bank->sectors[i].offset <= address &&
+                   address < bank->sectors[i].offset + chip->sector_size)
+                       return &bank->sectors[i];
+       }
+       return NULL;
+}
+
 /* Write an entire row (four pages) from host buffer 'buf' to row-aligned
  * 'address' in the Flash. */
 static int samd_write_row(struct flash_bank *bank, uint32_t address,
@@ -390,6 +411,18 @@ static int samd_write_row(struct flash_bank *bank, uint32_t address,
        int res;
        struct samd_info *chip = (struct samd_info *)bank->driver_priv;
 
+       struct flash_sector *sector = samd_find_sector_by_address(bank, address);
+
+       if (!sector) {
+               LOG_ERROR("Can't find sector corresponding to address 0x%08" PRIx32, address);
+               return ERROR_FLASH_OPERATION_FAILED;
+       }
+
+       if (sector->is_protected) {
+               LOG_ERROR("Trying to write to a protected sector at 0x%08" PRIx32, address);
+               return ERROR_FLASH_OPERATION_FAILED;
+       }
+
        /* Erase the row that we'll be writing to */
        res = samd_erase_row(bank, address);
        if (res != ERROR_OK)
@@ -418,6 +451,8 @@ static int samd_write_row(struct flash_bank *bank, uint32_t address,
                buf += chip->page_size;
        }
 
+       sector->is_erased = 0;
+
        return res;
 }