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

Linux 并发与竞争_linux 单核 多线程 并发 问题

作者：不正经 | 2024-02-27 08:12:46

赞

踩

linux 单核 多线程 并发 问题

目录

1.并发与竞争

1.1并发与竞争简介

2.原子操作

​编辑 3.自旋锁

4.信号量

 5. 互斥体

6.原子操作实验

 7.自旋锁

8.信号量

9.互斥体

1.并发与竞争

1.1并发与竞争简介

        并发就是多个“用户”同时访问同一个共享资源。Linux 系统是个多任务操作系统，会存在多个任务同时访问同一片内存区域，这些任务可能会相互覆盖这段内存中的数据，造成内存数据混乱。针对这个问题必须要做处理，严重的话可能会导致系统崩溃。现在的 Linux 系统并发产生的原因很复杂，总结一下有下面几个主要原因：

        （1）多线程并发访问，Linux是多任务系统。

        （2）抢占式并发访问，就是说调度程序可以在任意时刻抢占正在运行的线程，从而运行其他的线程。

        （3）中断程序并发访问。

        （4）SMP核间并发访问，多核CPU存在核间并发访问。

        并发访问带来的问题就是竞争。所谓的临界区就是共享数据段，对于临界区必须保证一次只有一个线程访问，也就是要保证临界区是原子访问的。如果多个进程同时操作临界区就表示存在竞争，我们在编写驱动的时候一定要注意避免并发和防止竞争访问。

2.原子操作

        原子操作就是指不能再进一步分割的操作，一般原子操作用于变量或者位操作。Linux 内核定义了叫做 atomic_t 的结构体来完成整形数据的原子操作，在使用中用原子变量来代替整形变量：

  1. typedef struct {
  2. 	int counter;
  3. } atomic_t;

如果要使用原子操作 API 函数，首先要先定义一个 atomic_t 的变量，如下所示：

atomic_t a; //定义 a

也可以在定义原子变量的时候给原子变量赋初值，如下所示：

  1. atomic_t b = ATOMIC_INIT(0); //定义原子变量 b 并赋初值为 0
  2. #define ATOMIC_INIT(i)	{ (i) }

        原子变量有了，接下来就是对原子变量进行操作，比如读、写、增加、减少等等， Linux 内
核提供了大量的原子操作 API 函数：

        以上API函数都是操作原子变量中的counter来实现目的的。        

 原子位操作 API 函数：

 3.自旋锁

        原子操作只能对整形变量或者位进行保护，但是，在实际的使用环境中怎么可能只有整形
变量或位这么简单的临界区。举个最简单的例子，设备结构体变量就不是整型变量，我们对于
结构体中成员变量的操作也要保证原子性，在线程 A 对结构体变量使用期间，应该禁止其他的
线程来访问此结构体变量，这些工作原子操作都不能胜任，需要本节要讲的锁机制，在 Linux
内核中就是自旋锁。

        当一个线程要访问某个共享资源的时候首先要先获取相应的锁， 锁只能被一个线程持有，只要此线程不释放持有的锁，那么其他的线程就不能获取此锁。对于自旋锁而言，如果自旋锁正在被线程 A 持有，线程 B 想要获取自旋锁，那么线程 B 就会处于忙循环-旋转-等待状态，线程 B 不会进入休眠状态或者说去做其他的处理，而是会一直傻傻的在那里“转圈圈”的等待锁可用。

        自旋锁的“自旋”也就是“原地打转”的意思，“原地打转”的目的是为了等待自旋锁可以用，可以访问共享资源。把自旋锁比作一个变量 a，变量 a=1 的时候表示共享资源可用，当 a=0的时候表示共享资源不可用。现在线程 A 要访问共享资源，发现 a=0(自旋锁被其他线程持有)，那么线程 A 就会不断的查询 a 的值，直到 a=1。从这里我们可以看到自旋锁的一个缺点：那就等待自旋锁的线程会一直处于自旋状态，这样会浪费处理器时间，降低系统性能，所以自旋锁的持有时间不能太长。所以自旋锁适用于短时期的轻量级加锁，如果遇到需要长时间持有锁的场景那就需要换其他的方法了，这个我们后面会讲解。Linux 内核使用结构体 spinlock_t 表示自旋锁：

  1. typedef struct spinlock {
  2. 	union {
  3. 		struct raw_spinlock rlock;
  4.  
  5. #ifdef CONFIG_DEBUG_LOCK_ALLOC
  6. # define LOCK_PADSIZE (offsetof(struct raw_spinlock, dep_map))
  7. 		struct {
  8. 			u8 __padding[LOCK_PADSIZE];
  9. 			struct lockdep_map dep_map;
  10. 		};
  11. #endif
  12. 	};
  13. } spinlock_t;

        在使用自旋锁之前，肯定要先定义一个自旋锁变量，定义方法如下所示：

spinlock_t lock; //定义自旋锁

自旋锁的API函数： 

        上述API函数适用于SMP或支持抢占的单CPU下线程之间的并发访问，也就是用于线程与线程之间，被自旋锁保护的临界区一定不能调用任何能够引起睡眠和阻塞的API 函数，否则的话会可能会导致死锁现象的发生。自旋锁会自动禁止抢占，也就说当线程 A得到锁以后会暂时禁止内核抢占。如果线程 A 在持有锁期间进入了休眠状态，那么线程 A 会自动放弃 CPU 使用权。线程 B 开始运行，线程 B 也想要获取锁，但是此时锁被 A 线程持有，而且内核抢占还被禁止了！线程 B 无法被调度出去，那么线程 A 就无法运行，锁也就无法释放，好了，死锁发生了！如果此时中断也要插一脚，中断也想访问共享资源，那该怎么办呢？首先可以肯定的是，中断里面可以使用自旋锁，但是在中断里面使用自旋锁的时候，在获取锁之前一定要先禁止本地中断(也就是本 CPU 中断，对于多核 SOC来说会有多个 CPU 核)，否则可能导致锁死现象的发生：

 一般在线程中使用 spin_lock_irqsave/spin_unlock_irqrestore，在中断中使用 spin_lock/spin_unlock，示例代码如下所示：

         下半部(BH)也会竞争共享资源，有些资料也会将下半部叫做底半部。

 其他类型的锁：

（1）读写自旋锁

  1. typedef struct {
  2. 	arch_rwlock_t raw_lock;
  3. #ifdef CONFIG_GENERIC_LOCKBREAK
  4. 	unsigned int break_lock;
  5. #endif
  6. #ifdef CONFIG_DEBUG_SPINLOCK
  7. 	unsigned int magic, owner_cpu;
  8. 	void *owner;
  9. #endif
  10. #ifdef CONFIG_DEBUG_LOCK_ALLOC
  11. 	struct lockdep_map dep_map;
  12. #endif
  13. } rwlock_t;

（2）顺序锁

  1. typedef struct {
  2. 	struct seqcount seqcount;
  3. 	spinlock_t lock;
  4. } seqlock_t;

        自旋锁使用注意事项：

