spi_eeprom.c File Reference

#include "reg.h"
#include "status_reg.h"
#include "telemetry.h"
#include "util.h"
#include <stdbool.h>
#include <string.h>
#include <tenstorrent/board_variables.h>
#include <tenstorrent/smc_msg.h>
#include <tenstorrent/msgqueue.h>
#include <tenstorrent/sys_init_defines.h>
#include <tenstorrent/tt_boot_fs.h>
#include <zephyr/drivers/mspi.h>
#include <zephyr/drivers/flash.h>
#include <zephyr/logging/log.h>
#include <zephyr/init.h>
#include <zephyr/kernel.h>

Include dependency graph for spi_eeprom.c:

Macros
#define	SPI_PAGE_SIZE   256
#define	SECTOR_SIZE   4096
#define	SPI_BUFFER_SIZE   4096
#define	BYTE_GET(v, b)
#define	SSI_RX_DLY_SR_DEPTH   64
#define	SPI_RX_SAMPLE_DELAY_TRAIN_ADDR   0x13FFC
#define	SPI_RX_SAMPLE_DELAY_TRAIN_DATA   0xA5A55A5A
#define	FLASH_JEDEC_ID_MT25QU512ABB   0x20BB20
#define	FLASH_UNLOCK_ERR_MISSING_VARIABLES   1
	FLASH_UNLOCK exit code: the host did not verify every required board variable. The required set is reported in response->data[1].

Functions
	LOG_MODULE_REGISTER (spi_eeprom, CONFIG_TT_APP_LOG_LEVEL)
static void	EepromSetup (void)
static int	SpiBlockRead (uint32_t spi_address, uint32_t num_bytes, uint8_t *dest)
static int	SpiSmartWrite (uint32_t address, const uint8_t *data, uint32_t num_bytes)
static bool	check_csm_region (uint32_t addr, uint32_t num_bytes)
static uint8_t	read_eeprom_handler (const union request *request, struct response *response)
static uint8_t	write_eeprom_handler (const union request *request, struct response *response)
static uint8_t	confirm_flashed_spi_handler (const union request *request, struct response *response)
	Confirms SPI flash operation by echoing challenge data.
static uint8_t	flash_lock_handler (const union request *request, struct response *response)
	Locks flash memory to prevent writes.
static uint32_t	required_board_variables (void)
	The board variables a host must verify before this board may be flashed.
static uint8_t	flash_unlock_handler (const union request *request, struct response *response)
	Unlocks flash memory to allow writes.
	REGISTER_MESSAGE (TT_SMC_MSG_READ_EEPROM, read_eeprom_handler)
	REGISTER_MESSAGE (TT_SMC_MSG_WRITE_EEPROM, write_eeprom_handler)
	REGISTER_MESSAGE (TT_SMC_MSG_CONFIRM_FLASHED_SPI, confirm_flashed_spi_handler)
	REGISTER_MESSAGE (TT_SMC_MSG_FLASH_LOCK, flash_lock_handler)
	REGISTER_MESSAGE (TT_SMC_MSG_FLASH_UNLOCK, flash_unlock_handler)
static int	InitSpiFS (void)
	SYS_INIT_APP (InitSpiFS)

Variables
static uint8_t	spi_page_buf [4096]
static uint8_t	spi_global_buffer [4096]
static struct flash_pages_info	page_info
static bool	flash_locked = true
static const struct device *	flash = DEVICE_DT_GET_OR_NULL(DT_NODELABEL(spi_flash))

Macro Definition Documentation

BYTE_GET

#define BYTE_GET	(		v,
			b )

Value:

FIELD_GET(0xFFu << ((b) * 8), (v))

FLASH_JEDEC_ID_MT25QU512ABB

#define FLASH_JEDEC_ID_MT25QU512ABB   0x20BB20

FLASH_UNLOCK_ERR_MISSING_VARIABLES

#define FLASH_UNLOCK_ERR_MISSING_VARIABLES   1

FLASH_UNLOCK exit code: the host did not verify every required board variable. The required set is reported in response->data[1].

SECTOR_SIZE

#define SECTOR_SIZE   4096

SPI_BUFFER_SIZE

#define SPI_BUFFER_SIZE   4096

SPI_PAGE_SIZE

#define SPI_PAGE_SIZE   256

