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;
}
}
int32_t Cool_WriteSettings (struct s_reader *reader, uint32_t BWT, uint32_t CWT, uint32_t EGT, uint32_t BGT)
{
//this code worked with old cnxt_lnx.ko, but prevented nagra cards from working with new cnxt_lnx.ko
/* struct
{
unsigned short CardActTime; //card activation time (in clock cycles = 1/54Mhz)
unsigned short CardDeactTime; //card deactivation time (in clock cycles = 1/54Mhz)
unsigned short ATRSTime; //ATR first char timeout in clock cycles (1/f)
unsigned short ATRDTime; //ATR duration in ETU
unsigned long BWT;
unsigned long CWT;
unsigned char EGT;
unsigned char BGT;
} params;
params.BWT = BWT;
params.CWT = CWT;
params.EGT = EGT;
params.BGT = BGT;
call (cnxt_smc_set_config_timeout(specdev()->handle, params));
cs_debug_mask(D_DEVICE, "COOL WriteSettings OK");*/
//set freq back to reader->mhz if necessary
uint32_t clk;
int32_t ret = cnxt_smc_get_clock_freq (specdev()->handle, &clk);
check_error("cnxt_smc_get_clock_freq", ret);
if (clk/10000 != reader->mhz) {
cs_debug_mask(D_DEVICE,"COOL: %s clock freq: %i, scheduling change to %i", reader->label, clk, reader->mhz*10000);
call (Cool_SetClockrate(reader, reader->mhz));
}
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_WriteSettings (struct s_reader *reader, uint32_t UNUSED(BWT), uint32_t UNUSED(CWT), uint32_t UNUSED(EGT), uint32_t UNUSED(BGT))
{
//first set freq back to reader->mhz if necessary
uint32_t clk;
int32_t ret = cnxt_smc_get_clock_freq (specdev()->handle, &clk);
coolapi_check_error("cnxt_smc_get_clock_freq", ret);
if (clk/10000 != (uint32_t)reader->mhz) {
rdr_debug_mask(reader, D_DEVICE, "COOL: clock freq: %i, scheduling change to %i", clk, reader->mhz * 10000);
call (Cool_SetClockrate(reader, reader->mhz));
}
//driver sets values in ETU automatically (except read_write_transmit_timeout)
//... but lets see what the driver did
uint16_t F;
uint8_t D;
ret = cnxt_smc_get_F_D_factors(specdev()->handle, &F, &D);
coolapi_check_error("cnxt_smc_get_F_D_factors", ret);
char *protocol;
CNXT_SMC_COMM comm;
ret = cnxt_smc_get_comm_parameters(specdev()->handle, &comm);
coolapi_check_error("cnxt_smc_get_comm_parameters", ret);
if (comm.protocol==0x01)
protocol = "T0";
else if (comm.protocol==0x02)
protocol = "T1";
else if (comm.protocol==0x04)
protocol = "T14";
else
protocol = "unknown";
rdr_log(reader, "Driver Settings: Convention=%s, Protocol=%s, FI=%i, F=%i, N=%i, DI=%i, D=%i, PI1=%i, PI2=%i, II=%i, TXRetries=%i, RXRetries=%i, FilterProtocolBytes=%i", comm.convention ? "Inverse" : "Direct", protocol, comm.FI, F, comm.N, comm.DI, D, comm.PI1, comm.PI2, comm.II, comm.retries.TXRetries, comm.retries.RXRetries, comm.filterprotocolbytes);
CNXT_SMC_TIMEOUT timeout;
ret = cnxt_smc_get_config_timeout(specdev()->handle, &timeout);
coolapi_check_error("cnxt_smc_get_config_timeout", ret);
rdr_log(reader, "Driver Settings: CardActTime=%i, CardDeactTime=%i, ATRSTime=%i, ATRDTime=%i, BLKTime=%i, CHTime=%i, CHGuardTime=%i, BKGuardTime=%i", timeout.CardActTime, timeout.CardDeactTime, timeout.ATRSTime, timeout.ATRDTime, timeout.BLKTime, timeout.CHTime, timeout.CHGuardTime, timeout.BKGuardTime);
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;
}
}
static int32_t Cool_WriteSettings(struct s_reader *reader, struct s_cardreader_settings *s)
{
struct cool_data *crdr_data = reader->crdr_data;
//first set freq back to reader->mhz if necessary
uint32_t clk;
int32_t 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->mhz)
{
rdr_log_dbg(reader, D_DEVICE, "COOL: clock freq: %i, scheduling change to %i", clk, reader->mhz * 10000);
call(Cool_SetClockrate(reader, reader->mhz));
}
uint32_t BLKTime = 0, CHTime = 0;
uint8_t BKGuardTime = 0;
switch(reader->protocol_type)
{
case ATR_PROTOCOL_TYPE_T1:
if(reader->BWT > 11)
{ BLKTime = (reader->BWT - 11); }
if(reader->CWT > 11)
{ CHTime = (reader->CWT - 11); }
if(s->BGT > 11)
{ BKGuardTime = (s->BGT - 11); }
else
{ BKGuardTime = 11; } //For T1, the BGT minimum time shall be 22 work etus. BGT is effectively offset by 11 etus internally.
if(!crdr_data->pps)
{
ret = cnxt_smc_set_F_D_factors(crdr_data->handle, s->F, s->D);
coolapi_check_error("cnxt_smc_set_F_D_factors", ret);
}
break;
case ATR_PROTOCOL_TYPE_T0:
case ATR_PROTOCOL_TYPE_T14:
default:
BLKTime = 0;
if(s->WWT > 12)
{ CHTime = (s->WWT - 12); }
if(s->BGT > 12)
{ BKGuardTime = (s->BGT - 12); }
if(BKGuardTime < 4)
{ BKGuardTime = 4; } //For T0, the BGT minimum time shall be 16 work etus. BGT is effectively offset by 12 etus internally.
if(!crdr_data->pps)
{
if(reader->protocol_type == ATR_PROTOCOL_TYPE_T14)
{
ret = cnxt_smc_set_F_D_factors(crdr_data->handle, 620, 1);
}
else
{
ret = cnxt_smc_set_F_D_factors(crdr_data->handle, s->F, s->D);
}
coolapi_check_error("cnxt_smc_set_F_D_factors", ret);
}
break;
}
ret = cnxt_smc_set_convention(crdr_data->handle, reader->convention);
coolapi_check_error("cnxt_smc_set_convention", ret);
CNXT_SMC_TIMEOUT timeout;
ret = cnxt_smc_get_config_timeout(crdr_data->handle, &timeout);
coolapi_check_error("cnxt_smc_get_config_timeout", ret);
timeout.BLKTime = BLKTime;
timeout.CHTime = CHTime;
timeout.CHGuardTime = s->EGT;
timeout.BKGuardTime = BKGuardTime;
ret = cnxt_smc_set_config_timeout(crdr_data->handle, timeout);
coolapi_check_error("cnxt_smc_set_config_timeout", ret);
Cool_Print_Comm_Parameters(reader);
return OK;
}
