设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › ARM7/9/11 Cortex-A/R › Tiny6410 简单的LED字符设备驱动 io驱动
返回列表 发新帖
查看: 4102|回复: 0
打印 上一主题 下一主题
收起左侧

Tiny6410 简单的LED字符设备驱动 io驱动

[复制链接]
跳转到指定楼层
楼主
ID:104287 发表于 2016-1-31 02:34 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
Step1：驱动加载函数： ***_init；
该函数内容为驱动硬件时仅执行一次的函数，其作用是硬件初始化。如配置IO端口输出方向，配置IO上拉等；该函数传入在module_init(***_init);函数中以使得在加载驱动时自动执行；

Step2：写open，read，write，release函数；
这三个函数的作用是为了传入file_operations结构体；在应用程序调用驱动时这三个函数作为借口被调用。
其中open的作用是在编写应用程序时加载驱动程序；其原型为pen(strpath, authority )如：fd = open("/dev/led",O_RDWR);//open函数加载驱动，返回值为描述符，返回值为0时则成功加载驱动。
Write函数的原型为： (structfile *filp, const char __user *buf, size_t count,loff_t *f_pos)   

Step3：将step2中的函数赋给operations结构体
struct file_operations led_fops =  
{   
    .owner= THIS_MODULE,   
    .open= led_open,   
    .read= led_read,   
    .write= led_write,   
    .release= led_release,   
};

Step4：在***_init函数中注册字符型设备驱动模块；如以下为注册led驱动函数：
register_chrdev(LED_MAJOR,"led",&led_fops);
int register_chrdev(unsignedintmajor,constchar*name,structfile_operations*fops);
其中参数major如果等于0，则表示采用系统动态分配的主设备号；不为0，则表示静态注册。
注销字符设备可以使用unregister_chrdev函数。

Step5：注销字符型设备驱动模块：
在led_exit（可以任意名字，最后把函数名传给module_exit即可）使用unregister_chrdev(LED_MAJOR,"led"); 函数注销驱动。并赋给module_exit(led_exit);


·一个活生生的例子   

1.查看用户手册

led1、led2、led3、led4 连接的分别是 GPK4、GPK5、GPK6、GPK7
2、查询6410芯片手册




下面还需要3个步骤：
1、设置GPIO为OUTPUT。
   将GPK4、GPK5、GPK6、GPK7设置为输出output=0001
   即GPKCON0的19:28都配置为0001

2、设置GPIO的数据。
   将GPKDATA的4:7位赋值为0

3、设置GPKUP为上拉。
   将GPKUP的4:7位设置为10

3、代码
led_driver.cStep1：驱动加载函数： ***_init；

该函数内容为驱动硬件时仅执行一次的函数，其作用是硬件初始化。如配置IO端口输出方向，配置IO上拉等；该函数传入在module_init(***_init);函数中以使得在加载驱动时自动执行；

Step2：写open，read，write，release函数；
这三个函数的作用是为了传入file_operations结构体；在应用程序调用驱动时这三个函数作为借口被调用。
其中open的作用是在编写应用程序时加载驱动程序；其原型为pen(strpath, authority )如：fd = open("/dev/led",O_RDWR);//open函数加载驱动，返回值为描述符，返回值为0时则成功加载驱动。
Write函数的原型为： (structfile *filp, const char __user *buf, size_t count,loff_t *f_pos)   

Step3：将step2中的函数赋给operations结构体
struct file_operations led_fops =  
{   
    .owner= THIS_MODULE,   
    .open= led_open,   
    .read= led_read,   
    .write= led_write,   
    .release= led_release,   
};

Step4：在***_init函数中注册字符型设备驱动模块；如以下为注册led驱动函数：
register_chrdev(LED_MAJOR,"led",&led_fops);
int register_chrdev(unsignedintmajor,constchar*name,structfile_operations*fops);
其中参数major如果等于0，则表示采用系统动态分配的主设备号；不为0，则表示静态注册。
注销字符设备可以使用unregister_chrdev函数。

