xref: /external/libnfc-nci/src/nfa/rw/nfa_rw_api.c

/******************************************************************************
 *
 *  Copyright (C) 2010-2014 Broadcom Corporation
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at:
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 ******************************************************************************/


/******************************************************************************
 *
 *  NFA interface for tag Reader/Writer
 *
 ******************************************************************************/
#include <string.h>
#include "nfa_api.h"
#include "nfa_sys.h"
#include "nfa_rw_int.h"
#include "nfa_sys_int.h"

/*****************************************************************************
**  Constants
*****************************************************************************/


/*****************************************************************************
**  APIs
*****************************************************************************/

/*******************************************************************************
**
** Function         NFA_RwDetectNDef
**
** Description      Perform the NDEF detection procedure  using the appropriate
**                  method for the currently activated tag.
**
**                  Upon successful completion of NDEF detection, a
**                  NFA_NDEF_DETECT_EVT will be sent, to notify the application
**                  of the NDEF attributes (NDEF total memory size, current
**                  size, etc.).
**
**                  It is not mandatory to call this function -  NFA_RwReadNDef
**                  and NFA_RwWriteNDef will perform NDEF detection internally if
**                  not performed already. This API may be called to get a
**                  tag's NDEF size before issuing a write-request.
**
** Returns:
**                  NFA_STATUS_OK if successfully initiated
**                  NFC_STATUS_REFUSED if tag does not support NDEF
**                  NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwDetectNDef (void)
{
    tNFA_RW_OPERATION *p_msg;

    NFA_TRACE_API0 ("NFA_RwDetectNDef");

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL)
    {
        p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT;
        p_msg->op        = NFA_RW_OP_DETECT_NDEF;

        nfa_sys_sendmsg (p_msg);

        return (NFA_STATUS_OK);
    }

    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
**
** Function         NFA_RwReadNDef
**
** Description      Read NDEF message from tag. This function will internally
**                  perform the NDEF detection procedure (if not performed
**                  previously), and read the NDEF tag data using the
**                  appropriate method for the currently activated tag.
**
**                  Upon successful completion of NDEF detection (if performed),
**                  a NFA_NDEF_DETECT_EVT will be sent, to notify the application
**                  of the NDEF attributes (NDEF total memory size, current size,
**                  etc.).
**
**                  Upon receiving the NDEF message, the message will be sent to
**                  the handler registered with NFA_RegisterNDefTypeHandler or
**                  NFA_RequestExclusiveRfControl (if exclusive RF mode is active)
**
** Returns:
**                  NFA_STATUS_OK if successfully initiated
**                  NFC_STATUS_REFUSED if tag does not support NDEF
**                  NFC_STATUS_NOT_INITIALIZED if NULL NDEF was detected on the tag
**                  NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwReadNDef (void)
{
    tNFA_RW_OPERATION *p_msg;

    NFA_TRACE_API0 ("NFA_RwReadNDef");

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL)
    {
        p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT;
        p_msg->op        = NFA_RW_OP_READ_NDEF;

        nfa_sys_sendmsg (p_msg);

        return (NFA_STATUS_OK);
    }

    return (NFA_STATUS_FAILED);
}



/*******************************************************************************
**
** Function         NFA_RwWriteNDef
**
** Description      Write NDEF data to the activated tag. This function will
**                  internally perform NDEF detection if necessary, and write
**                  the NDEF tag data using the appropriate method for the
**                  currently activated tag.
**
**                  When the entire message has been written, or if an error
**                  occurs, the app will be notified with NFA_WRITE_CPLT_EVT.
**
**                  p_data needs to be persistent until NFA_WRITE_CPLT_EVT
**
**
** Returns:
**                  NFA_STATUS_OK if successfully initiated
**                  NFC_STATUS_REFUSED if tag does not support NDEF/locked
**                  NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwWriteNDef (UINT8 *p_data, UINT32 len)
{
    tNFA_RW_OPERATION *p_msg;

    NFA_TRACE_API2 ("NFA_RwWriteNDef (): ndef p_data=%08x, len: %i", p_data, len);

    /* Validate parameters */
    if (p_data == NULL)
        return (NFA_STATUS_INVALID_PARAM);

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL)
    {
        p_msg->hdr.event                = NFA_RW_OP_REQUEST_EVT;
        p_msg->op                       = NFA_RW_OP_WRITE_NDEF;
        p_msg->params.write_ndef.len    = len;
        p_msg->params.write_ndef.p_data = p_data;
        nfa_sys_sendmsg (p_msg);

        return (NFA_STATUS_OK);
    }

    return (NFA_STATUS_FAILED);
}

/*****************************************************************************
**
** Function         NFA_RwPresenceCheck
**
** Description      Check if the tag is still in the field.
**
**                  The NFA_RW_PRESENCE_CHECK_EVT w/ status is used to
**                  indicate presence or non-presence.
**
**                  option is used only with ISO-DEP protocol
**
** Returns
**                  NFA_STATUS_OK if successfully initiated
**                  NFA_STATUS_FAILED otherwise
**
*****************************************************************************/
tNFA_STATUS NFA_RwPresenceCheck (tNFA_RW_PRES_CHK_OPTION option)
{
    tNFA_RW_OPERATION *p_msg;

    NFA_TRACE_API0 ("NFA_RwPresenceCheck");

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL)
    {
        p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT;
        p_msg->op        = NFA_RW_OP_PRESENCE_CHECK;
        p_msg->params.option    = option;

        nfa_sys_sendmsg (p_msg);

        return (NFA_STATUS_OK);
    }

    return (NFA_STATUS_FAILED);
}

