path: root/snxxx/libese-spi/p73/pal/spi/EseSpiTransport.cpp

/******************************************************************************
 *
 *  Copyright 2018-2020, 2023 NXP
 *
 *  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.
 *
 ******************************************************************************/

/*
 * DAL spi port implementation for linux
 *
 * Project: Trusted ESE Linux
 *
 */

#include "EseSpiTransport.h"

#define LOG_TAG "NxpEseHal"
#include <errno.h>
#include <ese_config.h>
#include <ese_logs.h>
#include <fcntl.h>
#include <hardware/nfc.h>
#include <log/log.h>
#include <phEseStatus.h>
#include <phNxpEsePal.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <unistd.h>

#include "NfcAdaptation.h"
#include "hal_nxpese.h"
#include "phNxpEse_Api.h"

#define MAX_RETRY_CNT 10
#define HAL_NFC_SPI_DWP_SYNC 21
#define USE_COLD_RESET 0x00

extern int omapi_status;

static int rf_status;
#if (NFC_NXP_ESE_VER == JCOP_VER_5_x)
eseIoctlData_t eseioctldata;
#endif
// Default max retry count for SPI CLT write blocked in secs
static unsigned long int gsMaxSpiWriteRetryCnt = 10;
#if (NFC_NXP_ESE_VER == JCOP_VER_4_0)
static ESESTATUS phNxpEse_spiIoctl_legacy(uint64_t ioctlType, void* p_data);
#endif

/*******************************************************************************
**
** Function         phPalEse_spi_close
**
** Description      Closes PN547 device
**
** Parameters       pDevHandle - device handle
**
** Returns          None
**
*******************************************************************************/
void EseSpiTransport::Close(void* pDevHandle) {
  if (NULL != pDevHandle) {
    close((intptr_t)pDevHandle);
  }
  return;
}

#ifdef NXP_BOOTTIME_UPDATE
/*******************************************************************************
**
** Function         phNxpEse_spiIoctl
**
** Description      Perform cross HAL IOCTL functionality
**
** Parameters       ioctlType, input data
**
** Returns          SUCCESS/FAIL
**
*******************************************************************************/
ESESTATUS phNxpEse_spiIoctl(uint64_t ioctlType, void* p_data) {
  ESESTATUS status = ESESTATUS_SUCCESS;
  if (!p_data) {
    NXP_LOG_ESE_E("halimpl phNxpEse_spiIoctl p_data is null ioctltyp: %ld",
                  (long)ioctlType);
    return ESESTATUS_FAILED;
  }
#if (NFC_NXP_ESE_VER == JCOP_VER_5_x)
  ese_nxp_IoctlInOutData_t* inpOutData = (ese_nxp_IoctlInOutData_t*)p_data;
  switch (ioctlType) {
    case HAL_ESE_IOCTL_RF_STATUS_UPDATE:
      rf_status = inpOutData->inp.data.nxpCmd.p_cmd[0];
      if (rf_status == 1) {
        NXP_LOG_ESE_D(
            "******************RF IS ON*************************************");
      } else {
        NXP_LOG_ESE_D(
            "******************RF IS OFF*************************************");
      }
      break;
    default:
      NXP_LOG_ESE_D("Invalid IOCTL type");
      break;
  }
#endif
#if (NFC_NXP_ESE_VER == JCOP_VER_4_0)
  status = phNxpEse_spiIoctl_legacy(ioctlType, p_data);
#endif
  return status;
}
#endif

#if (NFC_NXP_ESE_VER == JCOP_VER_4_0)
/*******************************************************************************
**
** Function         phNxpEse_spiIoctl_legacy
**
** Description      Perform cross HAL IOCTL functionality
**
** Parameters       ioctlType, input data
**
** Returns          SUCCESS/FAIL
**
*******************************************************************************/
static ESESTATUS phNxpEse_spiIoctl_legacy(uint64_t ioctlType, void* p_data) {
  ese_nxp_IoctlInOutData_t* inpOutData = (ese_nxp_IoctlInOutData_t*)p_data;
  switch (ioctlType) {
    case HAL_ESE_IOCTL_RF_STATUS_UPDATE:

      rf_status = inpOutData->inp.data.nxpCmd.p_cmd[0];
      if (rf_status == 1) {
        NXP_LOG_ESE_D(
            "******************RF IS ON*************************************");
      } else {
        NXP_LOG_ESE_D(
            "******************RF IS OFF*************************************");
      }
      break;
    default:
      NXP_LOG_ESE_D("Invalid IOCTL type");
      break;
  }
  return ESESTATUS_SUCCESS;
}
#endif

