csctapi/ifd_smargo.c

   1 #include "../globals.h"
   2
   3 #ifdef CARDREADER_SMARGO
   4 #include "../oscam-time.h"
   5 #include "icc_async.h"
   6 #include "io_serial.h"
   7
   8 #if defined(__CYGWIN__)
   9 #undef OK
  10 #undef ERROR
  11 #undef LOBYTE
  12 #undef HIBYTE
  13 #endif
  14
  15 #define OK 0
  16 #define ERROR 1
  17 #define LOBYTE(w) ((unsigned char)((w) & 0xff))
  18 #define HIBYTE(w) ((unsigned char)((w) >> 8))
  19
  20 #define SMARGO_DELAY 150
  21
  22 static void smargo_set_config_mode_on(struct s_reader *reader)
  23 {
  24         struct termios term;
  25
  26         tcgetattr(reader->handle, &term);
  27         term.c_cflag &= ~CSIZE;
  28         term.c_cflag |= CS5;
  29         tcsetattr(reader->handle, TCSANOW, &term);
  30
  31         cs_sleepms(SMARGO_DELAY);
  32 }
  33
  34 static void smargo_set_config_mode_off(struct s_reader *reader)
  35 {
  36         struct termios term;
  37
  38         cs_sleepms(SMARGO_DELAY);
  39
  40         tcgetattr(reader->handle, &term);
  41         term.c_cflag &= ~CSIZE;
  42         term.c_cflag |= CS8;
  43         tcsetattr(reader->handle, TCSANOW, &term);
  44 }
  45
  46 static int32_t smargo_set_settings(struct s_reader *reader, int32_t freq, unsigned char T, unsigned char inv, uint16_t Fi, unsigned char Di, unsigned char Ni)
  47 {
  48         uint16_t freqk = (freq * 10);
  49         uint8_t data[4];
  50
  51         smargo_set_config_mode_on(reader);
  52
  53         rdr_log_dbg(reader, D_DEVICE, "sending F=%04X (%d), D=%02X (%d), Freq=%04X (%d), N=%02X (%d), T=%02X (%d), inv=%02X (%d)",
  54                                    Fi, Fi, Di, Di, freqk, freqk, Ni, Ni, T, T, inv, inv);
  55
  56         if(T != 14 || freq == 369)
  57         {
  58                 data[0] = 0x01;
  59                 data[1] = HIBYTE(Fi);
  60                 data[2] = LOBYTE(Fi);
  61                 data[3] = Di;
  62                 IO_Serial_Write(reader, 0, 1000, 4, data);
  63         }
  64
  65         data[0] = 0x02;
  66         data[1] = HIBYTE(freqk);
  67         data[2] = LOBYTE(freqk);
  68         IO_Serial_Write(reader, 0, 1000, 3, data);
  69
  70         data[0] = 0x03;
  71         data[1] = Ni;
  72         IO_Serial_Write(reader, 0, 1000, 2, data);
  73
  74         data[0] = 0x04;
  75         data[1] = T;
  76         IO_Serial_Write(reader, 0, 1000, 2, data);
  77
  78         data[0] = 0x05;
  79         data[1] = inv;
  80         IO_Serial_Write(reader, 0, 1000, 2, data);
  81
  82         smargo_set_config_mode_off(reader);
  83
  84         return OK;
  85 }
  86
  87 static int32_t smargo_write_settings(struct s_reader *reader, struct s_cardreader_settings *s)
  88 {
  89         return smargo_set_settings(reader, reader->mhz, reader->protocol_type == 1 ? 0 : reader->protocol_type , reader->convention, s->Fi, s->D, s->Ni);
  90 }
  91
  92
  93 static int32_t smargo_init(struct s_reader *reader)
  94 {
  95         reader->handle = open(reader->device,  O_RDWR);
  96
  97         if(reader->handle < 0)
  98         {
  99                 rdr_log(reader, "ERROR: Opening device %s (errno=%d %s)", reader->device, errno, strerror(errno));
 100                 return ERROR;
 101         }
 102
 103         if(IO_Serial_SetParams(reader, DEFAULT_BAUDRATE, 8, PARITY_EVEN, 2, NULL, NULL))
 104                 { return ERROR; }
 105
 106         IO_Serial_RTS_Set(reader);
 107         IO_Serial_DTR_Set(reader);
 108         IO_Serial_Flush(reader);
 109
 110         return OK;
 111 }
 112
 113 static int32_t smargo_Serial_Read(struct s_reader *reader, uint32_t timeout, uint32_t size, unsigned char *data, int32_t *read_bytes)
 114 {
 115         uint32_t count = 0;
 116         uint32_t bytes_read = 0;
 117
 118         for(count = 0; count < size ; count += bytes_read)
 119         {
 120                 if(IO_Serial_WaitToRead(reader, 0, timeout) == OK)
 121                 {
 122                         if((bytes_read = read(reader->handle, data + count, size - count)) < 1)
 123                         {
 124                                 int saved_errno = errno;
 125                                 rdr_log_dump_dbg(reader, D_DEVICE, data, count, "Receiving:");
 126                                 rdr_log(reader, "ERROR: %s (errno=%d %s)", __func__, saved_errno, strerror(saved_errno));
 127                                 return ERROR;
 128                         }
 129                 }
 130                 else
 131                 {
 132                         rdr_log_dump_dbg(reader, D_DEVICE, data, count, "Receiving:");
 133                         rdr_log_dbg(reader, D_DEVICE, "Timeout in IO_Serial_Read");
 134                         *read_bytes = count;
 135                         return ERROR;
 136                 }
 137         }
 138         rdr_log_dump_dbg(reader, D_DEVICE, data, count, "Receiving:");
 139         return OK;
 140 }
 141
 142 static int32_t smargo_fast_reset_by_atr(struct s_reader *reader, ATR *atr)
 143 {
 144         int32_t ret = ERROR;
 145         unsigned char buf[ATR_MAX_SIZE];
 146         int32_t n = 0;
 147         int8_t atr_len = 0;
 148
 149         if(reader->seca_nagra_card == 1)
 150         {
 151                 atr_len = reader->card_atr_length; // this is a special case the data buffer has only the atr length.
 152         }
 153         else
 154         {
 155                 atr_len = reader->card_atr_length + 2; // data buffer has atr length + 2 bytes
 156         }
 157
 158         IO_Serial_Read(reader, 0, 500000, atr_len, buf);
 159
 160         IO_Serial_RTS_Set(reader);
 161         cs_sleepms(150);
 162         IO_Serial_RTS_Clr(reader);
 163
 164         smargo_Serial_Read(reader, ATR_TIMEOUT, atr_len + 1, buf, &n);
 165
 166         if(ATR_InitFromArray(atr, buf, n) != ERROR)
 167         {
 168                 rdr_log_dbg(reader, D_DEVICE, "SR: ATR parsing OK");
 169                 ret = OK;
 170         }
 171
 172         return ret;
 173 }
 174
 175 static int32_t smargo_reset(struct s_reader *reader, ATR *atr)
 176 {
 177         rdr_log_dbg(reader, D_IFD, "Resetting card");
 178         int32_t ret = ERROR;
 179         int32_t i;
 180         unsigned char buf[ATR_MAX_SIZE];
 181
 182         int32_t parity[4] = {PARITY_EVEN, PARITY_ODD, PARITY_NONE, PARITY_EVEN};
 183
 184         int32_t mhz = 369;
 185
 186         if(reader->mhz == reader->cardmhz && reader->cardmhz > 369)
 187                 { mhz = reader->cardmhz; }
 188
 189         for(i = 0; i < 4; i++)
 190         {
 191                 if(i == 3)  // hack for irdeto cards
 192                         { smargo_set_settings(reader, 600, 1, 0, 618, 1, 0); }
 193                 else
 194                         { smargo_set_settings(reader, mhz, 0, 0, 372, 1, 0); }
 195
 196                 call(IO_Serial_SetParity(reader, parity[i]));
 197
 198                 //IO_Serial_Flush(reader);
 199
 200                 IO_Serial_Read(reader, 0, 500000, ATR_MAX_SIZE, buf);
 201
 202                 IO_Serial_RTS_Set(reader);
 203                 cs_sleepms(150);
 204                 IO_Serial_RTS_Clr(reader);
 205
 206                 int32_t n = 0;
 207
 208                 smargo_Serial_Read(reader, ATR_TIMEOUT, ATR_MAX_SIZE, buf, &n);
 209
 210                 if(n == 0 || buf[0] == 0)
 211                         { continue; }
 212
 213                 rdr_log_dump_dbg(reader, D_IFD, buf, n, "ATR: %d bytes", n);
 214
 215                 if((buf[0] != 0x3B && buf[0] != 0x03 && buf[0] != 0x3F) || (buf[1] == 0xFF && buf[2] == 0x00))
 216                         { continue; } // this is not a valid ATR
 217
 218                 if(ATR_InitFromArray(atr, buf, n) != ERROR)
 219                 {
 220                         ret = OK;
 221                         break;
 222                 }
 223         }
 224
 225         int32_t convention;
 226
 227         ATR_GetConvention(atr, &convention);
 228         // If inverse convention, switch here due to if not PTS will fail
 229         if(convention == ATR_CONVENTION_INVERSE)
 230         {
 231                 uint8_t data[4];
 232
 233                 smargo_set_config_mode_on(reader);
 234
 235                 data[0] = 0x05;
 236                 data[1] = 0x01;
 237                 IO_Serial_Write(reader, 0, 1000, 2, data);
 238
 239                 smargo_set_config_mode_off(reader);
 240         }
 241
 242         return ret;
 243 }
 244
 245 int32_t smargo_activate(struct s_reader *reader, struct s_ATR *atr)
 246 {
 247         if(!reader->ins7e11_fast_reset)
 248         {
 249                 call(smargo_reset(reader, atr));
 250         }
 251         else
 252         {
 253                 rdr_log_dbg(reader, D_DEVICE, "Fast card reset with atr");
 254                 call(smargo_fast_reset_by_atr(reader, atr));
 255         }
 256         return OK;
 257 }
 258
 259 const struct s_cardreader cardreader_smargo =
 260 {
 261         .desc            = "smargo",
 262         .typ             = R_MOUSE,
 263         .max_clock_speed = 1,
 264         .reader_init     = smargo_init,
 265         .activate        = smargo_activate,
 266         .write_settings  = smargo_write_settings,
 267         .get_status      = IO_Serial_GetStatus,
 268         .transmit        = IO_Serial_Transmit,
 269         .receive         = IO_Serial_Receive,
 270         .close           = IO_Serial_Close,
 271         .set_parity      = IO_Serial_SetParity,
 272 };
 273
 274 #endif