m24sr_driver.h

/* mbed Microcontroller Library
 * SPDX-License-Identifier: BSD-3-Clause
 ******************************************************************************
 * @file    m24sr_driver.h
 * @author  ST Central Labs
 * @brief   This file provides a set of functions to interface with the M24SR
 *          device.
 ******************************************************************************
 * @attention
 *
 * <h2><center>&copy; COPYRIGHT(c) 2018 STMicroelectronics</center></h2>
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *   1. Redistributions of source code must retain the above copyright notice,
 *      this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright notice,
 *      this list of conditions and the following disclaimer in the documentation
 *      and/or other materials provided with the distribution.
 *   3. Neither the name of STMicroelectronics nor the names of its contributors
 *      may be used to endorse or promote products derived from this software
 *      without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 ******************************************************************************
 */
 
/*
 Based on:         X-CUBE-MEMS1/trunk/Drivers/BSP/Components/m24sr/m24sr.h
 Revision:         M24SR Driver V1.0.0
 */
 
#ifndef M24SR_H
#define M24SR_H
 
#include <stdint.h>
#include <mbed.h>
#include "I2C.h"
#include "NFCEEPROMDriver.h"
#include "EventQueue.h"
 
#if defined TARGET_DISCO_L475VG_IOT01A
 
#define M24SR_I2C_SDA_PIN     PB_11
#define M24SR_I2C_SCL_PIN     PB_10
#define M24SR_GPO_PIN         PE_4
#define M24SR_RF_DISABLE_PIN  PE_2
 
#elif MBED_CONF_X_NUCLEO_NFC01A1
 
#define M24SR_I2C_SDA_PIN     D14
#define M24SR_I2C_SCL_PIN     D15
#define M24SR_GPO_PIN         D12
#define M24SR_RF_DISABLE_PIN  D11
 
#else
 
#define M24SR_I2C_SDA_PIN     NC
#define M24SR_I2C_SCL_PIN     NC
#define M24SR_GPO_PIN         NC
#define M24SR_RF_DISABLE_PIN  NC
 
#endif
 
namespace mbed {
namespace nfc {
namespace vendor {
namespace ST {
 
#define OPEN_SESSION_RETRIES  5
#define CC_FILE_LENGTH        15
#define NDEF_FILE_HEADER_SIZE 2
#define MAX_NDEF_SIZE         0x1FFF
 
/**
 * User parameter used to invoke a command,
 * it is used to provide the data back with the response
 */
struct CommandData_t {
    uint8_t *data; /**< data */
    uint16_t length; /**< number of bytes in the data array */
    uint16_t offset; /**< offset parameter used in the read/write command */
};
 
/**
 * @brief APDU Command structure
 */
class C_APDU {
public:
    struct C_APDUHeader_t {
        uint8_t CLA; /**< Command class */
        uint8_t INS; /**< Operation code */
        uint8_t P1; /**< Selection Mode */
        uint8_t P2; /**< Selection Option */
    };
 
    struct C_APDUBody_t {
        uint8_t LC; /**< Data field length */
        const uint8_t *data; /**< Command parameters */
        uint8_t LE; /**< Expected length of data to be returned */
    };
 
    C_APDU(uint8_t cla, uint8_t ins, uint16_t p1p2, uint8_t length, const uint8_t *data, uint8_t expected)
    {
        header.CLA = cla;
        header.INS = ins;
        header.P1 = (uint8_t)((p1p2 & 0xFF00) >> 8);
        header.P2 = (uint8_t)(p1p2 & 0x00FF);
        body.LC = length;
        body.data = data;
        body.LE = expected;
    }
 
    C_APDUHeader_t header;
    C_APDUBody_t body;
};
 
/**
 * @brief SC response structure
 */
struct R_APDU {
    uint8_t *data; /**< Data returned from the card */ // pointer on the transceiver buffer = ReaderRecBuf[CR95HF_DATA_OFFSET ];
    uint8_t SW1; /**< Command Processing status */
    uint8_t SW2; /**< Command Processing qualification */
};
 
enum M24srError_t : uint16_t {
    M24SR_SUCCESS = 0,
    M24SR_ERROR = 0x6F00,
    M24SR_FILE_OVERFLOW_LE = 0x6280,
    M24SR_EOF = 0x6282,
    M24SR_PASSWORD_REQUIRED = 0x6300,
    M24SR_PASSWORD_INCORRECT = 0x63C0,
    M24SR_PASSWORD_INCORRECT1RETRY = 0x63C1,
    M24SR_PASSWORD_INCORRECT2RETRY = 0x63C2,
    M24SR_WRONG_LENGHT = 0x6700,
    M24SR_UNSUCESSFUL_UPDATING = 0x6581,
    M24SR_INCOPATIBLE_COMMAND = 0x6981,
    M24SR_SECURITY_UNSATISFIED = 0x6982,
    M24SR_REFERENCE_DATA_NOT_USABLE = 0x6984,
 
    M24SR_INCORRECT_PARAMETER = 0x6a80,
    M24SR_FILE_NOT_FOUND = 0x6a82,
    M24SR_FILE_OVERFLOW_LC = 0x6A84,
 
    M24SR_INCORRECT_P1_OR_P2 = 0x6A86,
    M24SR_RF_SESSION_KILLED = 0x6500,
    M24SR_INS_NOT_SUPPORTED = 0x6D00,
    M24SR_CLASS_NOT_SUPPORTED = 0x6E00,
 
