llrp_reader.c

Go to the documentation of this file.

/*
 * Copyright (c) 2011 ThingMagic, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#include "tm_reader.h"
#ifdef TMR_ENABLE_LLRP_READER

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <errno.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>

#include "tmr_utils.h"
#include "osdep.h"
#include "tmr_llrp_reader.h"
#include "llrp_reader_imp.h"

extern uint8_t TMR_LLRP_gpiListSargas[];
extern uint8_t TMR_LLRP_gpoListSargas[];
extern uint8_t sizeGpiListSargas;
extern uint8_t sizeGpoListSargas;
extern uint8_t TMR_LLRP_gpiListM6Astra[];
extern uint8_t TMR_LLRP_gpoListM6Astra[];
extern uint8_t sizeGpiListM6Astra;
extern uint8_t sizeGpoListM6Astra;

static TMR_Status
TMR_LLRP_initTxRxMapFromPorts(TMR_Reader *reader)
{
  TMR_Status ret;
  TMR_LLRP_PortDetect ports[TMR_SR_MAX_ANTENNA_PORTS];
  uint8_t numPorts, i;
  TMR_LLRP_LlrpReader *lr;

  numPorts = numberof(ports);
  lr = &reader->u.llrpReader;

  /* Need number of ports to set up Tx-Rx map */
  ret = TMR_LLRP_cmdAntennaDetect(reader, &numPorts, ports);
  if (TMR_SUCCESS != ret)
  {
    return ret;
  }

  lr->portMask = 0;
  for (i = 0; i < numPorts; i ++)
  {
    lr->portMask |= 1 << (ports[i].port - 1);
    lr->staticTxRxMapData[i].antenna = ports[i].port;
    lr->staticTxRxMapData[i].txPort  = ports[i].port;
    lr->staticTxRxMapData[i].rxPort  = ports[i].port;

    if (0 == reader->tagOpParams.antenna && ports[i].connected)
    {
      reader->tagOpParams.antenna = ports[i].port;
    }
  }

  lr->staticTxRxMap.max = TMR_SR_MAX_ANTENNA_PORTS;
  lr->staticTxRxMap.len = numPorts;
  lr->staticTxRxMap.list = lr->staticTxRxMapData;
  lr->txRxMap = &lr->staticTxRxMap;

  return TMR_SUCCESS;
}


static TMR_Status
TMR_LLRP_boot(TMR_Reader *reader)
{
  TMR_Status ret;
  TMR_LLRP_LlrpReader *lr;

  int i;

  ret = TMR_SUCCESS;
  lr = &reader->u.llrpReader;

  if (TMR_LLRP_READER_DEFAULT_PORT == reader->u.llrpReader.portNum)
  {
    ret = TMR_LLRP_setHoldEventsAndReportsStatus(reader, 1);
    if (TMR_SUCCESS != ret)
    {
    }

    ret = TMR_LLRP_stopActiveROSpecs(reader);
    if (TMR_SUCCESS != ret)
    {
      return ret;
    }
  }

  ret = TMR_LLRP_cmdGetRegion(reader, &reader->u.llrpReader.regionId);
  if (TMR_SUCCESS != ret)
  {
    reader->u.llrpReader.regionId = TMR_REGION_NA;
  }

  ret = TMR_LLRP_cmdGetReaderCapabilities(reader, &reader->u.llrpReader.capabilities);
  if (TMR_SUCCESS != ret)
  {
    uint8_t length = strlen("NOT AVAILABLE");
    memcpy(reader->u.llrpReader.capabilities.softwareVersion, "NOT AVAILABLE", (size_t)length);
    reader->u.llrpReader.capabilities.softwareVersion[length + 1] = '\0';
    reader->u.llrpReader.capabilities.model = 0;
    reader->u.llrpReader.capabilities.powerTable.list = NULL;
    reader->u.llrpReader.capabilities.powerTable.len = 0;
    reader->u.llrpReader.capabilities.freqTable.list = NULL;
    reader->u.llrpReader.capabilities.freqTable.len = 0;
  }

  /* Initialize the paramPresent and paramConfirmed bits. */
  /* This block is expected to be collapsed by the compiler into a
   * small number of constant-value writes into the lr->paramPresent
   * array.
   */
  for (i = 0 ; i < TMR_PARAMWORDS; i++)
  {
    lr->paramPresent[i] = 0;
  }

  BITSET(lr->paramPresent, TMR_PARAM_REGION_ID);
  BITSET(lr->paramPresent, TMR_PARAM_ANTENNA_PORTLIST);
  BITSET(lr->paramPresent, TMR_PARAM_ANTENNA_CONNECTEDPORTLIST);
  BITSET(lr->paramPresent, TMR_PARAM_RADIO_POWERMAX);
  BITSET(lr->paramPresent, TMR_PARAM_RADIO_POWERMIN);
  BITSET(lr->paramPresent, TMR_PARAM_RADIO_PORTREADPOWERLIST);
  BITSET(lr->paramPresent, TMR_PARAM_RADIO_PORTWRITEPOWERLIST);
  BITSET(lr->paramPresent, TMR_PARAM_READ_PLAN);
  BITSET(lr->paramPresent, TMR_PARAM_URI);
  BITSET(lr->paramPresent, TMR_PARAM_TRANSPORTTIMEOUT);
  BITSET(lr->paramPresent, TMR_PARAM_COMMANDTIMEOUT);
  BITSET(lr->paramPresent, TMR_PARAM_GPIO_INPUTLIST);
  BITSET(lr->paramPresent, TMR_PARAM_GPIO_OUTPUTLIST);
  BITSET(lr->paramPresent, TMR_PARAM_GEN2_ACCESSPASSWORD);
  BITSET(lr->paramPresent, TMR_PARAM_VERSION_HARDWARE);
  BITSET(lr->paramPresent, TMR_PARAM_VERSION_MODEL);
  BITSET(lr->paramPresent, TMR_PARAM_VERSION_SERIAL);
  BITSET(lr->paramPresent, TMR_PARAM_VERSION_SOFTWARE);
  BITSET(lr->paramPresent, TMR_PARAM_TAGREADDATA_RECORDHIGHESTRSSI);
  BITSET(lr->paramPresent, TMR_PARAM_TAGREADDATA_UNIQUEBYANTENNA);
  BITSET(lr->paramPresent, TMR_PARAM_TAGREADDATA_UNIQUEBYDATA);
  BITSET(lr->paramPresent, TMR_PARAM_READER_DESCRIPTION);
  BITSET(lr->paramPresent, TMR_PARAM_READER_HOSTNAME);
  BITSET(lr->paramPresent, TMR_PARAM_CURRENTTIME);
  BITSET(lr->paramPresent, TMR_PARAM_RADIO_TEMPERATURE);
  BITSET(lr->paramPresent, TMR_PARAM_GEN2_BLF);
  BITSET(lr->paramPresent, TMR_PARAM_GEN2_TAGENCODING);
  BITSET(lr->paramPresent, TMR_PARAM_GEN2_TARI);
  BITSET(lr->paramPresent, TMR_PARAM_GEN2_Q);
  BITSET(lr->paramPresent, TMR_PARAM_RADIO_READPOWER);
  BITSET(lr->paramPresent, TMR_PARAM_RADIO_WRITEPOWER);
  BITSET(lr->paramPresent, TMR_PARAM_VERSION_SUPPORTEDPROTOCOLS);
  BITSET(lr->paramPresent, TMR_PARAM_ANTENNA_CHECKPORT);
  BITSET(lr->paramPresent, TMR_PARAM_GEN2_SESSION);
  BITSET(lr->paramPresent, TMR_PARAM_GEN2_TARGET);
  BITSET(lr->paramPresent, TMR_PARAM_LICENSE_KEY);
  BITSET(lr->paramPresent, TMR_PARAM_TAGOP_ANTENNA);
  BITSET(lr->paramPresent, TMR_PARAM_TAGOP_PROTOCOL);
  BITSET(lr->paramPresent, TMR_PARAM_ISO180006B_DELIMITER);
  BITSET(lr->paramPresent, TMR_PARAM_ISO180006B_MODULATION_DEPTH);
  BITSET(lr->paramPresent, TMR_PARAM_ISO180006B_BLF);
  BITSET(lr->paramPresent, TMR_PARAM_REGION_SUPPORTEDREGIONS);
  BITSET(lr->paramPresent, TMR_PARAM_READ_ASYNCOFFTIME);
  BITSET(lr->paramPresent, TMR_PARAM_LICENSED_FEATURES);
 
  for (i = 0; i < TMR_PARAMWORDS; i++)
  {
    lr->paramConfirmed[i] = lr->paramPresent[i];
  }

   TMR_TagProtocol protocol[5];
   TMR_TagProtocolList protocolList;
   protocolList.list = protocol;
   ret = TMR_LLRP_cmdGetTMDeviceProtocolCapabilities(reader, &protocolList);
   if (TMR_SUCCESS != ret)
   {
     lr->supportedProtocols = (1 << (TMR_TAG_PROTOCOL_GEN2 - 1));
   }

  ret = TMR_LLRP_initTxRxMapFromPorts(reader);
  if (TMR_SUCCESS != ret)
  {
  }

  if (TMR_LLRP_READER_DEFAULT_PORT == reader->u.llrpReader.portNum)
  {
    ret = TMR_LLRP_setKeepAlive(reader);
    if (TMR_SUCCESS != ret)
    {
    }
  }

  return ret;
}

static void
TMR_LLRP_paramProbe(struct TMR_Reader *reader, TMR_Param key)
{
  TMR_LLRP_LlrpReader *lr;
 /* buf is at least as large as the largest parameter, with all values 0
  * (NULL pointers and 0 lengths).
  */
  uint32_t buf[] = {0, 0, 0, 0, 0, 0, 0, 0};
  TMR_Status ret;

  lr = &reader->u.llrpReader;

  ret = TMR_paramGet(reader, key, &buf);
  if (TMR_SUCCESS == ret)
  {
    BITSET(lr->paramPresent, key);
  }
  BITSET(lr->paramConfirmed, key);
}

