Linux I2C 驱动实验(2)

最新推荐文章于 2025-04-28 11:36:19 发布
最新推荐文章于 2025-04-28 11:36:19 发布
阅读量960 收藏 3
点赞数 1
分类专栏： linux驱动 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_45761493/article/details/119118992
版权

1 I2C 设备和驱动匹配过程

I2C 设备和驱动的匹配过程是由 I2C 核心来完成的， drivers/i2c/i2c-core.c 就是 I2C 的核心
部分， I2C 核心提供了一些与具体硬件无关的 API 函数，比如前面讲过的：
1 、 i2c_adapter 注册 / 注销函数
int i2c_add_adapter(struct i2c_adapter *adapter)
int i2c_add_numbered_adapter(struct i2c_adapter *adap)
void i2c_del_adapter(struct i2c_adapter * adap)
2 、 i2c_driver 注册 / 注销函数
int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
int i2c_add_driver (struct i2c_driver *driver)
void i2c_del_driver(struct i2c_driver *driver)
设备和驱动的匹配过程也是由 I2C 总线完成的， I2C 总线的数据结构为 i2c_bus_type ，定义
在 drivers/i2c/i2c-core.c 文件， i2c_bus_type 内容如下： 
736 struct bus_type i2c_bus_type = {
737 .name = "i2c",
738 .match = i2c_device_match,
739 .probe = i2c_device_probe,
740 .remove = i2c_device_remove,
741 .shutdown = i2c_device_shutdown,
742 };
.match 就是 I2C 总线的设备和驱动匹配函数，在这里就是 i2c_device_match 这个函数，此
函数内容如下： 
457 static int i2c_device_match(struct device *dev, struct
device_driver *drv)
458 {
459 struct i2c_client *client = i2c_verify_client(dev);
460 struct i2c_driver *driver;
461
462 if (!client)
463 return 0;
464
465 /* Attempt an OF style match */
466 if (of_driver_match_device(dev, drv))
467 return 1;
468
469 /* Then ACPI style match */
470 if (acpi_driver_match_device(dev, drv))
471 return 1;
472
473 driver = to_i2c_driver(drv);
474 /* match on an id table if there is one */
475 if (driver->id_table)
476 return i2c_match_id(driver->id_table, client) != NULL;
477
478 return 0;
479 }
第 466 行， of_driver_match_device 函数用于完成设备树设备和驱动匹配。比较 I2C 设备节
点的 compatible 属性和 of_device_id 中的 compatible 属性是否相等，如果相当的话就表示 I2C
设备和驱动匹配。
第 470 行， acpi_driver_match_device 函数用于 ACPI 形式的匹配。
第 476 行， i2c_match_id 函数用于传统的、无设备树的 I2C 设备和驱动匹配过程。比较 I2C
设备名字和 i2c_device_id 的 name 字段是否相等，相等的话就说明 I2C 设备和驱动匹配。

2 I2C 设备驱动编写流程

   1、IO 修改或添加

 首先肯定是要修改 IO，AP3216C 用到了 I2C1 接口，I.MX6U-ALPHA 开发板上的 I2C1 接 口使用到了 UART4_TXD 和 UART4_RXD，因此肯定要在设备树里面设置这两个 IO。如果要用 到 AP3216C 的中断功能的话还需要初始化 AP_INT 对应的 GIO1_IO01 这个 IO，本章实验我们 不使用中断功能。因此只需要设置 UART4_TXD 和 UART4_RXD 这两个 IO，NXP 其实已经将 他这两个 IO 设置好了，打开 imx6ull-alientek-emmc.dts，然后找到如下内容： 

		pinctrl_i2c1: i2c1grp {
			fsl,pins = <
				MX6UL_PAD_UART4_TX_DATA__I2C1_SCL 0x4001b8b0
				MX6UL_PAD_UART4_RX_DATA__I2C1_SDA 0x4001b8b0
			>;
		};
