Chinaunix首页 | 论坛 | 博客

oops

首页　| 　博文目录　| 　关于我

王贤才

  • 博客访问： 1176815
  • 博文数量： 573
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 66
  • 用 户 组： 普通用户
  • 注册时间： 2016-06-28 16:21
文章分类

全部博文（573）

文章存档

2018年（3）

2016年（48）

2015年（522）

我的朋友
最近访客
推荐博文
相关博文
touchscreen裸机驱动程序

分类： C/C++

2015-12-02 17:38:39

2440init.h文件

点击(此处)折叠或打开

  1. #ifndef _2440INIT_H_
  2. #define _2440INIT_H_

  4. /* WATCHDOG寄存器 */
  5. #define WTCON (*(volatile unsigned long *)0x53000000)
  6. /* SDRAM寄存器 */
  7. #define     MEM_CTL_BASE        0x48000000


  10. /*系统时钟相关寄存器*/
  11. #define    MPLLCON        (*(volatile unsigned long *)0x4c000004)
  12. #define    CLKDIVN        (*(volatile unsigned long *)0x4c000014)
  13. #define S3C2440_MPLL_200MHZ ((0x5c<<12)|(0x01<<4)|(0x02))

  15. void disable_watch_dog();
  16. void clock_init(void);
  17. void memsetup();
  18. void copy_steppingstone_to_sdram(void);
  19. void clean_bss(void);

  21. #endif
def.h文件

点击(此处)折叠或打开

  1. #ifndef __DEF_H__
  2. #define __DEF_H__

  4. #define U32 unsigned int
  5. #define U16 unsigned short
  6. #define S32 int
  7. #define S16 short int
  8. #define U8 unsigned char
  9. #define    S8 char

  11. #endif
head.S文件

点击(此处)折叠或打开

  1. @******************************************************************************
  2. @ File: head.S head.o init.o nand.o interrupt.o uart.o touchscreen.o main.o
  3. @ 功能: 设置SDRAM，将程序复制到SDRAM，然后跳到SDRAM继续执行
  4. @******************************************************************************
  5. .text
  6. .global _start
  7. _start:
  8. @******************************************************************************
  9. @ 中断向量，本程序中，除Reset和HandleIRQ外，其它异常都没有使用
  10. @******************************************************************************
  11.     b Reset

  13. @ 0x04: 未定义指令中止模式的向量地址
  14. HandleUndef:
  15.     b HandleUndef
  16.  
  17. @ 0x08: 管理模式的向量地址，通过SWI指令进入此模式
  18. HandleSWI:
  19.     b HandleSWI

  21. @ 0x0c: 指令预取终止导致的异常的向量地址
  22. HandlePrefetchAbort:
  23.     b HandlePrefetchAbort

  25. @ 0x10: 数据访问终止导致的异常的向量地址
  26. HandleDataAbort:
  27.     b HandleDataAbort

  29. @ 0x14: 保留
  30. HandleNotUsed:
  31.     b HandleNotUsed

  33. @ 0x18: 中断模式的向量地址
  34.     b HandleIRQ

  36. @ 0x1c: 快中断模式的向量地址
  37. HandleFIQ:
  38.     b HandleFIQ

  40. Reset:
  41.     ldr sp, =4096 @ 设置栈指针，以下都是C函数，调用前需要设好栈
  42.     bl disable_watch_dog @ 关闭WATCHDOG，否则CPU会不断重启
  43.     bl clock_init @ 设置MPLL，改变FCLK、HCLK、PCLK
  44.     bl memsetup @ 设置存储控制器以使用SDRAM
  45.     bl nand_init @ 初始化NAND Flash
  46.     
  47.                             @ 复制nand中4k后的代码到SDRAM中
  48.     ldr r0, =0x30000000 @ 1. 目标地址 = 0x30000000，这是SDRAM的起始地址
  49.     mov r1, #4096 @ 2. 源地址 = 4096，运行地址在SDRAM中的代码保存在NAND Flash 4096地址开始处
  50.     mov r2, #60*1024 @ 3. 复制长度 = 60K，对于本实验，这是足够了
  51.     bl CopyCode2SDRAM @ 调用C函数CopyCode2SDRAM
  52.     
  53.     bl clean_bss @ 清除bss段，未初始化或初值为0的全局/静态变量保存在bss段

  55.     msr cpsr_c, #0xd2 @ 进入中断模式
  56.     ldr sp, =0x31000000 @ 设置中断模式栈指针

  58.     msr cpsr_c, #0xdf @ 进入系统模式
  59.     ldr sp, =0x34000000 @ 设置系统模式栈指针，
  60.     
  61.     ldr lr, =ret_inituart @ 设置返回地址
  62.     ldr pc, =init_uart            @ 这里为什么不能用 bl init_uart ？？？，也可以在main函数里面初始化
  63. ret_inituart:
  64.         
  65.         
  66.     ldr lr, =ret_initirq @ 设置返回地址
  67.     ldr pc, =init_irq @ 调用中断初始化函数
  68. ret_initirq:
  69.     msr cpsr_c, #0x5f @ 设置I-bit=0，开IRQ中断

  71.     ldr lr, =halt_loop @ 设置返回地址
  72.     ldr pc, =main @ 调用main函数
  73. halt_loop:
  74.     b halt_loop

  76. HandleIRQ:
  77.     sub lr, lr, #4 @ 计算返回地址
  78.     stmdb { r0-r12,lr } @ 保存使用到的寄存器
  79.                                     @ 注意，此时的sp是中断模式的sp
  80.                                     @ 初始值是上面设置的4096
  81.     
  82.     ldr lr, =int_return @ 设置调用IRQ_Handle函数后的返回地址
  83.     ldr pc, =EINT_Handle @ 调用中断分发函数，在interrupt.c中
  84. int_return:
  85.     ldmia { r0-r12,pc }^ @ 中断返回, ^表示将spsr的值复制到cpsr
init.c文件

点击(此处)折叠或打开

  1. #include "2440init.h"

  3. /*
  4.  * 关闭WATCHDOG，否则CPU会不断重启
  5.  */
  6. void disable_watch_dog(void)
  7. {
  8.     WTCON = 0; // 关闭WATCHDOG很简单，往这个寄存器写0即可
  9. }

  11. /*
  12.  * 对于MPLLCON寄存器，[19:12]为MDIV，[9:4]为PDIV，[1:0]为SDIV
  13.  * 有如下计算公式：
  14.  * S3C2440: MPLL(FCLK) = (2 * m * Fin)/(p * 2^s)
  15.  * 其中: m = MDIV + 8 = 92+8, p = PDIV + 2 = 1+2, s = SDIV = 2
  16.  * 对于本开发板，Fin = 12MHz
  17.  * 设置CLKDIVN，令分频比为：FCLK:HCLK:PCLK=1:2:4，
  18.  * FCLK=200MHz,HCLK=100MHz,PCLK=50MHz
  19.  */
  20. void clock_init(void)
  21. {
  22.     // LOCKTIME = 0x00ffffff; // 使用默认值即可
  23.     CLKDIVN = 0x03; // FCLK:HCLK:PCLK=1:2:4, HDIVN=1,PDIVN=1
  24.     /* 如果HDIVN非0，CPU的总线模式应该从“fast bus mode”变为“asynchronous bus mode” */
  25. __asm__(
  26.     "mrc p15, 0, r1, c1, c0, 0\n" /* 读出控制寄存器 */
  27.     "orr r1, r1, #0xc0000000\n" /* 设置为“asynchronous bus mode” */
  28.     "mcr p15, 0, r1, c1, c0, 0\n" /* 写入控制寄存器 */
  29.     );

  31.     MPLLCON = S3C2440_MPLL_200MHZ;
  32.     /* 现在，FCLK=200MHz,HCLK=100MHz,PCLK=50MHz
  33.     并不保证你的任何设置都是合适的。所以，如果想要工作在200MHz，还是按照vivi的推荐值((0x5c<<12)|(0x01<<4)|(0x02))即可。
  34.     */
  35. }

  37. void memsetup(void)
  38. {
  39.     volatile unsigned long *p = (volatile unsigned long *)MEM_CTL_BASE;

  41.     // 可生成”位置无关的代码”，使得这个函数可以在被复制到
  42.     // SDRAM之前就可以在steppingstone中运行
  43.     // 存储控制器13个寄存器的值
  44.     p[0] = 0x22011110; //BWSCON
  45.     p[1] = 0x00000700; //BANKCON0
  46.     p[2] = 0x00000700; //BANKCON1
  47.     p[3] = 0x00000700; //BANKCON2
  48.     p[4] = 0x00000700; //BANKCON3
  49.     p[5] = 0x00000700; //BANKCON4
  50.     p[6] = 0x00000700; //BANKCON5
  51.     p[7] = 0x00018005; //BANKCON6
  52.     p[8] = 0x00018005; //BANKCON7
  53.     
  54.                                             // REFRESH,
  55.                                             // HCLK=12MHz: 0x008C07A3,
  56.                                             // HCLK=100MHz: 0x008C04F4
  57.     p[9] = 0x008C04F4;
  58.     p[10] = 0x000000B1; //BANKSIZE
  59.     p[11] = 0x00000030; //MRSRB6
  60.     p[12] = 0x00000030; //MRSRB7
  61. }

  63. void clean_bss(void)
  64. {
  65.     extern int __bss_start, __bss_end;
  66.     int *p = &__bss_start;
  67.     
  68.     for (; p < &__bss_end; p++)
  69.         *p = 0;
  70. }
