23. Flexible memory controller (FMC)

The flexible memory controller (FMC) includes three memory controllers:

• • The NOR/PSRAM memory controller
• • The NAND memory controller
• • The Synchronous DRAM (SDRAM/Mobile LPDDR SDRAM) controller

23.1 FMC main features

The FMC functional block makes the interface with: synchronous and asynchronous static memories, SDRAM memories, and NAND flash memory. Its main purposes are:

• • to translate AXI transactions into the appropriate external device protocol
• • to meet the access time requirements of the external memory devices

All external memories share the addresses, data and control signals with the controller. Each external device is accessed by means of a unique Chip Select. The FMC performs only one access at a time to an external device.

The main features of the FMC are the following:

• • Interface with static-memory mapped devices including:
  • – Static random access memory (SRAM)
  • – NOR flash memory/OneNAND flash memory
  • – PSRAM (4 memory banks)
  • – NAND flash memory with ECC hardware to check up to 8 Kbytes of data
• • Interface with synchronous DRAM (SDRAM/Mobile LPDDR SDRAM) memories
• • Burst mode support for faster access to synchronous devices such as NOR flash memory, PSRAM and SDRAM
• • Programmable continuous clock output for asynchronous and synchronous accesses
• • 8-, 16- or 32-bit wide data bus
• • Independent Chip Select control for each memory bank
• • Independent configuration for each memory bank
• • Write enable and byte lane select outputs for use with PSRAM, SRAM and SDRAM devices
• • External asynchronous wait control
• • Write FIFO with 16 x32-bit depth

The Write FIFO is common to all memory controllers and consists of:

• – a Write Data FIFO which stores the data to be written to the memory
• – a Write Address FIFO which stores the address (up to 28 bits) plus the data size (up to 2 bits). When operating in Burst mode, only the start address is stored except when crossing a page boundary (for PSRAM and SDRAM). In this case, the burst is broken into two FIFO entries.
• • Cacheable Read FIFO with 6 x64-bit depth (6 x14-bit address tag) for SDRAM controller.

At startup the FMC pins must be configured by the user application. The FMC I/O pins which are not used by the application can be used for other purposes.

The FMC registers that define the external device type and associated characteristics are set at boot time and do not change until the next reset or power-up. However, only a few bits can be changed on-the-fly:

• • ECCEN and PBKEN bits in the FMC_PCR register
• • IFS, IRS and ILS bits in the FMC_SR register
• • MODE[2:0], CTB1/CTB2, NRFS and MRD bits in the FMC_SDCMR register
• • REIE and CRE bits in the FMC_SDRTR register.

Follow the below sequence to modify parameters while the FMC is enabled:

1. 1. First disable the FMC to prevent further accesses to any memory controller while the register is modified.
2. 2. Update all required configurations.
3. 3. Enable the FMC again.

When the SDRAM controller is used, if the SDCLK Clock ratio or refresh rate has to be modified after initialization phase, the following procedure must be followed.

1. 1. Put the SDRAM device in Self-refresh mode.
2. 2. Disable the FMC by resetting the FMCEN bit in the FMC_BCR1 register.
3. 3. Update the required parameters.
4. 4. Enable the FMC once all parameters have been updated.
5. 5. Then, send the Clock Configuration Enable command to exit Self-fresh mode.

23.2 FMC block diagram

The FMC consists of the following main blocks:

• • The NOR flash/PSRAM/SRAM controller
• • The NAND controller
• • The SDRAM controller
• • The AXI interface
• • The AHB interface (including the FMC configuration registers)

The block diagram is shown in the figure below.

Figure 162. FMC block diagram

23.3 FMC internal signals

Table 164 gives the list of FMC internal signals. FMC pins (or external signals) are described in Section 23.7.1: External memory interface signals .

Table 164. FMC pins

23.4 AHB interface

The AHB slave interface allows internal CPUs to configure the FMC registers.

The AHB clock (fmc_hclk) is the reference clock for the FMC register accesses.

23.5 AXI interface

The AXI slave interface allows internal CPUs and other bus master peripherals to access the external memories.

AXI transactions are translated into the external device protocol. As the AXI data bus is 64-bit wide, the AXI transactions might be split into several consecutive 32-, 16- or 8-bit accesses according to data size accesses. The FMC Chip Select (FMC_NEx) does not toggle between consecutive accesses except in case of accesses in mode D when the Extended mode is enabled.

The FMC generates an AXI slave error when one of the following conditions is met:

• • Reading or writing to an FMC bank (Bank 1 to 4) which is not enabled.
• • Reading or writing to the NOR flash bank while the FACCEN bit is reset in the FMC_BCRx register.
• • Writing to a write protected SDRAM bank (WP bit set in the FMC_SDCRx register).
• • Violation of the SDRAM address range (access to reserved address range)
• • Attempting to read/write access from/to SDRAM bank when it is not yet initialized

The FMC generates an AXI decoder error when ADDR[31:28] address bits are not supported by the FMC bank base address following the BMAP[1:0] bits configuration.

The kernel clock for the FMC is the asynchronous fmc_ker_ck clock (refer to Section Reset and Clock control (RCC) for fmc_ker_ck clock source selection).

23.5.1 Supported memories and transactions

General transaction rules

The requested AXI transaction data size can be 8-, 16-, 32- or 64-bit wide whereas the accessed external device has a fixed data width. The best performance is always achieved with aligned AXI transactions whose size matches the external device data width.

When AXI transaction data size is different from the device data width, the result depends on the following factors:

• • AXI transaction data size is greater than the device data width:
  • – Read/Write transactions: the FMC splits the AXI transaction into smaller consecutive accesses matching the external device data width.
• • AXI transaction data size is smaller than the external device data width and the device supports byte selection (SRAM, PSRAM, SDRAM):
  • – Write transactions, the FMC manages the transaction using the byte lane signals.
  • – Read transactions, the FMC returns all bytes according to the external device data width. The useless bytes are discarded by the system.
• • AXI transaction data size is smaller than the external device data width and the device does not support byte selection (NOR and NAND flash memories):
  • – Write transactions: the FMC writes some irrelevant bytes which may corrupt the external device
  • – Read transactions: the FMC returns all bytes according to the external device data width. The useless bytes are discarded by the system.

Caution: Address alignment

• • Read transactions with unaligned addresses (such as half-word starting at an odd address) are not supported by the FMC.
• • Write transactions with unaligned addresses
  Their support depends on byte selection availability on the external device:
  • – If the device does not support byte selection (NOR and NAND flash memories), narrow write transactions and/or unaligned write transaction are not supported since the FMC would write irrelevant bytes and corrupt the external device.

Wrap support for NOR flash/PSRAM and SDRAM

The synchronous memories must be configured in Linear burst mode of undefined length as not all masters can issue wrap transactions.

If a master generates a wrap transaction:

• • The read is split into two linear burst transactions.
• • The write is split into two linear burst transactions if the write FIFO is enabled and into several linear burst transactions if the write FIFO is disabled.

Configuration registers

The FMC can be configured through a set of registers. Refer to Section 23.7.6 , for a detailed description of the NOR flash/PSRAM controller registers. Refer to Section 23.8.7 , for a detailed description of the NAND flash registers and to Section 23.9.5 for a detailed description of the SDRAM controller registers.

23.6 External device address mapping

From the FMC point of view, the external memory is divided into fixed-size banks of 256 Mbytes each (see Figure 163 ):

• • Bank 1 is used to address up to 4 NOR flash memory or PSRAM devices. This bank is split into 4 NOR/PSRAM subbanks with 4 dedicated Chip Selects, as follows:
  • – Bank 1 - NOR/PSRAM 1
  • – Bank 1 - NOR/PSRAM 2
  • – Bank 1 - NOR/PSRAM 3
  • – Bank 1 - NOR/PSRAM 4
• • Bank 2 and Bank 4 are not used by the FMC.
• • Bank 3 is used to address NAND flash memory devices. The MPU memory attribute for this space must be reconfigured by software to Device.
• • Bank 5 and 6 are used to address SDRAM devices (1 device per bank).

For each bank the type of memory to be used can be configured by the user application through the Configuration register.

Figure 163. FMC memory banks (default mapping)

The FMC bank mapping can be modified through the BMAP[1:0] bits in the FMC_BCR1 register. Table 165 shows the configuration to swap the NOR/PSRAM bank with SDRAM banks.

Table 165. FMC bank mapping options

23.6.1 NOR/PSRAM address mapping

ADDR[27:26] bits are used to select one of the four memory banks as shown in Table 166 .

Table 166. NOR/PSRAM bank selection

1. 1. ADDR are internal address lines that are translated to external memory.

The ADDR[25:0] bits contain the external memory address. Since ADDR is a byte address whereas the memory is addressed at word level, the address actually issued to the memory varies according to the memory data width, as shown in the following table.

Table 167. NOR/PSRAM External memory address

1. 1. In case of a 16-bit external memory width, the FMC internally uses ADDR[25:1] to generate the address for external memory FMC_A[24:0]. In case of a 32-bit memory width, the FMC internally uses ADDR[25:2] to generate the external address.
   Whatever the external memory width, FMC_A[0] should be connected to external memory address A[0].

23.6.2 NAND flash memory address mapping

The NAND bank is divided into memory areas as indicated in Table 168 .

For NAND flash memory, the common and attribute memory spaces are subdivided into three sections (see in Table 169 below) located in the lower 256 Kbytes:

• • Data section (first 64 Kbytes in the common/attribute memory space)
• • Command section (second 64 Kbytes in the common / attribute memory space)
• • Address section (next 128 Kbytes in the common / attribute memory space)

The application software uses the 3 sections to access the NAND flash memory:

• • To send a command to NAND flash memory , the software must write the command value to any memory location in the command section.
• • To specify the NAND flash address that must be read or written , the software must write the address value to any memory location in the address section. Since an address can be 4 or 5 bytes long (depending on the actual memory size), several consecutive write operations to the address section are required to specify the full address.
• • To read or write data , the software reads or writes the data from/to any memory location in the data section.

Since the NAND flash memory automatically increments addresses, there is no need to increment the address of the data section to access consecutive memory locations.

23.6.3 SDRAM address mapping

Two SDRAM banks are available as indicated in Table 170 .

Table 171 shows SDRAM mapping for a 13-bit row and an 11-bit column configuration.

Table 171. SDRAM address mapping

1. 1. When interfacing with a 16-bit memory, the FMC internally uses the ADDR[11:1] internal address lines to generate the external address. When interfacing with a 32-bit memory, the FMC internally uses ADDR[12:2] lines to generate the external address. Whatever the memory width, FMC_A[0] has to be connected to the external memory address A[0].
2. 2. The AutoPrecharge is not supported. FMC_A[10] must be connected to the external memory address A[10] but it is always driven low.

