devbox
繁依Fanyi0
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Linux驱动开发--内核定时器和内存管理_内存分配 gpf_atomic

作者：繁依Fanyi0 | 2024-03-03 02:03:38

赞

踩

内存分配 gpf_atomic

目录

一、时钟中断

二、延时机制

三、定时器

代码示例：

三、内核内存管理框架

四、内核中常用动态分配

4.1 kmalloc

4.2 vmalloc

4.3 kmalloc & vmalloc 的比较

4.4 分配选择原则：

4.5 代码示例：

五、IO访问-------访问外设控制器的寄存器

六、led驱动示例

代码示例：

一、时钟中断

硬件有一个时钟装置，该装置每隔一定时间发出一个时钟中断（称为一次时钟嘀嗒-tick），对应的中断处理程序就将全局变量jiffies_64加1

jiffies_64 是一个全局64位整型, jiffies全局变量为其低32位的全局变量，程序中一般用jiffies

HZ：可配置的宏，表示1秒钟产生的时钟中断次数，一般设为100或200

二、延时机制

  1. 短延迟：忙等待

    1. 1. void ndelay(unsigned long nsecs)
    2. 2. void udelay(unsigned long usecs)
    3. 3. void mdelay(unsigned long msecs)

  2. 长延迟：忙等待

    使用jiffies比较宏来实现

    1. time_after(a,b)    //a > b
    2. time_before(a,b)   //a < b
    3.  
    4. //延迟100个jiffies
    5. unsigned long delay = jiffies + 100;
    6. while(time_before(jiffies,delay))
    7. {
    8.     ;
    9. }
    10.  
    11. //延迟2s
    12. unsigned long delay = jiffies + 2*HZ;
    13. while(time_before(jiffies,delay))
    14. {
    15.     ;
    16. }

  3. 睡眠延迟----阻塞类

    1. void msleep(unsigned int msecs);
    2.  
    3. unsigned long msleep_interruptible(unsigned int msecs);

延时机制的选择原则：

  1. 异常上下文中只能采用忙等待类
  2. 任务上下文短延迟采用忙等待类，长延迟采用阻塞类

三、定时器

（1）定义定时器结构体

  1. struct timer_list 
  2. {
  3. 	struct list_head entry;
  4. 	unsigned long expires;  // 期望的时间值 jiffies + x * HZ
  5. 	void (*function)(unsigned long); // 时间到达后，执行的回调函数，软中断异常上下文
  6. 	unsigned long data;
  7. };

（2）初始化定时器

init_timer(struct timer_list *)

（3）增加定时器 ------ 定时器开始计时

void add_timer(struct timer_list *timer);

（4）删除定时器 -------定时器停止工作

int del_timer(struct timer_list * timer);

（5）修改定时器

 int mod_timer(struct timer_list *timer, unsigned long expires);

  1. 定义struct timer_list tl类型的变量
  2.  
  3.  
  4. init_timer(...);//模块入口函数
  5.  
  6. //模块入口函数或open或希望定时器开始工作的地方
  7. tl.expires = jiffies + n * HZ //n秒
  8. tl.function = xxx_func;
  9. tl.data = ...;
  10.  
  11. add_timer(....);
  12.  
  13.  
  14. //不想让定时器继续工作时
  15. del_timer(....);
  16.  
  17. void xxx_func(unsigned long arg)
  18. {
  19. 	......
  20. 	mod_timer(....);//如需要定时器继续隔指定时间再次调用本函数
  21. }

