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