bma150.c解析

一，Struct i2c_board_info :创建设备的模板,这个结构体用来创造一个i2c设备的信息列表。由i2c_register_board_info();注册。

struct i2c_board_info {

char type[I2C_NAME_SIZE];

unsigned short flags;

unsigned short addr;

void *platform_data;

struct dev_archdata *archdata;

#ifdef CONFIG_OF

struct device_node *of_node;

#endif

int irq;

};

解析：

type：芯片的类型，用来初始化i2c_https://www.360docs.net/doc/2013090495.html,.

flags：用来初始化i2c_cllient.flags.

addr:存储i2c_client.addr.

platform_data：存储i2c_client.dev.platform_data

archdata:拷贝到i2c_client.dev.archdata

irq:保存i2c_client.irq.

二，Struct i2c_adapter 是一个用于物理i2c总线的结构体，包括算法

struct i2c_adapter {

struct module *owner;

unsigned int id; //algorithm的类型，以I2C_ALGO_开始

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

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

void *algo_data; //algorithm数据

/* 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 list_head userspace_clients;

};

三,struct i2c_client：表示一个i2c从设备。指定了一个单一的设备（比如一个芯片）连接到一个I2

c总线上。

struct i2c_client {

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

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

/* addresses are stored in the */

/* _LOWER_ 7 bits */

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 detected;

};

解析：

flags：I2C_CLIENT_TEN:表示设备使用十位芯片寻址；I2C_CLIENT_PEC:表示使用SMBus错误检测包

addr：用于在I2C总线上连接当前适配器的地址。

name：指示设备的类型，通常是芯片的名字。

adapter：拥有这个设备的总线适配器

driver：设备的驱动

dev：从设备的驱动设备

irq：指定由该设备产生的IRQ

detected：i2c_driver.client列表的数字

I2C设备（BMA150）注册到I2C总线上的过程：(kernel/drivers/input/misc/bma150.c) BMA150_init() → bma150_attach_adapter();

进入bma150_attach_adapter()进行分析，原型代码如下：

int bma150_attach_adapter(void)

{

struct i2c_board_info info;

struct i2c_adapter *adapter;

struct i2c_client *client;

adapter = i2c_get_adapter(I2C_BUS_NUM);

//I2C_BUS_NUM是210板卡上面的I2C总线的号码，选择要挂载的I2C总线

memset(&info, 0, sizeof(struct i2c_board_info));

strlcpy(info.type, SENSOR_NAME, I2C_NAME_SIZE);//将BMA150名字放入

i2c_board_info中

info.addr = BMA150_I2C_ADDR;

//地址填充

client = i2c_new_device(adapter, &info);//创建一个新的I2C设备,bind在I2C上

if (!client)

{

printk("failed to add i2c driver\n");

return -ENODEV;

}

return 0;

}

i2c_get_adapter(I2C_BUS_NUM);得到I2C_BUS_NUM上的适配器，它的原型为：

struct i2c_adapter *i2c_get_adapter(int id)

{

struct i2c_adapter *adapter;

mutex_lock(&core_lock);

adapter = idr_find(&i2c_adapter_idr, id);

if (adapter && !try_module_get(adapter->owner))

adapter = NULL;

mutex_unlock(&core_lock);

return adapter;

}

i2c_new_device（adapter, &info）；的原型为：

（创建一个i2c设备，当我们从这个函数返回时，驱动可能绑定了这个设备）

struct i2c_client *

i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info) {

struct i2c_client *client;

int status;

client = kzalloc(sizeof *client, GFP_KERNEL);

if (!client)

return NULL;

client->adapter = adap;

//将选择的I2C总线适配器填充到client。

client->dev.platform_data = info->platform_data;//进行衔接

if (info->archdata)

client->dev.archdata = *info->archdata;

client->flags = info->flags;

client->addr = info->addr;

client->irq = info->irq;

strlcpy(client->name, info->type, sizeof(client->name));

/* Check for address validity 检查地址是否有效*/

status = i2c_check_client_addr_validity(client);

if (status) {

dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",

client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr); goto out_err_silent;

}

/* Check for address business */

status = i2c_check_addr_busy(adap, client->addr);

if (status)

goto out_err;

//注册的就是client->dev.

client->dev.parent = &client->adapter->dev;

client->dev.type = &i2c_client_type;

#ifdef CONFIG_OF

client->dev.of_node = info->of_node;

#endif

dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),

client->addr);

status = device_register(&client->dev);

//注册芯片设备。

if (status)

goto out_err;

dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",

client->name, dev_name(&client->dev));

return client;

out_err:

dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x " "(%d)\n", client->name, client->addr, status);

out_err_silent:

dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x " "(%d)\n", client->name, client->addr, status);

kfree(client);

return NULL;

}

这样一个新的I2C芯片设备就创建完成了。

接下来就是加入驱动程序,还是在BMA150_init()中：

BMA150_init() → i2c_add_driver(&bma_driver) →

i2c_register_driver(THIS_MODULE,driver);

i2c_register_driver(THIS_MODULE,driver)的原型为：

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

int res;

/* Can't register until after driver model init */

