blob: b891e8459d85f2c6dd946939658e7d72e485a84d [file] [log] [blame]
Simon Glass65c70532014-02-26 15:59:17 -07001Driver 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
Chris Packham34e4a2e2014-06-07 10:35:55 +120023 a way of accessing individual devices within the group, but always
Simon Glass65c70532014-02-26 15:59:17 -070024 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
Masahiro Yamada33fcd1b2014-12-19 14:16:44 +090039 make sandbox_defconfig
Simon Glass65c70532014-02-26 15:59:17 -070040 make
Masahiro Yamada33fcd1b2014-12-19 14:16:44 +090041 ./u-boot -d u-boot.dtb
Simon Glass65c70532014-02-26 15:59:17 -070042
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...>
Simon Glass98a16052015-04-19 07:21:01 -060098 Running 53 driver model tests
Simon Glass65c70532014-02-26 15:59:17 -070099 Test: dm_test_autobind
100 Test: dm_test_autoprobe
Simon Glass98a16052015-04-19 07:21:01 -0600101 Test: dm_test_bus_child_post_bind
102 Test: dm_test_bus_child_post_bind_uclass
103 Test: dm_test_bus_child_pre_probe_uclass
Simon Glass1ca7e202014-07-23 06:55:18 -0600104 Test: dm_test_bus_children
Simon Glass98a16052015-04-19 07:21:01 -0600105 Device 'c-test@0': seq 0 is in use by 'd-test'
106 Device 'c-test@1': seq 1 is in use by 'f-test'
Simon Glass997c87b2014-07-23 06:55:19 -0600107 Test: dm_test_bus_children_funcs
Simon Glassa8981d42014-10-13 23:41:49 -0600108 Test: dm_test_bus_children_iterators
Simon Glasse59f4582014-07-23 06:55:20 -0600109 Test: dm_test_bus_parent_data
Simon Glass98a16052015-04-19 07:21:01 -0600110 Test: dm_test_bus_parent_data_uclass
Simon Glassa327dee2014-07-23 06:55:21 -0600111 Test: dm_test_bus_parent_ops
Simon Glass98a16052015-04-19 07:21:01 -0600112 Test: dm_test_bus_parent_platdata
113 Test: dm_test_bus_parent_platdata_uclass
Simon Glass65c70532014-02-26 15:59:17 -0700114 Test: dm_test_children
Simon Glass98a16052015-04-19 07:21:01 -0600115 Test: dm_test_device_get_uclass_id
116 Test: dm_test_eth
117 Using eth@10002000 device
118 Using eth@10003000 device
119 Using eth@10004000 device
120 Test: dm_test_eth_alias
121 Using eth@10002000 device
122 Using eth@10004000 device
123 Using eth@10002000 device
124 Using eth@10003000 device
125 Test: dm_test_eth_prime
126 Using eth@10003000 device
127 Using eth@10002000 device
128 Test: dm_test_eth_rotate
129
130 Error: eth@10004000 address not set.
131
132 Error: eth@10004000 address not set.
133 Using eth@10002000 device
134
135 Error: eth@10004000 address not set.
136
137 Error: eth@10004000 address not set.
138 Using eth@10004000 device
Simon Glass65c70532014-02-26 15:59:17 -0700139 Test: dm_test_fdt
Simon Glassf4cdead2014-07-23 06:55:14 -0600140 Test: dm_test_fdt_offset
Simon Glass00606d72014-07-23 06:55:03 -0600141 Test: dm_test_fdt_pre_reloc
Simon Glass5a66a8f2014-07-23 06:55:12 -0600142 Test: dm_test_fdt_uclass_seq
Simon Glass65c70532014-02-26 15:59:17 -0700143 Test: dm_test_gpio
Simon Glass4b8f11c2014-10-04 11:29:48 -0600144 extra-gpios: get_value: error: gpio b5 not reserved
145 Test: dm_test_gpio_anon
Simon Glass43241742014-10-04 11:29:51 -0600146 Test: dm_test_gpio_copy
147 Test: dm_test_gpio_leak
148 extra-gpios: get_value: error: gpio b5 not reserved
Simon Glass98a16052015-04-19 07:21:01 -0600149 Test: dm_test_gpio_phandles
Simon Glassd44f5972014-10-04 11:29:49 -0600150 Test: dm_test_gpio_requestf
Simon Glass98a16052015-04-19 07:21:01 -0600151 Test: dm_test_i2c_bytewise
152 Test: dm_test_i2c_find
153 Test: dm_test_i2c_offset
154 Test: dm_test_i2c_offset_len
155 Test: dm_test_i2c_probe_empty
156 Test: dm_test_i2c_read_write
157 Test: dm_test_i2c_speed
Simon Glass65c70532014-02-26 15:59:17 -0700158 Test: dm_test_leak
Simon Glass65c70532014-02-26 15:59:17 -0700159 Test: dm_test_lifecycle
Simon Glass98a16052015-04-19 07:21:01 -0600160 Test: dm_test_net_retry
161 Using eth@10004000 device
162 Using eth@10002000 device
163 Using eth@10004000 device
Simon Glass65c70532014-02-26 15:59:17 -0700164 Test: dm_test_operations
165 Test: dm_test_ordering
Simon Glass98a16052015-04-19 07:21:01 -0600166 Test: dm_test_pci_base
167 Test: dm_test_pci_swapcase
Simon Glass65c70532014-02-26 15:59:17 -0700168 Test: dm_test_platdata
Simon Glass00606d72014-07-23 06:55:03 -0600169 Test: dm_test_pre_reloc
Simon Glass65c70532014-02-26 15:59:17 -0700170 Test: dm_test_remove
Simon Glass4b8f11c2014-10-04 11:29:48 -0600171 Test: dm_test_spi_find
172 Invalid chip select 0:0 (err=-19)
173 SF: Failed to get idcodes
Simon Glass4b8f11c2014-10-04 11:29:48 -0600174 SF: Detected M25P16 with page size 256 Bytes, erase size 64 KiB, total 2 MiB
175 Test: dm_test_spi_flash
176 2097152 bytes written in 0 ms
177 SF: Detected M25P16 with page size 256 Bytes, erase size 64 KiB, total 2 MiB
178 SPI flash test:
179 0 erase: 0 ticks, 65536000 KiB/s 524288.000 Mbps
180 1 check: 0 ticks, 65536000 KiB/s 524288.000 Mbps
181 2 write: 0 ticks, 65536000 KiB/s 524288.000 Mbps
182 3 read: 0 ticks, 65536000 KiB/s 524288.000 Mbps
183 Test passed
184 0 erase: 0 ticks, 65536000 KiB/s 524288.000 Mbps
185 1 check: 0 ticks, 65536000 KiB/s 524288.000 Mbps
186 2 write: 0 ticks, 65536000 KiB/s 524288.000 Mbps
187 3 read: 0 ticks, 65536000 KiB/s 524288.000 Mbps
188 Test: dm_test_spi_xfer
189 SF: Detected M25P16 with page size 256 Bytes, erase size 64 KiB, total 2 MiB
Simon Glass65c70532014-02-26 15:59:17 -0700190 Test: dm_test_uclass
Simon Glassc910e2e2014-07-23 06:55:15 -0600191 Test: dm_test_uclass_before_ready
Simon Glass98a16052015-04-19 07:21:01 -0600192 Test: dm_test_usb_base
193 Test: dm_test_usb_flash
194 USB-1: scanning bus 1 for devices... 2 USB Device(s) found
Simon Glass65c70532014-02-26 15:59:17 -0700195 Failures: 0
196
Simon Glass65c70532014-02-26 15:59:17 -0700197
198What is going on?
199-----------------
200
201Let's start at the top. The demo command is in common/cmd_demo.c. It does
Chris Packham34e4a2e2014-06-07 10:35:55 +1200202the usual command processing and then:
Simon Glass65c70532014-02-26 15:59:17 -0700203
Heiko Schocher54c5d082014-05-22 12:43:05 +0200204 struct udevice *demo_dev;
Simon Glass65c70532014-02-26 15:59:17 -0700205
206 ret = uclass_get_device(UCLASS_DEMO, devnum, &demo_dev);
207
208UCLASS_DEMO means the class of devices which implement 'demo'. Other
209classes might be MMC, or GPIO, hashing or serial. The idea is that the
210devices in the class all share a particular way of working. The class
211presents a unified view of all these devices to U-Boot.
212
213This function looks up a device for the demo uclass. Given a device
214number we can find the device because all devices have registered with
215the UCLASS_DEMO uclass.
216
217The device is automatically activated ready for use by uclass_get_device().
218
219Now that we have the device we can do things like:
220
221 return demo_hello(demo_dev, ch);
222
223This function is in the demo uclass. It takes care of calling the 'hello'
224method of the relevant driver. Bearing in mind that there are two drivers,
225this particular device may use one or other of them.
226
227The code for demo_hello() is in drivers/demo/demo-uclass.c:
228
Heiko Schocher54c5d082014-05-22 12:43:05 +0200229int demo_hello(struct udevice *dev, int ch)
Simon Glass65c70532014-02-26 15:59:17 -0700230{
231 const struct demo_ops *ops = device_get_ops(dev);
232
233 if (!ops->hello)
234 return -ENOSYS;
235
236 return ops->hello(dev, ch);
237}
238
239As you can see it just calls the relevant driver method. One of these is
240in drivers/demo/demo-simple.c:
241
Heiko Schocher54c5d082014-05-22 12:43:05 +0200242static int simple_hello(struct udevice *dev, int ch)
Simon Glass65c70532014-02-26 15:59:17 -0700243{
244 const struct dm_demo_pdata *pdata = dev_get_platdata(dev);
245
246 printf("Hello from %08x: %s %d\n", map_to_sysmem(dev),
247 pdata->colour, pdata->sides);
248
249 return 0;
250}
251
252
253So that is a trip from top (command execution) to bottom (driver action)
254but it leaves a lot of topics to address.
255
256
257Declaring Drivers
258-----------------
259
260A driver declaration looks something like this (see
261drivers/demo/demo-shape.c):
262
263static const struct demo_ops shape_ops = {
264 .hello = shape_hello,
265 .status = shape_status,
266};
267
268U_BOOT_DRIVER(demo_shape_drv) = {
269 .name = "demo_shape_drv",
270 .id = UCLASS_DEMO,
271 .ops = &shape_ops,
272 .priv_data_size = sizeof(struct shape_data),
273};
274
275
276This driver has two methods (hello and status) and requires a bit of
277private data (accessible through dev_get_priv(dev) once the driver has
278been probed). It is a member of UCLASS_DEMO so will register itself
279there.
280
281In U_BOOT_DRIVER it is also possible to specify special methods for bind
282and unbind, and these are called at appropriate times. For many drivers
283it is hoped that only 'probe' and 'remove' will be needed.
284
285The U_BOOT_DRIVER macro creates a data structure accessible from C,
286so driver model can find the drivers that are available.
287
288The methods a device can provide are documented in the device.h header.
289Briefly, they are:
290
291 bind - make the driver model aware of a device (bind it to its driver)
292 unbind - make the driver model forget the device
293 ofdata_to_platdata - convert device tree data to platdata - see later
294 probe - make a device ready for use
295 remove - remove a device so it cannot be used until probed again
296
297The sequence to get a device to work is bind, ofdata_to_platdata (if using
298device tree) and probe.
299
300
301Platform Data
302-------------
303
Simon Glass97f3ee32015-07-06 12:54:22 -0600304*** Note: platform data is the old way of doing things. It is
305*** basically a C structure which is passed to drivers to tell them about
306*** platform-specific settings like the address of its registers, bus
307*** speed, etc. Device tree is now the preferred way of handling this.
308*** Unless you have a good reason not to use device tree (the main one
309*** being you need serial support in SPL and don't have enough SRAM for
310*** the cut-down device tree and libfdt libraries) you should stay away
311*** from platform data.
312
Simon Glass22ec1362014-06-11 23:29:55 -0600313Platform data is like Linux platform data, if you are familiar with that.
314It provides the board-specific information to start up a device.
315
316Why is this information not just stored in the device driver itself? The
317idea is that the device driver is generic, and can in principle operate on
318any board that has that type of device. For example, with modern
319highly-complex SoCs it is common for the IP to come from an IP vendor, and
320therefore (for example) the MMC controller may be the same on chips from
321different vendors. It makes no sense to write independent drivers for the
322MMC controller on each vendor's SoC, when they are all almost the same.
323Similarly, we may have 6 UARTs in an SoC, all of which are mostly the same,
324but lie at different addresses in the address space.
325
326Using the UART example, we have a single driver and it is instantiated 6
327times by supplying 6 lots of platform data. Each lot of platform data
328gives the driver name and a pointer to a structure containing information
329about this instance - e.g. the address of the register space. It may be that
330one of the UARTS supports RS-485 operation - this can be added as a flag in
331the platform data, which is set for this one port and clear for the rest.
332
333Think of your driver as a generic piece of code which knows how to talk to
334a device, but needs to know where it is, any variant/option information and
335so on. Platform data provides this link between the generic piece of code
336and the specific way it is bound on a particular board.
337
338Examples of platform data include:
339
340 - The base address of the IP block's register space
341 - Configuration options, like:
342 - the SPI polarity and maximum speed for a SPI controller
343 - the I2C speed to use for an I2C device
344 - the number of GPIOs available in a GPIO device
345
346Where does the platform data come from? It is either held in a structure
347which is compiled into U-Boot, or it can be parsed from the Device Tree
348(see 'Device Tree' below).
349
350For an example of how it can be compiled in, see demo-pdata.c which
Simon Glass65c70532014-02-26 15:59:17 -0700351sets up a table of driver names and their associated platform data.
352The data can be interpreted by the drivers however they like - it is
353basically a communication scheme between the board-specific code and
354the generic drivers, which are intended to work on any board.
355
Chris Packham34e4a2e2014-06-07 10:35:55 +1200356Drivers can access their data via dev->info->platdata. Here is
Simon Glass65c70532014-02-26 15:59:17 -0700357the declaration for the platform data, which would normally appear
358in the board file.
359
360 static const struct dm_demo_cdata red_square = {
361 .colour = "red",
362 .sides = 4.
363 };
364 static const struct driver_info info[] = {
365 {
366 .name = "demo_shape_drv",
367 .platdata = &red_square,
368 },
369 };
370
371 demo1 = driver_bind(root, &info[0]);
372
373
374Device Tree
375-----------
376
377While platdata is useful, a more flexible way of providing device data is
Simon Glass97f3ee32015-07-06 12:54:22 -0600378by using device tree. In U-Boot you should use this where possible. Avoid
379sending patches which make use of the U_BOOT_DEVICE() macro unless strictly
380necessary.
381
382With device tree we replace the above code with the following device tree
383fragment:
Simon Glass65c70532014-02-26 15:59:17 -0700384
385 red-square {
386 compatible = "demo-shape";
387 colour = "red";
388 sides = <4>;
389 };
390
Simon Glass22ec1362014-06-11 23:29:55 -0600391This means that instead of having lots of U_BOOT_DEVICE() declarations in
392the board file, we put these in the device tree. This approach allows a lot
393more generality, since the same board file can support many types of boards
394(e,g. with the same SoC) just by using different device trees. An added
395benefit is that the Linux device tree can be used, thus further simplifying
396the task of board-bring up either for U-Boot or Linux devs (whoever gets to
397the board first!).
Simon Glass65c70532014-02-26 15:59:17 -0700398
399The easiest way to make this work it to add a few members to the driver:
400
401 .platdata_auto_alloc_size = sizeof(struct dm_test_pdata),
402 .ofdata_to_platdata = testfdt_ofdata_to_platdata,
Simon Glass65c70532014-02-26 15:59:17 -0700403
404The 'auto_alloc' feature allowed space for the platdata to be allocated
Simon Glass22ec1362014-06-11 23:29:55 -0600405and zeroed before the driver's ofdata_to_platdata() method is called. The
406ofdata_to_platdata() method, which the driver write supplies, should parse
407the device tree node for this device and place it in dev->platdata. Thus
408when the probe method is called later (to set up the device ready for use)
409the platform data will be present.
Simon Glass65c70532014-02-26 15:59:17 -0700410
411Note that both methods are optional. If you provide an ofdata_to_platdata
Simon Glass22ec1362014-06-11 23:29:55 -0600412method then it will be called first (during activation). If you provide a
413probe method it will be called next. See Driver Lifecycle below for more
414details.
Simon Glass65c70532014-02-26 15:59:17 -0700415
416If you don't want to have the platdata automatically allocated then you
417can leave out platdata_auto_alloc_size. In this case you can use malloc
418in your ofdata_to_platdata (or probe) method to allocate the required memory,
419and you should free it in the remove method.
420
Simon Glass2f3b95d2015-01-25 08:26:58 -0700421The driver model tree is intended to mirror that of the device tree. The
422root driver is at device tree offset 0 (the root node, '/'), and its
423children are the children of the root node.
424
Simon Glass65c70532014-02-26 15:59:17 -0700425
426Declaring Uclasses
427------------------
428
429The demo uclass is declared like this:
430
431U_BOOT_CLASS(demo) = {
432 .id = UCLASS_DEMO,
433};
434
435It is also possible to specify special methods for probe, etc. The uclass
436numbering comes from include/dm/uclass.h. To add a new uclass, add to the
437end of the enum there, then declare your uclass as above.
438
439
Simon Glass5a66a8f2014-07-23 06:55:12 -0600440Device Sequence Numbers
441-----------------------
442
443U-Boot numbers devices from 0 in many situations, such as in the command
444line for I2C and SPI buses, and the device names for serial ports (serial0,
445serial1, ...). Driver model supports this numbering and permits devices
Simon Glass9cc36a22015-01-25 08:27:05 -0700446to be locating by their 'sequence'. This numbering uniquely identifies a
Simon Glass547cea12014-10-13 23:41:51 -0600447device in its uclass, so no two devices within a particular uclass can have
448the same sequence number.
Simon Glass5a66a8f2014-07-23 06:55:12 -0600449
450Sequence numbers start from 0 but gaps are permitted. For example, a board
Simon Glass9cc36a22015-01-25 08:27:05 -0700451may have I2C buses 1, 4, 5 but no 0, 2 or 3. The choice of how devices are
Simon Glass5a66a8f2014-07-23 06:55:12 -0600452numbered is up to a particular board, and may be set by the SoC in some
453cases. While it might be tempting to automatically renumber the devices
454where there are gaps in the sequence, this can lead to confusion and is
455not the way that U-Boot works.
456
457Each device can request a sequence number. If none is required then the
458device will be automatically allocated the next available sequence number.
459
460To specify the sequence number in the device tree an alias is typically
Simon Glass9cc36a22015-01-25 08:27:05 -0700461used. Make sure that the uclass has the DM_UC_FLAG_SEQ_ALIAS flag set.
Simon Glass5a66a8f2014-07-23 06:55:12 -0600462
463aliases {
464 serial2 = "/serial@22230000";
465};
466
467This indicates that in the uclass called "serial", the named node
468("/serial@22230000") will be given sequence number 2. Any command or driver
469which requests serial device 2 will obtain this device.
470
Simon Glass9cc36a22015-01-25 08:27:05 -0700471More commonly you can use node references, which expand to the full path:
Simon Glass5a66a8f2014-07-23 06:55:12 -0600472
Simon Glass9cc36a22015-01-25 08:27:05 -0700473aliases {
474 serial2 = &serial_2;
475};
476...
477serial_2: serial@22230000 {
478...
479};
Simon Glass5a66a8f2014-07-23 06:55:12 -0600480
Simon Glass9cc36a22015-01-25 08:27:05 -0700481The alias resolves to the same string in this case, but this version is
482easier to read.
Simon Glass5a66a8f2014-07-23 06:55:12 -0600483
484Device sequence numbers are resolved when a device is probed. Before then
485the sequence number is only a request which may or may not be honoured,
486depending on what other devices have been probed. However the numbering is
487entirely under the control of the board author so a conflict is generally
488an error.
489
490
Simon Glassa327dee2014-07-23 06:55:21 -0600491Bus Drivers
492-----------
493
494A common use of driver model is to implement a bus, a device which provides
495access to other devices. Example of buses include SPI and I2C. Typically
496the bus provides some sort of transport or translation that makes it
497possible to talk to the devices on the bus.
498
Simon Glass2017aae2015-01-25 08:27:20 -0700499Driver model provides some useful features to help with implementing buses.
500Firstly, a bus can request that its children store some 'parent data' which
501can be used to keep track of child state. Secondly, the bus can define
502methods which are called when a child is probed or removed. This is similar
503to the methods the uclass driver provides. Thirdly, per-child platform data
504can be provided to specify things like the child's address on the bus. This
505persists across child probe()/remove() cycles.
506
507For consistency and ease of implementation, the bus uclass can specify the
508per-child platform data, so that it can be the same for all children of buses
509in that uclass. There are also uclass methods which can be called when
510children are bound and probed.
Simon Glassa327dee2014-07-23 06:55:21 -0600511
512Here an explanation of how a bus fits with a uclass may be useful. Consider
513a USB bus with several devices attached to it, each from a different (made
514up) uclass:
515
516 xhci_usb (UCLASS_USB)
517 eth (UCLASS_ETHERNET)
518 camera (UCLASS_CAMERA)
519 flash (UCLASS_FLASH_STORAGE)
520
521Each of the devices is connected to a different address on the USB bus.
522The bus device wants to store this address and some other information such
523as the bus speed for each device.
524
Simon Glass2017aae2015-01-25 08:27:20 -0700525To achieve this, the bus device can use dev->parent_platdata in each of its
526three children. This can be auto-allocated if the bus driver (or bus uclass)
527has a non-zero value for per_child_platdata_auto_alloc_size. If not, then
528the bus device or uclass can allocate the space itself before the child
529device is probed.
Simon Glassa327dee2014-07-23 06:55:21 -0600530
531Also the bus driver can define the child_pre_probe() and child_post_remove()
532methods to allow it to do some processing before the child is activated or
533after it is deactivated.
534
Simon Glass2017aae2015-01-25 08:27:20 -0700535Similarly the bus uclass can define the child_post_bind() method to obtain
536the per-child platform data from the device tree and set it up for the child.
537The bus uclass can also provide a child_pre_probe() method. Very often it is
538the bus uclass that controls these features, since it avoids each driver
539having to do the same processing. Of course the driver can still tweak and
540override these activities.
541
Simon Glassa327dee2014-07-23 06:55:21 -0600542Note that the information that controls this behaviour is in the bus's
543driver, not the child's. In fact it is possible that child has no knowledge
544that it is connected to a bus. The same child device may even be used on two
545different bus types. As an example. the 'flash' device shown above may also
546be connected on a SATA bus or standalone with no bus:
547
548 xhci_usb (UCLASS_USB)
549 flash (UCLASS_FLASH_STORAGE) - parent data/methods defined by USB bus
550
551 sata (UCLASS_SATA)
552 flash (UCLASS_FLASH_STORAGE) - parent data/methods defined by SATA bus
553
554 flash (UCLASS_FLASH_STORAGE) - no parent data/methods (not on a bus)
555
556Above you can see that the driver for xhci_usb/sata controls the child's
557bus methods. In the third example the device is not on a bus, and therefore
558will not have these methods at all. Consider the case where the flash
559device defines child methods. These would be used for *its* children, and
560would be quite separate from the methods defined by the driver for the bus
561that the flash device is connetced to. The act of attaching a device to a
562parent device which is a bus, causes the device to start behaving like a
563bus device, regardless of its own views on the matter.
564
565The uclass for the device can also contain data private to that uclass.
566But note that each device on the bus may be a memeber of a different
567uclass, and this data has nothing to do with the child data for each child
Simon Glass2017aae2015-01-25 08:27:20 -0700568on the bus. It is the bus' uclass that controls the child with respect to
569the bus.
Simon Glassa327dee2014-07-23 06:55:21 -0600570
571
Simon Glass22ec1362014-06-11 23:29:55 -0600572Driver Lifecycle
573----------------
574
575Here are the stages that a device goes through in driver model. Note that all
576methods mentioned here are optional - e.g. if there is no probe() method for
577a device then it will not be called. A simple device may have very few
578methods actually defined.
579
5801. Bind stage
581
582A device and its driver are bound using one of these two methods:
583
584 - Scan the U_BOOT_DEVICE() definitions. U-Boot It looks up the
585name specified by each, to find the appropriate driver. It then calls
586device_bind() to create a new device and bind' it to its driver. This will
587call the device's bind() method.
588
589 - Scan through the device tree definitions. U-Boot looks at top-level
590nodes in the the device tree. It looks at the compatible string in each node
591and uses the of_match part of the U_BOOT_DRIVER() structure to find the
592right driver for each node. It then calls device_bind() to bind the
593newly-created device to its driver (thereby creating a device structure).
594This will also call the device's bind() method.
595
596At this point all the devices are known, and bound to their drivers. There
597is a 'struct udevice' allocated for all devices. However, nothing has been
598activated (except for the root device). Each bound device that was created
599from a U_BOOT_DEVICE() declaration will hold the platdata pointer specified
600in that declaration. For a bound device created from the device tree,
601platdata will be NULL, but of_offset will be the offset of the device tree
602node that caused the device to be created. The uclass is set correctly for
603the device.
604
605The device's bind() method is permitted to perform simple actions, but
606should not scan the device tree node, not initialise hardware, nor set up
607structures or allocate memory. All of these tasks should be left for
608the probe() method.
609
610Note that compared to Linux, U-Boot's driver model has a separate step of
611probe/remove which is independent of bind/unbind. This is partly because in
612U-Boot it may be expensive to probe devices and we don't want to do it until
613they are needed, or perhaps until after relocation.
614
6152. Activation/probe
616
617When a device needs to be used, U-Boot activates it, by following these
618steps (see device_probe()):
619
620 a. If priv_auto_alloc_size is non-zero, then the device-private space
621 is allocated for the device and zeroed. It will be accessible as
622 dev->priv. The driver can put anything it likes in there, but should use
623 it for run-time information, not platform data (which should be static
624 and known before the device is probed).
625
626 b. If platdata_auto_alloc_size is non-zero, then the platform data space
627 is allocated. This is only useful for device tree operation, since
628 otherwise you would have to specific the platform data in the
629 U_BOOT_DEVICE() declaration. The space is allocated for the device and
630 zeroed. It will be accessible as dev->platdata.
631
632 c. If the device's uclass specifies a non-zero per_device_auto_alloc_size,
633 then this space is allocated and zeroed also. It is allocated for and
634 stored in the device, but it is uclass data. owned by the uclass driver.
635 It is possible for the device to access it.
636
Simon Glasse59f4582014-07-23 06:55:20 -0600637 d. If the device's immediate parent specifies a per_child_auto_alloc_size
638 then this space is allocated. This is intended for use by the parent
639 device to keep track of things related to the child. For example a USB
640 flash stick attached to a USB host controller would likely use this
641 space. The controller can hold information about the USB state of each
642 of its children.
643
644 e. All parent devices are probed. It is not possible to activate a device
Simon Glass22ec1362014-06-11 23:29:55 -0600645 unless its predecessors (all the way up to the root device) are activated.
646 This means (for example) that an I2C driver will require that its bus
647 be activated.
648
Simon Glasse59f4582014-07-23 06:55:20 -0600649 f. The device's sequence number is assigned, either the requested one
Simon Glass5a66a8f2014-07-23 06:55:12 -0600650 (assuming no conflicts) or the next available one if there is a conflict
651 or nothing particular is requested.
652
Simon Glasse59f4582014-07-23 06:55:20 -0600653 g. If the driver provides an ofdata_to_platdata() method, then this is
Simon Glass22ec1362014-06-11 23:29:55 -0600654 called to convert the device tree data into platform data. This should
655 do various calls like fdtdec_get_int(gd->fdt_blob, dev->of_offset, ...)
656 to access the node and store the resulting information into dev->platdata.
657 After this point, the device works the same way whether it was bound
658 using a device tree node or U_BOOT_DEVICE() structure. In either case,
659 the platform data is now stored in the platdata structure. Typically you
660 will use the platdata_auto_alloc_size feature to specify the size of the
661 platform data structure, and U-Boot will automatically allocate and zero
662 it for you before entry to ofdata_to_platdata(). But if not, you can
663 allocate it yourself in ofdata_to_platdata(). Note that it is preferable
664 to do all the device tree decoding in ofdata_to_platdata() rather than
665 in probe(). (Apart from the ugliness of mixing configuration and run-time
666 data, one day it is possible that U-Boot will cache platformat data for
667 devices which are regularly de/activated).
668
Simon Glasse59f4582014-07-23 06:55:20 -0600669 h. The device's probe() method is called. This should do anything that
Simon Glass22ec1362014-06-11 23:29:55 -0600670 is required by the device to get it going. This could include checking
671 that the hardware is actually present, setting up clocks for the
672 hardware and setting up hardware registers to initial values. The code
673 in probe() can access:
674
675 - platform data in dev->platdata (for configuration)
676 - private data in dev->priv (for run-time state)
677 - uclass data in dev->uclass_priv (for things the uclass stores
678 about this device)
679
680 Note: If you don't use priv_auto_alloc_size then you will need to
681 allocate the priv space here yourself. The same applies also to
682 platdata_auto_alloc_size. Remember to free them in the remove() method.
683
Simon Glasse59f4582014-07-23 06:55:20 -0600684 i. The device is marked 'activated'
Simon Glass22ec1362014-06-11 23:29:55 -0600685
Simon Glasse59f4582014-07-23 06:55:20 -0600686 j. The uclass's post_probe() method is called, if one exists. This may
Simon Glass22ec1362014-06-11 23:29:55 -0600687 cause the uclass to do some housekeeping to record the device as
688 activated and 'known' by the uclass.
689
6903. Running stage
691
692The device is now activated and can be used. From now until it is removed
693all of the above structures are accessible. The device appears in the
694uclass's list of devices (so if the device is in UCLASS_GPIO it will appear
695as a device in the GPIO uclass). This is the 'running' state of the device.
696
6974. Removal stage
698
699When the device is no-longer required, you can call device_remove() to
700remove it. This performs the probe steps in reverse:
701
702 a. The uclass's pre_remove() method is called, if one exists. This may
703 cause the uclass to do some housekeeping to record the device as
704 deactivated and no-longer 'known' by the uclass.
705
706 b. All the device's children are removed. It is not permitted to have
707 an active child device with a non-active parent. This means that
708 device_remove() is called for all the children recursively at this point.
709
710 c. The device's remove() method is called. At this stage nothing has been
711 deallocated so platform data, private data and the uclass data will all
712 still be present. This is where the hardware can be shut down. It is
713 intended that the device be completely inactive at this point, For U-Boot
714 to be sure that no hardware is running, it should be enough to remove
715 all devices.
716
Simon Glasse59f4582014-07-23 06:55:20 -0600717 d. The device memory is freed (platform data, private data, uclass data,
718 parent data).
Simon Glass22ec1362014-06-11 23:29:55 -0600719
720 Note: Because the platform data for a U_BOOT_DEVICE() is defined with a
721 static pointer, it is not de-allocated during the remove() method. For
722 a device instantiated using the device tree data, the platform data will
723 be dynamically allocated, and thus needs to be deallocated during the
724 remove() method, either:
725
726 1. if the platdata_auto_alloc_size is non-zero, the deallocation
727 happens automatically within the driver model core; or
728
729 2. when platdata_auto_alloc_size is 0, both the allocation (in probe()
730 or preferably ofdata_to_platdata()) and the deallocation in remove()
731 are the responsibility of the driver author.
732
Simon Glass5a66a8f2014-07-23 06:55:12 -0600733 e. The device sequence number is set to -1, meaning that it no longer
734 has an allocated sequence. If the device is later reactivated and that
735 sequence number is still free, it may well receive the name sequence
736 number again. But from this point, the sequence number previously used
737 by this device will no longer exist (think of SPI bus 2 being removed
738 and bus 2 is no longer available for use).
739
740 f. The device is marked inactive. Note that it is still bound, so the
Simon Glass22ec1362014-06-11 23:29:55 -0600741 device structure itself is not freed at this point. Should the device be
742 activated again, then the cycle starts again at step 2 above.
743
7445. Unbind stage
745
746The device is unbound. This is the step that actually destroys the device.
747If a parent has children these will be destroyed first. After this point
748the device does not exist and its memory has be deallocated.
749
750
Simon Glass65c70532014-02-26 15:59:17 -0700751Data Structures
752---------------
753
754Driver model uses a doubly-linked list as the basic data structure. Some
755nodes have several lists running through them. Creating a more efficient
756data structure might be worthwhile in some rare cases, once we understand
757what the bottlenecks are.
758
759
760Changes since v1
761----------------
762
763For the record, this implementation uses a very similar approach to the
764original patches, but makes at least the following changes:
765
Chris Packham34e4a2e2014-06-07 10:35:55 +1200766- Tried to aggressively remove boilerplate, so that for most drivers there
Simon Glass65c70532014-02-26 15:59:17 -0700767is little or no 'driver model' code to write.
768- Moved some data from code into data structure - e.g. store a pointer to
769the driver operations structure in the driver, rather than passing it
770to the driver bind function.
Simon Glassae7f4512014-06-11 23:29:45 -0600771- Rename some structures to make them more similar to Linux (struct udevice
Simon Glass65c70532014-02-26 15:59:17 -0700772instead of struct instance, struct platdata, etc.)
773- Change the name 'core' to 'uclass', meaning U-Boot class. It seems that
774this concept relates to a class of drivers (or a subsystem). We shouldn't
775use 'class' since it is a C++ reserved word, so U-Boot class (uclass) seems
776better than 'core'.
Heiko Schocher54c5d082014-05-22 12:43:05 +0200777- Remove 'struct driver_instance' and just use a single 'struct udevice'.
Simon Glass65c70532014-02-26 15:59:17 -0700778This removes a level of indirection that doesn't seem necessary.
779- Built in device tree support, to avoid the need for platdata
780- Removed the concept of driver relocation, and just make it possible for
781the new driver (created after relocation) to access the old driver data.
782I feel that relocation is a very special case and will only apply to a few
783drivers, many of which can/will just re-init anyway. So the overhead of
784dealing with this might not be worth it.
785- Implemented a GPIO system, trying to keep it simple
786
787
Simon Glass00606d72014-07-23 06:55:03 -0600788Pre-Relocation Support
789----------------------
790
791For pre-relocation we simply call the driver model init function. Only
792drivers marked with DM_FLAG_PRE_RELOC or the device tree
793'u-boot,dm-pre-reloc' flag are initialised prior to relocation. This helps
794to reduce the driver model overhead.
795
796Then post relocation we throw that away and re-init driver model again.
797For drivers which require some sort of continuity between pre- and
798post-relocation devices, we can provide access to the pre-relocation
799device pointers, but this is not currently implemented (the root device
800pointer is saved but not made available through the driver model API).
801
802
Simon Glass38687ae2014-11-10 17:16:54 -0700803SPL Support
804-----------
805
806Driver model can operate in SPL. Its efficient implementation and small code
807size provide for a small overhead which is acceptable for all but the most
808constrained systems.
809
810To enable driver model in SPL, define CONFIG_SPL_DM. You might want to
811consider the following option also. See the main README for more details.
812
813 - CONFIG_SYS_MALLOC_SIMPLE
814 - CONFIG_DM_WARN
815 - CONFIG_DM_DEVICE_REMOVE
816 - CONFIG_DM_STDIO
817
818
819Enabling Driver Model
820---------------------
821
822Driver model is being brought into U-Boot gradually. As each subsystems gets
823support, a uclass is created and a CONFIG to enable use of driver model for
824that subsystem.
825
826For example CONFIG_DM_SERIAL enables driver model for serial. With that
827defined, the old serial support is not enabled, and your serial driver must
828conform to driver model. With that undefined, the old serial support is
829enabled and driver model is not available for serial. This means that when
830you convert a driver, you must either convert all its boards, or provide for
831the driver to be compiled both with and without driver model (generally this
832is not very hard).
833
834See the main README for full details of the available driver model CONFIG
835options.
836
837
Simon Glass65c70532014-02-26 15:59:17 -0700838Things to punt for later
839------------------------
840
Simon Glass65c70532014-02-26 15:59:17 -0700841Uclasses are statically numbered at compile time. It would be possible to
842change this to dynamic numbering, but then we would require some sort of
843lookup service, perhaps searching by name. This is slightly less efficient
844so has been left out for now. One small advantage of dynamic numbering might
845be fewer merge conflicts in uclass-id.h.
846
847
848Simon Glass
849sjg@chromium.org
850April 2013
851Updated 7-May-13
852Updated 14-Jun-13
853Updated 18-Oct-13
854Updated 5-Nov-13