Step5：注销字符型设备驱动模块：
在led_exit（可以任意名字，最后把函数名传给module_exit即可）使用unregister_chrdev(LED_MAJOR,"led"); 函数注销驱动。并赋给module_exit(led_exit);


·一个活生生的例子   

1.查看用户手册

led1、led2、led3、led4 连接的分别是 GPK4、GPK5、GPK6、GPK7
2、查询6410芯片手册




下面还需要3个步骤：
1、设置GPIO为OUTPUT。
   将GPK4、GPK5、GPK6、GPK7设置为输出output=0001
   即GPKCON0的19:28都配置为0001

2、设置GPIO的数据。
   将GPKDATA的4:7位赋值为0

3、设置GPKUP为上拉。
   将GPKUP的4:7位设置为10

3、代码
led_driver.c

  1.     #include <linux/module.h>  /*它定义了模块的 API、类型和宏(MODULE_LICENSE、MODULE_AUTHOR等等)，所有的内核模块都必须包含这个头文件。*/   
  2.         
  3.     #include <linux/kernel.h>  /*使用内核信息优先级时要包含这个文件，一般在使用printk函数时使用到优先级信息*/  
  4.       
  5.     #include <linux/fs.h>   
  6.     #include <asm/uaccess.h> /* copy_to_user,copy_from_user */     
  7.     #include <linux/pci.h>     /*readl writel*/  
  8.     #include <mach/map.h>     
  9.     #include <mach/regs-gpio.h>      
  10.     #include <mach/gpio-bank-k.h>      
  11.       
  12.         
  13.     #define LED_MAJOR   243  
  14.       
  15.     #define LED_ON      1  
  16.     #define LED_OFF     0  
  17.     #define LED_1_ON    2  
  18.     #define LED_1_OFF   3  
  19.     #define LED_2_ON    4  
  20.     #define LED_2_OFF   5  
  21.     #define LED_3_ON    6  
  22.     #define LED_3_OFF   7  
  23.     #define LED_4_ON    8  
  24.     #define LED_4_OFF   9  
  25.       
  26.       
  27.     static int led_open (struct inode *inode,struct file *filp)   
  28.         
  29.     {   
  30.         unsigned tmp;      
  31.       
  32.         tmp = readl(S3C64XX_GPKCON);      
  33.         tmp = (tmp&0x0000ffff)| 0x1111ffff;  
  34.         writel(tmp, S3C64XX_GPKCON);     
  35.       
  36.         printk("#########open######\n");   
  37.         return 0;   
  38.     }   
  39.         
  40.     static int led_read (struct file *filp, char __user *buf, size_t count,loff_t *f_pos)   
  41.     {      
  42.         return count;   
  43.     }   
  44.         
  45.         
  46.     static int led_write (struct file *filp, const char __user *buf, size_t count,loff_t *f_pos)  
  47.       
  48.     {   
  49.         char wbuf[10];   
  50.         unsigned tmp;      
  51.          
  52.         if(copy_from_user(wbuf,buf,count))  
  53.             return -EFAULT;   
  54.       
  55.             switch(wbuf[0])   
  56.             {   
  57.               
  58.             case LED_ON:   
  59.                     tmp = readl(S3C64XX_GPKDAT);      
  60.                 tmp &= (0x0f);      
  61.                 writel(tmp, S3C64XX_GPKDAT);  
  62.                 printk("turn on!\n");      
  63.                     break;  
  64.       
  65.             case LED_OFF:   
  66.                 tmp  = readl(S3C64XX_GPKDAT);      
  67.                 tmp |= (0xf0);      
  68.                 writel(tmp, S3C64XX_GPKDAT);   
  69.                 printk("turn off!\n");     
  70.                 break;            
  71.       
  72.             case LED_1_ON:   
  73.                 tmp = readl(S3C64XX_GPKDAT);      
  74.                 tmp &= (0xef);      
  75.                 writel(tmp, S3C64XX_GPKDAT);   
  76.                 printk("turn off!\n");     
  77.                 break;   
  78.       
  79.             case LED_1_OFF:   
  80.                     tmp = readl(S3C64XX_GPKDAT);      
  81.                 tmp |= (0xf0);      
  82.                 writel(tmp, S3C64XX_GPKDAT);  
  83.                 printk("turn on!\n");      
  84.                     break;   
  85.       
  86.             case LED_2_ON:   
  87.                 tmp = readl(S3C64XX_GPKDAT);      
  88.                 tmp &= (0xdf);      
  89.                 writel(tmp, S3C64XX_GPKDAT);   
  90.                 printk("turn off!\n");     
  91.                 break;   
  92.       
  93.             case LED_2_OFF:   
  94.                     tmp = readl(S3C64XX_GPKDAT);      
  95.                 tmp |= (0xf0);      
  96.                 writel(tmp, S3C64XX_GPKDAT);  
  97.                 printk("turn on!\n");      
  98.                     break;   
  99.       
  100.             case LED_3_ON:   
  101.                 tmp = readl(S3C64XX_GPKDAT);      
  102.                 tmp &= (0xbf);      
  103.                 writel(tmp, S3C64XX_GPKDAT);   
  104.                 printk("turn off!\n");     
  105.                 break;   
  106.       
  107.             case LED_3_OFF:   
  108.                     tmp = readl(S3C64XX_GPKDAT);      
  109.                 tmp |= (0xf0);      
  110.                 writel(tmp, S3C64XX_GPKDAT);  
  111.                 printk("turn on!\n");      
  112.                     break;   
  113.       
  114.             case LED_4_ON:   
  115.                 tmp = readl(S3C64XX_GPKDAT);      
  116.                 tmp &= (0x7f);      
  117.                 writel(tmp, S3C64XX_GPKDAT);   
  118.                 printk("turn off!\n");     
  119.                 break;   
  120.       
  121.             case LED_4_OFF:   
  122.                     tmp  = readl(S3C64XX_GPKDAT);      
  123.                 tmp |= (0xf0);      
  124.                 writel(tmp, S3C64XX_GPKDAT);  
  125.                 printk("turn on!\n");      
  126.                     break;   
  127.               
  128.       
  129.             default :   
  130.                     break;   
  131.             }   
  132.          return 0;   
  133.     }   
  134.         
  135.     int led_release (struct inode *inode, struct file *filp)   
  136.     {   
  137.         printk("#########release######\n");   
  138.         return 0;   
  139.     }   
  140.         
  141.     struct file_operations led_fops =  
  142.     {   
  143.         .owner = THIS_MODULE,   
  144.         .open = led_open,   
  145.         .read = led_read,   
  146.         .write = led_write,   
  147.         .release = led_release,   
  148.     };   
  149.         
  150.     int __init led_init (void)   
  151.     {     
  152.         int rc;   
  153.         printk ("Test led dev\n");   
  154.         rc = register_chrdev(LED_MAJOR,"led",&led_fops);   
  155.       
  156.         if (rc <0)   
  157.         {   
  158.             printk ("register %s char dev error\n","led");   
  159.             return -1;   
  160.         }   
  161.         printk ("ok!\n");   
  162.         return 0;   
  163.     }   
  164.         
  165.     void __exit led_exit (void)   
  166.     {   
  167.         unregister_chrdev(LED_MAJOR,"led");   
  168.         printk ("module exit\n");   
  169.         return ;   
  170.     }   
  171.         
  172.     module_init(led_init);   
  173.     module_exit(led_exit);   


  176. Makefile


  179. [cpp] view plain copy
  180. print?

  182.     obj-m := led_driver.o   
  183.     KDIR :=/home/workdir/kernel/linux-2.6.38  
  184.     all:   
  185.         make -C $(KDIR) M=$(shell pwd) modules   
  186.     install:   
  187.         cp driver_led.ko /tftpboot/   
  188.     clean:   
  189.         make -C $(KDIR) M=$(shell pwd) clean   




  194. 测试文件


  197. test_led.c

  199. [cpp] view plain copy
  200. print?

  202.     #include <stdio.h>   
  203.     #include <sys/types.h>   
  204.     #include <sys/stat.h>   
  205.     #include <fcntl.h>   
  206.       
  207.       
  208.     #define LED_OFF     0  
  209.     #define LED_ON      1  
  210.     #define LED_1_ON    2  
  211.     #define LED_1_OFF   3  
  212.     #define LED_2_ON    4  
  213.     #define LED_2_OFF   5  
  214.     #define LED_3_ON    6  
  215.     #define LED_3_OFF   7  
  216.     #define LED_4_ON    8  
  217.     #define LED_4_OFF   9  
  218.       
  219.     int main (void)   
  220.     {   
  221.         int  i=0;  
  222.         int  fd;   
  223.         char buf[10]={  
  224.                 LED_ON ,   LED_OFF ,  
  225.                 LED_1_ON,  LED_1_OFF,  
  226.                 LED_2_ON,  LED_2_OFF,  
  227.                 LED_3_ON,  LED_3_OFF,  
  228.                 LED_4_ON,  LED_4_OFF,            
  229.              };   
  230.       
  231.         fd = open("/dev/led",O_RDWR);   
  232.         if (fd < 0)   
  233.         {   
  234.             printf ("Open /dev/led file error\n");   
  235.             return -1;   
  236.         }      
  237.       
  238.         while(i<10)   
  239.         {   
  240.             write(fd,&buf[i],4);   
  241.             sleep(1);   
  242.             i++;  
  243.         }   
  244.         close (fd);   
  245.         return 0;   
  246.         
  247.     }   