The ADDR[27:0] bits are translated into an external SDRAM address depending on the SDRAM controller configuration:

• • Data size: 8, 16 or 32 bits
• • Row size: 11, 12 or 13 bits
• • Column size: 8, 9, 10 or 11 bits
• • Number of internal banks: two or four internal banks

The following tables show the SDRAM address mapping versus the SDRAM controller configuration.

Table 172. SDRAM address mapping with 8-bit data bus width ⁽¹⁾⁽²⁾ (continued)

1. 1. BANK[1:0] are the Bank Address BA[1:0]. When only 2 internal banks are used, BA1 must always be set to '0'.
2. 2. Access to Reserved (Res.) address range generates an AXI slave error.

Table 173. SDRAM address mapping with 16-bit data bus width ⁽¹⁾⁽²⁾

1. 1. BANK[1:0] are the Bank Address BA[1:0]. When only 2 internal banks are used, BA1 must always be set to '0'.
2. 2. Access to Reserved space (Res.) generates an AXI Slave error.
3. 3. BM0: is the byte mask for 16-bit access.

1. 1. BANK[1:0] are the Bank Address BA[1:0]. When only 2 internal banks are used, BA1 must always be set to '0'.
2. 2. Access to Reserved space (Res.) generates an AXI slave error.
3. 3. BM[1:0]: is the byte mask for 32-bit access.

23.7 NOR flash/PSRAM controller

The FMC generates the appropriate signal timings to drive the following types of memories:

• • Asynchronous SRAM and ROM
  • – 8 bits
  • – 16 bits
  • – 32 bits
• • PSRAM (Cellular RAM)
  • – Asynchronous mode
  • – Burst mode for synchronous accesses with configurable option to split burst access when crossing boundary page for CDRAM 1.5.
  • – Multiplexed or non-multiplexed
• • NOR flash memory
  • – Asynchronous mode
  • – Burst mode for synchronous accesses
  • – Multiplexed or non-multiplexed

The FMC outputs a unique Chip Select signal, NE[4:1], per bank. All the other signals (addresses, data and control) are shared.

The FMC supports a wide range of devices through a programmable timings among which:

• • Programmable wait states (up to 15)
• • Programmable bus turnaround cycles (up to 15)
• • Programmable output enable and write enable delays (up to 15)
• • Independent read and write timings and protocol to support the widest variety of memories and timings
• • Programmable continuous clock (FMC_CLK) output.

The FMC output Clock (FMC_CLK) is a sub-multiple of the fmc_ker_ck clock. It can be delivered to the selected external device either during synchronous accesses only or during asynchronous and synchronous accesses depending on the CCKEN bit configuration in the FMC_BCR1 register:

• • If the CCLKEN bit is reset, the FMC generates the clock (FMC_CLK) only during synchronous accesses (Read/write transactions).
• • If the CCLKEN bit is set, the FMC generates a continuous clock during asynchronous and synchronous accesses. To generate the FMC_CLK continuous clock, Bank 1 must be configured in Synchronous mode (see Section 23.7.6: NOR/PSRAM controller registers ). Since the same clock is used for all synchronous memories, when a continuous output clock is generated and synchronous accesses are performed, the AXI data size has to be the same as the memory data width (MWID) otherwise the FMC_CLK frequency is changed depending on AXI data transaction (refer to Section 23.7.5: Synchronous transactions for FMC_CLK divider ratio formula).

The size of each bank is fixed and equal to 64 Mbytes. Each bank is configured through dedicated registers (see Section 23.7.6: NOR/PSRAM controller registers ).

The programmable memory parameters include access times (see Table 175 ) and support for wait management (for PSRAM and NOR flash memory accessed in Burst mode).

23.7.1 External memory interface signals

Table 176 , Table 177 and Table 178 list the signals that are typically used to interface with NOR flash memory, SRAM and PSRAM.

Note: The prefix “N” identifies the signals which are active low.

NOR flash memory, non-multiplexed I/Os

The maximum capacity is 512 Mbits (26 address lines).

The maximum capacity is 512 Mbits.

The maximum capacity is 512 Mbits.

Table 179. 16-Bit multiplexed I/O PSRAM (continued)

The maximum capacity is 512 Mbits (26 address lines).

23.7.2 Supported memories and transactions

Table 180 below shows an example of the supported devices, access modes and transactions when the memory data bus is 16-bit wide for NOR flash memory, PSRAM and SRAM. The transactions not allowed (or not supported) by the FMC are shown in gray in this example.

Table 180. NOR flash/PSRAM: Example of supported memories and transactions ⁽¹⁾ (continued)

1. NBL[1:0] are also driven by AXI write strobes.

23.7.3 General timing rules

Signal synchronization is performed as follows:

• • All controller output signals change on the rising edge of the fmc_ker_ck clock.
• • In Synchronous read and write modes, all output signals change on the rising edge of fmc_ker_ck clock. Whatever the CLKDIV value, all outputs change as follows:
  • – NOEL/NWEL/ NEL/NADVL/ NADVH /NBLL/ Address valid outputs change on the falling edge of FMC_CLK clock.
  • – NOEH/ NWEH / NEH/ NOEH/NBLH/ Address invalid outputs change on the rising edge of FMC_CLK clock.

23.7.4 NOR flash/PSRAM controller asynchronous transactions

Asynchronous transactions on static memories (NOR flash memory, PSRAM, SRAM) are performed as follows:

• • Signals are synchronized by the internal clock. This clock is not issued to the memory.
• • The FMC always samples the data before deasserting the Chip Select signal. This guarantees that the memory data hold timing constraint is met (minimum Chip Enable high to data transition is usually 0 ns)
• • If the Extended mode is enabled (EXTMOD bit is set in the FMC_BCRx register), up to four extended modes (A, B, C and D) are available. It is possible to mix A, B, C and D modes for read and write operations. For example, read operation can be performed in mode A and write in mode B.
• • If the Extended mode is disabled (EXTMOD bit is reset in the FMC_BCRx register), the FMC can operate in Mode1 or Mode2 as follows:
  • – Mode 1 is the default mode when SRAM/PSRAM memory type is selected (MTYP = 0x0 or 0x01 in the FMC_BCRx register)
  • – Mode 2 is the default mode when NOR memory type is selected (MTYP = 0x10 in the FMC_BCRx register).

Mode 1 - SRAM/PSRAM (CRAM)

The next figures show the read and write transactions for the supported modes followed by the required configuration of FMC_BCRx, and FMC_BTRx/FMC_BWTRx registers.

Figure 164. Mode 1 read access waveforms

Figure 165. Mode 1 write access waveforms

The fmc_ker_ck cycle at the end of the write transaction helps guarantee the address and data hold time after the NWE rising edge. Due to the presence of this fmc_ker_ck cycle, the DATAST value must be greater than zero (DATAST > 0).

Table 181. FMC_BCRx bitfields (mode 1)

Mode A - SRAM/PSRAM (CRAM) OE toggling

Figure 166. Mode A read access waveforms

• 1. NBL[3:0] are driven low during the read access

Figure 167. Mode A write access waveforms

The differences compared with Mode1 are the toggling of NOE and the independent read and write timings.

Table 183. FMC_BCRx bitfields (mode A)

Mode 2/B - NOR flash

Figure 168. Mode 2 and mode B read access waveforms

Figure 169. Mode 2 write access waveforms

Figure 170. Mode B write access waveforms

The differences with Mode1 are the toggling of NWE and the independent read and write timings when extended mode is set (mode B).

Table 186. FMC_BCRx bitfields (mode 2/B)

Note: The FMC_BWTRx register is valid only if the Extended mode is set (mode B), otherwise its content is don't care.

Mode C - NOR flash - OE toggling

Figure 171. Mode C read access waveforms

Figure 172. Mode C write access waveforms

The differences compared with Mode1 are the toggling of NOE and the independent read and write timings.

Table 189. FMC_BCRx bitfields (mode C)

Mode D - asynchronous access with extended address

Figure 173. Mode D read access waveforms

Figure 174. Mode D write access waveforms

The differences with Mode1 are the toggling of NOE that goes on toggling after NADV changes and the independent read and write timings.

Table 192. FMC_BCRx bitfields (mode D)

Table 193. FMC_BTRx bitfields (mode D)

Muxed mode - multiplexed asynchronous access to NOR flash memory

Figure 175. Muxed read access waveforms

Figure 176. Muxed write access waveforms

The difference with Mode D is the drive of the lower address byte(s) on the data bus.

WAIT management in asynchronous accesses

If the asynchronous memory asserts the WAIT signal to indicate that it is not yet ready to accept or to provide data, the ASYNCWAIT bit has to be set in FMC_BCRx register.

If the WAIT signal is active (high or low depending on the WAITPOL bit), the second access phase (Data setup phase), programmed by the DATAST bits, is extended until WAIT becomes inactive. Unlike the data setup phase, the first access phases (Address setup and Address hold phases), programmed by the ADDSET and ADDHLD bits, are not WAIT sensitive and so they are not prolonged.

The data setup phase must be programmed so that WAIT can be detected 4 fmc_ker_ck cycles before the end of the memory transaction. The following cases must be considered:

1. 1. The memory asserts the WAIT signal aligned to NOE/NWE which toggles:

1. 2. The memory asserts the WAIT signal aligned to NEx (or NOE/NWE not toggling):
   if

then:

otherwise

where max_wait_assertion_time is the maximum time taken by the memory to assert the WAIT signal once NEx/NOE/NWE is low.

Figure 177 and Figure 178 show the number of fmc_ker_ck clock cycles that are added to the memory access phase after WAIT is released by the asynchronous memory (independently of the above cases).

Figure 177. Asynchronous wait during a read access waveforms

1. NWAIT polarity depends on WAITPOL bit setting in FMC_BCRx register.

Figure 178. Asynchronous wait during a write access waveforms

1. NWAIT polarity depends on WAITPOL bit setting in FMC_BCRx register.

23.7.5 Synchronous transactions

The memory clock, FMC_CLK, is a sub-multiple of fmc_ker_ck. It depends on the value of CLKDIV and the MWID/ AXI data size, following the formula given below:

If MWID is 16 or 8-bit, the FMC_CLK divider ratio is always defined by the programmed CLKDIV value.

If MWID is 32-bit, the FMC_CLK divider ratio depends also on AXI data size.

Example:

• • If CLKDIV=1, MWID = 32 bits, AXI data size=8 bits, FMC_CLK=fmc_ker_ck/4.
• • If CLKDIV=1, MWID = 16 bits, AXI data size=8 bits, FMC_CLK=fmc_ker_ck/2.

