bsppllmb.c

这是单板上DPRAM的驱动程序

if(Syn60_Flag>0)   
 {       
	switch(CurStatus){
		case SDS_PLL_LOSE:
		case SDS_PLL_FASTC:
		case SDS_PLL_SLOWC:
		    			break;		
		case SDS_PLL_LOCK:
			if(++cmmpllcnt<Lock_Cnt){
			    SET_BIT(S_SiPendRegister,IRQ_PLL_PENDING_BIT,32)
		        return;
		    }
		    else{
		    	cmmpllcnt=0;
		    	
		    }
		    break;
	}
	
	Prev_PhD=PhD;
    tmp =*((ULONG *)PLLBase);
    tmp &= 0xffe00000L;
    tmp >>=21;
    if(tmp>=1625)
    {
     SET_BIT(S_SiPendRegister,IRQ_PLL_PENDING_BIT,32)	
     return; 
    } 
    PhD=(tmp>813)?(long)tmp-1625:(long)tmp;
    PD=PhD-Prev_PhD; 
    if(PD>813)
        PD-=1625;
    else if(PD<-813)
        PD+=1625;
    if(CurStatus==SDS_PLL_LOSE){
        PhBreaks=0;
    }
    else{
        if(PD>100 || PD<-100){
            PhBreaks++;
            ((PLLData *)pDataBuf)->chops++;
            
        } /* to skip the breaks in phase changing*/
        else{
            PhBreaks=0;
        }
        if(PhBreaks>0 && PhBreaks<4){    
            Prev_PhD=PhD;
            SET_BIT(S_SiPendRegister,IRQ_PLL_PENDING_BIT,32)
            return;
        }
    }/*if(CurStatus==SDS_PLL_LOSE)*/
   
/*调整初始相位*/
    if(ms_flag==1)
     {
       InitPhD=PhD;
       Prev_PhD=PhD;
       ms_flag=0;
       SET_BIT(S_SiPendRegister,IRQ_PLL_PENDING_BIT,32)
       return;	
     }    
        
    switch(CurStatus)
    {
     case SDS_PLL_LOSE:
        if (++entries>Power_Up_Time/TS1){
            CurStatus=SDS_PLL_FASTC;
            entries=0;
            for(i=0;i<5;i++)BufPhase[i]=PhD;    
            InitPhD=PhD;
            if(InitPhD>=0 && InitPhD<90)
               InitPhD+=50;
            else if(InitPhD<0 && InitPhD>-90)
               InitPhD-=50;
#ifdef PLLDEBUG
            INITPHD=InitPhD; 
#endif
        } 
        break;          
    case SDS_PLL_FASTC:
        PhD_InitPhD=PhD-InitPhD;
        dtao1=TS1/tao1_1*PhD_InitPhD+KD1*PD;
        tmp=(long)Prev_CW+(long)(dtao1);
        if(tmp<2459 &&tmp>=0)CW=tmp;
        entries++;
/*-----------------------------------------*/
#ifdef PLLDEBUG 
        runinfo[curpos].phdinfo=PhD;
        runinfo[curpos].statusinfo=CurStatus;
        runinfo[curpos].cwinfo=CW;
        runinfo[curpos].to_tgt=PhD_InitPhD;
        if(++curpos>=maxinfos)curpos-=maxinfos; 
#endif
/*-----------------------------------------*/
        if(PhD_InitPhD<Th1 &&PhD_InitPhD>-Th1)
            inband++; 
        else 
            inband=0;  
        if(inband>=Chk1){ 
            CurStatus= SDS_PLL_SLOWC;
            ((PLLData *)pDataBuf)->fast_tmout=SDA_NONE;
            entries=0;
            inband=0;
        }
        if(entries>PLL_F_T_CNT)
            ((PLLData *)pDataBuf)->fast_tmout= SDA_PLL_FASTC_TIMEOUT; 
            InitPhD=PhD;
            if(InitPhD>=0 && InitPhD<90)
               InitPhD+=50;
            else if(InitPhD<0 && InitPhD>-90)
            InitPhD-=50;
            
        break;
    case SDS_PLL_SLOWC:
        entries++;
        PhD_InitPhD=PhD-InitPhD;
        dtao1=TS2/tao1_2*PhD_InitPhD+KD2*PD;
        tmp=(long)Prev_CW+(long)(dtao1);
        if(tmp<2459 &&tmp>=0)CW=tmp;
/*-----------------------------------------*/
#ifdef PLLDEBUG    
        runinfo[curpos].phdinfo=PhD;
        runinfo[curpos].cwinfo=CW;
        runinfo[curpos].statusinfo=CurStatus; 
        runinfo[curpos].to_tgt=PhD_InitPhD;
        if(++curpos>=maxinfos)curpos-=maxinfos; 
#endif
/*-----------------------------------------*/
        if(PhD_InitPhD>Th1 ||PhD_InitPhD<-Th1){
            outband++;  
            inband=0;
        }
        else if(PhD_InitPhD<Th2 &&PhD_InitPhD>-Th2)
            inband++;
        else
            inband=0;
        if(outband>Chk15){
            entries=0; 
            CurStatus=SDS_PLL_FASTC; 
            entries=0; 
            ((PLLData *)pDataBuf)->slow_tmout=SDA_NONE;
            inband=0;
            outband=0;
        }    
        if(inband>=Chk2){ 
            CurStatus= SDS_PLL_LOCK;
            entries=0; 
            ((PLLData *)pDataBuf)->slow_tmout=SDA_NONE;
            inband=0;outband=0;
            outband1=0; 
        }    
        if(entries>(PLL_S_T_CNT))
            ((PLLData *)pDataBuf)->slow_tmout=SDA_PLL_SLOWC_TIMEOUT; 
        break;
     case SDS_PLL_LOCK:
       /*if(GetBTS_NO()!=0)  
        {
          SET_PB_BIT(26,1);
          SET_BIT(S_SiPendRegister,IRQ_PLL_PENDING_BIT,32)
          return;	
        }*/
        if(Syn60_Flag==2)
             {
               LocalWorkCtl(1);	
               Syn60_Flag=1;	
             }
        /*entries++; */
        PhD_InitPhD=PhD-InitPhD;

        if(PhD_InitPhD>Th4 ||PhD_InitPhD<-Th4)
            outband++; 
        else{ 
            outband=0;
                       
            dtao1=(TS3/tao1_3*PhD_InitPhD+KD3*PD);
            if(dtao1>=1) dtao1=1;
            else if(dtao1<=-1) dtao1=-1;
            else dtao1=0;
            tmp=(long)Prev_CW+(long)dtao1;
            if(tmp<2459 &&tmp>=0)
                CW=tmp;   
            }
        if(PhD_InitPhD>Th3 || PhD_InitPhD<-Th3)
            outband1++;
        else
            outband1=0;                
/*-----------------------------------------*/
#ifdef PLLDEBUG    
        runinfo[curpos].phdinfo=PhD;
        runinfo[curpos].cwinfo=CW;
        runinfo[curpos].statusinfo=CurStatus; 
        runinfo[curpos].to_tgt=PhD_InitPhD;
        if(++curpos>=maxinfos)curpos-=maxinfos; 
#endif
/*-----------------------------------------*/
        if(outband>Chk4){ 
            CurStatus= SDS_PLL_FASTC; 
            entries=0; 
            inband=0;
            outband=0;
            outband1=0;
            InitPhD=PhD;
            if(Syn60_Flag==1)
             {
               LocalWorkCtl(0);	
               Syn60_Flag=2;	
             }
            
            if(InitPhD>=0 && InitPhD<90)
                InitPhD+=50;
            else if(InitPhD<0 && InitPhD>-90)
                InitPhD-=50;
#ifdef PLLDEBUG
            INITPHD=InitPhD; 
#endif
        } 
    
        if(outband1>Chk3){ 
            CurStatus= SDS_PLL_SLOWC; 
            entries=0; 
            inband=0;
            outband=0;
            outband1=0;
            if(Syn60_Flag==1)
             {
               LocalWorkCtl(0);	
               Syn60_Flag=2;	
             }
        }   
/*-----------------------------------------*/
#ifdef PLLDEBUG
        runinfo[curpos].phdinfo=PhD;
        runinfo[curpos].statusinfo=CurStatus;
        runinfo[curpos].cwinfo=CW;
        runinfo[curpos].to_tgt=PhD_InitPhD;
        if(++curpos>=maxinfos)curpos-=maxinfos; 
#endif
/*-----------------------------------------*/
    }/*end of switch*/

    switch(CurStatus){
        case SDS_PLL_LOSE:
            SET_PLL_LOSE_STATE
            break;
        case SDS_PLL_FASTC:
        	SET_PLL_FAST_STATE
            break;
        case SDS_PLL_SLOWC:
        	SET_PLL_SLOW_STATE
            break;
        case SDS_PLL_LOCK:
        	SET_PLL_LOCK_STATE
        	break;
    }/*end of switch*/

    ((PLLData *)pDataBuf)->status=CurStatus;
    /* 向D/A写控制字*/
    if(CurStatus!=SDS_PLL_LOSE && Prev_CW!=CW){
    	
#if REVNUM ==1    	/*------------------by dmw------------*/
    	CWreverse=0;
     	mask=0x1L;
     	for(i=1;i<13;i++){
        	CWreverse|=(CW&mask)<<(33-2*i);
        	mask<<=1;
       	}
    	CWreverse&=0xfff00000;
    	*((volatile ULONG*)DABase)=CWreverse;
    	
#elif REVNUM==2
    	CWreverse=CW<<20;
    	*((volatile ULONG*)DABase)=CWreverse;     	
#elif (REVNUM==3 || REVNUM==4)
	    CWreverse=CW<<4;
    	*((volatile USHORT*)DABase)=(USHORT)CWreverse;     	 
#endif            /*------------------by dmw------------*/

    }
    Prev_CW=CW; 
    Prev_PhD=PhD; 
    SET_BIT(S_SiPendRegister,IRQ_PLL_PENDING_BIT,32)
}  
else if(Syn60_Flag==0)
#endif
 {
     int_counter=int_counter+1 ;
   if(int_counter>=100)
   {
       int_counter=0;
       sec_counter =(sec_counter+1) ;
   }
       
    switch(CurStatus)
    {
     case SDS_PLL_LOSE:
        if (++entries>Power_Up_Time/TS1)
         {   
          entries=0;
          CurStatus=SDS_PLL_FASTC;
            
          lock_alarm=0;
          sec_counter=0;
          
          /*flash_val=ReadDAFromFlash();
          if(flash_val<0||flash_val>V_OUT_MAX) flash_val=1229;*/
          CurDA=flash_val; 
          Locked_DAC_Val=flash_val;
          old_ph_diff=flash_val;
          #ifdef PLLDEBUG
            INITPHD=flash_val; 
          #endif 
          MAX_CurDA=0;
          MIN_CurDA=3000;
          Slave_Init=0;
 
          Frombegin=1;
          array_pr=0;
          for(m=0;m<=399;m++) DA[m]=0;
         }
          ((PLLData *)pDataBuf)->status=CurStatus;
     break;        
     case SDS_PLL_FASTC:
        tmp =*((ULONG *)PLLBase);
        tmp &= 0xffe00000L;
        tmp >>=21;
        if(tmp>=1625)
        {
          SET_BIT(S_SiPendRegister,IRQ_PLL_PENDING_BIT,32)	
          return;
        }   
        LoopFilter((long)tmp,CurDA,Frombegin);
        Frombegin=0;
      /*  entries++;*/
        if(en_able==-1)
	 {
	  en_able=0;
	  if(lock_alarm==0xaa)
	    {
	     CurDA=Locked_DAC_Val;
	     OutputDA((ULONG)CurDA);
            }
	  else 
	    {
	     CurDA=Frval;
	     OutputDA((ULONG)CurDA);
	    }			      			                
		/*-----------------------------------------*/
#ifdef PLLDEBUG 
        runinfo[curpos].phdinfo=NewPhase;
        runinfo[curpos].statusinfo=CurStatus;
        runinfo[curpos].cwinfo=CurDA;
        runinfo[curpos].to_tgt=FreV;
        if(++curpos>=maxinfos)curpos-=maxinfos; 
#endif
       /*-----------------------------------------*/	                
	 }  
/*判断是否已经锁定*/	   	
       if((sec_counter>=240)&&(sec_counter%240==0))
	{    
	 if(lock_alarm!=0xaa)
	  {
	   CurDA=Frval;			        
           if(abs(MAX_CurDA-MIN_CurDA)<=45)
	      {
	       /*flash_val=ReadDAFromFlash();
               if(flash_val<0||flash_val>V_OUT_MAX) flash_val=1229;	*/
	       if(abs(CurDA-flash_val)<380) 
	        {      
	         CurStatus=SDS_PLL_LOCK;
	         lock_alarm=0x0;
		 sec_counter=0;		
    	         }
    			                       
              }
          }       			                      
     	 MAX_CurDA=0;
         MIN_CurDA=3000;                                                             
        }
 /*判断有无偏离基准*/                           
       if(sec_counter>=1800)
        {       
     	 Frombegin=1;
         sec_counter=0;
         CurDA=Frval;
         /*flash_val=ReadDAFromFlash();
         if(flash_val<0||flash_val>V_OUT_MAX) flash_val=1229;*/
         if(abs(CurDA-flash_val)>380)
           {
            lock_alarm=0xaa;
            for(m=0;m<=399;m++) DA[m]=0;
            array_pr=0; 
           }
          else 			       	     	              			       	     	 
     	   lock_alarm=0x0;     			       	     	          			     			                 
     	}

     ((PLLData *)pDataBuf)->status=CurStatus;     	
     break;
     case SDS_PLL_LOCK:
      tmp =*((ULONG *)PLLBase);
      tmp =*((ULONG *)PLLBase);
      tmp &= 0xffe00000L;
      tmp >>=21;
      if(tmp>=1625)
      {
        SET_BIT(S_SiPendRegister,IRQ_PLL_PENDING_BIT,32)	
        return;
      }   
      LoopFilter((long)tmp,CurDA,Frombegin);
      Frombegin=0;
      if( en_able==-1) 
       {			
       	en_able=0;   	                                      
        CurDA=Frval;
	if(abs(CurDA-old_ph_diff)<380)  
	 {
          OutputDA((ULONG)CurDA);
          LoseLockCount=0;
          /*-----------------------------------------*/
#ifdef PLLDEBUG 
        runinfo[curpos].phdinfo=NewPhase;
        runinfo[curpos].statusinfo=CurStatus;
        runinfo[curpos].cwinfo=CurDA;
        runinfo[curpos].to_tgt=FreV;
        if(++curpos>=maxinfos)curpos-=maxinfos; 
#endif
         /*-----------------------------------------*/ 		
         }
        else
         {
          LoseLockCount++;
	   if(LoseLockCount>LoseLockThreshold)
	    {
	     CurStatus=SDS_PLL_FASTC;
	     lock_alarm=0xaa;
            
             LoseLockCount=0;
             KeepFast=0;
             KeepSlow=0;
	     sec_counter=0; 
	     MAX_CurDA=0;
             MIN_CurDA=3000; 
             for(m=0;m<=399;m++) DA[m]=0;
             array_pr=0;        
	     break;
	    }
	 }
       }     
  /*10分钟产生可以写入FLASH中的只值*/     
      if((sec_counter>=600)&&(sec_counter%600==0))
       {     			       
        if(abs(MAX_CurDA-MIN_CurDA)<=8)
	 {	   			                       		                        
       	  Locked_DAC_Val=(MAX_CurDA+MIN_CurDA)/2;
	 }	
	MAX_CurDA=0;
        MIN_CurDA=3000;   
       }
/*产生前一小时锁相值*/                                         	 			
       if(sec_counter>=3600)
        {
          sec_counter=0;
          if(Cr>=390)
           {
          /*  CurDA=(Addr_Da/Cr);*/        
            old_ph_diff=(Addr_Da/Cr);  
           }           
        } 
 
    ((PLLData *)pDataBuf)->status=CurStatus;
    break;
    }/*end of switch*/

    SET_BIT(S_SiPendRegister,IRQ_PLL_PENDING_BIT,32)
    return; 
 }   
    
}

char *PLLBspInit(int DEV, char *FreeMemPtr)
{
    InstallSD(DEV,PLLRead,NULL,PLLCntrl,FreeMemPtr);
    PLLInit(FreeMemPtr); 
    FreeMemPtr += sizeof(PLLData);
    memcpy(FreeMemPtr,"**PLLDat",8);
    FreeMemPtr += 8;
    return FreeMemPtr;
}