Linux驱动开发--平台总线id和设备树匹配

2023-11-14

一、ID匹配之框架代码

二、ID匹配之led驱动

三、设备树匹配

四、设备树匹配之led驱动

五、一个编写驱动用的宏

一、ID匹配之框架代码

id匹配（可想象成八字匹配）：一个驱动可以对应多个设备 ------优先级次低

注意事项：

device模块中，id的name成员必须与struct platform_device中的name成员内容一致，因此device模块中，struct platform_device中的name成员必须指定
driver模块中，struct platform_driver成员driver的name成员必须指定，但与device模块中name可以不相同

/*platform device框架*/
#include <linux/module.h> 
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>

//定义资源数组

static void device_release(struct device *dev)
{
	printk("platform: device release\n");
}

struct platform_device_id test_id = {
    .name = "test_device",
};

struct platform_device test_device = {
	.name = "test_device",//必须初始化
	.dev.release = device_release, 
    .id_entry = &test_id,
};

static int __init platform_device_init(void)
{
	platform_device_register(&test_device);
	return 0;
}

static void __exit platform_device_exit(void)
{
	platform_device_unregister(&test_device);
}

module_init(platform_device_init);
module_exit(platform_device_exit);
MODULE_LICENSE("Dual BSD/GPL");

/*platform driver框架*/
#include <linux/module.h> 
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>

static int driver_probe(struct platform_device *dev)
{
	printk("platform: match ok!\n");
	return 0;
}

static int driver_remove(struct platform_device *dev)
{
	printk("platform: driver remove\n");
	return 0;
}

struct platform_device_id testdrv_ids[] = 
{
	[0] = {.name = "test_device"},
    [1] = {.name = "abcxyz"},
    [2] = {}, //means ending
};

struct platform_driver test_driver = {
	.probe = driver_probe,
	.remove = driver_remove,
	.driver = {
		.name = "xxxxx", //必须初始化
	},
    .id_table = testdrv_ids,
};

static int __init platform_driver_init(void)
{
	platform_driver_register(&test_driver);
	return 0;
}

static void __exit platform_driver_exit(void)
{
	platform_driver_unregister(&test_driver);
}

module_init(platform_driver_init);
module_exit(platform_driver_exit);
MODULE_LICENSE("Dual BSD/GPL");

用到结构体数组，一般不指定大小，初始化时最后加{}表示数组结束

设备中增加资源，驱动中访问资源。

二、ID匹配之led驱动


#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/platform_device.h>
 
#define GPX1CON 0x11000C20
#define GPX1DAT 0x11000C24
 
#define GPX2CON 0x11000C40
#define GPX2DAT 0x11000C44
 
#define GPF3CON 0x114001E0
#define GPF3DAT 0x114001E4
void fs4412leds_dev_release(struct device *pdev)
{
	printk("fs4412leds_dev_release is called\n");
}
 
struct resource fs4412leds_dev_res [] =
{
	[0] = {.start = GPX1CON,.end=GPX1CON + 3,.name="GPX1CON",.flags = IORESOURCE_MEM},
	[1] = {.start = GPX1DAT,.end=GPX1DAT + 3,.name="GPX1DAT",.flags = IORESOURCE_MEM},
 
	[2] = {.start = GPX2CON,.end=GPX2CON + 3,.name="GPX2CON",.flags = IORESOURCE_MEM},
	[3] = {.start = GPX2DAT,.end=GPX2DAT + 3,.name="GPX2DAT",.flags = IORESOURCE_MEM},
	
	[4] = {.start = GPF3CON,.end=GPF3CON + 3,.name="GPF3CON",.flags = IORESOURCE_MEM},
	[5] = {.start = GPF3DAT,.end=GPF3DAT + 3,.name="GPF3DAT",.flags = IORESOURCE_MEM},
};
 
struct platform_device_id led_id = {
	.name = "fs4412leds",
};
 
struct platform_device fs4412leds_device = 
{
	.name = "fs4412leds",
	.dev.release = fs4412leds_dev_release,
	.resource = fs4412leds_dev_res,
	.num_resources = ARRAY_SIZE(fs4412leds_dev_res),
	.id_entry = &led_id,
};
 
int __init fs4412leds_device_init(void)
{
	platform_device_register(&fs4412leds_device);
	return 0;
}
 
void __exit fs4412leds_device_exit(void)
{
	platform_device_unregister(&fs4412leds_device);
}
 