NOR flash memories specify a minimum time from NADV assertion to FMC_CLK high. To meet this constraint, the FMC does not issue the clock to the memory during the first internal clock cycle of the synchronous access (before NADV assertion). This guarantees that the rising edge of the memory clock occurs in the middle of the NADV low pulse.

For some PSRAM memories which must be configured to Synchronous mode, during the BCR register writing, the memory attribute space must be configured to device or strongly-ordered. Once PSRAM BCR register is configured, the memory attribute of PSRAM address space can be programmed to cacheable.

Data latency versus NOR memory latency

The data latency is the number of cycles to wait before sampling the data. The DATLAT value must be consistent with the latency value specified in the NOR flash configuration register. The FMC does not include the clock cycle when NADV is low in the data latency count.

Caution: Some NOR flash memories include the NADV Low cycle in the data latency count, so that the exact relation between the NOR flash latency and the FMC DATLAT parameter can be either:

• • NOR flash latency = (DATLAT + 2) FMC_CLK clock cycles
• • or NOR flash latency = (DATLAT + 3) FMC_CLK clock cycles

Some recent memories assert NWAIT during the latency phase. In such cases DATLAT can be set to its minimum value. As a result, the FMC samples the data and waits long enough to evaluate if the data are valid. Thus the FMC detects when the memory exits latency and real data are processed.

Other memories do not assert NWAIT during latency. In this case the latency must be set correctly for both the FMC and the memory, otherwise invalid data are mistaken for good data, or valid data are lost in the initial phase of the memory access.

Single-burst transfer

When the selected bank is configured in Burst mode for synchronous accesses, if for example a single-burst transaction is requested on 16-bit memories, the FMC performs a burst transaction of length 1 (if the AXI transfer is 16 bits), or length 2 (if the AXI transfer is 32 bits) and deassert the Chip Select signal when the last data is strobed.

Such transfers are not the most efficient in terms of cycles compared to asynchronous read operations. Nevertheless, a random asynchronous access would first require to re-program the memory access mode, which would altogether last longer.

Cross boundary page for Cellular RAM 1.5

Cellular RAM 1.5 does not allow burst access to cross the page boundary. The FMC allows to split automatically the burst access when the memory page size is reached by configuring the CPSIZE bits in the FMC_BCR1 register following the memory page size.

Wait management

For synchronous NOR flash memories, NWAIT is evaluated after the programmed latency period, which corresponds to (DATLAT+2) FMC_CLK clock cycles.

If NWAIT is active (low level when WAITPOL = 0, high level when WAITPOL = 1), wait states are inserted until NWAIT is inactive (high level when WAITPOL = 0, low level when WAITPOL = 1).

When NWAIT is inactive, the data is considered valid either immediately (bit WAITCFG = 1) or on the next clock edge (bit WAITCFG = 0).

During wait-state insertion via the NWAIT signal, the controller continues to send clock pulses to the memory, keeping the Chip Select and output enable signals valid. It does not consider the data as valid.

In Burst mode, there are two timing configurations for the NOR flash NWAIT signal:

• • The flash memory asserts the NWAIT signal one data cycle before the wait state (default after reset).
• • The flash memory asserts the NWAIT signal during the wait state

The FMC supports both NOR flash wait state configurations, for each Chip Select, thanks to the WAITCFG bit in the FMC_BCRx registers (x = 0..3).

Figure 179. Wait configuration waveforms

Figure 180. Synchronous multiplexed read mode waveforms - NOR, PSRAM (CRAM)

1. 1. Byte lane outputs (NBL are not shown; for NOR access, they are held high, and for PSRAM (CRAM) access, they are held low.

Table 198. FMC_BTRx bitfields (Synchronous multiplexed read mode) (continued)

Figure 181. Synchronous multiplexed write mode waveforms - PSRAM (CRAM)

1. 1. The memory must issue NWAIT signal one cycle in advance, accordingly WAITCFG must be programmed to 0.
2. 2. Byte Lane (NBL) outputs are not shown, they are held low while NEx is active.

Table 199. FMC_BCRx bitfields (Synchronous multiplexed write mode)

23.7.6 NOR/PSRAM controller registers

SRAM/NOR-flash chip-select control registers for bank x (FMC_BCRx)

Address offset: \( 0x00 + 0x8 * (x - 1) \) , ( \( x = 1 \) to \( 4 \) )

Reset value: \( 0x0000\ 30DB \) , \( 0x0000\ 30D2 \) , Block 3: \( 0x0000\ 30D2 \) , \( 0x0000\ 30D2 \)

This register contains the control information of each memory bank, used for SRAMs, PSRAM and NOR flash memories.

Bit 31 FMCEN: FMC Enable

This bit enables/disables the FMC.

0: Disable the FMC

1: Enable the FMC

Note: The FMCEN bit of the FMC_BCR2..4 registers is don't care. It is only enabled through the FMC_BCR1 register.

Bits 30:26 Reserved, must be kept at reset value.

Bits 25:24 BMAP[1:0]: FMC bank mapping

These bits allow different remap or swap of the FMC NOR/PSRAM and SDRAM banks (refer to Table 165 ).

00: Default mapping (refer to Figure 163 and Table 165 ).

01: NOR/PSRAM bank and SDRAM bank 1 are swapped.

10: Reserved

11: Reserved.

Note: The BMAP bits of the FMC_BCR2..4 registers are don't care. It is only enabled through the FMC_BCR1 register.

Bits 23:22 Reserved, must be kept at reset value.

Bit 21 WFDIS: Write FIFO Disable

This bit disables the Write FIFO used by the FMC.

0: Write FIFO enabled (Default after reset)

1: Write FIFO disabled

Note: The WFDIS bit of the FMC_BCR2..4 registers is don't care. It is only enabled through the FMC_BCR1 register.

Bit 20 CCLKEN: Continuous Clock Enable

This bit enables the FMC_CLK clock output to external memory devices.

0: The FMC_CLK is only generated during the synchronous memory access (read/write transaction). The FMC_CLK clock ratio is specified by the programmed CLKDIV value in the FMC_BCRx register (default after reset).

1: The FMC_CLK is generated continuously during asynchronous and synchronous access. The FMC_CLK clock is activated when the CCLKEN is set.

Note: The CCLKEN bit of the FMC_BCR2..4 registers is don't care. It is only enabled through the FMC_BCR1 register. Bank 1 must be configured in Synchronous mode to generate the FMC_CLK continuous clock.

If CCLKEN bit is set, the FMC_CLK clock ratio is specified by CLKDIV value in the FMC_BTR1 register. CLKDIV in FMC_BWTR1 is don't care.

If the Synchronous mode is used and CCLKEN bit is set, the synchronous memories connected to other banks than Bank 1 are clocked by the same clock (the CLKDIV value in the FMC_BTR2..4 and FMC_BWTR2..4 registers for other banks has no effect.)

Bit 19 CBURSTRW: Write burst enable

For PSRAM (CRAM) operating in Burst mode, the bit enables synchronous accesses during write operations. The enable bit for synchronous read accesses is the BURSTEN bit in the FMC_BCRx register.

0: Write operations are always performed in Asynchronous mode

1: Write operations are performed in Synchronous mode.

Bits 18:16 CPSIZE[2:0]: CRAM Page Size

These are used for Cellular RAM 1.5 which does not allow burst access to cross the address boundaries between pages. When these bits are configured, the FMC splits automatically the burst access when the memory page size is reached (refer to memory datasheet for page size).

000: No burst split when crossing page boundary (default after reset).

001: 128 bytes

010: 256 bytes

100: 1024 bytes

Other configuration: reserved.

Bit 15 ASYNCWAIT: Wait signal during asynchronous transfers

This bit enables/disables the FMC to use the wait signal even during an asynchronous protocol.

0: NWAIT signal is not taken in to account when running an asynchronous protocol (default after reset)

1: NWAIT signal is taken in to account when running an asynchronous protocol

Bit 14 EXTMOD: Extended mode enable.

This bit enables the FMC to program the write timings for asynchronous accesses inside the FMC_BWTR register, thus resulting in different timings for read and write operations.

0: values inside FMC_BWTR register are not taken into account (default after reset)

1: values inside FMC_BWTR register are taken into account

Note: When the Extended mode is disabled, the FMC can operate in Mode1 or Mode2 as follows:

• – Mode 1 is the default mode when the SRAM/PSRAM memory type is selected (MTYP = 0x0 or 0x01)
• – Mode 2 is the default mode when the NOR memory type is selected (MTYP = 0x10).

This bit enables/disables wait-state insertion via the NWAIT signal when accessing the memory in Synchronous mode.

0: NWAIT signal is disabled (its level not taken into account, no wait state inserted after the programmed flash latency period)

1: NWAIT signal is enabled (its level is taken into account after the programmed latency period to insert wait states if asserted) (default after reset)

This bit indicates whether write operations are enabled/disabled in the bank by the FMC:

0: Write operations are disabled in the bank by the FMC, an AXI slave error is reported

1: Write operations are enabled for the bank by the FMC (default after reset).

The NWAIT signal indicates whether the data from the memory are valid or if a wait state must be inserted when accessing the memory in Synchronous mode. This configuration bit determines if NWAIT is asserted by the memory one clock cycle before the wait state or during the wait state:

0: NWAIT signal is active one data cycle before wait state (default after reset)

1: NWAIT signal is active during wait state (not used for PSRAM).

This bit defines the polarity of the wait signal from memory used for either in Synchronous or Asynchronous mode:

0: NWAIT active low (default after reset)

1: NWAIT active high.

This bit enables/disables synchronous accesses during read operations. It is valid only for synchronous memories operating in Burst mode:

0: Burst mode disabled (default after reset). Read accesses are performed in Asynchronous mode

1: Burst mode enable. Read accesses are performed in Synchronous mode.

This bit enables NOR flash memory access operations.

0: Corresponding NOR flash memory access is disabled

1: Corresponding NOR flash memory access is enabled (default after reset)

Defines the external memory device width, valid for all type of memories.

00: 8 bits

01: 16 bits (default after reset)

10: 32 bits

11: reserved

These bits define the type of external memory attached to the corresponding memory bank:

00: SRAM (default after reset for Bank 2...4)

01: PSRAM (CRAM)

10: NOR flash/OneNAND flash (default after reset for Bank 1)

11: reserved

When this bit is set, the address and data values are multiplexed on the data bus, valid only with NOR and PSRAM memories:

0: Address/Data non-multiplexed

1: Address/Data multiplexed on databus (default after reset)

This bit enables the memory bank. After reset Bank1 is enabled, all others are disabled.

Accessing a disabled bank causes an ERROR on AXI bus.

0: Corresponding memory bank is disabled

1: Corresponding memory bank is enabled

SRAM/NOR-flash chip-select timing registers for bank x (FMC_BTRx)

Address offset: \( 0x04 + 0x8 \times (x - 1) \) , ( \( x = 1 \) to \( 4 \) )

Reset value: \( 0x0FFF\ FFFF \)

This register contains the control information of each memory bank, used for SRAMs, PSRAM and NOR flash memories. If the EXTMOD bit is set in the FMC_BCRx register, then this register is partitioned for write and read access, that is, 2 registers are available: one to configure read accesses (this register) and one to configure write accesses (FMC_BWTRx registers).

Bits 31:30 Reserved, must be kept at reset value.

Bits 29:28 ACCMOD[1:0] : Access mode

These bits specify the Asynchronous access modes as shown in the timing diagrams. They are taken into account only when the EXTMOD bit in the FMC_BCRx register is 1.

• 00: access mode A
• 01: access mode B
• 10: access mode C
• 11: access mode D

Bits 27:24 DATLAT[3:0] : (see note below bit descriptions): Data latency for synchronous memory

For synchronous access with read/write Burst mode enabled (BURSTEN / CBURSTRW bits set), these bits define the number of memory clock cycles (+2) to issue to the memory before reading/writing the first data:

This timing parameter is not expressed in fmc_ker_ck periods, but in FMC_CLK periods.

For asynchronous access, this value is don't care.

• 0000: Data latency of 2 FMC_CLK clock cycles for first burst access
• 1111: Data latency of 17 FMC_CLK clock cycles for first burst access (default value after reset)

Bits 23:20 CLKDIV[3:0] : Clock divide ratio (for FMC_CLK signal)

These bits define the period of FMC_CLK clock output signal, expressed in number of fmc_ker_ck cycles:

• 0000: FMC_CLK period = \( 1 \times \) fmc_ker_ck period
• 0001: FMC_CLK period = \( 2 \times \) fmc_ker_ck periods
• 0010: FMC_CLK period = \( 3 \times \) fmc_ker_ck periods
• 1111: FMC_CLK period = \( 16 \times \) fmc_ker_ck periods (default value after reset)

In asynchronous NOR flash, SRAM or PSRAM accesses, this value is don't care.

Note: Refer to Section 23.7.5: Synchronous transactions for FMC_CLK divider ratio formula)

