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