mirror of
https://github.com/ByteWelder/Tactility.git
synced 2026-02-18 19:03:16 +00:00
253 lines
10 KiB
Python
253 lines
10 KiB
Python
import os.path
|
|
from textwrap import dedent
|
|
from source.models import *
|
|
from .exception import DevicetreeException
|
|
|
|
def write_include(file, include: IncludeC, verbose: bool):
|
|
if verbose:
|
|
print("Processing include:")
|
|
print(f" {include.statement}")
|
|
file.write(include.statement)
|
|
file.write('\n')
|
|
|
|
def write_define(file, define: DefineC, verbose: bool):
|
|
if verbose:
|
|
print("Processing define:")
|
|
print(f" {define.statement}")
|
|
file.write(define.statement)
|
|
file.write('\n')
|
|
|
|
def get_device_node_name_safe(device: Device):
|
|
if device.node_name == "/":
|
|
return "root"
|
|
else:
|
|
return device.node_name.replace("-", "_")
|
|
|
|
def get_device_type_name(device: Device, bindings: list[Binding]):
|
|
device_binding = find_device_binding(device, bindings)
|
|
if device_binding is None:
|
|
raise DevicetreeException(f"Binding not found for {device.node_name}")
|
|
if device_binding.compatible is None:
|
|
raise DevicetreeException(f"Couldn't find compatible binding for {device.node_name}")
|
|
compatible_safe = device_binding.compatible.split(",")[-1]
|
|
return compatible_safe.replace("-", "_")
|
|
|
|
def find_device_property(device: Device, name: str) -> DeviceProperty:
|
|
for property in device.properties:
|
|
if property.name == name:
|
|
return property
|
|
return None
|
|
|
|
def find_device_binding(device: Device, bindings: list[Binding]) -> Binding:
|
|
compatible_property = find_device_property(device, "compatible")
|
|
if compatible_property is None:
|
|
raise DevicetreeException(f"property 'compatible' not found in device {device.node_name}")
|
|
for binding in bindings:
|
|
if binding.compatible == compatible_property.value:
|
|
return binding
|
|
return None
|
|
|
|
def find_binding(compatible: str, bindings: list[Binding]) -> Binding:
|
|
for binding in bindings:
|
|
if binding.compatible == compatible:
|
|
return binding
|
|
return None
|
|
|
|
def find_phandle(devices: list[Device], phandle: str):
|
|
for device in devices:
|
|
if device.node_name == phandle or device.node_alias == phandle:
|
|
return f"&{get_device_node_name_safe(device)}"
|
|
raise DevicetreeException(f"phandle '{phandle}' not found in device tree")
|
|
|
|
def property_to_string(property: DeviceProperty, devices: list[Device]) -> str:
|
|
type = property.type
|
|
if type == "value" or type == "int":
|
|
return property.value
|
|
elif type == "boolean" or type == "bool":
|
|
return "true"
|
|
elif type == "text":
|
|
return f"\"{property.value}\""
|
|
elif type == "values":
|
|
value_list = list()
|
|
for item in property.value:
|
|
if isinstance(item, PropertyValue):
|
|
value_list.append(property_to_string(DeviceProperty(name="", type=item.type, value=item.value), devices))
|
|
else:
|
|
value_list.append(str(item))
|
|
return "{ " + ",".join(value_list) + " }"
|
|
elif type == "phandle":
|
|
return find_phandle(devices, property.value)
|
|
else:
|
|
raise DevicetreeException(f"property_to_string() has an unsupported type: {type}")
|
|
|
|
def resolve_parameters_from_bindings(device: Device, bindings: list[Binding], devices: list[Device]) -> list:
|
|
compatible_property = find_device_property(device, "compatible")
|
|
if compatible_property is None:
|
|
raise DevicetreeException(f"Cannot find 'compatible' property for {device.node_name}")
|
|
device_binding = find_binding(compatible_property.value, bindings)
|
|
if device_binding is None:
|
|
raise DevicetreeException(f"Binding not found for {device.node_name} and compatible '{compatible_property.value}'")
|
|
# Filter out system properties
|
|
binding_properties = []
|
|
binding_property_names = set()
|
|
for property in device_binding.properties:
|
|
if property.name != "compatible":
|
|
binding_properties.append(property)
|
|
binding_property_names.add(property.name)
|
|
|
|
# Check for invalid properties in device
|
|
for device_property in device.properties:
|
|
if device_property.name in ["compatible"]:
|
|
continue
|
|
if device_property.name not in binding_property_names:
|
|
raise DevicetreeException(f"Device '{device.node_name}' has invalid property '{device_property.name}'")
|
|
|
|
# Allocate total expected configuration arguments
|
|
result = [0] * len(binding_properties)
|
|
for index, binding_property in enumerate(binding_properties):
|
|
device_property = find_device_property(device, binding_property.name)
|
|
if device_property is None:
|
|
if binding_property.default is not None:
|
|
temp_prop = DeviceProperty(
|
|
name=binding_property.name,
|
|
type=binding_property.type,
|
|
value=binding_property.default
|
|
)
|
|
result[index] = property_to_string(temp_prop, devices)
|
|
elif binding_property.type == "bool":
|
|
result[index] = "false"
|
|
elif binding_property.required:
|
|
raise DevicetreeException(f"device {device.node_name} doesn't have property '{binding_property.name}'")
|
|
else:
|
|
raise DevicetreeException(f"Device {device.node_name} doesn't have property '{binding_property.name}' and no default value is set")
|
|
else:
|
|
result[index] = property_to_string(device_property, devices)
|
|
return result
|
|
|
|
def write_config(file, device: Device, bindings: list[Binding], devices: list[Device], type_name: str):
|
|
node_name = get_device_node_name_safe(device)
|
|
config_type = f"{type_name}_config_dt"
|
|
config_variable_name = f"{node_name}_config"
|
|
file.write(f"static const {config_type} {config_variable_name}" " = {\n")
|
|
config_params = resolve_parameters_from_bindings(device, bindings, devices)
|
|
# Indent all params
|
|
for index, config_param in enumerate(config_params):
|
|
config_params[index] = f"\t{config_param}"
|
|
# Join with command and newline
|
|
if len(config_params) > 0:
|
|
config_params_joined = ",\n".join(config_params)
|
|
file.write(f"{config_params_joined}\n")
|
|
file.write("};\n\n")
|
|
|
|
def write_device_structs(file, device: Device, parent_device: Device, bindings: list[Binding], devices: list[Device], verbose: bool):
|
|
if verbose:
|
|
print(f"Writing device struct for '{device.node_name}'")
|
|
# Assemble some pre-requisites
|
|
type_name = get_device_type_name(device, bindings)
|
|
compatible_property = find_device_property(device, "compatible")
|
|
if compatible_property is None:
|
|
raise DevicetreeException(f"Cannot find 'compatible' property for {device.node_name}")
|
|
node_name = get_device_node_name_safe(device)
|
|
config_variable_name = f"{node_name}_config"
|
|
if parent_device is not None:
|
|
parent_node_name = get_device_node_name_safe(parent_device)
|
|
parent_value = f"&{parent_node_name}"
|
|
else:
|
|
parent_value = "NULL"
|
|
# Write config struct
|
|
write_config(file, device, bindings, devices, type_name)
|
|
# Write device struct
|
|
file.write(f"static struct Device {node_name}" " = {\n")
|
|
file.write(f"\t.name = \"{device.node_name}\",\n") # Use original name
|
|
file.write(f"\t.config = &{config_variable_name},\n")
|
|
file.write(f"\t.parent = {parent_value},\n")
|
|
file.write("\t.internal = NULL\n")
|
|
file.write("};\n\n")
|
|
# Child devices
|
|
for child_device in device.devices:
|
|
write_device_structs(file, child_device, device, bindings, devices, verbose)
|
|
|
|
def write_device_init(file, device: Device, bindings: list[Binding], verbose: bool):
|
|
if verbose:
|
|
print(f"Processing device init code for '{device.node_name}'")
|
|
# Assemble some pre-requisites
|
|
compatible_property = find_device_property(device, "compatible")
|
|
if compatible_property is None:
|
|
raise DevicetreeException(f"Cannot find 'compatible' property for {device.node_name}")
|
|
# Type & instance names
|
|
node_name = get_device_node_name_safe(device)
|
|
device_variable = node_name
|
|
# Write device struct
|
|
file.write("\t{ " f"&{device_variable}, \"{compatible_property.value}\"" " },\n")
|
|
# Write children
|
|
for child_device in device.devices:
|
|
write_device_init(file, child_device, bindings, verbose)
|
|
|
|
# Walk the tree and gather all devices
|
|
def gather_devices(device: Device, output: list[Device]):
|
|
output.append(device)
|
|
for child_device in device.devices:
|
|
gather_devices(child_device, output)
|
|
|
|
def generate_devicetree_c(filename: str, items: list[object], bindings: list[Binding], verbose: bool):
|
|
# Create a cache for looking up device names and aliases easily
|
|
# We still want to traverse it as a tree during code generation because of parent-setting
|
|
devices = list()
|
|
for item in items:
|
|
if type(item) is Device:
|
|
gather_devices(item, devices)
|
|
|
|
with open(filename, "w") as file:
|
|
file.write(dedent('''\
|
|
// Default headers
|
|
#include <tactility/device.h>
|
|
// DTS headers
|
|
'''))
|
|
|
|
# Write all headers first
|
|
for item in items:
|
|
if type(item) is IncludeC:
|
|
write_include(file, item, verbose)
|
|
elif type(item) is DefineC:
|
|
write_define(file, item, verbose)
|
|
file.write("\n")
|
|
|
|
# Then write all devices
|
|
for item in items:
|
|
if type(item) is Device:
|
|
write_device_structs(file, item, None, bindings, devices, verbose)
|
|
# Init function body start
|
|
file.write("struct CompatibleDevice devicetree_devices[] = {\n")
|
|
# Init function body logic
|
|
for item in items:
|
|
if type(item) is Device:
|
|
write_device_init(file, item, bindings, verbose)
|
|
# Init function body end
|
|
file.write("\t{ NULL, NULL },\n")
|
|
file.write("};\n")
|
|
|
|
def generate_devicetree_h(filename: str):
|
|
with open(filename, "w") as file:
|
|
file.write(dedent('''\
|
|
#pragma once
|
|
#include <tactility/error.h>
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
extern struct CompatibleDevice devicetree_devices[];
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
'''))
|
|
|
|
def generate(output_path: str, items: list[object], bindings: list[Binding], verbose: bool):
|
|
if not os.path.exists(output_path):
|
|
os.makedirs(output_path)
|
|
devicetree_c_filename = os.path.join(output_path, "devicetree.c")
|
|
generate_devicetree_c(devicetree_c_filename, items, bindings, verbose)
|
|
devicetree_h_filename = os.path.join(output_path, "devicetree.h")
|
|
generate_devicetree_h(devicetree_h_filename)
|