1.. SPDX-License-Identifier: GPL-2.0+ 2.. sectionauthor:: Simon Glass <sjg@chromium.org> 3 4Design Details 5============== 6 7This README contains high-level information about driver model, a unified 8way of declaring and accessing drivers in U-Boot. The original work was done 9by: 10 11 * Marek Vasut <marex@denx.de> 12 * Pavel Herrmann <morpheus.ibis@gmail.com> 13 * Viktor Křivák <viktor.krivak@gmail.com> 14 * Tomas Hlavacek <tmshlvck@gmail.com> 15 16This has been both simplified and extended into the current implementation 17by: 18 19 * Simon Glass <sjg@chromium.org> 20 21 22Terminology 23----------- 24 25Uclass 26 a group of devices which operate in the same way. A uclass provides 27 a way of accessing individual devices within the group, but always 28 using the same interface. For example a GPIO uclass provides 29 operations for get/set value. An I2C uclass may have 10 I2C ports, 30 4 with one driver, and 6 with another. 31 32Driver 33 some code which talks to a peripheral and presents a higher-level 34 interface to it. 35 36Device 37 an instance of a driver, tied to a particular port or peripheral. 38 39 40How to try it 41------------- 42 43Build U-Boot sandbox and run it:: 44 45 make sandbox_defconfig 46 make 47 ./u-boot -d u-boot.dtb 48 49 (type 'reset' to exit U-Boot) 50 51 52There is a uclass called 'demo'. This uclass handles 53saying hello, and reporting its status. There are two drivers in this 54uclass: 55 56 - simple: Just prints a message for hello, doesn't implement status 57 - shape: Prints shapes and reports number of characters printed as status 58 59The demo class is pretty simple, but not trivial. The intention is that it 60can be used for testing, so it will implement all driver model features and 61provide good code coverage of them. It does have multiple drivers, it 62handles parameter data and plat (data which tells the driver how 63to operate on a particular platform) and it uses private driver data. 64 65To try it, see the example session below:: 66 67 =>demo hello 1 68 Hello '@' from 07981110: red 4 69 =>demo status 2 70 Status: 0 71 =>demo hello 2 72 g 73 r@ 74 e@@ 75 e@@@ 76 n@@@@ 77 g@@@@@ 78 =>demo status 2 79 Status: 21 80 =>demo hello 4 ^ 81 y^^^ 82 e^^^^^ 83 l^^^^^^^ 84 l^^^^^^^ 85 o^^^^^ 86 w^^^ 87 =>demo status 4 88 Status: 36 89 => 90 91 92Running the tests 93----------------- 94 95The intent with driver model is that the core portion has 100% test coverage 96in sandbox, and every uclass has its own test. As a move towards this, tests 97are provided in test/dm. To run them, try:: 98 99 ./test/py/test.py --bd sandbox --build -k ut_dm -v 100 101You should see something like this:: 102 103 (venv)$ ./test/py/test.py --bd sandbox --build -k ut_dm -v 104 +make O=/root/u-boot/build-sandbox -s sandbox_defconfig 105 +make O=/root/u-boot/build-sandbox -s -j8 106 ============================= test session starts ============================== 107 platform linux2 -- Python 2.7.5, pytest-2.9.0, py-1.4.31, pluggy-0.3.1 -- /root/u-boot/venv/bin/python 108 cachedir: .cache 109 rootdir: /root/u-boot, inifile: 110 collected 199 items 111 112 test/py/tests/test_ut.py::test_ut_dm_init PASSED 113 test/py/tests/test_ut.py::test_ut[ut_dm_adc_bind] PASSED 114 test/py/tests/test_ut.py::test_ut[ut_dm_adc_multi_channel_conversion] PASSED 115 test/py/tests/test_ut.py::test_ut[ut_dm_adc_multi_channel_shot] PASSED 116 test/py/tests/test_ut.py::test_ut[ut_dm_adc_single_channel_conversion] PASSED 117 test/py/tests/test_ut.py::test_ut[ut_dm_adc_single_channel_shot] PASSED 118 test/py/tests/test_ut.py::test_ut[ut_dm_adc_supply] PASSED 119 test/py/tests/test_ut.py::test_ut[ut_dm_adc_wrong_channel_selection] PASSED 120 test/py/tests/test_ut.py::test_ut[ut_dm_autobind] PASSED 121 test/py/tests/test_ut.py::test_ut[ut_dm_autobind_uclass_pdata_alloc] PASSED 122 test/py/tests/test_ut.py::test_ut[ut_dm_autobind_uclass_pdata_valid] PASSED 123 test/py/tests/test_ut.py::test_ut[ut_dm_autoprobe] PASSED 124 test/py/tests/test_ut.py::test_ut[ut_dm_bus_child_post_bind] PASSED 125 test/py/tests/test_ut.py::test_ut[ut_dm_bus_child_post_bind_uclass] PASSED 126 test/py/tests/test_ut.py::test_ut[ut_dm_bus_child_pre_probe_uclass] PASSED 127 test/py/tests/test_ut.py::test_ut[ut_dm_bus_children] PASSED 128 test/py/tests/test_ut.py::test_ut[ut_dm_bus_children_funcs] PASSED 129 test/py/tests/test_ut.py::test_ut[ut_dm_bus_children_iterators] PASSED 130 test/py/tests/test_ut.py::test_ut[ut_dm_bus_parent_data] PASSED 131 test/py/tests/test_ut.py::test_ut[ut_dm_bus_parent_data_uclass] PASSED 132 test/py/tests/test_ut.py::test_ut[ut_dm_bus_parent_ops] PASSED 133 test/py/tests/test_ut.py::test_ut[ut_dm_bus_parent_platdata] PASSED 134 test/py/tests/test_ut.py::test_ut[ut_dm_bus_parent_platdata_uclass] PASSED 135 test/py/tests/test_ut.py::test_ut[ut_dm_children] PASSED 136 test/py/tests/test_ut.py::test_ut[ut_dm_clk_base] PASSED 137 test/py/tests/test_ut.py::test_ut[ut_dm_clk_periph] PASSED 138 test/py/tests/test_ut.py::test_ut[ut_dm_device_get_uclass_id] PASSED 139 test/py/tests/test_ut.py::test_ut[ut_dm_eth] PASSED 140 test/py/tests/test_ut.py::test_ut[ut_dm_eth_act] PASSED 141 test/py/tests/test_ut.py::test_ut[ut_dm_eth_alias] PASSED 142 test/py/tests/test_ut.py::test_ut[ut_dm_eth_prime] PASSED 143 test/py/tests/test_ut.py::test_ut[ut_dm_eth_rotate] PASSED 144 test/py/tests/test_ut.py::test_ut[ut_dm_fdt] PASSED 145 test/py/tests/test_ut.py::test_ut[ut_dm_fdt_offset] PASSED 146 test/py/tests/test_ut.py::test_ut[ut_dm_fdt_pre_reloc] PASSED 147 test/py/tests/test_ut.py::test_ut[ut_dm_fdt_uclass_seq] PASSED 148 test/py/tests/test_ut.py::test_ut[ut_dm_gpio] PASSED 149 test/py/tests/test_ut.py::test_ut[ut_dm_gpio_anon] PASSED 150 test/py/tests/test_ut.py::test_ut[ut_dm_gpio_copy] PASSED 151 test/py/tests/test_ut.py::test_ut[ut_dm_gpio_leak] PASSED 152 test/py/tests/test_ut.py::test_ut[ut_dm_gpio_phandles] PASSED 153 test/py/tests/test_ut.py::test_ut[ut_dm_gpio_requestf] PASSED 154 test/py/tests/test_ut.py::test_ut[ut_dm_i2c_bytewise] PASSED 155 test/py/tests/test_ut.py::test_ut[ut_dm_i2c_find] PASSED 156 test/py/tests/test_ut.py::test_ut[ut_dm_i2c_offset] PASSED 157 test/py/tests/test_ut.py::test_ut[ut_dm_i2c_offset_len] PASSED 158 test/py/tests/test_ut.py::test_ut[ut_dm_i2c_probe_empty] PASSED 159 test/py/tests/test_ut.py::test_ut[ut_dm_i2c_read_write] PASSED 160 test/py/tests/test_ut.py::test_ut[ut_dm_i2c_speed] PASSED 161 test/py/tests/test_ut.py::test_ut[ut_dm_leak] PASSED 162 test/py/tests/test_ut.py::test_ut[ut_dm_led_base] PASSED 163 test/py/tests/test_ut.py::test_ut[ut_dm_led_gpio] PASSED 164 test/py/tests/test_ut.py::test_ut[ut_dm_led_label] PASSED 165 test/py/tests/test_ut.py::test_ut[ut_dm_lifecycle] PASSED 166 test/py/tests/test_ut.py::test_ut[ut_dm_mmc_base] PASSED 167 test/py/tests/test_ut.py::test_ut[ut_dm_net_retry] PASSED 168 test/py/tests/test_ut.py::test_ut[ut_dm_operations] PASSED 169 test/py/tests/test_ut.py::test_ut[ut_dm_ordering] PASSED 170 test/py/tests/test_ut.py::test_ut[ut_dm_pci_base] PASSED 171 test/py/tests/test_ut.py::test_ut[ut_dm_pci_busnum] PASSED 172 test/py/tests/test_ut.py::test_ut[ut_dm_pci_swapcase] PASSED 173 test/py/tests/test_ut.py::test_ut[ut_dm_platdata] PASSED 174 test/py/tests/test_ut.py::test_ut[ut_dm_power_pmic_get] PASSED 175 test/py/tests/test_ut.py::test_ut[ut_dm_power_pmic_io] PASSED 176 test/py/tests/test_ut.py::test_ut[ut_dm_power_regulator_autoset] PASSED 177 test/py/tests/test_ut.py::test_ut[ut_dm_power_regulator_autoset_list] PASSED 178 test/py/tests/test_ut.py::test_ut[ut_dm_power_regulator_get] PASSED 179 test/py/tests/test_ut.py::test_ut[ut_dm_power_regulator_set_get_current] PASSED 180 test/py/tests/test_ut.py::test_ut[ut_dm_power_regulator_set_get_enable] PASSED 181 test/py/tests/test_ut.py::test_ut[ut_dm_power_regulator_set_get_mode] PASSED 182 test/py/tests/test_ut.py::test_ut[ut_dm_power_regulator_set_get_voltage] PASSED 183 test/py/tests/test_ut.py::test_ut[ut_dm_pre_reloc] PASSED 184 test/py/tests/test_ut.py::test_ut[ut_dm_ram_base] PASSED 185 test/py/tests/test_ut.py::test_ut[ut_dm_regmap_base] PASSED 186 test/py/tests/test_ut.py::test_ut[ut_dm_regmap_syscon] PASSED 187 test/py/tests/test_ut.py::test_ut[ut_dm_remoteproc_base] PASSED 188 test/py/tests/test_ut.py::test_ut[ut_dm_remove] PASSED 189 test/py/tests/test_ut.py::test_ut[ut_dm_reset_base] PASSED 190 test/py/tests/test_ut.py::test_ut[ut_dm_reset_walk] PASSED 191 test/py/tests/test_ut.py::test_ut[ut_dm_rtc_base] PASSED 192 test/py/tests/test_ut.py::test_ut[ut_dm_rtc_dual] PASSED 193 test/py/tests/test_ut.py::test_ut[ut_dm_rtc_reset] PASSED 194 test/py/tests/test_ut.py::test_ut[ut_dm_rtc_set_get] PASSED 195 test/py/tests/test_ut.py::test_ut[ut_dm_spi_find] PASSED 196 test/py/tests/test_ut.py::test_ut[ut_dm_spi_flash] PASSED 197 test/py/tests/test_ut.py::test_ut[ut_dm_spi_xfer] PASSED 198 test/py/tests/test_ut.py::test_ut[ut_dm_syscon_base] PASSED 199 test/py/tests/test_ut.py::test_ut[ut_dm_syscon_by_driver_data] PASSED 200 test/py/tests/test_ut.py::test_ut[ut_dm_timer_base] PASSED 201 test/py/tests/test_ut.py::test_ut[ut_dm_uclass] PASSED 202 test/py/tests/test_ut.py::test_ut[ut_dm_uclass_before_ready] PASSED 203 test/py/tests/test_ut.py::test_ut[ut_dm_uclass_devices_find] PASSED 204 test/py/tests/test_ut.py::test_ut[ut_dm_uclass_devices_find_by_name] PASSED 205 test/py/tests/test_ut.py::test_ut[ut_dm_uclass_devices_get] PASSED 206 test/py/tests/test_ut.py::test_ut[ut_dm_uclass_devices_get_by_name] PASSED 207 test/py/tests/test_ut.py::test_ut[ut_dm_usb_base] PASSED 208 test/py/tests/test_ut.py::test_ut[ut_dm_usb_flash] PASSED 209 test/py/tests/test_ut.py::test_ut[ut_dm_usb_keyb] PASSED 210 test/py/tests/test_ut.py::test_ut[ut_dm_usb_multi] PASSED 211 test/py/tests/test_ut.py::test_ut[ut_dm_usb_remove] PASSED 212 test/py/tests/test_ut.py::test_ut[ut_dm_usb_tree] PASSED 213 test/py/tests/test_ut.py::test_ut[ut_dm_usb_tree_remove] PASSED 214 test/py/tests/test_ut.py::test_ut[ut_dm_usb_tree_reorder] PASSED 215 test/py/tests/test_ut.py::test_ut[ut_dm_video_base] PASSED 216 test/py/tests/test_ut.py::test_ut[ut_dm_video_bmp] PASSED 217 test/py/tests/test_ut.py::test_ut[ut_dm_video_bmp_comp] PASSED 218 test/py/tests/test_ut.py::test_ut[ut_dm_video_chars] PASSED 219 test/py/tests/test_ut.py::test_ut[ut_dm_video_context] PASSED 220 test/py/tests/test_ut.py::test_ut[ut_dm_video_rotation1] PASSED 221 test/py/tests/test_ut.py::test_ut[ut_dm_video_rotation2] PASSED 222 test/py/tests/test_ut.py::test_ut[ut_dm_video_rotation3] PASSED 223 test/py/tests/test_ut.py::test_ut[ut_dm_video_text] PASSED 224 test/py/tests/test_ut.py::test_ut[ut_dm_video_truetype] PASSED 225 test/py/tests/test_ut.py::test_ut[ut_dm_video_truetype_bs] PASSED 226 test/py/tests/test_ut.py::test_ut[ut_dm_video_truetype_scroll] PASSED 227 228 ======================= 84 tests deselected by '-kut_dm' ======================= 229 ================== 115 passed, 84 deselected in 3.77 seconds =================== 230 231What is going on? 232----------------- 233 234Let's start at the top. The demo command is in cmd/demo.c. It does 235the usual command processing and then: 236 237.. code-block:: c 238 239 struct udevice *demo_dev; 240 241 ret = uclass_get_device(UCLASS_DEMO, devnum, &demo_dev); 242 243UCLASS_DEMO means the class of devices which implement 'demo'. Other 244classes might be MMC, or GPIO, hashing or serial. The idea is that the 245devices in the class all share a particular way of working. The class 246presents a unified view of all these devices to U-Boot. 247 248This function looks up a device for the demo uclass. Given a device 249number we can find the device because all devices have registered with 250the UCLASS_DEMO uclass. 251 252The device is automatically activated ready for use by uclass_get_device(). 253 254Now that we have the device we can do things like: 255 256.. code-block:: c 257 258 return demo_hello(demo_dev, ch); 259 260This function is in the demo uclass. It takes care of calling the 'hello' 261method of the relevant driver. Bearing in mind that there are two drivers, 262this particular device may use one or other of them. 263 264The code for demo_hello() is in drivers/demo/demo-uclass.c: 265 266.. code-block:: c 267 268 int demo_hello(struct udevice *dev, int ch) 269 { 270 const struct demo_ops *ops = device_get_ops(dev); 271 272 if (!ops->hello) 273 return -ENOSYS; 274 275 return ops->hello(dev, ch); 276 } 277 278As you can see it just calls the relevant driver method. One of these is 279in drivers/demo/demo-simple.c: 280 281.. code-block:: c 282 283 static int simple_hello(struct udevice *dev, int ch) 284 { 285 const struct dm_demo_pdata *pdata = dev_get_plat(dev); 286 287 printf("Hello from %08x: %s %d\n", map_to_sysmem(dev), 288 pdata->colour, pdata->sides); 289 290 return 0; 291 } 292 293 294So that is a trip from top (command execution) to bottom (driver action) 295but it leaves a lot of topics to address. 296 297 298Declaring Drivers 299----------------- 300 301A driver declaration looks something like this (see 302drivers/demo/demo-shape.c): 303 304.. code-block:: c 305 306 static const struct demo_ops shape_ops = { 307 .hello = shape_hello, 308 .status = shape_status, 309 }; 310 311 U_BOOT_DRIVER(demo_shape_drv) = { 312 .name = "demo_shape_drv", 313 .id = UCLASS_DEMO, 314 .ops = &shape_ops, 315 .priv_data_size = sizeof(struct shape_data), 316 }; 317 318 319This driver has two methods (hello and status) and requires a bit of 320private data (accessible through dev_get_priv(dev) once the driver has 321been probed). It is a member of UCLASS_DEMO so will register itself 322there. 323 324In U_BOOT_DRIVER it is also possible to specify special methods for bind 325and unbind, and these are called at appropriate times. For many drivers 326it is hoped that only 'probe' and 'remove' will be needed. 327 328The U_BOOT_DRIVER macro creates a data structure accessible from C, 329so driver model can find the drivers that are available. 330 331The methods a device can provide are documented in the device.h header. 332Briefly, they are: 333 334 * bind - make the driver model aware of a device (bind it to its driver) 335 * unbind - make the driver model forget the device 336 * of_to_plat - convert device tree data to plat - see later 337 * probe - make a device ready for use 338 * remove - remove a device so it cannot be used until probed again 339 340The sequence to get a device to work is bind, of_to_plat (if using 341device tree) and probe. 342 343 344Platform Data 345------------- 346 347Note: platform data is the old way of doing things. It is 348basically a C structure which is passed to drivers to tell them about 349platform-specific settings like the address of its registers, bus 350speed, etc. Device tree is now the preferred way of handling this. 351Unless you have a good reason not to use device tree (the main one 352being you need serial support in SPL and don't have enough SRAM for 353the cut-down device tree and libfdt libraries) you should stay away 354from platform data. 355 356Platform data is like Linux platform data, if you are familiar with that. 357It provides the board-specific information to start up a device. 358 359Why is this information not just stored in the device driver itself? The 360idea is that the device driver is generic, and can in principle operate on 361any board that has that type of device. For example, with modern 362highly-complex SoCs it is common for the IP to come from an IP vendor, and 363therefore (for example) the MMC controller may be the same on chips from 364different vendors. It makes no sense to write independent drivers for the 365MMC controller on each vendor's SoC, when they are all almost the same. 366Similarly, we may have 6 UARTs in an SoC, all of which are mostly the same, 367but lie at different addresses in the address space. 368 369Using the UART example, we have a single driver and it is instantiated 6 370times by supplying 6 lots of platform data. Each lot of platform data 371gives the driver name and a pointer to a structure containing information 372about this instance - e.g. the address of the register space. It may be that 373one of the UARTS supports RS-485 operation - this can be added as a flag in 374the platform data, which is set for this one port and clear for the rest. 375 376Think of your driver as a generic piece of code which knows how to talk to 377a device, but needs to know where it is, any variant/option information and 378so on. Platform data provides this link between the generic piece of code 379and the specific way it is bound on a particular board. 380 381Examples of platform data include: 382 383 - The base address of the IP block's register space 384 - Configuration options, like: 385 - the SPI polarity and maximum speed for a SPI controller 386 - the I2C speed to use for an I2C device 387 - the number of GPIOs available in a GPIO device 388 389Where does the platform data come from? It is either held in a structure 390which is compiled into U-Boot, or it can be parsed from the Device Tree 391(see 'Device Tree' below). 392 393For an example of how it can be compiled in, see demo-pdata.c which 394sets up a table of driver names and their associated platform data. 395The data can be interpreted by the drivers however they like - it is 396basically a communication scheme between the board-specific code and 397the generic drivers, which are intended to work on any board. 398 399Drivers can access their data via dev->info->plat. Here is 400the declaration for the platform data, which would normally appear 401in the board file. 402 403.. code-block:: c 404 405 static const struct dm_demo_pdata red_square = { 406 .colour = "red", 407 .sides = 4. 408 }; 409 410 static const struct driver_info info[] = { 411 { 412 .name = "demo_shape_drv", 413 .plat = &red_square, 414 }, 415 }; 416 417 demo1 = driver_bind(root, &info[0]); 418 419 420Device Tree 421----------- 422 423While plat is useful, a more flexible way of providing device data is 424by using device tree. In U-Boot you should use this where possible. Avoid 425sending patches which make use of the U_BOOT_DRVINFO() macro unless strictly 426necessary. 427 428With device tree we replace the above code with the following device tree 429fragment: 430 431.. code-block:: c 432 433 red-square { 434 compatible = "demo-shape"; 435 colour = "red"; 436 sides = <4>; 437 }; 438 439This means that instead of having lots of U_BOOT_DRVINFO() declarations in 440the board file, we put these in the device tree. This approach allows a lot 441more generality, since the same board file can support many types of boards 442(e,g. with the same SoC) just by using different device trees. An added 443benefit is that the Linux device tree can be used, thus further simplifying 444the task of board-bring up either for U-Boot or Linux devs (whoever gets to 445the board first!). 446 447The easiest way to make this work it to add a few members to the driver: 448 449.. code-block:: c 450 451 .plat_auto = sizeof(struct dm_test_pdata), 452 .of_to_plat = testfdt_of_to_plat, 453 454The 'auto' feature allowed space for the plat to be allocated 455and zeroed before the driver's of_to_plat() method is called. The 456of_to_plat() method, which the driver write supplies, should parse 457the device tree node for this device and place it in dev->plat. Thus 458when the probe method is called later (to set up the device ready for use) 459the platform data will be present. 460 461Note that both methods are optional. If you provide an of_to_plat 462method then it will be called first (during activation). If you provide a 463probe method it will be called next. See Driver Lifecycle below for more 464details. 465 466If you don't want to have the plat automatically allocated then you 467can leave out plat_auto. In this case you can use malloc 468in your of_to_plat (or probe) method to allocate the required memory, 469and you should free it in the remove method. 470 471The driver model tree is intended to mirror that of the device tree. The 472root driver is at device tree offset 0 (the root node, '/'), and its 473children are the children of the root node. 474 475In order for a device tree to be valid, the content must be correct with 476respect to either device tree specification 477(https://www.devicetree.org/specifications/) or the device tree bindings that 478are found in the doc/device-tree-bindings directory. When not U-Boot specific 479the bindings in this directory tend to come from the Linux Kernel. As such 480certain design decisions may have been made already for us in terms of how 481specific devices are described and bound. In most circumstances we wish to 482retain compatibility without additional changes being made to the device tree 483source files. 484 485Declaring Uclasses 486------------------ 487 488The demo uclass is declared like this: 489 490.. code-block:: c 491 492 UCLASS_DRIVER(demo) = { 493 .id = UCLASS_DEMO, 494 }; 495 496It is also possible to specify special methods for probe, etc. The uclass 497numbering comes from include/dm/uclass-id.h. To add a new uclass, add to the 498end of the enum there, then declare your uclass as above. 499 500 501Device Sequence Numbers 502----------------------- 503 504U-Boot numbers devices from 0 in many situations, such as in the command 505line for I2C and SPI buses, and the device names for serial ports (serial0, 506serial1, ...). Driver model supports this numbering and permits devices 507to be locating by their 'sequence'. This numbering uniquely identifies a 508device in its uclass, so no two devices within a particular uclass can have 509the same sequence number. 510 511Sequence numbers start from 0 but gaps are permitted. For example, a board 512may have I2C buses 1, 4, 5 but no 0, 2 or 3. The choice of how devices are 513numbered is up to a particular board, and may be set by the SoC in some 514cases. While it might be tempting to automatically renumber the devices 515where there are gaps in the sequence, this can lead to confusion and is 516not the way that U-Boot works. 517 518Where a device gets its sequence number is controlled by the DM_SEQ_ALIAS 519Kconfig option, which can have a different value in U-Boot proper and SPL. 520If this option is not set, aliases are ignored. 521 522Even if CONFIG_DM_SEQ_ALIAS is enabled, the uclass must still have the 523DM_UC_FLAG_SEQ_ALIAS flag set, for its devices to be sequenced by aliases. 524 525With those options set, devices with an alias (e.g. "serial2") will get that 526sequence number (e.g. 2). Other devices get the next available number after all 527aliases and all existing numbers. This means that if there is just a single 528alias "serial2", unaliased serial devices will be assigned 3 or more, with 0 and 5291 being unused. 530 531If CONFIG_DM_SEQ_ALIAS or DM_UC_FLAG_SEQ_ALIAS are not set, all devices will get 532sequence numbers in a simple ordering starting from 0. To find the next number 533to allocate, driver model scans through to find the maximum existing number, 534then uses the next one. It does not attempt to fill in gaps. 535 536.. code-block:: none 537 538 aliases { 539 serial2 = "/serial@22230000"; 540 }; 541 542This indicates that in the uclass called "serial", the named node 543("/serial@22230000") will be given sequence number 2. Any command or driver 544which requests serial device 2 will obtain this device. 545 546More commonly you can use node references, which expand to the full path: 547 548.. code-block:: none 549 550 aliases { 551 serial2 = &serial_2; 552 }; 553 ... 554 serial_2: serial@22230000 { 555 ... 556 }; 557 558The alias resolves to the same string in this case, but this version is 559easier to read. 560 561Device sequence numbers are resolved when a device is bound and the number does 562not change for the life of the device. 563 564There are some situations where the uclass must allocate sequence numbers, 565since a strictly increase sequence (with devicetree nodes bound first) is not 566suitable. An example of this is the PCI bus. In this case, you can set the 567uclass DM_UC_FLAG_NO_AUTO_SEQ flag. With this flag set, only devices with an 568alias will be assigned a number by driver model. The rest is left to the uclass 569to sort out, e.g. when enumerating the bus. 570 571Note that changing the sequence number for a device (e.g. in a driver) is not 572permitted. If it is felt to be necessary, ask on the mailing list. 573 574Bus Drivers 575----------- 576 577A common use of driver model is to implement a bus, a device which provides 578access to other devices. Example of buses include SPI and I2C. Typically 579the bus provides some sort of transport or translation that makes it 580possible to talk to the devices on the bus. 581 582Driver model provides some useful features to help with implementing buses. 583Firstly, a bus can request that its children store some 'parent data' which 584can be used to keep track of child state. Secondly, the bus can define 585methods which are called when a child is probed or removed. This is similar 586to the methods the uclass driver provides. Thirdly, per-child platform data 587can be provided to specify things like the child's address on the bus. This 588persists across child probe()/remove() cycles. 589 590For consistency and ease of implementation, the bus uclass can specify the 591per-child platform data, so that it can be the same for all children of buses 592in that uclass. There are also uclass methods which can be called when 593children are bound and probed. 594 595Here an explanation of how a bus fits with a uclass may be useful. Consider 596a USB bus with several devices attached to it, each from a different (made 597up) uclass:: 598 599 xhci_usb (UCLASS_USB) 600 eth (UCLASS_ETH) 601 camera (UCLASS_CAMERA) 602 flash (UCLASS_FLASH_STORAGE) 603 604Each of the devices is connected to a different address on the USB bus. 605The bus device wants to store this address and some other information such 606as the bus speed for each device. 607 608To achieve this, the bus device can use dev->parent_plat in each of its 609three children. This can be auto-allocated if the bus driver (or bus uclass) 610has a non-zero value for per_child_plat_auto. If not, then 611the bus device or uclass can allocate the space itself before the child 612device is probed. 613 614Also the bus driver can define the child_pre_probe() and child_post_remove() 615methods to allow it to do some processing before the child is activated or 616after it is deactivated. 617 618Similarly the bus uclass can define the child_post_bind() method to obtain 619the per-child platform data from the device tree and set it up for the child. 620The bus uclass can also provide a child_pre_probe() method. Very often it is 621the bus uclass that controls these features, since it avoids each driver 622having to do the same processing. Of course the driver can still tweak and 623override these activities. 624 625Note that the information that controls this behaviour is in the bus's 626driver, not the child's. In fact it is possible that child has no knowledge 627that it is connected to a bus. The same child device may even be used on two 628different bus types. As an example. the 'flash' device shown above may also 629be connected on a SATA bus or standalone with no bus:: 630 631 xhci_usb (UCLASS_USB) 632 flash (UCLASS_FLASH_STORAGE) - parent data/methods defined by USB bus 633 634 sata (UCLASS_AHCI) 635 flash (UCLASS_FLASH_STORAGE) - parent data/methods defined by SATA bus 636 637 flash (UCLASS_FLASH_STORAGE) - no parent data/methods (not on a bus) 638 639Above you can see that the driver for xhci_usb/sata controls the child's 640bus methods. In the third example the device is not on a bus, and therefore 641will not have these methods at all. Consider the case where the flash 642device defines child methods. These would be used for *its* children, and 643would be quite separate from the methods defined by the driver for the bus 644that the flash device is connetced to. The act of attaching a device to a 645parent device which is a bus, causes the device to start behaving like a 646bus device, regardless of its own views on the matter. 647 648The uclass for the device can also contain data private to that uclass. 649But note that each device on the bus may be a member of a different 650uclass, and this data has nothing to do with the child data for each child 651on the bus. It is the bus' uclass that controls the child with respect to 652the bus. 653 654 655Driver Lifecycle 656---------------- 657 658Here are the stages that a device goes through in driver model. Note that all 659methods mentioned here are optional - e.g. if there is no probe() method for 660a device then it will not be called. A simple device may have very few 661methods actually defined. 662 663Bind stage 664^^^^^^^^^^ 665 666U-Boot discovers devices using one of these two methods: 667 668- Scan the U_BOOT_DRVINFO() definitions. U-Boot looks up the name specified 669 by each, to find the appropriate U_BOOT_DRIVER() definition. In this case, 670 there is no path by which driver_data may be provided, but the U_BOOT_DRVINFO() 671 may provide plat. 672 673- Scan through the device tree definitions. U-Boot looks at top-level 674 nodes in the the device tree. It looks at the compatible string in each node 675 and uses the of_match table of the U_BOOT_DRIVER() structure to find the 676 right driver for each node. In this case, the of_match table may provide a 677 driver_data value, but plat cannot be provided until later. 678 679For each device that is discovered, U-Boot then calls device_bind() to create a 680new device, initializes various core fields of the device object such as name, 681uclass & driver, initializes any optional fields of the device object that are 682applicable such as of_offset, driver_data & plat, and finally calls the 683driver's bind() method if one is defined. 684 685At this point all the devices are known, and bound to their drivers. There 686is a 'struct udevice' allocated for all devices. However, nothing has been 687activated (except for the root device). Each bound device that was created 688from a U_BOOT_DRVINFO() declaration will hold the plat pointer specified 689in that declaration. For a bound device created from the device tree, 690plat will be NULL, but of_offset will be the offset of the device tree 691node that caused the device to be created. The uclass is set correctly for 692the device. 693 694The device's sequence number is assigned, either the requested one or the next 695available one (after all aliases are processed) if nothing particular is 696requested. 697 698The device's bind() method is permitted to perform simple actions, but 699should not scan the device tree node, not initialise hardware, nor set up 700structures or allocate memory. All of these tasks should be left for 701the probe() method. 702 703Note that compared to Linux, U-Boot's driver model has a separate step of 704probe/remove which is independent of bind/unbind. This is partly because in 705U-Boot it may be expensive to probe devices and we don't want to do it until 706they are needed, or perhaps until after relocation. 707 708Reading ofdata 709^^^^^^^^^^^^^^ 710 711Most devices have data in the device tree which they can read to find out the 712base address of hardware registers and parameters relating to driver 713operation. This is called 'ofdata' (Open-Firmware data). 714 715The device's of_to_plat() implemnents allocation and reading of 716plat. A parent's ofdata is always read before a child. 717 718The steps are: 719 720 1. If priv_auto is non-zero, then the device-private space 721 is allocated for the device and zeroed. It will be accessible as 722 dev->priv. The driver can put anything it likes in there, but should use 723 it for run-time information, not platform data (which should be static 724 and known before the device is probed). 725 726 2. If plat_auto is non-zero, then the platform data space 727 is allocated. This is only useful for device tree operation, since 728 otherwise you would have to specify the platform data in the 729 U_BOOT_DRVINFO() declaration. The space is allocated for the device and 730 zeroed. It will be accessible as dev->plat. 731 732 3. If the device's uclass specifies a non-zero per_device_auto, 733 then this space is allocated and zeroed also. It is allocated for and 734 stored in the device, but it is uclass data. owned by the uclass driver. 735 It is possible for the device to access it. 736 737 4. If the device's immediate parent specifies a per_child_auto 738 then this space is allocated. This is intended for use by the parent 739 device to keep track of things related to the child. For example a USB 740 flash stick attached to a USB host controller would likely use this 741 space. The controller can hold information about the USB state of each 742 of its children. 743 744 5. If the driver provides an of_to_plat() method, then this is 745 called to convert the device tree data into platform data. This should 746 do various calls like dev_read_u32(dev, ...) to access the node and store 747 the resulting information into dev->plat. After this point, the device 748 works the same way whether it was bound using a device tree node or 749 U_BOOT_DRVINFO() structure. In either case, the platform data is now stored 750 in the plat structure. Typically you will use the 751 plat_auto feature to specify the size of the platform data 752 structure, and U-Boot will automatically allocate and zero it for you before 753 entry to of_to_plat(). But if not, you can allocate it yourself in 754 of_to_plat(). Note that it is preferable to do all the device tree 755 decoding in of_to_plat() rather than in probe(). (Apart from the 756 ugliness of mixing configuration and run-time data, one day it is possible 757 that U-Boot will cache platform data for devices which are regularly 758 de/activated). 759 760 6. The device is marked 'plat valid'. 761 762Note that ofdata reading is always done (for a child and all its parents) 763before probing starts. Thus devices go through two distinct states when 764probing: reading platform data and actually touching the hardware to bring 765the device up. 766 767Having probing separate from ofdata-reading helps deal with of-platdata, where 768the probe() method is common to both DT/of-platdata operation, but the 769of_to_plat() method is implemented differently. 770 771Another case has come up where this separate is useful. Generation of ACPI 772tables uses the of-platdata but does not want to probe the device. Probing 773would cause U-Boot to violate one of its design principles, viz that it 774should only probe devices that are used. For ACPI we want to generate a 775table for each device, even if U-Boot does not use it. In fact it may not 776even be possible to probe the device - e.g. an SD card which is not 777present will cause an error on probe, yet we still must tell Linux about 778the SD card connector in case it is used while Linux is running. 779 780It is important that the of_to_plat() method does not actually probe 781the device itself. However there are cases where other devices must be probed 782in the of_to_plat() method. An example is where a device requires a 783GPIO for it to operate. To select a GPIO obviously requires that the GPIO 784device is probed. This is OK when used by common, core devices such as GPIO, 785clock, interrupts, reset and the like. 786 787If your device relies on its parent setting up a suitable address space, so 788that dev_read_addr() works correctly, then make sure that the parent device 789has its setup code in of_to_plat(). If it has it in the probe method, 790then you cannot call dev_read_addr() from the child device's 791of_to_plat() method. Move it to probe() instead. Buses like PCI can 792fall afoul of this rule. 793 794Activation/probe 795^^^^^^^^^^^^^^^^ 796 797When a device needs to be used, U-Boot activates it, by first reading ofdata 798as above and then following these steps (see device_probe()): 799 800 1. All parent devices are probed. It is not possible to activate a device 801 unless its predecessors (all the way up to the root device) are activated. 802 This means (for example) that an I2C driver will require that its bus 803 be activated. 804 805 2. The device's probe() method is called. This should do anything that 806 is required by the device to get it going. This could include checking 807 that the hardware is actually present, setting up clocks for the 808 hardware and setting up hardware registers to initial values. The code 809 in probe() can access: 810 811 - platform data in dev->plat (for configuration) 812 - private data in dev->priv (for run-time state) 813 - uclass data in dev->uclass_priv (for things the uclass stores 814 about this device) 815 816 Note: If you don't use priv_auto then you will need to 817 allocate the priv space here yourself. The same applies also to 818 plat_auto. Remember to free them in the remove() method. 819 820 3. The device is marked 'activated' 821 822 4. The uclass's post_probe() method is called, if one exists. This may 823 cause the uclass to do some housekeeping to record the device as 824 activated and 'known' by the uclass. 825 826Running stage 827^^^^^^^^^^^^^ 828 829The device is now activated and can be used. From now until it is removed 830all of the above structures are accessible. The device appears in the 831uclass's list of devices (so if the device is in UCLASS_GPIO it will appear 832as a device in the GPIO uclass). This is the 'running' state of the device. 833 834Removal stage 835^^^^^^^^^^^^^ 836 837When the device is no-longer required, you can call device_remove() to 838remove it. This performs the probe steps in reverse: 839 840 1. The uclass's pre_remove() method is called, if one exists. This may 841 cause the uclass to do some housekeeping to record the device as 842 deactivated and no-longer 'known' by the uclass. 843 844 2. All the device's children are removed. It is not permitted to have 845 an active child device with a non-active parent. This means that 846 device_remove() is called for all the children recursively at this point. 847 848 3. The device's remove() method is called. At this stage nothing has been 849 deallocated so platform data, private data and the uclass data will all 850 still be present. This is where the hardware can be shut down. It is 851 intended that the device be completely inactive at this point, For U-Boot 852 to be sure that no hardware is running, it should be enough to remove 853 all devices. 854 855 4. The device memory is freed (platform data, private data, uclass data, 856 parent data). 857 858 Note: Because the platform data for a U_BOOT_DRVINFO() is defined with a 859 static pointer, it is not de-allocated during the remove() method. For 860 a device instantiated using the device tree data, the platform data will 861 be dynamically allocated, and thus needs to be deallocated during the 862 remove() method, either: 863 864 - if the plat_auto is non-zero, the deallocation happens automatically 865 within the driver model core in the unbind stage; or 866 867 - when plat_auto is 0, both the allocation (in probe() 868 or preferably of_to_plat()) and the deallocation in remove() 869 are the responsibility of the driver author. 870 871 5. The device is marked inactive. Note that it is still bound, so the 872 device structure itself is not freed at this point. Should the device be 873 activated again, then the cycle starts again at step 2 above. 874 875Unbind stage 876^^^^^^^^^^^^ 877 878The device is unbound. This is the step that actually destroys the device. 879If a parent has children these will be destroyed first. After this point 880the device does not exist and its memory has be deallocated. 881 882 883Special cases for removal 884------------------------- 885 886Some devices need to do clean-up before the OS is called. For example, a USB 887driver may want to stop the bus. This can be done in the remove() method. 888Some special flags are used to determine whether to remove the device: 889 890 DM_FLAG_OS_PREPARE - indicates that the device needs to get ready for OS 891 boot. The device will be removed just before the OS is booted 892 DM_REMOVE_ACTIVE_DMA - indicates that the device uses DMA. This is 893 effectively the same as DM_FLAG_OS_PREPARE, so the device is removed 894 before the OS is booted 895 DM_FLAG_VITAL - indicates that the device is 'vital' to the operation of 896 other devices. It is possible to remove this device after all regular 897 devices are removed. This is useful e.g. for a clock, which need to 898 be active during the device-removal phase. 899 900The dm_remove_devices_flags() function can be used to remove devices based on 901their driver flags. 902 903Data Structures 904--------------- 905 906Driver model uses a doubly-linked list as the basic data structure. Some 907nodes have several lists running through them. Creating a more efficient 908data structure might be worthwhile in some rare cases, once we understand 909what the bottlenecks are. 910 911 912Changes since v1 913---------------- 914 915For the record, this implementation uses a very similar approach to the 916original patches, but makes at least the following changes: 917 918- Tried to aggressively remove boilerplate, so that for most drivers there 919 is little or no 'driver model' code to write. 920- Moved some data from code into data structure - e.g. store a pointer to 921 the driver operations structure in the driver, rather than passing it 922 to the driver bind function. 923- Rename some structures to make them more similar to Linux (struct udevice 924 instead of struct instance, struct plat, etc.) 925- Change the name 'core' to 'uclass', meaning U-Boot class. It seems that 926 this concept relates to a class of drivers (or a subsystem). We shouldn't 927 use 'class' since it is a C++ reserved word, so U-Boot class (uclass) seems 928 better than 'core'. 929- Remove 'struct driver_instance' and just use a single 'struct udevice'. 930 This removes a level of indirection that doesn't seem necessary. 931- Built in device tree support, to avoid the need for plat 932- Removed the concept of driver relocation, and just make it possible for 933 the new driver (created after relocation) to access the old driver data. 934 I feel that relocation is a very special case and will only apply to a few 935 drivers, many of which can/will just re-init anyway. So the overhead of 936 dealing with this might not be worth it. 937- Implemented a GPIO system, trying to keep it simple 938 939 940Pre-Relocation Support 941---------------------- 942 943For pre-relocation we simply call the driver model init function. Only 944drivers marked with DM_FLAG_PRE_RELOC or the device tree 'u-boot,dm-pre-reloc' 945property are initialised prior to relocation. This helps to reduce the driver 946model overhead. This flag applies to SPL and TPL as well, if device tree is 947enabled (CONFIG_OF_CONTROL) there. 948 949Note when device tree is enabled, the device tree 'u-boot,dm-pre-reloc' 950property can provide better control granularity on which device is bound 951before relocation. While with DM_FLAG_PRE_RELOC flag of the driver all 952devices with the same driver are bound, which requires allocation a large 953amount of memory. When device tree is not used, DM_FLAG_PRE_RELOC is the 954only way for statically declared devices via U_BOOT_DRVINFO() to be bound 955prior to relocation. 956 957It is possible to limit this to specific relocation steps, by using 958the more specialized 'u-boot,dm-spl' and 'u-boot,dm-tpl' flags 959in the device tree node. For U-Boot proper you can use 'u-boot,dm-pre-proper' 960which means that it will be processed (and a driver bound) in U-Boot proper 961prior to relocation, but will not be available in SPL or TPL. 962 963To reduce the size of SPL and TPL, only the nodes with pre-relocation properties 964('u-boot,dm-pre-reloc', 'u-boot,dm-spl' or 'u-boot,dm-tpl') are keept in their 965device trees (see README.SPL for details); the remaining nodes are always bound. 966 967Then post relocation we throw that away and re-init driver model again. 968For drivers which require some sort of continuity between pre- and 969post-relocation devices, we can provide access to the pre-relocation 970device pointers, but this is not currently implemented (the root device 971pointer is saved but not made available through the driver model API). 972 973 974SPL Support 975----------- 976 977Driver model can operate in SPL. Its efficient implementation and small code 978size provide for a small overhead which is acceptable for all but the most 979constrained systems. 980 981To enable driver model in SPL, define CONFIG_SPL_DM. You might want to 982consider the following option also. See the main README for more details. 983 984 - CONFIG_SYS_MALLOC_SIMPLE 985 - CONFIG_DM_WARN 986 - CONFIG_DM_DEVICE_REMOVE 987 - CONFIG_DM_STDIO 988 989 990Enabling Driver Model 991--------------------- 992 993Driver model is being brought into U-Boot gradually. As each subsystems gets 994support, a uclass is created and a CONFIG to enable use of driver model for 995that subsystem. 996 997For example CONFIG_DM_SERIAL enables driver model for serial. With that 998defined, the old serial support is not enabled, and your serial driver must 999conform to driver model. With that undefined, the old serial support is 1000enabled and driver model is not available for serial. This means that when 1001you convert a driver, you must either convert all its boards, or provide for 1002the driver to be compiled both with and without driver model (generally this 1003is not very hard). 1004 1005See the main README for full details of the available driver model CONFIG 1006options. 1007 1008 1009Things to punt for later 1010------------------------ 1011 1012Uclasses are statically numbered at compile time. It would be possible to 1013change this to dynamic numbering, but then we would require some sort of 1014lookup service, perhaps searching by name. This is slightly less efficient 1015so has been left out for now. One small advantage of dynamic numbering might 1016be fewer merge conflicts in uclass-id.h. 1017