Eric Lee / smarc-uboot | Embedian Git Server

Commit 5513023cb74e56b3d6205f3ccc2d6a9ec8866369

Authored by Heiko Stübner 2017-02-19 02:46:21 +0800

Committed by Lokesh Vutla 2017-05-24 12:19:24 +0800

Exists in v2017.01-smarct4x and in 2 other branches

dm: allow limiting pre-reloc markings to spl or tpl

Right now the u-boot,dm-pre-reloc flag will make each marked node
always appear in both spl and tpl. But systems needing an additional
tpl might have special constraints for each, like the spl needing to
be very tiny.

So introduce two additional flags to mark nodes for only spl or tpl
environments and introduce a function dm_fdt_pre_reloc to automate
the necessary checks in code instances checking for pre-relocation
flags.

The behaviour of the original flag stays untouched and still marks
a node for both spl and tpl.

Signed-off-by: Heiko Stuebner <heiko@sntech.de>
Reviewed-by: Simon Glass <sjg@chromium.org>
Tested-by: Kever Yang <kever.yang@rock-chips.com>

Showing 8 changed files with 68 additions and 4 deletions Inline Diff

doc/driver-model/README.txt
drivers/clk/at91/pmc.c
drivers/core/root.c
drivers/core/util.c
drivers/pinctrl/pinctrl-uclass.c
include/dm/util.h
scripts/Makefile.spl
tools/dtoc/dtoc.py

doc/driver-model/README.txt

