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