forked from PAWPAW-Mirror/lib_xua
492 lines
12 KiB
Plaintext
492 lines
12 KiB
Plaintext
#include <xs1.h>
|
|
#include <platform.h>
|
|
#include "devicedefines.h"
|
|
|
|
#include "xud.h"
|
|
//#ifdef ARCH_G
|
|
//#include "XUD_USB_Defines.h"
|
|
//#else
|
|
#include "usb.h"
|
|
//#endif
|
|
|
|
#include "dfu_types.h"
|
|
#include "flash_interface.h"
|
|
|
|
static int DFU_state = STATE_APP_IDLE;
|
|
static int DFU_status = DFU_OK;
|
|
static timer DFUTimer;
|
|
static unsigned int DFUTimerStart = 0;
|
|
static unsigned int DFUResetTimeout = 100000000; // 1 second default
|
|
static int DFU_flash_connected = 0;
|
|
|
|
static unsigned int subPagesLeft = 0;
|
|
|
|
extern int DFU_reset_override;
|
|
|
|
extern void DFUCustomFlashEnable();
|
|
extern void DFUCustomFlashDisable();
|
|
|
|
void temp()
|
|
{
|
|
asm(".linkset DFU_reset_override, _edp.bss");
|
|
asm(".globl DFU_reset_override");
|
|
}
|
|
|
|
static int DFU_OpenFlash(chanend ?c_user_cmd)
|
|
{
|
|
if (!DFU_flash_connected)
|
|
{
|
|
unsigned int cmd_data[16];
|
|
DFUCustomFlashEnable();
|
|
flash_cmd_init();
|
|
DFU_flash_connected = 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int DFU_CloseFlash(chanend ?c_user_cmd)
|
|
{
|
|
if (DFU_flash_connected)
|
|
{
|
|
unsigned int cmd_data[16];
|
|
DFUCustomFlashDisable();
|
|
flash_cmd_deinit();
|
|
DFU_flash_connected = 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int DFU_Detach(unsigned int timeout, chanend ?c_user_cmd)
|
|
{
|
|
if (DFU_state == STATE_APP_IDLE)
|
|
{
|
|
|
|
DFU_state = STATE_APP_DETACH;
|
|
|
|
DFU_OpenFlash(c_user_cmd);
|
|
|
|
// Setup DFU timeout value
|
|
DFUResetTimeout = timeout * 100000;
|
|
|
|
// Start DFU reset timer
|
|
DFUTimer :> DFUTimerStart;
|
|
}
|
|
else
|
|
{
|
|
DFU_state = STATE_DFU_ERROR;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int DFU_Dnload(unsigned int request_len, unsigned int block_num, unsigned int request_data[16], chanend ?c_user_cmd)
|
|
{
|
|
unsigned int fromDfuIdle = 0;
|
|
|
|
// Get DFU packets here, sequence is
|
|
// DFU_DOWNLOAD -> DFU_DOWNLOAD_SYNC
|
|
// GET_STATUS -> DFU_DOWNLOAD_SYNC (flash busy) || DFU_DOWNLOAD_IDLE
|
|
// REPEAT UNTIL DFU_DOWNLOAD with 0 length -> DFU_MANIFEST_SYNC
|
|
|
|
DFU_OpenFlash(c_user_cmd);
|
|
|
|
switch (DFU_state)
|
|
{
|
|
case STATE_DFU_IDLE:
|
|
case STATE_DFU_DOWNLOAD_IDLE:
|
|
break;
|
|
default:
|
|
DFU_state = STATE_DFU_ERROR;
|
|
return 0;
|
|
}
|
|
|
|
if ((DFU_state == STATE_DFU_IDLE) && (request_len == 0))
|
|
{
|
|
DFU_state = STATE_DFU_ERROR;
|
|
return 0;
|
|
}
|
|
else if (DFU_state == STATE_DFU_IDLE)
|
|
{
|
|
fromDfuIdle = 1;
|
|
}
|
|
else
|
|
{
|
|
fromDfuIdle = 0;
|
|
}
|
|
|
|
if (request_len == 0)
|
|
{
|
|
// Host signalling complete download
|
|
int i = 0;
|
|
unsigned int cmd_data[16];
|
|
if (subPagesLeft)
|
|
{
|
|
unsigned int subPagePad[16] = {0};
|
|
for (i = 0; i < subPagesLeft; i++)
|
|
{
|
|
flash_cmd_write_page_data((subPagePad, unsigned char[64]));
|
|
}
|
|
}
|
|
|
|
cmd_data[0] = 2; // Terminate write
|
|
flash_cmd_write_page((cmd_data, unsigned char[]));
|
|
|
|
DFU_state = STATE_DFU_MANIFEST_SYNC;
|
|
}
|
|
else
|
|
{
|
|
unsigned int i = 0;
|
|
unsigned int flash_cmd = 0;
|
|
unsigned int flash_page_index = 0;
|
|
unsigned int cmd_data[16];
|
|
|
|
if (fromDfuIdle)
|
|
{
|
|
unsigned s = 0;
|
|
|
|
// Erase flash on first block
|
|
flash_cmd_erase_all();
|
|
}
|
|
|
|
// Program firmware, STATE_DFU_DOWNLOAD_BUSY not currently used
|
|
if (!(block_num % 4))
|
|
{
|
|
cmd_data[0] = !fromDfuIdle; // 0 for first page, 1 for other pages.
|
|
flash_cmd_write_page((cmd_data, unsigned char[64]));
|
|
subPagesLeft = 4;
|
|
}
|
|
|
|
for (i = 0; i < 16; i++)
|
|
{
|
|
cmd_data[i] = request_data[i];
|
|
}
|
|
|
|
flash_cmd_write_page_data((cmd_data, unsigned char[64]));
|
|
subPagesLeft--;
|
|
|
|
DFU_state = STATE_DFU_DOWNLOAD_SYNC;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int DFU_Upload(unsigned int request_len, unsigned int block_num, unsigned int request_data[16], chanend ?c_user_cmd)
|
|
{
|
|
unsigned int cmd_data[16];
|
|
unsigned int firstRead = 0;
|
|
|
|
// Start at flash address 0
|
|
// Keep reading flash pages until read_page returns 1 (address out of range)
|
|
// Return terminating upload packet at this point
|
|
DFU_OpenFlash(c_user_cmd);
|
|
|
|
switch (DFU_state)
|
|
{
|
|
case STATE_DFU_IDLE:
|
|
case STATE_DFU_UPLOAD_IDLE:
|
|
break;
|
|
default:
|
|
DFU_state = STATE_DFU_ERROR;
|
|
return 0;
|
|
}
|
|
|
|
if ((DFU_state == STATE_DFU_IDLE) && (request_len == 0))
|
|
{
|
|
DFU_state = STATE_DFU_ERROR;
|
|
return 0;
|
|
}
|
|
else if (DFU_state == STATE_DFU_IDLE)
|
|
{
|
|
firstRead = 1;
|
|
subPagesLeft = 0;
|
|
}
|
|
|
|
if (!subPagesLeft)
|
|
{
|
|
cmd_data[0] = !firstRead;
|
|
|
|
// Read page
|
|
flash_cmd_read_page((cmd_data, unsigned char[64]));
|
|
subPagesLeft = 4;
|
|
|
|
// If address out of range, terminate!
|
|
if (cmd_data[0] == 1)
|
|
{
|
|
subPagesLeft = 0;
|
|
// Back to idle state, upload complete
|
|
DFU_state = STATE_DFU_IDLE;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
// Read page data
|
|
flash_cmd_write_page_data((request_data, unsigned char[64]));
|
|
|
|
subPagesLeft--;
|
|
|
|
DFU_state = STATE_DFU_UPLOAD_IDLE;
|
|
|
|
return 64;
|
|
}
|
|
|
|
static int DFU_GetStatus(unsigned int request_len, unsigned int request_data[16], chanend ?c_user_cmd)
|
|
{
|
|
unsigned int timeout = 0;
|
|
|
|
request_data[0] = timeout << 8 | (unsigned char)DFU_status;
|
|
|
|
switch (DFU_state)
|
|
{
|
|
case STATE_DFU_MANIFEST:
|
|
case STATE_DFU_MANIFEST_WAIT_RESET:
|
|
DFU_state = STATE_DFU_ERROR;
|
|
break;
|
|
case STATE_DFU_DOWNLOAD_BUSY:
|
|
// If download completes -> DFU_DOWNLOAD_SYNC
|
|
// Currently all transactions are synchronous so no busy state
|
|
break;
|
|
case STATE_DFU_DOWNLOAD_SYNC:
|
|
DFU_state = STATE_DFU_DOWNLOAD_IDLE;
|
|
break;
|
|
case STATE_DFU_MANIFEST_SYNC:
|
|
// Check if complete here
|
|
DFU_state = STATE_DFU_IDLE;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
request_data[1] = DFU_state;
|
|
|
|
return 6;
|
|
}
|
|
|
|
static int DFU_ClrStatus(void)
|
|
{
|
|
if (DFU_state == STATE_DFU_ERROR)
|
|
{
|
|
DFU_state = STATE_DFU_IDLE;
|
|
}
|
|
else
|
|
{
|
|
DFU_state = STATE_DFU_ERROR;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int DFU_GetState(unsigned int request_len, unsigned int request_data[16], chanend ?c_user_cmd)
|
|
{
|
|
|
|
request_data[0] = DFU_state;
|
|
|
|
switch (DFU_state)
|
|
{
|
|
case STATE_DFU_DOWNLOAD_BUSY:
|
|
case STATE_DFU_MANIFEST:
|
|
case STATE_DFU_MANIFEST_WAIT_RESET:
|
|
DFU_state = STATE_DFU_ERROR;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int DFU_Abort(void)
|
|
{
|
|
DFU_state = STATE_DFU_IDLE;
|
|
return 0;
|
|
}
|
|
|
|
// Tell the DFU state machine that a USB reset has occured
|
|
int DFUReportResetState(chanend ?c_user_cmd)
|
|
{
|
|
unsigned int inDFU = 0;
|
|
unsigned int currentTime = 0;
|
|
|
|
if (DFU_reset_override == 0x11042011)
|
|
{
|
|
unsigned int cmd_data[16];
|
|
inDFU = 1;
|
|
DFU_state = STATE_DFU_IDLE;
|
|
return inDFU;
|
|
}
|
|
|
|
switch(DFU_state)
|
|
{
|
|
case STATE_APP_DETACH:
|
|
case STATE_DFU_IDLE:
|
|
DFU_state = STATE_DFU_IDLE;
|
|
|
|
DFUTimer :> currentTime;
|
|
if (currentTime - DFUTimerStart > DFUResetTimeout)
|
|
{
|
|
DFU_state = STATE_APP_IDLE;
|
|
inDFU = 0;
|
|
}
|
|
else
|
|
{
|
|
inDFU = 1;
|
|
}
|
|
break;
|
|
case STATE_APP_IDLE:
|
|
case STATE_DFU_DOWNLOAD_SYNC:
|
|
case STATE_DFU_DOWNLOAD_BUSY:
|
|
case STATE_DFU_DOWNLOAD_IDLE:
|
|
case STATE_DFU_MANIFEST_SYNC:
|
|
case STATE_DFU_MANIFEST:
|
|
case STATE_DFU_MANIFEST_WAIT_RESET:
|
|
case STATE_DFU_UPLOAD_IDLE:
|
|
case STATE_DFU_ERROR:
|
|
inDFU = 0;
|
|
DFU_state = STATE_APP_IDLE;
|
|
break;
|
|
default:
|
|
DFU_state = STATE_DFU_ERROR;
|
|
inDFU = 1;
|
|
break;
|
|
}
|
|
|
|
if (!inDFU)
|
|
{
|
|
DFU_CloseFlash(c_user_cmd);
|
|
}
|
|
|
|
return inDFU;
|
|
}
|
|
|
|
static int XMOS_DFU_RevertFactory(chanend ?c_user_cmd)
|
|
{
|
|
unsigned s = 0;
|
|
|
|
DFU_OpenFlash(c_user_cmd);
|
|
|
|
flash_cmd_erase_all();
|
|
|
|
DFUTimer :> s;
|
|
DFUTimer when timerafter(s + 25000000) :> s; // Wait for flash erase
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int XMOS_DFU_SelectImage(unsigned int index, chanend ?c_user_cmd)
|
|
{
|
|
// Select the image index for firmware update
|
|
// Currently not used or implemented
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int XMOS_DFU_SaveState()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static int XMOS_DFU_LoadState()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int DFUDeviceRequests(XUD_ep ep0_out, XUD_ep &?ep0_in, USB_SetupPacket_t &sp, chanend ?c_user_cmd, unsigned int altInterface, unsigned int user_reset)
|
|
{
|
|
unsigned int return_data_len = 0;
|
|
unsigned int data_buffer_len = 0;
|
|
unsigned int data_buffer[17];
|
|
unsigned int reset_device_after_ack = 0;
|
|
|
|
if(sp.bmRequestType.Direction == USB_BM_REQTYPE_DIRECTION_H2D)
|
|
{
|
|
// Host to device
|
|
if (sp.wLength)
|
|
data_buffer_len = XUD_GetBuffer(ep0_out, (data_buffer, unsigned char[]));
|
|
}
|
|
|
|
// Map Standard DFU commands onto device level firmware upgrade mechanism
|
|
switch (sp.bRequest)
|
|
{
|
|
case DFU_DETACH:
|
|
return_data_len = DFU_Detach(sp.wValue, c_user_cmd);
|
|
break;
|
|
case DFU_DNLOAD:
|
|
return_data_len = DFU_Dnload(sp.wLength, sp.wValue, data_buffer, c_user_cmd);
|
|
break;
|
|
case DFU_UPLOAD:
|
|
return_data_len = DFU_Upload(sp.wLength, sp.wValue, data_buffer, c_user_cmd);
|
|
break;
|
|
case DFU_GETSTATUS:
|
|
return_data_len = DFU_GetStatus(sp.wLength, data_buffer, c_user_cmd);
|
|
break;
|
|
case DFU_CLRSTATUS:
|
|
return_data_len = DFU_ClrStatus();
|
|
break;
|
|
case DFU_GETSTATE:
|
|
return_data_len = DFU_GetState(sp.wLength, data_buffer, c_user_cmd);
|
|
break;
|
|
case DFU_ABORT:
|
|
return_data_len = DFU_Abort();
|
|
break;
|
|
/* XMOS Custom DFU requests */
|
|
case XMOS_DFU_RESETDEVICE:
|
|
reset_device_after_ack = 1;
|
|
return_data_len = 0;
|
|
break;
|
|
case XMOS_DFU_REVERTFACTORY:
|
|
return_data_len = XMOS_DFU_RevertFactory(c_user_cmd);
|
|
break;
|
|
case XMOS_DFU_RESETINTODFU:
|
|
reset_device_after_ack = 1;
|
|
DFU_reset_override = 0x11042011;
|
|
return_data_len = 0;
|
|
break;
|
|
case XMOS_DFU_RESETFROMDFU:
|
|
reset_device_after_ack = 1;
|
|
DFU_reset_override = 0;
|
|
return_data_len = 0;
|
|
break;
|
|
case XMOS_DFU_SELECTIMAGE:
|
|
return_data_len = XMOS_DFU_SelectImage(sp.wValue, c_user_cmd);
|
|
break;
|
|
case XMOS_DFU_SAVESTATE:
|
|
/* Save passed state to flash */
|
|
return_data_len = XMOS_DFU_SaveState();
|
|
break;
|
|
case XMOS_DFU_RESTORESTATE:
|
|
/* Restore saved state from flash */
|
|
return_data_len = XMOS_DFU_LoadState();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (sp.bmRequestType.Direction == USB_BM_REQTYPE_DIRECTION_D2H && sp.wLength != 0)
|
|
{
|
|
// Device to host
|
|
#ifdef ARCH_G
|
|
XUD_DoGetRequest(ep0_out, 0, (data_buffer, unsigned char[]), return_data_len, return_data_len);
|
|
#else
|
|
XUD_DoGetRequest(ep0_out, ep0_in, (data_buffer, unsigned char[]), return_data_len, return_data_len);
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
#ifdef ARCH_G
|
|
XUD_DoSetRequestStatus(ep0_out);
|
|
#else
|
|
XUD_DoSetRequestStatus(ep0_in);
|
|
#endif
|
|
}
|
|
|
|
// If device reset requested, handle after command acknowledgement
|
|
if (reset_device_after_ack)
|
|
{
|
|
if (user_reset)
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|