drivers/nfc/st-nci/se.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
st_nci_se_get_bwi
st_nci_se_get_atr
st_nci_hci_load_session
st_nci_hci_admin_event_received
st_nci_hci_apdu_reader_event_received
st_nci_hci_connectivity_event_received
st_nci_hci_event_received
st_nci_hci_cmd_received
st_nci_control_se
st_nci_disable_se
st_nci_enable_se
st_nci_hci_network_init
st_nci_discover_se
st_nci_se_io
st_nci_se_wt_timeout
st_nci_se_activation_timeout
st_nci_se_init
st_nci_se_deinit
   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Secure Element driver for STMicroelectronics NFC NCI chip
   4  *
   5  * Copyright (C) 2014-2015 STMicroelectronics SAS. All rights reserved.
   6  */
   7 
   8 #include <linux/module.h>
   9 #include <linux/nfc.h>
  10 #include <linux/delay.h>
  11 #include <net/nfc/nci.h>
  12 #include <net/nfc/nci_core.h>
  13 
  14 #include "st-nci.h"
  15 
  16 struct st_nci_pipe_info {
  17         u8 pipe_state;
  18         u8 src_host_id;
  19         u8 src_gate_id;
  20         u8 dst_host_id;
  21         u8 dst_gate_id;
  22 } __packed;
  23 
  24 /* Hosts */
  25 #define ST_NCI_HOST_CONTROLLER_ID     0x00
  26 #define ST_NCI_TERMINAL_HOST_ID       0x01
  27 #define ST_NCI_UICC_HOST_ID           0x02
  28 #define ST_NCI_ESE_HOST_ID            0xc0
  29 
  30 /* Gates */
  31 #define ST_NCI_APDU_READER_GATE       0xf0
  32 #define ST_NCI_CONNECTIVITY_GATE      0x41
  33 
  34 /* Pipes */
  35 #define ST_NCI_DEVICE_MGNT_PIPE               0x02
  36 
  37 /* Connectivity pipe only */
  38 #define ST_NCI_SE_COUNT_PIPE_UICC             0x01
  39 /* Connectivity + APDU Reader pipe */
  40 #define ST_NCI_SE_COUNT_PIPE_EMBEDDED         0x02
  41 
  42 #define ST_NCI_SE_TO_HOT_PLUG                   1000 /* msecs */
  43 #define ST_NCI_SE_TO_PIPES                      2000
  44 
  45 #define ST_NCI_EVT_HOT_PLUG_IS_INHIBITED(x)   (x->data[0] & 0x80)
  46 
  47 #define NCI_HCI_APDU_PARAM_ATR                     0x01
  48 #define NCI_HCI_ADMIN_PARAM_SESSION_IDENTITY       0x01
  49 #define NCI_HCI_ADMIN_PARAM_WHITELIST              0x03
  50 #define NCI_HCI_ADMIN_PARAM_HOST_LIST              0x04
  51 
  52 #define ST_NCI_EVT_SE_HARD_RESET                0x20
  53 #define ST_NCI_EVT_TRANSMIT_DATA                0x10
  54 #define ST_NCI_EVT_WTX_REQUEST                  0x11
  55 #define ST_NCI_EVT_SE_SOFT_RESET                0x11
  56 #define ST_NCI_EVT_SE_END_OF_APDU_TRANSFER      0x21
  57 #define ST_NCI_EVT_HOT_PLUG                     0x03
  58 
  59 #define ST_NCI_SE_MODE_OFF                    0x00
  60 #define ST_NCI_SE_MODE_ON                     0x01
  61 
  62 #define ST_NCI_EVT_CONNECTIVITY       0x10
  63 #define ST_NCI_EVT_TRANSACTION        0x12
  64 
  65 #define ST_NCI_DM_GETINFO             0x13
  66 #define ST_NCI_DM_GETINFO_PIPE_LIST   0x02
  67 #define ST_NCI_DM_GETINFO_PIPE_INFO   0x01
  68 #define ST_NCI_DM_PIPE_CREATED        0x02
  69 #define ST_NCI_DM_PIPE_OPEN           0x04
  70 #define ST_NCI_DM_RF_ACTIVE           0x80
  71 #define ST_NCI_DM_DISCONNECT          0x30
  72 
  73 #define ST_NCI_DM_IS_PIPE_OPEN(p) \
  74         ((p & 0x0f) == (ST_NCI_DM_PIPE_CREATED | ST_NCI_DM_PIPE_OPEN))
  75 
  76 #define ST_NCI_ATR_DEFAULT_BWI        0x04
  77 
  78 /*
  79  * WT = 2^BWI/10[s], convert into msecs and add a secure
  80  * room by increasing by 2 this timeout
  81  */
  82 #define ST_NCI_BWI_TO_TIMEOUT(x)      ((1 << x) * 200)
  83 #define ST_NCI_ATR_GET_Y_FROM_TD(x)   (x >> 4)
  84 
  85 /* If TA is present bit 0 is set */
  86 #define ST_NCI_ATR_TA_PRESENT(x) (x & 0x01)
  87 /* If TB is present bit 1 is set */
  88 #define ST_NCI_ATR_TB_PRESENT(x) (x & 0x02)
  89 
  90 #define ST_NCI_NUM_DEVICES           256
  91 
  92 static DECLARE_BITMAP(dev_mask, ST_NCI_NUM_DEVICES);
  93 
  94 /* Here are the mandatory pipe for st_nci */
  95 static struct nci_hci_gate st_nci_gates[] = {
  96         {NCI_HCI_ADMIN_GATE, NCI_HCI_ADMIN_PIPE,
  97                                         ST_NCI_HOST_CONTROLLER_ID},
  98         {NCI_HCI_LINK_MGMT_GATE, NCI_HCI_LINK_MGMT_PIPE,
  99                                         ST_NCI_HOST_CONTROLLER_ID},
 100         {ST_NCI_DEVICE_MGNT_GATE, ST_NCI_DEVICE_MGNT_PIPE,
 101                                         ST_NCI_HOST_CONTROLLER_ID},
 102 
 103         {NCI_HCI_IDENTITY_MGMT_GATE, NCI_HCI_INVALID_PIPE,
 104                                         ST_NCI_HOST_CONTROLLER_ID},
 105 
 106         /* Secure element pipes are created by secure element host */
 107         {ST_NCI_CONNECTIVITY_GATE, NCI_HCI_DO_NOT_OPEN_PIPE,
 108                                         ST_NCI_HOST_CONTROLLER_ID},
 109         {ST_NCI_APDU_READER_GATE, NCI_HCI_DO_NOT_OPEN_PIPE,
 110                                         ST_NCI_HOST_CONTROLLER_ID},
 111 };
 112 
 113 static u8 st_nci_se_get_bwi(struct nci_dev *ndev)
 114 {
 115         int i;
 116         u8 td;
 117         struct st_nci_info *info = nci_get_drvdata(ndev);
 118 
 119         /* Bits 8 to 5 of the first TB for T=1 encode BWI from zero to nine */
 120         for (i = 1; i < ST_NCI_ESE_MAX_LENGTH; i++) {
 121                 td = ST_NCI_ATR_GET_Y_FROM_TD(info->se_info.atr[i]);
 122                 if (ST_NCI_ATR_TA_PRESENT(td))
 123                         i++;
 124                 if (ST_NCI_ATR_TB_PRESENT(td)) {
 125                         i++;
 126                         return info->se_info.atr[i] >> 4;
 127                 }
 128         }
 129         return ST_NCI_ATR_DEFAULT_BWI;
 130 }
 131 
 132 static void st_nci_se_get_atr(struct nci_dev *ndev)
 133 {
 134         struct st_nci_info *info = nci_get_drvdata(ndev);
 135         int r;
 136         struct sk_buff *skb;
 137 
 138         r = nci_hci_get_param(ndev, ST_NCI_APDU_READER_GATE,
 139                                 NCI_HCI_APDU_PARAM_ATR, &skb);
 140         if (r < 0)
 141                 return;
 142 
 143         if (skb->len <= ST_NCI_ESE_MAX_LENGTH) {
 144                 memcpy(info->se_info.atr, skb->data, skb->len);
 145 
 146                 info->se_info.wt_timeout =
 147                         ST_NCI_BWI_TO_TIMEOUT(st_nci_se_get_bwi(ndev));
 148         }
 149         kfree_skb(skb);
 150 }
 151 
 152 int st_nci_hci_load_session(struct nci_dev *ndev)
 153 {
 154         int i, j, r;
 155         struct sk_buff *skb_pipe_list, *skb_pipe_info;
 156         struct st_nci_pipe_info *dm_pipe_info;
 157         u8 pipe_list[] = { ST_NCI_DM_GETINFO_PIPE_LIST,
 158                         ST_NCI_TERMINAL_HOST_ID};
 159         u8 pipe_info[] = { ST_NCI_DM_GETINFO_PIPE_INFO,
 160                         ST_NCI_TERMINAL_HOST_ID, 0};
 161 
 162         /* On ST_NCI device pipes number are dynamics
 163          * If pipes are already created, hci_dev_up will fail.
 164          * Doing a clear all pipe is a bad idea because:
 165          * - It does useless EEPROM cycling
 166          * - It might cause issue for secure elements support
 167          * (such as removing connectivity or APDU reader pipe)
 168          * A better approach on ST_NCI is to:
 169          * - get a pipe list for each host.
 170          * (eg: ST_NCI_HOST_CONTROLLER_ID for now).
 171          * (TODO Later on UICC HOST and eSE HOST)
 172          * - get pipe information
 173          * - match retrieved pipe list in st_nci_gates
 174          * ST_NCI_DEVICE_MGNT_GATE is a proprietary gate
 175          * with ST_NCI_DEVICE_MGNT_PIPE.
 176          * Pipe can be closed and need to be open.
 177          */
 178         r = nci_hci_connect_gate(ndev, ST_NCI_HOST_CONTROLLER_ID,
 179                                 ST_NCI_DEVICE_MGNT_GATE,
 180                                 ST_NCI_DEVICE_MGNT_PIPE);
 181         if (r < 0)
 182                 return r;
 183 
 184         /* Get pipe list */
 185         r = nci_hci_send_cmd(ndev, ST_NCI_DEVICE_MGNT_GATE,
 186                         ST_NCI_DM_GETINFO, pipe_list, sizeof(pipe_list),
 187                         &skb_pipe_list);
 188         if (r < 0)
 189                 return r;
 190 
 191         /* Complete the existing gate_pipe table */
 192         for (i = 0; i < skb_pipe_list->len; i++) {
 193                 pipe_info[2] = skb_pipe_list->data[i];
 194                 r = nci_hci_send_cmd(ndev, ST_NCI_DEVICE_MGNT_GATE,
 195                                         ST_NCI_DM_GETINFO, pipe_info,
 196                                         sizeof(pipe_info), &skb_pipe_info);
 197 
 198                 if (r)
 199                         continue;
 200 
 201                 /*
 202                  * Match pipe ID and gate ID
 203                  * Output format from ST21NFC_DM_GETINFO is:
 204                  * - pipe state (1byte)
 205                  * - source hid (1byte)
 206                  * - source gid (1byte)
 207                  * - destination hid (1byte)
 208                  * - destination gid (1byte)
 209                  */
 210                 dm_pipe_info = (struct st_nci_pipe_info *)skb_pipe_info->data;
 211                 if (dm_pipe_info->dst_gate_id == ST_NCI_APDU_READER_GATE &&
 212                     dm_pipe_info->src_host_id == ST_NCI_UICC_HOST_ID) {
 213                         pr_err("Unexpected apdu_reader pipe on host %x\n",
 214                                dm_pipe_info->src_host_id);
 215                         kfree_skb(skb_pipe_info);
 216                         continue;
 217                 }
 218 
 219                 for (j = 3; (j < ARRAY_SIZE(st_nci_gates)) &&
 220                      (st_nci_gates[j].gate != dm_pipe_info->dst_gate_id); j++)
 221                         ;
 222 
 223                 if (j < ARRAY_SIZE(st_nci_gates) &&
 224                     st_nci_gates[j].gate == dm_pipe_info->dst_gate_id &&
 225                     ST_NCI_DM_IS_PIPE_OPEN(dm_pipe_info->pipe_state)) {
 226                         ndev->hci_dev->init_data.gates[j].pipe = pipe_info[2];
 227 
 228                         ndev->hci_dev->gate2pipe[st_nci_gates[j].gate] =
 229                                                 pipe_info[2];
 230                         ndev->hci_dev->pipes[pipe_info[2]].gate =
 231                                                 st_nci_gates[j].gate;
 232                         ndev->hci_dev->pipes[pipe_info[2]].host =
 233                                                 dm_pipe_info->src_host_id;
 234                 }
 235                 kfree_skb(skb_pipe_info);
 236         }
 237 
 238         /*
 239          * 3 gates have a well known pipe ID. Only NCI_HCI_LINK_MGMT_GATE
 240          * is not yet open at this stage.
 241          */
 242         r = nci_hci_connect_gate(ndev, ST_NCI_HOST_CONTROLLER_ID,
 243                                  NCI_HCI_LINK_MGMT_GATE,
 244                                  NCI_HCI_LINK_MGMT_PIPE);
 245 
 246         kfree_skb(skb_pipe_list);
 247         return r;
 248 }
 249 EXPORT_SYMBOL_GPL(st_nci_hci_load_session);
 250 
 251 static void st_nci_hci_admin_event_received(struct nci_dev *ndev,
 252                                               u8 event, struct sk_buff *skb)
 253 {
 254         struct st_nci_info *info = nci_get_drvdata(ndev);
 255 
 256         switch (event) {
 257         case ST_NCI_EVT_HOT_PLUG:
 258                 if (info->se_info.se_active) {
 259                         if (!ST_NCI_EVT_HOT_PLUG_IS_INHIBITED(skb)) {
 260                                 del_timer_sync(&info->se_info.se_active_timer);
 261                                 info->se_info.se_active = false;
 262                                 complete(&info->se_info.req_completion);
 263                         } else {
 264                                 mod_timer(&info->se_info.se_active_timer,
 265                                       jiffies +
 266                                       msecs_to_jiffies(ST_NCI_SE_TO_PIPES));
 267                         }
 268                 }
 269         break;
 270         default:
 271                 nfc_err(&ndev->nfc_dev->dev, "Unexpected event on admin gate\n");
 272         }
 273 }
 274 
 275 static int st_nci_hci_apdu_reader_event_received(struct nci_dev *ndev,
 276                                                    u8 event,
 277                                                    struct sk_buff *skb)
 278 {
 279         int r = 0;
 280         struct st_nci_info *info = nci_get_drvdata(ndev);
 281 
 282         pr_debug("apdu reader gate event: %x\n", event);
 283 
 284         switch (event) {
 285         case ST_NCI_EVT_TRANSMIT_DATA:
 286                 del_timer_sync(&info->se_info.bwi_timer);
 287                 info->se_info.bwi_active = false;
 288                 info->se_info.cb(info->se_info.cb_context,
 289                                  skb->data, skb->len, 0);
 290         break;
 291         case ST_NCI_EVT_WTX_REQUEST:
 292                 mod_timer(&info->se_info.bwi_timer, jiffies +
 293                           msecs_to_jiffies(info->se_info.wt_timeout));
 294         break;
 295         default:
 296                 nfc_err(&ndev->nfc_dev->dev, "Unexpected event on apdu reader gate\n");
 297                 return 1;
 298         }
 299 
 300         kfree_skb(skb);
 301         return r;
 302 }
 303 
 304 /*
 305  * Returns:
 306  * <= 0: driver handled the event, skb consumed
 307  *    1: driver does not handle the event, please do standard processing
 308  */
 309 static int st_nci_hci_connectivity_event_received(struct nci_dev *ndev,
 310                                                 u8 host, u8 event,
 311                                                 struct sk_buff *skb)
 312 {
 313         int r = 0;
 314         struct device *dev = &ndev->nfc_dev->dev;
 315         struct nfc_evt_transaction *transaction;
 316 
 317         pr_debug("connectivity gate event: %x\n", event);
 318 
 319         switch (event) {
 320         case ST_NCI_EVT_CONNECTIVITY:
 321                 r = nfc_se_connectivity(ndev->nfc_dev, host);
 322         break;
 323         case ST_NCI_EVT_TRANSACTION:
 324                 /* According to specification etsi 102 622
 325                  * 11.2.2.4 EVT_TRANSACTION Table 52
 326                  * Description  Tag     Length
 327                  * AID          81      5 to 16
 328                  * PARAMETERS   82      0 to 255
 329                  */
 330                 if (skb->len < NFC_MIN_AID_LENGTH + 2 &&
 331                     skb->data[0] != NFC_EVT_TRANSACTION_AID_TAG)
 332                         return -EPROTO;
 333 
 334                 transaction = (struct nfc_evt_transaction *)devm_kzalloc(dev,
 335                                             skb->len - 2, GFP_KERNEL);
 336                 if (!transaction)
 337                         return -ENOMEM;
 338 
 339                 transaction->aid_len = skb->data[1];
 340                 memcpy(transaction->aid, &skb->data[2], transaction->aid_len);
 341 
 342                 /* Check next byte is PARAMETERS tag (82) */
 343                 if (skb->data[transaction->aid_len + 2] !=
 344                     NFC_EVT_TRANSACTION_PARAMS_TAG)
 345                         return -EPROTO;
 346 
 347                 transaction->params_len = skb->data[transaction->aid_len + 3];
 348                 memcpy(transaction->params, skb->data +
 349                        transaction->aid_len + 4, transaction->params_len);
 350 
 351                 r = nfc_se_transaction(ndev->nfc_dev, host, transaction);
 352                 break;
 353         default:
 354                 nfc_err(&ndev->nfc_dev->dev, "Unexpected event on connectivity gate\n");
 355                 return 1;
 356         }
 357         kfree_skb(skb);
 358         return r;
 359 }
 360 
 361 void st_nci_hci_event_received(struct nci_dev *ndev, u8 pipe,
 362                                  u8 event, struct sk_buff *skb)
 363 {
 364         u8 gate = ndev->hci_dev->pipes[pipe].gate;
 365         u8 host = ndev->hci_dev->pipes[pipe].host;
 366 
 367         switch (gate) {
 368         case NCI_HCI_ADMIN_GATE:
 369                 st_nci_hci_admin_event_received(ndev, event, skb);
 370         break;
 371         case ST_NCI_APDU_READER_GATE:
 372                 st_nci_hci_apdu_reader_event_received(ndev, event, skb);
 373         break;
 374         case ST_NCI_CONNECTIVITY_GATE:
 375                 st_nci_hci_connectivity_event_received(ndev, host, event, skb);
 376         break;
 377         }
 378 }
 379 EXPORT_SYMBOL_GPL(st_nci_hci_event_received);
 380 
 381 void st_nci_hci_cmd_received(struct nci_dev *ndev, u8 pipe, u8 cmd,
 382                                struct sk_buff *skb)
 383 {
 384         struct st_nci_info *info = nci_get_drvdata(ndev);
 385         u8 gate = ndev->hci_dev->pipes[pipe].gate;
 386 
 387         pr_debug("cmd: %x\n", cmd);
 388 
 389         switch (cmd) {
 390         case NCI_HCI_ANY_OPEN_PIPE:
 391                 if (gate != ST_NCI_APDU_READER_GATE &&
 392                     ndev->hci_dev->pipes[pipe].host != ST_NCI_UICC_HOST_ID)
 393                         ndev->hci_dev->count_pipes++;
 394 
 395                 if (ndev->hci_dev->count_pipes ==
 396                     ndev->hci_dev->expected_pipes) {
 397                         del_timer_sync(&info->se_info.se_active_timer);
 398                         info->se_info.se_active = false;
 399                         ndev->hci_dev->count_pipes = 0;
 400                         complete(&info->se_info.req_completion);
 401                 }
 402         break;
 403         }
 404 }
 405 EXPORT_SYMBOL_GPL(st_nci_hci_cmd_received);
 406 
 407 static int st_nci_control_se(struct nci_dev *ndev, u8 se_idx,
 408                              u8 state)
 409 {
 410         struct st_nci_info *info = nci_get_drvdata(ndev);
 411         int r, i;
 412         struct sk_buff *sk_host_list;
 413         u8 host_id;
 414 
 415         switch (se_idx) {
 416         case ST_NCI_UICC_HOST_ID:
 417                 ndev->hci_dev->count_pipes = 0;
 418                 ndev->hci_dev->expected_pipes = ST_NCI_SE_COUNT_PIPE_UICC;
 419                 break;
 420         case ST_NCI_ESE_HOST_ID:
 421                 ndev->hci_dev->count_pipes = 0;
 422                 ndev->hci_dev->expected_pipes = ST_NCI_SE_COUNT_PIPE_EMBEDDED;
 423                 break;
 424         default:
 425                 return -EINVAL;
 426         }
 427 
 428         /*
 429          * Wait for an EVT_HOT_PLUG in order to
 430          * retrieve a relevant host list.
 431          */
 432         reinit_completion(&info->se_info.req_completion);
 433         r = nci_nfcee_mode_set(ndev, se_idx, state);
 434         if (r != NCI_STATUS_OK)
 435                 return r;
 436 
 437         mod_timer(&info->se_info.se_active_timer, jiffies +
 438                 msecs_to_jiffies(ST_NCI_SE_TO_HOT_PLUG));
 439         info->se_info.se_active = true;
 440 
 441         /* Ignore return value and check in any case the host_list */
 442         wait_for_completion_interruptible(&info->se_info.req_completion);
 443 
 444         /* There might be some "collision" after receiving a HOT_PLUG event
 445          * This may cause the CLF to not answer to the next hci command.
 446          * There is no possible synchronization to prevent this.
 447          * Adding a small delay is the only way to solve the issue.
 448          */
 449         if (info->se_info.se_status->is_ese_present &&
 450             info->se_info.se_status->is_uicc_present)
 451                 usleep_range(15000, 20000);
 452 
 453         r = nci_hci_get_param(ndev, NCI_HCI_ADMIN_GATE,
 454                         NCI_HCI_ADMIN_PARAM_HOST_LIST, &sk_host_list);
 455         if (r != NCI_HCI_ANY_OK)
 456                 return r;
 457 
 458         for (i = 0; i < sk_host_list->len &&
 459                 sk_host_list->data[i] != se_idx; i++)
 460                 ;
 461         host_id = sk_host_list->data[i];
 462         kfree_skb(sk_host_list);
 463         if (state == ST_NCI_SE_MODE_ON && host_id == se_idx)
 464                 return se_idx;
 465         else if (state == ST_NCI_SE_MODE_OFF && host_id != se_idx)
 466                 return se_idx;
 467 
 468         return -1;
 469 }
 470 
 471 int st_nci_disable_se(struct nci_dev *ndev, u32 se_idx)
 472 {
 473         int r;
 474 
 475         pr_debug("st_nci_disable_se\n");
 476 
 477         /*
 478          * According to upper layer, se_idx == NFC_SE_UICC when
 479          * info->se_info.se_status->is_uicc_enable is true should never happen
 480          * Same for eSE.
 481          */
 482         r = st_nci_control_se(ndev, se_idx, ST_NCI_SE_MODE_OFF);
 483         if (r < 0) {
 484                 /* Do best effort to release SWP */
 485                 if (se_idx == NFC_SE_EMBEDDED) {
 486                         r = nci_hci_send_event(ndev, ST_NCI_APDU_READER_GATE,
 487                                         ST_NCI_EVT_SE_END_OF_APDU_TRANSFER,
 488                                         NULL, 0);
 489                 }
 490                 return r;
 491         }
 492 
 493         return 0;
 494 }
 495 EXPORT_SYMBOL_GPL(st_nci_disable_se);
 496 
 497 int st_nci_enable_se(struct nci_dev *ndev, u32 se_idx)
 498 {
 499         int r;
 500 
 501         pr_debug("st_nci_enable_se\n");
 502 
 503         /*
 504          * According to upper layer, se_idx == NFC_SE_UICC when
 505          * info->se_info.se_status->is_uicc_enable is true should never happen.
 506          * Same for eSE.
 507          */
 508         r = st_nci_control_se(ndev, se_idx, ST_NCI_SE_MODE_ON);
 509         if (r == ST_NCI_ESE_HOST_ID) {
 510                 st_nci_se_get_atr(ndev);
 511                 r = nci_hci_send_event(ndev, ST_NCI_APDU_READER_GATE,
 512                                 ST_NCI_EVT_SE_SOFT_RESET, NULL, 0);
 513         }
 514 
 515         if (r < 0) {
 516                 /*
 517                  * The activation procedure failed, the secure element
 518                  * is not connected. Remove from the list.
 519                  */
 520                 nfc_remove_se(ndev->nfc_dev, se_idx);
 521                 return r;
 522         }
 523 
 524         return 0;
 525 }
 526 EXPORT_SYMBOL_GPL(st_nci_enable_se);
 527 
 528 static int st_nci_hci_network_init(struct nci_dev *ndev)
 529 {
 530         struct st_nci_info *info = nci_get_drvdata(ndev);
 531         struct core_conn_create_dest_spec_params *dest_params;
 532         struct dest_spec_params spec_params;
 533         struct nci_conn_info    *conn_info;
 534         int r, dev_num;
 535 
 536         dest_params =
 537                 kzalloc(sizeof(struct core_conn_create_dest_spec_params) +
 538                         sizeof(struct dest_spec_params), GFP_KERNEL);
 539         if (dest_params == NULL) {
 540                 r = -ENOMEM;
 541                 goto exit;
 542         }
 543 
 544         dest_params->type = NCI_DESTINATION_SPECIFIC_PARAM_NFCEE_TYPE;
 545         dest_params->length = sizeof(struct dest_spec_params);
 546         spec_params.id = ndev->hci_dev->nfcee_id;
 547         spec_params.protocol = NCI_NFCEE_INTERFACE_HCI_ACCESS;
 548         memcpy(dest_params->value, &spec_params,
 549                sizeof(struct dest_spec_params));
 550         r = nci_core_conn_create(ndev, NCI_DESTINATION_NFCEE, 1,
 551                                  sizeof(struct core_conn_create_dest_spec_params) +
 552                                  sizeof(struct dest_spec_params),
 553                                  dest_params);
 554         if (r != NCI_STATUS_OK)
 555                 goto free_dest_params;
 556 
 557         conn_info = ndev->hci_dev->conn_info;
 558         if (!conn_info)
 559                 goto free_dest_params;
 560 
 561         ndev->hci_dev->init_data.gate_count = ARRAY_SIZE(st_nci_gates);
 562         memcpy(ndev->hci_dev->init_data.gates, st_nci_gates,
 563                sizeof(st_nci_gates));
 564 
 565         /*
 566          * Session id must include the driver name + i2c bus addr
 567          * persistent info to discriminate 2 identical chips
 568          */
 569         dev_num = find_first_zero_bit(dev_mask, ST_NCI_NUM_DEVICES);
 570         if (dev_num >= ST_NCI_NUM_DEVICES) {
 571                 r = -ENODEV;
 572                 goto free_dest_params;
 573         }
 574 
 575         scnprintf(ndev->hci_dev->init_data.session_id,
 576                   sizeof(ndev->hci_dev->init_data.session_id),
 577                   "%s%2x", "ST21BH", dev_num);
 578 
 579         r = nci_hci_dev_session_init(ndev);
 580         if (r != NCI_HCI_ANY_OK)
 581                 goto free_dest_params;
 582 
 583         /*
 584          * In factory mode, we prevent secure elements activation
 585          * by disabling nfcee on the current HCI connection id.
 586          * HCI will be used here only for proprietary commands.
 587          */
 588         if (test_bit(ST_NCI_FACTORY_MODE, &info->flags))
 589                 r = nci_nfcee_mode_set(ndev,
 590                                        ndev->hci_dev->conn_info->dest_params->id,
 591                                        NCI_NFCEE_DISABLE);
 592         else
 593                 r = nci_nfcee_mode_set(ndev,
 594                                        ndev->hci_dev->conn_info->dest_params->id,
 595                                        NCI_NFCEE_ENABLE);
 596 
 597 free_dest_params:
 598         kfree(dest_params);
 599 
 600 exit:
 601         return r;
 602 }
 603 
 604 int st_nci_discover_se(struct nci_dev *ndev)
 605 {
 606         u8 white_list[2];
 607         int r, wl_size = 0;
 608         int se_count = 0;
 609         struct st_nci_info *info = nci_get_drvdata(ndev);
 610 
 611         pr_debug("st_nci_discover_se\n");
 612 
 613         r = st_nci_hci_network_init(ndev);
 614         if (r != 0)
 615                 return r;
 616 
 617         if (test_bit(ST_NCI_FACTORY_MODE, &info->flags))
 618                 return 0;
 619 
 620         if (info->se_info.se_status->is_uicc_present)
 621                 white_list[wl_size++] = ST_NCI_UICC_HOST_ID;
 622         if (info->se_info.se_status->is_ese_present)
 623                 white_list[wl_size++] = ST_NCI_ESE_HOST_ID;
 624 
 625         if (wl_size) {
 626                 r = nci_hci_set_param(ndev, NCI_HCI_ADMIN_GATE,
 627                                       NCI_HCI_ADMIN_PARAM_WHITELIST,
 628                                       white_list, wl_size);
 629                 if (r != NCI_HCI_ANY_OK)
 630                         return r;
 631         }
 632 
 633         if (info->se_info.se_status->is_uicc_present) {
 634                 nfc_add_se(ndev->nfc_dev, ST_NCI_UICC_HOST_ID, NFC_SE_UICC);
 635                 se_count++;
 636         }
 637 
 638         if (info->se_info.se_status->is_ese_present) {
 639                 nfc_add_se(ndev->nfc_dev, ST_NCI_ESE_HOST_ID, NFC_SE_EMBEDDED);
 640                 se_count++;
 641         }
 642 
 643         return !se_count;
 644 }
 645 EXPORT_SYMBOL_GPL(st_nci_discover_se);
 646 
 647 int st_nci_se_io(struct nci_dev *ndev, u32 se_idx,
 648                        u8 *apdu, size_t apdu_length,
 649                        se_io_cb_t cb, void *cb_context)
 650 {
 651         struct st_nci_info *info = nci_get_drvdata(ndev);
 652 
 653         pr_debug("\n");
 654 
 655         switch (se_idx) {
 656         case ST_NCI_ESE_HOST_ID:
 657                 info->se_info.cb = cb;
 658                 info->se_info.cb_context = cb_context;
 659                 mod_timer(&info->se_info.bwi_timer, jiffies +
 660                           msecs_to_jiffies(info->se_info.wt_timeout));
 661                 info->se_info.bwi_active = true;
 662                 return nci_hci_send_event(ndev, ST_NCI_APDU_READER_GATE,
 663                                         ST_NCI_EVT_TRANSMIT_DATA, apdu,
 664                                         apdu_length);
 665         default:
 666                 return -ENODEV;
 667         }
 668 }
 669 EXPORT_SYMBOL(st_nci_se_io);
 670 
 671 static void st_nci_se_wt_timeout(struct timer_list *t)
 672 {
 673         /*
 674          * No answer from the secure element
 675          * within the defined timeout.
 676          * Let's send a reset request as recovery procedure.
 677          * According to the situation, we first try to send a software reset
 678          * to the secure element. If the next command is still not
 679          * answering in time, we send to the CLF a secure element hardware
 680          * reset request.
 681          */
 682         /* hardware reset managed through VCC_UICC_OUT power supply */
 683         u8 param = 0x01;
 684         struct st_nci_info *info = from_timer(info, t, se_info.bwi_timer);
 685 
 686         pr_debug("\n");
 687 
 688         info->se_info.bwi_active = false;
 689 
 690         if (!info->se_info.xch_error) {
 691                 info->se_info.xch_error = true;
 692                 nci_hci_send_event(info->ndlc->ndev, ST_NCI_APDU_READER_GATE,
 693                                 ST_NCI_EVT_SE_SOFT_RESET, NULL, 0);
 694         } else {
 695                 info->se_info.xch_error = false;
 696                 nci_hci_send_event(info->ndlc->ndev, ST_NCI_DEVICE_MGNT_GATE,
 697                                 ST_NCI_EVT_SE_HARD_RESET, &param, 1);
 698         }
 699         info->se_info.cb(info->se_info.cb_context, NULL, 0, -ETIME);
 700 }
 701 
 702 static void st_nci_se_activation_timeout(struct timer_list *t)
 703 {
 704         struct st_nci_info *info = from_timer(info, t,
 705                                               se_info.se_active_timer);
 706 
 707         pr_debug("\n");
 708 
 709         info->se_info.se_active = false;
 710 
 711         complete(&info->se_info.req_completion);
 712 }
 713 
 714 int st_nci_se_init(struct nci_dev *ndev, struct st_nci_se_status *se_status)
 715 {
 716         struct st_nci_info *info = nci_get_drvdata(ndev);
 717 
 718         init_completion(&info->se_info.req_completion);
 719         /* initialize timers */
 720         timer_setup(&info->se_info.bwi_timer, st_nci_se_wt_timeout, 0);
 721         info->se_info.bwi_active = false;
 722 
 723         timer_setup(&info->se_info.se_active_timer,
 724                     st_nci_se_activation_timeout, 0);
 725         info->se_info.se_active = false;
 726 
 727         info->se_info.xch_error = false;
 728 
 729         info->se_info.wt_timeout =
 730                 ST_NCI_BWI_TO_TIMEOUT(ST_NCI_ATR_DEFAULT_BWI);
 731 
 732         info->se_info.se_status = se_status;
 733 
 734         return 0;
 735 }
 736 EXPORT_SYMBOL(st_nci_se_init);
 737 
 738 void st_nci_se_deinit(struct nci_dev *ndev)
 739 {
 740         struct st_nci_info *info = nci_get_drvdata(ndev);
 741 
 742         if (info->se_info.bwi_active)
 743                 del_timer_sync(&info->se_info.bwi_timer);
 744         if (info->se_info.se_active)
 745                 del_timer_sync(&info->se_info.se_active_timer);
 746 
 747         info->se_info.se_active = false;
 748         info->se_info.bwi_active = false;
 749 }
 750 EXPORT_SYMBOL(st_nci_se_deinit);
 751
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/nfc/st-nci/se.c

DEFINITIONS