if (unlikely(WARN_ON(!i2c_bus_type.p)))

return -EAGAIN;

/* add the driver to the list of i2c drivers in the driver core */

/*i2c_driver内嵌的标准driver赋值，其bus指定为i2c_bus_type*/

driver->driver.owner = owner;

driver->driver.bus = &i2c_bus_type;

//将新生成的驱动加入到i2c驱动列表中。

/* When registration returns, the driver core

* will have called probe() for all matching-but-unbound devices.

//注册标准的driver，driver注册后会失去i2c_bus_type的设备链表上匹配的设备，匹配函数用的是bus端，也就是i2c_device_match，如果匹配成功将建立标准关联，

并且调用bus端的probe函数初始化这个设备，即函数i2c_device_probe().

res = driver_register(&driver->driver);

//将驱动注册到总线上，最后会调用probe

if (res)

return res;

pr_debug("i2c-core: driver [%s] registered\n", driver->https://www.360docs.net/doc/2013090495.html,);

/*把该driver的clients初始化，该成员连接着这个driver可以操作的具体设备*/ INIT_LIST_HEAD(&driver->clients);

/* Walk the adapters that are already present */

mutex_lock(&core_lock);

/*遍历挂接在该i2c设备链表上的设备，并对其都调用__process_new_driver函数

*/

bus_for_each_dev(&i2c_bus_type, NULL, driver, __process_new_driver);

mutex_unlock(&core_lock);

return 0;

}

driver_register(&driver->driver);的原型为：（device_driver是标准的驱动，最终注册的就是这个驱动结构）

int driver_register(struct device_driver *drv)

{

int ret;

BUG_ON(!drv->bus->p);

if ((drv->bus->probe && drv->probe) ||

(drv->bus->remove && drv->remove) ||

(drv->bus->shutdown && drv->shutdown))

printk(KERN_WARNING "Driver '%s' needs updating - please use " "bus_type methods\n", drv->name);

other = driver_find(drv->name, drv->bus);//在总线中找到和该驱动同名的驱动，说白了就是看看这个驱动之前注册过没有

if (other) {

put_driver(other);

printk(KERN_ERR "Error: Driver '%s' is already registered, "

"aborting...\n", drv->name);

return -EBUSY;

}

ret = bus_add_driver(drv);

//如果没有注册，就把驱动注册到bus上

if (ret)

return ret;

ret = driver_add_groups(drv, drv->groups);

if (ret)

bus_remove_driver(drv);

return ret;

}

device_driver的结构体定义如下：

struct device_driver {

const char *name;

struct bus_type *bus;

struct module *owner;

const char *mod_name; /* used for built-in modules */ bool suppress_bind_attrs; /* disables bind/unbind via sysfs */

#if defined(CONFIG_OF)

const struct of_device_id *of_match_table;

#endif

int (*probe) (struct device *dev);

int (*remove) (struct device *dev);

void (*shutdown) (struct device *dev);

int (*suspend) (struct device *dev, pm_message_t state);

const struct attribute_group **groups;

const struct dev_pm_ops *pm;

struct driver_private *p;

};

driver_find(drv->name, drv->bus);的原型为：

struct device_driver *driver_find(const char *name, struct bus_type *bus) {

struct kobject *k = kset_find_obj(bus->p->drivers_kset, name);

struct driver_private *priv;

if (k) {

priv = to_driver(k);

return priv->driver;

}

return NULL;

}

调用bma150_probe，其中bma150_probe的原型为：

static int bma150_probe(struct i2c_client *client,

const struct i2c_device_id *id)

int err = 0;

int tempvalue;

struct bma150_data *data;

//检查适配器是否是I2C功能的？

/*不是所有的I2C或者SMBus适配器实现了I2C规范上的所有功能，因此当访问I2C适配器时，并不能完全假定适配器提供了你所需的功能。the client需要有一种检测适配器是否提供

了所需功能的方法。*/

if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {

printk(KERN_INFO "i2c_check_functionality error\n");

goto exit;

}

data = kzalloc(sizeof(struct bma150_data), GFP_KERNEL);

if (!data) {

err = -ENOMEM;

goto exit;

}

i2c_set_clientdata(client, data);//在下面进行分析。

data->platform_data = client->dev.platform_data;

// if (data->platform_data->power_on)

// data->platform_data->power_on();

// else

// printk(KERN_ERR "power_on function not defined!!\n");

tempvalue = 0;

tempvalue = i2c_smbus_read_word_data(client, BMA150_CHIP_ID_REG);

if ((tempvalue&0x00FF) == BMA150_CHIP_ID) {

printk(KERN_INFO "Bosch Sensortec Device detected!\n" \

"BMA150 registered I2C driver!\n");

} else{

printk(KERN_INFO "Bosch Sensortec Device not found" \

"i2c error %d\n", tempvalue);

err = -1;

goto kfree_exit;

}

i2c_set_clientdata(client, data);

data->bma150_client = client;

mutex_init(&data->value_mutex);

mutex_init(&data->mode_mutex);

bma150_set_bandwidth(client, BMA150_BW_SET);

bma150_set_range(client, BMA150_RANGE_SET);

