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