From eef9ff758bf97dc83e1bfb4cce4922bdf6273742 Mon Sep 17 00:00:00 2001 From: Stefan Rueger Date: Sun, 18 Aug 2024 01:54:24 +0100 Subject: [PATCH] Reformat spacing/comments in src/serialupdi.c --- src/serialupdi.c | 573 +++++++++++++++++++++++------------------------ 1 file changed, 279 insertions(+), 294 deletions(-) diff --git a/src/serialupdi.c b/src/serialupdi.c index ddaa4027..49ff1898 100644 --- a/src/serialupdi.c +++ b/src/serialupdi.c @@ -83,23 +83,23 @@ static int serialupdi_reset(const PROGRAMMER *pgm, reset_mode mode) { self.readwrite.write_cs(constants.UPDI_ASI_RESET_REQ, 0x00) */ switch (mode) { - case APPLY_RESET: - pmsg_debug("sending reset request\n"); - return updi_write_cs(pgm, UPDI_ASI_RESET_REQ, UPDI_RESET_REQ_VALUE); - case RELEASE_RESET: - pmsg_debug("sending release reset request\n"); - return updi_write_cs(pgm, UPDI_ASI_RESET_REQ, 0x00); + case APPLY_RESET: + pmsg_debug("sending reset request\n"); + return updi_write_cs(pgm, UPDI_ASI_RESET_REQ, UPDI_RESET_REQ_VALUE); + case RELEASE_RESET: + pmsg_debug("sending release reset request\n"); + return updi_write_cs(pgm, UPDI_ASI_RESET_REQ, 0x00); } return -1; } static int serialupdi_reset_connection(const PROGRAMMER *pgm) { - if (serialupdi_reset(pgm, APPLY_RESET) < 0) { + if(serialupdi_reset(pgm, APPLY_RESET) < 0) { pmsg_error("apply reset operation failed\n"); return -1; } - if (serialupdi_reset(pgm, RELEASE_RESET) < 0) { + if(serialupdi_reset(pgm, RELEASE_RESET) < 0) { pmsg_error("release reset operation failed\n"); return -1; } @@ -108,35 +108,35 @@ static int serialupdi_reset_connection(const PROGRAMMER *pgm) { } static int serialupdi_decode_sib(const PROGRAMMER *pgm, updi_sib_info *sib_info) { - char * str_ptr; + char *str_ptr; - sib_info->sib_string[SIB_INFO_STRING_LENGTH]=0; + sib_info->sib_string[SIB_INFO_STRING_LENGTH] = 0; pmsg_debug("received SIB: [%s]\n", sib_info->sib_string); - memset(sib_info->family_string, 0, SIB_INFO_FAMILY_LENGTH+1); - memset(sib_info->nvm_string, 0, SIB_INFO_NVM_LENGTH+1); - memset(sib_info->debug_string, 0, SIB_INFO_DEBUG_LENGTH+1); - memset(sib_info->pdi_string, 0, SIB_INFO_PDI_LENGTH+1); - memset(sib_info->extra_string, 0, SIB_INFO_EXTRA_LENGTH+1); + memset(sib_info->family_string, 0, SIB_INFO_FAMILY_LENGTH + 1); + memset(sib_info->nvm_string, 0, SIB_INFO_NVM_LENGTH + 1); + memset(sib_info->debug_string, 0, SIB_INFO_DEBUG_LENGTH + 1); + memset(sib_info->pdi_string, 0, SIB_INFO_PDI_LENGTH + 1); + memset(sib_info->extra_string, 0, SIB_INFO_EXTRA_LENGTH + 1); memcpy(sib_info->family_string, sib_info->sib_string, SIB_INFO_FAMILY_LENGTH); memcpy(sib_info->nvm_string, sib_info->sib_string + 8, SIB_INFO_NVM_LENGTH); memcpy(sib_info->debug_string, sib_info->sib_string + 11, SIB_INFO_DEBUG_LENGTH); memcpy(sib_info->pdi_string, sib_info->sib_string + 15, SIB_INFO_PDI_LENGTH); - strcpy(sib_info->extra_string, (char *)sib_info->sib_string + 19); + strcpy(sib_info->extra_string, (char *) sib_info->sib_string + 19); str_ptr = strstr(sib_info->nvm_string, ":"); - if (!str_ptr) { + if(!str_ptr) { pmsg_error("incorrect format of NVM string\n"); return -1; } - sib_info->nvm_version = *(str_ptr+1); + sib_info->nvm_version = *(str_ptr + 1); str_ptr = strstr(sib_info->debug_string, ":"); - if (!str_ptr) { + if(!str_ptr) { pmsg_error("incorrect format of DEBUG string\n"); return -1; } - sib_info->debug_version = *(str_ptr+1); + sib_info->debug_version = *(str_ptr + 1); pmsg_debug("Device family ID: %s\n", sib_info->family_string); pmsg_debug("NVM interface: %s\n", sib_info->nvm_string); @@ -144,46 +144,45 @@ static int serialupdi_decode_sib(const PROGRAMMER *pgm, updi_sib_info *sib_info) pmsg_debug("PDI oscillator: %s\n", sib_info->pdi_string); pmsg_debug("Extra information: %s\n", sib_info->extra_string); switch (sib_info->nvm_version) { - case '0': - pmsg_notice("NVM type 0: 16-bit, page oriented write\n"); - updi_set_nvm_mode(pgm, UPDI_NVM_MODE_V0); - updi_set_datalink_mode(pgm, UPDI_LINK_MODE_16BIT); - break; - case '2': - pmsg_notice("NVM type 2: 24-bit, word oriented write\n"); - updi_set_nvm_mode(pgm, UPDI_NVM_MODE_V2); - updi_set_datalink_mode(pgm, UPDI_LINK_MODE_24BIT); - break; - case '3': - pmsg_notice("NVM type 3: 24-bit, page oriented\n"); - updi_set_nvm_mode(pgm, UPDI_NVM_MODE_V3); - updi_set_datalink_mode(pgm, UPDI_LINK_MODE_24BIT); - break; - case '4': - pmsg_notice("NVM type 4: 24-bit, word oriented\n"); - updi_set_nvm_mode(pgm, UPDI_NVM_MODE_V4); - updi_set_datalink_mode(pgm, UPDI_LINK_MODE_24BIT); - break; - case '5': - pmsg_notice("NVM type 5: 24-bit, page oriented\n"); - updi_set_nvm_mode(pgm, UPDI_NVM_MODE_V5); - updi_set_datalink_mode(pgm, UPDI_LINK_MODE_24BIT); - break; - default: - pmsg_warning("unsupported NVM type: %c, please update software\n", sib_info->nvm_version); - return -1; + case '0': + pmsg_notice("NVM type 0: 16-bit, page oriented write\n"); + updi_set_nvm_mode(pgm, UPDI_NVM_MODE_V0); + updi_set_datalink_mode(pgm, UPDI_LINK_MODE_16BIT); + break; + case '2': + pmsg_notice("NVM type 2: 24-bit, word oriented write\n"); + updi_set_nvm_mode(pgm, UPDI_NVM_MODE_V2); + updi_set_datalink_mode(pgm, UPDI_LINK_MODE_24BIT); + break; + case '3': + pmsg_notice("NVM type 3: 24-bit, page oriented\n"); + updi_set_nvm_mode(pgm, UPDI_NVM_MODE_V3); + updi_set_datalink_mode(pgm, UPDI_LINK_MODE_24BIT); + break; + case '4': + pmsg_notice("NVM type 4: 24-bit, word oriented\n"); + updi_set_nvm_mode(pgm, UPDI_NVM_MODE_V4); + updi_set_datalink_mode(pgm, UPDI_LINK_MODE_24BIT); + break; + case '5': + pmsg_notice("NVM type 5: 24-bit, page oriented\n"); + updi_set_nvm_mode(pgm, UPDI_NVM_MODE_V5); + updi_set_datalink_mode(pgm, UPDI_LINK_MODE_24BIT); + break; + default: + pmsg_warning("unsupported NVM type: %c, please update software\n", sib_info->nvm_version); + return -1; } return 0; } -static void serialupdi_close(PROGRAMMER * pgm) -{ +static void serialupdi_close(PROGRAMMER *pgm) { pmsg_notice("leaving NVM programming mode\n"); - if (serialupdi_leave_progmode(pgm) < 0) { + if(serialupdi_leave_progmode(pgm) < 0) { pmsg_error("unable to leave NVM programming mode\n"); } - if (updi_get_rts_mode(pgm) != RTS_MODE_DEFAULT) { + if(updi_get_rts_mode(pgm) != RTS_MODE_DEFAULT) { pmsg_notice("releasing DTR/RTS handshake lines\n"); } @@ -208,19 +207,20 @@ static int serialupdi_wait_for_unlock(const PROGRAMMER *pgm, unsigned int ms) { self.logger.error("Timeout waiting for device to unlock") return False -*/ +*/ unsigned long start_time; unsigned long current_time; uint8_t status; + start_time = avr_ustimestamp(); do { - if (updi_read_cs(pgm, UPDI_ASI_SYS_STATUS, &status) >= 0) { - if (!(status & (1 << UPDI_ASI_SYS_STATUS_LOCKSTATUS))) { + if(updi_read_cs(pgm, UPDI_ASI_SYS_STATUS, &status) >= 0) { + if(!(status & (1 << UPDI_ASI_SYS_STATUS_LOCKSTATUS))) { return 0; } } current_time = avr_ustimestamp(); - } while ((current_time - start_time) < (ms * 1000)); + } while((current_time - start_time) < (ms*1000)); pmsg_error("timeout waiting for device to unlock\n"); return -1; @@ -254,25 +254,26 @@ static int serialupdi_wait_for_urow(const PROGRAMMER *pgm, unsigned int ms, urow self.logger.error("Timeout waiting for device to enter UROW WRITE mode") return False -*/ +*/ unsigned long start_time; unsigned long current_time; uint8_t status; + start_time = avr_ustimestamp(); do { - if (updi_read_cs(pgm, UPDI_ASI_SYS_STATUS, &status) >= 0) { - if (mode == WAIT_FOR_UROW_HIGH) { - if (status & (1 << UPDI_ASI_SYS_STATUS_UROWPROG)) { + if(updi_read_cs(pgm, UPDI_ASI_SYS_STATUS, &status) >= 0) { + if(mode == WAIT_FOR_UROW_HIGH) { + if(status & (1 << UPDI_ASI_SYS_STATUS_UROWPROG)) { return 0; } } else { - if (!(status & (1 << UPDI_ASI_SYS_STATUS_UROWPROG))) { + if(!(status & (1 << UPDI_ASI_SYS_STATUS_UROWPROG))) { return 0; } } } current_time = avr_ustimestamp(); - } while ((current_time - start_time) < (ms * 1000)); + } while((current_time - start_time) < (ms*1000)); pmsg_error("timeout waiting for device to complete UROW WRITE\n"); return -1; @@ -283,21 +284,21 @@ static int serialupdi_wait_for_nvmprog(const PROGRAMMER *pgm, unsigned int ms) { unsigned long start_time; unsigned long current_time; uint8_t status; + start_time = avr_ustimestamp(); do { - if (updi_read_cs(pgm, UPDI_ASI_SYS_STATUS, &status) >= 0) { - if (status & (1 << UPDI_ASI_SYS_STATUS_NVMPROG)) { + if(updi_read_cs(pgm, UPDI_ASI_SYS_STATUS, &status) >= 0) { + if(status & (1 << UPDI_ASI_SYS_STATUS_NVMPROG)) { return 0; } } current_time = avr_ustimestamp(); - } while ((current_time - start_time) < (ms * 1000)); + } while((current_time - start_time) < (ms*1000)); pmsg_error("timeout waiting for device to enter NVMPROG mode\n"); return -1; } - static int serialupdi_in_prog_mode(const PROGRAMMER *pgm, uint8_t *in_prog_mode) { /* def in_prog_mode(self): @@ -310,15 +311,15 @@ static int serialupdi_in_prog_mode(const PROGRAMMER *pgm, uint8_t *in_prog_mode) */ uint8_t value; int rc; - + rc = updi_read_cs(pgm, UPDI_ASI_SYS_STATUS, &value); - - if (rc < 0) { + + if(rc < 0) { pmsg_error("read CS operation failed\n"); return rc; } - if (value & (1 << UPDI_ASI_SYS_STATUS_NVMPROG)) { + if(value & (1 << UPDI_ASI_SYS_STATUS_NVMPROG)) { *in_prog_mode = 1; } else { *in_prog_mode = 0; @@ -369,52 +370,52 @@ def enter_progmode(self): unsigned char buffer[8]; uint8_t key_status; - if (serialupdi_in_prog_mode(pgm, &in_prog_mode) < 0) { + if(serialupdi_in_prog_mode(pgm, &in_prog_mode) < 0) { pmsg_error("checking UPDI NVM prog mode failed\n"); return -1; } - if (in_prog_mode) { + if(in_prog_mode) { pmsg_debug("already in prog mode\n"); return 0; } - if (serialupdi_reset(pgm, APPLY_RESET) < 0) { + if(serialupdi_reset(pgm, APPLY_RESET) < 0) { pmsg_error("apply reset operation failed\n"); return -1; } memcpy(buffer, UPDI_KEY_NVM, sizeof(buffer)); - if (updi_write_key(pgm, buffer, UPDI_KEY_64, sizeof(buffer)) < 0) { + if(updi_write_key(pgm, buffer, UPDI_KEY_64, sizeof(buffer)) < 0) { pmsg_error("writing NVM KEY failed\n"); return -1; } - if (updi_read_cs(pgm, UPDI_ASI_KEY_STATUS, &key_status) < 0) { + if(updi_read_cs(pgm, UPDI_ASI_KEY_STATUS, &key_status) < 0) { pmsg_error("checking KEY status failed\n"); return -1; } pmsg_debug("key status: 0x%02X\n", key_status); - if (!(key_status & (1 << UPDI_ASI_KEY_STATUS_NVMPROG))) { + if(!(key_status & (1 << UPDI_ASI_KEY_STATUS_NVMPROG))) { pmsg_warning("key was not accepted\n"); } - if (serialupdi_reset(pgm, APPLY_RESET) < 0) { + if(serialupdi_reset(pgm, APPLY_RESET) < 0) { pmsg_error("apply reset operation failed\n"); return -1; } - if (serialupdi_reset(pgm, RELEASE_RESET) < 0) { + if(serialupdi_reset(pgm, RELEASE_RESET) < 0) { pmsg_error("release reset operation failed\n"); return -1; } - if (serialupdi_wait_for_unlock(pgm, 100) < 0) { + if(serialupdi_wait_for_unlock(pgm, 100) < 0) { pmsg_error("unable to enter NVM programming mode: device is locked\n"); return -1; } - if (serialupdi_wait_for_nvmprog(pgm, 500) < 0) { + if(serialupdi_wait_for_nvmprog(pgm, 500) < 0) { pmsg_error("unable to enter NVM programming mode\n"); return -1; } @@ -436,12 +437,12 @@ static int serialupdi_leave_progmode(const PROGRAMMER *pgm) { self.readwrite.write_cs(constants.UPDI_CS_CTRLB, (1 << constants.UPDI_CTRLB_UPDIDIS_BIT) | (1 << constants.UPDI_CTRLB_CCDETDIS_BIT)) */ - if (serialupdi_reset(pgm, APPLY_RESET) < 0) { + if(serialupdi_reset(pgm, APPLY_RESET) < 0) { pmsg_error("apply reset operation failed\n"); return -1; } - if (serialupdi_reset(pgm, RELEASE_RESET) < 0) { + if(serialupdi_reset(pgm, RELEASE_RESET) < 0) { pmsg_error("release reset operation failed\n"); return -1; } @@ -450,136 +451,136 @@ static int serialupdi_leave_progmode(const PROGRAMMER *pgm) { } static int serialupdi_write_userrow(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *m, - unsigned int page_size, - unsigned int addr, unsigned int n_bytes) -{ + unsigned int page_size, unsigned int addr, unsigned int n_bytes) { /* - def write_user_row_locked_device(self, address, data): - """ - Writes data to the user row when the device is locked, using a key. - """ - # Put in the key - self.readwrite.write_key(constants.UPDI_KEY_64, constants.UPDI_KEY_UROW) + def write_user_row_locked_device(self, address, data): + """ + Writes data to the user row when the device is locked, using a key. + """ + # Put in the key + self.readwrite.write_key(constants.UPDI_KEY_64, constants.UPDI_KEY_UROW) - # Check key status - key_status = self.readwrite.read_cs(constants.UPDI_ASI_KEY_STATUS) - self.logger.debug("Key status = 0x%02X", key_status) + # Check key status + key_status = self.readwrite.read_cs(constants.UPDI_ASI_KEY_STATUS) + self.logger.debug("Key status = 0x%02X", key_status) - if not key_status & (1 << constants.UPDI_ASI_KEY_STATUS_UROWWRITE): - raise PymcuprogError("Key not accepted") + if not key_status & (1 << constants.UPDI_ASI_KEY_STATUS_UROWWRITE): + raise PymcuprogError("Key not accepted") - # Toggle reset - self.reset(apply_reset=True) - self.reset(apply_reset=False) + # Toggle reset + self.reset(apply_reset=True) + self.reset(apply_reset=False) - # Wait for mode to be entered - if not self.wait_urow_prog(500, wait_for_high=True): - raise PymcuprogError("Failed to enter urow write mode using key") + # Wait for mode to be entered + if not self.wait_urow_prog(500, wait_for_high=True): + raise PymcuprogError("Failed to enter urow write mode using key") - # At this point we can write one 'page' to the device, and have it transfered into the user row - # Transfer data - self.readwrite.write_data(address, data) + # At this point we can write one 'page' to the device, and have it transfered into the user row + # Transfer data + self.readwrite.write_data(address, data) - # Finalize - self.readwrite.write_cs(constants.UPDI_ASI_SYS_CTRLA, - (1 << constants.UPDI_ASI_SYS_CTRLA_UROW_FINAL) | - (1 << constants.UPDI_CTRLB_CCDETDIS_BIT)) + # Finalize + self.readwrite.write_cs(constants.UPDI_ASI_SYS_CTRLA, + (1 << constants.UPDI_ASI_SYS_CTRLA_UROW_FINAL) | + (1 << constants.UPDI_CTRLB_CCDETDIS_BIT)) - # Wait for mode to be exited - if not self.wait_urow_prog(500, wait_for_high=False): - # Toggle reset - self.reset(apply_reset=True) - self.reset(apply_reset=False) - raise PymcuprogError("Failed to exit urow write mode") + # Wait for mode to be exited + if not self.wait_urow_prog(500, wait_for_high=False): + # Toggle reset + self.reset(apply_reset=True) + self.reset(apply_reset=False) + raise PymcuprogError("Failed to exit urow write mode") - # Clear status - self.readwrite.write_cs(constants.UPDI_ASI_KEY_STATUS, - (1 << constants.UPDI_ASI_KEY_STATUS_UROWWRITE) | - (1 << constants.UPDI_CTRLB_CCDETDIS_BIT)) + # Clear status + self.readwrite.write_cs(constants.UPDI_ASI_KEY_STATUS, + (1 << constants.UPDI_ASI_KEY_STATUS_UROWWRITE) | + (1 << constants.UPDI_CTRLB_CCDETDIS_BIT)) - # Toggle reset - self.reset(apply_reset=True) - self.reset(apply_reset=False) - */ + # Toggle reset + self.reset(apply_reset=True) + self.reset(apply_reset=False) + */ unsigned char buffer[8]; uint8_t key_status; memcpy(buffer, UPDI_KEY_UROW, sizeof(buffer)); - if (updi_write_key(pgm, buffer, UPDI_KEY_64, sizeof(buffer)) < 0) { + if(updi_write_key(pgm, buffer, UPDI_KEY_64, sizeof(buffer)) < 0) { pmsg_error("writing USERROW KEY failed\n"); return -1; } - if (updi_read_cs(pgm, UPDI_ASI_KEY_STATUS, &key_status) < 0) { + if(updi_read_cs(pgm, UPDI_ASI_KEY_STATUS, &key_status) < 0) { pmsg_error("checking KEY status failed\n"); return -1; } pmsg_debug("key status: 0x%02X\n", key_status); - if (!(key_status & (1 << UPDI_ASI_KEY_STATUS_UROWWRITE))) { + if(!(key_status & (1 << UPDI_ASI_KEY_STATUS_UROWWRITE))) { pmsg_error("key was not accepted\n"); return -1; } - if (serialupdi_reset(pgm, APPLY_RESET) < 0) { + if(serialupdi_reset(pgm, APPLY_RESET) < 0) { pmsg_error("apply reset operation failed\n"); return -1; } - if (serialupdi_reset(pgm, RELEASE_RESET) < 0) { + if(serialupdi_reset(pgm, RELEASE_RESET) < 0) { pmsg_error("release reset operation failed\n"); return -1; } - if (serialupdi_wait_for_urow(pgm, 500, WAIT_FOR_UROW_HIGH) < 0) { + if(serialupdi_wait_for_urow(pgm, 500, WAIT_FOR_UROW_HIGH) < 0) { pmsg_error("unable to enter USERROW programming mode\n"); return -1; } - if (n_bytes <= UPDI_MAX_REPEAT_SIZE) { - if (updi_write_data(pgm, m->offset+addr, m->buf + addr, n_bytes) < 0) { + if(n_bytes <= UPDI_MAX_REPEAT_SIZE) { + if(updi_write_data(pgm, m->offset + addr, m->buf + addr, n_bytes) < 0) { pmsg_error("writing USER ROW failed\n"); return -1; } } else { - if (updi_write_data_words(pgm, m->offset+addr, m->buf + addr, n_bytes) < 0) { + if(updi_write_data_words(pgm, m->offset + addr, m->buf + addr, n_bytes) < 0) { pmsg_error("writing USER ROW failed\n"); return -1; } } - if (updi_write_cs(pgm, UPDI_ASI_SYS_CTRLA, (1 << UPDI_ASI_SYS_CTRLA_UROW_FINAL) | - (1 << UPDI_CTRLB_CCDETDIS_BIT)) < 0) { + if(updi_write_cs(pgm, UPDI_ASI_SYS_CTRLA, + (1 << UPDI_ASI_SYS_CTRLA_UROW_FINAL) | (1 << UPDI_CTRLB_CCDETDIS_BIT)) < 0) { + pmsg_error("unable to commit user row write\n"); return -1; } - if (serialupdi_wait_for_urow(pgm, 500, WAIT_FOR_UROW_LOW) < 0) { + if(serialupdi_wait_for_urow(pgm, 500, WAIT_FOR_UROW_LOW) < 0) { pmsg_debug("unable to exit USERROW programming mode\n"); - if (serialupdi_reset(pgm, APPLY_RESET) < 0) { + if(serialupdi_reset(pgm, APPLY_RESET) < 0) { pmsg_error("apply reset operation failed\n"); return -1; } - if (serialupdi_reset(pgm, RELEASE_RESET) < 0) { + if(serialupdi_reset(pgm, RELEASE_RESET) < 0) { pmsg_error("release reset operation failed\n"); return -1; } } - if (updi_write_cs(pgm, UPDI_ASI_KEY_STATUS, (1 << UPDI_ASI_KEY_STATUS_UROWWRITE) | - (1 << UPDI_CTRLB_CCDETDIS_BIT)) < 0) { + if(updi_write_cs(pgm, UPDI_ASI_KEY_STATUS, + (1 << UPDI_ASI_KEY_STATUS_UROWWRITE) | (1 << UPDI_CTRLB_CCDETDIS_BIT)) < 0) { + pmsg_error("unable to complete user row write\n"); return -1; } - if (serialupdi_reset(pgm, APPLY_RESET) < 0) { + if(serialupdi_reset(pgm, APPLY_RESET) < 0) { pmsg_error("apply reset operation failed\n"); return -1; } - if (serialupdi_reset(pgm, RELEASE_RESET) < 0) { + if(serialupdi_reset(pgm, RELEASE_RESET) < 0) { pmsg_error("release reset operation failed\n"); return -1; } @@ -593,88 +594,89 @@ static int serialupdi_write_userrow(const PROGRAMMER *pgm, const AVRPART *p, con static int serialupdi_initialize(const PROGRAMMER *pgm, const AVRPART *p) { uint8_t value; - uint8_t reset_link_required=0; - - if (updi_link_init(pgm) < 0) { + uint8_t reset_link_required = 0; + + if(updi_link_init(pgm) < 0) { pmsg_error("UPDI link initialization failed\n"); return -1; } pmsg_notice2("UPDI link initialization OK\n"); - if (updi_get_rts_mode(pgm) != RTS_MODE_DEFAULT) { - pmsg_notice("forcing serial DTR/RTS handshake lines %s\n", updi_get_rts_mode(pgm) == RTS_MODE_LOW ? "LOW" : "HIGH"); + if(updi_get_rts_mode(pgm) != RTS_MODE_DEFAULT) { + pmsg_notice("forcing serial DTR/RTS handshake lines %s\n", updi_get_rts_mode(pgm) == RTS_MODE_LOW? "LOW": "HIGH"); } - if (updi_read_cs(pgm, UPDI_ASI_SYS_STATUS, &value)<0) { + if(updi_read_cs(pgm, UPDI_ASI_SYS_STATUS, &value) < 0) { - /* let's try reset the connection */ - if (!serialupdi_reset_connection(pgm)) { + // Let's try reset the connection + if(!serialupdi_reset_connection(pgm)) { return -1; } - if (updi_read_cs(pgm, UPDI_ASI_SYS_STATUS, &value)<0) { + if(updi_read_cs(pgm, UPDI_ASI_SYS_STATUS, &value) < 0) { pmsg_error("read CS operation during initialization failed\n"); return -1; } } - if (value & (1 << UPDI_ASI_SYS_STATUS_LOCKSTATUS)) { + if(value & (1 << UPDI_ASI_SYS_STATUS_LOCKSTATUS)) { pmsg_notice("device is locked\n"); } - if (value & (1 << UPDI_ASI_SYS_STATUS_UROWPROG)) { + if(value & (1 << UPDI_ASI_SYS_STATUS_UROWPROG)) { pmsg_notice("device in USER ROW programming state, leaving programming mode\n"); reset_link_required = 1; } - if (value & (1 << UPDI_ASI_SYS_STATUS_NVMPROG)) { + if(value & (1 << UPDI_ASI_SYS_STATUS_NVMPROG)) { pmsg_notice("device in NVM programming state, leaving programming mode\n"); reset_link_required = 1; } - if (value & (1 << UPDI_ASI_SYS_STATUS_INSLEEP)) { + if(value & (1 << UPDI_ASI_SYS_STATUS_INSLEEP)) { pmsg_notice("device is in SLEEP mode\n"); } - if (value & (1 << UPDI_ASI_SYS_STATUS_RSTSYS)) { + if(value & (1 << UPDI_ASI_SYS_STATUS_RSTSYS)) { pmsg_notice("device in reset status, trying to release it\n"); - if (serialupdi_reset(pgm, RELEASE_RESET) < 0) { + if(serialupdi_reset(pgm, RELEASE_RESET) < 0) { return -1; } } - if (reset_link_required) { - if (serialupdi_reset_connection(pgm) < 0) { + if(reset_link_required) { + if(serialupdi_reset_connection(pgm) < 0) { pmsg_error("UPDI link reset failed\n"); return -1; } } - updi_sib_info * sib_info = updi_get_sib_info(pgm); + updi_sib_info *sib_info = updi_get_sib_info(pgm); - if (updi_read_sib(pgm, sib_info->sib_string, 32) < 0) { - /* this should never happen, let's try to reset connection and try again */ - if (serialupdi_reset_connection(pgm) < 0) { + if(updi_read_sib(pgm, sib_info->sib_string, 32) < 0) { + // This should never happen, let's try to reset connection and try again + if(serialupdi_reset_connection(pgm) < 0) { pmsg_error("SerialUPDI reset connection failed\n"); return -1; } - if (updi_read_sib(pgm, sib_info->sib_string, 32) < 0) { + if(updi_read_sib(pgm, sib_info->sib_string, 32) < 0) { pmsg_error("read SIB operation failed\n"); return -1; } } - if (serialupdi_decode_sib(pgm, sib_info) < 0) { + if(serialupdi_decode_sib(pgm, sib_info) < 0) { pmsg_error("decode SIB_INFO failed\n"); return -1; } - if (updi_link_init(pgm) < 0) { + if(updi_link_init(pgm) < 0) { pmsg_error("UPDI link initialization failed\n"); return -1; } pmsg_notice("entering NVM programming mode\n"); - /* try, but ignore failure */ - /* It will always fail if the device is locked */ - /* The device will be unlocked by erasing the chip after this. */ - if (serialupdi_enter_progmode(pgm) == 0) { - /* If successful, you can run silicon check */ - if (updi_read_data(pgm, p->syscfg_base+1, &value, 1) < 0) { + /* + * Try, but ignore failure. It will always fail if the device is locked. The + * device will be unlocked by erasing the chip after this. + */ + if(serialupdi_enter_progmode(pgm) == 0) { + // If successful, you can run silicon check + if(updi_read_data(pgm, p->syscfg_base + 1, &value, 1) < 0) { pmsg_error("reading chip silicon revision failed\n"); return -1; } else { @@ -687,14 +689,10 @@ static int serialupdi_initialize(const PROGRAMMER *pgm, const AVRPART *p) { } static void serialupdi_disable(const PROGRAMMER *pgm) { - /* Do nothing. */ - return; } -static void serialupdi_enable(PROGRAMMER * pgm, const AVRPART *p) { - /* Do nothing. */ - +static void serialupdi_enable(PROGRAMMER *pgm, const AVRPART *p) { return; } @@ -702,9 +700,7 @@ static void serialupdi_display(const PROGRAMMER *pgm, const char *p) { return; } -static int serialupdi_cmd(const PROGRAMMER *pgm, const unsigned char *cmd, - unsigned char * res) -{ +static int serialupdi_cmd(const PROGRAMMER *pgm, const unsigned char *cmd, unsigned char *res) { pmsg_error("cmd %s[%s] not implemented yet\n", cmd, res); return -1; } @@ -717,21 +713,20 @@ static int serialupdi_program_enable(const PROGRAMMER *pgm, const AVRPART *p) { #define Return(...) do { pmsg_error(__VA_ARGS__); msg_error("\n"); return -1; } while (0) static int serialupdi_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *mem, - unsigned long addr, unsigned char * value) -{ + unsigned long addr, unsigned char *value) { pmsg_debug("%s(%s, 0x%04lx)\n", __func__, mem->desc, addr); if(mem->size < 1) Return("cannot read byte from %s %s owing to its size %d", p->desc, mem->desc, mem->size); if(addr >= (unsigned long) mem->size) Return("cannot read byte from %s %s as address 0x%04lx outside range [0, 0x%04x]", - p->desc, mem->desc, addr, mem->size-1); + p->desc, mem->desc, addr, mem->size - 1); if(mem_is_sib(mem)) { if(addr >= SIB_INFO_STRING_LENGTH) Return("cannot read byte from %s sib as address 0x%04lx outside range [0, 0x%04x]", - p->desc, addr, SIB_INFO_STRING_LENGTH-1); - if(!*updi_get_sib_info(pgm)->sib_string) // This should never happen + p->desc, addr, SIB_INFO_STRING_LENGTH - 1); + if(!*updi_get_sib_info(pgm)->sib_string) // This should never happen Return("cannot read byte from %s sib as memory not initialised", p->desc); *value = updi_get_sib_info(pgm)->sib_string[addr]; return 0; @@ -741,40 +736,43 @@ static int serialupdi_read_byte(const PROGRAMMER *pgm, const AVRPART *p, const A } static int serialupdi_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *mem, - unsigned long addr, unsigned char value) -{ + unsigned long addr, unsigned char value) { pmsg_debug("%s(%s, 0x%04lx, 0x%02x)\n", __func__, mem->desc, addr, value); if(mem->size < 1) Return("cannot write byte to %s %s owing to its size %d", p->desc, mem->desc, mem->size); if(addr >= (unsigned long) mem->size) Return("cannot write byte to %s %s as address 0x%04lx outside range [0, 0x%04x]", - p->desc, mem->desc, addr, mem->size-1); + p->desc, mem->desc, addr, mem->size - 1); - if (mem_is_a_fuse(mem) || mem_is_fuses(mem)) { + if(mem_is_a_fuse(mem) || mem_is_fuses(mem)) { return updi_nvm_write_fuse(pgm, p, mem->offset + addr, value); } - if (mem_is_lock(mem)) { + if(mem_is_lock(mem)) { return updi_nvm_write_fuse(pgm, p, mem->offset + addr, value); } - if (mem_is_eeprom(mem)) { + if(mem_is_eeprom(mem)) { unsigned char buffer[1]; - buffer[0]=value; + + buffer[0] = value; return updi_nvm_write_eeprom(pgm, p, mem->offset + addr, buffer, 1); } - if (mem_is_flash(mem)) { + if(mem_is_flash(mem)) { unsigned char buffer[1]; - buffer[0]=value; + + buffer[0] = value; return updi_nvm_write_flash(pgm, p, mem->offset + addr, buffer, 1); } - if (mem_is_bootrow(mem)) { + if(mem_is_bootrow(mem)) { unsigned char buffer[1]; - buffer[0]=value; + + buffer[0] = value; return updi_nvm_write_boot_row(pgm, p, mem->offset + addr, buffer, 1); } // Read-only memories if(mem_is_readonly(mem)) { unsigned char is; + if(serialupdi_read_byte(pgm, p, mem, addr, &is) >= 0 && is == value) return 0; @@ -784,32 +782,29 @@ static int serialupdi_write_byte(const PROGRAMMER *pgm, const AVRPART *p, const return updi_write_byte(pgm, mem->offset + addr, value); } - static int serialupdi_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *m, - unsigned int page_size, - unsigned int addr, unsigned int n_bytes) -{ + unsigned int page_size, unsigned int addr, unsigned int n_bytes) { if(n_bytes > 65535) { pmsg_error("%s() called with implausibly high n_bytes = %u\n", __func__, n_bytes); return -1; } - if ((int) n_bytes > m->readsize) { + if((int) n_bytes > m->readsize) { unsigned int read_offset = addr; int remaining_bytes = n_bytes; int read_bytes = 0; int rc; - while (remaining_bytes > 0) { - rc = updi_read_data(pgm, m->offset + read_offset, m->buf + read_offset, - remaining_bytes > m->readsize ? m->readsize : remaining_bytes); - if (rc < 0) { + while(remaining_bytes > 0) { + rc = updi_read_data(pgm, m->offset + read_offset, m->buf + read_offset, + remaining_bytes > m->readsize? m->readsize: remaining_bytes); + if(rc < 0) { pmsg_error("paged load operation failed\n"); return rc; } else { - read_bytes+=rc; - read_offset+=m->readsize; - remaining_bytes-=m->readsize; + read_bytes += rc; + read_offset += m->readsize; + remaining_bytes -= m->readsize; } } return read_bytes; @@ -819,35 +814,33 @@ static int serialupdi_paged_load(const PROGRAMMER *pgm, const AVRPART *p, const } static int serialupdi_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *m, - unsigned int page_size, - unsigned int addr, unsigned int n_bytes) -{ + unsigned int page_size, unsigned int addr, unsigned int n_bytes) { int rc; if(n_bytes > 65535) { pmsg_error("%s() called with implausibly high n_bytes = %u\n", __func__, n_bytes); return -1; } - if ((int) n_bytes > m->page_size) { + if((int) n_bytes > m->page_size) { unsigned int write_offset = addr; int remaining_bytes = n_bytes; int write_bytes = 0; - while (remaining_bytes > 0) { + while(remaining_bytes > 0) { - if (mem_is_eeprom(m)) { - rc = updi_nvm_write_eeprom(pgm, p, m->offset + write_offset, m->buf + write_offset, - remaining_bytes > m->page_size ? m->page_size : remaining_bytes); - } else if (mem_is_flash(m)) { - rc = updi_nvm_write_flash(pgm, p, m->offset + write_offset, m->buf + write_offset, - remaining_bytes > m->page_size ? m->page_size : remaining_bytes); - } else if (mem_is_userrow(m)) { - rc = serialupdi_write_userrow(pgm, p, m, page_size, write_offset, - remaining_bytes > m->page_size ? m->page_size : remaining_bytes); - } else if (mem_is_bootrow(m)) { - rc = updi_nvm_write_boot_row(pgm, p, m->offset + write_offset, m->buf + write_offset, - remaining_bytes > m->page_size ? m->page_size : remaining_bytes); - } else if (mem_is_fuses(m)) { + if(mem_is_eeprom(m)) { + rc = updi_nvm_write_eeprom(pgm, p, m->offset + write_offset, m->buf + write_offset, + remaining_bytes > m->page_size? m->page_size: remaining_bytes); + } else if(mem_is_flash(m)) { + rc = updi_nvm_write_flash(pgm, p, m->offset + write_offset, m->buf + write_offset, + remaining_bytes > m->page_size? m->page_size: remaining_bytes); + } else if(mem_is_userrow(m)) { + rc = serialupdi_write_userrow(pgm, p, m, page_size, write_offset, + remaining_bytes > m->page_size? m->page_size: remaining_bytes); + } else if(mem_is_bootrow(m)) { + rc = updi_nvm_write_boot_row(pgm, p, m->offset + write_offset, m->buf + write_offset, + remaining_bytes > m->page_size? m->page_size: remaining_bytes); + } else if(mem_is_fuses(m)) { pmsg_debug("page write operation requested for fuses, falling back to byte-level write\n"); return -1; } else { @@ -855,28 +848,28 @@ static int serialupdi_paged_write(const PROGRAMMER *pgm, const AVRPART *p, const rc = -1; } - if (rc < 0) { + if(rc < 0) { pmsg_error("paged write operation failed\n"); return rc; } else { - write_bytes+=rc; - write_offset+=m->page_size; - remaining_bytes-=m->page_size; + write_bytes += rc; + write_offset += m->page_size; + remaining_bytes -= m->page_size; } } return write_bytes; } else { - if (mem_is_eeprom(m)) { - rc = updi_nvm_write_eeprom(pgm, p, m->offset+addr, m->buf+addr, n_bytes); - } else if (mem_is_flash(m)) { - rc = updi_nvm_write_flash(pgm, p, m->offset+addr, m->buf+addr, n_bytes); - } else if (mem_is_userrow(m)) { + if(mem_is_eeprom(m)) { + rc = updi_nvm_write_eeprom(pgm, p, m->offset + addr, m->buf + addr, n_bytes); + } else if(mem_is_flash(m)) { + rc = updi_nvm_write_flash(pgm, p, m->offset + addr, m->buf + addr, n_bytes); + } else if(mem_is_userrow(m)) { rc = serialupdi_write_userrow(pgm, p, m, page_size, addr, n_bytes); - } else if (mem_is_bootrow(m)) { - rc = updi_nvm_write_boot_row(pgm, p, m->offset+addr, m->buf+addr, n_bytes); - } else if (mem_is_fuses(m)) { - pmsg_debug("page write operation requested for fuses, falling back to byte-level write\n"); - rc = -1; + } else if(mem_is_bootrow(m)) { + rc = updi_nvm_write_boot_row(pgm, p, m->offset + addr, m->buf + addr, n_bytes); + } else if(mem_is_fuses(m)) { + pmsg_debug("page write operation requested for fuses, falling back to byte-level write\n"); + rc = -1; } else { pmsg_error("invalid memory: <%s:%d>, 0x%06X, %d (0x%04X)\n", m->desc, page_size, addr, n_bytes, n_bytes); rc = -1; @@ -911,41 +904,41 @@ static int serialupdi_unlock(const PROGRAMMER *pgm, const AVRPART *p) { */ unsigned char buffer[8]; uint8_t key_status; - + memcpy(buffer, UPDI_KEY_CHIPERASE, sizeof(buffer)); - if (updi_write_key(pgm, buffer, UPDI_KEY_64, sizeof(buffer)) < 0) { + if(updi_write_key(pgm, buffer, UPDI_KEY_64, sizeof(buffer)) < 0) { pmsg_error("writing NVM KEY failed\n"); return -1; } - if (updi_read_cs(pgm, UPDI_ASI_KEY_STATUS, &key_status) < 0) { + if(updi_read_cs(pgm, UPDI_ASI_KEY_STATUS, &key_status) < 0) { pmsg_error("checking KEY status failed\n"); return -1; } pmsg_debug("key status: 0x%02X\n", key_status); - if (!(key_status & (1 << UPDI_ASI_KEY_STATUS_CHIPERASE))) { + if(!(key_status & (1 << UPDI_ASI_KEY_STATUS_CHIPERASE))) { pmsg_error("key not accepted\n"); return -1; } - if (serialupdi_reset(pgm, APPLY_RESET) < 0) { + if(serialupdi_reset(pgm, APPLY_RESET) < 0) { pmsg_error("apply reset operation failed\n"); return -1; } - if (serialupdi_reset(pgm, RELEASE_RESET) < 0) { + if(serialupdi_reset(pgm, RELEASE_RESET) < 0) { pmsg_error("release reset operation failed\n"); return -1; } - if (serialupdi_wait_for_unlock(pgm, 500) < 0) { + if(serialupdi_wait_for_unlock(pgm, 500) < 0) { pmsg_error("waiting for unlock failed\n"); return -1; } - if (updi_link_init(pgm) < 0) { + if(updi_link_init(pgm) < 0) { pmsg_error("UPDI link reinitialization failed\n"); return -1; } @@ -956,14 +949,14 @@ static int serialupdi_unlock(const PROGRAMMER *pgm, const AVRPART *p) { static int serialupdi_chip_erase(const PROGRAMMER *pgm, const AVRPART *p) { uint8_t value; - if (updi_read_cs(pgm, UPDI_ASI_SYS_STATUS, &value)<0) { + if(updi_read_cs(pgm, UPDI_ASI_SYS_STATUS, &value) < 0) { pmsg_error("read CS operation during chip erase failed\n"); return -1; } - - if (value & (1 << UPDI_ASI_SYS_STATUS_LOCKSTATUS)) { + + if(value & (1 << UPDI_ASI_SYS_STATUS_LOCKSTATUS)) { pmsg_warning("device is locked\n"); - if (ovsigck) { + if(ovsigck) { pmsg_warning("attempting device erase\n"); return serialupdi_unlock(pgm, p); } @@ -973,9 +966,7 @@ static int serialupdi_chip_erase(const PROGRAMMER *pgm, const AVRPART *p) { return -1; } -static int serialupdi_page_erase(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *m, - unsigned int baseaddr) -{ +static int serialupdi_page_erase(const PROGRAMMER *pgm, const AVRPART *p, const AVRMEM *m, unsigned int baseaddr) { return updi_nvm_erase_flash_page(pgm, p, m->offset + baseaddr); } @@ -983,20 +974,20 @@ static int serialupdi_read_signature(const PROGRAMMER *pgm, const AVRPART *p, co uint8_t value; - if (updi_read_cs(pgm, UPDI_ASI_SYS_STATUS, &value)<0) { + if(updi_read_cs(pgm, UPDI_ASI_SYS_STATUS, &value) < 0) { pmsg_error("read CS operation during signature read failed\n"); return -1; } - if (value & (1 << UPDI_ASI_SYS_STATUS_LOCKSTATUS)) { - m->buf[0]=0x00; - m->buf[1]=0x00; - m->buf[2]=0x00; + if(value & (1 << UPDI_ASI_SYS_STATUS_LOCKSTATUS)) { + m->buf[0] = 0x00; + m->buf[1] = 0x00; + m->buf[2] = 0x00; return LIBAVRDUDE_SOFTFAIL; } else { updi_read_byte(pgm, m->offset + 0, m->buf); - updi_read_byte(pgm, m->offset + 1, m->buf+1); - updi_read_byte(pgm, m->offset + 2, m->buf+2); + updi_read_byte(pgm, m->offset + 1, m->buf + 1); + updi_read_byte(pgm, m->offset + 2, m->buf + 2); } return 3; @@ -1004,10 +995,10 @@ static int serialupdi_read_signature(const PROGRAMMER *pgm, const AVRPART *p, co static int serialupdi_read_sib(const PROGRAMMER *pgm, const AVRPART *p, char *sib) { - updi_sib_info * sib_info = updi_get_sib_info(pgm); + updi_sib_info *sib_info = updi_get_sib_info(pgm); memcpy(sib, sib_info->sib_string, 32); - + return 0; } @@ -1016,13 +1007,13 @@ static int serialupdi_parseextparms(const PROGRAMMER *pgm, const LISTID extparms int rv = 0; bool help = false; - for (LNODEID ln = lfirst(extparms); ln; ln = lnext(ln)) { + for(LNODEID ln = lfirst(extparms); ln; ln = lnext(ln)) { const char *extended_param = ldata(ln); - if (sscanf(extended_param, "rtsdtr=%4s", rts_mode) == 1) { - if (str_caseeq(rts_mode, "low")) { + if(sscanf(extended_param, "rtsdtr=%4s", rts_mode) == 1) { + if(str_caseeq(rts_mode, "low")) { updi_set_rts_mode(pgm, RTS_MODE_LOW); - } else if (str_caseeq(rts_mode, "high")) { + } else if(str_caseeq(rts_mode, "high")) { updi_set_rts_mode(pgm, RTS_MODE_HIGH); } else { pmsg_error("-x rtsdtr=: RTS/DTR mode must be LOW or HIGH\n"); @@ -1032,12 +1023,12 @@ static int serialupdi_parseextparms(const PROGRAMMER *pgm, const LISTID extparms continue; } - if (str_eq(extended_param, "help")) { + if(str_eq(extended_param, "help")) { help = true; rv = LIBAVRDUDE_EXIT; } - if (!help) { + if(!help) { pmsg_error("invalid extended parameter -x %s\n", extended_param); rv = -1; } @@ -1053,35 +1044,29 @@ static int serialupdi_parseextparms(const PROGRAMMER *pgm, const LISTID extparms void serialupdi_initpgm(PROGRAMMER *pgm) { strcpy(pgm->type, "serialupdi"); - /* - * mandatory functions - */ - - pgm->initialize = serialupdi_initialize; + // Mandatory functions + pgm->initialize = serialupdi_initialize; pgm->parseextparams = serialupdi_parseextparms; - pgm->display = serialupdi_display; - pgm->enable = serialupdi_enable; - pgm->disable = serialupdi_disable; + pgm->display = serialupdi_display; + pgm->enable = serialupdi_enable; + pgm->disable = serialupdi_disable; pgm->program_enable = serialupdi_program_enable; - pgm->chip_erase = serialupdi_chip_erase; - pgm->cmd = serialupdi_cmd; - pgm->open = serialupdi_open; - pgm->close = serialupdi_close; - pgm->read_byte = serialupdi_read_byte; - pgm->write_byte = serialupdi_write_byte; + pgm->chip_erase = serialupdi_chip_erase; + pgm->cmd = serialupdi_cmd; + pgm->open = serialupdi_open; + pgm->close = serialupdi_close; + pgm->read_byte = serialupdi_read_byte; + pgm->write_byte = serialupdi_write_byte; - /* - * optional functions - */ - - pgm->unlock = serialupdi_unlock; - pgm->paged_write = serialupdi_paged_write; + // Optional functions + pgm->unlock = serialupdi_unlock; + pgm->paged_write = serialupdi_paged_write; pgm->read_sig_bytes = serialupdi_read_signature; - pgm->read_sib = serialupdi_read_sib; - pgm->paged_load = serialupdi_paged_load; - pgm->page_erase = serialupdi_page_erase; - pgm->setup = serialupdi_setup; - pgm->teardown = serialupdi_teardown; + pgm->read_sib = serialupdi_read_sib; + pgm->paged_load = serialupdi_paged_load; + pgm->page_erase = serialupdi_page_erase; + pgm->setup = serialupdi_setup; + pgm->teardown = serialupdi_teardown; }