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