i2c: Document the different ways to instantiate i2c devices

On popular demand, here comes some documentation about how to instantiate i2c devices in the new (standard) i2c device driver binding model. I have also clarified how the class bitfield lets driver authors control which buses are probed in the auto-detect case, and warned more loudly against the abuse of this method. Signed-off-by: Jean Delvare <khali@linux-fr.org> Acked-by: Michael Lawnick <nospam_lawnick@gmx.de> Acked-by: Hans Verkuil <hverkuil@xs4all.nl>

i2c: Document the different ways to instantiate i2c devices
On popular demand, here comes some documentation about how to instantiate i2c devices in the new (standard) i2c device driver binding model. I have also clarified how the class bitfield lets driver authors control which buses are probed in the auto-detect case, and warned more loudly against the abuse of this method. Signed-off-by: Jean Delvare <khali@linux-fr.org> Acked-by: Michael Lawnick <nospam_lawnick@gmx.de> Acked-by: Hans Verkuil <hverkuil@xs4all.nl>
Jean Delvare
1 parent 5d80f8e5a9
Showing 2 changed files with 182 additions and 4 deletions Side-by-side Diff
Documentation/i2c/instantiating-devices
Documentation/i2c/writing-clients
+How to instantiate I2C devices
+==============================
+
+Unlike PCI or USB devices, I2C devices are not enumerated at the hardware
+level. Instead, the software must know which devices are connected on each
+I2C bus segment, and what address these devices are using. For this
+reason, the kernel code must instantiate I2C devices explicitly. There are
+several ways to achieve this, depending on the context and requirements.
+
+
+Method 1: Declare the I2C devices by bus number
+-----------------------------------------------
+
+This method is appropriate when the I2C bus is a system bus as is the case
+for many embedded systems. On such systems, each I2C bus has a number
+which is known in advance. It is thus possible to pre-declare the I2C
+devices which live on this bus. This is done with an array of struct
+i2c_board_info which is registered by calling i2c_register_board_info().
+
+Example (from omap2 h4):
+
+static struct i2c_board_info __initdata h4_i2c_board_info[] = {
+	{
+		I2C_BOARD_INFO("isp1301_omap", 0x2d),
+		.irq		= OMAP_GPIO_IRQ(125),
+	},
+	{	/* EEPROM on mainboard */
+		I2C_BOARD_INFO("24c01", 0x52),
+		.platform_data	= &m24c01,
+	},
+	{	/* EEPROM on cpu card */
+		I2C_BOARD_INFO("24c01", 0x57),
+		.platform_data	= &m24c01,
+	},
+};
+
+static void __init omap_h4_init(void)
+{
+	(...)
+	i2c_register_board_info(1, h4_i2c_board_info,
+			ARRAY_SIZE(h4_i2c_board_info));
+	(...)
+}
+
+The above code declares 3 devices on I2C bus 1, including their respective
+addresses and custom data needed by their drivers. When the I2C bus in
+question is registered, the I2C devices will be instantiated automatically
+by i2c-core.
+
+The devices will be automatically unbound and destroyed when the I2C bus
+they sit on goes away (if ever.)
+
+
+Method 2: Instantiate the devices explicitly
+--------------------------------------------
+
+This method is appropriate when a larger device uses an I2C bus for
+internal communication. A typical case is TV adapters. These can have a
+tuner, a video decoder, an audio decoder, etc. usually connected to the
+main chip by the means of an I2C bus. You won't know the number of the I2C
+bus in advance, so the method 1 described above can't be used. Instead,
+you can instantiate your I2C devices explicitly. This is done by filling
+a struct i2c_board_info and calling i2c_new_device().
+
+Example (from the sfe4001 network driver):
+
+static struct i2c_board_info sfe4001_hwmon_info = {
+	I2C_BOARD_INFO("max6647", 0x4e),
+};
+
+int sfe4001_init(struct efx_nic *efx)
+{
+	(...)
+	efx->board_info.hwmon_client =
+		i2c_new_device(&efx->i2c_adap, &sfe4001_hwmon_info);
+
+	(...)
+}
+
+The above code instantiates 1 I2C device on the I2C bus which is on the
+network adapter in question.
+
+A variant of this is when you don't know for sure if an I2C device is
+present or not (for example for an optional feature which is not present
+on cheap variants of a board but you have no way to tell them apart), or
+it may have different addresses from one board to the next (manufacturer
+changing its design without notice). In this case, you can call
+i2c_new_probed_device() instead of i2c_new_device().
+
+Example (from the pnx4008 OHCI driver):
+
+static const unsigned short normal_i2c[] = { 0x2c, 0x2d, I2C_CLIENT_END };
+
+static int __devinit usb_hcd_pnx4008_probe(struct platform_device *pdev)
+{
+	(...)
+	struct i2c_adapter *i2c_adap;
+	struct i2c_board_info i2c_info;
+
+	(...)
+	i2c_adap = i2c_get_adapter(2);
+	memset(&i2c_info, 0, sizeof(struct i2c_board_info));
+	strlcpy(i2c_info.name, "isp1301_pnx", I2C_NAME_SIZE);
+	isp1301_i2c_client = i2c_new_probed_device(i2c_adap, &i2c_info,
+						   normal_i2c);
+	i2c_put_adapter(i2c_adap);
+	(...)
+}
+
+The above code instantiates up to 1 I2C device on the I2C bus which is on
+the OHCI adapter in question. It first tries at address 0x2c, if nothing
+is found there it tries address 0x2d, and if still nothing is found, it
+simply gives up.
+
+The driver which instantiated the I2C device is responsible for destroying
+it on cleanup. This is done by calling i2c_unregister_device() on the
+pointer that was earlier returned by i2c_new_device() or
+i2c_new_probed_device().
+
+
+Method 3: Probe an I2C bus for certain devices
+----------------------------------------------
+
+Sometimes you do not have enough information about an I2C device, not even
+to call i2c_new_probed_device(). The typical case is hardware monitoring
+chips on PC mainboards. There are several dozen models, which can live
+at 25 different addresses. Given the huge number of mainboards out there,
+it is next to impossible to build an exhaustive list of the hardware
+monitoring chips being used. Fortunately, most of these chips have
+manufacturer and device ID registers, so they can be identified by
+probing.
+
+In that case, I2C devices are neither declared nor instantiated
+explicitly. Instead, i2c-core will probe for such devices as soon as their
+drivers are loaded, and if any is found, an I2C device will be
+instantiated automatically. In order to prevent any misbehavior of this
+mechanism, the following restrictions apply:
+* The I2C device driver must implement the detect() method, which
+  identifies a supported device by reading from arbitrary registers.
+* Only buses which are likely to have a supported device and agree to be
+  probed, will be probed. For example this avoids probing for hardware
+  monitoring chips on a TV adapter.
+
+Example:
+See lm90_driver and lm90_detect() in drivers/hwmon/lm90.c
+
+I2C devices instantiated as a result of such a successful probe will be
+destroyed automatically when the driver which detected them is removed,
+or when the underlying I2C bus is itself destroyed, whichever happens
+first.
+
+Those of you familiar with the i2c subsystem of 2.4 kernels and early 2.6
+kernels will find out that this method 3 is essentially similar to what
+was done there. Two significant differences are:
+* Probing is only one way to instantiate I2C devices now, while it was the
+  only way back then. Where possible, methods 1 and 2 should be preferred.
+  Method 3 should only be used when there is no other way, as it can have
+  undesirable side effects.
+* I2C buses must now explicitly say which I2C driver classes can probe
+  them (by the means of the class bitfield), while all I2C buses were
+  probed by default back then. The default is an empty class which means
+  that no probing happens. The purpose of the class bitfield is to limit
+  the aforementioned undesirable side effects.
+
+Once again, method 3 should be avoided wherever possible. Explicit device
+instantiation (methods 1 and 2) is much preferred for it is safer and
+faster.
@@ -207,15 +207,26 @@
 identify supported devices (returning 0 for supported ones and -ENODEV
 for unsupported ones), a list of addresses to probe, and a device type
 (or class) so that only I2C buses which may have that type of device
