void led_error(void){
while(1){
uint32_t pinmask;
pinmask = (1<<18);
hwpl_core_privcall(led_priv_on, &pinmask);
usleep(50*1000);
hwpl_core_privcall(led_priv_off, &pinmask);
usleep(50*1000);
}
}
/*! \details This function sets \a thread's scheduling policy and scheduling parameters to
* \a policy and \a param respectively.
*
* \return Zero on success or -1 with errno (see \ref ERRNO) set to:
* - ESRCH: thread is not a valid
* - EINVAL: param is NULL or the priority is invalid
*
*/
int pthread_setschedparam(pthread_t thread,
int policy,
struct sched_param *param){
int min_prio;
int max_prio;
priv_set_pthread_scheduling_param_t args;
if ( param == NULL ){
errno = EINVAL;
return -1;
}
if ( sched_check_tid(thread) < 0 ){
errno = ESRCH;
return -1;
}
max_prio = sched_get_priority_max(policy);
min_prio = sched_get_priority_min(policy);
if ( ((uint8_t)param->sched_priority >= min_prio) &&
((uint8_t)param->sched_priority <= max_prio) ){
args.tid = thread;
args.policy = policy;
args.param = param;
hwpl_core_privcall(priv_set_scheduling_param, &args);
return 0;
}
//The scheduling priority is invalid
errno = EINVAL;
return -1;
}
link_phy_t link_phy_open(const char * name, int baudrate){
link_phy_t fd;
uint32_t pinmask;
#ifdef __PHY_USB
fd = link_phy_usb_open();
if( fd < 0){
led_error();
return -1;
}
#else
uart_attr_t attr;
fd = open("/dev/uart0", O_RDWR);
if( fd < 0){
return -1;
}
attr.baudrate = 460800;
attr.parity = UART_PARITY_EVEN;
attr.pin_assign = 0;
attr.start = UART_ATTR_START_BITS_1;
attr.stop = UART_ATTR_STOP_BITS_2;
attr.width = 8;
if( ioctl(fd, I_UART_SETATTR, &attr) < 0 ){
return -1;
}
#endif
pinmask = (1<<18);
hwpl_core_privcall(led_priv_on, &pinmask);
usleep(50*1000);
hwpl_core_privcall(led_priv_off, &pinmask);
pinmask = (1<<20);
hwpl_core_privcall(led_priv_on, &pinmask);
usleep(75*1000);
hwpl_core_privcall(led_priv_off, &pinmask);
pinmask = (1<<21);
hwpl_core_privcall(led_priv_on, &pinmask);
usleep(100*1000);
hwpl_core_privcall(led_priv_off, &pinmask);
pinmask = (1<<23);
hwpl_core_privcall(led_priv_on, &pinmask);
usleep(200*1000);
hwpl_core_privcall(led_priv_off, &pinmask);
link_phy_flush(fd);
#ifdef XIVELY
init_devices();
#endif
return fd;
}
void unistd_clr_action(open_file_t * open_file){
unistd_priv_attr_t args;
hwpl_action_t action;
args.fs = open_file->fs;
args.handle = open_file->handle;
args.request = I_GLOBAL_SETACTION;
args.ctl = &action;
action.callback = 0;
hwpl_core_privcall(unistd_priv_ioctl, &args);
}
void crt_load_data(void * global_impure, void * code_start, int code_size, int data_size){
priv_load_data_t args;
//If the caller doesn't have the ability to write this memory location, a fault will occur
memset(global_impure, 0, data_size);
//Now copy the data in priv mode
args.global_impure = global_impure;
args.data = code_start + code_size;
args.size = data_size;
hwpl_core_privcall(priv_load_data, &args);
}
int task_new_process(void (*p)(int,char*const*),
void (*cleanup)(void*),
int argc,
char *const argv[],
task_memories_t * mem,
void * reent_ptr){
int tid;
int err;
void * stackaddr;
new_task_t task;
task_memories_t task_memories;
static int task_process_counter = 1;
//Variable initialization
stackaddr = mem->data.addr + mem->data.size;
//Check the stack alignment
if ( (unsigned int)stackaddr & 0x03 ){
errno = EIO;
return -1;
}
//Initialize the task
task.stackaddr = stackaddr;
task.start = (uint32_t)p;
task.stop = (uint32_t)cleanup;
task.r0 = (uint32_t)argc;
task.r1 = (uint32_t)argv;
task.pid = task_process_counter++; //Assign a new pid
//task.mem_size = mem_size;
task.reent = (struct _reent*)reent_ptr;
task.global_reent = task.reent;
task.flags = TASK_FLAGS_USED |
TASK_FLAGS_PARENT(task_current);
memcpy(&task_memories, mem, sizeof(task_memories_t));
if ( (err = task_mpu_calc_protection(&task_memories)) < 0 ){
return err;
}
task.mem = &task_memories;
//Do a priv call while accessing the task table so there are no interruptions
hwpl_core_privcall( (core_privcall_t)task_priv_new_task, &task);
tid = task.tid;
return tid;
}
void powerdown(int seconds){
bool deepsleep;
deepsleep = false;
if ( seconds > 0 ){
if (set_alarm(seconds) == 0 ){
deepsleep = true;
}
} else if ( seconds == 0 ){
deepsleep = true;
}
if ( deepsleep ){
hwpl_core_privcall(priv_powerdown, NULL);
}
}
int hibernate(int seconds){
bool deepsleep;
int ret = -1;
deepsleep = false;
if ( seconds > 0 ){
if (set_alarm(seconds) == 0 ){
deepsleep = true;
}
} else if ( seconds == 0 ){
deepsleep = true;
}
if( deepsleep ){
hwpl_core_privcall(priv_hibernate, NULL);
}
return ret;
}
void cl_dev_setdelay_mutex(pthread_mutex_t * mutex){
hwpl_core_privcall(set_delay_mutex, mutex);
}
int device_data_transfer(open_file_t * open_file, void * buf, int nbyte, int read){
int tmp;
int mode;
priv_device_data_transfer_t args;
if ( nbyte == 0 ){
return 0;
}
args.fs = (const sysfs_t*)open_file->fs;
args.handle = (device_t *)open_file->handle;
args.read = read;
args.op.loc = open_file->loc;
args.op.flags = open_file->flags;
args.op.buf = buf;
args.op.callback = priv_data_transfer_callback;
args.op.context = &args;
#if SINGLE_TASK == 0
args.op.tid = task_get_current();
#else
args.op.tid = 0;
#endif
if ( (mode = get_mode(args.fs, args.handle)) < 0 ){
return -1;
}
//privilege call for the operation
do {
#if SINGLE_TASK > 0
waiting = false;
#endif
args.op.nbyte = nbyte;
args.ret = -101010;
//This transfers the data
hwpl_core_privcall(priv_device_data_transfer, &args);
//We arrive here if the data is done transferring or there is no data to transfer and O_NONBLOCK is set
//or if there was an error
if( sched_get_unblock_type(task_get_current()) == SCHED_UNBLOCK_SIGNAL ){
unistd_clr_action(open_file);
errno = EINTR;
return -1;
}
#if SINGLE_TASK != 0
while ( waiting == true ){
core_sleep(CORE_SLEEP);
}
#endif
if ( args.ret > 0 ){
//The operation happened synchronously
tmp = args.ret;
break;
} else if ( args.ret == 0 ){
//the operation happened asynchronously
if ( args.op.nbyte > 0 ){
//The operation has completed and transferred args.op.nbyte bytes
tmp = args.op.nbyte;
break;
} else if ( args.op.nbyte == 0 ){
//There was no data to read/write -- try again
if (args.op.flags & O_NONBLOCK ){
errno = ENODATA;
return -1;
}
} else if ( args.op.nbyte < 0 ){
//there was an error executing the operation (or the operation was cancelled)
return -1;
}
} else if ( args.ret < 0 ){
//there was an error starting the operation (such as EAGAIN)
if( args.ret == -101010 ){
errno = ENXIO; //this is a rare/strange error where hwpl_core_privcall fails to run properly
}
return -1;
}
} while ( args.ret == 0 );
if ( ((mode & S_IFMT) != S_IFCHR) && (tmp > 0) ){
open_file->loc += tmp;
}
return tmp;
}
