ath6kl: Bringing in the upstream version

chromeos/drivers/ath6kl/htc2/htc_recv.c

 //------------------------------------------------------------------------------
 // <copyright file="htc_recv.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"
 
 #define HTCIssueRecv(t, p) \
     DevRecvPacket(&(t)->Device,  \
                   (p),          \
                   (p)->ActualLength)
 
 #define DO_RCV_COMPLETION(e,q)  DoRecvCompletion(e,q)
 
 #define DUMP_RECV_PKT_INFO(pP) \
-    AR_DEBUG_PRINTF(ATH_DEBUG_RECV, (" HTC RECV packet 0x%X (%d bytes) (hdr:0x%X) on ep : %d \n", \
-                        (A_UINT32)(pP),                        \
+    AR_DEBUG_PRINTF(ATH_DEBUG_RECV, (" HTC RECV packet 0x%lX (%d bytes) (hdr:0x%X) on ep : %d \n", \
+                        (unsigned long)(pP),                   \
                         (pP)->ActualLength,                    \
                         (pP)->PktInfo.AsRx.ExpectedHdr,        \
                         (pP)->Endpoint))                         
                         
 #ifdef HTC_EP_STAT_PROFILING
 #define HTC_RX_STAT_PROFILE(t,ep,numLookAheads)        \
 {                                                      \
     INC_HTC_EP_STAT((ep), RxReceived, 1);              \
     if ((numLookAheads) == 1) {                        \
         INC_HTC_EP_STAT((ep), RxLookAheads, 1);        \
@@ skipping 21 matching lines @@
                      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);
             INIT_HTC_PACKET_QUEUE(pQueueToIndicate);        
         } else {
             HTC_PACKET *pPacket;  
             /* using legacy EpRecv */         
             do {
                 pPacket = HTC_PACKET_DEQUEUE(pQueueToIndicate);
-                AR_DEBUG_PRINTF(ATH_DEBUG_RECV, (" HTC calling ep %d recv callback on packet 0x%X \n", \
-                        pEndpoint->Id, (A_UINT32)(pPacket)));
+                AR_DEBUG_PRINTF(ATH_DEBUG_RECV, (" HTC calling ep %d recv callback on packet 0x%lX \n", \
+                        pEndpoint->Id, (unsigned long)(pPacket)));
                 pEndpoint->EpCallBacks.EpRecv(pEndpoint->EpCallBacks.pContext, pPacket);                                              
             } while (!HTC_QUEUE_EMPTY(pQueueToIndicate));                                              
         }
         
     } while (FALSE);
 
 }
 
 static INLINE A_STATUS HTCProcessTrailer(HTC_TARGET *target,
                                          A_UINT8    *pBuffer,
@@ skipping 59 matching lines @@
                                 (" LookAhead Report Found (pre valid:0x%X, post valid:0x%X) \n",
                                 pLookAhead->PreValid,
                                 pLookAhead->PostValid));
 
                         /* look ahead bytes are valid, copy them over */
                     ((A_UINT8 *)(&pNextLookAheads[0]))[0] = pLookAhead->LookAhead[0];
                     ((A_UINT8 *)(&pNextLookAheads[0]))[1] = pLookAhead->LookAhead[1];
                     ((A_UINT8 *)(&pNextLookAheads[0]))[2] = pLookAhead->LookAhead[2];
                     ((A_UINT8 *)(&pNextLookAheads[0]))[3] = pLookAhead->LookAhead[3];
 
+#ifdef ATH_DEBUG_MODULE
                     if (AR_DEBUG_LVL_CHECK(ATH_DEBUG_RECV)) {
                         DebugDumpBytes((A_UINT8 *)pNextLookAheads,4,"Next Look Ahead");
                     }
+#endif
                         /* just one normal lookahead */
                     *pNumLookAheads = 1;
                 }
                 break;
             case HTC_RECORD_LOOKAHEAD_BUNDLE:
                 AR_DEBUG_ASSERT(pRecord->Length >= sizeof(HTC_BUNDLED_LOOKAHEAD_REPORT));
                 if (pRecord->Length >= sizeof(HTC_BUNDLED_LOOKAHEAD_REPORT) &&
                     (pNextLookAheads != NULL)) {                   
                     HTC_BUNDLED_LOOKAHEAD_REPORT    *pBundledLookAheadRpt;
                     int                             i;
                     
                     pBundledLookAheadRpt = (HTC_BUNDLED_LOOKAHEAD_REPORT *)pRecordBuf;
                     
+#ifdef ATH_DEBUG_MODULE
                     if (AR_DEBUG_LVL_CHECK(ATH_DEBUG_RECV)) {
                         DebugDumpBytes(pRecordBuf,pRecord->Length,"Bundle LookAhead");
                     }
+#endif
                     
                     if ((pRecord->Length / (sizeof(HTC_BUNDLED_LOOKAHEAD_REPORT))) >
                             HTC_HOST_MAX_MSG_PER_BUNDLE) {
                             /* this should never happen, the target restricts the number
                              * of messages per bundle configured by the host */        
                         A_ASSERT(FALSE);
                         status = A_EPROTO;
                         break;        
                     }
                                          
@@ skipping 16 matching lines @@
 
         if (A_FAILED(status)) {
             break;
         }
 
             /* advance buffer past this record for next time around */
         pBuffer += pRecord->Length;
         Length -= pRecord->Length;
     }
 
