I2C

1：

       i2c总线（串行总线），用于CPU与外设直接进行通信。只有两条线：数据线SDA总线），用于CPU与外设直接进行通信。只有两条线：数据线SDA, 控制线SCL。 具有简单性，有效性，"最主要优点"是：多主控，即可以连接多个设备，但同一时刻只有一个设备成为主设备与CPU通信。为主设备时，可以自己控制当前总线的时钟频率及数据传输。

2：

2.1 总线的构成及信号类型 

       I2C 总线是由数据线SDA和时钟SCL构成的串行总线，可发送和接收数据。在CPU与被控IC之间、IC与IC之间进行双向传送，最高传送速率 100kbps。各种被控制电路均并联在这条总线上，但就像电话机一样只有拨通各自的号码才能工作，所以每个电路和模块都有唯一的地址，在信息的传输过程 中，I2C总线上并接的每一模块电路既是主控器（或被控器），又是发送器（或接收器），这取决于它所要完成的功能。CPU发出的控制信号分为地址码和控制 量两部分，地址码用来选址，即接通需要控制的电路，确定控制的种类；控制量决定该调整的类别（如对比度、亮度等）及需要调整的量。这样，各控制电路虽然挂 在同一条总线上，却彼此独立，互不相关。

      I2C总线在传送数据过程中共有三种类型信号， 它们分别是：开始信号、结束信号和应答信号。

      开始信号：SCL为高电平时，SDA由高电平向低电平跳变，开始传送数据。

      结束信号：SCL为低电平时，SDA由低电平向高电平跳变，结束传送数据。 

      应 答信号：接收数据的IC在接收到8bit数据后，向发送数据的IC发出特定的低电平脉冲，表示已收到数据。CPU向受控单元发出一个信号后，等待受控单元 发出一个应答信号，CPU接收到应答信号后，根据实际情况作出是否继续传递信号的判断。若未收到应答信号，由判断为受控单元出现故障。 

  目前有很多半导体集成电路上都集成了I2C接口。

 2.2

       i2c总线是两条线连接多个设备，inter ic. 

       寻址是通过在scl线上发出寻址信号： 起始，7／10位 地址 ＋ 1位（读／写），（多个后续的数据），终止位。  而地址是由设备的脚决定，一般会有几个固定脚与几个可编程脚。通过编程可以确定设备的地址。当设备收到寻址信号后，判断是不是其地址。

7位寻址，被I2C协会保留，所以一般用10位寻址：s,1111 0xx (R/W) ACK xxxxxxxx  

若（R/W） = 0, 则为从MASTER > slave,写 所以10个x为地址

若（R/W） = 1，则为 从 SLAVE ＞ MASTER， 读， 此时先前被寻址了的SLAVE就会发送数据给MASTER。

2.3

i2c是基于8位的

SCL时钟线，由主机提供时钟。

起始位： sda下降，scl保持高

结束位： sda上升，scl保持高。

地址位，一般是10位，被拆分为 xx (r/w) ack xxxxxxxx

数据： 每个字节必须是8位，先传MSB。每个字节后必须跟一个响应位（从机发）

每次从机接收时，可以使SCL为低，从而让主机进入等待状态。

3："linuxi2c体系结构"

三个层次：

1，i2c核心，内核完成 i2c-core.c

2, i2c总线驱动， 实现 i2c_adapter(总线适配器),i2c_algorithm（通信方法）

3, i2c设备驱动，实现 i2c_driver, i2c_client

通信方法:

通过i2c_msg来表示每次的通信。每次可以收发多个i2c_msg.

//adapter注册，当成是一个platform_bus总线下的设备。

int i2c_add_adapter(struct i2c_adapter *adapter)

res = idr_get_new_above(&i2c_adapter_idr, adapter,__i2c_first_dynamic_bus_num, &id);

i2c_register_adapter(adapter);

static int i2c_register_adapter(struct i2c_adapter *adap)

{

if (adap->dev.parent == NULL) 

adap->dev.parent = &platform_bus;

adap->dev.release = &i2c_adapter_dev_release;

adap->dev.class = &i2c_adapter_class;

res = device_register(&adap->dev);

}

//i2c_add_adapter()而言,它使用的是动态总线号,即由系统给其分析一个总线号,而i2c_add_numbered_adapter()则是自己指定总线号,

//i2c_driver注册， 即driver先匹配所有adapter，找到正确的，然后检测硬件，生成对应的i2c_client, 然后把i2c_client注册到adapter上。

当 i2c_driver向内核注册时，会被调用attach_adatper,先匹配当前系统中所有adapter,再去检测硬件，当确定硬件存在，则会生 成匹配i2c_client？， 把i2c_client的driver指针指向自己（driver），adapter指针指向其adapter.然后会让这个adapter调用 其client_register. 

