git.rot13.org Git - librfid/blob - src/rfid_asic_rc632.c

   1 /* Generic Philips CL RC632 Routines
   2  *
   3  * (C) Harald Welte <laforge@gnumonks.org>
   4  *
   5  */
   6
   7 /*
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License version 2
  10  *  as published by the Free Software Foundation
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include <unistd.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <errno.h>
  26 #include <sys/types.h>
  27
  28 #include <librfid/rfid.h>
  29 #include <librfid/rfid_asic.h>
  30 #include <librfid/rfid_asic_rc632.h>
  31 #include <librfid/rfid_reader_cm5121.h>
  32 #include <librfid/rfid_layer2_iso14443a.h>
  33 #include <librfid/rfid_protocol_mifare_classic.h>
  34
  35 #include "rfid_iso14443_common.h"
  36 #include "rc632.h"
  37 //#include "rc632_14443a.h"
  38
  39
  40 #define RC632_TMO_AUTH1 14000
  41
  42 #define ENTER()         DEBUGP("entering\n")
  43 struct rfid_asic rc632;
  44
  45 /* Register and FIFO Access functions */
  46 static int
  47 rc632_reg_write(struct rfid_asic_handle *handle,
  48                 u_int8_t reg,
  49                 u_int8_t val)
  50 {
  51         return handle->rath->rat->priv.rc632.fn.reg_write(handle->rath, reg, val);
  52 }
  53
  54 static int
  55 rc632_reg_read(struct rfid_asic_handle *handle,
  56                u_int8_t reg,
  57                u_int8_t *val)
  58 {
  59         return handle->rath->rat->priv.rc632.fn.reg_read(handle->rath, reg, val);
  60 }
  61
  62 static int
  63 rc632_fifo_write(struct rfid_asic_handle *handle,
  64                  u_int8_t len,
  65                  const u_int8_t *buf,
  66                  u_int8_t flags)
  67 {
  68         return handle->rath->rat->priv.rc632.fn.fifo_write(handle->rath,
  69                                                            len, buf, flags);
  70 }
  71
  72 static int
  73 rc632_fifo_read(struct rfid_asic_handle *handle,
  74                 u_int8_t len,
  75                 u_int8_t *buf)
  76 {
  77         return handle->rath->rat->priv.rc632.fn.fifo_read(handle->rath, len, buf);
  78 }
  79
  80
  81 static int
  82 rc632_set_bits(struct rfid_asic_handle *handle,
  83                 u_int8_t reg,
  84                 u_int8_t val)
  85 {
  86         int ret;
  87         u_int8_t tmp;
  88
  89         ret = rc632_reg_read(handle, reg, &tmp);
  90         if (ret < 0)
  91                 return -1;
  92
  93         /* if bits are already set, no need to set them again */
  94         if ((tmp & val) == val)
  95                 return 0;
  96
  97         return rc632_reg_write(handle, reg, (tmp|val)&0xff);
  98 }
  99 static int
 100 rc632_set_bit_mask(struct rfid_asic_handle *handle,
 101                    u_int8_t reg, u_int8_t mask, u_int8_t val)
 102 {
 103         int ret;
 104         u_int8_t tmp;
 105
 106         ret = rc632_reg_read(handle, reg, &tmp);
 107         if (ret < 0)
 108                 return ret;
 109
 110         /* if bits are already like we want them, abort */
 111         if ((tmp & mask) == val)
 112                 return 0;
 113
 114         return rc632_reg_write(handle, reg, (tmp & ~mask)|(val & mask));
 115 }
 116
 117 static int
 118 rc632_clear_bits(struct rfid_asic_handle *handle,
 119                  u_int8_t reg,
 120                  u_int8_t val)
 121 {
 122         int ret;
 123         u_int8_t tmp;
 124
 125         ret = rc632_reg_read(handle, reg, &tmp);
 126         if (ret < 0) {
 127                 DEBUGP("error during reg_read(%p, %d):%d\n",
 128                         handle, reg, ret);
 129                 return -1;
 130         }
 131         /* if bits are already cleared, no need to clear them again */
 132         if ((tmp & val) == 0)
 133                 return 0;
 134
 135         return rc632_reg_write(handle, reg, (tmp & ~val)&0xff);
 136 }
 137
 138 static int
 139 rc632_turn_on_rf(struct rfid_asic_handle *handle)
 140 {
 141         ENTER();
 142         return rc632_set_bits(handle, RC632_REG_TX_CONTROL, 0x03);
 143 }
 144
 145 static int
 146 rc632_turn_off_rf(struct rfid_asic_handle *handle)
 147 {
 148         ENTER();
 149         return rc632_clear_bits(handle, RC632_REG_TX_CONTROL, 0x03);
 150 }
 151
 152 static int
 153 rc632_power_up(struct rfid_asic_handle *handle)
 154 {
 155         ENTER();
 156         return rc632_clear_bits(handle, RC632_REG_CONTROL,
 157                                 RC632_CONTROL_POWERDOWN);
 158 }
 159
 160 static int
 161 rc632_power_down(struct rfid_asic_handle *handle)
 162 {
 163         return rc632_set_bits(handle, RC632_REG_CONTROL,
 164                               RC632_CONTROL_POWERDOWN);
 165 }
 166
 167 /* Stupid RC623 implementations don't evaluate interrupts but poll the
 168  * command register for "status idle" */
 169 static int
 170 rc632_wait_idle(struct rfid_asic_handle *handle, u_int64_t timeout)
 171 {
 172         u_int8_t cmd = 0xff;
 173         int ret, cycles = 0;
 174 #define USLEEP_PER_CYCLE        128
 175
 176         while (cmd != 0) {
 177                 ret = rc632_reg_read(handle, RC632_REG_COMMAND, &cmd);
 178                 if (ret < 0)
 179                         return ret;
 180
 181                 if (cmd == 0) {
 182                         /* FIXME: read second time ?? */
 183                         return 0;
 184                 }
 185
 186                 {
 187                         u_int8_t foo;
 188                         rc632_reg_read(handle, RC632_REG_PRIMARY_STATUS, &foo);
 189                         if (foo & 0x04)
 190                                 rc632_reg_read(handle, RC632_REG_ERROR_FLAG, &foo);
 191                 }
 192
 193                 /* Abort after some timeout */
 194                 if (cycles > timeout*100/USLEEP_PER_CYCLE) {
 195                         return -ETIMEDOUT;
 196                 }
 197
 198                 cycles++;
 199                 usleep(USLEEP_PER_CYCLE);
 200         }
 201
 202         return 0;
 203 }
 204
 205 static int
 206 rc632_transmit(struct rfid_asic_handle *handle,
 207                 const u_int8_t *buf,
 208                 u_int8_t len,
 209                 u_int64_t timeout)
 210 {
 211         int ret, cur_len;
 212         const u_int8_t *cur_buf = buf;
 213
 214         if (len > 64)
 215                 cur_len = 64;
 216         else
 217                 cur_len = len;
 218
 219         do {
 220                 ret = rc632_fifo_write(handle, cur_len, cur_buf, 0x03);
 221                 if (ret < 0)
 222                         return ret;
 223
 224                 if (cur_buf == buf)  {
 225                         /* only start transmit first time */
 226                         ret = rc632_reg_write(handle, RC632_REG_COMMAND,
 227                                               RC632_CMD_TRANSMIT);
 228                         if (ret < 0)
 229                                 return ret;
 230                 }
 231
 232                 cur_buf += cur_len;
 233                 if (cur_buf < buf + len) {
 234                         cur_len = buf - cur_buf;
 235                         if (cur_len > 64)
 236                                 cur_len = 64;
 237                 } else
 238                         cur_len = 0;
 239
 240         } while (cur_len);
 241
 242         return rc632_wait_idle(handle, timeout);
 243 }
 244
 245 static int
 246 tcl_toggle_pcb(struct rfid_asic_handle *handle)
 247 {
 248         // FIXME: toggle something between 0x0a and 0x0b
 249         return 0;
 250 }
 251
 252 static int
 253 rc632_transceive(struct rfid_asic_handle *handle,
 254                  const u_int8_t *tx_buf,
 255                  u_int8_t tx_len,
 256                  u_int8_t *rx_buf,
 257                  u_int8_t *rx_len,
 258                  unsigned int timer,
 259                  unsigned int toggle)
 260 {
 261         int ret, cur_tx_len;
 262         const u_int8_t *cur_tx_buf = tx_buf;
 263
 264         if (tx_len > 64)
 265                 cur_tx_len = 64;
 266         else
 267                 cur_tx_len = tx_len;
 268
 269         do {
 270                 ret = rc632_fifo_write(handle, tx_len, tx_buf, 0x03);
 271                 if (ret < 0)
 272                         return ret;
 273
 274                 if (cur_tx_buf == tx_buf) {
 275                         ret = rc632_reg_write(handle, RC632_REG_COMMAND,
 276                                               RC632_CMD_TRANSCEIVE);
 277                         if (ret < 0)
 278                                 return ret;
 279                 }
 280
 281                 cur_tx_buf += cur_tx_len;
 282                 if (cur_tx_buf < tx_buf + tx_len) {
 283                         u_int8_t fifo_fill;
 284                         ret = rc632_reg_read(handle, RC632_REG_FIFO_LENGTH,
 285                                              &fifo_fill);
 286                         if (ret < 0)
 287                                 return ret;
 288                         cur_tx_len = 64 - fifo_fill;
 289                         printf("refilling tx fifo with %u bytes\n", cur_tx_len);
 290                 } else
 291                         cur_tx_len = 0;
 292
 293         } while (cur_tx_len);
 294
 295         if (toggle == 1)
 296                 tcl_toggle_pcb(handle);
 297
 298         ret = rc632_wait_idle(handle, timer);
 299         if (ret < 0)
 300                 return ret;
 301
 302         ret = rc632_reg_read(handle, RC632_REG_FIFO_LENGTH, rx_len);
 303         if (ret < 0)
 304                 return ret;
 305
 306         if (*rx_len == 0) {
 307                 u_int8_t tmp;
 308
 309                 DEBUGP("rx_len == 0\n");
 310
 311                 rc632_reg_read(handle, RC632_REG_ERROR_FLAG, &tmp);
 312                 rc632_reg_read(handle, RC632_REG_CHANNEL_REDUNDANCY, &tmp);
 313
 314                 return -1;
 315         }
 316
 317         return rc632_fifo_read(handle, *rx_len, rx_buf);
 318 }
 319
 320 static int
 321 rc632_read_eeprom(struct rfid_asic_handle *handle)
 322 {
 323         u_int8_t recvbuf[60];
 324         u_int8_t sndbuf[3];
 325         int ret;
 326
 327         sndbuf[0] = 0x00;
 328         sndbuf[1] = 0x00;
 329         sndbuf[2] = 0x3c;
 330
 331         ret = rc632_fifo_write(handle, 3, sndbuf, 0x03);
 332         if (ret < 0)
 333                 return ret;
 334
 335         ret = rc632_reg_write(handle, RC632_REG_COMMAND, RC632_CMD_READ_E2);
 336         if (ret < 0)
 337                 return ret;
 338
 339         usleep(20000);
 340
 341         ret = rc632_fifo_read(handle, sizeof(recvbuf), recvbuf);
 342         if (ret < 0)
 343                 return ret;
 344
 345         // FIXME: do something with eeprom contents
 346         return ret;
 347 }
 348
 349 static int
 350 rc632_calc_crc16_from(struct rfid_asic_handle *handle)
 351 {
 352         u_int8_t sndbuf[2] = { 0x01, 0x02 };
 353         u_int8_t crc_lsb = 0x00 , crc_msb = 0x00;
 354         int ret;
 355
 356         ret = rc632_reg_write(handle, RC632_REG_CRC_PRESET_LSB, 0x12);
 357         if (ret < 0)
 358                 return ret;
 359
 360         ret = rc632_reg_write(handle, RC632_REG_CRC_PRESET_MSB, 0xe0);
 361         if (ret < 0)
 362                 return ret;
 363
 364         ret = rc632_fifo_write(handle, sizeof(sndbuf), sndbuf, 3);
 365         if (ret < 0)
 366                 return ret;
 367
 368         ret = rc632_reg_write(handle, RC632_REG_COMMAND, RC632_CMD_CALC_CRC);
 369         if (ret < 0)
 370                 return ret;
 371
 372         usleep(10000);  // FIXME: no checking for cmd completion?
 373
 374         ret = rc632_reg_read(handle, RC632_REG_CRC_RESULT_LSB, &crc_lsb);
 375         if (ret < 0)
 376                 return ret;
 377
 378         ret = rc632_reg_read(handle, RC632_REG_CRC_RESULT_MSB, &crc_msb);
 379         if (ret < 0)
 380                 return ret;
 381
 382         // FIXME: what to do with crc result?
 383         return ret;
 384 }
 385
 386
 387 int
 388 rc632_register_dump(struct rfid_asic_handle *handle, u_int8_t *buf)
 389 {
 390         int ret;
 391         u_int8_t i;
 392
 393         for (i = 0; i <= 0x3f; i++) {
 394                 ret = rc632_reg_read(handle, i, &buf[i]);
 395                 // do we want error checks?
 396         }
 397         return 0;
 398 }
 399
 400
 401
 402 /* generic FIFO access functions (if no more efficient ones provided by
 403  * transport driver) */
 404
 405 static int
 406 generic_fifo_write()
 407 {
 408         // FIXME: implementation (not needed for CM 5121)
 409         return -1;
 410 }
 411
 412 static int
 413 generic_fifo_read()
 414 {
 415         // FIXME: implementation (not neded for CM 5121)
 416         return -1;
 417 }
 418
 419 static int
 420 rc632_init(struct rfid_asic_handle *ah)
 421 {
 422         int ret;
 423
 424         /* switch off rf (make sure PICCs are reset at init time) */
 425         ret = rc632_power_down(ah);
 426         if (ret < 0)
 427                 return ret;
 428
 429         usleep(10000);
 430
 431         /* switch on rf */
 432         ret = rc632_power_up(ah);
 433         if (ret < 0)
 434                 return ret;
 435
 436         /* disable register paging */
 437         ret = rc632_reg_write(ah, 0x00, 0x00);
 438         if (ret < 0)
 439                 return ret;
 440
 441         /* set some sane default values */
 442         ret = rc632_reg_write(ah, 0x11, 0x5b);
 443         if (ret < 0)
 444                 return ret;
 445
 446         /* switch on rf */
 447         ret = rc632_turn_on_rf(ah);
 448         if (ret < 0)
 449                 return ret;
 450
 451         return 0;
 452 }
 453
 454 static int
 455 rc632_fini(struct rfid_asic_handle *ah)
 456 {
 457         int ret;
 458
 459         /* switch off rf */
 460         ret = rc632_turn_off_rf(ah);
 461         if (ret < 0)
 462                 return ret;
 463
 464         ret = rc632_power_down(ah);
 465         if (ret < 0)
 466                 return ret;
 467
 468         return 0;
 469 }
 470
 471 struct rfid_asic_handle *
 472 rc632_open(struct rfid_asic_transport_handle *th)
 473 {
 474         struct rfid_asic_handle *h;
 475
 476         h = malloc(sizeof(*h));
 477         if (!h)
 478                 return NULL;
 479         memset(h, 0, sizeof(*h));
 480
 481         h->asic = &rc632;
 482         h->rath = th;
 483         h->fc = h->asic->fc;
 484         h->mtu = h->mru = 40; /* FIXME */
 485
 486         if (rc632_init(h) < 0) {
 487                 free(h);
 488                 return NULL;
 489         }
 490
 491         return h;
 492 }
 493
 494 void
 495 rc632_close(struct rfid_asic_handle *h)
 496 {
 497         rc632_fini(h);
 498         free(h);
 499 }
 500
 501
 502 /*
 503  * Philips CL RC632 primitives for ISO 14443-A compliant PICC's
 504  *
 505  * (C) 2005 by Harald Welte <laforge@gnumonks.org>
 506  *
 507  */
 508
 509 static int
 510 rc632_iso14443a_init(struct rfid_asic_handle *handle)
 511 {
 512         int ret;
 513
 514         // FIXME: some fifo work (drain fifo?)
 515
 516         /* flush fifo (our way) */
 517         ret = rc632_reg_write(handle, RC632_REG_CONTROL, 0x01);
 518
 519         ret = rc632_reg_write(handle, RC632_REG_TX_CONTROL,
 520                         (RC632_TXCTRL_TX1_RF_EN |
 521                          RC632_TXCTRL_TX2_RF_EN |
 522                          RC632_TXCTRL_TX2_INV |
 523                          RC632_TXCTRL_FORCE_100_ASK |
 524                          RC632_TXCTRL_MOD_SRC_INT));
 525         if (ret < 0)
 526                 return ret;
 527
 528         ret = rc632_reg_write(handle, RC632_REG_CW_CONDUCTANCE,
 529                                 CM5121_CW_CONDUCTANCE);
 530         if (ret < 0)
 531                 return ret;
 532
 533         /* Since FORCE_100_ASK is set (cf mc073930.pdf), this line may be left out? */
 534         ret = rc632_reg_write(handle, RC632_REG_MOD_CONDUCTANCE,
 535                                 CM5121_MOD_CONDUCTANCE);
 536         if (ret < 0)
 537                 return ret;
 538
 539         ret = rc632_reg_write(handle, RC632_REG_CODER_CONTROL,
 540                                 (RC632_CDRCTRL_TXCD_14443A |
 541                                  RC632_CDRCTRL_RATE_106K));
 542         if (ret < 0)
 543                 return ret;
 544
 545         ret = rc632_reg_write(handle, RC632_REG_MOD_WIDTH, 0x13);
 546         if (ret < 0)
 547                 return ret;
 548
 549         ret = rc632_reg_write(handle, RC632_REG_MOD_WIDTH_SOF, 0x3f);
 550         if (ret < 0)
 551                 return ret;
 552
 553         ret = rc632_reg_write(handle, RC632_REG_TYPE_B_FRAMING, 0x00);
 554         if (ret < 0)
 555                 return ret;
 556
 557         ret = rc632_reg_write(handle, RC632_REG_RX_CONTROL1,
 558                               (RC632_RXCTRL1_GAIN_35DB |
 559                                RC632_RXCTRL1_ISO14443 |
 560                                RC632_RXCTRL1_SUBCP_8));
 561         if (ret < 0)
 562                 return ret;
 563
 564         ret = rc632_reg_write(handle, RC632_REG_DECODER_CONTROL,
 565                               (RC632_DECCTRL_MANCHESTER |
 566                                RC632_DECCTRL_RXFR_14443A));
 567         if (ret < 0)
 568                 return ret;
 569
 570         ret = rc632_reg_write(handle, RC632_REG_BIT_PHASE,
 571                                 CM5121_14443A_BITPHASE);
 572         if (ret < 0)
 573                 return ret;
 574
 575         ret = rc632_reg_write(handle, RC632_REG_RX_THRESHOLD,
 576                                 CM5121_14443A_THRESHOLD);
 577         if (ret < 0)
 578                 return ret;
 579
 580         ret = rc632_reg_write(handle, RC632_REG_BPSK_DEM_CONTROL, 0x00);
 581         if (ret < 0)
 582                 return ret;
 583
 584         ret = rc632_reg_write(handle, RC632_REG_RX_CONTROL2,
 585                               (RC632_RXCTRL2_DECSRC_INT |
 586                                RC632_RXCTRL2_CLK_Q));
 587         if (ret < 0)
 588                 return ret;
 589
 590         /* Omnikey proprietary driver has 0x03, but 0x06 is the default reset value ?!? */
 591         ret = rc632_reg_write(handle, RC632_REG_RX_WAIT, 0x06);
 592         if (ret < 0)
 593                 return ret;
 594
 595         ret = rc632_reg_write(handle, RC632_REG_CHANNEL_REDUNDANCY,
 596                               (RC632_CR_PARITY_ENABLE |
 597                                RC632_CR_PARITY_ODD));
 598         if (ret < 0)
 599                 return ret;
 600
 601         ret = rc632_reg_write(handle, RC632_REG_CRC_PRESET_LSB, 0x63);
 602         if (ret < 0)
 603                 return ret;
 604
 605         ret = rc632_reg_write(handle, RC632_REG_CRC_PRESET_MSB, 0x63);
 606         if (ret < 0)
 607                 return ret;
 608
 609         return 0;
 610 }
 611
 612 static int
 613 rc632_iso14443a_fini(struct iso14443a_handle *handle_14443)
 614 {
 615
 616 #if 0
 617         ret = rc632_turn_off_rf(handle);
 618         if (ret < 0)
 619                 return ret;
 620 #endif
 621
 622
 623         return 0;
 624 }
 625
 626
 627 /* issue a 14443-3 A PCD -> PICC command in a short frame, such as REQA, WUPA */
 628 static int
 629 rc632_iso14443a_transceive_sf(struct rfid_asic_handle *handle,
 630                                 u_int8_t cmd,
 631                                 struct iso14443a_atqa *atqa)
 632 {
 633         int ret;
 634         u_int8_t tx_buf[1];
 635         u_int8_t rx_len = 2;
 636
 637         memset(atqa, 0, sizeof(atqa));
 638
 639         tx_buf[0] = cmd;
 640
 641         /* transfer only 7 bits of last byte in frame */
 642         ret = rc632_reg_write(handle, RC632_REG_BIT_FRAMING, 0x07);
 643         if (ret < 0)
 644                 return ret;
 645
 646         ret = rc632_clear_bits(handle, RC632_REG_CONTROL,
 647                                 RC632_CONTROL_CRYPTO1_ON);
 648         if (ret < 0)
 649                 return ret;
 650
 651 #if 0
 652         ret = rc632_reg_write(handle, RC632_REG_CHANNEL_REDUNDANCY,
 653                                 (RC632_CR_PARITY_ENABLE |
 654                                  RC632_CR_PARITY_ODD));
 655 #else
 656         ret = rc632_clear_bits(handle, RC632_REG_CHANNEL_REDUNDANCY,
 657                                 RC632_CR_RX_CRC_ENABLE|RC632_CR_TX_CRC_ENABLE);
 658
 659 #endif
 660         if (ret < 0)
 661                 return ret;
 662
 663         ret = rc632_transceive(handle, tx_buf, sizeof(tx_buf),
 664                                 (u_int8_t *)atqa, &rx_len, 0x32, 0);
 665         if (ret < 0) {
 666                 DEBUGP("error during rc632_transceive()\n");
 667                 return ret;
 668         }
 669
 670         /* switch back to normal 8bit last byte */
 671         ret = rc632_reg_write(handle, RC632_REG_BIT_FRAMING, 0x00);
 672         if (ret < 0)
 673                 return ret;
 674
 675         if (rx_len != 2) {
 676                 DEBUGP("rx_len(%d) != 2\n", rx_len);
 677                 return -1;
 678         }
 679
 680         return 0;
 681 }
 682
 683 /* transceive regular frame */
 684 static int
 685 rc632_iso14443ab_transceive(struct rfid_asic_handle *handle,
 686                            unsigned int frametype,
 687                            const u_int8_t *tx_buf, unsigned int tx_len,
 688                            u_int8_t *rx_buf, unsigned int *rx_len,
 689                            u_int64_t timeout, unsigned int flags)
 690 {
 691         int ret;
 692         u_int8_t rxl = *rx_len & 0xff;
 693         u_int8_t channel_red;
 694
 695         memset(rx_buf, 0, *rx_len);
 696
 697         switch (frametype) {
 698         case RFID_14443A_FRAME_REGULAR:
 699         case RFID_MIFARE_FRAME:
 700                 channel_red = RC632_CR_RX_CRC_ENABLE|RC632_CR_TX_CRC_ENABLE
 701                                 |RC632_CR_PARITY_ENABLE|RC632_CR_PARITY_ODD;
 702                 break;
 703         case RFID_14443B_FRAME_REGULAR:
 704                 channel_red = RC632_CR_RX_CRC_ENABLE|RC632_CR_TX_CRC_ENABLE
 705                                 |RC632_CR_CRC3309;
 706                 break;
 707 #if 0
 708         case RFID_MIFARE_FRAME:
 709                 channel_red = RC632_CR_PARITY_ENABLE|RC632_CR_PARITY_ODD;
 710                 break;
 711 #endif
 712         default:
 713                 return -EINVAL;
 714                 break;
 715         }
 716         ret = rc632_reg_write(handle, RC632_REG_CHANNEL_REDUNDANCY,
 717                               channel_red);
 718         if (ret < 0)
 719                 return ret;
 720
 721         ret = rc632_transceive(handle, tx_buf, tx_len, rx_buf, &rxl, 0x32, 0);
 722         *rx_len = rxl;
 723         if (ret < 0)
 724                 return ret;
 725
 726
 727         return 0;
 728 }
 729
 730 /* transceive anti collission bitframe */
 731 static int
 732 rc632_iso14443a_transceive_acf(struct rfid_asic_handle *handle,
 733                                 struct iso14443a_anticol_cmd *acf,
 734                                 unsigned int *bit_of_col)
 735 {
 736         int ret;
 737         u_int8_t rx_buf[64];
 738         u_int8_t rx_len = sizeof(rx_buf);
 739         u_int8_t rx_align = 0, tx_last_bits, tx_bytes;
 740         u_int8_t boc;
 741         u_int8_t error_flag;
 742         *bit_of_col = ISO14443A_BITOFCOL_NONE;
 743         memset(rx_buf, 0, sizeof(rx_buf));
 744
 745         /* disable mifare cryto */
 746         ret = rc632_clear_bits(handle, RC632_REG_CONTROL,
 747                                 RC632_CONTROL_CRYPTO1_ON);
 748         if (ret < 0)
 749                 return ret;
 750
 751         /* disable CRC summing */
 752 #if 0
 753         ret = rc632_reg_write(handle, RC632_REG_CHANNEL_REDUNDANCY,
 754                                 (RC632_CR_PARITY_ENABLE |
 755                                  RC632_CR_PARITY_ODD));
 756 #else
 757         ret = rc632_clear_bits(handle, RC632_REG_CHANNEL_REDUNDANCY,
 758                                 RC632_CR_TX_CRC_ENABLE|RC632_CR_TX_CRC_ENABLE);
 759 #endif
 760         if (ret < 0)
 761                 return ret;
 762
 763         tx_last_bits = acf->nvb & 0x0f; /* lower nibble indicates bits */
 764         tx_bytes = acf->nvb >> 4;
 765         if (tx_last_bits) {
 766                 tx_bytes++;
 767                 rx_align = (tx_last_bits+1) % 8;/* rx frame complements tx */
 768         }
 769
 770         //rx_align = 8 - tx_last_bits;/* rx frame complements tx */
 771
 772         /* set RxAlign and TxLastBits*/
 773         ret = rc632_reg_write(handle, RC632_REG_BIT_FRAMING,
 774                                 (rx_align << 4) | (tx_last_bits));
 775         if (ret < 0)
 776                 return ret;
 777
 778         ret = rc632_transceive(handle, (u_int8_t *)acf, tx_bytes,
 779                                 rx_buf, &rx_len, 0x32, 0);
 780         if (ret < 0)
 781                 return ret;
 782
 783         /* bitwise-OR the two halves of the split byte */
 784         acf->uid_bits[tx_bytes-2] = (
 785                   (acf->uid_bits[tx_bytes-2] & (0xff >> (8-tx_last_bits)))
 786                 | rx_buf[0]);
 787         /* copy the rest */
 788         memcpy(&acf->uid_bits[tx_bytes+1-2], &rx_buf[1], rx_len-1);
 789
 790         /* determine whether there was a collission */
 791         ret = rc632_reg_read(handle, RC632_REG_ERROR_FLAG, &error_flag);
 792         if (ret < 0)
 793                 return ret;
 794
 795         if (error_flag & RC632_ERR_FLAG_COL_ERR) {
 796                 /* retrieve bit of collission */
 797                 ret = rc632_reg_read(handle, RC632_REG_COLL_POS, &boc);
 798                 if (ret < 0)
 799                         return ret;
 800
 801                 /* bit of collission relative to start of part 1 of
 802                  * anticollision frame (!) */
 803                 *bit_of_col = 2*8 + boc;
 804         }
 805
 806         return 0;
 807 }
 808
 809 enum rc632_rate {
 810         RC632_RATE_106  = 0x00,
 811         RC632_RATE_212  = 0x01,
 812         RC632_RATE_424  = 0x02,
 813         RC632_RATE_848  = 0x03,
 814 };
 815
 816 struct rx_config {
 817         u_int8_t        subc_pulses;
 818         u_int8_t        rx_coding;
 819         u_int8_t        rx_threshold;
 820         u_int8_t        bpsk_dem_ctrl;
 821 };
 822
 823 struct tx_config {
 824         u_int8_t        rate;
 825         u_int8_t        mod_width;
 826 };
 827
 828 static struct rx_config rx_configs[] = {
 829         {
 830                 .subc_pulses    = RC632_RXCTRL1_SUBCP_8,
 831                 .rx_coding      = RC632_DECCTRL_MANCHESTER,
 832                 .rx_threshold   = 0x88,
 833                 .bpsk_dem_ctrl  = 0x00,
 834         },
 835         {
 836                 .subc_pulses    = RC632_RXCTRL1_SUBCP_4,
 837                 .rx_coding      = RC632_DECCTRL_BPSK,
 838                 .rx_threshold   = 0x50,
 839                 .bpsk_dem_ctrl  = 0x0c,
 840         },
 841         {
 842                 .subc_pulses    = RC632_RXCTRL1_SUBCP_2,
 843                 .rx_coding      = RC632_DECCTRL_BPSK,
 844                 .rx_threshold   = 0x50,
 845                 .bpsk_dem_ctrl  = 0x0c,
 846         },
 847         {
 848                 .subc_pulses    = RC632_RXCTRL1_SUBCP_1,
 849                 .rx_coding      = RC632_DECCTRL_BPSK,
 850                 .rx_threshold   = 0x50,
 851                 .bpsk_dem_ctrl  = 0x0c,
 852         },
 853 };
 854
 855 static struct tx_config tx_configs[] = {
 856         {
 857                 .rate           = RC632_CDRCTRL_RATE_106K,
 858                 .mod_width      = 0x13,
 859         },
 860         {
 861                 .rate           = RC632_CDRCTRL_RATE_212K,
 862                 .mod_width      = 0x07,
 863         },
 864         {
 865                 .rate           = RC632_CDRCTRL_RATE_424K,
 866                 .mod_width      = 0x03,
 867         },
 868         {
 869                 .rate           = RC632_CDRCTRL_RATE_848K,
 870                 .mod_width      = 0x01,
 871         },
 872 };
 873
 874 static int rc632_iso14443a_set_speed(struct rfid_asic_handle *handle,
 875                                      unsigned int tx,
 876                                      u_int8_t rate)
 877 {
 878         int rc;
 879         u_int8_t reg;
 880
 881
 882         if (!tx) {
 883                 /* Rx */
 884                 if (rate > ARRAY_SIZE(rx_configs))
 885                         return -EINVAL;
 886
 887                 rc = rc632_set_bit_mask(handle, RC632_REG_RX_CONTROL1,
 888                                         RC632_RXCTRL1_SUBCP_MASK,
 889                                         rx_configs[rate].subc_pulses);
 890                 if (rc < 0)
 891                         return rc;
 892
 893                 rc = rc632_set_bit_mask(handle, RC632_REG_DECODER_CONTROL,
 894                                         RC632_DECCTRL_BPSK,
 895                                         rx_configs[rate].rx_coding);
 896                 if (rc < 0)
 897                         return rc;
 898
 899                 rc = rc632_reg_write(handle, RC632_REG_RX_THRESHOLD,
 900                                         rx_configs[rate].rx_threshold);
 901                 if (rc < 0)
 902                         return rc;
 903
 904                 if (rx_configs[rate].rx_coding == RC632_DECCTRL_BPSK) {
 905                         rc = rc632_reg_write(handle,
 906                                              RC632_REG_BPSK_DEM_CONTROL,
 907                                              rx_configs[rate].bpsk_dem_ctrl);
 908                         if (rc < 0)
 909                                 return rc;
 910                 }
 911         } else {
 912                 /* Tx */
 913                 if (rate > ARRAY_SIZE(tx_configs))
 914                         return -EINVAL;
 915
 916                 rc = rc632_set_bit_mask(handle, RC632_REG_CODER_CONTROL,
 917                                         RC632_CDRCTRL_RATE_MASK,
 918                                         tx_configs[rate].rate);
 919                 if (rc < 0)
 920                         return rc;
 921
 922                 rc = rc632_reg_write(handle, RC632_REG_MOD_WIDTH,
 923                                      tx_configs[rate].mod_width);
 924                 if (rc < 0)
 925                         return rc;
 926         }
 927
 928         return 0;
 929 }
 930
 931 static int rc632_iso14443b_init(struct rfid_asic_handle *handle)
 932 {
 933         int ret;
 934
 935         // FIXME: some FIFO work
 936
 937         /* flush fifo (our way) */
 938         ret = rc632_reg_write(handle, RC632_REG_CONTROL, 0x01);
 939         if (ret < 0)
 940                 return ret;
 941
 942         ret = rc632_reg_write(handle, RC632_REG_TX_CONTROL,
 943                         (RC632_TXCTRL_TX1_RF_EN |
 944                          RC632_TXCTRL_TX2_RF_EN |
 945                          RC632_TXCTRL_TX2_INV |
 946                          RC632_TXCTRL_MOD_SRC_INT));
 947         if (ret < 0)
 948                 return ret;
 949
 950         ret = rc632_reg_write(handle, RC632_REG_CW_CONDUCTANCE, 0x3f);
 951         if (ret < 0)
 952                 return ret;
 953
 954         ret = rc632_reg_write(handle, RC632_REG_MOD_CONDUCTANCE, 0x04);
 955         if (ret < 0)
 956                 return ret;
 957
 958         ret = rc632_reg_write(handle, RC632_REG_CODER_CONTROL,
 959                               (RC632_CDRCTRL_TXCD_NRZ |
 960                                RC632_CDRCTRL_RATE_14443B));
 961         if (ret < 0)
 962                 return ret;
 963
 964         ret = rc632_reg_write(handle, RC632_REG_MOD_WIDTH, 0x13);
 965         if (ret < 0)
 966                 return ret;
 967
 968         ret = rc632_reg_write(handle, RC632_REG_MOD_WIDTH_SOF, 0x3f);
 969         if (ret < 0)
 970                 return ret;
 971
 972         ret = rc632_reg_write(handle, RC632_REG_TYPE_B_FRAMING,
 973                               (RC632_TBFRAMING_SOF_11L_3H |
 974                                (6 << RC632_TBFRAMING_SPACE_SHIFT) |
 975                                RC632_TBFRAMING_EOF_11));
 976         if (ret < 0)
 977                 return ret;
 978
 979         ret = rc632_reg_write(handle, RC632_REG_RX_CONTROL1,
 980                               (RC632_RXCTRL1_GAIN_35DB |
 981                                RC632_RXCTRL1_ISO14443 |
 982                                RC632_RXCTRL1_SUBCP_8));
 983         if (ret < 0)
 984                 return ret;
 985
 986         ret = rc632_reg_write(handle, RC632_REG_DECODER_CONTROL,
 987                               (RC632_DECCTRL_BPSK |
 988                                RC632_DECCTRL_RXFR_14443B));
 989         if (ret < 0)
 990                 return ret;
 991
 992         ret = rc632_reg_write(handle, RC632_REG_BIT_PHASE,
 993                                 CM5121_14443B_BITPHASE);
 994         if (ret < 0)
 995                 return ret;
 996
 997         ret = rc632_reg_write(handle, RC632_REG_RX_THRESHOLD,
 998                                 CM5121_14443B_THRESHOLD);
 999         if (ret < 0)
1000                 return ret;
1001
1002         ret = rc632_reg_write(handle, RC632_REG_BPSK_DEM_CONTROL,
1003                               ((0x2 & RC632_BPSKD_TAUB_MASK)<<RC632_BPSKD_TAUB_SHIFT |
1004                                (0x3 & RC632_BPSKD_TAUD_MASK)<<RC632_BPSKD_TAUD_SHIFT |
1005                                RC632_BPSKD_FILTER_AMP_DETECT |
1006                                RC632_BPSKD_NO_RX_EOF |
1007                                RC632_BPSKD_NO_RX_EGT));
1008         if (ret < 0)
1009                 return ret;
1010
1011         ret = rc632_reg_write(handle, RC632_REG_RX_CONTROL2,
1012                               (RC632_RXCTRL2_AUTO_PD |
1013                                RC632_RXCTRL2_DECSRC_INT));
1014         if (ret < 0)
1015                 return ret;
1016
1017         ret = rc632_reg_write(handle, RC632_REG_RX_WAIT, 0x03);
1018         if (ret < 0)
1019                 return ret;
1020
1021         ret = rc632_reg_write(handle, RC632_REG_CHANNEL_REDUNDANCY,
1022                               (RC632_CR_TX_CRC_ENABLE |
1023                                RC632_CR_RX_CRC_ENABLE |
1024                                RC632_CR_CRC3309));
1025         if (ret < 0)
1026                 return ret;
1027
1028         ret = rc632_reg_write(handle, RC632_REG_CRC_PRESET_LSB, 0xff);
1029         if (ret < 0)
1030                 return ret;
1031
1032         ret = rc632_reg_write(handle, RC632_REG_CRC_PRESET_MSB, 0xff);
1033         if (ret < 0)
1034                 return ret;
1035
1036         return 0;
1037 }
1038
1039 static int
1040 rc632_iso15693_init(struct rfid_asic_handle *h)
1041 {
1042         int ret;
1043
1044         ret = rc632_reg_write(h, RC632_REG_TX_CONTROL,
1045                                                 (RC632_TXCTRL_MOD_SRC_INT |
1046                                                  RC632_TXCTRL_TX2_INV |
1047                                                  RC632_TXCTRL_TX2_RF_EN |
1048                                                  RC632_TXCTRL_TX1_RF_EN));
1049         if (ret < 0)
1050                 return ret;
1051
1052         ret = rc632_reg_write(h, RC632_REG_CW_CONDUCTANCE, 0x3f);
1053         if (ret < 0)
1054                 return ret;
1055
1056         ret = rc632_reg_write(h, RC632_REG_MOD_CONDUCTANCE, 0x03);
1057         if (ret < 0)
1058                 return ret;
1059
1060         ret = rc632_reg_write(h, RC632_REG_CODER_CONTROL,
1061                                                 (RC632_CDRCTRL_RATE_15693 |
1062                                                  0x03)); /* FIXME */
1063         if (ret < 0)
1064                 return ret;
1065
1066         ret = rc632_reg_write(h, RC632_REG_MOD_WIDTH, 0x3f);
1067         if (ret < 0)
1068                 return ret;
1069
1070         ret = rc632_reg_write(h, RC632_REG_MOD_WIDTH_SOF, 0x3f);
1071         if (ret < 0)
1072                 return ret;
1073
1074         ret = rc632_reg_write(h, RC632_REG_TYPE_B_FRAMING, 0x00);
1075         if (ret < 0)
1076                 return ret;
1077
1078         ret = rc632_reg_write(h, RC632_REG_RX_CONTROL1,
1079                                                 (RC632_RXCTRL1_SUBCP_16 |
1080                                                  RC632_RXCTRL1_ISO15693 |
1081                                                  RC632_RXCTRL1_GAIN_35DB));
1082         if (ret < 0)
1083                 return ret;
1084
1085         ret = rc632_reg_write(h, RC632_REG_DECODER_CONTROL,
1086                                                 (RC632_DECCTRL_RXFR_15693 |
1087                                                  RC632_DECCTRL_RX_INVERT));
1088         if (ret < 0)
1089                 return ret;
1090
1091         ret = rc632_reg_write(h, RC632_REG_BIT_PHASE, 0xe0);
1092         if (ret < 0)
1093                 return ret;
1094
1095         ret = rc632_reg_write(h, RC632_REG_RX_THRESHOLD, 0xff);
1096         if (ret < 0)
1097                 return ret;
1098
1099         ret = rc632_reg_write(h, RC632_REG_BPSK_DEM_CONTROL, 0x00);
1100         if (ret < 0)
1101                 return ret;
1102
1103         ret = rc632_reg_write(h, RC632_REG_RX_CONTROL2,
1104                                                 (RC632_RXCTRL2_AUTO_PD |
1105                                                  RC632_RXCTRL2_DECSRC_INT));
1106         if (ret < 0)
1107                 return ret;
1108
1109         ret = rc632_reg_write(h, RC632_REG_CHANNEL_REDUNDANCY,
1110                                                 (RC632_CR_CRC3309 |
1111                                                  RC632_CR_RX_CRC_ENABLE |
1112                                                  RC632_CR_TX_CRC_ENABLE));
1113         if (ret < 0)
1114                 return ret;
1115
1116         ret = rc632_reg_write(h, RC632_REG_CRC_PRESET_LSB, 0xff);
1117         if (ret < 0)
1118                 return ret;
1119
1120         ret = rc632_reg_write(h, RC632_REG_CRC_PRESET_MSB, 0xff);
1121         if (ret < 0)
1122                 return ret;
1123
1124         return 0;
1125 }
1126
1127 static int
1128 rc632_iso15693_icode_init(struct rfid_asic_handle *h)
1129 {
1130         int ret;
1131
1132         ret = rc632_reg_write(h, RC632_REG_TX_CONTROL,
1133                                                 (RC632_TXCTRL_MOD_SRC_INT |
1134                                                  RC632_TXCTRL_TX2_INV |
1135                                                  RC632_TXCTRL_TX2_RF_EN |
1136                                                  RC632_TXCTRL_TX1_RF_EN));
1137         if (ret < 0)
1138                 return ret;
1139
1140         ret = rc632_reg_write(h, RC632_REG_CW_CONDUCTANCE, 0x3f);
1141         if (ret < 0)
1142                 return ret;
1143
1144         ret = rc632_reg_write(h, RC632_REG_MOD_CONDUCTANCE, 0x02);
1145         if (ret < 0)
1146                 return ret;
1147
1148         ret = rc632_reg_write(h, RC632_REG_CODER_CONTROL, 0x2c);
1149         if (ret < 0)
1150                 return ret;
1151
1152         ret = rc632_reg_write(h, RC632_REG_MOD_WIDTH, 0x3f);
1153         if (ret < 0)
1154                 return ret;
1155
1156         ret = rc632_reg_write(h, RC632_REG_MOD_WIDTH_SOF, 0x3f);
1157         if (ret < 0)
1158                 return ret;
1159
1160         ret = rc632_reg_write(h, RC632_REG_MOD_WIDTH_SOF, 0x3f);
1161         if (ret < 0)
1162                 return ret;
1163
1164         ret = rc632_reg_write(h, RC632_REG_TYPE_B_FRAMING, 0x00);
1165         if (ret < 0)
1166                 return ret;
1167
1168         ret = rc632_reg_write(h, RC632_REG_RX_CONTROL1, 0x8b); /* FIXME */
1169         if (ret < 0)
1170                 return ret;
1171
1172         ret = rc632_reg_write(h, RC632_REG_DECODER_CONTROL, 0x00);
1173         if (ret < 0)
1174                 return ret;
1175
1176         ret = rc632_reg_write(h, RC632_REG_BIT_PHASE, 0x52);
1177         if (ret < 0)
1178                 return ret;
1179
1180         ret = rc632_reg_write(h, RC632_REG_RX_THRESHOLD, 0x66);
1181         if (ret < 0)
1182                 return ret;
1183
1184         ret = rc632_reg_write(h, RC632_REG_BPSK_DEM_CONTROL, 0x00);
1185         if (ret < 0)
1186                 return ret;
1187
1188         ret = rc632_reg_write(h, RC632_REG_RX_CONTROL2,
1189                                                 RC632_RXCTRL2_DECSRC_INT);
1190         if (ret < 0)
1191                 return ret;
1192
1193         ret = rc632_reg_write(h, RC632_REG_CHANNEL_REDUNDANCY,
1194                                                 (RC632_CR_RX_CRC_ENABLE |
1195                                                  RC632_CR_TX_CRC_ENABLE));
1196         ret = rc632_reg_write(h, RC632_REG_CRC_PRESET_LSB, 0xfe);
1197         if (ret < 0)
1198                 return ret;
1199
1200         ret = rc632_reg_write(h, RC632_REG_CRC_PRESET_MSB, 0xff);
1201         if (ret < 0)
1202                 return ret;
1203
1204         return 0;
1205 }
1206
1207 static int
1208 rc632_iso15693_icl_init(struct rfid_asic_handle *h)
1209 {
1210         int ret;
1211
1212         /* ICL */
1213
1214         ret = rc632_reg_write(h, RC632_REG_TX_CONTROL,
1215                                                 (RC632_TXCTRL_MOD_SRC_INT |
1216                                                  RC632_TXCTRL_TX2_INV |
1217                                                  RC632_TXCTRL_TX2_RF_EN |
1218                                                  RC632_TXCTRL_TX1_RF_EN));
1219         if (ret < 0)
1220                 return ret;
1221
1222         ret = rc632_reg_write(h, RC632_REG_CW_CONDUCTANCE, 0x3f);
1223         if (ret < 0)
1224                 return ret;
1225
1226         ret = rc632_reg_write(h, RC632_REG_MOD_CONDUCTANCE, 0x11);
1227         if (ret < 0)
1228                 return ret;
1229
1230         ret = rc632_reg_write(h, RC632_REG_CODER_CONTROL,
1231                                                 (RC632_CDRCTRL_RATE_15693 |
1232                                                  RC632_CDRCTRL_TXCD_ICODE_STD |
1233                                                  0x03)); /* FIXME */
1234         if (ret < 0)
1235                 return ret;
1236
1237         ret = rc632_reg_write(h, RC632_REG_MOD_WIDTH, 0x3f);
1238         if (ret < 0)
1239                 return ret;
1240
1241         ret = rc632_reg_write(h, RC632_REG_MOD_WIDTH_SOF, 0x3f);
1242         if (ret < 0)
1243                 return ret;
1244         ret = rc632_reg_write(h, RC632_REG_RX_CONTROL1,
1245                                                 (RC632_RXCTRL1_SUBCP_16|
1246                                                  RC632_RXCTRL1_ISO15693|
1247                                                  RC632_RXCTRL1_GAIN_35DB));
1248         if (ret < 0)
1249                 return ret;
1250         ret = rc632_reg_write(h, RC632_REG_DECODER_CONTROL,
1251                                                 (RC632_DECCTRL_RX_INVERT|
1252                                                  RC632_DECCTRL_RXFR_15693));
1253         if (ret < 0)
1254                 return ret;
1255
1256         ret = rc632_reg_write(h, RC632_REG_BIT_PHASE, 0xbd);
1257         if (ret < 0)
1258                 return ret;
1259
1260         ret = rc632_reg_write(h, RC632_REG_RX_THRESHOLD, 0xff);
1261         if (ret < 0)
1262                 return ret;
1263
1264         ret = rc632_reg_write(h, RC632_REG_BPSK_DEM_CONTROL, 0x00);
1265         if (ret < 0)
1266                 return ret;
1267
1268         ret = rc632_reg_write(h, RC632_REG_RX_CONTROL2,
1269                                                 RC632_RXCTRL2_DECSRC_INT);
1270         if (ret < 0)
1271                 return ret;
1272
1273         ret = rc632_reg_write(h, RC632_REG_CHANNEL_REDUNDANCY, 0x00);
1274         if (ret < 0)
1275                 return ret;
1276
1277         ret = rc632_reg_write(h, RC632_REG_CRC_PRESET_LSB, 0x12);
1278         if (ret < 0)
1279                 return ret;
1280
1281         ret = rc632_reg_write(h, RC632_REG_CRC_PRESET_MSB, 0xe0);
1282         if (ret < 0)
1283                 return ret;
1284
1285         return 0;
1286 }
1287
1288 struct mifare_authcmd {
1289         u_int8_t auth_cmd;
1290         u_int8_t block_address;
1291         u_int32_t serno;        /* lsb 1 2 msb */
1292 } __attribute__ ((packed));
1293
1294
1295 #define RFID_MIFARE_KEY_LEN 6
1296 #define RFID_MIFARE_KEY_CODED_LEN 12
1297
1298 /* Transform crypto1 key from generic 6byte into rc632 specific 12byte */
1299 static int
1300 rc632_mifare_transform_key(const u_int8_t *key6, u_int8_t *key12)
1301 {
1302         int i;
1303         u_int8_t ln;
1304         u_int8_t hn;
1305
1306         for (i = 0; i < RFID_MIFARE_KEY_LEN; i++) {
1307                 ln = key6[i] & 0x0f;
1308                 hn = key6[i] >> 4;
1309                 key12[i * 2 + 1] = (~ln << 4) | ln;
1310                 key12[i * 2] = (~hn << 4) | hn;
1311         }
1312         return 0;
1313 }
1314
1315 static int
1316 rc632_mifare_set_key(struct rfid_asic_handle *h, const u_int8_t *key)
1317 {
1318         u_int8_t coded_key[RFID_MIFARE_KEY_CODED_LEN];
1319         u_int8_t reg;
1320         int ret;
1321
1322         ret = rc632_mifare_transform_key(key, coded_key);
1323         if (ret < 0)
1324                 return ret;
1325
1326         ret = rc632_fifo_write(h, RFID_MIFARE_KEY_CODED_LEN, coded_key, 0x03);
1327         if (ret < 0)
1328                 return ret;
1329
1330         ret = rc632_reg_write(h, RC632_REG_COMMAND, RC632_CMD_LOAD_KEY);
1331         if (ret < 0)
1332                 return ret;
1333
1334         ret = rc632_wait_idle(h, RC632_TMO_AUTH1);
1335         if (ret < 0)
1336                 return ret;
1337
1338         ret = rc632_reg_read(h, RC632_REG_ERROR_FLAG, &reg);
1339         if (ret < 0)
1340                 return ret;
1341
1342         if (reg & RC632_ERR_FLAG_KEY_ERR)
1343                 return -EINVAL;
1344
1345         return 0;
1346 }
1347
1348 static int
1349 rc632_mifare_auth(struct rfid_asic_handle *h, u_int8_t cmd, u_int32_t serno,
1350                   u_int8_t block)
1351 {
1352         int ret;
1353         struct mifare_authcmd acmd;
1354         u_int8_t reg;
1355
1356         if (cmd != RFID_CMD_MIFARE_AUTH1A && cmd != RFID_CMD_MIFARE_AUTH1B)
1357                 return -EINVAL;
1358
1359         /* Initialize acmd */
1360         acmd.block_address = block & 0xff;
1361         acmd.auth_cmd = cmd;
1362         //acmd.serno = htonl(serno);
1363         acmd.serno = serno;
1364
1365         /* Clear Rx CRC */
1366         ret = rc632_clear_bits(h, RC632_REG_CHANNEL_REDUNDANCY,
1367                                 RC632_CR_RX_CRC_ENABLE);
1368         if (ret < 0)
1369                 return ret;
1370
1371         /* Send Authent1 Command */
1372         ret = rc632_fifo_write(h, sizeof(acmd), (unsigned char *)&acmd, 0x03);
1373         if (ret < 0)
1374                 return ret;
1375
1376         ret = rc632_reg_write(h, RC632_REG_COMMAND, RC632_CMD_AUTHENT1);
1377         if (ret < 0)
1378                 return ret;
1379
1380         /* Wait until transmitter is idle */
1381         ret = rc632_wait_idle(h, RC632_TMO_AUTH1);
1382         if (ret < 0)
1383                 return ret;
1384
1385         ret = rc632_reg_read(h, RC632_REG_SECONDARY_STATUS, &reg);
1386         if (ret < 0)
1387                 return ret;
1388         if (reg & 0x07)
1389                 return -EIO;
1390
1391         /* Clear Tx CRC */
1392         ret = rc632_clear_bits(h, RC632_REG_CHANNEL_REDUNDANCY,
1393                                 RC632_CR_TX_CRC_ENABLE);
1394         if (ret < 0)
1395                 return ret;
1396
1397         /* Send Authent2 Command */
1398         ret = rc632_reg_write(h, RC632_REG_COMMAND, RC632_CMD_AUTHENT2);
1399         if (ret < 0)
1400                 return ret;
1401
1402         /* Wait until transmitter is idle */
1403         ret = rc632_wait_idle(h, RC632_TMO_AUTH1);
1404         if (ret < 0)
1405                 return ret;
1406
1407         /* Check whether authentication was successful */
1408         ret = rc632_reg_read(h, RC632_REG_CONTROL, &reg);
1409         if (ret < 0)
1410                 return ret;
1411
1412         if (!(reg & RC632_CONTROL_CRYPTO1_ON))
1413                 return -EACCES;
1414
1415         return 0;
1416
1417 }
1418
1419 /* transceive regular frame */
1420 static int
1421 rc632_mifare_transceive(struct rfid_asic_handle *handle,
1422                         const u_int8_t *tx_buf, unsigned int tx_len,
1423                         u_int8_t *rx_buf, unsigned int *rx_len,
1424                         u_int64_t timeout, unsigned int flags)
1425 {
1426         int ret;
1427         u_int8_t rxl = *rx_len & 0xff;
1428
1429         DEBUGP("entered\n");
1430         memset(rx_buf, 0, *rx_len);
1431
1432 #if 1
1433         ret = rc632_reg_write(handle, RC632_REG_CHANNEL_REDUNDANCY,
1434                                 (RC632_CR_PARITY_ENABLE |
1435                                  RC632_CR_PARITY_ODD |
1436                                  RC632_CR_TX_CRC_ENABLE |
1437                                  RC632_CR_RX_CRC_ENABLE));
1438 #else
1439         ret = rc632_clear_bits(handle, RC632_REG_CHANNEL_REDUNDANCY,
1440                                 RC632_CR_RX_CRC_ENABLE|RC632_CR_TX_CRC_ENABLE);
1441 #endif
1442         if (ret < 0)
1443                 return ret;
1444
1445         ret = rc632_transceive(handle, tx_buf, tx_len, rx_buf, &rxl, 0x32, 0);
1446         *rx_len = rxl;
1447         if (ret < 0)
1448                 return ret;
1449
1450
1451         return 0;
1452 }
1453
1454 struct rfid_asic rc632 = {
1455         .name   = "Philips CL RC632",
1456         .fc     = ISO14443_FREQ_CARRIER,
1457         .priv.rc632 = {
1458                 .fn = {
1459                         .power_up = &rc632_power_up,
1460                         .power_down = &rc632_power_down,
1461                         .turn_on_rf = &rc632_turn_on_rf,
1462                         .turn_off_rf = &rc632_turn_off_rf,
1463                         .transceive = &rc632_iso14443ab_transceive,
1464                         .iso14443a = {
1465                                 .init = &rc632_iso14443a_init,
1466                                 .transceive_sf = &rc632_iso14443a_transceive_sf,
1467                                 .transceive_acf = &rc632_iso14443a_transceive_acf,
1468                                 .set_speed = &rc632_iso14443a_set_speed,
1469                         },
1470                         .iso14443b = {
1471                                 .init = &rc632_iso14443b_init,
1472                         },
1473                         .iso15693 = {
1474                                 .init = &rc632_iso15693_init,
1475                         },
1476                         .mifare_classic = {
1477                                 .setkey = &rc632_mifare_set_key,
1478                                 .auth = &rc632_mifare_auth,
1479                         },
1480                 },
1481         },
1482 };