void generate_ul_ref_sigs(void) {
double qbar,phase;
unsigned int u,v,Msc_RS,q,m,n;
// These are the Zadoff-Chu sequences (for RB 3-100)
for (Msc_RS=2;Msc_RS<33;Msc_RS++) {
for (u=0;u<30;u++) {
for (v=0;v<2;v++) {
qbar = ref_primes[Msc_RS] * (u+1)/(double)31;
ul_ref_sigs[u][v][Msc_RS] = (int16_t*)malloc16(2*sizeof(int16_t)*dftsizes[Msc_RS]);
if ((((int)floor(2*qbar))&1) == 0)
q = (int)(floor(qbar+.5)) - v;
else
q = (int)(floor(qbar+.5)) + v;
#ifdef MAIN
printf("Msc_RS %d (%d), u %d, v %d -> q %d (qbar %f)\n",Msc_RS,dftsizes[Msc_RS],u,v,q,qbar);
#endif
for (n=0;n<dftsizes[Msc_RS];n++) {
m=n%ref_primes[Msc_RS];
phase = (double)q*m*(m+1)/ref_primes[Msc_RS];
ul_ref_sigs[u][v][Msc_RS][n<<1] =(int16_t)(floor(32767*cos(M_PI*phase)));
ul_ref_sigs[u][v][Msc_RS][1+(n<<1)] =-(int16_t)(floor(32767*sin(M_PI*phase)));
#ifdef MAIN
if (Msc_RS<5)
printf("(%d,%d) ",ul_ref_sigs[u][v][Msc_RS][n<<1],ul_ref_sigs[u][v][Msc_RS][1+(n<<1)]);
#endif
}
#ifdef MAIN
if (Msc_RS<5)
printf("\n");
#endif
}
}
}
// These are the sequences for RB 1
for (u=0;u<30;u++) {
ul_ref_sigs[u][0][0] = (int16_t*)malloc16(2*sizeof(int16_t)*dftsizes[0]);
for (n=0;n<dftsizes[0];n++) {
ul_ref_sigs[u][0][0][n<<1] =(int16_t)(floor(32767*cos(M_PI*ref12[(u*12) + n]/4)));
ul_ref_sigs[u][0][0][1+(n<<1)]=(int16_t)(floor(32767*sin(M_PI*ref12[(u*12) + n]/4)));
}
}
// These are the sequences for RB 2
for (u=0;u<30;u++) {
ul_ref_sigs[u][0][1] = (int16_t*)malloc16(2*sizeof(int16_t)*dftsizes[1]);
for (n=0;n<dftsizes[1];n++) {
ul_ref_sigs[u][0][1][n<<1] =(int16_t)(floor(32767*cos(M_PI*ref24[(u*24) + n]/4)));
ul_ref_sigs[u][0][1][1+(n<<1)]=(int16_t)(floor(32767*sin(M_PI*ref24[(u*24) + n]/4)));
}
}
}
LTE_eNB_DLSCH_t *new_eNB_dlsch(unsigned char Kmimo,unsigned char Mdlharq,u8 abstraction_flag) {
LTE_eNB_DLSCH_t *dlsch;
unsigned char exit_flag = 0,i,j,r;
dlsch = (LTE_eNB_DLSCH_t *)malloc16(sizeof(LTE_eNB_DLSCH_t));
if (dlsch) {
bzero(dlsch,sizeof(LTE_eNB_DLSCH_t));
dlsch->Kmimo = Kmimo;
dlsch->Mdlharq = Mdlharq;
for (i=0;i<10;i++)
dlsch->harq_ids[i] = Mdlharq;
for (i=0;i<Mdlharq;i++) {
dlsch->harq_processes[i] = (LTE_DL_eNB_HARQ_t *)malloc16(sizeof(LTE_DL_eNB_HARQ_t));
//printf("dlsch->harq_processes[%d] %p\n",i,dlsch->harq_processes[i]);
if (dlsch->harq_processes[i]) {
bzero(dlsch->harq_processes[i],sizeof(LTE_DL_eNB_HARQ_t));
dlsch->harq_processes[i]->b = (unsigned char*)malloc16(MAX_DLSCH_PAYLOAD_BYTES);
if (!dlsch->harq_processes[i]->b) {
msg("Can't get b\n");
exit_flag=1;
}
if (abstraction_flag==0) {
for (r=0;r<MAX_NUM_DLSCH_SEGMENTS;r++) {
dlsch->harq_processes[i]->c[r] = (unsigned char*)malloc16(((r==0)?8:0) + 3+(MAX_DLSCH_PAYLOAD_BYTES)); // account for filler in first segment and CRCs for multiple segment case
if (!dlsch->harq_processes[i]->c[r]) {
msg("Can't get c\n");
exit_flag=2;
}
}
}
} else {
msg("Can't get harq_p %d\n",i);
exit_flag=3;
}
}
if ((exit_flag==0)) {
for (i=0;i<Mdlharq;i++) {
dlsch->harq_processes[i]->round=0;
if (abstraction_flag==0) {
for (j=0;j<96;j++)
for (r=0;r<MAX_NUM_DLSCH_SEGMENTS;r++)
dlsch->harq_processes[i]->d[r][j] = LTE_NULL;
}
}
return(dlsch);
}
}
msg("new_eNB_dlsch exit flag %d, size of %d\n",exit_flag, sizeof(LTE_eNB_DLSCH_t));
free_eNB_dlsch(dlsch);
return(NULL);
}
int mac_init_global_param(){
/***********************************************************************/
Is_rrc_registered=0;
Mac_rlc_xface = NULL;
LOG_I(MAC,"[MAIN] CALLING RLC_MODULE_INIT...\n");
if (rlc_module_init()!=0)
return(-1);
LOG_I(MAC,"[MAIN] RLC_MODULE_INIT OK, malloc16 for mac_rlc_xface...\n");
Mac_rlc_xface = (MAC_RLC_XFACE*)malloc16(sizeof(MAC_RLC_XFACE));
bzero(Mac_rlc_xface,sizeof(MAC_RLC_XFACE));
if(Mac_rlc_xface == NULL){
LOG_E(MAC,"[MAIN] FATAL EROOR: Could not allocate memory for Mac_rlc_xface !!!\n");
return (-1);
}
LOG_I(MAC,"[MAIN] malloc16 OK, mac_rlc_xface @ %p\n",(void *)Mac_rlc_xface);
// mac_xface->macphy_data_ind=macphy_data_ind;
mac_xface->mrbch_phy_sync_failure=mrbch_phy_sync_failure;
mac_xface->dl_phy_sync_success=dl_phy_sync_success;
mac_xface->out_of_sync_ind=mac_out_of_sync_ind;
// Mac_rlc_xface->macphy_exit= mac_xface->macphy_exit;
// Mac_rlc_xface->frame = 0;
// Mac_rlc_xface->mac_config_req=mac_config_req;
// Mac_rlc_xface->mac_meas_req=mac_meas_req;
// Mac_rlc_xface->rrc_rlc_config_req=rrc_rlc_config_req;
// Mac_rlc_xface->rrc_rlc_data_req=rrc_rlc_data_req;
// Mac_rlc_xface->rrc_rlc_register_rrc=rrc_rlc_register_rrc;
// Mac_rlc_xface->rrc_mac_config_req=rrc_mac_config_req;
// LOG_I(MAC,"[MAIN] INIT_GLOBAL_PARAM: Mac_rlc_xface=%p,rrc_rlc_register_rrc =%p\n",Mac_rlc_xface,Mac_rlc_xface->rrc_rlc_register_rrc);
// Mac_rlc_xface->mac_rlc_data_req=mac_rlc_data_req;
// Mac_rlc_xface->mac_rlc_data_ind=mac_rlc_data_ind;
// Mac_rlc_xface->mac_rlc_status_ind=mac_rlc_status_ind;
// Mac_rlc_xface->pdcp_data_req=pdcp_data_req;
// Mac_rlc_xface->mrbch_phy_sync_failure=mrbch_phy_sync_failure;
// Mac_rlc_xface->dl_phy_sync_success=dl_phy_sync_success;
LOG_I(MAC,"[MAIN] RLC interface setup and init\n");
rrc_init_global_param();
Is_rrc_registered=1;
#ifdef USER_MODE
pdcp_layer_init ();
#else
pdcp_module_init ();
#endif
LOG_I(MAC,"[MAIN] Init Global Param Done\n");
return 0;
}
BOOL FASTCALL WM32EMReplaceSel (LPWM32MSGPARAMEX lpwm32mpex)
{
if ( lpwm32mpex->fThunk ) {
lpwm32mpex->Parm16.WndProc.wMsg = (WORD) (WM_USER + (lpwm32mpex->uMsg - EM_GETSEL));
if (lpwm32mpex->lParam) {
INT cb;
cb = strlen((LPSZ)lpwm32mpex->lParam)+1;
// winworks2.0a requires DS based string pointers for this message
if (CURRENTPTD()->dwWOWCompatFlags & WOWCF_DSBASEDSTRINGPOINTERS) {
lpwm32mpex->Parm16.WndProc.lParam = stackalloc16(cb);
} else {
lpwm32mpex->Parm16.WndProc.lParam = malloc16(cb);
}
if (!(lpwm32mpex->Parm16.WndProc.lParam))
return FALSE;
putstr16((VPSZ)lpwm32mpex->Parm16.WndProc.lParam, (LPSZ)lpwm32mpex->lParam, cb);
}
} else {
if (lpwm32mpex->Parm16.WndProc.lParam) {
if (CURRENTPTD()->dwWOWCompatFlags & WOWCF_DSBASEDSTRINGPOINTERS) {
stackfree16((VPVOID) lpwm32mpex->Parm16.WndProc.lParam);
} else {
free16((VPVOID) lpwm32mpex->Parm16.WndProc.lParam);
}
}
}
return (TRUE);
}
BOOL FASTCALL WM32EMGetLine (LPWM32MSGPARAMEX lpwm32mpex)
{
if ( lpwm32mpex->fThunk ) {
lpwm32mpex->Parm16.WndProc.wMsg = (WORD) (WM_USER + (lpwm32mpex->uMsg - EM_GETSEL));
if (lpwm32mpex->lParam) {
INT cb;
PBYTE lp;
// the first WORD is what USER uses.
cb = *(UNALIGNED WORD *)(lpwm32mpex->lParam);
lpwm32mpex->Parm16.WndProc.lParam = malloc16(cb);
if (!(lpwm32mpex->Parm16.WndProc.lParam))
return FALSE;
ALLOCVDMPTR(lpwm32mpex->Parm16.WndProc.lParam,2,lp);
*((UNALIGNED WORD *)lp) = cb;
FLUSHVDMPTR(lpwm32mpex->Parm16.WndProc.lParam,2,lp); /* first 2 bytes modified */
}
} else {
if (lpwm32mpex->Parm16.WndProc.lParam) {
PBYTE lp;
GETMISCPTR(lpwm32mpex->Parm16.WndProc.lParam,lp);
RtlCopyMemory((PBYTE)lpwm32mpex->lParam,lp,lpwm32mpex->lReturn);
FREEVDMPTR(lp);
free16((VPVOID) lpwm32mpex->Parm16.WndProc.lParam);
}
}
LOGDEBUG(3,(" Window %08lX is receiving Control Message %s(%08x)\n", lpwm32mpex->hwnd, (LPSZ)GetWMMsgName(lpwm32mpex->uMsg), lpwm32mpex->uMsg));
return (TRUE);
}
BOOL FASTCALL WM32CBAddString (LPWM32MSGPARAMEX lpwm32mpex)
{
PWW pww;
if ( lpwm32mpex->fThunk ) {
if (!(pww = lpwm32mpex->pww)) {
if (pww = FindPWW (lpwm32mpex->hwnd, WOWCLASS_UNKNOWN))
lpwm32mpex->pww = pww;
else
return FALSE;
}
lpwm32mpex->Parm16.WndProc.wMsg = (WORD) (WM_USER + (lpwm32mpex->uMsg - CB_GETEDITSEL));
//
// Determine if this combobox has string pointers or handles passed
// in with CB_ADDSTRING messages. Normal comboboxes have string
// pointers passed. Owner-draw comboboxes that don't have the
// CBS_HASSTRINGS style bit set have handles passed in. These handles
// are simply passed back to the owner at paint time. If the
// CBS_HASSTRINGS style bit is set, strings are used instead of
// handles as the "cookie" which is passed back to the application
// at paint time.
//
// We treat lpwm32mpex->dwParam as a BOOL indicating this combobox
// takes handles instead of strings.
//
lpwm32mpex->dwParam =
(pww->dwStyle & (CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE)) &&
!(pww->dwStyle & CBS_HASSTRINGS);
if ( !lpwm32mpex->dwParam ) { // if strings are used
if (lpwm32mpex->lParam) {
INT cb;
cb = strlen((LPSZ)lpwm32mpex->lParam)+1;
lpwm32mpex->Parm16.WndProc.lParam = malloc16(cb);
if (!(lpwm32mpex->Parm16.WndProc.lParam))
return FALSE;
putstr16((VPSZ)lpwm32mpex->Parm16.WndProc.lParam, (LPSZ)lpwm32mpex->lParam, cb);
}
}
} else {
if ( !lpwm32mpex->dwParam ) { // if strings are used
if (lpwm32mpex->Parm16.WndProc.lParam) {
getstr16((VPSZ)lpwm32mpex->Parm16.WndProc.lParam, (LPSZ)lpwm32mpex->lParam, -1);
free16((VPVOID) lpwm32mpex->Parm16.WndProc.lParam);
}
}
}
LOGDEBUG(3,(" Window %08lX is receiving Control Message %s(%08x)\n", lpwm32mpex->hwnd, (LPSZ)GetWMMsgName(lpwm32mpex->uMsg), lpwm32mpex->uMsg));
return(TRUE);
}
BOOL FASTCALL WM32CBDir (LPWM32MSGPARAMEX lpwm32mpex)
{
if (lpwm32mpex->fThunk) {
lpwm32mpex->Parm16.WndProc.wMsg = (WORD) (WM_USER + (lpwm32mpex->uMsg - CB_GETEDITSEL));
if (lpwm32mpex->lParam) {
INT cb;
if (W32CheckThunkParamFlag()) {
LONG lParam = (LONG)GetParam16(lpwm32mpex->lParam);
if (lParam) {
lpwm32mpex->Parm16.WndProc.lParam = lParam;
return (TRUE);
}
}
cb = strlen((LPSZ)lpwm32mpex->lParam)+1;
lpwm32mpex->Parm16.WndProc.lParam = malloc16(cb);
if (!(lpwm32mpex->Parm16.WndProc.lParam))
return FALSE;
putstr16((VPSZ)lpwm32mpex->Parm16.WndProc.lParam, (LPSZ)lpwm32mpex->lParam, cb);
}
} else {
if (W32CheckThunkParamFlag()) {
if (DeleteParamMap(lpwm32mpex->Parm16.WndProc.lParam, PARAM_16, NULL)) {
return TRUE;
}
}
if (lpwm32mpex->Parm16.WndProc.lParam)
free16((VPVOID) lpwm32mpex->Parm16.WndProc.lParam);
}
return(TRUE);
}
BOOL FASTCALL WM32LBDir (LPWM32MSGPARAMEX lpwm32mpex)
{
INT cb;
VPVOID vp;
if (lpwm32mpex->fThunk) {
lpwm32mpex->Parm16.WndProc.wMsg = (WORD) (WM_USER + (lpwm32mpex->uMsg - LB_ADDSTRING + 1));
if (lpwm32mpex->lParam) {
cb = strlen((LPSTR)lpwm32mpex->lParam)+1;
if (!(vp = malloc16(cb))) {
LOGDEBUG(0,(" WOW32.DLL : WM32LBDir() :: Could not allocate memory for string, ChandanC\n"));
WOW32ASSERT(vp);
return FALSE;
}
putstr16(vp, (LPSTR) lpwm32mpex->lParam, cb);
lpwm32mpex->Parm16.WndProc.lParam = vp;
}
}
else {
if (lpwm32mpex->Parm16.WndProc.lParam) {
free16((VPVOID) lpwm32mpex->Parm16.WndProc.lParam);
}
}
return(TRUE);
}
BOOL FASTCALL WM32LBAddString (LPWM32MSGPARAMEX lpwm32mpex)
{
PWW pww;
if ( lpwm32mpex->fThunk ) {
if (!(pww = lpwm32mpex->pww)) {
if (pww = FindPWW (lpwm32mpex->hwnd, WOWCLASS_UNKNOWN))
lpwm32mpex->pww = pww;
else
return FALSE;
}
lpwm32mpex->Parm16.WndProc.wMsg = (WORD) (WM_USER + (lpwm32mpex->uMsg - LB_ADDSTRING + 1));
//
// Determine if this listbox has string pointers or handles passed
// in with LB_ADDSTRING messages. Owner-draw listboxes that don't
// have the LBS_HASSTRINGS style bit set have handles passed in.
// These handles are simply passed back to the owner at paint time.
// If the LBS_HASSTRINGS style bit is set, strings are used instead of
// handles as the "cookie" which is passed back to the application
// at paint time.
//
// We treat lpwm32mpex->dwParam as a BOOL indicating this listbox
// takes handles instead of strings.
//
lpwm32mpex->dwParam =
(pww->dwStyle & (LBS_OWNERDRAWFIXED | LBS_OWNERDRAWVARIABLE)) &&
!(pww->dwStyle & LBS_HASSTRINGS);
if ( !lpwm32mpex->dwParam ) { // if this listbox takes strings
if (lpwm32mpex->lParam) {
INT cb;
cb = strlen((LPSZ)lpwm32mpex->lParam)+1;
lpwm32mpex->Parm16.WndProc.lParam = malloc16(cb);
if (!(lpwm32mpex->Parm16.WndProc.lParam))
return FALSE;
putstr16((VPSZ)lpwm32mpex->Parm16.WndProc.lParam, (LPSZ)lpwm32mpex->lParam, cb);
}
}
} else {
if ( !lpwm32mpex->dwParam ) { // if this listbox takes strings
if (lpwm32mpex->Parm16.WndProc.lParam) {
getstr16((VPSZ)lpwm32mpex->Parm16.WndProc.lParam, (LPSZ)lpwm32mpex->lParam, -1);
free16((VPVOID) lpwm32mpex->Parm16.WndProc.lParam);
}
}
}
return(TRUE);
}
BOOL FASTCALL WM32EMGetRect (LPWM32MSGPARAMEX lpwm32mpex)
{
if ( lpwm32mpex->fThunk ) {
lpwm32mpex->Parm16.WndProc.wMsg = (WORD) (WM_USER + (lpwm32mpex->uMsg - EM_GETSEL));
lpwm32mpex->Parm16.WndProc.lParam = malloc16(sizeof(RECT16));
if (!(lpwm32mpex->Parm16.WndProc.lParam))
return FALSE;
} else {
GETRECT16( lpwm32mpex->Parm16.WndProc.lParam, (LPRECT)lpwm32mpex->lParam );
if (lpwm32mpex->Parm16.WndProc.lParam)
free16((VPVOID) lpwm32mpex->Parm16.WndProc.lParam);
}
return (TRUE);
}
BOOL FASTCALL WM32LBSetTabStops (LPWM32MSGPARAMEX lpwm32mpex)
{
if ( lpwm32mpex->fThunk ) {
lpwm32mpex->Parm16.WndProc.wMsg = (WORD) (WM_USER + (lpwm32mpex->uMsg - LB_ADDSTRING + 1));
if (lpwm32mpex->uParam != 0) {
lpwm32mpex->Parm16.WndProc.lParam = malloc16(lpwm32mpex->uParam * sizeof(WORD));
if (!(lpwm32mpex->Parm16.WndProc.lParam))
return FALSE;
putintarray16((VPRECT16)lpwm32mpex->Parm16.WndProc.lParam, (INT)lpwm32mpex->uParam, (LPINT)lpwm32mpex->lParam);
}
} else {
if (lpwm32mpex->Parm16.WndProc.lParam)
free16((VPVOID) lpwm32mpex->Parm16.WndProc.lParam);
}
return(TRUE);
}
BOOL FASTCALL WM32LBGetItemRect (LPWM32MSGPARAMEX lpwm32mpex)
{
if ( lpwm32mpex->fThunk ) {
lpwm32mpex->Parm16.WndProc.wMsg = (WORD) (WM_USER + (lpwm32mpex->uMsg - LB_ADDSTRING + 1));
lpwm32mpex->Parm16.WndProc.lParam = malloc16(sizeof(RECT16));
if (!(lpwm32mpex->Parm16.WndProc.lParam))
return FALSE;
} else {
GETRECT16( lpwm32mpex->Parm16.WndProc.lParam, (LPRECT)lpwm32mpex->lParam );
if (lpwm32mpex->Parm16.WndProc.lParam)
free16((VPVOID) lpwm32mpex->Parm16.WndProc.lParam);
}
LOGDEBUG(3,(" Window %08lX is receiving Control Message %s(%08x)\n", lpwm32mpex->hwnd, (LPSZ)GetWMMsgName(lpwm32mpex->uMsg), lpwm32mpex->uMsg));
return(TRUE);
}
BOOL FASTCALL WM32LBGetSelItems (LPWM32MSGPARAMEX lpwm32mpex)
{
if ( lpwm32mpex->fThunk ) {
lpwm32mpex->Parm16.WndProc.wMsg = (WORD) (WM_USER + (lpwm32mpex->uMsg - LB_ADDSTRING + 1));
if (lpwm32mpex->lParam) {
INT cb;
cb = lpwm32mpex->uParam * sizeof(WORD);
lpwm32mpex->Parm16.WndProc.lParam = malloc16(cb);
if (!(lpwm32mpex->Parm16.WndProc.lParam))
return FALSE;
}
} else {
getintarray16((VPRECT16)lpwm32mpex->Parm16.WndProc.lParam, (INT)lpwm32mpex->uParam, (LPINT)lpwm32mpex->lParam);
if (lpwm32mpex->Parm16.WndProc.lParam)
free16((VPVOID) lpwm32mpex->Parm16.WndProc.lParam);
}
return(TRUE);
}
LTE_eNB_DLSCH_t *new_eNB_dlsch(unsigned char Kmimo,unsigned char Mdlharq,unsigned char N_RB_DL, uint8_t abstraction_flag)
{
LTE_eNB_DLSCH_t *dlsch;
unsigned char exit_flag = 0,i,j,r;
unsigned char bw_scaling =1;
switch (N_RB_DL) {
case 6:
bw_scaling =16;
break;
case 25:
bw_scaling =4;
break;
case 50:
bw_scaling =2;
break;
default:
bw_scaling =1;
break;
}
dlsch = (LTE_eNB_DLSCH_t *)malloc16(sizeof(LTE_eNB_DLSCH_t));
if (dlsch) {
bzero(dlsch,sizeof(LTE_eNB_DLSCH_t));
dlsch->Kmimo = Kmimo;
dlsch->Mdlharq = Mdlharq;
for (i=0; i<10; i++)
dlsch->harq_ids[i] = Mdlharq;
for (i=0; i<Mdlharq; i++) {
dlsch->harq_processes[i] = (LTE_DL_eNB_HARQ_t *)malloc16(sizeof(LTE_DL_eNB_HARQ_t));
LOG_T(PHY, "Required mem size %d (bw scaling %d), dlsch->harq_processes[%d] %p\n",
MAX_DLSCH_PAYLOAD_BYTES/bw_scaling,bw_scaling, i,dlsch->harq_processes[i]);
if (dlsch->harq_processes[i]) {
bzero(dlsch->harq_processes[i],sizeof(LTE_DL_eNB_HARQ_t));
// dlsch->harq_processes[i]->first_tx=1;
dlsch->harq_processes[i]->b = (unsigned char*)malloc16(MAX_DLSCH_PAYLOAD_BYTES/bw_scaling);
if (dlsch->harq_processes[i]->b) {
bzero(dlsch->harq_processes[i]->b,MAX_DLSCH_PAYLOAD_BYTES/bw_scaling);
} else {
msg("Can't get b\n");
exit_flag=1;
}
if (abstraction_flag==0) {
for (r=0; r<MAX_NUM_DLSCH_SEGMENTS/bw_scaling; r++) {
// account for filler in first segment and CRCs for multiple segment case
dlsch->harq_processes[i]->c[r] = (uint8_t*)malloc16(((r==0)?8:0) + 3+ 768);
dlsch->harq_processes[i]->d[r] = (uint8_t*)malloc16((96+12+3+(3*6144)));
if (dlsch->harq_processes[i]->c[r]) {
bzero(dlsch->harq_processes[i]->c[r],((r==0)?8:0) + 3+ 768);
} else {
msg("Can't get c\n");
exit_flag=2;
}
if (dlsch->harq_processes[i]->d[r]) {
bzero(dlsch->harq_processes[i]->d[r],(96+12+3+(3*6144)));
} else {
msg("Can't get d\n");
exit_flag=2;
}
}
}
} else {
msg("Can't get harq_p %d\n",i);
exit_flag=3;
}
}
if (exit_flag==0) {
for (i=0; i<Mdlharq; i++) {
dlsch->harq_processes[i]->round=0;
if (abstraction_flag==0) {
for (j=0; j<96; j++)
for (r=0; r<MAX_NUM_DLSCH_SEGMENTS/bw_scaling; r++) {
// printf("dlsch->harq_processes[%d]->d[%d] %p\n",i,r,dlsch->harq_processes[i]->d[r]);
dlsch->harq_processes[i]->d[r][j] = LTE_NULL;
}
}
}
return(dlsch);
}
}
LOG_D(PHY, "new_eNB_dlsch exit flag %d, size of %ld\n",
exit_flag, sizeof(LTE_eNB_DLSCH_t));
free_eNB_dlsch(dlsch);
return(NULL);
}
ULONG WOW32FaxHandler(UINT iFun, LPSTR lpIn)
{
LPWOWFAXINFO lpT = (LPWOWFAXINFO)lpIn;
LPWOWFAXINFO16 lpT16;
HWND hwnd = gfaxinfo.hwnd;
LPBYTE lpData;
VPVOID vp;
#ifdef DEBUG
int DebugStringIndex = iFun - (WM_USER+0x100+1);
if ((DebugStringIndex >= WM_DDRV_FIRST) && (DebugStringIndex <= WM_DDRV_LAST) ) {
LOGDEBUG(0,("WOW32FaxHandler, %s, 0x%lX\n", (LPSTR)szWmDdrvDebugStrings[DebugStringIndex], (LPSTR) lpIn));
}
#endif
switch (iFun) {
case WM_DDRV_SUBCLASS:
//
// Subclass the window - This is so that we get a chance to
// transform the 32bit data to 16bit data and vice versa. A
// NULL HWND, passed in lpIn, indicates don't subclass.
//
if (gfaxinfo.hwnd = (HWND)lpIn) {
gfaxinfo.proc16 = (WNDPROC)SetWindowLong((HWND)lpIn,
GWL_WNDPROC, (DWORD)WowFaxWndProc);
gfaxinfo.tid = GetWindowThreadProcessId((HWND)lpIn, NULL);
}
WOW32ASSERT(sizeof(DEVMODE16) + 4 == sizeof(DEVMODE31));
//
// Read in the SupFaxDrv name list from the registry.
//
SupFaxDrv = GetSupportedFaxDrivers(&uNumSupFaxDrv);
break;
case WM_DDRV_ENABLE:
// Enable the driver:
// . first intialize the 16bit faxinfo datastruct
// . then inform the driver (dll name) to be loaded
//
// format of ddrv_message:
// wParam = hdc (just a unique id)
// lparam = 16bit faxinfo struct with relevant data
// Must call 'callwindowproc' not 'sendmessage' because
// WowFaxWndProc is a subclass of the 16-bit FaxWndProc.
//
WOW32ASSERT(lpT->lpinfo16 == (LPSTR)NULL);
lpT->lpinfo16 = (LPSTR)CallWindowProc( gfaxinfo.proc16,
hwnd, WM_DDRV_INITFAXINFO16, lpT->hdc, (LPARAM)0);
if (lpT->lpinfo16) {
vp = malloc16(lpT->cData);
GETVDMPTR(vp, lpT->cData, lpData);
if (lpData == 0) {
break;
}
GETVDMPTR(lpT->lpinfo16, sizeof(WOWFAXINFO16), lpT16);
if (lpT16) {
if (lstrlenW(lpT->szDeviceName) < sizeof(lpT16->szDeviceName)) {
WideCharToMultiByte(CP_ACP, 0,
lpT->szDeviceName,
lstrlenW(lpT->szDeviceName) + 1,
lpT16->szDeviceName,
sizeof(lpT16->szDeviceName),
NULL, NULL);
lpT16->lpDriverName = lpT->lpDriverName;
if (lpT->lpDriverName) {
lpT16->lpDriverName = (LPBYTE)vp + (DWORD)lpT->lpDriverName;
WideCharToMultiByte(CP_ACP, 0,
(PWSTR)((LPSTR)lpT + (DWORD)lpT->lpDriverName),
lstrlenW((LPWSTR)((LPSTR)lpT + (DWORD)lpT->lpDriverName)) + 1,
lpData + (DWORD)lpT->lpDriverName,
lstrlenW((LPWSTR)((LPSTR)lpT + (DWORD)lpT->lpDriverName)) + 1,
NULL, NULL);
}
lpT16->lpPortName = lpT->lpPortName;
if (lpT->lpPortName) {
lpT16->lpPortName = (LPBYTE)vp + (DWORD)lpT->lpPortName;
WideCharToMultiByte(CP_ACP, 0,
(PWSTR)((LPSTR)lpT + (DWORD)lpT->lpPortName),
lstrlenW((LPWSTR)((LPSTR)lpT + (DWORD)lpT->lpPortName)) + 1,
lpData + (DWORD)lpT->lpPortName,
lstrlenW((LPWSTR)((LPSTR)lpT + (DWORD)lpT->lpPortName)) + 1,
NULL, NULL);
}
lpT16->lpIn = lpT->lpIn;
if (lpT->lpIn) {
lpT16->lpIn = (LPBYTE)vp + (DWORD)lpT->lpIn;
ConvertDevMode((PDEVMODE16)(lpData + (DWORD)lpT->lpIn),
(LPDEVMODEW)((LPSTR)lpT + (DWORD)lpT->lpIn), TRUE);
}
WOW32ASSERT((sizeof(GDIINFO16) + sizeof(POINT16)) <= sizeof(GDIINFO));
lpT16->lpOut = (LPBYTE)vp + (DWORD)lpT->lpOut;
FREEVDMPTR(lpData);
FREEVDMPTR(lpT16);
lpT->retvalue = CallWindowProc( gfaxinfo.proc16,
hwnd, lpT->msg, lpT->hdc, (LPARAM)lpT->lpinfo16);
if (lpT->retvalue) {
GETVDMPTR(vp, lpT->cData, lpData);
ConvertGdiInfo((LPGDIINFO16)(lpData + (DWORD)lpT->lpOut),
(PGDIINFO)((LPSTR)lpT + (DWORD)lpT->lpOut), FALSE);
}
}
}
free16(vp);
}
break;
case WM_DDRV_ESCAPE:
GETVDMPTR(lpT->lpinfo16, sizeof(WOWFAXINFO16), lpT16);
if (lpT16) {
lpT16->wCmd = lpT->wCmd;
}
FREEVDMPTR(lpT16);
lpT->retvalue = CallWindowProc( gfaxinfo.proc16,
hwnd, lpT->msg, lpT->hdc, (LPARAM)lpT->lpinfo16);
break;
case WM_DDRV_PRINTPAGE:
//
// set the global variable. When the 16bit driver calls DMBitBlt we
// get the bitmap info from here. Since WOW is single threaded we
// won't receive another printpage msg before we return from here.
//
// All pointers in the faxinfo structure are actually
// 'offsets from the start of the mapfile' to relevant data.
//
glpfaxinfoCur = lpT;
lpT->lpbits = (LPBYTE)lpT + (DWORD)lpT->lpbits;
// fall through;
case WM_DDRV_STARTDOC:
case WM_DDRV_ENDDOC:
lpT->retvalue = CallWindowProc( gfaxinfo.proc16,
hwnd, lpT->msg, lpT->hdc, (LPARAM)lpT->lpinfo16);
break;
case WM_DDRV_DISABLE:
CallWindowProc( gfaxinfo.proc16,
hwnd, lpT->msg, lpT->hdc, (LPARAM)lpT->lpinfo16);
lpT->retvalue = TRUE;
break;
case WM_DDRV_EXTDMODE:
case WM_DDRV_DEVCAPS:
WOW32ASSERT(lpT->lpinfo16 == (LPSTR)NULL);
lpT->lpinfo16 = (LPSTR)CallWindowProc( gfaxinfo.proc16,
hwnd, WM_DDRV_INITFAXINFO16, lpT->hdc, (LPARAM)0);
if (lpT->lpinfo16) {
vp = malloc16(lpT->cData);
GETVDMPTR(vp, lpT->cData, lpData);
if (lpData == 0) {
break;
}
GETVDMPTR(lpT->lpinfo16, sizeof(WOWFAXINFO16), lpT16);
if (lpT16) {
if (lstrlenW(lpT->szDeviceName) < sizeof(lpT16->szDeviceName)) {
WideCharToMultiByte(CP_ACP, 0,
lpT->szDeviceName,
lstrlenW(lpT->szDeviceName) + 1,
lpT16->szDeviceName,
sizeof(lpT16->szDeviceName),
NULL, NULL);
lpT16->lpDriverName = lpT->lpDriverName;
if (lpT->lpDriverName) {
lpT16->lpDriverName = (LPBYTE)vp + (DWORD)lpT->lpDriverName;
WideCharToMultiByte(CP_ACP, 0,
(PWSTR)((LPSTR)lpT + (DWORD)lpT->lpDriverName),
lstrlenW((LPWSTR)((LPSTR)lpT + (DWORD)lpT->lpDriverName)) + 1,
lpData + (DWORD)lpT->lpDriverName,
lstrlenW((LPWSTR)((LPSTR)lpT + (DWORD)lpT->lpDriverName)) + 1,
NULL, NULL);
}
FREEVDMPTR(lpData);
FREEVDMPTR(lpT16);
lpT->retvalue = CallWindowProc( gfaxinfo.proc16,
hwnd, WM_DDRV_LOAD, lpT->hdc, (LPARAM)lpT->lpinfo16);
if (lpT->retvalue) {
lpT->retvalue = (iFun == WM_DDRV_DEVCAPS) ? DeviceCapsHandler(lpT) :
ExtDevModeHandler(lpT) ;
}
CallWindowProc( gfaxinfo.proc16,
hwnd, WM_DDRV_UNLOAD, lpT->hdc, (LPARAM)lpT->lpinfo16);
}
}
free16(vp);
}
break;
}
return TRUE;
}
BOOL FASTCALL WM32LBGetText (LPWM32MSGPARAMEX lpwm32mpex)
{
PWW pww;
if ( lpwm32mpex->fThunk ) {
INT cb;
if (!(pww = lpwm32mpex->pww)) {
if (pww = FindPWW (lpwm32mpex->hwnd, WOWCLASS_UNKNOWN))
lpwm32mpex->pww = pww;
else
return FALSE;
}
lpwm32mpex->Parm16.WndProc.wMsg = (WORD) (WM_USER + (lpwm32mpex->uMsg - LB_ADDSTRING + 1));
//
// Determine if this listbox has string pointers or handles passed
// in with LB_ADDSTRING messages. Owner-draw listboxes that don't
// have the LBS_HASSTRINGS style bit set have handles passed in.
// These handles are simply passed back to the owner at paint time.
// If the LBS_HASSTRINGS style bit is set, strings are used instead of
// handles as the "cookie" which is passed back to the application
// at paint time.
//
// We treat lpwm32mpex->dwParam as a BOOL indicating this listbox
// takes handles instead of strings.
//
lpwm32mpex->dwParam =
(pww->dwStyle & (LBS_OWNERDRAWFIXED | LBS_OWNERDRAWVARIABLE)) &&
!(pww->dwStyle & LBS_HASSTRINGS);
if (lpwm32mpex->dwParam) { // if this listbox takes handles
cb = 4;
}
else {
cb = SendMessage(lpwm32mpex->hwnd, LB_GETTEXTLEN, lpwm32mpex->uParam, 0);
// Check for LB_ERR (which is -1) on the above SendMessage().
// When cb is equal to LB_ERR make the size as SIZE_BOGUS (256 bytes),
// and allocate a buffer just in case if the app diddles the lParam.
// We will free the buffer while unthunking the message (LB_GETTEXT).
// This fix makes the app MCAD happy.
// ChandanC 4-21-93.
if (cb == LB_ERR) {
cb = SIZE_BOGUS;
}
else {
//
// Add one for NULL character.
//
cb = cb + 1;
}
}
if (lpwm32mpex->lParam) {
BYTE *lpT;
lpwm32mpex->Parm16.WndProc.lParam = malloc16(cb);
if (!(lpwm32mpex->Parm16.WndProc.lParam))
return FALSE;
// The reason for this code to be here is that sometimes thunks
// are executed on a buffer that has not been initialized, e.g.
// if the hooks are installed by a wow app. That means we will
// alloc 16-bit buffer while thunking (boils down to uninitialized
// data buffer and will try to copy the buffer back while unthunking
// overwriting the stack sometimes (as user allocates temp bufs from
// the stack). This code initializes data so problem is avoided
// App: Grammatik/Windows v6.0 -- VadimB
GETVDMPTR((lpwm32mpex->Parm16.WndProc.lParam), sizeof(BYTE), lpT);
*lpT = 0;
FREEVDMPTR(lpT);
}
}
else {
if ((lpwm32mpex->lReturn != LB_ERR) && lpwm32mpex->lParam && lpwm32mpex->Parm16.WndProc.lParam) {
if (lpwm32mpex->dwParam) { // if this listbox takes handles
UNALIGNED DWORD *lpT;
GETVDMPTR((lpwm32mpex->Parm16.WndProc.lParam), sizeof(DWORD), lpT);
*(UNALIGNED DWORD *)lpwm32mpex->lParam = *lpT;
FREEVDMPTR(lpT);
}
else {
getstr16((VPSZ)lpwm32mpex->Parm16.WndProc.lParam, (LPSZ)lpwm32mpex->lParam, -1);
}
}
if (lpwm32mpex->Parm16.WndProc.lParam) {
free16((VPVOID) lpwm32mpex->Parm16.WndProc.lParam);
}
}
return(TRUE);
}
BOOL FASTCALL WM32CBGetLBText (LPWM32MSGPARAMEX lpwm32mpex)
{
PWW pww;
if ( lpwm32mpex->fThunk ) {
INT cb;
if (!(pww = lpwm32mpex->pww)) {
if (pww = FindPWW (lpwm32mpex->hwnd, WOWCLASS_UNKNOWN))
lpwm32mpex->pww = pww;
else
return FALSE;
}
lpwm32mpex->Parm16.WndProc.wMsg = (WORD) (WM_USER + (lpwm32mpex->uMsg - CB_GETEDITSEL));
//
// Determine if this combobox has string pointers or handles passed
// in with CB_ADDSTRING messages. Normal comboboxes have string
// pointers passed. Owner-draw comboboxes that don't have the
// CBS_HASSTRINGS style bit set have handles passed in. These handles
// are simply passed back to the owner at paint time. If the
// CBS_HASSTRINGS style bit is set, strings are used instead of
// handles as the "cookie" which is passed back to the application
// at paint time.
//
// We treat lpwm32mpex->dwParam as a BOOL indicating this combobox
// takes handles instead of strings.
//
lpwm32mpex->dwParam =
(pww->dwStyle & (CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE)) &&
!(pww->dwStyle & CBS_HASSTRINGS);
//
// Determine the size of the buffer to allocate on the 16-bit side
// to receive the text.
//
if (lpwm32mpex->dwParam) { // if handles are used
cb = 4;
} else {
cb = SendMessage(lpwm32mpex->hwnd, CB_GETLBTEXTLEN, lpwm32mpex->uParam, 0);
if (cb == CB_ERR) {
//
// lpwm32mpex->dwTmp[0] is initialized to 0 so that nothing
// gets copied to the buffer by getstr16() while unthunking
// this message.
//
// bug # 24415, ChandanC
//
cb = SIZE_BOGUS;
lpwm32mpex->dwTmp[0] = 0;
}
else {
//
// Add one for NULL character.
//
cb = cb + 1;
(INT) lpwm32mpex->dwTmp[0] = (INT) -1;
}
}
if (lpwm32mpex->lParam) {
BYTE *lpT;
// See comment on similar code below
lpwm32mpex->Parm16.WndProc.lParam = malloc16(cb);
if (!(lpwm32mpex->Parm16.WndProc.lParam))
return FALSE;
GETVDMPTR((lpwm32mpex->Parm16.WndProc.lParam), sizeof(BYTE), lpT);
*lpT = 0;
FREEVDMPTR(lpT);
}
}
else {
if (lpwm32mpex->lParam && lpwm32mpex->Parm16.WndProc.lParam) {
if (lpwm32mpex->dwParam) { // if handles are used
UNALIGNED DWORD *lpT;
GETVDMPTR((lpwm32mpex->Parm16.WndProc.lParam), sizeof(DWORD), lpT);
*(UNALIGNED DWORD *)lpwm32mpex->lParam = *lpT;
FREEVDMPTR(lpT);
}
else {
getstr16((VPSZ)lpwm32mpex->Parm16.WndProc.lParam, (LPSZ)lpwm32mpex->lParam,
(INT) lpwm32mpex->dwTmp[0]);
}
free16((VPVOID) lpwm32mpex->Parm16.WndProc.lParam);
}
}
return(TRUE);
}
DWORD DeviceCapsHandler(LPWOWFAXINFO lpfaxinfo)
{
LPWOWFAXINFO16 lpWFI16;
LPSTR lpSrc;
LPBYTE lpDest;
INT i;
DWORD cbData16; // Size of data items.
UINT cbUni;
LOGDEBUG(0,("DeviceCapsHandler, lpfaxinfo: %X, wCmd: %X\n", lpfaxinfo, lpfaxinfo->wCmd));
GETVDMPTR(lpfaxinfo->lpinfo16, sizeof(WOWFAXINFO16), lpWFI16);
// Get the number of data items with a call to the 16-bit printer driver.
lpWFI16->lpDriverName = 0;
lpWFI16->lpPortName = 0;
lpWFI16->wCmd = lpfaxinfo->wCmd;
lpWFI16->cData = 0;
lpWFI16->lpOut = 0;
lpfaxinfo->cData = 0;
lpfaxinfo->retvalue = CallWindowProc(gfaxinfo.proc16, gfaxinfo.hwnd,
lpfaxinfo->msg, lpfaxinfo->hdc,
(LPARAM)lpfaxinfo->lpinfo16);
cbData16 = gDC_ListItemSize[lpfaxinfo->wCmd];
if (lpfaxinfo->lpOut && cbData16 && lpfaxinfo->retvalue) {
// We need to allocate and copy for this query
lpWFI16->cData = cbData16 * lpfaxinfo->retvalue;
// assert the size of output buffer - and set it the actual data size
switch (lpfaxinfo->wCmd) {
case DC_BINNAMES:
case DC_PAPERNAMES:
// These fields need extra room for ANSI to UNICODE conversion.
WOW32ASSERT((lpfaxinfo->cData - (DWORD)lpfaxinfo->lpOut) >= lpWFI16->cData * sizeof(WCHAR));
lpfaxinfo->cData = lpWFI16->cData * sizeof(WCHAR);
break;
default:
WOW32ASSERT((lpfaxinfo->cData - (DWORD)lpfaxinfo->lpOut) >= lpWFI16->cData);
lpfaxinfo->cData = lpWFI16->cData;
break;
}
if ((lpWFI16->lpOut = (LPSTR)malloc16(lpWFI16->cData)) == NULL) {
lpfaxinfo->retvalue = 0;
goto LeaveDeviceCapsHandler;
}
// Get the list data with a call to the 16-bit printer driver.
lpfaxinfo->retvalue = CallWindowProc(gfaxinfo.proc16, gfaxinfo.hwnd,
lpfaxinfo->msg, lpfaxinfo->hdc,
(LPARAM)lpfaxinfo->lpinfo16);
GETVDMPTR(lpWFI16->lpOut, 0, lpSrc);
lpDest = (LPBYTE)lpfaxinfo + (DWORD)lpfaxinfo->lpOut;
switch (lpfaxinfo->wCmd) {
case DC_BINNAMES:
case DC_PAPERNAMES:
for (i = 0; i < (INT)lpfaxinfo->retvalue; i++) {
RtlMultiByteToUnicodeN((LPWSTR)lpDest,
cbData16 * sizeof(WCHAR),
(PULONG)&cbUni,
(LPBYTE)lpSrc, cbData16);
lpDest += cbData16 * sizeof(WCHAR);
lpSrc += cbData16;
}
break;
default:
RtlCopyMemory(lpDest, lpSrc, lpWFI16->cData);
break;
}
free16((VPVOID)lpWFI16->lpOut);
FREEVDMPTR(lpSrc);
}
LeaveDeviceCapsHandler:
FREEVDMPTR(lpWFI16);
return lpfaxinfo->retvalue;
}
DWORD ExtDevModeHandler(LPWOWFAXINFO lpfaxinfo)
{
LPWOWFAXINFO16 lpT16;
LPSTR lpT;
VPVOID vp;
LOGDEBUG(0,("ExtDevModeHandler\n"));
(LONG)lpfaxinfo->retvalue = -1;
GETVDMPTR(lpfaxinfo->lpinfo16, sizeof(WOWFAXINFO16), lpT16);
if (lpT16) {
// assumption that 16bit data won't be larger than 32bit data.
// this makes life easy in two ways; first we don't need to calculate
// the exact size and secondly the 16bit pointers can be set to same
// relative offsets as input(32 bit) pointers
vp = malloc16(lpfaxinfo->cData);
if (vp) {
GETVDMPTR(vp, lpfaxinfo->cData, lpT);
if (lpT) {
lpT16->wCmd = lpfaxinfo->wCmd;
lpT16->lpOut = (LPSTR)lpfaxinfo->lpOut;
lpT16->lpIn = (LPSTR)lpfaxinfo->lpIn;
lpT16->lpDriverName = (LPBYTE)vp + (DWORD)lpfaxinfo->lpDriverName;
lpT16->lpPortName = (LPBYTE)vp + (DWORD)lpfaxinfo->lpPortName;
WideCharToMultiByte(CP_ACP, 0,
(PWSTR)((LPSTR)lpfaxinfo + (DWORD)lpfaxinfo->lpDriverName),
lstrlenW((LPWSTR)((LPSTR)lpfaxinfo + (DWORD)lpfaxinfo->lpDriverName)) + 1,
lpT + (DWORD)lpfaxinfo->lpDriverName,
lstrlenW((LPWSTR)((LPSTR)lpfaxinfo + (DWORD)lpfaxinfo->lpDriverName)) + 1,
NULL, NULL);
WideCharToMultiByte(CP_ACP, 0,
(PWSTR)((LPSTR)lpfaxinfo + (DWORD)lpfaxinfo->lpPortName),
lstrlenW((LPWSTR)((LPSTR)lpfaxinfo + (DWORD)lpfaxinfo->lpPortName)) + 1,
lpT + (DWORD)lpfaxinfo->lpPortName,
lstrlenW((LPWSTR)((LPSTR)lpfaxinfo + (DWORD)lpfaxinfo->lpPortName)) + 1,
NULL, NULL);
if (lpfaxinfo->lpIn) {
lpT16->lpIn = (LPBYTE)vp + (DWORD)lpfaxinfo->lpIn;
ConvertDevMode((PDEVMODE16)(lpT + (DWORD)lpfaxinfo->lpIn),
(LPDEVMODEW)((LPSTR)lpfaxinfo + (DWORD)lpfaxinfo->lpIn), TRUE);
}
if (lpfaxinfo->lpOut) {
lpT16->lpOut = (LPBYTE)vp + (DWORD)lpfaxinfo->lpOut;
}
lpT16->hwndui = GETHWND16(lpfaxinfo->hwndui);
FREEVDMPTR(lpT);
lpfaxinfo->retvalue = CallWindowProc( gfaxinfo.proc16, gfaxinfo.hwnd,
lpfaxinfo->msg, lpfaxinfo->hdc, (LPARAM)lpfaxinfo->lpinfo16);
if ((lpfaxinfo->wCmd == 0) && (lpfaxinfo->retvalue > 0)) {
// the 16bit driver has returned 16bit struct size. change
// the return value to correspond to the devmodew struct.
//
// since devmode16 (the 3.0 version) is smaller than devmode31
// the retvalue will take careof both win30/win31 devmode
WOW32ASSERT(sizeof(DEVMODE16) < sizeof(DEVMODE31));
lpfaxinfo->retvalue += (sizeof(DEVMODEW) - sizeof(DEVMODE16));
}
GETVDMPTR(vp, lpfaxinfo->cData, lpT);
if ((lpfaxinfo->wCmd & DM_COPY) &&
lpfaxinfo->lpOut && (lpfaxinfo->retvalue == IDOK)) {
ConvertDevMode((PDEVMODE16)(lpT + (DWORD)lpfaxinfo->lpOut),
(LPDEVMODEW)((LPSTR)lpfaxinfo + (DWORD)lpfaxinfo->lpOut), FALSE);
}
}
free16(vp);
}
}
FREEVDMPTR(lpT16);
return lpfaxinfo->retvalue;
}
int main(int argc, char **argv) {
char c;
int i,aa,s,ind,Kr,Kr_bytes;;
double sigma2, sigma2_dB=10,SNR,snr0=-2.0,snr1,SNRmeas;
//int **txdataF, **txdata;
int **txdata;
#ifdef IFFT_FPGA
int **txdataF2;
#endif
//LTE_DL_FRAME_PARMS *frame_parms = (LTE_DL_FRAME_PARMS *)malloc(sizeof(LTE_DL_FRAME_PARMS));
//LTE_UE_COMMON *lte_ue_common_vars = (LTE_UE_COMMON *)malloc(sizeof(LTE_UE_COMMON));
double **s_re,**s_im,**r_re,**r_im;
double amps[8] = {0.3868472 , 0.3094778 , 0.1547389 , 0.0773694 , 0.0386847 , 0.0193424 , 0.0096712 , 0.0038685};
double aoa=.03,ricean_factor=1; //0.0000005;
int channel_length;
struct complex **ch;
int eNb_id = 0, eNb_id_i = 1;
unsigned char mcs,dual_stream_UE = 0;
unsigned short NB_RB=conv_nprb(0,DLSCH_RB_ALLOC);
unsigned char Ns,l,m;
unsigned char *input_data,*decoded_output;
unsigned char *input_buffer;
unsigned short input_buffer_length;
unsigned int ret;
unsigned int coded_bits_per_codeword,nsymb,dci_cnt;
unsigned int tx_lev,tx_lev_dB,trials,errs=0,dci_errors=0,dlsch_active=0,num_layers;
int re_allocated;
FILE *bler_fd;
FILE *csv_fd;
char bler_fname[20];
char csv_fname[20];
unsigned char pbch_pdu[6];
DCI_ALLOC_t dci_alloc[8],dci_alloc_rx[8];
FILE *rx_frame_file;
int result;
int n_frames;
int cnt=0;
int rx_lev_data_sym;
int rx_lev_null_sym;
int rx_snr_dB;
void *data;
int ii;
int bler;
double blerr;
int ch_realization;
channel_length = (int) 11+2*BW*Td;
lte_param_init(1,1,1);
num_layers = 1;
//int cont=0;
// default parameters
//for (cont =0;cont<29;cont++){
mcs = 0;
n_frames = 1000;
snr0 = 2;
//if(snr0>0)
// snr0 = 0;
while ((c = getopt (argc, argv, "hm:n:s:")) != -1)
{
switch (c)
{
case 'h':
printf("%s -h(elp) -m mcs -n n_frames -s snr0\n",argv[0]);
exit(1);
case 'm':
mcs = atoi(optarg);
break;
case 'n':
n_frames = atoi(optarg);
break;
case 's':
snr0 = atoi(optarg);
break;
default:
printf("%s -h(elp) -m mcs -n n_frames -s snr0\n",argv[0]);
exit (-1);
break;
}
}
printf("Setting mcs = %d\n",mcs);
printf("NPRB = %d\n",NB_RB);
printf("n_frames = %d\n",n_frames);
/*
snr0 = -7 + mcs;
if(snr0>0)
snr0 = ;
*/
snr1 = snr0+20;
printf("SNR0 %f, SNR1 %f\n",snr0,snr1);
/*
txdataF = (int **)malloc16(2*sizeof(int*));
txdataF[0] = (int *)malloc16(FRAME_LENGTH_BYTES);
txdataF[1] = (int *)malloc16(FRAME_LENGTH_BYTES);
txdata = (int **)malloc16(2*sizeof(int*));
txdata[0] = (int *)malloc16(FRAME_LENGTH_BYTES);
txdata[1] = (int *)malloc16(FRAME_LENGTH_BYTES);
*/
#ifdef IFFT_FPGA
txdata = (int **)malloc16(2*sizeof(int*));
txdata[0] = (int *)malloc16(FRAME_LENGTH_BYTES);
txdata[1] = (int *)malloc16(FRAME_LENGTH_BYTES);
bzero(txdata[0],FRAME_LENGTH_BYTES);
bzero(txdata[1],FRAME_LENGTH_BYTES);
txdataF2 = (int **)malloc16(2*sizeof(int*));
txdataF2[0] = (int *)malloc16(FRAME_LENGTH_BYTES_NO_PREFIX);
txdataF2[1] = (int *)malloc16(FRAME_LENGTH_BYTES_NO_PREFIX);
bzero(txdataF2[0],FRAME_LENGTH_BYTES_NO_PREFIX);
bzero(txdataF2[1],FRAME_LENGTH_BYTES_NO_PREFIX);
#else
txdata = PHY_vars_eNb->lte_eNB_common_vars.txdata[eNb_id];
#endif
s_re = malloc(2*sizeof(double*));
s_im = malloc(2*sizeof(double*));
r_re = malloc(2*sizeof(double*));
r_im = malloc(2*sizeof(double*));
nsymb = (lte_frame_parms->Ncp == 0) ? 14 : 12;
coded_bits_per_codeword = NB_RB * (12 * get_Qm(mcs)) * (lte_frame_parms->num_dlsch_symbols);
printf("Rate = %f (mod %d)\n",(((double)dlsch_tbs25[get_I_TBS(mcs)][NB_RB-1])*3/4)/coded_bits_per_codeword,
get_Qm(mcs));
sprintf(bler_fname,"bler_%d.m",mcs);
bler_fd = fopen(bler_fname,"w");
fprintf(bler_fd,"bler = [");
// CSV file
sprintf(csv_fname,"data_out%d.m",mcs);
csv_fd = fopen(csv_fname,"w");
fprintf(csv_fd,"data_all=[");
for (i=0;i<2;i++) {
s_re[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
s_im[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
r_re[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
r_im[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
}
PHY_vars_UE->lte_ue_pdcch_vars[0]->crnti = 0x1234;
// Fill in UL_alloc
UL_alloc_pdu.type = 0;
UL_alloc_pdu.hopping = 0;
UL_alloc_pdu.rballoc = UL_RB_ALLOC;
UL_alloc_pdu.mcs = 1;
UL_alloc_pdu.ndi = 1;
UL_alloc_pdu.TPC = 0;
UL_alloc_pdu.cqi_req = 1;
CCCH_alloc_pdu.type = 0;
CCCH_alloc_pdu.vrb_type = 0;
CCCH_alloc_pdu.rballoc = CCCH_RB_ALLOC;
CCCH_alloc_pdu.ndi = 1;
CCCH_alloc_pdu.mcs = 1;
CCCH_alloc_pdu.harq_pid = 0;
DLSCH_alloc_pdu2.rah = 0;
DLSCH_alloc_pdu2.rballoc = DLSCH_RB_ALLOC;
DLSCH_alloc_pdu2.TPC = 0;
DLSCH_alloc_pdu2.dai = 0;
DLSCH_alloc_pdu2.harq_pid = 0;
DLSCH_alloc_pdu2.tb_swap = 0;
DLSCH_alloc_pdu2.mcs1 = mcs;
DLSCH_alloc_pdu2.ndi1 = 1;
DLSCH_alloc_pdu2.rv1 = 0;
// Forget second codeword
DLSCH_alloc_pdu2.tpmi = 5 ; // precoding
// Create transport channel structures for SI pdus
PHY_vars_eNb->dlsch_eNb_cntl = new_eNb_dlsch(1,1);
PHY_vars_UE->dlsch_ue_cntl = new_ue_dlsch(1,1);
// Create transport channel structures for 2 transport blocks (MIMO)
PHY_vars_eNb->dlsch_eNb = (LTE_eNb_DLSCH_t**) malloc16(2*sizeof(LTE_eNb_DLSCH_t*));
PHY_vars_UE->dlsch_ue = (LTE_UE_DLSCH_t**) malloc16(2*sizeof(LTE_UE_DLSCH_t*));
for (i=0;i<2;i++) {
PHY_vars_eNb->dlsch_eNb[i] = new_eNb_dlsch(1,8);
PHY_vars_UE->dlsch_ue[i] = new_ue_dlsch(1,8);
if (!PHY_vars_eNb->dlsch_eNb[i]) {
printf("Can't get eNb dlsch structures\n");
exit(-1);
}
if (!PHY_vars_UE->dlsch_ue[i]) {
printf("Can't get ue dlsch structures\n");
exit(-1);
}
}
if (DLSCH_alloc_pdu2.tpmi == 5) {
PHY_vars_eNb->dlsch_eNb[0]->pmi_alloc = (unsigned short)(taus()&0xffff);
PHY_vars_UE->dlsch_ue[0]->pmi_alloc = PHY_vars_eNb->dlsch_eNb[0]->pmi_alloc;
PHY_vars_eNb->eNB_UE_stats[0].DL_pmi_single[0] = PHY_vars_eNb->dlsch_eNb[0]->pmi_alloc;
}
generate_eNb_dlsch_params_from_dci(0,
&DLSCH_alloc_pdu2,
0x1234,
format2_2A_M10PRB,
PHY_vars_eNb->dlsch_eNb,
lte_frame_parms,
SI_RNTI,
RA_RNTI,
P_RNTI,
0); //change this later
/*
generate_eNb_dlsch_params_from_dci(0,
&CCCH_alloc_pdu,
SI_RNTI,
format1A,
&dlsch_eNb_cntl,
lte_frame_parms,
SI_RNTI,
RA_RNTI,
P_RNTI);
*/
// input_data = (unsigned char*) malloc(block_length/8);
// decoded_output = (unsigned char*) malloc(block_length/8);
// DCI
memcpy(&dci_alloc[0].dci_pdu[0],&DLSCH_alloc_pdu2,sizeof(DCI2_5MHz_2A_M10PRB_TDD_t));
dci_alloc[0].dci_length = sizeof_DCI2_5MHz_2A_M10PRB_TDD_t;
dci_alloc[0].L = 3;
dci_alloc[0].rnti = 0x1234;
/*
memcpy(&dci_alloc[0].dci_pdu[0],&CCCH_alloc_pdu,sizeof(DCI1A_5MHz_TDD_1_6_t));
dci_alloc[0].dci_length = sizeof_DCI1A_5MHz_TDD_1_6_t;
dci_alloc[0].L = 3;
dci_alloc[0].rnti = SI_RNTI;
*/
memcpy(&dci_alloc[1].dci_pdu[0],&UL_alloc_pdu,sizeof(DCI0_5MHz_TDD0_t));
dci_alloc[1].dci_length = sizeof_DCI0_5MHz_TDD_0_t;
dci_alloc[1].L = 3;
dci_alloc[1].rnti = 0x1234;
// DLSCH
if (1) {
input_buffer_length = PHY_vars_eNb->dlsch_eNb[0]->harq_processes[0]->TBS/8;
printf("dlsch0: TBS %d\n",PHY_vars_eNb->dlsch_eNb[0]->harq_processes[0]->TBS);
printf("Input buffer size %d bytes\n",input_buffer_length);
input_buffer = (unsigned char *)malloc(input_buffer_length+4);
for (i=0;i<input_buffer_length;i++)
input_buffer[i]= (unsigned char)(taus()&0xff);
dlsch_encoding(input_buffer,
lte_frame_parms,
PHY_vars_eNb->dlsch_eNb[0]);
#ifdef OUTPUT_DEBUG
for (s=0;s<PHY_vars_eNb->dlsch_eNb[0]->harq_processes[0]->C;s++) {
if (s<PHY_vars_eNb->dlsch_eNb[0]->harq_processes[0]->Cminus)
Kr = PHY_vars_eNb->dlsch_eNb[0]->harq_processes[0]->Kminus;
else
Kr = PHY_vars_eNb->dlsch_eNb[0]->harq_processes[0]->Kplus;
Kr_bytes = Kr>>3;
for (i=0;i<Kr_bytes;i++)
printf("%d : (%x)\n",i,PHY_vars_eNb->dlsch_eNb[0]->harq_processes[0]->c[s][i]);
}
#endif
re_allocated = dlsch_modulation(PHY_vars_eNb->lte_eNB_common_vars.txdataF[eNb_id],
1024,
0,
&PHY_vars_eNb->lte_frame_parms,
PHY_vars_eNb->dlsch_eNb[0]);
printf("RB count %d (%d,%d)\n",re_allocated,re_allocated/lte_frame_parms->num_dlsch_symbols/12,lte_frame_parms->num_dlsch_symbols);
if (num_layers>1)
re_allocated = dlsch_modulation(PHY_vars_eNb->lte_eNB_common_vars.txdataF[eNb_id],
1024,
0,
&PHY_vars_eNb->lte_frame_parms,
PHY_vars_eNb->dlsch_eNb[1]);
}
int mac_top_init(){
/***********************************************************************/
unsigned char Mod_id,i,j;
RA_TEMPLATE *RA_template;
UE_TEMPLATE *UE_template;
LOG_I(MAC,"[MAIN] Init function start:Nb_UE_INST=%d\n",NB_UE_INST);
if (NB_UE_INST>0) {
UE_mac_inst = (UE_MAC_INST*)malloc16(NB_UE_INST*sizeof(UE_MAC_INST));
LOG_D(MAC,"[MAIN] ALLOCATE %d Bytes for %d UE_MAC_INST @ %p\n",NB_UE_INST*sizeof(UE_MAC_INST),NB_UE_INST,UE_mac_inst);
bzero(UE_mac_inst,NB_UE_INST*sizeof(UE_MAC_INST));
ue_init_mac();
}
else
UE_mac_inst = NULL;
LOG_I(MAC,"[MAIN] Init function start:Nb_eNB_INST=%d\n",NB_eNB_INST);
if (NB_eNB_INST>0) {
eNB_mac_inst = (eNB_MAC_INST*)malloc16(NB_eNB_INST*sizeof(eNB_MAC_INST));
LOG_D(MAC,"[MAIN] ALLOCATE %d Bytes for %d eNB_MAC_INST @ %p\n",NB_eNB_INST*sizeof(eNB_MAC_INST),NB_eNB_INST,eNB_mac_inst);
bzero(eNB_mac_inst,NB_eNB_INST*sizeof(eNB_MAC_INST));
}
else
eNB_mac_inst = NULL;
for(Mod_id=0;Mod_id<NB_eNB_INST;Mod_id++){
#ifdef PHY_EMUL
Mac_rlc_xface->Is_cluster_head[Mod_id]=2;//0: MR, 1: CH, 2: not CH neither MR
#endif
// Mac_rlc_xface->Node_id[Mod_id]=NODE_ID[Mod_id];
}
// Mac_rlc_xface->frame=Mac_rlc_xface->frame;
if (Is_rrc_registered == 1){
LOG_I(MAC,"[MAIN] calling RRC\n");
#ifndef CELLULAR //nothing to be done yet for cellular
openair_rrc_top_init();
#endif
}
else {
LOG_I(MAC,"[MAIN] Running without an RRC\n");
}
#ifndef USER_MODE
#ifndef PHY_EMUL
LOG_I(MAC,"[MAIN] add openair2 proc\n");
//// add_openair2_stats();
#endif
#endif
init_transport_channels(2);
// Set up DCIs for TDD 5MHz Config 1..6
for (i=0;i<NB_eNB_INST;i++) {
LOG_D(MAC,"[MAIN][eNB %d] initializing RA_template\n",i);
LOG_D(MAC, "[MSC_NEW][FRAME 00000][MAC_eNB][MOD %02d][]\n", i);
RA_template = (RA_TEMPLATE *)&eNB_mac_inst[i].RA_template[0];
for (j=0;j<NB_RA_PROC_MAX;j++) {
memcpy((void *)&RA_template[j].RA_alloc_pdu1[0],(void *)&RA_alloc_pdu,sizeof(DCI1A_5MHz_TDD_1_6_t));
memcpy((void *)&RA_template[j].RA_alloc_pdu2[0],(void *)&DLSCH_alloc_pdu1A,sizeof(DCI1A_5MHz_TDD_1_6_t));
RA_template[j].RA_dci_size_bytes1 = sizeof(DCI1A_5MHz_TDD_1_6_t);
RA_template[j].RA_dci_size_bytes2 = sizeof(DCI1A_5MHz_TDD_1_6_t);
RA_template[j].RA_dci_size_bits1 = sizeof_DCI1A_5MHz_TDD_1_6_t;
RA_template[j].RA_dci_size_bits2 = sizeof_DCI1A_5MHz_TDD_1_6_t;
RA_template[j].RA_dci_fmt1 = format1A;
RA_template[j].RA_dci_fmt2 = format1A;
}
UE_template = (UE_TEMPLATE *)&eNB_mac_inst[i].UE_template[0];
for (j=0;j<NB_CNX_eNB;j++) {
UE_template[j].rnti=0;
}
}
//ICIC init param
#ifdef ICIC
SB_size=mac_xface->get_SB_size(mac_xface->lte_frame_parms->N_RB_DL);
srand (time(NULL));
for(j=0;j<NB_eNB_INST;j++){
eNB_mac_inst[j].sbmap_conf.first_subframe=0;
eNB_mac_inst[j].sbmap_conf.periodicity=10;
eNB_mac_inst[j].sbmap_conf.sb_size=SB_size;
eNB_mac_inst[j].sbmap_conf.nb_active_sb=1;
for(i=0;i<NUMBER_OF_SUBBANDS;i++)
eNB_mac_inst[j].sbmap_conf.sbmap[i]=1;
eNB_mac_inst[j].sbmap_conf.sbmap[rand()%NUMBER_OF_SUBBANDS]=0;
}
#endif
//end ALU's algo
LOG_I(MAC,"[MAIN][INIT] Init function finished\n");
return(0);
}
int main(int argc, char **argv)
{
int i,l,aa,sector;
double sigma2, sigma2_dB=0;
mod_sym_t **txdataF;
#ifdef IFFT_FPGA
int **txdataF2;
#endif
int **txdata,**rxdata;
double **s_re,**s_im,**r_re,**r_im;
double amps[8] = {0.3868472 , 0.3094778 , 0.1547389 , 0.0773694 , 0.0386847 , 0.0193424 , 0.0096712 , 0.0038685};
double aoa=.03,ricean_factor=1,Td=1.0;
int channel_length;
int amp;
unsigned char pbch_pdu[6];
int sync_pos, sync_pos_slot;
FILE *rx_frame_file;
int result;
int freq_offset;
int subframe_offset;
char fname[40], vname[40];
int trial, n_errors=0;
unsigned int nb_rb = 25;
unsigned int first_rb = 0;
unsigned int eNb_id = 0;
unsigned int slot_offset = 0;
unsigned int sample_offset = 0;
unsigned int channel_offset = 0;
int n_frames;
int slot=0,last_slot=0,next_slot=0;
double nf[2] = {3.0,3.0}; //currently unused
double ip =0.0;
double N0W, path_loss, path_loss_dB, tx_pwr, rx_pwr;
double rx_gain;
int rx_pwr2, target_rx_pwr_dB;
struct complex **ch;
unsigned char first_call = 1;
LTE_DL_FRAME_PARMS frame_parms;
LTE_DL_FRAME_PARMS *lte_frame_parms = &frame_parms;
if (argc==2)
amp = atoi(argv[1]);
else
amp = 1024;
// we normalize the tx power to 0dBm, assuming the amplitude of the signal is 1024
// the SNR is this given by the difference of the path loss and the thermal noise (~-105dBm)
// the rx_gain is adjusted automatically to achieve the target_rx_pwr_dB
path_loss_dB = -90;
path_loss = pow(10,path_loss_dB/10);
target_rx_pwr_dB = 60;
lte_frame_parms->N_RB_DL = 25;
lte_frame_parms->N_RB_UL = 25;
lte_frame_parms->Ng_times6 = 1;
lte_frame_parms->Ncp = 1;
lte_frame_parms->Nid_cell = 0;
lte_frame_parms->nushift = 0;
lte_frame_parms->nb_antennas_tx = 2;
lte_frame_parms->nb_antennas_rx = 2;
lte_frame_parms->first_dlsch_symbol = 4;
lte_frame_parms->num_dlsch_symbols = 6;
lte_frame_parms->Csrs = 2;
lte_frame_parms->Bsrs = 0;
lte_frame_parms->kTC = 0;
lte_frame_parms->n_RRC = 0;
lte_frame_parms->mode1_flag = 1;
lte_frame_parms->ofdm_symbol_size = 512;
lte_frame_parms->log2_symbol_size = 9;
lte_frame_parms->samples_per_tti = 7680;
lte_frame_parms->first_carrier_offset = 362;
lte_frame_parms->nb_prefix_samples>>=2;
#ifdef IFFT_FPGA
txdata = (int **)malloc16(2*sizeof(int*));
txdata[0] = (int *)malloc16(FRAME_LENGTH_BYTES);
txdata[1] = (int *)malloc16(FRAME_LENGTH_BYTES);
bzero(txdata[0],FRAME_LENGTH_BYTES);
bzero(txdata[1],FRAME_LENGTH_BYTES);
rxdata = (int **)malloc16(2*sizeof(int*));
rxdata[0] = (int *)malloc16(2*FRAME_LENGTH_BYTES);
rxdata[1] = (int *)malloc16(2*FRAME_LENGTH_BYTES);
bzero(rxdata[0],2*FRAME_LENGTH_BYTES);
bzero(rxdata[1],2*FRAME_LENGTH_BYTES);
txdataF2 = (int **)malloc16(2*sizeof(int*));
txdataF2[0] = (int *)malloc16(FRAME_LENGTH_BYTES);
txdataF2[1] = (int *)malloc16(FRAME_LENGTH_BYTES);
bzero(txdataF2[0],FRAME_LENGTH_BYTES);
bzero(txdataF2[1],FRAME_LENGTH_BYTES);
#endif
s_re = malloc(2*sizeof(double*));
s_im = malloc(2*sizeof(double*));
r_re = malloc(2*sizeof(double*));
r_im = malloc(2*sizeof(double*));
for (i=0; i<2; i++) {
s_re[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
bzero(s_re[i],FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
s_im[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
bzero(s_im[i],FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
r_re[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
bzero(r_re[i],FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
r_im[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
bzero(r_im[i],FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
}
for (i=0; i<2; i++) {
for (l=0; l<FRAME_LENGTH_COMPLEX_SAMPLES; l++) {
((short*) txdata[i])[2*l] = amp * cos(M_PI/2*l);
((short*) txdata[i])[2*l+1] = amp * sin(M_PI/2*l);
}
}
tx_pwr = signal_energy(txdata[0],lte_frame_parms->samples_per_tti>>1);
printf("tx_pwr (DAC in) %d dB for slot %d (subframe %d)\n",dB_fixed(tx_pwr),next_slot,next_slot>>1);
channel_length = (int) 11+2*BW*Td;
ch = (struct complex**) malloc(4 * sizeof(struct complex*));
for (i = 0; i<4; i++)
ch[i] = (struct complex*) malloc(channel_length * sizeof(struct complex));
randominit(0);
set_taus_seed(0);
#ifdef RF
tx_pwr = dac_fixed_gain(s_re,
s_im,
txdata,
lte_frame_parms->nb_antennas_tx,
lte_frame_parms->samples_per_tti>>1,
14,
18); //this should give 0dBm output level for input with amplitude 1024
printf("tx_pwr (DAC out) %f dB for slot %d (subframe %d)\n",10*log10(tx_pwr),next_slot,next_slot>>1);
#else
for (i=0; i<(lte_frame_parms->samples_per_tti>>1); i++) {
for (aa=0; aa<lte_frame_parms->nb_antennas_tx; aa++) {
s_re[aa][i] = ((double)(((short *)txdata[aa]))[(i<<1)]);
s_im[aa][i] = ((double)(((short *)txdata[aa]))[(i<<1)+1]);
}
}
#endif
// printf("channel for slot %d (subframe %d)\n",next_slot,next_slot>>1);
multipath_channel(ch,s_re,s_im,r_re,r_im,
amps,Td,BW,ricean_factor,aoa,
lte_frame_parms->nb_antennas_tx,
lte_frame_parms->nb_antennas_rx,
lte_frame_parms->samples_per_tti>>1,
channel_length,
0,
.9,
(first_call == 1) ? 1 : 0);
if (first_call == 1)
first_call = 0;
#ifdef RF
//path_loss_dB = 0;
//path_loss = 1;
for (i=0; i<(lte_frame_parms->samples_per_tti>>1); i++) {
for (aa=0; aa<lte_frame_parms->nb_antennas_rx; aa++) {
r_re[aa][i]=r_re[aa][i]*sqrt(path_loss);
r_im[aa][i]=r_im[aa][i]*sqrt(path_loss);
}
}
rx_pwr = signal_energy_fp(r_re,r_im,lte_frame_parms->nb_antennas_rx,lte_frame_parms->samples_per_tti>>1,0);
printf("rx_pwr (RF in) %f dB for slot %d (subframe %d)\n",10*log10(rx_pwr),next_slot,next_slot>>1);
rx_gain = target_rx_pwr_dB - 10*log10(rx_pwr);
// RF model
rf_rx(r_re,
r_im,
NULL,
NULL,
0,
lte_frame_parms->nb_antennas_rx,
lte_frame_parms->samples_per_tti>>1,
1.0/7.68e6 * 1e9, // sampling time (ns)
0.0, // freq offset (Hz) (-20kHz..20kHz)
0.0, // drift (Hz) NOT YET IMPLEMENTED
nf, // noise_figure NOT YET IMPLEMENTED
rx_gain-66.227, // rx gain (66.227 = 20*log10(pow2(11)) = gain from the adc that will be applied later)
200, // IP3_dBm (dBm)
&ip, // initial phase
30.0e3, // pn_cutoff (kHz)
-500.0, // pn_amp (dBc) default: 50
0.0, // IQ imbalance (dB),
0.0); // IQ phase imbalance (rad)
rx_pwr = signal_energy_fp(r_re,r_im,lte_frame_parms->nb_antennas_rx,lte_frame_parms->samples_per_tti>>1,0);
printf("rx_pwr (ADC in) %f dB for slot %d (subframe %d)\n",10*log10(rx_pwr),next_slot,next_slot>>1);
#endif
#ifdef RF
adc(r_re,
r_im,
0,
slot_offset,
rxdata,
lte_frame_parms->nb_antennas_rx,
lte_frame_parms->samples_per_tti>>1,
12);
rx_pwr2 = signal_energy(rxdata[0]+slot_offset,lte_frame_parms->samples_per_tti>>1);
printf("rx_pwr (ADC out) %f dB (%d) for slot %d (subframe %d)\n",10*log10((double)rx_pwr2),rx_pwr2,next_slot,next_slot>>1);
#else
for (i=0; i<(lte_frame_parms->samples_per_tti>>1); i++) {
for (aa=0; aa<lte_frame_parms->nb_antennas_rx; aa++) {
((short*) rxdata[aa])[2*slot_offset + (2*i)] = (short) ((r_re[aa][i]) + sqrt(sigma2/2)*gaussdouble(0.0,1.0));
((short*) rxdata[aa])[2*slot_offset + (2*i)+1] = (short) ((r_im[aa][i]) + sqrt(sigma2/2)*gaussdouble(0.0,1.0));
}
}
#endif
write_output("rxsig0.m","rxs0",rxdata[0],lte_frame_parms->samples_per_tti>>1,1,1);
write_output("rxsig1.m","rxs1",rxdata[1],lte_frame_parms->samples_per_tti>>1,1,1);
#ifdef IFFT_FPGA
free(txdataF2[0]);
free(txdataF2[1]);
free(txdataF2);
free(txdata[0]);
free(txdata[1]);
free(txdata);
free(rxdata[0]);
free(rxdata[1]);
free(rxdata);
#endif
for (i=0; i<2; i++) {
free(s_re[i]);
free(s_im[i]);
free(r_re[i]);
free(r_im[i]);
}
free(s_re);
free(s_im);
free(r_re);
free(r_im);
return(0);
}
LTE_UE_DLSCH_t *new_ue_dlsch(uint8_t Kmimo,uint8_t Mdlharq,uint8_t max_turbo_iterations,uint8_t N_RB_DL, uint8_t abstraction_flag) {
LTE_UE_DLSCH_t *dlsch;
uint8_t exit_flag = 0,i,r;
unsigned char bw_scaling =1;
switch (N_RB_DL){
case 6:
bw_scaling =16;
break;
case 25:
bw_scaling =4;
break;
case 50:
bw_scaling =2;
break;
default:
bw_scaling =1;
break;
}
dlsch = (LTE_UE_DLSCH_t *)malloc16(sizeof(LTE_UE_DLSCH_t));
if (dlsch) {
memset(dlsch,0,sizeof(LTE_UE_DLSCH_t));
dlsch->Kmimo = Kmimo;
dlsch->Mdlharq = Mdlharq;
dlsch->max_turbo_iterations = max_turbo_iterations;
for (i=0;i<Mdlharq;i++) {
// msg("new_ue_dlsch: Harq process %d\n",i);
dlsch->harq_processes[i] = (LTE_DL_UE_HARQ_t *)malloc16(sizeof(LTE_DL_UE_HARQ_t));
if (dlsch->harq_processes[i]) {
memset(dlsch->harq_processes[i],0,sizeof(LTE_DL_UE_HARQ_t));
dlsch->harq_processes[i]->first_tx=1;
dlsch->harq_processes[i]->b = (uint8_t*)malloc16(MAX_DLSCH_PAYLOAD_BYTES/bw_scaling);
if (dlsch->harq_processes[i]->b)
memset(dlsch->harq_processes[i]->b,0,MAX_DLSCH_PAYLOAD_BYTES/bw_scaling);
else
exit_flag=3;
if (abstraction_flag == 0) {
for (r=0;r<MAX_NUM_DLSCH_SEGMENTS/bw_scaling;r++) {
dlsch->harq_processes[i]->c[r] = (uint8_t*)malloc16(((r==0)?8:0) + 3+ 768);
if (dlsch->harq_processes[i]->c[r])
memset(dlsch->harq_processes[i]->c[r],0,((r==0)?8:0) + 3+ 768);
else
exit_flag=2;
dlsch->harq_processes[i]->d[r] = (short*)malloc16(((3*8*6144)+12+96)*sizeof(short));
if (dlsch->harq_processes[i]->d[r])
memset(dlsch->harq_processes[i]->d[r],0,((3*8*6144)+12+96)*sizeof(short));
else
exit_flag=2;
}
}
} else {
exit_flag=1;
}
}
if (exit_flag==0)
return(dlsch);
}
msg("new_ue_dlsch with size %zu: exit_flag = %u\n",sizeof(LTE_DL_UE_HARQ_t), exit_flag);
free_ue_dlsch(dlsch);
return(NULL);
}
/*------------------------------------------------------------------------------*/
void openair_rrc_top_init(int eMBMS_active, uint8_t cba_group_active,uint8_t HO_active){
/*-----------------------------------------------------------------------------*/
module_id_t module_id;
OAI_UECapability_t *UECap = NULL;
// uint8_t dummy_buffer[100];
LOG_D(RRC, "[OPENAIR][INIT] Init function start: NB_UE_INST=%d, NB_eNB_INST=%d\n", NB_UE_INST, NB_eNB_INST);
if (NB_UE_INST > 0) {
UE_rrc_inst = (UE_RRC_INST*) malloc16(NB_UE_INST*sizeof(UE_RRC_INST));
memset (UE_rrc_inst, 0, NB_UE_INST * sizeof(UE_RRC_INST));
LOG_D(RRC, "ALLOCATE %d Bytes for UE_RRC_INST @ %p\n", (unsigned int)(NB_UE_INST*sizeof(UE_RRC_INST)), UE_rrc_inst);
// fill UE capability
UECap = fill_ue_capability ();
for (module_id = 0; module_id < NB_UE_INST; module_id++) {
UE_rrc_inst[module_id].UECapability = UECap->sdu;
UE_rrc_inst[module_id].UECapability_size = UECap->sdu_size;
}
/*
do_UECapabilityEnquiry(0,
dummy_buffer,
0,
0);*/
#ifdef Rel10
LOG_I(RRC,"[UE] eMBMS active state is %d \n", eMBMS_active);
for (module_id=0;module_id<NB_UE_INST;module_id++) {
UE_rrc_inst[module_id].MBMS_flag = (uint8_t)eMBMS_active;
}
#endif
}
else
UE_rrc_inst = NULL;
if (NB_eNB_INST > 0) {
eNB_rrc_inst = (eNB_RRC_INST*) malloc16(NB_eNB_INST*sizeof(eNB_RRC_INST));
memset (eNB_rrc_inst, 0, NB_eNB_INST * sizeof(eNB_RRC_INST));
LOG_I(RRC,"[eNB] handover active state is %d \n", HO_active);
for (module_id=0;module_id<NB_eNB_INST;module_id++) {
eNB_rrc_inst[module_id].HO_flag = (uint8_t)HO_active;
}
#ifdef Rel10
LOG_I(RRC,"[eNB] eMBMS active state is %d \n", eMBMS_active);
for (module_id=0;module_id<NB_eNB_INST;module_id++) {
eNB_rrc_inst[module_id].MBMS_flag = (uint8_t)eMBMS_active;
}
#endif
#ifdef CBA
for (module_id=0;module_id<NB_eNB_INST;module_id++) {
eNB_rrc_inst[module_id].num_active_cba_groups = cba_group_active;
}
#endif
#ifdef LOCALIZATION
/* later set this from xml or enb.config file*/
struct timeval ts; // time struct
gettimeofday(&ts, NULL); // get the current epoch timestamp
for (module_id=0;module_id<NB_eNB_INST;module_id++) {
eNB_rrc_inst[module_id].reference_timestamp_ms = ts.tv_sec * 1000 + ts.tv_usec / 1000;
initialize(&eNB_rrc_inst[module_id].loc_list);
eNB_rrc_inst[module_id].loc_type=0;
eNB_rrc_inst[module_id].aggregation_period_ms = 5000;
}
#endif
LOG_D(RRC,
"ALLOCATE %d Bytes for eNB_RRC_INST @ %p\n", (unsigned int)(NB_eNB_INST*sizeof(eNB_RRC_INST)), eNB_rrc_inst);
}
else
eNB_rrc_inst = NULL;
#ifndef NO_RRM
#ifndef USER_MODE
Header_buf=(char*)malloc16(sizeof(msg_head_t));
Data=(char*)malloc16(2400);
Header_read_idx=0;
Data_read_idx=0;
Header_size=sizeof(msg_head_t);
#endif //NO_RRM
Data_to_read = 0;
#endif //USER_MODE
}
void generate_ul_ref_sigs_rx(void) {
double qbar,phase;
unsigned int u,v,Msc_RS,q,m,n;
// These are the complex conjugated Zadoff-Chu sequences quantized to QPSK stored in repeated format (for RB 3-100)
for (Msc_RS=2;Msc_RS<33;Msc_RS++) {
for (u=0;u<30;u++) {
for (v=0;v<2;v++) {
qbar = ref_primes[Msc_RS] * (u+1)/(double)31;
ul_ref_sigs_rx[u][v][Msc_RS] = (int16_t*)malloc16(4*sizeof(int16_t)*dftsizes[Msc_RS]);
if ((((int)floor(2*qbar))&1) == 0)
q = (int)(floor(qbar+.5)) - v;
else
q = (int)(floor(qbar+.5)) + v;
#ifdef MAIN
printf("Msc_RS %d (%d), u %d, v %d -> q %d (qbar %f)\n",Msc_RS,dftsizes[Msc_RS],u,v,q,qbar);
#endif
for (n=0;n<dftsizes[Msc_RS];n++) {
m=n%ref_primes[Msc_RS];
phase = (double)q*m*(m+1)/ref_primes[Msc_RS];
#ifndef IFFT_FPGA
#ifndef NEW_FFT
ul_ref_sigs_rx[u][v][Msc_RS][n<<2] =(int16_t)(floor(32767*cos(M_PI*phase)));
ul_ref_sigs_rx[u][v][Msc_RS][1+(n<<2)] =-(int16_t)(floor(32767*sin(M_PI*phase)));
ul_ref_sigs_rx[u][v][Msc_RS][2+(n<<2)] =(int16_t)(floor(32767*sin(M_PI*phase)));
ul_ref_sigs_rx[u][v][Msc_RS][3+(n<<2)] =(int16_t)(floor(32767*cos(M_PI*phase)));
#else
ul_ref_sigs_rx[u][v][Msc_RS][n<<1] =(int16_t)(floor(32767*cos(M_PI*phase)));
ul_ref_sigs_rx[u][v][Msc_RS][1+(n<<1)] =-(int16_t)(floor(32767*sin(M_PI*phase)));
#endif
#else
#ifndef OFDMA_ULSCH
ul_ref_sigs_rx[u][v][Msc_RS][n<<2] =(int16_t)(floor(32767*cos(M_PI*phase)));
ul_ref_sigs_rx[u][v][Msc_RS][1+(n<<2)] =-(int16_t)(floor(32767*sin(M_PI*phase)));
ul_ref_sigs_rx[u][v][Msc_RS][2+(n<<2)] =(int16_t)(floor(32767*sin(M_PI*phase)));
ul_ref_sigs_rx[u][v][Msc_RS][3+(n<<2)] =(int16_t)(floor(32767*cos(M_PI*phase)));
#else
ul_ref_sigs_rx[u][v][Msc_RS][n<<2] =(int16_t) ((cos(M_PI*phase)>=0) ? ONE_OVER_SQRT2_Q15 : -ONE_OVER_SQRT2_Q15);
ul_ref_sigs_rx[u][v][Msc_RS][1+(n<<2)] =(int16_t)((-sin(M_PI*phase)>=0) ? ONE_OVER_SQRT2_Q15 : -ONE_OVER_SQRT2_Q15);
ul_ref_sigs_rx[u][v][Msc_RS][2+(n<<2)] =(int16_t)((-sin(M_PI*phase)>=0) ? -ONE_OVER_SQRT2_Q15 : ONE_OVER_SQRT2_Q15);
ul_ref_sigs_rx[u][v][Msc_RS][3+(n<<2)] =(int16_t) ((cos(M_PI*phase)>=0) ? ONE_OVER_SQRT2_Q15 : -ONE_OVER_SQRT2_Q15);
#endif
#endif
#ifdef MAIN
if (Msc_RS<5)
printf("(%d,%d) ",ul_ref_sigs_rx[u][v][Msc_RS][n<<2],ul_ref_sigs_rx[u][v][Msc_RS][1+(n<<2)]);
#endif
}
#ifdef MAIN
if (Msc_RS<5)
printf("\n");
#endif
}
}
}
// These are the sequences for RB 1
for (u=0;u<30;u++) {
ul_ref_sigs_rx[u][0][0] = (int16_t*)malloc16(4*sizeof(int16_t)*dftsizes[0]);
for (n=0;n<dftsizes[0];n++) {
#ifndef IFFT_FPGA
#ifndef NEW_FFT
ul_ref_sigs_rx[u][0][0][n<<2] = (int16_t)(floor(32767*cos(M_PI*ref12[(u*12) + n]/4)));
ul_ref_sigs_rx[u][0][0][1+(n<<2)]= (int16_t)(floor(32767*sin(M_PI*ref12[(u*12) + n]/4)));
ul_ref_sigs_rx[u][0][0][2+(n<<2)]=-(int16_t)(floor(32767*sin(M_PI*ref12[(u*12) + n]/4)));
ul_ref_sigs_rx[u][0][0][3+(n<<2)]= (int16_t)(floor(32767*cos(M_PI*ref12[(u*12) + n]/4)));
#else
ul_ref_sigs_rx[u][0][0][n<<1] = (int16_t)(floor(32767*cos(M_PI*ref12[(u*12) + n]/4)));
ul_ref_sigs_rx[u][0][0][1+(n<<1)]= (int16_t)(floor(32767*sin(M_PI*ref12[(u*12) + n]/4)));
#endif
#else
#ifndef OFDMA_ULSCH
ul_ref_sigs_rx[u][0][0][n<<2] = (int16_t)(floor(32767*cos(M_PI*ref12[(u*12) + n]/4)));
ul_ref_sigs_rx[u][0][0][1+(n<<2)]= (int16_t)(floor(32767*sin(M_PI*ref12[(u*12) + n]/4)));
ul_ref_sigs_rx[u][0][0][2+(n<<2)]=-(int16_t)(floor(32767*sin(M_PI*ref12[(u*12) + n]/4)));
ul_ref_sigs_rx[u][0][0][3+(n<<2)]= (int16_t)(floor(32767*cos(M_PI*ref12[(u*12) + n]/4)));
#else
ul_ref_sigs_rx[u][0][0][n<<2] = (int16_t)((cos(M_PI*ref12[(u*12) + n]/4)>=0) ? ONE_OVER_SQRT2_Q15 : -ONE_OVER_SQRT2_Q15);
ul_ref_sigs_rx[u][0][0][1+(n<<2)]= (int16_t)((sin(M_PI*ref12[(u*12) + n]/4)>=0) ? ONE_OVER_SQRT2_Q15 : -ONE_OVER_SQRT2_Q15);
ul_ref_sigs_rx[u][0][0][2+(n<<2)]= (int16_t)((sin(M_PI*ref12[(u*12) + n]/4)>=0) ? -ONE_OVER_SQRT2_Q15 : ONE_OVER_SQRT2_Q15);
ul_ref_sigs_rx[u][0][0][3+(n<<2)]= (int16_t)((cos(M_PI*ref12[(u*12) + n]/4)>=0) ? ONE_OVER_SQRT2_Q15 : -ONE_OVER_SQRT2_Q15);
#endif
#endif
}
}
// These are the sequences for RB 2
for (u=0;u<30;u++) {
ul_ref_sigs_rx[u][0][1] = (int16_t*)malloc16(4*sizeof(int16_t)*dftsizes[1]);
for (n=0;n<dftsizes[1];n++) {
#ifndef IFFT_FPGA
#ifndef NEW_FFT
ul_ref_sigs_rx[u][0][1][n<<2] = (int16_t)(floor(32767*cos(M_PI*ref24[(u*24) + n]/4)));
ul_ref_sigs_rx[u][0][1][1+(n<<2)]= (int16_t)(floor(32767*sin(M_PI*ref24[(u*24) + n]/4)));
#else
ul_ref_sigs_rx[u][0][1][n<<1] = (int16_t)(floor(32767*cos(M_PI*ref24[(u*24) + n]/4)));
ul_ref_sigs_rx[u][0][1][1+(n<<1)]= (int16_t)(floor(32767*sin(M_PI*ref24[(u*24) + n]/4)));
#endif
ul_ref_sigs_rx[u][0][1][2+(n<<2)]=-(int16_t)(floor(32767*sin(M_PI*ref24[(u*24) + n]/4)));
ul_ref_sigs_rx[u][0][1][3+(n<<2)]= (int16_t)(floor(32767*cos(M_PI*ref24[(u*24) + n]/4)));
#else
#ifndef OFDMA_ULSCH
ul_ref_sigs_rx[u][0][1][n<<2] = (int16_t)(floor(32767*cos(M_PI*ref24[(u*24) + n]/4)));
ul_ref_sigs_rx[u][0][1][1+(n<<2)]= (int16_t)(floor(32767*sin(M_PI*ref24[(u*24) + n]/4)));
ul_ref_sigs_rx[u][0][1][2+(n<<2)]=-(int16_t)(floor(32767*sin(M_PI*ref24[(u*24) + n]/4)));
ul_ref_sigs_rx[u][0][1][3+(n<<2)]= (int16_t)(floor(32767*cos(M_PI*ref24[(u*24) + n]/4)));
#else
ul_ref_sigs_rx[u][0][1][n<<2] = (int16_t)((cos(M_PI*ref24[(u*24) + n]/4)>=0) ? ONE_OVER_SQRT2_Q15 : -ONE_OVER_SQRT2_Q15);
ul_ref_sigs_rx[u][0][1][1+(n<<2)]= (int16_t)((sin(M_PI*ref24[(u*24) + n]/4)>=0) ? ONE_OVER_SQRT2_Q15 : -ONE_OVER_SQRT2_Q15);
ul_ref_sigs_rx[u][0][1][2+(n<<2)]= (int16_t)((sin(M_PI*ref24[(u*24) + n]/4)>=0) ? -ONE_OVER_SQRT2_Q15 : ONE_OVER_SQRT2_Q15);
ul_ref_sigs_rx[u][0][1][3+(n<<2)]= (int16_t)((cos(M_PI*ref24[(u*24) + n]/4)>=0) ? ONE_OVER_SQRT2_Q15 : -ONE_OVER_SQRT2_Q15);
#endif
#endif
}
}
}
