Linux裝置驅動程式架構分析之I2C架構(基於3.10.1核心)
作者:劉昊昱
核心版本:3.10.1
I2C體系架構的硬體實體包括兩部分:
- 硬體I2C Adapter:硬體I2C Adapter表示一個硬體I2C介面卡,也就是I2C控制器。一般是SOC中的一個介面,也可以用GPIO模擬。硬體I2C Adapter主要用來在I2C介面上產生I2C時鐘訊號和資料訊號。
- 硬體I2C Device:表示一個I2C從裝置,I2C從裝置並行的掛接在I2C總線上,通過I2C介面與I2C主控制器通訊。
Linux的I2C體系架構包括6個部分:
- I2C Core,定義了一些函式和資料結構,用於支援I2C控制器驅動(I2C Adapter drvier)和I2C裝置驅動(I2C client driver)。I2C Core的存在使I2C控制器驅動和I2C裝置驅動獨立開來,具有更好的可移置性,同時簡化了驅動開發的工作量。但是,I2C Core的存在也使Linux I2C體系結構理解起來更有難度。
- I2C Adapter,代表一個I2C控制器,用struct i2c_adapter來表示。
- Algorithm,訪問I2C控制器的介面,Algorithm直接操作I2C控制器的硬體暫存器來執行資料的傳送和接收。它提供操作I2C控制器的最底層操作函式。每個I2C Adapter都有自己的Algorithm,每個I2C Adapter通過自己的Algorithm與掛接在該控制器上的I2C從裝置進行通訊。
- I2C Client,代表一個掛接在I2C總線上的I2C裝置。
- I2C裝置驅動(I2C client driver)
- I2C-dev,I2C控制器的裝置檔案,通常命名為i2c-0、i2c-1等等,是I2C控制器的應用層訪問介面。
一、I2C相關資料結構
I2C控制器(例如S3C2440 I2C控制器)對應的資料結構是i2c_adapter,i2c_adapter結構定義在include/linux/i2c.h檔案中,從註釋可以看出,i2c_adapter代表一條物理的I2C匯流排,同時還包括訪問該I2C匯流排的方法。其內容如下:
409/* 410 * i2c_adapter is the structure used to identify a physical i2c bus along 411 * with the access algorithms necessary to access it. 412 */ 413struct i2c_adapter { 414 struct module *owner; 415 unsigned int class; /* classes to allow probing for */ 416 const struct i2c_algorithm *algo; /* the algorithm to access the bus */ 417 void *algo_data; 418 419 /* data fields that are valid for all devices */ 420 struct rt_mutex bus_lock; 421 422 int timeout; /* in jiffies */ 423 int retries; 424 struct device dev; /* the adapter device */ 425 426 int nr; 427 char name[48]; 428 struct completion dev_released; 429 430 struct mutex userspace_clients_lock; 431 struct list_head userspace_clients; 432 433 struct i2c_bus_recovery_info *bus_recovery_info; 434};
i2c_algorithm定義在include/linux/i2c.h檔案中,其內容如下:
347/*
348 * The following structs are for those who like to implement new bus drivers:
349 * i2c_algorithm is the interface to a class of hardware solutions which can
350 * be addressed using the same bus algorithms - i.e. bit-banging or the PCF8584
351 * to name two of the most common.
352 */
353struct i2c_algorithm {
354 /* If an adapter algorithm can't do I2C-level access, set master_xfer
355 to NULL. If an adapter algorithm can do SMBus access, set
356 smbus_xfer. If set to NULL, the SMBus protocol is simulated
357 using common I2C messages */
358 /* master_xfer should return the number of messages successfully
359 processed, or a negative value on error */
360 int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs,
361 int num);
362 int (*smbus_xfer) (struct i2c_adapter *adap, u16 addr,
363 unsigned short flags, char read_write,
364 u8 command, int size, union i2c_smbus_data *data);
365
366 /* To determine what the adapter supports */
367 u32 (*functionality) (struct i2c_adapter *);
368};
struct i2c_client代表一個I2C裝置,該結構體定義在include/linux/i2c.h檔案中,其內容如下:
200/**
201 * struct i2c_client - represent an I2C slave device
202 * @flags: I2C_CLIENT_TEN indicates the device uses a ten bit chip address;
203 * I2C_CLIENT_PEC indicates it uses SMBus Packet Error Checking
204 * @addr: Address used on the I2C bus connected to the parent adapter.
205 * @name: Indicates the type of the device, usually a chip name that's
206 * generic enough to hide second-sourcing and compatible revisions.
207 * @adapter: manages the bus segment hosting this I2C device
208 * @driver: device's driver, hence pointer to access routines
209 * @dev: Driver model device node for the slave.
210 * @irq: indicates the IRQ generated by this device (if any)
211 * @detected: member of an i2c_driver.clients list or i2c-core's
212 * userspace_devices list
213 *
214 * An i2c_client identifies a single device (i.e. chip) connected to an
215 * i2c bus. The behaviour exposed to Linux is defined by the driver
216 * managing the device.
217 */
218struct i2c_client {
219 unsigned short flags; /* div., see below */
220 unsigned short addr; /* chip address - NOTE: 7bit */
221 /* addresses are stored in the */
222 /* _LOWER_ 7 bits */
223 char name[I2C_NAME_SIZE];
224 struct i2c_adapter *adapter; /* the adapter we sit on */
225 struct i2c_driver *driver; /* and our access routines */
226 struct device dev; /* the device structure */
227 int irq; /* irq issued by device */
228 struct list_head detected;
229};
struct i2c_driver代表一個I2C裝置驅動程式,該結構體定義在include/linux/i2c.h檔案中,其內容如下:
124/**
125 * struct i2c_driver - represent an I2C device driver
126 * @class: What kind of i2c device we instantiate (for detect)
127 * @attach_adapter: Callback for bus addition (deprecated)
128 * @probe: Callback for device binding
129 * @remove: Callback for device unbinding
130 * @shutdown: Callback for device shutdown
131 * @suspend: Callback for device suspend
132 * @resume: Callback for device resume
133 * @alert: Alert callback, for example for the SMBus alert protocol
134 * @command: Callback for bus-wide signaling (optional)
135 * @driver: Device driver model driver
136 * @id_table: List of I2C devices supported by this driver
137 * @detect: Callback for device detection
138 * @address_list: The I2C addresses to probe (for detect)
139 * @clients: List of detected clients we created (for i2c-core use only)
140 *
141 * The driver.owner field should be set to the module owner of this driver.
142 * The driver.name field should be set to the name of this driver.
143 *
144 * For automatic device detection, both @detect and @address_list must
145 * be defined. @class should also be set, otherwise only devices forced
146 * with module parameters will be created. The detect function must
147 * fill at least the name field of the i2c_board_info structure it is
148 * handed upon successful detection, and possibly also the flags field.
149 *
150 * If @detect is missing, the driver will still work fine for enumerated
151 * devices. Detected devices simply won't be supported. This is expected
152 * for the many I2C/SMBus devices which can't be detected reliably, and
153 * the ones which can always be enumerated in practice.
154 *
155 * The i2c_client structure which is handed to the @detect callback is
156 * not a real i2c_client. It is initialized just enough so that you can
157 * call i2c_smbus_read_byte_data and friends on it. Don't do anything
158 * else with it. In particular, calling dev_dbg and friends on it is
159 * not allowed.
160 */
161struct i2c_driver {
162 unsigned int class;
163
164 /* Notifies the driver that a new bus has appeared. You should avoid
165 * using this, it will be removed in a near future.
166 */
167 int (*attach_adapter)(struct i2c_adapter *) __deprecated;
168
169 /* Standard driver model interfaces */
170 int (*probe)(struct i2c_client *, const struct i2c_device_id *);
171 int (*remove)(struct i2c_client *);
172
173 /* driver model interfaces that don't relate to enumeration */
174 void (*shutdown)(struct i2c_client *);
175 int (*suspend)(struct i2c_client *, pm_message_t mesg);
176 int (*resume)(struct i2c_client *);
177
178 /* Alert callback, for example for the SMBus alert protocol.
179 * The format and meaning of the data value depends on the protocol.
180 * For the SMBus alert protocol, there is a single bit of data passed
181 * as the alert response's low bit ("event flag").
182 */
183 void (*alert)(struct i2c_client *, unsigned int data);
184
185 /* a ioctl like command that can be used to perform specific functions
186 * with the device.
187 */
188 int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);
189
190 struct device_driver driver;
191 const struct i2c_device_id *id_table;
192
193 /* Device detection callback for automatic device creation */
194 int (*detect)(struct i2c_client *, struct i2c_board_info *);
195 const unsigned short *address_list;
196 struct list_head clients;
197};
二、i2c_adapter的註冊
i2c_add_adapter和i2c_add_numbered_adapter函式都可以註冊I2C adapter,這兩個函式的區別是,i2c_add_adapter動態分配一個bus number,而i2c_add_numbered_adapter使用i2c_adapter.nr指定的bus number。
下面是i2c_add_adapter函式的定義,它定義在drivers/i2c/i2c-core.c檔案中,其內容如下:
1099/**
1100 * i2c_add_adapter - declare i2c adapter, use dynamic bus number
1101 * @adapter: the adapter to add
1102 * Context: can sleep
1103 *
1104 * This routine is used to declare an I2C adapter when its bus number
1105 * doesn't matter or when its bus number is specified by an dt alias.
1106 * Examples of bases when the bus number doesn't matter: I2C adapters
1107 * dynamically added by USB links or PCI plugin cards.
1108 *
1109 * When this returns zero, a new bus number was allocated and stored
1110 * in adap->nr, and the specified adapter became available for clients.
1111 * Otherwise, a negative errno value is returned.
1112 */
1113int i2c_add_adapter(struct i2c_adapter *adapter)
1114{
1115 struct device *dev = &adapter->dev;
1116 int id;
1117
1118 if (dev->of_node) {
1119 id = of_alias_get_id(dev->of_node, "i2c");
1120 if (id >= 0) {
1121 adapter->nr = id;
1122 return __i2c_add_numbered_adapter(adapter);
1123 }
1124 }
1125
1126 mutex_lock(&core_lock);
1127 id = idr_alloc(&i2c_adapter_idr, adapter,
1128 __i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
1129 mutex_unlock(&core_lock);
1130 if (id < 0)
1131 return id;
1132
1133 adapter->nr = id;
1134
1135 return i2c_register_adapter(adapter);
1136}
1118-1124行,跳過。
1127-1128行,呼叫idr_alloc動態分配一個idr entry,並用返回的id作為bus number。
1135行,呼叫i2c_register_adapter函式。這個函式我們後面再分析。
下面是i2c_add_numbered_adapter函式的定義,它同樣定義在drivers/i2c/i2c-core.c檔案中,其內容如下:
1139/**
1140 * i2c_add_numbered_adapter - declare i2c adapter, use static bus number
1141 * @adap: the adapter to register (with adap->nr initialized)
1142 * Context: can sleep
1143 *
1144 * This routine is used to declare an I2C adapter when its bus number
1145 * matters. For example, use it for I2C adapters from system-on-chip CPUs,
1146 * or otherwise built in to the system's mainboard, and where i2c_board_info
1147 * is used to properly configure I2C devices.
1148 *
1149 * If the requested bus number is set to -1, then this function will behave
1150 * identically to i2c_add_adapter, and will dynamically assign a bus number.
1151 *
1152 * If no devices have pre-been declared for this bus, then be sure to
1153 * register the adapter before any dynamically allocated ones. Otherwise
1154 * the required bus ID may not be available.
1155 *
1156 * When this returns zero, the specified adapter became available for
1157 * clients using the bus number provided in adap->nr. Also, the table
1158 * of I2C devices pre-declared using i2c_register_board_info() is scanned,
1159 * and the appropriate driver model device nodes are created. Otherwise, a
1160 * negative errno value is returned.
1161 */
1162int i2c_add_numbered_adapter(struct i2c_adapter *adap)
1163{
1164 if (adap->nr == -1) /* -1 means dynamically assign bus id */
1165 return i2c_add_adapter(adap);
1166
1167 return __i2c_add_numbered_adapter(adap);
1168}
可以看到如果adap->nr的值為-1,則呼叫i2c_add_adapter動態分配一個bus number並註冊。否則,呼叫__i2c_add_numbered_adapter函式,該函式定義在drivers/i2c/i2c-core.c檔案中,其內容如下:
1078/**
1079 * __i2c_add_numbered_adapter - i2c_add_numbered_adapter where nr is never -1
1080 * @adap: the adapter to register (with adap->nr initialized)
1081 * Context: can sleep
1082 *
1083 * See i2c_add_numbered_adapter() for details.
1084 */
1085static int __i2c_add_numbered_adapter(struct i2c_adapter *adap)
1086{
1087 int id;
1088
1089 mutex_lock(&core_lock);
1090 id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1,
1091 GFP_KERNEL);
1092 mutex_unlock(&core_lock);
1093 if (id < 0)
1094 return id == -ENOSPC ? -EBUSY : id;
1095
1096 return i2c_register_adapter(adap);
1097}
1090行,呼叫idr_alloc函式用指定的daap->nr作為bus number分配一個idr entry。
1096行,呼叫i2c_register_adapter函式。
所以,不論是用i2c_add_adapter還是用i2c_add_numbered_adapter函式註冊i2c_adapter,最終都會呼叫i2c_register_adapter函式完成註冊。
i2c_register_adapter函式定義在drivers/i2c/i2c-core.c檔案中,其內容如下:
980static int i2c_register_adapter(struct i2c_adapter *adap)
981{
982 int res = 0;
983
984 /* Can't register until after driver model init */
985 if (unlikely(WARN_ON(!i2c_bus_type.p))) {
986 res = -EAGAIN;
987 goto out_list;
988 }
989
990 /* Sanity checks */
991 if (unlikely(adap->name[0] == '\0')) {
992 pr_err("i2c-core: Attempt to register an adapter with "
993 "no name!\n");
994 return -EINVAL;
995 }
996 if (unlikely(!adap->algo)) {
997 pr_err("i2c-core: Attempt to register adapter '%s' with "
998 "no algo!\n", adap->name);
999 return -EINVAL;
1000 }
1001
1002 rt_mutex_init(&adap->bus_lock);
1003 mutex_init(&adap->userspace_clients_lock);
1004 INIT_LIST_HEAD(&adap->userspace_clients);
1005
1006 /* Set default timeout to 1 second if not already set */
1007 if (adap->timeout == 0)
1008 adap->timeout = HZ;
1009
1010 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
1011 adap->dev.bus = &i2c_bus_type;
1012 adap->dev.type = &i2c_adapter_type;
1013 res = device_register(&adap->dev);
1014 if (res)
1015 goto out_list;
1016
1017 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
1018
1019#ifdef CONFIG_I2C_COMPAT
1020 res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
1021 adap->dev.parent);
1022 if (res)
1023 dev_warn(&adap->dev,
1024 "Failed to create compatibility class link\n");
1025#endif
1026
1027 /* bus recovery specific initialization */
1028 if (adap->bus_recovery_info) {
1029 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
1030
1031 if (!bri->recover_bus) {
1032 dev_err(&adap->dev, "No recover_bus() found, not using recovery\n");
1033 adap->bus_recovery_info = NULL;
1034 goto exit_recovery;
1035 }
1036
1037 /* Generic GPIO recovery */
1038 if (bri->recover_bus == i2c_generic_gpio_recovery) {
1039 if (!gpio_is_valid(bri->scl_gpio)) {
1040 dev_err(&adap->dev, "Invalid SCL gpio, not using recovery\n");
1041 adap->bus_recovery_info = NULL;
1042 goto exit_recovery;
1043 }
1044
1045 if (gpio_is_valid(bri->sda_gpio))
1046 bri->get_sda = get_sda_gpio_value;
1047 else
1048 bri->get_sda = NULL;
1049
1050 bri->get_scl = get_scl_gpio_value;
1051 bri->set_scl = set_scl_gpio_value;
1052 } else if (!bri->set_scl || !bri->get_scl) {
1053 /* Generic SCL recovery */
1054 dev_err(&adap->dev, "No {get|set}_gpio() found, not using recovery\n");
1055 adap->bus_recovery_info = NULL;
1056 }
1057 }
1058
1059exit_recovery:
1060 /* create pre-declared device nodes */
1061 if (adap->nr < __i2c_first_dynamic_bus_num)
1062 i2c_scan_static_board_info(adap);
1063
1064 /* Notify drivers */
1065 mutex_lock(&core_lock);
1066 bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
1067 mutex_unlock(&core_lock);
1068
1069 return 0;
1070
1071out_list:
1072 mutex_lock(&core_lock);
1073 idr_remove(&i2c_adapter_idr, adap->nr);
1074 mutex_unlock(&core_lock);
1075 return res;
1076}
984-1013行,完成基本的檢查和初始化工作後,註冊i2c_adapter.dev。
1027-1059行,如果有必要,為bus recovery作一些準備工作。
1060-1062行,如果有預先宣告的i2c裝置,則註冊對應的i2c_client。
先看1061行,判斷adap->nr是否小於__i2c_first_dynamic_bus_num,只有是使用i2c_add_numbered_adapter註冊i2c_adapter時,該判斷才會成立。用i2c_add_adapter函式註冊i2c_adapter時,動態分配的bus number一定是大於或等於__i2c_first_dynamic_bus_num的。
如果1061行的判斷成立,說明是使用預先定義的bus number,因此,就可能會有預置的I2C裝置資訊。所以1062行,呼叫i2c_scan_static_board_info函式,遍歷預置I2C裝置資訊列表,建立對應的i2c_client。
i2c_scan_static_board_info函式定義在drivers/i2c/i2c-core.c檔案中,其內容如下:
941static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
942{
943 struct i2c_devinfo *devinfo;
944
945 down_read(&__i2c_board_lock);
946 list_for_each_entry(devinfo, &__i2c_board_list, list) {
947 if (devinfo->busnum == adapter->nr
948 && !i2c_new_device(adapter,
949 &devinfo->board_info))
950 dev_err(&adapter->dev,
951 "Can't create device at 0x%02x\n",
952 devinfo->board_info.addr);
953 }
954 up_read(&__i2c_board_lock);
955}
該函式遍歷__i2c_board_list連結串列,如果某個節點的devinfo->busnum等於adapter->nr,即該I2C裝置屬於這個註冊的I2C adapter,則呼叫i2c_new_device建立並註冊該I2C裝置對應的i2c_client。
i2c_new_device定義在drivers/i2c/i2c-core.c檔案中,其內容如下:
612/**
613 * i2c_new_device - instantiate an i2c device
614 * @adap: the adapter managing the device
615 * @info: describes one I2C device; bus_num is ignored
616 * Context: can sleep
617 *
618 * Create an i2c device. Binding is handled through driver model
619 * probe()/remove() methods. A driver may be bound to this device when we
620 * return from this function, or any later moment (e.g. maybe hotplugging will
621 * load the driver module). This call is not appropriate for use by mainboard
622 * initialization logic, which usually runs during an arch_initcall() long
623 * before any i2c_adapter could exist.
624 *
625 * This returns the new i2c client, which may be saved for later use with
626 * i2c_unregister_device(); or NULL to indicate an error.
627 */
628struct i2c_client *
629i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
630{
631 struct i2c_client *client;
632 int status;
633
634 client = kzalloc(sizeof *client, GFP_KERNEL);
635 if (!client)
636 return NULL;
637
638 client->adapter = adap;
639
640 client->dev.platform_data = info->platform_data;
641
642 if (info->archdata)
643 client->dev.archdata = *info->archdata;
644
645 client->flags = info->flags;
646 client->addr = info->addr;
647 client->irq = info->irq;
648
649 strlcpy(client->name, info->type, sizeof(client->name));
650
651 /* Check for address validity */
652 status = i2c_check_client_addr_validity(client);
653 if (status) {
654 dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
655 client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
656 goto out_err_silent;
657 }
658
659 /* Check for address business */
660 status = i2c_check_addr_busy(adap, client->addr);
661 if (status)
662 goto out_err;
663
664 client->dev.parent = &client->adapter->dev;
665 client->dev.bus = &i2c_bus_type;
666 client->dev.type = &i2c_client_type;
667 client->dev.of_node = info->of_node;
668 ACPI_HANDLE_SET(&client->dev, info->acpi_node.handle);
669
670 /* For 10-bit clients, add an arbitrary offset to avoid collisions */
671 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
672 client->addr | ((client->flags & I2C_CLIENT_TEN)
673 ? 0xa000 : 0));
674 status = device_register(&client->dev);
675 if (status)
676 goto out_err;
677
678 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
679 client->name, dev_name(&client->dev));
680
681 return client;
682
683out_err:
684 dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
685 "(%d)\n", client->name, client->addr, status);
686out_err_silent:
687 kfree(client);
688 return NULL;
689}
這個函式很直接,就是初始化i2c_client的各個成員,並最終註冊client->dev,從而完成對i2c裝置的註冊。
這裡要說明一下,預置的i2c裝置資訊是通過呼叫i2c_register_board_info函式完成的,該函式定義在drivers/i2c/i2c-boardinfo.c檔案中,其內容如下:
42/**
43 * i2c_register_board_info - statically declare I2C devices
44 * @busnum: identifies the bus to which these devices belong
45 * @info: vector of i2c device descriptors
46 * @len: how many descriptors in the vector; may be zero to reserve
47 * the specified bus number.
48 *
49 * Systems using the Linux I2C driver stack can declare tables of board info
50 * while they initialize. This should be done in board-specific init code
51 * near arch_initcall() time, or equivalent, before any I2C adapter driver is
52 * registered. For example, mainboard init code could define several devices,
53 * as could the init code for each daughtercard in a board stack.
54 *
55 * The I2C devices will be created later, after the adapter for the relevant
56 * bus has been registered. After that moment, standard driver model tools
57 * are used to bind "new style" I2C drivers to the devices. The bus number
58 * for any device declared using this routine is not available for dynamic
59 * allocation.
60 *
61 * The board info passed can safely be __initdata, but be careful of embedded
62 * pointers (for platform_data, functions, etc) since that won't be copied.
63 */
64int __init
65i2c_register_board_info(int busnum,
66 struct i2c_board_info const *info, unsigned len)
67{
68 int status;
69
70 down_write(&__i2c_board_lock);
71
72 /* dynamic bus numbers will be assigned after the last static one */
73 if (busnum >= __i2c_first_dynamic_bus_num)
74 __i2c_first_dynamic_bus_num = busnum + 1;
75
76 for (status = 0; len; len--, info++) {
77 struct i2c_devinfo *devinfo;
78
79 devinfo = kzalloc(sizeof(*devinfo), GFP_KERNEL);
80 if (!devinfo) {
81 pr_debug("i2c-core: can't register boardinfo!\n");
82 status = -ENOMEM;
83 break;
84 }
85
86 devinfo->busnum = busnum;
87 devinfo->board_info = *info;
88 list_add_tail(&devinfo->list, &__i2c_board_list);
89 }
90
91 up_write(&__i2c_board_lock);
92
93 return status;
94}
可以看到,該函式將預置的i2c裝置資訊儲存在__i2c_board_list連結串列中。
回到i2c_register_adapter函式:
1066行,呼叫bus_for_each_drv函式,該函式定義在drivers/base/bus.c檔案中,其內容如下:
417/**
418 * bus_for_each_drv - driver iterator
419 * @bus: bus we're dealing with.
420 * @start: driver to start iterating on.
421 * @data: data to pass to the callback.
422 * @fn: function to call for each driver.
423 *
424 * This is nearly identical to the device iterator above.
425 * We iterate over each driver that belongs to @bus, and call
426 * @fn for each. If @fn returns anything but 0, we break out
427 * and return it. If @start is not NULL, we use it as the head
428 * of the list.
429 *
430 * NOTE: we don't return the driver that returns a non-zero
431 * value, nor do we leave the reference count incremented for that
432 * driver. If the caller needs to know that info, it must set it
433 * in the callback. It must also be sure to increment the refcount
434 * so it doesn't disappear before returning to the caller.
435 */
436int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
437 void *data, int (*fn)(struct device_driver *, void *))
438{
439 struct klist_iter i;
440 struct device_driver *drv;
441 int error = 0;
442
443 if (!bus)
444 return -EINVAL;
445
446 klist_iter_init_node(&bus->p->klist_drivers, &i,
447 start ? &start->p->knode_bus : NULL);
448 while ((drv = next_driver(&i)) && !error)
449 error = fn(drv, data);
450 klist_iter_exit(&i);
451 return error;
452}
這個函式我們在《Linux裝置模型分析之device(基於3.10.1核心)》一文中已經分析過了。448-449行,這個while迴圈依次遍歷bus->p->klist_drivers中的所有device_driver,對於每個device_driver,呼叫fn(drv,data)函式。這裡,傳遞過來的fn引數是__process_new_adapter,data引數是adap。這個迴圈是一個關鍵點,註冊一個新的i2c_adapter後,要為該i2c_adapter上的i2c裝置匹配驅動程式,這個匹配過程就是通過這個迴圈呼叫__process_new_adapter函式完成的。
__process_new_adapter函式定義在drivers/i2c/i2c-core.c檔案中,其內容如下:
975static int __process_new_adapter(struct device_driver *d, void *data)
976{
977 return i2c_do_add_adapter(to_i2c_driver(d), data);
978}
注意i2c_do_add_adapter函式的第一個引數,從device_driver轉換為i2c_driver。
i2c_do_add_adapter函式定義在drivers/i2c/i2c-core.c檔案中,其內容如下:
957static int i2c_do_add_adapter(struct i2c_driver *driver,
958 struct i2c_adapter *adap)
959{
960 /* Detect supported devices on that bus, and instantiate them */
961 i2c_detect(adap, driver);
962
963 /* Let legacy drivers scan this bus for matching devices */
964 if (driver->attach_adapter) {
965 dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
966 driver->driver.name);
967 dev_warn(&adap->dev, "Please use another way to instantiate "
968 "your i2c_client\n");
969 /* We ignore the return code; if it fails, too bad */
970 driver->attach_adapter(adap);
971 }
972 return 0;
973}
961行,呼叫i2c_detect函式,探測並初始化該i2c總線上的i2c裝置。該函式定義在drivers/i2c/i2c-core.c檔案中,其內容如下:
1730static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
1731{
1732 const unsigned short *address_list;
1733 struct i2c_client *temp_client;
1734 int i, err = 0;
1735 int adap_id = i2c_adapter_id(adapter);
1736
1737 address_list = driver->address_list;
1738 if (!driver->detect || !address_list)
1739 return 0;
1740
1741 /* Stop here if the classes do not match */
1742 if (!(adapter->class & driver->class))
1743 return 0;
1744
1745 /* Set up a temporary client to help detect callback */
1746 temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
1747 if (!temp_client)
1748 return -ENOMEM;
1749 temp_client->adapter = adapter;
1750
1751 for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
1752 dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
1753 "addr 0x%02x\n", adap_id, address_list[i]);
1754 temp_client->addr = address_list[i];
1755 err = i2c_detect_address(temp_client, driver);
1756 if (unlikely(err))
1757 break;
1758 }
1759
1760 kfree(temp_client);
1761 return err;
1762}
1755行,呼叫i2c_detect_address,探測指定的地址上的I2C裝置是否存在,如果存在,註冊該i2c裝置。i2c_detect_address函式定義在drivers/i2c/i2c-core.c檔案中,其內容如下:
1675static int i2c_detect_address(struct i2c_client *temp_client,
1676 struct i2c_driver *driver)
1677{
1678 struct i2c_board_info info;
1679 struct i2c_adapter *adapter = temp_client->adapter;
1680 int addr = temp_client->addr;
1681 int err;
1682
1683 /* Make sure the address is valid */
1684 err = i2c_check_addr_validity(addr);
1685 if (err) {
1686 dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
1687 addr);
1688 return err;
1689 }
1690
1691 /* Skip if already in use */
1692 if (i2c_check_addr_busy(adapter, addr))
1693 return 0;
1694
1695 /* Make sure there is something at this address */
1696 if (!i2c_default_probe(adapter, addr))
1697 return 0;
1698
1699 /* Finally call the custom detection function */
1700 memset(&info, 0, sizeof(struct i2c_board_info));
1701 info.addr = addr;
1702 err = driver->detect(temp_client, &info);
1703 if (err) {
1704 /* -ENODEV is returned if the detection fails. We catch it
1705 here as this isn't an error. */
1706 return err == -ENODEV ? 0 : err;
1707 }
1708
1709 /* Consistency check */
1710 if (info.type[0] == '\0') {
1711 dev_err(&adapter->dev, "%s detection function provided "
1712 "no name for 0x%x\n", driver->driver.name,
1713 addr);
1714 } else {
1715 struct i2c_client *client;
1716
1717 /* Detection succeeded, instantiate the device */
1718 dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
1719 info.type, info.addr);
1720 client = i2c_new_device(adapter, &info);
1721 if (client)
1722 list_add_tail(&client->detected, &driver->clients);
1723 else
1724 dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
1725 info.type, info.addr);
1726 }
1727 return 0;
1728}
1702行,呼叫driver->detect。
1720行,如果探測到i2c裝置確實存在,呼叫i2c_new_device函式初始化對應的i2c_client結構體並註冊。i2c_new_device函式我們在前面已經分析過。
至此,i2c_adapter的註冊過程我們就清楚了。
三、i2c_driver的註冊
i2c_driver的註冊是通過呼叫i2c_add_driver巨集完成的,該巨集定義在include/linux/i2c.h檔案中:
497/* use a define to avoid include chaining to get THIS_MODULE */
498#define i2c_add_driver(driver) \
499 i2c_register_driver(THIS_MODULE, driver)
i2c_register_driver函式定義在drivers/i2c/i2c-core.c檔案中,其內容如下:
1307/*
1308 * An i2c_driver is used with one or more i2c_client (device) nodes to access
1309 * i2c slave chips, on a bus instance associated with some i2c_adapter.
1310 */
1311
1312int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
1313{
1314 int res;
1315
1316 /* Can't register until after driver model init */
1317 if (unlikely(WARN_ON(!i2c_bus_type.p)))
1318 return -EAGAIN;
1319
1320 /* add the driver to the list of i2c drivers in the driver core */
1321 driver->driver.owner = owner;
1322 driver->driver.bus = &i2c_bus_type;
1323
1324 /* When registration returns, the driver core
1325 * will have called probe() for all matching-but-unbound devices.
1326 */
1327 res = driver_register(&driver->driver);
1328 if (res)
1329 return res;
1330
1331 /* Drivers should switch to dev_pm_ops instead. */
1332 if (driver->suspend)
1333 pr_warn("i2c-core: driver [%s] using legacy suspend method\n",
1334 driver->driver.name);
1335 if (driver->resume)
1336 pr_warn("i2c-core: driver [%s] using legacy resume method\n",
1337 driver->driver.name);
1338
1339 pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
1340
1341 INIT_LIST_HEAD(&driver->clients);
1342 /* Walk the adapters that are already present */
1343 i2c_for_each_dev(driver, __process_new_driver);
1344
1345 return 0;
1346}
1327行,呼叫driver_register註冊i2c_driver.driver。參考《 》對Linux裝置模型的分析,在driver_register執行過程中,如果I2C總線上找到了與該驅動匹配的I2C裝置,則i2c_driver.probe函式會被呼叫執行。
1343行,呼叫i2c_for_each_dev遍歷所有已存在的i2c_adapter。該函式定義在drivers/i2c/i2c-core.c檔案中,其內容如下:
1288int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))
1289{
1290 int res;
1291
1292 mutex_lock(&core_lock);
1293 res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);
1294 mutex_unlock(&core_lock);
1295
1296 return res;
1297}
1293行,呼叫bus_for_each_dev,這個函式定義在drivers/base/bus.c檔案中,其內容如下:
286intbus_for_each_dev(struct bus_type *bus, struct device *start,
287 void *data, int (*fn)(struct device *, void *))
288{
289 struct klist_iter i;
290 struct device *dev;
291 int error = 0;
292
293 if (!bus || !bus->p)
294 return -EINVAL;
295
296 klist_iter_init_node(&bus->p->klist_devices, &i,
297 (start ?&start->p->knode_bus : NULL));
298 while ((dev = next_device(&i)) && !error)
299 error = fn(dev, data);
300 klist_iter_exit(&i);
301 return error;
302}
我們在《 Linux裝置模型分析之device_driver(基於3.10.1核心)》一文中已經分析過這個函式。這裡,傳遞過來的data引數是要註冊的i2c_driver,fn引數是__process_new_driver函式,所以我們來看__process_new_driver函式,該函式定義在drivers/i2c/i2c-core.c檔案中,其內容如下:
1300static int __process_new_driver(structdevice *dev, void *data)
1301{
1302 if (dev->type != &i2c_adapter_type)
1303 return 0;
1304 return i2c_do_add_adapter(data, to_i2c_adapter(dev));
1305}
i2c_do_add_adapter函式定義在drivers/i2c/i2c-core.c檔案中,其內容如下:
957static int i2c_do_add_adapter(structi2c_driver *driver,
958 struct i2c_adapter *adap)
959{
960 /* Detect supported devices on that bus, and instantiate them */
961 i2c_detect(adap, driver);
962
963 /* Let legacy drivers scan this bus for matching devices */
964 if (driver->attach_adapter) {
965 dev_warn(&adap->dev, "%s: attach_adapter method isdeprecated\n",
966 driver->driver.name);
967 dev_warn(&adap->dev, "Please use another way to instantiate"
968 "your i2c_client\n");
969 /* We ignore the return code; if it fails, too bad */
970 driver->attach_adapter(adap);
971 }
972 return 0;
973}
這個函式我們在分析i2c_adapter的註冊過程時已經分析過了,它主要完成i2c_driver與i2c_adapter上的i2c裝置的匹配工作,如果匹配成功,初始化並註冊對應的i2c_client。
至此,i2c_driver的註冊過程我們就清楚了。
四、i2c_bus_type分析
i2c_init 函式完成Linux i2c框架的初始化工作,該函式定義在drivers/i2c/i2c-core.c檔案中,其內容如下:
1429static int __init i2c_init(void)
1430{
1431 int retval;
1432
1433 retval = bus_register(&i2c_bus_type);
1434 if (retval)
1435 return retval;
1436#ifdef CONFIG_I2C_COMPAT
1437 i2c_adapter_compat_class =class_compat_register("i2c-adapter");
1438 if (!i2c_adapter_compat_class) {
1439 retval = -ENOMEM;
1440 goto bus_err;
1441 }
1442#endif
1443 retval = i2c_add_driver(&dummy_driver);
1444 if (retval)
1445 goto class_err;
1446 return 0;
1447
1448class_err:
1449#ifdef CONFIG_I2C_COMPAT
1450 class_compat_unregister(i2c_adapter_compat_class);
1451bus_err:
1452#endif
1453 bus_unregister(&i2c_bus_type);
1454 return retval;
1455}
1433行,呼叫bus_register註冊了i2c_bus_type。i2c_bus_tpye定義在drivers/i2c/i2c-core.c檔案中,其內容如下:
442structbus_type i2c_bus_type = {
443 .name = "i2c",
444 .match = i2c_device_match,
445 .probe = i2c_device_probe,
446 .remove = i2c_device_remove,
447 .shutdown = i2c_device_shutdown,
448 .pm = &i2c_device_pm_ops,
449};
其型別是bus_type,所以它代表i2c匯流排。我們來關注一下i2c_device_match和i2c_device_probe函式。
i2c_device_match函式定義在drivers/i2c/i2c-core.c檔案中,其內容如下:
72static int i2c_device_match(struct device *dev, struct device_driver*drv)
73{
74 struct i2c_client *client = i2c_verify_client(dev);
75 struct i2c_driver *driver;
76
77 if (!client)
78 return 0;
79
80 /* Attempt an OF style match*/
81 if(of_driver_match_device(dev, drv))
82 return 1;
83
84 /* Then ACPI style match */
85 if(acpi_driver_match_device(dev, drv))
86 return 1;
87
88 driver = to_i2c_driver(drv);
89 /* match on an id table ifthere is one */
90 if (driver->id_table)
91 returni2c_match_id(driver->id_table, client) != NULL;
92
93 return 0;
94}
88行,將device_driver轉換為i2c_driver。
90-91行,如果driver->id_table不為空,則呼叫i2c_match_id函式,該函式定義在drivers/i2c/i2c-core.c檔案中,其內容如下:
61static const struct i2c_device_id *i2c_match_id(const structi2c_device_id *id,
62 const struct i2c_client *client)
63{
64 while (id->name[0]) {
65 if(strcmp(client->name, id->name) == 0)
66 return id;
67 id++;
68 }
69 return NULL;
70}
可以看到,如果client->name和id->name相同,則匹配成功,返回id。如果返回NULL,則表示匹配失敗。
分析到這裡,我們要回顧一下分析Linux裝置模型時涉及到的一個函式driver_match_device,該函式定義在drivers/base/base.h檔案中,其內容如下:
116static inline intdriver_match_device(struct device_driver *drv,
117 struct device *dev)
118{
119 return drv->bus->match ? drv->bus->match(dev, drv) : 1;
120}
當進行device和device_driver的匹配時,會呼叫這個函式,該函式返回值為0,表示match失敗。只有match成功時,才會進一步進行probe。
可以看到,如果drv->bus->match存在,會呼叫drv->bus->match(dev,drv)。所以,當i2c裝置(i2c_client)和i2c驅動(i2c_driver)進行匹配操作時,就會呼叫i2c_device_match函式。
在分析i2c_device_probe函式之前,我們要回顧一下分析Linux裝置模型時涉及到的一個函式driver_probe_device,device_driver探測支援的device時,會呼叫到這個函式,它又會進一步呼叫really_probe函式,really_probe函式定義在drivers/base/dd.c檔案中,其內容如下:
265static int really_probe(struct device*dev, struct device_driver *drv)
266{
267 int ret = 0;
268
269 atomic_inc(&probe_count);
270 pr_debug("bus: '%s': %s: probing driver %s with device %s\n",
271 drv->bus->name, __func__, drv->name, dev_name(dev));
272 WARN_ON(!list_empty(&dev->devres_head));
273
274 dev->driver = drv;
275
276 /* If using pinctrl, bind pins now before probing */
277 ret = pinctrl_bind_pins(dev);
278 if (ret)
279 goto probe_failed;
280
281 if (driver_sysfs_add(dev)) {
282 printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n",
283 __func__, dev_name(dev));
284 goto probe_failed;
285 }
286
287 if (dev->bus->probe) {
288 ret = dev->bus->probe(dev);
289 if (ret)
290 goto probe_failed;
291 } else if (drv->probe) {
292 ret = drv->probe(dev);
293 if (ret)
294 goto probe_failed;
295 }
296
297 driver_bound(dev);
298 ret = 1;
299 pr_debug("bus: '%s': %s: bound device %s to driver %s\n",
300 drv->bus->name, __func__, dev_name(dev), drv->name);
301 goto done;
302
303probe_failed:
304 devres_release_all(dev);
305 driver_sysfs_remove(dev);
306 dev->driver = NULL;
307 dev_set_drvdata(dev, NULL);
308
309 if (ret == -EPROBE_DEFER) {
310 /* Driver requested deferred probing */
311 dev_info(dev, "Driver %s requests probe deferral\n",drv->name);
312 driver_deferred_probe_add(dev);
313 } else if (ret != -ENODEV && ret != -ENXIO) {
314 /* driver matched but the probe failed */
315 printk(KERN_WARNING
316 "%s: probe of %s failedwith error %d\n",
317 drv->name, dev_name(dev),ret);
318 } else {
319 pr_debug("%s: probe of %s rejects match %d\n",
320 drv->name, dev_name(dev),ret);
321 }
322 /*
323 * Ignore errors returned by ->probe so that the next driver can try
324 * its luck.
325 */
326 ret = 0;
327done:
328 atomic_dec(&probe_count);
329 wake_up(&probe_waitqueue);
330 return ret;
331}
這個函式我們現在需要關注的是287-295行,如果dev->bus->probe存在,則呼叫dev->bus->probe(dev),如果dev->bus->probe不存在,並且drv->probe存在,才會呼叫drv->probe(dev)。所以,對於i2c裝置和i2c驅動,探測裝置時會優先呼叫i2c_bus_type.probe函式。而i2c_bus_type.probe即i2c_device_probe會轉而呼叫i2c_driver.probe函式。
現在我們可以來看i2c_device_probe函數了,它定義在drivers/i2c/i2c-core.c檔案中,其內容如下:
233staticint i2c_device_probe(struct device *dev)
234{
235 struct i2c_client *client =i2c_verify_client(dev);
236 struct i2c_driver *driver;
237 int status;
238
239 if (!client)
240 return 0;
241
242 driver = to_i2c_driver(dev->driver);
243 if (!driver->probe || !driver->id_table)
244 return -ENODEV;
245 client->driver = driver;
246 if (!device_can_wakeup(&client->dev))
247 device_init_wakeup(&client->dev,
248 client->flags &I2C_CLIENT_WAKE);
249 dev_dbg(dev, "probe\n");
250
251 status = driver->probe(client, i2c_match_id(driver->id_table,client));
252 if (status) {
253 client->driver = NULL;
254 i2c_set_clientdata(client, NULL);
255 }
256 return status;
257}
242行,取得i2c_driver。
243行,如果i2c_driver沒有定義probe或者i2c_driver沒有定義id_table,則直接退出。所以我們在寫i2c驅動時,必須定義i2c_driver.probe和i2c_driver.id_table。
251行,呼叫i2c_driver.probe。這時,我們的i2c驅動程式定義的probe函式就會執行。