Linux驱动之IIC总线

<作用>

电子设备中有很多IIC设备之间需要进行相互通信,这样就产生了IIC总线,常用来实现设备之间的数据通信。
 
<IIC总线结构>
IIC总线只有两条线,一条是串行数据线(SDA),另外一条是串行时钟线(SCL).
Linux驱动之IIC总线
注:每一个连接到总线上的设备都有一个唯一的地址可以访问(这一点有点像USB设备)
 
<IIC总线信号类型>
a:开始信号(S):当SCL信号为高电平,SDA的电平由高电平变为低电平表示开始传输数据。
b:结束信号(P):当SCL信号为高电平,SDA的电平由低电平变为高电平表示结束传输数据。
c:相应信号(ACK):从机接收到8位数据后,在第9个时钟周期,拉低SDA电平,表示接受到数据,这个信号称为应答信号。
 
<IIC数据传输方式>
主机(IIC控制器)主要通过SDA向从机发送数据,当总线处于空闲的时候SDA和SCL都处于高电平。
a:当主机检测到总线处于空闲状态时,主机发送给开始信号(S)
b:主机发出8位数据,8位数据中,前7位中表示从机地址,第8位表示数据的传输方向。
c:和地址匹配的从机发出相应信号。
d:从机传输一系列响应序列
e:主机接收到这些数据后,发出结束信号P,该次数据传输完成。
 
<IIC控制器结构图>
Linux驱动之IIC总线
a:主要涉及的寄存器
IICCON:控制寄存器
IICSTAT:状态寄存器
IICADD:地址寄存器
Linux驱动之IIC总线
 
IICCDS:接收和发送的数据存储寄存器
 
<linux 驱动之IIC>
a:背景
对于IIC设备的控制,但是IIC设备太多了,为了很好的管理这些设备(不同等的设备名,管理各种设备,不同设备的地址,不同设备对应的驱动),Linux内核开发了如下结构体:
b:IIC设备(i2c_client)
struct i2c_client {
unsigned short flags;
unsigned short addr;
char name[I2C_NAME_SIZE];
struct i2c_adapter *adapter; //通过该指针可以找到适配器,然后通过适配器找到                       //适配器算法中的发送消息和接受函数完成同IIC设备                          //的通信              
struct i2c_driver *driver;
struct device dev; //用于建立设备模型
int irq;
struct list_head detected;
};
 
c:IIC驱动(i2c_driver)
struct i2c_driver {
unsigned int class;
int (*attach_adapter)(struct i2c_adapter *) __deprecated;
int (*detach_adapter)(struct i2c_adapter *) __deprecated;
int (*probe)(struct i2c_client *, const struct i2c_device_id *);
int (*remove)(struct i2c_client *);
void (*shutdown)(struct i2c_client *);
int (*suspend)(struct i2c_client *, pm_message_t mesg);
int (*resume)(struct i2c_client *);
void (*alert)(struct i2c_client *, unsigned int data);
int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);
struct device_driver driver;//用于建立设备模型
const struct i2c_device_id *id_table;//是一个数组,保存该驱动支持的所有的 的                               //设备信息 
int (*detect)(struct i2c_client *, struct i2c_board_info *);
const unsigned short *address_list;
struct list_head clients;
};
d:IIC适配器(i2c_adapter)//其本质表示适配器这个设备
-----i2c_adapter is the structure used to identify a physical i2c bus along with the access algorithms necessary to access it.内核中可以有很多总线适配器,其中内核中有一个静态指针数组adapters记录了所有已经注册的总线适配器。
 
struct i2c_adapter {
struct module *owner;
unsigned int class;  /* classes to allow probing for */
const struct i2c_algorithm *algo; /* the algorithm to access the bus */
void *algo_data;
 
/* data fields that are valid for all devices */
struct rt_mutex bus_lock;
 
int timeout; /* in jiffies */
int retries;
struct device dev; /* the adapter device */
 
int nr;
char name[48];
struct completion dev_released;
 
struct mutex userspace_clients_lock;
struct list_head userspace_clients;//用于连接所有连接到这个适配器上的i2c设备
};
d:IIC适配器驱动(i2c_algorithm)
 
/*
 * The following structs are for those who like to implement new bus drivers:
 * i2c_algorithm is the interface to a class of hardware solutions which can
 * be addressed using the same bus algorithms - i.e. bit-banging or the PCF8584
 * to name two of the most common.
 */
