unit_ST25R3916.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2025 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_NFC_UNIT_ST25R3916_HPP
#define M5_UNIT_NFC_UNIT_ST25R3916_HPP
 
#include <M5UnitComponent.hpp>
#include "ST25R3916_definition.hpp"
#include "nfc/nfc.hpp"
#include "nfc/a/nfca.hpp"
#include "nfc/a/mifare.hpp"
#include "nfc/crypto/mifare_classic_crypto1.hpp"
#include "nfc/b/nfcb.hpp"
#include "nfc/f/nfcf.hpp"
#include "nfc/v/nfcv.hpp"
 
namespace m5 {
namespace nfc {
struct ListenerST25R3916ForA;
struct ListenerST25R3916ForF;
}  // namespace nfc
namespace unit {
 
namespace nfc {
struct AdapterST25R3916;
}  // namespace nfc
 
class UnitST25R3916 : public Component {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitST25R3916, 0x50 /* I2C address */);
 
public:
    explicit UnitST25R3916(const uint8_t arg = DEFAULT_ADDRESS) : Component(arg)
    {
        auto ccfg  = component_config();
        ccfg.clock = 400 * 1000U;
        component_config(ccfg);
    }
    virtual ~UnitST25R3916() = default;
 
    virtual bool begin() override;
    virtual void update(const bool force = false) override;
 
    struct config_t {
        m5::nfc::NFC mode{m5::nfc::NFC::A};  
        bool vdd_voltage_5V{false};          
        uint8_t tx_am_modulation{13};        
        bool using_irq{};                    
        uint8_t irq{};                       
        bool emulation{};                    
    };
 
 
    inline config_t config()
    {
        return _cfg;
    }
    inline void config(const config_t& cfg)
    {
        _cfg = cfg;
    }
 
    inline m5::nfc::NFC NFCMode() const
    {
        return _nfcMode;
    }
    bool configureNFCMode(const m5::nfc::NFC mode);
    bool configureEmulationMode(const m5::nfc::NFC mode);
 
    inline bool isNFCMode(const m5::nfc::NFC mode)
    {
        return NFCMode() == mode;
    }
 
    bool writeDirectCommand(const uint8_t cmd, const uint8_t* data = nullptr, const uint32_t dlen = 0u);
 
 
    bool clearInterrupts();
 
 
    bool writeInitiatorOperationMode(const st25r3916::InitiatorOperationMode mode, const uint8_t optional = 0);
    bool writeTargetOperationMode(const st25r3916::TargetOperationMode mode, const uint8_t optional = 0);
 
