S6E1C device support

[jfolerka]

Hello,

I'm trying to set up a development environment for a S6E1C32D MCU from Cypress semiconductor. My development hardware is the FM0-64L-S6E1C3 starter kit. I'm using Visual Studio Code and the GNU Arm Embedded Toolchain along with pyOCD.

I created the following pyOCD_user.py script to add support for my target by following the memory map of the device and by running the generate_flash_algo.py script to create a flash algorithm Python dictionary out of the FLM file for the target. The problem I'm seeing is that only the first sector is programmed. This device supports writing across sector boundaries and my test firmware image doesn't contain any holes from 0x0 to 0x99F0.

# Cypress S6E1C32x devices
FLASH_ALGO_S6E1C32X0 = {
    'load_address' : 0x20000000,

    # Flash algorithm as a hex string
    'instructions': [
    0xe00abe00,
    0xb5102100, 0x460a43c9, 0xf90df000, 0xbd102000, 0xf000b510, 0x2000f91e, 0xb510bd10, 0xf8c5f000,
    0xb510bd10, 0xf927f000, 0xb510bd10, 0xf86af000, 0x0000bd10, 0x49b348b4, 0x43c96001, 0x49b36001,
    0x72082000, 0x20014770, 0x68400500, 0x20004770, 0xb50e4770, 0x466a2100, 0x71117011, 0x00032101,
    0xf95af000, 0x12070405, 0x002a2018, 0x43087810, 0x7810e005, 0x70104308, 0x22207810, 0x7010e00f,
    0x43087910, 0xe0177110, 0x43087810, 0x78107010, 0xe0042204, 0x43087810, 0x78107010, 0x43102210,
    0xe7ec466a, 0x43087810, 0x78117010, 0x43012008, 0x79117011, 0x71114301, 0x07802001, 0x72117a01,
    0x466a7a01, 0x7a117211, 0xd5010789, 0xbd0e2001, 0x78127a11, 0x466a4011, 0x42917912, 0x2000d1f0,
    0x488bbd0e, 0x4448b500, 0x21f06882, 0x68828011, 0x46082100, 0xffadf7ff, 0xd0002800, 0xbd002001,
    0x47702000, 0x4f82b5f7, 0x4614b081, 0x9d01444f, 0x210068ba, 0xf7ff4608, 0x2800ff9c, 0x2001d002,
    0xbdf0b004, 0x26009802, 0x08401c40, 0xe0219000, 0x68bb8821, 0x221520aa, 0x189a01d2, 0x68bb8310,
    0x22152055, 0x189a0192, 0x68bb8090, 0x221520a0, 0x189a01d2, 0x88208310, 0x462a8028, 0xf7ff2001,
    0x2800ff78, 0xf7ffd002, 0xe7d8ffbc, 0x1cad1ca4, 0x1c769800, 0xd8db42b0, 0xe7d12000, 0x2001b501,
    0x68400500, 0x42889900, 0x466ad004, 0x48612104, 0xffb8f7ff, 0xbd082000, 0xb5004a5d, 0x444a2102,
    0xf7ff04c8, 0x2000ffaf, 0xb5f0bd00, 0x444c4c58, 0x210068a2, 0xf7ff4608, 0x2800ff4c, 0x2001d001,
    0x68a0bdf0, 0x68a28801, 0x201526aa, 0x181201c0, 0x68a58316, 0x10432255, 0x80aa18ed, 0x258068a7,
    0x833d183f, 0x182d68a5, 0x68a5832e, 0x809a18eb, 0x221068a3, 0x83021818, 0x200268a2, 0xff29f7ff,
    0xd0dd2800, 0xff6df7ff, 0xb510e7d9, 0x05002001, 0x4c3f6840, 0x6060444c, 0xffc7f7ff, 0xf7ff6860,
    0x2000ffad, 0xb517bd10, 0x98004c39, 0x60a0444c, 0xff00f7ff, 0xff55f7ff, 0x60209801, 0x1c409802,
    0x9802d001, 0x2001e002, 0x68400500, 0x20006060, 0x482fbd1e, 0x4448b500, 0xf7ff6840, 0xf7ffff8f,
    0x2000ff40, 0xb501bd00, 0x9801b081, 0x46698800, 0x88088008, 0xb5f1bd0c, 0x444c4c25, 0x210068a2,
    0xf7ff4608, 0x2800fee6, 0x2001d001, 0x9800bdf8, 0x880168a2, 0x201526aa, 0x181201c0, 0x68a58316,
    0x10432255, 0x80aa18ed, 0x258068a7, 0x833d183f, 0x182868a5, 0x68a08306, 0x808218c0, 0x20309a00,
    0x20038010, 0xf7ff9a00, 0x2800fec4, 0xf7ffd0de, 0xe7daff08, 0xb500480e, 0x68824448, 0x801121b0,
    0x21006882, 0xf7ff2004, 0x2800feb4, 0xf7ffd002, 0x2001fef8, 0x4906bd00, 0x44492030, 0x80086889,
    0x47702000, 0x1acce551, 0x40011c00, 0x40011000, 0x00000004, 0x00100004, 0x4674b430, 0x78251e64,
    0x42ab1c64, 0x461dd200, 0x005b5d63, 0xbc3018e3, 0x00004718, 0x00000000, 0x00000001, 0x00000000,
    0x00000000
    ],

    # Relative function addresses
    'pc_init': 0x20000005,
    'pc_unInit': 0x20000015,
    'pc_program_page': 0x2000002f,
    'pc_erase_sector': 0x20000027,
    'pc_eraseAll': 0x2000001f,

    'static_base' : 0x20000000 + 0x00000004 + 0x00000334,
    'begin_stack' : 0x20000548,
    'begin_data' : 0x20000000 + 0x1000,
    'page_size' : 0x400,
    'analyzer_supported' : True,
    'analyzer_address' : 0x20003000,
    'page_buffers' : [0x20001000, 0x20001400],   # Enable double buffering
    'min_program_length' : 0x4,

    # Relative region addresses and sizes
    'ro_start': 0x0,
    'ro_size': 0x334,
    'rw_start': 0x334,
    'rw_size': 0x10,
    'zi_start': 0x344,
    'zi_size': 0x0,

    # Flash information
    'flash_start': 0x0,
    'flash_size': 0x1fff0,
    'sector_sizes': (
        (0x0, 0x1ff0),
        (0x1ff0, 0x2000),
        (0x7ff0, 0x8000),
    )
}

