nfc_layer_f.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2025 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_NFC_NFC_LAYER_NFC_LAYER_F_HPP
#define M5_UNIT_NFC_NFC_LAYER_NFC_LAYER_F_HPP
 
#include "nfc/layer/nfc_layer.hpp"
#include "nfc/f/nfcf.hpp"
#include "nfc/layer/ndef_layer.hpp"
#include <vector>
#include <memory>
 
namespace m5 {
namespace unit {
class UnitST25R3916;
class CapST25R3916;
}  // namespace unit
 
namespace nfc {
 
class NFCLayerF : public NFCLayerInterface {
public:
    struct Adapter;
    explicit NFCLayerF(m5::unit::UnitST25R3916& u);
    explicit NFCLayerF(m5::unit::CapST25R3916& u);
    virtual ~NFCLayerF();
 
    virtual uint16_t maximum_fifo_depth() const override;
 
    inline bool isActive(const m5::nfc::f::PICC& picc) const
    {
        return _activePICC.valid() && _activePICC == picc;
    }
    const m5::nfc::f::PICC& activatedPICC() const
    {
        return _activePICC;
    }
 
 
    bool polling(m5::nfc::f::PICC& picc, const uint16_t system_code, const m5::nfc::f::RequestCode request_code,
                 const m5::nfc::f::TimeSlot time_slot);
 
    bool detect(m5::nfc::f::PICC& picc, const uint32_t timeout_ms = 100U);
    inline bool detect(std::vector<m5::nfc::f::PICC>& piccs,
                       m5::nfc::f::TimeSlot time_slot = m5::nfc::f::TimeSlot::Slot16, const uint32_t timeout_ms = 500U)
    {
        return detect(piccs, nullptr, 0, time_slot, timeout_ms);
    }
    inline bool detect(std::vector<m5::nfc::f::PICC>& piccs, const uint16_t private_code,
                       m5::nfc::f::TimeSlot time_slot = m5::nfc::f::TimeSlot::Slot16, const uint32_t timeout_ms = 500U)
    {
        return detect(piccs, &private_code, 1, time_slot, timeout_ms);
    }
    bool detect(std::vector<m5::nfc::f::PICC>& piccs, const uint16_t* private_code, const uint8_t pc_size,
                m5::nfc::f::TimeSlot time_slot = m5::nfc::f::TimeSlot::Slot16, const uint32_t timeout_ms = 500U);
 
    bool activate(const m5::nfc::f::PICC& picc);
    inline bool reactivate(const m5::nfc::f::PICC& picc)
    {
        return activate(picc);
    }
 
 
    bool deactivate();
 
    bool requestService(uint16_t& key_version, const uint16_t node_code);
    bool requestService(uint16_t key_version[], const uint16_t* node_code, const uint8_t node_num);
 
    inline bool requestResponse(m5::nfc::f::standard::Mode& mode)
    {
        return _activePICC.valid() && request_response_impl(_activePICC, mode);
    }
 
    bool requestSystemCode(uint16_t code_list[255], uint8_t& code_num);
 
    bool dump();
    bool dump(const m5::nfc::f::block_t block);
 
 
    inline bool read16(uint8_t rx[16], const m5::nfc::f::block_t block,
                       const uint16_t service_code = m5::nfc::f::service_random_read)
    {
        return read16(rx, &block, 1, service_code);
    }
    bool read16(uint8_t rx[16], const m5::nfc::f::block_t* block, const uint8_t block_num,
                const uint16_t service_code = m5::nfc::f::service_random_read);
 
    bool read(uint8_t* rx, uint16_t& rx_len, const m5::nfc::f::block_t sblock);
 
    inline bool read(uint8_t* rx, uint16_t& rx_len, const m5::nfc::f::block_t* block_list, const uint8_t block_num,
                     const uint16_t* service_code, const uint8_t service_num)
    {
        return _activePICC.valid() &&
               read_without_encryption_impl(rx, rx_len, block_list, block_num, service_code, service_num, _activePICC);
    }
 