+#ifdef ATH_DEBUG_MODULE
     if (A_FAILED(status)) {
         DebugDumpBytes(pOrigBuffer,origLength,"BAD Recv Trailer");
     }
+#endif
 
     AR_DEBUG_PRINTF(ATH_DEBUG_RECV, ("-HTCProcessTrailer \n"));
     return status;
 
 }
 
 /* process a received message (i.e. strip off header, process any trailer data)
  * note : locks must be released when this function is called */
 static A_STATUS HTCProcessRecvHeader(HTC_TARGET *target, 
                                      HTC_PACKET *pPacket, 
@@ skipping 52 matching lines @@
                     A_GET_UINT8_FIELD(pBuf, HTC_FRAME_HDR, EndpointID), pPacket->Endpoint));
                 status = A_EPROTO;
                 break;      
             }   
         }
                 
         if (lookAhead != pPacket->PktInfo.AsRx.ExpectedHdr) {
             /* somehow the lookahead that gave us the full read length did not
              * reflect the actual header in the pending message */
              AR_DEBUG_PRINTF(ATH_DEBUG_ERR,
-                    ("HTCProcessRecvHeader, lookahead mismatch! (pPkt:0x%X flags:0x%X) \n", 
-                        (A_UINT32)pPacket, pPacket->PktInfo.AsRx.HTCRxFlags));
+                    ("HTCProcessRecvHeader, lookahead mismatch! (pPkt:0x%lX flags:0x%X) \n", 
+                        (unsigned long)pPacket, pPacket->PktInfo.AsRx.HTCRxFlags));
+#ifdef ATH_DEBUG_MODULE
              DebugDumpBytes((A_UINT8 *)&pPacket->PktInfo.AsRx.ExpectedHdr,4,"Expected Message LookAhead");
              DebugDumpBytes(pBuf,sizeof(HTC_FRAME_HDR),"Current Frame Header");
 #ifdef HTC_CAPTURE_LAST_FRAME
             DebugDumpBytes((A_UINT8 *)&target->LastFrameHdr,sizeof(HTC_FRAME_HDR),"Last Frame Header");
             if (target->LastTrailerLength != 0) {
                 DebugDumpBytes(target->LastTrailer,
                                target->LastTrailerLength,
                                "Last trailer");
             }
 #endif
+#endif
             status = A_EPROTO;
             break;
         }
 
             /* get flags */
         temp = A_GET_UINT8_FIELD(pBuf, HTC_FRAME_HDR, Flags);
 
         if (temp & HTC_FLAGS_RECV_TRAILER) {
             /* this packet has a trailer */
 
@@ skipping 43 matching lines @@
 
             /* if we get to this point, the packet is good */
             /* remove header and adjust length */
         pPacket->pBuffer += HTC_HDR_LENGTH;
         pPacket->ActualLength -= HTC_HDR_LENGTH;
 
     } while (FALSE);
 
     if (A_FAILED(status)) {
             /* dump the whole packet */
+#ifdef ATH_DEBUG_MODULE
         DebugDumpBytes(pBuf,pPacket->ActualLength < 256 ? pPacket->ActualLength : 256 ,"BAD HTC Recv PKT");
+#endif
     } else {
 #ifdef HTC_CAPTURE_LAST_FRAME
         A_MEMCPY(&target->LastFrameHdr,pBuf,sizeof(HTC_FRAME_HDR));
 #endif
         if (AR_DEBUG_LVL_CHECK(ATH_DEBUG_RECV)) {
             if (pPacket->ActualLength > 0) {
                 AR_DEBUG_PRINTBUF(pPacket->pBuffer,pPacket->ActualLength,"HTC - Application Msg");
             }
         }
     }