Bits 19:16 BUSTURN[3:0] : Bus turnaround phase duration

These bits are written by software to add a delay at the end of a write-to-read (and read-to-write) transaction. This delay allows to match the minimum time between consecutive transactions ( \( t_{EHEL} \) from NEx high to NEx low) and the maximum time needed by the memory to free the data bus after a read access ( \( t_{EHQZ} \) ). The programmed bus turnaround delay is inserted between an asynchronous read (muxed or mode D) or write transaction and any other asynchronous /synchronous read or write to or from a static bank. The bank can be the same or different in case of read, in case of write the bank can be different except for muxed or mode D.

In some cases, whatever the programmed BUSTURN values, the bus turnaround delay is fixed as follows:

• • The bus turnaround delay is not inserted between two consecutive asynchronous write transfers to the same static memory bank except for muxed and D modes.
• • There is a bus turnaround delay of 1 FMC clock cycle between:
  • – Two consecutive asynchronous read transfers to the same static memory bank except for muxed and D modes.
  • – An asynchronous read to an asynchronous or synchronous write to any static bank or dynamic bank except for muxed and D modes.
  • – An asynchronous (modes 1, 2, A, B or C) read and a read from another static bank.
• • There is a bus turnaround delay of 2 FMC clock cycle between:
  • – Two consecutive synchronous writes (burst or single) to the same bank.
  • – A synchronous write (burst or single) access and an asynchronous write or read transfer to or from static memory bank (the bank can be the same or different for the case of read).
  • – Two consecutive synchronous reads (burst or single) followed by any synchronous/asynchronous read or write from/to another static memory bank.
• • There is a bus turnaround delay of 3 FMC clock cycle between:
  • – Two consecutive synchronous writes (burst or single) to different static bank.
  • – A synchronous write (burst or single) access and a synchronous read from the same or a different bank.

0000: BUSTURN phase duration = 0 fmc_ker_ck clock cycle added

...

1111: BUSTURN phase duration = 15 x fmc_ker_ck clock cycles added (default value after reset)

Bits 15:8 DATAST[7:0] : Data-phase duration

These bits are written by software to define the duration of the data phase (refer to Figure 164 to Figure 176 ), used in asynchronous accesses:

0000 0000: Reserved

0000 0001: DATAST phase duration = 1 × fmc_ker_ck clock cycles

0000 0010: DATAST phase duration = 2 × fmc_ker_ck clock cycles

...

1111 1111: DATAST phase duration = 255 × fmc_ker_ck clock cycles (default value after reset)

For each memory type and access mode data-phase duration, refer to the respective figure ( Figure 164 to Figure 176 ).

Example: Mode1, write access, DATAST = 1: Data-phase duration = DATAST+1 = 1 x fmc_ker_ck clock cycles.

Note: In synchronous accesses, this value is don't care.

These bits are written by software to define the duration of the address hold phase (refer to Figure 164 to Figure 176 ), used in mode D or multiplexed accesses:

0000: Reserved

0001: ADDHLD phase duration = \( 1 \times \text{fmc\_ker\_ck} \) clock cycle

0010: ADDHLD phase duration = \( 2 \times \text{fmc\_ker\_ck} \) clock cycle

...

1111: ADDHLD phase duration = \( 15 \times \text{fmc\_ker\_ck} \) clock cycles (default value after reset)

For each access mode address-hold phase duration, refer to the respective figure ( Figure 164 to Figure 176 ).

Note: In synchronous accesses, this value is not used, the address hold phase is always 1 memory clock period duration.

These bits are written by software to define the duration of the address setup phase (refer to Figure 164 to Figure 176 ), used in SRAMs, ROMs and asynchronous NOR flash:

0000: ADDSET phase duration = \( 0 \times \text{fmc\_ker\_ck} \) clock cycle

...

1111: ADDSET phase duration = \( 15 \times \text{fmc\_ker\_ck} \) clock cycles (default value after reset)

For each access mode address setup phase duration, refer to the respective figure (refer to Figure 164 to Figure 176 ).

Note: In synchronous accesses, this value is don't care.

In Muxed mode or mode D, the minimum value for ADDSET is 1.

In mode 1 and PSRAM memory, the minimum value for ADDSET is 1.

Note: PSRAMs (CRAMs) have a variable latency due to internal refresh. Therefore these memories issue the NWAIT signal during the whole latency phase to extend the latency as needed.
On PSRAMs (CRAMs) the filled DATLAT must be set to 0, so that the FMC exits its latency phase soon and starts sampling NWAIT from memory, then starts to read or write when the memory is ready.
This method can be used also with the latest generation of synchronous flash memories that issue the NWAIT signal, unlike older flash memories (check the datasheet of the specific flash memory being used).

SRAM/NOR-flash write timing registers for bank x (FMC_BWTRx)

Address offset: \( 0x104 + 0x8 \times (x - 1) \) , ( \( x = 1 \) to 4)

Reset value: 0x0FFF FFFF

This register contains the control information of each memory bank. It is used for SRAMs, PSRAMs and NOR flash memories. When the EXTMOD bit is set in the FMC_BCRx register, then this register is active for write access.

Bits 31:30 Reserved, must be kept at reset value.

Bits 29:28 ACCMOD[1:0] : Access mode.

These bits specify the asynchronous access modes as shown in the next timing diagrams. These bits are taken into account only when the EXTMOD bit in the FMC_BCRx register is 1.

00: access mode A

01: access mode B

10: access mode C

11: access mode D

Bits 27:20 Reserved, must be kept at reset value.

Bits 19:16 BUSTURN[3:0] : Bus turnaround phase duration

These bits are written by software to add a delay at the end of a write transaction to match the minimum time between consecutive transactions ( \( t_{EHEL} \) from ENx high to ENx low):

\( (BUSTURN + 1) \times fmc\_ker\_ck \text{ period} \geq t_{EHELmin} \)

The programmed bus turnaround delay is inserted between an asynchronous write transfer and any other asynchronous /synchronous read or write transfer to or from a static bank. The bank can be the same or different in case of read, in case of write the bank can be different except for muxed or mode D.

In some cases, whatever the programmed BUSTURN values, the bus turnaround delay is fixed as follows:

• • The bus turnaround delay is not inserted between two consecutive asynchronous write transfers to the same static memory bank except for muxed and D modes.
• • There is a bus turnaround delay of 2 FMC clock cycle between:
  • – Two consecutive synchronous writes (burst or single) to the same bank.
  • – A synchronous write (burst or single) transfer and an asynchronous write or read transfer to or from static memory bank.
• • There is a bus turnaround delay of 3 FMC clock cycle between:
  • – Two consecutive synchronous writes (burst or single) to different static bank.
  • – A synchronous write (burst or single) transfer and a synchronous read from the same or a different bank.

0000: BUSTURN phase duration = 0 fmc_ker_ck clock cycle added

...

1111: BUSTURN phase duration = 15 fmc_ker_ck clock cycles added (default value after reset)

Bits 15:8 DATAST[7:0] : Data-phase duration.

These bits are written by software to define the duration of the data phase (refer to Figure 164 to Figure 176 ), used in asynchronous SRAM, PSRAM and NOR flash memory accesses:

0000 0000: Reserved

0000 0001: DATAST phase duration = \( 1 \times \text{fmc\_ker\_ck} \) clock cycles

0000 0010: DATAST phase duration = \( 2 \times \text{fmc\_ker\_ck} \) clock cycles

...

1111 1111: DATAST phase duration = \( 255 \times \text{fmc\_ker\_ck} \) clock cycles (default value after reset)

Bits 7:4 ADDHLD[3:0] : Address-hold phase duration.

These bits are written by software to define the duration of the address hold phase (refer to Figure 164 to Figure 176 ), used in asynchronous multiplexed accesses:

0000: Reserved

0001: ADDHLD phase duration = \( 1 \times \text{fmc\_ker\_ck} \) clock cycle

0010: ADDHLD phase duration = \( 2 \times \text{fmc\_ker\_ck} \) clock cycle

...

1111: ADDHLD phase duration = \( 15 \times \text{fmc\_ker\_ck} \) clock cycles (default value after reset)

Note: In synchronous NOR flash accesses, this value is not used, the address hold phase is always 1 flash clock period duration.

