/*******************************************************************************
* Copyright 2013-2018 Intel Corporation
* All Rights Reserved.
*
* If this  software was obtained  under the  Intel Simplified  Software License,
* the following terms apply:
*
* The source code,  information  and material  ("Material") contained  herein is
* owned by Intel Corporation or its  suppliers or licensors,  and  title to such
* Material remains with Intel  Corporation or its  suppliers or  licensors.  The
* Material  contains  proprietary  information  of  Intel or  its suppliers  and
* licensors.  The Material is protected by  worldwide copyright  laws and treaty
* provisions.  No part  of  the  Material   may  be  used,  copied,  reproduced,
* modified, published,  uploaded, posted, transmitted,  distributed or disclosed
* in any way without Intel's prior express written permission.  No license under
* any patent,  copyright or other  intellectual property rights  in the Material
* is granted to  or  conferred  upon  you,  either   expressly,  by implication,
* inducement,  estoppel  or  otherwise.  Any  license   under such  intellectual
* property rights must be express and approved by Intel in writing.
*
* Unless otherwise agreed by Intel in writing,  you may not remove or alter this
* notice or  any  other  notice   embedded  in  Materials  by  Intel  or Intel's
* suppliers or licensors in any way.
*
*
* If this  software  was obtained  under the  Apache License,  Version  2.0 (the
* "License"), the following terms apply:
*
* You may  not use this  file except  in compliance  with  the License.  You may
* obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless  required  by   applicable  law  or  agreed  to  in  writing,  software
* distributed under the License  is distributed  on an  "AS IS"  BASIS,  WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
* See the   License  for the   specific  language   governing   permissions  and
* limitations under the License.
*******************************************************************************/

/* 
// 
//  Purpose:
//     Cryptography Primitive.
//     Fixed window exponentiation scramble/unscramble
// 
//  Contents:
//     cpScramblePut()
//     cpScrambleGet()
// 
// 
*/

#if !defined(_PC_SCRAMBLE_H)
#define _PC_SCRAMBLE_H

/*
// cpsScramblePut/cpsScrambleGet
// stores to/retrieves from pScrambleEntry position
// pre-computed data if fixed window method is used
*/
__INLINE void cpScramblePut(Ipp8u* pArray, cpSize colummSize,
                      const Ipp32u* pData, cpSize dataSize)
{
   int i;
   switch(colummSize) {
      case 1: // column - byte
         dataSize *= sizeof(Ipp32u);
         for(i=0; i<dataSize; i++)
            pArray[i*CACHE_LINE_SIZE] = ((Ipp8u*)pData)[i];
         break;
      case 2: // column - word (2 bytes)
         dataSize *= sizeof(Ipp16u);
         for(i=0; i<dataSize; i++)
            ((Ipp16u*)pArray)[i*CACHE_LINE_SIZE/sizeof(Ipp16u)] = ((Ipp16u*)pData)[i];
         break;
      case 4: // column - dword (4 bytes)
         for(i=0; i<dataSize; i++)
            ((Ipp32u*)pArray)[i*CACHE_LINE_SIZE/sizeof(Ipp32u)] = pData[i];
         break;
      case 8: // column - qword (8 bytes => 2 dword)
         for(; dataSize>=2; dataSize-=2, pArray+=CACHE_LINE_SIZE, pData+=2) {
            ((Ipp32u*)pArray)[0] = pData[0];
            ((Ipp32u*)pArray)[1] = pData[1];
         }
         if(dataSize)
            ((Ipp32u*)pArray)[0] = pData[0];
         break;
      case 16: // column - oword (16 bytes => 4 dword)
         for(; dataSize>=4; dataSize-=4, pArray+=CACHE_LINE_SIZE, pData+=4) {
            ((Ipp32u*)pArray)[0] = pData[0];
            ((Ipp32u*)pArray)[1] = pData[1];
            ((Ipp32u*)pArray)[2] = pData[2];
            ((Ipp32u*)pArray)[3] = pData[3];
         }
         for(; dataSize>0; dataSize--, pArray+=sizeof(Ipp32u), pData++)
            ((Ipp32u*)pArray)[0] = pData[0];
         break;
      case 32: // column - 2 oword (32 bytes => 8 dword)
         for(; dataSize>=8; dataSize-=8, pArray+=CACHE_LINE_SIZE, pData+=8) {
            ((Ipp32u*)pArray)[0] = pData[0];
            ((Ipp32u*)pArray)[1] = pData[1];
            ((Ipp32u*)pArray)[2] = pData[2];
            ((Ipp32u*)pArray)[3] = pData[3];
            ((Ipp32u*)pArray)[4] = pData[4];
            ((Ipp32u*)pArray)[5] = pData[5];
            ((Ipp32u*)pArray)[6] = pData[6];
            ((Ipp32u*)pArray)[7] = pData[7];
         }
         for(; dataSize>0; dataSize--, pArray+=sizeof(Ipp32u), pData++)
            ((Ipp32u*)pArray)[0] = pData[0];
         break;
      default:
         break;
   }
}


