sec2_init.c

freescale ppc sec2加解密单元驱动

/****************************************************************************
 * sec2_init.c -- The Initialization code for SEC2 Driver
 ****************************************************************************
 * Copyright (c) Certicom Corp. 1996-2002.  All rights reserved
 * Copyright (c) 2003-2005 Freescale Semiconductor
 * All Rights Reserved. Proprietary and Confidential.
 *
 * NOTICE: The information contained in this file is proprietary
 * to Freescale Semiconductor, and is being made available to
 * Freescale's customers under strict license agreements.
 * Use or disclosure of this information is permissible only
 * under the terms of the existing license agreement.
 ***************************************************************************/

/* Revision History:
 * 1.0   Aug 24,2003 dgs - adapted from the final version of mpc18x
 * 1.1.0 Nov 16,2004 sec - incorporate linux changes from prior versions
 * 1.1.1 Dec 16,2004 sec - remove old unused diagnostics
 * 1.2   Jan 27,2005 sec - fix comments associated with global inhibit
 */
#include <stdio.h>
#include "vxWorks.h"
#include "install.h"
#include "drvlib/include/drv_comm.h"
#include "sec2_const.h"
#include "Sec2Driver.h"

#define INIT_C
#if DRIVER_IPSEC_DBG
unsigned long SEC2DebugLevel = (DBGTXT_SETRQ | DBGTXT_SVCRQ | DBGTXT_INITDEV | DBGTXT_DPDSHOW | DBGTXT_INFO); 
/*unsigned long SEC2DebugLevel = (DBGTXT_INFO);*/
#else
unsigned long SEC2DebugLevel = 0x0;
#endif

#ifdef __KERNEL
EXPORT_SYMBOL(SEC2DebugLevel);
#endif
/********************函数声明********************************/
void Init_Drv_Ipsec_Queue(void);
int Init_Drv_Fwd_Queue(void);
void sec2_init_mem_free(void);
int SEC2DriverInit(void);
int sec2_channel_pktCnt_debug_init(void);
int sec2_pktCnt_debug_init(void);
extern int drv_Sec2RegisterDiag(void);

/*************************************************************************
 * Function Name: SEC2DriverInit
 * Purpose:
 *          Step1: Build base address by requesting peripheral base
 *          Step2: Init ChannelRegister & Cha Register
 *          Step3: Allocate Channel Assignments
 *          Step4: Init Sec2_ChannelAssignments & ChaAssignments
 *          Step5: Init ProcessQueueTop & ProcessQueueBottom 
 *          Step6: Init Semaphores
 *          Step7: Reset all Chas and Channels
 *          Step8: Config all Channels
 *          Step9: Connect Interrupt
 *          Step10: Enable Interrupt
 *          Step11: Return Success
 *          
 * Input: None
 *        
 * Return: SEC2_SUCCESS if everything passed, otherwise the error code
 *************************************************************************/ 
