AN233648  PSoC™ 6 MCU: Modify CY8CPROTO-062-4343W board to work with an external flash memory   

• CY8CPROTO-062-4343W PSoC™ 6 W-Fi Bluetooth® prototyping kit board
• SMT socket-wide SOIC-16
• 8-pin headers
• Cutter
• Soldering machine

Prepare the board and SMT socket-wide SOIC-16, and 8-pin headers. You may also need a cutter to remove the existing flash device and a soldering machine to solder the socket and pin headers.

1. Remove the attached flash with the cutter. Gently cut off the flash lead frames and then remove the leftovers with solders. Be careful not to strip off the PCB pattern
2. Fit the SMT socket-wide SOIC-16 into the PCB footprint. The existing flash on the board is in SOIC 16 pin package, so it is compatible with the new socket. Solder the socket along the footprint
3. Solder the pin headers to GND, VDDIO, pins 11.6, 11.5, 11.7, 11.2, 11.3, and 11.4 pin holes. See Table 1 and Figure 3
4. Make sure that all pins are connected

Test the flash devices as follows:

• To test any flash device in SOIC-16 package, replace the flash chip in the socket as shown in Figure 5
• To test flash devices in other package types or to test the flash device that is attached to another board like shown in Figure 6, use the pin header connector. In this case, keep the socket empty because the socket flash signal and external signal through pin header can be overlapped

Figure 5 and Figure 6 show the boards with the hardware modifications:

• Figure 5 shows the flash device in the socket being tested
• Figure 6 shows an external flash device on another board being tested. Note that the jumpers are connected to the pin header while the socket is empty

PSoC™ 6 MCU boards use Eclipse IDE for ModusToolbox™ and C language for programming.

Download the software from https://www.cypress.com/products/modustoolbox#tabs-0-bottom_side-6.

The SMIF Component implements an SPI-based communication hardware block for interfacing external memory devices with the PSoC™ 6 MCU device. The firmware uses the source code (cy_smif_memconfig.c and cy_smif_memconfig.h files) generated from the SMIF configurator. This source code defines the data structures that hold the memory configuration.

1. On Eclipse IDE for ModusToolbox™ software, import example project into your project. Do one of the following:
   • Select File > New > ModusToolbox™ Application
   • Click New Application on the Start tab on the Quick Panel
     
     
2. Choose the board support package (BSP) for the CY8CPROTO-062-4343W board and then click Next
   
   
3. On the Select Application window, select QSPI Flash Read Write. Optionally, change the application name
   
   

The following screen appears when the selected example is successfully imported:

Note that the application already includes supports for some flash operation commands for QSPI Flash Read and Write operation. The cy_smif_memslot.h file includes code to support the WRR(01h), WRDI(04h), RDSR1(05h), WREN(06h), 4QPP(34h), RDCR(35h), BE(60h), 4SE(DCh), and 4QIOR(ECh) commands. However, these commands may not be sufficient to test all flash operations.

