Mirrors/avrdude
1
0
Fork 0
mirror of https://github.com/avrdudes/avrdude.git synced 2026-09-22 09:06:23 +03:00
Code Issues Packages Projects Releases Wiki Activity

Reformat spacing/comments in src/flip2.c

Browse Source
This commit is contained in:
Stefan Rueger
2024-08-18 01:54:13 +01:00
parent 9a3535531c
commit a028d30e1b
1 changed files with 236 additions and 245 deletions
Download Patch File Download Diff File Expand all files Collapse all files

481
src/flip2.c
View File

@@ -31,9 +31,10 @@
#include "flip2.h"
#include "dfu.h"
#include "usbdevs.h" /* for USB_VENDOR_ATMEL */
#include "usbdevs.h" // For USB_VENDOR_ATMEL
/* There are three versions of the FLIP protocol:
/*
* There are three versions of the FLIP protocol:
*
* Version 0: C51 parts
* Version 1: megaAVR parts ("USB DFU Bootloader Datasheet" [doc7618])
@@ -46,14 +47,9 @@
* udi_dfu_atmel.c from XMEGA bootloaders archive.
*/
/* EXPORTED CONSTANT STRINGS */
const char flip2_desc[] = "FLIP USB DFU protocol version 2 (AVR4023)";
/* PRIVATE DATA STRUCTURES */
struct flip2
{
struct flip2 {
struct dfu_dev *dfu;
unsigned char part_sig[3];
unsigned char part_rev;
@@ -76,7 +72,7 @@ struct flip2
#define FLIP2_STATUS_BLANK_FAIL 0x0500
#define FLIP2_STATUS_ERASE_ONGOING 0x0904
/* FLIP2 data structures and constants. */
// FLIP2 data structures and constants
struct flip2_cmd {
unsigned char group_id;
@@ -121,11 +117,9 @@ enum flip2_mem_unit {
#ifdef HAVE_LIBUSB
/* EXPORTED PROGRAMMER FUNCTION PROTOTYPES */
static int flip2_open(PROGRAMMER *pgm, const char *port_spec);
static int flip2_initialize(const PROGRAMMER *pgm, const AVRPART *part);
static void flip2_close(PROGRAMMER* pgm);
static void flip2_close(PROGRAMMER *pgm);
static void flip2_enable(PROGRAMMER *pgm, const AVRPART *p);
static void flip2_disable(const PROGRAMMER *pgm);
static void flip2_display(const PROGRAMMER *pgm, const char *prefix);
@@ -141,58 +135,51 @@ static int flip2_paged_load(const PROGRAMMER *pgm, const AVRPART *part, const AV
static int flip2_paged_write(const PROGRAMMER *pgm, const AVRPART *part, const AVRMEM *mem,
unsigned int page_size, unsigned int addr, unsigned int n_bytes);
static int flip2_read_sig_bytes(const PROGRAMMER *pgm, const AVRPART *part, const AVRMEM *mem);
static int flip2_parseexitspecs(PROGRAMMER* pgm, const char *s);
static int flip2_parseexitspecs(PROGRAMMER *pgm, const char *s);
static void flip2_setup(PROGRAMMER *pgm);
static void flip2_teardown(PROGRAMMER *pgm);
/* INTERNAL PROGRAMMER FUNCTION PROTOTYPES */
static void flip2_show_info(struct flip2 *flip2);
static int flip2_read_memory(struct dfu_dev *dfu,
enum flip2_mem_unit mem_unit, uint32_t addr, void *ptr, int size);
static int flip2_write_memory(struct dfu_dev *dfu,
enum flip2_mem_unit mem_unit, uint32_t addr, const void *ptr, int size);
static int flip2_set_mem_unit(struct dfu_dev *dfu,
enum flip2_mem_unit mem_unit);
static int flip2_read_memory(struct dfu_dev *dfu, enum flip2_mem_unit mem_unit,
uint32_t addr, void *ptr, int size);
static int flip2_write_memory(struct dfu_dev *dfu, enum flip2_mem_unit mem_unit,
uint32_t addr, const void *ptr, int size);
static int flip2_set_mem_unit(struct dfu_dev *dfu, enum flip2_mem_unit mem_unit);
static int flip2_set_mem_page(struct dfu_dev *dfu, unsigned short page_addr);
static int flip2_read_max1k(struct dfu_dev *dfu,
unsigned short offset, void *ptr, unsigned short size);
static int flip2_write_max1k(struct dfu_dev *dfu,
unsigned short offset, const void *ptr, unsigned short size);
static int flip2_read_max1k(struct dfu_dev *dfu, unsigned short offset,
void *ptr, unsigned short size);
static int flip2_write_max1k(struct dfu_dev *dfu, unsigned short offset,
const void *ptr, unsigned short size);
static const char * flip2_status_str(const struct dfu_status *status);
static const char * flip2_mem_unit_str(enum flip2_mem_unit mem_unit);
static const char *flip2_status_str(const struct dfu_status *status);
static const char *flip2_mem_unit_str(enum flip2_mem_unit mem_unit);
static enum flip2_mem_unit flip2_mem_unit(const char *name);
void flip2_initpgm(PROGRAMMER *pgm) {
strcpy(pgm->type, "flip2");
/* Mandatory Functions */
pgm->initialize = flip2_initialize;
pgm->enable = flip2_enable;
pgm->disable = flip2_disable;
pgm->display = flip2_display;
pgm->program_enable = flip2_program_enable;
pgm->chip_erase = flip2_chip_erase;
pgm->open = flip2_open;
pgm->close = flip2_close;
pgm->paged_load = flip2_paged_load;
pgm->paged_write = flip2_paged_write;
pgm->read_byte = flip2_read_byte;
pgm->write_byte = flip2_write_byte;
pgm->read_sig_bytes = flip2_read_sig_bytes;
pgm->parseexitspecs = flip2_parseexitspecs;
pgm->setup = flip2_setup;
pgm->teardown = flip2_teardown;
// Mandatory functions
pgm->initialize = flip2_initialize;
pgm->enable = flip2_enable;
pgm->disable = flip2_disable;
pgm->display = flip2_display;
pgm->program_enable = flip2_program_enable;
pgm->chip_erase = flip2_chip_erase;
pgm->open = flip2_open;
pgm->close = flip2_close;
pgm->paged_load = flip2_paged_load;
pgm->paged_write = flip2_paged_write;
pgm->read_byte = flip2_read_byte;
pgm->write_byte = flip2_write_byte;
pgm->read_sig_bytes = flip2_read_sig_bytes;
pgm->parseexitspecs = flip2_parseexitspecs;
pgm->setup = flip2_setup;
pgm->teardown = flip2_teardown;
}
/* EXPORTED PROGRAMMER FUNCTION DEFINITIONS */
static int flip2_open(PROGRAMMER *pgm, const char *port_spec) {
FLIP2(pgm)->dfu = dfu_open(port_spec);
return (FLIP2(pgm)->dfu != NULL) ? 0 : -1;
return (FLIP2(pgm)->dfu != NULL)? 0: -1;
}
static int flip2_initialize(const PROGRAMMER *pgm, const AVRPART *part) {
@@ -219,17 +206,18 @@ static int flip2_initialize(const PROGRAMMER *pgm, const AVRPART *part) {
* the PID when matching a target device.
*/
vid = (pgm->usbvid != 0) ? pgm->usbvid : USB_VENDOR_ATMEL;
vid = (pgm->usbvid != 0)? pgm->usbvid: USB_VENDOR_ATMEL;
LNODEID usbpid = lfirst(pgm->usbpid);
if (usbpid) {
pid = *(int *)(ldata(usbpid));
if (lnext(usbpid))
if(usbpid) {
pid = *(int *) (ldata(usbpid));
if(lnext(usbpid))
pmsg_warning("using PID 0x%04x, ignoring remaining PIDs in list\n", pid);
} else {
pid = part->usbpid;
}
if (!ovsigck && !(part->prog_modes & PM_PDI)) {
if(!ovsigck && !(part->prog_modes & PM_PDI)) {
pmsg_error("flip2 (FLIP protocol version 2) is for Xmega devices;\n");
imsg_error("for AT90USB* or ATmega*U* devices use flip1 or use -F to bypass this check\n");
return -1;
@@ -237,64 +225,52 @@ static int flip2_initialize(const PROGRAMMER *pgm, const AVRPART *part) {
result = dfu_init(dfu, vid, pid);
if (result != 0)
if(result != 0)
goto flip2_initialize_fail;
/* Check if descriptor values are what we expect. */
// Check if descriptor values are what we expect
if (dfu->dev_desc.idVendor != vid)
pmsg_warning("USB idVendor = 0x%04X (expected 0x%04X)\n",
dfu->dev_desc.idVendor, vid);
if(dfu->dev_desc.idVendor != vid)
pmsg_warning("USB idVendor = 0x%04X (expected 0x%04X)\n", dfu->dev_desc.idVendor, vid);
if (pid != 0 && dfu->dev_desc.idProduct != pid)
pmsg_warning("USB idProduct = 0x%04X (expected 0x%04X)\n",
dfu->dev_desc.idProduct, pid);
if(pid != 0 && dfu->dev_desc.idProduct != pid)
pmsg_warning("USB idProduct = 0x%04X (expected 0x%04X)\n", dfu->dev_desc.idProduct, pid);
if (dfu->dev_desc.bNumConfigurations != 1)
pmsg_error("USB bNumConfigurations = %d (expected 1)\n",
(int) dfu->dev_desc.bNumConfigurations);
if(dfu->dev_desc.bNumConfigurations != 1)
pmsg_error("USB bNumConfigurations = %d (expected 1)\n", (int) dfu->dev_desc.bNumConfigurations);
if (dfu->conf_desc.bNumInterfaces != 1)
pmsg_error("USB bNumInterfaces = %d (expected 1)\n",
(int) dfu->conf_desc.bNumInterfaces);
if(dfu->conf_desc.bNumInterfaces != 1)
pmsg_error("USB bNumInterfaces = %d (expected 1)\n", (int) dfu->conf_desc.bNumInterfaces);
if (dfu->dev_desc.bDeviceClass != 0)
pmsg_error("USB bDeviceClass = %d (expected 0)\n",
(int) dfu->dev_desc.bDeviceClass);
if(dfu->dev_desc.bDeviceClass != 0)
pmsg_error("USB bDeviceClass = %d (expected 0)\n", (int) dfu->dev_desc.bDeviceClass);
if (dfu->dev_desc.bDeviceSubClass != 0)
pmsg_error("USB bDeviceSubClass = %d (expected 0)\n",
(int) dfu->dev_desc.bDeviceSubClass);
if(dfu->dev_desc.bDeviceSubClass != 0)
pmsg_error("USB bDeviceSubClass = %d (expected 0)\n", (int) dfu->dev_desc.bDeviceSubClass);
if (dfu->dev_desc.bDeviceProtocol != 0)
pmsg_error("USB bDeviceProtocol = %d (expected 0)\n",
(int) dfu->dev_desc.bDeviceProtocol);
if(dfu->dev_desc.bDeviceProtocol != 0)
pmsg_error("USB bDeviceProtocol = %d (expected 0)\n", (int) dfu->dev_desc.bDeviceProtocol);
if (dfu->intf_desc.bInterfaceClass != 0xFF)
pmsg_error("USB bInterfaceClass = %d (expected 255)\n",
(int) dfu->intf_desc.bInterfaceClass);
if(dfu->intf_desc.bInterfaceClass != 0xFF)
pmsg_error("USB bInterfaceClass = %d (expected 255)\n", (int) dfu->intf_desc.bInterfaceClass);
if (dfu->intf_desc.bInterfaceSubClass != 0)
pmsg_error("USB bInterfaceSubClass = %d (expected 0)\n",
(int) dfu->intf_desc.bInterfaceSubClass);
if(dfu->intf_desc.bInterfaceSubClass != 0)
pmsg_error("USB bInterfaceSubClass = %d (expected 0)\n", (int) dfu->intf_desc.bInterfaceSubClass);
if (dfu->intf_desc.bInterfaceProtocol != 0)
pmsg_error("USB bInterfaceSubClass = %d (expected 0)\n",
(int) dfu->intf_desc.bInterfaceProtocol);
if(dfu->intf_desc.bInterfaceProtocol != 0)
pmsg_error("USB bInterfaceSubClass = %d (expected 0)\n", (int) dfu->intf_desc.bInterfaceProtocol);
result = flip2_read_memory(FLIP2(pgm)->dfu,
FLIP2_MEM_UNIT_SIGNATURE, 0, FLIP2(pgm)->part_sig, 4);
result = flip2_read_memory(FLIP2(pgm)->dfu, FLIP2_MEM_UNIT_SIGNATURE, 0, FLIP2(pgm)->part_sig, 4);
if (result != 0)
if(result != 0)
goto flip2_initialize_fail;
result = flip2_read_memory(FLIP2(pgm)->dfu,
FLIP2_MEM_UNIT_BOOTLOADER, 0, &FLIP2(pgm)->boot_ver, 1);
result = flip2_read_memory(FLIP2(pgm)->dfu, FLIP2_MEM_UNIT_BOOTLOADER, 0, &FLIP2(pgm)->boot_ver, 1);
if (result != 0)
if(result != 0)
goto flip2_initialize_fail;
if (verbose > 0)
if(verbose > 0)
flip2_show_info(FLIP2(pgm));
return 0;
@@ -306,8 +282,8 @@ flip2_initialize_fail:
}
static void flip2_close(PROGRAMMER *pgm) {
if (FLIP2(pgm)->dfu != NULL) {
if (pgm->exit_reset == EXIT_RESET_ENABLED)
if(FLIP2(pgm)->dfu != NULL) {
if(pgm->exit_reset == EXIT_RESET_ENABLED)
flip2_start_app(pgm);
dfu_close(FLIP2(pgm)->dfu);
@@ -336,20 +312,19 @@ static int flip2_chip_erase(const PROGRAMMER *pgm, const AVRPART *part) {
pmsg_debug("flip_chip_erase()\n");
struct flip2_cmd cmd = {
FLIP2_CMD_GROUP_EXEC, FLIP2_CMD_CHIP_ERASE, { 0xFF, 0, 0, 0 }
FLIP2_CMD_GROUP_EXEC, FLIP2_CMD_CHIP_ERASE, {0xFF, 0, 0, 0}
};
for (;;) {
for(;;) {
cmd_result = dfu_dnload(FLIP2(pgm)->dfu, &cmd, sizeof(cmd));
aux_result = dfu_getstatus(FLIP2(pgm)->dfu, &status);
if (aux_result != 0)
if(aux_result != 0)
return aux_result;
if (status.bStatus != DFU_STATUS_OK) {
if (status.bStatus == ((FLIP2_STATUS_ERASE_ONGOING >> 8) & 0xFF) &&
status.bState == ((FLIP2_STATUS_ERASE_ONGOING >> 0) & 0xFF))
{
if(status.bStatus != DFU_STATUS_OK) {
if(status.bStatus == ((FLIP2_STATUS_ERASE_ONGOING >> 8) & 0xFF) &&
status.bState == ((FLIP2_STATUS_ERASE_ONGOING >> 0) & 0xFF)) {
continue;
}
pmsg_error("DFU status %s\n", flip2_status_str(&status));
@@ -365,13 +340,13 @@ static int flip2_start_app(const PROGRAMMER *pgm) {
pmsg_info("starting application\n");
struct flip2_cmd cmd = {
FLIP2_CMD_GROUP_EXEC, FLIP2_CMD_START_APP, { 0x00, 0, 0, 0 }
FLIP2_CMD_GROUP_EXEC, FLIP2_CMD_START_APP, {0x00, 0, 0, 0}
};
// queue command
// Queue command
int cmd_result = dfu_dnload(FLIP2(pgm)->dfu, &cmd, sizeof(cmd));
// repeat dnload to actually execute
// Repeat dnload to actually execute
dfu_dnload(FLIP2(pgm)->dfu, &cmd, sizeof(cmd));
return cmd_result;
@@ -381,14 +356,14 @@ static int flip2_read_byte(const PROGRAMMER *pgm, const AVRPART *part, const AVR
unsigned long addr, unsigned char *value) {
enum flip2_mem_unit mem_unit;
if (FLIP2(pgm)->dfu == NULL)
if(FLIP2(pgm)->dfu == NULL)
return -1;
mem_unit = flip2_mem_unit(mem->desc);
if (mem_unit == FLIP2_MEM_UNIT_UNKNOWN) {
if(mem_unit == FLIP2_MEM_UNIT_UNKNOWN) {
pmsg_error("%s memory not accessible using FLIP", mem->desc);
if (mem_is_flash(mem))
if(mem_is_flash(mem))
msg_error(" (did you mean \"application\"?)");
msg_error("\n");
return -1;
@@ -403,6 +378,7 @@ static int flip2_write_byte(const PROGRAMMER *pgm, const AVRPART *part, const AV
if(mem_is_readonly(mem)) {
unsigned char is;
if(pgm->read_byte(pgm, part, mem, addr, &is) >= 0 && is == value)
return 0;
@@ -410,14 +386,14 @@ static int flip2_write_byte(const PROGRAMMER *pgm, const AVRPART *part, const AV
return -1;
}
if (FLIP2(pgm)->dfu == NULL)
if(FLIP2(pgm)->dfu == NULL)
return -1;
mem_unit = flip2_mem_unit(mem->desc);
if (mem_unit == FLIP2_MEM_UNIT_UNKNOWN) {
if(mem_unit == FLIP2_MEM_UNIT_UNKNOWN) {
pmsg_error("%s memory not accessible using FLIP", mem->desc);
if (mem_is_flash(mem))
if(mem_is_flash(mem))
msg_error(" (did you mean \"application\"?)");
msg_error("\n");
return -1;
@@ -432,27 +408,26 @@ static int flip2_paged_load(const PROGRAMMER *pgm, const AVRPART *part, const AV
enum flip2_mem_unit mem_unit;
int result;
if (FLIP2(pgm)->dfu == NULL)
if(FLIP2(pgm)->dfu == NULL)
return -1;
mem_unit = flip2_mem_unit(mem->desc);
if (mem_unit == FLIP2_MEM_UNIT_UNKNOWN) {
if(mem_unit == FLIP2_MEM_UNIT_UNKNOWN) {
pmsg_error("%s memory not accessible using FLIP", mem->desc);
if (mem_is_flash(mem))
if(mem_is_flash(mem))
msg_error(" (did you mean \"application\"?)");
msg_error("\n");
return -1;
}
if (n_bytes > INT_MAX) {
/* This should never happen, unless the int type is only 16 bits. */
if(n_bytes > INT_MAX) {
// This should never happen, unless the int type is only 16 bits
pmsg_error("attempting to read more than %d bytes\n", INT_MAX);
return -1;
}
result = flip2_read_memory(FLIP2(pgm)->dfu, mem_unit, addr,
mem->buf + addr, n_bytes);
result = flip2_read_memory(FLIP2(pgm)->dfu, mem_unit, addr, mem->buf + addr, n_bytes);
return result == 0? (int) n_bytes: -1;
}
@@ -463,27 +438,26 @@ static int flip2_paged_write(const PROGRAMMER *pgm, const AVRPART *part, const A
enum flip2_mem_unit mem_unit;
int result;
if (FLIP2(pgm)->dfu == NULL)
if(FLIP2(pgm)->dfu == NULL)
return -1;
mem_unit = flip2_mem_unit(mem->desc);
if (mem_unit == FLIP2_MEM_UNIT_UNKNOWN) {
if(mem_unit == FLIP2_MEM_UNIT_UNKNOWN) {
pmsg_error("%s memory not accessible using FLIP", mem->desc);
if (mem_is_flash(mem))
if(mem_is_flash(mem))
msg_error(" (did you mean \"application\"?)");
msg_error("\n");
return -1;
}
if (n_bytes > INT_MAX) {
/* This should never happen, unless the int type is only 16 bits. */
if(n_bytes > INT_MAX) {
// This should never happen, unless the int type is only 16 bits
pmsg_error("attempting to read more than %d bytes\n", INT_MAX);
return -1;
}
result = flip2_write_memory(FLIP2(pgm)->dfu, mem_unit, addr,
mem->buf + addr, n_bytes);
result = flip2_write_memory(FLIP2(pgm)->dfu, mem_unit, addr, mem->buf + addr, n_bytes);
return result == 0? (int) n_bytes: -1;
}
@@ -495,22 +469,22 @@ static int flip2_parseexitspecs(PROGRAMMER *pgm, const char *sp) {
bool help = false;
s = str;
while ((cp = strtok(s, ","))) {
while((cp = strtok(s, ","))) {
s = NULL;
if (str_eq(cp, "reset")) {
if(str_eq(cp, "reset")) {
pgm->exit_reset = EXIT_RESET_ENABLED;
continue;
}
if (str_eq(cp, "noreset")) {
if(str_eq(cp, "noreset")) {
pgm->exit_reset = EXIT_RESET_DISABLED;
continue;
}
if (str_eq(cp, "help")) {
if(str_eq(cp, "help")) {
help = true;
rv = LIBAVRDUDE_EXIT;
}
if (!help) {
if(!help) {
pmsg_error("invalid exitspec parameter -E %s\n", cp);
rv = -1;
}
@@ -527,10 +501,10 @@ static int flip2_parseexitspecs(PROGRAMMER *pgm, const char *sp) {
}
static int flip2_read_sig_bytes(const PROGRAMMER *pgm, const AVRPART *part, const AVRMEM *mem) {
if (FLIP2(pgm)->dfu == NULL)
if(FLIP2(pgm)->dfu == NULL)
return -1;
if (mem->size < (int) sizeof(FLIP2(pgm)->part_sig)) {
if(mem->size < (int) sizeof(FLIP2(pgm)->part_sig)) {
pmsg_error("signature read must be at least %u bytes\n", (unsigned int) sizeof(FLIP2(pgm)->part_sig));
return -1;
}
@@ -555,32 +529,27 @@ static void flip2_show_info(struct flip2 *flip2) {
dfu_show_info(flip2->dfu);
msg_info(" Part signature : 0x%02X%02X%02X\n",
(int) flip2->part_sig[0],
(int) flip2->part_sig[1],
(int) flip2->part_sig[2]);
(int) flip2->part_sig[0], (int) flip2->part_sig[1], (int) flip2->part_sig[2]);
if (flip2->part_rev < 26)
msg_info(" Part revision : %c\n",
(char) (flip2->part_rev + 'A'));
if(flip2->part_rev < 26)
msg_info(" Part revision : %c\n", (char) (flip2->part_rev + 'A'));
else
msg_info(" Part revision : %c%c\n",
(char) (flip2->part_rev / 26 - 1 + 'A'),
(char) (flip2->part_rev % 26 + 'A'));
(char) (flip2->part_rev/26 - 1 + 'A'), (char) (flip2->part_rev%26 + 'A'));
msg_info(" Bootloader version : 2.%u.%u\n",
(flip2->boot_ver >> 4) & 0xF,
(flip2->boot_ver >> 0) & 0xF);
(flip2->boot_ver >> 4) & 0xF, (flip2->boot_ver >> 0) & 0xF);
msg_info(" USB max packet size : %hu\n",
(unsigned short) flip2->dfu->dev_desc.bMaxPacketSize0);
}
static int flip2_read_memory(struct dfu_dev *dfu,
enum flip2_mem_unit mem_unit, uint32_t addr, void *ptr, int size) {
static int flip2_read_memory(struct dfu_dev *dfu, enum flip2_mem_unit mem_unit,
uint32_t addr, void *ptr, int size) {
unsigned short prev_page_addr;
unsigned short page_addr;
const char * mem_name;
const char *mem_name;
int read_size;
int result;
@@ -588,8 +557,8 @@ static int flip2_read_memory(struct dfu_dev *dfu,
result = flip2_set_mem_unit(dfu, mem_unit);
if (result != 0) {
if ((mem_name = flip2_mem_unit_str(mem_unit)) != NULL)
if(result != 0) {
if((mem_name = flip2_mem_unit_str(mem_unit)) != NULL)
pmsg_error("unable to set memory unit 0x%02X (%s)\n", (int) mem_unit, mem_name);
else
pmsg_error("unable to set memory unit 0x%02X\n", (int) mem_unit);
@@ -599,32 +568,32 @@ static int flip2_read_memory(struct dfu_dev *dfu,
page_addr = addr >> 16;
result = flip2_set_mem_page(dfu, page_addr);
if (result != 0) {
if(result != 0) {
pmsg_error("unable to set memory page 0x%04hX\n", page_addr);
return -1;
}
while (size > 0) {
while(size > 0) {
prev_page_addr = page_addr;
page_addr = addr >> 16;
if (page_addr != prev_page_addr) {
if(page_addr != prev_page_addr) {
result = flip2_set_mem_page(dfu, page_addr);
if (result != 0) {
if(result != 0) {
pmsg_error("unable to set memory page 0x%04hX\n", page_addr);
return -1;
}
}
read_size = (size > 0x400) ? 0x400 : size;
read_size = (size > 0x400)? 0x400: size;
result = flip2_read_max1k(dfu, addr & 0xFFFF, ptr, read_size);
if (result != 0) {
if(result != 0) {
pmsg_error("unable to read 0x%04X bytes at 0x%04lX\n", read_size, (unsigned long) addr);
return -1;
}
ptr = (char*)ptr + read_size;
ptr = (char *) ptr + read_size;
addr += read_size;
size -= read_size;
}
@@ -632,12 +601,12 @@ static int flip2_read_memory(struct dfu_dev *dfu,
return 0;
}
static int flip2_write_memory(struct dfu_dev *dfu,
enum flip2_mem_unit mem_unit, uint32_t addr, const void *ptr, int size) {
static int flip2_write_memory(struct dfu_dev *dfu, enum flip2_mem_unit mem_unit,
uint32_t addr, const void *ptr, int size) {
unsigned short prev_page_addr;
unsigned short page_addr;
const char * mem_name;
const char *mem_name;
int write_size;
int result;
@@ -645,8 +614,8 @@ static int flip2_write_memory(struct dfu_dev *dfu,
result = flip2_set_mem_unit(dfu, mem_unit);
if (result != 0) {
if ((mem_name = flip2_mem_unit_str(mem_unit)) != NULL)
if(result != 0) {
if((mem_name = flip2_mem_unit_str(mem_unit)) != NULL)
pmsg_error("unable to set memory unit 0x%02X (%s)\n", (int) mem_unit, mem_name);
else
pmsg_error("unable to set memory unit 0x%02X\n", (int) mem_unit);
@@ -656,32 +625,32 @@ static int flip2_write_memory(struct dfu_dev *dfu,
page_addr = addr >> 16;
result = flip2_set_mem_page(dfu, page_addr);
if (result != 0) {
if(result != 0) {
pmsg_error("unable to set memory page 0x%04hX\n", page_addr);
return -1;
}
while (size > 0) {
while(size > 0) {
prev_page_addr = page_addr;
page_addr = addr >> 16;
if (page_addr != prev_page_addr) {
if(page_addr != prev_page_addr) {
result = flip2_set_mem_page(dfu, page_addr);
if (result != 0) {
if(result != 0) {
pmsg_error("unable to set memory page 0x%04hX\n", page_addr);
return -1;
}
}
write_size = (size > 0x800) ? 0x800 : size;
write_size = (size > 0x800)? 0x800: size;
result = flip2_write_max1k(dfu, addr & 0xFFFF, ptr, write_size);
if (result != 0) {
if(result != 0) {
pmsg_error("unable to write 0x%04X bytes at 0x%04lX\n", write_size, (unsigned long) addr);
return -1;
}
ptr = (const char*)ptr + write_size;
ptr = (const char *) ptr + write_size;
addr += write_size;
size -= write_size;
}
@@ -695,7 +664,7 @@ static int flip2_set_mem_unit(struct dfu_dev *dfu, enum flip2_mem_unit mem_unit)
int aux_result;
struct flip2_cmd cmd = {
FLIP2_CMD_GROUP_SELECT, FLIP2_CMD_SELECT_MEMORY, { 0, 0, 0, 0 }
FLIP2_CMD_GROUP_SELECT, FLIP2_CMD_SELECT_MEMORY, {0, 0, 0, 0}
};
cmd.args[0] = FLIP2_SELECT_MEMORY_UNIT;
@@ -705,13 +674,13 @@ static int flip2_set_mem_unit(struct dfu_dev *dfu, enum flip2_mem_unit mem_unit)
aux_result = dfu_getstatus(dfu, &status);
if (aux_result != 0)
if(aux_result != 0)
return aux_result;
if (status.bStatus != DFU_STATUS_OK) {
if (status.bStatus == ((FLIP2_STATUS_OUTOFRANGE >> 8) & 0xFF) &&
status.bState == ((FLIP2_STATUS_OUTOFRANGE >> 0) & 0xFF))
{
if(status.bStatus != DFU_STATUS_OK) {
if(status.bStatus == ((FLIP2_STATUS_OUTOFRANGE >> 8) & 0xFF) &&
status.bState == ((FLIP2_STATUS_OUTOFRANGE >> 0) & 0xFF)) {
pmsg_error("unknown memory unit (0x%02x)\n", (unsigned int) mem_unit);
} else
pmsg_error("DFU status %s\n", flip2_status_str(&status));
@@ -721,15 +690,14 @@ static int flip2_set_mem_unit(struct dfu_dev *dfu, enum flip2_mem_unit mem_unit)
return cmd_result;
}
static int flip2_set_mem_page(struct dfu_dev *dfu,
unsigned short page_addr) {
static int flip2_set_mem_page(struct dfu_dev *dfu, unsigned short page_addr) {
struct dfu_status status;
int cmd_result = 0;
int aux_result;
struct flip2_cmd cmd = {
FLIP2_CMD_GROUP_SELECT, FLIP2_CMD_SELECT_MEMORY, { 0, 0, 0, 0 }
FLIP2_CMD_GROUP_SELECT, FLIP2_CMD_SELECT_MEMORY, {0, 0, 0, 0}
};
cmd.args[0] = FLIP2_SELECT_MEMORY_PAGE;
@@ -740,13 +708,13 @@ static int flip2_set_mem_page(struct dfu_dev *dfu,
aux_result = dfu_getstatus(dfu, &status);
if (aux_result != 0)
if(aux_result != 0)
return aux_result;
if (status.bStatus != DFU_STATUS_OK) {
if (status.bStatus == ((FLIP2_STATUS_OUTOFRANGE >> 8) & 0xFF) &&
status.bState == ((FLIP2_STATUS_OUTOFRANGE >> 0) & 0xFF))
{
if(status.bStatus != DFU_STATUS_OK) {
if(status.bStatus == ((FLIP2_STATUS_OUTOFRANGE >> 8) & 0xFF) &&
status.bState == ((FLIP2_STATUS_OUTOFRANGE >> 0) & 0xFF)) {
pmsg_error("page address out of range (0x%04hx)\n", page_addr);
} else
pmsg_error("DFU status %s\n", flip2_status_str(&status));
@@ -756,41 +724,40 @@ static int flip2_set_mem_page(struct dfu_dev *dfu,
return cmd_result;
}
static int flip2_read_max1k(struct dfu_dev *dfu,
unsigned short offset, void *ptr, unsigned short size) {
static int flip2_read_max1k(struct dfu_dev *dfu, unsigned short offset, void *ptr, unsigned short size) {
struct dfu_status status;
int cmd_result = 0;
int aux_result;
struct flip2_cmd cmd = {
FLIP2_CMD_GROUP_UPLOAD, FLIP2_CMD_READ_MEMORY, { 0, 0, 0, 0 }
FLIP2_CMD_GROUP_UPLOAD, FLIP2_CMD_READ_MEMORY, {0, 0, 0, 0}
};
cmd.args[0] = (offset >> 8) & 0xFF;
cmd.args[1] = (offset >> 0) & 0xFF;
cmd.args[2] = ((offset+size-1) >> 8) & 0xFF;
cmd.args[3] = ((offset+size-1) >> 0) & 0xFF;
cmd.args[2] = ((offset + size - 1) >> 8) & 0xFF;
cmd.args[3] = ((offset + size - 1) >> 0) & 0xFF;
cmd_result = dfu_dnload(dfu, &cmd, sizeof(cmd));
if (cmd_result != 0)
if(cmd_result != 0)
goto flip2_read_max1k_status;
cmd_result = dfu_upload(dfu, (char*) ptr, size);
cmd_result = dfu_upload(dfu, (char *) ptr, size);
flip2_read_max1k_status:
aux_result = dfu_getstatus(dfu, &status);
if (aux_result != 0)
if(aux_result != 0)
return aux_result;
if (status.bStatus != DFU_STATUS_OK) {
if (status.bStatus == ((FLIP2_STATUS_OUTOFRANGE >> 8) & 0xFF) &&
status.bState == ((FLIP2_STATUS_OUTOFRANGE >> 0) & 0xFF))
{
pmsg_error("address out of range [0x%04X,0x%04X]\n", offset, (offset+size-1) & 0xffff);
if(status.bStatus != DFU_STATUS_OK) {
if(status.bStatus == ((FLIP2_STATUS_OUTOFRANGE >> 8) & 0xFF) &&
status.bState == ((FLIP2_STATUS_OUTOFRANGE >> 0) & 0xFF)) {
pmsg_error("address out of range [0x%04X,0x%04X]\n", offset, (offset + size - 1) & 0xffff);
} else
pmsg_error("DFU status %s\n", flip2_status_str(&status));
dfu_clrstatus(dfu);
@@ -799,25 +766,24 @@ flip2_read_max1k_status:
return cmd_result;
}
static int flip2_write_max1k(struct dfu_dev *dfu,
unsigned short offset, const void *ptr, unsigned short size) {
static int flip2_write_max1k(struct dfu_dev *dfu, unsigned short offset, const void *ptr, unsigned short size) {
char buffer[64+64+0x400];
char buffer[64 + 64 + 0x400];
unsigned short data_offset;
struct dfu_status status;
int cmd_result = 0;
int aux_result;
struct flip2_cmd cmd = {
FLIP2_CMD_GROUP_DOWNLOAD, FLIP2_CMD_PROG_START, { 0, 0, 0, 0 }
FLIP2_CMD_GROUP_DOWNLOAD, FLIP2_CMD_PROG_START, {0, 0, 0, 0}
};
cmd.args[0] = (offset >> 8) & 0xFF;
cmd.args[1] = (offset >> 0) & 0xFF;
cmd.args[2] = ((offset+size-1) >> 8) & 0xFF;
cmd.args[3] = ((offset+size-1) >> 0) & 0xFF;
cmd.args[2] = ((offset + size - 1) >> 8) & 0xFF;
cmd.args[3] = ((offset + size - 1) >> 0) & 0xFF;
if (size > 0x400) {
if(size > 0x400) {
pmsg_error("erite block too large (%hu > 1024)\n", size);
return -1;
}
@@ -831,7 +797,7 @@ static int flip2_write_max1k(struct dfu_dev *dfu,
*/
data_offset = dfu->dev_desc.bMaxPacketSize0;
data_offset += offset % dfu->dev_desc.bMaxPacketSize0;
data_offset += offset%dfu->dev_desc.bMaxPacketSize0;
memcpy(buffer, &cmd, sizeof(cmd));
memset(buffer + sizeof(cmd), 0, data_offset - sizeof(cmd));
@@ -841,14 +807,14 @@ static int flip2_write_max1k(struct dfu_dev *dfu,
aux_result = dfu_getstatus(dfu, &status);
if (aux_result != 0)
if(aux_result != 0)
return aux_result;
if (status.bStatus != DFU_STATUS_OK) {
if (status.bStatus == ((FLIP2_STATUS_OUTOFRANGE >> 8) & 0xFF) &&
status.bState == ((FLIP2_STATUS_OUTOFRANGE >> 0) & 0xFF))
{
pmsg_error("address out of range [0x%04X,0x%04X]\n", offset, (offset+size-1) & 0xffff);
if(status.bStatus != DFU_STATUS_OK) {
if(status.bStatus == ((FLIP2_STATUS_OUTOFRANGE >> 8) & 0xFF) &&
status.bState == ((FLIP2_STATUS_OUTOFRANGE >> 0) & 0xFF)) {
pmsg_error("address out of range [0x%04X,0x%04X]\n", offset, (offset + size - 1) & 0xffff);
} else
pmsg_error("DFU status %s\n", flip2_status_str(&status));
dfu_clrstatus(dfu);
@@ -864,61 +830,86 @@ static const char *flip2_status_str(const struct dfu_status *status) {
selector |= status->bState;
switch (selector) {
case FLIP2_STATUS_OK: return "OK";
case FLIP2_STATUS_STALL: return "STALL";
case FLIP2_STATUS_MEM_UKNOWN: return "MEM_UKNOWN";
case FLIP2_STATUS_MEM_PROTECTED: return "MEM_PROTECTED";
case FLIP2_STATUS_OUTOFRANGE: return "OUTOFRANGE";
case FLIP2_STATUS_BLANK_FAIL: return "BLANK_FAIL";
case FLIP2_STATUS_ERASE_ONGOING: return "ERASE_ONGOING";
default: return dfu_status_str(status->bStatus);
case FLIP2_STATUS_OK:
return "OK";
case FLIP2_STATUS_STALL:
return "STALL";
case FLIP2_STATUS_MEM_UKNOWN:
return "MEM_UKNOWN";
case FLIP2_STATUS_MEM_PROTECTED:
return "MEM_PROTECTED";
case FLIP2_STATUS_OUTOFRANGE:
return "OUTOFRANGE";
case FLIP2_STATUS_BLANK_FAIL:
return "BLANK_FAIL";
case FLIP2_STATUS_ERASE_ONGOING:
return "ERASE_ONGOING";
default:
return dfu_status_str(status->bStatus);
}
}
static const char * flip2_mem_unit_str(enum flip2_mem_unit mem_unit) {
static const char *flip2_mem_unit_str(enum flip2_mem_unit mem_unit) {
switch (mem_unit) {
case FLIP2_MEM_UNIT_FLASH: return "Flash";
case FLIP2_MEM_UNIT_EEPROM: return "EEPROM";
case FLIP2_MEM_UNIT_SECURITY: return "security";
case FLIP2_MEM_UNIT_CONFIGURATION: return "configuration";
case FLIP2_MEM_UNIT_BOOTLOADER: return "bootloader version";
case FLIP2_MEM_UNIT_SIGNATURE: return "signature";
case FLIP2_MEM_UNIT_USER: return "user";
case FLIP2_MEM_UNIT_INT_RAM: return "internal RAM";
case FLIP2_MEM_UNIT_EXT_MEM_CS0: return "EXT_MEM_CS0";
case FLIP2_MEM_UNIT_EXT_MEM_CS1: return "EXT_MEM_CS1";
case FLIP2_MEM_UNIT_EXT_MEM_CS2: return "EXT_MEM_CS2";
case FLIP2_MEM_UNIT_EXT_MEM_CS3: return "EXT_MEM_CS3";
case FLIP2_MEM_UNIT_EXT_MEM_CS4: return "EXT_MEM_CS4";
case FLIP2_MEM_UNIT_EXT_MEM_CS5: return "EXT_MEM_CS5";
case FLIP2_MEM_UNIT_EXT_MEM_CS6: return "EXT_MEM_CS6";
case FLIP2_MEM_UNIT_EXT_MEM_CS7: return "EXT_MEM_CS7";
case FLIP2_MEM_UNIT_EXT_MEM_DF: return "EXT_MEM_DF";
default: return "unknown";
case FLIP2_MEM_UNIT_FLASH:
return "Flash";
case FLIP2_MEM_UNIT_EEPROM:
return "EEPROM";
case FLIP2_MEM_UNIT_SECURITY:
return "security";
case FLIP2_MEM_UNIT_CONFIGURATION:
return "configuration";
case FLIP2_MEM_UNIT_BOOTLOADER:
return "bootloader version";
case FLIP2_MEM_UNIT_SIGNATURE:
return "signature";
case FLIP2_MEM_UNIT_USER:
return "user";
case FLIP2_MEM_UNIT_INT_RAM:
return "internal RAM";
case FLIP2_MEM_UNIT_EXT_MEM_CS0:
return "EXT_MEM_CS0";
case FLIP2_MEM_UNIT_EXT_MEM_CS1:
return "EXT_MEM_CS1";
case FLIP2_MEM_UNIT_EXT_MEM_CS2:
return "EXT_MEM_CS2";
case FLIP2_MEM_UNIT_EXT_MEM_CS3:
return "EXT_MEM_CS3";
case FLIP2_MEM_UNIT_EXT_MEM_CS4:
return "EXT_MEM_CS4";
case FLIP2_MEM_UNIT_EXT_MEM_CS5:
return "EXT_MEM_CS5";
case FLIP2_MEM_UNIT_EXT_MEM_CS6:
return "EXT_MEM_CS6";
case FLIP2_MEM_UNIT_EXT_MEM_CS7:
return "EXT_MEM_CS7";
case FLIP2_MEM_UNIT_EXT_MEM_DF:
return "EXT_MEM_DF";
default:
return "unknown";
}
}
static enum flip2_mem_unit flip2_mem_unit(const char *name) {
if (str_eq(name, "application"))
if(str_eq(name, "application"))
return FLIP2_MEM_UNIT_FLASH;
if (str_eq(name, "eeprom"))
if(str_eq(name, "eeprom"))
return FLIP2_MEM_UNIT_EEPROM;
if (str_eq(name, "signature"))
if(str_eq(name, "signature"))
return FLIP2_MEM_UNIT_SIGNATURE;
return FLIP2_MEM_UNIT_UNKNOWN;
}
#else /* !HAVE_LIBUSB */
#else // !HAVE_LIBUSB
// Give a proper error if we were not compiled with libusb
static int flip2_nousb_open(PROGRAMMER* pgm, const char* name) {
pmsg_error("no USB support; please compile with libusb installed\n");
return -1;
static int flip2_nousb_open(PROGRAMMER *pgm, const char *name) {
pmsg_error("no USB support; please compile with libusb installed\n");
return -1;
}
void flip2_initpgm(PROGRAMMER *pgm) {
strcpy(pgm->type, "flip2");
pgm->open = flip2_nousb_open;
strcpy(pgm->type, "flip2");
pgm->open = flip2_nousb_open;
}
#endif /* HAVE_LIBUSB */
#endif // HAVE_LIBUSB