代码示例：

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/fs.h>
  4. #include <linux/cdev.h>
  5. #include <linux/wait.h>
  6. #include <linux/device.h>
  7. #include <linux/sched.h>
  8. #include <linux/poll.h>
  9. #include <asm/uaccess.h>
  10. #include <asm/atomic.h>
  11.  
  12.  
  13. int major = 11;
  14. int minor = 0;
  15. int mysecond_num  = 1;
  16.  
  17. struct mysecond_dev
  18. {
  19.     struct cdev mydev;
  20.  
  21.     int second;
  22.     struct timer_list timer;
  23.  
  24.     atomic_t openflag;//1 can open, 0 can not open
  25.  
  26.     struct class *pcls;
  27.     struct device *pdev;
  28. };
  29.  
  30. struct mysecond_dev gmydev;
  31.  
  32. void timer_func(unsigned long arg)
  33. {
  34.     struct mysecond_dev *pmydev = (struct mysecond_dev *)arg;
  35.  
  36.     pmydev->second++;
  37.  
  38.     mod_timer(&pmydev->timer,jiffies + HZ * 1);
  39. }
  40.  
  41. int mysecond_open(struct inode *pnode,struct file *pfile)
  42. {
  43.     struct mysecond_dev *pmydev = NULL;
  44.  
  45.     pfile->private_data =(void *) (container_of(pnode->i_cdev,struct mysecond_dev,mydev));
  46.      
  47.     pmydev = (struct mysecond_dev *)pfile->private_data;
  48.  
  49.     if(atomic_dec_and_test(&pmydev->openflag))
  50.     {
  51.  
  52.         pmydev->timer.expires = jiffies + HZ * 1;
  53.         pmydev->timer.function = timer_func;
  54.         pmydev->timer.data = (unsigned long)pmydev;
  55.  
  56.         add_timer(&pmydev->timer);
  57.  
  58.         return 0;
  59.     }
  60.     else
  61.     {
  62.         atomic_inc(&pmydev->openflag);
  63.         printk("The device is opened already\n");
  64.         return -1;
  65.     }
  66. }
  67.  
  68. int mysecond_close(struct inode *pnode,struct file *pfile)
  69. {
  70.     struct mysecond_dev *pmydev = (struct mysecond_dev *)pfile->private_data;
  71.  
  72.     del_timer(&pmydev->timer);
  73.  
  74.     atomic_set(&pmydev->openflag,1);
  75.     return 0;
  76. }
  77.  
  78. ssize_t mysecond_read(struct file *pfile,char __user *puser,size_t size,loff_t *p_pos)
  79. {
  80.     struct mysecond_dev *pmydev = (struct mysecond_dev *)pfile->private_data;
  81.     int ret = 0;
  82.  
  83.     if(size < sizeof(int))
  84.     {
  85.         printk("the expect read size is invalid\n");
  86.         return -1;
  87.     }
  88.  
  89.     if(size >= sizeof(int))
  90.     {
  91.         size = sizeof(int);
  92.     }
  93.  
  94.     ret = copy_to_user(puser,&pmydev->second,size);
  95.     if(ret)
  96.     {
  97.         printk("copy to user failed\n");
  98.         return -1;
  99.     }
  100.     return size;
  101. }
  102.  
  103. struct file_operations myops = {
  104.     .owner = THIS_MODULE,
  105.     .open = mysecond_open,
  106.     .release = mysecond_close,
  107.     .read = mysecond_read,
  108. };
  109.  
  110. int __init mysecond_init(void)
  111. {
  112.     int ret = 0;
  113.     dev_t devno = MKDEV(major,minor);
  114.  
  115.     /*申请设备号*/
  116.     ret = register_chrdev_region(devno,mysecond_num,"mysecond");
  117.     if(ret)
  118.     {
  119.         ret = alloc_chrdev_region(&devno,minor,mysecond_num,"mysecond");
  120.         if(ret)
  121.         {
  122.             printk("get devno failed\n");
  123.             return -1;
  124.         }
  125.         major = MAJOR(devno);//容易遗漏，注意
  126.     }
  127.  
  128.     /*给struct cdev对象指定操作函数集*/  
  129.     cdev_init(&gmydev.mydev,&myops);
  130.  
  131.     /*将struct cdev对象添加到内核对应的数据结构里*/
  132.     gmydev.mydev.owner = THIS_MODULE;
  133.     cdev_add(&gmydev.mydev,devno,mysecond_num);
  134.  
  135.     init_timer(&gmydev.timer);
  136.  
  137.     atomic_set(&gmydev.openflag,1);
  138.  
  139.     gmydev.pcls = class_create(THIS_MODULE,"mysecond");
  140.     if(IS_ERR(gmydev.pcls))
  141.     {
  142.         printk("class_create failed\n");
  143.         cdev_del(&gmydev.mydev);
  144.         unregister_chrdev_region(devno,mysecond_num);
  145.         return -1;
  146.     }
  147.  
  148.     gmydev.pdev = device_create(gmydev.pcls,NULL,devno,NULL,"mysec");
  149.     if(NULL == gmydev.pdev)
  150.     {
  151.         printk("device_create failed\n");
  152.         class_destroy(gmydev.pcls);
  153.         cdev_del(&gmydev.mydev);
  154.         unregister_chrdev_region(devno,mysecond_num);
  155.         return -1;
  156.     }
  157.     return 0;
  158. }
  159.  
  160. void __exit mysecond_exit(void)
  161. {
  162.     dev_t devno = MKDEV(major,minor);
  163.  
  164.     device_destroy(gmydev.pcls,devno);
  165.     class_destroy(gmydev.pcls);
  166.  
  167.     cdev_del(&gmydev.mydev);
  168.  
  169.     unregister_chrdev_region(devno,mysecond_num);
  170. }
  171.  
  172.  
  173. MODULE_LICENSE("GPL");
  174.  
  175. module_init(mysecond_init);
  176. module_exit(mysecond_exit);

应用层：

  1. #include <sys/types.h>
  2. #include <sys/stat.h>
  3. #include <fcntl.h>
  4. #include <unistd.h>
  5.  
  6.  
  7. #include <stdio.h>
  8.  
  9. int main(int argc,char *argv[])
  10. {
  11.     int fd = -1;
  12.     int sec = 0;
  13.  
  14.     if(argc < 2)
  15.     {
  16.         printf("The argument is too few\n");
  17.         return 1;
  18.     }
  19.  
  20.     fd = open(argv[1],O_RDONLY);
  21.     if(fd < 0)
  22.     {
  23.         printf("open %s failed\n",argv[1]);
  24.         return 2;
  25.     }
  26.  
  27.     sleep(3);
  28.  
  29.     read(fd,&sec,sizeof(sec));
  30.     printf("The second is %d\n",sec);
  31.  
  32.     close(fd);
  33.     fd = -1;
  34.     return 0;
  35. }

