Quelle  se.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2014  STMicroelectronics SAS. All rights reserved.
 */

#include <net/nfc/hci.h>

#include "st21nfca.h"

#define ST21NFCA_EVT_UICC_ACTIVATE  0x10
#define ST21NFCA_EVT_UICC_DEACTIVATE  0x13
#define ST21NFCA_EVT_SE_HARD_RESET  0x20
#define ST21NFCA_EVT_SE_SOFT_RESET  0x11
#define ST21NFCA_EVT_SE_END_OF_APDU_TRANSFER 0x21
#define ST21NFCA_EVT_SE_ACTIVATE  0x22
#define ST21NFCA_EVT_SE_DEACTIVATE  0x23

#define ST21NFCA_EVT_TRANSMIT_DATA  0x10
#define ST21NFCA_EVT_WTX_REQUEST  0x11

#define ST21NFCA_EVT_CONNECTIVITY  0x10
#define ST21NFCA_EVT_TRANSACTION  0x12

#define ST21NFCA_SE_TO_HOT_PLUG   1000
/* Connectivity pipe only */
#define ST21NFCA_SE_COUNT_PIPE_UICC  0x01
/* Connectivity + APDU Reader pipe */
#define ST21NFCA_SE_COUNT_PIPE_EMBEDDED 0x02

#define ST21NFCA_SE_MODE_OFF   0x00
#define ST21NFCA_SE_MODE_ON    0x01

#define ST21NFCA_PARAM_ATR    0x01
#define ST21NFCA_ATR_DEFAULT_BWI  0x04

/*
 * WT = 2^BWI/10[s], convert into msecs and add a secure
 * room by increasing by 2 this timeout
 */
#define ST21NFCA_BWI_TO_TIMEOUT(x)  ((1 << x) * 200)
#define ST21NFCA_ATR_GET_Y_FROM_TD(x) (x >> 4)

/* If TA is present bit 0 is set */
#define ST21NFCA_ATR_TA_PRESENT(x) (x & 0x01)
/* If TB is present bit 1 is set */
#define ST21NFCA_ATR_TB_PRESENT(x) (x & 0x02)

static u8 st21nfca_se_get_bwi(struct nfc_hci_dev *hdev)
{
 int i;
 u8 td;
 struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev);

 /* Bits 8 to 5 of the first TB for T=1 encode BWI from zero to nine */
 for (i = 1; i < ST21NFCA_ESE_MAX_LENGTH; i++) {
  td = ST21NFCA_ATR_GET_Y_FROM_TD(info->se_info.atr[i]);
  if (ST21NFCA_ATR_TA_PRESENT(td))
   i++;
  if (ST21NFCA_ATR_TB_PRESENT(td)) {
   i++;
   return info->se_info.atr[i] >> 4;
  }
 }
 return ST21NFCA_ATR_DEFAULT_BWI;
}

static void st21nfca_se_get_atr(struct nfc_hci_dev *hdev)
{
 int r;
 struct sk_buff *skb;
 struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev);

 r = nfc_hci_get_param(hdev, ST21NFCA_APDU_READER_GATE,
   ST21NFCA_PARAM_ATR, &skb);
 if (r < 0)
  return;

 if (skb->len <= ST21NFCA_ESE_MAX_LENGTH) {
  memcpy(info->se_info.atr, skb->data, skb->len);
  info->se_info.wt_timeout =
   ST21NFCA_BWI_TO_TIMEOUT(st21nfca_se_get_bwi(hdev));
 }
 kfree_skb(skb);
}