    M24SR_IO_ERROR_I2CTIMEOUT = 0x0011,
    M24SR_IO_ERROR_CRC = 0x0012,
    M24SR_IO_ERROR_NACK = 0x0013,
    M24SR_IO_ERROR_PARAMETER = 0x0014,
    M24SR_IO_ERROR_NBATEMPT = 0x0015,
    M24SR_IO_NOACKNOWLEDGE = 0x0016,
    M24SR_IO_PIN_NOT_CONNECTED = 0x0017
};
 
/**
 * @brief GPO state
 */
enum NfcGpoState_t {
    HIGH_IMPEDANCE = 0,
    SESSION_OPENED = 1,
    WIP = 2,
    I2C_ANSWER_READY = 3,
    INTERRUPT = 4,
    STATE_CONTROL = 5
};
 
/**
 * Possible password to set.
 */
enum PasswordType_t {
    READ_PASSWORD = 0x01, /**< Password to use before reading the tag */
    WRITE_PASSWORD = 0x02, /**< Password to use before writing the tag */
    I2C_PASSWORD = 0x03, /**< Root password, used only through nfc */
};
 
/**
 * Command that the component can accept
 */
enum Command_t {
    NONE,
    DESELECT,
    SELECT_APPLICATION,
    SELECT_CC_FILE,
    SELECT_NDEF_FILE,
    SELECT_SYSTEM_FILE,
    READ,
    UPDATE,
    VERIFY,
    MANAGE_I2C_GPO,
    MANAGE_RF_GPO,
    CHANGE_REFERENCE_DATA,
    ENABLE_VERIFICATION_REQUIREMENT,
    DISABLE_VERIFICATION_REQUIREMENT,
    ENABLE_PERMANET_STATE,
    DISABLE_PERMANET_STATE,
};
 
/**
 * Communication mode used by this device
 */
enum Communication_t {
    SYNC, /**< SYNC wait the command response before returning */
    ASYNC /**< ASYNC use a callback to notify the end of a command */
};
 
/**
 * Class representing a M24SR component.
 * This component has two operation modes, sync or async.
 * In sync mode each function call returns only after the command has completed.
 * In async mode each function call returns immediately and the answer will be notified
 * through a callback.
 * The default behaviour is sync mode.
 */
class M24srDriver : public NFCEEPROMDriver {
public:
    /**
     * Object that contains all the callbacks fired by this class, each command has its own callback.
     * The callback default implementation is an empty function.
     */
    class Callbacks {
    public:
        /** called when get_session completes */
        virtual void on_session_open(M24srDriver *nfc, M24srError_t status)
        {
            (void) nfc;
            (void) status;
        }
 
        /** called when deselect completes */
        virtual void on_deselect(M24srDriver *nfc, M24srError_t status)
        {
            (void) nfc;
            (void) status;
        }
 
        /** called when select_application completes */
        virtual void on_selected_application(M24srDriver *nfc, M24srError_t status)
        {
            (void) nfc;
            (void) status;
        }
 
        /** called when select_cc_file completes */
        virtual void on_selected_cc_file(M24srDriver *nfc, M24srError_t status)
        {
            (void) nfc;
            (void) status;
        }
 
        /** called when select_ndef_file completes */
        virtual void on_selected_ndef_file(M24srDriver *nfc, M24srError_t status)
        {
            (void) nfc;
            (void) status;
        }
 
        /** called when select_system_file completes */
        virtual void on_selected_system_file(M24srDriver *nfc, M24srError_t status)
        {
            (void) nfc;
            (void) status;
        }
 
        /** called when read_binary completes */
        virtual void on_read_byte(M24srDriver *nfc, M24srError_t status, uint16_t offset, uint8_t *bytes_read,
                                  uint16_t read_count)
        {
            (void) nfc;
            (void) status;
            (void) offset;
            (void) bytes_read;
            (void) read_count;
        }
 
        /** called when update_binary completes */
        virtual void on_updated_binary(M24srDriver *nfc, M24srError_t status, uint16_t offset, uint8_t *bytes_written,
                                       uint16_t write_count)
        {
            (void) nfc;
            (void) status;
            (void) bytes_written;
            (void) write_count;
            (void) offset;
        }
 
        /** called when verify completes */
        virtual void on_verified(M24srDriver *nfc, M24srError_t status, PasswordType_t password_type, const uint8_t *pwd)
        {
            (void) nfc;
            (void) status;
            (void) password_type;
            (void) pwd;
        }
 
        /** called when manage_i2c_gpo completes */
        virtual void on_manage_i2c_gpo(M24srDriver *nfc, M24srError_t status, NfcGpoState_t new_status)
        {
            (void) nfc;
            (void) status;
            (void) new_status;
        }
 
        /** called when manage_rf_gpo completes */
        virtual void on_manage_rf_gpo(M24srDriver *nfc, M24srError_t status, NfcGpoState_t new_status)
        {
            (void) nfc;
            (void) status;
            (void) new_status;
        }
 
        /** called when change_reference_data completes */
        virtual void on_change_reference_data(M24srDriver *nfc, M24srError_t status, PasswordType_t type,
                                              const uint8_t *data)
        {
            (void) nfc;
            (void) status;
            (void) type;
            (void) data;
        }
 
        /** called when enable_verification_requirement completes */
        virtual void on_enable_verification_requirement(M24srDriver *nfc, M24srError_t status, PasswordType_t type)
        {
            (void) nfc;
            (void) status;
            (void) type;
        }
 
        /** called when disable_verification_requirement completes */
        virtual void on_disable_verification_requirement(M24srDriver *nfc, M24srError_t status, PasswordType_t type)
        {
            (void) nfc;
            (void) status;
            (void) type;
        }
 
        /** called when enable_permanent_state completes */
        virtual void on_enable_permanent_state(M24srDriver *nfc, M24srError_t status, PasswordType_t type)
        {
            (void) nfc;
            (void) status;
            (void) type;
        }
 
        /** called when disable_permanent_state completes */
        virtual void on_disable_permanent_state(M24srDriver *nfc, M24srError_t status, PasswordType_t type)
        {
            (void) nfc;
            (void) status;
            (void) type;
        }
 
        /** called when read_id completes */
        virtual void on_read_id(M24srDriver *nfc, M24srError_t status, uint8_t *id)
        {
            (void) nfc;
            (void) status;
            (void) id;
        }
 
        /** called when enable_read_password completes */
        virtual void on_enable_read_password(M24srDriver *nfc, M24srError_t status, const uint8_t *new_password)
        {
            (void) nfc;
            (void) status;
            (void) new_password;
        }
 