struct i2c_algorithm {
/* If an adapter algorithm can't do I2C-level access, set master_xfer
  to NULL. If an adapter algorithm can do SMBus access, set
  smbus_xfer. If set to NULL, the SMBus protocol is simulated
  using common I2C messages */
/* master_xfer should return the number of messages successfully
  processed, or a negative value on error */
int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs,
  int num);
int (*smbus_xfer) (struct i2c_adapter *adap, u16 addr,
  unsigned short flags, char read_write,
  u8 command, int size, union i2c_smbus_data *data);
 
/* To determine what the adapter supports */
u32 (*functionality) (struct i2c_adapter *);
};
e:注意:i2c_driver和i2c_client属于设备层,i2c_adapter和i2c_algorithm属于总线层。他们之间的关系如图所示:
Linux驱动之IIC总线
f:IIC设备之间的通信方式
struct i2c_msg {
__u16 addr; /* slave address */
__u16 flags;
#define I2C_M_TEN 0x0010 /* this is a ten bit chip address */
#define I2C_M_RD 0x0001 /* read data, from slave to master */
#define I2C_M_NOSTART 0x4000 /* if I2C_FUNC_PROTOCOL_MANGLING */
#define I2C_M_REV_DIR_ADDR 0x2000 /* if I2C_FUNC_PROTOCOL_MANGLING */
#define I2C_M_IGNORE_NAK 0x1000 /* if I2C_FUNC_PROTOCOL_MANGLING */
#define I2C_M_NO_RD_ACK 0x0800 /* if I2C_FUNC_PROTOCOL_MANGLING */
#define I2C_M_RECV_LEN 0x0400 /* length will be first received byte */
__u16 len; /* msg length */
__u8 *buf; /* pointer to msg data */
};
填该结构体,用于同IIC设备通信。
 
<IIC设备驱动流程>
a:流程图
Linux驱动之IIC总线 
(1)xxx_init()和i2c_add_driver()实现对IIC子系统的初始化,这项工作由内核完成。
(2)xxx_attach_adapter()用来将IIC设备驱动和适配器挂接在一起,这样才能IIC设备驱动才能利用适配器驱动控制适配器和IIC设备通信。(注意:在这两步中间需要根据具体适配器实现相应的驱动,以及相应struct algorithm{}的实现)
(3)i2c_probe()函数是在检测到IIC设备后调用的函数,进一步实现IIC设备的各数据结构的初始化。包括下面的函数都为了实现相应的功能。
 
b:IIC子系统初始化
(1)初始化函数
Linux驱动之IIC总线
(2)卸载函数
Linux驱动之IIC总线
 
c:适配器驱动程序
(1)IIC适配器内核结构
Linux驱动之IIC总线
注意:
"struct i2c_adapter adap"
这是内核提供的IIC适配器的结构体,特定类型的适配器结构体需要在这个结构上进行扩充(面向对象的思想)。
"void __iomem  *regs"
指向IIC适配器的控制寄存器地址,注意这个地址是物理地址
"struct resource *ioarea"
指向适配器申请的资源,这里应该是内存资源,先进行申请,然后进行映射
"struct i2c_msg *msg"
用来实现IIC设备驱动于设备之间的通信
 
(2)适配器加载函数
Linux驱动之IIC总线
(3)适配器卸载函数

Linux驱动之IIC总线

注意:这个适配器驱动跟字符设备驱动很相似,因为这里不需要同用户空间进行交互,所以这里没有相应的fops,但是有相应的类似fops——struct i2c_algorithm{}。和字符设备驱动相似,
重点就是要实现这个类似fops,struct i2c_algorithm{}中的相应的函数通过操作"void __iomem  *regs"中的相应的寄存器。
 
<IIC适配器驱动模块的加载与卸载>
a:这里将适配器驱动定性为平台设备
加载函数
Linux驱动之IIC总线
b:卸载函数
Linux驱动之IIC总线
c:注意其中的"s3c2410_i2c_driver"
Linux驱动之IIC总线
d:对于一个平台设备来"s3c2410_i2c_probe()"函数是很重要的
Linux驱动之IIC总线
Linux驱动之IIC总线
Linux驱动之IIC总线
Linux驱动之IIC总线
(1)"s3c2410_i2c_probe()"中的"s3c2410_i2c_init()"函数
Linux驱动之IIC总线
Linux驱动之IIC总线
 
e:与"s3c2410_i2c_probe()"相反的函数是s3c2410_i2c_remove()。