def will_connect():

    LOG.info("Updating device memory map")
    LOG.info("Session keep_unwritten: %s", session.options.get('keep_unwritten'))
    LOG.info("Smart flash: %s", session.options.get('smart_flash'))

    target.memory_map = MemoryMap(
                FlashRegion(    name="SA0",
                                start=0x00000000,
                                length=0x1FF0,
                                sector_size=0x1FF0,
                                page_size=0x3FE,
                                phrase_size=1,
                                access='rx',
                                is_boot_memory=True,
                                is_default=True,
                                is_cacheable=True,
                                erase_sector_weight=0.9,
                                erased_byte_value=0xFF,
                                algo=FLASH_ALGO_S6E1C32X0,
                                ),
                FlashRegion(    name="SA1_3",
                                start=0x1FF0,
                                length=0x6000,
                                sector_size=0x2000,
                                page_size=0x400,
                                phrase_size=1,
                                access='rx',
                                is_boot_memory=False,
                                is_default=False,
                                is_cacheable=True,
                                erase_sector_weight=0.9,
                                erased_byte_value=0xFF,
                                algo=FLASH_ALGO_S6E1C32X0
                                ),
                FlashRegion(    name="SA4_6",
                                start=0x7FF0,
                                length=0x18000,
                                sector_size=0x8000,
                                page_size=0x400,
                                phrase_size=1,
                                access='rx',
                                is_boot_memory=False,
                                is_default=False,
                                is_cacheable=True,
                                erase_sector_weight=2.7,
                                erased_byte_value=0xFF,
                                algo=FLASH_ALGO_S6E1C32X0
                                ),
            
                RamRegion(      name="SRAM",
                                start=0x20000000,
                                length=0x4000,
                                is_default=True)
                )
    LOG.info("%s", repr(target.memory_map))

Initially I did not have the page_size attribute set on any of the FlashRegion elements. When I first put them in, I would get this error:
pyocd.core.exceptions.FlashFailure: attempt to program invalid flash address (address 0x00000000)
here is a complete log file: pyOCD_log0.log

I then added option -O keep_unwritten=False to the command line and the error went away but something looks suspicious:
===0012580:DEBUG:flash:call erase_sector(6000)
Is a call to erase_sector at 0x6000 appropriate when the base address was set to 0x1FF0 by the Init function?
Here is the log: pyOCD_log1.log

Likewise, the first write at 0x1c00 would put it back in the sector that was previously programmed (writing flash twice?). Shouldn't this first write be to 0x0 if the base address was set to 0x1FF0?
0012674:DEBUG:flash:start_program_page_with_buffer(addr=1c00, len=400, data=20001000)