        /** called when oenable_write_password completes */
        virtual void on_enable_write_password(M24srDriver *nfc, M24srError_t status, const uint8_t *new_password)
        {
            (void) nfc;
            (void) status;
            (void) new_password;
        }
 
        /** called when disable_read_password completes */
        virtual void on_disable_read_password(M24srDriver *nfc, M24srError_t status)
        {
            (void) nfc;
            (void) status;
        }
 
        /** called when disable_write_password completes */
        virtual void on_disable_write_password(M24srDriver *nfc, M24srError_t status)
        {
            (void) nfc;
            (void) status;
        }
 
        /** called when disable_all_password completes */
        virtual void on_disable_all_password(M24srDriver *nfc, M24srError_t status)
        {
            (void) nfc;
            (void) status;
        }
 
        /** called when enable_read_only completes */
        virtual void on_enable_read_only(M24srDriver *nfc, M24srError_t status)
        {
            (void) nfc;
            (void) status;
        }
 
        /** called when enable_write_only completes */
        virtual void on_enable_write_only(M24srDriver *nfc, M24srError_t status)
        {
            (void) nfc;
            (void) status;
        }
 
        /** called when disable_read_only completes */
        virtual void on_disable_read_only(M24srDriver *nfc, M24srError_t status)
        {
            (void) nfc;
            (void) status;
        }
 
        /** called when disable_write_only completes */
        virtual void on_disable_write_only(M24srDriver *nfc, M24srError_t status)
        {
            (void) nfc;
            (void) status;
        }
 
        virtual ~Callbacks() { }
    };
 
public:
    /** Create the driver, default pin names will be used appropriate for the board.
     *  @param i2c_data_pin I2C data pin name.
     *  @param i2c_clock_pin I2C clock pin name.
     *  @param gpo_pin I2C GPO pin name.
     *  @param rf_disable_pin pin name for breaking the RF connection.
     */
    M24srDriver(PinName i2c_data_pin = M24SR_I2C_SDA_PIN, PinName i2c_clock_pin = M24SR_I2C_SCL_PIN,
                PinName gpo_pin = M24SR_GPO_PIN, PinName rf_disable_pin = M24SR_RF_DISABLE_PIN);
 
    virtual ~M24srDriver() { }
 
    /** @see NFCEEPROMDriver::reset
     */
    virtual void reset()
    {
        set_callback(&_default_cb);
        init();
        manage_i2c_gpo(I2C_ANSWER_READY);
    }
 
    /** @see NFCEEPROMDriver::get_max_size
     */
    virtual size_t read_max_size()
    {
        return MAX_NDEF_SIZE;
    }
 
    /** @see NFCEEPROMDriver::start_session
     */
    virtual void start_session(bool force = true)
    {
        if (_is_session_open) {
            delegate()->on_session_started(true);
            return;
        }
 
        set_callback(&_open_session_cb);
 
        get_session(force);
    }
 
    /** @see NFCEEPROMDriver::end_session
     */
    virtual void end_session()
    {
        set_callback(&_close_session_cb);
        deselect();
    }
 
    /** @see NFCEEPROMDriver::read_bytes
     */
    virtual void read_bytes(uint32_t address, uint8_t *bytes, size_t count)
    {
        if (!_is_session_open) {
            delegate()->on_bytes_read(0);
            return;
        }
 
        if (address > _ndef_size) {
            delegate()->on_bytes_read(0);
            return;
        }
 
        set_callback(&_read_byte_cb);
 
        if (count > _max_read_bytes) {
            count = _max_read_bytes;
        }
 
        if (address + count > _ndef_size) {
            count = _ndef_size - address;
        }
 
        if (count == 0) {
            delegate()->on_bytes_read(0);
            return;
        }
 
        /* offset by ndef file size*/
        address += NDEF_FILE_HEADER_SIZE;
 
        read_binary((uint16_t) address, (uint8_t) count, bytes);
    }
 
    /** @see NFCEEPROMDriver::write_bytes
     */
    virtual void write_bytes(uint32_t address, const uint8_t *bytes, size_t count)
    {
        if (!_is_session_open) {
            delegate()->on_bytes_written(0);
            return;
        }
 
        if (address > _ndef_size) {
            delegate()->on_bytes_written(0);
            return;
        }
 
        if (bytes) {
            set_callback(&_write_byte_cb);
        } else {
            set_callback(&_erase_bytes_cb);
        }
 
        if (count > _max_write_bytes) {
            count = _max_write_bytes;
        }
 
        if (address + count > _ndef_size) {
            count = _ndef_size - address;
        }
 
        if (count == 0) {
            delegate()->on_bytes_written(0);
            return;
        }
 
        /* offset by ndef file size*/
        address += NDEF_FILE_HEADER_SIZE;
 
        update_binary((uint16_t) address, (uint8_t) count, bytes);
    }
 
    /** @see NFCEEPROMDriver::set_size
     */
    virtual void write_size(size_t count)
    {
        if (!_is_session_open) {
            delegate()->on_size_read(false, 0);
            return;
        }
 
        if (count > MAX_NDEF_SIZE - NDEF_FILE_HEADER_SIZE) {
            delegate()->on_size_read(false, 0);
            return;
        }
 
        set_callback(&_set_size_cb);
 
        _ndef_size = (uint16_t)count;
 
        /* NDEF file size is BE */
        uint8_t *bytes = (uint8_t *)&_ndef_size;
        _ndef_size_buffer[0] = bytes[1];
        _ndef_size_buffer[1] = bytes[0];
 
        update_binary(0, NDEF_FILE_HEADER_SIZE, (const uint8_t *)&_ndef_size_buffer);
    }
 
    /** @see NFCEEPROMDriver::get_size
     */
    virtual void read_size()
    {
        if (!_is_session_open) {
            delegate()->on_size_read(false, 0);
            return;
        }
 
        set_callback(&_get_size_cb);
 
        read_binary(0, NDEF_FILE_HEADER_SIZE, (uint8_t *)&_ndef_size_buffer);
    }
 
