1
2 #include <string.h>
3 #include "MsCommon.h"
4
5 #include "drvNDSSC.h"
6 #include "drvGPIO.h"
7
8 #include "hdi_121.h"
9 #include "nsk_dbg.h"
10 #include "nsk2hdx_header.h"
11
12 /*****************************************************************************\
13 \ local defines
14 \*****************************************************************************/
15 #define SC_0 0
16 #define SC_1 1
17
18 #define Default_SC_DEV SC_0
19
20 #define NSK2_SC_EVT_MASK0 0x0000000F
21 #define NSK2_SC_EVT_MASK1 0x000000F0
22 #define NSK2_SC_EVT_IN0 0x00000001
23 #define NSK2_SC_EVT_OUT0 0x00000002
24 #define NSK2_SC_EVT_IN1 0x00000010
25 #define NSK2_SC_EVT_OUT1 0x00000020
26 #define NSK2_SC_EVT_STOP 0x00000100
27
28 #define Default_SC_PARAM _T0_InitParam
29 #define HDX_SC_TASK_STACK_SIZE 16*1024
30
31 #define SMC_PPS 0
32
33
34 static MS_U32 SCTimeOut = 0;
35 static MS_U32 SCHWTimeOut = 0;
36 #define SCTimeOutOffset SCTimeOut
37 #define SCHWTimeOutOffset SCHWTimeOut
38
39 #define INITIAL_WAITING_TIME 960 //SPEC 7816-3
40 #define LEAST_TC2_VALUE 0xA //least WWT value NDS stated
41
42 /*****************************************************************************\
43 \ global variables
44 \*****************************************************************************/
45 NSK2HDX_UARTCONFIGURATION gSC_conf[2] = {
46 {
47 .card_clock = NSK2HDX_SC_CLOCK_1,
48 .card_baud_rate = NSK2HDX_SC_BR_3,
49 .protocol = NSK2HDX_SC_PROTOCOL_T_0,
50 },
51 {
52 .card_clock = NSK2HDX_SC_CLOCK_1,
53 .card_baud_rate = NSK2HDX_SC_BR_3,
54 .protocol = NSK2HDX_SC_PROTOCOL_T_0,
55 }
56 };
57
58 SC_Param gSCInitParams[2];
59 NDS_UBYTE gbPin_Mask = NSK2HDX_UART_COMMAND_IO_C7_ON;
60 /*****************************************************************************\
61 \ local variables
62 \*****************************************************************************/
63
64 //NDS_ULONG sc_reader_id[] = {SC_0, SC_1};
65 NDS_ULONG sc_reader_id[] = {SC_0};
66
67 static MS_U8 _atrbuf[SC_ATR_LEN_MAX];
68 static MS_U8 _historybuf[SC_HIST_LEN_MAX];
69 static MS_U16 _atrlen = 0;
70 static MS_U16 _historylen = 0;
71
72 static MS_U8 _u8HDX_SCIsInit = FALSE;
73 static MS_S32 _s32HDX_SCEventId = -1;
74 static MS_S32 _s32HDX_SCTaskId = -1;
75
76 static void* _pHDX_SCTaskStack;
77 static MS_U8 _u8HDX_SC_StackBuffer[HDX_SC_TASK_STACK_SIZE];
78
79 static MS_U8 u8GT_record =0;
80 static MS_U8 u8Baudrate_record = 0;
81
82
83 static NDS_UBYTE _gSC_Vcc_Level = NSK2HDX_VCC_5V;
84 static MS_U32 _bSC_log = FALSE;
85 static NDS_UBYTE gGuardTime = 0;
86
87 static MS_BOOL isDefaultUART=TRUE;
88
89 extern void _NDS_T0_CmdTest(MS_U32 u8SCID);
90
91
92 typedef struct
93 {
94 MS_U8 TA1byte;
95 MS_U32 clock_rate;
96 MS_U32 clock_rate_conversion;
97 } SC_rate_conversion;
98
99 static SC_rate_conversion SC_Rate_Table[] =
100 {
101 {0x11, 72/*4.5*16*/, 372*16},
102 {0x12, 72/*4.5*16*/, 372*16},
103 {0x13, 72/*4.5*16*/, 372*16},
104 {0x14, 72/*4.5*16*/, 372*16},
105 {0x15, 72/*4.5*16*/, 372*16},
106 {0x36, 108/*6.75*16*/, 744*16},
107 {0x5f, 216/*13.5*16*/, 1488*16},
108 {0x6f, 216/*13.5*16*/, 1860*16},
109 {0x96, 72/*4.5*16*/, 512*16},
110 };
111
112
113 /*****************************************************************************\
114 \ local functions
115 \*****************************************************************************/
116
_debug_param_print(MS_U8 u8SCID)117 static void _debug_param_print(MS_U8 u8SCID)
118 {
119 NSK_TRACE(("u8SCID = %d\n",u8SCID));
120 NSK_TRACE(("u8Protocal = %x\n",gSCInitParams[u8SCID].u8Protocal));
121 NSK_TRACE(("eCardClk = %d\n",gSCInitParams[u8SCID].eCardClk));
122 NSK_TRACE(("u8UartMode = %d\n",gSCInitParams[u8SCID].u8UartMode));
123 NSK_TRACE(("u16ClkDiv = %d\n",gSCInitParams[u8SCID].u16ClkDiv));
124 NSK_TRACE(("eVccCtrl = %d\n",gSCInitParams[u8SCID].eVccCtrl));
125 NSK_TRACE(("u16Bonding = %d\n",gSCInitParams[u8SCID].u16Bonding));
126 NSK_TRACE(("u8Convention = %d\n",gSCInitParams[u8SCID].u8Convention));
127 }
128
_T0_InitParam(SC_Param * pParam)129 void _T0_InitParam(SC_Param *pParam)
130 {
131 pParam->eCardClk = E_SC_CLK_4P5M;
132 pParam->u8UartMode = SC_UART_CHAR_8 | SC_UART_STOP_2 | SC_UART_PARITY_ODD;
133 pParam->u16ClkDiv = (372 << 4);
134 }
135
136
_NSK2_verSC_Reset(MS_U8 u8SCID,SC_ResetType RstType)137 MS_BOOL _NSK2_verSC_Reset(MS_U8 u8SCID,SC_ResetType RstType)
138 {
139 MS_U8 _u8AtrBuf[SC_ATR_LEN_MAX];
140 MS_U16 _u16AtrLen = 255;
141 MS_U8 history[SC_HIST_LEN_MAX];
142 MS_U16 history_len = 200;
143 MS_U8 u8Protocol = 0xff;
144 SC_Param *pInitParams;
145 MS_U8 sc_clock;
146 // MS_U16 i;
147
148 NSK_TRACE(("Come to _NSK2_verSC_Reset\n"));
149
150 MDrv_SC_T0_SetTimeOut( 150 * 10 );
151 memset(_u8AtrBuf, 0x00, sizeof(_u8AtrBuf));
152
153 pInitParams = &gSCInitParams[u8SCID];
154 _debug_param_print(u8SCID);
155
156 #if 0
157 if (MDrv_SC_Reset(u8SCID, pInitParams) != E_SC_OK)
158 {
159 printf("[%s][%d] \n",__FUNCTION__,__LINE__);
160 return FALSE;
161 }
162 MDrv_SC_ClearState(u8SCID);
163 #endif
164
165 NSK_TRACE(("Start to Reset and Get ATR\n"));
166
167 //if (MDrv_SC_GetATR(u8SCID, 100*5, _u8AtrBuf, &_u16AtrLen, history, &history_len) == E_SC_OK)
168 if (MDrv_SC_Reset_ATR(u8SCID, pInitParams, _u8AtrBuf, &_u16AtrLen, history, &history_len) == E_SC_OK)
169 {
170 if (_u8AtrBuf[1] & 0x80)
171 {
172 u8Protocol = _u8AtrBuf[3] & 0xF;
173 }
174 else
175 {
176 u8Protocol = 0;
177 }
178 pInitParams->u8Protocal = u8Protocol;
179
180
181 u8GT_record = _u8AtrBuf[4]; //Save GT
182 u8Baudrate_record = _u8AtrBuf[2] & 0xf; //Save TA1
183
184 _atrlen = _u16AtrLen;
185 memcpy(_atrbuf,_u8AtrBuf,SC_ATR_LEN_MAX);
186 _historylen = history_len;
187 memcpy(_historybuf,history,SC_HIST_LEN_MAX);
188
189 //For setting SMC clock rate
190 sc_clock = (_atrbuf[2]>>4)&0xf;
191 if (3 == sc_clock ) //6.75MHz
192 {
193 pInitParams->eCardClk = E_SC_CLK_6M;
194 NSK_TRACE(("Change to 6.75MHz\n"));
195 }
196 else if( (5 == sc_clock ) || (6 == sc_clock ) )//13.5MHz
197 {
198 pInitParams->eCardClk = E_SC_CLK_13M;
199 NSK_TRACE(("Change to 13.5MHz\n"));
200 }
201 else if( (1 == sc_clock ) || (9 == sc_clock ) )//4.5MHz
202 {
203 pInitParams->eCardClk = E_SC_CLK_4P5M;
204 NSK_TRACE(("Change to 4.5MHz\n"));
205 }
206 else
207 {
208 ;
209 }
210
211 if (MDrv_SC_Config(u8SCID, pInitParams) != E_SC_OK)
212 {
213 printf("[%s][%d] \n",__FUNCTION__,__LINE__);
214 return FALSE;
215 }
216 MDrv_SC_SetGuardTime(u8SCID,_atrbuf[4]);
217 return TRUE;
218 }
219 else //For Card is not exist when initial
220 {
221 NSK_TRACE(("Get ATR Fail\n"));
222 pInitParams->eCardClk = E_SC_CLK_4P5M;
223 MDrv_SC_Config(u8SCID,pInitParams);
224 MDrv_SC_SetGuardTime(u8SCID,_atrbuf[4]);
225 }
226 MsOS_DelayTask(120);
227
228 return FALSE;
229
230 }
231
232
233
_SC_Notify(MS_U8 u8SCID,SC_Event eEvent)234 static void _SC_Notify(MS_U8 u8SCID, SC_Event eEvent)
235 {
236
237 NSK_TRACE(("eEvent = %d, u8SCID = %x\n",eEvent,u8SCID));
238 switch (eEvent)
239 {
240 case E_SC_EVENT_IN:
241 NSK_TRACE(("SC_EVENT_IN, u8SCID = %x\n",u8SCID));
242 //MDrv_SC_Activate(0);
243 MsOS_SetEvent(_s32HDX_SCEventId, ( E_SC_EVENT_IN | (u8SCID<<8) ) );
244 break;
245
246 case E_SC_EVENT_OUT:
247 NSK_TRACE(("SC_EVENT_OUT, u8SCID = %x\n",u8SCID));
248 #if 1
249 //MDrv_SC_DeactiveSeq();
250 MsOS_SetEvent(_s32HDX_SCEventId, ( E_SC_EVENT_OUT | (u8SCID<<8) ) );
251 #else
252 NSK2HDX_CardRemoved((NDS_ULONG)u8SCID); // inform the verifier
253 #endif
254 break;
255 case E_SC_EVENT_DATA:
256 NSK_TRACE(("SC_EVENT_DATA\n"));
257 break;
258 default:
259 break;
260 }
261
262
263 }
264
_HDX_SC_Notify_Proc(void)265 static void _HDX_SC_Notify_Proc(void)
266 {
267 MS_U32 u32Events;
268 MS_U8 u8SCID = 0;
269 while (1)
270 {
271 NSK_TRACE(("_HDX_SC_Notify_Proc wait Event\n"));
272 MsOS_WaitEvent(_s32HDX_SCEventId, 0xFFFFFFFF /*ECMFLT_STATES_GROUP*/, &u32Events, E_OR_CLEAR, MSOS_WAIT_FOREVER /*1000*/ );
273
274 u8SCID = (MS_U8)((u32Events>>8)&0xff);
275 NSK_TRACE(("u8SCID = %x\n",u8SCID));
276
277 if( (u32Events&0xff) == E_SC_EVENT_IN)
278 {
279 //_NSK2_SC_Reset(u8SCID,&gSCInitParams[u8SCID]);
280 NSK2HDX_CardInserted((NDS_ULONG)u8SCID); // inform the verifier
281 }
282 else if( (u32Events&0xff) == E_SC_EVENT_OUT)
283 {
284 printf("card out notify\n");
285 MDrv_SC_Deactivate(u8SCID);
286 NSK2HDX_SetVcc(u8SCID,NSK2HDX_VCC_OFF);
287 NSK2HDX_CardRemoved((NDS_ULONG)u8SCID); // inform the verifier
288 }
289
290 }
291 }
292
293
NSK2_SC_Init(SC_Init_Paras_t * pInitPara)294 MS_BOOL NSK2_SC_Init(SC_Init_Paras_t *pInitPara)
295 {
296 NSK_TRACE(("Enter\n"));
297
298 SC_Result errCode;
299 MS_U8 u8SCID = Default_SC_DEV;
300 SC_Param *pInitParams;
301 SC_Result eSCResult;
302
303 if(_u8HDX_SCIsInit == FALSE)
304 {
305 NSK_TRACE(("CreateEventGroup\n"));
306
307 _s32HDX_SCEventId = MsOS_CreateEventGroup("HDX_SC_Event");
308 if (_s32HDX_SCEventId < 0)
309 {
310 NSK_ERROR(("CreateEvent fail\n"));
311 return FALSE;
312 }
313
314 NSK_TRACE(("_s32ECMFLTEventId = %d\n",_s32HDX_SCEventId));
315
316 _pHDX_SCTaskStack = _u8HDX_SC_StackBuffer;
317 _s32HDX_SCTaskId = MsOS_CreateTask((TaskEntry)_HDX_SC_Notify_Proc,
318 (MS_U32)NULL,
319 E_TASK_PRI_MEDIUM,
320 TRUE,
321 _pHDX_SCTaskStack,
322 HDX_SC_TASK_STACK_SIZE,
323 "xxx");
324 if (_s32HDX_SCTaskId < 0)
325 {
326 NSK_ERROR(("CreateTask fail\n"));
327 MsOS_DeleteEventGroup(_s32HDX_SCEventId);
328 return FALSE;
329 }
330
331 _u8HDX_SCIsInit = TRUE;
332 }
333
334 if ( (errCode = MDrv_SC_Init(u8SCID)) != E_SC_OK )
335 {
336 NSK_ERROR(("Error code=%d\n", errCode));
337 return FALSE;
338 }
339
340 pInitParams = &gSCInitParams[u8SCID];
341 memset(pInitParams,0x0,sizeof(SC_Param));
342
343 SCTimeOut = pInitPara->DelayTime;
344 SCHWTimeOut = pInitPara->DelayTime;
345 if(pInitPara->b8024OnChip == TRUE)
346 {
347 pInitParams->eVccCtrl = E_SC_VCC_VCC_ONCHIP_8024;
348 printf(">>>>>>>>>Onchip 8024<<<<<<<<<<<\n");
349 }
350 else
351 {
352 pInitParams->eVccCtrl = E_SC_VCC_CTRL_8024_ON;
353 printf(">>>>>>>>>External 8024<<<<<<<<<<<\n");
354 }
355
356 // Init params
357 pInitParams->eCardClk = E_SC_CLK_4P5M;
358 pInitParams->u16ClkDiv = (372<<4);
359 pInitParams->u8Protocal = 0;
360 pInitParams->pfOCPControl = NULL;
361 pInitParams->eResetType = E_SC_WARM_RESET;
362 pInitParams->u8UartMode = SC_UART_CHAR_8 | SC_UART_STOP_2 | SC_UART_PARITY_ODD;
363 pInitParams->eVoltage = E_SC_VOLTAGE_5V;
364
365 // Open
366 if ( (eSCResult = MDrv_SC_Open(u8SCID, pInitParams->u8Protocal, pInitParams, _SC_Notify)) != E_SC_OK)
367 {
368 NSK_ERROR(("MDrv_SC_Open fail code=%d \n", eSCResult));
369 return FALSE;
370 }
371
372 NSK2HDX_SetScreaderHwInfo( &sc_reader_id[0],
373 sizeof(sc_reader_id)/sizeof(NDS_ULONG)); // inform verifier
374
375 _debug_param_print(u8SCID);
376
377 NSK_TRACE(("Exit\n"));
378 return TRUE;
379 }
380
NSK2HDX_CheckCardPresence(NDS_ULONG screader_id,NDS_ULONG * card_presence)381 NDS_STATUS32 NSK2HDX_CheckCardPresence(NDS_ULONG screader_id, NDS_ULONG *card_presence)
382 {
383 NSK_TRACE(("Enter\n"));
384
385 SC_Status sc_status;
386
387 NSK_PRINT(("Card ID:%d\n", screader_id));
388 if ( MDrv_SC_GetStatus((MS_U8)screader_id, &sc_status) != E_SC_OK )
389 {
390 NSK_ERROR(("Get Status fail\n"));
391 return NSK2HDX_FAIL;
392 }
393
394 NSK_TRACE(("bCardIn = %x\n",sc_status.bCardIn));
395 *card_presence = (sc_status.bCardIn) ? NSK2HDX_CARD_INSERTED : NSK2HDX_CARD_REMOVED;
396
397 NSK_TRACE(("Exit\n"));
398
399 return NSK2HDX_OK;
400 }
401
NSK2HDX_SetVccLevel(NDS_ULONG screader_id,NDS_UBYTE vcc_level)402 NDS_STATUS32 NSK2HDX_SetVccLevel(NDS_ULONG screader_id, NDS_UBYTE vcc_level)
403 {
404 NSK_TRACE(("Enter\n"));
405
406 NSK_PRINT(("Vcc Level:%s\n", (vcc_level==NSK2HDX_VCC_5V)? "5V" : "3V"));
407
408 if(_gSC_Vcc_Level == vcc_level)
409 {
410 return NSK2HDX_OK;
411 }
412 else
413 {
414 _gSC_Vcc_Level = vcc_level;
415 }
416
417 NSK_TRACE(("Exit\n"));
418
419 return NSK2HDX_OK;
420 }
421
NSK2HDX_SetVcc(NDS_ULONG screader_id,NDS_UBYTE vcc_switch)422 NDS_STATUS32 NSK2HDX_SetVcc(NDS_ULONG screader_id, NDS_UBYTE vcc_switch)
423 {
424 NSK_TRACE(("Enter\n"));
425
426 NSK_PRINT(("_Vcc switch:%s\n", (vcc_switch==NSK2HDX_VCC_ON)?"ON":"OFF"));
427
428 if(vcc_switch==NSK2HDX_VCC_ON)
429 {
430 if(_gSC_Vcc_Level==NSK2HDX_VCC_5V)
431 {
432 MDrv_SC_CardVoltage_Config(screader_id,E_SC_VOLTAGE_5V);
433 }
434 else if(_gSC_Vcc_Level==NSK2HDX_VCC_3V)
435 {
436 MDrv_SC_CardVoltage_Config(screader_id,E_SC_VOLTAGE_3_POINT_3V);
437 }
438 else
439 {
440 NSK_PRINT(("Error VCC\n"));
441 }
442 }
443 else
444 {
445 MDrv_SC_CardVoltage_Config(screader_id,E_SC_VOLTAGE_OFF);
446 }
447
448 NSK_TRACE(("Exit\n"));
449
450 return NSK2HDX_OK;
451 }
452
453 /*
454 * Calculate WWT value based on TC2 byte and TA1 byte
455 * TA1 value gives information of Clock-rate and Clock-rate-conversion
456 * which is seeding to WWT calculation formula here
457 */
_SC_Calc_WWT(MS_U8 u8Ta1Byte,MS_U8 u8Tc2Byte)458 MS_U32 _SC_Calc_WWT(MS_U8 u8Ta1Byte, MS_U8 u8Tc2Byte)
459 {
460 MS_U32 u32WWT=0;
461 MS_U32 wwt;
462 MS_U32 u32ConvTabSize;
463 MS_U32 i;
464
465 u32ConvTabSize = sizeof(SC_Rate_Table)/sizeof(SC_rate_conversion);
466 NSK_TRACE(("u32ConvTabSize=0x%x\n", u32ConvTabSize));
467
468 for(i=0; i<u32ConvTabSize; ++i)
469 {
470 if ( SC_Rate_Table[i].TA1byte == u8Ta1Byte )
471 {
472 NSK_TRACE(("clock_rate_conversion=%x, clock_rate=%x\n",
473 SC_Rate_Table[i].clock_rate_conversion, SC_Rate_Table[i].clock_rate));
474 wwt = INITIAL_WAITING_TIME * (MS_U32)u8Tc2Byte * (SC_Rate_Table[i].clock_rate_conversion / SC_Rate_Table[i].clock_rate);
475 wwt /= 1000; //convert to mSec
476 u32WWT = (MS_U32)wwt;
477 NSK_TRACE(("work waiting time, [%x]\n", u32WWT));
478 return u32WWT;
479 }
480 }
481 return u32WWT;
482 }
483
484
485 /*
486 * performs a single smart card reset pulse, receives the answer-to-reset data and
487 * parses the parameters of this ATR data
488 */
NSK2HDX_WarmResetCard(NDS_ULONG screader_id,NDS_UBYTE * atr_data,NDS_UBYTE * atr_len,NDS_UBYTE * first_history_byte)489 NDS_STATUS32 NSK2HDX_WarmResetCard(NDS_ULONG screader_id, NDS_UBYTE *atr_data,
490 NDS_UBYTE *atr_len, NDS_UBYTE *first_history_byte)
491 {
492 NSK_TRACE(("Enter, screader_id = %x\n",screader_id));
493 //printf("Come to NSK2HDX_WarmResetCard\n");
494 MS_U16 u16historylen=200;
495 MS_U16 u16atrlen=0, i;
496 MS_U8 history[SC_HIST_LEN_MAX];
497 MS_U32 u32waiting_time;
498
499 //MsOS_DelayTask(50);
500 _atrlen = 0;
501 isDefaultUART=TRUE;
502
503 #if 0
504 _verSC_Reset(screader_id);
505 #else
506 _NSK2_verSC_Reset(screader_id,0);
507 #endif
508
509
510 memcpy(atr_data,_atrbuf,_atrlen);
511 u16atrlen = _atrlen;
512
513 NSK_TRACE(("u16atrlen = %d, u16historylen = %d\n",u16atrlen, u16historylen));
514
515 if(u16atrlen == 0)
516 {
517 NSK_ERROR(("atrlen = 0\n"));
518 return NSK2HDX_FAIL;
519 }
520
521 NSK_TRACE(("ATR log\n"));
522 for(i = 0; i< u16atrlen; i++)
523 {
524 NSK_TRACE(("( %d, %x )\n",i,atr_data[i]));
525 }
526
527 memcpy(history,_historybuf,_historylen);
528 u16historylen = _historylen;
529
530 NSK_TRACE(("history log\n"));
531 for(i = 0; i< u16historylen; i++)
532 {
533 NSK_TRACE(("( %d, %x )\n",i,history[i]));
534 }
535
536 if(u16atrlen > u16historylen)
537 {
538 *first_history_byte = u16atrlen - u16historylen; //history[0];
539 }
540 else
541 {
542 *first_history_byte = 0;
543 }
544 *atr_len = u16atrlen;
545
546 //WWT set
547 if ( atr_data[7] < LEAST_TC2_VALUE ) //least WWT value
548 {
549 u32waiting_time = _SC_Calc_WWT(atr_data[2], LEAST_TC2_VALUE);
550 }
551 else
552 {
553 u32waiting_time = _SC_Calc_WWT(atr_data[2], atr_data[7]);
554 }
555 MDrv_SC_SetBlockWaitingTime(screader_id, u32waiting_time - SCHWTimeOutOffset);
556 MDrv_SC_SetWaitingTime(screader_id, u32waiting_time - SCTimeOutOffset);
557
558 NSK_TRACE(("Exit\n"));
559
560 return NSK2HDX_OK;
561 }
562
NSK2HDX_SetUartParams(NDS_ULONG screader_id,NSK2HDX_UARTCONFIGURATION * conf)563 NDS_STATUS32 NSK2HDX_SetUartParams(NDS_ULONG screader_id,
564 NSK2HDX_UARTCONFIGURATION *conf)
565 {
566 NSK_TRACE(("Enter\n"));
567
568
569 NSK_TRACE(("card_clock = %x, card_baud_rate = %x, nak_retries = %x\n",conf->card_clock,conf->card_baud_rate,conf->nak_retries));
570 NSK_TRACE(("parity_retries = %x, work_wait_time = %x, guard_time = %x\n",conf->parity_retries,conf->work_wait_time,conf->guard_time));
571 NSK_TRACE(("protocol = %x\n",conf->protocol));
572
573 //UART by verifier
574 isDefaultUART=FALSE;
575
576 if(gGuardTime != conf->guard_time)
577 {
578 MDrv_SC_SetGuardTime(screader_id, conf->guard_time);
579 gGuardTime = conf->guard_time;
580 }
581
582 conf->guard_time = u8GT_record;
583 conf->card_baud_rate = u8Baudrate_record;
584 //conf->work_wait_time = 60;
585
586 //if there is WWT set by verifier
587 if(conf->work_wait_time != 0)
588 {
589 NSK_TRACE(("Manual WWT = [%d]\n", conf->work_wait_time*10 ));
590 MDrv_SC_SetBlockWaitingTime(screader_id, conf->work_wait_time*10 - SCHWTimeOutOffset);
591 MDrv_SC_SetWaitingTime(screader_id, conf->work_wait_time*10 - SCTimeOutOffset);
592 }
593
594 memcpy(&gSC_conf[screader_id], conf, sizeof(NSK2HDX_UARTCONFIGURATION));
595
596 return NSK2HDX_OK;
597 }
598
NSK2HDX_GetUartParams(NDS_ULONG screader_id,NSK2HDX_UARTCONFIGURATION * conf)599 NDS_STATUS32 NSK2HDX_GetUartParams(NDS_ULONG screader_id,
600 NSK2HDX_UARTCONFIGURATION *conf)
601 {
602 NSK_TRACE(("Enter\n"));
603 MS_U16 wait_time;
604 //NSK_TRACE(("NSK2HDX_GetUartParams:%x\n",screader_id));
605 memcpy(conf, &gSC_conf[screader_id], sizeof(NSK2HDX_UARTCONFIGURATION));
606
607 conf->guard_time = u8GT_record;
608 conf->card_baud_rate = u8Baudrate_record;
609
610 //20150811, default work wait time depending on TC2 byte
611 if (TRUE == isDefaultUART)
612 {
613 wait_time = MDrv_SC_GetWaitingTime(screader_id);
614 NSK_TRACE(("NSK2HDX_GetUartParams: default wait_time = %x\n", wait_time));
615 conf->work_wait_time = wait_time /10;
616 }
617 else
618 {
619 //this case just return value set by verifier
620 }
621
622 NSK_TRACE(("Exit\n"));
623
624 return NSK2HDX_OK;
625 }
626
627
628
NSK2HDX_SetSCLog(MS_U32 * bEn)629 MS_U32 NSK2HDX_SetSCLog(MS_U32 *bEn)
630 {
631 _bSC_log = *bEn;
632 return TRUE;
633 }
634
635 extern void MApi_SC_T0_SetTimeOut(MS_U32 u32TimeOut);
636 //extern void MDrv_SC_T0_SetTimeOut(MS_U32 u32TimeOut);
637 //-------------------------------------------------------------------------------//
638 //--The buffers represented by the parameters to_card and from_card will hold ---//
639 //--only the data payload, not any additional bytes that are related to the -----//
640 //--protocol (for example PB/ACK, null bytes, etc.) -----------------------------//
641 //-------------------------------------------------------------------------------//
642
NSK2HDX_CardIoCommand(NDS_ULONG screader_id,NDS_UBYTE * to_card,NDS_ULONG to_card_len,NDS_UBYTE * from_card,NDS_ULONG * from_card_len,NDS_UBYTE direction,NDS_USHORT timeout)643 NDS_STATUS32 NSK2HDX_CardIoCommand( NDS_ULONG screader_id,
644 NDS_UBYTE *to_card,
645 NDS_ULONG to_card_len,
646 NDS_UBYTE *from_card,
647 NDS_ULONG *from_card_len,
648 NDS_UBYTE direction,
649 NDS_USHORT timeout)
650 {
651 MS_U32 u32CardIOTime = MsOS_GetSystemTime();
652 SC_Result sc_result = E_SC_OK;
653
654 NSK_TRACE(("start time is %d\n",MsOS_GetSystemTime()));
655 NSK_TRACE(("Enter, screader_id = %d, direction = %d\n",screader_id,direction));
656 NSK_TRACE(("to_card_len = %d, timeout = %d\n",to_card_len,timeout));
657 MS_U32 i;
658
659 //for( i=0; i<to_card_len ; i++)
660 //{
661 // NSK_TRACE(("(%d, %x)\n",i,to_card[i]));
662 //}
663
664 if(_bSC_log == TRUE)
665 {
666 printf(" \n");
667 for( i=0; i<to_card_len ; i++)
668 {
669 printf("0x%x, ",to_card[i]);
670 }
671 printf(" \n");
672 }
673
674 switch (direction)
675 {
676 case NSK2HDX_DIRECTION_FROM_CARD:
677 MDrv_SC_T0_SetTimeOut( timeout * 10 - SCTimeOutOffset);
678 sc_result = MDrv_SC_T0_SendRecv((MS_U8)screader_id, to_card, (MS_U16)to_card_len,from_card, (MS_U16*)from_card_len);
679 break;
680
681 case NSK2HDX_DIRECTION_TO_CARD:
682 MDrv_SC_T0_SetTimeOut( timeout * 10 - SCTimeOutOffset);
683 sc_result = MDrv_SC_T0_SendRecv((MS_U8)screader_id, to_card, (MS_U16)to_card_len, from_card, (MS_U16*)from_card_len);
684 break;
685
686 default:
687 break;
688 }
689
690
691 NSK_TRACE(("Time of Card IO Time = %d\n", (MsOS_GetSystemTime() - u32CardIOTime)));
692 NSK_TRACE(("Exit\n"));
693
694 if(E_SC_OK != sc_result)
695 {
696 NSK_ERROR(("sc_result = %d\n",sc_result));
697 NSK_ERROR(("now time is %d\n",MsOS_GetSystemTime()));
698 NSK_ERROR(("Time of Card IO Time = %d\n", (MsOS_GetSystemTime() - u32CardIOTime) ));
699 return NSK2HDX_FAIL;
700 }
701
702 return NSK2HDX_OK;
703 }
704
705 //-----------------------------------------------------------------------------------//
706 //-- In each call to this routine, exactly one of C4, C7 and C8 must be indicated ---//
707 //-- as the I/O line. The state of the other 2 (GPIO) lines must bothe be specified -//
708 //-- Before setting a pin for use as I/O, the pin must first be in state H. ---------//
709 //-----------------------------------------------------------------------------------//
710
711 //controls C7, C4, C8 pin setting in the smart card interface.
NSK2HDX_SetUartCommand(NDS_ULONG screader_id,NDS_UBYTE pin_mask)712 NDS_STATUS32 NSK2HDX_SetUartCommand(NDS_ULONG screader_id, NDS_UBYTE pin_mask)
713 {
714 NSK_TRACE(("Enter\n"));
715
716 printf("pin_mask:%x \n",pin_mask);
717
718 NDS_UBYTE IOLine = NSK2HDX_UART_COMMAND_IO_C7_ON;
719 if(gbPin_Mask == pin_mask)
720 {
721 NSK_TRACE(("pin mask is the same, return\n"));
722 }
723 gbPin_Mask = pin_mask;
724
725 if( pin_mask & NSK2HDX_UART_COMMAND_IO_C7_ON ) //case 1, C7 as I/O line...
726 {
727 NSK_TRACE(("C7 as I/O line...\n"));
728
729 //check C4,C8 pin configs....
730 if( pin_mask & NSK2HDX_UART_COMMAND_IO_C4_ON)
731 {
732 NSK_ERROR(("C7 is already the IO line, C4 \n"));
733 return NSK2HDX_INVALID_REQUEST;
734 }
735
736 if( pin_mask & NSK2HDX_UART_COMMAND_IO_C8_ON)
737 {
738 NSK_ERROR(("C7 is already the IO line, C8 \n"));
739 }
740
741 //config C7 as I/O line
742 MDrv_SC_IOC4C8Switch(E_SC_IO_USE_SMIO);
743
744 IOLine = NSK2HDX_UART_COMMAND_IO_C7_ON;
745 }
746 else if( pin_mask & NSK2HDX_UART_COMMAND_IO_C4_ON ) //case 2, C4 as I/O line...
747 {
748 NSK_TRACE(("C4 as I/O line...\n"));
749 //check C8 pin configs....
750 if( pin_mask & NSK2HDX_UART_COMMAND_IO_C8_ON)
751 {
752 NSK_ERROR(("C4 is already the IO line, C8 \n"));
753 }
754
755 //config C4 as I/O line
756 MDrv_SC_IOC4C8Switch(E_SC_IO_USE_C4);
757 IOLine = NSK2HDX_UART_COMMAND_IO_C4_ON;
758 }
759 else if( pin_mask & NSK2HDX_UART_COMMAND_IO_C8_ON ) //case 3, C8 as I/O line...
760 {
761 NSK_TRACE(("C8 as I/O line...\n"));
762 //config C8 as I/O line
763 MDrv_SC_IOC4C8Switch(E_SC_IO_USE_C8);
764 IOLine = NSK2HDX_UART_COMMAND_IO_C8_ON;
765 }
766 else
767 {
768 NSK_ERROR(("error pin config\n"));
769 MDrv_SC_IOC4C8Switch(E_SC_IO_USE_SMIO);
770 }
771
772 if(IOLine != NSK2HDX_UART_COMMAND_IO_C4_ON)
773 {
774 if( pin_mask & NSK2HDX_UART_COMMAND_C4_ON )
775 {
776 MDrv_SC_C4_SignalLevel(1);
777 }
778 else
779 {
780 MDrv_SC_C4_SignalLevel(0);
781 }
782 }
783
784
785 if(IOLine != NSK2HDX_UART_COMMAND_IO_C8_ON)
786 {
787 if(pin_mask & NSK2HDX_UART_COMMAND_C8_ON )
788 {
789 MDrv_SC_C8_SignalLevel(1);
790 }
791 else
792 {
793 MDrv_SC_C8_SignalLevel(0);
794 }
795 }
796
797 if(IOLine != NSK2HDX_UART_COMMAND_IO_C7_ON)
798 {
799 if(pin_mask & NSK2HDX_UART_COMMAND_C7_ON )
800 {
801 MDrv_SC_C7_SignalLevel(1);
802 }
803 else
804 {
805 MDrv_SC_C7_SignalLevel(0);
806 }
807 }
808
809 NSK_TRACE(("Exit\n"));
810
811 return NSK2HDX_OK;
812 }
813
NSK2HDX_GetUartCommand(NDS_ULONG screader_id,NDS_UBYTE * pin_mask)814 NDS_STATUS32 NSK2HDX_GetUartCommand(NDS_ULONG screader_id, NDS_UBYTE *pin_mask)
815 {
816 NSK_TRACE(("Enter\n"));
817
818 if((gbPin_Mask & 0xF) != 0x8)
819 {
820 *pin_mask = gbPin_Mask & 0x7F;
821 }
822 else
823 {
824 *pin_mask = gbPin_Mask;
825 }
826
827 NSK_TRACE(("Exit\n"));
828
829 return NSK2HDX_OK;
830 }
831
832