（1）因为在等待自旋锁的时候处于“自旋”状态，因此锁的持有时间不能太长，一定要短，否则的话会降低系统性能。如果临界区比较大，运行时间比较长的话要选择其他的并发处理方式，比如稍后要讲的信号量和互斥体。
（2）自旋锁保护的临界区内不能调用任何可能导致线程休眠的 API 函数，否则的话可能导致死锁。
（3）不能递归申请自旋锁，因为一旦通过递归的方式申请一个你正在持有的锁，那么你就必须“自旋”，等待锁被释放，然而你正处于“自旋”状态，根本没法释放锁。结果就是自己把自己锁死了！
（4）在编写驱动程序的时候我们必须考虑到驱动的可移植性，因此不管你用的是单核的还是多核的 SOC，都将其当做多核 SOC 来编写驱动程序。

4.信号量

        Linux 内核也提供了信号量机制，信号量常常用于控制对共享资源的访问。相比于自旋锁，信号量可以使线程进入休眠状态，比如 A 与 B、 C 合租了一套房子，这个房子只有一个厕所，一次只能一个人使用。某一天早上 A 去上厕所了，过了一会 B 也想用厕所，因为 A 在厕所里面，所以 B 只能等到 A 用来了才能进去。 B 要么就一直在厕所门口等着，等 A 出来，这个时候就相当于自旋锁。 B 也可以告诉 A，让 A 出来以后通知他一下，然后 B 继续回房间睡觉，这个时候相当于信号量。可以看出，使用信号量会提高处理器的使用效率，毕竟不用一直傻乎乎的在那里“自旋”等待。但是，信号量的开销要比自旋锁大，因为信号量使进程进入休眠状态以后会进行进程上下文切换，切换就会有开销。信号量特点：

（1）因为信号量可以使等待资源线程进入休眠状态，因此适用于那些占用资源比较久的场合。
（2）因此信号量不能用于中断中，因为信号量会引起休眠，中断不能休眠。
（3）如果共享资源的持有时间比较短，那就不适合使用信号量了，因为频繁的休眠、切换线程引起的开销要远大于信号量带来的那点优势。

        Linux 内核使用 semaphore 结构体表示信号量，结构体内容如下所示：

  1. struct semaphore {
  2. 	raw_spinlock_t		lock;
  3. 	unsigned int		count;
  4. 	struct list_head	wait_list;
  5. };

要想使用信号量就得先定义，然后初始化信号量。有关信号量的 API 函数如下：

  1. #define DEFINE_SEMAPHORE(name)	\
  2. 	struct semaphore name = __SEMAPHORE_INITIALIZER(name, 1)
  3.  
  4. static inline void sema_init(struct semaphore *sem, int val)
  5. {
  6. 	static struct lock_class_key __key;
  7. 	*sem = (struct semaphore) __SEMAPHORE_INITIALIZER(*sem, val);
  8. 	lockdep_init_map(&sem->lock.dep_map, "semaphore->lock", &__key, 0);
  9. }
  10.  
  11. void down(struct semaphore *sem)
  12. {
  13. 	unsigned long flags;
  14.  
  15. 	raw_spin_lock_irqsave(&sem->lock, flags);
  16. 	if (likely(sem->count > 0))
  17. 		sem->count--;
  18. 	else
  19. 		__down(sem);
  20. 	raw_spin_unlock_irqrestore(&sem->lock, flags);
  21. }
  22.  
  23. int down_trylock(struct semaphore *sem)
  24. {
  25. 	unsigned long flags;
  26. 	int count;
  27.  
  28. 	raw_spin_lock_irqsave(&sem->lock, flags);
  29. 	count = sem->count - 1;
  30. 	if (likely(count >= 0))
  31. 		sem->count = count;
  32. 	raw_spin_unlock_irqrestore(&sem->lock, flags);
  33.  
  34. 	return (count < 0);
  35. }
  36.  
  37. int down_interruptible(struct semaphore *sem)
  38. {
  39. 	unsigned long flags;
  40. 	int result = 0;
  41.  
  42. 	raw_spin_lock_irqsave(&sem->lock, flags);
  43. 	if (likely(sem->count > 0))
  44. 		sem->count--;
  45. 	else
  46. 		result = __down_interruptible(sem);
  47. 	raw_spin_unlock_irqrestore(&sem->lock, flags);
  48.  
  49. 	return result;
  50. }
  51.  
  52. void up(struct semaphore *sem)
  53. {
  54. 	unsigned long flags;
  55.  
  56. 	raw_spin_lock_irqsave(&sem->lock, flags);
  57. 	if (likely(list_empty(&sem->wait_list)))
  58. 		sem->count++;
  59. 	else
  60. 		__up(sem);
  61. 	raw_spin_unlock_irqrestore(&sem->lock, flags);
  62. }
  63. EXPORT_SYMBOL(up);