/*****************************************************************************
**
** Function         NFA_RwFormatTag
**
** Description      Check if the tag is NDEF Formatable. If yes Format the tag
**
**                  The NFA_RW_FORMAT_CPLT_EVT w/ status is used to
**                  indicate if tag is successfully formated or not
**
** Returns
**                  NFA_STATUS_OK if successfully initiated
**                  NFA_STATUS_FAILED otherwise
**
*****************************************************************************/
tNFA_STATUS NFA_RwFormatTag (void)
{
    tNFA_RW_OPERATION *p_msg;

    NFA_TRACE_API0 ("NFA_RwFormatTag");

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16)(sizeof (tNFA_RW_OPERATION)))) != NULL)
    {
        p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT;
        p_msg->op        = NFA_RW_OP_FORMAT_TAG;

        nfa_sys_sendmsg (p_msg);

        return (NFA_STATUS_OK);
    }

    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
**
** Function         NFA_RwSetTagReadOnly
**
** Description:
**      Sets tag as read only.
**
**      When tag is set as read only, or if an error occurs, the app will be
**      notified with NFA_SET_TAG_RO_EVT.
**
** Returns:
**      NFA_STATUS_OK if successfully initiated
**      NFA_STATUS_REJECTED if protocol is not T1/T2/ISO15693
**                 (or) if hard lock is not requested for protocol ISO15693
**      NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwSetTagReadOnly (BOOLEAN b_hard_lock)
{
    tNFA_RW_OPERATION *p_msg;
    tNFC_PROTOCOL      protocol = nfa_rw_cb.protocol;

    if ((protocol != NFC_PROTOCOL_T1T) && (protocol != NFC_PROTOCOL_T2T) && (protocol != NFC_PROTOCOL_15693) && (protocol != NFC_PROTOCOL_ISO_DEP) && (protocol != NFC_PROTOCOL_T3T))
    {
        NFA_TRACE_API1 ("NFA_RwSetTagReadOnly (): Cannot Configure as read only for Protocol: %d", protocol);
        return (NFA_STATUS_REJECTED);
    }

    if (  (!b_hard_lock && (protocol == NFC_PROTOCOL_15693))
        ||(b_hard_lock && (protocol == NFC_PROTOCOL_ISO_DEP))  )
    {
        NFA_TRACE_API2 ("NFA_RwSetTagReadOnly (): Cannot %s for Protocol: %d", b_hard_lock ? "Hard lock" : "Soft lock", protocol);
        return (NFA_STATUS_REJECTED);
    }

    NFA_TRACE_API1 ("NFA_RwSetTagReadOnly (): %s", b_hard_lock ? "Hard lock" : "Soft lock");

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL)
    {
        /* Fill in tNFA_RW_OPERATION struct */
        p_msg->hdr.event                       = NFA_RW_OP_REQUEST_EVT;
        p_msg->op                              = NFA_RW_OP_SET_TAG_RO;
        p_msg->params.set_readonly.b_hard_lock = b_hard_lock;

        nfa_sys_sendmsg (p_msg);
        return (NFA_STATUS_OK);
    }
    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
** Tag specific APIs
** (note: for Type-4 tags, use NFA_SendRawFrame to exchange APDUs)
*******************************************************************************/

/*******************************************************************************
**
** Function         NFA_RwLocateTlv
**
** Description:
**      Search for the Lock/Memory contril TLV on the activated Type1/Type2 tag
**
**      Data is returned to the application using the NFA_TLV_DETECT_EVT. When
**      search operation has completed, or if an error occurs, the app will be
**      notified with NFA_TLV_DETECT_EVT.
**
** Description      Perform the TLV detection procedure  using the appropriate
**                  method for the currently activated tag.
**
**                  Upon successful completion of TLV detection in T1/T2 tag, a
**                  NFA_TLV_DETECT_EVT will be sent, to notify the application
**                  of the TLV attributes (total lock/reserved bytes etc.).
**                  However if the TLV type specified is NDEF then it is same as
**                  calling NFA_RwDetectNDef and should expect to receive
**                  NFA_NDEF_DETECT_EVT instead of NFA_TLV_DETECT_EVT
**
**                  It is not mandatory to call this function -  NFA_RwDetectNDef,
**                  NFA_RwReadNDef and NFA_RwWriteNDef will perform TLV detection
**                  internally if not performed already. An application may call
**                  this API to check the a tag/card-emulator's total Reserved/
**                  Lock bytes before issuing a write-request.
**
** Returns:
**                  NFA_STATUS_OK if successfully initiated
**                  NFC_STATUS_REFUSED if tlv_type is NDEF & tag won't support NDEF
**                  NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwLocateTlv (UINT8 tlv_type)
{
    tNFA_RW_OPERATION *p_msg;

    NFA_TRACE_API0 ("NFA_RwLocateTlv");

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL)
    {
        p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT;

        if (tlv_type == TAG_LOCK_CTRL_TLV)
        {
            p_msg->op = NFA_RW_OP_DETECT_LOCK_TLV;
        }
        else if (tlv_type == TAG_MEM_CTRL_TLV)
        {
            p_msg->op = NFA_RW_OP_DETECT_MEM_TLV;
        }
        else if (tlv_type == TAG_NDEF_TLV)
        {
            p_msg->op = NFA_RW_OP_DETECT_NDEF;
        }
        else
            return (NFA_STATUS_FAILED);

        nfa_sys_sendmsg (p_msg);

        return (NFA_STATUS_OK);
    }

    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
**
** Function         NFA_RwT1tRid
**
** Description:
**      Send a RID command to the activated Type 1 tag.
**
**      Data is returned to the application using the NFA_DATA_EVT. When the read
**      operation has completed, or if an error occurs, the app will be notified with
**      NFA_READ_CPLT_EVT.
**
** Returns:
**      NFA_STATUS_OK if successfully initiated
**      NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwT1tRid (void)
{
    tNFA_RW_OPERATION *p_msg;

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL)
    {
        /* Fill in tNFA_RW_OPERATION struct */
        p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT;
        p_msg->op        = NFA_RW_OP_T1T_RID;

        nfa_sys_sendmsg (p_msg);
        return (NFA_STATUS_OK);
    }
    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