Bits 3:0 ADDSET[3:0] : Address setup phase duration.

These bits are written by software to define the duration of the address setup phase in \( \text{fmc\_ker\_ck} \) cycles (refer to Figure 164 to Figure 176 ), used in asynchronous accesses:

0000: ADDSET phase duration = \( 0 \times \text{fmc\_ker\_ck} \) clock cycle

...

1111: ADDSET phase duration = \( 15 \times \text{fmc\_ker\_ck} \) clock cycles (default value after reset)

Note: In synchronous accesses, this value is not used, the address setup phase is always 1 flash clock period duration. In muxed mode, the minimum ADDSET value is 1.

23.8 NAND flash controller

The FMC generates the appropriate signal timings to drive 8- and 16-bit NAND flash memories.

The NAND bank is configured through dedicated registers ( Section 23.8.7 ). The programmable memory parameters include access timings (shown in Table 201 ) and ECC configuration.

Table 201. Programmable NAND flash access parameters

23.8.1 External memory interface signals

The following tables list the signals that are typically used to interface NAND flash memories.

Note: The prefix “N” identifies the signals which are active low.

8-bit NAND flash memory

Table 202. 8-bit NAND flash memory

Theoretically, there is no capacity limitation as the FMC can manage as many address cycles as needed.

16-bit NAND flash memory

Table 203. 16-bit NAND flash memory

Note: Theoretically, there is no capacity limitation as the FMC can manage as many address cycles as needed.

23.8.2 NAND flash supported memories and transactions

Table 204 shows the supported devices, access modes and transactions. Transactions not allowed (or not supported) by the NAND flash controller are shown in gray.

Table 204. Supported memories and transactions

Table 204. Supported memories and transactions (continued)

23.8.3 Timing diagrams for NAND flash memories

The NAND flash memory bank is managed through a set of registers:

• • Control register: FMC_PCR
• • Interrupt status register: FMC_SR
• • ECC register: FMC_ECCR
• • Timing register for Common memory space: FMC_PMEM
• • Timing register for Attribute memory space: FMC_PATT

Each timing configuration register contains three parameters used to define the number of fmc_ker_ck cycles for the three phases of any NAND flash access, plus one parameter that defines the timing to start driving the data bus when a write access is performed. Figure 182 shows the timing parameter definitions for common memory accesses, knowing that Attribute memory space access timings are similar.

Figure 182. NAND flash controller waveforms for common memory access

1. 1. NOE remains high (inactive) during write accesses. NWE remains high (inactive) during read accesses.
2. 2. For write accesses, the hold phase delay is (MEMHOLD) fmc_ker_ck cycles and for read access is (MEMHOLD + 1) fmc_ker_ck cycles.

23.8.4 NAND flash operations

The command latch enable (CLE) and address latch enable (ALE) signals of the NAND flash memory device are driven by address signals from the FMC. This means that to send a command or an address to the NAND flash memory, the CPU has to perform a write to a specific address in its memory space.

A typical page read operation from the NAND flash device requires the following steps:

1. 1. Program and enable the corresponding memory bank by configuring the FMC_PCR and FMC_PMEM (and for some devices, FMC_PATT, see Section 23.8.5: NAND flash prewait feature ) registers according to the characteristics of the NAND flash memory (PWID bits for the data bus width of the NAND flash memory, PWAITEN = 0 or 1 as needed, see Section 23.6.2: NAND flash memory address mapping for timing configuration).
2. 2. The CPU performs a byte write to the common memory space, with data byte equal to one flash command byte (for example 0x00 for Samsung NAND flash devices). The LE input of the NAND flash memory is active during the write strobe (low pulse on NWE), thus the written byte is interpreted as a command by the NAND flash memory. Once the command is latched by the memory device, it does not need to be written again for the following page read operations.
3. 3. The CPU can send the start address (STARTAD) for a read operation by writing four bytes (or three for smaller capacity devices), STARTAD[7:0], STARTAD[16:9], STARTAD[24:17] and finally STARTAD[25] (for 64 Mb x 8 bit NAND flash memories) in the common memory or attribute space. The ALE input of the NAND flash device is active during the write strobe (low pulse on NWE), thus the written bytes are interpreted as the start address for read operations. Using the attribute memory space makes it possible to use a different timing configuration of the FMC, which can be used

to implement the prewait functionality needed by some NAND flash memories (see details in Section 23.8.5: NAND flash prewait feature ).

1. 4. The controller waits for the NAND flash memory to be ready (R/NB signal high), before starting a new access to the same or another memory bank. While waiting, the controller holds the NCE signal active (low).
2. 5. The CPU can then perform byte read operations from the common memory space to read the NAND flash page (data field + Spare field) byte by byte.
3. 6. The next NAND flash page can be read without any CPU command or address write operation. This can be done in three different ways:
   • – by simply performing the operation described in step 5
   • – a new random address can be accessed by restarting the operation at step 3
   • – a new command can be sent to the NAND flash device by restarting at step 2

23.8.5 NAND flash prewait feature

Some NAND flash devices require that, after writing the last part of the address, the controller waits for the R/NB signal to go low. (see Figure 183 ).

Figure 183. Access to non ‘CE don’t care’ NAND-flash

