1# 2# Copyright (c) 2012 The Chromium OS Authors. 3# 4# SPDX-License-Identifier: GPL-2.0+ 5# 6 7"""Tests for the dtb_platdata module 8 9This includes unit tests for some functions and functional tests for 10""" 11 12import collections 13import os 14import struct 15import unittest 16 17import dtb_platdata 18from dtb_platdata import conv_name_to_c 19from dtb_platdata import get_compat_name 20from dtb_platdata import get_value 21from dtb_platdata import tab_to 22import fdt 23import fdt_util 24import tools 25 26our_path = os.path.dirname(os.path.realpath(__file__)) 27 28 29def get_dtb_file(dts_fname): 30 """Compile a .dts file to a .dtb 31 32 Args: 33 dts_fname: Filename of .dts file in the current directory 34 35 Returns: 36 Filename of compiled file in output directory 37 """ 38 return fdt_util.EnsureCompiled(os.path.join(our_path, dts_fname)) 39 40 41class TestDtoc(unittest.TestCase): 42 """Tests for dtoc""" 43 @classmethod 44 def setUpClass(cls): 45 tools.PrepareOutputDir(None) 46 47 @classmethod 48 def tearDownClass(cls): 49 tools._RemoveOutputDir() 50 51 def test_name(self): 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')) 58 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')) 67 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)) 78 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']) 83 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)) 88 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)) 93 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)) 99 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) 108 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) 114 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: 121 data = infile.read() 122 self.assertEqual('''#include <stdbool.h> 123#include <libfdt.h> 124struct dtd_sandbox_i2c_test { 125}; 126struct dtd_sandbox_pmic_test { 127\tbool\t\tlow_power; 128\tfdt64_t\t\treg[2]; 129}; 130struct dtd_sandbox_spl_test { 131\tbool\t\tboolval; 132\tunsigned char\tbytearray[3]; 133\tunsigned char\tbyteval; 134\tfdt32_t\t\tintarray[4]; 135\tfdt32_t\t\tintval; 136\tunsigned char\tlongbytearray[9]; 137\tconst char *\tstringarray[3]; 138\tconst char *\tstringval; 139}; 140struct dtd_sandbox_spl_test_2 { 141}; 142''', data) 143 144 dtb_platdata.run_steps(['platdata'], dtb_file, False, output) 145 with open(output) as infile: 146 data = infile.read() 147 self.assertEqual('''#include <common.h> 148#include <dm.h> 149#include <dt-structs.h> 150 151static struct dtd_sandbox_spl_test dtv_spl_test = { 152\t.bytearray\t\t= {0x6, 0x0, 0x0}, 153\t.byteval\t\t= 0x5, 154\t.intval\t\t\t= 0x1, 155\t.longbytearray\t\t= {0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0x10, 156\t\t0x11}, 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", ""}, 161}; 162U_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), 166}; 167 168static struct dtd_sandbox_spl_test dtv_spl_test2 = { 169\t.bytearray\t\t= {0x1, 0x23, 0x34}, 170\t.byteval\t\t= 0x8, 171\t.intval\t\t\t= 0x3, 172\t.longbytearray\t\t= {0x9, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 173\t\t0x0}, 174\t.stringval\t\t= "message2", 175\t.intarray\t\t= {0x5, 0x0, 0x0, 0x0}, 176\t.stringarray\t\t= {"another", "multi-word", "message"}, 177}; 178U_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), 182}; 183 184static struct dtd_sandbox_spl_test dtv_spl_test3 = { 185\t.stringarray\t\t= {"one", "", ""}, 186}; 187U_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), 191}; 192 193static struct dtd_sandbox_spl_test_2 dtv_spl_test4 = { 194}; 195U_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), 199}; 200 201static struct dtd_sandbox_i2c_test dtv_i2c_at_0 = { 202}; 203U_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), 207}; 208 209static struct dtd_sandbox_pmic_test dtv_pmic_at_9 = { 210\t.low_power\t\t= true, 211\t.reg\t\t\t= {0x9, 0x0}, 212}; 213U_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), 217}; 218 219''', data) 220 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: 227 data = infile.read() 228 self.assertEqual('''#include <stdbool.h> 229#include <libfdt.h> 230struct dtd_source { 231\tstruct phandle_2_arg clocks[4]; 232}; 233struct dtd_target { 234\tfdt32_t\t\tintval; 235}; 236''', data) 237 238 dtb_platdata.run_steps(['platdata'], dtb_file, False, output) 239 with open(output) as infile: 240 data = infile.read() 241 self.assertEqual('''#include <common.h> 242#include <dm.h> 243#include <dt-structs.h> 244 245static struct dtd_target dtv_phandle_target = { 246\t.intval\t\t\t= 0x0, 247}; 248U_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), 252}; 253 254static struct dtd_target dtv_phandle2_target = { 255\t.intval\t\t\t= 0x1, 256}; 257U_BOOT_DEVICE(phandle2_target) = { 258\t.name\t\t= "target", 259\t.platdata\t= &dtv_phandle2_target, 260\t.platdata_size\t= sizeof(dtv_phandle2_target), 261}; 262 263static struct dtd_target dtv_phandle3_target = { 264\t.intval\t\t\t= 0x2, 265}; 266U_BOOT_DEVICE(phandle3_target) = { 267\t.name\t\t= "target", 268\t.platdata\t= &dtv_phandle3_target, 269\t.platdata_size\t= sizeof(dtv_phandle3_target), 270}; 271 272static struct dtd_source dtv_phandle_source = { 273\t.clocks\t\t\t= { 274\t\t\t{&dtv_phandle_target, {}}, 275\t\t\t{&dtv_phandle2_target, {11}}, 276\t\t\t{&dtv_phandle3_target, {12, 13}}, 277\t\t\t{&dtv_phandle_target, {}},}, 278}; 279U_BOOT_DEVICE(phandle_source) = { 280\t.name\t\t= "source", 281\t.platdata\t= &dtv_phandle_source, 282\t.platdata_size\t= sizeof(dtv_phandle_source), 283}; 284 285''', data) 286 287 def test_aliases(self): 288 """Test output from a node with multiple compatible strings""" 289 dtb_file = get_dtb_file('dtoc_test_aliases.dts') 290 output = tools.GetOutputFilename('output') 291 dtb_platdata.run_steps(['struct'], dtb_file, False, output) 292 with open(output) as infile: 293 data = infile.read() 294 self.assertEqual('''#include <stdbool.h> 295#include <libfdt.h> 296struct dtd_compat1 { 297\tfdt32_t\t\tintval; 298}; 299#define dtd_compat2_1_fred dtd_compat1 300#define dtd_compat3 dtd_compat1 301''', data) 302 303 dtb_platdata.run_steps(['platdata'], dtb_file, False, output) 304 with open(output) as infile: 305 data = infile.read() 306 self.assertEqual('''#include <common.h> 307#include <dm.h> 308#include <dt-structs.h> 309 310static struct dtd_compat1 dtv_spl_test = { 311\t.intval\t\t\t= 0x1, 312}; 313U_BOOT_DEVICE(spl_test) = { 314\t.name\t\t= "compat1", 315\t.platdata\t= &dtv_spl_test, 316\t.platdata_size\t= sizeof(dtv_spl_test), 317}; 318 319''', data) 320 321 def test_addresses64(self): 322 """Test output from a node with a 'reg' property with na=2, ns=2""" 323 dtb_file = get_dtb_file('dtoc_test_addr64.dts') 324 output = tools.GetOutputFilename('output') 325 dtb_platdata.run_steps(['struct'], dtb_file, False, output) 326 with open(output) as infile: 327 data = infile.read() 328 self.assertEqual('''#include <stdbool.h> 329#include <libfdt.h> 330struct dtd_test1 { 331\tfdt64_t\t\treg[2]; 332}; 333struct dtd_test2 { 334\tfdt64_t\t\treg[2]; 335}; 336struct dtd_test3 { 337\tfdt64_t\t\treg[4]; 338}; 339''', data) 340 341 dtb_platdata.run_steps(['platdata'], dtb_file, False, output) 342 with open(output) as infile: 343 data = infile.read() 344 self.assertEqual('''#include <common.h> 345#include <dm.h> 346#include <dt-structs.h> 347 348static struct dtd_test1 dtv_test1 = { 349\t.reg\t\t\t= {0x1234, 0x5678}, 350}; 351U_BOOT_DEVICE(test1) = { 352\t.name\t\t= "test1", 353\t.platdata\t= &dtv_test1, 354\t.platdata_size\t= sizeof(dtv_test1), 355}; 356 357static struct dtd_test2 dtv_test2 = { 358\t.reg\t\t\t= {0x1234567890123456, 0x9876543210987654}, 359}; 360U_BOOT_DEVICE(test2) = { 361\t.name\t\t= "test2", 362\t.platdata\t= &dtv_test2, 363\t.platdata_size\t= sizeof(dtv_test2), 364}; 365 366static struct dtd_test3 dtv_test3 = { 367\t.reg\t\t\t= {0x1234567890123456, 0x9876543210987654, 0x2, 0x3}, 368}; 369U_BOOT_DEVICE(test3) = { 370\t.name\t\t= "test3", 371\t.platdata\t= &dtv_test3, 372\t.platdata_size\t= sizeof(dtv_test3), 373}; 374 375''', data) 376 377 def test_addresses32(self): 378 """Test output from a node with a 'reg' property with na=1, ns=1""" 379 dtb_file = get_dtb_file('dtoc_test_addr32.dts') 380 output = tools.GetOutputFilename('output') 381 dtb_platdata.run_steps(['struct'], dtb_file, False, output) 382 with open(output) as infile: 383 data = infile.read() 384 self.assertEqual('''#include <stdbool.h> 385#include <libfdt.h> 386struct dtd_test1 { 387\tfdt32_t\t\treg[2]; 388}; 389struct dtd_test2 { 390\tfdt32_t\t\treg[4]; 391}; 392''', data) 393 394 dtb_platdata.run_steps(['platdata'], dtb_file, False, output) 395 with open(output) as infile: 396 data = infile.read() 397 self.assertEqual('''#include <common.h> 398#include <dm.h> 399#include <dt-structs.h> 400 401static struct dtd_test1 dtv_test1 = { 402\t.reg\t\t\t= {0x1234, 0x5678}, 403}; 404U_BOOT_DEVICE(test1) = { 405\t.name\t\t= "test1", 406\t.platdata\t= &dtv_test1, 407\t.platdata_size\t= sizeof(dtv_test1), 408}; 409 410static struct dtd_test2 dtv_test2 = { 411\t.reg\t\t\t= {0x12345678, 0x98765432, 0x2, 0x3}, 412}; 413U_BOOT_DEVICE(test2) = { 414\t.name\t\t= "test2", 415\t.platdata\t= &dtv_test2, 416\t.platdata_size\t= sizeof(dtv_test2), 417}; 418 419''', data) 420 421 def test_addresses64_32(self): 422 """Test output from a node with a 'reg' property with na=2, ns=1""" 423 dtb_file = get_dtb_file('dtoc_test_addr64_32.dts') 424 output = tools.GetOutputFilename('output') 425 dtb_platdata.run_steps(['struct'], dtb_file, False, output) 426 with open(output) as infile: 427 data = infile.read() 428 self.assertEqual('''#include <stdbool.h> 429#include <libfdt.h> 430struct dtd_test1 { 431\tfdt64_t\t\treg[2]; 432}; 433struct dtd_test2 { 434\tfdt64_t\t\treg[2]; 435}; 436struct dtd_test3 { 437\tfdt64_t\t\treg[4]; 438}; 439''', data) 440 441 dtb_platdata.run_steps(['platdata'], dtb_file, False, output) 442 with open(output) as infile: 443 data = infile.read() 444 self.assertEqual('''#include <common.h> 445#include <dm.h> 446#include <dt-structs.h> 447 448static struct dtd_test1 dtv_test1 = { 449\t.reg\t\t\t= {0x123400000000, 0x5678}, 450}; 451U_BOOT_DEVICE(test1) = { 452\t.name\t\t= "test1", 453\t.platdata\t= &dtv_test1, 454\t.platdata_size\t= sizeof(dtv_test1), 455}; 456 457static struct dtd_test2 dtv_test2 = { 458\t.reg\t\t\t= {0x1234567890123456, 0x98765432}, 459}; 460U_BOOT_DEVICE(test2) = { 461\t.name\t\t= "test2", 462\t.platdata\t= &dtv_test2, 463\t.platdata_size\t= sizeof(dtv_test2), 464}; 465 466static struct dtd_test3 dtv_test3 = { 467\t.reg\t\t\t= {0x1234567890123456, 0x98765432, 0x2, 0x3}, 468}; 469U_BOOT_DEVICE(test3) = { 470\t.name\t\t= "test3", 471\t.platdata\t= &dtv_test3, 472\t.platdata_size\t= sizeof(dtv_test3), 473}; 474 475''', data) 476 477 def test_addresses32_64(self): 478 """Test output from a node with a 'reg' property with na=1, ns=2""" 479 dtb_file = get_dtb_file('dtoc_test_addr32_64.dts') 480 output = tools.GetOutputFilename('output') 481 dtb_platdata.run_steps(['struct'], dtb_file, False, output) 482 with open(output) as infile: 483 data = infile.read() 484 self.assertEqual('''#include <stdbool.h> 485#include <libfdt.h> 486struct dtd_test1 { 487\tfdt64_t\t\treg[2]; 488}; 489struct dtd_test2 { 490\tfdt64_t\t\treg[2]; 491}; 492struct dtd_test3 { 493\tfdt64_t\t\treg[4]; 494}; 495''', data) 496 497 dtb_platdata.run_steps(['platdata'], dtb_file, False, output) 498 with open(output) as infile: 499 data = infile.read() 500 self.assertEqual('''#include <common.h> 501#include <dm.h> 502#include <dt-structs.h> 503 504static struct dtd_test1 dtv_test1 = { 505\t.reg\t\t\t= {0x1234, 0x567800000000}, 506}; 507U_BOOT_DEVICE(test1) = { 508\t.name\t\t= "test1", 509\t.platdata\t= &dtv_test1, 510\t.platdata_size\t= sizeof(dtv_test1), 511}; 512 513static struct dtd_test2 dtv_test2 = { 514\t.reg\t\t\t= {0x12345678, 0x9876543210987654}, 515}; 516U_BOOT_DEVICE(test2) = { 517\t.name\t\t= "test2", 518\t.platdata\t= &dtv_test2, 519\t.platdata_size\t= sizeof(dtv_test2), 520}; 521 522static struct dtd_test3 dtv_test3 = { 523\t.reg\t\t\t= {0x12345678, 0x9876543210987654, 0x2, 0x3}, 524}; 525U_BOOT_DEVICE(test3) = { 526\t.name\t\t= "test3", 527\t.platdata\t= &dtv_test3, 528\t.platdata_size\t= sizeof(dtv_test3), 529}; 530 531''', data) 532