source: trunk/csctapi/icc_async.c@ 4131

Last change on this file since 4131 was 4131, checked in by dingo35, 13 years ago

icc_async.c: Fix compile error for SCI devices
File size: 27.6 KB
Line 
1/*
2 icc_async.c
3 Asynchronous ICC's handling functions
4
5 This file is part of the Unix driver for Towitoko smartcard readers
6 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/or
11 modify it under the terms of the GNU Lesser General Public
12 License as published by the Free Software Foundation; either
13 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 of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 Lesser General Public License for more details.
19
20 You should have received a copy of the GNU Lesser General Public
21 License along with this library; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23*/
24
25#include <stdlib.h>
26#include <stdio.h>
27#include <string.h>
28#include "../globals.h"
29#include "defines.h"
30#include "icc_async.h"
31#include "mc_global.h"
32#include "protocol_t0.h"
33#include "io_serial.h"
34#include "ifd_cool.h"
35#include "ifd_mp35.h"
36#include "ifd_phoenix.h"
37#include "ifd_sc8in1.h"
38#include "ifd_sci.h"
39#include "ifd_smartreader.h"
40#include "ifd_azbox.h"
41
42// Default T0/T14 settings
43#define DEFAULT_WI 10
44// Default T1 settings
45#define DEFAULT_IFSC 32
46#define MAX_IFSC 251 /* Cannot send > 255 buffer */
47#define DEFAULT_CWI 13
48#define DEFAULT_BWI 4
49#define EDC_LRC 0
50
51#define PPS_MAX_LENGTH 6
52#define PPS_HAS_PPS1(block) ((block[1] & 0x10) == 0x10)
53#define PPS_HAS_PPS2(block) ((block[1] & 0x20) == 0x20)
54#define PPS_HAS_PPS3(block) ((block[1] & 0x40) == 0x40)
55
56
57/*
58 * Not exported functions declaration
59 */
60
61static void ICC_Async_InvertBuffer (unsigned size, BYTE * buffer);
62static int Parse_ATR (struct s_reader * reader, ATR * atr, unsigned short deprecated);
63static int PPS_Exchange (struct s_reader * reader, BYTE * params, unsigned *length);
64static unsigned PPS_GetLength (BYTE * block);
65static int InitCard (struct s_reader * reader, ATR * atr, BYTE FI, double d, double n, unsigned short deprecated);
66static unsigned int ETU_to_ms(struct s_reader * reader, unsigned long WWT);
67static BYTE PPS_GetPCK (BYTE * block, unsigned length);
68static int SetRightParity (struct s_reader * reader);
69
70/*
71 * Exported functions definition
72 */
73
74int ICC_Async_Device_Init (struct s_reader *reader)
75{
76 reader->fdmc=-1;
77 cs_debug_mask (D_IFD, "IFD: Opening device %s\n", reader->device);
78
79 reader->written = 0;
80
81 switch(reader->typ) {
82 case R_SC8in1:
83 //pthread_mutex_init(&sc8in1, NULL);
84 pthread_mutex_lock(&sc8in1);
85 if (reader->handle != 0) {//this reader is already initialized
86 pthread_mutex_unlock(&sc8in1);
87 return OK;
88 }
89
90 //this reader is uninitialized, thus the first one, since the first one initializes all others
91
92 //get physical device name
93 int pos = strlen(reader->device)-2; //this is where : should be located; is also valid length of physical device name
94 if (reader->device[pos] != 0x3a) //0x3a = ":"
95 cs_log("ERROR: '%c' detected instead of slot separator `:` at second to last position of device %s", reader->device[pos], reader->device);
96 reader->slot=(int)reader->device[pos+1] - 0x30;
97 reader->device[pos]= 0; //slot 1 reader now gets correct physicalname
98
99 //open physical device
100 reader->handle = open (reader->device, O_RDWR | O_NOCTTY| O_NONBLOCK);
101 if (reader->handle < 0) {
102 cs_log("ERROR opening device %s",reader->device);
103 pthread_mutex_unlock(&sc8in1);
104 return ERROR;
105 }
106
107 //copy physical device name and file handle to other slots
108 struct s_reader *rdr;
109 for (rdr=first_reader; rdr ; rdr=rdr->next) //copy handle to other slots
110 if (rdr->typ == R_SC8in1 && rdr != reader) { //we have another sc8in1 reader
111 unsigned char save = rdr->device[pos];
112 rdr->device[pos]=0; //set to 0 so we can compare device names
113 if (!strcmp(reader->device, rdr->device)) {//we have a match to another slot with same device name
114 rdr->handle = reader->handle;
115 rdr->slot=(int)rdr->device[pos+1] - 0x30;
116 }
117 else
118 rdr->device[pos] = save; //restore character
119 }
120 break;
121 case R_MP35:
122 case R_MOUSE:
123 reader->handle = open (reader->device, O_RDWR | O_NOCTTY| O_NONBLOCK);
124 if (reader->handle < 0) {
125 cs_log("ERROR opening device %s",reader->device);
126 return ERROR;
127 }
128 break;
129#if defined(TUXBOX) && defined(PPC)
130 case R_DB2COM1:
131 case R_DB2COM2:
132 reader->handle = open (reader->device, O_RDWR | O_NOCTTY| O_SYNC);
133 if (reader->handle < 0) {
134 cs_log("ERROR opening device %s",reader->device);
135 return ERROR;
136 }
137 if ((reader->fdmc = open(DEV_MULTICAM, O_RDWR)) < 0) {
138 close(reader->handle);
139 cs_log("ERROR opening device %s",DEV_MULTICAM);
140 return ERROR;
141 }
142 break;
143#endif
144 case R_SMART:
145#if defined(LIBUSB)
146 call (SR_Init(reader));
147 break;
148#else
149 cs_log("ERROR, you have specified 'protocol = smartreader' in oscam.server,");
150 cs_log("recompile with SmartReader support.");
151 return ERROR;
152#endif
153 case R_INTERNAL:
154#ifdef COOL
155 return Cool_Init(reader->device);
156#elif AZBOX
157 return Azbox_Init(reader);
158#elif SCI_DEV
159 #if defined(SH4) || defined(STB04SCI)
160 reader->handle = open (reader->device, O_RDWR|O_NONBLOCK|O_NOCTTY);
161 #else
162 reader->handle = open (reader->device, O_RDWR);
163 #endif
164 if (reader->handle < 0) {
165 cs_log("ERROR opening device %s",reader->device);
166 return ERROR;
167 }
168#else//SCI_DEV
169 cs_log("ERROR, you have specified 'protocol = internal' in oscam.server,");
170 cs_log("recompile with internal reader support.");
171 return ERROR;
172#endif//SCI_DEV
173 break;
174 default:
175 cs_log("ERROR ICC_Device_Init: unknow reader type %i",reader->typ);
176 return ERROR;
177 }
178
179 if (reader->typ == R_MP35)
180 {
181 if (MP35_Init(reader)) {
182 cs_log("ERROR: MP35_Init returns error");
183 MP35_Close (reader);
184 return ERROR;
185 }
186 }
187 else if (reader->typ <= R_MOUSE)
188 if (Phoenix_Init(reader)) {
189 cs_log("ERROR: Phoenix_Init returns error");
190 Phoenix_Close (reader);
191 return ERROR;
192 }
193
194 if (reader->typ == R_SC8in1) {
195 call(Sc8in1_Init(reader));
196 pthread_mutex_unlock(&sc8in1);
197 }
198
199 cs_debug_mask (D_IFD, "IFD: Device %s succesfully opened\n", reader->device);
200 return OK;
201}
202
203int ICC_Async_GetStatus (struct s_reader *reader, int * card)
204{
205 int in;
206
207// printf("\n%08X\n", (int)ifd->io);
208
209 switch(reader->typ) {
210 case R_DB2COM1:
211 case R_DB2COM2:
212#if defined(TUXBOX) && defined(PPC)
213 {
214 ushort msr=1;
215 IO_Serial_Ioctl_Lock(reader, 1);
216 ioctl(reader->fdmc, GET_PCDAT, &msr);
217 if (reader->typ == R_DB2COM2)
218 in=(!(msr & 1));
219 else
220 in=((msr & 0x0f00) == 0x0f00);
221 IO_Serial_Ioctl_Lock(reader, 0);
222 }
223 break;
224#endif
225 case R_SC8in1:
226 call (Sc8in1_GetStatus(reader, &in));
227 break;
228 case R_MP35:
229 case R_MOUSE:
230 call (Phoenix_GetStatus(reader, &in));
231 break;
232#if defined(LIBUSB)
233 case R_SMART:
234 call (SR_GetStatus(reader,&in));
235 break;
236#endif
237 case R_INTERNAL:
238#ifdef SCI_DEV
239 call (Sci_GetStatus(reader, &in));
240#elif COOL
241 call (Cool_GetStatus(&in));
242#elif AZBOX
243 call(Azbox_GetStatus(reader, &in));
244#endif
245 break;
246 default:
247 cs_log("ERROR ICC_Get_Status: unknow reader type %i",reader->typ);
248 return ERROR;
249 }
250
251 if (in)
252 *card = TRUE;
253 else
254 *card = FALSE;
255 // this debug is not really useful and polute the log in debug mode
256 // cs_debug_mask (D_IFD, "IFD: Status = %s", in ? "card": "no card");
257
258 return OK;
259}
260
261int ICC_Async_Activate (struct s_reader *reader, ATR * atr, unsigned short deprecated)
262{
263 int cs_ptyp_orig=cur_client()->cs_ptyp;
264 cur_client()->cs_ptyp=D_DEVICE;
265 cs_debug_mask (D_IFD, "IFD: Activating card in reader %s\n", reader->label);
266
267 reader->current_baudrate = DEFAULT_BAUDRATE; //this is needed for all readers to calculate work_etu for timings
268
269 if (reader->atr[0] != 0) {
270 cs_log("using ATR from reader config");
271 ATR_InitFromArray(atr, reader->atr, 33);
272 }
273 else {
274 switch(reader->typ) {
275 case R_MP35:
276 case R_DB2COM1:
277 case R_DB2COM2:
278 case R_SC8in1:
279 case R_MOUSE:
280 LOCK_SC8IN1;
281 int ret = Phoenix_Reset(reader, atr);
282 UNLOCK_SC8IN1;
283 if (ret) {
284 cs_debug_mask(D_TRACE, "ERROR, function call Phoenix_Reset returns error.");
285 return ERROR;
286 }
287 break;
288#if defined(LIBUSB)
289 case R_SMART:
290 call (SR_Reset(reader, atr));
291 break;
292#endif
293 case R_INTERNAL:
294#ifdef SCI_DEV
295 call (Sci_Activate(reader));
296 call (Sci_Reset(reader, atr));
297#elif COOL
298 call (Cool_Reset(atr));
299#elif AZBOX
300 call (Azbox_Reset(reader, atr));
301#endif
302 break;
303 default:
304 cs_log("ERROR ICC_Async_Activate: unknow reader type %i",reader->typ);
305 return ERROR;
306 }
307 }
308
309 unsigned char atrarr[64];
310 unsigned int atr_size;
311 ATR_GetRaw(atr, atrarr, &atr_size);
312 cs_ri_log(reader, "ATR: %s", cs_hexdump(1, atrarr, atr_size));
313
314
315 /* Get ICC reader->convention */
316 if (ATR_GetConvention (atr, &(reader->convention)) != ATR_OK) {
317 cs_log("ERROR: Could not read reader->convention");
318 reader->convention = 0;
319 reader->protocol_type = 0;
320 return ERROR;
321 }
322
323 reader->protocol_type = ATR_PROTOCOL_TYPE_T0;
324
325 cur_client()->cs_ptyp=D_ATR;
326 LOCK_SC8IN1;
327 int ret = Parse_ATR(reader, atr, deprecated);
328 UNLOCK_SC8IN1; //Parse_ATR and InitCard need to be included in lock because they change parity of serial port
329 if (ret)
330 cs_log("ERROR: Parse_ATR returned error");
331 cur_client()->cs_ptyp=D_DEVICE;;
332 if (ret)
333 return ERROR;
334 cs_debug_mask (D_IFD, "IFD: Card in reader %s succesfully activated\n", reader->label);
335
336 cur_client()->cs_ptyp=cs_ptyp_orig;
337 return OK;
338}
339
340int ICC_Async_CardWrite (struct s_reader *reader, unsigned char *command, unsigned short command_len, unsigned char *rsp, unsigned short *lr)
341{
342 *lr = 0; //will be returned in case of error
343
344 int ret;
345 cur_client()->cs_ptyp=D_DEVICE;
346
347 LOCK_SC8IN1;
348
349 switch (reader->protocol_type) {
350 case ATR_PROTOCOL_TYPE_T0:
351 ret = Protocol_T0_Command (reader, command, command_len, rsp, lr);
352 break;
353 case ATR_PROTOCOL_TYPE_T1:
354 {
355 int try = 1;
356 do {
357 ret = Protocol_T1_Command (reader, command, command_len, rsp, lr);
358 if (ret == OK)
359 break;
360 try++;
361 //try to resync
362 unsigned char resync[] = { 0x21, 0xC0, 0x00, 0xE1 };
363 Protocol_T1_Command (reader, resync, sizeof(resync), rsp, lr);
364 reader->ifsc = DEFAULT_IFSC;
365 } while (try <= 3);
366 break;
367 }
368 case ATR_PROTOCOL_TYPE_T14:
369 ret = Protocol_T14_ExchangeTPDU (reader, command, command_len, rsp, lr);
370 break;
371 default:
372 cs_log("Error, unknown protocol type %i",reader->protocol_type);
373 ret = ERROR;
374 }
375
376 UNLOCK_SC8IN1;
377
378 if (ret) {
379 cs_debug_mask(D_TRACE, "ERROR, function call Protocol_T0_Command returns error.");
380 return ERROR;
381 }
382
383 cs_ddump(rsp, *lr, "answer from cardreader %s:", reader->label);
384 cur_client()->cs_ptyp=D_READER;
385 return OK;
386}
387
388int ICC_Async_SetTimings (struct s_reader * reader, unsigned wait_etu)
389{
390 reader->read_timeout = ETU_to_ms(reader, wait_etu);
391 cs_debug_mask(D_IFD, "Setting timeout to %i", wait_etu);
392 return OK;
393}
394
395int ICC_Async_Transmit (struct s_reader *reader, unsigned size, BYTE * data)
396{
397 cs_ddump_mask(D_IFD, data, size, "IFD Transmit: ");
398 BYTE *buffer = NULL, *sent;
399
400 if (reader->convention == ATR_CONVENTION_INVERSE && reader->typ <= R_MOUSE) {
401 buffer = (BYTE *) calloc(sizeof (BYTE), size);
402 memcpy (buffer, data, size);
403 ICC_Async_InvertBuffer (size, buffer);
404 sent = buffer;
405 }
406 else
407 sent = data;
408
409 switch(reader->typ) {
410 case R_MP35:
411 case R_DB2COM1:
412 case R_DB2COM2:
413 case R_SC8in1:
414 case R_MOUSE:
415 call (Phoenix_Transmit (reader, sent, size, reader->block_delay, reader->char_delay));
416 break;
417#if defined(LIBUSB)
418 case R_SMART:
419 call (SR_Transmit(reader, sent, size));
420 break;
421#endif
422 case R_INTERNAL:
423#ifdef COOL
424 call (Cool_Transmit(sent, size));
425#elif AZBOX
426 call (Azbox_Transmit(reader, sent, size));
427#elif SCI_DEV
428 call (Phoenix_Transmit (reader, sent, size, 0, 0)); //the internal reader will provide the delay
429#endif
430 break;
431 default:
432 cs_log("ERROR ICC_Async_Transmit: unknow reader type %i",reader->typ);
433 return ERROR;
434 }
435
436 if (buffer)
437 free (buffer);
438 cs_debug_mask(D_IFD, "IFD Transmit succesful");
439 return OK;
440}
441
442int ICC_Async_Receive (struct s_reader *reader, unsigned size, BYTE * data)
443{
444 switch(reader->typ) {
445 case R_MP35:
446 case R_DB2COM1:
447 case R_DB2COM2:
448 case R_SC8in1:
449 case R_MOUSE:
450 call (Phoenix_Receive (reader, data, size, reader->read_timeout));
451 break;
452#if defined(LIBUSB)
453 case R_SMART:
454 call (SR_Receive(reader, data, size));
455 break;
456#endif
457 case R_INTERNAL:
458#ifdef COOL
459 call (Cool_Receive(data, size));
460#elif AZBOX
461 call (Azbox_Receive(reader, data, size));
462#elif SCI_DEV
463 call (Phoenix_Receive (reader, data, size, reader->read_timeout));
464#endif
465 break;
466 default:
467 cs_log("ERROR ICC_Async_Receive: unknow reader type %i",reader->typ);
468 return ERROR;
469 }
470
471 if (reader->convention == ATR_CONVENTION_INVERSE && reader->typ <= R_MOUSE)
472 ICC_Async_InvertBuffer (size, data);
473
474 cs_ddump_mask(D_IFD, data, size, "IFD Received: ");
475 return OK;
476}
477
478int ICC_Async_Close (struct s_reader *reader)
479{ //FIXME this routine is never called!
480 cs_debug_mask (D_IFD, "IFD: Closing device %s", reader->device);
481
482 switch(reader->typ) {
483 case R_MP35:
484 call (MP35_Close(reader));
485 break;
486 case R_DB2COM1:
487 case R_DB2COM2:
488 case R_MOUSE:
489 call (Phoenix_Close(reader));
490 break;
491#if defined(LIBUSB)
492 case R_SMART:
493 call (SR_Close(reader));
494 break;
495#endif
496 case R_INTERNAL:
497#ifdef SCI_DEV
498 /* Dectivate ICC */
499 call (Sci_Deactivate(reader));
500 call (Phoenix_Close(reader));
501#endif
502 break;
503 default:
504 cs_log("ERROR ICC_Async_Close: unknow reader type %i",reader->typ);
505 return ERROR;
506 }
507
508 cs_debug_mask (D_IFD, "IFD: Device %s succesfully closed", reader->device);
509 return OK;
510}
511
512static unsigned long ICC_Async_GetClockRate (int cardmhz)
513{
514 switch (cardmhz) {
515 case 357:
516 case 358:
517 return (372L * 9600L);
518 case 368:
519 return (384L * 9600L);
520 default:
521 return cardmhz * 10000L;
522 }
523}
524
525static void ICC_Async_InvertBuffer (unsigned size, BYTE * buffer)
526{
527 uint i;
528
529 for (i = 0; i < size; i++)
530 buffer[i] = ~(INVERT_BYTE (buffer[i]));
531}
532
533static int Parse_ATR (struct s_reader * reader, ATR * atr, unsigned short deprecated)
534{
535 BYTE FI = ATR_DEFAULT_FI;
536 //BYTE t = ATR_PROTOCOL_TYPE_T0;
537 double d = ATR_DEFAULT_D;
538 double n = ATR_DEFAULT_N;
539 int ret;
540
541 int numprot = atr->pn;
542 //if there is a trailing TD, this number is one too high
543 BYTE tx;
544 if (ATR_GetInterfaceByte (atr, numprot-1, ATR_INTERFACE_BYTE_TD, &tx) == ATR_OK)
545 if ((tx & 0xF0) == 0)
546 numprot--;
547 int i,point;
548 char txt[50];
549 bool OffersT[3]; //T14 stored as T2
550 for (i = 0; i <= 2; i++)
551 OffersT[i] = FALSE;
552 for (i=1; i<= numprot; i++) {
553 point = 0;
554 if (ATR_GetInterfaceByte (atr, i, ATR_INTERFACE_BYTE_TA, &tx) == ATR_OK) {
555 sprintf((char *)txt+point,"TA%i=%02X ",i,tx);
556 point +=7;
557 }
558 if (ATR_GetInterfaceByte (atr, i, ATR_INTERFACE_BYTE_TB, &tx) == ATR_OK) {
559 sprintf((char *)txt+point,"TB%i=%02X ",i,tx);
560 point +=7;
561 }
562 if (ATR_GetInterfaceByte (atr, i, ATR_INTERFACE_BYTE_TC, &tx) == ATR_OK) {
563 sprintf((char *)txt+point,"TC%i=%02X ",i,tx);
564 point +=7;
565 }
566 if (ATR_GetInterfaceByte (atr, i, ATR_INTERFACE_BYTE_TD, &tx) == ATR_OK) {
567 sprintf((char *)txt+point,"TD%i=%02X ",i,tx);
568 point +=7;
569 tx &= 0X0F;
570 sprintf((char *)txt+point,"(T%i)",tx);
571 if (tx == 14)
572 OffersT[2] = TRUE;
573 else
574 OffersT[tx] = TRUE;
575 }
576 else {
577 sprintf((char *)txt+point,"no TD%i means T0",i);
578 OffersT[0] = TRUE;
579 }
580 cs_debug("%s",txt);
581 }
582
583 int numprottype = 0;
584 for (i = 0; i <= 2; i++)
585 if (OffersT[i])
586 numprottype ++;
587 cs_debug("%i protocol types detected. Historical bytes: %s",numprottype, cs_hexdump(1,atr->hb,atr->hbn));
588
589 ATR_GetParameter (atr, ATR_PARAMETER_N, &(n));
590 ATR_GetProtocolType(atr,1,&(reader->protocol_type)); //get protocol from TD1
591 BYTE TA2;
592 bool SpecificMode = (ATR_GetInterfaceByte (atr, 2, ATR_INTERFACE_BYTE_TA, &TA2) == ATR_OK); //if TA2 present, specific mode, else negotiable mode
593 if (SpecificMode) {
594 reader->protocol_type = TA2 & 0x0F;
595 if ((TA2 & 0x10) != 0x10) { //bit 5 set to 0 means F and D explicitly defined in interface characters
596 BYTE TA1;
597 if (ATR_GetInterfaceByte (atr, 1 , ATR_INTERFACE_BYTE_TA, &TA1) == ATR_OK) {
598 FI = TA1 >> 4;
599 ATR_GetParameter (atr, ATR_PARAMETER_D, &(d));
600 }
601 else {
602 FI = ATR_DEFAULT_FI;
603 d = ATR_DEFAULT_D;
604 }
605 }
606 else {
607 cs_log("Specific mode: speed 'implicitly defined', not sure how to proceed, assuming default values");
608 FI = ATR_DEFAULT_FI;
609 d = ATR_DEFAULT_D;
610 }
611 cs_debug("Specific mode: T%i, F=%.0f, D=%.6f, N=%.0f\n", reader->protocol_type, (double) atr_f_table[FI], d, n);
612 }
613 else { //negotiable mode
614
615 bool PPS_success = FALSE;
616 bool NeedsPTS = ((reader->protocol_type != ATR_PROTOCOL_TYPE_T14) && (numprottype > 1 || (atr->ib[0][ATR_INTERFACE_BYTE_TA].present == TRUE && atr->ib[0][ATR_INTERFACE_BYTE_TA].value != 0x11) || n == 255)); //needs PTS according to old ISO 7816
617 if (NeedsPTS && deprecated == 0) {
618 // PTSS PTS0 PTS1 PCK
619 BYTE req[6] = { 0xFF, 0x10, 0x00, 0x00 }; //we currently do not support PTS2, standard guardtimes or PTS3,
620 //but spare 2 bytes in arrayif card responds with it
621 req[1]=0x10 | reader->protocol_type; //PTS0 always flags PTS1 to be sent always
622 if (ATR_GetInterfaceByte (atr, 1, ATR_INTERFACE_BYTE_TA, &req[2]) != ATR_OK) //PTS1
623 req[2] = 0x11; //defaults FI and DI to 1
624 unsigned int len = 0;
625 call (SetRightParity (reader));
626 ret = PPS_Exchange (reader, req, &len);
627 if (ret == OK) {
628 FI = req[2] >> 4;
629 BYTE DI = req[2] & 0x0F;
630 d = (double) (atr_d_table[DI]);
631 PPS_success = TRUE;
632 cs_debug("PTS Succesfull, selected protocol: T%i, F=%.0f, D=%.6f, N=%.0f\n", reader->protocol_type, (double) atr_f_table[FI], d, n);
633 }
634 else
635 cs_ddump(req,len,"PTS Failure, response:");
636 }
637
638 //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)
639 if (!PPS_success) {//last PPS not succesfull
640 BYTE TA1;
641 if (ATR_GetInterfaceByte (atr, 1 , ATR_INTERFACE_BYTE_TA, &TA1) == ATR_OK) {
642 FI = TA1 >> 4;
643 ATR_GetParameter (atr, ATR_PARAMETER_D, &(d));
644 }
645 else { //do not obey TA1
646 FI = ATR_DEFAULT_FI;
647 d = ATR_DEFAULT_D;
648 }
649 if (NeedsPTS) {
650 if ((d == 32) || (d == 12) || (d == 20)) //those values were RFU in old table
651 d = 0; // viaccess cards that fail PTS need this
652 }
653
654 cs_debug("No PTS %s, selected protocol T%i, F=%.0f, D=%.6f, N=%.0f\n", NeedsPTS?"happened":"needed", reader->protocol_type, (double) atr_f_table[FI], d, n);
655 }
656 }//end negotiable mode
657
658 //make sure no zero values
659 double F = (double) atr_f_table[FI];
660 if (!F) {
661 FI = ATR_DEFAULT_FI;
662 cs_log("Warning: F=0 is invalid, forcing FI=%d", FI);
663 }
664 if (!d) {
665 d = ATR_DEFAULT_D;
666 cs_log("Warning: D=0 is invalid, forcing D=%.0f",d);
667 }
668
669 if (deprecated == 0)
670 return InitCard (reader, atr, FI, d, n, deprecated);
671 else
672 return InitCard (reader, atr, ATR_DEFAULT_FI, ATR_DEFAULT_D, n, deprecated);
673}
674
675static int PPS_Exchange (struct s_reader * reader, BYTE * params, unsigned *length)
676{
677 BYTE confirm[PPS_MAX_LENGTH];
678 unsigned len_request, len_confirm;
679 int ret;
680
681 len_request = PPS_GetLength (params);
682 params[len_request - 1] = PPS_GetPCK(params, len_request - 1);
683 cs_debug_mask (D_IFD,"PTS: Sending request: %s", cs_hexdump(1, params, len_request));
684
685 /* Send PPS request */
686 call (ICC_Async_Transmit (reader, len_request, params));
687
688 /* Get PPS confirm */
689 call (ICC_Async_Receive (reader, 2, confirm));
690 len_confirm = PPS_GetLength (confirm);
691 call (ICC_Async_Receive (reader, len_confirm - 2, confirm + 2));
692
693 cs_debug_mask(D_IFD, "PTS: Receiving confirm: %s", cs_hexdump(1, confirm, len_confirm));
694 if ((len_request != len_confirm) || (memcmp (params, confirm, len_request)))
695 ret = ERROR;
696 else
697 ret = OK;
698
699 /* Copy PPS handshake */
700 memcpy (params, confirm, len_confirm);
701 (*length) = len_confirm;
702 return ret;
703}
704
705static unsigned PPS_GetLength (BYTE * block)
706{
707 unsigned length = 3;
708
709 if (PPS_HAS_PPS1 (block))
710 length++;
711
712 if (PPS_HAS_PPS2 (block))
713 length++;
714
715 if (PPS_HAS_PPS3 (block))
716 length++;
717
718 return length;
719}
720
721static unsigned int ETU_to_ms(struct s_reader * reader, unsigned long WWT)
722{
723#define CHAR_LEN 10L //character length in ETU, perhaps should be 9 when parity = none?
724 if (WWT > CHAR_LEN)
725 WWT -= CHAR_LEN;
726 else
727 WWT = 0;
728 double work_etu = 1000 / (double)reader->current_baudrate;//FIXME sometimes work_etu should be used, sometimes initial etu
729 return (unsigned int) WWT * work_etu * reader->cardmhz / reader->mhz;
730}
731
732static int ICC_Async_SetParity (struct s_reader * reader, unsigned short parity)
733{
734 switch(reader->typ) {
735 case R_MP35:
736 case R_DB2COM1:
737 case R_DB2COM2:
738 case R_SC8in1:
739 case R_MOUSE:
740 call (IO_Serial_SetParity (reader, parity));
741 break;
742#if defined(LIBUSB)
743 case R_SMART:
744 call (SR_SetParity(reader, parity));
745 break;
746#endif
747 case R_INTERNAL:
748 return OK;
749 default:
750 cs_log("ERROR ICC_Async_SetParity: unknow reader type %i",reader->typ);
751 return ERROR;
752 }
753 return OK;
754}
755
756static int SetRightParity (struct s_reader * reader)
757{
758 //set right parity
759 unsigned short parity = PARITY_EVEN;
760 if (reader->convention == ATR_CONVENTION_INVERSE)
761 parity = PARITY_ODD;
762 else if(reader->protocol_type == ATR_PROTOCOL_TYPE_T14)
763 parity = PARITY_NONE;
764
765#if defined(LIBUSB)
766 if (reader->typ == R_SMART)
767 reader->sr_config->parity = parity;
768#endif
769
770 call (ICC_Async_SetParity(reader, parity));
771
772#ifdef COOL
773 if (reader->typ != R_INTERNAL)
774#endif
775#ifdef AZBOX
776 if (reader->typ != R_INTERNAL)
777#endif
778#if defined(LIBUSB)
779 if (reader->typ != R_SMART)
780#endif
781 IO_Serial_Flush(reader);
782 return OK;
783}
784
785static int InitCard (struct s_reader * reader, ATR * atr, BYTE FI, double d, double n, unsigned short deprecated)
786{
787 double I;
788 double F;
789 unsigned long BGT, edc, EGT, CGT, WWT = 0;
790 unsigned int GT;
791 unsigned long gt_ms;
792
793 //set the amps and the volts according to ATR
794 if (ATR_GetParameter(atr, ATR_PARAMETER_I, &I) != ATR_OK)
795 I = 0;
796
797 //set clock speed to max if internal reader
798 if(reader->typ > R_MOUSE)
799 if (reader->mhz == 357 || reader->mhz == 358) //no overclocking
800 reader->mhz = atr_fs_table[FI] / 10000; //we are going to clock the card to this nominal frequency
801
802 //set clock speed/baudrate must be done before timings
803 //because reader->current_baudrate is used in calculation of timings
804 F = (double) atr_f_table[FI];
805
806 reader->current_baudrate = DEFAULT_BAUDRATE;
807
808 if (deprecated == 0) {
809 if (reader->protocol_type != ATR_PROTOCOL_TYPE_T14) { //dont switch for T14
810 unsigned long baud_temp = d * ICC_Async_GetClockRate (reader->cardmhz) / F;
811 if (reader->typ <= R_MOUSE)
812 call (Phoenix_SetBaudrate (reader, baud_temp));
813 cs_debug_mask(D_IFD, "Setting baudrate to %lu", baud_temp);
814 reader->current_baudrate = baud_temp; //this is needed for all readers to calculate work_etu for timings
815 }
816 }
817
818 //set timings according to ATR
819 reader->read_timeout = 0;
820 reader->block_delay = 0;
821 reader->char_delay = 0;
822
823 if (n == 255) //Extra Guard Time
824 EGT = 0;
825 else
826 EGT = n;
827 GT = EGT + 12; //Guard Time in ETU
828 gt_ms = ETU_to_ms(reader, GT);
829
830 switch (reader->protocol_type) {
831 case ATR_PROTOCOL_TYPE_T0:
832 case ATR_PROTOCOL_TYPE_T14:
833 {
834 BYTE wi;
835 /* Integer value WI = TC2, by default 10 */
836#ifndef PROTOCOL_T0_USE_DEFAULT_TIMINGS
837 if (ATR_GetInterfaceByte (atr, 2, ATR_INTERFACE_BYTE_TC, &(wi)) != ATR_OK)
838#endif
839 wi = DEFAULT_WI;
840
841 // WWT = 960 * WI * (Fi / f) * 1000 milliseconds
842 WWT = (unsigned long) 960 * wi; //in ETU
843 if (reader->protocol_type == ATR_PROTOCOL_TYPE_T14)
844 WWT >>= 1; //is this correct?
845
846 reader->read_timeout = ETU_to_ms(reader, WWT);
847 reader->block_delay = gt_ms;
848 reader->char_delay = gt_ms;
849 cs_debug("Setting timings: timeout=%u ms, block_delay=%u ms, char_delay=%u ms", reader->read_timeout, reader->block_delay, reader->char_delay);
850 cs_debug_mask (D_IFD,"Protocol: T=%i: WWT=%d, Clockrate=%lu\n", reader->protocol_type, (int)(WWT), ICC_Async_GetClockRate(reader->cardmhz));
851 }
852 break;
853 case ATR_PROTOCOL_TYPE_T1:
854 {
855 BYTE ta, tb, tc, cwi, bwi;
856
857 // Set IFSC
858 if (ATR_GetInterfaceByte (atr, 3, ATR_INTERFACE_BYTE_TA, &ta) == ATR_NOT_FOUND)
859 reader->ifsc = DEFAULT_IFSC;
860 else if ((ta != 0x00) && (ta != 0xFF))
861 reader->ifsc = ta;
862 else
863 reader->ifsc = DEFAULT_IFSC;
864
865 //FIXME workaround for Smargo until native mode works
866 if (reader->smargopatch == 1)
867 reader->ifsc = MIN (reader->ifsc, 28);
868 else
869 // Towitoko does not allow IFSC > 251
870 //FIXME not sure whether this limitation still exists
871 reader->ifsc = MIN (reader->ifsc, MAX_IFSC);
872
873 #ifndef PROTOCOL_T1_USE_DEFAULT_TIMINGS
874 // Calculate CWI and BWI
875 if (ATR_GetInterfaceByte (atr, 3, ATR_INTERFACE_BYTE_TB, &tb) == ATR_NOT_FOUND)
876 {
877 #endif
878 cwi = DEFAULT_CWI;
879 bwi = DEFAULT_BWI;
880 #ifndef PROTOCOL_T1_USE_DEFAULT_TIMINGS
881 }
882 else
883 {
884 cwi = tb & 0x0F;
885 bwi = tb >> 4;
886 }
887 #endif
888
889 // Set CWT = (2^CWI + 11) work etu
890 reader->CWT = (unsigned short) (((1<<cwi) + 11)); // in ETU
891
892 // Set BWT = (2^BWI * 960 + 11) work etu
893 reader->BWT = (unsigned short)((1<<bwi) * 960 * 372 * 9600 / ICC_Async_GetClockRate(reader->cardmhz)) + 11 ;
894
895 // Set BGT = 22 * work etu
896 BGT = 22L; //in ETU
897
898 if (n == 255)
899 CGT = 11L; //in ETU
900 else
901 CGT = GT;
902
903 // Set the error detection code type
904 if (ATR_GetInterfaceByte (atr, 3, ATR_INTERFACE_BYTE_TC, &tc) == ATR_NOT_FOUND)
905 edc = EDC_LRC;
906 else
907 edc = tc & 0x01;
908
909 // Set initial send sequence (NS)
910 reader->ns = 1;
911
912 cs_debug ("Protocol: T=1: IFSC=%d, CWT=%d etu, BWT=%d etu, BGT=%d etu, EDC=%s\n", reader->ifsc, reader->CWT, reader->BWT, BGT, (edc == EDC_LRC) ? "LRC" : "CRC");
913
914 reader->read_timeout = ETU_to_ms(reader, reader->BWT);
915 reader->block_delay = ETU_to_ms(reader, BGT);
916 reader->char_delay = ETU_to_ms(reader, CGT);
917 cs_debug("Setting timings: timeout=%u ms, block_delay=%u ms, char_delay=%u ms", reader->read_timeout, reader->block_delay, reader->char_delay);
918 }
919 break;
920 default:
921 return ERROR;
922 break;
923 }//switch
924
925 call (SetRightParity (reader));
926
927 //write settings to internal device
928 if(reader->typ == R_INTERNAL) {
929#ifdef SCI_DEV
930 double F = (double) atr_f_table[FI];
931 unsigned long ETU = 0;
932 //for Irdeto T14 cards, do not set ETU
933 if (!(atr->hbn >= 6 && !memcmp(atr->hb, "IRDETO", 6) && reader->protocol_type == ATR_PROTOCOL_TYPE_T14))
934 ETU = F / d;
935 call (Sci_WriteSettings (reader, reader->protocol_type, reader->mhz / 100, ETU, WWT, reader->BWT, reader->CWT, EGT, 5, (unsigned char)I)); //P fixed at 5V since this is default class A card, and TB is deprecated
936#elif COOL
937 call (Cool_SetClockrate(reader->mhz));
938 call (Cool_WriteSettings (reader->BWT, reader->CWT, EGT, BGT));
939#endif //COOL
940 }
941#if defined(LIBUSB)
942 if (reader->typ == R_SMART)
943 SR_WriteSettings(reader, (unsigned short) atr_f_table[FI], (BYTE)d, (BYTE)EGT, (BYTE)reader->protocol_type, reader->convention);
944#endif
945 cs_log("Maximum frequency for this card is formally %i Mhz, clocking it to %.2f Mhz", atr_fs_table[FI] / 1000000, (float) reader->mhz / 100);
946
947 //IFS setting in case of T1
948 if ((reader->protocol_type == ATR_PROTOCOL_TYPE_T1) && (reader->ifsc != DEFAULT_IFSC)) {
949 unsigned char rsp[CTA_RES_LEN];
950 unsigned short lr=0;
951 unsigned char tmp[] = { 0x21, 0xC1, 0x01, 0x00, 0x00 };
952 tmp[3] = reader->ifsc; // Information Field size
953 tmp[4] = reader->ifsc ^ 0xE1;
954 Protocol_T1_Command (reader, tmp, sizeof(tmp), rsp, &lr);
955 }
956 return OK;
957}
958
959static BYTE PPS_GetPCK (BYTE * block, unsigned length)
960{
961 BYTE pck;
962 unsigned i;
963
964 pck = block[0];
965 for (i = 1; i < length; i++)
966 pck ^= block[i];
967
968 return pck;
969}
Note: See TracBrowser for help on using the repository browser.