nfc_st25r3.c

Go to the documentation of this file.

/*
 * nfc_st25r3.c
 *
 *  Created on: 27. 12. 2025
 *      Author: Milan
 */
 
#if KOKOT
 
// ST25DV I2C Addresses
#define NFC4_I2C_ADDR_USER    (0x53 << 1) // User Memory/EEPROM
#define NFC4_I2C_ADDR_SYSTEM  (0x57 << 1) // System Configuration
 
// Register Addresses
#define REG_GPO_CTRL_DYN      0x2000
#define REG_EH_CTRL_DYN       0x2001  /* Energy-harvesting / field-presence status */
#define REG_MB_CTRL_DYN       0x200D //0x200D
#define REG_MB_LEN_DYN        0x200E
#define REG_MB_RAM_START      0x2008
 
// EH_CTRL_DYN bit masks
#define NFC4_EH_FIELD_ON      0x04  /* RF field is currently detected (FIELD_ON) */
 
/* RF busy-wait limit: 20 × 5 ms = 100 ms maximum wait before giving up */
#define NFC4_RF_BUSY_TIMEOUT  20U
 
#include "i2c.h"
#include "nfc_st25r3.h"
#include <string.h>
 
static int8_t _isNfc = 0;   // indicator whether sensor is active
 
int8_t nfc_st25r3_Is(I2C_HandleTypeDef *hi2c, int8_t tryInit)
{
    if (!_isNfc && tryInit)
        nfc_st25r3_Init(hi2c);
    return _isNfc;
}
 
static HAL_StatusTypeDef nfc_st25r3_PresentPassword(I2C_HandleTypeDef *hi2c)
{
    // Total 17 bytes: [0x09 (Validation Code)] + [8-byte PWD] + [8-byte PWD]
    uint8_t pwd_payload[17];
    pwd_payload[0] = 0x09;
    memset(&pwd_payload[1], 0x00, 16); // Default 8x 00h, repeated twice
 
    // MUST be written to 0x0900 in SYSTEM address space
    return HAL_I2C_Mem_Write(hi2c, NFC4_I2C_ADDR_SYSTEM, 0x0900, 2, pwd_payload, 17, 200);
}
 
static HAL_StatusTypeDef nfc_st25r3_onOff(I2C_HandleTypeDef *hi2c, uint8_t onOff)
{
    HAL_StatusTypeDef status = HAL_ERROR;
 
    if (_isNfc)
    {
        uint8_t reg_val, i; //, session_status = 0;
 
        // Configure GPO for ALL events:
        // 0x95 = GPO_EN(1), MsgReady(1), WriteEEPROM(1), FieldChange(1)
        reg_val = onOff;//0x95;
        for (i = 0; i < 5; i++)
        {
            status = HAL_I2C_Mem_Write(hi2c, NFC4_I2C_ADDR_USER, REG_GPO_CTRL_DYN, I2C_MEMADD_SIZE_16BIT, &reg_val, 1, 100);
            if (status == HAL_OK)
                break;  // for
            HAL_Delay(10);
        }
        _isNfc = (status == HAL_OK);
    }
    return status;
}
 
 
HAL_StatusTypeDef nfc_st25r3_On(I2C_HandleTypeDef *hi2c)
{
    // Configure GPO for ALL events:
    // 0x95 = GPO_EN(1), MsgReady(1), WriteEEPROM(1), FieldChange(1)
    return nfc_st25r3_onOff(hi2c, 0x95);
}
 
HAL_StatusTypeDef nfc_st25r3_Off(I2C_HandleTypeDef *hi2c)
{
    // Configure GPO for ALL events:
    // 0x95 = GPO_EN(1), MsgReady(1), WriteEEPROM(1), FieldChange(1)
    return nfc_st25r3_onOff(hi2c, 0x00);
}
 
HAL_StatusTypeDef nfc_st25r3_IsOn(I2C_HandleTypeDef *hi2c, uint8_t *onOff)
{
    HAL_StatusTypeDef status = HAL_ERROR;
 
    if (_isNfc)
    {
        uint8_t reg_val = 0;
        status = HAL_I2C_Mem_Read(hi2c, NFC4_I2C_ADDR_USER, REG_GPO_CTRL_DYN, I2C_MEMADD_SIZE_16BIT, &reg_val, 1, 100);
        if (status == HAL_OK)
            if (onOff != NULL)
                *onOff = (reg_val & 0x80) != 0;
    }
    return status;
}
 