    bool write16(const m5::nfc::f::block_t block, const uint8_t tx[16], const uint16_t tx_len);
    bool write(const m5::nfc::f::block_t sblock, const uint8_t* tx, const uint16_t tx_len);
 
    bool clearSPAD();
 
 
 
    bool internalAuthenticate(const uint8_t ck[16], const uint16_t ckv, const uint8_t rc[16]);
    bool externalAuthenticate(const uint8_t ck[16], const uint16_t ckv);
 
    void clearAuthenticate()
    {
        _authenticated = false;
    }
 
    bool readWithMAC16(uint8_t rx[16], const m5::nfc::f::block_t block);
 
    bool writeWithMAC16(const m5::nfc::f::block_t block, const uint8_t tx[16], const uint16_t tx_len);
 
 
    bool ndefIsValidFormat(bool& valid);
    bool ndefRead(m5::nfc::ndef::TLV& msg);
    bool ndefWrite(const m5::nfc::ndef::TLV& msg);
 
    bool writeSupportNDEF(const bool enabled);
 
protected:
    virtual bool read(uint8_t* rx, uint16_t& rx_len, const uint16_t saddr) override;
    virtual bool write(const uint16_t saddr, const uint8_t* tx, const uint16_t tx_len) override;
    inline virtual uint16_t first_user_block() const override
    {
        return _activePICC.firstUserBlock();
    }
    inline virtual uint16_t last_user_block() const override
    {
        return _activePICC.lastUserBlock();
    }
    inline virtual uint16_t user_area_size() const override
    {
        return _activePICC.userAreaSize();
    }
    inline virtual uint16_t unit_size_read() const override
    {
        return 16;
    }
    inline virtual uint16_t unit_size_write() const override
    {
        return 16;
    }
    inline virtual uint8_t maximum_read_blocks() const override
    {
        return _activePICC.maximumReadBlocks();
    }
    inline virtual uint8_t maximum_write_blocks() const override
    {
        return _activePICC.maximumWriteBlocks();
    }
 
    bool request_response_impl(const m5::nfc::f::PICC& picc, m5::nfc::f::standard::Mode& mode);
    bool request_system_code_impl(const m5::nfc::f::PICC& picc, uint16_t code_list[255], uint8_t& code_num);
    bool read_without_encryption_impl(uint8_t* rx, uint16_t& rx_len, const m5::nfc::f::block_t* block_list,
                                      const uint8_t block_num, const uint16_t* service_code, const uint8_t service_num,
                                      const m5::nfc::f::PICC& picc);
    bool write_without_encryption_impl(const m5::nfc::f::PICC& picc, const m5::nfc::f::block_t* block_list,
                                       const uint8_t block_num, const uint16_t* service_code, const uint8_t service_num,
                                       const uint8_t* tx, const uint16_t tx_len);
 
    bool dump_felica_lite();
    bool dump_felica_lite_s();
    bool dump_block(m5::nfc::f::block_t block);
 
    bool internal_authenticate_lite_s(const uint8_t ck[16], const uint16_t ckv, const uint8_t rc[16],
                                      const bool include_wcnt = false);
    bool external_authenticate_lite_s(const uint8_t ck[16], const uint16_t ckv);
 
protected:
    m5::nfc::f::PICC _activePICC{};
 
private:
    std::unique_ptr<Adapter> _impl;
    m5::nfc::ndef::NDEFLayer _ndef;
    union {
        uint8_t _sk[16]{};
        struct {
            uint8_t _sk1[8];
            uint8_t _sk2[8];
        };
    };
    uint8_t _rc[16]{};
    bool _authenticated{};
};
 
// Impl for units
struct NFCLayerF::Adapter {
    virtual ~Adapter() = default;
 
    virtual uint16_t max_fifo_depth() const            = 0;
    virtual bool transceive(uint8_t* rx, uint16_t& rx_len, const uint8_t* tx, const uint16_t tx_len,
                            const uint32_t timeout_ms) = 0;
};
 
}  // namespace nfc
}  // namespace m5
#endif