int32_t Cool_Reset (struct s_reader *reader, ATR * atr)
{
//set freq to reader->cardmhz if necessary
uint32_t clk;
int32_t ret;
ret = cnxt_smc_get_clock_freq (specdev()->handle, &clk);
check_error("cnxt_smc_get_clock_freq", ret);
if (clk/10000 != reader->cardmhz) {
cs_debug_mask(D_DEVICE,"COOL: %s clock freq: %i, scheduling change to %i for card reset", reader->label, clk, reader->cardmhz*10000);
call (Cool_SetClockrate(reader, reader->cardmhz));
}
//reset card
ret = cnxt_smc_reset_card (specdev()->handle, ATR_TIMEOUT, NULL, NULL);
check_error("cnxt_smc_reset_card", ret);
cs_sleepms(50);
int32_t n = 40;
unsigned char buf[40];
ret = cnxt_smc_get_atr (specdev()->handle, buf, &n);
check_error("cnxt_smc_get_atr", ret);
call (!ATR_InitFromArray (atr, buf, n) == ATR_OK);
{
cs_sleepms(50);
return OK;
}
}
static int32_t Azbox_Reset(struct s_reader *reader, ATR *atr)
{
int32_t status;
unsigned char tmp[512];
memset(tmp, 0, sizeof(tmp));
tmp[0] = 3;
tmp[1] = 1;
ioctl(reader->handle, SCARD_IOC_WARMRESET, &tmp);
cs_sleepms(500);
while ((status = _GetStatus(reader, NULL)) != 3)
cs_sleepms(50);
tmp[0] = 0x02;
tmp[1] = sc_mode;
status = ioctl(reader->handle, SCARD_IOC_CHECKCARD, &tmp);
memset(tmp, 0, sizeof(tmp));
tmp[0] = 1;
int32_t atr_len = ioctl(reader->handle, SCARD_IOC_CHECKCARD, &tmp);
if (ATR_InitFromArray(atr, tmp, atr_len) == ERROR)
return 0;
cs_sleepms(500);
return OK;
}
int32_t ICC_Async_Activate(struct s_reader *reader, ATR *atr, uint16_t deprecated)
{
rdr_debug_mask(reader, D_IFD, "Activating card");
reader->current_baudrate = DEFAULT_BAUDRATE;
if(reader->atr[0] != 0 && !reader->ins7e11_fast_reset)
{
rdr_log(reader, "Using ATR from reader config");
ATR_InitFromArray(atr, reader->atr, ATR_MAX_SIZE);
}
else
{
call(reader->crdr.activate(reader, atr));
if(reader->crdr.skip_extra_atr_parsing)
{ return OK; }
}
unsigned char atrarr[ATR_MAX_SIZE];
uint32_t atr_size;
ATR_GetRaw(atr, atrarr, &atr_size);
char tmp[atr_size * 3 + 1];
rdr_log(reader, "ATR: %s", cs_hexdump(1, atrarr, atr_size, tmp, sizeof(tmp)));
memcpy(reader->card_atr, atrarr, atr_size);
reader->card_atr_length = atr_size;
/* Get ICC reader->convention */
if(ATR_GetConvention(atr, &(reader->convention)) != ATR_OK)
{
rdr_log(reader, "ERROR: Could not read reader->convention");
reader->convention = 0;
reader->protocol_type = 0;
return ERROR;
}
reader->protocol_type = ATR_PROTOCOL_TYPE_T0;
// Parse_ATR and InitCard need to be included in lock because they change parity of serial port
if(reader->crdr.lock)
{ reader->crdr.lock(reader); }
int32_t ret = Parse_ATR(reader, atr, deprecated);
if(reader->crdr.unlock)
{ reader->crdr.unlock(reader); }
if(ret)
{ rdr_log(reader, "ERROR: Parse_ATR returned error"); }
if(ret)
{ return ERROR; }
rdr_debug_mask(reader, D_IFD, "Card succesfully activated");
return OK;
}
static int32_t pcsc_activate(struct s_reader *reader, struct s_ATR *atr)
{
unsigned char atrarr[ATR_MAX_SIZE];
uint16_t atr_size = 0;
if (pcsc_activate_card(reader, atrarr, &atr_size) == OK) {
if (ATR_InitFromArray(atr, atrarr, atr_size) != ERROR) // ATR is OK or softfail malformed
return OK;
else
return ERROR;
} else
return ERROR;
}
int32_t Cool_FastReset_With_ATR (struct s_reader *reader, ATR * atr)
{
int32_t n = 40, ret;
unsigned char buf[40];
//reset card
ret = cnxt_smc_reset_card (specdev()->handle, ATR_TIMEOUT, NULL, NULL);
check_error("cnxt_smc_reset_card", ret);
cs_sleepms(50);
ret = cnxt_smc_get_atr (specdev()->handle, buf, &n);
check_error("cnxt_smc_get_atr", ret);
call (!ATR_InitFromArray (atr, buf, n) == ATR_OK);
{
cs_sleepms(50);
return OK;
}
}
int32_t Cool_Reset (ATR * atr)
{
call (Cool_SetClockrate(357));
//reset card
int32_t timeout = 5000; // Timout in ms?
call (cnxt_smc_reset_card (specdev()->handle, ATR_TIMEOUT, NULL, NULL));
cs_sleepms(50);
int32_t n = 40;
unsigned char buf[40];
call (cnxt_smc_get_atr (specdev()->handle, buf, &n));
call (!ATR_InitFromArray (atr, buf, n) == ATR_OK);
{
cs_sleepms(50);
return OK;
}
}
static int32_t Cool_Reset(struct s_reader *reader, ATR *atr)
{
struct cool_data *crdr_data = reader->crdr_data;
int32_t ret;
if(!reader->ins7e11_fast_reset)
{
//set freq to reader->cardmhz if necessary
uint32_t clk;
ret = cnxt_smc_get_clock_freq(crdr_data->handle, &clk);
coolapi_check_error("cnxt_smc_get_clock_freq", ret);
if(clk / 10000 != (uint32_t)reader->cardmhz)
{
rdr_log_dbg(reader, D_DEVICE, "COOL: clock freq: %i, scheduling change to %i for card reset",
clk, reader->cardmhz * 10000);
call(Cool_SetClockrate(reader, reader->cardmhz));
}
}
else
{
rdr_log(reader, "Doing fast reset");
}
//reset card
ret = cnxt_smc_reset_card(crdr_data->handle, ATR_TIMEOUT, NULL, NULL);
coolapi_check_error("cnxt_smc_reset_card", ret);
cs_sleepms(50);
int32_t n = ATR_MAX_SIZE;
unsigned char buf[ATR_MAX_SIZE];
ret = cnxt_smc_get_atr(crdr_data->handle, buf, &n);
coolapi_check_error("cnxt_smc_get_atr", ret);
call(!ATR_InitFromArray(atr, buf, n) != ERROR);
{
cs_sleepms(50);
return OK;
}
}
static int32_t Cool_Reset (struct s_reader *reader, ATR * atr)
{
int32_t ret;
if (!reader->ins7e11_fast_reset) {
//set freq to reader->cardmhz if necessary
uint32_t clk;
ret = cnxt_smc_get_clock_freq (specdev()->handle, &clk);
coolapi_check_error("cnxt_smc_get_clock_freq", ret);
if (clk/10000 != (uint32_t)reader->cardmhz) {
rdr_debug_mask(reader, D_DEVICE, "COOL: clock freq: %i, scheduling change to %i for card reset",
clk, reader->cardmhz*10000);
call (Cool_SetClockrate(reader, reader->cardmhz));
}
}
else {
rdr_debug_mask(reader, D_DEVICE, "fast reset needed, restoring transmit parameter for coolstream device %s", reader->device);
call(Cool_Set_Transmit_Timeout(reader, 0));
rdr_log(reader, "Doing fast reset");
}
//reset card
ret = cnxt_smc_reset_card (specdev()->handle, ATR_TIMEOUT, NULL, NULL);
coolapi_check_error("cnxt_smc_reset_card", ret);
cs_sleepms(50);
int32_t n = ATR_MAX_SIZE;
unsigned char buf[ATR_MAX_SIZE];
ret = cnxt_smc_get_atr (specdev()->handle, buf, &n);
coolapi_check_error("cnxt_smc_get_atr", ret);
call (!ATR_InitFromArray (atr, buf, n) != ERROR);
{
cs_sleepms(50);
return OK;
}
}
int32_t ICC_Async_Activate (struct s_reader *reader, ATR * atr, uint16_t deprecated)
{
cs_debug_mask (D_IFD, "IFD: Activating card in reader %s\n", reader->label);
reader->current_baudrate = DEFAULT_BAUDRATE; //this is needed for all readers to calculate work_etu for timings
if (reader->atr[0] != 0) {
cs_log("using ATR from reader config");
ATR_InitFromArray(atr, reader->atr, ATR_MAX_SIZE);
}
else {
if (reader->crdr.active==1 && reader->crdr.activate) {
call(reader->crdr.activate(reader, atr));
} else {
switch(reader->typ) {
case R_MP35:
case R_DB2COM1:
case R_DB2COM2:
case R_SC8in1:
case R_MOUSE:
LOCK_SC8IN1;
int32_t ret = Phoenix_Reset(reader, atr);
UNLOCK_SC8IN1;
if (ret) {
cs_debug_mask(D_TRACE, "ERROR, function call Phoenix_Reset returns error.");
return ERROR;
}
break;
#if defined(LIBUSB)
case R_SMART:
call (SR_Reset(reader, atr));
break;
#endif
case R_INTERNAL:
#if defined(SCI_DEV)
call (Sci_Activate(reader));
call (Sci_Reset(reader, atr));
#elif defined(COOL)
call (Cool_Reset(atr));
#elif defined(WITH_STAPI)
call (STReader_Reset(reader->stsmart_handle, atr));
#elif defined(AZBOX)
call (Azbox_Reset(reader, atr));
#endif
break;
#ifdef HAVE_PCSC
case R_PCSC:
{
unsigned char atrarr[ATR_MAX_SIZE];
uint16_t atr_size = 0;
if (pcsc_activate_card(reader, atrarr, &atr_size))
{
if (ATR_InitFromArray (atr, atrarr, atr_size) == ATR_OK)
return OK;
else
return ERROR;
}
else
return ERROR;
}
break;
#endif
default:
cs_log("ERROR ICC_Async_Activate: unknow reader type %i",reader->typ);
return ERROR;
}
}
}
unsigned char atrarr[ATR_MAX_SIZE];
uint32_t atr_size;
ATR_GetRaw(atr, atrarr, &atr_size);
char tmp[atr_size*3+1];
cs_ri_log(reader, "ATR: %s", cs_hexdump(1, atrarr, atr_size, tmp, sizeof(tmp)));
/* Get ICC reader->convention */
if (ATR_GetConvention (atr, &(reader->convention)) != ATR_OK) {
cs_log("ERROR: Could not read reader->convention");
reader->convention = 0;
reader->protocol_type = 0;
return ERROR;
}
reader->protocol_type = ATR_PROTOCOL_TYPE_T0;
LOCK_SC8IN1;
int32_t ret = Parse_ATR(reader, atr, deprecated);
UNLOCK_SC8IN1; //Parse_ATR and InitCard need to be included in lock because they change parity of serial port
if (ret)
cs_log("ERROR: Parse_ATR returned error");
if (ret)
return ERROR;
cs_debug_mask (D_IFD, "IFD: Card in reader %s succesfully activated\n", reader->label);
return OK;
}
int32_t ICC_Async_Activate(struct s_reader *reader, ATR *atr, uint16_t deprecated)
{
rdr_debug_mask(reader, D_IFD, "Activating card");
reader->current_baudrate = DEFAULT_BAUDRATE;
if(reader->atr[0] != 0 && !reader->ins7e11_fast_reset)
{
rdr_log(reader, "Using ATR from reader config");
ATR_InitFromArray(atr, reader->atr, ATR_MAX_SIZE);
}
else
{
call(reader->crdr.activate(reader, atr));
if(reader->crdr.skip_extra_atr_parsing)
{ return OK; }
}
unsigned char atrarr[ATR_MAX_SIZE];
uint32_t atr_size;
ATR_GetRaw(atr, atrarr, &atr_size);
char tmp[atr_size * 3 + 1];
// dirty hack for seca cards on Golden Interstar Xspeed internal reader
char *hack_golden_interstar = cs_hexdump(1, atrarr, atr_size, tmp, sizeof(tmp));
int result = strncmp(hack_golden_interstar, "18 40 D8 ", sizeof(tmp));
if (!result)
{
rdr_log(reader, "Disabling rom rev detection. Golden Star internal reader dirty hack");
reader->ins7e11_fast_reset = 2;
}
// end dirty hack If a solution to the stb's sci driver is found remove this hack
rdr_log(reader, "ATR: %s", cs_hexdump(1, atrarr, atr_size, tmp, sizeof(tmp)));
memcpy(reader->card_atr, atrarr, atr_size);
reader->card_atr_length = atr_size;
/* Get ICC reader->convention */
if(ATR_GetConvention(atr, &(reader->convention)) != ATR_OK)
{
rdr_log(reader, "ERROR: Could not read reader->convention");
reader->convention = 0;
reader->protocol_type = 0;
return ERROR;
}
reader->protocol_type = ATR_PROTOCOL_TYPE_T0;
// Parse_ATR and InitCard need to be included in lock because they change parity of serial port
if(reader->crdr.lock)
{ reader->crdr.lock(reader); }
int32_t ret = Parse_ATR(reader, atr, deprecated);
if(reader->crdr.unlock)
{ reader->crdr.unlock(reader); }
if(ret)
{ rdr_log(reader, "ERROR: Parse_ATR returned error"); }
if(ret)
{ return ERROR; }
rdr_debug_mask(reader, D_IFD, "Card succesfully activated");
return OK;
}