MODULE_LICENSE("GPL");
module_init(fs4412leds_device_init);
module_exit(fs4412leds_device_exit);

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/platform_device.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/io.h>
#include <asm/uaccess.h>
#include <asm/atomic.h>
 
#include "leddrv.h"
 
 
 
int major = 11;
int minor = 0;
int myled_num  = 1;
 
struct myled_dev
{
	struct cdev mydev;
 
	volatile unsigned long *pled2_con;
	volatile unsigned long *pled2_dat;
	
	volatile unsigned long *pled3_con;
	volatile unsigned long *pled3_dat;
 
	volatile unsigned long *pled4_con;
	volatile unsigned long *pled4_dat;
 
	volatile unsigned long *pled5_con;
	volatile unsigned long *pled5_dat;
};
 
struct myled_dev *pgmydev = NULL;
 
 
int myled_open(struct inode *pnode,struct file *pfile)
{
	pfile->private_data =(void *) (container_of(pnode->i_cdev,struct myled_dev,mydev));
	
	return 0;
}
 
int myled_close(struct inode *pnode,struct file *pfile)
{
	return 0;
}
 
void led_on(struct myled_dev *pmydev,int ledno)
{
	switch(ledno)
	{
		case 2:
			writel(readl(pmydev->pled2_dat) | (0x1 << 7),pmydev->pled2_dat);
			break;
		case 3:
			writel(readl(pmydev->pled3_dat) | (0x1),pmydev->pled3_dat);
			break;
		case 4:
			writel(readl(pmydev->pled4_dat) | (0x1 << 4),pmydev->pled4_dat);
			break;
		case 5:
			writel(readl(pmydev->pled5_dat) | (0x1 << 5),pmydev->pled5_dat);
			break;
	}
}
 
void led_off(struct myled_dev *pmydev,int ledno)
{
	switch(ledno)
	{
		case 2:
			writel(readl(pmydev->pled2_dat) & (~(0x1 << 7)),pmydev->pled2_dat);
			break;
		case 3:
			writel(readl(pmydev->pled3_dat) & (~(0x1)),pmydev->pled3_dat);
			break;
		case 4:
			writel(readl(pmydev->pled4_dat) & (~(0x1 << 4)),pmydev->pled4_dat);
			break;
		case 5:
			writel(readl(pmydev->pled5_dat) & (~(0x1 << 5)),pmydev->pled5_dat);
			break;
	}
}
 
 
long myled_ioctl(struct file *pfile,unsigned int cmd,unsigned long arg)
{
	struct myled_dev *pmydev = (struct myled_dev *)pfile->private_data;
 
	if(arg < 2 || arg > 5)
	{
		return -1;
	}
	switch(cmd)
	{
		case MY_LED_ON:
			led_on(pmydev,arg);
			break;
		case MY_LED_OFF:
			led_off(pmydev,arg);
			break;
		default:
			return -1;
	}
 
	return 0;
}
 
struct file_operations myops = {
	.owner = THIS_MODULE,
	.open = myled_open,
	.release = myled_close,
	.unlocked_ioctl = myled_ioctl,
};
 
void ioremap_ledreg(struct myled_dev *pmydev,struct platform_device *p_pltdev)
{
	struct resource *pres = NULL;
 
 
	pres = platform_get_resource(p_pltdev,IORESOURCE_MEM,2);
	pmydev->pled2_con = ioremap(pres->start,4);
 
	pres = platform_get_resource(p_pltdev,IORESOURCE_MEM,3);
	pmydev->pled2_dat = ioremap(pres->start,4);
 
 
	pres = platform_get_resource(p_pltdev,IORESOURCE_MEM,0);
	pmydev->pled3_con = ioremap(pres->start,4);
 
	pres = platform_get_resource(p_pltdev,IORESOURCE_MEM,1);
	pmydev->pled3_dat = ioremap(pres->start,4);
	
 
	pres = platform_get_resource(p_pltdev,IORESOURCE_MEM,4);
	pmydev->pled4_con = ioremap(pres->start,4);
 
	pres = platform_get_resource(p_pltdev,IORESOURCE_MEM,5);
	pmydev->pled4_dat = ioremap(pres->start,4);
	
	pmydev->pled5_con = pmydev->pled4_con;
	pmydev->pled5_dat = pmydev->pled4_dat;
}
 
