/*

* Copyright (c) 2004-2007 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:  HID parser implementation

*

*/

// ----------------------------------------------------------------------

// References:

//

// [1] USB Device Class Definition for Human Interface Devices (HID),

//     Firmware Specification, Version 1.11, USB Implementers' Forum,

//     June 2001

//

// [2] HID Parser Error Codes (HID Parser Error Checking), Revision

//     1.2, USB Implementers' Forum, February 2000

//

// [3] USB HID Usage Tables, Version 1.11, USB Implementers' Forum,

//     June 2001

//

// ----------------------------------------------------------------------

#include <e32std.h>

#include <e32base.h>

#include <e32des8.h>

#include <e32svr.h>

#include "hidreportroot.h"

#include "hiditem.h"

#include "hidparser.h"

#include "debug.h"

// ----------------------------------------------------------------------

/*

// Define PARSER_DEBUG to activate trace output for WINS debug builds:

#undef PARSER_DEBUG

#if defined(PARSER_DEBUG) && defined(_DEBUG) && defined(__WINS__)

#define PDBG(a) a;

#define PDBG_ACTIVE

#else

#define PDBG(a)

#endif

*/

#define PDBG_ACTIVE

const TUint32 CParser::KLocalItemMask =

    EUsageMin | EUsageMax | EUsageId |

    EDesignatorIndex | EDesignatorMin | EDesignatorMax |

    EStringIndex | EStringMin | EStringMax;

const TUint32 KMaxStandardType   = 0x06;

const TUint32 KMinVendorType     = 0x80;

const TUint32 KMaxVendorType     = 0xFF;

const TUint32 KMaxUsagePage      = 0xffff;

const TUint32 KUnitData          = 0x0f;

const TUint32 CParser::KUnusedLocalItemsMask = KLocalItemMask & ~EUsageId;

const TUint32 KInputReservedBitsMask    = 0xffffff00;

const TUint32 KOutputReservedBitsMask   = 0xffffff00;

const TUint32 KFeatureReservedBitsMask  = 0xffffff00;

const TUint32 KUnitReservedBitsMask     = 0xf0000000;

const TInt KConstantFlag    = 1<<0;  // Constant (1) or Data (0)

const TInt KVariableFlag    = 1<<1;  // Array (0) or Variable (1)

const TInt KNullStateFlag   = 1<<6;

const TInt KExtendedDataSize  = 4;   // 32-bit extended data size

const TInt KExtendedDataShift = 16;  // 16 bit shift if extended usage page is used

const TInt KMaxReportIDMax    = 255;

const TInt K32Bit             = 32;

const TUint K32BitFirstBitOn   = 1u<<31;

const TInt  KUnitSystemMin     = 5;

const TInt  KUnitSystem15      = 15;

const TUint32 CParser::KMandatoryItemMask = EUsagePage |

        ELogicalMin | ELogicalMax | EReportSize | EReportCount;

const TUint32 CParser::KReportItemMask = EInputReport |

                  EOutputReport | EFeatureReport;        

// Reserved values as per the HUT document 1.11, [3]:

// This ranges are reserverd in future use.

const TInt KReservedUsage = 0x0e;

const TInt KReservedUsageRange1Min = 0x11;

const TInt KReservedUsageRange1Max = 0x13;

const TInt KReservedUsageRange2Min = 0x15;

const TInt KReservedUsageRange2Max = 0x3f;

const TInt KReservedUsageRange3Min = 0x41;

const TInt KReservedUsageRange3Max = 0x7f;

const TInt KReservedUsageRange4Min = 0x88;

const TInt KReservedUsageRange4Max = 0x8b;

const TInt KReservedUsageRange5Min = 0x92;

const TInt KReservedUsageRange5Max = 0xfeff;

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------

// NewLC()

// ---------------------------------------------------------------------------

//

