10.20 platform总线驱动

platform总线驱动

a.应用程序通过阻塞的io模型来读取number变量的值
b.number是内核驱动中的一个变量
c.number的值随着按键按下而改变（按键中断） 例如number=0 按下按键number=1 ,再次按下按键number=0
d.在按下按键的时候需要同时将led1的状态取反
e.驱动中需要编写字符设备驱动
f.驱动中需要自动创建设备节点
g.这个驱动需要的所有设备信息放在设备树的同一个节点中

实现代码

pdrv.c

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define CNAME "myled"
#include "myled.h"

int minor = 0; //次设备号从0开始
#if 0
unsigned int major = 0;//动态申请
#else
unsigned int major = 500; //静态指定设备号
#endif
char kbuf[128] = {}; //定义数组用于存放和用户之间拷贝的数据
struct cdev *cdev;
struct class *cls;
struct device *dev;

const int count = 3; //指定设备节点的个数为3
//定义队列头
wait_queue_head_t wq_head;
unsigned int condition = 0; //判断是否有数据准备好的标识变量

int gpiono1;
int number = 0;
struct property *pr; //属性结构体指针
struct device_node *node;
unsigned int irqno; //接收软中断号
struct work_struct work;

struct resource *res;
struct gpio_desc *desc;

struct resource *res;
struct gpio_desc *desc;

//对应的是open()
int mycdev_open(struct inode *inode, struct file *file)
{

      printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
      return 0;
}

//底半部中断处理函数
void work_func(struct work_struct *w)
{
      if (number == 1)
      {
            //点亮led1
            gpio_set_value(gpiono1, 0);
            number = 0;
      }
      else if (number == 0)
      {
            //点亮led1
            gpio_set_value(gpiono1, 1);
            number = 1;
      }
      condition = 1;
      wake_up_interruptible(&wq_head);
}
//中断处理函数
irqreturn_t irq_handler(int irq, void *dev)
{
      //启用底半部中断处理
      schedule_work(&work);
      return IRQ_HANDLED;
}

// read()
ssize_t mycdev_read(struct file *file, char __user *ubuf, size_t size, loff_t *loff)
{

      // size参数是用户期待读到的字节长度
      int ret;
      if (file->f_flags & O_NONBLOCK)
      {
            //非阻塞
            return -EINVAL;
      }
      else
      {
            //阻塞
            ret = wait_event_interruptible(wq_head, condition);
            if (ret)
            {
                  printk("接收阻塞休眠\n");
                  return ret;
            }
      }
      //把父进程拷贝到内核的数据再拷贝给子进程
      if (size > sizeof(number))
            size = sizeof(number);
      ret = copy_to_user(ubuf, &number, size);
      if (ret)
      {
            printk("数据从内核向用户拷贝失败\n");
            return -EIO;
      }
      // condition=0;
      condition = 0;

      return size;
}

// write()
ssize_t mycdev_write(struct file *file, const char __user *ubuf, size_t size, loff_t *loff)
{
      int ret;
      if (size > sizeof(kbuf))
            size = sizeof(kbuf);
      ret = copy_from_user(kbuf, ubuf, size);
      if (ret)
      {
            printk("数据从内核向用户拷贝失败\n");
            return -EIO;
      }
      //唤醒
      condition = 1;
      wake_up_interruptible(&wq_head);

      return size;
}

int mycdev_close(struct inode *inode, struct file *file)
{
      printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
      return 0;
}
//操作方法结构体的初始化
struct file_operations fops =
    {
        .open = mycdev_open,
        .read = mycdev_read,
        .release = mycdev_close,
        .write = mycdev_write,
};

