static int s3c24xx_i2c_probe(struct platform_device *pdev)

{

struct s3c24xx_i2c *i2c;//最重要的結構體

//保存設備樹信息

struct s3c2410_platform_i2c *pdata = NULL;

struct resource *res;

int ret;

if (!pdev->dev.of_node) {

pdata = dev_get_platdata(&pdev->dev);

if (!pdata) {

dev_err(&pdev->dev, "no platform data ");

return -EINVAL;

}

}

/*為結構體變量i2c分配內存*/

i2c = devm_kzalloc(&pdev->dev, sizeof(struct s3c24xx_i2c), GFP_KERNEL);

if (!i2c) {

dev_err(&pdev->dev, "no memory for state ");

return -ENOMEM;

}

i2c->pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);

if (!i2c->pdata) {

dev_err(&pdev->dev, "no memory for platform data ");

return -ENOMEM;

}

/*i2c控制器的一些特殊行為

#define QUIRK_S3C2440 (1 << 0)

#define QUIRK_HDMIPHY (1 << 1)

#define QUIRK_NO_GPIO (1 << 2)

#define QUIRK_POLL (1 << 3)

其中bite：3如果采用輪訓方式與底層硬件通信值為1，中斷方式值為0*/

i2c->quirks = s3c24xx_get_device_quirks(pdev);

if (pdata)

memcpy(i2c->pdata, pdata, sizeof(*pdata));

else

s3c24xx_i2c_parse_dt(pdev->dev.of_node, i2c);

strlcpy(i2c->adap.name, "s3c2410-i2c", sizeof(i2c->adap.name));

i2c->adap.owner = THIS_MODULE;

/*為i2c_msg傳輸方法賦值，*/

i2c->adap.algo = &s3c24xx_i2c_algorithm;

i2c->adap.retries = 2;

i2c->adap.class = I2C_CLASS_HWMON | I2C_CLASS_SPD;

i2c->tx_setup = 50;

//初始化等待隊列，該等待隊列用于喚醒讀寫數據的進程

init_waitqueue_head(&i2c->wait);

/* find the clock and enable it */

i2c->dev = &pdev->dev;

//獲取時鐘

i2c->clk = devm_clk_get(&pdev->dev, "i2c");

if (IS_ERR(i2c->clk)) {

dev_err(&pdev->dev, "cannot get clock ");

return -ENOENT;

}

dev_dbg(&pdev->dev, "clock source %p ", i2c->clk);

/* map the registers */

//通過pdev得到i2c控制器的寄存器地址資源

res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

//映射i2c控制器的物理基地址為虛擬基地址

i2c->regs = devm_ioremap_resource(&pdev->dev, res);

if (IS_ERR(i2c->regs))

return PTR_ERR(i2c->regs);

dev_dbg(&pdev->dev, "registers %p (%p) ",

i2c->regs, res);

/* setup info block for the i2c core */

/*將結構體變量i2c保存到i2c_adapter的私有變量指針algo_data，

編寫i2c設備驅動可以通過adapter指針找到結構體i2c*/

i2c->adap.algo_data = i2c;

i2c->adap.dev.parent = &pdev->dev;

i2c->pctrl = devm_pinctrl_get_select_default(i2c->dev);

/* inititalise the i2c gpio lines */

//得到i2c復用的gpio引腳并初始化

if (i2c->pdata->cfg_gpio) {

i2c->pdata->cfg_gpio(to_platform_device(i2c->dev));

} else if (IS_ERR(i2c->pctrl) && s3c24xx_i2c_parse_dt_gpio(i2c)) {

return -EINVAL;

}

/* initialise the i2c controller */

clk_prepare_enable(i2c->clk);

/*將從設備地址寫入寄存器S3C2410_IICADD，同時初始化時鐘頻率*/

ret = s3c24xx_i2c_init(i2c);

clk_disable_unprepare(i2c->clk);

if (ret != 0) {

dev_err(&pdev->dev, "I2C controller init failed ");

return ret;

}

/* find the IRQ for this unit (note, this relies on the init call to

* ensure no current IRQs pending

*/

