Linux学习笔记（二）IIC驱动编写

已于 2024-07-15 21:22:31 修改
阅读量748 收藏 19
点赞数 6
文章标签： 学习 笔记 linux
于 2024-07-15 21:22:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Norgin_1/article/details/140446018
版权

目录

IIC驱动的设备树配置

IIC设备驱动的代码编写

 ap3216c_probe函数的实现

字符设备驱动编写

其余部分 

IIC读写函数的实现

IIC读任意长度

IIC写任意长度

封装成读写单个

封装一个读传感器数据的函数

测试APP函数的编写

驱动函数完整版

结尾

        本笔记是基于正点原子IMX6ULL开发板的学习。实现功能是对AP3216C传感器进行配置和数据的读写。

IIC驱动的设备树配置

        一个IIC驱动的设备，可以抽象为一个挂载在开发板硬件IIC上的一个节点。如下图所示，我的AP3216C器件可以直接抽象为一个挂载在开发板硬件i2c1下的一个节点（板子上有若干个i2cx，想挂载在哪个下面，就在哪个下面创建节点）。这个节点下有一个compatible属性，这个属性是用来后续驱动编写时的器件配对，而reg属性则是这个器件的七位地址（在这个节点下也可以添加中断引脚属性等）。

        下图的红框部分 ，是关于这个硬件i2c1，的配置信息，从箭头指向的pinctrl_i2c1，可以找到相关的引脚配置信息，如果需要修改i2c1用不同的引脚，可以在pinctrl_i2c1下修改。

        自此，我们就在dts设备树下创建好了iic设备的节点，后续的驱动代码编写就十分方便了。

IIC设备驱动的代码编写

        工程文件的目录如下图所示，其中设备驱动的重点部分是ap3216c.c的编写，接下来重点关注这个文件代码的编写。

         根据Linux驱动代码的编写惯例，我们应该先写好设备初始化函数和设备注销函数。

//驱动初始函数
static int __init ap3216c_init(void)
{
    int ret = 0;
/*在驱动初始化时，我们应该添加一个iic设备*/
    ret = i2c_add_driver(&ap3216c_driver);
    return ret;
}   
//驱动注销函数
static void __exit ap3216c_exit(void)
{
/*在驱动注销时，我们应该把这个注册的iic设备给删除*/
    i2c_del_driver(&ap3216c_driver);
}


module_init(ap3216c_init);//注册驱动初始化函数
module_exit(ap3216c_exit);//注册驱动注销函数

        在添加和删除iic设备时，会用到一个参数，这个参数就是iic设备结构体。其结构体在本项目中用到的构成如下，完成设备的驱动编写，重点就是完善这个结构体。

static struct i2c_driver ap3216c_driver = 
{
    .probe = ap3216c_probe,    //一个函数指针，指向的probe函数用于设备的探测和初始化
    .remove = ap3216c_remove,  //一个函数指针，指向的remove函数用于设备的注销和删除
    .driver ={
        .name = "ap3216c",         //设备的名称
        .owner = THIS_MODULE,      //声明所有者
        .of_match_table = of_match_ptr(ap3216c_of_match),
/*这个是函数匹配表，此处用of_match_ptr函数来进行匹配，将匹配的结果返回给函数匹配表，ap3216c_of_match传入的是所要匹配的目标字段*/
    },
    .id_table = ap3216c_id,//这里是用非设备树的匹配方式
};
/*非设备树匹配*/
static struct  i2c_device_id ap3216c_id[]=
{
    {"alientek,ap3216c",0},//传入设备的名字和id，用名字和id来进行匹配
    {}
};

/*dts设备树匹配*/
static struct  of_device_id ap3216c_of_match[]=
{
    {.compatible = "alientek,ap3216c"},
/*用设备树的compatible属性来匹配，只有compatible属性值相同才能匹配成功，可以理解为在设备树搜寻我们想要配置的设备信息*/
    {}
};

 ap3216c_probe函数的实现

        此部分可以理解为iic设备的用户层初始化。

