hallow.c

Freescale ARM11系列CPU MX31的WINCE 5.0下的BSP

//---------------------------------------------------------------------------
// Copyright (C) 2006, Freescale Semiconductor, Inc. All Rights Reserved.
// THIS SOURCE CODE, AND ITS USE AND DISTRIBUTION, IS SUBJECT TO THE TERMS
// AND CONDITIONS OF THE APPLICABLE LICENSE AGREEMENT 
//--------------------------------------------------------------------------
//
// File:  hallow.c
// Source file for platform specific SDIO WLAN functions
//------------------------------------------------------------------------------
 

//------------------------------------------------------------------------------
// INCLUDE FILES  
//------------------------------------------------------------------------------

#include "precomp.h"



//-----------------------------------------------------------------------------
//
// NAME         vHALwriteRegister
// 
// PARAMETERS   psHAL		Pointer to HAL context.
//				ulOffset	Offset of control register.
//              ulValue		The value to be written.
//
// RETURNS      na
//
// DESCRIPTION  Write control register.
//
//-----------------------------------------------------------------------------
VOID
vHALwriteRegister( IN PHAL_CONTEXT psHAL, IN ULONG ulOffset, IN ULONG ulValue )
{


	SD_API_STATUS	iStatus;

	iStatus = SDReadWriteRegistersDirect( psHAL->psAdapter->hSDDeviceHandle, SD_IO_WRITE, HAL_SDIO_FUNCTION_1, 
										  ulOffset, FALSE, (PUCHAR)&ulValue, sizeof(BYTE) );
}


//-----------------------------------------------------------------------------
//
// NAME         vHALreadRegister
// 
// PARAMETERS   psHAL		Pointer to HAL context.
//				ulOffset	Offset of control register.
//              pulValue	Pointer to the value.
//
// RETURNS      na
//
// DESCRIPTION  Read control register.
//
//-----------------------------------------------------------------------------
VOID
vHALreadRegister( IN PHAL_CONTEXT psHAL, IN ULONG ulOffset, OUT PULONG pulValue )
{



	SD_API_STATUS	iStatus;

	iStatus = SDReadWriteRegistersDirect( psHAL->psAdapter->hSDDeviceHandle, SD_IO_READ, HAL_SDIO_FUNCTION_1, 
										  ulOffset, FALSE, (PUCHAR)pulValue, sizeof(BYTE) );


	//DBG_LEV1(("Read register 0x%x, Value = 0x%x, Status = 0x%x\n", ulOffset, *pulValue, iStatus));
}

//-----------------------------------------------------------------------------
//
// NAME         iHALbyteTransfer
// 
// PARAMETERS   psHAL			Pointer to HAL context.
//				ulRWFlag		SD_IO_OP_WRITE or SD_IO_OP_READ.
//				ulFunctionNum	SDIO function number.
//				ulBytes			Byte count.
//				ulTargetAddress	Register address.
//				pucHostAddress	Pointer to host buffer.
//
// RETURNS      SD API status.
//
// DESCRIPTION  This function transfers byte(s) of data to/from SD device.
//
//-----------------------------------------------------------------------------
SD_API_STATUS
iHALbyteTransfer( IN PHAL_CONTEXT psHAL, IN ULONG ulRWFlag, IN ULONG ulFunctionNum, 
				  IN ULONG ulBytes, IN ULONG ulTargetAddress, IN PUCHAR pucHostAddress )
{
	SD_API_STATUS		iStatus;
	SD_TRANSFER_CLASS	eTransferClass;
	SD_COMMAND_RESPONSE	sCardResponse;
	ULONG	ulArgument;
   ULONG ulByteOffset;

	eTransferClass = (ulRWFlag == SD_IO_OP_READ) ? SD_READ : SD_WRITE;

   ulByteOffset = 0;

   while (ulByteOffset < ulBytes)
   {
       ULONG ulCurrBytes = psHAL->ulMaxByteNumber;
       if (ulBytes - ulByteOffset < ulCurrBytes)
       {
           ulCurrBytes = ulBytes - ulByteOffset;
       }

       // Issue byte transfer.
       ulArgument = BUILD_IO_RW_EXTENDED_ARG( ulRWFlag,
                                              SD_IO_BYTE_MODE,
                                              ulFunctionNum, 
                                              ulTargetAddress + ulByteOffset,
                                              SD_IO_INCREMENT_ADDRESS,
                                              ulCurrBytes );
       iStatus = SDSynchronousBusRequest( psHAL->psAdapter->hSDDeviceHandle,
                                          SD_CMD_IO_RW_EXTENDED, 
                                          ulArgument,
                                          eTransferClass,
                                          ResponseR5,
                                          &sCardResponse, 
                                          1,
                                          ulCurrBytes,
                                          pucHostAddress + ulByteOffset,
                                          0 );

		if ( !SD_API_SUCCESS(iStatus) )
		{
			DBG_LEV0(("Error: R/W = %d, Bytes = %d, Address = 0x%x, Status = 0x%x\n", 
					  ulRWFlag, ulCurrBytes, ulTargetAddress + ulByteOffset, iStatus));
		}

       ulByteOffset += ulCurrBytes;
   }
   
	//DBG_LEV1(("R/W = %d, Bytes = %d, Address = 0x%x, Status = 0x%x\n", 
	//		  ulRWFlag, ulBytes, ulTargetAddress, iStatus));

	return( iStatus );
}