pinctrl_i2c1 就是 I2C1 的 IO 节点，这里将 UART4_TXD 和 UART4_RXD 这两个 IO 分别
复用为 I2C1_SCL 和 I2C1_SDA ，电气属性都设置为 0x4001b8b0 。
2 、在 i2c1 节点追加 ap3216c 子节点 
i2c1: i2c@021a0000 {
				#address-cells = <1>;
				#size-cells = <0>;
				compatible = "fsl,imx6ul-i2c", "fsl,imx21-i2c";
				reg = <0x021a0000 0x4000>;
				interrupts = <GIC_SPI 36 IRQ_TYPE_LEVEL_HIGH>;
				clocks = <&clks IMX6UL_CLK_I2C1>;
				status = "disabled";
			};
AP3216C 是连接到 I2C1 上的，因此需要在 i2c1 节点下添加 ap3216c 的设备子节点，在
imx6ull-alientek-emmc.dts 文件中找到 i2c1 节点，此节点默认内容如下： 
1 &i2c1 { 
2 clock-frequency = <100000>;
3 pinctrl-names = "default"; 
4 pinctrl-0 = <&pinctrl_i2c1>;
5 status = "okay"; 
6 
7 mag3110@0e { 
8 compatible = "fsl,mag3110"; 
9 reg = <0x0e>;
10 position = <2>;
11 };
12
13 fxls8471@1e {
14 compatible = "fsl,fxls8471";
15 reg = <0x1e>;
16 position = <0>;
17 interrupt-parent = <&gpio5>;
18 interrupts = <0 8>;
19 };
20 };
第 2 行， clock-frequency 属性为 I2C 频率，这里设置为 100KHz 。
第 4 行， pinctrl-0 属性指定 I2C 所使用的 IO 为示例代码 61.5.1.1 中的 pinctrl_i2c1 子节
点。
第 7~11 行， mag3110 是个磁力计， NXP 官方的 EVK 开发板上接了 mag3110 ，因此 NXP
在 i2c1 节点下添加了 mag3110 这个子节点。
第 13~19 行， NXP 官方 EVK 开发板也接了一个 fxls8471。
将 i2c1 节点里面原有的 mag3110 和 fxls8471 这两个 I2C 子节点删除，然后添加 ap3216c
子节点信息，完成以后的 i2c1 节点内容如下所示： 
&i2c1 {
	clock-frequency = <100000>;
	pinctrl-names = "default";
	pinctrl-0 = <&pinctrl_i2c1>;
	status = "okay";

	ap3216c@1e{
		compatible = "alientek,ap3216c";
		reg = <0x1e>;
	};
};
第 7 行， ap3216c 子节点， @ 后面的“ 1e ”是 ap3216c 的器件地址。
第 8 行，设置 compatible 值为“ alientek,ap3216c ”。
第 9 行， reg 属性也是设置 ap3216c 器件地址的，因此 reg 设置为 0x1e 。
设备树修改完成以后使用“ make dtbs ”重新编译一下，然后使用新的设备树启动 Linux 内
核。 /sys/bus/i2c/devices 目录下存放着所有 I2C 设备，如果设备树修改正确的话，会在
/sys/bus/i2c/devices 目录下看到一个名为“ 0-001e ”的子目录，如图 61.5.1.1 所示：

3 编写驱动框架，

 3.1I2C设备驱动框架和字符设备驱动框架

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/slab.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/delay.h>
#include <linux/string.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/of_irq.h>
#include <linux/input.h>
#include <linux/i2c.h>


struct ap3216c_dev{
    dev_t devid;
    int major;
    int minor;
    struct cdev cdev;
    struct class *class;
    struct device *device;
    struct device_node  *nd;
};
struct ap3216c_dev ap3216cdev;
#define ap3216c_cnt 1
#define ap3216c__name "ap3216c"

static int ap3216cdev_open(struct inode *inode, struct file *filp)
{
    printk("ap3216c open\r\n");
    return 0;
}