    /** @see NFCEEPROMDriver::erase_bytes
     */
    virtual void erase_bytes(uint32_t address, size_t size)
    {
        write_bytes(address, NULL, size);
    }
 
private:
    /**
     * Change the function to call when a command ends.
     * @param commandCallback Object containing the callback, if NULL it will use empty callback
     */
    void set_callback(Callbacks *callback)
    {
        if (callback) {
            _command_cb = callback;
        } else {
            _command_cb = &_default_cb;
        }
    }
 
    /**
     * get the callback object to use
     * @return callback object to use
     */
    Callbacks *get_callback()
    {
        /* this allows for two levels of operation, the previous command will continue
         * when this set of callbacks has finished */
        if (_subcommand_cb) {
            return _subcommand_cb;
        }
        return _command_cb;
    }
 
    void nfc_interrupt_callback()
    {
        if (_communication_type == ASYNC) {
            event_queue()->call(this, &M24srDriver::manage_event);
        }
    }
 
    /**
     * Enable the request of a password before reading the tag.
     * @param current_write_password Current password
     * @param new_password Password to request before reading the tag.
     * @return return M24SR_SUCCESS if no errors
     * @note The password must have a length of 16 chars.
     */
    M24srError_t enable_read_password(const uint8_t *current_write_password, const uint8_t *new_password)
    {
        _subcommand_cb = &_change_password_request_status_cb;
        _change_password_request_status_cb.set_task(READ_PASSWORD, new_password);
 
        return verify(WRITE_PASSWORD, current_write_password);
    }
 
    /**
     * Disable the request of a password before reading the tag.
     * @param current_write_password Current password
     * @return return M24SR_SUCCESS if no errors
     * @note The password must have a length of 16 chars.
     */
    M24srError_t disable_read_password(const uint8_t *current_write_password)
    {
        _subcommand_cb = &_change_password_request_status_cb;
        _change_password_request_status_cb.set_task(READ_PASSWORD, NULL);
 
        return verify(WRITE_PASSWORD, current_write_password);
    }
 
    /**
     * Enable the request of a password before writing to the tag.
     * @param current_write_password Current password
     * @param new_password Password to request before reading the tag.
     * @return return M24SR_SUCCESS if no errors
     * @note The password must have a length of 16 chars.
     */
    M24srError_t enable_write_password(const uint8_t *current_write_password, uint8_t *new_password)
    {
        _subcommand_cb = &_change_password_request_status_cb;
        _change_password_request_status_cb.set_task(WRITE_PASSWORD, new_password);
 
        return verify(WRITE_PASSWORD, current_write_password);
    }
 
    /**
     * Disable the request of a password before writing the tag.
     * @param current_write_password Current password.
     * @return return M24SR_SUCCESS if no errors
     * @note The password must have a length of 16 chars.
     */
    M24srError_t disable_write_password(const uint8_t *current_write_password)
    {
        _subcommand_cb = &_change_password_request_status_cb;
        _change_password_request_status_cb.set_task(WRITE_PASSWORD, NULL);
 
        return verify(WRITE_PASSWORD, current_write_password);
    }
 
    /**
     * @brief This function disables both read and write passwords.
     * @param super_user_password I2C super user password.
     * @return return M24SR_SUCCESS if no errors
     * @note The password must have a length of 16 chars.
     */
    M24srError_t disable_all_password(const uint8_t *super_user_password)
    {
        _subcommand_cb = &_remove_password_cb;
        return verify(I2C_PASSWORD, super_user_password);
    }
 
    /**
     * @brief This function enables read only mode.
     * @param current_write_password Write password is needed to enable read only mode.
     * @return return M24SR_SUCCESS if no errors
     * @note The password must have a length of 16 chars.
     */
    M24srError_t enable_read_only(const uint8_t *current_write_password)
    {
        _subcommand_cb = &_change_access_state_cb;
        _change_access_state_cb.change_access_state(ChangeAccessStateCallback::WRITE, false);
 
        return verify(WRITE_PASSWORD, current_write_password);
    }
 
    /**
     * @brief This function disables read only mode.
     * @param current_write_password Write password is needed to disable read only mode.
     * @return return M24SR_SUCCESS if no errors
     * @note The password must have a length of 16 chars.
     */
    M24srError_t disable_read_only(const uint8_t *current_write_password)
    {
        _subcommand_cb = &_change_access_state_cb;
        _change_access_state_cb.change_access_state(ChangeAccessStateCallback::WRITE, true);
 
        return verify(I2C_PASSWORD, current_write_password);
    }
 
    /**
     * @brief This function enables write only mode.
     * @param current_write_password Write password is needed to enable write only mode.
     * @return return M24SR_SUCCESS if no errors
     * @note The password must have a length of 16 chars.
     */
    M24srError_t enable_write_only(const uint8_t *current_write_password)
    {
        _subcommand_cb = &_change_access_state_cb;
        _change_access_state_cb.change_access_state(ChangeAccessStateCallback::READ, false);
 
        return verify(WRITE_PASSWORD, current_write_password);
    }
 
    /**
     * @brief This function disables write only mode.
     * @param current_write_password Write password is needed to disable write only mode.
     * @return return M24SR_SUCCESS if no errors
     * @note The password must have a length of 16 chars.
     */
    M24srError_t disable_write_only(const uint8_t *current_write_password)
    {
        _subcommand_cb = &_change_access_state_cb;
        _change_access_state_cb.change_access_state(ChangeAccessStateCallback::READ, true);
 
        return verify(I2C_PASSWORD, current_write_password);
    }
 
private:
    M24srError_t init();
    M24srError_t read_id(uint8_t *nfc_id);
    M24srError_t get_session(bool force = false);
 
    M24srError_t deselect();
    M24srError_t receive_deselect();
 
