Merge branch 'bzip2-lzma-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[linux-2.6] / Documentation / i2c / instantiating-devices
1 How to instantiate I2C devices
2 ==============================
3
4 Unlike PCI or USB devices, I2C devices are not enumerated at the hardware
5 level. Instead, the software must know which devices are connected on each
6 I2C bus segment, and what address these devices are using. For this
7 reason, the kernel code must instantiate I2C devices explicitly. There are
8 several ways to achieve this, depending on the context and requirements.
9
10
11 Method 1: Declare the I2C devices by bus number
12 -----------------------------------------------
13
14 This method is appropriate when the I2C bus is a system bus as is the case
15 for many embedded systems. On such systems, each I2C bus has a number
16 which is known in advance. It is thus possible to pre-declare the I2C
17 devices which live on this bus. This is done with an array of struct
18 i2c_board_info which is registered by calling i2c_register_board_info().
19
20 Example (from omap2 h4):
21
22 static 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
37 static 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
45 The above code declares 3 devices on I2C bus 1, including their respective
46 addresses and custom data needed by their drivers. When the I2C bus in
47 question is registered, the I2C devices will be instantiated automatically
48 by i2c-core.
49
50 The devices will be automatically unbound and destroyed when the I2C bus
51 they sit on goes away (if ever.)
52
53
54 Method 2: Instantiate the devices explicitly
55 --------------------------------------------
56
57 This method is appropriate when a larger device uses an I2C bus for
58 internal communication. A typical case is TV adapters. These can have a
59 tuner, a video decoder, an audio decoder, etc. usually connected to the
60 main chip by the means of an I2C bus. You won't know the number of the I2C
61 bus in advance, so the method 1 described above can't be used. Instead,
62 you can instantiate your I2C devices explicitly. This is done by filling
63 a struct i2c_board_info and calling i2c_new_device().
64
65 Example (from the sfe4001 network driver):
66
67 static struct i2c_board_info sfe4001_hwmon_info = {
68         I2C_BOARD_INFO("max6647", 0x4e),
69 };
70
71 int 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
80 The above code instantiates 1 I2C device on the I2C bus which is on the
81 network adapter in question.
82
83 A variant of this is when you don't know for sure if an I2C device is
84 present or not (for example for an optional feature which is not present
85 on cheap variants of a board but you have no way to tell them apart), or
86 it may have different addresses from one board to the next (manufacturer
87 changing its design without notice). In this case, you can call
88 i2c_new_probed_device() instead of i2c_new_device().
89
90 Example (from the pnx4008 OHCI driver):
91
92 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, I2C_CLIENT_END };
93
94 static int __devinit usb_hcd_pnx4008_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.name, "isp1301_pnx", I2C_NAME_SIZE);
104         isp1301_i2c_client = i2c_new_probed_device(i2c_adap, &i2c_info,
105                                                    normal_i2c);
106         i2c_put_adapter(i2c_adap);
107         (...)
108 }
109
110 The above code instantiates up to 1 I2C device on the I2C bus which is on
111 the OHCI adapter in question. It first tries at address 0x2c, if nothing
112 is found there it tries address 0x2d, and if still nothing is found, it
113 simply gives up.
114
115 The driver which instantiated the I2C device is responsible for destroying
116 it on cleanup. This is done by calling i2c_unregister_device() on the
117 pointer that was earlier returned by i2c_new_device() or
118 i2c_new_probed_device().
119
120
121 Method 3: Probe an I2C bus for certain devices
122 ----------------------------------------------
123
124 Sometimes you do not have enough information about an I2C device, not even
125 to call i2c_new_probed_device(). The typical case is hardware monitoring
126 chips on PC mainboards. There are several dozen models, which can live
127 at 25 different addresses. Given the huge number of mainboards out there,
128 it is next to impossible to build an exhaustive list of the hardware
129 monitoring chips being used. Fortunately, most of these chips have
130 manufacturer and device ID registers, so they can be identified by
131 probing.
132
133 In that case, I2C devices are neither declared nor instantiated
134 explicitly. Instead, i2c-core will probe for such devices as soon as their
135 drivers are loaded, and if any is found, an I2C device will be
136 instantiated automatically. In order to prevent any misbehavior of this
137 mechanism, 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
144 Example:
145 See lm90_driver and lm90_detect() in drivers/hwmon/lm90.c
146
147 I2C devices instantiated as a result of such a successful probe will be
148 destroyed automatically when the driver which detected them is removed,
149 or when the underlying I2C bus is itself destroyed, whichever happens
150 first.
151
152 Those of you familiar with the i2c subsystem of 2.4 kernels and early 2.6
153 kernels will find out that this method 3 is essentially similar to what
154 was 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
165 Once again, method 3 should be avoided wherever possible. Explicit device
166 instantiation (methods 1 and 2) is much preferred for it is safer and
167 faster.