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