void set_output_ledconreg(struct myled_dev *pmydev)
{
	writel((readl(pmydev->pled2_con) & (~(0xF << 28))) | (0x1 << 28),pmydev->pled2_con);
	writel((readl(pmydev->pled3_con) & (~(0xF))) | (0x1),pmydev->pled3_con);
	writel((readl(pmydev->pled4_con) & (~(0xF << 16))) | (0x1 << 16),pmydev->pled4_con);
	writel((readl(pmydev->pled5_con) & (~(0xF << 20))) | (0x1 << 20),pmydev->pled5_con);
 
	writel(readl(pmydev->pled2_dat) & (~(0x1 << 7)),pmydev->pled2_dat);
	writel(readl(pmydev->pled3_dat) & (~(0x1)),pmydev->pled3_dat);
	writel(readl(pmydev->pled4_dat) & (~(0x1 << 4)),pmydev->pled4_dat);
	writel(readl(pmydev->pled5_dat) & (~(0x1 << 5)),pmydev->pled5_dat);
}
 
void iounmap_ledreg(struct myled_dev *pmydev)
{
	iounmap(pmydev->pled2_con);
	pmydev->pled2_con = NULL;
	iounmap(pmydev->pled2_dat);
	pmydev->pled2_dat = NULL;
 
	iounmap(pmydev->pled3_con);
	pmydev->pled3_con = NULL;
	iounmap(pmydev->pled3_dat);
	pmydev->pled3_dat = NULL;
	
	iounmap(pmydev->pled4_con);
	pmydev->pled4_con = NULL;
	iounmap(pmydev->pled4_dat);
	pmydev->pled4_dat = NULL;
	
	pmydev->pled5_con = NULL;
	pmydev->pled5_dat = NULL;
}
 
int fs4412leds_driver_probe(struct platform_device *p_pltdev)
{
	int ret = 0;
	dev_t devno = MKDEV(major,minor);
 
	/*申请设备号*/
	ret = register_chrdev_region(devno,myled_num,"myled");
	if(ret)
	{
		ret = alloc_chrdev_region(&devno,minor,myled_num,"myled");
		if(ret)
		{
			printk("get devno failed\n");
			return -1;
		}
		major = MAJOR(devno);//容易遗漏，注意
	}
 
	pgmydev = (struct myled_dev *)kmalloc(sizeof(struct myled_dev),GFP_KERNEL);
	if(NULL == pgmydev)
	{
		unregister_chrdev_region(devno,myled_num);
		printk("kmalloc failed\n");
		return -1;
	}
	memset(pgmydev,0,sizeof(struct myled_dev));
 
	/*给struct cdev对象指定操作函数集*/	
	cdev_init(&pgmydev->mydev,&myops);
 
	/*将struct cdev对象添加到内核对应的数据结构里*/
	pgmydev->mydev.owner = THIS_MODULE;
	cdev_add(&pgmydev->mydev,devno,myled_num);
 
	/*ioremap*/
	ioremap_ledreg(pgmydev,p_pltdev);
 
	/*con-register set output*/
	set_output_ledconreg(pgmydev);
 
	return 0;
}
 
int fs4412leds_driver_remove(struct platform_device *p_pltdev)
{
	dev_t devno = MKDEV(major,minor);
 
	/*iounmap*/
	iounmap_ledreg(pgmydev);
 
	cdev_del(&pgmydev->mydev);
 
	unregister_chrdev_region(devno,myled_num);
 
	kfree(pgmydev);
	pgmydev = NULL;
 
	return 0;
}
 
struct platform_device_id leddrv_ids[] =
{
	[0] = {.name = "fs4412leds"},
	[1] = {.name = "xyz"},
	[2] = {}
};
 
struct platform_driver fs4412leds_driver = 
{
	.driver.name = "leds",
	.probe = fs4412leds_driver_probe,
	.remove = fs4412leds_driver_remove,
	.id_table = leddrv_ids,
};
 
int __init fs4412leds_driver_init(void)
{
	platform_driver_register(&fs4412leds_driver);
	return 0;
}
 
void __exit fs4412leds_driver_exit(void)
{
	platform_driver_unregister(&fs4412leds_driver);
}
 
MODULE_LICENSE("GPL");
 
module_init(fs4412leds_driver_init);
module_exit(fs4412leds_driver_exit);

#ifndef LED_DRIVER_H
#define LED_DRIVER_H
 