三、内核内存管理框架

内核将物理内存等分成N块4KB，称之为一页，每页都用一个struct page来表示，采用伙伴关系算法维护

内核地址空间划分图：

3G~3G+896M：低端内存，直接映射 虚拟地址 = 3G + 物理地址

​ 细分为：ZONE_DMA、ZONE_NORMAL

​ 分配方式：

  1. 					1. kmalloc:小内存分配，slab算法
  2. 					2. get_free_page：整页分配，2的n次方页，n最大为10

大于3G+896M：高端内存

​ 细分为：vmalloc区、持久映射区、固定映射区

​ 分配方式：vmalloc：虚拟地址连续，物理地址不连续

四、内核中常用动态分配

4.1 kmalloc

​ 函数原型：

void *kmalloc(size_t size, gfp_t flags);

kmalloc() 申请的内存位于直接映射区域，而且在物理上也是连续的，它们与真实的物理地址只有一个固定的偏移，因为存在较简单的转换关系，所以对申请的内存大小有限制，不能超过128KB。 　　 较常用的 flags（分配内存的方法）：

  • GFP_ATOMIC —— 分配内存的过程是一个原子过程，分配内存的过程不会被（高优先级进程或中断）打断；
  • GFP_KERNEL —— 正常分配内存；
  • GFP_DMA —— 给 DMA 控制器分配内存，需要使用该标志（DMA要求分配虚拟地址和物理地址连续）。

flags 的参考用法：

　|– 进程上下文，可以睡眠　　　　　GFP_KERNEL

　|– 异常上下文，不可以睡眠　　　　GFP_ATOMIC

　|　　|– 中断处理程序　　　　　　　GFP_ATOMIC

　|　　|– 软中断　　　　　　　　　　GFP_ATOMIC

　|　　|– Tasklet　　　　　　　　　GFP_ATOMIC

　|– 用于DMA的内存，可以睡眠　　　GFP_DMA | GFP_KERNEL

　|– 用于DMA的内存，不可以睡眠　　GFP_DMA |GFP_ATOMIC

 对应的内存释放函数为：

void kfree(const void *objp);

void *kzalloc(size_t size, gfp_t flags)

​

4.2 vmalloc

void *vmalloc(unsigned long size);

vmalloc() 函数则会在虚拟内存空间给出一块连续的内存区，但这片连续的虚拟内存在物理内存中并不一定连续。由于 vmalloc() 没有保证申请到的是连续的物理内存，因此对申请的内存大小没有限制，如果需要申请较大的内存空间就需要用此函数了。

对应的内存释放函数为：

void vfree(const void *addr);

注意：vmalloc() 和 vfree() 可以睡眠，因此不能从异常上下文调用。

4.3 kmalloc & vmalloc 的比较

kmalloc()、kzalloc()、vmalloc() 的共同特点是：

  1. 用于申请内核空间的内存；
  2. 内存以字节为单位进行分配；
  3. 所分配的内存虚拟地址上连续；

kmalloc()、kzalloc()、vmalloc() 的区别是：

  1. kzalloc 是强制清零的 kmalloc 操作；（以下描述不区分 kmalloc 和 kzalloc）
  2. kmalloc 分配的内存大小有限制（128KB），而 vmalloc 没有限制；
  3. kmalloc 可以保证分配的内存物理地址是连续的，但是 vmalloc 不能保证；
  4. kmalloc 分配内存的过程可以是原子过程（使用 GFP_ATOMIC），而 vmalloc 分配内存时则可能产生阻塞；
  5. kmalloc 分配内存的开销小，因此 kmalloc 比 vmalloc 要快；

一般情况下，内存只有在要被 DMA 访问的时候才需要物理上连续，但为了性能上的考虑，内核中一般使用 kmalloc()，而只有在需要获得大块内存时才使用 vmalloc()。

4.4 分配选择原则：

  1. 小内存（< 128k）用kmalloc,大内存用vmalloc或get_free_page
  2. 如果需要比较大的内存，并且要求使用效率较高时用get_free_page,否则用vmalloc

