/**

* Copyright (c) 2009 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:

* eka\kernel\srandombuff.cpp

* 

*/

#include <kernel/kern_priv.h>

#include <assp.h>

#include "kernel/securerng.h"

const TInt KWordIndexBitMask = 0x1FFF; // bottom 13 bits holds buffer word index

const TInt KEntropyCountBitShift = 14; // top 18 bits holds entropy count

const TUint KEntropyBufferThresholdWords = KEntropyBufferSizeWords * 3/4;

/**

	Adds a single bit to the random pool used to generate random numbers.

    @deprecated use Kern::RandomSalt(TUint32 aEntropyData, TUint aBitsOfEntropy) or Kern::RandomSalt(TUint64 aEntropyData, TUint aBitsOfEntropy) instead

	@param aBitOfSalt The least significant bit of this value is added to the random pool.

  	@pre Can be used in a device driver.

*/

EXPORT_C void Kern::RandomSalt(TUint32 aBitOfSalt)

	{

    // Check if RNG needs more entropy.

    if (SecureRNG->SecureRNGIdle())

        return;

    Kern::RandomSalt(aBitOfSalt, 1);

	}

/**

	Adds 32 bits of data, using the entropy estimate provided, to the random pool used to generate random numbers.

    @param aEntropyData The 32 bits of data to be added to the random pool.

    @param aBitsOfEntropy An estimate of the number of bits of entropy contained in the 32 bits of data.

  	@pre aBitsOfEntropy must be >=0 and <=32.

    @pre Can be used in a device driver.

*/

EXPORT_C void Kern::RandomSalt(TUint32 aEntropyData, TUint aBitsOfEntropy)

    {

    // Check if RNG needs more entropy.

    if (SecureRNG->SecureRNGIdle())

        return;

    __ASSERT_ALWAYS((TUint)aBitsOfEntropy <= 32, K::PanicKernExec(EEntropyEstimateOutOfRange));

    TUint32 addcounts = (aBitsOfEntropy << KEntropyCountBitShift) + 1; // top 18 bits holds entropy count, plus 1 to increment buffer word index

    TInt irq = NKern::DisableAllInterrupts();

    TInt currentcpu = NKern::CurrentCpu();

    TUint32 currentstatus = __e32_atomic_load_acq32(&K::EntropyBufferStatus[currentcpu]);

    TUint32 nextword = currentstatus & KWordIndexBitMask; // bottom 13 bits holds buffer word index

    if(nextword < KEntropyBufferSizeWords)

        {

        K::EntropyBuffer[currentcpu][nextword] = aEntropyData;

        __e32_atomic_add_ord32(&K::EntropyBufferStatus[currentcpu], addcounts);

        }

    NKern::RestoreInterrupts(irq);

    TUint32 entropycount = (currentstatus + addcounts) >> KEntropyCountBitShift; // top 18 bits holds entropy count

    if((nextword < KEntropyBufferSizeWords) && (entropycount >= KReseedThreshold || nextword > KEntropyBufferThresholdWords))

        {

        if (NKern::CurrentContext() == NKern::EInterrupt)

            K::EntropyBufferDfc.Add();

        else

            K::EntropyBufferDfc.Enque();

        }

    }

/**

	Adds 64 bits of data, using the entropy estimate provided, to the random pool used to generate random numbers.

    @param aEntropyData The 64 bits of data to be added to the random pool.

    @param aBitsOfEntropy An estimate of the number of bits of entropy contained in the 32 bits of data.

  	@pre aBitsOfEntropy must be >=0 and <=64.

    @pre Can be used in a device driver.

*/