Linux驱动之IIC总线

 
<IIC设备驱动实例>
a:设备文件操作函数集
static struct file_operations eep_fops = {
.owner = THIS_MODULE,
.llseek = eep_llseek,
.read = eep_read,
.ioctl = eep_ioctl,
.open = eep_open,
.release = eep_release,
.write = eep_write,
};
static dev_t dev_number; /* Allotted Device Number */
static struct class *eep_class; /* Device class */
/* Per-device client data structure for each
* memory bank supported by the driver
*/
 
b:IIC设备结构体
struct eep_bank {
struct i2c_client *client; /* I2C client for this bank */
unsigned int addr; /* Slave address of this bank */
unsigned short current_pointer; /* File pointer */
int bank_number; /* Actual memory bank number */
/* ... */ /* Spinlocks, data cache for slow devices,.. */
};
#define NUM_BANKS 2 /* Two supported banks */
#define BANK_SIZE 2048 /* Size of each bank */
struct ee_bank *ee_bank_list; /* List of private data
structures, one per bank */
c:初始化函数
int __init
eep_init(void)
{
int err, i;
/* Allocate the per-device data structure, ee_bank */
ee_bank_list = kmalloc(sizeof(struct ee_bank)*NUM_BANKS, GFP_KERNEL);
memset(ee_bank_list, 0, sizeof(struct ee_bank)*NUM_BANKS);
/* Register and create the /dev interfaces to access the EEPROM
banks. Refer back to Chapter 5, "Character Drivers" for more details */
if (alloc_chrdev_region(&dev_number, 0,
NUM_BANKS, "eep") < 0) {
printk(KERN_DEBUG "Can't register device\n");
return -1;
}
eep_class = class_create(THIS_MODULE, DEVICE_NAME);
for (i=0; i < NUM_BANKS;i++) {
/* Connect the file operations with cdev */
cdev_init(&ee_bank[i].cdev, &ee_fops);
/* Connect the major/minor number to the cdev */
if (cdev_add(&ee_bank[i].cdev, (dev_number + i), 1)) {
printk("Bad kmalloc\n");
return 1;
}
device_create(eep_class, NULL, MKDEV (MAJOR) (dev_number),i),
"eeprom%d", i);
}
/* Inform the I2C core about our existence. See the section
"Probing the Device" for the definition of eep_driver */
err = i2c_add_driver(&eep_driver);
if (err) {
printk("Registering I2C driver failed, errno is %d\n", err);
return err;
}
printk("EEPROM Driver Initialized.\n");

return 0;
}

(1) eep_driver结构体如下所示:
eep_init()在设备初始化的时调用i2c_add_driver()将注册eep_probe()
static struct i2c_driver eep_driver =

{
.driver = {
.name = "EEP", /* Name */
},
.id = I2C_DRIVERID_EEP, //设备标志符I2C_DRIVERID_EEP对于每个设备应该是唯一的

.attach_adapter = eep_probe, /* Probe Method */
.detach_client = eep_detach, /* Detach Method */
};
(2)当IIC核心调用表明主机适配器已经存在的客户驱动程序的probe()方法时,其会发过来调用i2c_probe(),该函数的参数是驱动程序所关联的设备地址以及具体的探测函数attach()。
 
#include <linux/i2c.h>
/* The EEPROM has two memory banks having addresses SLAVE_ADDR1
* and SLAVE_ADDR2, respectively
*/
static unsigned short normal_i2c[] = {
SLAVE_ADDR1, SLAVE_ADDR2, I2C_CLIENT_END
};
static struct i2c_client_address_data addr_data = {
.normal_i2c = normal_i2c,
.probe = ignore,
.ignore = ignore,
.forces = ignore,
};
static int eep_probe(struct i2c_adapter *adapter)
{
/* The callback function eep_attach(), is shown in Listing 8.5 */
return i2c_probe(adapter, &addr_data, eep_attach);
}

int eep_attach(struct i2c_adapter *adapter, int address, int kind)
{
static struct i2c_client *eep_client;
eep_client = kmalloc(sizeof(*eep_client), GFP_KERNEL);
eep_client->driver = &eep_driver; /* Registered in Listing 8.2 */
eep_client->addr = address; /* Detected Address */
eep_client->adapter = adapter; /* Host Adapter */
eep_client->flags = 0;
strlcpy(eep_client->name, "eep", I2C_NAME_SIZE);
/* Populate fields in the associated per-device data structure */
/* ... */
/* Attach */
i2c_attach_client(new_client);
}  

 
<整个程序框架>
Linux驱动之IIC总线
 
Linux驱动之IIC总线
 
上一篇:document library\ picture library\Asset Library的默认文件夹


下一篇:SpringMVC的执行流程(二)