From 4f88ce6c6b9c744746b48ea112a5a64fd9d64a42 Mon Sep 17 00:00:00 2001 From: Stefan Rueger Date: Sun, 18 Aug 2024 01:54:29 +0100 Subject: [PATCH] Reformat spacing/comments in src/updi_link.c --- src/updi_link.c | 229 +++++++++++++++++++++++++----------------------- 1 file changed, 120 insertions(+), 109 deletions(-) diff --git a/src/updi_link.c b/src/updi_link.c index 28decf8c..e79abff3 100644 --- a/src/updi_link.c +++ b/src/updi_link.c @@ -40,16 +40,15 @@ static void updi_set_rtsdtr_mode(const PROGRAMMER *pgm) { updi_rts_mode rts_mode = updi_get_rts_mode(pgm); - if (rts_mode == RTS_MODE_DEFAULT) { + if(rts_mode == RTS_MODE_DEFAULT) { return; } serial_set_dtr_rts(&pgm->fd, 0); - serial_set_dtr_rts(&pgm->fd, rts_mode == RTS_MODE_LOW ? 1 : 0); + serial_set_dtr_rts(&pgm->fd, rts_mode == RTS_MODE_LOW? 1: 0); } -static int updi_physical_open(PROGRAMMER* pgm, int baudrate, unsigned long cflags) -{ +static int updi_physical_open(PROGRAMMER *pgm, int baudrate, unsigned long cflags) { serial_recv_timeout = 1000; union pinfo pinfo; @@ -58,27 +57,22 @@ static int updi_physical_open(PROGRAMMER* pgm, int baudrate, unsigned long cflag pmsg_debug("opening serial port ...\n"); - if (serial_open(pgm->port, pinfo, &pgm->fd)==-1) { + if(serial_open(pgm->port, pinfo, &pgm->fd) == -1) { pmsg_debug("serial port open failed!\n"); return -1; } - /* - * drain any extraneous input - */ + // Drain any extraneous input serial_drain(&pgm->fd, 0); - /* - * set RTS/DTR mode if needed - */ + // Set RTS/DTR mode if needed updi_set_rtsdtr_mode(pgm); return 0; } -static void updi_physical_close(PROGRAMMER* pgm) -{ +static void updi_physical_close(PROGRAMMER *pgm) { serial_set_dtr_rts(&pgm->fd, 0); serial_close(&pgm->fd); pgm->fd.ifd = -1; @@ -89,9 +83,9 @@ static int updi_physical_send(const PROGRAMMER *pgm, unsigned char *buf, size_t int rv; pmsg_debug("sending %lu bytes [", (unsigned long) len); - for (i=0; ifd, buf, len); - if (rv < 0) { + if(rv < 0) { pmsg_debug("%s(): programmer is not responding\n", __func__); return -1; } pmsg_debug("received %lu bytes [", (unsigned long) len); - for (i=0; ifd, 300, SERIAL_8E1) < 0) { + if(serial_setparams(&pgm->fd, 300, SERIAL_8E1) < 0) { return -1; } @@ -149,15 +143,13 @@ static int updi_physical_send_double_break(const PROGRAMMER *pgm) { serial_drain(&pgm->fd, 0); - if (serial_setparams(&pgm->fd, pgm->baudrate? pgm->baudrate: 115200, SERIAL_8E2) < 0) { + if(serial_setparams(&pgm->fd, pgm->baudrate? pgm->baudrate: 115200, SERIAL_8E2) < 0) { return -1; } updi_set_rtsdtr_mode(pgm); - /* - * drain any extraneous input - */ + // Drain any extraneous input serial_drain(&pgm->fd, 0); return 0; @@ -179,7 +171,7 @@ int updi_physical_sib(const PROGRAMMER *pgm, unsigned char *buffer, uint8_t size send_buffer[0] = UPDI_PHY_SYNC; send_buffer[1] = UPDI_KEY | UPDI_KEY_SIB | UPDI_SIB_32BYTES; - if (updi_physical_send(pgm, send_buffer, 2) < 0) { + if(updi_physical_send(pgm, send_buffer, 2) < 0) { pmsg_debug("SIB request send failed\n"); return -1; } @@ -187,14 +179,14 @@ int updi_physical_sib(const PROGRAMMER *pgm, unsigned char *buffer, uint8_t size return updi_physical_recv(pgm, buffer, size); } -int updi_link_open(PROGRAMMER *pgm) { +int updi_link_open(PROGRAMMER *pgm) { unsigned char init_buffer[1]; - if (updi_physical_open(pgm, pgm->baudrate? pgm->baudrate: 115200, SERIAL_8E2) < 0) { + if(updi_physical_open(pgm, pgm->baudrate? pgm->baudrate: 115200, SERIAL_8E2) < 0) { return -1; } - init_buffer[0]=UPDI_BREAK; + init_buffer[0] = UPDI_BREAK; return updi_physical_send(pgm, init_buffer, 1); } @@ -202,7 +194,7 @@ void updi_link_close(PROGRAMMER *pgm) { updi_physical_close(pgm); } -static int updi_link_init_session_parameters(const PROGRAMMER *pgm) { +static int updi_link_init_session_parameters(const PROGRAMMER *pgm) { /* def _init_session_parameters(self): """ @@ -211,11 +203,11 @@ static int updi_link_init_session_parameters(const PROGRAMMER *pgm) { self.stcs(constants.UPDI_CS_CTRLB, 1 << constants.UPDI_CTRLB_CCDETDIS_BIT) self.stcs(constants.UPDI_CS_CTRLA, 1 << constants.UPDI_CTRLA_IBDLY_BIT) */ - if (updi_link_stcs(pgm, UPDI_CS_CTRLB, 1 << UPDI_CTRLB_CCDETDIS_BIT) < 0) { + if(updi_link_stcs(pgm, UPDI_CS_CTRLB, 1 << UPDI_CTRLB_CCDETDIS_BIT) < 0) { return -1; } - if (updi_link_stcs(pgm, UPDI_CS_CTRLA, 1 << UPDI_CTRLA_IBDLY_BIT) < 0) { + if(updi_link_stcs(pgm, UPDI_CS_CTRLA, 1 << UPDI_CTRLA_IBDLY_BIT) < 0) { return -1; } @@ -240,12 +232,13 @@ static int updi_link_check(const PROGRAMMER *pgm) { */ int result; uint8_t value; + result = updi_link_ldcs(pgm, UPDI_CS_STATUSA, &value); - if (result < 0) { + if(result < 0) { pmsg_debug("check failed\n"); return -1; } else { - if (value > 0) { + if(value > 0) { pmsg_debug("UDPI init OK\n"); return 0; } else { @@ -255,7 +248,6 @@ static int updi_link_check(const PROGRAMMER *pgm) { } } - int updi_link_init(const PROGRAMMER *pgm) { /* def init_datalink(self): @@ -271,22 +263,22 @@ int updi_link_init(const PROGRAMMER *pgm) { if not self._check_datalink(): raise PymcuprogError("UPDI initialisation failed") */ - if (updi_link_init_session_parameters(pgm) < 0) { + if(updi_link_init_session_parameters(pgm) < 0) { pmsg_debug("session initialisation failed\n"); return -1; } - if (updi_link_check(pgm) < 0) { + if(updi_link_check(pgm) < 0) { pmsg_debug("datalink not active, resetting ...\n"); - if (updi_physical_send_double_break(pgm) < 0) { + if(updi_physical_send_double_break(pgm) < 0) { pmsg_debug("datalink initialisation failed\n"); return -1; } - if (updi_link_init_session_parameters(pgm) < 0) { + if(updi_link_init_session_parameters(pgm) < 0) { pmsg_debug("session initialisation failed\n"); return -1; } - if (updi_link_check(pgm) < 0) { + if(updi_link_check(pgm) < 0) { pmsg_debug("restoring datalink failed\n"); return -1; } @@ -294,7 +286,7 @@ int updi_link_init(const PROGRAMMER *pgm) { return 0; } -int updi_link_ldcs(const PROGRAMMER *pgm, uint8_t address, uint8_t *value) { +int updi_link_ldcs(const PROGRAMMER *pgm, uint8_t address, uint8_t *value) { /* def ldcs(self, address): """ @@ -314,21 +306,22 @@ int updi_link_ldcs(const PROGRAMMER *pgm, uint8_t address, uint8_t *value) { */ unsigned char buffer[2]; int result; + pmsg_debug("LDCS from 0x%02X\n", address); - buffer[0]=UPDI_PHY_SYNC; - buffer[1]=UPDI_LDCS | (address & 0x0F); - if (updi_physical_send(pgm, buffer, 2) < 0) { + buffer[0] = UPDI_PHY_SYNC; + buffer[1] = UPDI_LDCS | (address & 0x0F); + if(updi_physical_send(pgm, buffer, 2) < 0) { pmsg_debug("LDCS send operation failed\n"); return -1; } result = updi_physical_recv(pgm, buffer, 1); - if (result != 1) { - if (result >= 0) { + if(result != 1) { + if(result >= 0) { pmsg_debug("incorrect response size, received %d instead of %d bytes\n", result, 1); } return -1; } - * value = buffer[0]; + *value = buffer[0]; return 0; } @@ -345,6 +338,7 @@ int updi_link_stcs(const PROGRAMMER *pgm, uint8_t address, uint8_t value) { self.updi_phy.send([constants.UPDI_PHY_SYNC, constants.UPDI_STCS | (address & 0x0F), value]) */ unsigned char buffer[3]; + pmsg_debug("STCS 0x%02X to address 0x%02X\n", value, address); buffer[0] = UPDI_PHY_SYNC; buffer[1] = UPDI_STCS | (address & 0x0F); @@ -357,7 +351,7 @@ int updi_link_ld_ptr_inc(const PROGRAMMER *pgm, unsigned char *buffer, uint16_t def ld_ptr_inc(self, size): """ Loads a number of bytes from the pointer location with pointer post-increment - + :param size: number of bytes to load :return: values read """ @@ -367,10 +361,11 @@ int updi_link_ld_ptr_inc(const PROGRAMMER *pgm, unsigned char *buffer, uint16_t return self.updi_phy.receive(size) */ unsigned char send_buffer[2]; + pmsg_debug("LD8 from ptr++\n"); send_buffer[0] = UPDI_PHY_SYNC; send_buffer[1] = UPDI_LD | UPDI_PTR_INC | UPDI_DATA_8; - if (updi_physical_send(pgm, send_buffer, 2) < 0) { + if(updi_physical_send(pgm, send_buffer, 2) < 0) { pmsg_debug("LD_PTR_INC send operation failed\n"); return -1; } @@ -392,10 +387,11 @@ int updi_link_ld_ptr_inc16(const PROGRAMMER *pgm, unsigned char *buffer, uint16_ return self.updi_phy.receive(words << 1) */ unsigned char send_buffer[2]; + pmsg_debug("LD16 from ptr++\n"); send_buffer[0] = UPDI_PHY_SYNC; send_buffer[1] = UPDI_LD | UPDI_PTR_INC | UPDI_DATA_16; - if (updi_physical_send(pgm, send_buffer, 2) < 0) { + if(updi_physical_send(pgm, send_buffer, 2) < 0) { pmsg_debug("LD_PTR_INC send operation failed\n"); return -1; } @@ -431,31 +427,32 @@ int updi_link_st_ptr_inc(const PROGRAMMER *pgm, unsigned char *buffer, uint16_t unsigned char recv_buffer[1]; int response; int num = 1; + pmsg_debug("ST8 to *ptr++\n"); send_buffer[0] = UPDI_PHY_SYNC; send_buffer[1] = UPDI_ST | UPDI_PTR_INC | UPDI_DATA_8; send_buffer[2] = buffer[0]; - if (updi_physical_send(pgm, send_buffer, 3) < 0) { + if(updi_physical_send(pgm, send_buffer, 3) < 0) { pmsg_debug("ST_PTR_INC send operation failed\n"); return -1; } response = updi_physical_recv(pgm, recv_buffer, 1); - if (response != 1 || recv_buffer[0] != UPDI_PHY_ACK) { + if(response != 1 || recv_buffer[0] != UPDI_PHY_ACK) { pmsg_debug("ACK was expected but not received\n"); return -1; } - while (num < size) { - send_buffer[0]=buffer[num]; - if (updi_physical_send(pgm, send_buffer, 1) < 0) { + while(num < size) { + send_buffer[0] = buffer[num]; + if(updi_physical_send(pgm, send_buffer, 1) < 0) { pmsg_debug("ST_PTR_INC data send operation failed\n"); return -1; } response = updi_physical_recv(pgm, recv_buffer, 1); - if (response != 1 || recv_buffer[0] != UPDI_PHY_ACK) { + if(response != 1 || recv_buffer[0] != UPDI_PHY_ACK) { pmsg_debug("data ACK was expected but not received\n"); return -1; } @@ -494,37 +491,38 @@ int updi_link_st_ptr_inc16(const PROGRAMMER *pgm, unsigned char *buffer, uint16_ unsigned char recv_buffer[1]; int response; int num = 2; + pmsg_debug("ST16 to *ptr++\n"); send_buffer[0] = UPDI_PHY_SYNC; send_buffer[1] = UPDI_ST | UPDI_PTR_INC | UPDI_DATA_16; send_buffer[2] = buffer[0]; send_buffer[3] = buffer[1]; - if (updi_physical_send(pgm, send_buffer, 4) < 0) { + if(updi_physical_send(pgm, send_buffer, 4) < 0) { pmsg_debug("ST_PTR_INC16 send operation failed\n"); return -1; } response = updi_physical_recv(pgm, recv_buffer, 1); - if (response != 1 || recv_buffer[0] != UPDI_PHY_ACK) { + if(response != 1 || recv_buffer[0] != UPDI_PHY_ACK) { pmsg_debug("ACK was expected but not received\n"); return -1; } - while (num < words) { - send_buffer[0]=buffer[num]; - send_buffer[1]=buffer[num+1]; - if (updi_physical_send(pgm, send_buffer, 2) < 0) { + while(num < words) { + send_buffer[0] = buffer[num]; + send_buffer[1] = buffer[num + 1]; + if(updi_physical_send(pgm, send_buffer, 2) < 0) { pmsg_debug("ST_PTR_INC data send operation failed\n"); return -1; } response = updi_physical_recv(pgm, recv_buffer, 1); - if (response != 1 || recv_buffer[0] != UPDI_PHY_ACK) { + if(response != 1 || recv_buffer[0] != UPDI_PHY_ACK) { pmsg_debug("data ACK was expected but not received\n"); return -1; } - num+=2; + num += 2; } return 0; @@ -548,12 +546,12 @@ int updi_link_st_ptr_inc16_RSD(const PROGRAMMER *pgm, unsigned char *buffer, uin repnumber= ((len(data) >> 1) -1) data = [*data, *[constants.UPDI_PHY_SYNC, constants.UPDI_STCS | constants.UPDI_CS_CTRLA, 0x06]] - if blocksize == -1 : + if blocksize == -1: # Send whole thing at once stcs + repeat + st + (data + stcs) blocksize = 3 + 3 + 2 + len(data) num = 0 firstpacket = [] - if blocksize < 10 : + if blocksize < 10: # very small block size - we send pair of 2-byte commands first. firstpacket = [*[constants.UPDI_PHY_SYNC, constants.UPDI_STCS | constants.UPDI_CS_CTRLA, 0x0E], *[constants.UPDI_PHY_SYNC, constants.UPDI_REPEAT | constants.UPDI_REPEAT_BYTE, (repnumber & 0xFF)]] @@ -573,13 +571,13 @@ int updi_link_st_ptr_inc16_RSD(const PROGRAMMER *pgm, unsigned char *buffer, uin self.updi_phy.send(data_slice) num += len(data_slice) */ - pmsg_debug("ST16 to *ptr++ with RSD, data length: 0x%03X in blocks of: %d\n", words * 2, blocksize); + pmsg_debug("ST16 to *ptr++ with RSD, data length: 0x%03X in blocks of: %d\n", words*2, blocksize); - unsigned int temp_buffer_size = 3 + 3 + 2 + (words * 2) + 3; - unsigned int num=0; - unsigned char* temp_buffer = mmt_malloc(temp_buffer_size); + unsigned int temp_buffer_size = 3 + 3 + 2 + (words*2) + 3; + unsigned int num = 0; + unsigned char *temp_buffer = mmt_malloc(temp_buffer_size); - if (blocksize == -1) { + if(blocksize == -1) { blocksize = temp_buffer_size; } @@ -592,37 +590,37 @@ int updi_link_st_ptr_inc16_RSD(const PROGRAMMER *pgm, unsigned char *buffer, uin temp_buffer[6] = UPDI_PHY_SYNC; temp_buffer[7] = UPDI_ST | UPDI_PTR_INC | UPDI_DATA_16; - memcpy(temp_buffer + 8, buffer, words * 2); + memcpy(temp_buffer + 8, buffer, words*2); - temp_buffer[temp_buffer_size-3] = UPDI_PHY_SYNC; - temp_buffer[temp_buffer_size-2] = UPDI_STCS | UPDI_CS_CTRLA; - temp_buffer[temp_buffer_size-1] = 0x06; + temp_buffer[temp_buffer_size - 3] = UPDI_PHY_SYNC; + temp_buffer[temp_buffer_size - 2] = UPDI_STCS | UPDI_CS_CTRLA; + temp_buffer[temp_buffer_size - 1] = 0x06; - if (blocksize < 10) { - if (updi_physical_send(pgm, temp_buffer, 6) < 0) { + if(blocksize < 10) { + if(updi_physical_send(pgm, temp_buffer, 6) < 0) { pmsg_debug("unable to send first package\n"); mmt_free(temp_buffer); return -1; } num = 6; - } + } - while (num < temp_buffer_size) { + while(num < temp_buffer_size) { int next_package_size; - if (num + blocksize > temp_buffer_size) { + if(num + blocksize > temp_buffer_size) { next_package_size = temp_buffer_size - num; } else { next_package_size = blocksize; } - if (updi_physical_send(pgm, temp_buffer + num, next_package_size) < 0) { + if(updi_physical_send(pgm, temp_buffer + num, next_package_size) < 0) { pmsg_debug("unable to send package\n"); mmt_free(temp_buffer); return -1; } - num+=next_package_size; + num += next_package_size; } mmt_free(temp_buffer); return 0; @@ -645,12 +643,13 @@ int updi_link_repeat(const PROGRAMMER *pgm, uint16_t repeats) { repeats & 0xFF]) */ unsigned char buffer[3]; + pmsg_debug("repeat %d\n", repeats); - if ((repeats - 1) > UPDI_MAX_REPEAT_SIZE) { + if((repeats - 1) > UPDI_MAX_REPEAT_SIZE) { pmsg_debug("invalid repeat count of %d\n", repeats); return -1; } - repeats-=1; + repeats -= 1; buffer[0] = UPDI_PHY_SYNC; buffer[1] = UPDI_REPEAT | UPDI_REPEAT_BYTE; buffer[2] = repeats & 0xFF; @@ -673,7 +672,7 @@ int updi_link_key(const PROGRAMMER *pgm, unsigned char *buffer, uint8_t size_typ def key(self, size, key): """ Write a key - + :param size: size of key (0=64B, 1=128B, 2=256B) :param key: key value """ @@ -686,20 +685,21 @@ int updi_link_key(const PROGRAMMER *pgm, unsigned char *buffer, uint8_t size_typ unsigned char send_buffer[2]; unsigned char reversed_key[256]; int index; + pmsg_debug("UPDI writing key\n"); - if (size != (8 << size_type)) { + if(size != (8 << size_type)) { pmsg_debug("invalid key length\n"); return -1; } send_buffer[0] = UPDI_PHY_SYNC; send_buffer[1] = UPDI_KEY | UPDI_KEY_KEY | size_type; - if (updi_physical_send(pgm, send_buffer, 2) < 0) { + if(updi_physical_send(pgm, send_buffer, 2) < 0) { pmsg_debug("UPDI key send message failed\n"); return -1; } - /* reverse key contents */ - for (index=0; index> 8) & 0xFF; send_buffer[4] = (address >> 16) & 0xFF; - if (updi_physical_send(pgm, send_buffer, updi_get_datalink_mode(pgm) == UPDI_LINK_MODE_24BIT ? 5 : 4) < 0) { + if(updi_physical_send(pgm, send_buffer, updi_get_datalink_mode(pgm) == UPDI_LINK_MODE_24BIT? 5: 4) < 0) { pmsg_debug("LD operation send failed\n"); return -1; } - if (updi_physical_recv(pgm, recv_buffer, 1) < 0) { + if(updi_physical_recv(pgm, recv_buffer, 1) < 0) { pmsg_debug("LD operation recv failed\n"); return -1; } - * value = recv_buffer[0]; + *value = recv_buffer[0]; return 0; } @@ -756,21 +758,23 @@ int updi_link_ld16(const PROGRAMMER *pgm, uint32_t address, uint16_t *value) { */ unsigned char send_buffer[5]; unsigned char recv_buffer[2]; + pmsg_debug("LD16 from 0x%06X\n", address); send_buffer[0] = UPDI_PHY_SYNC; - send_buffer[1] = UPDI_LDS | UPDI_DATA_16 | (updi_get_datalink_mode(pgm) == UPDI_LINK_MODE_24BIT ? UPDI_ADDRESS_24 : UPDI_ADDRESS_16); + send_buffer[1] = + UPDI_LDS | UPDI_DATA_16 | (updi_get_datalink_mode(pgm) == UPDI_LINK_MODE_24BIT? UPDI_ADDRESS_24: UPDI_ADDRESS_16); send_buffer[2] = address & 0xFF; send_buffer[3] = (address >> 8) & 0xFF; send_buffer[4] = (address >> 16) & 0xFF; - if (updi_physical_send(pgm, send_buffer, updi_get_datalink_mode(pgm) == UPDI_LINK_MODE_24BIT ? 5 : 4) < 0) { + if(updi_physical_send(pgm, send_buffer, updi_get_datalink_mode(pgm) == UPDI_LINK_MODE_24BIT? 5: 4) < 0) { pmsg_debug("LD16 operation send failed\n"); return -1; } - if (updi_physical_recv(pgm, recv_buffer, 2) < 0) { + if(updi_physical_recv(pgm, recv_buffer, 2) < 0) { pmsg_debug("LD16 operation recv failed\n"); return -1; } - * value = (recv_buffer[0] << 8 | recv_buffer[1]); + *value = (recv_buffer[0] << 8 | recv_buffer[1]); return 0; } @@ -794,23 +798,24 @@ static int updi_link_st_data_phase(const PROGRAMMER *pgm, unsigned char *buffer, raise PymcuprogError("Error with st") */ unsigned char recv_buffer[1]; - if (updi_physical_recv(pgm, recv_buffer, 1) < 0) { + + if(updi_physical_recv(pgm, recv_buffer, 1) < 0) { pmsg_debug("UPDI data phase recv failed on first ACK\n"); return -1; } - if (recv_buffer[0] != UPDI_PHY_ACK) { + if(recv_buffer[0] != UPDI_PHY_ACK) { pmsg_debug("UPDI data phase expected first ACK\n"); return -1; } - if (updi_physical_send(pgm, buffer, size) < 0) { + if(updi_physical_send(pgm, buffer, size) < 0) { pmsg_debug("UPDI data phase send failed\n"); return -1; } - if (updi_physical_recv(pgm, recv_buffer, 1) < 0) { + if(updi_physical_recv(pgm, recv_buffer, 1) < 0) { pmsg_debug("UPDI data phase recv failed on second ACK\n"); return -1; } - if (recv_buffer[0] != UPDI_PHY_ACK) { + if(recv_buffer[0] != UPDI_PHY_ACK) { pmsg_debug("UPDI data phase expected second ACK\n"); return -1; } @@ -833,13 +838,15 @@ int updi_link_st(const PROGRAMMER *pgm, uint32_t address, uint8_t value) { return self._st_data_phase([value & 0xFF]) */ unsigned char send_buffer[5]; + pmsg_debug("ST to 0x%06X\n", address); send_buffer[0] = UPDI_PHY_SYNC; - send_buffer[1] = UPDI_STS | UPDI_DATA_8 | (updi_get_datalink_mode(pgm) == UPDI_LINK_MODE_24BIT ? UPDI_ADDRESS_24 : UPDI_ADDRESS_16); + send_buffer[1] = + UPDI_STS | UPDI_DATA_8 | (updi_get_datalink_mode(pgm) == UPDI_LINK_MODE_24BIT? UPDI_ADDRESS_24: UPDI_ADDRESS_16); send_buffer[2] = address & 0xFF; send_buffer[3] = (address >> 8) & 0xFF; send_buffer[4] = (address >> 16) & 0xFF; - if (updi_physical_send(pgm, send_buffer, updi_get_datalink_mode(pgm) == UPDI_LINK_MODE_24BIT ? 5 : 4) < 0) { + if(updi_physical_send(pgm, send_buffer, updi_get_datalink_mode(pgm) == UPDI_LINK_MODE_24BIT? 5: 4) < 0) { pmsg_debug("ST operation send failed\n"); return -1; } @@ -863,13 +870,15 @@ int updi_link_st16(const PROGRAMMER *pgm, uint32_t address, uint16_t value) { return self._st_data_phase([value & 0xFF, (value >> 8) & 0xFF]) */ unsigned char send_buffer[5]; + pmsg_debug("ST16 to 0x%06X\n", address); send_buffer[0] = UPDI_PHY_SYNC; - send_buffer[1] = UPDI_STS | UPDI_DATA_16 | (updi_get_datalink_mode(pgm) == UPDI_LINK_MODE_24BIT ? UPDI_ADDRESS_24 : UPDI_ADDRESS_16); + send_buffer[1] = + UPDI_STS | UPDI_DATA_16 | (updi_get_datalink_mode(pgm) == UPDI_LINK_MODE_24BIT? UPDI_ADDRESS_24: UPDI_ADDRESS_16); send_buffer[2] = address & 0xFF; send_buffer[3] = (address >> 8) & 0xFF; send_buffer[4] = (address >> 16) & 0xFF; - if (updi_physical_send(pgm, send_buffer, updi_get_datalink_mode(pgm) == UPDI_LINK_MODE_24BIT ? 5 : 4) < 0) { + if(updi_physical_send(pgm, send_buffer, updi_get_datalink_mode(pgm) == UPDI_LINK_MODE_24BIT? 5: 4) < 0) { pmsg_debug("ST16 operation send failed\n"); return -1; } @@ -896,21 +905,23 @@ int updi_link_st_ptr(const PROGRAMMER *pgm, uint32_t address) { */ unsigned char send_buffer[5]; unsigned char recv_buffer[1]; + pmsg_debug("ST_PTR to 0x%06X\n", address); send_buffer[0] = UPDI_PHY_SYNC; - send_buffer[1] = UPDI_STS | UPDI_ST | UPDI_PTR_ADDRESS | (updi_get_datalink_mode(pgm) == UPDI_LINK_MODE_24BIT ? UPDI_DATA_24 : UPDI_DATA_16); + send_buffer[1] = UPDI_STS | UPDI_ST | UPDI_PTR_ADDRESS | + (updi_get_datalink_mode(pgm) == UPDI_LINK_MODE_24BIT? UPDI_DATA_24: UPDI_DATA_16); send_buffer[2] = address & 0xFF; send_buffer[3] = (address >> 8) & 0xFF; send_buffer[4] = (address >> 16) & 0xFF; - if (updi_physical_send(pgm, send_buffer, updi_get_datalink_mode(pgm) == UPDI_LINK_MODE_24BIT ? 5 : 4) < 0) { + if(updi_physical_send(pgm, send_buffer, updi_get_datalink_mode(pgm) == UPDI_LINK_MODE_24BIT? 5: 4) < 0) { pmsg_debug("ST_PTR operation send failed\n"); return -1; } - if (updi_physical_recv(pgm, recv_buffer, 1) < 0) { + if(updi_physical_recv(pgm, recv_buffer, 1) < 0) { pmsg_debug("UPDI ST_PTR recv failed on ACK\n"); return -1; } - if (recv_buffer[0] != UPDI_PHY_ACK) { + if(recv_buffer[0] != UPDI_PHY_ACK) { pmsg_debug("UPDI ST_PTR expected ACK\n"); return -1; }