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