static int ap3216cdev_release(struct inode *inode, struct file *filp)
{
    printk("ap3216c release\r\n");

    return 0;
}
static ssize_t ap3216c_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
{
    printk("ap3216c read\r\n");
    return 0;
}
static const struct file_operations ap3216cdev_fops = {
    .owner = THIS_MODULE,
	.read = ap3216c_read ,
	.open = ap3216cdev_open,
	.release = ap3216cdev_release,
};
static int ap3216c_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
    int ret = 0;
    printk("ap3216 probe\n");
    ap3216cdev.major = 0; 
    if(ap3216cdev.major) {
        ap3216cdev.devid = MKDEV(ap3216cdev.major,0);
        ret = register_chrdev_region(ap3216cdev.devid, ap3216c_cnt, ap3216c__name);
    } else {
        ret = alloc_chrdev_region(&ap3216cdev.devid, 0, ap3216c_cnt, ap3216c__name);
        ap3216cdev.major = MAJOR(ap3216cdev.devid);
        ap3216cdev.minor = MINOR(ap3216cdev.devid);
    }
    if(ret < 0) {
        goto fail_devid;
    }
    printk("major = %d,minor = %d\r\n",ap3216cdev.major,ap3216cdev.minor);

    ap3216cdev.cdev.owner = THIS_MODULE;

    cdev_init(&ap3216cdev.cdev, &ap3216cdev_fops);
    ret = cdev_add(&ap3216cdev.cdev, ap3216cdev.devid,  ap3216c_cnt);
    if(ret < 0) {
        goto fail_cdev;
    }

    ap3216cdev.class = class_create (THIS_MODULE, ap3216c__name);
    if (IS_ERR(ap3216cdev.class)) {
		ret = PTR_ERR(ap3216cdev.class);
		goto fail_class;
	}
    ap3216cdev.device = device_create(ap3216cdev.class, NULL, ap3216cdev.devid, NULL,ap3216c__name);
    if (IS_ERR(ap3216cdev.device)) {
		ret = PTR_ERR(ap3216cdev.device);
		goto fail_device;
	}
    return 0;
fail_device:
    class_destroy(ap3216cdev.class);
fail_class:
    cdev_del(&ap3216cdev.cdev);
fail_cdev:
    unregister_chrdev_region(ap3216cdev.devid, ap3216c_cnt);
fail_devid:
    return ret;
}
static int ap3216c_remove(struct i2c_client *client)
{
    printk("ap3216 remove\r\n");
    device_destroy(ap3216cdev.class, ap3216cdev.devid);
    class_destroy(ap3216cdev.class);
    cdev_del(&ap3216cdev.cdev);
    unregister_chrdev_region(ap3216cdev.devid, ap3216c_cnt);
    return 0;

}
static const struct i2c_device_id ap3216c_id_table[] = {
	{ "ysy_ap3216c", 0 },
	{ },
};
static const struct of_device_id ap3216c_of_match_table[] = {
   {.compatible = "alientek,ap3216c"},
    { /*sentinel*/},
};

static struct i2c_driver i2c_driver = {
	.driver = {
		.name	= "ap3216c",
		.owner	= THIS_MODULE,
		.of_match_table = ap3216c_of_match_table,
	},
	.probe		= ap3216c_probe,
	.remove		= ap3216c_remove,
	.id_table	= ap3216c_id_table,
};

static int __init ap3216c_init(void)
{
    
    return i2c_add_driver(&i2c_driver);
}

static void __exit ap3216c_exit(void)
{   

    i2c_del_driver(&i2c_driver);
}