static TMR_Status
TMR_LLRP_paramSet(struct TMR_Reader *reader, TMR_Param key, const void *value)
{
  TMR_Status ret;
  TMR_LLRP_LlrpReader *lr;

  ret = TMR_SUCCESS;
  lr = &reader->u.llrpReader;

  if (0 == BITGET(lr->paramConfirmed, key))
  {
    TMR_LLRP_paramProbe(reader, key);
  }

  if (BITGET(lr->paramConfirmed, key) && (0 == BITGET(lr->paramPresent, key)))
  {
    return TMR_ERROR_NOT_FOUND;
  }

  switch (key)
  {
    case TMR_PARAM_REGION_ID:
    case TMR_PARAM_REGION_SUPPORTEDREGIONS:
      {
        ret = TMR_ERROR_READONLY;
        break;
      }
   
    case TMR_PARAM_ANTENNA_PORTLIST:
    case TMR_PARAM_URI:
    case TMR_PARAM_ANTENNA_CONNECTEDPORTLIST:
    case TMR_PARAM_RADIO_POWERMAX:
    case TMR_PARAM_RADIO_POWERMIN:
    case TMR_PARAM_GPIO_INPUTLIST:
    case TMR_PARAM_GPIO_OUTPUTLIST:
    case TMR_PARAM_VERSION_MODEL:
    case TMR_PARAM_VERSION_SERIAL:
    case TMR_PARAM_VERSION_SOFTWARE:
    case TMR_PARAM_VERSION_HARDWARE:
    case TMR_PARAM_CURRENTTIME:
    case TMR_PARAM_RADIO_TEMPERATURE:
    case TMR_PARAM_VERSION_SUPPORTEDPROTOCOLS:
      {
        ret = TMR_ERROR_READONLY;
        break;
      }

    case TMR_PARAM_RADIO_PORTREADPOWERLIST:
      {
        TMR_PortValueList *list = (TMR_PortValueList *)value;

        if (NULL == list)
        {
          ret = TMR_ERROR_ILLEGAL_VALUE;
          break;
        }

        if (0 >= list->len)
        {
          ret = TMR_ERROR_ILLEGAL_VALUE;
          break;
        }

        ret = TMR_LLRP_cmdSetReadTransmitPowerList(reader, list);
        break;
      }

    case TMR_PARAM_RADIO_PORTWRITEPOWERLIST:
      {
        TMR_PortValueList *list = (TMR_PortValueList *)value;

        if (NULL == list)
        {
          ret = TMR_ERROR_ILLEGAL_VALUE;
          break;
        }

        if (0 >= list->len)
        {
          ret = TMR_ERROR_ILLEGAL_VALUE;
          break;
        }

        ret = TMR_LLRP_cmdSetWriteTransmitPowerList(reader, list);
        break;
      }

    case TMR_PARAM_READ_PLAN:
      {
        const TMR_ReadPlan *plan;
        TMR_ReadPlan tmpPlan;

        plan = value;
        tmpPlan = *plan;

        ret = validateReadPlan(reader, &tmpPlan, 
                        lr->txRxMap, lr->supportedProtocols);
        if (TMR_SUCCESS != ret)
        {
          return ret;
        }

        *reader->readParams.readPlan = tmpPlan;
        break;
      }

    case TMR_PARAM_COMMANDTIMEOUT:
      {
        uint32_t val = *(uint32_t *)value;
        if ((1<<31) & val)
        {
          ret = TMR_ERROR_ILLEGAL_VALUE;
        }
        else
        {
          lr->commandTimeout = *(uint32_t *)value;
        }
        break;
      }

    case TMR_PARAM_TRANSPORTTIMEOUT:
      {
        uint32_t val = *(uint32_t *)value;
        if ((1<<31) & val)
        {
          ret = TMR_ERROR_ILLEGAL_VALUE;
        }
        else
        {
          lr->transportTimeout = *(uint32_t *)value;
        }
        break;
      }

    case TMR_PARAM_GEN2_ACCESSPASSWORD:
      {
        lr->gen2AccessPassword = *(TMR_GEN2_Password *)value;
        break;
      }

    case TMR_PARAM_TAGREADDATA_RECORDHIGHESTRSSI:
    case TMR_PARAM_TAGREADDATA_UNIQUEBYANTENNA:
    case TMR_PARAM_TAGREADDATA_UNIQUEBYDATA:
      {
        TMR_LLRP_TMDeDuplication duplication;

        if (NULL == value)
        {
          return TMR_ERROR_ILLEGAL_VALUE;
        }

        /* Get ThingMagic DeDuplication before setting it */
        ret = TMR_LLRP_cmdGetThingMagicDeDuplication(reader, &duplication);

        if(TMR_SUCCESS != ret)
        {
          break;
        }

        /* Set the parameter asked by the user */
        switch(key)
        {
          case TMR_PARAM_TAGREADDATA_RECORDHIGHESTRSSI:
            {
              duplication.highestRSSI = *(bool*)value;
              break;
            }

          case TMR_PARAM_TAGREADDATA_UNIQUEBYANTENNA:
            {
              duplication.uniquebyAntenna = *(bool*)value;
              break;
            }

          case TMR_PARAM_TAGREADDATA_UNIQUEBYDATA:
            {
              duplication.uniquebyData = *(bool*)value;
              break;
            }

          default:
            ret = TMR_ERROR_NOT_FOUND;
        }
        /* Set ThingMagic DeDuplication */
        ret = TMR_LLRP_cmdSetThingMagicDeDuplication(reader, &duplication);

        break;
      }
    case TMR_PARAM_READER_DESCRIPTION:
      {
        TMR_String *desc = (TMR_String *)value;
        TMR_LLRP_TMReaderConfiguration config;

        if (NULL == value)
        {
          ret = TMR_ERROR_INVALID;
          break;
        }

        if (NULL == desc->value)
        {
          ret = TMR_ERROR_INVALID;
          break;
        }

        /* Get Reader Configuration before setting it */
        ret = TMR_LLRP_cmdGetThingmagicReaderConfiguration(reader, &config);
        if (TMR_SUCCESS != ret)
        {
          break;
        }

        /* Set the description asked by user */
        LLRP_utf8v_clear(&config.description);
        config.description = LLRP_utf8v_construct(strlen(desc->value));
        strcpy((char *)config.description.pValue, desc->value);
        
        /* Set Reader Configuration */
        ret = TMR_LLRP_cmdSetThingmagicReaderConfiguration(reader, &config);

        TMR_LLRP_freeTMReaderConfiguration(&config);
        break;
      }

    case TMR_PARAM_READER_HOSTNAME:
      {
        TMR_String *hostname = (TMR_String *)value;
        TMR_LLRP_TMReaderConfiguration config;

        if (NULL == value)
        {
          ret = TMR_ERROR_INVALID;
          break;
        }

        if (NULL == hostname->value)
        {
          ret = TMR_ERROR_INVALID;
          break;
        }

        /* Get Reader Configuration before setting it */
        ret = TMR_LLRP_cmdGetThingmagicReaderConfiguration(reader, &config);
        if (TMR_SUCCESS != ret)
        {
          break;
        }

        /* Set the host name asked by user */
        LLRP_utf8v_clear(&config.hostName);
        config.hostName = LLRP_utf8v_construct(strlen(hostname->value));
        strcpy((char *)config.hostName.pValue, hostname->value);

        /* Set Reader Configuration */
        ret = TMR_LLRP_cmdSetThingmagicReaderConfiguration(reader, &config);

        TMR_LLRP_freeTMReaderConfiguration(&config);
        break;
      }

    case TMR_PARAM_GEN2_BLF:
      {
        TMR_LLRP_RFControl rfControl;
        TMR_GEN2_LinkFrequency setBlf, activeBlf;
        TMR_GEN2_TagEncoding activeM;
        
        ret = TMR_LLRP_cmdGetActiveRFControl(reader, &rfControl);
        if (TMR_SUCCESS != ret)
        {
          break;
        }

        setBlf = *(TMR_GEN2_LinkFrequency *)value;
        activeBlf = lr->capabilities.u.gen2Modes[rfControl.index].blf;
        activeM = lr->capabilities.u.gen2Modes[rfControl.index].m;

        /* Set only if the active BLF value is not same */
        if (setBlf != activeBlf)
        {
          uint8_t i;

          /* RFMode table index starts from 1*/
          for (i = 1; i < TMR_LLRP_MAX_RFMODE_ENTRIES; i++)
          {
            TMR_LLRP_C1G2RFModeTable *entry = &lr->capabilities.u.gen2Modes[i];

            /* Find a suitable mode with the setM and active BLF */
            if ((setBlf == entry->blf) && (activeM == entry->m))
            {
              /* Set mode index */
              rfControl.index = i;

              /* Set this as active RFControl */
              ret = TMR_LLRP_cmdSetActiveRFControl(reader, &rfControl);
              return ret;
            }
          }

          return TMR_ERROR_LLRP_INVALID_RFMODE;
        }
 
        break;
      }

    case TMR_PARAM_GEN2_TAGENCODING:
      {
        TMR_LLRP_RFControl rfControl;
        TMR_GEN2_TagEncoding setM, activeM;
        TMR_GEN2_LinkFrequency activeBlf;

        ret = TMR_LLRP_cmdGetActiveRFControl(reader, &rfControl);
        if (TMR_SUCCESS != ret)
        {
          break;
        }

        setM = *(TMR_GEN2_TagEncoding *)value;
        activeBlf = lr->capabilities.u.gen2Modes[rfControl.index].blf;
        activeM = lr->capabilities.u.gen2Modes[rfControl.index].m;

        /* Set only if the active m value is not same */
        if (setM != activeM)
        {
          uint8_t i;

          /* RFMode table index starts from 1*/
          for (i = 1; i < TMR_LLRP_MAX_RFMODE_ENTRIES; i++)
          {
            TMR_LLRP_C1G2RFModeTable *entry = &lr->capabilities.u.gen2Modes[i];

            /* Find a suitable mode with the setM and active BLF */
            if ((setM == entry->m) && (activeBlf == entry->blf))
            {
              /* Set mode index */
              rfControl.index = i;

              /* Set this as active RFControl */
              ret = TMR_LLRP_cmdSetActiveRFControl(reader, &rfControl);
              return ret;
            }
          }

          return TMR_ERROR_LLRP_INVALID_RFMODE;
        }
        break;
      }

    case TMR_PARAM_GEN2_TARI:
      {
        TMR_LLRP_RFControl rfControl;
        TMR_GEN2_Tari tari = *(TMR_GEN2_Tari *)value;

        /* Get active RFControl */
        ret = TMR_LLRP_cmdGetActiveRFControl(reader, &rfControl);
        if (TMR_SUCCESS != ret)
        {
          break;
        }
        if((tari < lr->capabilities.u.gen2Modes[rfControl.index].minTari) || (tari > lr->capabilities.u.gen2Modes[rfControl.index].maxTari))
        {
          return TMR_ERROR_ILLEGAL_VALUE;  
        }

        /* Set only if the active tari value is not same */
        if (tari != rfControl.tari)
        {
          rfControl.tari = tari;
          ret = TMR_LLRP_cmdSetActiveRFControl(reader, &rfControl);
        }

        break;
      }

    case TMR_PARAM_GEN2_Q:
      {
        TMR_GEN2_Q *q = (TMR_GEN2_Q *)value;

        /* Error check for q value, in case of static type */
        if (TMR_SR_GEN2_Q_STATIC == q->type)
        {
          int qval = (int) q->u.staticQ.initialQ;
          if ((qval < 0) || (qval > 15))
          {
            return TMR_ERROR_ILLEGAL_VALUE;
          }
        }

        ret = TMR_LLRP_cmdSetGen2Q(reader, q);
        break;
      }

    case TMR_PARAM_GEN2_TARGET:
      {
        TMR_GEN2_Target target = *(TMR_GEN2_Target *)value;

        if (NULL == value)
        {
          ret = TMR_ERROR_INVALID;
          break;
        }
        ret = TMR_LLRP_cmdSetGen2Target(reader, &target);
        break;
      }

    case TMR_PARAM_GEN2_SESSION:
      {
        TMR_GEN2_Session session = *(TMR_GEN2_Session *)value;

        if (NULL == value)
        {
          ret = TMR_ERROR_INVALID;
          break;
        }
        ret = TMR_LLRP_cmdSetGen2Session(reader, &session);
        break;
      }
            
    case TMR_PARAM_RADIO_READPOWER:
    case TMR_PARAM_RADIO_WRITEPOWER:
      {
        TMR_PortValueList powerList;
        TMR_PortValue list[TMR_SR_MAX_ANTENNA_PORTS];
        int32_t power = *(int32_t *)value;
        uint8_t i;

        powerList.max = TMR_SR_MAX_ANTENNA_PORTS;
        powerList.list = list;
        powerList.len = 0;

        /* Set all antennas to same power */
        for (i = 0; i < lr->txRxMap->len; i ++)
        {
          powerList.list[i].port  = lr->txRxMap->list[i].antenna;
          powerList.list[i].value = power;
          powerList.len ++;
        }

        if (TMR_PARAM_RADIO_READPOWER == key)
        {
          /* Set read power */
          ret = TMR_LLRP_cmdSetReadTransmitPowerList(reader, &powerList);
        }
        else
        {
          /* Set write power */
          ret = TMR_LLRP_cmdSetWriteTransmitPowerList(reader, &powerList);
        }
     
        break;
      }
    case TMR_PARAM_ANTENNA_CHECKPORT:
      {
        if (NULL == value)
        {
          ret = TMR_ERROR_INVALID;
          break;
        }
        ret = TMR_LLRP_cmdSetThingMagicAntennaDetection(reader, (bool*)value);
        break;
      }

    case TMR_PARAM_LICENSE_KEY:
      {
        if (NULL == value)
        {
          ret = TMR_ERROR_INVALID;
          break;
        }
        ret = TMR_LLRP_cmdSetTMLicenseKey(reader, (TMR_uint8List *)value);
        break;
      }

    case TMR_PARAM_TAGOP_ANTENNA:
      {
        uint16_t i;
        TMR_AntennaMapList *map;
        uint8_t antenna, txPort, rxPort;

        map = lr->txRxMap;
        antenna = *(uint8_t *)value;

        txPort = rxPort = 0;
        for (i = 0; i < map->len && i < map->max; i++)
        {
          if (map->list[i].antenna == antenna)
          {
            txPort = map->list[i].txPort;
            rxPort = map->list[i].rxPort;
            reader->tagOpParams.antenna = antenna;
            break;
          }
        }
        if (txPort == 0)
        {
          ret = TMR_ERROR_NO_ANTENNA;
        }
        break;
      }

    case TMR_PARAM_TAGOP_PROTOCOL:
      {
        if (0 == ((1 << (*(TMR_TagProtocol *)value - 1)) &
                                lr->supportedProtocols))
        {
          /* If not present, return unsupported error */
          ret = TMR_ERROR_UNSUPPORTED;
        }
        else
        {
          reader->tagOpParams.protocol = *(TMR_TagProtocol *)value;
          reader->u.llrpReader.currentProtocol = reader->tagOpParams.protocol;
        }
        break;
      }

    case TMR_PARAM_READ_ASYNCOFFTIME:
      {
        uint32_t offtime = *(uint32_t *)value;
        ret = TMR_LLRP_cmdSetTMAsyncOffTime(reader, offtime);
        break;
      }

    case TMR_PARAM_LICENSED_FEATURES:
      {
        ret = TMR_ERROR_UNSUPPORTED;
        break;
      }
#ifdef TMR_ENABLE_ISO180006B
    case TMR_PARAM_ISO180006B_DELIMITER:
      {
        TMR_ISO180006B_Delimiter delimiter = *(TMR_ISO180006B_Delimiter *)value;

        if (NULL == value)
        {
          ret = TMR_ERROR_INVALID;
          break;
        }
        ret = TMR_LLRP_cmdSetISO18K6BDelimiter(reader, &delimiter);
        break;
      }

    case TMR_PARAM_ISO180006B_MODULATION_DEPTH:
      {
        TMR_ISO180006B_ModulationDepth modDepth = *(TMR_ISO180006B_ModulationDepth *)value;

        if (NULL == value)
        {
          ret = TMR_ERROR_INVALID;
          break;
        }
        ret = TMR_LLRP_cmdSetISO18K6BModDepth(reader, &modDepth);
        break;
      }

    case TMR_PARAM_ISO180006B_BLF:
      {
        TMR_ISO180006B_LinkFrequency linkFreq = *(TMR_ISO180006B_LinkFrequency *)value;

        if (NULL == value)
        {
          ret = TMR_ERROR_INVALID;
          break;
        }
        ret = TMR_LLRP_cmdSetISO18K6BLinkFrequency(reader, &linkFreq);
        break;
      }
#endif /* TMR_ENABLE_ISO180006B */

    default:
      ret = TMR_ERROR_NOT_FOUND;
  }

  return ret;
}


