]>
git.ipfire.org Git - people/ms/u-boot.git/blob - tools/dtoc/test_dtoc.py
fbae927cf8fcb9e5a002113590848cfcb788bfd0
2 # Copyright (c) 2012 The Chromium OS Authors.
4 # SPDX-License-Identifier: GPL-2.0+
7 """Tests for the dtb_platdata module
9 This includes unit tests for some functions and functional tests for
18 from dtb_platdata
import conv_name_to_c
19 from dtb_platdata
import get_compat_name
20 from dtb_platdata
import get_value
21 from dtb_platdata
import tab_to
26 our_path
= os
.path
.dirname(os
.path
.realpath(__file__
))
29 def get_dtb_file(dts_fname
):
30 """Compile a .dts file to a .dtb
33 dts_fname: Filename of .dts file in the current directory
36 Filename of compiled file in output directory
38 return fdt_util
.EnsureCompiled(os
.path
.join(our_path
, dts_fname
))
41 class TestDtoc(unittest
.TestCase
):
45 tools
.PrepareOutputDir(None)
48 def tearDownClass(cls
):
49 tools
._RemoveOutputDir
()
52 """Test conversion of device tree names to C identifiers"""
53 self
.assertEqual('serial_at_0x12', conv_name_to_c('serial@0x12'))
54 self
.assertEqual('vendor_clock_frequency',
55 conv_name_to_c('vendor,clock-frequency'))
56 self
.assertEqual('rockchip_rk3399_sdhci_5_1',
57 conv_name_to_c('rockchip,rk3399-sdhci-5.1'))
59 def test_tab_to(self
):
60 """Test operation of tab_to() function"""
61 self
.assertEqual('fred ', tab_to(0, 'fred'))
62 self
.assertEqual('fred\t', tab_to(1, 'fred'))
63 self
.assertEqual('fred was here ', tab_to(1, 'fred was here'))
64 self
.assertEqual('fred was here\t\t', tab_to(3, 'fred was here'))
65 self
.assertEqual('exactly8 ', tab_to(1, 'exactly8'))
66 self
.assertEqual('exactly8\t', tab_to(2, 'exactly8'))
68 def test_get_value(self
):
69 """Test operation of get_value() function"""
70 self
.assertEqual('0x45',
71 get_value(fdt
.TYPE_INT
, struct
.pack('>I', 0x45)))
72 self
.assertEqual('0x45',
73 get_value(fdt
.TYPE_BYTE
, struct
.pack('<I', 0x45)))
74 self
.assertEqual('0x0',
75 get_value(fdt
.TYPE_BYTE
, struct
.pack('>I', 0x45)))
76 self
.assertEqual('"test"', get_value(fdt
.TYPE_STRING
, 'test'))
77 self
.assertEqual('true', get_value(fdt
.TYPE_BOOL
, None))
79 def test_get_compat_name(self
):
80 """Test operation of get_compat_name() function"""
81 Prop
= collections
.namedtuple('Prop', ['value'])
82 Node
= collections
.namedtuple('Node', ['props'])
84 prop
= Prop(['rockchip,rk3399-sdhci-5.1', 'arasan,sdhci-5.1'])
85 node
= Node({'compatible': prop
})
86 self
.assertEqual(('rockchip_rk3399_sdhci_5_1', ['arasan_sdhci_5_1']),
87 get_compat_name(node
))
89 prop
= Prop(['rockchip,rk3399-sdhci-5.1'])
90 node
= Node({'compatible': prop
})
91 self
.assertEqual(('rockchip_rk3399_sdhci_5_1', []),
92 get_compat_name(node
))
94 prop
= Prop(['rockchip,rk3399-sdhci-5.1', 'arasan,sdhci-5.1', 'third'])
95 node
= Node({'compatible': prop
})
96 self
.assertEqual(('rockchip_rk3399_sdhci_5_1',
97 ['arasan_sdhci_5_1', 'third']),
98 get_compat_name(node
))
100 def test_empty_file(self
):
101 """Test output from a device tree file with no nodes"""
102 dtb_file
= get_dtb_file('dtoc_test_empty.dts')
103 output
= tools
.GetOutputFilename('output')
104 dtb_platdata
.run_steps(['struct'], dtb_file
, False, output
)
105 with
open(output
) as infile
:
106 lines
= infile
.read().splitlines()
107 self
.assertEqual(['#include <stdbool.h>', '#include <libfdt.h>'], lines
)
109 dtb_platdata
.run_steps(['platdata'], dtb_file
, False, output
)
110 with
open(output
) as infile
:
111 lines
= infile
.read().splitlines()
112 self
.assertEqual(['#include <common.h>', '#include <dm.h>',
113 '#include <dt-structs.h>', ''], lines
)
115 def test_simple(self
):
116 """Test output from some simple nodes with various types of data"""
117 dtb_file
= get_dtb_file('dtoc_test_simple.dts')
118 output
= tools
.GetOutputFilename('output')
119 dtb_platdata
.run_steps(['struct'], dtb_file
, False, output
)
120 with
open(output
) as infile
:
122 self
.assertEqual('''#include <stdbool.h>
124 struct dtd_sandbox_i2c_test {
126 struct dtd_sandbox_pmic_test {
130 struct dtd_sandbox_spl_test {
132 \tunsigned char\tbytearray[3];
133 \tunsigned char\tbyteval;
134 \tfdt32_t\t\tintarray[4];
136 \tunsigned char\tlongbytearray[9];
137 \tconst char *\tstringarray[3];
138 \tconst char *\tstringval;
140 struct dtd_sandbox_spl_test_2 {
144 dtb_platdata
.run_steps(['platdata'], dtb_file
, False, output
)
145 with
open(output
) as infile
:
147 self
.assertEqual('''#include <common.h>
149 #include <dt-structs.h>
151 static struct dtd_sandbox_spl_test dtv_spl_test = {
152 \t.bytearray\t\t= {0x6, 0x0, 0x0},
154 \t.intval\t\t\t= 0x1,
155 \t.longbytearray\t\t= {0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0x10,
157 \t.stringval\t\t= "message",
158 \t.boolval\t\t= true,
159 \t.intarray\t\t= {0x2, 0x3, 0x4, 0x0},
160 \t.stringarray\t\t= {"multi-word", "message", ""},
162 U_BOOT_DEVICE(spl_test) = {
163 \t.name\t\t= "sandbox_spl_test",
164 \t.platdata\t= &dtv_spl_test,
165 \t.platdata_size\t= sizeof(dtv_spl_test),
168 static struct dtd_sandbox_spl_test dtv_spl_test2 = {
169 \t.bytearray\t\t= {0x1, 0x23, 0x34},
171 \t.intval\t\t\t= 0x3,
172 \t.longbytearray\t\t= {0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
174 \t.stringval\t\t= "message2",
175 \t.intarray\t\t= {0x5, 0x0, 0x0, 0x0},
176 \t.stringarray\t\t= {"another", "multi-word", "message"},
178 U_BOOT_DEVICE(spl_test2) = {
179 \t.name\t\t= "sandbox_spl_test",
180 \t.platdata\t= &dtv_spl_test2,
181 \t.platdata_size\t= sizeof(dtv_spl_test2),
184 static struct dtd_sandbox_spl_test dtv_spl_test3 = {
185 \t.stringarray\t\t= {"one", "", ""},
187 U_BOOT_DEVICE(spl_test3) = {
188 \t.name\t\t= "sandbox_spl_test",
189 \t.platdata\t= &dtv_spl_test3,
190 \t.platdata_size\t= sizeof(dtv_spl_test3),
193 static struct dtd_sandbox_spl_test_2 dtv_spl_test4 = {
195 U_BOOT_DEVICE(spl_test4) = {
196 \t.name\t\t= "sandbox_spl_test_2",
197 \t.platdata\t= &dtv_spl_test4,
198 \t.platdata_size\t= sizeof(dtv_spl_test4),
201 static struct dtd_sandbox_i2c_test dtv_i2c_at_0 = {
203 U_BOOT_DEVICE(i2c_at_0) = {
204 \t.name\t\t= "sandbox_i2c_test",
205 \t.platdata\t= &dtv_i2c_at_0,
206 \t.platdata_size\t= sizeof(dtv_i2c_at_0),
209 static struct dtd_sandbox_pmic_test dtv_pmic_at_9 = {
210 \t.low_power\t\t= true,
211 \t.reg\t\t\t= {0x9, 0x0},
213 U_BOOT_DEVICE(pmic_at_9) = {
214 \t.name\t\t= "sandbox_pmic_test",
215 \t.platdata\t= &dtv_pmic_at_9,
216 \t.platdata_size\t= sizeof(dtv_pmic_at_9),
221 def test_phandle(self
):
222 """Test output from a node containing a phandle reference"""
223 dtb_file
= get_dtb_file('dtoc_test_phandle.dts')
224 output
= tools
.GetOutputFilename('output')
225 dtb_platdata
.run_steps(['struct'], dtb_file
, False, output
)
226 with
open(output
) as infile
:
228 self
.assertEqual('''#include <stdbool.h>
231 \tstruct phandle_1_arg clocks[1];
238 dtb_platdata
.run_steps(['platdata'], dtb_file
, False, output
)
239 with
open(output
) as infile
:
241 self
.assertEqual('''#include <common.h>
243 #include <dt-structs.h>
245 static struct dtd_target dtv_phandle_target = {
246 \t.intval\t\t\t= 0x1,
248 U_BOOT_DEVICE(phandle_target) = {
249 \t.name\t\t= "target",
250 \t.platdata\t= &dtv_phandle_target,
251 \t.platdata_size\t= sizeof(dtv_phandle_target),
254 static struct dtd_source dtv_phandle_source = {
256 \t\t{&dtv_phandle_target, {1}},},
258 U_BOOT_DEVICE(phandle_source) = {
259 \t.name\t\t= "source",
260 \t.platdata\t= &dtv_phandle_source,
261 \t.platdata_size\t= sizeof(dtv_phandle_source),
266 def test_aliases(self
):
267 """Test output from a node with multiple compatible strings"""
268 dtb_file
= get_dtb_file('dtoc_test_aliases.dts')
269 output
= tools
.GetOutputFilename('output')
270 dtb_platdata
.run_steps(['struct'], dtb_file
, False, output
)
271 with
open(output
) as infile
:
273 self
.assertEqual('''#include <stdbool.h>
278 #define dtd_compat2_1_fred dtd_compat1
279 #define dtd_compat3 dtd_compat1
282 dtb_platdata
.run_steps(['platdata'], dtb_file
, False, output
)
283 with
open(output
) as infile
:
285 self
.assertEqual('''#include <common.h>
287 #include <dt-structs.h>
289 static struct dtd_compat1 dtv_spl_test = {
290 \t.intval\t\t\t= 0x1,
292 U_BOOT_DEVICE(spl_test) = {
293 \t.name\t\t= "compat1",
294 \t.platdata\t= &dtv_spl_test,
295 \t.platdata_size\t= sizeof(dtv_spl_test),
300 def test_addresses64(self
):
301 """Test output from a node with a 'reg' property with na=2, ns=2"""
302 dtb_file
= get_dtb_file('dtoc_test_addr64.dts')
303 output
= tools
.GetOutputFilename('output')
304 dtb_platdata
.run_steps(['struct'], dtb_file
, False, output
)
305 with
open(output
) as infile
:
307 self
.assertEqual('''#include <stdbool.h>
320 dtb_platdata
.run_steps(['platdata'], dtb_file
, False, output
)
321 with
open(output
) as infile
:
323 self
.assertEqual('''#include <common.h>
325 #include <dt-structs.h>
327 static struct dtd_test1 dtv_test1 = {
328 \t.reg\t\t\t= {0x1234, 0x5678},
330 U_BOOT_DEVICE(test1) = {
331 \t.name\t\t= "test1",
332 \t.platdata\t= &dtv_test1,
333 \t.platdata_size\t= sizeof(dtv_test1),
336 static struct dtd_test2 dtv_test2 = {
337 \t.reg\t\t\t= {0x1234567890123456, 0x9876543210987654},
339 U_BOOT_DEVICE(test2) = {
340 \t.name\t\t= "test2",
341 \t.platdata\t= &dtv_test2,
342 \t.platdata_size\t= sizeof(dtv_test2),
345 static struct dtd_test3 dtv_test3 = {
346 \t.reg\t\t\t= {0x1234567890123456, 0x9876543210987654, 0x2, 0x3},
348 U_BOOT_DEVICE(test3) = {
349 \t.name\t\t= "test3",
350 \t.platdata\t= &dtv_test3,
351 \t.platdata_size\t= sizeof(dtv_test3),
356 def test_addresses32(self
):
357 """Test output from a node with a 'reg' property with na=1, ns=1"""
358 dtb_file
= get_dtb_file('dtoc_test_addr32.dts')
359 output
= tools
.GetOutputFilename('output')
360 dtb_platdata
.run_steps(['struct'], dtb_file
, False, output
)
361 with
open(output
) as infile
:
363 self
.assertEqual('''#include <stdbool.h>
373 dtb_platdata
.run_steps(['platdata'], dtb_file
, False, output
)
374 with
open(output
) as infile
:
376 self
.assertEqual('''#include <common.h>
378 #include <dt-structs.h>
380 static struct dtd_test1 dtv_test1 = {
381 \t.reg\t\t\t= {0x1234, 0x5678},
383 U_BOOT_DEVICE(test1) = {
384 \t.name\t\t= "test1",
385 \t.platdata\t= &dtv_test1,
386 \t.platdata_size\t= sizeof(dtv_test1),
389 static struct dtd_test2 dtv_test2 = {
390 \t.reg\t\t\t= {0x12345678, 0x98765432, 0x2, 0x3},
392 U_BOOT_DEVICE(test2) = {
393 \t.name\t\t= "test2",
394 \t.platdata\t= &dtv_test2,
395 \t.platdata_size\t= sizeof(dtv_test2),
400 def test_addresses64_32(self
):
401 """Test output from a node with a 'reg' property with na=2, ns=1"""
402 dtb_file
= get_dtb_file('dtoc_test_addr64_32.dts')
403 output
= tools
.GetOutputFilename('output')
404 dtb_platdata
.run_steps(['struct'], dtb_file
, False, output
)
405 with
open(output
) as infile
:
407 self
.assertEqual('''#include <stdbool.h>
420 dtb_platdata
.run_steps(['platdata'], dtb_file
, False, output
)
421 with
open(output
) as infile
:
423 self
.assertEqual('''#include <common.h>
425 #include <dt-structs.h>
427 static struct dtd_test1 dtv_test1 = {
428 \t.reg\t\t\t= {0x123400000000, 0x5678},
430 U_BOOT_DEVICE(test1) = {
431 \t.name\t\t= "test1",
432 \t.platdata\t= &dtv_test1,
433 \t.platdata_size\t= sizeof(dtv_test1),
436 static struct dtd_test2 dtv_test2 = {
437 \t.reg\t\t\t= {0x1234567890123456, 0x98765432},
439 U_BOOT_DEVICE(test2) = {
440 \t.name\t\t= "test2",
441 \t.platdata\t= &dtv_test2,
442 \t.platdata_size\t= sizeof(dtv_test2),
445 static struct dtd_test3 dtv_test3 = {
446 \t.reg\t\t\t= {0x1234567890123456, 0x98765432, 0x2, 0x3},
448 U_BOOT_DEVICE(test3) = {
449 \t.name\t\t= "test3",
450 \t.platdata\t= &dtv_test3,
451 \t.platdata_size\t= sizeof(dtv_test3),
456 def test_addresses32_64(self
):
457 """Test output from a node with a 'reg' property with na=1, ns=2"""
458 dtb_file
= get_dtb_file('dtoc_test_addr32_64.dts')
459 output
= tools
.GetOutputFilename('output')
460 dtb_platdata
.run_steps(['struct'], dtb_file
, False, output
)
461 with
open(output
) as infile
:
463 self
.assertEqual('''#include <stdbool.h>
476 dtb_platdata
.run_steps(['platdata'], dtb_file
, False, output
)
477 with
open(output
) as infile
:
479 self
.assertEqual('''#include <common.h>
481 #include <dt-structs.h>
483 static struct dtd_test1 dtv_test1 = {
484 \t.reg\t\t\t= {0x1234, 0x567800000000},
486 U_BOOT_DEVICE(test1) = {
487 \t.name\t\t= "test1",
488 \t.platdata\t= &dtv_test1,
489 \t.platdata_size\t= sizeof(dtv_test1),
492 static struct dtd_test2 dtv_test2 = {
493 \t.reg\t\t\t= {0x12345678, 0x9876543210987654},
495 U_BOOT_DEVICE(test2) = {
496 \t.name\t\t= "test2",
497 \t.platdata\t= &dtv_test2,
498 \t.platdata_size\t= sizeof(dtv_test2),
501 static struct dtd_test3 dtv_test3 = {
502 \t.reg\t\t\t= {0x12345678, 0x9876543210987654, 0x2, 0x3},
504 U_BOOT_DEVICE(test3) = {
505 \t.name\t\t= "test3",
506 \t.platdata\t= &dtv_test3,
507 \t.platdata_size\t= sizeof(dtv_test3),