if (!(i2c->quirks & QUIRK_POLL)) {

/*從plat_device中獲得中斷號*/

i2c->irq = ret = platform_get_irq(pdev, 0);

if (ret <= 0) {

dev_err(&pdev->dev, "cannot find IRQ ");

return ret;

}

/*注冊中斷處理函數s3c24xx_i2c_irq()*/

ret = devm_request_irq(&pdev->dev, i2c->irq, s3c24xx_i2c_irq, 0,

dev_name(&pdev->dev), i2c);

if (ret != 0) {

dev_err(&pdev->dev, "cannot claim IRQ %d ", i2c->irq);

return ret;

}

}

ret = s3c24xx_i2c_register_cpufreq(i2c);

if (ret < 0) {

dev_err(&pdev->dev, "failed to register cpufreq notifier ");

return ret;

}

/* Note, previous versions of the driver used i2c_add_adapter()

* to add the bus at any number. We now pass the bus number via

* the platform data, so if unset it will now default to always

* being bus 0.

*/

/*保存i2c控制器的通道號，本例是bus 5*/

i2c->adap.nr = i2c->pdata->bus_num;

i2c->adap.dev.of_node = pdev->dev.of_node;

//注冊adapter

ret = i2c_add_numbered_adapter(&i2c->adap);

if (ret < 0) {

dev_err(&pdev->dev, "failed to add bus to i2c core ");

s3c24xx_i2c_deregister_cpufreq(i2c);

return ret;

}

/*保存私有變量i2c到pdev->dev->p->driver_data*/

platform_set_drvdata(pdev, i2c);

pm_runtime_enable(&pdev->dev);

pm_runtime_enable(&i2c->adap.dev);

dev_info(&pdev->dev, "%s: S3C I2C adapter ", dev_name(&i2c->adap.dev));

return 0;

}

static int i2c_register_adapter(struct i2c_adapter *adap)

{

int res = 0;

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

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

res = -EAGAIN;

goto out_list;

}

/* Sanity checks */

if (unlikely(adap->name[0] == '?')) {

pr_err("i2c-core: Attempt to register an adapter with "

"no name! ");

return -EINVAL;

}

if (unlikely(!adap->algo)) {

pr_err("i2c-core: Attempt to register adapter '%s' with "

"no algo! ", adap->name);

return -EINVAL;

}

rt_mutex_init(&adap->bus_lock);

mutex_init(&adap->userspace_clients_lock);

INIT_LIST_HEAD(&adap->userspace_clients);

/* Set default timeout to 1 second if not already set */

if (adap->timeout == 0)

adap->timeout = HZ;

//設置adapter名字,本例注冊后會生成以下節點/dev/i2c-5

dev_set_name(&adap->dev, "i2c-%d", adap->nr);

adap->dev.bus = &i2c_bus_type;

adap->dev.type = &i2c_adapter_type;

res = device_register(&adap->dev);

if (res)

goto out_list;

dev_dbg(&adap->dev, "adapter [%s] registered ", adap->name);

#ifdef CONFIG_I2C_COMPAT

res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,

adap->dev.parent);

if (res)

dev_warn(&adap->dev,

"Failed to create compatibility class link ");

#endif

/* bus recovery specific initialization */

/*初始化sda、scl，通常這兩個引腳會復用gpio引腳*/

if (adap->bus_recovery_info) {

struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;

if (!bri->recover_bus) {

dev_err(&adap->dev, "No recover_bus() found, not using recovery ");

adap->bus_recovery_info = NULL;

goto exit_recovery;

}

/* Generic GPIO recovery */

if (bri->recover_bus == i2c_generic_gpio_recovery) {

if (!gpio_is_valid(bri->scl_gpio)) {

dev_err(&adap->dev, "Invalid SCL gpio, not using recovery ");

adap->bus_recovery_info = NULL;

goto exit_recovery;

}

if (gpio_is_valid(bri->sda_gpio))

bri->get_sda = get_sda_gpio_value;

else

bri->get_sda = NULL;

/*sda、scl資源賦值*/

bri->get_scl = get_scl_gpio_value;

bri->set_scl = set_scl_gpio_value;

} else if (!bri->set_scl || !bri->get_scl) {

/* Generic SCL recovery */

dev_err(&adap->dev, "No {get|set}_gpio() found, not using recovery ");

adap->bus_recovery_info = NULL;

}

}