**
** Function         NFA_RwT1tReadAll
**
** Description:
**      Send a RALL command to the activated Type 1 tag.
**
**      Data is returned to the application using the NFA_DATA_EVT. When the read
**      operation has completed, or if an error occurs, the app will be notified with
**      NFA_READ_CPLT_EVT.
**
** Returns:
**      NFA_STATUS_OK if successfully initiated
**      NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwT1tReadAll (void)
{
    tNFA_RW_OPERATION *p_msg;

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL)
    {
        /* Fill in tNFA_RW_OPERATION struct */
        p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT;
        p_msg->op        = NFA_RW_OP_T1T_RALL;

        nfa_sys_sendmsg (p_msg);
        return (NFA_STATUS_OK);
    }
    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
**
** Function         NFA_RwT1tRead
**
** Description:
**      Send a READ command to the activated Type 1 tag.
**
**      Data is returned to the application using the NFA_DATA_EVT. When the read
**      operation has completed, or if an error occurs, the app will be notified with
**      NFA_READ_CPLT_EVT.
**
** Returns:
**      NFA_STATUS_OK if successfully initiated
**      NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwT1tRead (UINT8 block_number, UINT8 index)
{
    tNFA_RW_OPERATION *p_msg;

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL)
    {
        /* Fill in tNFA_RW_OPERATION struct */
        p_msg->hdr.event                    = NFA_RW_OP_REQUEST_EVT;
        p_msg->op                           = NFA_RW_OP_T1T_READ;
        p_msg->params.t1t_read.block_number = block_number;
        p_msg->params.t1t_read.index        = index;

        nfa_sys_sendmsg (p_msg);
        return (NFA_STATUS_OK);
    }
    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
**
** Function         NFA_RwT1tWrite
**
** Description:
**      Send a WRITE command to the activated Type 1 tag.
**
**      Data is returned to the application using the NFA_DATA_EVT. When the write
**      operation has completed, or if an error occurs, the app will be notified with
**      NFA_WRITE_CPLT_EVT.
**
** Returns:
**      NFA_STATUS_OK if successfully initiated
**      NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwT1tWrite (UINT8 block_number, UINT8 index, UINT8 data, BOOLEAN b_erase)
{
    tNFA_RW_OPERATION *p_msg;

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL)
    {
        /* Fill in tNFA_RW_OPERATION struct */
        p_msg->hdr.event                     = NFA_RW_OP_REQUEST_EVT;
        p_msg->params.t1t_write.b_erase      = b_erase;
        p_msg->op                            = NFA_RW_OP_T1T_WRITE;
        p_msg->params.t1t_write.block_number = block_number;
        p_msg->params.t1t_write.index        = index;
        p_msg->params.t1t_write.p_block_data[0] = data;

        nfa_sys_sendmsg (p_msg);
        return (NFA_STATUS_OK);
    }
    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
**
** Function         NFA_RwT1tReadSeg
**
** Description:
**      Send a RSEG command to the activated Type 1 tag.
**
**      Data is returned to the application using the NFA_DATA_EVT. When the read
**      operation has completed, or if an error occurs, the app will be notified with
**      NFA_READ_CPLT_EVT.
**
** Returns:
**      NFA_STATUS_OK if successfully initiated
**      NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwT1tReadSeg (UINT8 segment_number)
{
    tNFA_RW_OPERATION *p_msg;

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL)
    {
        /* Fill in tNFA_RW_OPERATION struct */
        p_msg->hdr.event                      = NFA_RW_OP_REQUEST_EVT;
        p_msg->op                             = NFA_RW_OP_T1T_RSEG;
        p_msg->params.t1t_read.segment_number = segment_number;

        nfa_sys_sendmsg (p_msg);
        return (NFA_STATUS_OK);
    }
    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
**
** Function         NFA_RwT1tRead8
**
** Description:
**      Send a READ8 command to the activated Type 1 tag.
**
**      Data is returned to the application using the NFA_DATA_EVT. When the read
**      operation has completed, or if an error occurs, the app will be notified with
**      NFA_READ_CPLT_EVT.
**
** Returns:
**      NFA_STATUS_OK if successfully initiated
**      NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwT1tRead8 (UINT8 block_number)
{
    tNFA_RW_OPERATION *p_msg;

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL)
    {
        /* Fill in tNFA_RW_OPERATION struct */
        p_msg->hdr.event                     = NFA_RW_OP_REQUEST_EVT;
        p_msg->op                            = NFA_RW_OP_T1T_READ8;
        p_msg->params.t1t_write.block_number = block_number;

        nfa_sys_sendmsg (p_msg);
        return (NFA_STATUS_OK);
    }
    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