/*
// Retrieve data from pArray
*/
#define u8_to_u32(b0,b1,b2,b3, x) \
  ((x) = (b0), \
   (x)|=((b1)<<8), \
   (x)|=((b2)<<16), \
   (x)|=((b3)<<24))
#define u16_to_u32(w0,w1, x) \
  ((x) = (w0), \
   (x)|=((w1)<<16))
#define u32_to_u64(dw0,dw1, x) \
  ((x) = (Ipp64u)(dw0), \
   (x)|= (((Ipp64u)(dw1))<<32))

__INLINE void cpScrambleGet(Ipp32u* pData, cpSize dataSize,
                      const Ipp8u* pArray, cpSize colummSize)
{
   int i;
   switch(colummSize) {
      case 1: // column - byte
         for(i=0; i<dataSize; i++, pArray+=sizeof(Ipp32u)*CACHE_LINE_SIZE)
            u8_to_u32(pArray[0*CACHE_LINE_SIZE], pArray[1*CACHE_LINE_SIZE], pArray[2*CACHE_LINE_SIZE], pArray[3*CACHE_LINE_SIZE], pData[i]);
         break;
      case 2: // column - word (2 bytes)
         for(i=0; i<dataSize; i++, pArray+=sizeof(Ipp16u)*CACHE_LINE_SIZE) {
            Ipp16u w0 = *((Ipp16u*)(pArray));
            Ipp16u w1 = *((Ipp16u*)(pArray+CACHE_LINE_SIZE));
            u16_to_u32( w0, w1, pData[i]);
         }
         break;
      case 4: // column - dword (4 bytes)
         for(i=0; i<dataSize; i++, pArray+=CACHE_LINE_SIZE)
            pData[i] = ((Ipp32u*)pArray)[0];
         break;
      case 8: // column - qword (8 bytes => 2 dword)
         for(; dataSize>=2; dataSize-=2, pArray+=CACHE_LINE_SIZE, pData+=2) {
            pData[0] = ((Ipp32u*)pArray)[0];
            pData[1] = ((Ipp32u*)pArray)[1];
         }
         if(dataSize)
            pData[0] = ((Ipp32u*)pArray)[0];
         break;
      case 16: // column - oword (16 bytes => 4 dword)
         for(; dataSize>=4; dataSize-=4, pArray+=CACHE_LINE_SIZE, pData+=4) {
            pData[0] = ((Ipp32u*)pArray)[0];
            pData[1] = ((Ipp32u*)pArray)[1];
            pData[2] = ((Ipp32u*)pArray)[2];
            pData[3] = ((Ipp32u*)pArray)[3];

         }
         for(; dataSize>0; dataSize--, pArray+=sizeof(Ipp32u), pData++)
            pData[0] = ((Ipp32u*)pArray)[0];
         break;
      case 32: // column - 2 oword (32 bytes => 8 dword)
         for(; dataSize>=8; dataSize-=8, pArray+=CACHE_LINE_SIZE, pData+=8) {
            pData[0] = ((Ipp32u*)pArray)[0];
            pData[1] = ((Ipp32u*)pArray)[1];
            pData[2] = ((Ipp32u*)pArray)[2];
            pData[3] = ((Ipp32u*)pArray)[3];
            pData[4] = ((Ipp32u*)pArray)[4];
            pData[5] = ((Ipp32u*)pArray)[5];
            pData[6] = ((Ipp32u*)pArray)[6];
            pData[7] = ((Ipp32u*)pArray)[7];
         }
         for(; dataSize>0; dataSize--, pArray+=sizeof(Ipp32u), pData++)
            pData[0] = ((Ipp32u*)pArray)[0];
         break;
      default:
         break;
   }
}

#endif /* _PC_SCRAMBLE_H */