4.5 代码示例：

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/fs.h>
  4. #include <linux/cdev.h>
  5. #include <linux/uaccess.h>
  6. #include <linux/wait.h>
  7. #include <linux/sched.h>
  8. #include <linux/poll.h>
  9. #include <linux/mm.h>
  10. #include <linux/slab.h>
  11. #include "mychar.h"
  12.  
  13. #define BUF_LEN 100
  14.  
  15. int major = 11;
  16. int minor = 0;
  17. int mychar_num = 1;
  18.  
  19. struct mychar_dev
  20. {
  21. 	struct cdev mydev;
  22. 	char mydev_buf[BUF_LEN];
  23. 	int curlen;
  24.  
  25. 	struct mutex lock;
  26.  
  27. 	/*Read wait queue and write wait queue*/
  28. 	wait_queue_head_t rq;
  29. 	wait_queue_head_t wq;
  30.  
  31. 	struct fasync_struct *pasync_obj;
  32. };
  33.  
  34. struct mychar_dev *pgmydev = NULL;
  35.  
  36. int mychar_open(struct inode *pnode, struct file *pfile)
  37. {
  38. 	pfile->private_data = container_of(pnode->i_cdev, struct mychar_dev, mydev);
  39. 	printk("mychar_open\n");
  40. 	return 0;
  41. }
  42. int mychar_close(struct inode *pnode, struct file *pfile)
  43. {
  44. 	//printk("mychar_close\n");
  45. 	/*C90 requires printk after the variable declaration*/
  46. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  47.  
  48. 	if(pmydev->pasync_obj != NULL)
  49. 		fasync_helper(-1,pfile,0, &pmydev->pasync_obj);
  50. 	return 0;
  51. }
  52.  
  53. ssize_t mychar_read(struct file *pfile, char __user *puser, size_t count, loff_t *p_pos)
  54. {
  55. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  56. 	int size = 0;
  57. 	int ret = 0;
  58.  
  59. 	mutex_lock(&pmydev->lock);
  60. 	if(pmydev->curlen <= 0)
  61. 	{
  62. 		if(pfile->f_flags & O_NONBLOCK)
  63. 		{//non-blocking
  64. 			mutex_unlock(&pmydev->lock);
  65. 			printk("O_NONBLOCK No Data Read\n");
  66. 			return -1;
  67. 		}
  68. 		else
  69. 		{//blocking
  70. 			mutex_unlock(&pmydev->lock);
  71. 			ret = wait_event_interruptible(pmydev->rq,pmydev->curlen > 0);
  72. 			if(ret)
  73. 			{
  74. 				printk("Wake up by signal\n");
  75. 				return -ERESTARTSYS;
  76. 			}
  77. 			mutex_lock(&pmydev->lock);
  78. 		}
  79. 	}
  80.  
  81. 	if(count > pmydev->curlen)
  82. 	{
  83. 		size = pmydev->curlen;
  84. 	}
  85. 	else
  86. 	{
  87. 		size = count;
  88. 	}
  89.  
  90. 	ret = copy_to_user(puser, pmydev->mydev_buf, size);
  91. 	if(ret)
  92. 	{
  93. 		mutex_unlock(&pmydev->lock);
  94. 		printk("copy_to_user failed\n");
  95. 		return -1;
  96. 	}
  97.  
  98. 	memcpy(pmydev->mydev_buf, pmydev->mydev_buf + size, pmydev->curlen - size);
  99.  
  100. 	pmydev->curlen = pmydev->curlen - size;
  101. 	
  102. 	mutex_unlock(&pmydev->lock);
  103. 	/*Wake up interrupt*/
  104. 	wake_up_interruptible(&pmydev->wq);
  105. 	return size;
  106. }
  107. ssize_t mychar_write(struct file *pfile, const char __user *puser, size_t count, loff_t *p_pos)
  108. {
  109. 	int size = 0;
  110. 	int ret = 0;
  111. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  112.  
  113. 	mutex_lock(&pmydev->lock);
  114. 	if(pmydev->curlen >= BUF_LEN)
  115. 	{
  116. 		if(pfile->f_flags & O_NONBLOCK)
  117. 		{
  118. 			mutex_unlock(&pmydev->lock);
  119. 			printk("O_NONBLOCK can not write\n");
  120. 			return -1;
  121. 		}
  122. 		else
  123. 		{
  124. 			mutex_unlock(&pmydev->lock);
  125. 			ret = wait_event_interruptible(pmydev->wq,
  126. 					pmydev->curlen < BUF_LEN);
  127. 			if(ret)
  128. 			{
  129. 				printk("wake up by signal\n");
  130. 				return -ERESTARTSYS;
  131. 			}
  132. 			mutex_lock(&pmydev->lock);
  133. 		}
  134. 	}
  135.  
  136. 	if(count > BUF_LEN - pmydev->curlen)
  137. 	{
  138. 		size = BUF_LEN - pmydev->curlen;
  139. 	}
  140. 	else
  141. 	{
  142. 		size = count;
  143. 	}
  144.  
  145. 	ret = copy_from_user(pmydev->mydev_buf + pmydev->curlen, puser, size);
  146. 	if(ret)
  147. 	{
  148. 		mutex_unlock(&pmydev->lock);
  149. 		printk("copy_from_user failed\n");
  150. 		return -1;
  151. 	}
  152. 	pmydev->curlen += size;
  153.  
  154. 	mutex_unlock(&pmydev->lock);
  155. 	/*Wake up interrupt*/
  156. 	wake_up_interruptible(&pmydev->rq);
  157.  
  158. 	if(pmydev->pasync_obj != NULL)
  159. 	{
  160. 		kill_fasync(&pmydev->pasync_obj, SIGIO, POLL_IN);
  161. 	}
  162. 	return size;
  163. }
  164.  
  165. long mychar_ioctl(struct file *pfile, unsigned int cmd, unsigned long arg)
  166. {
  167. 	int __user *pret = (int *)arg;
  168. 	int maxlen = BUF_LEN;
  169. 	int ret = 0;
  170. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  171.  
  172.  
  173. 	switch(cmd)
  174. 	{
  175. 		case MYCHAR_IOCTL_GET_MAXLEN:
  176. 			ret = copy_to_user(pret, &maxlen, sizeof(int));
  177. 			if(ret)
  178. 			{
  179. 				printk("copy_to_user MAXLEN failed\n");
  180. 				return -1;
  181. 			}
  182. 			break;
  183. 		case MYCHAR_IOCTL_GET_CURLEN:
  184. 			mutex_lock(&pmydev->lock);
  185. 			ret = copy_to_user(pret, &pmydev->curlen, sizeof(int));
  186. 			mutex_unlock(&pmydev->lock);
  187. 			if(ret)
  188. 			{
  189. 				printk("copy_to_user MAXLEN failed\n");
  190. 				return -1;
  191. 			}
  192. 			break;
  193. 		default:
  194. 			printk("The cmd is unknow\n");
  195. 			return -1;
  196. 	}
  197. 	return 0;
  198. }
  199.  
  200. unsigned int mychar_poll(struct file *pfile, poll_table *ptb)
  201. {
  202. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  203. 	unsigned int mask = 0;
  204.  
  205. 	/*It not block. Adds the wait queue to the table*/
  206. 	poll_wait(pfile,&pmydev->rq,ptb);
  207. 	poll_wait(pfile,&pmydev->wq,ptb);
  208.  
  209. 	mutex_lock(&pmydev->lock);
  210. 	if(pmydev->curlen > 0)
  211. 	{
  212. 		mask |= POLLIN | POLLRDNORM;
  213. 	}
  214. 	if(pmydev->curlen < BUF_LEN)
  215. 	{
  216. 		mask |= POLLOUT | POLLWRNORM;
  217. 	}
  218. 	mutex_unlock(&pmydev->lock);
  219. 	return mask;
  220.  
  221. }
  222.  
  223. int mychar_fasync(int fd,struct file *pfile, int mode)
  224. {
  225. 	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
  226.  
  227. 	return fasync_helper(fd, pfile, mode, &pmydev->pasync_obj);
  228. }
  229. struct file_operations myops = {
  230. 	.owner = THIS_MODULE,
  231. 	.open = mychar_open,
  232. 	.release = mychar_close,
  233. 	.read = mychar_read,
  234. 	.write = mychar_write,
  235. 	.unlocked_ioctl = mychar_ioctl,
  236. 	.poll = mychar_poll,
  237. 	.fasync = mychar_fasync,
  238. };
  239.  
  240.  
  241. int __init mychar_init(void)
  242. {
  243. 	int ret = 0;
  244. 	dev_t devno = MKDEV(major,minor);
  245.  
  246. 	/*Apply for device number*/
  247. 	ret = register_chrdev_region(devno, mychar_num, "mychar");
  248. 	if(ret)
  249. 	{
  250. 		ret = alloc_chrdev_region(&devno, minor, mychar_num, "mychar");
  251. 		if(ret)
  252. 		{
  253. 			printk("get devno failed\n");
  254. 			return -1;
  255. 		}
  256. 		printk("copy_to_user failed\n");
  257. 		major = MAJOR(devno);//Easy to miss *****
  258. 	}
  259.  
  260. 	pgmydev = (struct mychar_dev *)kmalloc(sizeof(struct mychar_dev), GFP_KERNEL);
  261. 	if(NULL == pgmydev)
  262. 	{
  263. 		unregister_chrdev_region(devno, mychar_num);
  264. 		printk("kmallc for struct mychar_dev failed\n");
  265. 		return -1;
  266. 	}
  267.  
  268. 	/*Assign the 'struct cdev' a set of operation functions*/
  269. 	cdev_init(&pgmydev->mydev, &myops);
  270. 	/*Add 'struct cdev' to the kernel's data structure*/
  271. 	pgmydev->mydev.owner = THIS_MODULE;
  272. 	cdev_add(&pgmydev->mydev, devno, mychar_num);//add to Hash.
  273. 	
  274. 	/*initialize the wait queue header*/
  275. 	init_waitqueue_head(&pgmydev->rq);
  276. 	init_waitqueue_head(&pgmydev->wq);
  277.  
  278. 	mutex_init(&pgmydev->lock);
  279. 	return 0;
  280. }
  281. void __exit mychar_exit(void)
  282. {
  283. 	dev_t devno = MKDEV(major,minor);
  284. 	cdev_del(&pgmydev->mydev);
  285. 	//printk("mychar will exit\n");
  286. 	unregister_chrdev_region(devno, mychar_num);
  287. 	kfree(pgmydev);
  288. 	pgmydev = NULL;
  289. }
  290. MODULE_LICENSE("GPL");
  291.  
  292. module_init(mychar_init);
  293. module_exit(mychar_exit);