**
** Function         NFA_RwT1tWrite8
**
** Description:
**      Send a WRITE8_E / WRITE8_NE command to the activated Type 1 tag.
**
**      Data is returned to the application using the NFA_DATA_EVT. When the read
**      operation has completed, or if an error occurs, the app will be notified with
**      NFA_READ_CPLT_EVT.
**
** Returns:
**      NFA_STATUS_OK if successfully initiated
**      NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwT1tWrite8 (UINT8 block_number, UINT8 *p_data, BOOLEAN b_erase)
{
    tNFA_RW_OPERATION *p_msg;

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL)
    {
        /* Fill in tNFA_RW_OPERATION struct */
        p_msg->hdr.event                     = NFA_RW_OP_REQUEST_EVT;
        p_msg->params.t1t_write.b_erase      = b_erase;
        p_msg->op                            = NFA_RW_OP_T1T_WRITE8;
        p_msg->params.t1t_write.block_number = block_number;

        memcpy (p_msg->params.t1t_write.p_block_data,p_data,8);

        nfa_sys_sendmsg (p_msg);
        return (NFA_STATUS_OK);
    }
    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
**
** Function         NFA_RwT2tRead
**
** Description:
**      Send a READ command to the activated Type 2 tag.
**
**      Data is returned to the application using the NFA_DATA_EVT. When the read
**      operation has completed, or if an error occurs, the app will be notified with
**      NFA_READ_CPLT_EVT.
**
** Returns:
**      NFA_STATUS_OK if successfully initiated
**      NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwT2tRead (UINT8 block_number)
{
    tNFA_RW_OPERATION *p_msg;

    NFA_TRACE_API1 ("NFA_RwT2tRead (): Block to read: %d", block_number);

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL)
    {
        /* Fill in tNFA_RW_OPERATION struct */
        p_msg->hdr.event                    = NFA_RW_OP_REQUEST_EVT;
        p_msg->op                           = NFA_RW_OP_T2T_READ;
        p_msg->params.t2t_read.block_number = block_number;

        nfa_sys_sendmsg (p_msg);
        return (NFA_STATUS_OK);
    }
    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
**
** Function         NFA_RwT2tWrite
**
** Description:
**      Send an WRITE command to the activated Type 2 tag.
**
**      When the write operation has completed (or if an error occurs), the
**      app will be notified with NFA_WRITE_CPLT_EVT.
**
** Returns:
**      NFA_STATUS_OK if successfully initiated
**      NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwT2tWrite (UINT8 block_number,	UINT8 *p_data)
{
    tNFA_RW_OPERATION *p_msg;

    NFA_TRACE_API1 ("NFA_RwT2tWrite (): Block to write: %d", block_number);

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL)
    {
        /* Fill in tNFA_RW_OPERATION struct */
        p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT;
        p_msg->op        = NFA_RW_OP_T2T_WRITE;

        p_msg->params.t2t_write.block_number = block_number;

        memcpy (p_msg->params.t2t_write.p_block_data,p_data,4);

        nfa_sys_sendmsg (p_msg);
        return (NFA_STATUS_OK);
    }
    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
**
** Function         NFA_RwT2tSectorSelect
**
** Description:
**      Send SECTOR SELECT command to the activated Type 2 tag.
**
**      When the sector select operation has completed (or if an error occurs), the
**      app will be notified with NFA_SECTOR_SELECT_CPLT_EVT.
**
** Returns:
**      NFA_STATUS_OK if successfully initiated
**      NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwT2tSectorSelect (UINT8 sector_number)
{
    tNFA_RW_OPERATION *p_msg;

    NFA_TRACE_API1 ("NFA_RwT2tRead (): sector to select: %d", sector_number);

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL)
    {
        /* Fill in tNFA_RW_OPERATION struct */
        p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT;
        p_msg->op        = NFA_RW_OP_T2T_SECTOR_SELECT;

        p_msg->params.t2t_sector_select.sector_number = sector_number;

        nfa_sys_sendmsg (p_msg);
        return (NFA_STATUS_OK);
    }
    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
**
** Function         NFA_RwT3tRead
**
** Description:
**      Send a CHECK (read) command to the activated Type 3 tag.
**
**      Data is returned to the application using the NFA_DATA_EVT. When the read
**      operation has completed, or if an error occurs, the app will be notified with
**      NFA_READ_CPLT_EVT.
**
** Returns:
**      NFA_STATUS_OK if successfully initiated
**      NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwT3tRead (UINT8 num_blocks, tNFA_T3T_BLOCK_DESC *t3t_blocks)
{
    tNFA_RW_OPERATION *p_msg;
    UINT8 *p_block_desc;

    NFA_TRACE_API1 ("NFA_RwT3tRead (): num_blocks to read: %i", num_blocks);

    /* Validate parameters */
    if ((num_blocks == 0) || (t3t_blocks == NULL))
        return (NFA_STATUS_INVALID_PARAM);

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION) + (num_blocks * sizeof (tNFA_T3T_BLOCK_DESC))))) != NULL)
    {
        /* point to area after tNFA_RW_OPERATION */
        p_block_desc = (UINT8 *) (p_msg+1);

        /* Fill in tNFA_RW_OPERATION struct */
        p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT;
        p_msg->op        = NFA_RW_OP_T3T_READ;

        p_msg->params.t3t_read.num_blocks   = num_blocks;
        p_msg->params.t3t_read.p_block_desc = (tNFA_T3T_BLOCK_DESC *) p_block_desc;

        /* Copy block descriptor list */
        memcpy (p_block_desc, t3t_blocks, (num_blocks * sizeof (tNFA_T3T_BLOCK_DESC)));

        nfa_sys_sendmsg (p_msg);

        return (NFA_STATUS_OK);
    }

    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