static int ap3216c_probe(struct i2c_client *client, const struct  i2c_device_id *id)
/*这个函数的格式是规定的，可以参考Linux内核的一些驱动例子，其中传入的参数有两个，一个是 i2c_client *client的结构体指针。
另一个是i2c_device_id *id的数组首地址，分别对应了使用了设备树和不使用设备树的两种情况，这个i2c_client结构体内部包含的信息是初始化过程中自动获取的，直接调用即可*/
{
    /*正点原子教程中，在这里初始化了一个字符设备驱动，目的是为了便于使用这个框架的读写函数去获取iic设备的值*/
    int ret = 0;
    printk("ap3216c_probe\r\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)
    {
        printk("ap3216c chrdev_region err!\r\n");
        goto fail_devid;
    }
    printk("ap3216c major = %d, minor = %d\r\n",ap3216cdev.major,ap3216cdev.minor);

    ap3216cdev.cdev.owner = THIS_MODULE;
    cdev_init(&ap3216cdev.cdev,&ap3216c_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_data = 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;
    
}

字符设备驱动编写

        字符设备驱动的编写主要由以下步骤：

        第一步创建一个用户的字符设备结构体：

struct ap3216c_dev{
    int major;    //主设备号
    int minor;    //次设备号
    dev_t devid;  //设备id结构体
    /*注释部分为后续会用到，但是现在暂时用不到，这个结构体的完善是个循序渐进的过程*/
    /*
    struct cdev cdev;
    struct class *class;
    struct device *device;
    void *private_data;
    unsigned short ir,als,ps;*/
};

static struct ap3216c_dev ap3216cdev;

        第二步注册设备号：

 ap3216cdev.major = 0;//此处写0就是由系统分配设备号，不人为指定。
    if(ap3216cdev.major)//这里判断，如果不是0则认为指定了设备号，就按照这个设备号去申请
    {
        ap3216cdev.devid = MKDEV(ap3216cdev.major,0);//这里两个变量分别为主、次设备号。
        ret = register_chrdev_region(ap3216cdev.devid,AP3216C_CNT,AP3216C_NAME);
    }
    else//如果是0则由系统分配
    {
        ret = alloc_chrdev_region(&ap3216cdev.devid,0,AP3216C_CNT,AP3216C_NAME);
        ap3216cdev.major = MAJOR(ap3216cdev.devid);//通过设备id结构体把申请到的主、次设备号赋值到结构体的变量中
        ap3216cdev.minor = MINOR(ap3216cdev.devid);
    }
    if(ret<0)//如果返回值小于0则表明出错了，跳到fail_devid去处理（后续再统一介绍）
    {
        printk("ap3216c chrdev_region err!\r\n");
        goto fail_devid;
    }

        第三步初始化一个字符设备结构体

struct ap3216c_dev{
    int major;    //主设备号
    int minor;    //次设备号
    dev_t devid;
    struct cdev cdev; //系统的字符设备结构体
    /*注释部分为后续会用到，但是现在暂时用不到，这个结构体的完善是个循序渐进的过程*/
    /*
    struct class *class;
    struct device *device;
    void *private_data;
    unsigned short ir,als,ps;*/
};

static struct ap3216c_dev ap3216cdev;
#define AP3216C_CNT      1


//字符设备操作集，内部除了指定所有者的变量，其余都是函数指针，指向对应操作的函数，需要用户实现
    static const struct file_operations ap3216c_fops = {
        .owner = THIS_MODULE,
        .open = ap3216c_open,
        .release = ap3216c_release,
        .read = ap3216c_read,
    };    





    ap3216cdev.cdev.owner = THIS_MODULE;        //指定这个字符设备的所有者
    cdev_init(&ap3216cdev.cdev,&ap3216c_fops);  //初始化一个字符设备操作集
    ret = cdev_add(&ap3216cdev.cdev,ap3216cdev.devid,AP3216C_CNT);//添加一个（数量由AP3216C_CNT决定）字符设备
    if(ret<0)
    {
        goto fail_cdev;
    }

        第四步 添加一个类和在这个类下注册一个设备实例子

struct ap3216c_dev{
    int major;    //主设备号
    int minor;    //次设备号
    dev_t devid;
    struct cdev cdev; //系统的字符设备结构体
    struct class *class;
    struct device *device;
    /*注释部分为后续会用到，但是现在暂时用不到，这个结构体的完善是个循序渐进的过程*/
    /*
    void *private_data;
    unsigned short ir,als,ps;*/
};

static struct ap3216c_dev ap3216cdev;
    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);//创建一个设备实例子
/*参数分别为：
类（class）：这是一个指向 struct class 结构体的指针，表示新设备应该属于哪个设备类别。
父设备（parent）：这是一个指向 struct device 结构体的指针，表示新设备的父设备。如果新设备没有父设备，则这个参数可以是 NULL。
设备号（devt）：这是一个 dev_t 类型的值，用于唯一标识设备。通常，这个值是通过 MKDEV 宏从主设备号和次设备号计算得到的。
设备（device）：这是一个指向 struct device 结构体的指针，表示要创建的新设备。通常，这个结构体在调用 device_create 之前已经被初始化，并且它的 class 成员已经设置为了正确的设备类。如果传入NULL，则为不打算立即使用一个已经分配和初始化的 struct device 结构体实例。
设备名称（fmt, ...）：这是一个格式字符串和一系列参数，用于生成设备的名称。这个名称将用于在 /sys 文件系统中创建设备的目录。
*/
    if(IS_ERR(ap3216cdev.device))//判断是否注册成功
    {
        ret = PTR_ERR(ap3216cdev.device);
        goto fail_device;
    }

其余部分 

        在完成字符设备的编写后，还有以下几行代码，其主要作用如下：

    ap3216cdev.private_data = client;//这里创建了一个私有数据，这个私有数据保存了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;

ap3216c_remove函数的实现

        此部分在iic驱动注销时会调用，学过c++可以理解为与probe函数互为构造、析构函数，主要是实现了有关字符设备的注销操作。

static int ap3216c_remove(struct i2c_client *client)
{
    cdev_del(&ap3216cdev.cdev); //字符设备的删除

    unregister_chrdev_region(ap3216cdev.devid,AP3216C_CNT); //用于注销之前注册的字符设备区域

    device_destroy(ap3216cdev.class,ap3216cdev.devid); //摧毁设备实例，释放资源

    class_destroy(ap3216cdev.class); //摧毁设备类

    return 0;
}

字符设备操作集函数的实现

        主要实现的函数如下：

static const struct file_operations ap3216c_fops = {
    .owner = THIS_MODULE,
    .open = ap3216c_open,
    .release = ap3216c_release,
    .read = ap3216c_read,
};
//字符操作设备被打开时执行芯片的初始化
static int ap3216c_open(struct inode *inode,struct file *filp)
{
    unsigned char value = 0;
    filp->private_data = &ap3216cdev;
    printk("ap3216c_open\r\n");
    /*初始化ap3216c芯片*/
    ap3216c_write_reg(filp->private_data,AP3216C_SYSTEMCONG,0x04);
    mdelay(50);
    ap3216c_write_reg(filp->private_data,AP3216C_SYSTEMCONG,0x03);
    value = ap3216c_read_reg(filp->private_data,AP3216C_SYSTEMCONG);
    printk("AP3216C_SYSTEMCONG:%#x\r\n",value);

    return 0;
}
//这里是被释放即被关闭时实现的代码，只是简单打印了一句话，没有实际用到
static int ap3216c_release(struct inode *inode,struct file *filep)
{
    struct ap3216c_dev *dev = (struct ap3216c_dev*)filep->private_data;
    printk("ap3216c_release\r\n");
    return 0;
}
//这里是实现读函数，主要是实现对iic设备寄存器的读取，这里读出了三个值，红外强度，光强，距离
ssize_t ap3216c_read(struct file *file,char __user *buf,size_t cnt,loff_t *off)
{
    long err;
    short data[3];
    struct ap3216c_dev *dev = (struct ap3216c_dev *)file->private_data;
    //printk("ap3216c_read\r\n");D
    ap3216c_readdata(dev);//这里的读函数后面会有介绍
    /*返回传感器数据*/
    data[0] = dev->ir;
    data[1] = dev->als;
    data[2] = dev->ps;

    err = copy_to_user(buf,data,sizeof(data));
    return err;
}

IIC读写函数的实现

        我们先实现的是读写任意长度的的值，最后再封装成读写单个字节的值，具体实现下面会介绍

IIC读任意长度

static int ap3216c_read_regs(struct ap3216c_dev *dev,u8 reg,void *val, int len)
{
    struct i2c_msg msg[2]; //这个是IIC读写的信息块（结构体组成），一个就是执行一次读写操作，这里执行一次读的话要两个信息块，第一个告诉器件读哪个地址，第二个读出器件对应寄存器的值。
    struct i2c_client *client = (struct i2c_client*)dev->private_data;//前文定义的私有变量是用在这里，为的是获取器件的ID
    msg[0].addr = client->addr;    //可在client结构体的addr成员中获取到
    msg[0].flags = 0;              //flags=0表明执行写操作
    msg[0].buf = &reg;             //写入的值，传递一个reg变量，根据iic协议我们要先告诉iic器件我们要读哪个寄存器，这里的reg就是要读的寄存器，   
    msg[0].len = 1;                //写入的长度，这里reg是一个u8所以长度是一

    msg[1].addr = client->addr;    //同上
    msg[1].flags = I2C_M_RD;       //这里的这个宏是读器件地址的意思
    msg[1].buf = val;              //读取数据的缓冲区，是一个指针（读出来的值会放在这里）
    msg[1].len = len;              //要读的数据长度

    return i2c_transfer(client->adapter,msg,2);    //开启一次iic通讯（收发用同一个）这里第一个参数adap：是所使用的 I2C 适配器， i2c_client 会保存其对应的 i2c_adapter（client自动创建，自动获取）。


}

IIC写任意长度

static int ap3216c_write_regs(struct ap3216c_dev *dev,u8 reg,u8 *buf,u8 len)
{
    u8 b[256];    //这是我们要写入的数据的缓冲区
    struct i2c_msg msg[1];    //写函数用一个信息块就可以实现
    struct i2c_client *client = (struct i2c_client*)dev->private_data;//同上
    b[0] = reg;        //这里我们让缓冲区第一个元素为我们要写入的寄存器地址，由IIC写的规则可知，先写寄存器地址，再写数据。这里把寄存器地址放在缓冲区的0号元素，就是实现这里的功能
    memcpy(&b[1],buf,len);//把用户传递进来要写的值，从1号元素开始以此拷贝进缓冲区以备发送
    msg[0].addr = client->addr;//同上
    msg[0].flags = 0;//同上
    msg[0].buf = b;//发送缓冲区的首地址
    msg[0].len = len+1;//因为我们0号元素填充了一个寄存器地址，而len是我们传递进来要发送的数据的个数，算上先发送的寄存器地址，一共是发len+1个元素

    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,&buf,1);
}