EXPORT_C CParser* CParser::NewLC()

    {

    CParser* self = new (ELeave) CParser;

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

// ---------------------------------------------------------------------------

// NewL()

// ---------------------------------------------------------------------------

//

EXPORT_C CParser* CParser::NewL()

    {

    CParser* self = NewLC();

    CleanupStack::Pop();

    return self;

    }

// ---------------------------------------------------------------------------

// ConstructL()

// ---------------------------------------------------------------------------

//

void CParser::ConstructL()

    {

    TRACE_FUNC_THIS

    iLocal = CField::NewL();

    }

// ---------------------------------------------------------------------------

// Constructor

// ---------------------------------------------------------------------------

//

CParser::CParser():

    iFieldCount(0)

    {

    TRACE_FUNC_THIS

    }

// ---------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------

//

CParser:: ~CParser()

    {

    TRACE_FUNC_THIS

    // Free all RArray storage:

    iGlobalStack.Reset();

    // Although iCollectionStack is an RPointerArray, we aren't doing

    // a ResetAndDestroy() here, as all the collections are owned by

    // the report root object, iReportRoot:

    iCollectionStack.Reset();

    delete iReportRoot;

    delete iLocal;

    }

// ---------------------------------------------------------------------------

// CreateCollectionL

// ---------------------------------------------------------------------------

//

TInt CParser::CreateCollectionL(TUint32 aType)

    {

    TInt err = CheckForCollectionErrors(aType);

    if (err == KErrNone)

        {

        CCollection* collection = Collection()->AddCollectionL(); // Created collection added

                                                                  // Collection's collection array

        collection->SetType(aType);

        collection->SetUsagePage(iGlobal.iUsagePage);

        collection->SetUsage(iLocal->LastUsage());

        PushCollectionL(collection);         

        }

    return err;

    }

// ---------------------------------------------------------------------------

// CheckForMainErrors()

// ---------------------------------------------------------------------------

//

TInt CParser::CheckForMainErrors()

    {

    if ( ( iItemsDefined & ELogicalMin ) && ( iItemsDefined & ELogicalMax ) )

        {

        if ( iGlobal.iLogicalMin > iGlobal.iLogicalMax )

            {

            IssueWarning( ELogicalMinExceedsMax );

            }

        }

    if ( iItemsDefined & (EPhysicalMin | EPhysicalMax ) )

        {

        if ( !( iItemsDefined & EPhysicalMax ) )

            {

            return ELonelyPhysicalMin;

            }

        if (!( iItemsDefined & EPhysicalMin ))

            {

            return ELonelyPhysicalMax;

            }

        if ( iGlobal.iPhysicalMin > iGlobal.iPhysicalMax )

            {

            IssueWarning(EPhysicalMinExceedsMax);

            }

        }

    return KErrNone;

    }

// ---------------------------------------------------------------------------

// CheckForCollectionErrors()

// ---------------------------------------------------------------------------

//

TInt CParser::CheckForCollectionErrors(TUint32 aType)

    {    

    if (iCollectionStack.Count() == 0 )

        {

        return ENoCollectionToCheck;

        }

    if (aType > KMaxStandardType)

        {

        if ((aType < KMinVendorType) || (aType > KMaxVendorType))

            {

            IssueWarning( ECollectionTypeUnknownReserved );

            }

        }

    if ( iItemsDefined & KUnusedLocalItemsMask )

        {

        IssueWarning( ECollectionLocalUnused );

        }

    TInt numUsages = iLocal->UsageCount();

    if ( numUsages > 1 )

        {

        // Only a single usage value can be associated with a collection:

        IssueWarning( ECollectionLocalUnused );

        }

    if ( numUsages == 0 )

        {

        // A usage tag must be associated with a collection (see [1],

        // Section 6.2.2.6):

        IssueWarning( ECollectionHasNoUsage );

        }

    if ( !( iItemsDefined & EUsagePage ) )

        {

        // A usage page must be associated with a collection (see [1],

        // Section 6.2.2.6):

        IssueWarning( ECollectionHasNoUsagePage );

        }

    if (( aType == CCollection::EApplication ) && ( iItemsDefined & EDelimiter ))

        {

        // Delimiters can't be used when defining usages that apply to

        // Application Collections ([1], Section 6.2.2.8):

        IssueWarning(EApplicationHasDelimiter);

        // It is an error to declare a delimiter for a top-level

        // application collection, [2]:

        if (iCollectionStack.Count() == 1)

            {

            return EDelimiterAtTopLevel;

            }

        }

    return CheckForMainErrors();

    }

// ---------------------------------------------------------------------------

// CheckForFieldErrors()

// ---------------------------------------------------------------------------

//

TInt CParser::CheckForFieldErrors(CField::TType aType, TUint32 aAttributes)

    {  

    TInt ret = KErrNone;

    ret = CheckMandatoryFieldErrors(aType, aAttributes);

    if ( ret != KErrNone )

        {

        return ret;    

        }

    const TInt KLimitsError[] =

        { EInputMinExceedsMax, EOutputMinExceedsMax, EFeatureMinExceedsMax };

    if ( iGlobal.iLogicalMin > iGlobal.iLogicalMax )

        {

        return KLimitsError[aType];

        }

    if ( ( iItemsDefined & ( EPhysicalMin | EPhysicalMax ) )

        && ( iGlobal.iPhysicalMin > iGlobal.iPhysicalMax ))

        {

        return KLimitsError[aType];

        }   

    CheckLogicalMinAndMax( aAttributes );     

    CheckFieldBitNeeded( aType, aAttributes );

    return CheckForMainErrors();

    }

// ---------------------------------------------------------------------------

// BitsToRepresentRange()

// ---------------------------------------------------------------------------

//

TInt CParser::BitsToRepresentRange(TInt aMin, TInt aMax)

    {

    // The number of bits required to represent all values in the

    // range aMin to aMax inclusive.  If the range is all positive

    // then there is no sign bit, otherwise twos complement format is

    // assumed. ([1], Section 6.2.2.7.)

    TInt bitsNeeded = 0;

    if (aMin != aMax)

        {

        TUint absVal = static_cast<TUint>(Max(Abs(aMin), Abs(aMax)));

        bitsNeeded = K32Bit - NumberOfLeadingZeros(absVal);

        // If either are negative, we'll need space for the sign bit:

        //

        if ((aMax < 0) || (aMin < 0))

            {

            bitsNeeded++;

            // However, 2s complement allows us to represent one extra

            // negative number than positive, and so our calculation

            // may be one bit over. Catch this with a special case:

            //

            if (bitsNeeded > 1)

                {

                TInt n = 1 << (bitsNeeded - 2);

                if ((aMin == -n) && (aMax < n))

                    {

                    bitsNeeded--;

                    }

                }

            }

        }

    return bitsNeeded;

    }

// ---------------------------------------------------------------------------

// NumberOfLeadingZeros()

// ---------------------------------------------------------------------------

//

TInt CParser::NumberOfLeadingZeros(TUint32 aValue)

    {

    TInt count = 0;

    TUint32 pos = K32BitFirstBitOn;

    while ((pos != 0) && ((aValue & pos) == 0))

        {

        count++;

        pos >>= 1;

        }

    return count;

    }

// ---------------------------------------------------------------------------

// CheckAllReportSizes()

// ---------------------------------------------------------------------------

//

TBool CParser::CheckAllReportSizes() const

    {

    // Final report sizes must be an integral number of bytes, [2]:

    TBool sizesOk = ETrue;

    for (TInt i=0; sizesOk && (i<iReportRoot->NumberOfReports()); ++i)

        {

        TInt bits = iReportRoot->ReportSize(i);

        if ((bits == 0) || ((bits % 8) != 0))

            {

            sizesOk = EFalse;

            }

        }

    return sizesOk;

    }

// ---------------------------------------------------------------------------

// CreateFieldL()

// ---------------------------------------------------------------------------

//

TInt CParser::CreateFieldL(CField::TType aType, TUint32 aAttributes)

    {

    TInt err = CheckForFieldErrors( aType, aAttributes );

    //Microsoft Elite 2 keyboard HID bug fix

	if ( err == EInputMissingItems && iGlobal.iUsagePage == 0x07 )

		if ( iLocal->UsageMin( ) == 0xe0 && iLocal->UsageMax( ) == 0xe7 )

			{

			iGlobal.iLogicalMin = 0x0;

			iGlobal.iLogicalMax = 0x1;

			err = KErrNone;

			}

		else

			{

			iGlobal.iLogicalMin = 0x0;

			err = KErrNone;

			}

    if (err == KErrNone)

        {

        // Create a new field object:

        CField* field = Collection()->AddFieldL( );   // Created field added

                                                      // to collection's field array

        DumpStateTableL( field );

        field->SetType( aType );

        field->SetAttributes( aAttributes );

        // Set the field offset to the current report size, and

        // increase the report size by the size of this field:        

        if ( !iReportRoot )

            {

            User::Leave(ENoReportRoot);

            }

        field->SetOffset( iReportRoot->ReportSize( field->ReportId( ), aType) );

        iReportRoot->IncrementReportSizeL( field->ReportId(),

            aType, field->Count() * field->Size() );

        TRACE_INFO(_L("CParser::CreateFieldL Field added"));

        if ( field->UsageCount() )

            {

            iFieldCount++;

            }        

        }

    return err;

    }

// ---------------------------------------------------------------------------

// DumpStateTableL()

// ---------------------------------------------------------------------------

//

void CParser::DumpStateTableL(CField *aField) const

    {

    TRACE_INFO((_L("DumpStateTableL(0x%08x)\n"), aField));

    // Copy global state:

    //

    iGlobal.Populate(aField);

    // Copy local state:

    //

    aField->SetUsageRange( iLocal->UsageMin(), iLocal->UsageMax() );

    aField->SetDesignatorIndex( iLocal->DesignatorIndex() );

    aField->SetDesignatorRange( iLocal->DesignatorMin(),

        iLocal->DesignatorMax() );

    aField->SetStringIndex( iLocal->StringIndex() );

    aField->SetStringRange( iLocal->StringMin(), iLocal->StringMax() );

    // Copy usage list (local state) and calculate the usage range, if

    // it hasn't already been explicitly specified:

    //

    if ( iLocal->UsageCount() > 0 )

        {

        TInt minUsage, maxUsage;

        minUsage = maxUsage = iLocal->Usage( 0 );

        for (TInt i=0; i<iLocal->UsageCount(); ++i)

            {

            TInt value = iLocal->Usage( i );

            aField->AddUsageL( value );

            if ( value < minUsage )

                {

                minUsage = value;

                }

            if ( value > maxUsage )

                {

                maxUsage = value;

                }

            }

        if ( (iItemsDefined & (EUsageMin | EUsageMax) ) == 0)

            {

            aField->SetUsageRange( minUsage, maxUsage );

            }

        }

    }

// ---------------------------------------------------------------------------

// Collection()

// ---------------------------------------------------------------------------

//

CCollection* CParser::Collection()

    {    

    CCollection* lastcollection = NULL;

    if ( iCollectionStack.Count( ) > 0 )

        {

        lastcollection = iCollectionStack[ iCollectionStack.Count() - 1 ];

        }

    return lastcollection;

    }

// ---------------------------------------------------------------------------

// PushCollectionL()

// ---------------------------------------------------------------------------