**
** Function         NFA_RwT3tWrite
**
** Description:
**      Send an UPDATE (write) command to the activated Type 3 tag.
**
**      When the write operation has completed (or if an error occurs), the
**      app will be notified with NFA_WRITE_CPLT_EVT.
**
** Returns:
**      NFA_STATUS_OK if successfully initiated
**      NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwT3tWrite (UINT8 num_blocks, tNFA_T3T_BLOCK_DESC *t3t_blocks,	UINT8 *p_data)
{
    tNFA_RW_OPERATION *p_msg;
    UINT8 *p_block_desc, *p_data_area;

    NFA_TRACE_API1 ("NFA_RwT3tWrite (): num_blocks to write: %i", num_blocks);

    /* Validate parameters */
    if ((num_blocks == 0) || (t3t_blocks == NULL) | (p_data == NULL))
        return (NFA_STATUS_INVALID_PARAM);

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION) + (num_blocks * (sizeof (tNFA_T3T_BLOCK_DESC) + 16))))) != NULL)
    {
        /* point to block descriptor and data areas after tNFA_RW_OPERATION */
        p_block_desc = (UINT8 *) (p_msg+1);
        p_data_area  = p_block_desc + (num_blocks * (sizeof (tNFA_T3T_BLOCK_DESC)));

        /* Fill in tNFA_RW_OPERATION struct */
        p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT;
        p_msg->op        = NFA_RW_OP_T3T_WRITE;

        p_msg->params.t3t_write.num_blocks   = num_blocks;
        p_msg->params.t3t_write.p_block_desc = (tNFA_T3T_BLOCK_DESC *) p_block_desc;
        p_msg->params.t3t_write.p_block_data = p_data_area;

        /* Copy block descriptor list */
        memcpy (p_block_desc, t3t_blocks, (num_blocks * sizeof (tNFA_T3T_BLOCK_DESC)));

        /* Copy data */
        memcpy (p_data_area, p_data, (num_blocks * 16));

        nfa_sys_sendmsg (p_msg);

        return (NFA_STATUS_OK);
    }

    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
**
** Function         NFA_RwI93Inventory
**
** Description:
**      Send Inventory command to the activated ISO 15693 tag with/without AFI
**      If UID is provided then set UID[0]:MSB, ... UID[7]:LSB
**
**      When the operation has completed (or if an error occurs), the
**      app will be notified with NFA_I93_CMD_CPLT_EVT.
**
** Returns:
**      NFA_STATUS_OK if successfully initiated
**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
**      NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwI93Inventory (BOOLEAN afi_present, UINT8 afi, UINT8 *p_uid)
{
    tNFA_RW_OPERATION *p_msg;

    NFA_TRACE_API2 ("NFA_RwI93Inventory (): afi_present:%d, AFI: 0x%02X", afi_present, afi);

    if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693)
    {
        return (NFA_STATUS_WRONG_PROTOCOL);
    }

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL)
    {
        /* Fill in tNFA_RW_OPERATION struct */
        p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT;
        p_msg->op        = NFA_RW_OP_I93_INVENTORY;

        p_msg->params.i93_cmd.afi_present = afi_present;
        p_msg->params.i93_cmd.afi = afi;

        if (p_uid)
        {
            p_msg->params.i93_cmd.uid_present = TRUE;
            memcpy (p_msg->params.i93_cmd.uid, p_uid, I93_UID_BYTE_LEN);
        }
        else
        {
            p_msg->params.i93_cmd.uid_present = FALSE;
        }

        nfa_sys_sendmsg (p_msg);

        return (NFA_STATUS_OK);
    }

    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
**
** Function         NFA_RwI93StayQuiet
**
** Description:
**      Send Stay Quiet command to the activated ISO 15693 tag.
**
**      When the operation has completed (or if an error occurs), the
**      app will be notified with NFA_I93_CMD_CPLT_EVT.
**
** Returns:
**      NFA_STATUS_OK if successfully initiated
**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
**      NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwI93StayQuiet (void)
{
    tNFA_RW_OPERATION *p_msg;

    NFA_TRACE_API0 ("NFA_RwI93StayQuiet ()");

    if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693)
    {
        return (NFA_STATUS_WRONG_PROTOCOL);
    }

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL)
    {
        /* Fill in tNFA_RW_OPERATION struct */
        p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT;
        p_msg->op        = NFA_RW_OP_I93_STAY_QUIET;

        nfa_sys_sendmsg (p_msg);

        return (NFA_STATUS_OK);
    }

    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
