Linux驱动子系统之I2C（二）

4 总线驱动
4.1 概述
I2C总线驱动是I2C适配器的软件实现，提供I2C适配器与从设备间完成数据通信的能力，比如起始，停止，应答信号和master_xfer的实现函数。
I2C总线驱动由i2c_adapter和i2c_algorithm来描述
4.2 DM8168 I2C控制器的硬件描述
DM8168处理器内部集成了二个I2C控制器，通过一下寄存器来进行控制：

const static u8 omap4_reg_map[] = {
　　 [OMAP_I2C_REV_REG] = 0x04,
[OMAP_I2C_IE_REG] = 0x2c,
[OMAP_I2C_STAT_REG] = 0x28,
[OMAP_I2C_IV_REG] = 0x34,
[OMAP_I2C_WE_REG] = 0x34,
[OMAP_I2C_SYSS_REG] = 0x90,
[OMAP_I2C_BUF_REG] = 0x94,
[OMAP_I2C_CNT_REG] = 0x98,
[OMAP_I2C_DATA_REG] = 0x9c,
[OMAP_I2C_SYSC_REG] = 0x20,
[OMAP_I2C_CON_REG] = 0xa4,
[OMAP_I2C_OA_REG] = 0xa8,
[OMAP_I2C_SA_REG] = 0xac,
[OMAP_I2C_PSC_REG] = 0xb0,
[OMAP_I2C_SCLL_REG] = 0xb4,
[OMAP_I2C_SCLH_REG] = 0xb8,
[OMAP_I2C_SYSTEST_REG] = 0xbC,
[OMAP_I2C_BUFSTAT_REG] = 0xc0,
[OMAP_I2C_REVNB_LO] = 0x00,
[OMAP_I2C_REVNB_HI] = 0x04,
[OMAP_I2C_IRQSTATUS_RAW] = 0x24,
[OMAP_I2C_IRQENABLE_SET] = 0x2c,
[OMAP_I2C_IRQENABLE_CLR] = 0x30,
};

4.3 i2c-oamp总线驱动分析(platform_driver)
I2C总线驱动代码在drivers/i2c/busses/i2c-oamp.c，这个代码同样支持其他TI 芯片。
初始化模块和卸载模块

/* I2C may be needed to bring up other drivers */
static int __init
omap_i2c_init_driver(void)
{
return platform_driver_register(&omap_i2c_driver);
}
subsys_initcall(omap_i2c_init_driver);

static void __exit omap_i2c_exit_driver(void)
{
platform_driver_unregister(&omap_i2c_driver);
}
module_exit(omap_i2c_exit_driver);

总线驱动是基于platform来实现的，很符合设备驱动模型的思想。

static struct platform_driver omap_i2c_driver = {
.probe        = omap_i2c_probe,
.remove        = omap_i2c_remove,
.driver        = {
.name    = "omap_i2c",
.owner    = THIS_MODULE,
},
};

oamp_i2c_probe函数
当调用platform_driver_register函数注册platform_driver结构体时，如果platformdevice 和 platform driver匹配成功后，会调用probe函数，来初始化适配器硬件。

static int __devinit
omap_i2c_probe(struct platform_device *pdev)
{
struct omap_i2c_dev    *dev;
struct i2c_adapter    *adap;
struct resource        *mem, *irq, *ioarea;
struct omap_i2c_bus_platform_data *pdata = pdev->dev.platform_data;
irq_handler_t isr;
int r;
u32 speed = 0;

/* NOTE: driver uses the static register mapping */
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!mem) {
dev_err(&pdev->dev, "no mem resource?\n");
return -ENODEV;
}
irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
if (!irq) {
dev_err(&pdev->dev, "no irq resource?\n");
return -ENODEV;
}

ioarea = request_mem_region(mem->start, resource_size(mem),
pdev->name);
if (!ioarea) {
dev_err(&pdev->dev, "I2C region already claimed\n");
return -EBUSY;
}