INIT_DELAYED_WORK(&data->work, bma150_work_func);

atomic_set(&data->delay, BMA150_MAX_DELAY);

err = bma150_input_init(data);

if (err < 0)

goto kfree_exit;

err = sysfs_create_group(&data->input->dev.kobj,

&bma150_attribute_group);

if (err < 0)

goto error_sysfs;

schedule_delayed_work(&data->work,

msecs_to_jiffies(atomic_read(&data->delay))); return 0;

error_sysfs:

bma150_input_delete(data);

kfree_exit:

kfree(data);

exit:

其中：

struct i2c_device_id {

char name[I2C_NAME_SIZE];

kernel_ulong_t driver_data /* Data private to the driver */

__attribute__((aligned(sizeof(kernel_ulong_t)))); };

i2c_check_functionality(client->adapter, I2C_FUNC_I2C)的原型为：

/* Return 1 if adapter supports everything we need, 0 if not. */

static inline int i2c_check_functionality(struct i2c_adapter *adap, u32 func) {

return (func & i2c_get_functionality(adap)) == func;

}

i2c_get_functionality(adap);的原型为：

/* Return the functionality mask */

static inline u32 i2c_get_functionality(struct i2c_adapter *adap)

{

return adap->algo->functionality(adap);

}

其中adap->algo->functionality(adap);

就是s3c24xx_i2c_func

static u32 s3c24xx_i2c_func(struct i2c_adapter *adap)

return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | I2C_FUNC_PROTOCOL_MANGLING; }

i2c_set_clientdata(struct i2c_client *dev,void *data) → dev_set_drvdata(&dev ->dev,data);

其中dev_set_drvdata()的原型为：

void dev_set_drvdata(struct device *dev, void *data)

{

int error;

if (!dev)

return;

if (!dev->p) {

error = device_private_init(dev);

if (error)

return;

}

dev->p->driver_data = data;

}

将client和bma_data进行联系交互

tempvalue = i2c_smbus_read_word_data(client, BMA150_CHIP_ID_REG);//读取寄存器中的值（smbus “read word”协议）

i2c_smbus_read_word_data的原型为：

s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)

{

union i2c_smbus_data data;//成员分别是字节，字，块。用于存储读取的数值 int status;

status = i2c_smbus_xfer(client->adapter, client->addr, client->flags, I2C_SMBUS_READ, command,

I2C_SMBUS_WORD_DATA, &data);//执行SMBus协议操作，这里的command是BMA150芯片寄存器的地址。 I2C_SMBUS_WORD_DATA决定协议如何运行。

return (status < 0) ? status : data.word;

}

其中i2x_smbus_data的定义如下：

union i2c_smbus_data {

__u8 byte;//存储字节

__u16 word;//存储字

__u8 block[I2C_SMBUS_BLOCK_MAX + 2]; /* block[0] is used for length */ /* and one more for user-space compatibility */ };

其中 i2C_SMBUS_READ为1（在

/home/ls/work/android_gingerbread_realv210_ver_1_0/kernel/include/linux/i2c.h 中定义）

command为0x00(表示对chip_id进行操作)。

I2C_SMBUS_WORD_DATA 为 3（在

/home/ls/work/android_gingerbread_realv210_ver_1_0/kernel/include/linux/i2c.h 中定义）

i2c_smbus_xfer(client->adapter, client->addr, client->flags,

I2C_SMBUS_READ, command,

I2C_SMBUS_WORD_DATA, &data);的原型为：（这个函数通过适配器驱动提供的总线访问方法（i2c_algorithm的smbus_fer方法）尝试访问处于addr地址上的设备）

s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,

char read_write, u8 command, int protocol,

union i2c_smbus_data *data)

{

unsigned long orig_jiffies;

int try;

s32 res;

flags &= I2C_M_TEN | I2C_CLIENT_PEC;//检测是否是10位地址或设置包错误检验标志

if (adapter->algo->smbus_xfer) {

rt_mutex_lock(&adapter->bus_lock);

/* Retry automatically on arbitration loss */

orig_jiffies = jiffies;

for (res = 0, try = 0; try <= adapter->retries; try++) {

res = adapter->algo->smbus_xfer(adapter, addr, flags, read_write, command,

protocol, data);

if (res != -EAGAIN)

break;

if (time_after(jiffies,

orig_jiffies + adapter->timeout))

break;

}

rt_mutex_unlock(&adapter->bus_lock);

} else

res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,

command, protocol, data);

//应该走的这里, 经过打log处理确实走的这里

return res;

}

由于目前没有实现smbus_xfer方法而只实现了master_xfer方法，所以相关的操作就通过i2c_smbus_xfer_emulated函数来模拟。

i2c_smbus_xfer_emulated(adapter, addr, flags, read_write, command, protocol, data);

的原型为：（它的作用是使用i2c 协议来模拟SMBus 命令，如果使用这个总线地址和设备通信成功，则说明设备使用的正是这个地址）

static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,

unsigned short flags，char read_write, u8 command, int size,union

i2c_smbus_data *data)

{

//其中的u8 command就是BMA150芯片寄存器的地址。

printk(KERN_ERR "OK\n");