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;
}
}
static void cool_set_transmit_timeout(struct s_reader *reader)
{
rdr_debug_mask(reader, D_DEVICE, "init done - modifying timeout for coolstream internal device %s", reader->device);
Cool_Set_Transmit_Timeout(reader, 1);
}
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) || defined(SU980)
call (Cool_Reset(reader,atr));
#if 0
if ( ! reader->ins7e11_fast_reset) {
printf("do Cool_Reset\n");
call (Cool_Reset(reader, atr));
}
else {
printf("do fast reset \n");
cs_debug_mask(D_DEVICE,"fast reset needed for %s - restoring transmit parameter for coolstream device %s", reader->label, reader->device);
call(Cool_Set_Transmit_Timeout(reader, 0));
cs_log("Doing fast reset");
call (Cool_FastReset_With_ATR(reader, atr));
}
#endif
#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 reader_reset(struct s_reader * reader)
{
reader_nullcard(reader);
ATR atr;
uint16_t ret = 0;
#ifdef WITH_AZBOX
int32_t i;
if (reader->typ == R_INTERNAL) {
if (reader->azbox_mode != -1) {
Azbox_SetMode(reader, reader->azbox_mode);
if (!reader_activate_card(reader, &atr, 0)) return(0);
ret = reader_get_cardsystem(reader, &atr);
} else {
for (i = 0; i < AZBOX_MODES; i++) {
Azbox_SetMode(reader, i);
if (!reader_activate_card(reader, &atr, 0)) return(0);
ret = reader_get_cardsystem(reader, &atr);
if (ret)
break;
}
}
} else {
#endif
uint16_t deprecated;
for (deprecated = reader->deprecated; deprecated < 2; deprecated++) {
if (!reader_activate_card(reader, &atr, deprecated)) break;
ret = reader_get_cardsystem(reader, &atr);
if (ret)
break;
if (!deprecated)
rdr_log(reader, "Normal mode failed, reverting to Deprecated Mode");
}
#ifdef WITH_AZBOX
}
#endif
if (!ret)
{
reader->card_status = CARD_FAILURE;
rdr_log(reader, "card initializing error");
if (reader->typ == R_SC8in1 && reader->sc8in1_config->mcr_type) {
char text[] = {'S', (char)reader->slot+0x30, 'A', 'E', 'R'};
MCR_DisplayText(reader, text, 5, 400, 0);
}
led_status_card_activation_error();
}
else
{
reader_card_info(reader);
reader->card_status = CARD_INSERTED;
do_emm_from_file(reader);
if (reader->typ == R_SC8in1 && reader->sc8in1_config->mcr_type) {
char text[] = {'S', (char)reader->slot+0x30, 'A', 'O', 'K'};
MCR_DisplayText(reader, text, 5, 400, 0);
}
#ifdef WITH_COOLAPI
if (reader->typ == R_INTERNAL) {
rdr_debug_mask(reader, D_DEVICE, "init done - modifying timeout for coolstream internal device %s", reader->device);
call(Cool_Set_Transmit_Timeout(reader, 1));
}
#endif
}
return(ret);
}