五、IO访问-------访问外设控制器的寄存器

CPU不会直接和外设连接，需要经过一个对应的控制器，卡状的就叫适配器，芯片状的就叫控制器。外设直接和SOC上的控制器连接的叫一级外设。挂在总线上的叫二级外设。

两种方式：

  1. IO端口：X86上用IO指令访问
  2. IO内存：外设寄存器在SOC芯片手册上都有相应物理地址

IO内存访问接口：

  1. static inline void __iomem *ioremap(unsigned long offset, unsigned long size)
  2. /*
  3. 功能：实现IO管脚的映射
  4. 参数：offset:该管脚的偏移地址
  5. 	 Size:该管脚映射空间的大小
  6. 返回值：成功返回映射的虚拟地址,失败NULL
  7. */
  8.  
  9. static inline void iounmap(volatile void __iomem *addr)
  10. /*
  11. 功能：解除io管脚的映射
  12. 参数：addr:io管脚映射的地址
  13. */
  14.  
  15. unsigned readb(void *addr);//1字节   或ioread8(void *addr)
  16. unsigned readw(void *addr);//2字节   或ioread16(void *addr)
  17. unsigned readl(void *addr);//4字节   或ioread32(void *addr)
  18. /*
  19. 功能：读取寄存器的值
  20. 参数：addr  地址
  21. 返回值：读到的数据
  22. */
  23.  
  24. void writeb(unsigned value, void *addr);//1字节   或iowrite8(u8 value, void *addr)
  25. void writew(unsigned value, void *addr);//2字节  或iowrite16(u16 value, void *addr)
  26. void writel(unsigned value, void *addr);//4字节  或iowrite32(u32 value, void *addr)
  27. /*
  28.  功能：向指定的寄存器中，写入数据。
  29.  参数：value：待写入寄存器中的数据
  30. 	  Address：寄存器的虚拟地址
  31. */

