testall.c

freescale ppc sec2加解密单元驱动

/*
 * These functions handle memory buffer differences for each environment
 *
 * putKmem() allocates kernel memory for data to be placed into, and if the
 * data pointer is not NULL, will copy the data block.
 *
 * getKmem() copies post-operation data back to the user's buffer
 *
 * freeKmem() frees a kernel memory block after use
 */
#ifdef _LINUX_USERMODE_
int putKmem(int fd, void *data, void **block, unsigned int size)
{
    MALLOC_REQ  kmem;
    int iostat;
    
    kmem.pid = getpid();
    kmem.sz  = size;
    iostat = ioctl(fd, IOCTL_MALLOC, &kmem);
    if (iostat == SEC2_MALLOC_FAILED)
        return iostat;
        
    *block = kmem.ptr;
    
    if (data != NULL) 
    {
        kmem.from = data;
        kmem.to = kmem.ptr;
        iostat = ioctl(fd, IOCTL_COPYFROM, &kmem);
    }
    
    return 0;
}



int getKmem(int fd, void *data, void **block, unsigned int size)
{
    MALLOC_REQ kmem;
    int iostat;
    
    kmem.pid  = getpid();
    kmem.sz   = size;
    kmem.to   = data;
    kmem.from = *block;
    iostat = ioctl(fd, IOCTL_COPYTO, &kmem);
    
    return 0;
}


int freeKmem(int fd, void **block)
{
    int iostat;
    iostat = ioctl(fd, IOCTL_FREE, *block);
    
    return 0;
}

#endif

#ifdef __KERNEL__  /* then this is a Linux kernel-mode test module */
int putKmem(int fd, void *data, void **block, unsigned int size)
{
    *block = (void *)kmalloc(size, GFP_KERNEL | __GFP_DMA);
    if (*block == NULL)
        return -1;

    if (data != NULL)
        memcpy(*block, data, size);
    
    return 0;
}


int getKmem(int fd, void *data, void **block, unsigned int size)
{
    memcpy(data, *block, size);
    return 0;
}

int freeKmem(int fd, void **block)
{
    kfree(*block);
    return 0;
}

#endif

#ifdef VXWORKS     /* is flat-memory VxWorks, don't have to do anything */
int putKmem(int fd, void *data, void **block, unsigned int size)
{
    return 0;
}

int getKmem(int fd, void *data, void **block, unsigned int size)
{
    return 0;
}

int freeKmem(int fd, void *block)
{
    return 0;
}

#endif