    M24srError_t select_application();
    M24srError_t receive_select_application();
 
    M24srError_t select_cc_file();
    M24srError_t receive_select_cc_file();
 
    M24srError_t select_ndef_file(uint16_t ndef_file_id);
    M24srError_t receive_select_ndef_file();
 
    M24srError_t select_system_file();
    M24srError_t receive_select_system_file();
 
    M24srError_t read_binary(uint16_t offset, uint8_t length, uint8_t *buffer);
    M24srError_t st_read_binary(uint16_t offset, uint8_t length, uint8_t *buffer);
    M24srError_t receive_read_binary();
 
    M24srError_t update_binary(uint16_t offset, uint8_t length, const uint8_t *data);
    M24srError_t receive_update_binary();
 
    M24srError_t verify(PasswordType_t password_type, const uint8_t *password);
    M24srError_t receive_verify();
 
    M24srError_t change_reference_data(PasswordType_t password_type, const uint8_t *password);
    M24srError_t receive_change_reference_data();
 
    M24srError_t enable_verification_requirement(PasswordType_t password_type);
    M24srError_t receive_enable_verification_requirement();
 
    M24srError_t disable_verification_requirement(PasswordType_t password_type);
    M24srError_t receive_disable_verification_requirement();
 
    M24srError_t enable_permanent_state(PasswordType_t password_type);
    M24srError_t receive_enable_permanent_state();
 
    M24srError_t disable_permanent_state(PasswordType_t password_type);
    M24srError_t receive_disable_permanent_state();
 
    M24srError_t send_interrupt();
    M24srError_t state_control(bool gpo_reset);
 
    M24srError_t manage_i2c_gpo(NfcGpoState_t gpo_i2c_config);
    M24srError_t manage_rf_gpo(NfcGpoState_t gpo_rf_config);
 
    M24srError_t rf_config(bool enable);
    M24srError_t send_fwt_extension(uint8_t fwt_byte);
 
    M24srError_t send_receive_i2c(uint16_t length, uint8_t *command);
 
    /**
     * Function to call when the component fire an interrupt.
     * @return last operation status
     */
    M24srError_t manage_event();
 
    /**
     * Send a command to the component.
     * @param length Length of the command.
     * @param command Buffer containing the command.
     * @return M24SR_SUCCESS if no errors
     */
    M24srError_t io_send_i2c_command(uint8_t length, const uint8_t *command);
 
    /**
     * Read a command response.
     * @param length Number of bytes to read.
     * @param command Buffer to store the response into.
     * @return M24SR_SUCCESS if no errors
     */
    M24srError_t io_receive_i2c_response(uint8_t length, uint8_t *command);
 
    /**
     * Do an active polling on the I2C bus until the answer is ready.
     * @return M24SR_SUCCESS if no errors
     */
    M24srError_t io_poll_i2c();
 
    bool manage_sync_communication(M24srError_t *status);
 
private:
    /**
     * @brief This class permits to enable/disable the password request to read/write into the tag
     */
    class ChangePasswordRequestStatusCallback : public Callbacks {
    public:
        /**
         * Build the chain of callbacks.
         */
        ChangePasswordRequestStatusCallback()
            : _new_password(NULL),
              _type(I2C_PASSWORD),
              _enable(false) { }
 
        /* This class is equivalent to calling the methods:
         *
         * To enable the request:
         * - Verify
         * - change_reference_data
         * - enable_permanent_state
         *
         * To disable the request:
         * - verify
         * - disable_verification_requirement
         */
 
        /**
         * Set the password to enable/disable.
         * @param type Type of password to enable/disable.
         * @param new_password Array of 16bytes with the new password, if null the request will be disabled.
         */
        void set_task(PasswordType_t type, const uint8_t *new_password)
        {
            _new_password = new_password;
            _type = type;
            _enable = (new_password != NULL);
        }
 
        virtual void on_verified(M24srDriver *nfc, M24srError_t status, PasswordType_t, const uint8_t *)
        {
            if (status != M24SR_SUCCESS) {
                return on_finish_command(nfc, status);
            }
            if (_enable) {
                nfc->change_reference_data(_type, _new_password);
            } else {
                nfc->disable_verification_requirement(_type);
            }
        }
 
        virtual void on_disable_verification_requirement(M24srDriver *nfc, M24srError_t status, PasswordType_t)
        {
            on_finish_command(nfc, status);
        }
 
        virtual void on_change_reference_data(M24srDriver *nfc, M24srError_t status, PasswordType_t type, const uint8_t *)
        {
            if (status == M24SR_SUCCESS) {
                nfc->enable_permanent_state(type);
            } else {
                on_finish_command(nfc, status);
            }
        }
 
        virtual void on_enable_permanent_state(M24srDriver *nfc, M24srError_t status, PasswordType_t)
        {
            on_finish_command(nfc, status);
        }
 
    private:
        /**
         * Remove the private callbacks and call the user callback.
         * @param nfc Object triggering the command.
         * @param status Command status.
         */
        void on_finish_command(M24srDriver *nfc, M24srError_t status)
        {
            nfc->_subcommand_cb = NULL;
 
            if (_enable) {
                if (_type == READ_PASSWORD) {
                    nfc->get_callback()->on_enable_read_password(nfc, status, _new_password);
                } else {
                    nfc->get_callback()->on_enable_write_password(nfc, status, _new_password);
                }
            } else {
                if (_type == READ_PASSWORD) {
                    nfc->get_callback()->on_disable_read_password(nfc, status);
                } else {
                    nfc->get_callback()->on_disable_write_password(nfc, status);
                }
            }
        }
 
    private:
        const uint8_t *_new_password;
        PasswordType_t _type;
        bool _enable;
    };
 
    /**
     * @brief This class permits to disable all the password requests to read/write into the tag.
     */
    class RemoveAllPasswordCallback : public Callbacks {
    public:
        /**
         * Build the chain of callbacks.
         */
        RemoveAllPasswordCallback()
            : _password(NULL) { }
 