#define LED_DEV_MAGIC 'g'
 
#define MY_LED_OFF _IO(LED_DEV_MAGIC,0)
#define MY_LED_ON _IO(LED_DEV_MAGIC,1)
 
 
 
#endif

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <unistd.h>
 
#include <stdio.h>
 
#include "leddrv.h"
 
int main(int argc,char *argv[])
{
	int fd = -1;
	int onoff = 0;
	int no = 0;
 
	if(argc < 4)
	{
		printf("The argument is too few\n");
		return 1;
	}
 
	sscanf(argv[2],"%d",&onoff);
	sscanf(argv[3],"%d",&no);
 
	if(no < 2 || no > 5)
	{
		printf("len-no is invalid\n");
		return 2;
	}
 
	fd = open(argv[1],O_RDONLY);
	if(fd < 0)
	{
		printf("open %s failed\n",argv[1]);
		return 3;
	}
 
	if(onoff)
	{
		ioctl(fd,MY_LED_ON,no);
	}
	else
	{
		ioctl(fd,MY_LED_OFF,no);
	}
 
	close(fd);
	fd = -1;
	return 0;
}

三、设备树匹配

设备树匹配：内核启动时根据设备树自动产生的设备 ------ 优先级最高

注意事项：

无需编写device模块，只需编写driver模块
使用compatible属性进行匹配，注意设备树中compatible属性值不要包含空白字符
id_table可不设置，但struct platform_driver成员driver的name成员必须设置

/*platform driver框架*/
#include <linux/module.h> 
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>

static int driver_probe(struct platform_device *dev)
{
	printk("platform: match ok!\n");
	return 0;
}

static int driver_remove(struct platform_device *dev)
{
	printk("platform: driver remove\n");
	return 0;
}

struct platform_device_id testdrv_ids[] = 
{
	[0] = {.name = "test_device"},
    [1] = {.name = "abcxyz"},
    [2] = {}, //means ending
};

struct of_device_id test_of_ids[] = 
{
	[0] = {.compatible = "xyz,abc"},
    [1] = {.compatible = "qwe,opq"},
    [2] = {},
};

struct platform_driver test_driver = {
	.probe = driver_probe,
	.remove = driver_remove,
	.driver = {
		.name = "xxxxx", //必须初始化
        .of_match_table = test_of_ids,
	},
};

static int __init platform_driver_init(void)
{
	platform_driver_register(&test_driver);
	return 0;
}

static void __exit platform_driver_exit(void)
{
	platform_driver_unregister(&test_driver);
}

module_init(platform_driver_init);
module_exit(platform_driver_exit);
MODULE_LICENSE("Dual BSD/GPL");

四、设备树匹配之led驱动

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/platform_device.h>
#include <linux/fs.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/cdev.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/io.h>
#include <asm/uaccess.h>
#include <asm/atomic.h>
 
#include "leddrv.h"
 
int major = 11;
int minor = 0;
int myled_num  = 1;
 
struct myled_dev
{
	struct cdev mydev;
 
	unsigned int led2gpio;
	unsigned int led3gpio;
	unsigned int led4gpio;
	unsigned int led5gpio;
};
 
struct myled_dev *pgmydev = NULL;
 
 
int myled_open(struct inode *pnode,struct file *pfile)
{
	pfile->private_data =(void *) (container_of(pnode->i_cdev,struct myled_dev,mydev));
	
	return 0;
}
 
int myled_close(struct inode *pnode,struct file *pfile)
{
	return 0;
}
 
void led_on(struct myled_dev *pmydev,int ledno)
{
	switch(ledno)
	{
		case 2:
			gpio_set_value(pmydev->led2gpio,1);
			break;
		case 3:
			gpio_set_value(pmydev->led3gpio,1);
			break;
		case 4:
			gpio_set_value(pmydev->led4gpio,1);
			break;
		case 5:
			gpio_set_value(pmydev->led5gpio,1);
			break;
	}
}
 