exit_recovery:

/* create pre-declared device nodes */

/*通過設備樹節點注冊所有該控制器下的所有從設備*/

of_i2c_register_devices(adap);

acpi_i2c_register_devices(adap);

/*與動態分配的總線號相關，動態分配的總線號應該是從已經現有最大總線號基礎上+1的，

這樣能夠保證動態分配出的總線號與板級總線號不會產生沖突

在沒有設備樹情況下，會基于隊列__i2c_board_list, 創建i2c_client

其中節點struct i2c_board_info手動填寫*/

if (adap->nr < ? __i2c_first_dynamic_bus_num)

i2c_scan_static_board_info(adap);

/* Notify drivers */

mutex_lock(&core_lock);

bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);

mutex_unlock(&core_lock);

return 0;

out_list:

mutex_lock(&core_lock);

idr_remove(&i2c_adapter_idr, adap->nr);

mutex_unlock(&core_lock);

return res;

}

static void of_i2c_register_devices(struct i2c_adapter *adap)

{

void *result;

struct device_node *node;

/* Only register child devices if the adapter has a node pointer set */

if (!adap->dev.of_node)

return;

dev_dbg(&adap->dev, "of_i2c: walking child nodes ");

for_each_available_child_of_node(adap->dev.of_node, node) {

struct i2c_board_info info = {};

struct dev_archdata dev_ad = {};

const __be32 *addr;

int len;

dev_dbg(&adap->dev, "of_i2c: register %s ", node->full_name);

if (of_modalias_node(node, info.type, sizeof(info.type)) < 0) {

dev_err(&adap->dev, "of_i2c: modalias failure on %s ",

node->full_name);

continue;

}

/*獲取從設備的地址*/

addr = of_get_property(node, "reg", &len);

if (!addr || (len < ? sizeof(int))) {

dev_err(&adap->dev, "of_i2c: invalid reg on %s ",

node->full_name);

continue;

}

/*存儲從設備地址*/

info.addr = be32_to_cpup(addr);

if (info.addr > (1 << ? 10) - 1) {

dev_err(&adap->dev, "of_i2c: invalid addr=%x on %s ",

info.addr, node->full_name);

continue;

}

/*獲取中斷號*/

info.irq = irq_of_parse_and_map(node, 0);

info.of_node = of_node_get(node);

info.archdata = &dev_ad;

/*獲取設備樹節點wakeup-source信息*/

if (of_get_property(node, "wakeup-source", NULL))

info.flags |= I2C_CLIENT_WAKE;

request_module("%s%s", I2C_MODULE_PREFIX, info.type);

/*將i2c_board_info轉換成i2c_client并注冊到i2c總線*/

result = i2c_new_device(adap, &info);

if (result == NULL) {

dev_err(&adap->dev, "of_i2c: Failure registering %s ",

node->full_name);

of_node_put(node);

irq_dispose_mapping(info.irq);

continue;

}

}

}

{

struct i2c_client *client;

int status;

/*給i2c_client分配內存*/

client = kzalloc(sizeof *client, GFP_KERNEL);

if (!client)

return NULL;

/*將adapter的地址保存到i2c_client->adapter，

在驅動函數中可以通過i2c_client找到adapter*/

client->adapter = adap;

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 ",

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.parent = &client->adapter->dev;

client->dev.bus = &i2c_bus_type;

client->dev.type = &i2c_client_type;

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

ACPI_COMPANION_SET(&client->dev, info->acpi_node.companion);

i2c_dev_set_name(adap, client);

/*注冊到Linux核心*/

status = device_register(&client->dev);

if (status)

goto out_err;

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

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

return client;

out_err:

dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "

"(%d) ", client->name, client->addr, status);

out_err_silent:

kfree(client);

return NULL;

}