The flash is correctly programmed for the first sector only. The rest of the memory is left blank.

If I disable double-buffering and change the page size to 0x2000:

# Cypress S6E1C32x devices
FLASH_ALGO_S6E1C32X0 = {
    'load_address' : 0x20000000,

    # Flash algorithm as a hex string
    'instructions': [
    0xe00abe00,
    0xb5102100, 0x460a43c9, 0xf90df000, 0xbd102000, 0xf000b510, 0x2000f91e, 0xb510bd10, 0xf8c5f000,
    0xb510bd10, 0xf927f000, 0xb510bd10, 0xf86af000, 0x0000bd10, 0x49b348b4, 0x43c96001, 0x49b36001,
    0x72082000, 0x20014770, 0x68400500, 0x20004770, 0xb50e4770, 0x466a2100, 0x71117011, 0x00032101,
    0xf95af000, 0x12070405, 0x002a2018, 0x43087810, 0x7810e005, 0x70104308, 0x22207810, 0x7010e00f,
    0x43087910, 0xe0177110, 0x43087810, 0x78107010, 0xe0042204, 0x43087810, 0x78107010, 0x43102210,
    0xe7ec466a, 0x43087810, 0x78117010, 0x43012008, 0x79117011, 0x71114301, 0x07802001, 0x72117a01,
    0x466a7a01, 0x7a117211, 0xd5010789, 0xbd0e2001, 0x78127a11, 0x466a4011, 0x42917912, 0x2000d1f0,
    0x488bbd0e, 0x4448b500, 0x21f06882, 0x68828011, 0x46082100, 0xffadf7ff, 0xd0002800, 0xbd002001,
    0x47702000, 0x4f82b5f7, 0x4614b081, 0x9d01444f, 0x210068ba, 0xf7ff4608, 0x2800ff9c, 0x2001d002,
    0xbdf0b004, 0x26009802, 0x08401c40, 0xe0219000, 0x68bb8821, 0x221520aa, 0x189a01d2, 0x68bb8310,
    0x22152055, 0x189a0192, 0x68bb8090, 0x221520a0, 0x189a01d2, 0x88208310, 0x462a8028, 0xf7ff2001,
    0x2800ff78, 0xf7ffd002, 0xe7d8ffbc, 0x1cad1ca4, 0x1c769800, 0xd8db42b0, 0xe7d12000, 0x2001b501,
    0x68400500, 0x42889900, 0x466ad004, 0x48612104, 0xffb8f7ff, 0xbd082000, 0xb5004a5d, 0x444a2102,
    0xf7ff04c8, 0x2000ffaf, 0xb5f0bd00, 0x444c4c58, 0x210068a2, 0xf7ff4608, 0x2800ff4c, 0x2001d001,
    0x68a0bdf0, 0x68a28801, 0x201526aa, 0x181201c0, 0x68a58316, 0x10432255, 0x80aa18ed, 0x258068a7,
    0x833d183f, 0x182d68a5, 0x68a5832e, 0x809a18eb, 0x221068a3, 0x83021818, 0x200268a2, 0xff29f7ff,
    0xd0dd2800, 0xff6df7ff, 0xb510e7d9, 0x05002001, 0x4c3f6840, 0x6060444c, 0xffc7f7ff, 0xf7ff6860,
    0x2000ffad, 0xb517bd10, 0x98004c39, 0x60a0444c, 0xff00f7ff, 0xff55f7ff, 0x60209801, 0x1c409802,
    0x9802d001, 0x2001e002, 0x68400500, 0x20006060, 0x482fbd1e, 0x4448b500, 0xf7ff6840, 0xf7ffff8f,
    0x2000ff40, 0xb501bd00, 0x9801b081, 0x46698800, 0x88088008, 0xb5f1bd0c, 0x444c4c25, 0x210068a2,
    0xf7ff4608, 0x2800fee6, 0x2001d001, 0x9800bdf8, 0x880168a2, 0x201526aa, 0x181201c0, 0x68a58316,
    0x10432255, 0x80aa18ed, 0x258068a7, 0x833d183f, 0x182868a5, 0x68a08306, 0x808218c0, 0x20309a00,
    0x20038010, 0xf7ff9a00, 0x2800fec4, 0xf7ffd0de, 0xe7daff08, 0xb500480e, 0x68824448, 0x801121b0,
    0x21006882, 0xf7ff2004, 0x2800feb4, 0xf7ffd002, 0x2001fef8, 0x4906bd00, 0x44492030, 0x80086889,
    0x47702000, 0x1acce551, 0x40011c00, 0x40011000, 0x00000004, 0x00100004, 0x4674b430, 0x78251e64,
    0x42ab1c64, 0x461dd200, 0x005b5d63, 0xbc3018e3, 0x00004718, 0x00000000, 0x00000001, 0x00000000,
    0x00000000
    ],

    # Relative function addresses
    'pc_init': 0x20000005,
    'pc_unInit': 0x20000015,
    'pc_program_page': 0x2000002f,
    'pc_erase_sector': 0x20000027,
    'pc_eraseAll': 0x2000001f,

    'static_base' : 0x20000000 + 0x00000004 + 0x00000334,
    'begin_stack' : 0x20000548,
    'begin_data' : 0x20000000 + 0x1000,
    'page_size' : 0x2000,
    'analyzer_supported' : True,
    'analyzer_address' : 0x20003000,
    'page_buffers' : [0x20001000],  # Disable double buffering
    'min_program_length' : 0x4,

    # Relative region addresses and sizes
    'ro_start': 0x0,
    'ro_size': 0x334,
    'rw_start': 0x334,
    'rw_size': 0x10,
    'zi_start': 0x344,
    'zi_size': 0x0,

    # Flash information
    'flash_start': 0x0,
    'flash_size': 0x1fff0,
    'sector_sizes': (
        (0x0, 0x1ff0),
        (0x1ff0, 0x2000),
        (0x7ff0, 0x8000),
    )
}