Diff comments View file @ 5513023

 Driver Model
 ============
 This README contains high-level information about driver model, a unified
 way of declaring and accessing drivers in U-Boot. The original work was done
 by:
    Marek Vasut <marex@denx.de>
    Pavel Herrmann <morpheus.ibis@gmail.com>
    Viktor Křivák <viktor.krivak@gmail.com>
    Tomas Hlavacek <tmshlvck@gmail.com>
 This has been both simplified and extended into the current implementation
 by:
    Simon Glass <sjg@chromium.org>
 Terminology
 -----------
 Uclass - a group of devices which operate in the same way. A uclass provides
 	a way of accessing individual devices within the group, but always
 	using the same interface. For example a GPIO uclass provides
 	operations for get/set value. An I2C uclass may have 10 I2C ports,
 	4 with one driver, and 6 with another.
 Driver - some code which talks to a peripheral and presents a higher-level
 	interface to it.
 Device - an instance of a driver, tied to a particular port or peripheral.
 How to try it
 -------------
 Build U-Boot sandbox and run it:
    make sandbox_defconfig
    make
    ./u-boot -d u-boot.dtb
    (type 'reset' to exit U-Boot)
 There is a uclass called 'demo'. This uclass handles
 saying hello, and reporting its status. There are two drivers in this
 uclass:
    - simple: Just prints a message for hello, doesn't implement status
    - shape: Prints shapes and reports number of characters printed as status
 The demo class is pretty simple, but not trivial. The intention is that it
 can be used for testing, so it will implement all driver model features and
 provide good code coverage of them. It does have multiple drivers, it
 handles parameter data and platdata (data which tells the driver how
 to operate on a particular platform) and it uses private driver data.
 To try it, see the example session below:
 =>demo hello 1
 Hello '@' from 07981110: red 4
 =>demo status 2
 Status: 0
 =>demo hello 2
 g
 r@
 e@@
 e@@@
 n@@@@
 g@@@@@
 =>demo status 2
 Status: 21
 =>demo hello 4 ^
   y^^^
  e^^^^^
 l^^^^^^^
 l^^^^^^^
  o^^^^^
   w^^^
 =>demo status 4
 Status: 36
 =>
 Running the tests
 -----------------
 The intent with driver model is that the core portion has 100% test coverage
 in sandbox, and every uclass has its own test. As a move towards this, tests
 are provided in test/dm. To run them, try:
    ./test/py/test.py --bd sandbox --build -k ut_dm -v
 You should see something like this:
 (venv)$ ./test/py/test.py --bd sandbox --build -k ut_dm -v
 +make O=/root/u-boot/build-sandbox -s sandbox_defconfig
 +make O=/root/u-boot/build-sandbox -s -j8
 ============================= test session starts ==============================
 platform linux2 -- Python 2.7.5, pytest-2.9.0, py-1.4.31, pluggy-0.3.1 -- /root/u-boot/venv/bin/python
 cachedir: .cache
 rootdir: /root/u-boot, inifile:
 collected 199 items
 test/py/tests/test_ut.py::test_ut_dm_init PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_adc_bind] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_adc_multi_channel_conversion] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_adc_multi_channel_shot] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_adc_single_channel_conversion] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_adc_single_channel_shot] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_adc_supply] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_adc_wrong_channel_selection] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_autobind] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_autobind_uclass_pdata_alloc] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_autobind_uclass_pdata_valid] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_autoprobe] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_bus_child_post_bind] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_bus_child_post_bind_uclass] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_bus_child_pre_probe_uclass] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_bus_children] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_bus_children_funcs] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_bus_children_iterators] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_bus_parent_data] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_bus_parent_data_uclass] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_bus_parent_ops] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_bus_parent_platdata] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_bus_parent_platdata_uclass] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_children] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_clk_base] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_clk_periph] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_device_get_uclass_id] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_eth] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_eth_act] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_eth_alias] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_eth_prime] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_eth_rotate] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_fdt] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_fdt_offset] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_fdt_pre_reloc] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_fdt_uclass_seq] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_gpio] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_gpio_anon] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_gpio_copy] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_gpio_leak] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_gpio_phandles] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_gpio_requestf] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_i2c_bytewise] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_i2c_find] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_i2c_offset] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_i2c_offset_len] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_i2c_probe_empty] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_i2c_read_write] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_i2c_speed] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_leak] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_led_base] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_led_gpio] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_led_label] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_lifecycle] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_mmc_base] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_net_retry] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_operations] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_ordering] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_pci_base] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_pci_busnum] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_pci_swapcase] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_platdata] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_power_pmic_get] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_power_pmic_io] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_power_regulator_autoset] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_power_regulator_autoset_list] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_power_regulator_get] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_power_regulator_set_get_current] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_power_regulator_set_get_enable] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_power_regulator_set_get_mode] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_power_regulator_set_get_voltage] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_pre_reloc] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_ram_base] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_regmap_base] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_regmap_syscon] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_remoteproc_base] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_remove] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_reset_base] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_reset_walk] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_rtc_base] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_rtc_dual] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_rtc_reset] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_rtc_set_get] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_spi_find] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_spi_flash] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_spi_xfer] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_syscon_base] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_syscon_by_driver_data] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_timer_base] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_uclass] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_uclass_before_ready] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_uclass_devices_find] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_uclass_devices_find_by_name] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_uclass_devices_get] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_uclass_devices_get_by_name] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_usb_base] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_usb_flash] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_usb_keyb] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_usb_multi] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_usb_remove] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_usb_tree] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_usb_tree_remove] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_usb_tree_reorder] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_video_base] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_video_bmp] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_video_bmp_comp] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_video_chars] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_video_context] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_video_rotation1] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_video_rotation2] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_video_rotation3] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_video_text] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_video_truetype] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_video_truetype_bs] PASSED
 test/py/tests/test_ut.py::test_ut[ut_dm_video_truetype_scroll] PASSED
 ======================= 84 tests deselected by '-kut_dm' =======================
 ================== 115 passed, 84 deselected in 3.77 seconds ===================
 What is going on?
 -----------------
 Let's start at the top. The demo command is in common/cmd_demo.c. It does
 the usual command processing and then:
 	struct udevice *demo_dev;
 	ret = uclass_get_device(UCLASS_DEMO, devnum, &demo_dev);
 UCLASS_DEMO means the class of devices which implement 'demo'. Other
 classes might be MMC, or GPIO, hashing or serial. The idea is that the
 devices in the class all share a particular way of working. The class
 presents a unified view of all these devices to U-Boot.
 This function looks up a device for the demo uclass. Given a device
 number we can find the device because all devices have registered with
 the UCLASS_DEMO uclass.
 The device is automatically activated ready for use by uclass_get_device().
 Now that we have the device we can do things like:
 	return demo_hello(demo_dev, ch);
 This function is in the demo uclass. It takes care of calling the 'hello'
 method of the relevant driver. Bearing in mind that there are two drivers,
 this particular device may use one or other of them.
 The code for demo_hello() is in drivers/demo/demo-uclass.c:
 int demo_hello(struct udevice *dev, int ch)
 {
 	const struct demo_ops *ops = device_get_ops(dev);
 	if (!ops->hello)
 		return -ENOSYS;
 	return ops->hello(dev, ch);
 }
 As you can see it just calls the relevant driver method. One of these is
 in drivers/demo/demo-simple.c:
 static int simple_hello(struct udevice *dev, int ch)
 {
 	const struct dm_demo_pdata *pdata = dev_get_platdata(dev);
 	printf("Hello from %08x: %s %d\n", map_to_sysmem(dev),
 	       pdata->colour, pdata->sides);
 	return 0;
 }
 So that is a trip from top (command execution) to bottom (driver action)
 but it leaves a lot of topics to address.
 Declaring Drivers
 -----------------
 A driver declaration looks something like this (see
 drivers/demo/demo-shape.c):
 static const struct demo_ops shape_ops = {
 	.hello = shape_hello,
 	.status = shape_status,
 };
 U_BOOT_DRIVER(demo_shape_drv) = {
 	.name	= "demo_shape_drv",
 	.id	= UCLASS_DEMO,
 	.ops	= &shape_ops,
 	.priv_data_size = sizeof(struct shape_data),
 };
 This driver has two methods (hello and status) and requires a bit of
 private data (accessible through dev_get_priv(dev) once the driver has
 been probed). It is a member of UCLASS_DEMO so will register itself
 there.
 In U_BOOT_DRIVER it is also possible to specify special methods for bind
 and unbind, and these are called at appropriate times. For many drivers
 it is hoped that only 'probe' and 'remove' will be needed.
 The U_BOOT_DRIVER macro creates a data structure accessible from C,
 so driver model can find the drivers that are available.
 The methods a device can provide are documented in the device.h header.
 Briefly, they are:
     bind - make the driver model aware of a device (bind it to its driver)
     unbind - make the driver model forget the device
     ofdata_to_platdata - convert device tree data to platdata - see later
     probe - make a device ready for use
     remove - remove a device so it cannot be used until probed again
 The sequence to get a device to work is bind, ofdata_to_platdata (if using
 device tree) and probe.
 Platform Data
 -------------
 *** Note: platform data is the old way of doing things. It is
 *** basically a C structure which is passed to drivers to tell them about
 *** platform-specific settings like the address of its registers, bus
 *** speed, etc. Device tree is now the preferred way of handling this.
 *** Unless you have a good reason not to use device tree (the main one
 *** being you need serial support in SPL and don't have enough SRAM for
 *** the cut-down device tree and libfdt libraries) you should stay away
 *** from platform data.
 Platform data is like Linux platform data, if you are familiar with that.
 It provides the board-specific information to start up a device.
 Why is this information not just stored in the device driver itself? The
 idea is that the device driver is generic, and can in principle operate on
 any board that has that type of device. For example, with modern
 highly-complex SoCs it is common for the IP to come from an IP vendor, and
 therefore (for example) the MMC controller may be the same on chips from
 different vendors. It makes no sense to write independent drivers for the
 MMC controller on each vendor's SoC, when they are all almost the same.
 Similarly, we may have 6 UARTs in an SoC, all of which are mostly the same,
 but lie at different addresses in the address space.
 Using the UART example, we have a single driver and it is instantiated 6
 times by supplying 6 lots of platform data. Each lot of platform data
 gives the driver name and a pointer to a structure containing information
 about this instance - e.g. the address of the register space. It may be that
 one of the UARTS supports RS-485 operation - this can be added as a flag in
 the platform data, which is set for this one port and clear for the rest.
 Think of your driver as a generic piece of code which knows how to talk to
 a device, but needs to know where it is, any variant/option information and
 so on. Platform data provides this link between the generic piece of code
 and the specific way it is bound on a particular board.
 Examples of platform data include:
    - The base address of the IP block's register space
    - Configuration options, like:
          - the SPI polarity and maximum speed for a SPI controller
          - the I2C speed to use for an I2C device
          - the number of GPIOs available in a GPIO device
 Where does the platform data come from? It is either held in a structure
 which is compiled into U-Boot, or it can be parsed from the Device Tree
 (see 'Device Tree' below).
 For an example of how it can be compiled in, see demo-pdata.c which
 sets up a table of driver names and their associated platform data.
 The data can be interpreted by the drivers however they like - it is
 basically a communication scheme between the board-specific code and
 the generic drivers, which are intended to work on any board.
 Drivers can access their data via dev->info->platdata. Here is
 the declaration for the platform data, which would normally appear
 in the board file.
 	static const struct dm_demo_cdata red_square = {
 		.colour = "red",
 		.sides = 4.
 	};
 	static const struct driver_info info[] = {
 		{
 			.name = "demo_shape_drv",
 			.platdata = &red_square,
 		},
 	};
 	demo1 = driver_bind(root, &info[0]);
 Device Tree
 -----------
 While platdata is useful, a more flexible way of providing device data is
 by using device tree. In U-Boot you should use this where possible. Avoid
 sending patches which make use of the U_BOOT_DEVICE() macro unless strictly
 necessary.
 With device tree we replace the above code with the following device tree
 fragment:
 	red-square {
 		compatible = "demo-shape";
 		colour = "red";
 		sides = <4>;
 	};
 This means that instead of having lots of U_BOOT_DEVICE() declarations in
 the board file, we put these in the device tree. This approach allows a lot
 more generality, since the same board file can support many types of boards
 (e,g. with the same SoC) just by using different device trees. An added
 benefit is that the Linux device tree can be used, thus further simplifying
 the task of board-bring up either for U-Boot or Linux devs (whoever gets to
 the board first!).
 The easiest way to make this work it to add a few members to the driver:
 	.platdata_auto_alloc_size = sizeof(struct dm_test_pdata),
 	.ofdata_to_platdata = testfdt_ofdata_to_platdata,
 The 'auto_alloc' feature allowed space for the platdata to be allocated
 and zeroed before the driver's ofdata_to_platdata() method is called. The
 ofdata_to_platdata() method, which the driver write supplies, should parse
 the device tree node for this device and place it in dev->platdata. Thus
 when the probe method is called later (to set up the device ready for use)
 the platform data will be present.
 Note that both methods are optional. If you provide an ofdata_to_platdata
 method then it will be called first (during activation). If you provide a
 probe method it will be called next. See Driver Lifecycle below for more
 details.
 If you don't want to have the platdata automatically allocated then you
 can leave out platdata_auto_alloc_size. In this case you can use malloc
 in your ofdata_to_platdata (or probe) method to allocate the required memory,
 and you should free it in the remove method.
 The driver model tree is intended to mirror that of the device tree. The
 root driver is at device tree offset 0 (the root node, '/'), and its
 children are the children of the root node.
 Declaring Uclasses
 ------------------
 The demo uclass is declared like this:
 U_BOOT_CLASS(demo) = {
 	.id		= UCLASS_DEMO,
 };
 It is also possible to specify special methods for probe, etc. The uclass
 numbering comes from include/dm/uclass.h. To add a new uclass, add to the
 end of the enum there, then declare your uclass as above.
 Device Sequence Numbers
 -----------------------
 U-Boot numbers devices from 0 in many situations, such as in the command
 line for I2C and SPI buses, and the device names for serial ports (serial0,
 serial1, ...). Driver model supports this numbering and permits devices
 to be locating by their 'sequence'. This numbering uniquely identifies a
 device in its uclass, so no two devices within a particular uclass can have
 the same sequence number.
 Sequence numbers start from 0 but gaps are permitted. For example, a board
 may have I2C buses 1, 4, 5 but no 0, 2 or 3. The choice of how devices are
 numbered is up to a particular board, and may be set by the SoC in some
 cases. While it might be tempting to automatically renumber the devices
 where there are gaps in the sequence, this can lead to confusion and is
 not the way that U-Boot works.
 Each device can request a sequence number. If none is required then the
 device will be automatically allocated the next available sequence number.
 To specify the sequence number in the device tree an alias is typically
 used. Make sure that the uclass has the DM_UC_FLAG_SEQ_ALIAS flag set.
 aliases {
 	serial2 = "/serial@22230000";
 };
 This indicates that in the uclass called "serial", the named node
 ("/serial@22230000") will be given sequence number 2. Any command or driver
 which requests serial device 2 will obtain this device.
 More commonly you can use node references, which expand to the full path:
 aliases {
 	serial2 = &serial_2;
 };
 ...
 serial_2: serial@22230000 {
 ...
 };
 The alias resolves to the same string in this case, but this version is
 easier to read.
 Device sequence numbers are resolved when a device is probed. Before then
 the sequence number is only a request which may or may not be honoured,
 depending on what other devices have been probed. However the numbering is
 entirely under the control of the board author so a conflict is generally
 an error.
 Bus Drivers
 -----------
 A common use of driver model is to implement a bus, a device which provides
 access to other devices. Example of buses include SPI and I2C. Typically
 the bus provides some sort of transport or translation that makes it
 possible to talk to the devices on the bus.
 Driver model provides some useful features to help with implementing buses.
 Firstly, a bus can request that its children store some 'parent data' which
 can be used to keep track of child state. Secondly, the bus can define
 methods which are called when a child is probed or removed. This is similar
 to the methods the uclass driver provides. Thirdly, per-child platform data
 can be provided to specify things like the child's address on the bus. This
 persists across child probe()/remove() cycles.
 For consistency and ease of implementation, the bus uclass can specify the
 per-child platform data, so that it can be the same for all children of buses
 in that uclass. There are also uclass methods which can be called when
 children are bound and probed.
 Here an explanation of how a bus fits with a uclass may be useful. Consider
 a USB bus with several devices attached to it, each from a different (made
 up) uclass:
    xhci_usb (UCLASS_USB)
       eth (UCLASS_ETHERNET)
       camera (UCLASS_CAMERA)
       flash (UCLASS_FLASH_STORAGE)
 Each of the devices is connected to a different address on the USB bus.
 The bus device wants to store this address and some other information such
 as the bus speed for each device.
 To achieve this, the bus device can use dev->parent_platdata in each of its
 three children. This can be auto-allocated if the bus driver (or bus uclass)
 has a non-zero value for per_child_platdata_auto_alloc_size. If not, then
 the bus device or uclass can allocate the space itself before the child
 device is probed.
 Also the bus driver can define the child_pre_probe() and child_post_remove()
 methods to allow it to do some processing before the child is activated or
 after it is deactivated.
 Similarly the bus uclass can define the child_post_bind() method to obtain
 the per-child platform data from the device tree and set it up for the child.
 The bus uclass can also provide a child_pre_probe() method. Very often it is
 the bus uclass that controls these features, since it avoids each driver
 having to do the same processing. Of course the driver can still tweak and
 override these activities.
 Note that the information that controls this behaviour is in the bus's
 driver, not the child's. In fact it is possible that child has no knowledge
 that it is connected to a bus. The same child device may even be used on two
 different bus types. As an example. the 'flash' device shown above may also
 be connected on a SATA bus or standalone with no bus:
    xhci_usb (UCLASS_USB)
       flash (UCLASS_FLASH_STORAGE)  - parent data/methods defined by USB bus
    sata (UCLASS_SATA)
       flash (UCLASS_FLASH_STORAGE)  - parent data/methods defined by SATA bus
    flash (UCLASS_FLASH_STORAGE)  - no parent data/methods (not on a bus)
 Above you can see that the driver for xhci_usb/sata controls the child's
 bus methods. In the third example the device is not on a bus, and therefore
 will not have these methods at all. Consider the case where the flash
 device defines child methods. These would be used for *its* children, and
 would be quite separate from the methods defined by the driver for the bus
 that the flash device is connetced to. The act of attaching a device to a
 parent device which is a bus, causes the device to start behaving like a
 bus device, regardless of its own views on the matter.
 The uclass for the device can also contain data private to that uclass.
 But note that each device on the bus may be a memeber of a different
 uclass, and this data has nothing to do with the child data for each child
 on the bus. It is the bus' uclass that controls the child with respect to
 the bus.
 Driver Lifecycle
 ----------------
 Here are the stages that a device goes through in driver model. Note that all
 methods mentioned here are optional - e.g. if there is no probe() method for
 a device then it will not be called. A simple device may have very few
 methods actually defined.
 1. Bind stage
 U-Boot discovers devices using one of these two methods:
    - Scan the U_BOOT_DEVICE() definitions. U-Boot looks up the name specified
 by each, to find the appropriate U_BOOT_DRIVER() definition. In this case,
 there is no path by which driver_data may be provided, but the U_BOOT_DEVICE()
 may provide platdata.
    - Scan through the device tree definitions. U-Boot looks at top-level
 nodes in the the device tree. It looks at the compatible string in each node
 and uses the of_match table of the U_BOOT_DRIVER() structure to find the
 right driver for each node. In this case, the of_match table may provide a
 driver_data value, but platdata cannot be provided until later.
 For each device that is discovered, U-Boot then calls device_bind() to create a
 new device, initializes various core fields of the device object such as name,
 uclass & driver, initializes any optional fields of the device object that are
 applicable such as of_offset, driver_data & platdata, and finally calls the
 driver's bind() method if one is defined.
 At this point all the devices are known, and bound to their drivers. There
 is a 'struct udevice' allocated for all devices. However, nothing has been
 activated (except for the root device). Each bound device that was created
 from a U_BOOT_DEVICE() declaration will hold the platdata pointer specified
 in that declaration. For a bound device created from the device tree,
 platdata will be NULL, but of_offset will be the offset of the device tree
 node that caused the device to be created. The uclass is set correctly for
 the device.
 The device's bind() method is permitted to perform simple actions, but
 should not scan the device tree node, not initialise hardware, nor set up
 structures or allocate memory. All of these tasks should be left for
 the probe() method.
 Note that compared to Linux, U-Boot's driver model has a separate step of
 probe/remove which is independent of bind/unbind. This is partly because in
 U-Boot it may be expensive to probe devices and we don't want to do it until
 they are needed, or perhaps until after relocation.
 2. Activation/probe
 When a device needs to be used, U-Boot activates it, by following these
 steps (see device_probe()):
    a. If priv_auto_alloc_size is non-zero, then the device-private space
    is allocated for the device and zeroed. It will be accessible as
    dev->priv. The driver can put anything it likes in there, but should use
    it for run-time information, not platform data (which should be static
    and known before the device is probed).
    b. If platdata_auto_alloc_size is non-zero, then the platform data space
    is allocated. This is only useful for device tree operation, since
    otherwise you would have to specific the platform data in the
    U_BOOT_DEVICE() declaration. The space is allocated for the device and
    zeroed. It will be accessible as dev->platdata.
    c. If the device's uclass specifies a non-zero per_device_auto_alloc_size,
    then this space is allocated and zeroed also. It is allocated for and
    stored in the device, but it is uclass data. owned by the uclass driver.
    It is possible for the device to access it.
    d. If the device's immediate parent specifies a per_child_auto_alloc_size
    then this space is allocated. This is intended for use by the parent
    device to keep track of things related to the child. For example a USB
    flash stick attached to a USB host controller would likely use this
    space. The controller can hold information about the USB state of each
    of its children.
    e. All parent devices are probed. It is not possible to activate a device
    unless its predecessors (all the way up to the root device) are activated.
    This means (for example) that an I2C driver will require that its bus
    be activated.
    f. The device's sequence number is assigned, either the requested one
    (assuming no conflicts) or the next available one if there is a conflict
    or nothing particular is requested.
    g. If the driver provides an ofdata_to_platdata() method, then this is
    called to convert the device tree data into platform data. This should
    do various calls like fdtdec_get_int(gd->fdt_blob, dev->of_offset, ...)
    to access the node and store the resulting information into dev->platdata.
    After this point, the device works the same way whether it was bound
    using a device tree node or U_BOOT_DEVICE() structure. In either case,
    the platform data is now stored in the platdata structure. Typically you
    will use the platdata_auto_alloc_size feature to specify the size of the
    platform data structure, and U-Boot will automatically allocate and zero
    it for you before entry to ofdata_to_platdata(). But if not, you can
    allocate it yourself in ofdata_to_platdata(). Note that it is preferable
    to do all the device tree decoding in ofdata_to_platdata() rather than
    in probe(). (Apart from the ugliness of mixing configuration and run-time
    data, one day it is possible that U-Boot will cache platformat data for
    devices which are regularly de/activated).
    h. The device's probe() method is called. This should do anything that
    is required by the device to get it going. This could include checking
    that the hardware is actually present, setting up clocks for the
    hardware and setting up hardware registers to initial values. The code
    in probe() can access:
       - platform data in dev->platdata (for configuration)
       - private data in dev->priv (for run-time state)
       - uclass data in dev->uclass_priv (for things the uclass stores
         about this device)
    Note: If you don't use priv_auto_alloc_size then you will need to
    allocate the priv space here yourself. The same applies also to
    platdata_auto_alloc_size. Remember to free them in the remove() method.
    i. The device is marked 'activated'
    j. The uclass's post_probe() method is called, if one exists. This may
    cause the uclass to do some housekeeping to record the device as
    activated and 'known' by the uclass.
 3. Running stage
 The device is now activated and can be used. From now until it is removed
 all of the above structures are accessible. The device appears in the
 uclass's list of devices (so if the device is in UCLASS_GPIO it will appear
 as a device in the GPIO uclass). This is the 'running' state of the device.
 4. Removal stage
 When the device is no-longer required, you can call device_remove() to
 remove it. This performs the probe steps in reverse:
    a. The uclass's pre_remove() method is called, if one exists. This may
    cause the uclass to do some housekeeping to record the device as
    deactivated and no-longer 'known' by the uclass.
    b. All the device's children are removed. It is not permitted to have
    an active child device with a non-active parent. This means that
    device_remove() is called for all the children recursively at this point.
    c. The device's remove() method is called. At this stage nothing has been
    deallocated so platform data, private data and the uclass data will all
    still be present. This is where the hardware can be shut down. It is
    intended that the device be completely inactive at this point, For U-Boot
    to be sure that no hardware is running, it should be enough to remove
    all devices.
    d. The device memory is freed (platform data, private data, uclass data,
    parent data).
    Note: Because the platform data for a U_BOOT_DEVICE() is defined with a
    static pointer, it is not de-allocated during the remove() method. For
    a device instantiated using the device tree data, the platform data will
    be dynamically allocated, and thus needs to be deallocated during the
    remove() method, either:
       1. if the platdata_auto_alloc_size is non-zero, the deallocation
       happens automatically within the driver model core; or
       2. when platdata_auto_alloc_size is 0, both the allocation (in probe()
       or preferably ofdata_to_platdata()) and the deallocation in remove()
       are the responsibility of the driver author.
    e. The device sequence number is set to -1, meaning that it no longer
    has an allocated sequence. If the device is later reactivated and that
    sequence number is still free, it may well receive the name sequence
    number again. But from this point, the sequence number previously used
    by this device will no longer exist (think of SPI bus 2 being removed
    and bus 2 is no longer available for use).
    f. The device is marked inactive. Note that it is still bound, so the
    device structure itself is not freed at this point. Should the device be
    activated again, then the cycle starts again at step 2 above.
 5. Unbind stage
 The device is unbound. This is the step that actually destroys the device.
 If a parent has children these will be destroyed first. After this point
 the device does not exist and its memory has be deallocated.
 Data Structures
 ---------------
 Driver model uses a doubly-linked list as the basic data structure. Some
 nodes have several lists running through them. Creating a more efficient
 data structure might be worthwhile in some rare cases, once we understand
 what the bottlenecks are.
 Changes since v1
 ----------------
 For the record, this implementation uses a very similar approach to the
 original patches, but makes at least the following changes:
 - Tried to aggressively remove boilerplate, so that for most drivers there
 is little or no 'driver model' code to write.
 - Moved some data from code into data structure - e.g. store a pointer to
 the driver operations structure in the driver, rather than passing it
 to the driver bind function.
 - Rename some structures to make them more similar to Linux (struct udevice
 instead of struct instance, struct platdata, etc.)
 - Change the name 'core' to 'uclass', meaning U-Boot class. It seems that
 this concept relates to a class of drivers (or a subsystem). We shouldn't
 use 'class' since it is a C++ reserved word, so U-Boot class (uclass) seems
 better than 'core'.
 - Remove 'struct driver_instance' and just use a single 'struct udevice'.
 This removes a level of indirection that doesn't seem necessary.
 - Built in device tree support, to avoid the need for platdata
 - Removed the concept of driver relocation, and just make it possible for
 the new driver (created after relocation) to access the old driver data.
 I feel that relocation is a very special case and will only apply to a few
 drivers, many of which can/will just re-init anyway. So the overhead of
 dealing with this might not be worth it.
 - Implemented a GPIO system, trying to keep it simple
 Pre-Relocation Support
 ----------------------
 For pre-relocation we simply call the driver model init function. Only
 drivers marked with DM_FLAG_PRE_RELOC or the device tree
 'u-boot,dm-pre-reloc' flag are initialised prior to relocation. This helps
 to reduce the driver model overhead.