#if 0
/* Top level of test */
int testAll(void)
{
    int status=0, nFails=0, nTests=0;
    int fd;
    

#ifdef __KERNEL__
    init_MUTEX_LOCKED(&notifySemId);
#else
    fd = open(SEC2_DEVNAME, O_RDWR, 0);
    if (fd == -1)
    {
        printf("testAesa(): can't open %s, error = %d: ", SEC2_DEVNAME, errno);
        return -1;
    }
#endif

#ifdef TESTALL_HASH
    if ((status = hash_test(fd)) == 0) 
        nTests++;
    else
        printf("hash_test(%d) Failed! %04x\n", ++nFails, status);
#endif


#ifdef TESTALL_IPSEC
    if ((status = testIPSEC(fd)) == 0) /* IPSEC with DES */
        nTests++;
    else
        printf("testIPSEC(%d) Failed! %04x\n", ++nFails, status);
#endif



#ifdef TESTALL_RC4
    if ((status = testAfha(fd)) == 0) /* arc4 (0x1.) */
        nTests++;
    else
        printf("testAfha(%d) Failed! %04x\n", ++nFails, status);

#if 0
    if ((status = testAFHActx(fd)) == 0)
        nTests++;
    else
        printf("testAFHActx(%d) Failed! %04x\n", ++nFails, status);

    if ((status = testAfhaLong(fd)) == 0)
        nTests++;
    else
        printf("testAfhaLong(%d) Failed! %04x\n", ++nFails, status);
#endif
#endif



#ifdef TESTALL_DES
    if ((status = testDes(fd, 512, 4)) == 0)  /* DES (0x2.) */
        nTests++;
    else
        printf("testDes(%d) Failed! %04x\n", ++nFails, status);

    if ((status = testDesECB(fd, 512, 4)) == 0)   /* DES ECB */
        nTests++;
    else
        printf("testDesECB(%d) Failed! %04x\n", ++nFails, status);
#endif


#ifdef TESTALL_HMAC
    if ((status = testHmac(fd)))  /* Hmac (0x3.) */
        printf("testHmac(%d) Failed! %04x\n", ++nFails, status);
    else 
        nTests++;
#endif


#ifdef TESTALL_RNG
    if ((status = testRng(fd)) == 0)  /* RNG (0x4.) */
        nTests++;
    else
        printf("testRng(%d) Failed! %04x\n", ++nFails, status);
#endif


#ifdef TESTALL_AES
    if ((status = testAesa(fd)) == 0) /* AESA_SEL (0x6.) */
        nTests++;
    else
        printf("testAesa(%d) Failed! %04x\n", ++nFails, status);
#endif



#ifdef TESTALL_PKHA
  if ((status = testPKHA(fd)) == 0)
    nTests++;
  else
    printf("testPKHA(%d) failed, status = %04x\n", ++nFails, status);
#endif



#ifdef TESTALL_CCMP
  if ((status = testccmp(fd)) == 0)
    nTests++;
  else
    printf("testccmp(%d) failed, status = %04x\n", ++nFails, status);
#endif

#ifdef TESTALL_SCATTER
  if ((status = testSG(fd)) == 0)
    nTests++;
  else
    printf("testSG(%d) failed, status = %04x\n", ++nFails, status);
#endif


#ifdef TESTALL_FIFO_OVERFLOW
  if ((status = testFF()) == 0)
    nTests++;
  else
    printf("testFF(%d) failed, status = %04x\n", ++nFails, status);
#endif



  /* All tests complete, show status and exit */

  if (nFails == 0)
    printf("testAll(): All %d Tests Passed\n", nTests);
  else
    printf("Tests Passed %d, Failed %d!\n", nTests, nFails);

#ifdef __KERNEL__
    semDelete(notifySemId);
#else
    close(fd);
#endif

    if (nFails)
        return -1;
      
    return 0;
}




#ifdef _LINUX_USERMODE_

int main(int argc, char **argv)
{
    return testAll();
}
#endif


#ifdef __KERNEL__


static inline int __sem_update_count(struct semaphore *sem, int incr)
{
        int old_count, tmp;

        __asm__ __volatile__("\n"
"1:     lwarx   %0,0,%3\n"
"       srawi   %1,%0,31\n"
"       andc    %1,%0,%1\n"
"       add     %1,%1,%4\n"
        PPC405_ERR77(0,%3)
"       stwcx.  %1,0,%3\n"
"       bne     1b"
        : "=&r" (old_count), "=&r" (tmp), "=m" (sem->count)
        : "r" (&sem->count), "r" (incr), "m" (sem->count)
        : "cc");

        return old_count;
}

long __down_interruptible_timeout(struct semaphore * sem, long timeout)
{
        int retval = 0;
        struct task_struct *tsk = current;
        DECLARE_WAITQUEUE(wait, tsk);

        tsk->state = TASK_INTERRUPTIBLE;
        add_wait_queue_exclusive(&sem->wait, &wait);
        smp_wmb();

        while (__sem_update_count(sem, -1) <= 0) {
                if (signal_pending(current)) {
                        /*
                         * A signal is pending - give up trying.
                         * Set sem->count to 0 if it is negative,
                         * since we are no longer sleeping.
                         */
                        __sem_update_count(sem, 0);
                        retval = -EINTR;
                        break;
                }
                timeout = schedule_timeout(timeout);
                tsk->state = TASK_INTERRUPTIBLE;
        }
        tsk->state = TASK_RUNNING;
        remove_wait_queue(&sem->wait, &wait);
        wake_up(&sem->wait);
        return timeout>=0? 0: -1;
}




int func = 0;

MODULE_PARM (func, "i");

int init_module(void)
{
    switch (func)
    {
        case 0:
            testAll();
            break;

        default:
            printk("sec2drvTest [func=n] {testMain=0}\n", func);
    }
    return 0;
}

void cleanup_module(void)
{
    return;
}

MODULE_LICENSE("Freescale Restricted");
MODULE_DESCRIPTION("SEC2.x driver test module");
MODULE_AUTHOR("Freescale Semiconductor Inc.");
#endif
#endif