src/phFriNfc_DesfireFormat.c

   1 /*
   2  * Copyright (C) 2010 NXP Semiconductors
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /*!
  18 * \file  phFriNfc_DesfireFormat.c
  19 * \brief This component encapsulates different format functinalities ,
  20 *        for the Type4/Desfire card.
  21 *
  22 * Project: NFC-FRI
  23 *
  24 * $Date: Thu Oct 28 17:44:00 2010 $
  25 * $Author: ing02260 $
  26 * $Revision: 1.8 $
  27 * $Aliases:  $
  28 *
  29 */
  30 #include <phNfcTypes.h>
  31 #include <phFriNfc_OvrHal.h>
  32 #include <phFriNfc_SmtCrdFmt.h>
  33 #include <phFriNfc_DesfireFormat.h>
  34
  35
  36 /* Following section details, how to wrap the native DESFire commands in to ISO commands
  37 Following are different native commands are wrapped under the ISO commands :
  38 1. Crate Application
  39 2. Select File
  40 3. Get version
  41 4. Create CC/NDEF File
  42 5. Write data to STD File
  43 In this File above commands are sent using the ISO Wrapper.
  44
  45 Wrapping the native DESFire APDU's procedure
  46 --------------------------------------------------------------------------------
  47 CLA         INS     P1      P2      Lc          Data            Le
  48 0x90        Cmd     0x00    0x00    Data Len    Cmd. Par's      0x00
  49 -----------------------------------------------------------------------------------*/
  50
  51 /****************************** Macro definitions start ********************************/
  52 /* This settings can be changed, depending on the requirement*/
  53 #define  PH_FRINFC_DESF_PICC_NFC_KEY_SETTING                0x0FU
  54
  55 #ifdef FRINFC_READONLY_NDEF
  56
  57     #define READ_ONLY_NDEF_DESFIRE                          0xFFU
  58     #define CC_BYTES_SIZE                                   0x0FU
  59     #define PH_FRINFC_DESF_READ_DATA_CMD                    0xBDU
  60     #define NATIVE_WRAPPER_READ_DATA_LC_VALUE               0x07U
  61
  62 #endif /* #ifdef FRINFC_READONLY_NDEF */
  63
  64 #ifdef DESFIRE_FMT_EV1
  65
  66 #define DESFIRE_CARD_TYPE_EV1                               0x01U
  67
  68 #define DESFIRE_EV1_MAPPING_VERSION                         0x20U
  69
  70 #define DESFIRE_EV1_HW_MAJOR_VERSION                        0x01U
  71 #define DESFIRE_EV1_HW_MINOR_VERSION                        0x00U
  72 #define DESFIRE_EV1_SW_MAJOR_VERSION                        0x01U
  73 #define DESFIRE_EV1_SW_MINOR_VERSION                        0x03U
  74
  75 /* The below values are received for the command GET VERSION */
  76 #define DESFIRE_TAG_SIZE_IDENTIFIER_2K                      0x16U
  77 #define DESFIRE_TAG_SIZE_IDENTIFIER_4K                      0x18U
  78 #define DESFIRE_TAG_SIZE_IDENTIFIER_8K                      0x1AU
  79
  80 #define DESFIRE_2K_CARD                                     2048U
  81 #define DESFIRE_4K_CARD                                     4096U
  82 #define DESFIRE_8K_CARD                                     7680U
  83
  84 #define DESFIRE_EV1_KEY_SETTINGS_2                          0x21U
  85
  86 #define DESFIRE_EV1_FIRST_AID_BYTE                          0x01U
  87 #define DESFIRE_EV1_SECOND_AID_BYTE                         0x00U
  88 #define DESFIRE_EV1_THIRD_AID_BYTE                          0x00U
  89
  90 #define DESFIRE_EV1_FIRST_ISO_FILE_ID                       0x05U
  91 #define DESFIRE_EV1_SECOND_ISO_FILE_ID                      0xE1U
  92
  93 #define DESFIRE_EV1_ISO_APP_DF_NAME                         {0xD2, 0x76, 0x00, 0x00, 0x85, 0x01, 0x01}
  94
  95 #define DESFIRE_EV1_CC_FILE_ID                              0x01U
  96 #define DESFIRE_EV1_FIRST_CC_FILE_ID_BYTE                   0x03U
  97 #define DESFIRE_EV1_SECOND_CC_FILE_ID_BYTE                  0xE1U
  98
  99 #define DESFIRE_EV1_NDEF_FILE_ID                            0x02U
 100 #define DESFIRE_EV1_FIRST_NDEF_FILE_ID_BYTE                 0x04U
 101 #define DESFIRE_EV1_SECOND_NDEF_FILE_ID_BYTE                0xE1U
 102
 103
 104 #define PH_FRINFC_DESF_STATE_REACTIVATE                     0x0FU
 105
 106 #endif /* #ifdef DESFIRE_FMT_EV1 */
 107 /****************************** Macro definitions end ********************************/
 108 /* Helper functions to create app/select app/create data file/read /write from the
 109 CC file and NDEF files */
 110 static void phFriNfc_Desf_HWrapISONativeCmds(phFriNfc_sNdefSmtCrdFmt_t    *NdefSmtCrdFmt,uint8_t CmdType);
 111
 112 /* Gets H/W version details*/
 113 static NFCSTATUS phFriNfc_Desf_HGetHWVersion(phFriNfc_sNdefSmtCrdFmt_t    *NdefSmtCrdFmt);
 114
 115 /* Gets S/W version details*/
 116 static NFCSTATUS phFriNfc_Desf_HGetSWVersion(phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt);
 117
 118 /* Updates the version details to context structure*/
 119 static NFCSTATUS phFriNfc_Desf_HUpdateVersionDetails(phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt);
 120
 121 /*Gets UID details*/
 122 static NFCSTATUS phFriNfc_Desf_HGetUIDDetails(phFriNfc_sNdefSmtCrdFmt_t * NdefSmtCrdFmt);
 123
 124 /*Creates Application*/
 125 static NFCSTATUS phFriNfc_Desf_HCreateApp(phFriNfc_sNdefSmtCrdFmt_t    *NdefSmtCrdFmt);
 126
 127 /* Selects Application*/
 128 static NFCSTATUS phFriNfc_Desf_HSelectApp(phFriNfc_sNdefSmtCrdFmt_t    *NdefSmtCrdFmt);
 129
 130 /*Creates Capability Container File*/
 131 static NFCSTATUS phFriNfc_Desf_HCreatCCFile(phFriNfc_sNdefSmtCrdFmt_t    *NdefSmtCrdFmt);
 132
 133 /* Create NDEF File*/
 134 static NFCSTATUS phFriNfc_Desf_HCreatNDEFFile(phFriNfc_sNdefSmtCrdFmt_t    *NdefSmtCrdFmt);
 135
 136 /* Writes CC Bytes to CC File*/
 137 static NFCSTATUS phFriNfc_Desf_HWrCCBytes(phFriNfc_sNdefSmtCrdFmt_t    *NdefSmtCrdFmt);
 138
 139 /* Writes NDEF data into NDEF File*/
 140 static NFCSTATUS phFriNfc_Desf_HWrNDEFData(phFriNfc_sNdefSmtCrdFmt_t    *NdefSmtCrdFmt);
 141
 142 /* Transceive Cmd initiation*/
 143 static NFCSTATUS phFriNfc_Desf_HSendTransCmd(phFriNfc_sNdefSmtCrdFmt_t    *NdefSmtCrdFmt);
 144
 145 #ifdef FRINFC_READONLY_NDEF
 146
 147 #if 0
 148 static
 149 NFCSTATUS
 150 phFriNfc_Desf_HReadOnlySelectCCFile (
 151     phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt);
 152 #endif /* #if 0 */
 153
 154 static
 155 NFCSTATUS
 156 phFriNfc_Desf_HReadOnlyReadCCFile (
 157     phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt);
 158
 159 static
 160 NFCSTATUS
 161 phFriNfc_Desf_HReadOnlyWriteCCFile (
 162     phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt);
 163
 164 static
 165 NFCSTATUS
 166 phFriNfc_Desf_HReadOnlySelectApp (
 167     phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt);
 168
 169 #ifdef DESFIRE_FMT_EV1
 170
 171 static
 172 NFCSTATUS
 173 phFriNfc_Desf_HReadOnlySelectAppEV1 (
 174     phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt);
 175
 176 #endif /* #ifdef DESFIRE_FMT_EV1 */
 177
 178 #endif /* #ifdef FRINFC_READONLY_NDEF */
 179
 180 void phFriNfc_Desfire_Reset( phFriNfc_sNdefSmtCrdFmt_t    *NdefSmtCrdFmt)
 181 {
 182     /* This piece of code may not be useful for the current supported DESFire formatting feature*/
 183     /* Currently, s/w doesn't support authenticating either PICC Master key nor NFC Forum
 184     Application Master key*/
 185
 186     /*NdefSmtCrdFmt->AddInfo.Type4Info.PICCMasterKey[] = PH_FRINFC_SMTCRDFMT_DESF_PICC_MASTER_KEY;
 187     NdefSmtCrdFmt->AddInfo.Type4Info.NFCForumMasterkey[]  = PH_FRINFC_SMTCRDFMT_DESF_NFCFORUM_APP_KEY;*/
 188
 189     /* reset to zero PICC and NFC FORUM master keys*/
 190     (void)memset((void *)NdefSmtCrdFmt->AddInfo.Type4Info.PICCMasterKey,
 191                 0x00,
 192                                                                 16);
 193
 194     (void)memset((void *)NdefSmtCrdFmt->AddInfo.Type4Info.NFCForumMasterkey,
 195                 0x00,
 196                                                                 16);
 197     NdefSmtCrdFmt->AddInfo.Type4Info.PrevState = 0;
 198
 199 }
 200
 201
 202 static void phFriNfc_Desf_HWrapISONativeCmds(phFriNfc_sNdefSmtCrdFmt_t    *NdefSmtCrdFmt,uint8_t CmdType)
 203 {
 204
 205     uint16_t i=0, CmdByte=1;
 206     uint8_t NdefFileBytes[] = PH_FRINFC_DESF_NDEFFILE_BYTES;
 207     uint8_t CCFileBytes[]  = PH_FRINFC_DESF_CCFILE_BYTES;
 208
 209
 210     /* common elements for all the native commands*/
 211
 212     /* Class Byte */
 213     NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_NATIVE_CLASS_BYTE;
 214
 215     /* let the place to store the cmd byte type, point to next index*/
 216     i += 2;
 217
 218
 219     /* P1/P2 offsets always set to zero */
 220     NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_NATIVE_OFFSET_P1;
 221     i++;
 222     NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_NATIVE_OFFSET_P2;
 223     i++;
 224
 225     switch(CmdType)
 226     {
 227         case PH_FRINFC_DESF_GET_HW_VERSION_CMD :
 228         case PH_FRINFC_DESF_GET_SW_VERSION_CMD :
 229         case PH_FRINFC_DESF_GET_UID_CMD :
 230         {
 231             if (CmdType == PH_FRINFC_DESF_GET_HW_VERSION_CMD )
 232             {
 233                 /* Instruction Cmd code */
 234                 NdefSmtCrdFmt->SendRecvBuf[CmdByte] = PH_FRINFC_DESF_GET_VER_CMD;
 235             }
 236             else
 237             {
 238                 /* Instruction Cmd code */
 239                 NdefSmtCrdFmt->SendRecvBuf[CmdByte] = PH_FRINFC_DESF_PICC_ADDI_FRAME_RESP;
 240             }
 241
 242             /*  Lc: Length of wrapped data */
 243             NdefSmtCrdFmt->SendRecvBuf[i] = 0x00;
 244             i++;
 245
 246             /* NO Data to send in this cmd*/
 247             /* we are not suppose to set Le*/
 248             /* set the length of the buffer*/
 249             NdefSmtCrdFmt->SendLength = i;
 250
 251             break;
 252         }
 253
 254         case PH_FRINFC_DESF_CREATEAPP_CMD:
 255         {
 256 #ifdef DESFIRE_FMT_EV1
 257             uint8_t             df_name[] = DESFIRE_EV1_ISO_APP_DF_NAME;
 258 #endif /* #ifdef DESFIRE_FMT_EV1 */
 259
 260             /* Instruction Cmd code */
 261             NdefSmtCrdFmt->SendRecvBuf[CmdByte] = PH_FRINFC_DESF_CREATE_AID_CMD;
 262
 263 #ifdef DESFIRE_FMT_EV1
 264             if (DESFIRE_CARD_TYPE_EV1 == NdefSmtCrdFmt->CardType)
 265             {
 266                 /*  Lc: Length of wrapped data,
 267                     here the magic number 2 is for the ISO File ID for the application */
 268                 NdefSmtCrdFmt->SendRecvBuf[i] = (uint8_t)(PH_FRINFC_DESF_NATIVE_CRAPP_WRDT_LEN +
 269                                                 sizeof (df_name) + 2);
 270                 i++;
 271                 /* NFC FORUM APPLICATION ID*/
 272                 NdefSmtCrdFmt->SendRecvBuf[i] = DESFIRE_EV1_FIRST_AID_BYTE;
 273                 i++;
 274                 NdefSmtCrdFmt->SendRecvBuf[i] = DESFIRE_EV1_SECOND_AID_BYTE;
 275                 i++;
 276                 NdefSmtCrdFmt->SendRecvBuf[i] = DESFIRE_EV1_THIRD_AID_BYTE;
 277                 i++;
 278             }
 279             else
 280 #endif /* #ifdef DESFIRE_FMT_EV1 */
 281             {
 282                 /*  Lc: Length of wrapped data */
 283                 NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_NATIVE_CRAPP_WRDT_LEN;
 284                 i++;
 285                 /* NFC FORUM APPLICATION ID*/
 286                 NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_FIRST_AID_BYTE;
 287                 i++;
 288                 NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_SEC_AID_BYTE;
 289                 i++;
 290                 NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_THIRD_AID_BYTE;
 291                 i++;
 292             }
 293             /* set key settings and number of keys*/
 294             NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_PICC_NFC_KEY_SETTING;
 295             i++;
 296 #ifdef DESFIRE_FMT_EV1
 297             if (DESFIRE_CARD_TYPE_EV1 == NdefSmtCrdFmt->CardType)
 298             {
 299                 /* set key settings and number of keys*/
 300                 NdefSmtCrdFmt->SendRecvBuf[i] = DESFIRE_EV1_KEY_SETTINGS_2;
 301                 i++;
 302             }
 303             else
 304 #endif /* #ifdef DESFIRE_FMT_EV1 */
 305             {
 306                 NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_NFCFORUM_APP_NO_OF_KEYS;
 307                 i++;
 308             }
 309
 310 #ifdef DESFIRE_FMT_EV1
 311             if (DESFIRE_CARD_TYPE_EV1 == NdefSmtCrdFmt->CardType)
 312             {
 313                 /* ISO File ID */
 314                 NdefSmtCrdFmt->SendRecvBuf[i] = DESFIRE_EV1_FIRST_ISO_FILE_ID;
 315                 i++;
 316                 NdefSmtCrdFmt->SendRecvBuf[i] = DESFIRE_EV1_SECOND_ISO_FILE_ID;
 317                 i++;
 318                 /* DF file name */
 319                 (void)memcpy ((void *)&NdefSmtCrdFmt->SendRecvBuf[i],
 320                                 (void *)df_name, sizeof (df_name));
 321                 i = (uint16_t)(i + sizeof (df_name));
 322             }
 323 #endif /* #ifdef DESFIRE_FMT_EV1 */
 324
 325             /* Le bytes*/
 326             NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_NATIVE_LE_BYTE;
 327             i++;
 328
 329 #ifdef DESFIRE_FMT_EV1
 330             if (DESFIRE_CARD_TYPE_EV1 == NdefSmtCrdFmt->CardType)
 331             {
 332                 /* set the length of the buffer*/
 333                 NdefSmtCrdFmt->SendLength = i;
 334             }
 335             else
 336 #endif /* #ifdef DESFIRE_FMT_EV1 */
 337             {
 338                 NdefSmtCrdFmt->SendLength = PH_FRINFC_DESF_CREATEAPP_CMD_SNLEN;
 339             }
 340             break;
 341         }
 342
 343         case PH_FRINFC_DESF_SELECTAPP_CMD:
 344         {
 345             /* Instruction Cmd code */
 346             NdefSmtCrdFmt->SendRecvBuf[CmdByte] = PH_FRINFC_DESF_SLECT_APP_CMD;
 347
 348             /*  Lc: Length of wrapped data */
 349             NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_NATIVE_SLAPP_WRDT_LEN;
 350             i++;
 351
 352 #ifdef DESFIRE_FMT_EV1
 353             if (DESFIRE_CARD_TYPE_EV1 == NdefSmtCrdFmt->CardType)
 354             {
 355                 /* Data*/
 356                 /* set the send buffer to create the application identifier*/
 357                 NdefSmtCrdFmt->SendRecvBuf[i] = DESFIRE_EV1_FIRST_AID_BYTE;
 358                 i++;
 359
 360                 NdefSmtCrdFmt->SendRecvBuf[i] = DESFIRE_EV1_SECOND_AID_BYTE;
 361                 i++;
 362
 363                 NdefSmtCrdFmt->SendRecvBuf[i] = DESFIRE_EV1_THIRD_AID_BYTE;
 364                 i++;
 365             }
 366             else
 367 #endif /* #ifdef DESFIRE_FMT_EV1 */
 368             {
 369                 /* Data*/
 370                 /* set the send buffer to create the application identifier*/
 371                 NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_FIRST_AID_BYTE;
 372                 i++;
 373
 374                 NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_SEC_AID_BYTE;
 375                 i++;
 376
 377                 NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_THIRD_AID_BYTE;
 378                 i++;
 379             }
 380
 381             /* Le bytes*/
 382             NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_NATIVE_LE_BYTE;
 383             i++;
 384
 385             /* set the length of the buffer*/
 386             NdefSmtCrdFmt->SendLength = PH_FRINFC_DESF_SELECTAPP_CMD_SNLEN;
 387             break;
 388         }
 389
 390         case PH_FRINFC_DESF_CREATECC_CMD:
 391         {
 392             /* Instruction Cmd code */
 393             NdefSmtCrdFmt->SendRecvBuf[CmdByte] = PH_FRINFC_DESF_CREATE_DATA_FILE_CMD;
 394
 395 #ifdef DESFIRE_FMT_EV1
 396             if (DESFIRE_CARD_TYPE_EV1 == NdefSmtCrdFmt->CardType)
 397             {
 398                 /*  Lc: Length of wrapped data,
 399                 here the magic number 2 is added as part of the ISO File ID in the packet */
 400                 NdefSmtCrdFmt->SendRecvBuf[i] = (uint8_t)
 401                                     (PH_FRINFC_DESF_NATIVE_CRCCNDEF_WRDT_LEN + 2);
 402                 i++;
 403                 /*  set cc file id* */
 404                 NdefSmtCrdFmt->SendRecvBuf[i] = DESFIRE_EV1_CC_FILE_ID;
 405                 i++;
 406                 /* ISO File ID */
 407                 NdefSmtCrdFmt->SendRecvBuf[i] = DESFIRE_EV1_FIRST_CC_FILE_ID_BYTE;
 408                 i++;
 409                 NdefSmtCrdFmt->SendRecvBuf[i] = DESFIRE_EV1_SECOND_CC_FILE_ID_BYTE;
 410                 i++;
 411             }
 412             else
 413 #endif /* #ifdef DESFIRE_FMT_EV1 */
 414             {
 415                 /*  Lc: Length of wrapped data */
 416                 NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_NATIVE_CRCCNDEF_WRDT_LEN;
 417                 i++;
 418                 /* set cc file id*/
 419                 NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_CC_FILE_ID;
 420                 i++;
 421             }
 422
 423             NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_COMM_SETTINGS;
 424             i++;
 425
 426             /* set the Access Rights are set to full read/write, full cntrl*/
 427             NdefSmtCrdFmt->SendRecvBuf[i] = 0xEE;
 428             i++;
 429             NdefSmtCrdFmt->SendRecvBuf[i] = 0xEE;
 430             i++;
 431
 432             /* set the file size*/
 433             NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_CC_FILE_SIZE;
 434             i++;
 435             NdefSmtCrdFmt->SendRecvBuf[i] = 0x00;
 436             i++;
 437             NdefSmtCrdFmt->SendRecvBuf[i] = 0x00;
 438             i++;
 439
 440             /* Le bytes*/
 441             NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_NATIVE_LE_BYTE;
 442             i++;
 443 #ifdef DESFIRE_FMT_EV1
 444             if (DESFIRE_CARD_TYPE_EV1 == NdefSmtCrdFmt->CardType)
 445             {
 446                 /* set the length of the buffer*/
 447                 NdefSmtCrdFmt->SendLength = i;
 448             }
 449             else
 450 #endif /* #ifdef DESFIRE_FMT_EV1 */
 451             {
 452                 /* set the length of the buffer*/
 453                 NdefSmtCrdFmt->SendLength = PH_FRINFC_DESF_CREATECCNDEF_CMD_SNLEN;
 454             }
 455             break;
 456         }
 457
 458         case PH_FRINFC_DESF_CREATENDEF_CMD:
 459         {
 460             /* Instruction Cmd code */
 461             NdefSmtCrdFmt->SendRecvBuf[CmdByte] = PH_FRINFC_DESF_CREATE_DATA_FILE_CMD;
 462
 463 #ifdef DESFIRE_FMT_EV1
 464             if (DESFIRE_CARD_TYPE_EV1 == NdefSmtCrdFmt->CardType)
 465             {
 466                 /*  Lc: Length of wrapped data,
 467                 here the magic number 2 is added as part of the ISO File ID in the packet */
 468                 NdefSmtCrdFmt->SendRecvBuf[i] = (uint8_t)
 469                                     (PH_FRINFC_DESF_NATIVE_CRCCNDEF_WRDT_LEN + 2);
 470                 i++;
 471                 /*  set NDEF file id* */
 472                 NdefSmtCrdFmt->SendRecvBuf[i] = DESFIRE_EV1_NDEF_FILE_ID;
 473                 i++;
 474                 /* ISO File ID */
 475                 NdefSmtCrdFmt->SendRecvBuf[i] = DESFIRE_EV1_FIRST_NDEF_FILE_ID_BYTE;
 476                 i++;
 477                 NdefSmtCrdFmt->SendRecvBuf[i] = DESFIRE_EV1_SECOND_NDEF_FILE_ID_BYTE;
 478                 i++;
 479             }
 480             else
 481 #endif /* #ifdef DESFIRE_FMT_EV1 */
 482             {
 483                 /*  Lc: Length of wrapped data */
 484                 NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_NATIVE_CRCCNDEF_WRDT_LEN;
 485                 i++;
 486
 487                 /* set NDEF file id*/
 488                 NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_NDEF_FILE_ID;
 489                 i++;
 490             }
 491             NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_COMM_SETTINGS;
 492             i++;
 493
 494             /* set the r/w access rights.Once Authentication part is fixed,
 495             we will use the constants*/
 496             NdefSmtCrdFmt->SendRecvBuf[i] = 0xEE;
 497             i++;
 498             NdefSmtCrdFmt->SendRecvBuf[i] = 0xEE;
 499             i++;
 500
 501             NdefSmtCrdFmt->SendRecvBuf[i]= (uint8_t)NdefSmtCrdFmt->AddInfo.Type4Info.CardSize;
 502             i++;
 503             NdefSmtCrdFmt->SendRecvBuf[i]= (uint8_t)
 504                                     (NdefSmtCrdFmt->AddInfo.Type4Info.CardSize >> 8);
 505             i++;
 506             NdefSmtCrdFmt->SendRecvBuf[i]= (uint8_t)
 507                                     (NdefSmtCrdFmt->AddInfo.Type4Info.CardSize >> 16);
 508             i++;
 509
 510             /* Le bytes*/
 511             NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_NATIVE_LE_BYTE;
 512             i++;
 513
 514 #ifdef DESFIRE_FMT_EV1
 515             if (DESFIRE_CARD_TYPE_EV1 == NdefSmtCrdFmt->CardType)
 516             {
 517                 /* set the length of the buffer*/
 518                 NdefSmtCrdFmt->SendLength = i;
 519             }
 520             else
 521 #endif /* #ifdef DESFIRE_FMT_EV1 */
 522             {
 523                 /* set the length of the buffer*/
 524                 NdefSmtCrdFmt->SendLength = PH_FRINFC_DESF_CREATECCNDEF_CMD_SNLEN;
 525             }
 526             break;
 527         }
 528
 529         case PH_FRINFC_DESF_WRITECC_CMD:
 530         {
 531             /* Instruction Cmd code */
 532             NdefSmtCrdFmt->SendRecvBuf[CmdByte] = PH_FRINFC_DESF_WRITE_CMD;
 533
 534             /*  Lc: Length of wrapped data */
 535             NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_NATIVE_WRCC_WRDT_LEN;
 536             i++;
 537
 538 #ifdef DESFIRE_FMT_EV1
 539             if (DESFIRE_CARD_TYPE_EV1 == NdefSmtCrdFmt->CardType)
 540             {
 541                 /* set the file id*/
 542                 NdefSmtCrdFmt->SendRecvBuf[i] = DESFIRE_EV1_CC_FILE_ID;
 543                 i++;
 544             }
 545             else
 546 #endif /* #ifdef DESFIRE_FMT_EV1 */
 547             {
 548                 /* set the file id*/
 549                 NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_CC_FILE_ID;
 550                 i++;
 551             }
 552
 553             /* set the offset to zero*/
 554             NdefSmtCrdFmt->SendRecvBuf[i] = 0x00;
 555             i++;
 556             NdefSmtCrdFmt->SendRecvBuf[i] = 0x00;
 557             i++;
 558             NdefSmtCrdFmt->SendRecvBuf[i] = 0x00;
 559             i++;
 560
 561             /* Set the length of data available to write*/
 562             NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_CC_FILE_SIZE;
 563             i++;
 564             NdefSmtCrdFmt->SendRecvBuf[i] = 0x00;
 565             i++;
 566             NdefSmtCrdFmt->SendRecvBuf[i] = 0x00;
 567             i++;
 568 #ifdef DESFIRE_FMT_EV1
 569             if (DESFIRE_CARD_TYPE_EV1 == NdefSmtCrdFmt->CardType)
 570             {
 571                 CCFileBytes[2] = (uint8_t)DESFIRE_EV1_MAPPING_VERSION;
 572
 573                 /* Length value is updated in the CC as per the card size received from
 574                     the GetVersion command */
 575                 CCFileBytes[11] = (uint8_t)
 576                         (NdefSmtCrdFmt->AddInfo.Type4Info.CardSize >> 8);
 577                 CCFileBytes[12] = (uint8_t)
 578                         (NdefSmtCrdFmt->AddInfo.Type4Info.CardSize);
 579             }
 580 #endif /* #ifdef DESFIRE_FMT_EV1 */
 581             /*set the data to be written to the CC file*/
 582             (void)memcpy ((void *)&NdefSmtCrdFmt->SendRecvBuf[i],
 583                         (void *)CCFileBytes, sizeof (CCFileBytes));
 584 #ifdef DESFIRE_FMT_EV1
 585 #else
 586             i++;
 587 #endif /* #ifdef DESFIRE_FMT_EV1 */
 588
 589             i = (uint16_t)(i + sizeof (CCFileBytes));
 590
 591             /* Le bytes*/
 592             NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_NATIVE_LE_BYTE;
 593             i++;
 594 #ifdef DESFIRE_FMT_EV1
 595             if (DESFIRE_CARD_TYPE_EV1 == NdefSmtCrdFmt->CardType)
 596             {
 597                 NdefSmtCrdFmt->SendLength = i;
 598             }
 599             else
 600 #endif /* #ifdef DESFIRE_FMT_EV1 */
 601             {
 602                 NdefSmtCrdFmt->SendLength = PH_FRINFC_DESF_WRITECC_CMD_SNLEN;
 603             }
 604             break;
 605         }
 606
 607         case PH_FRINFC_DESF_WRITENDEF_CMD:
 608         {
 609             /* Instruction Cmd code */
 610             NdefSmtCrdFmt->SendRecvBuf[CmdByte] = PH_FRINFC_DESF_WRITE_CMD;
 611
 612             /*  Lc: Length of wrapped data */
 613             NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_NATIVE_WRNDEF_WRDT_LEN;
 614             i++;
 615
 616 #ifdef DESFIRE_FMT_EV1
 617             if (DESFIRE_CARD_TYPE_EV1 == NdefSmtCrdFmt->CardType)
 618             {
 619                 /* set the file id*/
 620                 NdefSmtCrdFmt->SendRecvBuf[i] = DESFIRE_EV1_NDEF_FILE_ID;
 621                 i++;
 622             }
 623             else
 624 #endif /* #ifdef DESFIRE_FMT_EV1 */
 625             {
 626                 /* set the file id*/
 627                 NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_NDEF_FILE_ID;
 628                 i++;
 629             }
 630
 631             /* set the offset to zero*/
 632             NdefSmtCrdFmt->SendRecvBuf[i] = 0x00;
 633             i++;
 634             NdefSmtCrdFmt->SendRecvBuf[i] = 0x00;
 635             i++;
 636             NdefSmtCrdFmt->SendRecvBuf[i] = 0x00;
 637             i++;
 638
 639             /* Set the length of data available to write*/
 640             NdefSmtCrdFmt->SendRecvBuf[i] = 0x02;
 641             i++;
 642             NdefSmtCrdFmt->SendRecvBuf[i] = 0x00;
 643             i++;
 644             NdefSmtCrdFmt->SendRecvBuf[i] = 0x00;
 645             i++;
 646
 647             /*set the data to be written to the CC file*/
 648
 649             (void)memcpy(&NdefSmtCrdFmt->SendRecvBuf[i],
 650                         NdefFileBytes, sizeof (NdefFileBytes));
 651             i = (uint16_t)(i + sizeof (NdefFileBytes));
 652
 653             /* Le bytes*/
 654             NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_NATIVE_LE_BYTE;
 655             i++;
 656
 657             NdefSmtCrdFmt->SendLength = PH_FRINFC_DESF_WRITENDEF_CMD_SNLEN;
 658             break;
 659         }
 660
 661         default:
 662         {
 663             break;
 664         }
 665     }
 666 }
 667
 668 static NFCSTATUS phFriNfc_Desf_HGetHWVersion(phFriNfc_sNdefSmtCrdFmt_t    *NdefSmtCrdFmt)
 669 {
 670     NFCSTATUS status = NFCSTATUS_SUCCESS;
 671 #ifdef PH_HAL4_ENABLE
 672     /* Removed uint8_t i=0; */
 673 #else
 674     uint8_t i=0;
 675 #endif /* #ifdef PH_HAL4_ENABLE */
 676
 677     /*set the state*/
 678     NdefSmtCrdFmt->State = PH_FRINFC_DESF_STATE_GET_HW_VERSION;
 679
 680     /* Helper routine to wrap the native DESFire cmds*/
 681     phFriNfc_Desf_HWrapISONativeCmds(NdefSmtCrdFmt,PH_FRINFC_DESF_GET_HW_VERSION_CMD);
 682
 683     status = phFriNfc_Desf_HSendTransCmd(NdefSmtCrdFmt);
 684
 685     return ( status);
 686 }
 687
 688 static NFCSTATUS phFriNfc_Desf_HGetSWVersion(phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt)
 689 {
 690
 691     NFCSTATUS status = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
 692         NFCSTATUS_FORMAT_ERROR);
 693
 694     if( ( NdefSmtCrdFmt->SendRecvBuf[*(NdefSmtCrdFmt->SendRecvLength)- 1] ==
 695                 PH_FRINFC_DESF_PICC_ADDI_FRAME_RESP) )
 696     {
 697         /*set the state*/
 698         NdefSmtCrdFmt->State = PH_FRINFC_DESF_STATE_GET_SW_VERSION;
 699
 700         /* Helper routine to wrap the native DESFire cmds*/
 701         phFriNfc_Desf_HWrapISONativeCmds(NdefSmtCrdFmt,PH_FRINFC_DESF_GET_SW_VERSION_CMD);
 702
 703         status = phFriNfc_Desf_HSendTransCmd(NdefSmtCrdFmt);
 704     }
 705     return status;
 706 }
 707
 708 static NFCSTATUS phFriNfc_Desf_HUpdateVersionDetails(phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt)
 709 {
 710     NFCSTATUS status = PHNFCSTVAL(CID_NFC_NONE,
 711                                 NFCSTATUS_SUCCESS);
 712
 713     if( ( NdefSmtCrdFmt->SendRecvBuf[*(NdefSmtCrdFmt->SendRecvLength)-
 714         PH_SMTCRDFMT_DESF_VAL1] ==  PH_FRINFC_DESF_PICC_ADDI_FRAME_RESP ) )
 715     {
 716         NdefSmtCrdFmt->AddInfo.Type4Info.MajorVersion = NdefSmtCrdFmt->SendRecvBuf[PH_SMTCRDFMT_DESF_VAL3];
 717         NdefSmtCrdFmt->AddInfo.Type4Info.MinorVersion = NdefSmtCrdFmt->SendRecvBuf[PH_SMTCRDFMT_DESF_VAL4];
 718
 719         if ((PH_FRINFC_DESF4_MAJOR_VERSION == NdefSmtCrdFmt->AddInfo.Type4Info.MajorVersion) &&
 720              (PH_FRINFC_DESF4_MINOR_VERSION == NdefSmtCrdFmt->AddInfo.Type4Info.MinorVersion))
 721         {
 722             /* card size of DESFire4 type */
 723             NdefSmtCrdFmt->AddInfo.Type4Info.CardSize = PH_FRINFC_DESF4_MEMORY_SIZE;
 724
 725         }
 726 #ifdef DESFIRE_FMT_EV1
 727         else if ((DESFIRE_EV1_SW_MAJOR_VERSION == NdefSmtCrdFmt->AddInfo.Type4Info.MajorVersion) &&
 728              (DESFIRE_EV1_SW_MINOR_VERSION == NdefSmtCrdFmt->AddInfo.Type4Info.MinorVersion))
 729         {
 730             NdefSmtCrdFmt->CardType = DESFIRE_CARD_TYPE_EV1;
 731         }
 732 #endif /* #ifdef DESFIRE_FMT_EV1 */
 733         else
 734         {
 735             // need to handle the Desfire8 type cards
 736             // need to use get free memory
 737             status = PHNFCSTVAL (CID_FRI_NFC_NDEF_SMTCRDFMT,
 738                                 NFCSTATUS_INVALID_REMOTE_DEVICE);
 739
 740         }
 741 #ifdef DESFIRE_FMT_EV1
 742         if (DESFIRE_CARD_TYPE_EV1 == NdefSmtCrdFmt->CardType)
 743         {
 744             switch (NdefSmtCrdFmt->SendRecvBuf[5])
 745             {
 746                 case DESFIRE_TAG_SIZE_IDENTIFIER_2K:
 747                 {
 748                     NdefSmtCrdFmt->AddInfo.Type4Info.CardSize = DESFIRE_2K_CARD;
 749                     break;
 750                 }
 751
 752                 case DESFIRE_TAG_SIZE_IDENTIFIER_4K:
 753                 {
 754                     NdefSmtCrdFmt->AddInfo.Type4Info.CardSize = DESFIRE_4K_CARD;
 755                     break;
 756                 }
 757
 758                 case DESFIRE_TAG_SIZE_IDENTIFIER_8K:
 759                 {
 760                     NdefSmtCrdFmt->AddInfo.Type4Info.CardSize = DESFIRE_8K_CARD;
 761                     break;
 762                 }
 763
 764                 default:
 765                 {
 766                     status = PHNFCSTVAL (CID_FRI_NFC_NDEF_SMTCRDFMT,
 767                                         NFCSTATUS_INVALID_REMOTE_DEVICE);
 768                     break;
 769                 }
 770             }
 771         }
 772 #endif /* #ifdef DESFIRE_FMT_EV1 */
 773     }
 774
 775     return status;
 776 }
 777
 778 static NFCSTATUS phFriNfc_Desf_HGetUIDDetails(phFriNfc_sNdefSmtCrdFmt_t * NdefSmtCrdFmt)
 779 {
 780
 781     NFCSTATUS status = NFCSTATUS_PENDING;
 782     if( ( NdefSmtCrdFmt->SendRecvBuf[*(NdefSmtCrdFmt->SendRecvLength)-
 783         PH_SMTCRDFMT_DESF_VAL1] ==  PH_FRINFC_DESF_PICC_ADDI_FRAME_RESP) )
 784     {
 785         /*set the state*/
 786         NdefSmtCrdFmt->State = PH_FRINFC_DESF_STATE_GET_UID;
 787
 788         /* Helper routine to wrap the native desfire cmds*/
 789         phFriNfc_Desf_HWrapISONativeCmds(NdefSmtCrdFmt,PH_FRINFC_DESF_GET_UID_CMD);
 790
 791         status = phFriNfc_Desf_HSendTransCmd(NdefSmtCrdFmt);
 792     }
 793
 794     return status;
 795
 796 }
 797
 798
 799 static NFCSTATUS phFriNfc_Desf_HCreateApp(phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt)
 800 {
 801     NFCSTATUS status = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
 802         NFCSTATUS_FORMAT_ERROR);
 803
 804     if ( (NdefSmtCrdFmt->SendRecvBuf[PH_SMTCRDFMT_DESF_VAL14] == PH_FRINFC_DESF_NAT_WRAP_FIRST_RESP_BYTE)
 805          && (NdefSmtCrdFmt->SendRecvBuf[PH_SMTCRDFMT_DESF_VAL15] == PH_FRINFC_DESF_NAT_WRAP_SEC_RESP_BYTE ))
 806     {
 807         /*set the state*/
 808         NdefSmtCrdFmt->State = PH_FRINFC_DESF_STATE_CREATE_AID;
 809
 810         /* Helper routine to wrap the native DESFire cmds*/
 811         phFriNfc_Desf_HWrapISONativeCmds(NdefSmtCrdFmt,PH_FRINFC_DESF_CREATEAPP_CMD);
 812
 813         status = phFriNfc_Desf_HSendTransCmd(NdefSmtCrdFmt);
 814     }
 815     return ( status);
 816 }
 817
 818
 819 static NFCSTATUS phFriNfc_Desf_HSelectApp(phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt)
 820 {
 821
 822     NFCSTATUS status = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
 823         NFCSTATUS_FORMAT_ERROR);
 824
 825     /* check for the response of previous operation, before
 826     issuing the next command*/
 827
 828     if ( (NdefSmtCrdFmt->SendRecvBuf[PH_SMTCRDFMT_DESF_VAL0] == PH_FRINFC_DESF_NAT_WRAP_FIRST_RESP_BYTE) &&
 829         (NdefSmtCrdFmt->SendRecvBuf[PH_SMTCRDFMT_DESF_VAL1] == PH_FRINFC_DESF_NAT_WRAP_SEC_RESP_BYTE ))
 830     {
 831         /*set the state*/
 832         NdefSmtCrdFmt->State = PH_FRINFC_DESF_STATE_SELECT_APP;
 833
 834         /* Helper routine to wrap the native DESFire cmds*/
 835         phFriNfc_Desf_HWrapISONativeCmds(NdefSmtCrdFmt,PH_FRINFC_DESF_SELECTAPP_CMD);
 836
 837         status = phFriNfc_Desf_HSendTransCmd(NdefSmtCrdFmt);
 838     }
 839     return ( status);
 840
 841 }
 842
 843 static NFCSTATUS phFriNfc_Desf_HCreatCCFile(phFriNfc_sNdefSmtCrdFmt_t    *NdefSmtCrdFmt)
 844 {
 845     NFCSTATUS status = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
 846         NFCSTATUS_FORMAT_ERROR);
 847
 848     if ( (NdefSmtCrdFmt->SendRecvBuf[PH_SMTCRDFMT_DESF_VAL0] == PH_FRINFC_DESF_NATIVE_RESP_BYTE1) &&
 849             (NdefSmtCrdFmt->SendRecvBuf[PH_SMTCRDFMT_DESF_VAL1] == PH_FRINFC_DESF_NATIVE_RESP_BYTE2 ))
 850     {
 851         /*set the state*/
 852         NdefSmtCrdFmt->State = PH_FRINFC_DESF_STATE_CREATE_CCFILE;
 853
 854         /* Helper routine to wrap the native DESFire cmds*/
 855         phFriNfc_Desf_HWrapISONativeCmds(NdefSmtCrdFmt,PH_FRINFC_DESF_CREATECC_CMD);
 856
 857         status = phFriNfc_Desf_HSendTransCmd(NdefSmtCrdFmt);
 858     }
 859     return ( status);
 860 }
 861
 862 static NFCSTATUS phFriNfc_Desf_HCreatNDEFFile(phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt)
 863 {
 864
 865     NFCSTATUS status = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
 866         NFCSTATUS_FORMAT_ERROR);
 867
 868     if ( (NdefSmtCrdFmt->SendRecvBuf[PH_SMTCRDFMT_DESF_VAL0] == PH_FRINFC_DESF_NATIVE_RESP_BYTE1) &&
 869             (NdefSmtCrdFmt->SendRecvBuf[PH_SMTCRDFMT_DESF_VAL1] == PH_FRINFC_DESF_NATIVE_RESP_BYTE2 ))
 870     {
 871         /*set the state*/
 872         NdefSmtCrdFmt->State = PH_FRINFC_DESF_STATE_CREATE_NDEFFILE;
 873
 874         /* Helper routine to wrap the native desfire cmds*/
 875         phFriNfc_Desf_HWrapISONativeCmds(NdefSmtCrdFmt,PH_FRINFC_DESF_CREATENDEF_CMD);
 876
 877         status = phFriNfc_Desf_HSendTransCmd(NdefSmtCrdFmt);
 878
 879     }
 880
 881     return ( status);
 882
 883 }
 884
 885 static NFCSTATUS phFriNfc_Desf_HWrCCBytes(phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt)
 886 {
 887
 888     NFCSTATUS result = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
 889         NFCSTATUS_FORMAT_ERROR);
 890     if ( (NdefSmtCrdFmt->SendRecvBuf[PH_SMTCRDFMT_DESF_VAL0] == PH_FRINFC_DESF_NATIVE_RESP_BYTE1) &&
 891             (NdefSmtCrdFmt->SendRecvBuf[PH_SMTCRDFMT_DESF_VAL1] == PH_FRINFC_DESF_NATIVE_RESP_BYTE2 ))
 892     {
 893
 894         /*set the state*/
 895         NdefSmtCrdFmt->State = PH_FRINFC_DESF_STATE_WRITE_CC_FILE;
 896
 897         /* Helper routine to wrap the native DESFire cmds*/
 898         phFriNfc_Desf_HWrapISONativeCmds(NdefSmtCrdFmt,PH_FRINFC_DESF_WRITECC_CMD);
 899
 900         result = phFriNfc_Desf_HSendTransCmd(NdefSmtCrdFmt);
 901     }
 902     return (result);
 903 }
 904
 905 static NFCSTATUS phFriNfc_Desf_HWrNDEFData(phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt)
 906 {
 907
 908     NFCSTATUS Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
 909         NFCSTATUS_FORMAT_ERROR);
 910
 911
 912     if ( (NdefSmtCrdFmt->SendRecvBuf[PH_SMTCRDFMT_DESF_VAL0] == PH_FRINFC_DESF_NATIVE_RESP_BYTE1) &&
 913             (NdefSmtCrdFmt->SendRecvBuf[PH_SMTCRDFMT_DESF_VAL1] == PH_FRINFC_DESF_NATIVE_RESP_BYTE2 ))
 914     {
 915         /*set the state*/
 916         NdefSmtCrdFmt->State = PH_FRINFC_DESF_STATE_WRITE_NDEF_FILE;
 917
 918         /* Helper routine to wrap the native DESFire cmds*/
 919         phFriNfc_Desf_HWrapISONativeCmds(NdefSmtCrdFmt,PH_FRINFC_DESF_WRITENDEF_CMD);
 920
 921         Result = phFriNfc_Desf_HSendTransCmd(NdefSmtCrdFmt);
 922     }
 923     return (Result);
 924 }
 925
 926 static NFCSTATUS phFriNfc_Desf_HSendTransCmd(phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt)
 927 {
 928
 929     NFCSTATUS status =  NFCSTATUS_SUCCESS;
 930
 931     /* set the command type*/
 932 #ifdef PH_HAL4_ENABLE
 933     NdefSmtCrdFmt->Cmd.Iso144434Cmd = phHal_eIso14443_4_Raw;
 934 #else
 935     NdefSmtCrdFmt->Cmd.Iso144434Cmd = phHal_eIso14443_4_CmdListTClCmd;
 936 #endif /* #ifdef PH_HAL4_ENABLE */
 937
 938     /* set the Additional Info*/
 939     NdefSmtCrdFmt->psDepAdditionalInfo.DepFlags.MetaChaining = 0;
 940     NdefSmtCrdFmt->psDepAdditionalInfo.DepFlags.NADPresent = 0;
 941
 942     /*set the completion routines for the desfire card operations*/
 943     NdefSmtCrdFmt->SmtCrdFmtCompletionInfo.CompletionRoutine = phFriNfc_NdefSmtCrd_Process;
 944     NdefSmtCrdFmt->SmtCrdFmtCompletionInfo.Context = NdefSmtCrdFmt;
 945
 946     /* set the receive length */
 947     *NdefSmtCrdFmt->SendRecvLength = PH_FRINFC_SMTCRDFMT_MAX_SEND_RECV_BUF_SIZE;
 948
 949
 950     /*Call the Overlapped HAL Transceive function */
 951     status = phFriNfc_OvrHal_Transceive(NdefSmtCrdFmt->LowerDevice,
 952         &NdefSmtCrdFmt->SmtCrdFmtCompletionInfo,
 953         NdefSmtCrdFmt->psRemoteDevInfo,
 954         NdefSmtCrdFmt->Cmd,
 955         &NdefSmtCrdFmt->psDepAdditionalInfo,
 956         NdefSmtCrdFmt->SendRecvBuf,
 957         NdefSmtCrdFmt->SendLength,
 958         NdefSmtCrdFmt->SendRecvBuf,
 959         NdefSmtCrdFmt->SendRecvLength);
 960
 961     return (status);
 962
 963
 964 }
 965
 966 NFCSTATUS phFriNfc_Desfire_Format(phFriNfc_sNdefSmtCrdFmt_t    *NdefSmtCrdFmt)
 967 {
 968
 969     NFCSTATUS status =  NFCSTATUS_SUCCESS;
 970 #ifdef DESFIRE_FMT_EV1
 971     NdefSmtCrdFmt->CardType = 0;
 972 #endif /* #ifdef DESFIRE_FMT_EV1 */
 973     status =  phFriNfc_Desf_HGetHWVersion(NdefSmtCrdFmt);
 974     return (status);
 975 }
 976
 977 #ifdef FRINFC_READONLY_NDEF
 978
 979 #if 0
 980 static
 981 NFCSTATUS
 982 phFriNfc_Desf_HReadOnlySelectCCFile (
 983     phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt)
 984 {
 985     NFCSTATUS result = NFCSTATUS_SUCCESS;
 986     return result;
 987 }
 988 #endif /* #if 0 */
 989
 990 static
 991 NFCSTATUS
 992 phFriNfc_Desf_HReadOnlyReadCCFile (
 993     phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt)
 994 {
 995     NFCSTATUS       result = NFCSTATUS_SUCCESS;
 996     uint16_t        i = 0;
 997
 998     if ((PH_FRINFC_DESF_NATIVE_RESP_BYTE1 ==
 999         NdefSmtCrdFmt->SendRecvBuf[(*NdefSmtCrdFmt->SendRecvLength - 2)])
1000         && (PH_FRINFC_DESF_NATIVE_RESP_BYTE2 ==
1001         NdefSmtCrdFmt->SendRecvBuf[(*NdefSmtCrdFmt->SendRecvLength - 1)]))
1002     {
1003         NdefSmtCrdFmt->State = PH_FRINFC_DESF_STATE_RO_READ_CC_FILE;
1004
1005         /* Class Byte */
1006         NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_NATIVE_CLASS_BYTE;
1007         i++;
1008
1009         /* let the place to store the cmd byte type, point to next index
1010             Instruction Cmd code */
1011         NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_READ_DATA_CMD;
1012         i++;
1013
1014
1015         /* P1/P2 offsets always set to zero */
1016         NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_NATIVE_OFFSET_P1;
1017         i++;
1018         NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_NATIVE_OFFSET_P2;
1019         i++;
1020
1021         /*  Lc: Length of wrapped data */
1022         NdefSmtCrdFmt->SendRecvBuf[i] = NATIVE_WRAPPER_READ_DATA_LC_VALUE;
1023         i++;
1024
1025 #ifdef DESFIRE_FMT_EV1
1026         if (DESFIRE_CARD_TYPE_EV1 == NdefSmtCrdFmt->CardType)
1027         {
1028             /* set the file id*/
1029             NdefSmtCrdFmt->SendRecvBuf[i] = DESFIRE_EV1_CC_FILE_ID;
1030             i++;
1031         }
1032         else
1033 #endif /* #ifdef DESFIRE_FMT_EV1 */
1034         {
1035             /* set the file id*/
1036             NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_CC_FILE_ID;
1037             i++;
1038         }
1039
1040         /* set the offset to zero*/
1041         NdefSmtCrdFmt->SendRecvBuf[i] = 0x00;
1042         i++;
1043         NdefSmtCrdFmt->SendRecvBuf[i] = 0x00;
1044         i++;
1045         NdefSmtCrdFmt->SendRecvBuf[i] = 0x00;
1046         i++;
1047
1048         /* Set the length of data available to read */
1049         NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_CC_FILE_SIZE;
1050         i++;
1051         NdefSmtCrdFmt->SendRecvBuf[i] = 0x00;
1052         i++;
1053         NdefSmtCrdFmt->SendRecvBuf[i] = 0x00;
1054         i++;
1055
1056         /* Le Value is set 0 */
1057         NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_NATIVE_LE_BYTE;
1058         i++;
1059
1060         NdefSmtCrdFmt->SendLength = i;
1061
1062         result = phFriNfc_Desf_HSendTransCmd (NdefSmtCrdFmt);
1063     }
1064     else
1065     {
1066         result = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
1067                             NFCSTATUS_FORMAT_ERROR);
1068     }
1069
1070     return result;
1071 }
1072
1073 static
1074 NFCSTATUS
1075 phFriNfc_Desf_HReadOnlyWriteCCFile (
1076     phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt)
1077 {
1078     NFCSTATUS   result = NFCSTATUS_SUCCESS;
1079     uint8_t     read_cc_btyes[CC_BYTES_SIZE] = {0};
1080     uint16_t    i = 0;
1081
1082     if ((PH_FRINFC_DESF_NATIVE_RESP_BYTE1 ==
1083         NdefSmtCrdFmt->SendRecvBuf[(*NdefSmtCrdFmt->SendRecvLength - 2)])
1084         && (PH_FRINFC_DESF_NATIVE_RESP_BYTE2 ==
1085         NdefSmtCrdFmt->SendRecvBuf[(*NdefSmtCrdFmt->SendRecvLength - 1)]))
1086     {
1087         NdefSmtCrdFmt->State = PH_FRINFC_DESF_STATE_RO_UPDATE_CC_FILE;
1088
1089         memcpy ((void *)read_cc_btyes, (void *)NdefSmtCrdFmt->SendRecvBuf,
1090                 sizeof (read_cc_btyes));
1091         read_cc_btyes[(sizeof (read_cc_btyes) - 1)] = READ_ONLY_NDEF_DESFIRE;
1092
1093         /* Class Byte */
1094         NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_NATIVE_CLASS_BYTE;
1095         i++;
1096
1097         /* let the place to store the cmd byte type, point to next index
1098             Instruction Cmd code */
1099         NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_WRITE_CMD;
1100         i++;
1101
1102
1103         /* P1/P2 offsets always set to zero */
1104         NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_NATIVE_OFFSET_P1;
1105         i++;
1106         NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_NATIVE_OFFSET_P2;
1107         i++;
1108
1109         /*  Lc: Length of wrapped data */
1110         NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_NATIVE_WRCC_WRDT_LEN;
1111         i++;
1112
1113 #ifdef DESFIRE_FMT_EV1
1114         if (DESFIRE_CARD_TYPE_EV1 == NdefSmtCrdFmt->CardType)
1115         {
1116             /* set the file id*/
1117             NdefSmtCrdFmt->SendRecvBuf[i] = DESFIRE_EV1_CC_FILE_ID;
1118             i++;
1119         }
1120         else
1121 #endif /* #ifdef DESFIRE_FMT_EV1 */
1122         {
1123             /* set the file id*/
1124             NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_CC_FILE_ID;
1125             i++;
1126         }
1127
1128         /* set the offset to zero*/
1129         NdefSmtCrdFmt->SendRecvBuf[i] = 0x00;
1130         i++;
1131         NdefSmtCrdFmt->SendRecvBuf[i] = 0x00;
1132         i++;
1133         NdefSmtCrdFmt->SendRecvBuf[i] = 0x00;
1134         i++;
1135
1136         /* Set the length of data available to write*/
1137         NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_CC_FILE_SIZE;
1138         i++;
1139         NdefSmtCrdFmt->SendRecvBuf[i] = 0x00;
1140         i++;
1141         NdefSmtCrdFmt->SendRecvBuf[i] = 0x00;
1142         i++;
1143
1144         /*set the data to be written to the CC file*/
1145         (void)memcpy ((void *)&NdefSmtCrdFmt->SendRecvBuf[i],
1146                     (void *)read_cc_btyes, sizeof (read_cc_btyes));
1147 #ifdef DESFIRE_FMT_EV1
1148 #else
1149         i++;
1150 #endif /* #ifdef DESFIRE_FMT_EV1 */
1151
1152         i = (uint16_t)(i + sizeof (read_cc_btyes));
1153
1154         /* Le bytes*/
1155         NdefSmtCrdFmt->SendRecvBuf[i] = PH_FRINFC_DESF_NATIVE_LE_BYTE;
1156         i++;
1157 #ifdef DESFIRE_FMT_EV1
1158         if (DESFIRE_CARD_TYPE_EV1 == NdefSmtCrdFmt->CardType)
1159         {
1160             NdefSmtCrdFmt->SendLength = i;
1161         }
1162         else
1163 #endif /* #ifdef DESFIRE_FMT_EV1 */
1164         {
1165             NdefSmtCrdFmt->SendLength = PH_FRINFC_DESF_WRITECC_CMD_SNLEN;
1166         }
1167
1168         result = phFriNfc_Desf_HSendTransCmd (NdefSmtCrdFmt);
1169     }
1170     else
1171     {
1172         result = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
1173                             NFCSTATUS_FORMAT_ERROR);
1174     }
1175
1176     return result;
1177 }
1178
1179 static
1180 NFCSTATUS
1181 phFriNfc_Desf_HReadOnlySelectApp (
1182     phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt)
1183 {
1184     NFCSTATUS result = NFCSTATUS_SUCCESS;
1185
1186     NdefSmtCrdFmt->CardType = 0;
1187
1188     NdefSmtCrdFmt->State = PH_FRINFC_DESF_STATE_RO_SELECT_APP;
1189
1190     /* Helper routine to wrap the native DESFire cmds */
1191     phFriNfc_Desf_HWrapISONativeCmds (NdefSmtCrdFmt, PH_FRINFC_DESF_SELECTAPP_CMD);
1192
1193     result = phFriNfc_Desf_HSendTransCmd (NdefSmtCrdFmt);
1194
1195     return result;
1196 }
1197
1198 #ifdef DESFIRE_FMT_EV1
1199 static
1200 NFCSTATUS
1201 phFriNfc_Desf_HReadOnlySelectAppEV1 (
1202     phFriNfc_sNdefSmtCrdFmt_t *NdefSmtCrdFmt)
1203 {
1204     NFCSTATUS result = NFCSTATUS_SUCCESS;
1205
1206     NdefSmtCrdFmt->CardType = DESFIRE_CARD_TYPE_EV1;
1207
1208     NdefSmtCrdFmt->State = PH_FRINFC_DESF_STATE_RO_SELECT_APP_EV1;
1209
1210     /* Helper routine to wrap the native DESFire cmds */
1211     phFriNfc_Desf_HWrapISONativeCmds (NdefSmtCrdFmt, PH_FRINFC_DESF_SELECTAPP_CMD);
1212
1213     result = phFriNfc_Desf_HSendTransCmd (NdefSmtCrdFmt);
1214
1215     return result;
1216 }
1217 #endif /* #ifdef DESFIRE_FMT_EV1 */
1218
1219 NFCSTATUS
1220 phFriNfc_Desfire_ConvertToReadOnly (
1221     phFriNfc_sNdefSmtCrdFmt_t   *NdefSmtCrdFmt)
1222 {
1223     NFCSTATUS result = NFCSTATUS_SUCCESS;
1224
1225 #ifdef DESFIRE_FMT_EV1
1226     result = phFriNfc_Desf_HReadOnlySelectAppEV1 (NdefSmtCrdFmt);
1227 #else
1228     result = phFriNfc_Desf_HReadOnlySelectApp (NdefSmtCrdFmt);
1229 #endif /* #ifdef DESFIRE_FMT_EV1 */
1230
1231     return result;
1232 }
1233
1234 #endif /* #ifdef FRINFC_READONLY_NDEF */
1235
1236 void phFriNfc_Desf_Process( void       *Context,
1237                            NFCSTATUS   Status)
1238 {
1239
1240     phFriNfc_sNdefSmtCrdFmt_t      *NdefSmtCrdFmt;
1241
1242     NdefSmtCrdFmt = (phFriNfc_sNdefSmtCrdFmt_t *)Context;
1243
1244     if((NFCSTATUS_SUCCESS & PHNFCSTBLOWER) == (Status & PHNFCSTBLOWER))
1245     {
1246         switch(NdefSmtCrdFmt->State)
1247         {
1248 #ifdef FRINFC_READONLY_NDEF
1249 #ifdef DESFIRE_FMT_EV1
1250             case PH_FRINFC_DESF_STATE_RO_SELECT_APP_EV1:
1251             {
1252                 if ((PH_FRINFC_DESF_NATIVE_RESP_BYTE1 ==
1253                     NdefSmtCrdFmt->SendRecvBuf[(*NdefSmtCrdFmt->SendRecvLength - 2)])
1254                     && (PH_FRINFC_DESF_NATIVE_RESP_BYTE2 ==
1255                     NdefSmtCrdFmt->SendRecvBuf[(*NdefSmtCrdFmt->SendRecvLength - 1)]))
1256                 {
1257                     Status = phFriNfc_Desf_HReadOnlyReadCCFile (NdefSmtCrdFmt);
1258                 }
1259                 else
1260                 {
1261                     Status = phFriNfc_Desf_HReadOnlySelectApp (NdefSmtCrdFmt);
1262                 }
1263                 break;
1264             }
1265 #endif /* #ifdef DESFIRE_FMT_EV1 */
1266
1267             case PH_FRINFC_DESF_STATE_RO_SELECT_APP:
1268             {
1269                 Status = phFriNfc_Desf_HReadOnlyReadCCFile (NdefSmtCrdFmt);
1270                 break;
1271             }
1272
1273             case PH_FRINFC_DESF_STATE_RO_READ_CC_FILE:
1274             {
1275                 Status = phFriNfc_Desf_HReadOnlyWriteCCFile (NdefSmtCrdFmt);
1276                 break;
1277             }
1278
1279             case PH_FRINFC_DESF_STATE_RO_UPDATE_CC_FILE:
1280             {
1281                 if ((PH_FRINFC_DESF_NATIVE_RESP_BYTE1 ==
1282                     NdefSmtCrdFmt->SendRecvBuf[(*NdefSmtCrdFmt->SendRecvLength - 2)])
1283                     && (PH_FRINFC_DESF_NATIVE_RESP_BYTE2 ==
1284                     NdefSmtCrdFmt->SendRecvBuf[(*NdefSmtCrdFmt->SendRecvLength - 1)]))
1285                 {
1286                     /* SUCCESSFULL Formatting */
1287 #ifdef DESFIRE_FMT_EV1
1288                     if (DESFIRE_CARD_TYPE_EV1 == NdefSmtCrdFmt->CardType)
1289                     {
1290                         Status = phFriNfc_OvrHal_Reconnect (
1291                                                 NdefSmtCrdFmt->LowerDevice,
1292                                                 &NdefSmtCrdFmt->SmtCrdFmtCompletionInfo,
1293                                                 NdefSmtCrdFmt->psRemoteDevInfo);
1294
1295                         if (NFCSTATUS_PENDING == Status)
1296                         {
1297                             NdefSmtCrdFmt->State = PH_FRINFC_DESF_STATE_REACTIVATE;
1298                         }
1299                     }
1300 #endif /* #ifdef DESFIRE_FMT_EV1 */
1301                 }
1302                 else
1303                 {
1304                     Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_SMTCRDFMT,
1305                                         NFCSTATUS_FORMAT_ERROR);
1306                 }
1307                 break;
1308             }
1309
1310 #endif /* #ifdef FRINFC_READONLY_NDEF */
1311             case PH_FRINFC_DESF_STATE_GET_HW_VERSION:
1312             {
1313                 /* Check and store the h/w and s/w specific details.
1314                     Ex: Major/Minor version, memory storage info. */
1315
1316                 Status = phFriNfc_Desf_HGetSWVersion (NdefSmtCrdFmt);
1317
1318                 break;
1319             }
1320
1321             case PH_FRINFC_DESF_STATE_GET_SW_VERSION:
1322             {
1323                 /* Check and store the h/w and s/w specific details.
1324                     Ex: Major/Minor version, memory storage info. */
1325
1326                 Status = phFriNfc_Desf_HUpdateVersionDetails (NdefSmtCrdFmt);
1327                 if ( Status == NFCSTATUS_SUCCESS )
1328                 {
1329                     Status = phFriNfc_Desf_HGetUIDDetails (NdefSmtCrdFmt);
1330                 }
1331                 break;
1332             }
1333
1334             case PH_FRINFC_DESF_STATE_GET_UID:
1335             {
1336                 Status = phFriNfc_Desf_HCreateApp (NdefSmtCrdFmt);
1337                 break;
1338             }
1339
1340             case PH_FRINFC_DESF_STATE_CREATE_AID:
1341             {
1342                 Status = phFriNfc_Desf_HSelectApp (NdefSmtCrdFmt);
1343                 break;
1344             }
1345
1346             case PH_FRINFC_DESF_STATE_SELECT_APP:
1347             {
1348                 Status = phFriNfc_Desf_HCreatCCFile (NdefSmtCrdFmt);
1349                 break;
1350             }
1351
1352             case PH_FRINFC_DESF_STATE_CREATE_CCFILE:
1353             {
1354                 Status = phFriNfc_Desf_HCreatNDEFFile (NdefSmtCrdFmt);
1355                 break;
1356             }
1357
1358             case PH_FRINFC_DESF_STATE_CREATE_NDEFFILE:
1359             {
1360                 Status = phFriNfc_Desf_HWrCCBytes (NdefSmtCrdFmt);
1361                 break;
1362             }
1363
1364             case PH_FRINFC_DESF_STATE_WRITE_CC_FILE:
1365             {
1366                 Status = phFriNfc_Desf_HWrNDEFData (NdefSmtCrdFmt);
1367                 break;
1368             }
1369
1370             case PH_FRINFC_DESF_STATE_WRITE_NDEF_FILE:
1371             {
1372                 if ((PH_FRINFC_DESF_NATIVE_RESP_BYTE1 ==
1373                     NdefSmtCrdFmt->SendRecvBuf[PH_SMTCRDFMT_DESF_VAL0]) &&
1374                     (PH_FRINFC_DESF_NATIVE_RESP_BYTE2 ==
1375                     NdefSmtCrdFmt->SendRecvBuf[PH_SMTCRDFMT_DESF_VAL1]))
1376                 {
1377                     NdefSmtCrdFmt->CardState = 0;
1378 #ifdef DESFIRE_FMT_EV1
1379                     if (DESFIRE_CARD_TYPE_EV1 == NdefSmtCrdFmt->CardType)
1380                     {
1381                         Status = phFriNfc_OvrHal_Reconnect (
1382                                                 NdefSmtCrdFmt->LowerDevice,
1383                                                 &NdefSmtCrdFmt->SmtCrdFmtCompletionInfo,
1384                                                 NdefSmtCrdFmt->psRemoteDevInfo);
1385
1386                         if (NFCSTATUS_PENDING == Status)
1387                         {
1388                             NdefSmtCrdFmt->State = PH_FRINFC_DESF_STATE_REACTIVATE;
1389                         }
1390                     }
1391                     else
1392 #endif /* #ifdef DESFIRE_FMT_EV1 */
1393                     {
1394                         Status = PHNFCSTVAL (CID_NFC_NONE, NFCSTATUS_SUCCESS);
1395                     }
1396                 }
1397                 break;
1398             }
1399
1400 #ifdef DESFIRE_FMT_EV1
1401             case PH_FRINFC_DESF_STATE_REACTIVATE:
1402             {
1403                 /* Do nothing */
1404                 break;
1405             }
1406 #endif /* #ifdef DESFIRE_FMT_EV1 */
1407
1408             default:
1409             {
1410                 /*set the invalid state*/
1411                 Status = PHNFCSTVAL (CID_FRI_NFC_NDEF_SMTCRDFMT,
1412                                     NFCSTATUS_INVALID_DEVICE_REQUEST);
1413                 break;
1414             }
1415         }
1416     }
1417     /* Handle the all the error cases*/
1418     if ((NFCSTATUS_PENDING & PHNFCSTBLOWER) != (Status & PHNFCSTBLOWER))
1419     {
1420         /* call respective CR */
1421         phFriNfc_SmtCrdFmt_HCrHandler(NdefSmtCrdFmt,Status);
1422     }
1423
1424 }
1425