/*
* Copyright (c) 2002-2010 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: Implementation of RWlanLogicalChannel inline methods.
*
*/
/*
* %version: 17 %
*/
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
inline TVersion RWlanLogicalChannel::VersionRequired() const
{
return TVersion(
KWlanDriverMajorVersion,
KWlanDriverMinorVersion,
KWlanDriverBuildVersion );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
inline TInt RWlanLogicalChannel::Open(
TWlanUnit aUnit,
TOpenParam& aOpenParam )
{
iWlanSystemInitialized = EFalse;
TInt err = DoCreate(
LDD_NAME,
VersionRequired(),
aUnit,
NULL,
NULL,
EOwnerProcess);
if ( err == KErrNone )
{
// driver load sequence success
// do system init
err = InitWlanSystem( aOpenParam );
if ( err == KErrNone )
{
// WLAN system successfully initialized
iWlanSystemInitialized = ETrue;
}
}
return err;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
inline void RWlanLogicalChannel::CloseChannel()
{
// release WLAN system resources only if we have been able to do the
// initialization successfully.
// This check is done to prevent a release attempt in a case where the
// device driver framework has not been properly initialized to be able to
// handle requests
if ( iWlanSystemInitialized )
{
TRequestStatus status;
DoRequest( EWlanFinitSystem, status );
User::WaitForRequest(status);
// not initialized any more. This is needed to handle the case
// that this method is called multiple times
iWlanSystemInitialized = EFalse;
}
// internally call close
Close();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
inline TInt RWlanLogicalChannel::InitWlanSystem(
TOpenParam& aOpenParam )
{
iOpenParam = aOpenParam;
TRequestStatus status;
DoRequest( EWlanInitSystem, status, &iOpenParam );
User::WaitForRequest(status);
return status.Int();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
inline TInt RWlanLogicalChannel::ManagementCommand(
const TDesC8& aInBuffer,
TDes8* aOutBuffer,
TRequestStatus* aStatus)
{
TInt ret( KErrNoMemory );
SOidMsgStorage* pdu( new SOidMsgStorage );
if ( pdu )
{
TUint32 input_param_len( aInBuffer.Length() );
os_memcpy( pdu, aInBuffer.Ptr(), input_param_len );
SOutputBuffer output = { NULL, 0 };
if ( aOutBuffer )
{
output.iData = const_cast<TUint8*>(aOutBuffer->Ptr());
output.iLen = aOutBuffer->Length();
}
if (aStatus == NULL)
{
// Execute command synchronously
TRequestStatus status;
DoRequest(
EWlanCommand,
status,
pdu,
(output.iData ? &output : NULL) );
User::WaitForRequest(status);
ret = status.Int();
}
else
{
// Execute command asynchronously
iAsyncOidCommandMsg = *pdu;
iAsyncOidCommandOutput = output;
DoRequest(
EWlanCommand,
*aStatus,
&iAsyncOidCommandMsg,
(output.iData ? &iAsyncOidCommandOutput : NULL) );
ret = KErrNone;
}
// always remember to deallocate
delete pdu;
}
return ret;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
inline void RWlanLogicalChannel::RequestSignal(
TRequestStatus &aStatus,
TIndication &aBuffer)
{
DoRequest(EWlanRequestNotify, aStatus, &aBuffer);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
inline void RWlanLogicalChannel::CancelRequestSignal()
{
// DoCancel uses mask instead of real values.
DoCancel(1<<EWlanRequestNotify);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
inline void RWlanLogicalChannel::CancelRxRequests()
{
// DoCancel uses mask instead of real values.
DoCancel(1<<EWlanRequestFrame);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
inline TInt RWlanLogicalChannel::InitialiseBuffers(
RFrameXferBlock*& aFrameXferBlock )
{
TInt status ( KErrNone );
TSharedChunkInfo info;
status = DoSvControl( EWlanSvControlInitBuffers,
static_cast<TAny*>(&info) );
if ( status == KErrNone )
{
// shared memory chunk initialization success
// Set the handle for the shared memory chunk
iSharedMemoryChunk.SetHandle( info.iChunkHandle );
// Set the relevant user mode
// addresses as offsets from the chunk base address
TUint8* baseAddress ( iSharedMemoryChunk.Base() );
const TUint KRxDataChunkSize(
info.iSize
- ( sizeof( TDataBuffer )
+ KMgmtSideTxBufferLength
+ KProtocolStackSideTxDataChunkSize
+ sizeof( RFrameXferBlock )
+ sizeof( RFrameXferBlockProtocolStack ) ) );
aFrameXferBlock = reinterpret_cast<RFrameXferBlock*>(
baseAddress
+ KRxDataChunkSize
+ sizeof( TDataBuffer )
+ KMgmtSideTxBufferLength
+ KProtocolStackSideTxDataChunkSize );
aFrameXferBlock->SetRxDataChunkField( reinterpret_cast<TLinAddr>(
baseAddress) );
aFrameXferBlock->SetTxDataBufferField( reinterpret_cast<TLinAddr>(
baseAddress
+ KRxDataChunkSize ) );
}
return status;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
inline TInt RWlanLogicalChannel::ReleaseBuffers()
{
// close the handle to the shared memory chunk
iSharedMemoryChunk.Close();
return DoSvControl( EWlanSvControlFreeBuffers );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
inline void RWlanLogicalChannel::WriteFrame(
TRequestStatus &aStatus )
{
DoRequest( EWlanRequestSend, aStatus );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
inline void RWlanLogicalChannel::RequestFrame(
TRequestStatus &aStatus )
{
DoRequest( EWlanRequestFrame, aStatus );
}