ath6kl: Bringing in the upstream version

chromeos/drivers/ath6kl/bmi/src/bmi.c

 //------------------------------------------------------------------------------
 // <copyright file="bmi.c" company="Atheros">
-//    Copyright (c) 2004-2008 Atheros Corporation.  All rights reserved.
+//    Copyright (c) 2004-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"
 //==============================================================================
 
 
+#ifdef THREAD_X
+#include <string.h>
+#endif
+
 #include "hif.h"
 #include "bmi.h"
 #include "htc_api.h"
 #include "bmi_internal.h"
 
-#ifdef DEBUG
+#ifdef ATH_DEBUG_MODULE
 static ATH_DEBUG_MASK_DESCRIPTION bmi_debug_desc[] = {
     { ATH_DEBUG_BMI , "BMI Tracing"},
 };
 
 ATH_DEBUG_INSTANTIATE_MODULE_VAR(bmi,
                                  "bmi",
                                  "Boot Manager Interface",
                                  ATH_DEBUG_MASK_DEFAULTS,
                                  ATH_DEBUG_DESCRIPTION_COUNT(bmi_debug_desc),
                                  bmi_debug_desc);
@@ skipping 38 matching lines @@
     }
 
     if (!pBMICmdBuf) {
         pBMICmdBuf = (A_UCHAR *)A_MALLOC_NOWAIT(MAX_BMI_CMDBUF_SZ);
         A_ASSERT(pBMICmdBuf);
     }
     
     A_REGISTER_MODULE_DEBUG_INFO(bmi);
 }
 
+void
+BMICleanup(void)
+{
+    if (pBMICmdCredits) {
+        A_FREE(pBMICmdCredits);
+        pBMICmdCredits = NULL;
+    }
+
+    if (pBMICmdBuf) {
+        A_FREE(pBMICmdBuf);
+        pBMICmdBuf = NULL;
+    }
+}
+
 A_STATUS
 BMIDone(HIF_DEVICE *device)
 {
     A_STATUS status;
     A_UINT32 cid;
 
     if (bmiDone) {
         AR_DEBUG_PRINTF (ATH_DEBUG_BMI, ("BMIDone skipped\n"));
         return A_OK;
     }
@@ skipping 67 matching lines @@
 
         /* Read the remainder of the targ_info */
         status = bmiBufferReceive(device,
                         ((A_UCHAR *)targ_info)+sizeof(targ_info->target_info_byte_count),
                         sizeof(*targ_info)-sizeof(targ_info->target_info_byte_count), TRUE);
         if (status != A_OK) {
             AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Unable to read Target Info (%d bytes) from the device\n",
                                                                 targ_info->target_info_byte_count));
             return A_ERROR;
         }
-    } else {
-        /*
-         * Target must be an AR6001 whose firmware does not
-         * support BMI_GET_TARGET_INFO.  Construct the data
-         * that it would have sent.
-         */
-        targ_info->target_info_byte_count=sizeof(*targ_info);
-        targ_info->target_type=TARGET_TYPE_AR6001;
     }
 
     AR_DEBUG_PRINTF(ATH_DEBUG_BMI, ("BMI Get Target Info: Exit (ver: 0x%x type: 0x%x)\n",
                                                                 targ_info->target_ver, targ_info->target_type));
 
     return A_OK;
 }
 
 A_STATUS
 BMIReadMemory(HIF_DEVICE *device,
@@ skipping 55 matching lines @@
 BMIWriteMemory(HIF_DEVICE *device,
                A_UINT32 address,
                A_UCHAR *buffer,
                A_UINT32 length)
 {
     A_UINT32 cid;
     A_STATUS status;
     A_UINT32 offset;
     A_UINT32 remaining, txlen;
     const A_UINT32 header = sizeof(cid) + sizeof(address) + sizeof(length);
-    
+    A_UCHAR alignedBuffer[BMI_DATASZ_MAX];
+    A_UCHAR *src;
+
     A_ASSERT(BMI_COMMAND_FITS(BMI_DATASZ_MAX + header));
     memset (pBMICmdBuf, 0, BMI_DATASZ_MAX + header);
 
     if (bmiDone) {
         AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Command disallowed\n"));
         return A_ERROR;
     }
 
     AR_DEBUG_PRINTF(ATH_DEBUG_BMI,
          ("BMI Write Memory: Enter (device: 0x%p, address: 0x%x, length: %d)\n",
          device, address, length));
 
     cid = BMI_WRITE_MEMORY;
 
     remaining = length;
     while (remaining)
     {
-        txlen = (remaining < (BMI_DATASZ_MAX - header)) ?
-                                       remaining : (BMI_DATASZ_MAX - header);
+        src = &buffer[length - remaining];
+        if (remaining < (BMI_DATASZ_MAX - header)) {
+            if (remaining & 3) {
+                /* align it with 4 bytes */
+                remaining = remaining + (4 - (remaining & 3));
+                memcpy(alignedBuffer, src, remaining);
+                src = alignedBuffer;
+            } 
+            txlen = remaining;
+        } else {
+            txlen = (BMI_DATASZ_MAX - header);
+        }
         offset = 0;
         A_MEMCPY(&(pBMICmdBuf[offset]), &cid, sizeof(cid));
         offset += sizeof(cid);
         A_MEMCPY(&(pBMICmdBuf[offset]), &address, sizeof(address));
         offset += sizeof(address);
         A_MEMCPY(&(pBMICmdBuf[offset]), &txlen, sizeof(txlen));
         offset += sizeof(txlen);
-        A_MEMCPY(&(pBMICmdBuf[offset]), &buffer[length - remaining], txlen);
+        A_MEMCPY(&(pBMICmdBuf[offset]), src, txlen);
         offset += txlen;
         status = bmiBufferSend(device, pBMICmdBuf, offset);
         if (status != A_OK) {
             AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Unable to write to the device\n"));
             return A_ERROR;
         }
         remaining -= txlen; address += txlen;
     }
 
     AR_DEBUG_PRINTF(ATH_DEBUG_BMI, ("BMI Write Memory: Exit\n"));
@@ skipping 681 matching lines @@
 BMIRawWrite(HIF_DEVICE *device, A_UCHAR *buffer, A_UINT32 length)
 {
     return bmiBufferSend(device, buffer, length);
 }
 
 A_STATUS
 BMIRawRead(HIF_DEVICE *device, A_UCHAR *buffer, A_UINT32 length, A_BOOL want_timeout)
 {
     return bmiBufferReceive(device, buffer, length, want_timeout);
 }