static TMR_Status
TMR_LLRP_paramGet(struct TMR_Reader *reader, TMR_Param key, void *value)
{
  TMR_Status ret;
  TMR_LLRP_LlrpReader *lr;

  ret = TMR_SUCCESS;
  lr = &reader->u.llrpReader;

  if (NULL == value)
  {
    return TMR_ERROR_ILLEGAL_VALUE;
  }

  if (BITGET(lr->paramConfirmed, key) && (0 == BITGET(lr->paramPresent, key)))
  {
    return TMR_ERROR_NOT_FOUND;
  }

  switch (key)
  {
    case TMR_PARAM_REGION_ID:
      {
        *(TMR_Region *)value = lr->regionId;
        break;
      }

    case TMR_PARAM_REGION_SUPPORTEDREGIONS:
      {
        TMR_RegionList *regions = (TMR_RegionList *)value;
        regions->len = 0;
        regions->list[regions->len++] = lr->regionId;
        break;
      }

    case TMR_PARAM_URI:
      {
        TMR_stringCopy((TMR_String *) value, reader->uri, (int)strlen(reader->uri));
        break;
      }

    case TMR_PARAM_ANTENNA_PORTLIST:
      {
        uint8_t i;
        TMR_uint8List *u8List;

        u8List = value;
        u8List->len = 0;

        for (i = 0; i < reader->u.llrpReader.txRxMap->len; i++)
        {
          LISTAPPEND(u8List, reader->u.llrpReader.txRxMap->list[i].antenna);
        }
        break;
      }

    case TMR_PARAM_ANTENNA_CONNECTEDPORTLIST:
      {
        TMR_LLRP_PortDetect ports[TMR_SR_MAX_ANTENNA_PORTS];
        uint8_t numPorts, i;
        TMR_uint8List *u8List;

        u8List = (TMR_uint8List *)value;
        u8List->len = 0;

        numPorts = numberof(ports);
        ret = TMR_LLRP_cmdAntennaDetect(reader, &numPorts, ports);
        if (TMR_SUCCESS != ret)
        {
          break;
        }

        if (u8List->max < numPorts)
        {
          numPorts = u8List->max;
        }

        for (i = 0; i < numPorts; i++)
        {
          if (ports[i].connected)
          {
            LISTAPPEND(u8List, ports[i].port);
          }
        }
        break;
      }

    case TMR_PARAM_GPIO_INPUTLIST:
      {
        if (TMR_LLRP_MODEL_M6 == lr->capabilities.model ||
                        TMR_LLRP_MODEL_ASTRA_EX == lr->capabilities.model ||
                        TMR_LLRP_MODEL_SARGAS == lr->capabilities.model)
        {
          TMR_uint8List *u8List;
          uint8_t i, numPins;

          u8List = (TMR_uint8List *)value;

          u8List->len = 0;
          if (TMR_LLRP_MODEL_SARGAS == lr->capabilities.model)
          {
                  numPins = sizeGpiListSargas;
          }
          else
          {
                  numPins = sizeGpiListM6Astra;
          }
          if (u8List->max < numPins)
          {
            numPins = u8List->max;
          }

          for(i = 0; i < numPins; i++)
          {
                  if (TMR_LLRP_MODEL_SARGAS == lr->capabilities.model)
                  {
                    LISTAPPEND(u8List, TMR_LLRP_gpiListSargas[i]);
                  }
                  else
                  {
                    LISTAPPEND(u8List, TMR_LLRP_gpiListM6Astra[i]);
                  }
          }
        }
        break;

      }
    case TMR_PARAM_GPIO_OUTPUTLIST:
      {
        if (TMR_LLRP_MODEL_M6 == lr->capabilities.model ||
                        TMR_LLRP_MODEL_ASTRA_EX == lr->capabilities.model ||
                        TMR_LLRP_MODEL_SARGAS == lr->capabilities.model)
        {
          TMR_uint8List *u8List;
          uint8_t i, numPins;

          u8List = (TMR_uint8List *)value;

          u8List->len = 0;
          if (TMR_LLRP_MODEL_SARGAS == lr->capabilities.model)
          {
                  numPins = sizeGpoListSargas;
          }
          else
          {
                  numPins = sizeGpoListM6Astra;
          }
          if (u8List->max < numPins)
          {
            numPins = u8List->max;
          }
          for(i = 0; i < numPins; i++)
          {
                  if (TMR_LLRP_MODEL_SARGAS == lr->capabilities.model)
                  {
                    LISTAPPEND(u8List, TMR_LLRP_gpoListSargas[i]);
                  }
                  else
                  {
                    LISTAPPEND(u8List, TMR_LLRP_gpoListM6Astra[i]);
                  }
          }
        }
        break;
      }
    case TMR_PARAM_RADIO_POWERMAX:
      {
        TMR_uint16List *table;
        int16_t i, max;

        table = &lr->capabilities.powerTable;

        if (0 == table->len)
        {
          ret = TMR_ERROR_INVALID;
          break;
        }

        max = table->list[1];
        for(i = 1; i <= table->len; i ++)
        {
          if(table->list[i] > max)
          {
            max = table->list[i];
          }
        }

        *(int16_t*)value = max;
        break;
      }

    case TMR_PARAM_RADIO_POWERMIN:
      {
        TMR_uint16List *table;
        int16_t i, min;

        table = &lr->capabilities.powerTable;

        if (0 == table->len)
        {
          ret = TMR_ERROR_INVALID;
          break;
        }

        min = table->list[1];
        for(i = 1; i <= table->len; i ++)
        {
          if(table->list[i] < min)
          {
            min = table->list[i];
          }
        }

        *(int16_t*)value = min;
        break;
      }

    case TMR_PARAM_RADIO_PORTREADPOWERLIST:
      {
        TMR_PortValueList *list = (TMR_PortValueList *)value;

        if (NULL == list)
        {
          ret = TMR_ERROR_ILLEGAL_VALUE;
          break;
        }

        if (0 >= list->max)
        {
          ret = TMR_ERROR_ILLEGAL_VALUE;
          break;
        }

        ret = TMR_LLRP_cmdGetReadTransmitPowerList(reader, (TMR_PortValueList *)list);
        break;
      }

    case TMR_PARAM_RADIO_PORTWRITEPOWERLIST:
      {
        TMR_PortValueList *list = (TMR_PortValueList *)value;

        if (NULL == list)
        {
          ret = TMR_ERROR_ILLEGAL_VALUE;
          break;
        }

        if (0 >= list->max)
        {
          ret = TMR_ERROR_ILLEGAL_VALUE;
          break;
        }

        ret = TMR_LLRP_cmdGetWriteTransmitPowerList(reader, (TMR_PortValueList *)list);
        break;
      }

    case TMR_PARAM_VERSION_MODEL:
      {
        const char *model;

        switch (lr->capabilities.model)
        {
          case TMR_LLRP_MODEL_M6:
            model = "Mercury6";
            break;
          case TMR_LLRP_MODEL_ASTRA_EX:
            model = "Astra-EX" ;
            break;

          case TMR_LLRP_MODEL_SARGAS:
            model = "Sargas" ;
            break;

          default:
            model = "Unknown";
        }

        TMR_stringCopy(value, model, (int)strlen(model));
        break;
      }
    case TMR_PARAM_VERSION_SERIAL:
      {
        //TMR_String *val = (TMR_String *) value;
        //ret = TMR_LLRP_cmdGetVersionSerial (reader, (TMR_String *)val);
        //break;
        TMR_String *val = (TMR_String *)value;
        ret = TMR_LLRP_cmdGetTMDeviceInformationCapabilities (reader, TMR_PARAM_VERSION_SERIAL, (TMR_String *)val);
        break;

      }

    case TMR_PARAM_VERSION_SOFTWARE:
      {
        char *software = lr->capabilities.softwareVersion;
        TMR_stringCopy(value, software, (int)strlen(software));
        break;
      }
      
    case TMR_PARAM_VERSION_HARDWARE:
      {
        TMR_String *val = (TMR_String *)value;
        ret = TMR_LLRP_cmdGetTMDeviceInformationCapabilities (reader, TMR_PARAM_VERSION_HARDWARE, (TMR_String *)val);

        break;
      }

    case TMR_PARAM_COMMANDTIMEOUT:
      {
        *(uint32_t *)value = lr->commandTimeout;
        break;
      }

    case TMR_PARAM_TRANSPORTTIMEOUT:
      {
        *(uint32_t *)value = lr->transportTimeout;
        break;
      }

    case TMR_PARAM_GEN2_ACCESSPASSWORD:
      {
        *(TMR_GEN2_Password *)value = lr->gen2AccessPassword;
        break;
      }

    case TMR_PARAM_TAGREADDATA_RECORDHIGHESTRSSI:
    case TMR_PARAM_TAGREADDATA_UNIQUEBYANTENNA:
    case TMR_PARAM_TAGREADDATA_UNIQUEBYDATA:
      {
        TMR_LLRP_TMDeDuplication duplication;
        ret = TMR_LLRP_cmdGetThingMagicDeDuplication(reader, &duplication);
        if (TMR_SUCCESS != ret)
        {
          break;
        }

        switch(key)
        {
          case TMR_PARAM_TAGREADDATA_RECORDHIGHESTRSSI:
            {
              *(bool*)value = (bool)duplication.highestRSSI;
              break;
            }
          case TMR_PARAM_TAGREADDATA_UNIQUEBYANTENNA:
            {
              *(bool*)value = (bool)duplication.uniquebyAntenna;
              break;
            }
          case TMR_PARAM_TAGREADDATA_UNIQUEBYDATA:
            {
              *(bool*)value = (bool)duplication.uniquebyData;
              break;
            }
          default:
            ret = TMR_ERROR_NOT_FOUND;
        }

        break;
      }

    case TMR_PARAM_READER_DESCRIPTION:
      {
        TMR_String *desc = (TMR_String *)value;
        TMR_LLRP_TMReaderConfiguration config;

        if (NULL != desc->value)
        {
          ret = TMR_LLRP_cmdGetThingmagicReaderConfiguration(reader, &config);
          if (TMR_SUCCESS == ret)
          {
            TMR_stringCopy(desc, (char *)config.description.pValue, config.description.nValue);
            TMR_LLRP_freeTMReaderConfiguration(&config);
          }
        }
        else
        {
          ret = TMR_ERROR_ILLEGAL_VALUE;
        }

        break;
      }

    case TMR_PARAM_READER_HOSTNAME:
      {
        TMR_String *hostname = (TMR_String *)value;
        TMR_LLRP_TMReaderConfiguration config;
        hostname->max = 25;

        if (NULL != hostname->value)
        {
          ret = TMR_LLRP_cmdGetThingmagicReaderConfiguration(reader, &config);
          if (TMR_SUCCESS == ret)
          {
            TMR_stringCopy(hostname, (char *)config.hostName.pValue, config.hostName.nValue);
            TMR_LLRP_freeTMReaderConfiguration(&config);
          }
        }
        else
        {
          ret = TMR_ERROR_ILLEGAL_VALUE;
        }

        break;
      }

    case TMR_PARAM_CURRENTTIME:
      {
        ret = TMR_LLRP_cmdGetThingMagicCurrentTime(reader, (struct tm *)value);
        break;
      }

    case TMR_PARAM_RADIO_TEMPERATURE:
    {
      ret = TMR_LLRP_cmdGetThingMagicReaderModuleTemperature(reader, (uint8_t *)value);
      break;
    }
    case TMR_PARAM_ANTENNA_CHECKPORT:
    {
      ret = TMR_LLRP_cmdGetThingMagicAntennaDetection(reader, (bool *)value);
      break;
    }

    case TMR_PARAM_VERSION_SUPPORTEDPROTOCOLS:
    {
      TMR_TagProtocolList *protocol = (TMR_TagProtocolList *)value;
      if (NULL == protocol->list)
      {
        ret = TMR_ERROR_ILLEGAL_VALUE;
        break;
      }

      ret = TMR_LLRP_cmdGetTMDeviceProtocolCapabilities(reader, (TMR_TagProtocolList *)protocol);
      break;
    }

    case TMR_PARAM_GEN2_BLF:
      {
        TMR_LLRP_RFControl rfControl;
        TMR_GEN2_LinkFrequency *blf = (TMR_GEN2_LinkFrequency *)value;

        ret = TMR_LLRP_cmdGetActiveRFControl(reader, &rfControl);
        if (TMR_SUCCESS != ret)
        {
          break;
        }

        *blf = lr->capabilities.u.gen2Modes[rfControl.index].blf;
        break;
      }

    case TMR_PARAM_GEN2_TAGENCODING:
      {
        TMR_LLRP_RFControl rfControl;
        TMR_GEN2_TagEncoding *m = (TMR_GEN2_TagEncoding *)value;

        ret = TMR_LLRP_cmdGetActiveRFControl(reader, &rfControl);
        if (TMR_SUCCESS != ret)
        {
          break;
        }

        *m = lr->capabilities.u.gen2Modes[rfControl.index].m;
        break;
      }

    case TMR_PARAM_GEN2_TARI:
      {
        TMR_LLRP_RFControl rfControl;
        TMR_GEN2_Tari *tari = (TMR_GEN2_Tari *)value;

        ret = TMR_LLRP_cmdGetActiveRFControl(reader, &rfControl);
        if (TMR_SUCCESS != ret)
        {
          break;
        }

        *tari = rfControl.tari;
        break;
      }

    case TMR_PARAM_GEN2_Q:
      {
        TMR_GEN2_Q *q = (TMR_GEN2_Q *)value;

        ret = TMR_LLRP_cmdGetGen2Q(reader, q);
        break;
      }

    case TMR_PARAM_GEN2_TARGET:
      {
        TMR_GEN2_Target *target = (TMR_GEN2_Target *)value;

        ret = TMR_LLRP_cmdGetGen2Target(reader, target);
        break;
      }

    case TMR_PARAM_LICENSE_KEY:
      {
        ret = TMR_ERROR_UNSUPPORTED;
        break;
      }
  
    case TMR_PARAM_GEN2_SESSION:
      {
        TMR_GEN2_Session *session = (TMR_GEN2_Session *)value;

        ret = TMR_LLRP_cmdGetGen2Session(reader, session);
        break;
      }

    case TMR_PARAM_RADIO_READPOWER:
    case TMR_PARAM_RADIO_WRITEPOWER:
      {
        TMR_PortValueList powerList;
        TMR_PortValue list[TMR_SR_MAX_ANTENNA_PORTS];
        uint8_t i;
        int32_t power;


        powerList.max  = TMR_SR_MAX_ANTENNA_PORTS;
        powerList.list = list;
        powerList.len  = 0;

        if (TMR_PARAM_RADIO_READPOWER == key)
        {
          /* Get per port read power list */
          ret = TMR_LLRP_cmdGetReadTransmitPowerList(reader, &powerList);
        }
        else
        {
          /* Get per port write power list */
          ret = TMR_LLRP_cmdGetWriteTransmitPowerList(reader, &powerList);
        }
        if (TMR_SUCCESS != ret)
        {
          break;
        }
       
        power = powerList.list[0].value;
        for (i = 1; i < powerList.len; i ++)
        {
          if (power != powerList.list[i].value)
          {
            return TMR_ERROR_LLRP_UNDEFINED_VALUE;
          }
        }

        *(int32_t *)value = (int32_t)power;
        
        break;
      }

    case TMR_PARAM_TAGOP_ANTENNA:
      {
        *(uint8_t *)value = reader->tagOpParams.antenna;
        break;
      }

    case TMR_PARAM_TAGOP_PROTOCOL:
      {
        *(TMR_TagProtocol *)value = reader->tagOpParams.protocol;
        break;
      }
    case TMR_PARAM_READ_ASYNCOFFTIME:
      {
        uint32_t offtime;
        ret = TMR_LLRP_cmdGetTMAsyncOffTime(reader, &offtime);
        if (TMR_SUCCESS != ret)
        {
          break;
        }
        *(uint32_t *)value = offtime;
        break;
      }

    case TMR_PARAM_LICENSED_FEATURES:
      {
        if(TMR_LLRP_MODEL_SARGAS == lr->capabilities.model)
        {
          TMR_uint8List *val = (TMR_uint8List *)value;
          ret = TMR_LLRP_cmdGetLicensedFeatures(reader, (TMR_uint8List *)val);
          if (TMR_SUCCESS != ret)
          {
            break;
          }
        }
        else
        {
          ret = TMR_ERROR_UNSUPPORTED;
        }
        break;
      }
#ifdef TMR_ENABLE_ISO180006B
    case TMR_PARAM_ISO180006B_DELIMITER:
      {
        TMR_ISO180006B_Delimiter *delimiter = (TMR_ISO180006B_Delimiter *)value;

        ret = TMR_LLRP_cmdGetISO18K6BDelimiter(reader, delimiter);
        break;
      }

    case TMR_PARAM_ISO180006B_MODULATION_DEPTH:
      {
        TMR_ISO180006B_ModulationDepth *modDepth = (TMR_ISO180006B_ModulationDepth *)value;

        ret = TMR_LLRP_cmdGetISO18K6BModDepth(reader, modDepth);
        break;
      }

    case TMR_PARAM_ISO180006B_BLF:
      {
        TMR_ISO180006B_LinkFrequency *linkFreq = (TMR_ISO180006B_LinkFrequency *)value;
        
        ret = TMR_LLRP_cmdGetISO18K6BLinkFrequency(reader, linkFreq);
        break;
      }
#endif /* TMR_ENABLE_ISO180006B */

    default:
      ret = TMR_ERROR_NOT_FOUND;
  }

  if (0 == BITGET(lr->paramConfirmed, key))
  {
    if (TMR_SUCCESS == ret)
    {
      BITSET(lr->paramPresent, key);
    }
    BITSET(lr->paramConfirmed, key);
  }

  return ret;
}

