| #!/usr/bin/env python3 |
| # |
| #-------------------------------------------------------- |
| # Padframe Editor and Core Floorplanner |
| # |
| #-------------------------------------------------------- |
| # Written by Tim Edwards |
| # efabless, inc. |
| # April 24, 2019 |
| # Version 0.5 |
| # Based on https://github.com/YosysHQ/padring (requirement) |
| # Update: May 9, 2019 to add console message window |
| # Update: May 10, 2019 to incorporate core floorplanning |
| # Update: Jan 31, 2020 to allow batch operation |
| #-------------------------------------------------------- |
| |
| import os |
| import re |
| import sys |
| import glob |
| import json |
| import math |
| import shutil |
| import signal |
| import select |
| import subprocess |
| import faulthandler |
| |
| import tkinter |
| from tkinter import ttk |
| from tkinter import filedialog |
| import tksimpledialog |
| from consoletext import ConsoleText |
| |
| # User preferences file (if it exists) |
| prefsfile = '~/design/.profile/prefs.json' |
| |
| #------------------------------------------------------ |
| # Dialog for entering a pad |
| #------------------------------------------------------ |
| |
| class PadNameDialog(tksimpledialog.Dialog): |
| def body(self, master, warning=None, seed=None): |
| if warning: |
| ttk.Label(master, text=warning).grid(row = 0, columnspan = 2, sticky = 'wns') |
| ttk.Label(master, text="Enter new group name:").grid(row = 1, column = 0, sticky = 'wns') |
| self.nentry = ttk.Entry(master) |
| self.nentry.grid(row = 1, column = 1, sticky = 'ewns') |
| if seed: |
| self.nentry.insert(0, seed) |
| return self.nentry # initial focus |
| |
| def apply(self): |
| return self.nentry.get() |
| |
| #------------------------------------------------------ |
| # Dialog for entering core dimensions |
| #------------------------------------------------------ |
| |
| class CoreSizeDialog(tksimpledialog.Dialog): |
| def body(self, master, warning="Chip core dimensions", seed=None): |
| if warning: |
| ttk.Label(master, text=warning).grid(row = 0, columnspan = 2, sticky = 'wns') |
| ttk.Label(master, text="Enter core width x height (microns):").grid(row = 1, column = 0, sticky = 'wns') |
| self.nentry = ttk.Entry(master) |
| self.nentry.grid(row = 1, column = 1, sticky = 'ewns') |
| |
| |
| if seed: |
| self.nentry.insert(0, seed) |
| return self.nentry # initial focus |
| |
| def apply(self): |
| return self.nentry.get() |
| |
| #------------------------------------------------ |
| # SoC Floorplanner and Padframe Generator GUI |
| #------------------------------------------------ |
| |
| class SoCFloorplanner(ttk.Frame): |
| """Pad Frame Generator.""" |
| |
| def __init__(self, parent = None, *args, **kwargs): |
| '''See the __init__ for Tkinter.Toplevel.''' |
| ttk.Frame.__init__(self, parent, *args[1:], **kwargs) |
| self.root = parent |
| self.init_data() |
| if args[0] == True: |
| self.do_gui = True |
| self.init_gui() |
| else: |
| self.do_gui = False |
| self.use_console = False |
| |
| def on_quit(self): |
| """Exits program.""" |
| quit() |
| |
| def init_gui(self): |
| """Builds GUI.""" |
| global prefsfile |
| |
| message = [] |
| fontsize = 11 |
| |
| # Read user preferences file, get default font size from it. |
| prefspath = os.path.expanduser(prefsfile) |
| if os.path.exists(prefspath): |
| with open(prefspath, 'r') as f: |
| self.prefs = json.load(f) |
| if 'fontsize' in self.prefs: |
| fontsize = self.prefs['fontsize'] |
| else: |
| self.prefs = {} |
| |
| s = ttk.Style() |
| |
| available_themes = s.theme_names() |
| s.theme_use(available_themes[0]) |
| |
| s.configure('normal.TButton', font=('Helvetica', fontsize), border = 3, relief = 'raised') |
| s.configure('title.TLabel', font=('Helvetica', fontsize, 'bold italic'), |
| foreground = 'brown', anchor = 'center') |
| s.configure('blue.TLabel', font=('Helvetica', fontsize), foreground = 'blue') |
| s.configure('normal.TLabel', font=('Helvetica', fontsize)) |
| s.configure('normal.TCheckbutton', font=('Helvetica', fontsize)) |
| s.configure('normal.TMenubutton', font=('Helvetica', fontsize)) |
| s.configure('normal.TEntry', font=('Helvetica', fontsize), background='white') |
| s.configure('pad.TLabel', font=('Helvetica', fontsize), foreground = 'blue', relief = 'flat') |
| s.configure('select.TLabel', font=('Helvetica', fontsize, 'bold'), foreground = 'white', |
| background = 'blue', relief = 'flat') |
| |
| # parent.withdraw() |
| self.root.title('Padframe Generator and Core Floorplanner') |
| self.root.option_add('*tearOff', 'FALSE') |
| self.pack(side = 'top', fill = 'both', expand = 'true') |
| self.root.protocol("WM_DELETE_WINDOW", self.on_quit) |
| |
| pane = tkinter.PanedWindow(self, orient = 'vertical', sashrelief = 'groove', |
| sashwidth = 6) |
| pane.pack(side = 'top', fill = 'both', expand = 'true') |
| |
| self.toppane = ttk.Frame(pane) |
| self.botpane = ttk.Frame(pane) |
| |
| self.toppane.columnconfigure(0, weight = 1) |
| self.toppane.rowconfigure(0, weight = 1) |
| self.botpane.columnconfigure(0, weight = 1) |
| self.botpane.rowconfigure(0, weight = 1) |
| |
| # Scrolled frame using canvas widget |
| self.pframe = tkinter.Frame(self.toppane) |
| self.pframe.grid(row = 0, column = 0, sticky = 'news') |
| self.pframe.rowconfigure(0, weight = 1) |
| self.pframe.columnconfigure(0, weight = 1) |
| |
| # Add column on the left, listing all groups and the pads they belong to. |
| # This starts as just a frame to be filled. Use a canvas to create a |
| # scrolled frame. |
| |
| # The primary frame holds the canvas |
| self.canvas = tkinter.Canvas(self.pframe, background = "white") |
| self.canvas.grid(row = 0, column = 0, sticky = 'news') |
| |
| # Add Y scrollbar to pad list window |
| xscrollbar = ttk.Scrollbar(self.pframe, orient = 'horizontal') |
| xscrollbar.grid(row = 1, column = 0, sticky = 'news') |
| yscrollbar = ttk.Scrollbar(self.pframe, orient = 'vertical') |
| yscrollbar.grid(row = 0, column = 1, sticky = 'news') |
| |
| self.canvas.config(xscrollcommand = xscrollbar.set) |
| xscrollbar.config(command = self.canvas.xview) |
| self.canvas.config(yscrollcommand = yscrollbar.set) |
| yscrollbar.config(command = self.canvas.yview) |
| |
| self.canvas.bind("<Button-4>", self.on_scrollwheel) |
| self.canvas.bind("<Button-5>", self.on_scrollwheel) |
| |
| # Configure callback |
| self.canvas.bind("<Configure>", self.frame_configure) |
| |
| # Add a text window to capture output. Redirect print statements to it. |
| self.console = ttk.Frame(self.botpane) |
| self.console.grid(column = 0, row = 0, sticky = "news") |
| self.text_box = ConsoleText(self.console, wrap='word', height = 4) |
| self.text_box.pack(side='left', fill='both', expand='true') |
| console_scrollbar = ttk.Scrollbar(self.console) |
| console_scrollbar.pack(side='right', fill='y') |
| # Attach console to scrollbar |
| self.text_box.config(yscrollcommand = console_scrollbar.set) |
| console_scrollbar.config(command = self.text_box.yview) |
| |
| # Add the bottom bar with buttons |
| self.bbar = ttk.Frame(self.botpane) |
| self.bbar.grid(column = 0, row = 1, sticky = "news") |
| |
| self.bbar.import_button = ttk.Button(self.bbar, text='Import', |
| command=self.vlogimport, style='normal.TButton') |
| self.bbar.import_button.grid(column=0, row=0, padx = 5) |
| |
| self.bbar.generate_button = ttk.Button(self.bbar, text='Generate', |
| command=self.generate, style='normal.TButton') |
| self.bbar.generate_button.grid(column=1, row=0, padx = 5) |
| |
| self.bbar.save_button = ttk.Button(self.bbar, text='Save', |
| command=self.save, style='normal.TButton') |
| self.bbar.save_button.grid(column=2, row=0, padx = 5) |
| |
| self.bbar.cancel_button = ttk.Button(self.bbar, text='Quit', |
| command=self.on_quit, style='normal.TButton') |
| self.bbar.cancel_button.grid(column=3, row=0, padx = 5) |
| |
| pane.add(self.toppane) |
| pane.add(self.botpane) |
| pane.paneconfig(self.toppane, stretch='first') |
| |
| def init_data(self): |
| |
| self.vlogpads = [] |
| self.corecells = [] |
| self.Npads = [] |
| self.Spads = [] |
| self.Epads = [] |
| self.Wpads = [] |
| self.NEpad = [] |
| self.NWpad = [] |
| self.SEpad = [] |
| self.SWpad = [] |
| self.coregroup = [] |
| |
| self.celldefs = [] |
| self.coredefs = [] |
| self.selected = [] |
| self.ioleflibs = [] |
| self.llx = 0 |
| self.lly = 0 |
| self.urx = 0 |
| self.ury = 0 |
| |
| self.event_data = {} |
| self.event_data['x0'] = 0 |
| self.event_data['y0'] = 0 |
| self.event_data['x'] = 0 |
| self.event_data['y'] = 0 |
| self.event_data['tag'] = None |
| self.scale = 1.0 |
| self.margin = 10 |
| self.pad_rotation = 0 |
| |
| self.init_messages = [] |
| self.stdout = None |
| self.stderr = None |
| |
| self.keep_cfg = False |
| self.ef_format = False |
| self.use_console = False |
| |
| def init_padframe(self): |
| self.set_project() |
| self.vlogimport() |
| self.readplacement(precheck=True) |
| self.resolve() |
| self.generate() |
| |
| # Local routines for handling printing to the text console |
| |
| def print(self, message, file=None, end='\n', flush=True): |
| if not file: |
| if not self.use_console: |
| file = sys.stdout |
| else: |
| file = ConsoleText.StdoutRedirector(self.text_box) |
| if self.stdout: |
| print(message, file=file, end=end) |
| if flush: |
| self.stdout.flush() |
| self.update_idletasks() |
| else: |
| self.init_messages.append(message) |
| |
| def text_to_console(self): |
| # Redirect stdout and stderr to the console as the last thing to do. . . |
| # Otherwise errors in the GUI get sucked into the void. |
| |
| self.stdout = sys.stdout |
| self.stderr = sys.stderr |
| if self.use_console: |
| sys.stdout = ConsoleText.StdoutRedirector(self.text_box) |
| sys.stderr = ConsoleText.StderrRedirector(self.text_box) |
| |
| if len(self.init_messages) > 0: |
| for message in self.init_messages: |
| self.print(message) |
| self.init_messages = [] |
| |
| # Set the project name(s). This is the name of the top-level verilog. |
| # The standard protocol is that the project directory contains a file |
| # project.json that defines a name 'ip-name' that is the same as the |
| # layout name, the verilog module name, etc. |
| |
| def set_project(self): |
| # Check pwd |
| pwdname = self.projectpath if self.projectpath else os.getcwd() |
| |
| subdir = os.path.split(pwdname)[1] |
| if subdir == 'mag' or subdir == 'verilog': |
| projectpath = os.path.split(pwdname)[0] |
| else: |
| projectpath = pwdname |
| |
| # Also check for project below the current working directory |
| |
| if not os.path.exists(projectpath + '/mag'): |
| print('No project path, checking subdirectories') |
| dlist = os.listdir(projectpath) |
| for dir in dlist: |
| print('Checking ' + projectpath + '/' + dir) |
| if os.path.exists(projectpath + '/' + dir + '/mag'): |
| projectpath = projectpath + '/' + dir |
| print('Found!') |
| break |
| |
| projectroot = os.path.split(projectpath)[0] |
| projectdirname = os.path.split(projectpath)[1] |
| |
| # Check for efabless format. This is probably more complicated than |
| # it deserves to be. Option -ef_format is the best way to specify |
| # efabless format. However, if it is not specified, then check the |
| # technology PDK directory and the project directory for the tell-tale |
| # ".ef-config" (efabless format) directory vs. ".config" (not efabless |
| # format). |
| |
| if not self.ef_format: |
| if os.path.exists(projectpath + '/.ef-config'): |
| self.ef_format = True |
| elif self.techpath: |
| if os.path.exists(self.techpath + '/.ef-config'): |
| self.ef_format = True |
| else: |
| # Do a quick consistency check. Honor the -ef_format option but warn if |
| # there is an apparent inconsistency. |
| if os.path.exists(projectpath + '/.config'): |
| self.print('Warning: -ef_format used in apparently non-efabless setup.') |
| elif self.techpath: |
| if os.path.exists(self.techpath + '/.config'): |
| self.print('Warning: -ef_format used in apparently non-efabless setup.') |
| |
| # Check for project.json |
| |
| jsonname = None |
| if os.path.isfile(projectpath + '/project.json'): |
| jsonname = projectpath + '/project.json' |
| elif os.path.isfile(projectroot + '/' + projectdirname + '.json'): |
| jsonname = projectroot + '/' + projectdirname + '.json' |
| if os.path.isfile(projectroot + '/project.json'): |
| # Just in case this was started from some other subdirectory |
| projectpath = projectroot |
| jsonname = projectroot + '/project.json' |
| |
| if jsonname: |
| self.print('Reading project JSON file ' + jsonname) |
| with open(jsonname, 'r') as ifile: |
| topdata = json.load(ifile) |
| if 'data-sheet' in topdata: |
| dsheet = topdata['data-sheet'] |
| if 'ip-name' in dsheet: |
| self.project = dsheet['ip-name'] |
| self.projectpath = projectpath |
| else: |
| self.print('No project JSON file; using directory name as the project name.') |
| self.project = os.path.split(projectpath)[1] |
| self.projectpath = projectpath |
| |
| self.print('Project name is ' + self.project + ' (' + self.projectpath + ')') |
| |
| # Functions for drag-and-drop capability |
| def add_draggable(self, tag): |
| self.canvas.tag_bind(tag, '<ButtonPress-1>', self.on_button_press) |
| self.canvas.tag_bind(tag, '<ButtonRelease-1>', self.on_button_release) |
| self.canvas.tag_bind(tag, '<B1-Motion>', self.on_button_motion) |
| self.canvas.tag_bind(tag, '<ButtonPress-2>', self.on_button2_press) |
| self.canvas.tag_bind(tag, '<ButtonPress-3>', self.on_button3_press) |
| |
| def on_button_press(self, event): |
| '''Begining drag of an object''' |
| # Find the closest item, then record its tag. |
| locx = event.x + self.canvas.canvasx(0) |
| locy = event.y + self.canvas.canvasy(0) |
| item = self.canvas.find_closest(locx, locy)[0] |
| self.event_data['tag'] = self.canvas.gettags(item)[0] |
| self.event_data['x0'] = event.x |
| self.event_data['y0'] = event.y |
| self.event_data['x'] = event.x |
| self.event_data['y'] = event.y |
| |
| def on_button2_press(self, event): |
| '''Flip an object (excluding corners)''' |
| locx = event.x + self.canvas.canvasx(0) |
| locy = event.y + self.canvas.canvasy(0) |
| item = self.canvas.find_closest(locx, locy)[0] |
| tag = self.canvas.gettags(item)[0] |
| |
| try: |
| corecell = next(item for item in self.coregroup if item['name'] == tag) |
| except: |
| try: |
| pad = next(item for item in self.Npads if item['name'] == tag) |
| except: |
| pad = None |
| if not pad: |
| try: |
| pad = next(item for item in self.Epads if item['name'] == tag) |
| except: |
| pad = None |
| if not pad: |
| try: |
| pad = next(item for item in self.Spads if item['name'] == tag) |
| except: |
| pad = None |
| if not pad: |
| try: |
| pad = next(item for item in self.Wpads if item['name'] == tag) |
| except: |
| pad = None |
| if not pad: |
| self.print('Error: Object cannot be flipped.') |
| else: |
| # Flip the pad (in the only way meaningful for the pad). |
| orient = pad['o'] |
| if orient == 'N': |
| pad['o'] = 'FN' |
| elif orient == 'E': |
| pad['o'] = 'FW' |
| elif orient == 'S': |
| pad['o'] = 'FS' |
| elif orient == 'W': |
| pad['o'] = 'FE' |
| elif orient == 'FN': |
| pad['o'] = 'N' |
| elif orient == 'FE': |
| pad['o'] = 'W' |
| elif orient == 'FS': |
| pad['o'] = 'S' |
| elif orient == 'FW': |
| pad['o'] = 'E' |
| else: |
| # Flip the cell. Use the DEF meaning of flip, which is to |
| # add or subtract 'F' from the orientation. |
| orient = corecell['o'] |
| if not 'F' in orient: |
| corecell['o'] = 'F' + orient |
| else: |
| corecell['o'] = orient[1:] |
| |
| # Redraw |
| self.populate(0) |
| |
| def on_button3_press(self, event): |
| '''Rotate a core object (no pads) ''' |
| locx = event.x + self.canvas.canvasx(0) |
| locy = event.y + self.canvas.canvasy(0) |
| item = self.canvas.find_closest(locx, locy)[0] |
| tag = self.canvas.gettags(item)[0] |
| |
| try: |
| corecell = next(item for item in self.coregroup if item['name'] == tag) |
| except: |
| self.print('Error: Object cannot be rotated.') |
| else: |
| # Modify its orientation |
| orient = corecell['o'] |
| if orient == 'N': |
| corecell['o'] = 'E' |
| elif orient == 'E': |
| corecell['o'] = 'S' |
| elif orient == 'S': |
| corecell['o'] = 'W' |
| elif orient == 'W': |
| corecell['o'] = 'N' |
| elif orient == 'FN': |
| corecell['o'] = 'FW' |
| elif orient == 'FW': |
| corecell['o'] = 'FS' |
| elif orient == 'FS': |
| corecell['o'] = 'FE' |
| elif orient == 'FE': |
| corecell['o'] = 'FN' |
| |
| # rewrite the core DEF file |
| self.write_core_def() |
| |
| # Redraw |
| self.populate(0) |
| |
| def on_button_motion(self, event): |
| '''Handle dragging of an object''' |
| # compute how much the mouse has moved |
| delta_x = event.x - self.event_data['x'] |
| delta_y = event.y - self.event_data['y'] |
| # move the object the appropriate amount |
| self.canvas.move(self.event_data['tag'], delta_x, delta_y) |
| # record the new position |
| self.event_data['x'] = event.x |
| self.event_data['y'] = event.y |
| |
| def on_button_release(self, event): |
| '''End drag of an object''' |
| |
| # Find the pad associated with the tag and update its position information |
| tag = self.event_data['tag'] |
| |
| # Collect pads in clockwise order. Note that E and S rows are not clockwise |
| allpads = [] |
| allpads.extend(self.Npads) |
| allpads.extend(self.NEpad) |
| allpads.extend(reversed(self.Epads)) |
| allpads.extend(self.SEpad) |
| allpads.extend(reversed(self.Spads)) |
| allpads.extend(self.SWpad) |
| allpads.extend(self.Wpads) |
| allpads.extend(self.NWpad) |
| |
| # Create a list of row references (also in clockwise order, but no reversing) |
| padrows = [self.Npads, self.NEpad, self.Epads, self.SEpad, self.Spads, self.SWpad, self.Wpads, self.NWpad] |
| |
| # Record the row or corner where this pad was located before the move |
| for row in padrows: |
| try: |
| pad = next(item for item in row if item['name'] == tag) |
| except: |
| pass |
| else: |
| padrow = row |
| break |
| |
| # Currently there is no procedure to move a pad out of the corner |
| # position; corners are fixed by definition. |
| if padrow == self.NEpad or padrow == self.SEpad or padrow == self.SWpad or padrow == self.NWpad: |
| # Easier to run generate() than to put the pad back. . . |
| self.generate() |
| return |
| |
| # Find the original center point of the pad being moved |
| |
| padllx = pad['x'] |
| padlly = pad['y'] |
| if pad['o'] == 'N' or pad['o'] == 'S': |
| padurx = padllx + pad['width'] |
| padury = padlly + pad['height'] |
| else: |
| padurx = padllx + pad['height'] |
| padury = padlly + pad['width'] |
| padcx = (padllx + padurx) / 2 |
| padcy = (padlly + padury) / 2 |
| |
| # Add distance from drag information (note that drag position in y |
| # is negative relative to the chip dimensions) |
| padcx += (self.event_data['x'] - self.event_data['x0']) / self.scale |
| padcy -= (self.event_data['y'] - self.event_data['y0']) / self.scale |
| |
| # reset the drag information |
| self.event_data['tag'] = None |
| self.event_data['x'] = 0 |
| self.event_data['y'] = 0 |
| self.event_data['x0'] = 0 |
| self.event_data['y0'] = 0 |
| |
| # Find the distance from the pad to all other pads, and get the two |
| # closest entries. |
| |
| wwidth = self.urx - self.llx |
| dist0 = wwidth |
| dist1 = wwidth |
| pad0 = None |
| pad1 = None |
| |
| for npad in allpads: |
| if npad == pad: |
| continue |
| |
| npadllx = npad['x'] |
| npadlly = npad['y'] |
| if npad['o'] == 'N' or npad['o'] == 'S': |
| npadurx = npadllx + npad['width'] |
| npadury = npadlly + npad['height'] |
| else: |
| npadurx = npadllx + npad['height'] |
| npadury = npadlly + npad['width'] |
| npadcx = (npadllx + npadurx) / 2 |
| npadcy = (npadlly + npadury) / 2 |
| |
| deltx = npadcx - padcx |
| delty = npadcy - padcy |
| pdist = math.sqrt(deltx * deltx + delty * delty) |
| if pdist < dist0: |
| dist1 = dist0 |
| pad1 = pad0 |
| dist0 = pdist |
| pad0 = npad |
| |
| elif pdist < dist1: |
| dist1 = pdist |
| pad1 = npad |
| |
| # Diagnostic |
| # self.print('Two closest pads to pad ' + pad['name'] + ' (' + pad['cell'] + '): ') |
| # self.print(pad0['name'] + ' (' + pad0['cell'] + ') dist = ' + str(dist0)) |
| # self.print(pad1['name'] + ' (' + pad1['cell'] + ') dist = ' + str(dist1)) |
| |
| # Record the row or corner where these pads are |
| for row in padrows: |
| try: |
| testpad = next(item for item in row if item['name'] == pad0['name']) |
| except: |
| pass |
| else: |
| padrow0 = row |
| break |
| |
| for row in padrows: |
| try: |
| testpad = next(item for item in row if item['name'] == pad1['name']) |
| except: |
| pass |
| else: |
| padrow1 = row |
| break |
| |
| # Remove pad from its own row |
| padrow.remove(pad) |
| |
| # Insert pad into new row. Watch for wraparound from the last entry to the first |
| padidx0 = allpads.index(pad0) |
| padidx1 = allpads.index(pad1) |
| if padidx0 == 0 and padidx1 > 2: |
| padidx1 = -1 |
| |
| if padidx1 > padidx0: |
| padafter = pad1 |
| rowafter = padrow1 |
| padbefore = pad0 |
| rowbefore = padrow0 |
| else: |
| padafter = pad0 |
| rowafter = padrow0 |
| padbefore = pad1 |
| rowbefore = padrow1 |
| |
| # Do not replace corner positions (? may be necessary ?) |
| if rowafter == self.NWpad: |
| self.Wpads.append(pad) |
| elif rowafter == self.NWpad: |
| self.Npads.append(pad) |
| elif rowafter == self.SEpad: |
| self.Epads.insert(0, pad) |
| elif rowafter == self.SWpad: |
| self.Spads.insert(0, pad) |
| elif rowafter == self.Wpads or rowafter == self.Npads: |
| idx = rowafter.index(padafter) |
| rowafter.insert(idx, pad) |
| elif rowbefore == self.NEpad: |
| self.Epads.append(pad) |
| elif rowbefore == self.SEpad: |
| self.Spads.append(pad) |
| else: |
| # rows E and S are ordered counterclockwise |
| idx = rowbefore.index(padbefore) |
| rowbefore.insert(idx, pad) |
| |
| # Re-run padring |
| self.generate() |
| |
| def on_scrollwheel(self, event): |
| if event.num == 4: |
| zoomval = 1.1; |
| elif event.num == 5: |
| zoomval = 0.9; |
| else: |
| zoomval = 1.0; |
| |
| self.scale *= zoomval |
| self.canvas.scale('all', -15 * zoomval, -15 * zoomval, zoomval, zoomval) |
| self.event_data['x'] *= zoomval |
| self.event_data['y'] *= zoomval |
| self.event_data['x0'] *= zoomval |
| self.event_data['y0'] *= zoomval |
| self.frame_configure(event) |
| |
| # Callback functions similar to the pad event callbacks above, but for |
| # core cells. Unlike pad cells, core cells can be rotated and flipped |
| # arbitrarily, and they do not force a recomputation of the padframe |
| # unless their position forces the padframe to expand |
| |
| def add_core_draggable(self, tag): |
| self.canvas.tag_bind(tag, '<ButtonPress-1>', self.on_button_press) |
| self.canvas.tag_bind(tag, '<ButtonRelease-1>', self.core_on_button_release) |
| self.canvas.tag_bind(tag, '<B1-Motion>', self.on_button_motion) |
| self.canvas.tag_bind(tag, '<ButtonPress-2>', self.on_button2_press) |
| self.canvas.tag_bind(tag, '<ButtonPress-3>', self.on_button3_press) |
| |
| def core_on_button_release(self, event): |
| '''End drag of a core cell''' |
| |
| # Find the pad associated with the tag and update its position information |
| tag = self.event_data['tag'] |
| |
| try: |
| corecell = next(item for item in self.coregroup if item['name'] == tag) |
| except: |
| self.print('Error: cell ' + item['name'] + ' is not in coregroup!') |
| else: |
| # Modify its position values |
| corex = corecell['x'] |
| corey = corecell['y'] |
| |
| # Add distance from drag information (note that drag position in y |
| # is negative relative to the chip dimensions) |
| deltax = (self.event_data['x'] - self.event_data['x0']) / self.scale |
| deltay = (self.event_data['y'] - self.event_data['y0']) / self.scale |
| |
| corecell['x'] = corex + deltax |
| corecell['y'] = corey - deltay |
| |
| # rewrite the core DEF file |
| self.write_core_def() |
| |
| # reset the drag information |
| self.event_data['tag'] = None |
| self.event_data['x'] = 0 |
| self.event_data['y'] = 0 |
| self.event_data['x0'] = 0 |
| self.event_data['y0'] = 0 |
| |
| # Critically needed or else frame does not resize to scrollbars! |
| def grid_configure(self, padx, pady): |
| pass |
| |
| # Redraw the chip frame view in response to changes in the pad list |
| def redraw_frame(self): |
| self.canvas.coords('boundary', self.llx, self.urx, self.lly, self.ury) |
| |
| # Update the canvas scrollregion to incorporate all the interior windows |
| def frame_configure(self, event): |
| if self.do_gui == False: |
| return |
| self.update_idletasks() |
| bbox = self.canvas.bbox("all") |
| try: |
| newbbox = (-15, -15, bbox[2] + 15, bbox[3] + 15) |
| except: |
| pass |
| else: |
| self.canvas.configure(scrollregion = newbbox) |
| |
| # Fill the GUI entries with resident data |
| def populate(self, level): |
| if self.do_gui == False: |
| return |
| |
| if level > 1: |
| self.print('Recursion error: Returning now.') |
| return |
| |
| self.print('Populating floorplan view.') |
| |
| # Remove all entries from the canvas |
| self.canvas.delete('all') |
| |
| allpads = self.Npads + self.NEpad + self.Epads + self.SEpad + self.Spads + self.SWpad + self.Wpads + self.NWpad |
| |
| notfoundlist = [] |
| |
| for pad in allpads: |
| if 'x' not in pad: |
| self.print('Error: Pad ' + pad['name'] + ' has no placement information.') |
| continue |
| llx = int(pad['x']) |
| lly = int(pad['y']) |
| pado = pad['o'] |
| try: |
| padcell = next(item for item in self.celldefs if item['name'] == pad['cell']) |
| except: |
| # This should not happen (failsafe) |
| if pad['cell'] not in notfoundlist: |
| self.print('Warning: there is no cell named ' + pad['cell'] + ' in the libraries.') |
| notfoundlist.append(pad['cell']) |
| continue |
| padw = padcell['width'] |
| padh = padcell['height'] |
| if 'N' in pado or 'S' in pado: |
| urx = int(llx + padw) |
| ury = int(lly + padh) |
| else: |
| urx = int(llx + padh) |
| ury = int(lly + padw) |
| |
| pad['llx'] = llx |
| pad['lly'] = lly |
| pad['urx'] = urx |
| pad['ury'] = ury |
| |
| # Note that the DEF coordinate system is reversed in Y from the canvas. . . |
| |
| height = self.ury - self.lly |
| for pad in allpads: |
| |
| llx = pad['llx'] |
| lly = height - pad['lly'] |
| urx = pad['urx'] |
| ury = height - pad['ury'] |
| |
| tag_id = pad['name'] |
| if 'subclass' in pad: |
| if pad['subclass'] == 'POWER': |
| pad_color = 'orange2' |
| elif pad['subclass'] == 'INOUT': |
| pad_color = 'yellow' |
| elif pad['subclass'] == 'OUTPUT': |
| pad_color = 'powder blue' |
| elif pad['subclass'] == 'INPUT': |
| pad_color = 'goldenrod1' |
| elif pad['subclass'] == 'SPACER': |
| pad_color = 'green yellow' |
| elif pad['class'] == 'ENDCAP': |
| pad_color = 'green yellow' |
| elif pad['subclass'] == '' or pad['class'] == ';': |
| pad_color = 'khaki1' |
| else: |
| self.print('Unhandled pad class ' + pad['class']) |
| pad_color = 'gray' |
| else: |
| pad_color = 'gray' |
| |
| sllx = self.scale * llx |
| slly = self.scale * lly |
| surx = self.scale * urx |
| sury = self.scale * ury |
| |
| self.canvas.create_rectangle((sllx, slly), (surx, sury), fill=pad_color, tags=[tag_id]) |
| cx = (sllx + surx) / 2 |
| cy = (slly + sury) / 2 |
| |
| s = 10 if pad['width'] >= 10 else pad['width'] |
| if pad['height'] < s: |
| s = pad['height'] |
| |
| # Create an indicator line at the bottom left corner of the cell |
| if pad['o'] == 'N': |
| allx = sllx |
| ally = slly - s |
| aurx = sllx + s |
| aury = slly |
| elif pad['o'] == 'E': |
| allx = sllx |
| ally = sury + s |
| aurx = sllx + s |
| aury = sury |
| elif pad['o'] == 'S': |
| allx = surx |
| ally = sury + s |
| aurx = surx - s |
| aury = sury |
| elif pad['o'] == 'W': |
| allx = surx |
| ally = slly - s |
| aurx = surx - s |
| aury = slly |
| elif pad['o'] == 'FN': |
| allx = surx |
| ally = slly - s |
| aurx = surx - s |
| aury = slly |
| elif pad['o'] == 'FE': |
| allx = surx |
| ally = sury + s |
| aurx = surx - s |
| aury = sury |
| elif pad['o'] == 'FS': |
| allx = sllx |
| ally = sury + s |
| aurx = sllx + s |
| aury = sury |
| elif pad['o'] == 'FW': |
| allx = sllx |
| ally = slly - s |
| aurx = sllx + s |
| aury = slly |
| self.canvas.create_line((allx, ally), (aurx, aury), tags=[tag_id]) |
| |
| # Rotate text on top and bottom rows if the tkinter version allows it. |
| if tkinter.TclVersion >= 8.6: |
| if pad['o'] == 'N' or pad['o'] == 'S': |
| angle = 90 |
| else: |
| angle = 0 |
| self.canvas.create_text((cx, cy), text=pad['name'], angle=angle, tags=[tag_id]) |
| else: |
| self.canvas.create_text((cx, cy), text=pad['name'], tags=[tag_id]) |
| |
| # Make the pad draggable |
| self.add_draggable(tag_id) |
| |
| # Now add the core cells |
| for cell in self.coregroup: |
| if 'x' not in cell: |
| self.print('Error: Core cell ' + cell['name'] + ' has no placement information.') |
| continue |
| # else: |
| # self.print('Diagnostic: Creating object for core cell ' + cell['name']) |
| llx = int(cell['x']) |
| lly = int(cell['y']) |
| cello = cell['o'] |
| try: |
| corecell = next(item for item in self.coredefs if item['name'] == cell['cell']) |
| except: |
| # This should not happen (failsafe) |
| if cell['cell'] not in notfoundlist: |
| self.print('Warning: there is no cell named ' + cell['cell'] + ' in the libraries.') |
| notfoundlist.append(cell['cell']) |
| continue |
| cellw = corecell['width'] |
| cellh = corecell['height'] |
| if 'N' in cello or 'S' in cello: |
| urx = int(llx + cellw) |
| ury = int(lly + cellh) |
| else: |
| urx = int(llx + cellh) |
| ury = int(lly + cellw) |
| print('NOTE: cell ' + corecell['name'] + ' is rotated, w = ' + str(urx - llx) + '; h = ' + str(ury - lly)) |
| |
| cell['llx'] = llx |
| cell['lly'] = lly |
| cell['urx'] = urx |
| cell['ury'] = ury |
| |
| # Watch for out-of-window position in core cells. |
| corellx = self.llx |
| corelly = self.lly |
| coreurx = self.urx |
| coreury = self.ury |
| |
| for cell in self.coregroup: |
| |
| if 'llx' not in cell: |
| # Error message for this was handled above |
| continue |
| |
| llx = cell['llx'] |
| lly = height - cell['lly'] |
| urx = cell['urx'] |
| ury = height - cell['ury'] |
| |
| # Check for out-of-window cell |
| if llx < corellx: |
| corellx = llx |
| if lly < corelly: |
| corelly = lly |
| if urx > coreurx: |
| coreurx = urx |
| if ury > coreury: |
| coreury = ury |
| |
| tag_id = cell['name'] |
| cell_color = 'gray40' |
| |
| sllx = self.scale * llx |
| slly = self.scale * lly |
| surx = self.scale * urx |
| sury = self.scale * ury |
| |
| self.canvas.create_rectangle((sllx, slly), (surx, sury), fill=cell_color, tags=[tag_id]) |
| cx = (sllx + surx) / 2 |
| cy = (slly + sury) / 2 |
| |
| s = 10 if cell['width'] >= 10 else cell['width'] |
| if cell['height'] < s: |
| s = cell['height'] |
| |
| # Create an indicator line at the bottom left corner of the cell |
| if cell['o'] == 'N': |
| allx = sllx |
| ally = slly - s |
| aurx = sllx + s |
| aury = slly |
| elif cell['o'] == 'E': |
| allx = sllx |
| ally = sury + s |
| aurx = sllx + s |
| aury = sury |
| elif cell['o'] == 'S': |
| allx = surx |
| ally = sury + s |
| aurx = surx - s |
| aury = sury |
| elif cell['o'] == 'W': |
| allx = surx |
| ally = slly - s |
| aurx = surx - s |
| aury = slly |
| elif cell['o'] == 'FN': |
| allx = surx |
| ally = slly - s |
| aurx = surx - s |
| aury = slly |
| elif cell['o'] == 'FE': |
| allx = surx |
| ally = sury + s |
| aurx = surx - s |
| aury = sury |
| elif cell['o'] == 'FS': |
| allx = sllx |
| ally = sury + s |
| aurx = sllx + s |
| aury = sury |
| elif cell['o'] == 'FW': |
| allx = sllx |
| ally = slly - s |
| aurx = sllx + s |
| aury = slly |
| self.canvas.create_line((allx, ally), (aurx, aury), tags=[tag_id]) |
| |
| # self.print('Created entry for cell ' + cell['name'] + ' at {0:g}, {1:g}'.format(cx, cy)) |
| |
| # Rotate text on top and bottom rows if the tkinter version allows it. |
| if tkinter.TclVersion >= 8.6: |
| if 'N' in cell['o'] or 'S' in cell['o']: |
| angle = 90 |
| else: |
| angle = 0 |
| self.canvas.create_text((cx, cy), text=cell['name'], angle=angle, tags=[tag_id]) |
| else: |
| self.canvas.create_text((cx, cy), text=cell['name'], tags=[tag_id]) |
| |
| # Make the core cell draggable |
| self.add_core_draggable(tag_id) |
| |
| # Is there a boundary size defined? |
| if self.urx > self.llx and self.ury > self.lly: |
| self.create_boundary() |
| |
| # Did the core extend into negative X or Y? If so, adjust all canvas |
| # coordinates to fit in the window, or else objects cannot be reached |
| # even by zooming out (since zooming is pinned on the top corner). |
| |
| offsetx = 0 |
| offsety = 0 |
| |
| # NOTE: Probably want to check if the core exceeds the inner |
| # dimension of the pad ring, not the outer (to check and to do). |
| |
| if corellx < self.llx: |
| offsetx = self.llx - corellx |
| if corelly < self.lly: |
| offsety = self.lly - corelly |
| if offsetx > 0 or offsety > 0: |
| self.canvas.move("all", offsetx, offsety) |
| # An offset implies that the chip is core limited, and the |
| # padframe requires additional space. This can be accomplished |
| # simply by running "Generate". NOTE: Since generate() calls |
| # populate(), be VERY SURE that this does not infinitely recurse! |
| self.generate(level) |
| |
| # Generate a DEF file of the core area |
| |
| def write_core_def(self): |
| self.print('Writing core placementment information in DEF file "core.def".') |
| |
| mag_path = self.projectpath + '/mag' |
| |
| # The core cells must always clear the I/O pads on the left and |
| # bottom (with the ad-hoc margin of self.margin). If core cells have |
| # been moved to the left or down past the padframe edge, then the |
| # entire core needs to be repositioned. |
| |
| # To be done: draw a boundary around the core, let the edges of that |
| # boundary be draggable, and let the difference between the boundary |
| # and the core area define the margin. |
| |
| if self.SWpad != []: |
| corellx = self.SWpad[0]['x'] + self.SWpad[0]['width'] + self.margin |
| corelly = self.SWpad[0]['y'] + self.SWpad[0]['height'] + self.margin |
| else: |
| corellx = self.Wpads[0]['x'] + self.Wpads[0]['height'] + self.margin |
| corelly = self.Spads[0]['x'] + self.Spads[0]['height'] + self.margin |
| |
| offsetx = 0 |
| offsety = 0 |
| for corecell in self.coregroup: |
| if corecell['x'] < corellx: |
| if corellx - corecell['x'] > offsetx: |
| offsetx = corellx - corecell['x'] |
| if corecell['y'] < corelly: |
| if corelly - corecell['y'] > offsety: |
| offsety = corelly - corecell['y'] |
| if offsetx > 0 or offsety > 0: |
| for corecell in self.coregroup: |
| corecell['x'] += offsetx |
| corecell['y'] += offsety |
| |
| # Now write the core DEF file |
| |
| with open(mag_path + '/core.def', 'w') as ofile: |
| print('DESIGN CORE ;', file=ofile) |
| print('UNITS DISTANCE MICRONS 1000 ;', file=ofile) |
| print('COMPONENTS {0:d} ;'.format(len(self.coregroup)), file=ofile) |
| for corecell in self.coregroup: |
| print(' - ' + corecell['name'] + ' ' + corecell['cell'], file=ofile) |
| print(' + PLACED ( {0:d} {1:d} ) {2:s} ;'.format(int(corecell['x'] * 1000), int(corecell['y'] * 1000), corecell['o']), file=ofile) |
| print ('END COMPONENTS', file=ofile) |
| print ('END DESIGN', file=ofile) |
| |
| # Create the chip boundary area |
| |
| def create_boundary(self): |
| scale = self.scale |
| llx = (self.llx - 10) * scale |
| lly = (self.lly - 10) * scale |
| urx = (self.urx + 10) * scale |
| ury = (self.ury + 10) * scale |
| |
| pad_color = 'plum1' |
| tag_id = 'boundary' |
| self.canvas.create_rectangle((llx, lly), (urx, ury), outline=pad_color, width=2, tags=[tag_id]) |
| # Add text to the middle representing the chip and core areas |
| cx = ((self.llx + self.urx) / 2) * scale |
| cy = ((self.lly + self.ury) / 2) * scale |
| width = self.urx - self.llx |
| height = self.ury - self.lly |
| areatext = 'Chip dimensions (um): {0:g} x {1:g}'.format(width, height) |
| tag_id = 'chiparea' |
| self.canvas.create_text((cx, cy), text=areatext, tags=[tag_id]) |
| |
| # Rotate orientation according to self.pad_rotation. |
| |
| def rotate_orientation(self, orient_in): |
| orient_v = ['N', 'E', 'S', 'W', 'N', 'E', 'S', 'W'] |
| idxadd = int(self.pad_rotation / 90) |
| idx = orient_v.index(orient_in) |
| return orient_v[idx + idxadd] |
| |
| # Read a list of cell macros (name, size, class) from a LEF library |
| |
| def read_lef_macros(self, libpath, libname = None, libtype = 'iolib'): |
| if libtype == 'iolib': |
| libtext = 'I/O ' |
| elif libtype == 'celllib': |
| libtext = 'core ' |
| else: |
| libtext = '' |
| |
| macros = [] |
| |
| if libname: |
| if os.path.splitext(libname)[1] == '': |
| libname += '.lef' |
| leffiles = glob.glob(libpath + '/' + libname) |
| else: |
| leffiles = glob.glob(libpath + '/*.lef') |
| if leffiles == []: |
| if libname: |
| self.print('WARNING: No file ' + libpath + '/' + libname + '.lef') |
| else: |
| self.print('WARNING: No files ' + libpath + '/*.lef') |
| for leffile in leffiles: |
| libpath = os.path.split(leffile)[0] |
| libname = os.path.split(libpath)[1] |
| self.print('Reading LEF ' + libtext + 'library ' + leffile) |
| with open(leffile, 'r') as ifile: |
| ilines = ifile.read().splitlines() |
| in_macro = False |
| for iline in ilines: |
| iparse = iline.split() |
| if iparse == []: |
| continue |
| elif iparse[0] == 'MACRO': |
| in_macro = True |
| newmacro = {} |
| newmacro['name'] = iparse[1] |
| newmacro[libtype] = leffile |
| macros.append(newmacro) |
| elif in_macro: |
| if iparse[0] == 'END': |
| if len(iparse) > 1 and iparse[1] == newmacro['name']: |
| in_macro = False |
| elif iparse[0] == 'CLASS': |
| newmacro['class'] = iparse[1] |
| if len(iparse) > 2: |
| newmacro['subclass'] = iparse[2] |
| |
| # Use the 'ENDCAP' class to identify pad rotations |
| # other than BOTTOMLEFT. This is somewhat ad-hoc |
| # depending on the foundry; may not be generally |
| # applicable. |
| |
| if newmacro['class'] == 'ENDCAP': |
| if newmacro['subclass'] == 'TOPLEFT': |
| self.pad_rotation = 90 |
| elif newmacro['subclass'] == 'TOPRIGHT': |
| self.pad_rotation = 180 |
| elif newmacro['subclass'] == 'BOTTOMRIGHT': |
| self.pad_rotation = 270 |
| else: |
| newmacro['subclass'] = None |
| elif iparse[0] == 'SIZE': |
| newmacro['width'] = float(iparse[1]) |
| newmacro['height'] = float(iparse[3]) |
| elif iparse[0] == 'ORIGIN': |
| newmacro['x'] = float(iparse[1]) |
| newmacro['y'] = float(iparse[2]) |
| return macros |
| |
| # Read a list of cell names from a verilog file |
| # If filename is relative, then check in the same directory as the verilog |
| # top-level netlist (vlogpath) and in the subdirectory 'source/' of the top- |
| # level directory. Also check in the ~/design/ip/ directory. These are |
| # common include paths for the simulation. |
| |
| def read_verilog_lib(self, incpath, vlogpath): |
| iocells = [] |
| if not os.path.isfile(incpath) and incpath[0] != '/': |
| locincpath = vlogpath + '/' + incpath |
| if not os.path.isfile(locincpath): |
| locincpath = vlogpath + '/source/' + incpath |
| if not os.path.isfile(locincpath): |
| projectpath = os.path.split(vlogpath)[0] |
| designpath = os.path.split(projectpath)[0] |
| locincpath = designpath + '/ip/' + incpath |
| else: |
| locincpath = incpath |
| |
| if not os.path.isfile(locincpath): |
| self.print('File ' + incpath + ' not found (at ' + locincpath + ')!') |
| else: |
| self.print('Reading verilog library ' + locincpath) |
| with open(locincpath, 'r') as ifile: |
| ilines = ifile.read().splitlines() |
| for iline in ilines: |
| iparse = re.split('[\t ()]', iline) |
| while '' in iparse: |
| iparse.remove('') |
| if iparse == []: |
| continue |
| elif iparse[0] == 'module': |
| iocells.append(iparse[1]) |
| return iocells |
| |
| # Generate a LEF abstract view from a magic layout. If "outpath" is not |
| # "None", then write output to outputpath (this is required if the input |
| # file is in a read-only directory). |
| |
| def write_lef_file(self, magfile, outpath=None): |
| mag_path = os.path.split(magfile)[0] |
| magfullname = os.path.split(magfile)[1] |
| module = os.path.splitext(magfullname)[0] |
| |
| if outpath: |
| write_path = outpath |
| else: |
| write_path = mag_path |
| |
| self.print('Generating LEF view from layout for module ' + module) |
| |
| with open(write_path + '/pfg_write_lef.tcl', 'w') as ofile: |
| print('drc off', file=ofile) |
| print('box 0 0 0 0', file=ofile) |
| # NOTE: Using "-force" option in case an IP with a different but |
| # compatible tech is used (e.g., EFHX035A IP inside EFXH035C). This |
| # is not checked for legality! |
| if outpath: |
| print('load ' + magfile + ' -force', file=ofile) |
| else: |
| print('load ' + module + ' -force', file=ofile) |
| print('select top cell', file=ofile) |
| print('lef write -hide', file=ofile) |
| print('quit', file=ofile) |
| |
| magicexec = self.magic_path if self.magic_path else 'magic' |
| mproc = subprocess.Popen([magicexec, '-dnull', '-noconsole', |
| 'pfg_write_lef.tcl'], |
| stdin = subprocess.PIPE, stdout = subprocess.PIPE, |
| stderr = subprocess.PIPE, cwd = write_path, universal_newlines = True) |
| |
| self.watch(mproc) |
| os.remove(write_path + '/pfg_write_lef.tcl') |
| |
| # Watch a running process, polling for output and updating the GUI message |
| # window as output arrives. Return only when the process has exited. |
| # Note that this process cannot handle stdin(), so any input to the process |
| # must be passed from a file. |
| |
| def watch(self, process): |
| if process == None: |
| return |
| |
| while True: |
| status = process.poll() |
| if status != None: |
| try: |
| outputpair = process.communicate(timeout=1) |
| except ValueError: |
| self.print("Process forced stop, status " + str(status)) |
| else: |
| for line in outputpair[0].splitlines(): |
| self.print(line) |
| for line in outputpair[1].splitlines(): |
| self.print(line, file=sys.stderr) |
| break |
| else: |
| sresult = select.select([process.stdout, process.stderr], [], [], 0)[0] |
| if process.stdout in sresult: |
| outputline = process.stdout.readline().strip() |
| self.print(outputline) |
| elif process.stderr in sresult: |
| outputline = process.stderr.readline().strip() |
| self.print(outputline, file=sys.stderr) |
| else: |
| self.update_idletasks() |
| |
| # Reimport the pad list by reading the top-level verilog netlist. Determine |
| # what pads are listed in the file, and check against the existing pad list. |
| |
| # The verilog/ directory should have a .v file containing a module of the |
| # same name as self.project (ip-name). The .v filename should have the |
| # same name as well (but not necessarily). To do: Handle import of |
| # projects having a top-level schematic instead of a verilog netlist. |
| |
| def vlogimport(self): |
| |
| if self.ef_format: |
| config_dir = '/.ef-config' |
| else: |
| config_dir = '/.config' |
| |
| # First find the process PDK name for this project. Read the nodeinfo.json |
| # file and find the list of I/O cell libraries. |
| |
| if self.techpath: |
| pdkpath = self.techpath |
| elif os.path.islink(self.projectpath + config_dir + '/techdir'): |
| pdkpath = os.path.realpath(self.projectpath + config_dir + '/techdir') |
| else: |
| self.print('Error: Cannot determine path to PDK. Try using option -tech-path=') |
| return |
| |
| self.print('Importing verilog sources.') |
| |
| nodeinfopath = pdkpath + config_dir + '/nodeinfo.json' |
| ioleflist = [] |
| if os.path.exists(nodeinfopath): |
| self.print('Reading known I/O cell libraries from ' + nodeinfopath) |
| with open(nodeinfopath, 'r') as ifile: |
| itop = json.load(ifile) |
| if 'iocells' in itop: |
| ioleflist = [] |
| for iolib in itop['iocells']: |
| if '/' in iolib: |
| # Entries <lib>/<cell> refer to specific files |
| if self.ef_format: |
| iolibpath = pdkpath + '/libs.ref/lef/' + iolib |
| else: |
| iolibpath = pdkpath + '/libs.ref/' + iolib |
| if os.path.splitext(iolib)[1] == '': |
| if not os.path.exists(iolibpath): |
| iolibpath = iolibpath + '.lib' |
| if not os.path.exists(iolibpath): |
| self.print('Warning: nodeinfo.json bad I/O library path ' + iolibpath) |
| ioleflist.append(iolibpath) |
| else: |
| # All other entries refer to everything in the directory. |
| if self.ef_format: |
| iolibpath = pdkpath + '/libs.ref/lef/' + iolib |
| else: |
| iolibpath = pdkpath + '/libs.ref/' + iolib + '/lef/' |
| iolibfiles = glob.glob(iolibpath + '/*.lef') |
| if len(iolibfiles) == 0: |
| self.print('Warning: nodeinfo.json bad I/O library path ' + iolibpath) |
| ioleflist.extend(iolibfiles) |
| else: |
| # Diagnostic |
| self.print('Cannot read PDK information file ' + nodeinfopath) |
| |
| # Fallback behavior: List everything in libs.ref/lef/ beginning with "IO" |
| if len(ioleflist) == 0: |
| if self.ef_format: |
| ioleflist = glob.glob(pdkpath + '/libs.ref/lef/IO*/*.lef') |
| else: |
| ioleflist = glob.glob(pdkpath + '/libs.ref/IO*/lef/*.lef') |
| |
| if len(ioleflist) == 0: |
| self.print('Cannot find any I/O cell libraries for this technology') |
| return |
| |
| # Read the LEF libraries to get a list of all available cells. Keep |
| # this list of cells in "celldefs". |
| |
| celldefs = [] |
| ioliblist = [] |
| ioleflibs = [] |
| for iolib in ioleflist: |
| iolibpath = os.path.split(iolib)[0] |
| iolibfile = os.path.split(iolib)[1] |
| ioliblist.append(os.path.split(iolibpath)[1]) |
| celldefs.extend(self.read_lef_macros(iolibpath, iolibfile, 'iolib')) |
| |
| verilogcells = [] |
| newpadlist = [] |
| coredefs = [] |
| corecells = [] |
| corecelllist = [] |
| lefprocessed = [] |
| |
| busrex = re.compile('.*\[[ \t]*([0-9]+)[ \t]*:[ \t]*([0-9]+)[ \t]*\]') |
| |
| vlogpath = self.projectpath + '/verilog' |
| vlogfile = vlogpath + '/' + self.project + '.v' |
| |
| # Verilog netlists are too difficult to parse from a simple script. |
| # Use qflow tools to convert to SPICE, if they are available. Parse |
| # the verilog only for "include" statements to find the origin of |
| # the various IP blocks, and then parse the SPICE file to get the |
| # full list of instances. |
| # |
| # (to be done) |
| |
| if os.path.isfile(vlogfile): |
| with open(vlogfile, 'r') as ifile: |
| vloglines = ifile.read().splitlines() |
| for vlogline in vloglines: |
| vlogparse = re.split('[\t ()]', vlogline) |
| while '' in vlogparse: |
| vlogparse.remove('') |
| if vlogparse == []: |
| continue |
| elif vlogparse[0] == '//': |
| continue |
| elif vlogparse[0] == '`include': |
| incpath = vlogparse[1].strip('"') |
| libpath = os.path.split(incpath)[0] |
| libname = os.path.split(libpath)[1] |
| libfile = os.path.split(incpath)[1] |
| |
| # Read the verilog library for module names to match |
| # against macro names in celldefs. |
| modulelist = self.read_verilog_lib(incpath, vlogpath) |
| matching = list(item for item in celldefs if item['name'] in modulelist) |
| for imatch in matching: |
| verilogcells.append(imatch['name']) |
| leffile = imatch['iolib'] |
| if leffile not in ioleflibs: |
| ioleflibs.append(leffile) |
| |
| # Read a corresponding LEF file entry for non-I/O macros, if one |
| # can be found (this handles files in the PDK). |
| if len(matching) == 0: |
| if libname != '': |
| # (NOTE: Assumes full path starting with '/') |
| lefpath = libpath.replace('verilog', 'lef') |
| lefname = libfile.replace('.v', '.lef') |
| if not os.path.exists(lefpath + '/' + lefname): |
| leffiles = glob.glob(lefpath + '/*.lef') |
| else: |
| leffiles = [lefpath + '/' + lefname] |
| |
| for leffile in leffiles: |
| if leffile in ioleflibs: |
| continue |
| elif leffile in lefprocessed: |
| continue |
| else: |
| lefprocessed.append(leffile) |
| |
| lefname = os.path.split(leffile)[1] |
| |
| newcoredefs = self.read_lef_macros(lefpath, lefname, 'celllib') |
| coredefs.extend(newcoredefs) |
| corecells.extend(list(item['name'] for item in newcoredefs)) |
| |
| if leffiles == []: |
| maglefname = libfile.replace('.v', '.mag') |
| |
| # Handle PDK files with a maglef/ view but no LEF file. |
| maglefpath = libpath.replace('verilog', 'maglef') |
| if not os.path.exists(maglefpath + '/' + maglefname): |
| magleffiles = glob.glob(maglefpath + '/*.mag') |
| else: |
| magleffiles = [maglefpath + '/' + maglefname] |
| |
| if magleffiles == []: |
| # Handle user ip/ files with a maglef/ view but |
| # no LEF file. |
| maglefpath = libpath.replace('verilog', 'maglef') |
| designpath = os.path.split(self.projectpath)[0] |
| maglefpath = designpath + '/ip/' + maglefpath |
| |
| if not os.path.exists(maglefpath + '/' + maglefname): |
| magleffiles = glob.glob(maglefpath + '/*.mag') |
| else: |
| magleffiles = [maglefpath + '/' + maglefname] |
| |
| for magleffile in magleffiles: |
| # Generate LEF file. Since PDK and ip/ entries |
| # are not writeable, write into the project mag/ |
| # directory. |
| magpath = self.projectpath + '/mag' |
| magname = os.path.split(magleffile)[1] |
| magroot = os.path.splitext(magname)[0] |
| leffile = magpath + '/' + magroot + '.lef' |
| if not os.path.isfile(leffile): |
| self.write_lef_file(magleffile, magpath) |
| |
| if leffile in ioleflibs: |
| continue |
| elif leffile in lefprocessed: |
| continue |
| else: |
| lefprocessed.append(leffile) |
| |
| lefname = os.path.split(leffile)[1] |
| |
| newcoredefs = self.read_lef_macros(magpath, lefname, 'celllib') |
| coredefs.extend(newcoredefs) |
| corecells.extend(list(item['name'] for item in newcoredefs)) |
| # LEF files generated on-the-fly are not needed |
| # after they have been parsed. |
| # os.remove(leffile) |
| |
| # Check if all modules in modulelist are represented by |
| # corresponding LEF macros. If not, then go looking for a LEF |
| # file in the mag/ or maglef/ directory. Then, go looking for |
| # a .mag file in the mag/ or maglef/ directory, and build a |
| # LEF macro from it. |
| |
| matching = list(item['name'] for item in coredefs if item['name'] in modulelist) |
| for module in modulelist: |
| if module not in matching: |
| lefpath = self.projectpath + '/lef' |
| magpath = self.projectpath + '/mag' |
| maglefpath = self.projectpath + '/mag' |
| lefname = libfile.replace('.v', '.lef') |
| |
| # If the verilog file root name is not the same as |
| # the module name, then make a quick check for a |
| # LEF file with the same root name as the verilog. |
| # That indicates that the module does not exist in |
| # the LEF file, probably because it is a primary |
| # module that does not correspond to any layout. |
| |
| leffile = lefpath + '/' + lefname |
| if os.path.exists(leffile): |
| self.print('Diagnostic: module ' + module + ' is not in ' + leffile + ' (probably a primary module)') |
| continue |
| |
| leffile = magpath + '/' + lefname |
| istemp = False |
| if not os.path.exists(leffile): |
| magname = libfile.replace('.v', '.mag') |
| magfile = magpath + '/' + magname |
| if os.path.exists(magfile): |
| self.print('Diagnostic: Found a .mag file for ' + module + ' in ' + magfile) |
| self.write_lef_file(magfile) |
| istemp = True |
| else: |
| magleffile = maglefpath + '/' + lefname |
| if not os.path.exists(magleffile): |
| self.print('Diagnostic: (module ' + module + ') has no LEF file ' + leffile + ' or ' + magleffile) |
| magleffile = maglefpath + '/' + magname |
| if os.path.exists(magleffile): |
| self.print('Diagnostic: Found a .mag file for ' + module + ' in ' + magleffile) |
| if os.access(maglefpath, os.W_OK): |
| self.write_lef_file(magleffile) |
| leffile = magleffile |
| istemp = True |
| else: |
| self.write_lef_file(magleffile, magpath) |
| else: |
| self.print('Did not find a file ' + magfile) |
| # self.print('Warning: module ' + module + ' has no LEF or .mag views') |
| pass |
| else: |
| self.print('Diagnostic: Found a LEF file for ' + module + ' in ' + magleffile) |
| leffile = magleffile |
| else: |
| self.print('Diagnostic: Found a LEF file for ' + module + ' in ' + leffile) |
| |
| if os.path.exists(leffile): |
| if leffile in lefprocessed: |
| continue |
| else: |
| lefprocessed.append(leffile) |
| |
| newcoredefs = self.read_lef_macros(magpath, lefname, 'celllib') |
| # The LEF file generated on-the-fly is not needed |
| # any more after parsing the macro(s). |
| # if istemp: |
| # os.remove(leffile) |
| coredefs.extend(newcoredefs) |
| corecells.extend(list(item['name'] for item in newcoredefs)) |
| else: |
| # self.print('Failed to find a LEF view for module ' + module) |
| pass |
| |
| elif vlogparse[0] in verilogcells: |
| # Check for array of pads |
| bushigh = buslow = -1 |
| if len(vlogparse) >= 3: |
| bmatch = busrex.match(vlogline) |
| if bmatch: |
| bushigh = int(bmatch.group(1)) |
| buslow = int(bmatch.group(2)) |
| |
| for i in range(buslow, bushigh + 1): |
| newpad = {} |
| if i >= 0: |
| newpad['name'] = vlogparse[1] + '[' + str(i) + ']' |
| else: |
| newpad['name'] = vlogparse[1] |
| newpad['cell'] = vlogparse[0] |
| padcell = next(item for item in celldefs if item['name'] == vlogparse[0]) |
| newpad['iolib'] = padcell['iolib'] |
| newpad['class'] = padcell['class'] |
| newpad['subclass'] = padcell['subclass'] |
| newpad['width'] = padcell['width'] |
| newpad['height'] = padcell['height'] |
| newpadlist.append(newpad) |
| |
| elif vlogparse[0] in corecells: |
| # Check for array of cells |
| bushigh = buslow = -1 |
| if len(vlogparse) >= 3: |
| bmatch = busrex.match(vlogline) |
| if bmatch: |
| bushigh = int(bmatch.group(1)) |
| buslow = int(bmatch.group(2)) |
| |
| for i in range(buslow, bushigh + 1): |
| newcorecell = {} |
| if i >= 0: |
| newcorecell['name'] = vlogparse[1] + '[' + str(i) + ']' |
| else: |
| newcorecell['name'] = vlogparse[1] |
| newcorecell['cell'] = vlogparse[0] |
| corecell = next(item for item in coredefs if item['name'] == vlogparse[0]) |
| newcorecell['celllib'] = corecell['celllib'] |
| newcorecell['class'] = corecell['class'] |
| newcorecell['subclass'] = corecell['subclass'] |
| newcorecell['width'] = corecell['width'] |
| newcorecell['height'] = corecell['height'] |
| corecelllist.append(newcorecell) |
| |
| self.print('') |
| self.print('Source file information:') |
| self.print('Source filename: ' + vlogfile) |
| self.print('Number of I/O libraries is ' + str(len(ioleflibs))) |
| self.print('Number of library cells in I/O libraries used: ' + str(len(verilogcells))) |
| self.print('Number of core celldefs is ' + str(len(coredefs))) |
| self.print('') |
| self.print('Number of I/O cells in design: ' + str(len(newpadlist))) |
| self.print('Number of core cells in design: ' + str(len(corecelllist))) |
| self.print('') |
| |
| # Save the results |
| self.celldefs = celldefs |
| self.coredefs = coredefs |
| self.vlogpads = newpadlist |
| self.corecells = corecelllist |
| self.ioleflibs = ioleflibs |
| |
| # Check self.vlogpads, which was created during import (above) against |
| # self.(N,S,W,E)pads, which was read from the DEF file (if there was one) |
| # Also check self.corecells, which was created during import against |
| # self.coregroup, which was read from the DEF file. |
| |
| def resolve(self): |
| self.print('Resolve differences in verilog and LEF views.') |
| |
| samepads = [] |
| addedpads = [] |
| removedpads = [] |
| |
| # (1) Create list of entries that are in both self.vlogpads and self.()pads |
| # (2) Create list of entries that are in self.vlogpads but not in self.()pads |
| |
| allpads = self.Npads + self.NEpad + self.Epads + self.SEpad + self.Spads + self.SWpad + self.Wpads + self.NWpad |
| |
| for pad in self.vlogpads: |
| newpadname = pad['name'] |
| try: |
| lpad = next(item for item in allpads if item['name'] == newpadname) |
| except: |
| addedpads.append(pad) |
| else: |
| samepads.append(lpad) |
| |
| # (3) Create list of entries that are in allpads but not in self.vlogpads |
| for pad in allpads: |
| newpadname = pad['name'] |
| try: |
| lpad = next(item for item in self.vlogpads if item['name'] == newpadname) |
| except: |
| removedpads.append(pad) |
| |
| # Print results |
| if len(addedpads) > 0: |
| self.print('Added pads:') |
| for pad in addedpads: |
| self.print(pad['name'] + ' (' + pad['cell'] + ')') |
| |
| if len(removedpads) > 0: |
| plist = [] |
| nspacers = 0 |
| for pad in removedpads: |
| if 'subclass' in pad: |
| if pad['subclass'] != 'SPACER': |
| plist.append(pad) |
| else: |
| nspacers += 1 |
| |
| if nspacers > 0: |
| self.print(str(nspacers) + ' spacer cells ignored.') |
| if len(plist) > 0: |
| self.print('Removed pads:') |
| for pad in removedpads: |
| self.print(pad['name'] + ' (' + pad['cell'] + ')') |
| |
| if len(addedpads) + len(removedpads) == 0: |
| self.print('Pad list has not changed.') |
| |
| # Remove all cells from the "removed" list, with comment |
| |
| allpads = [self.Npads, self.NEpad, self.Epads, self.SEpad, self.Spads, self.SWpad, self.Wpads, self.NWpad] |
| |
| for pad in removedpads: |
| rname = pad['name'] |
| for row in allpads: |
| try: |
| rpad = next(item for item in row if item['name'] == rname) |
| except: |
| rpad = None |
| else: |
| row.remove(rpad) |
| |
| # Now the verilog file has no placement information, so the old padlist |
| # entries (if they exist) are preferred. Add to these the new padlist |
| # entries |
| |
| # First pass for unassigned pads: Use of "CLASS ENDCAP" is preferred |
| # for identifying corner pads. Otherwise, if 'CORNER' or 'corner' is |
| # in the pad name, then make sure there is one per row in the first |
| # position. This is not foolproof and depends on the cell library |
| # using the text 'corner' in the name of the corner cell. However, |
| # if the ad hoc methods fail, the user can still manually move the |
| # corner cells to the right place (to be done: Identify if library |
| # uses ENDCAP designation for corner cells up front; don't go |
| # looking for 'corner' text if the cells are easily identifiable by |
| # LEF class). |
| |
| for pad in addedpads[:]: |
| iscorner = False |
| if 'class' in pad and pad['class'] == 'ENDCAP': |
| iscorner = True |
| elif 'CORNER' in pad['cell'].upper(): |
| iscorner = True |
| |
| if iscorner: |
| if self.NWpad == []: |
| self.NWpad.append(pad) |
| pad['o'] = 'E' |
| addedpads.remove(pad) |
| elif self.NEpad == []: |
| self.NEpad.append(pad) |
| pad['o'] = 'S' |
| addedpads.remove(pad) |
| elif self.SEpad == []: |
| self.SEpad.append(pad) |
| pad['o'] = 'W' |
| addedpads.remove(pad) |
| elif self.SWpad == []: |
| self.SWpad.append(pad) |
| pad['o'] = 'N' |
| addedpads.remove(pad) |
| |
| numN = len(self.Npads) |
| numS = len(self.Spads) |
| numE = len(self.Epads) |
| numW = len(self.Wpads) |
| |
| minnum = min(numN, numS, numE, numW) |
| minnum = max(minnum, int(len(addedpads) / 4)) |
| |
| # Add pads in clockwise order. Note that S and E pads are defined counterclockwise |
| for pad in addedpads: |
| if numN < minnum: |
| self.Npads.append(pad) |
| numN += 1 |
| pad['o'] = 'S' |
| self.print("Adding pad " + pad['name'] + " to Npads") |
| elif numE < minnum: |
| self.Epads.insert(0, pad) |
| numE += 1 |
| pad['o'] = 'W' |
| self.print("Adding pad " + pad['name'] + " to Epads") |
| elif numS < minnum: |
| self.Spads.insert(0, pad) |
| numS += 1 |
| pad['o'] = 'N' |
| self.print("Adding pad " + pad['name'] + " to Spads") |
| # elif numW < minnum: |
| else: |
| self.Wpads.append(pad) |
| numW += 1 |
| pad['o'] = 'E' |
| self.print("Adding pad " + pad['name'] + " to Wpads") |
| |
| minnum = min(numN, numS, numE, numW) |
| minnum = max(minnum, int(len(addedpads) / 4)) |
| |
| # Make sure all pads have included information from the cell definition |
| |
| allpads = self.Npads + self.NEpad + self.Epads + self.SEpad + self.Spads + self.SWpad + self.Wpads + self.NWpad |
| |
| for pad in allpads: |
| if 'width' not in pad: |
| try: |
| celldef = next(item for item in celldefs if item['name'] == pad['cell']) |
| except: |
| self.print('Cell ' + pad['cell'] + ' not found!') |
| else: |
| pad['width'] = celldef['width'] |
| pad['height'] = celldef['height'] |
| pad['class'] = celldef['class'] |
| pad['subclass'] = celldef['subclass'] |
| |
| # Now treat the core cells in the same way (resolve list parsed from verilog |
| # against the list parsed from DEF) |
| |
| # self.print('Diagnostic: ') |
| # self.print('self.corecells = ' + str(self.corecells)) |
| # self.print('self.coregroup = ' + str(self.coregroup)) |
| |
| samecore = [] |
| addedcore = [] |
| removedcore = [] |
| |
| # (1) Create list of entries that are in both self.corecells and self.coregroup |
| # (2) Create list of entries that are in self.corecells but not in self.coregroup |
| |
| for cell in self.corecells: |
| newcellname = cell['name'] |
| try: |
| lcore = next(item for item in self.coregroup if item['name'] == newcellname) |
| except: |
| addedcore.append(cell) |
| else: |
| samecore.append(lcore) |
| |
| # (3) Create list of entries that are in self.coregroup but not in self.corecells |
| for cell in self.coregroup: |
| newcellname = cell['name'] |
| try: |
| lcore = next(item for item in self.corecells if item['name'] == newcellname) |
| except: |
| removedcore.append(cell) |
| |
| # Print results |
| if len(addedcore) > 0: |
| self.print('Added core cells:') |
| for cell in addedcore: |
| self.print(cell['name'] + ' (' + cell['cell'] + ')') |
| |
| if len(removedcore) > 0: |
| clist = [] |
| for cell in removedcore: |
| clist.append(cell) |
| |
| if len(clist) > 0: |
| self.print('Removed core cells:') |
| for cell in removedcore: |
| self.print(cell['name'] + ' (' + cell['cell'] + ')') |
| |
| if len(addedcore) + len(removedcore) == 0: |
| self.print('Core cell list has not changed.') |
| |
| # Remove all cells from the "removed" list |
| |
| coregroup = self.coregroup |
| for cell in removedcore: |
| rname = cell['name'] |
| try: |
| rcell = next(item for item in coregroup if item['name'] == rname) |
| except: |
| rcell = None |
| else: |
| coregroup.remove(rcell) |
| |
| # Add all cells from the "added" list to coregroup |
| |
| for cell in addedcore: |
| rname = cell['name'] |
| try: |
| rcell = next(item for item in coregroup if item['name'] == rname) |
| except: |
| coregroup.append(cell) |
| if not 'o' in cell: |
| cell['o'] = 'N' |
| if not 'x' in cell: |
| if len(self.Wpads) > 0: |
| pad = self.Wpads[0] |
| padx = pad['x'] if 'x' in pad else 0 |
| cell['x'] = padx + pad['height'] + self.margin |
| else: |
| cell['x'] = self.margin |
| if not 'y' in cell: |
| if len(self.Spads) > 0: |
| pad = self.Spads[0] |
| pady = pad['y'] if 'y' in pad else 0 |
| cell['y'] = pady + pad['height'] + self.margin |
| else: |
| cell['y'] = self.margin |
| else: |
| rcell = None |
| |
| # Make sure all core cells have included information from the cell definition |
| |
| for cell in coregroup: |
| if 'width' not in cell: |
| try: |
| coredef = next(item for item in coredefs if item['name'] == cell['cell']) |
| except: |
| self.print('Cell ' + cell['cell'] + ' not found!') |
| else: |
| cell['width'] = coredef['width'] |
| cell['height'] = coredef['height'] |
| cell['class'] = coredef['class'] |
| cell['subclass'] = coredef['subclass'] |
| |
| # Generate a new padframe by writing the configuration file, running |
| # padring, reading back the DEF file, and (re)poplulating the workspace |
| |
| def generate(self, level=0): |
| self.print('Generate legal padframe using padring') |
| |
| # Write out the configuration file |
| self.writeconfig() |
| # Run the padring app |
| self.runpadring() |
| # Rotate pads in the output if pad orientations are different from |
| # padring's expectations |
| self.rotate_pads_in_def() |
| # Read the placement information back from the generated DEF file |
| self.readplacement() |
| # Resolve differences (e.g., remove spacers) |
| self.resolve() |
| # Recreate and draw the padframe view on the canvas |
| self.populate(level + 1) |
| self.frame_configure(None) |
| |
| # Write a new configuration file |
| |
| def writeconfig(self): |
| mag_path = self.projectpath + '/mag' |
| if not os.path.exists(mag_path): |
| self.print('Error: No project path /mag directory exists. Cannot write config file.') |
| return |
| |
| self.print('Writing padring configuration file.') |
| |
| # Determine cell width and height from pad sizes. |
| # NOTE: This compresses the chip to the minimum dimensions |
| # allowed by the arrangement of pads. Use a "core" block to |
| # force the area larger than minimum (not yet implemented) |
| |
| topwidth = 0 |
| for pad in self.Npads: |
| if 'width' not in pad: |
| self.print('No width: pad = ' + str(pad)) |
| topwidth += pad['width'] |
| |
| # Add in the corner cells |
| if self.NWpad != []: |
| topwidth += self.NWpad[0]['height'] |
| if self.NEpad != []: |
| topwidth += self.NEpad[0]['width'] |
| |
| botwidth = 0 |
| for pad in self.Spads: |
| botwidth += pad['width'] |
| |
| # Add in the corner cells |
| if self.SWpad != []: |
| botwidth += self.SWpad[0]['width'] |
| if self.SEpad != []: |
| botwidth += self.SEpad[0]['height'] |
| |
| width = max(botwidth, topwidth) |
| |
| # if width < self.urx - self.llx: |
| # width = self.urx - self.llx |
| |
| leftheight = 0 |
| for pad in self.Wpads: |
| leftheight += pad['width'] |
| |
| # Add in the corner cells |
| if self.NWpad != []: |
| leftheight += self.NWpad[0]['height'] |
| if self.SWpad != []: |
| leftheight += self.SWpad[0]['width'] |
| |
| rightheight = 0 |
| for pad in self.Epads: |
| rightheight += pad['width'] |
| |
| # Add in the corner cells |
| if self.NEpad != []: |
| rightheight += self.NEpad[0]['width'] |
| if self.SEpad != []: |
| rightheight += self.SEpad[0]['height'] |
| |
| height = max(leftheight, rightheight) |
| |
| # Check the dimensions of the core cells. If they exceed the available |
| # padframe area, then expand the padframe to accomodate the core. |
| |
| corellx = coreurx = (self.llx + self.urx) / 2 |
| corelly = coreury = (self.lly + self.ury) / 2 |
| |
| for corecell in self.coregroup: |
| corient = corecell['o'] |
| if 'S' in corient or 'N' in corient: |
| cwidth = corecell['width'] |
| cheight = corecell['height'] |
| else: |
| cwidth = corecell['height'] |
| cheight = corecell['width'] |
| |
| if corecell['x'] < corellx: |
| corellx = corecell['x'] |
| if corecell['x'] + cwidth > coreurx: |
| coreurx = corecell['x'] + cwidth |
| if corecell['y'] < corelly: |
| corelly = corecell['y'] |
| if corecell['y'] + cheight > coreury: |
| coreury = corecell['y'] + cheight |
| |
| coreheight = coreury - corelly |
| corewidth = coreurx - corellx |
| |
| # Ignoring the possibility of overlaps with nonstandard-sized pads, |
| # assuming that the user has visually separated them. Only check |
| # the core bounds against the standard padframe inside edge. |
| |
| if self.SWpad != [] and self.SEpad != []: |
| if corewidth > width - self.SWpad[0]['width'] - self.SEpad[0]['width']: |
| width = corewidth + self.SWpad[0]['width'] + self.SEpad[0]['width'] |
| if self.NWpad != [] and self.SWpad != []: |
| if coreheight > height - self.NWpad[0]['height'] - self.SWpad[0]['height']: |
| height = coreheight + self.NWpad[0]['height'] + self.SWpad[0]['height'] |
| |
| # Core cells are given a margin of self.margin from the pad inside edge, so the |
| # core area passed to the padring app is 2 * self.margin larger than the |
| # measured size of the core area. |
| width += 2 * self.margin |
| height += 2 * self.margin |
| |
| if self.keep_cfg == False or not os.path.exists(mag_path + '/padframe.cfg'): |
| |
| if os.path.exists(mag_path + '/padframe.cfg'): |
| # Copy the previous padframe.cfg file to a backup. In case something |
| # goes badly wrong, this should be the only file overwritten, and can |
| # be recovered from the backup. |
| shutil.copy(mag_path + '/padframe.cfg', mag_path + '/padframe.cfg.bak') |
| |
| with open(mag_path + '/padframe.cfg', 'w') as ofile: |
| print('AREA ' + str(int(width)) + ' ' + str(int(height)) + ' ;', |
| file=ofile) |
| print('', file=ofile) |
| for pad in self.NEpad: |
| print('CORNER ' + pad['name'] + ' SW ' + pad['cell'] + ' ;', |
| file=ofile) |
| for pad in self.SEpad: |
| print('CORNER ' + pad['name'] + ' NW ' + pad['cell'] + ' ;', |
| file=ofile) |
| for pad in self.SWpad: |
| print('CORNER ' + pad['name'] + ' NE ' + pad['cell'] + ' ;', |
| file=ofile) |
| for pad in self.NWpad: |
| print('CORNER ' + pad['name'] + ' SE ' + pad['cell'] + ' ;', |
| file=ofile) |
| for pad in self.Npads: |
| flip = 'F ' if 'F' in pad['o'] else '' |
| print('PAD ' + pad['name'] + ' N ' + flip + pad['cell'] + ' ;', |
| file=ofile) |
| for pad in self.Epads: |
| flip = 'F ' if 'F' in pad['o'] else '' |
| print('PAD ' + pad['name'] + ' E ' + flip + pad['cell'] + ' ;', |
| file=ofile) |
| for pad in self.Spads: |
| flip = 'F ' if 'F' in pad['o'] else '' |
| print('PAD ' + pad['name'] + ' S ' + flip + pad['cell'] + ' ;', |
| file=ofile) |
| for pad in self.Wpads: |
| flip = 'F ' if 'F' in pad['o'] else '' |
| print('PAD ' + pad['name'] + ' W ' + flip + pad['cell'] + ' ;', |
| file=ofile) |
| |
| # Run the padring app. |
| |
| def runpadring(self): |
| mag_path = self.projectpath + '/mag' |
| if not os.path.exists(mag_path): |
| self.print('No path /mag exists in project space; cannot run padring.') |
| return |
| |
| self.print('Running padring') |
| |
| if self.padring_path: |
| padringopts = [self.padring_path] |
| else: |
| padringopts = ['padring'] |
| |
| # Diagnostic |
| # self.print('Used libraries (self.ioleflibs) = ' + str(self.ioleflibs)) |
| |
| for iolib in self.ioleflibs: |
| padringopts.append('-L') |
| padringopts.append(iolib) |
| padringopts.append('--def') |
| padringopts.append('padframe.def') |
| padringopts.append('padframe.cfg') |
| |
| self.print('Running ' + str(padringopts)) |
| |
| p = subprocess.Popen(padringopts, stdout = subprocess.PIPE, |
| stderr = subprocess.PIPE, cwd = mag_path) |
| self.watch(p) |
| |
| # Read placement information from the DEF file generated by padring. |
| |
| def readplacement(self, precheck=False): |
| self.print('Reading placement information from DEF file') |
| |
| mag_path = self.projectpath + '/mag' |
| if not os.path.isfile(mag_path + '/padframe.def'): |
| if not precheck: |
| self.print('No file padframe.def: pad frame was not generated.') |
| return False |
| |
| # Very simple DEF file parsing. The placement DEF only contains a |
| # COMPONENTS section. Certain assumptions are made about the syntax |
| # that depends on the way 'padring' writes its output. This is not |
| # a rigorous DEF parser! |
| |
| units = 1000 |
| in_components = False |
| Npadlist = [] |
| Spadlist = [] |
| Epadlist = [] |
| Wpadlist = [] |
| NEpad = [] |
| NWpad = [] |
| SEpad = [] |
| SWpad = [] |
| coregroup = [] |
| |
| # Reset bounds |
| self.llx = self.lly = self.urx = self.ury = 0 |
| corners = 0 |
| |
| with open(mag_path + '/padframe.def', 'r') as ifile: |
| deflines = ifile.read().splitlines() |
| for line in deflines: |
| if 'UNITS DISTANCE MICRONS' in line: |
| units = line.split()[3] |
| elif in_components: |
| lparse = line.split() |
| if lparse[0] == '-': |
| instname = lparse[1] |
| cellname = lparse[2] |
| |
| elif lparse[0] == '+': |
| if lparse[1] == 'PLACED': |
| placex = lparse[3] |
| placey = lparse[4] |
| placeo = lparse[6] |
| |
| newpad = {} |
| newpad['name'] = instname |
| newpad['cell'] = cellname |
| |
| try: |
| celldef = next(item for item in self.celldefs if item['name'] == cellname) |
| except: |
| celldef = None |
| else: |
| newpad['iolib'] = celldef['iolib'] |
| newpad['width'] = celldef['width'] |
| newpad['height'] = celldef['height'] |
| newpad['class'] = celldef['class'] |
| newpad['subclass'] = celldef['subclass'] |
| |
| newpad['x'] = float(placex) / float(units) |
| newpad['y'] = float(placey) / float(units) |
| newpad['o'] = placeo |
| |
| # Adjust bounds |
| if celldef: |
| if newpad['x'] < self.llx: |
| self.llx = newpad['x'] |
| if newpad['y'] < self.lly: |
| self.lly = newpad['y'] |
| |
| if newpad['o'] == 'N' or newpad['o'] == 'S': |
| padurx = newpad['x'] + celldef['width'] |
| padury = newpad['y'] + celldef['height'] |
| else: |
| padurx = newpad['x'] + celldef['height'] |
| padury = newpad['y'] + celldef['width'] |
| |
| if padurx > self.urx: |
| self.urx = padurx |
| if padury > self.ury: |
| self.ury = padury |
| |
| # First four entries in the DEF file are corners |
| # padring puts the lower left corner at zero, so |
| # use the zero coordinates to determine which pads |
| # are which. Note that padring assumes the corner |
| # pad is drawn in the SW corner position! |
| |
| if corners < 4: |
| if newpad['x'] == 0 and newpad['y'] == 0: |
| SWpad.append(newpad) |
| elif newpad['x'] == 0: |
| NWpad.append(newpad) |
| elif newpad['y'] == 0: |
| SEpad.append(newpad) |
| else: |
| NEpad.append(newpad) |
| corners += 1 |
| else: |
| # Place according to orientation. If orientation |
| # is not standard, be sure to make it standard! |
| placeo = self.rotate_orientation(placeo) |
| if placeo == 'N': |
| Spadlist.append(newpad) |
| elif placeo == 'E': |
| Wpadlist.append(newpad) |
| elif placeo == 'S': |
| Npadlist.append(newpad) |
| else: |
| Epadlist.append(newpad) |
| |
| elif 'END COMPONENTS' in line: |
| in_components = False |
| elif 'COMPONENTS' in line: |
| in_components = True |
| |
| self.Npads = Npadlist |
| self.Wpads = Wpadlist |
| self.Spads = Spadlist |
| self.Epads = Epadlist |
| |
| self.NWpad = NWpad |
| self.NEpad = NEpad |
| self.SWpad = SWpad |
| self.SEpad = SEpad |
| |
| # The padframe has its own DEF file from the padring app, but the core |
| # does not. The core needs to be floorplanned in a very similar manner. |
| # This will be done by searching for a DEF file of the project top-level |
| # layout. If none exists, it is created by generating it from the layout. |
| # If the top-level layout does not exist, then all core cells are placed |
| # at the origin, and the origin placed at the padframe inside corner. |
| |
| mag_path = self.projectpath + '/mag' |
| if not os.path.isfile(mag_path + '/' + self.project + '.def'): |
| if os.path.isfile(mag_path + '/' + self.project + '.mag'): |
| |
| # Create a DEF file from the layout |
| with open(mag_path + '/pfg_write_def.tcl', 'w') as ofile: |
| print('drc off', file=ofile) |
| print('box 0 0 0 0', file=ofile) |
| print('load ' + self.project, file=ofile) |
| print('def write', file=ofile) |
| print('quit', file=ofile) |
| |
| magicexec = self.magic_path if self.magic_path else 'magic' |
| mproc = subprocess.Popen([magicexec, '-dnull', '-noconsole', |
| 'pfg_write_def.tcl'], |
| stdin = subprocess.PIPE, stdout = subprocess.PIPE, |
| stderr = subprocess.PIPE, cwd = mag_path, universal_newlines = True) |
| |
| self.watch(mproc) |
| os.remove(mag_path + '/pfg_write_def.tcl') |
| |
| elif not os.path.isfile(mag_path + '/core.def'): |
| |
| # With no other information available, copy the corecells |
| # (from the verilog file) into the coregroup list. |
| # Position all core cells starting at the padframe top left |
| # inside corner, and arranging in rows without overlapping. |
| # Note that no attempt is made to organize the cells or |
| # otherwise produce an efficient layout. Any dimension larger |
| # than the current padframe overruns to the right or bottom. |
| |
| if self.SWpad != []: |
| corellx = SWpad[0]['x'] + SWpad[0]['width'] + self.margin |
| corelly = SWpad[0]['y'] + SWpad[0]['height'] + self.margin |
| else: |
| corellx = Wpadlist[0]['x'] + Wpadlist[0]['height'] + self.margin |
| corelly = Spadlist[0]['x'] + Spadlist[0]['height'] + self.margin |
| if self.NEpad != []: |
| coreurx = NEpad[0]['x'] - self.margin |
| coreury = NEpad[0]['y'] - self.margin |
| else: |
| coreurx = Epadlist[0]['x'] - self.margin |
| coreury = Npadlist[0]['x'] - self.margin |
| locllx = corellx |
| testllx = corellx |
| loclly = corelly |
| testlly = corelly |
| nextlly = corelly |
| |
| for cell in self.corecells: |
| |
| testllx = locllx + cell['width'] |
| if testllx > coreurx: |
| locllx = corellx |
| corelly = nextlly |
| loclly = nextlly |
| |
| newcore = cell |
| newcore['x'] = locllx |
| newcore['y'] = loclly |
| newcore['o'] = 'N' |
| |
| locllx += cell['width'] + self.margin |
| |
| testlly = corelly + cell['height'] + self.margin |
| if testlly > nextlly: |
| nextlly = testlly |
| |
| coregroup.append(newcore) |
| |
| self.coregroup = coregroup |
| |
| if os.path.isfile(mag_path + '/' + self.project + '.def'): |
| # Read the top-level DEF, and use it to position the core cells. |
| self.print('Reading the top-level cell DEF for core cell placement.') |
| |
| units = 1000 |
| in_components = False |
| with open(mag_path + '/' + self.project + '.def', 'r') as ifile: |
| deflines = ifile.read().splitlines() |
| for line in deflines: |
| if 'UNITS DISTANCE MICRONS' in line: |
| units = line.split()[3] |
| elif in_components: |
| lparse = line.split() |
| if lparse[0] == '-': |
| instname = lparse[1] |
| # NOTE: Magic should not drop the entire path to the |
| # cell for the cellname; this needs to be fixed! To |
| # work around it, remove any path components. |
| cellpath = lparse[2] |
| cellname = os.path.split(cellpath)[1] |
| |
| elif lparse[0] == '+': |
| if lparse[1] == 'PLACED': |
| placex = lparse[3] |
| placey = lparse[4] |
| placeo = lparse[6] |
| |
| newcore = {} |
| newcore['name'] = instname |
| newcore['cell'] = cellname |
| |
| try: |
| celldef = next(item for item in self.coredefs if item['name'] == cellname) |
| except: |
| celldef = None |
| else: |
| newcore['celllib'] = celldef['celllib'] |
| newcore['width'] = celldef['width'] |
| newcore['height'] = celldef['height'] |
| newcore['class'] = celldef['class'] |
| newcore['subclass'] = celldef['subclass'] |
| |
| newcore['x'] = float(placex) / float(units) |
| newcore['y'] = float(placey) / float(units) |
| newcore['o'] = placeo |
| coregroup.append(newcore) |
| |
| elif 'END COMPONENTS' in line: |
| in_components = False |
| elif 'COMPONENTS' in line: |
| in_components = True |
| |
| self.coregroup = coregroup |
| |
| elif os.path.isfile(mag_path + '/core.def'): |
| # No DEF or .mag file, so fallback position is the last core.def |
| # file generated by this script. |
| self.read_core_def(precheck=precheck) |
| |
| return True |
| |
| # Read placement information from the "padframe.def" file and rotate |
| # all cells according to self.pad_rotation. This accounts for the |
| # problem that the default orientation of pads is arbitrarily defined |
| # by the foundry, while padring assumes that the corner pad is drawn |
| # in the lower-left position and other pads are drawn with the pad at |
| # the bottom and the buses at the top. |
| |
| def rotate_pads_in_def(self): |
| if self.pad_rotation == 0: |
| return |
| |
| self.print('Rotating pads in padframe DEF file.') |
| mag_path = self.projectpath + '/mag' |
| |
| if not os.path.isfile(mag_path + '/padframe.def'): |
| self.print('No file padframe.def: Cannot modify pad rotations.') |
| return |
| |
| deflines = [] |
| with open(mag_path + '/padframe.def', 'r') as ifile: |
| deflines = ifile.read().splitlines() |
| |
| outlines = [] |
| in_components = False |
| for line in deflines: |
| if in_components: |
| lparse = line.split() |
| if lparse[0] == '+': |
| if lparse[1] == 'PLACED': |
| neworient = self.rotate_orientation(lparse[6]) |
| lparse[6] = neworient |
| line = ' '.join(lparse) |
| |
| elif 'END COMPONENTS' in line: |
| in_components = False |
| elif 'COMPONENTS' in line: |
| in_components = True |
| outlines.append(line) |
| |
| with open(mag_path + '/padframe.def', 'w') as ofile: |
| for line in outlines: |
| print(line, file=ofile) |
| |
| # Read placement information from the DEF file for the core (created by |
| # a previous run of this script) |
| |
| def read_core_def(self, precheck=False): |
| self.print('Reading placement information from core DEF file.') |
| |
| mag_path = self.projectpath + '/mag' |
| |
| if not os.path.isfile(mag_path + '/core.def'): |
| if not precheck: |
| self.print('No file core.def: core placement was not generated.') |
| return False |
| |
| # Very simple DEF file parsing, similar to the padframe.def reading |
| # routine above. |
| |
| units = 1000 |
| in_components = False |
| |
| coregroup = [] |
| |
| with open(mag_path + '/core.def', 'r') as ifile: |
| deflines = ifile.read().splitlines() |
| for line in deflines: |
| if 'UNITS DISTANCE MICRONS' in line: |
| units = line.split()[3] |
| elif in_components: |
| lparse = line.split() |
| if lparse[0] == '-': |
| instname = lparse[1] |
| cellname = lparse[2] |
| |
| elif lparse[0] == '+': |
| if lparse[1] == 'PLACED': |
| placex = lparse[3] |
| placey = lparse[4] |
| placeo = lparse[6] |
| |
| newcore = {} |
| newcore['name'] = instname |
| newcore['cell'] = cellname |
| |
| try: |
| celldef = next(item for item in self.coredefs if item['name'] == cellname) |
| except: |
| celldef = None |
| else: |
| newcore['celllib'] = celldef['celllib'] |
| newcore['width'] = celldef['width'] |
| newcore['height'] = celldef['height'] |
| newcore['class'] = celldef['class'] |
| newcore['subclass'] = celldef['subclass'] |
| |
| newcore['x'] = float(placex) / float(units) |
| newcore['y'] = float(placey) / float(units) |
| newcore['o'] = placeo |
| coregroup.append(newcore) |
| |
| elif 'END COMPONENTS' in line: |
| in_components = False |
| elif 'COMPONENTS' in line: |
| in_components = True |
| |
| self.coregroup = coregroup |
| |
| return True |
| |
| # Save the layout to a Magic database file (to be completed) |
| |
| def save(self): |
| self.print('Saving results in a magic layout database.') |
| |
| # Generate a list of (unique) LEF libraries for all padframe and core cells |
| leflist = [] |
| for pad in self.celldefs: |
| if pad['iolib'] not in leflist: |
| leflist.append(pad['iolib']) |
| |
| for core in self.coredefs: |
| if core['celllib'] not in leflist: |
| leflist.append(core['celllib']) |
| |
| # Run magic, and generate the padframe with a series of commands |
| mag_path = self.projectpath + '/mag' |
| |
| with open(mag_path + '/pfg_write_mag.tcl', 'w') as ofile: |
| print('drc off', file=ofile) |
| print('box 0 0 0 0', file=ofile) |
| for leffile in leflist: |
| print('lef read ' + leffile, file=ofile) |
| print('def read padframe', file=ofile) |
| print('select top cell', file=ofile) |
| print('select area', file=ofile) |
| print('select save padframe', file=ofile) |
| print('delete', file=ofile) |
| print('def read core', file=ofile) |
| print('getcell padframe', file=ofile) |
| print('save ' + self.project, file=ofile) |
| print('writeall force ' + self.project, file=ofile) |
| print('quit', file=ofile) |
| |
| magicexec = self.magic_path if self.magic_path else 'magic' |
| mproc = subprocess.Popen([magicexec, '-dnull', '-noconsole', |
| 'pfg_write_mag.tcl'], |
| stdin = subprocess.PIPE, stdout = subprocess.PIPE, |
| stderr = subprocess.PIPE, cwd = mag_path, universal_newlines = True) |
| self.watch(mproc) |
| os.remove(mag_path + '/pfg_write_mag.tcl') |
| self.print('Done writing layout ' + self.project + '.mag') |
| |
| # Write the core DEF file if it does not exist yet. |
| if not os.path.isfile(mag_path + '/core.def'): |
| self.write_core_def() |
| |
| if __name__ == '__main__': |
| faulthandler.register(signal.SIGUSR2) |
| options = [] |
| arguments = [] |
| for item in sys.argv[1:]: |
| if item.find('-', 0) == 0: |
| options.append(item) |
| else: |
| arguments.append(item) |
| |
| if '-help' in options: |
| print(sys.argv[0] + ' [options]') |
| print('') |
| print('options:') |
| print(' -noc Print output to terminal, not the gui window') |
| print(' -nog No graphics, run in batch mode') |
| print(' -cfg Use existing padframe.cfg, do not regenerate') |
| print(' -padring-path=<path> path to padring executable') |
| print(' -magic-path=<path> path to magic executable') |
| print(' -tech-path=<path> path to tech root folder') |
| print(' -project-path=<path> path to project root folder') |
| print(' -help Print this usage information') |
| print('') |
| sys.exit(0) |
| |
| root = tkinter.Tk() |
| do_gui = False if ('-nog' in options or '-nogui' in options) else True |
| app = SoCFloorplanner(root, do_gui) |
| |
| # Allow option -noc to bypass the text-to-console redirection, so crash |
| # information doesn't disappear with the app. |
| |
| app.use_console = False if ('-noc' in options or '-noconsole' in options) else True |
| if do_gui == False: |
| app.use_console = False |
| |
| # efabless format can be specified on the command line, but note that it |
| # is otherwise auto-detected by checking for .config vs. .ef-config in |
| # the project space. |
| |
| app.ef_format = True if '-ef_format' in options else False |
| app.keep_cfg = True if '-cfg' in options else False |
| |
| app.padring_path = None |
| app.magic_path = None |
| app.techpath = None |
| app.projectpath = None |
| |
| for option in options: |
| if option.split('=')[0] == '-padring-path': |
| app.padring_path = option.split('=')[1] |
| elif option.split('=')[0] == '-magic-path': |
| app.magic_path = option.split('=')[1] |
| elif option.split('=')[0] == '-tech-path': |
| app.techpath = option.split('=')[1] |
| elif option.split('=')[0] == '-project-path': |
| app.projectpath = option.split('=')[1] |
| app.projectpath = app.projectpath[:-1] if app.projectpath[-1] == '/' else app.projectpath |
| |
| app.text_to_console() |
| app.init_padframe() |
| if app.do_gui: |
| root.mainloop() |
| else: |
| # Run 'save' in non-GUI mode |
| app.save() |
| sys.exit(0) |
| |