        /* This class is equivalent to calling the methods:
         * - verify(i2c)
         * - disable_permanent_state(Read)
         * - disable_permanent_state(write)
         * - disable_verification_requirement(Read)
         * - disable_verification_requirement(write)
         * - change_reference_data(Read)
         * - change_reference_data(write)
         */
 
        virtual void on_verified(M24srDriver *nfc, M24srError_t status, PasswordType_t, const uint8_t *data)
        {
            if (status != M24SR_SUCCESS) {
                return on_finish_command(nfc, status);
            }
            _password = data;
            nfc->disable_permanent_state(READ_PASSWORD);
        }
 
        virtual void on_disable_permanent_state(M24srDriver *nfc, M24srError_t status, PasswordType_t type)
        {
            if (status != M24SR_SUCCESS) {
                return on_finish_command(nfc, status);
            }
            if (type == READ_PASSWORD) {
                nfc->disable_permanent_state(WRITE_PASSWORD);
            } else {
                nfc->disable_verification_requirement(READ_PASSWORD);
            }
        }
 
        virtual void on_disable_verification_requirement(M24srDriver *nfc, M24srError_t status, PasswordType_t type)
        {
            if (status != M24SR_SUCCESS) {
                return on_finish_command(nfc, status);
            }
            if (type == READ_PASSWORD) {
                nfc->disable_verification_requirement(WRITE_PASSWORD);
            } else {
                nfc->change_reference_data(READ_PASSWORD, _password);
            }
        }
 
        virtual void on_change_reference_data(M24srDriver *nfc, M24srError_t status, PasswordType_t type,
                                              const uint8_t *data)
        {
            if (status != M24SR_SUCCESS) {
                return on_finish_command(nfc, status);
            }
            if (type == READ_PASSWORD) {
                nfc->change_reference_data(WRITE_PASSWORD, data);
            } else {
                on_finish_command(nfc, status);
            }
        }
 
    private:
        /**
         * Remove the private callback and call the onDisableAllPassword callback.
         * @param nfc Object triggering the command.
         * @param status Command status.
         */
        void on_finish_command(M24srDriver *nfc, M24srError_t status)
        {
            nfc->_subcommand_cb = NULL;
            _password = NULL;
            nfc->get_callback()->on_disable_all_password(nfc, status);
        }
 
    private:
        /**
         * Store the default password used for open a super user session
         * it will be set as default read/write password
         */
        const uint8_t *_password;
    };
 
    /**
     * @brief This class permits to set the tag as read/write only.
     */
    class ChangeAccessStateCallback : public Callbacks {
    public:
        enum AccessType_t {
            WRITE,
            READ
        };
 
        /**
         * Build the chain of callbacks.
         */
        ChangeAccessStateCallback()
            : _type(WRITE),
              _enable(false) { }
 
        /* This class is equivalent to calling the methods:
         * - verify(i2c)
         * - enable_permanent_state(Read/write)
         * or:
         * - verify(i2c)
         * - disable_permanent_state</li>
         * - disable_verification_requirement(Read/write)
         */
 
        /**
         * Set the access to enable/disable an access type.
         * @param type Access type.
         * @param enable True to enable the state, False to disable it.
         */
        void change_access_state(AccessType_t type, bool enable)
        {
            _type = type;
            _enable = enable;
        }
 
        virtual void on_verified(M24srDriver *nfc, M24srError_t status, PasswordType_t, const uint8_t *)
        {
            if (status != M24SR_SUCCESS) {
                return on_finish_command(nfc, status);
            }
 
            if (_enable) {
                nfc->disable_permanent_state(_type == WRITE ? WRITE_PASSWORD : READ_PASSWORD);
            } else {
                nfc->enable_permanent_state(_type == WRITE ? WRITE_PASSWORD : READ_PASSWORD);
            }
 
        }
 
        virtual void on_disable_permanent_state(M24srDriver *nfc, M24srError_t status, PasswordType_t type)
        {
            if (status != M24SR_SUCCESS) {
                return on_finish_command(nfc, status);
            }
 
            nfc->disable_verification_requirement(type);
        }
 
        virtual void on_disable_verification_requirement(M24srDriver *nfc, M24srError_t status, PasswordType_t)
        {
            on_finish_command(nfc, status);
        }
 
        virtual void on_enable_permanent_state(M24srDriver *nfc, M24srError_t status, PasswordType_t)
        {
            on_finish_command(nfc, status);
        }
 
    private:
        /**
         * Remove the private callback and call the user callback.
         * @param nfc Object triggering the command.
         * @param status Command status.
         */
        void on_finish_command(M24srDriver *nfc, M24srError_t status)
        {
            nfc->_subcommand_cb = NULL;
            if (_enable) {
                if (_type == READ) {
                    //enable read = disable write only
                    nfc->get_callback()->on_disable_write_only(nfc, status);
                } else {
                    //enable write = disable read only
                    nfc->get_callback()->on_disable_read_only(nfc, status);
                }
            } else {
                if (_type == WRITE) {
                    //disable write = enable read only
                    nfc->get_callback()->on_enable_read_only(nfc, status);
                } else {
                    nfc->get_callback()->on_enable_write_only(nfc, status);
                }
            }
        }
 
    private:
        AccessType_t _type;
        bool _enable;
    };
 
    /**
     * @brief Object with the callback used to send a ManageGPO command.
     */
    class ManageGPOCallback : public Callbacks {
 
    public:
        /**
         * Build the chain of callbacks.
         * @param parent Parent component to run the command on.
         */
        ManageGPOCallback()
            : _new_gpo_config(HIGH_IMPEDANCE),
              _read_gpo_config(0),
              _change_i2c_gpo(true) { }
 
        /* This class is equivalent to calling the methods:
         * - selected_application
         * - select_system_file
         * - read_binary
         * - verify
         * - update_binary
         */
 
