ath6kl: Bringing in the upstream version

chromeos/drivers/ath6kl/htc2/htc_send.c

 //------------------------------------------------------------------------------
 // <copyright file="htc_send.c" company="Atheros">
-//    Copyright (c) 2007-2008 Atheros Corporation.  All rights reserved.
+//    Copyright (c) 2007-2010 Atheros Corporation.  All rights reserved.
 // 
-// This program is free software; you can redistribute it and/or modify
-// it under the terms of the GNU General Public License version 2 as
-// published by the Free Software Foundation;
 //
-// Software distributed under the License is distributed on an "AS
-// IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-// implied. See the License for the specific language governing
-// rights and limitations under the License.
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 //
 //
 //------------------------------------------------------------------------------
 //==============================================================================
 // Author(s): ="Atheros"
 //==============================================================================
 #include "htc_internal.h"
 
 typedef 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;
 
 #define DO_EP_TX_COMPLETION(ep,q)  DoSendCompletion(ep,q)
 
 /* call the distribute credits callback with the distribution */
 #define DO_DISTRIBUTION(t,reason,description,pList) \
 {                                             \
     AR_DEBUG_PRINTF(ATH_DEBUG_SEND,           \
-        ("  calling distribute function (%s) (dfn:0x%X, ctxt:0x%X, dist:0x%X) \n", \
+        ("  calling distribute function (%s) (dfn:0x%lX, ctxt:0x%lX, dist:0x%lX) \n", \
                 (description),                                           \
-                (A_UINT32)(t)->DistributeCredits,                        \
-                (A_UINT32)(t)->pCredDistContext,                         \
-                (A_UINT32)pList));                                       \
+                (unsigned long)(t)->DistributeCredits,                   \
+                (unsigned long)(t)->pCredDistContext,                    \
+                (unsigned long)pList));                                  \
     (t)->DistributeCredits((t)->pCredDistContext,                        \
                            (pList),                                      \
                            (reason));                                    \
 }
 
 static void DoSendCompletion(HTC_ENDPOINT       *pEndpoint,
                              HTC_PACKET_QUEUE   *pQueueToIndicate)
 {           
     do {
                 
         if (HTC_QUEUE_EMPTY(pQueueToIndicate)) {
                 /* nothing to indicate */
             break;    
         }
  
         if (pEndpoint->EpCallBacks.EpTxCompleteMultiple != NULL) {    
             AR_DEBUG_PRINTF(ATH_DEBUG_SEND, (" 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 */
             INIT_HTC_PACKET_QUEUE(pQueueToIndicate);                                                      
         } else {
             HTC_PACKET *pPacket;  
             /* using legacy EpTxComplete */         
             do {
                 pPacket = HTC_PACKET_DEQUEUE(pQueueToIndicate);
-                AR_DEBUG_PRINTF(ATH_DEBUG_SEND, (" HTC calling ep %d send complete callback on packet 0x%X \n", \
-                        pEndpoint->Id, (A_UINT32)(pPacket)));
+                AR_DEBUG_PRINTF(ATH_DEBUG_SEND, (" HTC calling ep %d send complete callback on packet 0x%lX \n", \
+                        pEndpoint->Id, (unsigned long)(pPacket)));
                 pEndpoint->EpCallBacks.EpTxComplete(pEndpoint->EpCallBacks.pContext, pPacket);                                              
             } while (!HTC_QUEUE_EMPTY(pQueueToIndicate));                                              
         }
         
     } while (FALSE);
 
 }
 
 /* do final completion on sent packet */
 static INLINE void CompleteSentPacket(HTC_TARGET *target, HTC_ENDPOINT *pEndpoint, HTC_PACKET *pPacket)
@@ skipping 37 matching lines @@
     A_STATUS status;
     A_BOOL   sync = FALSE;
 
     if (pPacket->Completion == NULL) {
             /* mark that this request was synchronously issued */
         sync = TRUE;
     }
 
     AR_DEBUG_PRINTF(ATH_DEBUG_SEND,
                     ("+-HTCIssueSend: transmit length : %d (%s) \n",
-                    pPacket->ActualLength + HTC_HDR_LENGTH,
+                    pPacket->ActualLength + (A_UINT32)HTC_HDR_LENGTH,
                     sync ? "SYNC" : "ASYNC" ));
 
         /* send message to device */
     status = DevSendPacket(&target->Device,
                            pPacket,
                            pPacket->ActualLength + HTC_HDR_LENGTH);
 
     if (sync) {
             /* use local sync variable.  If this was issued asynchronously, pPacket is no longer
              * safe to access. */
@@ skipping 23 matching lines @@
         /* loop until we can grab as many packets out of the queue as we can */       
     while (TRUE) {    
         
         sendFlags = 0;   
             /* get packet at head, but don't remove it */
         pPacket = HTC_GET_PKT_AT_HEAD(&pEndpoint->TxQueue);       
         if (pPacket == NULL) {
             break;    
         }
         
-        AR_DEBUG_PRINTF(ATH_DEBUG_SEND,(" Got head packet:0x%X , Queue Depth: %d\n",
-                (A_UINT32)pPacket, HTC_PACKET_QUEUE_DEPTH(&pEndpoint->TxQueue)));
+        AR_DEBUG_PRINTF(ATH_DEBUG_SEND,(" Got head packet:0x%lX , Queue Depth: %d\n",
+                (unsigned long)pPacket, HTC_PACKET_QUEUE_DEPTH(&pEndpoint->TxQueue)));
         
         transferLength = DEV_CALC_SEND_PADDED_LEN(&target->Device, pPacket->ActualLength + HTC_HDR_LENGTH);       
        
         if (transferLength <= target->TargetCreditSize) {
             creditsRequired = 1;    
         } else {
                 /* figure out how many credits this message requires */
             creditsRequired = transferLength / target->TargetCreditSize;
             remainder = transferLength % target->TargetCreditSize;
             
@@ skipping 234 matching lines @@
             HTC_PREPARE_SEND_PKT(pPacket,
                                  pPacket->PktInfo.AsTx.SendFlags | HTC_FLAGS_SEND_BUNDLE, 
                                  creditPad,                                 
                                  pPacket->PktInfo.AsTx.SeqNo); 
             pScatterReq->ScatterList[i].pBuffer = pPacket->pBuffer;
             pScatterReq->ScatterList[i].Length = transferLength;
             A_ASSERT(transferLength);
             pScatterReq->TotalLength += transferLength;
             pScatterReq->ValidScatterEntries++;
             packetsInScatterReq++;             
-            AR_DEBUG_PRINTF(ATH_DEBUG_SEND,("  %d, Adding packet : 0x%X, len:%d (remaining space:%d) \n", 
-                    i, (A_UINT32)pPacket,transferLength,scatterSpaceRemaining));                                                      
+            AR_DEBUG_PRINTF(ATH_DEBUG_SEND,("  %d, Adding packet : 0x%lX, len:%d (remaining space:%d) \n", 
+                    i, (unsigned long)pPacket,transferLength,scatterSpaceRemaining));                                                      
         }
                     
         if (packetsInScatterReq >= HTC_MIN_HTC_MSGS_TO_BUNDLE) {          
                 /* send path is always asynchronous */
             pScatterReq->CompletionRoutine = HTCAsyncSendScatterCompletion;
             pScatterReq->Context = pEndpoint;
             bundlesSent++;
             totalPktsInBundle += packetsInScatterReq;
             packetsInScatterReq = 0;
             AR_DEBUG_PRINTF(ATH_DEBUG_SEND,(" Send Scatter total bytes: %d , entries: %d\n",
@@ skipping 41 matching lines @@
                                         HTC_ENDPOINT     *pEndpoint,
                                         HTC_PACKET_QUEUE *pCallersSendQueue)
 {
     HTC_PACKET_QUEUE      sendQueue; /* temp queue to hold packets at various stages */
     HTC_PACKET            *pPacket;
     int                   bundlesSent;
     int                   pktsInBundles;
     int                   overflow;
     HTC_SEND_QUEUE_RESULT result = HTC_SEND_QUEUE_OK;
     
-    AR_DEBUG_PRINTF(ATH_DEBUG_SEND,("+HTCTrySend (Queue:0x%X Depth:%d)\n",
-            (A_UINT32)pCallersSendQueue, 
+    AR_DEBUG_PRINTF(ATH_DEBUG_SEND,("+HTCTrySend (Queue:0x%lX Depth:%d)\n",
+            (unsigned long)pCallersSendQueue, 
             (pCallersSendQueue == NULL) ? 0 : HTC_PACKET_QUEUE_DEPTH(pCallersSendQueue)));
 
         /* init the local send queue */
     INIT_HTC_PACKET_QUEUE(&sendQueue);
     
     do {
         
         if (NULL == pCallersSendQueue) {
                 /* caller didn't provide a queue, just wants us to check queues and send */
             break;    
@@ skipping 38 matching lines @@
                 pPacket = HTC_PACKET_DEQUEUE(pCallersSendQueue);
                 A_ASSERT(pPacket != NULL);
                     /* insert into local queue */
                 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 */            
             ITERATE_OVER_LIST_ALLOW_REMOVE(&pCallersSendQueue->QueueHead, pPacket, HTC_PACKET, ListLink) {            
                 
-                AR_DEBUG_PRINTF(ATH_DEBUG_SEND, (" Indicating overflowed TX packet: 0x%X \n", 
-                                            (A_UINT32)pPacket));    
+                AR_DEBUG_PRINTF(ATH_DEBUG_SEND, (" Indicating overflowed TX packet: 0x%lX \n", 
+                                            (unsigned long)pPacket));    
                 if (pEndpoint->EpCallBacks.EpSendFull(pEndpoint->EpCallBacks.pContext,
                                                       pPacket) == HTC_SEND_FULL_DROP) {
                         /* callback wants the packet dropped */
                     INC_HTC_EP_STAT(pEndpoint, TxDropped, 1);
                         /* leave this one in the caller's queue for cleanup */
                 } else {
                         /* callback wants to keep this packet, remove from caller's queue */
                     HTC_PACKET_REMOVE(pCallersSendQueue, pPacket);
                         /* put it in the send queue */
                     HTC_PACKET_ENQUEUE(&sendQueue,pPacket);                                      
@@ skipping 104 matching lines @@
 
     return HTC_SEND_QUEUE_OK;
 }
 
 A_STATUS  HTCSendPktsMultiple(HTC_HANDLE HTCHandle, HTC_PACKET_QUEUE *pPktQueue)
 {
     HTC_TARGET      *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle);
     HTC_ENDPOINT    *pEndpoint;
     HTC_PACKET      *pPacket;
 
-    AR_DEBUG_PRINTF(ATH_DEBUG_SEND, ("+HTCSendPktsMultiple: Queue: 0x%X, Pkts %d \n",
-                    (A_UINT32)pPktQueue, HTC_PACKET_QUEUE_DEPTH(pPktQueue)));
+    AR_DEBUG_PRINTF(ATH_DEBUG_SEND, ("+HTCSendPktsMultiple: Queue: 0x%lX, Pkts %d \n",
+                    (unsigned long)pPktQueue, HTC_PACKET_QUEUE_DEPTH(pPktQueue)));
     
         /* get packet at head to figure out which endpoint these packets will go into */
     pPacket = HTC_GET_PKT_AT_HEAD(pPktQueue);
     if (NULL == pPacket) {
         AR_DEBUG_PRINTF(ATH_DEBUG_SEND, ("-HTCSendPktsMultiple \n"));
         return A_EINVAL;   
     }
     
     AR_DEBUG_ASSERT(pPacket->Endpoint < ENDPOINT_MAX);
     pEndpoint = &target->EndPoint[pPacket->Endpoint];
@@ skipping 18 matching lines @@
 
     return A_OK;   
 }
 
 /* HTC API - HTCSendPkt */
 A_STATUS HTCSendPkt(HTC_HANDLE HTCHandle, HTC_PACKET *pPacket)
 {
     HTC_PACKET_QUEUE queue;
     
     AR_DEBUG_PRINTF(ATH_DEBUG_SEND,
-                    ("+-HTCSendPkt: Enter endPointId: %d, buffer: 0x%X, length: %d \n",
-                    pPacket->Endpoint, (A_UINT32)pPacket->pBuffer, pPacket->ActualLength));                   
+                    ("+-HTCSendPkt: Enter endPointId: %d, buffer: 0x%lX, length: %d \n",
+                    pPacket->Endpoint, (unsigned long)pPacket->pBuffer, pPacket->ActualLength));                   
     INIT_HTC_PACKET_QUEUE_AND_ADD(&queue,pPacket); 
     return HTCSendPktsMultiple(HTCHandle, &queue);
 }
 
 /* check TX queues to drain because of credit distribution update */
 static INLINE void HTCCheckEndpointTxQueues(HTC_TARGET *target)
 {
     HTC_ENDPOINT                *pEndpoint;
     HTC_ENDPOINT_CREDIT_DIST    *pDistItem;
 
@@ skipping 135 matching lines @@
 
     UNLOCK_HTC_TX(target);
 
         /* empty the discard queue */
     while (1) {
         pPacket = HTC_PACKET_DEQUEUE(&discardQueue);
         if (NULL == pPacket) {
             break;
         }
         pPacket->Status = A_ECANCELED;
-        AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("  Flushing TX packet:0x%X, length:%d, ep:%d tag:0x%X \n",
-                (A_UINT32)pPacket, pPacket->ActualLength, pPacket->Endpoint, pPacket->PktInfo.AsTx.Tag));
+        AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("  Flushing TX packet:0x%lX, length:%d, ep:%d tag:0x%X \n",
+                (unsigned long)pPacket, pPacket->ActualLength, pPacket->Endpoint, pPacket->PktInfo.AsTx.Tag));
         INIT_HTC_PACKET_QUEUE_AND_ADD(&container,pPacket);
         DO_EP_TX_COMPLETION(pEndpoint,&container);
     }
 
 }
 
 void DumpCreditDist(HTC_ENDPOINT_CREDIT_DIST *pEPDist)
 {
     AR_DEBUG_PRINTF(ATH_DEBUG_ANY, ("--- EP : %d  ServiceID: 0x%X    --------------\n",
                         pEPDist->Endpoint, pEPDist->ServiceID));
-    AR_DEBUG_PRINTF(ATH_DEBUG_ANY, (" this:0x%X next:0x%X prev:0x%X\n",
-                (A_UINT32)pEPDist, (A_UINT32)pEPDist->pNext, (A_UINT32)pEPDist->pPrev));
+    AR_DEBUG_PRINTF(ATH_DEBUG_ANY, (" this:0x%lX next:0x%lX prev:0x%lX\n",
+                (unsigned long)pEPDist, (unsigned long)pEPDist->pNext, (unsigned long)pEPDist->pPrev));
     AR_DEBUG_PRINTF(ATH_DEBUG_ANY, (" DistFlags          : 0x%X \n", pEPDist->DistFlags));
     AR_DEBUG_PRINTF(ATH_DEBUG_ANY, (" TxCreditsNorm      : %d \n", pEPDist->TxCreditsNorm));
     AR_DEBUG_PRINTF(ATH_DEBUG_ANY, (" TxCreditsMin       : %d \n", pEPDist->TxCreditsMin));
     AR_DEBUG_PRINTF(ATH_DEBUG_ANY, (" TxCredits          : %d \n", pEPDist->TxCredits));
     AR_DEBUG_PRINTF(ATH_DEBUG_ANY, (" TxCreditsAssigned  : %d \n", pEPDist->TxCreditsAssigned));
     AR_DEBUG_PRINTF(ATH_DEBUG_ANY, (" TxCreditsSeek      : %d \n", pEPDist->TxCreditsSeek));
     AR_DEBUG_PRINTF(ATH_DEBUG_ANY, (" TxCreditSize       : %d \n", pEPDist->TxCreditSize));
     AR_DEBUG_PRINTF(ATH_DEBUG_ANY, (" TxCreditsPerMaxMsg : %d \n", pEPDist->TxCreditsPerMaxMsg));
     AR_DEBUG_PRINTF(ATH_DEBUG_ANY, (" TxCreditsToDist    : %d \n", pEPDist->TxCreditsToDist));
     AR_DEBUG_PRINTF(ATH_DEBUG_ANY, (" TxQueueDepth       : %d \n", 
@@ skipping 116 matching lines @@
     if (pEndpoint->ServiceID == 0) {
         return FALSE;
     }
     
     if (pEndpoint->CreditDist.DistFlags & HTC_EP_ACTIVE) {
         return TRUE;
     }
     
     return FALSE;
 }