interrupt.c文件

点击(此处)折叠或打开

  1. #include "interrupt.h"
  2. #include "touchscreen.h"
  3. #include "uart.h"
  4. #include "2440init.h"

  6. /*
  7. void (*isr_handle_array[50])(void);

  9. void Dummy_isr(void)
  10. {
  11.     while(1);
  12. }

  14. void all_init_irq(void)
  15. {
  16.     int i = 0;
  17.     for (i = 0; i < sizeof(isr_handle_array) / sizeof(isr_handle_array[0]); i++)
  18.     {
  19.         isr_handle_array[i] = Dummy_isr;
  20.     }

  22.     INTMOD = 0x0;     // 所有中断都设为IRQ模式
  23.     INTMSK = BIT_ALLMSK; // 先屏蔽所有中断

  25. //    isr_handle_array[ISR_IIC_OFT] = I2CIntHandle;
  26. }

  28. void IRQ_Handle(void)
  29. {
  30.     unsigned long oft = INTOFFSET;
  31.     
  32.     //清中断
  33.     if (oft == 4)
  34.         EINTPEND = 1<<7; //EINT4-7合用IRQ4，注意EINTPEND[3:0]保留未用，向这些位写入1可能导致未知结果
  35.     SRCPND = 1<<oft;    
  36.     INTPND = INTPND;    

  38.     //调用中断服务程序
  39.     isr_handle_array[oft]();
  40. }
  41. */

  43. //以上程序模板，只用函数指针，可以设置所有的中断函数，本程序先使用下面固定的函数：使用LED来测试4个外部中断

  45. /*
  46.  * 功能：初始化按键相关的GPIO引脚为外部中断
  47.  * 本程序：
  48.  * K1 : EINT1，引脚是GPF1
  49.  * K2 : EINT4，引脚是GPF4
  50.  * K3 : EINT2，引脚是GPF2
  51.  * K4 : EINT0，引脚是GPF0
  52.  */
  53. void init_irq()
  54. {
  55.      GPFCON |= (GPF0_EINT | GPF1_EINT | GPF2_EINT | GPF4_EINT); /*设置这几个引脚为中断功能*/
  56.     GPFUP = 0x00;
  57.     
  58.     EXTINT0 = 0x00; /*设置外部中断控制寄存器，低电平触发，默认也是0x00，所以这句可以不要*/
  59.         
  60.         /*设置外部中断屏蔽寄存器，EINT4~EINT24，共20个需要在这个寄存器中使能他们,
  61.          *EINTMASK只能使能EINT4， EINT0,EINT1,EINT2,EINT3 不受EINTMASK控制
  62.          *EINTMASK[4]:禁止/使能EINT4
  63.          */
  64.         EINTMASK &= (~(1<<4));
  65.         
  66.         /*设置模式寄存器 ：在IRQ模式中处理，默认也是0x00，所以这句可以不要*/
  67.         INTMOD = 0x00;
  68.         
  69.         /*设置中断优先级寄存器
  70.         *仲裁租0和6，优先级不轮换使能，每个仲裁组下优先级顺序：0-1-2-3-4-5-6,默认也是这个顺序
  71.         *最终按键产生中断的优先级顺序：K4(EINT0) > K1(EINT1) > K3(EINT2) > K2(EINT4)
  72.         */
  73.         PRIORITY &= (~(1<<0)) & (~(1<<6)) ;
  74.         
  75.         /*设置中断屏蔽寄存器，一级中断
  76.         *INTMSK[0]:禁止/使能EINT0
  77.         *INTMSK[1]:禁止/使能EINT1
  78.         *INTMSK[2]:禁止/使能EINT2
  79.         *INTMSK[4]:禁止/使能EINT4~EINT7
  80.         */
  81.         INTMSK &= (~(1<<0)) & (~(1<<1)) & (~(1<<2)) & (~(1<<4)); /*其实到这里，中断仍未完全开启，CPSR的I位还要清0*/
  82. }

  84. /*
  85.  * 功能：初始化LED的GPIO引脚
  86.  */
  87. static void init_led()
  88. {
  89.      GPBCON = (GPB5_OUT | GPB6_OUT | GPB7_OUT | GPB8_OUT);
  90.     GPBUP = 0x1e0;
  91.     GPBDAT = (GPB5_OFF | GPB6_OFF | GPB7_OFF | GPB8_OFF);
  92. }

  94. /*
  95. *功能：中断服务子程序
  96. *注意：1,按键产生中断的优先级顺序：K4(EINT0) > K1(EINT1) > K3(EINT2) > K2(EINT4)
  97. * 所以，同时按下其中2个，3个或者4个，只有优先级最高的哪个LED会被点亮
  98. * 2,如果硬件接线有LED连接了EINT4，EINT5，由于他们的中断优先级相同,EINTPEND[4:5]都是1，但都只会让SRCPND[4]=1,
  99. * 如果他们同时按下，则INTPND[4]=1,且INTOFFSET=4,走到case 4，EINTPEND[4:5]=11b,2个if都成立，所以，最后这2个LED会被同时点亮。
  100. */
  101. void EINT_Handle()
  102. {        
  103.             /*INTOFFSET:中断偏移寄存器，INTPND寄存器中的值被置1之后，中断偏移寄存器的值=32个一级中断的编号*/
  104.             unsigned long offset = INTOFFSET;
  105.             unsigned long eintval;
  106.             
  107.             //下面几个变量是触摸屏需要的变量
  108.             unsigned int subsrcval;
  109.             unsigned int ADCDLY_save;
  110.             float x_data; //x轴坐标转换后的数据值
  111.             float y_data; //y轴坐标转换后的数据值
  112.             int temp;
  113.             
  114.             init_led();
  115.             
  116.             /*
  117.             uart_sendString("\n\nINTOFFSET=");
  118.             uart_sendByte_hex(offset);
  119.             uart_sendByte('\n');
  120.             */
  121.             
  122.             switch(offset)
  123.             {
  124.                     /*EINT0中断：K4被按下*/
  125.                     case 0:
  126.                     {
  127.                                 uart_sendString("K4 ON!->LED4 ON!\n");
  128.                                 GPBDAT = (GPB5_OFF | GPB6_OFF | GPB7_OFF | GPB8_OFF);
  129.                                 GPBDAT = GPB8_ON; /*LED4亮*/
  130.                                 break;
  131.                     }
  132.                     /*EINT1中断：K1被按下*/
  133.                     case 1:
  134.                     {
  135.                                 uart_sendString("K1 ON!->LED1 ON!\n");
  136.                                 GPBDAT = (GPB5_OFF | GPB6_OFF | GPB7_OFF | GPB8_OFF);
  137.                                 GPBDAT = GPB5_ON; /*LED1亮*/
  138.                                 break;
  139.                     }
  140.                     /*EINT2中断：K3被按下*/
  141.                     case 2:
  142.                     {
  143.                                 uart_sendString("K3 ON!->LED3 ON!\n");
  144.                                 GPBDAT = (GPB5_OFF | GPB6_OFF | GPB7_OFF | GPB8_OFF);
  145.                                 GPBDAT = GPB7_ON; /*LED3亮*/
  146.                                 break;
  147.                     }
  148.                     /*EINT4~EINT7中断：虽然这里可以肯定是，EINT4，K2被按下,但是还是做一下判断：具体是EINT4到EINT7中的哪一个？*/
  149.                     case 4:
  150.                     {
  151.                                 GPBDAT = (GPB5_OFF | GPB6_OFF | GPB7_OFF | GPB8_OFF);
  152.                                 
  153.                                 /*EINTPEND:外部中断挂起寄存器
  154.                                 *EINTPEND低4位保留
  155.                                 *EINTPEND[4]=1 : 表示EINT4发生
  156.                                 *EINTPEND[5]=1 : 表示EINT5发生
  157.                                 */
  158.                                 eintval = EINTPEND;
  159.                                 if(eintval & (1<<4))
  160.                                 {
  161.                                         uart_sendString("K2 ON!->LED2 ON!\n");
  162.                                         GPBDAT = GPB6_ON; /*LED2亮*/
  163.                                 }
  164.                                 if(eintval & (1<<5))
  165.                                 {
  166.                                         
  167.                                 }
  168.                                 break;
  169.                     }
  170.                     /*看门狗INT_WDT_AC97中断: 将看门狗定时器做 普通定时器用，产生的中断*/
  171.                     case 9:
  172.                     {
  173.                          //看门狗中断时 内部中断 2级中断，所以必须清除 SUBSRCPND，当然 SRCPND INTPND也需要清除
  174.                                 SUBSRCPND |= (1<<13);
  175.                                 //SRCPND |= (1<<9); //程序后面有做，这里可以不在写了。
  176.                                 //INTPND |= (1<<9);
  177.                                 uart_sendString("\n watchdog interrupt!\n");
  178.                                 break;
  179.                     }
  180.                     case 31:
  181.                     {
  182.                                 //本程序只触摸使用中断。AD转换完毕不使用中断，使用查询方式。
  183.                                 //即2级中断只可能产生INT_TC，不可能产生INT_ADC_S。
  184.                                 subsrcval = SUBSRCPND;
  185.                                 if(subsrcval & (1<<9)) //INT_TC
  186.                                 {
  187.                                         /*
  188.                                         uart_sendString("\n*************************************\n");
  189.                                         uart_sendString("touchscreen INT_TC interrupt!\n");
  190.                                         */
  191.                                         
  192.                                         ADCDLY_save = ADCDLY; //也可以不保存
  193.                                         
  194.                                         //走到这里，说明有触摸屏被按下。此时：触摸屏的模式是等待中断模式。
  195.                                         ADCDLY = ADCDLYVALUE; //设置采样的延时值,多长时间采样一次。大概是13ms采样一次。
  196.                                         ADCTSC |= ((1<<3) | (1<<2)); //从等待中断模式，自动进入读取xy坐标模式
  197.                                         ADC_START(); //启动AD转换
  198.                                         
  199.                                         while(ADCCON & 0x1); //转换真正开始时，此位会被清0，清0之后继续向下走
  200.                                         
  201.                                         while((ADCCON & 0x8000) == 0); //0:正在转换 1：转换结束,变成1之后继续向下走
  202.                                         
  203.                                         //走到这里，说明触摸屏的xy轴坐标转换完毕。由上面2句代码可知 : AD转换完毕检测使用查询方式。
  204.                                         x_data = (ADCDAT0 & 0x3ff); //ADCDAT0[9:0]10位，是x轴坐标转换后的数据值
  205.                                         y_data = (ADCDAT1 & 0x3ff); //ADCDAT1[9:0]10位，是y轴坐标转换后的数据值
  206.                                         
  207.                                         ADCTSC = ADC_WAITINT_MODE; //这一句和一下句,一起作用，进入(等待触摸屏松开)中断模式。
  208.                                         ADCTSC |= (1<<8); //触点pen松开时，可以产生触摸屏松开中断了。
  209.                                         /*
  210.                                         uart_sendString("SUBSRCPND1=");
  211.                                         uart_sendByte_hex((unsigned long)(SUBSRCPND));
  212.                                         uart_sendByte('\n');
  213.                                         */
  214.                                         //下面清中断，是为了等待 触点pen松开 2级中断的发生.
  215.                                         SUBSRCPND = (1<<9);
  216.                                         /*
  217.                                         uart_sendString("SUBSRCPND2=");
  218.                                         uart_sendByte_hex((unsigned long)(SUBSRCPND));
  219.                                         uart_sendByte('\n');
  220.                                         */
  221.                                         //由于    此时SRCPND，INTPND并没有清除，所以最多只会是2级中断源发生后，被挂起，1级中断源不会发生，不会挂起，不会产生。
  222.                                         //while((SUBSRCPND & (1<<9)) != 1); //判断第9位是否是1，必须用下面的语句，这一句不行。
  223.                                         while(1)
  224.                                         {
  225.                                                 if(SUBSRCPND & (1<<9))
  226.                                                 {
  227.                                                         break; /*走到这里表示 : pen松开*/
  228.                                                 }
  229.                                         }
  230.                                         //注意：本程序从按下到松开，均只产生一次中断，无论按下多长时间，按下中断也只会产生一次。
  231.                                         /*
  232.                                         uart_sendString("SUBSRCPND3=");
  233.                                         uart_sendByte_hex((unsigned long)(SUBSRCPND));
  234.                                         uart_sendByte('\n');
  235.                                         */
  236.                                         //下面几行是触摸屏的校验算法。由于浮点数的问题，编译失败。怎么办？？？？
  237.                                         x_data = x_data * (0.272);
  238.                                         y_data = y_data * (0.480);
  239.                                         y_data = 480-y_data;
  240.                                         temp = y_data;
  241.                                         y_data = x_data;
  242.                                         x_data = temp;    
  243.                                         x_data = (x_data-20.0303)/0.8957;
  244.                                         y_data = (y_data-37.86667)/0.7486;
  245.                                         /*
  246.                                         uart_sendString("x_data=");
  247.                                         uart_sendByte_hex((unsigned long)(x_data));
  248.                                         uart_sendByte('\n');
  249.                                         
  250.                                         uart_sendString("y_data=");
  251.                                         uart_sendByte_hex((unsigned long)(y_data));
  252.                                         uart_sendByte('\n');
  253.                                         */
  254.                                         uart_printf("\n your press point in (%d, %d)\n", (unsigned long)x_data, (unsigned long)y_data);
  255.                                         
  256.                                         ADCDLY = ADCDLY_save;
  257.                                         ADCTSC = ADC_WAITINT_MODE;
  258.                                         ADCTSC &= (~(1<<8)); //再次进入 检测触点按下中断，可以产生触摸屏按下中断了。所以进入本中断函数的都是按下中断。
  259.                                         //触摸屏中断是 内部中断 2级中断，所以必须清除 SUBSRCPND，当然 SRCPND INTPND也需要清除
  260.                                         SUBSRCPND = (1<<9);
  261.                                         
  262.                                         //uart_sendString("*************************************\n");
  263.                                 }
  264.                                 break;
  265.                     }
  266.                     default:
  267.                     {
  268.                                 break;
  269.                     }
  270.             }
  271.             /*中断处理完成之后：必须清除所有的挂起寄存器
  272.             *注意：向挂起寄存器中写1，即可令此位为0；写入0是没有效果的，若写入0，挂起寄存器中的数据保持不变。
  273.             */
  274.             if(offset == 4) /*二级外部中断，还必须清除 EINTPEND*/
  275.             {
  276.                      EINTPEND = (1<<4);
  277.             }
  278.             SRCPND = (1<<offset);
  279.             /*
  280.             uart_sendString("SRCPND=");
  281.             uart_sendByte_hex(SRCPND);
  282.             uart_sendByte('\n');
  283.             */
  284.             
  285.             INTPND = (1<<offset);
  286.             /*
  287.             uart_sendString("INTPND=");
  288.             uart_sendByte_hex(SRCPND);
  289.             
  290.             */
  291.             /*在清除 SRCPND INTPND时，INTOFFSET会被自动清除*/
  292. }