封装一个读传感器数据的函数

        这个函数便是前面在字符设备操作集中，读函数内实现的功能，一下子读出器件的测量的三个值。

        这里我们为了便于保存着三个值，我们在用户定义的字符设备结构体中声明三个变量，直接把换算号的传感器值保存在结构体内。

struct ap3216c_dev{
    int major;
    int minor;
    dev_t devid;
    struct cdev cdev;
    struct class *class;
    struct device *device;
    void *private_data;
    unsigned short ir,als,ps;//定义三个变量接收传感器的三个值
};
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;					
	else 				/* 读取IR传感器的数据   		*/
		dev->ir = ((unsigned short)buf[1] << 2) | (buf[0] & 0X03); 			
	
	dev->als = ((unsigned short)buf[3] << 8) | buf[2];	/* 读取ALS传感器的数据 			 */  
	
    if(buf[4] & 0x40)	/* IR_OF位为1,则数据无效 			*/
		dev->ps = 0;    													
	else 				/* 读取PS传感器的数据    */
		dev->ps = ((unsigned short)(buf[5] & 0X3F) << 4) | (buf[4] & 0X0F); 	
}

测试APP函数的编写

        这部分比较简单，不再赘述，大家一看就能懂。

int main(int argc, char *argv[])

{

	int fd, err;

	char *filename;

	unsigned short data[3];

	unsigned short ir,ps,als;



	if(argc !=2){

		printf("error usage!\r\n");

		return -1;

	}

	filename = argv[1];

	fd = open(filename,O_RDWR);

	if(fd<0){

		printf("file %s open failed!\r\n",filename);

		return -1;

	}

	while (1)

	{

		err = read(fd,&data,sizeof(data));

		if(err == 0){

			ir = data[0];

			als = data[1];

			ps = data[2];

			printf("AP3216C ir = %d,als = %d,ps = %d\r\n",ir,als,ps);

		}

		usleep(200000);

	}

	

	close(fd);

	return 0;

}

