Linux驱动之i2c驱动

最新推荐文章于 2024-07-16 10:42:05 发布
最新推荐文章于 2024-07-16 10:42:05 发布
阅读量4.1k 收藏 20
点赞数 1
分类专栏： 驱动 文章标签： linux 嵌入式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Pintitus/article/details/122629813
版权

一、I2C简介

​ I2C是很常用的总线协议。它使用两条线在主控制器与从机直接进行数据通信。一条是时钟线，一条是数据线，两条数据线都要接4.7K的上拉电阻，空闲的时候处于高电平。I2C总线的标准模式下传输速度可以达到100k/s，快速模式达到400k/s。

​ 常见的I2C驱动从设备有电容触摸屏，CMOS camera ，重力传感器，EEPROM,HDMI。

在这里插入图片描述

二、I2C的协议内容

​ 起始位S：数据位电平拉低

​ 停止位P：数据位拉高

在这里插入图片描述

​ ACK1：MASTER发送完地址后，SLIVER将数据位拉低，响应主机。

​ ACK2：读写完以后，主机拉低数据位，告诉SLIVER进行回应。

写数据：

​ 主机发送起始位S信号，发送i2c从机的地址，发送写位，ACK1，写入从机的寄存器的8位数据，然后循环写数据，最后从机ACK2应答，并且主机发送停止位信号。

读数据：

​ 写入设备地址，写入寄存器地址，读取设备地址，读取寄存器的值。

​ 阶段一：主机发送S，写入I2C设备地址，ACK1从机响应。

​ 阶段二：重发S，发送寄存器的地址，从机ACK1响应。

​ 阶段三：重发S，发送I2C设备地址，读位，ACK1响应。

​ 阶段四：读取数据，ACK2主机拉低信号读完8bit，主机发送P。

三、I2C子系统框架

分为应用层，驱动层与硬件层三层。

其中驱动层可分为三层:i2c_driver，i2c_core，i2c_adaptor。分别是驱动层，内核层以及适配器层。驱动层是设备的IO的驱动程序。内核层是将设备与驱动分离的两个链表，使得设备树信息与驱动程序进行匹配。适配器层是用于提供硬件协议的执行算法，一般由供应商提供。

I2C相关的API：

struct i2c_driver{
  int (*probe)(struct i2c_client * , const struct i2c_device_id *);
  int (*remove)(struct i2c_client *);
  struct device_driver driver;
  const struct i2c_device_id *id_table;
};
//注册与注销：
int i2c_add_driver(struct i2c_driver *driver)；
void i2c_del_driver(struct i2c_driver *driver);

//发送接收消息
int i2c_master_send(const struct i2c_client *client, const char *buf, int count);
int i2c_master_recv(const struct i2c_client *client, char *buf, int count);

struct i2c_client {
	unsigned short addr;	//从设备地址，来源于设备树中的reg = <0x68>
	char name[I2C_NAME_SIZE];	//用于与i2c_driver进行匹配的compatible信息
    struct i2c_adapter *adapter;
    struct device dev;
};

//创建i2c_client的函数
struct i2c_client * i2c_new_device(struct i2c_adapter *adap , struct i2c_board_info const *info);

​ 其中i2c_client相当于设备数中的i2c结点的信息，i2c_adapter相当于设备树中i2c总线上挂在的设备的信息。因此我们在后面编写读写程序的时候会将i2c_client中的信息传递给i2c_adapter。

&i2c1 {
	//i2c_client
	clock-frequency = <100000>;
	pinctrl-names = "default";
	pinctrl-0 = <&pinctrl_i2c1>;
	status = "okay";

	mpu6050@68 {
        //i2c_adapter
		compatible = "mpu6050,INV_MPU6050";
		reg = <0x68>;
	};
};

I2C读写信息实现：

​ I2C的收发其实是使用i2c_transfer函数实现的。唯一的不同点是i2c_msg结构体的flags中读是1，写是0。

/**
 * i2c_master_send - issue a single I2C message in master transmit mode
 * @client: Handle to slave device
 * @buf: Data that will be written to the slave
 * @count: How many bytes to write, must be less than 64k since msg.len is u16
 *
 * Returns negative errno, or else the number of bytes written.
 */