def will_connect():

    LOG.info("Updating device memory map")
    LOG.info("Session keep_unwritten: %s", session.options.get('keep_unwritten'))
    LOG.info("Smart flash: %s", session.options.get('smart_flash'))

    target.memory_map = MemoryMap(
                FlashRegion(    name="SA0",
                                start=0x00000000,
                                length=0x1FF0,
                                sector_size=0x1FF0,
                                page_size=0x1FF0,
                                phrase_size=1,
                                access='rx',
                                is_boot_memory=True,
                                is_default=True,
                                is_cacheable=True,
                                erase_sector_weight=0.9,
                                erased_byte_value=0xFF,
                                algo=FLASH_ALGO_S6E1C32X0,
                                ),
                FlashRegion(    name="SA1_3",
                                start=0x1FF0,
                                length=0x6000,
                                sector_size=0x2000,
                                page_size=0x2000,
                                phrase_size=1,
                                access='rx',
                                is_boot_memory=False,
                                is_default=False,
                                is_cacheable=True,
                                erase_sector_weight=0.9,
                                erased_byte_value=0xFF,
                                algo=FLASH_ALGO_S6E1C32X0
                                ),
                FlashRegion(    name="SA4_6",
                                start=0x7FF0,
                                length=0x18000,
                                sector_size=0x8000,
                                page_size=0x2000,
                                phrase_size=1,
                                access='rx',
                                is_boot_memory=False,
                                is_default=False,
                                is_cacheable=True,
                                erase_sector_weight=2.7,
                                erased_byte_value=0xFF,
                                algo=FLASH_ALGO_S6E1C32X0
                                ),
            
                RamRegion(      name="SRAM",
                                start=0x20000000,
                                length=0x4000,
                                is_default=True)
                )
    LOG.info("%s", repr(target.memory_map))

I get the same result, only the first sector is flashed. Here is the log file: pyOCD_log2.log

I also added -O smart_flash=False and also got the same result. Here is the log file: pyOCD_log3.log

To remove a "black box" from the picture I created a very simple flash algorithm for this device using the guidance provided here and the procedures in this document.

Using "my" algorithm in the pyOCD_user.py script yielded some interesting results. Log file here: pyOCD_log4.log

• The first sector is flashed correctly
• The data for the sector starting at 0x1FF0 starts at 0x3FE0 and goes to 0x7FEF (the data that should have been in 0x5FFF is in 0x7FEF, all of the data is correct but shifted by 0x1FF0 bytes)
• The firmware image data from 0x6000 to 0x7FEF is not programmed
• The data for the sector starting at 0x7FF0 starts at 0xFFE0 (offset by 0x7FF0)

I may not have understood what the purpose of the device base address passed to Init is supposed to do. This version of my code keeps the base address as an offset to any subsequent calls to the memory clear/write/check functions. For a device such a this one with an oddly-sized sector and two other sector sizes, this seemed like a sensible interpretation since it makes everything else so much easier.

