4 This README contains high-level information about driver model, a unified
5 way of declaring and accessing drivers in U-Boot. The original work was done
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>
13 This has been both simplified and extended into the current implementation
16 Simon Glass <sjg@chromium.org>
22 Uclass - a group of devices which operate in the same way. A uclass provides
23 a way of accessing individual devices within the group, but always
24 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.
28 Driver - some code which talks to a peripheral and presents a higher-level
31 Device - an instance of a driver, tied to a particular port or peripheral.
37 Build U-Boot sandbox and run it:
43 (type 'reset' to exit U-Boot)
46 There is a uclass called 'demo'. This uclass handles
47 saying hello, and reporting its status. There are two drivers in this
50 - simple: Just prints a message for hello, doesn't implement status
51 - shape: Prints shapes and reports number of characters printed as status
53 The demo class is pretty simple, but not trivial. The intention is that it
54 can be used for testing, so it will implement all driver model features and
55 provide good code coverage of them. It does have multiple drivers, it
56 handles parameter data and platdata (data which tells the driver how
57 to operate on a particular platform) and it uses private driver data.
59 To try it, see the example session below:
62 Hello '@' from 07981110: red 4
89 The intent with driver model is that the core portion has 100% test coverage
90 in sandbox, and every uclass has its own test. As a move towards this, tests
91 are provided in test/dm. To run them, try:
95 You should see something like this:
98 Running 18 driver model tests
99 Test: dm_test_autobind
100 Test: dm_test_autoprobe
101 Test: dm_test_bus_children
102 Device 'd-test': seq 3 is in use by 'b-test'
103 Device 'c-test@0': seq 0 is in use by 'a-test'
104 Device 'c-test@1': seq 1 is in use by 'd-test'
105 Test: dm_test_children
107 Device 'd-test': seq 3 is in use by 'b-test'
108 Test: dm_test_fdt_offset
109 Test: dm_test_fdt_pre_reloc
110 Test: dm_test_fdt_uclass_seq
111 Device 'd-test': seq 3 is in use by 'b-test'
112 Device 'a-test': seq 0 is in use by 'd-test'
114 sandbox_gpio: sb_gpio_get_value: error: offset 4 not reserved
116 Test: dm_test_lifecycle
117 Test: dm_test_operations
118 Test: dm_test_ordering
119 Test: dm_test_platdata
120 Test: dm_test_pre_reloc
123 Test: dm_test_uclass_before_ready
130 Let's start at the top. The demo command is in common/cmd_demo.c. It does
131 the usual command processing and then:
133 struct udevice *demo_dev;
135 ret = uclass_get_device(UCLASS_DEMO, devnum, &demo_dev);
137 UCLASS_DEMO means the class of devices which implement 'demo'. Other
138 classes might be MMC, or GPIO, hashing or serial. The idea is that the
139 devices in the class all share a particular way of working. The class
140 presents a unified view of all these devices to U-Boot.
142 This function looks up a device for the demo uclass. Given a device
143 number we can find the device because all devices have registered with
144 the UCLASS_DEMO uclass.
146 The device is automatically activated ready for use by uclass_get_device().
148 Now that we have the device we can do things like:
150 return demo_hello(demo_dev, ch);
152 This function is in the demo uclass. It takes care of calling the 'hello'
153 method of the relevant driver. Bearing in mind that there are two drivers,
154 this particular device may use one or other of them.
156 The code for demo_hello() is in drivers/demo/demo-uclass.c:
158 int demo_hello(struct udevice *dev, int ch)
160 const struct demo_ops *ops = device_get_ops(dev);
165 return ops->hello(dev, ch);
168 As you can see it just calls the relevant driver method. One of these is
169 in drivers/demo/demo-simple.c:
171 static int simple_hello(struct udevice *dev, int ch)
173 const struct dm_demo_pdata *pdata = dev_get_platdata(dev);
175 printf("Hello from %08x: %s %d\n", map_to_sysmem(dev),
176 pdata->colour, pdata->sides);
182 So that is a trip from top (command execution) to bottom (driver action)
183 but it leaves a lot of topics to address.
189 A driver declaration looks something like this (see
190 drivers/demo/demo-shape.c):
192 static const struct demo_ops shape_ops = {
193 .hello = shape_hello,
194 .status = shape_status,
197 U_BOOT_DRIVER(demo_shape_drv) = {
198 .name = "demo_shape_drv",
201 .priv_data_size = sizeof(struct shape_data),
205 This driver has two methods (hello and status) and requires a bit of
206 private data (accessible through dev_get_priv(dev) once the driver has
207 been probed). It is a member of UCLASS_DEMO so will register itself
210 In U_BOOT_DRIVER it is also possible to specify special methods for bind
211 and unbind, and these are called at appropriate times. For many drivers
212 it is hoped that only 'probe' and 'remove' will be needed.
214 The U_BOOT_DRIVER macro creates a data structure accessible from C,
215 so driver model can find the drivers that are available.
217 The methods a device can provide are documented in the device.h header.
220 bind - make the driver model aware of a device (bind it to its driver)
221 unbind - make the driver model forget the device
222 ofdata_to_platdata - convert device tree data to platdata - see later
223 probe - make a device ready for use
224 remove - remove a device so it cannot be used until probed again
226 The sequence to get a device to work is bind, ofdata_to_platdata (if using
227 device tree) and probe.
233 Platform data is like Linux platform data, if you are familiar with that.
234 It provides the board-specific information to start up a device.
236 Why is this information not just stored in the device driver itself? The
237 idea is that the device driver is generic, and can in principle operate on
238 any board that has that type of device. For example, with modern
239 highly-complex SoCs it is common for the IP to come from an IP vendor, and
240 therefore (for example) the MMC controller may be the same on chips from
241 different vendors. It makes no sense to write independent drivers for the
242 MMC controller on each vendor's SoC, when they are all almost the same.
243 Similarly, we may have 6 UARTs in an SoC, all of which are mostly the same,
244 but lie at different addresses in the address space.
246 Using the UART example, we have a single driver and it is instantiated 6
247 times by supplying 6 lots of platform data. Each lot of platform data
248 gives the driver name and a pointer to a structure containing information
249 about this instance - e.g. the address of the register space. It may be that
250 one of the UARTS supports RS-485 operation - this can be added as a flag in
251 the platform data, which is set for this one port and clear for the rest.
253 Think of your driver as a generic piece of code which knows how to talk to
254 a device, but needs to know where it is, any variant/option information and
255 so on. Platform data provides this link between the generic piece of code
256 and the specific way it is bound on a particular board.
258 Examples of platform data include:
260 - The base address of the IP block's register space
261 - Configuration options, like:
262 - the SPI polarity and maximum speed for a SPI controller
263 - the I2C speed to use for an I2C device
264 - the number of GPIOs available in a GPIO device
266 Where does the platform data come from? It is either held in a structure
267 which is compiled into U-Boot, or it can be parsed from the Device Tree
268 (see 'Device Tree' below).
270 For an example of how it can be compiled in, see demo-pdata.c which
271 sets up a table of driver names and their associated platform data.
272 The data can be interpreted by the drivers however they like - it is
273 basically a communication scheme between the board-specific code and
274 the generic drivers, which are intended to work on any board.
276 Drivers can access their data via dev->info->platdata. Here is
277 the declaration for the platform data, which would normally appear
280 static const struct dm_demo_cdata red_square = {
284 static const struct driver_info info[] = {
286 .name = "demo_shape_drv",
287 .platdata = &red_square,
291 demo1 = driver_bind(root, &info[0]);
297 While platdata is useful, a more flexible way of providing device data is
298 by using device tree. With device tree we replace the above code with the
299 following device tree fragment:
302 compatible = "demo-shape";
307 This means that instead of having lots of U_BOOT_DEVICE() declarations in
308 the board file, we put these in the device tree. This approach allows a lot
309 more generality, since the same board file can support many types of boards
310 (e,g. with the same SoC) just by using different device trees. An added
311 benefit is that the Linux device tree can be used, thus further simplifying
312 the task of board-bring up either for U-Boot or Linux devs (whoever gets to
315 The easiest way to make this work it to add a few members to the driver:
317 .platdata_auto_alloc_size = sizeof(struct dm_test_pdata),
318 .ofdata_to_platdata = testfdt_ofdata_to_platdata,
320 The 'auto_alloc' feature allowed space for the platdata to be allocated
321 and zeroed before the driver's ofdata_to_platdata() method is called. The
322 ofdata_to_platdata() method, which the driver write supplies, should parse
323 the device tree node for this device and place it in dev->platdata. Thus
324 when the probe method is called later (to set up the device ready for use)
325 the platform data will be present.
327 Note that both methods are optional. If you provide an ofdata_to_platdata
328 method then it will be called first (during activation). If you provide a
329 probe method it will be called next. See Driver Lifecycle below for more
332 If you don't want to have the platdata automatically allocated then you
333 can leave out platdata_auto_alloc_size. In this case you can use malloc
334 in your ofdata_to_platdata (or probe) method to allocate the required memory,
335 and you should free it in the remove method.
341 The demo uclass is declared like this:
343 U_BOOT_CLASS(demo) = {
347 It is also possible to specify special methods for probe, etc. The uclass
348 numbering comes from include/dm/uclass.h. To add a new uclass, add to the
349 end of the enum there, then declare your uclass as above.
352 Device Sequence Numbers
353 -----------------------
355 U-Boot numbers devices from 0 in many situations, such as in the command
356 line for I2C and SPI buses, and the device names for serial ports (serial0,
357 serial1, ...). Driver model supports this numbering and permits devices
358 to be locating by their 'sequence'.
360 Sequence numbers start from 0 but gaps are permitted. For example, a board
361 may have I2C buses 0, 1, 4, 5 but no 2 or 3. The choice of how devices are
362 numbered is up to a particular board, and may be set by the SoC in some
363 cases. While it might be tempting to automatically renumber the devices
364 where there are gaps in the sequence, this can lead to confusion and is
365 not the way that U-Boot works.
367 Each device can request a sequence number. If none is required then the
368 device will be automatically allocated the next available sequence number.
370 To specify the sequence number in the device tree an alias is typically
374 serial2 = "/serial@22230000";
377 This indicates that in the uclass called "serial", the named node
378 ("/serial@22230000") will be given sequence number 2. Any command or driver
379 which requests serial device 2 will obtain this device.
381 Some devices represent buses where the devices on the bus are numbered or
382 addressed. For example, SPI typically numbers its slaves from 0, and I2C
383 uses a 7-bit address. In these cases the 'reg' property of the subnode is
388 spi2 = "/spi@22300000";
392 #address-cells = <1>;
403 In this case we have a SPI bus with two slaves at 0 and 1. The SPI bus
404 itself is numbered 2. So we might access the SPI flash with:
412 These commands simply need to look up the 2nd device in the SPI uclass to
413 find the right SPI bus. Then, they look at the children of that bus for the
414 right sequence number (0 or 1 in this case).
416 Typically the alias method is used for top-level nodes and the 'reg' method
417 is used only for buses.
419 Device sequence numbers are resolved when a device is probed. Before then
420 the sequence number is only a request which may or may not be honoured,
421 depending on what other devices have been probed. However the numbering is
422 entirely under the control of the board author so a conflict is generally
429 Here are the stages that a device goes through in driver model. Note that all
430 methods mentioned here are optional - e.g. if there is no probe() method for
431 a device then it will not be called. A simple device may have very few
432 methods actually defined.
436 A device and its driver are bound using one of these two methods:
438 - Scan the U_BOOT_DEVICE() definitions. U-Boot It looks up the
439 name specified by each, to find the appropriate driver. It then calls
440 device_bind() to create a new device and bind' it to its driver. This will
441 call the device's bind() method.
443 - Scan through the device tree definitions. U-Boot looks at top-level
444 nodes in the the device tree. It looks at the compatible string in each node
445 and uses the of_match part of the U_BOOT_DRIVER() structure to find the
446 right driver for each node. It then calls device_bind() to bind the
447 newly-created device to its driver (thereby creating a device structure).
448 This will also call the device's bind() method.
450 At this point all the devices are known, and bound to their drivers. There
451 is a 'struct udevice' allocated for all devices. However, nothing has been
452 activated (except for the root device). Each bound device that was created
453 from a U_BOOT_DEVICE() declaration will hold the platdata pointer specified
454 in that declaration. For a bound device created from the device tree,
455 platdata will be NULL, but of_offset will be the offset of the device tree
456 node that caused the device to be created. The uclass is set correctly for
459 The device's bind() method is permitted to perform simple actions, but
460 should not scan the device tree node, not initialise hardware, nor set up
461 structures or allocate memory. All of these tasks should be left for
464 Note that compared to Linux, U-Boot's driver model has a separate step of
465 probe/remove which is independent of bind/unbind. This is partly because in
466 U-Boot it may be expensive to probe devices and we don't want to do it until
467 they are needed, or perhaps until after relocation.
471 When a device needs to be used, U-Boot activates it, by following these
472 steps (see device_probe()):
474 a. If priv_auto_alloc_size is non-zero, then the device-private space
475 is allocated for the device and zeroed. It will be accessible as
476 dev->priv. The driver can put anything it likes in there, but should use
477 it for run-time information, not platform data (which should be static
478 and known before the device is probed).
480 b. If platdata_auto_alloc_size is non-zero, then the platform data space
481 is allocated. This is only useful for device tree operation, since
482 otherwise you would have to specific the platform data in the
483 U_BOOT_DEVICE() declaration. The space is allocated for the device and
484 zeroed. It will be accessible as dev->platdata.
486 c. If the device's uclass specifies a non-zero per_device_auto_alloc_size,
487 then this space is allocated and zeroed also. It is allocated for and
488 stored in the device, but it is uclass data. owned by the uclass driver.
489 It is possible for the device to access it.
491 d. All parent devices are probed. It is not possible to activate a device
492 unless its predecessors (all the way up to the root device) are activated.
493 This means (for example) that an I2C driver will require that its bus
496 e. The device's sequence number is assigned, either the requested one
497 (assuming no conflicts) or the next available one if there is a conflict
498 or nothing particular is requested.
500 f. If the driver provides an ofdata_to_platdata() method, then this is
501 called to convert the device tree data into platform data. This should
502 do various calls like fdtdec_get_int(gd->fdt_blob, dev->of_offset, ...)
503 to access the node and store the resulting information into dev->platdata.
504 After this point, the device works the same way whether it was bound
505 using a device tree node or U_BOOT_DEVICE() structure. In either case,
506 the platform data is now stored in the platdata structure. Typically you
507 will use the platdata_auto_alloc_size feature to specify the size of the
508 platform data structure, and U-Boot will automatically allocate and zero
509 it for you before entry to ofdata_to_platdata(). But if not, you can
510 allocate it yourself in ofdata_to_platdata(). Note that it is preferable
511 to do all the device tree decoding in ofdata_to_platdata() rather than
512 in probe(). (Apart from the ugliness of mixing configuration and run-time
513 data, one day it is possible that U-Boot will cache platformat data for
514 devices which are regularly de/activated).
516 g. The device's probe() method is called. This should do anything that
517 is required by the device to get it going. This could include checking
518 that the hardware is actually present, setting up clocks for the
519 hardware and setting up hardware registers to initial values. The code
520 in probe() can access:
522 - platform data in dev->platdata (for configuration)
523 - private data in dev->priv (for run-time state)
524 - uclass data in dev->uclass_priv (for things the uclass stores
527 Note: If you don't use priv_auto_alloc_size then you will need to
528 allocate the priv space here yourself. The same applies also to
529 platdata_auto_alloc_size. Remember to free them in the remove() method.
531 h. The device is marked 'activated'
533 i. The uclass's post_probe() method is called, if one exists. This may
534 cause the uclass to do some housekeeping to record the device as
535 activated and 'known' by the uclass.
539 The device is now activated and can be used. From now until it is removed
540 all of the above structures are accessible. The device appears in the
541 uclass's list of devices (so if the device is in UCLASS_GPIO it will appear
542 as a device in the GPIO uclass). This is the 'running' state of the device.
546 When the device is no-longer required, you can call device_remove() to
547 remove it. This performs the probe steps in reverse:
549 a. The uclass's pre_remove() method is called, if one exists. This may
550 cause the uclass to do some housekeeping to record the device as
551 deactivated and no-longer 'known' by the uclass.
553 b. All the device's children are removed. It is not permitted to have
554 an active child device with a non-active parent. This means that
555 device_remove() is called for all the children recursively at this point.
557 c. The device's remove() method is called. At this stage nothing has been
558 deallocated so platform data, private data and the uclass data will all
559 still be present. This is where the hardware can be shut down. It is
560 intended that the device be completely inactive at this point, For U-Boot
561 to be sure that no hardware is running, it should be enough to remove
564 d. The device memory is freed (platform data, private data, uclass data).
566 Note: Because the platform data for a U_BOOT_DEVICE() is defined with a
567 static pointer, it is not de-allocated during the remove() method. For
568 a device instantiated using the device tree data, the platform data will
569 be dynamically allocated, and thus needs to be deallocated during the
570 remove() method, either:
572 1. if the platdata_auto_alloc_size is non-zero, the deallocation
573 happens automatically within the driver model core; or
575 2. when platdata_auto_alloc_size is 0, both the allocation (in probe()
576 or preferably ofdata_to_platdata()) and the deallocation in remove()
577 are the responsibility of the driver author.
579 e. The device sequence number is set to -1, meaning that it no longer
580 has an allocated sequence. If the device is later reactivated and that
581 sequence number is still free, it may well receive the name sequence
582 number again. But from this point, the sequence number previously used
583 by this device will no longer exist (think of SPI bus 2 being removed
584 and bus 2 is no longer available for use).
586 f. The device is marked inactive. Note that it is still bound, so the
587 device structure itself is not freed at this point. Should the device be
588 activated again, then the cycle starts again at step 2 above.
592 The device is unbound. This is the step that actually destroys the device.
593 If a parent has children these will be destroyed first. After this point
594 the device does not exist and its memory has be deallocated.
600 Driver model uses a doubly-linked list as the basic data structure. Some
601 nodes have several lists running through them. Creating a more efficient
602 data structure might be worthwhile in some rare cases, once we understand
603 what the bottlenecks are.
609 For the record, this implementation uses a very similar approach to the
610 original patches, but makes at least the following changes:
612 - Tried to aggressively remove boilerplate, so that for most drivers there
613 is little or no 'driver model' code to write.
614 - Moved some data from code into data structure - e.g. store a pointer to
615 the driver operations structure in the driver, rather than passing it
616 to the driver bind function.
617 - Rename some structures to make them more similar to Linux (struct udevice
618 instead of struct instance, struct platdata, etc.)
619 - Change the name 'core' to 'uclass', meaning U-Boot class. It seems that
620 this concept relates to a class of drivers (or a subsystem). We shouldn't
621 use 'class' since it is a C++ reserved word, so U-Boot class (uclass) seems
623 - Remove 'struct driver_instance' and just use a single 'struct udevice'.
624 This removes a level of indirection that doesn't seem necessary.
625 - Built in device tree support, to avoid the need for platdata
626 - Removed the concept of driver relocation, and just make it possible for
627 the new driver (created after relocation) to access the old driver data.
628 I feel that relocation is a very special case and will only apply to a few
629 drivers, many of which can/will just re-init anyway. So the overhead of
630 dealing with this might not be worth it.
631 - Implemented a GPIO system, trying to keep it simple
634 Pre-Relocation Support
635 ----------------------
637 For pre-relocation we simply call the driver model init function. Only
638 drivers marked with DM_FLAG_PRE_RELOC or the device tree
639 'u-boot,dm-pre-reloc' flag are initialised prior to relocation. This helps
640 to reduce the driver model overhead.
642 Then post relocation we throw that away and re-init driver model again.
643 For drivers which require some sort of continuity between pre- and
644 post-relocation devices, we can provide access to the pre-relocation
645 device pointers, but this is not currently implemented (the root device
646 pointer is saved but not made available through the driver model API).
649 Things to punt for later
650 ------------------------
652 - SPL support - this will have to be present before many drivers can be
653 converted, but it seems like we can add it once we are happy with the
656 That is not to say that no thinking has gone into this - in fact there
657 is quite a lot there. However, getting these right is non-trivial and
658 there is a high cost associated with going down the wrong path.
660 For SPL, it may be possible to fit in a simplified driver model with only
661 bind and probe methods, to reduce size.
663 Uclasses are statically numbered at compile time. It would be possible to
664 change this to dynamic numbering, but then we would require some sort of
665 lookup service, perhaps searching by name. This is slightly less efficient
666 so has been left out for now. One small advantage of dynamic numbering might
667 be fewer merge conflicts in uclass-id.h.