Anders Blomdell / mbed-sdk-tools

Clone of official tools

targets.py@16:a6285a7e5cc6, 2016-07-14 (annotated)

Committer:
screamer
Date:
Thu Jul 14 21:29:46 2016 +0100
Revision:
16:a6285a7e5cc6
Parent:
14:ee1b877e6839
Child:
22:9e85236d8716
Update targets.py to latest

Who changed what in which revision?

UserRevisionLine numberNew contents of line
screamer 0:66f3b5499f7f 1 """
screamer 0:66f3b5499f7f 2 mbed SDK
screamer 0:66f3b5499f7f 3 Copyright (c) 2011-2016 ARM Limited
screamer 0:66f3b5499f7f 4
screamer 0:66f3b5499f7f 5 Licensed under the Apache License, Version 2.0 (the "License");
screamer 0:66f3b5499f7f 6 you may not use this file except in compliance with the License.
screamer 0:66f3b5499f7f 7 You may obtain a copy of the License at
screamer 0:66f3b5499f7f 8
screamer 0:66f3b5499f7f 9 http://www.apache.org/licenses/LICENSE-2.0
screamer 0:66f3b5499f7f 10
screamer 0:66f3b5499f7f 11 Unless required by applicable law or agreed to in writing, software
screamer 0:66f3b5499f7f 12 distributed under the License is distributed on an "AS IS" BASIS,
screamer 0:66f3b5499f7f 13 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
screamer 0:66f3b5499f7f 14 See the License for the specific language governing permissions and
screamer 0:66f3b5499f7f 15 limitations under the License.
screamer 0:66f3b5499f7f 16 """
screamer 0:66f3b5499f7f 17
screamer 0:66f3b5499f7f 18 CORE_LABELS = {
screamer 0:66f3b5499f7f 19 "ARM7TDMI-S": ["ARM7", "LIKE_CORTEX_ARM7"],
screamer 0:66f3b5499f7f 20 "Cortex-M0" : ["M0", "CORTEX_M", "LIKE_CORTEX_M0"],
screamer 0:66f3b5499f7f 21 "Cortex-M0+": ["M0P", "CORTEX_M", "LIKE_CORTEX_M0"],
screamer 0:66f3b5499f7f 22 "Cortex-M1" : ["M1", "CORTEX_M", "LIKE_CORTEX_M1"],
screamer 0:66f3b5499f7f 23 "Cortex-M3" : ["M3", "CORTEX_M", "LIKE_CORTEX_M3"],
screamer 0:66f3b5499f7f 24 "Cortex-M4" : ["M4", "CORTEX_M", "RTOS_M4_M7", "LIKE_CORTEX_M4"],
screamer 0:66f3b5499f7f 25 "Cortex-M4F" : ["M4", "CORTEX_M", "RTOS_M4_M7", "LIKE_CORTEX_M4"],
screamer 0:66f3b5499f7f 26 "Cortex-M7" : ["M7", "CORTEX_M", "RTOS_M4_M7", "LIKE_CORTEX_M7"],
screamer 0:66f3b5499f7f 27 "Cortex-M7F" : ["M7", "CORTEX_M", "RTOS_M4_M7", "LIKE_CORTEX_M7"],
screamer 13:ab47a20b66f0 28 "Cortex-M7FD" : ["M7", "CORTEX_M", "RTOS_M4_M7", "LIKE_CORTEX_M7"],
screamer 0:66f3b5499f7f 29 "Cortex-A9" : ["A9", "CORTEX_A", "LIKE_CORTEX_A9"]
screamer 0:66f3b5499f7f 30 }
screamer 0:66f3b5499f7f 31
screamer 0:66f3b5499f7f 32 import os
screamer 0:66f3b5499f7f 33 import binascii
screamer 0:66f3b5499f7f 34 import struct
screamer 0:66f3b5499f7f 35 import shutil
screamer 0:66f3b5499f7f 36 from tools.patch import patch
screamer 0:66f3b5499f7f 37 from paths import TOOLS_BOOTLOADERS
screamer 7:5af61d55adbe 38 import json
screamer 7:5af61d55adbe 39 import inspect
screamer 7:5af61d55adbe 40 import sys
screamer 7:5af61d55adbe 41 from tools.utils import json_file_to_dict
screamer 7:5af61d55adbe 42
screamer 7:5af61d55adbe 43 ########################################################################################################################
screamer 7:5af61d55adbe 44 # Generic Target class that reads and interprets the data in targets.json
screamer 7:5af61d55adbe 45
screamer 7:5af61d55adbe 46 # A simple class that represents all the exceptions associated with hooking
screamer 7:5af61d55adbe 47 class HookError(Exception):
screamer 7:5af61d55adbe 48 pass
screamer 7:5af61d55adbe 49
screamer 7:5af61d55adbe 50 # A simple decorator used for automatically caching data returned by a function
screamer 7:5af61d55adbe 51 caches = {}
screamer 7:5af61d55adbe 52 def cached(func):
screamer 7:5af61d55adbe 53 def wrapper(*args, **kwargs):
screamer 16:a6285a7e5cc6 54 if not caches.has_key((func.__name__, args)):
screamer 16:a6285a7e5cc6 55 caches[(func.__name__, args)] = func(*args, **kwargs)
screamer 16:a6285a7e5cc6 56 return caches[(func.__name__, args)]
screamer 7:5af61d55adbe 57 return wrapper
screamer 0:66f3b5499f7f 58
screamer 0:66f3b5499f7f 59 class Target:
screamer 7:5af61d55adbe 60 # Cumulative attributes can have values appended to them, so they
screamer 7:5af61d55adbe 61 # need to be computed differently than regular attributes
screamer 13:ab47a20b66f0 62 __cumulative_attributes = ['extra_labels', 'macros', 'device_has', 'features']
screamer 7:5af61d55adbe 63
screamer 7:5af61d55adbe 64 # List of targets that were added dynamically using "add_py_targets" (see below)
screamer 7:5af61d55adbe 65 __py_targets = set()
screamer 7:5af61d55adbe 66
screamer 16:a6285a7e5cc6 67 # Location of the 'targets.json' file
screamer 16:a6285a7e5cc6 68 __targets_json_location = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'targets.json')
screamer 16:a6285a7e5cc6 69
screamer 7:5af61d55adbe 70 # Load the description of JSON target data
screamer 7:5af61d55adbe 71 @staticmethod
screamer 7:5af61d55adbe 72 @cached
screamer 7:5af61d55adbe 73 def get_json_target_data():
screamer 16:a6285a7e5cc6 74 return json_file_to_dict(Target.__targets_json_location)
screamer 16:a6285a7e5cc6 75
screamer 16:a6285a7e5cc6 76 # Set the location of the targets.json file
screamer 16:a6285a7e5cc6 77 @staticmethod
screamer 16:a6285a7e5cc6 78 def set_targets_json_location(location):
screamer 16:a6285a7e5cc6 79 Target.__targets_json_location = location
screamer 16:a6285a7e5cc6 80 # Invalidate caches, since the location of the JSON file changed
screamer 16:a6285a7e5cc6 81 caches.clear()
screamer 7:5af61d55adbe 82
screamer 7:5af61d55adbe 83 # Get the members of this module using Python's "inspect" module
screamer 7:5af61d55adbe 84 @staticmethod
screamer 7:5af61d55adbe 85 @cached
screamer 7:5af61d55adbe 86 def get_module_data():
screamer 7:5af61d55adbe 87 return dict([(m[0], m[1]) for m in inspect.getmembers(sys.modules[__name__])])
screamer 0:66f3b5499f7f 88
screamer 7:5af61d55adbe 89 # Return the order in which target descriptions are searched for attributes
screamer 7:5af61d55adbe 90 # This mimics the Python 2.2 method resolution order, which is what the old targets.py module used
screamer 7:5af61d55adbe 91 # For more details, check http://makina-corpus.com/blog/metier/2014/python-tutorial-understanding-python-mro-class-search-path
screamer 7:5af61d55adbe 92 # The resolution order contains (name, level) tuples, where "name" is the name of the class and "level"
screamer 7:5af61d55adbe 93 # is the level in the inheritance hierarchy (the target itself is at level 0, its first parent at level 1,
screamer 7:5af61d55adbe 94 # its parent's parent at level 1 and so on)
screamer 7:5af61d55adbe 95 def __get_resolution_order(self, target_name, order, level = 0):
screamer 7:5af61d55adbe 96 if not target_name in [l[0] for l in order]: # the resolution order can't contain duplicate target names
screamer 7:5af61d55adbe 97 order.append((target_name, level))
screamer 7:5af61d55adbe 98 parents = self.get_json_target_data()[target_name].get("inherits", [])
screamer 7:5af61d55adbe 99 for p in parents:
screamer 7:5af61d55adbe 100 order = self.__get_resolution_order(p, order, level + 1)
screamer 7:5af61d55adbe 101 return order
screamer 0:66f3b5499f7f 102
screamer 7:5af61d55adbe 103 # Modify the exporter specification ("progen") by changing all "template" keys to full paths
screamer 7:5af61d55adbe 104 @staticmethod
screamer 7:5af61d55adbe 105 def __add_paths_to_progen(data):
screamer 7:5af61d55adbe 106 out = {}
screamer 7:5af61d55adbe 107 for key, value in data.items():
screamer 7:5af61d55adbe 108 if isinstance(value, dict):
screamer 7:5af61d55adbe 109 out[key] = Target.__add_paths_to_progen(value)
screamer 7:5af61d55adbe 110 elif key == "template":
screamer 7:5af61d55adbe 111 out[key] = [os.path.join(os.path.dirname(__file__), 'export', v) for v in value]
screamer 7:5af61d55adbe 112 else:
screamer 7:5af61d55adbe 113 out[key] = value
screamer 7:5af61d55adbe 114 return out
screamer 0:66f3b5499f7f 115
screamer 7:5af61d55adbe 116 # Comute the value of a given target attribute
screamer 7:5af61d55adbe 117 def __getattr_helper(self, attrname):
screamer 7:5af61d55adbe 118 tdata = self.get_json_target_data()
screamer 7:5af61d55adbe 119 if attrname in self.__cumulative_attributes:
screamer 7:5af61d55adbe 120 # For a cumulative attribute, figure out when it was defined the last time (in attribute
screamer 7:5af61d55adbe 121 # resolution order) then follow the "_add" and "_remove" data fields
screamer 7:5af61d55adbe 122 for idx, t in enumerate(self.resolution_order):
screamer 7:5af61d55adbe 123 if attrname in tdata[t[0]]: # the attribute was defined at this level in the resolution order
screamer 7:5af61d55adbe 124 def_idx = idx
screamer 7:5af61d55adbe 125 break
screamer 7:5af61d55adbe 126 else:
screamer 7:5af61d55adbe 127 raise AttributeError("Attribute '%s' not found in target '%s'" % (attrname, self.name))
screamer 7:5af61d55adbe 128 # Get the starting value of the attribute
screamer 7:5af61d55adbe 129 v = (tdata[self.resolution_order[def_idx][0]][attrname] or [])[:]
screamer 7:5af61d55adbe 130 # Traverse the resolution list in high inheritance to low inheritance level, left to right order
screamer 7:5af61d55adbe 131 # to figure out all the other classes that change the definition by adding or removing elements
screamer 7:5af61d55adbe 132 for idx in xrange(self.resolution_order[def_idx][1] - 1, -1, -1):
screamer 7:5af61d55adbe 133 same_level_targets = [t[0] for t in self.resolution_order if t[1] == idx]
screamer 7:5af61d55adbe 134 for t in same_level_targets:
screamer 7:5af61d55adbe 135 data = tdata[t]
screamer 7:5af61d55adbe 136 # Do we have anything to add ?
screamer 7:5af61d55adbe 137 if data.has_key(attrname + "_add"):
screamer 7:5af61d55adbe 138 v.extend(data[attrname + "_add"])
screamer 7:5af61d55adbe 139 # Do we have anything to remove ?
screamer 7:5af61d55adbe 140 if data.has_key(attrname + "_remove"):
screamer 7:5af61d55adbe 141 # Macros can be defined either without a value (MACRO) or with a value (MACRO=10).
screamer 7:5af61d55adbe 142 # When removing, we specify only the name of the macro, without the value. So we need
screamer 7:5af61d55adbe 143 # to create a mapping between the macro name and its value. This will work for
screamer 7:5af61d55adbe 144 # extra_labels and other type of arrays as well, since they fall into the "macros
screamer 7:5af61d55adbe 145 # without a value" category (simple definitions without a value).
screamer 7:5af61d55adbe 146 name_def_map = {}
screamer 7:5af61d55adbe 147 for crtv in v:
screamer 7:5af61d55adbe 148 if crtv.find('=') != -1:
screamer 7:5af61d55adbe 149 temp = crtv.split('=')
screamer 7:5af61d55adbe 150 if len(temp) != 2:
screamer 7:5af61d55adbe 151 raise ValueError("Invalid macro definition '%s'" % crtv)
screamer 7:5af61d55adbe 152 name_def_map[temp[0]] = crtv
screamer 7:5af61d55adbe 153 else:
screamer 7:5af61d55adbe 154 name_def_map[crtv] = crtv
screamer 7:5af61d55adbe 155 for e in data[attrname + "_remove"]:
screamer 7:5af61d55adbe 156 if not e in name_def_map:
screamer 7:5af61d55adbe 157 raise ValueError("Unable to remove '%s' in '%s.%s' since it doesn't exist" % (e, self.name, attrname))
screamer 7:5af61d55adbe 158 v.remove(name_def_map[e])
screamer 7:5af61d55adbe 159 return v
screamer 7:5af61d55adbe 160 # Look for the attribute in the class and its parents, as defined by the resolution order
screamer 7:5af61d55adbe 161 v = None
screamer 7:5af61d55adbe 162 for t in self.resolution_order:
screamer 7:5af61d55adbe 163 data = tdata[t[0]]
screamer 7:5af61d55adbe 164 if data.has_key(attrname):
screamer 7:5af61d55adbe 165 v = data[attrname]
screamer 7:5af61d55adbe 166 break
screamer 7:5af61d55adbe 167 else: # Attribute not found
screamer 7:5af61d55adbe 168 raise AttributeError("Attribute '%s' not found in target '%s'" % (attrname, self.name))
screamer 7:5af61d55adbe 169 # 'progen' needs the full path to the template (the path in JSON is relative to tools/export)
screamer 7:5af61d55adbe 170 return v if attrname != "progen" else self.__add_paths_to_progen(v)
screamer 0:66f3b5499f7f 171
screamer 7:5af61d55adbe 172 # Return the value of an attribute
screamer 7:5af61d55adbe 173 # This function only computes the attribute's value once, then adds it to the instance attributes
screamer 7:5af61d55adbe 174 # (in __dict__), so the next time it is returned directly
screamer 7:5af61d55adbe 175 def __getattr__(self, attrname):
screamer 7:5af61d55adbe 176 v = self.__getattr_helper(attrname)
screamer 7:5af61d55adbe 177 self.__dict__[attrname] = v
screamer 7:5af61d55adbe 178 return v
screamer 0:66f3b5499f7f 179
screamer 7:5af61d55adbe 180 # Add one or more new target(s) represented as a Python dictionary in 'new_targets'
screamer 7:5af61d55adbe 181 # It it an error to add a target with a name that exists in "targets.json"
screamer 7:5af61d55adbe 182 # However, it is OK to add a target that was previously added via "add_py_targets"
screamer 7:5af61d55adbe 183 # (this makes testing easier without changing the regular semantics)
screamer 7:5af61d55adbe 184 @staticmethod
screamer 7:5af61d55adbe 185 def add_py_targets(new_targets):
screamer 7:5af61d55adbe 186 crt_data = Target.get_json_target_data()
screamer 7:5af61d55adbe 187 # First add all elemnts to the internal dictionary
screamer 7:5af61d55adbe 188 for tk, tv in new_targets.items():
screamer 7:5af61d55adbe 189 if crt_data.has_key(tk) and (not tk in Target.__py_targets):
screamer 7:5af61d55adbe 190 raise Exception("Attempt to add target '%s' that already exists" % tk)
screamer 7:5af61d55adbe 191 crt_data[tk] = tv
screamer 7:5af61d55adbe 192 Target.__py_targets.add(tk)
screamer 7:5af61d55adbe 193 # Then create the new instances and update global variables if needed
screamer 7:5af61d55adbe 194 for tk, tv in new_targets.items():
screamer 7:5af61d55adbe 195 # Is the target already created?
screamer 7:5af61d55adbe 196 old_target = Target.__target_map.get(tk, None)
screamer 7:5af61d55adbe 197 # Instantiate this target. If it is public, update the data in
screamer 7:5af61d55adbe 198 # in TARGETS, TARGET_MAP, TARGET_NAMES
screamer 7:5af61d55adbe 199 new_target = Target(tk)
screamer 7:5af61d55adbe 200 if tv.get("public", True):
screamer 7:5af61d55adbe 201 if old_target: # remove the old target from TARGETS and TARGET_NAMES
screamer 7:5af61d55adbe 202 TARGETS.remove(old_target)
screamer 7:5af61d55adbe 203 TARGET_NAMES.remove(tk)
screamer 7:5af61d55adbe 204 # Add the new target
screamer 7:5af61d55adbe 205 TARGETS.append(new_target)
screamer 7:5af61d55adbe 206 TARGET_MAP[tk] = new_target
screamer 7:5af61d55adbe 207 TARGET_NAMES.append(tk)
screamer 7:5af61d55adbe 208 # Update the target cache
screamer 7:5af61d55adbe 209 Target.__target_map[tk] = new_target
screamer 0:66f3b5499f7f 210
screamer 7:5af61d55adbe 211 # Return the target instance starting from the target name
screamer 7:5af61d55adbe 212 @staticmethod
screamer 16:a6285a7e5cc6 213 @cached
screamer 7:5af61d55adbe 214 def get_target(name):
screamer 16:a6285a7e5cc6 215 return Target(name)
screamer 7:5af61d55adbe 216
screamer 7:5af61d55adbe 217 def __init__(self, name):
screamer 7:5af61d55adbe 218 self.name = name
screamer 7:5af61d55adbe 219
screamer 7:5af61d55adbe 220 # Compute resolution order once (it will be used later in __getattr__)
screamer 7:5af61d55adbe 221 self.resolution_order = self.__get_resolution_order(self.name, [])
screamer 7:5af61d55adbe 222 # Create also a list with only the names of the targets in the resolution order
screamer 7:5af61d55adbe 223 self.resolution_order_names = [t[0] for t in self.resolution_order]
screamer 0:66f3b5499f7f 224
screamer 13:ab47a20b66f0 225 @property
screamer 0:66f3b5499f7f 226 def program_cycle_s(self):
screamer 7:5af61d55adbe 227 try:
screamer 7:5af61d55adbe 228 return self.__getattr__("program_cycle_s")
screamer 7:5af61d55adbe 229 except AttributeError:
screamer 7:5af61d55adbe 230 return 4 if self.is_disk_virtual else 1.5
screamer 0:66f3b5499f7f 231
screamer 0:66f3b5499f7f 232 def get_labels(self):
screamer 13:ab47a20b66f0 233 labels = [self.name] + CORE_LABELS[self.core] + self.extra_labels
screamer 13:ab47a20b66f0 234 # Automatically define UVISOR_UNSUPPORTED if the target doesn't specifically
screamer 13:ab47a20b66f0 235 # define UVISOR_SUPPORTED
screamer 13:ab47a20b66f0 236 if not "UVISOR_SUPPORTED" in labels:
screamer 13:ab47a20b66f0 237 labels.append("UVISOR_UNSUPPORTED")
screamer 13:ab47a20b66f0 238 return labels
screamer 0:66f3b5499f7f 239
screamer 7:5af61d55adbe 240 # For now, this function only allows "post binary" hooks (hooks that are executed after
screamer 7:5af61d55adbe 241 # the binary image is extracted from the executable file)
screamer 0:66f3b5499f7f 242 def init_hooks(self, hook, toolchain_name):
screamer 7:5af61d55adbe 243 # If there's no hook, simply return
screamer 7:5af61d55adbe 244 try:
screamer 7:5af61d55adbe 245 hook_data = self.post_binary_hook
screamer 7:5af61d55adbe 246 except AttributeError:
screamer 7:5af61d55adbe 247 return
screamer 7:5af61d55adbe 248 # A hook was found. The hook's name is in the format "classname.functionname"
screamer 7:5af61d55adbe 249 temp = hook_data["function"].split(".")
screamer 7:5af61d55adbe 250 if len(temp) != 2:
screamer 7:5af61d55adbe 251 raise HookError("Invalid format for hook '%s' in target '%s' (must be 'class_name.function_name')" % (hook_data["function"], self.name))
screamer 7:5af61d55adbe 252 class_name, function_name = temp[0], temp[1]
screamer 7:5af61d55adbe 253 # "class_name" must refer to a class in this file, so check if the class exists
screamer 7:5af61d55adbe 254 mdata = self.get_module_data()
screamer 7:5af61d55adbe 255 if not mdata.has_key(class_name) or not inspect.isclass(mdata[class_name]):
screamer 7:5af61d55adbe 256 raise HookError("Class '%s' required by '%s' in target '%s' not found in targets.py" % (class_name, hook_data["function"], self.name))
screamer 7:5af61d55adbe 257 # "function_name" must refer to a static function inside class "class_name"
screamer 7:5af61d55adbe 258 cls = mdata[class_name]
screamer 7:5af61d55adbe 259 if (not hasattr(cls, function_name)) or (not inspect.isfunction(getattr(cls, function_name))):
screamer 7:5af61d55adbe 260 raise HookError("Static function '%s' required by '%s' in target '%s' not found in class '%s'" % (function_name, hook_data["function"], self.name, class_name))
screamer 7:5af61d55adbe 261 # Check if the hook specification also has target restrictions
screamer 7:5af61d55adbe 262 toolchain_restrictions = hook_data.get("toolchains", [])
screamer 7:5af61d55adbe 263 if toolchain_restrictions and (toolchain_name not in toolchain_restrictions):
screamer 7:5af61d55adbe 264 return
screamer 7:5af61d55adbe 265 # Finally, hook the requested function
screamer 7:5af61d55adbe 266 hook.hook_add_binary("post", getattr(cls, function_name))
screamer 0:66f3b5499f7f 267
screamer 7:5af61d55adbe 268 ########################################################################################################################
screamer 7:5af61d55adbe 269 # Target specific code goes in this section
screamer 7:5af61d55adbe 270 # This code can be invoked from the target description using the "post_binary_hook" key
screamer 0:66f3b5499f7f 271
screamer 7:5af61d55adbe 272 class LPCTargetCode:
screamer 0:66f3b5499f7f 273 @staticmethod
screamer 0:66f3b5499f7f 274 def lpc_patch(t_self, resources, elf, binf):
screamer 0:66f3b5499f7f 275 t_self.debug("LPC Patch: %s" % os.path.split(binf)[1])
screamer 0:66f3b5499f7f 276 patch(binf)
screamer 0:66f3b5499f7f 277
screamer 7:5af61d55adbe 278 class LPC4088Code:
screamer 0:66f3b5499f7f 279 @staticmethod
screamer 0:66f3b5499f7f 280 def binary_hook(t_self, resources, elf, binf):
screamer 0:66f3b5499f7f 281 if not os.path.isdir(binf):
screamer 0:66f3b5499f7f 282 # Regular binary file, nothing to do
screamer 7:5af61d55adbe 283 LPCTargetCode.lpc_patch(t_self, resources, elf, binf)
screamer 0:66f3b5499f7f 284 return
screamer 0:66f3b5499f7f 285 outbin = open(binf + ".temp", "wb")
screamer 0:66f3b5499f7f 286 partf = open(os.path.join(binf, "ER_IROM1"), "rb")
screamer 0:66f3b5499f7f 287 # Pad the fist part (internal flash) with 0xFF to 512k
screamer 0:66f3b5499f7f 288 data = partf.read()
screamer 0:66f3b5499f7f 289 outbin.write(data)
screamer 0:66f3b5499f7f 290 outbin.write('\xFF' * (512*1024 - len(data)))
screamer 0:66f3b5499f7f 291 partf.close()
screamer 0:66f3b5499f7f 292 # Read and append the second part (external flash) in chunks of fixed size
screamer 0:66f3b5499f7f 293 chunksize = 128 * 1024
screamer 0:66f3b5499f7f 294 partf = open(os.path.join(binf, "ER_IROM2"), "rb")
screamer 0:66f3b5499f7f 295 while True:
screamer 0:66f3b5499f7f 296 data = partf.read(chunksize)
screamer 0:66f3b5499f7f 297 outbin.write(data)
screamer 0:66f3b5499f7f 298 if len(data) < chunksize:
screamer 0:66f3b5499f7f 299 break
screamer 0:66f3b5499f7f 300 partf.close()
screamer 0:66f3b5499f7f 301 outbin.close()
screamer 0:66f3b5499f7f 302 # Remove the directory with the binary parts and rename the temporary
screamer 0:66f3b5499f7f 303 # file to 'binf'
screamer 0:66f3b5499f7f 304 shutil.rmtree(binf, True)
screamer 0:66f3b5499f7f 305 os.rename(binf + '.temp', binf)
screamer 0:66f3b5499f7f 306 t_self.debug("Generated custom binary file (internal flash + SPIFI)")
screamer 7:5af61d55adbe 307 LPCTargetCode.lpc_patch(t_self, resources, elf, binf)
screamer 0:66f3b5499f7f 308
screamer 7:5af61d55adbe 309 class TEENSY3_1Code:
screamer 0:66f3b5499f7f 310 @staticmethod
screamer 0:66f3b5499f7f 311 def binary_hook(t_self, resources, elf, binf):
screamer 0:66f3b5499f7f 312 from intelhex import IntelHex
screamer 0:66f3b5499f7f 313 binh = IntelHex()
screamer 0:66f3b5499f7f 314 binh.loadbin(binf, offset = 0)
screamer 0:66f3b5499f7f 315
screamer 0:66f3b5499f7f 316 with open(binf.replace(".bin", ".hex"), "w") as f:
screamer 0:66f3b5499f7f 317 binh.tofile(f, format='hex')
screamer 0:66f3b5499f7f 318
screamer 7:5af61d55adbe 319 class MTSCode:
screamer 0:66f3b5499f7f 320 @staticmethod
screamer 7:5af61d55adbe 321 def _combine_bins_helper(target_name, t_self, resources, elf, binf):
screamer 7:5af61d55adbe 322 loader = os.path.join(TOOLS_BOOTLOADERS, target_name, "bootloader.bin")
screamer 0:66f3b5499f7f 323 target = binf + ".tmp"
screamer 0:66f3b5499f7f 324 if not os.path.exists(loader):
screamer 0:66f3b5499f7f 325 print "Can't find bootloader binary: " + loader
screamer 0:66f3b5499f7f 326 return
screamer 0:66f3b5499f7f 327 outbin = open(target, 'w+b')
screamer 0:66f3b5499f7f 328 part = open(loader, 'rb')
screamer 0:66f3b5499f7f 329 data = part.read()
screamer 0:66f3b5499f7f 330 outbin.write(data)
screamer 0:66f3b5499f7f 331 outbin.write('\xFF' * (64*1024 - len(data)))
screamer 0:66f3b5499f7f 332 part.close()
screamer 0:66f3b5499f7f 333 part = open(binf, 'rb')
screamer 0:66f3b5499f7f 334 data = part.read()
screamer 0:66f3b5499f7f 335 outbin.write(data)
screamer 0:66f3b5499f7f 336 part.close()
screamer 0:66f3b5499f7f 337 outbin.seek(0, 0)
screamer 0:66f3b5499f7f 338 data = outbin.read()
screamer 0:66f3b5499f7f 339 outbin.seek(0, 1)
screamer 0:66f3b5499f7f 340 crc = struct.pack('<I', binascii.crc32(data) & 0xFFFFFFFF)
screamer 0:66f3b5499f7f 341 outbin.write(crc)
screamer 0:66f3b5499f7f 342 outbin.close()
screamer 0:66f3b5499f7f 343 os.remove(binf)
screamer 0:66f3b5499f7f 344 os.rename(target, binf)
screamer 0:66f3b5499f7f 345
screamer 0:66f3b5499f7f 346 @staticmethod
screamer 7:5af61d55adbe 347 def combine_bins_mts_dot(t_self, resources, elf, binf):
screamer 7:5af61d55adbe 348 MTSCode._combine_bins_helper("MTS_MDOT_F411RE", t_self, resources, elf, binf)
screamer 0:66f3b5499f7f 349
screamer 7:5af61d55adbe 350 @staticmethod
screamer 7:5af61d55adbe 351 def combine_bins_mts_dragonfly(t_self, resources, elf, binf):
screamer 7:5af61d55adbe 352 MTSCode._combine_bins_helper("MTS_DRAGONFLY_F411RE", t_self, resources, elf, binf)
screamer 0:66f3b5499f7f 353
screamer 7:5af61d55adbe 354 class MCU_NRF51Code:
screamer 0:66f3b5499f7f 355 @staticmethod
screamer 0:66f3b5499f7f 356 def binary_hook(t_self, resources, elf, binf):
screamer 0:66f3b5499f7f 357
screamer 0:66f3b5499f7f 358 # Scan to find the actual paths of soft device
screamer 0:66f3b5499f7f 359 sdf = None
screamer 0:66f3b5499f7f 360 for softdeviceAndOffsetEntry in t_self.target.EXPECTED_SOFTDEVICES_WITH_OFFSETS:
screamer 0:66f3b5499f7f 361 for hexf in resources.hex_files:
screamer 0:66f3b5499f7f 362 if hexf.find(softdeviceAndOffsetEntry['name']) != -1:
screamer 0:66f3b5499f7f 363 t_self.debug("SoftDevice file found %s." % softdeviceAndOffsetEntry['name'])
screamer 0:66f3b5499f7f 364 sdf = hexf
screamer 0:66f3b5499f7f 365
screamer 0:66f3b5499f7f 366 if sdf is not None: break
screamer 0:66f3b5499f7f 367 if sdf is not None: break
screamer 0:66f3b5499f7f 368
screamer 0:66f3b5499f7f 369 if sdf is None:
screamer 0:66f3b5499f7f 370 t_self.debug("Hex file not found. Aborting.")
screamer 0:66f3b5499f7f 371 return
screamer 0:66f3b5499f7f 372
screamer 0:66f3b5499f7f 373 # Look for bootloader file that matches this soft device or bootloader override image
screamer 0:66f3b5499f7f 374 blf = None
screamer 0:66f3b5499f7f 375 if t_self.target.MERGE_BOOTLOADER is True:
screamer 0:66f3b5499f7f 376 for hexf in resources.hex_files:
screamer 0:66f3b5499f7f 377 if hexf.find(t_self.target.OVERRIDE_BOOTLOADER_FILENAME) != -1:
screamer 0:66f3b5499f7f 378 t_self.debug("Bootloader file found %s." % t_self.target.OVERRIDE_BOOTLOADER_FILENAME)
screamer 0:66f3b5499f7f 379 blf = hexf
screamer 0:66f3b5499f7f 380 break
screamer 0:66f3b5499f7f 381 elif hexf.find(softdeviceAndOffsetEntry['boot']) != -1:
screamer 0:66f3b5499f7f 382 t_self.debug("Bootloader file found %s." % softdeviceAndOffsetEntry['boot'])
screamer 0:66f3b5499f7f 383 blf = hexf
screamer 0:66f3b5499f7f 384 break
screamer 0:66f3b5499f7f 385
screamer 0:66f3b5499f7f 386 # Merge user code with softdevice
screamer 0:66f3b5499f7f 387 from intelhex import IntelHex
screamer 0:66f3b5499f7f 388 binh = IntelHex()
screamer 0:66f3b5499f7f 389 binh.loadbin(binf, offset=softdeviceAndOffsetEntry['offset'])
screamer 0:66f3b5499f7f 390
screamer 0:66f3b5499f7f 391 if t_self.target.MERGE_SOFT_DEVICE is True:
screamer 0:66f3b5499f7f 392 t_self.debug("Merge SoftDevice file %s" % softdeviceAndOffsetEntry['name'])
screamer 0:66f3b5499f7f 393 sdh = IntelHex(sdf)
screamer 0:66f3b5499f7f 394 binh.merge(sdh)
screamer 0:66f3b5499f7f 395
screamer 0:66f3b5499f7f 396 if t_self.target.MERGE_BOOTLOADER is True and blf is not None:
screamer 0:66f3b5499f7f 397 t_self.debug("Merge BootLoader file %s" % blf)
screamer 0:66f3b5499f7f 398 blh = IntelHex(blf)
screamer 0:66f3b5499f7f 399 binh.merge(blh)
screamer 0:66f3b5499f7f 400
screamer 0:66f3b5499f7f 401 with open(binf.replace(".bin", ".hex"), "w") as f:
screamer 0:66f3b5499f7f 402 binh.tofile(f, format='hex')
screamer 0:66f3b5499f7f 403
screamer 7:5af61d55adbe 404 ########################################################################################################################
screamer 0:66f3b5499f7f 405
screamer 7:5af61d55adbe 406 # Instantiate all public targets
screamer 7:5af61d55adbe 407 TARGETS = [Target.get_target(name) for name, value in Target.get_json_target_data().items() if value.get("public", True)]
screamer 0:66f3b5499f7f 408
screamer 0:66f3b5499f7f 409 # Map each target name to its unique instance
screamer 7:5af61d55adbe 410 TARGET_MAP = dict([(t.name, t) for t in TARGETS])
screamer 0:66f3b5499f7f 411
screamer 0:66f3b5499f7f 412 TARGET_NAMES = TARGET_MAP.keys()
screamer 0:66f3b5499f7f 413
screamer 0:66f3b5499f7f 414 # Some targets with different name have the same exporters
screamer 7:5af61d55adbe 415 EXPORT_MAP = {}
screamer 0:66f3b5499f7f 416
screamer 0:66f3b5499f7f 417 # Detection APIs
screamer 0:66f3b5499f7f 418 def get_target_detect_codes():
screamer 0:66f3b5499f7f 419 """ Returns dictionary mapping detect_code -> platform_name
screamer 0:66f3b5499f7f 420 """
screamer 0:66f3b5499f7f 421 result = {}
screamer 0:66f3b5499f7f 422 for target in TARGETS:
screamer 0:66f3b5499f7f 423 for detect_code in target.detect_code:
screamer 0:66f3b5499f7f 424 result[detect_code] = target.name
screamer 0:66f3b5499f7f 425 return result
screamer 16:a6285a7e5cc6 426
screamer 16:a6285a7e5cc6 427 # Sets the location of the JSON file that contains the targets
screamer 16:a6285a7e5cc6 428 def set_targets_json_location(location):
screamer 16:a6285a7e5cc6 429 # First instruct Target about the new location
screamer 16:a6285a7e5cc6 430 Target.set_targets_json_location(location)
screamer 16:a6285a7e5cc6 431 # Then re-initialize TARGETS, TARGET_MAP and TARGET_NAMES
screamer 16:a6285a7e5cc6 432 # The re-initialization does not create new variables, it keeps the old ones instead
screamer 16:a6285a7e5cc6 433 # This ensures compatibility with code that does "from tools.targets import TARGET_NAMES"
screamer 16:a6285a7e5cc6 434 TARGETS[:] = [Target.get_target(name) for name, value in Target.get_json_target_data().items() if value.get("public", True)]
screamer 16:a6285a7e5cc6 435 TARGET_MAP.clear()
screamer 16:a6285a7e5cc6 436 TARGET_MAP.update(dict([(t.name, t) for t in TARGETS]))
screamer 16:a6285a7e5cc6 437 TARGET_NAMES[:] = TARGET_MAP.keys()