int pdrv_probe(struct platform_device *pdr)
{
      //获取设备信息
      printk("%s:%d\n", __FILE__, __LINE__);
      res = platform_get_resource(pdr, IORESOURCE_MEM, 0);
      if (res == NULL)
      {
            printk("获取资源失败\n");
            return -ENODATA;
      }
      irqno = platform_get_irq(pdr, 0);
      if (irqno < 0)
      {
            printk("获取资源失败\n");
            return irqno;
      }
      printk("%#x    %d\n", res->start, irqno);

      return 0;
}
int pdrv_remove(struct platform_device *pdr)
{
      printk("%s:%d\n", __FILE__, __LINE__);
      return 0;
}
//定义compatible表
struct of_device_id oftable[] = {
    {.compatible = "hqyj,hello"},
    {},
};
MODULE_DEVICE_TABLE(of, oftable);
//定义并初始化对象
struct platform_driver pdrv = {
    .probe = pdrv_probe,
    .remove = pdrv_remove,
    .driver = {
        .name = "test",
        .of_match_table = oftable, //设备树匹配
    },
};
static int __init mycdev_init(void)
{
      int ret, i;

      //分配对象
      dev_t devno;

      //注册对象
      platform_driver_register(&pdrv);

      cdev = cdev_alloc();
      if (cdev == NULL)
      {
            printk("cdev alloc memory err\n");

            ret = -ENOMEM;
            goto ERR1;
      }
      printk("对象分配成功\n");
      //对象的初始化
      cdev_init(cdev, &fops);
      //设备号的申请

      if (major == 0) //动态申请
      {
            ret = alloc_chrdev_region(&devno, minor, count, "my_led");
            if (ret)
            {
                  printk("动态申请设备号失败\n");
                  goto ERR2;
            }
            major = MAJOR(devno);
            minor = MINOR(devno);
            printk("动态申请设备号成功\n");
      }
      else
      {
            ret = register_chrdev_region(MKDEV(major, minor), count, "my_led");
            if (ret)
            {
                  printk("静态申请设备号失败\n");
                  goto ERR2;
            }
            printk("静态申请设备号成功\n");
      }
      //注册字符设备驱动
      ret = cdev_add(cdev, MKDEV(major, minor), count);
      if (ret)
      {
            printk("字符设备驱动注册失败\n");
            goto ERR3;
      }
      printk("注册字符设备驱动成功\n");

      //自动创建设备节点
      cls = class_create(THIS_MODULE, "led");
      if (IS_ERR(cls))
      {
            printk("创建逻辑节点目录失败\n");
            ret = PTR_ERR(cls);
            goto ERR4;
      }
      printk("创建逻辑节点目录成功\n");
      //向上提交节点信息
      for (i = 0; i < 3; i++)
      {
            dev = device_create(cls, NULL, MKDEV(major, i), NULL, "my_led%d", i);
            if (IS_ERR(dev))
            {
                  printk("创建逻辑节点失败\n");
                  ret = PTR_ERR(dev);
                  goto ERR5;
            }
      }
      printk("创建逻辑节点成功\n");
      //初始化队列头
      init_waitqueue_head(&wq_head);

      //工作队列初始化
      INIT_WORK(&work, work_func);
      //解析设备树节点
      node = of_find_node_by_name(NULL, "myirq");
      if (node == NULL)
      {
            printk("解析设备树节点失败\n");
            return EAGAIN;
      }
      printk("解析设备树节点成功\n");
      //根据设备树节点获取软中断号
      irqno = irq_of_parse_and_map(node, 0);
      if (irqno == 0)
      {
            printk("获取软中断号失败\n");
            return EINVAL;
      }
      printk("获取软中断号成功\n");
      //注册中断
      ret = request_irq(irqno, irq_handler, IRQF_TRIGGER_FALLING, "key2_inte", NULL);
      if (ret)
      {
            printk("注册中断失败\n");
            return ret;
      }
      printk("注册中断成功\n");
      //获取gpio编号
      gpiono1 = of_get_named_gpio(node, "led1", 0);
      if (gpiono1 < 0)
      {
            printk("获取led1编号失败\n");
            return gpiono1;
      }
      printk("获取led1编号成功\n");
      //申请gpio编号使用权
      ret = gpio_request(gpiono1, NULL);
      if (ret)
      {
            printk("申请设备编号失败\n");
            return ret;
      }
      //设置输出方式
      gpio_direction_output(gpiono1, 0);

      return 0;
ERR5:
      for (--i; i >= 0; i--)
      {
            device_destroy(cls, MKDEV(major, i));
      }
      class_destroy(cls);
ERR4:
      cdev_del(cdev);
ERR3:
      unregister_chrdev_region(MKDEV(major, minor), count);
ERR2:
      kfree(cdev);
ERR1:
      return ret;
}
static void __exit mycdev_exit(void)
{
      // 1.销毁设备节点
      int i;
      for (i = 0; i < count; i++)
      {
            device_destroy(cls, MKDEV(major, i));
      }
      class_destroy(cls);
      // 2.注销字符设备驱动
      cdev_del(cdev);
      // 3.释放设备号
      unregister_chrdev_region(MKDEV(major, minor), count);
      // 4.释放动态申请的空间
      kfree(cdev);
      //注销中断
      free_irq(irqno, NULL);

      //释放设备号
      gpio_set_value(gpiono1, 0);
      gpio_free(gpiono1);

      //释放GPIO编号
      gpiod_direction_output(desc, 0);
      gpiod_put(desc);

      //注销
      platform_driver_unregister(&pdrv);
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364

Makefile

modname ?= demo
arch ?= arm

ifeq ($(arch),arm)#arm架构
KERNELDIR := /home/ubuntu/fsmp1a/linux-stm32mp-5.10.61-stm32mp-r2-r0/linux-5.10.61
else  
KERNELDIR := /lib/modules/$(shell uname -r)/build #当前x86架构格式路径
#KERNELDIR是一个变量，指向内核源码目录
endif
PWD:=$(shell pwd)
#PWD指向当前驱动目录的一个变量

all:
	make -C $(KERNELDIR) M=$(PWD) modules
#make -C $(KERNELDIR)
#进入内核顶层目录下，读取对应的Makefile文件，然后执行make
# M=$(PWD)  :指定编译模块的路径为当前驱动路径
#make modules:模块化编译
#进入内核顶层目录使用其中的Makefile对当前文件进行模块化编译

clean:
	make -C $(KERNELDIR) M=$(PWD) clean
#清除编译

obj-m:=$(modname).o
#指定当前编译生成的模块名字为demo   demo.c==>demo.ko
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

test.c

#include
#include
#include
#include
#include
#include
#include
 #include 
#include 
#include"myled.h"
 
int main(int argc, char const *argv[])
{
   pid_t pid;
   int number=0;
   int count = 10;
   int fd=open("/dev/my_led0",O_RDWR);
   if(fd<0)
   {
    printf("设备文件打开失败\n");
    exit(-1);
   }
    while(1)
    {
        //write(fd,&number,sizeof(number));
        read(fd,&number,sizeof(number));
        printf("number:%d\n",number);
    }
    exit(0);
   
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

设备树节点

myplatform{
          compatible="hqyj,hello2";
          //填写内存地址
          reg = <0x12345678 0x14>;
          //填写中断
          interrupt-parent=<&gpiof>;
          interrupts=<9 0>,<7 0>,<8 0>;   
          led1 = <&gpioe 10 0>;
          led2 = <&gpiof 10 0>;
          led3 = <&gpioe 8 0>;
      };
1
2
3
4
5
6
7
8
9
10
11

运行结果

终端运行make modname=pdrv arch=arm，生成pdrv.ko
终端运行arm-linux-gnueabihf-gcc test.c，生成a.out
将这两个文件复制到~/nfs/rootfs/下
在串口工具中下载驱动并运行a.out