interrupt.h文件

点击(此处)折叠或打开

  1. #ifndef _INTERRUPT_H_
  2. #define _INTERRUPT_H_

  4. /**************************************************************************/
  5. //中断相关寄存器
  6. #define EXTINT0 (*(volatile unsigned long *)0x56000088)
  7. #define EINTMASK (*(volatile unsigned long *)0x560000A4)
  8. #define EINTPEND (*(volatile unsigned long *)0x560000A8)

  10. #define SRCPND (*(volatile unsigned long *)0x4A000000)
  11. #define INTMOD (*(volatile unsigned long *)0x4A000004)
  12. #define INTMSK (*(volatile unsigned long *)0x4A000008)
  13. #define PRIORITY (*(volatile unsigned long *)0x4A00000C)
  14. #define INTPND (*(volatile unsigned long *)0x4A000010)
  15. #define INTOFFSET (*(volatile unsigned long *)0x4A000014)

  17. #define SUBSRCPND (*(volatile unsigned long *)0x4A000018)
  18. #define INTSUBMSK (*(volatile unsigned long *)0x4A00001C)

  20. #define BIT_ALLMSK        (0xffffffff)
  21. /**************************************************************************/


  24. /**************************************************************************/
  25. //按键相关的GPIO
  26. #define GPFCON (*(volatile unsigned long *)0x56000050)
  27. #define GPFDAT (*(volatile unsigned long *)0x56000054)
  28. #define GPFUP (*(volatile unsigned long *)0x56000058)
  29. /*注意：这个程序没有mmu，所以寄存器的地址是物理地址*/

  31. #define GPF0_EINT (2<<(0*2))
  32. #define GPF1_EINT (2<<(1*2))
  33. #define GPF2_EINT (2<<(2*2))
  34. #define GPF4_EINT (2<<(4*2))
  35. /**************************************************************************/


  38. /**************************************************************************/
  39. //LED相关的GPIO
  40. #define GPBDAT (*(volatile unsigned long *)0x56000014)
  41. #define GPBCON (*(volatile unsigned long *)0x56000010)
  42. #define GPBUP (*(volatile unsigned long *)0x56000018)
  43. /*注意：这个程序没有mmu，所以寄存器的地址是物理地址*/

  45. #define GPB5_OUT (1<<(5*2))
  46. #define GPB6_OUT (1<<(6*2))
  47. #define GPB7_OUT (1<<(7*2))
  48. #define GPB8_OUT (1<<(8*2))

  50. #define GPB5_ON (~(1<<5))
  51. #define GPB6_ON (~(1<<6))
  52. #define GPB7_ON (~(1<<7))
  53. #define GPB8_ON (~(1<<8))

  55. #define GPB5_OFF (1<<5)
  56. #define GPB6_OFF (1<<6)
  57. #define GPB7_OFF (1<<7)
  58. #define GPB8_OFF (1<<8)
  59. /**************************************************************************/


  62. #endif