**
** Function         NFA_RwI93ReadSingleBlock
**
** Description:
**      Send Read Single Block command to the activated ISO 15693 tag.
**
**      Data is returned to the application using the NFA_DATA_EVT. When the read
**      operation has completed, or if an error occurs, the app will be notified with
**      NFA_I93_CMD_CPLT_EVT.
**
** Returns:
**      NFA_STATUS_OK if successfully initiated
**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
**      NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwI93ReadSingleBlock (UINT8 block_number)
{
    tNFA_RW_OPERATION *p_msg;

    NFA_TRACE_API1 ("NFA_RwI93ReadSingleBlock (): block_number: 0x%02X", block_number);

    if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693)
    {
        return (NFA_STATUS_WRONG_PROTOCOL);
    }

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL)
    {
        /* Fill in tNFA_RW_OPERATION struct */
        p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT;
        p_msg->op        = NFA_RW_OP_I93_READ_SINGLE_BLOCK;

        p_msg->params.i93_cmd.first_block_number = block_number;

        nfa_sys_sendmsg (p_msg);

        return (NFA_STATUS_OK);
    }

    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
**
** Function         NFA_RwI93WriteSingleBlock
**
** Description:
**      Send Write Single Block command to the activated ISO 15693 tag.
**
**      When the write operation has completed (or if an error occurs), the
**      app will be notified with NFA_I93_CMD_CPLT_EVT.
**
** Returns:
**      NFA_STATUS_OK if successfully initiated
**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
**      NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwI93WriteSingleBlock (UINT8 block_number,
                                       UINT8 *p_data)
{
    tNFA_RW_OPERATION *p_msg;

    NFA_TRACE_API1 ("NFA_RwI93WriteSingleBlock (): block_number: 0x%02X", block_number);

    if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693)
    {
        return (NFA_STATUS_WRONG_PROTOCOL);
    }

    /* we don't know block size of tag */
    if (  (nfa_rw_cb.i93_block_size == 0)
        ||(nfa_rw_cb.i93_num_block == 0)  )
    {
        return (NFA_STATUS_FAILED);
    }

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION) + nfa_rw_cb.i93_block_size))) != NULL)
    {
        /* Fill in tNFA_RW_OPERATION struct */
        p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT;
        p_msg->op        = NFA_RW_OP_I93_WRITE_SINGLE_BLOCK;

        p_msg->params.i93_cmd.first_block_number = block_number;
        p_msg->params.i93_cmd.p_data             = (UINT8*) (p_msg + 1);

        memcpy (p_msg->params.i93_cmd.p_data, p_data, nfa_rw_cb.i93_block_size);

        nfa_sys_sendmsg (p_msg);

        return (NFA_STATUS_OK);
    }

    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
**
** Function         NFA_RwI93LockBlock
**
** Description:
**      Send Lock block command to the activated ISO 15693 tag.
**
**      When the operation has completed (or if an error occurs), the
**      app will be notified with NFA_I93_CMD_CPLT_EVT.
**
** Returns:
**      NFA_STATUS_OK if successfully initiated
**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
**      NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwI93LockBlock (UINT8 block_number)
{
    tNFA_RW_OPERATION *p_msg;

    NFA_TRACE_API1 ("NFA_RwI93LockBlock (): block_number: 0x%02X", block_number);

    if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693)
    {
        return (NFA_STATUS_WRONG_PROTOCOL);
    }

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL)
    {
        /* Fill in tNFA_RW_OPERATION struct */
        p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT;
        p_msg->op        = NFA_RW_OP_I93_LOCK_BLOCK;

        p_msg->params.i93_cmd.first_block_number = block_number;

        nfa_sys_sendmsg (p_msg);

        return (NFA_STATUS_OK);
    }

    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
**
** Function         NFA_RwI93ReadMultipleBlocks
**
** Description:
**      Send Read Multiple Block command to the activated ISO 15693 tag.
**
**      Data is returned to the application using the NFA_DATA_EVT. When the read
**      operation has completed, or if an error occurs, the app will be notified with
**      NFA_I93_CMD_CPLT_EVT.
**
** Returns:
**      NFA_STATUS_OK if successfully initiated
**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
**      NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwI93ReadMultipleBlocks (UINT8  first_block_number,
                                         UINT16 number_blocks)
{
    tNFA_RW_OPERATION *p_msg;

    NFA_TRACE_API2 ("NFA_RwI93ReadMultipleBlocks(): %d, %d", first_block_number, number_blocks);

    if ( nfa_rw_cb.protocol != NFC_PROTOCOL_15693)
    {
        return (NFA_STATUS_WRONG_PROTOCOL);
    }

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL)
    {
        /* Fill in tNFA_RW_OPERATION struct */
        p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT;
        p_msg->op        = NFA_RW_OP_I93_READ_MULTI_BLOCK;

        p_msg->params.i93_cmd.first_block_number = first_block_number;
        p_msg->params.i93_cmd.number_blocks      = number_blocks;

        nfa_sys_sendmsg (p_msg);

        return (NFA_STATUS_OK);
    }

    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