六、led驱动示例

  1. 读原理图

  2. 查阅SOC芯片手册

    GPX2_7 led2 GPX2CON----0x11000C40---28~31-----0001 GPX2DAT-----0x11000C44-----7

    GPX1_0 led3 GPX1CON----0x11000C20---0~3-----0001 GPX1DAT----0x11000C24-----0

    GPF3_4 led4 GPF3CON----0x114001E0---16~19-----0001 GPF3DAT----0x114001E4-----4

    GPF3_5 led5 GPF3CON----0x114001E0---20~23-----0001 GPF3DAT----0x114001E4-----5

  3. 编写驱动

    a. 设计设备数据类型

    1. struct myled_dev
    2. {
    3. 	struct cdev mydev;
    4.     
    5.     unsigned long * led2con;
    6.     unsigned long * led2dat;
    7.  
    8.     unsigned long * led3con;
    9.     unsigned long * led3dat;
    10.     
    11.     unsigned long * led4con;
    12.     unsigned long * led4dat;
    13.  
    14.     unsigned long * led5con;
    15.     unsigned long * led5dat;
    16. };

    b. 考虑需要支持的函数

    c. 模块入口：ioremap + 设置成输出

    d. 模块出口：iounmap

    e. 编写关灯函数和开灯函数，实现ioctl

volatile：对指针指向的空间不做任何优化，不加这个关键字会把指针的值放到cpu的寄存器中，加快访问速度。加上这个关键字会阻止这种优化。

代码示例：

leddrv.h

  1. #ifndef LED_DRIVER_H
  2. #define LED_DRIVER_H
  3.  
  4. #define LED_DEV_MAGIC 'g'
  5.  
  6. #define MY_LED_OFF _IO(LED_DEV_MAGIC,0)
  7. #define MY_LED_ON _IO(LED_DEV_MAGIC,1)
  8.  
  9.  
  10.  
  11. #endif

