开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > uCOS > 查看源码
pll.c
资源名称：mini2440_uCos2_ucgui.rar　[点击查看]
上传用户：zbk8730
上传日期：2017-08-10
资源大小：12168k
文件大小：8k
源码类别：

uCOS

开发平台：

C/C++

pll.c：源码内容
  1. /*****************************************
  2.   NAME: pll.c
  3.   DESC: PLL & Maximum frequency test.
  4.   HISTORY:
  5.   03.21.2002:purnnamu: first release for S3C2410X
  6.   06.02.2003:DonGo: Modified for S3C2440X
  7.   Jan.e.2004:DonGo: Modified for S3C2440A
  8.  *****************************************/
  9. #include <math.h>
  10. #include <stdlib.h>
  12. #include "def.h"
  13. #include "option.h"
  14. #include "2440addr.h"
  15. #include "2440lib.h"
  16. #include "2440slib.h" 
  17. #include "pll.h"
  18. #include "memtest.h"
  20. extern Calc_Clock(int print_msg);
  21. extern U32 Mdiv, Pdiv, Sdiv, Fclk, Hclk, Pclk, Hdivn, Pdivn, Hclk_Ratio, Pclk_Ratio, Ref_Cnt;
  24. void Sram_Test(void);
  26. #if FIN==12000000
  27. volatile U32 Mps_Val[][4]={
  28. // FCLK,  M,  P,  S.
  29. {271500000, 173,  2, 2},
  30. {304000000,   68,  1, 1},
  31. {338400000, 133,  3, 1},
  32. {372000000,   85,  1, 1},
  33. {406430000, 127,  2, 1},
  34. {451200000, 180,  3, 1},
  35. {496000000, 116,  1, 1},
  36. {532800000, 125,  1, 1},
  37. {542400000, 218,  3, 1}
  38. };
  39. #else
  40. volatile U32 Mps_Val[][4]={
  41. // FCLK,  M,  P,  S.
  42. {266716800, 118,  2, 2},
  43. {296352000,   97,  1, 2},
  44. {331914240,   90,  3, 1},
  45. {370440000, 167,  6, 1},
  46. {399651840, 110,  3, 1},
  47. {431827200,   94,  2, 1},
  48. /*{470776320, 131,  3, 1},
  49. {500774400, 199,  5, 1},
  50. {530611200,   86,  1, 1},
  51. {541900800, 120,  2, 1}
  52. */
  53. };
  54. #endif
  56. int No_Of_Mps_Val=sizeof(Mps_Val)/16;
  59. void Test_PLL(void)
  60. {
  61. int temp, voltage=120;
  62. int i,j, mdiv, pdiv, sdiv, sval, fclk, hdiv_val, pdiv_val;
  63. U32 prev_fclk;
  64. U32 mpllcon_bk, clkdivn_bk, camdivn_bk;
  66. // clock register backup.
  67. mpllcon_bk = rMPLLCON;
  68. clkdivn_bk = rCLKDIVN;
  69. camdivn_bk = rCAMDIVN;
  71. Uart_Printf("[PLL frequency change test 100,000 times]n");
  72. //Uart_TxEmpty(1);
  74. rLOCKTIME=((U32)(1807*0.8)<<12)|((U32)(1807*0.8)<<0); 
  75. //rLOCKTIME=((U32)(12048)<<16)|((U32)(12048)<<0); 
  76. // 1807 is 150us at 12Mhz
  78. j=0;
  79. while(1) 
  80. {
  81. if(Uart_GetKey()==ESC_KEY) 
  82. break;
  83. if(j>100000) 
  84. break;
  86. i= j%No_Of_Mps_Val;
  89. fclk = Mps_Val[i][0];
  90. //Uart_Printf("[%d]FCLK=%d [Mps_Val=%xh,%xh,%xh]n", j, Mps_Val[i][0],Mps_Val[i][1],Mps_Val[i][2],Mps_Val[i][3]);
  91. Uart_Printf("[%d] ", j);
  92. Uart_TxEmpty(1);
  94. if(Mps_Val[i][0]<=350000000)
  95. {
  96. hdiv_val=12; 
  97. pdiv_val=12;
  98. voltage=110;
  99. }
  100. else if(Mps_Val[i][0]<= 440000000) 
  101. {
  102. hdiv_val=13; 
  103. pdiv_val=12;
  104. voltage=120;
  105. }
  106. else
  107. {
  108. hdiv_val=14; 
  109. pdiv_val=12;
  110. voltage=135;
  111. }
  113. Led_Display(j%2);
  114. //Uart_Printf("[FCLK:HCLK:PCLK=1:%d:%d=", hdiv_val%10, (hdiv_val%10)*(pdiv_val%10));
  115. //Uart_Printf("%4.1f:%4.1f:%4.1f MHz]n", (float)fclk/MEGA, (float)fclk/MEGA/(hdiv_val%10), (float)fclk/MEGA/((hdiv_val%10)*(pdiv_val%10)));
  116. Uart_Printf("Voltage:%4.2f[V]n", (float)voltage/100);
  117. Max1718_Set(voltage);
  118. Delay(10);
  120. if(prev_fclk<Mps_Val[i][0]) {
  121. Led_Display(0x1);
  122. ChangeClockDivider(hdiv_val, pdiv_val);
  123. Led_Display(0x2);
  124. ChangeMPllValue(Mps_Val[i][1],Mps_Val[i][2],Mps_Val[i][3]);
  125. } 
  126. else 
  127. {
  128. Led_Display(0x2);
  129. ChangeMPllValue(Mps_Val[i][1],Mps_Val[i][2],Mps_Val[i][3]);
  130. Led_Display(0x1);
  131. ChangeClockDivider(hdiv_val, pdiv_val);
  132. }
  134. Calc_Clock(1);
  135. Led_Display(0x4);
  136. UPDATE_REFRESH(Hclk);
  137. Led_Display(0x8);
  139. #if 1
  140. Mem_Test(1);
  141. #endif
  143. prev_fclk = Mps_Val[i][0];
  144. j++;
  145. }  
  147. Uart_Printf("nMPLL change test OK.n");
  149. Uart_Printf("nReturn to Previous setting.n");
  150. rMPLLCON = mpllcon_bk;
  151. rCLKDIVN = clkdivn_bk;
  152. rCAMDIVN = camdivn_bk;
  153. Calc_Clock(1);
  155. }
  159. // lock time: user lock time setting time[us],
  160. // lock_count: register setting value for wanted locktime.
  161. #define TIME_OF_XTAL ((float)MEGA/(float)FIN) //us
  162. U32 Calc_Locktime(U32 lock_time)
  163. {
  164. U32 lock_count=0;
  166. lock_count = (U32)((float)lock_time/((float)TIME_OF_XTAL));
  168. return lock_count;
  169. }
  171. void Test_Locktime(void)
  172. {
  173. int temp;
  174. int i,j, mdiv, pdiv, sdiv, sval, fclk, hdiv_val, pdiv_val;
  175. U32 lock_time=300, lock_count=12048; //Unit is us.
  176. U32 mpllcon_bk;
  178. // clock register backup.
  179. mpllcon_bk = rMPLLCON;
  181. Uart_Printf("[PLL Lock time test 100,000 times]n");
  182. Uart_Printf("Lock time range: 300us - %d [us]n", (U32)(0xffff*TIME_OF_XTAL));
  183. Uart_Printf("Input Lock time[us]: ");
  184. lock_time = Uart_GetIntNum();
  186. lock_count = Calc_Locktime(lock_time); // lock_time [us]
  187. rLOCKTIME=((U32)(lock_count)<<16)|((U32)(lock_count)<<0); 
  188. Uart_Printf("Locktime register value is %d(%xh).n", rLOCKTIME&0xffff, rLOCKTIME&0xffff);
  190. Uart_Printf("Clock will be locked after LED7 is ON.n");
  192. i=0;
  193. //ChangeClockDivider(12,12); // 1:2:4
  194. while(1) 
  195. {
  196. if(Uart_GetKey()!=0x0) 
  197. break;
  198. if(i>100000) 
  199. break;
  200. if(i%2) 
  201. {
  202. Led_Display(0x8);
  203. rMPLLCON = mpllcon_bk;
  204. } 
  205. else 
  206. {
  207. Led_Display(0x0);
  208. rMPLLCON = mpllcon_bk;
  209. }
  210. //Delay(1000);
  211. i++;
  212. }
  213. Uart_Printf("[PLL Lock time test %d times end]n",i-1);
  214. }
  217. void Manual_Change_Pll(void)
  218. {
  219. U32 pdiv, mdiv, sdiv, sval, fclk, hdiv_val, pdiv_val, voltage=120;
  220. int i, fclk_sel;
  221. float ffclk;
  223. Uart_Printf("[Running change test of M/P/S value]n");
  225. for(i=0; i<sizeof(Mps_Val)/16; i++) {
  226. if(i%2==0) Uart_Printf("n");
  227. Uart_Printf("%2d: FCLK=%4.1f [%xh(%d),%xh,%xh] ", i, (float)Mps_Val[i][0]/MEGA,Mps_Val[i][1],Mps_Val[i][1],Mps_Val[i][2],Mps_Val[i][3]);
  228. }
  229. Uart_Printf("n");
  231. #if 1
  232. Uart_Printf("Select FCLK No(0-%d): ", sizeof(Mps_Val)/16-1);
  233. fclk_sel=Uart_GetIntNum();
  234. mdiv = Mps_Val[fclk_sel][1];
  235. pdiv = Mps_Val[fclk_sel][2];
  236. sdiv = Mps_Val[fclk_sel][3];
  237. #else
  238. Uart_Printf("Input M vlaue : ");
  239. mdiv=Uart_GetIntNum();
  240. Uart_Printf("Input P vlaue : ");
  241. pdiv=Uart_GetIntNum();
  242. Uart_Printf("Input S vlaue : ");
  243. sdiv=Uart_GetIntNum();
  244. #endif
  246. Uart_Printf("Select FCLK : HCLK(1:1=11,1:2=12,1:3=13,1:4=14,...) : ");
  247. hdiv_val=Uart_GetIntNum();
  248. Uart_Printf("Select HCLK : PCLK(1:1=11,1:2=12) : ");
  249. pdiv_val=Uart_GetIntNum();
  251. sval=(int)pow(2,sdiv);
  252. ffclk = (U32) ( (((float)mdiv+8)*FIN*2.0)/(((float)pdiv+2)*(float)sval)); // pll2188x.
  253. Uart_Printf("Now change PLL value...(%dhz)[mps=%xh(%d), %d, %d]n", (U32)ffclk, mdiv,mdiv, pdiv, sdiv);
  255. Uart_Printf("Voltage: ");
  256. voltage = Uart_GetIntNum();
  257. Max1718_Set(voltage);
  258. Delay(10);
  260. ChangeClockDivider(hdiv_val, pdiv_val);
  261. ChangeMPllValue(mdiv,pdiv,sdiv);
  263. Calc_Clock(1);
  264. UPDATE_REFRESH(Hclk);
  265. Uart_Init(Pclk, 115200);
  268. #if 1
  269. //Uart_Getch();
  270. Uart_Printf("Memory test (y/n)? ");
  271. if(Uart_Getch()=='y') {
  272. while(1) {
  273. Mem_Test(1);
  274. if(Uart_GetKey()!=0x0) break;
  275. //Uart_SendByte((int)'.');
  276. }
  277. }
  278. #endif
  280.  }
  282. void Manual_Change_Pll_Iostrength(void)
  283. {
  285. Manual_Change_Pll();
  286. Test_IO_Strength();
  288. #if 1
  289. //Uart_Getch();
  290. while(1) {
  291. Mem_Test(1);
  292. if(Uart_GetKey()!=0x0) break;
  293. }
  294. #endif
  295. }
  297. void Test_PllOnOff(void)
  298. {
  299. int i,j;
  300. unsigned int saveREFRESH;
  302. Uart_Printf("[PLL On/Off test, 10000 times]n");
  303. Uart_TxEmpty(1); //To avoid being crushed the character
  305. rLOCKTIME=((U32)(1807*0.8)<<12)|((U32)(1807*0.8)<<0); 
  306. // 1807 is 150us at 12Mhz
  307. Uart_Printf("count:                    ");
  309. for(j=0;j<10000;j++) {
  310. Led_Display(0x2);
  311. rCLKSLOW=(1<<7)|(1<<5)|(1<<4)|(0<<0); //FCLK=FIN/1,SLOW mode,MPLL=off,UPLL=off
  313. saveREFRESH=rREFRESH;
  314. rREFRESH=(1<<23)|(U32)(2048+1-12*7.8); //HCLK = 12MHz, Trp=2clk,Trc=4clk
  316. rCLKSLOW=(1<<7)|(0<<5)|(1<<4)|(0<<0);//PLL on,MPLL=on,UPLL=on
  317. for(i=0;i<2048/4;i++); //S/W MPLL lock-time
  318. Led_Display(0x0);
  319. rCLKSLOW=(1<<7)|(0<<5)|(0<<4)|(0<<0);//NORMAL mode,PLL on,MPLL=on,UPLL=on
  321. rREFRESH=saveREFRESH;
  322. if(j%500==0)
  323. {
  324. Uart_Printf("bbbbbb%6d", j);
  325. Uart_TxEmpty(1); //To avoid being crushed the character
  326. }
  327. }
  328. Uart_Printf("bbbbbb%6d", j);
  329. }