/*******************************************************************************
**
** Function         OpenAndConfigure
**
** Description      Open and configure pn547 device
**
** Parameters       pConfig     - hardware information
**                  pLinkHandle - device handle
**
** Returns          ESE status:
**                  ESESTATUS_SUCCESS            - open_and_configure operation
*success
**                  ESESTATUS_INVALID_DEVICE     - device open operation failure
**
*******************************************************************************/
ESESTATUS EseSpiTransport::OpenAndConfigure(pphPalEse_Config_t pConfig) {
  int nHandle;
  int retryCnt = 0;
  ALOGD("NxpEse EseSpiTransport::OpenAndConfigure 1");
  if (EseConfig::hasKey(NAME_NXP_SOF_WRITE)) {
    mConfigSofWrite = EseConfig::getUnsigned(NAME_NXP_SOF_WRITE);
    NXP_LOG_ESE_D("NXP_SOF_WRITE value from config file = %ld",
                  mConfigSofWrite);
  }
  if (EseConfig::hasKey(NAME_NXP_SPI_WRITE_TIMEOUT)) {
    mConfigSpiWriteTimeout = EseConfig::getUnsigned(NAME_NXP_SPI_WRITE_TIMEOUT);
    NXP_LOG_ESE_D("NXP_SPI_WRITE_TIMEOUT value from config file = %ld",
                  mConfigSpiWriteTimeout);
  }
  /* Read eSE cold reset interface from ese config file */
  if (EseConfig::hasKey(NAME_NXP_P61_COLD_RESET_INTERFACE)) {
    mConfigColdResetIntf =
        EseConfig::getUnsigned(NAME_NXP_P61_COLD_RESET_INTERFACE);
    NXP_LOG_ESE_D("mConfigColdResetIntf value from config file = %ld",
                  mConfigColdResetIntf);
  } else {
    mConfigColdResetIntf = 0x01; /* Default interface is NFC HAL */
    NXP_LOG_ESE_D("mConfigColdResetIntf: Default value ");
  }
  /* Read eSE GPIO reset config */
  if (EseConfig::hasKey(NAME_NXP_ESE_GPIO_RESET)) {
    mConfigGpioReset = EseConfig::getUnsigned(NAME_NXP_ESE_GPIO_RESET);
    NXP_LOG_ESE_D("mConfigGpioReset value from config file = %ld",
                  mConfigGpioReset);
  } else {
    mConfigGpioReset = USE_COLD_RESET;
    NXP_LOG_ESE_D("mConfigGpioReset: Default value ");
  }
  NXP_LOG_ESE_D("Opening port=%s\n", pConfig->pDevName);
/* open port */
retry:
  nHandle = open((char const*)pConfig->pDevName, O_RDWR);
  if (nHandle < 0) {
    NXP_LOG_ESE_E("%s : failed errno = 0x%x, retval %x", __FUNCTION__, errno,
                  nHandle);

    if ((errno == -EBUSY) || (errno == EBUSY)) {
      if (GET_CHIP_OS_VERSION() != OS_VERSION_4_0) {
        phPalEse_sleep(100 * 1000);  // 100ms delay
        return ESESTATUS_DRIVER_BUSY;
      } else {
        retryCnt++;
        NXP_LOG_ESE_E("Retry open eSE driver, retry cnt : %d", retryCnt);
        if (retryCnt < MAX_RETRY_CNT) {
          phPalEse_sleep(1000000);
          goto retry;
        }
      }
    }
    NXP_LOG_ESE_E("_spi_open() Failed: retval %x", nHandle);
    pConfig->pDevHandle = NULL;
    return ESESTATUS_INVALID_DEVICE;
  }
  NXP_LOG_ESE_D("eSE driver opened :: fd = [%d]", nHandle);
  pConfig->pDevHandle = (void*)((intptr_t)nHandle);
  return ESESTATUS_SUCCESS;
}

/*******************************************************************************
**
** Function         Read
**
** Description      Reads requested number of bytes from pn547 device into given
*buffer
**
** Parameters       pDevHandle       - valid device handle
**                  pBuffer          - buffer for read data
**                  nNbBytesToRead   - number of bytes requested to be read
**
** Returns          numRead   - number of successfully read bytes
**                  -1        - read operation failure
**
*******************************************************************************/
int EseSpiTransport::Read(void* pDevHandle, uint8_t* pBuffer,
                          int nNbBytesToRead) {
  int ret = -1;
  ret = read((intptr_t)pDevHandle, (void*)pBuffer, (nNbBytesToRead));
  return ret;
}