int i2c_master_send(const struct i2c_client *client, const char *buf, int count)
{
	int ret;
	struct i2c_adapter *adap = client->adapter;
	struct i2c_msg msg;

	msg.addr = client->addr;
	msg.flags = client->flags & I2C_M_TEN;
	msg.len = count;
	msg.buf = (char *)buf;

	ret = i2c_transfer(adap, &msg, 1);

	/*
	 * If everything went ok (i.e. 1 msg transmitted), return #bytes
	 * transmitted, else error code.
	 */
	return (ret == 1) ? count : ret;
}
/**
 * i2c_master_recv - issue a single I2C message in master receive mode
 * @client: Handle to slave device
 * @buf: Where to store data read from slave
 * @count: How many bytes to read, must be less than 64k since msg.len is u16
 *
 * Returns negative errno, or else the number of bytes read.
 */
int i2c_master_recv(const struct i2c_client *client, char *buf, int count)
{
	struct i2c_adapter *adap = client->adapter;
	struct i2c_msg msg;
	int ret;

	msg.addr = client->addr;
	msg.flags = client->flags & I2C_M_TEN;
	msg.flags |= I2C_M_RD;
	msg.len = count;
	msg.buf = buf;

	ret = i2c_transfer(adap, &msg, 1);

	/*
	 * If everything went ok (i.e. 1 msg received), return #bytes received,
	 * else error code.
	 */
	return (ret == 1) ? count : ret;
}

在编写I2C驱动中我们一般是要对寄存器的数据进行读操作，因此就需要首先写入从设备地址，读取寄存器的数据。

int i2c_read_reg(const struct i2c_client *client, char *buf, int reg , int count)
{
	struct i2c_adapter *adap = client->adapter;
	struct i2c_msg msg[2];
	char rxbuf[1];
	int ret;
	
	//写入寄存器地址
	msg[0].addr = client->addr;
	msg[0].flags = 0;
	msg[0].len = 1;
	msg[0].buf = &reg;
	
	//往寄存器读取数据
	msg[0].addr = client->addr;
	msg[0].flags = 1;
	msg[0].len = 1;
	msg[0].buf = rxbuf;

	ret = i2c_transfer(adap, &msg, 2);

	/*
	 * If everything went ok (i.e. 1 msg received), return #bytes received,
	 * else error code.
	 */
	return rxbuf[0];
}

四、MPU6050驱动程序

#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/io.h>
#include <linux/ioctl.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <linux/of.h>
#include <linux/of_gpio.h>
#include <linux/gpio.h>
#include <linux/input.h>
#include <linux/platform_device.h>
#include <linux/compaction.h>
#include <linux/irq.h>
#include <linux/irqreturn.h>
#include <linux/uaccess.h>
#include <linux/interrupt.h>
#include <linux/fcntl.h>
#include <linux/sh_clk.h>
#include <linux/i2c.h>


#include <linux/delay.h>
#include <linux/slab.h>

#include "mpu6050.h"


struct mpu6050_device{
	struct i2c_client *mpu6050_client;
    struct cdev cdev;
    int major;
    struct class *class;
    struct device *dev;
};
static struct mpu6050_device *mpu6050;

static int mpu6050_read_byte (struct i2c_client *client, char *buf, int count)
{
    int ret;
    struct i2c_adapter *adapter = client->adapter;
    struct i2c_msg msg;
    
    msg.addr = client->addr;
    msg.flags = 1;
    msg.len = count;
    msg.buf = buf;

	ret = i2c_transfer(adapter,&msg,1);//num是消息的个数
    return (ret == 1) ? count : ret;
}


static int mpu6050_write_byte (struct i2c_client *client, char *buf, int count)
{
    int ret;
    struct i2c_adapter *adapter = client->adapter;
    struct i2c_msg msg;
    
    msg.addr = client->addr;
    msg.flags = 0;
    msg.len = count;
    msg.buf = buf;

	ret = i2c_transfer(adapter,&msg,1);//num是消息的个数
    return (ret == 1) ? count : ret;
}