+It is possible to limit this to specific relocation steps, by using
+the more specialized 'u-boot,dm-spl' and 'u-boot,dm-tpl' flags
+in the devicetree.
 Then post relocation we throw that away and re-init driver model again.
 For drivers which require some sort of continuity between pre- and
 post-relocation devices, we can provide access to the pre-relocation
 device pointers, but this is not currently implemented (the root device
 pointer is saved but not made available through the driver model API).
 SPL Support
 -----------
 Driver model can operate in SPL. Its efficient implementation and small code
 size provide for a small overhead which is acceptable for all but the most
 constrained systems.
 To enable driver model in SPL, define CONFIG_SPL_DM. You might want to
 consider the following option also. See the main README for more details.
    - CONFIG_SYS_MALLOC_SIMPLE
    - CONFIG_DM_WARN
    - CONFIG_DM_DEVICE_REMOVE
    - CONFIG_DM_STDIO
 Enabling Driver Model
 ---------------------
 Driver model is being brought into U-Boot gradually. As each subsystems gets
 support, a uclass is created and a CONFIG to enable use of driver model for
 that subsystem.
 For example CONFIG_DM_SERIAL enables driver model for serial. With that
 defined, the old serial support is not enabled, and your serial driver must
 conform to driver model. With that undefined, the old serial support is
 enabled and driver model is not available for serial. This means that when
 you convert a driver, you must either convert all its boards, or provide for
 the driver to be compiled both with and without driver model (generally this
 is not very hard).
 See the main README for full details of the available driver model CONFIG
 options.
 Things to punt for later
 ------------------------
 Uclasses are statically numbered at compile time. It would be possible to
 change this to dynamic numbering, but then we would require some sort of
 lookup service, perhaps searching by name. This is slightly less efficient
 so has been left out for now. One small advantage of dynamic numbering might
 be fewer merge conflicts in uclass-id.h.
 Simon Glass
 sjg@chromium.org
 April 2013
 Updated 7-May-13
 Updated 14-Jun-13
 Updated 18-Oct-13
 Updated 5-Nov-13

drivers/clk/at91/pmc.c

Diff comments View file @ 5513023

 /*
  * Copyright (C) 2016 Atmel Corporation
  *               Wenyou.Yang <wenyou.yang@atmel.com>
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #include <common.h>
 #include <clk-uclass.h>
 #include <dm/device.h>
 #include <dm/lists.h>
 #include <dm/root.h>
+#include <dm/util.h>
 #include "pmc.h"
 DECLARE_GLOBAL_DATA_PTR;
 static const struct udevice_id at91_pmc_match[] = {
 	{ .compatible = "atmel,sama5d2-pmc" },
 	{}
 };
 U_BOOT_DRIVER(at91_pmc) = {
 	.name = "at91-pmc",
 	.id = UCLASS_SIMPLE_BUS,
 	.of_match = at91_pmc_match,
 };
 /*---------------------------------------------------------*/
 int at91_pmc_core_probe(struct udevice *dev)
 {
 	struct pmc_platdata *plat = dev_get_platdata(dev);
 	dev = dev_get_parent(dev);
 	plat->reg_base = (struct at91_pmc *)dev_get_addr_ptr(dev);
 	return 0;
 }
 /**
  * at91_clk_sub_device_bind() - for the at91 clock driver
  * Recursively bind its children as clk devices.
  *
  * @return: 0 on success, or negative error code on failure
  */
 int at91_clk_sub_device_bind(struct udevice *dev, const char *drv_name)
 {
 	const void *fdt = gd->fdt_blob;
 	int offset = dev->of_offset;
 	bool pre_reloc_only = !(gd->flags & GD_FLG_RELOC);
 	const char *name;
 	int ret;
 	for (offset = fdt_first_subnode(fdt, offset);
 	     offset > 0;
 	     offset = fdt_next_subnode(fdt, offset)) {
 		if (pre_reloc_only &&
-		    !fdt_getprop(fdt, offset, "u-boot,dm-pre-reloc", NULL))
+		    !dm_fdt_pre_reloc(fdt, offset))
 			continue;
 		/*
 		 * If this node has "compatible" property, this is not
 		 * a clock sub-node, but a normal device. skip.
 		 */
 		fdt_get_property(fdt, offset, "compatible", &ret);
 		if (ret >= 0)
 			continue;
 		if (ret != -FDT_ERR_NOTFOUND)
 			return ret;
 		name = fdt_get_name(fdt, offset, NULL);
 		if (!name)
 			return -EINVAL;
 		ret = device_bind_driver_to_node(dev, drv_name, name,
 						 offset, NULL);
 		if (ret)
 			return ret;
 	}
 	return 0;
 }
 int at91_clk_of_xlate(struct clk *clk, struct fdtdec_phandle_args *args)
 {
 	int periph;
 	if (args->args_count) {
 		debug("Invalid args_count: %d\n", args->args_count);
 		return -EINVAL;
 	}
 	periph = fdtdec_get_uint(gd->fdt_blob, clk->dev->of_offset, "reg", -1);
 	if (periph < 0)
 		return -EINVAL;
 	clk->id = periph;
 	return 0;
 }
 int at91_clk_probe(struct udevice *dev)
 {
 	struct udevice *dev_periph_container, *dev_pmc;
 	struct pmc_platdata *plat = dev_get_platdata(dev);
 	dev_periph_container = dev_get_parent(dev);
 	dev_pmc = dev_get_parent(dev_periph_container);
 	plat->reg_base = (struct at91_pmc *)dev_get_addr_ptr(dev_pmc);
 	return 0;
 }

drivers/core/root.c

Diff comments View file @ 5513023

