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_config 40 make 41 ./u-boot 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/dm/test-dm.sh 94 95You should see something like this: 96 97 <...U-Boot banner...> 98 Running 14 driver model tests 99 Test: dm_test_autobind 100 Test: dm_test_autoprobe 101 Test: dm_test_children 102 Test: dm_test_fdt 103 Test: dm_test_fdt_pre_reloc 104 Test: dm_test_gpio 105 sandbox_gpio: sb_gpio_get_value: error: offset 4 not reserved 106 Test: dm_test_leak 107 Test: dm_test_lifecycle 108 Test: dm_test_operations 109 Test: dm_test_ordering 110 Test: dm_test_platdata 111 Test: dm_test_pre_reloc 112 Test: dm_test_remove 113 Test: dm_test_uclass 114 Failures: 0 115 116 117What is going on? 118----------------- 119 120Let's start at the top. The demo command is in common/cmd_demo.c. It does 121the usual command processing and then: 122 123 struct udevice *demo_dev; 124 125 ret = uclass_get_device(UCLASS_DEMO, devnum, &demo_dev); 126 127UCLASS_DEMO means the class of devices which implement 'demo'. Other 128classes might be MMC, or GPIO, hashing or serial. The idea is that the 129devices in the class all share a particular way of working. The class 130presents a unified view of all these devices to U-Boot. 131 132This function looks up a device for the demo uclass. Given a device 133number we can find the device because all devices have registered with 134the UCLASS_DEMO uclass. 135 136The device is automatically activated ready for use by uclass_get_device(). 137 138Now that we have the device we can do things like: 139 140 return demo_hello(demo_dev, ch); 141 142This function is in the demo uclass. It takes care of calling the 'hello' 143method of the relevant driver. Bearing in mind that there are two drivers, 144this particular device may use one or other of them. 145 146The code for demo_hello() is in drivers/demo/demo-uclass.c: 147 148int demo_hello(struct udevice *dev, int ch) 149{ 150 const struct demo_ops *ops = device_get_ops(dev); 151 152 if (!ops->hello) 153 return -ENOSYS; 154 155 return ops->hello(dev, ch); 156} 157 158As you can see it just calls the relevant driver method. One of these is 159in drivers/demo/demo-simple.c: 160 161static int simple_hello(struct udevice *dev, int ch) 162{ 163 const struct dm_demo_pdata *pdata = dev_get_platdata(dev); 164 165 printf("Hello from %08x: %s %d\n", map_to_sysmem(dev), 166 pdata->colour, pdata->sides); 167 168 return 0; 169} 170 171 172So that is a trip from top (command execution) to bottom (driver action) 173but it leaves a lot of topics to address. 174 175 176Declaring Drivers 177----------------- 178 179A driver declaration looks something like this (see 180drivers/demo/demo-shape.c): 181 182static const struct demo_ops shape_ops = { 183 .hello = shape_hello, 184 .status = shape_status, 185}; 186 187U_BOOT_DRIVER(demo_shape_drv) = { 188 .name = "demo_shape_drv", 189 .id = UCLASS_DEMO, 190 .ops = &shape_ops, 191 .priv_data_size = sizeof(struct shape_data), 192}; 193 194 195This driver has two methods (hello and status) and requires a bit of 196private data (accessible through dev_get_priv(dev) once the driver has 197been probed). It is a member of UCLASS_DEMO so will register itself 198there. 199 200In U_BOOT_DRIVER it is also possible to specify special methods for bind 201and unbind, and these are called at appropriate times. For many drivers 202it is hoped that only 'probe' and 'remove' will be needed. 203 204The U_BOOT_DRIVER macro creates a data structure accessible from C, 205so driver model can find the drivers that are available. 206 207The methods a device can provide are documented in the device.h header. 208Briefly, they are: 209 210 bind - make the driver model aware of a device (bind it to its driver) 211 unbind - make the driver model forget the device 212 ofdata_to_platdata - convert device tree data to platdata - see later 213 probe - make a device ready for use 214 remove - remove a device so it cannot be used until probed again 215 216The sequence to get a device to work is bind, ofdata_to_platdata (if using 217device tree) and probe. 218 219 220Platform Data 221------------- 222 223Platform data is like Linux platform data, if you are familiar with that. 224It provides the board-specific information to start up a device. 225 226Why is this information not just stored in the device driver itself? The 227idea is that the device driver is generic, and can in principle operate on 228any board that has that type of device. For example, with modern 229highly-complex SoCs it is common for the IP to come from an IP vendor, and 230therefore (for example) the MMC controller may be the same on chips from 231different vendors. It makes no sense to write independent drivers for the 232MMC controller on each vendor's SoC, when they are all almost the same. 233Similarly, we may have 6 UARTs in an SoC, all of which are mostly the same, 234but lie at different addresses in the address space. 235 236Using the UART example, we have a single driver and it is instantiated 6 237times by supplying 6 lots of platform data. Each lot of platform data 238gives the driver name and a pointer to a structure containing information 239about this instance - e.g. the address of the register space. It may be that 240one of the UARTS supports RS-485 operation - this can be added as a flag in 241the platform data, which is set for this one port and clear for the rest. 242 243Think of your driver as a generic piece of code which knows how to talk to 244a device, but needs to know where it is, any variant/option information and 245so on. Platform data provides this link between the generic piece of code 246and the specific way it is bound on a particular board. 247 248Examples of platform data include: 249 250 - The base address of the IP block's register space 251 - Configuration options, like: 252 - the SPI polarity and maximum speed for a SPI controller 253 - the I2C speed to use for an I2C device 254 - the number of GPIOs available in a GPIO device 255 256Where does the platform data come from? It is either held in a structure 257which is compiled into U-Boot, or it can be parsed from the Device Tree 258(see 'Device Tree' below). 259 260For an example of how it can be compiled in, see demo-pdata.c which 261sets up a table of driver names and their associated platform data. 262The data can be interpreted by the drivers however they like - it is 263basically a communication scheme between the board-specific code and 264the generic drivers, which are intended to work on any board. 265 266Drivers can access their data via dev->info->platdata. Here is 267the declaration for the platform data, which would normally appear 268in the board file. 269 270 static const struct dm_demo_cdata red_square = { 271 .colour = "red", 272 .sides = 4. 273 }; 274 static const struct driver_info info[] = { 275 { 276 .name = "demo_shape_drv", 277 .platdata = &red_square, 278 }, 279 }; 280 281 demo1 = driver_bind(root, &info[0]); 282 283 284Device Tree 285----------- 286 287While platdata is useful, a more flexible way of providing device data is 288by using device tree. With device tree we replace the above code with the 289following device tree fragment: 290 291 red-square { 292 compatible = "demo-shape"; 293 colour = "red"; 294 sides = <4>; 295 }; 296 297This means that instead of having lots of U_BOOT_DEVICE() declarations in 298the board file, we put these in the device tree. This approach allows a lot 299more generality, since the same board file can support many types of boards 300(e,g. with the same SoC) just by using different device trees. An added 301benefit is that the Linux device tree can be used, thus further simplifying 302the task of board-bring up either for U-Boot or Linux devs (whoever gets to 303the board first!). 304 305The easiest way to make this work it to add a few members to the driver: 306 307 .platdata_auto_alloc_size = sizeof(struct dm_test_pdata), 308 .ofdata_to_platdata = testfdt_ofdata_to_platdata, 309 310The 'auto_alloc' feature allowed space for the platdata to be allocated 311and zeroed before the driver's ofdata_to_platdata() method is called. The 312ofdata_to_platdata() method, which the driver write supplies, should parse 313the device tree node for this device and place it in dev->platdata. Thus 314when the probe method is called later (to set up the device ready for use) 315the platform data will be present. 316 317Note that both methods are optional. If you provide an ofdata_to_platdata 318method then it will be called first (during activation). If you provide a 319probe method it will be called next. See Driver Lifecycle below for more 320details. 321 322If you don't want to have the platdata automatically allocated then you 323can leave out platdata_auto_alloc_size. In this case you can use malloc 324in your ofdata_to_platdata (or probe) method to allocate the required memory, 325and you should free it in the remove method. 326 327 328Declaring Uclasses 329------------------ 330 331The demo uclass is declared like this: 332 333U_BOOT_CLASS(demo) = { 334 .id = UCLASS_DEMO, 335}; 336 337It is also possible to specify special methods for probe, etc. The uclass 338numbering comes from include/dm/uclass.h. To add a new uclass, add to the 339end of the enum there, then declare your uclass as above. 340 341 342Driver Lifecycle 343---------------- 344 345Here are the stages that a device goes through in driver model. Note that all 346methods mentioned here are optional - e.g. if there is no probe() method for 347a device then it will not be called. A simple device may have very few 348methods actually defined. 349 3501. Bind stage 351 352A device and its driver are bound using one of these two methods: 353 354 - Scan the U_BOOT_DEVICE() definitions. U-Boot It looks up the 355name specified by each, to find the appropriate driver. It then calls 356device_bind() to create a new device and bind' it to its driver. This will 357call the device's bind() method. 358 359 - Scan through the device tree definitions. U-Boot looks at top-level 360nodes in the the device tree. It looks at the compatible string in each node 361and uses the of_match part of the U_BOOT_DRIVER() structure to find the 362right driver for each node. It then calls device_bind() to bind the 363newly-created device to its driver (thereby creating a device structure). 364This will also call the device's bind() method. 365 366At this point all the devices are known, and bound to their drivers. There 367is a 'struct udevice' allocated for all devices. However, nothing has been 368activated (except for the root device). Each bound device that was created 369from a U_BOOT_DEVICE() declaration will hold the platdata pointer specified 370in that declaration. For a bound device created from the device tree, 371platdata will be NULL, but of_offset will be the offset of the device tree 372node that caused the device to be created. The uclass is set correctly for 373the device. 374 375The device's bind() method is permitted to perform simple actions, but 376should not scan the device tree node, not initialise hardware, nor set up 377structures or allocate memory. All of these tasks should be left for 378the probe() method. 379 380Note that compared to Linux, U-Boot's driver model has a separate step of 381probe/remove which is independent of bind/unbind. This is partly because in 382U-Boot it may be expensive to probe devices and we don't want to do it until 383they are needed, or perhaps until after relocation. 384 3852. Activation/probe 386 387When a device needs to be used, U-Boot activates it, by following these 388steps (see device_probe()): 389 390 a. If priv_auto_alloc_size is non-zero, then the device-private space 391 is allocated for the device and zeroed. It will be accessible as 392 dev->priv. The driver can put anything it likes in there, but should use 393 it for run-time information, not platform data (which should be static 394 and known before the device is probed). 395 396 b. If platdata_auto_alloc_size is non-zero, then the platform data space 397 is allocated. This is only useful for device tree operation, since 398 otherwise you would have to specific the platform data in the 399 U_BOOT_DEVICE() declaration. The space is allocated for the device and 400 zeroed. It will be accessible as dev->platdata. 401 402 c. If the device's uclass specifies a non-zero per_device_auto_alloc_size, 403 then this space is allocated and zeroed also. It is allocated for and 404 stored in the device, but it is uclass data. owned by the uclass driver. 405 It is possible for the device to access it. 406 407 d. All parent devices are probed. It is not possible to activate a device 408 unless its predecessors (all the way up to the root device) are activated. 409 This means (for example) that an I2C driver will require that its bus 410 be activated. 411 412 e. If the driver provides an ofdata_to_platdata() method, then this is 413 called to convert the device tree data into platform data. This should 414 do various calls like fdtdec_get_int(gd->fdt_blob, dev->of_offset, ...) 415 to access the node and store the resulting information into dev->platdata. 416 After this point, the device works the same way whether it was bound 417 using a device tree node or U_BOOT_DEVICE() structure. In either case, 418 the platform data is now stored in the platdata structure. Typically you 419 will use the platdata_auto_alloc_size feature to specify the size of the 420 platform data structure, and U-Boot will automatically allocate and zero 421 it for you before entry to ofdata_to_platdata(). But if not, you can 422 allocate it yourself in ofdata_to_platdata(). Note that it is preferable 423 to do all the device tree decoding in ofdata_to_platdata() rather than 424 in probe(). (Apart from the ugliness of mixing configuration and run-time 425 data, one day it is possible that U-Boot will cache platformat data for 426 devices which are regularly de/activated). 427 428 f. The device's probe() method is called. This should do anything that 429 is required by the device to get it going. This could include checking 430 that the hardware is actually present, setting up clocks for the 431 hardware and setting up hardware registers to initial values. The code 432 in probe() can access: 433 434 - platform data in dev->platdata (for configuration) 435 - private data in dev->priv (for run-time state) 436 - uclass data in dev->uclass_priv (for things the uclass stores 437 about this device) 438 439 Note: If you don't use priv_auto_alloc_size then you will need to 440 allocate the priv space here yourself. The same applies also to 441 platdata_auto_alloc_size. Remember to free them in the remove() method. 442 443 g. The device is marked 'activated' 444 445 h. The uclass's post_probe() method is called, if one exists. This may 446 cause the uclass to do some housekeeping to record the device as 447 activated and 'known' by the uclass. 448 4493. Running stage 450 451The device is now activated and can be used. From now until it is removed 452all of the above structures are accessible. The device appears in the 453uclass's list of devices (so if the device is in UCLASS_GPIO it will appear 454as a device in the GPIO uclass). This is the 'running' state of the device. 455 4564. Removal stage 457 458When the device is no-longer required, you can call device_remove() to 459remove it. This performs the probe steps in reverse: 460 461 a. The uclass's pre_remove() method is called, if one exists. This may 462 cause the uclass to do some housekeeping to record the device as 463 deactivated and no-longer 'known' by the uclass. 464 465 b. All the device's children are removed. It is not permitted to have 466 an active child device with a non-active parent. This means that 467 device_remove() is called for all the children recursively at this point. 468 469 c. The device's remove() method is called. At this stage nothing has been 470 deallocated so platform data, private data and the uclass data will all 471 still be present. This is where the hardware can be shut down. It is 472 intended that the device be completely inactive at this point, For U-Boot 473 to be sure that no hardware is running, it should be enough to remove 474 all devices. 475 476 d. The device memory is freed (platform data, private data, uclass data). 477 478 Note: Because the platform data for a U_BOOT_DEVICE() is defined with a 479 static pointer, it is not de-allocated during the remove() method. For 480 a device instantiated using the device tree data, the platform data will 481 be dynamically allocated, and thus needs to be deallocated during the 482 remove() method, either: 483 484 1. if the platdata_auto_alloc_size is non-zero, the deallocation 485 happens automatically within the driver model core; or 486 487 2. when platdata_auto_alloc_size is 0, both the allocation (in probe() 488 or preferably ofdata_to_platdata()) and the deallocation in remove() 489 are the responsibility of the driver author. 490 491 e. The device is marked inactive. Note that it is still bound, so the 492 device structure itself is not freed at this point. Should the device be 493 activated again, then the cycle starts again at step 2 above. 494 4955. Unbind stage 496 497The device is unbound. This is the step that actually destroys the device. 498If a parent has children these will be destroyed first. After this point 499the device does not exist and its memory has be deallocated. 500 501 502Data Structures 503--------------- 504 505Driver model uses a doubly-linked list as the basic data structure. Some 506nodes have several lists running through them. Creating a more efficient 507data structure might be worthwhile in some rare cases, once we understand 508what the bottlenecks are. 509 510 511Changes since v1 512---------------- 513 514For the record, this implementation uses a very similar approach to the 515original patches, but makes at least the following changes: 516 517- Tried to aggressively remove boilerplate, so that for most drivers there 518is little or no 'driver model' code to write. 519- Moved some data from code into data structure - e.g. store a pointer to 520the driver operations structure in the driver, rather than passing it 521to the driver bind function. 522- Rename some structures to make them more similar to Linux (struct udevice 523instead of struct instance, struct platdata, etc.) 524- Change the name 'core' to 'uclass', meaning U-Boot class. It seems that 525this concept relates to a class of drivers (or a subsystem). We shouldn't 526use 'class' since it is a C++ reserved word, so U-Boot class (uclass) seems 527better than 'core'. 528- Remove 'struct driver_instance' and just use a single 'struct udevice'. 529This removes a level of indirection that doesn't seem necessary. 530- Built in device tree support, to avoid the need for platdata 531- Removed the concept of driver relocation, and just make it possible for 532the new driver (created after relocation) to access the old driver data. 533I feel that relocation is a very special case and will only apply to a few 534drivers, many of which can/will just re-init anyway. So the overhead of 535dealing with this might not be worth it. 536- Implemented a GPIO system, trying to keep it simple 537 538 539Pre-Relocation Support 540---------------------- 541 542For pre-relocation we simply call the driver model init function. Only 543drivers marked with DM_FLAG_PRE_RELOC or the device tree 544'u-boot,dm-pre-reloc' flag are initialised prior to relocation. This helps 545to reduce the driver model overhead. 546 547Then post relocation we throw that away and re-init driver model again. 548For drivers which require some sort of continuity between pre- and 549post-relocation devices, we can provide access to the pre-relocation 550device pointers, but this is not currently implemented (the root device 551pointer is saved but not made available through the driver model API). 552 553 554Things to punt for later 555------------------------ 556 557- SPL support - this will have to be present before many drivers can be 558converted, but it seems like we can add it once we are happy with the 559core implementation. 560 561That is not to say that no thinking has gone into this - in fact there 562is quite a lot there. However, getting these right is non-trivial and 563there is a high cost associated with going down the wrong path. 564 565For SPL, it may be possible to fit in a simplified driver model with only 566bind and probe methods, to reduce size. 567 568Uclasses are statically numbered at compile time. It would be possible to 569change this to dynamic numbering, but then we would require some sort of 570lookup service, perhaps searching by name. This is slightly less efficient 571so has been left out for now. One small advantage of dynamic numbering might 572be fewer merge conflicts in uclass-id.h. 573 574 575Simon Glass 576sjg@chromium.org 577April 2013 578Updated 7-May-13 579Updated 14-Jun-13 580Updated 18-Oct-13 581Updated 5-Nov-13 582