static int mpu6050_read_reg_byte(struct i2c_client *client, char reg)
{
    int ret;
    struct i2c_adapter *adapter = client->adapter;
    struct i2c_msg msg[2];
    char rxbuf[1];
    
    //先写reg寄存器地址
    msg[0].addr = client->addr;
    msg[0].flags = 0;   //W
    msg[0].len = 1;
    msg[0].buf = &reg;

    //读取寄存器的数据
    msg[1].addr = client->addr;
    msg[1].flags = 1;   //R
    msg[1].len = 1;
    msg[1].buf = rxbuf;

	ret = i2c_transfer(adapter,msg,2);//num是消息的个数
    if(ret < 0){
        printk("i2c_transfer read reg error\r\n");
        return ret;
    }

    return rxbuf[0];
}

static int mpu6050_ioctl(struct file *file, unsigned int cmd,unsigned long arg)
{

    struct mpu6050_data data;
	struct i2c_client *client = mpu6050->mpu6050_client;

	switch(cmd) {
        case IOC_GET_ACCEL:
            printk("IOC_GET_ACCEL \r\n");
            data.accel.x = mpu6050_read_reg_byte(client, ACCEL_XOUT_L);
            data.accel.x |= mpu6050_read_reg_byte(client, ACCEL_XOUT_H) << 8;

            data.accel.y = mpu6050_read_reg_byte(client, ACCEL_YOUT_L);
            data.accel.y |= mpu6050_read_reg_byte(client, ACCEL_YOUT_H) << 8;

            data.accel.z = mpu6050_read_reg_byte(client, ACCEL_ZOUT_L);
            data.accel.z |= mpu6050_read_reg_byte(client, ACCEL_ZOUT_H) << 8;
            break;

        case IOC_GET_GYRO:
            printk("IOC_GET_GYRO \r\n");
            data.gyro.x = mpu6050_read_reg_byte(client, GYRO_XOUT_L);
            data.gyro.x |= mpu6050_read_reg_byte(client, GYRO_XOUT_H) << 8;

            data.gyro.y = mpu6050_read_reg_byte(client, GYRO_YOUT_L);
            data.gyro.y |= mpu6050_read_reg_byte(client, GYRO_YOUT_H) << 8;

            data.gyro.z = mpu6050_read_reg_byte(client, GYRO_ZOUT_L);
            data.gyro.z |= mpu6050_read_reg_byte(client, GYRO_ZOUT_H) << 8;
            break;

        case IOC_GET_TEMP:
            printk("IOC_GET_TEMP \r\n");
            data.temp = mpu6050_read_reg_byte(client, TEMP_OUT_L);
            data.temp |= mpu6050_read_reg_byte(client, TEMP_OUT_H) << 8;
            break;

        default:
            printk("invalid argument\n");
            return -EINVAL;
	}

	if (copy_to_user((void *)arg, &data, sizeof(data)))
		return -EFAULT;

	return 0;
}

/*字符设备操作函数集，open函数实现*/
static int mpu6050_open(struct inode *inode, struct file *filp){
    printk("--------------mpu6050_open-------------\r\n");
    /*向 mpu6050 发送配置数据，让mpu6050处于正常工作状态*/
    char buf[2] = {PWR_MGMT_1 , 0x0};
    mpu6050_write_byte(mpu6050->mpu6050_client , buf, 2);
    char buf1[2] = {SMPLRT_DIV, 0x07};
    mpu6050_write_byte(mpu6050->mpu6050_client , buf1, 2);
    char buf2[2] = {CONFIG, 0X06};
    mpu6050_write_byte(mpu6050->mpu6050_client , buf2, 2);
    char buf3[2] = {ACCEL_CONFIG, 0X01};
    mpu6050_write_byte(mpu6050->mpu6050_client , buf3, 2);
    char buf4[2] = {GYRO_CONFIG, 0X18};
    mpu6050_write_byte(mpu6050->mpu6050_client , buf4, 2);
    return 0;
}
static int mpu6050_release(struct inode *inode , struct file *filp){
    printk("--------------mpu6050_release-------------\r\n");
    return 0;
}


static struct file_operations mpu6050_fops={
	     .owner=THIS_MODULE,
		 .open = mpu6050_open,
         .release = mpu6050_release,
		 .unlocked_ioctl = mpu6050_ioctl,
};