typedef struct
{
/*This specifies the number of address bytes used by the memory slave device, valid values 1-4 */
  uint32_t numOfAddrBytes;
  /*The memory size: For densities of 2 gigabits or less - the size in bytes; For densities 4 gigabits and above - bit-31 is set to 1b to define that this memory is 4 gigabits and above; and other 30:0 bits define N where the density is computed as 2^N bytes. For example, 0x80000021 corresponds to 2^30 = 1 gigabyte.*/
  uint32_t memSize; 
/*This specifies the Read command */
  cy_stc_smif_mem_cmd_t* readCmd;
/*This specifies the Write Enable command */
  cy_stc_smif_mem_cmd_t* writeEnCmd;
/*This specifies the Write Disable command */
  cy_stc_smif_mem_cmd_t* writeDisCmd;
/*This specifies the Erase command */
  cy_stc_smif_mem_cmd_t* eraseCmd;
/*This specifies the sector size of each Erase */
  uint32_t eraseSize;
/*This specifies the Chip Erase command */
  cy_stc_smif_mem_cmd_t* chipEraseCmd;
/*This specifies the Program command */
  cy_stc_smif_mem_cmd_t* programCmd;
/*This specifies the page size for programming */
  uint32_t programSize;
/*This specifies the command to read the WIP-containing status register */
  cy_stc_smif_mem_cmd_t* readStsRegWipCmd;
/*This specifies the command to read the QE-containing status register */
  cy_stc_smif_mem_cmd_t* readStsRegQeCmd;
/*This specifies the command to write into the QE-containing status register */
  cy_stc_smif_mem_cmd_t* writeStsRegQeCmd;
/*This specifies the read SFDP command */
  cy_stc_smif_mem_cmd_t* readSfdpCmd;
/*This specifies the Read ID command */
  cy_stc_smif_mem_cmd_t* readIDCmd;
/* The Busy mask for the status registers */
  uint32_t stsRegBusyMask;
/*The QE mask for the status registers */
  uint32_t stsRegQuadEnableMask;
/*Max time for erase type 1 cycle time in ms*/
  uint32_t eraseTime; 
/*Max time for chip erase cycle time in ms */
  uint32_t chipEraseTime; 
/*Max time for page program cycle time in us */
  uint32_t programTime; 
/*This specifies the number of regions for memory with hybrid sectors */
  uint32_t hybridRegionCount;
/*This specifies data for memory with hybrid sectors */
  cy_stc_smif_hybrid_region_info_t** hybridRegionInfo; 
} cy_stc_smif_mem_device_cfg_t;

This section provides steps to add additional operation commands other than the commands provided by the example code. The flash commands vary from the products and the interface—see the datasheet for each flash for supported command sets.

For example, a brief list of supported commands for the S25FL512S device is in shown in Table 2. See the datasheet for detailed descriptions for each command.

The example code provided commands WRR(01h), WRDI(04h), RDSR1(05h), WREN(06h), 4QPP(34h), RDCR(35h), BE(60h), 4SE(DCh), 4QIOR(ECh) are shown in Bold.

Use the top-down approach on the codes to determine the architecture of the serial flash memory operation.

For example, consider the cy_serial_flash_qspi_read operation starting from main.c to investigate the SMIF structure.

By exploring from main.c and all the way down to cy_smif.c, you can determine that the actual operation command is delivered to Cy_SMIF_TransmitCommand in cy_smif.c with command arguments, command width, address width, mode, mode width, the number of dummy cycles, and data width. The arguments are specified in cycfg_qspi_memslot.c for each operation command.

const cy_stc_smif_mem_cmd_t 
   S25FL512S_4byteaddr_SlaveSlot_0_readCmd =
     {
       /* The 8-bit command. 1 x I/O read command. */
       .command = 0xECU,
       /* The width of the command transfer. */
       .cmdWidth = CY_SMIF_WIDTH_SINGLE,
       /* The width of the address transfer. */
       .addrWidth = CY_SMIF_WIDTH_QUAD,
       /* The 8-bit mode byte. This value is 0xFFFFFFFF when there is no mode present. */
       .mode = 0x01U,
       /* The width of the mode command transfer. */
       .modeWidth = CY_SMIF_WIDTH_QUAD,
       /* The number of dummy cycles. A zero value suggests no dummy cycles. */
       .dummyCycles = 4U,
       /* The width of the data transfer. */
       .dataWidth = CY_SMIF_WIDTH_QUAD
     };

See the datasheet for the argument values in the command sequence.

To add an additional command other than the supported commands, reverse the top-down approach. This is demonstrated with the RDID (9Fh) command.

1. Check the command sequence for RDID 9Fh

   
   