leddrv.c

  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/fs.h>
  4. #include <linux/cdev.h>
  5. #include <linux/wait.h>
  6. #include <linux/sched.h>
  7. #include <linux/poll.h>
  8. #include <linux/slab.h>
  9. #include <linux/mm.h>
  10. #include <linux/io.h>
  11. #include <asm/uaccess.h>
  12. #include <asm/atomic.h>
  13.  
  14. #include "leddrv.h"
  15.  
  16. #define GPX1CON 0x11000C20
  17. #define GPX1DAT 0x11000C24
  18.  
  19. #define GPX2CON 0x11000C40
  20. #define GPX2DAT 0x11000C44
  21.  
  22. #define GPF3CON 0x114001E0
  23. #define GPF3DAT 0x114001E4
  24.  
  25.  
  26. int major = 11;
  27. int minor = 0;
  28. int myled_num  = 1;
  29.  
  30. struct myled_dev
  31. {
  32.     struct cdev mydev;
  33.  
  34.     volatile unsigned long *pled2_con;
  35.     volatile unsigned long *pled2_dat;
  36.      
  37.     volatile unsigned long *pled3_con;
  38.     volatile unsigned long *pled3_dat;
  39.  
  40.     volatile unsigned long *pled4_con;
  41.     volatile unsigned long *pled4_dat;
  42.  
  43.     volatile unsigned long *pled5_con;
  44.     volatile unsigned long *pled5_dat;
  45. };
  46.  
  47. struct myled_dev *pgmydev = NULL;
  48.  
  49.  
  50. int myled_open(struct inode *pnode,struct file *pfile)
  51. {
  52.     pfile->private_data =(void *) (container_of(pnode->i_cdev,struct myled_dev,mydev));
  53.      
  54.     return 0;
  55. }
  56.  
  57. int myled_close(struct inode *pnode,struct file *pfile)
  58. {
  59.     return 0;
  60. }
  61.  
  62. void led_on(struct myled_dev *pmydev,int ledno)
  63. {
  64.     switch(ledno)
  65.     {
  66.         case 2:
  67.             writel(readl(pmydev->pled2_dat) | (0x1 << 7),pmydev->pled2_dat);
  68.             break;
  69.         case 3:
  70.             writel(readl(pmydev->pled3_dat) | (0x1),pmydev->pled3_dat);
  71.             break;
  72.         case 4:
  73.             writel(readl(pmydev->pled4_dat) | (0x1 << 4),pmydev->pled4_dat);
  74.             break;
  75.         case 5:
  76.             writel(readl(pmydev->pled5_dat) | (0x1 << 5),pmydev->pled5_dat);
  77.             break;
  78.     }
  79. }
  80.  
  81. void led_off(struct myled_dev *pmydev,int ledno)
  82. {
  83.     switch(ledno)
  84.     {
  85.         case 2:
  86.             writel(readl(pmydev->pled2_dat) & (~(0x1 << 7)),pmydev->pled2_dat);
  87.             break;
  88.         case 3:
  89.             writel(readl(pmydev->pled3_dat) & (~(0x1)),pmydev->pled3_dat);
  90.             break;
  91.         case 4:
  92.             writel(readl(pmydev->pled4_dat) & (~(0x1 << 4)),pmydev->pled4_dat);
  93.             break;
  94.         case 5:
  95.             writel(readl(pmydev->pled5_dat) & (~(0x1 << 5)),pmydev->pled5_dat);
  96.             break;
  97.     }
  98. }
  99.  
  100.  
  101. long myled_ioctl(struct file *pfile,unsigned int cmd,unsigned long arg)
  102. {
  103.     struct myled_dev *pmydev = (struct myled_dev *)pfile->private_data;
  104.  
  105.     if(arg < 2 || arg > 5)
  106.     {
  107.         return -1;
  108.     }
  109.     switch(cmd)
  110.     {
  111.         case MY_LED_ON:
  112.             led_on(pmydev,arg);
  113.             break;
  114.         case MY_LED_OFF:
  115.             led_off(pmydev,arg);
  116.             break;
  117.         default:
  118.             return -1;
  119.     }
  120.  
  121.     return 0;
  122. }
  123.  
  124. struct file_operations myops = {
  125.     .owner = THIS_MODULE,
  126.     .open = myled_open,
  127.     .release = myled_close,
  128.     .unlocked_ioctl = myled_ioctl,
  129. };
  130.  
  131. void ioremap_ledreg(struct myled_dev *pmydev)
  132. {
  133.     pmydev->pled2_con = ioremap(GPX2CON,4);
  134.     pmydev->pled2_dat = ioremap(GPX2DAT,4);
  135.  
  136.     pmydev->pled3_con = ioremap(GPX1CON,4);
  137.     pmydev->pled3_dat = ioremap(GPX1DAT,4);
  138.      
  139.     pmydev->pled4_con = ioremap(GPF3CON,4);
  140.     pmydev->pled4_dat = ioremap(GPF3DAT,4);
  141.      
  142.     pmydev->pled5_con = pmydev->pled4_con;
  143.     pmydev->pled5_dat = pmydev->pled4_dat;
  144. }
  145.  
  146. void set_output_ledconreg(struct myled_dev *pmydev)
  147. {
  148.     writel((readl(pmydev->pled2_con) & (~(0xF << 28))) | (0x1 << 28),pmydev->pled2_con);
  149.     writel((readl(pmydev->pled3_con) & (~(0xF))) | (0x1),pmydev->pled3_con);
  150.     writel((readl(pmydev->pled4_con) & (~(0xF << 16))) | (0x1 << 16),pmydev->pled4_con);
  151.     writel((readl(pmydev->pled5_con) & (~(0xF << 20))) | (0x1 << 20),pmydev->pled5_con);
  152.  
  153.     writel(readl(pmydev->pled2_dat) & (~(0x1 << 7)),pmydev->pled2_dat);
  154.     writel(readl(pmydev->pled3_dat) & (~(0x1)),pmydev->pled3_dat);
  155.     writel(readl(pmydev->pled4_dat) & (~(0x1 << 4)),pmydev->pled4_dat);
  156.     writel(readl(pmydev->pled5_dat) & (~(0x1 << 5)),pmydev->pled5_dat);
  157. }
  158.  
  159. void iounmap_ledreg(struct myled_dev *pmydev)
  160. {
  161.     iounmap(pmydev->pled2_con);
  162.     pmydev->pled2_con = NULL;
  163.     iounmap(pmydev->pled2_dat);
  164.     pmydev->pled2_dat = NULL;
  165.  
  166.     iounmap(pmydev->pled3_con);
  167.     pmydev->pled3_con = NULL;
  168.     iounmap(pmydev->pled3_dat);
  169.     pmydev->pled3_dat = NULL;
  170.      
  171.     iounmap(pmydev->pled4_con);
  172.     pmydev->pled4_con = NULL;
  173.     iounmap(pmydev->pled4_dat);
  174.     pmydev->pled4_dat = NULL;
  175.      
  176.     pmydev->pled5_con = NULL;
  177.     pmydev->pled5_dat = NULL;
  178. }
  179.  
  180. int __init myled_init(void)
  181. {
  182.     int ret = 0;
  183.     dev_t devno = MKDEV(major,minor);
  184.  
  185.     /*申请设备号*/
  186.     ret = register_chrdev_region(devno,myled_num,"myled");
  187.     if(ret)
  188.     {
  189.         ret = alloc_chrdev_region(&devno,minor,myled_num,"myled");
  190.         if(ret)
  191.         {
  192.             printk("get devno failed\n");
  193.             return -1;
  194.         }
  195.         major = MAJOR(devno);//容易遗漏，注意
  196.     }
  197.  
  198.     pgmydev = (struct myled_dev *)kmalloc(sizeof(struct myled_dev),GFP_KERNEL);
  199.     if(NULL == pgmydev)
  200.     {
  201.         unregister_chrdev_region(devno,myled_num);
  202.         printk("kmalloc failed\n");
  203.         return -1;
  204.     }
  205.     memset(pgmydev,0,sizeof(struct myled_dev));
  206.  
  207.     /*给struct cdev对象指定操作函数集*/  
  208.     cdev_init(&pgmydev->mydev,&myops);
  209.  
  210.     /*将struct cdev对象添加到内核对应的数据结构里*/
  211.     pgmydev->mydev.owner = THIS_MODULE;
  212.     cdev_add(&pgmydev->mydev,devno,myled_num);
  213.  
  214.     /*ioremap*/
  215.     ioremap_ledreg(pgmydev);
  216.  
  217.     /*con-register set output*/
  218.     set_output_ledconreg(pgmydev);
  219.  
  220.     return 0;
  221. }
  222.  
  223. void __exit myled_exit(void)
  224. {
  225.     dev_t devno = MKDEV(major,minor);
  226.  
  227.     /*iounmap*/
  228.     iounmap_ledreg(pgmydev);
  229.  
  230.     cdev_del(&pgmydev->mydev);
  231.  
  232.     unregister_chrdev_region(devno,myled_num);
  233.  
  234.     kfree(pgmydev);
  235.     pgmydev = NULL;
  236. }
  237.  
  238.  
  239. MODULE_LICENSE("GPL");
  240.  
  241. module_init(myled_init);
  242. module_exit(myled_exit);