static int  mpu6050_probe(struct i2c_client *client,const struct i2c_device_id *id)
{
  dev_t devid;

  printk("--------------mpu6050_probe-------------\r\n");
  mpu6050=kzalloc(sizeof(struct mpu6050_device),GFP_KERNEL);
  mpu6050->mpu6050_client=client;
  if (mpu6050->major) {  
        devid = MKDEV(mpu6050->major, 0);  
        register_chrdev_region(devid, 1, "mpu6050");   
    } else {  
        alloc_chrdev_region(&devid, 0, 1, "mpu6050");   
        mpu6050->major = MAJOR(devid);                       
    }  
  cdev_init(&mpu6050->cdev, &mpu6050_fops); 
  cdev_add(&mpu6050->cdev, devid, 1);	
  mpu6050->class=class_create(THIS_MODULE,"mpu6050");
  mpu6050->dev = device_create(mpu6050->class,NULL,MKDEV(mpu6050->major,0),NULL,"mpu6050");
  

  printk("--------------mpu6050_probe over-------------\r\n");
  return 0;
}

 static int mpu6050_remove(struct inode *inode, struct file *filp)
{
    printk("--------------mpu6050_remove-------------\r\n");
    device_destroy(mpu6050->class,MKDEV(mpu6050->major,0));
	class_destroy(mpu6050->class);
	cdev_del(&mpu6050->cdev);  
	kfree(mpu6050);
	unregister_chrdev_region(MKDEV(mpu6050->major, 0), 1);
	return 0;
}
 
static const struct i2c_device_id mpu6050_id[] = {
	{ "mpu6050,INV_MPU6050", 0 },
	{ }
};
/*定义设备树匹配表*/
static const struct of_device_id mpu6050_of_match_table[] = {
    {.compatible = "mpu6050,INV_MPU6050"},
    {/* sentinel */}
};


static struct i2c_driver mpu6050_driver ={
     .driver={
	 	.name ="mpu6050",
		.owner=THIS_MODULE,
        .of_match_table = mpu6050_of_match_table,
     	},
     .probe = mpu6050_probe,
     .remove = mpu6050_remove,
     .id_table = mpu6050_id,
};
static int mpu6050_driver_init(void)
{
  i2c_add_driver(&mpu6050_driver);
 
  return 0;
}

static void mpu6050_driver_exit(void)
{
  i2c_del_driver(&mpu6050_driver);
}

module_init(mpu6050_driver_init);
module_exit(mpu6050_driver_exit);
MODULE_LICENSE("GPL");

五、应用测试程序

​ 这个应用程序说来也奇怪，当我使用Ioctl系统调用的时候，如果不进行判错，data就不会更新数据，有大伙知道是为什么的吗？

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

#include "mpu6050.h"

int main(int argc, char * argv []){
	struct mpu6050_data *data , *data1;
	int fd ;

	fd = open("/dev/mpu6050" , O_RDWR);
	if(fd < 0){
		perror("open");
		exit(-1);
	}

    data = (struct mpu6050_data *)malloc( sizeof( struct mpu6050_data ));
    if(!data ){
        printf("failed data\r\n");
        return -1;
    }
	while(1){
		if(ioctl(fd, IOC_GET_ACCEL,data) < 0)
        {
            printf("error IOC_GET_ACCEL\r\n");
        }
		printf("accel data : x = %d,y= %d , z = %d\n",data->accel.x, data->accel.y, data->accel.z );

        sleep(1);

		if(ioctl(fd, IOC_GET_GYRO,data) < 0)
        {
            printf("error IOC_GET_ACCEL\r\n");
        }
		printf("gyro data : x = %d,y= %d , z = %d\n",data->gyro.x, data->gyro.y , data->gyro.z );

		sleep(1);
		
        if(ioctl(fd, IOC_GET_TEMP,data) < 0)
        {
            printf("error IOC_GET_TEMP\r\n");
        }
		printf("temp data1 : %f\n",data->temp/340.0 + 36.53);

		sleep(1);
	}
    free(data);
	close(fd);
	return 0;
}

#ifndef __MPU6050_H__
#define __MPU6050_H__