main.c文件

点击(此处)折叠或打开

  1. #include "uart.h"
  2. #include "touchscreen.h"

  4. int main(void)
  5. {
  6.         //本程序触摸使用中断。AD转换完毕也使用中断，不使用查询方式。
  7.         //即2级中断产生INT_TC，也产生INT_ADC_S。？？？未完成
  8.         uart_sendString("\nTouchScreen Start: Please use touchpen touch srceen!\n");

  10.         init_touchscreen();

  12.         uart_sendString("press any key quit!\n");

  14.         uart_getch();

  16.         uart_sendString("end!\n");

  18.         return 0;
  19. }
makefile文件

点击(此处)折叠或打开

  1. objs := head.o init.o nand.o interrupt.o uart.o touchscreen.o main.o

  3. touchscreen.bin: $(objs)
  4.     arm-linux-ld -Ttouchscreen.lds -o touchscreen_elf $^ $(shell arm-linux-gcc -msoft-float -print-libgcc-file-name)
  5.     arm-linux-objcopy -O binary -S touchscreen_elf $@
  6.     arm-linux-objdump -D -m arm touchscreen_elf > touchscreen.dis

  8. %.o:%.c
  9.     arm-linux-gcc -Wall -msoft-float -O2 -c -o $@ $<

  11. %.o:%.S
  12.     arm-linux-gcc -Wall -O2 -c -o $@ $<

  14. clean:
  15.     rm -f touchscreen.bin touchscreen_elf touchscreen.dis *.o
nand.c文件

