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