#define SMPLRT_DIV		0x19
#define CONFIG			0x1A
#define GYRO_CONFIG 	0x1B
#define ACCEL_CONFIG	0x1C
#define ACCEL_XOUT_H	0x3B
#define ACCEL_XOUT_L	0x3C
#define ACCEL_YOUT_H	0x3D
#define ACCEL_YOUT_L	0x3E
#define ACCEL_ZOUT_H	0x3F
#define ACCEL_ZOUT_L	0x40
#define TEMP_OUT_H		0x41
#define TEMP_OUT_L		0x42
#define GYRO_XOUT_H 	0x43
#define GYRO_XOUT_L 	0x44
#define GYRO_YOUT_H 	0x45
#define GYRO_YOUT_L 	0x46
#define GYRO_ZOUT_H 	0x47
#define GYRO_ZOUT_L 	0x48
#define PWR_MGMT_1		0x6B

struct mpu6050_data{
	struct{
		short x;
		short y;
		short z;
	}accel;
	struct{
		short x;
		short y;
		short z;
	}gyro;
	short temp;
};
#if 0

#define IOC_GET_ACCEL  _IOW('M', 0x34, union mpu6050_data)
#define IOC_GET_GYRO  _IOW('M', 0x35, union mpu6050_data)
#define IOC_GET_TEMP  _IOW('M', 0x36, union mpu6050_data)

#else

#define IOC_GET_ACCEL  0x01
#define IOC_GET_GYRO  0x04
#define IOC_GET_TEMP  0x08

#endif