TMR_Status
TMR_LLRP_LlrpReader_init(TMR_Reader *reader)
{
  reader->readerType = TMR_READER_TYPE_LLRP;
  
  /*
   * Allocate the type registry. This is needed
   * by the connection to decode.
   */
  reader->u.llrpReader.pTypeRegistry = LLRP_getTheTypeRegistry();
  if(NULL == reader->u.llrpReader.pTypeRegistry)
  {
    return TMR_ERROR_LLRP_GETTYPEREGISTRY;
  }
  LLRP_enrollTmTypesIntoRegistry(reader->u.llrpReader.pTypeRegistry);


  reader->connect     = TMR_LLRP_connect;
  reader->destroy     = TMR_LLRP_destroy;
  reader->paramSet    = TMR_LLRP_paramSet;
  reader->paramGet    = TMR_LLRP_paramGet;
  reader->read        = TMR_LLRP_read;
  reader->hasMoreTags = TMR_LLRP_hasMoreTags;
  reader->getNextTag  = TMR_LLRP_getNextTag;
  reader->executeTagOp = TMR_LLRP_executeTagOp;
  reader->gpiGet = TMR_LLRP_gpiGet;
  reader->gpoSet = TMR_LLRP_gpoSet;
  reader->readTagMemBytes = TMR_LLRP_readTagMemBytes;
  reader->readTagMemWords = TMR_LLRP_readTagMemWords;
  reader->writeTagMemBytes = TMR_LLRP_writeTagMemBytes;
  reader->writeTagMemWords = TMR_LLRP_writeTagMemWords;
  reader->firmwareLoad = TMR_LLRP_firmwareLoad;
  reader->reboot = TMR_LLRP_reboot;
  reader->writeTag = TMR_LLRP_writeTag;
  reader->killTag = TMR_LLRP_killTag;
  reader->lockTag = TMR_LLRP_lockTag;
#ifdef TMR_ENABLE_BACKGROUND_READS
  reader->cmdStopReading = TMR_LLRP_cmdStopReading;
#endif
  
  reader->u.llrpReader.msgId = 1;
  reader->u.llrpReader.roSpecId = 0;
  reader->u.llrpReader.opSpecId = 0;
  reader->u.llrpReader.accessSpecId = 0;
  reader->u.llrpReader.gen2AccessPassword = 0;
  memset(reader->u.llrpReader.paramConfirmed,0,
         sizeof(reader->u.llrpReader.paramConfirmed));
  memset(reader->u.llrpReader.paramPresent,0,
         sizeof(reader->u.llrpReader.paramPresent));
  
  reader->u.llrpReader.transportTimeout = 5000;
  reader->u.llrpReader.commandTimeout = 1000;
  reader->u.llrpReader.currentProtocol = TMR_TAG_PROTOCOL_NONE;
  reader->u.llrpReader.supportedProtocols = 0;
  reader->u.llrpReader.regionId = TMR_REGION_NONE;
  reader->u.llrpReader.tagsRemaining = 0;
  reader->continuousReading = false;
  reader->u.llrpReader.capabilities.model = 0;

  /* Initialize tagOpParams */
  reader->tagOpParams.antenna = 1;
  reader->tagOpParams.protocol = TMR_TAG_PROTOCOL_GEN2;

  /* Initialize llrp receiver thread params */
  pthread_mutex_init(&reader->u.llrpReader.receiverLock, NULL);
  pthread_cond_init(&reader->u.llrpReader.receiverCond, NULL);
  reader->u.llrpReader.receiverSetup = false;
  reader->u.llrpReader.receiverRunning = false;
  reader->u.llrpReader.receiverEnabled = false;
  reader->u.llrpReader.numOfROSpecEvents = 0;
  reader->u.llrpReader.bufResponse = NULL;

  /* Initialize keep alive params */
  reader->u.llrpReader.ka_start = 0;
  reader->u.llrpReader.ka_now   = 0;
  reader->u.llrpReader.get_report = false;
  reader->u.llrpReader.reportReceived = false;
  reader->u.llrpReader.isResponsePending = false;
  reader->u.llrpReader.threadCancel = false;
  return TMR_reader_init_internal(reader);
}

