From e3e209e1fd6b08cdf663c33d530edcbda712b2e8 Mon Sep 17 00:00:00 2001 From: Manikandan Mohan Date: Thu, 13 Apr 2017 20:19:26 -0700 Subject: [PATCH] qcacmn: Fix kernel module check patch warnings Fix kernel module check patch warnings in Host Target Communication module files Change-Id: I151f597142d93a26e5e037cf7fce944f86fba72a CRs-fixed: 2033001 --- htc/dl_list.h | 64 +-- htc/htc.c | 116 ++--- htc/htc_api.h | 1047 +++++++++++++++++++++-------------------- htc/htc_internal.h | 117 +++-- htc/htc_packet.h | 142 +++--- htc/htc_recv.c | 109 ++--- htc/htc_send.c | 447 +++++++++--------- htc/htc_services.c | 62 +-- wmi/src/wmi_unified.c | 4 +- 9 files changed, 1095 insertions(+), 1013 deletions(-) diff --git a/htc/dl_list.h b/htc/dl_list.h index 1b5d72f780..be9970cf0a 100644 --- a/htc/dl_list.h +++ b/htc/dl_list.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013-2014 The Linux Foundation. All rights reserved. + * Copyright (c) 2013-2014, 2017 The Linux Foundation. All rights reserved. * * Previously licensed under the ISC license by Qualcomm Atheros, Inc. * @@ -25,17 +25,18 @@ * to the Linux Foundation. */ -/* ============================================================================== */ +/*=========================================================================== */ /* Double-link list definitions (adapted from Atheros SDIO stack) */ /* */ /* Author(s): ="Atheros" */ -/* ============================================================================== */ +/*=========================================================================== */ #ifndef __DL_LIST_H___ #define __DL_LIST_H___ #define A_CONTAINING_STRUCT(address, struct_type, field_name) \ - ((struct_type *)((char *)(address) - (char *)(&((struct_type *)0)->field_name))) + ((struct_type *)((char *)(address) - \ + (char *)(&((struct_type *)0)->field_name))) /* list functions */ /* pointers for the list */ @@ -50,14 +51,15 @@ typedef struct _DL_LIST { {(pList)->pPrev = pList; (pList)->pNext = pList; } /* faster macro to init list and add a single item */ -#define DL_LIST_INIT_AND_ADD(pList,pItem) \ +#define DL_LIST_INIT_AND_ADD(pList, pItem) \ { (pList)->pPrev = (pItem); \ (pList)->pNext = (pItem); \ (pItem)->pNext = (pList); \ (pItem)->pPrev = (pList); \ } -#define DL_LIST_IS_EMPTY(pList) (((pList)->pPrev == (pList)) && ((pList)->pNext == (pList))) +#define DL_LIST_IS_EMPTY(pList) (((pList)->pPrev == (pList)) && \ + ((pList)->pNext == (pList))) #define DL_LIST_GET_ITEM_AT_HEAD(pList) (pList)->pNext #define DL_LIST_GET_ITEM_AT_TAIL(pList) (pList)->pPrev /* @@ -66,9 +68,10 @@ typedef struct _DL_LIST { * iteration loop */ #define ITERATE_OVER_LIST(pStart, pTemp) \ - for((pTemp) =(pStart)->pNext; pTemp != (pStart); (pTemp) = (pTemp)->pNext) + for ((pTemp) = (pStart)->pNext; pTemp != (pStart); \ + (pTemp) = (pTemp)->pNext) -static __inline bool dl_list_is_entry_in_list(const DL_LIST *pList, +static inline bool dl_list_is_entry_in_list(const DL_LIST *pList, const DL_LIST *pEntry) { const DL_LIST *pTmp; @@ -77,9 +80,8 @@ static __inline bool dl_list_is_entry_in_list(const DL_LIST *pList, return true; ITERATE_OVER_LIST(pList, pTmp) { - if (pTmp == pEntry) { + if (pTmp == pEntry) return true; - } } return false; @@ -88,30 +90,29 @@ static __inline bool dl_list_is_entry_in_list(const DL_LIST *pList, /* safe iterate macro that allows the item to be removed from the list * the iteration continues to the next item in the list */ -#define ITERATE_OVER_LIST_ALLOW_REMOVE(pStart,pItem,st,offset) \ +#define ITERATE_OVER_LIST_ALLOW_REMOVE(pStart, pItem, st, offset) \ { \ PDL_LIST pTemp; \ - pTemp = (pStart)->pNext; \ + { pTemp = (pStart)->pNext; } \ while (pTemp != (pStart)) { \ - (pItem) = A_CONTAINING_STRUCT(pTemp,st,offset); \ - pTemp = pTemp->pNext; \ + { (pItem) = A_CONTAINING_STRUCT(pTemp, st, offset); } \ + { pTemp = pTemp->pNext; } \ #define ITERATE_IS_VALID(pStart) dl_list_is_entry_in_list(pStart, pTemp) -#define ITERATE_RESET(pStart) pTemp=(pStart)->pNext +#define ITERATE_RESET(pStart) { pTemp = (pStart)->pNext; } #define ITERATE_END }} /* * dl_list_insert_tail - insert pAdd to the end of the list */ -static __inline PDL_LIST dl_list_insert_tail(PDL_LIST pList, PDL_LIST pAdd) +static inline PDL_LIST dl_list_insert_tail(PDL_LIST pList, PDL_LIST pAdd) { /* insert at tail */ pAdd->pPrev = pList->pPrev; pAdd->pNext = pList; - if (pList->pPrev) { + if (pList->pPrev) pList->pPrev->pNext = pAdd; - } pList->pPrev = pAdd; return pAdd; } @@ -119,7 +120,7 @@ static __inline PDL_LIST dl_list_insert_tail(PDL_LIST pList, PDL_LIST pAdd) /* * dl_list_insert_head - insert pAdd into the head of the list */ -static __inline PDL_LIST dl_list_insert_head(PDL_LIST pList, PDL_LIST pAdd) +static inline PDL_LIST dl_list_insert_head(PDL_LIST pList, PDL_LIST pAdd) { /* insert at head */ pAdd->pPrev = pList; @@ -129,20 +130,17 @@ static __inline PDL_LIST dl_list_insert_head(PDL_LIST pList, PDL_LIST pAdd) return pAdd; } -#define DL_ListAdd(pList,pItem) dl_list_insert_head((pList),(pItem)) +#define DL_ListAdd(pList, pItem) dl_list_insert_head((pList), (pItem)) /* * dl_list_remove - remove pDel from list */ -static __inline PDL_LIST dl_list_remove(PDL_LIST pDel) +static inline PDL_LIST dl_list_remove(PDL_LIST pDel) { - if (pDel->pNext != NULL) { + if (pDel->pNext != NULL) pDel->pNext->pPrev = pDel->pPrev; - } - if (pDel->pPrev != NULL) { + if (pDel->pPrev != NULL) pDel->pPrev->pNext = pDel->pNext; - } - - /* point back to itself just to be safe, incase remove is called again */ + /* point back to itself just to be safe, if remove is called again */ pDel->pNext = pDel; pDel->pPrev = pDel; return pDel; @@ -151,9 +149,10 @@ static __inline PDL_LIST dl_list_remove(PDL_LIST pDel) /* * dl_list_remove_item_from_head - get a list item from the head */ -static __inline PDL_LIST dl_list_remove_item_from_head(PDL_LIST pList) +static inline PDL_LIST dl_list_remove_item_from_head(PDL_LIST pList) { PDL_LIST pItem = NULL; + if (pList->pNext != pList) { pItem = pList->pNext; /* remove the first item from head */ @@ -162,9 +161,10 @@ static __inline PDL_LIST dl_list_remove_item_from_head(PDL_LIST pList) return pItem; } -static __inline PDL_LIST dl_list_remove_item_from_tail(PDL_LIST pList) +static inline PDL_LIST dl_list_remove_item_from_tail(PDL_LIST pList) { PDL_LIST pItem = NULL; + if (pList->pPrev != pList) { pItem = pList->pPrev; /* remove the item from tail */ @@ -174,7 +174,7 @@ static __inline PDL_LIST dl_list_remove_item_from_tail(PDL_LIST pList) } /* transfer src list items to the tail of the destination list */ -static __inline void dl_list_transfer_items_to_tail(PDL_LIST pDest, PDL_LIST pSrc) +static inline void dl_list_transfer_items_to_tail(PDL_LIST pDest, PDL_LIST pSrc) { /* only concatenate if src is not empty */ if (!DL_LIST_IS_EMPTY(pSrc)) { @@ -190,11 +190,11 @@ static __inline void dl_list_transfer_items_to_tail(PDL_LIST pDest, PDL_LIST pSr } /* transfer src list items to the head of the destination list */ -static __inline void dl_list_transfer_items_to_head(PDL_LIST pDest, PDL_LIST pSrc) +static inline void dl_list_transfer_items_to_head(PDL_LIST pDest, PDL_LIST pSrc) { /* only concatenate if src is not empty */ if (!DL_LIST_IS_EMPTY(pSrc)) { - /* cut out circular list in src and re-attach to start of dest */ + /* cut out circular list in src and reattach to start of dest */ pSrc->pNext->pPrev = pDest; pDest->pNext->pPrev = pSrc->pPrev; pSrc->pPrev->pNext = pDest->pNext; diff --git a/htc/htc.c b/htc/htc.c index 67449a235d..a8c0a656f4 100644 --- a/htc/htc.c +++ b/htc/htc.c @@ -60,12 +60,11 @@ static void reset_endpoint_states(HTC_TARGET *target); static void destroy_htc_tx_ctrl_packet(HTC_PACKET *pPacket) { qdf_nbuf_t netbuf; + netbuf = (qdf_nbuf_t) GET_HTC_PACKET_NET_BUF_CONTEXT(pPacket); AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("free ctrl netbuf :0x%p\n", netbuf)); - if (netbuf != NULL) { + if (netbuf != NULL) qdf_nbuf_free(netbuf); - } - qdf_mem_free(pPacket); } @@ -76,9 +75,8 @@ static HTC_PACKET *build_htc_tx_ctrl_packet(qdf_device_t osdev) do { pPacket = (HTC_PACKET *) qdf_mem_malloc(sizeof(HTC_PACKET)); - if (NULL == pPacket) { + if (pPacket == NULL) break; - } netbuf = qdf_nbuf_alloc(osdev, HTC_CONTROL_BUFFER_SIZE, 20, 4, true); if (NULL == netbuf) { @@ -88,7 +86,7 @@ static HTC_PACKET *build_htc_tx_ctrl_packet(qdf_device_t osdev) break; } AR_DEBUG_PRINTF(ATH_DEBUG_TRC, - ("alloc ctrl netbuf :0x%p \n", netbuf)); + ("alloc ctrl netbuf :0x%p\n", netbuf)); SET_HTC_PACKET_NET_BUF_CONTEXT(pPacket, netbuf); } while (false); @@ -129,12 +127,14 @@ void htc_set_target_failure_callback(HTC_HANDLE HTCHandle, HTC_TARGET_FAILURE Callback) { HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle); + target->HTCInitInfo.TargetFailure = Callback; } void htc_dump(HTC_HANDLE HTCHandle, uint8_t CmdId, bool start) { HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle); + hif_dump(target->hif_dev, CmdId, start); } @@ -152,29 +152,26 @@ static void htc_cleanup(HTC_TARGET *target) while (true) { pPacket = allocate_htc_packet_container(target); - if (NULL == pPacket) { + if (pPacket == NULL) break; - } qdf_mem_free(pPacket); } pPacket = target->pBundleFreeList; while (pPacket) { HTC_PACKET *pPacketTmp = (HTC_PACKET *) pPacket->ListLink.pNext; + qdf_mem_free(pPacket); pPacket = pPacketTmp; } #ifdef TODO_FIXME while (true) { pPacket = htc_alloc_control_tx_packet(target); - if (NULL == pPacket) { + if (pPacket == NULL) break; - } netbuf = (qdf_nbuf_t) GET_HTC_PACKET_NET_BUF_CONTEXT(pPacket); - if (netbuf != NULL) { + if (netbuf != NULL) qdf_nbuf_free(netbuf); - } - qdf_mem_free(pPacket); } #endif @@ -238,8 +235,8 @@ static inline void htc_runtime_pm_init(HTC_TARGET *target) { } #endif /* registered target arrival callback from the HIF layer */ -HTC_HANDLE htc_create(void *ol_sc, HTC_INIT_INFO *pInfo, qdf_device_t osdev, - uint32_t con_mode) +HTC_HANDLE htc_create(void *ol_sc, struct htc_init_info *pInfo, + qdf_device_t osdev, uint32_t con_mode) { struct hif_msg_callbacks htcCallbacks; HTC_ENDPOINT *pEndpoint = NULL; @@ -270,7 +267,7 @@ HTC_HANDLE htc_create(void *ol_sc, HTC_INIT_INFO *pInfo, qdf_device_t osdev, do { qdf_mem_copy(&target->HTCInitInfo, pInfo, - sizeof(HTC_INIT_INFO)); + sizeof(struct htc_init_info)); target->host_handle = pInfo->pContext; target->osdev = osdev; target->con_mode = con_mode; @@ -280,19 +277,17 @@ HTC_HANDLE htc_create(void *ol_sc, HTC_INIT_INFO *pInfo, qdf_device_t osdev, INIT_HTC_PACKET_QUEUE(&target->ControlBufferTXFreeList); for (i = 0; i < HTC_PACKET_CONTAINER_ALLOCATION; i++) { - HTC_PACKET *pPacket = - (HTC_PACKET *) qdf_mem_malloc(sizeof(HTC_PACKET)); - if (pPacket != NULL) { + HTC_PACKET *pPacket = (HTC_PACKET *) + qdf_mem_malloc(sizeof(HTC_PACKET)); + if (pPacket != NULL) free_htc_packet_container(target, pPacket); - } } #ifdef TODO_FIXME for (i = 0; i < NUM_CONTROL_TX_BUFFERS; i++) { pPacket = build_htc_tx_ctrl_packet(); - if (NULL == pPacket) { + if (pPacket == NULL) break; - } htc_free_control_tx_packet(target, pPacket); } #endif @@ -302,7 +297,8 @@ HTC_HANDLE htc_create(void *ol_sc, HTC_INIT_INFO *pInfo, qdf_device_t osdev, htcCallbacks.Context = target; htcCallbacks.rxCompletionHandler = htc_rx_completion_handler; htcCallbacks.txCompletionHandler = htc_tx_completion_handler; - htcCallbacks.txResourceAvailHandler = htc_tx_resource_avail_handler; + htcCallbacks.txResourceAvailHandler = + htc_tx_resource_avail_handler; htcCallbacks.fwEventHandler = htc_fw_event_handler; target->hif_dev = ol_sc; @@ -325,6 +321,7 @@ HTC_HANDLE htc_create(void *ol_sc, HTC_INIT_INFO *pInfo, qdf_device_t osdev, void htc_destroy(HTC_HANDLE HTCHandle) { HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle); + AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("+htc_destroy .. Destroying :0x%p\n", target)); hif_stop(htc_get_hif_device(HTCHandle)); @@ -333,19 +330,22 @@ void htc_destroy(HTC_HANDLE HTCHandle) AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("-htc_destroy\n")); } -/* get the low level HIF device for the caller , the caller may wish to do low level - * HIF requests */ +/* get the low level HIF device for the caller , the caller may wish to do low + * level HIF requests + */ void *htc_get_hif_device(HTC_HANDLE HTCHandle) { HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle); + return target->hif_dev; } static void htc_control_tx_complete(void *Context, HTC_PACKET *pPacket) { HTC_TARGET *target = (HTC_TARGET *) Context; + AR_DEBUG_PRINTF(ATH_DEBUG_TRC, - ("+-htc_control_tx_complete 0x%p (l:%d) \n", pPacket, + ("+-htc_control_tx_complete 0x%p (l:%d)\n", pPacket, pPacket->ActualLength)); htc_free_control_tx_packet(target, pPacket); } @@ -363,8 +363,8 @@ static void htc_control_tx_complete(void *Context, HTC_PACKET *pPacket) */ static void htc_setup_epping_credit_allocation(struct hif_opaque_softc *scn, - HTC_SERVICE_TX_CREDIT_ALLOCATION *pEntry, - int credits) + struct htc_service_tx_credit_allocation *pEntry, + int credits) { switch (hif_get_bus_type(scn)) { case QDF_BUS_TYPE_PCI: @@ -384,7 +384,6 @@ htc_setup_epping_credit_allocation(struct hif_opaque_softc *scn, default: break; } - return; } /** @@ -396,15 +395,14 @@ htc_setup_epping_credit_allocation(struct hif_opaque_softc *scn, static A_STATUS htc_setup_target_buffer_assignments(HTC_TARGET *target) { - HTC_SERVICE_TX_CREDIT_ALLOCATION *pEntry; + struct htc_service_tx_credit_allocation *pEntry; A_STATUS status; int credits; int creditsPerMaxMsg; creditsPerMaxMsg = MAX_MESSAGE_SIZE / target->TargetCreditSize; - if (MAX_MESSAGE_SIZE % target->TargetCreditSize) { + if (MAX_MESSAGE_SIZE % target->TargetCreditSize) creditsPerMaxMsg++; - } /* TODO, this should be configured by the caller! */ @@ -423,7 +421,7 @@ A_STATUS htc_setup_target_buffer_assignments(HTC_TARGET *target) pEntry->CreditAllocation = credits; /* endpoint ping is a testing tool directly on top of HTC in * both target and host sides. - * In target side, the endppint ping fw has no wlan stack and the + * In target side, the endppint ping fw has no wlan stack and * FW mboxping app directly sits on HTC and it simply drops * or loops back TX packets. For rx perf, FW mboxping app * generates packets and passes packets to HTC to send to host. @@ -440,9 +438,9 @@ A_STATUS htc_setup_target_buffer_assignments(HTC_TARGET *target) * space through the Ethernet interface. * For credit allocation, in SDIO bus case, only BE service is * used for tx/rx perf testing so that all credits are given - * to BE service. In PCIe and USB bus case, endpoint ping uses both - * BE and BK services to stress the bus so that the total credits - * are equally distributed to BE and BK services. + * to BE service. In PCIe and USB bus case, endpoint ping uses + * both BE and BK services to stress the bus so that the total + * credits are equally distributed to BE and BK services. */ htc_setup_epping_credit_allocation(target->hif_dev, @@ -471,6 +469,7 @@ A_STATUS htc_setup_target_buffer_assignments(HTC_TARGET *target) if (A_SUCCESS(status)) { int i; + for (i = 0; i < HTC_MAX_SERVICE_ALLOC_ENTRIES; i++) { if (target->ServiceTxAllocTable[i].service_id != 0) { AR_DEBUG_PRINTF(ATH_DEBUG_INIT, @@ -513,8 +512,8 @@ A_STATUS htc_wait_target(HTC_HANDLE HTCHandle) A_STATUS status = A_OK; HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle); HTC_READY_EX_MSG *pReadyMsg; - HTC_SERVICE_CONNECT_REQ connect; - HTC_SERVICE_CONNECT_RESP resp; + struct htc_service_connect_req connect; + struct htc_service_connect_resp resp; HTC_READY_MSG *rdy_msg; uint16_t htc_rdy_msg_id; uint8_t i = 0; @@ -528,19 +527,19 @@ A_STATUS htc_wait_target(HTC_HANDLE HTCHandle) status = hif_start(target->hif_dev); if (A_FAILED(status)) { - AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("hif_start failed\n")); + AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, + ("hif_start failed\n")); break; } status = htc_wait_recv_ctrl_message(target); - if (A_FAILED(status)) { + if (A_FAILED(status)) break; - } if (target->CtrlResponseLength < (sizeof(HTC_READY_EX_MSG))) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, - ("Invalid HTC Ready Msg Len:%d! \n", + ("Invalid HTC Ready Msg Len:%d!\n", target->CtrlResponseLength)); status = A_ECOMM; break; @@ -553,7 +552,7 @@ A_STATUS htc_wait_target(HTC_HANDLE HTCHandle) HTC_GET_FIELD(rdy_msg, HTC_READY_MSG, MESSAGEID); if (htc_rdy_msg_id != HTC_MSG_READY_ID) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, - ("Invalid HTC Ready Msg : 0x%X ! \n", + ("Invalid HTC Ready Msg : 0x%X!\n", htc_rdy_msg_id)); status = A_ECOMM; break; @@ -565,8 +564,9 @@ A_STATUS htc_wait_target(HTC_HANDLE HTCHandle) (int)HTC_GET_FIELD(rdy_msg, HTC_READY_MSG, CREDITSIZE); target->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 */ + /* for old fw this value is set to 0. But the minimum value + * should be 1, i.e., no bundling + */ if (target->MaxMsgsPerHTCBundle < 1) target->MaxMsgsPerHTCBundle = 1; @@ -619,7 +619,8 @@ A_STATUS htc_wait_target(HTC_HANDLE HTCHandle) } while (false); - AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("htc_wait_target - Exit (%d)\n", status)); + AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("htc_wait_target - Exit (%d)\n", + status)); AR_DEBUG_PRINTF(ATH_DEBUG_ANY, ("-HWT\n")); return status; } @@ -703,7 +704,8 @@ A_STATUS htc_start(HTC_HANDLE HTCHandle) } if ((hif_get_bus_type(target->hif_dev) == QDF_BUS_TYPE_SDIO) || - (hif_get_bus_type(target->hif_dev) == QDF_BUS_TYPE_USB)) { + (hif_get_bus_type(target->hif_dev) == + QDF_BUS_TYPE_USB)) { if (HTC_RX_BUNDLE_ENABLED(target)) pSetupComp->SetupFlags |= HTC_SETUP_COMPLETE_FLAGS_ENABLE_BUNDLE_RECV; @@ -718,10 +720,8 @@ A_STATUS htc_start(HTC_HANDLE HTCHandle) ENDPOINT_0, HTC_SERVICE_TX_PACKET_TAG); status = htc_send_pkt((HTC_HANDLE) target, pSendPacket); - if (A_FAILED(status)) { + if (A_FAILED(status)) break; - } - } while (false); AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("htc_start Exit\n")); @@ -760,10 +760,12 @@ void htc_flush_surprise_remove(HTC_HANDLE HTCHandle) reset_endpoint_states(target); - AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("-htc_flush_surprise_remove \n")); + AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("-htc_flush_surprise_remove\n")); } -/* stop HTC communications, i.e. stop interrupt reception, and flush all queued buffers */ +/* stop HTC communications, i.e. stop interrupt reception, and flush all queued + * buffers + */ void htc_stop(HTC_HANDLE HTCHandle) { HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle); @@ -836,14 +838,14 @@ void htc_dump_credit_states(HTC_HANDLE HTCHandle) (" TxQueueDepth : %d\n", HTC_PACKET_QUEUE_DEPTH(&pEndpoint->TxQueue))); AR_DEBUG_PRINTF(ATH_DEBUG_ANY, - ("----------------------------------------------------\n")); + ("----------------------------------------\n")); } } bool htc_get_endpoint_statistics(HTC_HANDLE HTCHandle, HTC_ENDPOINT_ID Endpoint, - HTC_ENDPOINT_STAT_ACTION Action, - HTC_ENDPOINT_STATS *pStats) + enum htc_endpoint_stat_action Action, + struct htc_endpoint_stats *pStats) { #ifdef HTC_EP_STAT_PROFILING HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle); @@ -875,13 +877,13 @@ bool htc_get_endpoint_statistics(HTC_HANDLE HTCHandle, A_ASSERT(pStats != NULL); /* return the stats to the caller */ qdf_mem_copy(pStats, &target->endpoint[Endpoint].endpoint_stats, - sizeof(HTC_ENDPOINT_STATS)); + sizeof(struct htc_endpoint_stats)); } if (clearStats) { /* reset stats */ qdf_mem_zero(&target->endpoint[Endpoint].endpoint_stats, - sizeof(HTC_ENDPOINT_STATS)); + sizeof(struct htc_endpoint_stats)); } UNLOCK_HTC_RX(target); diff --git a/htc/htc_api.h b/htc/htc_api.h index 14488e4260..bcee5393cb 100644 --- a/htc/htc_api.h +++ b/htc/htc_api.h @@ -53,13 +53,13 @@ typedef uint16_t HTC_SERVICE_ID; typedef void (*HTC_TARGET_FAILURE)(void *Instance, QDF_STATUS Status); -typedef struct _HTC_INIT_INFO { +struct htc_init_info { void *pContext; /* context for target notifications */ void (*TargetFailure)(void *Instance, QDF_STATUS Status); void (*TargetSendSuspendComplete)(void *ctx, bool is_nack); void (*target_initial_wakeup_cb)(void *cb_ctx); void *target_psoc; -} HTC_INIT_INFO; +}; /* Struct for HTC layer packet stats*/ struct ol_ath_htc_stats { @@ -74,157 +74,216 @@ typedef void (*HTC_EP_RESUME_TX_QUEUE)(void *); /* per service connection send completion */ typedef void (*HTC_EP_SEND_PKT_COMPLETE)(void *, HTC_PACKET *); /* per service connection callback when a plurality of packets have been sent - * The HTC_PACKET_QUEUE is a temporary queue object (e.g. freed on return from the callback) - * to hold a list of completed send packets. - * If the handler cannot fully traverse the packet queue before returning, it should - * transfer the items of the queue into the caller's private queue using: - * HTC_PACKET_ENQUEUE() */ + * The HTC_PACKET_QUEUE is a temporary queue object (e.g. freed on return from + * the callback) to hold a list of completed send packets. + * If the handler cannot fully traverse the packet queue before returning, it + * should transfer the items of the queue into the caller's private queue using: + * HTC_PACKET_ENQUEUE() + */ typedef void (*HTC_EP_SEND_PKT_COMP_MULTIPLE)(void *, HTC_PACKET_QUEUE *); /* per service connection pkt received */ typedef void (*HTC_EP_RECV_PKT)(void *, HTC_PACKET *); /* per service connection callback when a plurality of packets are received - * The HTC_PACKET_QUEUE is a temporary queue object (e.g. freed on return from the callback) - * to hold a list of recv packets. - * If the handler cannot fully traverse the packet queue before returning, it should - * transfer the items of the queue into the caller's private queue using: - * HTC_PACKET_ENQUEUE() */ + * The HTC_PACKET_QUEUE is a temporary queue object (e.g. freed on return from + * the callback) to hold a list of recv packets. + * If the handler cannot fully traverse the packet queue before returning, it + * should transfer the items of the queue into the caller's private queue using: + * HTC_PACKET_ENQUEUE() + */ typedef void (*HTC_EP_RECV_PKT_MULTIPLE)(void *, HTC_PACKET_QUEUE *); /* Optional per service connection receive buffer re-fill callback, - * On some OSes (like Linux) packets are allocated from a global pool and indicated up - * to the network stack. The driver never gets the packets back from the OS. For these OSes - * a refill callback can be used to allocate and re-queue buffers into HTC. + * On some OSes (like Linux) packets are allocated from a global pool and + * indicated up to the network stack. The driver never gets the packets back + * from the OS. For these OSes a refill callback can be used to allocate and + * re-queue buffers into HTC. * - * On other OSes, the network stack can call into the driver's OS-specifc "return_packet" handler and - * the driver can re-queue these buffers into HTC. In this regard a refill callback is - * unnecessary */ + * On other OSes, the network stack can call into the driver's OS-specific + * "return_packet" handler and the driver can re-queue these buffers into HTC. + * In this regard a refill callback is unnecessary + */ typedef void (*HTC_EP_RECV_REFILL)(void *, HTC_ENDPOINT_ID Endpoint); /* Optional per service connection receive buffer allocation callback. - * On some systems packet buffers are an extremely limited resource. Rather than + * On some systems packet buffers are an extremely limited resource. Rather than * queue largest-possible-sized buffers to HTC, some systems would rather * allocate a specific size as the packet is received. The trade off is * slightly more processing (callback invoked for each RX packet) * for the benefit of committing fewer buffer resources into HTC. * - * The callback is provided the length of the pending packet to fetch. This includes the - * HTC header length plus the length of payload. The callback can return a pointer to - * the allocated HTC packet for immediate use. + * The callback is provided the length of the pending packet to fetch. This + * includes the HTC header length plus the length of payload. The callback can + * return a pointer to the allocated HTC packet for immediate use. * - * Alternatively a variant of this handler can be used to allocate large receive packets as needed. - * For example an application can use the refill mechanism for normal packets and the recv-alloc mechanism to - * handle the case where a large packet buffer is required. This can significantly reduce the + * Alternatively a variant of this handler can be used to allocate large receive + * packets as needed. For example an application can use the refill mechanism + * for normal packets and the recv-alloc mechanism to handle the case where a + * large packet buffer is required. This can significantly reduce the * amount of "committed" memory used to receive packets. - * - * */ + */ typedef HTC_PACKET *(*HTC_EP_RECV_ALLOC)(void *, HTC_ENDPOINT_ID Endpoint, int Length); -typedef enum _HTC_SEND_FULL_ACTION { - HTC_SEND_FULL_KEEP = 0, /* packet that overflowed should be kept in the queue */ - HTC_SEND_FULL_DROP = 1, /* packet that overflowed should be dropped */ -} HTC_SEND_FULL_ACTION; +enum htc_send_full_action { + /* packet that overflowed should be kept in the queue */ + HTC_SEND_FULL_KEEP = 0, + /* packet that overflowed should be dropped */ + HTC_SEND_FULL_DROP = 1, +}; -/* Optional per service connection callback when a send queue is full. This can occur if the - * host continues queueing up TX packets faster than credits can arrive - * To prevent the host (on some Oses like Linux) from continuously queueing packets +/* Optional per service connection callback when a send queue is full. This can + * occur if host continues queueing up TX packets faster than credits can arrive + * To prevent the host (on some Oses like Linux) from continuously queueing pkts * and consuming resources, this callback is provided so that that the host * can disable TX in the subsystem (i.e. network stack). - * This callback is invoked for each packet that "overflows" the HTC queue. The callback can - * determine whether the new packet that overflowed the queue can be kept (HTC_SEND_FULL_KEEP) or - * dropped (HTC_SEND_FULL_DROP). If a packet is dropped, the EpTxComplete handler will be called - * and the packet's status field will be set to A_NO_RESOURCE. - * Other OSes require a "per-packet" indication for each completed TX packet, this - * closed loop mechanism will prevent the network stack from overunning the NIC - * The packet to keep or drop is passed for inspection to the registered handler the handler - * must ONLY inspect the packet, it may not free or reclaim the packet. */ -typedef HTC_SEND_FULL_ACTION (*HTC_EP_SEND_QUEUE_FULL)(void *, - HTC_PACKET * - pPacket); + * This callback is invoked for each packet that "overflows" the HTC queue. The + * callback can determine whether the new packet that overflowed the queue can + * be kept (HTC_SEND_FULL_KEEP) or dropped (HTC_SEND_FULL_DROP). If a packet is + * dropped, the EpTxComplete handler will be called and the packet's status + * field will be set to A_NO_RESOURCE. + * Other OSes require a "per-packet" indication for each completed TX packet, + * this closed loop mechanism will prevent the network stack from overunning the + * NIC. The packet to keep or drop is passed for inspection to the registered + * handler the handler must ONLY inspect the packet, it may not free or reclaim + * the packet. + */ +typedef enum htc_send_full_action (*HTC_EP_SEND_QUEUE_FULL)(void *, + HTC_PACKET *pPacket); -typedef struct _HTC_EP_CALLBACKS { - void *pContext; /* context for each callback */ - HTC_EP_SEND_PKT_COMPLETE EpTxComplete; /* tx completion callback for connected endpoint */ - HTC_EP_RECV_PKT EpRecv; /* receive callback for connected endpoint */ - HTC_EP_RECV_REFILL EpRecvRefill; /* OPTIONAL receive re-fill callback for connected endpoint */ - HTC_EP_SEND_QUEUE_FULL EpSendFull; /* OPTIONAL send full callback */ - HTC_EP_RECV_ALLOC EpRecvAlloc; /* OPTIONAL recv allocation callback */ - HTC_EP_RECV_ALLOC EpRecvAllocThresh; /* OPTIONAL recv allocation callback based on a threshold */ - HTC_EP_SEND_PKT_COMP_MULTIPLE EpTxCompleteMultiple; /* OPTIONAL completion handler for multiple complete - indications (EpTxComplete must be NULL) */ - HTC_EP_RECV_PKT_MULTIPLE EpRecvPktMultiple; /* OPTIONAL completion handler for multiple - recv packet indications (EpRecv must be NULL) */ +struct htc_ep_callbacks { + /* context for each callback */ + void *pContext; + /* tx completion callback for connected endpoint */ + HTC_EP_SEND_PKT_COMPLETE EpTxComplete; + /* receive callback for connected endpoint */ + HTC_EP_RECV_PKT EpRecv; + /* OPTIONAL receive re-fill callback for connected endpoint */ + HTC_EP_RECV_REFILL EpRecvRefill; + /* OPTIONAL send full callback */ + HTC_EP_SEND_QUEUE_FULL EpSendFull; + /* OPTIONAL recv allocation callback */ + HTC_EP_RECV_ALLOC EpRecvAlloc; + /* OPTIONAL recv allocation callback based on a threshold */ + HTC_EP_RECV_ALLOC EpRecvAllocThresh; + /* OPTIONAL completion handler for multiple complete + * indications (EpTxComplete must be NULL) + */ + HTC_EP_SEND_PKT_COMP_MULTIPLE EpTxCompleteMultiple; + /* OPTIONAL completion handler for multiple + * recv packet indications (EpRecv must be NULL) + */ + HTC_EP_RECV_PKT_MULTIPLE EpRecvPktMultiple; HTC_EP_RESUME_TX_QUEUE ep_resume_tx_queue; - int RecvAllocThreshold; /* if EpRecvAllocThresh is non-NULL, HTC will compare the - threshold value to the current recv packet length and invoke - the EpRecvAllocThresh callback to acquire a packet buffer */ - int RecvRefillWaterMark; /* if a EpRecvRefill handler is provided, this value - can be used to set a trigger refill callback - when the recv queue drops below this value - if set to 0, the refill is only called when packets - are empty */ -} HTC_EP_CALLBACKS; + /* if EpRecvAllocThresh is non-NULL, HTC will compare the + * threshold value to the current recv packet length and invoke + * the EpRecvAllocThresh callback to acquire a packet buffer + */ + int RecvAllocThreshold; + /* if a EpRecvRefill handler is provided, this value + * can be used to set a trigger refill callback + * when the recv queue drops below this value + * if set to 0, the refill is only called when packets + * are empty + */ + int RecvRefillWaterMark; + +}; /* service connection information */ -typedef struct _HTC_SERVICE_CONNECT_REQ { - HTC_SERVICE_ID service_id; /* service ID to connect to */ - 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 */ - 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; +struct htc_service_connect_req { + /* service ID to connect to */ + HTC_SERVICE_ID service_id; + /* connection flags, see htc protocol definition */ + uint16_t ConnectionFlags; + /* ptr to optional service-specific meta-data */ + uint8_t *pMetaData; + /* optional meta data length */ + uint8_t MetaDataLength; + /* endpoint callbacks */ + struct htc_ep_callbacks EpCallbacks; + /* maximum depth of any send queue */ + int MaxSendQueueDepth; + /* HTC flags for the host-side (local) connection */ + uint32_t LocalConnectionFlags; + /* override max message size in send direction */ + unsigned int MaxSendMsgSize; +}; -#define HTC_LOCAL_CONN_FLAGS_ENABLE_SEND_BUNDLE_PADDING (1 << 0) /* enable send bundle padding for this endpoint */ +/* enable send bundle padding for this endpoint */ +#define HTC_LOCAL_CONN_FLAGS_ENABLE_SEND_BUNDLE_PADDING (1 << 0) /* service connection response information */ -typedef struct _HTC_SERVICE_CONNECT_RESP { - 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 */ - uint8_t ConnectRespCode; /* connect response code from target */ -} HTC_SERVICE_CONNECT_RESP; +struct htc_service_connect_resp { + /* caller supplied buffer to optional meta-data */ + uint8_t *pMetaData; + /* length of caller supplied buffer */ + uint8_t BufferLength; + /* actual length of meta data */ + uint8_t ActualLength; + /* endpoint to communicate over */ + HTC_ENDPOINT_ID Endpoint; + /* max length of all messages over this endpoint */ + unsigned int MaxMsgLength; + /* connect response code from target */ + uint8_t ConnectRespCode; +}; /* endpoint distribution structure */ -typedef struct _HTC_ENDPOINT_CREDIT_DIST { - struct _HTC_ENDPOINT_CREDIT_DIST *pNext; - 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) */ - 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 - is only relevant to the credit distribution function */ - int TxCreditsMin; /* floor for credit distribution, this field is - only relevant to the credit distribution function */ - int TxCreditsAssigned; /* number of credits assigned to this EP, this field - is only relevant to the credit dist function */ - int TxCredits; /* current credits available, this field is used by - HTC to determine whether a message can be sent or - must be queued */ - int TxCreditsToDist; /* pending credits to distribute on this endpoint, this - is set by HTC when credit reports arrive. - The credit distribution functions sets this to zero - when it distributes the credits */ - int TxCreditsSeek; /* this is the number of credits that the current pending TX - packet needs to transmit. This is set by HTC when - and endpoint needs credits in order to transmit */ - int TxCreditSize; /* size in bytes of each credit (set by HTC) */ - int TxCreditsPerMaxMsg; /* credits required for a maximum sized messages (set by HTC) */ - void *pHTCReserved; /* reserved for HTC use */ - int TxQueueDepth; /* current depth of TX queue , i.e. messages waiting for credits - This field is valid only when HTC_CREDIT_DIST_ACTIVITY_CHANGE - or HTC_CREDIT_DIST_SEND_COMPLETE is indicated on an endpoint - that has non-zero credits to recover - */ -} HTC_ENDPOINT_CREDIT_DIST; +struct htc_endpoint_credit_dist { + struct _htc_endpoint_credit_dist *pNext; + struct _htc_endpoint_credit_dist *pPrev; + /* Service ID (set by HTC) */ + HTC_SERVICE_ID service_id; + /* endpoint for this distribution struct (set by HTC) */ + HTC_ENDPOINT_ID Endpoint; + /* distribution flags, distribution function can + * set default activity using SET_EP_ACTIVE() macro + */ + uint32_t DistFlags; + /* credits for normal operation, anything above this + * indicates the endpoint is over-subscribed, this field + * is only relevant to the credit distribution function + */ + int TxCreditsNorm; + /* floor for credit distribution, this field is + * only relevant to the credit distribution function + */ + int TxCreditsMin; + /* number of credits assigned to this EP, this field + * is only relevant to the credit dist function + */ + int TxCreditsAssigned; + /* current credits available, this field is used by + * HTC to determine whether a message can be sent or + * must be queued + */ + int TxCredits; + /* pending credits to distribute on this endpoint, this + * is set by HTC when credit reports arrive. + * The credit distribution functions sets this to zero + * when it distributes the credits + */ + int TxCreditsToDist; + /* this is the number of credits that the current pending TX + * packet needs to transmit. This is set by HTC when + * and endpoint needs credits in order to transmit + */ + int TxCreditsSeek; + /* size in bytes of each credit (set by HTC) */ + int TxCreditSize; + /* credits required for a maximum sized messages (set by HTC) */ + int TxCreditsPerMaxMsg; + /* reserved for HTC use */ + void *pHTCReserved; + /* current depth of TX queue , i.e. messages waiting for credits + * This field is valid only when HTC_CREDIT_DIST_ACTIVITY_CHANGE + * or HTC_CREDIT_DIST_SEND_COMPLETE is indicated on an endpoint + * that has non-zero credits to recover + */ + int TxQueueDepth; +}; #define HTC_EP_ACTIVE ((uint32_t) (1u << 31)) @@ -234,218 +293,227 @@ typedef struct _HTC_ENDPOINT_CREDIT_DIST { #define SET_EP_ACTIVE(epDist) (epDist)->DistFlags |= HTC_EP_ACTIVE /* credit distibution code that is passed into the distrbution function, - * there are mandatory and optional codes that must be handled */ -typedef enum _HTC_CREDIT_DIST_REASON { - HTC_CREDIT_DIST_SEND_COMPLETE = 0, /* credits available as a result of completed - send operations (MANDATORY) resulting in credit reports */ - HTC_CREDIT_DIST_ACTIVITY_CHANGE = 1, /* a change in endpoint activity occured (OPTIONAL) */ - HTC_CREDIT_DIST_SEEK_CREDITS, /* an endpoint needs to "seek" credits (OPTIONAL) */ - HTC_DUMP_CREDIT_STATE /* for debugging, dump any state information that is kept by - the distribution function */ -} HTC_CREDIT_DIST_REASON; + * there are mandatory and optional codes that must be handled + */ +enum htc_credit_dist_reason { + /* credits available as a result of completed + * send operations (MANDATORY) resulting in credit reports + */ + HTC_CREDIT_DIST_SEND_COMPLETE = 0, + /* a change in endpoint activity occurred (OPTIONAL) */ + HTC_CREDIT_DIST_ACTIVITY_CHANGE = 1, + /* an endpoint needs to "seek" credits (OPTIONAL) */ + HTC_CREDIT_DIST_SEEK_CREDITS, + /* for debugging, dump any state information that is kept by + * the distribution function + */ + HTC_DUMP_CREDIT_STATE +}; typedef void (*HTC_CREDIT_DIST_CALLBACK)(void *Context, - HTC_ENDPOINT_CREDIT_DIST * + struct htc_endpoint_credit_dist * pEPList, - HTC_CREDIT_DIST_REASON + enum htc_credit_dist_reason Reason); typedef void (*HTC_CREDIT_INIT_CALLBACK)(void *Context, - HTC_ENDPOINT_CREDIT_DIST * + struct htc_endpoint_credit_dist * pEPList, int TotalCredits); /* endpoint statistics action */ -typedef enum _HTC_ENDPOINT_STAT_ACTION { - HTC_EP_STAT_SAMPLE = 0, /* only read statistics */ - HTC_EP_STAT_SAMPLE_AND_CLEAR = 1, /* sample and immediately clear statistics */ - HTC_EP_STAT_CLEAR /* clear only */ -} HTC_ENDPOINT_STAT_ACTION; +enum htc_endpoint_stat_action { + /* only read statistics */ + HTC_EP_STAT_SAMPLE = 0, + /* sample and immediately clear statistics */ + HTC_EP_STAT_SAMPLE_AND_CLEAR = 1, + /* clear only */ + HTC_EP_STAT_CLEAR +}; /* endpoint statistics */ -typedef struct _HTC_ENDPOINT_STATS { - 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 */ - 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 */ - 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; +struct htc_endpoint_stats { + /* number of TX packets posted to the endpoint */ + uint32_t TxPosted; + /* number of times the host set the credit-low flag in a send message on + * this endpoint + */ + uint32_t TxCreditLowIndications; + /* running count of total TX packets issued */ + uint32_t TxIssued; + /* running count of TX packets that were issued in bundles */ + uint32_t TxPacketsBundled; + /* running count of TX bundles that were issued */ + uint32_t TxBundles; + /* tx packets that were dropped */ + uint32_t TxDropped; + /* running count of total credit reports received for this endpoint */ + uint32_t TxCreditRpts; + /* credit reports received from this endpoint's RX packets */ + uint32_t TxCreditRptsFromRx; + /* credit reports received from RX packets of other endpoints */ + uint32_t TxCreditRptsFromOther; + /* credit reports received from endpoint 0 RX packets */ + uint32_t TxCreditRptsFromEp0; + /* count of credits received via Rx packets on this endpoint */ + uint32_t TxCreditsFromRx; + /* count of credits received via another endpoint */ + uint32_t TxCreditsFromOther; + /* count of credits received via another endpoint */ + uint32_t TxCreditsFromEp0; + /* count of consummed credits */ + uint32_t TxCreditsConsummed; + /* count of credits returned */ + uint32_t TxCreditsReturned; + /* count of RX packets received */ + uint32_t RxReceived; + /* count of lookahead records + * found in messages received on this endpoint + */ + uint32_t RxLookAheads; + /* count of recv packets received in a bundle */ + uint32_t RxPacketsBundled; + /* count of number of bundled lookaheads */ + uint32_t RxBundleLookAheads; + /* count of the number of bundle indications from the HTC header */ + uint32_t RxBundleIndFromHdr; + /* number of times the recv allocation threshold was hit */ + uint32_t RxAllocThreshHit; + /* total number of bytes */ + uint32_t RxAllocThreshBytes; +}; /* ------ Function Prototypes ------ */ -/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - @desc: Create an instance of HTC over the underlying HIF device - @function name: htc_create - @input: HifDevice - hif device handle, - pInfo - initialization information - osdev - QDF device structure - con_mode - driver connection mode - @output: - @return: HTC_HANDLE on success, NULL on failure - @notes: - @example: - @see also: htc_destroy - +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ -HTC_HANDLE htc_create(void *HifDevice, HTC_INIT_INFO *pInfo, qdf_device_t osdev, - uint32_t con_mode); -/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - @desc: Get the underlying HIF device handle - @function name: htc_get_hif_device - @input: HTCHandle - handle passed into the AddInstance callback - @output: - @return: opaque HIF device handle usable in HIF API calls. - @notes: - @example: - @see also: - +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ -void *htc_get_hif_device(HTC_HANDLE HTCHandle); -/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - @desc: Set credit distribution parameters - @function name: htc_set_credit_distribution - @input: HTCHandle - HTC handle - pCreditDistCont - caller supplied context to pass into distribution functions - CreditDistFunc - Distribution function callback - CreditDistInit - Credit Distribution initialization callback - ServicePriorityOrder - Array containing list of service IDs, lowest index - is highestpriority - ListLength - number of elements in ServicePriorityOrder - @output: - @return: - @notes : The user can set a custom credit distribution function to handle - special requirementsfor each endpoint. A default credit distribution - routine can be used by setting CreditInitFunc to NULL. The default - credit distribution is only provided for simple "fair" credit distribution - without regard to any prioritization. +/** + * htc_create - Create an instance of HTC over the underlying HIF device + * @HifDevice: hif device handle, + * @pInfo: initialization information + * @osdev: QDF device structure + * @con_mode: driver connection mode + * + * Return: HTC_HANDLE on success, NULL on failure + */ +HTC_HANDLE htc_create(void *HifDevice, struct htc_init_info *pInfo, + qdf_device_t osdev, uint32_t con_mode); - @example: - @see also: - +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/** + * htc_get_hif_device - Get the underlying HIF device handle + * @HTCHandle: handle passed into the AddInstance callback + * + * Return: opaque HIF device handle usable in HIF API calls. + */ +void *htc_get_hif_device(HTC_HANDLE HTCHandle); + +/** + * htc_set_credit_distribution - Set credit distribution parameters + * @HTCHandle: HTC handle + * @pCreditDistCont: caller supplied context to pass into distribution functions + * @CreditDistFunc: Distribution function callback + * @CreditDistInit: Credit Distribution initialization callback + * @ServicePriorityOrder: Array containing list of service IDs, lowest index + * @is highestpriority: ListLength - number of elements in ServicePriorityOrder + * + * The user can set a custom credit distribution function to handle + * special requirementsfor each endpoint. A default credit distribution + * routine can be used by setting CreditInitFunc to NULL. The default + * credit distribution is only provided for simple "fair" credit distribution + * without regard to any prioritization. + * Return: None + */ void htc_set_credit_distribution(HTC_HANDLE HTCHandle, void *pCreditDistContext, HTC_CREDIT_DIST_CALLBACK CreditDistFunc, HTC_CREDIT_INIT_CALLBACK CreditInitFunc, HTC_SERVICE_ID ServicePriorityOrder[], int ListLength); -/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - @desc: Wait for the target to indicate the HTC layer is ready - @function name: htc_wait_target - @input: HTCHandle - HTC handle - @output: - @return: - @notes: This API blocks until the target responds with an HTC ready message. - The caller should not connect services until the target has indicated it is - ready. - @example: - @see also: htc_connect_service - +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ -A_STATUS htc_wait_target(HTC_HANDLE HTCHandle); -/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - @desc: Start target service communications - @function name: htc_start - @input: HTCHandle - HTC handle - @output: - @return: - @notes: This API indicates to the target that the service connection phase - is completeand the target can freely start all connected services. This - API should only be called AFTER all service connections have been made. - TCStart will issue a SETUP_COMPLETE message to the target to indicate that - all service connections have been made and the target can start - communicating over the endpoints. - @example: - @see also: htc_connect_service - +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ -A_STATUS htc_start(HTC_HANDLE HTCHandle); -/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - @desc: Add receive packet to HTC - @function name: htc_add_receive_pkt - @input: HTCHandle - HTC handle - pPacket - HTC receive packet to add - @output: - @return: A_OK on success - @notes: user must supply HTC packets for capturing incomming HTC frames. - The caller must initialize each HTC packet using the - SET_HTC_PACKET_INFO_RX_REFILL() macro. - @example: - @see also: - +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ -A_STATUS htc_add_receive_pkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket); -/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - @desc: Connect to an HTC service - @function name: htc_connect_service - @input: HTCHandle - HTC handle - pReq - connection details - @output: pResp - connection response - @return: - @notes: Service connections must be performed before htc_start. - User provides callback handlersfor various endpoint events. - @example: - @see also: htc_start - +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ -A_STATUS htc_connect_service(HTC_HANDLE HTCHandle, - HTC_SERVICE_CONNECT_REQ *pReq, - HTC_SERVICE_CONNECT_RESP *pResp); -/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - @desc: HTC register log dump - @function name: htc_dump - @input: HTCHandle - HTC handle - CmdId - Log command - start - start/print logs - @output: - @return: - @notes: Register logs will be started/printed. - be flushed. - @example: - @see also: - +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + * Wait for the target to indicate the HTC layer is ready + * htc_wait_target + * @HTCHandle - HTC handle + * + * This API blocks until the target responds with an HTC ready message. + * The caller should not connect services until the target has indicated it is + * ready. + * Return: None + */ +A_STATUS htc_wait_target(HTC_HANDLE HTCHandle); + +/** + * htc_start - Start target service communications + * @HTCHandle - HTC handle + * + * This API indicates to the target that the service connection phase + * is completeand the target can freely start all connected services. This + * API should only be called AFTER all service connections have been made. + * TCStart will issue a SETUP_COMPLETE message to the target to indicate that + * all service connections have been made and the target can start + * communicating over the endpoints. + * Return: None + */ +A_STATUS htc_start(HTC_HANDLE HTCHandle); + +/** + * htc_add_receive_pkt - Add receive packet to HTC + * @HTCHandle - HTC handle + * @pPacket - HTC receive packet to add + * + * User must supply HTC packets for capturing incoming HTC frames. + * The caller must initialize each HTC packet using the + * SET_HTC_PACKET_INFO_RX_REFILL() macro. + * Return: A_OK on success + */ +A_STATUS htc_add_receive_pkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket); + +/** + * htc_connect_service - Connect to an HTC service + * @HTCHandle - HTC handle + * @pReq - connection details + * @pResp - connection response + * + * Service connections must be performed before htc_start. + * User provides callback handlersfor various endpoint events. + * Return: None + */ +A_STATUS htc_connect_service(HTC_HANDLE HTCHandle, + struct htc_service_connect_req *pReq, + struct htc_service_connect_resp *pResp); + +/** + * htc_dump - HTC register log dump + * @HTCHandle - HTC handle + * @CmdId - Log command + * @start - start/print logs + * + * Register logs will be started/printed/ be flushed. + * Return: None + */ void htc_dump(HTC_HANDLE HTCHandle, uint8_t CmdId, bool start); -/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - @desc: Send an HTC packet - @function name: htc_send_pkt - @input: HTCHandle - HTC handle - pPacket - packet to send - @output: - @return: A_OK - @notes: Caller must initialize packet using SET_HTC_PACKET_INFO_TX() macro. - This interface is fully asynchronous. On error, HTC SendPkt will - call the registered Endpoint callback to cleanup the packet. - @example: - @see also: htc_flush_endpoint - +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ + +/** + * htc_send_pkt - Send an HTC packet + * @HTCHandle - HTC handle + * @pPacket - packet to send + * + * Caller must initialize packet using SET_HTC_PACKET_INFO_TX() macro. + * This interface is fully asynchronous. On error, HTC SendPkt will + * call the registered Endpoint callback to cleanup the packet. + * Return: A_OK + */ A_STATUS htc_send_pkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket); -/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - @desc: Send an HTC packet containing a tx descriptor and data - @function name: htc_send_data_pkt - @input: HTCHandle - HTC handle - pPacket - packet to send - @output: - @return: A_OK - @notes: Caller must initialize packet using SET_HTC_PACKET_INFO_TX() macro. - Caller must provide headroom in an initial fragment added to the - network buffer to store a HTC_FRAME_HDR. - This interface is fully asynchronous. On error, htc_send_data_pkt will - call the registered Endpoint EpDataTxComplete callback to cleanup - the packet. - @example: - @see also: htc_send_pkt - +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ + +/** + * htc_send_data_pkt - Send an HTC packet containing a tx descriptor and data + * @HTCHandle - HTC handle + * @pPacket - packet to send + * + * Caller must initialize packet using SET_HTC_PACKET_INFO_TX() macro. + * Caller must provide headroom in an initial fragment added to the + * network buffer to store a HTC_FRAME_HDR. + * This interface is fully asynchronous. On error, htc_send_data_pkt will + * call the registered Endpoint EpDataTxComplete callback to cleanup + * the packet. + * Return: A_OK + */ #ifdef ATH_11AC_TXCOMPACT A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, qdf_nbuf_t netbuf, int Epid, int ActualLength); @@ -453,229 +521,188 @@ A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, qdf_nbuf_t netbuf, A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket, uint8_t more_data); #endif /*ATH_11AC_TXCOMPACT */ -/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - @desc: Flush HTC when target is removed surprisely service communications - @function name: htc_flush_surprise_remove - @input: HTCHandle - HTC handle - @output: - @return: - @notes: All receive and pending TX packets will - be flushed. - @example: - @see also: - +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ + +/** + * htc_flush_surprise_remove - Flush HTC when target is removed surprisely + * service communications + * @HTCHandle - HTC handle + * + * All receive and pending TX packets will be flushed. + * Return: None + */ void htc_flush_surprise_remove(HTC_HANDLE HTCHandle); -/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - @desc: Stop HTC service communications - @function name: htc_stop - @input: HTCHandle - HTC handle - @output: - @return: - @notes: HTC communications is halted. All receive and pending TX packets will - be flushed. - @example: - @see also: - +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ + +/** + * htc_stop - Stop HTC service communications + * @HTCHandle - HTC handle + * + * HTC communications is halted. All receive and pending TX packets + * will be flushed. + * Return: None + */ void htc_stop(HTC_HANDLE HTCHandle); -/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - @desc: Destory HTC service - @function name: htc_destroy - @input: HTCHandle - @output: - @return: - @notes: This cleans up all resources allocated by htc_create(). - @example: - @see also: htc_create - +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ + +/** + * htc_destroy - Destroy HTC service + * @HTCHandle - HTC handle + * + * This cleans up all resources allocated by htc_create(). + * Return: None + */ void htc_destroy(HTC_HANDLE HTCHandle); -/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - @desc: Flush pending TX packets - @function name: htc_flush_endpoint - @input: HTCHandle - HTC handle - Endpoint - Endpoint to flush - Tag - flush tag - @output: - @return: - @notes: The Tag parameter is used to selectively flush packets with matching tags. - The value of 0 forces all packets to be flush regardless of tag. - @example: - @see also: htc_send_pkt - +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ + +/** + * htc_flush_endpoint - Flush pending TX packets + * @HTCHandle - HTC handle + * @Endpoint - Endpoint to flush + * @Tag - flush tag + * + * The Tag parameter is used to selectively flush packets with matching + * tags. The value of 0 forces all packets to be flush regardless of tag + * Return: None + */ void htc_flush_endpoint(HTC_HANDLE HTCHandle, HTC_ENDPOINT_ID Endpoint, HTC_TX_TAG Tag); -/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - @desc: Dump credit distribution state - @function name: htc_dump_credit_states - @input: HTCHandle - HTC handle - @output: - @return: - @notes: This dumps all credit distribution information to the debugger - @example: - @see also: - +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/** + * htc_dump_credit_states - Dump credit distribution state + * @HTCHandle - HTC handle + * + * This dumps all credit distribution information to the debugger + * Return: None + */ void htc_dump_credit_states(HTC_HANDLE HTCHandle); -/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - @desc: Indicate a traffic activity change on an endpoint - @function name: htc_indicate_activity_change - @input: HTCHandle - HTC handle - Endpoint - endpoint in which activity has changed - Active - true if active, false if it has become inactive - @output: - @return: - @notes: This triggers the registered credit distribution function to - re-adjust credits for active/inactive endpoints. - @example: - @see also: - +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ + +/** + * htc_indicate_activity_change - Indicate a traffic activity change on an + * endpoint + * @HTCHandle - HTC handle + * @Endpoint - endpoint in which activity has changed + * @Active - true if active, false if it has become inactive + * + * This triggers the registered credit distribution function to + * re-adjust credits for active/inactive endpoints. + * Return: None + */ void htc_indicate_activity_change(HTC_HANDLE HTCHandle, HTC_ENDPOINT_ID Endpoint, bool Active); -/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - @desc: Get endpoint statistics - @function name: htc_get_endpoint_statistics - @input: HTCHandle - HTC handle - Endpoint - Endpoint identifier - Action - action to take with statistics - @output: - pStats - statistics that were sampled (can be NULL if Action is HTC_EP_STAT_CLEAR) - - @return: true if statistics profiling is enabled, otherwise false. - - @notes : Statistics is a compile-time option and this function may return - false if HTC is not compiled with profiling. - - The caller can specify the statistic "action" to take when sampling - the statistics. This includes : - - HTC_EP_STAT_SAMPLE : The pStats structure is filled with the current - values. - HTC_EP_STAT_SAMPLE_AND_CLEAR : The structure is filled and the current - statisticsare cleared. - - HTC_EP_STAT_CLEA : the statistics are cleared, the called can pass a NULL - value forpStats - - @example: - @see also: - +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/** + * htc_get_endpoint_statistics - Get endpoint statistics + * @HTCHandle - HTC handle + * @Endpoint - Endpoint identifier + * @Action - action to take with statistics + * @pStats - statistics that were sampled (can be NULL if Action is + * HTC_EP_STAT_CLEAR) + * + * Statistics is a compile-time option and this function may return + * false if HTC is not compiled with profiling. + * The caller can specify the statistic "action" to take when sampling + * the statistics. This includes : + * HTC_EP_STAT_SAMPLE : The pStats structure is filled with the current + * values. + * HTC_EP_STAT_SAMPLE_AND_CLEAR : The structure is filled and the current + * statisticsare cleared. + * HTC_EP_STAT_CLEA : the statistics are cleared, the called can pass + * a NULL value for pStats + * Return: true if statistics profiling is enabled, otherwise false. + */ bool htc_get_endpoint_statistics(HTC_HANDLE HTCHandle, HTC_ENDPOINT_ID Endpoint, - HTC_ENDPOINT_STAT_ACTION Action, - HTC_ENDPOINT_STATS *pStats); + enum htc_endpoint_stat_action Action, + struct htc_endpoint_stats *pStats); -/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - @desc: Unblock HTC message reception - @function name: htc_unblock_recv - @input: HTCHandle - HTC handle - @output: - @return: - @notes: - HTC will block the receiver if the EpRecvAlloc callback fails to provide a - packet. The caller can use this API to indicate to HTC when resources - (buffers) are available such that the receiver can be unblocked and HTC - may re-attempt fetching the pending message. - - This API is not required if the user uses the EpRecvRefill callback or uses - the HTCAddReceivePacket()API to recycle or provide receive packets to HTC. - - @example: - @see also: - +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/** + * htc_unblock_recv - Unblock HTC message reception + * @HTCHandle - HTC handle + * + * HTC will block the receiver if the EpRecvAlloc callback fails to provide a + * packet. The caller can use this API to indicate to HTC when resources + * (buffers) are available such that the receiver can be unblocked and HTC + * may re-attempt fetching the pending message. + * This API is not required if the user uses the EpRecvRefill callback or uses + * the HTCAddReceivePacket()API to recycle or provide receive packets to HTC. + * Return: None + */ void htc_unblock_recv(HTC_HANDLE HTCHandle); -/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - @desc: send a series of HTC packets - @function name: htc_send_pkts_multiple - @input: HTCHandle - HTC handle - pPktQueue - local queue holding packets to send - @output: - @return: A_OK - @notes: Caller must initialize each packet using SET_HTC_PACKET_INFO_TX() macro. - The queue must only contain packets directed at the same endpoint. - Caller supplies a pointer to an HTC_PACKET_QUEUE structure holding the TX packets in FIFO order. - This API will remove the packets from the pkt queue and place them into the HTC Tx Queue - and bundle messages where possible. - The caller may allocate the pkt queue on the stack to hold the packets. - This interface is fully asynchronous. On error, htc_send_pkts will - call the registered Endpoint callback to cleanup the packet. - @example: - @see also: htc_flush_endpoint - +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/** + * htc_send_pkts_multiple - Send a series of HTC packets + * @HTCHandle - HTC handle + * @pPktQueue - local queue holding packets to send + * + * Caller must initialize each packet using SET_HTC_PACKET_INFO_TX() + * macro. The queue must only contain packets directed at the same + * endpoint. Caller supplies a pointer to an HTC_PACKET_QUEUE structure + * holding the TX packets in FIFO order. This API will remove the + * packets from the pkt queue and place them into the HTC Tx Queue + * and bundle messages where possible. + * The caller may allocate the pkt queue on the stack to hold the pkts. + * This interface is fully asynchronous. On error, htc_send_pkts will + * call the registered Endpoint callback to cleanup the packet. + * Return: A_OK + */ A_STATUS htc_send_pkts_multiple(HTC_HANDLE HTCHandle, HTC_PACKET_QUEUE *pPktQueue); -/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - @desc: Add multiple receive packets to HTC - @function name: htc_add_receive_pkt_multiple - @input: HTCHandle - HTC handle - pPktQueue - HTC receive packet queue holding packets to add - @output: - @return: A_OK on success - @notes: user must supply HTC packets for capturing incomming HTC frames. The caller - must initialize each HTC packet using the SET_HTC_PACKET_INFO_RX_REFILL() - macro. The queue must only contain recv packets for the same endpoint. - Caller supplies a pointer to an HTC_PACKET_QUEUE structure holding the recv packet. - This API will remove the packets from the pkt queue and place them into internal - recv packet list. - The caller may allocate the pkt queue on the stack to hold the packets. - @example: - @see also: - +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/** + * htc_add_receive_pkt_multiple - Add multiple receive packets to HTC + * @HTCHandle - HTC handle + * @pPktQueue - HTC receive packet queue holding packets to add + * + * User must supply HTC packets for capturing incoming HTC frames. + * The caller mmust initialize each HTC packet using the + * SET_HTC_PACKET_INFO_RX_REFILL() macro. The queue must only contain + * recv packets for the same endpoint. Caller supplies a pointer to an + * HTC_PACKET_QUEUE structure holding the recv packet. This API will + * remove the packets from the pkt queue and place them into internal + * recv packet list. + * The caller may allocate the pkt queue on the stack to hold the pkts. + * Return: A_OK on success + */ A_STATUS htc_add_receive_pkt_multiple(HTC_HANDLE HTCHandle, HTC_PACKET_QUEUE *pPktQueue); -/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - @desc: Check if an endpoint is marked active - @function name: htc_is_endpoint_active - @input: HTCHandle - HTC handle - Endpoint - endpoint to check for active state - @output: - @return: returns true if Endpoint is Active - @notes: - @example: - @see also: - +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/** + * htc_is_endpoint_active - Check if an endpoint is marked active + * @HTCHandle - HTC handle + * @Endpoint - endpoint to check for active state + * + * Return: returns true if Endpoint is Active + */ bool htc_is_endpoint_active(HTC_HANDLE HTCHandle, HTC_ENDPOINT_ID Endpoint); -/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - @desc: Set up nodrop pkt flag for mboxping nodrop pkt - @function name: htc_set_nodrop_pkt - @input: HTCHandle - HTC handle - isNodropPkt - indicates whether it is nodrop pkt - @output: - @return: - @notes: - @example: - @see also: - +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/** + * htc_set_nodrop_pkt - Set up nodrop pkt flag for mboxping nodrop pkt + * @HTCHandle - HTC handle + * @isNodropPkt - indicates whether it is nodrop pkt + * + * Return: None + * Return: + * + */ void htc_set_nodrop_pkt(HTC_HANDLE HTCHandle, A_BOOL isNodropPkt); -/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - @desc: Get the number of recv buffers currently queued into an HTC endpoint - @function name: htc_get_num_recv_buffers - @input: HTCHandle - HTC handle - Endpoint - endpoint to check - @output: - @return: returns number of buffers in queue - @notes: - @example: - @see also: - +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/** + * htc_get_num_recv_buffers - Get the number of recv buffers currently queued + * into an HTC endpoint + * @HTCHandle - HTC handle + * @Endpoint - endpoint to check + * + * Return: returns number of buffers in queue + * + */ int htc_get_num_recv_buffers(HTC_HANDLE HTCHandle, HTC_ENDPOINT_ID Endpoint); -/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - @desc: Set the target failure handling callback in HTC layer - @function name: htc_set_target_failure_callback - @input: HTCHandle - HTC handle - Callback - target failure handling callback - @output: - @return: - @notes: - @example: - @see also: - +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +/** + * htc_set_target_failure_callback - Set the target failure handling callback + * in HTC layer + * @HTCHandle - HTC handle + * @Callback - target failure handling callback + * + * Return: None + */ void htc_set_target_failure_callback(HTC_HANDLE HTCHandle, HTC_TARGET_FAILURE Callback); @@ -714,20 +741,20 @@ int htc_get_tx_queue_depth(HTC_HANDLE *htc_handle, HTC_ENDPOINT_ID endpoint_id); void htc_ctrl_msg_cmpl(HTC_HANDLE htc_pdev, HTC_ENDPOINT_ID htc_ep_id); #define HTC_TX_DESC_FILL(_htc_tx_desc, _download_len, _ep_id, _seq_no) \ -do { \ - HTC_WRITE32((_htc_tx_desc), \ - SM((_download_len), HTC_FRAME_HDR_PAYLOADLEN) | \ - SM((_ep_id), HTC_FRAME_HDR_ENDPOINTID)); \ - \ - HTC_WRITE32((uint32_t *)(_htc_tx_desc) + 1, \ - SM((_seq_no), HTC_FRAME_HDR_CONTROLBYTES1));\ +do { \ + HTC_WRITE32((_htc_tx_desc), \ + SM((_download_len), HTC_FRAME_HDR_PAYLOADLEN) | \ + SM((_ep_id), HTC_FRAME_HDR_ENDPOINTID)); \ + HTC_WRITE32((uint32_t *)(_htc_tx_desc) + 1, \ + SM((_seq_no), HTC_FRAME_HDR_CONTROLBYTES1)); \ } while (0) #endif /* WLAN_FEATURE_FASTPATH */ #ifdef __cplusplus } #endif -void htc_get_control_endpoint_tx_host_credits(HTC_HANDLE HTCHandle, int *credit); +void htc_get_control_endpoint_tx_host_credits(HTC_HANDLE HTCHandle, + int *credit); void htc_dump_counter_info(HTC_HANDLE HTCHandle); void *htc_get_targetdef(HTC_HANDLE htc_handle); #ifdef FEATURE_RUNTIME_PM diff --git a/htc/htc_internal.h b/htc/htc_internal.h index 1d5bfc0a68..21ec661e16 100644 --- a/htc/htc_internal.h +++ b/htc/htc_internal.h @@ -69,7 +69,8 @@ extern "C" { #define HTC_PACKET_CONTAINER_ALLOCATION 32 #define NUM_CONTROL_TX_BUFFERS 2 -#define HTC_CONTROL_BUFFER_SIZE (HTC_MAX_CONTROL_MESSAGE_LENGTH + HTC_HDR_LENGTH) +#define HTC_CONTROL_BUFFER_SIZE (HTC_MAX_CONTROL_MESSAGE_LENGTH + \ + HTC_HDR_LENGTH) #define HTC_CONTROL_BUFFER_ALIGN 32 #define HTC_TARGET_RESPONSE_POLL_MS 10 #if !defined(A_SIMOS_DEVHOST) @@ -84,16 +85,16 @@ extern "C" { #define HTC_IS_EPPING_ENABLED(_x) ((_x) == QDF_GLOBAL_EPPING_MODE) -typedef enum { +enum htc_credit_exchange_type { HTC_REQUEST_CREDIT, HTC_PROCESS_CREDIT_REPORT, HTC_SUSPEND_ACK, HTC_SUSPEND_NACK, HTC_INITIAL_WAKE_UP, -} htc_credit_exchange_type; +}; static inline const char* -htc_credit_exchange_type_str(htc_credit_exchange_type type) +htc_credit_exchange_type_str(enum htc_credit_exchange_type type) { switch (type) { case HTC_REQUEST_CREDIT: @@ -111,12 +112,12 @@ htc_credit_exchange_type_str(htc_credit_exchange_type type) } } -typedef struct { - htc_credit_exchange_type type; +struct HTC_CREDIT_HISTORY { + enum htc_credit_exchange_type type; uint64_t time; uint32_t tx_credit; uint32_t htc_tx_queue_depth; -} HTC_CREDIT_HISTORY; +}; typedef struct _HTC_ENDPOINT { HTC_ENDPOINT_ID Id; @@ -126,32 +127,44 @@ typedef struct _HTC_ENDPOINT { */ HTC_SERVICE_ID service_id; - HTC_EP_CALLBACKS EpCallBacks; /* callbacks associated with this endpoint */ - HTC_PACKET_QUEUE TxQueue; /* HTC frame buffer TX queue */ - int MaxTxQueueDepth; /* max depth of the TX queue before we need to - call driver's full handler */ - int MaxMsgLength; /* max length of endpoint message */ + /* callbacks associated with this endpoint */ + struct htc_ep_callbacks EpCallBacks; + /* HTC frame buffer TX queue */ + HTC_PACKET_QUEUE TxQueue; + /* max depth of the TX queue before calling driver's full handler */ + int MaxTxQueueDepth; + /* max length of endpoint message */ + int MaxMsgLength; uint8_t UL_PipeID; uint8_t DL_PipeID; - int ul_is_polled; /* Need to call HIF to get tx completion callbacks? */ + /* Need to call HIF to get tx completion callbacks? */ + int ul_is_polled; qdf_timer_t ul_poll_timer; int ul_poll_timer_active; int ul_outstanding_cnt; - int dl_is_polled; /* Need to call HIF to fetch rx? (Not currently supported.) */ -#if 0 /* not currently supported */ - qdf_timer_t dl_poll_timer; -#endif + /* Need to call HIF to fetch rx? (Not currently supported.) */ + int dl_is_polled; + /* not currently supported */ + /* qdf_timer_t dl_poll_timer; */ - HTC_PACKET_QUEUE TxLookupQueue; /* lookup queue to match netbufs to htc packets */ - HTC_PACKET_QUEUE RxBufferHoldQueue; /* temporary hold queue for back compatibility */ - uint8_t SeqNo; /* TX seq no (helpful) for debugging */ - qdf_atomic_t TxProcessCount; /* serialization */ + /* lookup queue to match netbufs to htc packets */ + HTC_PACKET_QUEUE TxLookupQueue; + /* temporary hold queue for back compatibility */ + HTC_PACKET_QUEUE RxBufferHoldQueue; + /* TX seq no (helpful) for debugging */ + uint8_t SeqNo; + /* serialization */ + qdf_atomic_t TxProcessCount; struct _HTC_TARGET *target; - int TxCredits; /* TX credits available on this endpoint */ - int TxCreditSize; /* size in bytes of each credit (set by HTC) */ - int TxCreditsPerMaxMsg; /* credits required per max message (precalculated) */ + /* TX credits available on this endpoint */ + int TxCredits; + /* size in bytes of each credit (set by HTC) */ + int TxCreditSize; + /* credits required per max message (precalculated) */ + int TxCreditsPerMaxMsg; #ifdef HTC_EP_STAT_PROFILING - HTC_ENDPOINT_STATS endpoint_stats; /* endpoint statistics */ + /* endpoint statistics */ + struct htc_endpoint_stats endpoint_stats; #endif bool TxCreditFlowEnabled; bool async_update; /* packets can be queued asynchronously */ @@ -163,16 +176,17 @@ typedef struct _HTC_ENDPOINT { #define INC_HTC_EP_STAT(p, stat, count) #endif -typedef struct { +struct htc_service_tx_credit_allocation { uint16_t service_id; uint8_t CreditAllocation; -} HTC_SERVICE_TX_CREDIT_ALLOCATION; +}; #define HTC_MAX_SERVICE_ALLOC_ENTRIES 8 /* Error codes for HTC layer packet stats*/ enum ol_ath_htc_pkt_ecodes { - GET_HTC_PKT_Q_FAIL = 0, /* error- get packet at head of HTC_PACKET_Q */ + /* error- get packet at head of HTC_PACKET_Q */ + GET_HTC_PKT_Q_FAIL = 0, HTC_PKT_Q_EMPTY, HTC_SEND_Q_EMPTY }; @@ -186,15 +200,15 @@ typedef struct _HTC_TARGET { qdf_spinlock_t HTCCreditLock; uint32_t HTCStateFlags; void *host_handle; - HTC_INIT_INFO HTCInitInfo; - HTC_PACKET *pHTCPacketStructPool; /* pool of HTC packets */ + struct htc_init_info HTCInitInfo; + HTC_PACKET *pHTCPacketStructPool; /* pool of HTC packets */ HTC_PACKET_QUEUE ControlBufferTXFreeList; uint8_t CtrlResponseBuffer[HTC_MAX_CONTROL_MESSAGE_LENGTH]; int CtrlResponseLength; qdf_event_t ctrl_response_valid; bool CtrlResponseProcessing; int TotalTransmitCredits; - HTC_SERVICE_TX_CREDIT_ALLOCATION + struct htc_service_tx_credit_allocation ServiceTxAllocTable[HTC_MAX_SERVICE_ALLOC_ENTRIES]; int TargetCreditSize; #ifdef RX_SG_SUPPORT @@ -252,21 +266,23 @@ typedef struct _HTC_TARGET { #ifdef RX_SG_SUPPORT #define RESET_RX_SG_CONFIG(_target) \ +do { \ _target->ExpRxSgTotalLen = 0; \ _target->CurRxSgTotalLen = 0; \ - _target->IsRxSgInprogress = false; + _target->IsRxSgInprogress = false; \ +} while (0) #endif #define HTC_STATE_STOPPING (1 << 0) #define HTC_STOPPING(t) ((t)->HTCStateFlags & HTC_STATE_STOPPING) -#define LOCK_HTC(t) qdf_spin_lock_bh(&(t)->HTCLock); -#define UNLOCK_HTC(t) qdf_spin_unlock_bh(&(t)->HTCLock); -#define LOCK_HTC_RX(t) qdf_spin_lock_bh(&(t)->HTCRxLock); -#define UNLOCK_HTC_RX(t) qdf_spin_unlock_bh(&(t)->HTCRxLock); -#define LOCK_HTC_TX(t) qdf_spin_lock_bh(&(t)->HTCTxLock); -#define UNLOCK_HTC_TX(t) qdf_spin_unlock_bh(&(t)->HTCTxLock); -#define LOCK_HTC_CREDIT(t) qdf_spin_lock_bh(&(t)->HTCCreditLock); -#define UNLOCK_HTC_CREDIT(t) qdf_spin_unlock_bh(&(t)->HTCCreditLock); +#define LOCK_HTC(t) qdf_spin_lock_bh(&(t)->HTCLock) +#define UNLOCK_HTC(t) qdf_spin_unlock_bh(&(t)->HTCLock) +#define LOCK_HTC_RX(t) qdf_spin_lock_bh(&(t)->HTCRxLock) +#define UNLOCK_HTC_RX(t) qdf_spin_unlock_bh(&(t)->HTCRxLock) +#define LOCK_HTC_TX(t) qdf_spin_lock_bh(&(t)->HTCTxLock) +#define UNLOCK_HTC_TX(t) qdf_spin_unlock_bh(&(t)->HTCTxLock) +#define LOCK_HTC_CREDIT(t) qdf_spin_lock_bh(&(t)->HTCCreditLock) +#define UNLOCK_HTC_CREDIT(t) qdf_spin_unlock_bh(&(t)->HTCCreditLock) #define GET_HTC_TARGET_FROM_HANDLE(hnd) ((HTC_TARGET *)(hnd)) @@ -278,21 +294,19 @@ typedef struct _HTC_TARGET { #define OL_ATH_HTC_PKT_ERROR_COUNT_INCR(_target, _ecode) \ do { \ if (_ecode == GET_HTC_PKT_Q_FAIL) \ - (_target->htc_pkt_stats.htc_get_pkt_q_fail_count) += 1 \ - ; \ + (_target->htc_pkt_stats.htc_get_pkt_q_fail_count) += 1; \ if (_ecode == HTC_PKT_Q_EMPTY) \ - (_target->htc_pkt_stats.htc_pkt_q_empty_count) += 1 \ - ; \ + (_target->htc_pkt_stats.htc_pkt_q_empty_count) += 1; \ if (_ecode == HTC_SEND_Q_EMPTY) \ - (_target->htc_pkt_stats.htc_send_q_empty_count) += 1 \ - ; \ - } while (0); + (_target->htc_pkt_stats.htc_send_q_empty_count) += 1; \ + } while (0) /* internal HTC functions */ QDF_STATUS htc_rx_completion_handler(void *Context, qdf_nbuf_t netbuf, uint8_t pipeID); QDF_STATUS htc_tx_completion_handler(void *Context, qdf_nbuf_t netbuf, - unsigned int transferID, uint32_t toeplitz_hash_result); + unsigned int transferID, + uint32_t toeplitz_hash_result); HTC_PACKET *allocate_htc_bundle_packet(HTC_TARGET *target); void free_htc_bundle_packet(HTC_TARGET *target, HTC_PACKET *pPacket); @@ -318,7 +332,7 @@ void htc_send_complete_check_cleanup(void *context); void htc_kick_queues(void *context); #endif -void htc_credit_record(htc_credit_exchange_type type, uint32_t tx_credit, +void htc_credit_record(enum htc_credit_exchange_type type, uint32_t tx_credit, uint32_t htc_tx_queue_depth); static inline void htc_send_complete_poll_timer_stop(HTC_ENDPOINT * @@ -336,9 +350,8 @@ static inline void htc_send_complete_poll_timer_start(HTC_ENDPOINT * LOCK_HTC_TX(pEndpoint->target); if (pEndpoint->ul_outstanding_cnt && !pEndpoint->ul_poll_timer_active) { - /* - qdf_timer_start( - &pEndpoint->ul_poll_timer, HTC_POLL_CLEANUP_PERIOD_MS); + /* qdf_timer_start( + * &pEndpoint->ul_poll_timer, HTC_POLL_CLEANUP_PERIOD_MS); */ pEndpoint->ul_poll_timer_active = 1; } diff --git a/htc/htc_packet.h b/htc/htc_packet.h index bb23dcbf3c..5356e4f62d 100644 --- a/htc/htc_packet.h +++ b/htc/htc_packet.h @@ -52,13 +52,21 @@ typedef void (*HTC_PACKET_COMPLETION)(void *, struct _HTC_PACKET *); 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) */ - uint8_t SendFlags; /* send flags (HTC internal) */ - int SeqNo; /* internal seq no for debugging (HTC internal) */ - uint32_t Flags; /* internal use */ -} HTC_TX_PACKET_INFO; +/** + * struct htc_tx_packet_info - HTC TX packet information + * @Tag: tag used to selective flush packets + * @CreditsUsed: number of credits used for this TX packet (HTC internal) + * @SendFlags: send flags (HTC internal) + * @SeqNo: internal seq no for debugging (HTC internal) + * @Flags: Internal use + */ +struct htc_tx_packet_info { + HTC_TX_TAG Tag; + int CreditsUsed; + uint8_t SendFlags; + int SeqNo; + uint32_t Flags; +}; /** * HTC_TX_PACKET_TAG_XXX - #defines for tagging packets for special handling @@ -80,26 +88,51 @@ typedef struct _HTC_TX_PACKET_INFO { #define HTC_TX_PACKET_FLAG_FIXUP_NETBUF (1 << 0) -typedef struct _HTC_RX_PACKET_INFO { - 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; +/** + * struct htc_rx_packet_info - HTC RX Packet information + * @ExpectedHdr: HTC Internal use + * @HTCRxFlags: HTC Internal use + * @IndicationFlags: indication flags set on each RX packet indication + */ +struct htc_rx_packet_info { + uint32_t ExpectedHdr; + uint32_t HTCRxFlags; + uint32_t IndicationFlags; +}; -#define HTC_RX_FLAGS_INDICATE_MORE_PKTS (1 << 0) /* more packets on this endpoint are being fetched */ +/* more packets on this endpoint are being fetched */ +#define HTC_RX_FLAGS_INDICATE_MORE_PKTS (1 << 0) #define HTC_PACKET_MAGIC_COOKIE 0xdeadbeef /* wrapper around endpoint-specific packets */ +/** + * struct _HTC_PACKET - HTC Packet data structure + * @ListLink: double link + * @pPktContext: caller's per packet specific context + * @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 field allows + * the caller to reset pBuffer when it recycles receive packets + * back to HTC + * @pBuffer: payload start (RX/TX) + * @BufferLength: length of buffer + * @ActualLength: actual length of payload + * @Endpoint: endpoint that this packet was sent/recv'd from + * @Status: completion status + * @PktInfo: Packet specific info + * @netbufOrigHeadRoom: Original head room of skb + * @Completion: completion + * @pContext: HTC private completion context + * @pNetBufContext: optimization for network-oriented data, the HTC packet can + * pass the network buffer corresponding to the HTC packet + * lower layers may optimized the transfer knowing this is a + * network buffer + * @magic_cookie: HTC Magic cookie + */ typedef struct _HTC_PACKET { - DL_LIST ListLink; /* double link */ - void *pPktContext; /* caller's per packet specific context */ - - 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 - field allows the caller to reset pBuffer when it - recycles receive packets back to HTC */ + DL_LIST ListLink; + void *pPktContext; + uint8_t *pBufferStart; /* * Pointer to the start of the buffer. In the transmit * direction this points to the start of the payload. In the @@ -107,24 +140,20 @@ 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 */ - 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 */ + uint8_t *pBuffer; + uint32_t BufferLength; + uint32_t ActualLength; + HTC_ENDPOINT_ID Endpoint; + A_STATUS Status; union { - HTC_TX_PACKET_INFO AsTx; /* Tx Packet specific info */ - HTC_RX_PACKET_INFO AsRx; /* Rx Packet specific info */ + struct htc_tx_packet_info AsTx; + struct htc_rx_packet_info AsRx; } PktInfo; - /* the following fields are for internal HTC use */ uint32_t netbufOrigHeadRoom; - HTC_PACKET_COMPLETION Completion; /* completion */ - void *pContext; /* HTC private completion context */ - void *pNetBufContext; /* optimization for network-oriented data, the HTC packet - can pass the network buffer corresponding to the HTC packet - lower layers may optimized the transfer knowing this is - a network buffer */ + HTC_PACKET_COMPLETION Completion; + void *pContext; + void *pNetBufContext; uint32_t magic_cookie; } HTC_PACKET; @@ -167,9 +196,9 @@ typedef struct _HTC_PACKET { } while (0) #define SET_HTC_PACKET_NET_BUF_CONTEXT(p, nb) \ - do { \ - (p)->pNetBufContext = (nb); \ - } while (0) + { \ + (p)->pNetBufContext = (nb); \ + } #define GET_HTC_PACKET_NET_BUF_CONTEXT(p) (p)->pNetBufContext @@ -202,11 +231,11 @@ typedef struct _HTC_PACKET_QUEUE { /* get packet at head without removing it */ static inline HTC_PACKET *htc_get_pkt_at_head(HTC_PACKET_QUEUE *queue) { - if (queue->Depth == 0) { + if (queue->Depth == 0) return NULL; - } - return - A_CONTAINING_STRUCT((DL_LIST_GET_ITEM_AT_HEAD(&queue->QueueHead)), + + return A_CONTAINING_STRUCT((DL_LIST_GET_ITEM_AT_HEAD( + &queue->QueueHead)), HTC_PACKET, ListLink); } @@ -221,6 +250,7 @@ static inline HTC_PACKET *htc_get_pkt_at_head(HTC_PACKET_QUEUE *queue) static inline HTC_PACKET *htc_packet_dequeue(HTC_PACKET_QUEUE *queue) { DL_LIST *pItem = dl_list_remove_item_from_head(&queue->QueueHead); + if (pItem != NULL) { queue->Depth--; return A_CONTAINING_STRUCT(pItem, HTC_PACKET, ListLink); @@ -232,6 +262,7 @@ static inline HTC_PACKET *htc_packet_dequeue(HTC_PACKET_QUEUE *queue) static inline HTC_PACKET *htc_packet_dequeue_tail(HTC_PACKET_QUEUE *queue) { DL_LIST *pItem = dl_list_remove_item_from_tail(&queue->QueueHead); + if (pItem != NULL) { queue->Depth--; return A_CONTAINING_STRUCT(pItem, HTC_PACKET, ListLink); @@ -245,11 +276,12 @@ static inline HTC_PACKET *htc_packet_dequeue_tail(HTC_PACKET_QUEUE *queue) #define HTC_GET_TAG_FROM_PKT(p) (p)->PktInfo.AsTx.Tag /* transfer the packets from one queue to the tail of another queue */ -#define HTC_PACKET_QUEUE_TRANSFER_TO_TAIL(pQDest, pQSrc) \ - { \ - dl_list_transfer_items_to_tail(&(pQDest)->QueueHead, &(pQSrc)->QueueHead); \ - (pQDest)->Depth += (pQSrc)->Depth; \ - (pQSrc)->Depth = 0; \ +#define HTC_PACKET_QUEUE_TRANSFER_TO_TAIL(pQDest, pQSrc) \ + { \ + dl_list_transfer_items_to_tail(&(pQDest)->QueueHead, \ + &(pQSrc)->QueueHead); \ + (pQDest)->Depth += (pQSrc)->Depth; \ + (pQSrc)->Depth = 0; \ } /* @@ -259,10 +291,11 @@ static inline HTC_PACKET *htc_packet_dequeue_tail(HTC_PACKET_QUEUE *queue) * to the concatenated queue. */ #define HTC_PACKET_QUEUE_TRANSFER_TO_HEAD(pQDest, pQSrc) \ - { \ - dl_list_transfer_items_to_head(&(pQDest)->QueueHead, &(pQSrc)->QueueHead); \ - (pQDest)->Depth += (pQSrc)->Depth; \ - (pQSrc)->Depth = 0; \ + { \ + dl_list_transfer_items_to_head(&(pQDest)->QueueHead, \ + &(pQSrc)->QueueHead); \ + (pQDest)->Depth += (pQSrc)->Depth; \ + (pQSrc)->Depth = 0; \ } /* fast version to init and add a single packet to a queue */ @@ -273,9 +306,10 @@ static inline HTC_PACKET *htc_packet_dequeue_tail(HTC_PACKET_QUEUE *queue) } #define HTC_PACKET_QUEUE_ITERATE_ALLOW_REMOVE(pQ, pPTemp) \ - ITERATE_OVER_LIST_ALLOW_REMOVE(&(pQ)->QueueHead, (pPTemp), HTC_PACKET, ListLink) + ITERATE_OVER_LIST_ALLOW_REMOVE(&(pQ)->QueueHead, \ + (pPTemp), HTC_PACKET, ListLink) -#define HTC_PACKET_QUEUE_ITERATE_IS_VALID(pQ) ITERATE_IS_VALID(&(pQ)->QueueHead) +#define HTC_PACKET_QUEUE_ITERATE_IS_VALID(pQ) ITERATE_IS_VALID(&(pQ)->QueueHead) #define HTC_PACKET_QUEUE_ITERATE_RESET(pQ) ITERATE_RESET(&(pQ)->QueueHead) #define HTC_PACKET_QUEUE_ITERATE_END ITERATE_END diff --git a/htc/htc_recv.c b/htc/htc_recv.c index b64f0e70e2..af0d6875df 100644 --- a/htc/htc_recv.c +++ b/htc/htc_recv.c @@ -94,15 +94,16 @@ static void do_recv_completion(HTC_ENDPOINT *pEndpoint, if (pEndpoint->EpCallBacks.EpRecvPktMultiple != NULL) { AR_DEBUG_PRINTF(ATH_DEBUG_RECV, - (" HTC calling ep %d, recv multiple callback (%d pkts) \n", + ("HTC calling ep %d, recv multiple callback (%d pkts)\n", pEndpoint->Id, HTC_PACKET_QUEUE_DEPTH (pQueueToIndicate))); - /* a recv multiple handler is being used, pass the queue to the handler */ - pEndpoint->EpCallBacks.EpRecvPktMultiple(pEndpoint-> - EpCallBacks. - pContext, - pQueueToIndicate); + /* a recv multiple handler is being used, pass the queue + * to the handler + */ + pEndpoint->EpCallBacks.EpRecvPktMultiple( + pEndpoint->EpCallBacks.pContext, + pQueueToIndicate); INIT_HTC_PACKET_QUEUE(pQueueToIndicate); } else { HTC_PACKET *pPacket; @@ -137,6 +138,7 @@ static void recv_packet_completion(HTC_TARGET *target, HTC_ENDPOINT *pEndpoint, HTC_PACKET *pPacket) { HTC_PACKET_QUEUE container; + INIT_HTC_PACKET_QUEUE_AND_ADD(&container, pPacket); /* do completion */ do_recv_completion(pEndpoint, &container); @@ -169,6 +171,7 @@ void htc_disable_recv(HTC_HANDLE HTCHandle) int htc_get_num_recv_buffers(HTC_HANDLE HTCHandle, HTC_ENDPOINT_ID Endpoint) { HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle); + HTC_ENDPOINT *pEndpoint = &target->endpoint[Endpoint]; return HTC_PACKET_QUEUE_DEPTH(&pEndpoint->RxBufferHoldQueue); } @@ -278,7 +281,7 @@ QDF_STATUS htc_rx_completion_handler(void *Context, qdf_nbuf_t netbuf, uint16_t payloadLen; uint32_t trailerlen = 0; uint8_t htc_ep_id; - HTC_INIT_INFO *info; + struct htc_init_info *info; #ifdef RX_SG_SUPPORT LOCK_HTC_RX(target); @@ -314,7 +317,8 @@ QDF_STATUS htc_rx_completion_handler(void *Context, qdf_nbuf_t netbuf, ("HTC Rx: invalid EndpointID=%d\n", htc_ep_id)); debug_dump_bytes((uint8_t *) HtcHdr, - sizeof(HTC_FRAME_HDR), "BAD HTC Header"); + sizeof(HTC_FRAME_HDR), + "BAD HTC Header"); status = QDF_STATUS_E_FAILURE; QDF_BUG(0); break; @@ -325,12 +329,11 @@ QDF_STATUS htc_rx_completion_handler(void *Context, qdf_nbuf_t netbuf, /* * If this endpoint that received a message from the target has * a to-target HIF pipe whose send completions are polled rather - * than interrupt-driven, this is a good point to ask HIF to check - * whether it has any completed sends to handle. + * than interrupt driven, this is a good point to ask HIF to + * check whether it has any completed sends to handle. */ - if (pEndpoint->ul_is_polled) { + if (pEndpoint->ul_is_polled) htc_send_complete_check(pEndpoint, 1); - } payloadLen = HTC_GET_FIELD(HtcHdr, HTC_FRAME_HDR, PAYLOADLEN); @@ -384,12 +387,14 @@ QDF_STATUS htc_rx_completion_handler(void *Context, qdf_nbuf_t netbuf, } trailerlen = temp; - /* process trailer data that follows HDR + application payload */ + /* process trailer data that follows HDR + + * application payload + */ temp_status = htc_process_trailer(target, - ((uint8_t *) HtcHdr + - HTC_HDR_LENGTH + - payloadLen - temp), - temp, htc_ep_id); + ((uint8_t *) HtcHdr + + HTC_HDR_LENGTH + + payloadLen - temp), + temp, htc_ep_id); if (A_FAILED(temp_status)) { status = QDF_STATUS_E_FAILURE; break; @@ -399,7 +404,7 @@ QDF_STATUS htc_rx_completion_handler(void *Context, qdf_nbuf_t netbuf, } if (((int)payloadLen - (int)trailerlen) <= 0) { - /* zero length packet with trailer data, just drop these */ + /* 0 length packet with trailer data, just drop these */ break; } @@ -414,15 +419,17 @@ QDF_STATUS htc_rx_completion_handler(void *Context, qdf_nbuf_t netbuf, netlen = qdf_nbuf_len(netbuf); htc_msg = (HTC_UNKNOWN_MSG *) netdata; - message_id = - HTC_GET_FIELD(htc_msg, HTC_UNKNOWN_MSG, MESSAGEID); + message_id = HTC_GET_FIELD(htc_msg, HTC_UNKNOWN_MSG, + MESSAGEID); switch (message_id) { default: /* handle HTC control message */ if (target->CtrlResponseProcessing) { - /* this is a fatal error, target should not be sending unsolicited messages - * on the endpoint 0 */ + /* this is a fatal error, target should + * not be sending unsolicited messages + * on the endpoint 0 + */ AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("HTC Rx Ctrl still processing\n")); status = QDF_STATUS_E_FAILURE; @@ -496,10 +503,11 @@ QDF_STATUS htc_rx_completion_handler(void *Context, qdf_nbuf_t netbuf, break; } - /* the current message based HIF architecture allocates net bufs for recv packets - * since this layer bridges that HIF to upper layers , which expects HTC packets, - * we form the packets here - * TODO_FIXME */ + /* the current message based HIF architecture allocates net bufs + * for recv packets since this layer bridges that HIF to upper + * layers , which expects HTC packets, we form the packets here + * TODO_FIXME + */ pPacket = allocate_htc_packet_container(target); if (NULL == pPacket) { status = QDF_STATUS_E_RESOURCES; @@ -525,9 +533,8 @@ QDF_STATUS htc_rx_completion_handler(void *Context, qdf_nbuf_t netbuf, _out: #endif - if (netbuf != NULL) { + if (netbuf != NULL) qdf_nbuf_free(netbuf); - } return status; @@ -592,6 +599,7 @@ A_STATUS htc_add_receive_pkt_multiple(HTC_HANDLE HTCHandle, A_STATUS htc_add_receive_pkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket) { HTC_PACKET_QUEUE queue; + INIT_HTC_PACKET_QUEUE_AND_ADD(&queue, pPacket); return htc_add_receive_pkt_multiple(HTCHandle, &queue); } @@ -605,14 +613,13 @@ void htc_flush_rx_hold_queue(HTC_TARGET *target, HTC_ENDPOINT *pEndpoint) while (1) { pPacket = htc_packet_dequeue(&pEndpoint->RxBufferHoldQueue); - if (NULL == pPacket) { + if (pPacket == NULL) break; - } UNLOCK_HTC_RX(target); pPacket->Status = A_ECANCELED; pPacket->ActualLength = 0; AR_DEBUG_PRINTF(ATH_DEBUG_RECV, - (" Flushing RX packet:%p, length:%d, ep:%d \n", + ("Flushing RX packet:%p, length:%d, ep:%d\n", pPacket, pPacket->BufferLength, pPacket->Endpoint)); INIT_HTC_PACKET_QUEUE_AND_ADD(&container, pPacket); @@ -650,32 +657,6 @@ A_STATUS htc_wait_recv_ctrl_message(HTC_TARGET *target) UNLOCK_HTC_RX(target); -#if 0 - while (count > 0) { - - LOCK_HTC_RX(target); - - if (target->CtrlResponseValid) { - target->CtrlResponseValid = false; - /* caller will clear this flag */ - target->CtrlResponseProcessing = true; - UNLOCK_HTC_RX(target); - break; - } - - UNLOCK_HTC_RX(target); - - count--; - A_MSLEEP(HTC_TARGET_RESPONSE_POLL_MS); - } - - if (count <= 0) { - AR_DEBUG_PRINTF(ATH_DEBUG_ERR, - ("-HTCWaitCtrlMessageRecv: Timeout!\n")); - return A_ECOMM; - } -#endif - AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("-HTCWaitCtrlMessageRecv success\n")); return A_OK; } @@ -693,11 +674,10 @@ static A_STATUS htc_process_trailer(HTC_TARGET *target, A_STATUS status; AR_DEBUG_PRINTF(ATH_DEBUG_RECV, - ("+htc_process_trailer (length:%d) \n", Length)); + ("+htc_process_trailer (length:%d)\n", Length)); - if (AR_DEBUG_LVL_CHECK(ATH_DEBUG_RECV)) { + if (AR_DEBUG_LVL_CHECK(ATH_DEBUG_RECV)) AR_DEBUG_PRINTBUF(pBuffer, Length, "Recv Trailer"); - } pOrigBuffer = pBuffer; origLength = Length; @@ -720,7 +700,7 @@ static A_STATUS htc_process_trailer(HTC_TARGET *target, if (htc_rec_len > Length) { /* no room left in buffer for record */ AR_DEBUG_PRINTF(ATH_DEBUG_ERR, - (" invalid record length: %d (id:%d) buffer has: %d bytes left \n", + ("invalid record length: %d (id:%d) buffer has: %d bytes left\n", htc_rec_len, htc_rec_id, Length)); status = A_EPROTO; break; @@ -751,7 +731,7 @@ static A_STATUS htc_process_trailer(HTC_TARGET *target, default: AR_DEBUG_PRINTF(ATH_DEBUG_ERR, - (" HTC unhandled record: id:%d length:%d \n", + ("HTC unhandled record: id:%d length:%d\n", htc_rec_id, htc_rec_len)); break; } @@ -765,11 +745,10 @@ static A_STATUS htc_process_trailer(HTC_TARGET *target, Length -= htc_rec_len; } - if (A_FAILED(status)) { + if (A_FAILED(status)) debug_dump_bytes(pOrigBuffer, origLength, "BAD Recv Trailer"); - } - AR_DEBUG_PRINTF(ATH_DEBUG_RECV, ("-htc_process_trailer \n")); + AR_DEBUG_PRINTF(ATH_DEBUG_RECV, ("-htc_process_trailer\n")); return status; } diff --git a/htc/htc_send.c b/htc/htc_send.c index 3b82ac3a8a..38e46a17e9 100644 --- a/htc/htc_send.c +++ b/htc/htc_send.c @@ -38,10 +38,10 @@ #define HTC_DATA_RESOURCE_THRS 256 #define HTC_DATA_MINDESC_PERPACKET 2 -typedef enum _HTC_SEND_QUEUE_RESULT { +enum HTC_SEND_QUEUE_RESULT { HTC_SEND_QUEUE_OK = 0, /* packet was queued */ - HTC_SEND_QUEUE_DROP = 1, /* this packet should be dropped */ -} HTC_SEND_QUEUE_RESULT; + HTC_SEND_QUEUE_DROP = 1, /* this packet should be dropped */ +}; #ifndef DEBUG_CREDIT #define DEBUG_CREDIT 0 @@ -49,14 +49,14 @@ typedef enum _HTC_SEND_QUEUE_RESULT { #if DEBUG_CREDIT /* bit mask to enable debug certain endpoint */ -static unsigned ep_debug_mask = +static unsigned int ep_debug_mask = (1 << ENDPOINT_0) | (1 << ENDPOINT_1) | (1 << ENDPOINT_2); #endif /* HTC Control Path Credit History */ -uint32_t g_htc_credit_history_idx = 0; +uint32_t g_htc_credit_history_idx; uint32_t g_htc_credit_history_length; -HTC_CREDIT_HISTORY htc_credit_history_buffer[HTC_CREDIT_HISTORY_MAX]; +struct HTC_CREDIT_HISTORY htc_credit_history_buffer[HTC_CREDIT_HISTORY_MAX]; /** * htc_credit_record() - records tx que state & credit transactions @@ -72,9 +72,9 @@ HTC_CREDIT_HISTORY htc_credit_history_buffer[HTC_CREDIT_HISTORY_MAX]; * Consider making this function accept an HTC_ENDPOINT and find the current * credits and queue depth itself. * - * Consider moving the LOCK_HTC_CREDIT(target); logic into this function as well. + * Consider moving the LOCK_HTC_CREDIT(target); logic into this func as well */ -void htc_credit_record(htc_credit_exchange_type type, uint32_t tx_credit, +void htc_credit_record(enum htc_credit_exchange_type type, uint32_t tx_credit, uint32_t htc_tx_queue_depth) { if (HTC_CREDIT_HISTORY_MAX <= g_htc_credit_history_idx) g_htc_credit_history_idx = 0; @@ -113,7 +113,8 @@ void htc_print_credit_history(HTC_HANDLE htc, uint32_t count, print(print_priv, "Time (seconds) Type Credits Queue Depth"); while (count) { - HTC_CREDIT_HISTORY *hist = &htc_credit_history_buffer[idx]; + struct HTC_CREDIT_HISTORY *hist = + &htc_credit_history_buffer[idx]; uint64_t secs, usecs; qdf_log_timestamp_to_secs(hist->time, &secs, &usecs); @@ -151,7 +152,8 @@ int htc_get_tx_queue_depth(HTC_HANDLE *htc_handle, HTC_ENDPOINT_ID endpoint_id) return HTC_PACKET_QUEUE_DEPTH(&endpoint->TxQueue); } -void htc_get_control_endpoint_tx_host_credits(HTC_HANDLE HTCHandle, int *credits) +void htc_get_control_endpoint_tx_host_credits(HTC_HANDLE HTCHandle, + int *credits) { HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle); HTC_ENDPOINT *pEndpoint; @@ -178,6 +180,7 @@ static inline void restore_tx_packet(HTC_TARGET *target, HTC_PACKET *pPacket) { if (pPacket->PktInfo.AsTx.Flags & HTC_TX_PACKET_FLAG_FIXUP_NETBUF) { qdf_nbuf_t netbuf = GET_HTC_PACKET_NET_BUF_CONTEXT(pPacket); + qdf_nbuf_unmap(target->osdev, netbuf, QDF_DMA_TO_DEVICE); qdf_nbuf_pull_head(netbuf, sizeof(HTC_FRAME_HDR)); pPacket->PktInfo.AsTx.Flags &= ~HTC_TX_PACKET_FLAG_FIXUP_NETBUF; @@ -197,16 +200,19 @@ static void do_send_completion(HTC_ENDPOINT *pEndpoint, if (pEndpoint->EpCallBacks.EpTxCompleteMultiple != NULL) { AR_DEBUG_PRINTF(ATH_DEBUG_SEND, - (" HTC calling ep %d, send complete multiple callback (%d pkts) \n", + ("HTC calling ep %d, send complete multiple callback (%d pkts)\n", pEndpoint->Id, HTC_PACKET_QUEUE_DEPTH (pQueueToIndicate))); - /* a multiple send complete handler is being used, pass the queue to the handler */ - pEndpoint->EpCallBacks.EpTxCompleteMultiple(pEndpoint-> - EpCallBacks. - pContext, - pQueueToIndicate); - /* all packets are now owned by the callback, reset queue to be safe */ + /* a multiple send complete handler is being used, pass + * the queue to the handler + */ + pEndpoint->EpCallBacks.EpTxCompleteMultiple( + pEndpoint->EpCallBacks.pContext, + pQueueToIndicate); + /* all packets are now owned by the callback, reset + * queue to be safe + */ INIT_HTC_PACKET_QUEUE(pQueueToIndicate); } else { HTC_PACKET *pPacket; @@ -214,7 +220,7 @@ static void do_send_completion(HTC_ENDPOINT *pEndpoint, do { pPacket = htc_packet_dequeue(pQueueToIndicate); AR_DEBUG_PRINTF(ATH_DEBUG_SEND, - (" HTC calling ep %d send complete callback on packet %p \n", + ("HTC calling ep %d send complete callback on packet %p\n", pEndpoint->Id, pPacket)); pEndpoint->EpCallBacks.EpTxComplete(pEndpoint-> EpCallBacks. @@ -242,6 +248,7 @@ static void send_packet_completion(HTC_TARGET *target, HTC_PACKET *pPacket) void htc_send_complete_check_cleanup(void *context) { HTC_ENDPOINT *pEndpoint = (HTC_ENDPOINT *) context; + htc_send_complete_check(pEndpoint, 1); } @@ -250,6 +257,7 @@ HTC_PACKET *allocate_htc_bundle_packet(HTC_TARGET *target) HTC_PACKET *pPacket; HTC_PACKET_QUEUE *pQueueSave; qdf_nbuf_t netbuf; + LOCK_HTC_TX(target); if (NULL == target->pBundleFreeList) { UNLOCK_HTC_TX(target); @@ -257,9 +265,8 @@ HTC_PACKET *allocate_htc_bundle_packet(HTC_TARGET *target) target->MaxMsgsPerHTCBundle * target->TargetCreditSize, 0, 4, false); AR_DEBUG_ASSERT(netbuf); - if (!netbuf) { + if (!netbuf) return NULL; - } pPacket = qdf_mem_malloc(sizeof(HTC_PACKET)); AR_DEBUG_ASSERT(pPacket); if (!pPacket) { @@ -279,8 +286,10 @@ HTC_PACKET *allocate_htc_bundle_packet(HTC_TARGET *target) pPacket->pBuffer = qdf_nbuf_data(netbuf); pPacket->BufferLength = qdf_nbuf_len(netbuf); - /* store the original head room so that we can restore this when we "free" the packet */ - /* free packet puts the packet back on the free list */ + /* store the original head room so that we can restore this + * when we "free" the packet. + * free packet puts the packet back on the free list + */ pPacket->netbufOrigHeadRoom = qdf_nbuf_headroom(netbuf); return pPacket; } @@ -307,14 +316,16 @@ void free_htc_bundle_packet(HTC_TARGET *target, HTC_PACKET *pPacket) netbuf = GET_HTC_PACKET_NET_BUF_CONTEXT(pPacket); AR_DEBUG_ASSERT(netbuf); if (!netbuf) { - AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("\n%s: Invalid netbuf in HTC " - "Packet\n", __func__)); + AR_DEBUG_PRINTF(ATH_DEBUG_ERR, + ("\n%s: Invalid netbuf in HTC Packet\n", + __func__)); return; } - /* HIF adds data to the headroom section of the nbuf, restore the original */ - /* size. If this is not done, headroom keeps shrinking with every HIF send */ - /* and eventually HIF ends up doing another malloc big enough to store the */ - /* data + its header */ + /* HIF adds data to the headroom section of the nbuf, restore thei + * original size. If this is not done, headroom keeps shrinking with + * every HIF send and eventually HIF ends up doing another malloc big + * enough to store the data + its header + */ curentHeadRoom = qdf_nbuf_headroom(netbuf); qdf_nbuf_pull_head(netbuf, @@ -360,8 +371,6 @@ htc_send_update_tx_bundle_stats(HTC_TARGET *target, { if ((data_len / TxCreditSize) <= HTC_MAX_MSG_PER_BUNDLE_TX) target->tx_bundle_stats[(data_len / TxCreditSize) - 1]++; - - return; } /** @@ -383,13 +392,11 @@ htc_send_update_tx_bundle_stats(HTC_TARGET *target, qdf_size_t data_len, int TxCreditSize) { - return; } static inline void htc_issue_tx_bundle_stats_inc(HTC_TARGET *target) { - return; } #endif @@ -465,7 +472,7 @@ static void htc_issue_packets_bundle(HTC_TARGET *target, if (!pPacketTx) { /* good time to panic */ AR_DEBUG_PRINTF(ATH_DEBUG_ERR, - ("allocate_htc_bundle_packet failed \n")); + ("allocate_htc_bundle_packet failed\n")); AR_DEBUG_ASSERT(false); return; } @@ -474,16 +481,15 @@ static void htc_issue_packets_bundle(HTC_TARGET *target, pQueueSave = (HTC_PACKET_QUEUE *) pPacketTx->pContext; while (1) { pPacket = htc_packet_dequeue(pPktQueue); - if (pPacket == NULL) { + if (pPacket == NULL) break; - } creditPad = 0; transferLength = pPacket->ActualLength + HTC_HDR_LENGTH; creditRemainder = transferLength % pEndpoint->TxCreditSize; if (creditRemainder != 0) { if (transferLength < pEndpoint->TxCreditSize) { - creditPad = - pEndpoint->TxCreditSize - transferLength; + creditPad = pEndpoint->TxCreditSize - + transferLength; } else { creditPad = creditRemainder; } @@ -506,7 +512,7 @@ static void htc_issue_packets_bundle(HTC_TARGET *target, if (!pPacketTx) { /* good time to panic */ AR_DEBUG_PRINTF(ATH_DEBUG_ERR, - ("allocate_htc_bundle_packet failed \n")); + ("allocate_htc_bundle_packet failed\n")); AR_DEBUG_ASSERT(false); return; } @@ -519,9 +525,8 @@ static void htc_issue_packets_bundle(HTC_TARGET *target, netbuf = GET_HTC_PACKET_NET_BUF_CONTEXT(pPacket); if (hif_get_bus_type(target->hif_dev) != QDF_BUS_TYPE_USB) { - pHtcHdr = - (HTC_FRAME_HDR *) - qdf_nbuf_get_frag_vaddr(netbuf, 0); + pHtcHdr = (HTC_FRAME_HDR *)qdf_nbuf_get_frag_vaddr( + netbuf, 0); HTC_WRITE32(pHtcHdr, SM(pPacket->ActualLength, HTC_FRAME_HDR_PAYLOADLEN) | @@ -542,9 +547,8 @@ static void htc_issue_packets_bundle(HTC_TARGET *target, int frag_len = qdf_nbuf_get_frag_len(netbuf, i); unsigned char *frag_addr = qdf_nbuf_get_frag_vaddr(netbuf, i); - if (frag_len > nbytes) { + if (frag_len > nbytes) frag_len = nbytes; - } qdf_mem_copy(pBundleBuffer, frag_addr, frag_len); nbytes -= frag_len; pBundleBuffer += frag_len; @@ -552,20 +556,17 @@ static void htc_issue_packets_bundle(HTC_TARGET *target, HTC_PACKET_ENQUEUE(pQueueSave, pPacket); pBundleBuffer += creditPad; - if (hif_get_bus_type(target->hif_dev) == QDF_BUS_TYPE_USB) { - /* last one can't be packed. */ + /* last one can't be packed. */ + if (hif_get_bus_type(target->hif_dev) == QDF_BUS_TYPE_USB) last_credit_pad = creditPad; - } - } - if (pBundleBuffer != qdf_nbuf_data(bundleBuf)) { - /* send out remaining buffer */ + /* send out remaining buffer */ + if (pBundleBuffer != qdf_nbuf_data(bundleBuf)) htc_send_bundled_netbuf(target, pEndpoint, pBundleBuffer - last_credit_pad, pPacketTx); - } else { + else free_htc_bundle_packet(target, pPacketTx); - } } #endif /* ENABLE_BUNDLE_TX */ #else @@ -600,7 +601,7 @@ static A_STATUS htc_issue_packets(HTC_TARGET *target, bus_type = hif_get_bus_type(target->hif_dev); AR_DEBUG_PRINTF(ATH_DEBUG_SEND, - ("+htc_issue_packets: Queue: %p, Pkts %d \n", pPktQueue, + ("+htc_issue_packets: Queue: %p, Pkts %d\n", pPktQueue, HTC_PACKET_QUEUE_DEPTH(pPktQueue))); while (true) { if (HTC_TX_BUNDLE_ENABLED(target) && @@ -619,8 +620,8 @@ static A_STATUS htc_issue_packets(HTC_TARGET *target, break; } } - /* if not bundling or there was a packet that could not be placed in a bundle, - * and send it by normal way + /* if not bundling or there was a packet that could not be + * placed in a bundle, and send it by normal way */ pPacket = htc_packet_dequeue(pPktQueue); if (NULL == pPacket) { @@ -630,8 +631,8 @@ static A_STATUS htc_issue_packets(HTC_TARGET *target, netbuf = GET_HTC_PACKET_NET_BUF_CONTEXT(pPacket); AR_DEBUG_ASSERT(netbuf); - /* Non-credit enabled endpoints have been mapped and setup by now, - * so no need to revisit the HTC headers + /* Non-credit enabled endpoints have been mapped and setup by + * now, so no need to revisit the HTC headers */ if (IS_TX_CREDIT_FLOW_ENABLED(pEndpoint)) { @@ -643,24 +644,23 @@ static A_STATUS htc_issue_packets(HTC_TARGET *target, AR_DEBUG_ASSERT(pHtcHdr); HTC_WRITE32(pHtcHdr, - SM(payloadLen, - HTC_FRAME_HDR_PAYLOADLEN) | SM(pPacket-> - PktInfo. - AsTx. - SendFlags, - HTC_FRAME_HDR_FLAGS) - | SM(pPacket->Endpoint, - HTC_FRAME_HDR_ENDPOINTID)); + SM(payloadLen, + HTC_FRAME_HDR_PAYLOADLEN) | + SM(pPacket->PktInfo.AsTx.SendFlags, + HTC_FRAME_HDR_FLAGS) | + SM(pPacket->Endpoint, + HTC_FRAME_HDR_ENDPOINTID)); HTC_WRITE32(((uint32_t *) pHtcHdr) + 1, SM(pPacket->PktInfo.AsTx.SeqNo, HTC_FRAME_HDR_CONTROLBYTES1)); /* - * Now that the HTC frame header has been added, the netbuf can be - * mapped. This only applies to non-data frames, since data frames - * were already mapped as they entered into the driver. - * Check the "FIXUP_NETBUF" flag to see whether this is a data netbuf - * that is already mapped, or a non-data netbuf that needs to be + * Now that the HTC frame header has been added, the + * netbuf can be mapped. This only applies to non-data + * frames, since data frames were already mapped as they + * entered into the driver. Check the "FIXUP_NETBUF" + * flag to see whether this is a data netbuf that is + * already mapped, or a non-data netbuf that needs to be * mapped. */ if (pPacket->PktInfo.AsTx. @@ -670,8 +670,8 @@ static A_STATUS htc_issue_packets(HTC_TARGET *target, (pPacket), QDF_DMA_TO_DEVICE); if (ret != QDF_STATUS_SUCCESS) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, - ("%s: nbuf map failed, endpoint %p\n", - __func__, pEndpoint)); + ("%s nbuf Map Fail Endpnt %p\n", + __func__, pEndpoint)); status = A_ERROR; break; } @@ -709,10 +709,13 @@ static A_STATUS htc_issue_packets(HTC_TARGET *target, if (qdf_unlikely(A_FAILED(status))) { if (status != A_NO_RESOURCE) { - /* TODO : if more than 1 endpoint maps to the same PipeID it is possible - * to run out of resources in the HIF layer. Don't emit the error */ + /* TODO : if more than 1 endpoint maps to the + * same PipeID it is possible to run out of + * resources in the HIF layer. Don't emit the + * error + */ AR_DEBUG_PRINTF(ATH_DEBUG_ERR, - ("hif_send Failed status:%d \n", + ("hif_send Failed status:%d\n", status)); } if (!pEndpoint->async_update) { @@ -747,7 +750,7 @@ static A_STATUS htc_issue_packets(HTC_TARGET *target, pPacket, status)); } - AR_DEBUG_PRINTF(ATH_DEBUG_SEND, ("-htc_issue_packets \n")); + AR_DEBUG_PRINTF(ATH_DEBUG_SEND, ("-htc_issue_packets\n")); return status; } @@ -829,8 +832,9 @@ static void get_htc_send_packets_credit_based(HTC_TARGET *target, HTC_PACKET_QUEUE pm_queue; bool do_pm_get = false; - /****** NOTE : the TX lock is held when this function is called *****************/ - AR_DEBUG_PRINTF(ATH_DEBUG_SEND, ("+get_htc_send_packets_credit_based\n")); + /*** NOTE : the TX lock is held when this function is called ***/ + AR_DEBUG_PRINTF(ATH_DEBUG_SEND, + ("+get_htc_send_packets_credit_based\n")); INIT_HTC_PACKET_QUEUE(&pm_queue); extract_htc_pm_packets(pEndpoint, &pm_queue); @@ -873,9 +877,8 @@ static void get_htc_send_packets_credit_based(HTC_TARGET *target, transferLength / pEndpoint->TxCreditSize; remainder = transferLength % pEndpoint->TxCreditSize; - if (remainder) { + if (remainder) creditsRequired++; - } } AR_DEBUG_PRINTF(ATH_DEBUG_SEND, @@ -893,7 +896,7 @@ static void get_htc_send_packets_credit_based(HTC_TARGET *target, if (pEndpoint->TxCredits < creditsRequired) { #if DEBUG_CREDIT AR_DEBUG_PRINTF(ATH_DEBUG_ERR, - (" EP%d, No Credit now. %d < %d\n", + ("EP%d,No Credit now.%d < %d\n", pEndpoint->Id, pEndpoint->TxCredits, creditsRequired)); @@ -963,7 +966,7 @@ static void get_htc_send_packets(HTC_TARGET *target, HTC_PACKET_QUEUE pm_queue; bool do_pm_get; - /****** NOTE : the TX lock is held when this function is called *****************/ + /*** NOTE : the TX lock is held when this function is called ***/ AR_DEBUG_PRINTF(ATH_DEBUG_SEND, ("+get_htc_send_packets %d resources\n", Resources)); @@ -999,10 +1002,6 @@ static void get_htc_send_packets(HTC_TARGET *target, /* For non-credit path the sequence number is already embedded * in the constructed HTC header */ -#if 0 - pPacket->PktInfo.AsTx.SeqNo = pEndpoint->SeqNo; - pEndpoint->SeqNo++; -#endif pPacket->PktInfo.AsTx.SendFlags = 0; pPacket->PktInfo.AsTx.CreditsUsed = 0; /* queue this packet into the caller's queue */ @@ -1014,13 +1013,13 @@ static void get_htc_send_packets(HTC_TARGET *target, * qdf_nbuf_map, because the MacOS version of qdf_nbuf_t doesn't * support qdf_nbuf_get_num_frags until after qdf_nbuf_map has * been done. - * Assume that the non-data netbufs, i.e. the WMI message netbufs, + * Assume that the non-data netbufs, i.e. WMI message netbufs, * consist of a single fragment. */ + /* WMI messages are in a single-fragment network buf */ num_frags = (pPacket->PktInfo.AsTx. - Flags & HTC_TX_PACKET_FLAG_FIXUP_NETBUF) ? 1 - /* WMI messages are in a single-fragment network buffer */ : + Flags & HTC_TX_PACKET_FLAG_FIXUP_NETBUF) ? 1 : qdf_nbuf_get_num_frags(GET_HTC_PACKET_NET_BUF_CONTEXT (pPacket)); Resources -= num_frags; @@ -1039,18 +1038,19 @@ static void get_htc_send_packets(HTC_TARGET *target, * @pEndpoint: logical endpoint on which packets needs to be sent * @pCallersSendQueue: packet queue containing the list of packets to be sent * - * Return: HTC_SEND_QUEUE_RESULT indicates whether the packet was queued to be - * sent or the packet should be dropped by the upper layer + * Return: enum HTC_SEND_QUEUE_RESULT indicates whether the packet was queued to + * be sent or the packet should be dropped by the upper layer */ -static HTC_SEND_QUEUE_RESULT htc_try_send(HTC_TARGET *target, +static enum HTC_SEND_QUEUE_RESULT htc_try_send(HTC_TARGET *target, HTC_ENDPOINT *pEndpoint, HTC_PACKET_QUEUE *pCallersSendQueue) { - HTC_PACKET_QUEUE sendQueue; /* temp queue to hold packets at various stages */ + /* temp queue to hold packets at various stages */ + HTC_PACKET_QUEUE sendQueue; HTC_PACKET *pPacket; int tx_resources; int overflow; - HTC_SEND_QUEUE_RESULT result = HTC_SEND_QUEUE_OK; + enum HTC_SEND_QUEUE_RESULT result = HTC_SEND_QUEUE_OK; AR_DEBUG_PRINTF(ATH_DEBUG_SEND, ("+htc_try_send (Queue:%p Depth:%d)\n", pCallersSendQueue, @@ -1064,10 +1064,11 @@ static HTC_SEND_QUEUE_RESULT htc_try_send(HTC_TARGET *target, do { - if (NULL == pCallersSendQueue) { - /* caller didn't provide a queue, just wants us to check queues and send */ + /* caller didn't provide a queue, just wants us to check + * queues and send + */ + if (pCallersSendQueue == NULL) break; - } if (HTC_QUEUE_EMPTY(pCallersSendQueue)) { /* empty queue */ @@ -1085,14 +1086,14 @@ static HTC_SEND_QUEUE_RESULT htc_try_send(HTC_TARGET *target, /* figure out how much we will overflow by */ overflow = HTC_PACKET_QUEUE_DEPTH(&pEndpoint->TxQueue); overflow += HTC_PACKET_QUEUE_DEPTH(pCallersSendQueue); - /* figure out how much we will overflow the TX queue by */ + /* get how much we will overflow the TX queue by */ overflow -= pEndpoint->MaxTxQueueDepth; } /* if overflow is negative or zero, we are okay */ if (overflow > 0) { AR_DEBUG_PRINTF(ATH_DEBUG_SEND, - (" Endpoint %d, TX queue will overflow :%d , Tx Depth:%d, Max:%d \n", + ("Endpoint %d, TX queue will overflow :%d , Tx Depth:%d, Max:%d\n", pEndpoint->Id, overflow, HTC_PACKET_QUEUE_DEPTH(&pEndpoint-> TxQueue), @@ -1100,8 +1101,10 @@ static HTC_SEND_QUEUE_RESULT htc_try_send(HTC_TARGET *target, } if ((overflow <= 0) || (pEndpoint->EpCallBacks.EpSendFull == NULL)) { - /* all packets will fit or caller did not provide send full indication handler - * -- just move all of them to the local sendQueue object */ + /* all packets will fit or caller did not provide send + * full indication handler + * just move all of them to local sendQueue object + */ HTC_PACKET_QUEUE_TRANSFER_TO_TAIL(&sendQueue, pCallersSendQueue); } else { @@ -1111,8 +1114,9 @@ static HTC_SEND_QUEUE_RESULT htc_try_send(HTC_TARGET *target, overflow; A_ASSERT(goodPkts >= 0); - /* we have overflowed, and a callback is provided */ - /* dequeue all non-overflow packets into the sendqueue */ + /* we have overflowed and callback is provided. Dequeue + * all non-overflow packets into the sendqueue + */ for (i = 0; i < goodPkts; i++) { /* pop off caller's queue */ pPacket = htc_packet_dequeue(pCallersSendQueue); @@ -1121,18 +1125,21 @@ static HTC_SEND_QUEUE_RESULT htc_try_send(HTC_TARGET *target, HTC_PACKET_ENQUEUE(&sendQueue, pPacket); } - /* the caller's queue has all the packets that won't fit */ - /* walk through the caller's queue and indicate each one to the send full handler */ + /* the caller's queue has all the packets that won't fit + * walk through the caller's queue and indicate each one + * to the send full handler + */ ITERATE_OVER_LIST_ALLOW_REMOVE(&pCallersSendQueue-> QueueHead, pPacket, HTC_PACKET, ListLink) { AR_DEBUG_PRINTF(ATH_DEBUG_SEND, - (" Indicating overflowed TX packet: %p \n", + ("Indicating overflowed TX packet: %p\n", pPacket)); /* - * Remove headroom reserved for HTC_FRAME_HDR before giving - * the packet back to the user via the EpSendFull callback. + * Remove headroom reserved for HTC_FRAME_HDR + * before giving the packet back to the user via + * the EpSendFull callback. */ restore_tx_packet(target, pPacket); @@ -1142,16 +1149,23 @@ static HTC_SEND_QUEUE_RESULT htc_try_send(HTC_TARGET *target, /* callback wants the packet dropped */ INC_HTC_EP_STAT(pEndpoint, TxDropped, 1); - /* leave this one in the caller's queue for cleanup */ + /* leave this one in the caller's queue + * for cleanup + */ } else { - /* callback wants to keep this packet, remove from caller's queue */ + /* callback wants to keep this packet, + * remove from caller's queue + */ HTC_PACKET_REMOVE(pCallersSendQueue, pPacket); - /* put it in the send queue */ - /* add HTC_FRAME_HDR space reservation again */ + /* put it in the send queue + * add HTC_FRAME_HDR space reservation + * again + */ qdf_nbuf_push_head (GET_HTC_PACKET_NET_BUF_CONTEXT - (pPacket), sizeof(HTC_FRAME_HDR)); + (pPacket), + sizeof(HTC_FRAME_HDR)); HTC_PACKET_ENQUEUE(&sendQueue, pPacket); } @@ -1162,7 +1176,7 @@ static HTC_SEND_QUEUE_RESULT htc_try_send(HTC_TARGET *target, if (HTC_QUEUE_EMPTY(&sendQueue)) { /* no packets made it in, caller will cleanup */ OL_ATH_HTC_PKT_ERROR_COUNT_INCR(target, - HTC_SEND_Q_EMPTY); + HTC_SEND_Q_EMPTY); result = HTC_SEND_QUEUE_DROP; break; } @@ -1207,18 +1221,21 @@ static HTC_SEND_QUEUE_RESULT htc_try_send(HTC_TARGET *target, /* increment tx processing count on entry */ if (qdf_atomic_inc_return(&pEndpoint->TxProcessCount) > 1) { - /* another thread or task is draining the TX queues on this endpoint - * that thread will reset the tx processing count when the queue is drained */ + /* another thread or task is draining the TX queues on this + * endpoint that thread will reset the tx processing count when + * the queue is drained + */ qdf_atomic_dec(&pEndpoint->TxProcessCount); UNLOCK_HTC_TX(target); - AR_DEBUG_PRINTF(ATH_DEBUG_SEND, ("-htc_try_send (busy) \n")); + AR_DEBUG_PRINTF(ATH_DEBUG_SEND, ("-htc_try_send (busy)\n")); return HTC_SEND_QUEUE_OK; } /***** beyond this point only 1 thread may enter ******/ - /* now drain the endpoint TX queue for transmission as long as we have enough - * transmit resources */ + /* now drain the endpoint TX queue for transmission as long as we have + * enough transmit resources + */ while (true) { if (HTC_PACKET_QUEUE_DEPTH(&pEndpoint->TxQueue) == 0) @@ -1226,23 +1243,25 @@ static HTC_SEND_QUEUE_RESULT htc_try_send(HTC_TARGET *target, if (pEndpoint->async_update && (!IS_TX_CREDIT_FLOW_ENABLED(pEndpoint)) && - (!tx_resources)) { + (!tx_resources)) break; - } if (IS_TX_CREDIT_FLOW_ENABLED(pEndpoint)) { #if DEBUG_CREDIT int cred = pEndpoint->TxCredits; #endif - /* credit based mechanism provides flow control based on target transmit resource availability, we - * assume that the HIF layer will always have bus resources greater than target transmit resources */ + /* credit based mechanism provides flow control based on + * target transmit resource availability, we assume that + * the HIF layer will always have bus resources greater + * than target transmit resources + */ get_htc_send_packets_credit_based(target, pEndpoint, &sendQueue); #if DEBUG_CREDIT if (ep_debug_mask & (1 << pEndpoint->Id)) { if (cred - pEndpoint->TxCredits > 0) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, - (" Decrease EP%d %d - %d = %d credits.\n", + (" Decrease EP%d %d - %d = %d credits.\n", pEndpoint->Id, cred, cred - pEndpoint->TxCredits, @@ -1269,24 +1288,28 @@ static HTC_SEND_QUEUE_RESULT htc_try_send(HTC_TARGET *target, tx_resources = (HTC_MAX_MSG_PER_BUNDLE_TX * 2); } - /* get all the packets for this endpoint that we can for this pass */ + /* get all the packets for this endpoint that we can for + * this pass + */ get_htc_send_packets(target, pEndpoint, &sendQueue, tx_resources); } if (HTC_PACKET_QUEUE_DEPTH(&sendQueue) == 0) { - /* didn't get any packets due to a lack of resources or TX queue was drained */ + /* didn't get any packets due to a lack of resources or + * TX queue was drained + */ break; } - if (!pEndpoint->async_update) { + if (!pEndpoint->async_update) UNLOCK_HTC_TX(target); - } /* send what we can */ result = htc_issue_packets(target, pEndpoint, &sendQueue); if (result) { int i; + AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("htc_issue_packets, failed status:%d put it back to head of callersSendQueue", result)); @@ -1318,13 +1341,14 @@ static HTC_SEND_QUEUE_RESULT htc_try_send(HTC_TARGET *target, UNLOCK_HTC_TX(target); - AR_DEBUG_PRINTF(ATH_DEBUG_SEND, ("-htc_try_send: \n")); + AR_DEBUG_PRINTF(ATH_DEBUG_SEND, ("-htc_try_send:\n")); return HTC_SEND_QUEUE_OK; } #ifdef USB_HIF_SINGLE_PIPE_DATA_SCHED -static uint16_t 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; @@ -1333,17 +1357,15 @@ static uint16_t htc_send_pkts_sched_check(HTC_HANDLE HTCHandle, HTC_ENDPOINT_ID uint16_t resources; uint16_t acQueueStatus[DATA_EP_SIZE] = { 0, 0, 0, 0 }; - if (id < ENDPOINT_2 || id > ENDPOINT_5) { + if (id < ENDPOINT_2 || id > ENDPOINT_5) return 1; - } for (eid = ENDPOINT_2; eid <= ENDPOINT_5; eid++) { pEndpoint = &target->endpoint[eid]; pTxQueue = &pEndpoint->TxQueue; - if (HTC_QUEUE_EMPTY(pTxQueue)) { + if (HTC_QUEUE_EMPTY(pTxQueue)) acQueueStatus[eid - 2] = 1; - } } switch (id) { @@ -1387,9 +1409,8 @@ static A_STATUS htc_send_pkts_sched_queue(HTC_TARGET *target, HTC_PACKET_ENQUEUE(pTxQueue, pPacket); goodPkts--; - if (goodPkts <= 0) { + if (goodPkts <= 0) break; - } } } @@ -1416,7 +1437,8 @@ static A_STATUS htc_send_pkts_sched_queue(HTC_TARGET *target, #endif -A_STATUS htc_send_pkts_multiple(HTC_HANDLE HTCHandle, HTC_PACKET_QUEUE *pPktQueue) +A_STATUS htc_send_pkts_multiple(HTC_HANDLE HTCHandle, + HTC_PACKET_QUEUE *pPktQueue) { HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle); HTC_ENDPOINT *pEndpoint; @@ -1426,14 +1448,16 @@ A_STATUS htc_send_pkts_multiple(HTC_HANDLE HTCHandle, HTC_PACKET_QUEUE *pPktQueu QDF_STATUS status; AR_DEBUG_PRINTF(ATH_DEBUG_SEND, - ("+htc_send_pkts_multiple: Queue: %p, Pkts %d \n", + ("+htc_send_pkts_multiple: Queue: %p, Pkts %d\n", pPktQueue, HTC_PACKET_QUEUE_DEPTH(pPktQueue))); - /* get packet at head to figure out which endpoint these packets will go into */ + /* get packet at head to figure out which endpoint these packets will + * go into + */ pPacket = htc_get_pkt_at_head(pPktQueue); if (NULL == pPacket) { OL_ATH_HTC_PKT_ERROR_COUNT_INCR(target, GET_HTC_PKT_Q_FAIL); - AR_DEBUG_PRINTF(ATH_DEBUG_SEND, ("-htc_send_pkts_multiple \n")); + AR_DEBUG_PRINTF(ATH_DEBUG_SEND, ("-htc_send_pkts_multiple\n")); return A_EINVAL; } @@ -1462,10 +1486,10 @@ A_STATUS htc_send_pkts_multiple(HTC_HANDLE HTCHandle, HTC_PACKET_QUEUE *pPktQueu pHtcHdr = (HTC_FRAME_HDR *) qdf_nbuf_get_frag_vaddr(netbuf, 0); AR_DEBUG_ASSERT(pHtcHdr); HTC_WRITE32(pHtcHdr, - SM(pPacket->ActualLength, - HTC_FRAME_HDR_PAYLOADLEN) | SM(pPacket->Endpoint, - HTC_FRAME_HDR_ENDPOINTID)); - + SM(pPacket->ActualLength, + HTC_FRAME_HDR_PAYLOADLEN) | + SM(pPacket->Endpoint, + HTC_FRAME_HDR_ENDPOINTID)); LOCK_HTC_TX(target); pPacket->PktInfo.AsTx.SeqNo = pEndpoint->SeqNo; @@ -1477,9 +1501,9 @@ A_STATUS htc_send_pkts_multiple(HTC_HANDLE HTCHandle, HTC_PACKET_QUEUE *pPktQueu UNLOCK_HTC_TX(target); /* - * Now that the HTC frame header has been added, the netbuf can be - * mapped. This only applies to non-data frames, since data frames - * were already mapped as they entered into the driver. + * Now that the HTC frame header has been added, the netbuf can + * be mapped. This only applies to non-data frames, since data + * frames were already mapped as they entered into the driver. */ status = qdf_nbuf_map(target->osdev, GET_HTC_PACKET_NET_BUF_CONTEXT(pPacket), @@ -1496,11 +1520,10 @@ A_STATUS htc_send_pkts_multiple(HTC_HANDLE HTCHandle, HTC_PACKET_QUEUE *pPktQueu HTC_PACKET_QUEUE_ITERATE_END; #ifdef USB_HIF_SINGLE_PIPE_DATA_SCHED - if (!htc_send_pkts_sched_check(HTCHandle, pEndpoint->Id)) { + if (!htc_send_pkts_sched_check(HTCHandle, pEndpoint->Id)) htc_send_pkts_sched_queue(HTCHandle, pPktQueue, pEndpoint->Id); - } else { + else htc_try_send(target, pEndpoint, pPktQueue); - } #else htc_try_send(target, pEndpoint, pPktQueue); #endif @@ -1512,18 +1535,17 @@ A_STATUS htc_send_pkts_multiple(HTC_HANDLE HTCHandle, HTC_PACKET_QUEUE *pPktQueu /* remove the headroom reserved for HTC_FRAME_HDR */ restore_tx_packet(target, pPacket); - if (HTC_STOPPING(target)) { + if (HTC_STOPPING(target)) pPacket->Status = A_ECANCELED; - } else { + else pPacket->Status = A_NO_RESOURCE; - } } HTC_PACKET_QUEUE_ITERATE_END; do_send_completion(pEndpoint, pPktQueue); } - AR_DEBUG_PRINTF(ATH_DEBUG_SEND, ("-htc_send_pkts_multiple \n")); + AR_DEBUG_PRINTF(ATH_DEBUG_SEND, ("-htc_send_pkts_multiple\n")); return A_OK; } @@ -1533,12 +1555,11 @@ A_STATUS htc_send_pkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket) { HTC_PACKET_QUEUE queue; - if (HTCHandle == NULL || pPacket == NULL) { + if (HTCHandle == NULL || pPacket == NULL) return A_ERROR; - } AR_DEBUG_PRINTF(ATH_DEBUG_SEND, - ("+-htc_send_pkt: Enter endPointId: %d, buffer: %p, length: %d \n", + ("+-htc_send_pkt: Enter endPointId: %d, buffer: %p, length: %d\n", pPacket->Endpoint, pPacket->pBuffer, pPacket->ActualLength)); INIT_HTC_PACKET_QUEUE_AND_ADD(&queue, pPacket); @@ -1566,8 +1587,8 @@ A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, qdf_nbuf_t netbuf, int Epid, pEndpoint = &target->endpoint[Epid]; - tx_resources = - hif_get_free_queue_number(target->hif_dev, pEndpoint->UL_PipeID); + tx_resources = hif_get_free_queue_number(target->hif_dev, + pEndpoint->UL_PipeID); if (tx_resources < HTC_DATA_RESOURCE_THRS) { if (pEndpoint->ul_is_polled) { @@ -1577,9 +1598,8 @@ A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, qdf_nbuf_t netbuf, int Epid, hif_get_free_queue_number(target->hif_dev, pEndpoint->UL_PipeID); } - if (tx_resources < HTC_DATA_MINDESC_PERPACKET) { + if (tx_resources < HTC_DATA_MINDESC_PERPACKET) return A_ERROR; - } } if (hif_pm_runtime_get(target->hif_dev)) @@ -1657,24 +1677,26 @@ A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket, AR_DEBUG_ASSERT(pHtcHdr); HTC_WRITE32(pHtcHdr, - SM(pPacket->ActualLength, - HTC_FRAME_HDR_PAYLOADLEN) | SM(pPacket->PktInfo. - AsTx.SendFlags, - HTC_FRAME_HDR_FLAGS) - | SM(pPacket->Endpoint, HTC_FRAME_HDR_ENDPOINTID)); + SM(pPacket->ActualLength, + HTC_FRAME_HDR_PAYLOADLEN) | + SM(pPacket->PktInfo.AsTx.SendFlags, + HTC_FRAME_HDR_FLAGS) | + SM(pPacket->Endpoint, + HTC_FRAME_HDR_ENDPOINTID)); /* * If the HIF pipe for the data endpoint is polled rather than * interrupt-driven, this is a good point to check whether any * data previously sent through the HIF pipe have finished being - * sent. - * Since this may result in callbacks to htc_tx_completion_handler, - * which can take the HTC tx lock, make the hif_send_complete_check - * call before acquiring the HTC tx lock. + * sent. Since this may result in callbacks to + * htc_tx_completion_handler, which can take the HTC tx lock, + * make the hif_send_complete_check call before acquiring the + * HTC tx lock. * Call hif_send_complete_check directly, rather than calling - * htc_send_complete_check, and call the PollTimerStart separately - * after calling hif_send_head, so the timer will be started to - * check for completion of the new outstanding download (in the - * unexpected event that other polling calls don't catch it). + * htc_send_complete_check, and call the PollTimerStart + * separately after calling hif_send_head, so the timer will be + * started to check for completion of the new outstanding + * download (in the unexpected event that other polling calls + * don't catch it). */ if (pEndpoint->ul_is_polled) { htc_send_complete_poll_timer_stop(pEndpoint); @@ -1706,9 +1728,9 @@ A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket, qdf_atomic_inc(&pEndpoint->TxProcessCount); if (qdf_atomic_read(&pEndpoint->TxProcessCount) > 1) { /* - * Another thread or task is draining the TX queues on this endpoint. - * That thread will reset the tx processing count when the queue is - * drained. + * Another thread or task is draining the TX queues on this + * endpoint. That thread will reset the tx processing count when + * the queue is drained. */ qdf_atomic_dec(&pEndpoint->TxProcessCount); UNLOCK_HTC_TX(target); @@ -1722,7 +1744,8 @@ A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket, #if DEBUG_CREDIT int cred = pEndpoint->TxCredits; #endif - get_htc_send_packets_credit_based(target, pEndpoint, &sendQueue); + get_htc_send_packets_credit_based(target, pEndpoint, + &sendQueue); #if DEBUG_CREDIT if (ep_debug_mask & (1 << pEndpoint->Id)) { if (cred - pEndpoint->TxCredits > 0) { @@ -1743,10 +1766,10 @@ A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket, hif_get_free_queue_number(target->hif_dev, pEndpoint->UL_PipeID)) { /* - * Header and payload belongs to the different fragments - * and consume 2 resource for one HTC package but USB - * combine into one transfer. - */ + * Header and payload belongs to the different fragments + * and consume 2 resource for one HTC package but USB + * combine into one transfer. + */ get_htc_send_packets(target, pEndpoint, &sendQueue, (HTC_MAX_MSG_PER_BUNDLE_TX * 2)); } else { @@ -1756,16 +1779,16 @@ A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket, } UNLOCK_HTC_TX(target); - } - else { + } else { /* - * Now drain the endpoint TX queue for transmission as long as we have - * enough transmit resources + * Now drain the endpoint TX queue for transmission as long as + * we have enough transmit resources */ tx_resources = hif_get_free_queue_number(target->hif_dev, pEndpoint->UL_PipeID); - get_htc_send_packets(target, pEndpoint, &sendQueue, tx_resources); + get_htc_send_packets(target, pEndpoint, &sendQueue, + tx_resources); UNLOCK_HTC_TX(target); } QDF_NBUF_UPDATE_TX_PKT_COUNT(netbuf, QDF_NBUF_TX_PKT_HTC); @@ -1783,9 +1806,8 @@ A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket, htc_issue_packets_bundle(target, pEndpoint, &sendQueue); } pPacket = htc_packet_dequeue(&sendQueue); - if (pPacket == NULL) { + if (pPacket == NULL) break; - } netbuf = GET_HTC_PACKET_NET_BUF_CONTEXT(pPacket); LOCK_HTC_TX(target); @@ -1823,12 +1845,16 @@ A_STATUS htc_send_data_pkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket, * In HL systems, the txrx SW explicitly performs the * tx flow control. */ - /* pEndpoint->TxCredits += pPacket->PktInfo.AsTx.CreditsUsed; */ + /* pEndpoint->TxCredits += + * pPacket->PktInfo.AsTx.CreditsUsed; + */ /* put this frame back at the front of the sendQueue */ HTC_PACKET_ENQUEUE_TO_HEAD(&sendQueue, pPacket); - /* put the sendQueue back at the front of pEndpoint->TxQueue */ + /* put the sendQueue back at the front of + * pEndpoint->TxQueue + */ HTC_PACKET_QUEUE_TRANSFER_TO_HEAD(&pEndpoint->TxQueue, &sendQueue); UNLOCK_HTC_TX(target); @@ -1883,13 +1909,12 @@ static HTC_PACKET *htc_lookup_tx_packet(HTC_TARGET *target, if (netbuf == (qdf_nbuf_t) GET_HTC_PACKET_NET_BUF_CONTEXT(pPacket)) { UNLOCK_HTC_TX(target); return pPacket; - } else { - HTC_PACKET_ENQUEUE(&lookupQueue, pPacket); } + HTC_PACKET_ENQUEUE(&lookupQueue, pPacket); /* - * Move TX lookup queue to temp queue because most of packets that are not index 0 - * are not top 10 packets. + * Move TX lookup queue to temp queue because most of packets that are + * not index 0 are not top 10 packets. */ HTC_PACKET_QUEUE_TRANSFER_TO_TAIL(&lookupQueue, &pEndpoint->TxLookupQueue); @@ -1974,7 +1999,8 @@ QDF_STATUS htc_tx_completion_handler(void *Context, HTC_PACKET_QUEUE_ITERATE_END; free_htc_bundle_packet(target, pPacket); - if (hif_get_bus_type(target->hif_dev) == QDF_BUS_TYPE_USB) { + if (hif_get_bus_type(target->hif_dev) == + QDF_BUS_TYPE_USB) { if (!IS_TX_CREDIT_FLOW_ENABLED(pEndpoint)) htc_try_send(target, pEndpoint, NULL); } @@ -1989,9 +2015,10 @@ QDF_STATUS htc_tx_completion_handler(void *Context, } while (false); if (!IS_TX_CREDIT_FLOW_ENABLED(pEndpoint)) { - /* note: when using TX credit flow, the re-checking of queues happens - * when credits flow back from the target. - * in the non-TX credit case, we recheck after the packet completes */ + /* note: when using TX credit flow, the re-checking of queues + * happens when credits flow back from the target. In the non-TX + * credit case, we recheck after the packet completes + */ if ((qdf_atomic_read(&pEndpoint->TxProcessCount) == 0) || (!pEndpoint->async_update)) { htc_try_send(target, pEndpoint, NULL); @@ -2030,9 +2057,8 @@ void htc_tx_resource_avail_handler(void *context, uint8_t pipeID) for (i = 0; i < ENDPOINT_MAX; i++) { pEndpoint = &target->endpoint[i]; if (pEndpoint->service_id != 0) { - if (pEndpoint->UL_PipeID == pipeID) { + if (pEndpoint->UL_PipeID == pipeID) break; - } } } @@ -2044,7 +2070,7 @@ void htc_tx_resource_avail_handler(void *context, uint8_t pipeID) } AR_DEBUG_PRINTF(ATH_DEBUG_SEND, - ("HIF indicated more resources for pipe:%d \n", + ("HIF indicated more resources for pipe:%d\n", pipeID)); htc_try_send(target, pEndpoint, NULL); @@ -2133,6 +2159,7 @@ bool htc_is_endpoint_active(HTC_HANDLE HTCHandle, HTC_ENDPOINT_ID Endpoint) void htc_set_nodrop_pkt(HTC_HANDLE HTCHandle, A_BOOL isNodropPkt) { HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle); + target->is_nodrop_pkt = isNodropPkt; } @@ -2154,7 +2181,7 @@ void htc_process_credit_rpt(HTC_TARGET *target, HTC_CREDIT_REPORT *pRpt, uint8_t rpt_credits, rpt_ep_id; AR_DEBUG_PRINTF(ATH_DEBUG_SEND, - ("+htc_process_credit_rpt, Credit Report Entries:%d \n", + ("+htc_process_credit_rpt, Credit Report Entries:%d\n", NumEntries)); /* lock out TX while we update credits */ @@ -2188,13 +2215,14 @@ void htc_process_credit_rpt(HTC_TARGET *target, HTC_CREDIT_REPORT *pRpt, INC_HTC_EP_STAT(pEndpoint, TxCreditsReturned, rpt_credits); if (FromEndpoint == rpt_ep_id) { - /* this credit report arrived on the same endpoint indicating it arrived in an RX - * packet */ + /* this credit report arrived on the same endpoint + * indicating it arrived in an RX packet + */ INC_HTC_EP_STAT(pEndpoint, TxCreditsFromRx, rpt_credits); INC_HTC_EP_STAT(pEndpoint, TxCreditRptsFromRx, 1); } else if (FromEndpoint == ENDPOINT_0) { - /* this credit arrived on endpoint 0 as a NULL message */ + /* this credit arrived on endpoint 0 as a NULL msg */ INC_HTC_EP_STAT(pEndpoint, TxCreditsFromEp0, rpt_credits); INC_HTC_EP_STAT(pEndpoint, TxCreditRptsFromEp0, 1); @@ -2224,11 +2252,10 @@ void htc_process_credit_rpt(HTC_TARGET *target, HTC_CREDIT_REPORT *pRpt, #ifdef ATH_11AC_TXCOMPACT htc_try_send(target, pEndpoint, NULL); #else - if (pEndpoint->service_id == HTT_DATA_MSG_SVC) { + if (pEndpoint->service_id == HTT_DATA_MSG_SVC) htc_send_data_pkt(target, NULL, 0); - } else { + else htc_try_send(target, pEndpoint, NULL); - } #endif LOCK_HTC_TX(target); } @@ -2236,12 +2263,12 @@ void htc_process_credit_rpt(HTC_TARGET *target, HTC_CREDIT_REPORT *pRpt, } AR_DEBUG_PRINTF(ATH_DEBUG_SEND, - (" Report indicated %d credits to distribute \n", + (" Report indicated %d credits to distribute\n", totalCredits)); UNLOCK_HTC_TX(target); - AR_DEBUG_PRINTF(ATH_DEBUG_SEND, ("-htc_process_credit_rpt \n")); + AR_DEBUG_PRINTF(ATH_DEBUG_SEND, ("-htc_process_credit_rpt\n")); } /* function to fetch stats from htc layer*/ diff --git a/htc/htc_services.c b/htc/htc_services.c index 0ddf398af5..bd8a0803d7 100644 --- a/htc/htc_services.c +++ b/htc/htc_services.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013-2016 The Linux Foundation. All rights reserved. + * Copyright (c) 2013-2017 The Linux Foundation. All rights reserved. * * Previously licensed under the ISC license by Qualcomm Atheros, Inc. * @@ -83,7 +83,6 @@ htc_alt_data_credit_size_update(HTC_TARGET *target, (*ul_pipe == 1) && (*dl_pipe == 0)) *txCreditSize = target->AltDataCreditSize; - return; } #else @@ -93,13 +92,12 @@ htc_alt_data_credit_size_update(HTC_TARGET *target, uint8_t *dl_pipe, int *txCreditSize) { - return; } #endif A_STATUS htc_connect_service(HTC_HANDLE HTCHandle, - HTC_SERVICE_CONNECT_REQ *pConnectReq, - HTC_SERVICE_CONNECT_RESP *pConnectResp) + struct htc_service_connect_req *pConnectReq, + struct htc_service_connect_resp *pConnectResp) { HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle); A_STATUS status = A_OK; @@ -189,15 +187,14 @@ A_STATUS htc_connect_service(HTC_HANDLE HTCHandle, disableCreditFlowCtrl = true; } - if (!htc_credit_flow) { + if (!htc_credit_flow) disableCreditFlowCtrl = true; - } /* check caller if it wants to transfer meta data */ if ((pConnectReq->pMetaData != NULL) && (pConnectReq->MetaDataLength <= HTC_SERVICE_META_DATA_MAX_LENGTH)) { - /* copy meta data into message buffer (after header ) */ + /* copy meta data into msg buffer (after hdr) */ qdf_mem_copy((uint8_t *) pConnectMsg + sizeof(HTC_CONNECT_SERVICE_MSG), pConnectReq->pMetaData, @@ -219,23 +216,23 @@ A_STATUS htc_connect_service(HTC_HANDLE HTCHandle, status = htc_send_pkt((HTC_HANDLE) target, pSendPacket); /* we don't own it anymore */ pSendPacket = NULL; - if (A_FAILED(status)) { + if (A_FAILED(status)) break; - } /* wait for response */ status = htc_wait_recv_ctrl_message(target); - if (A_FAILED(status)) { + if (A_FAILED(status)) break; - } - /* we controlled the buffer creation so it has to be properly aligned */ + /* we controlled the buffer creation so it has to be + * properly aligned + */ pResponseMsg = (HTC_CONNECT_SERVICE_RESPONSE_MSG *) target-> CtrlResponseBuffer; rsp_msg_id = HTC_GET_FIELD(pResponseMsg, - HTC_CONNECT_SERVICE_RESPONSE_MSG, - MESSAGEID); + HTC_CONNECT_SERVICE_RESPONSE_MSG, + MESSAGEID); rsp_msg_serv_id = HTC_GET_FIELD(pResponseMsg, HTC_CONNECT_SERVICE_RESPONSE_MSG, @@ -280,12 +277,13 @@ A_STATUS htc_connect_service(HTC_HANDLE HTCHandle, rsp_msg_serv_id, rsp_msg_status)); status = A_EPROTO; -/* TODO: restore the ifdef when FW supports services 301 and 302 (HTT_MSG_DATA[23]_MSG_SVC) -#ifdef QCA_TX_HTT2_SUPPORT -*/ - /* Keep work and not to block the control message. */ +/* TODO: restore the ifdef when FW supports services 301 and 302 + * (HTT_MSG_DATA[23]_MSG_SVC) + */ +/* #ifdef QCA_TX_HTT2_SUPPORT */ + /* Keep work and not to block the control msg */ target->CtrlResponseProcessing = false; -/*#endif */ /* QCA_TX_HTT2_SUPPORT */ +/* #endif */ /* QCA_TX_HTT2_SUPPORT */ break; } @@ -296,7 +294,9 @@ A_STATUS htc_connect_service(HTC_HANDLE HTCHandle, (rsp_msg_serv_meta_len > 0) && (rsp_msg_serv_meta_len <= HTC_SERVICE_META_DATA_MAX_LENGTH)) { - /* caller supplied a buffer and the target responded with data */ + /* caller supplied a buffer and the target + * responded with data + */ int copyLength = min((int)pConnectResp->BufferLength, (int)rsp_msg_serv_meta_len); @@ -312,7 +312,7 @@ A_STATUS htc_connect_service(HTC_HANDLE HTCHandle, target->CtrlResponseProcessing = false; } - /* the rest of these are parameter checks so set the error status */ + /* rest of these are parameter checks so set the error status */ status = A_EPROTO; if (assignedEndpoint >= ENDPOINT_MAX) { @@ -346,9 +346,8 @@ A_STATUS htc_connect_service(HTC_HANDLE HTCHandle, pEndpoint->TxCreditSize = target->TargetCreditSize; pEndpoint->TxCreditsPerMaxMsg = maxMsgSize / target->TargetCreditSize; - if (maxMsgSize % target->TargetCreditSize) { + if (maxMsgSize % target->TargetCreditSize) pEndpoint->TxCreditsPerMaxMsg++; - } #if DEBUG_CREDIT qdf_print(" Endpoint%d initial credit:%d, size:%d.\n", pEndpoint->Id, pEndpoint->TxCredits, @@ -365,16 +364,16 @@ A_STATUS htc_connect_service(HTC_HANDLE HTCHandle, &pEndpoint->DL_PipeID, &pEndpoint->ul_is_polled, &pEndpoint->dl_is_polled); - if (A_FAILED(status)) { + if (A_FAILED(status)) break; - } htc_alt_data_credit_size_update(target, &pEndpoint->UL_PipeID, &pEndpoint->DL_PipeID, &pEndpoint->TxCreditSize); - qdf_assert(!pEndpoint->dl_is_polled); /* not currently supported */ + /* not currently supported */ + qdf_assert(!pEndpoint->dl_is_polled); if (pEndpoint->ul_is_polled) { qdf_timer_init(target->osdev, @@ -411,19 +410,20 @@ void htc_set_credit_distribution(HTC_HANDLE HTCHandle, HTC_SERVICE_ID ServicePriorityOrder[], int ListLength) { - /* NOT Supported, this transport does not use a credit based flow control mechanism */ + /* NOT Supported, this transport does not use a credit based flow + * control mechanism + */ } void htc_fw_event_handler(void *context, QDF_STATUS status) { HTC_TARGET *target = (HTC_TARGET *) context; - HTC_INIT_INFO *initInfo = &target->HTCInitInfo; + struct htc_init_info *initInfo = &target->HTCInitInfo; /* check if target failure handler exists and pass error code to it. */ - if (target->HTCInitInfo.TargetFailure != NULL) { + if (target->HTCInitInfo.TargetFailure != NULL) initInfo->TargetFailure(initInfo->pContext, status); - } } diff --git a/wmi/src/wmi_unified.c b/wmi/src/wmi_unified.c index a63195c46c..f886fb209e 100644 --- a/wmi/src/wmi_unified.c +++ b/wmi/src/wmi_unified.c @@ -2871,8 +2871,8 @@ static int wmi_connect_pdev_htc_service(struct wmi_soc *soc, int status; uint32_t svc_id[] = {WMI_CONTROL_SVC, WMI_CONTROL_SVC_WMAC1, WMI_CONTROL_SVC_WMAC2}; - HTC_SERVICE_CONNECT_RESP response; - HTC_SERVICE_CONNECT_REQ connect; + struct htc_service_connect_resp response; + struct htc_service_connect_req connect; OS_MEMZERO(&connect, sizeof(connect)); OS_MEMZERO(&response, sizeof(response));