dev = kzalloc(sizeof(struct omap_i2c_dev), GFP_KERNEL);
if (!dev) {
r = -ENOMEM;
goto err_release_region;
}

if (pdata != NULL) {
speed = pdata->clkrate;
dev->set_mpu_wkup_lat = pdata->set_mpu_wkup_lat;
} else {
speed = 100;    /* Default speed */
dev->set_mpu_wkup_lat = NULL;
}

dev->speed = speed;
dev->idle = 1;
dev->dev = &pdev->dev;
dev->irq = irq->start;
dev->base = ioremap(mem->start, resource_size(mem));
if (!dev->base) {
r = -ENOMEM;
goto err_free_mem;
}

platform_set_drvdata(pdev, dev);

if (cpu_is_omap7xx())
dev->reg_shift = 1;
else if (cpu_is_omap44xx() || cpu_is_ti81xx())
dev->reg_shift = 0;
else
dev->reg_shift = 2;

if (cpu_is_omap44xx() || cpu_is_ti81xx())
dev->regs = (u8 *) omap4_reg_map;
else
dev->regs = (u8 *) reg_map;

pm_runtime_enable(&pdev->dev);
omap_i2c_unidle(dev);

dev->rev = omap_i2c_read_reg(dev, OMAP_I2C_REV_REG) & 0xff;

if (dev->rev <= OMAP_I2C_REV_ON_3430)
dev->errata |= I2C_OMAP3_1P153;

if (!(cpu_class_is_omap1() || cpu_is_omap2420())) {
u16 s;

/* Set up the fifo size - Get total size */
s = (omap_i2c_read_reg(dev, OMAP_I2C_BUFSTAT_REG) >> 14) & 0x3;
dev->fifo_size = 0x8 << s;

/*
* Set up notification threshold as half the total available
* size. This is to ensure that we can handle the status on int
* call back latencies.
*/
if (dev->rev >= OMAP_I2C_REV_ON_4430) {
dev->fifo_size = 0;
dev->b_hw = 0; /* Disable hardware fixes */
} else {
dev->fifo_size = (dev->fifo_size / 2);
dev->b_hw = 1; /* Enable hardware fixes */
}
/* calculate wakeup latency constraint for MPU */
if (dev->set_mpu_wkup_lat != NULL)
dev->latency = (1000000 * dev->fifo_size) /
(1000 * speed / 8);
}

/* reset ASAP, clearing any IRQs */
omap_i2c_init(dev);

isr = (dev->rev < OMAP_I2C_REV_2) ? omap_i2c_rev1_isr : omap_i2c_isr;
r = request_irq(dev->irq, isr, 0, pdev->name, dev);

if (r) {
dev_err(dev->dev, "failure requesting irq %i\n", dev->irq);
goto err_unuse_clocks;
}

dev_info(dev->dev, "bus %d rev%d.%d at %d kHz\n",
pdev->id, dev->rev >> 4, dev->rev & 0xf, dev->speed);

omap_i2c_idle(dev);

adap = &dev->adapter;
i2c_set_adapdata(adap, dev);
adap->owner = THIS_MODULE;
adap->class = I2C_CLASS_HWMON;
strlcpy(adap->name, "OMAP I2C adapter", sizeof(adap->name));
adap->algo = &omap_i2c_algo;
adap->dev.parent = &pdev->dev;

/* i2c device drivers may be active on return from add_adapter() */
adap->nr = pdev->id;
r = i2c_add_numbered_adapter(adap);
if (r) {
dev_err(dev->dev, "failure adding adapter\n");
goto err_free_irq;
}

return 0;

err_free_irq:
free_irq(dev->irq, dev);
err_unuse_clocks:
omap_i2c_write_reg(dev, OMAP_I2C_CON_REG, 0);
omap_i2c_idle(dev);
iounmap(dev->base);
err_free_mem:
platform_set_drvdata(pdev, NULL);
kfree(dev);
err_release_region:
release_mem_region(mem->start, resource_size(mem));

return r;
}

