diff --git a/htc/htc.c b/htc/htc.c index f282c02813..2388f7c185 100644 --- a/htc/htc.c +++ b/htc/htc.c @@ -27,9 +27,9 @@ #include "htc_debug.h" #include "htc_internal.h" +#include #include /* qdf_nbuf_t */ #include /* qdf_print */ -#include #ifdef DEBUG static ATH_DEBUG_MASK_DESCRIPTION g_htc_debug_description[] = { @@ -77,9 +77,9 @@ static HTC_PACKET *build_htc_tx_ctrl_packet(qdf_device_t osdev) if (NULL == pPacket) { break; } - A_MEMZERO(pPacket, sizeof(HTC_PACKET)); - netbuf = qdf_nbuf_alloc(osdev, - HTC_CONTROL_BUFFER_SIZE, 20, 4, true); + qdf_mem_zero(pPacket, sizeof(HTC_PACKET)); + netbuf = qdf_nbuf_alloc(osdev, HTC_CONTROL_BUFFER_SIZE, + 20, 4, true); if (NULL == netbuf) { qdf_mem_free(pPacket); pPacket = NULL; @@ -258,7 +258,7 @@ HTC_HANDLE htc_create(void *ol_sc, HTC_INIT_INFO *pInfo, qdf_device_t osdev, return NULL; } - A_MEMZERO(target, sizeof(HTC_TARGET)); + qdf_mem_zero(target, sizeof(HTC_TARGET)); htc_runtime_pm_init(target); qdf_spinlock_create(&target->HTCLock); @@ -267,7 +267,8 @@ HTC_HANDLE htc_create(void *ol_sc, HTC_INIT_INFO *pInfo, qdf_device_t osdev, qdf_spinlock_create(&target->HTCCreditLock); do { - A_MEMCPY(&target->HTCInitInfo, pInfo, sizeof(HTC_INIT_INFO)); + qdf_mem_copy(&target->HTCInitInfo, pInfo, + sizeof(HTC_INIT_INFO)); target->host_handle = pInfo->pContext; target->osdev = osdev; target->con_mode = con_mode; @@ -280,7 +281,7 @@ HTC_HANDLE htc_create(void *ol_sc, HTC_INIT_INFO *pInfo, qdf_device_t osdev, HTC_PACKET *pPacket = (HTC_PACKET *) qdf_mem_malloc(sizeof(HTC_PACKET)); if (pPacket != NULL) { - A_MEMZERO(pPacket, sizeof(HTC_PACKET)); + qdf_mem_zero(pPacket, sizeof(HTC_PACKET)); free_htc_packet_container(target, pPacket); } } @@ -434,9 +435,9 @@ A_STATUS htc_setup_target_buffer_assignments(HTC_TARGET *target) return status; } -A_UINT8 htc_get_credit_allocation(HTC_TARGET *target, A_UINT16 service_id) +uint8_t htc_get_credit_allocation(HTC_TARGET *target, uint16_t service_id) { - A_UINT8 allocation = 0; + uint8_t allocation = 0; int i; for (i = 0; i < HTC_MAX_SERVICE_ALLOC_ENTRIES; i++) { @@ -463,7 +464,7 @@ A_STATUS htc_wait_target(HTC_HANDLE HTCHandle) HTC_SERVICE_CONNECT_REQ connect; HTC_SERVICE_CONNECT_RESP resp; HTC_READY_MSG *rdy_msg; - A_UINT16 htc_rdy_msg_id; + uint16_t htc_rdy_msg_id; AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("htc_wait_target - Enter (target:0x%p) \n", HTCHandle)); @@ -509,7 +510,7 @@ A_STATUS htc_wait_target(HTC_HANDLE HTCHandle) target->TargetCreditSize = (int)HTC_GET_FIELD(rdy_msg, HTC_READY_MSG, CREDITSIZE); target->MaxMsgsPerHTCBundle = - (A_UINT8) pReadyMsg->MaxMsgsPerHTCBundle; + (uint8_t) pReadyMsg->MaxMsgsPerHTCBundle; /* for old fw this value is set to 0. But the minimum value should be 1, * i.e., no bundling */ if (target->MaxMsgsPerHTCBundle < 1) @@ -532,8 +533,8 @@ A_STATUS htc_wait_target(HTC_HANDLE HTCHandle) htc_setup_target_buffer_assignments(target); /* setup our pseudo HTC control endpoint connection */ - A_MEMZERO(&connect, sizeof(connect)); - A_MEMZERO(&resp, sizeof(resp)); + qdf_mem_zero(&connect, sizeof(connect)); + qdf_mem_zero(&resp, sizeof(resp)); connect.EpCallbacks.pContext = target; connect.EpCallbacks.EpTxComplete = htc_control_tx_complete; connect.EpCallbacks.EpRecv = htc_control_rx_complete; @@ -573,7 +574,7 @@ static void reset_endpoint_states(HTC_TARGET *target) INIT_HTC_PACKET_QUEUE(&pEndpoint->TxLookupQueue); INIT_HTC_PACKET_QUEUE(&pEndpoint->RxBufferHoldQueue); pEndpoint->target = target; - pEndpoint->TxCreditFlowEnabled = (A_BOOL)htc_credit_flow; + pEndpoint->TxCreditFlowEnabled = (bool)htc_credit_flow; qdf_atomic_init(&pEndpoint->TxProcessCount); } } @@ -608,7 +609,7 @@ A_STATUS htc_start(HTC_HANDLE HTCHandle) qdf_nbuf_put_tail(netbuf, sizeof(HTC_SETUP_COMPLETE_EX_MSG)); pSetupComp = (HTC_SETUP_COMPLETE_EX_MSG *) qdf_nbuf_data(netbuf); - A_MEMZERO(pSetupComp, sizeof(HTC_SETUP_COMPLETE_EX_MSG)); + qdf_mem_zero(pSetupComp, sizeof(HTC_SETUP_COMPLETE_EX_MSG)); HTC_SET_FIELD(pSetupComp, HTC_SETUP_COMPLETE_EX_MSG, MESSAGEID, HTC_MSG_SETUP_COMPLETE_EX_ID); @@ -633,7 +634,7 @@ A_STATUS htc_start(HTC_HANDLE HTCHandle) SET_HTC_PACKET_INFO_TX(pSendPacket, NULL, - (A_UINT8 *) pSetupComp, + (uint8_t *) pSetupComp, sizeof(HTC_SETUP_COMPLETE_EX_MSG), ENDPOINT_0, HTC_SERVICE_TX_PACKET_TAG); @@ -760,15 +761,15 @@ void htc_dump_credit_states(HTC_HANDLE HTCHandle) } } -A_BOOL htc_get_endpoint_statistics(HTC_HANDLE HTCHandle, +bool htc_get_endpoint_statistics(HTC_HANDLE HTCHandle, HTC_ENDPOINT_ID Endpoint, HTC_ENDPOINT_STAT_ACTION Action, HTC_ENDPOINT_STATS *pStats) { #ifdef HTC_EP_STAT_PROFILING HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle); - A_BOOL clearStats = false; - A_BOOL sample = false; + bool clearStats = false; + bool sample = false; switch (Action) { case HTC_EP_STAT_SAMPLE: @@ -794,13 +795,13 @@ A_BOOL htc_get_endpoint_statistics(HTC_HANDLE HTCHandle, if (sample) { A_ASSERT(pStats != NULL); /* return the stats to the caller */ - A_MEMCPY(pStats, &target->endpoint[Endpoint].endpoint_stats, + qdf_mem_copy(pStats, &target->endpoint[Endpoint].endpoint_stats, sizeof(HTC_ENDPOINT_STATS)); } if (clearStats) { /* reset stats */ - A_MEMZERO(&target->endpoint[Endpoint].endpoint_stats, + qdf_mem_zero(&target->endpoint[Endpoint].endpoint_stats, sizeof(HTC_ENDPOINT_STATS)); } diff --git a/htc/htc_api.h b/htc/htc_api.h index 998a013f3d..ae2be2591d 100644 --- a/htc/htc_api.h +++ b/htc/htc_api.h @@ -28,11 +28,10 @@ #ifndef _HTC_API_H_ #define _HTC_API_H_ -#include "osapi_linux.h" -#include "htc_packet.h" #include #include #include /* qdf_device_t */ +#include "htc_packet.h" #ifdef __cplusplus extern "C" { @@ -48,7 +47,7 @@ extern "C" { typedef void *HTC_HANDLE; -typedef A_UINT16 HTC_SERVICE_ID; +typedef uint16_t HTC_SERVICE_ID; typedef void (*HTC_TARGET_FAILURE)(void *Instance, QDF_STATUS Status); @@ -167,12 +166,12 @@ typedef struct _HTC_EP_CALLBACKS { /* service connection information */ typedef struct _HTC_SERVICE_CONNECT_REQ { HTC_SERVICE_ID service_id; /* service ID to connect to */ - A_UINT16 ConnectionFlags; /* connection flags, see htc protocol definition */ - A_UINT8 *pMetaData; /* ptr to optional service-specific meta-data */ - A_UINT8 MetaDataLength; /* optional meta data length */ + uint16_t ConnectionFlags; /* connection flags, see htc protocol definition */ + uint8_t *pMetaData; /* ptr to optional service-specific meta-data */ + uint8_t MetaDataLength; /* optional meta data length */ HTC_EP_CALLBACKS EpCallbacks; /* endpoint callbacks */ int MaxSendQueueDepth; /* maximum depth of any send queue */ - A_UINT32 LocalConnectionFlags; /* HTC flags for the host-side (local) connection */ + uint32_t LocalConnectionFlags; /* HTC flags for the host-side (local) connection */ unsigned int MaxSendMsgSize; /* override max message size in send direction */ } HTC_SERVICE_CONNECT_REQ; @@ -180,12 +179,12 @@ typedef struct _HTC_SERVICE_CONNECT_REQ { /* service connection response information */ typedef struct _HTC_SERVICE_CONNECT_RESP { - A_UINT8 *pMetaData; /* caller supplied buffer to optional meta-data */ - A_UINT8 BufferLength; /* length of caller supplied buffer */ - A_UINT8 ActualLength; /* actual length of meta data */ + uint8_t *pMetaData; /* caller supplied buffer to optional meta-data */ + uint8_t BufferLength; /* length of caller supplied buffer */ + uint8_t ActualLength; /* actual length of meta data */ HTC_ENDPOINT_ID Endpoint; /* endpoint to communicate over */ unsigned int MaxMsgLength; /* max length of all messages over this endpoint */ - A_UINT8 ConnectRespCode; /* connect response code from target */ + uint8_t ConnectRespCode; /* connect response code from target */ } HTC_SERVICE_CONNECT_RESP; /* endpoint distribution structure */ @@ -194,7 +193,7 @@ typedef struct _HTC_ENDPOINT_CREDIT_DIST { struct _HTC_ENDPOINT_CREDIT_DIST *pPrev; HTC_SERVICE_ID service_id; /* Service ID (set by HTC) */ HTC_ENDPOINT_ID Endpoint; /* endpoint for this distribution struct (set by HTC) */ - A_UINT32 DistFlags; /* distribution flags, distribution function can + uint32_t DistFlags; /* distribution flags, distribution function can set default activity using SET_EP_ACTIVE() macro */ int TxCreditsNorm; /* credits for normal operation, anything above this indicates the endpoint is over-subscribed, this field @@ -223,7 +222,7 @@ typedef struct _HTC_ENDPOINT_CREDIT_DIST { */ } HTC_ENDPOINT_CREDIT_DIST; -#define HTC_EP_ACTIVE ((A_UINT32) (1u << 31)) +#define HTC_EP_ACTIVE ((uint32_t) (1u << 31)) /* macro to check if an endpoint has gone active, useful for credit * distributions */ @@ -260,30 +259,30 @@ typedef enum _HTC_ENDPOINT_STAT_ACTION { /* endpoint statistics */ typedef struct _HTC_ENDPOINT_STATS { - A_UINT32 TxPosted; /* number of TX packets posted to the endpoint */ - A_UINT32 TxCreditLowIndications; /* number of times the host set the credit-low flag in a send message on + uint32_t TxPosted; /* number of TX packets posted to the endpoint */ + uint32_t TxCreditLowIndications; /* number of times the host set the credit-low flag in a send message on this endpoint */ - A_UINT32 TxIssued; /* running count of total TX packets issued */ - A_UINT32 TxPacketsBundled; /* running count of TX packets that were issued in bundles */ - A_UINT32 TxBundles; /* running count of TX bundles that were issued */ - A_UINT32 TxDropped; /* tx packets that were dropped */ - A_UINT32 TxCreditRpts; /* running count of total credit reports received for this endpoint */ - A_UINT32 TxCreditRptsFromRx; /* credit reports received from this endpoint's RX packets */ - A_UINT32 TxCreditRptsFromOther; /* credit reports received from RX packets of other endpoints */ - A_UINT32 TxCreditRptsFromEp0; /* credit reports received from endpoint 0 RX packets */ - A_UINT32 TxCreditsFromRx; /* count of credits received via Rx packets on this endpoint */ - A_UINT32 TxCreditsFromOther; /* count of credits received via another endpoint */ - A_UINT32 TxCreditsFromEp0; /* count of credits received via another endpoint */ - A_UINT32 TxCreditsConsummed; /* count of consummed credits */ - A_UINT32 TxCreditsReturned; /* count of credits returned */ - A_UINT32 RxReceived; /* count of RX packets received */ - A_UINT32 RxLookAheads; /* count of lookahead records + uint32_t TxIssued; /* running count of total TX packets issued */ + uint32_t TxPacketsBundled; /* running count of TX packets that were issued in bundles */ + uint32_t TxBundles; /* running count of TX bundles that were issued */ + uint32_t TxDropped; /* tx packets that were dropped */ + uint32_t TxCreditRpts; /* running count of total credit reports received for this endpoint */ + uint32_t TxCreditRptsFromRx; /* credit reports received from this endpoint's RX packets */ + uint32_t TxCreditRptsFromOther; /* credit reports received from RX packets of other endpoints */ + uint32_t TxCreditRptsFromEp0; /* credit reports received from endpoint 0 RX packets */ + uint32_t TxCreditsFromRx; /* count of credits received via Rx packets on this endpoint */ + uint32_t TxCreditsFromOther; /* count of credits received via another endpoint */ + uint32_t TxCreditsFromEp0; /* count of credits received via another endpoint */ + uint32_t TxCreditsConsummed; /* count of consummed credits */ + uint32_t TxCreditsReturned; /* count of credits returned */ + uint32_t RxReceived; /* count of RX packets received */ + uint32_t RxLookAheads; /* count of lookahead records found in messages received on this endpoint */ - A_UINT32 RxPacketsBundled; /* count of recv packets received in a bundle */ - A_UINT32 RxBundleLookAheads; /* count of number of bundled lookaheads */ - A_UINT32 RxBundleIndFromHdr; /* count of the number of bundle indications from the HTC header */ - A_UINT32 RxAllocThreshHit; /* count of the number of times the recv allocation threshhold was hit */ - A_UINT32 RxAllocThreshBytes; /* total number of bytes */ + uint32_t RxPacketsBundled; /* count of recv packets received in a bundle */ + uint32_t RxBundleLookAheads; /* count of number of bundled lookaheads */ + uint32_t RxBundleIndFromHdr; /* count of the number of bundle indications from the HTC header */ + uint32_t RxAllocThreshHit; /* count of the number of times the recv allocation threshhold was hit */ + uint32_t RxAllocThreshBytes; /* total number of bytes */ } HTC_ENDPOINT_STATS; /* ------ Function Prototypes ------ */ @@ -448,7 +447,7 @@ A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, qdf_nbuf_t netbuf, int Epid, int ActualLength); #else /*ATH_11AC_TXCOMPACT */ A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket, - A_UINT8 more_data); + uint8_t more_data); #endif /*ATH_11AC_TXCOMPACT */ /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @desc: Flush HTC when target is removed surprisely service communications @@ -525,7 +524,7 @@ void htc_dump_credit_states(HTC_HANDLE HTCHandle); @see also: +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ void htc_indicate_activity_change(HTC_HANDLE HTCHandle, - HTC_ENDPOINT_ID Endpoint, A_BOOL Active); + HTC_ENDPOINT_ID Endpoint, bool Active); /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @desc: Get endpoint statistics @@ -555,7 +554,7 @@ void htc_indicate_activity_change(HTC_HANDLE HTCHandle, @example: @see also: +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ -A_BOOL htc_get_endpoint_statistics(HTC_HANDLE HTCHandle, +bool htc_get_endpoint_statistics(HTC_HANDLE HTCHandle, HTC_ENDPOINT_ID Endpoint, HTC_ENDPOINT_STAT_ACTION Action, HTC_ENDPOINT_STATS *pStats); @@ -632,7 +631,7 @@ A_STATUS htc_add_receive_pkt_multiple(HTC_HANDLE HTCHandle, @example: @see also: +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ -A_BOOL htc_is_endpoint_active(HTC_HANDLE HTCHandle, +bool htc_is_endpoint_active(HTC_HANDLE HTCHandle, HTC_ENDPOINT_ID Endpoint); /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ @@ -667,8 +666,8 @@ void htc_set_target_failure_callback(HTC_HANDLE HTCHandle, void htc_enable_recv(HTC_HANDLE HTCHandle); void htc_disable_recv(HTC_HANDLE HTCHandle); A_STATUS HTCWaitForPendingRecv(HTC_HANDLE HTCHandle, - A_UINT32 TimeoutInMs, - A_BOOL *pbIsRecvPending); + uint32_t TimeoutInMs, + bool *pbIsRecvPending); /* function to fetch stats from htc layer*/ struct ol_ath_htc_stats *ieee80211_ioctl_get_htc_stats(HTC_HANDLE @@ -693,7 +692,7 @@ do { \ SM((_download_len), HTC_FRAME_HDR_PAYLOADLEN) | \ SM((_ep_id), HTC_FRAME_HDR_ENDPOINTID)); \ \ - HTC_WRITE32((A_UINT32 *)(_htc_tx_desc) + 1, \ + HTC_WRITE32((uint32_t *)(_htc_tx_desc) + 1, \ SM((_seq_no), HTC_FRAME_HDR_CONTROLBYTES1));\ } while (0) #endif /* WLAN_FEATURE_FASTPATH */ diff --git a/htc/htc_internal.h b/htc/htc_internal.h index 29f2a1cc10..4f057a4106 100644 --- a/htc/htc_internal.h +++ b/htc/htc_internal.h @@ -32,16 +32,16 @@ extern "C" { #endif /* __cplusplus */ -#include -#include -#include -#include -#include -#include -#include "hif.h" -#include #include "htc_api.h" #include "htc_packet.h" +#include +#include +#include +#include +#include +#include +#include +#include /* HTC operational parameters */ #define HTC_TARGET_RESPONSE_TIMEOUT 2000 /* in ms */ @@ -120,7 +120,7 @@ typedef struct _HTC_ENDPOINT { HTC_PACKET_QUEUE TxLookupQueue; /* lookup queue to match netbufs to htc packets */ HTC_PACKET_QUEUE RxBufferHoldQueue; /* temporary hold queue for back compatibility */ - A_UINT8 SeqNo; /* TX seq no (helpful) for debugging */ + uint8_t SeqNo; /* TX seq no (helpful) for debugging */ qdf_atomic_t TxProcessCount; /* serialization */ struct _HTC_TARGET *target; int TxCredits; /* TX credits available on this endpoint */ @@ -129,7 +129,7 @@ typedef struct _HTC_ENDPOINT { #ifdef HTC_EP_STAT_PROFILING HTC_ENDPOINT_STATS endpoint_stats; /* endpoint statistics */ #endif - A_BOOL TxCreditFlowEnabled; + bool TxCreditFlowEnabled; } HTC_ENDPOINT; #ifdef HTC_EP_STAT_PROFILING @@ -139,8 +139,8 @@ typedef struct _HTC_ENDPOINT { #endif typedef struct { - A_UINT16 service_id; - A_UINT8 CreditAllocation; + uint16_t service_id; + uint8_t CreditAllocation; } HTC_SERVICE_TX_CREDIT_ALLOCATION; #define HTC_MAX_SERVICE_ALLOC_ENTRIES 8 @@ -159,31 +159,31 @@ typedef struct _HTC_TARGET { qdf_spinlock_t HTCRxLock; qdf_spinlock_t HTCTxLock; qdf_spinlock_t HTCCreditLock; - A_UINT32 HTCStateFlags; + uint32_t HTCStateFlags; void *host_handle; HTC_INIT_INFO HTCInitInfo; HTC_PACKET *pHTCPacketStructPool; /* pool of HTC packets */ HTC_PACKET_QUEUE ControlBufferTXFreeList; - A_UINT8 CtrlResponseBuffer[HTC_MAX_CONTROL_MESSAGE_LENGTH]; + uint8_t CtrlResponseBuffer[HTC_MAX_CONTROL_MESSAGE_LENGTH]; int CtrlResponseLength; qdf_event_t ctrl_response_valid; - A_BOOL CtrlResponseProcessing; + bool CtrlResponseProcessing; int TotalTransmitCredits; HTC_SERVICE_TX_CREDIT_ALLOCATION ServiceTxAllocTable[HTC_MAX_SERVICE_ALLOC_ENTRIES]; int TargetCreditSize; #ifdef RX_SG_SUPPORT qdf_nbuf_queue_t RxSgQueue; - A_BOOL IsRxSgInprogress; - A_UINT32 CurRxSgTotalLen; /* current total length */ - A_UINT32 ExpRxSgTotalLen; /* expected total length */ + bool IsRxSgInprogress; + uint32_t CurRxSgTotalLen; /* current total length */ + uint32_t ExpRxSgTotalLen; /* expected total length */ #endif qdf_device_t osdev; struct ol_ath_htc_stats htc_pkt_stats; HTC_PACKET *pBundleFreeList; - A_UINT32 ce_send_cnt; - A_UINT32 TX_comp_cnt; - A_UINT8 MaxMsgsPerHTCBundle; + uint32_t ce_send_cnt; + uint32_t TX_comp_cnt; + uint8_t MaxMsgsPerHTCBundle; qdf_work_t queue_kicker; uint32_t con_mode; } HTC_TARGET; @@ -245,8 +245,8 @@ void htc_recv_init(HTC_TARGET *target); A_STATUS htc_wait_recv_ctrl_message(HTC_TARGET *target); void htc_free_control_tx_packet(HTC_TARGET *target, HTC_PACKET *pPacket); HTC_PACKET *htc_alloc_control_tx_packet(HTC_TARGET *target); -A_UINT8 htc_get_credit_allocation(HTC_TARGET *target, A_UINT16 service_id); -void htc_tx_resource_avail_handler(void *context, A_UINT8 pipeID); +uint8_t htc_get_credit_allocation(HTC_TARGET *target, uint16_t service_id); +void htc_tx_resource_avail_handler(void *context, uint8_t pipeID); void htc_control_rx_complete(void *Context, HTC_PACKET *pPacket); void htc_process_credit_rpt(HTC_TARGET *target, HTC_CREDIT_REPORT *pRpt, diff --git a/htc/htc_packet.h b/htc/htc_packet.h index 46c3de8f7f..7d13b40ae5 100644 --- a/htc/htc_packet.h +++ b/htc/htc_packet.h @@ -50,14 +50,14 @@ struct _HTC_PACKET; typedef void (*HTC_PACKET_COMPLETION)(void *, struct _HTC_PACKET *); -typedef A_UINT16 HTC_TX_TAG; +typedef uint16_t HTC_TX_TAG; typedef struct _HTC_TX_PACKET_INFO { HTC_TX_TAG Tag; /* tag used to selective flush packets */ int CreditsUsed; /* number of credits used for this TX packet (HTC internal) */ - A_UINT8 SendFlags; /* send flags (HTC internal) */ + uint8_t SendFlags; /* send flags (HTC internal) */ int SeqNo; /* internal seq no for debugging (HTC internal) */ - A_UINT32 Flags; /* internal use */ + uint32_t Flags; /* internal use */ } HTC_TX_PACKET_INFO; /** @@ -81,9 +81,9 @@ typedef struct _HTC_TX_PACKET_INFO { #define HTC_TX_PACKET_FLAG_FIXUP_NETBUF (1 << 0) typedef struct _HTC_RX_PACKET_INFO { - A_UINT32 ExpectedHdr; /* HTC internal use */ - A_UINT32 HTCRxFlags; /* HTC internal use */ - A_UINT32 IndicationFlags; /* indication flags set on each RX packet indication */ + uint32_t ExpectedHdr; /* HTC internal use */ + uint32_t HTCRxFlags; /* HTC internal use */ + uint32_t IndicationFlags; /* indication flags set on each RX packet indication */ } HTC_RX_PACKET_INFO; #define HTC_RX_FLAGS_INDICATE_MORE_PKTS (1 << 0) /* more packets on this endpoint are being fetched */ @@ -93,7 +93,7 @@ typedef struct _HTC_PACKET { DL_LIST ListLink; /* double link */ void *pPktContext; /* caller's per packet specific context */ - A_UINT8 *pBufferStart; /* the true buffer start , the caller can + uint8_t *pBufferStart; /* the true buffer start , the caller can store the real buffer start here. In receive callbacks, the HTC layer sets pBuffer to the start of the payload past the header. This @@ -106,9 +106,9 @@ typedef struct _HTC_PACKET { * points to the start of the HTC header but when returned * to the caller points to the start of the payload */ - A_UINT8 *pBuffer; /* payload start (RX/TX) */ - A_UINT32 BufferLength; /* length of buffer */ - A_UINT32 ActualLength; /* actual length of payload */ + uint8_t *pBuffer; /* payload start (RX/TX) */ + uint32_t BufferLength; /* length of buffer */ + uint32_t ActualLength; /* actual length of payload */ HTC_ENDPOINT_ID Endpoint; /* endpoint that this packet was sent/recv'd from */ A_STATUS Status; /* completion status */ union { @@ -117,7 +117,7 @@ typedef struct _HTC_PACKET { } PktInfo; /* the following fields are for internal HTC use */ - A_UINT32 netbufOrigHeadRoom; + uint32_t netbufOrigHeadRoom; HTC_PACKET_COMPLETION Completion; /* completion */ void *pContext; /* HTC private completion context */ void *pNetBufContext; /* optimization for network-oriented data, the HTC packet diff --git a/htc/htc_recv.c b/htc/htc_recv.c index 00b836d4fa..51718bcc8a 100644 --- a/htc/htc_recv.c +++ b/htc/htc_recv.c @@ -33,12 +33,12 @@ #define HTC_CONTROL_RX_TIMEOUT 3000 #ifdef DEBUG -void debug_dump_bytes(A_UCHAR *buffer, A_UINT16 length, char *pDescription) +void debug_dump_bytes(uint8_t *buffer, uint16_t length, char *pDescription) { - A_CHAR stream[60]; - A_CHAR byteOffsetStr[10]; - A_UINT32 i; - A_UINT16 offset, count, byteOffset; + int8_t stream[60]; + int8_t byteOffsetStr[10]; + uint32_t i; + uint16_t offset, count, byteOffset; A_PRINTF("<---------Dumping %d Bytes : %s ------>\n", length, pDescription); @@ -58,7 +58,7 @@ void debug_dump_bytes(A_UCHAR *buffer, A_UINT16 length, char *pDescription) A_SNPRINTF(byteOffsetStr, sizeof(byteOffset), "%4.4X", byteOffset); A_PRINTF("[%s]: %s\n", byteOffsetStr, stream); - A_MEMZERO(stream, 60); + qdf_mem_zero(stream, 60); byteOffset += 16; } } @@ -72,13 +72,13 @@ void debug_dump_bytes(A_UCHAR *buffer, A_UINT16 length, char *pDescription) A_PRINTF("<------------------------------------------------->\n"); } #else -void debug_dump_bytes(A_UCHAR *buffer, A_UINT16 length, char *pDescription) +void debug_dump_bytes(uint8_t *buffer, uint16_t length, char *pDescription) { } #endif static A_STATUS htc_process_trailer(HTC_TARGET *target, - A_UINT8 *pBuffer, + uint8_t *pBuffer, int Length, HTC_ENDPOINT_ID FromEndpoint); static void do_recv_completion(HTC_ENDPOINT *pEndpoint, @@ -268,9 +268,9 @@ QDF_STATUS htc_rx_completion_handler(void *Context, qdf_nbuf_t netbuf, uint32_t netlen; HTC_ENDPOINT *pEndpoint; HTC_PACKET *pPacket; - A_UINT16 payloadLen; + uint16_t payloadLen; uint32_t trailerlen = 0; - A_UINT8 htc_ep_id; + uint8_t htc_ep_id; #ifdef RX_SG_SUPPORT LOCK_HTC_RX(target); @@ -305,7 +305,7 @@ QDF_STATUS htc_rx_completion_handler(void *Context, qdf_nbuf_t netbuf, AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("HTC Rx: invalid EndpointID=%d\n", htc_ep_id)); - debug_dump_bytes((A_UINT8 *) HtcHdr, + debug_dump_bytes((uint8_t *) HtcHdr, sizeof(HTC_FRAME_HDR), "BAD HTC Header"); status = QDF_STATUS_E_FAILURE; QDF_BUG(0); @@ -341,7 +341,7 @@ QDF_STATUS htc_rx_completion_handler(void *Context, qdf_nbuf_t netbuf, AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("HTC Rx: insufficient length, got:%d expected =%zu\n", netlen, payloadLen + HTC_HDR_LENGTH)); - debug_dump_bytes((A_UINT8 *) HtcHdr, + debug_dump_bytes((uint8_t *) HtcHdr, sizeof(HTC_FRAME_HDR), "BAD RX packet length"); status = QDF_STATUS_E_FAILURE; @@ -357,7 +357,7 @@ QDF_STATUS htc_rx_completion_handler(void *Context, qdf_nbuf_t netbuf, /* if (IS_TX_CREDIT_FLOW_ENABLED(pEndpoint)) { */ { - A_UINT8 temp; + uint8_t temp; A_STATUS temp_status; /* get flags to check for trailer */ temp = HTC_GET_FIELD(HtcHdr, HTC_FRAME_HDR, FLAGS); @@ -378,7 +378,7 @@ QDF_STATUS htc_rx_completion_handler(void *Context, qdf_nbuf_t netbuf, trailerlen = temp; /* process trailer data that follows HDR + application payload */ temp_status = htc_process_trailer(target, - ((A_UINT8 *) HtcHdr + + ((uint8_t *) HtcHdr + HTC_HDR_LENGTH + payloadLen - temp), temp, htc_ep_id); @@ -396,7 +396,7 @@ QDF_STATUS htc_rx_completion_handler(void *Context, qdf_nbuf_t netbuf, } if (htc_ep_id == ENDPOINT_0) { - A_UINT16 message_id; + uint16_t message_id; HTC_UNKNOWN_MSG *htc_msg; int wow_nack = 0; @@ -426,8 +426,9 @@ QDF_STATUS htc_rx_completion_handler(void *Context, qdf_nbuf_t netbuf, target->CtrlResponseLength = min((int)netlen, HTC_MAX_CONTROL_MESSAGE_LENGTH); - A_MEMCPY(target->CtrlResponseBuffer, netdata, - target->CtrlResponseLength); + qdf_mem_copy(target->CtrlResponseBuffer, + netdata, + target->CtrlResponseLength); /* Requester will clear this flag */ target->CtrlResponseProcessing = true; @@ -652,14 +653,14 @@ A_STATUS htc_wait_recv_ctrl_message(HTC_TARGET *target) } static A_STATUS htc_process_trailer(HTC_TARGET *target, - A_UINT8 *pBuffer, + uint8_t *pBuffer, int Length, HTC_ENDPOINT_ID FromEndpoint) { HTC_RECORD_HDR *pRecord; - A_UINT8 htc_rec_id; - A_UINT8 htc_rec_len; - A_UINT8 *pRecordBuf; - A_UINT8 *pOrigBuffer; + uint8_t htc_rec_id; + uint8_t htc_rec_len; + uint8_t *pRecordBuf; + uint8_t *pOrigBuffer; int origLength; A_STATUS status; diff --git a/htc/htc_send.c b/htc/htc_send.c index 9466adefeb..4563b4a86f 100644 --- a/htc/htc_send.c +++ b/htc/htc_send.c @@ -27,8 +27,9 @@ #include "htc_debug.h" #include "htc_internal.h" +#include /* qdf_mem_malloc */ #include /* qdf_nbuf_t */ -#include /* qdf_mem_malloc */ + /* #define USB_HIF_SINGLE_PIPE_DATA_SCHED */ /* #ifdef USB_HIF_SINGLE_PIPE_DATA_SCHED */ @@ -53,7 +54,7 @@ static unsigned ep_debug_mask = #endif /* HTC Control Path Credit History */ -A_UINT32 g_htc_credit_history_idx = 0; +uint32_t g_htc_credit_history_idx = 0; HTC_CREDIT_HISTORY htc_credit_history_buffer[HTC_CREDIT_HISTORY_MAX]; /** @@ -255,7 +256,7 @@ HTC_PACKET *allocate_htc_bundle_packet(HTC_TARGET *target) void free_htc_bundle_packet(HTC_TARGET *target, HTC_PACKET *pPacket) { - A_UINT32 curentHeadRoom; + uint32_t curentHeadRoom; qdf_nbuf_t netbuf; HTC_PACKET_QUEUE *pQueueSave; @@ -415,7 +416,7 @@ static void htc_issue_packets_bundle(HTC_TARGET *target, HTC_FLAGS_SEND_BUNDLE, HTC_FRAME_HDR_FLAGS) | SM(pPacket->Endpoint, HTC_FRAME_HDR_ENDPOINTID)); - HTC_WRITE32((A_UINT32 *) pHtcHdr + 1, + HTC_WRITE32((uint32_t *) pHtcHdr + 1, SM(pPacket->PktInfo.AsTx.SeqNo, HTC_FRAME_HDR_CONTROLBYTES1) | SM(creditPad, HTC_FRAME_HDR_RESERVED)); @@ -429,7 +430,7 @@ static void htc_issue_packets_bundle(HTC_TARGET *target, if (frag_len > nbytes) { frag_len = nbytes; } - A_MEMCPY(pBundleBuffer, frag_addr, frag_len); + qdf_mem_copy(pBundleBuffer, frag_addr, frag_len); nbytes -= frag_len; pBundleBuffer += frag_len; } @@ -504,7 +505,7 @@ static A_STATUS htc_issue_packets(HTC_TARGET *target, HTC_FRAME_HDR_FLAGS) | SM(pPacket->Endpoint, HTC_FRAME_HDR_ENDPOINTID)); - HTC_WRITE32(((A_UINT32 *) pHtcHdr) + 1, + HTC_WRITE32(((uint32_t *) pHtcHdr) + 1, SM(pPacket->PktInfo.AsTx.SeqNo, HTC_FRAME_HDR_CONTROLBYTES1)); @@ -663,7 +664,7 @@ void get_htc_send_packets_credit_based(HTC_TARGET *target, { int creditsRequired; int remainder; - A_UINT8 sendFlags; + uint8_t sendFlags; HTC_PACKET *pPacket; unsigned int transferLength; HTC_PACKET_QUEUE *tx_queue; @@ -1131,14 +1132,14 @@ static HTC_SEND_QUEUE_RESULT htc_try_send(HTC_TARGET *target, } #ifdef USB_HIF_SINGLE_PIPE_DATA_SCHED -static A_UINT16 htc_send_pkts_sched_check(HTC_HANDLE HTCHandle, HTC_ENDPOINT_ID id) +static uint16_t htc_send_pkts_sched_check(HTC_HANDLE HTCHandle, HTC_ENDPOINT_ID id) { HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle); HTC_ENDPOINT *pEndpoint; HTC_ENDPOINT_ID eid; HTC_PACKET_QUEUE *pTxQueue; - A_UINT16 resources; - A_UINT16 acQueueStatus[DATA_EP_SIZE] = { 0, 0, 0, 0 }; + uint16_t resources; + uint16_t acQueueStatus[DATA_EP_SIZE] = { 0, 0, 0, 0 }; if (id < ENDPOINT_2 || id > ENDPOINT_5) { return 1; @@ -1277,7 +1278,7 @@ A_STATUS htc_send_pkts_multiple(HTC_HANDLE HTCHandle, HTC_PACKET_QUEUE *pPktQueu pPacket->PktInfo.AsTx.SeqNo = pEndpoint->SeqNo; pEndpoint->SeqNo++; - HTC_WRITE32(((A_UINT32 *) pHtcHdr) + 1, + HTC_WRITE32(((uint32_t *) pHtcHdr) + 1, SM(pPacket->PktInfo.AsTx.SeqNo, HTC_FRAME_HDR_CONTROLBYTES1)); @@ -1402,7 +1403,7 @@ A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, qdf_nbuf_t netbuf, int Epid, LOCK_HTC_TX(target); - HTC_WRITE32(((A_UINT32 *) pHtcHdr) + 1, + HTC_WRITE32(((uint32_t *) pHtcHdr) + 1, SM(pEndpoint->SeqNo, HTC_FRAME_HDR_CONTROLBYTES1)); pEndpoint->SeqNo++; @@ -1421,7 +1422,7 @@ A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, qdf_nbuf_t netbuf, int Epid, #else /*ATH_11AC_TXCOMPACT */ A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket, - A_UINT8 more_data) + uint8_t more_data) { HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle); HTC_ENDPOINT *pEndpoint; @@ -1472,7 +1473,7 @@ A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket, pPacket->PktInfo.AsTx.SeqNo = pEndpoint->SeqNo; pEndpoint->SeqNo++; - HTC_WRITE32(((A_UINT32 *) pHtcHdr) + 1, + HTC_WRITE32(((uint32_t *) pHtcHdr) + 1, SM(pPacket->PktInfo.AsTx.SeqNo, HTC_FRAME_HDR_CONTROLBYTES1)); @@ -1707,9 +1708,9 @@ QDF_STATUS htc_tx_completion_handler(void *Context, HTC_ENDPOINT_ID eid[DATA_EP_SIZE] = { ENDPOINT_5, ENDPOINT_4, ENDPOINT_2, ENDPOINT_3 }; int epidIdx; - A_UINT16 resourcesThresh[DATA_EP_SIZE]; /* urb resources */ - A_UINT16 resources; - A_UINT16 resourcesMax; + uint16_t resourcesThresh[DATA_EP_SIZE]; /* urb resources */ + uint16_t resources; + uint16_t resourcesMax; #endif pEndpoint = &target->endpoint[EpID]; @@ -1758,7 +1759,7 @@ QDF_STATUS htc_tx_completion_handler(void *Context, } /* callback when TX resources become available */ -void htc_tx_resource_avail_handler(void *context, A_UINT8 pipeID) +void htc_tx_resource_avail_handler(void *context, uint8_t pipeID) { int i; HTC_TARGET *target = (HTC_TARGET *) context; @@ -1855,12 +1856,12 @@ void htc_flush_endpoint(HTC_HANDLE HTCHandle, HTC_ENDPOINT_ID Endpoint, /* HTC API to indicate activity to the credit distribution function */ void htc_indicate_activity_change(HTC_HANDLE HTCHandle, - HTC_ENDPOINT_ID Endpoint, A_BOOL Active) + HTC_ENDPOINT_ID Endpoint, bool Active) { /* TODO */ } -A_BOOL htc_is_endpoint_active(HTC_HANDLE HTCHandle, HTC_ENDPOINT_ID Endpoint) +bool htc_is_endpoint_active(HTC_HANDLE HTCHandle, HTC_ENDPOINT_ID Endpoint) { return true; } @@ -1872,7 +1873,7 @@ void htc_process_credit_rpt(HTC_TARGET *target, HTC_CREDIT_REPORT *pRpt, int i; HTC_ENDPOINT *pEndpoint; int totalCredits = 0; - A_UINT8 rpt_credits, rpt_ep_id; + uint8_t rpt_credits, rpt_ep_id; AR_DEBUG_PRINTF(ATH_DEBUG_SEND, ("+htc_process_credit_rpt, Credit Report Entries:%d \n", diff --git a/htc/htc_services.c b/htc/htc_services.c index 2b29b1a85c..b4ccb7c1f3 100644 --- a/htc/htc_services.c +++ b/htc/htc_services.c @@ -27,8 +27,8 @@ #include "htc_debug.h" #include "htc_internal.h" +#include #include /* qdf_nbuf_t */ -#include "hif.h" /* use credit flow control over HTC */ unsigned int htc_credit_flow = 1; @@ -49,12 +49,12 @@ A_STATUS htc_connect_service(HTC_HANDLE HTCHandle, HTC_ENDPOINT *pEndpoint; unsigned int maxMsgSize = 0; qdf_nbuf_t netbuf; - A_UINT8 txAlloc; + uint8_t txAlloc; int length; - A_BOOL disableCreditFlowCtrl = false; - A_UINT16 conn_flags; - A_UINT16 rsp_msg_id, rsp_msg_serv_id, rsp_msg_max_msg_size; - A_UINT8 rsp_msg_status, rsp_msg_end_id, rsp_msg_serv_meta_len; + bool disableCreditFlowCtrl = false; + uint16_t conn_flags; + uint16_t rsp_msg_id, rsp_msg_serv_id, rsp_msg_max_msg_size; + uint8_t rsp_msg_status, rsp_msg_end_id, rsp_msg_serv_meta_len; AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("+htc_connect_service, target:%p SvcID:0x%X\n", target, @@ -108,7 +108,8 @@ A_STATUS htc_connect_service(HTC_HANDLE HTCHandle, break; } - A_MEMZERO(pConnectMsg, sizeof(HTC_CONNECT_SERVICE_MSG)); + qdf_mem_zero(pConnectMsg, + sizeof(HTC_CONNECT_SERVICE_MSG)); conn_flags = (pConnectReq-> @@ -136,7 +137,7 @@ A_STATUS htc_connect_service(HTC_HANDLE HTCHandle, (pConnectReq->MetaDataLength <= HTC_SERVICE_META_DATA_MAX_LENGTH)) { /* copy meta data into message buffer (after header ) */ - A_MEMCPY((A_UINT8 *) pConnectMsg + + qdf_mem_copy((uint8_t *) pConnectMsg + sizeof(HTC_CONNECT_SERVICE_MSG), pConnectReq->pMetaData, pConnectReq->MetaDataLength); @@ -149,7 +150,7 @@ A_STATUS htc_connect_service(HTC_HANDLE HTCHandle, SET_HTC_PACKET_INFO_TX(pSendPacket, NULL, - (A_UINT8 *) pConnectMsg, + (uint8_t *) pConnectMsg, length, ENDPOINT_0, HTC_SERVICE_TX_PACKET_TAG); @@ -237,8 +238,8 @@ A_STATUS htc_connect_service(HTC_HANDLE HTCHandle, min((int)pConnectResp->BufferLength, (int)rsp_msg_serv_meta_len); /* copy the meta data */ - A_MEMCPY(pConnectResp->pMetaData, - ((A_UINT8 *) pResponseMsg) + + qdf_mem_copy(pConnectResp->pMetaData, + ((uint8_t *) pResponseMsg) + sizeof (HTC_CONNECT_SERVICE_RESPONSE_MSG), copyLength);