驱动函数完整版

    ap3216c.c

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

#define AP3216C_CNT      1
#define AP3216C_NAME    "ap3216c"

struct ap3216c_dev{
    int major;
    int minor;
    dev_t devid;
    struct cdev cdev;
    struct class *class;
    struct device *device;
    void *private_data;
    unsigned short ir,als,ps;
};
static struct ap3216c_dev ap3216cdev;

static int ap3216c_read_regs(struct ap3216c_dev *dev,u8 reg,void *val, int len)
{
    struct i2c_msg msg[2];
    struct i2c_client *client = (struct i2c_client*)dev->private_data;
    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;

    return i2c_transfer(client->adapter,msg,2);

}

static int ap3216c_write_regs(struct ap3216c_dev *dev,u8 reg,u8 *buf,u8 len)
{
    u8 b[256];
    struct i2c_msg msg[1];
    struct i2c_client *client = (struct i2c_client*)dev->private_data;
    b[0] = reg;
    memcpy(&b[1],buf,len);
    msg[0].addr = client->addr;
    msg[0].flags = 0;
    msg[0].buf = b;
    msg[0].len = len+1;


    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,&buf,1);
}


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;					
	else 				/* 读取IR传感器的数据   		*/
		dev->ir = ((unsigned short)buf[1] << 2) | (buf[0] & 0X03); 			
	
	dev->als = ((unsigned short)buf[3] << 8) | buf[2];	/* 读取ALS传感器的数据 			 */  
	
    if(buf[4] & 0x40)	/* IR_OF位为1,则数据无效 			*/
		dev->ps = 0;    													
	else 				/* 读取PS传感器的数据    */
		dev->ps = ((unsigned short)(buf[5] & 0X3F) << 4) | (buf[4] & 0X0F); 	
}