static TMR_Status
TMR_LLRP_openConnectionToReader(TMR_Reader *reader, LLRP_tSConnection *pConn)
{
  int sock;
  static const struct addrinfo addrInfoMask =
  {    
    0,   
    AF_INET,
    SOCK_STREAM,
    0,                                                                                                                                                             
    0,   
    NULL,
    NULL,
    NULL 
  };   
  struct addrinfo *           hostAddress;
  int                         flag;
  struct sockaddr_in          sin; 
  int                         rc;

  if (NULL == pConn)
  {
    return TMR_ERROR_LLRP_CONNECTIONFAILED;
  }

  /*
   * Clear the connect error string
   */
  pConn->pConnectErrorStr = NULL;

  /*
   * Make sure there isn't already a connection.
   */
  if(0 <= pConn->fd)
  {
    pConn->pConnectErrorStr = "already connected";
    return TMR_ERROR_LLRP_ALREADY_CONNECTED;
  }

  /*
   * Look up host using getaddrinfo().
   * Gethostbyname() could be configured a lot of
   * different ways. There is /etc/hosts, DNS, NIS, etc, etc.
   * Suffice to say it is big, bulky, and susceptible to stall.
   */
  if(0 != getaddrinfo(reader->uri, NULL, &addrInfoMask, &hostAddress))
  {
    pConn->pConnectErrorStr = "host lookup failed";
    return -1;
  }

  /*
   * Convert the address to sockaddr_in format
   */
  memset(&sin, 0, sizeof sin);
  sin.sin_family = AF_INET;
  sin.sin_addr = ((struct sockaddr_in *)(hostAddress->ai_addr))->sin_addr;
  sin.sin_port = htons(reader->u.llrpReader.portNum);

  /*
   * Done withe the host addrinfo
   */
  freeaddrinfo(hostAddress);

  /*
   * Create the socket.
   */
  sock = socket(AF_INET, SOCK_STREAM, 0);
  if(0 > sock)
  {
    pConn->pConnectErrorStr = "socket() failed";
    return TMR_ERROR_LLRP_CONNECTIONFAILED;
  }

  /*
   * Connect the socket to reader. This can stall.
   */
  rc = connect(sock, (struct sockaddr *)&sin, sizeof sin);
  if(0 > rc)
  {
    /* Connect failed */
    /* check for the error no */
    if (ECONNREFUSED ==  errno)
    {
      tmr_sleep(1000);
    }
    pConn->pConnectErrorStr = "connect() failed";
    close(sock);
    return TMR_ERROR_LLRP_CONNECTIONFAILED;
  }

  /*
   * Best effort to set no delay. If this doesn't work
   * (no reason it shouldn't) we do not declare defeat.
   */
  flag = 1;
  setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (void*)&flag, sizeof flag);

  /*
   * Record the socket in the connection instance
   */
  pConn->fd = sock;

  return TMR_SUCCESS;
}