点击(此处)折叠或打开

  1. #include "nand.h"
  2. #include "def.h"

  4. /*
  5. *功能：重启
  6. */
  7. void nand_reset()
  8. {
  9.     /*每操作NandFlash之前必须先片选*/
  10.     NF_CE_L();
  11.     /*发送命令之前要先清除RB*/
  12.     NF_CLEAR_RB();
  13.     /*向NandFlash写命令:即发送复位命令*/
  14.     NF_CMD(CMD_RESET);
  15.     /*注意：命令执行期间，NandFlash存储器忙，所以一直要等待为1:不忙*/
  16.     NF_WAIT_RB();
  17.     /*关闭片选*/
  18.     NF_CE_H();
  19. }

  21. /*
  22. *功能：NANDFLASH初始化
  23. *注意：1,本程序使用的是ARM9 2440处理器，需要设置 NFCONF，NFCONT这2个寄存器
  24. * 2,NandFlash的芯片是K9F2G08U0A。由芯片手册可知：
  25. * 容量：（256M+8M）字节，后面的8M叫OOB空间，坏块管理会用到它。
  26. * 8bit
  27. * 2K个块，每个块有64个page页
  28. * 一个page页 =（2K+64）字节
  29. * 所以，一个块 = 64页 = 64*（2K+64）字节 =（128K+2K）字节
  30. * 一个Nand器件 = 2K个块 = 2K*64个page页 = 128K页
  31. * 一个Nand器件 = 128K页 = 128K*（2K+64）字节 = （256M+8M）字节
  32. * 3，片内内存+SDRAM+网卡+寄存器：是由CPU统一编址的，由CPU发出地址。
  33. * 但是NandFlash不是由CPU统一编址的，所以NandFlash的0地址和片内内存的0地址，不是一回事。
  34. * 4，NandFlash中的OOB不参与编址，读取NandFlash上的2049这个地址，不是读取的0页上的地址，是1页上的。
  35. * 5，NandFlash控制器的各个控制引脚的时序，不需要程序员来驱动这些引脚，
  36. * 程序员只需要设置相关寄存器之后，控制器会自动发出控制信号。
  37. */
  38. void nand_init()
  39. {
  40.     //char ret;
  41.     //char ch;
  42.     /*NANDFLASH配置寄存器 : NFCONF
  43.     [13:12]=01:时序图中CLE,ALE持续值设置,1个HCLK时钟周期，如HCLK是100Mhz，则，1个HCLK时钟周期=10ns。
  44.     [10:8]=011:时序图中TWRPH0持续值设置,3个HCLK时钟周期
  45.     [6:4]=100:时序图中TWRPH1持续值设置，0个HCLK时钟周期
  46.     */
  47.     rNFCONF = ((TACLS << 12) | (TWRPH0 << 8) | (TWRPH1 << 4));
  48.     /*NANDFLASH控制寄存器 : NFCONT
  49.     其他位基本都是初始值或者不需要设置
  50.     [1]=1:禁止片选，CE引脚输出为1
  51.     [0]=1:MODE位，使能NandFlash控制器，命令使能CLE引脚设置为1
  52.     */
  53.     rNFCONT = (1<<4)|(1<<1)|(1<<0);
  54.     nand_reset();
  55.     
  56.     return ;
  57. }


  60. /*功能：读取芯片的ID号
  61. *注意：查看NandFlash的相关配置是否正确，可以去检查芯片的ID号。如果ID读取正确了，则说明配置正确了。
  62. *第1个周期：厂商编号 : 0xEC
  63. *第2个周期：设备编号:相同型号的芯片，有相同的ID号 : 0xDA,这个必须正确
  64. *第3个周期：内部芯片编号 : 0x10
  65. *第4个周期：页的大小 : 0x95
  66. *第5个周期：一个page另外带的融错空间的大小 : 0x44
  67. */
  68. char nand_readId()
  69. {
  70.     int i;
  71.     U8 cyc1;
  72.     U8 cyc2;
  73.     U8 cyc3;
  74.     U8 cyc4;
  75.     U8 cyc5;
  76.     //片选
  77.     NF_CE_L();
  78.     //清除RB
  79.     NF_CLEAR_RB();
  80.     //发送读ID命令
  81.     NF_CMD(CMD_READID);
  82.     //发送地址值：需要读取这个地址上的值,读ID号，规定就是这个地址，看的时序图，只需发送一个地址.
  83.     NF_ADDR(0x0);
  84.     for(i=0; i<1000; i++);
  85.     //从nandflash中读取数据:读5次，看时序图
  86.     //注意：每次只能读取8位数据，保存在数据寄存器中。
  87.     cyc1 = NF_RDDATA8();
  88.     for(i=0; i<100; i++);
  89.     cyc2 = NF_RDDATA8();
  90.     for(i=0; i<100; i++);
  91.     cyc3 = NF_RDDATA8();
  92.     for(i=0; i<100; i++);
  93.     cyc4 = NF_RDDATA8();
  94.     for(i=0; i<100; i++);
  95.     cyc5 = NF_RDDATA8();
  96.     for(i=0; i<100; i++);
  97.     
  98.     //等待命令执行完毕
  99.     NF_WAIT_RB();
  100.     //关闭片选
  101.     NF_CE_H();
  102.     
  103.     return cyc2;
  104. }


  107. /*功能 : 发出地址
  108. *注意： 这个地址，不是页编号，是具体的读取NandFlash的起始地址,包括页内地址
  109. */
  110. void write_addr(unsigned int addr)
  111. {
  112.         //写地址(要读取数据的起始地址) :
  113.         //包括 : 列(页内)地址,是低位地址，共A0~A11，在具体的page页内寻址。一个page页=（2K+64）字节
  114.         // 行(页)地址,是高位地址，共A12~A28，可以寻址到page页。一个Nand器件=2K*64个page页 = 128K页
  115.         // 高位地址中，A12~A17，可以寻址到block块下面的page页。一个block块=64个page页
  116.         // 高位地址中，A18~A28，可以寻址到block块。一个Nand器件=2K个block块
  117.         //要写全部的5个周期的地址
  118.     
  119.         //32位的page_number : 低29位有效 :
  120.         //| 28| 27| 26| 25| 24| 23| 22| 21| 20| 19| 18| 17| 16| 15| 14| 13| 12| 11| 10| 9 | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  121.      // 对应最后3个地址周期的页内地址的高11位 :
  122.         //|A28|A27|A26|A25|A24|A23|A22|A21|A20|A19|A18|A17|A16|A15|A14|A13|A12|A11|A10|A09|A08|A07|A06|A05|A04|A03|A02|A01|A00|
  123.         //29位在5个地址周期中应是如下的分布 :
  124.         //| I7 | I6 | I5 | I4 | I3 | I2 | I1 | I0 |
  125.         //| L | L | L | L | L | L | L | A28 |
  126.         //| A27 | A26 | A25 | A24 | A23 | A22 | A21 | A20 |
  127.         //| A19 | A18 | A17 | A16 | A15 | A14 | A13 | A12 |
  128.         //| L | L | L | L | A11 | A10 | A9 | A8 |
  129.         //| A7 | A6 | A5 | A4 | A3 | A2 | A1 | A0 |
  130.     
  131.     int i;
  132.     int col, page;

  134.         col = addr & (2048 -1); //截取低位：取2048的原因：本程序使用的nand芯片的一个page页是2048字节
  135.         page = addr / 2048; //截取高位
  136.     
  137.     NF_ADDR(col & 0xFF); //列(页内)地址 A0~A7
  138.     for(i=0; i<100; i++);
  139.         NF_ADDR((col >> 8) & 0x0F);     //列(页内)地址 A8~A11
  140.         for(i=0; i<100; i++);
  141.         
  142.         NF_ADDR(page & 0xFF); //行(页)地址 A12~A19
  143.         for(i=0; i<100; i++);
  144.         NF_ADDR((page >> 8) & 0xFF); //行(页)地址 A20~A27
  145.         for(i=0; i<100; i++);
  146.         NF_ADDR((page >> 16) & 0x03); //行(页)地址 A28~A29
  147.         for(i=0; i<100; i++);
  148. }

  150. /*
  151. *功能 : 从NandFlash位置start_addr开始读取数据，将数据复制到指定的SDRAM地址buf处，共复制size个字节。
  152. * 数据方向:（Nand的start_addr->SDRAM的buf）
  153. *参数 : buf : SDRAM的缓冲区起始地址：0x30001000
  154. * start_addr : 不是页编号，也就是说，不是每一个page页的开始地址处理，
  155. * 是具体的读取NandFlash的起始地址,包括页内地址：0x1003=4099
  156. * size ： 复制的字节数，可以是页空间整数倍，也可以不是，也就是说，size可以小于2K,也可以大于2K。0x810，0x800=2048
  157. *注意 ： read是相对于cpu说的，cpu读取nand中的程序代码，拷贝到SDRAM中去执行。
  158. */
  159. void nand_read(unsigned char *buf, unsigned long start_addr, int size)
  160. {
  161.         U32 i = 0, j = 0;
  162.         //片选
  163.         NF_CE_L();
  164.         
  165.         for(i=start_addr; i < (start_addr + size);)
  166.         {
  167.                 //清除RB
  168.                 NF_CLEAR_RB();
  169.                 //读NandFlash时的第1个命令
  170.               //0x00命令发出后，即相当于向NFCMD寄存器中写入了0，nandflash控制器会自动发出各种控制信号，
  171.                 //会自动满足时序图的要求，不再需要人工参与了。
  172.                 //这样，nandflash控制器提供的几个寄存器，就简化了对nandflash的操作。
  173.                 NF_CMD(CMD_READ1);
  174.                 //写地址
  175.                 write_addr(i);
  176.                 //读NandFlash时的第2个命令
  177.                 NF_CMD(CMD_READ2);
  178.                 //等待NandFlash不忙
  179.                 NF_WAIT_RB();
  180.                 
  181.                 //读数据 : 一般1次读1页的数据(1页=2K + 64字节)，可能跨了2页才能读取一页的数据。
  182.                 //也可以只读一个page页的一部分数据，只是多了几次下面的循环。
  183.                 for(j=0; j<2048; j++, i++) //小于2048也行
  184.                 {
  185.                     //1次从nandflash的8位IO口上读取8位数据。
  186.                     //注意：每次读此寄存器，即执行一次下面语句，就会启动对nandflash的1次读操作。
  187.                     //前一次读操作未完成，是不会启动下一次读操作的。
  188.                     *buf = NF_RDDATA8();
  189.                     buf++;
  190.                 }
  191.         }
  192.         //关闭片选
  193.         NF_CE_H();
  194.         
  195. }

  197. int CopyCode2SDRAM(unsigned char *buf, unsigned long start_addr, int size)
  198. {
  199.     nand_read(buf, start_addr, size);
  200.     return 0;
  201. }


  204. /*
  205. *功能 : 擦除指定的块
  206. *参数 : block_number : 块号
  207. *注意 : 1,一个NandFlash块有2K个块。
  208. * 2，块被擦除后nand对应的块中的数据全部是1
  209. * 3,命令字分为2个阶段
  210. U8 nand_erase(U32 block_number)
  211. {
  212.         int i;
  213.         U8 stat;
  214.         //片选
  215.         NF_CE_L();
  216.         //清除RB
  217.         NF_CLEAR_RB();
  218.         //写入第1个擦除命令
  219.         NF_CMD(CMD_ERASE1);
  220.         //写块的地址 : 注意 : 只写块的地址就行，块地址都在行(页)地址的高位上，
  221.         //所以不需要写前面2个周期的列(页内)地址，写后面3个周期的页地址的高11位就行。
  222.         //列地址 : 就是页内地址, 共12位
  223.         //行地址 : 就是页地址, 共17位 : 高11位(A28-A18)是2K的块地址，低6位是64的页地址。
  224.         
  225.         //32位block_number：低11位有效 :
  226.      // | 10 | 9 | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  227.      // 对应最后3个地址周期的页内地址的高11位 :
  228.         //| A28 | A27 | A26 | A25 | A24 | A23 | A22 | A21 | A20 | A19 | A18 |
  229.         //高11位在后面3个地址周期中应是如下的分布 :
  230.         //| I7 | I6 | I5 | I4 | I3 | I2 | I1 | I0 |
  231.         //| | | | | | | | A28 |
  232.         //| A27 | A26 | A25 | A24 | A23 | A22 | A21 | A20 |
  233.         //| A19 | A18 | | | | | | |
  234.         //
  235.         NF_ADDR((block_number << 6) & 0xFF);
  236.         NF_ADDR((block_number >> 2) & 0xFF);
  237.         NF_ADDR((block_number >> 10) & 0xFF);
  238.         //写入第2个擦除命令
  239.         NF_CMD(CMD_ERASE2);
  240.         
  241.         for(i=0; i<1000; i++);
  242.         //写入读状态寄存器的命令
  243.         NF_CMD(CMD_STATUS);
  244.         do
  245.         {
  246.          //读取8位状态数据
  247.                 stat = NF_RDDATA8();
  248.         }
  249.         while(!(stat & 0x40)); //等到第6位为1 : 表示读取数据完成。第0位为0，表示擦除成功
  250.         //关闭片选
  251.         NF_CE_H();
  252.         
  253.         //约定用0x66来表示擦除成功，或者写成功
  254.         return 0x66;
  255. }
  256. */


  259. /*功能 : 将buf处开始的数据，写入NandFlash的start_addr地址处，共写入size个字节。
  260. * 数据方向:（SDRAM的buf->Nand的start_addr）
  261. *参数 : buf : SDRAM的缓冲区起始地址
  262. * start_addr : 不是页编号，也就是说，不是每一个page页的开始地址处理，
  263. * 是具体的读取NandFlash的起始地址,包括页内地址：0x1003=4099
  264. * size ： 复制的字节数，可以是页空间整数倍，也可以不是，也就是说，size可以小于2K,也可以大于2K。0x810，0x800=2048
  265. *注意 ： write是相对于cpu说的，cpu写数据到nand中，SDRAM中的数据拷贝到Nand中。
  266. U8 nand_write(unsigned char *buf, unsigned long start_addr, int size)
  267. {
  268.         int i,j;
  269.         U8 stat;
  270.         //片选
  271.         NF_CE_L();
  272.         
  273.         for(i=start_addr; i < (start_addr + size);)
  274.         {
  275.                 //清除RB
  276.                 NF_CLEAR_RB();
  277.                 //写NandFlash时的第1个命令 : NandFlash写准备
  278.                 NF_CMD(CMD_WRITE1);
  279.                 //写地址
  280.                 write_addr(i);
  281.                 //写数据 : 一般1次写1页的数据 : 1页=2K字节+64字节,可能跨了2页才能写一页的数据。
  282.                 //也可以只写一个page页的一部分数据，只是多了几次下面的循环。
  283.                 for(j=0; j<2048; j++, i++)
  284.                 {
  285.                  //1次写8位的数据给NandFlash的8位IO口
  286.                  //注意：每次写这个寄存器，即执行一次下面的语句，都会启动一次nandflash的写数据操作，
  287.                  //前一次写数据操作不完成，是不会启动下一次写数据操作的
  288.                         NF_WRDATA8(*buf);
  289.                         buf++;
  290.                 }
  291.                 
  292.                 //写NandFlash时的第2个命令 : 启动写操作
  293.                 //此时，Flash内部会自动完成写，校验操作。
  294.                 NF_CMD(CMD_WRITE2);
  295.                 for(j=0; j<100; j++);
  296.                 //写入读状态寄存器的命令 : 用来判断当前写操作是否完成，是否成功
  297.                 NF_CMD(CMD_STATUS);
  298.                 do
  299.                 {
  300.                  //读取8位状态数据
  301.                         stat = NF_RDDATA8();
  302.                 }
  303.                 while(!(stat & 0x40)); //等到第6位为1 : 表示写数据完成。第0位为0，表示写数据成功
  304.         }
  305.         //关闭片选
  306.         NF_CE_H();
  307.         
  308.         return 0x66;
  309. }
  310. */