2. Specify the arguments for the operation command in cycfg_qspi_memslot.c to define the SMIF-driver memory configuration

   Code Listing 3: S25FL512S_4byteaddr_SlaveSlot_0_readIDCmd in cycfg_qspi_memslot.c

   const cy_stc_smif_mem_cmd_t
   S25FL512S_4byteaddr_SlaveSlot_0_readIDCmd =
   {
     /* The 8-bit command. 1 x I/O read command. */
     .command = 0x9FU,
     /* The width of the command transfer. */
     .cmdWidth = CY_SMIF_WIDTH_SINGLE,
     /* The width of the address transfer. */
     .addrWidth = CY_SMIF_WIDTH_NA,
     /* The 8-bit mode byte. This value is 0xFFFFFFFF when there is no mode present. */
     .mode = 0xFFFFFFFFU,
     /* The width of the mode command transfer. */
     .modeWidth = CY_SMIF_WIDTH_NA,
     /* The number of dummy cycles. A zero value suggests no dummy cycles. */
     .dummyCycles = 0U,
     /* The width of the data transfer. */
     .dataWidth = CY_SMIF_WIDTH_SINGLE
   };

3. Add the read ID command to the command structure in cycfg_qspi_memslot.c

   Code Listing 4: deviceCfg_S25FL512S_4byteaddr_SlaveSlot_0 in cycfg_qspi_memslot.c

   const cy_stc_smif_mem_device_cfg_t
   deviceCfg_S25FL512S_4byteaddr_SlaveSlot_0 =
     {
       ...
       .readIDCmd =
   (cy_stc_smif_mem_cmd_t*)&S25FL512S_4byteaddr_SlaveSlot_0_readIDCmd,           
       ...
     }

4. Add the function that actually operates the command in cy_smif_memslot.c where the source code for memory-level APIs for the SMIF driver is provided

   Code Listing 5: Cy_SMIF_MemCmdReadID in cy_smif_memslot.c

   cy_en_smif_status_t Cy_SMIF_MemCmdReadID(SMIF_Type *base,
                                cy_stc_smif_mem_config_t const *memDevice,
                                uint8_t* readBuff,
                                uint32_t size,
                                cy_stc_smif_context_t *context)
   {
     cy_en_smif_status_t result = CY_SMIF_BAD_PARAM;
     cy_en_smif_slave_select_t slaveSelected;
     cy_stc_smif_mem_device_cfg_t *device = memDevice->deviceCfg;
     cy_stc_smif_mem_cmd_t *cmdReadID = device->readIDCmd;
     if(NULL == cmdReadID)
     {
       result = CY_SMIF_CMD_NOT_FOUND;
     }
     else
     {
       slaveSelected = (0U == memDevice->dualQuadSlots)?memDevice->slaveSelect:
                       (cy_en_smif_slave_select_t)memDevice->dualQuadSlots;
       result = Cy_SMIF_TransmitCommand( base,
                (uint8_t)cmdReadID->command,
                cmdReadID->cmdWidth,
                CY_SMIF_CMD_WITHOUT_PARAM, CY_SMIF_CMD_WITHOUT_PARAM,
                        CY_SMIF_WIDTH_NA,
                slaveSelected, CY_SMIF_TX_NOT_LAST_BYTE, context);
       if(CY_SMIF_SUCCESS == result)
       {
         result = Cy_SMIF_ReceiveData(base, readBuff, size,
                        cmdReadID->dataWidth, NULL, context);
       }
     }
     return(result);
   }

