Fetch ram/rom start/size

tools/config/__init__.py

@@ -71,6 +71,14 @@
     "ETHERNET_HOST",
 ]
 
+# List of all possible ram memories that can be available for a target
+RAM_ALL_MEMORIES = ['IRAM1', 'IRAM2', 'IRAM3', 'IRAM4', 'SRAM_OC', \
+                    'SRAM_ITC', 'SRAM_DTC', 'SRAM_UPPER', 'SRAM_LOWER', \
+                    'SRAM']
+
+# List of all possible rom memories that can be available for a target
+ROM_ALL_MEMORIES = ['IROM1', 'PROGRAM_FLASH', 'IROM2']
+
 # Base class for all configuration exceptions
 class ConfigException(Exception):
     """Config system only exception. Makes it easier to distinguish config
@@ -588,8 +596,6 @@ def sectors(self):
         raise ConfigException("No sector info available")
 
     def _get_cmsis_part(self):
-        if not getattr(self.target, "bootloader_supported", False):
-            raise ConfigException("Bootloader not supported on this target.")
         if not hasattr(self.target, "device_name"):
             raise ConfigException("Bootloader not supported on this target: "
                                   "targets.json `device_name` not specified.")
@@ -610,24 +616,68 @@ def _get_mem_specs(self, memories, cmsis_part, exception_text):
                 continue
         raise ConfigException(exception_text)
 
-    @property
-    def rom(self):
-        """Get rom information as a pair of start_addr, size"""
+    def get_all_active_memories(self, memory_list):
+        """Get information of all available rom/ram memories in the form of dictionary 
+        {Memory: [start_addr, size]}. Takes in the argument, a list of all available 
+        regions within the ram/rom memory"""
         # Override rom_start/rom_size
         #
         # This is usually done for a target which:
         # 1. Doesn't support CMSIS pack, or
         # 2. Supports TrustZone and user needs to change its flash partition
-        cmsis_part = self._get_cmsis_part()
-        rom_start, rom_size = self._get_mem_specs(
-            ["IROM1", "PROGRAM_FLASH"],
-            cmsis_part,
-            "Not enough information in CMSIS packs to build a bootloader "
-            "project"
-        )
-        rom_start = int(getattr(self.target, "mbed_rom_start", False) or rom_start, 0)
-        rom_size = int(getattr(self.target, "mbed_rom_size", False) or rom_size, 0)
-        return (rom_start, rom_size)
+
+        available_memories = {}
+        # Counter to keep track of ROM/RAM memories supported by target
+        active_memory_counter = 0
+        # Find which memory we are dealing with, RAM/ROM
+        active_memory = 'RAM' if any('RAM' in mem_list for mem_list in memory_list) else 'ROM'
+
+        try:
+            cmsis_part = self._get_cmsis_part()
+        except ConfigException:
+            """ If the target doesn't exits in cmsis, but present in targets.json
+            with ram and rom start/size defined"""
+            if getattr(self.target, "mbed_ram_start") and \
+               getattr(self.target, "mbed_rom_start"):
+                mem_start = int(getattr(self.target, "mbed_" + active_memory.lower() + "_start"), 0)
+                mem_size = int(getattr(self.target, "mbed_" + active_memory.lower() + "_size"), 0)
+                available_memories[active_memory] = [mem_start, mem_size]
+                return available_memories
+            else:
+                raise ConfigException("Bootloader not supported on this target. "
+                                      "ram/rom start/size not found in "
+                                      "targets.json.")
+
+        present_memories = set(cmsis_part['memory'].keys())
+        valid_memories = set(memory_list).intersection(present_memories)
+
+        for memory in valid_memories:
+            mem_start, mem_size = self._get_mem_specs(
+                [memory],
+                cmsis_part,
+                "Not enough information in CMSIS packs to build a bootloader "
+                "project"
+            )
+            if memory=='IROM1' or memory=='PROGRAM_FLASH':
+                mem_start = getattr(self.target, "mbed_rom_start", False) or mem_start
+                mem_size = getattr(self.target, "mbed_rom_size", False) or mem_size
+                memory = 'ROM'
+            elif memory == 'IRAM1' or memory == 'SRAM_OC' or \
+                memory == 'SRAM_UPPER' or memory == 'SRAM':
+                if (self.has_ram_regions):
+                    continue
+                mem_start = getattr(self.target, "mbed_ram_start", False) or mem_start
+                mem_size = getattr(self.target, "mbed_ram_size", False) or mem_size
+                memory = 'RAM'
+            else:
+                active_memory_counter += 1
+                memory = active_memory + str(active_memory_counter)
+
+            mem_start = int(mem_start, 0)
+            mem_size = int(mem_size, 0)
+            available_memories[memory] = [mem_start, mem_size]
+
+        return available_memories
 
     @property
     def ram_regions(self):
@@ -650,16 +700,18 @@ def ram_regions(self):
     @property
     def regions(self):
         """Generate a list of regions from the config"""
+        if not getattr(self.target, "bootloader_supported", False):
+            raise ConfigException("Bootloader not supported on this target.")
         if  ((self.target.bootloader_img or self.target.restrict_size) and
              (self.target.mbed_app_start or self.target.mbed_app_size)):
             raise ConfigException(
-                "target.bootloader_img and target.restirct_size are "
+                "target.bootloader_img and target.restrict_size are "
                 "incompatible with target.mbed_app_start and "
                 "target.mbed_app_size")
         if self.target.bootloader_img or self.target.restrict_size:
-            return self._generate_bootloader_build(*self.rom)
+            return self._generate_bootloader_build(self.get_all_active_memories(ROM_ALL_MEMORIES))
         else:
-            return self._generate_linker_overrides(*self.rom)
+            return self._generate_linker_overrides(self.get_all_active_memories(ROM_ALL_MEMORIES))
 
     @staticmethod
     def header_member_size(member):
@@ -696,7 +748,8 @@ def _assign_new_offset(rom_start, start, new_offset, region_name):
                 "Can not place % region inside previous region" % region_name)
         return newstart
 
-    def _generate_bootloader_build(self, rom_start, rom_size):
+    def _generate_bootloader_build(self, rom_memories):
+        rom_start, rom_size = rom_memories.get('ROM')
         start = rom_start
         rom_end = rom_start + rom_size
         if self.target.bootloader_img:
@@ -780,7 +833,8 @@ def report(self):
         return {'app_config': self.app_config_location,
                 'library_configs': map(relpath, self.processed_configs.keys())}
 
-    def _generate_linker_overrides(self, rom_start, rom_size):
+    def _generate_linker_overrides(self, rom_memories):
+        rom_start, rom_size = rom_memories.get('ROM')
         if self.target.mbed_app_start is not None:
             start = int(self.target.mbed_app_start, 0)
         else:

tools/toolchains/__init__.py

@@ -40,7 +40,7 @@
 from ..notifier.term import TerminalNotifier
 from ..resources import FileType
 from ..memap import MemapParser
-from ..config import ConfigException
+from ..config import (ConfigException, RAM_ALL_MEMORIES, ROM_ALL_MEMORIES)
 
 
 #Disables multiprocessing if set to higher number than the host machine CPUs
@@ -693,14 +693,19 @@ def mem_stats(self, map):
 
         return None
 
-    def _add_defines_from_region(self, region, suffixes=['_ADDR', '_SIZE']):
+    def _add_defines_from_region(self, region, linker_define=False, suffixes=['_ADDR', '_SIZE']):
         for define in [(region.name.upper() + suffixes[0], region.start),
                        (region.name.upper() + suffixes[1], region.size)]:
             define_string = "-D%s=0x%x" %  define
             self.cc.append(define_string)
             self.cppc.append(define_string)
             self.flags["common"].append(define_string)
-
+            if linker_define:
+                ld_string = ("%s" % define[0], "0x%x" % define[1])
+                ld_string = self.make_ld_define(*ld_string)
+                self.ld.append(ld_string)
+                self.flags["ld"].append(ld_string)
+
     def _add_all_regions(self, region_list, active_region_name):
         for region in region_list:
             self._add_defines_from_region(region)
@@ -732,13 +737,31 @@ def add_regions(self):
                 ", ".join(r.name for r in regions)
             ))
             self._add_all_regions(regions, "MBED_RAM")
+
+        Region = namedtuple("Region", "name start size")
+
+        try:
+            # Add all available ROM regions to build profile
+            rom_available_regions = self.config.get_all_active_memories(ROM_ALL_MEMORIES)
+            for key, value in rom_available_regions.items():
+                rom_start, rom_size = value
+                self._add_defines_from_region(
+                    Region("MBED_" + key, rom_start, rom_size),
+                    True,
+                    suffixes=["_START", "_SIZE"]
+                )
+        except ConfigException:
+            pass
         try:
-            rom_start, rom_size = self.config.rom
-            Region = namedtuple("Region", "name start size")
-            self._add_defines_from_region(
-                Region("MBED_ROM", rom_start, rom_size),
-                suffixes=["_START", "_SIZE"]
-            )
+            # Add all available RAM regions to build profile
+            ram_available_regions = self.config.get_all_active_memories(RAM_ALL_MEMORIES)
+            for key, value in ram_available_regions.items():
+                ram_start, ram_size = value
+                self._add_defines_from_region(
+                    Region("MBED_" + key, ram_start, ram_size),
+                    True,
+                    suffixes=["_START", "_SIZE"]
+                )
         except ConfigException:
             pass