注册：

static inline int i2c_add_driver(struct i2c_driver *driver)

{

return i2c_register_driver(THIS_MODULE, driver);

}

int i2c_register_driver(struct module *owner, struct i2c_driver *driver)

{

driver->driver.owner = owner;

driver->driver.bus = &i2c_bus_type;

res = driver_register(&driver->driver); //注册代表本 i2c_driver的 内部 driver

class_for_each_device(&i2c_adapter_class, NULL, driver, __attach_adapter); //从目前系统中所的adapter中去匹配 对应的 adapter.

}

static int __attach_adapter(struct device *dev, void *da ta)

{

struct i2c_adapter *adapter = to_i2c_adapter(dev);

struct i2c_driver *driver = da ta;

i2c_detect(adapter, driver); //检测硬件

/* Legacy drivers scan i2c busses directly */

if (driver->attach_adapter)

driver->attach_adapter(adapter); //生成client 并加入到adapter 中。

return 0;

}

而一般 i2c_driver的实现时是：

static int yy_attach_adapter(struct i2c_adapter *adapter)

{

return i2c_probe(adapter, &addr_da ta, yy_detect);

}

static int yy_detect (struct i2c_adapter * adapter, int address, int kind)

{

struct yy_da ta da ta = kzalloc(sizeof(struct yy_da ta), GFP_KERNEL);

i2c_client new_client = da ta->client;

err = i2c_attach_client(new_client);

}

/*

 * 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,   "i2c传输函数"

  int num);

int (*smbus_xfer) (struct i2c_adapter *adap, u16 addr, "smbus传输函数"

  unsigned short flags, char read_write,

  u8 command, int size, union i2c_smbus_da ta *da ta);

/* To determine what the adapter supports */

u32 (*functionality) (struct i2c_adapter *);   "返回适配器支持的功能"

};

/*

 * i2c_adapter is the structure used to identify a physical i2c bus along

 * with the access algorithms necessary to access it.

 */

struct i2c_adapter {  "代表 一个物理的I2C总线"

struct module *owner;

unsigned int id;

unsigned int class;  /* classes to allow probing for */

const struct i2c_algorithm *algo; /* the algorithm to access the bus */

void *algo_da ta;

/* --- administration stuff. */

int (*client_register)(struct i2c_client *);

int (*client_unregister)(struct i2c_client *);

/* da ta fields that are valid for all devices */

u8 level; /* nesting level for lockdep */

struct mutex bus_lock;

struct mutex clist_lock;

int timeout; /* in jiffies */

int retries;

struct device dev; /* the adapter device */

int nr;

struct list_head clients; /* DEPRECATED */

char name[48];

struct completion dev_released;

};

/**

 * struct i2c_driver - represent an I2C device driver

 * @id: Unique driver ID (optional)

 * @class: What kind of i2c device we instantiate (for detect)

 * @attach_adapter: Callback for bus addition (for legacy drivers)

 * @detach_adapter: Callback for bus removal (for legacy drivers)

 * @detach_client: Callback for device removal (for legacy drivers)

 * @probe: Callback for device binding (new-style drivers)

 * @remove: Callback for device unbinding (new-style drivers)

 * @shutdown: Callback for device shutdown

 * @suspend: Callback for device suspend

 * @resume: Callback for device resume

 * @command: Callback for bus-wide signaling (optional)

 * @driver: Device driver model driver

 * @id_table: List of I2C devices supported by this driver

 * @detect: Callback for device detection

 * @address_da ta: The I2C addresses to probe, ignore or force (for detect)

 * @clients: List of detected clients we created (for i2c-core use on ly)

 *

 * The driver.owner field should be set to the module owner of this driver.

 * The driver.name field should be set to the name of this driver.

 *

 * For automatic device detection, both @detect and @address_da ta must

 * be defined. @class should also be set, otherwise on ly devices forced

 * with module parameters will be created. The detect function must

 * fill at least the name field of the i2c_board_info structure it is

 * handed upon successful detection, and possibly also the flags field.

 *

 * If @detect is missing, the driver will still work fine for enumerated

 * devices. Detected devices simply won't be supported. This is expected

 * for the many I2C/SMBus devices which can't be detected reliably, and

 * the on es which can always be enumerated in practice.

 *

 * The i2c_client structure which is handed to the @detect callback is

 * not a real i2c_client. It is initialized just enough so that you can

 * call i2c_smbus_read_byte_da ta and friends on it. Don't do anything

 * else with it. In particular, calling dev_dbg and friends on it is

 * not allowed.

 */