void led_off(struct myled_dev *pmydev,int ledno)
{
	switch(ledno)
	{
		case 2:
			gpio_set_value(pmydev->led2gpio,0);
			break;
		case 3:
			gpio_set_value(pmydev->led3gpio,0);
			break;
		case 4:
			gpio_set_value(pmydev->led4gpio,0);
			break;
		case 5:
			gpio_set_value(pmydev->led5gpio,0);
			break;
	}
}
 
 
long myled_ioctl(struct file *pfile,unsigned int cmd,unsigned long arg)
{
	struct myled_dev *pmydev = (struct myled_dev *)pfile->private_data;
 
	if(arg < 2 || arg > 5)
	{
		return -1;
	}
	switch(cmd)
	{
		case MY_LED_ON:
			led_on(pmydev,arg);
			break;
		case MY_LED_OFF:
			led_off(pmydev,arg);
			break;
		default:
			return -1;
	}
 
	return 0;
}
 
struct file_operations myops = {
	.owner = THIS_MODULE,
	.open = myled_open,
	.release = myled_close,
	.unlocked_ioctl = myled_ioctl,
};
 
void request_leds_gpio(struct myled_dev *pmydev,struct device_node *pnode)
{
	pmydev->led2gpio = of_get_named_gpio(pnode,"led2-gpio",0);
	gpio_request(pmydev->led2gpio,"led2");
	
	pmydev->led3gpio = of_get_named_gpio(pnode,"led3-gpio",0);
	gpio_request(pmydev->led3gpio,"led3");
	
	pmydev->led4gpio = of_get_named_gpio(pnode,"led4-gpio",0);
	gpio_request(pmydev->led4gpio,"led4");
	
	pmydev->led5gpio = of_get_named_gpio(pnode,"led5-gpio",0);
	gpio_request(pmydev->led5gpio,"led5");
}
 
void set_leds_gpio_output(struct myled_dev *pmydev)
{
	gpio_direction_output(pmydev->led2gpio,0);
	gpio_direction_output(pmydev->led3gpio,0);
	gpio_direction_output(pmydev->led4gpio,0);
	gpio_direction_output(pmydev->led5gpio,0);
}
 
void free_leds_gpio(struct myled_dev *pmydev)
{
	gpio_free(pmydev->led2gpio);
	gpio_free(pmydev->led3gpio);
	gpio_free(pmydev->led4gpio);
	gpio_free(pmydev->led5gpio);
}
 
int myled_probe(struct platform_device *p_pltdev)
{
	int ret = 0;
	dev_t devno = MKDEV(major,minor);
	struct device_node *pnode = NULL;
	
	/*申请设备号*/
	ret = register_chrdev_region(devno,myled_num,"myled");
	if(ret)
	{
		ret = alloc_chrdev_region(&devno,minor,myled_num,"myled");
		if(ret)
		{
			printk("get devno failed\n");
			return -1;
		}
		major = MAJOR(devno);//容易遗漏，注意
	}
 
	pgmydev = (struct myled_dev *)kmalloc(sizeof(struct myled_dev),GFP_KERNEL);
	if(NULL == pgmydev)
	{
		unregister_chrdev_region(devno,myled_num);
		printk("kmalloc failed\n");
		return -1;
	}
	memset(pgmydev,0,sizeof(struct myled_dev));
 
	/*给struct cdev对象指定操作函数集*/	
	cdev_init(&pgmydev->mydev,&myops);
 
	/*将struct cdev对象添加到内核对应的数据结构里*/
	pgmydev->mydev.owner = THIS_MODULE;
	cdev_add(&pgmydev->mydev,devno,myled_num);
 
	pnode = p_pltdev->dev.of_node;
 
	/*ioremap*/
	request_leds_gpio(pgmydev,pnode);
 
	/*con-register set output*/
	set_leds_gpio_output(pgmydev);
 
	return 0;
}
 
int myled_remove(struct platform_device *p_pltdev)
{
	dev_t devno = MKDEV(major,minor);
 
	/*iounmap*/
	free_leds_gpio(pgmydev);
 
	cdev_del(&pgmydev->mydev);
 
	unregister_chrdev_region(devno,myled_num);
 
	kfree(pgmydev);
	pgmydev = NULL;
 
	return 0;
}
 
struct of_device_id myleddrv_of_ids[] = 
{
	[0] = {.compatible = "fs4412,led2-5"},
	[1] = {.compatible = "origen4412,led6-9"},
	[2] = {},
};
 
struct platform_driver myled_driver = 
{
	.driver = {
		.name = "fs4412leds",
		.of_match_table = myleddrv_of_ids,
	},
	.probe = myled_probe,
	.remove = myled_remove,
};
 
int __init myled_init(void)
{
	platform_driver_register(&myled_driver);
 
	return 0;
}
 