static int ap3216c_open(struct inode *inode,struct file *filp)
{
    unsigned char value = 0;
    filp->private_data = &ap3216cdev;
    printk("ap3216c_open\r\n");
    /*初始化芯片*/
    ap3216c_write_reg(filp->private_data,AP3216C_SYSTEMCONG,0x04);
    mdelay(50);
    ap3216c_write_reg(filp->private_data,AP3216C_SYSTEMCONG,0x03);
    value = ap3216c_read_reg(filp->private_data,AP3216C_SYSTEMCONG);
    printk("AP3216C_SYSTEMCONG:%#x\r\n",value);

    return 0;
}

static int ap3216c_release(struct inode *inode,struct file *filep)
{
    struct ap3216c_dev *dev = (struct ap3216c_dev*)filep->private_data;
    printk("ap3216c_release\r\n");
    return 0;
}

ssize_t ap3216c_read(struct file *file,char __user *buf,size_t cnt,loff_t *off)
{
    long err;
    short data[3];
    struct ap3216c_dev *dev = (struct ap3216c_dev *)file->private_data;
    //printk("ap3216c_read\r\n");D
    ap3216c_readdata(dev);
    /*返回传感器数据*/
    data[0] = dev->ir;
    data[1] = dev->als;
    data[2] = dev->ps;

    err = copy_to_user(buf,data,sizeof(data));
    return err;
}

static const struct file_operations ap3216c_fops = {
    .owner = THIS_MODULE,
    .open = ap3216c_open,
    .release = ap3216c_release,
    .read = ap3216c_read,
};