5. Add the function that returns the data to the rxBuffer in cy_smif_memslot.c where the source code for memory-level APIs for the SMIF driver is provided

   Code Listing 6: Cy_SMIF_MemCmdReadID in cy_smif_memslot.c

   cy_en_smif_status_t Cy_SMIF_MemReadID(SMIF_Type *base,
                   cy_stc_smif_mem_config_t const *memConfig,
                   uint8_t rxBuffer[],
                   uint32_t length,
                   cy_stc_smif_context_t *context)
   {
     cy_en_smif_status_t status = CY_SMIF_BAD_PARAM;
     uint32_t chunk = 0UL;
     CY_ASSERT_L1(NULL != memConfig);
     CY_ASSERT_L1(NULL != rxBuffer);
     if(1)
     {
          /* SMIF can read only up to 65536 bytes in one go. Split the larger  
             read into multiple chunks */
       while (length > 0UL)
       {
          /* Get the number of bytes which can be read during one operation */
         chunk = (length > SMIF_MAX_RX_COUNT) ?
                     (SMIF_MAX_RX_COUNT) : length;
          /* Send the command to read data from the external memory to the rxBuffer array */
          status = Cy_SMIF_MemCmdReadID(base, memConfig,
                     (uint8_t *)rxBuffer, chunk, context);
          if(CY_SMIF_SUCCESS == status)
            {
               /* Wait until the SMIF block completes receiving data */
               status = PollTransferStatus(base, CY_SMIF_REC_CMPLT, context);
            }
            if(CY_SMIF_SUCCESS != status)
            {
              break;
            }
            /* Recalculate the next rxBuffer offset */
            length -= chunk;
            rxBuffer = (uint8_t *)rxBuffer + chunk;
       }
     }
     return status;
   }

6. Add the function that executes the read ID operation to the external flash in cy_serial_flash_qspi.c where it provides APIs for interacting with an external flash

   Code Listing 7: cy_serial_flash_qspi_readID in cy_serial_flash_qspi.c

   cy_rslt_t cy_serial_flash_qspi_readID(size_t length,
                                 uint8_t* buf)
   {
     cy_rslt_t result_mutex_rel = CY_RSLT_SUCCESS;
     cy_rslt_t result = _mutex_acquire();
     if (CY_RSLT_SUCCESS == result)
     {
       /* Cy_SMIF_MemReadID() returns error if (addr + length) > total flash 
               size.*/
       result = (cy_rslt_t)Cy_SMIF_MemReadID(qspi_obj.base,
                   qspi_block_config.memConfig[MEM_SLOT], 
                   buf, length,
                   &qspi_obj.context);
                   result_mutex_rel = _mutex_release();
       result_mutex_rel = _mutex_release();
     }
     /* Give priority to the status of SMIF operation when both SMIF  
               operation and mutex release fail.*/
               return ((CY_RSLT_SUCCESS == result) ? result_mutex_rel : 
                            result);
   }

7. In main.c, add the function to operate the read device RDID (9Fh) operation

   Code Listing 8: cy_serial_flash_qspi_readID in main.c

   int main(void)
   {
   ...
        printf("\r\n1. Reading device ID\r\n");
        result = cy_serial_flash_qspi_readID(DEVICE_ID, rx_buf);
        check_status("Reading Device ID failed", result);
        printf("Byte Address: Data\r\n");
        for(uint8_t i = 0; i < DEVICE_ID; i++)
          printf("0x%02dh : 0x%02Xh \r\n", i, rx_buf[i]);
   ...
   }

Make sure to include the added functions to the header files also.

This example code is in SPI mode. Some flash devices such as S25FS512S supports QPI mode, so if you want to operate RDID (9Fh) in QPI mode, you can modify the command width and data width into Quad.

Code Listing 9: RDID(9Fh) in QPI mode

const cy_stc_smif_mem_cmd_t
S25FL512S_4byteaddr_SlaveSlot_0_readIDQPICmd =
{
  /* The 8-bit command. 1 x I/O read command. */
  .command = 0x9FU,
  /* The width of the command transfer. */
  .cmdWidth = CY_SMIF_WIDTH_QUAD,
  /* The width of the address transfer. */
  .addrWidth = CY_SMIF_WIDTH_NA,
  /* The 8-bit mode byte. This value is 0xFFFFFFFF when there 
             is no mode  present. */
  .mode = 0xFFFFFFFFU,
  /* The width of the mode command transfer. */
  .modeWidth = CY_SMIF_WIDTH_NA,
  /* The number of dummy cycles. A zero value suggests no dummy cycles. */
  .dummyCycles = 0U,
  /* The width of the data transfer. */
  };