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

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