| #!/usr/bin/env python3 |
| """ |
| This script parses given interface pin-mapping xml file, stores the pin-mapping |
| information w.r.t. its location in the device. It also generates a template |
| csv file for the end-user of the eFPGA device. User can modify the template |
| csv file and specify the user-defined pin names to the ports defined in the |
| template csv file. |
| """ |
| |
| import argparse |
| import csv |
| import sys |
| |
| from collections import namedtuple |
| |
| import lxml.etree as ET |
| |
| |
| # ============================================================================= |
| class PinMappingData(object): |
| """ |
| Pin mapping data for IO ports in an eFPGA device. |
| |
| port_name - IO port name |
| mapped_pin - User-defined pin name mapped to the given port_name |
| x - x coordinate corresponding to column number |
| y - y coordinate corresponding to row number |
| z - z coordinate corresponding to pin index at current x,y location |
| """ |
| |
| def __init__(self, port_name, mapped_pin, x, y, z): |
| self.port_name = port_name |
| self.mapped_pin = mapped_pin |
| self.x = x |
| self.y = y |
| self.z = z |
| |
| def __str__(self): |
| return "{Port_name: '%s' mapped_pin: '%s' x: '%s' y: '%s' z: '%s'}" % ( |
| self.port_name, self.mapped_pin, self.x, self.y, self.z |
| ) |
| |
| def __repr__(self): |
| return "{Port_name: '%s' mapped_pin: '%s' x: '%s' y: '%s' z: '%s'}" % ( |
| self.port_name, self.mapped_pin, self.x, self.y, self.z |
| ) |
| |
| |
| """ |
| Device properties present in the pin-mapping xml |
| |
| name - Device name |
| family - Device family name |
| width - Device width aka number of cells in a row |
| heigth - Device height aka number of cells in a column |
| z - Number of cells per row/col |
| """ |
| DeviceData = namedtuple("DeviceData", "name family width height z") |
| |
| # ============================================================================= |
| |
| |
| def parse_io(xml_io, port_map, orientation, width, height, z): |
| ''' |
| Parses IO section of xml file |
| ''' |
| assert xml_io is not None |
| |
| pins = {} |
| |
| io_row = "" |
| io_col = "" |
| if orientation in ("TOP", "BOTTOM"): |
| io_row = xml_io.get("y") |
| if io_row is None: |
| if orientation == "TOP": |
| io_row = str(int(height) - 1) |
| elif orientation == "BOTTOM": |
| io_row = "0" |
| elif orientation in ("LEFT", "RIGHT"): |
| io_col = xml_io.get("x") |
| if io_col is None: |
| if orientation == "LEFT": |
| io_col = "0" |
| elif orientation == "RIGHT": |
| io_col = str(int(width) - 1) |
| |
| for xml_cell in xml_io.findall("CELL"): |
| port_name = xml_cell.get("port_name") |
| mapped_name = xml_cell.get("mapped_name") |
| startx = xml_cell.get("startx") |
| starty = xml_cell.get("starty") |
| endx = xml_cell.get("endx") |
| endy = xml_cell.get("endy") |
| |
| # define properties for scalar pins |
| scalar_mapped_pins = vec_to_scalar(mapped_name) |
| |
| i = 0 |
| if startx is not None and endx is not None: |
| curr_startx = int(startx) |
| curr_endx = int(endx) |
| y = io_row |
| if curr_startx < curr_endx: |
| for x in range(curr_startx, curr_endx + 1): |
| for j in range(0, int(z)): |
| pins[x, y, j] = PinMappingData( |
| port_name=port_name, |
| mapped_pin=scalar_mapped_pins[i], |
| x=x, |
| y=y, |
| z=j |
| ) |
| port_map[scalar_mapped_pins[i]] = pins[x, y, j] |
| i += 1 |
| else: |
| for x in range(curr_startx, curr_endx - 1, -1): |
| for j in range(0, int(z)): |
| pins[x, y, j] = PinMappingData( |
| port_name=port_name, |
| mapped_pin=scalar_mapped_pins[i], |
| x=x, |
| y=y, |
| z=j |
| ) |
| port_map[scalar_mapped_pins[i]] = pins[x, y, j] |
| i += 1 |
| elif starty is not None and endy is not None: |
| curr_starty = int(starty) |
| curr_endy = int(endy) |
| x = io_col |
| if curr_starty < curr_endy: |
| for y in range(curr_starty, curr_endy + 1): |
| for j in range(0, int(z)): |
| pins[x, y, j] = PinMappingData( |
| port_name=port_name, |
| mapped_pin=scalar_mapped_pins[i], |
| x=x, |
| y=y, |
| z=j |
| ) |
| port_map[scalar_mapped_pins[i]] = pins[x, y, j] |
| i += 1 |
| else: |
| for y in range(curr_starty, curr_endy - 1, -1): |
| for j in range(0, int(z)): |
| pins[x, y, j] = PinMappingData( |
| port_name=port_name, |
| mapped_pin=scalar_mapped_pins[i], |
| x=x, |
| y=y, |
| z=j |
| ) |
| port_map[scalar_mapped_pins[i]] = pins[x, y, j] |
| i += 1 |
| |
| return pins, port_map |
| |
| |
| # ============================================================================= |
| |
| |
| def vec_to_scalar(port_name): |
| ''' |
| Converts given bus port into its scalar ports |
| ''' |
| scalar_ports = [] |
| if port_name is not None and ':' in port_name: |
| open_brace = port_name.find('[') |
| close_brace = port_name.find(']') |
| if open_brace == -1 or close_brace == -1: |
| print( |
| 'Invalid portname "{}" specified. Bus ports should contain [ ] to specify range' |
| .format(port_name), |
| file=sys.stderr |
| ) |
| sys.exit(1) |
| bus = port_name[open_brace + 1:close_brace] |
| lsb = int(bus[:bus.find(':')]) |
| msb = int(bus[bus.find(':') + 1:]) |
| if lsb > msb: |
| for i in range(lsb, msb - 1, -1): |
| curr_port_name = port_name[:open_brace] + '[' + str(i) + ']' |
| scalar_ports.append(curr_port_name) |
| else: |
| for i in range(lsb, msb + 1): |
| curr_port_name = port_name[:open_brace] + '[' + str(i) + ']' |
| scalar_ports.append(curr_port_name) |
| else: |
| scalar_ports.append(port_name) |
| |
| return scalar_ports |
| |
| |
| # ============================================================================= |
| |
| |
| def parse_io_cells(xml_root): |
| """ |
| Parses the "IO" section of the pinmapfile. Returns a dict indexed by IO cell |
| names which contains cell types and their locations in the device grid. |
| """ |
| |
| cells = {} |
| port_map = {} |
| |
| width = xml_root.get("width"), |
| height = xml_root.get("height"), |
| io_per_cell = xml_root.get("z") |
| |
| # Get the "IO" section |
| xml_io = xml_root.find("IO") |
| if xml_io is None: |
| print("ERROR: No mandatory 'IO' section defined in 'DEVICE' section") |
| sys.exit(1) |
| |
| xml_top_io = xml_io.find("TOP_IO") |
| if xml_top_io is not None: |
| currcells, port_map = parse_io( |
| xml_top_io, port_map, "TOP", width, height, io_per_cell |
| ) |
| cells["TOP"] = currcells |
| |
| xml_bottom_io = xml_io.find("BOTTOM_IO") |
| if xml_bottom_io is not None: |
| currcells, port_map = parse_io( |
| xml_bottom_io, port_map, "BOTTOM", width, height, io_per_cell |
| ) |
| cells["BOTTOM"] = currcells |
| |
| xml_left_io = xml_io.find("LEFT_IO") |
| if xml_left_io is not None: |
| currcells, port_map = parse_io( |
| xml_left_io, port_map, "LEFT", width, height, io_per_cell |
| ) |
| cells["LEFT"] = currcells |
| |
| xml_right_io = xml_io.find("RIGHT_IO") |
| if xml_right_io is not None: |
| currcells, port_map = parse_io( |
| xml_right_io, port_map, "RIGHT", width, height, io_per_cell |
| ) |
| cells["RIGHT"] = currcells |
| |
| return cells, port_map |
| |
| |
| # ============================================================================ |
| |
| |
| def read_pinmapfile_data(pinmapfile): |
| """ |
| Loads and parses a pinmap file |
| """ |
| |
| # Read and parse the XML archfile |
| parser = ET.XMLParser(resolve_entities=False, strip_cdata=False) |
| xml_tree = ET.parse(pinmapfile, parser) |
| xml_root = xml_tree.getroot() |
| |
| if xml_root.get("name") is None: |
| print( |
| "ERROR: No mandatory attribute 'name' specified in 'DEVICE' section" |
| ) |
| sys.exit(1) |
| |
| if xml_root.get("family") is None: |
| print( |
| "ERROR: No mandatory attribute 'family' specified in 'DEVICE' section" |
| ) |
| sys.exit(1) |
| |
| if xml_root.get("width") is None: |
| print( |
| "ERROR: No mandatory attribute 'width' specified in 'DEVICE' section" |
| ) |
| sys.exit(1) |
| |
| if xml_root.get("height") is None: |
| print( |
| "ERROR: No mandatory attribute 'height' specified in 'DEVICE' section" |
| ) |
| sys.exit(1) |
| |
| if xml_root.get("z") is None: |
| print( |
| "ERROR: No mandatory attribute 'z' specified in 'DEVICE' section" |
| ) |
| sys.exit(1) |
| |
| # Parse IO cells |
| io_cells, port_map = parse_io_cells(xml_root) |
| |
| return io_cells, port_map |
| |
| |
| # ============================================================================= |
| |
| |
| def generate_pinmap_csv(pinmap_csv_file, io_cells): |
| ''' |
| Generates pinmap csv file |
| ''' |
| with open(pinmap_csv_file, "w", newline='') as csvfile: |
| fieldnames = [ |
| 'orientation', 'row', 'col', 'pin_num_in_cell', 'port_name', |
| 'mapped_pin', 'GPIO_type', 'Associated Clock', 'Clock Edge' |
| ] |
| writer = csv.DictWriter(csvfile, fieldnames=fieldnames) |
| |
| writer.writeheader() |
| for orientation, pin_map in io_cells.items(): |
| for pin_loc, pin_obj in pin_map.items(): |
| writer.writerow( |
| { |
| 'orientation': orientation, |
| 'row': str(pin_obj.y), |
| 'col': str(pin_obj.x), |
| 'pin_num_in_cell': str(pin_obj.z), |
| 'port_name': pin_obj.mapped_pin, |
| } |
| ) |
| |
| |
| # ============================================================================= |
| |
| |
| def main(): |
| ''' |
| Processes interface mapping xml file and generates template csv file |
| ''' |
| # Parse arguments |
| parser = argparse.ArgumentParser( |
| description='Process interface mapping xml file to generate csv file.' |
| ) |
| |
| parser.add_argument( |
| "--pinmapfile", |
| "-p", |
| "-P", |
| type=str, |
| required=True, |
| help="Input pin-mapping XML file" |
| ) |
| parser.add_argument( |
| "--csv_file", |
| "-c", |
| "-C", |
| type=str, |
| default="template_pinmap.csv", |
| help="Output template pinmap CSV file" |
| ) |
| |
| args = parser.parse_args() |
| |
| # Load all the necessary data from the pinmapfile |
| io_cells, port_map = read_pinmapfile_data(args.pinmapfile) |
| |
| # Generate the pinmap CSV |
| generate_pinmap_csv(args.csv_file, io_cells) |
| |
| |
| if __name__ == "__main__": |
| main() |