1	/*	1	/*
2	* Copyright (c) 2013 Google, Inc	2	* Copyright (c) 2013 Google, Inc
3	*	3	*
4	* (C) Copyright 2012	4	* (C) Copyright 2012
5	* Pavel Herrmann <morpheus.ibis@gmail.com>	5	* Pavel Herrmann <morpheus.ibis@gmail.com>
6	*	6	*
7	* SPDX-License-Identifier: GPL-2.0+	7	* SPDX-License-Identifier: GPL-2.0+
8	*/	8	*/
9		9
10	#include <common.h>	10	#include <common.h>
11	#include <errno.h>	11	#include <errno.h>
12	#include <fdtdec.h>	12	#include <fdtdec.h>
13	#include <malloc.h>	13	#include <malloc.h>
14	#include <libfdt.h>	14	#include <libfdt.h>
15	#include <dm/device.h>	15	#include <dm/device.h>
16	#include <dm/device-internal.h>	16	#include <dm/device-internal.h>
17	#include <dm/lists.h>	17	#include <dm/lists.h>
18	#include <dm/platdata.h>	18	#include <dm/platdata.h>
19	#include <dm/root.h>	19	#include <dm/root.h>
20	#include <dm/uclass.h>	20	#include <dm/uclass.h>
21	#include <dm/util.h>	21	#include <dm/util.h>
22	#include <linux/list.h>	22	#include <linux/list.h>
23		23
24	DECLARE_GLOBAL_DATA_PTR;	24	DECLARE_GLOBAL_DATA_PTR;
25		25
26	struct root_priv {	26	struct root_priv {
27	fdt_addr_t translation_offset; /* optional translation offset */	27	fdt_addr_t translation_offset; /* optional translation offset */
28	};	28	};
29		29
30	static const struct driver_info root_info = {	30	static const struct driver_info root_info = {
31	.name = "root_driver",	31	.name = "root_driver",
32	};	32	};
33		33
34	struct udevice *dm_root(void)	34	struct udevice *dm_root(void)
35	{	35	{
36	if (!gd->dm_root) {	36	if (!gd->dm_root) {
37	dm_warn("Virtual root driver does not exist!\n");	37	dm_warn("Virtual root driver does not exist!\n");
38	return NULL;	38	return NULL;
39	}	39	}
40		40
41	return gd->dm_root;	41	return gd->dm_root;
42	}	42	}
43		43
44	void dm_fixup_for_gd_move(struct global_data *new_gd)	44	void dm_fixup_for_gd_move(struct global_data *new_gd)
45	{	45	{
46	/* The sentinel node has moved, so update things that point to it */	46	/* The sentinel node has moved, so update things that point to it */
47	if (gd->dm_root) {	47	if (gd->dm_root) {
48	new_gd->uclass_root.next->prev = &new_gd->uclass_root;	48	new_gd->uclass_root.next->prev = &new_gd->uclass_root;
49	new_gd->uclass_root.prev->next = &new_gd->uclass_root;	49	new_gd->uclass_root.prev->next = &new_gd->uclass_root;
50	}	50	}
51	}	51	}
52		52
53	fdt_addr_t dm_get_translation_offset(void)	53	fdt_addr_t dm_get_translation_offset(void)
54	{	54	{
55	struct udevice *root = dm_root();	55	struct udevice *root = dm_root();
56	struct root_priv *priv = dev_get_priv(root);	56	struct root_priv *priv = dev_get_priv(root);
57		57
58	return priv->translation_offset;	58	return priv->translation_offset;
59	}	59	}
60		60
61	void dm_set_translation_offset(fdt_addr_t offs)	61	void dm_set_translation_offset(fdt_addr_t offs)
62	{	62	{
63	struct udevice *root = dm_root();	63	struct udevice *root = dm_root();
64	struct root_priv *priv = dev_get_priv(root);	64	struct root_priv *priv = dev_get_priv(root);
65		65
66	priv->translation_offset = offs;	66	priv->translation_offset = offs;
67	}	67	}
68		68
69	#if defined(CONFIG_NEEDS_MANUAL_RELOC)	69	#if defined(CONFIG_NEEDS_MANUAL_RELOC)
70	void fix_drivers(void)	70	void fix_drivers(void)
71	{	71	{
72	struct driver *drv =	72	struct driver *drv =
73	ll_entry_start(struct driver, driver);	73	ll_entry_start(struct driver, driver);
74	const int n_ents = ll_entry_count(struct driver, driver);	74	const int n_ents = ll_entry_count(struct driver, driver);
75	struct driver *entry;	75	struct driver *entry;
76		76
77	for (entry = drv; entry != drv + n_ents; entry++) {	77	for (entry = drv; entry != drv + n_ents; entry++) {
78	if (entry->of_match)	78	if (entry->of_match)
79	entry->of_match = (const struct udevice_id *)	79	entry->of_match = (const struct udevice_id *)
80	((u32)entry->of_match + gd->reloc_off);	80	((u32)entry->of_match + gd->reloc_off);
81	if (entry->bind)	81	if (entry->bind)
82	entry->bind += gd->reloc_off;	82	entry->bind += gd->reloc_off;
83	if (entry->probe)	83	if (entry->probe)
84	entry->probe += gd->reloc_off;	84	entry->probe += gd->reloc_off;
85	if (entry->remove)	85	if (entry->remove)
86	entry->remove += gd->reloc_off;	86	entry->remove += gd->reloc_off;
87	if (entry->unbind)	87	if (entry->unbind)
88	entry->unbind += gd->reloc_off;	88	entry->unbind += gd->reloc_off;
89	if (entry->ofdata_to_platdata)	89	if (entry->ofdata_to_platdata)
90	entry->ofdata_to_platdata += gd->reloc_off;	90	entry->ofdata_to_platdata += gd->reloc_off;
91	if (entry->child_post_bind)	91	if (entry->child_post_bind)
92	entry->child_post_bind += gd->reloc_off;	92	entry->child_post_bind += gd->reloc_off;
93	if (entry->child_pre_probe)	93	if (entry->child_pre_probe)
94	entry->child_pre_probe += gd->reloc_off;	94	entry->child_pre_probe += gd->reloc_off;
95	if (entry->child_post_remove)	95	if (entry->child_post_remove)
96	entry->child_post_remove += gd->reloc_off;	96	entry->child_post_remove += gd->reloc_off;
97	/* OPS are fixed in every uclass post_probe function */	97	/* OPS are fixed in every uclass post_probe function */
98	if (entry->ops)	98	if (entry->ops)
99	entry->ops += gd->reloc_off;	99	entry->ops += gd->reloc_off;
100	}	100	}
101	}	101	}
102		102
103	void fix_uclass(void)	103	void fix_uclass(void)
104	{	104	{
105	struct uclass_driver *uclass =	105	struct uclass_driver *uclass =
106	ll_entry_start(struct uclass_driver, uclass);	106	ll_entry_start(struct uclass_driver, uclass);
107	const int n_ents = ll_entry_count(struct uclass_driver, uclass);	107	const int n_ents = ll_entry_count(struct uclass_driver, uclass);
108	struct uclass_driver *entry;	108	struct uclass_driver *entry;
109		109
110	for (entry = uclass; entry != uclass + n_ents; entry++) {	110	for (entry = uclass; entry != uclass + n_ents; entry++) {
111	if (entry->post_bind)	111	if (entry->post_bind)
112	entry->post_bind += gd->reloc_off;	112	entry->post_bind += gd->reloc_off;
113	if (entry->pre_unbind)	113	if (entry->pre_unbind)
114	entry->pre_unbind += gd->reloc_off;	114	entry->pre_unbind += gd->reloc_off;
115	if (entry->pre_probe)	115	if (entry->pre_probe)
116	entry->pre_probe += gd->reloc_off;	116	entry->pre_probe += gd->reloc_off;
117	if (entry->post_probe)	117	if (entry->post_probe)
118	entry->post_probe += gd->reloc_off;	118	entry->post_probe += gd->reloc_off;
119	if (entry->pre_remove)	119	if (entry->pre_remove)
120	entry->pre_remove += gd->reloc_off;	120	entry->pre_remove += gd->reloc_off;
121	if (entry->child_post_bind)	121	if (entry->child_post_bind)
122	entry->child_post_bind += gd->reloc_off;	122	entry->child_post_bind += gd->reloc_off;
123	if (entry->child_pre_probe)	123	if (entry->child_pre_probe)
124	entry->child_pre_probe += gd->reloc_off;	124	entry->child_pre_probe += gd->reloc_off;
125	if (entry->init)	125	if (entry->init)
126	entry->init += gd->reloc_off;	126	entry->init += gd->reloc_off;
127	if (entry->destroy)	127	if (entry->destroy)
128	entry->destroy += gd->reloc_off;	128	entry->destroy += gd->reloc_off;
129	/* FIXME maybe also need to fix these ops */	129	/* FIXME maybe also need to fix these ops */
130	if (entry->ops)	130	if (entry->ops)
131	entry->ops += gd->reloc_off;	131	entry->ops += gd->reloc_off;
132	}	132	}
133	}	133	}
134		134
135	void fix_devices(void)	135	void fix_devices(void)
136	{	136	{
137	struct driver_info *dev =	137	struct driver_info *dev =
138	ll_entry_start(struct driver_info, driver_info);	138	ll_entry_start(struct driver_info, driver_info);
139	const int n_ents = ll_entry_count(struct driver_info, driver_info);	139	const int n_ents = ll_entry_count(struct driver_info, driver_info);
140	struct driver_info *entry;	140	struct driver_info *entry;
141		141
142	for (entry = dev; entry != dev + n_ents; entry++) {	142	for (entry = dev; entry != dev + n_ents; entry++) {
143	if (entry->platdata)	143	if (entry->platdata)
144	entry->platdata += gd->reloc_off;	144	entry->platdata += gd->reloc_off;
145	}	145	}
146	}	146	}
147		147
148	#endif	148	#endif
149		149
150	int dm_init(void)	150	int dm_init(void)
151	{	151	{
152	int ret;	152	int ret;
153		153
154	if (gd->dm_root) {	154	if (gd->dm_root) {
155	dm_warn("Virtual root driver already exists!\n");	155	dm_warn("Virtual root driver already exists!\n");
156	return -EINVAL;	156	return -EINVAL;
157	}	157	}
158	INIT_LIST_HEAD(&DM_UCLASS_ROOT_NON_CONST);	158	INIT_LIST_HEAD(&DM_UCLASS_ROOT_NON_CONST);
159		159
160	#if defined(CONFIG_NEEDS_MANUAL_RELOC)	160	#if defined(CONFIG_NEEDS_MANUAL_RELOC)
161	fix_drivers();	161	fix_drivers();
162	fix_uclass();	162	fix_uclass();
163	fix_devices();	163	fix_devices();
164	#endif	164	#endif
165		165
166	ret = device_bind_by_name(NULL, false, &root_info, &DM_ROOT_NON_CONST);	166	ret = device_bind_by_name(NULL, false, &root_info, &DM_ROOT_NON_CONST);
167	if (ret)	167	if (ret)
168	return ret;	168	return ret;
169	#if CONFIG_IS_ENABLED(OF_CONTROL)	169	#if CONFIG_IS_ENABLED(OF_CONTROL)
170	DM_ROOT_NON_CONST->of_offset = 0;	170	DM_ROOT_NON_CONST->of_offset = 0;
171	#endif	171	#endif
172	ret = device_probe(DM_ROOT_NON_CONST);	172	ret = device_probe(DM_ROOT_NON_CONST);
173	if (ret)	173	if (ret)
174	return ret;	174	return ret;
175		175
176	return 0;	176	return 0;
177	}	177	}
178		178
179	int dm_uninit(void)	179	int dm_uninit(void)
180	{	180	{
181	device_remove(dm_root());	181	device_remove(dm_root());
182	device_unbind(dm_root());	182	device_unbind(dm_root());
183		183
184	return 0;	184	return 0;
185	}	185	}
186		186
187	int dm_scan_platdata(bool pre_reloc_only)	187	int dm_scan_platdata(bool pre_reloc_only)
188	{	188	{
189	int ret;	189	int ret;
190		190
191	ret = lists_bind_drivers(DM_ROOT_NON_CONST, pre_reloc_only);	191	ret = lists_bind_drivers(DM_ROOT_NON_CONST, pre_reloc_only);
192	if (ret == -ENOENT) {	192	if (ret == -ENOENT) {
193	dm_warn("Some drivers were not found\n");	193	dm_warn("Some drivers were not found\n");
194	ret = 0;	194	ret = 0;
195	}	195	}
196		196
197	return ret;	197	return ret;
198	}	198	}
199		199
200	#if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)	200	#if CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)
201	int dm_scan_fdt_node(struct udevice parent, const void blob, int offset,	201	int dm_scan_fdt_node(struct udevice parent, const void blob, int offset,
202	bool pre_reloc_only)	202	bool pre_reloc_only)
203	{	203	{
204	int ret = 0, err;	204	int ret = 0, err;
205		205
206	for (offset = fdt_first_subnode(blob, offset);	206	for (offset = fdt_first_subnode(blob, offset);
207	offset > 0;	207	offset > 0;
208	offset = fdt_next_subnode(blob, offset)) {	208	offset = fdt_next_subnode(blob, offset)) {
209	if (pre_reloc_only &&	209	if (pre_reloc_only &&
210	!fdt_getprop(blob, offset, "u-boot,dm-pre-reloc", NULL))	210	!dm_fdt_pre_reloc(blob, offset))
211	continue;	211	continue;
212	if (!fdtdec_get_is_enabled(blob, offset)) {	212	if (!fdtdec_get_is_enabled(blob, offset)) {
213	dm_dbg(" - ignoring disabled device\n");	213	dm_dbg(" - ignoring disabled device\n");
214	continue;	214	continue;
215	}	215	}
216	err = lists_bind_fdt(parent, blob, offset, NULL);	216	err = lists_bind_fdt(parent, blob, offset, NULL);
217	if (err && !ret) {	217	if (err && !ret) {
218	ret = err;	218	ret = err;
219	debug("%s: ret=%d\n", fdt_get_name(blob, offset, NULL),	219	debug("%s: ret=%d\n", fdt_get_name(blob, offset, NULL),
220	ret);	220	ret);
221	}	221	}
222	}	222	}
223		223
224	if (ret)	224	if (ret)
225	dm_warn("Some drivers failed to bind\n");	225	dm_warn("Some drivers failed to bind\n");
226		226
227	return ret;	227	return ret;
228	}	228	}
229		229
230	int dm_scan_fdt_dev(struct udevice *dev)	230	int dm_scan_fdt_dev(struct udevice *dev)
231	{	231	{
232	if (dev->of_offset == -1)	232	if (dev->of_offset == -1)
233	return 0;	233	return 0;
234		234
235	return dm_scan_fdt_node(dev, gd->fdt_blob, dev->of_offset,	235	return dm_scan_fdt_node(dev, gd->fdt_blob, dev->of_offset,
236	gd->flags & GD_FLG_RELOC ? false : true);	236	gd->flags & GD_FLG_RELOC ? false : true);
237	}	237	}
238		238
239	int dm_scan_fdt(const void *blob, bool pre_reloc_only)	239	int dm_scan_fdt(const void *blob, bool pre_reloc_only)
240	{	240	{
241	return dm_scan_fdt_node(gd->dm_root, blob, 0, pre_reloc_only);	241	return dm_scan_fdt_node(gd->dm_root, blob, 0, pre_reloc_only);
242	}	242	}
243	#endif	243	#endif
244		244
245	__weak int dm_scan_other(bool pre_reloc_only)	245	__weak int dm_scan_other(bool pre_reloc_only)
246	{	246	{
247	return 0;	247	return 0;
248	}	248	}
249		249
250	int dm_init_and_scan(bool pre_reloc_only)	250	int dm_init_and_scan(bool pre_reloc_only)
251	{	251	{
252	int ret;	252	int ret;
253		253
254	ret = dm_init();	254	ret = dm_init();
255	if (ret) {	255	if (ret) {
256	debug("dm_init() failed: %d\n", ret);	256	debug("dm_init() failed: %d\n", ret);
257	return ret;	257	return ret;
258	}	258	}
259	ret = dm_scan_platdata(pre_reloc_only);	259	ret = dm_scan_platdata(pre_reloc_only);
260	if (ret) {	260	if (ret) {
261	debug("dm_scan_platdata() failed: %d\n", ret);	261	debug("dm_scan_platdata() failed: %d\n", ret);
262	return ret;	262	return ret;
263	}	263	}
264		264
265	if (CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)) {	265	if (CONFIG_IS_ENABLED(OF_CONTROL) && !CONFIG_IS_ENABLED(OF_PLATDATA)) {
266	ret = dm_scan_fdt(gd->fdt_blob, pre_reloc_only);	266	ret = dm_scan_fdt(gd->fdt_blob, pre_reloc_only);
267	if (ret) {	267	if (ret) {
268	debug("dm_scan_fdt() failed: %d\n", ret);	268	debug("dm_scan_fdt() failed: %d\n", ret);
269	return ret;	269	return ret;
270	}	270	}
271	}	271	}
272		272
273	ret = dm_scan_other(pre_reloc_only);	273	ret = dm_scan_other(pre_reloc_only);
274	if (ret)	274	if (ret)
275	return ret;	275	return ret;
276		276
277	return 0;	277	return 0;
278	}	278	}
279		279
280	/* This is the root driver - all drivers are children of this */	280	/* This is the root driver - all drivers are children of this */
281	U_BOOT_DRIVER(root_driver) = {	281	U_BOOT_DRIVER(root_driver) = {
282	.name = "root_driver",	282	.name = "root_driver",
283	.id = UCLASS_ROOT,	283	.id = UCLASS_ROOT,
284	.priv_auto_alloc_size = sizeof(struct root_priv),	284	.priv_auto_alloc_size = sizeof(struct root_priv),
285	};	285	};
286		286
287	/* This is the root uclass */	287	/* This is the root uclass */
288	UCLASS_DRIVER(root) = {	288	UCLASS_DRIVER(root) = {
289	.name = "root",	289	.name = "root",
290	.id = UCLASS_ROOT,	290	.id = UCLASS_ROOT,
291	};	291	};
292		292

