SPI Flash Demo

The SPI Flash Demo (spiFlashDemo directory) provides example code for reading the device ID and JEDEC ID of the SPI flash device on the development board. The application displays the written data on each address starting at 0x720000 and read the address from SPI flash.

For more detail of the driver, refer to SPI Flash Driver & SPI Driver.

Newlib

By default, newlib-nano is used for this demo.

See also

User Debug Configuration - To learn more about User Debug Configuration.

Customize Your Own Flash

To use a custom flash chip not found in the supported known flash library (known_flash), user needs to declare a spiFlash_info_t entry and register it before calling spiFlash_probe.

Refer to spiFlash_list.c for details about supported flash library.

Step 1 — Declare the Custom Flash Entry

Populate a spiFlash_info_t with the correct jedec_id, flags, and optionally a post_init_hook function:

const spiFlash_info_t user_flash[] = {
    {
        .part_no        = "FLASH_X",
        .jedec_id       = 0x9D701A00,   // Must match the actual JEDEC ID of the chip
        .flags          = 0,
        .post_init_hook = custom_chip_setup,
    },
};

Note: If the jedec_id does not match the connected flash, the driver will fall back to the built-in known flash library.

Step 2 — Implement the Post-Init Hook (Optional)

If the flash chip requires special command configuration (e.g. a non-standard write status command or quad-enable bit), use the post_init_hook to override the default commands after initialization.

The hook receives a pointer to the spiFlash_instance_t, which exposes the following configurable fields:

Field	Type	Description
cmd_rd_status	u8	Command for Read Status
cmd_wr_status	u8	Command for Write Status
cmd_exit_4byte	u8	Command for exit 4-byte addressing
mask_qe	u8	Quad Enable bitmask

Example of declaring a custom hook function:

int custom_chip_setup(void *instance)
{
    spiFlash_instance_t *flash = (spiFlash_instance_t *)instance;
 
    flash->cmd_wr_status = 0x77;  // Override write status command
    flash->mask_qe       = 0x40;  // Override quad enable bit
 
    printf("Custom flash post_init_hook triggered\n");
    return 0;
}

Step 3 — Register and Probe

Register the custom flash table before calling spiFlash_probe so the driver searches the user table first:

spiFlash_register(user_flash);
spiFlash_probe(&Flash);

Execution Sequence:

The following shows the expected execution sequence:

