int proc_hw_thread_exit( proc_interface_t * iface, void * ret)
{
volatile int * cmd;
int status;
if(ret != NULL)
{
// Setup return value in V-HWTI
*(iface->res_reg) = (int)ret;
// Place return value in global TCB array for safe-keeping (V-HWTI return reg is too volatile when using dynamic APIs)
// IMPORTANT - as V-HWTI may be re-used by a smart function, then move return value
//to global data struct "threads" retval location
volatile hthread_thread_t * tcb_array = (hthread_thread_t*) *(iface->gctx_ptr);
Huint tid = *(iface->tid_reg);
tcb_array[tid].retval = ret;
}
// IMPORTANT - set V-HWTI utilized field back to free!!!!!
*(iface->uti_reg) = 0;
// Perform hthread_exit()
cmd = (int*)(encode_cmd(*(iface->tid_reg),HT_CMD_EXIT_THREAD));
status = *cmd;
//xil_printf("Thread ID %d exit status = 0x%08x\r\n",*(iface->tid_reg), status);
return status;
}
int proc_hw_thread_exit( proc_interface_t * iface, void * ret)
{
volatile int * cmd;
int status;
// Store execution time -
volatile hthread_time_t * timer = (hthread_time_t *) LOCAL_TIMER;
hthread_time_t stop = *timer;
hthread_time_t start = *(iface->execution_time);
*(iface->execution_time) = stop-start;
// Return a value (if any) first
if(ret != NULL)
{
// Setup return value in V-HWTI
*(iface->res_reg) = (int)ret;
// Place return value in global TCB array for safe-keeping
// (V-HWTI return reg is too volatile when using dynamic APIs)
// IMPORTANT - as V-HWTI may be re-used by a smart function, then move return value
//to global data struct "threads" retval location
volatile hthread_thread_t * tcb_array = (hthread_thread_t*) *(iface->gctx_ptr);
Huint tid = *(iface->tid_reg);
tcb_array[tid].retval = ret;
}
// If there was an accelerator used, we need to update the
// first use accelerator for this particular function it ran.
// The host processor is responsible for writing the proper address.
if (*(iface->first_used_accelerator) != MAGIC_NUMBER) {
volatile unsigned int * first_used_acc = (unsigned int *) *(iface->first_used_ptr);
if (first_used_acc != NULL)
*first_used_acc = *(iface->first_used_accelerator);
}
// We should also update the last used accelerator, checking to see
// if the previous last used accelerator is equal to the currently
// loader accelerator.
if (*(iface->last_used_accelerator) != prev_last_used_accelerator) {
// Update the last used accelerator
volatile unsigned int * last_used_acc = (unsigned int *) *(iface->last_used_ptr);
if (last_used_acc != NULL) {
*last_used_acc = *(iface->last_used_accelerator);
}
// Update the previous_last_used_accelerator to current
prev_last_used_accelerator = *(iface->last_used_accelerator);
}
// Perform hthread_exit() second
cmd = (int*)(encode_cmd(*(iface->tid_reg),HT_CMD_EXIT_THREAD));
status = *cmd;
// Mark in the V-HWTI that this slave is free third
*(iface->uti_reg) = 0;
//xil_printf("Thread ID %d exit status = 0x%08x\r\n",*(iface->tid_reg), status);
return status;
}
void test_command_with_args() {
uint8_t buf[255];
int pos = 0;
int rc;
uint8_t dest;
uint8_t code;
uint16_t mref;
rc = encode_cmd(buf, &pos, LS1P_ADDR_ARM, LS1P_REQ_CODE_CMDLOG, 314);
assert(rc == LS1P_API_OK);
assert(pos == 3);
assert(buf[0] == 0x01);
rc = encode_uint8(buf, &pos, 123);
assert(rc == LS1P_API_OK);
assert(pos == 4);
rc = encode_uint16(buf, &pos, 4023);
assert(rc == LS1P_API_OK);
assert(pos == 6);
assert(buf[0] == 0x01);
assert(buf[1] == 0x01);
assert(buf[2] == 0x3A);
assert(buf[3] == 0x7B);
assert(buf[4] == 0x0F);
assert(buf[5] == 0xB7);
rc = decode_cmd(buf, &pos, &dest, &code, &mref);
assert(rc == LS1P_API_OK);
assert(dest == LS1P_ADDR_ARM);
assert(code == LS1P_REQ_CODE_CMDLOG);
assert(mref == 314);
assert(pos == 3);
}
int main ( int argc, char *argv[] )
{
if(argc<4) {
printf("Expecting at least four params.\n");
return 1;
}
wiringPiSetup () ;
//setup pins
pinMode (0, OUTPUT) ;//LED
pinMode (1, OUTPUT) ;//Sender
digitalWrite (1, LOW) ;
int system_type=0;
char unit_type='A';
char onoff=0;
int retries=5;
system_type=atoi(argv[1]);
unit_type=argv[2][0];
if(strcmp(argv[3],"on")==0){
onoff=1;
}
if(argc>=4){
retries=atoi(argv[4]);
}
printf("Brennenstuhl remote power socket. \nSystem code: %i \nUnit code: %c\nSwitch %i ",system_type,unit_type,onoff);
printf(argv[3]);
printf("\nRetries %i\n",retries);
//signal sending init
int signal[PULSE_CNT];
char cmd[CMD_LEN];
if(encode_cmd(cmd,CMD_LEN,system_type,unit_type,onoff)){
if(encode_signal(signal,PULSE_CNT,cmd,CMD_LEN)){
int j=0;
for(j=0;j<retries;j++){
char pulse=START_PULSE;
int i=0;
for(i=0;i<PULSE_CNT;i++){
send_pulse(signal[i],pulse,1);
pulse=pulse*-1+1;
}
}
}
}
digitalWrite(0,LOW);
digitalWrite(1,LOW);
return 0 ;
}
void proc_hw_thread_exit( proc_interface_t * iface, void * ret)
{
volatile int * cmd;
int status;
// Setup return value
*(iface->res_reg) = (int)ret;
cmd = (int*)(encode_cmd(*(iface->tid_reg),HT_CMD_EXIT_THREAD));
status = *cmd;
}
void test_nonzero_dest()
{
uint8_t buf[255];
int pos = 0;
int rc;
rc = encode_cmd(buf, &pos, LS1P_ADDR_ARDUINO, LS1P_REQ_CODE_UNDEFINED, 315);
assert(rc == LS1P_API_OK);
assert(pos == 3);
assert(buf[0] == 0x20);
}
int main( int argc, char *argv[] )
{
unsigned int base;
unsigned int cmd;
unsigned int id;
unsigned int mx;
if( argc < 3 )
{
printf( "Usage: %s <thread id> <mutex id> [base addr]\n", argv[0] );
return 1;
}
base = BASE;
id = atoi( argv[1] );
mx = atoi( argv[2] );
if( argc >= 4 )
{
base = strtol( argv[3], NULL, 16 );
}
printf( "\n\n" );
printf( "HWTI Base Address: 0x%04x\n", base );
printf( "Thread ID: %u\n", id );
printf( "Mutex ID: %u\n", mx );
printf( "-----------------------------------------------\n" );
cmd = encode_cmd(id, HT_CMD_CLEAR_THREAD );
printf( "Clear Thread: mrd 0x%04x\n", cmd );
cmd = encode_cmd(id, HT_CMD_JOIN_THREAD );
printf( "Join Thread: mrd 0x%04x\n", cmd );
cmd = encode_cmd(id, HT_CMD_DETACH_THREAD );
printf( "Detach Thread: mrd 0x%04x\n", cmd );
cmd = encode_cmd(id, HT_CMD_READ_THREAD );
printf( "Read Thread: mrd 0x%04x\n", cmd );
cmd = encode_cmd(id, HT_CMD_ADD_THREAD );
printf( "Add Thread: mrd 0x%04x\n", cmd );
cmd = encode_cmd(id, HT_CMD_EXIT_THREAD );
printf( "Exit Thread: mrd 0x%04x\n", cmd );
cmd = encode_cmd(0, HT_CMD_CREATE_THREAD_J );
printf( "Create Joinable Thread: mrd 0x%04x\n", cmd );
cmd = encode_cmd(0, HT_CMD_CREATE_THREAD_D );
printf( "Create Detached Thread: mrd 0x%04x\n", cmd );
cmd = encode_cmd(0, HT_CMD_NEXT_THREAD );
printf( "Next Thread: mrd 0x%04x\n", cmd );
cmd = encode_cmd(0, HT_CMD_CURRENT_THREAD );
printf( "Current Thread: mrd 0x%04x\n", cmd );
cmd = encode_cmd(0, HT_CMD_EXCEPTION_REG);
printf( "Exception Cause: mrd 0x%04x\n", cmd );
cmd = sched_cmd(0, id, HT_CMD_SCHED_SET_IDLE_THREAD );
printf( "Idle Thread: mrd 0x%04x\n", cmd );
cmd = sched_cmd(0, id, HT_CMD_SCHED_HIGHPRI );
printf( "High/DBG Thread: mrd 0x%04x\n", cmd );
cmd = encode_cmd(0, HT_CMD_QUE_LENGTH );
printf( "Queue Length: mrd 0x%04x\n", cmd );
cmd = encode_cmd(0, HT_CMD_SOFT_STOP );
printf( "Soft Stop: mrd 0x%04x\n", cmd );
cmd = encode_cmd(0, HT_CMD_SOFT_START );
printf( "Soft Start: mrd 0x%04x\n", cmd );
cmd = encode_cmd(0, HT_CMD_SOFT_RESET );
printf( "Soft Reset: mrd 0x%04x\n", cmd );
cmd = mutex_cmd( HT_MUTEX_LOCK, id, mx );
//cmd = blk_sema_cmd( HT_CMD_REQUEST, id, mx );
printf( "Mutex Lock: mrd 0x%04x\n", cmd );
cmd = mutex_cmd( HT_MUTEX_UNLOCK, id, mx );
//cmd = blk_sema_cmd( HT_CMD_RELEASE, id, mx );
printf( "Mutex Unlock: mrd 0x%04x\n", cmd );
cmd = mutex_cmd( HT_MUTEX_TRY, id, mx );
//cmd = blk_sema_cmd( HT_CMD_TRYLOCK, id, mx );
printf( "Mutex Try Lock: mrd 0x%04x\n", cmd );
cmd = mutex_cmd( HT_MUTEX_OWNER, 0, mx );
printf( "Mutex Owner: mrd 0x%04x\n", cmd );
cmd = mutex_cmd( HT_MUTEX_KIND, 0, mx );
printf( "Mutex Kind: mrd 0x%04x\n", cmd );
cmd = mutex_cmd( HT_MUTEX_COUNT, 0, mx );
printf( "Mutex Count: mrd 0x%04x\n", cmd );
cmd = cvr_sema_cmd(HT_CMD_SIGNAL, id, mx);
printf( "Cond Signal: mrd 0x%04x\n", cmd );
cmd = cvr_sema_cmd(HT_CMD_CWAIT, id, mx);
printf( "Cond Wait: mrd 0x%04x\n", cmd );
cmd = cvr_sema_cmd(HT_CMD_BROADCAST, id, mx);
printf( "Cond Broad: mrd 0x%04x\n", cmd );
cmd = sched_cmd(0, id, HT_CMD_SCHED_ENTRY);
printf( "Sched Entry: mrd 0x%04x\n", cmd );
cmd = sched_cmd( 0, id, HT_CMD_SCHED_SETSCHEDPARAM );
printf( "Set Sched Param: mrd 0x%04x\n", cmd );
cmd = sched_cmd( 0, id, HT_CMD_SCHED_GETSCHEDPARAM );
printf( "Get Sched Param: mrd 0x%04x\n", cmd );
cmd = sched_cmd( 0, id, HT_CMD_SCHED_SYSCALL_LOCK );
cmd |= 0x00040000;
printf( "Syscall lock: mrd 0x%04x\n", cmd );
cmd = sched_cmd( 0, id, HT_CMD_SCHED_SYSCALL_LOCK );
printf( "Syscall unlock: mrd 0x%04x\n", cmd );
cmd = sched_cmd( 0, id, HT_CMD_SCHED_MALLOC_LOCK );
cmd |= 0x00040000;
printf( "Malloc lock: mrd 0x%04x\n", cmd );
cmd = sched_cmd( 0, id, HT_CMD_SCHED_MALLOC_LOCK );
printf( "Malloc unlock: mrd 0x%04x\n", cmd );
cmd = hwti_cmd( base, HT_CMD_HWTI_COMMAND );
printf( "HWTI Reset: mrd 0x%04x\n", cmd );
cmd = hwti_cmd( base, HT_CMD_HWTI_SETID );
printf( "HWTI Set ID: mrd 0x%04x\n", cmd );
cmd = hwti_cmd( base, HT_CMD_HWTI_SETARG );
printf( "HWTI Set Arg: mrd 0x%04x\n", cmd );
cmd = hwti_cmd( base, HT_CMD_HWTI_RESULTS );
printf( "HWTI Results: mrd 0x%04x\n", cmd );
cmd = cbis_encode_cmd( CBIS_WRITE, id, mx );
printf( "CBIS Associate (TID = %d, IID = %d) mrd 0x%04x\n", id, mx, cmd );
printf( "\n\n" );
return 0;
}
int proc_hw_thread_exit( proc_interface_t * iface, void * ret)
{
volatile int * cmd;
int status;
volatile hthread_thread_t * tcb_array = (hthread_thread_t*) *(iface->gctx_ptr);
// Store execution time -
hthread_time_t stop = hthread_time_get();
hthread_time_t start = *(iface->execution_time);
*(iface->execution_time) = stop-start;
// Get TID for storing return value (if any) and
// execution time back in TCB[tid].
Huint tid = *(iface->tid_reg);
tcb_array[tid].execution_time = stop-start;
// Return a value (if any) first
if(ret != NULL)
{
// Setup return value in V-HWTI
*(iface->res_reg) = (int)ret;
// Place return value in global TCB for safe-keeping before scheduling
// another thread onto this slave (and using it's V-HWTI registers).
tcb_array[tid].retval = ret;
}
// If there was an accelerator used, we need to update the
// first use accelerator for this particular function it ran.
// The host processor is responsible for writing the proper address.
if (*(iface->first_used_accelerator) != NO_ACC) {
volatile unsigned int * first_used_acc = (unsigned int *) *(iface->first_used_ptr);
if (first_used_acc != NULL)
*first_used_acc = *(iface->first_used_accelerator);
}
// We should also update the last used accelerator, checking to see
// if the previous last used accelerator is equal to the currently
// loader accelerator.
if (*(iface->last_used_accelerator) != prev_last_used_accelerator) {
// Update the last used accelerator
volatile unsigned int * last_used_acc = (unsigned int *) *(iface->last_used_ptr);
if (last_used_acc != NULL) {
*last_used_acc = *(iface->last_used_accelerator);
}
// Update the previous_last_used_accelerator to current
prev_last_used_accelerator = *(iface->last_used_accelerator);
}
// Perform hthread_exit() second
cmd = (int*)(encode_cmd(*(iface->tid_reg),HT_CMD_EXIT_THREAD));
status = *cmd;
// Mark in the V-HWTI that this slave is free
*(iface->uti_reg) = 0;
//xil_printf("Thread ID %d exit status = 0x%08x\r\n",*(iface->tid_reg), status);
return status;
}
