| #!/usr/bin/env python3 |
| |
| # Copyright (c) 2022 The Chromium OS Authors |
| # SPDX-License-Identifier: Apache-2.0 |
| |
| """This file contains a Python script which parses through Zephyr device tree using |
| EDT.pickle generated at build and generates a XML file containing USB VIF policies""" |
| |
| import argparse |
| import inspect |
| import os |
| import pickle |
| import sys |
| import xml.etree.ElementTree as ET |
| |
| import constants |
| |
| SCRIPTS_DIR = os.path.join(os.path.dirname(__file__), "..") |
| sys.path.insert(0, os.path.join(SCRIPTS_DIR, 'dts', 'python-devicetree', 'src')) |
| |
| def main(): |
| global edtlib |
| |
| args = parse_args() |
| with open(args.edt_pickle, 'rb') as f: |
| edt = pickle.load(f) |
| edtlib = inspect.getmodule(edt) |
| |
| xml_root = get_root() |
| add_elements_to_xml(xml_root, constants.VIF_SPEC_ELEMENTS) |
| add_element_to_xml(xml_root, constants.MODEL_PART_NUMBER, args.board) |
| for node in edt.compat2nodes[args.compatible]: |
| xml_ele = add_element_to_xml(xml_root, constants.COMPONENT) |
| parse_and_add_node_to_xml(xml_ele, node) |
| tree = ET.ElementTree(xml_root) |
| tree.write(args.vif_out, xml_declaration=True, |
| encoding=constants.XML_ENCODING) |
| |
| |
| def is_vif_element(name): |
| if name in constants.VIF_ELEMENTS: |
| return True |
| return False |
| |
| |
| def get_vif_element_name(name): |
| return constants.XML_ELEMENT_NAME_PREFIX + ":" + constants.DT_VIF_ELEMENTS.get( |
| name, name) |
| |
| |
| def get_root(): |
| xml_root = ET.Element(get_vif_element_name(constants.XML_ROOT_ELEMENT_NAME)) |
| add_attributes_to_xml_element(xml_root, constants.XML_NAMESPACE_ATTRIBUTES) |
| return xml_root |
| |
| |
| def add_attributes_to_xml_element(xml_ele, attributes): |
| for key, value in attributes.items(): |
| xml_ele.set(key, value) |
| |
| |
| def add_element_to_xml(xml_ele, name, text=None, attributes=None): |
| if is_vif_element(name): |
| new_xml_ele = ET.SubElement(xml_ele, get_vif_element_name(name)) |
| if text: |
| new_xml_ele.text = str(text) |
| if attributes: |
| add_attributes_to_xml_element(new_xml_ele, attributes) |
| return new_xml_ele |
| return xml_ele |
| |
| |
| def add_elements_to_xml(xml_ele, elements): |
| for element_name in elements: |
| text = elements[element_name].get(constants.TEXT, None) |
| attributes = elements[element_name].get(constants.ATTRIBUTES, None) |
| new_xml_ele = add_element_to_xml(xml_ele, element_name, text, attributes) |
| if constants.CHILD in elements[element_name]: |
| add_elements_to_xml(new_xml_ele, elements[element_name][constants.CHILD]) |
| |
| |
| def is_simple_datatype(value): |
| if isinstance(value, (str, int, bool)): |
| return True |
| return False |
| |
| |
| def get_pdo_type(pdo_value): |
| return pdo_value >> 30 |
| |
| |
| def get_xml_bool_value(value): |
| if value: |
| return constants.TRUE |
| return constants.FALSE |
| |
| |
| def parse_and_add_sink_pdos_to_xml(xml_ele, sink_pdos): |
| new_xml_ele = add_element_to_xml(xml_ele, constants.SINK_PDOS) |
| pdos_info = dict() |
| snk_max_power = 0 |
| for pdo_value in sink_pdos: |
| power_mv = parse_and_add_sink_pdo_to_xml(new_xml_ele, pdo_value, pdos_info) |
| if power_mv > snk_max_power: |
| snk_max_power = power_mv |
| add_element_to_xml(xml_ele, constants.NUM_SINK_PDOS, None, |
| {constants.VALUE: str(len(sink_pdos))}) |
| add_element_to_xml(xml_ele, constants.EPR_SUPPORTED_AS_SINK, |
| attributes={constants.VALUE: constants.FALSE}) |
| add_element_to_xml(xml_ele, constants.NO_USB_SUSPEND_MAY_BE_SET, |
| attributes={constants.VALUE: constants.TRUE}) |
| add_element_to_xml(xml_ele, constants.HIGHER_CAPABILITY_SET, attributes={ |
| constants.VALUE: get_xml_bool_value(pdos_info.get(constants.HIGHER_CAPABILITY_SET, 0))}) |
| add_element_to_xml(xml_ele, constants.FR_SWAP_REQD_TYPE_C_CURRENT_AS_INITIAL_SOURCE, |
| "FR_Swap not supported", attributes={constants.VALUE: str( |
| pdos_info.get(constants.FR_SWAP_REQD_TYPE_C_CURRENT_AS_INITIAL_SOURCE, 0))}) |
| add_element_to_xml(xml_ele, constants.PD_POWER_AS_SINK, f'{snk_max_power} mW', |
| {constants.VALUE: str(snk_max_power)}) |
| |
| |
| def parse_and_add_sink_pdo_to_xml(xml_ele, pdo_value, pdos_info): |
| power_mw = 0 |
| xml_ele = add_element_to_xml(xml_ele, constants.SINK_PDO) |
| pdo_type = get_pdo_type(pdo_value) |
| if pdo_type == constants.PDO_TYPE_FIXED: |
| current = pdo_value & 0x3ff |
| current_ma = current * 10 |
| voltage = (pdo_value >> 10) & 0x3ff |
| voltage_mv = voltage * 50 |
| power_mw = (current_ma * voltage_mv) // 1000 |
| pdos_info[constants.HIGHER_CAPABILITY_SET] = pdo_value & (1 << 28) |
| pdos_info[constants.FR_SWAP_REQD_TYPE_C_CURRENT_AS_INITIAL_SOURCE] = pdo_value & (3 << 23) |
| add_element_to_xml(xml_ele, constants.SINK_PDO_VOLTAGE, f'{voltage_mv} mV', |
| {constants.VALUE: str(voltage)}) |
| add_element_to_xml(xml_ele, constants.SINK_PDO_OP_CURRENT, |
| f'{current_ma} mA', |
| {constants.VALUE: str(current)}) |
| elif pdo_type == constants.PDO_TYPE_BATTERY: |
| max_voltage = (pdo_value >> 20) & 0x3ff |
| max_voltage_mv = max_voltage * 50 |
| min_voltage = (pdo_value >> 10) & 0x3ff |
| min_voltage_mv = min_voltage * 50 |
| power = pdo_value & 0x3ff |
| power_mw = power * 250 |
| add_element_to_xml(xml_ele, constants.SINK_PDO_MIN_VOLTAGE, |
| f'{min_voltage_mv} mV', |
| {constants.VALUE: str(min_voltage)}) |
| add_element_to_xml(xml_ele, constants.SINK_PDO_MAX_VOLTAGE, |
| f'{max_voltage_mv} mV', |
| {constants.VALUE: str(max_voltage)}) |
| add_element_to_xml(xml_ele, constants.SINK_PDO_OP_POWER, f'{power_mw} mW', |
| {constants.VALUE: str(power)}) |
| elif pdo_type == constants.PDO_TYPE_VARIABLE: |
| max_voltage = (pdo_value >> 20) & 0x3ff |
| max_voltage_mv = max_voltage * 50 |
| min_voltage = (pdo_value >> 10) & 0x3ff |
| min_voltage_mv = min_voltage * 50 |
| current = pdo_value & 0x3ff |
| current_ma = current * 10 |
| power_mw = (current_ma * max_voltage_mv) // 1000 |
| add_element_to_xml(xml_ele, constants.SINK_PDO_MIN_VOLTAGE, |
| f'{min_voltage_mv} mV', |
| {constants.VALUE: str(min_voltage)}) |
| add_element_to_xml(xml_ele, constants.SINK_PDO_MAX_VOLTAGE, |
| f'{max_voltage_mv} mV', |
| {constants.VALUE: str(max_voltage)}) |
| add_element_to_xml(xml_ele, constants.SINK_PDO_OP_CURRENT, |
| f'{current_ma} mA', |
| {constants.VALUE: str(current)}) |
| elif pdo_type == constants.PDO_TYPE_AUGUMENTED: |
| pps = (pdo_value >> 28) & 0x03 |
| if pps: |
| raise ValueError(f'ERROR: Invalid PDO_TYPE {pdo_value}') |
| pps_max_voltage = (pdo_value >> 17) & 0xff |
| pps_max_voltage_mv = pps_max_voltage * 100 |
| pps_min_voltage = (pdo_value >> 8) & 0xff |
| pps_min_voltage_mv = pps_min_voltage * 100 |
| pps_current = pdo_value & 0x7f |
| pps_current_ma = pps_current * 50 |
| power_mw = (pps_current_ma * pps_max_voltage_mv) // 1000 |
| add_element_to_xml(xml_ele, constants.SINK_PDO_MIN_VOLTAGE, |
| f'{pps_min_voltage_mv} mV', |
| {constants.VALUE: str(pps_min_voltage)}) |
| add_element_to_xml(xml_ele, constants.SINK_PDO_MAX_VOLTAGE, |
| f'{pps_max_voltage_mv} mV', |
| {constants.VALUE: str(pps_max_voltage)}) |
| add_element_to_xml(xml_ele, constants.SINK_PDO_OP_CURRENT, |
| f'{pps_current_ma} mA', |
| {constants.VALUE: str(pps_current)}) |
| else: |
| raise ValueError(f'ERROR: Invalid PDO_TYPE {pdo_value}') |
| add_element_to_xml(xml_ele, constants.SINK_PDO_SUPPLY_TYPE, |
| constants.PDO_TYPES[pdo_type], {constants.VALUE: str(pdo_type)}) |
| return power_mw |
| |
| |
| def parse_and_add_controller_and_data_to_xml(xml_ele, cad): |
| xml_ele = add_element_to_xml(xml_ele, cad.basename) |
| for name in cad.data: |
| add_element_to_xml(xml_ele, name, str(cad.data[name])) |
| parse_and_add_node_to_xml(xml_ele, cad.controller) |
| |
| |
| def parse_and_add_array_to_xml(xml_ele, prop): |
| for member in prop.val: |
| if is_simple_datatype(member): |
| add_element_to_xml(xml_ele, prop.name, str(member)) |
| elif isinstance(member, list): |
| new_xml_ele = add_element_to_xml(xml_ele, prop.name) |
| parse_and_add_array_to_xml(new_xml_ele, member) |
| elif isinstance(member, edtlib.Node): |
| new_xml_ele = add_element_to_xml(xml_ele, prop.name) |
| parse_and_add_node_to_xml(new_xml_ele, member) |
| elif isinstance(member, edtlib.ControllerAndData): |
| new_xml_ele = add_element_to_xml(xml_ele, prop.name) |
| parse_and_add_controller_and_data_to_xml(new_xml_ele, member) |
| else: |
| ValueError( |
| f'Noticed undefined type : {str(type(member))}, with value {str(member)}') |
| |
| |
| def parse_and_add_node_to_xml(xml_ele, node): |
| if not isinstance(node, edtlib.Node): |
| return |
| xml_ele = add_element_to_xml(xml_ele, node.name) |
| for prop in node.props: |
| if is_simple_datatype(node.props[prop].val): |
| add_element_to_xml(xml_ele, node.props[prop].name, |
| str(node.props[prop].val)) |
| elif node.props[prop].name == constants.SINK_PDOS: |
| parse_and_add_sink_pdos_to_xml(xml_ele, node.props[prop].val) |
| elif isinstance(node.props[prop].val, list): |
| parse_and_add_array_to_xml(xml_ele, node.props[prop]) |
| elif isinstance(node.props[prop].val, edtlib.Node): |
| new_xml_ele = add_element_to_xml(xml_ele, node.props[prop].name) |
| parse_and_add_node_to_xml(new_xml_ele, node.props[prop].val) |
| elif isinstance(node.props[prop].val, edtlib.ControllerAndData): |
| new_xml_ele = add_element_to_xml(xml_ele, node.props[prop].name) |
| parse_and_add_controller_and_data_to_xml(new_xml_ele, node.props[prop].val) |
| else: |
| ValueError( |
| f'Noticed undefined type : {str(type(node.props[prop].val))}, ' |
| f'with value {str(node.props[prop].val)}') |
| for child in node.children: |
| new_xml_ele = add_element_to_xml(xml_ele, child) |
| parse_and_add_node_to_xml(new_xml_ele, node.children[child]) |
| |
| |
| def parse_args(): |
| parser = argparse.ArgumentParser(allow_abbrev=False) |
| parser.add_argument("--edt-pickle", required=True, |
| help="path to read the pickled edtlib.EDT object from") |
| parser.add_argument("--compatible", required=True, |
| help="device tree compatible to be parsed") |
| parser.add_argument("--vif-out", required=True, |
| help="path to write VIF policies to") |
| parser.add_argument("--board", required=True, help="board name") |
| return parser.parse_args() |
| |
| |
| if __name__ == "__main__": |
| main() |
