////与虚拟机用网卡通信 ping 192.168.44.194 if pxe get; then pxe boot; fi //添加编译工具 3> 导入sdk linux@ubuntu:~/farsight/sdk$ source /opt/stm32_sdk/environment-setup-cortexa7t2hf-neon-vfpv4-ostl-linux-gnueabi 

struct stm32mp157{ 
        
	int major;//主设备号
	struct class * clazz;//类
	struct device * dev;//数据节点
	gpio_t * gpioz;
	gpio_t * gpioe;
	rcc_t *rcc;
};
struct stm32mp157 * stm32_led;
--------------------------------------------------
//获取次设备号的方法,在ssize_t led_write(struct file * filp, const char __user * buff, size_t count, loff_t * pos)
	int minor;
	struct inode * node;
	node = filp->f_path.dentry->d_inode;
	minor = iminor(node);//获得次设备号
--------------------------------------------------
//打开锁相环
  	key->rcc->PLL4CR|= (1<<0);
//等待锁相环进入ready状态
	while((key->rcc->PLL4CR & (1<<1)) == 0);
	key->rcc->MP_AHB4ENSETR |= (1 << 5);
	return 0; 

struct resource * res1;
struct resource * res2;

zhangsan:stm32mp157_led@54004000 { 
        
        compatible = "stm32mp157,led_test";
        reg = <0x50005400 0x400 0x50000000 0x1000>;
        shen_name = "daoge","farsight";
        age = <33>;
        ages = <33 44>, <55 66>;
        test = [06 06 06];
        special{ 
        
           spec = "linux";
       };

ps:在应用程序(app)操作之前，内核里的驱动层和设备层就已经匹配完毕。应用层只是调用匹配完后的内核里的接口。进程只是应用层里的概念，而这些进程公用驱动层的一套程序而已。

struct resource led_main[] = { 
        
	[0] = { 
        
		.start = RCC_S,
		.end = RCC_P,
		.name = "led_main_rcc",
		.flags = IORESOURCE_MEM,
	},
	[1] = { 
        
		.start = GPIOZ_S,
		.end = GPIOZ_P,	
		.name = "led_main_gpio",
		.flags = IORESOURCE_MEM,
	},
	//========以下为测试=========
	[2] = { 
        
		.start = 11,
		.end = 11,	
		.name = "led_main_irq",
		.flags = IORESOURCE_IRQ,
	},
};
struct platform_device pdev_main=
{ 
        
	.name = "led_main",
	.id = -1,
	.dev = { 
        
		.release = led_dev_release,
	},
	.num_resources = ARRAY_SIZE(led_main),//资源的个数,ARRAY_SIZE(数组)计算数组长度
	.resource = led_main,//资源(地址，中断)
};

res1 = platform_get_resource(pdev, IORESOURCE_MEM, 0);
//参数2为资源类别，参数3为以该资源类的下标(从0开始)

//根据给的属性名去找属性并返回对应的值
shen_name = (char *)of_get_property(pdev->dev.of_node, "shen_name", &lenp);
//带参宏，定义如下
/*#define of_property_for_each_string(np, propname, prop, s) \ for (prop = of_find_property(np, propname, NULL), \ s = of_prop_next_string(prop, NULL); \ s; \ s = of_prop_next_string(prop, s)) */
//该函数会遍历属性数组"shen_name"，把每个读到的内容存到s
of_property_for_each_string(pdev->dev.of_node, "shen_name", prop, s)
{ 
        
	printk("s=%s\n",s);
}
//计算该属性有几个元素
lenp = of_property_count_u32_elems(pdev->dev.of_node, "ages");
//从属性读取一个32位数组的值,返回值放out_value数组里，参数4为读取的个数，其他类似
of_property_read_u32_array(pdev->dev.of_node, "ages", out_value,4);
of_property_read_string_helper(pdev->dev.of_node,"shen_name",&shen_name, 2, 1);
of_property_read_u32(pdev->dev.of_node, "age", &value);
of_property_read_u8_array(pdev->dev.of_node, "test", data, 3);
node = of_find_node_by_name(pdev->dev.of_node, "special");
of_property_read_string(node,"spec",&special);

struct stm32mp157{ 
        
        int major;
        struct class * clazz;
        struct device * dev;
        int gpioz_5;
        int gpioz_6;
        int gpioz_7;
};

stm32mp157_led_test{ 
        //设置引脚有效电平
          compatible = "stm32mp157,led_test2";
          led-gpios = <&gpioz 5 GPIO_ACTIVE_HIGH>,
                  <&gpioz 6 GPIO_ACTIVE_HIGH>,
                  <&gpioz 7 GPIO_ACTIVE_HIGH>;
      };

方法1:
//物理地址转化成虚拟地址
stm32_led->gpioz = ioremap(res3->start, resource_size(res3));
//获得GPIO号
stm32_led->gpioz_5 = of_get_gpio(pdev->dev.of_node, 0);
	if(stm32_led->gpioz_5 < 0)
	{ 
        
		ret = stm32_led->gpioz_5;
		printk("of_get_gpio error1\n");
		goto device_create_err;
	}
//请求操作GPIO权限
    ret = gpio_request(stm32_led->gpioz_5, "led1");
	if(ret < 0)
	{ 
        
		printk("gpio_request error1\n");
		goto device_create_err;
	}
//设置GPIO输出，低电平
	gpio_direction_output(stm32_led->gpioz_5, 0);
//释放GPIO
	gpio_free(stm32_led->gpioz_5);
方法2:
//物理地址转化成虚拟地址
stm32_led->gpioz = ioremap(res3->start, resource_size(res3));
//获得GPIO号(使用devm前缀不用自己释放)
stm32_led->led1 = devm_gpiod_get_index(&pdev->dev,"led",0,GPIOD_OUT_HIGH);
//设置引脚为输出模式，且初始值value为0
gpiod_direction_output(stm32_led->led1,0);
//改变电平的值
gpiod_set_value(stm32_led->led1,1);

/*struct miscdevice {//杂项驱动结构体的major默认是10 int minor; const char *name; const struct file_operations *fops; struct list_head list; struct device *parent; struct device *this_device; const struct attribute_group **groups; const char *nodename; umode_t mode; };*/
struct miscdevice misc = { 
        
	.minor = 199,
	.name = "key_drv",
	.fops = &key_fops,
};

ret = misc_register(&misc);
	if(ret < 0)
	{
		printk("misc_register error\n");
		goto kzalloc_err2;
	}

//外设结构体
struct key_info{
    //按键地名称
    char name[10];
	//按键的ID
	int id;
	//按键中断号
	int irq_no;
	//按键的值
	int value;
	//触发方式
	int flag;
};
//自动获取外设结构体并赋值和注册中断
for(i = 0; i < pdev->num_resources; i++)
	{
	    sprintf(key->info[i].name, "KEY_%d", i+1);
		key->info[i].id = i+1;
		key->info[i].flag = IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING;//中断判定方式
		key->info[i].irq_no = platform_get_irq(pdev, i);//从设备树获取设备号
		ret = request_irq(key->info[i].irq_no, key_drv_handler, key->info[i].flag, key->info[i].name, &key->info[i]);
		if(ret < 0)
		{
			printk("request_irq error\n");
			goto misc_register_err;
		}
	}
request_irq	中断注册函数
//参数1:虚拟中断号(设备树种获取)，参数2:中断处理函数，参数3:触发方式，参数4:描述，参数5:传递给中断处理函数的参数

1. 保存现场
2. 进入对应的异常向量表
3. 进入异常处理函数
4. 读控制器的位(标志宏)
5. 进入中断处理函数
6. 回复现场

1. 创造结构体变量:

   struct tasklet_struct tasklet;
   

2. 初始化结构体变量(probe):

   //参数1:中断结构体赋值，参数2:下半部处理函数的函数指针,参数3:下半部处理函数的参数
   	tasklet_init(&key->tasklet, key_drv_func, 0);
   

3. 在上半部分处理函数(key_drv_handler)进行调度

   //调度,启动下半部分函数
   	tasklet_schedule(&key->tasklet);
   

1. 创建work结构体变量:

   struct work_struct work;
   

2. 初始化结构体变量(probe):

   //参数1:work结构体指针,参数2:下半部处理函数的函数指针
   	INIT_WORK(&key->work, key_drv_work);
   

3. 在上半部分处理函数(key_drv_handler)进行调度

   schedule_work(&key-> work);
   

1. 写后半段处理函数作为申请线程中断处理的参数

   irqreturn_t key_drv_irq_thread(int irq_no,void * data)
   { 
             
   	printk("-----------start---%s---------\n",__FUNCTION__);
   	return IRQ_HANDLED;
   }
   

2. 申请线程中断处理

   //可以再带一个线程处理中断函数
   	ret = request_threaded_irq(key->info[i].irq_no, key_drv_handler,key_drv_irq_thread, key>info[i].flag, key->info[i].name, &key->info[i]);
   

3. 在上半部分处理函数(key_drv_handler)返回唤醒进程的宏

   return IRQ_WAKE_THREAD;//唤醒线程,启动线程中断处理函数5、
   

1. 创建等待队列头以及资源标志位

   struct wait_queue_head wq_head;//等待队列头
   int have_data;//是否有资源标志位
   

2. 初始化等待队列头以及资源标志位

   key->have_data = 0;//初始化标志位
   init_waitqueue_head(&key->wq_head);//初始化等待队列头
   

3. 在key_drv_read中设置一个可以被打断的休眠(阻塞)

   //一个可以被打断的休眠(阻塞)，即进程被挂在了休眠队列上。参数1:等待队列头，参数2:休眠条件
   wait_event_interruptible(key->wq_head, key->have_data);
   

4. 在中断函数中拿到资源并唤醒休眠

   key->have_data = 1;
   wake_up_interruptible(&(key->wq_head));//中断唤醒休眠
   

1. 创建监听事件结构体

   //struct pollfd
   //{ 
             
   // int fd;
   // short events;//输入值:被监视的的事件
   // short revents;//输出值:返回真正发生的事件
   //};
   struct pollfd fds[2];
   

2. 初始化监听事件结构体

   	fds[0].fd = fd;
   	fds[0].events = POLLIN;
   
   	fds[1].fd = 0;
   	fds[1].events = POLLIN;
   

3. 开启轮询监听

   while(1)
   	{ 
             	 //参数1:监听事件结构体pollfd，参数2:被监听的事件总数，参数3:设置-1等于没有超时时间
   		//返回值>0表示监听到事件
   		ret = poll(fds, sizeof(fds)/sizeof(fds[0]), -1);
   

4. 判定监听事件以及动作

   if(ret > 0)
   		{ 
             
   			if(fds[0].revents & POLLIN) //有按键数据了
   			{ 
             				
   				read(fd, &info, sizeof(info));
   				//
   				if(info.value)
   					printf("KEY--->%s, Pressed...\n",info.name);
   				else
   					printf("KEY--->%s, Release...\n",info.name);
   			}
   			
   			if(fds[1].revents & POLLIN)//有标准输出了
   			{ 
             
   				int len;
   				printf("---------start3----------\n");
   				len = read(0, buff, sizeof(buff));
   				buff[len] = '\0';
   				printf(