Probe主要工作是时能硬件并申请I2C适配器使用的IO地址，中断号等，然后向I2C核心添加这个适配器。I2c_adapter注册过程i2c_add_numbered_adapter->i2c_register_adapter
I2C总线通信方法

static const struct i2c_algorithm omap_i2c_algo = {
.master_xfer    = omap_i2c_xfer,
.functionality    = omap_i2c_func,
};

oamp_i2c_xfer函数是总线通信方式的具体实现，依赖于omap_i2c_wait_for_bb和omap_i2c_xfer_msg两个函数；

/*
* Prepare controller for a transaction and call omap_i2c_xfer_msg
* to do the work during IRQ processing.
*/
static int
omap_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num)
{
struct omap_i2c_dev *dev = i2c_get_adapdata(adap);
int i;
int r;

omap_i2c_unidle(dev);

r = omap_i2c_wait_for_bb(dev);
if (r < 0)
goto out;

for (i = 0; i < num; i++) {
r = omap_i2c_xfer_msg(adap, &msgs[i], (i == (num - 1)));
if (r != 0)
break;
}

if (r == 0)
r = num;

omap_i2c_wait_for_bb(dev);
out:
omap_i2c_idle(dev);
return r;
}

首先设置s3c I2C控制器是否忙，不忙然后调用omap_i2c_xfer_msg函数启动I2C消息传输。
omap_i2c_func函数返回适配器所支持的通信功能。

static u32
omap_i2c_func(struct i2c_adapter *adap)
{
return I2C_FUNC_I2C | (I2C_FUNC_SMBUS_EMUL & ~I2C_FUNC_SMBUS_QUICK);
}

4.4 适配器的设备资源(platform_device)
DM8168的I2C总线驱动是基于platform来实现，前面我们分析了platform driver部分，再来看下platform device部分。
在arch/arm/mach-oamp2/omap_hwmod_81xx_data.c文件中定义了platform_device结构体以及I2C控制器的资源信息（注意由于DM8168属于不对称多核架构，分为l3（内部核之间）、l4（外围设备与核直接）两个总线，通过ti81xx_hwmod_init->omap_hwmod_init->_register将所有的设备资源（omap_hwmod结构体）加入到omap_hwmod_list链表中）：

static struct omap_hwmod ti81xx_i2c1_hwmod = {
.name        = "i2c1",
.mpu_irqs    = i2c1_mpu_irqs,
.mpu_irqs_cnt    = ARRAY_SIZE(i2c1_mpu_irqs),
.sdma_reqs    = i2c1_edma_reqs,
.sdma_reqs_cnt    = ARRAY_SIZE(i2c1_edma_reqs),
.main_clk    = "i2c1_fck",
.prcm        = {
.omap4 = {
.clkctrl_reg = TI816X_CM_ALWON_I2C_0_CLKCTRL,
},
},
.slaves        = ti816x_i2c1_slaves,
.slaves_cnt    = ARRAY_SIZE(ti816x_i2c1_slaves),
.class        = &i2c_class,
.omap_chip    = OMAP_CHIP_INIT(CHIP_IS_TI81XX),
};
///////////////////////////
static struct omap_hwmod ti816x_i2c2_hwmod = {
.name           = "i2c2",
.mpu_irqs       = i2c2_mpu_irqs,
.mpu_irqs_cnt   = ARRAY_SIZE(i2c2_mpu_irqs),
.sdma_reqs      = i2c2_edma_reqs,
.sdma_reqs_cnt  = ARRAY_SIZE(i2c2_edma_reqs),
.main_clk       = "i2c2_fck",
.prcm           = {
.omap4 = {
.clkctrl_reg = TI816X_CM_ALWON_I2C_1_CLKCTRL,
},
},
.slaves         = ti816x_i2c2_slaves,
.slaves_cnt     = ARRAY_SIZE(ti816x_i2c2_slaves),
.class          = &i2c_class,
.omap_chip      = OMAP_CHIP_INIT(CHIP_IS_TI816X),
};