EXPORT_C void Kern::RandomSalt(TUint64 aEntropyData, TUint aBitsOfEntropy)

    {

    // Check if RNG needs more entropy.

    if (SecureRNG->SecureRNGIdle())

        return;

    __ASSERT_ALWAYS((TUint)aBitsOfEntropy <= 64, K::PanicKernExec(EEntropyEstimateOutOfRange));

    TUint32 addcounts = (aBitsOfEntropy << KEntropyCountBitShift) + 2; // top 18 bits holds entropy count, plus 2 to increment buffer word index

    TInt irq = NKern::DisableAllInterrupts();

    TInt currentcpu = NKern::CurrentCpu();

    TUint32 currentstatus = __e32_atomic_load_acq32(&K::EntropyBufferStatus[currentcpu]);

    TUint32 nextword = currentstatus & KWordIndexBitMask; // bottom 13 bits holds buffer word index

    if((nextword + 1) < KEntropyBufferSizeWords)

        {

        K::EntropyBuffer[currentcpu][nextword] = I64LOW(aEntropyData);

        K::EntropyBuffer[currentcpu][nextword+1] = I64HIGH(aEntropyData);

        __e32_atomic_add_ord32(&K::EntropyBufferStatus[currentcpu], addcounts);

        }

    NKern::RestoreInterrupts(irq);

    TUint32 entropycount = (currentstatus + addcounts) >> KEntropyCountBitShift; // top 18 bits holds entropy count

    if((nextword < KEntropyBufferSizeWords) && (entropycount >= KReseedThreshold || nextword > KEntropyBufferThresholdWords))

        {

        if (NKern::CurrentContext() == NKern::EInterrupt)

            K::EntropyBufferDfc.Add();

        else

            K::EntropyBufferDfc.Enque();

        }

    }

#if defined(__EPOC32__)

EXPORT_C void Interrupt::AddTimingEntropy()

    {

    // This function should only be called from Interrupt context otherwise timing may be predictable.

    CHECK_PRECONDITIONS(MASK_NOT_THREAD|MASK_NOT_IDFC, "Interrupt::AddTimingEntropy()");

    // Check if RNG needs more entropy.

    if (SecureRNG->SecureRNGIdle())

        return;

    TUint32 timestamp = NKern::FastCounter();

    Kern::RandomSalt(timestamp, 1);

    }

#endif

extern void DrainEntropyBuffers(TAny*)

    {

    TUint32 wordsavailable = 0;

    TUint32 wordscopied;

    TUint32 currentstatus;

    TBool result = 0;

    for(TInt cpu = (NKern::NumberOfCpus() - 1); cpu >= 0; --cpu)

        {

        wordscopied = 0;

        currentstatus = __e32_atomic_load_acq32(&K::EntropyBufferStatus[cpu]);

        // if this CPU's buffer is empty then skip processing

        if(currentstatus == 0) continue;

        do

            {

            wordsavailable = currentstatus & KWordIndexBitMask;

            memcpy(&K::TempEntropyBuffer[wordscopied], &K::EntropyBuffer[cpu][wordscopied], (wordsavailable - wordscopied)*4);

            wordscopied = wordsavailable;

            result = __e32_atomic_cas_ord32(&K::EntropyBufferStatus[cpu], &currentstatus, 0);

            }

        while(!result);

        SecureRNG->AddEntropy((TUint8*)&K::TempEntropyBuffer[0], wordscopied*4, currentstatus >> KEntropyCountBitShift);

        }

    }

extern TInt InitialiseEntropyBuffers()

    {

    TInt numcpus = NKern::NumberOfCpus();

    // Allocate space for all cpu buffers and store pointer to beginning as CPU 0 buffer.

    K::EntropyBuffer[0] = (TUint32*)Kern::Alloc(KEntropyBufferSizeWords * numcpus * 4);

    // Initialise pointers for remaining cpus

    for(TInt cpu = 1; cpu < numcpus; ++cpu)

        {

        K::EntropyBuffer[cpu] = K::EntropyBuffer[0] + (cpu * KEntropyBufferSizeWords);

        }

    // Initialise DFC

    K::EntropyBufferDfc.SetDfcQ(K::SvMsgQ);

    return KErrNone;

    }