drivers/core/util.c

Diff comments View file @ 5513023

 /*
  * Copyright (c) 2013 Google, Inc
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #include <common.h>
+#include <libfdt.h>
 #include <vsprintf.h>
 void dm_warn(const char *fmt, ...)
 {
 	va_list args;
 	va_start(args, fmt);
 	vprintf(fmt, args);
 	va_end(args);
 }
 void dm_dbg(const char *fmt, ...)
 {
 	va_list args;
 	va_start(args, fmt);
 	vprintf(fmt, args);
 	va_end(args);
 }
 int list_count_items(struct list_head *head)
 {
 	struct list_head *node;
 	int count = 0;
 	list_for_each(node, head)
 		count++;
 	return count;
+}
+int dm_fdt_pre_reloc(const void *blob, int offset)
+{
+	if (fdt_getprop(blob, offset, "u-boot,dm-pre-reloc", NULL))
+		return 1;
+#ifdef CONFIG_TPL_BUILD
+	if (fdt_getprop(blob, offset, "u-boot,dm-tpl", NULL))
+		return 1;
+#elif defined(CONFIG_SPL_BUILD)
+	if (fdt_getprop(blob, offset, "u-boot,dm-spl", NULL))
+		return 1;
+#else
+	/*
+	 * In regular builds individual spl and tpl handling both
+	 * count as handled pre-relocation for later second init.
+	 */
+	if (fdt_getprop(blob, offset, "u-boot,dm-spl", NULL) ||
+	    fdt_getprop(blob, offset, "u-boot,dm-tpl", NULL))
+		return 1;
+#endif
+	return 0;
 }

drivers/pinctrl/pinctrl-uclass.c