TMR_Status
TMR_LLRP_connect(TMR_Reader *reader)
{
  TMR_Status ret;
  LLRP_tSMessage *pMsg = NULL;
  LLRP_tSREADER_EVENT_NOTIFICATION *pNtf;
  LLRP_tSReaderEventNotificationData *pNtfData;
  LLRP_tSConnectionAttemptEvent *pEvent;
  LLRP_tSConnection *pConn;

  ret = TMR_SUCCESS;
  /*
   * Construct a connection (LLRP_tSConnection).
   * Using a 32kb max frame size for send/recv.
   * The connection object is ready for business
   * but not actually connected to the reader yet.
   */
  reader->u.llrpReader.pConn = LLRP_Conn_construct(reader->u.llrpReader.pTypeRegistry, 32u*1024u);
  if(NULL == reader->u.llrpReader.pConn)
  {
    sprintf(reader->u.llrpReader.errMsg, "Error: Connection initialization failed");
    return TMR_ERROR_LLRP_CONNECTIONFAILED;
  }

  /*
   * Open the connection to the reader
   */
  pConn = reader->u.llrpReader.pConn;
  ret = TMR_LLRP_openConnectionToReader(reader, pConn);
  if(TMR_SUCCESS != ret)
  {
    LLRP_Conn_destruct(pConn);
    reader->u.llrpReader.pConn = NULL;
    sprintf(reader->u.llrpReader.errMsg,
            "Error: Connect - %s", pConn->pConnectErrorStr);
    return TMR_ERROR_LLRP_CONNECTIONFAILED;
  }

  /* Receive READER_EVENT_NOTIFICATION.ConnectionAttemptEvent */
  ret = TMR_LLRP_receiveMessage(reader, &pMsg, reader->u.llrpReader.commandTimeout);
  if (TMR_SUCCESS != ret)
  {
    goto fail;
  }

  /*
   * Check to make sure the message is of the right type.
   * The type label (pointer) in the message should be
   * the type descriptor for READER_EVENT_NOTIFICATION.
   */
  if (&LLRP_tdREADER_EVENT_NOTIFICATION != pMsg->elementHdr.pType)
  {
    goto fail;
  }

  /*
   * Now that we are sure it is a READER_EVENT_NOTIFICATION,
   * traverse to the ReaderEventNotificationData parameter.
   */
  pNtf = (LLRP_tSREADER_EVENT_NOTIFICATION *) pMsg;
  pNtfData = pNtf->pReaderEventNotificationData;
  if(NULL == pNtfData)
  {
    goto fail;
  }

  /*
   * The ConnectionAttemptEvent parameter must be present.
   */
  pEvent = pNtfData->pConnectionAttemptEvent;
  if(NULL == pEvent)
  {
    goto fail;
  }

  /*
   * The status in the ConnectionAttemptEvent parameter
   * must indicate connection success.
   */
  if(LLRP_ConnectionAttemptStatusType_Success != pEvent->eStatus)
  {
    goto fail;
  }

  /*
   * At this point, We are sure that the connection is success
   * Free the message
   */
  TMR_LLRP_freeMessage(pMsg);
  reader->connected = true;
  ret = TMR_LLRP_boot(reader);
  
  return ret;

fail:
  /*
   * Connection attempt is not successful, Return Error
   */
  TMR_LLRP_freeMessage(pMsg);
  sprintf(reader->u.llrpReader.errMsg,
      "Error: Connection attempt failed");
  return TMR_ERROR_LLRP_CONNECTIONFAILED;
}

TMR_Status
TMR_LLRP_destroy(TMR_Reader *reader)
{
  LLRP_tSCLOSE_CONNECTION CloseConn = {
    .hdr.elementHdr.pType = &LLRP_tdCLOSE_CONNECTION,
    .hdr.MessageID        = reader->u.llrpReader.msgId ++,
  };

  LLRP_tSMessage *pRspMsg = NULL;
  uint8_t i;

  reader->u.llrpReader.threadCancel = true;

  pthread_join(reader->u.llrpReader.llrpReceiver, NULL);
  reader->u.llrpReader.threadCancel = false;

  pthread_mutex_lock(&reader->u.llrpReader.receiverLock);
  if (true == reader->u.llrpReader.receiverSetup)
  {
    usleep(10);
    reader->u.llrpReader.receiverSetup = false;
  }
  pthread_mutex_unlock(&reader->u.llrpReader.receiverLock);

#ifdef TMR_ENABLE_BACKGROUND_READS
  /* Cleanup background threads */
  cleanup_background_threads(reader);
#endif

  if (NULL != reader->u.llrpReader.bufResponse)
  {
    /* free this before leaking the memory */
    for (i = 0; i < reader->u.llrpReader.bufPointer; i++)
    {
      TMR_LLRP_freeMessage(reader->u.llrpReader.bufResponse[i]);
    }
    free(reader->u.llrpReader.bufResponse);
    reader->u.llrpReader.bufResponse=NULL;
  }

  if (true == reader->connected)
  {
    TMR_LLRP_send(reader, &CloseConn.hdr, &pRspMsg);
    if (NULL != pRspMsg)
    {
      TMR_LLRP_checkLLRPStatus(((LLRP_tSCLOSE_CONNECTION_RESPONSE *) pRspMsg)->pLLRPStatus);

      /* Free the response */
      TMR_LLRP_freeMessage(pRspMsg);
    }
    /*
     * Close the connection and release its resources
     */
  }
  if (NULL != reader->u.llrpReader.pConn)
  {
    LLRP_Conn_destruct(reader->u.llrpReader.pConn);
    reader->u.llrpReader.pConn=NULL;
  }
  if (NULL != reader->u.llrpReader.pTypeRegistry)
  {
    LLRP_TypeRegistry_destruct(reader->u.llrpReader.pTypeRegistry);
    reader->u.llrpReader.pTypeRegistry=NULL;
  }
  reader->connected = false;
  
  return TMR_SUCCESS;
}