static int ap3216c_probe(struct i2c_client *client, const struct  i2c_device_id *id)
{
    int ret = 0;
    printk("ap3216c_probe\r\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)
    {
        printk("ap3216c chrdev_region err!\r\n");
        goto fail_devid;
    }
    printk("ap3216c major = %d, minor = %d\r\n",ap3216cdev.major,ap3216cdev.minor);

    ap3216cdev.cdev.owner = THIS_MODULE;
    cdev_init(&ap3216cdev.cdev,&ap3216c_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_data = 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)
{
    cdev_del(&ap3216cdev.cdev);

    unregister_chrdev_region(ap3216cdev.devid,AP3216C_CNT);

    device_destroy(ap3216cdev.class,ap3216cdev.devid);

    class_destroy(ap3216cdev.class);

    return 0;
}


/*traditional*/
static struct  i2c_device_id ap3216c_id[]=
{
    {"alientek,ap3216c",0},
    {}
};

/*dts*/
static struct  of_device_id ap3216c_of_match[]=
{
    {.compatible = "alientek,ap3216c"},
    {}
};




/*i2c_driver*/
static struct i2c_driver ap3216c_driver = 
{
    .probe = ap3216c_probe,
    .remove = ap3216c_remove,
    .driver ={
        .name = "ap3216c",
        .owner = THIS_MODULE,
        .of_match_table = of_match_ptr(ap3216c_of_match),
    },
    .id_table = ap3216c_id,
};



static int __init ap3216c_init(void)
{
    int ret = 0;
    ret = i2c_add_driver(&ap3216c_driver);
    return ret;
}   

static void __exit ap3216c_exit(void)
{
    i2c_del_driver(&ap3216c_driver);
}


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

ap3216creg.h 

#ifndef AP3216C_H
#define AP3216C_H

#define AP3216C_ADDR    	0X1E	/* AP3216C器件地址 */

/* AP3316C寄存器 */
#define AP3216C_SYSTEMCONG	0x00	/* 配置寄存器 			*/
#define AP3216C_INTSTATUS	0X01	/* 中断状态寄存器 			*/
#define AP3216C_INTCLEAR	0X02	/* 中断清除寄存器 			*/
#define AP3216C_IRDATALOW	0x0A	/* IR数据低字节 			*/
#define AP3216C_IRDATAHIGH	0x0B	/* IR数据高字节 			*/
#define AP3216C_ALSDATALOW	0x0C	/* ALS数据低字节 		*/
#define AP3216C_ALSDATAHIGH	0X0D	/* ALS数据高字节			*/
#define AP3216C_PSDATALOW	0X0E	/* PS数据低字节 			*/
#define AP3216C_PSDATAHIGH	0X0F	/* PS数据高字节 			*/


#endif // !AP3216C_H

结尾

        今天用了一天时间，整理总结了IIC驱动的编写，复习了字符设备的驱动编写。用这篇博客，便于将来复习。

Norgin_1
关注
  • 6
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
IIC.zip_IIC驱动开发_linux iic
09-24
本压缩包"IIC.zip_IIC驱动开发_linux iic"包含了针对Linux系统的IIC驱动程序的开发实例，这对于理解IIC驱动的工作原理和开发流程至关重要。 IIC协议的核心特点在于其使用两条数据线：SDA（串行数据线）和SCL（时钟...
linux-iic.rar_Linux IIC驱动_linux iic
09-14
通过深入学习和分析`linux-iic.rar`提供的源码，开发者可以更好地理解和实现自己的I2C驱动程序，提高与硬件交互的效率和可靠性。同时，对于系统维护和优化，理解I2C驱动的工作方式也至关重要。在实际开发中，结合...
【Linux学习笔记】IIC驱动
第六个葫芦娃的博客
07-23 298
同系列笔记已放置链接在上面。
Linux驱动开发笔记（九）IIC子系统及其驱动
sincerelover的博客
06-20 1123
IIC我们已经学习过很多次了，在应用部分我们已经介绍过其应用层的开发，这章我们将继续驱动部分的开发。本次实验采用MPU6050，使用了input子系统及IIC子系统构成。MPU6050是全球首例整合性6轴（3轴陀螺仪+3轴加速度计）运动处理组件，也可以通过扩展实现9轴运动处理（在连接三轴磁传感器后）。它集成了三轴MEMS陀螺仪和三轴MEMS加速度计，以及一个可扩展的数字运动处理器DMP（Digital Motion Processor）。
Linux驱动开发学习笔记-驱动开发基础知识
weixin_45593094的博客
06-02 1383
《原子Linux开发》1. 字符设备开发基础知识：1)字符设备：就是一个一个字节，按照字节流进行读写操作的设备，读写数据是分先后顺序的。 比如常见的点灯，按键，IIC，SPI，LCD等都是字符设备。2)Linux中一切皆文件，驱动加载成功后会在“/dev”目录下生成一个相应的文件，应用程序通过对这个名为“/dev/xxx”(xxx是具体驱动文件名)进行 相应操作即可实现对硬件的操作。3)应用程序运行在用户空间，驱动运行于内核空间，用户空间不能直接对内核进行操作，因此必须使用“系统调用”的方式
Linux驱动开发学习笔记-设备树
weixin_45593094的博客
06-02 486
1、设备树1) 将描述板级硬件信息的内容都从 Linux 内中分离开来，用一个专属的文件格式来描述， 这个专属的文件就叫做设备树，文件扩展名为.dts。 一个 SOC 可以作出很多不同的板子，这些不同的板子肯定是有共同的信息， 将这些共同的信息提取出来作为一个通用的文件，其他的.dts 文件直接引用这个通用文件即可， 这个通用文件就是.dtsi 文件，类似于 C 语言中的头文件。 .dts 描述板级信息(也就是开发板上有哪些 IIC 设备、SPI 设备等)， .d
IIC__driver.rar_LINUX iic 驱动_linux iic
09-21
二、Linux中的IIC子系统 在Linux内核中，IIC子系统负责处理与硬件IIC总线的交互。它提供了驱动模型，使得开发者可以编写特定硬件的IIC驱动程序。IIC子系统的核心组件包括： 1. **i2c-core**: 这是IIC子系统的内核...
Linux应用层使用IIc驱动SSD1306芯片的OLED
06-04
总的来说，Linux应用层使用I2C驱动SSD1306芯片的OLED涉及到理解I2C协议、使用I2C工具、选择合适的库、编写应用代码以及在服务器环境中的实际应用。通过实践，你可以掌握这一技术，并将其应用于各种嵌入式和服务器...
IIc.rar_IIC_iic驱动_linux iic_嵌入式linux 驱动
09-23
总的来说，理解并编写嵌入式Linux下的IIC驱动是一项挑战性的任务，需要深入理解IIC协议、内核驱动模型以及具体的硬件特性。通过分析"IIc.c"，开发者可以学习如何与硬件交互，实现高效可靠的IIC通信，这对于在嵌入式...
Linux：基础命令学习
qq_55038440的博客
07-20 1472
实例：-F根据文件类型在列出的文件名称后加一符号。实例： -R 递归显示目录中的所有文件和子目录。. 开头的隐藏文件也会列出。可执行文件则加 "*"，用于显示目录文件信息。
AvaloniaUI的学习
最新发布
lishuangquan1987的博客
07-25 769
官方中文文档：https://docs.avaloniaui.net/zh-Hans/docs/welcome。
Python编程学习第一篇——Python零基础快速入门（六）（4）异常处理
urhero的专栏
07-25 268
我们已经了解了Python的基本数据类型、变量和基本的逻辑控制语句，基于这些基础知识可以编写一些小程序了，但是在写程序的时候我们会发现，有时候程序并不是按我们预期的方向执行，有的直接报错，有的没有报错，却并未得到我们预期的结果。在这个例子中，除数为0会引发ZeroDivisionError异常，我们将异常信息赋值给变量e，并输出"除数不能为0"和异常信息。在这个例子中，由于除数不为0，所以没有发生ZeroDivisionError异常，代码会执行else语句块，并输出结果2.0。
FastAPI（八十）实战开发《在线课程学习系统》接口开发-- 课程列表
mr~li的博客
07-25 245
源码见："
SAP PP学习笔记31 - 计划运行的步骤2 - Scheduling(日程计算)，BOM Explosion(BOM展开）
shi_ly的专栏
07-24 754
本章主要讲Scheduling(日程计算),其中包括 外部调达中的调度，生产订单中的调度，修改需求日期(其实就是在物料中增加安全时间和BOM中的提前期偏置量)。另外还讲了BOM展开的内容，详细讲了BOM选择的各种方法，除了按数量选BOM之外，还有其他比如 按日期，按生产版本等，而其中按日期又分为按订单开始日期，订单终了日期等，越趋复杂。
前端学习1——自学习梳理
qq_63125992的博客
07-24 280
【代码】前端学习1——自学习梳理。
虚拟机学习
weixin_63374588的博客
07-25 201
虚拟机的优点：虚拟机使用教程：
(leetcode学习)110. 平衡二叉树
m0_54888411的博客
07-24 364
很久没写结构体了，复习一下。学习二叉树的通用解题方法。给定一个二叉树，判断它是否是。
7-23学习笔记
L14173233的博客
07-23 636
/检查性异常 是Exception的直接子类创建对象的方法1 new2 克隆3 反序列化4 反射。
Linux iic 驱动
04-01
Linux iic驱动是一种用于控制iic总线的驱动程序，它将I2C总线上的数据传输和控制操作封装成了一组API函数，以便用户能够轻松地访问和控制I2C设备。 在Linux内核中，iic驱动程序使用i2c_adapter结构体来表示I2C总线的适配器，该结构体包含了总线的硬件特性和操作方法。用户可以通过调用i2c_add_adapter()函数来注册一个I2C适配器。一旦适配器注册成功，用户就可以使用i2c_transfer()函数来进行I2C数据传输，并使用其他API函数来控制和查询I2C设备。 Linux iic驱动程序的开发需要掌握Linux内核编程和I2C协议相关知识。在开发过程中，需要针对不同的I2C设备编写不同的驱动程序，以便能够正确地控制设备并与之通信。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值