查找平台设备硬件资源(通过omap2_i2c_add_bus->omap_hwmod_lookup从omap_hwmod_list链表中查到相应的硬件资源（omap_hwmod）)：

/**
* omap_hwmod_lookup - look up a registered omap_hwmod by name
* @name: name of the omap_hwmod to look up
*
* Given a @name of an omap_hwmod, return a pointer to the registered
* struct omap_hwmod *, or NULL upon error.
*/
struct omap_hwmod *omap_hwmod_lookup(const char *name)
{
struct omap_hwmod *oh;

if (!name)
return NULL;

oh = _lookup(name);

return oh;
}

将查找到的硬件资源填充平台设备的resource结构体（omap2_i2c_add_bus->omap_device_build->omap_device_build_ss->omap_device_fill_resources->omap_hwmod_fill_resources）：

/**
* omap_hwmod_fill_resources - fill struct resource array with hwmod data
* @oh: struct omap_hwmod *
* @res: pointer to the first element of an array of struct resource to fill
*
* Fill the struct resource array @res with resource data from the
* omap_hwmod @oh.  Intended to be called by code that registers
* omap_devices.  See also omap_hwmod_count_resources().  Returns the
* number of array elements filled.
*/
int omap_hwmod_fill_resources(struct omap_hwmod *oh, struct resource *res)
{
int i, j;
int r = 0;

/* For each IRQ, DMA, memory area, fill in array.*/

for (i = 0; i < oh->mpu_irqs_cnt; i++) {
(res + r)->name = (oh->mpu_irqs + i)->name;
(res + r)->start = (oh->mpu_irqs + i)->irq;
(res + r)->end = (oh->mpu_irqs + i)->irq;
(res + r)->flags = IORESOURCE_IRQ;
r++;
}

for (i = 0; i < oh->sdma_reqs_cnt; i++) {
(res + r)->name = (oh->sdma_reqs + i)->name;
(res + r)->start = (oh->sdma_reqs + i)->dma_req;
(res + r)->end = (oh->sdma_reqs + i)->dma_req;
(res + r)->flags = IORESOURCE_DMA;
r++;
}

for (i = 0; i < oh->slaves_cnt; i++) {
struct omap_hwmod_ocp_if *os;

os = oh->slaves[i];

for (j = 0; j < os->addr_cnt; j++) {
(res + r)->name = (os->addr + j)->name;
(res + r)->start = (os->addr + j)->pa_start;
(res + r)->end = (os->addr + j)->pa_end;
(res + r)->flags = IORESOURCE_MEM;
r++;
}
}

return r;
}

在板文件中把platform_device注册进内核(omap2_i2c_add_bus->omap_device_build->omap_device_build_ss->omap_device_register->platform_device_register)：

/**
* omap_device_register - register an omap_device with one omap_hwmod
* @od: struct omap_device * to register
*
* Register the omap_device structure.  This currently just calls
* platform_device_register() on the underlying platform_device.
* Returns the return value of platform_device_register().
*/
int omap_device_register(struct omap_device *od)
{
pr_debug("omap_device: %s: registering\n", od->pdev.name);

od->pdev.dev.parent = &omap_device_parent;
return platform_device_register(&od->pdev);
}

调用platform_device_add_data函数把适配器具体的数据赋值给dev.platform_data(omap2_i2c_add_bus->omap_device_build->omap_device_build_ss->platform_device_add_data)：

/**
* platform_device_add_data - add platform-specific data to a platform device
* @pdev: platform device allocated by platform_device_alloc to add resources to
* @data: platform specific data for this platform device
* @size: size of platform specific data
*
* Add a copy of platform specific data to the platform device's
* platform_data pointer.  The memory associated with the platform data
* will be freed when the platform device is released.
*/
int platform_device_add_data(struct platform_device *pdev, const void *data,
size_t size)
{
void *d;

if (!data)
return 0;

d = kmemdup(data, size, GFP_KERNEL);
if (d) {
pdev->dev.platform_data = d;
return 0;
}
return -ENOMEM;
}
EXPORT_SYMBOL_GPL(platform_device_add_data);

