FreeCalypso > hg > tcs211-l1-reconst

comparison chipsetsw/layer1/cfile/l1_trace.c @ 154:f9d2c65905f5

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
l1_trace.c: binary trace code excised
author Mychaela Falconia <falcon@ivan.Harhan.ORG>
date Sat, 21 May 2016 04:03:40 +0000
parents ac77167940a3
children c11f6d8d8fbd
comparison
equal deleted inserted replaced
153:ac77167940a3 154:f9d2c65905f5
631 631
632 /************************************ Binary trace ********************************************************/ 632 /************************************ Binary trace ********************************************************/
633 633
634 #if L1_BINARY_TRACE 634 #if L1_BINARY_TRACE
635 635
636 /*************************************************************************/ 636 /*
637 /* Classic trace output */ 637 * FreeCalypso: the binary trace code has been excised
638 /*************************************************************************/ 638 * because we have no way of reconstructing what it was
639 639 * in the TCS211 version before LoCosto changes.
640 /*-------------------------------------------------------*/ 640 */
641 /* l1_trace_message() */
642 /*-------------------------------------------------------*/
643 /* Parameters : */
644 /* Return : */
645 /* Description: L1 Trace formatting. */
646 /*-------------------------------------------------------*/
647 void l1_trace_message(xSignalHeaderRec *msg)
648 {
649
650 /***********************************************************************/
651 /* Trace configuration */
652 /***********************************************************************/
653
654 if (msg->SignalCode == TRACE_CONFIG)
655 {
656 char *ptr;
657 T_TRACE_CONFIG *save;
658
659
660 // Download values
661 //----------------
662
663 // Note: RTT values are used in L1S but partial download of these values have no
664 // negative influence on L1 or Trace behavior
665
666 // First UWORD32 is the classic L1 dynamic trace
667 trace_info.pending_config->l1_dyn_trace = ((T_TRACE_CONFIG_CHANGE *)(msg->SigP))->trace_config;
668
669 // The eight following UWORD32 define the RTT cell configuration
670 trace_info.pending_config->rttl1_cell_enable[0] = ((T_TRACE_CONFIG_CHANGE *)(msg->SigP))->rtt_cell_enable[0];
671 trace_info.pending_config->rttl1_cell_enable[1] = ((T_TRACE_CONFIG_CHANGE *)(msg->SigP))->rtt_cell_enable[1];
672 trace_info.pending_config->rttl1_cell_enable[2] = ((T_TRACE_CONFIG_CHANGE *)(msg->SigP))->rtt_cell_enable[2];
673 trace_info.pending_config->rttl1_cell_enable[3] = ((T_TRACE_CONFIG_CHANGE *)(msg->SigP))->rtt_cell_enable[3];
674 trace_info.pending_config->rttl1_cell_enable[4] = ((T_TRACE_CONFIG_CHANGE *)(msg->SigP))->rtt_cell_enable[4];
675 trace_info.pending_config->rttl1_cell_enable[5] = ((T_TRACE_CONFIG_CHANGE *)(msg->SigP))->rtt_cell_enable[5];
676 trace_info.pending_config->rttl1_cell_enable[6] = ((T_TRACE_CONFIG_CHANGE *)(msg->SigP))->rtt_cell_enable[6];
677 trace_info.pending_config->rttl1_cell_enable[7] = ((T_TRACE_CONFIG_CHANGE *)(msg->SigP))->rtt_cell_enable[7];
678
679 // Last UWORD32 define the RTT event
680 trace_info.pending_config->rttl1_event_enable = ((T_TRACE_CONFIG_CHANGE *)(msg->SigP))->rtt_event;
681
682 // Re-initialize global variables
683 l1_init_trace_var();
684
685 // Switch pointers
686 save = trace_info.current_config;
687 trace_info.current_config = trace_info.pending_config;
688 trace_info.pending_config = save;
689
690 // Trace the configuration change
691 //-------------------------------
692
693 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_TRACE_CONFIG_CHANGE), (T_RVT_BUFFER *) &ptr) == RVT_OK)
694 {
695
696 ((T_TR_TRACE_CONFIG_CHANGE *)(ptr))->header = TRL1_TRACE_CONFIG_CHANGE | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
697 ((T_TR_TRACE_CONFIG_CHANGE *)(ptr))->trace_config = trace_info.current_config->l1_dyn_trace ;
698 ((T_TR_TRACE_CONFIG_CHANGE *)(ptr))->rtt_cell_enable[0] = trace_info.current_config->rttl1_cell_enable[0];
699 ((T_TR_TRACE_CONFIG_CHANGE *)(ptr))->rtt_cell_enable[1] = trace_info.current_config->rttl1_cell_enable[1];
700 ((T_TR_TRACE_CONFIG_CHANGE *)(ptr))->rtt_cell_enable[2] = trace_info.current_config->rttl1_cell_enable[2];
701 ((T_TR_TRACE_CONFIG_CHANGE *)(ptr))->rtt_cell_enable[3] = trace_info.current_config->rttl1_cell_enable[3];
702 ((T_TR_TRACE_CONFIG_CHANGE *)(ptr))->rtt_cell_enable[4] = trace_info.current_config->rttl1_cell_enable[4];
703 ((T_TR_TRACE_CONFIG_CHANGE *)(ptr))->rtt_cell_enable[5] = trace_info.current_config->rttl1_cell_enable[5];
704 ((T_TR_TRACE_CONFIG_CHANGE *)(ptr))->rtt_cell_enable[6] = trace_info.current_config->rttl1_cell_enable[6];
705 ((T_TR_TRACE_CONFIG_CHANGE *)(ptr))->rtt_cell_enable[7] = trace_info.current_config->rttl1_cell_enable[7];
706 ((T_TR_TRACE_CONFIG_CHANGE *)(ptr))->rtt_event = trace_info.current_config->rttl1_event_enable;
707
708 L1_send_trace_no_cpy(ptr,sizeof(T_TR_TRACE_CONFIG_CHANGE));
709
710 return;
711 }
712
713 }
714
715 /***********************************************************************/
716 /* Traces coming from L1S */
717 /***********************************************************************/
718
719 switch(msg->SignalCode)
720 {
721 #if (DSP_DEBUG_TRACE_ENABLE == 1)
722
723 //////////////////////
724 // DSP debug buffer //
725 //////////////////////
726
727 case TRACE_DSP_DEBUG:
728 {
729 WORD16 size = ((T_DSP_DEBUG_INFO *)(msg->SigP))->size;
730 char *ptr;
731 UWORD8 index = 0;
732
733 // DSP debug header trace: L1 indication to associate with the buffer
734 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_DSP_DEBUG_HEADER), (T_RVT_BUFFER *) &ptr) == RVT_OK)
735 {
736 ((T_TR_DSP_DEBUG_HEADER *)(ptr))->header = TRL1_DSP_DEBUG_HEADER | (((T_DSP_DEBUG_INFO *)(msg->SigP))->fn << TR_HEADER_FN_DELAY);
737 ((T_TR_DSP_DEBUG_HEADER *)(ptr))->debug_time = ((T_DSP_DEBUG_INFO *)(msg->SigP))->debug_time;
738 ((T_TR_DSP_DEBUG_HEADER *)(ptr))->patch_version = ((T_DSP_DEBUG_INFO *)(msg->SigP))->patch_version;
739 ((T_TR_DSP_DEBUG_HEADER *)(ptr))->trace_level = ((T_DSP_DEBUG_INFO *)(msg->SigP))->trace_level;
740
741 L1_send_trace_no_cpy(ptr,sizeof(T_TR_DSP_DEBUG_HEADER));
742 }
743
744 // DSP debug buffer trace
745 while (size > 0)
746 {
747 UWORD8 item_size = size;
748
749 // Split buffer in several buffers with size inferior to 240 (RVT limitation to 255)
750 // Header not included (+8b)
751 if (item_size > 240) item_size = 240;
752
753 // Buffer size -> add header
754 if (rvt_mem_alloc(trace_info.l1_trace_user_id, item_size + sizeof(T_TR_DSP_DEBUG_BUFFER) - sizeof(UWORD16), (T_RVT_BUFFER *) &ptr) == RVT_OK)
755 {
756 UWORD8 i;
757
758 ((T_TR_DSP_DEBUG_BUFFER *)(ptr))->header = TRL1_DSP_DEBUG_BUFFER | (((T_DSP_DEBUG_INFO *)(msg->SigP))->fn << TR_HEADER_FN_DELAY);
759 ((T_TR_DSP_DEBUG_BUFFER *)(ptr))->size = (item_size >> 1);
760 // First element tells if it's the last msg
761 ((T_TR_DSP_DEBUG_BUFFER *)(ptr))->content[0] = 0;
762
763 for (i = 1; i < (item_size >> 1); i++)
764 {
765 ((T_TR_DSP_DEBUG_BUFFER *)(ptr))->content[i] = ((T_DSP_DEBUG_INFO *)(msg->SigP))->buffer[index++];
766 }
767
768 size -= (item_size - 2); // (item_size - 2) bytes of the buffer transmitted
769 // -2 because of the first word used for status
770
771 // Indicates it's the last buffer
772 if (size <= 0)
773 ((T_TR_DSP_DEBUG_BUFFER *)(ptr))->content[0] = 1;
774
775 L1_send_trace_no_cpy(ptr,item_size + sizeof(T_TR_DSP_DEBUG_BUFFER) - sizeof(UWORD16));
776 }
777
778 // No trace buffer available -> cancel trace !
779 else
780 {
781 break;
782 }
783 }
784 }
785 break;
786
787 #endif // DSP_DEBUG_TRACE_ENABLE
788
789 #if (L1_GPRS)
790
791 ///////////////////////////
792 // PDTCH condensed trace //
793 ///////////////////////////
794
795 case TRACE_CONDENSED_PDTCH:
796 {
797 char *ptr;
798
799 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_CONDENSED_PDTCH), (T_RVT_BUFFER *) &ptr) == RVT_OK)
800 {
801 UWORD8 i,j;
802
803 ((T_TR_CONDENSED_PDTCH *)(ptr))->header = TRL1_CONDENSED_PDTCH | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
804 ((T_TR_CONDENSED_PDTCH *)(ptr))->rx_allocation = ((T_CONDENSED_PDTCH_INFO *)(msg->SigP))->rx_allocation;
805 ((T_TR_CONDENSED_PDTCH *)(ptr))->tx_allocation = ((T_CONDENSED_PDTCH_INFO *)(msg->SigP))->tx_allocation;
806 ((T_TR_CONDENSED_PDTCH *)(ptr))->blk_status = ((T_CONDENSED_PDTCH_INFO *)(msg->SigP))->blk_status;
807 ((T_TR_CONDENSED_PDTCH *)(ptr))->dl_cs_type = ((T_CONDENSED_PDTCH_INFO *)(msg->SigP))->dl_cs_type;
808 ((T_TR_CONDENSED_PDTCH *)(ptr))->dl_status[0] = ((T_CONDENSED_PDTCH_INFO *)(msg->SigP))->dl_status[0];
809 ((T_TR_CONDENSED_PDTCH *)(ptr))->dl_status[1] = ((T_CONDENSED_PDTCH_INFO *)(msg->SigP))->dl_status[1];
810 ((T_TR_CONDENSED_PDTCH *)(ptr))->dl_status[2] = ((T_CONDENSED_PDTCH_INFO *)(msg->SigP))->dl_status[2];
811 ((T_TR_CONDENSED_PDTCH *)(ptr))->dl_status[3] = ((T_CONDENSED_PDTCH_INFO *)(msg->SigP))->dl_status[3];
812
813 for (i=0, j=0; (i<8)&&(j<4); i++)
814 if (((T_CONDENSED_PDTCH_INFO *)(msg->SigP))->ul_status[i] != 0)
815 {
816 ((T_TR_CONDENSED_PDTCH *)(ptr))->ul_status[j++] = ((T_CONDENSED_PDTCH_INFO *)(msg->SigP))->ul_status[i];
817 }
818
819 L1_send_trace_no_cpy(ptr,sizeof(T_TR_CONDENSED_PDTCH));
820 }
821 }
822 break;
823
824 #endif // L1_GPRS
825
826 /////////////////
827 // Quick trace //
828 /////////////////
829
830 case QUICK_TRACE:
831 {
832 UWORD8 debug_code = ((T_QUICK_TRACE *)(msg->SigP))->debug_code;
833 char ptr[200];
834 char *str = ((T_TR_ASCII *)(ptr))->str;
835 UWORD32 *param = ((T_QUICK_TRACE *)(msg->SigP))->tab;
836
837 // Fill string in 'str' variable
838 // Parameters included in param[n]
839 switch (debug_code)
840 {
841 case 0:
842 {
843 sprintf(str, "Quick trace example %d", param[0]);
844 }
845 break;
846
847 }
848
849 // Send trace
850 ((T_TR_ASCII *)(ptr))->header = TRL1_ASCII | (((T_QUICK_TRACE *)(msg->SigP))->fn << TR_HEADER_FN_DELAY);
851 ((T_TR_ASCII *)(ptr))->size = strlen(((T_TR_ASCII *)(ptr))->str);
852 L1_send_trace_cpy(ptr,((T_TR_ASCII *)(ptr))->size + 8);
853 }
854 break;
855
856 ////////////////
857 // Debug info //
858 ////////////////
859
860 case TRACE_INFO:
861 {
862 // Read cell ID in the header (first UWORD32)
863 UWORD16 trace_id = *((UWORD32 *)(msg->SigP)) & TR_HEADER_ID_MASK;
864
865 switch(trace_id)
866 {
867 case TRL1_PM_EQUAL_0:
868 {
869 L1_send_trace_cpy(msg->SigP,sizeof(T_TR_PM_EQUAL_0));
870 }
871 break;
872
873 case TRL1_MCU_DSP_MISMATCH:
874 {
875 L1_send_trace_cpy(msg->SigP,sizeof(T_TR_MCU_DSP_MISMATCH));
876 }
877 break;
878
879 case TRL1_L1S_ABORT:
880 {
881 L1_send_trace_cpy(msg->SigP,sizeof(T_TR_L1S_ABORT));
882 }
883 break;
884
885 #if (D_ERROR_STATUS_TRACE_ENABLE)
886 case TRL1_D_ERROR_STATUS:
887 {
888 L1_send_trace_cpy(msg->SigP,sizeof(T_TR_D_ERROR_STATUS));
889 }
890 break;
891 #endif
892
893 #if L1_GPRS
894
895 case TRL1_RLC_UL_PARAM:
896 {
897 L1_send_trace_cpy(msg->SigP,sizeof(T_TR_RLC_UL_PARAM));
898 }
899 break;
900
901 case TRL1_RLC_DL_PARAM:
902 {
903 L1_send_trace_cpy(msg->SigP,sizeof(T_TR_RLC_DL_PARAM));
904 }
905 break;
906
907 case TRL1_FORBIDDEN_UPLINK:
908 {
909 L1_send_trace_cpy(msg->SigP,sizeof(T_TR_FORBIDDEN_UPLINK));
910 }
911 break;
912
913 case TRL1_DL_PTCCH:
914 {
915 L1_send_trace_cpy(msg->SigP,sizeof(T_TR_DL_PTCCH));
916 }
917 break;
918
919 case TRL1_IT_DSP_ERROR:
920 {
921 L1_send_trace_cpy(msg->SigP,sizeof(T_TR_IT_DSP_ERROR));
922 }
923 break;
924
925 #endif // L1_GPRS
926
927 case TRL1_ADC:
928 {
929 L1_send_trace_cpy(msg->SigP,sizeof(T_TR_ADC));
930 }
931 break;
932
933 case TRL1_NEW_TOA:
934 {
935 L1_send_trace_cpy(msg->SigP,sizeof(T_TR_NEW_TOA));
936 }
937 break;
938
939 case TRL1_SAIC_DEBUG:
940 {
941 L1_send_trace_cpy(msg->SigP,sizeof(T_TR_SAIC_DEBUG));
942 }
943 break;
944
945 case TRL1_BURST_PARAM:
946 {
947 L1_send_trace_cpy(msg->SigP,sizeof(T_TR_BURST_PARAM));
948 }
949 break;
950
951 case TRL1_SLEEP:
952 {
953 L1_send_trace_cpy(msg->SigP,sizeof(T_TR_SLEEP));
954 }
955 break;
956
957 case TRL1_GAUGING:
958 {
959 L1_send_trace_cpy(msg->SigP,sizeof(T_TR_GAUGING));
960 }
961 break;
962
963 case TRL1_PTCCH_DISABLE:
964 {
965 L1_send_trace_cpy(msg->SigP,sizeof(T_TR_PTCCH_DISABLE));
966 }
967 break;
968
969 default:
970 {
971 char *ptr;
972
973 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_UNKNOWN_L1S_TRACE), (T_RVT_BUFFER *) &ptr) == RVT_OK)
974 {
975
976 ((T_TR_UNKNOWN_L1S_TRACE *)(ptr))->header = TRL1_UNKNOWN_L1S_TRACE | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
977 ((T_TR_UNKNOWN_L1S_TRACE *)(ptr))->id = trace_id;
978
979 L1_send_trace_no_cpy(ptr,sizeof(T_TR_UNKNOWN_L1S_TRACE));
980 }
981 }
982 } // End switch
983 } // End case "TRACE_INFO"
984 }
985
986 /***********************************************************************/
987 /* L1S CPU load */
988 /***********************************************************************/
989
990 if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_L1S_CPU_LOAD)
991 {
992 if(max_cpu_flag)
993 {
994 char *ptr;
995
996 max_cpu_flag = 0;
997
998 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1S_CPU_PEAK), (T_RVT_BUFFER *) &ptr) == RVT_OK)
999 {
1000
1001 ((T_TR_L1S_CPU_PEAK *)(ptr))->header = TRL1_L1S_CPU_PEAK | (fn_max_cpu << TR_HEADER_FN_DELAY);
1002 ((T_TR_L1S_CPU_PEAK *)(ptr))->max_cpu = (UWORD8)max_cpu;
1003
1004 L1_send_trace_no_cpy(ptr, sizeof(T_TR_L1S_CPU_PEAK));
1005 }
1006 }
1007 }
1008
1009 /***********************************************************************/
1010 /* L1A messages */
1011 /***********************************************************************/
1012
1013 if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_L1A_MESSAGES)
1014 {
1015
1016 switch(msg->SignalCode)
1017 {
1018
1019 /********************************************************************************/
1020 /* CIRCUIT SWITCHED */
1021 /********************************************************************************/
1022
1023 /////////////////////////////////////////
1024 // Message to set the right radio band //
1025 /////////////////////////////////////////
1026 case MPHC_INIT_L1_REQ:
1027 {
1028 char *ptr;
1029
1030 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_INIT_L1_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1031 {
1032
1033 ((T_TR_MPHC_INIT_L1_REQ *)(ptr))->header = TRL1_MPHC_INIT_L1_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1034 ((T_TR_MPHC_INIT_L1_REQ *)(ptr))->radio_band_config = ((T_MPHC_INIT_L1_REQ *)(msg->SigP))->radio_band_config;
1035
1036 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_NEW_SCELL_REQ));
1037 }
1038 }
1039 break;
1040
1041 case MPHC_INIT_L1_CON:
1042 {
1043 char *ptr;
1044
1045 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_INIT_L1_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1046 {
1047 ((T_TR_MPHC_INIT_L1_CON *)(ptr))->header = TRL1_MPHC_INIT_L1_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1048
1049 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_NEW_SCELL_REQ));
1050 }
1051 }
1052 break;
1053
1054 ////////////////////////////
1055 // Serving Cell selection //
1056 ////////////////////////////
1057
1058 case MPHC_NEW_SCELL_REQ:
1059 {
1060 char *ptr;
1061
1062 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_NEW_SCELL_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1063 {
1064
1065 ((T_TR_MPHC_NEW_SCELL_REQ *)(ptr))->header = TRL1_MPHC_NEW_SCELL_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1066 ((T_TR_MPHC_NEW_SCELL_REQ *)(ptr))->radio_freq = ((T_MPHC_NEW_SCELL_REQ *)(msg->SigP))->radio_freq;
1067 ((T_TR_MPHC_NEW_SCELL_REQ *)(ptr))->fn_offset = ((T_MPHC_NEW_SCELL_REQ *)(msg->SigP))->fn_offset;
1068 ((T_TR_MPHC_NEW_SCELL_REQ *)(ptr))->time_alignmt = ((T_MPHC_NEW_SCELL_REQ *)(msg->SigP))->time_alignmt;
1069 ((T_TR_MPHC_NEW_SCELL_REQ *)(ptr))->bsic = ((T_MPHC_NEW_SCELL_REQ *)(msg->SigP))->bsic;
1070
1071 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_NEW_SCELL_REQ));
1072 }
1073 }
1074 break;
1075
1076 //////////////////////////////
1077 // Neighbor cell monitoring //
1078 //////////////////////////////
1079
1080 case MPHC_NETWORK_LOST_IND:
1081 {
1082 char *ptr;
1083
1084 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_NETWORK_LOST_IND), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1085 {
1086
1087 ((T_TR_MPHC_NETWORK_LOST_IND *)(ptr))->header = TRL1_MPHC_NETWORK_LOST_IND | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1088
1089 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_NETWORK_LOST_IND));
1090 }
1091 }
1092 break;
1093
1094 // Idle mode neighbor cell synchronization
1095
1096 case MPHC_NETWORK_SYNC_REQ:
1097 {
1098 char *ptr;
1099
1100 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_NETWORK_SYNC_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1101 {
1102
1103 ((T_TR_MPHC_NETWORK_SYNC_REQ *)(ptr))->header = TRL1_MPHC_NETWORK_SYNC_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1104 ((T_TR_MPHC_NETWORK_SYNC_REQ *)(ptr))->radio_freq = ((T_MPHC_NETWORK_SYNC_REQ *)(msg->SigP))->radio_freq;
1105 ((T_TR_MPHC_NETWORK_SYNC_REQ *)(ptr))->fn_offset = ((T_MPHC_NETWORK_SYNC_REQ *)(msg->SigP))->fn_offset;
1106 ((T_TR_MPHC_NETWORK_SYNC_REQ *)(ptr))->time_alignmt = ((T_MPHC_NETWORK_SYNC_REQ *)(msg->SigP))->time_alignmt;
1107 ((T_TR_MPHC_NETWORK_SYNC_REQ *)(ptr))->timing_validity = ((T_MPHC_NETWORK_SYNC_REQ *)(msg->SigP))->timing_validity;
1108 ((T_TR_MPHC_NETWORK_SYNC_REQ *)(ptr))->search_mode = ((T_MPHC_NETWORK_SYNC_REQ *)(msg->SigP))->search_mode;
1109
1110 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_NETWORK_SYNC_REQ));
1111 }
1112 }
1113 break;
1114
1115 case MPHC_STOP_NETWORK_SYNC_REQ:
1116 {
1117 char *ptr;
1118
1119 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_STOP_NETWORK_SYNC_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1120 {
1121
1122 ((T_TR_MPHC_STOP_NETWORK_SYNC_REQ *)(ptr))->header = TRL1_MPHC_STOP_NETWORK_SYNC_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1123
1124 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_STOP_NETWORK_SYNC_REQ));
1125 }
1126 }
1127 break;
1128
1129 case MPHC_NCELL_SYNC_REQ:
1130 {
1131 char *ptr;
1132
1133 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_NCELL_SYNC_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1134 {
1135
1136 ((T_TR_MPHC_NCELL_SYNC_REQ *)(ptr))->header = TRL1_MPHC_NCELL_SYNC_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1137 ((T_TR_MPHC_NCELL_SYNC_REQ *)(ptr))->radio_freq = ((T_MPHC_NCELL_SYNC_REQ *)(msg->SigP))->radio_freq;
1138 ((T_TR_MPHC_NCELL_SYNC_REQ *)(ptr))->fn_offset = ((T_MPHC_NCELL_SYNC_REQ *)(msg->SigP))->fn_offset;
1139 ((T_TR_MPHC_NCELL_SYNC_REQ *)(ptr))->time_alignmt = ((T_MPHC_NCELL_SYNC_REQ *)(msg->SigP))->time_alignmt;
1140 ((T_TR_MPHC_NCELL_SYNC_REQ *)(ptr))->timing_validity = ((T_MPHC_NCELL_SYNC_REQ *)(msg->SigP))->timing_validity;
1141
1142 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_NCELL_SYNC_REQ));
1143 }
1144 }
1145 break;
1146
1147 case MPHC_NCELL_LIST_SYNC_REQ:
1148 {
1149 char *ptr;
1150
1151 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_NCELL_LIST_SYNC_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1152 {
1153 UWORD8 i;
1154
1155 ((T_TR_MPHC_NCELL_LIST_SYNC_REQ *)(ptr))->header = TRL1_MPHC_NCELL_LIST_SYNC_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1156 ((T_TR_MPHC_NCELL_LIST_SYNC_REQ *)(ptr))->eotd = ((T_MPHC_NCELL_LIST_SYNC_REQ *)(msg->SigP))->eotd;
1157 ((T_TR_MPHC_NCELL_LIST_SYNC_REQ *)(ptr))->list_size = ((T_MPHC_NCELL_LIST_SYNC_REQ *)(msg->SigP))->list_size;
1158
1159
1160 for (i=0; i<((T_MPHC_NCELL_LIST_SYNC_REQ *)(msg->SigP))->list_size; i++)
1161 {
1162 ((T_TR_MPHC_NCELL_LIST_SYNC_REQ *)(ptr))->radio_freq[i] = ((T_MPHC_NCELL_LIST_SYNC_REQ *)(msg->SigP))->ncell_list[i].timing_validity;
1163 ((T_TR_MPHC_NCELL_LIST_SYNC_REQ *)(ptr))->fn_offset[i] = ((T_MPHC_NCELL_LIST_SYNC_REQ *)(msg->SigP))->ncell_list[i].time_alignmt;
1164 ((T_TR_MPHC_NCELL_LIST_SYNC_REQ *)(ptr))->time_alignmt[i] = ((T_MPHC_NCELL_LIST_SYNC_REQ *)(msg->SigP))->ncell_list[i].fn_offset;
1165 ((T_TR_MPHC_NCELL_LIST_SYNC_REQ *)(ptr))->timing_validity[i] = ((T_MPHC_NCELL_LIST_SYNC_REQ *)(msg->SigP))->ncell_list[i].radio_freq;
1166 }
1167
1168 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_NCELL_LIST_SYNC_REQ));
1169 }
1170 }
1171 break;
1172
1173 case MPHC_STOP_NCELL_SYNC_REQ:
1174 {
1175 char *ptr;
1176
1177 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_STOP_NCELL_SYNC_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1178 {
1179
1180 ((T_TR_MPHC_STOP_NCELL_SYNC_REQ *)(ptr))->header = TRL1_MPHC_STOP_NCELL_SYNC_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1181 ((T_TR_MPHC_STOP_NCELL_SYNC_REQ *)(ptr))->radio_freq_array_size = ((T_MPHC_STOP_NCELL_SYNC_REQ *)(msg->SigP))->radio_freq_array_size;
1182 ((T_TR_MPHC_STOP_NCELL_SYNC_REQ *)(ptr))->radio_freq_array[0] = ((T_MPHC_STOP_NCELL_SYNC_REQ *)(msg->SigP))->radio_freq_array[0];
1183 ((T_TR_MPHC_STOP_NCELL_SYNC_REQ *)(ptr))->radio_freq_array[1] = ((T_MPHC_STOP_NCELL_SYNC_REQ *)(msg->SigP))->radio_freq_array[1];
1184 ((T_TR_MPHC_STOP_NCELL_SYNC_REQ *)(ptr))->radio_freq_array[2] = ((T_MPHC_STOP_NCELL_SYNC_REQ *)(msg->SigP))->radio_freq_array[2];
1185 ((T_TR_MPHC_STOP_NCELL_SYNC_REQ *)(ptr))->radio_freq_array[3] = ((T_MPHC_STOP_NCELL_SYNC_REQ *)(msg->SigP))->radio_freq_array[3];
1186 ((T_TR_MPHC_STOP_NCELL_SYNC_REQ *)(ptr))->radio_freq_array[4] = ((T_MPHC_STOP_NCELL_SYNC_REQ *)(msg->SigP))->radio_freq_array[4];
1187 ((T_TR_MPHC_STOP_NCELL_SYNC_REQ *)(ptr))->radio_freq_array[5] = ((T_MPHC_STOP_NCELL_SYNC_REQ *)(msg->SigP))->radio_freq_array[5];
1188 ((T_TR_MPHC_STOP_NCELL_SYNC_REQ *)(ptr))->radio_freq_array[6] = ((T_MPHC_STOP_NCELL_SYNC_REQ *)(msg->SigP))->radio_freq_array[0];
1189 ((T_TR_MPHC_STOP_NCELL_SYNC_REQ *)(ptr))->radio_freq_array[7] = ((T_MPHC_STOP_NCELL_SYNC_REQ *)(msg->SigP))->radio_freq_array[1];
1190 ((T_TR_MPHC_STOP_NCELL_SYNC_REQ *)(ptr))->radio_freq_array[8] = ((T_MPHC_STOP_NCELL_SYNC_REQ *)(msg->SigP))->radio_freq_array[2];
1191 ((T_TR_MPHC_STOP_NCELL_SYNC_REQ *)(ptr))->radio_freq_array[9] = ((T_MPHC_STOP_NCELL_SYNC_REQ *)(msg->SigP))->radio_freq_array[3];
1192 ((T_TR_MPHC_STOP_NCELL_SYNC_REQ *)(ptr))->radio_freq_array[10] = ((T_MPHC_STOP_NCELL_SYNC_REQ *)(msg->SigP))->radio_freq_array[4];
1193 ((T_TR_MPHC_STOP_NCELL_SYNC_REQ *)(ptr))->radio_freq_array[11] = ((T_MPHC_STOP_NCELL_SYNC_REQ *)(msg->SigP))->radio_freq_array[5];
1194
1195
1196 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_STOP_NCELL_SYNC_REQ));
1197 }
1198 }
1199 break;
1200
1201 // Dedicated mode neigbor cell synchronization
1202
1203 case MPHC_NCELL_FB_SB_READ:
1204 {
1205 char *ptr;
1206
1207 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_NCELL_FB_SB_READ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1208 {
1209
1210 ((T_TR_MPHC_NCELL_FB_SB_READ *)(ptr))->header = TRL1_MPHC_NCELL_FB_SB_READ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1211 ((T_TR_MPHC_NCELL_FB_SB_READ *)(ptr))->radio_freq = ((T_MPHC_NCELL_FB_SB_READ *)(msg->SigP))->radio_freq;
1212
1213 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_NCELL_FB_SB_READ));
1214 }
1215 }
1216 break;
1217
1218 case MPHC_NCELL_SB_READ:
1219 {
1220 char *ptr;
1221
1222 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_NCELL_SB_READ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1223 {
1224
1225 ((T_TR_MPHC_NCELL_SB_READ *)(ptr))->header = TRL1_MPHC_NCELL_SB_READ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1226 ((T_TR_MPHC_NCELL_SB_READ *)(ptr))->radio_freq = ((T_MPHC_NCELL_SB_READ *)(msg->SigP))->radio_freq;
1227 ((T_TR_MPHC_NCELL_SB_READ *)(ptr))->fn_offset = ((T_MPHC_NCELL_SB_READ *)(msg->SigP))->fn_offset;
1228 ((T_TR_MPHC_NCELL_SB_READ *)(ptr))->time_alignmt = ((T_MPHC_NCELL_SB_READ *)(msg->SigP))->time_alignmt;
1229
1230 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_NCELL_SB_READ));
1231 }
1232 }
1233 break;
1234
1235 case L1C_FB_INFO:
1236 {
1237 char *ptr;
1238
1239 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1C_FB_INFO), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1240 {
1241
1242 ((T_TR_L1C_FB_INFO *)(ptr))->header = TRL1_L1C_FB_INFO | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1243 ((T_TR_L1C_FB_INFO *)(ptr))->fb_flag = ((T_L1C_FB_INFO*)(msg->SigP))->fb_flag;
1244 ((T_TR_L1C_FB_INFO *)(ptr))->radio_freq = ((T_L1C_FB_INFO*)(msg->SigP))->radio_freq;
1245 ((T_TR_L1C_FB_INFO *)(ptr))->pm = ((T_L1C_FB_INFO*)(msg->SigP))->pm;
1246 ((T_TR_L1C_FB_INFO *)(ptr))->toa = ((T_L1C_FB_INFO*)(msg->SigP))->toa;
1247 ((T_TR_L1C_FB_INFO *)(ptr))->angle = ((T_L1C_FB_INFO*)(msg->SigP))->angle;
1248 ((T_TR_L1C_FB_INFO *)(ptr))->snr = ((T_L1C_FB_INFO*)(msg->SigP))->snr;
1249 ((T_TR_L1C_FB_INFO *)(ptr))->input_level = l1a_l1s_com.last_input_level[((T_L1C_FB_INFO*)(msg->SigP))->radio_freq -
1250 l1_config.std.radio_freq_index_offset].input_level;
1251 ((T_TR_L1C_FB_INFO *)(ptr))->tpu_offset = l1s.tpu_offset;
1252 ((T_TR_L1C_FB_INFO *)(ptr))->afc = l1s.afc;
1253
1254 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1C_FB_INFO));
1255 }
1256 }
1257 break;
1258
1259 case L1C_SB_INFO:
1260 {
1261 char *ptr;
1262
1263 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1C_SB_INFO), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1264 {
1265
1266 ((T_TR_L1C_SB_INFO *)(ptr))->header = TRL1_L1C_SB_INFO | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1267 ((T_TR_L1C_SB_INFO *)(ptr))->radio_freq = ((T_L1C_SB_INFO *)(msg->SigP))->radio_freq;
1268 ((T_TR_L1C_SB_INFO *)(ptr))->sb_flag = ((T_L1C_SB_INFO *)(msg->SigP))->sb_flag;
1269 ((T_TR_L1C_SB_INFO *)(ptr))->fn_offset = ((T_L1C_SB_INFO *)(msg->SigP))->fn_offset;
1270 ((T_TR_L1C_SB_INFO *)(ptr))->time_alignmt = ((T_L1C_SB_INFO *)(msg->SigP))->time_alignmt;
1271 ((T_TR_L1C_SB_INFO *)(ptr))->bsic = ((T_L1C_SB_INFO *)(msg->SigP))->bsic;
1272 ((T_TR_L1C_SB_INFO *)(ptr))->pm = ((T_L1C_SB_INFO *)(msg->SigP))->pm;
1273 ((T_TR_L1C_SB_INFO *)(ptr))->toa = ((T_L1C_SB_INFO *)(msg->SigP))->toa;
1274 ((T_TR_L1C_SB_INFO *)(ptr))->angle = ((T_L1C_SB_INFO *)(msg->SigP))->angle;
1275 ((T_TR_L1C_SB_INFO *)(ptr))->snr = ((T_L1C_SB_INFO *)(msg->SigP))->snr;
1276 ((T_TR_L1C_SB_INFO *)(ptr))->input_level = l1a_l1s_com.last_input_level[((T_L1C_SB_INFO *)(msg->SigP))->radio_freq - l1_config.std.radio_freq_index_offset].input_level;
1277 ((T_TR_L1C_SB_INFO *)(ptr))->tpu_offset = l1s.tpu_offset;
1278 ((T_TR_L1C_SB_INFO *)(ptr))->afc = l1s.afc;
1279
1280 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1C_SB_INFO));
1281 }
1282 }
1283 break;
1284
1285 case L1C_SBCONF_INFO:
1286 {
1287 char *ptr;
1288
1289 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1C_SBCONF_INFO), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1290 {
1291
1292 ((T_TR_L1C_SBCONF_INFO *)(ptr))->header = TRL1_L1C_SBCONF_INFO | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1293 ((T_TR_L1C_SBCONF_INFO *)(ptr))->radio_freq = ((T_L1C_SBCONF_INFO *)(msg->SigP))->radio_freq;
1294 ((T_TR_L1C_SBCONF_INFO *)(ptr))->sb_flag = ((T_L1C_SBCONF_INFO *)(msg->SigP))->sb_flag;
1295 ((T_TR_L1C_SBCONF_INFO *)(ptr))->fn_offset = ((T_L1C_SBCONF_INFO *)(msg->SigP))->fn_offset;
1296 ((T_TR_L1C_SBCONF_INFO *)(ptr))->time_alignmt = ((T_L1C_SBCONF_INFO *)(msg->SigP))->time_alignmt;
1297 ((T_TR_L1C_SBCONF_INFO *)(ptr))->bsic = ((T_L1C_SBCONF_INFO *)(msg->SigP))->bsic;
1298 ((T_TR_L1C_SBCONF_INFO *)(ptr))->pm = ((T_L1C_SBCONF_INFO *)(msg->SigP))->pm;
1299 ((T_TR_L1C_SBCONF_INFO *)(ptr))->toa = ((T_L1C_SBCONF_INFO *)(msg->SigP))->toa;
1300 ((T_TR_L1C_SBCONF_INFO *)(ptr))->angle = ((T_L1C_SBCONF_INFO *)(msg->SigP))->angle;
1301 ((T_TR_L1C_SBCONF_INFO *)(ptr))->snr = ((T_L1C_SBCONF_INFO *)(msg->SigP))->snr;
1302 ((T_TR_L1C_SBCONF_INFO *)(ptr))->input_level = l1a_l1s_com.last_input_level[((T_L1C_SBCONF_INFO *)(msg->SigP))->radio_freq - l1_config.std.radio_freq_index_offset].input_level;
1303 ((T_TR_L1C_SBCONF_INFO *)(ptr))->tpu_offset = l1s.tpu_offset;
1304 ((T_TR_L1C_SBCONF_INFO *)(ptr))->afc = l1s.afc;
1305
1306 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1C_SBCONF_INFO));
1307 }
1308 }
1309 break;
1310
1311 case MPHC_NETWORK_SYNC_IND:
1312 {
1313 char *ptr;
1314
1315 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_NETWORK_SYNC_IND), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1316 {
1317
1318 ((T_TR_MPHC_NETWORK_SYNC_IND *)(ptr))->header = TRL1_MPHC_NETWORK_SYNC_IND | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1319 ((T_TR_MPHC_NETWORK_SYNC_IND *)(ptr))->sb_flag = ((T_MPHC_NETWORK_SYNC_IND*)(msg->SigP))->sb_flag;
1320 ((T_TR_MPHC_NETWORK_SYNC_IND *)(ptr))->radio_freq = ((T_MPHC_NETWORK_SYNC_IND*)(msg->SigP))->radio_freq;
1321 ((T_TR_MPHC_NETWORK_SYNC_IND *)(ptr))->fn_offset = ((T_MPHC_NETWORK_SYNC_IND*)(msg->SigP))->fn_offset;
1322 ((T_TR_MPHC_NETWORK_SYNC_IND *)(ptr))->time_alignmt = ((T_MPHC_NETWORK_SYNC_IND*)(msg->SigP))->time_alignmt;
1323 ((T_TR_MPHC_NETWORK_SYNC_IND *)(ptr))->bsic = ((T_MPHC_NETWORK_SYNC_IND*)(msg->SigP))->bsic;
1324
1325 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_NETWORK_SYNC_IND));
1326 }
1327 }
1328 break;
1329
1330 case MPHC_NCELL_SYNC_IND:
1331 {
1332 char *ptr;
1333
1334 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_NCELL_SYNC_IND), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1335 {
1336
1337 ((T_TR_MPHC_NCELL_SYNC_IND *)(ptr))->header = TRL1_MPHC_NCELL_SYNC_IND | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1338 ((T_TR_MPHC_NCELL_SYNC_IND *)(ptr))->radio_freq = ((T_MPHC_NCELL_SYNC_IND*)(msg->SigP))->radio_freq;
1339 ((T_TR_MPHC_NCELL_SYNC_IND *)(ptr))->sb_flag = ((T_MPHC_NCELL_SYNC_IND*)(msg->SigP))->sb_flag;
1340 ((T_TR_MPHC_NCELL_SYNC_IND *)(ptr))->fn_offset = ((T_MPHC_NCELL_SYNC_IND*)(msg->SigP))->fn_offset;
1341 ((T_TR_MPHC_NCELL_SYNC_IND *)(ptr))->time_alignmt = ((T_MPHC_NCELL_SYNC_IND*)(msg->SigP))->time_alignmt;
1342 ((T_TR_MPHC_NCELL_SYNC_IND *)(ptr))->bsic = ((T_MPHC_NCELL_SYNC_IND*)(msg->SigP))->bsic;
1343 ((T_TR_MPHC_NCELL_SYNC_IND *)(ptr))->neigh_id = ((T_MPHC_NCELL_SYNC_IND*)(msg->SigP))->neigh_id;
1344 ((T_TR_MPHC_NCELL_SYNC_IND *)(ptr))->list_size = l1a_l1s_com.nsync.current_list_size;
1345 #if (L1_EOTD)
1346 ((T_TR_MPHC_NCELL_SYNC_IND *)(ptr))->eotd_data_valid = ((T_MPHC_NCELL_SYNC_IND*)(msg->SigP))->eotd_data_valid;
1347 ((T_TR_MPHC_NCELL_SYNC_IND *)(ptr))->mode = ((T_MPHC_NCELL_SYNC_IND*)(msg->SigP))->mode;
1348 ((T_TR_MPHC_NCELL_SYNC_IND *)(ptr))->fn_sb_neigh = ((T_MPHC_NCELL_SYNC_IND*)(msg->SigP))->fn_sb_neigh;
1349 ((T_TR_MPHC_NCELL_SYNC_IND *)(ptr))->fn_in_SB = ((T_MPHC_NCELL_SYNC_IND*)(msg->SigP))->fn_in_SB;
1350 ((T_TR_MPHC_NCELL_SYNC_IND *)(ptr))->toa_correction = ((T_MPHC_NCELL_SYNC_IND*)(msg->SigP))->toa_correction;
1351 ((T_TR_MPHC_NCELL_SYNC_IND *)(ptr))->delta_fn = ((T_MPHC_NCELL_SYNC_IND*)(msg->SigP))->delta_fn;
1352 ((T_TR_MPHC_NCELL_SYNC_IND *)(ptr))->delta_qbit = ((T_MPHC_NCELL_SYNC_IND*)(msg->SigP))->delta_qbit;
1353 #endif
1354 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_NCELL_SYNC_IND));
1355 }
1356 }
1357 break;
1358
1359 // Neighbor cell BCCH reading
1360
1361 case MPHC_NCELL_BCCH_REQ:
1362 {
1363 char *ptr;
1364
1365 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_NCELL_BCCH_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1366 {
1367
1368 ((T_TR_MPHC_NCELL_BCCH_REQ *)(ptr))->header = TRL1_MPHC_NCELL_BCCH_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1369 ((T_TR_MPHC_NCELL_BCCH_REQ *)(ptr))->radio_freq = ((T_MPHC_NCELL_BCCH_REQ *)(msg->SigP))->radio_freq;
1370 ((T_TR_MPHC_NCELL_BCCH_REQ *)(ptr))->fn_offset = ((T_MPHC_NCELL_BCCH_REQ *)(msg->SigP))->fn_offset;
1371 ((T_TR_MPHC_NCELL_BCCH_REQ *)(ptr))->time_alignmt = ((T_MPHC_NCELL_BCCH_REQ *)(msg->SigP))->time_alignmt;
1372 ((T_TR_MPHC_NCELL_BCCH_REQ *)(ptr))->tsc = ((T_MPHC_NCELL_BCCH_REQ *)(msg->SigP))->tsc;
1373 ((T_TR_MPHC_NCELL_BCCH_REQ *)(ptr))->bcch_blks_req = ((T_MPHC_NCELL_BCCH_REQ *)(msg->SigP))->bcch_blks_req;
1374 #if L1_GPRS
1375 ((T_TR_MPHC_NCELL_BCCH_REQ *)(ptr))->gprs_priority = ((T_MPHC_NCELL_BCCH_REQ *)(msg->SigP))->gprs_priority;
1376 #endif
1377
1378 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_NCELL_BCCH_REQ));
1379 }
1380 }
1381 break;
1382
1383 case MPHC_STOP_NCELL_BCCH_REQ:
1384 {
1385 char *ptr;
1386
1387 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_STOP_NCELL_BCCH_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1388 {
1389
1390 ((T_TR_MPHC_STOP_NCELL_BCCH_REQ *)(ptr))->header = TRL1_MPHC_STOP_NCELL_BCCH_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1391 ((T_TR_MPHC_STOP_NCELL_BCCH_REQ *)(ptr))->radio_freq_array_size = ((T_MPHC_STOP_NCELL_BCCH_REQ *)(msg->SigP))->radio_freq_array_size;
1392 ((T_TR_MPHC_STOP_NCELL_BCCH_REQ *)(ptr))->radio_freq_array[0] = ((T_MPHC_STOP_NCELL_BCCH_REQ *)(msg->SigP))->radio_freq_array[0];
1393 ((T_TR_MPHC_STOP_NCELL_BCCH_REQ *)(ptr))->radio_freq_array[1] = ((T_MPHC_STOP_NCELL_BCCH_REQ *)(msg->SigP))->radio_freq_array[1];
1394 ((T_TR_MPHC_STOP_NCELL_BCCH_REQ *)(ptr))->radio_freq_array[2] = ((T_MPHC_STOP_NCELL_BCCH_REQ *)(msg->SigP))->radio_freq_array[2];
1395 ((T_TR_MPHC_STOP_NCELL_BCCH_REQ *)(ptr))->radio_freq_array[3] = ((T_MPHC_STOP_NCELL_BCCH_REQ *)(msg->SigP))->radio_freq_array[3];
1396 ((T_TR_MPHC_STOP_NCELL_BCCH_REQ *)(ptr))->radio_freq_array[4] = ((T_MPHC_STOP_NCELL_BCCH_REQ *)(msg->SigP))->radio_freq_array[4];
1397 ((T_TR_MPHC_STOP_NCELL_BCCH_REQ *)(ptr))->radio_freq_array[5] = ((T_MPHC_STOP_NCELL_BCCH_REQ *)(msg->SigP))->radio_freq_array[5];
1398
1399 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_STOP_NCELL_BCCH_REQ));
1400 }
1401 }
1402 break;
1403
1404 case L1C_BCCHN_INFO:
1405 {
1406 char *ptr;
1407
1408 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1C_BCCHN_INFO), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1409 {
1410
1411 ((T_TR_L1C_BCCHN_INFO *)(ptr))->header = TRL1_L1C_BCCHN_INFO | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1412 ((T_TR_L1C_BCCHN_INFO *)(ptr))->error_flag = ((T_MPHC_DATA_IND *)(msg->SigP))->error_flag;
1413 ((T_TR_L1C_BCCHN_INFO *)(ptr))->radio_freq = ((T_MPHC_DATA_IND *)(msg->SigP))->radio_freq;
1414 ((T_TR_L1C_BCCHN_INFO *)(ptr))->input_level = l1a_l1s_com.last_input_level[((T_MPHC_DATA_IND *)(msg->SigP))->radio_freq -
1415 l1_config.std.radio_freq_index_offset].input_level;
1416 ((T_TR_L1C_BCCHN_INFO *)(ptr))->tpu_offset = l1s.tpu_offset;
1417 ((T_TR_L1C_BCCHN_INFO *)(ptr))->afc = l1s.afc;
1418
1419 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1C_BCCHN_INFO));
1420 }
1421 }
1422 break;
1423
1424 ///////////////////////////////////////
1425 // Serving cell normal burst reading //
1426 ///////////////////////////////////////
1427
1428 // CCCH reading
1429
1430 case MPHC_START_CCCH_REQ:
1431 {
1432 char *ptr;
1433
1434 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_START_CCCH_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1435 {
1436
1437 ((T_TR_MPHC_START_CCCH_REQ *)(ptr))->header = TRL1_MPHC_START_CCCH_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1438 ((T_TR_MPHC_START_CCCH_REQ *)(ptr))->bs_pa_mfrms = ((T_MPHC_START_CCCH_REQ *)(msg->SigP))->bs_pa_mfrms;
1439 ((T_TR_MPHC_START_CCCH_REQ *)(ptr))->bs_ag_blks_res = ((T_MPHC_START_CCCH_REQ *)(msg->SigP))->bs_ag_blks_res;
1440 ((T_TR_MPHC_START_CCCH_REQ *)(ptr))->bcch_combined = ((T_MPHC_START_CCCH_REQ *)(msg->SigP))->bcch_combined;
1441 ((T_TR_MPHC_START_CCCH_REQ *)(ptr))->ccch_group = ((T_MPHC_START_CCCH_REQ *)(msg->SigP))->ccch_group;
1442 ((T_TR_MPHC_START_CCCH_REQ *)(ptr))->page_group = ((T_MPHC_START_CCCH_REQ *)(msg->SigP))->page_group;
1443 ((T_TR_MPHC_START_CCCH_REQ *)(ptr))->page_block_index = ((T_MPHC_START_CCCH_REQ *)(msg->SigP))->page_block_index;
1444 ((T_TR_MPHC_START_CCCH_REQ *)(ptr))->page_mode = ((T_MPHC_START_CCCH_REQ *)(msg->SigP))->page_mode;
1445
1446 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_START_CCCH_REQ));
1447 }
1448 }
1449 break;
1450
1451 case MPHC_STOP_CCCH_REQ:
1452 {
1453 char *ptr;
1454
1455 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_STOP_CCCH_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1456 {
1457
1458 ((T_TR_MPHC_STOP_CCCH_REQ *)(ptr))->header = TRL1_MPHC_STOP_CCCH_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1459
1460 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_STOP_CCCH_REQ));
1461 }
1462 }
1463 break;
1464
1465 case L1C_NP_INFO:
1466 {
1467 char *ptr;
1468
1469 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1C_NP_INFO), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1470 {
1471
1472 ((T_TR_L1C_NP_INFO *)(ptr))->header = TRL1_L1C_NP_INFO | (((T_MPHC_DATA_IND *)(msg->SigP))->fn << TR_HEADER_FN_DELAY);
1473 ((T_TR_L1C_NP_INFO *)(ptr))->error_flag = ((T_MPHC_DATA_IND *)(msg->SigP))->error_flag;
1474 ((T_TR_L1C_NP_INFO *)(ptr))->radio_freq = ((T_MPHC_DATA_IND *)(msg->SigP))->radio_freq;
1475 ((T_TR_L1C_NP_INFO *)(ptr))->input_level = l1a_l1s_com.Scell_IL_for_rxlev;
1476 ((T_TR_L1C_NP_INFO *)(ptr))->tpu_offset = l1s.tpu_offset;
1477 ((T_TR_L1C_NP_INFO *)(ptr))->afc = l1s.afc;
1478
1479 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1C_NP_INFO));
1480 }
1481 }
1482 break;
1483
1484 case L1C_EP_INFO:
1485 {
1486 char *ptr;
1487
1488 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1C_EP_INFO), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1489 {
1490
1491 ((T_TR_L1C_EP_INFO *)(ptr))->header = TRL1_L1C_EP_INFO | (((T_MPHC_DATA_IND *)(msg->SigP))->fn << TR_HEADER_FN_DELAY);
1492 ((T_TR_L1C_EP_INFO *)(ptr))->error_flag = ((T_MPHC_DATA_IND *)(msg->SigP))->error_flag;
1493 ((T_TR_L1C_EP_INFO *)(ptr))->radio_freq = ((T_MPHC_DATA_IND *)(msg->SigP))->radio_freq;
1494 ((T_TR_L1C_EP_INFO *)(ptr))->input_level = l1a_l1s_com.Scell_IL_for_rxlev;
1495 ((T_TR_L1C_EP_INFO *)(ptr))->tpu_offset = l1s.tpu_offset;
1496 ((T_TR_L1C_EP_INFO *)(ptr))->afc = l1s.afc;
1497
1498 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1C_EP_INFO));
1499 }
1500 }
1501 break;
1502
1503 case L1C_ALLC_INFO:
1504 {
1505 char *ptr;
1506
1507 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1C_ALLC_INFO), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1508 {
1509
1510 ((T_TR_L1C_ALLC_INFO *)(ptr))->header = TRL1_L1C_ALLC_INFO | (((T_MPHC_DATA_IND *)(msg->SigP))->fn << TR_HEADER_FN_DELAY);
1511 ((T_TR_L1C_ALLC_INFO *)(ptr))->error_flag = ((T_MPHC_DATA_IND *)(msg->SigP))->error_flag;
1512 ((T_TR_L1C_ALLC_INFO *)(ptr))->radio_freq = ((T_MPHC_DATA_IND *)(msg->SigP))->radio_freq;
1513 ((T_TR_L1C_ALLC_INFO *)(ptr))->input_level = l1a_l1s_com.Scell_IL_for_rxlev;
1514 ((T_TR_L1C_ALLC_INFO *)(ptr))->tpu_offset = l1s.tpu_offset;
1515 ((T_TR_L1C_ALLC_INFO *)(ptr))->afc = l1s.afc;
1516
1517 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1C_ALLC_INFO));
1518 }
1519 }
1520 break;
1521
1522 // BCCH reading
1523
1524 case MPHC_SCELL_NBCCH_REQ:
1525 {
1526 char *ptr;
1527
1528 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_SCELL_NBCCH_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1529 {
1530
1531 ((T_TR_MPHC_SCELL_NBCCH_REQ *)(ptr))->header = TRL1_MPHC_SCELL_NBCCH_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1532 ((T_TR_MPHC_SCELL_NBCCH_REQ *)(ptr))->schedule_array_size = ((T_MPHC_SCELL_NBCCH_REQ *)(msg->SigP))->schedule_array_size;
1533 ((T_TR_MPHC_SCELL_NBCCH_REQ *)(ptr))->modulus[0] = ((T_MPHC_SCELL_NBCCH_REQ *)(msg->SigP))->schedule_array[0].modulus;
1534 ((T_TR_MPHC_SCELL_NBCCH_REQ *)(ptr))->modulus[1] = ((T_MPHC_SCELL_NBCCH_REQ *)(msg->SigP))->schedule_array[1].modulus;
1535 ((T_TR_MPHC_SCELL_NBCCH_REQ *)(ptr))->modulus[2] = ((T_MPHC_SCELL_NBCCH_REQ *)(msg->SigP))->schedule_array[2].modulus;
1536 ((T_TR_MPHC_SCELL_NBCCH_REQ *)(ptr))->modulus[3] = ((T_MPHC_SCELL_NBCCH_REQ *)(msg->SigP))->schedule_array[3].modulus;
1537 ((T_TR_MPHC_SCELL_NBCCH_REQ *)(ptr))->modulus[4] = ((T_MPHC_SCELL_NBCCH_REQ *)(msg->SigP))->schedule_array[4].modulus;
1538 ((T_TR_MPHC_SCELL_NBCCH_REQ *)(ptr))->modulus[5] = ((T_MPHC_SCELL_NBCCH_REQ *)(msg->SigP))->schedule_array[5].modulus;
1539 ((T_TR_MPHC_SCELL_NBCCH_REQ *)(ptr))->modulus[6] = ((T_MPHC_SCELL_NBCCH_REQ *)(msg->SigP))->schedule_array[6].modulus;
1540 ((T_TR_MPHC_SCELL_NBCCH_REQ *)(ptr))->modulus[7] = ((T_MPHC_SCELL_NBCCH_REQ *)(msg->SigP))->schedule_array[7].modulus;
1541 ((T_TR_MPHC_SCELL_NBCCH_REQ *)(ptr))->modulus[8] = ((T_MPHC_SCELL_NBCCH_REQ *)(msg->SigP))->schedule_array[8].modulus;
1542 ((T_TR_MPHC_SCELL_NBCCH_REQ *)(ptr))->modulus[9] = ((T_MPHC_SCELL_NBCCH_REQ *)(msg->SigP))->schedule_array[9].modulus;
1543 ((T_TR_MPHC_SCELL_NBCCH_REQ *)(ptr))->relative_position[0] = ((T_MPHC_SCELL_NBCCH_REQ *)(msg->SigP))->schedule_array[0].relative_position;
1544 ((T_TR_MPHC_SCELL_NBCCH_REQ *)(ptr))->relative_position[1] = ((T_MPHC_SCELL_NBCCH_REQ *)(msg->SigP))->schedule_array[1].relative_position;
1545 ((T_TR_MPHC_SCELL_NBCCH_REQ *)(ptr))->relative_position[2] = ((T_MPHC_SCELL_NBCCH_REQ *)(msg->SigP))->schedule_array[2].relative_position;
1546 ((T_TR_MPHC_SCELL_NBCCH_REQ *)(ptr))->relative_position[3] = ((T_MPHC_SCELL_NBCCH_REQ *)(msg->SigP))->schedule_array[3].relative_position;
1547 ((T_TR_MPHC_SCELL_NBCCH_REQ *)(ptr))->relative_position[4] = ((T_MPHC_SCELL_NBCCH_REQ *)(msg->SigP))->schedule_array[4].relative_position;
1548 ((T_TR_MPHC_SCELL_NBCCH_REQ *)(ptr))->relative_position[5] = ((T_MPHC_SCELL_NBCCH_REQ *)(msg->SigP))->schedule_array[5].relative_position;
1549 ((T_TR_MPHC_SCELL_NBCCH_REQ *)(ptr))->relative_position[6] = ((T_MPHC_SCELL_NBCCH_REQ *)(msg->SigP))->schedule_array[6].relative_position;
1550 ((T_TR_MPHC_SCELL_NBCCH_REQ *)(ptr))->relative_position[7] = ((T_MPHC_SCELL_NBCCH_REQ *)(msg->SigP))->schedule_array[7].relative_position;
1551 ((T_TR_MPHC_SCELL_NBCCH_REQ *)(ptr))->relative_position[8] = ((T_MPHC_SCELL_NBCCH_REQ *)(msg->SigP))->schedule_array[8].relative_position;
1552 ((T_TR_MPHC_SCELL_NBCCH_REQ *)(ptr))->relative_position[9] = ((T_MPHC_SCELL_NBCCH_REQ *)(msg->SigP))->schedule_array[9].relative_position;
1553
1554 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_SCELL_NBCCH_REQ));
1555 }
1556 }
1557 break;
1558
1559 case MPHC_SCELL_EBCCH_REQ:
1560 {
1561 char *ptr;
1562
1563 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_SCELL_EBCCH_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1564 {
1565
1566 ((T_TR_MPHC_SCELL_EBCCH_REQ *)(ptr))->header = TRL1_MPHC_SCELL_EBCCH_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1567 ((T_TR_MPHC_SCELL_EBCCH_REQ *)(ptr))->schedule_array_size = ((T_MPHC_SCELL_EBCCH_REQ *)(msg->SigP))->schedule_array_size;
1568 ((T_TR_MPHC_SCELL_EBCCH_REQ *)(ptr))->modulus[0] = ((T_MPHC_SCELL_EBCCH_REQ *)(msg->SigP))->schedule_array[0].modulus;
1569 ((T_TR_MPHC_SCELL_EBCCH_REQ *)(ptr))->modulus[1] = ((T_MPHC_SCELL_EBCCH_REQ *)(msg->SigP))->schedule_array[1].modulus;
1570 ((T_TR_MPHC_SCELL_EBCCH_REQ *)(ptr))->modulus[2] = ((T_MPHC_SCELL_EBCCH_REQ *)(msg->SigP))->schedule_array[2].modulus;
1571 ((T_TR_MPHC_SCELL_EBCCH_REQ *)(ptr))->modulus[3] = ((T_MPHC_SCELL_EBCCH_REQ *)(msg->SigP))->schedule_array[3].modulus;
1572 ((T_TR_MPHC_SCELL_EBCCH_REQ *)(ptr))->modulus[4] = ((T_MPHC_SCELL_EBCCH_REQ *)(msg->SigP))->schedule_array[4].modulus;
1573 ((T_TR_MPHC_SCELL_EBCCH_REQ *)(ptr))->modulus[5] = ((T_MPHC_SCELL_EBCCH_REQ *)(msg->SigP))->schedule_array[5].modulus;
1574 ((T_TR_MPHC_SCELL_EBCCH_REQ *)(ptr))->modulus[6] = ((T_MPHC_SCELL_EBCCH_REQ *)(msg->SigP))->schedule_array[6].modulus;
1575 ((T_TR_MPHC_SCELL_EBCCH_REQ *)(ptr))->modulus[7] = ((T_MPHC_SCELL_EBCCH_REQ *)(msg->SigP))->schedule_array[7].modulus;
1576 ((T_TR_MPHC_SCELL_EBCCH_REQ *)(ptr))->modulus[8] = ((T_MPHC_SCELL_EBCCH_REQ *)(msg->SigP))->schedule_array[8].modulus;
1577 ((T_TR_MPHC_SCELL_EBCCH_REQ *)(ptr))->modulus[9] = ((T_MPHC_SCELL_EBCCH_REQ *)(msg->SigP))->schedule_array[9].modulus;
1578 ((T_TR_MPHC_SCELL_EBCCH_REQ *)(ptr))->relative_position[0] = ((T_MPHC_SCELL_EBCCH_REQ *)(msg->SigP))->schedule_array[0].relative_position;
1579 ((T_TR_MPHC_SCELL_EBCCH_REQ *)(ptr))->relative_position[1] = ((T_MPHC_SCELL_EBCCH_REQ *)(msg->SigP))->schedule_array[1].relative_position;
1580 ((T_TR_MPHC_SCELL_EBCCH_REQ *)(ptr))->relative_position[2] = ((T_MPHC_SCELL_EBCCH_REQ *)(msg->SigP))->schedule_array[2].relative_position;
1581 ((T_TR_MPHC_SCELL_EBCCH_REQ *)(ptr))->relative_position[3] = ((T_MPHC_SCELL_EBCCH_REQ *)(msg->SigP))->schedule_array[3].relative_position;
1582 ((T_TR_MPHC_SCELL_EBCCH_REQ *)(ptr))->relative_position[4] = ((T_MPHC_SCELL_EBCCH_REQ *)(msg->SigP))->schedule_array[4].relative_position;
1583 ((T_TR_MPHC_SCELL_EBCCH_REQ *)(ptr))->relative_position[5] = ((T_MPHC_SCELL_EBCCH_REQ *)(msg->SigP))->schedule_array[5].relative_position;
1584 ((T_TR_MPHC_SCELL_EBCCH_REQ *)(ptr))->relative_position[6] = ((T_MPHC_SCELL_EBCCH_REQ *)(msg->SigP))->schedule_array[6].relative_position;
1585 ((T_TR_MPHC_SCELL_EBCCH_REQ *)(ptr))->relative_position[7] = ((T_MPHC_SCELL_EBCCH_REQ *)(msg->SigP))->schedule_array[7].relative_position;
1586 ((T_TR_MPHC_SCELL_EBCCH_REQ *)(ptr))->relative_position[8] = ((T_MPHC_SCELL_EBCCH_REQ *)(msg->SigP))->schedule_array[8].relative_position;
1587 ((T_TR_MPHC_SCELL_EBCCH_REQ *)(ptr))->relative_position[9] = ((T_MPHC_SCELL_EBCCH_REQ *)(msg->SigP))->schedule_array[9].relative_position;
1588
1589 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_SCELL_EBCCH_REQ));
1590 }
1591 }
1592 break;
1593
1594 case MPHC_STOP_SCELL_BCCH_REQ:
1595 {
1596 char *ptr;
1597
1598 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_STOP_SCELL_BCCH_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1599 {
1600
1601 ((T_TR_MPHC_STOP_SCELL_BCCH_REQ *)(ptr))->header = TRL1_MPHC_STOP_SCELL_BCCH_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1602
1603 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_STOP_SCELL_BCCH_REQ));
1604 }
1605 }
1606 break;
1607
1608 case L1C_BCCHS_INFO:
1609 {
1610 char *ptr;
1611
1612 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1C_BCCHS_INFO), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1613 {
1614
1615 ((T_TR_L1C_BCCHS_INFO *)(ptr))->header = TRL1_L1C_BCCHS_INFO | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1616 ((T_TR_L1C_BCCHS_INFO *)(ptr))->error_flag = ((T_MPHC_DATA_IND *)(msg->SigP))->error_flag;
1617 ((T_TR_L1C_BCCHS_INFO *)(ptr))->radio_freq = ((T_MPHC_DATA_IND *)(msg->SigP))->radio_freq;
1618 ((T_TR_L1C_BCCHS_INFO *)(ptr))->input_level = l1a_l1s_com.Scell_IL_for_rxlev;
1619 ((T_TR_L1C_BCCHS_INFO *)(ptr))->tpu_offset = l1s.tpu_offset;
1620 ((T_TR_L1C_BCCHS_INFO *)(ptr))->afc = l1s.afc;
1621
1622 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1C_BCCHS_INFO));
1623 }
1624 }
1625 break;
1626
1627 //////////
1628 // CBCH //
1629 //////////
1630
1631 case MPHC_CONFIG_CBCH_REQ:
1632 {
1633 char *ptr;
1634
1635 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_CONFIG_CBCH_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1636 {
1637
1638 ((T_TR_MPHC_CONFIG_CBCH_REQ *)(ptr))->header = TRL1_MPHC_CONFIG_CBCH_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1639 ((T_TR_MPHC_CONFIG_CBCH_REQ *)(ptr))->h = ((T_MPHC_CONFIG_CBCH_REQ *)(msg->SigP))->cbch_desc.chan_sel.h;
1640 ((T_TR_MPHC_CONFIG_CBCH_REQ *)(ptr))->radio_freq = ((T_MPHC_CONFIG_CBCH_REQ *)(msg->SigP))->cbch_desc.chan_sel.rf_channel.single_rf.radio_freq;
1641 ((T_TR_MPHC_CONFIG_CBCH_REQ *)(ptr))->timeslot_no = ((T_MPHC_CONFIG_CBCH_REQ *)(msg->SigP))->cbch_desc.timeslot_no;
1642
1643 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_CONFIG_CBCH_REQ));
1644 }
1645 }
1646 break;
1647
1648 case MPHC_CBCH_SCHEDULE_REQ:
1649 {
1650 char *ptr;
1651
1652 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_CBCH_SCHEDULE_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1653 {
1654
1655 ((T_TR_MPHC_CBCH_SCHEDULE_REQ *)(ptr))->header = TRL1_MPHC_CBCH_SCHEDULE_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1656 ((T_TR_MPHC_CBCH_SCHEDULE_REQ *)(ptr))->extended_cbch = ((T_MPHC_CBCH_SCHEDULE_REQ *)(msg->SigP))->extended_cbch;
1657 ((T_TR_MPHC_CBCH_SCHEDULE_REQ *)(ptr))->schedule_length = ((T_MPHC_CBCH_SCHEDULE_REQ *)(msg->SigP))->schedule_length;
1658 ((T_TR_MPHC_CBCH_SCHEDULE_REQ *)(ptr))->first_block_0 = ((T_MPHC_CBCH_SCHEDULE_REQ *)(msg->SigP))->first_block_0;
1659 ((T_TR_MPHC_CBCH_SCHEDULE_REQ *)(ptr))->first_block_1 = ((T_MPHC_CBCH_SCHEDULE_REQ *)(msg->SigP))->first_block_1;
1660
1661 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_CBCH_SCHEDULE_REQ));
1662 }
1663 }
1664 break;
1665
1666 case MPHC_CBCH_INFO_REQ:
1667 {
1668 char *ptr;
1669
1670 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_CBCH_INFO_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1671 {
1672
1673 ((T_TR_MPHC_CBCH_INFO_REQ *)(ptr))->header = TRL1_MPHC_CBCH_INFO_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1674 ((T_TR_MPHC_CBCH_INFO_REQ *)(ptr))->tb_bitmap = ((T_MPHC_CBCH_INFO_REQ *)(msg->SigP))->tb_bitmap;
1675
1676 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_CBCH_INFO_REQ));
1677 }
1678 }
1679 break;
1680
1681 case MPHC_CBCH_UPDATE_REQ:
1682 {
1683 char *ptr;
1684
1685 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_CBCH_UPDATE_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1686 {
1687
1688 ((T_TR_MPHC_CBCH_UPDATE_REQ *)(ptr))->header = TRL1_MPHC_CBCH_UPDATE_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1689 ((T_TR_MPHC_CBCH_UPDATE_REQ *)(ptr))->extended_cbch = ((T_MPHC_CBCH_UPDATE_REQ*)(msg->SigP))->extended_cbch;
1690 ((T_TR_MPHC_CBCH_UPDATE_REQ *)(ptr))->first_block_0 = ((T_MPHC_CBCH_UPDATE_REQ*)(msg->SigP))->first_block_0;
1691 ((T_TR_MPHC_CBCH_UPDATE_REQ *)(ptr))->first_block_1 = ((T_MPHC_CBCH_UPDATE_REQ*)(msg->SigP))->first_block_1;
1692
1693 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_CBCH_UPDATE_REQ));
1694 }
1695 }
1696 break;
1697
1698 case L1C_CB_INFO:
1699 {
1700 char *ptr;
1701
1702 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1C_CB_INFO), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1703 {
1704
1705 ((T_TR_L1C_CB_INFO *)(ptr))->header = TRL1_L1C_CB_INFO | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1706 ((T_TR_L1C_CB_INFO *)(ptr))->error_flag = ((T_MPHC_DATA_IND *)(msg->SigP))->error_flag;
1707 ((T_TR_L1C_CB_INFO *)(ptr))->radio_freq = ((T_MPHC_DATA_IND *)(msg->SigP))->radio_freq;
1708 ((T_TR_L1C_CB_INFO *)(ptr))->input_level = l1a_l1s_com.Scell_IL_for_rxlev;
1709 ((T_TR_L1C_CB_INFO *)(ptr))->tpu_offset = l1s.tpu_offset;
1710 ((T_TR_L1C_CB_INFO *)(ptr))->afc = l1s.afc;
1711
1712 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1C_CB_INFO));
1713 }
1714 }
1715 break;
1716
1717 // Stop CBCH
1718
1719 case MPHC_STOP_CBCH_REQ:
1720 {
1721 char *ptr;
1722
1723 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_STOP_CBCH_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1724 {
1725
1726 ((T_TR_MPHC_STOP_CBCH_REQ *)(ptr))->header = TRL1_MPHC_STOP_CBCH_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1727 ((T_TR_MPHC_STOP_CBCH_REQ *)(ptr))->normal_cbch = ((T_MPHC_STOP_CBCH_REQ *)(msg->SigP))->normal_cbch;
1728 ((T_TR_MPHC_STOP_CBCH_REQ *)(ptr))->extended_cbch = ((T_MPHC_STOP_CBCH_REQ *)(msg->SigP))->extended_cbch;
1729
1730 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_STOP_CBCH_REQ));
1731 }
1732 }
1733 break;
1734
1735 case MPHC_STOP_CBCH_CON:
1736 {
1737 char *ptr;
1738
1739 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_STOP_CBCH_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1740 {
1741
1742 ((T_TR_MPHC_STOP_CBCH_CON *)(ptr))->header = TRL1_MPHC_STOP_CBCH_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1743
1744 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_STOP_CBCH_CON));
1745 }
1746 }
1747 break;
1748
1749 ///////////////////
1750 // Random Access //
1751 ///////////////////
1752
1753 case MPHC_RA_REQ:
1754 {
1755 char *ptr;
1756
1757 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_RA_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1758 {
1759
1760 ((T_TR_MPHC_RA_REQ *)(ptr))->header = TRL1_MPHC_RA_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1761 ((T_TR_MPHC_RA_REQ *)(ptr))->txpwr = ((T_MPHC_RA_REQ *)(msg->SigP))->txpwr;
1762 ((T_TR_MPHC_RA_REQ *)(ptr))->rand = ((T_MPHC_RA_REQ *)(msg->SigP))->rand;
1763 ((T_TR_MPHC_RA_REQ *)(ptr))->channel_request = ((T_MPHC_RA_REQ *)(msg->SigP))->channel_request;
1764 ((T_TR_MPHC_RA_REQ *)(ptr))->powerclass_band1 = ((T_MPHC_RA_REQ *)(msg->SigP))->powerclass_band1;
1765 ((T_TR_MPHC_RA_REQ *)(ptr))->powerclass_band2 = ((T_MPHC_RA_REQ *)(msg->SigP))->powerclass_band2;
1766
1767 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_RA_REQ));
1768 }
1769 }
1770 break;
1771
1772 case MPHC_STOP_RA_REQ:
1773 {
1774 char *ptr;
1775
1776 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_STOP_RA_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1777 {
1778
1779 ((T_TR_MPHC_STOP_RA_REQ *)(ptr))->header = TRL1_MPHC_STOP_RA_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1780
1781 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_STOP_RA_REQ));
1782 }
1783 }
1784 break;
1785
1786 case L1C_RA_DONE:
1787 {
1788 char *ptr;
1789
1790 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1C_RA_DONE), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1791 {
1792
1793 ((T_TR_L1C_RA_DONE *)(ptr))->header = TRL1_L1C_RA_DONE | (((T_MPHC_RA_CON *)(msg->SigP))->fn << TR_HEADER_FN_DELAY);
1794
1795 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1C_RA_DONE));
1796 }
1797 }
1798 break;
1799
1800 /////////////////////////////
1801 // Dedicated mode channels //
1802 /////////////////////////////
1803
1804 // Immediate assignment
1805
1806 case MPHC_IMMED_ASSIGN_REQ:
1807 {
1808 char *ptr;
1809
1810 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_IMMED_ASSIGN_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1811 {
1812
1813 ((T_TR_MPHC_IMMED_ASSIGN_REQ *)(ptr))->header = TRL1_MPHC_IMMED_ASSIGN_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1814 ((T_TR_MPHC_IMMED_ASSIGN_REQ *)(ptr))->h = ((T_MPHC_IMMED_ASSIGN_REQ *)(msg->SigP))->channel_desc.chan_sel.h;
1815 ((T_TR_MPHC_IMMED_ASSIGN_REQ *)(ptr))->radio_freq = ((T_MPHC_IMMED_ASSIGN_REQ *)(msg->SigP))->channel_desc.chan_sel.rf_channel.single_rf.radio_freq;
1816 ((T_TR_MPHC_IMMED_ASSIGN_REQ *)(ptr))->channel_type = ((T_MPHC_IMMED_ASSIGN_REQ *)(msg->SigP))->channel_desc.channel_type;
1817 ((T_TR_MPHC_IMMED_ASSIGN_REQ *)(ptr))->subchannel = ((T_MPHC_IMMED_ASSIGN_REQ *)(msg->SigP))->channel_desc.subchannel;
1818 ((T_TR_MPHC_IMMED_ASSIGN_REQ *)(ptr))->timeslot_no = ((T_MPHC_IMMED_ASSIGN_REQ *)(msg->SigP))->channel_desc.timeslot_no;
1819 ((T_TR_MPHC_IMMED_ASSIGN_REQ *)(ptr))->tsc = ((T_MPHC_IMMED_ASSIGN_REQ *)(msg->SigP))->channel_desc.tsc;
1820 ((T_TR_MPHC_IMMED_ASSIGN_REQ *)(ptr))->timing_advance = ((T_MPHC_IMMED_ASSIGN_REQ *)(msg->SigP))->timing_advance;
1821 ((T_TR_MPHC_IMMED_ASSIGN_REQ *)(ptr))->rf_chan_cnt = ((T_MPHC_IMMED_ASSIGN_REQ *)(msg->SigP))->frequency_list.rf_chan_cnt;
1822 ((T_TR_MPHC_IMMED_ASSIGN_REQ *)(ptr))->starting_time_present = ((T_MPHC_IMMED_ASSIGN_REQ *)(msg->SigP))->starting_time.start_time_present;
1823 ((T_TR_MPHC_IMMED_ASSIGN_REQ *)(ptr))->n32 = ((T_MPHC_IMMED_ASSIGN_REQ *)(msg->SigP))->starting_time.start_time.n32;
1824 ((T_TR_MPHC_IMMED_ASSIGN_REQ *)(ptr))->n51 = ((T_MPHC_IMMED_ASSIGN_REQ *)(msg->SigP))->starting_time.start_time.n51;
1825 ((T_TR_MPHC_IMMED_ASSIGN_REQ *)(ptr))->n26 = ((T_MPHC_IMMED_ASSIGN_REQ *)(msg->SigP))->starting_time.start_time.n26;
1826 ((T_TR_MPHC_IMMED_ASSIGN_REQ *)(ptr))->bef_sti_rf_chan_cnt = ((T_MPHC_IMMED_ASSIGN_REQ *)(msg->SigP))->frequency_list_bef_sti.rf_chan_cnt;
1827 ((T_TR_MPHC_IMMED_ASSIGN_REQ *)(ptr))->dtx_allowed = ((T_MPHC_IMMED_ASSIGN_REQ *)(msg->SigP))->dtx_allowed;
1828 ((T_TR_MPHC_IMMED_ASSIGN_REQ *)(ptr))->pwrc = ((T_MPHC_IMMED_ASSIGN_REQ *)(msg->SigP))->pwrc;
1829
1830 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_IMMED_ASSIGN_REQ));
1831 }
1832 }
1833 break;
1834
1835 case MPHC_IMMED_ASSIGN_CON:
1836 {
1837 char *ptr;
1838
1839 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_IMMED_ASSIGN_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1840 {
1841
1842 ((T_TR_MPHC_IMMED_ASSIGN_CON *)(ptr))->header = TRL1_MPHC_IMMED_ASSIGN_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1843
1844 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_IMMED_ASSIGN_CON));
1845 }
1846 }
1847 break;
1848
1849 // Channel assignment
1850
1851 case MPHC_CHANNEL_ASSIGN_REQ:
1852 {
1853 char *ptr;
1854
1855 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_CHANNEL_ASSIGN_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1856 {
1857 ((T_TR_MPHC_CHANNEL_ASSIGN_REQ *)(ptr))->header = TRL1_MPHC_CHANNEL_ASSIGN_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1858 ((T_TR_MPHC_CHANNEL_ASSIGN_REQ *)(ptr))->h = ((T_MPHC_CHANNEL_ASSIGN_REQ *)(msg->SigP))->channel_desc_1.chan_sel.h;
1859 ((T_TR_MPHC_CHANNEL_ASSIGN_REQ *)(ptr))->radio_freq = ((T_MPHC_CHANNEL_ASSIGN_REQ *)(msg->SigP))->channel_desc_1.chan_sel.rf_channel.single_rf.radio_freq;
1860 ((T_TR_MPHC_CHANNEL_ASSIGN_REQ *)(ptr))->channel_type = ((T_MPHC_CHANNEL_ASSIGN_REQ *)(msg->SigP))->channel_desc_1.channel_type;
1861 ((T_TR_MPHC_CHANNEL_ASSIGN_REQ *)(ptr))->subchannel = ((T_MPHC_CHANNEL_ASSIGN_REQ *)(msg->SigP))->channel_desc_1.subchannel;
1862 ((T_TR_MPHC_CHANNEL_ASSIGN_REQ *)(ptr))->timeslot_no = ((T_MPHC_CHANNEL_ASSIGN_REQ *)(msg->SigP))->channel_desc_1.timeslot_no;
1863 ((T_TR_MPHC_CHANNEL_ASSIGN_REQ *)(ptr))->tsc = ((T_MPHC_CHANNEL_ASSIGN_REQ *)(msg->SigP))->channel_desc_1.tsc;
1864 ((T_TR_MPHC_CHANNEL_ASSIGN_REQ *)(ptr))->channel_mode_1 = ((T_MPHC_CHANNEL_ASSIGN_REQ *)(msg->SigP))->channel_mode_1;
1865 ((T_TR_MPHC_CHANNEL_ASSIGN_REQ *)(ptr))->txpwr = ((T_MPHC_CHANNEL_ASSIGN_REQ *)(msg->SigP))->txpwr;
1866 ((T_TR_MPHC_CHANNEL_ASSIGN_REQ *)(ptr))->rf_chan_cnt = ((T_MPHC_CHANNEL_ASSIGN_REQ *)(msg->SigP))->frequency_list.rf_chan_cnt;
1867 ((T_TR_MPHC_CHANNEL_ASSIGN_REQ *)(ptr))->starting_time_present = ((T_MPHC_CHANNEL_ASSIGN_REQ *)(msg->SigP))->starting_time.start_time_present;
1868 ((T_TR_MPHC_CHANNEL_ASSIGN_REQ *)(ptr))->n32 = ((T_MPHC_CHANNEL_ASSIGN_REQ *)(msg->SigP))->starting_time.start_time.n32;
1869 ((T_TR_MPHC_CHANNEL_ASSIGN_REQ *)(ptr))->n51 = ((T_MPHC_CHANNEL_ASSIGN_REQ *)(msg->SigP))->starting_time.start_time.n51;
1870 ((T_TR_MPHC_CHANNEL_ASSIGN_REQ *)(ptr))->n26 = ((T_MPHC_CHANNEL_ASSIGN_REQ *)(msg->SigP))->starting_time.start_time.n26;
1871 ((T_TR_MPHC_CHANNEL_ASSIGN_REQ *)(ptr))->bef_sti_rf_chan_cnt = ((T_MPHC_CHANNEL_ASSIGN_REQ *)(msg->SigP))->frequency_list_bef_sti.rf_chan_cnt;
1872 ((T_TR_MPHC_CHANNEL_ASSIGN_REQ *)(ptr))->cipher_mode = ((T_MPHC_CHANNEL_ASSIGN_REQ *)(msg->SigP))->cipher_mode;
1873 ((T_TR_MPHC_CHANNEL_ASSIGN_REQ *)(ptr))->a5_algorithm = ((T_MPHC_CHANNEL_ASSIGN_REQ *)(msg->SigP))->a5_algorithm;
1874 ((T_TR_MPHC_CHANNEL_ASSIGN_REQ *)(ptr))->dtx_allowed = ((T_MPHC_CHANNEL_ASSIGN_REQ *)(msg->SigP))->dtx_allowed;
1875
1876 #if (AMR == 1)
1877 ((T_TR_MPHC_CHANNEL_ASSIGN_REQ *)(ptr))->noise_suppression_bit = ((T_MPHC_CHANNEL_ASSIGN_REQ *)(msg->SigP))->amr_configuration.noise_suppression_bit;
1878 ((T_TR_MPHC_CHANNEL_ASSIGN_REQ *)(ptr))->initial_codec_mode_indicator = ((T_MPHC_CHANNEL_ASSIGN_REQ *)(msg->SigP))->amr_configuration.initial_codec_mode_indicator;
1879 ((T_TR_MPHC_CHANNEL_ASSIGN_REQ *)(ptr))->initial_codec_mode = ((T_MPHC_CHANNEL_ASSIGN_REQ *)(msg->SigP))->amr_configuration.initial_codec_mode;
1880 ((T_TR_MPHC_CHANNEL_ASSIGN_REQ *)(ptr))->active_codec_set = ((T_MPHC_CHANNEL_ASSIGN_REQ *)(msg->SigP))->amr_configuration.active_codec_set;
1881 ((T_TR_MPHC_CHANNEL_ASSIGN_REQ *)(ptr))->threshold[0] = ((T_MPHC_CHANNEL_ASSIGN_REQ *)(msg->SigP))->amr_configuration.threshold[0];
1882 ((T_TR_MPHC_CHANNEL_ASSIGN_REQ *)(ptr))->threshold[1] = ((T_MPHC_CHANNEL_ASSIGN_REQ *)(msg->SigP))->amr_configuration.threshold[1];
1883 ((T_TR_MPHC_CHANNEL_ASSIGN_REQ *)(ptr))->threshold[2] = ((T_MPHC_CHANNEL_ASSIGN_REQ *)(msg->SigP))->amr_configuration.threshold[2];
1884 ((T_TR_MPHC_CHANNEL_ASSIGN_REQ *)(ptr))->hysteresis[0] = ((T_MPHC_CHANNEL_ASSIGN_REQ *)(msg->SigP))->amr_configuration.hysteresis[0];
1885 ((T_TR_MPHC_CHANNEL_ASSIGN_REQ *)(ptr))->hysteresis[1] = ((T_MPHC_CHANNEL_ASSIGN_REQ *)(msg->SigP))->amr_configuration.hysteresis[1];
1886 ((T_TR_MPHC_CHANNEL_ASSIGN_REQ *)(ptr))->hysteresis[2] = ((T_MPHC_CHANNEL_ASSIGN_REQ *)(msg->SigP))->amr_configuration.hysteresis[2];
1887 #endif
1888
1889 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_CHANNEL_ASSIGN_REQ));
1890 }
1891 }
1892 break;
1893
1894 case MPHC_CHANNEL_ASSIGN_CON:
1895 {
1896 char *ptr;
1897
1898 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_CHANNEL_ASSIGN_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1899 {
1900
1901 ((T_TR_MPHC_CHANNEL_ASSIGN_CON *)(ptr))->header = TRL1_MPHC_CHANNEL_ASSIGN_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1902
1903 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_CHANNEL_ASSIGN_CON));
1904 }
1905 }
1906 break;
1907
1908 // SACCH reception
1909
1910 case L1C_SACCH_INFO:
1911 {
1912 char *ptr;
1913
1914 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1C_SACCH_INFO), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1915 {
1916
1917 ((T_TR_L1C_SACCH_INFO *)(ptr))->header = TRL1_L1C_SACCH_INFO | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1918 ((T_TR_L1C_SACCH_INFO *)(ptr))->error_cause = ((T_PH_DATA_IND *)(msg->SigP))->error_cause;
1919 ((T_TR_L1C_SACCH_INFO *)(ptr))->rf_chan_num = ((T_PH_DATA_IND *)(msg->SigP))->rf_chan_num;
1920 ((T_TR_L1C_SACCH_INFO *)(ptr))->beacon_input_level = l1a_l1s_com.Scell_info.traffic_meas_beacon.input_level;
1921 ((T_TR_L1C_SACCH_INFO *)(ptr))->input_level = l1a_l1s_com.Scell_info.traffic_meas.input_level;
1922 ((T_TR_L1C_SACCH_INFO *)(ptr))->tpu_offset = l1s.tpu_offset;
1923 ((T_TR_L1C_SACCH_INFO *)(ptr))->afc = l1s.afc;
1924
1925 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1C_SACCH_INFO));
1926 }
1927 }
1928 break;
1929
1930 // Channel modification
1931
1932 case MPHC_CHANGE_FREQUENCY:
1933 {
1934 char *ptr;
1935
1936 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_CHANGE_FREQUENCY), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1937 {
1938
1939 ((T_TR_MPHC_CHANGE_FREQUENCY *)(ptr))->header = TRL1_MPHC_CHANGE_FREQUENCY | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1940 ((T_TR_MPHC_CHANGE_FREQUENCY *)(ptr))->h = ((T_MPHC_CHANGE_FREQUENCY *)(msg->SigP))->channel_desc.chan_sel.h;
1941 ((T_TR_MPHC_CHANGE_FREQUENCY *)(ptr))->radio_freq = ((T_MPHC_CHANGE_FREQUENCY *)(msg->SigP))->channel_desc.chan_sel.rf_channel.single_rf.radio_freq;
1942 ((T_TR_MPHC_CHANGE_FREQUENCY *)(ptr))->channel_type = ((T_MPHC_CHANGE_FREQUENCY *)(msg->SigP))->channel_desc.channel_type;
1943 ((T_TR_MPHC_CHANGE_FREQUENCY *)(ptr))->subchannel = ((T_MPHC_CHANGE_FREQUENCY *)(msg->SigP))->channel_desc.subchannel;
1944 ((T_TR_MPHC_CHANGE_FREQUENCY *)(ptr))->timeslot_no = ((T_MPHC_CHANGE_FREQUENCY *)(msg->SigP))->channel_desc.timeslot_no;
1945 ((T_TR_MPHC_CHANGE_FREQUENCY *)(ptr))->tsc = ((T_MPHC_CHANGE_FREQUENCY *)(msg->SigP))->channel_desc.tsc;
1946 ((T_TR_MPHC_CHANGE_FREQUENCY *)(ptr))->rf_chan_cnt = ((T_MPHC_CHANGE_FREQUENCY *)(msg->SigP))->frequency_list.rf_chan_cnt;
1947 ((T_TR_MPHC_CHANGE_FREQUENCY *)(ptr))->start_time_present = ((T_MPHC_CHANGE_FREQUENCY *)(msg->SigP))->starting_time.start_time_present;
1948 ((T_TR_MPHC_CHANGE_FREQUENCY *)(ptr))->n32 = ((T_MPHC_CHANGE_FREQUENCY *)(msg->SigP))->starting_time.start_time.n32;
1949 ((T_TR_MPHC_CHANGE_FREQUENCY *)(ptr))->n51 = ((T_MPHC_CHANGE_FREQUENCY *)(msg->SigP))->starting_time.start_time.n51;
1950 ((T_TR_MPHC_CHANGE_FREQUENCY *)(ptr))->n26 = ((T_MPHC_CHANGE_FREQUENCY *)(msg->SigP))->starting_time.start_time.n26;
1951
1952 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_CHANGE_FREQUENCY));
1953 }
1954 }
1955 break;
1956
1957 case L1C_REDEF_DONE:
1958 {
1959 char *ptr;
1960
1961 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1C_REDEF_DONE), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1962 {
1963
1964 ((T_TR_L1C_REDEF_DONE *)(ptr))->header = TRL1_L1C_REDEF_DONE | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1965
1966 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1C_REDEF_DONE));
1967 }
1968 }
1969 break;
1970
1971 case MPHC_CHANNEL_MODE_MODIFY_REQ:
1972 {
1973 char *ptr;
1974
1975 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_CHANNEL_MODE_MODIFY_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
1976 {
1977 ((T_TR_MPHC_CHANNEL_MODE_MODIFY_REQ *)(ptr))->header = TRL1_MPHC_CHANNEL_MODE_MODIFY_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
1978 ((T_TR_MPHC_CHANNEL_MODE_MODIFY_REQ *)(ptr))->subchannel = ((T_MPHC_CHANNEL_MODE_MODIFY_REQ *)(msg->SigP))->subchannel;
1979 ((T_TR_MPHC_CHANNEL_MODE_MODIFY_REQ *)(ptr))->channel_mode = ((T_MPHC_CHANNEL_MODE_MODIFY_REQ *)(msg->SigP))->channel_mode;
1980
1981 #if (AMR == 1)
1982 ((T_TR_MPHC_CHANNEL_MODE_MODIFY_REQ *)(ptr))->noise_suppression_bit = ((T_MPHC_CHANNEL_MODE_MODIFY_REQ *)(msg->SigP))->amr_configuration.noise_suppression_bit;
1983 ((T_TR_MPHC_CHANNEL_MODE_MODIFY_REQ *)(ptr))->initial_codec_mode_indicator = ((T_MPHC_CHANNEL_MODE_MODIFY_REQ *)(msg->SigP))->amr_configuration.initial_codec_mode_indicator;
1984 ((T_TR_MPHC_CHANNEL_MODE_MODIFY_REQ *)(ptr))->initial_codec_mode = ((T_MPHC_CHANNEL_MODE_MODIFY_REQ *)(msg->SigP))->amr_configuration.initial_codec_mode;
1985 ((T_TR_MPHC_CHANNEL_MODE_MODIFY_REQ *)(ptr))->active_codec_set = ((T_MPHC_CHANNEL_MODE_MODIFY_REQ *)(msg->SigP))->amr_configuration.active_codec_set;
1986 ((T_TR_MPHC_CHANNEL_MODE_MODIFY_REQ *)(ptr))->threshold[0] = ((T_MPHC_CHANNEL_MODE_MODIFY_REQ *)(msg->SigP))->amr_configuration.threshold[0];
1987 ((T_TR_MPHC_CHANNEL_MODE_MODIFY_REQ *)(ptr))->threshold[1] = ((T_MPHC_CHANNEL_MODE_MODIFY_REQ *)(msg->SigP))->amr_configuration.threshold[1];
1988 ((T_TR_MPHC_CHANNEL_MODE_MODIFY_REQ *)(ptr))->threshold[2] = ((T_MPHC_CHANNEL_MODE_MODIFY_REQ *)(msg->SigP))->amr_configuration.threshold[2];
1989 ((T_TR_MPHC_CHANNEL_MODE_MODIFY_REQ *)(ptr))->hysteresis[0] = ((T_MPHC_CHANNEL_MODE_MODIFY_REQ *)(msg->SigP))->amr_configuration.hysteresis[0];
1990 ((T_TR_MPHC_CHANNEL_MODE_MODIFY_REQ *)(ptr))->hysteresis[1] = ((T_MPHC_CHANNEL_MODE_MODIFY_REQ *)(msg->SigP))->amr_configuration.hysteresis[1];
1991 ((T_TR_MPHC_CHANNEL_MODE_MODIFY_REQ *)(ptr))->hysteresis[2] = ((T_MPHC_CHANNEL_MODE_MODIFY_REQ *)(msg->SigP))->amr_configuration.hysteresis[2];
1992 #endif
1993
1994 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_CHANNEL_MODE_MODIFY_REQ));
1995 }
1996 }
1997 break;
1998
1999 // Ciphering
2000
2001 case MPHC_SET_CIPHERING_REQ:
2002 {
2003 char *ptr;
2004
2005 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_SET_CIPHERING_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2006 {
2007
2008 ((T_TR_MPHC_SET_CIPHERING_REQ *)(ptr))->header = TRL1_MPHC_SET_CIPHERING_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2009 ((T_TR_MPHC_SET_CIPHERING_REQ *)(ptr))->cipher_mode = ((T_MPHC_SET_CIPHERING_REQ *)(msg->SigP))->cipher_mode;
2010 ((T_TR_MPHC_SET_CIPHERING_REQ *)(ptr))->a5_algorithm = ((T_MPHC_SET_CIPHERING_REQ *)(msg->SigP))->a5_algorithm;
2011 ((T_TR_MPHC_SET_CIPHERING_REQ *)(ptr))->A[0] = ((T_MPHC_SET_CIPHERING_REQ *)(msg->SigP))->new_ciph_param.A[0];
2012 ((T_TR_MPHC_SET_CIPHERING_REQ *)(ptr))->A[1] = ((T_MPHC_SET_CIPHERING_REQ *)(msg->SigP))->new_ciph_param.A[1];
2013 ((T_TR_MPHC_SET_CIPHERING_REQ *)(ptr))->A[2] = ((T_MPHC_SET_CIPHERING_REQ *)(msg->SigP))->new_ciph_param.A[2];
2014 ((T_TR_MPHC_SET_CIPHERING_REQ *)(ptr))->A[3] = ((T_MPHC_SET_CIPHERING_REQ *)(msg->SigP))->new_ciph_param.A[3];
2015 ((T_TR_MPHC_SET_CIPHERING_REQ *)(ptr))->A[4] = ((T_MPHC_SET_CIPHERING_REQ *)(msg->SigP))->new_ciph_param.A[4];
2016 ((T_TR_MPHC_SET_CIPHERING_REQ *)(ptr))->A[5] = ((T_MPHC_SET_CIPHERING_REQ *)(msg->SigP))->new_ciph_param.A[5];
2017 ((T_TR_MPHC_SET_CIPHERING_REQ *)(ptr))->A[6] = ((T_MPHC_SET_CIPHERING_REQ *)(msg->SigP))->new_ciph_param.A[6];
2018 ((T_TR_MPHC_SET_CIPHERING_REQ *)(ptr))->A[7] = ((T_MPHC_SET_CIPHERING_REQ *)(msg->SigP))->new_ciph_param.A[7];
2019
2020 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_SET_CIPHERING_REQ));
2021 }
2022 }
2023 break;
2024
2025 // Generic stop
2026
2027 case MPHC_STOP_DEDICATED_REQ:
2028 {
2029 char *ptr;
2030
2031 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_STOP_DEDICATED_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2032 {
2033
2034 ((T_TR_MPHC_STOP_DEDICATED_REQ *)(ptr))->header = TRL1_MPHC_STOP_DEDICATED_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2035
2036 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_STOP_DEDICATED_REQ));
2037 }
2038 }
2039 break;
2040
2041 case MPHC_STOP_DEDICATED_CON:
2042 {
2043 char *ptr;
2044
2045 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_STOP_DEDICATED_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2046 {
2047
2048 ((T_TR_MPHC_STOP_DEDICATED_CON *)(ptr))->header = TRL1_MPHC_STOP_DEDICATED_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2049
2050 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_STOP_DEDICATED_CON));
2051 }
2052 }
2053 break;
2054
2055 case L1C_STOP_DEDICATED_DONE:
2056 {
2057 char *ptr;
2058
2059 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1C_STOP_DEDICATED_DONE), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2060 {
2061
2062 ((T_TR_L1C_STOP_DEDICATED_DONE *)(ptr))->header = TRL1_L1C_STOP_DEDICATED_DONE | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2063
2064 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1C_STOP_DEDICATED_DONE));
2065 }
2066 }
2067 break;
2068
2069 //////////////
2070 // HANDOVER //
2071 //////////////
2072
2073 // Asynchronous handover request
2074
2075 case MPHC_ASYNC_HO_REQ:
2076 {
2077 #define msg_aho ((T_MPHC_ASYNC_HO_REQ *)(msg->SigP))
2078
2079 char *ptr;
2080
2081 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_ASYNC_HO_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2082 {
2083 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->header = TRL1_MPHC_ASYNC_HO_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2084 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->ncc = msg_aho->handover_command.cell_description.ncc;
2085 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->bcc = msg_aho->handover_command.cell_description.bcc;
2086 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->bcch_carrier = msg_aho->handover_command.cell_description.bcch_carrier;
2087 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->h = msg_aho->handover_command.channel_desc_1.chan_sel.h;
2088 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->radio_freq = msg_aho->handover_command.channel_desc_1.chan_sel.rf_channel.single_rf.radio_freq;
2089 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->channel_type = msg_aho->handover_command.channel_desc_1.channel_type;
2090 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->subchannel = msg_aho->handover_command.channel_desc_1.subchannel;
2091 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->timeslot_no = msg_aho->handover_command.channel_desc_1.timeslot_no;
2092 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->tsc = msg_aho->handover_command.channel_desc_1.tsc;
2093 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->channel_mode_1 = msg_aho->handover_command.channel_mode_1;
2094 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->txpwr = msg_aho->handover_command.txpwr;
2095 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->rf_chan_cnt = msg_aho->handover_command.frequency_list.rf_chan_cnt;
2096 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->starting_time_present = msg_aho->handover_command.starting_time.start_time_present;
2097 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->n32 = msg_aho->handover_command.starting_time.start_time.n32;
2098 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->n51 = msg_aho->handover_command.starting_time.start_time.n51;
2099 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->n26 = msg_aho->handover_command.starting_time.start_time.n26;
2100 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->ho_acc = msg_aho->handover_command.ho_acc;
2101 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->report_time_diff = msg_aho->handover_command.report_time_diff;
2102 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->bef_sti_rf_chan_cnt = msg_aho->handover_command.frequency_list_bef_sti.rf_chan_cnt;
2103 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->cipher_mode = msg_aho->handover_command.cipher_mode;
2104 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->a5_algorithm = msg_aho->handover_command.a5_algorithm;
2105 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->fn_offset = msg_aho->fn_offset;
2106 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->time_alignmt = msg_aho->time_alignmt;
2107
2108 #if (AMR == 1)
2109 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->noise_suppression_bit = msg_aho->amr_configuration.noise_suppression_bit;
2110 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->initial_codec_mode_indicator = msg_aho->amr_configuration.initial_codec_mode_indicator;
2111 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->initial_codec_mode = msg_aho->amr_configuration.initial_codec_mode;
2112 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->active_codec_set = msg_aho->amr_configuration.active_codec_set;
2113 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->threshold[0] = msg_aho->amr_configuration.threshold[0];
2114 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->threshold[1] = msg_aho->amr_configuration.threshold[1];
2115 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->threshold[2] = msg_aho->amr_configuration.threshold[2];
2116 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->hysteresis[0] = msg_aho->amr_configuration.hysteresis[0];
2117 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->hysteresis[1] = msg_aho->amr_configuration.hysteresis[1];
2118 ((T_TR_MPHC_ASYNC_HO_REQ *)(ptr))->hysteresis[2] = msg_aho->amr_configuration.hysteresis[2];
2119 #endif
2120
2121 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_ASYNC_HO_REQ));
2122 }
2123 }
2124 break;
2125
2126 case MPHC_ASYNC_HO_CON:
2127 {
2128 char *ptr;
2129
2130 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_ASYNC_HO_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2131 {
2132
2133 ((T_TR_MPHC_ASYNC_HO_CON *)(ptr))->header = TRL1_MPHC_ASYNC_HO_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2134
2135 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_ASYNC_HO_CON));
2136 }
2137 }
2138 break;
2139
2140 // Synchronous handover request
2141
2142 case MPHC_SYNC_HO_REQ:
2143 case MPHC_PRE_SYNC_HO_REQ:
2144 case MPHC_PSEUDO_SYNC_HO_REQ:
2145 {
2146 #define msg_sho ((T_MPHC_SYNC_HO_REQ *)(msg->SigP))
2147
2148 char *ptr;
2149
2150 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_SYNC_HO_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2151 {
2152 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->header = TRL1_MPHC_SYNC_HO_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2153 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->ncc = msg_sho->handover_command.cell_description.ncc;
2154 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->bcc = msg_sho->handover_command.cell_description.bcc;
2155 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->bcch_carrier = msg_sho->handover_command.cell_description.bcch_carrier;
2156 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->h = msg_sho->handover_command.channel_desc_1.chan_sel.h;
2157 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->radio_freq = msg_sho->handover_command.channel_desc_1.chan_sel.rf_channel.single_rf.radio_freq;
2158 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->channel_type = msg_sho->handover_command.channel_desc_1.channel_type;
2159 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->subchannel = msg_sho->handover_command.channel_desc_1.subchannel;
2160 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->timeslot_no = msg_sho->handover_command.channel_desc_1.timeslot_no;
2161 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->tsc = msg_sho->handover_command.channel_desc_1.tsc;
2162 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->channel_mode_1 = msg_sho->handover_command.channel_mode_1;
2163 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->txpwr = msg_sho->handover_command.txpwr;
2164 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->rf_chan_cnt = msg_sho->handover_command.frequency_list.rf_chan_cnt;
2165 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->starting_time_present = msg_sho->handover_command.starting_time.start_time_present;
2166 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->n32 = msg_sho->handover_command.starting_time.start_time.n32;
2167 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->n51 = msg_sho->handover_command.starting_time.start_time.n51;
2168 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->n26 = msg_sho->handover_command.starting_time.start_time.n26;
2169 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->ho_acc = msg_sho->handover_command.ho_acc;
2170 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->report_time_diff = msg_sho->handover_command.report_time_diff;
2171 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->bef_sti_rf_chan_cnt = msg_sho->handover_command.frequency_list_bef_sti.rf_chan_cnt;
2172 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->cipher_mode = msg_sho->handover_command.cipher_mode;
2173 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->a5_algorithm = msg_sho->handover_command.a5_algorithm;
2174 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->fn_offset = msg_sho->fn_offset;
2175 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->time_alignmt = msg_sho->time_alignmt;
2176
2177 #if (AMR == 1)
2178 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->noise_suppression_bit = msg_sho->amr_configuration.noise_suppression_bit;
2179 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->initial_codec_mode_indicator = msg_sho->amr_configuration.initial_codec_mode_indicator;
2180 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->initial_codec_mode = msg_sho->amr_configuration.initial_codec_mode;
2181 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->active_codec_set = msg_sho->amr_configuration.active_codec_set;
2182 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->threshold[0] = msg_sho->amr_configuration.threshold[0];
2183 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->threshold[1] = msg_sho->amr_configuration.threshold[1];
2184 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->threshold[2] = msg_sho->amr_configuration.threshold[2];
2185 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->hysteresis[0] = msg_sho->amr_configuration.hysteresis[0];
2186 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->hysteresis[1] = msg_sho->amr_configuration.hysteresis[1];
2187 ((T_TR_MPHC_SYNC_HO_REQ *)(ptr))->hysteresis[2] = msg_sho->amr_configuration.hysteresis[2];
2188 #endif
2189
2190 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_SYNC_HO_REQ));
2191 }
2192 }
2193 break;
2194
2195 case MPHC_SYNC_HO_CON:
2196 case MPHC_PRE_SYNC_HO_CON:
2197 {
2198 char *ptr;
2199
2200 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_SYNC_HO_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2201 {
2202
2203 ((T_TR_MPHC_SYNC_HO_CON *)(ptr))->header = TRL1_MPHC_SYNC_HO_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2204
2205 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_SYNC_HO_CON));
2206 }
2207 }
2208 break;
2209
2210 case L1C_HANDOVER_FINISHED:
2211 {
2212 char *ptr;
2213
2214 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1C_HANDOVER_FINISHED), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2215 {
2216
2217 ((T_TR_L1C_HANDOVER_FINISHED *)(ptr))->header = TRL1_L1C_HANDOVER_FINISHED | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2218 ((T_TR_L1C_HANDOVER_FINISHED *)(ptr))->cause = ((T_MPHC_HANDOVER_FINISHED *)(msg->SigP))->cause;
2219 #if ((REL99 == 1) && (FF_BHO == 1))
2220 ((T_TR_L1C_HANDOVER_FINISHED *)(ptr))->fn_offset = ((T_MPHC_HANDOVER_FINISHED *)(msg->SigP))->fn_offset;
2221 ((T_TR_L1C_HANDOVER_FINISHED *)(ptr))->time_alignment = ((T_MPHC_HANDOVER_FINISHED *)(msg->SigP))->time_alignment;
2222 #endif
2223 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1C_HANDOVER_FINISHED));
2224 }
2225 }
2226 break;
2227
2228 case MPHC_TA_FAIL_IND:
2229 {
2230 char *ptr;
2231
2232 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_TA_FAIL_IND), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2233 {
2234
2235 ((T_TR_MPHC_TA_FAIL_IND *)(ptr))->header = TRL1_MPHC_TA_FAIL_IND | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2236
2237 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_TA_FAIL_IND));
2238 }
2239 }
2240 break;
2241
2242 // Handover failure
2243
2244 case MPHC_HANDOVER_FAIL_REQ:
2245 {
2246 char *ptr;
2247
2248 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_HANDOVER_FAIL_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2249 {
2250
2251 ((T_TR_MPHC_HANDOVER_FAIL_REQ *)(ptr))->header = TRL1_MPHC_HANDOVER_FAIL_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2252
2253 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_HANDOVER_FAIL_REQ));
2254 }
2255 }
2256 break;
2257
2258 case MPHC_HANDOVER_FAIL_CON:
2259 {
2260 char *ptr;
2261
2262 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_HANDOVER_FAIL_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2263 {
2264
2265 ((T_TR_MPHC_HANDOVER_FAIL_CON *)(ptr))->header = TRL1_MPHC_HANDOVER_FAIL_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2266
2267 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_HANDOVER_FAIL_CON));
2268 }
2269 }
2270 break;
2271
2272 //////////////////
2273 // Measurements //
2274 //////////////////
2275
2276 // Cell selection / PLMN selection / Extended measurements
2277
2278 case MPHC_RXLEV_REQ:
2279 {
2280 char *ptr;
2281
2282 trace_info.rxlev_req_count ++;
2283
2284 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_RXLEV_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2285 {
2286
2287 ((T_TR_MPHC_RXLEV_REQ *)(ptr))->header = TRL1_MPHC_RXLEV_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2288 ((T_TR_MPHC_RXLEV_REQ *)(ptr))->power_array_size = ((T_MPHC_RXLEV_REQ *)(msg->SigP))->power_array_size;
2289
2290 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_RXLEV_REQ));
2291 }
2292 }
2293 break;
2294
2295 case MPHC_STOP_RXLEV_REQ:
2296 {
2297 char *ptr;
2298
2299 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_STOP_RXLEV_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2300 {
2301
2302 ((T_TR_MPHC_STOP_RXLEV_REQ *)(ptr))->header = TRL1_MPHC_STOP_RXLEV_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2303
2304 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_STOP_RXLEV_REQ));
2305 }
2306 }
2307 break;
2308
2309 case L1C_VALID_MEAS_INFO:
2310 {
2311 char *ptr;
2312
2313 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1C_VALID_MEAS_INFO), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2314 {
2315 ((T_TR_L1C_VALID_MEAS_INFO *)(ptr))->header = TRL1_L1C_VALID_MEAS_INFO | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2316 ((T_TR_L1C_VALID_MEAS_INFO *)(ptr))->power_array_size = l1a_l1s_com.full_list_ptr->power_array_size;
2317 ((T_TR_L1C_VALID_MEAS_INFO *)(ptr))->rxlev_req_count = trace_info.rxlev_req_count;
2318
2319 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1C_VALID_MEAS_INFO));
2320 }
2321
2322 if (trace_info.rxlev_req_count == 5)
2323 {
2324 trace_info.rxlev_req_count = 0;
2325
2326 if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_FULL_LIST_REPORT)
2327 {
2328 UWORD16 index = 0;
2329 UWORD16 size = l1a_l1s_com.full_list_ptr->power_array_size * 4;
2330 UWORD8 i;
2331
2332 while (size > 0)
2333 {
2334 UWORD16 item_size = size;
2335
2336 // Split buffer in several buffers with size inferior to 240 (RVT limitation to 255)
2337 // Header not inluded (+8b)
2338 if (item_size > 240) item_size = 240;
2339
2340 if (rvt_mem_alloc(trace_info.l1_trace_user_id, item_size + sizeof(T_TR_FULL_LIST_REPORT) - sizeof(UWORD32), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2341 {
2342 ((T_TR_FULL_LIST_REPORT *)(ptr))->header = TRL1_FULL_LIST_REPORT | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2343 ((T_TR_FULL_LIST_REPORT *)(ptr))->size = (item_size >> 2);
2344
2345 for (i=0; i<(item_size >> 2); i++)
2346 {
2347 ((T_TR_FULL_LIST_REPORT *)(ptr))->content[i] = l1a_l1s_com.full_list_ptr->power_array[index].radio_freq;
2348 ((T_TR_FULL_LIST_REPORT *)(ptr))->content[i] |= l1a_l1s_com.full_list_ptr->power_array[index].accum_power_result << 16;
2349 index++;
2350 }
2351
2352 size -= item_size;
2353
2354 L1_send_trace_no_cpy(ptr,item_size + sizeof(T_TR_FULL_LIST_REPORT) - sizeof(UWORD32));
2355 }
2356 else
2357 break;
2358 }
2359 }
2360 } // 5th attempt
2361 }
2362 break;
2363
2364 // Idle mode BA list
2365
2366 case MPHC_RXLEV_PERIODIC_REQ:
2367 {
2368 char *ptr;
2369
2370 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_RXLEV_PERIODIC_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2371 {
2372
2373 ((T_TR_MPHC_RXLEV_PERIODIC_REQ *)(ptr))->header = TRL1_MPHC_RXLEV_PERIODIC_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2374 ((T_TR_MPHC_RXLEV_PERIODIC_REQ *)(ptr))->num_of_chans = ((T_MPHC_RXLEV_PERIODIC_REQ *)(msg->SigP))->num_of_chans;
2375 ((T_TR_MPHC_RXLEV_PERIODIC_REQ *)(ptr))->ba_id = ((T_MPHC_RXLEV_PERIODIC_REQ *)(msg->SigP))->ba_id;
2376 ((T_TR_MPHC_RXLEV_PERIODIC_REQ *)(ptr))->next_radio_freq_measured = ((T_MPHC_RXLEV_PERIODIC_REQ *)(msg->SigP))->next_radio_freq_measured;
2377
2378 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_RXLEV_PERIODIC_REQ));
2379 }
2380 }
2381 break;
2382
2383 case MPHC_STOP_RXLEV_PERIODIC_REQ:
2384 {
2385 char *ptr;
2386
2387 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_STOP_RXLEV_PERIODIC_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2388 {
2389
2390 ((T_TR_MPHC_STOP_RXLEV_PERIODIC_REQ *)(ptr))->header = TRL1_MPHC_STOP_RXLEV_PERIODIC_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2391
2392 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_STOP_RXLEV_PERIODIC_REQ));
2393 }
2394 }
2395 break;
2396
2397 case L1C_RXLEV_PERIODIC_DONE:
2398 {
2399 char *ptr;
2400
2401 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1C_RXLEV_PERIODIC_DONE), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2402 {
2403
2404 ((T_TR_L1C_RXLEV_PERIODIC_DONE *)(ptr))->header = TRL1_L1C_RXLEV_PERIODIC_DONE | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2405 ((T_TR_L1C_RXLEV_PERIODIC_DONE *)(ptr))->ba_id = ((T_MPHC_RXLEV_PERIODIC_IND *)(msg->SigP))->ba_id;
2406 ((T_TR_L1C_RXLEV_PERIODIC_DONE *)(ptr))->s_rxlev = ((T_MPHC_RXLEV_PERIODIC_IND *)(msg->SigP))->s_rxlev;
2407 ((T_TR_L1C_RXLEV_PERIODIC_DONE *)(ptr))->radio_freq_no[0] = ((T_MPHC_RXLEV_PERIODIC_IND *)(msg->SigP))->A[0].radio_freq_no;
2408 ((T_TR_L1C_RXLEV_PERIODIC_DONE *)(ptr))->radio_freq_no[1] = ((T_MPHC_RXLEV_PERIODIC_IND *)(msg->SigP))->A[1].radio_freq_no;
2409 ((T_TR_L1C_RXLEV_PERIODIC_DONE *)(ptr))->radio_freq_no[2] = ((T_MPHC_RXLEV_PERIODIC_IND *)(msg->SigP))->A[2].radio_freq_no;
2410 ((T_TR_L1C_RXLEV_PERIODIC_DONE *)(ptr))->radio_freq_no[3] = ((T_MPHC_RXLEV_PERIODIC_IND *)(msg->SigP))->A[3].radio_freq_no;
2411 ((T_TR_L1C_RXLEV_PERIODIC_DONE *)(ptr))->radio_freq_no[4] = ((T_MPHC_RXLEV_PERIODIC_IND *)(msg->SigP))->A[4].radio_freq_no;
2412 ((T_TR_L1C_RXLEV_PERIODIC_DONE *)(ptr))->radio_freq_no[5] = ((T_MPHC_RXLEV_PERIODIC_IND *)(msg->SigP))->A[5].radio_freq_no;
2413 ((T_TR_L1C_RXLEV_PERIODIC_DONE *)(ptr))->radio_freq_no[6] = ((T_MPHC_RXLEV_PERIODIC_IND *)(msg->SigP))->A[6].radio_freq_no;
2414 ((T_TR_L1C_RXLEV_PERIODIC_DONE *)(ptr))->radio_freq_no[7] = ((T_MPHC_RXLEV_PERIODIC_IND *)(msg->SigP))->A[7].radio_freq_no;
2415 ((T_TR_L1C_RXLEV_PERIODIC_DONE *)(ptr))->rxlev[0] = ((T_MPHC_RXLEV_PERIODIC_IND *)(msg->SigP))->A[0].rxlev;
2416 ((T_TR_L1C_RXLEV_PERIODIC_DONE *)(ptr))->rxlev[1] = ((T_MPHC_RXLEV_PERIODIC_IND *)(msg->SigP))->A[1].rxlev;
2417 ((T_TR_L1C_RXLEV_PERIODIC_DONE *)(ptr))->rxlev[2] = ((T_MPHC_RXLEV_PERIODIC_IND *)(msg->SigP))->A[2].rxlev;
2418 ((T_TR_L1C_RXLEV_PERIODIC_DONE *)(ptr))->rxlev[3] = ((T_MPHC_RXLEV_PERIODIC_IND *)(msg->SigP))->A[3].rxlev;
2419 ((T_TR_L1C_RXLEV_PERIODIC_DONE *)(ptr))->rxlev[4] = ((T_MPHC_RXLEV_PERIODIC_IND *)(msg->SigP))->A[4].rxlev;
2420 ((T_TR_L1C_RXLEV_PERIODIC_DONE *)(ptr))->rxlev[5] = ((T_MPHC_RXLEV_PERIODIC_IND *)(msg->SigP))->A[5].rxlev;
2421 ((T_TR_L1C_RXLEV_PERIODIC_DONE *)(ptr))->rxlev[6] = ((T_MPHC_RXLEV_PERIODIC_IND *)(msg->SigP))->A[6].rxlev;
2422 ((T_TR_L1C_RXLEV_PERIODIC_DONE *)(ptr))->rxlev[7] = ((T_MPHC_RXLEV_PERIODIC_IND *)(msg->SigP))->A[7].rxlev;
2423 ((T_TR_L1C_RXLEV_PERIODIC_DONE *)(ptr))->qual_acc_idle = ((T_MPHC_RXLEV_PERIODIC_IND *)(msg->SigP))->qual_acc_idle;
2424 ((T_TR_L1C_RXLEV_PERIODIC_DONE *)(ptr))->qual_nbr_meas_idle = ((T_MPHC_RXLEV_PERIODIC_IND *)(msg->SigP))->qual_nbr_meas_idle;
2425
2426
2427 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1C_RXLEV_PERIODIC_DONE));
2428 }
2429 }
2430 break;
2431
2432
2433 // Dedicated mode BA list
2434
2435 case MPHC_MEAS_REPORT:
2436 {
2437 char *ptr;
2438
2439 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1C_MEAS_DONE), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2440 {
2441
2442 ((T_TR_L1C_MEAS_DONE *)(ptr))->header = TRL1_L1C_MEAS_DONE | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2443 ((T_TR_L1C_MEAS_DONE *)(ptr))->meas_valid = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->meas_valid;
2444 ((T_TR_L1C_MEAS_DONE *)(ptr))->txpwr_used = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->txpwr_used;
2445 ((T_TR_L1C_MEAS_DONE *)(ptr))->timing_advance = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->timing_advance;
2446 ((T_TR_L1C_MEAS_DONE *)(ptr))->rxlev_full_acc = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->rxlev_full_acc;
2447 ((T_TR_L1C_MEAS_DONE *)(ptr))->rxlev_full_nbr_meas = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->rxlev_full_nbr_meas;
2448 ((T_TR_L1C_MEAS_DONE *)(ptr))->rxlev_sub_acc = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->rxlev_sub_acc;
2449 ((T_TR_L1C_MEAS_DONE *)(ptr))->rxlev_sub_nbr_meas = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->rxlev_sub_nbr_meas;
2450 ((T_TR_L1C_MEAS_DONE *)(ptr))->rxqual_full_acc_errors = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->rxqual_full_acc_errors;
2451 ((T_TR_L1C_MEAS_DONE *)(ptr))->rxqual_full_nbr_bits = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->rxqual_full_nbr_bits;
2452 ((T_TR_L1C_MEAS_DONE *)(ptr))->rxqual_sub_acc_errors = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->rxqual_sub_acc_errors;
2453 ((T_TR_L1C_MEAS_DONE *)(ptr))->rxqual_sub_nbr_bits = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->rxqual_sub_nbr_bits;
2454 #if(REL99)
2455 #if(FF_EMR)
2456 ((T_TR_L1C_MEAS_DONE *)(ptr))->rxlev_val_acc; = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->rxlev_val_acc;
2457 ((T_TR_L1C_MEAS_DONE *)(ptr))->rxlev_val_nbr_meas; = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->rxlev_val_nbr_meas;
2458 ((T_TR_L1C_MEAS_DONE *)(ptr))->mean_bep_block_acc; = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->mean_bep_block_acc;
2459 ((T_TR_L1C_MEAS_DONE *)(ptr))->cv_bep_block_acc; = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->cv_bep_block_acc;
2460 ((T_TR_L1C_MEAS_DONE *)(ptr))->mean_bep_block_num; = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->mean_bep_block_num;
2461 ((T_TR_L1C_MEAS_DONE *)(ptr))->cv_bep_block_num; = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->cv_bep_block_num;
2462 ((T_TR_L1C_MEAS_DONE *)(ptr))->nbr_rcvd_blocks; = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->nbr_rcvd_blocks;
2463 #endif
2464 #endif
2465 ((T_TR_L1C_MEAS_DONE *)(ptr))->facch_ul_count = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->facch_ul_count;
2466 ((T_TR_L1C_MEAS_DONE *)(ptr))->facch_dl_count = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->facch_dl_count;
2467 ((T_TR_L1C_MEAS_DONE *)(ptr))->bcch_freq[0] = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->ncell_meas.A[0].bcch_freq;
2468 ((T_TR_L1C_MEAS_DONE *)(ptr))->bcch_freq[1] = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->ncell_meas.A[1].bcch_freq;
2469 ((T_TR_L1C_MEAS_DONE *)(ptr))->bcch_freq[2] = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->ncell_meas.A[2].bcch_freq;
2470 ((T_TR_L1C_MEAS_DONE *)(ptr))->bcch_freq[3] = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->ncell_meas.A[3].bcch_freq;
2471 ((T_TR_L1C_MEAS_DONE *)(ptr))->bcch_freq[4] = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->ncell_meas.A[4].bcch_freq;
2472 ((T_TR_L1C_MEAS_DONE *)(ptr))->bcch_freq[5] = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->ncell_meas.A[5].bcch_freq;
2473 ((T_TR_L1C_MEAS_DONE *)(ptr))->rxlev_acc[0] = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->ncell_meas.A[0].rxlev_acc;
2474 ((T_TR_L1C_MEAS_DONE *)(ptr))->rxlev_acc[1] = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->ncell_meas.A[1].rxlev_acc;
2475 ((T_TR_L1C_MEAS_DONE *)(ptr))->rxlev_acc[2] = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->ncell_meas.A[2].rxlev_acc;
2476 ((T_TR_L1C_MEAS_DONE *)(ptr))->rxlev_acc[3] = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->ncell_meas.A[3].rxlev_acc;
2477 ((T_TR_L1C_MEAS_DONE *)(ptr))->rxlev_acc[4] = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->ncell_meas.A[4].rxlev_acc;
2478 ((T_TR_L1C_MEAS_DONE *)(ptr))->rxlev_acc[5] = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->ncell_meas.A[5].rxlev_acc;
2479 ((T_TR_L1C_MEAS_DONE *)(ptr))->rxlev_nbr_meas[0] = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->ncell_meas.A[0].rxlev_nbr_meas;
2480 ((T_TR_L1C_MEAS_DONE *)(ptr))->rxlev_nbr_meas[1] = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->ncell_meas.A[1].rxlev_nbr_meas;
2481 ((T_TR_L1C_MEAS_DONE *)(ptr))->rxlev_nbr_meas[2] = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->ncell_meas.A[2].rxlev_nbr_meas;
2482 ((T_TR_L1C_MEAS_DONE *)(ptr))->rxlev_nbr_meas[3] = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->ncell_meas.A[3].rxlev_nbr_meas;
2483 ((T_TR_L1C_MEAS_DONE *)(ptr))->rxlev_nbr_meas[4] = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->ncell_meas.A[4].rxlev_nbr_meas;
2484 ((T_TR_L1C_MEAS_DONE *)(ptr))->rxlev_nbr_meas[5] = ((T_MPHC_MEAS_REPORT *)(msg->SigP))->ncell_meas.A[5].rxlev_nbr_meas;
2485
2486 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1C_MEAS_DONE));
2487 }
2488 }
2489 break;
2490
2491 // Update BA list
2492
2493 case MPHC_UPDATE_BA_LIST:
2494 {
2495 char *ptr;
2496
2497 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHC_UPDATE_BA_LIST), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2498 {
2499
2500 ((T_TR_MPHC_UPDATE_BA_LIST *)(ptr))->header = TRL1_MPHC_UPDATE_BA_LIST | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2501 ((T_TR_MPHC_UPDATE_BA_LIST *)(ptr))->num_of_chans = ((T_MPHC_UPDATE_BA_LIST *)(msg->SigP))->num_of_chans;
2502 ((T_TR_MPHC_UPDATE_BA_LIST *)(ptr))->pwrc = ((T_MPHC_UPDATE_BA_LIST *)(msg->SigP))->pwrc;
2503 ((T_TR_MPHC_UPDATE_BA_LIST *)(ptr))->dtx_allowed = ((T_MPHC_UPDATE_BA_LIST *)(msg->SigP))->dtx_allowed;
2504 ((T_TR_MPHC_UPDATE_BA_LIST *)(ptr))->ba_id = ((T_MPHC_UPDATE_BA_LIST *)(msg->SigP))->ba_id;
2505
2506 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHC_UPDATE_BA_LIST));
2507 }
2508 }
2509 break;
2510
2511 #if L1_GPRS
2512
2513 /********************************************************************************/
2514 /* PACKET SWITCHED */
2515 /********************************************************************************/
2516
2517 //////////////////////////////
2518 // Neighbor cell monitoring //
2519 //////////////////////////////
2520
2521 // Neighbor PBCCH reading
2522
2523 case MPHP_NCELL_PBCCH_REQ:
2524 {
2525 char *ptr;
2526
2527 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHP_NCELL_PBCCH_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2528 {
2529
2530 ((T_TR_MPHP_NCELL_PBCCH_REQ *)(ptr))->header = TRL1_MPHP_NCELL_PBCCH_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2531 ((T_TR_MPHP_NCELL_PBCCH_REQ *)(ptr))->bs_pbcch_blks = ((T_MPHP_NCELL_PBCCH_REQ *)(msg->SigP))->bs_pbcch_blks;
2532 ((T_TR_MPHP_NCELL_PBCCH_REQ *)(ptr))->pb = ((T_MPHP_NCELL_PBCCH_REQ *)(msg->SigP))->pb;
2533 ((T_TR_MPHP_NCELL_PBCCH_REQ *)(ptr))->psi1_repeat_period = ((T_MPHP_NCELL_PBCCH_REQ *)(msg->SigP))->psi1_repeat_period;
2534 ((T_TR_MPHP_NCELL_PBCCH_REQ *)(ptr))->relative_position = ((T_MPHP_NCELL_PBCCH_REQ *)(msg->SigP))->relative_position;
2535 ((T_TR_MPHP_NCELL_PBCCH_REQ *)(ptr))->h = ((T_MPHP_NCELL_PBCCH_REQ *)(msg->SigP))->packet_chn_desc.chan_sel.h;
2536 ((T_TR_MPHP_NCELL_PBCCH_REQ *)(ptr))->radio_freq = ((T_MPHP_NCELL_PBCCH_REQ *)(msg->SigP))->packet_chn_desc.chan_sel.rf_channel.single_rf.radio_freq;
2537 ((T_TR_MPHP_NCELL_PBCCH_REQ *)(ptr))->timeslot_no = ((T_MPHP_NCELL_PBCCH_REQ *)(msg->SigP))->packet_chn_desc.timeslot_no;
2538 ((T_TR_MPHP_NCELL_PBCCH_REQ *)(ptr))->tsc = ((T_MPHP_NCELL_PBCCH_REQ *)(msg->SigP))->packet_chn_desc.tsc;
2539 ((T_TR_MPHP_NCELL_PBCCH_REQ *)(ptr))->rf_chan_cnt = ((T_MPHP_NCELL_PBCCH_REQ *)(msg->SigP))->frequency_list.rf_chan_cnt;
2540 ((T_TR_MPHP_NCELL_PBCCH_REQ *)(ptr))->bcch_carrier = ((T_MPHP_NCELL_PBCCH_REQ *)(msg->SigP))->bcch_carrier;
2541 ((T_TR_MPHP_NCELL_PBCCH_REQ *)(ptr))->fn_offset = ((T_MPHP_NCELL_PBCCH_REQ *)(msg->SigP))->fn_offset;
2542 ((T_TR_MPHP_NCELL_PBCCH_REQ *)(ptr))->time_alignment = ((T_MPHP_NCELL_PBCCH_REQ *)(msg->SigP))->time_alignment;
2543
2544 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHP_NCELL_PBCCH_REQ));
2545 }
2546 }
2547 break;
2548
2549 case MPHP_NCELL_PBCCH_STOP_REQ:
2550 {
2551 char *ptr;
2552
2553 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHP_NCELL_PBCCH_STOP_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2554 {
2555
2556 ((T_TR_MPHP_NCELL_PBCCH_STOP_REQ *)(ptr))->header = TRL1_MPHP_NCELL_PBCCH_STOP_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2557
2558 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHP_NCELL_PBCCH_STOP_REQ));
2559 }
2560 }
2561 break;
2562
2563 case L1P_PBCCHN_INFO:
2564 {
2565 char *ptr;
2566
2567 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1P_PBCCHN_INFO), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2568 {
2569
2570 ((T_TR_L1P_PBCCHN_INFO *)(ptr))->header = TRL1_L1P_PBCCHN_INFO | (((T_MPHP_DATA_IND *)(msg->SigP))->fn << TR_HEADER_FN_DELAY);
2571 ((T_TR_L1P_PBCCHN_INFO *)(ptr))->error_flag = ((T_MPHP_DATA_IND *)(msg->SigP))->error_flag;
2572 ((T_TR_L1P_PBCCHN_INFO *)(ptr))->radio_freq = ((T_MPHP_DATA_IND *)(msg->SigP))->radio_freq;
2573 ((T_TR_L1P_PBCCHN_INFO *)(ptr))->relative_position = ((T_MPHP_DATA_IND *)(msg->SigP))->relative_position;
2574 ((T_TR_L1P_PBCCHN_INFO *)(ptr))->input_level = l1a_l1s_com.last_input_level[l1pa_l1ps_com.pbcchn.bcch_carrier -
2575 l1_config.std.radio_freq_index_offset].input_level;
2576 ((T_TR_L1P_PBCCHN_INFO *)(ptr))->tpu_offset = l1s.tpu_offset;
2577 ((T_TR_L1P_PBCCHN_INFO *)(ptr))->afc = l1s.afc;
2578
2579 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1P_PBCCHN_INFO));
2580 }
2581 }
2582 break;
2583
2584 //////////////////////////////////////////////////////
2585 // Serving cell normal burst reading in packet idle //
2586 //////////////////////////////////////////////////////
2587
2588 // PCCCH reading
2589
2590 case MPHP_START_PCCCH_REQ:
2591 {
2592 char *ptr;
2593
2594 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHP_START_PCCCH_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2595 {
2596
2597 ((T_TR_MPHP_START_PCCCH_REQ *)(ptr))->header = TRL1_MPHP_START_PCCCH_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2598 ((T_TR_MPHP_START_PCCCH_REQ *)(ptr))->imsimod = ((T_MPHP_START_PCCCH_REQ *)(msg->SigP))->imsimod;
2599 ((T_TR_MPHP_START_PCCCH_REQ *)(ptr))->kcn = ((T_MPHP_START_PCCCH_REQ *)(msg->SigP))->kcn;
2600 ((T_TR_MPHP_START_PCCCH_REQ *)(ptr))->split_pg_cycle = ((T_MPHP_START_PCCCH_REQ *)(msg->SigP))->split_pg_cycle;
2601 ((T_TR_MPHP_START_PCCCH_REQ *)(ptr))->bs_pag_blks_res = ((T_MPHP_START_PCCCH_REQ *)(msg->SigP))->bs_pag_blks_res;
2602 ((T_TR_MPHP_START_PCCCH_REQ *)(ptr))->bs_pbcch_blks = ((T_MPHP_START_PCCCH_REQ *)(msg->SigP))->bs_pbcch_blks;
2603 ((T_TR_MPHP_START_PCCCH_REQ *)(ptr))->pb = ((T_MPHP_START_PCCCH_REQ *)(msg->SigP))->pb;
2604 ((T_TR_MPHP_START_PCCCH_REQ *)(ptr))->page_mode = ((T_MPHP_START_PCCCH_REQ *)(msg->SigP))->page_mode;
2605 ((T_TR_MPHP_START_PCCCH_REQ *)(ptr))->h = ((T_MPHP_START_PCCCH_REQ *)(msg->SigP))->packet_chn_desc.chan_sel.h;
2606 ((T_TR_MPHP_START_PCCCH_REQ *)(ptr))->radio_freq = ((T_MPHP_START_PCCCH_REQ *)(msg->SigP))->packet_chn_desc.chan_sel.rf_channel.single_rf.radio_freq;
2607 ((T_TR_MPHP_START_PCCCH_REQ *)(ptr))->timeslot_no = ((T_MPHP_START_PCCCH_REQ *)(msg->SigP))->packet_chn_desc.timeslot_no;
2608 ((T_TR_MPHP_START_PCCCH_REQ *)(ptr))->tsc = ((T_MPHP_START_PCCCH_REQ *)(msg->SigP))->packet_chn_desc.tsc;
2609 ((T_TR_MPHP_START_PCCCH_REQ *)(ptr))->rf_chan_cnt = ((T_MPHP_START_PCCCH_REQ *)(msg->SigP))->frequency_list.rf_chan_cnt;
2610
2611 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHP_START_PCCCH_REQ));
2612 }
2613 }
2614 break;
2615
2616 case MPHP_STOP_PCCCH_REQ:
2617 {
2618 char *ptr;
2619
2620 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHP_STOP_PCCCH_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2621 {
2622
2623 ((T_TR_MPHP_STOP_PCCCH_REQ *)(ptr))->header = TRL1_MPHP_STOP_PCCCH_REQ;
2624
2625 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHP_STOP_PCCCH_REQ));
2626 }
2627 }
2628 break;
2629
2630 case L1P_PNP_INFO:
2631 {
2632 char *ptr;
2633
2634 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1P_PNP_INFO), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2635 {
2636
2637 ((T_TR_L1P_PNP_INFO *)(ptr))->header = TRL1_L1P_PNP_INFO | (((T_MPHP_DATA_IND *)(msg->SigP))->fn << TR_HEADER_FN_DELAY);
2638 ((T_TR_L1P_PNP_INFO *)(ptr))->error_flag = ((T_MPHP_DATA_IND *)(msg->SigP))->error_flag;
2639 ((T_TR_L1P_PNP_INFO *)(ptr))->radio_freq = ((T_MPHP_DATA_IND *)(msg->SigP))->radio_freq;
2640 ((T_TR_L1P_PNP_INFO *)(ptr))->relative_position = ((T_MPHP_DATA_IND *)(msg->SigP))->relative_position;
2641 ((T_TR_L1P_PNP_INFO *)(ptr))->input_level = l1a_l1s_com.Scell_IL_for_rxlev;
2642 ((T_TR_L1P_PNP_INFO *)(ptr))->tpu_offset = l1s.tpu_offset;
2643 ((T_TR_L1P_PNP_INFO *)(ptr))->afc = l1s.afc;
2644
2645 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1P_PNP_INFO));
2646 }
2647 }
2648 break;
2649
2650 case L1P_PEP_INFO:
2651 {
2652 char *ptr;
2653
2654 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1P_PEP_INFO), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2655 {
2656
2657 ((T_TR_L1P_PEP_INFO *)(ptr))->header = TRL1_L1P_PEP_INFO | (((T_MPHP_DATA_IND *)(msg->SigP))->fn << TR_HEADER_FN_DELAY);
2658 ((T_TR_L1P_PEP_INFO *)(ptr))->error_flag = ((T_MPHP_DATA_IND *)(msg->SigP))->error_flag;
2659 ((T_TR_L1P_PEP_INFO *)(ptr))->radio_freq = ((T_MPHP_DATA_IND *)(msg->SigP))->radio_freq;
2660 ((T_TR_L1P_PEP_INFO *)(ptr))->relative_position = ((T_MPHP_DATA_IND *)(msg->SigP))->relative_position;
2661 ((T_TR_L1P_PEP_INFO *)(ptr))->input_level = l1a_l1s_com.Scell_IL_for_rxlev;
2662 ((T_TR_L1P_PEP_INFO *)(ptr))->tpu_offset = l1s.tpu_offset;
2663 ((T_TR_L1P_PEP_INFO *)(ptr))->afc = l1s.afc;
2664
2665 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1P_PEP_INFO));
2666 }
2667 }
2668 break;
2669
2670 case L1P_PALLC_INFO:
2671 {
2672 char *ptr;
2673
2674 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1P_PALLC_INFO), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2675 {
2676
2677 ((T_TR_L1P_PALLC_INFO *)(ptr))->header = TRL1_L1P_PALLC_INFO | (((T_MPHP_DATA_IND *)(msg->SigP))->fn << TR_HEADER_FN_DELAY);
2678 ((T_TR_L1P_PALLC_INFO *)(ptr))->error_flag = ((T_MPHP_DATA_IND *)(msg->SigP))->error_flag;
2679 ((T_TR_L1P_PALLC_INFO *)(ptr))->radio_freq = ((T_MPHP_DATA_IND *)(msg->SigP))->radio_freq;
2680 ((T_TR_L1P_PALLC_INFO *)(ptr))->relative_position = ((T_MPHP_DATA_IND *)(msg->SigP))->relative_position;
2681 ((T_TR_L1P_PALLC_INFO *)(ptr))->input_level = l1a_l1s_com.Scell_IL_for_rxlev;
2682 ((T_TR_L1P_PALLC_INFO *)(ptr))->tpu_offset = l1s.tpu_offset;
2683 ((T_TR_L1P_PALLC_INFO *)(ptr))->afc = l1s.afc;
2684
2685 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1P_PALLC_INFO));
2686 }
2687 }
2688 break;
2689
2690 // PBCCH reading
2691
2692 case MPHP_SCELL_PBCCH_REQ:
2693 {
2694 char *ptr;
2695
2696 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHP_SCELL_PBCCH_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2697 {
2698
2699 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->header = TRL1_MPHP_SCELL_PBCCH_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2700 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->nbr_psi = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->nbr_psi;
2701 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->bs_pbcch_blks = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->bs_pbcch_blks;
2702 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->pb = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->pb;
2703 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->psi1_repeat_period = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->psi1_repeat_period;
2704 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->h = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->packet_chn_desc.chan_sel.h;
2705 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->radio_freq = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->packet_chn_desc.chan_sel.rf_channel.single_rf.radio_freq;
2706 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->timeslot_no = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->packet_chn_desc.timeslot_no;
2707 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->tsc = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->packet_chn_desc.tsc;
2708 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->rf_chan_cnt = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->frequency_list.rf_chan_cnt;
2709 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->relative_position_array[0] = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->relative_position_array[0];
2710 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->relative_position_array[1] = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->relative_position_array[1];
2711 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->relative_position_array[2] = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->relative_position_array[2];
2712 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->relative_position_array[3] = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->relative_position_array[3];
2713 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->relative_position_array[4] = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->relative_position_array[4];
2714 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->relative_position_array[5] = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->relative_position_array[5];
2715 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->relative_position_array[6] = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->relative_position_array[6];
2716 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->relative_position_array[7] = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->relative_position_array[7];
2717 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->relative_position_array[8] = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->relative_position_array[8];
2718 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->relative_position_array[9] = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->relative_position_array[9];
2719 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->relative_position_array[10] = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->relative_position_array[10];
2720 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->relative_position_array[11] = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->relative_position_array[11];
2721 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->relative_position_array[12] = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->relative_position_array[12];
2722 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->relative_position_array[13] = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->relative_position_array[13];
2723 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->relative_position_array[14] = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->relative_position_array[14];
2724 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->relative_position_array[15] = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->relative_position_array[15];
2725 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->relative_position_array[16] = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->relative_position_array[16];
2726 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->relative_position_array[17] = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->relative_position_array[17];
2727 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->relative_position_array[18] = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->relative_position_array[18];
2728 ((T_TR_MPHP_SCELL_PBCCH_REQ *)(ptr))->relative_position_array[19] = ((T_MPHP_SCELL_PBCCH_REQ *)(msg->SigP))->relative_position_array[19];
2729
2730 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHP_SCELL_PBCCH_REQ));
2731 }
2732 }
2733 break;
2734
2735 case MPHP_SCELL_PBCCH_STOP_REQ:
2736 {
2737 char *ptr;
2738
2739 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHP_SCELL_PBCCH_STOP_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2740 {
2741
2742 ((T_TR_MPHP_SCELL_PBCCH_STOP_REQ *)(ptr))->header = TRL1_MPHP_SCELL_PBCCH_STOP_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2743
2744 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHP_SCELL_PBCCH_STOP_REQ));
2745 }
2746 }
2747 break;
2748
2749 case L1P_PBCCHS_INFO:
2750 {
2751 char *ptr;
2752
2753 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1P_PBCCHS_INFO), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2754 {
2755
2756 ((T_TR_L1P_PBCCHS_INFO *)(ptr))->header = TRL1_L1P_PBCCHS_INFO | (((T_MPHP_DATA_IND *)(msg->SigP))->fn << TR_HEADER_FN_DELAY);
2757 ((T_TR_L1P_PBCCHS_INFO *)(ptr))->error_flag = ((T_MPHP_DATA_IND *)(msg->SigP))->error_flag;
2758 ((T_TR_L1P_PBCCHS_INFO *)(ptr))->radio_freq = ((T_MPHP_DATA_IND *)(msg->SigP))->radio_freq;
2759 ((T_TR_L1P_PBCCHS_INFO *)(ptr))->relative_position = ((T_MPHP_DATA_IND *)(msg->SigP))->relative_position;
2760 ((T_TR_L1P_PBCCHS_INFO *)(ptr))->input_level = l1a_l1s_com.Scell_IL_for_rxlev;
2761 ((T_TR_L1P_PBCCHS_INFO *)(ptr))->tpu_offset = l1s.tpu_offset;
2762 ((T_TR_L1P_PBCCHS_INFO *)(ptr))->afc = l1s.afc;
2763
2764 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1P_PBCCHS_INFO));
2765 }
2766 }
2767 break;
2768
2769 ///////////////////
2770 // Packet Access //
2771 ///////////////////
2772
2773 // Random access
2774
2775 case MPHP_RA_REQ:
2776 {
2777 char *ptr;
2778
2779 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHP_RA_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2780 {
2781
2782 ((T_TR_MPHP_RA_REQ *)(ptr))->header = TRL1_MPHP_RA_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2783 ((T_TR_MPHP_RA_REQ *)(ptr))->txpwr = ((T_MPHP_RA_REQ *)(msg->SigP))->txpwr;
2784 ((T_TR_MPHP_RA_REQ *)(ptr))->rand = ((T_MPHP_RA_REQ *)(msg->SigP))->rand;
2785 ((T_TR_MPHP_RA_REQ *)(ptr))->channel_request_data = ((T_MPHP_RA_REQ *)(msg->SigP))->channel_request_data;
2786 ((T_TR_MPHP_RA_REQ *)(ptr))->bs_prach_blks = ((T_MPHP_RA_REQ *)(msg->SigP))->bs_prach_blks;
2787 ((T_TR_MPHP_RA_REQ *)(ptr))->access_burst_type = ((T_MPHP_RA_REQ *)(msg->SigP))->access_burst_type;
2788
2789 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHP_RA_REQ));
2790 }
2791 }
2792 break;
2793
2794 case MPHP_RA_STOP_REQ:
2795 {
2796 char *ptr;
2797
2798 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHP_RA_STOP_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2799 {
2800
2801 ((T_TR_MPHP_RA_STOP_REQ *)(ptr))->header = TRL1_MPHP_RA_STOP_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2802
2803 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHP_RA_STOP_REQ));
2804 }
2805 }
2806 break;
2807
2808 case L1P_RA_DONE:
2809 {
2810 char *ptr;
2811
2812 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1P_RA_DONE), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2813 {
2814
2815 ((T_TR_L1P_RA_DONE *)(ptr))->header = TRL1_L1P_RA_DONE | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2816 ((T_TR_L1P_RA_DONE *)(ptr))->channel_request_data = ((T_MPHP_RA_CON *)(msg->SigP))->channel_request_data;
2817
2818 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1P_RA_DONE));
2819 }
2820 }
2821 break;
2822
2823 // Single block
2824
2825 case MPHP_SINGLE_BLOCK_REQ:
2826 {
2827 char *ptr;
2828
2829 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHP_SINGLE_BLOCK_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2830 {
2831 WORD32 sti;
2832
2833 if (((T_MPHP_SINGLE_BLOCK_REQ *)(msg->SigP))->tbf_sti.present == 0)
2834 sti = -1;
2835 else
2836 sti = (WORD32) ((T_MPHP_SINGLE_BLOCK_REQ *)(msg->SigP))->tbf_sti.absolute_fn;
2837
2838
2839 ((T_TR_MPHP_SINGLE_BLOCK_REQ *)(ptr))->header = TRL1_MPHP_SINGLE_BLOCK_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2840 ((T_TR_MPHP_SINGLE_BLOCK_REQ *)(ptr))->assignment_id = ((T_MPHP_SINGLE_BLOCK_REQ *)(msg->SigP))->assignment_id;
2841 ((T_TR_MPHP_SINGLE_BLOCK_REQ *)(ptr))->purpose = ((T_MPHP_SINGLE_BLOCK_REQ *)(msg->SigP))->purpose;
2842 ((T_TR_MPHP_SINGLE_BLOCK_REQ *)(ptr))->pc_meas_chan = ((T_MPHP_SINGLE_BLOCK_REQ *)(msg->SigP))->pc_meas_chan;
2843 ((T_TR_MPHP_SINGLE_BLOCK_REQ *)(ptr))->access_burst_type = ((T_MPHP_SINGLE_BLOCK_REQ *)(msg->SigP))->access_burst_type;
2844 ((T_TR_MPHP_SINGLE_BLOCK_REQ *)(ptr))->ta = ((T_MPHP_SINGLE_BLOCK_REQ *)(msg->SigP))->packet_ta.ta;
2845 ((T_TR_MPHP_SINGLE_BLOCK_REQ *)(ptr))->p0 = ((T_MPHP_SINGLE_BLOCK_REQ *)(msg->SigP))->dl_pwr_ctl.p0;
2846 ((T_TR_MPHP_SINGLE_BLOCK_REQ *)(ptr))->bts_pwr_ctl_mode = ((T_MPHP_SINGLE_BLOCK_REQ *)(msg->SigP))->dl_pwr_ctl.bts_pwr_ctl_mode;
2847 ((T_TR_MPHP_SINGLE_BLOCK_REQ *)(ptr))->pr_mode = ((T_MPHP_SINGLE_BLOCK_REQ *)(msg->SigP))->dl_pwr_ctl.pr_mode;
2848 ((T_TR_MPHP_SINGLE_BLOCK_REQ *)(ptr))->tsc = ((T_MPHP_SINGLE_BLOCK_REQ *)(msg->SigP))->tsc;
2849 ((T_TR_MPHP_SINGLE_BLOCK_REQ *)(ptr))->h = ((T_MPHP_SINGLE_BLOCK_REQ *)(msg->SigP))->freq_param.chan_sel.h;
2850 ((T_TR_MPHP_SINGLE_BLOCK_REQ *)(ptr))->radio_freq = ((T_MPHP_SINGLE_BLOCK_REQ *)(msg->SigP))->freq_param.chan_sel.rf_channel.single_rf.radio_freq;
2851 ((T_TR_MPHP_SINGLE_BLOCK_REQ *)(ptr))->rf_chan_cnt = ((T_MPHP_SINGLE_BLOCK_REQ *)(msg->SigP))->freq_param.freq_list.rf_chan_cnt;
2852 ((T_TR_MPHP_SINGLE_BLOCK_REQ *)(ptr))->tbf_sti = sti;
2853 ((T_TR_MPHP_SINGLE_BLOCK_REQ *)(ptr))->timeslot_number = ((T_MPHP_SINGLE_BLOCK_REQ *)(msg->SigP))->timeslot_number;
2854
2855 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHP_SINGLE_BLOCK_REQ));
2856 }
2857 }
2858 break;
2859
2860 case MPHP_STOP_SINGLE_BLOCK_REQ:
2861 {
2862 char *ptr;
2863
2864 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHP_STOP_SINGLE_BLOCK_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2865 {
2866
2867 ((T_TR_MPHP_STOP_SINGLE_BLOCK_REQ *)(ptr))->header = TRL1_MPHP_STOP_SINGLE_BLOCK_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2868
2869 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHP_STOP_SINGLE_BLOCK_REQ));
2870 }
2871 }
2872 break;
2873
2874 case L1P_PACCH_INFO:
2875 {
2876 char *ptr;
2877
2878 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1P_PACCH_INFO), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2879 {
2880
2881 ((T_TR_L1P_PACCH_INFO *)(ptr))->header = TRL1_L1P_PACCH_INFO | (((T_MPHP_DATA_IND *)(msg->SigP))->fn << TR_HEADER_FN_DELAY);
2882 ((T_TR_L1P_PACCH_INFO *)(ptr))->error_flag = ((T_MPHP_DATA_IND *)(msg->SigP))->error_flag;
2883 ((T_TR_L1P_PACCH_INFO *)(ptr))->radio_freq = ((T_MPHP_DATA_IND *)(msg->SigP))->radio_freq;
2884 ((T_TR_L1P_PACCH_INFO *)(ptr))->relative_position = ((T_MPHP_DATA_IND *)(msg->SigP))->relative_position;
2885 ((T_TR_L1P_PACCH_INFO *)(ptr))->input_level = l1a_l1s_com.Scell_IL_for_rxlev;
2886 ((T_TR_L1P_PACCH_INFO *)(ptr))->tpu_offset = l1s.tpu_offset;
2887 ((T_TR_L1P_PACCH_INFO *)(ptr))->afc = l1s.afc;
2888
2889 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1P_PACCH_INFO));
2890 }
2891 }
2892 break;
2893
2894 case L1P_SINGLE_BLOCK_CON:
2895 {
2896 char *ptr;
2897
2898 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1P_SINGLE_BLOCK_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2899 {
2900
2901 ((T_TR_L1P_SINGLE_BLOCK_CON *)(ptr))->header = TRL1_L1P_SINGLE_BLOCK_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2902 ((T_TR_L1P_SINGLE_BLOCK_CON *)(ptr))->assignment_id = ((T_MPHP_SINGLE_BLOCK_CON *)(msg->SigP))->assignment_id;
2903 ((T_TR_L1P_SINGLE_BLOCK_CON *)(ptr))->purpose = ((T_MPHP_SINGLE_BLOCK_CON *)(msg->SigP))->purpose;
2904 ((T_TR_L1P_SINGLE_BLOCK_CON *)(ptr))->status = ((T_MPHP_SINGLE_BLOCK_CON *)(msg->SigP))->status;
2905 ((T_TR_L1P_SINGLE_BLOCK_CON *)(ptr))->dl_error_flag = ((T_MPHP_SINGLE_BLOCK_CON *)(msg->SigP))->dl_error_flag;
2906 ((T_TR_L1P_SINGLE_BLOCK_CON *)(ptr))->txpwr[0] = l1pa_l1ps_com.transfer.dl_pwr_ctrl.txpwr[0];
2907 ((T_TR_L1P_SINGLE_BLOCK_CON *)(ptr))->txpwr[1] = l1pa_l1ps_com.transfer.dl_pwr_ctrl.txpwr[1];
2908 ((T_TR_L1P_SINGLE_BLOCK_CON *)(ptr))->txpwr[2] = l1pa_l1ps_com.transfer.dl_pwr_ctrl.txpwr[2];
2909 ((T_TR_L1P_SINGLE_BLOCK_CON *)(ptr))->txpwr[3] = l1pa_l1ps_com.transfer.dl_pwr_ctrl.txpwr[3];
2910
2911 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1P_SINGLE_BLOCK_CON));
2912 }
2913 }
2914 break;
2915
2916 // Idle mode polling
2917
2918 case MPHP_POLLING_RESPONSE_REQ:
2919 {
2920 char *ptr;
2921
2922 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHP_POLLING_RESPONSE_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2923 {
2924
2925 ((T_TR_MPHP_POLLING_RESPONSE_REQ *)(ptr))->header = TRL1_MPHP_POLLING_RESPONSE_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2926 ((T_TR_MPHP_POLLING_RESPONSE_REQ *)(ptr))->pol_resp_type = ((T_MPHP_POLLING_RESPONSE_REQ *)(msg->SigP))->pol_resp_type;
2927 ((T_TR_MPHP_POLLING_RESPONSE_REQ *)(ptr))->fn_req = ((T_MPHP_POLLING_RESPONSE_REQ *)(msg->SigP))->fn;
2928 ((T_TR_MPHP_POLLING_RESPONSE_REQ *)(ptr))->timing_advance = ((T_MPHP_POLLING_RESPONSE_REQ *)(msg->SigP))->timing_advance;
2929 ((T_TR_MPHP_POLLING_RESPONSE_REQ *)(ptr))->txpwr = ((T_MPHP_POLLING_RESPONSE_REQ *)(msg->SigP))->txpwr;
2930
2931 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHP_POLLING_RESPONSE_REQ));
2932 }
2933 }
2934 break;
2935
2936 case L1P_POLL_DONE:
2937 {
2938 char *ptr;
2939
2940 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1P_POLL_DONE), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2941 {
2942
2943 ((T_TR_L1P_POLL_DONE *)(ptr))->header = TRL1_L1P_POLL_DONE | (((T_MPHP_POLLING_IND *)(msg->SigP))->fn << TR_HEADER_FN_DELAY);
2944
2945 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1P_POLL_DONE));
2946 }
2947 }
2948 break;
2949
2950 //////////////////////////
2951 // Packet transfer mode //
2952 //////////////////////////
2953
2954 // Temporary block flow assignment
2955
2956 case MPHP_ASSIGNMENT_REQ:
2957 {
2958 char *ptr;
2959
2960 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHP_ASSIGNMENT_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
2961 {
2962 WORD32 sti;
2963
2964 if (((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->tbf_sti.present == 0)
2965 sti = -1;
2966 else
2967 sti = (WORD32) ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->tbf_sti.absolute_fn;
2968
2969
2970 ((T_TR_MPHP_ASSIGNMENT_REQ *)(ptr))->header = TRL1_MPHP_ASSIGNMENT_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
2971 ((T_TR_MPHP_ASSIGNMENT_REQ *)(ptr))->assignment_id = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->assignment_id;
2972 ((T_TR_MPHP_ASSIGNMENT_REQ *)(ptr))->assignment_command = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->assignment_command;
2973 ((T_TR_MPHP_ASSIGNMENT_REQ *)(ptr))->multislot_class = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->multislot_class;
2974 ((T_TR_MPHP_ASSIGNMENT_REQ *)(ptr))->interf_meas_enable = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->interf_meas_enable;
2975 ((T_TR_MPHP_ASSIGNMENT_REQ *)(ptr))->pc_meas_chan = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->pc_meas_chan;
2976 ((T_TR_MPHP_ASSIGNMENT_REQ *)(ptr))->access_burst_type = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->access_burst_type;
2977 ((T_TR_MPHP_ASSIGNMENT_REQ *)(ptr))->ta = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->packet_ta.ta;
2978 ((T_TR_MPHP_ASSIGNMENT_REQ *)(ptr))->ta_index = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->packet_ta.ta_index;
2979 ((T_TR_MPHP_ASSIGNMENT_REQ *)(ptr))->ta_tn = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->packet_ta.ta_tn;
2980 ((T_TR_MPHP_ASSIGNMENT_REQ *)(ptr))->p0 = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->dl_pwr_ctl.p0;
2981 ((T_TR_MPHP_ASSIGNMENT_REQ *)(ptr))->bts_pwr_ctl_mode = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->dl_pwr_ctl.bts_pwr_ctl_mode;
2982 ((T_TR_MPHP_ASSIGNMENT_REQ *)(ptr))->pr_mode = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->dl_pwr_ctl.pr_mode;
2983 ((T_TR_MPHP_ASSIGNMENT_REQ *)(ptr))->tsc = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->tsc;
2984 ((T_TR_MPHP_ASSIGNMENT_REQ *)(ptr))->h = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->freq_param.chan_sel.h;
2985 ((T_TR_MPHP_ASSIGNMENT_REQ *)(ptr))->radio_freq = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->freq_param.chan_sel.rf_channel.single_rf.radio_freq;
2986 ((T_TR_MPHP_ASSIGNMENT_REQ *)(ptr))->rf_chan_cnt = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->freq_param.freq_list.rf_chan_cnt;
2987 ((T_TR_MPHP_ASSIGNMENT_REQ *)(ptr))->tbf_sti = sti;
2988 ((T_TR_MPHP_ASSIGNMENT_REQ *)(ptr))->mac_mode = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->mac_mode;
2989 ((T_TR_MPHP_ASSIGNMENT_REQ *)(ptr))->dl_ressource_alloc = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->dl_ressource_alloc.timeslot_alloc;
2990 ((T_TR_MPHP_ASSIGNMENT_REQ *)(ptr))->ul_ressource_alloc = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->ul_ressource_alloc.timeslot_alloc;
2991 ((T_TR_MPHP_ASSIGNMENT_REQ *)(ptr))->usf_granularity = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->ul_ressource_alloc.dynamic_alloc.usf_granularity;
2992 ((T_TR_MPHP_ASSIGNMENT_REQ *)(ptr))->ctrl_timeslot = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->ul_ressource_alloc.fixed_alloc.ctrl_timeslot;
2993 ((T_TR_MPHP_ASSIGNMENT_REQ *)(ptr))->bitmap_length = ((T_MPHP_ASSIGNMENT_REQ *)(msg->SigP))->ul_ressource_alloc.fixed_alloc.bitmap_length;
2994
2995 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHP_ASSIGNMENT_REQ));
2996 }
2997 }
2998 break;
2999
3000 case MPHP_ASSIGNMENT_CON:
3001 {
3002 char *ptr;
3003
3004 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHP_ASSIGNMENT_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3005 {
3006
3007 ((T_TR_MPHP_ASSIGNMENT_CON *)(ptr))->header = TRL1_MPHP_ASSIGNMENT_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3008 ((T_TR_MPHP_ASSIGNMENT_CON *)(ptr))->dl_tn = l1a_l1s_com.dl_tn;
3009
3010 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHP_ASSIGNMENT_CON));
3011 }
3012 }
3013 break;
3014
3015 case MPHP_TBF_RELEASE_REQ:
3016 {
3017 char *ptr;
3018
3019 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHP_TBF_RELEASE_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3020 {
3021
3022 ((T_TR_MPHP_TBF_RELEASE_REQ *)(ptr))->header = TRL1_MPHP_TBF_RELEASE_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3023 ((T_TR_MPHP_TBF_RELEASE_REQ *)(ptr))->tbf_type = ((T_MPHP_TBF_RELEASE_REQ *)(msg->SigP))->tbf_type;
3024
3025 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHP_TBF_RELEASE_REQ));
3026 }
3027 }
3028 break;
3029
3030 case L1P_TBF_RELEASED:
3031 {
3032 char *ptr;
3033
3034 if (((T_L1P_TBF_RELEASED *)(msg->SigP))->released_all == 1)
3035 trace_info.new_tcr_list = 0;
3036
3037 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1P_TBF_RELEASED), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3038 {
3039
3040 ((T_TR_L1P_TBF_RELEASED *)(ptr))->header = TRL1_L1P_TBF_RELEASED | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3041 ((T_TR_L1P_TBF_RELEASED *)(ptr))->released_all = ((T_L1P_TBF_RELEASED *)(msg->SigP))->released_all;
3042 ((T_TR_L1P_TBF_RELEASED *)(ptr))->dl_tn = l1a_l1s_com.dl_tn;
3043 ((T_TR_L1P_TBF_RELEASED *)(ptr))->tbf_type = ((T_L1P_TBF_RELEASED *)(msg->SigP))->tbf_type;
3044 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1P_TBF_RELEASED));
3045 }
3046 }
3047 break;
3048
3049 // PDCH release
3050
3051 case MPHP_PDCH_RELEASE_REQ:
3052 {
3053 char *ptr;
3054
3055 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHP_PDCH_RELEASE_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3056 {
3057
3058 ((T_TR_MPHP_PDCH_RELEASE_REQ *)(ptr))->header = TRL1_MPHP_PDCH_RELEASE_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3059 ((T_TR_MPHP_PDCH_RELEASE_REQ *)(ptr))->assignment_id = ((T_MPHP_PDCH_RELEASE_REQ *)(msg->SigP))->assignment_id;
3060 ((T_TR_MPHP_PDCH_RELEASE_REQ *)(ptr))->timeslot_available = ((T_MPHP_PDCH_RELEASE_REQ *)(msg->SigP))->timeslot_available;
3061
3062 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHP_PDCH_RELEASE_REQ));
3063 }
3064 }
3065 break;
3066
3067 case L1P_PDCH_RELEASED:
3068 {
3069 char *ptr;
3070
3071 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1P_PDCH_RELEASED), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3072 {
3073
3074 ((T_TR_L1P_PDCH_RELEASED *)(ptr))->header = TRL1_L1P_PDCH_RELEASED | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3075 ((T_TR_L1P_PDCH_RELEASED *)(ptr))->assignment_id = ((T_MPHP_PDCH_RELEASE_CON *)(msg->SigP))->assignment_id;
3076 ((T_TR_L1P_PDCH_RELEASED *)(ptr))->dl_tn = l1a_l1s_com.dl_tn;
3077
3078 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1P_PDCH_RELEASED));
3079 }
3080 }
3081 break;
3082
3083 // Timing advance update
3084
3085 case MPHP_TIMING_ADVANCE_REQ:
3086 {
3087 char *ptr;
3088
3089 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHP_TIMING_ADVANCE_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3090 {
3091
3092 ((T_TR_MPHP_TIMING_ADVANCE_REQ *)(ptr))->header = TRL1_MPHP_TIMING_ADVANCE_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3093 ((T_TR_MPHP_TIMING_ADVANCE_REQ *)(ptr))->assignment_id = ((T_MPHP_TIMING_ADVANCE_REQ *)(msg->SigP))->assignment_id;
3094 ((T_TR_MPHP_TIMING_ADVANCE_REQ *)(ptr))->ta = ((T_MPHP_TIMING_ADVANCE_REQ *)(msg->SigP))->packet_ta.ta;
3095 ((T_TR_MPHP_TIMING_ADVANCE_REQ *)(ptr))->ta_index = ((T_MPHP_TIMING_ADVANCE_REQ *)(msg->SigP))->packet_ta.ta_index;
3096 ((T_TR_MPHP_TIMING_ADVANCE_REQ *)(ptr))->ta_tn = ((T_MPHP_TIMING_ADVANCE_REQ *)(msg->SigP))->packet_ta.ta_tn;
3097
3098 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHP_TIMING_ADVANCE_REQ));
3099 }
3100 }
3101 break;
3102
3103 case L1P_TA_CONFIG_DONE:
3104 {
3105 char *ptr;
3106
3107 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1P_TA_CONFIG_DONE), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3108 {
3109
3110 ((T_TR_L1P_TA_CONFIG_DONE *)(ptr))->header = TRL1_L1P_TA_CONFIG_DONE | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3111
3112 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1P_TA_CONFIG_DONE));
3113 }
3114 }
3115 break;
3116
3117 // Update PSI parameters
3118
3119 case MPHP_UPDATE_PSI_PARAM_REQ:
3120 {
3121 char *ptr;
3122
3123 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHP_UPDATE_PSI_PARAM_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3124 {
3125
3126 ((T_TR_MPHP_UPDATE_PSI_PARAM_REQ *)(ptr))->header = TRL1_MPHP_UPDATE_PSI_PARAM_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3127 ((T_TR_MPHP_UPDATE_PSI_PARAM_REQ *)(ptr))->pb = ((T_MPHP_UPDATE_PSI_PARAM_REQ *)(msg->SigP))->pb;
3128 ((T_TR_MPHP_UPDATE_PSI_PARAM_REQ *)(ptr))->access_burst_type = ((T_MPHP_UPDATE_PSI_PARAM_REQ *)(msg->SigP))->access_burst_type;
3129
3130 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHP_UPDATE_PSI_PARAM_REQ));
3131 }
3132 }
3133 break;
3134
3135 // Fixed mode repeat allocation
3136
3137 case MPHP_REPEAT_UL_FIXED_ALLOC_REQ:
3138 {
3139 char *ptr;
3140
3141 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHP_REPEAT_UL_FIXED_ALLOC_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3142 {
3143 WORD32 sti;
3144
3145 if (((T_MPHP_REPEAT_UL_FIXED_ALLOC_REQ *)(msg->SigP))->tbf_sti.present == 0)
3146 sti = -1;
3147 else
3148 sti = (WORD32) ((T_MPHP_REPEAT_UL_FIXED_ALLOC_REQ *)(msg->SigP))->tbf_sti.absolute_fn;
3149
3150
3151 ((T_TR_MPHP_REPEAT_UL_FIXED_ALLOC_REQ *)(ptr))->header = TRL1_MPHP_REPEAT_UL_FIXED_ALLOC_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3152 ((T_TR_MPHP_REPEAT_UL_FIXED_ALLOC_REQ *)(ptr))->repeat_allocation = ((T_MPHP_REPEAT_UL_FIXED_ALLOC_REQ *)(msg->SigP))->repeat_allocation;
3153 ((T_TR_MPHP_REPEAT_UL_FIXED_ALLOC_REQ *)(ptr))->ts_override = ((T_MPHP_REPEAT_UL_FIXED_ALLOC_REQ *)(msg->SigP))->ts_override;
3154 ((T_TR_MPHP_REPEAT_UL_FIXED_ALLOC_REQ *)(ptr))->tbf_sti = sti;
3155
3156 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHP_REPEAT_UL_FIXED_ALLOC_REQ));
3157 }
3158 }
3159 break;
3160
3161 case L1P_REPEAT_ALLOC_DONE:
3162 {
3163 char *ptr;
3164
3165 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1P_REPEAT_ALLOC_DONE), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3166 {
3167
3168 ((T_TR_L1P_REPEAT_ALLOC_DONE *)(ptr))->header = TRL1_L1P_REPEAT_ALLOC_DONE | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3169 ((T_TR_L1P_REPEAT_ALLOC_DONE *)(ptr))->dl_tn = l1a_l1s_com.dl_tn;
3170
3171 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1P_REPEAT_ALLOC_DONE));
3172 }
3173 }
3174 break;
3175
3176 // Fixed mode allocation exhaustion
3177
3178 case L1P_ALLOC_EXHAUST_DONE:
3179 {
3180 char *ptr;
3181
3182 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1P_ALLOC_EXHAUST_DONE), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3183 {
3184
3185 ((T_TR_L1P_ALLOC_EXHAUST_DONE *)(ptr))->header = TRL1_L1P_ALLOC_EXHAUST_DONE | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3186 ((T_TR_L1P_ALLOC_EXHAUST_DONE *)(ptr))->dl_tn = l1a_l1s_com.dl_tn;
3187
3188 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1P_ALLOC_EXHAUST_DONE));
3189 }
3190 }
3191 break;
3192
3193 //////////////////////////////
3194 // Packet mode measurements //
3195 //////////////////////////////
3196
3197 // BA list measurements in packet idle
3198
3199 case MPHP_CR_MEAS_REQ:
3200 {
3201 char *ptr;
3202
3203 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHP_CR_MEAS_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3204 {
3205
3206 ((T_TR_MPHP_CR_MEAS_REQ *)(ptr))->header = TRL1_MPHP_CR_MEAS_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3207 ((T_TR_MPHP_CR_MEAS_REQ *)(ptr))->nb_carrier = ((T_MPHP_CR_MEAS_REQ *)(msg->SigP))->nb_carrier;
3208 ((T_TR_MPHP_CR_MEAS_REQ *)(ptr))->list_id = ((T_MPHP_CR_MEAS_REQ *)(msg->SigP))->list_id;
3209
3210 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHP_CR_MEAS_REQ));
3211 }
3212 }
3213 break;
3214
3215 case MPHP_CR_MEAS_STOP_REQ:
3216 {
3217 char *ptr;
3218
3219 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHP_CR_MEAS_STOP_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3220 {
3221
3222 ((T_TR_MPHP_CR_MEAS_STOP_REQ *)(ptr))->header = TRL1_MPHP_CR_MEAS_STOP_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3223
3224 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHP_CR_MEAS_STOP_REQ));
3225 }
3226 }
3227 break;
3228
3229 case L1P_CR_MEAS_DONE:
3230 {
3231 char *ptr;
3232
3233 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1P_CR_MEAS_DONE), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3234 {
3235 UWORD8 i,nmeas;
3236
3237
3238 ((T_TR_L1P_CR_MEAS_DONE *)(ptr))->header = TRL1_L1P_CR_MEAS_DONE | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3239 ((T_TR_L1P_CR_MEAS_DONE *)(ptr))->nmeas = ((T_L1P_CR_MEAS_DONE *)(msg->SigP))->nmeas;
3240 ((T_TR_L1P_CR_MEAS_DONE *)(ptr))->list_id = ((T_L1P_CR_MEAS_DONE *)(msg->SigP))->list_id;
3241 ((T_TR_L1P_CR_MEAS_DONE *)(ptr))->reporting_period = ((T_L1P_CR_MEAS_DONE *)(msg->SigP))->reporting_period;
3242
3243 nmeas = ((T_L1P_CR_MEAS_DONE *)(msg->SigP))->nmeas;
3244 if (nmeas > MAX_CR) nmeas = MAX_CR;
3245
3246 for (i=0;i<nmeas;i++)
3247 {
3248 ((T_TR_L1P_CR_MEAS_DONE *)(ptr))->freq[i] = l1pa_l1ps_com.cres_freq_list.alist->freq_list[i];
3249 ((T_TR_L1P_CR_MEAS_DONE *)(ptr))->rxlev[i] = ((T_L1P_CR_MEAS_DONE *)(msg->SigP))->ncell_meas[i].rxlev;
3250 }
3251
3252 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1P_CR_MEAS_DONE));
3253 }
3254 }
3255 break;
3256
3257 // BA list measurements in packet transfer
3258
3259 case MPHP_TCR_MEAS_REQ:
3260 {
3261 char *ptr;
3262
3263 trace_info.new_tcr_list = 1;
3264
3265 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHP_TCR_MEAS_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3266 {
3267
3268 ((T_TR_MPHP_TCR_MEAS_REQ *)(ptr))->header = TRL1_MPHP_TCR_MEAS_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3269 ((T_TR_MPHP_TCR_MEAS_REQ *)(ptr))->nb_carrier = ((T_MPHP_TCR_MEAS_REQ *)(msg->SigP))->nb_carrier;
3270 ((T_TR_MPHP_TCR_MEAS_REQ *)(ptr))->list_id = ((T_MPHP_TCR_MEAS_REQ *)(msg->SigP))->list_id;
3271
3272 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHP_TCR_MEAS_REQ));
3273 }
3274 }
3275 break;
3276
3277 case MPHP_TCR_MEAS_STOP_REQ:
3278 {
3279 char *ptr;
3280
3281 trace_info.new_tcr_list = 0;
3282
3283 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHP_TCR_MEAS_STOP_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3284 {
3285
3286 ((T_TR_MPHP_TCR_MEAS_STOP_REQ *)(ptr))->header = TRL1_MPHP_TCR_MEAS_STOP_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3287
3288 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHP_TCR_MEAS_STOP_REQ));
3289 }
3290 }
3291 break;
3292
3293 case L1P_TCR_MEAS_DONE:
3294 {
3295 char *ptr;
3296
3297 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1P_TCR_MEAS_DONE), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3298 {
3299 UWORD8 i, nmeas;
3300 T_CRES_LIST_PARAM *list_ptr;
3301
3302 if (trace_info.new_tcr_list == 0)
3303 // No TCR list update: keep the alist pointer
3304 list_ptr = l1pa_l1ps_com.cres_freq_list.alist;
3305 else
3306 {
3307 // In case of TCR list updating, the alist pointer has changed
3308 if(l1pa_l1ps_com.cres_freq_list.alist == &(l1pa_l1ps_com.cres_freq_list.list[0]))
3309 list_ptr = &(l1pa_l1ps_com.cres_freq_list.list[1]);
3310 else
3311 list_ptr = &(l1pa_l1ps_com.cres_freq_list.list[0]);
3312 //Reset the variable new_tcr_list so that next time onwards the new list of
3313 //frequencies will get printed.
3314 trace_info.new_tcr_list = 0;
3315 }
3316
3317
3318 ((T_TR_L1P_TCR_MEAS_DONE *)(ptr))->header = TRL1_L1P_TCR_MEAS_DONE | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3319 ((T_TR_L1P_TCR_MEAS_DONE *)(ptr))->list_id = ((T_L1P_TCR_MEAS_DONE *)(msg->SigP))->list_id;
3320 ((T_TR_L1P_TCR_MEAS_DONE *)(ptr))->nb_carrier = list_ptr->nb_carrier;
3321
3322 nmeas = list_ptr->nb_carrier;
3323 if (nmeas > MAX_TCR) nmeas = MAX_TCR;
3324
3325 for (i=0;i<nmeas;i++)
3326 {
3327 ((T_TR_L1P_TCR_MEAS_DONE *)(ptr))->radio_freq[i] = list_ptr->freq_list[i];
3328 ((T_TR_L1P_TCR_MEAS_DONE *)(ptr))->acc_level[i] = ((T_L1P_TCR_MEAS_DONE *)(msg->SigP))->acc_level[i];
3329 ((T_TR_L1P_TCR_MEAS_DONE *)(ptr))->acc_nbmeas[i] = ((T_L1P_TCR_MEAS_DONE *)(msg->SigP))->acc_nbmeas[i];
3330 }
3331
3332 ((T_TR_L1P_TCR_MEAS_DONE *)(ptr))->tpu_offset = l1s.tpu_offset;
3333
3334
3335 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1P_TCR_MEAS_DONE));
3336 }
3337 }
3338 break;
3339
3340 ///////////////////////////////
3341 // Interference measurements //
3342 ///////////////////////////////
3343
3344 // Interference measurements in packet idle
3345
3346 case MPHP_INT_MEAS_REQ:
3347 {
3348 char *ptr;
3349
3350 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHP_INT_MEAS_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3351 {
3352
3353 ((T_TR_MPHP_INT_MEAS_REQ *)(ptr))->header = TRL1_MPHP_INT_MEAS_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3354 ((T_TR_MPHP_INT_MEAS_REQ *)(ptr))->h = ((T_MPHP_INT_MEAS_REQ *)(msg->SigP))->packet_intm_freq_param.chan_sel.h;
3355 ((T_TR_MPHP_INT_MEAS_REQ *)(ptr))->radio_freq = ((T_MPHP_INT_MEAS_REQ *)(msg->SigP))->packet_intm_freq_param.chan_sel.rf_channel.single_rf.radio_freq;
3356 ((T_TR_MPHP_INT_MEAS_REQ *)(ptr))->rf_chan_cnt = ((T_MPHP_INT_MEAS_REQ *)(msg->SigP))->packet_intm_freq_param.freq_list.rf_chan_cnt;
3357 ((T_TR_MPHP_INT_MEAS_REQ *)(ptr))->tn = ((T_MPHP_INT_MEAS_REQ *)(msg->SigP))->tn;
3358 ((T_TR_MPHP_INT_MEAS_REQ *)(ptr))->multislot_class = ((T_MPHP_INT_MEAS_REQ *)(msg->SigP))->multislot_class;
3359
3360 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHP_INT_MEAS_REQ));
3361 }
3362 }
3363 break;
3364
3365 case MPHP_INT_MEAS_STOP_REQ:
3366 {
3367 char *ptr;
3368
3369 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHP_INT_MEAS_STOP_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3370 {
3371
3372 ((T_TR_MPHP_INT_MEAS_STOP_REQ *)(ptr))->header = TRL1_MPHP_INT_MEAS_STOP_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3373
3374 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHP_INT_MEAS_STOP_REQ));
3375 }
3376 }
3377 break;
3378
3379 case L1P_ITMEAS_IND:
3380 {
3381 char *ptr;
3382
3383 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1P_ITMEAS_IND), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3384 {
3385
3386 ((T_TR_L1P_ITMEAS_IND *)(ptr))->header = TRL1_L1P_ITMEAS_IND | (((T_L1P_ITMEAS_IND *)(msg->SigP))->fn << TR_HEADER_FN_DELAY);
3387 ((T_TR_L1P_ITMEAS_IND *)(ptr))->position = ((T_L1P_ITMEAS_IND *)(msg->SigP))->position;
3388 ((T_TR_L1P_ITMEAS_IND *)(ptr))->meas_bitmap = ((T_L1P_ITMEAS_IND *)(msg->SigP))->meas_bitmap;
3389
3390 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1P_ITMEAS_IND));
3391 }
3392 }
3393 break;
3394
3395 case MPHP_INT_MEAS_IND:
3396 {
3397 char *ptr;
3398
3399 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHP_INT_MEAS_IND), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3400 {
3401
3402 ((T_TR_MPHP_INT_MEAS_IND *)(ptr))->header = TRL1_MPHP_INT_MEAS_IND | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3403 ((T_TR_MPHP_INT_MEAS_IND *)(ptr))->rxlev_0[0] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[0].rxlev[0];
3404 ((T_TR_MPHP_INT_MEAS_IND *)(ptr))->rxlev_0[1] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[1].rxlev[0];
3405 ((T_TR_MPHP_INT_MEAS_IND *)(ptr))->rxlev_0[2] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[2].rxlev[0];
3406 ((T_TR_MPHP_INT_MEAS_IND *)(ptr))->rxlev_0[3] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[3].rxlev[0];
3407 ((T_TR_MPHP_INT_MEAS_IND *)(ptr))->rxlev_0[4] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[4].rxlev[0];
3408 ((T_TR_MPHP_INT_MEAS_IND *)(ptr))->rxlev_0[5] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[5].rxlev[0];
3409 ((T_TR_MPHP_INT_MEAS_IND *)(ptr))->rxlev_0[6] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[6].rxlev[0];
3410 ((T_TR_MPHP_INT_MEAS_IND *)(ptr))->rxlev_0[7] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[7].rxlev[0];
3411 ((T_TR_MPHP_INT_MEAS_IND *)(ptr))->rxlev_1[0] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[0].rxlev[1];
3412 ((T_TR_MPHP_INT_MEAS_IND *)(ptr))->rxlev_1[1] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[1].rxlev[1];
3413 ((T_TR_MPHP_INT_MEAS_IND *)(ptr))->rxlev_1[2] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[2].rxlev[1];
3414 ((T_TR_MPHP_INT_MEAS_IND *)(ptr))->rxlev_1[3] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[3].rxlev[1];
3415 ((T_TR_MPHP_INT_MEAS_IND *)(ptr))->rxlev_1[4] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[4].rxlev[1];
3416 ((T_TR_MPHP_INT_MEAS_IND *)(ptr))->rxlev_1[5] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[5].rxlev[1];
3417 ((T_TR_MPHP_INT_MEAS_IND *)(ptr))->rxlev_1[6] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[6].rxlev[1];
3418 ((T_TR_MPHP_INT_MEAS_IND *)(ptr))->rxlev_1[7] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[7].rxlev[1];
3419
3420 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHP_INT_MEAS_IND));
3421 }
3422 }
3423 break;
3424
3425 // Interference measurements in packet transfer
3426
3427 case MPHP_TINT_MEAS_IND:
3428 {
3429 char *ptr;
3430
3431 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MPHP_TINT_MEAS_IND), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3432 {
3433
3434 ((T_TR_MPHP_TINT_MEAS_IND *)(ptr))->header = TRL1_MPHP_TINT_MEAS_IND | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3435 ((T_TR_MPHP_TINT_MEAS_IND *)(ptr))->rxlev_0[0] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[0].rxlev[0];
3436 ((T_TR_MPHP_TINT_MEAS_IND *)(ptr))->rxlev_0[1] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[1].rxlev[0];
3437 ((T_TR_MPHP_TINT_MEAS_IND *)(ptr))->rxlev_0[2] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[2].rxlev[0];
3438 ((T_TR_MPHP_TINT_MEAS_IND *)(ptr))->rxlev_0[3] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[3].rxlev[0];
3439 ((T_TR_MPHP_TINT_MEAS_IND *)(ptr))->rxlev_0[4] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[4].rxlev[0];
3440 ((T_TR_MPHP_TINT_MEAS_IND *)(ptr))->rxlev_0[5] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[5].rxlev[0];
3441 ((T_TR_MPHP_TINT_MEAS_IND *)(ptr))->rxlev_0[6] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[6].rxlev[0];
3442 ((T_TR_MPHP_TINT_MEAS_IND *)(ptr))->rxlev_0[7] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[7].rxlev[0];
3443 ((T_TR_MPHP_TINT_MEAS_IND *)(ptr))->rxlev_1[0] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[0].rxlev[1];
3444 ((T_TR_MPHP_TINT_MEAS_IND *)(ptr))->rxlev_1[1] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[1].rxlev[1];
3445 ((T_TR_MPHP_TINT_MEAS_IND *)(ptr))->rxlev_1[2] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[2].rxlev[1];
3446 ((T_TR_MPHP_TINT_MEAS_IND *)(ptr))->rxlev_1[3] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[3].rxlev[1];
3447 ((T_TR_MPHP_TINT_MEAS_IND *)(ptr))->rxlev_1[4] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[4].rxlev[1];
3448 ((T_TR_MPHP_TINT_MEAS_IND *)(ptr))->rxlev_1[5] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[5].rxlev[1];
3449 ((T_TR_MPHP_TINT_MEAS_IND *)(ptr))->rxlev_1[6] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[6].rxlev[1];
3450 ((T_TR_MPHP_TINT_MEAS_IND *)(ptr))->rxlev_1[7] = ((T_MPHP_INT_MEAS_IND *)(msg->SigP))->int_meas[7].rxlev[1];
3451
3452 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MPHP_TINT_MEAS_IND));
3453 }
3454 }
3455 break;
3456
3457 #endif
3458
3459 #if (AUDIO_TASK == 1)
3460
3461 /********************************************************************************/
3462 /* BACKGROUND TASKS */
3463 /********************************************************************************/
3464
3465 //////////////////
3466 // MMI messages //
3467 //////////////////
3468
3469 #if (KEYBEEP)
3470 // Keybeep
3471 case MMI_KEYBEEP_START_REQ:
3472 {
3473 char *ptr;
3474
3475 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_KEYBEEP_START_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3476 {
3477
3478 ((T_TR_MMI_KEYBEEP_START_REQ *)(ptr))->header = TRL1_MMI_KEYBEEP_START_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3479 ((T_TR_MMI_KEYBEEP_START_REQ *)(ptr))->d_k_x1_kt0 = ((T_MMI_KEYBEEP_REQ *)(msg->SigP))->d_k_x1_kt0;
3480 ((T_TR_MMI_KEYBEEP_START_REQ *)(ptr))->d_k_x1_kt1 = ((T_MMI_KEYBEEP_REQ *)(msg->SigP))->d_k_x1_kt1;
3481 ((T_TR_MMI_KEYBEEP_START_REQ *)(ptr))->d_dur_kb = ((T_MMI_KEYBEEP_REQ *)(msg->SigP))->d_dur_kb;
3482
3483 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_KEYBEEP_START_REQ));
3484 }
3485 }
3486 break;
3487
3488 case MMI_KEYBEEP_START_CON:
3489 {
3490 char *ptr;
3491
3492 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_KEYBEEP_START_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3493 {
3494
3495 ((T_TR_MMI_KEYBEEP_START_CON *)(ptr))->header = TRL1_MMI_KEYBEEP_START_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3496
3497 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_KEYBEEP_START_CON));
3498 }
3499 }
3500 break;
3501
3502 case MMI_KEYBEEP_STOP_REQ:
3503 {
3504 char *ptr;
3505
3506 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_KEYBEEP_STOP_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3507 {
3508
3509 ((T_TR_MMI_KEYBEEP_STOP_REQ *)(ptr))->header = TRL1_MMI_KEYBEEP_STOP_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3510
3511 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_KEYBEEP_STOP_REQ));
3512 }
3513 }
3514 break;
3515
3516 case MMI_KEYBEEP_STOP_CON:
3517 {
3518 char *ptr;
3519
3520 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_KEYBEEP_STOP_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3521 {
3522
3523 ((T_TR_MMI_KEYBEEP_STOP_CON *)(ptr))->header = TRL1_MMI_KEYBEEP_STOP_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3524
3525 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_KEYBEEP_STOP_CON));
3526 }
3527 }
3528 break;
3529 #endif // KEYBEEP
3530
3531 #if (TONE)
3532 // Tone
3533 case MMI_TONE_START_REQ:
3534 {
3535 char *ptr;
3536
3537 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_TONE_START_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3538 {
3539
3540 ((T_TR_MMI_TONE_START_REQ *)(ptr))->header = TRL1_MMI_TONE_START_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3541 ((T_TR_MMI_TONE_START_REQ *)(ptr))->d_k_x1_t0 = ((T_MMI_TONE_REQ *)(msg->SigP))->d_k_x1_t0;
3542 ((T_TR_MMI_TONE_START_REQ *)(ptr))->d_k_x1_t1 = ((T_MMI_TONE_REQ *)(msg->SigP))->d_k_x1_t1;
3543 ((T_TR_MMI_TONE_START_REQ *)(ptr))->d_k_x1_t2 = ((T_MMI_TONE_REQ *)(msg->SigP))->d_k_x1_t2;
3544 ((T_TR_MMI_TONE_START_REQ *)(ptr))->d_pe_rep = ((T_MMI_TONE_REQ *)(msg->SigP))->d_pe_rep;
3545 ((T_TR_MMI_TONE_START_REQ *)(ptr))->d_pe_off = ((T_MMI_TONE_REQ *)(msg->SigP))->d_pe_off;
3546 ((T_TR_MMI_TONE_START_REQ *)(ptr))->d_se_off = ((T_MMI_TONE_REQ *)(msg->SigP))->d_se_off;
3547 ((T_TR_MMI_TONE_START_REQ *)(ptr))->d_bu_off = ((T_MMI_TONE_REQ *)(msg->SigP))->d_bu_off;
3548 ((T_TR_MMI_TONE_START_REQ *)(ptr))->d_t0_on = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t0_on;
3549 ((T_TR_MMI_TONE_START_REQ *)(ptr))->d_t0_off = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t0_off;
3550 ((T_TR_MMI_TONE_START_REQ *)(ptr))->d_t1_on = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t1_on;
3551 ((T_TR_MMI_TONE_START_REQ *)(ptr))->d_t1_off = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t1_off;
3552 ((T_TR_MMI_TONE_START_REQ *)(ptr))->d_t2_on = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t2_on;
3553 ((T_TR_MMI_TONE_START_REQ *)(ptr))->d_t2_off = ((T_MMI_TONE_REQ *)(msg->SigP))->d_t2_off;
3554
3555 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_TONE_START_REQ));
3556 }
3557 }
3558 break;
3559
3560 case MMI_TONE_START_CON:
3561 {
3562 char *ptr;
3563
3564 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_TONE_START_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3565 {
3566
3567 ((T_TR_MMI_TONE_START_CON *)(ptr))->header = TRL1_MMI_TONE_START_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3568
3569 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_TONE_START_CON));
3570 }
3571 }
3572 break;
3573
3574 case MMI_TONE_STOP_REQ:
3575 {
3576 char *ptr;
3577
3578 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_TONE_STOP_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3579 {
3580
3581 ((T_TR_MMI_TONE_STOP_REQ *)(ptr))->header = TRL1_MMI_TONE_STOP_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3582
3583 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_TONE_STOP_REQ));
3584 }
3585 }
3586 break;
3587
3588 case MMI_TONE_STOP_CON:
3589 {
3590 char *ptr;
3591
3592 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_TONE_STOP_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3593 {
3594
3595 ((T_TR_MMI_TONE_STOP_CON *)(ptr))->header = TRL1_MMI_TONE_STOP_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3596
3597 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_TONE_STOP_CON));
3598 }
3599 }
3600 break;
3601 #endif // TONE
3602
3603 #if (MELODY_E1)
3604 // Melody 0
3605 case MMI_MELODY0_START_REQ:
3606 {
3607 char *ptr;
3608
3609 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_MELODY0_START_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3610 {
3611
3612 ((T_TR_MMI_MELODY0_START_REQ *)(ptr))->header = TRL1_MMI_MELODY0_START_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3613 ((T_TR_MMI_MELODY0_START_REQ *)(ptr))->session_id = ((T_MMI_MELODY_REQ *)(msg->SigP))->session_id;
3614 ((T_TR_MMI_MELODY0_START_REQ *)(ptr))->loopback = ((T_MMI_MELODY_REQ *)(msg->SigP))->loopback;
3615 ((T_TR_MMI_MELODY0_START_REQ *)(ptr))->oscillator_used_bitmap = ((T_MMI_MELODY_REQ *)(msg->SigP))->oscillator_used_bitmap;
3616
3617 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_MELODY0_START_REQ));
3618 }
3619 }
3620 break;
3621
3622 case MMI_MELODY0_START_CON:
3623 {
3624 char *ptr;
3625
3626 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_MELODY0_START_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3627 {
3628
3629 ((T_TR_MMI_MELODY0_START_CON *)(ptr))->header = TRL1_MMI_MELODY0_START_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3630
3631 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_MELODY0_START_CON));
3632 }
3633 }
3634 break;
3635
3636 case MMI_MELODY0_STOP_REQ:
3637 {
3638 char *ptr;
3639
3640 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_MELODY0_STOP_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3641 {
3642
3643 ((T_TR_MMI_MELODY0_STOP_REQ *)(ptr))->header = TRL1_MMI_MELODY0_STOP_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3644
3645 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_MELODY0_STOP_REQ));
3646 }
3647 }
3648 break;
3649
3650 case MMI_MELODY0_STOP_CON:
3651 {
3652 char *ptr;
3653
3654 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_MELODY0_STOP_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3655 {
3656
3657 ((T_TR_MMI_MELODY0_STOP_CON *)(ptr))->header = TRL1_MMI_MELODY0_STOP_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3658
3659 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_MELODY0_STOP_CON));
3660 }
3661 }
3662 break;
3663
3664 // Melody 1
3665 case MMI_MELODY1_START_REQ:
3666 {
3667 char *ptr;
3668
3669 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_MELODY1_START_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3670 {
3671
3672 ((T_TR_MMI_MELODY1_START_REQ *)(ptr))->header = TRL1_MMI_MELODY1_START_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3673 ((T_TR_MMI_MELODY1_START_REQ *)(ptr))->session_id = ((T_MMI_MELODY_REQ *)(msg->SigP))->session_id;
3674 ((T_TR_MMI_MELODY1_START_REQ *)(ptr))->loopback = ((T_MMI_MELODY_REQ *)(msg->SigP))->loopback;
3675 ((T_TR_MMI_MELODY1_START_REQ *)(ptr))->oscillator_used_bitmap = ((T_MMI_MELODY_REQ *)(msg->SigP))->oscillator_used_bitmap;
3676
3677 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_MELODY1_START_REQ));
3678 }
3679 }
3680 break;
3681
3682 case MMI_MELODY1_START_CON:
3683 {
3684 char *ptr;
3685
3686 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_MELODY1_START_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3687 {
3688
3689 ((T_TR_MMI_MELODY1_START_CON *)(ptr))->header = TRL1_MMI_MELODY1_START_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3690
3691 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_MELODY1_START_CON));
3692 }
3693 }
3694 break;
3695
3696 case MMI_MELODY1_STOP_REQ:
3697 {
3698 char *ptr;
3699
3700 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_MELODY1_STOP_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3701 {
3702
3703 ((T_TR_MMI_MELODY1_STOP_REQ *)(ptr))->header = TRL1_MMI_MELODY1_STOP_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3704
3705 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_MELODY1_STOP_REQ));
3706 }
3707 }
3708 break;
3709
3710 case MMI_MELODY1_STOP_CON:
3711 {
3712 char *ptr;
3713
3714 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_MELODY1_STOP_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3715 {
3716
3717 ((T_TR_MMI_MELODY1_STOP_CON *)(ptr))->header = TRL1_MMI_MELODY1_STOP_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3718
3719 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_MELODY1_STOP_CON));
3720 }
3721 }
3722 break;
3723 #endif // MELODY_E1
3724
3725 #if (VOICE_MEMO)
3726 // Voice memo recording
3727 case MMI_VM_RECORD_START_REQ:
3728 {
3729 char *ptr;
3730
3731 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_VM_RECORD_START_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3732 {
3733
3734 ((T_TR_MMI_VM_RECORD_START_REQ *)(ptr))->header = TRL1_MMI_VM_RECORD_START_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3735 ((T_TR_MMI_VM_RECORD_START_REQ *)(ptr))->session_id = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->session_id;
3736 ((T_TR_MMI_VM_RECORD_START_REQ *)(ptr))->maximum_size = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->maximum_size;
3737 ((T_TR_MMI_VM_RECORD_START_REQ *)(ptr))->dtx_used = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->dtx_used;
3738 ((T_TR_MMI_VM_RECORD_START_REQ *)(ptr))->record_coeff_dl = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->record_coeff_dl;
3739 ((T_TR_MMI_VM_RECORD_START_REQ *)(ptr))->record_coeff_ul = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->record_coeff_ul;
3740 ((T_TR_MMI_VM_RECORD_START_REQ *)(ptr))->d_k_x1_t0 = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_k_x1_t0;
3741 ((T_TR_MMI_VM_RECORD_START_REQ *)(ptr))->d_k_x1_t1 = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_k_x1_t1;
3742 ((T_TR_MMI_VM_RECORD_START_REQ *)(ptr))->d_k_x1_t2 = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_k_x1_t2;
3743 ((T_TR_MMI_VM_RECORD_START_REQ *)(ptr))->d_pe_rep = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_pe_rep;
3744 ((T_TR_MMI_VM_RECORD_START_REQ *)(ptr))->d_pe_off = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_pe_off;
3745 ((T_TR_MMI_VM_RECORD_START_REQ *)(ptr))->d_se_off = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_se_off;
3746 ((T_TR_MMI_VM_RECORD_START_REQ *)(ptr))->d_bu_off = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_bu_off;
3747 ((T_TR_MMI_VM_RECORD_START_REQ *)(ptr))->d_t0_on = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t0_on;
3748 ((T_TR_MMI_VM_RECORD_START_REQ *)(ptr))->d_t0_off = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t0_off;
3749 ((T_TR_MMI_VM_RECORD_START_REQ *)(ptr))->d_t1_on = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t1_on;
3750 ((T_TR_MMI_VM_RECORD_START_REQ *)(ptr))->d_t1_off = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t1_off;
3751 ((T_TR_MMI_VM_RECORD_START_REQ *)(ptr))->d_t2_on = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t2_on;
3752 ((T_TR_MMI_VM_RECORD_START_REQ *)(ptr))->d_t2_off = ((T_MMI_VM_RECORD_REQ *)(msg->SigP))->d_t2_off;
3753
3754 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_VM_RECORD_START_REQ));
3755 }
3756 }
3757 break;
3758
3759 case MMI_VM_RECORD_START_CON:
3760 {
3761 char *ptr;
3762
3763 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_VM_RECORD_START_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3764 {
3765
3766 ((T_TR_MMI_VM_RECORD_START_CON *)(ptr))->header = TRL1_MMI_VM_RECORD_START_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3767
3768 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_VM_RECORD_START_CON));
3769 }
3770 }
3771 break;
3772
3773 case MMI_VM_RECORD_STOP_REQ:
3774 {
3775 char *ptr;
3776
3777 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_VM_RECORD_STOP_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3778 {
3779
3780 ((T_TR_MMI_VM_RECORD_STOP_REQ *)(ptr))->header = TRL1_MMI_VM_RECORD_STOP_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3781
3782 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_VM_RECORD_STOP_REQ));
3783 }
3784 }
3785 break;
3786
3787 case MMI_VM_RECORD_STOP_CON:
3788 {
3789 char *ptr;
3790
3791 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_VM_RECORD_STOP_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3792 {
3793
3794 ((T_TR_MMI_VM_RECORD_STOP_CON *)(ptr))->header = TRL1_MMI_VM_RECORD_STOP_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3795
3796 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_VM_RECORD_STOP_CON));
3797 }
3798 }
3799 break;
3800
3801 // Voice memo playing
3802 case MMI_VM_PLAY_START_REQ:
3803 {
3804 char *ptr;
3805
3806 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_VM_PLAY_START_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3807 {
3808
3809 ((T_TR_MMI_VM_PLAY_START_REQ *)(ptr))->header = TRL1_MMI_VM_PLAY_START_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3810 ((T_TR_MMI_VM_PLAY_START_REQ *)(ptr))->session_id = ((T_MMI_VM_PLAY_REQ *)(msg->SigP))->session_id;
3811
3812 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_VM_PLAY_START_REQ));
3813 }
3814 }
3815 break;
3816
3817 case MMI_VM_PLAY_START_CON:
3818 {
3819 char *ptr;
3820
3821 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_VM_PLAY_START_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3822 {
3823
3824 ((T_TR_MMI_VM_PLAY_START_CON *)(ptr))->header = TRL1_MMI_VM_PLAY_START_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3825
3826 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_VM_PLAY_START_CON));
3827 }
3828 }
3829 break;
3830
3831 case MMI_VM_PLAY_STOP_REQ:
3832 {
3833 char *ptr;
3834
3835 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_VM_PLAY_STOP_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3836 {
3837
3838 ((T_TR_MMI_VM_PLAY_STOP_REQ *)(ptr))->header = TRL1_MMI_VM_PLAY_STOP_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3839
3840 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_VM_PLAY_STOP_REQ));
3841 }
3842 }
3843 break;
3844
3845 case MMI_VM_PLAY_STOP_CON:
3846 {
3847 char *ptr;
3848
3849 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_VM_PLAY_STOP_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3850 {
3851
3852 ((T_TR_MMI_VM_PLAY_STOP_CON *)(ptr))->header = TRL1_MMI_VM_PLAY_STOP_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3853
3854 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_VM_PLAY_STOP_CON));
3855 }
3856 }
3857 break;
3858 #endif // VOICE_MEMO
3859
3860 #if (L1_VOICE_MEMO_AMR)
3861 // Voice memo recording
3862 case MMI_VM_AMR_RECORD_START_REQ:
3863 {
3864 char *ptr;
3865
3866 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_VM_AMR_RECORD_START_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3867 {
3868
3869 ((T_TR_MMI_VM_AMR_RECORD_START_REQ *)(ptr))->header = TRL1_MMI_VM_AMR_RECORD_START_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3870 ((T_TR_MMI_VM_AMR_RECORD_START_REQ *)(ptr))->session_id = ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->session_id;
3871 ((T_TR_MMI_VM_AMR_RECORD_START_REQ *)(ptr))->maximum_size = ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->maximum_size;
3872 ((T_TR_MMI_VM_AMR_RECORD_START_REQ *)(ptr))->dtx_used = ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->dtx_used;
3873 ((T_TR_MMI_VM_RECORD_START_REQ *)(ptr))->record_coeff_ul = ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->record_coeff_ul;
3874 ((T_TR_MMI_VM_AMR_RECORD_START_REQ *)(ptr))->amr_vocoder = ((T_MMI_VM_AMR_RECORD_REQ *)(msg->SigP))->amr_vocoder;
3875
3876 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_VM_AMR_RECORD_START_REQ));
3877 }
3878 }
3879 break;
3880
3881 case MMI_VM_AMR_RECORD_START_CON:
3882 {
3883 char *ptr;
3884
3885 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_VM_AMR_RECORD_START_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3886 {
3887
3888 ((T_TR_MMI_VM_AMR_RECORD_START_CON *)(ptr))->header = TRL1_MMI_VM_AMR_RECORD_START_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3889
3890 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_VM_AMR_RECORD_START_CON));
3891 }
3892 }
3893 break;
3894
3895 case MMI_VM_AMR_RECORD_STOP_REQ:
3896 {
3897 char *ptr;
3898
3899 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_VM_AMR_RECORD_STOP_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3900 {
3901
3902 ((T_TR_MMI_VM_AMR_RECORD_STOP_REQ *)(ptr))->header = TRL1_MMI_VM_AMR_RECORD_STOP_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3903
3904 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_VM_AMR_RECORD_STOP_REQ));
3905 }
3906 }
3907 break;
3908
3909 case MMI_VM_AMR_RECORD_STOP_CON:
3910 {
3911 char *ptr;
3912
3913 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_VM_AMR_RECORD_STOP_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3914 {
3915
3916 ((T_TR_MMI_VM_AMR_RECORD_STOP_CON *)(ptr))->header = TRL1_MMI_VM_AMR_RECORD_STOP_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3917
3918 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_VM_AMR_RECORD_STOP_CON));
3919 }
3920 }
3921 break;
3922
3923 // Voice memo playing
3924 case MMI_VM_AMR_PLAY_START_REQ:
3925 {
3926 char *ptr;
3927
3928 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_VM_AMR_PLAY_START_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3929 {
3930
3931 ((T_TR_MMI_VM_AMR_PLAY_START_REQ *)(ptr))->header = TRL1_MMI_VM_AMR_PLAY_START_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3932 ((T_TR_MMI_VM_AMR_PLAY_START_REQ *)(ptr))->session_id = ((T_MMI_VM_AMR_PLAY_REQ *)(msg->SigP))->session_id;
3933
3934 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_VM_AMR_PLAY_START_REQ));
3935 }
3936 }
3937 break;
3938
3939 case MMI_VM_AMR_PLAY_START_CON:
3940 {
3941 char *ptr;
3942
3943 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_VM_AMR_PLAY_START_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3944 {
3945
3946 ((T_TR_MMI_VM_AMR_PLAY_START_CON *)(ptr))->header = TRL1_MMI_VM_AMR_PLAY_START_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3947
3948 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_VM_AMR_PLAY_START_CON));
3949 }
3950 }
3951 break;
3952
3953 case MMI_VM_AMR_PLAY_STOP_REQ:
3954 {
3955 char *ptr;
3956
3957 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_VM_AMR_PLAY_STOP_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3958 {
3959
3960 ((T_TR_MMI_VM_AMR_PLAY_STOP_REQ *)(ptr))->header = TRL1_MMI_VM_AMR_PLAY_STOP_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3961
3962 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_VM_AMR_PLAY_STOP_REQ));
3963 }
3964 }
3965 break;
3966
3967 case MMI_VM_AMR_PLAY_STOP_CON:
3968 {
3969 char *ptr;
3970
3971 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_VM_AMR_PLAY_STOP_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3972 {
3973
3974 ((T_TR_MMI_VM_AMR_PLAY_STOP_CON *)(ptr))->header = TRL1_MMI_VM_AMR_PLAY_STOP_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3975
3976 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_VM_AMR_PLAY_STOP_CON));
3977 }
3978 }
3979 break;
3980 case MMI_VM_AMR_PAUSE_REQ:
3981 {
3982 char *ptr;
3983
3984 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_VM_AMR_PAUSE_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3985 {
3986
3987 ((T_TR_MMI_VM_AMR_PAUSE_REQ *)(ptr))->header = TRL1_MMI_VM_AMR_PAUSE_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
3988
3989
3990 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_VM_AMR_PAUSE_REQ));
3991 }
3992 }
3993 break;
3994 case MMI_VM_AMR_RESUME_REQ:
3995 {
3996 char *ptr;
3997
3998 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_VM_AMR_RESUME_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
3999 {
4000
4001 ((T_TR_MMI_VM_AMR_RESUME_REQ *)(ptr))->header = TRL1_MMI_VM_AMR_RESUME_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4002 // ((T_TR_MMI_VM_AMR_RESUME_REQ *)(ptr))->session_id = ((T_MMI_VM_AMR_RESUME_REQ *)(msg->SigP))->session_id;
4003
4004 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_VM_AMR_RESUME_REQ));
4005 }
4006 }
4007 break;
4008
4009 case MMI_VM_AMR_PAUSE_CON:
4010 {
4011 char *ptr;
4012
4013 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_VM_AMR_PAUSE_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4014 {
4015
4016 ((T_TR_MMI_VM_AMR_PAUSE_CON *)(ptr))->header = TRL1_MMI_VM_AMR_PAUSE_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4017 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_VM_AMR_PAUSE_CON));
4018 }
4019 }
4020 break;
4021 case MMI_VM_AMR_RESUME_CON:
4022 {
4023 char *ptr;
4024
4025 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_VM_AMR_RESUME_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4026 {
4027
4028 ((T_TR_MMI_VM_AMR_RESUME_CON *)(ptr))->header = TRL1_MMI_VM_AMR_RESUME_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4029
4030 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_VM_AMR_RESUME_CON));
4031 }
4032 }
4033 break;
4034
4035
4036
4037
4038 #endif // L1_VOICE_MEMO_AMR
4039
4040 #if (SPEECH_RECO)
4041 case MMI_SR_ENROLL_START_REQ:
4042 {
4043 char *ptr;
4044
4045 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_SR_ENROLL_START_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4046 {
4047
4048 ((T_TR_MMI_SR_ENROLL_START_REQ *)(ptr))->header = TRL1_MMI_SR_ENROLL_START_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4049 ((T_TR_MMI_SR_ENROLL_START_REQ *)(ptr))->database_id = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->database_id;
4050 ((T_TR_MMI_SR_ENROLL_START_REQ *)(ptr))->word_index = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->word_index;
4051 ((T_TR_MMI_SR_ENROLL_START_REQ *)(ptr))->speech = ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->speech;
4052 ((T_TR_MMI_SR_ENROLL_START_REQ *)(ptr))->speech_address = (UWORD32) ((T_MMI_SR_ENROLL_REQ *)(msg->SigP))->speech_address;
4053
4054 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_SR_ENROLL_START_REQ));
4055 }
4056 }
4057 break;
4058
4059 case MMI_SR_ENROLL_STOP_REQ:
4060 {
4061 char *ptr;
4062
4063 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_SR_ENROLL_STOP_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4064 {
4065
4066 ((T_TR_MMI_SR_ENROLL_STOP_REQ *)(ptr))->header = TRL1_MMI_SR_ENROLL_STOP_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4067
4068 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_SR_ENROLL_STOP_REQ));
4069 }
4070 }
4071 break;
4072
4073 case MMI_SR_ENROLL_START_CON:
4074 {
4075 char *ptr;
4076
4077 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_SR_ENROLL_START_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4078 {
4079
4080 ((T_TR_MMI_SR_ENROLL_START_CON *)(ptr))->header = TRL1_MMI_SR_ENROLL_START_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4081
4082 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_SR_ENROLL_START_CON));
4083 }
4084 }
4085 break;
4086
4087 case MMI_SR_ENROLL_STOP_CON:
4088 {
4089 char *ptr;
4090
4091 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_SR_ENROLL_STOP_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4092 {
4093
4094 ((T_TR_MMI_SR_ENROLL_STOP_CON *)(ptr))->header = TRL1_MMI_SR_ENROLL_STOP_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4095 ((T_TR_MMI_SR_ENROLL_STOP_CON *)(ptr))->error_id = ((T_MMI_SR_ENROLL_STOP_CON *)(msg->SigP))->error_id;
4096
4097 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_SR_ENROLL_STOP_CON));
4098 }
4099 }
4100 break;
4101
4102 case MMI_SR_UPDATE_START_REQ:
4103 {
4104 char *ptr;
4105
4106 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_SR_UPDATE_START_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4107 {
4108
4109 ((T_TR_MMI_SR_UPDATE_START_REQ *)(ptr))->header = TRL1_MMI_SR_UPDATE_START_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4110 ((T_TR_MMI_SR_UPDATE_START_REQ *)(ptr))->database_id = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->database_id;
4111 ((T_TR_MMI_SR_UPDATE_START_REQ *)(ptr))->word_index = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->word_index;
4112 ((T_TR_MMI_SR_UPDATE_START_REQ *)(ptr))->speech = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->speech;
4113 ((T_TR_MMI_SR_UPDATE_START_REQ *)(ptr))->speech_address = ((T_MMI_SR_UPDATE_REQ *)(msg->SigP))->speech_address;
4114
4115 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_SR_UPDATE_START_REQ));
4116 }
4117 }
4118 break;
4119
4120 case MMI_SR_UPDATE_STOP_REQ:
4121 {
4122 char *ptr;
4123
4124 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_SR_UPDATE_STOP_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4125 {
4126
4127 ((T_TR_MMI_SR_UPDATE_STOP_REQ *)(ptr))->header = TRL1_MMI_SR_UPDATE_STOP_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4128
4129 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_SR_UPDATE_STOP_REQ));
4130 }
4131 }
4132 break;
4133
4134 case MMI_SR_UPDATE_START_CON:
4135 {
4136 char *ptr;
4137
4138 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_SR_UPDATE_START_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4139 {
4140
4141 ((T_TR_MMI_SR_UPDATE_START_CON *)(ptr))->header = TRL1_MMI_SR_UPDATE_START_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4142
4143 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_SR_UPDATE_START_CON));
4144 }
4145 }
4146 break;
4147
4148 case MMI_SR_UPDATE_STOP_CON:
4149 {
4150 char *ptr;
4151
4152 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_SR_UPDATE_STOP_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4153 {
4154
4155 ((T_TR_MMI_SR_UPDATE_STOP_CON *)(ptr))->header = TRL1_MMI_SR_UPDATE_STOP_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4156 ((T_TR_MMI_SR_UPDATE_STOP_CON *)(ptr))->error_id = ((T_MMI_SR_UPDATE_STOP_CON *)(msg->SigP))->error_id;
4157
4158 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_SR_UPDATE_STOP_CON));
4159 }
4160 }
4161 break;
4162
4163 case MMI_SR_RECO_START_REQ:
4164 {
4165 char *ptr;
4166
4167 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_SR_RECO_START_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4168 {
4169
4170 ((T_TR_MMI_SR_RECO_START_REQ *)(ptr))->header = TRL1_MMI_SR_RECO_START_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4171 ((T_TR_MMI_SR_RECO_START_REQ *)(ptr))->database_id = ((T_MMI_SR_RECO_REQ *)(msg->SigP))->database_id;
4172 ((T_TR_MMI_SR_RECO_START_REQ *)(ptr))->vocabulary_size = ((T_MMI_SR_RECO_REQ *)(msg->SigP))->vocabulary_size;
4173
4174 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_SR_RECO_START_REQ));
4175 }
4176 }
4177 break;
4178
4179 case MMI_SR_RECO_STOP_REQ:
4180 {
4181 char *ptr;
4182
4183 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_SR_RECO_STOP_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4184 {
4185
4186 ((T_TR_MMI_SR_RECO_STOP_REQ *)(ptr))->header = TRL1_MMI_SR_RECO_STOP_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4187
4188 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_SR_RECO_STOP_REQ));
4189 }
4190 }
4191 break;
4192
4193 case MMI_SR_RECO_START_CON:
4194 {
4195 char *ptr;
4196
4197 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_SR_RECO_START_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4198 {
4199
4200 ((T_TR_MMI_SR_RECO_START_CON *)(ptr))->header = TRL1_MMI_SR_RECO_START_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4201
4202 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_SR_RECO_START_CON));
4203 }
4204 }
4205 break;
4206
4207 case MMI_SR_RECO_STOP_CON:
4208 {
4209 char *ptr;
4210
4211 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_SR_RECO_STOP_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4212 {
4213
4214 ((T_TR_MMI_SR_RECO_STOP_CON *)(ptr))->header = TRL1_MMI_SR_RECO_STOP_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4215 ((T_TR_MMI_SR_RECO_STOP_CON *)(ptr))->error_id = ((T_MMI_SR_RECO_STOP_CON *)(msg->SigP))->error_id;
4216 ((T_TR_MMI_SR_RECO_STOP_CON *)(ptr))->best_word_index = ((T_MMI_SR_RECO_STOP_CON *)(msg->SigP))->best_word_index;
4217 ((T_TR_MMI_SR_RECO_STOP_CON *)(ptr))->best_word_score = ((T_MMI_SR_RECO_STOP_CON *)(msg->SigP))->best_word_score;
4218 ((T_TR_MMI_SR_RECO_STOP_CON *)(ptr))->second_best_word_index = ((T_MMI_SR_RECO_STOP_CON *)(msg->SigP))->second_best_word_index;
4219 ((T_TR_MMI_SR_RECO_STOP_CON *)(ptr))->second_best_word_score = ((T_MMI_SR_RECO_STOP_CON *)(msg->SigP))->second_best_word_score;
4220 ((T_TR_MMI_SR_RECO_STOP_CON *)(ptr))->third_best_word_index = ((T_MMI_SR_RECO_STOP_CON *)(msg->SigP))->third_best_word_index;
4221 ((T_TR_MMI_SR_RECO_STOP_CON *)(ptr))->third_best_word_score = ((T_MMI_SR_RECO_STOP_CON *)(msg->SigP))->third_best_word_score;
4222 ((T_TR_MMI_SR_RECO_STOP_CON *)(ptr))->fourth_best_word_index = ((T_MMI_SR_RECO_STOP_CON *)(msg->SigP))->fourth_best_word_index;
4223 ((T_TR_MMI_SR_RECO_STOP_CON *)(ptr))->fourth_best_word_score = ((T_MMI_SR_RECO_STOP_CON *)(msg->SigP))->fourth_best_word_score;
4224 ((T_TR_MMI_SR_RECO_STOP_CON *)(ptr))->d_sr_db_level = ((T_MMI_SR_RECO_STOP_CON *)(msg->SigP))->d_sr_db_level;
4225 ((T_TR_MMI_SR_RECO_STOP_CON *)(ptr))->d_sr_db_noise = ((T_MMI_SR_RECO_STOP_CON *)(msg->SigP))->d_sr_db_noise;
4226 ((T_TR_MMI_SR_RECO_STOP_CON *)(ptr))->d_sr_model_size = ((T_MMI_SR_RECO_STOP_CON *)(msg->SigP))->d_sr_model_size;
4227
4228 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_SR_RECO_STOP_CON));
4229 }
4230 }
4231 break;
4232
4233 case MMI_SR_UPDATE_CHECK_START_REQ:
4234 {
4235 char *ptr;
4236
4237 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_SR_UPDATE_CHECK_START_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4238 {
4239
4240 ((T_TR_MMI_SR_UPDATE_CHECK_START_REQ *)(ptr))->header = TRL1_MMI_SR_UPDATE_CHECK_START_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4241 ((T_TR_MMI_SR_UPDATE_CHECK_START_REQ *)(ptr))->database_id = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->database_id;
4242 ((T_TR_MMI_SR_UPDATE_CHECK_START_REQ *)(ptr))->word_index = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->word_index;
4243 ((T_TR_MMI_SR_UPDATE_CHECK_START_REQ *)(ptr))->model_address = (UWORD32) ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->model_address;
4244 ((T_TR_MMI_SR_UPDATE_CHECK_START_REQ *)(ptr))->speech = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->speech;
4245 ((T_TR_MMI_SR_UPDATE_CHECK_START_REQ *)(ptr))->speech_address = (UWORD32) ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->speech_address;
4246 ((T_TR_MMI_SR_UPDATE_CHECK_START_REQ *)(ptr))->vocabulary_size = ((T_MMI_SR_UPDATE_CHECK_REQ *)(msg->SigP))->vocabulary_size;
4247
4248 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_SR_UPDATE_CHECK_START_REQ));
4249 }
4250 }
4251 break;
4252
4253 case MMI_SR_UPDATE_CHECK_STOP_REQ:
4254 {
4255 char *ptr;
4256
4257 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_SR_UPDATE_CHECK_STOP_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4258 {
4259
4260 ((T_TR_MMI_SR_UPDATE_CHECK_STOP_REQ *)(ptr))->header = TRL1_MMI_SR_UPDATE_CHECK_STOP_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4261
4262 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_SR_UPDATE_CHECK_STOP_REQ));
4263 }
4264 }
4265 break;
4266
4267 case MMI_SR_UPDATE_CHECK_START_CON:
4268 {
4269 char *ptr;
4270
4271 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_SR_UPDATE_CHECK_START_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4272 {
4273
4274 ((T_TR_MMI_SR_UPDATE_CHECK_START_CON *)(ptr))->header = TRL1_MMI_SR_UPDATE_CHECK_START_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4275
4276 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_SR_UPDATE_CHECK_START_CON));
4277 }
4278 }
4279 break;
4280
4281 case MMI_SR_UPDATE_CHECK_STOP_CON:
4282 {
4283 char *ptr;
4284
4285 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_SR_UPDATE_CHECK_STOP_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4286 {
4287
4288 ((T_TR_MMI_SR_UPDATE_CHECK_STOP_CON *)(ptr))->header = TRL1_MMI_SR_UPDATE_CHECK_STOP_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4289 ((T_TR_MMI_SR_UPDATE_CHECK_STOP_CON *)(ptr))->error_id = ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->error_id;
4290 ((T_TR_MMI_SR_UPDATE_CHECK_STOP_CON *)(ptr))->best_word_index = ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->best_word_index;
4291 ((T_TR_MMI_SR_UPDATE_CHECK_STOP_CON *)(ptr))->best_word_score = ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->best_word_score;
4292 ((T_TR_MMI_SR_UPDATE_CHECK_STOP_CON *)(ptr))->second_best_word_index = ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->second_best_word_index;
4293 ((T_TR_MMI_SR_UPDATE_CHECK_STOP_CON *)(ptr))->second_best_word_score = ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->second_best_word_score;
4294 ((T_TR_MMI_SR_UPDATE_CHECK_STOP_CON *)(ptr))->third_best_word_index = ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->third_best_word_index;
4295 ((T_TR_MMI_SR_UPDATE_CHECK_STOP_CON *)(ptr))->third_best_word_score = ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->third_best_word_score;
4296 ((T_TR_MMI_SR_UPDATE_CHECK_STOP_CON *)(ptr))->fourth_best_word_index = ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->fourth_best_word_index;
4297 ((T_TR_MMI_SR_UPDATE_CHECK_STOP_CON *)(ptr))->fourth_best_word_score = ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->fourth_best_word_score;
4298 ((T_TR_MMI_SR_UPDATE_CHECK_STOP_CON *)(ptr))->d_sr_db_level = ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->d_sr_db_level;
4299 ((T_TR_MMI_SR_UPDATE_CHECK_STOP_CON *)(ptr))->d_sr_db_noise = ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->d_sr_db_noise;
4300 ((T_TR_MMI_SR_UPDATE_CHECK_STOP_CON *)(ptr))->d_sr_model_size = ((T_MMI_SR_UPDATE_CHECK_STOP_CON *)(msg->SigP))->d_sr_model_size;
4301
4302 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_SR_UPDATE_CHECK_STOP_CON));
4303 }
4304 }
4305 break;
4306
4307 case L1_SRBACK_SAVE_DATA_REQ:
4308 {
4309 char *ptr;
4310
4311 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1_SRBACK_SAVE_DATA_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4312 {
4313
4314 ((T_TR_L1_SRBACK_SAVE_DATA_REQ *)(ptr))->header = TRL1_L1_SRBACK_SAVE_DATA_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4315 ((T_TR_L1_SRBACK_SAVE_DATA_REQ *)(ptr))->database_id = ((T_L1_SRBACK_SAVE_DATA_REQ *)(msg->SigP))->database_id;
4316 ((T_TR_L1_SRBACK_SAVE_DATA_REQ *)(ptr))->model_index = ((T_L1_SRBACK_SAVE_DATA_REQ *)(msg->SigP))->model_index;
4317 ((T_TR_L1_SRBACK_SAVE_DATA_REQ *)(ptr))->model_RAM_address = (UWORD32) ((T_L1_SRBACK_SAVE_DATA_REQ *)(msg->SigP))->model_RAM_address;
4318 ((T_TR_L1_SRBACK_SAVE_DATA_REQ *)(ptr))->speech = ((T_L1_SRBACK_SAVE_DATA_REQ *)(msg->SigP))->speech;
4319 ((T_TR_L1_SRBACK_SAVE_DATA_REQ *)(ptr))->start_buffer = (UWORD32) ((T_L1_SRBACK_SAVE_DATA_REQ *)(msg->SigP))->start_buffer;
4320 ((T_TR_L1_SRBACK_SAVE_DATA_REQ *)(ptr))->stop_buffer = (UWORD32) ((T_L1_SRBACK_SAVE_DATA_REQ *)(msg->SigP))->stop_buffer;
4321 ((T_TR_L1_SRBACK_SAVE_DATA_REQ *)(ptr))->start_address = (UWORD32) ((T_L1_SRBACK_SAVE_DATA_REQ *)(msg->SigP))->start_address;
4322 ((T_TR_L1_SRBACK_SAVE_DATA_REQ *)(ptr))->stop_address = (UWORD32) ((T_L1_SRBACK_SAVE_DATA_REQ *)(msg->SigP))->stop_address;
4323
4324 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1_SRBACK_SAVE_DATA_REQ));
4325 }
4326 }
4327 break;
4328
4329 case L1_SRBACK_SAVE_DATA_CON:
4330 {
4331 char *ptr;
4332
4333 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1_SRBACK_SAVE_DATA_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4334 {
4335
4336 ((T_TR_L1_SRBACK_SAVE_DATA_CON *)(ptr))->header = TRL1_L1_SRBACK_SAVE_DATA_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4337
4338 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1_SRBACK_SAVE_DATA_CON));
4339 }
4340 }
4341 break;
4342
4343 case L1_SRBACK_LOAD_MODEL_REQ:
4344 {
4345 char *ptr;
4346
4347 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1_SRBACK_LOAD_MODEL_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4348 {
4349
4350 ((T_TR_L1_SRBACK_LOAD_MODEL_REQ *)(ptr))->header = TRL1_L1_SRBACK_LOAD_MODEL_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4351 ((T_TR_L1_SRBACK_LOAD_MODEL_REQ *)(ptr))->database_id = ((T_L1_SRBACK_LOAD_MODEL_REQ *)(msg->SigP))->database_id;
4352 ((T_TR_L1_SRBACK_LOAD_MODEL_REQ *)(ptr))->model_index = ((T_L1_SRBACK_LOAD_MODEL_REQ *)(msg->SigP))->model_index;
4353 ((T_TR_L1_SRBACK_LOAD_MODEL_REQ *)(ptr))->model_RAM_address = (UWORD32) ((T_L1_SRBACK_LOAD_MODEL_REQ *)(msg->SigP))->model_RAM_address;
4354 ((T_TR_L1_SRBACK_LOAD_MODEL_REQ *)(ptr))->CTO_enable = ((T_L1_SRBACK_LOAD_MODEL_REQ *)(msg->SigP))->CTO_enable;
4355
4356 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1_SRBACK_LOAD_MODEL_REQ));
4357 }
4358 }
4359 break;
4360
4361 case L1_SRBACK_LOAD_MODEL_CON:
4362 {
4363 char *ptr;
4364
4365 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1_SRBACK_LOAD_MODEL_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4366 {
4367
4368 ((T_TR_L1_SRBACK_LOAD_MODEL_CON *)(ptr))->header = TRL1_L1_SRBACK_LOAD_MODEL_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4369
4370 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1_SRBACK_LOAD_MODEL_CON));
4371 }
4372 }
4373 break;
4374
4375 case L1_SRBACK_TEMP_SAVE_DATA_REQ:
4376 {
4377 char *ptr;
4378
4379 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1_SRBACK_TEMP_SAVE_DATA_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4380 {
4381
4382 ((T_TR_L1_SRBACK_TEMP_SAVE_DATA_REQ *)(ptr))->header = TRL1_L1_SRBACK_TEMP_SAVE_DATA_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4383 ((T_TR_L1_SRBACK_TEMP_SAVE_DATA_REQ *)(ptr))->model_RAM_address_input = (UWORD32) ((T_L1_SRBACK_TEMP_SAVE_DATA_REQ *)(msg->SigP))->model_RAM_address_input;
4384 ((T_TR_L1_SRBACK_TEMP_SAVE_DATA_REQ *)(ptr))->model_RAM_address_output = (UWORD32) ((T_L1_SRBACK_TEMP_SAVE_DATA_REQ *)(msg->SigP))->model_RAM_address_output;
4385
4386 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1_SRBACK_TEMP_SAVE_DATA_REQ));
4387 }
4388 }
4389 break;
4390
4391 case L1_SRBACK_TEMP_SAVE_DATA_CON:
4392 {
4393 char *ptr;
4394
4395 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1_SRBACK_TEMP_SAVE_DATA_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4396 {
4397
4398 ((T_TR_L1_SRBACK_TEMP_SAVE_DATA_CON *)(ptr))->header = TRL1_L1_SRBACK_TEMP_SAVE_DATA_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4399
4400 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1_SRBACK_TEMP_SAVE_DATA_CON));
4401 }
4402 }
4403 break;
4404 #endif // SPEECH_RECO
4405 #if (FIR)
4406 case MMI_AUDIO_FIR_REQ:
4407 {
4408 char *ptr;
4409
4410 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_AUDIO_FIR_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4411 {
4412
4413 ((T_TR_MMI_AUDIO_FIR_REQ *)(ptr))->header = TRL1_MMI_AUDIO_FIR_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4414 ((T_TR_MMI_AUDIO_FIR_REQ *)(ptr))->fir_loop = ((T_MMI_AUDIO_FIR_REQ *)(msg->SigP))->fir_loop;
4415 ((T_TR_MMI_AUDIO_FIR_REQ *)(ptr))->update_fir = ((T_MMI_AUDIO_FIR_REQ *)(msg->SigP))->update_fir;
4416 ((T_TR_MMI_AUDIO_FIR_REQ *)(ptr))->fir_ul_coefficient = (UWORD32) ((T_MMI_AUDIO_FIR_REQ *)(msg->SigP))->fir_ul_coefficient;
4417 ((T_TR_MMI_AUDIO_FIR_REQ *)(ptr))->fir_dl_coefficient = (UWORD32) ((T_MMI_AUDIO_FIR_REQ *)(msg->SigP))->fir_dl_coefficient;
4418
4419 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_AUDIO_FIR_REQ));
4420 }
4421 }
4422 break;
4423
4424 case MMI_AUDIO_FIR_CON:
4425 {
4426 char *ptr;
4427
4428 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_AUDIO_FIR_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4429 {
4430
4431 ((T_TR_MMI_AUDIO_FIR_CON *)(ptr))->header = TRL1_MMI_AUDIO_FIR_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4432
4433 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_AUDIO_FIR_CON));
4434 }
4435 }
4436 break;
4437 #endif //FIR
4438 #if (L1_AEC == 1)
4439 case MMI_AEC_REQ:
4440 {
4441 char *ptr;
4442
4443 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_AEC_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4444 {
4445
4446 ((T_TR_MMI_AEC_REQ *)(ptr))->header = TRL1_MMI_AEC_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4447 ((T_TR_MMI_AEC_REQ *)(ptr))->aec_control = ((T_MMI_AEC_REQ *)(msg->SigP))->aec_control;
4448
4449 #if (L1_NEW_AEC)
4450 ((T_TR_MMI_AEC_REQ *)(ptr))->cont_filter = ((T_MMI_AEC_REQ *)(msg->SigP))->cont_filter;
4451 ((T_TR_MMI_AEC_REQ *)(ptr))->granularity_att = ((T_MMI_AEC_REQ *)(msg->SigP))->granularity_att;
4452 ((T_TR_MMI_AEC_REQ *)(ptr))->coef_smooth = ((T_MMI_AEC_REQ *)(msg->SigP))->coef_smooth;
4453 ((T_TR_MMI_AEC_REQ *)(ptr))->es_level_max = ((T_MMI_AEC_REQ *)(msg->SigP))->es_level_max;
4454 ((T_TR_MMI_AEC_REQ *)(ptr))->fact_vad = ((T_MMI_AEC_REQ *)(msg->SigP))->fact_vad;
4455 ((T_TR_MMI_AEC_REQ *)(ptr))->thrs_abs = ((T_MMI_AEC_REQ *)(msg->SigP))->thrs_abs;
4456 ((T_TR_MMI_AEC_REQ *)(ptr))->fact_asd_fil = ((T_MMI_AEC_REQ *)(msg->SigP))->fact_asd_fil;
4457 ((T_TR_MMI_AEC_REQ *)(ptr))->fact_asd_mut = ((T_MMI_AEC_REQ *)(msg->SigP))->fact_asd_mut;
4458 #else
4459 ((T_TR_MMI_AEC_REQ *)(ptr))->cont_filter = 0;
4460 ((T_TR_MMI_AEC_REQ *)(ptr))->granularity_att = 0;
4461 ((T_TR_MMI_AEC_REQ *)(ptr))->coef_smooth = 0;
4462 ((T_TR_MMI_AEC_REQ *)(ptr))->es_level_max = 0;
4463 ((T_TR_MMI_AEC_REQ *)(ptr))->fact_vad = 0;
4464 ((T_TR_MMI_AEC_REQ *)(ptr))->thrs_abs = 0;
4465 ((T_TR_MMI_AEC_REQ *)(ptr))->fact_asd_fil = 0;
4466 ((T_TR_MMI_AEC_REQ *)(ptr))->fact_asd_mut = 0;
4467 #endif
4468
4469 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_AEC_REQ));
4470 }
4471 }
4472 break;
4473
4474 #if (L1_NEW_AEC)
4475 case L1_AEC_IND:
4476 {
4477 char *ptr;
4478
4479 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1_AEC_IND), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4480 {
4481
4482 ((T_TR_L1_AEC_IND *)(ptr))->header = TRL1_L1_AEC_IND | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4483 ((T_TR_L1_AEC_IND *)(ptr))->far_end_pow = ((T_L1_AEC_IND *)(msg->SigP))->far_end_pow;
4484 ((T_TR_L1_AEC_IND *)(ptr))->far_end_noise = ((T_L1_AEC_IND *)(msg->SigP))->far_end_noise;
4485 ((T_TR_L1_AEC_IND *)(ptr))->es_level = ((T_L1_AEC_IND *)(msg->SigP))->es_level;
4486
4487 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1_AEC_IND));
4488 }
4489 }
4490 #endif
4491
4492 case MMI_AEC_CON:
4493 {
4494 char *ptr;
4495
4496 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_AEC_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4497 {
4498
4499 ((T_TR_MMI_AEC_CON *)(ptr))->header = TRL1_MMI_AEC_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4500
4501 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_AEC_CON));
4502 }
4503 }
4504 break;
4505 #endif //AEC
4506
4507 #if (AUDIO_MODE)
4508 case MMI_AUDIO_MODE_REQ:
4509 {
4510 char *ptr;
4511
4512 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_AUDIO_MODE_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4513 {
4514
4515 ((T_TR_MMI_AUDIO_MODE_REQ *)(ptr))->header = TRL1_MMI_AUDIO_MODE_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4516 ((T_TR_MMI_AUDIO_MODE_REQ *)(ptr))->audio_mode = ((T_MMI_AUDIO_MODE *)(msg->SigP))->audio_mode;
4517
4518 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_AUDIO_MODE_REQ));
4519 }
4520 }
4521 break;
4522
4523 case MMI_AUDIO_MODE_CON:
4524 {
4525 char *ptr;
4526
4527 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_AUDIO_MODE_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4528 {
4529
4530 ((T_TR_MMI_AUDIO_MODE_CON *)(ptr))->header = TRL1_MMI_AUDIO_MODE_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4531
4532 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_AUDIO_MODE_CON));
4533 }
4534 }
4535 break;
4536
4537 #endif // AUDIO_MODE
4538
4539 #if (MELODY_E2)
4540 // MMI command and request
4541 case MMI_MELODY0_E2_START_REQ :
4542 {
4543 char *ptr;
4544
4545 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_MELODY0_E2_START_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4546 {
4547
4548 ((T_TR_MMI_MELODY0_E2_START_REQ *)(ptr))->header = TRL1_MMI_MELODY0_E2_START_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4549 ((T_TR_MMI_MELODY0_E2_START_REQ *)(ptr))->session_id = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->session_id,
4550 ((T_TR_MMI_MELODY0_E2_START_REQ *)(ptr))->loopback = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->loopback;
4551
4552 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_MELODY0_E2_START_REQ));
4553 }
4554 }
4555 break;
4556
4557 case MMI_MELODY0_E2_STOP_REQ :
4558 {
4559 char *ptr;
4560
4561 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_MELODY0_E2_STOP_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4562 {
4563
4564 ((T_TR_MMI_MELODY0_E2_STOP_REQ *)(ptr))->header = TRL1_MMI_MELODY0_E2_STOP_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4565
4566 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_MELODY0_E2_STOP_REQ));
4567 }
4568 }
4569 break;
4570
4571 case MMI_MELODY0_E2_START_CON :
4572 {
4573 char *ptr;
4574
4575 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_MELODY0_E2_START_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4576 {
4577
4578 ((T_TR_MMI_MELODY0_E2_START_CON *)(ptr))->header = TRL1_MMI_MELODY0_E2_START_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4579
4580 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_MELODY0_E2_START_CON));
4581 }
4582 }
4583 break;
4584
4585 case MMI_MELODY0_E2_STOP_CON :
4586 {
4587 char *ptr;
4588
4589 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_MELODY0_E2_STOP_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4590 {
4591
4592 ((T_TR_MMI_MELODY0_E2_STOP_CON *)(ptr))->header = TRL1_MMI_MELODY0_E2_STOP_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4593
4594 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_MELODY0_E2_STOP_CON));
4595 }
4596 }
4597 break;
4598
4599 case MMI_MELODY1_E2_START_REQ :
4600 {
4601 char *ptr;
4602
4603 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_MELODY0_E2_START_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4604 {
4605
4606 ((T_TR_MMI_MELODY1_E2_START_REQ *)(ptr))->header = TRL1_MMI_MELODY1_E2_START_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4607 ((T_TR_MMI_MELODY1_E2_START_REQ *)(ptr))->session_id = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->session_id,
4608 ((T_TR_MMI_MELODY1_E2_START_REQ *)(ptr))->loopback = ((T_MMI_MELODY_E2_REQ *)(msg->SigP))->loopback;
4609
4610 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_MELODY1_E2_START_REQ));
4611 }
4612 }
4613 break;
4614
4615 case MMI_MELODY1_E2_STOP_REQ :
4616 {
4617 char *ptr;
4618
4619 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_MELODY1_E2_STOP_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4620 {
4621
4622 ((T_TR_MMI_MELODY1_E2_STOP_REQ *)(ptr))->header = TRL1_MMI_MELODY1_E2_STOP_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4623
4624 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_MELODY1_E2_STOP_REQ));
4625 }
4626 }
4627 break;
4628
4629 case MMI_MELODY1_E2_START_CON :
4630 {
4631 char *ptr;
4632
4633 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_MELODY1_E2_START_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4634 {
4635
4636 ((T_TR_MMI_MELODY1_E2_START_CON *)(ptr))->header = TRL1_MMI_MELODY1_E2_START_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4637
4638 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_MELODY1_E2_START_CON));
4639 }
4640 }
4641 break;
4642
4643 case MMI_MELODY1_E2_STOP_CON :
4644 {
4645 char *ptr;
4646
4647 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_MELODY1_E2_STOP_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4648 {
4649
4650 ((T_TR_MMI_MELODY1_E2_STOP_CON *)(ptr))->header = TRL1_MMI_MELODY1_E2_STOP_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4651
4652 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_MELODY1_E2_STOP_CON));
4653 }
4654 }
4655 break;
4656
4657 // Audio download instrument message
4658 case L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ :
4659 {
4660 char *ptr;
4661
4662 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4663 {
4664
4665 ((T_TR_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(ptr))->header = TRL1_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4666 ((T_TR_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(ptr))->melody_id = ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id;
4667 ((T_TR_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(ptr))->number_of_instrument = ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->number_of_instrument;
4668 ((T_TR_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(ptr))->waves_table_id[0] = ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->waves_table_id[0];
4669 ((T_TR_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(ptr))->waves_table_id[1] = ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->waves_table_id[1];
4670 ((T_TR_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(ptr))->waves_table_id[2] = ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->waves_table_id[2];
4671 ((T_TR_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(ptr))->waves_table_id[3] = ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->waves_table_id[3];
4672 ((T_TR_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(ptr))->waves_table_id[4] = ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->waves_table_id[4];
4673 ((T_TR_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(ptr))->waves_table_id[5] = ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->waves_table_id[5];
4674 ((T_TR_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(ptr))->waves_table_id[6] = ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->waves_table_id[6];
4675 ((T_TR_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(ptr))->waves_table_id[7] = ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ *)(msg->SigP))->waves_table_id[7];
4676
4677 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_REQ));
4678 }
4679 }
4680 break;
4681
4682 case L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON :
4683 {
4684 char *ptr;
4685
4686 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4687 {
4688
4689 ((T_TR_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON *)(ptr))->header = TRL1_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4690 ((T_TR_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON *)(ptr))->melody_id = ((T_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON *)(msg->SigP))->melody_id;
4691
4692 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1_BACK_MELODY_E2_LOAD_INSTRUMENT_CON));
4693 }
4694 }
4695 break;
4696
4697 case L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ :
4698 {
4699 char *ptr;
4700
4701 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4702 {
4703
4704 ((T_TR_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(ptr))->header = TRL1_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4705 ((T_TR_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(ptr))->melody_id = ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(msg->SigP))->melody_id;
4706 ((T_TR_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(ptr))->number_of_instrument = ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ *)(msg->SigP))->number_of_instrument;
4707
4708 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ));
4709 }
4710 }
4711 break;
4712
4713 case L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON :
4714 {
4715 char *ptr;
4716
4717 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4718 {
4719
4720 ((T_TR_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON *)(ptr))->header = TRL1_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4721 ((T_TR_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON *)(ptr))->melody_id = ((T_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_CON *)(msg->SigP))->melody_id;
4722
4723 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1_BACK_MELODY_E2_UNLOAD_INSTRUMENT_REQ));
4724 }
4725 }
4726 break;
4727
4728 // L1S stop confirmation
4729 case L1_MELODY0_E2_STOP_CON :
4730 {
4731 char *ptr;
4732
4733 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1_MELODY0_E2_STOP_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4734 {
4735
4736 ((T_TR_L1_MELODY0_E2_STOP_CON *)(ptr))->header = TRL1_L1_MELODY0_E2_STOP_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4737
4738 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1_MELODY0_E2_STOP_CON));
4739 }
4740 }
4741 break;
4742
4743 case L1_MELODY1_E2_STOP_CON :
4744 {
4745 char *ptr;
4746
4747 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1_MELODY1_E2_STOP_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4748 {
4749
4750 ((T_TR_L1_MELODY1_E2_STOP_CON *)(ptr))->header = TRL1_L1_MELODY1_E2_STOP_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4751
4752 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1_MELODY1_E2_STOP_CON));
4753 }
4754 }
4755 break;
4756
4757 // Instrument download
4758 #endif // MELODY_E2
4759 #if (L1_VOCODER_IF_CHANGE == 1)
4760 case MMI_TCH_VOCODER_CFG_REQ:
4761 {
4762 char *ptr;
4763 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_TCH_VOCODER_CFG_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4764 {
4765 ((T_TR_MMI_TCH_VOCODER_CFG_REQ *)(ptr))->header = TRL1_MMI_TCH_VOCODER_CFG_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4766 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_TCH_VOCODER_CFG_REQ));
4767 }
4768 }
4769 break;
4770 case MMI_TCH_VOCODER_CFG_CON:
4771 {
4772 char *ptr;
4773 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_TCH_VOCODER_CFG_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4774 {
4775 ((T_TR_MMI_TCH_VOCODER_CFG_CON *)(ptr))->header = TRL1_MMI_TCH_VOCODER_CFG_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4776 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_TCH_VOCODER_CFG_CON));
4777 }
4778 }
4779 break;
4780 case L1_VOCODER_CFG_ENABLE_CON:
4781 {
4782 char *ptr;
4783 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1_VOCODER_CFG_ENABLE_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4784 {
4785 ((T_TR_L1_VOCODER_CFG_ENABLE_CON *)(ptr))->header = TRL1_L1_VOCODER_CFG_ENABLE_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4786 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1_VOCODER_CFG_ENABLE_CON));
4787 }
4788 }
4789 break;
4790 case L1_VOCODER_CFG_DISABLE_CON:
4791 {
4792 char *ptr;
4793 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1_VOCODER_CFG_DISABLE_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4794 {
4795 ((T_TR_L1_VOCODER_CFG_DISABLE_CON *)(ptr))->header = TRL1_L1_VOCODER_CFG_DISABLE_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4796 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1_VOCODER_CFG_DISABLE_CON));
4797 }
4798 }
4799 break;
4800
4801 #endif // L1_VOCODER_IF_CHANGE
4802 #endif // AUDIO_TASK
4803
4804 ///////////////////
4805 // OML1 messages //
4806 ///////////////////
4807
4808 case OML1_CLOSE_TCH_LOOP_REQ:
4809 {
4810 char *ptr;
4811
4812 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_OML1_CLOSE_TCH_LOOP_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4813 {
4814
4815 ((T_TR_OML1_CLOSE_TCH_LOOP_REQ *)(ptr))->header = TRL1_OML1_CLOSE_TCH_LOOP_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4816 ((T_TR_OML1_CLOSE_TCH_LOOP_REQ *)(ptr))->sub_channel = ((T_OML1_CLOSE_TCH_LOOP_REQ *)(msg->SigP))->sub_channel;
4817 ((T_TR_OML1_CLOSE_TCH_LOOP_REQ *)(ptr))->frame_erasure = ((T_OML1_CLOSE_TCH_LOOP_REQ *)(msg->SigP))->frame_erasure;
4818
4819 L1_send_trace_no_cpy(ptr,sizeof(T_TR_OML1_CLOSE_TCH_LOOP_REQ));
4820 }
4821 }
4822 break;
4823
4824 case OML1_OPEN_TCH_LOOP_REQ:
4825 {
4826 char *ptr;
4827
4828 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_OML1_OPEN_TCH_LOOP_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4829 {
4830
4831 ((T_TR_OML1_OPEN_TCH_LOOP_REQ *)(ptr))->header = TRL1_OML1_OPEN_TCH_LOOP_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4832
4833 L1_send_trace_no_cpy(ptr,sizeof(T_TR_OML1_OPEN_TCH_LOOP_REQ));
4834 }
4835 }
4836 break;
4837
4838 case OML1_START_DAI_TEST_REQ:
4839 {
4840 char *ptr;
4841
4842 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_OML1_START_DAI_TEST_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4843 {
4844
4845 ((T_TR_OML1_START_DAI_TEST_REQ *)(ptr))->header = TRL1_OML1_START_DAI_TEST_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4846 ((T_TR_OML1_START_DAI_TEST_REQ *)(ptr))->tested_device = ((T_OML1_START_DAI_TEST_REQ *)(msg->SigP))->tested_device;
4847
4848 L1_send_trace_no_cpy(ptr,sizeof(T_TR_OML1_START_DAI_TEST_REQ));
4849 }
4850 }
4851 break;
4852
4853 case OML1_STOP_DAI_TEST_REQ:
4854 {
4855 char *ptr;
4856
4857 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_OML1_STOP_DAI_TEST_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4858 {
4859
4860 ((T_TR_OML1_STOP_DAI_TEST_REQ *)(ptr))->header = TRL1_OML1_STOP_DAI_TEST_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4861
4862 L1_send_trace_no_cpy(ptr,sizeof(T_TR_OML1_STOP_DAI_TEST_REQ));
4863 }
4864 }
4865 break;
4866
4867 ///////////////////
4868 // Test messages //
4869 ///////////////////
4870
4871 case TST_TEST_HW_REQ:
4872 {
4873 char *ptr;
4874
4875 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_TST_TEST_HW_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4876 {
4877
4878 ((T_TR_TST_TEST_HW_REQ *)(ptr))->header = TRL1_TST_TEST_HW_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4879
4880 L1_send_trace_no_cpy(ptr,sizeof(T_TR_TST_TEST_HW_REQ));
4881 }
4882 }
4883 break;
4884
4885 case L1_TEST_HW_INFO:
4886 {
4887 char *ptr;
4888
4889 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_L1_TEST_HW_INFO), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4890 {
4891
4892 ((T_TR_L1_TEST_HW_INFO *)(ptr))->header = TRL1_L1_TEST_HW_INFO | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4893 ((T_TR_L1_TEST_HW_INFO *)(ptr))->dsp_code_version = ((T_TST_TEST_HW_CON*)(msg->SigP))->dsp_code_version;
4894 ((T_TR_L1_TEST_HW_INFO *)(ptr))->dsp_checksum = ((T_TST_TEST_HW_CON*)(msg->SigP))->dsp_checksum;
4895 ((T_TR_L1_TEST_HW_INFO *)(ptr))->dsp_patch_version = ((T_TST_TEST_HW_CON*)(msg->SigP))->dsp_patch_version;
4896 ((T_TR_L1_TEST_HW_INFO *)(ptr))->mcu_alr_version = ((T_TST_TEST_HW_CON*)(msg->SigP))->mcu_alr_version;
4897 ((T_TR_L1_TEST_HW_INFO *)(ptr))->mcu_tm_version = ((T_TST_TEST_HW_CON*)(msg->SigP))->mcu_tm_version;
4898 #if L1_GPRS
4899 ((T_TR_L1_TEST_HW_INFO *)(ptr))->mcu_gprs_version = ((T_TST_TEST_HW_CON*)(msg->SigP))->mcu_gprs_version;
4900 #else
4901 ((T_TR_L1_TEST_HW_INFO *)(ptr))->mcu_gprs_version = 0;
4902 #endif
4903 #if ((((CHIPSET !=2 )) && ((LONG_JUMP != 0))) || (CHIPSET == 12) || (CHIPSET == 15))
4904 ((T_TR_L1_TEST_HW_INFO *)(ptr))->d_checksum1 = d_checksum1;
4905 ((T_TR_L1_TEST_HW_INFO *)(ptr))->d_checksum2 = d_checksum2;
4906 #else
4907 ((T_TR_L1_TEST_HW_INFO *)(ptr))->d_checksum1 = 0;
4908 ((T_TR_L1_TEST_HW_INFO *)(ptr))->d_checksum2 = 0;
4909 #endif
4910 L1_send_trace_no_cpy(ptr,sizeof(T_TR_L1_TEST_HW_INFO));
4911 }
4912 }
4913 break;
4914
4915 case TST_SLEEP_REQ:
4916 {
4917 char *ptr;
4918
4919 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_TST_SLEEP_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4920 {
4921
4922 ((T_TR_TST_SLEEP_REQ *)(ptr))->header = TRL1_TST_SLEEP_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4923 ((T_TR_TST_SLEEP_REQ *)(ptr))->sleep_mode = ((T_TST_SLEEP_REQ*)(msg->SigP))->sleep_mode;
4924 ((T_TR_TST_SLEEP_REQ *)(ptr))->clocks = ((T_TST_SLEEP_REQ*)(msg->SigP))->clocks;
4925
4926 L1_send_trace_no_cpy(ptr,sizeof(T_TR_TST_SLEEP_REQ));
4927 }
4928 }
4929 break;
4930
4931 /////////
4932 // ADC //
4933 /////////
4934
4935 case MMI_ADC_REQ:
4936 {
4937 char *ptr;
4938
4939 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_ADC_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4940 {
4941
4942 ((T_TR_MMI_ADC_REQ *)(ptr))->header = TRL1_MMI_ADC_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4943
4944 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_ADC_REQ));
4945 }
4946 }
4947 break;
4948
4949 case MMI_STOP_ADC_REQ:
4950 {
4951 char *ptr;
4952
4953 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_STOP_ADC_REQ), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4954 {
4955
4956 ((T_TR_MMI_STOP_ADC_REQ *)(ptr))->header = TRL1_MMI_STOP_ADC_REQ | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4957
4958 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_STOP_ADC_REQ));
4959 }
4960 }
4961 break;
4962
4963 case MMI_STOP_ADC_CON:
4964 {
4965 char *ptr;
4966
4967 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_MMI_STOP_ADC_CON), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4968 {
4969
4970 ((T_TR_MMI_STOP_ADC_CON *)(ptr))->header = TRL1_MMI_STOP_ADC_CON | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4971
4972 L1_send_trace_no_cpy(ptr,sizeof(T_TR_MMI_STOP_ADC_CON));
4973 }
4974 }
4975 break;
4976
4977 } // ...End of switch
4978 } // End if L1A message trace enabled
4979 }
4980
4981 #if L1_RECOVERY
4982
4983 /*********************************/
4984 /* Trace in case of system crash */
4985 /*********************************/
4986
4987 void l1_trace_recovery(void)
4988 {
4989 char *ptr;
4990
4991 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TR_RECOVERY), (T_RVT_BUFFER *) &ptr) == RVT_OK)
4992 {
4993
4994 ((T_TR_RECOVERY *)(ptr))->header = TRL1_RECOVERY | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
4995
4996 L1_send_trace_no_cpy(ptr,sizeof(T_TR_RECOVERY));
4997 }
4998 }
4999 #endif
5000
5001 /*************************************************************************/
5002 /* L1 Dynamic traces */
5003 /*************************************************************************/
5004
5005 /* WARNING : Following functions are called by L1S */
5006 /***************************************************/
5007
5008 #if (DSP_DEBUG_TRACE_ENABLE == 1)
5009 #define DSP_DEBUG_ENABLE \
5010 if (trace_info.dsp_debug_buf_start[l1s_dsp_com.dsp_r_page] == 0) \
5011 { \
5012 trace_info.dsp_debug_buf_start[l1s_dsp_com.dsp_r_page] = l1s_dsp_com.dsp_db2_current_r_ptr->d_debug_ptr_begin; \
5013 trace_info.dsp_debug_fn[l1s_dsp_com.dsp_r_page] = l1s.actual_time.fn; \
5014 trace_info.dsp_debug_time[l1s_dsp_com.dsp_r_page] = (UWORD16)l1s.debug_time; \
5015 }
5016 #endif
5017
5018 //////////////////////
5019 // L1S Debug Traces //
5020 //////////////////////
5021
5022 /*-------------------------------------------------------*/
5023 /* Trace_L1s_Abort() */
5024 /*-------------------------------------------------------*/
5025 /* Parameters : */
5026 /* Return : */
5027 /* */
5028 /*-------------------------------------------------------*/
5029 void Trace_L1s_Abort(UWORD8 task)
5030 {
5031 xSignalHeaderRec *msg;
5032
5033 // Allocate DEBUG message.
5034 msg = os_alloc_sig(sizeof(T_TR_L1S_ABORT));
5035 DEBUGMSG(status,NU_ALLOC_ERR)
5036 msg->SignalCode = TRACE_INFO;
5037
5038 ((T_TR_L1S_ABORT *)(msg->SigP))->header = TRL1_L1S_ABORT | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
5039 ((T_TR_L1S_ABORT *)(msg->SigP))->tpu_offset = l1s.tpu_offset;
5040 ((T_TR_L1S_ABORT *)(msg->SigP))->tpu_offset_hw = l1s.tpu_offset_hw;
5041 ((T_TR_L1S_ABORT *)(msg->SigP))->d_debug = l1s_dsp_com.dsp_db_r_ptr->d_debug & 0xffff;
5042 ((T_TR_L1S_ABORT *)(msg->SigP))->debug_time = (UWORD16) l1s.debug_time & 0xffff;
5043 ((T_TR_L1S_ABORT *)(msg->SigP))->adc_mode = l1a_l1s_com.adc_mode; // ADC enabled
5044 ((T_TR_L1S_ABORT *)(msg->SigP))->task = task;
5045
5046 // send message...
5047 os_send_sig(msg, L1C1_QUEUE);
5048 DEBUGMSG(status,NU_SEND_QUEUE_ERR)
5049
5050 }
5051
5052 /*-------------------------------------------------------*/
5053 /* Trace_MCU_DSP_Com_Mismatch() */
5054 /*-------------------------------------------------------*/
5055 /* Parameters : */
5056 /* Return : */
5057 /* */
5058 /*-------------------------------------------------------*/
5059 void Trace_MCU_DSP_Com_Mismatch(UWORD8 task)
5060 {
5061 if (trace_info.current_config->l1_dyn_trace & 1 << L1_DYN_TRACE_L1S_DEBUG)
5062 {
5063 xSignalHeaderRec *msg;
5064
5065 if((l1s_dsp_com.dsp_db_r_ptr->d_debug & 0xffff ) != (l1s.debug_time & 0xffff ))
5066 // Debug number is different than the one expected...
5067 {
5068 if(!trace_info.DSP_misaligned)
5069 // MCU/DSP com. is misaligned.
5070 {
5071 #if (DSP_DEBUG_TRACE_ENABLE == 1)
5072 if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_DSP_DEBUG)
5073 {
5074 // Flag DSP error for DSP trace and memorize address of start of DSP trace
5075 #if(MELODY_E2 || L1_MP3 || L1_AAC || L1_DYN_DSP_DWNLD )
5076 // DSP Trace is output ONLY if melody e2, mp3 or dynamic download are not currently running
5077 if(trace_info.dsptrace_handler_globals.trace_flag_blocked == FALSE)
5078 #endif
5079 DSP_DEBUG_ENABLE
5080 }
5081 #endif
5082
5083 RTTL1_EVENT(RTTL1_EVENT_ERROR, RTTL1_EVENT_SIZE_ERROR)
5084
5085 trace_info.DSP_misaligned = TRUE;
5086 }
5087 else
5088 return;
5089 }
5090 else
5091 {
5092 if(trace_info.DSP_misaligned)
5093 // MCU/DSP com. is now realigned.
5094 {
5095 trace_info.DSP_misaligned = FALSE;
5096 }
5097 else
5098 return;
5099 }
5100
5101 // Allocate DEBUG message.
5102 msg = os_alloc_sig(sizeof(T_TR_MCU_DSP_MISMATCH));
5103 DEBUGMSG(status,NU_ALLOC_ERR)
5104 msg->SignalCode = TRACE_INFO;
5105
5106 ((T_TR_MCU_DSP_MISMATCH *)(msg->SigP))->header = TRL1_MCU_DSP_MISMATCH | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
5107 ((T_TR_MCU_DSP_MISMATCH *)(msg->SigP))->tpu_offset = l1s.tpu_offset;
5108 ((T_TR_MCU_DSP_MISMATCH *)(msg->SigP))->tpu_offset_hw = l1s.tpu_offset_hw;
5109 ((T_TR_MCU_DSP_MISMATCH *)(msg->SigP))->d_debug = l1s_dsp_com.dsp_db_r_ptr->d_debug & 0xffff;
5110 ((T_TR_MCU_DSP_MISMATCH *)(msg->SigP))->debug_time = (UWORD16) l1s.debug_time & 0xffff;
5111 ((T_TR_MCU_DSP_MISMATCH *)(msg->SigP))->adc_mode = l1a_l1s_com.adc_mode; // ADC enabled
5112 ((T_TR_MCU_DSP_MISMATCH *)(msg->SigP))->task = task;
5113 ((T_TR_MCU_DSP_MISMATCH *)(msg->SigP))->error = trace_info.DSP_misaligned;
5114
5115 // send message...
5116 os_send_sig(msg, L1C1_QUEUE);
5117 DEBUGMSG(status,NU_SEND_QUEUE_ERR)
5118 }
5119 }
5120
5121 /*-------------------------------------------------------*/
5122 /* Trace_PM_Equal_0() */
5123 /*-------------------------------------------------------*/
5124 /* Parameters : */
5125 /* Return : */
5126 /* */
5127 /*-------------------------------------------------------*/
5128 void Trace_PM_Equal_0(UWORD32 pm, UWORD8 task)
5129 {
5130 if(pm==0) // PM error in the frame
5131 {
5132 if (trace_info.PM_Task == 255) // 1st PM error in the frame: This PM is memorized
5133 trace_info.PM_Task = task; // memorize the Task of this 1st PM error
5134
5135 #if ( ((TRACE_TYPE==1) || (TRACE_TYPE == 4)))
5136 if (trace_info.current_config->l1_dyn_trace & 1 << L1_DSP_TRACE_FULL_DUMP)
5137 {
5138 #if(MELODY_E2 || L1_MP3 || L1_AAC || L1_DYN_DSP_DWNLD )
5139 // DSP Trace is output ONLY if melody e2, mp3 or dynamic download are not currently running
5140 if(trace_info.dsptrace_handler_globals.trace_flag_blocked == FALSE)
5141 #endif
5142 l1_trace_full_dsp_buffer(); // trace DSP trace buffer in case a PM error occurs
5143 } // used only for debug mode,
5144 #endif
5145
5146 }
5147 else // no error in the frame :is it a PM recovery ?
5148 {
5149 if (trace_info.Not_PM_Task == 255) // 1st PM recovery case: task of recovery needs to be memorized
5150 trace_info.Not_PM_Task = task;
5151 }
5152 }
5153
5154 /*-------------------------------------------------------*/
5155 /* Trace_PM_Equal_0_balance() */
5156 /*-------------------------------------------------------*/
5157 /* Parameters : */
5158 /* Return : */
5159 /* */
5160 /*-------------------------------------------------------*/
5161 void Trace_PM_Equal_0_balance(void)
5162 {
5163 // Here below we handle the case where we have lot of PM occuring during next frames
5164 // The PM traces are filtered in order to trace:
5165 // => the first PM
5166 // => the latest PM when we have no more PM
5167 BOOL trace_pm = FALSE;
5168
5169
5170 if(trace_info.PM_Task != 255) // at least one PM occured in the current frame
5171 {
5172 if(!trace_info.PM_equal_0) // We are not in a phase of PM: We trace only the 1st PM
5173 {
5174 if (trace_info.current_config->l1_dyn_trace & 1 << L1_DYN_TRACE_L1S_DEBUG)
5175 {
5176 trace_pm = TRUE;
5177
5178 #if (DSP_DEBUG_TRACE_ENABLE == 1)
5179 if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_DSP_DEBUG)
5180 // Flag DSP error for DSP trace and memorize address of start of DSP trace
5181 {
5182 #if(MELODY_E2 || L1_MP3 || L1_AAC || L1_DYN_DSP_DWNLD )
5183 // DSP Trace is output ONLY if melody e2, mp3 or dynamic download are not currently running
5184 if(trace_info.dsptrace_handler_globals.trace_flag_blocked == FALSE)
5185 #endif
5186
5187 DSP_DEBUG_ENABLE
5188 }
5189 #endif
5190
5191 RTTL1_EVENT(RTTL1_EVENT_ERROR, RTTL1_EVENT_SIZE_ERROR)
5192 }
5193
5194 trace_info.PM_equal_0 = TRUE; // We enter in a phase of a lot of PM
5195 }
5196 }
5197 else // no PM in the current frame
5198 {
5199 if(trace_info.PM_equal_0) // this is the end of the PM phase: we trace the latest PM
5200 {
5201 if (trace_info.current_config->l1_dyn_trace & 1 << L1_DYN_TRACE_L1S_DEBUG)
5202 {
5203 trace_pm = TRUE;
5204 }
5205
5206 trace_info.PM_equal_0 = FALSE;
5207 }
5208 }
5209
5210 if (trace_pm)
5211 {
5212 xSignalHeaderRec *msg;
5213
5214 // Allocate DEBUG message.
5215 msg = os_alloc_sig(sizeof(T_TR_PM_EQUAL_0));
5216 DEBUGMSG(status,NU_ALLOC_ERR)
5217 msg->SignalCode = TRACE_INFO;
5218
5219 ((T_TR_PM_EQUAL_0 *)(msg->SigP))->header = TRL1_PM_EQUAL_0 | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
5220 ((T_TR_PM_EQUAL_0 *)(msg->SigP))->tpu_offset = l1s.tpu_offset;
5221 ((T_TR_PM_EQUAL_0 *)(msg->SigP))->tpu_offset_hw = l1s.tpu_offset_hw;
5222 ((T_TR_PM_EQUAL_0 *)(msg->SigP))->d_debug = l1s_dsp_com.dsp_db_r_ptr->d_debug & 0xffff;
5223 ((T_TR_PM_EQUAL_0 *)(msg->SigP))->debug_time = (UWORD16) l1s.debug_time & 0xffff;
5224 ((T_TR_PM_EQUAL_0 *)(msg->SigP))->adc_mode = l1a_l1s_com.adc_mode; // ADC enabled
5225 ((T_TR_PM_EQUAL_0 *)(msg->SigP))->task = trace_info.PM_Task;
5226 ((T_TR_PM_EQUAL_0 *)(msg->SigP))->no_pm_task = trace_info.Not_PM_Task;
5227 ((T_TR_PM_EQUAL_0 *)(msg->SigP))->error = trace_info.PM_equal_0;
5228
5229 // send message...
5230 os_send_sig(msg, L1C1_QUEUE);
5231 DEBUGMSG(status,NU_SEND_QUEUE_ERR)
5232 }
5233
5234 trace_info.PM_Task = 255;
5235 trace_info.Not_PM_Task = 255;
5236 }
5237
5238 /*-------------------------------------------------------*/
5239 /* l1_trace_IT_DSP_error() */
5240 /*-------------------------------------------------------*/
5241 /* Parameters : */
5242 /* Return : */
5243 /* */
5244 /*-------------------------------------------------------*/
5245 void l1_trace_IT_DSP_error(UWORD8 cause)
5246 {
5247 #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
5248 if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_L1S_DEBUG)
5249 {
5250 xSignalHeaderRec *msg;
5251
5252 // Allocate DEBUG message.
5253 msg = os_alloc_sig(sizeof(T_TR_IT_DSP_ERROR));
5254 DEBUGMSG(status,NU_ALLOC_ERR)
5255 msg->SignalCode = TRACE_INFO;
5256
5257 ((T_TR_IT_DSP_ERROR *)(msg->SigP))->header = TRL1_IT_DSP_ERROR | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
5258
5259 // send message...
5260 os_send_sig(msg, L1C1_QUEUE);
5261 DEBUGMSG(status,NU_SEND_QUEUE_ERR)
5262 }
5263 #endif
5264 }
5265
5266 ///////////////////////
5267 // P.Transfer traces //
5268 ///////////////////////
5269
5270 #if L1_GPRS
5271
5272 /*-------------------------------------------------------*/
5273 /* Trace_dl_ptcch() */
5274 /*-------------------------------------------------------*/
5275 /* Parameters : */
5276 /* Return : */
5277 /* */
5278 /*-------------------------------------------------------*/
5279 void Trace_dl_ptcch(UWORD8 ordered_ta,
5280 UWORD8 crc) // Current TX allocation for Polling
5281 {
5282 xSignalHeaderRec *msg;
5283
5284 // Allocate DEBUG message.
5285 msg = os_alloc_sig(sizeof(T_TR_DL_PTCCH));
5286 DEBUGMSG(status,NU_ALLOC_ERR)
5287 msg->SignalCode = TRACE_INFO;
5288
5289 ((T_TR_DL_PTCCH *)(msg->SigP))->header = TRL1_DL_PTCCH | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
5290 ((T_TR_DL_PTCCH *)(msg->SigP))->crc_error = crc;
5291 ((T_TR_DL_PTCCH *)(msg->SigP))->ordered_ta = ordered_ta;
5292
5293 // send message...
5294 os_send_sig(msg, L1C1_QUEUE);
5295 DEBUGMSG(status,NU_SEND_QUEUE_ERR)
5296
5297 } // End Trace_ptcch_error
5298
5299 /*-------------------------------------------------------*/
5300 /* Trace_rlc_ul_param() */
5301 /*-------------------------------------------------------*/
5302 /* Parameters : */
5303 /* Return : */
5304 /* */
5305 /*-------------------------------------------------------*/
5306 void Trace_rlc_ul_param(UWORD8 assignment_id,
5307 UWORD8 tx_no,
5308 UWORD32 fn,
5309 UWORD8 ta,
5310 UWORD32 a_pu_gprs,
5311 UWORD32 a_du_gprs,
5312 BOOL fix_alloc_exhaust)
5313 {
5314 xSignalHeaderRec *msg;
5315
5316 // Allocate DEBUG message.
5317 msg = os_alloc_sig(sizeof(T_TR_RLC_UL_PARAM));
5318 DEBUGMSG(status,NU_ALLOC_ERR)
5319 msg->SignalCode = TRACE_INFO;
5320
5321 ((T_TR_RLC_UL_PARAM *)(msg->SigP))->header = TRL1_RLC_UL_PARAM | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
5322 ((T_TR_RLC_UL_PARAM *)(msg->SigP))->a_pu_gprs = a_pu_gprs;
5323 ((T_TR_RLC_UL_PARAM *)(msg->SigP))->a_du_gprs = a_du_gprs;
5324 ((T_TR_RLC_UL_PARAM *)(msg->SigP))->assignment_id = assignment_id;
5325 ((T_TR_RLC_UL_PARAM *)(msg->SigP))->tx_no = tx_no;
5326 ((T_TR_RLC_UL_PARAM *)(msg->SigP))->fn_param = fn;
5327 ((T_TR_RLC_UL_PARAM *)(msg->SigP))->ta = ta;
5328 ((T_TR_RLC_UL_PARAM *)(msg->SigP))->fix_alloc_exhaust = fix_alloc_exhaust;
5329
5330 // send message...
5331 os_send_sig(msg, L1C1_QUEUE);
5332 DEBUGMSG(status,NU_SEND_QUEUE_ERR)
5333 }
5334
5335 /*-------------------------------------------------------*/
5336 /* Trace_rlc_dl_param() */
5337 /*-------------------------------------------------------*/
5338 /* Parameters : */
5339 /* Return : */
5340 /* */
5341 /*-------------------------------------------------------*/
5342 void Trace_rlc_dl_param( UWORD8 assignment_id,
5343 UWORD32 fn,
5344 UWORD32 d_rlcmac_rx_no_gprs,
5345 UWORD8 rx_no,
5346 UWORD8 rlc_blocks_sent,
5347 UWORD8 last_poll_response)
5348 {
5349 xSignalHeaderRec *msg;
5350
5351 // Allocate DEBUG message.
5352 msg = os_alloc_sig(sizeof(T_TR_RLC_DL_PARAM));
5353 DEBUGMSG(status,NU_ALLOC_ERR)
5354 msg->SignalCode = TRACE_INFO;
5355
5356
5357 ((T_TR_RLC_DL_PARAM *)(msg->SigP))->header = TRL1_RLC_DL_PARAM | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
5358 ((T_TR_RLC_DL_PARAM *)(msg->SigP))->fn_param = fn;
5359 ((T_TR_RLC_DL_PARAM *)(msg->SigP))->d_rlcmac_rx_no_gprs = d_rlcmac_rx_no_gprs;
5360 ((T_TR_RLC_DL_PARAM *)(msg->SigP))->assignment_id = assignment_id;
5361 ((T_TR_RLC_DL_PARAM *)(msg->SigP))->rx_no = rx_no;
5362 ((T_TR_RLC_DL_PARAM *)(msg->SigP))->rlc_blocks_sent = rlc_blocks_sent;
5363 ((T_TR_RLC_DL_PARAM *)(msg->SigP))->last_poll_response = last_poll_response;
5364
5365 // send message...
5366 os_send_sig(msg, L1C1_QUEUE);
5367 DEBUGMSG(status,NU_SEND_QUEUE_ERR)
5368 }
5369
5370 /*-------------------------------------------------------*/
5371 /* Trace_uplink_no_TA() */
5372 /*-------------------------------------------------------*/
5373 /* Parameters : */
5374 /* Return : */
5375 /* */
5376 /*-------------------------------------------------------*/
5377 void Trace_uplink_no_TA()
5378 {
5379 xSignalHeaderRec *msg;
5380
5381 // Allocate DEBUG message.
5382 msg = os_alloc_sig(sizeof(T_TR_FORBIDDEN_UPLINK));
5383 DEBUGMSG(status,NU_ALLOC_ERR)
5384 msg->SignalCode = TRACE_INFO;
5385
5386 ((T_TR_FORBIDDEN_UPLINK *)(msg->SigP))->header = TRL1_FORBIDDEN_UPLINK | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
5387
5388 // send message...
5389 os_send_sig(msg, L1C1_QUEUE);
5390 DEBUGMSG(status,NU_SEND_QUEUE_ERR)
5391 }
5392
5393 /*-------------------------------------------------------*/
5394 /* l1_trace_ptcch_disable() */
5395 /*-------------------------------------------------------*/
5396 /* Parameters : */
5397 /* Return : */
5398 /* Trace the gauging is running */
5399 /*-------------------------------------------------------*/
5400 void l1_trace_ptcch_disable(void)
5401 {
5402 #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
5403
5404 xSignalHeaderRec *msg;
5405
5406 if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_L1S_DEBUG)
5407 {
5408 // Allocate DEBUG message.
5409 msg = os_alloc_sig(sizeof(T_TR_PTCCH_DISABLE));
5410 DEBUGMSG(status,NU_ALLOC_ERR)
5411 msg->SignalCode = TRACE_INFO;
5412
5413 ((T_TR_TOA_NOT_UPDATED *)(msg->SigP))->header = TRL1_PTCCH_DISABLE | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
5414
5415 // send message...
5416 os_send_sig(msg, L1C1_QUEUE);
5417 DEBUGMSG(status,NU_SEND_QUEUE_ERR)
5418 }
5419 #endif
5420 }
5421
5422 /*-------------------------------------------------------*/
5423 /* Trace_pdtch() */
5424 /*-------------------------------------------------------*/
5425 /* Parameters : */
5426 /* Return : */
5427 /* */
5428 /*-------------------------------------------------------*/
5429 void Trace_condensed_pdtch(UWORD8 rx_allocation, UWORD8 tx_allocation)
5430 {
5431 xSignalHeaderRec *msg;
5432
5433 // Allocate DEBUG message.
5434 msg = os_alloc_sig(sizeof(T_CONDENSED_PDTCH_INFO));
5435 DEBUGMSG(status,NU_ALLOC_ERR)
5436 msg->SignalCode = TRACE_CONDENSED_PDTCH;
5437
5438 ((T_CONDENSED_PDTCH_INFO *)(msg->SigP))->fn = l1s.actual_time.fn;
5439 ((T_CONDENSED_PDTCH_INFO *)(msg->SigP))->rx_allocation = rx_allocation;
5440 ((T_CONDENSED_PDTCH_INFO *)(msg->SigP))->tx_allocation = tx_allocation;
5441 ((T_CONDENSED_PDTCH_INFO *)(msg->SigP))->blk_status = trace_info.pdtch_trace.blk_status;
5442 ((T_CONDENSED_PDTCH_INFO *)(msg->SigP))->dl_cs_type = trace_info.pdtch_trace.dl_cs_type;
5443 ((T_CONDENSED_PDTCH_INFO *)(msg->SigP))->dl_status[0] = trace_info.pdtch_trace.dl_status[0];
5444 ((T_CONDENSED_PDTCH_INFO *)(msg->SigP))->dl_status[1] = trace_info.pdtch_trace.dl_status[1];
5445 ((T_CONDENSED_PDTCH_INFO *)(msg->SigP))->dl_status[2] = trace_info.pdtch_trace.dl_status[2];
5446 ((T_CONDENSED_PDTCH_INFO *)(msg->SigP))->dl_status[3] = trace_info.pdtch_trace.dl_status[3];
5447 ((T_CONDENSED_PDTCH_INFO *)(msg->SigP))->ul_status[0] = trace_info.pdtch_trace.ul_status[0];
5448 ((T_CONDENSED_PDTCH_INFO *)(msg->SigP))->ul_status[1] = trace_info.pdtch_trace.ul_status[1];
5449 ((T_CONDENSED_PDTCH_INFO *)(msg->SigP))->ul_status[2] = trace_info.pdtch_trace.ul_status[2];
5450 ((T_CONDENSED_PDTCH_INFO *)(msg->SigP))->ul_status[3] = trace_info.pdtch_trace.ul_status[3];
5451 ((T_CONDENSED_PDTCH_INFO *)(msg->SigP))->ul_status[4] = trace_info.pdtch_trace.ul_status[4];
5452 ((T_CONDENSED_PDTCH_INFO *)(msg->SigP))->ul_status[5] = trace_info.pdtch_trace.ul_status[5];
5453 ((T_CONDENSED_PDTCH_INFO *)(msg->SigP))->ul_status[6] = trace_info.pdtch_trace.ul_status[6];
5454 ((T_CONDENSED_PDTCH_INFO *)(msg->SigP))->ul_status[7] = trace_info.pdtch_trace.ul_status[7];
5455
5456 // send message...
5457 os_send_sig(msg, L1C1_QUEUE);
5458 DEBUGMSG(status,NU_SEND_QUEUE_ERR)
5459 }
5460
5461 /*-------------------------------------------------------*/
5462 /* Quick_Trace() */
5463 /*-------------------------------------------------------*/
5464 /* Parameters : */
5465 /* Return : */
5466 /* Description: This function can be used to quickly add */
5467 /* a trace */
5468 /* NOT TO USE FOR PERMANENT TRACES !!! */
5469 /*-------------------------------------------------------*/
5470 void Quick_Trace(UWORD8 debug_code,
5471 UWORD32 param0,
5472 UWORD32 param1,
5473 UWORD32 param2,
5474 UWORD32 param3,
5475 UWORD32 param4,
5476 UWORD32 param5,
5477 UWORD32 param6)
5478 {
5479 xSignalHeaderRec *msg;
5480
5481 // Allocate DEBUG message.
5482 msg = os_alloc_sig(sizeof(T_QUICK_TRACE));
5483 DEBUGMSG(status,NU_ALLOC_ERR)
5484 msg->SignalCode = QUICK_TRACE;
5485
5486 ((T_QUICK_TRACE *)(msg->SigP))->debug_code = debug_code;
5487 ((T_QUICK_TRACE *)(msg->SigP))->fn = l1s.actual_time.fn;
5488
5489 ((T_QUICK_TRACE *)(msg->SigP))->tab[0] = param0;
5490 ((T_QUICK_TRACE *)(msg->SigP))->tab[1] = param1;
5491 ((T_QUICK_TRACE *)(msg->SigP))->tab[2] = param2;
5492 ((T_QUICK_TRACE *)(msg->SigP))->tab[3] = param3;
5493 ((T_QUICK_TRACE *)(msg->SigP))->tab[4] = param4;
5494 ((T_QUICK_TRACE *)(msg->SigP))->tab[5] = param5;
5495 ((T_QUICK_TRACE *)(msg->SigP))->tab[6] = param6;
5496
5497 // send message...
5498 os_send_sig(msg, L1C1_QUEUE);
5499 DEBUGMSG(status,NU_SEND_QUEUE_ERR)
5500 }
5501
5502 #endif // L1_GPRS
5503
5504 ///////////////////////
5505 // DSP error traces //
5506 ///////////////////////
5507
5508 #if (D_ERROR_STATUS_TRACE_ENABLE)
5509
5510 /*-------------------------------------------------------*/
5511 /* Trace_d_error_status() */
5512 /*-------------------------------------------------------*/
5513 /* Parameters : */
5514 /* Return : */
5515 /* */
5516 /*-------------------------------------------------------*/
5517 void Trace_d_error_status()
5518 {
5519 #if L1_GPRS
5520 UWORD16 d_error_status_masked =
5521 (l1s_dsp_com.dsp_ndb_ptr->d_error_status) &
5522 (trace_info.d_error_status_masks[l1a_l1s_com.dsp_scheduler_mode - 1]); // depends on the scheduler mode
5523 #else
5524 UWORD16 d_error_status_masked =
5525 (l1s_dsp_com.dsp_ndb_ptr->d_error_status) &
5526 (trace_info.d_error_status_masks[GSM_SCHEDULER - 1]);
5527 #endif
5528 UWORD16 changed_bits = d_error_status_masked ^ trace_info.d_error_status_old;
5529
5530 // trace in case of change of status (field is reseted on change of scheduler)
5531 if (changed_bits)
5532 {
5533 xSignalHeaderRec *msg;
5534
5535 // Allocate DEBUG message.
5536 msg = os_alloc_sig(sizeof(T_TR_D_ERROR_STATUS));
5537 DEBUGMSG(status,NU_ALLOC_ERR)
5538 msg->SignalCode = TRACE_INFO;
5539
5540 ((T_TR_D_ERROR_STATUS *)(msg->SigP))->header = TRL1_D_ERROR_STATUS | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
5541 ((T_TR_D_ERROR_STATUS *)(msg->SigP))->debug_time = (UWORD16)l1s.debug_time;
5542 ((T_TR_D_ERROR_STATUS *)(msg->SigP))->d_error_status = d_error_status_masked;
5543 ((T_TR_D_ERROR_STATUS *)(msg->SigP))->d_debug = l1s_dsp_com.dsp_db_r_ptr->d_debug & 0xffff;
5544
5545 // send message...
5546 os_send_sig(msg, L1C1_QUEUE);
5547 DEBUGMSG(status,NU_SEND_QUEUE_ERR)
5548
5549 #if (DSP_DEBUG_TRACE_ENABLE == 1)
5550 if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_DSP_DEBUG)
5551 {
5552 // DSP debug buffer trace only if an ERROR is detected (not for a End of error detection)
5553 if ((changed_bits & d_error_status_masked) & ~trace_info.d_error_status_old)
5554 {
5555 // Flag DSP error for DSP trace and memorize address of start of DSP trace
5556
5557 #if(MELODY_E2 || L1_MP3 || L1_AAC || L1_DYN_DSP_DWNLD)
5558 // DSP Trace is output ONLY if melody e2, mp3 or dynamic download are not currently running
5559 if(trace_info.dsptrace_handler_globals.trace_flag_blocked == FALSE)
5560 #endif
5561
5562 DSP_DEBUG_ENABLE
5563 }
5564 }
5565 #endif
5566
5567 RTTL1_EVENT(RTTL1_EVENT_ERROR, RTTL1_EVENT_SIZE_ERROR)
5568
5569 trace_info.d_error_status_old = d_error_status_masked;
5570 }
5571
5572 // Clear bits that have been set by the DSP
5573 l1s_dsp_com.dsp_ndb_ptr->d_error_status &= ~d_error_status_masked;
5574 }
5575
5576 #endif // (D_ERROR_STATUS_TRACE_ENABLE)
5577
5578 #if (DSP_DEBUG_TRACE_ENABLE == 1)
5579
5580 /*-------------------------------------------------------*/
5581 /* Trace_dsp_debug() */
5582 /*-------------------------------------------------------*/
5583 /* Parameters : */
5584 /* Return : */
5585 /* */
5586 /*-------------------------------------------------------*/
5587 void Trace_dsp_debug()
5588 {
5589 // WARNING: l1s_dsp_com.dsp_r_page changed in l1s_end_manager() but DSP DB pointers haven't been
5590 // updated !!!
5591 UWORD32 start_address = trace_info.dsp_debug_buf_start[l1s_dsp_com.dsp_r_page];
5592 UWORD32 end_address, stop_address;
5593 UWORD16 size;
5594 API *i;
5595 UWORD8 j = 0;
5596 xSignalHeaderRec *msg;
5597
5598 // DSP DEBUG trace only works when GSM activity is enabled
5599 if (l1s_dsp_com.dsp_r_page_used == FALSE)
5600 {
5601 trace_info.dsp_debug_buf_start[0] = trace_info.dsp_debug_buf_start[1] = 0;
5602 }
5603
5604 // If a DSP error occured...
5605 if (start_address)
5606 {
5607 WORD32 diff = l1s.debug_time - trace_info.fn_last_dsp_debug;
5608
5609 if (diff < 0) diff += 0xFFFFFFFF;
5610
5611 if (diff >= 104)
5612 {
5613
5614 // Take the DB_R pointers on the start/end of last TDMA trace
5615 start_address = 0xFFD00000 + (start_address - 0x800) * 2;
5616 end_address = 0xFFD00000 + (l1s_dsp_com.dsp_db2_other_r_ptr->d_debug_ptr_end - 0x800) * 2;
5617
5618 // Process size of block
5619 if (end_address >= start_address)
5620 {
5621 size = end_address - start_address;
5622 stop_address = end_address;
5623 }
5624 else
5625 {
5626 size = end_address - start_address + C_DEBUG_BUFFER_SIZE * 2;
5627 stop_address = (0xFFD00000 + (C_DEBUG_BUFFER_ADD + 1 + C_DEBUG_BUFFER_SIZE - 0x800) * 2);
5628 }
5629
5630 if ((size > 0) && (size < 1000) && (size < C_DEBUG_BUFFER_SIZE))
5631 {
5632 // Allocate memory pool
5633 msg = os_alloc_sig(size + sizeof(T_DSP_DEBUG_INFO) - 2*sizeof(API));
5634 DEBUGMSG(status,NU_ALLOC_ERR)
5635
5636 msg->SignalCode = TRACE_DSP_DEBUG;
5637 ((T_DSP_DEBUG_INFO *)(msg->SigP))->size = size;
5638 ((T_DSP_DEBUG_INFO *)(msg->SigP))->fn = trace_info.dsp_debug_fn[l1s_dsp_com.dsp_r_page];
5639 ((T_DSP_DEBUG_INFO *)(msg->SigP))->debug_time = trace_info.dsp_debug_time[l1s_dsp_com.dsp_r_page];
5640 ((T_DSP_DEBUG_INFO *)(msg->SigP))->patch_version = l1s_dsp_com.dsp_ndb_ptr->d_version_number2;
5641 ((T_DSP_DEBUG_INFO *)(msg->SigP))->trace_level = l1s_dsp_com.dsp_ndb_ptr->d_debug_trace_type;
5642
5643 // Copy data into message
5644 for (i = (API*)start_address; i < (API*)stop_address; i++)
5645 {
5646 ((T_DSP_DEBUG_INFO *)(msg->SigP))->buffer[j++] = *i;
5647 }
5648
5649 // Circular buffer management
5650 if (i != (API*)end_address)
5651 {
5652 for (i = (API*) (0xFFD00000 + (C_DEBUG_BUFFER_ADD + 1 - 0x800)*2); i < (API*)end_address; i++)
5653 {
5654 ((T_DSP_DEBUG_INFO *)(msg->SigP))->buffer[j++] = *i;
5655 }
5656 }
5657
5658 // Send sig to L1A
5659 os_send_sig(msg, L1C1_QUEUE);
5660 DEBUGMSG(status,NU_SEND_QUEUE_ERR)
5661
5662 // Set FN to avoid another DSP debug trace in the next 104 frames.
5663 trace_info.fn_last_dsp_debug = l1s.debug_time;
5664 }
5665 } // Enf if diff >= 104
5666
5667 // Clear flag
5668 trace_info.dsp_debug_buf_start[l1s_dsp_com.dsp_r_page] = 0;
5669 } // End if "DSP error occured"
5670 }
5671
5672 #if (AMR == 1)
5673
5674 /*-------------------------------------------------------*/
5675 /* Trace_dsp_amr_debug() */
5676 /*-------------------------------------------------------*/
5677 /* Parameters : */
5678 /* Return : */
5679 /* */
5680 /*-------------------------------------------------------*/
5681 void Trace_dsp_amr_debug()
5682 {
5683 UWORD32 start_address;
5684 UWORD32 end_address, stop_address;
5685 UWORD16 size;
5686 API *i;
5687 UWORD8 j = 0;
5688 xSignalHeaderRec *msg;
5689
5690 // Start address of the AMR trace in the DSP trace buffer
5691 start_address = l1s_dsp_com.dsp_ndb_ptr->xxx;
5692
5693 // Clear the pointer
5694 l1s_dsp_com.dsp_ndb_ptr->xxx = 0;
5695
5696 // If start address different of 0 -> trace to be performed
5697 if (start_address != 0)
5698 {
5699 // Process MCU start address
5700 start_address = 0xFFD00000 + (start_address - 0x800) * 2;
5701
5702 // Check ID and read size
5703 if ((((API*)start_adress & 0xFE00) >> 9) == C_AMR_TRACE_ID)
5704 {
5705 // Read size
5706 size = ((((API*)start_address) & 0x1FF) * 2);
5707 start_address += sizeof(API); // Do not dump header
5708
5709 // Process stop address
5710 end_address = start_address + size;
5711
5712 // Circular buffer...
5713 if (end_address <= (0xFFD00000 + (C_DEBUG_BUFFER_ADD + 1 + C_DEBUG_BUFFER_SIZE - 0x800) * 2))
5714 {
5715 stop_address = end_address;
5716 }
5717 else
5718 {
5719 stop_address = (0xFFD00000 + (C_DEBUG_BUFFER_ADD + 1 + C_DEBUG_BUFFER_SIZE - 0x800) * 2);
5720 end_address -= C_DEBUG_BUFFER_SIZE * 2;
5721 }
5722
5723 // Create L1S->L1A message and dump buffer
5724
5725 // Allocate memory pool
5726 msg = os_alloc_sig(size+sizeof(T_DSP_AMR_DEBUG_INFO)-2*sizeof(API));
5727 DEBUGMSG(status,NU_ALLOC_ERR)
5728
5729 msg->SignalCode = TRACE_DSP_AMR_DEBUG;
5730 ((T_DSP_AMR_DEBUG_INFO *)(msg->SigP))->size = size;
5731 ((T_DSP_AMR_DEBUG_INFO *)(msg->SigP))->fn = l1s.actual_time.fn;
5732
5733 // Copy data into message
5734 for (i = (API*)start_address; i < (API*)stop_address; i++)
5735 {
5736 ((T_DSP_AMR_DEBUG_INFO *)(msg->SigP))->buffer[j++] = *i;
5737 }
5738
5739 // Circular buffer management
5740 if (i != (API*)end_address)
5741 {
5742 for (i = (API*) (0xFFD00000 + (C_DEBUG_BUFFER_ADD + 1 - 0x800)*2); i < (API*)end_address; i++)
5743 {
5744 ((T_DSP_AMR_DEBUG_INFO *)(msg->SigP))->buffer[j++] = *i;
5745 }
5746 }
5747
5748 // Send sig to L1A
5749 os_send_sig(msg, L1C1_QUEUE);
5750 DEBUGMSG(status,NU_SEND_QUEUE_ERR)
5751 }
5752 }
5753 }
5754
5755 #endif // #if (AMR == 1)
5756
5757 #endif // #if (DSP_DEBUG_TRACE_ENABLE)
5758
5759 ///////////////////////////
5760 // Trace type 1 CPU load //
5761 ///////////////////////////
5762
5763 #if ((TRACE_TYPE == 1) || (TRACE_TYPE == 4)) && (CODE_VERSION != SIMULATION)
5764
5765 /*-------------------------------------------------------*/
5766 /* L1S_CPU_load_process() */
5767 /*-------------------------------------------------------*/
5768 /* Parameters : */
5769 /* Return : */
5770 /* */
5771 /*-------------------------------------------------------*/
5772 void Trace_L1S_CPU_load()
5773 {
5774 #define TIMER_RESET_VALUE (0xFFFF)
5775 #define TICKS_PER_TDMA (1875)
5776
5777 unsigned long cpu;
5778
5779 //Dtimer2_Start(0);
5780 layer_1_sync_end_time = TIMER_RESET_VALUE - Dtimer2_ReadValue();
5781
5782 // Trace
5783 cpu = (100 * layer_1_sync_end_time) / TICKS_PER_TDMA;
5784
5785 if (cpu > max_cpu)
5786 {
5787 max_cpu=cpu;
5788 fn_max_cpu=l1s.actual_time.fn;
5789 max_cpu_flag = 1;
5790 }
5791
5792 if (((l1s.actual_time.fn%1326) == 0) && (max_cpu_flag == 0))
5793 max_cpu = 0;
5794 } /* end of Trace_L1S_CPU_load() */
5795
5796 #if 0 /* FreeCalypso: feature not present in our chipset */
5797 /********** DSP CPU load measurement *************/
5798 void l1_dsp_cpu_load_read()
5799 {
5800
5801 #define DSP_TIMER_PRESCALER_VALUE (9)
5802
5803 T_DB_MCU_TO_DSP_CPU_LOAD *mcu_dsp_cpu_load_r_ptr; // DSP CPU load measurement
5804 UWORD32 dsp_fgd_tsk_cycles = 0L;
5805 UWORD16 dsp_tdma_fn;
5806 UWORD16 d_dsp_page_read;
5807 UWORD32 d_dsp_work_period;
5808 UWORD32 d_dsp_fgd_tsk_cycles_per_tdma;
5809 UWORD16 d_tdma_fnmod4;
5810 UWORD16 d_tdma_fnmod13;
5811
5812 // **** 1. Read the DSP FGD task cycles from API ****
5813
5814 // Check if DSP CPU load has been written in first buffer
5815 mcu_dsp_cpu_load_r_ptr = (T_DB_MCU_TO_DSP_CPU_LOAD *)DSP_CPU_LOAD_DB_W_PAGE_0;
5816 if ((API)mcu_dsp_cpu_load_r_ptr->d_dsp_fgd_tsk_tim0 & 0x8000)
5817 {
5818 mcu_dsp_cpu_load_r_ptr->d_dsp_fgd_tsk_tim0 &= ~(0x8000); // reset the bit
5819 dsp_fgd_tsk_cycles = (UWORD32)(((UWORD32)mcu_dsp_cpu_load_r_ptr->d_dsp_fgd_tsk_tim0 << 16)
5820 + ((UWORD32)mcu_dsp_cpu_load_r_ptr->d_dsp_fgd_tsk_tim1));
5821 dsp_fgd_tsk_cycles = (dsp_fgd_tsk_cycles * DSP_TIMER_PRESCALER_VALUE);
5822
5823 dsp_tdma_fn = (API)mcu_dsp_cpu_load_r_ptr->d_tdma_dsp_fn;
5824
5825 d_dsp_page_read = 0;
5826 }
5827 else
5828 {
5829 // Check if DSP CPU load has been written in second buffer
5830 mcu_dsp_cpu_load_r_ptr = (T_DB_MCU_TO_DSP_CPU_LOAD *)DSP_CPU_LOAD_DB_W_PAGE_1;
5831 if ((API)mcu_dsp_cpu_load_r_ptr->d_dsp_fgd_tsk_tim0 & 0x8000)
5832 {
5833 mcu_dsp_cpu_load_r_ptr->d_dsp_fgd_tsk_tim0 &= ~(0x8000); // reset the bit
5834 dsp_fgd_tsk_cycles = (UWORD32)(((UWORD32)mcu_dsp_cpu_load_r_ptr->d_dsp_fgd_tsk_tim0 << 16)
5835 + ((UWORD32)mcu_dsp_cpu_load_r_ptr->d_dsp_fgd_tsk_tim1));
5836 dsp_fgd_tsk_cycles = (dsp_fgd_tsk_cycles * DSP_TIMER_PRESCALER_VALUE);
5837
5838 dsp_tdma_fn = (API)mcu_dsp_cpu_load_r_ptr->d_tdma_dsp_fn;
5839
5840 d_dsp_page_read = 1;
5841
5842 }
5843 }
5844
5845 // **** 2. Get the number of DSP cycles per TDMA (based on DSP work period) ****
5846 if (dsp_fgd_tsk_cycles != 0L)
5847 {
5848 /* Take care of TDMA FN overflow */
5849 d_dsp_work_period = (l1s.actual_time.fn_mod42432 - dsp_tdma_fn - 2 + 42432) % 42432;
5850
5851 d_dsp_fgd_tsk_cycles_per_tdma = dsp_fgd_tsk_cycles/(d_dsp_work_period + 1); // to avoid divide by 0, just in case
5852
5853 // **** 3. For DSP work-period, update max cycles count ****
5854 d_tdma_fnmod13 = (l1s.actual_time.fn_mod13 - 1 + 13) % 13;
5855 d_tdma_fnmod4 = (l1s.actual_time.fn_mod13_mod4 - 1 + 4) % 4;
5856
5857 if (d_tdma_fnmod13 == 12) //Idle/SACCH/PTCCH frames
5858 {
5859 if (dsp_max_cpu_load_idle_frame <= d_dsp_fgd_tsk_cycles_per_tdma)
5860 dsp_max_cpu_load_idle_frame = d_dsp_fgd_tsk_cycles_per_tdma;
5861 }
5862 else // for TDMA frames 0/1/2/3 (mod 4)
5863 {
5864 if (dsp_max_cpu_load_trace_array[d_tdma_fnmod4] <= d_dsp_fgd_tsk_cycles_per_tdma)
5865 dsp_max_cpu_load_trace_array[d_tdma_fnmod4] = d_dsp_fgd_tsk_cycles_per_tdma;
5866 }
5867
5868 // **** 4. If 104 TDMA frames have elapsed, print out the DSP CPU cycles ****
5869 if ((l1s.actual_time.fn_mod42432 % 104) == 0)
5870 {
5871 l1_dsp_cpu_load_trace_flag = 1;
5872 }
5873 }
5874 } /* end of l1_dsp_cpu_load_read() */
5875 #endif
5876
5877 #endif
5878
5879 ///////////////////////////
5880 // Additional L1S traces //
5881 ///////////////////////////
5882
5883 /*-------------------------------------------------------*/
5884 /* l1_trace_ADC() */
5885 /*-------------------------------------------------------*/
5886 /* Parameters : */
5887 /* Return : */
5888 /* */
5889 /*-------------------------------------------------------*/
5890 void l1_trace_ADC(UWORD8 type)
5891 {
5892 #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
5893
5894 xSignalHeaderRec *msg;
5895
5896 if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_L1A_MESSAGES)
5897 {
5898 // Allocate DEBUG message.
5899 msg = os_alloc_sig(sizeof(T_TR_ADC));
5900 DEBUGMSG(status,NU_ALLOC_ERR)
5901 msg->SignalCode = TRACE_INFO;
5902
5903 ((T_TR_ADC *)(msg->SigP))->header = TRL1_ADC | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
5904 ((T_TR_ADC *)(msg->SigP))->type = type;
5905
5906 // send message...
5907 os_send_sig(msg, L1C1_QUEUE);
5908 DEBUGMSG(status,NU_SEND_QUEUE_ERR)
5909 }
5910 #endif
5911 }
5912
5913 /*-------------------------------------------------------*/
5914 /* l1_trace_burst_param() */
5915 /*-------------------------------------------------------*/
5916 /* Parameters : */
5917 /* Return : */
5918 /* */
5919 /*-------------------------------------------------------*/
5920 void l1_trace_burst_param (UWORD32 angle, UWORD32 snr, UWORD32 afc, UWORD32 task,
5921 UWORD32 pm, UWORD32 toa_val, UWORD32 IL_for_rxlev)
5922 {
5923 #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
5924
5925 xSignalHeaderRec *msg;
5926
5927 if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_BURST_PARAM)
5928 {
5929 // Allocate DEBUG message.
5930 msg = os_alloc_sig(sizeof(T_TR_BURST_PARAM));
5931 DEBUGMSG(status,NU_ALLOC_ERR)
5932 msg->SignalCode = TRACE_INFO;
5933
5934 ((T_TR_BURST_PARAM *)(msg->SigP))->header = TRL1_BURST_PARAM | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
5935 ((T_TR_BURST_PARAM *)(msg->SigP))->angle = angle;
5936 ((T_TR_BURST_PARAM *)(msg->SigP))->snr = snr;
5937 ((T_TR_BURST_PARAM *)(msg->SigP))->afc = afc;
5938 ((T_TR_BURST_PARAM *)(msg->SigP))->task = task;
5939 ((T_TR_BURST_PARAM *)(msg->SigP))->pm = pm;
5940 ((T_TR_BURST_PARAM *)(msg->SigP))->toa = toa_val;
5941 ((T_TR_BURST_PARAM *)(msg->SigP))->input_level = IL_for_rxlev;
5942
5943 // send message...
5944 os_send_sig(msg, L1C1_QUEUE);
5945 DEBUGMSG(status,NU_SEND_QUEUE_ERR)
5946 }
5947 #endif
5948 }
5949
5950
5951 /*-------------------------------------------------------*/
5952 /* l1_trace_saic() */
5953 /*-------------------------------------------------------*/
5954 /* Parameters : */
5955 /* Return : */
5956 /* */
5957 /*-------------------------------------------------------*/
5958 void l1_trace_saic(UWORD32 SWH_flag, UWORD32 SAIC_flag)
5959 {
5960 #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
5961
5962 xSignalHeaderRec *msg;
5963
5964 if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_SAIC_DEBUG)
5965 {
5966 // Allocate DEBUG message.
5967 msg = os_alloc_sig(sizeof(T_TR_SAIC_DEBUG));
5968 DEBUGMSG(status,NU_ALLOC_ERR)
5969 msg->SignalCode = TRACE_INFO;
5970
5971 ((T_TR_SAIC_DEBUG *)(msg->SigP))->header = TRL1_SAIC_DEBUG | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
5972 ((T_TR_SAIC_DEBUG *)(msg->SigP))->SWH_flag = SWH_flag;
5973 ((T_TR_SAIC_DEBUG *)(msg->SigP))->SAIC_flag = SAIC_flag;
5974
5975 // send message...
5976 os_send_sig(msg, L1C1_QUEUE);
5977 DEBUGMSG(status,NU_SEND_QUEUE_ERR)
5978 }
5979 #endif
5980 }
5981
5982
5983 /*-------------------------------------------------------*/
5984 /* l1_trace_new_toa() */
5985 /*-------------------------------------------------------*/
5986 /* Parameters : */
5987 /* Return : */
5988 /* */
5989 /*-------------------------------------------------------*/
5990 void l1_trace_new_toa(void)
5991 {
5992 #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
5993
5994 xSignalHeaderRec *msg;
5995
5996 if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_L1A_MESSAGES)
5997 {
5998 // Allocate DEBUG message.
5999 msg = os_alloc_sig(sizeof(T_TR_NEW_TOA));
6000 DEBUGMSG(status,NU_ALLOC_ERR)
6001 msg->SignalCode = TRACE_INFO;
6002
6003 ((T_TR_NEW_TOA *)(msg->SigP))->header = TRL1_NEW_TOA | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
6004 #if (TOA_ALGO == 2)
6005 ((T_TR_NEW_TOA *)(msg->SigP))->toa_shift = l1s.toa_var.toa_shift;
6006 #else
6007 ((T_TR_NEW_TOA *)(msg->SigP))->toa_shift = l1s.toa_shift;
6008 #endif
6009
6010 #if(TOA_ALGO == 2)
6011 ((T_TR_NEW_TOA *)(msg->SigP))->toa_frames_counter = trace_info.toa_trace_var.toa_frames_counter;
6012 ((T_TR_NEW_TOA *)(msg->SigP))->toa_accumul_counter = trace_info.toa_trace_var.toa_accumul_counter;
6013 ((T_TR_NEW_TOA *)(msg->SigP))->toa_accumul_value = trace_info.toa_trace_var.toa_accumul_value;
6014 #endif
6015
6016 // send message...
6017 os_send_sig(msg, L1C1_QUEUE);
6018 DEBUGMSG(status,NU_SEND_QUEUE_ERR)
6019 }
6020 #endif
6021 }
6022
6023 /*-------------------------------------------------------*/
6024 /* l1_trace_toa_not_updated() */
6025 /*-------------------------------------------------------*/
6026 /* Parameters : */
6027 /* Return : */
6028 /* TOA ERROR: TOA not updated */
6029 /*-------------------------------------------------------*/
6030 void l1_trace_toa_not_updated(void)
6031 {
6032 #if (TRACE_TYPE==1) || (TRACE_TYPE==4)
6033
6034 // !!!!!!!!!!!!!!!!!!!!!!!!
6035 // !!! should not occur !!!
6036 // !!!!!!!!!!!!!!!!!!!!!!!!
6037
6038 xSignalHeaderRec *msg;
6039
6040 if (trace_info.current_config->l1_dyn_trace & 1<<L1_DYN_TRACE_L1S_DEBUG)
6041 {
6042 // Allocate DEBUG message.
6043 msg = os_alloc_sig(sizeof(T_TR_TOA_NOT_UPDATED));
6044 DEBUGMSG(status,NU_ALLOC_ERR)
6045 msg->SignalCode = TRACE_INFO;
6046
6047 ((T_TR_TOA_NOT_UPDATED *)(msg->SigP))->header = TRL1_TOA_NOT_UPDATED | (l1s.actual_time.fn << TR_HEADER_FN_DELAY);
6048 #if (TOA_ALGO == 2)
6049 ((T_TR_TOA_NOT_UPDATED *)(msg->SigP))->toa_shift = l1s.toa_var.toa_shift;
6050 #else
6051 ((T_TR_TOA_NOT_UPDATED *)(msg->SigP))->toa_shift = l1s.toa_shift;
6052 #endif
6053 // send message...
6054 os_send_sig(msg, L1C1_QUEUE);
6055 DEBUGMSG(status,NU_SEND_QUEUE_ERR)
6056 }
6057 #endif
6058 }
6059
6060 ////////////////////////////////////////
6061 // Dynamic trace configuration change //
6062 ////////////////////////////////////////
6063
6064 /*-------------------------------------------------------*/
6065 /* l1_send_trace_version() */
6066 /*-------------------------------------------------------*/
6067 /* Parameters : */
6068 /* Return : */
6069 /* */
6070 /*-------------------------------------------------------*/
6071 void l1_send_trace_version()
6072 {
6073 #if (TRACE_TYPE == 1)
6074 char ptr[11];
6075 char nb_bytes_sent = 0;
6076
6077 ptr[0] = trace_info.l1_trace_user_id;
6078 ptr[1] = TRACE_CHECK_RESULT_OPCODE & 0xff;
6079 ptr[2] = (TRACE_CHECK_RESULT_OPCODE >> 8) & 0xff;
6080 ptr[3] = (TRACE_CHECK_RESULT_OPCODE >> 16) & 0xff;
6081 ptr[4] = (TRACE_CHECK_RESULT_OPCODE >> 24) & 0xff;
6082 ptr[5] = sizeof(T_TRACE_CELLS) & 0xff;
6083 ptr[6] = (sizeof(T_TRACE_CELLS) >> 8) & 0xff;
6084 ptr[7] = (sizeof(T_TRACE_CELLS) >> 16) & 0xff;
6085 ptr[8] = (sizeof(T_TRACE_CELLS) >> 24) & 0xff;
6086 ptr[9] = L1_TRACE_VERSION & 0xff;
6087 ptr[10] = (L1_TRACE_VERSION >> 8) & 0xff;
6088
6089 while( nb_bytes_sent < 11)
6090 nb_bytes_sent += SER_tr_WriteNBytes(SER_LAYER_1, (SYS_UWORD8 *)ptr + nb_bytes_sent, 11 - nb_bytes_sent );
6091
6092 #elif (TRACE_TYPE == 4)
6093 char *ptr;
6094
6095 if (rvt_mem_alloc(trace_info.l1_trace_user_id, sizeof(T_TRACE_VERSION), (T_RVT_BUFFER *) &ptr) == RVT_OK)
6096 {
6097 ((T_TRACE_VERSION *)ptr)->Opcode = TRACE_CHECK_RESULT_OPCODE;
6098 ((T_TRACE_VERSION *)ptr)->checksum = sizeof(T_TRACE_CELLS);
6099 ((T_TRACE_VERSION *)ptr)->version = L1_TRACE_VERSION;
6100
6101 L1_send_trace_no_cpy(ptr,sizeof(T_TRACE_VERSION));
6102 }
6103 #endif
6104 }
6105
6106 /*-------------------------------------------------------*/
6107 /* l1_trace_configuration() */
6108 /*-------------------------------------------------------*/
6109 /* Parameters : */
6110 /* Return : */
6111 /* */
6112 /*-------------------------------------------------------*/
6113 void l1_trace_configuration(T_RVT_BUFFER trace_msg, UINT16 trace_msg_size)
6114 {
6115 UWORD8 Opcode = trace_msg[0];
6116
6117 switch (Opcode)
6118 {
6119 case TRACE_CONFIG_OPCODE:
6120 {
6121 // Send message to L1A
6122 xSignalHeaderRec *msg;
6123
6124 // Allocate DEBUG message.
6125 msg = os_alloc_sig(sizeof(T_TRACE_CONFIG_CHANGE));
6126 DEBUGMSG(status,NU_ALLOC_ERR)
6127 msg->SignalCode = TRACE_CONFIG;
6128
6129 // NOTE: trace_msg isnt necessary 32-bit aligned !!!
6130
6131 // First UWORD32 is the classic L1 dynamic trace
6132 ((T_TRACE_CONFIG_CHANGE *)(msg->SigP))->trace_config = (trace_msg[1]) | (trace_msg[2] << 8) | (trace_msg[3] << 16) | (trace_msg[4] << 24);
6133
6134 // The eight following UWORD32 define the RTT cell configuration
6135 ((T_TRACE_CONFIG_CHANGE *)(msg->SigP))->rtt_cell_enable[0] = (trace_msg[5]) | (trace_msg[6] << 8) | (trace_msg[7] << 16) | (trace_msg[8] << 24);
6136 ((T_TRACE_CONFIG_CHANGE *)(msg->SigP))->rtt_cell_enable[1] = (trace_msg[9]) | (trace_msg[10] << 8) | (trace_msg[11] << 16) | (trace_msg[12] << 24);
6137 ((T_TRACE_CONFIG_CHANGE *)(msg->SigP))->rtt_cell_enable[2] = (trace_msg[13]) | (trace_msg[14] << 8) | (trace_msg[15] << 16) | (trace_msg[16] << 24);
6138 ((T_TRACE_CONFIG_CHANGE *)(msg->SigP))->rtt_cell_enable[3] = (trace_msg[17]) | (trace_msg[18] << 8) | (trace_msg[19] << 16) | (trace_msg[20] << 24);
6139 ((T_TRACE_CONFIG_CHANGE *)(msg->SigP))->rtt_cell_enable[4] = (trace_msg[21]) | (trace_msg[22] << 8) | (trace_msg[23] << 16) | (trace_msg[24] << 24);
6140 ((T_TRACE_CONFIG_CHANGE *)(msg->SigP))->rtt_cell_enable[5] = (trace_msg[25]) | (trace_msg[26] << 8) | (trace_msg[27] << 16) | (trace_msg[28] << 24);
6141 ((T_TRACE_CONFIG_CHANGE *)(msg->SigP))->rtt_cell_enable[6] = (trace_msg[29]) | (trace_msg[30] << 8) | (trace_msg[31] << 16) | (trace_msg[32] << 24);
6142 ((T_TRACE_CONFIG_CHANGE *)(msg->SigP))->rtt_cell_enable[7] = (trace_msg[33]) | (trace_msg[34] << 8) | (trace_msg[35] << 16) | (trace_msg[36] << 24);
6143
6144 // Last UWORD32 define the RTT event
6145 ((T_TRACE_CONFIG_CHANGE *)(msg->SigP))->rtt_event = (trace_msg[37]) | (trace_msg[38] << 8) | (trace_msg[39] << 16) | (trace_msg[40]);
6146
6147 // send message...
6148 os_send_sig(msg, L1C1_QUEUE);
6149 DEBUGMSG(status,NU_SEND_QUEUE_ERR)
6150 }
6151 break;
6152
6153 case TRACE_CHECKING_OPCODE:
6154 {
6155 l1_send_trace_version();
6156 }
6157 break;
6158 }
6159 }
6160 641
6161 /************************************ ASCII trace *********************************************************/ 642 /************************************ ASCII trace *********************************************************/
6162 643
6163 #else // L1_BINARY_TRACE = 0 644 #else // L1_BINARY_TRACE = 0
6164 645