**
** Function         NFA_RwI93WriteMultipleBlocks
**
** Description:
**      Send Write Multiple Block command to the activated ISO 15693 tag.
**
**      When the write operation has completed (or if an error occurs), the
**      app will be notified with NFA_I93_CMD_CPLT_EVT.
**
** Returns:
**      NFA_STATUS_OK if successfully initiated
**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
**      NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwI93WriteMultipleBlocks (UINT8  first_block_number,
                                          UINT16 number_blocks,
                                          UINT8 *p_data)
{
    tNFA_RW_OPERATION *p_msg;
    UINT16      data_length;

    NFA_TRACE_API2 ("NFA_RwI93WriteMultipleBlocks (): %d, %d", first_block_number, number_blocks);

    if ( nfa_rw_cb.protocol != NFC_PROTOCOL_15693)
    {
        return (NFA_STATUS_WRONG_PROTOCOL);
    }

    /* we don't know block size of tag */
    if ((nfa_rw_cb.i93_block_size == 0) || (nfa_rw_cb.i93_num_block == 0))
    {
        return (NFA_STATUS_FAILED);
    }

    data_length = nfa_rw_cb.i93_block_size * number_blocks;

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION) + data_length))) != NULL)
    {
        /* Fill in tNFA_RW_OPERATION struct */
        p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT;
        p_msg->op        = NFA_RW_OP_I93_WRITE_MULTI_BLOCK;

        p_msg->params.i93_cmd.first_block_number = first_block_number;
        p_msg->params.i93_cmd.number_blocks      = number_blocks;
        p_msg->params.i93_cmd.p_data             = (UINT8*) (p_msg + 1);

        memcpy (p_msg->params.i93_cmd.p_data, p_data, data_length);

        nfa_sys_sendmsg (p_msg);

        return (NFA_STATUS_OK);
    }

    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
**
** Function         NFA_RwI93Select
**
** Description:
**      Send Select command to the activated ISO 15693 tag.
**
**      UID[0]: 0xE0, MSB
**      UID[1]: IC Mfg Code
**      ...
**      UID[7]: LSB
**
**      When the operation has completed (or if an error occurs), the
**      app will be notified with NFA_I93_CMD_CPLT_EVT.
**
** Returns:
**      NFA_STATUS_OK if successfully initiated
**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
**      NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwI93Select (UINT8 *p_uid)
{
    tNFA_RW_OPERATION *p_msg;

    NFA_TRACE_API3 ("NFA_RwI93Select (): UID: [%02X%02X%02X...]", *(p_uid), *(p_uid+1), *(p_uid+2));

    if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693)
    {
        return (NFA_STATUS_WRONG_PROTOCOL);
    }

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION) + I93_UID_BYTE_LEN))) != NULL)
    {
        /* Fill in tNFA_RW_OPERATION struct */
        p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT;
        p_msg->op        = NFA_RW_OP_I93_SELECT;

        p_msg->params.i93_cmd.p_data = (UINT8 *) (p_msg + 1);
        memcpy (p_msg->params.i93_cmd.p_data, p_uid, I93_UID_BYTE_LEN);

        nfa_sys_sendmsg (p_msg);

        return (NFA_STATUS_OK);
    }

    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
**
** Function         NFA_RwI93ResetToReady
**
** Description:
**      Send Reset to ready command to the activated ISO 15693 tag.
**
**      When the operation has completed (or if an error occurs), the
**      app will be notified with NFA_I93_CMD_CPLT_EVT.
**
** Returns:
**      NFA_STATUS_OK if successfully initiated
**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
**      NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwI93ResetToReady (void)
{
    tNFA_RW_OPERATION *p_msg;

    NFA_TRACE_API0 ("NFA_RwI93ResetToReady ()");

    if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693)
    {
        return (NFA_STATUS_WRONG_PROTOCOL);
    }

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL)
    {
        /* Fill in tNFA_RW_OPERATION struct */
        p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT;
        p_msg->op        = NFA_RW_OP_I93_RESET_TO_READY;

        nfa_sys_sendmsg (p_msg);

        return (NFA_STATUS_OK);
    }

    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
**
** Function         NFA_RwI93WriteAFI
**
** Description:
**      Send Write AFI command to the activated ISO 15693 tag.
**
**      When the operation has completed (or if an error occurs), the
**      app will be notified with NFA_I93_CMD_CPLT_EVT.
**
** Returns:
**      NFA_STATUS_OK if successfully initiated
**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
**      NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwI93WriteAFI (UINT8 afi)
{
    tNFA_RW_OPERATION *p_msg;

    NFA_TRACE_API1 ("NFA_RwI93WriteAFI (): AFI: 0x%02X", afi);

    if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693)
    {
        return (NFA_STATUS_WRONG_PROTOCOL);
    }

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL)
    {
        /* Fill in tNFA_RW_OPERATION struct */
        p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT;
        p_msg->op        = NFA_RW_OP_I93_WRITE_AFI;

        p_msg->params.i93_cmd.afi = afi;

        nfa_sys_sendmsg (p_msg);

        return (NFA_STATUS_OK);
    }

    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
**
** Function         NFA_RwI93LockAFI
**
** Description:
**      Send Lock AFI command to the activated ISO 15693 tag.
**
**      When the operation has completed (or if an error occurs), the
**      app will be notified with NFA_I93_CMD_CPLT_EVT.
**
** Returns:
**      NFA_STATUS_OK if successfully initiated
**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
**      NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwI93LockAFI (void)
{
    tNFA_RW_OPERATION *p_msg;

    NFA_TRACE_API0 ("NFA_RwI93LockAFI ()");

    if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693)
    {
        return (NFA_STATUS_WRONG_PROTOCOL);
    }

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL)
    {
        /* Fill in tNFA_RW_OPERATION struct */
        p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT;
        p_msg->op        = NFA_RW_OP_I93_LOCK_AFI;

        nfa_sys_sendmsg (p_msg);

        return (NFA_STATUS_OK);
    }

    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
