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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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_rf_power(struct rfid_asic_handle *handle, int on)
 143 {
 144         ENTER();
 145         if (on)
 146                 return rc632_set_bits(handle, RC632_REG_TX_CONTROL,
 147                                       RC632_TXCTRL_TX1_RF_EN|
 148                                       RC632_TXCTRL_TX2_RF_EN);
 149         else
 150                 return rc632_clear_bits(handle, RC632_REG_TX_CONTROL,
 151                                         RC632_TXCTRL_TX1_RF_EN|
 152                                         RC632_TXCTRL_TX2_RF_EN);
 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);
 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 = 0;
 516         u_int8_t i;
 517
 518         for (i = 0; i <= 0x3f; i++)
 519                 ret |= rc632_reg_read(handle, i, &buf[i]);
 520
 521         return ret;
 522 }
 523
 524 /* generic FIFO access functions (if no more efficient ones provided by
 525  * transport driver) */
 526
 527 static int
 528 generic_fifo_write()
 529 {
 530         // FIXME: implementation (not needed for CM 5121)
 531         return -1;
 532 }
 533
 534 static int
 535 generic_fifo_read()
 536 {
 537         // FIXME: implementation (not neded for CM 5121)
 538         return -1;
 539 }
 540
 541 static int
 542 rc632_init(struct rfid_asic_handle *ah)
 543 {
 544         int ret;
 545
 546         /* switch off rf (make sure PICCs are reset at init time) */
 547         ret = rc632_power_down(ah);
 548         if (ret < 0)
 549                 return ret;
 550
 551         usleep(10000);
 552
 553         /* switch on rf */
 554         ret = rc632_power_up(ah);
 555         if (ret < 0)
 556                 return ret;
 557
 558         /* disable register paging */
 559         ret = rc632_reg_write(ah, 0x00, 0x00);
 560         if (ret < 0)
 561                 return ret;
 562
 563         /* set some sane default values */
 564         ret = rc632_reg_write(ah, 0x11, 0x5b);
 565         if (ret < 0)
 566                 return ret;
 567
 568         /* switch off rf */
 569         ret = rc632_rf_power(ah, 0);
 570         if (ret < 0)
 571                 return ret;
 572
 573         usleep(100000);
 574
 575         /* switch on rf */
 576         ret = rc632_rf_power(ah, 1);
 577         if (ret < 0)
 578                 return ret;
 579
 580         return 0;
 581 }
 582
 583 static int
 584 rc632_fini(struct rfid_asic_handle *ah)
 585 {
 586         int ret;
 587
 588         /* switch off rf */
 589         ret = rc632_rf_power(ah, 0);
 590         if (ret < 0)
 591                 return ret;
 592
 593         ret = rc632_power_down(ah);
 594         if (ret < 0)
 595                 return ret;
 596
 597         return 0;
 598 }
 599
 600 struct rfid_asic_handle *
 601 rc632_open(struct rfid_asic_transport_handle *th)
 602 {
 603         struct rfid_asic_handle *h;
 604
 605         h = malloc_asic_handle(sizeof(*h));
 606         if (!h)
 607                 return NULL;
 608         memset(h, 0, sizeof(*h));
 609
 610         h->asic = (void*)&rc632;
 611         h->rath = th;
 612         h->fc = h->asic->fc;
 613         /* FIXME: this is only cm5121 specific, since the latency
 614          * down to the RC632 FIFO is too long to refill during TX/RX */
 615         h->mtu = h->mru = 64;
 616
 617         if (rc632_init(h) < 0) {
 618                 free_asic_handle(h);
 619                 return NULL;
 620         }
 621
 622         return h;
 623 }
 624
 625 void
 626 rc632_close(struct rfid_asic_handle *h)
 627 {
 628         rc632_fini(h);
 629         free_asic_handle(h);
 630 }
 631
 632
 633 /*
 634  * Philips CL RC632 primitives for ISO 14443-A compliant PICC's
 635  *
 636  * (C) 2005-2006 by Harald Welte <laforge@gnumonks.org>
 637  *
 638  */
 639
 640 static int
 641 rc632_iso14443a_init(struct rfid_asic_handle *handle)
 642 {
 643         int ret;
 644
 645         // FIXME: some fifo work (drain fifo?)
 646
 647         /* flush fifo (our way) */
 648         ret = rc632_reg_write(handle, RC632_REG_CONTROL,
 649                               RC632_CONTROL_FIFO_FLUSH);
 650
 651         ret = rc632_reg_write(handle, RC632_REG_TX_CONTROL,
 652                         (RC632_TXCTRL_TX1_RF_EN |
 653                          RC632_TXCTRL_TX2_RF_EN |
 654                          RC632_TXCTRL_TX2_INV |
 655                          RC632_TXCTRL_FORCE_100_ASK |
 656                          RC632_TXCTRL_MOD_SRC_INT));
 657         if (ret < 0)
 658                 return ret;
 659
 660         ret = rc632_reg_write(handle, RC632_REG_CW_CONDUCTANCE,
 661                                 CM5121_CW_CONDUCTANCE);
 662         if (ret < 0)
 663                 return ret;
 664
 665         /* Since FORCE_100_ASK is set (cf mc073930.pdf), this line may be left out? */
 666         ret = rc632_reg_write(handle, RC632_REG_MOD_CONDUCTANCE,
 667                                 CM5121_MOD_CONDUCTANCE);
 668         if (ret < 0)
 669                 return ret;
 670
 671         ret = rc632_reg_write(handle, RC632_REG_CODER_CONTROL,
 672                                 (RC632_CDRCTRL_TXCD_14443A |
 673                                  RC632_CDRCTRL_RATE_106K));
 674         if (ret < 0)
 675                 return ret;
 676
 677         ret = rc632_reg_write(handle, RC632_REG_MOD_WIDTH, 0x13);
 678         if (ret < 0)
 679                 return ret;
 680
 681         ret = rc632_reg_write(handle, RC632_REG_MOD_WIDTH_SOF, 0x3f);
 682         if (ret < 0)
 683                 return ret;
 684
 685         ret = rc632_reg_write(handle, RC632_REG_TYPE_B_FRAMING, 0x00);
 686         if (ret < 0)
 687                 return ret;
 688
 689         ret = rc632_reg_write(handle, RC632_REG_RX_CONTROL1,
 690                               (RC632_RXCTRL1_GAIN_35DB |
 691                                RC632_RXCTRL1_ISO14443 |
 692                                RC632_RXCTRL1_SUBCP_8));
 693         if (ret < 0)
 694                 return ret;
 695
 696         ret = rc632_reg_write(handle, RC632_REG_DECODER_CONTROL,
 697                               (RC632_DECCTRL_MANCHESTER |
 698                                RC632_DECCTRL_RXFR_14443A));
 699         if (ret < 0)
 700                 return ret;
 701
 702         ret = rc632_reg_write(handle, RC632_REG_BIT_PHASE,
 703                                 CM5121_14443A_BITPHASE);
 704         if (ret < 0)
 705                 return ret;
 706
 707         ret = rc632_reg_write(handle, RC632_REG_RX_THRESHOLD,
 708                                 CM5121_14443A_THRESHOLD);
 709         if (ret < 0)
 710                 return ret;
 711
 712         ret = rc632_reg_write(handle, RC632_REG_BPSK_DEM_CONTROL, 0x00);
 713         if (ret < 0)
 714                 return ret;
 715
 716         ret = rc632_reg_write(handle, RC632_REG_RX_CONTROL2,
 717                               (RC632_RXCTRL2_DECSRC_INT |
 718                                RC632_RXCTRL2_CLK_Q));
 719         if (ret < 0)
 720                 return ret;
 721
 722         /* Omnikey proprietary driver has 0x03, but 0x06 is the default reset value ?!? */
 723         ret = rc632_reg_write(handle, RC632_REG_RX_WAIT, 0x06);
 724         if (ret < 0)
 725                 return ret;
 726
 727         ret = rc632_reg_write(handle, RC632_REG_CHANNEL_REDUNDANCY,
 728                               (RC632_CR_PARITY_ENABLE |
 729                                RC632_CR_PARITY_ODD));
 730         if (ret < 0)
 731                 return ret;
 732
 733         ret = rc632_reg_write(handle, RC632_REG_CRC_PRESET_LSB, 0x63);
 734         if (ret < 0)
 735                 return ret;
 736
 737         ret = rc632_reg_write(handle, RC632_REG_CRC_PRESET_MSB, 0x63);
 738         if (ret < 0)
 739                 return ret;
 740
 741         return 0;
 742 }
 743
 744 static int
 745 rc632_iso14443a_fini(struct iso14443a_handle *handle_14443)
 746 {
 747
 748 #if 0
 749         ret = rc632_rf_power(handle, 0);
 750         if (ret < 0)
 751                 return ret;
 752 #endif
 753
 754
 755         return 0;
 756 }
 757
 758
 759 /* issue a 14443-3 A PCD -> PICC command in a short frame, such as REQA, WUPA */
 760 static int
 761 rc632_iso14443a_transceive_sf(struct rfid_asic_handle *handle,
 762                                 u_int8_t cmd,
 763                                 struct iso14443a_atqa *atqa)
 764 {
 765         int ret;
 766         u_int8_t tx_buf[1];
 767         u_int8_t rx_len = 2;
 768         u_int8_t error_flag;
 769
 770         memset(atqa, 0, sizeof(*atqa));
 771
 772         tx_buf[0] = cmd;
 773
 774         /* transfer only 7 bits of last byte in frame */
 775         ret = rc632_reg_write(handle, RC632_REG_BIT_FRAMING, 0x07);
 776         if (ret < 0)
 777                 return ret;
 778
 779         ret = rc632_clear_bits(handle, RC632_REG_CONTROL,
 780                                 RC632_CONTROL_CRYPTO1_ON);
 781         if (ret < 0)
 782                 return ret;
 783
 784 #if 0
 785         ret = rc632_reg_write(handle, RC632_REG_CHANNEL_REDUNDANCY,
 786                                 (RC632_CR_PARITY_ENABLE |
 787                                  RC632_CR_PARITY_ODD));
 788 #else
 789         ret = rc632_clear_bits(handle, RC632_REG_CHANNEL_REDUNDANCY,
 790                                 RC632_CR_RX_CRC_ENABLE|RC632_CR_TX_CRC_ENABLE);
 791
 792 #endif
 793         if (ret < 0)
 794                 return ret;
 795
 796         ret = rc632_transceive(handle, tx_buf, sizeof(tx_buf),
 797                                 (u_int8_t *)atqa, &rx_len,
 798                                 ISO14443A_FDT_ANTICOL_LAST1, 0);
 799         if (ret < 0) {
 800                 DEBUGP("error during rc632_transceive()\n");
 801                 return ret;
 802         }
 803
 804         /* switch back to normal 8bit last byte */
 805         ret = rc632_reg_write(handle, RC632_REG_BIT_FRAMING, 0x00);
 806         if (ret < 0)
 807                 return ret;
 808
 809         /* determine whether there was a collission */
 810         ret = rc632_reg_read(handle, RC632_REG_ERROR_FLAG, &error_flag);
 811         if (ret < 0)
 812                 return ret;
 813
 814         if (error_flag & RC632_ERR_FLAG_COL_ERR) {
 815                 u_int8_t boc;
 816                 /* retrieve bit of collission */
 817                 ret = rc632_reg_read(handle, RC632_REG_COLL_POS, &boc);
 818                 if (ret < 0)
 819                         return ret;
 820                 DEBUGP("collision detected in xcv_sf: bit_of_col=%u\n", boc);
 821                 /* FIXME: how to signal this up the stack */
 822         }
 823
 824         if (rx_len != 2) {
 825                 DEBUGP("rx_len(%d) != 2\n", rx_len);
 826                 return -1;
 827         }
 828
 829         return 0;
 830 }
 831
 832 /* transceive regular frame */
 833 static int
 834 rc632_iso14443ab_transceive(struct rfid_asic_handle *handle,
 835                            unsigned int frametype,
 836                            const u_int8_t *tx_buf, unsigned int tx_len,
 837                            u_int8_t *rx_buf, unsigned int *rx_len,
 838                            u_int64_t timeout, unsigned int flags)
 839 {
 840         int ret;
 841         u_int8_t rxl;
 842         u_int8_t channel_red;
 843
 844         if (*rx_len > 0xff)
 845                 rxl = 0xff;
 846         else
 847                 rxl = *rx_len;
 848
 849         memset(rx_buf, 0, *rx_len);
 850
 851         switch (frametype) {
 852         case RFID_14443A_FRAME_REGULAR:
 853         case RFID_MIFARE_FRAME:
 854                 channel_red = RC632_CR_RX_CRC_ENABLE|RC632_CR_TX_CRC_ENABLE
 855                                 |RC632_CR_PARITY_ENABLE|RC632_CR_PARITY_ODD;
 856                 break;
 857         case RFID_14443B_FRAME_REGULAR:
 858                 channel_red = RC632_CR_RX_CRC_ENABLE|RC632_CR_TX_CRC_ENABLE
 859                                 |RC632_CR_CRC3309;
 860                 break;
 861 #if 0
 862         case RFID_MIFARE_FRAME:
 863                 channel_red = RC632_CR_PARITY_ENABLE|RC632_CR_PARITY_ODD;
 864                 break;
 865 #endif
 866         default:
 867                 return -EINVAL;
 868                 break;
 869         }
 870         ret = rc632_reg_write(handle, RC632_REG_CHANNEL_REDUNDANCY,
 871                               channel_red);
 872         if (ret < 0)
 873                 return ret;
 874
 875         ret = rc632_transceive(handle, tx_buf, tx_len, rx_buf, &rxl, timeout, 0);
 876         *rx_len = rxl;
 877         if (ret < 0)
 878                 return ret;
 879
 880
 881         return 0;
 882 }
 883
 884 /* transceive anti collission bitframe */
 885 static int
 886 rc632_iso14443a_transceive_acf(struct rfid_asic_handle *handle,
 887                                 struct iso14443a_anticol_cmd *acf,
 888                                 unsigned int *bit_of_col)
 889 {
 890         int ret;
 891         u_int8_t rx_buf[64];
 892         u_int8_t rx_len = sizeof(rx_buf);
 893         u_int8_t rx_align = 0, tx_last_bits, tx_bytes, tx_bytes_total;
 894         u_int8_t boc;
 895         u_int8_t error_flag;
 896         *bit_of_col = ISO14443A_BITOFCOL_NONE;
 897         memset(rx_buf, 0, sizeof(rx_buf));
 898
 899         /* disable mifare cryto */
 900         ret = rc632_clear_bits(handle, RC632_REG_CONTROL,
 901                                 RC632_CONTROL_CRYPTO1_ON);
 902         if (ret < 0)
 903                 return ret;
 904
 905         /* disable CRC summing */
 906 #if 0
 907         ret = rc632_reg_write(handle, RC632_REG_CHANNEL_REDUNDANCY,
 908                                 (RC632_CR_PARITY_ENABLE |
 909                                  RC632_CR_PARITY_ODD));
 910 #else
 911         ret = rc632_clear_bits(handle, RC632_REG_CHANNEL_REDUNDANCY,
 912                                 RC632_CR_TX_CRC_ENABLE|RC632_CR_TX_CRC_ENABLE);
 913 #endif
 914         if (ret < 0)
 915                 return ret;
 916
 917         tx_last_bits = acf->nvb & 0x07; /* lower nibble indicates bits */
 918         tx_bytes = ( acf->nvb >> 4 ) & 0x07;
 919         if (tx_last_bits) {
 920                 tx_bytes_total = tx_bytes+1;
 921                 rx_align = tx_last_bits & 0x07; /* rx frame complements tx */
 922         }
 923         else
 924                 tx_bytes_total = tx_bytes;
 925
 926         /* set RxAlign and TxLastBits*/
 927         ret = rc632_reg_write(handle, RC632_REG_BIT_FRAMING,
 928                                 (rx_align << 4) | (tx_last_bits));
 929         if (ret < 0)
 930                 return ret;
 931
 932         ret = rc632_transceive(handle, (u_int8_t *)acf, tx_bytes_total,
 933                                 rx_buf, &rx_len, 0x32, 0);
 934         if (ret < 0)
 935                 return ret;
 936
 937         /* bitwise-OR the two halves of the split byte */
 938         acf->uid_bits[tx_bytes-2] = (
 939                   (acf->uid_bits[tx_bytes-2] & (0xff >> (8-tx_last_bits)))
 940                 | rx_buf[0]);
 941
 942         /* copy the rest */
 943         if (rx_len)
 944                 memcpy(&acf->uid_bits[tx_bytes-1], &rx_buf[1], rx_len-1);
 945
 946         /* determine whether there was a collission */
 947         ret = rc632_reg_read(handle, RC632_REG_ERROR_FLAG, &error_flag);
 948         if (ret < 0)
 949                 return ret;
 950
 951         if (error_flag & RC632_ERR_FLAG_COL_ERR) {
 952                 /* retrieve bit of collission */
 953                 ret = rc632_reg_read(handle, RC632_REG_COLL_POS, &boc);
 954                 if (ret < 0)
 955                         return ret;
 956
 957                 /* bit of collission relative to start of part 1 of
 958                  * anticollision frame (!) */
 959                 *bit_of_col = 2*8 + boc;
 960         }
 961
 962         return 0;
 963 }
 964
 965 enum rc632_rate {
 966         RC632_RATE_106  = 0x00,
 967         RC632_RATE_212  = 0x01,
 968         RC632_RATE_424  = 0x02,
 969         RC632_RATE_848  = 0x03,
 970 };
 971
 972 struct rx_config {
 973         u_int8_t        subc_pulses;
 974         u_int8_t        rx_coding;
 975         u_int8_t        rx_threshold;
 976         u_int8_t        bpsk_dem_ctrl;
 977 };
 978
 979 struct tx_config {
 980         u_int8_t        rate;
 981         u_int8_t        mod_width;
 982 };
 983
 984 static struct rx_config rx_configs[] = {
 985         {
 986                 .subc_pulses    = RC632_RXCTRL1_SUBCP_8,
 987                 .rx_coding      = RC632_DECCTRL_MANCHESTER,
 988                 .rx_threshold   = 0x88,
 989                 .bpsk_dem_ctrl  = 0x00,
 990         },
 991         {
 992                 .subc_pulses    = RC632_RXCTRL1_SUBCP_4,
 993                 .rx_coding      = RC632_DECCTRL_BPSK,
 994                 .rx_threshold   = 0x50,
 995                 .bpsk_dem_ctrl  = 0x0c,
 996         },
 997         {
 998                 .subc_pulses    = RC632_RXCTRL1_SUBCP_2,
 999                 .rx_coding      = RC632_DECCTRL_BPSK,
1000                 .rx_threshold   = 0x50,
1001                 .bpsk_dem_ctrl  = 0x0c,
1002         },
1003         {
1004                 .subc_pulses    = RC632_RXCTRL1_SUBCP_1,
1005                 .rx_coding      = RC632_DECCTRL_BPSK,
1006                 .rx_threshold   = 0x50,
1007                 .bpsk_dem_ctrl  = 0x0c,
1008         },
1009 };
1010
1011 static struct tx_config tx_configs[] = {
1012         {
1013                 .rate           = RC632_CDRCTRL_RATE_106K,
1014                 .mod_width      = 0x13,
1015         },
1016         {
1017                 .rate           = RC632_CDRCTRL_RATE_212K,
1018                 .mod_width      = 0x07,
1019         },
1020         {
1021                 .rate           = RC632_CDRCTRL_RATE_424K,
1022                 .mod_width      = 0x03,
1023         },
1024         {
1025                 .rate           = RC632_CDRCTRL_RATE_848K,
1026                 .mod_width      = 0x01,
1027         },
1028 };
1029
1030 static int rc632_iso14443a_set_speed(struct rfid_asic_handle *handle,
1031                                      unsigned int tx, unsigned int rate)
1032 {
1033         int rc;
1034         u_int8_t reg;
1035
1036
1037         if (!tx) {
1038                 /* Rx */
1039                 if (rate > ARRAY_SIZE(rx_configs))
1040                         return -EINVAL;
1041
1042                 rc = rc632_set_bit_mask(handle, RC632_REG_RX_CONTROL1,
1043                                         RC632_RXCTRL1_SUBCP_MASK,
1044                                         rx_configs[rate].subc_pulses);
1045                 if (rc < 0)
1046                         return rc;
1047
1048                 rc = rc632_set_bit_mask(handle, RC632_REG_DECODER_CONTROL,
1049                                         RC632_DECCTRL_BPSK,
1050                                         rx_configs[rate].rx_coding);
1051                 if (rc < 0)
1052                         return rc;
1053
1054                 rc = rc632_reg_write(handle, RC632_REG_RX_THRESHOLD,
1055                                         rx_configs[rate].rx_threshold);
1056                 if (rc < 0)
1057                         return rc;
1058
1059                 if (rx_configs[rate].rx_coding == RC632_DECCTRL_BPSK) {
1060                         rc = rc632_reg_write(handle,
1061                                              RC632_REG_BPSK_DEM_CONTROL,
1062                                              rx_configs[rate].bpsk_dem_ctrl);
1063                         if (rc < 0)
1064                                 return rc;
1065                 }
1066         } else {
1067                 /* Tx */
1068                 if (rate > ARRAY_SIZE(tx_configs))
1069                         return -EINVAL;
1070
1071                 rc = rc632_set_bit_mask(handle, RC632_REG_CODER_CONTROL,
1072                                         RC632_CDRCTRL_RATE_MASK,
1073                                         tx_configs[rate].rate);
1074                 if (rc < 0)
1075                         return rc;
1076
1077                 rc = rc632_reg_write(handle, RC632_REG_MOD_WIDTH,
1078                                      tx_configs[rate].mod_width);
1079                 if (rc < 0)
1080                         return rc;
1081         }
1082
1083         return 0;
1084 }
1085
1086 static int rc632_iso14443b_init(struct rfid_asic_handle *handle)
1087 {
1088         int ret;
1089
1090         // FIXME: some FIFO work
1091
1092         /* flush fifo (our way) */
1093         ret = rc632_reg_write(handle, RC632_REG_CONTROL,
1094                               RC632_CONTROL_FIFO_FLUSH);
1095         if (ret < 0)
1096                 return ret;
1097
1098         ret = rc632_reg_write(handle, RC632_REG_TX_CONTROL,
1099                         (RC632_TXCTRL_TX1_RF_EN |
1100                          RC632_TXCTRL_TX2_RF_EN |
1101                          RC632_TXCTRL_TX2_INV |
1102                          RC632_TXCTRL_MOD_SRC_INT));
1103         if (ret < 0)
1104                 return ret;
1105
1106         ret = rc632_reg_write(handle, RC632_REG_CW_CONDUCTANCE, 0x3f);
1107         if (ret < 0)
1108                 return ret;
1109
1110         ret = rc632_reg_write(handle, RC632_REG_MOD_CONDUCTANCE, 0x04);
1111         if (ret < 0)
1112                 return ret;
1113
1114         ret = rc632_reg_write(handle, RC632_REG_CODER_CONTROL,
1115                               (RC632_CDRCTRL_TXCD_NRZ |
1116                                RC632_CDRCTRL_RATE_14443B));
1117         if (ret < 0)
1118                 return ret;
1119
1120         ret = rc632_reg_write(handle, RC632_REG_MOD_WIDTH, 0x13);
1121         if (ret < 0)
1122                 return ret;
1123
1124         ret = rc632_reg_write(handle, RC632_REG_MOD_WIDTH_SOF, 0x3f);
1125         if (ret < 0)
1126                 return ret;
1127
1128         ret = rc632_reg_write(handle, RC632_REG_TYPE_B_FRAMING,
1129                               (RC632_TBFRAMING_SOF_11L_3H |
1130                                (6 << RC632_TBFRAMING_SPACE_SHIFT) |
1131                                RC632_TBFRAMING_EOF_11));
1132         if (ret < 0)
1133                 return ret;
1134
1135         ret = rc632_reg_write(handle, RC632_REG_RX_CONTROL1,
1136                               (RC632_RXCTRL1_GAIN_35DB |
1137                                RC632_RXCTRL1_ISO14443 |
1138                                RC632_RXCTRL1_SUBCP_8));
1139         if (ret < 0)
1140                 return ret;
1141
1142         ret = rc632_reg_write(handle, RC632_REG_DECODER_CONTROL,
1143                               (RC632_DECCTRL_BPSK |
1144                                RC632_DECCTRL_RXFR_14443B));
1145         if (ret < 0)
1146                 return ret;
1147
1148         ret = rc632_reg_write(handle, RC632_REG_BIT_PHASE,
1149                                 CM5121_14443B_BITPHASE);
1150         if (ret < 0)
1151                 return ret;
1152
1153         ret = rc632_reg_write(handle, RC632_REG_RX_THRESHOLD,
1154                                 CM5121_14443B_THRESHOLD);
1155         if (ret < 0)
1156                 return ret;
1157
1158         ret = rc632_reg_write(handle, RC632_REG_BPSK_DEM_CONTROL,
1159                               ((0x2 & RC632_BPSKD_TAUB_MASK)<<RC632_BPSKD_TAUB_SHIFT |
1160                                (0x3 & RC632_BPSKD_TAUD_MASK)<<RC632_BPSKD_TAUD_SHIFT |
1161                                RC632_BPSKD_FILTER_AMP_DETECT |
1162                                RC632_BPSKD_NO_RX_EOF |
1163                                RC632_BPSKD_NO_RX_EGT));
1164         if (ret < 0)
1165                 return ret;
1166
1167         ret = rc632_reg_write(handle, RC632_REG_RX_CONTROL2,
1168                               (RC632_RXCTRL2_AUTO_PD |
1169                                RC632_RXCTRL2_DECSRC_INT));
1170         if (ret < 0)
1171                 return ret;
1172
1173         ret = rc632_reg_write(handle, RC632_REG_RX_WAIT, 0x03);
1174         if (ret < 0)
1175                 return ret;
1176
1177         ret = rc632_reg_write(handle, RC632_REG_CHANNEL_REDUNDANCY,
1178                               (RC632_CR_TX_CRC_ENABLE |
1179                                RC632_CR_RX_CRC_ENABLE |
1180                                RC632_CR_CRC3309));
1181         if (ret < 0)
1182                 return ret;
1183
1184         ret = rc632_reg_write(handle, RC632_REG_CRC_PRESET_LSB, 0xff);
1185         if (ret < 0)
1186                 return ret;
1187
1188         ret = rc632_reg_write(handle, RC632_REG_CRC_PRESET_MSB, 0xff);
1189         if (ret < 0)
1190                 return ret;
1191
1192         return 0;
1193 }
1194
1195 static int
1196 rc632_iso15693_init(struct rfid_asic_handle *h)
1197 {
1198         int ret;
1199
1200         ret = rc632_reg_write(h, RC632_REG_TX_CONTROL,
1201                                                 (RC632_TXCTRL_MOD_SRC_INT |
1202                                                  RC632_TXCTRL_TX2_INV |
1203                                                  RC632_TXCTRL_TX2_RF_EN |
1204                                                  RC632_TXCTRL_TX1_RF_EN));
1205         if (ret < 0)
1206                 return ret;
1207
1208         ret = rc632_reg_write(h, RC632_REG_CW_CONDUCTANCE, 0x3f);
1209         if (ret < 0)
1210                 return ret;
1211
1212         ret = rc632_reg_write(h, RC632_REG_MOD_CONDUCTANCE, 0x03);
1213         if (ret < 0)
1214                 return ret;
1215
1216         ret = rc632_reg_write(h, RC632_REG_CODER_CONTROL,
1217                                                 (RC632_CDRCTRL_RATE_15693 |
1218                                                  0x03)); /* FIXME */
1219         if (ret < 0)
1220                 return ret;
1221
1222         ret = rc632_reg_write(h, RC632_REG_MOD_WIDTH, 0x3f);
1223         if (ret < 0)
1224                 return ret;
1225
1226         ret = rc632_reg_write(h, RC632_REG_MOD_WIDTH_SOF, 0x3f);
1227         if (ret < 0)
1228                 return ret;
1229
1230         ret = rc632_reg_write(h, RC632_REG_TYPE_B_FRAMING, 0x00);
1231         if (ret < 0)
1232                 return ret;
1233
1234         ret = rc632_reg_write(h, RC632_REG_RX_CONTROL1,
1235                                                 (RC632_RXCTRL1_SUBCP_16 |
1236                                                  RC632_RXCTRL1_ISO15693 |
1237                                                  RC632_RXCTRL1_GAIN_35DB));
1238         if (ret < 0)
1239                 return ret;
1240
1241         ret = rc632_reg_write(h, RC632_REG_DECODER_CONTROL,
1242                                                 (RC632_DECCTRL_RXFR_15693 |
1243                                                  RC632_DECCTRL_RX_INVERT));
1244         if (ret < 0)
1245                 return ret;
1246
1247         ret = rc632_reg_write(h, RC632_REG_BIT_PHASE, 0xe0);
1248         if (ret < 0)
1249                 return ret;
1250
1251         ret = rc632_reg_write(h, RC632_REG_RX_THRESHOLD, 0xff);
1252         if (ret < 0)
1253                 return ret;
1254
1255         ret = rc632_reg_write(h, RC632_REG_BPSK_DEM_CONTROL, 0x00);
1256         if (ret < 0)
1257                 return ret;
1258
1259         ret = rc632_reg_write(h, RC632_REG_RX_CONTROL2,
1260                                                 (RC632_RXCTRL2_AUTO_PD |
1261                                                  RC632_RXCTRL2_DECSRC_INT));
1262         if (ret < 0)
1263                 return ret;
1264
1265         ret = rc632_reg_write(h, RC632_REG_CHANNEL_REDUNDANCY,
1266                                                 (RC632_CR_CRC3309 |
1267                                                  RC632_CR_RX_CRC_ENABLE |
1268                                                  RC632_CR_TX_CRC_ENABLE));
1269         if (ret < 0)
1270                 return ret;
1271
1272         ret = rc632_reg_write(h, RC632_REG_CRC_PRESET_LSB, 0xff);
1273         if (ret < 0)
1274                 return ret;
1275
1276         ret = rc632_reg_write(h, RC632_REG_CRC_PRESET_MSB, 0xff);
1277         if (ret < 0)
1278                 return ret;
1279
1280         return 0;
1281 }
1282
1283 static int
1284 rc632_iso15693_icode_init(struct rfid_asic_handle *h)
1285 {
1286         int ret;
1287
1288         ret = rc632_reg_write(h, RC632_REG_TX_CONTROL,
1289                                                 (RC632_TXCTRL_MOD_SRC_INT |
1290                                                  RC632_TXCTRL_TX2_INV |
1291                                                  RC632_TXCTRL_TX2_RF_EN |
1292                                                  RC632_TXCTRL_TX1_RF_EN));
1293         if (ret < 0)
1294                 return ret;
1295
1296         ret = rc632_reg_write(h, RC632_REG_CW_CONDUCTANCE, 0x3f);
1297         if (ret < 0)
1298                 return ret;
1299
1300         ret = rc632_reg_write(h, RC632_REG_MOD_CONDUCTANCE, 0x02);
1301         if (ret < 0)
1302                 return ret;
1303
1304         ret = rc632_reg_write(h, RC632_REG_CODER_CONTROL, 0x2c);
1305         if (ret < 0)
1306                 return ret;
1307
1308         ret = rc632_reg_write(h, RC632_REG_MOD_WIDTH, 0x3f);
1309         if (ret < 0)
1310                 return ret;
1311
1312         ret = rc632_reg_write(h, RC632_REG_MOD_WIDTH_SOF, 0x3f);
1313         if (ret < 0)
1314                 return ret;
1315
1316         ret = rc632_reg_write(h, RC632_REG_MOD_WIDTH_SOF, 0x3f);
1317         if (ret < 0)
1318                 return ret;
1319
1320         ret = rc632_reg_write(h, RC632_REG_TYPE_B_FRAMING, 0x00);
1321         if (ret < 0)
1322                 return ret;
1323
1324         ret = rc632_reg_write(h, RC632_REG_RX_CONTROL1, 0x8b); /* FIXME */
1325         if (ret < 0)
1326                 return ret;
1327
1328         ret = rc632_reg_write(h, RC632_REG_DECODER_CONTROL, 0x00);
1329         if (ret < 0)
1330                 return ret;
1331
1332         ret = rc632_reg_write(h, RC632_REG_BIT_PHASE, 0x52);
1333         if (ret < 0)
1334                 return ret;
1335
1336         ret = rc632_reg_write(h, RC632_REG_RX_THRESHOLD, 0x66);
1337         if (ret < 0)
1338                 return ret;
1339
1340         ret = rc632_reg_write(h, RC632_REG_BPSK_DEM_CONTROL, 0x00);
1341         if (ret < 0)
1342                 return ret;
1343
1344         ret = rc632_reg_write(h, RC632_REG_RX_CONTROL2,
1345                                                 RC632_RXCTRL2_DECSRC_INT);
1346         if (ret < 0)
1347                 return ret;
1348
1349         ret = rc632_reg_write(h, RC632_REG_CHANNEL_REDUNDANCY,
1350                                                 (RC632_CR_RX_CRC_ENABLE |
1351                                                  RC632_CR_TX_CRC_ENABLE));
1352         ret = rc632_reg_write(h, RC632_REG_CRC_PRESET_LSB, 0xfe);
1353         if (ret < 0)
1354                 return ret;
1355
1356         ret = rc632_reg_write(h, RC632_REG_CRC_PRESET_MSB, 0xff);
1357         if (ret < 0)
1358                 return ret;
1359
1360         return 0;
1361 }
1362
1363 static int
1364 rc632_iso15693_icl_init(struct rfid_asic_handle *h)
1365 {
1366         int ret;
1367
1368         /* ICL */
1369
1370         ret = rc632_reg_write(h, RC632_REG_TX_CONTROL,
1371                                                 (RC632_TXCTRL_MOD_SRC_INT |
1372                                                  RC632_TXCTRL_TX2_INV |
1373                                                  RC632_TXCTRL_TX2_RF_EN |
1374                                                  RC632_TXCTRL_TX1_RF_EN));
1375         if (ret < 0)
1376                 return ret;
1377
1378         ret = rc632_reg_write(h, RC632_REG_CW_CONDUCTANCE, 0x3f);
1379         if (ret < 0)
1380                 return ret;
1381
1382         ret = rc632_reg_write(h, RC632_REG_MOD_CONDUCTANCE, 0x11);
1383         if (ret < 0)
1384                 return ret;
1385
1386         ret = rc632_reg_write(h, RC632_REG_CODER_CONTROL,
1387                                                 (RC632_CDRCTRL_RATE_15693 |
1388                                                  RC632_CDRCTRL_TXCD_ICODE_STD |
1389                                                  0x03)); /* FIXME */
1390         if (ret < 0)
1391                 return ret;
1392
1393         ret = rc632_reg_write(h, RC632_REG_MOD_WIDTH, 0x3f);
1394         if (ret < 0)
1395                 return ret;
1396
1397         ret = rc632_reg_write(h, RC632_REG_MOD_WIDTH_SOF, 0x3f);
1398         if (ret < 0)
1399                 return ret;
1400         ret = rc632_reg_write(h, RC632_REG_RX_CONTROL1,
1401                                                 (RC632_RXCTRL1_SUBCP_16|
1402                                                  RC632_RXCTRL1_ISO15693|
1403                                                  RC632_RXCTRL1_GAIN_35DB));
1404         if (ret < 0)
1405                 return ret;
1406         ret = rc632_reg_write(h, RC632_REG_DECODER_CONTROL,
1407                                                 (RC632_DECCTRL_RX_INVERT|
1408                                                  RC632_DECCTRL_RXFR_15693));
1409         if (ret < 0)
1410                 return ret;
1411
1412         ret = rc632_reg_write(h, RC632_REG_BIT_PHASE, 0xbd);
1413         if (ret < 0)
1414                 return ret;
1415
1416         ret = rc632_reg_write(h, RC632_REG_RX_THRESHOLD, 0xff);
1417         if (ret < 0)
1418                 return ret;
1419
1420         ret = rc632_reg_write(h, RC632_REG_BPSK_DEM_CONTROL, 0x00);
1421         if (ret < 0)
1422                 return ret;
1423
1424         ret = rc632_reg_write(h, RC632_REG_RX_CONTROL2,
1425                                                 RC632_RXCTRL2_DECSRC_INT);
1426         if (ret < 0)
1427                 return ret;
1428
1429         ret = rc632_reg_write(h, RC632_REG_CHANNEL_REDUNDANCY, 0x00);
1430         if (ret < 0)
1431                 return ret;
1432
1433         ret = rc632_reg_write(h, RC632_REG_CRC_PRESET_LSB, 0x12);
1434         if (ret < 0)
1435                 return ret;
1436
1437         ret = rc632_reg_write(h, RC632_REG_CRC_PRESET_MSB, 0xe0);
1438         if (ret < 0)
1439                 return ret;
1440
1441         return 0;
1442 }
1443
1444 struct mifare_authcmd {
1445         u_int8_t auth_cmd;
1446         u_int8_t block_address;
1447         u_int32_t serno;        /* lsb 1 2 msb */
1448 } __attribute__ ((packed));
1449
1450
1451 #define RFID_MIFARE_KEY_LEN 6
1452 #define RFID_MIFARE_KEY_CODED_LEN 12
1453
1454 /* Transform crypto1 key from generic 6byte into rc632 specific 12byte */
1455 static int
1456 rc632_mifare_transform_key(const u_int8_t *key6, u_int8_t *key12)
1457 {
1458         int i;
1459         u_int8_t ln;
1460         u_int8_t hn;
1461
1462         for (i = 0; i < RFID_MIFARE_KEY_LEN; i++) {
1463                 ln = key6[i] & 0x0f;
1464                 hn = key6[i] >> 4;
1465                 key12[i * 2 + 1] = (~ln << 4) | ln;
1466                 key12[i * 2] = (~hn << 4) | hn;
1467         }
1468         return 0;
1469 }
1470
1471 static int
1472 rc632_mifare_set_key(struct rfid_asic_handle *h, const u_int8_t *key)
1473 {
1474         u_int8_t coded_key[RFID_MIFARE_KEY_CODED_LEN];
1475         u_int8_t reg;
1476         int ret;
1477
1478         ret = rc632_mifare_transform_key(key, coded_key);
1479         if (ret < 0)
1480                 return ret;
1481
1482         /* Terminate probably running command */
1483         ret = rc632_reg_write(h, RC632_REG_COMMAND, RC632_CMD_IDLE);
1484         if (ret < 0)
1485                 return ret;
1486
1487         ret = rc632_fifo_write(h, RFID_MIFARE_KEY_CODED_LEN, coded_key, 0x03);
1488         if (ret < 0)
1489                 return ret;
1490
1491         ret = rc632_reg_write(h, RC632_REG_COMMAND, RC632_CMD_LOAD_KEY);
1492         if (ret < 0)
1493                 return ret;
1494
1495         ret = rc632_wait_idle(h, RC632_TMO_AUTH1);
1496         if (ret < 0)
1497                 return ret;
1498
1499         ret = rc632_reg_read(h, RC632_REG_ERROR_FLAG, &reg);
1500         if (ret < 0)
1501                 return ret;
1502
1503         if (reg & RC632_ERR_FLAG_KEY_ERR)
1504                 return -EINVAL;
1505
1506         return 0;
1507 }
1508
1509 static int
1510 rc632_mifare_auth(struct rfid_asic_handle *h, u_int8_t cmd, u_int32_t serno,
1511                   u_int8_t block)
1512 {
1513         int ret;
1514         struct mifare_authcmd acmd;
1515         u_int8_t reg;
1516
1517         if (cmd != RFID_CMD_MIFARE_AUTH1A && cmd != RFID_CMD_MIFARE_AUTH1B) {
1518                 DEBUGP("invalid auth command\n");
1519                 return -EINVAL;
1520         }
1521
1522         /* Initialize acmd */
1523         acmd.block_address = block & 0xff;
1524         acmd.auth_cmd = cmd;
1525         //acmd.serno = htonl(serno);
1526         acmd.serno = serno;
1527
1528 #if 1
1529         /* Clear Rx CRC */
1530         ret = rc632_clear_bits(h, RC632_REG_CHANNEL_REDUNDANCY,
1531                                 RC632_CR_RX_CRC_ENABLE);
1532 #else
1533         /* Clear Rx CRC, Set Tx CRC and Odd Parity */
1534         ret = rc632_reg_write(h, RC632_REG_CHANNEL_REDUNDANCY,
1535                                 RC632_CR_TX_CRC_ENABLE | RC632_CR_PARITY_ODD |
1536                                 RC632_CR_PARITY_ENABLE);
1537 #endif
1538         if (ret < 0)
1539                 return ret;
1540
1541         /* Send Authent1 Command */
1542         ret = rc632_fifo_write(h, sizeof(acmd), (unsigned char *)&acmd, 0x03);
1543         if (ret < 0)
1544                 return ret;
1545
1546         ret = rc632_reg_write(h, RC632_REG_COMMAND, RC632_CMD_AUTHENT1);
1547         if (ret < 0) {
1548                 DEBUGP("error during AUTHENT1");
1549                 return ret;
1550         }
1551
1552         /* Wait until transmitter is idle */
1553         ret = rc632_wait_idle(h, RC632_TMO_AUTH1);
1554         if (ret < 0)
1555                 return ret;
1556
1557         ret = rc632_reg_read(h, RC632_REG_SECONDARY_STATUS, &reg);
1558         if (ret < 0)
1559                 return ret;
1560         if (reg & 0x07) {
1561                 DEBUGP("bitframe?");
1562                 return -EIO;
1563         }
1564
1565         /* Clear Tx CRC */
1566         ret = rc632_clear_bits(h, RC632_REG_CHANNEL_REDUNDANCY,
1567                                 RC632_CR_TX_CRC_ENABLE);
1568         if (ret < 0)
1569                 return ret;
1570
1571         /* Send Authent2 Command */
1572         ret = rc632_reg_write(h, RC632_REG_COMMAND, RC632_CMD_AUTHENT2);
1573         if (ret < 0)
1574                 return ret;
1575
1576         /* Wait until transmitter is idle */
1577         ret = rc632_wait_idle(h, RC632_TMO_AUTH1);
1578         if (ret < 0)
1579                 return ret;
1580
1581         /* Check whether authentication was successful */
1582         ret = rc632_reg_read(h, RC632_REG_CONTROL, &reg);
1583         if (ret < 0)
1584                 return ret;
1585
1586         if (!(reg & RC632_CONTROL_CRYPTO1_ON)) {
1587                 DEBUGP("authentication not successful");
1588                 return -EACCES;
1589         }
1590
1591         return 0;
1592 }
1593
1594 /* transceive regular frame */
1595 static int
1596 rc632_mifare_transceive(struct rfid_asic_handle *handle,
1597                         const u_int8_t *tx_buf, unsigned int tx_len,
1598                         u_int8_t *rx_buf, unsigned int *rx_len,
1599                         u_int64_t timeout, unsigned int flags)
1600 {
1601         int ret;
1602         u_int8_t rxl = *rx_len & 0xff;
1603
1604         DEBUGP("entered\n");
1605         memset(rx_buf, 0, *rx_len);
1606
1607 #if 1
1608         ret = rc632_reg_write(handle, RC632_REG_CHANNEL_REDUNDANCY,
1609                                 (RC632_CR_PARITY_ENABLE |
1610                                  RC632_CR_PARITY_ODD |
1611                                  RC632_CR_TX_CRC_ENABLE |
1612                                  RC632_CR_RX_CRC_ENABLE));
1613 #else
1614         ret = rc632_clear_bits(handle, RC632_REG_CHANNEL_REDUNDANCY,
1615                                 RC632_CR_RX_CRC_ENABLE|RC632_CR_TX_CRC_ENABLE);
1616 #endif
1617         if (ret < 0)
1618                 return ret;
1619
1620         ret = rc632_transceive(handle, tx_buf, tx_len, rx_buf, &rxl, 0x32, 0);
1621         *rx_len = rxl;
1622         if (ret < 0)
1623                 return ret;
1624
1625
1626         return 0;
1627 }
1628
1629 const struct rfid_asic rc632 = {
1630         .name   = "Philips CL RC632",
1631         .fc     = ISO14443_FREQ_CARRIER,
1632         .priv.rc632 = {
1633                 .fn = {
1634                         .power_up = &rc632_power_up,
1635                         .power_down = &rc632_power_down,
1636                         .rf_power = &rc632_rf_power,
1637                         .transceive = &rc632_iso14443ab_transceive,
1638                         .iso14443a = {
1639                                 .init = &rc632_iso14443a_init,
1640                                 .transceive_sf = &rc632_iso14443a_transceive_sf,
1641                                 .transceive_acf = &rc632_iso14443a_transceive_acf,
1642                                 .set_speed = &rc632_iso14443a_set_speed,
1643                         },
1644                         .iso14443b = {
1645                                 .init = &rc632_iso14443b_init,
1646                         },
1647                         .iso15693 = {
1648                                 .init = &rc632_iso15693_init,
1649                         },
1650                         .mifare_classic = {
1651                                 .setkey = &rc632_mifare_set_key,
1652                                 .auth = &rc632_mifare_auth,
1653                         },
1654                 },
1655         },
1656 };