Changeset 11429 for trunk/csctapi/icc_async.c
- Timestamp:
- 07/28/18 21:31:01 (6 years ago)
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/csctapi/icc_async.c
r11413 r11429 1 /*2 icc_async.c3 Asynchronous ICC's handling functions4 5 This file is part of the Unix driver for Towitoko smartcard readers6 Copyright (C) 2000 2001 Carlos Prados <cprados@yahoo.com>7 8 This version is modified by doz21 to work in a special manner ;)9 10 This library is free software; you can redistribute it and/or11 modify it under the terms of the GNU Lesser General Public12 License as published by the Free Software Foundation; either13 version 2 of the License, or (at your option) any later version.14 15 This library is distributed in the hope that it will be useful,16 but WITHOUT ANY WARRANTY; without even the implied warranty of17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU18 Lesser General Public License for more details.19 20 You should have received a copy of the GNU Lesser General Public21 License along with this library; if not, write to the Free Software22 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA23 */24 25 1 #include "../globals.h" 26 2 #ifdef WITH_CARDREADER … … 32 8 #include "ifd_phoenix.h" 33 9 #include "../oscam-time.h" 34 35 #define OK 0 36 #define ERROR 1 10 #include "../cardlist.h" 11 #include "../oscam-work.h" 12 #ifdef READER_NAGRA_MERLIN 13 #include "../cscrypt/fast_aes.h" 14 #include "../cscrypt/sha256.h" 15 #include "../cscrypt/aescbc.h" 16 #include "../cscrypt/mdc2.h" 17 #include "../cscrypt/bn.h" 18 #include "../cscrypt/idea.h" 19 #endif 20 21 #define OK 0 22 #define ERROR 1 37 23 38 24 // Default T0/T14 settings 39 #define DEFAULT_WI 25 #define DEFAULT_WI 10 40 26 // Default T1 settings 41 #define DEFAULT_IFSC 32 42 #define MAX_IFSC 251 /* Cannot send > 255 buffer */ 43 #define DEFAULT_CWI 13 44 #define DEFAULT_BWI 4 45 #define EDC_LRC 0 46 47 #define PPS_MAX_LENGTH 6 48 #define PPS_HAS_PPS1(block) ((block[1] & 0x10) == 0x10) 49 #define PPS_HAS_PPS2(block) ((block[1] & 0x20) == 0x20) 50 #define PPS_HAS_PPS3(block) ((block[1] & 0x40) == 0x40) 51 52 /* 53 * Not exported functions declaration 54 */ 55 static uint16_t tempfi; // used to capture FI and use it for rounding or not 27 #define DEFAULT_IFSC 32 28 #define MAX_IFSC 251 29 #define DEFAULT_CWI 13 30 #define DEFAULT_BWI 4 31 #define EDC_LRC 0 32 33 #define PPS_MAX_LENGTH 6 34 #define PPS_HAS_PPS1(block) ((block[1] & 0x10) == 0x10) 35 #define PPS_HAS_PPS2(block) ((block[1] & 0x20) == 0x20) 36 #define PPS_HAS_PPS3(block) ((block[1] & 0x40) == 0x40) 37 38 static uint16_t tempfi; // used to capture FI and use it for rounding or not 56 39 static void ICC_Async_InvertBuffer(struct s_reader *reader, uint32_t size, unsigned char *buffer); 57 40 static int32_t Parse_ATR(struct s_reader *reader, ATR *atr, uint16_t deprecated); … … 63 46 static int32_t SetRightParity(struct s_reader *reader); 64 47 65 /* 66 * Exported functions definition 67 */ 48 #ifdef READER_NAGRA_MERLIN 49 static uint32_t crctab[256] = 50 { 51 0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9, 0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005, 52 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61, 0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd, 53 0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9, 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75, 54 0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011, 0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd, 55 0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039, 0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5, 56 0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81, 0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d, 57 0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49, 0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95, 58 0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1, 0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, 59 0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae, 0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072, 60 0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, 0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca, 61 0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde, 0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02, 62 0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066, 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba, 63 0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, 0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692, 64 0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6, 0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a, 65 0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e, 0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2, 66 0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, 0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a, 67 0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637, 0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb, 68 0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f, 0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53, 69 0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, 0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b, 70 0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff, 0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623, 71 0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7, 0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b, 72 0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f, 0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3, 73 0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7, 0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b, 74 0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f, 0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3, 75 0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640, 0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c, 76 0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8, 0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24, 77 0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30, 0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec, 78 0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, 0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654, 79 0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0, 0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c, 80 0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18, 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4, 81 0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, 0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c, 82 0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668, 0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4, 83 }; 84 85 uint32_t calc_ccitt32(uint8_t *buf, uint8_t count) 86 { 87 #define M1 0xffffffff 88 #define M2 0xffffff00 89 uint32_t crc = M1; 90 while(count--) 91 { 92 crc=((crc<<8)&M2)^crctab[((crc>>24)&0xff)^*buf++]; 93 } 94 return(crc); 95 } 96 97 static void calculate_cas7_vars(struct s_reader *reader, const ATR *atr) 98 { 99 uint8_t aes_key[32]; 100 const uint8_t aes_iv[] = { 0x4E, 0x61, 0x67, 0x72, 0x61, 0x63, 0x61, 0x72, 0x64, 0x28, 0x63, 0x29, 0x32, 0x30, 0x30, 0x36 }; // Nagracard(c)2006 101 mbedtls_sha256_context ctx_sha256; 102 mbedtls_sha256_init(&ctx_sha256); 103 mbedtls_sha256_starts(&ctx_sha256, 0); 104 mbedtls_sha256_update(&ctx_sha256, atr->hb, atr->hbn); 105 mbedtls_sha256_finish(&ctx_sha256, aes_key); 106 mbedtls_sha256_free(&ctx_sha256); 107 memcpy(reader->cas7_aes_key,aes_key,32); 108 memcpy(reader->cas7_aes_iv,aes_iv,16); 109 } 110 111 void calculate_cas7_cmd(struct s_reader *reader, uint8_t *cmdin,uint8_t cmdlen,uint8_t *cmdout) 112 { 113 uint32_t crc = calc_ccitt32(cmdin+4, cmdlen-4); 114 i2b_buf(4, crc, cmdin); 115 AesCtx ctx; 116 AesCtxIni(&ctx, reader->cas7_aes_iv, &reader->cas7_aes_key[16], KEY128, CBC); 117 AesEncrypt(&ctx, cmdin, cmdout, cmdlen); 118 } 119 120 void do_cas7_cmd(struct s_reader *reader,unsigned char *cta_res, uint16_t *p_cta_lr,uint8_t *data,uint8_t inlen,uint8_t resplen) 121 { 122 reader->cas7_seq++; 123 uint8_t req[inlen+5+1]; // +head+len 124 memset(req,0x00,sizeof(req)); 125 // head 126 req[0]=0x80; 127 req[1]=0xCA; 128 // len 129 req[4]=inlen; 130 req[sizeof(req)-1]=resplen; 131 data[4]=(reader->cas7_seq>>16)&0xFF; 132 data[5]=(reader->cas7_seq>>8)&0xFF; 133 data[6]=(reader->cas7_seq)&0xFF; 134 calculate_cas7_cmd(reader,data,inlen,&req[5]); 135 if(!ICC_Async_CardWrite(reader, req, sizeof(req), cta_res, p_cta_lr, 0x21)) 136 { 137 AesCtx ctx; 138 AesCtxIni(&ctx, reader->cas7_aes_iv, &reader->cas7_aes_key[16], KEY128, CBC); 139 AesDecrypt(&ctx, cta_res, cta_res, *p_cta_lr-2); 140 } 141 else 142 { 143 *p_cta_lr=0; 144 } 145 } 146 147 static void calculate_changerom_cmd(struct s_reader *reader, const ATR *atr, uint8_t *cmd) 148 { 149 uint8_t cmd_data[] = { 0xCC, 0xCC, 0xCC, 0xCC, 0x00, 0x00, 0x01, 0x01, 0x01, 0x95, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC }; 150 calculate_cas7_vars(reader,atr); 151 calculate_cas7_cmd(reader,cmd_data,sizeof(cmd_data),cmd); 152 } 153 #endif 68 154 69 155 int32_t ICC_Async_Device_Init(struct s_reader *reader) … … 76 162 int32_t ret = crdr_ops->reader_init(reader); 77 163 if(ret == OK) 78 { rdr_log_dbg(reader, D_IFD, "Device %s succesfully opened", reader->device); } 164 { 165 rdr_log_dbg(reader, D_IFD, "Device %s succesfully opened", reader->device); 166 } 79 167 else 80 168 { 81 if(reader->typ != R_SC8in1) { NULLFREE(reader->crdr_data); } 169 if(reader->typ != R_SC8in1) 170 { 171 NULLFREE(reader->crdr_data); 172 } 82 173 rdr_log_dbg(reader, D_IFD, "ERROR: Can't open %s device", reader->device); 83 174 } … … 103 194 { 104 195 const struct s_cardreader *crdr_ops = reader->crdr; 105 if (!crdr_ops) return ERROR; 106 if (reader->typ == R_SMART && reader->smartdev_found >= 4) { 196 if (!crdr_ops) 197 { 198 return ERROR; 199 } 200 if (reader->typ == R_SMART && reader->smartdev_found >= 4) 201 { 107 202 reader->statuscnt = reader->statuscnt + 1; 108 if (reader->statuscnt == 6) { 203 if (reader->statuscnt == 6) 204 { 205 int32_t in = 0; 206 call(crdr_ops->get_status(reader, &in)); 207 if(in) 208 { 209 reader->modemstat = 1; 210 *card = 1; 211 reader->statuscnt = 0; 212 } 213 else 214 { 215 reader->modemstat = 0; 216 *card = 0; 217 reader->statuscnt = 0; 218 } 219 return OK; 220 } 221 else 222 { 223 *card = reader->modemstat; 224 return OK; 225 } 226 } 227 else 228 { 109 229 int32_t in = 0; 110 230 call(crdr_ops->get_status(reader, &in)); 111 231 if(in) 112 {reader->modemstat = 1; *card = 1; reader->statuscnt = 0;} 232 { 233 *card = 1; 234 } 113 235 else 114 {reader->modemstat = 0; *card = 0; reader->statuscnt = 0;} 236 { 237 *card = 0; 238 } 115 239 return OK; 116 } else {117 *card = reader->modemstat;118 return OK;119 }120 }121 else {122 int32_t in = 0;123 call(crdr_ops->get_status(reader, &in));124 if(in)125 { *card = 1;}126 else127 { *card = 0;}128 return OK;129 240 } 130 241 … … 134 245 { 135 246 rdr_log_dbg(reader, D_IFD, "Activating card"); 136 137 247 const struct s_cardreader *crdr_ops = reader->crdr; 138 248 if (!crdr_ops) return ERROR; 139 140 249 reader->current_baudrate = DEFAULT_BAUDRATE; 141 250 if(reader->atr[0] != 0 && !reader->ins7e11_fast_reset) … … 149 258 call(crdr_ops->activate(reader, atr)); 150 259 if(crdr_ops->skip_extra_atr_parsing) 151 { return OK; } 260 { 261 return OK; 262 } 152 263 } 153 264 … … 155 266 uint32_t atr_size; 156 267 ATR_GetRaw(atr, atrarr, &atr_size); 157 char tmp[atr_size * 3 + 1]; 158 rdr_log(reader, "ATR: %s", cs_hexdump(1, atrarr, atr_size, tmp, sizeof(tmp))); 268 char tmp1[atr_size * 3 + 1]; 269 memcpy(current.atr, cs_hexdump(1, atrarr, atr_size, tmp1, sizeof(tmp1)), atr_size * 3 - 1); 270 current.atr[atr_size * 3 - 1] = '\0'; 271 rdr_log(reader, "ATR: %s", current.atr); 159 272 memcpy(reader->card_atr, atrarr, atr_size); 160 273 reader->card_atr_length = atr_size; 161 162 /* Get ICC reader->convention */ 163 if(ATR_GetConvention(atr, &(reader->convention)) != ATR_OK) 164 { 165 rdr_log(reader, "ERROR: Could not read reader->convention"); 166 reader->convention = 0; 167 reader->protocol_type = 0; 274 findatr(reader); 275 if ( current.found == 1 ) 276 { 277 rdr_log(reader, "%s recognized", current.providername); 278 } 279 280 if(current.badcard == 1 ) /* set badcard in cardlist.h */ 281 { 282 current.badcard = 0; 283 rdr_log(reader, "Bad Card -> quick restart"); 284 add_job(reader->client, ACTION_READER_RESTART, NULL, 0); 168 285 return ERROR; 169 286 } 170 171 reader->protocol_type = ATR_PROTOCOL_TYPE_T0; 172 173 // Parse_ATR and InitCard need to be included in lock because they change parity of serial port 174 if(crdr_ops->lock) 175 { crdr_ops->lock(reader); } 176 177 int32_t ret = Parse_ATR(reader, atr, deprecated); 178 179 if(crdr_ops->unlock) 180 { crdr_ops->unlock(reader); } 181 182 if(ret) 183 { rdr_log(reader, "ERROR: Parse_ATR returned error"); } 184 if(ret) 185 { return ERROR; } 186 rdr_log_dbg(reader, D_IFD, "Card succesfully activated"); 187 287 else 288 { 289 290 /* Get ICC reader->convention */ 291 if(ATR_GetConvention(atr, &(reader->convention)) != ATR_OK) 292 { 293 rdr_log(reader, "ERROR: Could not read reader->convention"); 294 reader->convention = 0; 295 reader->protocol_type = 0; 296 return ERROR; 297 } 298 reader->protocol_type = ATR_PROTOCOL_TYPE_T0; 299 if(crdr_ops->lock) 300 { 301 crdr_ops->lock(reader); 302 } 303 int32_t ret = Parse_ATR(reader, atr, deprecated); 304 if(crdr_ops->unlock) 305 { 306 crdr_ops->unlock(reader); 307 } 308 if(ret) 309 { 310 rdr_log(reader, "ERROR: Parse_ATR returned error"); 311 } 312 if(ret) 313 { 314 return ERROR; 315 } 316 } 317 318 #ifdef READER_NAGRA_MERLIN 319 320 char tmp[atr_size * 3 + 1]; 321 322 if(current.ishd04 == 1) 323 { 324 rdr_log_dbg(reader, D_READER, "HD04 merlin handling"); 325 calculate_cas7_vars(reader, atr); 326 } 327 else if(current.ishd03 == 1 || current.ishd04 == 1) // Switch ROM 328 { 329 330 static uint8_t changerom_handshake[] = { 0x80, 0xCA, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10 }; 331 332 calculate_changerom_cmd(reader, atr, &changerom_handshake[5]); 333 memset(reader->rom, 0, 15); 334 unsigned char cta_res[CTA_RES_LEN]; 335 memset(cta_res, 0, CTA_RES_LEN); 336 uint16_t cta_lr; 337 uint8_t block_nad = 0; 338 339 changerom_handshake[4] = 0x11; // 0x11: length of data we will send 340 uint8_t cta_res1_ok = 0x61; 341 uint8_t cta_res2_ok = 0x10; 342 343 if(reader->protocol_type != ATR_PROTOCOL_TYPE_T0) 344 { 345 block_nad = 0x21; 346 changerom_handshake[0] = 0x80; // fix for mipsel router 347 changerom_handshake[4] = 0x10; // 0x10: length of data we will send 348 cta_res1_ok = 0x90; 349 cta_res2_ok = 0x00; 350 } 351 352 //rdr_log_dbg(reader, D_READER, "try to init nagra layer"); 353 rdr_log(reader,"try to init nagra layer"); 354 355 //rdr_log_dump_dbg(reader, D_READER, changerom_handshake, sizeof(changerom_handshake), "changerom_handshake data:"); 356 357 if(!ICC_Async_CardWrite(reader, changerom_handshake, sizeof(changerom_handshake), cta_res, &cta_lr, block_nad)) 358 { 359 if(cta_res[cta_lr-2] == cta_res1_ok && cta_res[cta_lr-1] == cta_res2_ok) 360 { 361 //rdr_log_dbg(reader, D_READER, "switch to nagra layer OK"); 362 rdr_log(reader, "switch to nagra layer OK"); 363 uint8_t cmd_data[cta_lr+2] ; 364 AES128_CBC_decrypt_buffer(cmd_data,cta_res, (cta_lr-2), &reader->cas7_aes_key[16], reader->cas7_aes_iv); 365 memset(atr, 0, 1); 366 call(crdr_ops->activate(reader, atr)); //try to read the atr of this layer 367 ATR_GetRaw(atr, atrarr, &atr_size); 368 //rdr_log_dbg(reader, D_READER, "Nagra layer ATR: %s", cs_hexdump(1, atrarr, atr_size, tmp, sizeof(tmp))); 369 rdr_log(reader,"Nagra layer ATR: %s", cs_hexdump(1, atrarr, atr_size, tmp, sizeof(tmp))); 370 calculate_cas7_vars(reader, atr); 371 if(crdr_ops->lock) 372 { 373 crdr_ops->lock(reader); 374 } 375 Parse_ATR(reader, atr, deprecated); 376 if(crdr_ops->unlock) 377 { 378 crdr_ops->unlock(reader); 379 } 380 } 381 else 382 { 383 //rdr_log_dbg(reader, D_READER, "Switch to nagra layer failed!"); 384 rdr_log(reader,"Switch to nagra layer failed!"); 385 return ERROR; 386 } 387 } 388 else 389 { 390 //rdr_log_dbg(reader, D_READER, "Switch to nagra layer command failed!"); 391 rdr_log(reader,"Switch to nagra layer command failed!"); 392 return ERROR; 393 } 394 memcpy(reader->card_atr, atrarr, atr_size); 395 reader->card_atr_length = atr_size; 396 memcpy(reader->rom, atr->hb, (atr->hbn>15)?15:atr->hbn);// get historical bytes from atr 397 } 398 #endif 399 rdr_log_dbg(reader, D_READER, "Card succesfully activated"); 400 188 401 return OK; 189 } 190 191 int32_t ICC_Async_CardWrite(struct s_reader *reader, unsigned char *command, uint16_t command_len, unsigned char *rsp, uint16_t *lr )402 } 403 404 int32_t ICC_Async_CardWrite(struct s_reader *reader, unsigned char *command, uint16_t command_len, unsigned char *rsp, uint16_t *lr, uint8_t block_nad) 192 405 { 193 406 const struct s_cardreader *crdr_ops = reader->crdr; 194 407 if (!crdr_ops) return ERROR; 195 408 int32_t ret; 196 197 409 *lr = 0; //will be returned in case of error 198 410 if(crdr_ops->card_write) … … 202 414 return OK; 203 415 } 204 205 416 if(crdr_ops->lock) 206 { crdr_ops->lock(reader); } 207 417 { 418 crdr_ops->lock(reader); 419 } 208 420 int32_t try = 1; 209 421 uint16_t type = 0; 210 422 do 211 423 { 212 if(try > 1){ 213 rdr_log(reader, "Warning: needed try nr %i, next ECM has some delay", try); 214 } 215 216 switch(reader->protocol_type){ 217 424 switch(reader->protocol_type) 425 { 426 if(try > 1) 427 rdr_log(reader, "Warning: needed try nr %i, next ECM has some delay", try); 218 428 case ATR_PROTOCOL_TYPE_T0: 219 429 ret = Protocol_T0_Command(reader, command, command_len, rsp, lr); … … 221 431 break; 222 432 case ATR_PROTOCOL_TYPE_T1: 223 ret = Protocol_T1_Command(reader, command, command_len, rsp, lr );433 ret = Protocol_T1_Command(reader, command, command_len, rsp, lr, block_nad); 224 434 type = 1; 225 435 if(ret != OK && !crdr_ops->skip_t1_command_retries) … … 228 438 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); 229 439 unsigned char resync[] = { 0x21, 0xC0, 0x00, 0xE1 }; 230 ret = Protocol_T1_Command(reader, resync, sizeof(resync), rsp, lr );440 ret = Protocol_T1_Command(reader, resync, sizeof(resync), rsp, lr, 0); 231 441 if(ret == OK) 232 442 { 233 //reader->ifsc = DEFAULT_IFSC; //tryfix cardtimeouts: ifsc is setup at card init, on resync it should not return to default_ifsc 443 //reader->ifsc = DEFAULT_IFSC; 444 //tryfix cardtimeouts: ifsc is setup at card init, on resync it should not return to default_ifsc 234 445 rdr_log(reader, "T1 Resync command succesfull ifsc = %i", reader->ifsc); 235 446 ret = ERROR; … … 241 452 ICC_Async_Activate(reader, &atr, reader->deprecated); 242 453 if(crdr_ops->unlock) 243 { crdr_ops->unlock(reader); } 454 { 455 crdr_ops->unlock(reader); 456 } 244 457 return ERROR; 245 458 } … … 257 470 try++; 258 471 } 259 while((try < 3) && (ret != OK)); //always do one retry when failing 260 472 while((try < 3) && (ret != OK)); //always do one retry when failing 261 473 if(crdr_ops->unlock) 262 { crdr_ops->unlock(reader); } 263 474 { 475 crdr_ops->unlock(reader); 476 } 264 477 if(ret) 265 478 { … … 267 480 return ERROR; 268 481 } 269 270 482 rdr_log_dump_dbg(reader, D_READER, rsp, *lr, "Answer from cardreader:"); 271 483 return OK; … … 274 486 int32_t ICC_Async_GetTimings(struct s_reader *reader, uint32_t wait_etu) 275 487 { 276 int32_t timeout = ETU_to_us(reader, wait_etu) ;488 int32_t timeout = ETU_to_us(reader, wait_etu)*2; 277 489 rdr_log_dbg(reader, D_IFD, "Setting timeout to %i ETU (%d us)", wait_etu, timeout); 278 490 return timeout; … … 284 496 if (!crdr_ops) return ERROR; 285 497 286 if(expectedlen) //expectedlen = 0 means expected len is unknown 287 { rdr_log_dbg(reader, D_IFD, "Transmit size %d bytes, expected len %d bytes, delay %d us, timeout=%d us", size, expectedlen, delay, timeout); } 498 if(expectedlen) 499 { 500 rdr_log_dbg(reader, D_IFD, "Transmit size %d bytes, expected len %d bytes, delay %d us, timeout=%d us", size, expectedlen, delay, timeout); 501 } 288 502 else 289 { rdr_log_dbg(reader, D_IFD, "Transmit size %d bytes, delay %d us, timeout=%d us", size, delay, timeout); } 290 rdr_log_dump_dbg(reader, D_IFD, data, size, "Transmit:"); 503 { 504 rdr_log_dbg(reader, D_IFD, "Transmit size %d bytes, delay %d us, timeout=%d us", size, delay, timeout); 505 } 506 //rdr_log_dump_dbg(reader, D_IFD, data, size, "Transmit:"); 507 rdr_log_dump_dbg(reader, D_READER, data, size, "Transmit:"); 291 508 unsigned char *sent = data; 292 293 509 if(reader->convention == ATR_CONVENTION_INVERSE && crdr_ops->need_inverse) 294 510 { 295 511 ICC_Async_InvertBuffer(reader, size, sent); 296 512 } 297 298 513 call(crdr_ops->transmit(reader, sent, size, expectedlen, delay, timeout)); 299 514 rdr_log_dbg(reader, D_IFD, "Transmit succesful"); … … 303 518 ICC_Async_InvertBuffer(reader, size, sent); 304 519 } 305 306 520 return OK; 307 521 } … … 313 527 314 528 rdr_log_dbg(reader, D_IFD, "Receive size %d bytes, delay %d us, timeout=%d us", size, delay, timeout); 529 rdr_log_dump_dbg(reader, D_IFD, data, size, "RECEIVED:"); 315 530 call(crdr_ops->receive(reader, data, size, delay, timeout)); 316 531 rdr_log_dbg(reader, D_IFD, "Receive succesful"); 317 532 if(reader->convention == ATR_CONVENTION_INVERSE && crdr_ops->need_inverse == 1) 533 { 318 534 ICC_Async_InvertBuffer(reader, size, data); 535 } 319 536 return OK; 320 537 } … … 324 541 const struct s_cardreader *crdr_ops = reader->crdr; 325 542 if (!crdr_ops) return ERROR; 326 327 543 rdr_log_dbg(reader, D_IFD, "Closing device %s", reader->device); 328 544 call(crdr_ops->close(reader)); 329 545 if(reader->typ != R_SC8in1) 330 { 331 332 333 546 { 547 NULLFREE(reader->crdr_data); 548 NULLFREE(reader->csystem_data); 549 } 334 550 rdr_log_dbg(reader, D_IFD, "Device %s succesfully closed", reader->device); 335 551 return OK; … … 352 568 } 353 569 354 /*static uint32_t ICC_Async_GetClockRate_NewSmart(int32_t cardmhz)355 {356 return (cardmhz * 10000L);357 358 }*/359 360 570 static uint32_t ICC_Async_GetClockRate(int32_t cardmhz) 361 571 { … … 365 575 case 358: 366 576 return (372L * 9600L); 367 case 368: 577 case 368: 368 578 return (384L * 9600L); 369 579 default: … … 374 584 static int32_t ICC_Async_GetPLL_Divider(struct s_reader *reader) 375 585 { 376 if(reader->divider != 0) { return reader->divider; } 377 586 if(reader->divider != 0) 587 { 588 return reader->divider; 589 } 378 590 if(reader->cardmhz != 8300) /* Check dreambox is not DM7025 */ 379 591 { … … 381 593 divider = ((float) reader->cardmhz) / ((float) reader->mhz); 382 594 if (tempfi == 9) reader->divider = (int32_t) divider; // some card's runs only when slightly oveclocked like HD02 383 else { 384 reader->divider = (int32_t) divider; 385 if(divider > reader->divider) { reader->divider++; } /* to prevent over clocking, ceil (round up) the divider */ 595 else 596 { 597 reader->divider = (int32_t) divider; 598 if(divider > reader->divider) 599 { 600 reader->divider++; /* to prevent over clocking, ceil (round up) the divider */ 601 } 386 602 } 387 603 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, 388 604 reader->divider, (float) reader->cardmhz / reader->divider / 100); 389 605 reader->mhz = reader->cardmhz / reader->divider; 390 606 } 391 else /* STB is DM7025 */ 392 { 393 int32_t i, dm7025_clock_freq[] = {518, 461, 395, 360, 319, 296, 267, 244, 230, 212, 197}, 394 dm7025_PLL_setting[] = {6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}, t_cardmhz = reader->mhz; 395 607 else 608 { 609 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; 396 610 for(i = 0; i < 11; i++) 397 if(t_cardmhz >= dm7025_clock_freq[i]) { break; } 398 399 if(i > 10) { i = 10; } 400 611 if(t_cardmhz >= dm7025_clock_freq[i]) 612 { 613 break; 614 } 615 if(i > 10) 616 { 617 i = 10; 618 } 401 619 reader->mhz = dm7025_clock_freq[i]; 402 620 reader->divider = dm7025_PLL_setting[i]; /*Nicer way of codeing is: reader->divider = i + 6;*/ 403 404 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, 405 reader->divider, (float) reader->mhz / 100); 406 } 407 621 rdr_log_dbg(reader, D_DEVICE, "DM7025 PLL maxmhz = %.2f, wanted mhz = %.2f, PLL setting used = %d, actualcardclock=%.2f", 622 (float) reader->cardmhz / 100, 623 (float) t_cardmhz / 100, 624 reader->divider, 625 (float) reader->mhz / 100); 626 } 408 627 return reader->divider; 409 628 } … … 415 634 rdr_log_dbg(reader, D_IFD, "%s: size=%u buf[0]=%02x", __func__, size, buffer[0]); 416 635 for(i = 0; i < size; i++) 417 { buffer[i] = ~(INVERT_BYTE(buffer[i])); } 636 { 637 buffer[i] = ~(INVERT_BYTE(buffer[i])); 638 } 418 639 } 419 640 … … 431 652 if(ATR_GetInterfaceByte(atr, numprot - 1, ATR_INTERFACE_BYTE_TD, &tx) == ATR_OK) 432 653 if((tx & 0xF0) == 0) 433 { numprot--; } 654 { 655 numprot--; 656 } 434 657 int32_t i, point; 435 658 char txt[50]; 436 659 bool OffersT[3]; //T14 stored as T2 437 660 for(i = 0; i <= 2; i++) 438 { OffersT[i] = 0; } 661 { 662 OffersT[i] = 0; 663 } 439 664 for(i = 1; i <= numprot; i++) 440 665 { … … 462 687 snprintf((char *)txt + point, sizeof(txt) - point, "(T%i)", tx); 463 688 if(tx == 14) 464 { OffersT[2] = 1; } 689 { 690 OffersT[2] = 1; 691 } 465 692 else 466 { OffersT[tx] = 1; } 693 { 694 OffersT[tx] = 1; 695 } 467 696 } 468 697 else … … 477 706 for(i = 0; i <= 2; i++) 478 707 if(OffersT[i]) 479 { numprottype ++; } 480 rdr_log_dbg(reader, D_ATR, "%i protocol types detected. Historical bytes: %s", 481 numprottype, cs_hexdump(1, atr->hb, atr->hbn, tmp, sizeof(tmp))); 708 { 709 numprottype ++; 710 } 711 rdr_log_dbg(reader, D_ATR, "%i protocol types detected. Historical bytes: %s", numprottype, cs_hexdump(1, atr->hb, atr->hbn, tmp, sizeof(tmp))); 482 712 483 713 ATR_GetParameter(atr, ATR_PARAMETER_N, &(N)); … … 492 722 { 493 723 unsigned char TA1; 494 if(ATR_GetInterfaceByte(atr, 1 724 if(ATR_GetInterfaceByte(atr, 1, ATR_INTERFACE_BYTE_TA, &TA1) == ATR_OK) 495 725 { 496 726 FI = TA1 >> 4; … … 510 740 } 511 741 uint32_t F = atr_f_table[FI]; 512 rdr_log_dbg(reader, D_ATR, "Specific mode: T%i, F=%d, D=%d, N=%d", 513 reader->protocol_type, F, D, N); 742 rdr_log_dbg(reader, D_ATR, "Specific mode: T%i, F=%d, D=%d, N=%d", reader->protocol_type, F, D, N); 514 743 } 515 744 else //negotiable mode … … 526 755 req[1] = 0x10 | reader->protocol_type; //PTS0 always flags PTS1 to be sent always 527 756 if(ATR_GetInterfaceByte(atr, 1, ATR_INTERFACE_BYTE_TA, &req[2]) != ATR_OK) //PTS1 528 { req[2] = 0x11; } //defaults FI and DI to 1 757 { 758 req[2] = 0x11; //defaults FI and DI to 1 759 } 529 760 uint32_t len = 0; 530 761 call(SetRightParity(reader)); … … 537 768 uint32_t F = atr_f_table[FI]; 538 769 PPS_success = 1; 539 rdr_log_dbg(reader, D_ATR, "PTS Succesfull, selected protocol: T%i, F=%d, D=%d, N=%d", 540 reader->protocol_type, F, D, N); 770 rdr_log_dbg(reader, D_ATR, "PTS Succesfull, selected protocol: T%i, F=%d, D=%d, N=%d", reader->protocol_type, F, D, N); 541 771 } 542 772 else 543 { rdr_log_dump_dbg(reader, D_ATR, req, len, "PTS Failure, response:"); } 773 { 774 rdr_log_dump_dbg(reader, D_ATR, req, len, "PTS Failure, response:"); 775 } 544 776 } 545 777 … … 548 780 { 549 781 unsigned char TA1; 550 if(ATR_GetInterfaceByte(atr, 1 782 if(ATR_GetInterfaceByte(atr, 1, ATR_INTERFACE_BYTE_TA, &TA1) == ATR_OK) 551 783 { 552 784 FI = TA1 >> 4; … … 561 793 { 562 794 if((D == 32) || (D == 12) || (D == 20)) //those values were RFU in old table 563 { D = 0; } // viaccess cards that fail PTS need this 795 { 796 D = 0; // viaccess cards that fail PTS need this 797 } 564 798 } 565 799 uint32_t F = atr_f_table[FI]; 566 800 rdr_log_dbg(reader, D_ATR, "No PTS %s, selected protocol T%i, F=%d, D=%d, N=%d", 567 801 NeedsPTS ? "happened" : "needed", reader->protocol_type, F, D, N); 568 802 } 569 803 }//end negotiable mode … … 581 815 rdr_log(reader, "Warning: D=0 is invalid, forcing D=%d", D); 582 816 } 583 rdr_log (reader, "Init card protocol T%i, FI=%d, F=%d, D=%d, N=%d", reader->protocol_type, FI, F, D, N);817 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); 584 818 if(deprecated == 0) 585 { return InitCard(reader, atr, FI, D, N, deprecated); } 819 { 820 return InitCard(reader, atr, FI, D, N, deprecated); 821 } 586 822 else 587 { return InitCard(reader, atr, ATR_DEFAULT_FI, ATR_DEFAULT_D, N, deprecated); } 823 { 824 return InitCard(reader, atr, ATR_DEFAULT_FI, ATR_DEFAULT_D, N, deprecated); 825 } 588 826 } 589 827 … … 601 839 params[len_request - 1] = PPS_GetPCK(params, len_request - 1); 602 840 rdr_log_dbg(reader, D_IFD, "PTS: Sending request: %s", 603 841 cs_hexdump(1, params, len_request, tmp, sizeof(tmp))); 604 842 605 843 if(crdr_ops->set_protocol) … … 618 856 619 857 rdr_log_dbg(reader, D_IFD, "PTS: Receiving confirm: %s", 620 858 cs_hexdump(1, confirm, len_confirm, tmp, sizeof(tmp))); 621 859 if((len_request != len_confirm) || (memcmp(params, confirm, len_request))) 622 { ret = ERROR; } 860 { 861 ret = ERROR; 862 } 623 863 else 624 { ret = OK; } 864 { 865 ret = OK; 866 } 625 867 626 868 /* Copy PPS handshake */ … … 635 877 636 878 if(PPS_HAS_PPS1(block)) 637 { length++; } 879 { 880 length++; 881 } 638 882 639 883 if(PPS_HAS_PPS2(block)) 640 { length++; } 884 { 885 length++; 886 } 641 887 642 888 if(PPS_HAS_PPS3(block)) 643 { length++; } 889 { 890 length++; 891 } 644 892 645 893 return length; … … 648 896 static uint32_t ETU_to_us(struct s_reader *reader, uint32_t ETU) 649 897 { 650 651 return (uint32_t)((double) ETU * reader->worketu ); // in us898 899 return (uint32_t)((double) ETU * reader->worketu*2); // in us 652 900 } 653 901 … … 673 921 uint16_t parity = PARITY_EVEN; 674 922 if(reader->convention == ATR_CONVENTION_INVERSE) 675 { parity = PARITY_ODD; } 923 { 924 parity = PARITY_ODD; 925 } 676 926 else if(reader->protocol_type == ATR_PROTOCOL_TYPE_T14) 677 { parity = PARITY_NONE; } 927 { 928 parity = PARITY_NONE; 929 } 678 930 679 931 call(ICC_Async_SetParity(reader, parity)); 680 932 681 933 if(crdr_ops->flush && reader->crdr_flush) 682 { IO_Serial_Flush(reader); } 934 { 935 IO_Serial_Flush(reader); 936 } 683 937 684 938 return OK; … … 695 949 //set the amps and the volts according to ATR 696 950 if(ATR_GetParameter(atr, ATR_PARAMETER_I, &I) != ATR_OK) 697 { I = 0; } 951 { 952 I = 0; 953 } 698 954 699 955 tempfi = FI; … … 703 959 { 704 960 if(reader->autospeed == 1) //no overclocking 705 { reader->mhz = atr_fs_table[FI] / 10000; } //we are going to clock the card to this nominal frequency 961 { 962 reader->mhz = atr_fs_table[FI] / 10000; //we are going to clock the card to this nominal frequency 963 } 706 964 707 965 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 708 966 { 709 967 reader->mhz = atr_fs_table[FI] / 10000 ; 710 if((!strncmp(boxtype_get(), "vu", 2 ))||(boxtype_is("ini-8000am"))){reader->mhz = 450;} 968 if((!strncmp(boxtype_get(), "vu", 2 ))||(boxtype_is("ini-8000am"))) 969 { 970 reader->mhz = 450; 971 } 711 972 } 712 973 } … … 737 998 } 738 999 } 739 if(reader->cardmhz > 2000 && reader->typ == R_INTERNAL) { F = reader->mhz; } // for PLL based internal readers 740 else { 741 if (reader->typ == R_SMART || is_smargo_reader(reader)) 742 { 743 if (reader->autospeed == 1) { 744 uint32_t Fsmart = atr_fs_table[FI]; 745 reader->mhz = Fsmart/10000; 746 if(reader->mhz >= 1600) { reader->mhz = 1600; } 747 else if(reader->mhz >= 1200) { reader->mhz = 1200; } 748 else if(reader->mhz >= 961) { reader->mhz = 961; } 749 else if(reader->mhz >= 800) { reader->mhz = 800; } 750 else if(reader->mhz >= 686) { reader->mhz = 686; } 751 else if(reader->mhz >= 600) { reader->mhz = 600; } 752 else if(reader->mhz >= 534) { reader->mhz = 534; } 753 else if(reader->mhz >= 480) { reader->mhz = 534; } 754 else if(reader->mhz >= 436) { reader->mhz = 436; } 755 else if(reader->mhz >= 400) { reader->mhz = 400; } 756 else if(reader->mhz >= 369) { reader->mhz = 369; } 757 else if(reader->mhz >= 357) { reader->mhz = 369; } // 357 not suported by smartreader 758 else if(reader->mhz >= 343) { reader->mhz = 343; } 759 else 760 { reader->mhz = 320; } 761 } 762 } 763 F = reader->mhz; } // all other readers 764 reader->worketu = (double)((double)(1 / (double)D) * ((double)Fi / (double)((double)F / 100))); 765 rdr_log(reader, "Calculated work ETU is %.2f us reader mhz = %u", reader->worketu, reader->mhz); 1000 if(reader->cardmhz > 2000 && reader->typ == R_INTERNAL) 1001 { 1002 F = reader->mhz; // for PLL based internal readers 1003 } 1004 else 1005 { 1006 if (reader->typ == R_SMART || is_smargo_reader(reader)) 1007 { 1008 if (reader->autospeed == 1) 1009 { 1010 uint32_t Fsmart = atr_fs_table[FI]; 1011 reader->mhz = Fsmart/10000; 1012 if(reader->mhz >= 1600) 1013 { 1014 reader->mhz = 1600; 1015 } 1016 else if(reader->mhz >= 1200) 1017 { 1018 reader->mhz = 1200; 1019 } 1020 else if(reader->mhz >= 961) 1021 { 1022 reader->mhz = 961; 1023 } 1024 else if(reader->mhz >= 800) 1025 { 1026 reader->mhz = 800; 1027 } 1028 else if(reader->mhz >= 686) 1029 { 1030 reader->mhz = 686; 1031 } 1032 else if(reader->mhz >= 600) 1033 { 1034 reader->mhz = 600; 1035 } 1036 else if(reader->mhz >= 534) 1037 { 1038 reader->mhz = 534; 1039 } 1040 else if(reader->mhz >= 480) 1041 { 1042 reader->mhz = 534; 1043 } 1044 else if(reader->mhz >= 436) 1045 { 1046 reader->mhz = 436; 1047 } 1048 else if(reader->mhz >= 400) 1049 { 1050 reader->mhz = 400; 1051 } 1052 else if(reader->mhz >= 369) 1053 { 1054 reader->mhz = 369; 1055 } 1056 else if(reader->mhz >= 357) 1057 { 1058 reader->mhz = 369; // 357 not suported by smartreader 1059 } 1060 else if(reader->mhz >= 343) 1061 { 1062 reader->mhz = 343; 1063 } 1064 else 1065 { 1066 reader->mhz = 320; 1067 } 1068 } 1069 } 1070 F = reader->mhz; 1071 } // all other readers 1072 reader->worketu = (double)((double)(1 / (double)D) * ((double)Fi / (double)((double)F / 100))); 1073 rdr_log_dbg(reader, D_ATR, "Calculated work ETU is %.2f us reader mhz = %u", reader->worketu, reader->mhz); 766 1074 767 1075 //set timings according to ATR … … 782 1090 783 1091 WWT = (uint32_t) 960 * D * wi; //in work ETU 784 785 /*unsigned char tmpatr[7]; // this is card atr of conax with pairingecmrotation, they need some additional WWT time but this isnt in those ATRs786 tmpatr[0] = 0x3B;787 tmpatr[1] = 0x24;788 tmpatr[2] = 0x00;789 tmpatr[3] = 0x30;790 tmpatr[4] = 0x42;791 tmpatr[5] = 0x30;792 tmpatr[6] = 0x30;793 794 795 // WWT = (uint32_t) 960 * D * wi; //in work ETU796 if (!memcmp(reader->card_atr, tmpatr, sizeof(tmpatr))){ // check for conax pairingecmrotation card atr.797 WWT = WWT * 600; // if found add some additional WWT time798 }*/799 1092 GT = 2; // standard guardtime 800 1093 GT += 1; // start bit … … 803 1096 804 1097 if(N != 255) //add extra Guard Time by ATR 805 { EGT += N; } // T0 protocol, if TC1 = 255 then dont add extra guardtime 1098 { 1099 EGT += N; // T0 protocol, if TC1 = 255 then dont add extra guardtime 1100 } 806 1101 reader->CWT = 0; // T0 protocol doesnt have char waiting time (used to detect errors within 1 single block of data) 807 1102 reader->BWT = 0; // T0 protocol doesnt have block waiting time (used to detect unresponsive card, this is max time for starting a block answer) 808 1103 809 810 1104 rdr_log_dbg(reader, D_ATR, "Protocol: T=%i, WWT=%u, Clockrate=%u", reader->protocol_type, WWT, F * 10000); 811 812 1105 reader->read_timeout = WWT; // Work waiting time used in T0 (max time to signal unresponsive card!) 813 1106 reader->char_delay = GT + EGT; // Character delay is used on T0 814 rdr_log_dbg(reader, D_ATR, "Setting timings: timeout=%u ETU, block_delay=%u ETU, char_delay=%u ETU", 815 reader->read_timeout, reader->block_delay, reader->char_delay); 1107 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); 816 1108 break; 817 1109 } … … 822 1114 // Set IFSC 823 1115 if(ATR_GetInterfaceByte(atr, 3, ATR_INTERFACE_BYTE_TA, &ta) == ATR_NOT_FOUND) 824 { reader->ifsc = DEFAULT_IFSC; } 1116 { 1117 reader->ifsc = DEFAULT_IFSC; 1118 } 825 1119 else if((ta != 0x00) && (ta != 0xFF)) 826 { reader->ifsc = ta; } 1120 { 1121 reader->ifsc = ta; 1122 } 827 1123 else 828 { reader->ifsc = DEFAULT_IFSC; } 1124 { 1125 reader->ifsc = DEFAULT_IFSC; 1126 } 829 1127 830 1128 //FIXME workaround for Smargo until native mode works 831 1129 if(reader->smargopatch == 1) 832 { reader->ifsc = MIN(reader->ifsc, 28); } 1130 { 1131 reader->ifsc = MIN(reader->ifsc, 28); 1132 } 833 1133 else 834 1134 // Towitoko and smartreaders dont allow IFSC > 251 835 { reader->ifsc = MIN(reader->ifsc, MAX_IFSC); } 1135 { 1136 reader->ifsc = MIN(reader->ifsc, MAX_IFSC); 1137 } 836 1138 837 1139 #ifndef PROTOCOL_T1_USE_DEFAULT_TIMINGS … … 853 1155 // Set CWT = 11+(2^CWI) work etu 854 1156 reader->CWT = (uint16_t) 11 + (1 << cwi); // in work ETU 855 // Set BWT = (2^BWI * 960 * 372 / clockspeed in mhz) us + 11*work etu856 // Set BWT = (2^BWI * 960 * 372 / clockspeed in mhz) / worketu + 11857 1157 858 1158 reader->BWT = (uint32_t) ((1<<bwi) * 960 * 372 / (double)((double)F / 100) / (double) reader->worketu) + 11; // BWT in work ETU 859 1159 860 // Set BGT = 22 * work etu861 1160 BGT = 22L; // Block Guard Time in ETU used to interspace between block responses 862 863 1161 GT = 2; // standard guardtime 864 1162 GT += 1; // start bit … … 867 1165 868 1166 if(N == 255) 869 { GT -= 1; } // special case, ATR says standard 2 etu guardtime is decreased by 1 (in ETU) EGT remains zero! 1167 { 1168 GT -= 1; // special case, ATR says standard 2 etu guardtime is decreased by 1 (in ETU) EGT remains zero! 1169 } 870 1170 else 871 { EGT += N; } // ATR says add extra guardtime (in ETU) 1171 { 1172 EGT += N; // ATR says add extra guardtime (in ETU) 1173 } 872 1174 873 1175 // Set the error detection code type 874 1176 if(ATR_GetInterfaceByte(atr, 3, ATR_INTERFACE_BYTE_TC, &tc) == ATR_NOT_FOUND) 875 { edc = EDC_LRC; } 1177 { 1178 edc = EDC_LRC; 1179 } 876 1180 else 877 { edc = tc & 0x01; } 1181 { 1182 edc = tc & 0x01; 1183 } 878 1184 879 1185 // Set initial send sequence (NS) 880 1186 reader->ns = 1; 881 1187 #ifdef READER_NAGRA_MERLIN 1188 cas7_seq=0x00; 1189 #endif 882 1190 rdr_log_dbg(reader, D_ATR, "Protocol: T=%i: IFSC=%d, CWT=%d etu, BWT=%d etu, BGT=%d etu, EDC=%s, N=%d", 883 884 885 1191 reader->protocol_type, reader->ifsc, 1192 reader->CWT, reader->BWT, 1193 BGT, (edc == EDC_LRC) ? "LRC" : "CRC", N); 886 1194 reader->read_timeout = reader->BWT; 887 1195 reader->block_delay = BGT; 888 1196 reader->char_delay = GT + EGT; 889 rdr_log_dbg(reader, D_ATR, "Setting timings: reader timeout=%u ETU, block_delay=%u ETU, char_delay=%u ETU", 890 reader->read_timeout, reader->block_delay, reader->char_delay); 1197 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); 891 1198 892 1199 break; … … 902 1209 if(atr->hbn >= 6 && !memcmp(atr->hb, "IRDETO", 6) && reader->protocol_type == ATR_PROTOCOL_TYPE_T14) 903 1210 { 904 ETU = 0; // for Irdeto T14 cards, do not set ETU 905 // if ((reader->typ == R_SMART) && (reader->smart_type >= 2)) 906 // reader->worketu *= 2.1; else // increase the worketu for v2 and tripple zigo try out 1211 ETU = 0; 907 1212 reader->worketu *= 2; // overclocked T14 needs this otherwise high ecm reponses 908 1213 } 909 1214 910 struct s_cardreader_settings s = { 1215 struct s_cardreader_settings s = 1216 { 911 1217 .ETU = ETU, 912 1218 .EGT = EGT, … … 926 1232 } 927 1233 928 if(reader->typ == R_INTERNAL) 929 { 930 if(reader->cardmhz > 2000) 931 { 932 rdr_log(reader, "PLL Reader: ATR Fsmax is %i MHz, clocking card to %.2f Mhz (nearest possible mhz specified reader->mhz)", 933 atr_fs_table[FI] / 1000000, (float) reader->mhz / 100); 934 } 935 else 936 { 937 rdr_log(reader, "ATR Fsmax is %i MHz, clocking card to %.2f (specified in reader->mhz)", 938 atr_fs_table[FI] / 1000000, (float) reader->mhz / 100); 939 } 940 } 941 else 942 { 943 if ((reader->typ == R_SMART) && (reader->autospeed == 1)) 944 rdr_log(reader, "ATR Fsmax is %i MHz, clocking card to ATR Fsmax for smartreader cardspeed of %.2f MHz (specified in reader->mhz)", 945 atr_fs_table[FI] / 1000000, (float) reader->mhz / 100); 946 else 947 rdr_log(reader, "ATR Fsmax is %i MHz, clocking card to wanted user cardclock of %.2f MHz (specified in reader->mhz)", 948 atr_fs_table[FI] / 1000000, (float) reader->mhz / 100); 949 } 1234 /* 1235 if(reader->typ == R_INTERNAL) 1236 { 1237 if(reader->cardmhz > 2000){ 1238 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); 1239 }else{ 1240 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); 1241 } 1242 }else{ 1243 if ((reader->typ == R_SMART) && (reader->autospeed == 1)){ 1244 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); 1245 }else{ 1246 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); 1247 } 1248 } 1249 */ 950 1250 951 1251 //Communicate to T1 card IFSD -> we use same as IFSC 1252 952 1253 if(reader->protocol_type == ATR_PROTOCOL_TYPE_T1 && reader->ifsc != DEFAULT_IFSC && !crdr_ops->skip_setting_ifsc) 953 1254 { … … 958 1259 tmp[3] = reader->ifsc; // Information Field size 959 1260 tmp[4] = reader->ifsc ^ 0xE1; 960 ret = Protocol_T1_Command(reader, tmp, sizeof(tmp), rsp, &lr); 961 if(ret != OK) { rdr_log(reader, "Warning: Card returned error on setting ifsd value to %d", reader->ifsc); } 962 else { rdr_log(reader, "Card responded ok for ifsd request of %d", reader->ifsc); } 1261 ret = Protocol_T1_Command(reader, tmp, sizeof(tmp), rsp, &lr, 0); 1262 if(ret != OK) 1263 { 1264 rdr_log(reader, "Warning: Card returned error on setting ifsd value to %d", reader->ifsc); 1265 } 1266 else 1267 { 1268 rdr_log_dbg(reader, D_ATR, "Card responded ok for ifsd request of %d", reader->ifsc); 1269 } 963 1270 } 964 1271 return OK; … … 969 1276 unsigned char pck; 970 1277 uint32_t i; 971 972 1278 pck = block[0]; 973 1279 for(i = 1; i < length; i++) 974 { pck ^= block[i]; } 975 1280 { 1281 pck ^= block[i]; 1282 } 976 1283 return pck; 977 1284 }
Note:
See TracChangeset
for help on using the changeset viewer.