csctapi/protocol_t1.c

   1 #include "../globals.h"
   2 #include "../oscam-time.h"
   3 #ifdef WITH_CARDREADER
   4 #include "icc_async.h"
   5
   6 #define OK 0
   7 #define ERROR 1
   8
   9 /* Buffer sizes */
  10 #define T1_BLOCK_MAX_SIZE               259
  11
  12 /* Types of block */
  13 #define T1_BLOCK_I                              0x00
  14 #define T1_BLOCK_R_OK                   0x80
  15 #define T1_BLOCK_R_EDC_ERR              0x81
  16 #define T1_BLOCK_R_OTHER_ERR    0x82
  17 #define T1_BLOCK_S_RESYNCH_REQ  0xC0
  18 #define T1_BLOCK_S_RESYNCH_RES  0xE0
  19 #define T1_BLOCK_S_IFS_REQ              0xC1
  20 #define T1_BLOCK_S_IFS_RES              0xE1
  21 #define T1_BLOCK_S_ABORT_REQ    0xC2
  22 #define T1_BLOCK_S_ABORT_RES    0xE2
  23 #define T1_BLOCK_S_WTX_REQ              0xC3
  24 #define T1_BLOCK_S_WTX_RES              0xE3
  25 #define T1_BLOCK_S_VPP_ERR              0xE4
  26
  27 #define T1_BLOCK_NAD                    0x00
  28
  29 #define T1_Block_GetNS(a)   ((a[1] >> 6) & 0x01)
  30 #define T1_Block_GetMore(a) ((a[1] >> 5) & 0x01)
  31 #define T1_Block_GetNR(a)   ((a[1] >> 4) & 0x01)
  32 #define T1_Block_GetLen(a)  a[2]
  33
  34
  35 static unsigned char T1_Block_LRC(unsigned char *data, uint32_t length)
  36 {
  37         unsigned char lrc = 0x00;
  38         uint32_t i;
  39         for(i = 0; i < length; i++)
  40         {
  41                 lrc ^= data[i];
  42         }
  43         return lrc;
  44 }
  45
  46 static int32_t T1_Block_SendIBlock(struct s_reader *reader, uint8_t *block_data, unsigned char len, unsigned char *inf, unsigned char ns, int32_t more, uint32_t timeout)
  47 {
  48         int length = len + 4;
  49
  50         block_data[0] = T1_BLOCK_NAD;
  51         block_data[1] = T1_BLOCK_I | ((ns << 6) & 0x40);
  52         if(more)
  53         {
  54                 block_data[1] |= 0x20;
  55         }
  56         block_data[2] = len;
  57         if(len != 0x00)
  58         {
  59                 memcpy(block_data + 3, inf, len);
  60         }
  61         block_data[len + 3] = T1_Block_LRC(block_data, len + 3);
  62
  63         return ICC_Async_Transmit(reader, length, 0, block_data, 0, timeout);
  64 }
  65
  66 static int32_t T1_Block_SendRBlock(struct s_reader *reader, uint8_t *block_data, unsigned char type, unsigned char nr, uint32_t timeout)
  67 {
  68         int length = 4;
  69
  70         block_data[0] = T1_BLOCK_NAD;
  71         block_data[1] = type | ((nr << 4) & 0x10);
  72         block_data[2] = 0x00;
  73         block_data[3] = T1_Block_LRC(block_data, 3);
  74
  75         return ICC_Async_Transmit(reader, length, 0, block_data, 0, timeout);
  76 }
  77
  78 static int32_t T1_Block_SendSBlock(struct s_reader *reader, uint8_t *block_data, unsigned char type, unsigned char len, unsigned char *inf, uint32_t timeout)
  79 {
  80         int length = 4 + len;
  81
  82         block_data[0] = T1_BLOCK_NAD;
  83         block_data[1] = type;
  84         block_data[2] = len;
  85         if(len != 0x00)
  86         {
  87                 memcpy(block_data + 3, inf, len);
  88         }
  89
  90         block_data[len + 3] = T1_Block_LRC(block_data, len + 3);
  91
  92         return ICC_Async_Transmit(reader, length, 0, block_data, 0, timeout);
  93 }
  94
  95 static int32_t Protocol_T1_ReceiveBlock(struct s_reader *reader, uint8_t *block_data, uint32_t *block_length, uint8_t *rsp_type, uint32_t timeout)
  96 {
  97         int32_t ret, length;
  98
  99         /* Receive four mandatory bytes */
 100         if(ICC_Async_Receive(reader, 4, block_data, 0, timeout))
 101         {
 102                 ret = ERROR;
 103         }
 104         else
 105         {
 106                 length = block_data[2];
 107                 if(length != 0x00)
 108                 {
 109                         *block_length = (length + 4 > T1_BLOCK_MAX_SIZE) ? T1_BLOCK_MAX_SIZE : length + 4;
 110
 111                         /* Receive remaining bytes */
 112                         if(ICC_Async_Receive(reader, *block_length - 4, block_data + 4, 0, timeout))
 113                         {
 114                                 ret = ERROR;
 115                         }
 116                         else
 117                         {
 118                                 ret = OK;
 119                         }
 120                 }
 121                 else
 122                 {
 123                         ret = OK;
 124                         *block_length = 4;
 125                 }
 126         }
 127         *rsp_type = ((block_data[1] & 0x80) == T1_BLOCK_I) ? T1_BLOCK_I : (block_data[1] & 0xEF);
 128
 129         return ret;
 130 }
 131
 132 int32_t Protocol_T1_Command(struct s_reader *reader, unsigned char *command, uint16_t command_len, unsigned char *rsp, uint16_t *lr)
 133 {
 134         uint8_t block_data[T1_BLOCK_MAX_SIZE];
 135         uint8_t rsp_type, bytes, nr, wtx;
 136         uint16_t counter;
 137         int32_t ret, timeout;
 138         bool more;
 139         uint32_t block_length = 0;
 140         if(command[1] == T1_BLOCK_S_IFS_REQ)
 141         {
 142                 uint8_t inf = command[3];
 143
 144                 /* Create an IFS request S-Block */
 145                 timeout = ICC_Async_GetTimings(reader, reader->CWT);  // we are going to send: CWT timeout
 146                 //cs_sleepus(reader->block_delay); // we were receiving, now sending so wait BGT time
 147                 ret = T1_Block_SendSBlock(reader, block_data, T1_BLOCK_S_IFS_REQ, 1, &inf, timeout);
 148                 if(ret == ERROR)
 149                 {
 150                         rdr_log_dbg(reader, D_IFD, "Protocol: Sending block S(IFS request, %d)", inf);
 151                 }
 152
 153                 /* Receive a block */
 154                 timeout = ICC_Async_GetTimings(reader, reader->BWT); // we are going to receive so set Block Waiting Timeout!
 155                 //cs_sleepus(reader->block_delay); // we were sending, now receiving so wait BGT time
 156                 ret = Protocol_T1_ReceiveBlock(reader, block_data, &block_length, &rsp_type, timeout);
 157
 158                 if(ret == OK)
 159                 {
 160                         /* Positive IFS Response S-Block received */
 161                         if(rsp_type == T1_BLOCK_S_IFS_RES)
 162                         {
 163                                 rdr_log_dbg(reader, D_IFD, "Protocol: Received block S(IFS response, %d)", block_data[3]);
 164                         }
 165                 }
 166
 167                 return ret;
 168         }
 169         else if(command[1] == T1_BLOCK_S_RESYNCH_REQ)
 170         {
 171                 /* Create an Resynch request S-Block */
 172                 timeout = ICC_Async_GetTimings(reader, reader->CWT);  // we are going to send: CWT timeout
 173                 //cs_sleepus(reader->block_delay); // we were receiving, now sending so wait BGT time
 174                 ret = T1_Block_SendSBlock(reader, block_data, T1_BLOCK_S_RESYNCH_REQ, 0, NULL, timeout);
 175                 if(ret == ERROR)
 176                 {
 177                         rdr_log_dbg(reader, D_IFD, "Protocol: Sending block S(RESYNCH request)");
 178                 }
 179
 180                 /* Receive a block */
 181                 timeout = ICC_Async_GetTimings(reader, reader->BWT); // we are going to receive so set Block Waiting Timeout!
 182                 //cs_sleepus(reader->block_delay); // we were sending, now receiving so wait BGT time
 183                 ret = Protocol_T1_ReceiveBlock(reader, block_data, &block_length, &rsp_type, timeout);
 184
 185                 if(ret == OK)
 186                 {
 187                         /* Positive IFS Response S-Block received */
 188                         if(rsp_type == T1_BLOCK_S_RESYNCH_RES)
 189                         {
 190                                 rdr_log_dbg(reader, D_IFD, "Protocol: Received block S(RESYNCH response)");
 191                                 reader->ns = 0;
 192                         }
 193                 }
 194                 return ret;
 195         }
 196
 197         /* Calculate the number of bytes to send */
 198         counter = 0;
 199         bytes = MIN(command_len, reader->ifsc);
 200
 201         /* See if chaining is needed */
 202         more = (command_len > reader->ifsc);
 203
 204         /* Increment ns */
 205         reader->ns = (reader->ns == 1) ? 0 : 1; //toggle from 0 to 1 and back
 206
 207         /* Create an I-Block */
 208         timeout = ICC_Async_GetTimings(reader, reader->CWT);  // we are going to send: CWT timeout
 209         //cs_sleepus(reader->block_delay); // we were receiving, now sending so wait BGT time
 210         ret = T1_Block_SendIBlock(reader, block_data, bytes, command, reader->ns, more, timeout);
 211         rdr_log_dbg(reader, D_IFD, "Sending block I(%d,%d)", reader->ns, more);
 212
 213         while((ret == OK) && more)
 214         {
 215                 /* Receive a block */
 216
 217                 timeout = ICC_Async_GetTimings(reader, reader->BWT); // we are going to receive so set Block Waiting Timeout!
 218                 //cs_sleepus(reader->block_delay); // we were sending, now receiving so wait BGT time
 219                 ret = Protocol_T1_ReceiveBlock(reader, block_data, &block_length, &rsp_type, timeout);
 220
 221                 if(ret == OK)
 222                 {
 223                         /* Positive ACK R-Block received */
 224                         if(rsp_type == T1_BLOCK_R_OK)
 225                         {
 226                                 rdr_log_dbg(reader, D_IFD, "Protocol: Received block R(%d)", T1_Block_GetNR(block_data));
 227
 228                                 /* Increment ns  */
 229                                 reader->ns = (reader->ns == 1) ? 0 : 1; //toggle from 0 to 1 and back
 230
 231                                 /* Calculate the number of bytes to send */
 232                                 counter += bytes;
 233                                 bytes = MIN(command_len - counter, reader->ifsc);
 234
 235                                 /* See if chaining is needed */
 236                                 more = (command_len - counter > reader->ifsc);
 237
 238                                 /* Send an I-Block */
 239                                 timeout = ICC_Async_GetTimings(reader, reader->CWT);  // we are going to send: CWT timeout
 240                                 //cs_sleepus(reader->block_delay); // we were receiving, now sending so wait BGT time
 241                                 ret = T1_Block_SendIBlock(reader, block_data, bytes, command + counter, reader->ns, more, timeout);
 242                                 rdr_log_dbg(reader, D_IFD, "Protocol: Sending block I(%d,%d)", reader->ns, more);
 243
 244                         }
 245                         else
 246                         {
 247                                 rdr_log_dbg(reader, D_TRACE, "ERROR: T1 Command %02X not implemented", rsp_type);
 248                                 return ERROR;
 249                         }
 250                 }
 251                 else
 252                 {
 253                         rdr_log_dbg(reader, D_TRACE, "ERROR: T1 Command returned error");
 254                         return ERROR;
 255                 }
 256         }
 257
 258         /* Reset counter */
 259         counter = 0;
 260         more = 1;
 261         wtx = 1;
 262
 263         while((ret == OK) && more)
 264         {
 265
 266                 /* Receive a block */
 267                 timeout = ICC_Async_GetTimings(reader, wtx * reader->BWT); // we are going to receive so set Block Waiting Timeout!
 268                 //cs_sleepus(reader->block_delay); // we were sending, now receiving so wait BGT time
 269                 ret = Protocol_T1_ReceiveBlock(reader, block_data, &block_length, &rsp_type, timeout);
 270                 wtx = 1; // reset WTX value since its only valid for first received I block
 271
 272                 if(ret == OK)
 273                 {
 274                         if(rsp_type == T1_BLOCK_I)
 275                         {
 276                                 rdr_log_dbg(reader, D_IFD, "Protocol: Received block I(%d,%d)", T1_Block_GetNS(block_data), T1_Block_GetMore(block_data));
 277
 278                                 bytes = T1_Block_GetLen(block_data);
 279
 280                                 /* Calculate nr */
 281                                 nr = (T1_Block_GetNS(block_data) + 1) % 2;
 282
 283                                 if(counter + bytes > T1_BLOCK_MAX_SIZE)
 284                                 {
 285                                         return ERROR;
 286                                 }
 287
 288                                 memcpy(rsp + counter, block_data + 3, bytes);
 289                                 counter += bytes;
 290
 291                                 /* See if chaining is requested */
 292                                 more = T1_Block_GetMore(block_data);
 293
 294                                 if(more)
 295                                 {
 296                                         /* Send R-Block */
 297                                         timeout = ICC_Async_GetTimings(reader, reader->CWT);  // we are going to send: CWT timeout
 298                                         //cs_sleepus(reader->block_delay); // we were receiving, now sending so wait BGT time
 299                                         ret = T1_Block_SendRBlock(reader, block_data, T1_BLOCK_R_OK, nr, timeout);
 300                                         rdr_log_dbg(reader, D_IFD, "Protocol: Sending block R(%d)", nr);
 301                                 }
 302                         }
 303                         else if(rsp_type == T1_BLOCK_S_WTX_REQ)      /* WTX Request S-Block received */
 304                         {
 305                                 /* Get wtx multiplier */
 306                                 wtx = block_data[3];
 307                                 rdr_log_dbg(reader, D_IFD, "Protocol: Received block S(WTX request, %d)", wtx);
 308
 309                                 /* Send an WTX response S-Block */
 310                                 timeout = ICC_Async_GetTimings(reader, reader->CWT);  // we are going to send: CWT timeout
 311                                 //cs_sleepus(reader->block_delay); // we were receiving, now sending so wait BGT time
 312                                 ret = T1_Block_SendSBlock(reader, block_data, T1_BLOCK_S_WTX_RES, 1, &wtx, timeout);
 313                                 rdr_log_dbg(reader, D_IFD, "Protocol: Sending block S(WTX response, %d)", wtx);
 314                         }
 315                         else
 316                         {
 317                                 rdr_log_dbg(reader, D_TRACE, "ERROR: T1 Command %02X not implemented in Receive Block", rsp_type);
 318                                 ret = ERROR; //not implemented
 319                         }
 320                 }
 321         }
 322
 323         if(ret == OK)
 324         {
 325                 *lr = counter;
 326         }
 327
 328         return ret;
 329 }
 330 #endif