csctapi/icc_async.c

   1 #include "../globals.h"
   2 #ifdef WITH_CARDREADER
   3 #include "../oscam-lock.h"
   4 #include "../oscam-string.h"
   5 #include "icc_async.h"
   6 #include "protocol_t0.h"
   7 #include "io_serial.h"
   8 #include "ifd_phoenix.h"
   9 #include "../oscam-time.h"
  10 #ifdef READER_NAGRA_MERLIN
  11 #include "../cscrypt/fast_aes.h"
  12 #include "../cscrypt/sha256.h"
  13 #include "../cscrypt/mdc2.h"
  14 #include "../cscrypt/idea.h"
  15 #endif
  16
  17 #define OK 0
  18 #define ERROR 1
  19
  20 // Default T0/T14 settings
  21 #define DEFAULT_WI              10
  22 // Default T1 settings
  23 #define DEFAULT_IFSC    32
  24 #define MAX_IFSC                251 // Cannot send > 255 buffer
  25 #define DEFAULT_CWI             13
  26 #define DEFAULT_BWI             4
  27 #define EDC_LRC                 0
  28
  29 #define PPS_MAX_LENGTH  6
  30 #define PPS_HAS_PPS1(block) ((block[1] & 0x10) == 0x10)
  31 #define PPS_HAS_PPS2(block) ((block[1] & 0x20) == 0x20)
  32 #define PPS_HAS_PPS3(block) ((block[1] & 0x40) == 0x40)
  33
  34 static uint16_t tempfi; // used to capture FI and use it for rounding or not
  35 static void ICC_Async_InvertBuffer(struct s_reader *reader, uint32_t size, unsigned char *buffer);
  36 static int32_t Parse_ATR(struct s_reader *reader, ATR *atr, uint16_t deprecated);
  37 static int32_t PPS_Exchange(struct s_reader *reader, unsigned char *params, uint32_t *length);
  38 static uint32_t PPS_GetLength(unsigned char *block);
  39 static int32_t InitCard(struct s_reader *reader, ATR *atr, unsigned char FI, uint32_t D, unsigned char N, uint16_t deprecated);
  40 static uint32_t ETU_to_us(struct s_reader *reader, uint32_t ETU);
  41 static unsigned char PPS_GetPCK(unsigned char *block, uint32_t length);
  42 static int32_t SetRightParity(struct s_reader *reader);
  43
  44 #ifdef READER_NAGRA_MERLIN
  45 static void calculate_cak7_vars(struct s_reader *reader, const ATR *atr)
  46 {
  47         uint8_t aes_key[32];
  48         const uint8_t aes_iv[] = { 0x4E, 0x61, 0x67, 0x72, 0x61, 0x63, 0x61, 0x72, 0x64, 0x28, 0x63, 0x29, 0x32, 0x30, 0x30, 0x36 }; // Nagracard(c)2006
  49         mbedtls_sha256_context ctx_sha256;
  50         mbedtls_sha256_init(&ctx_sha256);
  51         mbedtls_sha256_starts(&ctx_sha256, 0);
  52         mbedtls_sha256_update(&ctx_sha256, atr->hb, atr->hbn);
  53         mbedtls_sha256_finish(&ctx_sha256, aes_key);
  54         mbedtls_sha256_free(&ctx_sha256);
  55         memcpy(reader->cak7_aes_key,aes_key,32);
  56         memcpy(reader->cak7_aes_iv,aes_iv,16);
  57         char tmp[128];
  58         rdr_log(reader, "Initial AES: %s", cs_hexdump(1, reader->cak7_aes_key + 16, 16, tmp, sizeof(tmp)));
  59 }
  60
  61 void calculate_cak7_cmd(struct s_reader *reader, uint8_t *cmdin,uint8_t cmdlen,uint8_t *cmdout)
  62 {
  63         uint32_t crc = ccitt32_crc(cmdin+4, cmdlen-4);
  64         i2b_buf(4, crc, cmdin);
  65         AesCtx ctx;
  66         AesCtxIni(&ctx, reader->cak7_aes_iv, &reader->cak7_aes_key[16], KEY128, CBC);
  67         AesEncrypt(&ctx, cmdin, cmdout, cmdlen);
  68 }
  69
  70 void do_cak7_cmd(struct s_reader *reader,unsigned char *cta_res, uint16_t *p_cta_lr,uint8_t *data,uint8_t inlen,uint8_t resplen)
  71 {
  72         reader->cak7_seq++;
  73
  74         uint8_t req[inlen+5+1]; // +head+len
  75         memset(req,0x00,sizeof(req));
  76         // head
  77         req[0]=0x80;
  78         req[1]=0xCA;
  79         if(reader->protocol_type == ATR_PROTOCOL_TYPE_T0)
  80         {
  81                 req[4]=inlen + 1;
  82         }
  83         else
  84         {
  85                 req[4]=inlen;
  86         }
  87         req[sizeof(req)-1]=resplen;
  88         data[4]=(reader->cak7_seq>>16)&0xFF;
  89         data[5]=(reader->cak7_seq>>8)&0xFF;
  90         data[6]=(reader->cak7_seq)&0xFF;
  91         calculate_cak7_cmd(reader,data,inlen,&req[5]);
  92         if(!ICC_Async_CardWrite(reader, req, sizeof(req), cta_res, p_cta_lr))
  93         {
  94                 if(reader->protocol_type == ATR_PROTOCOL_TYPE_T0)
  95                 {
  96                         if(cta_res[*p_cta_lr - 2] == 0x61)
  97                         {
  98                                 uint8_t resp[] = {0x00,0xC0,0x00,0x00,0x00};
  99                                 memcpy(resp + 4,&cta_res[*p_cta_lr - 1],1);
 100                                 if(!ICC_Async_CardWrite(reader, resp, sizeof(resp), cta_res, p_cta_lr))
 101                                 {
 102                                         AesCtx ctx;
 103                                         AesCtxIni(&ctx, reader->cak7_aes_iv, &reader->cak7_aes_key[16], KEY128, CBC);
 104                                         AesDecrypt(&ctx, cta_res, cta_res, *p_cta_lr-2);
 105                                 }
 106                                 else
 107                                 {
 108                                         *p_cta_lr=0;
 109                                 }
 110                         }
 111                         else if(cta_res[*p_cta_lr - 2] == 0x6F && cta_res[*p_cta_lr - 1] == 0x01)
 112                         {
 113                                 rdr_log(reader, "card answered 6F01 - trying one more time");
 114                                 if(!ICC_Async_CardWrite(reader, req, sizeof(req), cta_res, p_cta_lr))
 115                                 {
 116                                         if(cta_res[*p_cta_lr - 2]  == 0x61)
 117                                         {
 118                                                 uint8_t resp[] = {0x00,0xC0,0x00,0x00,0x00};
 119                                                 memcpy(resp + 4,&cta_res[*p_cta_lr - 1],1);
 120                                                 if(!ICC_Async_CardWrite(reader, resp, sizeof(resp), cta_res, p_cta_lr))
 121                                                 {
 122                                                         AesCtx ctx;
 123                                                         AesCtxIni(&ctx, reader->cak7_aes_iv, &reader->cak7_aes_key[16], KEY128, CBC);
 124                                                         AesDecrypt(&ctx, cta_res, cta_res, *p_cta_lr-2);
 125                                                 }
 126                                                 else
 127                                                 {
 128                                                         *p_cta_lr=0;
 129                                                 }
 130                                         }
 131                                         else if(cta_res[*p_cta_lr - 2]  == 0x6F && cta_res[*p_cta_lr - 1] == 0x01)
 132                                         {
 133                                                 rdr_log(reader, "card needs reinit");
 134                                         }
 135                                 }
 136                                 else
 137                                 {
 138                                         *p_cta_lr=0;
 139                                 }
 140                         }
 141                 }
 142                 else
 143                 {
 144                         if(cta_res[*p_cta_lr - 2] == 0x6F && cta_res[*p_cta_lr - 1] == 0x01)
 145                         {
 146                                 rdr_log(reader, "card answered 6F01 - trying one more time");
 147                                 if(!ICC_Async_CardWrite(reader, req, sizeof(req), cta_res, p_cta_lr))
 148                                 {
 149                                         if(cta_res[*p_cta_lr - 2] == 0x6F && cta_res[*p_cta_lr - 1] == 0x01)
 150                                         {
 151                                                 rdr_log(reader, "card needs reinit");
 152                                         }
 153                                         else
 154                                         {
 155                                                 AesCtx ctx;
 156                                                 AesCtxIni(&ctx, reader->cak7_aes_iv, &reader->cak7_aes_key[16], KEY128, CBC);
 157                                                 AesDecrypt(&ctx, cta_res, cta_res, *p_cta_lr-2);
 158                                         }
 159                                 }
 160                                 else
 161                                 {
 162                                         *p_cta_lr=0;
 163                                 }
 164                         }
 165                         else
 166                         {
 167                                 AesCtx ctx;
 168                                 AesCtxIni(&ctx, reader->cak7_aes_iv, &reader->cak7_aes_key[16], KEY128, CBC);
 169                                 AesDecrypt(&ctx, cta_res, cta_res, *p_cta_lr-2);
 170                         }
 171                 }
 172         }
 173         else
 174         {
 175                 *p_cta_lr=0;
 176         }
 177 }
 178
 179 static void calculate_changerom_cmd(struct s_reader *reader, const ATR *atr, uint8_t *cmd)
 180 {
 181         uint8_t cmd_data[] = { 0xCC, 0xCC, 0xCC, 0xCC, 0x00, 0x00, 0x01, 0x01, 0x01, 0x95, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC };
 182         calculate_cak7_vars(reader,atr);
 183         calculate_cak7_cmd(reader,cmd_data,sizeof(cmd_data),cmd);
 184 }
 185 #endif
 186
 187 int32_t ICC_Async_Device_Init(struct s_reader *reader)
 188 {
 189         const struct s_cardreader *crdr_ops = reader->crdr;
 190         if (!crdr_ops) return ERROR;
 191         reader->fdmc = -1;
 192         rdr_log_dbg(reader, D_IFD, "Opening device %s", reader->device);
 193         reader->written = 0;
 194         int32_t ret = crdr_ops->reader_init(reader);
 195         if(ret == OK)
 196         {
 197                 rdr_log_dbg(reader, D_IFD, "Device %s successfully opened", reader->device);
 198         }
 199         else
 200         {
 201                 if(reader->typ != R_SC8in1)
 202                 {
 203                         NULLFREE(reader->crdr_data);
 204                 }
 205                 rdr_log_dbg(reader, D_IFD, "ERROR: Can't open %s device", reader->device);
 206         }
 207         return ret;
 208 }
 209
 210 int32_t ICC_Async_Init_Locks(void)
 211 {
 212         // Init device specific locks here, called from init thread
 213         // before reader threads are running
 214         struct s_reader *rdr;
 215         LL_ITER itr = ll_iter_create(configured_readers);
 216         while((rdr = ll_iter_next(&itr)))
 217         {
 218                 const struct s_cardreader *crdr_ops = rdr->crdr;
 219                 if (!crdr_ops || !crdr_ops->lock_init) continue;
 220                 crdr_ops->lock_init(rdr);
 221         }
 222         return OK;
 223 }
 224
 225 int32_t ICC_Async_GetStatus(struct s_reader *reader, int32_t *card)
 226 {
 227         const struct s_cardreader *crdr_ops = reader->crdr;
 228         if (!crdr_ops)
 229         {
 230                 return ERROR;
 231         }
 232         if (reader->typ == R_SMART && reader->smartdev_found >= 4)
 233         {
 234                 reader->statuscnt = reader->statuscnt + 1;
 235                 if (reader->statuscnt == 6)
 236                 {
 237                         int32_t in = 0;
 238                         call(crdr_ops->get_status(reader, &in));
 239                         if(in)
 240                         {
 241                                 reader->modemstat = 1;
 242                                 *card = 1;
 243                                 reader->statuscnt = 0;
 244                         }
 245                         else
 246                         {
 247                                 reader->modemstat = 0;
 248                                 *card = 0;
 249                                 reader->statuscnt = 0;
 250                         }
 251                         return OK;
 252                 }
 253                 else
 254                 {
 255                         *card = reader->modemstat;
 256                         return OK;
 257                 }
 258         }
 259         else
 260         {
 261                 int32_t in = 0;
 262                 call(crdr_ops->get_status(reader, &in));
 263                 if(in)
 264                 {
 265                         *card = 1;
 266                 }
 267                 else
 268                 {
 269                         *card = 0;
 270                 }
 271                 return OK;
 272         }
 273
 274 }
 275
 276 int32_t ICC_Async_Activate(struct s_reader *reader, ATR *atr, uint16_t deprecated)
 277 {
 278         rdr_log_dbg(reader, D_IFD, "Activating card");
 279         const struct s_cardreader *crdr_ops = reader->crdr;
 280         if (!crdr_ops) return ERROR;
 281         reader->current_baudrate = DEFAULT_BAUDRATE;
 282         if(reader->atr[0] != 0 && !reader->ins7e11_fast_reset)
 283         {
 284                 rdr_log(reader, "Using ATR from reader config");
 285                 ATR_InitFromArray(atr, reader->atr, ATR_MAX_SIZE);
 286         }
 287         else
 288         {
 289                 reader->crdr_flush = crdr_ops->flush; // Flush flag may be changed for each reader
 290                 call(crdr_ops->activate(reader, atr));
 291                 if(crdr_ops->skip_extra_atr_parsing)
 292                 {
 293                         return OK;
 294                 }
 295         }
 296
 297         uint8_t atrarr[ATR_MAX_SIZE];
 298         uint32_t atr_size;
 299         ATR_GetRaw(atr, atrarr, &atr_size);
 300         char tmp[atr_size * 3 + 1];
 301         rdr_log(reader, "ATR: %s", cs_hexdump(1, atrarr, atr_size, tmp, sizeof(tmp)));
 302         memcpy(reader->card_atr, atrarr, atr_size);
 303         reader->card_atr_length = atr_size;
 304
 305         // Get ICC reader->convention
 306         if(ATR_GetConvention(atr, &(reader->convention)) != ATR_OK)
 307         {
 308                 rdr_log(reader, "ERROR: Could not read reader->convention");
 309                 reader->convention = 0;
 310                 reader->protocol_type = 0;
 311                 return ERROR;
 312         }
 313         reader->protocol_type = ATR_PROTOCOL_TYPE_T0;
 314
 315         // Parse_ATR and InitCard need to be included in lock because they change parity of serial port
 316         if(crdr_ops->lock)
 317         {
 318                 crdr_ops->lock(reader);
 319         }
 320         int32_t ret = Parse_ATR(reader, atr, deprecated);
 321         if(crdr_ops->unlock)
 322         {
 323                 crdr_ops->unlock(reader);
 324         }
 325         if(ret)
 326         {
 327                 rdr_log(reader, "ERROR: Parse_ATR returned error");
 328                 return ERROR;
 329         }
 330
 331         reader->cak7type = 0;
 332 #ifdef READER_NAGRA_MERLIN
 333
 334         ATR_GetRaw(atr, atrarr, &atr_size);
 335
 336         if((memcmp(atrarr + 8, "DNASP40", 7) == 0) || (memcmp(atrarr + 11, "DNASP41", 7) == 0) || (memcmp(atrarr + 11, "DNASP48", 7) == 0))
 337         {
 338                 rdr_log(reader, "card needs reset before init");
 339                 memset(atr, 0, 1);
 340                 call(crdr_ops->activate(reader, atr)); //try to read the atr of this layer
 341                 ATR_GetRaw(atr, atrarr, &atr_size);
 342                 rdr_log(reader,"ATR: %s", cs_hexdump(1, atrarr, atr_size, tmp, sizeof(tmp)));
 343                 // Parse_ATR and InitCard need to be included in lock because they change parity of serial port
 344                 if(crdr_ops->lock)
 345                 {
 346                 crdr_ops->lock(reader);
 347                 }
 348                 int32_t ret1 = Parse_ATR(reader, atr, deprecated);
 349                 if(crdr_ops->unlock)
 350                 {
 351                         crdr_ops->unlock(reader);
 352                 }
 353                 if(ret1)
 354                 {
 355                         rdr_log(reader, "ERROR: Parse_ATR returned error");
 356                         return ERROR;
 357                 }
 358         }
 359
 360         if((memcmp(atrarr + 8, "DNASP4", 6) == 0) || (memcmp(atrarr + 11, "DNASP4", 6) == 0))
 361         {
 362                 rdr_log(reader, "detected card in CAK7 mode");
 363                 calculate_cak7_vars(reader, atr);
 364                 reader->cak7type = 1;
 365         }
 366         else if(((memcmp(atrarr + 7, "pp", 2) == 0 && ((atrarr[9]&0x0F) >= 10)) || (memcmp(atrarr + 11, "DNASP18", 7) == 0) || (memcmp(atrarr + 11, "DNASP19", 7) == 0) || (memcmp(atrarr + 11, "DNASP1A", 7) == 0)) && reader->cak7_mode)
 367         {
 368                 rdr_log(reader, "detected card in CAK6/Seca mode -> try switch to Nagra CAK7");
 369                 uint8_t changerom_handshake[22];
 370                 memset(changerom_handshake, 0x00, 22);
 371
 372                 calculate_changerom_cmd(reader, atr, &changerom_handshake[5]);
 373                 memset(reader->rom, 0, 15);
 374                 unsigned char cta_res[CTA_RES_LEN];
 375                 memset(cta_res, 0, CTA_RES_LEN);
 376                 uint16_t cta_lr;
 377
 378                 changerom_handshake[0] = 0x80;
 379                 changerom_handshake[1] = 0xCA;
 380                 changerom_handshake[4] = 0x11; // 0x11: length of data we will send
 381                 uint8_t cta_res1_ok = 0x61;
 382                 uint8_t cta_res2_ok = 0x10;
 383
 384                 if(reader->protocol_type != ATR_PROTOCOL_TYPE_T0)
 385                 {
 386                         //changerom_handshake[0] = 0x80; // fix for mipsel router
 387                         changerom_handshake[4] = 0x10; // 0x10: length of data we will send
 388                         cta_res1_ok = 0x90;
 389                         cta_res2_ok = 0x00;
 390                 }
 391
 392                 changerom_handshake[21] = 0x10;
 393
 394                 reader->cak7type = 1;
 395                 if(!ICC_Async_CardWrite(reader, changerom_handshake, sizeof(changerom_handshake), cta_res, &cta_lr))
 396                 {
 397                         if(cta_res[cta_lr-2] == cta_res1_ok && cta_res[cta_lr-1] == cta_res2_ok)
 398                         {
 399                                 rdr_log(reader, "switch nagra layer OK");
 400                                 memset(atr, 0, 1);
 401                                 call(crdr_ops->activate(reader, atr)); //try to read the atr of this layer
 402                                 ATR_GetRaw(atr, atrarr, &atr_size);
 403                                 rdr_log(reader,"ATR: %s", cs_hexdump(1, atrarr, atr_size, tmp, sizeof(tmp)));
 404                                 calculate_cak7_vars(reader, atr);
 405                                 if(reader->protocol_type == ATR_PROTOCOL_TYPE_T0)
 406                                 {
 407                                         reader->cak7type = 3;
 408                                 }
 409                                 else
 410                                 {
 411                                         reader->cak7type = 1;
 412                                 }
 413
 414                                 if(crdr_ops->lock)
 415                                 {
 416                                         crdr_ops->lock(reader);
 417                                 }
 418                                 int32_t ret2 = Parse_ATR(reader, atr, deprecated);
 419                                 if(crdr_ops->unlock)
 420                                 {
 421                                         crdr_ops->unlock(reader);
 422                                 }
 423                                 if(ret2)
 424                                 {
 425                                         rdr_log(reader, "ERROR: Parse_ATR returned error");
 426                                         return ERROR;
 427                                 }
 428                         }
 429                         else
 430                         {
 431                                 rdr_log(reader,"Switch to nagra layer failed!");
 432                                 return ERROR;
 433                         }
 434                 }
 435                 else
 436                 {
 437                         rdr_log(reader,"Switch to nagra layer command failed!");
 438                         return ERROR;
 439                 }
 440                 memcpy(reader->card_atr, atrarr, atr_size);
 441                 reader->card_atr_length = atr_size;
 442                 memcpy(reader->rom, atr->hb, (atr->hbn>15)?15:atr->hbn); // get historical bytes from atr
 443         }
 444 #endif
 445         rdr_log_dbg(reader, D_READER, "Card successfully activated");
 446
 447         return OK;
 448 }
 449
 450 int32_t ICC_Async_CardWrite(struct s_reader *reader, unsigned char *command, uint16_t command_len, unsigned char *rsp, uint16_t *lr)
 451 {
 452         const struct s_cardreader *crdr_ops = reader->crdr;
 453         if (!crdr_ops) return ERROR;
 454         int32_t ret;
 455         *lr = 0; //will be returned in case of error
 456         if(crdr_ops->card_write)
 457         {
 458                 call(crdr_ops->card_write(reader, command, rsp, lr, command_len));
 459                 rdr_log_dump_dbg(reader, D_READER, rsp, *lr, "Answer from cardreader:");
 460                 return OK;
 461         }
 462         if(crdr_ops->lock)
 463         {
 464                 crdr_ops->lock(reader);
 465         }
 466         int32_t try = 1;
 467         uint16_t type = 0;
 468         do
 469         {
 470                 if(try > 1)
 471                 {
 472                         rdr_log(reader, "Warning: needed try nr %i, next ECM has some delay", try);
 473                 }
 474
 475                 switch(reader->protocol_type)
 476                 {
 477                 case ATR_PROTOCOL_TYPE_T0:
 478                         ret = Protocol_T0_Command(reader, command, command_len, rsp, lr);
 479                         type = 0;
 480                         break;
 481                 case ATR_PROTOCOL_TYPE_T1:
 482                         ret = Protocol_T1_Command(reader, command, command_len, rsp, lr);
 483                         type = 1;
 484                         if(ret != OK && !crdr_ops->skip_t1_command_retries && reader->cak7type == 0)
 485                         {
 486                                 //try to resync
 487                                 rdr_log(reader, "Resync error: readtimeouts %d/%d (max/min) us, writetimeouts %d/%d (max/min) us", reader->maxreadtimeout, reader->minreadtimeout, reader->maxwritetimeout, reader->minwritetimeout);
 488                                 unsigned char resync[] = { 0x21, 0xC0, 0x00, 0xE1 };
 489                                 ret = Protocol_T1_Command(reader, resync, sizeof(resync), rsp, lr);
 490                                 if(ret == OK)
 491                                 {
 492                                         //reader->ifsc = DEFAULT_IFSC; // tryfix cardtimeouts: ifsc is setup at card init, on resync it should not return to default_ifsc
 493                                         rdr_log(reader, "T1 Resync command successful ifsc = %i", reader->ifsc);
 494                                         ret = ERROR;
 495                                 }
 496                                 else
 497                                 {
 498                                         rdr_log(reader, "T1 Resync command error, trying to reactivate!");
 499                                         ATR atr;
 500                                         ICC_Async_Activate(reader, &atr, reader->deprecated);
 501                                         if(crdr_ops->unlock)
 502                                         {
 503                                                 crdr_ops->unlock(reader);
 504                                         }
 505                                         return ERROR;
 506                                 }
 507                         }
 508                         break;
 509                 case ATR_PROTOCOL_TYPE_T14:
 510                         ret = Protocol_T14_ExchangeTPDU(reader, command, command_len, rsp, lr);
 511                         type = 14;
 512                         break;
 513                 default:
 514                         rdr_log(reader, "ERROR: Unknown protocol type %i", reader->protocol_type);
 515                         type = 99; // use 99 for unknown.
 516                         ret = ERROR;
 517                 }
 518                 try++;
 519         }
 520         while((try < 3) && (ret != OK) && (((type == 0 || type == 1) && reader->cak7type == 0) || type == 14)); // always do one retry when failing
 521         if(crdr_ops->unlock)
 522         {
 523                 crdr_ops->unlock(reader);
 524         }
 525         if(ret)
 526         {
 527                 rdr_log_dbg(reader, D_TRACE, "ERROR: Protocol_T%d_Command returns error", type);
 528                 return ERROR;
 529         }
 530         rdr_log_dump_dbg(reader, D_READER, rsp, *lr, "Answer from cardreader:");
 531         return OK;
 532 }
 533
 534 int32_t ICC_Async_GetTimings(struct s_reader *reader, uint32_t wait_etu)
 535 {
 536         int32_t timeout = ETU_to_us(reader, wait_etu);
 537         rdr_log_dbg(reader, D_IFD, "Setting timeout to %i ETU (%d us)", wait_etu, timeout);
 538         return timeout;
 539 }
 540
 541 int32_t ICC_Async_Transmit(struct s_reader *reader, uint32_t size, uint32_t expectedlen, unsigned char *data, uint32_t delay, uint32_t timeout)
 542 {
 543         const struct s_cardreader *crdr_ops = reader->crdr;
 544         if (!crdr_ops) return ERROR;
 545
 546         if(expectedlen)
 547         {
 548                 rdr_log_dbg(reader, D_IFD, "Transmit size %d bytes, expected len %d bytes, delay %d us, timeout=%d us", size, expectedlen, delay, timeout);
 549         }
 550         else
 551         {
 552                 rdr_log_dbg(reader, D_IFD, "Transmit size %d bytes, delay %d us, timeout=%d us", size, delay, timeout);
 553         }
 554         rdr_log_dump_dbg(reader, D_IFD, data, size, "Transmit:");
 555         unsigned char *sent = data;
 556         if(reader->convention == ATR_CONVENTION_INVERSE && crdr_ops->need_inverse)
 557         {
 558                 ICC_Async_InvertBuffer(reader, size, sent);
 559         }
 560         call(crdr_ops->transmit(reader, sent, size, expectedlen, delay, timeout));
 561         rdr_log_dbg(reader, D_IFD, "Transmit successful");
 562         if(reader->convention == ATR_CONVENTION_INVERSE && crdr_ops->need_inverse)
 563         {
 564                 // revert inversion cause the code in protocol_t0 is accessing buffer after transmit
 565                 ICC_Async_InvertBuffer(reader, size, sent);
 566         }
 567         return OK;
 568 }
 569
 570 int32_t ICC_Async_Receive(struct s_reader *reader, uint32_t size, unsigned char *data, uint32_t delay, uint32_t timeout)
 571 {
 572         const struct s_cardreader *crdr_ops = reader->crdr;
 573         if (!crdr_ops) return ERROR;
 574
 575         rdr_log_dbg(reader, D_IFD, "Receive size %d bytes, delay %d us, timeout=%d us", size, delay, timeout);
 576         call(crdr_ops->receive(reader, data, size, delay, timeout));
 577         rdr_log_dbg(reader, D_IFD, "Receive successful");
 578         if(reader->convention == ATR_CONVENTION_INVERSE && crdr_ops->need_inverse == 1)
 579         {
 580                 ICC_Async_InvertBuffer(reader, size, data);
 581         }
 582         return OK;
 583 }
 584
 585 int32_t ICC_Async_Close(struct s_reader *reader)
 586 {
 587         const struct s_cardreader *crdr_ops = reader->crdr;
 588         if (!crdr_ops) return ERROR;
 589         rdr_log_dbg(reader, D_IFD, "Closing device %s", reader->device);
 590         call(crdr_ops->close(reader));
 591         if(reader->typ != R_SC8in1)
 592         {
 593                 NULLFREE(reader->crdr_data);
 594                 NULLFREE(reader->csystem_data);
 595         }
 596         rdr_log_dbg(reader, D_IFD, "Device %s successfully closed", reader->device);
 597         return OK;
 598 }
 599
 600 void ICC_Async_DisplayMsg(struct s_reader *reader, char *msg)
 601 {
 602         const struct s_cardreader *crdr_ops = reader->crdr;
 603         if (!crdr_ops || !crdr_ops->display_msg)
 604         {
 605                 return;
 606         }
 607         crdr_ops->display_msg(reader, msg);
 608 }
 609
 610 int32_t ICC_Async_Reset(struct s_reader *reader, struct s_ATR *atr, int32_t (*rdr_activate_card)(struct s_reader *, struct s_ATR *, uint16_t deprecated), int32_t (*rdr_get_cardsystem)(struct s_reader *, struct s_ATR *))
 611 {
 612         const struct s_cardreader *crdr_ops = reader->crdr;
 613         if (!crdr_ops || !crdr_ops->do_reset)
 614         {
 615                 return 0;
 616         }
 617         return crdr_ops->do_reset(reader, atr, rdr_activate_card, rdr_get_cardsystem);
 618 }
 619
 620 static uint32_t ICC_Async_GetClockRate(int32_t cardmhz)
 621 {
 622         switch(cardmhz)
 623         {
 624         case 357:
 625         case 358:
 626                 return (372L * 9600L);
 627         case 368:
 628                 return (384L * 9600L);
 629         default:
 630                 return (cardmhz * 10000L);
 631         }
 632 }
 633
 634 static int32_t ICC_Async_GetPLL_Divider(struct s_reader *reader)
 635 {
 636         if(reader->divider != 0)
 637         {
 638                 return reader->divider;
 639         }
 640         if(reader->cardmhz != 8300) // Check dreambox is not DM7025
 641         {
 642                 float divider;
 643                 divider = ((float) reader->cardmhz) / ((float) reader->mhz);
 644                 if (tempfi == 9) reader->divider = (int32_t) divider; // some card's runs only when slightly oveclocked like HD02
 645                 else
 646                 {
 647                         reader->divider = (int32_t) divider;
 648                         if(divider > reader->divider)
 649                         {
 650                                 reader->divider++; // to prevent over clocking, ceil (round up) the divider
 651                         }
 652                 }
 653                 rdr_log_dbg(reader, D_DEVICE, "PLL maxmhz = %.2f, wanted mhz = %.2f, divider used = %d, actualcardclock=%.2f", (float) reader->cardmhz / 100, (float) reader->mhz / 100, reader->divider, (float) reader->cardmhz / reader->divider / 100);
 654                 reader->mhz = reader->cardmhz / reader->divider;
 655         }
 656         else // STB is DM7025
 657         {
 658                 int32_t i, dm7025_clock_freq[] = {518, 461, 395, 360, 319, 296, 267, 244, 230, 212, 197}, dm7025_PLL_setting[] = {6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}, t_cardmhz = reader->mhz;
 659                 for(i = 0; i < 11; i++)
 660                         if(t_cardmhz >= dm7025_clock_freq[i])
 661                         {
 662                                 break;
 663                         }
 664                 if(i > 10)
 665                 {
 666                         i = 10;
 667                 }
 668                 reader->mhz = dm7025_clock_freq[i];
 669                 reader->divider = dm7025_PLL_setting[i]; /*Nicer way of codeing is: reader->divider = i + 6;*/
 670                 rdr_log_dbg(reader, D_DEVICE, "DM7025 PLL maxmhz = %.2f, wanted mhz = %.2f, PLL setting used = %d, actualcardclock=%.2f", (float) reader->cardmhz / 100, (float) t_cardmhz / 100, reader->divider, (float) reader->mhz / 100);
 671         }
 672         return reader->divider;
 673 }
 674
 675 static void ICC_Async_InvertBuffer(struct s_reader *reader, uint32_t size, unsigned char *buffer)
 676 {
 677         uint32_t i;
 678         rdr_log_dbg(reader, D_IFD, "%s: size=%u buf[0]=%02x", __func__, size, buffer[0]);
 679         for(i = 0; i < size; i++)
 680         {
 681                 buffer[i] = ~(INVERT_BYTE(buffer[i]));
 682         }
 683 }
 684
 685 static int32_t Parse_ATR(struct s_reader *reader, ATR *atr, uint16_t deprecated)
 686 {
 687         unsigned char FI = ATR_DEFAULT_FI;
 688         uint32_t D = ATR_DEFAULT_D;
 689         uint32_t N = ATR_DEFAULT_N;
 690         int32_t ret;
 691         char tmp[256];
 692
 693         int32_t numprot = atr->pn;
 694         //if there is a trailing TD, this number is one too high
 695         unsigned char tx;
 696         if(ATR_GetInterfaceByte(atr, numprot - 1, ATR_INTERFACE_BYTE_TD, &tx) == ATR_OK)
 697                 if((tx & 0xF0) == 0)
 698                 {
 699                         numprot--;
 700                 }
 701         int32_t i, point;
 702         char txt[50];
 703         bool OffersT[3]; //T14 stored as T2
 704         for(i = 0; i <= 2; i++)
 705         {
 706                 OffersT[i] = 0;
 707         }
 708         for(i = 1; i <= numprot; i++)
 709         {
 710                 point = 0;
 711                 if(ATR_GetInterfaceByte(atr, i, ATR_INTERFACE_BYTE_TA, &tx) == ATR_OK)
 712                 {
 713                         snprintf((char *)txt + point, sizeof(txt) - point, "TA%i=%02X ", i, tx);
 714                         point += 7;
 715                 }
 716                 if(ATR_GetInterfaceByte(atr, i, ATR_INTERFACE_BYTE_TB, &tx) == ATR_OK)
 717                 {
 718                         snprintf((char *)txt + point, sizeof(txt) - point, "TB%i=%02X ", i, tx);
 719                         point += 7;
 720                 }
 721                 if(ATR_GetInterfaceByte(atr, i, ATR_INTERFACE_BYTE_TC, &tx) == ATR_OK)
 722                 {
 723                         snprintf((char *)txt + point, sizeof(txt) - point, "TC%i=%02X ", i, tx);
 724                         point += 7;
 725                 }
 726                 if(ATR_GetInterfaceByte(atr, i, ATR_INTERFACE_BYTE_TD, &tx) == ATR_OK)
 727                 {
 728                         snprintf((char *)txt + point, sizeof(txt) - point, "TD%i=%02X ", i, tx);
 729                         point += 7;
 730                         tx &= 0X0F;
 731                         snprintf((char *)txt + point, sizeof(txt) - point, "(T%i)", tx);
 732                         if(tx == 14)
 733                         {
 734                                 OffersT[2] = 1;
 735                         }
 736                         else
 737                         {
 738                                 OffersT[tx] = 1;
 739                         }
 740                 }
 741                 else
 742                 {
 743                         snprintf((char *)txt + point, sizeof(txt) - point, "no TD%i means T0", i);
 744                         OffersT[0] = 1;
 745                 }
 746                 rdr_log_dbg(reader, D_ATR, "%s", txt);
 747         }
 748
 749         int32_t numprottype = 0;
 750         for(i = 0; i <= 2; i++)
 751                 if(OffersT[i])
 752                 {
 753                         numprottype ++;
 754                 }
 755         rdr_log_dbg(reader, D_ATR, "%i protocol types detected. Historical bytes: %s", numprottype, cs_hexdump(1, atr->hb, atr->hbn, tmp, sizeof(tmp)));
 756
 757         ATR_GetParameter(atr, ATR_PARAMETER_N, &(N));
 758         ATR_GetProtocolType(atr, 1, &(reader->protocol_type)); // get protocol from TD1
 759
 760         unsigned char TA2;
 761         bool SpecificMode = (ATR_GetInterfaceByte(atr, 2, ATR_INTERFACE_BYTE_TA, &TA2) == ATR_OK); // if TA2 present, specific mode, else negotiable mode
 762         if(SpecificMode)
 763         {
 764                 reader->protocol_type = TA2 & 0x0F;
 765                 if((TA2 & 0x10) != 0x10) // bit 5 set to 0 means F and D explicitly defined in interface characters
 766                 {
 767                         unsigned char TA1;
 768                         if(ATR_GetInterfaceByte(atr, 1, ATR_INTERFACE_BYTE_TA, &TA1) == ATR_OK)
 769                         {
 770                                 FI = TA1 >> 4;
 771                                 ATR_GetParameter(atr, ATR_PARAMETER_D, &(D));
 772                         }
 773                         else
 774                         {
 775                                 FI = ATR_DEFAULT_FI;
 776                                 D = ATR_DEFAULT_D;
 777                         }
 778                 }
 779                 else
 780                 {
 781                         rdr_log(reader, "Specific mode: speed 'implicitly defined', not sure how to proceed, assuming default values");
 782                         FI = ATR_DEFAULT_FI;
 783                         D = ATR_DEFAULT_D;
 784                 }
 785                 uint32_t F = atr_f_table[FI];
 786                 rdr_log_dbg(reader, D_ATR, "Specific mode: T%i, F=%d, D=%d, N=%d", reader->protocol_type, F, D, N);
 787         }
 788         else // negotiable mode
 789         {
 790
 791                 reader->read_timeout = 1000000; // in us
 792                 bool PPS_success = 0;
 793                 bool NeedsPTS = ((reader->protocol_type != ATR_PROTOCOL_TYPE_T14) && (numprottype > 1 || (atr->ib[0][ATR_INTERFACE_BYTE_TA].present == 1 && atr->ib[0][ATR_INTERFACE_BYTE_TA].value != 0x11) || N == 255)); //needs PTS according to old ISO 7816
 794                 if(NeedsPTS && deprecated == 0)
 795                 {
 796                         //                       PTSS  PTS0  PTS1  PCK
 797                         unsigned char req[6] = { 0xFF, 0x10, 0x00, 0x00 }; //we currently do not support PTS2, standard guardtimes or PTS3,
 798                         //but spare 2 bytes in arrayif card responds with it
 799                         req[1] = 0x10 | reader->protocol_type; //PTS0 always flags PTS1 to be sent always
 800                         if(ATR_GetInterfaceByte(atr, 1, ATR_INTERFACE_BYTE_TA, &req[2]) != ATR_OK) //PTS1
 801                         {
 802                                 req[2] = 0x11; // defaults FI and DI to 1
 803                         }
 804                         uint32_t len = 0;
 805                         call(SetRightParity(reader));
 806                         ret = PPS_Exchange(reader, req, &len);
 807                         if(ret == OK)
 808                         {
 809                                 FI = req[2] >> 4;
 810                                 unsigned char DI = req[2] & 0x0F;
 811                                 D = atr_d_table[DI];
 812                                 uint32_t F = atr_f_table[FI];
 813                                 PPS_success = 1;
 814                                 rdr_log_dbg(reader, D_ATR, "PTS successful, selected protocol: T%i, F=%d, D=%d, N=%d", reader->protocol_type, F, D, N);
 815                         }
 816                         else
 817                         {
 818                                 rdr_log_dump_dbg(reader, D_ATR, req, len, "PTS Failure, response:");
 819                         }
 820                 }
 821
 822                 //When for SCI, T14 protocol, TA1 is obeyed, this goes OK for mosts devices, but somehow on DM7025 Sky S02 card goes wrong when setting ETU (ok on DM800/DM8000)
 823                 if(!PPS_success) // last PPS not successful
 824                 {
 825                         unsigned char TA1;
 826                         if(ATR_GetInterfaceByte(atr, 1, ATR_INTERFACE_BYTE_TA, &TA1) == ATR_OK)
 827                         {
 828                                 FI = TA1 >> 4;
 829                                 ATR_GetParameter(atr, ATR_PARAMETER_D, &(D));
 830                         }
 831                         else // do not obey TA1
 832                         {
 833                                 FI = ATR_DEFAULT_FI;
 834                                 D = ATR_DEFAULT_D;
 835                         }
 836                         if(NeedsPTS)
 837                         {
 838                                 if((D == 32) || (D == 12) || (D == 20))  //those values were RFU in old table
 839                                 {
 840                                         D = 0; // viaccess cards that fail PTS need this
 841                                 }
 842                         }
 843                         uint32_t F = atr_f_table[FI];
 844                         rdr_log_dbg(reader, D_ATR, "No PTS %s, selected protocol T%i, F=%d, D=%d, N=%d", NeedsPTS ? "happened" : "needed", reader->protocol_type, F, D, N);
 845                 }
 846         }//end negotiable mode
 847
 848         //make sure no zero values
 849         uint32_t F = atr_f_table[FI];
 850         if(!F)
 851         {
 852                 FI = ATR_DEFAULT_FI;
 853                 rdr_log(reader, "Warning: F=0 is invalid, forcing FI=%d", FI);
 854         }
 855         if(!D)
 856         {
 857                 D = ATR_DEFAULT_D;
 858                 rdr_log(reader, "Warning: D=0 is invalid, forcing D=%d", D);
 859         }
 860         rdr_log_dbg(reader, D_ATR, "Init card protocol T%i, FI=%d, F=%d, D=%d, N=%d", reader->protocol_type, FI, F, D, N);
 861         if(deprecated == 0)
 862         {
 863                 return InitCard(reader, atr, FI, D, N, deprecated);
 864         }
 865         else
 866         {
 867                 return InitCard(reader, atr, ATR_DEFAULT_FI, ATR_DEFAULT_D, N, deprecated);
 868         }
 869 }
 870
 871 static int32_t PPS_Exchange(struct s_reader *reader, unsigned char *params, uint32_t *length)
 872 {
 873         const struct s_cardreader *crdr_ops = reader->crdr;
 874         if (!crdr_ops) return ERROR;
 875
 876         unsigned char confirm[PPS_MAX_LENGTH];
 877         uint32_t len_request, len_confirm;
 878         char tmp[128];
 879         int32_t ret;
 880
 881         len_request = PPS_GetLength(params);
 882         params[len_request - 1] = PPS_GetPCK(params, len_request - 1);
 883         rdr_log_dbg(reader, D_IFD, "PTS: Sending request: %s", cs_hexdump(1, params, len_request, tmp, sizeof(tmp)));
 884
 885         if(crdr_ops->set_protocol)
 886         {
 887                 ret = crdr_ops->set_protocol(reader, params, length, len_request);
 888                 return ret;
 889         }
 890
 891         // Send PPS request
 892         call(ICC_Async_Transmit(reader, len_request, len_request, params, 0, 1000000));
 893
 894         // Get PPS confirm
 895         call(ICC_Async_Receive(reader, 2, confirm, 0, 1000000));
 896         len_confirm = PPS_GetLength(confirm);
 897         call(ICC_Async_Receive(reader, len_confirm - 2, confirm + 2, 0, 1000000));
 898
 899         rdr_log_dbg(reader, D_IFD, "PTS: Receiving confirm: %s", cs_hexdump(1, confirm, len_confirm, tmp, sizeof(tmp)));
 900         if((len_request != len_confirm) || (memcmp(params, confirm, len_request)))
 901         {
 902                 ret = ERROR;
 903         }
 904         else
 905         {
 906                 ret = OK;
 907         }
 908
 909         // Copy PPS handshake
 910         memcpy(params, confirm, len_confirm);
 911         (*length) = len_confirm;
 912         return ret;
 913 }
 914
 915 static uint32_t PPS_GetLength(unsigned char *block)
 916 {
 917         uint32_t length = 3;
 918
 919         if(PPS_HAS_PPS1(block))
 920         {
 921                 length++;
 922         }
 923
 924         if(PPS_HAS_PPS2(block))
 925         {
 926                 length++;
 927         }
 928
 929         if(PPS_HAS_PPS3(block))
 930         {
 931                 length++;
 932         }
 933
 934         return length;
 935 }
 936
 937 static uint32_t ETU_to_us(struct s_reader *reader, uint32_t ETU)
 938 {
 939         return (uint32_t)((double) ETU * reader->worketu); // in us
 940 }
 941
 942 static int32_t ICC_Async_SetParity(struct s_reader *reader, uint16_t parity)
 943 {
 944         const struct s_cardreader *crdr_ops = reader->crdr;
 945         if (!crdr_ops) return ERROR;
 946
 947         if(crdr_ops->set_parity)
 948         {
 949                 rdr_log_dbg(reader, D_IFD, "Setting right parity");
 950                 call(crdr_ops->set_parity(reader, parity));
 951         }
 952         return OK;
 953 }
 954
 955 static int32_t SetRightParity(struct s_reader *reader)
 956 {
 957         const struct s_cardreader *crdr_ops = reader->crdr;
 958         if (!crdr_ops) return ERROR;
 959
 960         //set right parity
 961         uint16_t parity = PARITY_EVEN;
 962         if(reader->convention == ATR_CONVENTION_INVERSE)
 963         {
 964                 parity = PARITY_ODD;
 965         }
 966         else if(reader->protocol_type == ATR_PROTOCOL_TYPE_T14)
 967         {
 968                 parity = PARITY_NONE;
 969         }
 970
 971         call(ICC_Async_SetParity(reader, parity));
 972
 973         if(crdr_ops->flush && reader->crdr_flush)
 974         {
 975                 IO_Serial_Flush(reader);
 976         }
 977
 978         return OK;
 979 }
 980
 981 static int32_t InitCard(struct s_reader *reader, ATR *atr, unsigned char FI, uint32_t D, unsigned char N, uint16_t deprecated)
 982 {
 983         const struct s_cardreader *crdr_ops = reader->crdr;
 984         if (!crdr_ops) return ERROR;
 985
 986         uint32_t I, F, Fi, BGT = 0, edc, GT = 0, WWT = 0, EGT = 0;
 987         unsigned char wi = 0;
 988
 989         // set the amps and the volts according to ATR
 990         if(ATR_GetParameter(atr, ATR_PARAMETER_I, &I) != ATR_OK)
 991         {
 992                 I = 0;
 993         }
 994
 995         tempfi = FI;
 996
 997         // set clock speed to max if internal reader
 998         if(crdr_ops->max_clock_speed == 1 && reader->typ == R_INTERNAL)
 999         {
1000                 if(reader->autospeed == 1) //no overclocking
1001                 {
1002                         reader->mhz = atr_fs_table[FI] / 10000; // we are going to clock the card to this nominal frequency
1003                 }
1004
1005                 if(reader->cardmhz > 2000 && reader->autospeed == 1) // -1 replaced by autospeed parameter is magic number pll internal reader set cardmhz according to optimal atr speed
1006                 {
1007                         reader->mhz = atr_fs_table[FI] / 10000 ;
1008                         if((!strncmp(boxtype_get(), "vu", 2 ))||(boxtype_is("ini-8000am")))
1009                         {
1010                                 reader->mhz = 450;
1011                         }
1012                 }
1013         }
1014
1015         if(reader->cardmhz > 2000)
1016         {
1017                 reader->divider = 0; // reset pll divider so divider will be set calculated again.
1018                 ICC_Async_GetPLL_Divider(reader); // calculate pll divider for target cardmhz.
1019         }
1020
1021         Fi = atr_f_table[FI]; // get the frequency divider also called clock rate conversion factor
1022         if(crdr_ops->set_baudrate)
1023         {
1024                 reader->current_baudrate = DEFAULT_BAUDRATE;
1025
1026                 if(deprecated == 0)
1027                 {
1028
1029                         if(reader->protocol_type != ATR_PROTOCOL_TYPE_T14) // dont switch for T14
1030                         {
1031                                 uint32_t baud_temp = (double)D * ICC_Async_GetClockRate(reader->cardmhz) / (double)Fi;
1032                                 uint32_t baud_temp2 = (double)D * ICC_Async_GetClockRate(reader->mhz) / (double)Fi;
1033                                 rdr_log(reader, "Setting baudrate to %d bps", baud_temp2);
1034                                 // set_baudrate() increases/decreases baud_temp to baud_temp2 in case of over/underclocking
1035                                 call(crdr_ops->set_baudrate(reader, baud_temp));
1036                                 reader->current_baudrate = baud_temp2;
1037                         }
1038                 }
1039         }
1040         if(reader->cardmhz > 2000 && reader->typ == R_INTERNAL)
1041         {
1042                 F = reader->mhz; // for PLL based internal readers
1043         }
1044         else
1045         {
1046                 if (reader->typ == R_SMART || is_smargo_reader(reader))
1047                 {
1048                         if (reader->autospeed == 1)
1049                         {
1050                                 uint32_t Fsmart = atr_fs_table[FI];
1051                                 reader->mhz = Fsmart/10000;
1052                                 if(reader->mhz >= 1600)
1053                                 {
1054                                         reader->mhz = 1600;
1055                                 }
1056                                 else if(reader->mhz >= 1200)
1057                                 {
1058                                         reader->mhz = 1200;
1059                                 }
1060                                 else if(reader->mhz >= 961)
1061                                 {
1062                                         reader->mhz =  961;
1063                                 }
1064                                 else if(reader->mhz >= 800)
1065                                 {
1066                                         reader->mhz =  800;
1067                                 }
1068                                 else if(reader->mhz >= 686)
1069                                 {
1070                                         reader->mhz =  686;
1071                                 }
1072                                 else if(reader->mhz >= 600)
1073                                 {
1074                                         reader->mhz =  600;
1075                                 }
1076                                 else if(reader->mhz >= 534)
1077                                 {
1078                                         reader->mhz =  534;
1079                                 }
1080                                 else if(reader->mhz >= 480)
1081                                 {
1082                                         reader->mhz =  534;
1083                                 }
1084                                 else if(reader->mhz >= 436)
1085                                 {
1086                                         reader->mhz =  436;
1087                                 }
1088                                 else if(reader->mhz >= 400)
1089                                 {
1090                                         reader->mhz =  400;
1091                                 }
1092                                 else if(reader->mhz >= 369)
1093                                 {
1094                                         reader->mhz =  369;
1095                                 }
1096                                 else if(reader->mhz >= 357)
1097                                 {
1098                                         reader->mhz =  369; // 357 not suported by smartreader
1099                                 }
1100                                 else if(reader->mhz >= 343)
1101                                 {
1102                                         reader->mhz =  343;
1103                                 }
1104                                 else
1105                                 {
1106                                         reader->mhz =  320;
1107                                 }
1108                         }
1109                 }
1110                 F = reader->mhz; //all other readers
1111         }
1112         reader->worketu = (double)((double)(1 / (double)D) * ((double)Fi / (double)((double)F / 100)));
1113         rdr_log_dbg(reader, D_ATR, "Calculated work ETU is %.2f us reader mhz = %u", reader->worketu, reader->mhz);
1114
1115         //set timings according to ATR
1116         reader->read_timeout = 0;
1117         reader->block_delay = 0;
1118         reader->char_delay = 0;
1119
1120         switch(reader->protocol_type)
1121         {
1122         case ATR_PROTOCOL_TYPE_T0:
1123         case ATR_PROTOCOL_TYPE_T14:
1124         {
1125                 /* Integer value WI = TC2, by default 10 */
1126 #ifndef PROTOCOL_T0_USE_DEFAULT_TIMINGS
1127                 if(ATR_GetInterfaceByte(atr, 2, ATR_INTERFACE_BYTE_TC, &(wi)) != ATR_OK)
1128 #endif
1129                         wi = DEFAULT_WI;
1130
1131                 WWT = (uint32_t) 960 * D * wi; //in work ETU
1132                 GT = 2; // standard guardtime
1133                 GT += 1; // start bit
1134                 GT += 8; // databits
1135                 GT += 1; // parity bit
1136
1137                 if(N != 255)  //add extra Guard Time by ATR
1138                 {
1139                         EGT += N; // T0 protocol, if TC1 = 255 then dont add extra guardtime
1140                 }
1141                 reader->CWT = 0; // T0 protocol doesnt have char waiting time (used to detect errors within 1 single block of data)
1142                 reader->BWT = 0; // T0 protocol doesnt have block waiting time (used to detect unresponsive card, this is max time for starting a block answer)
1143
1144                 rdr_log_dbg(reader, D_ATR, "Protocol: T=%i, WWT=%u, Clockrate=%u", reader->protocol_type, WWT, F * 10000);
1145                 reader->read_timeout = WWT; // Work waiting time used in T0 (max time to signal unresponsive card!)
1146                 reader->char_delay = GT + EGT; // Character delay is used on T0
1147                 rdr_log_dbg(reader, D_ATR, "Setting timings: timeout=%u ETU, block_delay=%u ETU, char_delay=%u ETU", reader->read_timeout, reader->block_delay, reader->char_delay);
1148                 break;
1149         }
1150         case ATR_PROTOCOL_TYPE_T1:
1151         {
1152                 unsigned char ta, tb, tc, cwi, bwi;
1153
1154                 // Set IFSC
1155                 if(ATR_GetInterfaceByte(atr, 3, ATR_INTERFACE_BYTE_TA, &ta) == ATR_NOT_FOUND)
1156                 {
1157                         reader->ifsc = DEFAULT_IFSC;
1158                 }
1159                 else if((ta != 0x00) && (ta != 0xFF))
1160                 {
1161                         reader->ifsc = ta;
1162                 }
1163                 else
1164                 {
1165                         reader->ifsc = DEFAULT_IFSC;
1166                 }
1167
1168                 // FIXME workaround for Smargo until native mode works
1169                 if(reader->smargopatch == 1)
1170                 {
1171                         reader->ifsc = MIN(reader->ifsc, 28);
1172                 }
1173                 else
1174                         // Towitoko and smartreaders dont allow IFSC > 251
1175                 {
1176                         reader->ifsc = MIN(reader->ifsc, MAX_IFSC);
1177                 }
1178
1179 #ifndef PROTOCOL_T1_USE_DEFAULT_TIMINGS
1180                 // Calculate CWI and BWI
1181                 if(ATR_GetInterfaceByte(atr, 3, ATR_INTERFACE_BYTE_TB, &tb) == ATR_NOT_FOUND)
1182                 {
1183 #endif
1184                         cwi = DEFAULT_CWI;
1185                         bwi = DEFAULT_BWI;
1186 #ifndef PROTOCOL_T1_USE_DEFAULT_TIMINGS
1187                 }
1188                 else
1189                 {
1190                         cwi = tb & 0x0F;
1191                         bwi = tb >> 4;
1192                 }
1193 #endif
1194
1195                 // Set CWT = 11+(2^CWI) work etu
1196                 reader->CWT = (uint16_t) 11 + (1 << cwi); // in work ETU
1197
1198                 reader->BWT = (uint32_t) ((1<<bwi) * 960 * 372 / (double)((double)F / 100) / (double) reader->worketu) + 11;  // BWT in work ETU
1199
1200                 BGT = 22L; // Block Guard Time in ETU used to interspace between block responses
1201                 GT = 2; // standard guardtime
1202                 GT += 1; // start bit
1203                 GT += 8; // databits
1204                 GT += 1; // parity bit
1205
1206                 if(N == 255)
1207                 {
1208                         GT -= 1; // special case, ATR says standard 2 etu guardtime is decreased by 1 (in ETU) EGT remains zero!
1209                 }
1210                 else
1211                 {
1212                         EGT += N; // ATR says add extra guardtime (in ETU)
1213                 }
1214
1215                 // Set the error detection code type
1216                 if(ATR_GetInterfaceByte(atr, 3, ATR_INTERFACE_BYTE_TC, &tc) == ATR_NOT_FOUND)
1217                 {
1218                         edc = EDC_LRC;
1219                 }
1220                 else
1221                 {
1222                         edc = tc & 0x01;
1223                 }
1224
1225                 // Set initial send sequence (NS)
1226                 reader->ns = 1;
1227
1228                 rdr_log_dbg(reader, D_ATR, "Protocol: T=%i: IFSC=%d, CWT=%d etu, BWT=%d etu, BGT=%d etu, EDC=%s, N=%d", reader->protocol_type, reader->ifsc, reader->CWT, reader->BWT, BGT, (edc == EDC_LRC) ? "LRC" : "CRC", N);
1229                 reader->read_timeout = reader->BWT;
1230                 reader->block_delay = BGT;
1231                 reader->char_delay = GT + EGT;
1232                 rdr_log_dbg(reader, D_ATR, "Setting timings: reader timeout=%u ETU, block_delay=%u ETU, char_delay=%u ETU", reader->read_timeout, reader->block_delay, reader->char_delay);
1233
1234                 break;
1235         }
1236
1237         default:
1238                 return ERROR;
1239                 break;
1240         }//switch
1241         SetRightParity(reader);  // some reader devices need to get set the right parity
1242
1243         uint32_t ETU = Fi / D;
1244         if(atr->hbn >= 6 && !memcmp(atr->hb, "IRDETO", 6) && reader->protocol_type == ATR_PROTOCOL_TYPE_T14)
1245         {
1246                 ETU = 0;
1247                 reader->worketu *= 2; // overclocked T14 needs this otherwise high ecm reponses
1248         }
1249
1250         struct s_cardreader_settings s =
1251         {
1252                 .ETU = ETU,
1253                 .EGT = EGT,
1254                 .P   = 5,
1255                 .I   = I,
1256                 .F   = Fi,
1257                 .Fi  = (uint16_t) Fi,
1258                 .Ni  = N,
1259                 .D   = D,
1260                 .WWT = WWT,
1261                 .BGT = BGT,
1262         };
1263
1264         if(crdr_ops->write_settings)
1265         {
1266                 call(crdr_ops->write_settings(reader, &s));
1267         }
1268
1269 /*
1270         if(reader->typ == R_INTERNAL)
1271         {
1272                 if(reader->cardmhz > 2000)
1273                 {
1274                         rdr_log(reader, "PLL Reader: ATR Fsmax is %i MHz, clocking card to %.2f Mhz (nearest possible mhz specified reader->mhz)", atr_fs_table[FI] / 1000000, (float) reader->mhz / 100);
1275                 }
1276                 else
1277                 {
1278                         rdr_log(reader, "ATR Fsmax is %i MHz, clocking card to %.2f (specified in reader->mhz)", atr_fs_table[FI] / 1000000, (float) reader->mhz / 100);
1279                 }
1280         }
1281         else
1282         {
1283                 if ((reader->typ == R_SMART) && (reader->autospeed == 1))
1284                 {
1285                         rdr_log(reader, "ATR Fsmax is %i MHz, clocking card to ATR Fsmax for smartreader cardspeed of %.2f MHz (specified in reader->mhz)", atr_fs_table[FI] / 1000000, (float) reader->mhz / 100);
1286                 }
1287                 else
1288                 {
1289                         rdr_log(reader, "ATR Fsmax is %i MHz, clocking card to wanted user cardclock of %.2f MHz (specified in reader->mhz)",atr_fs_table[FI] / 1000000, (float) reader->mhz / 100);
1290                 }
1291         }
1292 */
1293
1294         //Communicate to T1 card IFSD -> we use same as IFSC
1295         if(reader->protocol_type == ATR_PROTOCOL_TYPE_T1 && reader->ifsc != DEFAULT_IFSC && !crdr_ops->skip_setting_ifsc)
1296         {
1297                 unsigned char rsp[CTA_RES_LEN];
1298                 uint16_t lr = 0;
1299                 int32_t ret;
1300                 unsigned char tmp[] = { 0x21, 0xC1, 0x01, 0x00, 0x00 };
1301                 tmp[3] = reader->ifsc; // Information Field size
1302                 tmp[4] = reader->ifsc ^ 0xE1;
1303                 ret = Protocol_T1_Command(reader, tmp, sizeof(tmp), rsp, &lr);
1304                 if(ret != OK)
1305                 {
1306                         rdr_log(reader, "Warning: Card returned error on setting ifsd value to %d", reader->ifsc);
1307                 }
1308                 else
1309                 {
1310                         rdr_log_dbg(reader, D_ATR, "Card responded ok for ifsd request of %d", reader->ifsc);
1311                 }
1312         }
1313         return OK;
1314 }
1315
1316 static unsigned char PPS_GetPCK(unsigned char *block, uint32_t length)
1317 {
1318         unsigned char pck;
1319         uint32_t i;
1320         pck = block[0];
1321         for(i = 1; i < length; i++)
1322         {
1323                 pck ^= block[i];
1324         }
1325         return pck;
1326 }
1327 #endif