static int st21nfca_hci_control_se(struct nfc_hci_dev *hdev, u32 se_idx,
    u8 state)
{
 struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev);
 int r, i;
 struct sk_buff *sk_host_list;
 u8 se_event, host_id;

 switch (se_idx) {
 case NFC_HCI_UICC_HOST_ID:
  se_event = (state == ST21NFCA_SE_MODE_ON ?
     ST21NFCA_EVT_UICC_ACTIVATE :
     ST21NFCA_EVT_UICC_DEACTIVATE);

  info->se_info.count_pipes = 0;
  info->se_info.expected_pipes = ST21NFCA_SE_COUNT_PIPE_UICC;
  break;
 case ST21NFCA_ESE_HOST_ID:
  se_event = (state == ST21NFCA_SE_MODE_ON ?
     ST21NFCA_EVT_SE_ACTIVATE :
     ST21NFCA_EVT_SE_DEACTIVATE);

  info->se_info.count_pipes = 0;
  info->se_info.expected_pipes = ST21NFCA_SE_COUNT_PIPE_EMBEDDED;
  break;
 default:
  return -EINVAL;
 }

 /*
 * Wait for an EVT_HOT_PLUG in order to
 * retrieve a relevant host list.
 */
 reinit_completion(&info->se_info.req_completion);
 r = nfc_hci_send_event(hdev, ST21NFCA_DEVICE_MGNT_GATE, se_event,
          NULL, 0);
 if (r < 0)
  return r;

 mod_timer(&info->se_info.se_active_timer, jiffies +
  msecs_to_jiffies(ST21NFCA_SE_TO_HOT_PLUG));
 info->se_info.se_active = true;

 /* Ignore return value and check in any case the host_list */
 wait_for_completion_interruptible(&info->se_info.req_completion);

 r = nfc_hci_get_param(hdev, NFC_HCI_ADMIN_GATE,
   NFC_HCI_ADMIN_HOST_LIST,
   &sk_host_list);
 if (r < 0)
  return r;

 for (i = 0; i < sk_host_list->len &&
  sk_host_list->data[i] != se_idx; i++)
  ;
 host_id = sk_host_list->data[i];
 kfree_skb(sk_host_list);

 if (state == ST21NFCA_SE_MODE_ON && host_id == se_idx)
  return se_idx;
 else if (state == ST21NFCA_SE_MODE_OFF && host_id != se_idx)
  return se_idx;

 return -1;
}

int st21nfca_hci_discover_se(struct nfc_hci_dev *hdev)
{
 struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev);
 int se_count = 0;

 if (test_bit(ST21NFCA_FACTORY_MODE, &hdev->quirks))
  return 0;

 if (info->se_status->is_uicc_present) {
  nfc_add_se(hdev->ndev, NFC_HCI_UICC_HOST_ID, NFC_SE_UICC);
  se_count++;
 }

 if (info->se_status->is_ese_present) {
  nfc_add_se(hdev->ndev, ST21NFCA_ESE_HOST_ID, NFC_SE_EMBEDDED);
  se_count++;
 }

 return !se_count;
}
EXPORT_SYMBOL(st21nfca_hci_discover_se);

int st21nfca_hci_enable_se(struct nfc_hci_dev *hdev, u32 se_idx)
{
 int r;

 /*
 * According to upper layer, se_idx == NFC_SE_UICC when
 * info->se_status->is_uicc_enable is true should never happen.
 * Same for eSE.
 */
 r = st21nfca_hci_control_se(hdev, se_idx, ST21NFCA_SE_MODE_ON);
 if (r == ST21NFCA_ESE_HOST_ID) {
  st21nfca_se_get_atr(hdev);
  r = nfc_hci_send_event(hdev, ST21NFCA_APDU_READER_GATE,
    ST21NFCA_EVT_SE_SOFT_RESET, NULL, 0);
  if (r < 0)
   return r;
 } else if (r < 0) {
  /*
 * The activation tentative failed, the secure element
 * is not connected. Remove from the list.
 */
  nfc_remove_se(hdev->ndev, se_idx);
  return r;
 }

 return 0;
}
EXPORT_SYMBOL(st21nfca_hci_enable_se);

int st21nfca_hci_disable_se(struct nfc_hci_dev *hdev, u32 se_idx)
{
 int r;

 /*
 * According to upper layer, se_idx == NFC_SE_UICC when
 * info->se_status->is_uicc_enable is true should never happen
 * Same for eSE.
 */
 r = st21nfca_hci_control_se(hdev, se_idx, ST21NFCA_SE_MODE_OFF);
 if (r < 0)
  return r;

 return 0;
}
EXPORT_SYMBOL(st21nfca_hci_disable_se);

