Code Review / openocd.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
- Fixes '+' whitespace
[openocd.git] / src / flash / mflash.c
diff --git a/src/flash/mflash.c b/src/flash/mflash.c
index 39a6ca85a7caace53a1b0ef3143657b861d54b5a..25b9f0962ba543c67d68e2d2a9eeb757089ed118 100644 (file)
--- a/src/flash/mflash.c
+++ b/src/flash/mflash.c
@@ -66,7 +66,7 @@ static mflash_gpio_drv_t *mflash_gpio[] =
 
 static int pxa270_set_gpio_to_output (mflash_gpio_num_t gpio)
 {
-       u32 addr, value, mask;
+       uint32_t addr, value, mask;
        target_t *target = mflash_bank->target;
        int ret;
 
@@ -103,7 +103,7 @@ static int pxa270_set_gpio_to_output (mflash_gpio_num_t gpio)
 
 static int pxa270_set_gpio_output_val (mflash_gpio_num_t gpio, uint8_t val)
 {
-       u32 addr, value, mask;
+       uint32_t addr, value, mask;
        target_t *target = mflash_bank->target;
        int ret;
 
@@ -132,7 +132,7 @@ static int pxa270_set_gpio_output_val (mflash_gpio_num_t gpio, uint8_t val)
 
 static int s3c2440_set_gpio_to_output (mflash_gpio_num_t gpio)
 {
-       u32 data, mask, gpio_con;
+       uint32_t data, mask, gpio_con;
        target_t *target = mflash_bank->target;
        int ret;
 
@@ -164,7 +164,7 @@ static int s3c2440_set_gpio_to_output (mflash_gpio_num_t gpio)
 
 static int s3c2440_set_gpio_output_val (mflash_gpio_num_t gpio, uint8_t val)
 {
-       u32 data, mask, gpio_dat;
+       uint32_t data, mask, gpio_dat;
        target_t *target = mflash_bank->target;
        int ret;
 
@@ -210,14 +210,14 @@ static int mg_init_gpio (void)
        return ret;
 }
 
-static int mg_dsk_wait(mg_io_type_wait wait, u32 time)
+static int mg_dsk_wait(mg_io_type_wait wait, uint32_t time)
 {
        uint8_t status, error;
        target_t *target = mflash_bank->target;
-       u32 mg_task_reg = mflash_bank->base + MG_REG_OFFSET;
+       uint32_t mg_task_reg = mflash_bank->base + MG_REG_OFFSET;
        duration_t duration;
        int ret;
-       long long t=0;
+       long long t = 0;
 
        duration_start_measure(&duration);
 
@@ -232,7 +232,7 @@ static int mg_dsk_wait(mg_io_type_wait wait, u32 time)
                        if (wait == mg_io_wait_bsy)
                                return ERROR_OK;
                } else {
-                       switch(wait)
+                       switch (wait)
                        {
                                case mg_io_wait_not_bsy:
                                        return ERROR_OK;
@@ -277,8 +277,8 @@ static int mg_dsk_wait(mg_io_type_wait wait, u32 time)
 
                duration_stop_measure(&duration, NULL);
 
-               t=duration.duration.tv_usec/1000;
-               t+=duration.duration.tv_sec*1000;
+               t = duration.duration.tv_usec/1000;
+               t += duration.duration.tv_sec*1000;
 
                if (t > time)
                        break;
@@ -291,14 +291,14 @@ static int mg_dsk_wait(mg_io_type_wait wait, u32 time)
 static int mg_dsk_srst(uint8_t on)
 {
        target_t *target = mflash_bank->target;
-       u32 mg_task_reg = mflash_bank->base + MG_REG_OFFSET;
+       uint32_t mg_task_reg = mflash_bank->base + MG_REG_OFFSET;
        uint8_t value;
        int ret;
 
        if ((ret = target_read_u8(target, mg_task_reg + MG_REG_DRV_CTRL, &value)) != ERROR_OK)
                return ret;
 
-       if(on) {
+       if (on) {
                value |= (mg_io_rbit_devc_srst);
        } else {
                value &= ~mg_io_rbit_devc_srst;
@@ -308,10 +308,10 @@ static int mg_dsk_srst(uint8_t on)
        return ret;
 }
 
-static int mg_dsk_io_cmd(u32 sect_num, u32 cnt, uint8_t cmd)
+static int mg_dsk_io_cmd(uint32_t sect_num, uint32_t cnt, uint8_t cmd)
 {
        target_t *target = mflash_bank->target;
-       u32 mg_task_reg = mflash_bank->base + MG_REG_OFFSET;
+       uint32_t mg_task_reg = mflash_bank->base + MG_REG_OFFSET;
        uint8_t value;
        int ret;
 
@@ -336,7 +336,7 @@ static int mg_dsk_io_cmd(u32 sect_num, u32 cnt, uint8_t cmd)
 static int mg_dsk_drv_info(void)
 {
        target_t *target = mflash_bank->target;
-       u32 mg_buff = mflash_bank->base + MG_BUFFER_OFFSET;
+       uint32_t mg_buff = mflash_bank->base + MG_BUFFER_OFFSET;
        int ret;
 
        if ((ret =  mg_dsk_io_cmd(0, 1, mg_io_cmd_identify)) != ERROR_OK)
@@ -355,7 +355,7 @@ static int mg_dsk_drv_info(void)
        if (ret != ERROR_OK)
                return ret;
 
-       mflash_bank->drv_info->tot_sects = (u32)(mflash_bank->drv_info->drv_id.total_user_addressable_sectors_hi << 16)
+       mflash_bank->drv_info->tot_sects = (uint32_t)(mflash_bank->drv_info->drv_id.total_user_addressable_sectors_hi << 16)
                                                                        + mflash_bank->drv_info->drv_id.total_user_addressable_sectors_lo;
 
        return target_write_u8(target, mflash_bank->base + MG_REG_OFFSET + MG_REG_COMMAND, mg_io_cmd_confirm_read);
@@ -414,16 +414,16 @@ static int mg_probe_cmd(struct command_context_s *cmd_ctx, char *cmd, char **arg
        ret = mg_mflash_probe();
 
        if (ret == ERROR_OK) {
-               command_print(cmd_ctx, "mflash (total %u sectors) found at 0x%8.8x",
+               command_print(cmd_ctx, "mflash (total %" PRIu32 " sectors) found at 0x%8.8" PRIx32 "",
                                mflash_bank->drv_info->tot_sects, mflash_bank->base );
        }
 
        return ret;
 }
 
-static int mg_mflash_do_read_sects(void *buff, u32 sect_num, u32 sect_cnt)
+static int mg_mflash_do_read_sects(void *buff, uint32_t sect_num, uint32_t sect_cnt)
 {
-       u32 i, address;
+       uint32_t i, address;
        int ret;
        target_t *target = mflash_bank->target;
        uint8_t *buff_ptr = buff;
@@ -451,12 +451,12 @@ static int mg_mflash_do_read_sects(void *buff, u32 sect_num, u32 sect_cnt)
                if (ret != ERROR_OK)
                        return ret;
 
-               LOG_DEBUG("mflash: %u (0x%8.8x) sector read", sect_num + i, (sect_num + i) * MG_MFLASH_SECTOR_SIZE);
+               LOG_DEBUG("mflash: %" PRIu32 " (0x%8.8" PRIx32 ") sector read", sect_num + i, (sect_num + i) * MG_MFLASH_SECTOR_SIZE);
 
                duration_stop_measure(&duration, NULL);
 
                if ((duration.duration.tv_sec * 1000 + duration.duration.tv_usec / 1000) > 3000) {
-                       LOG_INFO("mflash: read %u'th sectors", sect_num + i);
+                       LOG_INFO("mflash: read %" PRIu32 "'th sectors", sect_num + i);
                        duration_start_measure(&duration);
                }
        }
@@ -464,9 +464,9 @@ static int mg_mflash_do_read_sects(void *buff, u32 sect_num, u32 sect_cnt)
        return mg_dsk_wait(mg_io_wait_rdy, MG_OEM_DISK_WAIT_TIME_NORMAL);
 }
 
-static int mg_mflash_read_sects(void *buff, u32 sect_num, u32 sect_cnt)
+static int mg_mflash_read_sects(void *buff, uint32_t sect_num, uint32_t sect_cnt)
 {
-       u32 quotient, residue, i;
+       uint32_t quotient, residue, i;
        uint8_t *buff_ptr = buff;
        int ret = ERROR_OK;
 
@@ -474,7 +474,7 @@ static int mg_mflash_read_sects(void *buff, u32 sect_num, u32 sect_cnt)
        residue = sect_cnt % 256;
 
        for (i = 0; i < quotient; i++) {
-               LOG_DEBUG("mflash: sect num : %u buff : 0x%0lx", sect_num, 
+               LOG_DEBUG("mflash: sect num : %" PRIu32 " buff : 0x%0lx", sect_num, 
                        (unsigned long)buff_ptr);
                ret = mg_mflash_do_read_sects(buff_ptr, sect_num, 256);
                if (ret != ERROR_OK)
@@ -485,7 +485,7 @@ static int mg_mflash_read_sects(void *buff, u32 sect_num, u32 sect_cnt)
        }
 
        if (residue) {
-               LOG_DEBUG("mflash: sect num : %u buff : %0lx", sect_num, 
+               LOG_DEBUG("mflash: sect num : %" PRIx32 " buff : %0lx", sect_num, 
                        (unsigned long)buff_ptr);
                return mg_mflash_do_read_sects(buff_ptr, sect_num, residue);
        }
@@ -493,10 +493,10 @@ static int mg_mflash_read_sects(void *buff, u32 sect_num, u32 sect_cnt)
        return ret;
 }
 
-static int mg_mflash_do_write_sects(void *buff, u32 sect_num, u32 sect_cnt,
+static int mg_mflash_do_write_sects(void *buff, uint32_t sect_num, uint32_t sect_cnt,
                mg_io_type_cmd cmd)
 {
-       u32 i, address;
+       uint32_t i, address;
        int ret;
        target_t *target = mflash_bank->target;
        uint8_t *buff_ptr = buff;
@@ -524,12 +524,12 @@ static int mg_mflash_do_write_sects(void *buff, u32 sect_num, u32 sect_cnt,
                if (ret != ERROR_OK)
                        return ret;
 
-               LOG_DEBUG("mflash: %u (0x%8.8x) sector write", sect_num + i, (sect_num + i) * MG_MFLASH_SECTOR_SIZE);
+               LOG_DEBUG("mflash: %" PRIu32 " (0x%8.8" PRIx32 ") sector write", sect_num + i, (sect_num + i) * MG_MFLASH_SECTOR_SIZE);
 
                duration_stop_measure(&duration, NULL);
 
                if ((duration.duration.tv_sec * 1000 + duration.duration.tv_usec / 1000) > 3000) {
-                       LOG_INFO("mflash: wrote %u'th sectors", sect_num + i);
+                       LOG_INFO("mflash: wrote %" PRIu32 "'th sectors", sect_num + i);
                        duration_start_measure(&duration);
                }
        }
@@ -542,9 +542,9 @@ static int mg_mflash_do_write_sects(void *buff, u32 sect_num, u32 sect_cnt,
        return ret;
 }
 
-static int mg_mflash_write_sects(void *buff, u32 sect_num, u32 sect_cnt)
+static int mg_mflash_write_sects(void *buff, uint32_t sect_num, uint32_t sect_cnt)
 {
-       u32 quotient, residue, i;
+       uint32_t quotient, residue, i;
        uint8_t *buff_ptr = buff;
        int ret = ERROR_OK;
 
@@ -552,8 +552,8 @@ static int mg_mflash_write_sects(void *buff, u32 sect_num, u32 sect_cnt)
        residue = sect_cnt % 256;
 
        for (i = 0; i < quotient; i++) {
-               LOG_DEBUG("mflash: sect num : %u buff : %0lx", sect_num, 
-                       (unsigned long)buff_ptr);
+               LOG_DEBUG("mflash: sect num : %" PRIu32 "buff : %p", sect_num, 
+                       buff_ptr);
                ret = mg_mflash_do_write_sects(buff_ptr, sect_num, 256, mg_io_cmd_write);
                if (ret != ERROR_OK)
                        return ret;
@@ -563,19 +563,19 @@ static int mg_mflash_write_sects(void *buff, u32 sect_num, u32 sect_cnt)
        }
 
        if (residue) {
-               LOG_DEBUG("mflash: sect num : %u buff : %0lx", sect_num, 
-                       (unsigned long)buff_ptr);
+               LOG_DEBUG("mflash: sect num : %" PRIu32 " buff : %p", sect_num, 
+                       buff_ptr);
                return mg_mflash_do_write_sects(buff_ptr, sect_num, residue, mg_io_cmd_write);
        }
 
        return ret;
 }
 
-static int mg_mflash_read (u32 addr, uint8_t *buff, u32 len)
+static int mg_mflash_read (uint32_t addr, uint8_t *buff, uint32_t len)
 {
        uint8_t *buff_ptr = buff;
        uint8_t sect_buff[MG_MFLASH_SECTOR_SIZE];
-       u32 cur_addr, next_sec_addr, end_addr, cnt, sect_num;
+       uint32_t cur_addr, next_sec_addr, end_addr, cnt, sect_num;
        int ret = ERROR_OK;
 
        cnt = 0;
@@ -592,11 +592,11 @@ static int mg_mflash_read (u32 addr, uint8_t *buff, u32 len)
 
                if (end_addr < next_sec_addr) {
                        memcpy(buff_ptr, sect_buff + (cur_addr & MG_MFLASH_SECTOR_SIZE_MASK), end_addr - cur_addr);
-                       LOG_DEBUG("mflash: copies %u byte from sector offset 0x%8.8x", end_addr - cur_addr, cur_addr);
+                       LOG_DEBUG("mflash: copies %" PRIu32 " byte from sector offset 0x%8.8" PRIx32 "", end_addr - cur_addr, cur_addr);
                        cur_addr = end_addr;
                } else {
                        memcpy(buff_ptr, sect_buff + (cur_addr & MG_MFLASH_SECTOR_SIZE_MASK), next_sec_addr - cur_addr);
-                       LOG_DEBUG("mflash: copies %u byte from sector offset 0x%8.8x", next_sec_addr - cur_addr, cur_addr);
+                       LOG_DEBUG("mflash: copies %" PRIu32 " byte from sector offset 0x%8.8" PRIx32 "", next_sec_addr - cur_addr, cur_addr);
                        buff_ptr += (next_sec_addr - cur_addr);
                        cur_addr = next_sec_addr;
                }
@@ -627,7 +627,7 @@ static int mg_mflash_read (u32 addr, uint8_t *buff, u32 len)
                                return ret;
 
                        memcpy(buff_ptr, sect_buff, end_addr - cur_addr);
-                       LOG_DEBUG("mflash: copies %u byte", end_addr - cur_addr);
+                       LOG_DEBUG("mflash: copies %u byte", (unsigned)(end_addr - cur_addr));
 
                }
        }
@@ -635,11 +635,11 @@ static int mg_mflash_read (u32 addr, uint8_t *buff, u32 len)
        return ret;
 }
 
-static int mg_mflash_write(u32 addr, uint8_t *buff, u32 len)
+static int mg_mflash_write(uint32_t addr, uint8_t *buff, uint32_t len)
 {
        uint8_t *buff_ptr = buff;
        uint8_t sect_buff[MG_MFLASH_SECTOR_SIZE];
-       u32 cur_addr, next_sec_addr, end_addr, cnt, sect_num;
+       uint32_t cur_addr, next_sec_addr, end_addr, cnt, sect_num;
        int ret = ERROR_OK;
 
        cnt = 0;
@@ -656,11 +656,11 @@ static int mg_mflash_write(u32 addr, uint8_t *buff, u32 len)
 
                if (end_addr < next_sec_addr) {
                        memcpy(sect_buff + (cur_addr & MG_MFLASH_SECTOR_SIZE_MASK), buff_ptr, end_addr - cur_addr);
-                       LOG_DEBUG("mflash: copies %u byte to sector offset 0x%8.8x", end_addr - cur_addr, cur_addr);
+                       LOG_DEBUG("mflash: copies %" PRIu32 " byte to sector offset 0x%8.8" PRIx32 "", end_addr - cur_addr, cur_addr);
                        cur_addr = end_addr;
                } else {
                        memcpy(sect_buff + (cur_addr & MG_MFLASH_SECTOR_SIZE_MASK), buff_ptr, next_sec_addr - cur_addr);
-                       LOG_DEBUG("mflash: copies %u byte to sector offset 0x%8.8x", next_sec_addr - cur_addr, cur_addr);
+                       LOG_DEBUG("mflash: copies %" PRIu32 " byte to sector offset 0x%8.8" PRIx32 "", next_sec_addr - cur_addr, cur_addr);
                        buff_ptr += (next_sec_addr - cur_addr);
                        cur_addr = next_sec_addr;
                }
@@ -695,7 +695,7 @@ static int mg_mflash_write(u32 addr, uint8_t *buff, u32 len)
                                return ret;
 
                        memcpy(sect_buff, buff_ptr, end_addr - cur_addr);
-                       LOG_DEBUG("mflash: copies %u byte", end_addr - cur_addr);
+                       LOG_DEBUG("mflash: copies %" PRIu32 " byte", end_addr - cur_addr);
                        ret = mg_mflash_write_sects(sect_buff, sect_num, 1);
                }
        }
@@ -705,7 +705,7 @@ static int mg_mflash_write(u32 addr, uint8_t *buff, u32 len)
 
 static int mg_write_cmd(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
-       u32 address, buf_cnt, cnt, res, i;
+       uint32_t address, buf_cnt, cnt, res, i;
        uint8_t *buffer;
        fileio_t fileio;
        duration_t duration;
@@ -772,7 +772,7 @@ mg_write_cmd_err:
 
 static int mg_dump_cmd(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
-       u32 address, size_written, size, cnt, res, i;
+       uint32_t address, size_written, size, cnt, res, i;
        uint8_t *buffer;
        fileio_t fileio;
        duration_t duration;
@@ -819,7 +819,7 @@ static int mg_dump_cmd(struct command_context_s *cmd_ctx, char *cmd, char **args
 
        duration_stop_measure(&duration, &duration_text);
 
-       command_print(cmd_ctx, "dump image (address 0x%8.8x size %u) to file %s in %s (%f kB/s)",
+       command_print(cmd_ctx, "dump image (address 0x%8.8" PRIx32 " size %" PRIu32 ") to file %s in %s (%f kB/s)",
                                address, size, args[1], duration_text,
                                (float)size / 1024.0 / ((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0)));
 
@@ -841,7 +841,7 @@ mg_dump_cmd_err:
 static int mg_set_feature(mg_feature_id feature, mg_feature_val config)
 {
        target_t *target = mflash_bank->target;
-       u32 mg_task_reg = mflash_bank->base + MG_REG_OFFSET;
+       uint32_t mg_task_reg = mflash_bank->base + MG_REG_OFFSET;
        int ret;
 
        if ((ret = mg_dsk_wait(mg_io_wait_rdy_noerr, MG_OEM_DISK_WAIT_TIME_NORMAL))
@@ -871,7 +871,7 @@ static int mg_pll_get_M(unsigned short feedback_div)
 {
        int i, M;
 
-       for (i = 1, M=0; i < 512; i <<= 1, feedback_div >>= 1)
+       for (i = 1, M = 0; i < 512; i <<= 1, feedback_div >>= 1)
                M += (feedback_div & 1) * i;
 
        return M + 2;
@@ -892,7 +892,7 @@ static int mg_pll_get_NO(unsigned char  output_div)
        int i, NO;
 
        for (i = 0, NO = 1; i < 2; ++i, output_div >>= 1)
-               if(output_div & 1)
+               if (output_div & 1)
                        NO = NO << 1;
 
        return NO;
@@ -923,7 +923,7 @@ static double mg_do_calc_pll(double XIN, mg_pll_t * p_pll_val, int is_approximat
 
                                CLK_OUT = XIN * ((double)M / N) / NO;
 
-                               if ((int)((CLK_OUT+ROUND) / DIV)
+                               if ((int)((CLK_OUT + ROUND) / DIV)
                                                == (int)(MG_PLL_CLK_OUT / DIV)) {
                                        if (mg_is_valid_pll(XIN, N, CLK_OUT, NO) == ERROR_OK)
                                        {
@@ -956,9 +956,9 @@ static double mg_calc_pll(double XIN, mg_pll_t *p_pll_val)
 
 static int mg_verify_interface(void)
 {
-       u16 buff[MG_MFLASH_SECTOR_SIZE >> 1];
-       u16 i, j;
-       u32 address = mflash_bank->base + MG_BUFFER_OFFSET;
+       uint16_t buff[MG_MFLASH_SECTOR_SIZE >> 1];
+       uint16_t i, j;
+       uint32_t address = mflash_bank->base + MG_BUFFER_OFFSET;
        target_t *target = mflash_bank->target;
        int ret;
 
@@ -1152,7 +1152,7 @@ static int mg_boot_config(void)
        buff[0] = mg_op_mode_snd;               /* operation mode */
        buff[1] = MG_UNLOCK_OTP_AREA;
        buff[2] = 4;                            /* boot size */
-       *((u32 *)(buff + 4)) = 0;               /* XIP size */
+       *((uint32_t *)(buff + 4)) = 0;          /* XIP size */
 
        if ((ret = mg_mflash_do_write_sects(buff, 0, 1, mg_vcmd_update_xipinfo))
                        != ERROR_OK)
@@ -1173,8 +1173,8 @@ static int mg_set_pll(mg_pll_t *pll)
 
        memset(buff, 0xff, 512);
        /* PLL Lock cycle and Feedback 9bit Divider */
-       memcpy(buff, &pll->lock_cyc, sizeof(u32));
-       memcpy(buff + 4, &pll->feedback_div, sizeof(u16));
+       memcpy(buff, &pll->lock_cyc, sizeof(uint32_t));
+       memcpy(buff + 4, &pll->feedback_div, sizeof(uint16_t));
        buff[6] = pll->input_div;               /* PLL Input 5bit Divider */
        buff[7] = pll->output_div;              /* PLL Output Divider */
 
@@ -1252,9 +1252,9 @@ int mg_config_cmd(struct command_context_s *cmd_ctx, char *cmd,
                                        return ERROR_MG_INVALID_PLL;
                                }
 
-                               LOG_INFO("mflash: Fout=%u Hz, feedback=%u," 
+                               LOG_INFO("mflash: Fout=%" PRIu32 " Hz, feedback=%u," 
                                                "indiv=%u, outdiv=%u, lock=%u",
-                                               (u32)fout, pll.feedback_div,
+                                               (uint32_t)fout, pll.feedback_div,
                                                pll.input_div, pll.output_div,
                                                pll.lock_cyc);
 
@@ -1306,7 +1306,7 @@ static int mg_bank_cmd(struct command_context_s *cmd_ctx, char *cmd, char **args
        mflash_bank->base = strtoul(args[1], NULL, 0);
        mflash_bank->rst_pin.num = strtoul(args[2], &str, 0);
        if (*str)
-               mflash_bank->rst_pin.port[0] = (u16)tolower(str[0]);
+               mflash_bank->rst_pin.port[0] = (uint16_t)tolower(str[0]);
 
        mflash_bank->target = target;
 
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)