X-Git-Url: https://review.openocd.org/gitweb?a=blobdiff_plain;f=src%2Fflash%2Fmflash.c;h=bf759c97ab57527fd851664262bbf682bb8cfe4e;hb=ee4723c494fb9cd8deefdbf5387f0ba31ea57c65;hp=24efaa776ee6d2ece511604365ca54be81e7183e;hpb=a92cc405ac5775ad97c0d0e72ca9233dcfdc8228;p=openocd.git diff --git a/src/flash/mflash.c b/src/flash/mflash.c index 24efaa776e..bf759c97ab 100644 --- a/src/flash/mflash.c +++ b/src/flash/mflash.c @@ -28,9 +28,9 @@ static int s3c2440_set_gpio_to_output (mflash_gpio_num_t gpio); -static int s3c2440_set_gpio_output_val (mflash_gpio_num_t gpio, u8 val); +static int s3c2440_set_gpio_output_val (mflash_gpio_num_t gpio, uint8_t val); static int pxa270_set_gpio_to_output (mflash_gpio_num_t gpio); -static int pxa270_set_gpio_output_val (mflash_gpio_num_t gpio, u8 val); +static int pxa270_set_gpio_output_val (mflash_gpio_num_t gpio, uint8_t val); static command_t *mflash_cmd; @@ -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; @@ -101,9 +101,9 @@ static int pxa270_set_gpio_to_output (mflash_gpio_num_t gpio) return ret; } -static int pxa270_set_gpio_output_val (mflash_gpio_num_t gpio, u8 val) +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, u8 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; @@ -162,9 +162,9 @@ static int s3c2440_set_gpio_to_output (mflash_gpio_num_t gpio) return ret; } -static int s3c2440_set_gpio_output_val (mflash_gpio_num_t gpio, u8 val) +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; @@ -191,7 +191,7 @@ static int s3c2440_set_gpio_output_val (mflash_gpio_num_t gpio, u8 val) return ret; } -static int mg_hdrst(u8 level) +static int mg_hdrst(uint8_t level) { return mflash_bank->gpio_drv->set_gpio_output_val(mflash_bank->rst_pin, level); } @@ -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) { - u8 status, error; + 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; @@ -288,17 +288,17 @@ static int mg_dsk_wait(mg_io_type_wait wait, u32 time) return ERROR_MG_TIMEOUT; } -static int mg_dsk_srst(u8 on) +static int mg_dsk_srst(uint8_t on) { target_t *target = mflash_bank->target; - u32 mg_task_reg = mflash_bank->base + MG_REG_OFFSET; - u8 value; + 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,11 +308,11 @@ static int mg_dsk_srst(u8 on) return ret; } -static int mg_dsk_io_cmd(u32 sect_num, u32 cnt, u8 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; - u8 value; + uint32_t mg_task_reg = mflash_bank->base + MG_REG_OFFSET; + uint8_t value; int ret; ret = mg_dsk_wait(mg_io_wait_rdy_noerr, MG_OEM_DISK_WAIT_TIME_NORMAL); @@ -322,10 +322,10 @@ static int mg_dsk_io_cmd(u32 sect_num, u32 cnt, u8 cmd) value = mg_io_rval_dev_drv_master | mg_io_rval_dev_lba_mode |((sect_num >> 24) & 0xf); ret = target_write_u8(target, mg_task_reg + MG_REG_DRV_HEAD, value); - ret |= target_write_u8(target, mg_task_reg + MG_REG_SECT_CNT, (u8)cnt); - ret |= target_write_u8(target, mg_task_reg + MG_REG_SECT_NUM, (u8)sect_num); - ret |= target_write_u8(target, mg_task_reg + MG_REG_CYL_LOW, (u8)(sect_num >> 8)); - ret |= target_write_u8(target, mg_task_reg + MG_REG_CYL_HIGH, (u8)(sect_num >> 16)); + ret |= target_write_u8(target, mg_task_reg + MG_REG_SECT_CNT, (uint8_t)cnt); + ret |= target_write_u8(target, mg_task_reg + MG_REG_SECT_NUM, (uint8_t)sect_num); + ret |= target_write_u8(target, mg_task_reg + MG_REG_CYL_LOW, (uint8_t)(sect_num >> 8)); + ret |= target_write_u8(target, mg_task_reg + MG_REG_CYL_HIGH, (uint8_t)(sect_num >> 16)); if (ret != ERROR_OK) return ret; @@ -336,7 +336,7 @@ static int mg_dsk_io_cmd(u32 sect_num, u32 cnt, u8 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) @@ -351,11 +351,11 @@ static int mg_dsk_drv_info(void) mflash_bank->drv_info = malloc(sizeof(mg_drv_info_t)); target_read_memory(target, mg_buff, 2, sizeof(mg_io_type_drv_info) >> 1, - (u8 *)&mflash_bank->drv_info->drv_id); + (uint8_t *)&mflash_bank->drv_info->drv_id); 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,22 +414,22 @@ 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", - mflash_bank->drv_info->tot_sects, mflash_bank->base ); + 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; - u8 *buff_ptr = buff; + uint8_t *buff_ptr = buff; duration_t duration; - if ((ret = mg_dsk_io_cmd(sect_num, sect_cnt, mg_io_cmd_read)) != ERROR_OK ) + if ((ret = mg_dsk_io_cmd(sect_num, sect_cnt, mg_io_cmd_read)) != ERROR_OK) return ret; address = mflash_bank->base + MG_BUFFER_OFFSET; @@ -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,18 +464,18 @@ 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; - u8 *buff_ptr = buff; + uint32_t quotient, residue, i; + uint8_t *buff_ptr = buff; int ret = ERROR_OK; quotient = sect_cnt >> 8; residue = sect_cnt % 256; for (i = 0; i < quotient; i++) { - LOG_DEBUG("mflash: sect num : %u buff : 0x%0lx", sect_num, - (unsigned long)buff_ptr); + LOG_DEBUG("mflash: sect num : %" PRIu32 " buff : %p", + sect_num, buff_ptr); ret = mg_mflash_do_read_sects(buff_ptr, sect_num, 256); if (ret != ERROR_OK) return ret; @@ -485,24 +485,24 @@ 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, - (unsigned long)buff_ptr); + LOG_DEBUG("mflash: sect num : %" PRIx32 " buff : %p", + sect_num, buff_ptr); return mg_mflash_do_read_sects(buff_ptr, sect_num, residue); } 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; - u8 *buff_ptr = buff; + uint8_t *buff_ptr = buff; duration_t duration; - if ((ret = mg_dsk_io_cmd(sect_num, sect_cnt, cmd)) != ERROR_OK ) + if ((ret = mg_dsk_io_cmd(sect_num, sect_cnt, cmd)) != ERROR_OK) return ret; address = mflash_bank->base + MG_BUFFER_OFFSET; @@ -517,19 +517,19 @@ static int mg_mflash_do_write_sects(void *buff, u32 sect_num, u32 sect_cnt, ret = target_write_memory(target, address, 2, MG_MFLASH_SECTOR_SIZE / 2, buff_ptr); if (ret != ERROR_OK) return ret; - + buff_ptr += MG_MFLASH_SECTOR_SIZE; ret = target_write_u8(target, mflash_bank->base + MG_REG_OFFSET + MG_REG_COMMAND, mg_io_cmd_confirm_write); 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,18 +542,18 @@ 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; - u8 *buff_ptr = buff; + uint32_t quotient, residue, i; + uint8_t *buff_ptr = buff; int ret = ERROR_OK; quotient = sect_cnt >> 8; 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, u8 *buff, u32 len) +static int mg_mflash_read (uint32_t addr, uint8_t *buff, uint32_t len) { - u8 *buff_ptr = buff; - u8 sect_buff[MG_MFLASH_SECTOR_SIZE]; - u32 cur_addr, next_sec_addr, end_addr, cnt, sect_num; + uint8_t *buff_ptr = buff; + uint8_t sect_buff[MG_MFLASH_SECTOR_SIZE]; + 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, u8 *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, u8 *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, u8 *buff, u32 len) return ret; } -static int mg_mflash_write(u32 addr, u8 *buff, u32 len) +static int mg_mflash_write(uint32_t addr, uint8_t *buff, uint32_t len) { - u8 *buff_ptr = buff; - u8 sect_buff[MG_MFLASH_SECTOR_SIZE]; - u32 cur_addr, next_sec_addr, end_addr, cnt, sect_num; + uint8_t *buff_ptr = buff; + uint8_t sect_buff[MG_MFLASH_SECTOR_SIZE]; + 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, u8 *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, u8 *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,8 +705,8 @@ static int mg_mflash_write(u32 addr, u8 *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; - u8 *buffer; + uint32_t address, buf_cnt, cnt, res, i; + uint8_t *buffer; fileio_t fileio; duration_t duration; char *duration_text; @@ -716,7 +716,7 @@ static int mg_write_cmd(struct command_context_s *cmd_ctx, char *cmd, char **arg return ERROR_COMMAND_SYNTAX_ERROR; } - address = strtoul(args[2], NULL, 0); + COMMAND_PARSE_NUMBER(u32, args[2], address); ret = fileio_open(&fileio, args[1], FILEIO_READ, FILEIO_BINARY); if (ret != ERROR_OK) @@ -741,10 +741,10 @@ static int mg_write_cmd(struct command_context_s *cmd_ctx, char *cmd, char **arg goto mg_write_cmd_err; address += MG_FILEIO_CHUNK; } - + if (res) { if ((ret = fileio_read(&fileio, res, buffer, &buf_cnt)) != ERROR_OK) - goto mg_write_cmd_err; + goto mg_write_cmd_err; if ((ret = mg_mflash_write(address, buffer, res)) != ERROR_OK) goto mg_write_cmd_err; } @@ -772,8 +772,8 @@ 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; - u8 *buffer; + uint32_t address, size_written, size, cnt, res, i; + uint8_t *buffer; fileio_t fileio; duration_t duration; char *duration_text; @@ -783,13 +783,13 @@ static int mg_dump_cmd(struct command_context_s *cmd_ctx, char *cmd, char **args return ERROR_COMMAND_SYNTAX_ERROR; } - address = strtoul(args[2], NULL, 0); - size = strtoul(args[3], NULL, 0); + COMMAND_PARSE_NUMBER(u32, args[2], address); + COMMAND_PARSE_NUMBER(u32, args[3], size); ret = fileio_open(&fileio, args[1], FILEIO_WRITE, FILEIO_BINARY); if (ret != ERROR_OK) return ret; - + buffer = malloc(MG_FILEIO_CHUNK); if (!buffer) { fileio_close(&fileio); @@ -798,7 +798,7 @@ static int mg_dump_cmd(struct command_context_s *cmd_ctx, char *cmd, char **args cnt = size / MG_FILEIO_CHUNK; res = size % MG_FILEIO_CHUNK; - + duration_start_measure(&duration); for (i = 0; i < cnt; i++) { @@ -809,7 +809,7 @@ static int mg_dump_cmd(struct command_context_s *cmd_ctx, char *cmd, char **args goto mg_dump_cmd_err; address += MG_FILEIO_CHUNK; } - + if (res) { if ((ret = mg_mflash_read(address, buffer, res)) != ERROR_OK) goto mg_dump_cmd_err; @@ -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))); @@ -834,14 +834,14 @@ mg_dump_cmd_err: free(duration_text); free(buffer); fileio_close(&fileio); - - return ret; + + return ret; } 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; @@ -967,14 +967,14 @@ static int mg_verify_interface(void) buff[i] = i; ret = target_write_memory(target, address, 2, - MG_MFLASH_SECTOR_SIZE / 2, (u8 *)buff); + MG_MFLASH_SECTOR_SIZE / 2, (uint8_t *)buff); if (ret != ERROR_OK) return ret; memset(buff, 0xff, MG_MFLASH_SECTOR_SIZE); ret = target_read_memory(target, address, 2, - MG_MFLASH_SECTOR_SIZE / 2, (u8 *)buff); + MG_MFLASH_SECTOR_SIZE / 2, (uint8_t *)buff); if (ret != ERROR_OK) return ret; @@ -1117,7 +1117,7 @@ static void mg_gen_ataid(mg_io_type_drv_info *pSegIdDrvInfo) static int mg_storage_config(void) { - u8 buff[512]; + uint8_t buff[512]; int ret; if ((ret = mg_set_feature(mg_feature_id_transmode, mg_feature_val_trans_vcmd)) @@ -1140,7 +1140,7 @@ static int mg_storage_config(void) static int mg_boot_config(void) { - u8 buff[512]; + uint8_t buff[512]; int ret; if ((ret = mg_set_feature(mg_feature_id_transmode, mg_feature_val_trans_vcmd)) @@ -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) @@ -1168,13 +1168,13 @@ static int mg_boot_config(void) static int mg_set_pll(mg_pll_t *pll) { - u8 buff[512]; + uint8_t buff[512]; int ret; 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 */ @@ -1229,7 +1229,7 @@ int mg_config_cmd(struct command_context_s *cmd_ctx, char *cmd, switch (argc) { case 2: - if (!strcmp(args[1], "boot")) + if (!strcmp(args[1], "boot")) return mg_boot_config(); else if (!strcmp(args[1], "storage")) return mg_storage_config(); @@ -1238,7 +1238,9 @@ int mg_config_cmd(struct command_context_s *cmd_ctx, char *cmd, break; case 3: if (!strcmp(args[1], "pll")) { - fin = strtoul(args[2], NULL, 0); + unsigned long freq; + COMMAND_PARSE_NUMBER(ulong, args[2], freq); + fin = freq; if (fin > MG_PLL_CLK_OUT) { LOG_ERROR("mflash: input freq. is too large"); @@ -1252,9 +1254,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); @@ -1288,7 +1290,6 @@ int mflash_init_drivers(struct command_context_s *cmd_ctx) static int mg_bank_cmd(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { target_t *target; - char *str; int i; if (argc < 4) @@ -1303,10 +1304,12 @@ static int mg_bank_cmd(struct command_context_s *cmd_ctx, char *cmd, char **args } mflash_bank = calloc(sizeof(mflash_bank_t), 1); - mflash_bank->base = strtoul(args[1], NULL, 0); + COMMAND_PARSE_NUMBER(u32, args[1], mflash_bank->base); + /// @todo Verify how this parsing should work, then document it. + char *str; 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;