src/phy_stub/l1_bdy1.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /*This file contains stub for PHY to handle messages to/from MAC CL */
  20
  21 #include <stdint.h>
  22
  23 #include "envdep.h"
  24 #include "gen.h"
  25 #include "ssi.h"
  26
  27 #include "gen.x"
  28 #include "ssi.x"
  29
  30 #include "rg_cl_phy.h"
  31 #include "lwr_mac.h"
  32 #ifdef FAPI
  33 #include "fapi.h"
  34 #endif
  35 #include "lphy_stub.h"
  36
  37 #define MAX_SLOT_VALUE   9
  38 #define MAX_SFN_VALUE    1023
  39
  40 uint16_t sfnValue = 0;
  41 uint16_t slotValue = 0;
  42 EXTERN void phyToMac ARGS((uint16_t msgType, uint32_t msgLen,void *msg));
  43 #ifdef FAPI
  44 EXTERN void fillTlvs ARGS((fapi_uint16_tlv_t *tlv, uint16_t tag, uint16_t
  45 length, uint16_t value, uint32_t *msgLen));
  46 EXTERN void fillMsgHeader ARGS((fapi_msg_t *hdr, uint16_t msgType, uint16_t msgLen));
  47 #endif
  48 EXTERN void sendToLowerMac ARGS((uint16_t msgType, uint32_t msgLen,void *msg));
  49 EXTERN void handlePhyMessages ARGS((void *msg));
  50
  51 /*******************************************************************
  52  *
  53  * @brief Builds and sends param response to MAC CL
  54  *
  55  * @details
  56  *
  57  *    Function : l1BldAndSndParamRsp
  58  *
  59  *    Functionality:
  60  *          - Builds and sends param response to MAC
  61  *
  62  * @params[in] Config request message pointer
  63  * @return ROK     - success
  64  *         RFAILED - failure
  65  *
  66  * ****************************************************************/
  67 S16 l1BldAndSndParamRsp(void *msg)
  68 {
  69 #ifdef FAPI
  70    uint8_t index = 0;
  71    uint32_t msgLen = 0;
  72         fapi_param_resp_t *fapiParamRsp = (fapi_param_resp_t *)msg;
  73
  74   /* Cell Params */
  75   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_RELEASE_CAPABILITY_TAG,                          sizeof(uint16_t), 1, &msgLen);
  76   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PHY_STATE_TAG,                                   sizeof(uint16_t), 0, &msgLen);
  77   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_SKIP_BLANK_DL_CONFIG_TAG,                        sizeof(uint8_t),  0, &msgLen);
  78   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_SKIP_BLANK_UL_CONFIG_TAG,                        sizeof(uint8_t),  0, &msgLen);
  79   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_NUM_CONFIG_TLVS_TO_REPORT_TYPE_TAG,              sizeof(uint8_t),  0, &msgLen);
  80
  81   /* Carrier Params */
  82   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_CYCLIC_PREFIX_TAG,                               sizeof(uint8_t),  1, &msgLen);
  83   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_SUPPORTED_SUBCARRIER_SPACING_DL_TAG,             sizeof(uint8_t),  1, &msgLen);
  84   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_SUPPORTED_BANDWIDTH_DL_TAG,                      sizeof(uint16_t), 1, &msgLen);
  85   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_SUPPORTED_SUBCARRIER_SPACING_UL_TAG,             sizeof(uint8_t),  0, &msgLen);
  86   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_SUPPORTED_BANDWIDTH_UL_TAG,                      sizeof(uint16_t), 0, &msgLen);
  87
  88   /* PDCCH Param*/
  89   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_CCE_MAPPING_TYPE_TAG,                            sizeof(uint8_t), 0, &msgLen);
  90   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_CORESET_OUTSIDE_FIRST_3_OFDM_SYMS_OF_SLOT_TAG,   sizeof(uint8_t), 0, &msgLen);
  91   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PRECODER_GRANULARITY_CORESET_TAG,                sizeof(uint8_t), 0, &msgLen);
  92   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PDCCH_MU_MIMO_TAG,                               sizeof(uint8_t), 0, &msgLen);
  93   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PDCCH_PRECODER_CYCLING_TAG,                      sizeof(uint8_t), 0, &msgLen);
  94   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_MAX_PDCCHS_PER_SLOT_TAG,                         sizeof(uint8_t), 0, &msgLen);
  95
  96   /* PUCCH Param */
  97   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PUCCH_FORMATS_TAG,                               sizeof(uint8_t), 0, &msgLen);
  98   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_MAX_PUCCHS_PER_SLOT_TAG,                         sizeof(uint8_t), 0, &msgLen);
  99
 100   /* PDSCH Param */
 101   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PDSCH_MAPPING_TYPE_TAG,                          sizeof(uint8_t), 0, &msgLen);
 102   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PDSCH_ALLOCATION_TYPES_TAG,                      sizeof(uint8_t), 0, &msgLen);
 103   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PDSCH_VRB_TO_PRB_MAPPING_TAG,                    sizeof(uint8_t), 0, &msgLen);
 104   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PDSCH_CBG_TAG,                                   sizeof(uint8_t), 0, &msgLen);
 105   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PDSCH_DMRS_CONFIG_TYPES_TAG,                     sizeof(uint8_t), 0, &msgLen);
 106   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PDSCH_DMRS_MAX_LENGTH_TAG,                       sizeof(uint8_t), 0, &msgLen);
 107   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PDSCH_DMRS_ADDITIONAL_POS_TAG,                   sizeof(uint8_t), 0, &msgLen);
 108   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_MAX_PDSCHS_TBS_PER_SLOT_TAG,                     sizeof(uint8_t), 0, &msgLen);
 109   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_MAX_NUMBER_MIMO_LAYERS_PDSCH_TAG,                sizeof(uint8_t), 0, &msgLen);
 110   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_SUPPORTED_MAX_MODULATION_ORDER_DL_TAG,           sizeof(uint8_t), 0, &msgLen);
 111   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_MAX_MU_MIMO_USERS_DL_TAG,                        sizeof(uint8_t), 0, &msgLen);
 112   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PDSCH_DATA_IN_DMRS_SYMBOLS_TAG,                  sizeof(uint8_t), 0, &msgLen);
 113   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PREMPTIONSUPPORT_TAG,                            sizeof(uint8_t), 0, &msgLen);
 114   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PDSCH_NON_SLOT_SUPPORT_TAG,                      sizeof(uint8_t), 0, &msgLen);
 115
 116   /* PUSCH Param */
 117   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_UCI_MUX_ULSCH_IN_PUSCH_TAG,                      sizeof(uint8_t), 0, &msgLen);
 118   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_UCI_ONLY_PUSCH_TAG,                              sizeof(uint8_t), 0, &msgLen);
 119   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PUSCH_FREQUENCY_HOPPING_TAG,                     sizeof(uint8_t), 0, &msgLen);
 120   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PUSCH_DMRS_CONFIG_TYPES_TAG,                     sizeof(uint8_t), 0, &msgLen);
 121   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PUSCH_DMRS_MAX_LEN_TAG,                          sizeof(uint8_t), 0, &msgLen);
 122   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PUSCH_DMRS_ADDITIONAL_POS_TAG,                   sizeof(uint8_t), 0, &msgLen);
 123   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PUSCH_CBG_TAG,                                   sizeof(uint8_t), 0, &msgLen);
 124   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PUSCH_MAPPING_TYPE_TAG,                          sizeof(uint8_t), 0, &msgLen);
 125   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PUSCH_ALLOCATION_TYPES_TAG,                      sizeof(uint8_t), 0, &msgLen);
 126   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PUSCH_VRB_TO_PRB_MAPPING_TAG,                    sizeof(uint8_t), 0, &msgLen);
 127   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PUSCH_MAX_PTRS_PORTS_TAG,                        sizeof(uint8_t), 0, &msgLen);
 128   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_MAX_PDUSCHS_TBS_PER_SLOT_TAG,                    sizeof(uint8_t), 0, &msgLen);
 129   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_MAX_NUMBER_MIMO_LAYERS_NON_CB_PUSCH_TAG,         sizeof(uint8_t), 0, &msgLen);
 130   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_SUPPORTED_MODULATION_ORDER_UL_TAG,               sizeof(uint8_t), 0, &msgLen);
 131   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_MAX_MU_MIMO_USERS_UL_TAG,                        sizeof(uint8_t), 0, &msgLen);
 132   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_DFTS_OFDM_SUPPORT_TAG,                           sizeof(uint8_t), 0, &msgLen);
 133   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PUSCH_AGGREGATION_FACTOR_TAG,                    sizeof(uint8_t), 0, &msgLen);
 134
 135   /* PRACH Params */
 136   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PRACH_LONG_FORMATS_TAG,                          sizeof(uint8_t), 0, &msgLen);
 137   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PRACH_SHORT_FORMATS_TAG,                         sizeof(uint8_t), 0, &msgLen);
 138   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PRACH_RESTRICTED_SETS_TAG,                       sizeof(uint8_t), 0, &msgLen);
 139   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_MAX_PRACH_FD_OCCASIONS_IN_A_SLOT_TAG,            sizeof(uint8_t), 0, &msgLen);
 140
 141   /* MEASUREMENT TAG */
 142   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_RSSI_MEASUREMENT_SUPPORT_TAG,                    sizeof(uint8_t), 0, &msgLen);
 143
 144   fapiParamRsp->number_of_tlvs = index;
 145   msgLen = msgLen + sizeof(fapi_param_resp_t);
 146
 147   fillMsgHeader(&fapiParamRsp->header, FAPI_PARAM_RESPONSE, msgLen);
 148   fapiParamRsp->error_code = MSG_OK;
 149   printf("\nPHY_STUB: Sending Param Request to Lower Mac");
 150   sendToLowerMac(fapiParamRsp->header.message_type_id, sizeof(fapi_param_resp_t), (void *)fapiParamRsp);
 151 #endif
 152   return ROK;
 153 }
 154
 155 /*******************************************************************
 156  *
 157  * @brief Builds and sends config response to lower mac
 158  *
 159  * @details
 160  *
 161  *    Function : l1BldAndSndConfigRsp
 162  *
 163  *    Functionality:
 164  *          - Builds and sends config response to MAC
 165  *
 166  * @params[in] Config request message pointer
 167  * @return ROK     - success
 168  *         RFAILED - failure
 169  *
 170  * ****************************************************************/
 171
 172 S16 l1BldAndSndConfigRsp(void *msg)
 173 {
 174 #ifdef FAPI
 175    uint8_t index = 0;
 176    uint32_t msgLen = 0;
 177    fapi_config_resp_t *fapiConfigRsp = (fapi_config_resp_t *)msg;
 178
 179    if(fapiConfigRsp != NULL)
 180    {
 181       fapiConfigRsp->number_of_invalid_tlvs = NULLP;
 182       fapiConfigRsp->number_of_inv_tlvs_idle_only = NULLP;
 183       fapiConfigRsp->number_of_missing_tlvs = NULLP;
 184       fapiConfigRsp->error_code = MSG_OK;
 185       msgLen += sizeof(fapi_config_resp_t);
 186       fillMsgHeader(&fapiConfigRsp->header, FAPI_CONFIG_RESPONSE, msgLen);
 187       printf("\nPHY_STUB: Sending Config Response to Lower Mac");
 188       sendToLowerMac(fapiConfigRsp->header.message_type_id, sizeof(fapi_config_resp_t), (void *)fapiConfigRsp);
 189       return ROK;
 190    }
 191 #else
 192    return ROK;
 193 #endif
 194 }
 195 /*******************************************************************
 196  *
 197  * @brief Handles param request received from MAC
 198  *
 199  * @details
 200  *
 201  *    Function : l1HdlParamReq
 202  *
 203  *    Functionality:
 204  *          -Handles param request received from MAC
 205  *
 206  * @params[in]   Message length
 207  *               Param request message pointer
 208  *
 209  * @return void
 210  *
 211  * ****************************************************************/
 212
 213 PUBLIC void l1HdlParamReq(uint32_t msgLen, void *msg)
 214 {
 215    printf("\nPHY_STUB: Received Param Request in PHY");
 216    /* Handling PARAM RESPONSE */
 217    if(l1BldAndSndParamRsp(msg)!= ROK)
 218    {
 219       printf("\nPHY_STUB: Failed Sending Param Response");
 220    }
 221 }
 222
 223 /*******************************************************************
 224  *
 225  * @brief Handles config request received from MAC
 226  *
 227  * @details
 228  *
 229  *    Function : l1HdlConfigReq
 230  *
 231  *    Functionality:
 232  *          -Handles config request received from MAC
 233  *
 234  * @params[in]   Message length
 235  *               config request message pointer
 236  *
 237  * @return void
 238  *
 239  * ****************************************************************/
 240
 241 PUBLIC void l1HdlConfigReq(uint32_t msgLen, void *msg)
 242 {
 243    printf("\nPHY_STUB: Received Config Request in PHY");
 244
 245    /* Handling CONFIG RESPONSE */
 246    if(l1BldAndSndConfigRsp(msg)!= ROK)
 247    {
 248       printf("\nPHY_STUB: Failed Sending config Response");
 249    }
 250 }
 251
 252 /*******************************************************************
 253  *
 254  * @brief Builds and Send the Slot Indication message to MAC
 255  *
 256  * @details
 257  *
 258  *    Function : buildAndSendSlotIndication
 259  *
 260  *    Functionality:
 261  *          -Send the Slot indication Message to MAC
 262  *
 263  * @params[in]   Message length
 264  *               config request message pointer
 265  *
 266  * @return void
 267  *
 268  * ****************************************************************/
 269 PUBLIC S16 buildAndSendSlotIndication()
 270 {
 271 #ifdef FAPI
 272    fapi_slot_ind_t *slotIndMsg;
 273    if(SGetSBuf(0, 0, (Data **)&slotIndMsg, sizeof(slotIndMsg)) != ROK)
 274    {
 275        printf("\nPHY_STUB: Memory allocation failed for slot Indication Message");
 276        return RFAILED;
 277    }
 278    else
 279    {
 280       slotValue++;
 281       if(sfnValue > MAX_SFN_VALUE && slotValue > MAX_SLOT_VALUE)
 282       {
 283          sfnValue = 0;
 284          slotValue = 0;
 285       }
 286       else if(slotValue > MAX_SLOT_VALUE)
 287       {
 288          sfnValue++;
 289          slotValue = 0;
 290       }
 291       slotIndMsg->sfn = sfnValue;
 292       slotIndMsg->slot = slotValue;
 293       fillMsgHeader(&slotIndMsg->header, FAPI_SLOT_INDICATION, sizeof(fapi_slot_ind_t));
 294       printf("\nPHY_STUB [%d:%d] ",sfnValue,slotValue);
 295       handlePhyMessages((void*)slotIndMsg);
 296       SPutSBuf(0, 0, (Data *)slotIndMsg, sizeof(slotIndMsg));
 297    }
 298 #endif
 299    return ROK;
 300 }
 301
 302 /*******************************************************************
 303  *
 304  * @brief Handles start request received from MAC
 305  *
 306  * @details
 307  *
 308  *    Function : l1HdlStartReq
 309  *
 310  *    Functionality:
 311  *          -Handles start request received from MAC
 312  *
 313  * @params[in]   Message length
 314  *               config request message pointer
 315  *
 316  * @return void
 317  *
 318  * ****************************************************************/
 319
 320 PUBLIC S16 l1HdlStartReq(uint32_t msgLen, void *msg)
 321 {
 322    if(clGlobalCp.phyState == PHY_STATE_CONFIGURED)
 323    {
 324       duStartSlotIndicaion();
 325 #ifdef FAPI
 326       SPutSBuf(0, 0, (Data *)msg, sizeof(fapi_start_req_t));
 327 #endif
 328       return ROK;
 329    }
 330    else
 331    {
 332       printf("\n PHY_STUB: Received Start Req in PHY State", clGlobalCp.phyState);
 333       return RFAILED;
 334    }
 335 }
 336
 337 /*******************************************************************
 338 *
 339 * @brief Handles Dl Tti request received from MAC
 340 *
 341 * @details
 342 *
 343 *    Function : l1HdlDlTtiReq
 344 *
 345 *    Functionality:
 346 *          -Handles Dl Tti request received from MAC
 347 *
 348 * @params[in]   Message length
 349 *               Dl Tti request message pointer
 350 *
 351 * @return void
 352 *
 353 * ****************************************************************/
 354
 355 PUBLIC S16 l1HdlDlTtiReq(uint16_t msgLen, void *msg)
 356 {
 357 #ifdef FAPI
 358    fapi_dl_tti_req_t *dlTtiReq;
 359    dlTtiReq = (fapi_dl_tti_req_t *)msg;
 360 #if 0
 361    printf("\nPHY_STUB:  Received DL TTI Request in PHY");
 362    printf("\nPHY_STUB:  SFN     %d", dlTtiReq->sfn);
 363    printf("\nPHY_STUB:  SLOT    %d", dlTtiReq->slot);
 364    printf("\nPHY_STUB:  nPdus   %d", dlTtiReq->nPdus);
 365    printf("\nPHY_STUB:  nGroup  %d", dlTtiReq->nGroup);
 366    /* Printing SSB CONFIGURED VALUES */
 367    printf("\nPHY_STUB: physCellId   %d", dlTtiReq->pdus->u.ssb_pdu.physCellId);
 368    printf("\nPHY_STUB: betaPss      %d", dlTtiReq->pdus->u.ssb_pdu.betaPss);
 369    printf("\nPHY_STUB: ssbBlockIndex %d",       dlTtiReq->pdus->u.ssb_pdu.ssbBlockIndex);
 370    printf("\nPHY_STUB: ssbSubCarrierOffset %d", dlTtiReq->pdus->u.ssb_pdu.ssbSubCarrierOffset);
 371    printf("\nPHY_STUB: ssbOffsetPointA     %d", dlTtiReq->pdus->u.ssb_pdu.ssbOffsetPointA);
 372    printf("\nPHY_STUB: bchPayloadFlag      %d", dlTtiReq->pdus->u.ssb_pdu.bchPayloadFlag);
 373    printf("\nPHY_STUB: bchPayload          %x", dlTtiReq->pdus->u.ssb_pdu.bchPayload);
 374 #endif
 375    uint8_t numPdus = dlTtiReq->nPdus;
 376         if(numPdus == 0)
 377         {
 378                 printf("no  PDU \n");
 379    }
 380         while(numPdus)
 381         {
 382                 if(dlTtiReq->pdus->pduType == 3) //SSB_PDU_TYPE
 383                         printf("SSB PDU\n");
 384                 else if(dlTtiReq->pdus->pduType == 0)
 385                         printf("SIB1 PDCCH PDU\n");
 386                 else if(dlTtiReq->pdus->pduType == 1)
 387                         printf("SIB1 PDSCH PDU\n");
 388
 389                 numPdus--;
 390         }
 391
 392    SPutSBuf(0, 0, (Data *)dlTtiReq, sizeof(fapi_dl_tti_req_t));
 393 #endif
 394    return ROK;
 395 }
 396 /*******************************************************************
 397  *
 398  * @brief Receives message from MAC
 399  *
 400  * @details
 401  *
 402  *    Function : processFapiRequest
 403  *
 404  *    Functionality:
 405  *       - Receives message from MAC and calls handler
 406  *
 407  * @params[in] Message type
 408  *             Message length
 409  *             Message pointer
 410  *
 411  * @return void
 412  *
 413  * ****************************************************************/
 414
 415 void processFapiRequest(uint8_t msgType, uint32_t msgLen, void *msg)
 416 {
 417    switch(msgType)
 418    {
 419 #ifdef FAPI
 420       case FAPI_PARAM_REQUEST:
 421          l1HdlParamReq(msgLen, msg);
 422          break;
 423       case FAPI_CONFIG_REQUEST:
 424          l1HdlConfigReq(msgLen, msg);
 425          break;
 426       case FAPI_START_REQUEST:
 427          l1HdlStartReq(msgLen, msg);
 428          break;
 429       case FAPI_DL_TTI_REQUEST:
 430          l1HdlDlTtiReq(msgLen, msg);
 431          break;
 432       default:
 433          printf("\nPHY_STUB: Invalid message type[%x] received at PHY", msgType);
 434          break;
 435 #endif
 436    }
 437 }
 438 /**********************************************************************
 439          End of file
 440 **********************************************************************/