1How to instantiate I2C devices 2============================== 3 4Unlike PCI or USB devices, I2C devices are not enumerated at the hardware 5level. Instead, the software must know which devices are connected on each 6I2C bus segment, and what address these devices are using. For this 7reason, the kernel code must instantiate I2C devices explicitly. There are 8several ways to achieve this, depending on the context and requirements. 9 10 11Method 1: Declare the I2C devices by bus number 12----------------------------------------------- 13 14This method is appropriate when the I2C bus is a system bus as is the case 15for many embedded systems. On such systems, each I2C bus has a number 16which is known in advance. It is thus possible to pre-declare the I2C 17devices which live on this bus. This is done with an array of struct 18i2c_board_info which is registered by calling i2c_register_board_info(). 19 20Example (from omap2 h4): 21 22static struct i2c_board_info __initdata h4_i2c_board_info[] = { 23 { 24 I2C_BOARD_INFO("isp1301_omap", 0x2d), 25 .irq = OMAP_GPIO_IRQ(125), 26 }, 27 { /* EEPROM on mainboard */ 28 I2C_BOARD_INFO("24c01", 0x52), 29 .platform_data = &m24c01, 30 }, 31 { /* EEPROM on cpu card */ 32 I2C_BOARD_INFO("24c01", 0x57), 33 .platform_data = &m24c01, 34 }, 35}; 36 37static void __init omap_h4_init(void) 38{ 39 (...) 40 i2c_register_board_info(1, h4_i2c_board_info, 41 ARRAY_SIZE(h4_i2c_board_info)); 42 (...) 43} 44 45The above code declares 3 devices on I2C bus 1, including their respective 46addresses and custom data needed by their drivers. When the I2C bus in 47question is registered, the I2C devices will be instantiated automatically 48by i2c-core. 49 50The devices will be automatically unbound and destroyed when the I2C bus 51they sit on goes away (if ever.) 52 53 54Method 2: Instantiate the devices explicitly 55-------------------------------------------- 56 57This method is appropriate when a larger device uses an I2C bus for 58internal communication. A typical case is TV adapters. These can have a 59tuner, a video decoder, an audio decoder, etc. usually connected to the 60main chip by the means of an I2C bus. You won't know the number of the I2C 61bus in advance, so the method 1 described above can't be used. Instead, 62you can instantiate your I2C devices explicitly. This is done by filling 63a struct i2c_board_info and calling i2c_new_device(). 64 65Example (from the sfe4001 network driver): 66 67static struct i2c_board_info sfe4001_hwmon_info = { 68 I2C_BOARD_INFO("max6647", 0x4e), 69}; 70 71int sfe4001_init(struct efx_nic *efx) 72{ 73 (...) 74 efx->board_info.hwmon_client = 75 i2c_new_device(&efx->i2c_adap, &sfe4001_hwmon_info); 76 77 (...) 78} 79 80The above code instantiates 1 I2C device on the I2C bus which is on the 81network adapter in question. 82 83A variant of this is when you don't know for sure if an I2C device is 84present or not (for example for an optional feature which is not present 85on cheap variants of a board but you have no way to tell them apart), or 86it may have different addresses from one board to the next (manufacturer 87changing its design without notice). In this case, you can call 88i2c_new_probed_device() instead of i2c_new_device(). 89 90Example (from the nxp OHCI driver): 91 92static const unsigned short normal_i2c[] = { 0x2c, 0x2d, I2C_CLIENT_END }; 93 94static int __devinit usb_hcd_nxp_probe(struct platform_device *pdev) 95{ 96 (...) 97 struct i2c_adapter *i2c_adap; 98 struct i2c_board_info i2c_info; 99 100 (...) 101 i2c_adap = i2c_get_adapter(2); 102 memset(&i2c_info, 0, sizeof(struct i2c_board_info)); 103 strlcpy(i2c_info.type, "isp1301_nxp", I2C_NAME_SIZE); 104 isp1301_i2c_client = i2c_new_probed_device(i2c_adap, &i2c_info, 105 normal_i2c, NULL); 106 i2c_put_adapter(i2c_adap); 107 (...) 108} 109 110The above code instantiates up to 1 I2C device on the I2C bus which is on 111the OHCI adapter in question. It first tries at address 0x2c, if nothing 112is found there it tries address 0x2d, and if still nothing is found, it 113simply gives up. 114 115The driver which instantiated the I2C device is responsible for destroying 116it on cleanup. This is done by calling i2c_unregister_device() on the 117pointer that was earlier returned by i2c_new_device() or 118i2c_new_probed_device(). 119 120 121Method 3: Probe an I2C bus for certain devices 122---------------------------------------------- 123 124Sometimes you do not have enough information about an I2C device, not even 125to call i2c_new_probed_device(). The typical case is hardware monitoring 126chips on PC mainboards. There are several dozen models, which can live 127at 25 different addresses. Given the huge number of mainboards out there, 128it is next to impossible to build an exhaustive list of the hardware 129monitoring chips being used. Fortunately, most of these chips have 130manufacturer and device ID registers, so they can be identified by 131probing. 132 133In that case, I2C devices are neither declared nor instantiated 134explicitly. Instead, i2c-core will probe for such devices as soon as their 135drivers are loaded, and if any is found, an I2C device will be 136instantiated automatically. In order to prevent any misbehavior of this 137mechanism, the following restrictions apply: 138* The I2C device driver must implement the detect() method, which 139 identifies a supported device by reading from arbitrary registers. 140* Only buses which are likely to have a supported device and agree to be 141 probed, will be probed. For example this avoids probing for hardware 142 monitoring chips on a TV adapter. 143 144Example: 145See lm90_driver and lm90_detect() in drivers/hwmon/lm90.c 146 147I2C devices instantiated as a result of such a successful probe will be 148destroyed automatically when the driver which detected them is removed, 149or when the underlying I2C bus is itself destroyed, whichever happens 150first. 151 152Those of you familiar with the i2c subsystem of 2.4 kernels and early 2.6 153kernels will find out that this method 3 is essentially similar to what 154was done there. Two significant differences are: 155* Probing is only one way to instantiate I2C devices now, while it was the 156 only way back then. Where possible, methods 1 and 2 should be preferred. 157 Method 3 should only be used when there is no other way, as it can have 158 undesirable side effects. 159* I2C buses must now explicitly say which I2C driver classes can probe 160 them (by the means of the class bitfield), while all I2C buses were 161 probed by default back then. The default is an empty class which means 162 that no probing happens. The purpose of the class bitfield is to limit 163 the aforementioned undesirable side effects. 164 165Once again, method 3 should be avoided wherever possible. Explicit device 166instantiation (methods 1 and 2) is much preferred for it is safer and 167faster. 168 169 170Method 4: Instantiate from user-space 171------------------------------------- 172 173In general, the kernel should know which I2C devices are connected and 174what addresses they live at. However, in certain cases, it does not, so a 175sysfs interface was added to let the user provide the information. This 176interface is made of 2 attribute files which are created in every I2C bus 177directory: new_device and delete_device. Both files are write only and you 178must write the right parameters to them in order to properly instantiate, 179respectively delete, an I2C device. 180 181File new_device takes 2 parameters: the name of the I2C device (a string) 182and the address of the I2C device (a number, typically expressed in 183hexadecimal starting with 0x, but can also be expressed in decimal.) 184 185File delete_device takes a single parameter: the address of the I2C 186device. As no two devices can live at the same address on a given I2C 187segment, the address is sufficient to uniquely identify the device to be 188deleted. 189 190Example: 191# echo eeprom 0x50 > /sys/bus/i2c/devices/i2c-3/new_device 192 193While this interface should only be used when in-kernel device declaration 194can't be done, there is a variety of cases where it can be helpful: 195* The I2C driver usually detects devices (method 3 above) but the bus 196 segment your device lives on doesn't have the proper class bit set and 197 thus detection doesn't trigger. 198* The I2C driver usually detects devices, but your device lives at an 199 unexpected address. 200* The I2C driver usually detects devices, but your device is not detected, 201 either because the detection routine is too strict, or because your 202 device is not officially supported yet but you know it is compatible. 203* You are developing a driver on a test board, where you soldered the I2C 204 device yourself. 205 206This interface is a replacement for the force_* module parameters some I2C 207drivers implement. Being implemented in i2c-core rather than in each 208device driver individually, it is much more efficient, and also has the 209advantage that you do not have to reload the driver to change a setting. 210You can also instantiate the device before the driver is loaded or even 211available, and you don't need to know what driver the device needs. 212