I2C总线驱动就分析到这里。

5 客户驱动
5.1 概述
I2C客户驱动是对I2C从设备的实现，一个具体的I2C客户驱动包括两个部分：一部分是i2c_driver，用于将设备挂接于i2c总线；另一部分是设备本身的驱动。
I2C客户驱动程序主要由i2c_driver和i2c_client来描述。
5.2 实例源码分析
好了，我们来深入了解客户驱动代码的实现，sound/soc/codesc/tlv320aic3x.c文件。
I2c_driver实现

/* machine i2c codec control layer */
static struct i2c_driver aic3x_i2c_driver = {
.driver = {
.name = "tlv320aic3x-codec",
.owner = THIS_MODULE,
},
.probe    = aic3x_i2c_probe,
.remove = aic3x_i2c_remove,
.id_table = aic3x_i2c_id,
};

初始化和卸载

static int __init aic3x_modinit(void)
{
int ret = 0;
#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
ret = i2c_add_driver(&aic3x_i2c_driver);
if (ret != 0) {
printk(KERN_ERR "Failed to register TLV320AIC3x I2C driver: %d\n",
ret);
}
#endif
return ret;
}
module_init(aic3x_modinit);

static void __exit aic3x_exit(void)
{
#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
i2c_del_driver(&aic3x_i2c_driver);
#endif
}
module_exit(aic3x_exit);

aic3x_i2c_Probe函数

/*
* If the i2c layer weren't so broken, we could pass this kind of data
* around
*/
static int aic3x_i2c_probe(struct i2c_client *i2c,
const struct i2c_device_id *id)
{
struct aic3x_pdata *pdata = i2c->dev.platform_data;
struct aic3x_priv *aic3x;
int ret;
const struct i2c_device_id *tbl;

aic3x = kzalloc(sizeof(struct aic3x_priv), GFP_KERNEL);
if (aic3x == NULL) {
dev_err(&i2c->dev, "failed to create private data\n");
return -ENOMEM;
}

aic3x->control_data = i2c;
aic3x->control_type = SND_SOC_I2C;

i2c_set_clientdata(i2c, aic3x);
if (pdata) {
aic3x->gpio_reset = pdata->gpio_reset;
aic3x->setup = pdata->setup;
} else {
aic3x->gpio_reset = -1;
}

for (tbl = aic3x_i2c_id; tbl->name[0]; tbl++) {
if (!strcmp(tbl->name, id->name))
break;
}
aic3x->model = tbl - aic3x_i2c_id;

ret = snd_soc_register_codec(&i2c->dev,
&soc_codec_dev_aic3x, &aic3x_dai, 1);
if (ret < 0)
kfree(aic3x);
return ret;
}

Probe函数主要的工作是初始化芯片的控制类型，控制数据（i2c_client）,并且注册解码器到声卡。
5.3 I2c_client实现
tlv320aic3x不依赖于具体的CPU和I2C控制器硬件特性，因此如果电路板包含该外设，只需要添加对应的i2c_board_info，下面是tlv320aic3x i2c_client在板文件中的实现：

static struct i2c_board_info __initdata ti816x_i2c_boardinfo0[] = {
{
I2C_BOARD_INFO("tlv320aic3x", 0x18),
},
{
I2C_BOARD_INFO("ds1337", 0x68),
},
#ifdef CONFIG_REGULATOR_TPS40400
{
I2C_BOARD_INFO("pmbus", 0x38),
.platform_data    = &pmbus_pmic_init_data,
},
#endif
{
I2C_BOARD_INFO("24c256",0x00),  //
},
};

I2c_register_board_info函数会把I2C从设备硬件特性信息注册到全局链表__i2c_board_list，在调用i2c_add_adapter函数时，会遍历__i2c_board_list获得从设备信息来构造i2c_client(omap_register_i2c_bus->omap_register_i2c_bus)。