nand.h文件

点击(此处)折叠或打开

  1. #ifndef _NAND_H_
  2. #define _NAND_H_

  4. /*NANDFLASH配置寄存器 : NFCONF：用来设置时序参数宽度，数据位宽*/
  5. #define rNFCONF (*(volatile unsigned long *)0x4E000000)
  6. /*NANDFLASH控制寄存器 : NFCONT：用来禁止/使能nandflash控制器，使能/禁止片选信号*/
  7. #define rNFCONT (*(volatile unsigned long *)0x4E000004)
  8. /*NANDFLASH命令集寄存器 : NFCMMD：用来向nandflash发出命令信号*/
  9. #define rNFCMMD (*(volatile unsigned long *)0x4E000008)
  10. /*NANDFLASH地址集寄存器 : NFADDR：用来向nandflash发出地址信号*/
  11. #define rNFADDR (*(volatile unsigned long *)0x4E00000C)
  12. /*NANDFLASH数据寄存器 : NFDATA,32位=0x4E000010+0x4E000011+0x4E000012+0x4E000013*/
  13. #define rNFDATA (*(volatile unsigned long *)0x4E000010)
  14. /*截取NANDFLASH数据寄存器的8位 : 仅0x4E000010，实际上每次读写也只用到低8位，不可能用到32位。
  15. 每次读写此寄存器，就将启动一次对nandflash的读数据写数据的操作。*/
  16. #define rNFDATA8 (*(volatile unsigned char *)0x4E000010)
  17. /*NANDFLASH运行状态寄存器 : NFSTAT：只用了最低位，0：busy，1：ready*/
  18. #define rNFSTAT (*(volatile unsigned long *)0x4E000020)

  20. /*相关命令如下 : */
  21. /*读NandFlash页时的命令1*/
  22. #define CMD_READ1 0x00
  23. /*读NandFlash页时的命令2*/
  24. #define CMD_READ2 0x30

  26. /*页编程 : 写NandFlash页时的命令1*/
  27. #define CMD_WRITE1 0x80
  28. /*页编程 : 写NandFlash页时的命令2*/
  29. #define CMD_WRITE2 0x10

  31. /*擦除NandFlash块的命令1*/
  32. #define CMD_ERASE1 0x60
  33. /*擦除NandFlash块的命令2*/
  34. #define CMD_ERASE2 0xD0

  36. /*读状态寄存器的命令*/
  37. #define CMD_STATUS 0x70
  38. /*读取芯片ID的命令*/
  39. #define CMD_READID 0x90
  40. /*重启命令*/
  41. #define CMD_RESET 0xFF

  43. #define NF_CE_L() {(rNFCONT) &= (~(1<<1));}
  44. /*禁止nandfalsh : 控制寄存器NFCONT[1]=1*/
  45. #define NF_CE_H() {(rNFCONT) |= (1<<1);}

  47. /*向存储器发出命令 : 命令寄存器NFCMMD[7:0]*/
  48. #define NF_CMD(data) {(rNFCMMD) = (data);}
  49. /*向存储器发出地址值 : 地址寄存器NFADDR[7:0]*/
  50. #define NF_ADDR(data) {(rNFADDR) = (data);}

  52. /*等待NandFlash准备就绪(即不忙) : 一直等到状态寄存器NFSTAT[0]=1,循环才退出*/
  53. #define NF_WAIT_RB() {while(!((rNFSTAT) & (1<<0)));}
  54. /*清除RB:即检测RB传输*/
  55. #define NF_CLEAR_RB() {(rNFSTAT) |= (1<<2);}
  56. /*等待检测RnB : 一直等到状态寄存器NFSTAT[2]=1,循环才退出*/
  57. #define NF_DETECT_RB {while(!((rNDSTA) & (1<<2)));}

  59. /*从NANDFLASH的IO口中读数据(32位) : 数据寄存器NFDATA*/
  60. #define NF_RDDATA() (rNFDATA)
  61. /*从NANDFLASH的IO口中读数据(8位) : 数据寄存器NFDATA*/
  62. #define NF_RDDATA8() (rNFDATA8)
  63. /*向NANDFLASH的IO口中写数据(32位) : 数据寄存器NFDATA*/
  64. #define NF_WRDATA(data) {(rNFDATA) = (data);}
  65. /*向NANDFLASH的IO口中写数据(8位) : 数据寄存器NFDATA*/
  66. #define NF_WRDATA8(data) {(rNFDATA8) = (data);}

  68. /*时序信号参数的宽度*/
  69. #define TACLS 1
  70. #define TWRPH0 3
  71. #define TWRPH1 0

  73. void nand_reset();
  74. void nand_init();
  75. char nand_readId();
  76. void write_addr(unsigned int addr);
  77. void nand_read(unsigned char *buf, unsigned long start_addr, int size);
  78. int CopyCode2SDRAM(unsigned char *buf, unsigned long start_addr, int size);
  79. //U8 nand_erase(U32 block_number);
  80. //U8 nand_write(unsigned char *buf, unsigned long start_addr, int size);

  82. #endif
touchscreen.c文件

点击(此处)折叠或打开

  1. #include "touchscreen.h"
  2. #include "uart.h"
  3. #include "interrupt.h"

  5. /*
  6. *功能：触摸屏转换的初始化
  7. */
  8. void init_touchscreen()
  9. {
  10.         uart_sendString("init_touchscreen!\n");
  11.      //当PCLK为50M，ADC转换频率为2M时，算得预分频系数是24
  12.         unsigned int prscen = PCLK/ADC_FREQ -1;

  14.         ADCCON &= (~(0xFF << 6)); //这里8位必须清0
  15.         ADCCON &= (~(1 << 2));
  16.         //上面2句也可以合并成如下一句：
  17.         //ADCCON = 0x0; //全部清0，因为已经在前面保存了这个寄存器原来的值，所以这里可以全清0。
  18.         
  19.         ADCCON |= ((1 << 14) | ((prscen & 0xff) << 6));
  20.         ADCCON &= (~(1 << 1));
  21.         ADC_DISABLE(); //初始化时，并不启动AD转换
  22.         
  23.         //这里触摸屏的AD转换，所以有很多中断相关的位要设置
  24.         //2级源挂起寄存器：第9位是表示触屏中断发生，第10位是表示xy坐标转换完毕。
  25.         SUBSRCPND |= (1<<9);
  26.         //SUBSRCPND |= (1<<10); //本程序触摸使用中断，AD转换完毕不使用中断，使用查询
  27.         
  28.         //源挂起寄存器：第31位是表示触摸屏的2个中断发生
  29.         SRCPND |= (1<<31);
  30.         INTPND |= (1<<31);
  31.         
  32.         //2级中断屏蔽寄存器：：第9位是表示触屏中断发生，第10位是表示xy坐标转换完毕。
  33.         INTSUBMSK &= ~(1<<9);
  34.         //INTSUBMSK &= ~(1<<10); //本程序触摸使用中断，AD转换完毕不使用中断，使用查询
  35.         
  36.         //1级中断屏蔽寄存器：第31位是表示触摸屏的2个中断发生
  37.         INTMSK &= ~(1<<31);

  39.         /*ADCTSC寄存器
  40.         *[8]=0 0：检测触点按下中断 1：检测触点松开中断
  41.         *[7]=1 0：开关s4断开 1：开关s4闭合
  42.         *[6]=1 0：开关s2闭合 1：开关s2断开
  43.         *[5]=0 0：开关s3断开 1：开关s3闭合
  44.         *[4]=1 0：开关s1闭合 1：开关s1断开
  45.         *[3]=0 0：开关s5闭合 1：开关s5断开
  46.         *[2]=0 0：普通转换模式 1：自动连续xy轴坐标转换模式
  47.         *[1:0]=11 (00)：无操作模式 (01)：测量x轴坐标 (10):测量y轴坐标 (11):等待中断模式
  48.         */
  49.         ADCTSC = ADC_WAITINT_MODE; //表示进入到等待中断模式0xd3。
  50.         ADCTSC &= ~(1<<8); //触点按下时，这可以产生触摸屏按下中断了。
  51. }
touchscreen.h文件

点击(此处)折叠或打开

  1. #ifndef __TOUCHSCREE_H__
  2. #define __TOUCHSCREE_H__

  4. /*模数转换相关寄存器*/
  5. #define    ADCCON        (*(volatile unsigned long *)0x58000000)
  6. #define    ADCTSC        (*(volatile unsigned long *)0x58000004)
  7. #define    ADCDLY        (*(volatile unsigned long *)0x58000008)
  8. #define    ADCDAT0        (*(volatile unsigned long *)0x5800000C)
  9. #define    ADCDAT1        (*(volatile unsigned long *)0x58000010)
  10. #define    ADCUPDN        (*(volatile unsigned long *)0x58000014)

  12. //禁止AD转换
  13. #define ADC_DISABLE() ((ADCCON) & (~(1<<0)))
  14. //启动AD转换
  15. #define ADC_START() ((ADCCON) |= (0x1))

  17. //ADC转换频率最大为2M
  18. #define ADC_FREQ (2000000)
  19. #define ADCDLYVALUE 50000

  21. #define ADC_CHANAL_AIN0 0
  22. #define ADC_CHANAL_AIN1 1
  23. #define ADC_CHANAL_AIN2 2
  24. #define ADC_CHANAL_AIN3 3
  25. #define ADC_CHANAL_YM 4
  26. #define ADC_CHANAL_YP 5
  27. #define ADC_CHANAL_XM 6
  28. #define ADC_CHANAL_XP 7

  30. #define ADC_WAITINT_MODE (0xd3) //进入等待中断模式时，ADCTSC寄存器的值

  32. void init_touchscreen();

  34. #endif

