git.zerfleddert.de Git - proxmark3-svn/blob - client/cmdlft55xx.c

   1 //-----------------------------------------------------------------------------
   2 //
   3 // This code is licensed to you under the terms of the GNU GPL, version 2 or,
   4 // at your option, any later version. See the LICENSE.txt file for the text of
   5 // the license.
   6 //-----------------------------------------------------------------------------
   7 // Low frequency T55xx commands
   8 //-----------------------------------------------------------------------------
   9
  10 #include <stdio.h>
  11 #include <string.h>
  12 #include <inttypes.h>
  13 #include "proxmark3.h"
  14 #include "ui.h"
  15 #include "graph.h"
  16 #include "cmdmain.h"
  17 #include "cmdparser.h"
  18 #include "cmddata.h"
  19 #include "cmdlf.h"
  20 #include "cmdlft55xx.h"
  21 #include "util.h"
  22 #include "data.h"
  23 #include "lfdemod.h"
  24 #include "../common/crc.h"
  25
  26 #define LF_TRACE_BUFF_SIZE 20000 // 32 x 32 x 10  (32 bit times numofblock (7), times clock skip..)
  27 #define LF_BITSSTREAM_LEN 1000 // more then 1000 bits shouldn't happend..  8block * 4 bytes * 8bits =
  28
  29 //  0 = FSK
  30 //  1 = ASK
  31 //  2 = PSK
  32 //  4 = NZR (direct)
  33 typedef struct {
  34         uint8_t modulation;
  35         bool inversed;
  36         uint32_t block0;
  37 } t55xx_conf_block_t;
  38
  39 // Default configuration: FSK, not inversed.
  40 t55xx_conf_block_t config = { .modulation = 0, .inversed = FALSE, .block0 = 0x00};
  41
  42 int usage_t55xx_config(){
  43         PrintAndLog("Usage: lf t55xx config [d <demodulation>] [i 1]");
  44         PrintAndLog("Options:        ");
  45         PrintAndLog("       h                        This help");
  46         PrintAndLog("       d <FSK|ASK|PSK|NZ|BI>    Set demodulation FSK / ASK / PSK / NZ / Biphase");
  47         PrintAndLog("       i [1]                    Inverse data signal, defaults to normal");
  48         PrintAndLog("");
  49         PrintAndLog("Examples:");
  50         PrintAndLog("      lf t55xx config d FSK     - FSK demodulation");
  51         PrintAndLog("      lf t55xx config d FSK i 1 - FSK demodulation, inverse data");
  52         PrintAndLog("");
  53         return 0;
  54 }
  55 int usage_t55xx_read(){
  56         PrintAndLog("Usage:  lf t55xx read <block> <password>");
  57     PrintAndLog("     <block>, block number to read. Between 0-7");
  58     PrintAndLog("     <password>, OPTIONAL password (8 hex characters)");
  59     PrintAndLog("");
  60         PrintAndLog("Examples:");
  61     PrintAndLog("      lf t55xx read 0           - read data from block 0");
  62         PrintAndLog("      lf t55xx read 0 feedbeef  - read data from block 0 password feedbeef");
  63         PrintAndLog("");
  64         return 0;
  65 }
  66 int usage_t55xx_write(){
  67         PrintAndLog("Usage:  lf t55xx wr <block> <data> [password]");
  68     PrintAndLog("     <block>, block number to read. Between 0-7");
  69         PrintAndLog("     <data>,  4 bytes of data to write (8 hex characters)");
  70     PrintAndLog("     [password], OPTIONAL password 4bytes (8 hex characters)");
  71     PrintAndLog("");
  72         PrintAndLog("Examples:");
  73     PrintAndLog("      lf t55xx wd 3 11223344           - write 11223344 to block 3");
  74         PrintAndLog("      lf t55xx wd 3 11223344 feedbeef  - write 11223344 to block 3 password feedbeef");
  75         PrintAndLog("");
  76         return 0;
  77 }
  78 int usage_t55xx_trace() {
  79         PrintAndLog("Usage:  lf t55xx trace [1]");
  80         PrintAndLog("     [graph buffer data], if set, use Graphbuffer otherwise read data from tag.");
  81         PrintAndLog("");
  82         PrintAndLog("Examples:");
  83         PrintAndLog("      lf t55xx trace");
  84         PrintAndLog("      lf t55xx trace 1");
  85         PrintAndLog("");
  86         return 0;
  87 }
  88 int usage_t55xx_info() {
  89         PrintAndLog("Usage:  lf t55xx info [1]");
  90         PrintAndLog("     [graph buffer data], if set, use Graphbuffer otherwise read data from tag.");
  91         PrintAndLog("");
  92         PrintAndLog("Examples:");
  93         PrintAndLog("      lf t55xx info");
  94         PrintAndLog("      lf t55xx info 1");
  95         PrintAndLog("");
  96         return 0;
  97 }
  98 int usage_t55xx_dump(){
  99         PrintAndLog("Usage:  lf t55xx dump <password>");
 100     PrintAndLog("     <password>, OPTIONAL password 4bytes (8 hex symbols)");
 101         PrintAndLog("");
 102         PrintAndLog("Examples:");
 103         PrintAndLog("      lf t55xx dump");
 104         PrintAndLog("      lf t55xx dump feedbeef");
 105         PrintAndLog("");
 106         return 0;
 107 }
 108
 109 static int CmdHelp(const char *Cmd);
 110
 111 int CmdT55xxSetConfig(const char *Cmd){
 112
 113         int len;
 114         bool inverse;
 115         bool errors = FALSE;
 116         uint8_t cmdp = 0;
 117         char modulation[4] = {0x00};
 118
 119         while(param_getchar(Cmd, cmdp) != 0x00 && !errors)
 120         {
 121                 switch(param_getchar(Cmd, cmdp))
 122                 {
 123                 case 'h':
 124                 case 'H':
 125                         return usage_t55xx_config();
 126                 case 'd':
 127                         len = param_getstr(Cmd, cmdp+1, modulation);
 128                         cmdp+= len+1;
 129                         //FSK|ASK|PSK|NZ|BI
 130                         if ( strcmp(modulation, "FSK" ) == 0)
 131                                 len = 1;
 132                         else if ( strcmp(modulation, "ASK" ) == 0)
 133                                 len = 2;
 134                         else if ( strcmp(modulation, "PSK" ) == 0)
 135                                 len = 3;
 136                         else if ( strcmp(modulation, "NZ" ) == 0)
 137                                 len = 4;
 138                         else if ( strcmp(modulation, "BI" ) == 0)
 139                                 len = 5;
 140                         else {
 141                                 PrintAndLog("Unknown modulation '%s'", modulation);
 142                                 errors = TRUE;
 143                         }
 144                         break;
 145                 case 'i':
 146                         inverse = param_getchar(Cmd,cmdp+1) == '1';
 147                         cmdp+=2;
 148                         break;
 149                 default:
 150                         PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd, cmdp));
 151                         errors = TRUE;
 152                         break;
 153                 }
 154         }
 155         // No args
 156         if (cmdp == 0) {
 157                 PrintAndLog("Modulation: %d", config.modulation);
 158                 PrintAndLog("Invert    : %d", config.inversed);
 159                 PrintAndLog("Block0    : %08X", config.block0);
 160                 return 0;
 161         }
 162         //Validations
 163         if (errors)
 164                 return usage_t55xx_config();
 165
 166         config.modulation = len;
 167         config.inversed = inverse;
 168         config.block0 = 0;
 169         return 0;
 170 }
 171 // detect configuration?
 172
 173 int CmdReadBlk(const char *Cmd)
 174 {
 175         int block = -1;
 176         int password = 0xFFFFFFFF; //default to blank Block 7
 177
 178         char cmdp = param_getchar(Cmd, 0);
 179         if (cmdp == 'h' || cmdp == 'H')
 180                 return usage_t55xx_read();
 181
 182         int res = sscanf(Cmd, "%d %x", &block, &password);
 183
 184         if ( res < 1 || res > 2 ){
 185                 usage_t55xx_read();
 186                 return 1;
 187         }
 188
 189         if ((block < 0) | (block > 7)) {
 190                 PrintAndLog("Block must be between 0 and 7");
 191                 return 1;
 192         }
 193
 194         UsbCommand c = {CMD_T55XX_READ_BLOCK, {0, block, 0}};
 195         c.d.asBytes[0] = 0x0;
 196
 197         //Password mode
 198         if ( res == 2 ) {
 199                 c.arg[2] = password;
 200                 c.d.asBytes[0] = 0x1;
 201         }
 202
 203         SendCommand(&c);
 204         if ( !WaitForResponseTimeout(CMD_ACK,NULL,2500) ) {
 205                 PrintAndLog("command execution time out");
 206                 return 2;
 207         }
 208
 209         uint8_t got[12000];
 210         GetFromBigBuf(got,sizeof(got),0);
 211         WaitForResponse(CMD_ACK,NULL);
 212
 213         setGraphBuf(got, 12000);
 214
 215         if (block == 0){
 216                 // try a detection.
 217         }
 218
 219         if (GetFskClock("", FALSE, FALSE)){ //wave is almost certainly FSK
 220                 // FSK
 221                 if ( FSKrawDemod("0 0", FALSE) && test())
 222                         printT55xx("FSK");
 223                 // FSK inverted
 224                 if ( FSKrawDemod("0 1", FALSE) && test())
 225                         printT55xx("FSK inv");
 226     } else {
 227                 // ASK/MAN (autoclock, normal, maxerrors 1)
 228                 if ( ASKmanDemod("0 0 1", FALSE, FALSE) && test())
 229                         printT55xx("ASK/MAN");
 230
 231                 // ASK/MAN (autoclock, inverted, maxerrors 1)
 232                 if ( ASKmanDemod("0 1 1", FALSE, FALSE)  && test())
 233                         printT55xx("ASK/MAN Inv");
 234
 235                 // NZR (autoclock, normal, maxerrors 1)
 236                 if ( NRZrawDemod("0 0 1", FALSE)  && test())
 237                         printT55xx("NZR");
 238                 // NZR (autoclock, inverted, maxerrors 1)
 239                 if ( NRZrawDemod("0 1 1", FALSE)  && test())
 240                         printT55xx("NZR inv");
 241
 242                 // PSK (autoclock, normal, maxerrors 1)
 243                 if ( PSKDemod("0 0 1", FALSE)  && test())
 244                         printT55xx("PSK");
 245
 246                 // PSK (autoclock, inverted, maxerrors 1)
 247                 if ( PSKDemod("0 1 1", FALSE) && test())
 248                         printT55xx("PSK inv");
 249
 250                 //PSK2?
 251
 252                 // if (!BiphaseRawDecode("0",FALSE)  && test())
 253                         // printT55xx("BIPHASE");
 254
 255                 // if (!BiphaseRawDecode("1",FALSE) && test())
 256                         // printT55xx("BIPHASE inv");
 257         }
 258         return 0;
 259 }
 260 bool test(){
 261
 262         if ( !DemodBufferLen)
 263                 return false;
 264
 265         uint8_t si = 1;
 266         uint8_t safer    = PackBits(si, 4, DemodBuffer); si += 4;
 267         uint8_t resv     = PackBits(si, 7, DemodBuffer); si += 7+3;
 268         uint8_t extend   = PackBits(si, 1, DemodBuffer); si += 1;
 269
 270         //PrintAndLog("test: %X %X %X ", safer, resv, extend);
 271
 272         // 2nibble must be zeroed.
 273         if ( resv > 0x00) return FALSE;
 274
 275         if ( safer == 0x6 || safer == 0x9){
 276                 if ( extend == 0x00)
 277                         return TRUE;
 278         }
 279         if ( resv== 0x00) return TRUE;
 280         return FALSE;
 281 }
 282
 283 void printT55xx(const char *demodStr){
 284
 285         uint32_t blockData = 0;
 286         uint8_t bits[MAX_GRAPH_TRACE_LEN] = {0x00};
 287
 288         if ( !DemodBufferLen)
 289                 return;
 290
 291         int i =0;
 292     for (;i<DemodBufferLen;++i)
 293                 bits[i]=DemodBuffer[i];
 294
 295         blockData = PackBits(1, 32, bits);
 296         PrintAndLog("0x%08X  %s [%s]", blockData, sprint_bin(bits+1,32), demodStr );
 297 }
 298
 299 /*
 300 FSK1 / FSK1a
 301 size = fskdemod(dest, size, 32, 0, 8, 10);  // fsk1 RF/32
 302 size = fskdemod(dest, size, 32, 1, 8, 10);  // fsk1a RF/32
 303
 304 FSK2 / FSK2a
 305 size = fskdemod(dest, size, 32, 0, 10, 8);  // fsk2 RF/32
 306 size = fskdemod(dest, size, 32, 1, 10, 8);  // fsk2a RF/32
 307 size = fskdemod(dest, size, 50, 1, 10, 8);  // fsk2a RF/50
 308 size = fskdemod(dest, size, 64, 1, 10, 8);  // FSK2a RF/64
 309
 310 PSK1
 311 errCnt = pskRawDemod(bits, &bitlen, 32, 0);
 312 */
 313 int CmdWriteBlk(const char *Cmd)
 314 {
 315         int block = 8; //default to invalid block
 316         int data = 0xFFFFFFFF; //default to blank Block
 317         int password = 0xFFFFFFFF; //default to blank Block 7
 318
 319         char cmdp = param_getchar(Cmd, 0);
 320         if (cmdp == 'h' || cmdp == 'H') {
 321                 usage_t55xx_write();
 322                 return 0;
 323         }
 324
 325         int res = sscanf(Cmd, "%d %x %x",&block, &data, &password);
 326
 327         if ( res < 2 || res > 3) {
 328                 usage_t55xx_write();
 329                 return 1;
 330         }
 331
 332         if (block > 7) {
 333                 PrintAndLog("Block must be between 0 and 7");
 334                 return 1;
 335         }
 336
 337         UsbCommand c = {CMD_T55XX_WRITE_BLOCK, {data, block, 0}};
 338         c.d.asBytes[0] = 0x0;
 339
 340         PrintAndLog("Writing to T55x7");
 341         PrintAndLog("block : %d", block);
 342         PrintAndLog("data  : 0x%08X", data);
 343
 344         //Password mode
 345         if (res == 3) {
 346                 c.arg[2] = password;
 347                 c.d.asBytes[0] = 0x1;
 348                 PrintAndLog("pwd   : 0x%08X", password);
 349         }
 350         SendCommand(&c);
 351         return 0;
 352 }
 353
 354 int CmdReadTrace(const char *Cmd)
 355 {
 356         uint8_t bits[MAX_GRAPH_TRACE_LEN] = {0x00};
 357
 358         char cmdp = param_getchar(Cmd, 0);
 359
 360         if (strlen(Cmd) > 1 || cmdp == 'h' || cmdp == 'H') {
 361                 usage_t55xx_trace();
 362                 return 0;
 363         }
 364
 365         if ( strlen(Cmd)==0){
 366
 367                 UsbCommand c = {CMD_T55XX_READ_TRACE, {0, 0, 0}};
 368                 SendCommand(&c);
 369                 if ( !WaitForResponseTimeout(CMD_ACK,NULL,2500) ) {
 370                         PrintAndLog("command execution time out");
 371                         return 1;
 372                 }
 373                 //darn
 374                 //CmdSamples("12000");
 375         }
 376
 377         size_t bitlen = getFromGraphBuf(bits);
 378         if ( bitlen == 0 )
 379                 return 2;
 380
 381         RepaintGraphWindow();
 382
 383         uint8_t si = 5;
 384         uint32_t bl0     = PackBits(si, 32, bits);
 385         uint32_t bl1     = PackBits(si+32, 32, bits);
 386
 387         uint32_t acl     = PackBits(si,  8, bits); si += 8;
 388         uint32_t mfc     = PackBits(si, 8, bits); si += 8;
 389         uint32_t cid     = PackBits(si, 5, bits); si += 5;
 390         uint32_t icr     = PackBits(si, 3, bits); si += 3;
 391         uint32_t year    = PackBits(si, 4, bits); si += 4;
 392         uint32_t quarter = PackBits(si, 2, bits); si += 2;
 393         uint32_t lotid    = PackBits(si, 12, bits); si += 12;
 394         uint32_t wafer   = PackBits(si, 5, bits); si += 5;
 395         uint32_t dw      = PackBits(si, 15, bits);
 396
 397         PrintAndLog("");
 398         PrintAndLog("-- T55xx Trace Information ----------------------------------");
 399         PrintAndLog("-------------------------------------------------------------");
 400         PrintAndLog(" ACL Allocation class (ISO/IEC 15963-1)  : 0x%02X (%d)", acl, acl);
 401         PrintAndLog(" MFC Manufacturer ID (ISO/IEC 7816-6)    : 0x%02X (%d)", mfc, mfc);
 402         PrintAndLog(" CID                                     : 0x%02X (%d)", cid, cid);
 403         PrintAndLog(" ICR IC Revision                         : %d",icr );
 404         PrintAndLog(" Manufactured");
 405         PrintAndLog("     Year/Quarter : %d/%d",2000+year, quarter );
 406         PrintAndLog("     Lot ID       : %d", lotid );
 407         PrintAndLog("     Wafer number : %d", wafer);
 408         PrintAndLog("     Die Number   : %d", dw);
 409         PrintAndLog("-------------------------------------------------------------");
 410         PrintAndLog(" Raw Data - Page 1");
 411         PrintAndLog("     Block 0  : 0x%08X  %s", bl0, sprint_bin(bits+5,32) );
 412         PrintAndLog("     Block 0  : 0x%08X  %s", bl1, sprint_bin(bits+37,32) );
 413         PrintAndLog("-------------------------------------------------------------");
 414         /*
 415         TRACE - BLOCK O
 416                 Bits    Definition                                                              HEX
 417                 1-8             ACL Allocation class (ISO/IEC 15963-1)  0xE0
 418                 9-16    MFC Manufacturer ID (ISO/IEC 7816-6)    0x15 Atmel Corporation
 419                 17-21   CID                                                                             0x1 = Atmel ATA5577M1  0x2 = Atmel ATA5577M2
 420                 22-24   ICR IC revision
 421                 25-28   YEAR (BCD encoded)                                              9 (= 2009)
 422                 29-30   QUARTER                                                                 1,2,3,4
 423                 31-32   LOT ID
 424
 425         TRACE - BLOCK 1
 426                 1-12    LOT ID
 427                 13-17   Wafer number
 428                 18-32   DW,  die number sequential
 429         */
 430
 431   return 0;
 432 }
 433
 434 int CmdInfo(const char *Cmd){
 435         /*
 436                 Page 0 Block 0 Configuration data.
 437                 Normal mode
 438                 Extended mode
 439         */
 440         char cmdp = param_getchar(Cmd, 0);
 441
 442         if (cmdp == 'h' || cmdp == 'H') {
 443                 return usage_t55xx_info();
 444         } else {
 445                 CmdReadBlk("0");
 446         }
 447
 448         // config
 449
 450         uint8_t bits[LF_BITSSTREAM_LEN] = {0x00};
 451
 452         uint8_t si = 1;
 453         uint32_t bl0      = PackBits(si, 32, bits);
 454
 455         uint32_t safer    = PackBits(si, 4, bits); si += 4;
 456         uint32_t resv     = PackBits(si, 7, bits); si += 7;
 457         uint32_t dbr      = PackBits(si, 3, bits); si += 3;
 458         uint32_t extend   = PackBits(si, 1, bits); si += 1;
 459         uint32_t datamod  = PackBits(si, 5, bits); si += 5;
 460         uint32_t pskcf    = PackBits(si, 2, bits); si += 2;
 461         uint32_t aor      = PackBits(si, 1, bits); si += 1;
 462         uint32_t otp      = PackBits(si, 1, bits); si += 1;
 463         uint32_t maxblk   = PackBits(si, 3, bits); si += 3;
 464         uint32_t pwd      = PackBits(si, 1, bits); si += 1;
 465         uint32_t sst      = PackBits(si, 1, bits); si += 1;
 466         uint32_t fw       = PackBits(si, 1, bits); si += 1;
 467         uint32_t inv      = PackBits(si, 1, bits); si += 1;
 468         uint32_t por      = PackBits(si, 1, bits); si += 1;
 469
 470         PrintAndLog("");
 471         PrintAndLog("-- T55xx Configuration & Tag Information --------------------");
 472         PrintAndLog("-------------------------------------------------------------");
 473         PrintAndLog(" Safer key                 : %s", GetSaferStr(safer));
 474         PrintAndLog(" reserved                  : %d", resv);
 475         PrintAndLog(" Data bit rate             : %s", GetBitRateStr(dbr));
 476         PrintAndLog(" eXtended mode             : %s", (extend) ? "Yes - Warning":"No");
 477         PrintAndLog(" Modulation                : %s", GetModulationStr(datamod));
 478         PrintAndLog(" PSK clock freq            : %d", pskcf);
 479         PrintAndLog(" AOR - Answer on Request   : %s", (aor) ? "Yes":"No");
 480         PrintAndLog(" OTP - One Time Pad        : %s", (otp) ? "Yes - Warning":"No" );
 481         PrintAndLog(" Max block                 : %d", maxblk);
 482         PrintAndLog(" Password mode             : %s", (pwd) ? "Yes":"No");
 483         PrintAndLog(" Sequence Start Terminator : %s", (sst) ? "Yes":"No");
 484         PrintAndLog(" Fast Write                : %s", (fw)  ? "Yes":"No");
 485         PrintAndLog(" Inverse data              : %s", (inv) ? "Yes":"No");
 486         PrintAndLog(" POR-Delay                 : %s", (por) ? "Yes":"No");
 487         PrintAndLog("-------------------------------------------------------------");
 488         PrintAndLog(" Raw Data - Page 0");
 489         PrintAndLog("     Block 0  : 0x%08X  %s", bl0, sprint_bin(bits+5,32) );
 490         PrintAndLog("-------------------------------------------------------------");
 491
 492         return 0;
 493 }
 494
 495 int CmdDump(const char *Cmd){
 496
 497         char s[20] = {0x00};
 498         uint8_t pwd[4] = {0x00};
 499
 500         char cmdp = param_getchar(Cmd, 0);
 501         if ( cmdp == 'h' || cmdp == 'H') {
 502                 usage_t55xx_dump();
 503                 return 0;
 504         }
 505
 506         bool hasPwd = ( strlen(Cmd) > 0);
 507         if ( hasPwd ){
 508                 if (param_gethex(Cmd, 0, pwd, 8)) {
 509                         PrintAndLog("password must include 8 HEX symbols");
 510                         return 1;
 511                 }
 512         }
 513
 514         for ( int i = 0; i <8; ++i){
 515                 memset(s,0,sizeof(s));
 516                 if ( hasPwd ) {
 517                         sprintf(s,"%d %02x%02x%02x%02x", i, pwd[0],pwd[1],pwd[2],pwd[3]);
 518                 } else {
 519                         sprintf(s,"%d", i);
 520                 }
 521                 CmdReadBlk(s);
 522         }
 523         return 0;
 524 }
 525
 526 char * GetBitRateStr(uint32_t id){
 527         static char buf[40];
 528         char *retStr = buf;
 529                 switch (id){
 530                 case 0:
 531                         sprintf(retStr,"%d - RF/8",id);
 532                         break;
 533                 case 1:
 534                         sprintf(retStr,"%d - RF/16",id);
 535                         break;
 536                 case 2:
 537                         sprintf(retStr,"%d - RF/32",id);
 538                         break;
 539                 case 3:
 540                         sprintf(retStr,"%d - RF/40",id);
 541                         break;
 542                 case 4:
 543                         sprintf(retStr,"%d - RF/50",id);
 544                         break;
 545                 case 5:
 546                         sprintf(retStr,"%d - RF/64",id);
 547                         break;
 548                 case 6:
 549                         sprintf(retStr,"%d - RF/100",id);
 550                         break;
 551                 case 7:
 552                         sprintf(retStr,"%d - RF/128",id);
 553                         break;
 554                 default:
 555                         sprintf(retStr,"%d - (Unknown)",id);
 556                         break;
 557                 }
 558
 559         return buf;
 560 }
 561
 562 char * GetSaferStr(uint32_t id){
 563         static char buf[40];
 564         char *retStr = buf;
 565
 566         sprintf(retStr,"%d",id);
 567         if (id == 6) {
 568                 sprintf(retStr,"%d - passwd",id);
 569         }
 570         if (id == 9 ){
 571                 sprintf(retStr,"%d - testmode",id);
 572         }
 573
 574         return buf;
 575 }
 576 char * GetModulationStr( uint32_t id){
 577         static char buf[40];
 578         char *retStr = buf;
 579
 580         switch (id){
 581                 case 0:
 582                         sprintf(retStr,"%d - DIRECT (ASK/NRZ)",id);
 583                         break;
 584                 case 1:
 585                         sprintf(retStr,"%d - PSK 1 phase change when input changes",id);
 586                         break;
 587                 case 2:
 588                         sprintf(retStr,"%d - PSK 2 phase change on bitclk if input high",id);
 589                         break;
 590                 case 3:
 591                         sprintf(retStr,"%d - PSK 3 phase change on rising edge of input",id);
 592                         break;
 593                 case 4:
 594                         sprintf(retStr,"%d - FSK 1 RF/8  RF/5",id);
 595                         break;
 596                 case 5:
 597                         sprintf(retStr,"%d - FSK 2 RF/8  RF/10",id);
 598                         break;
 599                 case 6:
 600                         sprintf(retStr,"%d - FSK 1a RF/5  RF/8",id);
 601                         break;
 602                 case 7:
 603                         sprintf(retStr,"%d - FSK 2a RF/10  RF/8",id);
 604                         break;
 605                 case 8:
 606                         sprintf(retStr,"%d - Manschester",id);
 607                         break;
 608                 case 16:
 609                         sprintf(retStr,"%d - Biphase",id);
 610                         break;
 611                 case 17:
 612                         sprintf(retStr,"%d - Reserved",id);
 613                         break;
 614                 default:
 615                         sprintf(retStr,"0x%02X (Unknown)",id);
 616                         break;
 617                 }
 618         return buf;
 619 }
 620
 621 uint32_t PackBits(uint8_t start, uint8_t len, uint8_t* bits){
 622
 623         int i = start;
 624         int j = len-1;
 625         if (len > 32) {
 626                 return 0;
 627         }
 628         uint32_t tmp = 0;
 629         for (; j >= 0; --j, ++i){
 630                 tmp     |= bits[i] << j;
 631         }
 632         return tmp;
 633 }
 634
 635 static command_t CommandTable[] =
 636 {
 637   {"help",   CmdHelp,           1, "This help"},
 638   {"config", CmdT55xxSetConfig, 1, "Set T55XX config for modulation, inversed data"},
 639   {"read",   CmdReadBlk,        0, "<block> [password] -- Read T55xx block data (page 0) [optional password]"},
 640   {"write",  CmdWriteBlk,       0, "<block> <data> [password] -- Write T55xx block data (page 0) [optional password]"},
 641   {"trace",  CmdReadTrace,      0, "[1] Read T55xx traceability data (page 1/ blk 0-1)"},
 642   {"info",   CmdInfo,           0, "[1] Read T55xx configuration data (page 0/ blk 0)"},
 643   {"dump",   CmdDump,           0, "[password] Dump T55xx card block 0-7. [optional password]"},
 644   {NULL, NULL, 0, NULL}
 645 };
 646
 647 int CmdLFT55XX(const char *Cmd)
 648 {
 649   CmdsParse(CommandTable, Cmd);
 650   return 0;
 651 }
 652
 653 int CmdHelp(const char *Cmd)
 654 {
 655   CmdsHelp(CommandTable);
 656   return 0;
 657 }