1. 1. CPU wrote byte 0x00 at address 0x7001 0000.
2. 2. CPU wrote byte A7~A0 at address 0x7002 0000.
3. 3. CPU wrote byte A16~A9 at address 0x7002 0000.
4. 4. CPU wrote byte A24~A17 at address 0x7002 0000.
5. 5. CPU wrote byte A25 at address 0x8802 0000: FMC performs a write access using FMC_PATT2 timing definition, where \( ATTHOLD \ge 7 \) (providing that \( (7+1) \times fmc\_ker\_ck = 112\text{ ns} > t_{WB}\text{ max} \) ). This guarantees that NCE remains low until R/NB goes low and high again (only requested for NAND flash memories where NCE is not don't care).

When this function is required, it can be performed by programming the MEMHOLD value to meet the \( t_{WB} \) timing. However, any CPU read access to NAND flash memory has a hold delay of (MEMHOLD + 1) fmc_ker_ck cycles, and any CPU write access has a hold delay of (MEMHOLD) fmc_ker_ck cycles that is inserted between the rising edge of the NWE signal and the next access.

To cope with this timing constraint, the attribute memory space can be used by programming its timing register with an ATTHOLD value that meets the \( t_{WB} \) timing, and by keeping the MEMHOLD value at its minimum value. The CPU must then use the common memory space for all NAND flash read and write accesses, except when writing the last address byte to the NAND flash device, where the CPU must write to the attribute memory space.

23.8.6 Computation of the error correction code (ECC) in NAND flash memory

The FMC includes an error correction code computation hardware block. It reduces the host CPU workload when processing the ECC by software. The ECC block is associated with NAND bank.

The ECC algorithm implemented in the FMC can perform 1-bit error correction and 2-bit error detection per 256, 512, 1 024, 2 048, 4 096 or 8 192 bytes read or written from/to the NAND flash memory. It is based on the Hamming coding algorithm and consists in calculating the row and column parity.

The ECC modules monitor the NAND flash data bus and read/write signals (NCE and NWE) each time the NAND flash memory bank is active.

The ECC operates as follows:

• • When accessing NAND flash bank, the data present on the D[15:0] bus is latched and used for ECC computation.
• • When accessing any other address in NAND flash memory, the ECC logic is idle, and does not perform any operation. As a result, write operations to define commands or addresses to the NAND flash memory are not taken into account for ECC computation.

Once the desired number of bytes has been read/written from/to the NAND flash memory by the host CPU, the FMC_ECCR registers must be read to retrieve the computed value. Once read, they should be cleared by resetting the ECCEN bit to '0'. To compute a new data block, the ECCEN bit must be set to one in the FMC_PCR registers.

Execute below the sequence to perform an ECC computation:

1. 1. Enable the ECCEN bit in the FMC_PCR register.
2. 2. Write data to the NAND flash memory page. While the NAND page is written, the ECC block computes the ECC value.
3. 3. Wait until the ECC code is ready (FIFO empty).
4. 4. Read the ECC value available in the FMC_ECCR register and store it in a variable.
5. 5. Clear the ECCEN bit and then enable it in the FMC_PCR register before reading back the written data from the NAND page. While the NAND page is read, the ECC block computes the ECC value.
6. 6. Read the new ECC value available in the FMC_ECCR register.
7. 7. If the two ECC values are the same, no correction is required, otherwise there is an ECC error and the software correction routine returns information on whether the error can be corrected or not.

23.8.7 NAND flash controller registers

NAND flash control registers (FMC_PCR)

Address offset: 0x80

Reset value: 0x0000 0018

Bits 31:20 Reserved, must be kept at reset value.

Bits 19:17 ECCPS[2:0] : ECC page size.

These bits define the page size for the extended ECC:

• 000: 256 bytes
• 001: 512 bytes
• 010: 1024 bytes
• 011: 2048 bytes
• 100: 4096 bytes
• 101: 8192 bytes

Bits 16:13 TAR[3:0] : ALE to RE delay.

These bits set time from ALE low to RE low in number of fmc_ker_ck clock cycles.

Time is: \( t\_ar = (TAR + SET + 2) \times t_{fmc\_ker\_ck} \) where \( t_{fmc\_ker\_ck} \) is the FMC clock period

• 0000: 1 x fmc_ker_ck cycle (default)
• 1111: 16 x fmc_ker_ck cycles

Note: Set is MEMSET or ATTSET according to the addressed space.

Bits 12:9 TCLR[3:0] : CLE to RE delay.

These bits set time from CLE low to RE low in number of fmc_ker_ck clock cycles. The time is given by the following formula:

\( t\_clr = (TCLR + SET + 2) \times t_{fmc\_ker\_ck} \) where \( t_{fmc\_ker\_ck} \) is the fmc_ker_ck clock period

• 0000: 1 x fmc_ker_ck cycle (default)
• 1111: 16 x fmc_ker_ck cycles

Note: Set is MEMSET or ATTSET according to the addressed space.

Bits 8:7 Reserved, must be kept at reset value.

Bit 6 ECCEN : ECC computation logic enable bit

• 0: ECC logic is disabled and reset (default after reset),
• 1: ECC logic is enabled.

Bits 5:4 PWID[1:0] : Data bus width.

These bits define the external memory device width.

• 00: 8 bits
• 01: 16 bits (default after reset).
• 10: reserved.
• 11: reserved.

Bit 3 Reserved, must be kept at reset value.

Bit 2 PBKEN : NAND flash memory bank enable bit.

This bit enables the memory bank. Accessing a disabled memory bank causes an ERROR on AXI bus

0: Corresponding memory bank is disabled (default after reset)

1: Corresponding memory bank is enabled

Bit 1 PWAITEN : Wait feature enable bit.

This bit enables the Wait feature for the NAND flash memory bank:

0: disabled

1: enabled

Bit 0 Reserved, must be kept at reset value.

FIFO status and interrupt register (FMC_SR)

Address offset: 0x84

Reset value: 0x0000 0040

This register contains information about the FIFO status and interrupt. The FMC features a FIFO that is used when writing to memories to transfer up to 16 words of data.

This is used to quickly write to the FIFO and free the AXI bus for transactions to peripherals other than the FMC, while the FMC is draining its FIFO into the memory. One of these register bits indicates the status of the FIFO, for ECC purposes.

The ECC is calculated while the data are written to the memory. To read the correct ECC, the software must consequently wait until the FIFO is empty.

Bits 31:7 Reserved, must be kept at reset value.

Bit 6 FEMPT : FIFO empty.

Read-only bit that provides the status of the FIFO

0: FIFO not empty

1: FIFO empty

Bit 5 IFEN : Interrupt falling edge detection enable bit

0: Interrupt falling edge detection request disabled

1: Interrupt falling edge detection request enabled

Bit 4 ILEN : Interrupt high-level detection enable bit

0: Interrupt high-level detection request disabled

1: Interrupt high-level detection request enabled

Bit 3 IREN : Interrupt rising edge detection enable bit

0: Interrupt rising edge detection request disabled

1: Interrupt rising edge detection request enabled

Bit 2 IFS : Interrupt falling edge status

The flag is set by hardware and reset by software.

0: No interrupt falling edge occurred

1: Interrupt falling edge occurred

Note: If this bit is written by software to 1 it is set.

Bit 1 ILS : Interrupt high-level status

The flag is set by hardware and reset by software.

0: No Interrupt high-level occurred

1: Interrupt high-level occurred

Bit 0 IRS : Interrupt rising edge status

The flag is set by hardware and reset by software.

0: No interrupt rising edge occurred

1: Interrupt rising edge occurred

Note: If this bit is written by software to 1 it is set.

Common memory space timing register (FMC_PMEM)

Address offset: 0x88

Reset value: 0xFCFC FCFC

The FMC_PMEM read/write register contains the timing information for NAND flash memory bank. This information is used to access either the common memory space of the NAND flash for command, address write access and data read/write access.

Bits 31:24 MEMHIZ[7:0] : Common memory x data bus Hi-Z time

These bits define the number of fmc_ker_ck clock cycles during which the data bus is kept Hi-Z after the start of a NAND flash write access to common memory space. This is only valid for write transactions:

0000 0000: 0 x fmc_ker_ck cycle

1111 1110: 254 x fmc_ker_ck cycles

1111 1111: reserved.

Bits 23:16 MEMHOLD[7:0] : Common memory hold time

These bits define the number of fmc_ker_ck clock cycles for write accesses and fmc_ker_ck+1 clock cycles for read accesses during which the address is held (and data for write accesses) after the command is deasserted (NWE, NOE), for NAND flash read or write access to common memory space:

0000 0000: reserved.

0000 0001: 1 fmc_ker_ck cycle for write access / 3 fmc_ker_ck cycle for read access

1111 1110: 254 fmc_ker_ck cycles for write access / 257 fmc_ker_ck cycles for read access

1111 1111: reserved.

Bits 15:8 MEMWAIT[7:0] : Common memory wait time

These bits define the minimum number of fmc_ker_ck (+1) clock cycles to assert the command (NWE, NOE), for NAND flash read or write access to common memory space. The duration of command assertion is extended if the wait signal (NWAIT) is active (low) at the end of the programmed value of fmc_ker_ck:

0000 0000: reserved

0000 0001: x fmc_ker_ck cycles (+ wait cycle introduced by deasserting NWAIT)

1111 1110: 255 x fmc_ker_ck cycles (+ wait cycle introduced by deasserting NWAIT)

1111 1111: reserved.

Bits 7:0 MEMSET[7:0] : Common memory x setup time

These bits define the number of fmc_ker_ck (+1) clock cycles to set up the address before the command assertion (NWE, NOE), for NAND flash read or write access to common memory space:

0000 0000: fmc_ker_ck cycles

1111 1110: 255 x fmc_ker_ck cycles

1111 1111: reserved

Attribute memory space timing registers (FMC_PATT)

Address offset: 0x8C

Reset value: 0xFCFC FCFC

The FMC_PATT read/write register contains the timing information for NAND flash memory bank. It is used for 8-bit accesses to the attribute memory space of the NAND flash for the last address write access if the timing must differ from that of previous accesses (for Ready/Busy management, refer to Section 23.8.5: NAND flash prewait feature ).

Bits 31:24 ATTHIZ[7:0] : Attribute memory data bus Hi-Z time

These bits define the number of fmc_ker_ck clock cycles during which the data bus is kept in Hi-Z after the start of a NAND flash write access to attribute memory space on socket. Only valid for writ transaction:

0000 0000: 0 x fmc_ker_ck cycle

1111 1110: 254 x fmc_ker_ck cycles

1111 1111: reserved.

Bits 23:16 ATTHOLD[7:0] : Attribute memory hold time

These bits define the number of fmc_ker_ck clock cycles during which the address is held (and data for write access) after the command deassertion (NWE, NOE), for NAND flash read or write access to attribute memory space:

0000 0000: reserved

0000 0001: 1 x fmc_ker_ck cycle

1111 1110: 254 x fmc_ker_ck cycles

1111 1111: reserved.

These bits define the minimum number of x fmc_ker_ck (+1) clock cycles to assert the command (NWE, NOE), for NAND flash read or write access to attribute memory space. The duration for command assertion is extended if the wait signal (NWAIT) is active (low) at the end of the programmed value of fmc_ker_ck:

0000 0000: reserved

0000 0001: 2 x fmc_ker_ck cycles (+ wait cycle introduced by deassertion of NWAIT)

1111 1110: 255 x fmc_ker_ck cycles (+ wait cycle introduced by deasserting NWAIT)

1111 1111: reserved.

These bits define the number of fmc_ker_ck (+1) clock cycles to set up address before the command assertion (NWE, NOE), for NAND flash read or write access to attribute memory space:

0000 0000: 1 x fmc_ker_ck cycle

1111 1110: 255 x fmc_ker_ck cycles

1111 1111: reserved.

ECC result registers (FMC_ECCR)

Address offset: 0x94

Reset value: 0x0000 0000

This register contains the current error correction code value computed by the ECC computation modules of the FMC NAND controller. When the CPU reads/writes the data from a NAND flash memory page at the correct address (refer to Section 23.8.6: Computation of the error correction code (ECC) in NAND flash memory ), the data read/written from/to the NAND flash memory are processed automatically by the ECC computation module. When X bytes have been read (according to the ECCPS field in the FMC_PCR registers), the CPU must read the computed ECC value from the FMC_ECC registers. It then verifies if these computed parity data are the same as the parity value recorded in the spare area, to determine whether a page is valid, and, to correct it otherwise. The FMC_ECCR register should be cleared after being read by setting the ECCEN bit to '0'. To compute a new data block, the ECCEN bit must be set to '1'.

Bits 31:0 ECC[31:0] : ECC result

This field contains the value computed by the ECC computation logic. Table 205 describes the contents of these bitfields.

Table 205. ECC result relevant bits

23.9 SDRAM controller

23.9.1 SDRAM controller main features

The main features of the SDRAM controller are the following:

• • Two SDRAM banks with independent configuration
• • 8-bit, 16-bit, 32-bit data bus width
• • 13-bits Address Row, 11-bits Address Column, 4 internal banks: 4x16Mx32bit (256 MB), 4x16Mx16bit (128 MB), 4x16Mx8bit (64 MB)
• • Word, half-word, byte access
• • SDRAM clock can be fmc_ker_ck/2 or fmc_ker_ck/3
• • Automatic row and bank boundary management
• • Multibank ping-pong access
• • Programmable timing parameters
• • Automatic Refresh operation with programmable Refresh rate
• • Self-refresh mode
• • Power-down mode
• • SDRAM power-up initialization by software
• • CAS latency of 1,2,3
• • Cacheable Read FIFO with depth of 6 lines x32-bit (6 x14-bit address tag)

23.9.2 SDRAM External memory interface signals

At startup, the SDRAM I/O pins used to interface the FMC SDRAM controller with the external SDRAM devices must configured by the user application. The SDRAM controller I/O pins which are not used by the application, can be used for other purposes.

Table 206. SDRAM signals

23.9.3 SDRAM controller functional description

All SDRAM controller outputs (signals, address and data) change on the falling edge of the memory clock (FMC_SDCLK).

SDRAM initialization

The initialization sequence is managed by software. If the two banks are used, the initialization sequence must be generated simultaneously to Bank 1 and Bank 2 by setting the Target Bank bits CTB1 and CTB2 in the FMC_SDCMR register:

1. 1. Program the memory device features into the FMC_SDCRx register. The SDRAM clock frequency, RBURST and RPIPE must be programmed in the FMC_SDCR1 register.
2. 2. Program the memory device timing into the FMC_SDTRx register. The TRP and TRC timings must be programmed in the FMC_SDTR1 register.
3. 3. Set MODE bits to '001' and configure the Target Bank bits (CTB1 and/or CTB2) in the FMC_SDCMR register to start delivering the clock to the memory (SDCKE is driven high).
4. 4. Wait during the prescribed delay period. Typical delay is around 100 µs (refer to the SDRAM datasheet for the required delay after power-up).
5. 5. Set MODE bits to '010' and configure the Target Bank bits (CTB1 and/or CTB2) in the FMC_SDCMR register to issue a "Precharge All" command.
6. 6. Set MODE bits to '011', and configure the Target Bank bits (CTB1 and/or CTB2) as well as the number of consecutive Auto-refresh commands (NRFS) in the FMC_SDCMR register. Refer to the SDRAM datasheet for the number of Auto-refresh commands that should be issued. Typical number is 8.
7. 7. Configure the MRD field, set the MODE bits to '100', and configure the Target Bank bits (CTB1 and/or CTB2) in the FMC_SDCMR register to issue a "Load Mode Register" command and program the SDRAM device. In particular the Burst Length (BL) has to be set to '1') and the CAS latency has to be selected. If the Mode Register is not the same for both SDRAM banks, this step has to be repeated twice, once for each bank and the Target Bank bits set accordingly. For mobile SDRAM devices, the MRD field is also used to configure the extended mode register while issuing the Load Mode Register"
8. 8. Program the refresh rate in the FMC_SDRTR register
   The refresh rate corresponds to the delay between refresh cycles. Its value must be adapted to SDRAM devices.