/*******************************************************************************
**
** Function         Write
**
** Description      Writes requested number of bytes from given buffer into
*pn547 device
**
** Parameters       pDevHandle       - valid device handle
**                  pBuffer          - buffer for read data
**                  nNbBytesToWrite  - number of bytes requested to be written
**
** Returns          numWrote   - number of successfully written bytes
**                  -1         - write operation failure
**
*******************************************************************************/
int EseSpiTransport::Write(void* pDevHandle, uint8_t* pBuffer,
                           int nNbBytesToWrite) {
  int ret = -1;
  int numWrote = 0;
  unsigned long int retryCount = 0;
  if (NULL == pDevHandle) {
    NXP_LOG_ESE_E("phPalEse_spi_write: received pDevHandle=NULL");
    return -1;
  }
  if (GET_CHIP_OS_VERSION() == OS_VERSION_4_0) {
    if (mConfigSofWrite == 1) {
      /* Appending SOF for SPI write */
      pBuffer[0] = SEND_PACKET_SOF;
    } else {
      /* Do Nothing */
    }
  }
  NXP_LOG_ESE_D("NXP_SPI_WRITE_TIMEOUT value is... : %ld secs",
                mConfigSpiWriteTimeout);
  if (mConfigSpiWriteTimeout > 0) {
    gsMaxSpiWriteRetryCnt = mConfigSpiWriteTimeout;
  } else {
    /* Do Nothing */
  }

  while (numWrote < nNbBytesToWrite) {
    // usleep(5000);
    if (rf_status == 0) {
      ret = write((intptr_t)pDevHandle, pBuffer + numWrote,
                  nNbBytesToWrite - numWrote);
    } else {
      ret = -1;
    }
    if (ret > 0) {
      numWrote += ret;
    } else if (ret == 0) {
      NXP_LOG_ESE_E("_spi_write() EOF");
      return -1;
    } else {
      NXP_LOG_ESE_E("_spi_write() errno : %x", errno);
      NXP_LOG_ESE_D("rf_status value is %d", rf_status);
      if ((errno == EINTR || errno == EAGAIN || rf_status == 1) &&
          (retryCount < gsMaxSpiWriteRetryCnt)) {
        /*Configure retry count or timeout here,now its configured for 2*10
         * secs*/
        if (retryCount > gsMaxSpiWriteRetryCnt) {
          ret = -1;
          break;
        }

        retryCount++;
        /* 5ms delay to give ESE wake up delay */
        phPalEse_sleep(1000 * (GET_WAKE_UP_DELAY()));
        NXP_LOG_ESE_E("_spi_write() failed. Going to retry, counter:%ld !",
                      retryCount);
        continue;
      }
      return -1;
    }
  }
  return numWrote;
}

