hi_des_api.c

嵌入式linux系统下hi3510平台的osd开发源码

/*   extdrv/crypto/des/hi_des_api.c
 *
 * Copyright (c) 2006 Hisilicon Co., Ltd. 
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.
 *
 * History:
 *      17-May-2006  create this file
 *    
 */


#include <asm/io.h>
#include <linux/ioctl.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include "hi_des_api.h"
#include <string.h>
#include <stdio.h>
#include <time.h>
#include <sys/time.h>
#include <sys/mman.h>
#include <stdlib.h>

#define HI_ASSERT(expr)                                     \
    do{                                                     \
        if (!(expr)) { \
            printf("\nASSERT failed at:\n  >File name: %s\n  >Function : %s\n  >Line No. : %d\n  >Condition: %s\n", \
                __FILE__,__FUNCTION__, __LINE__, #expr);}\
    }while(0)


/*  DES register read macro definition */
#ifndef READ_REGISTER_ULONG
#define READ_REGISTER_ULONG(reg,result) ((result)=*(volatile unsigned int *)(reg))
#endif

#ifndef WRITE_REGISTER_ULONG
#define WRITE_REGISTER_ULONG(reg, data) (*((volatile unsigned int *)(reg))=(data))
#endif

#ifndef WRITE_REGISTER_CHAR
#define WRITE_REGISTER_CHAR(reg, data) (*((volatile unsigned char *)(reg))=(data))
#endif

/* define DES module base address and register address */

unsigned int*  p_map=0;
int fd;


#define ECS_DES_OFFSET     0x101FB000
#define ECS_DES_BASE       ((unsigned long)p_map)

#define ECS_DES_DIN1       IO_ADDRESS(ECS_DES_BASE + 0x0)
#define ECS_DES_DIN2       IO_ADDRESS(ECS_DES_BASE + 0x4)
#define ECS_DES_IVIN1      IO_ADDRESS(ECS_DES_BASE + 0x8)
#define ECS_DES_IVIN2      IO_ADDRESS(ECS_DES_BASE + 0xC)
#define ECS_DES_KEY11      IO_ADDRESS(ECS_DES_BASE + 0x10)
#define ECS_DES_KEY12      IO_ADDRESS(ECS_DES_BASE + 0x14)
#define ECS_DES_KEY21      IO_ADDRESS(ECS_DES_BASE + 0x18)
#define ECS_DES_KEY22      IO_ADDRESS(ECS_DES_BASE + 0x1C)
#define ECS_DES_KEY31      IO_ADDRESS(ECS_DES_BASE + 0x20)
#define ECS_DES_KEY32      IO_ADDRESS(ECS_DES_BASE + 0x24)
#define ECS_DES_CTRL       IO_ADDRESS(ECS_DES_BASE + 0x28)
#define ECS_DES_DOUT1      IO_ADDRESS(ECS_DES_BASE + 0x2C)
#define ECS_DES_DOUT2      IO_ADDRESS(ECS_DES_BASE + 0x30)
#define ECS_DES_IVOUT1     IO_ADDRESS(ECS_DES_BASE + 0x34)
#define ECS_DES_IVOUT2     IO_ADDRESS(ECS_DES_BASE + 0x38)
#define ECS_DES_INT        IO_ADDRESS(ECS_DES_BASE + 0x3C)
#define ECS_DES_BUSY       IO_ADDRESS(ECS_DES_BASE + 0x40)
#define ECS_DES_START      IO_ADDRESS(ECS_DES_BASE + 0x44)

#define IO_ADDRESS(n)      n
#define MMAP_LENGTH        0x1000

#define  DES_BUSY                0x01
#define  DES_START               0x01
#define  DES_BUSY_ERR            0x02
#define  DES_CTRLBYTE_ERR        0x03
#define  ALL_SUCCESS             0x00
//#define DEBUG
//#define PERFOR_TEST 

#ifdef PERFOR_TEST
unsigned int  u_begin_seconds;
unsigned int  u_end_seconds;
struct timeval timeval;
void getbegintime(void);
void getendtime(void);
void calc_speed(unsigned int plaintext_length);
#endif

static int des_ctrl(unsigned int cmd, unsigned char *arg);
static int des_alg_operate(unsigned char * pplaintext,unsigned char * pouttext,unsigned long plaintext_length,struct keys* pcipher);
static unsigned int control_byte = 0;
static unsigned  char *  des_iv;


#ifdef PERFOR_TEST
void getbegintime(void)
{
   gettimeofday(&timeval,0);
   u_begin_seconds=timeval.tv_sec*1000000+timeval.tv_usec;
   printf("begin time is:%u\n",u_begin_seconds);

}

void getendtime(void)
{
    gettimeofday(&timeval,0);
    u_end_seconds=timeval.tv_sec*1000000+timeval.tv_usec;
    printf("end time is:%u\n",u_end_seconds);
}


void calc_speed(unsigned int plaintext_length)
{
   double plaintext_lengthtmp;
   double speed;
   float  speed_Kbyte;
   unsigned int cipher_time;
 
   plaintext_lengthtmp=plaintext_length;
   cipher_time=u_end_seconds-u_begin_seconds;

   printf("cipher time is:%u\n",cipher_time);
   printf("plaintext_lengthtmp is:%f\n",plaintext_lengthtmp);

   
   speed=(plaintext_lengthtmp*1000000.0)/cipher_time;
   printf("speed is:%f\n",speed);

   speed_Kbyte=speed/1024;

   printf("the cipher_speed  is: %f Kbyte/s!\n",speed_Kbyte);
}
#endif


int  hi_des_init( )
{
    fd=open("/dev/mem",O_RDWR|O_SYNC,00777);
    if(fd<0)
    {
        return -1;
    }
    p_map = (unsigned int *) mmap( NULL,MMAP_LENGTH,PROT_READ|PROT_WRITE,MAP_SHARED,fd,ECS_DES_OFFSET);

    if(p_map==0)
    {
        return -1;
    }
    return 0;
}


int hi_des_exit()
{
    if(-1== munmap( p_map, MMAP_LENGTH))
    {
        printf("mumap failed");
        return -1;
    }
    return 0;
    if(-1==close( fd ))
    {
        printf("close the file operator failed");
        return -1;
    }
    return 0;
}

static int reverse_array( unsigned char *src)
{
        int i;
        unsigned char tmp[8];
        if(NULL==src)
        {
            printf("the pointer in  reverse is null!");
            return -1;
        }

        for( i = 0; i < 8; i++ )
        {
            tmp[i] = src[(8-1) - i];
        }

        for( i = 0; i < 8; i++ )
        {
            src[i] = tmp[i];
        }
        return 0;
}

static  int des_config_key(unsigned char  *pkey1, unsigned char *pkey2, unsigned char *pkey3, unsigned int ctrlbyte)
{
    unsigned int  stavalue,k;
    unsigned int *ptmpkey1, *ptmpkey2, *ptmpkey3;

    if(NULL==pkey1)
    {
         printf("the pointer in des_config_key is null!");
         return -1;
    }

    if((ctrlbyte&0xf)==0x3 ||(ctrlbyte&0xf)==0x7)
    {
        ptmpkey1 = (unsigned int *)pkey3;
        ptmpkey2 = (unsigned int *)pkey2;
        ptmpkey3 = (unsigned int *)pkey1;
    }
    else
    {
        ptmpkey1 = (unsigned int *)pkey1;
        ptmpkey2 = (unsigned int *)pkey2;
        ptmpkey3 = (unsigned int *)pkey3;
    }
    READ_REGISTER_ULONG(ECS_DES_BUSY,stavalue);

    for(k=0;(k<100000)&&(stavalue==1);k++)
    {
       READ_REGISTER_ULONG(ECS_DES_BUSY,stavalue);
    }
    if (k>=100000)
    {
        printf(" there is something wrong with the module!");
        return DES_BUSY_ERR;
    } 
    
    if ((ctrlbyte & 0x40) != DES_KEYENDIAN_LITTLE)
    {
        reverse_array((unsigned char *)ptmpkey1);
    }

    WRITE_REGISTER_ULONG(ECS_DES_KEY11,*ptmpkey1++);
    WRITE_REGISTER_ULONG(ECS_DES_KEY12,*ptmpkey1);

 #ifdef DEBUG
    printf("keytmp_1:%x\n",*ptmpkey1);
    READ_REGISTER_ULONG(ECS_DES_KEY12,stavalue); 
    printf("key12:%x\n",stavalue);
    READ_REGISTER_ULONG(ECS_DES_KEY11,stavalue); 
    printf("key11:%x\n",stavalue);
 #endif
    if ((ctrlbyte & 0x01) ==  DES_ALGO_3DES)
    {
        if ((ctrlbyte & 0x40) != DES_KEYENDIAN_LITTLE)
        {
             reverse_array((unsigned char *)ptmpkey2);
             reverse_array((unsigned char *)ptmpkey3);
        }
        WRITE_REGISTER_ULONG(ECS_DES_KEY21,*ptmpkey2++);
        WRITE_REGISTER_ULONG(ECS_DES_KEY22,*ptmpkey2);

        WRITE_REGISTER_ULONG(ECS_DES_KEY31,*ptmpkey3++);
        WRITE_REGISTER_ULONG(ECS_DES_KEY32,*ptmpkey3);
#ifdef DEBUG

    printf("keytmp_2:%x\n",*ptmpkey2);
    printf("keytmp_2:%x\n",*(ptmpkey2-1));
    READ_REGISTER_ULONG(ECS_DES_KEY22,stavalue); 
    printf("key22:%x\n",stavalue);
    READ_REGISTER_ULONG(ECS_DES_KEY21,stavalue); 
    printf("key21:%x\n",stavalue);
    READ_REGISTER_ULONG(ECS_DES_KEY32,stavalue); 
    printf("key32:%x\n",stavalue);
    READ_REGISTER_ULONG(ECS_DES_KEY31,stavalue); 
    printf("key31:%x\n",stavalue);

 #endif

   }
   
    return 0;
}

static  int des_config_iv (unsigned char *pivin, unsigned int ctrlbyte)
{
    unsigned int  stavalue,k;
    unsigned int  *ptmpiv;

    if(NULL==pivin)
    {
        printf("the pointer in des_config_iv is null!");
        return -1;
    }

    ptmpiv = (unsigned int *)pivin;
    READ_REGISTER_ULONG(ECS_DES_BUSY,stavalue);

    for(k=0;(k<100000)&&(stavalue==1);k++)
    {
       READ_REGISTER_ULONG(ECS_DES_BUSY,stavalue);
    }

    if (k>=100000)
    {
        printf(" there is something wrong with the module!");
        return DES_BUSY_ERR;
    }

     /*set iv*/
    if ((ctrlbyte & 0x0C) != DES_MODE_ECB)
    {
        WRITE_REGISTER_ULONG(ECS_DES_IVIN1,*ptmpiv++);
        WRITE_REGISTER_ULONG(ECS_DES_IVIN2,*ptmpiv);
    }
    else
    {
        return DES_CTRLBYTE_ERR;
    }

 #ifdef DEBUG
    READ_REGISTER_ULONG(ECS_DES_IVIN2,stavalue); 
    printf("ivin2:%x\n",stavalue);
    READ_REGISTER_ULONG(ECS_DES_IVIN1,stavalue); 
    printf("ivin1:%x\n",stavalue);
 #endif

    return 0;
}

static  int des_config_m (unsigned char *pmin, unsigned int ctrlbyte)
{
    unsigned int  stavalue,k;
    unsigned int *ptmpm;

    if(NULL==pmin)
    {
        printf("the pointer in des_config_m is null!");
        return -1;
    }

    ptmpm = (unsigned int *)pmin;
    READ_REGISTER_ULONG(ECS_DES_BUSY,stavalue);
    for(k=0;(k<100000)&&(stavalue==1);k++)
    {
       READ_REGISTER_ULONG(ECS_DES_BUSY,stavalue);
    }

    if (k>=100000)
    {