At this stage the SDRAM device is ready to accept commands. If a system reset occurs during an ongoing SDRAM access, the data bus might still be driven by the SDRAM device. Therefore the SDRAM device must be first reinitialized after reset before issuing any new access by the NOR flash/PSRAM/SRAM or NAND flash controller.

Note: If two SDRAM devices are connected to the FMC, all the accesses performed at the same time to both devices by the Command Mode register (Load Mode Register command) are issued using the timing parameters configured for SDRAM Bank 1 (TMRD andTRAS timings) in the FMC_SDTR1 register.

SDRAM controller write cycle

The SDRAM controller accepts single and burst write requests and translates them into single memory accesses. In both cases, the SDRAM controller keeps track of the active row for each bank to be able to perform consecutive write accesses to different banks (Multibank ping-pong access).

Before performing any write access, the SDRAM bank write protection must be disabled by clearing the WP bit in the FMC_SDCRx register.

Figure 184. Burst write SDRAM access waveforms

The SDRAM controller always checks the next access.

• • If the next access is in the same row or in another active row, the write operation is carried out,
• • if the next access targets another row (not active), the SDRAM controller generates a precharge command, activates the new row and initiates a write command.

SDRAM controller read cycle

The SDRAM controller accepts single and burst read requests and translates them into single memory accesses. In both cases, the SDRAM controller keeps track of the active row in each bank to be able to perform consecutive read accesses in different banks (Multibank ping-pong access).

Figure 185. Burst read SDRAM access

The FMC SDRAM controller features a Cacheable read FIFO (6 lines x 32 bits). It is used to store data read in advance during the CAS latency period (up to 3 memory clock cycles, programmed FMC_SDCRx) and during the RPIPE delay when set to 2xfmc_ker_ck clock cycles as configured in FMC_SDCR1) following this formula: \( CAS\ Latency + 1 + (RPIPE\ DIV2) \) . The RBURST bit must be set in the FMC_SDCR1 register to anticipate the next read access.

Examples:

• • CAS=3, RPIPE= 2xfmc_ker_ck. In this case, 5 data (not committed) are stored in the FIFO (4 data during CAS latency and 1 data during RPIPE delay)
• • CAS=3, RPIPE= 1xfmc_ker_ck. In this case, 4 data (not committed) are stored in the FIFO (4 data during CAS latency)

The read FIFO features a 14-bit address tag to each line to identify its content: 11 bits for the column address, 2 bits to select the internal bank and the active row, and 1 bit to select the SDRAM device

When the end of the row is reached in advance during an burst read transaction, the data read in advance (not committed) are not stored in the read FIFO. For single read access, data are correctly stored in the FIFO.

Each time a read request occurs, the SDRAM controller checks:

• • If the address matches one of the address tags, data are directly read from the FIFO and the corresponding address tag/ line content is cleared and the remaining data in the FIFO are compacted to avoid empty lines.
• • Otherwise, a new read command is issued to the memory and the FIFO is updated with new data. If the FIFO is full, the older data are lost.

Figure 186. Logic diagram of Read access with RBURST bit set (CAS=2, RPIPE=0)

During a write access or a Precharge command, the read FIFO is flushed and ready to be filled with new data.

After the first read request, if the current access was not performed to a row boundary, the SDRAM controller anticipates the next read access during the CAS latency period and the RPIPE delay (if configured). This is done by incrementing the memory address. The following condition must be met:

• • RBURST control bit should be set to '1' in the FMC_SDCR1 register.

The address management depends on the next AXI request:

• • Next request is sequential (Burst access)
  In this case, the SDRAM controller increments the address.
• • Next request is not sequential
  • – If the new read request targets the same row or another active row, the new address is passed to the memory and the master is stalled for the CAS latency period, waiting for the new data from memory.
  • – If the new read request does not target an active row, the SDRAM controller generates a Precharge command, activates the new row, and initiates a read command.

If the RBURST is reset, the read FIFO is not used.

Row and bank boundary management

When a read or write access crosses a row boundary, if the next read or write access is sequential and the current access was performed to a row boundary, the SDRAM controller executes the following operations:

1. 1. Precharge of the active row,
2. 2. Activation of the new row
3. 3. Start of a read/write command.

At a row boundary, the automatic activation of the next row is supported for all columns and data bus width configurations.

If necessary, the SDRAM controller inserts additional clock cycles between the following commands:

• • Between Precharge and Active commands to match TRP parameter (only if the next access is in a different row in the same bank),
• • Between Active and Read commands to match the TRCD parameter.

These parameters are defined into the FMC_SDTRx register.

Refer to Figure 184 and Figure 185 for read and burst write access crossing a row boundary.

Figure 187. Read access crossing row boundary

Figure 188. Write access crossing row boundary

If the next access is sequential and the current access crosses a bank boundary, the SDRAM controller activates the first row in the next bank and initiates a new read/write command. Two cases are possible:

• • If the current bank is not the last one, the active row in the new bank must be precharged. At a bank boundary, the automatic activation of the next row is supported for all rows/columns and data bus width configuration.
• • If the current bank is the last one, the automatic activation of the next row is supported only when addressing 13-bit rows, 11-bit columns, 4 internal banks and 32-bit data bus SDRAM devices. Otherwise, the SDRAM address range is violated and an AXI slave error is generated.
• • In case of 13-bit row address, 11-bit column address, 4 internal banks and bus width 32-bit SDRAM memories, at boundary bank, the SDRAM controller continues to read/write from the second SDRAM device (assuming it has been initialized):
  1. a) The SDRAM controller activates the first row (after precharging the active row, if there is already an active row in the first internal bank, and initiates a new read/write command.
  2. b) If the first row is already activated, the SDRAM controller just initiates a read/write command.

SDRAM controller refresh cycle

The Auto-refresh command is used to refresh the SDRAM device content. The SDRAM controller periodically issues auto-refresh commands. An internal counter is loaded with the COUNT value in the register FMC_SDRTR. This value defines the number of memory clock cycles between the refresh cycles (refresh rate). When this counter reaches zero, an internal pulse is generated.

If a memory access is ongoing, the auto-refresh request is delayed. However, if the memory access and the auto-refresh requests are generated simultaneously, the auto-refresh request takes precedence.

If the memory access occurs during an auto-refresh operation, the request is buffered and processed when the auto-refresh is complete.

If a new auto-refresh request occurs while the previous one was not served, the RE (Refresh Error) bit is set in the Status register. An Interrupt is generated if it has been enabled (REIE = '1').

If SDRAM lines are not in idle state (not all row are closed), the SDRAM controller generates a PALL (Precharge ALL) command before the auto-refresh.

If the Auto-refresh command is generated by the FMC_SDCMR Command Mode register (Mode bits = '011'), a PALL command (Mode bits = '010') must be issued first.

23.9.4 Low-power modes

Two low-power modes are available:

• • Self-refresh mode
  The auto-refresh cycles are performed by the SDRAM device itself to retain data without external clocking.
• • Power-down mode
  The auto-refresh cycles are performed by the SDRAM controller.

Self-refresh mode

This mode is selected by setting the MODE bits to '101' and by configuring the Target Bank bits (CTB1 and/or CTB2) in the FMC_SDCMR register.

The SDRAM clock stops running after a TRAS delay and the internal refresh timer stops counting only if one of the following conditions is met:

• • A Self-refresh command is issued to both devices
• • One of the devices is not activated (SDRAM bank is not initialized).

Before entering Self-Refresh mode, the SDRAM controller automatically issues a PALL command.

If the Write data FIFO is not empty, all data are sent to the memory before activating the Self-refresh mode and the BUSY status flag remains set.

In Self-refresh mode, all SDRAM device inputs become don't care except for SDCKE which remains low.

The SDRAM device must remain in Self-refresh mode for a minimum period of time of TRAS and can remain in Self-refresh mode for an indefinite period beyond that. To guarantee this minimum period, the BUSY status flag remains high after the Self-refresh activation during a TRAS delay.

As soon as an SDRAM device is selected, the SDRAM controller generates a sequence of commands to exit from Self-refresh mode. After the memory access, the selected device remains in Normal mode.

To exit from Self-refresh, the MODE bits must be set to '000' (Normal mode) and the Target Bank bits (CTB1 and/or CTB2) must be configured in the FMC_SDCMR register.

Figure 189. Self-refresh mode

MS30450V1

Power-down mode

This mode is selected by setting the MODE bits to '110' and by configuring the Target Bank bits (CTB1 and/or CTB2) in the FMC_SDCMR register.

Figure 190. Power-down mode

If the Write data FIFO is not empty, all data are sent to the memory before activating the Power-down mode.

As soon as an SDRAM device is selected, the SDRAM controller exits from the Power-down mode. After the memory access, the selected SDRAM device remains in Normal mode.

During Power-down mode, all SDRAM device input and output buffers are deactivated except for the SDCKE which remains low.

The SDRAM device cannot remain in Power-down mode longer than the refresh period and cannot perform the Auto-refresh cycles by itself. Therefore, the SDRAM controller carries out the refresh operation by executing the operations below:

1. 1. Exit from Power-down mode and drive the SDCKE high
2. 2. Generate the PALL command only if a row was active during Power-down mode
3. 3. Generate the auto-refresh command
4. 4. Drive SDCKE low again to return to Power-down mode.

To exit from Power-down mode, the MODE bits must be set to '000' (Normal mode) and the Target Bank bits (CTB1 and/or CTB2) must be configured in the FMC_SDCMR register.

23.9.5 SDRAM controller registers

SDRAM Control registers for SDRAM memory bank x (FMC_SDCRx)

Address offset: \( 0x140 + 0x4 \times (x - 1) \) , ( \( x = 1 \) to \( 2 \) )

Reset value: 0x0000 02D0

This register contains the control parameters for each SDRAM memory bank

Bits 31:15 Reserved, must be kept at reset value.

Bits 14:13 RPIPE[1:0] : Read pipe

These bits define the delay, in fmc_ker_ck clock cycles, for reading data after CAS latency.

00: No fmc_ker_ck clock cycle delay

01: One fmc_ker_ck clock cycle delay

10: Two fmc_ker_ck clock cycle delay

11: reserved.

Note: The corresponding bits in the FMC_SDCR2 register is read only.

Bit 12 RBURST : Burst read

This bit enables Burst read mode. The SDRAM controller anticipates the next read commands during the CAS latency and stores data in the Read FIFO.

0: single read requests are not managed as bursts

1: single read requests are always managed as bursts