int st21nfca_hci_se_io(struct nfc_hci_dev *hdev, u32 se_idx,
   u8 *apdu, size_t apdu_length,
   se_io_cb_t cb, void *cb_context)
{
 struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev);

 pr_debug("se_io %x\n", se_idx);

 switch (se_idx) {
 case ST21NFCA_ESE_HOST_ID:
  info->se_info.cb = cb;
  info->se_info.cb_context = cb_context;
  mod_timer(&info->se_info.bwi_timer, jiffies +
     msecs_to_jiffies(info->se_info.wt_timeout));
  info->se_info.bwi_active = true;
  return nfc_hci_send_event(hdev, ST21NFCA_APDU_READER_GATE,
     ST21NFCA_EVT_TRANSMIT_DATA,
     apdu, apdu_length);
 default:
  /* Need to free cb_context here as at the moment we can't
 * clearly indicate to the caller if the callback function
 * would be called (and free it) or not. In both cases a
 * negative value may be returned to the caller.
 */
  kfree(cb_context);
  return -ENODEV;
 }
}
EXPORT_SYMBOL(st21nfca_hci_se_io);

static void st21nfca_se_wt_work(struct work_struct *work)
{
 /*
 * No answer from the secure element
 * within the defined timeout.
 * Let's send a reset request as recovery procedure.
 * According to the situation, we first try to send a software reset
 * to the secure element. If the next command is still not
 * answering in time, we send to the CLF a secure element hardware
 * reset request.
 */
 /* hardware reset managed through VCC_UICC_OUT power supply */
 u8 param = 0x01;
 struct st21nfca_hci_info *info = container_of(work,
      struct st21nfca_hci_info,
      se_info.timeout_work);

 info->se_info.bwi_active = false;

 if (!info->se_info.xch_error) {
  info->se_info.xch_error = true;
  nfc_hci_send_event(info->hdev, ST21NFCA_APDU_READER_GATE,
    ST21NFCA_EVT_SE_SOFT_RESET, NULL, 0);
 } else {
  info->se_info.xch_error = false;
  nfc_hci_send_event(info->hdev, ST21NFCA_DEVICE_MGNT_GATE,
    ST21NFCA_EVT_SE_HARD_RESET, ¶m, 1);
 }
 info->se_info.cb(info->se_info.cb_context, NULL, 0, -ETIME);
}

static void st21nfca_se_wt_timeout(struct timer_list *t)
{
 struct st21nfca_hci_info *info = timer_container_of(info, t,
           se_info.bwi_timer);

 schedule_work(&info->se_info.timeout_work);
}

static void st21nfca_se_activation_timeout(struct timer_list *t)
{
 struct st21nfca_hci_info *info = timer_container_of(info, t,
           se_info.se_active_timer);

 info->se_info.se_active = false;

 complete(&info->se_info.req_completion);
}

/*
 * Returns:
 * <= 0: driver handled the event, skb consumed
 *    1: driver does not handle the event, please do standard processing
 */