touchscreen.lds文件

点击(此处)折叠或打开

  1. SECTIONS {
  2.     . = 0x00000000;
  3.     .init : AT(0){ head.o init.o nand.o}
  4.     . = 0x30000000;
  5.     .text : AT(4096) { *(.text) }
  6.     .rodata ALIGN(4) : AT((LOADADDR(.text)+SIZEOF(.text)+3)&~(0x03)) {*(.rodata*)}
  7.     .data ALIGN(4) : AT((LOADADDR(.rodata)+SIZEOF(.rodata)+3)&~(0x03)) { *(.data) }
  8.     __bss_start = .;
  9.     .bss ALIGN(4) : { *(.bss) *(COMMON) }
  10.     __bss_end = .;
  11. }
uart.c文件

点击(此处)折叠或打开

  1. #include "uart.h"

  3. /***********************************************************************************/
  4. //串口相关函数
  5. /*功能：初始化串口UART0
  6. *轮询方式来使用串口
  7. */
  8. void init_uart(void)
  9. {
  10.      /*GPHCON寄存器
  11.     [7:6]=10,GPH2作为TXD0,串口发送数据引脚
  12.     [5:4]=10,GPH3作为RXD0,串口接受数据引脚
  13.     GPH2，GPH3控制串口通道0
  14.     GPH4，GPH5控制串口通道1
  15.     GPH6，GPH7控制串口通道2
  16.     */
  17.         rGPHCON = ((2<<6)|(2<<4)|(0<<2)|(0<<0));
  18.         rGPHUP = ((1<<3)|(1<<2)); /*禁止上拉*/
  19.         
  20.         /*ULCON0串口线路控制寄存器:设置传输格式
  21.         [6]=0，普通模式，非红外工作模式
  22.         [5:3]=000，无奇偶校验位，100=奇校验，101=偶校验，110=固定校验位为1，111=固定校验位为0
  23.         [2]=0，每帧1个停止位，1：每帧2个停止位
  24.         [1:0]=11，8位，每帧发送或接受的数据位的个数。00=5位，01=6位，10=7位
  25.         */
  26.         rULCON0 = 0x3;
  27.         
  28.         /*UCON0:串口控制寄存器：用于选择UART时钟源，设置UART中断方式
  29.         [15:12]: 当[11:10]选择PCLK时，这4位无效。选择FCLK/n时，表示n值。
  30.         [11:10]=00: 选择PCLK给UART比特率，10：PCLK, 01：UEXTCLK, 11:FCLK/n。
  31.         [9]=1: 中断请求类型
  32.         [8]=0: 中断请求类型
  33.         [7]=0: 禁止超时中断，1：使能超时中断
  34.         [6]=1: 产生接受错误状态中断，1：不产生接受错误状态中断
  35.         [5]=0: 正常操作，非回环模式。发送引脚发送的数据，直接到达接受引脚，一般是测试用。
  36.         [4]=0: 正常操作，不发送断电信号
  37.         [3:2]=01: 发送模式，中断或者轮询,如果中断寄存器不设置，就是轮询。
  38.         [1:0]=01: 接受模式，中断或者轮询
  39.         */
  40.         rUCON0 = 0x5;
  41.         
  42.         /*UFCON:串口FIFO控制寄存器：用于设置是否使用FIFO,设置各FIFO的触发阀值。
  43.         [7:6]=发送FIFO的触发深度，即在发送时，发送FIFO中还剩有多少个数据时，才触发中断，告诉CPU可以继续发送了。
  44.         [5:4]=接受FIFO的触发深度，即在接受时，接受FIFO中接受了多少个数据后，才触发中断，告诉CPU已经有接受到的数据了。
  45.         [3]=空
  46.         [2]=TX的FIFO是否复位
  47.         [1]=RX的FIFO是否复位
  48.         [0]=0,不使用FIFO，非FIFO模式，相当于接受和发送时，不使用缓冲寄存器,上面的设置无效。如果这里是1，则上面的位肯定有对应的设置。
  49.         */
  50.         rUFCON0 = 0x0;
  51.         
  52.         /*UMCON:串口MODEM控制寄存器：用于流量控制
  53.         [7:5]=000,规定必须为0
  54.         [4]=0:禁止自动流控制(AFC)，即不使用流控。一般不使用这种硬件自动流控制手段。
  55.         [3:1]=000:规定必须为0
  56.         [0]=0:高电平(撤销nRTS),1:低电平(激活nRTS),因为,AFC位禁止,nRTS必须由软件控制。如果AFC使能，则忽略这个位。
  57.         */
  58.         rUMCON0 = 0x0;
  59.         
  60.         /*UBRDIV:波特率分频寄存器：用于设置波特率
  61.         [15:0],波特率分频值。使用UEXTCLK作为输入时钟时，可以设置UBRDIV为0.
  62.         UBRDIV = (int)(UART时钟/(波特率*16))-1
  63.         */
  64.         rUBRDIV0 = UART_BRD;
  65. }

  67. /*功能：向串口发送一个字符
  68. *参数：待发送的字符

  70. UTRSTAT0:用来表明数据是否已经发送完毕，是否已经接受到数据
  71. 串口收发TX/RX状态寄存器，是CPU自动更新的，程序员检测它的状态就行。
  72. [2]:发送移位寄存器空标志。
  73. 检测为0：表示发送移位寄存器非空，或发送缓冲寄存器非空。
  74. 检测为1：表示发送移位寄存器为空，且发送缓冲寄存器为空，程序员可以继续发送数据了。
  75. [1]:发送缓冲区空标志位。
  76. 检测为0：表示发送缓冲寄存器非空，即上次要发送的数据还没有发完。不能太快，否则会覆盖掉。
  77. 检测为1：表示发送缓冲寄存器为空，程序员可以继续发送数据了。(非FIFO模式，非请求中断，非DMA)
  78. 注意：如果UART使用FIFO，用户应该使用UFSTAT寄存器中的Rx FIFO计数位 和 Rx FIFO满位取代对此位的检查。
  79. [0]:接收缓冲器数据就绪标志位。
  80. 检测为0：表示接收缓冲器为空。
  81. 检测为1：表示接收缓冲器接收到有效数据，程序员可以取数据了。(非FIFO模式，非请求中断，非DMA)
  82. 注意：如果UART使用FIFO，用户应该使用UFSTAT寄存器中的Rx FIFO计数位 和 Rx FIFO满位取代对此位的检查。

  84. UTXH0：串口发送缓冲寄存器
  85. [7:0]:串口要发送的数据
  86. */
  87. void uart_sendByte(int data)
  88. {
  89.     if(data == '\n')
  90.     {
  91.         while(!(rUTRSTAT0 &0x2));
  92.         WrUTXH0('\r'); /*回车不换行*/
  93.     }
  94.     /*等待，直到发送缓冲区中的数据已经全部发送出去
  95.     这里也可以检测UTRSTAT0[2]位*/
  96.     while(!(rUTRSTAT0 &0x2));
  97.     /*向UTXH0寄存器中写入数据，UART即自动将它发送出去
  98.     #define rUTXH0 (*(volatile unsigned char *)0x50000020)    //UART 0 Transmission Hold
  99.     #define WrUTXH0(ch) (*(volatile unsigned char *)0x50000020)=(unsigned char)(ch)
  100.     所以：WrUTXH0(data); 相当于 rUTXH0 = data；
  101.     */
  102.     WrUTXH0(data);
  103. }

  105. /*功能：向串口打印一个字符串
  106. *参数：待打印的字符串
  107. */
  108. void uart_sendString(char *p)
  109. {
  110.     while(*p)
  111.         uart_sendByte(*p++);
  112. }

  114. /*功能：向串口打印一个字符的16进制格式
  115. *参数：待打印的字符
  116. * 数字0=0x30，数字9=0x39
  117. */
  118. void uart_sendByte_hex(unsigned long val)
  119. {
  120.     // val = 0x1234ABCD
  121.     unsigned long c;
  122.     int i = 0;
  123.     
  124.     uart_sendByte('0');
  125.     uart_sendByte('x');

  127.     for (i = 0; i < 8; i++)
  128.     {
  129.         c = (val >> ((7-i)*4)) & 0xf;
  130.         if((c >= 0) && (c <= 9))
  131.         {
  132.             c = '0' + c;
  133.         }
  134.         else if ((c >= 0xA) && (c <= 0xF))
  135.         {
  136.             c = 'A' + (c - 0xA);
  137.         }
  138.         uart_sendByte((int)c);
  139.     }
  140. }

  142. /*功能：从串口接受一个字符
  143. *返回值：接受到的字符

  145. UTRSTAT0: 串口收发TX/RX状态寄存器
  146. [0]:接收缓冲器数据就绪标志位。
  147. 0：接收缓冲器为空
  148. 1：接收缓冲器接收到有效数据(非FIFO模式，非请求中断，非DMA)
  149. 注意：如果UART使用FIFO，用户应该使用UFSTAT寄存器中的Rx FIFO计数位 和 Rx FIFO满位取代对此位的检查。

  151. URXH0：串口接受缓冲寄存器
  152. [7:0]:串口接受到的数据
  153. */
  154. char uart_getch(void)
  155. {
  156.     /*等待，直到接受缓冲区中有数据*/
  157.     while(!(rUTRSTAT0 & 0x1));
  158.     /*直接读取URXH0寄存器，即可以获得接受到的数据
  159.     #define rURXH0 (*(volatile unsigned char *)0x50000024)    //UART 0 Receive buffer
  160.     #define RdURXH0() (*(volatile unsigned char *)0x50000024)
  161.     所以：return RdURXH0(); 相当于：return rURXH0；
  162.     */
  163.     return RdURXH0();
  164. }

  166. /*功能：从串口接受一个字符串
  167. *参数：输入的字符串
  168. */
  169. void uart_getString(char *string)
  170. {
  171.     char *string2 = string;
  172.     char c;
  173.     while((c=uart_getch()) != '\r')
  174.     {
  175.         if(c == '\b')
  176.         {
  177.             if((int)string2 < (int)string)
  178.             {
  179.                 //uart_printf("\b\b");
  180.                 string--;
  181.             }
  182.         }
  183.         else
  184.         {
  185.             *string++ = c;
  186.             uart_sendByte(c);
  187.         }
  188.     }
  189.     *string = '\0';
  190.     uart_sendByte('\n');
  191. }

  193. /***********************************************************************************/
  194. /*
  195. *功能：整型(int) 转化成 字符型(char)
  196. *注意：不用 % / 符号的话，只能正确打印:0...9的数字对应的字符'0'...'9'
  197. */
  198. void itoa(unsigned int n, char * buf)
  199. {
  200.     int i;

  202.     if(n < 10){
  203.         buf[0] = n + '0';
  204.         buf[1] = '\0';
  205.         return;
  206.     }
  207.     itoa(n / 10, buf);
  208.     
  209.     for(i=0; buf[i]!='\0'; i++);
  210.     
  211.     buf[i] = (n % 10) + '0';
  212.     
  213.     buf[i+1] = '\0';
  214. }

  216. /*
  217. *功能：16进制字(0x) 转化成 字符型(char)
  218. *注意：不用 % / 符号的话，只能正确打印，0...9..15的数字,对应的'0'...'9''A'...'F'
  219. *注意：由于编译问题，这个函数，暂时由uart_sendByte_hex()函数替代
  220. */
  221. void xtoa(unsigned int n, char * buf)
  222. {
  223.     int i;

  225.     if(n < 16)
  226.     {
  227.         if(n < 10)
  228.         {
  229.             buf[0] = n + '0';
  230.         }
  231.         else
  232.         {
  233.             buf[0] = n - 10 + 'a';
  234.         }
  235.         buf[1] = '\0';
  236.         return;
  237.     }
  238.     xtoa(n / 16, buf);
  239.     
  240.     for(i = 0; buf[i] != '\0'; i++);
  241.     
  242.     if((n % 16) < 10)
  243.     {
  244.         buf[i] = (n % 16) + '0';
  245.     }
  246.     else
  247.     {
  248.         buf[i] = (n % 16) - 10 + 'a';
  249.     }
  250.     buf[i + 1] = '\0';
  251. }

  253. /*******************************************************************************************
  254. 为了支持求余求模，需要:
  255. 1,修改makefile如下：增加libgcc的库
  256.     arm-linux-ld -Tuart.lds -o uart_elf $^ $(shell arm-linux-gcc -msoft-float -print-libgcc-file-name)
  257. 上面一句展开后，其实就是下面的一句：
  258. ##    arm-linux-ld -Tuart.lds -o uart_elf head.o init.o uart.o leds.o /home/wangxc/linux/toolchain/gcc-3.4.5-glibc-2.3.6/bin/../lib/gcc/arm-linux/3.4.5/libgcc.a
  259. 2,自己手写libgcc的库。
  260. 这个在uart3实现
  261. *******************************************************************************************/

  263. /*功能：向串口格式化打印一个字符串
  264. *参数：格式化的字符串
  265. *注意：由于求模求余的问题没有解决，所以这里%d输出时，只能输出0~9，10和10以上的不能输出
  266. */
  267. int uart_printf(const char *fmt, ...)
  268. {
  269.     int count = 0;
  270.     char c;
  271.     char *s;
  272.     int n;
  273.     char buf[65];
  274.     va_list ap;
  275.     
  276.     va_start(ap, fmt);
  277.     
  278.     while(*fmt != '\0')
  279.     {
  280.         if(*fmt == '%')
  281.         {
  282.             fmt++;
  283.             switch(*fmt)
  284.          {
  285.                 case 'd': /*整型*/
  286.                     n = va_arg(ap, int);
  287.                     if(n < 0)
  288.                     {
  289.                         //uputchar('-');
  290.                         uart_sendByte('-');
  291.                         n = -n;
  292.                     }    
  293.                     itoa(n, buf);
  294.                     //_uputs(buf);
  295.                     uart_sendString(buf);
  296.                     break;        
  297.                 case 'c': /*字符型*/
  298.                     c = va_arg(ap, int);
  299.                     uart_sendByte(c);
  300.                     break;
  301.                 case 'x': /*16进制*/
  302.                     n = va_arg(ap, int);
  303.                     //uart_sendByte_hex(n); /*由于求模求余编译有问题，所以用uart_sendByte_hex来替代下面的2行代码*/
  304.                     xtoa(n, buf);
  305.                     uart_sendString(buf);
  306.                     break;
  307.                 case 's': /*字符串*/
  308.                     s = va_arg(ap, char *);
  309.                     uart_sendString(s);
  310.                     break;
  311.                 case '%': /*输出%*/
  312.                     uart_sendByte('%');
  313.                     break;
  314.                 default:
  315.                     break;
  316.             }    
  317.         }
  318.         else
  319.         {
  320.             uart_sendByte(*fmt);
  321.             if(*fmt == '\n')
  322.             {
  323.                 //uart_sendByte('\r');
  324.             }
  325.         }
  326.         fmt++;
  327.     }

  329.     va_end(ap);

  331.     return count;
  332. }