I changed "my" algorithm to take the address passed in from pyOCD as the absolute flash address to be programmed (base address always = 0) but the flash hardware times out and the programming fails. See log: pyOCD_log6.log
The following call is made twice:
0018338:DEBUG:flash:start_program_page_with_buffer(addr=7c00, len=400, data=20000430)
0019575:DEBUG:flash:start_program_page_with_buffer(addr=7c00, len=400, data=20000430)

• Any suggestions on how to get my device to program correctly?
• What is the correct usage of the base address passed to Init?
• Might there be a bug with the smart flash algorithm or the algorithm that calculates page address offsets with respect to sector start?
• Is it possible that the keep_unwritten feature also failed because of a bug with the page address calculation?

Thank you so much in advance!

[flit]

Hi @jfolerka! I guess you saw the CMSIS-Pack for the FM0+ family, since you used the FLM algo? Did you try using the pack's device support directly? Although, that probably won't help much since the flash is being troublesome.

Pyocd expects flash sectors to be evenly divisible by the page size.

I haven't read the MCU reference manual yet, but it certainly seems like I need to. I've never before encountered or heard of a device with flash that doesn't meet this requirement, but your statements that "This device supports writing across sector boundaries" and "a device such a this one with an oddly-sized sector" makes me suspect my view will soon be challenged! 😉

Given that, pyocd's flash programming logic will result in attempts to write at very unhappy addresses when the page and sector sizes don't align.

To answer other questions:

• The base address parameter (and all others) of the flash algo Init function is only used if the algo needs it, and most flash algos totally ignore all Init parameters.
• Smart flash will not change the address calculations. It only attempts to improve flash programming performance by not reprogramming unchanging data. (Though it can sometimes negatively affect performance if the flash is large and all pages are changing.)
• Yes, keep_unwritten also failed because of address calculation errors.

I'll read up on this device over the next few days so I understand how the flash works, and what the appropriate programming algorithm is. Unfortunately, this is one MCU family that I don't have, so I can't reproduce the issues.

[jfolerka]

Hi @flit, thanks for looking into this!

The FM0+ CMSIS-Pack only includes support for the S6E1A1 devices, so that's a no-go.

Pyocd expects flash sectors to be evenly divisible by the page size.

I noticed 🙂, I was also getting an error when I forced the page size to something that wasn't an integer factor of the sector size. I think that there might be some additional expectation that the page size will remain either the same or an integer multiple of the initial page size as you advance through the sectors, which causes a problem for this particular device. The greatest common factor between the sizes of the first sector and the rest is 16, which is awfully small for a page size🙁. I'll try with a page size of 16 and report my findings.

Let me know if/how I can assist with testing or anything else!

[jfolerka]

Hi @flit, I've got some interesting findings to report.

Went back and used "my" flash algo with the modification to program/erase directly to the address sent in from pyOCD. This time I changed the page_size to 0x10 for all sectors, see the log file: pyOCD_log9.log.

The flashing is painfully slow, as expected. This time however, the starting address of the "next" sector with a different sector_size is correct every time.

The flashing result this time is:

• the first sector is blank
• the remaining firmware image is programmed correctly on the subsequent sectors

I believe the first sector is blank because pyOCD is calling erase_sector(0) every time there is a new sector size (and obviously at the beginning):
0013990:DEBUG:flash:call erase_sector(0)
0027479:DEBUG:flash:call erase_sector(0) shouldn't be here??
0067055:DEBUG:flash:call erase_sector(0) shouldn't be here??

Just for fun, I left the page_size of the first sector at 0x10 and changed the rest of the sectors to 0x400. See log: pyOCD_log10.log

This time the address calculation seems to have choked again when the sector AND page sizes changed:
0025489:DEBUG:flash:start_program_page_with_buffer(addr=1fe0, len=10, data=20000470)
0025887:DEBUG:flash:call erase_sector(0)
0026829:DEBUG:flash:start_program_page_with_buffer(addr=1c00, len=400, data=20000470) oops! but succeeds since sector 0 was just erased

0028364:DEBUG:flash:start_program_page_with_buffer(addr=7c00, len=400, data=20000470)
0028763:DEBUG:flash:call erase_sector(0) shouldn't be here??
0029589:DEBUG:flash:start_program_page_with_buffer(addr=7c00, len=400, data=20000470) angry flash hardware, fails

It seems that the address calculation logic assumes the page size can't change from whatever the starting value is, and there seems to be some error introduced when the sector size changes for the erase_sector(0) call to be made every time.

Voilà I think these cases illustrate where the quirks are 🙂