    bool writeBitrate(const m5::nfc::Bitrate tx, const m5::nfc::Bitrate rx);
 
 
    bool readFIFOSize(uint16_t& bytes, uint8_t& bits);
    uint32_t readFIFO(uint16_t& actual, uint8_t* buf, const uint16_t buf_size);
    bool writeFIFO(const uint8_t* buf, const uint16_t buf_size);
 
 
    inline bool readIOConfiguration1(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_IO_CONFIGURATION_1, value);
    }
    inline bool writeIOConfiguration1(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_IO_CONFIGURATION_1, value);
    }
    inline bool readIOConfiguration2(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_IO_CONFIGURATION_2, value);
    }
    inline bool writeIOConfiguration2(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_IO_CONFIGURATION_2, value);
    }
    inline bool readIOConfiguration(uint16_t& value)
    {
        return read_register16(st25r3916::command::REG_IO_CONFIGURATION_1, value);
    }
    inline bool writeIOConfiguration(const uint16_t value)
    {
        return write_register16(st25r3916::command::REG_IO_CONFIGURATION_1, value);
    }
 
 
    inline bool readOperationControl(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_OPERATION_CONTROL, value);
    }
    inline bool writeOperationControl(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_OPERATION_CONTROL, value);
    }
    inline bool readModeDefinition(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_MODE_DEFINITION, value);
    }
    inline bool writeModeDefinition(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_MODE_DEFINITION, value);
    }
    inline bool readBitrateDefinition(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_BITRATE_DEFINITION, value);
    }
    inline bool writeBitrateDefinition(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_BITRATE_DEFINITION, value);
    }
 
 
    inline bool readSettingsISO14443A(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_ISO14443A_SETTINGS, value);
    }
    inline bool writeSettingsISO14443A(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_ISO14443A_SETTINGS, value);
    }
    inline bool readSettingsISO14443B(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_ISO14443B_SETTINGS, value);
    }
    inline bool writeSettingsISO14443B(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_ISO14443B_SETTINGS, value);
    }
    inline bool readSettingsFelica(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_FELICA_SETTINGS, value);
    }
    inline bool writeSettingsFelica(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_FELICA_SETTINGS, value);
    }
    inline bool readNFCIP1PassiveTargetDefinition(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_NFCIP_1_PASSIVE_TARGET_DEFINITION, value);
    }
    inline bool writeNFCIP1PassiveTargetDefinition(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_NFCIP_1_PASSIVE_TARGET_DEFINITION, value);
    }
    inline bool readStreamModeDefinition(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_STREAM_MODE_DEFINITION, value);
    }
    inline bool writeStreamModeDefinition(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_STREAM_MODE_DEFINITION, value);
    }
    inline bool readAuxiliaryDefinition(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_AUXILIARY_DEFINITION, value);
    }
    inline bool writeAuxiliaryDefinition(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_AUXILIARY_DEFINITION, value);
    }
 
    inline bool readEMDSuppressionConfiguration(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_EMD_SUPPRESSION_CONFIGURATION, value);
    }
    inline bool writeEMDSuppressionConfiguration(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_EMD_SUPPRESSION_CONFIGURATION, value);
    }
    inline bool readSubcarrierStartTimer(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_SUBCARRIER_START_TIMER, value);
    }
    inline bool writeSubcarrierStartTimer(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_SUBCARRIER_START_TIMER, value);
    }
 
 
    inline bool readReceiverConfiguration1(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_RECEIVER_CONFIGURATION_1, value);
    }
    inline bool writeReceiverConfiguration1(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_RECEIVER_CONFIGURATION_1, value);
    }
    inline bool readReceiverConfiguration2(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_RECEIVER_CONFIGURATION_2, value);
    }
    inline bool writeReceiverConfiguration2(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_RECEIVER_CONFIGURATION_2, value);
    }
    inline bool readReceiverConfiguration3(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_RECEIVER_CONFIGURATION_3, value);
    }
    inline bool writeReceiverConfiguration3(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_RECEIVER_CONFIGURATION_3, value);
    }
    inline bool readReceiverConfiguration4(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_RECEIVER_CONFIGURATION_4, value);
    }
    inline bool writeReceiverConfiguration4(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_RECEIVER_CONFIGURATION_4, value);
    }
    inline bool readReceiverConfiguration(uint32_t& value)
    {
        return read_register32(st25r3916::command::REG_RECEIVER_CONFIGURATION_1, value);
    }
    inline bool writeReceiverConfiguration(const uint32_t value)
    {
        return write_register32(st25r3916::command::REG_RECEIVER_CONFIGURATION_1, value);
    }
 
    inline bool readP2PReceiverConfiguration(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_P2P_RECEIVER_CONFIGURATION, value);
    }
    inline bool writeP2PReceiverConfiguration(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_P2P_RECEIVER_CONFIGURATION, value);
    }
    inline bool readCorrelatorConfiguration1(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_CORRELATOR_CONFIGURATION_1, value);
    }
    inline bool writeCorrelatorConfiguration1(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_CORRELATOR_CONFIGURATION_1, value);
    }
    inline bool readCorrelatorConfiguration2(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_CORRELATOR_CONFIGURATION_2, value);
    }
    inline bool writeCorrelatorConfiguration2(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_CORRELATOR_CONFIGURATION_2, value);
    }
    inline bool readCorrelatorConfiguration(uint16_t& value)
    {
        return read_register16(st25r3916::command::REG_CORRELATOR_CONFIGURATION_1, value);
    }
    inline bool writeCorrelatorConfiguration(const uint16_t value)
    {
        return write_register16(st25r3916::command::REG_CORRELATOR_CONFIGURATION_1, value);
    }
 
 
    inline bool readMaskReceiveTimer(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_MASK_RECEIVER_TIMER, value);
    }
    inline bool writeMaskReceiveTimer(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_MASK_RECEIVER_TIMER, value);
    }
    inline bool readNoResponseTimer1(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_NO_RESPONSE_TIMER_1, value);
    }
    inline bool writeNoResponseTimer1(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_NO_RESPONSE_TIMER_1, value);
    }
    inline bool readNoResponseTimer2(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_NO_RESPONSE_TIMER_2, value);
    }
    inline bool writeNoResponseTimer2(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_NO_RESPONSE_TIMER_2, value);
    }
    inline bool readNoResponseTimer(uint16_t& value)
    {
        return read_register16(st25r3916::command::REG_NO_RESPONSE_TIMER_1, value);
    }
    inline bool writeNoResponseTimer(const uint16_t value)
    {
        return write_register16(st25r3916::command::REG_NO_RESPONSE_TIMER_1, value);
    }
    inline bool readTimerAndEMVControl(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_TIMER_AND_EMV_CONTROL, value);
    }
    inline bool writeTimerAndEMVControl(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_TIMER_AND_EMV_CONTROL, value);
    }
    inline bool readGeneralPurposeTimer1(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_GENERAL_PURPOSE_TIMER_1, value);
    }
    inline bool writeGeneralPurposeTimer1(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_GENERAL_PURPOSE_TIMER_1, value);
    }
    inline bool readGeneralPurposeTimer2(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_GENERAL_PURPOSE_TIMER_2, value);
    }
    inline bool writeGeneralPurposeTimer2(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_GENERAL_PURPOSE_TIMER_2, value);
    }
    inline bool readGeneralPurposeTimer(uint16_t& value)
    {
        return read_register16(st25r3916::command::REG_GENERAL_PURPOSE_TIMER_1, value);
    }
    inline bool writeGeneralPurposeTimer(const uint16_t value)
    {
        return write_register16(st25r3916::command::REG_GENERAL_PURPOSE_TIMER_1, value);
    }
    inline bool readPPON2FieldWaiting(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_PPON2_FIELD_WAITING, value);
    }
    inline bool writePPON2FieldWaiting(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_PPON2_FIELD_WAITING, value);
    }
 
    inline bool readSquelchTimer(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_SQUELCH_TIMER, value);
    }
    inline bool writeSquelchTimer(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_SQUELCH_TIMER, value);
    }
    inline bool readNFCFieldOnGuardTimer(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_NFC_FIELD_ON_GUARD_TIMER, value);
    }
    inline bool writeNFCFieldOnGuardTimer(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_NFC_FIELD_ON_GUARD_TIMER, value);
    }
 
 
    inline bool readMaskMainInterrupt(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_MASK_MAIN_INTERRUPT, value);
    }
    inline bool writeMaskMainInterrupt(const uint8_t value)
    {
        if (write_register8(st25r3916::command::REG_MASK_MAIN_INTERRUPT, value)) {
            _enabled_irq = (_enabled_irq & 0x00FFFFFF) | ((uint32_t)~value << 24);
            return true;
        }
        return false;
    }
    inline bool readMaskTimerAndNFCInterrupt(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_MASK_TIMER_AND_NFC_INTERRUPT, value);
    }
    inline bool writeMaskTimerAndNFCInterrupt(const uint8_t value)
    {
        if (write_register8(st25r3916::command::REG_MASK_TIMER_AND_NFC_INTERRUPT, value)) {
            _enabled_irq = (_enabled_irq & 0xFF00FFFF) | ((uint32_t)~value << 16);
            return true;
        }
        return false;
    }
    inline bool readMaskErrorAndWakeupInterrupt(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_MASK_ERROR_AND_WAKEUP_INTERRUPT, value);
    }
    inline bool writeMaskErrorAndWakeupInterrupt(const uint8_t value)
    {
        if (write_register8(st25r3916::command::REG_MASK_ERROR_AND_WAKEUP_INTERRUPT, value)) {
            _enabled_irq = (_enabled_irq & 0xFFFF00FF) | ((uint32_t)~value << 8);
            return true;
        }
        return false;
    }
    inline bool readMaskPassiveTargetInterrupt(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_MASK_PASSIVE_TARGET_INTERRUPT, value);
    }
    inline bool writeMaskPassiveTargetInterrupt(const uint8_t value)
    {
        if (write_register8(st25r3916::command::REG_MASK_PASSIVE_TARGET_INTERRUPT, value)) {
            _enabled_irq = (_enabled_irq & 0xFFFFFF00) | (uint32_t)~value;
            return true;
        }
        return false;
    }
    inline bool readMaskInterrupts(uint32_t& value)
    {
        return read_register32(st25r3916::command::REG_MASK_MAIN_INTERRUPT, value);
    }
    inline bool writeMaskInterrupts(const uint32_t value)
    {
        if (write_register32(st25r3916::command::REG_MASK_MAIN_INTERRUPT, value)) {
            _enabled_irq = ~value;
            return true;
        }
        return false;
    }
 
    inline bool readMainInterrupt(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_MAIN_INTERRUPT, value);
    }
    inline bool readTimerAndNFCInterrupt(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_TIMER_AND_NFC_INTERRUPT, value);
    }
    inline bool readErrorAndWakeupInterrupt(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_ERROR_AND_WAKEUP_INTERRUPT, value);
    }
    inline bool readPassiveTargetInterrupt(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_PASSIVE_TARGET_INTERRUPT, value);
    }
    bool readInterrupts(uint32_t& value);
 
    inline bool readFIFOStatus1(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_FIFO_STATUS_1, value);
    }
    inline bool readFIFOStatus2(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_FIFO_STATUS_2, value);
    }
    inline bool readFIFOStatus(uint16_t& value)
    {
        return read_register16(st25r3916::command::REG_FIFO_STATUS_1, value);
    }
 
    inline bool readCollisionDisplay(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_COLLISION_DISPLAY, value);
    }
    inline bool readPassiveTargetDisplay(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_PASSIVE_TARGET_DISPLAY, value);
    }
 
 
    inline bool readNumberOfTransmittedBytes1(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_NUMBER_OF_TRANSMITTED_BYTES_1, value);
    }
    inline bool writeNumberOfTransmittedBytes1(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_NUMBER_OF_TRANSMITTED_BYTES_1, value);
    }
    inline bool readNumberOfTransmittedBytes2(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_NUMBER_OF_TRANSMITTED_BYTES_2, value);
    }
    inline bool writeNumberOfTransmittedBytes2(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_NUMBER_OF_TRANSMITTED_BYTES_2, value);
    }
    inline bool readNumberOfTransmittedBytes(uint16_t& value)
    {
        return read_register16(st25r3916::command::REG_NUMBER_OF_TRANSMITTED_BYTES_1, value);
    }
    inline bool writeNumberOfTransmittedBytes(const uint16_t value)
    {
        return write_register16(st25r3916::command::REG_NUMBER_OF_TRANSMITTED_BYTES_1, value);
    }
 
    inline bool writeNumberOfTransmittedBytes(const uint16_t bytes, const uint8_t bits)
    {
        // M5_LIB_LOGD("TransmitBytes:%u, %u", bytes, bits);
        return writeNumberOfTransmittedBytes(((bytes & 0x01FF) << 3 /* ntx 0-12 */) | (bits & 0x07 /*nbtx 0-2*/));
    }
 
    inline bool readBitrateDetectionDisplay(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_BITRATE_DETECTION_DISPLAY, value);
    }
 
 
    inline bool readADConverterOutput(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_AD_CONVERTER_OUTPUT, value);
    }
 
 
    inline bool readAntennaTuningControl1(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_ANTENNA_TUNING_CONTROL_1, value);
    }
    inline bool writeAntennaTuningControl1(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_ANTENNA_TUNING_CONTROL_1, value);
    }
    inline bool readAntennaTuningControl2(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_ANTENNA_TUNING_CONTROL_2, value);
    }
    inline bool writeAntennaTuningControl2(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_ANTENNA_TUNING_CONTROL_2, value);
    }
    inline bool readAntennaTuningControl(uint16_t& value)
    {
        return read_register16(st25r3916::command::REG_ANTENNA_TUNING_CONTROL_1, value);
    }
    inline bool writeAntennaTuningControl(const uint16_t value)
    {
        return write_register16(st25r3916::command::REG_ANTENNA_TUNING_CONTROL_1, value);
    }
 
 
    inline bool readTXDriver(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_TX_DRIVER, value);
    }
    inline bool writeTXDriver(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_TX_DRIVER, value);
    }
    inline bool readPassiveTargetModulation(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_PASSIVE_TARGET_MODULATION, value);
    }
    inline bool writePassiveTargetModulation(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_PASSIVE_TARGET_MODULATION, value);
    }
 
    inline bool readAuxiliaryModulationSetting(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_AUXILIARY_MODULATION_SETTING, value);
    }
    inline bool writeAuxiliaryModulationSetting(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_AUXILIARY_MODULATION_SETTING, value);
    }
    inline bool readTXDriverTiming(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_TX_DRIVER_TIMING, value);
    }
    inline bool writeTXDriverTiming(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_TX_DRIVER_TIMING, value);
    }
 
 
    inline bool readExternalFieldDetectorActivationThreshold(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_EXTERNAL_FIELD_DETECTOR_ACTIVATION_THRESHOLD, value);
    }
    inline bool writeExternalFieldDetectorActivationThreshold(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_EXTERNAL_FIELD_DETECTOR_ACTIVATION_THRESHOLD, value);
    }
    inline bool readExternalFieldDetectorDeactivationThreshold(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_EXTERNAL_FIELD_DETECTOR_DEACTIVATION_THRESHOLD, value);
    }
    inline bool writeExternalFieldDetectorDeactivationThreshold(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_EXTERNAL_FIELD_DETECTOR_DEACTIVATION_THRESHOLD, value);
    }
 
    inline bool readResistiveAMModulation(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_RESISTIVE_AM_MODULATION, value);
    }
    inline bool writeResistiveAMModulation(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_RESISTIVE_AM_MODULATION, value);
    }
    inline bool readTXDriverTimingDisplay(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_TX_DRIVER_TIMING_DISPLAY, value);
    }
 
 
    inline bool readRegulatorVoltageControl(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_REGULATOR_VOLTAGE_CONTROL, value);
    }
    inline bool writeRegulatorVoltageControl(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_REGULATOR_VOLTAGE_CONTROL, value);
    }
    inline bool readRegulatorDisplay(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_REGULATOR_DISPLAY, value);
    }
 
 
    inline bool readRSSIDisplay(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_RSSI_DISPLAY, value);
    }
    inline bool readGainReductionState(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_GAIN_REDUCTION_STATE, value);
    }
 
 
    inline bool readCapacitiveSensorControl(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_CAPACITIVE_SENSOR_CONTROL, value);
    }
    inline bool writeCapacitiveSensorControl(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_CAPACITIVE_SENSOR_CONTROL, value);
    }
    inline bool readCapacitiveSensorDisplay(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_CAPACITIVE_SENSOR_DISPLAY, value);
    }
 
 
    inline bool readAuxiliaryDisplay(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_AUXILIARY_DISPLAY, value);
    }
 
 
    inline bool readWakeupTimerControl(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_WAKEUP_TIMER_CONTROL, value);
    }
    inline bool writeWakeupTimerControl(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_WAKEUP_TIMER_CONTROL, value);
    }
 
    inline bool readAmplitudeMeasurementConfiguration(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_AMPLITUDE_MEASUREMENT_CONFIGURATION, value);
    }
    inline bool writeAmplitudeMeasurementConfiguration(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_AMPLITUDE_MEASUREMENT_CONFIGURATION, value);
    }
    inline bool readAmplitudeMeasurementReference(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_AMPLITUDE_MEASUREMENT_REFERENCE, value);
    }
    inline bool writeAmplitudeMeasurementReference(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_AMPLITUDE_MEASUREMENT_REFERENCE, value);
    }
    inline bool readAmplitudeMeasurementAutoAveragingDisplay(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_AMPLITUDE_MEASUREMENT_AUTO_AVERAGING_DISPLAY, value);
    }
    inline bool readAmplitudeMeasurementDisplay(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_AMPLITUDE_MEASUREMENT_DISPLAY, value);
    }
 
    inline bool readPhaseMeasurementConfiguration(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_PHASE_MEASUREMENT_CONFIGURATION, value);
    }
    inline bool writePhaseMeasurementConfiguration(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_PHASE_MEASUREMENT_CONFIGURATION, value);
    }
    inline bool readPhaseMeasurementReference(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_PHASE_MEASUREMENT_REFERENCE, value);
    }
    inline bool writePhaseMeasurementReference(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_PHASE_MEASUREMENT_REFERENCE, value);
    }
    inline bool readPhaseMeasurementAutoAveragingDisplay(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_PHASE_MEASUREMENT_AUTO_AVERAGING_DISPLAY, value);
    }
    inline bool readPhaseMeasurementDisplay(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_PHASE_MEASUREMENT_DISPLAY, value);
    }
 
    inline bool readCapacitanceMeasurementConfiguration(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_CAPACITANCE_MEASUREMENT_CONFIGURATION, value);
    }
    inline bool writeCapacitanceMeasurementConfiguration(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_CAPACITANCE_MEASUREMENT_CONFIGURATION, value);
    }
    inline bool readCapacitanceMeasurementReference(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_CAPACITANCE_MEASUREMENT_REFERENCE, value);
    }
    inline bool writeCapacitanceMeasurementReference(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_CAPACITANCE_MEASUREMENT_REFERENCE, value);
    }
    inline bool readCapacitanceMeasurementAutoAveragingDisplay(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_CAPACITANCE_MEASUREMENT_AUTO_AVERAGING_DISPLAY, value);
    }
    inline bool readCapacitanceMeasurementDisplay(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_CAPACITANCE_MEASUREMENT_DISPLAY, value);
    }
 
 
    inline bool readOvershootProtectionConfiguration1(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_OVERSHOOT_PROTECTION_CONFIGURATION_1, value);
    }
    inline bool writeOvershootProtectionConfiguration1(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_OVERSHOOT_PROTECTION_CONFIGURATION_1, value);
    }
    inline bool readOvershootProtectionConfiguration2(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_OVERSHOOT_PROTECTION_CONFIGURATION_2, value);
    }
    inline bool writeOvershootProtectionConfiguration2(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_OVERSHOOT_PROTECTION_CONFIGURATION_2, value);
    }
    inline bool readOvershootProtectionConfiguration(uint16_t& value)
    {
        return read_register16(st25r3916::command::REG_OVERSHOOT_PROTECTION_CONFIGURATION_1, value);
    }
    inline bool writeOvershootProtectionConfiguration(const uint16_t value)
    {
        return write_register16(st25r3916::command::REG_OVERSHOOT_PROTECTION_CONFIGURATION_1, value);
    }
 
    inline bool readUndershootProtectionConfiguration1(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_UNDERSHOOT_PROTECTION_CONFIGURATION_1, value);
    }
    inline bool writeUndershootProtectionConfiguration1(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_UNDERSHOOT_PROTECTION_CONFIGURATION_1, value);
    }
    inline bool readUndershootProtectionConfiguration2(uint8_t& value)
    {
        return read_register8(st25r3916::command::REG_UNDERSHOOT_PROTECTION_CONFIGURATION_2, value);
    }
    inline bool writeUndershootProtectionConfiguration2(const uint8_t value)
    {
        return write_register8(st25r3916::command::REG_UNDERSHOOT_PROTECTION_CONFIGURATION_2, value);
    }
    inline bool readUndershootProtectionConfiguration(uint16_t& value)
    {
        return read_register16(st25r3916::command::REG_UNDERSHOOT_PROTECTION_CONFIGURATION_1, value);
    }
    inline bool writeUndershootProtectionConfiguration(const uint16_t value)
    {
        return write_register16(st25r3916::command::REG_UNDERSHOOT_PROTECTION_CONFIGURATION_1, value);
    }
 
 
    bool readICIdentity(uint8_t& type, uint8_t& rev);
 
 
    bool disableField();
    bool enableField();
 
    // ----------------------------------------------------------------------------------------------
 
    uint32_t nfcaTransceive(uint8_t* rx, uint16_t& rx_len, const uint8_t* tx, const uint16_t tx_len,
                            const uint32_t timeout_ms);
    bool nfcaTransmit(const uint8_t* tx, const uint16_t tx_len, const uint32_t timeout_ms);
    bool nfcaEmulationTransmit(const uint8_t* tx, const uint16_t tx_len);
    bool nfcaReceive(uint8_t* rx, uint16_t& rx_len, const uint32_t timeout_ms);
 
    inline bool nfcaRequest(uint16_t& atqa)
    {
        return nfca_request_wakeup(atqa, true);
    }
    inline bool nfcaWakeup(uint16_t& atqa)
    {
        return nfca_request_wakeup(atqa, false);
    }
    bool nfcaSelectWithAnticollision(bool& completed, m5::nfc::a::PICC& picc, const uint8_t lv);
    bool nfcaSelect(const m5::nfc::a::PICC& picc);
    bool nfcaReadBlock(uint8_t rx[16], const uint8_t block);
    bool nfcaWriteBlock(const uint8_t block, const uint8_t tx[16]);
    bool nfcaHlt();
 
    // ----------------------------------------------------------------------------------------------
 
    inline bool mifareClassicAuthenticateA(
        const m5::nfc::a::PICC& picc, const uint8_t block,
        const m5::nfc::a::mifare::classic::Key& key = m5::nfc::a::mifare::classic::DEFAULT_KEY)
    {
        return mifare_classic_authenticate(m5::nfc::a::Command::AUTH_WITH_KEY_A, picc, block, key);
    }
    inline bool mifareClassicAuthenticateB(
        const m5::nfc::a::PICC& picc, const uint8_t block,
        const m5::nfc::a::mifare::classic::Key& key = m5::nfc::a::mifare::classic::DEFAULT_KEY)
    {
        return mifare_classic_authenticate(m5::nfc::a::Command::AUTH_WITH_KEY_B, picc, block, key);
    }
    bool mifareClassicValueBlock(const m5::nfc::a::Command cmd, const uint8_t block, const uint32_t arg = 0);
 
    // ----------------------------------------------------------------------------------------------
 
    bool nfcbTransceive(uint8_t* rx, uint16_t& rx_len, const uint8_t* tx, const uint16_t tx_len,
                        const uint32_t timeout_ms);
    bool nfcbTransmit(const uint8_t* tx, const uint16_t tx_len, const uint32_t timeout_ms);
    bool nfcbReceive(uint8_t* rx, uint16_t& rx_len, const uint32_t timeout_ms);
 
    // ----------------------------------------------------------------------------------------------
 
    bool nfcfTransceive(uint8_t* rx, uint16_t& rx_len, const uint8_t* tx, const uint16_t tx_len,
                        const uint32_t timeout_ms);
    bool nfcfTransmit(const uint8_t* tx, const uint16_t tx_len, const uint32_t timeout_ms);
    bool nfcfEmulationTransmit(const uint8_t* tx, const uint16_t tx_len);
    bool nfcfReceive(uint8_t* rx, uint16_t& rx_len, const uint32_t timeout_ms);
 
    // ----------------------------------------------------------------------------------------------
 
    bool nfcvTransceive(uint8_t* rx, uint16_t& rx_len, const uint8_t* tx, const uint16_t tx_bytes,
                        const uint32_t timeout_ms,
                        const m5::nfc::v::ModulationMode mode = m5::nfc::v::ModulationMode::OneOf4);
    bool nfcvTransmit(const uint8_t* tx, const uint16_t tx_len, const uint32_t timeout_ms,
                      const m5::nfc::v::ModulationMode mode = m5::nfc::v::ModulationMode::OneOf4);
    bool nfcvReceive(uint8_t* rx, uint16_t& rx_len, const uint32_t timeout_ms);
 
    bool writePtMemoryA(const uint8_t* tx, const uint32_t tx_len);
    bool writePtMemoryF(const uint8_t* tx, const uint32_t tx_len);
    bool writePtMemoryTSN(const uint8_t* tx, const uint32_t tx_len);
    bool readPtMemory(uint8_t* rx, const uint32_t rx_len);
 
    // For debug
    void dumpRegister();
 
