Initial commit of public repository open_pdks.
diff --git a/common/soc_floorplanner.py b/common/soc_floorplanner.py
new file mode 100755
index 0000000..959a623
--- /dev/null
+++ b/common/soc_floorplanner.py
@@ -0,0 +1,2619 @@
+#!/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):
+ """Open Galaxy 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(0)
+
+ # 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
+
+ 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(0)
+ 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(0)
+
+ 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('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):
+ 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)
+