        /**
         * Command parameters.
         * @param i2cGpo true to change the i2c gpo, false for the rf gpo.
         * @param new_config new gpo function.
         */
        void set_new_gpo_config(bool i2cGpo, NfcGpoState_t new_config)
        {
            _new_gpo_config = new_config;
            _change_i2c_gpo = i2cGpo;
        }
 
        virtual void on_selected_application(M24srDriver *nfc, M24srError_t status)
        {
            if (status == M24SR_SUCCESS) {
                nfc->select_system_file();
            } else {
                on_finish_command(nfc, status);
            }
        }
 
        virtual void on_selected_system_file(M24srDriver *nfc, M24srError_t status)
        {
            if (status == M24SR_SUCCESS) {
                nfc->read_binary(0x0004, 0x01, &_read_gpo_config);
            } else {
                on_finish_command(nfc, status);
            }
        }
 
        virtual void on_read_byte(M24srDriver *nfc, M24srError_t status, uint16_t, uint8_t *, uint16_t)
        {
            if (status == M24SR_SUCCESS) {
                nfc->verify(I2C_PASSWORD, default_password);
            } else {
                on_finish_command(nfc, status);
            }
        }
 
        virtual void on_verified(M24srDriver *nfc, M24srError_t status, PasswordType_t, const uint8_t *)
        {
            if (status != M24SR_SUCCESS) {
                return on_finish_command(nfc, status);
            }
 
            if (_change_i2c_gpo) {
                _read_gpo_config = (_read_gpo_config & 0xF0) | (uint8_t) _new_gpo_config;
            } else {
                _read_gpo_config = (_read_gpo_config & 0x0F) | (((uint8_t) _new_gpo_config) << 4);
            }
 
            nfc->update_binary(0x0004, 0x01, &_read_gpo_config);
        }
 
        virtual void on_updated_binary(M24srDriver *nfc, M24srError_t status, uint16_t, uint8_t *, uint16_t)
        {
 
            if (status == M24SR_SUCCESS) {
                if (_new_gpo_config == I2C_ANSWER_READY) {
                    nfc->_communication_type = ASYNC;
                } else {
                    nfc->_communication_type = SYNC;
                }
            }
            on_finish_command(nfc, status);
        }
 
    private:
        /**
         * Remove the private callback and call the user callback.
         * @param nfc Object where the command was send to.
         * @param status Command status.
         */
        void on_finish_command(M24srDriver *nfc, M24srError_t status)
        {
            nfc->_subcommand_cb = NULL;
            if (_change_i2c_gpo) {
                nfc->_command_cb->on_manage_i2c_gpo(nfc, status, _new_gpo_config);
            } else {
                nfc->_command_cb->on_manage_rf_gpo(nfc, status, _new_gpo_config);
            }
        }
 
    private:
        /** new gpo function that this class has to write */
        NfcGpoState_t _new_gpo_config;
 
        /** variable where storeing the read gpo configuration */
        uint8_t _read_gpo_config;
 
        /** true to change the i2c gpo, false to change the rf gpo */
        bool _change_i2c_gpo;
    };
 
    /**
     * @brief Object with the callback used to read the component ID
     */
    class ReadIDCallback : public Callbacks {
    public:
        /**
         * Build the chain of callbacks.
         * @param parent object where to send the command to.
         */
        ReadIDCallback() : _id(NULL) { }
 
        /* This class is equivalent to calling the methods:
         * - select_application
         * - select_system_file
         * - read_binary
         */
 
        /**
         * Set the variable containing the result
         * @param idPtr
         */
        void set_task(uint8_t *id)
        {
            _id = id;
        }
 
        virtual void on_selected_application(M24srDriver *nfc, M24srError_t status)
        {
            if (status == M24SR_SUCCESS) {
                nfc->select_system_file();
            } else {
                on_finish_command(nfc, status);
            }
 
        }
 
        virtual void on_selected_system_file(M24srDriver *nfc, M24srError_t status)
        {
            if (status == M24SR_SUCCESS) {
                nfc->read_binary(0x0011, 0x01, _id);
            } else {
                on_finish_command(nfc, status);
            }
        }
 
        virtual void on_read_byte(M24srDriver *nfc, M24srError_t status, uint16_t, uint8_t *, uint16_t)
        {
            on_finish_command(nfc, status);
        }
 
    private:
        /**
         * Remove the private callback and call the user onReadId function.
         * @param nfc Object where the command was send.
         * @param status Command status.
         */
        void on_finish_command(M24srDriver *nfc, M24srError_t status)
        {
            nfc->_subcommand_cb = NULL;
            nfc->get_callback()->on_read_id(nfc, status, _id);
        }
 
    private:
        /** pointer to read id */
        uint8_t *_id;
    };
 
    /**
     * Class containing the callback needed to open a session and read the max
     * read/write size
     */
    class OpenSessionCallBack : public Callbacks {
    public:
        OpenSessionCallBack()
            : _retries(OPEN_SESSION_RETRIES) { }
 
        void on_session_open(M24srDriver *nfc, M24srError_t status)
        {
            if (status == M24SR_SUCCESS) {
                nfc->select_application();
            } else {
                nfc->delegate()->on_session_started(false);
            }
        }
 
        void on_selected_application(M24srDriver *nfc, M24srError_t status)
        {
            if (status == M24SR_SUCCESS) {
                nfc->select_cc_file();
            } else {
                if (_retries == 0) {
                    nfc->delegate()->on_session_started(false);
                } else {
                    _retries--;
                    nfc->select_application();
                }
            }
        }
 
        void on_selected_cc_file(M24srDriver *nfc, M24srError_t status)
        {
            if (status == M24SR_SUCCESS) {
                nfc->read_binary(0x0000, CC_FILE_LENGTH, CCFile);
            } else {
                nfc->delegate()->on_session_started(false);
            }
        }
 