module_init(ap3216c_init);
module_exit(ap3216c_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("YSY");

3.2 驱动编写

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/slab.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/delay.h>
#include <linux/string.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/of_irq.h>
#include <linux/input.h>
#include <linux/i2c.h>

#include "ap3216creg.h"

struct ap3216c_dev{
    dev_t devid;
    int major;
    int minor;
    struct cdev cdev;
    struct class *class;
    struct device *device;
    struct device_node  *nd;
    struct i2c_client *private;
    short ir,ps,als;
};
struct ap3216c_dev ap3216cdev;
#define ap3216c_cnt 1
#define ap3216c__name "ap3216c"


/*读取ap3216c的N个寄存器值*/
static int ap3216c_read_regs(struct ap3216c_dev *dev, u8 reg, void *val, int len)
{
    struct i2c_client *client = (struct i2c_client *)dev->private;
    //struct i2c_msg msg[2];
    /*msg[0]发送要读取的寄存器的首地址   msg[1]读取数据*/
    struct i2c_msg msg[2] = {
        {
            .addr = client->addr,
            .flags = 0,
            .buf = &reg,
            .len = 1,
        },
        {
            .addr = client->addr,
            .flags = I2C_M_RD,
            .buf = val,
            .len = len,
        },
    };
#if 0
    msg[0].addr = client->addr;
    msg[0].flags = 0;
    msg[0].buf = &reg;
    msg[0].len = 1;

    msg[1].addr = client->addr;
    msg[1].flags = I2C_M_RD;
    msg[1].buf = val;
    msg[1].len = len;
#endif
    return i2c_transfer(client->adapter, msg, 2);
}
/*向ap3216写N个寄存器值*/
static int ap3216c_write_regs(struct ap3216c_dev *dev, u8 reg, u8 *buf, int len)
{
    u8 b[256];
    struct i2c_client *client = (struct i2c_client *)dev->private;
    //struct i2c_msg msg;
    /*msg[0]发送要读取的寄存器的首地址   msg[1]读取数据*/ 
    struct i2c_msg msg[1] = {
        {
            .addr = client->addr,
            .flags = 0,
            .buf = b,
            .len = len+1,
        },
    };
    b[0]=reg;
    memcpy(&b[1], buf, len);
#if 0
    b[0]=reg;
    memcpy(&b[1], buf, len);
    msg.addr = client->addr;
    msg.flags = 0;
    msg.buf = b;
    msg.len = len+1;
#endif
    return i2c_transfer(client->adapter, msg, 1);
}
static unsigned char ap3216c_read_reg(struct ap3216c_dev *dev, u8 reg)
{

    u8 data = 0; 
    ap3216c_read_regs(dev, reg, &data, 1);
    return data;
}
static void ap3216c_write_reg(struct ap3216c_dev *dev, u8 reg, u8 data)
{
    u8 buf = 0;
    buf = data;
    ap3216c_write_regs(dev, reg, &data, 1);
}
static int ap3216cdev_open(struct inode *inode, struct file *filp)
{
    int value = 0;
    filp->private_data = &ap3216cdev;
    
    ap3216c_write_reg(&ap3216cdev, AP3216C_SYSTEMCONG, 0X04);	
	mdelay(50);												
	ap3216c_write_reg(&ap3216cdev, AP3216C_SYSTEMCONG, 0X03);	
	value = ap3216c_read_reg(&ap3216cdev, AP3216C_SYSTEMCONG);	
    printk("value = %#x\r\n",value);
    return 0;
}
void ap3216c_readdata(struct ap3216c_dev *dev)
{
    unsigned char buf[6];
    unsigned char i;

	/* 循环读取所有传感器数据 */
    for(i = 0; i < 6; i++)	
    {
        buf[i] = ap3216c_read_reg(dev, AP3216C_IRDATALOW + i);	
    }
	
    if(buf[0] & 0X80) 	/* IR_OF位为1,则数据无效 */
    {
        dev->ir = 0;	
        dev->ps = 0	;
    } else {
		dev->ir = ((unsigned short)buf[1] << 2) | (buf[0] & 0X03); 			
		dev->ps = ((unsigned short)(buf[5] & 0X3F) << 4) | (buf[4] & 0X0F); 	
    }	
	dev->als = ((unsigned short)buf[3] << 8) | buf[2];	/* 读取ALS传感器的数据 			 */  
}
static int ap3216cdev_release(struct inode *inode, struct file *filp)
{
    printk("ap3216c release\r\n");

    return 0;
}
static ssize_t ap3216c_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
{
    short data[3];
    int err = 0;
    struct ap3216c_dev *dev = (struct ap3216c_dev *)filp->private_data;
    //printk("ap3216c read\r\n");
    ap3216c_readdata(dev);
    data[0] = dev->ir;
    data[1] = dev->als;
    data[2] = dev->ps;
    err = copy_to_user(buf, data, sizeof(data));

    return 0;
}
static const struct file_operations ap3216cdev_fops = {
    .owner = THIS_MODULE,
	.read = ap3216c_read ,
	.open = ap3216cdev_open,
	.release = ap3216cdev_release,
};
static int ap3216c_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
    int ret = 0;
    printk("ap3216 probe\n");
    ap3216cdev.major = 0; 
    if(ap3216cdev.major) {
        ap3216cdev.devid = MKDEV(ap3216cdev.major,0);
        ret = register_chrdev_region(ap3216cdev.devid, ap3216c_cnt, ap3216c__name);
    } else {
        ret = alloc_chrdev_region(&ap3216cdev.devid, 0, ap3216c_cnt, ap3216c__name);
        ap3216cdev.major = MAJOR(ap3216cdev.devid);
        ap3216cdev.minor = MINOR(ap3216cdev.devid);
    }
    if(ret < 0) {
        goto fail_devid;
    }
    printk("major = %d,minor = %d\r\n",ap3216cdev.major,ap3216cdev.minor);

    ap3216cdev.cdev.owner = THIS_MODULE;

    cdev_init(&ap3216cdev.cdev, &ap3216cdev_fops);
    ret = cdev_add(&ap3216cdev.cdev, ap3216cdev.devid,  ap3216c_cnt);
    if(ret < 0) {
        goto fail_cdev;
    }

    ap3216cdev.class = class_create (THIS_MODULE, ap3216c__name);
    if (IS_ERR(ap3216cdev.class)) {
		ret = PTR_ERR(ap3216cdev.class);
		goto fail_class;
	}
    ap3216cdev.device = device_create(ap3216cdev.class, NULL, ap3216cdev.devid, NULL,ap3216c__name);
    if (IS_ERR(ap3216cdev.device)) {
		ret = PTR_ERR(ap3216cdev.device);
		goto fail_device;
	}
    ap3216cdev.private = client;
    return 0;
fail_device:
    class_destroy(ap3216cdev.class);
fail_class:
    cdev_del(&ap3216cdev.cdev);
fail_cdev:
    unregister_chrdev_region(ap3216cdev.devid, ap3216c_cnt);
fail_devid:
    return ret;
}
static int ap3216c_remove(struct i2c_client *client)
{
    printk("ap3216 remove\r\n");
    device_destroy(ap3216cdev.class, ap3216cdev.devid);
    class_destroy(ap3216cdev.class);
    cdev_del(&ap3216cdev.cdev);
    unregister_chrdev_region(ap3216cdev.devid, ap3216c_cnt);
    return 0;

}
static const struct i2c_device_id ap3216c_id_table[] = {
	{ "ysy_ap3216c", 0 },
	{ },
};
static const struct of_device_id ap3216c_of_match_table[] = {
   {.compatible = "alientek,ap3216c"},
    { /*sentinel*/},
};