static TMR_Status
TMR_LLRP_read_internal(TMR_Reader *reader,
                        uint32_t timeoutMs,
                        TMR_ReadPlan *rp)
{
  TMR_Status ret;
  TMR_LLRP_LlrpReader *lr;
  TMR_uint8List *antennaList = NULL;

  ret = TMR_SUCCESS;
  lr  = &reader->u.llrpReader;
  lr->searchTimeoutMs = timeoutMs;
  
  if (TMR_READ_PLAN_TYPE_SIMPLE == rp->type)
  {
    antennaList = &rp->u.simple.antennas;
    reader->fastSearch = rp->u.simple.useFastSearch;
  }
  else if (TMR_READ_PLAN_TYPE_MULTI == rp->type)
  {
    uint32_t subTimeout;
    int i;

    subTimeout = 0;

    reader->u.llrpReader.numOfROSpecEvents = rp->u.multi.planCount;
    if (0 == rp->u.multi.totalWeight)
    {
      subTimeout = timeoutMs / rp->u.multi.planCount;
    }

    for (i = 0; i < rp->u.multi.planCount; i ++)
    {
      if (rp->u.multi.totalWeight)
      {
        subTimeout = (rp->u.multi.plans[i]->weight * timeoutMs) 
                                  / rp->u.multi.totalWeight;
      }

      /* Iterate each simple read plan */
      ret = TMR_LLRP_read_internal(reader, subTimeout, rp->u.multi.plans[i]);
      if (TMR_SUCCESS != ret && TMR_ERROR_NO_TAGS_FOUND != ret)
      {
        return ret;
      }
    }
    return ret;
  }
  else
  {
    return TMR_ERROR_INVALID;
  }

  /* At this point we are guaranteed to have simple read plan */
  
  if (NULL == rp->u.simple.tagop)
  {
    lr->roSpecId++;
    if (TMR_LLRP_SYNC_MAX_ROSPECS <= lr->roSpecId)
    {
      lr->roSpecId = 1;
    }
    lr->readPlanProtocol[lr->roSpecId].rospecProtocol = rp->u.simple.protocol;
    lr->readPlanProtocol[lr->roSpecId].rospecID = lr->roSpecId;
    ret = TMR_LLRP_cmdPrepareROSpec(reader, (uint16_t)timeoutMs, antennaList, 
                                  rp->u.simple.filter, rp->u.simple.protocol);
  }

  else
  {
    lr->roSpecId ++;
    if (TMR_LLRP_SYNC_MAX_ROSPECS <= lr->roSpecId)
    {
      lr->roSpecId = 1;
    }
    lr->readPlanProtocol[lr->roSpecId].rospecProtocol = rp->u.simple.protocol;
    lr->readPlanProtocol[lr->roSpecId].rospecID = lr->roSpecId;
    ret = TMR_LLRP_cmdPrepareROSpec(reader, (uint16_t)timeoutMs, antennaList,
                                rp->u.simple.filter, rp->u.simple.protocol);
    if (TMR_SUCCESS != ret)
    {
      return ret;
  }

    lr->accessSpecId ++;
    ret = TMR_LLRP_cmdAddAccessSpec(reader, rp->u.simple.protocol,
                                  NULL, lr->roSpecId, rp->u.simple.tagop, false);
    if (TMR_SUCCESS != ret)
  {
      return ret;
  }

    ret = TMR_LLRP_cmdEnableAccessSpec(reader, lr->accessSpecId);
    if (TMR_SUCCESS != ret)
  {
      return ret;
  }
 }

  if ((true == reader->continuousReading) &&
      (TMR_READ_PLAN_TYPE_MULTI == reader->readParams.readPlan->type))
  {
  return ret;
  }
  else
  {
    return TMR_LLRP_cmdStartROSpec(reader, lr->roSpecId);
  }
}

TMR_Status
TMR_LLRP_read(TMR_Reader *reader, uint32_t timeoutMs, int32_t *tagCount)
{
  TMR_Status ret;
  TMR_ReadPlan *rp;
  uint8_t i;

  rp = reader->readParams.readPlan;
  ret = TMR_SUCCESS;

  if (tagCount)
  {
    *tagCount = 0;
  }

  if (NULL != reader->u.llrpReader.bufResponse)
  {
    /* free this before leaking the memory */
    for (i = 0; i < reader->u.llrpReader.bufPointer; i++)
    {
      TMR_LLRP_freeMessage(reader->u.llrpReader.bufResponse[i]);
    }
    free(reader->u.llrpReader.bufResponse);
    reader->u.llrpReader.bufResponse=NULL;
  }

  reader->u.llrpReader.tagsRemaining = 0;
  reader->u.llrpReader.bufPointer = 0;
  reader->u.llrpReader.bufIndex = 0;
 
  reader->u.llrpReader.bufResponse = (LLRP_tSMessage **) malloc( 1 * sizeof(LLRP_tSMessage *));
  reader->u.llrpReader.pTagReportData = NULL;
   
  ret = TMR_LLRP_enableEventsAndReports(reader);
  if (TMR_SUCCESS != ret)
  {
    return ret;
  }

  ret = TMR_LLRP_cmdDeleteAllROSpecs(reader, true);
  /*FIXME:
   * If there are no rospecs on reader, it will throw an exception
   * Do we really need to care about the error here?
  if (TMR_SUCCESS != ret)
  {
    return ret;
  }*/
  ret = TMR_LLRP_cmdDeleteAllAccessSpecs(reader);
  if (!reader->continuousReading)
  {
    /* Enable Reader Event Notifications */
    ret = TMR_LLRP_cmdSetEventNotificationSpec(reader, true);
    if (TMR_SUCCESS != ret)
    {
      return ret;
    }
  }

  reader->u.llrpReader.numOfROSpecEvents = 1;

  ret = TMR_LLRP_read_internal(reader, timeoutMs, rp);
  if (TMR_SUCCESS != ret)
  {
    return ret;
  }

  if (!reader->continuousReading)
  {
    ret = TMR_LLRP_verifyReadOperation(reader, tagCount);
    if (TMR_SUCCESS != ret)
    {
#ifdef TMR_ENABLE_BACKGROUND_READS      
      notify_exception_listeners(reader, ret);
#endif
      return ret;
    }

    /* Disable Reader Event Notifications */
    ret = TMR_LLRP_cmdSetEventNotificationSpec(reader, false);
    if (TMR_SUCCESS != ret)
    {
      return ret;
    }
  }

  return ret;
}

TMR_Status
TMR_LLRP_hasMoreTags(TMR_Reader *reader)
{
  TMR_LLRP_LlrpReader *lr;
  TMR_Status ret;

  lr = &reader->u.llrpReader;
  ret = TMR_SUCCESS;

#ifdef TMR_ENABLE_BACKGROUND_READS
  if (reader->continuousReading)
  {
    const LLRP_tSTypeDescriptor   *pType;
    int timeout;

    timeout = lr->searchTimeoutMs;

    if (true == reader->u.llrpReader.get_report)
    {
      ret = TMR_LLRP_cmdGetReport(reader);
      if (TMR_SUCCESS == ret)
      {
        reader->u.llrpReader.get_report = false;
      }
    }

    ret = TMR_LLRP_receiveMessage(reader, &lr->bufResponse[0], timeout);
    if (TMR_SUCCESS != ret)
    {
      TMR_LLRP_freeMessage(lr->bufResponse[0]);
      
      if (TMR_ERROR_LLRP_RECEIVEIO_ERROR == ret)
      {
        uint64_t diffTime;

        reader->u.llrpReader.ka_now = tmr_gettime();
        diffTime = reader->u.llrpReader.ka_now - reader->u.llrpReader.ka_start;
        if ((TMR_LLRP_KEEP_ALIVE_TIMEOUT * 4) < diffTime)
        {
          return TMR_ERROR_LLRP_READER_CONNECTION_LOST;
        }
      }
      return ret;
    }

    if (NULL != lr->bufResponse[0])
    {
      pType = lr->bufResponse[0]->elementHdr.pType;

      if (&LLRP_tdRO_ACCESS_REPORT == pType)
      {
        reader->isStatusResponse = false;
        reader->u.llrpReader.reportReceived = true;
        return TMR_SUCCESS;
      }
      else if(&LLRP_tdRFSurveyReportData == pType)
      {
        reader->isStatusResponse = true;
        /* TODO: yet to be implemented */
        return TMR_ERROR_UNIMPLEMENTED_FEATURE;
      }
      else if(&LLRP_tdREADER_EVENT_NOTIFICATION == pType)
      {
        TMR_LLRP_handleReaderEvents(reader, lr->bufResponse[0]);

        return TMR_ERROR_NO_TAGS;
      }
      else if (&LLRP_tdKEEPALIVE == pType)
      {
        reader->u.llrpReader.ka_start = tmr_gettime();

        /* handle keepalive messages. */
        TMR_LLRP_handleKeepAlive(reader, lr->bufResponse[0]);

        if (false == reader->u.llrpReader.reportReceived)
        {
          reader->u.llrpReader.get_report = true;
        }
        reader->u.llrpReader.reportReceived = false;

        return TMR_ERROR_NO_TAGS;
      }
      else if ((&LLRP_tdSTOP_ROSPEC_RESPONSE == pType) ||
               (&LLRP_tdDELETE_ROSPEC_RESPONSE == pType))
      {
        reader->finishedReading = true;
        TMR_LLRP_freeMessage(lr->bufResponse[0]);
        free(lr->bufResponse);
        lr->bufResponse = NULL;
        return TMR_ERROR_END_OF_READING;
      }
      else
      {
        reader->u.llrpReader.unhandledAsyncResponse.lMsg = reader->u.llrpReader.bufResponse[0];
        reader->u.llrpReader.isResponsePending = true;

        return TMR_ERROR_NO_TAGS;
      }
    }
  }
  else
#endif
  {
    ret = (lr->tagsRemaining > 0) ? TMR_SUCCESS : TMR_ERROR_NO_TAGS;

    if (TMR_SUCCESS == ret)
    {
      /* If TagReportData is not null, loop through the list */
      if (NULL != lr->pTagReportData)
      {
        lr->pTagReportData = (LLRP_tSTagReportData *)lr->pTagReportData->hdr.pNextSubParameter;
      }

      if (NULL == lr->pTagReportData)
      {
        LLRP_tSRO_ACCESS_REPORT *pReport;
    
        pReport = (LLRP_tSRO_ACCESS_REPORT *)lr->bufResponse[lr->bufIndex];
        lr->pTagReportData = pReport->listTagReportData;
          lr->bufIndex ++;
        }
    }
    else
    {
      uint8_t i;

      for (i = 0; i < lr->bufIndex; i ++)
      {
        TMR_LLRP_freeMessage(lr->bufResponse[i]);
      }
      
      free(lr->bufResponse);
      lr->bufResponse = NULL;
    }
  }
    return ret;
}

