ath6kl: Bringing in the upstream version

chromeos/drivers/ath6kl/htc2/htc.c

 //------------------------------------------------------------------------------
 // <copyright file="htc.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"
 
-#ifdef DEBUG
+#ifdef ATH_DEBUG_MODULE
 static ATH_DEBUG_MASK_DESCRIPTION g_HTCDebugDescription[] = {
     { ATH_DEBUG_SEND , "Send"},
     { ATH_DEBUG_RECV , "Recv"},
     { ATH_DEBUG_SYNC , "Sync"},
     { ATH_DEBUG_DUMP , "Dump Data (RX or TX)"},
     { ATH_DEBUG_IRQ  , "Interrupt Processing"}
 };
 
 ATH_DEBUG_INSTANTIATE_MODULE_VAR(htc,
                                  "htc",
@@ skipping 164 matching lines @@
     }
 
     AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("HTCCreate - Exit\n"));
 
     return target;
 }
 
 void  HTCDestroy(HTC_HANDLE HTCHandle)
 {
     HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle);
-    AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("+HTCDestroy ..  Destroying :0x%X \n",(A_UINT32)target));
+    AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("+HTCDestroy ..  Destroying :0x%lX \n",(unsigned long)target));
     HTCCleanup(target);
     AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("-HTCDestroy \n"));
 }
 
 /* get the low level HIF device for the caller , the caller may wish to do low level
  * HIF requests */
 void *HTCGetHifDevice(HTC_HANDLE HTCHandle)
 {
     HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle);
     return target->Device.HIFDevice;
 }
 
 /* wait for the target to arrive (sends HTC Ready message)
  * this operation is fully synchronous and the message is polled for */
 A_STATUS HTCWaitTarget(HTC_HANDLE HTCHandle)
 {
     HTC_TARGET              *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle);
     A_STATUS                 status;
     HTC_PACKET              *pPacket = NULL;
     HTC_READY_EX_MSG        *pRdyMsg;
+
     HTC_SERVICE_CONNECT_REQ  connect;
     HTC_SERVICE_CONNECT_RESP resp;
 
-    AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("HTCWaitTarget - Enter (target:0x%X) \n", (A_UINT32)target));
+    AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("HTCWaitTarget - Enter (target:0x%lX) \n", (unsigned long)target));
 
     do {
 
 #ifdef MBOXHW_UNIT_TEST
 
         status = DoMboxHWTest(&target->Device);
 
         if (status != A_OK) {
             break;
         }
@@ skipping 64 matching lines @@
                 target->MaxMsgPerBundle = 0;        
             } else {
                     /* limit bundle what the device layer can handle */
                 target->MaxMsgPerBundle = min(DEV_GET_MAX_MSG_PER_BUNDLE(&target->Device),
                                               target->MaxMsgPerBundle);     
             }
         }
         
         if (target->MaxMsgPerBundle > 0) {
             AR_DEBUG_PRINTF(ATH_DEBUG_TRC, 
-                    (" HTC bundling allowed. Max Msg Per HTC Bundle: %d\n", target->MaxMsgPerBundle));       
-            target->SendBundlingEnabled = TRUE;
-            target->RecvBundlingEnabled = TRUE;                    
+                    (" HTC bundling allowed. Max Msg Per HTC Bundle: %d\n", target->MaxMsgPerBundle));    
+           
+            if (DEV_GET_MAX_BUNDLE_SEND_LENGTH(&target->Device) != 0) {           
+                target->SendBundlingEnabled = TRUE;
+            }            
+            if (DEV_GET_MAX_BUNDLE_RECV_LENGTH(&target->Device) != 0) {    
+                target->RecvBundlingEnabled = TRUE;    
+            }
+                            
             if (!DEV_IS_LEN_BLOCK_ALIGNED(&target->Device,target->TargetCreditSize)) {
                 AR_DEBUG_PRINTF(ATH_DEBUG_WARN, ("*** Credit size: %d is not block aligned! Disabling send bundling \n",
                         target->TargetCreditSize));    
                     /* disallow send bundling since the credit size is not aligned to a block size
                      * the I/O block padding will spill into the next credit buffer which is fatal */
                 target->SendBundlingEnabled = FALSE;
             }
         }
            
             /* setup our pseudo HTC control endpoint connection */
@@ skipping 62 matching lines @@
         AR_DEBUG_ASSERT(target->EpCreditDistributionListHead != NULL);
         AR_DEBUG_ASSERT(target->EpCreditDistributionListHead->pNext != NULL);
 
             /* call init credits callback to do the distribution ,
              * NOTE: the first entry in the distribution list is ENDPOINT_0, so
              * we pass the start of the list after this one. */
         target->InitCredits(target->pCredDistContext,
                             target->EpCreditDistributionListHead->pNext,
                             target->TargetCredits);
 
+#ifdef ATH_DEBUG_MODULE
+
         if (AR_DEBUG_LVL_CHECK(ATH_DEBUG_TRC)) {
             DumpCreditDistStates(target);
         }
+#endif
 
             /* the caller is done connecting to services, so we can indicate to the
             * target that the setup phase is complete */
         status = HTCSendSetupComplete(target);
 
         if (A_FAILED(status)) {
             break;
         }
 
             /* unmask interrupts */
@@ skipping 41 matching lines @@
 
     LOCK_HTC(target);
         /* mark that we are shutting down .. */
     target->OpStateFlags |= HTC_OP_STATE_STOPPING;
     UNLOCK_HTC(target);
     
         /* Masking interrupts is a synchronous operation, when this function returns
          * all pending HIF I/O has completed, we can safely flush the queues */
     DevMaskInterrupts(&target->Device);
 
+#ifdef THREAD_X
+        //
+        //      Is this delay required
+        //
+    A_MDELAY(200); // wait for IRQ process done
+#endif
         /* flush all send packets */
     HTCFlushSendPkts(target);
         /* flush all recv buffers */
     HTCFlushRecvBuffers(target);
 
     ResetEndpointStates(target);
    
     AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("-HTCStop \n"));
 }
 
+#ifdef ATH_DEBUG_MODULE
 void HTCDumpCreditStates(HTC_HANDLE HTCHandle)
 {
     HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle);
 
     LOCK_HTC_TX(target);
 
     DumpCreditDistStates(target);
 
     UNLOCK_HTC_TX(target);
     
     DumpAR6KDevState(&target->Device);
 }
-
+#endif
 /* report a target failure from the device, this is a callback from the device layer
  * which uses a mechanism to report errors from the target (i.e. special interrupts) */
 static void HTCReportFailure(void *Context)
 {
     HTC_TARGET *target = (HTC_TARGET *)Context;
 
     target->TargetFailure = TRUE;
 
     if (target->HTCInitInfo.TargetFailure != NULL) {
             /* let upper layer know, it needs to call HTCStop() */
@@ skipping 52 matching lines @@
     return FALSE;
 #endif
 }
 
 AR6K_DEVICE  *HTCGetAR6KDevice(void *HTCHandle)
 {
     HTC_TARGET *target = GET_HTC_TARGET_FROM_HANDLE(HTCHandle);
     return &target->Device;
 }