static struct i2c_driver i2c_driver = {
	.driver = {
		.name	= "ap3216c",
		.owner	= THIS_MODULE,
		.of_match_table = ap3216c_of_match_table,
	},
	.probe		= ap3216c_probe,
	.remove		= ap3216c_remove,
	.id_table	= ap3216c_id_table,
};

static int __init ap3216c_init(void)
{
    
    return i2c_add_driver(&i2c_driver);
}

static void __exit ap3216c_exit(void)
{   

    i2c_del_driver(&i2c_driver);
}

module_init(ap3216c_init);
module_exit(ap3216c_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("YSY");

3.3编写测试 APP

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <linux/input.h>


int main(int argc,char *argv[])
{
    int fd;
    int ret;
    unsigned short data[3];
    char *filename;
    unsigned short ir,ps,als;
    filename = argv[1];
    if(argc != 2)
    {
        printf("Error usage!\r\n");
        return -1;
    }
    fd=open(filename,O_RDWR);
    if(fd<0)
    {
        printf("file %s open fialed !\r\n",filename);
        return -1;
    }
    while(1) 
    {
        ret = read(fd, &data, sizeof(data));
        if(ret == 0) {
            ir = data[0];
            als = data[1];
            ps = data[2];
            printf("ir=%d, ps=%d, als=%d\r\n",ir,ps,als);
        }
        usleep(200000);

    }
    close(fd);
    return 0;
}
ap3216cApp.c 文件内容很简单，就是在 while 循环中不断的读取 AP3216C 的设备文件，从
而得到 ir 、 als 和 ps 这三个数据值，然后将其输出到终端上。
linux软件层修改i2c速率,Linux I2C驱动分析(三)----i2c_dev驱动和应用层分析
weixin_39637646的博客
05-09 779
一、i2c-dev驱动分析1.1、设备驱动注册分析这个驱动，还是从module_init()和module_exit()开始，程序如下：点击(此处)折叠或打开staticint__init i2c_dev_init(void){intres;printk(KERN_INFO"i2c /dev entries driver\n");res=register_chrdev(I2C_MAJOR, "i2...
linux i2c速度设置,I2C子系统之I2C总线时钟频率设置
weixin_33066321的博客
05-15 3285
可以发现此处已经将clk_p.rate修改为pclk了，默认值为0。调用函数s3c2410_baseclk_add()注册外设时钟的过程和注册总线时钟的过程类似，也是将各个定义好的外设时钟如：structclkinit_clocks_off[]={{......}，{.name="i2c",.id=-1,.parent=&clk_p,.enab...
详解Linux-I2C驱动
omnispace的博客
02-25 6974
目录 一、LinuxI2C驱动--概述 1.1 写在前面 1.2 I2C 1.3 硬件 1.4 软件 1.5 参考二、LinuxI2C驱动--I2C总线 2.1 I2C总线物理结构 2.2 I2C总线特性 2.3 开始和停止条件 2.4 数据传输格式 2.5 响应 2.6 总线仲裁三、LinuxI2C驱动--解析EEPROM的读写 3.1 概述 3.2 设备地址
pinctrl介绍
最新发布
weixin_60270984的博客
04-28 714
pinctrl
【Linux下i2c-tools工具使用】
Cool_summer_wind的博客
07-17 955
i2cdetect：检查总线挂载i2c设备情况i2cget：获取某个总线上某个设备的寄存器值i2cset：设置某个总线上某个设备的寄存器值i2cdump：查看某个总线上某个从设备（8位地址）所有寄存器的值i2ctranfer:向寄存器地址为16位的从设备读取或写入数据。
Linux I2C工具查看配置I2C设备【转】
weixin_34179762的博客
11-21 247
转自：http://blog.chinaunix.net/uid-26895763-id-3478882.html 在處理音訊相關的問題時，我通常會找個方法來讀寫codec中register的值。幸好linux上也有這樣的工具 – i2c tools。先到lm-sensors下載soure code，然後cross compile成arm的執行檔，就...
Linux I2C 驱动实验
qq_28576837的博客
10-18 887
首先肯定要描述 I2C 设备节点信息，先来看一下没有使用设备树的时候是如何在 BSP 里面描述 I2C 设备信息的，在未使用设备树的时候需要在 BSP 里面使用 i2c_board_info 结构体来描述一个具体的 I2C 设备。i2c_imx_start、i2c_imx_read、i2c_imx_write 和 i2c_imx_stop 这些函数就是 I2C 寄存器的具体操作函数，函数内容基本和我们裸机篇中讲的 I2C 驱动一样，这里我们就不详细的分析了，大家可以对照着第二十六章实验自行分析。
firefly-rk3288j开发板--linux I2C实验之eeprom驱动，包含驱动源码、测试app
06-10
适用用于linux内核驱动学习，参考
i2c.rar_44b0_i2c linux_linux i2c
09-21
"I2c"文件可能是具体的实验代码、配置文件或者日志，用于演示如何在Linux内核中注册I2C设备，如何编写I2C驱动，以及如何通过用户空间应用程序与I2C设备交互。这些文件可能包括Makefile、驱动源码、设备树配置、测试...
Linux i2c 连续 写长数据,「正点原子Linux连载」第六十一章Linux I2C驱动实验（二）...
weixin_32108979的博客
05-14 502
1)实验平台：正点原子Linux开发板2)摘自《正点原子I.MX6U嵌入式Linux驱动开发指南》关注官方微信号公众号，获取更多资料：正点原子61.3.2 I2C设备数据收发处理流程在61.1.2小节已经说过了，I2C设备驱动首先要做的就是初始化i2c_driver并向Linux内核注册。当设备和驱动匹配以后i2c_driver里面的probe函数就会执行，probe函数里面所做的就是字符设备驱动...
i.MX6ULL终结者Linux I2C驱动实验Linux I2C驱动框架简介
weixin_46635880的博客
01-11 261
文章目录1 I2C总线驱动2 I2C设备驱动3 I2C核心 在Linux内核中I2C的体系结构分为3个部分： ①　I2C核心：I2C核心提供了I2C总线驱动和设备驱动的注册、注销方法等。 ②　I2C总线驱动：I2C总线驱动是对I2C硬件体系结构中适配器端的实现，适配器可由CPU控制，甚至可以直接集成在CPU内部。 ③　I2C设备驱动：I2C设备驱动是对I2C硬件体系结构中设备端的实现，设备一般挂接在受CPU控制的I2C适配器上，通过I2C适配器与CPU交换数据。 1 I2C总线驱动 I2C总线和platfo
i2c Linux 动态 波特率,如何在Linux中设置i2c总线的波特率？
weixin_39561577的博客
05-14 379
我有一台基于riko-3288处理器的ARM计算机。我还具有带有自定义内核(不带模块系统)的设备的Ubuntu映像。我目前正在尝试为i2c总线设置最高100KHz的波特率。我不是Linux方面的专家，我不知道该怎么做。i2c总线的波特率更高，我认为它超过1MHz。我已经读过我必须在引导加载文件中写一个像这样的命令“ dtparam = i2c_arm = on，i2c_arm = on_baudr...
linux驱动学习笔记（九）I2C
weixin_35429431的博客
02-23 3619
前言 i2c协议是由 数据线SDA和时钟线SCL构成的串行总线，是半双工通信方式，一个I2c接口可以挂载多个从设备，但是每个从设备都会有唯一的器件地址， I2C速度在标准模式下为100k，快速模式下可以达到400k，高速模式下可以达到3.4M 时序介绍 空闲状态 SDA与SCL两条信号线同时处于高电平状态 起始信号 SCL为高的时候 SDA为下降沿 停止信号 SCL为高的时候 SDA为上升沿 数据传输 SCL为低时候 SDA数据可以变化。SCL为高的时候要求数据稳定 应答信号 I2C
查看linux开发板的CPU频率
heda3的博客
09-08 1854
该文章介绍Linux开发板的频率查看和设置命令
linux怎么看系统内存多大内存频率,Linux 查看 CPU 型号及内存频率及其它信息的命令...
weixin_42311972的博客
04-30 1319
查看 CPU：cat /proc/cpuinfo该命令可以查看系统CPU有多少个核，频率，特性等等。查看 cpu 内核频率cat /proc/cpuinfo |grep MHz|uniq//双核四线程的 cpu 当前的数据cpu MHz : 801.406cpu MHz : 799.878cpu MHz : 799.968cpu MHz : 815.332查看内存：...
Linux I2C 应用编程
10-10 1740
Linux I2C 应用编程 设备文件 /dev/i2c-x x是I2C总线号，即一组SCL和SDA，一条总线上可以挂接多个I2C设备，通信时以设备地址区分，不体现在系统设备文件上。 对于树莓派，启用I2C功能后，有一条总线，即一个设备： /dev/i2c-1 i2c-0被eeprom占用未导出 树莓派I2C相关PIN定义参考https://pinout.xyz/pinout/i2c# 用户空间设备操作ioctl 相关头文件 #include <linux/i2c-dev.h> #inclu
linux下i2c分析,【linux】i2c使用分析&源码实战
weixin_39776817的博客
05-13 477
目录前言1. 设备检查命令1.1 查看I2C驱动1.2 i2c-tools1.2.1 I2C-detect安装1.2.2 i2cdetect 命令1.2.3 i2cget 命令1.2.4 i2cset 命令1.2.5 i2cdump 命令2. 源码实战2.1 编写 bsp_mpu6050.h 文件2.2 编写 bsp_mpu6050.c 文件2.3 编写 main.c 文件相关链接前言目前不涉及驱...
Linux驱动（四）platform总线匹配过程
cesheng3410的博客
01-12 2012
详细讲解platform总线匹配过程，根据内核代码梳理匹配流程
Linux I2C设备驱动基本规范
飞翔de刺猬
08-03 2849
不同于单片机驱动开发，即使是简单的I2C设备驱动程序，如果要在Linux上实现同种功能的驱动程序，事情也会变的复杂起来。对于初学者而言，主要的困难就是不知道如何使用Linux现有的驱动框架，去完成驱动程序的开发。I2C设备驱动，相对来说比较简单，但由于Linux大部分设备驱动框架十分的类似，所以，通过对于I2C驱动框架的学习，可以作为继续深入Linux其他设备驱动框架的基础。 学习一项技术的最好方式就是去应用它，所以为了更为高效的学习，本文结合两个i2c设备驱动实例，来分析如何从零实现一个驱动程序。 程序框
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值