@@ skipping 14 matching lines @@
         AR_DEBUG_PRINTF(ATH_DEBUG_RECV,
                         ("HTCAsyncRecvCheckMorePackets - num lookaheads were non-zero : %d \n",
                          NumLookAheads));
             /* force status re-check */                    
         REF_IRQ_STATUS_RECHECK(&target->Device);
             /* we have more packets, get the next packet fetch started */
         nextStatus = HTCRecvMessagePendingHandler(target, NextLookAheads, NumLookAheads, NULL, &fetched);
         if (A_EPROTO == nextStatus) {
             AR_DEBUG_PRINTF(ATH_DEBUG_ERR,
                         ("Next look ahead from recv header was INVALID\n"));
+#ifdef ATH_DEBUG_MODULE
             DebugDumpBytes((A_UINT8 *)NextLookAheads,
                             NumLookAheads * (sizeof(A_UINT32)),
                             "BAD lookaheads from lookahead report");
+#endif
         }
         if (A_SUCCESS(nextStatus) && !fetched) {
                 /* we could not fetch any more packets due to resources */
             DevAsyncIrqProcessComplete(&target->Device);        
         }
     } else {
         if (CheckMoreMsgs) {
             AR_DEBUG_PRINTF(ATH_DEBUG_RECV,
                 ("HTCAsyncRecvCheckMorePackets - rechecking for more messages...\n"));
             /* if we did not get anything on the look-ahead,
@@ skipping 95 matching lines @@
  * completes a read request, it will call this completion handler */
 void HTCRecvCompleteHandler(void *Context, HTC_PACKET *pPacket)
 {
     HTC_TARGET      *target = (HTC_TARGET *)Context;
     HTC_ENDPOINT    *pEndpoint;
     A_UINT32        nextLookAheads[HTC_HOST_MAX_MSG_PER_BUNDLE];
     int             numLookAheads = 0;
     A_STATUS        status;
     A_BOOL          checkMorePkts = TRUE;
 
-    AR_DEBUG_PRINTF(ATH_DEBUG_RECV, ("+HTCRecvCompleteHandler (pkt:0x%X, status:%d, ep:%d) \n",
-                (A_UINT32)pPacket, pPacket->Status, pPacket->Endpoint));
+    AR_DEBUG_PRINTF(ATH_DEBUG_RECV, ("+HTCRecvCompleteHandler (pkt:0x%lX, status:%d, ep:%d) \n",
+                (unsigned long)pPacket, pPacket->Status, pPacket->Endpoint));
 
     A_ASSERT(!IS_DEV_IRQ_PROC_SYNC_MODE(&target->Device));
     AR_DEBUG_ASSERT(pPacket->Endpoint < ENDPOINT_MAX);
     pEndpoint = &target->EndPoint[pPacket->Endpoint];
     pPacket->Completion = NULL;
 
         /* get completion status */
     status = pPacket->Status;
 
     do {
@@ skipping 178 matching lines @@
         if (pHdr->EndpointID != pEndpoint->Id) {
             AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Invalid Endpoint in look-ahead: %d should be : %d (index:%d)\n",
                 pHdr->EndpointID, pEndpoint->Id, i));
                 /* invalid endpoint */
             status = A_EPROTO;
             break;    
         }    
        
         if (pHdr->PayloadLen > HTC_MAX_PAYLOAD_LENGTH) {
             AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Payload length %d exceeds max HTC : %d !\n",
-                    pHdr->PayloadLen, HTC_MAX_PAYLOAD_LENGTH));
+                    pHdr->PayloadLen, (A_UINT32)HTC_MAX_PAYLOAD_LENGTH));
             status = A_EPROTO;
             break;
         }
 
         if (0 == pEndpoint->ServiceID) {
             AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Endpoint %d is not connected !\n",pHdr->EndpointID));
                 /* endpoint isn't even connected */
             status = A_EPROTO;
             break;
         }
@@ skipping 756 matching lines @@
     LOCK_HTC_RX(target);
 
     while (1) {
         pPacket = HTC_PACKET_DEQUEUE(pQueue);
         if (NULL == pPacket) {
             break;
         }
         UNLOCK_HTC_RX(target);
         pPacket->Status = A_ECANCELED;
         pPacket->ActualLength = 0;
-        AR_DEBUG_PRINTF(ATH_DEBUG_RECV, ("  Flushing RX packet:0x%X, length:%d, ep:%d \n",
-                (A_UINT32)pPacket, pPacket->BufferLength, pPacket->Endpoint));
+        AR_DEBUG_PRINTF(ATH_DEBUG_RECV, ("  Flushing RX packet:0x%lX, length:%d, ep:%d \n",
+                (unsigned long)pPacket, pPacket->BufferLength, pPacket->Endpoint));
         INIT_HTC_PACKET_QUEUE_AND_ADD(&container,pPacket);
             /* give the packet back */
         DO_RCV_COMPLETION(pEndpoint,&container);
         LOCK_HTC_RX(target);
     }
     
     UNLOCK_HTC_RX(target);
 }
 
 static void HTCFlushEndpointRX(HTC_TARGET *target, HTC_ENDPOINT *pEndpoint)
@@ skipping 40 matching lines @@
     }
 }
 
 int HTCGetNumRecvBuffers(HTC_HANDLE      HTCHandle,
                          HTC_ENDPOINT_ID Endpoint)
 {
     HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle);    
     return HTC_PACKET_QUEUE_DEPTH(&(target->EndPoint[Endpoint].RxBuffers));
 }
 
+A_STATUS HTCWaitForPendingRecv(HTC_HANDLE   HTCHandle,
+                               A_UINT32     TimeoutInMs,
+                               A_BOOL      *pbIsRecvPending)
+{
+    A_STATUS    status  = A_OK;
+    HTC_TARGET *target  = GET_HTC_TARGET_FROM_HANDLE(HTCHandle);
+
+    status = DevWaitForPendingRecv(&target->Device,
+                                    TimeoutInMs,
+                                    pbIsRecvPending);
+
+    return status;
+}