struct i2c_driver {

int id;

unsigned int class;

/* Notifies the driver that a new bus has appeared. This routine

* can be used by the driver to test if the bus meets its conditions

* & seek for the presence of the chip(s) it supports. If found, it

* registers the client(s) that are on the bus to the i2c admin. via

* i2c_attach_client.  (LEGACY I2C DRIVERS ON LY)

*/

int (*attach_adapter)(struct i2c_adapter *);

int (*detach_adapter)(struct i2c_adapter *);

/* tells the driver that a client is about to be deleted & gives it

* the chance to remove its private da ta. Also, if the client struct

* has been dynamically allocated by the driver in the function above,

* it must be freed here.  (LEGACY I2C DRIVERS ON LY)

*/

int (*detach_client)(struct i2c_client *) __deprecated;

/* Standard driver model interfaces, for "new style" i2c drivers.

* With the driver model, device enumeration is NEVER done by drivers;

* it's done by infrastructure.  (NEW STYLE DRIVERS ON LY)

*/

int (*probe)(struct i2c_client *, const struct i2c_device_id *);

int (*remove)(struct i2c_client *);

/* driver model interfaces that don't relate to enumeration  */

void (*shutdown)(struct i2c_client *);

int (*suspend)(struct i2c_client *, pm_message_t mesg);

int (*resume)(struct i2c_client *);

/* a ioctl like command that can be used to perform specific functions

* with the device.

*/

int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);  "类似ioctl"

struct device_driver driver;

const struct i2c_device_id *id_table;    "与本驱动 匹配的 设备id"

/* Device detection callback for automatic device creation */

int (*detect)(struct i2c_client *, int kind, struct i2c_board_info *); "设备检测"

const struct i2c_client_address_da ta *address_da ta;

struct list_head clients;

};

/**

 * struct i2c_client - represent an I2C slave device

 * @flags: I2C_CLIENT_TEN indicates the device uses a ten bit chip address;

 * I2C_CLIENT_PEC indicates it uses SMBus Packet Error Checking

 * @addr: Address used on the I2C bus connected to the parent adapter.

 * @name: Indicates the type of the device, usually a chip name that's

 * generic enough to hide second-sourcing and compatible revisions.

 * @adapter: manages the bus segment hosting this I2C device

 * @driver: device's driver, hence pointer to access routines

 * @dev: Driver model device node for the slave.

 * @irq: indicates the IRQ generated by this device (if any)

 * @list: list of active/busy clients (DEPRECATED)

 * @detected: member of an i2c_driver.clients list

 * @released: used to synchronize client releases & detaches and references

 *

 * An i2c_client identifies a single device (i.e. chip) connected to an

 * i2c bus. The behaviour exposed to Linux is defined by the driver

 * managing the device.

 */

struct i2c_client {

unsigned short flags; /* div., see below */

unsigned short addr; /* chip address - NOTE: 7bit */

/* addresses are stored in the */

/* _LOWER_ 7 bits */

char name[I2C_NAME_SIZE];

struct i2c_adapter *adapter; /* the adapter we sit on */

struct i2c_driver *driver; /* and our access routines */

struct device dev; /* the device structure */

int irq; /* irq issued by device */

struct list_head list; /* DEPRECATED */

struct list_head detected;

struct completion released;

};

/**

 * struct i2c_board_info - template for device creation

 * @type: chip type, to initialize i2c_client.name

 * @flags: to initialize i2c_client.flags

 * @addr: stored in i2c_client.addr

 * @platform_da ta: stored in i2c_client.dev.platform_da ta

 * @archdata: copied into i2c_client.dev.archdata

 * @irq: stored in i2c_client.irq

 *

 * I2C doesn't actually support hardware probing, although controllers and

 * devices may be able to use I2C_SMBUS_QUICK to tell whether or not there's

 * a device at a given address.  Drivers commonly need more information than

 * that, such as chip type, configuration, associated IRQ, and so on.

 *

 * i2c_board_info is used to build tables of information listing I2C devices

 * that are present.  This information is used to grow the driver model tree

 * for "new style" I2C drivers.  For mainboards this is done statically using

 * i2c_register_board_info(); bus numbers identify adapters that aren't

 * yet available.  For add-on boards, i2c_new_device() does this dynamically

 * with the adapter already known.

 */

struct i2c_board_info {

char type[I2C_NAME_SIZE];

unsigned short flags;

unsigned short addr;

void *platform_da ta;

struct dev_archdata *archdata;

int irq;

};

struct i2c_devinfo {

struct list_head list;

int busnum;

struct i2c_board_info board_info;

};

//***************************************************************//

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 da ta, 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 da ta */

};