SPI_RX_SAMPLE_DELAY_TRAIN_ADDR

#define SPI_RX_SAMPLE_DELAY_TRAIN_ADDR   0x13FFC

SPI_RX_SAMPLE_DELAY_TRAIN_DATA

#define SPI_RX_SAMPLE_DELAY_TRAIN_DATA   0xA5A55A5A

SSI_RX_DLY_SR_DEPTH

#define SSI_RX_DLY_SR_DEPTH   64

Function Documentation

check_csm_region()

bool check_csm_region ( uint32_t addr, uint32_t num_bytes )

static

confirm_flashed_spi_handler()

uint8_t confirm_flashed_spi_handler ( const union request * request, struct response * response )

static

Confirms SPI flash operation by echoing challenge data.

Echoes the challenge data from request field back to response data[1] to confirm firmware update completion

EepromSetup()

void EepromSetup ( void )

static

flash_lock_handler()

uint8_t flash_lock_handler ( const union request * request, struct response * response )

static

Locks flash memory to prevent writes.

Sets the global flash_locked flag to true, blocking all subsequent flash write operations until unlocked. The host must prove board compatibility again before the next unlock.

flash_unlock_handler()

uint8_t flash_unlock_handler ( const union request * request, struct response * response )

static

Unlocks flash memory to allow writes.

Clears the global flash_locked flag, enabling flash write operations, but only once the host has declared that it verified every board variable this board requires.

An image is compatible with a board if its board type matches (always verified by SPI writers) and the board variable checks pass. A host that does not know a variable exists cannot have checked it, so it is refused rather than allowed to write an image that the board cannot boot.

We also need a special exception for tt-flash + luwen. luwen unlocks & relocks (with no variable verification bits) in every call to spi_flash, failing if the unlock fails. Thus, if already unlocked, we ignore a no-bit unlock.

The requirement is reported in response->data[1] on success and failure alike, so that a rejected host can name what it must check.

InitSpiFS()

int InitSpiFS ( void )

static

LOG_MODULE_REGISTER()

LOG_MODULE_REGISTER	(	spi_eeprom	,
		CONFIG_TT_APP_LOG_LEVEL	)

read_eeprom_handler()

uint8_t read_eeprom_handler ( const union request * request, struct response * response )

static

REGISTER_MESSAGE() [1/5]

REGISTER_MESSAGE	(	TT_SMC_MSG_CONFIRM_FLASHED_SPI	,
		confirm_flashed_spi_handler	)

REGISTER_MESSAGE() [2/5]

REGISTER_MESSAGE	(	TT_SMC_MSG_FLASH_LOCK	,
		flash_lock_handler	)

REGISTER_MESSAGE() [3/5]

REGISTER_MESSAGE	(	TT_SMC_MSG_FLASH_UNLOCK	,
		flash_unlock_handler	)

REGISTER_MESSAGE() [4/5]

REGISTER_MESSAGE	(	TT_SMC_MSG_READ_EEPROM	,
		read_eeprom_handler	)

REGISTER_MESSAGE() [5/5]

REGISTER_MESSAGE	(	TT_SMC_MSG_WRITE_EEPROM	,
		write_eeprom_handler	)

required_board_variables()

uint32_t required_board_variables ( void )

static

The board variables a host must verify before this board may be flashed.

See board_variables.h. Requiring a variable makes the board unflashable by any tool that does not know how to check it, so a variable is only required where getting it wrong would produce an unbootable image.

SpiBlockRead()

int SpiBlockRead ( uint32_t spi_address, uint32_t num_bytes, uint8_t * dest )

static

SpiSmartWrite()

int SpiSmartWrite ( uint32_t address, const uint8_t * data, uint32_t num_bytes )

static

SYS_INIT_APP()

SYS_INIT_APP

(

InitSpiFS

)

write_eeprom_handler()

uint8_t write_eeprom_handler ( const union request * request, struct response * response )

static

Variable Documentation

flash

const struct device* flash = DEVICE_DT_GET_OR_NULL(DT_NODELABEL(spi_flash))

static

flash_locked

bool flash_locked = true

static

page_info

struct flash_pages_info page_info

static

spi_global_buffer

uint8_t spi_global_buffer[4096]

static

spi_page_buf

uint8_t spi_page_buf[4096]

static