Diff comments View file @ 5513023

 /*
  * Copyright (C) 2015  Masahiro Yamada <yamada.masahiro@socionext.com>
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #include <common.h>
 #include <libfdt.h>
 #include <linux/err.h>
 #include <linux/list.h>
 #include <dm/device.h>
 #include <dm/lists.h>
 #include <dm/pinctrl.h>
 #include <dm/uclass.h>
+#include <dm/util.h>
 DECLARE_GLOBAL_DATA_PTR;
 int pinctrl_decode_pin_config(const void *blob, int node)
 {
 	int flags = 0;
 	if (fdtdec_get_bool(blob, node, "bias-pull-up"))
 		flags |= 1 << PIN_CONFIG_BIAS_PULL_UP;
 	else if (fdtdec_get_bool(blob, node, "bias-pull-down"))
 		flags |= 1 << PIN_CONFIG_BIAS_PULL_DOWN;
 	return flags;
 }
 #if CONFIG_IS_ENABLED(PINCTRL_FULL)
 /**
  * pinctrl_config_one() - apply pinctrl settings for a single node
  *
  * @config: pin configuration node
  * @return: 0 on success, or negative error code on failure
  */
 static int pinctrl_config_one(struct udevice *config)
 {
 	struct udevice *pctldev;
 	const struct pinctrl_ops *ops;
 	pctldev = config;
 	for (;;) {
 		pctldev = dev_get_parent(pctldev);
 		if (!pctldev) {
 			dev_err(config, "could not find pctldev\n");
 			return -EINVAL;
 		}
 		if (pctldev->uclass->uc_drv->id == UCLASS_PINCTRL)
 			break;
 	}
 	ops = pinctrl_get_ops(pctldev);
 	return ops->set_state(pctldev, config);
 }
 /**
  * pinctrl_select_state_full() - full implementation of pinctrl_select_state
  *
  * @dev: peripheral device
  * @statename: state name, like "default"
  * @return: 0 on success, or negative error code on failure
  */
 static int pinctrl_select_state_full(struct udevice *dev, const char *statename)
 {
 	const void *fdt = gd->fdt_blob;
 	int node = dev->of_offset;
 	char propname[32]; /* long enough */
 	const fdt32_t *list;
 	uint32_t phandle;
 	int config_node;
 	struct udevice *config;
 	int state, size, i, ret;
 	state = fdt_stringlist_search(fdt, node, "pinctrl-names", statename);
 	if (state < 0) {
 		char *end;
 		/*
 		 * If statename is not found in "pinctrl-names",
 		 * assume statename is just the integer state ID.
 		 */
 		state = simple_strtoul(statename, &end, 10);
 		if (*end)
 			return -EINVAL;
 	}
 	snprintf(propname, sizeof(propname), "pinctrl-%d", state);
 	list = fdt_getprop(fdt, node, propname, &size);
 	if (!list)
 		return -EINVAL;
 	size /= sizeof(*list);
 	for (i = 0; i < size; i++) {
 		phandle = fdt32_to_cpu(*list++);
 		config_node = fdt_node_offset_by_phandle(fdt, phandle);
 		if (config_node < 0) {
 			dev_err(dev, "prop %s index %d invalid phandle\n",
 				propname, i);
 			return -EINVAL;
 		}
 		ret = uclass_get_device_by_of_offset(UCLASS_PINCONFIG,
 						     config_node, &config);
 		if (ret)
 			return ret;
 		ret = pinctrl_config_one(config);
 		if (ret)
 			return ret;
 	}
 	return 0;
 }
 /**
  * pinconfig_post_bind() - post binding for PINCONFIG uclass
  * Recursively bind its children as pinconfig devices.
  *
  * @dev: pinconfig device
  * @return: 0 on success, or negative error code on failure
  */
 static int pinconfig_post_bind(struct udevice *dev)
 {
 	const void *fdt = gd->fdt_blob;
 	int offset = dev->of_offset;
 	bool pre_reloc_only = !(gd->flags & GD_FLG_RELOC);
 	const char *name;
 	int ret;
 	for (offset = fdt_first_subnode(fdt, offset);
 	     offset > 0;
 	     offset = fdt_next_subnode(fdt, offset)) {
 		if (pre_reloc_only &&
-		    !fdt_getprop(fdt, offset, "u-boot,dm-pre-reloc", NULL))
+		    !dm_fdt_pre_reloc(fdt, offset))
 			continue;
 		/*
 		 * If this node has "compatible" property, this is not
 		 * a pin configuration node, but a normal device. skip.
 		 */
 		fdt_get_property(fdt, offset, "compatible", &ret);
 		if (ret >= 0)
 			continue;
 		if (ret != -FDT_ERR_NOTFOUND)
 			return ret;
 		name = fdt_get_name(fdt, offset, NULL);
 		if (!name)
 			return -EINVAL;
 		ret = device_bind_driver_to_node(dev, "pinconfig", name,
 						 offset, NULL);
 		if (ret)
 			return ret;
 	}
 	return 0;
 }
 UCLASS_DRIVER(pinconfig) = {
 	.id = UCLASS_PINCONFIG,
 	.post_bind = pinconfig_post_bind,
 	.name = "pinconfig",
 };
 U_BOOT_DRIVER(pinconfig_generic) = {
 	.name = "pinconfig",
 	.id = UCLASS_PINCONFIG,
 };
 #else
 static int pinctrl_select_state_full(struct udevice *dev, const char *statename)
 {
 	return -ENODEV;
 }
 static int pinconfig_post_bind(struct udevice *dev)
 {
 	return 0;
 }
 #endif
 /**
  * pinctrl_select_state_simple() - simple implementation of pinctrl_select_state
  *
  * @dev: peripheral device
  * @return: 0 on success, or negative error code on failure
  */
 static int pinctrl_select_state_simple(struct udevice *dev)
 {
 	struct udevice *pctldev;
 	struct pinctrl_ops *ops;
 	int ret;
 	/*
 	 * For simplicity, assume the first device of PINCTRL uclass
 	 * is the correct one.  This is most likely OK as there is
 	 * usually only one pinctrl device on the system.
 	 */
 	ret = uclass_get_device(UCLASS_PINCTRL, 0, &pctldev);
 	if (ret)
 		return ret;
 	ops = pinctrl_get_ops(pctldev);
 	if (!ops->set_state_simple) {
 		dev_dbg(dev, "set_state_simple op missing\n");
 		return -ENOSYS;
 	}
 	return ops->set_state_simple(pctldev, dev);
 }
 int pinctrl_select_state(struct udevice *dev, const char *statename)
 {
 	/*
 	 * Try full-implemented pinctrl first.
 	 * If it fails or is not implemented, try simple one.
 	 */
 	if (pinctrl_select_state_full(dev, statename))
 		return pinctrl_select_state_simple(dev);
 	return 0;
 }
 int pinctrl_request(struct udevice *dev, int func, int flags)
 {
 	struct pinctrl_ops *ops = pinctrl_get_ops(dev);
 	if (!ops->request)
 		return -ENOSYS;
 	return ops->request(dev, func, flags);
 }
 int pinctrl_request_noflags(struct udevice *dev, int func)
 {
 	return pinctrl_request(dev, func, 0);
 }
 int pinctrl_get_periph_id(struct udevice *dev, struct udevice *periph)
 {
 	struct pinctrl_ops *ops = pinctrl_get_ops(dev);
 	if (!ops->get_periph_id)
 		return -ENOSYS;
 	return ops->get_periph_id(dev, periph);
 }
 int pinctrl_get_gpio_mux(struct udevice *dev, int banknum, int index)
 {
 	struct pinctrl_ops *ops = pinctrl_get_ops(dev);
 	if (!ops->get_gpio_mux)
 		return -ENOSYS;
 	return ops->get_gpio_mux(dev, banknum, index);
 }
 /**
  * pinconfig_post_bind() - post binding for PINCTRL uclass
  * Recursively bind child nodes as pinconfig devices in case of full pinctrl.
  *
  * @dev: pinctrl device
  * @return: 0 on success, or negative error code on failure
  */
 static int pinctrl_post_bind(struct udevice *dev)
 {
 	const struct pinctrl_ops *ops = pinctrl_get_ops(dev);
 	if (!ops) {
 		dev_dbg(dev, "ops is not set.  Do not bind.\n");
 		return -EINVAL;
 	}
 	/*
 	 * If set_state callback is set, we assume this pinctrl driver is the
 	 * full implementation.  In this case, its child nodes should be bound
 	 * so that peripheral devices can easily search in parent devices
 	 * during later DT-parsing.
 	 */
 	if (ops->set_state)
 		return pinconfig_post_bind(dev);
 	return 0;
 }
 UCLASS_DRIVER(pinctrl) = {
 	.id = UCLASS_PINCTRL,
 	.post_bind = pinctrl_post_bind,
 	.flags = DM_UC_FLAG_SEQ_ALIAS,
 	.name = "pinctrl",
 };

include/dm/util.h

Diff comments View file @ 5513023

 /*
  * Copyright (c) 2013 Google, Inc
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #ifndef __DM_UTIL_H
 #define __DM_UTIL_H
 #ifdef CONFIG_DM_WARN
 void dm_warn(const char *fmt, ...);
 #else
 static inline void dm_warn(const char *fmt, ...)
 {
 }
 #endif
 #ifdef DEBUG
 void dm_dbg(const char *fmt, ...);
 #else
 static inline void dm_dbg(const char *fmt, ...)
 {
 }
 #endif
 struct list_head;
 /**
  * list_count_items() - Count number of items in a list
  *
  * @param head:		Head of list
  * @return number of items, or 0 if empty
  */
 int list_count_items(struct list_head *head);
 /* Dump out a tree of all devices */
 void dm_dump_all(void);
 /* Dump out a list of uclasses and their devices */
 void dm_dump_uclass(void);
 #ifdef CONFIG_DEBUG_DEVRES
 /* Dump out a list of device resources */
 void dm_dump_devres(void);
 #else
 static inline void dm_dump_devres(void)
 {
 }
 #endif
+/**
+ * Check if a dt node should be or was bound before relocation.
+ *
+ * Devicetree nodes can be marked as needed to be bound
+ * in the loader stages via special devicetree properties.
+ *
+ * Before relocation this function can be used to check if nodes
+ * are required in either SPL or TPL stages.
+ *
+ * After relocation and jumping into the real U-Boot binary
+ * it is possible to determine if a node was bound in one of
+ * SPL/TPL stages.
+ *
+ * There are 3 settings currently in use
+ * -
+ * - u-boot,dm-pre-reloc: legacy and indicates any of TPL or SPL
+ *   Existing platforms only use it to indicate nodes needee in
+ *   SPL. Should probably be replaced by u-boot,dm-spl for
+ *   existing platforms.
+ * @blob: devicetree
+ * @offset: node offset
+ *
+ * Returns true if node is needed in SPL/TL, false otherwise.
+ */
+int dm_fdt_pre_reloc(const void *blob, int offset);
 #endif

scripts/Makefile.spl

