the other jimmy / mbed-sdk-tools

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Fork of mbed-sdk-tools by mbed official

targets.py@30:f12ce67666d0, 2016-08-29 (annotated)

Committer:
screamer
Date:
Mon Aug 29 11:56:59 2016 +0100
Revision:
30:f12ce67666d0
Parent:
29:1210849dba19
Child:
31:182518299918
Update tools from the mbed OS 5.1.2 release (instead of master)

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