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:
39 make sandbox_defconfig
41 ./u-boot -d u-boot.dtb
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 29 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_bus_children_funcs
106 Test: dm_test_bus_children_iterators
107 Test: dm_test_bus_parent_data
108 Test: dm_test_bus_parent_ops
109 Test: dm_test_children
111 Device 'd-test': seq 3 is in use by 'b-test'
112 Test: dm_test_fdt_offset
113 Test: dm_test_fdt_pre_reloc
114 Test: dm_test_fdt_uclass_seq
115 Device 'd-test': seq 3 is in use by 'b-test'
116 Device 'a-test': seq 0 is in use by 'd-test'
118 extra-gpios: get_value: error: gpio b5 not reserved
119 Test: dm_test_gpio_anon
120 Test: dm_test_gpio_copy
121 Test: dm_test_gpio_leak
122 extra-gpios: get_value: error: gpio b5 not reserved
123 Test: dm_test_gpio_requestf
125 Test: dm_test_lifecycle
126 Test: dm_test_operations
127 Test: dm_test_ordering
128 Test: dm_test_platdata
129 Test: dm_test_pre_reloc
131 Test: dm_test_spi_find
132 Invalid chip select 0:0 (err=-19)
133 SF: Failed to get idcodes
134 Device 'name-emul': seq 0 is in use by 'name-emul'
135 SF: Detected M25P16 with page size 256 Bytes, erase size 64 KiB, total 2 MiB
136 Test: dm_test_spi_flash
137 2097152 bytes written in 0 ms
138 SF: Detected M25P16 with page size 256 Bytes, erase size 64 KiB, total 2 MiB
140 0 erase: 0 ticks, 65536000 KiB/s 524288.000 Mbps
141 1 check: 0 ticks, 65536000 KiB/s 524288.000 Mbps
142 2 write: 0 ticks, 65536000 KiB/s 524288.000 Mbps
143 3 read: 0 ticks, 65536000 KiB/s 524288.000 Mbps
145 0 erase: 0 ticks, 65536000 KiB/s 524288.000 Mbps
146 1 check: 0 ticks, 65536000 KiB/s 524288.000 Mbps
147 2 write: 0 ticks, 65536000 KiB/s 524288.000 Mbps
148 3 read: 0 ticks, 65536000 KiB/s 524288.000 Mbps
149 Test: dm_test_spi_xfer
150 SF: Detected M25P16 with page size 256 Bytes, erase size 64 KiB, total 2 MiB
152 Test: dm_test_uclass_before_ready
159 Let's start at the top. The demo command is in common/cmd_demo.c. It does
160 the usual command processing and then:
162 struct udevice *demo_dev;
164 ret = uclass_get_device(UCLASS_DEMO, devnum, &demo_dev);
166 UCLASS_DEMO means the class of devices which implement 'demo'. Other
167 classes might be MMC, or GPIO, hashing or serial. The idea is that the
168 devices in the class all share a particular way of working. The class
169 presents a unified view of all these devices to U-Boot.
171 This function looks up a device for the demo uclass. Given a device
172 number we can find the device because all devices have registered with
173 the UCLASS_DEMO uclass.
175 The device is automatically activated ready for use by uclass_get_device().
177 Now that we have the device we can do things like:
179 return demo_hello(demo_dev, ch);
181 This function is in the demo uclass. It takes care of calling the 'hello'
182 method of the relevant driver. Bearing in mind that there are two drivers,
183 this particular device may use one or other of them.
185 The code for demo_hello() is in drivers/demo/demo-uclass.c:
187 int demo_hello(struct udevice *dev, int ch)
189 const struct demo_ops *ops = device_get_ops(dev);
194 return ops->hello(dev, ch);
197 As you can see it just calls the relevant driver method. One of these is
198 in drivers/demo/demo-simple.c:
200 static int simple_hello(struct udevice *dev, int ch)
202 const struct dm_demo_pdata *pdata = dev_get_platdata(dev);
204 printf("Hello from %08x: %s %d\n", map_to_sysmem(dev),
205 pdata->colour, pdata->sides);
211 So that is a trip from top (command execution) to bottom (driver action)
212 but it leaves a lot of topics to address.
218 A driver declaration looks something like this (see
219 drivers/demo/demo-shape.c):
221 static const struct demo_ops shape_ops = {
222 .hello = shape_hello,
223 .status = shape_status,
226 U_BOOT_DRIVER(demo_shape_drv) = {
227 .name = "demo_shape_drv",
230 .priv_data_size = sizeof(struct shape_data),
234 This driver has two methods (hello and status) and requires a bit of
235 private data (accessible through dev_get_priv(dev) once the driver has
236 been probed). It is a member of UCLASS_DEMO so will register itself
239 In U_BOOT_DRIVER it is also possible to specify special methods for bind
240 and unbind, and these are called at appropriate times. For many drivers
241 it is hoped that only 'probe' and 'remove' will be needed.
243 The U_BOOT_DRIVER macro creates a data structure accessible from C,
244 so driver model can find the drivers that are available.
246 The methods a device can provide are documented in the device.h header.
249 bind - make the driver model aware of a device (bind it to its driver)
250 unbind - make the driver model forget the device
251 ofdata_to_platdata - convert device tree data to platdata - see later
252 probe - make a device ready for use
253 remove - remove a device so it cannot be used until probed again
255 The sequence to get a device to work is bind, ofdata_to_platdata (if using
256 device tree) and probe.
262 Platform data is like Linux platform data, if you are familiar with that.
263 It provides the board-specific information to start up a device.
265 Why is this information not just stored in the device driver itself? The
266 idea is that the device driver is generic, and can in principle operate on
267 any board that has that type of device. For example, with modern
268 highly-complex SoCs it is common for the IP to come from an IP vendor, and
269 therefore (for example) the MMC controller may be the same on chips from
270 different vendors. It makes no sense to write independent drivers for the
271 MMC controller on each vendor's SoC, when they are all almost the same.
272 Similarly, we may have 6 UARTs in an SoC, all of which are mostly the same,
273 but lie at different addresses in the address space.
275 Using the UART example, we have a single driver and it is instantiated 6
276 times by supplying 6 lots of platform data. Each lot of platform data
277 gives the driver name and a pointer to a structure containing information
278 about this instance - e.g. the address of the register space. It may be that
279 one of the UARTS supports RS-485 operation - this can be added as a flag in
280 the platform data, which is set for this one port and clear for the rest.
282 Think of your driver as a generic piece of code which knows how to talk to
283 a device, but needs to know where it is, any variant/option information and
284 so on. Platform data provides this link between the generic piece of code
285 and the specific way it is bound on a particular board.
287 Examples of platform data include:
289 - The base address of the IP block's register space
290 - Configuration options, like:
291 - the SPI polarity and maximum speed for a SPI controller
292 - the I2C speed to use for an I2C device
293 - the number of GPIOs available in a GPIO device
295 Where does the platform data come from? It is either held in a structure
296 which is compiled into U-Boot, or it can be parsed from the Device Tree
297 (see 'Device Tree' below).
299 For an example of how it can be compiled in, see demo-pdata.c which
300 sets up a table of driver names and their associated platform data.
301 The data can be interpreted by the drivers however they like - it is
302 basically a communication scheme between the board-specific code and
303 the generic drivers, which are intended to work on any board.
305 Drivers can access their data via dev->info->platdata. Here is
306 the declaration for the platform data, which would normally appear
309 static const struct dm_demo_cdata red_square = {
313 static const struct driver_info info[] = {
315 .name = "demo_shape_drv",
316 .platdata = &red_square,
320 demo1 = driver_bind(root, &info[0]);
326 While platdata is useful, a more flexible way of providing device data is
327 by using device tree. With device tree we replace the above code with the
328 following device tree fragment:
331 compatible = "demo-shape";
336 This means that instead of having lots of U_BOOT_DEVICE() declarations in
337 the board file, we put these in the device tree. This approach allows a lot
338 more generality, since the same board file can support many types of boards
339 (e,g. with the same SoC) just by using different device trees. An added
340 benefit is that the Linux device tree can be used, thus further simplifying
341 the task of board-bring up either for U-Boot or Linux devs (whoever gets to
344 The easiest way to make this work it to add a few members to the driver:
346 .platdata_auto_alloc_size = sizeof(struct dm_test_pdata),
347 .ofdata_to_platdata = testfdt_ofdata_to_platdata,
349 The 'auto_alloc' feature allowed space for the platdata to be allocated
350 and zeroed before the driver's ofdata_to_platdata() method is called. The
351 ofdata_to_platdata() method, which the driver write supplies, should parse
352 the device tree node for this device and place it in dev->platdata. Thus
353 when the probe method is called later (to set up the device ready for use)
354 the platform data will be present.
356 Note that both methods are optional. If you provide an ofdata_to_platdata
357 method then it will be called first (during activation). If you provide a
358 probe method it will be called next. See Driver Lifecycle below for more
361 If you don't want to have the platdata automatically allocated then you
362 can leave out platdata_auto_alloc_size. In this case you can use malloc
363 in your ofdata_to_platdata (or probe) method to allocate the required memory,
364 and you should free it in the remove method.
366 The driver model tree is intended to mirror that of the device tree. The
367 root driver is at device tree offset 0 (the root node, '/'), and its
368 children are the children of the root node.
374 The demo uclass is declared like this:
376 U_BOOT_CLASS(demo) = {
380 It is also possible to specify special methods for probe, etc. The uclass
381 numbering comes from include/dm/uclass.h. To add a new uclass, add to the
382 end of the enum there, then declare your uclass as above.
385 Device Sequence Numbers
386 -----------------------
388 U-Boot numbers devices from 0 in many situations, such as in the command
389 line for I2C and SPI buses, and the device names for serial ports (serial0,
390 serial1, ...). Driver model supports this numbering and permits devices
391 to be locating by their 'sequence'. This numbering uniquely identifies a
392 device in its uclass, so no two devices within a particular uclass can have
393 the same sequence number.
395 Sequence numbers start from 0 but gaps are permitted. For example, a board
396 may have I2C buses 1, 4, 5 but no 0, 2 or 3. The choice of how devices are
397 numbered is up to a particular board, and may be set by the SoC in some
398 cases. While it might be tempting to automatically renumber the devices
399 where there are gaps in the sequence, this can lead to confusion and is
400 not the way that U-Boot works.
402 Each device can request a sequence number. If none is required then the
403 device will be automatically allocated the next available sequence number.
405 To specify the sequence number in the device tree an alias is typically
406 used. Make sure that the uclass has the DM_UC_FLAG_SEQ_ALIAS flag set.
409 serial2 = "/serial@22230000";
412 This indicates that in the uclass called "serial", the named node
413 ("/serial@22230000") will be given sequence number 2. Any command or driver
414 which requests serial device 2 will obtain this device.
416 More commonly you can use node references, which expand to the full path:
422 serial_2: serial@22230000 {
426 The alias resolves to the same string in this case, but this version is
429 Device sequence numbers are resolved when a device is probed. Before then
430 the sequence number is only a request which may or may not be honoured,
431 depending on what other devices have been probed. However the numbering is
432 entirely under the control of the board author so a conflict is generally
439 A common use of driver model is to implement a bus, a device which provides
440 access to other devices. Example of buses include SPI and I2C. Typically
441 the bus provides some sort of transport or translation that makes it
442 possible to talk to the devices on the bus.
444 Driver model provides a few useful features to help with implementing
445 buses. Firstly, a bus can request that its children store some 'parent
446 data' which can be used to keep track of child state. Secondly, the bus can
447 define methods which are called when a child is probed or removed. This is
448 similar to the methods the uclass driver provides.
450 Here an explanation of how a bus fits with a uclass may be useful. Consider
451 a USB bus with several devices attached to it, each from a different (made
454 xhci_usb (UCLASS_USB)
455 eth (UCLASS_ETHERNET)
456 camera (UCLASS_CAMERA)
457 flash (UCLASS_FLASH_STORAGE)
459 Each of the devices is connected to a different address on the USB bus.
460 The bus device wants to store this address and some other information such
461 as the bus speed for each device.
463 To achieve this, the bus device can use dev->parent_priv in each of its
464 three children. This can be auto-allocated if the bus driver has a non-zero
465 value for per_child_auto_alloc_size. If not, then the bus device can
466 allocate the space itself before the child device is probed.
468 Also the bus driver can define the child_pre_probe() and child_post_remove()
469 methods to allow it to do some processing before the child is activated or
470 after it is deactivated.
472 Note that the information that controls this behaviour is in the bus's
473 driver, not the child's. In fact it is possible that child has no knowledge
474 that it is connected to a bus. The same child device may even be used on two
475 different bus types. As an example. the 'flash' device shown above may also
476 be connected on a SATA bus or standalone with no bus:
478 xhci_usb (UCLASS_USB)
479 flash (UCLASS_FLASH_STORAGE) - parent data/methods defined by USB bus
482 flash (UCLASS_FLASH_STORAGE) - parent data/methods defined by SATA bus
484 flash (UCLASS_FLASH_STORAGE) - no parent data/methods (not on a bus)
486 Above you can see that the driver for xhci_usb/sata controls the child's
487 bus methods. In the third example the device is not on a bus, and therefore
488 will not have these methods at all. Consider the case where the flash
489 device defines child methods. These would be used for *its* children, and
490 would be quite separate from the methods defined by the driver for the bus
491 that the flash device is connetced to. The act of attaching a device to a
492 parent device which is a bus, causes the device to start behaving like a
493 bus device, regardless of its own views on the matter.
495 The uclass for the device can also contain data private to that uclass.
496 But note that each device on the bus may be a memeber of a different
497 uclass, and this data has nothing to do with the child data for each child
504 Here are the stages that a device goes through in driver model. Note that all
505 methods mentioned here are optional - e.g. if there is no probe() method for
506 a device then it will not be called. A simple device may have very few
507 methods actually defined.
511 A device and its driver are bound using one of these two methods:
513 - Scan the U_BOOT_DEVICE() definitions. U-Boot It looks up the
514 name specified by each, to find the appropriate driver. It then calls
515 device_bind() to create a new device and bind' it to its driver. This will
516 call the device's bind() method.
518 - Scan through the device tree definitions. U-Boot looks at top-level
519 nodes in the the device tree. It looks at the compatible string in each node
520 and uses the of_match part of the U_BOOT_DRIVER() structure to find the
521 right driver for each node. It then calls device_bind() to bind the
522 newly-created device to its driver (thereby creating a device structure).
523 This will also call the device's bind() method.
525 At this point all the devices are known, and bound to their drivers. There
526 is a 'struct udevice' allocated for all devices. However, nothing has been
527 activated (except for the root device). Each bound device that was created
528 from a U_BOOT_DEVICE() declaration will hold the platdata pointer specified
529 in that declaration. For a bound device created from the device tree,
530 platdata will be NULL, but of_offset will be the offset of the device tree
531 node that caused the device to be created. The uclass is set correctly for
534 The device's bind() method is permitted to perform simple actions, but
535 should not scan the device tree node, not initialise hardware, nor set up
536 structures or allocate memory. All of these tasks should be left for
539 Note that compared to Linux, U-Boot's driver model has a separate step of
540 probe/remove which is independent of bind/unbind. This is partly because in
541 U-Boot it may be expensive to probe devices and we don't want to do it until
542 they are needed, or perhaps until after relocation.
546 When a device needs to be used, U-Boot activates it, by following these
547 steps (see device_probe()):
549 a. If priv_auto_alloc_size is non-zero, then the device-private space
550 is allocated for the device and zeroed. It will be accessible as
551 dev->priv. The driver can put anything it likes in there, but should use
552 it for run-time information, not platform data (which should be static
553 and known before the device is probed).
555 b. If platdata_auto_alloc_size is non-zero, then the platform data space
556 is allocated. This is only useful for device tree operation, since
557 otherwise you would have to specific the platform data in the
558 U_BOOT_DEVICE() declaration. The space is allocated for the device and
559 zeroed. It will be accessible as dev->platdata.
561 c. If the device's uclass specifies a non-zero per_device_auto_alloc_size,
562 then this space is allocated and zeroed also. It is allocated for and
563 stored in the device, but it is uclass data. owned by the uclass driver.
564 It is possible for the device to access it.
566 d. If the device's immediate parent specifies a per_child_auto_alloc_size
567 then this space is allocated. This is intended for use by the parent
568 device to keep track of things related to the child. For example a USB
569 flash stick attached to a USB host controller would likely use this
570 space. The controller can hold information about the USB state of each
573 e. All parent devices are probed. It is not possible to activate a device
574 unless its predecessors (all the way up to the root device) are activated.
575 This means (for example) that an I2C driver will require that its bus
578 f. The device's sequence number is assigned, either the requested one
579 (assuming no conflicts) or the next available one if there is a conflict
580 or nothing particular is requested.
582 g. If the driver provides an ofdata_to_platdata() method, then this is
583 called to convert the device tree data into platform data. This should
584 do various calls like fdtdec_get_int(gd->fdt_blob, dev->of_offset, ...)
585 to access the node and store the resulting information into dev->platdata.
586 After this point, the device works the same way whether it was bound
587 using a device tree node or U_BOOT_DEVICE() structure. In either case,
588 the platform data is now stored in the platdata structure. Typically you
589 will use the platdata_auto_alloc_size feature to specify the size of the
590 platform data structure, and U-Boot will automatically allocate and zero
591 it for you before entry to ofdata_to_platdata(). But if not, you can
592 allocate it yourself in ofdata_to_platdata(). Note that it is preferable
593 to do all the device tree decoding in ofdata_to_platdata() rather than
594 in probe(). (Apart from the ugliness of mixing configuration and run-time
595 data, one day it is possible that U-Boot will cache platformat data for
596 devices which are regularly de/activated).
598 h. The device's probe() method is called. This should do anything that
599 is required by the device to get it going. This could include checking
600 that the hardware is actually present, setting up clocks for the
601 hardware and setting up hardware registers to initial values. The code
602 in probe() can access:
604 - platform data in dev->platdata (for configuration)
605 - private data in dev->priv (for run-time state)
606 - uclass data in dev->uclass_priv (for things the uclass stores
609 Note: If you don't use priv_auto_alloc_size then you will need to
610 allocate the priv space here yourself. The same applies also to
611 platdata_auto_alloc_size. Remember to free them in the remove() method.
613 i. The device is marked 'activated'
615 j. The uclass's post_probe() method is called, if one exists. This may
616 cause the uclass to do some housekeeping to record the device as
617 activated and 'known' by the uclass.
621 The device is now activated and can be used. From now until it is removed
622 all of the above structures are accessible. The device appears in the
623 uclass's list of devices (so if the device is in UCLASS_GPIO it will appear
624 as a device in the GPIO uclass). This is the 'running' state of the device.
628 When the device is no-longer required, you can call device_remove() to
629 remove it. This performs the probe steps in reverse:
631 a. The uclass's pre_remove() method is called, if one exists. This may
632 cause the uclass to do some housekeeping to record the device as
633 deactivated and no-longer 'known' by the uclass.
635 b. All the device's children are removed. It is not permitted to have
636 an active child device with a non-active parent. This means that
637 device_remove() is called for all the children recursively at this point.
639 c. The device's remove() method is called. At this stage nothing has been
640 deallocated so platform data, private data and the uclass data will all
641 still be present. This is where the hardware can be shut down. It is
642 intended that the device be completely inactive at this point, For U-Boot
643 to be sure that no hardware is running, it should be enough to remove
646 d. The device memory is freed (platform data, private data, uclass data,
649 Note: Because the platform data for a U_BOOT_DEVICE() is defined with a
650 static pointer, it is not de-allocated during the remove() method. For
651 a device instantiated using the device tree data, the platform data will
652 be dynamically allocated, and thus needs to be deallocated during the
653 remove() method, either:
655 1. if the platdata_auto_alloc_size is non-zero, the deallocation
656 happens automatically within the driver model core; or
658 2. when platdata_auto_alloc_size is 0, both the allocation (in probe()
659 or preferably ofdata_to_platdata()) and the deallocation in remove()
660 are the responsibility of the driver author.
662 e. The device sequence number is set to -1, meaning that it no longer
663 has an allocated sequence. If the device is later reactivated and that
664 sequence number is still free, it may well receive the name sequence
665 number again. But from this point, the sequence number previously used
666 by this device will no longer exist (think of SPI bus 2 being removed
667 and bus 2 is no longer available for use).
669 f. The device is marked inactive. Note that it is still bound, so the
670 device structure itself is not freed at this point. Should the device be
671 activated again, then the cycle starts again at step 2 above.
675 The device is unbound. This is the step that actually destroys the device.
676 If a parent has children these will be destroyed first. After this point
677 the device does not exist and its memory has be deallocated.
683 Driver model uses a doubly-linked list as the basic data structure. Some
684 nodes have several lists running through them. Creating a more efficient
685 data structure might be worthwhile in some rare cases, once we understand
686 what the bottlenecks are.
692 For the record, this implementation uses a very similar approach to the
693 original patches, but makes at least the following changes:
695 - Tried to aggressively remove boilerplate, so that for most drivers there
696 is little or no 'driver model' code to write.
697 - Moved some data from code into data structure - e.g. store a pointer to
698 the driver operations structure in the driver, rather than passing it
699 to the driver bind function.
700 - Rename some structures to make them more similar to Linux (struct udevice
701 instead of struct instance, struct platdata, etc.)
702 - Change the name 'core' to 'uclass', meaning U-Boot class. It seems that
703 this concept relates to a class of drivers (or a subsystem). We shouldn't
704 use 'class' since it is a C++ reserved word, so U-Boot class (uclass) seems
706 - Remove 'struct driver_instance' and just use a single 'struct udevice'.
707 This removes a level of indirection that doesn't seem necessary.
708 - Built in device tree support, to avoid the need for platdata
709 - Removed the concept of driver relocation, and just make it possible for
710 the new driver (created after relocation) to access the old driver data.
711 I feel that relocation is a very special case and will only apply to a few
712 drivers, many of which can/will just re-init anyway. So the overhead of
713 dealing with this might not be worth it.
714 - Implemented a GPIO system, trying to keep it simple
717 Pre-Relocation Support
718 ----------------------
720 For pre-relocation we simply call the driver model init function. Only
721 drivers marked with DM_FLAG_PRE_RELOC or the device tree
722 'u-boot,dm-pre-reloc' flag are initialised prior to relocation. This helps
723 to reduce the driver model overhead.
725 Then post relocation we throw that away and re-init driver model again.
726 For drivers which require some sort of continuity between pre- and
727 post-relocation devices, we can provide access to the pre-relocation
728 device pointers, but this is not currently implemented (the root device
729 pointer is saved but not made available through the driver model API).
735 Driver model can operate in SPL. Its efficient implementation and small code
736 size provide for a small overhead which is acceptable for all but the most
739 To enable driver model in SPL, define CONFIG_SPL_DM. You might want to
740 consider the following option also. See the main README for more details.
742 - CONFIG_SYS_MALLOC_SIMPLE
744 - CONFIG_DM_DEVICE_REMOVE
748 Enabling Driver Model
749 ---------------------
751 Driver model is being brought into U-Boot gradually. As each subsystems gets
752 support, a uclass is created and a CONFIG to enable use of driver model for
755 For example CONFIG_DM_SERIAL enables driver model for serial. With that
756 defined, the old serial support is not enabled, and your serial driver must
757 conform to driver model. With that undefined, the old serial support is
758 enabled and driver model is not available for serial. This means that when
759 you convert a driver, you must either convert all its boards, or provide for
760 the driver to be compiled both with and without driver model (generally this
763 See the main README for full details of the available driver model CONFIG
767 Things to punt for later
768 ------------------------
770 Uclasses are statically numbered at compile time. It would be possible to
771 change this to dynamic numbering, but then we would require some sort of
772 lookup service, perhaps searching by name. This is slightly less efficient
773 so has been left out for now. One small advantage of dynamic numbering might
774 be fewer merge conflicts in uclass-id.h.