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