其中__down和__down_interruptible的区别：

  1. static noinline void __sched __down(struct semaphore *sem)
  2. {
  3. 	__down_common(sem, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
  4. }
  5.  
  6. static noinline int __sched __down_interruptible(struct semaphore *sem)
  7. {
  8. 	return __down_common(sem, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
  9. }

信号量的使用如下所示：

 5. 互斥体

         将信号量的值设置为 1 就可以使用信号量进行互斥访问了，虽然可以通过信号量实现互斥，但是 Linux 提供了一个比信号量更专业的机制来进行互斥，它就是互斥体—mutex。互斥访问表示一次只有一个线程可以访问共享资源，不能递归申请互斥体。Linux 内核使用 mutex 结构体表示互斥体，定义如下：

  1. struct mutex {
  2. 	/* 1: unlocked, 0: locked, negative: locked, possible waiters */
  3. 	atomic_t		count;
  4. 	spinlock_t		wait_lock;
  5. 	struct list_head	wait_list;
  6. #if defined(CONFIG_DEBUG_MUTEXES) || defined(CONFIG_MUTEX_SPIN_ON_OWNER)
  7. 	struct task_struct	*owner;
  8. #endif
  9. #ifdef CONFIG_MUTEX_SPIN_ON_OWNER
  10. 	struct optimistic_spin_queue osq; /* Spinner MCS lock */
  11. #endif
  12. #ifdef CONFIG_DEBUG_MUTEXES
  13. 	void			*magic;
  14. #endif
  15. #ifdef CONFIG_DEBUG_LOCK_ALLOC
  16. 	struct lockdep_map	dep_map;
  17. #endif
  18. };

在使用 mutex 的时候要注意如下几点：
①、 mutex 可以导致休眠，因此不能在中断中使用 mutex，中断中只能使用自旋锁。
②、和信号量一样， mutex 保护的临界区可以调用引起阻塞的 API 函数。
③、因为一次只有一个线程可以持有 mutex，因此，必须由 mutex 的持有者释放 mutex。并
且 mutex 不能递归上锁和解锁。

有关互斥体的 API 函数如下：

  1. #define DEFINE_MUTEX(mutexname) \
  2. 	struct mutex mutexname = __MUTEX_INITIALIZER(mutexname)
  3.  
  4. void
  5. __mutex_init(struct mutex *lock, const char *name, struct lock_class_key *key)
  6. {
  7. 	atomic_set(&lock->count, 1);
  8. 	spin_lock_init(&lock->wait_lock);
  9. 	INIT_LIST_HEAD(&lock->wait_list);
  10. 	mutex_clear_owner(lock);
  11. #ifdef CONFIG_MUTEX_SPIN_ON_OWNER
  12. 	osq_lock_init(&lock->osq);
  13. #endif
  14.  
  15. 	debug_mutex_init(lock, name, key);
  16. }
  17.  
  18. void __sched mutex_lock(struct mutex *lock)
  19. {
  20. 	might_sleep();
  21. 	/*
  22. 	 * The locking fastpath is the 1->0 transition from
  23. 	 * 'unlocked' into 'locked' state.
  24. 	 */
  25. 	__mutex_fastpath_lock(&lock->count, __mutex_lock_slowpath);
  26. 	mutex_set_owner(lock);
  27. }
  28.  
  29. void __sched mutex_unlock(struct mutex *lock)
  30. {
  31. 	/*
  32. 	 * The unlocking fastpath is the 0->1 transition from 'locked'
  33. 	 * into 'unlocked' state:
  34. 	 */
  35. #ifndef CONFIG_DEBUG_MUTEXES
  36. 	/*
  37. 	 * When debugging is enabled we must not clear the owner before time,
  38. 	 * the slow path will always be taken, and that clears the owner field
  39. 	 * after verifying that it was indeed current.
  40. 	 */
  41. 	mutex_clear_owner(lock);
  42. #endif
  43. 	__mutex_fastpath_unlock(&lock->count, __mutex_unlock_slowpath);
  44. }
  45.  
  46. int __sched mutex_trylock(struct mutex *lock)
  47. {
  48. 	int ret;
  49.  
  50. 	ret = __mutex_fastpath_trylock(&lock->count, __mutex_trylock_slowpath);
  51. 	if (ret)
  52. 		mutex_set_owner(lock);
  53.  
  54. 	return ret;
  55. }
  56.  
  57. static inline int mutex_is_locked(struct mutex *lock)
  58. {
  59. 	return atomic_read(&lock->count) != 1;
  60. }
  61. int __sched mutex_lock_interruptible(struct mutex *lock)
  62. {
  63. 	int ret;
  64.  
  65. 	might_sleep();
  66. 	ret =  __mutex_fastpath_lock_retval(&lock->count);
  67. 	if (likely(!ret)) {
  68. 		mutex_set_owner(lock);
  69. 		return 0;
  70. 	} else
  71. 		return __mutex_lock_interruptible_slowpath(lock);
  72. }

互斥体的使用如下所示：

6.原子操作实验

        本节实验重点就是使用atomic 来实现一次只能允许一个应用访问 LED。

  1. #include <linux/types.h>
  2. #include <linux/kernel.h>
  3. #include <linux/delay.h>
  4. #include <linux/ide.h>
  5. #include <linux/init.h>
  6. #include <linux/module.h>
  7. #include <linux/errno.h>
  8. #include <linux/gpio.h>
  9. #include <linux/cdev.h>
  10. #include <linux/device.h>
  11. #include <linux/of.h>
  12. #include <linux/of_address.h>
  13. #include <linux/of_gpio.h>
  14. #include <asm/mach/map.h>
  15. #include <asm/uaccess.h>
  16. #include <asm/io.h>
  17.  
  18. #define GPIOLED_CNT			1		  	/* 设备号个数 */
  19. #define GPIOLED_NAME		"gpioled"	/* 名字 */
  20. #define LEDOFF 				0			/* 关灯 */
  21. #define LEDON 				1			/* 开灯 */
  22.  
  23.  
  24. /* gpioled设备结构体 */
  25. struct gpioled_dev{
  26. 	dev_t devid;			/* 设备号 	 */
  27. 	struct cdev cdev;		/* cdev 	*/
  28. 	struct class *class;	/* 类 		*/
  29. 	struct device *device;	/* 设备 	 */
  30. 	int major;				/* 主设备号	  */
  31. 	int minor;				/* 次设备号   */
  32. 	struct device_node	*nd; /* 设备节点 */
  33. 	int led_gpio;			/* led所使用的GPIO编号		*/
  34. 	atomic_t lock;			/* 原子变量 */
  35. };
  36.  
  37. struct gpioled_dev gpioled;	/* led设备 */
  38.  
  39. /*
  40.  * @description		: 打开设备
  41.  * @param - inode 	: 传递给驱动的inode
  42.  * @param - filp 	: 设备文件，file结构体有个叫做private_data的成员变量
  43.  * 					  一般在open的时候将private_data指向设备结构体。
  44.  * @return 			: 0 成功;其他 失败
  45.  */
  46. static int led_open(struct inode *inode, struct file *filp)
  47. {
  48. 	/* 通过判断原子变量的值来检查LED有没有被别的应用使用 */
  49. 	if (!atomic_dec_and_test(&gpioled.lock)) {
  50. 		atomic_inc(&gpioled.lock);	/* 小于0的话就加1,使其原子变量等于0 */
  51. 		return -EBUSY;				/* LED被使用，返回忙 */
  52. 	}
  53.  
  54. 	filp->private_data = &gpioled; /* 设置私有数据 */
  55. 	return 0;
  56. }
  57.  
  58. /*
  59.  * @description		: 从设备读取数据 
  60.  * @param - filp 	: 要打开的设备文件(文件描述符)
  61.  * @param - buf 	: 返回给用户空间的数据缓冲区
  62.  * @param - cnt 	: 要读取的数据长度
  63.  * @param - offt 	: 相对于文件首地址的偏移
  64.  * @return 			: 读取的字节数，如果为负值，表示读取失败
  65.  */
  66. static ssize_t led_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
  67. {
  68. 	return 0;
  69. }
  70.  
  71. /*
  72.  * @description		: 向设备写数据 
  73.  * @param - filp 	: 设备文件，表示打开的文件描述符
  74.  * @param - buf 	: 要写给设备写入的数据
  75.  * @param - cnt 	: 要写入的数据长度
  76.  * @param - offt 	: 相对于文件首地址的偏移
  77.  * @return 			: 写入的字节数，如果为负值，表示写入失败
  78.  */
  79. static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
  80. {
  81. 	int retvalue;
  82. 	unsigned char databuf[1];
  83. 	unsigned char ledstat;
  84. 	struct gpioled_dev *dev = filp->private_data;
  85.  
  86. 	retvalue = copy_from_user(databuf, buf, cnt);
  87. 	if(retvalue < 0) {
  88. 		printk("kernel write failed!\r\n");
  89. 		return -EFAULT;
  90. 	}
  91.  
  92. 	ledstat = databuf[0];		/* 获取状态值 */
  93.  
  94. 	if(ledstat == LEDON) {	
  95. 		gpio_set_value(dev->led_gpio, 0);	/* 打开LED灯 */
  96. 	} else if(ledstat == LEDOFF) {
  97. 		gpio_set_value(dev->led_gpio, 1);	/* 关闭LED灯 */
  98. 	}
  99. 	return 0;
  100. }
  101.  
  102. /*
  103.  * @description		: 关闭/释放设备
  104.  * @param - filp 	: 要关闭的设备文件(文件描述符)
  105.  * @return 			: 0 成功;其他 失败
  106.  */
  107. static int led_release(struct inode *inode, struct file *filp)
  108. {
  109. 	struct gpioled_dev *dev = filp->private_data;
  110.  
  111. 	/* 关闭驱动文件的时候释放原子变量 */
  112. 	atomic_inc(&dev->lock);
  113. 	return 0;
  114. }
  115.  
  116. /* 设备操作函数 */
  117. static struct file_operations gpioled_fops = {
  118. 	.owner = THIS_MODULE,
  119. 	.open = led_open,
  120. 	.read = led_read,
  121. 	.write = led_write,
  122. 	.release = 	led_release,
  123. };
  124.  
  125. /*
  126.  * @description	: 驱动入口函数
  127.  * @param 		: 无
  128.  * @return 		: 无
  129.  */
  130. static int __init led_init(void)
  131. {
  132. 	int ret = 0;
  133.  
  134. 	/* 初始化原子变量 */
  135. 	atomic_set(&gpioled.lock, 1);	/* 原子变量初始值为1 */
  136.  
  137. 	/* 设置LED所使用的GPIO */
  138. 	/* 1、获取设备节点：gpioled */
  139. 	gpioled.nd = of_find_node_by_path("/gpioled");
  140. 	if(gpioled.nd == NULL) {
  141. 		printk("gpioled node not find!\r\n");
  142. 		return -EINVAL;
  143. 	} else {
  144. 		printk("gpioled node find!\r\n");
  145. 	}
  146.  
  147. 	/* 2、 获取设备树中的gpio属性，得到LED所使用的LED编号 */
  148. 	gpioled.led_gpio = of_get_named_gpio(gpioled.nd, "led-gpio", 0);
  149. 	if(gpioled.led_gpio < 0) {
  150. 		printk("can't get led-gpio");
  151. 		return -EINVAL;
  152. 	}
  153. 	printk("led-gpio num = %d\r\n", gpioled.led_gpio);
  154.  
  155. 	/* 3、设置GPIO1_IO03为输出，并且输出高电平，默认关闭LED灯 */
  156. 	ret = gpio_direction_output(gpioled.led_gpio, 1);
  157. 	if(ret < 0) {
  158. 		printk("can't set gpio!\r\n");
  159. 	}
  160.  
  161. 	/* 注册字符设备驱动 */
  162. 	/* 1、创建设备号 */
  163. 	if (gpioled.major) {		/*  定义了设备号 */
  164. 		gpioled.devid = MKDEV(gpioled.major, 0);
  165. 		register_chrdev_region(gpioled.devid, GPIOLED_CNT, GPIOLED_NAME);
  166. 	} else {						/* 没有定义设备号 */
  167. 		alloc_chrdev_region(&gpioled.devid, 0, GPIOLED_CNT, GPIOLED_NAME);	/* 申请设备号 */
  168. 		gpioled.major = MAJOR(gpioled.devid);	/* 获取分配号的主设备号 */
  169. 		gpioled.minor = MINOR(gpioled.devid);	/* 获取分配号的次设备号 */
  170. 	}
  171. 	printk("gpioled major=%d,minor=%d\r\n",gpioled.major, gpioled.minor);	
  172. 	
  173. 	/* 2、初始化cdev */
  174. 	gpioled.cdev.owner = THIS_MODULE;
  175. 	cdev_init(&gpioled.cdev, &gpioled_fops);
  176. 	
  177. 	/* 3、添加一个cdev */
  178. 	cdev_add(&gpioled.cdev, gpioled.devid, GPIOLED_CNT);
  179.  
  180. 	/* 4、创建类 */
  181. 	gpioled.class = class_create(THIS_MODULE, GPIOLED_NAME);
  182. 	if (IS_ERR(gpioled.class)) {
  183. 		return PTR_ERR(gpioled.class);
  184. 	}
  185.  
  186. 	/* 5、创建设备 */
  187. 	gpioled.device = device_create(gpioled.class, NULL, gpioled.devid, NULL, GPIOLED_NAME);
  188. 	if (IS_ERR(gpioled.device)) {
  189. 		return PTR_ERR(gpioled.device);
  190. 	}
  191. 	
  192. 	return 0;
  193. }
  194.  
  195. /*
  196.  * @description	: 驱动出口函数
  197.  * @param 		: 无
  198.  * @return 		: 无
  199.  */
  200. static void __exit led_exit(void)
  201. {
  202. 	/* 注销字符设备驱动 */
  203. 	cdev_del(&gpioled.cdev);/*  删除cdev */
  204. 	unregister_chrdev_region(gpioled.devid, GPIOLED_CNT); /* 注销设备号 */
  205.  
  206. 	device_destroy(gpioled.class, gpioled.devid);
  207. 	class_destroy(gpioled.class);
  208. }
  209.  
  210. module_init(led_init);
  211. module_exit(led_exit);
  212. MODULE_LICENSE("GPL");
  213. MODULE_AUTHOR("wrw");

 7.自旋锁

  1. #include <linux/types.h>
  2. #include <linux/kernel.h>
  3. #include <linux/delay.h>
  4. #include <linux/ide.h>
  5. #include <linux/init.h>
  6. #include <linux/module.h>
  7. #include <linux/errno.h>
  8. #include <linux/gpio.h>
  9. #include <linux/cdev.h>
  10. #include <linux/device.h>
  11. #include <linux/of.h>
  12. #include <linux/of_address.h>
  13. #include <linux/of_gpio.h>
  14. #include <asm/mach/map.h>
  15. #include <asm/uaccess.h>
  16. #include <asm/io.h>
  17.  
  18. #define GPIOLED_CNT			1		  	/* 设备号个数 */
  19. #define GPIOLED_NAME		"gpioled"	/* 名字 */
  20. #define LEDOFF 				0			/* 关灯 */
  21. #define LEDON 				1			/* 开灯 */
  22.  
  23.  
  24. /* gpioled设备结构体 */
  25. struct gpioled_dev{
  26. 	dev_t devid;			/* 设备号 	 */
  27. 	struct cdev cdev;		/* cdev 	*/
  28. 	struct class *class;	/* 类 		*/
  29. 	struct device *device;	/* 设备 	 */
  30. 	int major;				/* 主设备号	  */
  31. 	int minor;				/* 次设备号   */
  32. 	struct device_node	*nd; /* 设备节点 */
  33. 	int led_gpio;			/* led所使用的GPIO编号		*/
  34. 	int dev_stats;			/* 设备使用状态，0，设备未使用;>0,设备已经被使用 */
  35. 	spinlock_t lock;		/* 自旋锁 */
  36. };
  37.  
  38. struct gpioled_dev gpioled;	/* led设备 */
  39.  
  40. /*
  41.  * @description		: 打开设备
  42.  * @param - inode 	: 传递给驱动的inode
  43.  * @param - filp 	: 设备文件，file结构体有个叫做private_data的成员变量
  44.  * 					  一般在open的时候将private_data指向设备结构体。
  45.  * @return 			: 0 成功;其他 失败
  46.  */
  47. static int led_open(struct inode *inode, struct file *filp)
  48. {
  49. 	unsigned long flags;
  50. 	filp->private_data = &gpioled; /* 设置私有数据 */
  51.  
  52. 	spin_lock_irqsave(&gpioled.lock, flags);	/* 上锁 */
  53. 	if (gpioled.dev_stats) {					/* 如果设备被使用了 */
  54. 		spin_unlock_irqrestore(&gpioled.lock, flags);/* 解锁 */
  55. 		return -EBUSY;
  56. 	}
  57. 	gpioled.dev_stats++;	/* 如果设备没有打开，那么就标记已经打开了 */
  58. 	spin_unlock_irqrestore(&gpioled.lock, flags);/* 解锁 */
  59.  
  60. 	return 0;
  61. }
  62.  
  63. /*
  64.  * @description		: 从设备读取数据 
  65.  * @param - filp 	: 要打开的设备文件(文件描述符)
  66.  * @param - buf 	: 返回给用户空间的数据缓冲区
  67.  * @param - cnt 	: 要读取的数据长度
  68.  * @param - offt 	: 相对于文件首地址的偏移
  69.  * @return 			: 读取的字节数，如果为负值，表示读取失败
  70.  */
  71. static ssize_t led_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
  72. {
  73. 	return 0;
  74. }
  75.  
  76. /*
  77.  * @description		: 向设备写数据 
  78.  * @param - filp 	: 设备文件，表示打开的文件描述符
  79.  * @param - buf 	: 要写给设备写入的数据
  80.  * @param - cnt 	: 要写入的数据长度
  81.  * @param - offt 	: 相对于文件首地址的偏移
  82.  * @return 			: 写入的字节数，如果为负值，表示写入失败
  83.  */
  84. static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
  85. {
  86. 	int retvalue;
  87. 	unsigned char databuf[1];
  88. 	unsigned char ledstat;
  89. 	struct gpioled_dev *dev = filp->private_data;
  90.  
  91. 	retvalue = copy_from_user(databuf, buf, cnt);
  92. 	if(retvalue < 0) {
  93. 		printk("kernel write failed!\r\n");
  94. 		return -EFAULT;
  95. 	}
  96.  
  97. 	ledstat = databuf[0];		/* 获取状态值 */
  98.  
  99. 	if(ledstat == LEDON) {	
  100. 		gpio_set_value(dev->led_gpio, 0);	/* 打开LED灯 */
  101. 	} else if(ledstat == LEDOFF) {
  102. 		gpio_set_value(dev->led_gpio, 1);	/* 关闭LED灯 */
  103. 	}
  104. 	return 0;
  105. }
  106.  
  107. /*
  108.  * @description		: 关闭/释放设备
  109.  * @param - filp 	: 要关闭的设备文件(文件描述符)
  110.  * @return 			: 0 成功;其他 失败
  111.  */
  112. static int led_release(struct inode *inode, struct file *filp)
  113. {
  114. 	unsigned long flags;
  115. 	struct gpioled_dev *dev = filp->private_data;
  116.  
  117. 	/* 关闭驱动文件的时候将dev_stats减1 */
  118. 	spin_lock_irqsave(&dev->lock, flags);	/* 上锁 */
  119. 	if (dev->dev_stats) {
  120. 		dev->dev_stats--;
  121. 	}
  122. 	spin_unlock_irqrestore(&dev->lock, flags);/* 解锁 */
  123.  
  124. 	return 0;
  125. }
  126.  
  127. /* 设备操作函数 */
  128. static struct file_operations gpioled_fops = {
  129. 	.owner = THIS_MODULE,
  130. 	.open = led_open,
  131. 	.read = led_read,
  132. 	.write = led_write,
  133. 	.release = 	led_release,
  134. };
  135.  
  136. /*
  137.  * @description	: 驱动入口函数
  138.  * @param 		: 无
  139.  * @return 		: 无
  140.  */
  141. static int __init led_init(void)
  142. {
  143. 	int ret = 0;
  144.  
  145. 	/*  初始化自旋锁 */
  146. 	spin_lock_init(&gpioled.lock);
  147. 	
  148. 	/* 设置LED所使用的GPIO */
  149. 	/* 1、获取设备节点：gpioled */
  150. 	gpioled.nd = of_find_node_by_path("/gpioled");
  151. 	if(gpioled.nd == NULL) {
  152. 		printk("gpioled node not find!\r\n");
  153. 		return -EINVAL;
  154. 	} else {
  155. 		printk("gpioled node find!\r\n");
  156. 	}
  157.  
  158. 	/* 2、 获取设备树中的gpio属性，得到LED所使用的LED编号 */
  159. 	gpioled.led_gpio = of_get_named_gpio(gpioled.nd, "led-gpio", 0);
  160. 	if(gpioled.led_gpio < 0) {
  161. 		printk("can't get led-gpio");
  162. 		return -EINVAL;
  163. 	}
  164. 	printk("led-gpio num = %d\r\n", gpioled.led_gpio);
  165.  
  166. 	/* 3、设置GPIO1_IO03为输出，并且输出高电平，默认关闭LED灯 */
  167. 	ret = gpio_direction_output(gpioled.led_gpio, 1);
  168. 	if(ret < 0) {
  169. 		printk("can't set gpio!\r\n");
  170. 	}
  171.  
  172. 	/* 注册字符设备驱动 */
  173. 	/* 1、创建设备号 */
  174. 	if (gpioled.major) {		/*  定义了设备号 */
  175. 		gpioled.devid = MKDEV(gpioled.major, 0);
  176. 		register_chrdev_region(gpioled.devid, GPIOLED_CNT, GPIOLED_NAME);
  177. 	} else {						/* 没有定义设备号 */
  178. 		alloc_chrdev_region(&gpioled.devid, 0, GPIOLED_CNT, GPIOLED_NAME);	/* 申请设备号 */
  179. 		gpioled.major = MAJOR(gpioled.devid);	/* 获取分配号的主设备号 */
  180. 		gpioled.minor = MINOR(gpioled.devid);	/* 获取分配号的次设备号 */
  181. 	}
  182. 	printk("gpioled major=%d,minor=%d\r\n",gpioled.major, gpioled.minor);	
  183. 	
  184. 	/* 2、初始化cdev */
  185. 	gpioled.cdev.owner = THIS_MODULE;
  186. 	cdev_init(&gpioled.cdev, &gpioled_fops);
  187. 	
  188. 	/* 3、添加一个cdev */
  189. 	cdev_add(&gpioled.cdev, gpioled.devid, GPIOLED_CNT);
  190.  
  191. 	/* 4、创建类 */
  192. 	gpioled.class = class_create(THIS_MODULE, GPIOLED_NAME);
  193. 	if (IS_ERR(gpioled.class)) {
  194. 		return PTR_ERR(gpioled.class);
  195. 	}
  196.  
  197. 	/* 5、创建设备 */
  198. 	gpioled.device = device_create(gpioled.class, NULL, gpioled.devid, NULL, GPIOLED_NAME);
  199. 	if (IS_ERR(gpioled.device)) {
  200. 		return PTR_ERR(gpioled.device);
  201. 	}
  202. 	
  203. 	return 0;
  204. }
  205.  
  206. /*
  207.  * @description	: 驱动出口函数
  208.  * @param 		: 无
  209.  * @return 		: 无
  210.  */
  211. static void __exit led_exit(void)
  212. {
  213. 	/* 注销字符设备驱动 */
  214. 	cdev_del(&gpioled.cdev);/*  删除cdev */
  215. 	unregister_chrdev_region(gpioled.devid, GPIOLED_CNT); /* 注销设备号 */
  216.  
  217. 	device_destroy(gpioled.class, gpioled.devid);
  218. 	class_destroy(gpioled.class);
  219. }
  220.  
  221. module_init(led_init);
  222. module_exit(led_exit);
  223. MODULE_LICENSE("GPL");
  224. MODULE_AUTHOR("WRW");

8.信号量

  1. #include <linux/types.h>
  2. #include <linux/kernel.h>
  3. #include <linux/delay.h>
  4. #include <linux/ide.h>
  5. #include <linux/init.h>
  6. #include <linux/module.h>
  7. #include <linux/errno.h>
  8. #include <linux/gpio.h>
  9. #include <linux/cdev.h>
  10. #include <linux/device.h>
  11. #include <linux/of.h>
  12. #include <linux/of_address.h>
  13. #include <linux/of_gpio.h>
  14. #include <linux/semaphore.h>
  15. #include <asm/mach/map.h>
  16. #include <asm/uaccess.h>
  17. #include <asm/io.h>
  18.  
  19. #define GPIOLED_CNT			1		  	/* 设备号个数 */
  20. #define GPIOLED_NAME		"gpioled"	/* 名字 */
  21. #define LEDOFF 				0			/* 关灯 */
  22. #define LEDON 				1			/* 开灯 */
  23.  
  24.  
  25. /* gpioled设备结构体 */
  26. struct gpioled_dev{
  27. 	dev_t devid;			/* 设备号 	 */
  28. 	struct cdev cdev;		/* cdev 	*/
  29. 	struct class *class;	/* 类 		*/
  30. 	struct device *device;	/* 设备 	 */
  31. 	int major;				/* 主设备号	  */
  32. 	int minor;				/* 次设备号   */
  33. 	struct device_node	*nd; /* 设备节点 */
  34. 	int led_gpio;			/* led所使用的GPIO编号		*/
  35. 	struct semaphore sem;	/* 信号量 */
  36. };
  37.  
  38. struct gpioled_dev gpioled;	/* led设备 */
  39.  
  40. /*
  41.  * @description		: 打开设备
  42.  * @param - inode 	: 传递给驱动的inode
  43.  * @param - filp 	: 设备文件，file结构体有个叫做private_data的成员变量
  44.  * 					  一般在open的时候将private_data指向设备结构体。
  45.  * @return 			: 0 成功;其他 失败
  46.  */
  47. static int led_open(struct inode *inode, struct file *filp)
  48. {
  49. 	filp->private_data = &gpioled; /* 设置私有数据 */
  50.  
  51. 	/* 获取信号量 */
  52. 	if (down_interruptible(&gpioled.sem)) { /* 获取信号量,进入休眠状态的进程可以被信号打断 */
  53. 		return -ERESTARTSYS;
  54. 	}
  55. #if 0
  56. 	down(&gpioled.sem);		/* 不能被信号打断 */
  57. #endif
  58.  
  59. 	return 0;
  60. }
  61.  
  62. /*
  63.  * @description		: 从设备读取数据 
  64.  * @param - filp 	: 要打开的设备文件(文件描述符)
  65.  * @param - buf 	: 返回给用户空间的数据缓冲区
  66.  * @param - cnt 	: 要读取的数据长度
  67.  * @param - offt 	: 相对于文件首地址的偏移
  68.  * @return 			: 读取的字节数，如果为负值，表示读取失败
  69.  */
  70. static ssize_t led_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
  71. {
  72. 	return 0;
  73. }
  74.  
  75. /*
  76.  * @description		: 向设备写数据 
  77.  * @param - filp 	: 设备文件，表示打开的文件描述符
  78.  * @param - buf 	: 要写给设备写入的数据
  79.  * @param - cnt 	: 要写入的数据长度
  80.  * @param - offt 	: 相对于文件首地址的偏移
  81.  * @return 			: 写入的字节数，如果为负值，表示写入失败
  82.  */
  83. static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
  84. {
  85. 	int retvalue;
  86. 	unsigned char databuf[1];
  87. 	unsigned char ledstat;
  88. 	struct gpioled_dev *dev = filp->private_data;
  89.  
  90. 	retvalue = copy_from_user(databuf, buf, cnt);
  91. 	if(retvalue < 0) {
  92. 		printk("kernel write failed!\r\n");
  93. 		return -EFAULT;
  94. 	}
  95.  
  96. 	ledstat = databuf[0];		/* 获取状态值 */
  97.  
  98. 	if(ledstat == LEDON) {	
  99. 		gpio_set_value(dev->led_gpio, 0);	/* 打开LED灯 */
  100. 	} else if(ledstat == LEDOFF) {
  101. 		gpio_set_value(dev->led_gpio, 1);	/* 关闭LED灯 */
  102. 	}
  103. 	return 0;
  104. }
  105.  
  106. /*
  107.  * @description		: 关闭/释放设备
  108.  * @param - filp 	: 要关闭的设备文件(文件描述符)
  109.  * @return 			: 0 成功;其他 失败
  110.  */
  111. static int led_release(struct inode *inode, struct file *filp)
  112. {
  113. 	struct gpioled_dev *dev = filp->private_data;
  114.  
  115. 	up(&dev->sem);		/* 释放信号量，信号量值加1 */
  116.  
  117. 	return 0;
  118. }
  119.  
  120. /* 设备操作函数 */
  121. static struct file_operations gpioled_fops = {
  122. 	.owner = THIS_MODULE,
  123. 	.open = led_open,
  124. 	.read = led_read,
  125. 	.write = led_write,
  126. 	.release = 	led_release,
  127. };
  128.  
  129. /*
  130.  * @description	: 驱动入口函数
  131.  * @param 		: 无
  132.  * @return 		: 无
  133.  */
  134. static int __init led_init(void)
  135. {
  136. 	int ret = 0;
  137.  
  138. 	/* 初始化信号量 */
  139. 	sema_init(&gpioled.sem, 1);
  140. 	
  141. 	/* 设置LED所使用的GPIO */
  142. 	/* 1、获取设备节点：gpioled */
  143. 	gpioled.nd = of_find_node_by_path("/gpioled");
  144. 	if(gpioled.nd == NULL) {
  145. 		printk("gpioled node not find!\r\n");
  146. 		return -EINVAL;
  147. 	} else {
  148. 		printk("gpioled node find!\r\n");
  149. 	}
  150.  
  151. 	/* 2、 获取设备树中的gpio属性，得到LED所使用的LED编号 */
  152. 	gpioled.led_gpio = of_get_named_gpio(gpioled.nd, "led-gpio", 0);
  153. 	if(gpioled.led_gpio < 0) {
  154. 		printk("can't get led-gpio");
  155. 		return -EINVAL;
  156. 	}
  157. 	printk("led-gpio num = %d\r\n", gpioled.led_gpio);
  158.  
  159. 	/* 3、设置GPIO1_IO03为输出，并且输出高电平，默认关闭LED灯 */
  160. 	ret = gpio_direction_output(gpioled.led_gpio, 1);
  161. 	if(ret < 0) {
  162. 		printk("can't set gpio!\r\n");
  163. 	}
  164.  
  165. 	/* 注册字符设备驱动 */
  166. 	/* 1、创建设备号 */
  167. 	if (gpioled.major) {		/*  定义了设备号 */
  168. 		gpioled.devid = MKDEV(gpioled.major, 0);
  169. 		register_chrdev_region(gpioled.devid, GPIOLED_CNT, GPIOLED_NAME);
  170. 	} else {						/* 没有定义设备号 */
  171. 		alloc_chrdev_region(&gpioled.devid, 0, GPIOLED_CNT, GPIOLED_NAME);	/* 申请设备号 */
  172. 		gpioled.major = MAJOR(gpioled.devid);	/* 获取分配号的主设备号 */
  173. 		gpioled.minor = MINOR(gpioled.devid);	/* 获取分配号的次设备号 */
  174. 	}
  175. 	printk("gpioled major=%d,minor=%d\r\n",gpioled.major, gpioled.minor);	
  176. 	
  177. 	/* 2、初始化cdev */
  178. 	gpioled.cdev.owner = THIS_MODULE;
  179. 	cdev_init(&gpioled.cdev, &gpioled_fops);
  180. 	
  181. 	/* 3、添加一个cdev */
  182. 	cdev_add(&gpioled.cdev, gpioled.devid, GPIOLED_CNT);
  183.  
  184. 	/* 4、创建类 */
  185. 	gpioled.class = class_create(THIS_MODULE, GPIOLED_NAME);
  186. 	if (IS_ERR(gpioled.class)) {
  187. 		return PTR_ERR(gpioled.class);
  188. 	}
  189.  
  190. 	/* 5、创建设备 */
  191. 	gpioled.device = device_create(gpioled.class, NULL, gpioled.devid, NULL, GPIOLED_NAME);
  192. 	if (IS_ERR(gpioled.device)) {
  193. 		return PTR_ERR(gpioled.device);
  194. 	}
  195. 	
  196. 	return 0;
  197. }
  198.  
  199. /*
  200.  * @description	: 驱动出口函数
  201.  * @param 		: 无
  202.  * @return 		: 无
  203.  */
  204. static void __exit led_exit(void)
  205. {
  206. 	/* 注销字符设备驱动 */
  207. 	cdev_del(&gpioled.cdev);/*  删除cdev */
  208. 	unregister_chrdev_region(gpioled.devid, GPIOLED_CNT); /* 注销设备号 */
  209.  
  210. 	device_destroy(gpioled.class, gpioled.devid);
  211. 	class_destroy(gpioled.class);
  212. }
  213.  
  214. module_init(led_init);
  215. module_exit(led_exit);
  216. MODULE_LICENSE("GPL");
  217. MODULE_AUTHOR("wrw");

9.互斥体

  1. #include <linux/types.h>
  2. #include <linux/kernel.h>
  3. #include <linux/delay.h>
  4. #include <linux/ide.h>
  5. #include <linux/init.h>
  6. #include <linux/module.h>
  7. #include <linux/errno.h>
  8. #include <linux/gpio.h>
  9. #include <linux/cdev.h>
  10. #include <linux/device.h>
  11. #include <linux/of.h>
  12. #include <linux/of_address.h>
  13. #include <linux/of_gpio.h>
  14. #include <linux/semaphore.h>
  15. #include <asm/mach/map.h>
  16. #include <asm/uaccess.h>
  17. #include <asm/io.h>
  18.  
  19. #define GPIOLED_CNT			1		  	/* 设备号个数 */
  20. #define GPIOLED_NAME		"gpioled"	/* 名字 */
  21. #define LEDOFF 				0			/* 关灯 */
  22. #define LEDON 				1			/* 开灯 */
  23.  
  24.  
  25. /* gpioled设备结构体 */
  26. struct gpioled_dev{
  27. 	dev_t devid;			/* 设备号 	 */
  28. 	struct cdev cdev;		/* cdev 	*/
  29. 	struct class *class;	/* 类 		*/
  30. 	struct device *device;	/* 设备 	 */
  31. 	int major;				/* 主设备号	  */
  32. 	int minor;				/* 次设备号   */
  33. 	struct device_node	*nd; /* 设备节点 */
  34. 	int led_gpio;			/* led所使用的GPIO编号		*/
  35. 	struct mutex lock;		/* 互斥体 */
  36. };
  37.  
  38. struct gpioled_dev gpioled;	/* led设备 */
  39.  
  40. /*
  41.  * @description		: 打开设备
  42.  * @param - inode 	: 传递给驱动的inode
  43.  * @param - filp 	: 设备文件，file结构体有个叫做private_data的成员变量
  44.  * 					  一般在open的时候将private_data指向设备结构体。
  45.  * @return 			: 0 成功;其他 失败
  46.  */
  47. static int led_open(struct inode *inode, struct file *filp)
  48. {
  49. 	filp->private_data = &gpioled; /* 设置私有数据 */
  50.  
  51. 	/* 获取互斥体,可以被信号打断 */
  52. 	if (mutex_lock_interruptible(&gpioled.lock)) {
  53. 		return -ERESTARTSYS;
  54. 	}
  55. #if 0
  56. 	mutex_lock(&gpioled.lock);	/* 不能被信号打断 */
  57. #endif
  58.  
  59. 	return 0;
  60. }
  61.  
  62. /*
  63.  * @description		: 从设备读取数据 
  64.  * @param - filp 	: 要打开的设备文件(文件描述符)
  65.  * @param - buf 	: 返回给用户空间的数据缓冲区
  66.  * @param - cnt 	: 要读取的数据长度
  67.  * @param - offt 	: 相对于文件首地址的偏移
  68.  * @return 			: 读取的字节数，如果为负值，表示读取失败
  69.  */
  70. static ssize_t led_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
  71. {
  72. 	return 0;
  73. }
  74.  
  75. /*
  76.  * @description		: 向设备写数据 
  77.  * @param - filp 	: 设备文件，表示打开的文件描述符
  78.  * @param - buf 	: 要写给设备写入的数据
  79.  * @param - cnt 	: 要写入的数据长度
  80.  * @param - offt 	: 相对于文件首地址的偏移
  81.  * @return 			: 写入的字节数，如果为负值，表示写入失败
  82.  */
  83. static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
  84. {
  85. 	int retvalue;
  86. 	unsigned char databuf[1];
  87. 	unsigned char ledstat;
  88. 	struct gpioled_dev *dev = filp->private_data;
  89.  
  90. 	retvalue = copy_from_user(databuf, buf, cnt);
  91. 	if(retvalue < 0) {
  92. 		printk("kernel write failed!\r\n");
  93. 		return -EFAULT;
  94. 	}
  95.  
  96. 	ledstat = databuf[0];		/* 获取状态值 */
  97.  
  98. 	if(ledstat == LEDON) {	
  99. 		gpio_set_value(dev->led_gpio, 0);	/* 打开LED灯 */
  100. 	} else if(ledstat == LEDOFF) {
  101. 		gpio_set_value(dev->led_gpio, 1);	/* 关闭LED灯 */
  102. 	}
  103. 	return 0;
  104. }
  105.  
  106. /*
  107.  * @description		: 关闭/释放设备
  108.  * @param - filp 	: 要关闭的设备文件(文件描述符)
  109.  * @return 			: 0 成功;其他 失败
  110.  */
  111. static int led_release(struct inode *inode, struct file *filp)
  112. {
  113. 	struct gpioled_dev *dev = filp->private_data;
  114.  
  115. 	/* 释放互斥锁 */
  116. 	mutex_unlock(&dev->lock);
  117.  
  118. 	return 0;
  119. }
  120.  
  121. /* 设备操作函数 */
  122. static struct file_operations gpioled_fops = {
  123. 	.owner = THIS_MODULE,
  124. 	.open = led_open,
  125. 	.read = led_read,
  126. 	.write = led_write,
  127. 	.release = 	led_release,
  128. };
  129.  
  130. /*
  131.  * @description	: 驱动入口函数
  132.  * @param 		: 无
  133.  * @return 		: 无
  134.  */
  135. static int __init led_init(void)
  136. {
  137. 	int ret = 0;
  138.  
  139. 	/* 初始化互斥体 */
  140. 	mutex_init(&gpioled.lock);
  141. 	
  142. 	/* 设置LED所使用的GPIO */
  143. 	/* 1、获取设备节点：gpioled */
  144. 	gpioled.nd = of_find_node_by_path("/gpioled");
  145. 	if(gpioled.nd == NULL) {
  146. 		printk("gpioled node not find!\r\n");
  147. 		return -EINVAL;
  148. 	} else {
  149. 		printk("gpioled node find!\r\n");
  150. 	}
  151.  
  152. 	/* 2、 获取设备树中的gpio属性，得到LED所使用的LED编号 */
  153. 	gpioled.led_gpio = of_get_named_gpio(gpioled.nd, "led-gpio", 0);
  154. 	if(gpioled.led_gpio < 0) {
  155. 		printk("can't get led-gpio");
  156. 		return -EINVAL;
  157. 	}
  158. 	printk("led-gpio num = %d\r\n", gpioled.led_gpio);
  159.  
  160. 	/* 3、设置GPIO1_IO03为输出，并且输出高电平，默认关闭LED灯 */
  161. 	ret = gpio_direction_output(gpioled.led_gpio, 1);
  162. 	if(ret < 0) {
  163. 		printk("can't set gpio!\r\n");
  164. 	}
  165.  
  166. 	/* 注册字符设备驱动 */
  167. 	/* 1、创建设备号 */
  168. 	if (gpioled.major) {		/*  定义了设备号 */
  169. 		gpioled.devid = MKDEV(gpioled.major, 0);
  170. 		register_chrdev_region(gpioled.devid, GPIOLED_CNT, GPIOLED_NAME);
  171. 	} else {						/* 没有定义设备号 */
  172. 		alloc_chrdev_region(&gpioled.devid, 0, GPIOLED_CNT, GPIOLED_NAME);	/* 申请设备号 */
  173. 		gpioled.major = MAJOR(gpioled.devid);	/* 获取分配号的主设备号 */
  174. 		gpioled.minor = MINOR(gpioled.devid);	/* 获取分配号的次设备号 */
  175. 	}
  176. 	printk("gpioled major=%d,minor=%d\r\n",gpioled.major, gpioled.minor);	
  177. 	
  178. 	/* 2、初始化cdev */
  179. 	gpioled.cdev.owner = THIS_MODULE;
  180. 	cdev_init(&gpioled.cdev, &gpioled_fops);
  181. 	
  182. 	/* 3、添加一个cdev */
  183. 	cdev_add(&gpioled.cdev, gpioled.devid, GPIOLED_CNT);
  184.  
  185. 	/* 4、创建类 */
  186. 	gpioled.class = class_create(THIS_MODULE, GPIOLED_NAME);
  187. 	if (IS_ERR(gpioled.class)) {
  188. 		return PTR_ERR(gpioled.class);
  189. 	}
  190.  
  191. 	/* 5、创建设备 */
  192. 	gpioled.device = device_create(gpioled.class, NULL, gpioled.devid, NULL, GPIOLED_NAME);
  193. 	if (IS_ERR(gpioled.device)) {
  194. 		return PTR_ERR(gpioled.device);
  195. 	}
  196. 	
  197. 	return 0;
  198. }
  199.  
  200. /*
  201.  * @description	: 驱动出口函数
  202.  * @param 		: 无
  203.  * @return 		: 无
  204.  */
  205. static void __exit led_exit(void)
  206. {
  207. 	/* 注销字符设备驱动 */
  208. 	cdev_del(&gpioled.cdev);/*  删除cdev */
  209. 	unregister_chrdev_region(gpioled.devid, GPIOLED_CNT); /* 注销设备号 */
  210.  
  211. 	device_destroy(gpioled.class, gpioled.devid);
  212. 	class_destroy(gpioled.class);
  213. }
  214.  
  215. module_init(led_init);
  216. module_exit(led_exit);
  217. MODULE_LICENSE("GPL");
  218. MODULE_AUTHOR("wrw");

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

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

  

闽ICP备14008679号