TMR_Status
TMR_LLRP_getNextTag(TMR_Reader *reader, TMR_TagReadData *data)
{
  TMR_LLRP_LlrpReader *lr;
  TMR_Status ret;
  LLRP_tSMessage *pMsg;

  lr = &reader->u.llrpReader;
  ret = TMR_SUCCESS;

  pMsg = lr->bufResponse[lr->bufIndex];

  if (0 == lr->tagsRemaining)
  {
    return TMR_ERROR_NO_TAGS;
  }

  if (reader->continuousReading)
  {
    ret = TMR_LLRP_hasMoreTags(reader);
    if (TMR_SUCCESS != ret)
    {
      return ret;
    }
  }
  
  TMR_TRD_init(data);

  /* Parse the response message */
  ret = TMR_LLRP_parseMetadataFromMessage(reader, data, lr->pTagReportData);
  if (TMR_SUCCESS != ret)
  {
    TMR_LLRP_freeMessage(pMsg);
    return ret;
  }

  if (reader->continuousReading)
  {
    TMR_LLRP_freeMessage(pMsg);
  }
  else
  {
    lr->tagsRemaining --;
  }

  data->reader = reader;
  return ret;
}

TMR_Status
TMR_LLRP_executeTagOp(TMR_Reader *reader, TMR_TagOp *tagop, 
                TMR_TagFilter *filter, TMR_uint8List *data)
{
  TMR_Status ret;
  TMR_LLRP_LlrpReader *lr;
  TMR_TagProtocol protocol;
  int timeout;
  uint64_t start, end, difftime;

  lr = &reader->u.llrpReader;
  ret = TMR_SUCCESS;
 
  reader->u.llrpReader.bufPointer = 0;
  if (NULL != reader->u.llrpReader.bufResponse)
  {
    /* free this before leaking the memory */
    free(reader->u.llrpReader.bufResponse);
    reader->u.llrpReader.bufResponse=NULL;
  }
  reader->u.llrpReader.bufResponse = (LLRP_tSMessage **) malloc(1 * sizeof(LLRP_tSMessage *));


  TMR_LLRP_cmdDeleteAllROSpecs(reader, true);
  TMR_LLRP_cmdDeleteAllAccessSpecs(reader);

  {
    uint8_t antenna[1];
    TMR_uint8List antennaList;

    antenna[0] = reader->tagOpParams.antenna;
    antennaList.len = 1;
    antennaList.max = 1;
    antennaList.list = antenna;

    if ((TMR_TAGOP_ISO180006B_READDATA == tagop->type) || (TMR_TAGOP_ISO180006B_WRITEDATA == tagop->type)
                                          ||(TMR_TAGOP_ISO180006B_LOCK == tagop->type))
    {
      protocol = TMR_TAG_PROTOCOL_ISO180006B;
    }
    else
    {
      protocol = reader->tagOpParams.protocol;
    }

    lr->roSpecId ++;
    /* timeout = 0, as it has no significance in this case */
    ret = TMR_LLRP_cmdPrepareROSpec(reader, 0, &antennaList, filter, protocol);
    if (TMR_SUCCESS != ret)
    {
      return ret;
    }
  }

  lr->accessSpecId ++;
  ret = TMR_LLRP_cmdAddAccessSpec(reader, protocol, NULL,
                                lr->roSpecId, tagop, true);
  if (TMR_SUCCESS != ret)
  {
    return ret;
  }

  ret = TMR_LLRP_cmdEnableAccessSpec(reader, lr->accessSpecId);
  if (TMR_SUCCESS != ret)
  {
    return ret;
  }

  ret = TMR_LLRP_cmdStartROSpec(reader, lr->roSpecId);
  if (TMR_SUCCESS != ret)
  {
    return ret;
  }

  timeout = lr->commandTimeout + lr->transportTimeout;
  start = tmr_gettime();
  while (true)
  {
    if (lr->bufPointer)
    {
      break;
    }
    end = tmr_gettime();
    difftime = end - start;
    if (difftime > timeout)
    {
      return TMR_ERROR_TIMEOUT;
    }
  }

  {
    LLRP_tSRO_ACCESS_REPORT *pReport;
    LLRP_tSTagReportData *pTagReportData;

    pReport = (LLRP_tSRO_ACCESS_REPORT *)lr->bufResponse[0];
    pTagReportData = pReport->listTagReportData;

    if (NULL != pTagReportData)
    {
      LLRP_tSParameter *pOpSpec;

      pOpSpec = pTagReportData->listAccessCommandOpSpecResult;
      /* Verify the OpSpecResult status */
      ret = TMR_LLRP_verifyOpSpecResultStatus(reader, pOpSpec);
      if (TMR_SUCCESS != ret)
      {
        return ret;
      }
      if (NULL != data)
      {
        TMR_LLRP_parseTagOpSpecData(pOpSpec, data);
      }
    }

    {
      uint8_t i;

      for (i = 0; i < lr->bufPointer; i ++)
      {
        TMR_LLRP_freeMessage(lr->bufResponse[i]);
      }
      free(lr->bufResponse);
      lr->bufResponse = NULL;
    }
  }
  return ret;
}

TMR_Status
TMR_LLRP_gpiGet(struct TMR_Reader *reader, uint8_t *count,
                         TMR_GpioPin state[])
{
  TMR_Status ret;
  ret = TMR_LLRP_cmdGetGPIState(reader, count, state);
  return ret;
}

TMR_Status
TMR_LLRP_gpoSet(struct TMR_Reader *reader, uint8_t count,
                      const TMR_GpioPin state[])
{
  TMR_Status ret;
  ret = TMR_LLRP_cmdSetGPOState(reader, count, state);
  return ret;
}

TMR_Status
TMR_LLRP_readTagMemBytes(struct TMR_Reader *reader, const TMR_TagFilter *filter,
                         uint32_t bank, uint32_t address,
                         uint16_t count,uint8_t data[])
{
  TMR_Status ret;
  /*
   * currently in fixed reader this feature is
   * not supported
   */
  ret = TMR_ERROR_UNSUPPORTED;
  return ret;
}

TMR_Status
TMR_LLRP_readTagMemWords(struct TMR_Reader *reader, const TMR_TagFilter *filter,
                         uint32_t bank, uint32_t address,
                         uint16_t count, uint16_t *data)
{
  TMR_Status ret;
  /*
   * currently in fixed reader this feature is
   * not supported
   */
  ret = TMR_ERROR_UNSUPPORTED;
  return ret;
}

TMR_Status
TMR_LLRP_writeTagMemBytes(struct TMR_Reader *reader, const TMR_TagFilter *filter,
                         uint32_t bank, uint32_t address,
                         uint16_t count,const uint8_t data[])
{
  TMR_Status ret;
  /*
   * currently in fixed reader this feature is
   * not supported
   */
  ret = TMR_ERROR_UNSUPPORTED;
  return ret;
}

TMR_Status
TMR_LLRP_writeTagMemWords(struct TMR_Reader *reader, const TMR_TagFilter *filter,
                         uint32_t bank, uint32_t address,
                         uint16_t count, const uint16_t *data)
{
  TMR_Status ret;
  /*
   * currently in fixed reader this feature is
   * not supported
   */
  ret = TMR_ERROR_UNSUPPORTED;
  return ret;
}

TMR_Status
TMR_LLRP_firmwareLoad( TMR_Reader *reader, void *cookie,
                      TMR_FirmwareDataProvider provider)
{
  TMR_Status ret;
  /*
   * currently in fixed reader this feature is
   * not supported
   */
  ret = TMR_ERROR_UNSUPPORTED;
  return ret;
}

TMR_Status
TMR_LLRP_reboot(TMR_Reader *reader)
{
  TMR_Status ret;

  ret = TMR_LLRP_cmdrebootReader(reader);

  return ret;
}

TMR_Status
TMR_LLRP_writeTag( TMR_Reader *reader, const TMR_TagFilter *filter,
                  const TMR_TagData *data)
{
  TMR_Status ret;
  TMR_TagOp tagop;
  ret = TMR_TagOp_init_GEN2_WriteTag(&tagop, (TMR_TagData *)data);
  ret = TMR_executeTagOp(reader, &tagop, (TMR_TagFilter *)filter, NULL);
  if (TMR_SUCCESS != ret)
  {
    return ret;
  }
  return ret;
}

TMR_Status
TMR_LLRP_killTag(struct TMR_Reader *reader, const TMR_TagFilter *filter,
                 const TMR_TagAuthentication *auth)
{
  TMR_Status ret;
  TMR_TagOp tagop;
  TMR_TagOp_init_GEN2_Kill(&tagop, auth->u.gen2Password);
  ret= TMR_executeTagOp(reader,&tagop, (TMR_TagFilter *)filter, NULL);
  if (TMR_SUCCESS != ret)
  {
    return ret;
  }
  return ret;

}

TMR_Status
TMR_LLRP_lockTag(struct TMR_Reader *reader,const TMR_TagFilter *filter,
                 TMR_TagLockAction *action)
{
  TMR_Status ret;
  TMR_TagOp tagop;
  TMR_TagOp_init_GEN2_Lock(&tagop, action->u.gen2LockAction.mask, action->u.gen2LockAction.action, 
      reader->u.llrpReader.gen2AccessPassword);
  ret= TMR_executeTagOp(reader,&tagop, (TMR_TagFilter *)filter, NULL);
  if (TMR_SUCCESS != ret)
  {
    return ret;
  }
  return ret;
}
#endif /* TMR_ENABLE_LLRP_TRANSPORT  */