HAL_StatusTypeDef nfc_st25r3_Init(I2C_HandleTypeDef *hi2c)
{
    HAL_StatusTypeDef status;
    uint8_t reg_val, i; //, session_status = 0;
 
    do
    {
        // 1. Wait for device to be ready
        if ((status = I2C_IsDeviceReadyMT(hi2c, NFC4_I2C_ADDR_USER, 10, 100)) != HAL_OK)
            break;
#if 0
        // 2. Present Password to modify system registers
        if ((status = nfc_st25r3_PresentPassword(hi2c)) != HAL_OK)
            break;
 
        // --- CRITICAL: Wait for the Session to stabilize ---
        HAL_Delay(50);
 
        // 3. Requires Password presentation first - this doesn't work
 
         reg_val = 0x01;
         if ((status = HAL_I2C_Mem_Write(hi2c, NFC4_I2C_ADDR_SYSTEM, 0x000D, 2, &reg_val, 1, 100)) != HAL_OK)
         break;
 
 
         /* coje toto ????? preco sa prepsuje - kokotina*/
        // 4. Enable Mailbox (Dynamic RAM)
        // We use a small loop because the RF field might cause a NACK
        reg_val = 0x01;
        for (i = 0; i < 5; i++)
        {
            status = HAL_I2C_Mem_Write(hi2c, NFC4_I2C_ADDR_USER, REG_MB_CTRL_DYN, I2C_MEMADD_SIZE_16BIT, &reg_val, 1, 100);
            if (status == HAL_OK)
                break;  // for
            HAL_Delay(10);
        }
        if (status != HAL_OK)
            break;
 
        // --- CRITICAL: Wait for the Session to stabilize ---
        HAL_Delay(50);
 
        // 5. FORCE CLEAR the status (The "Deadlock Breaker")
        // This forces Bit 0 (Host Put) and Bit 1 (RF Put) to 0.
        reg_val = 0x00;
        if ((status = HAL_I2C_Mem_Write(hi2c, NFC4_I2C_ADDR_USER, REG_MB_CTRL_DYN, I2C_MEMADD_SIZE_16BIT, &reg_val, 1, 100)) != HAL_OK)
            break;
#endif
        // --- MANDATORY DELAY ---
        // The chip needs time to process the Mailbox Enable before changing GPO settings
        HAL_Delay(20);
        _isNfc = 1;
        nfc_st25r3_Off(hi2c);
    } while (0);
    return status;
}
 
HAL_StatusTypeDef nfc_st25r3_ReadEEPROM(I2C_HandleTypeDef *hi2c, uint16_t addr, uint8_t *pData, uint16_t len)
{
    return (_isNfc) ? HAL_I2C_Mem_Read(hi2c, NFC4_I2C_ADDR_USER, addr, I2C_MEMADD_SIZE_16BIT, pData, len, 500) : HAL_ERROR;
}
 
int8_t nfc_st25r3_IsRFBusy(I2C_HandleTypeDef *hi2c)
{
    uint8_t reg_val = 0;
 
    if (!_isNfc)
        return 0;
 
    /* Read EH_CTRL_DYN; if the I2C read fails assume the field is not active */
    if (HAL_I2C_Mem_Read(hi2c, NFC4_I2C_ADDR_USER, REG_EH_CTRL_DYN,
                         I2C_MEMADD_SIZE_16BIT, &reg_val, 1, 50) != HAL_OK)
        return 0;
 
    /* FIELD_ON (bit 2) is set while an RF field is present */
    return (reg_val & NFC4_EH_FIELD_ON) ? 1 : 0;
}
 
