| // Copyright (c) 2012 GCT Semiconductor, Inc. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #if !defined(GCTTYPE_H_20100310) |
| #define GCTTYPE_H_20100310 |
| |
| #include "WiMaxType.h" |
| |
| #if !defined(SDK_TYPEDEF) |
| #define SDK_TYPEDEF |
| #if !defined(__cplusplus) |
| typedef char bool; |
| #endif |
| typedef unsigned char u8; |
| typedef unsigned short u16; |
| typedef unsigned int u32; |
| typedef unsigned long long u64; |
| typedef signed char s8; |
| typedef signed short s16; |
| typedef int s32; |
| typedef long long s64; |
| #if 1 |
| typedef wchar_t uchar; |
| #else |
| typedef unsigned short uchar; |
| #endif |
| #endif |
| |
| #define GCT_API |
| #define INVALID_GHANDLE 0x000000000 |
| |
| typedef enum _GCT_API_RET |
| { |
| GCT_API_RET_FIRST_COMMON_ERROR = 0, |
| /// No errors |
| GCT_API_RET_SUCCESS, |
| /// Fail to obtain results |
| GCT_API_RET_FAILED, |
| /// Buffer size pass in parameter is too small. |
| GCT_API_RET_BUFFER_SIZE_TOO_SMALL, |
| /// Invalid privileges to execute the command |
| GCT_API_RET_PERMISSION_DENIED, |
| /// Device specified is invalid. |
| GCT_API_RET_INVALID_DEVICE, |
| /// Invalid Parameter Passed |
| GCT_API_RET_INVALID_PARAMETER, |
| /// Cannot perform the command mobile connection. |
| GCT_API_RET_ALREADY_CONNECTED, |
| /// Link is not connected, cannot obtain result. |
| GCT_API_RET_LINK_NOT_CONNECTED, |
| /// Connection to the network is prohibited |
| GCT_API_RET_NETWORK_PROHIBITED, |
| /// Device specified is missing because of just being removed! |
| GCT_API_RET_DEVICE_MISSING, |
| /// Profile specified is invalid. |
| GCT_API_RET_INVALID_PROFILE, |
| /// Connection to a roaming network is not allowed. |
| GCT_API_RET_ROAMING_NOT_ALLOWED, |
| /// Connection is already in progress |
| GCT_API_RET_CONNECTION_IN_PROGRESS, |
| /// Function not implemented |
| GCT_API_RET_NOT_IMPLEMENTED, |
| /// SDK is busy |
| GCT_API_RET_BUSY, |
| |
| /// last error code |
| GCT_API_RET_LAST_COMMON_ERROR |
| } GCT_API_RET, *PGCT_API_RET; |
| |
| typedef void * APIHAND; |
| |
| typedef struct GDEV_ID_S { |
| APIHAND apiHandle; |
| u8 deviceIndex; |
| |
| } GDEV_ID, *GDEV_ID_P; |
| |
| typedef enum _GCT_WIMAX_SDK_MODE |
| { |
| GCT_WIMAX_SDK_EMBEDDED_EAP_ENABLED = (1<<0), |
| GCT_WIMAX_SDK_OMA_DM_ENABLED = (1<<1), |
| GCT_WIMAX_SDK_MODE_MAX |
| |
| } GCT_WIMAX_SDK_MODE; |
| |
| typedef enum _GCT_WIMAX_API_OPEN_MODE |
| { |
| GCT_WIMAX_API_PRIVILEGE_READ_WRITE = (1<<0), /**< Read Write privilege access.(default) */ |
| GCT_WIMAX_API_PRIVILEGE_READ_ONLY = (1<<1), /**< Read Only privilege access. */ |
| |
| GCT_WIMAX_API_OPEN_MODE_NORMAL = (1<<2), |
| GCT_WIMAX_API_OPEN_MODE_ENG = (1<<3), |
| |
| GCT_WIMAX_API_OPEN_MODE_MAX |
| |
| } GCT_WIMAX_API_OPEN_MODE, *PGCT_WIMAX_API_OPEN_MODE; |
| |
| |
| typedef struct _GCT_WIMAX_API_PARAM { |
| char nonvolatile_dir[256]; |
| char log_path[256]; |
| int log_level; |
| |
| } GCT_WIMAX_API_PARAM; |
| |
| typedef enum _GCT_API_POWER_MODE |
| { |
| WiMAXPowerModeIdle, |
| WiMAXPowerModeSleep, |
| WiMAXPowerModeNormal, |
| |
| WiMAXPowerModeMaximum |
| |
| } GCT_API_POWER_MODE, *GCT_API_POWER_MODE_P; |
| |
| typedef struct _GCT_API_NEIGHBOR_LIST |
| { |
| UINT32 structureSize; /**< size of this structure. */ |
| UINT8 bsId[6]; /**< BS ID of the current serving BS as received from the network */ |
| UINT8 rssi; /**< RSSI value */ |
| UINT8 cinr; /**< CINR value */ |
| UINT8 preamble; /** preamble value */ |
| //UINT16 roundTripTime; /** round trip time from the base station measured in nanoseconds. */ |
| UINT32 frequency; |
| |
| } GCT_API_NEIGHBOR_LIST, *GCT_API_NEIGHBOR_LIST_P; |
| |
| typedef struct gct_harq_statistics_s |
| { |
| UINT32 NumDlHarqRetry[8]; |
| UINT32 NumUlHarqRetry[8]; |
| |
| } gct_harq_statistics_t; |
| |
| typedef struct gct_mcs_stats_s { |
| UINT8 ModulationFEC; |
| UINT8 RepetitionCode; |
| UINT8 IUC; |
| UINT8 Feature; |
| UINT8 NumBurst; |
| UINT8 NumBurstError; |
| UINT8 LenPDU; |
| UINT8 NumPDU; |
| |
| } gct_mcs_stats_t; |
| |
| typedef enum _GCT_API_EAP_TYPE |
| { |
| GCT_WIMAX_NO_EAP = 0, |
| GCT_WIMAX_EAP_TLS = 1, |
| GCT_WIMAX_EAP_TTLS_MD5 = 2, |
| GCT_WIMAX_EAP_TTLS_MSCHAPV2 = 3, |
| GCT_WIMAX_EAP_TTLS_CHAP = 4, |
| GCT_WIMAX_EAP_AKA = 5 |
| |
| } GCT_API_EAP_TYPE; |
| #define GCT_API_IS_EAP_TLS(t) ((t)>=GCT_WIMAX_EAP_TLS && (t)<=GCT_WIMAX_EAP_TTLS_CHAP) |
| #define GCT_API_IS_VALID_EAP(t) ((t)>=GCT_WIMAX_EAP_TLS && (t)<=GCT_WIMAX_EAP_AKA) |
| |
| typedef struct _GCT_API_EAP_PARAM |
| { |
| #define WIMAX_EAP_STR_LEN 256 |
| #define WIMAX_EAP_FILE_LEN 256 |
| #define WIMAX_EAP_DECO_LEN 128 /*decoration*/ |
| GCT_API_EAP_TYPE type; |
| |
| UINT16 fragSize; |
| UINT8 useDelimiter; |
| UINT8 devCertNULL; |
| UINT8 caCertNULL; |
| UINT8 disableResumption; |
| UINT8 cr801Enable; |
| UINT8 disableSessionTicket; |
| |
| UINT8 useNvramParam; |
| UINT8 userId[WIMAX_EAP_STR_LEN]; |
| UINT8 userIdPwd[WIMAX_EAP_STR_LEN]; |
| UINT8 anonymousId[WIMAX_EAP_STR_LEN]; |
| UINT8 privateKeyPwd[WIMAX_EAP_STR_LEN]; |
| |
| UINT8 decoration[WIMAX_EAP_DECO_LEN]; |
| |
| #define CACERT_NUM 10 |
| |
| UINT8 logEnable; |
| } GCT_API_EAP_PARAM, *GCT_API_EAP_PARAM_P; |
| |
| typedef struct _GCT_API_ODM_PARAM |
| { |
| UINT8 useODM; |
| |
| } GCT_API_ODM_PARAM, *GCT_API_ODM_PARAM_P; |
| |
| typedef struct _GCT_API_CERT_INFO |
| { |
| #define WIMAX_CERT_STR_LEN 256 |
| UINT32 source; |
| UINT8 cert_type[WIMAX_CERT_STR_LEN]; |
| UINT8 subject_cn[WIMAX_CERT_STR_LEN]; |
| UINT8 issuer_cn[WIMAX_CERT_STR_LEN]; |
| UINT8 expire_date[WIMAX_CERT_STR_LEN]; |
| |
| } GCT_API_CERT_INFO, *GCT_API_CERT_INFO_P; |
| |
| typedef struct _GCT_API_RF_INFORM { |
| INT32 nPERReceiveCount; |
| INT32 nPERErrorCount; |
| UINT8 bsId[6]; |
| UINT8 ULPermBase; |
| UINT8 DLPermBase; |
| UINT8 CurrentPreambleIndex; |
| UINT8 PreviousPreambleIndex; |
| UINT16 HandOverCount; |
| UINT16 HandOverFailCount; |
| UINT16 ResyncCount; |
| UINT16 HoSignalLatency; |
| UINT8 CINR; |
| UINT8 CINR2; |
| UINT8 RSSI; |
| UINT8 RSSI2; |
| UINT16 PER; |
| UINT8 PowerControlMode; |
| UINT8 TxPower; |
| UINT8 TxPowerMax; |
| UINT8 ULBurstDataFECScheme; |
| UINT8 DLBurstDataFECScheme; |
| UINT8 ULBurstDataUIUC; |
| UINT8 DLBurstDataDIUC; |
| UINT32 Frequency; |
| |
| } GCT_API_RF_INFORM, *GCT_API_RF_INFORM_P; |
| |
| typedef enum _GCT_API_SCAN_TYPE { |
| GCT_API_SCAN_WIDE, |
| GCT_API_SCAN_ALL_SUBSCRIPTIONS, |
| GCT_API_SCAN_CURR_SUBSCRIPTION |
| |
| } GCT_API_SCAN_TYPE, *GCT_API_SCAN_TYPE_P; |
| |
| typedef enum _GCT_API_NOTI_CATEGORY { |
| GCT_API_ERROR_NOTI_EAP, |
| GCT_API_NOTI_EAP, |
| GCT_API_NOTI_ODM_NOTI, |
| GCT_API_NOTI_ODM_ERROR |
| |
| } GCT_API_NOTI_CATEGORY, *GCT_API_NOTI_CATEGORY_P; |
| |
| typedef enum _GCT_API_ODM_NOTI_TYPE_P { |
| GCT_API_ODM_NOTI_EXEC_REGISTRATION_PAGE_OPEN, |
| GCT_API_ODM_NOTI_CHANGE_ACTIVATED, |
| GCT_API_ODM_NOTI_UNKNOWN_SERVER_REALM // for CR1074 |
| |
| } GCT_API_ODM_NOTI_TYPE, *GCT_API_ODM_NOTI_TYPE_P; |
| |
| typedef enum _GCT_API_NOTI_TYPE { |
| GCT_API_NOTI_TYPE_CODE, |
| GCT_API_NOTI_TYPE_TEXT |
| |
| } GCT_API_NOTI_TYPE, *GCT_API_NOTI_TYPE_P; |
| |
| typedef enum _IMAGE_TYPE { |
| IMG_KERNEL = 0, |
| IMG_FS = 1, |
| IMG_CFG = 2, |
| IMG_CFG_RAM = 3, |
| IMG_FS2 = 4, |
| IMG_CLR_CFG = 5, |
| IMG_EAP_PARAM = 6, |
| IMG_BL_EEPROM = 7, |
| IMG_BL_FLASH = 8, |
| |
| IMG_OMA_XML = 0x100, |
| IMG_DEV_CERT = 0x101, |
| IMG_CERT1_U = 0x102, |
| IMG_CERT1_L = 0x103, |
| IMG_CERT2_U = 0x104, |
| IMG_CERT2_L = 0x105, |
| IMG_CERT_BIG = 0x106, |
| |
| IMG_END |
| |
| } IMAGE_TYPE; |
| |
| typedef enum _CAPABILITY_BIT { |
| CAPABILITY_ENC_XML = (1<<0), |
| CAPABILITY_E_EAP_TLS = (1<<1), |
| CAPABILITY_ODM = (1<<2), |
| CAPABILITY_E_EAP_AKA = (1<<3), |
| CAPABILITY_CAPL_INFO = (1<<4), |
| |
| CAPABILITY_END |
| |
| } CAPABILITY_BIT, *CAPABILITY_BIT_P; |
| |
| #if defined(CONFIG_ENABLE_SERVICE_FLOW) |
| /*---------------------------------------------------------------------- |
| * |
| * Service Flow Management |
| * |
| *----------------------------------------------------------------------*/ |
| |
| #include <netinet/in.h> |
| |
| #define WIMAX_MAX_SERVICE_FLOW 16 |
| #define WIMAX_MAX_RULES 16 /* MAX rules per SF */ |
| #define MAX_SERVICE_CLASS_NAME 128 |
| |
| |
| /* UL Grant Scheduling Type Parameter */ |
| #define UL_SCHED_TYPE_RESERVED 0 |
| #define UL_SCHED_TYPE_UNDEF 1 |
| #define UL_SCHED_TYPE_BE 2 |
| #define UL_SCHED_TYPE_nrtPS 3 |
| #define UL_SCHED_TYPE_rtPS 4 |
| #define UL_SCHED_TYPE_ertPS 5 |
| #define UL_SCHED_TYPE_UGS 6 |
| |
| |
| /* Type of Data Delivery Services parameter */ |
| #define DATA_SERVICE_UGS 0 |
| #define DATA_SERVICE_RT_VR 1 |
| #define DATA_SERVICE_NRT_VR 2 |
| #define DATA_SERVICE_BE 3 |
| #define DATA_SERVICE_ERT_VR 4 |
| |
| #define MAX_PHSS 128 |
| |
| struct wimax_sf_event_param { |
| uint8_t cc; /* confirm code */ |
| uint8_t ms_initiated; /* MS initiated DSx */ |
| uint32_t sfid; /* SFID SF event took place on */ |
| int8_t clfr_action; /* classification rule DSC action */ |
| uint16_t PacketClassificationRuleIndex; /* changed classfication rule index */ |
| int8_t phs_action; /* phs rule changed DSC action */ |
| uint16_t PHSI; /* changed PHSI */ |
| }; |
| |
| typedef enum _WIMAX_SF_EVENT_TYPE { |
| /* Service flow-related events */ |
| WIMAX_EVT_SERVICE_FLOW_ADDED, |
| WIMAX_EVT_SERVICE_FLOW_CHANGED, |
| WIMAX_EVT_SERVICE_FLOW_DELETED, |
| WIMAX_EVT_CID_UPDATE, |
| } WIMAX_SF_EVENT_TYPE; |
| |
| typedef struct _wimax_sf_event { |
| WIMAX_SF_EVENT_TYPE code; |
| struct wimax_sf_event_param sf; |
| } __attribute__((packed)) WIMAX_SF_EVENT, *WIMAX_SF_EVENT_P; |
| |
| typedef enum { |
| WIMAX_SF_SUCCESS = 0, |
| WIMAX_SF_OTHER, |
| WIMAX_SF_UNRECOGNIZED_CONF_SETTING, |
| WIMAX_SF_TEMPORARY, // reject-resource |
| WIMAX_SF_PERMANANT, // reject-admin |
| WIMAX_SF_NOT_OWNER, |
| WIMAX_SF_NOT_FOUND, |
| WIMAX_SF_EXISTS, |
| WIMAX_SF_REQIRED_PARAM_NOT_PRESENT, |
| WIMAX_SF_HEADER_SUPRESSION, |
| WIMAX_SF_UNKNOWN_TRANSACTION_ID, |
| WIMAX_SF_AUTH_FAILURE, |
| WIMAX_SF_ADD_ABORTED, |
| WIMAX_SF_EXCEEDED_DYNAMIC_SERVICE_LIMIT, |
| WIMAX_SF_NOT_AUTHORIZED_FOR_THE_REQUESTED_SAID, |
| WIMAX_SF_FAIL_TO_ESTABLISH_THE_REQUESTED_SA, |
| WIMAX_SF_NOT_SUPPORTED_PARAMETER, |
| WIMAX_SF_NOT_SUPPORTED_PARAMETER_VALUE |
| } WIMAX_SF_CC; |
| |
| |
| typedef enum { |
| DSC_ADD_CLASSIFIER = 0, |
| DSC_REPLACE_CLASSIFIER, |
| DSC_DELETE_CLASSIFIER, |
| DSC_NOP_CLASSIFIER, |
| } WIMAX_CLFR_DSC_ACTION; |
| |
| |
| typedef enum { |
| DSC_ADD_PHS = 0, |
| DSC_SET_PHS, //TODO not tested |
| DSC_DELETE_PHS, |
| DSC_DELETE_ALL_PHS, //TODO not supported |
| DSC_NOP_PHS, |
| } WIMAX_PHS_DSC_ACTION; |
| |
| |
| struct ipv4_addr { |
| struct in_addr address; |
| struct in_addr mask; |
| } __attribute__((packed)); |
| |
| |
| struct ipv6_addr { |
| struct in6_addr address; |
| struct in6_addr mask; |
| } __attribute__((packed)); |
| |
| typedef struct wimax_classification_rule { |
| uint32_t valid; |
| |
| union { |
| uint16_t all; |
| struct { |
| uint16_t reserived:1; |
| uint16_t IPTypeOfService:1; |
| uint16_t Protocol:1; |
| uint16_t IPMaskedSrcAddress:1; |
| uint16_t IPMaskedDstAddress:1; |
| uint16_t ProtocolSrcPortRange:1; |
| uint16_t ProtocolDstPortRange:1; |
| uint16_t DstMacAddr:1; |
| uint16_t SrcMacAddr:1; |
| uint16_t Ethertype:1; |
| uint16_t IEEE802_1DUserPriority:1; |
| uint16_t IEEE802_1QVLANID:1; |
| uint16_t Reserved:5; |
| } fields; |
| } mask; |
| |
| /* Packet Classification Rule */ |
| uint8_t ClassifierRulePriority; |
| struct { |
| uint8_t low; |
| uint8_t high; |
| uint8_t mask; |
| } __attribute__((packed)) IPTypeOfService; |
| |
| uint8_t Protocol; |
| |
| struct ipv4_addr IPv4MaskedSourceAddress; |
| struct ipv6_addr IPv6MaskedSourceAddress; |
| struct ipv4_addr IPv4MaskedDestAddress; |
| struct ipv6_addr IPv6MaskedDestAddress; |
| |
| struct { |
| uint16_t low; |
| uint16_t high; |
| } __attribute__((packed)) ProtocolSourcePort, ProtocolDestPort; |
| |
| struct { |
| uint8_t addr[6]; |
| uint8_t mask[6]; |
| } __attribute__((packed)) EthernetDestMACAddress, EthernetSourceMACAddress; |
| |
| struct { |
| uint8_t type; |
| uint8_t eprot1; |
| uint8_t eprot2; |
| } __attribute__((packed)) EtherType; |
| |
| struct { |
| uint8_t low; |
| uint8_t high; |
| } __attribute__((packed)) IEEE802_1D_UserPriority; |
| |
| uint16_t IEEE802_1Q_VLANID; |
| |
| uint8_t AssociatedPHSI; |
| uint16_t PacketClassifierRuleIndex; |
| uint8_t IPv6FlowLabel[3]; |
| uint8_t ContextID; |
| } WIMAX_CLFR_RULE, *WIMAX_CLFR_RULE_P; |
| |
| |
| typedef struct wimax_phs_rule { |
| uint32_t valid; |
| struct wimax_phs_rule *next; /* not used */ |
| uint8_t state; |
| uint8_t PHSI; |
| uint8_t PHSF[MAX_PHSS]; |
| uint8_t PHSM[(MAX_PHSS + 7) >> 3]; |
| uint8_t PHSS; |
| uint8_t PHSV; |
| } WIMAX_PHS_RULE, *WIMAX_PHS_RULE_P; |
| |
| |
| typedef struct wimax_sf_param { |
| uint8_t DL; |
| /* TLV - 11.13 */ |
| uint32_t SFID; |
| uint16_t CID; |
| uint8_t ServiceClassName[MAX_SERVICE_CLASS_NAME]; |
| uint8_t MBSService; |
| |
| uint8_t QosParamSetType; /* Admitted, Active, Provisioned */ |
| uint8_t TrafficPriority; /* 6 */ |
| uint32_t MaxSustainedTrafficRate; |
| uint32_t MaxTrafficBurst; |
| uint32_t MinReservedTrafficRate; |
| uint32_t MinTolerableRate; /* 10 */ |
| uint8_t ULGrantSchedulingType; /* 11 */ |
| uint8_t RequestTransmissionPolicy; /* 12 */ |
| uint32_t ToleratedJitter; /* 13 */ |
| uint32_t MaxLatency; /* 14 */ |
| |
| uint8_t FixedLengthSDUIndicator; /* 15 */ |
| uint8_t SDUSize; /* 16 */ |
| uint16_t TargetSAID; /* 17 */ |
| |
| uint8_t ARQEnable; /* 18 */ |
| uint16_t ARQWindowSize; /* 19 */ |
| uint16_t ARQTransmitterDelay; /* 20 */ |
| uint16_t ARQReceiverDelay; /* 21 */ |
| uint16_t ARQBlockLifeTime; /* 22 */ |
| uint16_t ARQSyncLossTimeout; /* 23 */ |
| uint8_t ARQDeliverInOrder; /* 24 */ |
| uint16_t ARQRxPurgeTimeout; /* 25 */ |
| uint16_t ARQBlockSize; /* 26 */ |
| uint8_t ReceiverARQAckProcessingTime; /* 27 */ |
| |
| uint8_t CSSpecification; /* 28 */ |
| |
| uint8_t TypeOfDataDeliveryServices; // 29 |
| uint16_t SDUInterArrivalInterval; // 30 |
| uint16_t TimeBase; // 31 |
| uint8_t PagingPreference; // 32 |
| uint8_t MBSZoneID[8]; // 33 |
| uint8_t TrafficPreferenceIndication; // 34 |
| uint8_t GlobalServiceClassName[6]; // 35 |
| uint8_t SNFeedbackEnabled; // 37 |
| uint8_t FSNSize; // 38 |
| uint8_t Num_CIDAllocForActiveBSs; |
| uint16_t CIDAllocForActiveBSs[8]; // 39 ?? |
| uint16_t UnsolicitedGrantInterval; // 40 |
| uint16_t UnsolicitedPollingInterval; // 41 |
| uint8_t PDUSNExtendedSubheaderForHARQReordering; // 42 |
| uint8_t Num_MBSContentsIDs; // 43 |
| uint16_t MBSContentsIDs[8]; // 43 |
| uint8_t HARQServiceFlows; // 44 |
| uint8_t AuthorizationToken; // 45 |
| uint8_t Num_HARQChannelMapping; // 46 |
| uint8_t HARQChannelMapping[16]; // 46 |
| } WIMAX_SF_PARAM, *WIMAX_SF_PARAM_P; |
| |
| typedef union wimax_sf_stats { |
| struct { |
| uint32_t sdu_packets; |
| uint32_t sdu_packets_dropped; |
| uint32_t sdu_bytes; |
| uint32_t sdu_bytes_dropped; |
| uint32_t pdu_packets; |
| uint32_t pdu_bytes; |
| |
| uint32_t bw_req; |
| uint32_t gmsh; |
| |
| uint32_t arq_blocks; |
| uint32_t arq_blocks_retry; |
| uint16_t arq_discard; |
| uint16_t arq_reset; |
| uint16_t arq_sync_loss; |
| } ul; |
| struct { |
| uint32_t sdu_packets; |
| uint32_t sdu_packets_dropped; |
| uint32_t sdu_bytes; |
| uint32_t sdu_bytes_dropped; |
| uint32_t pdu_packets; |
| uint32_t pdu_bytes; |
| |
| uint32_t arq_blocks; |
| uint32_t arq_blocks_retry; |
| uint16_t arq_discard; |
| uint16_t arq_reset; |
| uint16_t arq_sync_loss; |
| } dl; |
| } WIMAX_SF_STATS, *WIMAX_SF_STATS_P; |
| |
| typedef struct wimax_service_flow { |
| uint8_t valid; |
| struct wimax_sf_param param; |
| struct wimax_classification_rule classification_rule[WIMAX_MAX_RULES]; |
| struct wimax_phs_rule phs_rule[WIMAX_MAX_RULES]; |
| union wimax_sf_stats stats; |
| } WIMAX_SERVICE_FLOW, *WIMAX_SERVICE_FLOW_P; |
| |
| |
| extern const struct wimax_sf_param sf_param_init; |
| extern const struct wimax_classification_rule classifier_rule_init; |
| extern const struct wimax_phs_rule phs_rule_init; |
| |
| #endif // CONFIG_ENABLE_SERVICE_FLOW |
| |
| typedef enum _GCT_API_CMD_MAC_STATE_TYPE { |
| GCT_API_CMD_MAC_STATE_ENTER_SLEEP_MODE, |
| GCT_API_CMD_MAC_STATE_EXIT_SLEEP_MODE, |
| GCT_API_CMD_MAC_STATE_ENTER_IDLE_MODE, |
| GCT_API_CMD_MAC_STATE_EXIT_IDLE_MODE |
| } GCT_API_CMD_MAC_STATE_TYPE, *GCT_API_CMD_MAC_STATE_TYPE_P; |
| |
| typedef enum _FEC_MOD { |
| OFDMA_FEC_MOD_QPSK_CC_H = 0, |
| OFDMA_FEC_MOD_QPSK_CC_3Q = 1, |
| OFDMA_FEC_MOD_QAM16_CC_H = 2, |
| OFDMA_FEC_MOD_QAM16_CC_3Q = 3, |
| OFDMA_FEC_MOD_QAM64_CC_H = 4, |
| OFDMA_FEC_MOD_QAM64_CC_2O3 = 5, |
| OFDMA_FEC_MOD_QAM64_CC_3Q = 6, |
| OFDMA_FEC_MOD_QPSK_BTC_H = 7, |
| OFDMA_FEC_MOD_QPSK_BTC_3Q = 8, |
| OFDMA_FEC_MOD_QAM16_BTC_3O5 = 9, |
| OFDMA_FEC_MOD_QAM16_BTC_4O5 = 10, |
| OFDMA_FEC_MOD_QAM64_BTC_5O8 = 11, |
| OFDMA_FEC_MOD_QAM64_BTC_4O5 = 12, |
| OFDMA_FEC_MOD_QPSK_CTC_H = 13, |
| OFDMA_FEC_MOD_RESERVED14 = 14, |
| OFDMA_FEC_MOD_QPSK_CTC_3Q = 15, |
| OFDMA_FEC_MOD_QAM16_CTC_H = 16, |
| OFDMA_FEC_MOD_QAM16_CTC_3Q = 17, |
| OFDMA_FEC_MOD_QAM64_CTC_H = 18, |
| OFDMA_FEC_MOD_QAM64_CTC_2O3 = 19, |
| OFDMA_FEC_MOD_QAM64_CTC_3Q = 20, |
| OFDMA_FEC_MOD_QAM64_CTC_5O6 = 21, |
| OFDMA_FEC_MOD_QPSK_ZTCC_H = 22, |
| OFDMA_FEC_MOD_QPSK_ZTCC_3Q = 23, |
| OFDMA_FEC_MOD_QAM16_ZTCC_H = 24, |
| OFDMA_FEC_MOD_QAM16_ZTCC_3Q = 25, |
| OFDMA_FEC_MOD_QAM64_ZTCC_H = 26, |
| OFDMA_FEC_MOD_QAM64_ZTCC_2O3 = 27, |
| OFDMA_FEC_MOD_QAM64_ZTCC_3Q = 28, |
| OFDMA_FEC_MOD_QPSK_SDPC_H = 29, |
| OFDMA_FEC_MOD_QPSK_SDPC_2O3_A_CODE = 30, |
| OFDMA_FEC_MOD_QPSK_LDPC_3Q_A_CODE = 31, |
| OFDMA_FEC_MOD_QAM16_LDPC_H = 32, |
| OFDMA_FEC_MOD_QAM16_LDPC_2O3_A_CODE = 33, |
| OFDMA_FEC_MOD_QAM16_LDPC_3Q_A_CODE = 34, |
| OFDMA_FEC_MOD_QAM64_LDPC_H = 35, |
| OFDMA_FEC_MOD_QAM64_LDPC_2O3_A_CODE = 36, |
| OFDMA_FEC_MOD_QAM64_LDPC_3Q_A_CODE = 37, |
| OFDMA_FEC_MOD_QPSK_LDPC_2O3_B_CODE = 38, |
| OFDMA_FEC_MOD_QPSK_LDPC_3Q_B_CODE = 39, |
| OFDMA_FEC_MOD_QAM16_LDPC_2O3_B_CODE = 40, |
| OFDMA_FEC_MOD_QAM16_LDPC_3Q_B_CODE = 41, |
| OFDMA_FEC_MOD_QAM64_LDPC_2O3_B_CODE = 42, |
| OFDMA_FEC_MOD_QAM64_LDPC_3Q_B_CODE = 43, |
| OFDMA_FEC_MOD_QPSK_CC_OI_H = 44, |
| OFDMA_FEC_MOD_QPSK_CC_OI_3Q = 45, |
| OFDMA_FEC_MOD_QAM16_CC_OI_H = 46, |
| OFDMA_FEC_MOD_QAM16_CC_OI_3Q = 47, |
| OFDMA_FEC_MOD_QAM64_CC_OI_2O3 = 48, |
| OFDMA_FEC_MOD_QAM64_CC_OI_3Q = 49, |
| OFDMA_FEC_MOD_QPSK_LDPC_5O6 = 50, |
| OFDMA_FEC_MOD_QAM16_LDPC_5O6 = 51, |
| OFDMA_FEC_MOD_QAM64_LDPC_5O6 = 52, |
| OFDMA_FEC_MODE_CNT, |
| } FEC_MOD; |
| |
| typedef enum _REPETITION_CODE |
| { |
| REPETITION_CODING_NOT_SPECIFIED = 0, |
| NO_REPETITION_CODING = 1, |
| REPETITION_CODING_OF_2_USED = 2, |
| REPETITION_CODING_OF_4_USED = 3, |
| REPETITION_CODING_OF_6_USED = 4, |
| REPETITION_CODING_CNT, |
| } REPETITION_CODE; |
| |
| typedef enum _MIMO_TYPE |
| { |
| MINO_TYPE_NOT_SPEC = 0, |
| MINO_TYPE2_ANT_STC_MATRIX_A = 1, |
| MINO_TYPE2_ANT_STC_MATRIX_B_VC = 2, |
| /* |
| MINO_TYPE2_ANT_STC_MATRIX_B_HC = 3, |
| MINO_TYPE4_ANT_STC_MATRIX_A = 4, |
| MINO_TYPE4_ANT_STC_MATRIX_B_VC = 5, |
| MINO_TYPE4_ANT_STC_MATRIX_B_HC = 6, |
| MINO_TYPE4_ANT_STC_MATRIX_C_VC = 7, |
| MINO_TYPE4_ANT_STC_MATRIX_C_HC = 8, |
| MINO_TYPE3_ANT_STC_MATRIX_A = 9, |
| MINO_TYPE3_ANT_STC_MATRIX_B = 10, |
| MINO_TYPE3_ANT_STC_MATRIX_C_VC = 11, |
| MINO_TYPE3_ANT_STC_MATRIX_C_HC = 12, |
| MIMO_NOT_USD = 13, |
| */ |
| MIMO_TYPE_CNT, |
| } MIMO_TYPE; |
| |
| typedef struct _GCT_API_MAC_PHY_MAC_BASIC { |
| u32 frame_number; |
| u32 fch; |
| u16 ttg; |
| u16 rtg; |
| u8 num_dl_symbol; |
| u8 num_ul_symbol; |
| u8 current_pi; /*PreambleIndex*/ |
| u8 previous_pi; /*PreambleIndex*/ |
| u8 ul_perm_base; |
| u8 mac_state; |
| u8 bsid[6]; |
| s32 ul_time; |
| u32 frequency; |
| u16 bandwidth; |
| u16 pad; // padding |
| u32 time_active; |
| u32 time_sleep; |
| u32 time_idle; |
| u16 basic_cid; |
| u16 primary_cid; |
| } GCT_API_MAC_PHY_MAC_BASIC, *GCT_API_MAC_PHY_MAC_BASIC_P; |
| |
| typedef struct _GCT_API_MAC_PHY_MCS { |
| struct struct_mac_phy_mcs_s { |
| u32 num_burst; |
| u32 num_burst_error; |
| u32 len_pdu; |
| u32 num_pdu; |
| } dl[OFDMA_FEC_MODE_CNT][REPETITION_CODING_CNT][MIMO_TYPE_CNT], ul[OFDMA_FEC_MODE_CNT][REPETITION_CODING_CNT][MIMO_TYPE_CNT]; |
| |
| bool dl_used[OFDMA_FEC_MODE_CNT][REPETITION_CODING_CNT][MIMO_TYPE_CNT]; |
| bool ul_used[OFDMA_FEC_MODE_CNT][REPETITION_CODING_CNT][MIMO_TYPE_CNT]; |
| } GCT_API_MAC_PHY_MCS, *GCT_API_MAC_PHY_MCS_P; |
| |
| typedef struct _GCT_API_MAC_PHY_CINR_RSSI { |
| s8 cinr_mean; |
| s8 cinr_std_dev; |
| s8 rssi_mean; |
| s8 rssi_std_dev; |
| s8 cinr_a_mean; |
| s8 cinr_b_mean; |
| s8 cinr_main; |
| s8 cinr_diversity; |
| s8 rssi_main; |
| s8 rssi_diversity; |
| s8 preamble_cinr_reuse3; |
| s8 preamble_cinr_reuse1; |
| } GCT_API_MAC_PHY_CINR_RSSI, *GCT_API_MAC_PHY_CINR_RSSI_P; |
| |
| typedef enum _FUMO_RESULT { |
| FUMO_SUCCESSFUL = 200, /*The Request has Succeeded*/ |
| FUMO_SUCCESSFUL_VENDOR_SPEC = 250, /*250 -299 Vendor Specified Successful Operation |
| with Vendor Specified ResultCode*/ |
| FUMO_MNGMT_CLIENT_ERR = 400, /*Management Client error . |
| based on User or Device behavior*/ |
| FUMO_USER_CANCELLED = 401, /*User chose not to accept the operation when prompted*/ |
| FUMO_CORRUPTED_FW_UPDATE = 402, /*Corrupted firmware update package, |
| did not store correctly.*/ |
| FUMO_DEVICE_MISMATCH = 403, /*Firmware Update Package. Device Mismatch*/ |
| FUMO_PKG_VALIDATION_ERR = 404, /*Package Validation Failure to positively validate |
| digital signature of firmware update package*/ |
| FUMO_PKG_NOT_ACCEPTABLE_FW = 405, /*Firmware Update Package is Not Acceptable*/ |
| FUMO_ALTERNATE_DL_AUTH_ERR = 406, /*Authentication was Required but Authentication |
| Failure was encountered when downloading Firmware Update Package*/ |
| FUMO_ALTERNATE_DL_REQ_TIMEOUT = 407, /*Client has encountered a time-out |
| when downloading Firmware Update Package*/ |
| FUMO_NOT_IMPLEMENTED = 408, /*The device does not support the requested operation.*/ |
| FUMO_UNDEFINED_ERR = 409, /*Indicates failure not defined by any other error code*/ |
| FUMO_FW_UPDATE_FAILED = 410, /*Firmware Update operation failed in device*/ |
| FUMO_MALFORMED_OR_BAD_URL = 411, /*The URL provided for alternate download is bad*/ |
| FUMO_ALT_DL_SERV_UNAVAILABLE = 412, /*The Alternate Download Server is |
| Unavailable or Does not Respond*/ |
| FUMO_CLIENT_ERR = 450, /*450-499: Client Error encountered for Operation with |
| Vendor Specified ResultCode*/ |
| FUMO_ALT_DL_SERV_ERR = 500, /*Alternate Download Server Error Encountered*/ |
| FUMO_DL_OUT_OF_MEM = 501, /*Download fails due to device is out of memory |
| The download fails due insufficient memory in the device |
| to save the firmware update package.*/ |
| FUMO_UPDATE_OUT_OF_MEM = 502, /*Firmware update fails due to device out of memory |
| The update fails because there isn't sufficient memory to update the device.*/ |
| FUMO_DL_NETWORK_ERR = 503, /*Download fails due to network issues |
| The download fails due to network/transport level errors*/ |
| FUMO_ALT_DL_SERV_ERR_VENDOR_SPEC = 550, /*550-599: Alternate Download Server Error. |
| Vendor Specified |
| Alternate Download Server Error encountered for Operation |
| with Vendor Specified ResultCode*/ |
| |
| FUMO_RESULT_END |
| } FUMO_RESULT; |
| |
| #define GAPI_LOG_LEVEL_IS_FILE(level) ((level)>4) |
| #define GAPI_LOG_FLUSH_LEVEL 10 |
| |
| typedef void (*GIndRcvHCIPacket) (GDEV_ID_P pID, char *szBuf, int nBufSize); |
| typedef void (*GIndPowerModeChange) (GDEV_ID_P pID, GCT_API_POWER_MODE nPowerMode); |
| typedef void (*GIndDeviceStatusUpdate)(GDEV_ID_P pID, |
| WIMAX_API_DEVICE_STATUS deviceStatus, |
| WIMAX_API_STATUS_REASON statusReason, |
| WIMAX_API_CONNECTION_PROGRESS_INFO connectionProgressInfo); |
| typedef void (*GIndDeviceInsertRemove)(GDEV_ID_P pID, BOOL cardPresence); |
| typedef void (*GIndControlPowerManagement)(GDEV_ID_P pID, WIMAX_API_RF_STATE powerState); |
| typedef void (*GIndConnectToNetwork) (GDEV_ID_P pID, |
| WIMAX_API_NETWORK_CONNECTION_RESP networkConnectionResponse); |
| typedef void (*GIndDisconnectFromNetwork) (GDEV_ID_P pID, |
| WIMAX_API_NETWORK_CONNECTION_RESP networkDisconnectResponse); |
| typedef void (*GIndNetworkSearchWideScan) (GDEV_ID_P pID, WIMAX_API_NSP_INFO_P pNspList, |
| UINT32 listSize); |
| typedef void (*GIndProvisioningOperation) (GDEV_ID_P pID, |
| WIMAX_API_PROV_OPERATION provisioningOperation, |
| WIMAX_API_CONTACT_TYPE contactType); |
| typedef void (*GIndPackageUpdate) (GDEV_ID_P pID, WIMAX_API_PACK_UPDATE packageUpdate); |
| typedef void (*GIndNotification) (GDEV_ID_P pID, GCT_API_NOTI_CATEGORY nCategory, |
| GCT_API_NOTI_TYPE nType, int nBufSize, char *szBuf); |
| |
| #if defined(CONFIG_ENABLE_SERVICE_FLOW) |
| typedef void (*GIndNotiServiceFlow)(GDEV_ID_P pID, WIMAX_SF_EVENT_P pSfEvent); |
| #endif // CONFIG_ENABLE_SERVICE_FLOW |
| #endif |