/**
* omap_register_i2c_bus - register I2C bus with device descriptors
* @bus_id: bus id counting from number 1
* @clkrate: clock rate of the bus in kHz
* @info: pointer into I2C device descriptor table or NULL
* @len: number of descriptors in the table
*
* Returns 0 on success or an error code.
*/
int __init omap_register_i2c_bus(int bus_id, u32 clkrate,
struct i2c_board_info const *info,
unsigned len)
{
int err;

BUG_ON(bus_id < 1 || bus_id > omap_i2c_nr_ports());

if (info) {
err = i2c_register_board_info(bus_id, info, len);
if (err)
return err;
}

if (!i2c_pdata[bus_id - 1].clkrate)
i2c_pdata[bus_id - 1].clkrate = clkrate;

i2c_pdata[bus_id - 1].clkrate &= ~OMAP_I2C_CMDLINE_SETUP;

return omap_i2c_add_bus(bus_id);
}

I2c_client的构建
我们调用I2c_register_board_info函数会把I2C从设备硬件特性信息注册到全局链表__i2c_board_list，但是还没有构建出一个i2c_client结构体，也没有注册进I2C总线。我们来分析一下构造的过程，调用i2c_add_adapter函数时，会遍历__i2c_board_list获得从设备信息来构造i2c_client：i2c_register_adapter()->i2c_scan_static_board_info()->i2c_new_device()->device_register()。
5.4 I2c_driver和i2c_client的match
在调用i2c_add_driver注册i2c_driver和构建i2c_client时，都会调用i2c bus中注册的i2c_device_match()->i2c_match_id()函数通过i2c_driver->id_table->name和client->name来匹配(i2c_add_driver->i2c_register_driver->driver_register->bus_add_driver->driver_attach->__driver_attach->driver_match_device->i2c_device_match->i2c_match_id)

static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
const struct i2c_client *client)
{
while (id->name[0]) {
if (strcmp(client->name, id->name) == 0)
return id;
id++;
}
return NULL;
}

5.5 测试
i2c-tools测试工具可以从http://www.lm-sensors.org/wiki/I2CTools下载，按照http://3sec.kilab.tw/?p=260来进行试验，这个工具可以测试I2C子系统。
i2c-tools中含有四個執行檔
i2cdetect – 用來列舉I2C bus和上面所有的裝置
i2cdump – 顯示裝置上所有register的值
i2cget – 讀取裝置上某個register的值
i2cset – 寫入裝置上某個register
./i2cdetect -l 查看有多少I2C总线组
./i2cdetect -y -r 1 查看看bus上有那些裝置

总结
I2c_driver、i2c_client与i2c_adapter
I2c_driver与i2c_client是一对多的关系，一个i2c_driver上可以支持多个同等类型的i2c_client。调用i2c_add_driver函数将I2c_driver注册到I2C总线上，调用i2c_register_board_info函数将i2c_client注册到全局链表__i2c_board_list。当调用i2c_add_adapter注册适配器时，遍历__i2c_board_list链表，i2c_register_adapter()->i2c_scan_static_board_info()->i2c_new_device()会构建i2c_client结构。当调用i2c_add_driver时，会先注册i2c_driver到I2C总线上，然后调用I2C BUS注册的match函数进行匹配，如果匹配成功，则先调用I2C BUS中注册的probe函数，在调用i2c_driver中实现的probe函数，完成相应的工作（i2c_add_numbered_adapter->i2c_register_adapter->i2c_scan_static_board_info->i2c_new_device->device_register->device_attach->__device_attach->driver_probe_device->really_probe->dev->bus->probe、drv->probe）。
i2c控制器驱动开发步骤：
1.通过platform_device和platform_device_register创建平台设备和资源i2c控制器驱动。
2.通过platform_driver和platform_driver_register、i2c_add_numbered_adapter实现。
i2c设备驱动开发步骤：
1.判断是写用户驱动还是客服驱动，客服驱动需要下面的两步。
2.通过I2C_BOARD_INFO和i2c_register_board_info来创建i2c_client，并且绑定i2c适配器（也就是控制器）。
3.通过i2c_driver和i2c_add_driver实现i2c客户驱动。