//-----------------------------------------------------------------------------
void
fifo_printf_init (void)
{
//-----------------------------------------------------------------------------
printk ("[TRACE] INIT\n");
rtf_create (FIFO_PRINTF_L1_NO, FIFO_PRINTF_SIZE);
rtf_create (FIFO_PRINTF_L2_NO, FIFO_PRINTF_SIZE);
}
/*------------------------------------------------------------------------------*/
int L3_xface_init(void) {
/*------------------------------------------------------------------------------*/
int ret = 0;
#ifdef USER_MODE
int sock;
LOG_D(RRC, "[L3_XFACE] init de l'interface \n");
if (open_socket (&S_rrc, RRC_RRM_SOCK_PATH, RRM_RRC_SOCK_PATH, 0) == -1)
return (-1);
if (S_rrc.s == -1) {
return (-1);
}
socket_setnonblocking (S_rrc.s);
msg ("Interface Connected... RRM-RRC\n");
return 0;
#else
ret=rtf_create(RRC2RRM_FIFO,32768);
if (ret < 0) {
msg("[openair][MAC][INIT] Cannot create RRC2RRM fifo %d (ERROR %d)\n",RRC2RRM_FIFO,ret);
return(-1);
}
else {
msg("[openair][MAC][INIT] Created RRC2RRM fifo %d\n",RRC2RRM_FIFO);
rtf_reset(RRC2RRM_FIFO);
}
ret=rtf_create(RRM2RRC_FIFO,32768);
if (ret < 0) {
msg("[openair][MAC][INIT] Cannot create RRM2RRC fifo %d (ERROR %d)\n",RRM2RRC_FIFO,ret);
return(-1);
}
else {
msg("[openair][MAC][INIT] Created RRC2RRM fifo %d\n",RRM2RRC_FIFO);
rtf_reset(RRM2RRC_FIFO);
}
return(0);
#endif
}
int RTFOpen(int minor, int size)
{
int err;
if (minor < 0) {
int i;
for (i = 0; i < RTF_NO; ++i)
if (rtf_create(i, size) == 0) { minor = i; break; }
if (minor < 0) return -1;
return minor;
}
/* else minor >= 0.. */
err = rtf_create(minor, size);
if (err) return err;
return minor;
}
static void init(scicos_block *block)
{
int sizeData = sizeof(float)*(block->nin+1);
int dim = block->ipar[1]/sizeData*sizeData;
rtf_create(block->ipar[0],dim);
rtf_reset(block->ipar[0]);
}
int init_module(void)
{
unsigned int local_ip;
unsigned int server_ip = rt_inet_aton(server_ip_s);
struct rtnet_callback callback = {echo_rcv, NULL};
if (strlen(local_ip_s) != 0)
local_ip = rt_inet_aton(local_ip_s);
else
local_ip = INADDR_ANY;
if (interval < 1) interval = 1;
if (interval > 1000) interval = 1000;
if (packetsize < 1) packetsize = 1;
if (packetsize > 1400) packetsize = 1400;
printk("***** start of rt_client ***** %s %s *****\n", __DATE__, __TIME__);
printk("local ip address %s=%08x\n", local_ip_s, local_ip);
printk("server ip address %s=%08x\n", server_ip_s, server_ip);
printk("interval = %d\n", interval);
printk("packetsize = %d\n", packetsize);
printk("start timer %d\n", start_timer);
rtf_create(PRINT, 8000);
/* create rt-socket */
sock = socket_rt(AF_INET,SOCK_DGRAM,0);
/* bind the rt-socket to local_addr */
memset(&local_addr, 0, sizeof(struct sockaddr_in));
local_addr.sin_family = AF_INET;
local_addr.sin_port = htons(RCV_PORT);
local_addr.sin_addr.s_addr = local_ip;
bind_rt(sock, (struct sockaddr *)&local_addr, sizeof(struct sockaddr_in));
/* set server-addr */
memset(&server_addr, 0, sizeof(struct sockaddr_in));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(SRV_PORT);
server_addr.sin_addr.s_addr = server_ip;
/* set up callback handler */
ioctl_rt(sock, RTNET_RTIOC_CALLBACK, &callback);
if (start_timer) {
rt_set_oneshot_mode();
start_rt_timer(0);
}
rt_task_init(&rt_task,(void *)process,0,4096,10,0,NULL);
rt_task_make_periodic_relative_ns(&rt_task, 1000000,
(RTIME)interval * 1000000);
return 0;
}
int init_module(void)
{
int err;
if( (err = rtf_create(FROM_KERN, 1000)) < 0 ) {
printk("rtf_create: %d, errno = %d\n", FROM_KERN, err);
return err;
}
if( (err = rtf_create(TO_KERN, 1000)) < 0 ) {
printk("rtf_create: %d, errno = %d\n", TO_KERN, err);
return err;
}
if( (err = rtf_create_handler(TO_KERN, &handler)) ) {
printk("rtf_create_handler: %d, errno = %d\n", TO_KERN, err);
return err;
}
rt_mount();
return 0;
}
int init_module(void)
{
hide = FALSE;
pause = FALSE;
rtf_create(Keyboard, 1000);
rtf_create_handler(Keyboard, keybrd_handler);
rtf_create(Screen, 10000);
rt_sem_init(&keybrd_sem, 0);
rt_task_init_cpuid(&read, ClockChrono_Read, 0, 2000, 0, 0, 0, READ_RUN_ON_CPU);
rt_task_init_cpuid(&chrono, ClockChrono_Chrono, 0, 2000, 0, 0, 0, CHRONO_RUN_ON_CPU);
rt_task_init_cpuid(&clock, ClockChrono_Clock, 0, 2000, 0, 0, 0, CLOCK_RUN_ON_CPU);
rt_task_init_cpuid(&write, ClockChrono_Write, 0, 2000, 0, 0, 0, WRITE_RUN_ON_CPU);
start_rt_apic_timers(apic_setup_data, 0);
rt_task_resume(&read);
rt_task_resume(&chrono);
rt_task_resume(&clock);
rt_task_resume(&write);
return 0;
}
static int
__latency_init(void)
{
/* XXX check option ranges here */
/* register a proc entry */
#ifdef CONFIG_PROC_FS
create_proc_read_entry("rtai/latency_calibrate", /* name */
0, /* default mode */
NULL, /* parent dir */
proc_read, /* function */
NULL /* client data */
);
#endif
rtf_create(DEBUG_FIFO, 16000); /* create a fifo length: 16000 bytes */
rt_linux_use_fpu(use_fpu); /* declare if we use the FPU */
rt_task_init( /* create our measuring task */
&thread, /* poiter to our RT_TASK */
fun, /* implementation of the task */
0, /* we could transfer data -> task */
3000, /* stack size */
0, /* priority */
use_fpu, /* do we use the FPU? */
0 /* signal? XXX */
);
rt_set_runnable_on_cpus( /* select on which CPUs the task is */
&thread, /* allowed to run */
RUN_ON_CPUS
);
/* Test if we have to start the timer */
if (start_timer || (start_timer = !rt_is_hard_timer_running())) {
if (timer_mode) {
rt_set_periodic_mode();
} else {
rt_set_oneshot_mode();
}
rt_assign_irq_to_cpu(TIMER_8254_IRQ, TIMER_TO_CPU);
period_counts = start_rt_timer(nano2count(period));
} else {
period_counts = nano2count(period);
}
loops = (1000000000*avrgtime)/period;
/* Calculate the start time for the task. */
/* We set this to "now plus 10 periods" */
expected = rt_get_time() + 10 * period_counts;
rt_task_make_periodic(&thread, expected, period_counts);
return 0;
}
int init_module(void)
{
#ifdef CONFIG_X86_LOCAL_APIC
params.mp = 1;
#endif /* CONFIG_X86_LOCAL_APIC */
params.freq_apic = RTAI_FREQ_APIC;
params.cpu_freq = RTAI_CPU_FREQ;
rtf_create(0, FIFOBUFSIZE);
if ((srq = rt_request_srq(CALSRQ, (void *)user_srq, user_srq)) < 0) {
printk("No sysrq available for the calibration.\n");
return srq;
}
return 0;
}
int init_module(void)
{
int err, i;
if( (err = rtf_create(FROM_KERN, 1000)) < 0 ) {
printk("rtf_create: %d, errno = %d\n", FROM_KERN, err);
return err;
}
for(i = 0; i < NTASKS; i++) {
if( (err = rt_task_create(&td[i])) ) {
return err;
}
}
return 0;
}
int init_module(void)
{
int ret;
unsigned long local_ip = rt_inet_aton(local_ip_s);
unsigned long server_ip = rt_inet_aton(server_ip_s);
rtf_create(PRINT, 40000);
rt_sem_init(&tx_sem, 0);
rt_printk ("local ip address %s=%8x\n", local_ip_s, (unsigned int) local_ip);
rt_printk ("server ip address %s=%8x\n", server_ip_s, (unsigned int) server_ip);
/* create rt-socket */
sock=rt_socket(AF_INET,SOCK_DGRAM,0);
/* bind the rt-socket to local_addr */
memset(&local_addr, 0, sizeof(struct sockaddr_in));
local_addr.sin_family = AF_INET;
local_addr.sin_port = htons(RCV_PORT);
local_addr.sin_addr.s_addr = local_ip;
ret=rt_socket_bind(sock, (struct sockaddr *) &local_addr, sizeof(struct sockaddr_in));
/* set server-addr */
memset(&server_addr, 0, sizeof(struct sockaddr_in));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(SRV_PORT);
server_addr.sin_addr.s_addr = server_ip;
// set up receiving
rt_socket_callback(sock, echo_rcv, NULL);
rt_set_oneshot_mode();
start_rt_timer(TIMERTICKS);
ret=rt_task_init(&rt_task,(void *)process,0,4096,10,0,NULL);
rt_task_resume(&rt_task);
rt_request_global_irq(parirq, parport_irq_handler);
rt_startup_irq(parirq);
outb(0xFF, PAR_DATA);
outb(0x14 + KHZ0_1, PAR_CONTROL);
return ret;
}
int init_module(void)
{
int ret;
RTIME tick_period;
unsigned int local_ip = rt_inet_aton(local_ip_s);
unsigned int server_ip = rt_inet_aton(server_ip_s);
if (interval < 1) interval = 1;
if (interval > 1000) interval = 1000;
if (packetsize < 1) packetsize = 1;
if (packetsize > 1400) packetsize = 1400;
printk ("***** start of rt_client ***** %s %s *****\n", __DATE__, __TIME__);
printk ("local ip address %s=%08x\n", local_ip_s, local_ip);
printk ("server ip address %s=%08x\n", server_ip_s, server_ip);
printk ("interval = %d\n", interval);
printk ("packetsize = %d\n", packetsize);
rtf_create(PRINT, 8000);
/* create rt-socket */
sock=rt_socket(AF_INET,SOCK_DGRAM,0);
/* bind the rt-socket to local_addr */
memset(&local_addr, 0, sizeof(struct sockaddr_in));
local_addr.sin_family = AF_INET;
local_addr.sin_port = htons(RCV_PORT);
local_addr.sin_addr.s_addr = local_ip;
ret=rt_socket_bind(sock, (struct sockaddr *) &local_addr, sizeof(struct sockaddr_in));
/* set server-addr */
memset(&server_addr, 0, sizeof(struct sockaddr_in));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(SRV_PORT);
server_addr.sin_addr.s_addr = server_ip;
/* set up receiving */
rt_socket_callback(sock, echo_rcv, NULL);
tick_period = start_rt_timer(nano2count(TICK_PERIOD));
ret=rt_task_init(&rt_task,(void *)process,0,4096,0,0,NULL);
ret=rt_task_make_periodic_relative_ns( &rt_task, 1000000, (RTIME) interval * 1000000);
return 0;
}
int init_module(void)
{
rt_assign_irq_to_cpu(0, 0);
rtf_create(CMDF, 10000);
if (Mode) {
rt_typed_sem_init(&sem, 0, SEM_TYPE);
}
rt_task_init_cpuid(&thread, intr_handler, 0, STACK_SIZE, 0, 0, 0, 0);
rt_task_resume(&thread);
#ifdef IRQEXT
rt_request_timer((void *)rt_timer_tick_ext, imuldiv(TICK, FREQ_8254, 1000000000), 0);
rt_set_global_irq_ext(0, 1, 0);
#else
rt_request_timer((void *)rt_timer_tick, imuldiv(TICK, FREQ_8254, 1000000000), 0);
#endif
SETUP_8254_TSC_EMULATION;
return 0;
}
static int __preempt_init(void)
{
RTIME start;
rtf_create(FIFO, 1000);
rt_linux_use_fpu(USE_FPU);
rt_task_init_cpuid(&thread, fun, 0, 5000, 0, USE_FPU, 0, 0);
rt_task_init_cpuid(&Fast_Task, Fast_Thread, 0, 5000, 1, 0, 0, 0);
rt_task_init_cpuid(&Slow_Task, Slow_Thread, 0, 5000, 2, 0, 0, 0);
#ifdef ONESHOT_MODE
rt_set_oneshot_mode();
#endif
period = start_rt_timer(nano2count(TICK_TIME));
expected = start = rt_get_time() + 100*period;
rt_task_make_periodic(&thread, start, period);
rt_task_make_periodic(&Fast_Task, start, FASTMUL*period);
rt_task_make_periodic(&Slow_Task, start, SLOWMUL*period);
return 0;
}
int init_module(void)
{
int ret;
unsigned long local_ip = rt_inet_aton(local_ip_s);
unsigned long broadcast_ip = rt_inet_aton(broadcast_ip_s);
rtf_create(PRINT, 40000);
rt_sem_init(&tx_sem, 0);
rt_printk ("local ip address %s=%8x\n", local_ip_s, local_ip);
rt_printk ("broadcast ip address %s=%8x\n", broadcast_ip_s, broadcast_ip);
/* create rt-socket */
sock=rt_socket(AF_INET,SOCK_DGRAM,0);
/* bind the rt-socket to local_addr */
memset(&local_addr, 0, sizeof(struct sockaddr_in));
local_addr.sin_family = AF_INET;
local_addr.sin_port = htons(RCV_PORT);
local_addr.sin_addr.s_addr = local_ip;
ret=rt_socket_bind(sock, (struct sockaddr *) &local_addr, sizeof(struct sockaddr_in));
/* set server-addr */
memset(&broadcast_addr, 0, sizeof(struct sockaddr_in));
broadcast_addr.sin_family = AF_INET;
broadcast_addr.sin_port = htons(SRV_PORT);
broadcast_addr.sin_addr.s_addr = broadcast_ip;
// set up receiving
rt_socket_callback(sock, echo_rcv, NULL);
/* Timer already started by RTmac in oneshot mode. */
//rt_set_oneshot_mode();
//start_rt_timer(TIMERTICKS);
ret=rt_task_init(&rt_task,(void *)process,0,4096,10,0,NULL);
ret=rt_task_make_periodic_relative_ns( &rt_task, 10 * 1000*1000, cycle * 1000);
return ret;
}
int init_module(void)
{
unsigned int add_rtskbs = 30;
int ret;
unsigned long local_ip;
unsigned long server_ip;
if (strlen(local_ip_s) != 0)
local_ip = rt_inet_aton(local_ip_s);
else
local_ip = INADDR_ANY;
server_ip = rt_inet_aton(server_ip_s);
rtf_create(PRINT_FIFO, 40000);
rt_sem_init(&tx_sem, 0);
rt_printk("local ip address %s=%8x\n", local_ip_s, (unsigned int) local_ip);
rt_printk("server ip address %s=%8x\n", server_ip_s, (unsigned int) server_ip);
/* create rt-socket */
rt_printk("create rtsocket\n");
if ((sock = socket_rt(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
rt_printk("socket not created\n");
return sock;
}
/* extend the socket pool */
ret = ioctl_rt(sock, RTNET_RTIOC_EXTPOOL, &add_rtskbs);
if (ret != (int)add_rtskbs) {
close_rt(sock);
rt_printk("ioctl_rt(RTNET_RTIOC_EXTPOOL) = %d\n", ret);
return -1;
}
/* bind the rt-socket to local_addr */
local_addr.sin_family = AF_INET;
local_addr.sin_port = htons(RCV_PORT);
local_addr.sin_addr.s_addr = local_ip;
if ((ret = bind_rt(sock, (struct sockaddr *)&local_addr,
sizeof(struct sockaddr_in))) < 0) {
close_rt(sock);
rt_printk("can't bind rtsocket\n");
return ret;
}
/* set server-addr */
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(SRV_PORT);
server_addr.sin_addr.s_addr = server_ip;
rt_task_init(&xmit_task,(void *)process,0,4096,10,0,NULL);
rt_task_resume(&xmit_task);
rt_task_init(&recv_task,(void *)echo_rcv,0,4096,9,0,NULL);
rt_task_resume(&recv_task);
rt_request_global_irq(parirq, parport_irq_handler);
rt_startup_irq(parirq);
outb(0xFF, PAR_DATA);
outb(0x14 + KHZ0_1, PAR_CONTROL);
return ret;
}
int init_module(void)
{
unsigned int nonblock = 1;
unsigned int add_rtskbs = 30;
int ret;
unsigned long local_ip;
unsigned long server_ip;
if (strlen(local_ip_s) != 0)
local_ip = rt_inet_aton(local_ip_s);
else
local_ip = INADDR_ANY;
server_ip = rt_inet_aton(server_ip_s);
rtf_create(PRINT_FIFO, 40000);
rt_sem_init(&tx_sem, 0);
rt_printk ("local ip address %s=%8x\n", local_ip_s, (unsigned int) local_ip);
rt_printk ("server ip address %s=%8x\n", server_ip_s, (unsigned int) server_ip);
/* create rt-socket */
rt_printk("create rtsocket\n");
if ((sock=rt_socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
rt_printk("socket not created\n");
return sock;
}
/* switch to non-blocking */
ret = rt_setsockopt(sock, SOL_SOCKET, RT_SO_NONBLOCK, &nonblock, sizeof(nonblock));
rt_printk("rt_setsockopt(RT_SO_NONBLOCK) = %d\n", ret);
/* extend the socket pool */
ret = rt_setsockopt(sock, SOL_SOCKET, RT_SO_EXTPOOL, &add_rtskbs, sizeof(add_rtskbs));
if (ret != (int)add_rtskbs) {
rt_socket_close(sock);
rt_printk("rt_setsockopt(RT_SO_EXTPOOL) = %d\n", ret);
return -1;
}
/* bind the rt-socket to local_addr */
memset(&local_addr, 0, sizeof(struct sockaddr_in));
local_addr.sin_family = AF_INET;
local_addr.sin_port = htons(RCV_PORT);
local_addr.sin_addr.s_addr = local_ip;
if ( (ret=rt_socket_bind(sock, (struct sockaddr *) &local_addr, sizeof(struct sockaddr_in)))<0 ) {
rt_socket_close(sock);
rt_printk("can't bind rtsocket\n");
return ret;
}
/* set server-addr */
memset(&server_addr, 0, sizeof(struct sockaddr_in));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(SRV_PORT);
server_addr.sin_addr.s_addr = server_ip;
/* set up receiving */
rt_socket_callback(sock, echo_rcv, NULL);
ret=rt_task_init(&rt_task,(void *)process,0,4096,10,0,NULL);
rt_task_resume(&rt_task);
rt_request_global_irq(parirq, parport_irq_handler);
rt_startup_irq(parirq);
outb(0xFF, PAR_DATA);
outb(0x14 + KHZ0_1, PAR_CONTROL);
return ret;
}
static void *intr_handler(void *args)
{
RT_TASK *mytask;
RTIME period;
int playfifo, cntrfifo;
char data;
#ifdef U_LAW
int go=1;
int divisor = DIVISOR;
#else
char temp;
#endif
rt_allow_nonroot_hrt();
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
#ifdef U_LAW
if (iopl(3)) {
printf("iopl() failed/n");
exit(1);
}
outb_p(0x92, 0x43); /* binary, mode1, LSB only, ch 2 */
/* You can make this bigger, but then you start to get
* clipping, which sounds bad. 29 is good */
/* VOLUME SETTING */
pcsp_calc_vol(70);
port61 = inb(0x61) | 0x3;
#else
ioperm(PORT_ADR, 1, 1);
#endif
if (!(mytask = rt_task_init_schmod(nam2num("SOUND"), 1, 0, 0, SCHED_FIFO, 0xF))) {
printf("CANNOT INIT SOUND TASK\n");
exit(1);
}
playfifo = 0;
cntrfifo = 1;
rtf_create(playfifo, 8192); /* 1s buffer */
rtf_reset(playfifo);
rtf_create(cntrfifo, 1000);
rtf_reset(cntrfifo);
rt_set_oneshot_mode();
start_rt_timer(0);
period = nano2count(PERIOD);
printf("\nINIT SOUND TASK\n");
mlockall(MCL_CURRENT | MCL_FUTURE);
#ifdef HARDREALTIME
rt_make_hard_real_time();
#endif
rt_task_make_periodic(mytask, rt_get_time() + 5*period, period);
rtf_put(cntrfifo, &data, 1);
rt_sleep(nano2count(100000000));
while(1) {
#ifdef U_LAW
if (!(--divisor)) {
divisor = DIVISOR;
//cpu_used[hard_cpu_id()]++;
if (!(rtf_get(playfifo, &data, 1) > 0)) {
go=0;
}else{
go=1;
}
}
if(go){
outb(port61,0x61);
outb(port61^1,0x61);
outb(vl_tab[((unsigned int)data)&0xff], 0x42);
}
#else
if (rtf_get(playfifo, &data, 1) > 0) {
go=1;
data = filter(data);
temp = inb(PORT_ADR);
temp &= 0xfd;
temp |= (data & 1) << 1;
outb(temp, PORT_ADR);
} else {
go=0;
}
#endif
rt_task_wait_period();
if (go==0) {
if (rtf_get(cntrfifo, &data, 1) > 0) {
break;
}
}
}
stop_rt_timer();
rt_make_soft_real_time();
rtf_destroy(playfifo);
rtf_destroy(cntrfifo);
rt_task_delete(mytask);
printf("\nEND SOUND TASK\n");
return 0;
}
int init_module(void)
{
int ret;
RTIME tick_period;
struct rtsocket *socket;
unsigned long local_ip = rt_inet_aton(local_ip_s);
unsigned long client_ip = rt_inet_aton(client_ip_s);
rt_printk ("local ip address %s=%8x\n", local_ip_s, local_ip);
rt_printk ("client ip address %s=%8x\n", client_ip_s, client_ip);
/* create rt-socket */
rt_printk("create rtsocket\n");
if ( !(sock=rt_socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) ) {
rt_printk("socket not created\n");
return -ENOMEM;
}
/* bind the rt-socket to local_addr */
rt_printk("bind rtsocket to local address:port\n");
memset(&local_addr, 0, sizeof(struct sockaddr_in));
local_addr.sin_family = AF_INET;
local_addr.sin_port = htons(RCV_PORT);
local_addr.sin_addr.s_addr = local_ip;
if ( (ret=rt_socket_bind(sock, (struct sockaddr *) &local_addr, sizeof(struct sockaddr_in)))<0 ) {
rt_printk("can't bind rtsocket\n");
return ret;
}
/* set client-addr */
rt_printk("connect rtsocket to client address:port\n");
memset(&client_addr, 0, sizeof(struct sockaddr_in));
client_addr.sin_family = AF_INET;
client_addr.sin_port = htons(SRV_PORT);
client_addr.sin_addr.s_addr = client_ip;
if ( (ret=rt_socket_connect(sock, (struct sockaddr *) &client_addr, sizeof(struct sockaddr_in)))<0 ) {
rt_printk("can't connect rtsocket\n");
return ret;
}
/* get socket-structure for printing */
if ( (socket=rt_socket_lookup(sock)) ) {
rt_printk("src addr: %x:%x\n", socket->saddr, socket->sport);
rt_printk("dest addr: %x:%x\n", socket->daddr, socket->dport);
}
/* set up receiving */
rt_socket_callback(sock, echo_rcv, NULL);
/* initialize semaphore */
rt_sem_init(&tx_sem, 0);
/* create print-fifo */
rtf_create (PRINT, 3000);
tick_period = start_rt_timer(nano2count(TICK_PERIOD));
ret=rt_task_init(&rt_task,(void *)process,0,4096,0,0,NULL);
ret=rt_task_make_periodic_relative_ns( &rt_task, 1000000, 1000000000);
return ret;
}
int logInit (void)
{
#ifdef USER_MODE
#ifndef RTAI
int i;
#endif
g_log = calloc(1, sizeof(log_t));
#else
g_log = kmalloc(sizeof(log_t), GFP_KERNEL);
#endif
if (g_log == NULL) {
#ifdef USER_MODE
perror ("cannot allocated memory for log generation module \n");
exit(EXIT_FAILURE);
#else
printk("cannot allocated memory for log generation module \n");
return(-1);
#endif
}
#if ! defined(CN_BUILD)
g_log->log_component[PHY].name = "PHY";
g_log->log_component[PHY].level = LOG_EMERG;
g_log->log_component[PHY].flag = LOG_MED;
g_log->log_component[PHY].interval = 1;
g_log->log_component[PHY].fd = 0;
g_log->log_component[PHY].filelog = 0;
g_log->log_component[PHY].filelog_name = "/tmp/phy.log";
g_log->log_component[MAC].name = "MAC";
g_log->log_component[MAC].level = LOG_EMERG;
g_log->log_component[MAC].flag = LOG_MED;
g_log->log_component[MAC].interval = 1;
g_log->log_component[MAC].fd = 0;
g_log->log_component[MAC].filelog = 0;
g_log->log_component[MAC].filelog_name = "/tmp/mac.log";
g_log->log_component[OPT].name = "OPT";
g_log->log_component[OPT].level = LOG_EMERG;
g_log->log_component[OPT].flag = LOG_MED;
g_log->log_component[OPT].interval = 1;
g_log->log_component[OPT].fd = 0;
g_log->log_component[OPT].filelog = 0;
g_log->log_component[OPT].filelog_name = "";
g_log->log_component[RLC].name = "RLC";
g_log->log_component[RLC].level = LOG_INFO;
g_log->log_component[RLC].flag = LOG_MED;
g_log->log_component[RLC].interval = 1;
g_log->log_component[RLC].fd = 0;
g_log->log_component[RLC].filelog = 0;
g_log->log_component[RLC].filelog_name = "/tmp/rlc.log";
g_log->log_component[PDCP].name = "PDCP";
g_log->log_component[PDCP].level = LOG_INFO;
g_log->log_component[PDCP].flag = LOG_MED;
g_log->log_component[PDCP].interval = 1;
g_log->log_component[PDCP].fd = 0;
g_log->log_component[PDCP].filelog = 0;
g_log->log_component[PDCP].filelog_name = "/tmp/pdcp.log";
g_log->log_component[RRC].name = "RRC";
g_log->log_component[RRC].level = LOG_TRACE;
g_log->log_component[RRC].flag = LOG_MED;
g_log->log_component[RRC].interval = 1;
g_log->log_component[RRC].fd = 0;
g_log->log_component[RRC].filelog = 0;
g_log->log_component[RRC].filelog_name = "/tmp/rrc.log";
g_log->log_component[EMU].name = "EMU";
g_log->log_component[EMU].level = LOG_EMERG;
g_log->log_component[EMU].flag = LOG_MED;
g_log->log_component[EMU].interval = 1;
g_log->log_component[EMU].fd = 0;
g_log->log_component[EMU].filelog = 0;
g_log->log_component[EMU].filelog_name = "";
g_log->log_component[OMG].name = "OMG";
g_log->log_component[OMG].level = LOG_EMERG;
g_log->log_component[OMG].flag = LOG_MED;
g_log->log_component[OMG].interval = 1;
g_log->log_component[OMG].fd = 0;
g_log->log_component[OMG].filelog = 0;
g_log->log_component[OMG].filelog_name = "/tmp/omg.csv";
g_log->log_component[OTG].name = "OTG";
g_log->log_component[OTG].level = LOG_EMERG;
g_log->log_component[OTG].flag = LOG_MED;
g_log->log_component[OTG].interval = 1;
g_log->log_component[OTG].fd = 0;
g_log->log_component[OTG].filelog = 0;
g_log->log_component[OTG].filelog_name = "/tmp/otg.log";
g_log->log_component[OTG_LATENCY].name = "OTG_LATENCY";
g_log->log_component[OTG_LATENCY].level = LOG_EMERG;
g_log->log_component[OTG_LATENCY].flag = LOG_MED;
g_log->log_component[OTG_LATENCY].interval = 1;
g_log->log_component[OTG_LATENCY].fd = 0;
g_log->log_component[OTG_LATENCY].filelog = 0;
g_log->log_component[OTG_LATENCY].filelog_name = "/tmp/otg_latency.dat";
g_log->log_component[OTG_LATENCY_BG].name = "OTG_LATENCY_BG";
g_log->log_component[OTG_LATENCY_BG].level = LOG_EMERG;
g_log->log_component[OTG_LATENCY_BG].flag = LOG_MED;
g_log->log_component[OTG_LATENCY_BG].interval = 1;
g_log->log_component[OTG_LATENCY_BG].fd = 0;
g_log->log_component[OTG_LATENCY_BG].filelog = 0;
g_log->log_component[OTG_LATENCY_BG].filelog_name = "/tmp/otg_latency_bg.dat";
g_log->log_component[OTG_GP].name = "OTG_GP";
g_log->log_component[OTG_GP].level = LOG_EMERG;
g_log->log_component[OTG_GP].flag = LOG_MED;
g_log->log_component[OTG_GP].interval = 1;
g_log->log_component[OTG_GP].fd = 0;
g_log->log_component[OTG_GP].filelog = 0;
g_log->log_component[OTG_GP].filelog_name = "/tmp/otg_goodput.dat";
g_log->log_component[OTG_GP_BG].name = "OTG_GP_BG";
g_log->log_component[OTG_GP_BG].level = LOG_EMERG;
g_log->log_component[OTG_GP_BG].flag = LOG_MED;
g_log->log_component[OTG_GP_BG].interval = 1;
g_log->log_component[OTG_GP_BG].fd = 0;
g_log->log_component[OTG_GP_BG].filelog = 0;
g_log->log_component[OTG_GP_BG].filelog_name = "/tmp/otg_goodput_bg.dat";
g_log->log_component[OTG_JITTER].name = "OTG_JITTER";
g_log->log_component[OTG_JITTER].level = LOG_EMERG;
g_log->log_component[OTG_JITTER].flag = LOG_MED;
g_log->log_component[OTG_JITTER].interval = 1;
g_log->log_component[OTG_JITTER].fd = 0;
g_log->log_component[OTG_JITTER].filelog = 0;
g_log->log_component[OTG_JITTER].filelog_name = "/tmp/otg_jitter.dat";
g_log->log_component[OCG].name = "OCG";
g_log->log_component[OCG].level = LOG_EMERG;
g_log->log_component[OCG].flag = LOG_MED;
g_log->log_component[OCG].interval = 1;
g_log->log_component[OCG].fd = 0;
g_log->log_component[OCG].filelog = 0;
g_log->log_component[OCG].filelog_name = "";
g_log->log_component[PERF].name = "PERF";
g_log->log_component[PERF].level = LOG_EMERG;
g_log->log_component[PERF].flag = LOG_MED;
g_log->log_component[PERF].interval = 1;
g_log->log_component[PERF].fd = 0;
g_log->log_component[PERF].filelog = 0;
g_log->log_component[PERF].filelog_name = "";
g_log->log_component[OIP].name = "OIP";
g_log->log_component[OIP].level = LOG_EMERG;
g_log->log_component[OIP].flag = LOG_MED;
g_log->log_component[OIP].interval = 1;
g_log->log_component[OIP].fd = 0;
g_log->log_component[OIP].filelog = 0;
g_log->log_component[OIP].filelog_name = "";
g_log->log_component[CLI].name = "CLI";
g_log->log_component[CLI].level = LOG_EMERG;
g_log->log_component[CLI].flag = LOG_MED;
g_log->log_component[CLI].interval = 1;
g_log->log_component[CLI].fd = 0;
g_log->log_component[CLI].filelog = 0;
g_log->log_component[CLI].filelog_name = "";
g_log->log_component[MSC].name = "MSC";
g_log->log_component[MSC].level = LOG_EMERG;
g_log->log_component[MSC].flag = LOG_MED;
g_log->log_component[MSC].interval = 1;
g_log->log_component[MSC].fd = 0;
g_log->log_component[MSC].filelog = 0;
g_log->log_component[MSC].filelog_name = "/tmp/msc.log";
g_log->log_component[OCM].name = "OCM";
g_log->log_component[OCM].level = LOG_EMERG;
g_log->log_component[OCM].flag = LOG_MED;
g_log->log_component[OCM].interval = 1;
g_log->log_component[OCM].fd = 0;
g_log->log_component[OCM].filelog = 0;
g_log->log_component[OCM].filelog_name = "/tmp/ocm.log";
g_log->log_component[HW].name = "HW";
g_log->log_component[HW].level = LOG_EMERG;
g_log->log_component[HW].flag = LOG_MED;
g_log->log_component[HW].interval = 1;
g_log->log_component[HW].fd = 0;
g_log->log_component[HW].filelog = 0;
g_log->log_component[HW].filelog_name = "";
g_log->log_component[OSA].name = "OSA";
g_log->log_component[OSA].level = LOG_EMERG;
g_log->log_component[OSA].flag = LOG_MED;
g_log->log_component[OSA].interval = 1;
g_log->log_component[OSA].fd = 0;
g_log->log_component[OSA].filelog = 0;
g_log->log_component[OSA].filelog_name = "";
g_log->log_component[RAL_ENB].name = "eRAL";
g_log->log_component[RAL_ENB].level = LOG_EMERG;
g_log->log_component[RAL_ENB].flag = LOG_MED;
g_log->log_component[RAL_ENB].interval = 1;
g_log->log_component[RAL_ENB].fd = 0;
g_log->log_component[RAL_ENB].filelog = 0;
g_log->log_component[RAL_ENB].filelog_name = "";
g_log->log_component[RAL_UE].name = "mRAL";
g_log->log_component[RAL_UE].level = LOG_EMERG;
g_log->log_component[RAL_UE].flag = LOG_MED;
g_log->log_component[RAL_UE].interval = 1;
g_log->log_component[RAL_UE].fd = 0;
g_log->log_component[RAL_UE].filelog = 0;
g_log->log_component[RAL_UE].filelog_name = "";
g_log->log_component[ENB_APP].name = "ENB_APP";
g_log->log_component[ENB_APP].level = LOG_EMERG;
g_log->log_component[ENB_APP].flag = LOG_MED;
g_log->log_component[ENB_APP].interval = 1;
g_log->log_component[ENB_APP].fd = 0;
g_log->log_component[ENB_APP].filelog = 0;
g_log->log_component[ENB_APP].filelog_name = "";
g_log->log_component[FLEXRAN_AGENT].name = "FLEXRAN_AGENT";
g_log->log_component[FLEXRAN_AGENT].level = LOG_DEBUG;
g_log->log_component[FLEXRAN_AGENT].flag = LOG_MED;
g_log->log_component[FLEXRAN_AGENT].interval = 1;
g_log->log_component[FLEXRAN_AGENT].fd = 0;
g_log->log_component[FLEXRAN_AGENT].filelog = 0;
g_log->log_component[FLEXRAN_AGENT].filelog_name = "";
g_log->log_component[TMR].name = "TMR";
g_log->log_component[TMR].level = LOG_EMERG;
g_log->log_component[TMR].flag = LOG_MED;
g_log->log_component[TMR].interval = 1;
g_log->log_component[TMR].fd = 0;
g_log->log_component[TMR].filelog = 0;
g_log->log_component[TMR].filelog_name = "";
g_log->log_component[USIM].name = "USIM";
g_log->log_component[USIM].level = LOG_DEBUG;
g_log->log_component[USIM].flag = LOG_NONE;
g_log->log_component[USIM].interval = 1;
g_log->log_component[USIM].fd = 0;
g_log->log_component[USIM].filelog = 0;
g_log->log_component[USIM].filelog_name = "/tmp/usim.txt";
/* following log component are used for the localization*/
g_log->log_component[LOCALIZE].name = "LOCALIZE";
g_log->log_component[LOCALIZE].level = LOG_EMERG;
g_log->log_component[LOCALIZE].flag = LOG_MED;
g_log->log_component[LOCALIZE].interval = 1;
g_log->log_component[LOCALIZE].fd = 0;
g_log->log_component[LOCALIZE].filelog = 0;
g_log->log_component[LOCALIZE].filelog_name = "/tmp/localize.log";
#endif // ! defined(CN_BUILD)
g_log->log_component[NAS].name = "NAS";
g_log->log_component[NAS].level = LOG_TRACE;
g_log->log_component[NAS].flag = LOG_MED;
g_log->log_component[NAS].interval = 1;
g_log->log_component[NAS].fd = 0;
g_log->log_component[NAS].filelog = 0;
g_log->log_component[NAS].filelog_name = "/tmp/nas.log";
g_log->log_component[UDP_].name = "UDP";
g_log->log_component[UDP_].level = LOG_EMERG;
g_log->log_component[UDP_].flag = LOG_FULL;
g_log->log_component[UDP_].interval = 1;
g_log->log_component[UDP_].fd = 0;
g_log->log_component[UDP_].filelog = 0;
g_log->log_component[UDP_].filelog_name = "";
g_log->log_component[GTPU].name = "GTPV1U";
g_log->log_component[GTPU].level = LOG_EMERG;
g_log->log_component[GTPU].flag = LOG_FULL;
g_log->log_component[GTPU].interval = 1;
g_log->log_component[GTPU].fd = 0;
g_log->log_component[GTPU].filelog = 0;
g_log->log_component[GTPU].filelog_name = "";
g_log->log_component[S1AP].name = "S1AP";
g_log->log_component[S1AP].level = LOG_EMERG;
g_log->log_component[S1AP].flag = LOG_FULL;
g_log->log_component[S1AP].interval = 1;
g_log->log_component[S1AP].fd = 0;
g_log->log_component[S1AP].filelog = 0;
g_log->log_component[S1AP].filelog_name = "";
g_log->log_component[SCTP].name = "SCTP";
g_log->log_component[SCTP].level = LOG_EMERG;
g_log->log_component[SCTP].flag = LOG_MED;
g_log->log_component[SCTP].interval = 1;
g_log->log_component[SCTP].fd = 0;
g_log->log_component[SCTP].filelog = 0;
g_log->log_component[SCTP].filelog_name = "";
g_log->log_component[RRH].name = "RRH";
g_log->log_component[RRH].level = LOG_EMERG;
g_log->log_component[RRH].flag = LOG_MED;
g_log->log_component[RRH].interval = 1;
g_log->log_component[RRH].fd = 0;
g_log->log_component[RRH].filelog = 0;
g_log->log_component[RRH].filelog_name = "";
g_log->level2string[LOG_EMERG] = "G"; //EMERG
g_log->level2string[LOG_ALERT] = "A"; // ALERT
g_log->level2string[LOG_CRIT] = "C"; // CRITIC
g_log->level2string[LOG_ERR] = "E"; // ERROR
g_log->level2string[LOG_WARNING] = "W"; // WARNING
g_log->level2string[LOG_NOTICE] = "N"; // NOTICE
g_log->level2string[LOG_INFO] = "I"; //INFO
g_log->level2string[LOG_DEBUG] = "D"; // DEBUG
g_log->level2string[LOG_FILE] = "F"; // file
g_log->level2string[LOG_TRACE] = "T"; // TRACE
g_log->onlinelog = 1; //online log file
g_log->syslog = 0;
g_log->filelog = 0;
g_log->level = LOG_TRACE;
g_log->flag = LOG_LOW;
#ifndef RTAI
g_log->config.remote_ip = 0;
g_log->config.remote_level = LOG_EMERG;
g_log->config.facility = LOG_LOCAL7;
g_log->config.audit_ip = 0;
g_log->config.audit_facility = LOG_LOCAL6;
g_log->config.format = 0x00; // online debug inactive
g_log->filelog_name = "/tmp/openair.log";
if (g_log->syslog) {
#if ! defined(CN_BUILD)
openlog(g_log->log_component[EMU].name, LOG_PID, g_log->config.facility);
#endif // ! defined(CN_BUILD)
}
if (g_log->filelog) {
gfd = open(g_log->filelog_name, O_WRONLY | O_CREAT, 0666);
}
// could put a loop here to check for all comps
for (i=MIN_LOG_COMPONENTS; i < MAX_LOG_COMPONENTS; i++) {
if (g_log->log_component[i].filelog == 1 ) {
g_log->log_component[i].fd = open(g_log->log_component[i].filelog_name,
O_WRONLY | O_CREAT | O_APPEND, 0666);
}
}
#else
g_log->syslog = 0;
g_log->filelog = 0;
rtf_create (FIFO_PRINTF_NO, FIFO_PRINTF_SIZE);
#endif
#ifdef USER_MODE
printf("log init done\n");
#else
printk("log init done\n");
#endif
return 0;
}
int main(int argc, char **argv) {
#ifdef RTAI
RT_TASK *task;
RTIME period;
#endif
int i,j,aa;
void *status;
/*
uint32_t rf_mode_max[4] = {55759,55759,55759,55759};
uint32_t rf_mode_med[4] = {39375,39375,39375,39375};
uint32_t rf_mode_byp[4] = {22991,22991,22991,22991};
*/
uint32_t my_rf_mode = RXEN + TXEN + TXLPFNORM + TXLPFEN + TXLPF25 + RXLPFNORM + RXLPFEN + RXLPF25 + LNA1ON +LNAMax + RFBBNORM + DMAMODE_RX + DMAMODE_TX;
uint32_t rf_mode_base = TXLPFNORM + TXLPFEN + TXLPF25 + RXLPFNORM + RXLPFEN + RXLPF25 + LNA1ON +LNAMax + RFBBNORM;
uint32_t rf_mode[4] = {my_rf_mode,0,0,0};
uint32_t rf_local[4] = {8255000,8255000,8255000,8255000}; // UE zepto
//{8254617, 8254617, 8254617, 8254617}; //eNB khalifa
//{8255067,8254810,8257340,8257340}; // eNB PETRONAS
uint32_t rf_vcocal[4] = {910,910,910,910};
uint32_t rf_vcocal_850[4] = {2015, 2015, 2015, 2015};
uint32_t rf_rxdc[4] = {32896,32896,32896,32896};
uint32_t rxgain[4] = {20,20,20,20};
uint32_t txgain[4] = {20,20,20,20};
uint16_t Nid_cell = 0;
uint8_t cooperation_flag=0, transmission_mode=1, abstraction_flag=0;
uint8_t beta_ACK=0,beta_RI=0,beta_CQI=2;
int c;
char do_forms=0;
unsigned int fd;
unsigned int tcxo = 114;
int amp;
uint8_t prach_fmt;
int N_ZC;
char rxg_fname[100];
char txg_fname[100];
char rflo_fname[100];
char rfdc_fname[100];
FILE *rxg_fd=NULL;
FILE *txg_fd=NULL;
FILE *rflo_fd=NULL;
FILE *rfdc_fd=NULL;
unsigned int rxg_max[4]={133,133,133,133}, rxg_med[4]={127,127,127,127}, rxg_byp[4]={120,120,120,120};
int tx_max_power=0;
char line[1000];
int l;
int ret, ant;
int ant_offset=0;
int error_code;
char *itti_dump_file = NULL;
const struct option long_options[] = {
{"calib-ue-rx", required_argument, NULL, 256},
{"calib-ue-rx-med", required_argument, NULL, 257},
{"calib-ue-rx-byp", required_argument, NULL, 258},
{"debug-ue-prach", no_argument, NULL, 259},
{"no-L2-connect", no_argument, NULL, 260},
{NULL, 0, NULL, 0}};
//mode = normal_txrx;
while ((c = getopt_long (argc, argv, "C:K:O:ST:UdF:V",long_options,NULL)) != -1)
{
switch (c)
{
case 'V':
ouput_vcd = 1;
break;
case 'd':
do_forms=1;
break;
case 'U':
UE_flag = 1;
break;
case 'C':
carrier_freq[0] = atoi(optarg);
carrier_freq[1] = atoi(optarg);
carrier_freq[2] = atoi(optarg);
carrier_freq[3] = atoi(optarg);
break;
case 'S':
fs4_test=1;
break;
case 'T':
tcxo=atoi(optarg);
break;
case 'K':
#if defined(ENABLE_ITTI)
itti_dump_file = strdup(optarg);
#else
printf("-K option is disabled when ENABLE_ITTI is not defined\n");
#endif
break;
case 'O':
#if defined(ENABLE_USE_MME)
EPC_MODE_ENABLED = 1;
if (optarg == NULL) /* No IP address provided: use localhost */
{
memcpy(&EPC_MODE_MME_ADDRESS[0], "127.0.0.1", 10);
} else {
uint8_t ip_length = strlen(optarg) + 1;
memcpy(&EPC_MODE_MME_ADDRESS[0], optarg,
ip_length > 16 ? 16 : ip_length);
}
#else
printf("You enabled mme mode without s1ap compiled...\n");
#endif
break;
case 'F':
sprintf(rxg_fname,"%srxg.lime",optarg);
rxg_fd = fopen(rxg_fname,"r");
if (rxg_fd) {
printf("Loading RX Gain parameters from %s\n",rxg_fname);
l=0;
while (fgets(line, sizeof(line), rxg_fd)) {
if ((strlen(line)==0) || (*line == '#')) continue; //ignore empty or comment lines
else {
if (l==0) sscanf(line,"%d %d %d %d",&rxg_max[0],&rxg_max[1],&rxg_max[2],&rxg_max[3]);
if (l==1) sscanf(line,"%d %d %d %d",&rxg_med[0],&rxg_med[1],&rxg_med[2],&rxg_med[3]);
if (l==2) sscanf(line,"%d %d %d %d",&rxg_byp[0],&rxg_byp[1],&rxg_byp[2],&rxg_byp[3]);
l++;
}
}
}
else
printf("%s not found, running with defaults\n",rxg_fname);
sprintf(txg_fname,"%stxg.lime",optarg);
txg_fd = fopen(txg_fname,"r");
if (txg_fd) {
printf("Loading TX Gain parameters from %s\n",txg_fname);
l=0;
while (fgets(line, sizeof(line), txg_fd)) {
if ((strlen(line)==0) || (*line == '#')) {
continue; //ignore empty or comment lines
}
else {
if (l==0) sscanf(line,"%d %d %d %d",&txgain[0],&txgain[1],&txgain[2],&txgain[3]);
if (l==1) sscanf(line,"%d",&tx_max_power);
l++;
}
}
}
else
printf("%s not found, running with defaults\n",txg_fname);
sprintf(rflo_fname,"%srflo.lime",optarg);
rflo_fd = fopen(rflo_fname,"r");
if (rflo_fd) {
printf("Loading RF LO parameters from %s\n",rflo_fname);
fscanf(rflo_fd,"%d %d %d %d",&rf_local[0],&rf_local[1],&rf_local[2],&rf_local[3]);
}
else
printf("%s not found, running with defaults\n",rflo_fname);
sprintf(rfdc_fname,"%srfdc.lime",optarg);
rfdc_fd = fopen(rfdc_fname,"r");
if (rfdc_fd) {
printf("Loading RF DC parameters from %s\n",rfdc_fname);
fscanf(rfdc_fd,"%d %d %d %d",&rf_rxdc[0],&rf_rxdc[1],&rf_rxdc[2],&rf_rxdc[3]);
}
else
printf("%s not found, running with defaults\n",rfdc_fname);
break;
/*
case 256:
mode = rx_calib_ue;
rx_input_level_dBm = atoi(optarg);
printf("Running with UE calibration on (LNA max), input level %d dBm\n",rx_input_level_dBm);
break;
case 257:
mode = rx_calib_ue_med;
rx_input_level_dBm = atoi(optarg);
printf("Running with UE calibration on (LNA med), input level %d dBm\n",rx_input_level_dBm);
break;
case 258:
mode = rx_calib_ue_byp;
rx_input_level_dBm = atoi(optarg);
printf("Running with UE calibration on (LNA byp), input level %d dBm\n",rx_input_level_dBm);
break;
case 259:
mode = debug_prach;
break;
case 260:
mode = no_L2_connect;
break;
*/
default:
break;
}
}
if (UE_flag==1)
printf("configuring for UE\n");
else
printf("configuring for eNB\n");
//randominit (0);
//set_taus_seed (0);
// initialize the log (see log.h for details)
logInit();
#if defined(ENABLE_ITTI)
itti_init(TASK_MAX, THREAD_MAX, MESSAGES_ID_MAX, tasks_info, messages_info, messages_definition_xml, itti_dump_file);
# if defined(ENABLE_USE_MME)
if (itti_create_task(TASK_SCTP, sctp_eNB_task, NULL) < 0) {
LOG_E(EMU, "Create task failed");
LOG_D(EMU, "Initializing SCTP task interface: FAILED\n");
return -1;
}
if (itti_create_task(TASK_S1AP, s1ap_eNB_task, NULL) < 0) {
LOG_E(EMU, "Create task failed");
LOG_D(EMU, "Initializing S1AP task interface: FAILED\n");
return -1;
}
# endif
if (itti_create_task(TASK_L2L1, l2l1_task, NULL) < 0) {
LOG_E(EMU, "Create task failed");
LOG_D(EMU, "Initializing L2L1 task interface: FAILED\n");
return -1;
}
// Handle signals until all tasks are terminated
// itti_wait_tasks_end();
#endif
if (ouput_vcd) {
if (UE_flag==1)
vcd_signal_dumper_init("/tmp/openair_dump_UE.vcd");
else
vcd_signal_dumper_init("/tmp/openair_dump_eNB.vcd");
}
#ifdef NAS_NETLINK
netlink_init();
#endif
// to make a graceful exit when ctrl-c is pressed
signal(SIGSEGV, signal_handler);
signal(SIGINT, signal_handler);
#ifndef RTAI
check_clock();
#endif
g_log->log_component[HW].level = LOG_DEBUG;
g_log->log_component[HW].flag = LOG_HIGH;
#ifdef OPENAIR2
g_log->log_component[PHY].level = LOG_INFO;
#else
g_log->log_component[PHY].level = LOG_INFO;
#endif
g_log->log_component[PHY].flag = LOG_HIGH;
g_log->log_component[MAC].level = LOG_INFO;
g_log->log_component[MAC].flag = LOG_HIGH;
g_log->log_component[RLC].level = LOG_INFO;
g_log->log_component[RLC].flag = LOG_HIGH;
g_log->log_component[PDCP].level = LOG_INFO;
g_log->log_component[PDCP].flag = LOG_HIGH;
g_log->log_component[OTG].level = LOG_INFO;
g_log->log_component[OTG].flag = LOG_HIGH;
g_log->log_component[RRC].level = LOG_INFO;
g_log->log_component[RRC].flag = LOG_HIGH;
// Initialize card
ret = openair0_open();
if ( ret != 0 ) {
if (ret == -1)
printf("Error opening /dev/openair0");
if (ret == -2)
printf("Error mapping bigshm");
if (ret == -3)
printf("Error mapping RX or TX buffer");
return(ret);
}
printf ("Detected %d number of cards, %d number of antennas.\n", openair0_num_detected_cards, openair0_num_antennas[card]);
p_exmimo_config = openair0_exmimo_pci[card].exmimo_config_ptr;
p_exmimo_id = openair0_exmimo_pci[card].exmimo_id_ptr;
printf("Card %d: ExpressMIMO %d, HW Rev %d, SW Rev 0x%d\n", card, p_exmimo_id->board_exmimoversion, p_exmimo_id->board_hwrev, p_exmimo_id->board_swrev);
if (p_exmimo_id->board_swrev>=BOARD_SWREV_CNTL2)
p_exmimo_config->framing.eNB_flag = 0;
else
p_exmimo_config->framing.eNB_flag = !UE_flag;
p_exmimo_config->framing.tdd_config = DUPLEXMODE_FDD + TXRXSWITCH_LSB;
for (ant=0; ant<4; ant++)
p_exmimo_config->framing.resampling_factor[ant] = RESAMPLING_FACTOR;
/*
for (ant=0;ant<max(frame_parms->nb_antennas_tx,frame_parms->nb_antennas_rx);ant++)
p_exmimo_config->rf.rf_mode[ant] = rf_mode_base;
for (ant=0;ant<frame_parms->nb_antennas_tx;ant++)
p_exmimo_config->rf.rf_mode[ant] += (TXEN + DMAMODE_TX);
for (ant=0;ant<frame_parms->nb_antennas_rx;ant++)
p_exmimo_config->rf.rf_mode[ant] += (RXEN + DMAMODE_RX);
for (ant=max(frame_parms->nb_antennas_tx,frame_parms->nb_antennas_rx);ant<4;ant++) {
p_exmimo_config->rf.rf_mode[ant] = 0;
carrier_freq[ant] = 0; //this turns off all other LIMEs
}
*/
ant_offset = 0;
for (ant=0; ant<4; ant++) {
if (ant==ant_offset) {
//if (1) {
p_exmimo_config->rf.rf_mode[ant] = rf_mode_base;
//p_exmimo_config->rf.rf_mode[ant] += (TXEN + DMAMODE_TX);
p_exmimo_config->rf.rf_mode[ant] += (RXEN + DMAMODE_RX);
}
else {
p_exmimo_config->rf.rf_mode[ant] = 0;
carrier_freq[ant] = 0; //this turns off all other LIMEs
}
}
for (ant = 0; ant<4; ant++) {
p_exmimo_config->rf.do_autocal[ant] = 1;
p_exmimo_config->rf.rf_freq_rx[ant] = carrier_freq[ant];
p_exmimo_config->rf.rf_freq_tx[ant] = carrier_freq[ant];
p_exmimo_config->rf.rx_gain[ant][0] = rxgain[ant];
p_exmimo_config->rf.tx_gain[ant][0] = txgain[ant];
p_exmimo_config->rf.rf_local[ant] = rf_local[ant];
p_exmimo_config->rf.rf_rxdc[ant] = rf_rxdc[ant];
if ((carrier_freq[ant] >= 850000000) && (carrier_freq[ant] <= 865000000)) {
p_exmimo_config->rf.rf_vcocal[ant] = rf_vcocal_850[ant];
p_exmimo_config->rf.rffe_band_mode[ant] = DD_TDD;
}
else if ((carrier_freq[ant] >= 1900000000) && (carrier_freq[ant] <= 2000000000)) {
p_exmimo_config->rf.rf_vcocal[ant] = rf_vcocal[ant];
p_exmimo_config->rf.rffe_band_mode[ant] = B19G_TDD;
}
else {
p_exmimo_config->rf.rf_vcocal[ant] = rf_vcocal[ant];
p_exmimo_config->rf.rffe_band_mode[ant] = 0;
}
p_exmimo_config->rf.rffe_gain_txlow[ant] = 31;
p_exmimo_config->rf.rffe_gain_txhigh[ant] = 31;
p_exmimo_config->rf.rffe_gain_rxfinal[ant] = 52;
p_exmimo_config->rf.rffe_gain_rxlow[ant] = 31;
}
number_of_cards = openair0_num_detected_cards;
/*
if (p_exmimo_id->board_exmimoversion==1) //ExpressMIMO1
openair_daq_vars.timing_advance = 138;
else //ExpressMIMO2
openair_daq_vars.timing_advance = 0;
*/
openair0_dump_config(card);
printf("EXMIMO_CONFIG: rf_mode 0x %x %x %x %x, [0]: TXRXEn %d, TXLPFEn %d, TXLPF %d, RXLPFEn %d, RXLPF %d, RFBB %d, LNA %d, LNAGain %d, RXLPFMode %d, SWITCH %d, rf_rxdc %d, rf_local %d, rf_vcocal %d\n",
p_exmimo_config->rf.rf_mode[0],
p_exmimo_config->rf.rf_mode[1],
p_exmimo_config->rf.rf_mode[2],
p_exmimo_config->rf.rf_mode[3],
(p_exmimo_config->rf.rf_mode[0]&3), // RXen+TXen
(p_exmimo_config->rf.rf_mode[0]&4)>>2, //TXLPFen
(p_exmimo_config->rf.rf_mode[0]&TXLPFMASK)>>3, //TXLPF
(p_exmimo_config->rf.rf_mode[0]&128)>>7, //RXLPFen
(p_exmimo_config->rf.rf_mode[0]&RXLPFMASK)>>8, //TXLPF
(p_exmimo_config->rf.rf_mode[0]&RFBBMASK)>>16, // RFBB mode
(p_exmimo_config->rf.rf_mode[0]&LNAMASK)>>12, // RFBB mode
(p_exmimo_config->rf.rf_mode[0]&LNAGAINMASK)>>14, // RFBB mode
(p_exmimo_config->rf.rf_mode[0]&RXLPFMODEMASK)>>19, // RXLPF mode
(p_exmimo_config->framing.tdd_config&TXRXSWITCH_MASK)>>1, // Switch mode
p_exmimo_config->rf.rf_rxdc[0],
p_exmimo_config->rf.rf_local[0],
p_exmimo_config->rf.rf_vcocal[0]);
for (ant=0;ant<4;ant++)
p_exmimo_config->rf.do_autocal[ant] = 0;
#ifdef EMOS
error_code = rtf_create(CHANSOUNDER_FIFO_MINOR,CHANSOUNDER_FIFO_SIZE);
if (error_code==0)
printf("[OPENAIR][SCHED][INIT] Created EMOS FIFO %d\n",CHANSOUNDER_FIFO_MINOR);
else if (error_code==ENODEV)
printf("[OPENAIR][SCHED][INIT] Problem: EMOS FIFO %d is greater than or equal to RTF_NO\n",CHANSOUNDER_FIFO_MINOR);
else if (error_code==ENOMEM)
printf("[OPENAIR][SCHED][INIT] Problem: cannot allocate memory for EMOS FIFO %d\n",CHANSOUNDER_FIFO_MINOR);
else
printf("[OPENAIR][SCHED][INIT] Problem creating EMOS FIFO %d, error_code %d\n",CHANSOUNDER_FIFO_MINOR,error_code);
#endif
mlockall(MCL_CURRENT | MCL_FUTURE);
#ifdef RTAI
// make main thread LXRT soft realtime
task = rt_task_init_schmod(nam2num("MYTASK"), 9, 0, 0, SCHED_FIFO, 0xF);
// start realtime timer and scheduler
#ifdef TIMER_ONESHOT_MODE
rt_set_oneshot_mode();
start_rt_timer(0);
printf("started RTAI timer inoneshot mode\n");
#else
rt_set_periodic_mode();
period = start_rt_timer(nano2count(500000));
printf("started RTAI timer with period %llu ns\n",count2nano(period));
#endif
printf("Init mutex\n");
//mutex = rt_get_adr(nam2num("MUTEX"));
mutex = rt_sem_init(nam2num("MUTEX"), 1);
if (mutex==0)
{
printf("Error init mutex\n");
exit(-1);
}
else
printf("mutex=%p\n",mutex);
#endif
DAQ_MBOX = (volatile unsigned int *) openair0_exmimo_pci[card].rxcnt_ptr[0];
// this starts the DMA transfers
if (UE_flag!=1)
openair0_start_rt_acquisition(card);
#ifdef XFORMS
if (do_forms==1) {
fl_initialize (&argc, argv, NULL, 0, 0);
form_stats = create_form_stats_form();
if (UE_flag==1) {
form_ue[UE_id] = create_lte_phy_scope_ue();
sprintf (title, "LTE DL SCOPE UE");
fl_show_form (form_ue[UE_id]->lte_phy_scope_ue, FL_PLACE_HOTSPOT, FL_FULLBORDER, title);
} else {
for(UE_id=0;UE_id<scope_enb_num_ue;UE_id++) {
form_enb[UE_id] = create_lte_phy_scope_enb();
sprintf (title, "UE%d LTE UL SCOPE eNB",UE_id+1);
fl_show_form (form_enb[UE_id]->lte_phy_scope_enb, FL_PLACE_HOTSPOT, FL_FULLBORDER, title);
}
}
fl_show_form (form_stats->stats_form, FL_PLACE_HOTSPOT, FL_FULLBORDER, "stats");
if (UE_flag==0) {
for (UE_id=0;UE_id<scope_enb_num_ue;UE_id++) {
if (otg_enabled) {
fl_set_button(form_enb[UE_id]->button_0,1);
fl_set_object_label(form_enb[UE_id]->button_0,"DL Traffic ON");
}
else {
fl_set_button(form_enb[UE_id]->button_0,0);
fl_set_object_label(form_enb[UE_id]->button_0,"DL Traffic OFF");
}
}
}
else {
if (openair_daq_vars.use_ia_receiver) {
fl_set_button(form_ue[UE_id]->button_0,1);
fl_set_object_label(form_ue[UE_id]->button_0, "IA Receiver ON");
}
else {
fl_set_button(form_ue[UE_id]->button_0,0);
fl_set_object_label(form_ue[UE_id]->button_0, "IA Receiver OFF");
}
}
ret = pthread_create(&thread2, NULL, scope_thread, NULL);
printf("Scope thread created, ret=%d\n",ret);
}
#endif
#ifdef EMOS
ret = pthread_create(&thread3, NULL, emos_thread, NULL);
printf("EMOS thread created, ret=%d\n",ret);
#endif
rt_sleep_ns(10*FRAME_PERIOD);
#ifndef RTAI
pthread_attr_init (&attr_dlsch_threads);
pthread_attr_setstacksize(&attr_dlsch_threads,OPENAIR_THREAD_STACK_SIZE);
//attr_dlsch_threads.priority = 1;
sched_param_dlsch.sched_priority = sched_get_priority_max(SCHED_FIFO); //OPENAIR_THREAD_PRIORITY;
pthread_attr_setschedparam (&attr_dlsch_threads, &sched_param_dlsch);
pthread_attr_setschedpolicy (&attr_dlsch_threads, SCHED_FIFO);
#endif
// start the main thread
if (UE_flag == 1) {
/*
#ifdef RTAI
thread1 = rt_thread_create(UE_thread, NULL, 100000000);
#else
error_code = pthread_create(&thread1, &attr_dlsch_threads, UE_thread, NULL);
if (error_code!= 0) {
LOG_D(HW,"[lte-softmodem.c] Could not allocate UE_thread, error %d\n",error_code);
return(error_code);
}
else {
LOG_D(HW,"[lte-softmodem.c] Allocate UE_thread successful\n");
}
#endif
#ifdef DLSCH_THREAD
init_rx_pdsch_thread();
rt_sleep_ns(FRAME_PERIOD/10);
init_dlsch_threads();
#endif
printf("UE threads created\n");
*/
}
else {
#ifdef RTAI
thread0 = rt_thread_create(eNB_thread, NULL, 100000000);
#else
error_code = pthread_create(&thread0, &attr_dlsch_threads, eNB_thread, NULL);
if (error_code!= 0) {
LOG_D(HW,"[lte-softmodem.c] Could not allocate eNB_thread, error %d\n",error_code);
return(error_code);
}
else {
LOG_D(HW,"[lte-softmodem.c] Allocate eNB_thread successful\n");
}
#endif
#ifdef ULSCH_THREAD
init_ulsch_threads();
#endif
printf("eNB threads created\n");
}
// wait for end of program
printf("TYPE <CTRL-C> TO TERMINATE\n");
//getchar();
while (oai_exit==0)
rt_sleep_ns(FRAME_PERIOD);
// stop threads
#ifdef XFORMS
printf("waiting for XFORMS thread\n");
if (do_forms==1)
{
pthread_join(thread2,&status);
fl_hide_form(form_stats->stats_form);
fl_free_form(form_stats->stats_form);
if (UE_flag==1) {
fl_hide_form(form_ue[UE_id]->lte_phy_scope_ue);
fl_free_form(form_ue[UE_id]->lte_phy_scope_ue);
} else {
for(UE_id=0;UE_id<scope_enb_num_ue;UE_id++) {
fl_hide_form(form_enb[UE_id]->lte_phy_scope_enb);
fl_free_form(form_enb[UE_id]->lte_phy_scope_enb);
}
}
}
#endif
printf("stopping MODEM threads\n");
// cleanup
if (UE_flag == 1) {
/*
#ifdef RTAI
rt_thread_join(thread1);
#else
pthread_join(thread1,&status);
#endif
#ifdef DLSCH_THREAD
cleanup_dlsch_threads();
cleanup_rx_pdsch_thread();
#endif
*/
}
else {
#ifdef RTAI
rt_thread_join(thread0);
#else
pthread_join(thread0,&status);
#endif
#ifdef ULSCH_THREAD
cleanup_ulsch_threads();
#endif
}
#ifdef OPENAIR2
//cleanup_pdcp_thread();
#endif
#ifdef RTAI
stop_rt_timer();
#endif
printf("stopping card\n");
openair0_stop(card);
printf("closing openair0_lib\n");
openair0_close();
#ifdef EMOS
printf("waiting for EMOS thread\n");
pthread_cancel(thread3);
pthread_join(thread3,&status);
#endif
#ifdef EMOS
error_code = rtf_destroy(CHANSOUNDER_FIFO_MINOR);
printf("[OPENAIR][SCHED][CLEANUP] EMOS FIFO closed, error_code %d\n", error_code);
#endif
if (ouput_vcd)
vcd_signal_dumper_close();
logClean();
return 0;
}
