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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > DSP编程 > 查看源码
VT1420.gel
资源名称：DSP-C6000-DM642DEMO.rar　[点击查看]
上传用户：dahaojd
上传日期：2008-01-29
资源大小：14357k
文件大小：14k
源码类别：

DSP编程

开发平台：

C/C++

VT1420.gel：源码内容
  1. /*--------------------------------------------------------------*/
  2. /* VT1420.gel                                                   */
  3. /* version xxxx                                                 */
  4. /*                                                              */
  5. /* This GEL file is designed to be used in conjunction with the */
  6. /* CCS 2.0 and the VT-142x TMS320C6416 DSP based PMC modules.   */
  7. /* Copied from the TI TEB_6416.gel.                             */
  8. /*                                                              */
  9. /* Things to do:                                                */
  10. /*     LED on/off func like LED_cycle()                         */
  11. /*     Memory/config detect: Read GPIO, test memory, determine  */
  12. /*                           Flash type (AMD vs SST) like       */
  13. /*                                     QuickTest()              */
  14. /*--------------------------------------------------------------*/
  16. /*--------------------------------------------------------------*/
  17. /* The StartUp() function is called each time CCS is started.   */
  18. /* Customize this function to perform desired initialization.   */
  19. /*--------------------------------------------------------------*/
  21. StartUp()
  22. {
  23. /*  setup_memory_map();  */
  24.   GEL_Reset();  
  25.   init_emif();
  26.   init_GPIO();
  27. } 
  30. /*--------------------------------------------------------------*/
  31. /* The setup_memory_map() function does not appear to work in   */
  32. /* the simulator.  It code be unnecessary since C64x only has   */
  33. /* one mapping (unlike other TI DSPs).                          */
  34. /*--------------------------------------------------------------*/
  35. setup_memory_map()
  36. {
  37.         GEL_MapOn();
  38.         GEL_MapReset();
  39.         GEL_MapAdd(0x00000000, 0, 0x00100000, 1, 1); /* Internal Memory       */
  40.         GEL_MapAdd(0x01800000, 0, 0x00000054, 1, 1); /* EMIFA CTL REGS        */
  41.         GEL_MapAdd(0x01840000, 0, 0x000082FC, 1, 1); /* INT MEM CTL REGS      */
  42.         GEL_MapAdd(0x018C0000, 0, 0x0000003C, 1, 1); /* MCBSP0 CTL REGS       */
  43.         GEL_MapAdd(0x01900000, 0, 0x0000003C, 1, 1); /* MCBSP1 CTL REGS       */
  44.         GEL_MapAdd(0x01940000, 0, 0x00000008, 1, 1); /* TIMER0 CTL REGS       */
  45.         GEL_MapAdd(0x01980000, 0, 0x00000008, 1, 1); /* TIMER1 CTL REGS       */
  46.         GEL_MapAdd(0x019C0000, 0, 0x00000008, 1, 1); /* INT CTL REGS          */
  47.         GEL_MapAdd(0x01A00000, 0, 0x0000FFFC, 1, 1); /* EDMA REGS AND PARAM   */
  48.         GEL_MapAdd(0x01A40000, 0, 0x0000003C, 1, 1); /* MCBSP2 CTL REGS       */
  49.         GEL_MapAdd(0x01A80000, 0, 0x00000054, 1, 1); /* EMIFB CTL REGS        */
  50.         GEL_MapAdd(0x01AC0000, 0, 0x00000008, 1, 1); /* TIMER2 CTL REGS       */
  51.         GEL_MapAdd(0x01B00000, 0, 0x00000024, 1, 1); /* GPIO REGS             */
  52.         GEL_MapAdd(0x02000000, 0, 0x00000030, 1, 1); /* QDMA REGS             */
  53.         GEL_MapAdd(0x30000000, 0, 0x04000000, 1, 1); /* MCBSP0 Data, EDMA map */
  54.         GEL_MapAdd(0x34000000, 0, 0x04000000, 1, 1); /* MCBSP1 Data, EDMA map */
  55.         GEL_MapAdd(0x38000000, 0, 0x04000000, 1, 1); /* MCBSP2 Data, EDMA map */
  56.         GEL_MapAdd(0x64000000, 0, 0x00040000, 1, 1); /* FLASH EMIF-B, CE1     */
  57.         GEL_MapAdd(0x80000000, 0, 0x01000000, 1, 1); /* 16MB SDRAM EMIF-A, CE0*/
  58. }
  60. /*--------------------------------------------------------------*/
  61. /* init_emif()                                                      */
  62. /*             EMIF settings depend on EMIF Clock freq and      */
  63. /*                     memory device specifics.                 */
  64. /*                                                              */
  65. /*             SDRAM devices: MT48LC2M32B2-7                    */
  66. /*                            2Mx32, 512Kx32x4 banks            */
  67. /*                            tRC(-7) = 70 nsec                 */
  68. /*                            tRP(-7) = 20 nsec                 */
  69. /*                            tRCD(-7) = 20 nsec                */
  70. /*                            tREF(-7) = 64 msec for 4,096 rows */
  71. /*                            tCL = 2 tcyc (min) for <=100MHz   */
  72. /*                            tRAS(-7) = 42(min)-120K(max)nsec  */
  73. /*                            tRRD(-7) = 14 nsec                */
  74. /*                            tWR(-7) = 1 tcyc + 7 nsec (17min) */
  75. /*                               min for the following=         */
  76. /*                                    tRC for same bank         */
  77. /*                                    tRRD for different banks  */
  78. /*                            tRD2RD(-7) = 1 tcyc (figure 8)    */
  79. /*                            tRD2DEAC(-7) = 2 tcyc (p 17)      */
  80. /*                            tRD2WR(-7) = 1 tcyc (fig 9)       */
  81. /*                            tR2WDQM(-7) = 2 tcyc (p 16)       */
  82. /*                            tWR2WR(-7) = 1 tcyc (p 19)        */
  83. /*                            tWR2DEAC(-7) = 2 tcyc (p 20)      */
  84. /*                            tWR2RD(-7) = 1 tcyc (p 20)        */
  85. /*                                                              */
  86. /*                                                              */
  87. /*                                                              */
  88. /*             EMIFA Clock: 100MHz  (10 nsec tcyc)              */ 
  89. /*                          33MHz DSP input clock               */
  90. /*                          CPU=400MHz (x12 multiplier)         */
  91. /*                          EMIFA clock boot settings: 01 CPU/4 */
  92. /*                            :AECLKIN_SELECT = CPU/4 = 100MHz  */
  93. /*                          Notes: VT-1420 uses ECLKOUT2        */
  94. /*                                 DSP EMIF timing is based on  */
  95. /*                                    ECLKOUT1 for tcyc         */
  96. /*                                                              */
  97. /*--------------------------------------------------------------*/
  98. init_emif()
  99. {
  101. #define EMIFA_GCTL       0x01800000
  102. #define EMIFA_CE1        0x01800004
  103. #define EMIFA_CE0        0x01800008
  104. #define EMIFA_CE2        0x01800010
  105. #define EMIFA_CE3        0x01800014
  106. #define EMIFA_SDRAMCTL   0x01800018
  107. #define EMIFA_SDRAMREF   0x0180001c
  108. #define EMIFA_SDRAMEXT   0x01800020
  109. #define EMIFA_CE1SECCTL  0x01800044
  110. #define EMIFA_CE0SECCTL  0x01800048
  111. #define EMIFA_CE2SECCTL  0x01800050
  112. #define EMIFA_CE3SECCTL  0x01800054
  114. #define EMIFB_GCTL       0x01A80000
  115. #define EMIFB_CE1        0x01A80004
  116. #define EMIFB_CE0        0x01A80008
  117. #define EMIFB_CE2        0x01A80010
  118. #define EMIFB_CE3        0x01A80014
  119. #define EMIFB_SDRAMCTL   0x01A80018
  120. #define EMIFB_SDRAMREF   0x01A8001c
  121. #define EMIFB_SDRAMEXT   0x01A80020
  122. #define EMIFB_CE1SECCTL  0x01A80044
  123. #define EMIFB_CE0SECCTL  0x01A80048
  124. #define EMIFB_CE2SECCTL  0x01A80050
  125. #define EMIFB_CE3SECCTL  0x01A80054
  126.         
  127.     /* EMIFA Control */
  128.         *(int *)EMIFA_GCTL     = 0x000120DC; /* Why did TEB board write a '1' to bit 12? */
  129.         
  130.         /*EMIFA CE0 SDRAM*/
  131.         *(int *)EMIFA_CE0      = 0xffffffdf;
  132.         *(int *)EMIFA_SDRAMCTL = 0x47116000; /* Pure coincedence that this matches the TEB */
  133.         *(int *)EMIFA_SDRAMREF = 0x000005DC; /* Use powerup default, more conservative than TEB */
  134.         *(int *)EMIFA_SDRAMEXT = 0x000504A8; /* TEB value of 0x00054549 is more conservative */
  135.                                              /* I thought it should be 0x000504A8 */
  136.         
  138.     /* EMIFB Control */
  139.         *(int *)EMIFB_GCTL     = 0x000120DC; 
  140.         
  141.         /*EMIFB CE1 FLASH, 8 Bit*/
  142.         *(int *)EMIFB_CE1      = 0xffffff03; /* Conservative #, Optimize speed by trying VT-1402 number 0x2372CD23 */
  144.         *(int *)EMIFA_SDRAMCTL = 0x47116000; /* Do this again to reset the SDRAM */
  146. }
  147.  
  148. /*--------------------------------------------------------------*/
  149. /* GPIO DEFINITIONS, 1=Enable, 1=Output DIR                     */
  150. /*--------------------------------------------------------------*/
  151. #define GPEN_REG       0x01B00000
  152. #define GPDIR_REG      0x01B00004
  153. #define GPVAL_REG      0x01B00008
  155. #define MS_FLASH       0x0001
  156. #define GREEN_LED      0x0002
  157. #define RED_LED        0x0004
  158. #define MCBSP2_EN      0x0008
  159. #define EXT_INT4       0x0010
  160. #define EXT_INT5       0x0020
  161. #define EXT_INT6       0x0040
  162. #define DSP_ID         0x0080
  164. #define Get_GPIO_En     (*(char *)GPEN_REG )
  165. #define Get_GPIO_Val    (*(char *)GPVAL_REG )
  166. #define Get_DSP_ID      ( (*(char *)GPVAL_REG & DSP_ID) >> 7 )
  167. #define Get_GREEN_LED   ( (*(char *)GPVAL_REG & GREEN_LED) >> 1 )
  168. #define Get_RED_LED     ( (*(char *)GPVAL_REG & RED_LED) >> 2 )
  171. /*--------------------------------------------------------------*/
  172. /* Timer GPIO DEFINITIONS, 1=Enable, 1=Output DIR               */
  173. /*--------------------------------------------------------------*/
  174. #define T0_CTL_REG       0x01940000
  175. #define T1_CTL_REG       0x01980000
  176. #define T1_CTL_REG       0x01AC0000
  177.  
  178. #define TIMER_CTL_DEF    0x00000000
  180. #define TIMER_DIN        0x0004
  181. #define TIMER_DOUT       0x0008
  183. #define Get_DSP_Cfg0    ( (*(char *)T0_CTL_REG & TIMER_DIN) >> 2 )
  184. #define Get_DSP_Cfg1    ( (*(char *)T1_CTL_REG & TIMER_DIN) >> 2 )
  187. /*--------------------------------------------------------------*/
  188. /* init_GPIO()                                                  */
  189. /*--------------------------------------------------------------*/
  190. init_GPIO()
  191. {
  192. /*    *(char *)GPEN_REG = Get_GPIO_En | (GREEN_LED | RED_LED | DSP_ID) ; */
  193.         *(char *)GPEN_REG = 0x0 | (GREEN_LED | RED_LED | DSP_ID) ; 
  194.         *(char *)GPDIR_REG = 0x0 | (GREEN_LED | RED_LED) ; 
  196. }
  199. /*--------------------------------------------------------------*/
  200. /* clear_memory_map()                                           */
  201. /*--------------------------------------------------------------*/
  202. clear_memory_map()
  203. {
  204.     GEL_MapOff();
  205. }
  207. /*--------------------------------------------------------------*/
  208. /* LED_cycle()                                                  */
  209. /*--------------------------------------------------------------*/
  210. LED_cycle()
  211. {
  213.   RED_LED_off();
  214.   GREEN_LED_off();
  215.   RED_LED_on();
  216.   GREEN_LED_on();
  217.   RED_LED_off();
  219. }  
  222. /*--------------------------------------------------------------*/
  223. /* RED_LED_on()   logic low puts the LED on                     */
  224. /*--------------------------------------------------------------*/
  225. RED_LED_on()
  226. {
  227.     *(char *)GPVAL_REG = Get_GPIO_Val & ~RED_LED        ;
  228. }  
  230. /*--------------------------------------------------------------*/
  231. /* RED_LED_off()                                                */
  232. /*--------------------------------------------------------------*/
  233. RED_LED_off()
  234. {
  235.     *(char *)GPVAL_REG = Get_GPIO_Val | RED_LED ;
  236. }  
  238. /*--------------------------------------------------------------*/
  239. /* GREEN_LED_on()                                               */
  240. /*--------------------------------------------------------------*/
  241. GREEN_LED_on()
  242. {
  243.     *(char *)GPVAL_REG = Get_GPIO_Val & ~ GREEN_LED     ;
  244. }  
  246. /*--------------------------------------------------------------*/
  247. /* GREEN_LED_off()                                               */
  248. /*--------------------------------------------------------------*/
  249. GREEN_LED_off()
  250. {
  251.     *(char *)GPVAL_REG = Get_GPIO_Val | GREEN_LED ;
  252. }  
  256. /*--------------------------------------------------------------*/
  257. /* OnReset()                                                    */
  258. /*--------------------------------------------------------------*/
  259. OnReset(int nErrorCode)
  260. {
  261.         init_GPIO();
  262.     LED_cycle();
  263.         
  264.         GEL_BreakPtReset();
  265.         FlushCache();
  266.         init_emif();
  267. }
  270. /*--------------------------------------------------------------*/
  271. /* OnPreFileLoaded()                                            */
  272. /* This function is called automatically when the 'Load Program'*/
  273. /* Menu item is selected.                                       */
  274. /*--------------------------------------------------------------*/
  275. OnPreFileLoaded()
  276. {
  277.         FlushCache();
  278. }
  280. /*--------------------------------------------------------------*/
  281. /* FlushCache()                                                 */
  282. /*--------------------------------------------------------------*/ 
  283. FlushCache()   
  284. { 
  285.         *(int *)0x01840000 = (*(int *)0x01840000 | 0x00000300);
  286.         *(int *)0x01845000 = 0x1;
  287. }   
  290. /*--------------------------------------------------------------*/
  291. /* RESET MENU                                                   */
  292. /*--------------------------------------------------------------*/ 
  293. menuitem "Resets";
  295. hotmenu Reset_BreakPts_and_EMIF()
  296. {
  297.         GEL_BreakPtReset();
  298.         GEL_Reset();
  299.         init_emif();
  300. } 
  301. hotmenu Flush_Cache() 
  302. { 
  303.         FlushCache();
  304. } 
  306. /*--------------------------------------------------------------*/
  307. /* MEMORY MAP MENU                                              */
  308. /*--------------------------------------------------------------*/ 
  309. menuitem "Memory Map";
  311. hotmenu SetMemoryMap()
  312. {
  313.         setup_memory_map();
  314. }
  316. hotmenu ClearMemoryMap()
  317. {
  318.         clear_memory_map();
  319. }
  321. /*--------------------------------------------------------------*/
  322. /* Quick Test MENU                                              */
  323. /*--------------------------------------------------------------*/ 
  324. menuitem "Check VT-1420";
  325. hotmenu QuickTest()
  326. {
  327.         LED_cycle();
  328.         LED_cycle();
  329.         LED_cycle();
  330.         GEL_OpenWindow("VT1420 Output", 0, 5);
  331.         GEL_TextOut(" DSP_ID (0 for DSP A, 1 for DSP B): %d n",
  332.                       "VT1420 Output",1,1,1,
  333.                       Get_DSP_ID);      
  334.         GEL_TextOut(" DSP_CFG0 (expect=0): %d n",
  335.                       "VT1420 Output",1,1,1,
  336.                       Get_DSP_Cfg0);    
  337.         GEL_TextOut(" DSP_CFG1 (expect=0): %d n",
  338.                       "VT1420 Output",1,1,1,
  339.                       Get_DSP_Cfg1);    
  340.         GEL_TextOut(" GREEN LED (0=ON, 1=OFF): %d n",
  341.                       "VT1420 Output",1,1,1,
  342.                       Get_GREEN_LED);   
  343.         GEL_TextOut(" RED LED (0=ON, 1=OFF): %d nn",
  344.                       "VT1420 Output",1,1,1,
  345.                       Get_RED_LED);     
  347. }
  349. hotmenu REDLED_ON()
  350. {
  351.   RED_LED_on();
  352. }
  354. hotmenu REDLED_OFF()
  355. {
  356.   RED_LED_off();
  357. }
  359. hotmenu GREENLED_ON()
  360. {
  361.   GREEN_LED_on();
  362. }
  364. hotmenu GREENLED_OFF()
  365. {
  366.   GREEN_LED_off();
  367. }
  369. hotmenu CYCLE_LEDS()
  370. {
  371.   LED_cycle();
  372. }