Diff comments View file @ 5513023

 #
 # (C) Copyright 2000-2011
 # Wolfgang Denk, DENX Software Engineering, wd@denx.de.
 #
 # (C) Copyright 2011
 # Daniel Schwierzeck, daniel.schwierzeck@googlemail.com.
 #
 # (C) Copyright 2011
 # Texas Instruments Incorporated - http://www.ti.com/
 # Aneesh V <aneesh@ti.com>
 #
 # SPDX-License-Identifier:	GPL-2.0+
 #
 # Based on top-level Makefile.
 #
 src := $(obj)
 # Create output directory if not already present
 _dummy := $(shell [ -d $(obj) ] || mkdir -p $(obj))
 include $(srctree)/scripts/Kbuild.include
 -include include/config/auto.conf
 -include $(obj)/include/autoconf.mk
 KBUILD_CPPFLAGS += -DCONFIG_SPL_BUILD
 ifeq ($(CONFIG_TPL_BUILD),y)
 KBUILD_CPPFLAGS += -DCONFIG_TPL_BUILD
 endif
 ifeq ($(CONFIG_TPL_BUILD),y)
 SPL_BIN := u-boot-tpl
 else
 SPL_BIN := u-boot-spl
 endif
 include $(srctree)/config.mk
 include $(srctree)/arch/$(ARCH)/Makefile
 # Enable garbage collection of un-used sections for SPL
 KBUILD_CFLAGS += -ffunction-sections -fdata-sections
 LDFLAGS_FINAL += --gc-sections
 # FIX ME
 cpp_flags := $(KBUILD_CPPFLAGS) $(PLATFORM_CPPFLAGS) $(UBOOTINCLUDE) \
 							$(NOSTDINC_FLAGS)
 c_flags := $(KBUILD_CFLAGS) $(cpp_flags)
 HAVE_VENDOR_COMMON_LIB = $(if $(wildcard $(srctree)/board/$(VENDOR)/common/Makefile),y,n)
 libs-y += $(if $(BOARDDIR),board/$(BOARDDIR)/)
 libs-$(HAVE_VENDOR_COMMON_LIB) += board/$(VENDOR)/common/
 libs-$(CONFIG_SPL_FRAMEWORK) += common/spl/
 libs-y += common/init/
 # Special handling for a few options which support SPL/TPL
 ifeq ($(CONFIG_TPL_BUILD),y)
 libs-$(CONFIG_TPL_LIBCOMMON_SUPPORT) += common/ cmd/
 libs-$(CONFIG_TPL_LIBGENERIC_SUPPORT) += lib/
 else
 libs-$(CONFIG_SPL_LIBCOMMON_SUPPORT) += common/ cmd/
 libs-$(CONFIG_SPL_LIBGENERIC_SUPPORT) += lib/
 endif
 libs-$(CONFIG_SPL_LIBDISK_SUPPORT) += disk/
 libs-y += drivers/
 libs-$(CONFIG_SPL_USB_GADGET_SUPPORT) += drivers/usb/dwc3/
 libs-y += dts/
 libs-y += fs/
 libs-$(CONFIG_SPL_POST_MEM_SUPPORT) += post/drivers/
 libs-$(CONFIG_SPL_NET_SUPPORT) += net/
 head-y		:= $(addprefix $(obj)/,$(head-y))
 libs-y		:= $(addprefix $(obj)/,$(libs-y))
 u-boot-spl-dirs	:= $(patsubst %/,%,$(filter %/, $(libs-y)))
 libs-y := $(patsubst %/, %/built-in.o, $(libs-y))
 # Add GCC lib
 ifeq ($(CONFIG_USE_PRIVATE_LIBGCC),y)
 PLATFORM_LIBGCC = arch/$(ARCH)/lib/lib.a
 PLATFORM_LIBS := $(filter-out %/lib.a, $(filter-out -lgcc, $(PLATFORM_LIBS))) $(PLATFORM_LIBGCC)
 endif
 u-boot-spl-init := $(head-y)
 u-boot-spl-main := $(libs-y)
 ifdef CONFIG_SPL_OF_PLATDATA
 u-boot-spl-platdata := $(obj)/dts/dt-platdata.o
 endif
 # Linker Script
 ifdef CONFIG_SPL_LDSCRIPT
 # need to strip off double quotes
 LDSCRIPT := $(addprefix $(srctree)/,$(CONFIG_SPL_LDSCRIPT:"%"=%))
 endif
 ifeq ($(wildcard $(LDSCRIPT)),)
 	LDSCRIPT := $(srctree)/board/$(BOARDDIR)/u-boot-spl.lds
 endif
 ifeq ($(wildcard $(LDSCRIPT)),)
 	LDSCRIPT := $(srctree)/$(CPUDIR)/u-boot-spl.lds
 endif
 ifeq ($(wildcard $(LDSCRIPT)),)
 	LDSCRIPT := $(srctree)/arch/$(ARCH)/cpu/u-boot-spl.lds
 endif
 ifeq ($(wildcard $(LDSCRIPT)),)
 $(error could not find linker script)
 endif
 # Special flags for CPP when processing the linker script.
 # Pass the version down so we can handle backwards compatibility
 # on the fly.
 LDPPFLAGS += \
 	-include $(srctree)/include/u-boot/u-boot.lds.h \
 	-include $(objtree)/include/config.h \
 	-DCPUDIR=$(CPUDIR) \
 	$(shell $(LD) --version | \
 	  sed -ne 's/GNU ld version \([0-9][0-9]*\)\.\([0-9][0-9]*\).*/-DLD_MAJOR=\1 -DLD_MINOR=\2/p')
 MKIMAGEOUTPUT ?= /dev/null
 quiet_cmd_mkimage = MKIMAGE $@
 cmd_mkimage = $(objtree)/tools/mkimage $(MKIMAGEFLAGS_$(@F)) -d $< $@ \
 	$(if $(KBUILD_VERBOSE:1=), >$(MKIMAGEOUTPUT))
 MKIMAGEFLAGS_MLO = -T omapimage -a $(CONFIG_SPL_TEXT_BASE)
 MKIMAGEFLAGS_MLO.byteswap = -T omapimage -n byteswap -a $(CONFIG_SPL_TEXT_BASE)
 MLO MLO.byteswap: $(obj)/u-boot-spl.bin FORCE
 	$(call if_changed,mkimage)
 ifeq ($(CONFIG_SYS_SOC),"at91")
 MKIMAGEFLAGS_boot.bin = -T atmelimage
 ifeq ($(CONFIG_SPL_GENERATE_ATMEL_PMECC_HEADER),y)
 MKIMAGEFLAGS_boot.bin += -n $(shell $(obj)/../tools/atmel_pmecc_params)
 boot.bin: $(obj)/../tools/atmel_pmecc_params
 endif
 boot.bin: $(obj)/u-boot-spl.bin FORCE
 	$(call if_changed,mkimage)
 else
 ifdef CONFIG_ARCH_ZYNQ
 MKIMAGEFLAGS_boot.bin = -T zynqimage -R $(srctree)/$(CONFIG_BOOT_INIT_FILE)
 endif
 ifdef CONFIG_ARCH_ZYNQMP
 MKIMAGEFLAGS_boot.bin = -T zynqmpimage -R $(srctree)/$(CONFIG_BOOT_INIT_FILE)
 endif
 spl/boot.bin: $(obj)/u-boot-spl.bin FORCE
 	$(call if_changed,mkimage)
 endif
 ALL-y	+= $(obj)/$(SPL_BIN).bin
 ifdef CONFIG_SAMSUNG
 ALL-y	+= $(obj)/$(BOARD)-spl.bin
 endif
 ifdef CONFIG_ARCH_SOCFPGA
 ALL-y	+= $(obj)/$(SPL_BIN).sfp
 endif
 ifdef CONFIG_ARCH_SUNXI
 ALL-y	+= $(obj)/sunxi-spl.bin
 endif
 ifeq ($(CONFIG_SYS_SOC),"at91")
 ALL-y	+= boot.bin
 endif
 ALL-$(CONFIG_ARCH_ZYNQ)		+= $(obj)/boot.bin
 ALL-$(CONFIG_ARCH_ZYNQMP)	+= $(obj)/boot.bin
 all:	$(ALL-y)
 quiet_cmd_cat = CAT     $@
 cmd_cat = cat $(filter-out $(PHONY), $^) > $@
 quiet_cmd_copy = COPY    $@
       cmd_copy = cp $< $@
 ifeq ($(CONFIG_SPL_OF_CONTROL)$(CONFIG_OF_SEPARATE)$(CONFIG_SPL_OF_PLATDATA),yy)
 $(obj)/$(SPL_BIN)-dtb.bin: $(obj)/$(SPL_BIN)-nodtb.bin $(obj)/$(SPL_BIN)-pad.bin \
 		$(obj)/$(SPL_BIN).dtb FORCE
 	$(call if_changed,cat)
 $(obj)/$(SPL_BIN).bin: $(obj)/$(SPL_BIN)-dtb.bin FORCE
 	$(call if_changed,copy)
 else
 $(obj)/$(SPL_BIN).bin: $(obj)/$(SPL_BIN)-nodtb.bin FORCE
 	$(call if_changed,copy)
 endif
 # Create a file that pads from the end of u-boot-spl-nodtb.bin to bss_end
 $(obj)/$(SPL_BIN)-pad.bin: $(obj)/$(SPL_BIN)
 	@bss_size_str=$(shell $(NM) $< | awk 'BEGIN {size = 0} /__bss_size/ {size = $$1} END {print "ibase=16; " toupper(size)}' | bc); \
 	dd if=/dev/zero of=$@ bs=1 count=$${bss_size_str} 2>/dev/null;
 # Pass the original device tree file through fdtgrep twice. The first pass
 # removes any unwanted nodes (i.e. those which don't have the
 # 'u-boot,dm-pre-reloc' property and thus are not needed by SPL. The second
 # pass removes various unused properties from the remaining nodes.
 # The output is typically a much smaller device tree file.
+ifeq ($(CONFIG_TPL_BUILD),y)
+fdtgrep_props := -b u-boot,dm-pre-reloc -b u-boot,dm-tpl
+else
+fdtgrep_props := -b u-boot,dm-pre-reloc -b u-boot,dm-spl
+endif
 quiet_cmd_fdtgrep = FDTGREP $@