uart.h文件

点击(此处)折叠或打开

  1. #ifndef _UART_H_
  2. #define _UART_H_

  4. /**************************************************************************/
  5. //串口相关寄存器
  6. #define rULCON0 (*(volatile unsigned *)0x50000000)
  7. #define rUCON0 (*(volatile unsigned *)0x50000004)
  8. #define rUFCON0 (*(volatile unsigned *)0x50000008)
  9. #define rUMCON0 (*(volatile unsigned *)0x5000000c)
  10. #define rUTRSTAT0 (*(volatile unsigned *)0x50000010)
  11. #define rUBRDIV0 (*(volatile unsigned *)0x50000028)

  13. #define WrUTXH0(ch) (*(volatile unsigned char *)0x50000020)=(unsigned char)(ch)
  14. #define RdURXH0() (*(volatile unsigned char *)0x50000024)

  16. #define rGPHCON (*(volatile unsigned *)0x56000070)
  17. #define rGPHUP (*(volatile unsigned *)0x56000078)

  19. #define PCLK 50000000 // init.c中的clock_init函数设置PCLK为50MHz
  20. #define UART_CLK PCLK // UART0的时钟源设为PCLK
  21. #define UART_BAUD_RATE 115200 // 波特率
  22. #define UART_BRD ((UART_CLK / (UART_BAUD_RATE * 16)) - 1)

  24. typedef char * va_list;
  25. #define va_start(ap,p) (ap = (char *) (&(p)+1))
  26. #define va_arg(ap, type) ((type *) (ap += sizeof(type)))[-1]
  27. #define va_argp(ap, type) ((type *) (ap += sizeof(type)))-1
  28. #define va_end(ap)

  30. void init_uart(void);
  31. void uart_sendByte(int data);
  32. void uart_sendString(char *p);
  33. void uart_sendByte_hex(unsigned long val);
  34. char uart_getch(void);
  35. void uart_getString(char *string);

  37. void itoa(unsigned int n, char * buf);
  38. void xtoa(unsigned int n, char * buf);
  39. int uart_printf(const char *fmt, ...);
  40. /**************************************************************************/

  42. #endif








阅读(843) | 评论(0) | 转发(0) |
0

上一篇：watchdog做普通定时器用-裸机驱动程序

下一篇：led裸机驱动程序

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6