testled.c

  1. #include <sys/types.h>
  2. #include <sys/stat.h>
  3. #include <fcntl.h>
  4. #include <sys/ioctl.h>
  5. #include <unistd.h>
  6.  
  7. #include <stdio.h>
  8.  
  9. #include "leddrv.h"
  10.  
  11. int main(int argc,char *argv[])
  12. {
  13.     int fd = -1;
  14.     int onoff = 0;
  15.     int no = 0;
  16.  
  17.     if(argc < 4)
  18.     {
  19.         printf("The argument is too few\n");
  20.         return 1;
  21.     }
  22.  
  23.     sscanf(argv[2],"%d",&onoff);
  24.     sscanf(argv[3],"%d",&no);
  25.  
  26.     if(no < 2 || no > 5)
  27.     {
  28.         printf("len-no is invalid\n");
  29.         return 2;
  30.     }
  31.  
  32.     fd = open(argv[1],O_RDONLY);
  33.     if(fd < 0)
  34.     {
  35.         printf("open %s failed\n",argv[1]);
  36.         return 3;
  37.     }
  38.  
  39.     if(onoff)
  40.     {
  41.         ioctl(fd,MY_LED_ON,no);
  42.     }
  43.     else
  44.     {
  45.         ioctl(fd,MY_LED_OFF,no);
  46.     }
  47.  
  48.     close(fd);
  49.     fd = -1;
  50.     return 0;
  51. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/183436?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号