ath6kl: Bringing in the upstream version

chromeos/drivers/ath6kl/hif/sdio/linux_sdio/src/hif_scatter.c

 //------------------------------------------------------------------------------
-// <copyright file="hif_scatter.c" company="Atheros">
-//    Copyright (c) 2009 Atheros Corporation.  All rights reserved.
+// Copyright (c) 2009-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.
 //
 //
 //------------------------------------------------------------------------------
 //==============================================================================
 // HIF scatter implementation
 //
 // Author(s): ="Atheros"
 //==============================================================================
 
 #include <linux/mmc/card.h>
@@ skipping 97 matching lines @@
         opcode = _CMD53_ARG_INCR_ADDRESS;
     }
     
         /* fill SG entries */
     pSg = pReqPriv->sgentries;   
     sg_init_table(pSg, pReq->ValidScatterEntries); 
           
         /* assemble SG list */   
     for (i = 0 ; i < pReq->ValidScatterEntries ; i++, pSg++) {
             /* setup each sg entry */
-        if ((A_UINT32)pReq->ScatterList[i].pBuffer & 0x3) {
+        if ((unsigned long)pReq->ScatterList[i].pBuffer & 0x3) {
                 /* note some scatter engines can handle unaligned buffers, print this
                  * as informational only */
             AR_DEBUG_PRINTF(ATH_DEBUG_SCATTER,
-                            ("HIF: (%s) Scatter Buffer is unaligned 0x%08x\n",
+                            ("HIF: (%s) Scatter Buffer is unaligned 0x%lx\n",
                             pReq->Request & HIF_WRITE ? "WRITE":"READ",
-                            (A_UINT32)pReq->ScatterList[i].pBuffer)); 
+                            (unsigned long)pReq->ScatterList[i].pBuffer)); 
         }
         
-        AR_DEBUG_PRINTF(ATH_DEBUG_SCATTER, ("  %d:  Addr:0x%X, Len:%d \n",
-            i,(A_UINT32)pReq->ScatterList[i].pBuffer,pReq->ScatterList[i].Length));
+        AR_DEBUG_PRINTF(ATH_DEBUG_SCATTER, ("  %d:  Addr:0x%lX, Len:%d \n",
+            i,(unsigned long)pReq->ScatterList[i].pBuffer,pReq->ScatterList[i].Length));
             
         sg_set_buf(pSg, pReq->ScatterList[i].pBuffer, pReq->ScatterList[i].Length);
     }
         /* set scatter-gather table for request */
     data.sg = pReqPriv->sgentries;
     data.sg_len = pReq->ValidScatterEntries;
         /* set command argument */    
     SDIO_SET_CMD53_ARG(cmd.arg, 
                        rw, 
                        device->func->num, 
@@ skipping 24 matching lines @@
 
     if (A_FAILED(status)) {
         AR_DEBUG_PRINTF(ATH_DEBUG_ERROR, ("HIF-SCATTER: FAILED!!! (%s) Address: 0x%X, Block mode (BlockLen: %d, BlockCount: %d)\n",
               (pReq->Request & HIF_WRITE) ? "WRITE":"READ",pReq->Address, data.blksz, data.blocks));        
     }
     
         /* set completion status, fail or success */
     pReq->CompletionStatus = status;
     
     if (pReq->Request & HIF_ASYNCHRONOUS) {
-        AR_DEBUG_PRINTF(ATH_DEBUG_SCATTER, ("HIF-SCATTER: async_task completion routine req: 0x%X (%d)\n",(unsigned int)busrequest, status));
+        AR_DEBUG_PRINTF(ATH_DEBUG_SCATTER, ("HIF-SCATTER: async_task completion routine req: 0x%lX (%d)\n",(unsigned long)busrequest, status));
             /* complete the request */
         A_ASSERT(pReq->CompletionRoutine != NULL);
         pReq->CompletionRoutine(pReq);
     } else {
-        AR_DEBUG_PRINTF(ATH_DEBUG_SCATTER, ("HIF-SCATTER async_task upping busrequest : 0x%X (%d)\n", (unsigned int)busrequest,status));
+        AR_DEBUG_PRINTF(ATH_DEBUG_SCATTER, ("HIF-SCATTER async_task upping busrequest : 0x%lX (%d)\n", (unsigned long)busrequest,status));
             /* signal wait */
         up(&busrequest->sem_req);
     }
                                                                
     return status;   
 }
 
     /* callback to issue a read-write scatter request */
 static A_STATUS HifReadWriteScatter(HIF_DEVICE *device, HIF_SCATTER_REQ *pReq)
 {
@@ skipping 34 matching lines @@
         
         if (pReq->TotalLength == 0) {
             A_ASSERT(FALSE);
             break;    
         }
         
             /* add bus request to the async list for the async I/O thread to process */
         AddToAsyncList(device, pReqPriv->busrequest);
 
         if (request & HIF_SYNCHRONOUS) {
-            AR_DEBUG_PRINTF(ATH_DEBUG_SCATTER, ("HIF-SCATTER: queued sync req: 0x%X\n", (unsigned int)pReqPriv->busrequest));
+            AR_DEBUG_PRINTF(ATH_DEBUG_SCATTER, ("HIF-SCATTER: queued sync req: 0x%lX\n", (unsigned long)pReqPriv->busrequest));
             /* signal thread and wait */
             up(&device->sem_async);
             if (down_interruptible(&pReqPriv->busrequest->sem_req) != 0) {
                 AR_DEBUG_PRINTF(ATH_DEBUG_ERROR,("HIF-SCATTER: interrupted! \n"));
                 /* interrupted, exit */
                 status = A_ERROR;
                 break;
             } else {
                 status = pReq->CompletionStatus;
             }
         } else {
-            AR_DEBUG_PRINTF(ATH_DEBUG_SCATTER, ("HIF-SCATTER: queued async req: 0x%X\n", (unsigned int)pReqPriv->busrequest));
+            AR_DEBUG_PRINTF(ATH_DEBUG_SCATTER, ("HIF-SCATTER: queued async req: 0x%lX\n", (unsigned long)pReqPriv->busrequest));
                 /* wake thread, it will process and then take care of the async callback */
             up(&device->sem_async);
             status = A_OK;
         }           
        
     } while (FALSE);
 
     if (A_FAILED(status) && (request & HIF_ASYNCHRONOUS)) {
         pReq->CompletionStatus = status;
         pReq->CompletionRoutine(pReq);
@@ skipping 113 matching lines @@
         if (pReqPriv->pHifScatterReq != NULL) {
             A_FREE(pReqPriv->pHifScatterReq);   
             pReqPriv->pHifScatterReq = NULL; 
         }
                 
         A_FREE(pReqPriv);       
     }
 }
 
 #endif // HIF_LINUX_MMC_SCATTER_SUPPORT