#endif
Pintitus
关注
  • 1
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Linux I2C驱动
weixin_47366800的博客
04-12 1810
介绍：I2C是常见的一个串行通信接口，用于连接各种外设、传感器等。I2C 总线仅仅使用 SCL、SDA 这两根信号线就实现了设备之间的数据交互。 I2C的体系架构：由I2C核心，I2C总线驱动，I2C设备驱动三部分构成。 I2C核心：提供I2C总线驱动和设备驱动的注册，注销。 I2C总线驱动：I2C总线驱动是对硬件中适配器的实现，适配器可让CPU控制，也可以集成在CPU内部。 I2C 设备驱动：I2C 设备驱动是对 I2C 硬件体系结构中设备端的实现，设备一般挂接在受 CPU 控制的 I2C 适配器
Linux之I2C驱动
weixin_45664645的博客
09-12 1467
Linux之I2C驱动I2C适配器芯片的I2C接口I2C核心I2C通用设备驱动访问I2C通用设备文件的方法之一访问I2C通用设备文件的方法之二I2C用户设备驱动总结 本文将介绍Linux环境下的I2C驱动开发。文中内容涉及shell脚本，C语言和Linux内核驱动的基础知识。限于篇幅，本文只专注I2C的相关内容，且假设读者对以上基础知识已熟悉。 I2C总线仅使用两条信号线就可实现与设备之间的数据通信。其应用广泛且使用简单。但在Linux内核中却是相当复杂。其核心部分的代码量就有几千行。目的是要构成一个通用的
I2C驱动
weixin_34235105的博客
08-30 130
linux设备驱动那点事儿之I2C驱动理论篇 (2011-08-01 21:31) 分类： linux设备驱动程序分析 一：I2C 概述 I2C是philips提出的外设总线.I2C只有两条线,一条串行数据线:SDA,一...
【Linux驱动设备开发详解】15.Linux I2C核心、总线和设备驱动
最新发布
qq_38089448的博客
07-16 299
IC总线共有两根线，SCL和SDA，通过这两根信号线就实现了设备间的数据交互。
linux i2c
xiyu_1986的专栏
07-01 4203
1 Linux I2C驱动架构Linux下I2C驱动的架构图如下：  图1.1 Linux下I2C驱动架构    如上图所示，每条I2C总线会对应一个adapter，而每条I2C总线上则可以有多个 client，在linux kernel中，通过I2C core层将I2C client与I2C adapter关联起来，Linux 中I2C驱动代码位于drivers/i2c目录。    Linux中
linux I2C驱动
Calmer_的博客
02-21 822
linux I2C驱动
LINUX_I2C驱动程序
12-11
技巧(1) windows(2)(1) pc-lint(1) insight(1) source(1) 入门(2)(1) ss,vc(1) 基础(1) delphi(1) 面试题(1) .source(1) in(1) thinking(1) 设计(1) 数据库(1) server(1) 管理(1) 数据结构(1) 电子书(1) c++沉思录(1) 答案(1) 1800例(1) sql(1) 精通(1) primer(1) 全集(1) vc(1) 3rd(1) edition(1) 实践(1) 注册表(1) xp(1) 程序设计(1)
Linux的I2C驱动
QQ2558030393的博客
07-15 522
因为IIC设备种类丰富，如果为每一一个 IIC设备写一个驱动程序，那么Linux内核中关于IIC设备的驱动将非常庞大。这种设计方式不符合软件工程中的代码复用规则，所以需要对IIC设备驱动中的代码进行层次化组织。 实现分层后，多个设备（client）可以共用一个驱动（driver），多个驱动可以共用一个适配器（adapter） ——————————————————————————————————...
i.MX6ULL使用regmap驱动I2C（AP3216C传感器）【Linux驱动】.zip
02-21
这个教程将深入探讨Linux驱动开发的相关知识，包括I2C总线接口、regmap驱动模型、以及与硬件交互的基本步骤。 首先，i.MX6ULL是NXP半导体公司的一款超低功耗应用处理器，广泛应用于嵌入式和物联网设备。它包含了ARM...
I2C_driver_for_linux.rar_Linux驱动_i2c_i2c linux_linux i2c
09-23
在"I2C Linux驱动（－）2007.doc"文档中，可能包含了关于2007年时Linux I2C驱动的详细信息，包括如何配置I2C总线，如何编写驱动代码，以及可能遇到的问题和解决方案。尽管文档可能不是最新的，但它仍然具有一定的...
Linux下I2C设备驱动开发和实现
11-19
本文描述了Linux下I2C驱动的结构，并在此基础上给出了I2C设备驱动和应用的实现。 　1 引言 　I2C (INTER－Integrated CIRCUIT)总线是一种由PHILIPS公司开发的两线式串行总线，用于连接微控制器及其外围设备。I2C...
linux I2C通用驱动
12-05
android下或者linux下 I2C通用驱动的 实现数据的收发 也有DMA的通信方式
i2c.rar_I2C驱动_i2c linux_linux i2c_linux i2c 驱动
09-24
标题中的“i2c.rar”可能是一个包含I2C驱动程序源代码或文档的压缩文件，用于帮助开发者理解或实现Linux下的I2C驱动。通过这个压缩包，你可以学习到如何在Linux内核中编写和配置I2C驱动，这对于嵌入式系统的开发者...
i2c.zip_Linux IIC驱动_i2c驱动 linux
09-14
Linux IIC（Inter-Integrated Circuit）驱动，通常称为I2C驱动，是Linux操作系统中用于控制和支持I2C总线设备的关键组件。I2C总线是一种由飞利浦（现为恩智浦半导体）开发的多主控、双向二线制串行通信协议，广泛...
linux下I2C驱动
Destihang的博客
02-14 1179
说起Linux下的子系统，I2C子系统已经算是比较简单的框架了。   首先相关代码在driver/i2c下.built-in.o.cmd .i2c-dev.o.cmd algos/ i2c-boardinfo.c i2c-core.h i2c-dev.o muxes/.i2c-boardinfo.o
linux 驱动-i2c
sty01z的博客
06-13 1507
本文借助mtk平台分析linux的i2c框架，mtk平台mt6765，内核版本kernel-4.9，本文只分析linux的i2c框架，不讨论i2c总线协议相关内容.作者: baron具体的i2次设备的软件抽象，它拥有所有i2c次设备的信息：i2c_client这个结构被注册时候就被注册到 i2c bus 上了，因此我们可以利用 i2c bus 获取到这个结构 2、i2c_adapter i2c适配器，adapter翻译过来就是适配器的意思，这个结构描述了硬件上的i2c总线的控制器信息，注意不是我们理解的设备
i2c驱动
懒惰的小蓝's Blog
10-19 270
1.在设备树上对应的i2c接口编写设备节点信息 2.写驱动 #include <linux/module.h> #include <linux/init.h> #include <linux/types.h> #include <linux/i2c.h> #include <linux/kernel.h> #include <...
Linux2.6.25 I2C驱动架构深度解析
"Linux2.6.25平台下的I2C驱动架构分析" 在Linux 2.6.25版本的内核中，I2C（Inter-Integrated Circuit）驱动架构是一个复杂而精细的设计，它允许系统与使用I2C总线的外部设备进行通信。I2C总线是一种简单、低功耗的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值