//-----------------------------------------------------------------------------
//
// NAME         iHALblockTransfer
// 
// PARAMETERS   psHAL			Pointer to HAL context.
//				ulRWFlag		SD_IO_OP_WRITE or SD_IO_OP_READ.
//				ulFunctionNum	SDIO function number.
//				ulBlockSize		Block size.
//				ulNumBlocks		Number of blocks.
//				ulTargetAddress	Register address.
//				pucHostAddress	Pointer to host buffer.
//
// RETURNS      SD API status.
//
// DESCRIPTION  This function transfers block(s) of data to/from SD device.
//
//-----------------------------------------------------------------------------
SD_API_STATUS
iHALblockTransfer( IN PHAL_CONTEXT psHAL, IN ULONG ulRWFlag, IN ULONG ulFunctionNum, 
				   IN ULONG ulBlockSize, IN ULONG ulNumBlocks, 
				   IN ULONG ulTargetAddress, IN PUCHAR pucHostAddress )
{
	SD_API_STATUS		iStatus;
	SD_TRANSFER_CLASS	eTransferClass;
	SD_COMMAND_RESPONSE	sCardResponse;
	ULONG	ulArgument;

   if (psHAL->boSupportBlockMode == FALSE)
   {
       iStatus = iHALbyteTransfer( psHAL,
                                   ulRWFlag,
                                   ulFunctionNum, 
                                   ulNumBlocks * ulBlockSize,
                                   ulTargetAddress,
                                   pucHostAddress);
   }
   else
   {
       ULONG ulBlockOffset;
       
       eTransferClass = (ulRWFlag == SD_IO_OP_READ) ? SD_READ : SD_WRITE;

       ulBlockOffset = 0;
       
       while (ulBlockOffset < ulNumBlocks)
       {
           ULONG ulCurrBlocks = psHAL->ulMaxBlockNumber;
           if (ulNumBlocks - ulBlockOffset < ulCurrBlocks)
           {
               ulCurrBlocks = ulNumBlocks - ulBlockOffset;
           }

           // Issue block transfer.
           ulArgument = BUILD_IO_RW_EXTENDED_ARG(
               ulRWFlag,
               SD_IO_BLOCK_MODE,
               ulFunctionNum, 
               ulTargetAddress + ulBlockOffset * ulBlockSize,
               SD_IO_INCREMENT_ADDRESS,
               ulCurrBlocks );
           iStatus = SDSynchronousBusRequest(
               psHAL->psAdapter->hSDDeviceHandle,
               SD_CMD_IO_RW_EXTENDED, 
               ulArgument,
               eTransferClass,
               ResponseR5,
               &sCardResponse, 
               ulCurrBlocks,
               ulBlockSize,
               pucHostAddress + ulBlockOffset * ulBlockSize,
               0 );

			if ( !SD_API_SUCCESS(iStatus) )
			{
				DBG_LEV0(("Error: R/W = %d, Block size = %d, Block num = %d, Address = 0x%x, Status = 0x%x\n", 
						  ulRWFlag, ulBlockSize, ulCurrBlocks, ulTargetAddress+ulBlockOffset*ulBlockSize, iStatus));
			}

           ulBlockOffset += ulCurrBlocks;
       }
   }

	//DBG_LEV1(("R/W = %d, Block size = %d, Block num = %d, Address = 0x%x, Status = 0x%x\n", 
	//		  ulRWFlag, ulBlockSize, ulNumBlocks, ulTargetAddress, iStatus));

	return( iStatus );
}

//-----------------------------------------------------------------------------
//
// NAME         vHALwriteIMem
// 
// PARAMETERS   psHAL		Pointer to HAL context.
//				ulAddress	Offset in IMEM (0-0x1FFF).
//              pulSource	Pointer to the host memory.
//              ulLength	The number of bytes to write.
//
// RETURNS      na
//
// DESCRIPTION  This function is used to transfer blocks of memory from the
//              host to the card IMEM using the HAL.
//
//-----------------------------------------------------------------------------
VOID
vHALwriteIMem( IN PHAL_CONTEXT psHAL, IN ULONG ulAddress, IN PULONG pulSource, IN ULONG ulLength )
{


	ULONG	ulNumBlocks;

	// Address must be DWORD aligned.
	ASSERT ((ulAddress & 3) == 0);
	// Get DWORD aligned length.
	ulLength = ((ulLength + 3) >> 2) << 2;

	// Calculate number of blocks.
	ulNumBlocks = ulLength / psHAL->ulBlockSize;
	if ( ulLength > ulNumBlocks * psHAL->ulBlockSize )
		ulNumBlocks ++;

	if ( ulNumBlocks )
	{
		// Write blocks of data to IMEM.
		iHALblockTransfer( psHAL, SD_IO_OP_WRITE, HAL_SDIO_FUNCTION_1, psHAL->ulBlockSize, 
						   ulNumBlocks, ulAddress, (PUCHAR)pulSource );
	}

}


//-----------------------------------------------------------------------------
//
// NAME         vHALreadIMem
// 
// PARAMETERS   psHAL		Pointer to HAL context.
//				ulAddress	Offset in IMEM (0-0x1FFF).
//              pulDest		Pointer to the host memory.
//              ulLength	The number of bytes to read.
//
// RETURNS      na
//
// DESCRIPTION  This function is used to transfer blocks of memory from the
//              the card IMEM to host using the HAL.
//
//-----------------------------------------------------------------------------
VOID
vHALreadIMem( IN PHAL_CONTEXT psHAL, IN ULONG ulAddress, OUT PULONG pulDest, IN ULONG ulLength )
{

	ULONG	ulNumBlocks;

	// Address must be DWORD aligned.
	ASSERT ((ulAddress & 3) == 0);
	// Get DWORD aligned length.
	ulLength = ((ulLength + 3) >> 2) << 2;

	// Calculate number of blocks.
	ulNumBlocks = ulLength / psHAL->ulBlockSize;
	if ( ulLength > ulNumBlocks * psHAL->ulBlockSize )
		ulNumBlocks ++;

	if ( ulNumBlocks )
	{