void __exit myled_exit(void)
{
	platform_driver_unregister(&myled_driver);
}
 
 
MODULE_LICENSE("GPL");
 
module_init(myled_init);
module_exit(myled_exit);

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <unistd.h>
 
#include <stdio.h>
 
#include "leddrv.h"
 
int main(int argc,char *argv[])
{
	int fd = -1;
	int onoff = 0;
	int no = 0;
 
	if(argc < 4)
	{
		printf("The argument is too few\n");
		return 1;
	}
 
	sscanf(argv[2],"%d",&onoff);
	sscanf(argv[3],"%d",&no);
 
	if(no < 2 || no > 5)
	{
		printf("len-no is invalid\n");
		return 2;
	}
 
	fd = open(argv[1],O_RDONLY);
	if(fd < 0)
	{
		printf("open %s failed\n",argv[1]);
		return 3;
	}
 
	if(onoff)
	{
		ioctl(fd,MY_LED_ON,no);
	}
	else
	{
		ioctl(fd,MY_LED_OFF,no);
	}
 
	close(fd);
	fd = -1;
	return 0;
}

五、一个编写驱动用的宏

struct platform_driver xxx = {  
    ...
};
module_platform_driver(xxx);
//最终展开后就是如下形式：
static int __init xxx_init(void)
{
        return platform_driver_register(&xxx);
}
module_init(xxx_init);
static void __exit xxx_init(void)
{
        return platform_driver_unregister(&xxx);
}
module_exit(xxx_exit)

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

Linux

驱动开发

运维

Linux驱动开发--平台总线id和设备树匹配的相关文章

Linux 上的 RTLD_LOCAL 和dynamic_cast

我们有一个由应用程序中的一些共享库构成的插件我们需要在应用程序运行时更新它出于性能原因我们在卸载旧插件之前加载并开始使用新插件并且只有当所有线程都使用旧插件完成后我们才卸载它由于新插件和旧插件的库具有相同的符号我们dlopen
嵌入式linux编写AT命令

我在向 GSM 模块写入 AT 命令时遇到问题当我使用 minicom b 115200 D dev ttySP0 term vt100 时它工作完美但我不知道如何在 C 代码中做同样的事情我没有收到任何错误但模块对命令没有反应有
linux命令中括号的用途是什么[重复]

这个问题在这里已经有答案了我在 Linux 终端中运行以下命令谁能告诉我 Linux 终端中括号和以下命令的用途是什么 echo GET HTTP 1 0 echo 主机 www google com echo 数控 www googl
Raspberry 交叉编译 - 执行程序以“分段错误”结束

我有一个自己编写的程序我想从我的 x86 机器上为 Raspberry Pi 构建它我正在使用 eclipse 生成的 makefile 并且无法更改此内容我已经阅读了 CC for raspi 的教程 Hackaday 链接 htt
PyPI 上的轮子平台约束有什么限制吗？

是否有任何地方 PEP 或其他地方声明关于 Linux 轮子上传范围的限制 PyPI http pypi io 应该有具体来说上传是否被认为是可接受的做法linux x86 64轮子到 PyPI 而不是manylinux1 x86 6
如何将后台作业的输出分配给 bash 变量？

我想在 bash 中运行后台作业并将其结果分配给一个变量我不喜欢使用临时文件并且希望同时运行多个类似的后台任务 root root var echo hello world root root echo var hello world
从c调用汇编函数

我试图从 c 调用汇编函数但我不断收到错误 text globl integrate type integrate function integrate push ebp mov esp ebp mov 0 edi start loop
dlopen 或 dlclose 未调用信号处理程序

我在随机时间内收到分段错误我注册了信号但发生分段错误时未调用信号处理程序 include
码头无故停止

我需要经验丰富的码头用户的建议我在负载均衡器亚马逊云后面维护着 2 台 Linux 机器使用 Jetty 9 0 3 有时我的 Jetty 容器会被 Thread 2 无故关闭同时地显示以下日志并且容器无故停止没有错误没有例
用于编辑 /etc/sudoers 文件的正则表达式模式

我想删除 etc sudoers 文件中的 uncommnet 轮组那么我应该使用什么正则表达式模式 cat etc sudoers Allows members of the sys group to run networking so
Fortran 中的共享库，最小示例不起作用