HAL_StatusTypeDef nfc_st25r3_WriteEEPROM(I2C_HandleTypeDef *hi2c, uint16_t addr, uint8_t *pData, uint16_t len)
{
    HAL_StatusTypeDef status = HAL_ERROR;
 
    if (_isNfc)
    {
        status = HAL_OK;
 
        /* Wait for RF write to complete
        uint8_t retry_count = 0;
        while (nfc_st25r3_IsRFBusy(hi2c) && status == HAL_OK)
        {
            HAL_Delay(5);
            if (++retry_count >= NFC4_RF_BUSY_TIMEOUT)
                status = HAL_TIMEOUT;
        } */
        if (status == HAL_OK)
            do
            {
                uint16_t i = 0;
                while (i < len)
                {
                    /* ST25DV page size is 4 bytes for write operations */
                    /* Clip chunk to: remaining bytes, max 4, and must not cross 4-byte page */
                    uint16_t page_offset = (addr + i) % 4;  // offset within current 4-byte page
                    uint16_t max_in_page = 4 - page_offset;  // bytes left in this page
                    uint16_t remaining   = len - i;
                    uint16_t chunk       = remaining < max_in_page ? remaining : max_in_page;
 
                    /* Poll for ACK — device NACKs during internal write cycle */
                    uint8_t retry = 0;
                    do
                    {
                        status = HAL_I2C_Mem_Write(hi2c, NFC4_I2C_ADDR_USER, addr + i, I2C_MEMADD_SIZE_16BIT, &pData[i], chunk, 100);
                        if (status == HAL_OK)
                            break;
                        HAL_Delay(2);
                    } while (++retry < 10);
 
                    if (status != HAL_OK)
                        break;
                    i += chunk;
                    HAL_Delay(6);  // tW: ensure write cycle completes before next page
                }
            }while(0);
    }
    return status;
}
 
void nfc_st25r3_ResetEEPROM(I2C_HandleTypeDef *hi2c, uint16_t len)
{
    uint8_t zero = 0;
 
    if (_isNfc)
        for (uint16_t i = 0; i < len; i++)
        {
            nfc_st25r3_WriteEEPROM(hi2c, i, &zero, 1);
        }
}
 
HAL_StatusTypeDef nfc_st25r3_ProcessMailBox(I2C_HandleTypeDef *hi2c)
{
    uint8_t mb_ctrl, mb_len;
 
    if (_isNfc)
    {
        // Check if Mailbox has a message from RF (Phone)
        HAL_I2C_Mem_Read(hi2c, NFC4_I2C_ADDR_USER, REG_MB_CTRL_DYN, I2C_MEMADD_SIZE_16BIT, &mb_ctrl, 1, 100);
 
        if (mb_ctrl & 0x02)
        { // RF Put Msg bit
            HAL_I2C_Mem_Read(hi2c, NFC4_I2C_ADDR_USER, REG_MB_LEN_DYN, I2C_MEMADD_SIZE_16BIT, &mb_len, 1, 100);
            uint8_t buffer[256];
            uint16_t msg_len = mb_len + 1;
 
            HAL_I2C_Mem_Read(hi2c, NFC4_I2C_ADDR_USER, REG_MB_RAM_START, I2C_MEMADD_SIZE_16BIT, buffer, msg_len, 200);
            nfc_st25r3_OnMailboxData(buffer, msg_len);
            return HAL_OK;
        }
    }
    return HAL_ERROR;
}
 
HAL_StatusTypeDef nfc_st25r3_WriteMailBoxNDEF(I2C_HandleTypeDef *hi2c, char *text)
{
    if (!_isNfc)
        return HAL_ERROR;
 
    uint8_t payload[128];
    uint8_t text_len = strlen(text);
 
    // Simple NDEF Text Record Wrapper
    payload[0] = 0xD1; // MB=1, ME=1, SR=1, Tnf=1 (NFC Forum Well-known type)
    payload[1] = 0x01; // Type Length
    payload[2] = text_len + 3; // Payload Length (3 bytes for status/lang + text)
    payload[3] = 'T';  // Type: Text
    payload[4] = 0x02; // Status: UTF-8, "en" length = 2
    payload[5] = 'e';  // 'e'
    payload[6] = 'n';  // 'n'
    memcpy(&payload[7], text, text_len);
 
    return HAL_I2C_Mem_Write(hi2c, NFC4_I2C_ADDR_USER, REG_MB_RAM_START, I2C_MEMADD_SIZE_16BIT, payload, text_len + 7, 200);
}
 
HAL_StatusTypeDef nfc_st25r3_SetRFMgmt(I2C_HandleTypeDef *hi2c, uint8_t enable)
{
    if (!_isNfc)
        return HAL_ERROR;
 
    nfc_st25r3_PresentPassword(hi2c);
    uint8_t val = enable ? 0x00 : 0x01; // 0 = RF Enabled, 1 = RF Disabled
    return HAL_I2C_Mem_Write(hi2c, NFC4_I2C_ADDR_SYSTEM, 0x0003, 2, &val, 1, 100);
}
 
#endif