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;
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;
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;
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;
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);
if (wait == mg_io_wait_bsy)
return ERROR_OK;
} else {
- switch(wait)
+ switch (wait)
{
case mg_io_wait_not_bsy:
return ERROR_OK;
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;
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;
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;
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)
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);
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;
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;
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);
}
}
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;
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)
}
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);
}
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;
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;
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);
}
}
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;
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;
}
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;
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;
}
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));
}
}
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;
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;
}
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);
}
}
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;
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;
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)));
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))
{
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;
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;
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)
{
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;
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)
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 */
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);
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;