int SEC2DriverInit(void)
{
    int             cha;
    int             channel;
    unsigned long   address;
    unsigned int    idx[] = {0,2,4,3,5,1};
    char           *coreID;
    static  int   first_time = 0;

    /*初始化只需要一次*/
    if(first_time == 0)
    {
        first_time = 1;
    }
    else   /*否则返回*/
    {
        SEC2Dump(DBGTXT_INFO, ("SEC 2.x Security Processor Core have inited \n"));
        return SEC2_ERROR;
    }
    if (NULL == gpDrvSec2End)
    {
        gpDrvSec2End = (DRV_SEC2_END *)malloc(sizeof(DRV_SEC2_END));
        if ((DRV_SEC2_END *)NULL == gpDrvSec2End)
        {
            ASSERT(0);
            return SEC2_ERROR;
        }
        else
        {
            memset((void *)gpDrvSec2End, 0, sizeof(DRV_SEC2_END));
        }
    }
    
/* sysGetPeripheralBase() gets the PQ3 CCSBAR from the OS */
    sec2_IOBaseAddress = (unsigned long)(drv_GetPeripheralBase() + TALITOS2X_BASE_ADDRESS);

/* Identify the running hardware */
    SEC2Dump(DBGTXT_INFO, ("SEC 2.x Security Processor Core\n"));
    SEC2Dump(DBGTXT_INFO, ("Driver Version %s %s %s\n", VERSION, __DATE__,__TIME__));
	
/*Identification register,标识哪种版本加密核,这里只是用来打印*/
    sec2_coremask = *((volatile unsigned long *)(sec2_IOBaseAddress + IDENTIFICATION_OFFSET) + 1);

    switch(sec2_coremask)
    {
        case SEC_COREID_2_0_0:
            coreID = "2.0.0";
            break;
        
        case SEC_COREID_2_1_0:
            coreID = "2.1.0";
            break;
        
        default:
            coreID = "unknown";
            break;
    }

    SEC2Dump(DBGTXT_INFO, ("Security Core Version Mask: %s (0x%08lx)\n\n", coreID, sec2_coremask));

    /* set up rebound cha index table */
    /*PKEU=0,RNG=1,DEU=2,MDEU=3,AESU=4,AFEU=5*/
    memcpy ((char *)sec2_cha_idx, (char *)idx, sizeof (idx));

    /* set up SEC2 register addresses */
    /* controller registers */
    sec2_ChaAssignmentStatusRegister = (volatile unsigned long*)
        (sec2_IOBaseAddress + CHA_ASSIGNMENT_STATUS_OFFSET);
    sec2_InterruptControlRegister = (volatile unsigned long*)
        (sec2_IOBaseAddress + INTERRUPT_CONTROL_OFFSET);
    sec2_InterruptStatusRegister = (volatile unsigned long*)
        (sec2_IOBaseAddress + INTERRUPT_STATUS_OFFSET);
    sec2_InterruptClearRegister = (volatile unsigned long*)
        (sec2_IOBaseAddress + INTERRUPT_CLEAR_OFFSET);
    sec2_IdRegister = (volatile unsigned long*)
        (sec2_IOBaseAddress + IDENTIFICATION_OFFSET);
    sec2_MasterControlRegister = (volatile unsigned long *)
        (sec2_IOBaseAddress + SEC2_MASTER_CONTROL_REGISTER);
    SEC2Dump(DBGTXT_INITDEV, ("SEC2DriverInit->IOBaseAddress=0x%08lx\n", sec2_IOBaseAddress));



    /* Reset the SEC2 */
    /* Note that we turn on global inhibit for all processors. At the time    */
    /* of coding, GI only exists in the 8349; it's irrelevant to PQ3 devices. */
    /* So, it's just turned on for all processors, which is OK for now.       */
    /* In time, this may be need to become an option in build configuration.  */
    
    SEC2Dump(DBGTXT_INITDEV, ("SEC2DriverInit->reset Master Control Register\n"));
    *(sec2_MasterControlRegister)     = SEC2_RESET | SEC2_GLOBAL_INHIBIT;
    *(sec2_MasterControlRegister + 1) = 0;


    SEC2Dump(DBGTXT_INITDEV,
            ("SEC2DriverInit->IdRegister=0x%08lx 0x%08lx\n",
            *(sec2_IdRegister), 
            *(sec2_IdRegister + 1)));



    /* channel registers */
    SEC2Dump(DBGTXT_INITDEV, ("SEC2DriverInit->channel registers\n"));
    for (channel=0, address=CHANNEL_CONFIG_BASE; channel<SEC2_NUM_CHANNELS;
        channel++,address+=CHANNEL_DISTANCE)
    {
        sec2_ChannelConfigRegister[channel] = 
            (volatile unsigned long*)(sec2_IOBaseAddress + address);
    }
    for (channel=0,address=CHANNEL_POINTER_STATUS_BASE; channel<SEC2_NUM_CHANNELS;
        channel++,address+=CHANNEL_DISTANCE)
    {
        sec2_ChannelPointerStatusRegister[channel] = 
            (volatile unsigned long*)(sec2_IOBaseAddress + address);
    }
    for (channel=0,address=CHANNEL_NEXT_DESCRIPTOR_BASE; channel<SEC2_NUM_CHANNELS;
        channel++,address+=CHANNEL_DISTANCE)
    {
        sec2_ChannelNextDescriptorRegister[channel] = 
            (volatile unsigned long*)(sec2_IOBaseAddress + address);
    }
    for (channel=0,address=CHANNEL_DBR_BASE; channel<SEC2_NUM_CHANNELS;
        channel++,address+=CHANNEL_DISTANCE)
    {
        sec2_ChannelDataBufferDescriptorRegister[channel] = 
            (volatile unsigned long*)(sec2_IOBaseAddress + address);
    }
    for (channel=0,address=CHANNEL_CDPR_BASE; channel<SEC2_NUM_CHANNELS;
        channel++,address+=CHANNEL_DISTANCE)
    {
        sec2_ChannelDataBufferDescriptorRegister[channel] = 
            (volatile unsigned long*)(sec2_IOBaseAddress + address);
    }

    /* cha registers */
    SEC2Dump(DBGTXT_INITDEV, ("SEC2DriverInit->cha registers\n"));
    for (cha=0,address=CHA_RESET_CONTROL_BASE; cha<NUM_CHAS;
        cha++,address+=CHA_DISTANCE)
    {
        sec2_ChaResetControlRegister[cha] = 
            (volatile unsigned long*)(sec2_IOBaseAddress + address);
    } 
    for (cha=0,address=CHA_INTERRUPT_STATUS_BASE; cha<NUM_CHAS;
        cha++,address+=CHA_DISTANCE)
    {
        Sec2ChaInterruptStatusRegister[sec2_cha_idx[cha]] = 
            (volatile unsigned long*)(sec2_IOBaseAddress + address);
    }
    for (cha=0,address=CHA_INTERRUPT_CONTROL_BASE; cha<NUM_CHAS;
        cha++,address+=CHA_DISTANCE)
    {
        sec2_ChaInterruptControlRegister[cha] = 
            (volatile unsigned long*)(sec2_IOBaseAddress + address);
    }

    /* allocate other driver variables */
    SEC2Dump(DBGTXT_INITDEV, ("SEC2DriverInit->allocating other driver variables\n"));

    /* variable init */
    sec2_FreeChannels = SEC2_NUM_CHANNELS;
    sec2_FreeRngas = SEC2_NUM_RNGAS;
    sec2_FreeAfhas = SEC2_NUM_AFHAS;
    sec2_FreeDesas = SEC2_NUM_DESAS;
    sec2_FreeMdhas = SEC2_NUM_MDHAS;
    sec2_FreePkhas = SEC2_NUM_PKHAS;
    sec2_FreeAesas = SEC2_NUM_AESAS;

    /* Init Sec2_ChannelAssignments */
    for (channel=0; channel<SEC2_NUM_CHANNELS; channel++)
    {
        if (SEC2_SUCCESS != sec2_InitChannelAssignment(channel))
        {
            SEC2Dump(DBGTXT_INITDEV, ("SEC2DriverInit->init channel assinment failed\n"));
            sec2_init_mem_free();
            ASSERT(0);
            return SEC2_ERROR;
        }
    }

    /* Init ChaAssignments直接初始化为动态  */
    for (cha=0; cha<16; cha++)
    {
        sec2_ChaAssignments[cha] = CHA_DYNAMIC;
    }

    /* 初始化队列*/
    Init_Drv_Ipsec_Queue();
    
    if(SEC2_SUCCESS != Init_Drv_Fwd_Queue())
    {
          SEC2Dump(DBGTXT_INITDEV, ("SEC2DriverInit->init sec2 fwd queue failed \n"));
          sec2_init_mem_free();
          ASSERT (0);
          return SEC2_ERROR;
    }
    
    /*创建通道信号量，失败则挂起*/
    if(SEC2_SUCCESS != IOInitChannelSemaphores())
    {
          SEC2Dump(DBGTXT_INITDEV, ("SEC2DriverInit->init channel semaphores failed \n"));
          sec2_init_mem_free();
          ASSERT(0);
          return SEC2_ERROR;
    }

    /*创建队列信号量，失败则挂起*/
    if(SEC2_SUCCESS != InitGlobalQueueSemaphores())
    {
          SEC2Dump(DBGTXT_INITDEV, ("SEC2DriverInit->init channel semaphores failed \n"));
          sec2_init_mem_free();
          ASSERT(0);