blob: d6fa5c4857934264dae874613370c0b3981010bd [file] [log] [blame]
Simon Glass65c70532014-02-26 15:59:17 -07001Driver Model
2============
3
4This README contains high-level information about driver model, a unified
5way of declaring and accessing drivers in U-Boot. The original work was done
6by:
7
8 Marek Vasut <marex@denx.de>
9 Pavel Herrmann <morpheus.ibis@gmail.com>
10 Viktor Křivák <viktor.krivak@gmail.com>
11 Tomas Hlavacek <tmshlvck@gmail.com>
12
13This has been both simplified and extended into the current implementation
14by:
15
16 Simon Glass <sjg@chromium.org>
17
18
19Terminology
20-----------
21
22Uclass - a group of devices which operate in the same way. A uclass provides
Chris Packham34e4a2e2014-06-07 10:35:55 +120023 a way of accessing individual devices within the group, but always
Simon Glass65c70532014-02-26 15:59:17 -070024 using the same interface. For example a GPIO uclass provides
25 operations for get/set value. An I2C uclass may have 10 I2C ports,
26 4 with one driver, and 6 with another.
27
28Driver - some code which talks to a peripheral and presents a higher-level
29 interface to it.
30
31Device - an instance of a driver, tied to a particular port or peripheral.
32
33
34How to try it
35-------------
36
37Build U-Boot sandbox and run it:
38
Masahiro Yamada33fcd1b2014-12-19 14:16:44 +090039 make sandbox_defconfig
Simon Glass65c70532014-02-26 15:59:17 -070040 make
Masahiro Yamada33fcd1b2014-12-19 14:16:44 +090041 ./u-boot -d u-boot.dtb
Simon Glass65c70532014-02-26 15:59:17 -070042
43 (type 'reset' to exit U-Boot)
44
45
46There is a uclass called 'demo'. This uclass handles
47saying hello, and reporting its status. There are two drivers in this
48uclass:
49
50 - simple: Just prints a message for hello, doesn't implement status
51 - shape: Prints shapes and reports number of characters printed as status
52
53The demo class is pretty simple, but not trivial. The intention is that it
54can be used for testing, so it will implement all driver model features and
55provide good code coverage of them. It does have multiple drivers, it
56handles parameter data and platdata (data which tells the driver how
57to operate on a particular platform) and it uses private driver data.
58
59To try it, see the example session below:
60
61=>demo hello 1
62Hello '@' from 07981110: red 4
63=>demo status 2
64Status: 0
65=>demo hello 2
66g
67r@
68e@@
69e@@@
70n@@@@
71g@@@@@
72=>demo status 2
73Status: 21
74=>demo hello 4 ^
75 y^^^
76 e^^^^^
77l^^^^^^^
78l^^^^^^^
79 o^^^^^
80 w^^^
81=>demo status 4
82Status: 36
83=>
84
85
86Running the tests
87-----------------
88
89The intent with driver model is that the core portion has 100% test coverage
90in sandbox, and every uclass has its own test. As a move towards this, tests
91are provided in test/dm. To run them, try:
92
Jagan Tekie57f9c82016-03-17 12:23:18 +053093 ./test/py/test.py --bd sandbox --build -k ut_dm -v
Simon Glass65c70532014-02-26 15:59:17 -070094
95You should see something like this:
96
Jagan Tekie57f9c82016-03-17 12:23:18 +053097(venv)$ ./test/py/test.py --bd sandbox --build -k ut_dm -v
98+make O=/root/u-boot/build-sandbox -s sandbox_defconfig
99+make O=/root/u-boot/build-sandbox -s -j8
100============================= test session starts ==============================
101platform linux2 -- Python 2.7.5, pytest-2.9.0, py-1.4.31, pluggy-0.3.1 -- /root/u-boot/venv/bin/python
102cachedir: .cache
103rootdir: /root/u-boot, inifile:
104collected 199 items
Simon Glass98a16052015-04-19 07:21:01 -0600105
Jagan Tekie57f9c82016-03-17 12:23:18 +0530106test/py/tests/test_ut.py::test_ut_dm_init PASSED
107test/py/tests/test_ut.py::test_ut[ut_dm_adc_bind] PASSED
108test/py/tests/test_ut.py::test_ut[ut_dm_adc_multi_channel_conversion] PASSED
109test/py/tests/test_ut.py::test_ut[ut_dm_adc_multi_channel_shot] PASSED
110test/py/tests/test_ut.py::test_ut[ut_dm_adc_single_channel_conversion] PASSED
111test/py/tests/test_ut.py::test_ut[ut_dm_adc_single_channel_shot] PASSED
112test/py/tests/test_ut.py::test_ut[ut_dm_adc_supply] PASSED
113test/py/tests/test_ut.py::test_ut[ut_dm_adc_wrong_channel_selection] PASSED
114test/py/tests/test_ut.py::test_ut[ut_dm_autobind] PASSED
115test/py/tests/test_ut.py::test_ut[ut_dm_autobind_uclass_pdata_alloc] PASSED
116test/py/tests/test_ut.py::test_ut[ut_dm_autobind_uclass_pdata_valid] PASSED
117test/py/tests/test_ut.py::test_ut[ut_dm_autoprobe] PASSED
118test/py/tests/test_ut.py::test_ut[ut_dm_bus_child_post_bind] PASSED
119test/py/tests/test_ut.py::test_ut[ut_dm_bus_child_post_bind_uclass] PASSED
120test/py/tests/test_ut.py::test_ut[ut_dm_bus_child_pre_probe_uclass] PASSED
121test/py/tests/test_ut.py::test_ut[ut_dm_bus_children] PASSED
122test/py/tests/test_ut.py::test_ut[ut_dm_bus_children_funcs] PASSED
123test/py/tests/test_ut.py::test_ut[ut_dm_bus_children_iterators] PASSED
124test/py/tests/test_ut.py::test_ut[ut_dm_bus_parent_data] PASSED
125test/py/tests/test_ut.py::test_ut[ut_dm_bus_parent_data_uclass] PASSED
126test/py/tests/test_ut.py::test_ut[ut_dm_bus_parent_ops] PASSED
127test/py/tests/test_ut.py::test_ut[ut_dm_bus_parent_platdata] PASSED
128test/py/tests/test_ut.py::test_ut[ut_dm_bus_parent_platdata_uclass] PASSED
129test/py/tests/test_ut.py::test_ut[ut_dm_children] PASSED
130test/py/tests/test_ut.py::test_ut[ut_dm_clk_base] PASSED
131test/py/tests/test_ut.py::test_ut[ut_dm_clk_periph] PASSED
132test/py/tests/test_ut.py::test_ut[ut_dm_device_get_uclass_id] PASSED
133test/py/tests/test_ut.py::test_ut[ut_dm_eth] PASSED
134test/py/tests/test_ut.py::test_ut[ut_dm_eth_act] PASSED
135test/py/tests/test_ut.py::test_ut[ut_dm_eth_alias] PASSED
136test/py/tests/test_ut.py::test_ut[ut_dm_eth_prime] PASSED
137test/py/tests/test_ut.py::test_ut[ut_dm_eth_rotate] PASSED
138test/py/tests/test_ut.py::test_ut[ut_dm_fdt] PASSED
139test/py/tests/test_ut.py::test_ut[ut_dm_fdt_offset] PASSED
140test/py/tests/test_ut.py::test_ut[ut_dm_fdt_pre_reloc] PASSED
141test/py/tests/test_ut.py::test_ut[ut_dm_fdt_uclass_seq] PASSED
142test/py/tests/test_ut.py::test_ut[ut_dm_gpio] PASSED
143test/py/tests/test_ut.py::test_ut[ut_dm_gpio_anon] PASSED
144test/py/tests/test_ut.py::test_ut[ut_dm_gpio_copy] PASSED
145test/py/tests/test_ut.py::test_ut[ut_dm_gpio_leak] PASSED
146test/py/tests/test_ut.py::test_ut[ut_dm_gpio_phandles] PASSED
147test/py/tests/test_ut.py::test_ut[ut_dm_gpio_requestf] PASSED
148test/py/tests/test_ut.py::test_ut[ut_dm_i2c_bytewise] PASSED
149test/py/tests/test_ut.py::test_ut[ut_dm_i2c_find] PASSED
150test/py/tests/test_ut.py::test_ut[ut_dm_i2c_offset] PASSED
151test/py/tests/test_ut.py::test_ut[ut_dm_i2c_offset_len] PASSED
152test/py/tests/test_ut.py::test_ut[ut_dm_i2c_probe_empty] PASSED
153test/py/tests/test_ut.py::test_ut[ut_dm_i2c_read_write] PASSED
154test/py/tests/test_ut.py::test_ut[ut_dm_i2c_speed] PASSED
155test/py/tests/test_ut.py::test_ut[ut_dm_leak] PASSED
156test/py/tests/test_ut.py::test_ut[ut_dm_led_base] PASSED
157test/py/tests/test_ut.py::test_ut[ut_dm_led_gpio] PASSED
158test/py/tests/test_ut.py::test_ut[ut_dm_led_label] PASSED
159test/py/tests/test_ut.py::test_ut[ut_dm_lifecycle] PASSED
160test/py/tests/test_ut.py::test_ut[ut_dm_mmc_base] PASSED
161test/py/tests/test_ut.py::test_ut[ut_dm_net_retry] PASSED
162test/py/tests/test_ut.py::test_ut[ut_dm_operations] PASSED
163test/py/tests/test_ut.py::test_ut[ut_dm_ordering] PASSED
164test/py/tests/test_ut.py::test_ut[ut_dm_pci_base] PASSED
165test/py/tests/test_ut.py::test_ut[ut_dm_pci_busnum] PASSED
166test/py/tests/test_ut.py::test_ut[ut_dm_pci_swapcase] PASSED
167test/py/tests/test_ut.py::test_ut[ut_dm_platdata] PASSED
168test/py/tests/test_ut.py::test_ut[ut_dm_power_pmic_get] PASSED
169test/py/tests/test_ut.py::test_ut[ut_dm_power_pmic_io] PASSED
170test/py/tests/test_ut.py::test_ut[ut_dm_power_regulator_autoset] PASSED
171test/py/tests/test_ut.py::test_ut[ut_dm_power_regulator_autoset_list] PASSED
172test/py/tests/test_ut.py::test_ut[ut_dm_power_regulator_get] PASSED
173test/py/tests/test_ut.py::test_ut[ut_dm_power_regulator_set_get_current] PASSED
174test/py/tests/test_ut.py::test_ut[ut_dm_power_regulator_set_get_enable] PASSED
175test/py/tests/test_ut.py::test_ut[ut_dm_power_regulator_set_get_mode] PASSED
176test/py/tests/test_ut.py::test_ut[ut_dm_power_regulator_set_get_voltage] PASSED
177test/py/tests/test_ut.py::test_ut[ut_dm_pre_reloc] PASSED
178test/py/tests/test_ut.py::test_ut[ut_dm_ram_base] PASSED
179test/py/tests/test_ut.py::test_ut[ut_dm_regmap_base] PASSED
180test/py/tests/test_ut.py::test_ut[ut_dm_regmap_syscon] PASSED
181test/py/tests/test_ut.py::test_ut[ut_dm_remoteproc_base] PASSED
182test/py/tests/test_ut.py::test_ut[ut_dm_remove] PASSED
183test/py/tests/test_ut.py::test_ut[ut_dm_reset_base] PASSED
184test/py/tests/test_ut.py::test_ut[ut_dm_reset_walk] PASSED
185test/py/tests/test_ut.py::test_ut[ut_dm_rtc_base] PASSED
186test/py/tests/test_ut.py::test_ut[ut_dm_rtc_dual] PASSED
187test/py/tests/test_ut.py::test_ut[ut_dm_rtc_reset] PASSED
188test/py/tests/test_ut.py::test_ut[ut_dm_rtc_set_get] PASSED
189test/py/tests/test_ut.py::test_ut[ut_dm_spi_find] PASSED
190test/py/tests/test_ut.py::test_ut[ut_dm_spi_flash] PASSED
191test/py/tests/test_ut.py::test_ut[ut_dm_spi_xfer] PASSED
192test/py/tests/test_ut.py::test_ut[ut_dm_syscon_base] PASSED
193test/py/tests/test_ut.py::test_ut[ut_dm_syscon_by_driver_data] PASSED
194test/py/tests/test_ut.py::test_ut[ut_dm_timer_base] PASSED
195test/py/tests/test_ut.py::test_ut[ut_dm_uclass] PASSED
196test/py/tests/test_ut.py::test_ut[ut_dm_uclass_before_ready] PASSED
197test/py/tests/test_ut.py::test_ut[ut_dm_uclass_devices_find] PASSED
198test/py/tests/test_ut.py::test_ut[ut_dm_uclass_devices_find_by_name] PASSED
199test/py/tests/test_ut.py::test_ut[ut_dm_uclass_devices_get] PASSED
200test/py/tests/test_ut.py::test_ut[ut_dm_uclass_devices_get_by_name] PASSED
201test/py/tests/test_ut.py::test_ut[ut_dm_usb_base] PASSED
202test/py/tests/test_ut.py::test_ut[ut_dm_usb_flash] PASSED
203test/py/tests/test_ut.py::test_ut[ut_dm_usb_keyb] PASSED
204test/py/tests/test_ut.py::test_ut[ut_dm_usb_multi] PASSED
205test/py/tests/test_ut.py::test_ut[ut_dm_usb_remove] PASSED
206test/py/tests/test_ut.py::test_ut[ut_dm_usb_tree] PASSED
207test/py/tests/test_ut.py::test_ut[ut_dm_usb_tree_remove] PASSED
208test/py/tests/test_ut.py::test_ut[ut_dm_usb_tree_reorder] PASSED
209test/py/tests/test_ut.py::test_ut[ut_dm_video_base] PASSED
210test/py/tests/test_ut.py::test_ut[ut_dm_video_bmp] PASSED
211test/py/tests/test_ut.py::test_ut[ut_dm_video_bmp_comp] PASSED
212test/py/tests/test_ut.py::test_ut[ut_dm_video_chars] PASSED
213test/py/tests/test_ut.py::test_ut[ut_dm_video_context] PASSED
214test/py/tests/test_ut.py::test_ut[ut_dm_video_rotation1] PASSED
215test/py/tests/test_ut.py::test_ut[ut_dm_video_rotation2] PASSED
216test/py/tests/test_ut.py::test_ut[ut_dm_video_rotation3] PASSED
217test/py/tests/test_ut.py::test_ut[ut_dm_video_text] PASSED
218test/py/tests/test_ut.py::test_ut[ut_dm_video_truetype] PASSED
219test/py/tests/test_ut.py::test_ut[ut_dm_video_truetype_bs] PASSED
220test/py/tests/test_ut.py::test_ut[ut_dm_video_truetype_scroll] PASSED
Simon Glass98a16052015-04-19 07:21:01 -0600221
Jagan Tekie57f9c82016-03-17 12:23:18 +0530222======================= 84 tests deselected by '-kut_dm' =======================
223================== 115 passed, 84 deselected in 3.77 seconds ===================
Simon Glass65c70532014-02-26 15:59:17 -0700224
225What is going on?
226-----------------
227
228Let's start at the top. The demo command is in common/cmd_demo.c. It does
Chris Packham34e4a2e2014-06-07 10:35:55 +1200229the usual command processing and then:
Simon Glass65c70532014-02-26 15:59:17 -0700230
Heiko Schocher54c5d082014-05-22 12:43:05 +0200231 struct udevice *demo_dev;
Simon Glass65c70532014-02-26 15:59:17 -0700232
233 ret = uclass_get_device(UCLASS_DEMO, devnum, &demo_dev);
234
235UCLASS_DEMO means the class of devices which implement 'demo'. Other
236classes might be MMC, or GPIO, hashing or serial. The idea is that the
237devices in the class all share a particular way of working. The class
238presents a unified view of all these devices to U-Boot.
239
240This function looks up a device for the demo uclass. Given a device
241number we can find the device because all devices have registered with
242the UCLASS_DEMO uclass.
243
244The device is automatically activated ready for use by uclass_get_device().
245
246Now that we have the device we can do things like:
247
248 return demo_hello(demo_dev, ch);
249
250This function is in the demo uclass. It takes care of calling the 'hello'
251method of the relevant driver. Bearing in mind that there are two drivers,
252this particular device may use one or other of them.
253
254The code for demo_hello() is in drivers/demo/demo-uclass.c:
255
Heiko Schocher54c5d082014-05-22 12:43:05 +0200256int demo_hello(struct udevice *dev, int ch)
Simon Glass65c70532014-02-26 15:59:17 -0700257{
258 const struct demo_ops *ops = device_get_ops(dev);
259
260 if (!ops->hello)
261 return -ENOSYS;
262
263 return ops->hello(dev, ch);
264}
265
266As you can see it just calls the relevant driver method. One of these is
267in drivers/demo/demo-simple.c:
268
Heiko Schocher54c5d082014-05-22 12:43:05 +0200269static int simple_hello(struct udevice *dev, int ch)
Simon Glass65c70532014-02-26 15:59:17 -0700270{
271 const struct dm_demo_pdata *pdata = dev_get_platdata(dev);
272
273 printf("Hello from %08x: %s %d\n", map_to_sysmem(dev),
274 pdata->colour, pdata->sides);
275
276 return 0;
277}
278
279
280So that is a trip from top (command execution) to bottom (driver action)
281but it leaves a lot of topics to address.
282
283
284Declaring Drivers
285-----------------
286
287A driver declaration looks something like this (see
288drivers/demo/demo-shape.c):
289
290static const struct demo_ops shape_ops = {
291 .hello = shape_hello,
292 .status = shape_status,
293};
294
295U_BOOT_DRIVER(demo_shape_drv) = {
296 .name = "demo_shape_drv",
297 .id = UCLASS_DEMO,
298 .ops = &shape_ops,
299 .priv_data_size = sizeof(struct shape_data),
300};
301
302
303This driver has two methods (hello and status) and requires a bit of
304private data (accessible through dev_get_priv(dev) once the driver has
305been probed). It is a member of UCLASS_DEMO so will register itself
306there.
307
308In U_BOOT_DRIVER it is also possible to specify special methods for bind
309and unbind, and these are called at appropriate times. For many drivers
310it is hoped that only 'probe' and 'remove' will be needed.
311
312The U_BOOT_DRIVER macro creates a data structure accessible from C,
313so driver model can find the drivers that are available.
314
315The methods a device can provide are documented in the device.h header.
316Briefly, they are:
317
318 bind - make the driver model aware of a device (bind it to its driver)
319 unbind - make the driver model forget the device
320 ofdata_to_platdata - convert device tree data to platdata - see later
321 probe - make a device ready for use
322 remove - remove a device so it cannot be used until probed again
323
324The sequence to get a device to work is bind, ofdata_to_platdata (if using
325device tree) and probe.
326
327
328Platform Data
329-------------
330
Simon Glass97f3ee32015-07-06 12:54:22 -0600331*** Note: platform data is the old way of doing things. It is
332*** basically a C structure which is passed to drivers to tell them about
333*** platform-specific settings like the address of its registers, bus
334*** speed, etc. Device tree is now the preferred way of handling this.
335*** Unless you have a good reason not to use device tree (the main one
336*** being you need serial support in SPL and don't have enough SRAM for
337*** the cut-down device tree and libfdt libraries) you should stay away
338*** from platform data.
339
Simon Glass22ec1362014-06-11 23:29:55 -0600340Platform data is like Linux platform data, if you are familiar with that.
341It provides the board-specific information to start up a device.
342
343Why is this information not just stored in the device driver itself? The
344idea is that the device driver is generic, and can in principle operate on
345any board that has that type of device. For example, with modern
346highly-complex SoCs it is common for the IP to come from an IP vendor, and
347therefore (for example) the MMC controller may be the same on chips from
348different vendors. It makes no sense to write independent drivers for the
349MMC controller on each vendor's SoC, when they are all almost the same.
350Similarly, we may have 6 UARTs in an SoC, all of which are mostly the same,
351but lie at different addresses in the address space.
352
353Using the UART example, we have a single driver and it is instantiated 6
354times by supplying 6 lots of platform data. Each lot of platform data
355gives the driver name and a pointer to a structure containing information
356about this instance - e.g. the address of the register space. It may be that
357one of the UARTS supports RS-485 operation - this can be added as a flag in
358the platform data, which is set for this one port and clear for the rest.
359
360Think of your driver as a generic piece of code which knows how to talk to
361a device, but needs to know where it is, any variant/option information and
362so on. Platform data provides this link between the generic piece of code
363and the specific way it is bound on a particular board.
364
365Examples of platform data include:
366
367 - The base address of the IP block's register space
368 - Configuration options, like:
369 - the SPI polarity and maximum speed for a SPI controller
370 - the I2C speed to use for an I2C device
371 - the number of GPIOs available in a GPIO device
372
373Where does the platform data come from? It is either held in a structure
374which is compiled into U-Boot, or it can be parsed from the Device Tree
375(see 'Device Tree' below).
376
377For an example of how it can be compiled in, see demo-pdata.c which
Simon Glass65c70532014-02-26 15:59:17 -0700378sets up a table of driver names and their associated platform data.
379The data can be interpreted by the drivers however they like - it is
380basically a communication scheme between the board-specific code and
381the generic drivers, which are intended to work on any board.
382
Chris Packham34e4a2e2014-06-07 10:35:55 +1200383Drivers can access their data via dev->info->platdata. Here is
Simon Glass65c70532014-02-26 15:59:17 -0700384the declaration for the platform data, which would normally appear
385in the board file.
386
387 static const struct dm_demo_cdata red_square = {
388 .colour = "red",
389 .sides = 4.
390 };
391 static const struct driver_info info[] = {
392 {
393 .name = "demo_shape_drv",
394 .platdata = &red_square,
395 },
396 };
397
398 demo1 = driver_bind(root, &info[0]);
399
400
401Device Tree
402-----------
403
404While platdata is useful, a more flexible way of providing device data is
Simon Glass97f3ee32015-07-06 12:54:22 -0600405by using device tree. In U-Boot you should use this where possible. Avoid
406sending patches which make use of the U_BOOT_DEVICE() macro unless strictly
407necessary.
408
409With device tree we replace the above code with the following device tree
410fragment:
Simon Glass65c70532014-02-26 15:59:17 -0700411
412 red-square {
413 compatible = "demo-shape";
414 colour = "red";
415 sides = <4>;
416 };
417
Simon Glass22ec1362014-06-11 23:29:55 -0600418This means that instead of having lots of U_BOOT_DEVICE() declarations in
419the board file, we put these in the device tree. This approach allows a lot
420more generality, since the same board file can support many types of boards
421(e,g. with the same SoC) just by using different device trees. An added
422benefit is that the Linux device tree can be used, thus further simplifying
423the task of board-bring up either for U-Boot or Linux devs (whoever gets to
424the board first!).
Simon Glass65c70532014-02-26 15:59:17 -0700425
426The easiest way to make this work it to add a few members to the driver:
427
428 .platdata_auto_alloc_size = sizeof(struct dm_test_pdata),
429 .ofdata_to_platdata = testfdt_ofdata_to_platdata,
Simon Glass65c70532014-02-26 15:59:17 -0700430
431The 'auto_alloc' feature allowed space for the platdata to be allocated
Simon Glass22ec1362014-06-11 23:29:55 -0600432and zeroed before the driver's ofdata_to_platdata() method is called. The
433ofdata_to_platdata() method, which the driver write supplies, should parse
434the device tree node for this device and place it in dev->platdata. Thus
435when the probe method is called later (to set up the device ready for use)
436the platform data will be present.
Simon Glass65c70532014-02-26 15:59:17 -0700437
438Note that both methods are optional. If you provide an ofdata_to_platdata
Simon Glass22ec1362014-06-11 23:29:55 -0600439method then it will be called first (during activation). If you provide a
440probe method it will be called next. See Driver Lifecycle below for more
441details.
Simon Glass65c70532014-02-26 15:59:17 -0700442
443If you don't want to have the platdata automatically allocated then you
444can leave out platdata_auto_alloc_size. In this case you can use malloc
445in your ofdata_to_platdata (or probe) method to allocate the required memory,
446and you should free it in the remove method.
447
Simon Glass2f3b95d2015-01-25 08:26:58 -0700448The driver model tree is intended to mirror that of the device tree. The
449root driver is at device tree offset 0 (the root node, '/'), and its
450children are the children of the root node.
451
Simon Glass65c70532014-02-26 15:59:17 -0700452
453Declaring Uclasses
454------------------
455
456The demo uclass is declared like this:
457
458U_BOOT_CLASS(demo) = {
459 .id = UCLASS_DEMO,
460};
461
462It is also possible to specify special methods for probe, etc. The uclass
463numbering comes from include/dm/uclass.h. To add a new uclass, add to the
464end of the enum there, then declare your uclass as above.
465
466
Simon Glass5a66a8f2014-07-23 06:55:12 -0600467Device Sequence Numbers
468-----------------------
469
470U-Boot numbers devices from 0 in many situations, such as in the command
471line for I2C and SPI buses, and the device names for serial ports (serial0,
472serial1, ...). Driver model supports this numbering and permits devices
Simon Glass9cc36a22015-01-25 08:27:05 -0700473to be locating by their 'sequence'. This numbering uniquely identifies a
Simon Glass547cea12014-10-13 23:41:51 -0600474device in its uclass, so no two devices within a particular uclass can have
475the same sequence number.
Simon Glass5a66a8f2014-07-23 06:55:12 -0600476
477Sequence numbers start from 0 but gaps are permitted. For example, a board
Simon Glass9cc36a22015-01-25 08:27:05 -0700478may have I2C buses 1, 4, 5 but no 0, 2 or 3. The choice of how devices are
Simon Glass5a66a8f2014-07-23 06:55:12 -0600479numbered is up to a particular board, and may be set by the SoC in some
480cases. While it might be tempting to automatically renumber the devices
481where there are gaps in the sequence, this can lead to confusion and is
482not the way that U-Boot works.
483
484Each device can request a sequence number. If none is required then the
485device will be automatically allocated the next available sequence number.
486
487To specify the sequence number in the device tree an alias is typically
Simon Glass9cc36a22015-01-25 08:27:05 -0700488used. Make sure that the uclass has the DM_UC_FLAG_SEQ_ALIAS flag set.
Simon Glass5a66a8f2014-07-23 06:55:12 -0600489
490aliases {
491 serial2 = "/serial@22230000";
492};
493
494This indicates that in the uclass called "serial", the named node
495("/serial@22230000") will be given sequence number 2. Any command or driver
496which requests serial device 2 will obtain this device.
497
Simon Glass9cc36a22015-01-25 08:27:05 -0700498More commonly you can use node references, which expand to the full path:
Simon Glass5a66a8f2014-07-23 06:55:12 -0600499
Simon Glass9cc36a22015-01-25 08:27:05 -0700500aliases {
501 serial2 = &serial_2;
502};
503...
504serial_2: serial@22230000 {
505...
506};
Simon Glass5a66a8f2014-07-23 06:55:12 -0600507
Simon Glass9cc36a22015-01-25 08:27:05 -0700508The alias resolves to the same string in this case, but this version is
509easier to read.
Simon Glass5a66a8f2014-07-23 06:55:12 -0600510
511Device sequence numbers are resolved when a device is probed. Before then
512the sequence number is only a request which may or may not be honoured,
513depending on what other devices have been probed. However the numbering is
514entirely under the control of the board author so a conflict is generally
515an error.
516
517
Simon Glassa327dee2014-07-23 06:55:21 -0600518Bus Drivers
519-----------
520
521A common use of driver model is to implement a bus, a device which provides
522access to other devices. Example of buses include SPI and I2C. Typically
523the bus provides some sort of transport or translation that makes it
524possible to talk to the devices on the bus.
525
Simon Glass2017aae2015-01-25 08:27:20 -0700526Driver model provides some useful features to help with implementing buses.
527Firstly, a bus can request that its children store some 'parent data' which
528can be used to keep track of child state. Secondly, the bus can define
529methods which are called when a child is probed or removed. This is similar
530to the methods the uclass driver provides. Thirdly, per-child platform data
531can be provided to specify things like the child's address on the bus. This
532persists across child probe()/remove() cycles.
533
534For consistency and ease of implementation, the bus uclass can specify the
535per-child platform data, so that it can be the same for all children of buses
536in that uclass. There are also uclass methods which can be called when
537children are bound and probed.
Simon Glassa327dee2014-07-23 06:55:21 -0600538
539Here an explanation of how a bus fits with a uclass may be useful. Consider
540a USB bus with several devices attached to it, each from a different (made
541up) uclass:
542
543 xhci_usb (UCLASS_USB)
544 eth (UCLASS_ETHERNET)
545 camera (UCLASS_CAMERA)
546 flash (UCLASS_FLASH_STORAGE)
547
548Each of the devices is connected to a different address on the USB bus.
549The bus device wants to store this address and some other information such
550as the bus speed for each device.
551
Simon Glass2017aae2015-01-25 08:27:20 -0700552To achieve this, the bus device can use dev->parent_platdata in each of its
553three children. This can be auto-allocated if the bus driver (or bus uclass)
554has a non-zero value for per_child_platdata_auto_alloc_size. If not, then
555the bus device or uclass can allocate the space itself before the child
556device is probed.
Simon Glassa327dee2014-07-23 06:55:21 -0600557
558Also the bus driver can define the child_pre_probe() and child_post_remove()
559methods to allow it to do some processing before the child is activated or
560after it is deactivated.
561
Simon Glass2017aae2015-01-25 08:27:20 -0700562Similarly the bus uclass can define the child_post_bind() method to obtain
563the per-child platform data from the device tree and set it up for the child.
564The bus uclass can also provide a child_pre_probe() method. Very often it is
565the bus uclass that controls these features, since it avoids each driver
566having to do the same processing. Of course the driver can still tweak and
567override these activities.
568
Simon Glassa327dee2014-07-23 06:55:21 -0600569Note that the information that controls this behaviour is in the bus's
570driver, not the child's. In fact it is possible that child has no knowledge
571that it is connected to a bus. The same child device may even be used on two
572different bus types. As an example. the 'flash' device shown above may also
573be connected on a SATA bus or standalone with no bus:
574
575 xhci_usb (UCLASS_USB)
576 flash (UCLASS_FLASH_STORAGE) - parent data/methods defined by USB bus
577
578 sata (UCLASS_SATA)
579 flash (UCLASS_FLASH_STORAGE) - parent data/methods defined by SATA bus
580
581 flash (UCLASS_FLASH_STORAGE) - no parent data/methods (not on a bus)
582
583Above you can see that the driver for xhci_usb/sata controls the child's
584bus methods. In the third example the device is not on a bus, and therefore
585will not have these methods at all. Consider the case where the flash
586device defines child methods. These would be used for *its* children, and
587would be quite separate from the methods defined by the driver for the bus
588that the flash device is connetced to. The act of attaching a device to a
589parent device which is a bus, causes the device to start behaving like a
590bus device, regardless of its own views on the matter.
591
592The uclass for the device can also contain data private to that uclass.
593But note that each device on the bus may be a memeber of a different
594uclass, and this data has nothing to do with the child data for each child
Simon Glass2017aae2015-01-25 08:27:20 -0700595on the bus. It is the bus' uclass that controls the child with respect to
596the bus.
Simon Glassa327dee2014-07-23 06:55:21 -0600597
598
Simon Glass22ec1362014-06-11 23:29:55 -0600599Driver Lifecycle
600----------------
601
602Here are the stages that a device goes through in driver model. Note that all
603methods mentioned here are optional - e.g. if there is no probe() method for
604a device then it will not be called. A simple device may have very few
605methods actually defined.
606
6071. Bind stage
608
Stephen Warrendaac3bf2016-05-11 15:26:24 -0600609U-Boot discovers devices using one of these two methods:
Simon Glass22ec1362014-06-11 23:29:55 -0600610
Stephen Warrendaac3bf2016-05-11 15:26:24 -0600611 - Scan the U_BOOT_DEVICE() definitions. U-Boot looks up the name specified
612by each, to find the appropriate U_BOOT_DRIVER() definition. In this case,
613there is no path by which driver_data may be provided, but the U_BOOT_DEVICE()
614may provide platdata.
Simon Glass22ec1362014-06-11 23:29:55 -0600615
616 - Scan through the device tree definitions. U-Boot looks at top-level
617nodes in the the device tree. It looks at the compatible string in each node
Stephen Warrendaac3bf2016-05-11 15:26:24 -0600618and uses the of_match table of the U_BOOT_DRIVER() structure to find the
619right driver for each node. In this case, the of_match table may provide a
620driver_data value, but platdata cannot be provided until later.
621
622For each device that is discovered, U-Boot then calls device_bind() to create a
623new device, initializes various core fields of the device object such as name,
624uclass & driver, initializes any optional fields of the device object that are
625applicable such as of_offset, driver_data & platdata, and finally calls the
626driver's bind() method if one is defined.
Simon Glass22ec1362014-06-11 23:29:55 -0600627
628At this point all the devices are known, and bound to their drivers. There
629is a 'struct udevice' allocated for all devices. However, nothing has been
630activated (except for the root device). Each bound device that was created
631from a U_BOOT_DEVICE() declaration will hold the platdata pointer specified
632in that declaration. For a bound device created from the device tree,
633platdata will be NULL, but of_offset will be the offset of the device tree
634node that caused the device to be created. The uclass is set correctly for
635the device.
636
637The device's bind() method is permitted to perform simple actions, but
638should not scan the device tree node, not initialise hardware, nor set up
639structures or allocate memory. All of these tasks should be left for
640the probe() method.
641
642Note that compared to Linux, U-Boot's driver model has a separate step of
643probe/remove which is independent of bind/unbind. This is partly because in
644U-Boot it may be expensive to probe devices and we don't want to do it until
645they are needed, or perhaps until after relocation.
646
6472. Activation/probe
648
649When a device needs to be used, U-Boot activates it, by following these
650steps (see device_probe()):
651
652 a. If priv_auto_alloc_size is non-zero, then the device-private space
653 is allocated for the device and zeroed. It will be accessible as
654 dev->priv. The driver can put anything it likes in there, but should use
655 it for run-time information, not platform data (which should be static
656 and known before the device is probed).
657
658 b. If platdata_auto_alloc_size is non-zero, then the platform data space
659 is allocated. This is only useful for device tree operation, since
660 otherwise you would have to specific the platform data in the
661 U_BOOT_DEVICE() declaration. The space is allocated for the device and
662 zeroed. It will be accessible as dev->platdata.
663
664 c. If the device's uclass specifies a non-zero per_device_auto_alloc_size,
665 then this space is allocated and zeroed also. It is allocated for and
666 stored in the device, but it is uclass data. owned by the uclass driver.
667 It is possible for the device to access it.
668
Simon Glasse59f4582014-07-23 06:55:20 -0600669 d. If the device's immediate parent specifies a per_child_auto_alloc_size
670 then this space is allocated. This is intended for use by the parent
671 device to keep track of things related to the child. For example a USB
672 flash stick attached to a USB host controller would likely use this
673 space. The controller can hold information about the USB state of each
674 of its children.
675
676 e. All parent devices are probed. It is not possible to activate a device
Simon Glass22ec1362014-06-11 23:29:55 -0600677 unless its predecessors (all the way up to the root device) are activated.
678 This means (for example) that an I2C driver will require that its bus
679 be activated.
680
Simon Glasse59f4582014-07-23 06:55:20 -0600681 f. The device's sequence number is assigned, either the requested one
Simon Glass5a66a8f2014-07-23 06:55:12 -0600682 (assuming no conflicts) or the next available one if there is a conflict
683 or nothing particular is requested.
684
Simon Glasse59f4582014-07-23 06:55:20 -0600685 g. If the driver provides an ofdata_to_platdata() method, then this is
Simon Glass22ec1362014-06-11 23:29:55 -0600686 called to convert the device tree data into platform data. This should
Simon Glasse160f7d2017-01-17 16:52:55 -0700687 do various calls like fdtdec_get_int(gd->fdt_blob, dev_of_offset(dev), ...)
Simon Glass22ec1362014-06-11 23:29:55 -0600688 to access the node and store the resulting information into dev->platdata.
689 After this point, the device works the same way whether it was bound
690 using a device tree node or U_BOOT_DEVICE() structure. In either case,
691 the platform data is now stored in the platdata structure. Typically you
692 will use the platdata_auto_alloc_size feature to specify the size of the
693 platform data structure, and U-Boot will automatically allocate and zero
694 it for you before entry to ofdata_to_platdata(). But if not, you can
695 allocate it yourself in ofdata_to_platdata(). Note that it is preferable
696 to do all the device tree decoding in ofdata_to_platdata() rather than
697 in probe(). (Apart from the ugliness of mixing configuration and run-time
Chris Packham09b8d672018-07-06 22:29:46 +1200698 data, one day it is possible that U-Boot will cache platform data for
Simon Glass22ec1362014-06-11 23:29:55 -0600699 devices which are regularly de/activated).
700
Simon Glasse59f4582014-07-23 06:55:20 -0600701 h. The device's probe() method is called. This should do anything that
Simon Glass22ec1362014-06-11 23:29:55 -0600702 is required by the device to get it going. This could include checking
703 that the hardware is actually present, setting up clocks for the
704 hardware and setting up hardware registers to initial values. The code
705 in probe() can access:
706
707 - platform data in dev->platdata (for configuration)
708 - private data in dev->priv (for run-time state)
709 - uclass data in dev->uclass_priv (for things the uclass stores
710 about this device)
711
712 Note: If you don't use priv_auto_alloc_size then you will need to
713 allocate the priv space here yourself. The same applies also to
714 platdata_auto_alloc_size. Remember to free them in the remove() method.
715
Simon Glasse59f4582014-07-23 06:55:20 -0600716 i. The device is marked 'activated'
Simon Glass22ec1362014-06-11 23:29:55 -0600717
Simon Glasse59f4582014-07-23 06:55:20 -0600718 j. The uclass's post_probe() method is called, if one exists. This may
Simon Glass22ec1362014-06-11 23:29:55 -0600719 cause the uclass to do some housekeeping to record the device as
720 activated and 'known' by the uclass.
721
7223. Running stage
723
724The device is now activated and can be used. From now until it is removed
725all of the above structures are accessible. The device appears in the
726uclass's list of devices (so if the device is in UCLASS_GPIO it will appear
727as a device in the GPIO uclass). This is the 'running' state of the device.
728
7294. Removal stage
730
731When the device is no-longer required, you can call device_remove() to
732remove it. This performs the probe steps in reverse:
733
734 a. The uclass's pre_remove() method is called, if one exists. This may
735 cause the uclass to do some housekeeping to record the device as
736 deactivated and no-longer 'known' by the uclass.
737
738 b. All the device's children are removed. It is not permitted to have
739 an active child device with a non-active parent. This means that
740 device_remove() is called for all the children recursively at this point.
741
742 c. The device's remove() method is called. At this stage nothing has been
743 deallocated so platform data, private data and the uclass data will all
744 still be present. This is where the hardware can be shut down. It is
745 intended that the device be completely inactive at this point, For U-Boot
746 to be sure that no hardware is running, it should be enough to remove
747 all devices.
748
Simon Glasse59f4582014-07-23 06:55:20 -0600749 d. The device memory is freed (platform data, private data, uclass data,
750 parent data).
Simon Glass22ec1362014-06-11 23:29:55 -0600751
752 Note: Because the platform data for a U_BOOT_DEVICE() is defined with a
753 static pointer, it is not de-allocated during the remove() method. For
754 a device instantiated using the device tree data, the platform data will
755 be dynamically allocated, and thus needs to be deallocated during the
756 remove() method, either:
757
758 1. if the platdata_auto_alloc_size is non-zero, the deallocation
759 happens automatically within the driver model core; or
760
761 2. when platdata_auto_alloc_size is 0, both the allocation (in probe()
762 or preferably ofdata_to_platdata()) and the deallocation in remove()
763 are the responsibility of the driver author.
764
Simon Glass5a66a8f2014-07-23 06:55:12 -0600765 e. The device sequence number is set to -1, meaning that it no longer
766 has an allocated sequence. If the device is later reactivated and that
767 sequence number is still free, it may well receive the name sequence
768 number again. But from this point, the sequence number previously used
769 by this device will no longer exist (think of SPI bus 2 being removed
770 and bus 2 is no longer available for use).
771
772 f. The device is marked inactive. Note that it is still bound, so the
Simon Glass22ec1362014-06-11 23:29:55 -0600773 device structure itself is not freed at this point. Should the device be
774 activated again, then the cycle starts again at step 2 above.
775
7765. Unbind stage
777
778The device is unbound. This is the step that actually destroys the device.
779If a parent has children these will be destroyed first. After this point
780the device does not exist and its memory has be deallocated.
781
782
Simon Glass65c70532014-02-26 15:59:17 -0700783Data Structures
784---------------
785
786Driver model uses a doubly-linked list as the basic data structure. Some
787nodes have several lists running through them. Creating a more efficient
788data structure might be worthwhile in some rare cases, once we understand
789what the bottlenecks are.
790
791
792Changes since v1
793----------------
794
795For the record, this implementation uses a very similar approach to the
796original patches, but makes at least the following changes:
797
Chris Packham34e4a2e2014-06-07 10:35:55 +1200798- Tried to aggressively remove boilerplate, so that for most drivers there
Simon Glass65c70532014-02-26 15:59:17 -0700799is little or no 'driver model' code to write.
800- Moved some data from code into data structure - e.g. store a pointer to
801the driver operations structure in the driver, rather than passing it
802to the driver bind function.
Simon Glassae7f4512014-06-11 23:29:45 -0600803- Rename some structures to make them more similar to Linux (struct udevice
Simon Glass65c70532014-02-26 15:59:17 -0700804instead of struct instance, struct platdata, etc.)
805- Change the name 'core' to 'uclass', meaning U-Boot class. It seems that
806this concept relates to a class of drivers (or a subsystem). We shouldn't
807use 'class' since it is a C++ reserved word, so U-Boot class (uclass) seems
808better than 'core'.
Heiko Schocher54c5d082014-05-22 12:43:05 +0200809- Remove 'struct driver_instance' and just use a single 'struct udevice'.
Simon Glass65c70532014-02-26 15:59:17 -0700810This removes a level of indirection that doesn't seem necessary.
811- Built in device tree support, to avoid the need for platdata
812- Removed the concept of driver relocation, and just make it possible for
813the new driver (created after relocation) to access the old driver data.
814I feel that relocation is a very special case and will only apply to a few
815drivers, many of which can/will just re-init anyway. So the overhead of
816dealing with this might not be worth it.
817- Implemented a GPIO system, trying to keep it simple
818
819
Simon Glass00606d72014-07-23 06:55:03 -0600820Pre-Relocation Support
821----------------------
822
823For pre-relocation we simply call the driver model init function. Only
824drivers marked with DM_FLAG_PRE_RELOC or the device tree
825'u-boot,dm-pre-reloc' flag are initialised prior to relocation. This helps
826to reduce the driver model overhead.
827
Heiko Stübner27326c72017-02-18 19:46:21 +0100828It is possible to limit this to specific relocation steps, by using
829the more specialized 'u-boot,dm-spl' and 'u-boot,dm-tpl' flags
830in the devicetree.
831
Simon Glass00606d72014-07-23 06:55:03 -0600832Then post relocation we throw that away and re-init driver model again.
833For drivers which require some sort of continuity between pre- and
834post-relocation devices, we can provide access to the pre-relocation
835device pointers, but this is not currently implemented (the root device
836pointer is saved but not made available through the driver model API).
837
838
Simon Glass38687ae2014-11-10 17:16:54 -0700839SPL Support
840-----------
841
842Driver model can operate in SPL. Its efficient implementation and small code
843size provide for a small overhead which is acceptable for all but the most
844constrained systems.
845
846To enable driver model in SPL, define CONFIG_SPL_DM. You might want to
847consider the following option also. See the main README for more details.
848
849 - CONFIG_SYS_MALLOC_SIMPLE
850 - CONFIG_DM_WARN
851 - CONFIG_DM_DEVICE_REMOVE
852 - CONFIG_DM_STDIO
853
854
855Enabling Driver Model
856---------------------
857
858Driver model is being brought into U-Boot gradually. As each subsystems gets
859support, a uclass is created and a CONFIG to enable use of driver model for
860that subsystem.
861
862For example CONFIG_DM_SERIAL enables driver model for serial. With that
863defined, the old serial support is not enabled, and your serial driver must
864conform to driver model. With that undefined, the old serial support is
865enabled and driver model is not available for serial. This means that when
866you convert a driver, you must either convert all its boards, or provide for
867the driver to be compiled both with and without driver model (generally this
868is not very hard).
869
870See the main README for full details of the available driver model CONFIG
871options.
872
873
Simon Glass65c70532014-02-26 15:59:17 -0700874Things to punt for later
875------------------------
876
Simon Glass65c70532014-02-26 15:59:17 -0700877Uclasses are statically numbered at compile time. It would be possible to
878change this to dynamic numbering, but then we would require some sort of
879lookup service, perhaps searching by name. This is slightly less efficient
880so has been left out for now. One small advantage of dynamic numbering might
881be fewer merge conflicts in uclass-id.h.
882
883
884Simon Glass
885sjg@chromium.org
886April 2013
887Updated 7-May-13
888Updated 14-Jun-13
889Updated 18-Oct-13
890Updated 5-Nov-13