/*******************************************************************************
**
** Function         Ioctl
**
** Description      Exposed ioctl by p61 spi driver
**
** Parameters       pDevHandle     - valid device handle
**                  level          - reset level
**
** Returns           0   - ioctl operation success
**                  -1   - ioctl operation failure
**
*******************************************************************************/
ESESTATUS EseSpiTransport::Ioctl(phPalEse_ControlCode_t eControlCode,
                                 void* pDevHandle, long level) {
  ESESTATUS ret = ESESTATUS_IOCTL_FAILED;
  int retioctl = 0x00;
#if (NFC_NXP_ESE_VER == JCOP_VER_5_x)
  ese_nxp_IoctlInOutData_t inpOutData;
  inpOutData.inp.level = level;
  NfcAdaptation& pNfcAdapt = NfcAdaptation::GetInstance();
#endif
  NXP_LOG_ESE_D("phPalEse_spi_ioctl(), ioctl %x , level %lx", eControlCode,
                level);
  if (NULL == pDevHandle) {
    if (GET_CHIP_OS_VERSION() == OS_VERSION_4_0) {
      return ESESTATUS_IOCTL_FAILED;
    }
  }
  switch (eControlCode) {
    case phPalEse_e_ResetDevice:
      if (GET_CHIP_OS_VERSION() != OS_VERSION_4_0) {
        ret = ESESTATUS_SUCCESS;
      } else {
        ret = (ESESTATUS)ioctl((intptr_t)pDevHandle, P61_SET_PWR, level);
      }
      break;

    case phPalEse_e_EnableLog:
      if (GET_CHIP_OS_VERSION() != OS_VERSION_4_0) {
        ret = ESESTATUS_SUCCESS;
      } else {
        ret = (ESESTATUS)ioctl((intptr_t)pDevHandle, P61_SET_DBG, level);
      }
      break;

    case phPalEse_e_EnablePollMode:
      if (GET_CHIP_OS_VERSION() != OS_VERSION_4_0) {
        ret = ESESTATUS_SUCCESS;
      } else {
        ret = (ESESTATUS)ioctl((intptr_t)pDevHandle, P61_SET_POLL, level);
      }
      break;
    case phPalEse_e_SetSecureMode:
      ret =
          (ESESTATUS)ioctl((intptr_t)pDevHandle, ESE_SET_TRUSTED_ACCESS, level);
      if (0x00 <= ret) {
        ret = ESESTATUS_SUCCESS;
      }
      break;
    case phPalEse_e_ChipRst:
      if (GET_CHIP_OS_VERSION() != OS_VERSION_4_0) {
        if (level == 5) {              // SPI driver communication part
          if (!mConfigColdResetIntf) { // Call the driver IOCTL
            unsigned int cmd = ESE_PERFORM_COLD_RESET;
            if ((mConfigGpioReset == 0x01) &&
                ((GET_CHIP_OS_VERSION() == OS_VERSION_8_9))) {
              cmd = P61_SET_PWR;
            }
            retioctl = ioctl((intptr_t)pDevHandle, cmd, level);
            if (0x00 <= retioctl) {
              ret = ESESTATUS_SUCCESS;
            }
          } else {
            if ((NFC_NXP_ESE_VER == JCOP_VER_5_x) &&
                (GET_CHIP_OS_VERSION() != OS_VERSION_8_9)) {
              // Nfc Driver communication part
              pNfcAdapt.Initialize();
              ret = pNfcAdapt.resetEse(level);
            } else {
              NXP_LOG_ESE_E("%s: Not supported", __func__);
              ret = ESESTATUS_SUCCESS;
            }
          }
        } else {
          ret = ESESTATUS_SUCCESS;
        }
      } else {
        ret = (ESESTATUS)ioctl((intptr_t)pDevHandle, P61_SET_SPM_PWR, level);
      }
      break;
    case phPalEse_e_ResetProtection:
      if (GET_CHIP_OS_VERSION() != OS_VERSION_4_0) {
        retioctl = ioctl((intptr_t)pDevHandle, PERFORM_RESET_PROTECTION, level);
        if (0x00 <= retioctl) {
          ret = ESESTATUS_SUCCESS;
        } else {
          NXP_LOG_ESE_E("phPalEse_e_ResetProtection ioctl failed status :%x !",
                        retioctl);
        }
      }
      break;
    case phPalEse_e_EnableThroughputMeasurement:
      if (GET_CHIP_OS_VERSION() != OS_VERSION_4_0) {
        ret = ESESTATUS_SUCCESS;
      } else {
        ret = (ESESTATUS)ioctl((intptr_t)pDevHandle, P61_SET_THROUGHPUT, level);
      }
      break;

    case phPalEse_e_SetPowerScheme:
      if (GET_CHIP_OS_VERSION() != OS_VERSION_4_0) {
        ret = ESESTATUS_SUCCESS;
      } else {
        ret =
            (ESESTATUS)ioctl((intptr_t)pDevHandle, P61_SET_POWER_SCHEME, level);
      }
      break;

    case phPalEse_e_GetSPMStatus:
      if (GET_CHIP_OS_VERSION() != OS_VERSION_4_0) {
        ret = ESESTATUS_SUCCESS;
      } else {
        ret = (ESESTATUS)ioctl((intptr_t)pDevHandle, P61_GET_SPM_STATUS, level);
      }
      break;

    case phPalEse_e_GetEseAccess:
      if (GET_CHIP_OS_VERSION() != OS_VERSION_4_0) {
        ret = ESESTATUS_SUCCESS;
      } else {
        ret = (ESESTATUS)ioctl((intptr_t)pDevHandle, P61_GET_ESE_ACCESS, level);
      }
      break;
    case phPalEse_e_SetJcopDwnldState:
      if (GET_CHIP_OS_VERSION() != OS_VERSION_4_0) {
        ret = ESESTATUS_SUCCESS;
      } else {
        ret =
            (ESESTATUS)ioctl((intptr_t)pDevHandle, P61_SET_DWNLD_STATUS, level);
      }
      break;
    case phPalEse_e_DisablePwrCntrl:
      ret = ESESTATUS_SUCCESS;
      break;
    default:
      ret = ESESTATUS_IOCTL_FAILED;
      break;
  }
  NXP_LOG_ESE_D("Exit  phPalEse_spi_ioctl : ret = %d errno = %d", ret, errno);
  return (ESESTATUS)ret;
}