Mbed OS Reference | m24sr_driver.h Source File

 /* 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.
  * To enable the async mode ManageI2CGPO(I2C_ANSWER_READY) function must be called.
  * When the component notifies an interrupt user must call  {@link ManageEvent} function.
  * Note that passing a parameter other than I2C_ANSWER_READY to ManageI2CGPO initialize the component in 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****/
Important Information for this Arm website
