void gpio_init(void)
{
SIM->SCGC5 |= SIM_SCGC5_PORTA_MASK | SIM_SCGC5_PORTB_MASK | SIM_SCGC5_PORTC_MASK | SIM_SCGC5_PORTD_MASK | SIM_SCGC5_PORTE_MASK;
// configure pin as GPIO
PIN_HID_LED_PORT->PCR[PIN_HID_LED_BIT] = PORT_PCR_MUX(1);
PIN_MSC_LED_PORT->PCR[PIN_MSC_LED_BIT] = PORT_PCR_MUX(1);
PIN_CDC_LED_PORT->PCR[PIN_CDC_LED_BIT] = PORT_PCR_MUX(1);
PIN_SW_RESET_PORT->PCR[PIN_SW_RESET_BIT] = PORT_PCR_MUX(1);
PIN_POWER_EN_PORT->PCR[PIN_POWER_EN_BIT] = PORT_PCR_MUX(1);
// led off
gpio_set_hid_led(GPIO_LED_OFF);
gpio_set_cdc_led(GPIO_LED_OFF);
gpio_set_msc_led(GPIO_LED_OFF);
// power regulator on
PIN_POWER_EN_GPIO->PDOR |= PIN_POWER_EN;
// set as output
PIN_HID_LED_GPIO->PDDR |= PIN_HID_LED;
PIN_MSC_LED_GPIO->PDDR |= PIN_MSC_LED;
PIN_CDC_LED_GPIO->PDDR |= PIN_CDC_LED;
PIN_POWER_EN_GPIO->PDDR |= PIN_POWER_EN;
// set as input
PIN_SW_RESET_GPIO->PDDR &= ~PIN_SW_RESET;
}
void gpio_init(void)
{
SIM->SCGC5 |= SIM_SCGC5_PORTA_MASK | SIM_SCGC5_PORTB_MASK | SIM_SCGC5_PORTC_MASK | SIM_SCGC5_PORTD_MASK | SIM_SCGC5_PORTE_MASK;
// configure pin as GPIO
PIN_HID_LED_PORT->PCR[PIN_HID_LED_BIT] = PORT_PCR_MUX(1);
PIN_MSC_LED_PORT->PCR[PIN_MSC_LED_BIT] = PORT_PCR_MUX(1);
PIN_CDC_LED_PORT->PCR[PIN_CDC_LED_BIT] = PORT_PCR_MUX(1);
PIN_SW_RESET_PORT->PCR[PIN_SW_RESET_BIT] = PORT_PCR_MUX(1);
PIN_POWER_EN_PORT->PCR[PIN_POWER_EN_BIT] = PORT_PCR_MUX(1);
// led off
gpio_set_hid_led(GPIO_LED_OFF);
gpio_set_cdc_led(GPIO_LED_OFF);
gpio_set_msc_led(GPIO_LED_OFF);
// power regulator on
PIN_POWER_EN_GPIO->PDOR |= PIN_POWER_EN;
// set as output
PIN_HID_LED_GPIO->PDDR |= PIN_HID_LED;
PIN_MSC_LED_GPIO->PDDR |= PIN_MSC_LED;
PIN_CDC_LED_GPIO->PDDR |= PIN_CDC_LED;
PIN_POWER_EN_GPIO->PDDR |= PIN_POWER_EN;
// set as input
PIN_SW_RESET_GPIO->PDDR &= ~PIN_SW_RESET;
// Let the voltage rails stabilize. This is especailly important
// during software resets, since the target's 3.3v rail can take
// 20-50ms to drain. During this time the target could be driving
// the reset pin low, causing the bootloader to think the reset
// button is pressed.
// Note: With optimization set to -O2 the value 1000000 delays for ~85ms
busy_wait(1000000);
}
__task void main_task(void)
{
// State processing
uint16_t flags = 0;
// LED
gpio_led_state_t hid_led_value = GPIO_LED_ON;
gpio_led_state_t cdc_led_value = GPIO_LED_ON;
gpio_led_state_t msc_led_value = GPIO_LED_ON;
// USB
uint32_t usb_state_count = USB_BUSY_TIME;
// thread running after usb connected started
uint8_t thread_started = 0;
// button state
main_reset_state_t main_reset_button_state = MAIN_RESET_RELEASED;
// Initialize settings
config_init();
// Initialize our serial mailbox
os_mbx_init(&serial_mailbox, sizeof(serial_mailbox));
// Get a reference to this task
main_task_id = os_tsk_self();
// leds
gpio_init();
// Turn off LED
gpio_set_hid_led(GPIO_LED_ON);
gpio_set_cdc_led(GPIO_LED_ON);
gpio_set_msc_led(GPIO_LED_ON);
// do some init with the target before USB and files are configured
prerun_target_config();
// Update versions and IDs
info_init();
// USB
usbd_init();
vfs_user_enable(true);
usbd_connect(0);
usb_state = USB_CONNECTING;
usb_state_count = USB_CONNECT_DELAY;
// Start timer tasks
os_tsk_create_user(timer_task_30mS, TIMER_TASK_30_PRIORITY, (void *)stk_timer_30_task, TIMER_TASK_30_STACK);
// Target running
target_set_state(RESET_RUN);
while(1) {
os_evt_wait_or( FLAGS_MAIN_RESET // Put target in reset state
| FLAGS_MAIN_90MS // 90mS tick
| FLAGS_MAIN_30MS // 30mS tick
| FLAGS_MAIN_POWERDOWN // Power down interface
| FLAGS_MAIN_DISABLEDEBUG // Disable target debug
| FLAGS_MAIN_PROC_USB // process usb events
,NO_TIMEOUT);
// Find out what event happened
flags = os_evt_get();
if (flags & FLAGS_MAIN_PROC_USB) {
USBD_Handler();
}
if (flags & FLAGS_MAIN_RESET) {
target_set_state(RESET_RUN);
}
if (flags & FLAGS_MAIN_POWERDOWN) {
// Disable debug
target_set_state(NO_DEBUG);
// Disconnect USB
usbd_connect(0);
// Turn off LED
gpio_set_hid_led(GPIO_LED_OFF);
gpio_set_cdc_led(GPIO_LED_OFF);
gpio_set_msc_led(GPIO_LED_OFF);
// TODO: put the interface chip in sleep mode
while(1);
}
if (flags & FLAGS_MAIN_DISABLEDEBUG) {
// Disable debug
target_set_state(NO_DEBUG);
}
if (flags & FLAGS_MAIN_90MS) {
// Update USB busy status
vfs_user_periodic(90); // FLAGS_MAIN_90MS
// Update USB connect status
switch (usb_state) {
case USB_DISCONNECTING:
usb_state = USB_DISCONNECTED;
usbd_connect(0);
break;
case USB_CONNECTING:
// Wait before connecting
if (DECZERO(usb_state_count) == 0) {
usbd_connect(1);
usb_state = USB_CHECK_CONNECTED;
}
break;
case USB_CHECK_CONNECTED:
if(usbd_configured()) {
if (!thread_started) {
os_tsk_create_user(hid_process, DAP_TASK_PRIORITY, (void *)stk_dap_task, DAP_TASK_STACK);
serial_task_id = os_tsk_create_user(serial_process, SERIAL_TASK_PRIORITY, (void *)stk_serial_task, SERIAL_TASK_STACK);
thread_started = 1;
}
usb_state = USB_CONNECTED;
}
break;
case USB_CONNECTED:
case USB_DISCONNECTED:
default:
break;
}
}
// 30mS tick used for flashing LED when USB is busy
if (flags & FLAGS_MAIN_30MS) {
// handle reset button without eventing
switch (main_reset_button_state) {
default:
case MAIN_RESET_RELEASED:
if (0 == gpio_get_sw_reset()) {
main_reset_button_state = MAIN_RESET_PRESSED;
target_forward_reset(true);
}
break;
case MAIN_RESET_PRESSED:
// ToDo: add a counter to do a mass erase or target recovery after xxx seconds of being held
if (1 == gpio_get_sw_reset()) {
main_reset_button_state = MAIN_RESET_TARGET;
}
break;
case MAIN_RESET_TARGET:
target_forward_reset(false);
main_reset_button_state = MAIN_RESET_RELEASED;
break;
}
if (hid_led_usb_activity && ((hid_led_state == MAIN_LED_FLASH) || (hid_led_state == MAIN_LED_FLASH_PERMANENT))) {
// Flash DAP LED ONCE
if (hid_led_value) {
hid_led_value = GPIO_LED_OFF;
} else {
hid_led_value = GPIO_LED_ON; // Turn on
if (hid_led_state == MAIN_LED_FLASH) {
hid_led_usb_activity = 0;
}
}
// Update hardware
gpio_set_hid_led(hid_led_value);
}
if (msc_led_usb_activity && ((msc_led_state == MAIN_LED_FLASH) || (msc_led_state == MAIN_LED_FLASH_PERMANENT))) {
// Flash MSD LED ONCE
if (msc_led_value) {
msc_led_value = GPIO_LED_OFF;
} else {
msc_led_value = GPIO_LED_ON; // Turn on
if (msc_led_state == MAIN_LED_FLASH) {
msc_led_usb_activity = 0;
}
}
// Update hardware
gpio_set_msc_led(msc_led_value);
}
if (cdc_led_usb_activity && ((cdc_led_state == MAIN_LED_FLASH) || (cdc_led_state == MAIN_LED_FLASH_PERMANENT))) {
// Flash CDC LED ONCE
if (cdc_led_value) {
cdc_led_value = GPIO_LED_OFF;
} else {
cdc_led_value = GPIO_LED_ON; // Turn on
if (cdc_led_state == MAIN_LED_FLASH) {
cdc_led_usb_activity = 0;
}
}
// Update hardware
gpio_set_cdc_led(cdc_led_value);
}
}
}
}
__task void main_task(void) {
// State processing
uint16_t flags;
// LED
uint8_t dap_led_value = 1;
uint8_t cdc_led_value = 1;
uint8_t msd_led_value = 1;
// USB
uint32_t usb_state_count;
// thread running after usb connected started
uint8_t thread_started = 0;
// button state
char button_activated;
// string containing unique ID
uint8_t * id_str;
// Get a reference to this task
main_task_id = os_tsk_self();
// leds
gpio_init();
usbd_init();
swd_init();
// Turn on LED
gpio_set_dap_led(1);
gpio_set_cdc_led(1);
gpio_set_msd_led(1);
// Setup reset button
gpio_enable_button_flag(main_task_id, FLAGS_MAIN_RESET);
button_activated = 1;
// USB
usbd_connect(0);
usb_busy = USB_IDLE;
usb_busy_count = 0;
usb_state = USB_CONNECTING;
usb_state_count = USB_CONNECT_DELAY;
// Update HTML version information file
update_html_file();
// Start timer tasks
os_tsk_create_user(timer_task_30mS, TIMER_TASK_30_PRIORITY, (void *)stk_timer_30_task, TIMER_TASK_30_STACK);
// Target running
target_set_state(RESET_RUN_WITH_DEBUG);
// start semihost task
semihost_init();
semihost_enable();
while(1) {
os_evt_wait_or( FLAGS_MAIN_RESET // Put target in reset state
| FLAGS_MAIN_90MS // 90mS tick
| FLAGS_MAIN_30MS // 30mS tick
| FLAGS_MAIN_POWERDOWN // Power down interface
| FLAGS_MAIN_DISABLEDEBUG // Power down interface
| FLAGS_MAIN_USB_DISCONNECT, // Disable target debug
NO_TIMEOUT);
// Find out what event happened
flags = os_evt_get();
if (flags & FLAGS_MAIN_USB_DISCONNECT) {
usb_busy = USB_IDLE; // USB not busy
usb_state_count = 4;
usb_state = USB_DISCONNECT_CONNECT; // disconnect the usb
}
if (flags & FLAGS_MAIN_RESET) {
cdc_led_state = LED_OFF;
gpio_set_cdc_led(0);
//usbd_cdc_ser_flush();
if (send_uID) {
// set the target in reset to not receive char on the serial port
target_set_state(RESET_HOLD);
// send uid
id_str = get_uid_string();
USBD_CDC_ACM_DataSend(id_str, strlen((const char *)id_str));
send_uID = 0;
}
// Reset target
target_set_state(RESET_RUN);
cdc_led_state = LED_FLASH;
gpio_set_cdc_led(1);
button_activated = 0;
}
if (flags & FLAGS_MAIN_POWERDOWN) {
// Stop semihost task
semihost_disable();
// Disable debug
target_set_state(NO_DEBUG);
// Disconnect USB
usbd_connect(0);
// Turn off LED
gpio_set_dap_led(0);
gpio_set_cdc_led(0);
gpio_set_msd_led(0);
// TODO: put the interface chip in sleep mode
while (1) { }
}
if (flags & FLAGS_MAIN_DISABLEDEBUG) {
// Stop semihost task
semihost_disable();
// Disable debug
target_set_state(NO_DEBUG);
}
if (flags & FLAGS_MAIN_90MS) {
if (!button_activated) {
gpio_enable_button_flag(main_task_id, FLAGS_MAIN_RESET);
button_activated = 1;
}
// Update USB busy status
switch (usb_busy) {
case USB_ACTIVE:
if (DECZERO(usb_busy_count) == 0) {
usb_busy=USB_IDLE;
}
break;
case USB_IDLE:
default:
break;
}
// Update USB connect status
switch (usb_state) {
case USB_DISCONNECTING:
// Wait until USB is idle before disconnecting
if (usb_busy == USB_IDLE) {
usbd_connect(0);
usb_state = USB_DISCONNECTED;
}
break;
case USB_DISCONNECT_CONNECT:
// Wait until USB is idle before disconnecting
if ((usb_busy == USB_IDLE) && (DECZERO(usb_state_count) == 0)) {
usbd_connect(0);
usb_state = USB_CONNECTING;
// Update HTML file
update_html_file();
}
break;
case USB_CONNECTING:
// Wait before connecting
if (DECZERO(usb_state_count) == 0) {
usbd_connect(1);
usb_state = USB_CHECK_CONNECTED;
}
break;
case USB_CHECK_CONNECTED:
if(usbd_configured()) {
if (!thread_started) {
os_tsk_create_user(hid_process, DAP_TASK_PRIORITY, (void *)stk_dap_task, DAP_TASK_STACK);
serial_task_id = os_tsk_create_user(serial_process, SERIAL_TASK_PRIORITY, (void *)stk_serial_task, SERIAL_TASK_STACK);
thread_started = 1;
}
usb_state = USB_CONNECTED;
}
break;
case USB_CONNECTED:
case USB_DISCONNECTED:
default:
break;
}
}
// 30mS tick used for flashing LED when USB is busy
if (flags & FLAGS_MAIN_30MS) {
if (dap_led_usb_activity && ((dap_led_state == LED_FLASH) || (dap_led_state == LED_FLASH_PERMANENT))) {
// Flash DAP LED ONCE
if (dap_led_value) {
dap_led_value = 0;
} else {
dap_led_value = 1; // Turn on
if (dap_led_state == LED_FLASH) {
dap_led_usb_activity = 0;
}
}
// Update hardware
gpio_set_dap_led(dap_led_value);
}
if (msd_led_usb_activity && ((msd_led_state == LED_FLASH) || (msd_led_state == LED_FLASH_PERMANENT))) {
// Flash MSD LED ONCE
if (msd_led_value) {
msd_led_value = 0;
} else {
msd_led_value = 1; // Turn on
if (msd_led_state == LED_FLASH) {
msd_led_usb_activity = 0;
}
}
// Update hardware
gpio_set_msd_led(msd_led_value);
}
if (cdc_led_usb_activity && ((cdc_led_state == LED_FLASH) || (cdc_led_state == LED_FLASH_PERMANENT))) {
// Flash CDC LED ONCE
if (cdc_led_value) {
cdc_led_value = 0;
} else {
cdc_led_value = 1; // Turn on
if (cdc_led_state == LED_FLASH) {
cdc_led_usb_activity = 0;
}
}
// Update hardware
gpio_set_cdc_led(cdc_led_value);
}
}
}
}
__task void main_task(void) {
// State processing
uint16_t flags;
// LED
uint8_t dap_led_value = 1;
uint8_t cdc_led_value = 1;
uint8_t msd_led_value = 1;
// USB
uint32_t usb_state_count;
// thread running after usb connected started
uint8_t thread_started = 0;
// button state
char button_activated;
// string containing unique ID
uint8_t * id_str;
// Initialize our serial mailbox
os_mbx_init(&serial_mailbox, sizeof(serial_mailbox));
// Get a reference to this task
main_task_id = os_tsk_self();
// leds
gpio_init();
// Turn off LED
gpio_set_dap_led(1);
gpio_set_cdc_led(1);
gpio_set_msd_led(1);
#ifdef BOARD_UBLOX_C027
PORT_SWD_SETUP();
// wait until reset output to the target is pulled high
while (!PIN_nRESET_IN()) {
/* wait doing nothing */
}
os_dly_wait(4);
// if the reset input from button is low then enter isp programming mode
if (!(LPC_GPIO->B[19/*RESET_PIN*/ + (1/*RESET_PORT*/ << 5)] & 1)) {
enter_isp();
}
#endif
usbd_init();
swd_init();
// Setup reset button
gpio_enable_button_flag(main_task_id, FLAGS_MAIN_RESET);
button_activated = 1;
// USB
usbd_connect(0);
usb_busy = USB_IDLE;
usb_busy_count = 0;
usb_state = USB_CONNECTING;
usb_state_count = USB_CONNECT_DELAY;
// Update HTML version information file
update_html_file();
// Start timer tasks
os_tsk_create_user(timer_task_30mS, TIMER_TASK_30_PRIORITY, (void *)stk_timer_30_task, TIMER_TASK_30_STACK);
#ifndef BOARD_UBLOX_C027
// Target running
//target_set_state(RESET_RUN_WITH_DEBUG);
#endif
#ifdef BOARD_NRF51822AA
// Target running
target_set_state(RESET_RUN);
#endif
// start semihost task
semihost_init();
semihost_enable();
while(1) {
os_evt_wait_or( FLAGS_MAIN_RESET // Put target in reset state
| FLAGS_MAIN_90MS // 90mS tick
| FLAGS_MAIN_30MS // 30mS tick
| FLAGS_MAIN_POWERDOWN // Power down interface
| FLAGS_MAIN_DISABLEDEBUG // Power down interface
#ifdef USE_USB_EJECT_INSERT
| FLAGS_MAIN_USB_DISCONNECT // Disable target debug
| FLAGS_MAIN_USB_MEDIA_EJECT, // Eject file system
#else
| FLAGS_MAIN_USB_DISCONNECT, // Disable target debug
#endif
NO_TIMEOUT);
// Find out what event happened
flags = os_evt_get();
if (flags & FLAGS_MAIN_USB_DISCONNECT) {
usb_busy = USB_IDLE; // USB not busy
usb_state_count = 4;
usb_state = USB_DISCONNECT_CONNECT; // disconnect the usb
}
#ifdef USE_USB_EJECT_INSERT
if (flags & FLAGS_MAIN_USB_MEDIA_EJECT) {
EjectInsertMediaMode = EJECT_INSERT_WAIT_TO_EJECT;
EjectInsertMediaCounter = EJECT_INSERT_DELAY_500MS;
}
#endif
if (flags & FLAGS_MAIN_RESET) {
cdc_led_state = LED_OFF;
gpio_set_cdc_led(0);
//usbd_cdc_ser_flush();
if (send_uID) {
// set the target in reset to not receive char on the serial port
target_set_state(RESET_HOLD);
// send uid
id_str = get_uid_string();
USBD_CDC_ACM_DataSend(id_str, strlen((const char *)id_str));
send_uID = 0;
}
// Reset target
target_set_state(RESET_RUN);
cdc_led_state = LED_FLASH;
gpio_set_cdc_led(1);
button_activated = 0;
}
if (flags & FLAGS_MAIN_POWERDOWN) {
// Stop semihost task
semihost_disable();
// Disable debug
target_set_state(NO_DEBUG);
// Disconnect USB
usbd_connect(0);
// Turn off LED
gpio_set_dap_led(0);
gpio_set_cdc_led(0);
gpio_set_msd_led(0);
// TODO: put the interface chip in sleep mode
while (1) { }
}
if (flags & FLAGS_MAIN_DISABLEDEBUG) {
// Stop semihost task
semihost_disable();
// Disable debug
target_set_state(NO_DEBUG);
}
if (flags & FLAGS_MAIN_90MS) {
if (!button_activated) {
gpio_enable_button_flag(main_task_id, FLAGS_MAIN_RESET);
button_activated = 1;
}
#ifdef USE_USB_EJECT_INSERT
if (EjectInsertMediaMode == EJECT_INSERT_WAIT_TO_EJECT) {
if (--EjectInsertMediaCounter == 0) {
// Have waited ~0.5 second, time to eject media
EjectInsertMediaMode = EJECT_INSERT_WAIT_TO_INSERT;
EjectInsertMediaCounter = EJECT_INSERT_DELAY_500MS;
USBD_MSC_MediaReady = __FALSE;
}
}
if ((EjectInsertMediaMode == EJECT_INSERT_WAIT_TO_INSERT) && !USBD_MSC_MediaReadyEx) {
// The host computer have questioned the state and received
// the message that the media has been removed
if (--EjectInsertMediaCounter == 0) {
// Have waited ~0.5 seconds after ejecting, time to insert media
EjectInsertMediaMode = EJECT_INSERT_INACTIVE;
USBD_MSC_MediaReady = __TRUE;
}
}
#endif
// Update USB busy status
switch (usb_busy) {
case USB_ACTIVE:
if (DECZERO(usb_busy_count) == 0) {
usb_busy=USB_IDLE;
}
break;
case USB_IDLE:
default:
break;
}
// Update USB connect status
switch (usb_state) {
case USB_DISCONNECTING:
// Wait until USB is idle before disconnecting
if (usb_busy == USB_IDLE) {
usbd_connect(0);
usb_state = USB_DISCONNECTED;
}
break;
case USB_DISCONNECT_CONNECT:
// Wait until USB is idle before disconnecting
if ((usb_busy == USB_IDLE) && (DECZERO(usb_state_count) == 0)) {
usbd_connect(0);
usb_state = USB_CONNECTING;
// Update HTML file
update_html_file();
// Delay the connecting state before reconnecting to the host - improved usage with VMs
usb_state_count = 10; //(90ms * 10 = 900ms)
}
break;
case USB_CONNECTING:
// Wait before connecting
if (DECZERO(usb_state_count) == 0) {
usbd_connect(1);
usb_state = USB_CHECK_CONNECTED;
}
break;
case USB_CHECK_CONNECTED:
if(usbd_configured()) {
if (!thread_started) {
os_tsk_create_user(hid_process, DAP_TASK_PRIORITY, (void *)stk_dap_task, DAP_TASK_STACK);
serial_task_id = os_tsk_create_user(serial_process, SERIAL_TASK_PRIORITY, (void *)stk_serial_task, SERIAL_TASK_STACK);
thread_started = 1;
}
usb_state = USB_CONNECTED;
}
break;
case USB_CONNECTED:
case USB_DISCONNECTED:
default:
break;
}
}
// 30mS tick used for flashing LED when USB is busy
if (flags & FLAGS_MAIN_30MS) {
if (dap_led_usb_activity && ((dap_led_state == LED_FLASH) || (dap_led_state == LED_FLASH_PERMANENT))) {
// Flash DAP LED ONCE
if (dap_led_value) {
dap_led_value = 0;
} else {
dap_led_value = 1; // Turn on
if (dap_led_state == LED_FLASH) {
dap_led_usb_activity = 0;
}
}
// Update hardware
gpio_set_dap_led(dap_led_value);
}
if (msd_led_usb_activity && ((msd_led_state == LED_FLASH) || (msd_led_state == LED_FLASH_PERMANENT))) {
// Flash MSD LED ONCE
if (msd_led_value) {
msd_led_value = 0;
} else {
msd_led_value = 1; // Turn on
if (msd_led_state == LED_FLASH) {
msd_led_usb_activity = 0;
}
}
// Update hardware
gpio_set_msd_led(msd_led_value);
}
if (cdc_led_usb_activity && ((cdc_led_state == LED_FLASH) || (cdc_led_state == LED_FLASH_PERMANENT))) {
// Flash CDC LED ONCE
if (cdc_led_value) {
cdc_led_value = 0;
} else {
cdc_led_value = 1; // Turn on
if (cdc_led_state == LED_FLASH) {
cdc_led_usb_activity = 0;
}
}
// Update hardware
gpio_set_cdc_led(cdc_led_value);
}
}
}
}
void command_exec(void)
{
#if 1
unsigned long address = 0x20002000;
unsigned char type = 0;
unsigned char width = 8;
int count = 1;
unsigned char data[10] = {0xaa,0x55,0xaa,0x78};
if(new_cmd_pending == CMD_HALT)
{
t_halt();
new_cmd_pending = 0;
}
else if(new_cmd_pending == CMD_GO)
{
t_go();
new_cmd_pending = 0;
}
else if(new_cmd_pending == CMD_WRITE_MEM)
{
t_write_mem(type, address, width, count, data);
new_cmd_pending = 0;
}
else if(new_cmd_pending == CMD_READ_MEM)
{
t_read_mem(type, address, width, count, data);
new_cmd_pending = 0;
}
else if(new_cmd_pending == CMD_CORE_WRITE)
{
t_changePC(0,0);
new_cmd_pending = 0;
}
else if(new_cmd_pending == CMD_CORE_RESET)
{
t_reset();
new_cmd_pending = 0;
}
else if(new_cmd_pending == CMD_CORE_READ)
{
t_ReadPC();
new_cmd_pending = 0;
}
else
{
;
}
#endif
#if 0
uint32_t i = 0, j = 0, k = 0, l = 0;
uint32_t read_count = 0;
uint32_t retry = 0;
uint8_t led_state = 0;
uint32_t write_error = 0;
uint32_t sectorsize = 0;
uint32_t rambufsize = 0;
uint32_t rambufaddr = 0;
gpio_set_cdc_led(led_state);
led_state = !led_state;
//Start to program
if (!gpio_get_pin_loader_state())
{
//t_halt();
gpio_set_cdc_led(1);
while(!gpio_get_pin_loader_state())
{
;
}
gpio_set_cdc_led(0);
/*
while(gpio_get_pin_loader_state())
{
;
}
gpio_set_cdc_led(1);
while(!gpio_get_pin_loader_state())
{
;
}
gpio_set_cdc_led(0);
*/
t_reset();
for(i = 0; i < RETRY_TIME; i++)
{
write_error = 0;
pwrite = (uint32_t *)KINETIS_FLASHPRG;
pread = (uint32_t *)READBACK_ADDR;
t_write_mem(0,FLASH_PC - 1, 8, 1024, (unsigned char *)pwrite);
t_read_mem(0,FLASH_PC - 1, 8, 4, (unsigned char *)pread);
for(l = 0; l < 1; l++)
{
if(*pread != *pwrite)
{
write_error = 1;
}
*pread++;
*pwrite++;
}
if(write_error == 0)
{
break;
}
}
if(write_error == 1)
{
write_error = 0;
return;
}
//return ;
t_changePC(FLASH_PC,FLASH_SP);
t_go();
#if 1
//判断Target是否运行
while(1)
{
t_read_mem(0,HWESR, 32, 1, (unsigned char *)&readreg);
if((readreg == CPU_WAIT))
{
retry = 0;
read_count = 0;
break;
}
else
{
read_count++;
}
if(read_count > READ_TIME)
{
t_halt();
t_write_mem(0,FLASH_PC - 1, 8, 1024, (unsigned char *)KINETIS_FLASHPRG);
t_reset();
t_changePC(FLASH_PC,FLASH_SP);
t_go();
read_count = 0;
retry++;
}
//retry more times
if(retry >= RETRY_TIME)
{
retry = 0;
read_count = 0;
break;
}
}
#endif
#if 1
//计算烧写地址和大小
t_read_mem(0,HWSID, 32, 1, (unsigned char *)§orsize);
filenb = (*(uint32_t *)FILE_SIZE)/sectorsize;
if((*(uint32_t *)FILE_SIZE)%sectorsize)
{
filenb++;
}
//开始擦除flash
for(i = 0; i < filenb; i++)
{
gpio_set_cdc_led(led_state);
led_state = !led_state;
//write byte len
writereg = 0;
t_write_mem(0,HWBCR, 32, 1, (unsigned char *)&writereg);
//write addr
writereg = sectorsize*i;
t_write_mem(0,HWBFR, 32, 1, (unsigned char *)&writereg);
writereg = CMD_ERASE;
t_write_mem(0,HWCMR, 32, 1, (unsigned char *)&writereg);
writereg = CMD_RUN;
t_write_mem(0,HWCSR, 32, 1, (unsigned char *)&writereg);
//等待擦除完成
while(1)
{
t_read_mem(0,HWCSR, 32, 1, (unsigned char *)&readreg);
if((readreg == CMD_DONW))
{
read_count = 0;
break;
}
else
{
read_count++;
}
if(read_count > READ_TIME)
{
read_count = 0;
return;
}
}
}
#endif
#if 1
//开始编程
//i = 0;
//j = 0;
t_read_mem(0,HWFCG1, 32, 1, (unsigned char *)&rambufsize);
t_read_mem(0,HWFCG2, 32, 1, (unsigned char *)&rambufaddr);
t_read_mem(0,HWSID, 32, 1, (unsigned char *)§orsize);
fileram = (*(uint32_t *)FILE_SIZE)/rambufsize;
if((*(uint32_t *)FILE_SIZE)%rambufsize)
{
fileram++;
}
//for(i = 0; i < filenb;i++)
{
for(j = 0; j < fileram; j++)
{
gpio_set_cdc_led(led_state);
led_state = !led_state;
//t_halt();
//write buf addr
writereg = rambufaddr;
t_write_mem(0,HWBUFADDR, 32, 1, (unsigned char *)&writereg);
pwrite = (uint32_t *)(START_APP_ADDRESS + rambufsize*j);
pread = (uint32_t *)READBACK_ADDR;
t_write_mem(0,rambufaddr, 8, rambufsize, (unsigned char *)pwrite);
//write word len
writereg = rambufsize/4; //编程一次写4个字节
t_write_mem(0,HWBCR, 32, 1, (unsigned char *)&writereg);
//write addr
writereg = rambufsize*j;
t_write_mem(0,HWBFR, 32, 1, (unsigned char *)&writereg);
//write cmd
writereg = CMD_PROGRA;
t_write_mem(0,HWCMR, 32, 1, (unsigned char *)&writereg);
//start to run
writereg = CMD_RUN;
t_write_mem(0,HWCSR, 32, 1, (unsigned char *)&writereg);
//t_go();
//delay_us(10);
//wait for down
while(1)
{
t_read_mem(0,HWCSR, 32, 1, (unsigned char *)&readreg);
if((readreg == CMD_DONW))
{
read_count = 0;
break;
}
else
{
read_count++;
}
if(read_count > READ_TIME)
{
read_count = 0;
return;
}
}
}
}
#endif
}
#endif
}