int st21nfca_connectivity_event_received(struct nfc_hci_dev *hdev, u8 host,
    u8 event, struct sk_buff *skb)
{
 int r = 0;
 struct device *dev = &hdev->ndev->dev;
 struct nfc_evt_transaction *transaction;
 u32 aid_len;
 u8 params_len;

 pr_debug("connectivity gate event: %x\n", event);

 switch (event) {
 case ST21NFCA_EVT_CONNECTIVITY:
  r = nfc_se_connectivity(hdev->ndev, host);
 break;
 case ST21NFCA_EVT_TRANSACTION:
  /* According to specification etsi 102 622
 * 11.2.2.4 EVT_TRANSACTION Table 52
 * Description Tag Length
 * AID 81 5 to 16
 * PARAMETERS 82 0 to 255
 *
 * The key differences are aid storage length is variably sized
 * in the packet, but fixed in nfc_evt_transaction, and that the aid_len
 * is u8 in the packet, but u32 in the structure, and the tags in
 * the packet are not included in nfc_evt_transaction.
 *
 * size in bytes: 1          1       5-16 1             1           0-255
 * offset:        0          1       2    aid_len + 2   aid_len + 3 aid_len + 4
 * member name:   aid_tag(M) aid_len aid  params_tag(M) params_len  params
 * example:       0x81       5-16    X    0x82 0-255    X
 */
  if (skb->len < 2 || skb->data[0] != NFC_EVT_TRANSACTION_AID_TAG)
   return -EPROTO;

  aid_len = skb->data[1];

  if (skb->len < aid_len + 4 || aid_len > sizeof(transaction->aid))
   return -EPROTO;

  params_len = skb->data[aid_len + 3];

  /* Verify PARAMETERS tag is (82), and final check that there is enough
 * space in the packet to read everything.
 */
  if ((skb->data[aid_len + 2] != NFC_EVT_TRANSACTION_PARAMS_TAG) ||
      (skb->len < aid_len + 4 + params_len))
   return -EPROTO;

  transaction = devm_kzalloc(dev, sizeof(*transaction) + params_len, GFP_KERNEL);
  if (!transaction)
   return -ENOMEM;

  transaction->aid_len = aid_len;
  transaction->params_len = params_len;

  memcpy(transaction->aid, &skb->data[2], aid_len);
  memcpy(transaction->params, &skb->data[aid_len + 4], params_len);

  r = nfc_se_transaction(hdev->ndev, host, transaction);
 break;
 default:
  nfc_err(&hdev->ndev->dev, "Unexpected event on connectivity gate\n");
  return 1;
 }
 kfree_skb(skb);
 return r;
}
EXPORT_SYMBOL(st21nfca_connectivity_event_received);

int st21nfca_apdu_reader_event_received(struct nfc_hci_dev *hdev,
     u8 event, struct sk_buff *skb)
{
 int r = 0;
 struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev);

 pr_debug("apdu reader gate event: %x\n", event);

 switch (event) {
 case ST21NFCA_EVT_TRANSMIT_DATA:
  timer_delete_sync(&info->se_info.bwi_timer);
  cancel_work_sync(&info->se_info.timeout_work);
  info->se_info.bwi_active = false;
  r = nfc_hci_send_event(hdev, ST21NFCA_DEVICE_MGNT_GATE,
    ST21NFCA_EVT_SE_END_OF_APDU_TRANSFER, NULL, 0);
  if (r < 0)
   goto exit;

  info->se_info.cb(info->se_info.cb_context,
   skb->data, skb->len, 0);
  break;
 case ST21NFCA_EVT_WTX_REQUEST:
  mod_timer(&info->se_info.bwi_timer, jiffies +
    msecs_to_jiffies(info->se_info.wt_timeout));
  break;
 default:
  nfc_err(&hdev->ndev->dev, "Unexpected event on apdu reader gate\n");
  return 1;
 }

exit:
 kfree_skb(skb);
 return r;
}
EXPORT_SYMBOL(st21nfca_apdu_reader_event_received);

void st21nfca_se_init(struct nfc_hci_dev *hdev)
{
 struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev);

 init_completion(&info->se_info.req_completion);
 INIT_WORK(&info->se_info.timeout_work, st21nfca_se_wt_work);
 /* initialize timers */
 timer_setup(&info->se_info.bwi_timer, st21nfca_se_wt_timeout, 0);
 info->se_info.bwi_active = false;

 timer_setup(&info->se_info.se_active_timer,
      st21nfca_se_activation_timeout, 0);
 info->se_info.se_active = false;

 info->se_info.count_pipes = 0;
 info->se_info.expected_pipes = 0;

 info->se_info.xch_error = false;

 info->se_info.wt_timeout =
   ST21NFCA_BWI_TO_TIMEOUT(ST21NFCA_ATR_DEFAULT_BWI);
}
EXPORT_SYMBOL(st21nfca_se_init);

void st21nfca_se_deinit(struct nfc_hci_dev *hdev)
{
 struct st21nfca_hci_info *info = nfc_hci_get_clientdata(hdev);

 if (info->se_info.bwi_active)
  timer_delete_sync(&info->se_info.bwi_timer);
 if (info->se_info.se_active)
  timer_delete_sync(&info->se_info.se_active_timer);

 cancel_work_sync(&info->se_info.timeout_work);
 info->se_info.bwi_active = false;
 info->se_info.se_active = false;
}
EXPORT_SYMBOL(st21nfca_se_deinit);