我试图了解如何在 Linux 下的 Fortran 中动态创建和链接共享库我有两个文件第一个 liblol f90 看起来像这样 subroutine func print lol end subroutine func 我用它编译gf
如何在 Linux 中重新添加 unicode 字节顺序标记？

我有一个相当大的 SQL 文件它以 FFFE 的字节顺序标记开头我使用 unicode 感知的 linux 分割工具将此文件分割成 100 000 行块但是当将这些传递回窗口时它确实not与第一个部分以外的任何部分一样只是它具有
运行此处编译的 C 程序会导致在另一台服务器上找不到 GLIBC 库错误 - 是我的错还是他们的错？

此处编译的 C 程序在我们的 Ubuntu 服务器上运行良好但是当其他人尝试在他们的特定 Linux 服务器上运行它时他们会收到以下错误 myprog install lib tls libc so 6 version GLIBC 2
Python将文件从Linux复制到WIndows

我正在构建一个网站该网站有一个表单可以捕获用户数据并在用户数据上运行一些cgi cgi 的第一步是需要将文件从 Linux Web 服务器复制到 Windows 计算机服务器将使用 Active Directory 角色帐户作为复制凭
使用c在linux上分块读写

我有一个 ASCII 文件其中每一行都包含一个可变长度的记录例如 Record 1 15 characters Record 2 200 characters Record 3 500 characters Record n X cha
在非实时操作系统/内核上执行接近实时任务的最佳方法是什么？

在一台 GNU Linux 机器上如果想要执行实时亚毫秒级时间关键任务您几乎总是必须经历漫长复杂且容易出现问题的内核补丁过程以提供足够的支持 1 http en wikipedia org wiki RTLinux Backg
为什么默认情况下不启用 arp 忽略/通告 [关闭]

Closed 这个问题是无关 help closed questions 目前不接受答案我有一个需要经验才能回答的具体问题为什么 arp ignore arp announce 在 Linux 安装例如 debian 上默认不启用有
Grep 递归和计数

需要在具有大量子目录的目录中搜索文件内的字符串我在用着 grep c r string here 我怎样才能找到总数量如何仅输出至少具有一个实例的文件使用 Bash 的进程替换这给出了我认为是您想要的输出如果不是请澄清问题 gr
如何使用 go1.6.2 构建 linux 32 位

有没有任何组合GOARCH and GOOS我可以设置哪些值来构建 ELF 32 位二进制文件 GOOS linux and GOARCH 386 更多示例架构 32 bit gt GOARCH 386 64 bit gt GOARCH
为什么 call_usermodehelper 大多数时候都会失败？

从内核模块中我尝试使用 call usermodehelper 函数来执行可执行文件 sha1 该可执行文件将文件作为参数并将文件的 SHA1 哈希和写入另一个文件名为输出可执行文件完美运行 int result 1 name hom

随机推荐

【Egg从基础到进阶】一：Egg项目初始化及基础入门

目录 Egg js 为企业级框架和应用而生我们希望由 Egg js 孕育出更多上层框架帮助开发团队和开发人员降低开发和维护成本使用Egg 脚手架创建一个Egg项目 node gt 14 20 0 app router app cont
Java架构师技术进阶路线图详解

在企业里一名架构师已经可以算是高端人物了但架构师也是需要学习的任何人与事物都需要学习下面我们就来了解一下Java架构师到底该如何进阶请看如下一阅读源码深入的Java学习经典源码阅读不可少常见的设计模式编码必备 Spri
如何给elementui中表格的行设置样式
【C++ 存储和读取二进制文件以及类的实例】

很多时候程序运行时的数据都以类的对象的形式存储那么如何将这些对象保存使得下一次运行程序的时候可以直接使用呢 Step 1 gt 首先我们需要知道如何读写二进制文件 inline size t readBinaryFile const ch
Elasticsearch基础1——搜索引擎发展史和工作流程、es/es-head/kibana的基础安装

文章目录一搜索引擎 1 1 搜索引擎的发展背景 1 2 Lucene和Elasticsearch 1 3 Solr和Elasticsearch对比 1 4 数据搜索方式 1 5 搜索引擎 1 5 1 搜索引擎工作流程 1 5 2 网络爬
SVN：This client is too old to work with working copy…解决办法

svn This client is too old to work with working copy 由于svn工作拷贝目录下都有个 svn目录里面保存着svn需要的一些版本信息等当客户端软件升级后里面的信息也相应增加以支持更多的
如何查看共享服务器文件夹权限设置,如何共享服务器文件夹权限设置