        void on_read_byte(M24srDriver *nfc, M24srError_t status, uint16_t, uint8_t *bytes_read,
                          uint16_t read_count)
        {
            if (status != M24SR_SUCCESS || read_count != CC_FILE_LENGTH) {
                nfc->delegate()->on_session_started(false);
            }
            uint16_t ndef_file_id = (uint16_t)((bytes_read[0x09] << 8) | bytes_read[0x0A]);
            nfc->_max_read_bytes = (uint16_t)((bytes_read[0x03] << 8) | bytes_read[0x04]);
            nfc->_max_write_bytes = (uint16_t)((bytes_read[0x05] << 8) | bytes_read[0x06]);
            nfc->select_ndef_file(ndef_file_id);
        }
 
        void on_selected_ndef_file(M24srDriver *nfc, M24srError_t status)
        {
            nfc->_is_session_open = (status == M24SR_SUCCESS);
            nfc->delegate()->on_session_started(nfc->_is_session_open);
        }
 
    private:
        /** number of trials done for open the session */
        uint32_t _retries;
 
        /** buffer where read the CC file */
        uint8_t CCFile[15];
    };
 
    /**
     * Class containing the callback needed to close a session
     */
    class CloseSessionCallBack : public Callbacks {
    public:
        CloseSessionCallBack() { }
 
        virtual void on_deselect(M24srDriver *nfc, M24srError_t status)
        {
            if (status == M24SR_SUCCESS) {
                nfc->_is_session_open = false;
                nfc->delegate()->on_session_ended(true);
            } else {
                nfc->delegate()->on_session_ended(false);
            }
        }
    };
 
    /**
     * Class containing the callback needed to write a buffer
     */
    class WriteByteCallback : public Callbacks {
    public:
        WriteByteCallback() { }
 
        virtual void on_updated_binary(M24srDriver *nfc, M24srError_t status, uint16_t offset, uint8_t *bytes_written,
                                       uint16_t write_count)
        {
            if (status != M24SR_SUCCESS) {
                nfc->delegate()->on_bytes_written(0);
                return;
            }
 
            nfc->delegate()->on_bytes_written(write_count);
        }
    };
 
    /**
     * Class containing the callback needed to read a buffer
     */
    class ReadByteCallback : public Callbacks {
    public:
        ReadByteCallback() { }
 
        virtual void on_read_byte(M24srDriver *nfc, M24srError_t status, uint16_t offset, uint8_t *bytes_read,
                                  uint16_t read_count)
        {
            if (status != M24SR_SUCCESS) {
                nfc->delegate()->on_bytes_read(0);
                return;
            }
 
            nfc->delegate()->on_bytes_read(read_count);
        }
    };
 
    class SetSizeCallback : public Callbacks {
    public:
        SetSizeCallback() { }
 
        virtual void on_updated_binary(M24srDriver *nfc, M24srError_t status, uint16_t offset, uint8_t *bytes_written,
                                       uint16_t write_count)
        {
            if (status != M24SR_SUCCESS) {
                nfc->delegate()->on_size_written(false);
                return;
            }
 
            nfc->delegate()->on_size_written(true);
        }
    };
 
    class GetSizeCallback : public Callbacks {
    public:
        GetSizeCallback() { }
 
        virtual void on_read_byte(M24srDriver *nfc, M24srError_t status, uint16_t offset, uint8_t *bytes_read,
                                  uint16_t read_count)
        {
            if (status != M24SR_SUCCESS) {
                nfc->delegate()->on_size_read(false, 0);
                return;
            }
 
            /* NDEF file size is BE */
            nfc->_ndef_size = (((uint16_t) nfc->_ndef_size_buffer[0]) << 8 | nfc->_ndef_size_buffer[1]);
 
            nfc->delegate()->on_size_read(true, nfc->_ndef_size);
        }
    };
 
    class EraseBytesCallback : public Callbacks {
    public:
        EraseBytesCallback() { }
 
        virtual void on_updated_binary(M24srDriver *nfc, M24srError_t status, uint16_t offset, uint8_t *bytes_written,
                                       uint16_t write_count)
        {
            if (status != M24SR_SUCCESS) {
                nfc->delegate()->on_bytes_erased(0);
                return;
            }
 
            nfc->delegate()->on_bytes_erased(write_count);
        }
    };
 
private:
    /** Default password used to change the write/read permission */
    static const uint8_t default_password[16];
 
    I2C _i2c_channel;
 
    /** Interrupt object fired when the gpo status changes */
    InterruptIn _gpo_event_interrupt;
    DigitalIn _gpo_pin;
    DigitalOut _rf_disable_pin;
 
    /** object containing the callbacks to use*/
    Callbacks *_command_cb;
 
    /**
     * Object with private callbacks used to hide high level commands each
     * calling multiple low level commands. This callbacks object has
     * higher priority comparing to the user callbacks.
     */
    Callbacks *_subcommand_cb;
 
    Callbacks _default_cb;
    ManageGPOCallback _manage_gpo_cb;
    ReadIDCallback _read_id_cb;
    ChangePasswordRequestStatusCallback _change_password_request_status_cb;
    RemoveAllPasswordCallback _remove_password_cb;
    ChangeAccessStateCallback _change_access_state_cb;
    OpenSessionCallBack _open_session_cb;
    CloseSessionCallBack _close_session_cb;
    WriteByteCallback _write_byte_cb;
    ReadByteCallback _read_byte_cb;
    SetSizeCallback _set_size_cb;
    GetSizeCallback _get_size_cb;
    EraseBytesCallback _erase_bytes_cb;
 
 
    uint8_t _buffer[0xFF];
 
    /** Type of communication being used (SYNC, ASYNC) */
    Communication_t _communication_type;
 
    Command_t _last_command;
    CommandData_t _last_command_data;
 
    /** Buffer used to build the command to send to the chip. */
    uint16_t _ndef_size;
    uint8_t _ndef_size_buffer[NDEF_FILE_HEADER_SIZE];
    uint8_t _max_read_bytes;
    uint8_t _max_write_bytes;
    uint8_t _did_byte;
 
    bool _is_session_open;
};
 
} //ST
} //vendor
} //nfc
} //mbed
 
#endif // M24SR_H
 
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/