Note: The corresponding bit in the FMC_SDCR2 register is read only.

Bits 11:10 SDCLK[1:0] : SDRAM clock configuration

These bits define the SDRAM clock period for both SDRAM banks and allow disabling the clock before changing the frequency. In this case the SDRAM must be re-initialized.

00: SDCLK clock disabled

01: Reserved

10: SDCLK period = 2 x fmc_ker_ck periods

11: SDCLK period = 3 x fmc_ker_ck periods

Note: The corresponding bits in the FMC_SDCR2 register is read only.

Bit 9 WP : Write protection

This bit enables Write mode access to the SDRAM bank.

0: Write accesses allowed

1: Write accesses ignored

Bits 8:7 CAS[1:0] : CAS Latency

This bits sets the SDRAM CAS latency in number of memory clock cycles

00: reserved.

01: 1 cycle

10: 2 cycles

11: 3 cycles

Bit 6 NB : Number of internal banks

This bit sets the number of internal banks.

0: Two internal Banks

1: Four internal Banks

Bits 5:4 MWID[1:0] : Memory data bus width.

These bits define the memory device width.

• 00: 8 bits
• 01: 16 bits
• 10: 32 bits
• 11: reserved.

Bits 3:2 NR[1:0] : Number of row address bits

These bits define the number of bits of a row address.

• 00: 11 bit
• 01: 12 bits
• 10: 13 bits
• 11: reserved.

Bits 1:0 NC[1:0] : Number of column address bits

These bits define the number of bits of a column address.

• 00: 8 bits
• 01: 9 bits
• 10: 10 bits
• 11: 11 bits.

Note: Before modifying the RBURST or RPIPE settings or disabling the SDCLK clock, the user must first send a PALL command to make sure ongoing operations are complete.

SDRAM Timing registers for SDRAM memory bank x (FMC_SDTRx)

Address offset: \( 0x148 + 0x4 * (x - 1) \) , ( \( x = 1 \) to \( 2 \) )

Reset value: 0x0FFF FFFF

This register contains the timing parameters of each SDRAM bank

Bits 31:28 Reserved, must be kept at reset value.

Bits 27:24 TRCD[3:0] : Row to column delay

These bits define the delay, \( t_{RCD} \) , from the Activate command to a Read/Write command in number of memory clock cycles.

• 0000: 2 cycles
• 0001: 3 cycles
• ....
• 1111: 17 cycles

Note: \( t_{RCD} \) delay is replaced by \( (TWR[3:0]+2) \) cycles when \( TWR[3:0] > TRCD[3:0] \) .

These bits define the delay, \( t_{RP} \) , between a Precharge command and another command in number of memory clock cycles. The TRP timing is only configured in the FMC_SDTR1 register. If two SDRAM devices are used, the TRP must be programmed with the timing of the slowest device.

0000: 1 cycle

0001: 2 cycles

....

1111: 16 cycles

Note: The corresponding bits in the FMC_SDTR2 register are don't care.

These bits define the delay, \( t_{WR} \) , between a Write and a Precharge command in number of memory clock cycles.

0000: 1 cycle

0001: 2 cycles

....

1111: 16 cycles

Note: TWR must be programmed to match the write recovery time ( \( t_{WR} \) ) defined in the SDRAM datasheet, and to guarantee that:

Example: TRAS= 4 cycles, TRCD= 2 cycles. So, \( TWR \geq 2 \) cycles. TWR must be programmed to 0x1.

If two SDRAM devices are used, the FMC_SDTR1 and FMC_SDTR2 must be programmed with the same TWR timing corresponding to the slowest SDRAM device.

If only one SDRAM device is used, the TWR timing must be kept at reset value (0xF) for the not used bank.

These bits define the delay, \( t_{RC} \) , between the Refresh command and the Activate command, as well as the delay between two consecutive Refresh commands. It is expressed in number of memory clock cycles. The TRC timing is only configured in the FMC_SDTR1 register. If two SDRAM devices are used, the TRC must be programmed with the timings of the slowest device.

0000: 1 cycle

0001: 2 cycles

....

1111: 16 cycles

Note: TRC must match the TRC and TRFC (Auto Refresh period) timings defined in the SDRAM device datasheet.

Note: The corresponding bits in the FMC_SDTR2 register are don't care.

These bits define the minimum Self-refresh period in number of memory clock cycles.

0000: 1 cycle

0001: 2 cycles

....

1111: 16 cycles

Bits 7:4 TXSR[3:0] : Exit Self-refresh delay

These bits define the delay, \( t_{XSR} \) , from releasing the Self-refresh command to issuing the Activate command in number of memory clock cycles.
0000: 1 cycle
0001: 2 cycles
....
1111: 16 cycles

Note: If two SDRAM devices are used, the FMC_SDTR1 and FMC_SDTR2 must be programmed with the same TXSR timing corresponding to the slowest SDRAM device.

Bits 3:0 TMRD[3:0] : Load Mode Register to Active

These bits define the delay between a Load Mode Register command and an Active or Refresh command in number of memory clock cycles.
0000: 1 cycle
0001: 2 cycles
....
1111: 16 cycles

Note: If two SDRAM devices are connected, all the accesses performed simultaneously to both devices by the Command Mode register (Load Mode Register command) are issued using the timing parameters configured for Bank 1 (TMRD and TRAS timings) in the FMC_SDTR1 register.

The TRP and TRC timings are only configured in the FMC_SDTR1 register. If two SDRAM devices are used, the TRP and TRC timings must be programmed with the timings of the slowest device.

SDRAM Command mode register (FMC_SDCMR)

Address offset: 0x150

Reset value: 0x0000 0000

This register contains the command issued when the SDRAM device is accessed. This register is used to initialize the SDRAM device, and to activate the Self-refresh and the Power-down modes. As soon as the MODE field is written, the command is issued only to one or to both SDRAM banks according to CTB1 and CTB2 command bits. This register is the same for both SDRAM banks.

Bits 31:23 Reserved, must be kept at reset value.

Bits 22:9 MRD[13:0] : Mode Register definition

This 14-bit field defines the SDRAM Mode Register content. The Mode Register is programmed using the Load Mode Register command. The MRD[13:0] bits are also used to program the extended mode register for mobile SDRAM.

These bits define the number of consecutive Auto-refresh commands issued when MODE = '011'.

0000: 1 Auto-refresh cycle

0001: 2 Auto-refresh cycles

...

1110: 15 Auto-refresh cycles

1111: 16 Auto-refresh cycles

This bit indicates whether the command is issued to SDRAM Bank 1 or not.

0: Command not issued to SDRAM Bank 1

1: Command issued to SDRAM Bank 1

This bit indicates whether the command is issued to SDRAM Bank 2 or not.

0: Command not issued to SDRAM Bank 2

1: Command issued to SDRAM Bank 2

These bits define the command issued to the SDRAM device.

000: Normal Mode

001: Clock Configuration Enable

010: PALL ("All Bank Precharge") command

011: Auto-refresh command

100: Load Mode Register

101: Self-refresh command

110: Power-down command

111: Reserved

Note: When a command is issued, at least one Command Target Bank bit ( CTB1 or CTB2) must be set otherwise the command is ignored.

Note: If two SDRAM banks are used, the Auto-refresh and PALL command must be issued simultaneously to the two devices with CTB1 and CTB2 bits set otherwise the command is ignored.

Note: If only one SDRAM bank is used and a command is issued with it's associated CTB bit set, the other CTB bit of the unused bank must be kept to 0.

SDRAM refresh timer register (FMC_SDRTR)

Address offset: 0x154

Reset value: 0x0000 0000

This register sets the refresh rate in number of SDCLK clock cycles between the refresh cycles by configuring the Refresh Timer Count value.

Below an example of refresh rate calculation:

where 64 ms is the SDRAM refresh period.

The refresh rate must be increased by 20 SDRAM clock cycles (as in the above example) to obtain a safe margin if an internal refresh request occurs when a read request has been accepted. It corresponds to a COUNT value of '0000111000000' (448).

This 13-bit field is loaded into a timer which is decremented using the SDRAM clock. This timer generates a refresh pulse when zero is reached. The COUNT value must be set at least to 41 SDRAM clock cycles.

As soon as the FMC_SDRTR register is programmed, the timer starts counting. If the value programmed in the register is '0', no refresh is carried out. This register must not be reprogrammed after the initialization procedure to avoid modifying the refresh rate.

Each time a refresh pulse is generated, this 13-bit COUNT field is reloaded into the counter.

If a memory access is in progress, the Auto-refresh request is delayed. However, if the memory access and Auto-refresh requests are generated simultaneously, the Auto-refresh takes precedence. If the memory access occurs during a refresh operation, the request is buffered to be processed when the refresh is complete.

This register is common to SDRAM bank 1 and bank 2.

Bits 31:15 Reserved, must be kept at reset value.

Bit 14 REIE : RES Interrupt Enable

0: Interrupt is disabled

1: An Interrupt is generated if RE = 1

Bits 13:1 COUNT[12:0] : Refresh Timer Count

This 13-bit field defines the refresh rate of the SDRAM device. It is expressed in number of memory clock cycles. It must be set at least to 58 SDRAM clock cycles (0x34).

Refresh rate = (COUNT + 1) x SDRAM frequency clock

COUNT = (SDRAM refresh period / Number of rows) - 20

Bit 0 CRE : Clear Refresh error flag

This bit is used to clear the Refresh Error Flag (RE) in the Status Register.

0: no effect

1: Refresh Error flag is cleared

Note: The programmed COUNT value must not be equal to the sum of the following timings:
\( T_{WR} + T_{RP} + T_{RC} + T_{RCD} + 4 \) memory clock cycles .

SDRAM Status register (FMC_SDSR)

Address offset: 0x158

Reset value: 0x0000 0000

Bits 31:5 Reserved, must be kept at reset value.

Bits 4:3 MODES2[1:0] : Status Mode for Bank 2

These bits define the Status Mode of SDRAM Bank 2.

00: Normal Mode

01: Self-refresh mode

10: Power-down mode

Bits 2:1 MODES1[1:0] : Status Mode for Bank 1

These bits define the Status Mode of SDRAM Bank 1.

00: Normal Mode

01: Self-refresh mode

10: Power-down mode

Bit 0 RE : Refresh error flag

0: No refresh error has been detected

1: A refresh error has been detected

An interrupt is generated if REIE = 1 and RE = 1

23.9.6 FMC register map

The following table summarizes the FMC registers.

Table 207. FMC register map

Table 207. FMC register map (continued)

Table 207. FMC register map (continued)

Refer to Section 2.3 on page 150 for the register boundary addresses.