复制代码


上述编译没有问题，就可以下到板子测试了。

加载驱动          insmod  led_driver.ko
创建设备文件    mknod /dev/led c 243 0  其中243要跟驱动文件中的设备号一致

运行测试文件    ./test_led
完成。

------------------------------------------------------------------------------------------
参考资料：
  1. #include <linux/module.h>/*它定义了模块的 API、类型和宏(MODULE_LICENSE、MODULE_AUTHOR等等)，所有的内核模块都必须包含这个头文件。/
  2. #include <linux/kernel.h>/*使用内核信息优先级时要包含这个文件，一般在使用printk函数时使用到优先级信息*/
  3. #include <linux/init.h>//头文件：module_init、module_exit等宏定义。
  4. #include <linux/fs.h>////struct file_operations
  5. #include <asm/irq.h>
  6. #include <mach/regs-gpio.h>// S3C2410 GPIO寄存器定义
  7. #include <mach/hardware.h>// s3c2410_gpio_setpin, s3c2410_gpio_cfgpin等
  8. #include <linux/device.h>//class_create device_create(注意，有些2.6.27以前是的可能是class_device_create，如果出现implicate 错误时，看一下这个头问题里边是哪一个)，udev，自动在/dev下创建设备节点
  9. #include <linux/cdev.h>//字符设备节点注册，函数有cdev_init,cdev_add,cdev_del等早期的办法是register_chrdev,unregister_chrdev这种方法应避免使用。
  10. #define DEVICE_NAME "leds" /* 加载模式后，执行”cat /proc/devices”命令看到的设备名称 */
  11. #define LED_MAJOR 231 /* 主设备号 */
  12. /* 应用程序执行ioctl(fd, cmd, arg)时的第2个参数 */
  13. #define IOCTL_LED_ON 1
  14. #define IOCTL_LED_OFF 0
  15. /* 用来指定LED所用的GPIO引脚 */
  16. static unsigned long led_table [] =
  17. {
  18. S3C2410_GPB5,
  19. S3C2410_GPB6,
  20. S3C2410_GPB7,
  21. S3C2410_GPB8,
  22. };
  23. /* 用来指定GPIO引脚的功能：输出 */
  24. static unsigned int led_cfg_table [] =
  25. {
  26. S3C2410_GPB5_OUTP,
  27. S3C2410_GPB6_OUTP,
  28. S3C2410_GPB7_OUTP,
  29. S3C2410_GPB8_OUTP,
  30. };
  31. struct leds_type
  32. {
  33. struct cdev cdev;
  34. };
  35. struct leds_type *my_leds_dev;
  36. /* 应用程序对设备文件/dev/EmbedSky-leds执行open(...)时，
  37. * 就会调用EmbedSky_leds_open函数
  38. */
  39. static int EmbedSky_leds_open(struct inode *inode, struct file *file)
  40. {
  41. int i;
  42. for (i = 0; i < 4; i++)
  43. {
  44. // 设置GPIO引脚的功能：本驱动中LED所涉及的GPIO引脚设为输出功能
  45. s3c2410_gpio_cfgpin(led_table[i], led_cfg_table[i]);
  46. }
  47. return 0;
  48. }
  49. /* 应用程序对设备文件/dev/EmbedSky-leds执行ioclt(...)时，
  50. * 就会调用EmbedSky_leds_ioctl函数
  51. */
  52. static int EmbedSky_leds_ioctl( struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
  53. {
  54. if (arg > 4)
  55. {
  56. return -EINVAL;
  57. }
  58. switch(cmd)
  59. {
  60. case IOCTL_LED_ON:
  61. // 设置指定引脚的输出电平为0
  62. s3c2410_gpio_setpin(led_table[arg], 0);
  63. return 0;
  64. case IOCTL_LED_OFF:
  65. // 设置指定引脚的输出电平为1
  66. s3c2410_gpio_setpin(led_table[arg], 1);
  67. return 0;
  68. default:
  69. return -EINVAL;
  70. }
  71. }
  72. /* 这个结构是字符设备驱动程序的核心
  73. * 当应用程序操作设备文件时所调用的open、read、write等函数，
  74. * 最终会调用这个结构中指定的对应函数
  75. */
  76. static struct file_operations EmbedSky_leds_fops =
  77. {
  78. .owner = THIS_MODULE, /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
  79. .open = EmbedSky_leds_open,
  80. .ioctl = EmbedSky_leds_ioctl,
  81. };
  82. static char __initdata banner[] = "TQ2440/SKY2440 LEDS, (c) 2008,2009 www.embedsky.net/n";
  83. static struct class *led_class;
  84. /*
  85. * 执行“insmod EmbedSky_leds.ko”命令时就会调用这个函数
  86. */
  87. static int __init EmbedSky_leds_init(void)
  88. {
  89. int ret;
  90. dev_t devno=MKDEV(LED_MAJOR,0);
  91. printk("init led/n");
  92. printk(banner);
  93. /* 注册字符设备驱动程序
  94. * 参数为主设备号、设备名字、file_operations结构；
  95. * 这样，主设备号就和具体的file_operations结构联系起来了，
  96. * 操作主设备为LED_MAJOR的设备文件时，就会调用EmbedSky_leds_fops中的相关成员函数
  97. ret = register_chrdev_region(devno, 1,DEVICE_NAME);//获得设备编号
  98. my_leds_dev=kmalloc(sizeof(struct leds_type),GFP_KERNEL);
  99. /*这个必须有不然会在加载模块时出现Unable to handle kernel NULL pointer dereference at virtual addres 00000000 错误，这是由于在这里my_leds_dev仅仅是个指针，没有相应大小的分配内存，所以使用时会出错，，，寻找这个错误是比较麻烦的*/
  100. if(!my_leds_dev)
  101. {
  102. ret=-ENOMEM;
  103. goto fail_malloc;
  104. }
  105. memset(my_leds_dev,0,sizeof(struct leds_type));
  106. cdev_init(&(my_leds_dev->cdev),&EmbedSky_leds_fops);
  107. ret=cdev_add(&(my_leds_dev->cdev),devno,1);
  108. /*注意：与早期的设备注册方法不同，早期的直接register_chrdev()就可以，*/
  109. if(ret)printk(KERN_NOTICE"ERROR %d",ret);
  110. //注册一个类，使mdev可以在"/dev/"目录下面建立设备节点
  111. led_class = class_create(THIS_MODULE, DEVICE_NAME);
  112. if(IS_ERR(led_class))
  113. {
  114. printk("Err: failed in EmbedSky-leds class. /n");
  115. return -1;
  116. }
  117. //创建一个设备节点，节点名为DEVICE_NAME
  118. device_create(led_class, NULL, MKDEV(LED_MAJOR, 0), NULL, DEVICE_NAME);
  119. printk(DEVICE_NAME " initialized/n");
  120. return 0;
  121. fail_malloc: unregister_chrdev_region(devno,1);
  122. return ret;
  123. }
  124. /*
  125. * 执行”rmmod EmbedSky_leds.ko”命令时就会调用这个函数
  126. */
  127. static void __exit EmbedSky_leds_exit(void)
  128. {
  129. /* 卸载驱动程序 */
  130. unregister_chrdev(LED_MAJOR, DEVICE_NAME);
  131. device_destroy(led_class, MKDEV(LED_MAJOR, 0)); //删掉设备节点
  132. class_destroy(led_class); //注销类
  133. }
  134. /* 这两行指定驱动程序的初始化函数和卸载函数 */
  135. module_init(EmbedSky_leds_init);
  136. module_exit(EmbedSky_leds_exit);
  137. /* 描述驱动程序的一些信息，不是必须的 */
  138. MODULE_AUTHOR("http://www.embedsky.net"); // 驱动程序的作者
  139. MODULE_DESCRIPTION("TQ2440/SKY2440 LED Driver"); // 一些描述信息
  140. MODULE_LICENSE("GPL"); // 遵循的协议
  141. 上面代码中，led_table数组相当于对应了GPB的四个IO口的索引，通过这四个值，对这四个IO口进行相关操作。例如：
  142. S3C2410_GPB5 ＝ S3C2410_GPIONO(S3C2410_GPIO_BANKB, 5)
  143. ＝ S3C2410_GPIO_BANKB ＋ 5
  144. ＝ 32*1 + 5
  145. 在s3c2410_gpio_setpin(S3C2410_GPB5，0)中，该函数首先通过S3C2410_GPB5获得GPB的虚拟地址和偏移地址，再对GPB5的GPBDAT寄存器进行操作，具体
  146. void s3c2410_gpio_setpin(unsigned int pin, unsigned int to)
  147. {
  148. void __iomem *base = S3C2410_GPIO_BASE(pin);
  149. unsigned long offs = S3C2410_GPIO_OFFSET(pin);
  150. unsigned long flags;
  151. unsigned long dat;
  152. local_irq_save(flags);
  153. dat = __raw_readl(base + 0x04);//读取GPIO的DAT数据到dat
  154. dat &= ~(1 << offs); //先将要设置的IO口拉低
  155. dat |= to << offs; //再将形参的to值赋给dat
  156. __raw_writel(dat, base + 0x04);//最后将DAT值写进GPIO的DAT
  157. local_irq_restore(flags);
  158. }

  160. 上面的 函数调用了两个子函数，具体定义如下

  162. #define S3C2410_GPIO_BASE(pin) ((((pin) & ~31) >> 1) + S3C24XX_VA_GPIO)
  163. #define S3C2410_GPIO_OFFSET(pin) ((pin) & 31)
  164. 其中S3C24XX_VA_GPIO定义如下：

  166. #define S3C24XX_VA_GPIO S3C2410_ADDR(0x00E00000)
  167. #define S3C2410_ADDR(x) (0xF0000000 + (x))
  168. 这里S3C2410_ADDR的基地址为0xF0000000(??)，也即2440所有寄存器的虚拟地址的基地址。0x00E00000表示2440的GPIO的偏移地址，也就是说其GPIO的虚拟地址首地址为0xF0E00000。

  170. 再看看S3C2410_GPIO_BASE(pin)的定义，我们不仿把S3C2410_GPB5的值放进去计算，可以得到(S3C2410_GPB5&~31)=32。其目的就是去掉GPB的偏移值，然后再右移一位，和GPIO的虚拟地址首地址相加。因此，S3C2410_GPIO_BASE(pin)只代表了对应GPIO组的虚拟地址，如GPB的虚拟地址为10000(B)+0xF0E00000=0xF0E00010。依此类推，可以得到所有GPIO的偏移地址，具体如下表：


  173. BANK
  174. （pin&~31）
  175. （pin&~31）>>1
  176. S3C2410_GPIO_BASE(pin)

  178. GPA
  179. 32*0
  180. 0000,0000
  181. 0x00
  182. 0xF0E00000

  184. GPB
  185. 32*1
  186. 0010,0000
  187. 0x10
  188. 0xF0E00010

  190. GPC
  191. 32*2
  192. 0100,0000
  193. 0x20
  194. 0xF0E00020

  196. GPD
  197. 32*3
  198. 0110,0000
  199. 0x30
  200. 0xF0E00030

  202. GPE
  203. 32*4
  204. 1000,0000
  205. 0x40
  206. 0xF0E00040

  208. GPF
  209. 32*5
  210. 1010,0000
  211. 0x50
  212. 0xF0E00050

  214. GPG
  215. 32*6
  216. 1100,0000
  217. 0x60
  218. 0xF0E00060

  220. GPH
  221. 32*7
  222. 1110,0000
  223. 0x70
  224. 0xF0E00070


  227. S3C2410_GPIO_OFFSET用于获得具体GPIO的偏移地址。如GPB5，则S3C2410_GPIO_OFFSET(pin) ＝ (pin)&31 = (32*1 + 5) & 31 = 5。有了*base和off，就可以操作具体的寄存器了。
  228. 函数s3c2410_gpio_cfgpin()用于配置GPCON寄存器。具体代码
  229. void s3c2410_gpio_cfgpin(unsigned int pin, unsigned int function)
  230. {
  231. void __iomem *base = S3C2410_GPIO_BASE(pin);
  232. unsigned long mask;
  233. unsigned long con;
  234. unsigned long flags;
  235. if (pin < S3C2410_GPIO_BANKB)
  236. {
  237. mask = 1 << S3C2410_GPIO_OFFSET(pin);//GPA的寄存器只占一位
  238. }
  239. else
  240. {
  241. mask = 3 << S3C2410_GPIO_OFFSET(pin)*2;//非GPA的寄存器占两位
  242. }
  243. local_irq_save(flags);
  244. con = __raw_readl(base + 0x00);//先保留GPCON的值
  245. con &= ~mask; //再将要设置的管脚的CON值清零
  246. con |= function; //然后将形参传进来的配置赋给CON
  247. __raw_writel(con, base + 0x00); //最后将CON值写进GPCON寄存器
  248. local_irq_restore(flags);
  249. }
  250. 上面的LED驱动程序中，led_cfg_table数组给出了GPB相应管脚的属性设置，调用上面的函数后即设置为Output。

  252. 到此为止，整个S3C2440的IO口操作，应该就一目了然了

  254. #define __raw_writel(v,a) (__chk_io_ptr(a), *(volatile unsigned int __force *)(a) = (v))
  255. # define __chk_io_ptr(x) (void)0

  257. __chk_io_ptr()是编译器为了更细致地检查参数的属性，用于调试，正常编译时没有作用。
  258. volatile为了防止Compiler优化。

  260. 内核中,对所有的地址都是通过虚拟地址进行访问的.因此，不能直接访问0x56000010的物理地址，如果要对0x56000010的物理地址进行访问(一般是外设寄存器),那么需要把0x56000010的物理地址映射为虚拟地址,然后对该虚拟地址进行访问就是对实际的物理地址进行访问了。
  261. 需要注意的是:在进行映射时,该虚拟地址需要disable cache和Write Buffer, 否则就是加了volatile也是没有用的

  263. 这个IOREMAP的实现过程中
  264. /*
  265. * figure out the physical address offset in a page size
  266. * PAGE_MASK = (1 << 10)
  267. */
  268. offset = phys_addr &~ PAGE_MASK;
  269. /*
  270. * figure out physical address with page align
  271. */
  272. phys_addrs &= PAGE_MASK;
  273. /*
  274. * get the real size with page align
  275. */
  276. size = PAGE_ALIGN(last_addr) - phys_addrs;
  277. 下面是通过vmlist中查找以size大小的空闲块,所以从这里可以看出,已经做过了页的对齐,只以映射的大小

  279. 杂项设备（misc device）

  281. 杂项设备也是在嵌入式系统中用得比较多的一种设备驱动。在 Linux 内核的include/linux目录下有Miscdevice.h文件，要把自己定义的misc device从设备定义在这里。其实是因为这些字符设备不符合预先确定的字符设备范畴，所有这些设备采用主编号10 ，一起归于misc device，其实misc_register就是用主标号10调用register_chrdev()的。

  283. 也就是说，misc设备其实也就是特殊的字符设备。

  285. 字符设备(char device)

  287. 使用register_chrdev(LED_MAJOR,DEVICE_NAME,&dev_fops)注册字符设备驱动程序时，如果有多个设备使用该函数注册驱动程序，LED_MAJOR不能相同，否则几个设备都无法注册(我已验证)。如果模块使用该方式注册并且 LED_MAJOR为0(自动分配主设备号 )，使用insmod命令加载模块时会在终端显示分配的主设备号和次设备号，在/dev目录下建立该节点，比如设备leds，如果加载该模块时分配的主设备号和次设备号为253和0，则建立节点:mknod leds c 253 0。使用register_chrdev (LED_MAJOR,DEVICE_NAME,&dev_fops)注册字符设备驱动程序时都要手动建立节点 ，否则在应用程序无法打开该设备。

  289. __raw_readl和__raw_writel

  291. Linux对I/O的操作都定义在asm/io.h中，相应的在arm平台下，就在asm-arm/io.h中。

  293. #define __raw_writeb(v,a) (__chk_io_ptr(a), *(volatile unsigned char __force *)(a) = (v))

  295. #define __raw_writew(v,a) (__chk_io_ptr(a), *(volatile unsigned short __force *)(a) = (v))

  297. #define __raw_writel(v,a) (__chk_io_ptr(a), *(volatile unsigned int __force *)(a) = (v))在include/linux/compiler.h中：

  299. #ifdef __CHECKER__……
  300. extern void __chk_io_ptr(void __iomem *);
  301. #else……
  302. # define __chk_io_ptr(x) (void)0……
  303. #endif

  305. __raw_readl(a)展开是：((void)0, *(volatile unsigned int _force *)(a))。在定义了__CHECKER__的时候先调用__chk_io_ptr检查该地址，否则__chk_io_ptr什么也不做，*(volatile unsigned int _force *)(a)就是返回地址为a处的值。(void)xx的做法有时候是有用的，例如编译器打开了检查未使用的参数的时候需要将没有用到的参数这么弄一下才能编译通过。

  307. CPU对I/O的物理地址的编程方式有两种：一种是I/O映射，一种是内存映射。__raw_readl和__raw_writel等是原始的操作I/O的方法，由此派生出来的操作方法有：inb、outb、_memcpy_fromio、readb、writeb、ioread8、iowrite8等。
复制代码


应用程序, release, 结构体, count, write
分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶顶 踩踩

相关帖子
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表