-connected (and not otherwise enumerated) will be probed.  The i2c
-core will then call you back as needed and will instantiate a device
-for you for every successful detection.
+connected (and not otherwise enumerated) will be probed.  For example,
+a driver for a hardware monitoring chip for which auto-detection is
+needed would set its class to I2C_CLASS_HWMON, and only I2C adapters
+with a class including I2C_CLASS_HWMON would be probed by this driver.
+Note that the absence of matching classes does not prevent the use of
+a device of that type on the given I2C adapter.  All it prevents is
+auto-detection; explicit instantiation of devices is still possible.
  
 Note that this mechanism is purely optional and not suitable for all
 devices.  You need some reliable way to identify the supported devices
 (typically using device-specific, dedicated identification registers),
 otherwise misdetections are likely to occur and things can get wrong
-quickly.
+quickly.  Keep in mind that the I2C protocol doesn't include any
+standard way to detect the presence of a chip at a given address, let
+alone a standard way to identify devices.  Even worse is the lack of
+semantics associated to bus transfers, which means that the same
+transfer can be seen as a read operation by a chip and as a write
+operation by another chip.  For these reasons, explicit device
+instantiation should always be preferred to auto-detection where
+possible.
  
  
 Device Deletion
	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.
...	...	@@ -207,15 +207,26 @@
207	207	identify supported devices (returning 0 for supported ones and -ENODEV
208	208	for unsupported ones), a list of addresses to probe, and a device type
209	209	(or class) so that only I2C buses which may have that type of device
210		-connected (and not otherwise enumerated) will be probed. The i2c
211		-core will then call you back as needed and will instantiate a device
212		-for you for every successful detection.
	210	+connected (and not otherwise enumerated) will be probed. For example,
	211	+a driver for a hardware monitoring chip for which auto-detection is
	212	+needed would set its class to I2C_CLASS_HWMON, and only I2C adapters
	213	+with a class including I2C_CLASS_HWMON would be probed by this driver.
	214	+Note that the absence of matching classes does not prevent the use of
	215	+a device of that type on the given I2C adapter. All it prevents is
	216	+auto-detection; explicit instantiation of devices is still possible.
213	217
214	218	Note that this mechanism is purely optional and not suitable for all
215	219	devices. You need some reliable way to identify the supported devices
216	220	(typically using device-specific, dedicated identification registers),
217	221	otherwise misdetections are likely to occur and things can get wrong
218		-quickly.
	222	+quickly. Keep in mind that the I2C protocol doesn't include any
	223	+standard way to detect the presence of a chip at a given address, let
	224	+alone a standard way to identify devices. Even worse is the lack of
	225	+semantics associated to bus transfers, which means that the same
	226	+transfer can be seen as a read operation by a chip and as a write
	227	+operation by another chip. For these reasons, explicit device
	228	+instantiation should always be preferred to auto-detection where
	229	+possible.
219	230
220	231
221	232	Device Deletion