protected:
    friend struct m5::nfc::ListenerST25R3916ForA;
    friend struct m5::nfc::ListenerST25R3916ForF;
 
    static void IRAM_ATTR on_irq(void* arg);
 
    bool read_register8(const uint8_t reg, uint8_t& v);
    bool read_register8(const uint16_t reg, uint8_t& v);
    bool write_register8(const uint8_t reg, const uint8_t v);
    bool write_register8(const uint16_t reg, const uint8_t v);
    bool read_register16(const uint8_t reg, uint16_t& v);
    bool read_register16(const uint16_t reg, uint16_t& v);
    bool write_register16(const uint8_t reg, const uint16_t v);
    bool write_register16(const uint16_t reg, const uint16_t v);
    bool read_register32(const uint8_t reg, uint32_t& v);
    bool read_register32(const uint16_t reg, uint32_t& v);
    bool write_register32(const uint8_t reg, const uint32_t v);
    bool write_register32(const uint16_t reg, const uint32_t v);
 
    bool write_fwt_timer(const uint32_t ms);
    bool write_mask_receiver_timer(const uint32_t us);
    bool write_squelch_timer(const uint32_t us);
 
    uint32_t wait_for_interrupt(const uint32_t irq, const uint32_t timeout_ms = 100);
 
    bool wait_for_FIFO(const uint32_t timeout_ms, const uint16_t required_size = 0);
    bool read_FIFO(std::vector<uint8_t>& out);
 
    // Mode configuration
    bool configure_nfc_a();
    bool configure_nfc_b();
    bool configure_nfc_f();
    bool configure_nfc_v();
    bool nfc_initial_field_on();
 
    bool configure_emulation_a();
    bool configure_emulation_f();
 
    // Utility
    bool modify_bit_register8(const uint8_t reg, const uint8_t set_mask, const uint8_t clear_mask);
    bool modify_bit_register8(const uint16_t reg, const uint8_t set_mask, const uint8_t clear_mask);
    bool set_bit_register8(const uint8_t reg, const uint8_t bits);
    bool set_bit_register8(const uint16_t reg, const uint8_t bits);
    bool clear_bit_register8(const uint8_t reg, const uint8_t bits);
    bool clear_bit_register8(const uint16_t reg, const uint8_t bits);
    inline bool change_bit_register8(const uint8_t reg, const uint8_t bits, const uint8_t mask)
    {
        return modify_bit_register8(reg, mask & bits, mask);
    }
    inline bool change_bit_register8(const uint16_t reg, const uint8_t bits, const uint8_t mask)
    {
        return modify_bit_register8(reg, mask & bits, mask);
    }
    bool change_test_bit_register8(const uint8_t reg, const uint8_t bits, const uint8_t mask);
    bool change_test_bit_register8(const uint16_t reg, const uint8_t bits, const uint8_t mask);
 
    bool modify_interrupts(const uint32_t clr, const uint32_t set);
    inline bool enable_interrupts(const uint32_t mask)
    {
        return modify_interrupts(mask, 0);
    }
    inline bool disable_interrupts(const uint32_t mask)
    {
        return modify_interrupts(0, mask);
    }
 
    bool enable_osc();
    bool disable_field();
 
    // NFC-A
    bool nfca_request_wakeup(uint16_t& atqa, const bool req);
    bool nfca_anti_collision(uint8_t rbuf[5], const uint8_t lv);
 
    // MIFARE
    bool mifare_classic_send_encrypt(const uint8_t* tx, const uint16_t tx_len);
    bool mifare_classic_transceive_encrypt(uint8_t* rx, uint16_t& rx_len, const uint8_t* tx, const uint16_t tx_len,
                                           const uint32_t timeout_ms, const bool include_crc, const bool decrypt);
    bool mifare_classic_authenticate(const m5::nfc::a::Command cmd, const m5::nfc::a::PICC& picc, const uint8_t block,
                                     const m5::nfc::a::mifare::classic::Key& key);
 
private:
    config_t _cfg{};
 
    volatile uint32_t _stored_irq{};
    uint32_t _enabled_irq{};  // for !_using_irq
 
    volatile bool _interrupt_occurred{};
    m5::nfc::NFC _nfcMode{};
    bool _encrypted{};
    bool _using_irq{};
 
    m5::nfc::a::mifare::classic::Crypto1 _crypto1{};
};
 
class CapST25R3916 : public UnitST25R3916 {
    M5_UNIT_COMPONENT_HPP_BUILDER(CapST25R3916, 0x06 /* SPI CS pin */);
 
public:
    explicit CapST25R3916(const uint8_t cs_pin = DEFAULT_ADDRESS);
    virtual ~CapST25R3916() = default;
 
    virtual bool begin() override;
};
 
}  // namespace unit
}  // namespace m5
#endif