**
** Function         NFA_RwI93WriteDSFID
**
** Description:
**      Send Write DSFID command to the activated ISO 15693 tag.
**
**      When the operation has completed (or if an error occurs), the
**      app will be notified with NFA_I93_CMD_CPLT_EVT.
**
** Returns:
**      NFA_STATUS_OK if successfully initiated
**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
**      NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwI93WriteDSFID (UINT8 dsfid)
{
    tNFA_RW_OPERATION *p_msg;

    NFA_TRACE_API1 ("NFA_RwI93WriteDSFID (): DSFID: 0x%02X", dsfid);

    if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693)
    {
        return (NFA_STATUS_WRONG_PROTOCOL);
    }

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL)
    {
        /* Fill in tNFA_RW_OPERATION struct */
        p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT;
        p_msg->op        = NFA_RW_OP_I93_WRITE_DSFID;

        p_msg->params.i93_cmd.dsfid = dsfid;

        nfa_sys_sendmsg (p_msg);

        return (NFA_STATUS_OK);
    }

    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
**
** Function         NFA_RwI93LockDSFID
**
** Description:
**      Send Lock DSFID command to the activated ISO 15693 tag.
**
**      When the operation has completed (or if an error occurs), the
**      app will be notified with NFA_I93_CMD_CPLT_EVT.
**
** Returns:
**      NFA_STATUS_OK if successfully initiated
**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
**      NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwI93LockDSFID (void)
{
    tNFA_RW_OPERATION *p_msg;

    NFA_TRACE_API0 ("NFA_RwI93LockDSFID ()");

    if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693)
    {
        return (NFA_STATUS_WRONG_PROTOCOL);
    }

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL)
    {
        /* Fill in tNFA_RW_OPERATION struct */
        p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT;
        p_msg->op        = NFA_RW_OP_I93_LOCK_DSFID;

        nfa_sys_sendmsg (p_msg);

        return (NFA_STATUS_OK);
    }

    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
**
** Function         NFA_RwI93GetSysInfo
**
** Description:
**      Send Get system information command to the activated ISO 15693 tag.
**      If UID is provided then set UID[0]:MSB, ... UID[7]:LSB
**
**      When the operation has completed (or if an error occurs), the
**      app will be notified with NFA_I93_CMD_CPLT_EVT.
**
** Returns:
**      NFA_STATUS_OK if successfully initiated
**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
**      NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwI93GetSysInfo (UINT8 *p_uid)
{
    tNFA_RW_OPERATION *p_msg;

    NFA_TRACE_API0 ("NFA_RwI93GetSysInfo ()");

    if (nfa_rw_cb.protocol != NFC_PROTOCOL_15693)
    {
        return (NFA_STATUS_WRONG_PROTOCOL);
    }

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL)
    {
        /* Fill in tNFA_RW_OPERATION struct */
        p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT;
        p_msg->op        = NFA_RW_OP_I93_GET_SYS_INFO;

        if (p_uid)
        {
            p_msg->params.i93_cmd.uid_present = TRUE;
            memcpy (p_msg->params.i93_cmd.uid, p_uid, I93_UID_BYTE_LEN);
        }
        else
        {
            p_msg->params.i93_cmd.uid_present = FALSE;
        }

        nfa_sys_sendmsg (p_msg);

        return (NFA_STATUS_OK);
    }

    return (NFA_STATUS_FAILED);
}

/*******************************************************************************
**
** Function         NFA_RwI93GetMultiBlockSecurityStatus
**
** Description:
**      Send Get Multiple block security status command to the activated ISO 15693 tag.
**
**      Data is returned to the application using the NFA_DATA_EVT. When the read
**      operation has completed, or if an error occurs, the app will be notified with
**      NFA_I93_CMD_CPLT_EVT.
**
** Returns:
**      NFA_STATUS_OK if successfully initiated
**      NFA_STATUS_WRONG_PROTOCOL: ISO 15693 tag not activated
**      NFA_STATUS_FAILED otherwise
**
*******************************************************************************/
tNFA_STATUS NFA_RwI93GetMultiBlockSecurityStatus (UINT8  first_block_number,
                                                  UINT16 number_blocks)
{
    tNFA_RW_OPERATION *p_msg;

    NFA_TRACE_API2 ("NFA_RwI93GetMultiBlockSecurityStatus(): %d, %d", first_block_number, number_blocks);

    if ( nfa_rw_cb.protocol != NFC_PROTOCOL_15693)
    {
        return (NFA_STATUS_WRONG_PROTOCOL);
    }

    if ((p_msg = (tNFA_RW_OPERATION *) GKI_getbuf ((UINT16) (sizeof (tNFA_RW_OPERATION)))) != NULL)
    {
        /* Fill in tNFA_RW_OPERATION struct */
        p_msg->hdr.event = NFA_RW_OP_REQUEST_EVT;
        p_msg->op        = NFA_RW_OP_I93_GET_MULTI_BLOCK_STATUS;

        p_msg->params.i93_cmd.first_block_number = first_block_number;
        p_msg->params.i93_cmd.number_blocks      = number_blocks;

        nfa_sys_sendmsg (p_msg);

        return (NFA_STATUS_OK);
    }

    return (NFA_STATUS_FAILED);
}