void wmi_htc_tx_complete(void *ctx, HTC_PACKET *htc_pkt)
{
struct wmi_unified *wmi_handle = (struct wmi_unified *)ctx;
wmi_buf_t wmi_cmd_buf = GET_HTC_PACKET_NET_BUF_CONTEXT(htc_pkt);
#ifdef WMI_INTERFACE_EVENT_LOGGING
uint32_t cmd_id;
#endif
ASSERT(wmi_cmd_buf);
#ifdef WMI_INTERFACE_EVENT_LOGGING
cmd_id = WMI_GET_FIELD(cdf_nbuf_data(wmi_cmd_buf),
WMI_CMD_HDR, COMMANDID);
#ifdef QCA_WIFI_3_0_EMU
printk("\nSent WMI command:%s command_id:0x%x over dma and recieved tx complete interupt\n",
get_wmi_cmd_string(cmd_id), cmd_id);
#endif
cdf_spin_lock_bh(&wmi_handle->wmi_record_lock);
/* Record 16 bytes of WMI cmd tx complete data
- exclude TLV and WMI headers */
if (cmd_id == WMI_MGMT_TX_SEND_CMDID) {
WMI_MGMT_COMMAND_TX_CMP_RECORD(cmd_id,
((uint32_t *) cdf_nbuf_data(wmi_cmd_buf) + 2));
} else {
WMI_COMMAND_TX_CMP_RECORD(cmd_id,
((uint32_t *) cdf_nbuf_data(wmi_cmd_buf) + 2));
}
cdf_spin_unlock_bh(&wmi_handle->wmi_record_lock);
#endif
cdf_nbuf_free(wmi_cmd_buf);
cdf_mem_free(htc_pkt);
cdf_atomic_dec(&wmi_handle->pending_cmds);
}
A_STATUS HTCStart(HTC_HANDLE HTCHandle)
{
adf_nbuf_t netbuf;
A_STATUS status = A_OK;
HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle);
HTC_SETUP_COMPLETE_EX_MSG *pSetupComp;
HTC_PACKET *pSendPacket;
AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("HTCStart Enter\n"));
do {
HTCConfigTargetHIFPipe(target);
/* allocate a buffer to send */
pSendPacket = HTCAllocControlTxPacket(target);
if (NULL == pSendPacket) {
AR_DEBUG_ASSERT(FALSE);
adf_os_print("%s: allocControlTxPacket failed\n",__func__);
status = A_NO_MEMORY;
break;
}
netbuf = (adf_nbuf_t)GET_HTC_PACKET_NET_BUF_CONTEXT(pSendPacket);
/* assemble setup complete message */
adf_nbuf_put_tail(netbuf, sizeof(HTC_SETUP_COMPLETE_EX_MSG));
pSetupComp = (HTC_SETUP_COMPLETE_EX_MSG *) adf_nbuf_data(netbuf);
A_MEMZERO(pSetupComp,sizeof(HTC_SETUP_COMPLETE_EX_MSG));
HTC_SET_FIELD(pSetupComp, HTC_SETUP_COMPLETE_EX_MSG,
MESSAGEID, HTC_MSG_SETUP_COMPLETE_EX_ID);
//if (!htc_credit_flow) {
if (0) {
AR_DEBUG_PRINTF(ATH_DEBUG_INIT, ("HTC will not use TX credit flow control\n"));
pSetupComp->SetupFlags |= HTC_SETUP_COMPLETE_FLAGS_DISABLE_TX_CREDIT_FLOW;
} else {
AR_DEBUG_PRINTF(ATH_DEBUG_INIT, ("HTC using TX credit flow control\n"));
}
SET_HTC_PACKET_INFO_TX(pSendPacket,
NULL,
(A_UINT8 *)pSetupComp,
sizeof(HTC_SETUP_COMPLETE_EX_MSG),
ENDPOINT_0,
HTC_SERVICE_TX_PACKET_TAG);
status = HTCSendPkt((HTC_HANDLE)target,pSendPacket);
if (A_FAILED(status)) {
break;
}
} while (FALSE);
AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("HTCStart Exit\n"));
return status;
}
void wmi_htc_tx_complete(void *ctx,HTC_PACKET *htc_pkt)
{
wmi_buf_t wmi_cmd_buf=GET_HTC_PACKET_NET_BUF_CONTEXT(htc_pkt);
struct cookie *cookie = htc_pkt->pPktContext;
ASSERT(wmi_cmd_buf);
wbuf_free(wmi_cmd_buf);
ol_free_cookie(ctx, cookie);
}
static void DestroyHTCTxCtrlPacket(HTC_PACKET *pPacket)
{
adf_nbuf_t netbuf;
netbuf = (adf_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) {
adf_nbuf_free(netbuf);
}
A_FREE(pPacket);
}
static void destroy_htc_tx_ctrl_packet(HTC_PACKET *pPacket)
{
cdf_nbuf_t netbuf;
netbuf = (cdf_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) {
cdf_nbuf_free(netbuf);
}
cdf_mem_free(pPacket);
}
void wmi_htc_tx_complete(void *ctx,HTC_PACKET *htc_pkt)
{
wmi_buf_t wmi_cmd_buf=GET_HTC_PACKET_NET_BUF_CONTEXT(htc_pkt);
struct wmi_unified *wmi_handle = (struct wmi_unified *)ctx;
struct cookie *cookie = htc_pkt->pPktContext;
ASSERT(wmi_cmd_buf);
wbuf_free(wmi_cmd_buf);
ol_free_cookie(wmi_handle->scn_handle , cookie);
return;
}
/* cleanup the HTC instance */
static void htc_cleanup(HTC_TARGET *target)
{
HTC_PACKET *pPacket;
/* cdf_nbuf_t netbuf; */
if (target->hif_dev != NULL) {
hif_detach_htc(target->hif_dev);
target->hif_dev = NULL;
}
while (true) {
pPacket = allocate_htc_packet_container(target);
if (NULL == pPacket) {
break;
}
cdf_mem_free(pPacket);
}
pPacket = target->pBundleFreeList;
while (pPacket) {
HTC_PACKET *pPacketTmp = (HTC_PACKET *) pPacket->ListLink.pNext;
cdf_mem_free(pPacket);
pPacket = pPacketTmp;
}
#ifdef TODO_FIXME
while (true) {
pPacket = htc_alloc_control_tx_packet(target);
if (NULL == pPacket) {
break;
}
netbuf = (cdf_nbuf_t) GET_HTC_PACKET_NET_BUF_CONTEXT(pPacket);
if (netbuf != NULL) {
cdf_nbuf_free(netbuf);
}
cdf_mem_free(pPacket);
}
#endif
cdf_spinlock_destroy(&target->HTCLock);
cdf_spinlock_destroy(&target->HTCRxLock);
cdf_spinlock_destroy(&target->HTCTxLock);
cdf_spinlock_destroy(&target->HTCCreditLock);
/* free our instance */
cdf_mem_free(target);
}
/* cleanup the HTC instance */
static void HTCCleanup(HTC_TARGET *target)
{
HTC_PACKET *pPacket;
//adf_nbuf_t netbuf;
if (target->hif_dev != NULL) {
HIFDetachHTC(target->hif_dev);
target->hif_dev = NULL;
}
while (TRUE) {
pPacket = AllocateHTCPacketContainer(target);
if (NULL == pPacket) {
break;
}
A_FREE(pPacket);
}
#ifdef TODO_FIXME
while (TRUE) {
pPacket = HTCAllocControlTxPacket(target);
if (NULL == pPacket) {
break;
}
netbuf = (adf_nbuf_t)GET_HTC_PACKET_NET_BUF_CONTEXT(pPacket);
if (netbuf != NULL) {
adf_nbuf_free(netbuf);
}
A_FREE(pPacket);
}
#endif
adf_os_spinlock_destroy(&target->HTCLock);
adf_os_spinlock_destroy(&target->HTCRxLock);
adf_os_spinlock_destroy(&target->HTCTxLock);
/* free our instance */
A_FREE(target);
}
void wmi_htc_tx_complete(void *ctx, HTC_PACKET *htc_pkt)
{
struct wmi_unified *wmi_handle = (struct wmi_unified *)ctx;
wmi_buf_t wmi_cmd_buf = GET_HTC_PACKET_NET_BUF_CONTEXT(htc_pkt);
#ifdef WMI_INTERFACE_EVENT_LOGGING
u_int32_t cmd_id;
#endif
ASSERT(wmi_cmd_buf);
#ifdef WMI_INTERFACE_EVENT_LOGGING
cmd_id = WMI_GET_FIELD(adf_nbuf_data(wmi_cmd_buf),
WMI_CMD_HDR, COMMANDID);
adf_os_spin_lock_bh(&wmi_handle->wmi_record_lock);
/* Record 16 bytes of WMI cmd tx complete data
- exclude TLV and WMI headers */
WMI_COMMAND_TX_CMP_RECORD(cmd_id,
((u_int32_t *)adf_nbuf_data(wmi_cmd_buf) + 2));
adf_os_spin_unlock_bh(&wmi_handle->wmi_record_lock);
#endif
adf_nbuf_free(wmi_cmd_buf);
adf_os_mem_free(htc_pkt);
adf_os_atomic_dec(&wmi_handle->pending_cmds);
}
/*
* Call netif_stop_queue frequently will impact the mboxping tx t-put.
* Return HTC_SEND_FULL_KEEP directly in epping_tx_queue_full to avoid.
*/
return HTC_SEND_FULL_KEEP;
}
#endif /* HIF_SDIO */
void epping_tx_complete_multiple(void *ctx,
HTC_PACKET_QUEUE *pPacketQueue)
{
epping_context_t *pEpping_ctx = (epping_context_t *)ctx;
epping_adapter_t *pAdapter = pEpping_ctx->epping_adapter;
struct net_device* dev = pAdapter->dev;
A_STATUS status;
HTC_ENDPOINT_ID eid;
adf_nbuf_t pktSkb;
struct epping_cookie *cookie;
A_BOOL flushing = FALSE;
adf_nbuf_queue_t skb_queue;
HTC_PACKET *htc_pkt;
adf_nbuf_queue_init(&skb_queue);
adf_os_spin_lock_bh(&pAdapter->data_lock);
while (!HTC_QUEUE_EMPTY(pPacketQueue)) {
htc_pkt = HTC_PACKET_DEQUEUE(pPacketQueue);
if (htc_pkt == NULL)
break;
status=htc_pkt->Status;
eid=htc_pkt->Endpoint;
pktSkb=GET_HTC_PACKET_NET_BUF_CONTEXT(htc_pkt);
cookie = htc_pkt->pPktContext;
if (!pktSkb) {
EPPING_LOG(VOS_TRACE_LEVEL_ERROR,
"%s: pktSkb is NULL", __func__);
ASSERT(0);
} else {
if (htc_pkt->pBuffer != adf_nbuf_data(pktSkb)) {
EPPING_LOG(VOS_TRACE_LEVEL_ERROR,
"%s: htc_pkt buffer not equal to skb->data", __func__);
ASSERT(0);
}
/* add this to the list, use faster non-lock API */
adf_nbuf_queue_add(&skb_queue,pktSkb);
if (A_SUCCESS(status))
if (htc_pkt->ActualLength != adf_nbuf_len(pktSkb)) {
EPPING_LOG(VOS_TRACE_LEVEL_ERROR,
"%s: htc_pkt length not equal to skb->len", __func__);
ASSERT(0);
}
}
EPPING_LOG(VOS_TRACE_LEVEL_INFO,
"%s skb=%p data=%p len=0x%x eid=%d ",
__func__, pktSkb, htc_pkt->pBuffer,
htc_pkt->ActualLength, eid);
if (A_FAILED(status)) {
if (status == A_ECANCELED) {
/* a packet was flushed */
flushing = TRUE;
}
if (status != A_NO_RESOURCE) {
printk("%s() -TX ERROR, status: 0x%x\n", __func__,
status);
}
} else {
EPPING_LOG(VOS_TRACE_LEVEL_INFO, "%s: OK\n", __func__);
flushing = FALSE;
}
epping_free_cookie(pAdapter->pEpping_ctx, cookie);
}
adf_os_spin_unlock_bh(&pAdapter->data_lock);
/* free all skbs in our local list */
while (adf_nbuf_queue_len(&skb_queue)) {
/* use non-lock version */
pktSkb = adf_nbuf_queue_remove(&skb_queue);
if (pktSkb == NULL)
break;
adf_nbuf_tx_free(pktSkb, ADF_NBUF_PKT_ERROR);
pEpping_ctx->total_tx_acks++;
}
if (!flushing) {
netif_wake_queue(dev);
}
}
A_STATUS htc_start(HTC_HANDLE HTCHandle)
{
cdf_nbuf_t netbuf;
A_STATUS status = A_OK;
HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle);
HTC_SETUP_COMPLETE_EX_MSG *pSetupComp;
HTC_PACKET *pSendPacket;
AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("htc_start Enter\n"));
do {
htc_config_target_hif_pipe(target);
/* allocate a buffer to send */
pSendPacket = htc_alloc_control_tx_packet(target);
if (NULL == pSendPacket) {
AR_DEBUG_ASSERT(false);
cdf_print("%s: allocControlTxPacket failed\n",
__func__);
status = A_NO_MEMORY;
break;
}
netbuf =
(cdf_nbuf_t) GET_HTC_PACKET_NET_BUF_CONTEXT(pSendPacket);
/* assemble setup complete message */
cdf_nbuf_put_tail(netbuf, sizeof(HTC_SETUP_COMPLETE_EX_MSG));
pSetupComp =
(HTC_SETUP_COMPLETE_EX_MSG *) cdf_nbuf_data(netbuf);
A_MEMZERO(pSetupComp, sizeof(HTC_SETUP_COMPLETE_EX_MSG));
HTC_SET_FIELD(pSetupComp, HTC_SETUP_COMPLETE_EX_MSG,
MESSAGEID, HTC_MSG_SETUP_COMPLETE_EX_ID);
if (!htc_credit_flow) {
AR_DEBUG_PRINTF(ATH_DEBUG_INIT,
("HTC will not use TX credit flow control\n"));
pSetupComp->SetupFlags |=
HTC_SETUP_COMPLETE_FLAGS_DISABLE_TX_CREDIT_FLOW;
} else {
AR_DEBUG_PRINTF(ATH_DEBUG_INIT,
("HTC using TX credit flow control\n"));
}
#ifdef HIF_SDIO
#if ENABLE_BUNDLE_RX
if (HTC_ENABLE_BUNDLE(target))
pSetupComp->SetupFlags |=
HTC_SETUP_COMPLETE_FLAGS_ENABLE_BUNDLE_RECV;
#endif /* ENABLE_BUNDLE_RX */
#endif /* HIF_SDIO */
SET_HTC_PACKET_INFO_TX(pSendPacket,
NULL,
(A_UINT8 *) pSetupComp,
sizeof(HTC_SETUP_COMPLETE_EX_MSG),
ENDPOINT_0, HTC_SERVICE_TX_PACKET_TAG);
status = htc_send_pkt((HTC_HANDLE) target, pSendPacket);
if (A_FAILED(status)) {
break;
}
} while (false);
AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("htc_start Exit\n"));
return status;
}
A_STATUS HTCConnectService(HTC_HANDLE HTCHandle,
HTC_SERVICE_CONNECT_REQ *pConnectReq,
HTC_SERVICE_CONNECT_RESP *pConnectResp)
{
HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle);
A_STATUS status = A_OK;
HTC_PACKET *pSendPacket = NULL;
HTC_CONNECT_SERVICE_RESPONSE_MSG *pResponseMsg;
HTC_CONNECT_SERVICE_MSG *pConnectMsg;
HTC_ENDPOINT_ID assignedEndpoint = ENDPOINT_MAX;
HTC_ENDPOINT *pEndpoint;
unsigned int maxMsgSize = 0;
adf_nbuf_t netbuf;
A_UINT8 txAlloc;
int length;
A_BOOL disableCreditFlowCtrl = FALSE;
A_UINT16 conn_flags;
A_UINT16 rsp_msg_id, rsp_msg_serv_id, rsp_msg_max_msg_size;
A_UINT8 rsp_msg_status, rsp_msg_end_id, rsp_msg_serv_meta_len;
AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("+HTCConnectService, target:%p SvcID:0x%X \n",
target, pConnectReq->ServiceID));
do {
AR_DEBUG_ASSERT(pConnectReq->ServiceID != 0);
if (HTC_CTRL_RSVD_SVC == pConnectReq->ServiceID) {
/* special case for pseudo control service */
assignedEndpoint = ENDPOINT_0;
maxMsgSize = HTC_MAX_CONTROL_MESSAGE_LENGTH;
txAlloc = 0;
} else {
txAlloc = HTCGetCreditAllocation(target,pConnectReq->ServiceID);
if (!txAlloc) {
AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("Service %d does not allocate target credits!\n",
pConnectReq->ServiceID));
}
/* allocate a packet to send to the target */
pSendPacket = HTCAllocControlTxPacket(target);
if (NULL == pSendPacket) {
AR_DEBUG_ASSERT(FALSE);
status = A_NO_MEMORY;
break;
}
netbuf = (adf_nbuf_t)GET_HTC_PACKET_NET_BUF_CONTEXT(pSendPacket);
length = sizeof(HTC_CONNECT_SERVICE_MSG) + pConnectReq->MetaDataLength;
/* assemble connect service message */
adf_nbuf_put_tail(netbuf, length);
pConnectMsg = (HTC_CONNECT_SERVICE_MSG *)adf_nbuf_data(netbuf);
AR_DEBUG_ASSERT(pConnectMsg != NULL);
A_MEMZERO(pConnectMsg,sizeof(HTC_CONNECT_SERVICE_MSG));
conn_flags = (pConnectReq->ConnectionFlags & ~HTC_SET_RECV_ALLOC_MASK) |
HTC_CONNECT_FLAGS_SET_RECV_ALLOCATION(txAlloc);
HTC_SET_FIELD(pConnectMsg, HTC_CONNECT_SERVICE_MSG, MESSAGEID,
HTC_MSG_CONNECT_SERVICE_ID);
HTC_SET_FIELD(pConnectMsg, HTC_CONNECT_SERVICE_MSG, SERVICE_ID,
pConnectReq->ServiceID);
HTC_SET_FIELD(pConnectMsg, HTC_CONNECT_SERVICE_MSG,
CONNECTIONFLAGS, conn_flags);
if (pConnectReq->ConnectionFlags & HTC_CONNECT_FLAGS_DISABLE_CREDIT_FLOW_CTRL) {
disableCreditFlowCtrl = TRUE;
}
/*
* EV #134248 BUG Fix : Credit miss happens resulting in failure to create
* VAP. Disable Credit for WMI endpoint too.
*/
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 ) */
A_MEMCPY((A_UINT8 *)pConnectMsg + sizeof(HTC_CONNECT_SERVICE_MSG),
pConnectReq->pMetaData,
pConnectReq->MetaDataLength);
HTC_SET_FIELD(pConnectMsg, HTC_CONNECT_SERVICE_MSG,
SERVICEMETALENGTH, pConnectReq->MetaDataLength);
}
SET_HTC_PACKET_INFO_TX(pSendPacket,
NULL,
(A_UINT8 *)pConnectMsg,
length,
ENDPOINT_0,
HTC_SERVICE_TX_PACKET_TAG);
status = HTCSendPkt((HTC_HANDLE)target,pSendPacket);
/* we don't own it anymore */
pSendPacket = NULL;
if (A_FAILED(status)) {
break;
}
/* wait for response */
status = HTCWaitRecvCtrlMessage(target);
if (A_FAILED(status)) {
break;
}
/* 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);
rsp_msg_serv_id = HTC_GET_FIELD(pResponseMsg,
HTC_CONNECT_SERVICE_RESPONSE_MSG, SERVICEID);
rsp_msg_status = HTC_GET_FIELD(pResponseMsg,
HTC_CONNECT_SERVICE_RESPONSE_MSG, STATUS);
rsp_msg_end_id = HTC_GET_FIELD(pResponseMsg,
HTC_CONNECT_SERVICE_RESPONSE_MSG, ENDPOINTID);
rsp_msg_max_msg_size = HTC_GET_FIELD(pResponseMsg,
HTC_CONNECT_SERVICE_RESPONSE_MSG, MAXMSGSIZE);
rsp_msg_serv_meta_len = HTC_GET_FIELD(pResponseMsg,
HTC_CONNECT_SERVICE_RESPONSE_MSG, SERVICEMETALENGTH);
if ((rsp_msg_id != HTC_MSG_CONNECT_SERVICE_RESPONSE_ID) ||
(target->CtrlResponseLength < sizeof(HTC_CONNECT_SERVICE_RESPONSE_MSG))) {
/* this message is not valid */
AR_DEBUG_ASSERT(FALSE);
status = A_EPROTO;
break;
}
AR_DEBUG_PRINTF(ATH_DEBUG_TRC,
("HTCConnectService, service 0x%X connect response from target status:%d, assigned ep: %d\n",
rsp_msg_serv_id, rsp_msg_status, rsp_msg_end_id));
pConnectResp->ConnectRespCode = rsp_msg_status;
/* check response status */
if (rsp_msg_status != HTC_SERVICE_SUCCESS) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,
(" Target failed service 0x%X connect request (status:%d)\n",
rsp_msg_serv_id, rsp_msg_status));
status = A_EPROTO;
break;
}
assignedEndpoint = (HTC_ENDPOINT_ID)rsp_msg_end_id;
maxMsgSize = rsp_msg_max_msg_size;
if ((pConnectResp->pMetaData != NULL) &&
(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 */
int copyLength = min((int)pConnectResp->BufferLength, (int)rsp_msg_serv_meta_len);
/* copy the meta data */
A_MEMCPY(pConnectResp->pMetaData,
((A_UINT8 *)pResponseMsg) + sizeof(HTC_CONNECT_SERVICE_RESPONSE_MSG),
copyLength);
pConnectResp->ActualLength = copyLength;
}
/* done processing response buffer */
target->CtrlResponseProcessing = FALSE;
}
/* the rest of these are parameter checks so set the error status */
status = A_EPROTO;
if (assignedEndpoint >= ENDPOINT_MAX) {
AR_DEBUG_ASSERT(FALSE);
break;
}
if (0 == maxMsgSize) {
AR_DEBUG_ASSERT(FALSE);
break;
}
pEndpoint = &target->EndPoint[assignedEndpoint];
pEndpoint->Id = assignedEndpoint;
if (pEndpoint->ServiceID != 0) {
/* endpoint already in use! */
AR_DEBUG_ASSERT(FALSE);
break;
}
/* return assigned endpoint to caller */
pConnectResp->Endpoint = assignedEndpoint;
pConnectResp->MaxMsgLength = maxMsgSize;
/* setup the endpoint */
pEndpoint->ServiceID = pConnectReq->ServiceID; /* this marks the endpoint in use */
pEndpoint->MaxTxQueueDepth = pConnectReq->MaxSendQueueDepth;
pEndpoint->MaxMsgLength = maxMsgSize;
pEndpoint->TxCredits = txAlloc;
pEndpoint->TxCreditSize = target->TargetCreditSize;
pEndpoint->TxCreditsPerMaxMsg = maxMsgSize / target->TargetCreditSize;
if (maxMsgSize % target->TargetCreditSize) {
pEndpoint->TxCreditsPerMaxMsg++;
}
/* copy all the callbacks */
pEndpoint->EpCallBacks = pConnectReq->EpCallbacks;
status = HIFMapServiceToPipe(target->hif_dev,
pEndpoint->ServiceID,
&pEndpoint->UL_PipeID,
&pEndpoint->DL_PipeID,
&pEndpoint->ul_is_polled,
&pEndpoint->dl_is_polled);
if (A_FAILED(status)) {
break;
}
adf_os_assert(!pEndpoint->dl_is_polled); /* not currently supported */
if (pEndpoint->ul_is_polled) {
adf_os_timer_init(
target->osdev,
&pEndpoint->ul_poll_timer,
HTCSendCompleteCheckCleanup,
pEndpoint);
}
AR_DEBUG_PRINTF(ATH_DEBUG_SETUP, ("HTC Service:0x%4.4X, ULpipe:%d DLpipe:%d id:%d Ready\n",
pEndpoint->ServiceID,pEndpoint->UL_PipeID,pEndpoint->DL_PipeID,pEndpoint->Id));
if (disableCreditFlowCtrl && pEndpoint->TxCreditFlowEnabled) {
pEndpoint->TxCreditFlowEnabled = FALSE;
AR_DEBUG_PRINTF(ATH_DEBUG_WARN,("HTC Service:0x%4.4X ep:%d TX flow control disabled\n",
pEndpoint->ServiceID, assignedEndpoint));
}
} while (FALSE);
AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("-HTCConnectService \n"));
return status;
}
