FreeCalypso > hg > tcs211-l1-reconst
changeset 292:51e57732da26
l1p_asyn.c: initial import from LoCosto source
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Mon, 02 Oct 2017 04:58:02 +0000 |
| parents | 3333f7aacb63 |
| children | c98b6ae0f7f1 |
| files | chipsetsw/layer1/p_cfile/l1p_asyn.c |
| diffstat | 1 files changed, 3102 insertions(+), 1 deletions(-) [+] |
line wrap: on
line diff
--- a/chipsetsw/layer1/p_cfile/l1p_asyn.c Mon Oct 02 04:54:46 2017 +0000 +++ b/chipsetsw/layer1/p_cfile/l1p_asyn.c Mon Oct 02 04:58:02 2017 +0000 @@ -1,1 +1,3102 @@ -/* dummy C source file */ +/************* Revision Controle System Header ************* + * GSM Layer 1 software + * L1P_ASYN.C + * + * Filename l1p_asyn.c + * Copyright 2003 (C) Texas Instruments + * + ************* Revision Controle System Header *************/ + +//#pragma DUPLICATE_FOR_INTERNAL_RAM_START + #include "l1_macro.h" + #include "l1_confg.h" +//#pragma DUPLICATE_FOR_INTERNAL_RAM_END + +#if !((MOVE_IN_INTERNAL_RAM == 1) && (GSM_IDLE_RAM !=0)) // MOVE TO INTERNAL MEM IN CASE GSM_IDLE_RAM enabled +//#pragma GSM_IDLE_DUPLICATE_FOR_INTERNAL_RAM_START // KEEP IN EXTERNAL MEM otherwise + +#define L1P_ASYN_C + +//#pragma GSM_IDLE_DUPLICATE_FOR_INTERNAL_RAM_END // KEEP IN EXTERNAL MEM otherwise +#endif + +//#pragma DUPLICATE_FOR_INTERNAL_RAM_START + +#include "l1_macro.h" +#include "l1_confg.h" + +#if L1_GPRS + +#if (CODE_VERSION == SIMULATION) + #include <string.h> + #include "l1_types.h" + #include "sys_types.h" + #include "l1_const.h" + #if TESTMODE + #include "l1tm_defty.h" + #endif + #if (AUDIO_TASK == 1) + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_defty.h" + #endif + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "l1_varex.h" + #include "l1_signa.h" + #include "l1_proto.h" + #include "l1_time.h" + #include "l1_ctl.h" + + #include "l1p_cons.h" + #include "l1p_msgt.h" + #include "l1p_deft.h" + #include "l1p_vare.h" + #include "l1p_tabs.h" + #include "l1p_sign.h" + #include "l1p_mfta.h" + #include "l1p_macr.h" + + #include "macs_def.h" + #include "macs_cst.h" +#else + #include <string.h> + #include "l1_types.h" + #include "sys_types.h" + #include "l1_const.h" + + #if TESTMODE + #include "l1tm_defty.h" + #endif + #if (AUDIO_TASK == 1) + #include "l1audio_const.h" + #include "l1audio_cust.h" + #include "l1audio_defty.h" + #endif + #if (L1_GTT == 1) + #include "l1gtt_const.h" + #include "l1gtt_defty.h" + #endif + #if (L1_MP3 == 1) + #include "l1mp3_defty.h" + #endif + #if (L1_MIDI == 1) + #include "l1midi_defty.h" + #endif + #include "l1_defty.h" + #include "cust_os.h" + #include "l1_msgty.h" + #include "l1_varex.h" + #include "l1_signa.h" + #include "l1_proto.h" + #include "l1_time.h" + #include "l1_ctl.h" + + #include "l1p_cons.h" + #include "l1p_msgt.h" + #include "l1p_deft.h" + #include "l1p_vare.h" + #include "l1p_tabs.h" + #include "l1p_sign.h" + #include "l1p_mfta.h" + #include "l1p_macr.h" + + #include "macs_def.h" + #include "macs_cst.h" +#endif + +T_TRANSFER_SET *l1pa_get_free_transfer_set (UWORD8 new_tbf); +void l1pa_transfer_process (xSignalHeaderRec *msg); +void l1pa_access_process (xSignalHeaderRec *msg); +void l1pa_idle_packet_polling_process (xSignalHeaderRec *msg); +void l1pa_idle_paging_process (xSignalHeaderRec *msg); +void l1pa_cr_meas_process (xSignalHeaderRec *msg); +void l1pa_serving_cell_pbcch_read_process (xSignalHeaderRec *msg); +void l1pa_neighbor_cell_pbcch_read_process (xSignalHeaderRec *msg); +int l1pa_sort (const void *a, const void *b); +void l1pa_reset_cr_freq_list (void); +void l1pa_tcr_meas_process (xSignalHeaderRec *msg); +T_CRES_LIST_PARAM *l1pa_get_free_cres_list_set (void); +void l1pa_idle_interference_meas_process (xSignalHeaderRec *msg); +void l1pa_transfer_interference_meas_process (xSignalHeaderRec *msg); +void l1pa_idle_smscb_process (xSignalHeaderRec *msg); + +// External prototype +void l1pa_send_int_meas_report(UWORD32 SignalCode, + T_L1P_ITMEAS_IND *last_l1s_msg, + T_L1A_INT_MEAS_PARAM *first_meas_ptr); +void l1pa_send_confirmation(UWORD32 SignalCode, UWORD8 id); +void l1pa_send_tbf_release_con(UWORD32 SignalCode, UWORD8 tbf_type); + +//#pragma DUPLICATE_FOR_INTERNAL_RAM_END + +#if !((MOVE_IN_INTERNAL_RAM == 1) && (GSM_IDLE_RAM > 1)) // MOVE TO INTERNAL MEM IN CASE GSM_IDLE_RAM == 2 +//#pragma GSM_IDLE2_DUPLICATE_FOR_INTERNAL_RAM_START // KEEP IN EXTERNAL MEM otherwise + + +/*-------------------------------------------------------*/ +/* l1pa_task() */ +/*-------------------------------------------------------*/ +/* */ +/* Description: */ +/* ------------ */ +/* L1PA (Layer 1 Asynchronous) task function. This */ +/* function manages the GPRS interface between L3 and L1.*/ +/* It is composed with a set of state machine, each */ +/* machine handles a particular GSM functionality. When */ +/* a message is received in L1_C1 message queue, it is */ +/* submitted to every state machine. The one which are */ +/* impacted by the message process it. At the end of */ +/* "l1pa_task()" function, a balance routine is called, */ +/* it enables L1S tasks consequently to the state machine*/ +/* requests. */ +/* */ +/*-------------------------------------------------------*/ +void l1pa_task(xSignalHeaderRec *msg) +{ + UWORD8 process; + + // Clear L1PA "enable meas and tasks" variables. + //--------------------------------------------- + for(process=0; process<NBR_L1PA_PROCESSES; process++) + { + l1pa.l1pa_en_meas[process] = NO_TASK; + } + + #if (GSM_IDLE_RAM != 0) + if ((msg->SignalCode != L1P_PNP_INFO) && (msg->SignalCode != L1P_PEP_INFO)) + + #if (GSM_IDLE_RAM > 1) // GPF modified for GSM_IDLE_RAM -> SW still running in Internal RAM + { + #endif + l1s.gsm_idle_ram_ctl.l1s_full_exec = TRUE; + #endif // GSM_IDLE_RAM + + // Serving Cell Packet System Information Reading + l1pa_serving_cell_pbcch_read_process(msg); + + // Neighbor Cell Packet System Information Reading + l1pa_neighbor_cell_pbcch_read_process(msg); + + #if (GSM_IDLE_RAM <= 1) // GPF modified for GSM_IDLE_RAM -> SW still running in Internal RAM + { + // Serving Cell Packet Paging Reading + l1pa_idle_paging_process(msg); + } + #endif + // Cell reselection measurement process + l1pa_cr_meas_process(msg); + + // Packet access proccess + l1pa_access_process(msg); + + // Packet polling process + l1pa_idle_packet_polling_process(msg); + + // Packet transfer process. + l1pa_transfer_process(msg); + + // Neighbour Cell Measurement in Packet Transfer mode + l1pa_tcr_meas_process(msg); + + // Intererence measurements in packet idle mode + l1pa_idle_interference_meas_process(msg); + + // Intererence measurements in packet transfer mode + l1pa_transfer_interference_meas_process(msg); + + #if (GSM_IDLE_RAM > 1) // GPF modified for GSM_IDLE_RAM -> SW still running in Internal RAM + }else + { + // Serving Cell Packet Packet Idle Paging Reading + l1pa_idle_paging_process(msg); + } + #endif +} + +//#pragma GSM_IDLE_DUPLICATE_FOR_INTERNAL_RAM_END // KEEP IN EXTERNAL MEM otherwise +#endif + +/*-------------------------------------------------------*/ +/* l1pa_access_process() */ +/*-------------------------------------------------------*/ +/* Description : This state machine handles the packet */ +/* access to the network while in PACKET IDLE mode. */ +/* */ +/* Starting messages: MPHP_RA_REQ */ +/* */ +/* Subsequent messages: MPHP_RA_REQ */ +/* */ +/* Result messages (input): L1P_PRA_DONE */ +/* */ +/* Result messages (output): MPHP_RA_CON */ +/* */ +/* Reset message (input): MPHP_RA_STOP_REQ */ +/* */ +/* Reset message (input): MPHP_RA_STOP_CON */ +/*-------------------------------------------------------*/ +void l1pa_access_process(xSignalHeaderRec *msg) +{ + enum states + { + RESET = 0, + WAIT_INIT = 1, + WAIT_RESULT = 2 + }; + + UWORD8 *state = &l1pa.state[P_ACC]; + UWORD32 SignalCode = msg->SignalCode; + + BOOL end_process = 0; + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Step in state machine. + *state = WAIT_INIT; + + // Reset PRACH process. + l1a_l1s_com.l1s_en_task[PRACH] = TASK_DISABLED; // Clear PRACH task enable flag. + l1pa_l1ps_com.pra_info.prach_alloc = 0; + } + break; + + + case WAIT_INIT: + { + if(SignalCode == MPHP_RA_REQ) + // 1st Random access request message. + //----------------------------------- + { + + // Download Transmit power configuration. + // Given value must be used on 1st TX. + // TXPWR value supplied by L3 is the max. TX power level the MS may use in the given band + l1s.applied_txpwr = ((T_MPHP_RA_REQ *)(msg->SigP))->txpwr; + + + #if L1_R99 + // Init PRACH process. + // "rand" parameter chosen by protocol in range [1..4] for R99 + l1pa_l1ps_com.pra_info.rand = ((T_MPHP_RA_REQ *)(msg->SigP))->rand; + #else + // "rand" parameter from msg is not used for the 1st PRACH. + l1pa_l1ps_com.pra_info.rand = 1; // First PRACH has to be sent immediately + #endif + l1pa_l1ps_com.pra_info.channel_request_data = ((T_MPHP_RA_REQ *)(msg->SigP))->channel_request_data; + l1pa_l1ps_com.pra_info.bs_prach_blks = ((T_MPHP_RA_REQ *)(msg->SigP))->bs_prach_blks; + l1pa_l1ps_com.access_burst_type = ((T_MPHP_RA_REQ *)(msg->SigP))->access_burst_type; + + // Increment rand parameter by 4 in order to avoid conflict between SYNCHRO and + // PRACH tasks when MPHP_START_PCCCH_REQ and MPHP_RA_REQ are + // sent at the same time by L3 + l1pa_l1ps_com.pra_info.rand+=4; + + if ((l1pa_l1ps_com.pra_info.bs_prach_blks == 0) || // no blocks allocated + (l1pa_l1ps_com.pra_info.bs_prach_blks > 12)) // invalid number of blocks + l1pa_l1ps_com.pra_info.prach_alloc = DYN_PRACH_ALLOC; + + // step in state machine. + *state = WAIT_RESULT; + + // Change mode to connection establishment part 1. + l1a_l1s_com.mode = CON_EST_MODE1; + + // Activate PRACH task (no semaphore for UL tasks). + l1a_l1s_com.l1s_en_task[PRACH] = TASK_ENABLED; // Set PRACH task enable flag. + + } + + // end of process. + end_process = 1; + } + break; + + case WAIT_RESULT: + { + if(SignalCode == L1P_RA_DONE) + // Random access acknowledge message: PRACH sent. + //----------------------------------------------- + { + // Forward result message to L3. + l1a_send_result(MPHP_RA_CON, msg, GRRM1_QUEUE); + + // Change mode to connection establishment part 2. + l1a_l1s_com.mode = CON_EST_MODE2; + + // end of process. + return; + } + + else + if(SignalCode == MPHP_RA_REQ) + // Random access message. + //----------------------- + { + // REM: rand is added the msg content since its current content is the already + // spent "slots" from the last PRACH sending. + l1pa_l1ps_com.pra_info.rand += ((T_MPHP_RA_REQ *)(msg->SigP))->rand + 1; + l1pa_l1ps_com.pra_info.channel_request_data = ((T_MPHP_RA_REQ *)(msg->SigP))->channel_request_data; + l1pa_l1ps_com.pra_info.bs_prach_blks = ((T_MPHP_RA_REQ *)(msg->SigP))->bs_prach_blks; + l1pa_l1ps_com.access_burst_type = ((T_MPHP_RA_REQ *)(msg->SigP))->access_burst_type; + + if ((l1pa_l1ps_com.pra_info.bs_prach_blks == 0) || // no blocks allocated + (l1pa_l1ps_com.pra_info.bs_prach_blks > 12)) // invalid number of blocks + l1pa_l1ps_com.pra_info.prach_alloc = DYN_PRACH_ALLOC; +// else +// l1pa_l1ps_com.pra_info.prach_alloc = FIX_PRACH_ALLOC; + else + l1pa_l1ps_com.pra_info.prach_alloc = 0; //must be reset for each burst sent + + + // Activate PRACH task (no semaphore for UL tasks). + l1a_l1s_com.l1s_en_task[PRACH] = TASK_ENABLED; // Set PRACH task enable flag. + + // end of process. + return; + } + + else + if(SignalCode == MPHP_RA_STOP_REQ) + // Request to STOP the LINK ACCESS procedure. + //------------------------------------------- + { + UWORD8 i; + + // send confirmation + l1a_send_confirmation(MPHP_RA_STOP_CON,GRRM1_QUEUE); + + // Store MAX TXPWR value to be used for first Tx PDCH blocks + for(i = 0; i < 8; i++) + { + l1pa_l1ps_com.transfer.dl_pwr_ctrl.txpwr[i] = l1s.applied_txpwr; + } + + // This process must be reset. + *state = RESET; + } + + else + if(SignalCode == MPHP_POLLING_RESPONSE_REQ) + // Stop packet access when packet polling initiated. + //-------------------------------------------------- + { + // Unacknowledged + + // This process must be reset. + *state = RESET; + } + + else + // No action in this machine for other messages. + //---------------------------------------------- + { + // End of process. + end_process = 1; + } + } + break; + } // end of "switch". + } // end of "while" +} // end of procedure. + +/*-------------------------------------------------------*/ +/* l1pa_cr_meas_process() */ +/*-------------------------------------------------------*/ +/* Description : This state machine handles periodic */ +/* signal strength monitoring on carriers specified */ +/* in a frequency list: BA(GPRS), NC_FREQUENCY_LIST, */ +/* EXT_FREEQUENCY_LIST (respectively: cell reselection */ +/* Network Control and Extended measurements. */ +/* */ +/* Starting messages: MPHP_CR_MEAS_REQ */ +/* ------------------ */ +/* L1 starts then the periodic FREQUENCY list receive */ +/* level monitoring. */ +/* */ +/* Subsequent messages: MPHP_CR_MEAS_REQ */ +/* -------------------- */ +/* The frequency list is updated only when measures */ +/* on all the carriers of the current list are */ +/* performed. */ +/* */ +/* Result messages (input): L1P_RXLEV_PERIODIC_DONE */ +/* ------------------------ */ +/* This is a message reported to L1A from L1S. */ +/* Reporting is done when last carrier of the frequency */ +/* list is read. */ +/* */ +/* Result messages (output): MPHP_CR_MEAS_IND */ +/* ------------------------- */ +/* This is the periodic reporting message to L3. */ +/* */ +/* Reset messages (input): MPHP_CR_MEAS_STOP_REQ */ +/* ----------------------- */ +/* Frequency list measurement process is stopped by */ +/* this message. */ +/* */ +/*-------------------------------------------------------*/ +void l1pa_cr_meas_process(xSignalHeaderRec *msg) +{ + enum states + { + RESET = 0, + WAIT_INIT = 1, + WAIT_RESULT = 2 + + }; + + UWORD8 *state = &l1pa.state[CR_MEAS]; + UWORD32 SignalCode = msg->SignalCode; + + BOOL end_process = 0; + while(!end_process) + { + switch(*state) + { + case RESET: + { + // step in state machine. + *state = WAIT_INIT; + + // Reset P_CRMS_MEAS process. + l1pa_l1ps_com.l1ps_en_meas &= P_CRMS_MEAS_MASK; // Reset Packet Cell Reselection Measurement enable flag. + } + break; + + case WAIT_INIT: + { + if(SignalCode == MPHP_CR_MEAS_REQ) + // We receive the Frequency list to be monitored. + //---------------------------------------------- + { + UWORD8 i; + T_CRES_LIST_PARAM *free_list; + + // Set parameter synchro semaphore for P_CRMS_MEAS task. + l1pa_l1ps_com.meas_param |= P_CRMS_MEAS; + + // Reset the frequency list structure. + l1pa_reset_cr_freq_list(); + + // Get Ptr to the free Neighbour meas list. + // The number of carriers in the list and the list + // identification are initialized. + free_list = l1pa_get_free_cres_list_set(); + + // Set number of carrier in the frequency list. + free_list->nb_carrier = ((T_MPHP_CR_MEAS_REQ *)(msg->SigP))->nb_carrier; + + // Store ARFCN list in the Packet Cell Reselection structure. + for(i=0;i<free_list->nb_carrier;i++) + free_list->freq_list[i] = ((T_MPHP_CR_MEAS_REQ *)(msg->SigP))->radio_freq_no[i]; + + // Download Frequency list identifier. + free_list->list_id = ((T_MPHP_CR_MEAS_REQ *)(msg->SigP))->list_id; + + // Set "flist" with new set of frequency list parameter + l1pa_l1ps_com.cres_freq_list.flist = free_list; + + // Enable Packet Cell Reselection measurement task. + l1pa.l1pa_en_meas[CR_MEAS] |= P_CRMS_MEAS; + + // step in state machine. + *state = WAIT_RESULT; + } + + // End of process. + end_process = 1; + } + break; + + case WAIT_RESULT: + { + if(SignalCode == L1P_CR_MEAS_DONE) + // One set of measurement has been completed. + //--------------------------------------------- + { + // Forward result message to L3. + l1a_send_result(MPHP_CR_MEAS_IND, msg, GRRM1_QUEUE); + + // End of process. + end_process = 1; + } + + else + if((SignalCode == MPHP_CR_MEAS_STOP_REQ) || + (SignalCode == L1P_TRANSFER_DONE) || + (SignalCode == L1C_DEDIC_DONE)) + // Request to STOP this activity. + //------------------------------- + { + // send confirmation message + l1a_send_confirmation(MPHP_CR_MEAS_STOP_CON,GRRM1_QUEUE); + // This process must be reset. + *state = RESET; + } + + else + if (SignalCode == MPHP_CR_MEAS_REQ) + { + // This process must be reset. + *state = RESET; + } + + else + // No action in this machine for other messages. + //---------------------------------------------- + { + // End of process. + end_process = 1; + } + } + break; + } // end of "switch". + } // end of "while" +} // end of procedure. + +#if !((MOVE_IN_INTERNAL_RAM == 1) && (GSM_IDLE_RAM > 1)) // MOVE TO INTERNAL MEM IN CASE GSM_IDLE_RAM == 2 +//#pragma GSM_IDLE2_DUPLICATE_FOR_INTERNAL_RAM_START // KEEP IN EXTERNAL MEM otherwise + +/*-------------------------------------------------------*/ +/* l1pa_idle_paging_process() */ +/*-------------------------------------------------------*/ +/* */ +/*-------------------------------------------------------*/ +void l1pa_idle_paging_process(xSignalHeaderRec *msg) +{ + enum states + { + RESET = 0, + WAIT_INIT = 1, + WAIT_MSG = 2 + }; + + enum pg_mode + { + NORM_PG = 0, + EXT_PG = 1, + REORG_PG = 2 + }; + + UWORD8 *state = &l1pa.state[PI_SCP]; + UWORD32 SignalCode = msg->SignalCode; + UWORD16 imsimod; + UWORD16 split_pg_cycle; + UWORD16 kcn; + UWORD8 page_mode; + + BOOL end_process = 0; + + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Step in state machine. + *state = WAIT_INIT; + + // Disable serving cell tasks. + l1a_l1s_com.l1s_en_task[PALLC] = TASK_DISABLED; // Reset PALLC (reorg) task enable flag. + l1a_l1s_com.l1s_en_task[PNP] = TASK_DISABLED; // Reset PNP task enable flag. + l1a_l1s_com.l1s_en_task[PEP] = TASK_DISABLED; // Reset PEP task enable flag. + + // No Paging => no gauging => no Deep sleep + l1s.pw_mgr.enough_gaug = FALSE; // forbid Deep sleep + + } + break; + + case WAIT_INIT: + { + if(SignalCode == MPHP_START_PCCCH_REQ) + { + // Set semaphores for any PCCCH reading tasks. + l1a_l1s_com.task_param[PALLC] = SEMAPHORE_SET; + l1a_l1s_com.task_param[PNP] = SEMAPHORE_SET; + l1a_l1s_com.task_param[PEP] = SEMAPHORE_SET; + + // Request to enter in PACKET PAGING REORGANIZATION or NORMAL mode. + //---------------------------------------------------------------- + // The initial page mode in the Mobile Station shall be set to paging Reorganization + // cf 04.08 section 3.3.2.1.1. however current implementation allows to init the Paging + // procedure either in Reorganization or in Normal paging mode. + + // Download the PAGING PARAMETERS from the command message. + page_mode = ((T_MPHP_START_PCCCH_REQ *)(msg->SigP))->page_mode; + imsimod = ((T_MPHP_START_PCCCH_REQ *)(msg->SigP))->imsimod; + kcn = ((T_MPHP_START_PCCCH_REQ *)(msg->SigP))->kcn; + split_pg_cycle = ((T_MPHP_START_PCCCH_REQ *)(msg->SigP))->split_pg_cycle; + l1pa_l1ps_com.pccch.bs_pag_blks_res = ((T_MPHP_START_PCCCH_REQ *)(msg->SigP))->bs_pag_blks_res; + l1pa_l1ps_com.pccch.bs_pbcch_blks = ((T_MPHP_START_PCCCH_REQ *)(msg->SigP))->bs_pbcch_blks; + l1pa_l1ps_com.pccch.frequency_list = ((T_MPHP_START_PCCCH_REQ *)(msg->SigP))->frequency_list; + l1pa_l1ps_com.pccch.packet_chn_desc = ((T_MPHP_START_PCCCH_REQ *)(msg->SigP))->packet_chn_desc; + l1a_l1s_com.Scell_info.pb = ((T_MPHP_START_PCCCH_REQ *)(msg->SigP))->pb << 2; // Pb format 7.1 + + // Number of paging blocks "available" on one PCCCH = number of ppch blocks per MF52 * 64 + // = (12 - BS_PAG_BLKS_RES - BS_PBCCH_BLKS)*64 + l1pa_l1ps_com.pccch.nb_ppch_per_mf52 = (12 - l1pa_l1ps_com.pccch.bs_pag_blks_res - (l1pa_l1ps_com.pccch.bs_pbcch_blks + 1)); + + // Compute M. + l1pa_l1ps_com.pccch.pg_blks_avail = l1pa_l1ps_com.pccch.nb_ppch_per_mf52 * 64; + + // (IMSI mod 1000) div (KC*N) (Note: N = 1 for PCCCH) + l1pa_l1ps_com.pccch.pg_offset = imsimod / kcn; + + // First Paging Group value: PAGING_GROUP = ((IMSI mod 1000) div ((KC*N)*N)) (for m = 0) + l1pa_l1ps_com.pccch.first_pg_grp = (l1pa_l1ps_com.pccch.pg_offset % l1pa_l1ps_com.pccch.pg_blks_avail); + + // Split Paging computation = min (pg_blks_avail, SPLIT_PG_CYCLE) + l1pa_l1ps_com.pccch.split_pg_value = Min(l1pa_l1ps_com.pccch.pg_blks_avail, split_pg_cycle); + + // Paging Period computation + l1pa_l1ps_com.pccch.pnp_period = (64*52) / l1pa_l1ps_com.pccch.split_pg_value; + + // Rem: changing the paging parameters changes the place where "Periodic Packet + // Measurement" task must be executed. It implies to set semaphore for P_CRMS task. + l1pa_l1ps_com.meas_param |= P_CRMS_MEAS; + + // Layer 1 internal mode is set to IDLE MODE. + l1a_l1s_com.mode = I_MODE; + + // In order to keep tn_difference and dl_tn consistent, we need to avoid + // the execution of the SYNCHRO task with tn_difference updated and + // dl_tn not yet updated (this can occur if we go in the HISR just after + // the update of tn_difference). To do this the solution is to use the Semaphore + // associated to the SYNCHRO task. SYNCHRO task will be schedule only if its + // associated Semaphore is reset. + // Note: Due to the specificity of the SYNCHRO task which can be enabled + // by L1A state machines as by L1S processes, the semaphore can't followed + // the generic rules of the Semaphore shared between L1A and L1S. + // We must shift the mobile time setting to the timeslot provided by + // ((T_MPHP_START_PCCCH_REQ *)(msg->SigP))->packet_chn_desc.timeslot_no parameter. + // tn_difference -> loaded with the number of timeslot to shift. + // dl_tn -> loaded with the new timeslot. + l1a_l1s_com.task_param[SYNCHRO] = SEMAPHORE_SET; + { + l1a_l1s_com.tn_difference += l1pa_l1ps_com.pccch.packet_chn_desc.timeslot_no - l1a_l1s_com.dl_tn; + l1a_l1s_com.dl_tn = l1pa_l1ps_com.pccch.packet_chn_desc.timeslot_no; + + // Select GPRS DSP Scheduler. + l1a_l1s_com.dsp_scheduler_mode = GPRS_SCHEDULER; + + // Timing must be shifted to a new timeslot, enables SYNCHRO task.. + l1a_l1s_com.l1s_en_task[SYNCHRO] = TASK_ENABLED; + } + l1a_l1s_com.task_param[SYNCHRO] = SEMAPHORE_RESET; + // Note: The using of the semaphore associated to the SYNCHRO task can't be done + // as it is for the other semaphores. This is due to the specificity of the SYNCHRO + // task both touch by L1A and L1S. Here above the semaphore is set prior to touching + // the SYNCHRO parameters and reset after. In L1S this semaphore is checked. If it's + // seen SET then L1S will not execute SYNCHRO task nor modify its parameters. + + // Step in state machine. + *state = WAIT_MSG; + + if(page_mode == REORG_PG) + // Paging Reorganization mode... + { + // Enable Packet Paging Reorganisation tasks. + l1a_l1s_com.l1s_en_task[PALLC] = TASK_ENABLED; + l1a_l1s_com.l1s_en_task[PNP] = TASK_ENABLED; + + // End of process. + end_process = 1; + } + else + if(page_mode == NORM_PG) + // Normal Paging mode... + { + // Enable Packet Paging tasks in mode "NORMAL". + l1a_l1s_com.l1s_en_task[PNP] = TASK_ENABLED; + + // End of process. + end_process = 1; + } + else + // Extended Paging mode... + { + // Initialize Paging State for PAGING_GROUP computation (L1S part) + l1pa_l1ps_com.pccch.epg_computation = PPCH_POS_NOT_COMP; + + // Enable Packet Paging tasks in mode "EXTENDED". + l1a_l1s_com.l1s_en_task[PNP] = TASK_ENABLED; + l1a_l1s_com.l1s_en_task[PEP] = TASK_ENABLED; + + // End of process. + end_process = 1; + } + + } // end of test on SignalCode == MPHP_START_PCCCH_REQ + + else + // No action in this machine for other messages. + //---------------------------------------------- + { + // End of process. + end_process = 1; + } + + } // end of case WAIT_INIT + break; + + case WAIT_MSG: + { + if((SignalCode == L1P_PNP_INFO) || + (SignalCode == L1P_PALLC_INFO) || + (SignalCode == L1P_PEP_INFO)) + // Paging Task results + { + // Forward result message to L3. + l1a_send_result(MPHP_DATA_IND, msg, GRRM1_QUEUE); + + // End of process. + return; + } + + else + if(SignalCode == MPHP_START_PCCCH_REQ) + // New PCCCH configuration is provided. + //-------------------------------------------------------- + { + // Step in state machine + *state = RESET; + } + + else + if((SignalCode == MPHP_STOP_PCCCH_REQ) || + (SignalCode == L1P_TRANSFER_DONE) || (SignalCode == L1C_DEDIC_DONE)) + // Request to STOP any serving cell Packet Paging activity, OR + // Packet Transfer has just started. + // In both cases, PCCCH reading must be stopped. + //-------------------------------------------------------- + { + // Send confirmation message to L3. + l1a_send_confirmation(MPHP_STOP_PCCCH_CON,GRRM1_QUEUE); + + // This process must be reset. + *state = RESET; + } + + else + if((SignalCode == L1P_SINGLE_BLOCK_CON) || + (SignalCode == MPHP_SINGLE_BLOCK_CON)) + // If Two Phase Access is ongoing: Packet Resource Request + // msg has been sent to the network. PCCCH reading must be + // stopped to let PDCH reading going. + // REM: we must check both L1P/MPHP messages since an other + // process could have renamed L1P into MPHP. + //-------------------------------------------------------- + { + if(((T_MPHP_SINGLE_BLOCK_CON *)(msg->SigP))->purpose == TWO_PHASE_ACCESS) + { + // This process must be reset. + *state = RESET; + } + else + { + // End of process. + return; + } + } + + else + // No action in this machine for other messages. + //---------------------------------------------- + { + // End of process. + return; + } + + } // end of case WAIT_MSG + break; + } // end of switch + } // end of while +} // end of procedure + +//#pragma GSM_IDLE_DUPLICATE_FOR_INTERNAL_RAM_END +#endif + +/*-------------------------------------------------------*/ +/* l1pa_idle_packet_polling_process() */ +/*-------------------------------------------------------*/ +/* Description : . */ +/* This state machine handles packet polling after */ +/* initiation of the packet acces procedure, when a */ +/* packet queuing notification is sent by the network */ +/* */ +/* Starting messages: MPHP_POLLING_RESPONSE_REQ */ +/* */ +/* Subsequent messages: */ +/* */ +/* Result messages (input): L1P_PRA_DONE */ +/* */ +/* Result messages (output): MPHP_POLLING_IND */ +/* */ +/* Reset message (input): */ +/* */ +/* Reset message (input): */ +/*-------------------------------------------------------*/ +void l1pa_idle_packet_polling_process(xSignalHeaderRec *msg) +{ + enum states + { + RESET = 0, + WAIT_INIT = 1, + WAIT_RESULT = 2 + }; + + UWORD8 *state = &l1pa.state[P_POLL]; + UWORD32 SignalCode = msg->SignalCode; + + BOOL end_process = 0; + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Step in state machine. + *state = WAIT_INIT; + + // Reset POLL process. + l1a_l1s_com.l1s_en_task[POLL] = TASK_DISABLED; // Clear RAACC task enable flag. + } + break; + + + case WAIT_INIT: + { + if(SignalCode == MPHP_POLLING_RESPONSE_REQ) + // Polling response request for access procedure. + //----------------------------------------------- + { + UWORD8 i; + + // Init POLL process. + l1pa_l1ps_com.poll_info.pol_resp_type = ((T_MPHP_POLLING_RESPONSE_REQ *)(msg->SigP))->pol_resp_type; + l1pa_l1ps_com.poll_info.fn = ((T_MPHP_POLLING_RESPONSE_REQ *)(msg->SigP))->fn; + + // TXPWR value supplied by L3 is the max. TX power level the MS may use in the given band + l1s.applied_txpwr = ((T_MPHP_POLLING_RESPONSE_REQ *)(msg->SigP))->txpwr; + + // 1 RLC/MAC block is sent: + // This is a special case, only possible if the MS has a valid TA available from a pending + // assignment and is pooled for an RLC/MAC block. + if (l1pa_l1ps_com.poll_info.pol_resp_type == CS1_TYPE_POLL) + { + for (i=0; i<24; i++) + { + // download 24 bytes from message + l1pa_l1ps_com.poll_info.chan_req.cs1_data[i] = + ((T_MPHP_POLLING_RESPONSE_REQ *)(msg->SigP))->channel_request_data[i]; + } + l1pa_l1ps_com.poll_info.timing_advance = ((T_MPHP_POLLING_RESPONSE_REQ *)(msg->SigP))->timing_advance; + + // Store MAX TXPWR value to be used for first POLL RESPONSE + // if not already done by Packet Access process... + for(i = 0; i < 8; i++) + { + l1pa_l1ps_com.transfer.dl_pwr_ctrl.txpwr[i] = l1s.applied_txpwr; + } + } + // 4 identical PRACH are sent + else + { + // UWORD16 = data[1]<<8 | data[0] + l1pa_l1ps_com.poll_info.chan_req.prach_data[0] = + ((T_MPHP_POLLING_RESPONSE_REQ *)(msg->SigP))->channel_request_data[0]; + l1pa_l1ps_com.poll_info.chan_req.prach_data[0] |= + (((T_MPHP_POLLING_RESPONSE_REQ *)(msg->SigP))->channel_request_data[1] << 8); + + l1pa_l1ps_com.poll_info.timing_advance = 0; + } + + // step in state machine. + *state = WAIT_RESULT; + + // Change mode to connection establishment part 1. + l1a_l1s_com.mode = CON_EST_MODE1; + + // Activate POLL task (no semaphore for UL tasks). + // Enable Paging Reorg and Normal paging tasks. + l1a_l1s_com.l1s_en_task[POLL] = TASK_ENABLED; // Set PRACH task enable flag. + } + + // end of process. + end_process = 1; + } + break; + + case WAIT_RESULT: + { + if(SignalCode == L1P_POLL_DONE) + // Random access acqnowledge message. + //----------------------------------- + { + // Forward result message to L3. + l1a_send_result(MPHP_POLLING_IND, msg, GRRM1_QUEUE); + + // Change mode to connection establishment part 2. + l1a_l1s_com.mode = CON_EST_MODE2; + + // This state machine has to be reset + *state = RESET; + + // end of process. + end_process = 1; + } + + else + // No action in this machine for other messages. + //---------------------------------------------- + { + // End of process. + end_process = 1; + } + } + break; + } // end of "switch". + } // end of "while" +} // end of procedure. + + +/*-------------------------------------------------------*/ +/* l1pa_transfer_process() */ +/*-------------------------------------------------------*/ +/* Description: */ +/* ------------ */ +/* */ +/* Starting messages: */ +/* ------------------ */ +/* */ +/* Subsequent messages: */ +/* -------------------- */ +/* */ +/* Result messages (input): */ +/* ------------------------ */ +/* */ +/* Result messages (output): */ +/* ------------------------- */ +/* */ +/* Reset messages (input): */ +/* ----------------------- */ +/* */ +/*-------------------------------------------------------*/ +void l1pa_transfer_process(xSignalHeaderRec *msg) +{ + enum states + { + RESET = 0, + WAIT_MSG = 1 + }; + + UWORD8 *state = &l1pa.state[TRANSFER]; + UWORD32 SignalCode = msg->SignalCode; + + BOOL end_process = 0; + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Step in state machine. + *state = WAIT_MSG; + + // Rise transfert parameter semaphore. + l1pa_l1ps_com.transfer.semaphore = TRUE; + } + break; + + case WAIT_MSG: + { + switch(SignalCode) + // switch on input message. + //------------------------- + { + case MPHP_SINGLE_BLOCK_REQ: + // Repeat fixed allocation. + //------------------------- + { + T_TRANSFER_SET *free_set; + UWORD8 purpose; + UWORD8 i; + + // Rise transfert parameter semaphore to prevent L1S to use partial configuration. + l1pa_l1ps_com.transfer.semaphore = TRUE; + + purpose = ((T_MPHP_SINGLE_BLOCK_REQ *)(msg->SigP))->purpose; + + // Get Ptr to the free dedicated parameter set. + // All important fields are initialised. + free_set = l1pa_get_free_transfer_set(purpose); + + // Fill Transfer mode generic parameters. + free_set->assignment_id = ((T_MPHP_SINGLE_BLOCK_REQ *)(msg->SigP))->assignment_id; + free_set->assignment_command = purpose; + free_set->allocated_tbf = purpose; + free_set->packet_ta = ((T_MPHP_SINGLE_BLOCK_REQ *)(msg->SigP))->packet_ta; + + if((purpose == SINGLE_BLOCK_DL)||(purpose == SINGLE_BLOCK_UL)) + { + free_set->packet_ta.ta_index = 255; + free_set->packet_ta.ta_tn = 255; + } + + free_set->dl_pwr_ctl = ((T_MPHP_SINGLE_BLOCK_REQ *)(msg->SigP))->dl_pwr_ctl; + if (free_set->dl_pwr_ctl.p0 != 255) + free_set->dl_pwr_ctl.p0 <<= 2; // P0 format 7.1 + free_set->tsc = ((T_MPHP_SINGLE_BLOCK_REQ *)(msg->SigP))->tsc; + free_set->freq_param = ((T_MPHP_SINGLE_BLOCK_REQ *)(msg->SigP))->freq_param; + free_set->tbf_sti = ((T_MPHP_SINGLE_BLOCK_REQ *)(msg->SigP))->tbf_sti; + free_set->pc_meas_chan = ((T_MPHP_SINGLE_BLOCK_REQ *)(msg->SigP))->pc_meas_chan; + + // Download access_burst_type + l1pa_l1ps_com.transfer.psi_param.access_burst_type = ((T_MPHP_SINGLE_BLOCK_REQ *)(msg->SigP))->access_burst_type; + // Keep the same Pb factor + l1pa_l1ps_com.transfer.psi_param.Scell_pb = l1a_l1s_com.Scell_info.pb; + // Enable PSI param updating in order to update access_burst_type in L1S + l1pa_l1ps_com.transfer.psi_param.psi_param_update_cmd = TRUE; + + // Fill single block specific parameters. + for(i=0;i<23;i++) + { + l1pa_l1ps_com.transfer.single_block.data_array[i] = + ((T_MPHP_SINGLE_BLOCK_REQ *)(msg->SigP))->data_array[i]; + } + l1pa_l1ps_com.transfer.single_block.tn = + ((T_MPHP_SINGLE_BLOCK_REQ *)(msg->SigP))->timeslot_number; + + l1pa_l1ps_com.transfer.single_block.dl_tn_to_restore = l1a_l1s_com.dl_tn; + + // Fill "synchro_timeslot" which will be the frame synchro slot. + free_set->ul_tbf_synchro_timeslot = l1pa_l1ps_com.transfer.single_block.tn; + free_set->transfer_synchro_timeslot = l1pa_l1ps_com.transfer.single_block.tn; + + // Step in state machine. + *state = WAIT_MSG; + + // Store signalcode. + free_set->SignalCode = MPHP_SINGLE_BLOCK_REQ; + + // Clear transfer parameter semaphore to let L1S use the new parameters. + l1pa_l1ps_com.transfer.semaphore = FALSE; + + // end of process. + end_process = 1; + } + break; + + case MPHP_ASSIGNMENT_REQ: + // Assignement message. + //--------------------- + { + static int count =0; + + T_TRANSFER_SET *free_set; + UWORD8 assignment_command; + UWORD8 timeslot_alloc; + UWORD8 timeslot=0; + + // TBF_changes + + #if FF_TBF + + BOOL pseudo_tbf_two_phase_acc; + + // Special case for two phase access (single or multi allocation): + // It is handled as a pseudo UL TBF using a fixed allocation. + // Still needs to be flagged to preempt TBF establishment switch in + // transfer manager. + if (((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->assignment_command == TWO_PHASE_ACCESS) + { + ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->assignment_command = UL_TBF; + pseudo_tbf_two_phase_acc = TRUE; + } + else + pseudo_tbf_two_phase_acc = FALSE; + #endif + count++ ; + + // Rise transfert parameter semaphore to prevent L1S to use partial configuration. + l1pa_l1ps_com.transfer.semaphore = TRUE; + + assignment_command = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->assignment_command; + + // Get Ptr to the free dedicated parameter set. + // All important fields are initialised. + free_set = l1pa_get_free_transfer_set(assignment_command); + + // Download message containt. + free_set->assignment_id = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->assignment_id; + free_set->assignment_command = assignment_command; + free_set->multislot_class = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->multislot_class; + free_set->dl_pwr_ctl = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->dl_pwr_ctl; + if (free_set->dl_pwr_ctl.p0 != 255) + free_set->dl_pwr_ctl.p0 <<= 2; // P0 format 7.1 + free_set->packet_ta = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->packet_ta; + free_set->tsc = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->tsc; + free_set->freq_param = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->freq_param; + free_set->mac_mode = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->mac_mode; + free_set->tbf_sti = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->tbf_sti; + free_set->interf_meas_enable = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->interf_meas_enable; + free_set->pc_meas_chan = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->pc_meas_chan; + +// TBF_changes + + #if FF_TBF + // Two phase access condition is stored in FSET structure to be + // transfered in ASET for transfer mode manager use. + free_set->pseudo_tbf_two_phase_acc = pseudo_tbf_two_phase_acc; + #endif + + // Download access_burst_type + l1pa_l1ps_com.transfer.psi_param.access_burst_type = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->access_burst_type; + // Keep the same Pb factor + l1pa_l1ps_com.transfer.psi_param.Scell_pb = l1a_l1s_com.Scell_info.pb; + // Enable PSI param updating in order to update access_burst_type in L1S + l1pa_l1ps_com.transfer.psi_param.psi_param_update_cmd = TRUE; + + switch(assignment_command) + { + case DL_TBF: + { + free_set->dl_tbf_alloc = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->dl_ressource_alloc; + + if((free_set->allocated_tbf == UL_TBF) || + (free_set->allocated_tbf == BOTH_TBF)) + free_set->allocated_tbf = BOTH_TBF; + else + free_set->allocated_tbf = DL_TBF; + + // Look for 1st allocated timeslot. + // MSB=TS0...LSB=TS7 + timeslot_alloc = free_set->dl_tbf_alloc.timeslot_alloc; + timeslot = 0; + while((timeslot<7) && !(timeslot_alloc & (0x80>>timeslot))) + { + timeslot++; + } + + // Fill "synchro_timeslot" which will be the frame synchro slot. + free_set->dl_tbf_synchro_timeslot = timeslot; + free_set->transfer_synchro_timeslot = timeslot; + } + break; + + case UL_TBF: + { + *(free_set->ul_tbf_alloc) = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->ul_ressource_alloc; + + if((free_set->allocated_tbf == DL_TBF) || + (free_set->allocated_tbf == BOTH_TBF)) + free_set->allocated_tbf = BOTH_TBF; + else + free_set->allocated_tbf = UL_TBF; + + // Look for 1st allocated timeslot. + // MSB=TS0...LSB=TS7 + + // Dynamic mode: the uplink PDCH are always monitored + // The 1st allocated timeslot is a RX on the lowest numbered + // timeslot allocated in uplink + #if L1_EDA + if((free_set->mac_mode == DYN_ALLOC) || (free_set->mac_mode == EXT_DYN_ALLOC)) + #else + if(free_set->mac_mode == DYN_ALLOC) + #endif + { + timeslot_alloc = free_set->ul_tbf_alloc->timeslot_alloc; + + timeslot = 0; + while((timeslot<7) && !(timeslot_alloc & (0x80>>timeslot))) + { + timeslot++; + } + } + else + + // Fixed mode: the 1st allocated timeslot is the downlink control + // timeslot allocated by the network, which is a timeslot allocated + // in uplink + if(free_set->mac_mode == FIX_ALLOC_NO_HALF) + { + timeslot = free_set->ul_tbf_alloc->fixed_alloc.ctrl_timeslot; + } + + // Fill "synchro_timeslot" which will be the frame synchro slot. + free_set->ul_tbf_synchro_timeslot = timeslot; + free_set->transfer_synchro_timeslot = timeslot; + } + break; + + case BOTH_TBF: + { + free_set->dl_tbf_alloc = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->dl_ressource_alloc; + *(free_set->ul_tbf_alloc) = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->ul_ressource_alloc; + free_set->allocated_tbf = BOTH_TBF; + + // Process the downlink TBF first allocated timeslot + timeslot_alloc = free_set->dl_tbf_alloc.timeslot_alloc; + timeslot = 0; + + while((timeslot<7) && !(timeslot_alloc & (0x80>>timeslot))) + { + timeslot++; + } + + free_set->dl_tbf_synchro_timeslot = timeslot; + + // Process the uplink TBF first allocated timeslot + + // Dynamic mode: the uplink PDCH are always monitored + // The 1st allocated timeslot is a RX on the lowest numbered + // timeslot allocated in uplink + #if L1_EDA + if((free_set->mac_mode == DYN_ALLOC) || (free_set->mac_mode == EXT_DYN_ALLOC)) + #else + if(free_set->mac_mode == DYN_ALLOC) + #endif + { + timeslot_alloc = free_set->ul_tbf_alloc->timeslot_alloc; + + timeslot = 0; + while((timeslot<7) && !(timeslot_alloc & (0x80>>timeslot))) + { + timeslot++; + } + } + else + + // Fixed mode: the 1st allocated timeslot is the downlink control + // timeslot allocated by the network, which is a timeslot allocated + // in uplink + if(free_set->mac_mode == FIX_ALLOC_NO_HALF) + { + timeslot = free_set->ul_tbf_alloc->fixed_alloc.ctrl_timeslot; + } + + free_set->ul_tbf_synchro_timeslot = timeslot; + + // Fill "synchro_timeslot" which will be the frame synchro slot. + if (free_set->dl_tbf_synchro_timeslot > free_set->ul_tbf_synchro_timeslot) + { + free_set->transfer_synchro_timeslot = free_set->ul_tbf_synchro_timeslot; + } + else + { + free_set->transfer_synchro_timeslot = free_set->dl_tbf_synchro_timeslot; + } + + } + break; + } + + // Cancel any pending release on the assigned TBF + if (l1pa_l1ps_com.transfer.tbf_release_param.tbf_release_cmd == TRUE) + { + // If pending released TBF = assigned TBF or assigned TBF = BOTH + if ((assignment_command == l1pa_l1ps_com.transfer.tbf_release_param.released_tbf) || + (assignment_command == BOTH_TBF)) + { + // Send a "TBF Release confirmation" msg to L3 : CQ 46842 + l1pa_send_tbf_release_con(MPHP_TBF_RELEASE_CON,l1pa_l1ps_com.transfer.tbf_release_param.released_tbf); + + // Cancel the TBF release order + l1pa_l1ps_com.transfer.tbf_release_param.tbf_release_cmd = FALSE; + l1pa_l1ps_com.transfer.tbf_release_param.released_tbf = NO_TBF; + } + // If BOTH TBF release order pending and no BOTH TBF assigned + else if (l1pa_l1ps_com.transfer.tbf_release_param.released_tbf == BOTH_TBF) + { + // Keep the release of the TBF which is not assigned by this message + if (assignment_command == DL_TBF) + l1pa_l1ps_com.transfer.tbf_release_param.released_tbf = UL_TBF; + else + l1pa_l1ps_com.transfer.tbf_release_param.released_tbf = DL_TBF; + } + } + + // Step in state machine. + *state = WAIT_MSG; + + // Store signalcode. + free_set->SignalCode = MPHP_ASSIGNMENT_REQ; + + // Clear transfer parameter semaphore to let L1S use the new parameters. + l1pa_l1ps_com.transfer.semaphore = FALSE; + + // end of process. + end_process = 1; + } + break; + + case L1P_TRANSFER_DONE: + // Switch to TRANSFER mode has been done. Send a Assignment confirmation + // msg to L3. + { + l1pa_send_confirmation(MPHP_ASSIGNMENT_CON, + ((T_L1P_TRANSFER_DONE *) msg->SigP)->assignment_id); + + // End of process. + end_process = 1; + } + break; + + case MPHP_TBF_RELEASE_REQ: + // TBF Release. + //------------- + { + UWORD8 i; + + // Rise transfert parameter semaphore to prevent L1S to use partial configuration. + l1pa_l1ps_com.transfer.semaphore = TRUE; + + // Cumulate with a possible TBF release request received during the same block period + if (l1pa_l1ps_com.transfer.tbf_release_param.tbf_release_cmd == TRUE) + { + if (l1pa_l1ps_com.transfer.tbf_release_param.released_tbf != ((T_MPHP_TBF_RELEASE_REQ *)(msg->SigP))->tbf_type) + { + l1pa_l1ps_com.transfer.tbf_release_param.released_tbf = BOTH_TBF; + } + } + else + { + // Enables the TBF release processing in L1S. + l1pa_l1ps_com.transfer.tbf_release_param.tbf_release_cmd = TRUE; + + // Download msg info into L1PA_L1PS_COM. + l1pa_l1ps_com.transfer.tbf_release_param.released_tbf = ((T_MPHP_TBF_RELEASE_REQ *)(msg->SigP))->tbf_type; + } + + // Disable all pending TBFs those type is the same as the released TBF + for(i = 0; i < 2; i++) + { + // Pending assignment + if (l1pa_l1ps_com.transfer.fset[i]->SignalCode == MPHP_ASSIGNMENT_REQ) + { + #if !FF_TBF + switch(l1pa_l1ps_com.transfer.tbf_release_param.released_tbf) + #else + UWORD8 released_tbf; + + // Special case if we got a request to release a two phase access TBF: + // It is registered within FSET structure as an uplink TBF. If current + // structure is pseudo TBF for two phase access, we process the request + // like an uplink release, otherwise we skip it. + + released_tbf = l1pa_l1ps_com.transfer.tbf_release_param.released_tbf; + + if (released_tbf == TWO_PHASE_ACCESS) + { + if (l1pa_l1ps_com.transfer.fset[i]->pseudo_tbf_two_phase_acc) + released_tbf = UL_TBF; + else + released_tbf = NO_TBF; + } + + switch(released_tbf) + #endif // FF_TBF + { + case UL_TBF: + { + if (l1pa_l1ps_com.transfer.fset[i]->allocated_tbf == UL_TBF) + { + l1pa_l1ps_com.transfer.fset[i]->allocated_tbf = NO_TBF; + l1pa_l1ps_com.transfer.fset[i]->SignalCode = NULL; + } + if (l1pa_l1ps_com.transfer.fset[i]->allocated_tbf == BOTH_TBF) + { + l1pa_l1ps_com.transfer.fset[i]->allocated_tbf = DL_TBF; + } + } break; + + case DL_TBF: + { + if (l1pa_l1ps_com.transfer.fset[i]->allocated_tbf == DL_TBF) + { + l1pa_l1ps_com.transfer.fset[i]->allocated_tbf = NO_TBF; + l1pa_l1ps_com.transfer.fset[i]->SignalCode = NULL; + } + if (l1pa_l1ps_com.transfer.fset[i]->allocated_tbf == BOTH_TBF) + { + l1pa_l1ps_com.transfer.fset[i]->allocated_tbf = UL_TBF; + } + } break; + + case BOTH_TBF: + { + l1pa_l1ps_com.transfer.fset[i]->allocated_tbf = NO_TBF; + l1pa_l1ps_com.transfer.fset[i]->SignalCode = NULL; + } break; + + } // End of switch "tbf_release" + } // End if SignalCode = MPHP_ASSIGNMENT_REQ or MPHP_REPEAT_UL_FIXED_ALLOC + } // End "for" + + // Clear transfer parameter semaphore to let L1S use the new parameters. + l1pa_l1ps_com.transfer.semaphore = FALSE; + + // end of process. + end_process = 1; + } + break; + + case L1P_TBF_RELEASED: + // TBF has been release by L1S. Send a "TBF Release confirmation" + // msg to L3 + { + // Send confirmation message to L3. + l1pa_send_tbf_release_con(MPHP_TBF_RELEASE_CON,((T_L1P_TBF_RELEASED *)(msg->SigP))->tbf_type); + + // End of process. + end_process = 1; + } + break; + + case MPHP_STOP_SINGLE_BLOCK_REQ: + // Stop SINGLE block activity. + //---------------------------- + { + UWORD8 i; + + // Rise transfert parameter semaphore to prevent L1S to use partial configuration. + l1pa_l1ps_com.transfer.semaphore = TRUE; + + // Disable SINGLE task. + l1a_l1s_com.l1s_en_task[SINGLE] = TASK_DISABLED; + + // No more TBF... + // Disable PDTCH task. + l1a_l1s_com.l1s_en_task[PDTCH] = TASK_DISABLED; + + // Disable PTCCH task. + l1a_l1s_com.l1s_en_task[PTCCH] = TASK_DISABLED; + + // Free the active set. + l1pa_l1ps_com.transfer.aset->allocated_tbf = NO_TBF; + + // Send confirmation message to L3. + l1a_send_confirmation(MPHP_STOP_SINGLE_BLOCK_CON,GRRM1_QUEUE); + + // disable all pending TBF those type is a single block + for(i = 0; i < 2; i++) + { + // check for pending single block req (MPHP_SINGLE_BLOCK_REQ) + if (l1pa_l1ps_com.transfer.fset[i]->SignalCode == MPHP_SINGLE_BLOCK_REQ) + { + // disable the fset corresponding to single blocks + l1pa_l1ps_com.transfer.fset[i]->allocated_tbf = NO_TBF; + l1pa_l1ps_com.transfer.fset[i]->SignalCode = NULL; + } + } + + // This process must be reset. + *state = RESET; + + // end of process. + end_process = 1; + } + break; + + case MPHP_PDCH_RELEASE_REQ: + // PDCH Release. + //-------------- + { + // Rise transfert parameter semaphore to prevent L1S to use partial configuration. + l1pa_l1ps_com.transfer.semaphore = TRUE; + + // Enables the PDCH release processing in L1S. + l1pa_l1ps_com.transfer.pdch_release_param.pdch_release_cmd = TRUE; + + // Download msg info into L1PA_L1PS_COM. + l1pa_l1ps_com.transfer.pdch_release_param.timeslot_available = ((T_MPHP_PDCH_RELEASE_REQ *)(msg->SigP))->timeslot_available; + l1pa_l1ps_com.transfer.pdch_release_param.assignment_id = ((T_MPHP_PDCH_RELEASE_REQ *)(msg->SigP))->assignment_id; + + // Clear transfer parameter semaphore to let L1S use the new parameters. + l1pa_l1ps_com.transfer.semaphore = FALSE; + + // end of process. + end_process = 1; + } + break; + + case L1P_PDCH_RELEASED: + // PDCHs have been release by L1S. Send a "PDCH Release confirmation" + // msg to L3 + { + // Send confirmation message to L3. + l1pa_send_confirmation(MPHP_PDCH_RELEASE_CON, + ((T_L1P_PDCH_RELEASE_CON *) msg->SigP)->assignment_id); + + // End of process. + end_process = 1; + } + break; + + case MPHP_TIMING_ADVANCE_REQ: + // TA configuration. + //------------------ + { + // Rise transfert parameter semaphore to prevent L1S to use partial configuration. + l1pa_l1ps_com.transfer.semaphore = TRUE; + + // Enables the timing advance update in L1S. + l1pa_l1ps_com.transfer.ptcch.ta_update_cmd = TRUE; + + // Download message content. + l1pa_l1ps_com.transfer.ptcch.packet_ta = ((T_MPHP_TIMING_ADVANCE_REQ *)(msg->SigP))->packet_ta; + l1pa_l1ps_com.transfer.ptcch.assignment_id = ((T_MPHP_TIMING_ADVANCE_REQ *)(msg->SigP))->assignment_id; + + // Clear transfer parameter semaphore to let L1S use the new parameters. + l1pa_l1ps_com.transfer.semaphore = FALSE; + + // end of process. + end_process = 1; + } + break; + + case L1P_TA_CONFIG_DONE: + // TA configuration done. + //----------------------- + { + // Send confirmation message to L3. + l1pa_send_confirmation(MPHP_TIMING_ADVANCE_CON, + ((T_MPHP_TIMING_ADVANCE_CON *) msg->SigP)->assignment_id); + + // end of process. + end_process = 1; + } + break; + + case MPHP_UPDATE_PSI_PARAM_REQ: + // Update PSI Parameters. + //---------------------- + { + // Download msg content + l1pa_l1ps_com.transfer.psi_param.Scell_pb = ((T_MPHP_UPDATE_PSI_PARAM_REQ *)(msg->SigP))->pb << 2; // Pb format 7.1 + l1pa_l1ps_com.transfer.psi_param.access_burst_type = ((T_MPHP_UPDATE_PSI_PARAM_REQ *)(msg->SigP))->access_burst_type; + + l1pa_l1ps_com.transfer.psi_param.psi_param_update_cmd = TRUE; + + // send confirmation message + l1a_send_confirmation(MPHP_UPDATE_PSI_PARAM_CON,GRRM1_QUEUE); + + // end of process. + end_process = 1; + } + break; + + case L1P_PACCH_INFO: + // Two Phase Access is ongoing: Packet Resource Request + // msg has been sent to the network. CCCH reading must be + // stopped to let PDCH reading going. + //-------------------------------------------------------- + { + // Forward result message to RR. + l1a_send_result(MPHP_DATA_IND, msg, GRRM1_QUEUE); + + // end of process. + end_process = 1; + } + break; + + case L1P_SINGLE_BLOCK_CON: + // Two Phase Access is ongoing: Packet Resource Request + // msg has been sent to the network. CCCH reading must be + // stopped to let PDCH reading going. + //-------------------------------------------------------- + { + // Forward result message to RR. + l1a_send_result(MPHP_SINGLE_BLOCK_CON, msg, GRRM1_QUEUE); + + // This process must be reset. + *state = RESET; + + // end of process. + end_process = 1; + } + break; + + case MPHP_REPEAT_UL_FIXED_ALLOC_REQ: + // Repeat uplink fixed mode allocation bitmap + //------------------------------------------- + { + // Rise transfert parameter semaphore to prevent L1S to use partial configuration. + l1pa_l1ps_com.transfer.semaphore = TRUE; + + // If an UL TBF is running... + if ((l1pa_l1ps_com.transfer.aset->allocated_tbf == UL_TBF) || + (l1pa_l1ps_com.transfer.aset->allocated_tbf == BOTH_TBF)) + { + // Download info. from message + l1pa_l1ps_com.transfer.repeat_alloc = *((T_MPHP_REPEAT_UL_FIXED_ALLOC_REQ *) msg->SigP); + } + + // Send confirmation if this message was a repeat allocation cancelling + if (!((T_MPHP_REPEAT_UL_FIXED_ALLOC_REQ *) msg->SigP)->repeat_allocation) + { + l1a_send_confirmation(MPHP_REPEAT_UL_FIXED_ALLOC_CON,GRRM1_QUEUE); + } + else + { + UWORD8 i; + + // Disable all pending UL TBF + for(i = 0; i < 2; i++) + { + // Pending assignment + if (l1pa_l1ps_com.transfer.fset[i]->SignalCode == MPHP_ASSIGNMENT_REQ) + { + switch(l1pa_l1ps_com.transfer.fset[i]->allocated_tbf) + { + // Remove pending UL TBF + case UL_TBF: + { + l1pa_l1ps_com.transfer.fset[i]->allocated_tbf = NO_TBF; + l1pa_l1ps_com.transfer.fset[i]->SignalCode = NULL; + } + break; + + // Change pending BOTH_TBF in pending DL_TBF + case BOTH_TBF: + { + l1pa_l1ps_com.transfer.fset[i]->allocated_tbf = DL_TBF; + } + break; + + } // End of switch "allocated_tbf" + } // End if SignalCode = MPHP_ASSIGNMENT_REQ + } // End "for" + } + + // Clear transfer parameter semaphore to let L1S use the new parameters. + l1pa_l1ps_com.transfer.semaphore = FALSE; + + // end of process. + end_process = 1; + } + break; + + case L1P_REPEAT_ALLOC_DONE: + { + // Send confirmation message to L3. + l1a_send_confirmation(MPHP_REPEAT_UL_FIXED_ALLOC_CON,GRRM1_QUEUE); + + // end of process. + end_process = 1; + } + break; + + default: + // End of process. + //---------------- + { + return; + } + } // end of switch(SignalCode) + } // end of case WAIT_CONFIG. + } // end of "switch". + } // end of "while" +} // end of procedure. + +/*-------------------------------------------------------*/ +/* l1pa_serving_cell_pbcch_read_process() */ +/*-------------------------------------------------------*/ +/* Description : This state machine handles Packet */ +/* serving cell PBCCH reading. */ +/* */ +/* Starting messages: MPHP_SCELL_PBCCH_REQ */ +/* ------------------ */ +/* */ +/* L1 continuously reads the serving cell PBCCH */ +/* as requested by the scheduling info (PSI1 repeat */ +/* period and relative position. */ +/* */ +/* Result messages (input): L1C_PBCCHS_INFO */ +/* ------------------------ */ +/* System information data block from L1S. */ +/* */ +/* Reset messages (input): MPHP_SCELL_PBCCH_STOP_REQ */ +/* ----------------------- */ +/* */ +/*-------------------------------------------------------*/ +void l1pa_serving_cell_pbcch_read_process(xSignalHeaderRec *msg) +{ + enum states + { + RESET = 0, + WAIT_PBCCHS_CONFIG = 1, + WAIT_PBCCHS_RESULT = 2, + PBCCHS_CONFIG = 3 + }; + + UWORD8 *state = &l1pa.state[SCPB]; + UWORD32 SignalCode = msg->SignalCode; + + #define PbcchS l1pa_l1ps_com.pbcchs + + BOOL end_process = 0; + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Step in state machine. + *state = WAIT_PBCCHS_CONFIG; + + // Reset PBCCHS process. + l1a_l1s_com.l1s_en_task[PBCCHS] = TASK_DISABLED; // Clear PBCCHS task enable flag. + } + break; + + case WAIT_PBCCHS_CONFIG: + { + // Request to read Normal BCCH from serving cell. + if(SignalCode == MPHP_SCELL_PBCCH_REQ) + { + #define MAX_PSI1_PERIOD 16 + + UWORD8 i; + + // Set semaphores for Serving Cell PBCCH reading task. + l1a_l1s_com.task_param[PBCCHS] = SEMAPHORE_SET; + + // Download message content. + //-------------------------- + PbcchS.nbr_psi = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->nbr_psi; + PbcchS.bs_pbcch_blks = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->bs_pbcch_blks; + PbcchS.packet_chn_desc = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->packet_chn_desc; + PbcchS.frequency_list = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->frequency_list; + l1a_l1s_com.Scell_info.pb = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->pb << 2; // Pb format 7.1 + PbcchS.psi1_repeat_period = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->psi1_repeat_period; + + // PBCCH Period is: MF52 * psi1_repeat_period + PbcchS.pbcch_period = 52L * PbcchS.psi1_repeat_period; + + if(PbcchS.nbr_psi == 0) + // Full PBCCH reading: Emulated throw "relative positions". + //--------------------------------------------------------- + { + // Emulate full PBCCH reading throw "relative positions" and a repeat period + // of 1 MF52. + // bs_pbcch_blks= 0 -> Read B0 + // bs_pbcch_blks= 1 -> Read B0,B6 + // bs_pbcch_blks= 2 -> Read B0,B6,B3 + // bs_pbcch_blks= 3 -> Read B0,B6,B3,B9 + + PbcchS.nbr_psi = PbcchS.bs_pbcch_blks+1; + PbcchS.read_all_psi = TRUE; + + for(i=0;i<PbcchS.nbr_psi;i++) + { + ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->relative_position_array[i] = i; + } + } + + else + // PBCCH reading: use provided "relative positions". + //-------------------------------------------------- + { + PbcchS.read_all_psi = FALSE; + } + + // Compute FN offset for each PSI. + //-------------------------------- + for(i=0;i<l1pa_l1ps_com.pbcchs.nbr_psi;i++) + { + WORD8 nbr_mf52; // Range 0..MAX_PSI1_PERIOD (can be negative along its estimation) + UWORD8 nbr_rest; // Range 0..3 + UWORD8 relative_position; // Range 0..4*MAX_PSI1_PERIOD + UWORD8 psi_period; // psi1_repeat_period = 1 if nbr_psi = 0 + + relative_position = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->relative_position_array[i]; + + nbr_mf52 = relative_position / (PbcchS.bs_pbcch_blks+1); + nbr_rest = relative_position % (PbcchS.bs_pbcch_blks+1); + + // Block B0 is a special case since CTRL phase occurs during + // the MF52 before. + if(nbr_rest == 0) + { + nbr_mf52 -= 1; + + // Set psi_period to 1 when all PSI have to be read (nbr_psi = 0) + if(PbcchS.read_all_psi) + psi_period = 1; + else + psi_period = PbcchS.psi1_repeat_period; + + if(nbr_mf52 < 0) + nbr_mf52 += psi_period; + } + + PbcchS.offset_array[i] = (nbr_mf52 * 52L) + PBCCH_POSITION[PbcchS.bs_pbcch_blks][nbr_rest]; + PbcchS.relative_position_array[i] = relative_position; + } + + // Step in state machine. + *state = PBCCHS_CONFIG; + } + + // No action in this machine for other messages. + else + { + // End of process. + return; + } + } + break; + + case PBCCHS_CONFIG: + { + WORD8 tn_pbcch; + + // If PBCCH TS is inferior to L1 synchronization TS, the PBCCH reading + // control must be done one frame in advance + if (PbcchS.packet_chn_desc.timeslot_no < l1a_l1s_com.dl_tn) + PbcchS.control_offset = TRUE; + else + PbcchS.control_offset = FALSE; + + // Set "change_synchro" flag to trigger L1S to change the synchro on fly + // within PBCCHS and to restore current synchro when PBCCHS task is completed. + if(((PbcchS.packet_chn_desc.timeslot_no - l1a_l1s_com.dl_tn + 8) % 8) >=4) + { + // L1S will make a intra PBCCHS task synchro to current TS + 4. + PbcchS.change_synchro = TRUE; + tn_pbcch = PbcchS.packet_chn_desc.timeslot_no - l1a_l1s_com.dl_tn - 4; + } + else + { + // L1S will NOT make the intra PBCCHS task synchro. + PbcchS.change_synchro = FALSE; + tn_pbcch = PbcchS.packet_chn_desc.timeslot_no - l1a_l1s_com.dl_tn; + } + + if(tn_pbcch < 0) + PbcchS.tn_pbcch = tn_pbcch + 8; + else + PbcchS.tn_pbcch = tn_pbcch; + + // Enable PBCCHS task. + l1a_l1s_com.l1s_en_task[PBCCHS] = TASK_ENABLED; + + + // Step in state machine. + *state = WAIT_PBCCHS_RESULT; + + // End of process. + end_process = 1; + } + break; + + case WAIT_PBCCHS_RESULT: + { + if(SignalCode == L1P_PBCCHS_INFO) + // Serving cell BCCH reading result. + //---------------------------------- + { + // Forward result message to L3. + l1a_send_result(MPHP_DATA_IND, msg, GRRM1_QUEUE); + + // End of process. + return; + } + + else + if(SignalCode == MPHP_SCELL_PBCCH_REQ) + // Request to re-configure PBCCH reading. + //-------------------------------------- + { + // Step in state machine. + *state = WAIT_PBCCHS_CONFIG; + } + + else + if(SignalCode == MPHP_SCELL_PBCCH_STOP_REQ) + // Request to STOP any serving cell pbcch activity. + //------------------------------------------------ + { + // Send confirmation message to L3. + l1a_send_confirmation(MPHP_SCELL_PBCCH_STOP_CON,GRRM1_QUEUE); + + // This process must be reset. + *state = RESET; + } + + else + // End of packet transfer mode: test PDTCH to be sure that TBF downlink and uplink are released + if((SignalCode == L1P_TBF_RELEASED) && (((T_L1P_TBF_RELEASED *)(msg->SigP))->released_all)) + { + // This process must be reset. + *state = RESET; + } + + else + if ((SignalCode == L1P_TRANSFER_DONE) || (SignalCode == L1P_TBF_RELEASED) || //change of Time Slot + (SignalCode == L1P_REPEAT_ALLOC_DONE) || (SignalCode == L1P_ALLOC_EXHAUST_DONE)) + { + // Clear PBCCHS task enable flag. + l1a_l1s_com.l1s_en_task[PBCCHS] = TASK_DISABLED; + + // Set semaphores for Serving Cell PBCCH reading task. + l1a_l1s_com.task_param[PBCCHS] = SEMAPHORE_SET; + + // l1a_l1s_com.dl_tn was changed. Check if a change synchro is needed + *state = PBCCHS_CONFIG; // Step in state machine. + } + + else + // No action in this machine for other messages. + //---------------------------------------------- + { + // End of process. + return; + } + } + break; + } // end of "switch". + } // end of "while" +} // end of procedure. + + +/*-------------------------------------------------------*/ +/* l1pa_neighbor_cell_pbcch_read_process() */ +/*-------------------------------------------------------*/ +/* Description : This state machine handles Packet */ +/* neighbor cell PBCCH reading. */ +/* */ +/* Starting messages: MPHP_NCELL_PBCCH_REQ */ +/* ------------------ */ +/* */ +/* L1 continuously reads the neighbor cell PBCCH */ +/* as requested by the scheduling info (PSI1 repeat */ +/* period and relative position. */ +/* */ +/* Result messages (input): L1C_PBCCHN_INFO */ +/* ------------------------ */ +/* System information data block from L1S. */ +/* */ +/* Reset messages (input): MPHP_NCELL_PBCCH_STOP_REQ */ +/* ----------------------- */ +/* */ +/*-------------------------------------------------------*/ +void l1pa_neighbor_cell_pbcch_read_process(xSignalHeaderRec *msg) +{ + enum states + { + RESET = 0, + WAIT_PBCCHN_CONFIG = 1, + WAIT_PBCCHN_RESULT = 2, + PBCCHN_CONFIG = 3 + }; + + UWORD8 *state = &l1pa.state[NCPB]; + UWORD32 SignalCode = msg->SignalCode; + + #define PbcchN l1pa_l1ps_com.pbcchn + + static WORD32 fn_offset_mem; + static WORD32 time_alignmt_mem; + + BOOL end_process = 0; + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Step in state machine. + *state = WAIT_PBCCHN_CONFIG; + + // Reset PBCCHS process. + l1a_l1s_com.l1s_en_task[PBCCHN_IDLE] = TASK_DISABLED; // Clear PBCCHN task enable flag used in IDLE mode + l1a_l1s_com.l1s_en_task[PBCCHN_TRAN] = TASK_DISABLED; // Clear PBCCHN task enable flag used in Transfer Packet mode + } + break; + + case WAIT_PBCCHN_CONFIG: + { + // Request to read Normal PBCCH from neighbor cell. + if(SignalCode == MPHP_NCELL_PBCCH_REQ) + { + #define MAX_PSI1_PERIOD 16 + + // Set semaphores for Neighbor Cell PBCCH reading task. + l1a_l1s_com.task_param[PBCCHN_IDLE] = SEMAPHORE_SET; + l1a_l1s_com.task_param[PBCCHN_TRAN] = SEMAPHORE_SET; + + // Download message content. + //-------------------------- + PbcchN.bcch_carrier = ((T_MPHP_NCELL_PBCCH_REQ *)(msg->SigP))->bcch_carrier; + PbcchN.bs_pbcch_blks = ((T_MPHP_NCELL_PBCCH_REQ *)(msg->SigP))->bs_pbcch_blks; + PbcchN.packet_chn_desc = ((T_MPHP_NCELL_PBCCH_REQ *)(msg->SigP))->packet_chn_desc; + PbcchN.frequency_list = ((T_MPHP_NCELL_PBCCH_REQ *)(msg->SigP))->frequency_list; + PbcchN.psi1_repeat_period = ((T_MPHP_NCELL_PBCCH_REQ *)(msg->SigP))->psi1_repeat_period; + PbcchN.relative_position = ((T_MPHP_NCELL_PBCCH_REQ *)(msg->SigP))->relative_position; + fn_offset_mem = ((T_MPHP_NCELL_PBCCH_REQ *)(msg->SigP))->fn_offset; + time_alignmt_mem = ((T_MPHP_NCELL_PBCCH_REQ *)(msg->SigP))->time_alignment; + PbcchN.pb = ((T_MPHP_NCELL_PBCCH_REQ *)(msg->SigP))->pb << 2; // Pb format 7.1 + + // PBCCH Period is: MF52 * psi1_repeat_period + PbcchN.pbcch_period = 52L * PbcchN.psi1_repeat_period; + + // Compute FN offset. + //------------------ + { + WORD8 nbr_mf52; // Range 0..MAX_PSI1_PERIOD (can be negative along its estimation) + UWORD8 nbr_rest; // Range 0..3 + UWORD8 relative_position; // Range 0..4*MAX_PSI1_PERIOD + + relative_position = PbcchN.relative_position; + + // number of PBCCH blocs + nbr_mf52 = relative_position / (PbcchN.bs_pbcch_blks+1); + nbr_rest = relative_position % (PbcchN.bs_pbcch_blks+1); + + // Block B0 is a special case since CTRL phase occurs during the MF52 before. + if(nbr_rest == 0) + { + nbr_mf52 -= 1; + + if(nbr_mf52 < 0) + nbr_mf52 += PbcchN.psi1_repeat_period; + } + + PbcchN.offset = (nbr_mf52 * 52L) + PBCCH_POSITION[PbcchN.bs_pbcch_blks][nbr_rest]; + + // In case of idle mode + if (l1a_l1s_com.mode != PACKET_TRANSFER_MODE) + { + PbcchN.offset -= 2 ; // because of the 2 frames for the measurement windows + // note: PbcchN.offset can not be negative (PbcchN.offset > 12). + } + } + // Step in state machine. + *state = PBCCHN_CONFIG; + } + + // No action in this machine for other messages. + else + { + // End of process. + return; + } + } + break; + + case PBCCHN_CONFIG: + { + //================================================================================== + // choose a relative base time in the neighbor cell in order to simplify the L1S scheduling. + //================================================================================== + PbcchN.fn_offset = fn_offset_mem; + PbcchN.time_alignmt = time_alignmt_mem; + + //the new relative base time is set in order to have the Neighbor burst in position 0. + //update with the burts position of the neighor cell : PbcchN.packet_chn_desc.timeslot_no + //update according to the current serving cell synchro : l1a_l1s_com.dl_tn + PbcchN.time_alignmt += (PbcchN.packet_chn_desc.timeslot_no - l1a_l1s_com.dl_tn ) * TN_WIDTH; + + // PbcchN.time_alignmt is in [-7TS..+16TS[. + // more than 1 frame between the serving cell and the neighbor burst + if ( PbcchN.time_alignmt >= 8*TN_WIDTH) + { + PbcchN.time_alignmt -= 8*TN_WIDTH; + PbcchN.fn_offset --; + } + else + if ( PbcchN.time_alignmt < 0) + { + PbcchN.time_alignmt += 8*TN_WIDTH; + PbcchN.fn_offset ++; + } + + // Set "change_synchro" flag to trigger L1S to change the synchro on fly + // within PBCCHN and to restore current synchro when PBCCHN task is completed. + if (PbcchN.time_alignmt >= 4 * TN_WIDTH) + { + PbcchN.time_alignmt -= 4 * TN_WIDTH; + PbcchN.change_synchro = TRUE; + } + else + PbcchN.change_synchro = FALSE; + + // In case of packet transfer mode + if (l1a_l1s_com.mode == PACKET_TRANSFER_MODE) + { + // Enable Packet Transfer PBCCHN task + l1a_l1s_com.l1s_en_task[PBCCHN_TRAN] = TASK_ENABLED; + + } + // in case of Idle mode + else + { + // Enable IDLE PBCCHN task + l1a_l1s_com.l1s_en_task[PBCCHN_IDLE] = TASK_ENABLED; + } + + // Step in state machine. + *state = WAIT_PBCCHN_RESULT; + + // End of process. + end_process = 1; + } + break; + + case WAIT_PBCCHN_RESULT: + { + if(SignalCode == L1P_PBCCHN_INFO) + // Serving cell BCCH reading result. + //---------------------------------- + { + // Forward result message to L3. + l1a_send_result(MPHP_NCELL_PBCCH_IND, msg, GRRM1_QUEUE); + + // This process must be reset. + *state = RESET; + } + + else + if(SignalCode == MPHP_NCELL_PBCCH_REQ) + // Request to re-configure PBCCH reading. + //-------------------------------------- + { + // Step in state machine. + *state = WAIT_PBCCHN_CONFIG; + } + + else + if(SignalCode == MPHP_NCELL_PBCCH_STOP_REQ) + // Request to STOP any serving cell pbcch activity. + //------------------------------------------------ + { + // Send confirmation message to L3. + l1a_send_confirmation(MPHP_NCELL_PBCCH_STOP_CON,GRRM1_QUEUE); + + // This process must be reset. + *state = RESET; + } + else + // End of packet transfer mode: test PDTCH to be sure that TBF downlink and uplink are released + if((SignalCode == L1P_TBF_RELEASED) && (((T_L1P_TBF_RELEASED *)(msg->SigP))->released_all)) + { + // This process must be reset. + *state = RESET; + } + else + if ((SignalCode == L1P_TRANSFER_DONE) || (SignalCode == L1P_TBF_RELEASED) || //change of Time Slot + (SignalCode == L1P_REPEAT_ALLOC_DONE) || (SignalCode == L1P_ALLOC_EXHAUST_DONE)) + { + // We consider only the case: packet Transfer => packet Transfer,the serving TS may be changed + // For other cases such as Idle -> Transfer... decision not yet taken. + + // update the PBCCHN parameters + // Clear PBCCHN_TRAN task disable flag. + l1a_l1s_com.l1s_en_task[PBCCHN_TRAN] = TASK_DISABLED; + + // Set semaphores for Neighbor Cell PBCCH reading task. + l1a_l1s_com.task_param[PBCCHN_TRAN] = SEMAPHORE_SET; + + // update the PBCCHN parameters + *state = PBCCHN_CONFIG;// Step in state machine. + } + else + // No action in this machine for other messages. + //---------------------------------------------- + { + // End of process. + return; + } + } + break; + } // end of "switch". + } // end of "while" +} // end of procedure. + + + +/*-------------------------------------------------------*/ +/* l1pa_tcr_meas_process() */ +/*-------------------------------------------------------*/ +/* Description : This state machine handles Neigbor cell */ +/* measurement process in Packet Transfer mode. */ +/* Measurement are made on a specified frequency list. */ +/* The process is started automatically by L1 (on receipt*/ +/* of a L1P_TRANSFER_DONE message from L1S) and doesn't */ +/* need to receive any message from L3. */ +/* In order to update the frequency list, a */ +/* MHPC_TCR_MEAS_REQ msg will be sent from L3 to L1 */ +/* */ +/* Starting messages: L1P_TRANSFER_DONE */ +/* ------------------ */ +/* L1 starts then measures on carriers specified in the */ +/* frequency list. Measures are performed on every */ +/* frames with the occurence of 1 measure per frame */ +/* */ +/* Subsequent messages: MPHP_TCR_MEAS_REQ */ +/* -------------------- */ +/* The update is not done asap but postponed until the */ +/* end of the reporting period. Frequency list is */ +/* updated with the new list. */ +/* */ +/* Result messages (input): L1P_TRANSFER_MEAS_DONE */ +/* ------------------------ */ +/* This is the periodic reporting message sent by L1S. */ +/* The reporting is done every "reporting period". */ +/* The beguining of the reporting period is arbitrary */ +/* and starts when the Neigh Meas task is enabled. */ +/* */ +/* Result messages (output): MPHP_TCR_MEAS_IND */ +/* ------------------------- */ +/* This is the periodic reporting message to L3. */ +/* */ +/* Reset messages (input): MPHP_TCR_MEAS_STOP_REQ */ +/* ----------------------- */ +/* Frequency list neigbor cell measurement process in */ +/* Packet Transfer mode is stopped by this message. */ +/* */ +/*-------------------------------------------------------*/ +void l1pa_tcr_meas_process(xSignalHeaderRec *msg) +{ + enum states + { + RESET = 0, + WAIT_INIT = 1, + WAIT_RESULT = 3 + + }; + + UWORD8 *state = &l1pa.state[TCR_MEAS]; + UWORD32 SignalCode = msg->SignalCode; + UWORD8 i; + UWORD8 list_size; + T_CRES_LIST_PARAM *free_list; + + BOOL end_process = 0; + while(!end_process) + { + switch(*state) + { + case RESET: + { + // step in state machine. + *state = WAIT_INIT; + + // Reset TCR_MEAS process. + l1pa_l1ps_com.l1ps_en_meas &= P_TCRMS_MEAS_MASK; // Disable Neighbour Measurement task. + } + break; + + case WAIT_INIT: + { + if(SignalCode == L1P_TRANSFER_DONE) + // We enter in Packet Transfer mode. + //--------------------------------- + { + #if (CODE_VERSION != SIMULATION) + //no meas when entering in Transfer if no BA list initialized + //stay in this state and wait for a MPHP_TCR_MEAS_REQ from L3 + if((l1pa_l1ps_com.cres_freq_list.alist->nb_carrier == 0) && + (l1pa_l1ps_com.tcr_freq_list.new_list_present == FALSE) && (l1a_l1s_com.ba_list.nbr_carrier == 0)) + return; + #endif + // Set parameter synchro semaphore for P_TCRMS_MEAS task. + l1pa_l1ps_com.meas_param |= P_TCRMS_MEAS; + + // Reset Neighbour Cell measurement parameters. + l1pa_l1ps_com.tcr_freq_list.tcr_next_to_ctrl = 0; + l1pa_l1ps_com.tcr_freq_list.tcr_next_to_read = 0; + l1pa_l1ps_com.tcr_freq_list.last_stored_tcr_to_read = 0; + l1pa_l1ps_com.tcr_freq_list.first_pass_flag = TRUE; + + // Initialize counter used to report measurements + l1pa_l1ps_com.tcr_freq_list.cres_meas_report = 0; + + + // If no Packet Idle phase has been done and no BA(GPRS) list has been + // downloaded, init BA(GPRS) list with BA list used in CS Idle mode. + if((l1pa_l1ps_com.cres_freq_list.alist->nb_carrier == 0) && + (l1pa_l1ps_com.tcr_freq_list.new_list_present == FALSE)) + { + // Get Ptr to the free Neighbour meas list. + // The number of carriers in the list and the list + // identification are initialized. + free_list = l1pa_get_free_cres_list_set(); + + // Download new list within T_CRES_LIST_PARAM structure. + free_list->nb_carrier = l1a_l1s_com.ba_list.nbr_carrier; + + for(i = 0; i < free_list->nb_carrier; i++) + { + free_list->freq_list[i] = l1a_l1s_com.ba_list.A[i].radio_freq; + } + + free_list->list_id = l1a_l1s_com.ba_list.ba_id; + + // Set "flist" with Circuit Swithed BA frequency list parameters + l1pa_l1ps_com.cres_freq_list.alist = free_list; + } + + // Reset flags. + l1pa_l1ps_com.tcr_freq_list.ms_ctrl = 0; + l1pa_l1ps_com.tcr_freq_list.ms_ctrl_d = 0; + l1pa_l1ps_com.tcr_freq_list.ms_ctrl_dd = 0; + + // Reset measures made on beacon frequency. + l1pa_l1ps_com.tcr_freq_list.beacon_meas = 0; + + // Enable Packet Transfer Neighbour Measurement task. + l1pa.l1pa_en_meas[TCR_MEAS] |= P_TCRMS_MEAS; + + // step in state machine. + *state = WAIT_RESULT; + } + else + if(SignalCode == MPHC_RXLEV_PERIODIC_REQ) + // We receive the BA list to be monitored in Idle mode + //---------------------------------------------------- + { + // When enter in Transfer the Idle list must be used + // =>reset the packet Transfert list in order to use the Idle list + l1pa_l1ps_com.cres_freq_list.alist->nb_carrier = 0; + l1pa_l1ps_com.tcr_freq_list.new_list_present = FALSE; + } + else + if(SignalCode == MPHP_TCR_MEAS_REQ) + // Restart Packet Transfer measurement in TBF after + // MPHP_TCR_MEAS_STOP_REQ + // ### Check reason why was missing (s921_bis note)... + //---------------------------------------------------- + { + + // Set parameter synchro semaphore for P_TCRMS_MEAS task. + l1pa_l1ps_com.meas_param |= P_TCRMS_MEAS; + + free_list = l1pa_get_free_cres_list_set(); + + + // Download new list within T_CRES_LIST_PARAM structure. + free_list->nb_carrier = ((T_MPHP_TCR_MEAS_REQ *)(msg->SigP))->nb_carrier; + + for(i = 0; i < free_list->nb_carrier; i++) + { + free_list->freq_list[i] = ((T_MPHP_TCR_MEAS_REQ *)(msg->SigP))->radio_freq_no[i]; + } + + free_list->list_id = ((T_MPHP_TCR_MEAS_REQ *)(msg->SigP))->list_id; + + // Set "flist" with Circuit Swithed BA frequency list parameters + l1pa_l1ps_com.cres_freq_list.alist = free_list; + + // Reset Neighbour Cell measurement parameters. + l1pa_l1ps_com.tcr_freq_list.tcr_next_to_ctrl = 0; + l1pa_l1ps_com.tcr_freq_list.tcr_next_to_read = 0; + l1pa_l1ps_com.tcr_freq_list.last_stored_tcr_to_read = 0; + l1pa_l1ps_com.tcr_freq_list.first_pass_flag = TRUE; + + // Initialize counter used to report measurements + l1pa_l1ps_com.tcr_freq_list.cres_meas_report = 0; + + // Reset flags. + l1pa_l1ps_com.tcr_freq_list.ms_ctrl = 0; + l1pa_l1ps_com.tcr_freq_list.ms_ctrl_d = 0; + l1pa_l1ps_com.tcr_freq_list.ms_ctrl_dd = 0; + + // Reset measures made on beacon frequency. + l1pa_l1ps_com.tcr_freq_list.beacon_meas = 0; + + // Enable Packet Transfer Neighbour Measurement task. + l1pa.l1pa_en_meas[TCR_MEAS] |= P_TCRMS_MEAS; + + // step in state machine. + *state = WAIT_RESULT; + } + + // End of process. + end_process = 1; + } + break; + + case WAIT_RESULT: + { + switch(SignalCode) + { + case L1P_TCR_MEAS_DONE: + // One reporting period has been completed. A set of measures is forward to L3. + //----------------------------------------------------------------------------- + { + // Forward result message to L3. + l1a_send_result(MPHP_TCR_MEAS_IND, msg, GRRM1_QUEUE); + + // End of process. + end_process = 1; + } + break; + + case MPHP_TCR_MEAS_REQ: + // Update of the parameters are postponed until end of the reporting period. + // Parameters are saved in a double buffer. + { + // Reset present flag to avoid to mix 2 updates in case of + // an update already pending within "l1pa_l1ps_com.cres_freq_list.flist". + l1pa_l1ps_com.tcr_freq_list.new_list_present = FALSE; + + // Get Ptr to the free Neighbour meas list. + // The number of carriers in the list and the list + // identification are initialized. + free_list = l1pa_get_free_cres_list_set(); + + + // Download new list within T_CRES_LIST_PARAM structure. + list_size = ((T_MPHP_TCR_MEAS_REQ *)(msg->SigP))->nb_carrier; + free_list->nb_carrier = list_size; + + for(i = 0; i < list_size; i++) + { + free_list->freq_list[i] = ((T_MPHP_TCR_MEAS_REQ *)(msg->SigP))->radio_freq_no[i]; + } + + free_list->list_id = ((T_MPHP_TCR_MEAS_REQ *)(msg->SigP))->list_id; + + // Set "flist" with new set of frequency list parameter + l1pa_l1ps_com.cres_freq_list.flist = free_list; + + // Set present flag only when the list has been downloaded. + l1pa_l1ps_com.tcr_freq_list.new_list_present = TRUE; + + // End of process. + end_process = 1; + } + break; + + case L1P_TBF_RELEASED: + { + // Test if all TBF have been released + // Then stop Neighbour Measurement process + if(((T_L1P_TBF_RELEASED *)(msg->SigP))->released_all) + { + // This process must be reset. + *state = RESET; + } + else + { + return; + } + } + break; + + case MPHP_TCR_MEAS_STOP_REQ: + // Note: A TBF stop do not imply a stop of the Neighbour Measurement process. + // L3 has to send a MPHP_TCR_MEAS_STOP message to stop the measurement process. + { + // send confirmation message + l1a_send_confirmation(MPHP_TCR_MEAS_STOP_CON,GRRM1_QUEUE); + + // This process must be reset. + *state = RESET; + } + break; + + default: + // No action in this machine for other messages. + // Note: No action is performed on receipt of a L1P_TRANSFER_DONE + // message. However a SYNCHRO task is programmed, which implies + // a reset of measures related to the Serving Cell (cf. L1S). + //-------------------------------------------------------------- + { + return; + } + } // end of switch(SignalCode) + } + break; + } // end of "switch". + } // end of "while" +} // end of procedure. + +/*-------------------------------------------------------*/ +/* l1pa_idle_interference_meas_process() */ +/*-------------------------------------------------------*/ +/* Description : */ +/* */ +/* Starting messages: MPHP_INT_MEAS_REQ */ +/* */ +/* This message requests signal strength measurements */ +/* on several channels of a specific carrier. */ +/* Measurements must be done on one search frame and one */ +/* PTCCH frame. */ +/* */ +/* Result messages (input): L1PS_ITMEAS_IND */ +/* */ +/* This message is reported to L1A when signal strength */ +/* has been measured on one idle frame (PTCCH or search) */ +/* */ +/* Result messages (output): MPHP_INT_MEAS_IND */ +/* */ +/* This message is reported to L3 when measurements have */ +/* been done on two contiguous idle frames */ +/* */ +/* Reset message (input): MPHP_INT_MEAS_STOP_REQ */ +/* */ +/* Interference measurement processing is stopped by */ +/* this message */ +/*-------------------------------------------------------*/ +void l1pa_idle_interference_meas_process(xSignalHeaderRec *msg) +{ + enum states + { + RESET = 0, + WAIT_INIT = 1, + WAIT_1ST_RESULT = 2, + WAIT_2ND_RESULT = 3 + }; + + static T_L1A_INT_MEAS_PARAM int_meas_param; + UWORD8 *state = &l1pa.state[PI_INT_MEAS]; + UWORD32 SignalCode = msg->SignalCode; + + BOOL end_process = 0; + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Step in state machine. + *state = WAIT_INIT; + + // Reset ITMEAS process. + l1a_l1s_com.l1s_en_task[ITMEAS] = TASK_DISABLED; // Clear ITMEAS task enable flag. + } + break; + + case WAIT_INIT: + { + // Interference measurement request + //--------------------------------- + if (SignalCode == MPHP_INT_MEAS_REQ) + { + UWORD8 bitmap,i; + + // Set semaphore + l1a_l1s_com.task_param[ITMEAS] = SEMAPHORE_SET; + + // Download message content + l1pa_l1ps_com.itmeas.packet_intm_freq_param = ((T_MPHP_INT_MEAS_REQ *)(msg->SigP))->packet_intm_freq_param; + l1pa_l1ps_com.itmeas.multislot_class = ((T_MPHP_INT_MEAS_REQ *)(msg->SigP))->multislot_class; + int_meas_param.id = ((T_MPHP_INT_MEAS_REQ *)(msg->SigP))->carrier_id; + + // Processing of the 2 possible measurement bitmaps + //------------------------------------------------- + + // 1- Without Rx on the frame before + + l1pa_l1ps_com.itmeas.idle_tn_no_rx = ((T_MPHP_INT_MEAS_REQ *)(msg->SigP))->tn; + + // Trb respect after measurements + // We consider that the timeslot on which the Layer 1 is synchronized is + // always allocated on the frame after the idle frame. + // For the Trb multi-slot class parameter respect, we must clear the bits at + // the right of the interference measurement bitmap + l1pa_l1ps_com.itmeas.idle_tn_no_rx &= (UWORD8) + ~( 0xFF + >> ( 8 + l1a_l1s_com.dl_tn + - MS_CLASS[l1pa_l1ps_com.itmeas.multislot_class].trb)); + + // 2- With a Rx programmed on the frame before + // Note: This Rx is always on the dl_tn + + l1pa_l1ps_com.itmeas.idle_tn_rx = l1pa_l1ps_com.itmeas.idle_tn_no_rx; + + // Trb respect before measurements + // The timeslot on which the Layer 1 is synchronized is allocated on the frame + // before the idle frame. + // For the Trb multi-slot class parameter respect, we must clear the bits at + // the left of the interference measurement bitmap + bitmap = 0x80; + + i = 8 - l1a_l1s_com.dl_tn - MS_CLASS[l1pa_l1ps_com.itmeas.multislot_class].trb; + if (i > 8) + bitmap >>= (-i); + else + bitmap <<= i; + + for (i = 1; i<= MS_CLASS[l1pa_l1ps_com.itmeas.multislot_class].trb; i++) + { + l1pa_l1ps_com.itmeas.idle_tn_rx &= (UWORD8) ~bitmap; + bitmap <<= 1; + } + + // Initialize parameters + l1pa_l1ps_com.itmeas.position = ANY_IDLE_FRAME; // First measurement on any idle frame + + // Enable synchronous task + l1a_l1s_com.l1s_en_task[ITMEAS] = TASK_ENABLED; + + // Step in state machine + *state = WAIT_1ST_RESULT; + + // End of process + end_process = 1; + } + + // No action in this machine for other messages. + else + { + // End of process. + end_process = 1; + } + } + break; + + case WAIT_1ST_RESULT: + { + // Reporting of 1st measurement session + //------------------------------------- + if (SignalCode == L1P_ITMEAS_IND) + { + UWORD8 i; + + // Set semaphore + l1a_l1s_com.task_param[ITMEAS] = SEMAPHORE_SET; + + // Save interference measurements + for(i=0; i<8; i++) + int_meas_param.rxlev[i] = ((T_L1P_ITMEAS_IND *)(msg->SigP))->rxlev[i]; + + // Save bitmap + int_meas_param.meas_bitmap = ((T_L1P_ITMEAS_IND *)(msg->SigP))->meas_bitmap; + + // Save reported fn + int_meas_param.fn = ((T_L1P_ITMEAS_IND *)(msg->SigP))->fn; + + // Position = complement of reported position + if (((T_L1P_ITMEAS_IND *)(msg->SigP))->position == PTCCH_FRAME) + l1pa_l1ps_com.itmeas.position = SEARCH_FRAME; + else + l1pa_l1ps_com.itmeas.position = PTCCH_FRAME; + + // Enable ITMEAS + l1a_l1s_com.l1s_en_task[ITMEAS] = TASK_ENABLED; + + // Step in state machine + *state = WAIT_2ND_RESULT; + + // End of process + return; + } + + else + if (SignalCode == MPHP_INT_MEAS_STOP_REQ) + { + // Send confirmation + l1a_send_confirmation(MPHP_INT_MEAS_STOP_CON,GRRM1_QUEUE); + + // Reset process + *state = RESET; + } + + // No action in this machine for other messages. + else + { + // End of process + return; + } + } + break; + + case WAIT_2ND_RESULT: + { + // Reporting subsequent measurement session + //----------------------------------------- + if (SignalCode == L1P_ITMEAS_IND) + { + // At least one measurement session has already been reported + //----------------------------------------------------------- + UWORD32 reported_fn; + + // Check fn + // The two measurement sessions must be done in two contiguous idle frames + + // Modulo + if (((T_L1P_ITMEAS_IND *)(msg->SigP))->fn < int_meas_param.fn) + { + reported_fn = ((T_L1P_ITMEAS_IND *)(msg->SigP))->fn + MAX_FN; + } + else + { + reported_fn = ((T_L1P_ITMEAS_IND *)(msg->SigP))->fn; + } + + // The two last measurement sessions are enough close + if ((reported_fn - int_meas_param.fn) == 13) + { + // Build and send result msg to L3. + l1pa_send_int_meas_report(MPHP_INT_MEAS_IND, + ((T_L1P_ITMEAS_IND *)(msg->SigP)), + &int_meas_param); + + // Only one measurement session per request + *state = RESET; + } + + // The two last measurement sessions aren't enough close + else + { + // 1st measurement result is no more valid, second result + // must replace it: this is achieved by WAIT_1ST_RESULT state!!! + + // Step in state machine + *state = WAIT_1ST_RESULT; + } + } + + else + if (SignalCode == MPHP_INT_MEAS_STOP_REQ) + { + // Send confirmation + l1a_send_confirmation(MPHP_INT_MEAS_STOP_CON,GRRM1_QUEUE); + + // Reset process + *state = RESET; + } + + // No action in this machine for other messages. + else + { + // End of process + return; + } + } + break; + + } // End of "switch" + } // End of "while" +} // End of "procedure" + +/*-------------------------------------------------------*/ +/* l1pa_transfer_interference_meas_process() */ +/*-------------------------------------------------------*/ +/* Description : */ +/* */ +/* Starting messages: L1P_TRANFSER_DONE */ +/* */ +/* Interference measurement processing starts each time */ +/* a new starting time occurs if the interference */ +/* measurements are enabled */ +/* Measurements must be done on one search frame and one */ +/* PTCCH frame. */ +/* */ +/* Result messages (input): L1PS_ITMEAS_IND */ +/* */ +/* This message is reported to L1A when signal strength */ +/* has been measured on one idle frame (PTCCH or search) */ +/* */ +/* Result messages (output): MPHP_TINT_MEAS_IND */ +/* */ +/* This message is reported to L3 when measurements have */ +/* been done on two idle frames as close as possible */ +/* */ +/* Reset message (input): L1P_TBF_RELEASED */ +/* */ +/* Interference measurement processing is stopped when */ +/* all TBF are released */ +/*-------------------------------------------------------*/ +void l1pa_transfer_interference_meas_process(xSignalHeaderRec *msg) +{ + /* Bitmaps used for the processing of full_allocation */ + /*----------------------------------------------------*/ + const UWORD8 FULL_ALLOCATION[9]= +{ + 0x00, + 0x80, + 0xc0, + 0xe0, + 0xf0, + 0xf8, + 0xfc, + 0xfe, + 0xff + }; + + enum states + { + RESET = 0, + WAIT_INIT = 1, + CONFIG = 2, + WAIT_1ST_RESULT = 3, + WAIT_2ND_RESULT = 4 + }; + + static T_L1A_INT_MEAS_PARAM int_meas_param; + UWORD8 *state = &l1pa.state[PT_INT_MEAS]; + UWORD32 SignalCode = msg->SignalCode; + + BOOL end_process = 0; + while(!end_process) + { + switch(*state) + { + case RESET: + { + // Step in state machine. + *state = WAIT_INIT; + + // Reset ITMEAS process. + l1a_l1s_com.l1s_en_task[ITMEAS] = TASK_DISABLED; // Clear ITMEAS task enable flag. + } + break; + + case WAIT_INIT: + { + // New channel assignment + //----------------------- + if ((SignalCode == L1P_TRANSFER_DONE) || (SignalCode == L1P_REPEAT_ALLOC_DONE) || + (SignalCode == L1P_ALLOC_EXHAUST_DONE)) + { + *state = CONFIG; + } + + // No action in this machine for other messages. + else + { + // End of process. + return; + } + } + break; + + case CONFIG: + { + // Rise transfert parameter semaphore to prevent L1S to use partial configuration. + l1pa_l1ps_com.transfer.semaphore = TRUE; + + // If the interference measurements are disabled + if (l1pa_l1ps_com.transfer.aset->interf_meas_enable == FALSE) + { + *state = WAIT_INIT; + } + else + { + // Set semaphore + l1a_l1s_com.task_param[ITMEAS] = SEMAPHORE_SET; + + // Initialize parameters + l1pa_l1ps_com.itmeas.position = ANY_IDLE_FRAME; // First measurement on any idle frame + + // Save assignment ID for the interference measurements reporting message + int_meas_param.id = l1pa_l1ps_com.transfer.aset->assignment_id; + + // Processing of the measurement bitmap + l1pa_l1ps_com.itmeas.meas_bitmap = (UWORD8) + FULL_ALLOCATION[MS_CLASS[l1pa_l1ps_com.transfer.aset->multislot_class].rx] >> + l1a_l1s_com.dl_tn; + + // Enable synchronous task + l1a_l1s_com.l1s_en_task[ITMEAS] = TASK_ENABLED; + + // Step in state machine + *state = WAIT_1ST_RESULT; + } + + // Clear transfer parameter semaphore to let L1S use the new parameters. + l1pa_l1ps_com.transfer.semaphore = FALSE; + + // End of process. + end_process = 1; + } + break; + + case WAIT_1ST_RESULT: + { + // Reporting of 1st measurement session + //------------------------------------- + if (SignalCode == L1P_ITMEAS_IND) + { + UWORD8 i; + + // Set semaphore + l1a_l1s_com.task_param[ITMEAS] = SEMAPHORE_SET; + + // Save interference measurements + for(i=0; i<8; i++) + int_meas_param.rxlev[i] = ((T_L1P_ITMEAS_IND *)(msg->SigP))->rxlev[i]; + + // Save bitmap + int_meas_param.meas_bitmap = ((T_L1P_ITMEAS_IND *)(msg->SigP))->meas_bitmap; + + // Save reported fn + int_meas_param.fn = ((T_L1P_ITMEAS_IND *)(msg->SigP))->fn; + + // Position = complement of reported position + if (((T_L1P_ITMEAS_IND *)(msg->SigP))->position == PTCCH_FRAME) + l1pa_l1ps_com.itmeas.position = SEARCH_FRAME; + else + l1pa_l1ps_com.itmeas.position = PTCCH_FRAME; + + // Enable ITMEAS + l1a_l1s_com.l1s_en_task[ITMEAS] = TASK_ENABLED; + + // Step in state machine + *state = WAIT_2ND_RESULT; + + // End of process + return; + } + + else + if (SignalCode == L1P_TRANSFER_DONE) + // The starting time of a new TBF occurs + { + // Reset process + *state = RESET; + } + + else + if (SignalCode == L1P_TBF_RELEASED) + // A TBF has been released + { + // No remaining TBF + if(((T_L1P_TBF_RELEASED *)(msg->SigP))->released_all) + { + // Reset process + *state = RESET; + } + else + { + // Enable a new measurement session + *state = CONFIG; + } + } + + else + if (SignalCode == L1P_PDCH_RELEASED) + // PDCH have been released + { + // Enable a new measurement session + *state = CONFIG; + } + + // No action in this machine for other messages. + else + { + // End of process + return; + } + } + break; + + case WAIT_2ND_RESULT: + { + // Reporting subsequent measurement session + //----------------------------------------- + if (SignalCode == L1P_ITMEAS_IND) + { + // At least one measurement session has already been reported + //----------------------------------------------------------- + UWORD32 reported_fn; + + // Check fn + // The two measurement sessions must be done in two contiguous idle frames + + // Modulo + if (((T_L1P_ITMEAS_IND *)(msg->SigP))->fn < int_meas_param.fn) + { + reported_fn = ((T_L1P_ITMEAS_IND *)(msg->SigP))->fn + MAX_FN; + } + else + { + reported_fn = ((T_L1P_ITMEAS_IND *)(msg->SigP))->fn; + } + + // The two last measurement sessions are enough close + if ((reported_fn - int_meas_param.fn) <= 104) + { + // Build and send result msg to L3. + l1pa_send_int_meas_report(MPHP_TINT_MEAS_IND, + ((T_L1P_ITMEAS_IND *)(msg->SigP)), + &int_meas_param); + + // Enable a new measurement session + *state = CONFIG; + } + + // The two last measurement sessions aren't enough close + else + { + // 1st measurement result is no more valid, second result + // must replace it: this is achieved by WAIT_1ST_RESULT state!!! + + // Step in state machine + *state = WAIT_1ST_RESULT; + } + } + + else + + // New channel assignment + //----------------------- + if ((SignalCode == L1P_TRANSFER_DONE) || (SignalCode == L1P_REPEAT_ALLOC_DONE) || + (SignalCode == L1P_ALLOC_EXHAUST_DONE)) + { + // Reset process + *state = RESET; + } + + else + if (SignalCode == L1P_TBF_RELEASED) + // A TBF has been released + { + // No remaining TBF + if(((T_L1P_TBF_RELEASED *)(msg->SigP))->released_all) + { + // Reset process + *state = RESET; + } + else + { + // Enable a new measurement session + *state = CONFIG; + } + } + + else + if (SignalCode == L1P_PDCH_RELEASED) + // PDCH have been released + { + // Enable a new measurement session + *state = CONFIG; + } + + // No action in this machine for other messages. + else + { + // End of process + return; + } + } + break; + + } // End of "switch" + } // End of "while" +} // End of "procedure" +//#pragma DUPLICATE_FOR_INTERNAL_RAM_START +#endif +//#pragma DUPLICATE_FOR_INTERNAL_RAM_END