-      cmd_fdtgrep = $(objtree)/tools/fdtgrep -b u-boot,dm-pre-reloc -RT $< \
+      cmd_fdtgrep = $(objtree)/tools/fdtgrep $(fdtgrep_props) -RT $< \
 		-n /chosen -O dtb | \
 	$(objtree)/tools/fdtgrep -r -O dtb - -o $@ \
 		$(addprefix -P ,$(subst $\",,$(CONFIG_OF_SPL_REMOVE_PROPS)))
 $(obj)/$(SPL_BIN).dtb: dts/dt.dtb $(objtree)/tools/fdtgrep FORCE
 	$(call if_changed,fdtgrep)
 pythonpath = PYTHONPATH=tools
 quiet_cmd_dtocc = DTOC C  $@
 cmd_dtocc = $(pythonpath) $(srctree)/tools/dtoc/dtoc -d $(obj)/$(SPL_BIN).dtb -o $@ platdata
 quiet_cmd_dtoch = DTOC H  $@
 cmd_dtoch = $(pythonpath) $(srctree)/tools/dtoc/dtoc -d $(obj)/$(SPL_BIN).dtb -o $@ struct
 quiet_cmd_plat = PLAT    $@
 cmd_plat = $(CC) $(c_flags) -c $< -o $@
 $(obj)/dts/dt-platdata.o: $(obj)/dts/dt-platdata.c include/generated/dt-structs.h
 	$(call if_changed,plat)
 PHONY += dts_dir
 dts_dir:
 	$(shell [ -d $(obj)/dts ] || mkdir -p $(obj)/dts)
 include/generated/dt-structs.h: $(obj)/$(SPL_BIN).dtb dts_dir dtoc
 	$(call if_changed,dtoch)
 $(obj)/dts/dt-platdata.c: $(obj)/$(SPL_BIN).dtb dts_dir dtoc
 	$(call if_changed,dtocc)
 dtoc: #$(objtree)/tools/_libfdt.so
 ifdef CONFIG_SAMSUNG
 ifdef CONFIG_VAR_SIZE_SPL
 VAR_SIZE_PARAM = --vs
 else
 VAR_SIZE_PARAM =
 endif
 $(obj)/$(BOARD)-spl.bin: $(obj)/u-boot-spl.bin
 	$(if $(wildcard $(objtree)/spl/board/samsung/$(BOARD)/tools/mk$(BOARD)spl),\
 	$(objtree)/spl/board/samsung/$(BOARD)/tools/mk$(BOARD)spl,\
 	$(objtree)/tools/mkexynosspl) $(VAR_SIZE_PARAM) $< $@
 endif
 quiet_cmd_objcopy = OBJCOPY $@
 cmd_objcopy = $(OBJCOPY) $(OBJCOPYFLAGS) $(OBJCOPYFLAGS_$(@F)) $< $@
 OBJCOPYFLAGS_$(SPL_BIN)-nodtb.bin = $(SPL_OBJCFLAGS) -O binary
 $(obj)/$(SPL_BIN)-nodtb.bin: $(obj)/$(SPL_BIN) FORCE
 	$(call if_changed,objcopy)
 LDFLAGS_$(SPL_BIN) += -T u-boot-spl.lds $(LDFLAGS_FINAL)
 ifneq ($(CONFIG_SPL_TEXT_BASE),)
 LDFLAGS_$(SPL_BIN) += -Ttext $(CONFIG_SPL_TEXT_BASE)
 endif
 MKIMAGEFLAGS_$(SPL_BIN).sfp = -T socfpgaimage
 $(obj)/$(SPL_BIN).sfp: $(obj)/$(SPL_BIN).bin FORCE
 	$(call if_changed,mkimage)
 quiet_cmd_mksunxiboot = MKSUNXI $@
 cmd_mksunxiboot = $(objtree)/tools/mksunxiboot $< $@
 $(obj)/sunxi-spl.bin: $(obj)/$(SPL_BIN).bin FORCE
 	$(call if_changed,mksunxiboot)
 # Rule to link u-boot-spl
 # May be overridden by arch/$(ARCH)/config.mk
 quiet_cmd_u-boot-spl ?= LD      $@
       cmd_u-boot-spl ?= (cd $(obj) && $(LD) $(LDFLAGS) $(LDFLAGS_$(@F)) \
 		       $(patsubst $(obj)/%,%,$(u-boot-spl-init)) --start-group \
 		       $(patsubst $(obj)/%,%,$(u-boot-spl-main))  \
 		       $(patsubst $(obj)/%,%,$(u-boot-spl-platdata)) \
 		       --end-group \
 		       $(PLATFORM_LIBS) -Map $(SPL_BIN).map -o $(SPL_BIN))
 $(obj)/$(SPL_BIN): $(u-boot-spl-platdata) $(u-boot-spl-init) \
 		$(u-boot-spl-main) $(obj)/u-boot-spl.lds FORCE
 	$(call if_changed,u-boot-spl)
 $(sort $(u-boot-spl-init) $(u-boot-spl-main)): $(u-boot-spl-dirs) ;
 PHONY += $(u-boot-spl-dirs)
 $(u-boot-spl-dirs): $(u-boot-spl-platdata)
 	$(Q)$(MAKE) $(build)=$@
 quiet_cmd_cpp_lds = LDS     $@
 cmd_cpp_lds = $(CPP) -Wp,-MD,$(depfile) $(cpp_flags) $(LDPPFLAGS) -ansi \
 		-D__ASSEMBLY__ -x assembler-with-cpp -P -o $@ $<
 $(obj)/u-boot-spl.lds: $(LDSCRIPT) FORCE
 	$(call if_changed_dep,cpp_lds)
 # read all saved command lines
 targets := $(wildcard $(sort $(targets)))
 cmd_files := $(wildcard $(obj)/.*.cmd $(foreach f,$(targets),$(dir $(f)).$(notdir $(f)).cmd))
 ifneq ($(cmd_files),)
   $(cmd_files): ;	# Do not try to update included dependency files
   include $(cmd_files)
 endif
 PHONY += FORCE
 FORCE:
 # Declare the contents of the .PHONY variable as phony.  We keep that
 # information in a variable so we can use it in if_changed and friends.
 .PHONY: $(PHONY)

tools/dtoc/dtoc.py

Diff comments View file @ 5513023

 #!/usr/bin/python
 #
 # Copyright (C) 2016 Google, Inc
 # Written by Simon Glass <sjg@chromium.org>
 #
 # SPDX-License-Identifier:	GPL-2.0+
 #
 import copy
 from optparse import OptionError, OptionParser
 import os
 import struct
 import sys
 # Bring in the patman libraries
 our_path = os.path.dirname(os.path.realpath(__file__))
 sys.path.append(os.path.join(our_path, '../patman'))
 import fdt
 import fdt_select
 import fdt_util
 # When we see these properties we ignore them - i.e. do not create a structure member
 PROP_IGNORE_LIST = [
     '#address-cells',
     '#gpio-cells',
     '#size-cells',
     'compatible',
     'linux,phandle',
     "status",
     'phandle',
     'u-boot,dm-pre-reloc',
+    'u-boot,dm-tpl',
+    'u-boot,dm-spl',
 ]
 # C type declarations for the tyues we support
 TYPE_NAMES = {
     fdt.TYPE_INT: 'fdt32_t',
     fdt.TYPE_BYTE: 'unsigned char',
     fdt.TYPE_STRING: 'const char *',
     fdt.TYPE_BOOL: 'bool',
 };
 STRUCT_PREFIX = 'dtd_'
 VAL_PREFIX = 'dtv_'
 def Conv_name_to_c(name):
     """Convert a device-tree name to a C identifier
     Args:
         name:   Name to convert
     Return:
         String containing the C version of this name
     """
     str = name.replace('@', '_at_')
     str = str.replace('-', '_')
     str = str.replace(',', '_')
     str = str.replace('/', '__')
     return str
 def TabTo(num_tabs, str):
     if len(str) >= num_tabs * 8:
         return str + ' '
     return str + '\t' * (num_tabs - len(str) // 8)
 class DtbPlatdata:
     """Provide a means to convert device tree binary data to platform data
     The output of this process is C structures which can be used in space-
     constrained encvironments where the ~3KB code overhead of device tree
     code is not affordable.
     Properties:
         fdt: Fdt object, referencing the device tree
         _dtb_fname: Filename of the input device tree binary file
         _valid_nodes: A list of Node object with compatible strings
         _options: Command-line options
         _phandle_node: A dict of nodes indexed by phandle number (1, 2...)
         _outfile: The current output file (sys.stdout or a real file)
         _lines: Stashed list of output lines for outputting in the future
         _phandle_node: A dict of Nodes indexed by phandle (an integer)
     """
     def __init__(self, dtb_fname, options):
         self._dtb_fname = dtb_fname
         self._valid_nodes = None
         self._options = options
         self._phandle_node = {}
         self._outfile = None
         self._lines = []
     def SetupOutput(self, fname):
         """Set up the output destination
         Once this is done, future calls to self.Out() will output to this
         file.
         Args:
             fname: Filename to send output to, or '-' for stdout
         """
         if fname == '-':
             self._outfile = sys.stdout
         else:
             self._outfile = open(fname, 'w')
     def Out(self, str):
         """Output a string to the output file
         Args:
             str: String to output
         """
         self._outfile.write(str)
     def Buf(self, str):
         """Buffer up a string to send later
         Args:
             str: String to add to our 'buffer' list
         """
         self._lines.append(str)
     def GetBuf(self):
         """Get the contents of the output buffer, and clear it
         Returns:
             The output buffer, which is then cleared for future use
         """
         lines = self._lines
         self._lines = []
         return lines
     def GetValue(self, type, value):
         """Get a value as a C expression
         For integers this returns a byte-swapped (little-endian) hex string
         For bytes this returns a hex string, e.g. 0x12
         For strings this returns a literal string enclosed in quotes
         For booleans this return 'true'
         Args:
             type: Data type (fdt_util)
             value: Data value, as a string of bytes
         """
         if type == fdt.TYPE_INT:
             return '%#x' % fdt_util.fdt32_to_cpu(value)
         elif type == fdt.TYPE_BYTE:
             return '%#x' % ord(value[0])
         elif type == fdt.TYPE_STRING:
             return '"%s"' % value
         elif type == fdt.TYPE_BOOL:
             return 'true'
     def GetCompatName(self, node):
         """Get a node's first compatible string as a C identifier
         Args:
             node: Node object to check
         Return:
             C identifier for the first compatible string
         """
         compat = node.props['compatible'].value
         if type(compat) == list:
             compat = compat[0]
         return Conv_name_to_c(compat)
     def ScanDtb(self):
         """Scan the device tree to obtain a tree of notes and properties
         Once this is done, self.fdt.GetRoot() can be called to obtain the
         device tree root node, and progress from there.
         """
         self.fdt = fdt_select.FdtScan(self._dtb_fname)
     def ScanTree(self):
         """Scan the device tree for useful information
         This fills in the following properties:
             _phandle_node: A dict of Nodes indexed by phandle (an integer)
             _valid_nodes: A list of nodes we wish to consider include in the
                 platform data
         """
         node_list = []
         self._phandle_node = {}
         for node in self.fdt.GetRoot().subnodes:
             if 'compatible' in node.props:
                 status = node.props.get('status')
                 if (not options.include_disabled and not status or
                     status.value != 'disabled'):
                     node_list.append(node)
                     phandle_prop = node.props.get('phandle')
                     if phandle_prop:
                         phandle = phandle_prop.GetPhandle()
                         self._phandle_node[phandle] = node
         self._valid_nodes = node_list
     def IsPhandle(self, prop):
         """Check if a node contains phandles
         We have no reliable way of detecting whether a node uses a phandle
         or not. As an interim measure, use a list of known property names.
         Args:
             prop: Prop object to check
         Return:
             True if the object value contains phandles, else False
         """
         if prop.name in ['clocks']:
             return True
         return False
     def ScanStructs(self):
         """Scan the device tree building up the C structures we will use.
         Build a dict keyed by C struct name containing a dict of Prop
         object for each struct field (keyed by property name). Where the
         same struct appears multiple times, try to use the 'widest'
         property, i.e. the one with a type which can express all others.
         Once the widest property is determined, all other properties are
         updated to match that width.
         """
         structs = {}
         for node in self._valid_nodes:
             node_name = self.GetCompatName(node)
             fields = {}
             # Get a list of all the valid properties in this node.
             for name, prop in node.props.items():
                 if name not in PROP_IGNORE_LIST and name[0] != '#':
                     fields[name] = copy.deepcopy(prop)
             # If we've seen this node_name before, update the existing struct.
             if node_name in structs:
                 struct = structs[node_name]
                 for name, prop in fields.items():
                     oldprop = struct.get(name)
                     if oldprop:
                         oldprop.Widen(prop)
                     else:
                         struct[name] = prop
             # Otherwise store this as a new struct.
             else:
                 structs[node_name] = fields
         upto = 0
         for node in self._valid_nodes:
             node_name = self.GetCompatName(node)
             struct = structs[node_name]
             for name, prop in node.props.items():
                 if name not in PROP_IGNORE_LIST and name[0] != '#':
                     prop.Widen(struct[name])
             upto += 1
         return structs
     def GenerateStructs(self, structs):
         """Generate struct defintions for the platform data
         This writes out the body of a header file consisting of structure
         definitions for node in self._valid_nodes. See the documentation in
         README.of-plat for more information.
         """
         self.Out('#include <stdbool.h>\n')
         self.Out('#include <libfdt.h>\n')
         # Output the struct definition
         for name in sorted(structs):
             self.Out('struct %s%s {\n' % (STRUCT_PREFIX, name));
             for pname in sorted(structs[name]):
                 prop = structs[name][pname]
                 if self.IsPhandle(prop):
                     # For phandles, include a reference to the target
                     self.Out('\t%s%s[%d]' % (TabTo(2, 'struct phandle_2_cell'),
                                              Conv_name_to_c(prop.name),
                                              len(prop.value) / 2))
                 else:
                     ptype = TYPE_NAMES[prop.type]
                     self.Out('\t%s%s' % (TabTo(2, ptype),
                                          Conv_name_to_c(prop.name)))
                     if type(prop.value) == list:
                         self.Out('[%d]' % len(prop.value))
                 self.Out(';\n')
             self.Out('};\n')
     def GenerateTables(self):
         """Generate device defintions for the platform data
         This writes out C platform data initialisation data and
         U_BOOT_DEVICE() declarations for each valid node. See the
         documentation in README.of-plat for more information.
         """
         self.Out('#include <common.h>\n')
         self.Out('#include <dm.h>\n')
         self.Out('#include <dt-structs.h>\n')
         self.Out('\n')
         node_txt_list = []
         for node in self._valid_nodes:
             struct_name = self.GetCompatName(node)
             var_name = Conv_name_to_c(node.name)
             self.Buf('static struct %s%s %s%s = {\n' %
                 (STRUCT_PREFIX, struct_name, VAL_PREFIX, var_name))
             for pname, prop in node.props.items():
                 if pname in PROP_IGNORE_LIST or pname[0] == '#':
                     continue
                 ptype = TYPE_NAMES[prop.type]
                 member_name = Conv_name_to_c(prop.name)
                 self.Buf('\t%s= ' % TabTo(3, '.' + member_name))
                 # Special handling for lists
                 if type(prop.value) == list:
                     self.Buf('{')
                     vals = []
                     # For phandles, output a reference to the platform data
                     # of the target node.
                     if self.IsPhandle(prop):
                         # Process the list as pairs of (phandle, id)
                         it = iter(prop.value)
                         for phandle_cell, id_cell in zip(it, it):
                             phandle = fdt_util.fdt32_to_cpu(phandle_cell)
                             id = fdt_util.fdt32_to_cpu(id_cell)
                             target_node = self._phandle_node[phandle]
                             name = Conv_name_to_c(target_node.name)
                             vals.append('{&%s%s, %d}' % (VAL_PREFIX, name, id))
                     else:
                         for val in prop.value:
                             vals.append(self.GetValue(prop.type, val))
                     self.Buf(', '.join(vals))
                     self.Buf('}')
                 else:
                     self.Buf(self.GetValue(prop.type, prop.value))
                 self.Buf(',\n')
             self.Buf('};\n')
             # Add a device declaration
             self.Buf('U_BOOT_DEVICE(%s) = {\n' % var_name)
             self.Buf('\t.name\t\t= "%s",\n' % struct_name)
             self.Buf('\t.platdata\t= &%s%s,\n' % (VAL_PREFIX, var_name))
             self.Buf('\t.platdata_size\t= sizeof(%s%s),\n' %
                      (VAL_PREFIX, var_name))
             self.Buf('};\n')
             self.Buf('\n')
             # Output phandle target nodes first, since they may be referenced
             # by others
             if 'phandle' in node.props:
                 self.Out(''.join(self.GetBuf()))
             else:
                 node_txt_list.append(self.GetBuf())
         # Output all the nodes which are not phandle targets themselves, but
         # may reference them. This avoids the need for forward declarations.
         for node_txt in node_txt_list:
             self.Out(''.join(node_txt))
 if __name__ != "__main__":
     pass
 parser = OptionParser()
 parser.add_option('-d', '--dtb-file', action='store',
                   help='Specify the .dtb input file')
 parser.add_option('--include-disabled', action='store_true',
                   help='Include disabled nodes')
 parser.add_option('-o', '--output', action='store', default='-',
                   help='Select output filename')
 (options, args) = parser.parse_args()
 if not args:
     raise ValueError('Please specify a command: struct, platdata')
 plat = DtbPlatdata(options.dtb_file, options)
 plat.ScanDtb()
 plat.ScanTree()
 plat.SetupOutput(options.output)
 structs = plat.ScanStructs()
 for cmd in args[0].split(','):
     if cmd == 'struct':
         plat.GenerateStructs(structs)
     elif cmd == 'platdata':
         plat.GenerateTables()
     else:
         raise ValueError("Unknown command '%s': (use: struct, platdata)" % cmd)