***Starting SPI Flash Demo*** 
INFO: W25Q128JVSIQ Flash is found!
INFO: Detected JEDEC_ID: 0x9D701A00.
Writing block of 256 bytes.
Reading block of 256 bytes.
Addr 0x720000 := Wr[0x0] vs Rd[0x0]
Addr 0x720001 := Wr[0x1] vs Rd[0x1]
Addr 0x720002 := Wr[0x2] vs Rd[0x2]
Addr 0x720003 := Wr[0x3] vs Rd[0x3]
Addr 0x720004 := Wr[0x4] vs Rd[0x4]
Addr 0x720005 := Wr[0x5] vs Rd[0x5]
Addr 0x720006 := Wr[0x6] vs Rd[0x6]
Addr 0x720007 := Wr[0x7] vs Rd[0x7]
Addr 0x720008 := Wr[0x8] vs Rd[0x8]
Addr 0x720009 := Wr[0x9] vs Rd[0x9]
Addr 0x72000a := Wr[0xA] vs Rd[0xA]
Addr 0x72000b := Wr[0xB] vs Rd[0xB]
Addr 0x72000c := Wr[0xC] vs Rd[0xC]
Addr 0x72000d := Wr[0xD] vs Rd[0xD]
Addr 0x72000e := Wr[0xE] vs Rd[0xE]
Addr 0x72000f := Wr[0xF] vs Rd[0xF]
Addr 0x720010 := Wr[0x10] vs Rd[0x10]
Addr 0x720011 := Wr[0x11] vs Rd[0x11]
Addr 0x720012 := Wr[0x12] vs Rd[0x12]
Addr 0x720013 := Wr[0x13] vs Rd[0x13]
Addr 0x720014 := Wr[0x14] vs Rd[0x14]
Addr 0x720015 := Wr[0x15] vs Rd[0x15]
Addr 0x720016 := Wr[0x16] vs Rd[0x16]
Addr 0x720017 := Wr[0x17] vs Rd[0x17]
Addr 0x720018 := Wr[0x18] vs Rd[0x18]
Addr 0x720019 := Wr[0x19] vs Rd[0x19]
Addr 0x72001a := Wr[0x1A] vs Rd[0x1A]
Addr 0x72001b := Wr[0x1B] vs Rd[0x1B]
Addr 0x72001c := Wr[0x1C] vs Rd[0x1C]
Addr 0x72001d := Wr[0x1D] vs Rd[0x1D]
Addr 0x72001e := Wr[0x1E] vs Rd[0x1E]
Addr 0x72001f := Wr[0x1F] vs Rd[0x1F]
Addr 0x720020 := Wr[0x20] vs Rd[0x20]
Addr 0x720021 := Wr[0x21] vs Rd[0x21]
Addr 0x720022 := Wr[0x22] vs Rd[0x22]
Addr 0x720023 := Wr[0x23] vs Rd[0x23]
Addr 0x720024 := Wr[0x24] vs Rd[0x24]
Addr 0x720025 := Wr[0x25] vs Rd[0x25]
Addr 0x720026 := Wr[0x26] vs Rd[0x26]
Addr 0x720027 := Wr[0x27] vs Rd[0x27]
Addr 0x720028 := Wr[0x28] vs Rd[0x28]
Addr 0x720029 := Wr[0x29] vs Rd[0x29]
Addr 0x72002a := Wr[0x2A] vs Rd[0x2A]
Addr 0x72002b := Wr[0x2B] vs Rd[0x2B]
Addr 0x72002c := Wr[0x2C] vs Rd[0x2C]
Addr 0x72002d := Wr[0x2D] vs Rd[0x2D]
Addr 0x72002e := Wr[0x2E] vs Rd[0x2E]
Addr 0x72002f := Wr[0x2F] vs Rd[0x2F]
Addr 0x720030 := Wr[0x30] vs Rd[0x30]
Addr 0x720031 := Wr[0x31] vs Rd[0x31]
Addr 0x720032 := Wr[0x32] vs Rd[0x32]
Addr 0x720033 := Wr[0x33] vs Rd[0x33]
Addr 0x720034 := Wr[0x34] vs Rd[0x34]
Addr 0x720035 := Wr[0x35] vs Rd[0x35]
Addr 0x720036 := Wr[0x36] vs Rd[0x36]
Addr 0x720037 := Wr[0x37] vs Rd[0x37]
Addr 0x720038 := Wr[0x38] vs Rd[0x38]
Addr 0x720039 := Wr[0x39] vs Rd[0x39]
Addr 0x72003a := Wr[0x3A] vs Rd[0x3A]
Addr 0x72003b := Wr[0x3B] vs Rd[0x3B]
Addr 0x72003c := Wr[0x3C] vs Rd[0x3C]
Addr 0x72003d := Wr[0x3D] vs Rd[0x3D]
Addr 0x72003e := Wr[0x3E] vs Rd[0x3E]
Addr 0x72003f := Wr[0x3F] vs Rd[0x3F]
Addr 0x720040 := Wr[0x40] vs Rd[0x40]
Addr 0x720041 := Wr[0x41] vs Rd[0x41]
Addr 0x720042 := Wr[0x42] vs Rd[0x42]
Addr 0x720043 := Wr[0x43] vs Rd[0x43]
Addr 0x720044 := Wr[0x44] vs Rd[0x44]
Addr 0x720045 := Wr[0x45] vs Rd[0x45]
Addr 0x720046 := Wr[0x46] vs Rd[0x46]
Addr 0x720047 := Wr[0x47] vs Rd[0x47]
Addr 0x720048 := Wr[0x48] vs Rd[0x48]
Addr 0x720049 := Wr[0x49] vs Rd[0x49]
Addr 0x72004a := Wr[0x4A] vs Rd[0x4A]
Addr 0x72004b := Wr[0x4B] vs Rd[0x4B]
Addr 0x72004c := Wr[0x4C] vs Rd[0x4C]
Addr 0x72004d := Wr[0x4D] vs Rd[0x4D]
Addr 0x72004e := Wr[0x4E] vs Rd[0x4E]
Addr 0x72004f := Wr[0x4F] vs Rd[0x4F]
Addr 0x720050 := Wr[0x50] vs Rd[0x50]
Addr 0x720051 := Wr[0x51] vs Rd[0x51]
Addr 0x720052 := Wr[0x52] vs Rd[0x52]
Addr 0x720053 := Wr[0x53] vs Rd[0x53]
Addr 0x720054 := Wr[0x54] vs Rd[0x54]
Addr 0x720055 := Wr[0x55] vs Rd[0x55]
Addr 0x720056 := Wr[0x56] vs Rd[0x56]
Addr 0x720057 := Wr[0x57] vs Rd[0x57]
Addr 0x720058 := Wr[0x58] vs Rd[0x58]
Addr 0x720059 := Wr[0x59] vs Rd[0x59]
Addr 0x72005a := Wr[0x5A] vs Rd[0x5A]
Addr 0x72005b := Wr[0x5B] vs Rd[0x5B]
Addr 0x72005c := Wr[0x5C] vs Rd[0x5C]
Addr 0x72005d := Wr[0x5D] vs Rd[0x5D]
Addr 0x72005e := Wr[0x5E] vs Rd[0x5E]
Addr 0x72005f := Wr[0x5F] vs Rd[0x5F]
Addr 0x720060 := Wr[0x60] vs Rd[0x60]
Addr 0x720061 := Wr[0x61] vs Rd[0x61]
Addr 0x720062 := Wr[0x62] vs Rd[0x62]
Addr 0x720063 := Wr[0x63] vs Rd[0x63]
Addr 0x720064 := Wr[0x64] vs Rd[0x64]
Addr 0x720065 := Wr[0x65] vs Rd[0x65]
Addr 0x720066 := Wr[0x66] vs Rd[0x66]
Addr 0x720067 := Wr[0x67] vs Rd[0x67]
Addr 0x720068 := Wr[0x68] vs Rd[0x68]
Addr 0x720069 := Wr[0x69] vs Rd[0x69]
Addr 0x72006a := Wr[0x6A] vs Rd[0x6A]
Addr 0x72006b := Wr[0x6B] vs Rd[0x6B]
Addr 0x72006c := Wr[0x6C] vs Rd[0x6C]
Addr 0x72006d := Wr[0x6D] vs Rd[0x6D]
Addr 0x72006e := Wr[0x6E] vs Rd[0x6E]
Addr 0x72006f := Wr[0x6F] vs Rd[0x6F]
Addr 0x720070 := Wr[0x70] vs Rd[0x70]
Addr 0x720071 := Wr[0x71] vs Rd[0x71]
Addr 0x720072 := Wr[0x72] vs Rd[0x72]
Addr 0x720073 := Wr[0x73] vs Rd[0x73]
Addr 0x720074 := Wr[0x74] vs Rd[0x74]
Addr 0x720075 := Wr[0x75] vs Rd[0x75]
Addr 0x720076 := Wr[0x76] vs Rd[0x76]
Addr 0x720077 := Wr[0x77] vs Rd[0x77]
Addr 0x720078 := Wr[0x78] vs Rd[0x78]
Addr 0x720079 := Wr[0x79] vs Rd[0x79]
Addr 0x72007a := Wr[0x7A] vs Rd[0x7A]
Addr 0x72007b := Wr[0x7B] vs Rd[0x7B]
Addr 0x72007c := Wr[0x7C] vs Rd[0x7C]
Addr 0x72007d := Wr[0x7D] vs Rd[0x7D]
Addr 0x72007e := Wr[0x7E] vs Rd[0x7E]
Addr 0x72007f := Wr[0x7F] vs Rd[0x7F]
Addr 0x720080 := Wr[0x80] vs Rd[0x80]
Addr 0x720081 := Wr[0x81] vs Rd[0x81]
Addr 0x720082 := Wr[0x82] vs Rd[0x82]
Addr 0x720083 := Wr[0x83] vs Rd[0x83]
Addr 0x720084 := Wr[0x84] vs Rd[0x84]
Addr 0x720085 := Wr[0x85] vs Rd[0x85]
Addr 0x720086 := Wr[0x86] vs Rd[0x86]
Addr 0x720087 := Wr[0x87] vs Rd[0x87]
Addr 0x720088 := Wr[0x88] vs Rd[0x88]
Addr 0x720089 := Wr[0x89] vs Rd[0x89]
Addr 0x72008a := Wr[0x8A] vs Rd[0x8A]
Addr 0x72008b := Wr[0x8B] vs Rd[0x8B]
Addr 0x72008c := Wr[0x8C] vs Rd[0x8C]
Addr 0x72008d := Wr[0x8D] vs Rd[0x8D]
Addr 0x72008e := Wr[0x8E] vs Rd[0x8E]
Addr 0x72008f := Wr[0x8F] vs Rd[0x8F]
Addr 0x720090 := Wr[0x90] vs Rd[0x90]
Addr 0x720091 := Wr[0x91] vs Rd[0x91]
Addr 0x720092 := Wr[0x92] vs Rd[0x92]
Addr 0x720093 := Wr[0x93] vs Rd[0x93]
Addr 0x720094 := Wr[0x94] vs Rd[0x94]
Addr 0x720095 := Wr[0x95] vs Rd[0x95]
Addr 0x720096 := Wr[0x96] vs Rd[0x96]
Addr 0x720097 := Wr[0x97] vs Rd[0x97]
Addr 0x720098 := Wr[0x98] vs Rd[0x98]
Addr 0x720099 := Wr[0x99] vs Rd[0x99]
Addr 0x72009a := Wr[0x9A] vs Rd[0x9A]
Addr 0x72009b := Wr[0x9B] vs Rd[0x9B]
Addr 0x72009c := Wr[0x9C] vs Rd[0x9C]
Addr 0x72009d := Wr[0x9D] vs Rd[0x9D]
Addr 0x72009e := Wr[0x9E] vs Rd[0x9E]
Addr 0x72009f := Wr[0x9F] vs Rd[0x9F]
Addr 0x7200a0 := Wr[0xA0] vs Rd[0xA0]
Addr 0x7200a1 := Wr[0xA1] vs Rd[0xA1]
Addr 0x7200a2 := Wr[0xA2] vs Rd[0xA2]
Addr 0x7200a3 := Wr[0xA3] vs Rd[0xA3]
Addr 0x7200a4 := Wr[0xA4] vs Rd[0xA4]
Addr 0x7200a5 := Wr[0xA5] vs Rd[0xA5]
Addr 0x7200a6 := Wr[0xA6] vs Rd[0xA6]
Addr 0x7200a7 := Wr[0xA7] vs Rd[0xA7]
Addr 0x7200a8 := Wr[0xA8] vs Rd[0xA8]
Addr 0x7200a9 := Wr[0xA9] vs Rd[0xA9]
Addr 0x7200aa := Wr[0xAA] vs Rd[0xAA]
Addr 0x7200ab := Wr[0xAB] vs Rd[0xAB]
Addr 0x7200ac := Wr[0xAC] vs Rd[0xAC]
Addr 0x7200ad := Wr[0xAD] vs Rd[0xAD]
Addr 0x7200ae := Wr[0xAE] vs Rd[0xAE]
Addr 0x7200af := Wr[0xAF] vs Rd[0xAF]
Addr 0x7200b0 := Wr[0xB0] vs Rd[0xB0]
Addr 0x7200b1 := Wr[0xB1] vs Rd[0xB1]
Addr 0x7200b2 := Wr[0xB2] vs Rd[0xB2]
Addr 0x7200b3 := Wr[0xB3] vs Rd[0xB3]
Addr 0x7200b4 := Wr[0xB4] vs Rd[0xB4]
Addr 0x7200b5 := Wr[0xB5] vs Rd[0xB5]
Addr 0x7200b6 := Wr[0xB6] vs Rd[0xB6]
Addr 0x7200b7 := Wr[0xB7] vs Rd[0xB7]
Addr 0x7200b8 := Wr[0xB8] vs Rd[0xB8]
Addr 0x7200b9 := Wr[0xB9] vs Rd[0xB9]
Addr 0x7200ba := Wr[0xBA] vs Rd[0xBA]
Addr 0x7200bb := Wr[0xBB] vs Rd[0xBB]
Addr 0x7200bc := Wr[0xBC] vs Rd[0xBC]
Addr 0x7200bd := Wr[0xBD] vs Rd[0xBD]
Addr 0x7200be := Wr[0xBE] vs Rd[0xBE]
Addr 0x7200bf := Wr[0xBF] vs Rd[0xBF]
Addr 0x7200c0 := Wr[0xC0] vs Rd[0xC0]
Addr 0x7200c1 := Wr[0xC1] vs Rd[0xC1]
Addr 0x7200c2 := Wr[0xC2] vs Rd[0xC2]
Addr 0x7200c3 := Wr[0xC3] vs Rd[0xC3]
Addr 0x7200c4 := Wr[0xC4] vs Rd[0xC4]
Addr 0x7200c5 := Wr[0xC5] vs Rd[0xC5]
Addr 0x7200c6 := Wr[0xC6] vs Rd[0xC6]
Addr 0x7200c7 := Wr[0xC7] vs Rd[0xC7]
Addr 0x7200c8 := Wr[0xC8] vs Rd[0xC8]
Addr 0x7200c9 := Wr[0xC9] vs Rd[0xC9]
Addr 0x7200ca := Wr[0xCA] vs Rd[0xCA]
Addr 0x7200cb := Wr[0xCB] vs Rd[0xCB]
Addr 0x7200cc := Wr[0xCC] vs Rd[0xCC]
Addr 0x7200cd := Wr[0xCD] vs Rd[0xCD]
Addr 0x7200ce := Wr[0xCE] vs Rd[0xCE]
Addr 0x7200cf := Wr[0xCF] vs Rd[0xCF]
Addr 0x7200d0 := Wr[0xD0] vs Rd[0xD0]
Addr 0x7200d1 := Wr[0xD1] vs Rd[0xD1]
Addr 0x7200d2 := Wr[0xD2] vs Rd[0xD2]
Addr 0x7200d3 := Wr[0xD3] vs Rd[0xD3]
Addr 0x7200d4 := Wr[0xD4] vs Rd[0xD4]
Addr 0x7200d5 := Wr[0xD5] vs Rd[0xD5]
Addr 0x7200d6 := Wr[0xD6] vs Rd[0xD6]
Addr 0x7200d7 := Wr[0xD7] vs Rd[0xD7]
Addr 0x7200d8 := Wr[0xD8] vs Rd[0xD8]
Addr 0x7200d9 := Wr[0xD9] vs Rd[0xD9]
Addr 0x7200da := Wr[0xDA] vs Rd[0xDA]
Addr 0x7200db := Wr[0xDB] vs Rd[0xDB]
Addr 0x7200dc := Wr[0xDC] vs Rd[0xDC]
Addr 0x7200dd := Wr[0xDD] vs Rd[0xDD]
Addr 0x7200de := Wr[0xDE] vs Rd[0xDE]
Addr 0x7200df := Wr[0xDF] vs Rd[0xDF]
Addr 0x7200e0 := Wr[0xE0] vs Rd[0xE0]
Addr 0x7200e1 := Wr[0xE1] vs Rd[0xE1]
Addr 0x7200e2 := Wr[0xE2] vs Rd[0xE2]
Addr 0x7200e3 := Wr[0xE3] vs Rd[0xE3]
Addr 0x7200e4 := Wr[0xE4] vs Rd[0xE4]
Addr 0x7200e5 := Wr[0xE5] vs Rd[0xE5]
Addr 0x7200e6 := Wr[0xE6] vs Rd[0xE6]
Addr 0x7200e7 := Wr[0xE7] vs Rd[0xE7]
Addr 0x7200e8 := Wr[0xE8] vs Rd[0xE8]
Addr 0x7200e9 := Wr[0xE9] vs Rd[0xE9]
Addr 0x7200ea := Wr[0xEA] vs Rd[0xEA]
Addr 0x7200eb := Wr[0xEB] vs Rd[0xEB]
Addr 0x7200ec := Wr[0xEC] vs Rd[0xEC]
Addr 0x7200ed := Wr[0xED] vs Rd[0xED]
Addr 0x7200ee := Wr[0xEE] vs Rd[0xEE]
Addr 0x7200ef := Wr[0xEF] vs Rd[0xEF]
Addr 0x7200f0 := Wr[0xF0] vs Rd[0xF0]
Addr 0x7200f1 := Wr[0xF1] vs Rd[0xF1]
Addr 0x7200f2 := Wr[0xF2] vs Rd[0xF2]
Addr 0x7200f3 := Wr[0xF3] vs Rd[0xF3]
Addr 0x7200f4 := Wr[0xF4] vs Rd[0xF4]
Addr 0x7200f5 := Wr[0xF5] vs Rd[0xF5]
Addr 0x7200f6 := Wr[0xF6] vs Rd[0xF6]
Addr 0x7200f7 := Wr[0xF7] vs Rd[0xF7]
Addr 0x7200f8 := Wr[0xF8] vs Rd[0xF8]
Addr 0x7200f9 := Wr[0xF9] vs Rd[0xF9]
Addr 0x7200fa := Wr[0xFA] vs Rd[0xFA]
Addr 0x7200fb := Wr[0xFB] vs Rd[0xFB]
Addr 0x7200fc := Wr[0xFC] vs Rd[0xFC]
Addr 0x7200fd := Wr[0xFD] vs Rd[0xFD]
Addr 0x7200fe := Wr[0xFE] vs Rd[0xFE]
Addr 0x7200ff := Wr[0xFF] vs Rd[0xFF]
OK: Demo ran successfully!