如何共享服务器文件夹权限设置内容精选换一换 Linux操作系统的弹性云服务器默认只能通过root帐号使用mount命令进行挂载文件系统但可通过赋予其他普通用户root权限达到使非root的普通用户能够在弹性云服务器上使用mount命
双线macd指标参数最佳设置_15分钟macd参数设置方法 15分钟k线macd指标如何判断买卖点...

炒股投资过程中我们通常会借助多种指标来判断股票买卖时机今天为大家分享判断股票买卖点的组合是15分钟k线与macd指标那么15分钟macd参数设置方法是什么 15分钟k线macd指标如何判断买卖点下面小编为大家来详细介绍下15分钟线m
网络穿透代理局域网

网址穿透网址开启通道开始代理
ARM中的---汇编指令

一带点的一般都是ARM GNU伪汇编指令 1 text data bss 依次表示的是以下是代码段以下是初始化数据段以下是未初始化数据段 2 global 定义一个全局符号通常是为ld使用比如经常看到的 global star
利用树莓派搭建简易服务器

读研以来笔者一直负责实验室的网络维护可以说是实验室名副其实的首席大网管整个实验室是从学校网络中心购买了一个教育网的公网IP地址和带宽公网IP绑定了实验室的主路由器而主路由器就在笔者卡位的旁边有一天笔者突发奇想拿了手头的树莓派3结
Micropython——报错解决：TypeError: object with buffer protocol required

报错检查报错处代码仔细检查可以发现是括号放错位置导致函数无法正常执行故报错一般情况下 Micropython除硬件如定时器中断内存溢出等硬件本身报错外其他均为语法错误
统计学习方法学习笔记（一）————统计学习方法概论

1 统计学习 1 统计学习概念统计学习 statistical learning 是关于计算机基于数据构建概率统计模型并运用模型对数据进行预测与分析的一门学科统计学习也称为统计机器学习 statistical machine learn
MLIR入门系列系列学习笔记

目录 1 名字解释这一定义包含3个关键元素 2 代码演示 2 1 环境准备 2 2 编译llvm project 2 3 测试解析 2 3 1 源程序 2 3 2 将源程序生成抽象语法树 AST 3 MLIR三要素 3 1 MLIRGen
为什么在组件内部data是一个函数而不是一个对象？

为什么在组件内部data是一个函数而不是一个对象因为在组件复用的时候会重新生成一个对象而data是一个对象的话因为对象是引用数据类型 data数据会被复用而当data是一个函数的时候每次调用的时候就会返回一个新的data对象 vue
安装--centos7上使用kubeadm安装三节点的k8s集群

安装文档 https kubernetes io zh cn docs setup production environment tools kubeadm install kubeadm 参考 https blog csdn net qq
瑞吉外卖业务开发

一软件开发整体介绍软件开发流程需求分析产品原型需求规格说明书设计产品文档 UI界面设计概要设计详细设计数据库设计编码项目代码单元测试测试测试用例测试报告上线运维软件环境安装配置角色分工项目经理对整
2023华为OD机试真题【垃圾短信识别】

题目描述大众对垃圾短信深恶痛绝希望能对垃圾短信发送者进行识别为此很多软件增加了垃圾短信的识别机制经分析发现正常用户的短信通常具备交互性而垃圾短信往往都是大量单向的短信按照如下规则进行垃圾短信识别本题中发送者A符合以下条件
unity3d FPS 枪的后座力

实现枪开枪后向上偏移一段距离再缓慢下移复位模仿cs 调小后座力 using UnityEngine using System Collections public class Camera2Follower MonoBehaviour
Linux驱动开发--平台总线id和设备树匹配

目录一 ID匹配之框架代码二 ID匹配之led驱动三设备树匹配四设备树匹配之led驱动五一个编写驱动用的宏一 ID匹配之框架代码 id匹配可想象成八字匹配一个驱动可以对应多个设备优先级次低注意事项 device模块

Linux驱动开发--平台总线id和设备树匹配

一、ID匹配之框架代码

二、ID匹配之led驱动

三、设备树匹配

四、设备树匹配之led驱动

五、一个编写驱动用的宏

Linux驱动开发--平台总线id和设备树匹配 的相关文章

随机推荐

热门标签

Linux驱动开发--平台总线id和设备树匹配的相关文章