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;
 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 & 0x0f; /* lower nibble indicates bits */
 903         tx_bytes = acf->nvb >> 4;
 904         if (tx_last_bits) {
 905                 tx_bytes++;
 906                 rx_align = (tx_last_bits+1) % 8;/* rx frame complements tx */
 907         }
 908
 909         //rx_align = 8 - tx_last_bits;/* rx frame complements tx */
 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,
 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         /* copy the rest */
 927         memcpy(&acf->uid_bits[tx_bytes+1-2], &rx_buf[1], rx_len-1);
 928
 929         /* determine whether there was a collission */
 930         ret = rc632_reg_read(handle, RC632_REG_ERROR_FLAG, &error_flag);
 931         if (ret < 0)
 932                 return ret;
 933
 934         if (error_flag & RC632_ERR_FLAG_COL_ERR) {
 935                 /* retrieve bit of collission */
 936                 ret = rc632_reg_read(handle, RC632_REG_COLL_POS, &boc);
 937                 if (ret < 0)
 938                         return ret;
 939
 940                 /* bit of collission relative to start of part 1 of
 941                  * anticollision frame (!) */
 942                 *bit_of_col = 2*8 + boc;
 943         }
 944
 945         return 0;
 946 }
 947
 948 enum rc632_rate {
 949         RC632_RATE_106  = 0x00,
 950         RC632_RATE_212  = 0x01,
 951         RC632_RATE_424  = 0x02,
 952         RC632_RATE_848  = 0x03,
 953 };
 954
 955 struct rx_config {
 956         u_int8_t        subc_pulses;
 957         u_int8_t        rx_coding;
 958         u_int8_t        rx_threshold;
 959         u_int8_t        bpsk_dem_ctrl;
 960 };
 961
 962 struct tx_config {
 963         u_int8_t        rate;
 964         u_int8_t        mod_width;
 965 };
 966
 967 static struct rx_config rx_configs[] = {
 968         {
 969                 .subc_pulses    = RC632_RXCTRL1_SUBCP_8,
 970                 .rx_coding      = RC632_DECCTRL_MANCHESTER,
 971                 .rx_threshold   = 0x88,
 972                 .bpsk_dem_ctrl  = 0x00,
 973         },
 974         {
 975                 .subc_pulses    = RC632_RXCTRL1_SUBCP_4,
 976                 .rx_coding      = RC632_DECCTRL_BPSK,
 977                 .rx_threshold   = 0x50,
 978                 .bpsk_dem_ctrl  = 0x0c,
 979         },
 980         {
 981                 .subc_pulses    = RC632_RXCTRL1_SUBCP_2,
 982                 .rx_coding      = RC632_DECCTRL_BPSK,
 983                 .rx_threshold   = 0x50,
 984                 .bpsk_dem_ctrl  = 0x0c,
 985         },
 986         {
 987                 .subc_pulses    = RC632_RXCTRL1_SUBCP_1,
 988                 .rx_coding      = RC632_DECCTRL_BPSK,
 989                 .rx_threshold   = 0x50,
 990                 .bpsk_dem_ctrl  = 0x0c,
 991         },
 992 };
 993
 994 static struct tx_config tx_configs[] = {
 995         {
 996                 .rate           = RC632_CDRCTRL_RATE_106K,
 997                 .mod_width      = 0x13,
 998         },
 999         {
1000                 .rate           = RC632_CDRCTRL_RATE_212K,
1001                 .mod_width      = 0x07,
1002         },
1003         {
1004                 .rate           = RC632_CDRCTRL_RATE_424K,
1005                 .mod_width      = 0x03,
1006         },
1007         {
1008                 .rate           = RC632_CDRCTRL_RATE_848K,
1009                 .mod_width      = 0x01,
1010         },
1011 };
1012
1013 static int rc632_iso14443a_set_speed(struct rfid_asic_handle *handle,
1014                                      unsigned int tx, unsigned int rate)
1015 {
1016         int rc;
1017         u_int8_t reg;
1018
1019
1020         if (!tx) {
1021                 /* Rx */
1022                 if (rate > ARRAY_SIZE(rx_configs))
1023                         return -EINVAL;
1024
1025                 rc = rc632_set_bit_mask(handle, RC632_REG_RX_CONTROL1,
1026                                         RC632_RXCTRL1_SUBCP_MASK,
1027                                         rx_configs[rate].subc_pulses);
1028                 if (rc < 0)
1029                         return rc;
1030
1031                 rc = rc632_set_bit_mask(handle, RC632_REG_DECODER_CONTROL,
1032                                         RC632_DECCTRL_BPSK,
1033                                         rx_configs[rate].rx_coding);
1034                 if (rc < 0)
1035                         return rc;
1036
1037                 rc = rc632_reg_write(handle, RC632_REG_RX_THRESHOLD,
1038                                         rx_configs[rate].rx_threshold);
1039                 if (rc < 0)
1040                         return rc;
1041
1042                 if (rx_configs[rate].rx_coding == RC632_DECCTRL_BPSK) {
1043                         rc = rc632_reg_write(handle,
1044                                              RC632_REG_BPSK_DEM_CONTROL,
1045                                              rx_configs[rate].bpsk_dem_ctrl);
1046                         if (rc < 0)
1047                                 return rc;
1048                 }
1049         } else {
1050                 /* Tx */
1051                 if (rate > ARRAY_SIZE(tx_configs))
1052                         return -EINVAL;
1053
1054                 rc = rc632_set_bit_mask(handle, RC632_REG_CODER_CONTROL,
1055                                         RC632_CDRCTRL_RATE_MASK,
1056                                         tx_configs[rate].rate);
1057                 if (rc < 0)
1058                         return rc;
1059
1060                 rc = rc632_reg_write(handle, RC632_REG_MOD_WIDTH,
1061                                      tx_configs[rate].mod_width);
1062                 if (rc < 0)
1063                         return rc;
1064         }
1065
1066         return 0;
1067 }
1068
1069 static int rc632_iso14443b_init(struct rfid_asic_handle *handle)
1070 {
1071         int ret;
1072
1073         // FIXME: some FIFO work
1074
1075         /* flush fifo (our way) */
1076         ret = rc632_reg_write(handle, RC632_REG_CONTROL,
1077                               RC632_CONTROL_FIFO_FLUSH);
1078         if (ret < 0)
1079                 return ret;
1080
1081         ret = rc632_reg_write(handle, RC632_REG_TX_CONTROL,
1082                         (RC632_TXCTRL_TX1_RF_EN |
1083                          RC632_TXCTRL_TX2_RF_EN |
1084                          RC632_TXCTRL_TX2_INV |
1085                          RC632_TXCTRL_MOD_SRC_INT));
1086         if (ret < 0)
1087                 return ret;
1088
1089         ret = rc632_reg_write(handle, RC632_REG_CW_CONDUCTANCE, 0x3f);
1090         if (ret < 0)
1091                 return ret;
1092
1093         ret = rc632_reg_write(handle, RC632_REG_MOD_CONDUCTANCE, 0x04);
1094         if (ret < 0)
1095                 return ret;
1096
1097         ret = rc632_reg_write(handle, RC632_REG_CODER_CONTROL,
1098                               (RC632_CDRCTRL_TXCD_NRZ |
1099                                RC632_CDRCTRL_RATE_14443B));
1100         if (ret < 0)
1101                 return ret;
1102
1103         ret = rc632_reg_write(handle, RC632_REG_MOD_WIDTH, 0x13);
1104         if (ret < 0)
1105                 return ret;
1106
1107         ret = rc632_reg_write(handle, RC632_REG_MOD_WIDTH_SOF, 0x3f);
1108         if (ret < 0)
1109                 return ret;
1110
1111         ret = rc632_reg_write(handle, RC632_REG_TYPE_B_FRAMING,
1112                               (RC632_TBFRAMING_SOF_11L_3H |
1113                                (6 << RC632_TBFRAMING_SPACE_SHIFT) |
1114                                RC632_TBFRAMING_EOF_11));
1115         if (ret < 0)
1116                 return ret;
1117
1118         ret = rc632_reg_write(handle, RC632_REG_RX_CONTROL1,
1119                               (RC632_RXCTRL1_GAIN_35DB |
1120                                RC632_RXCTRL1_ISO14443 |
1121                                RC632_RXCTRL1_SUBCP_8));
1122         if (ret < 0)
1123                 return ret;
1124
1125         ret = rc632_reg_write(handle, RC632_REG_DECODER_CONTROL,
1126                               (RC632_DECCTRL_BPSK |
1127                                RC632_DECCTRL_RXFR_14443B));
1128         if (ret < 0)
1129                 return ret;
1130
1131         ret = rc632_reg_write(handle, RC632_REG_BIT_PHASE,
1132                                 CM5121_14443B_BITPHASE);
1133         if (ret < 0)
1134                 return ret;
1135
1136         ret = rc632_reg_write(handle, RC632_REG_RX_THRESHOLD,
1137                                 CM5121_14443B_THRESHOLD);
1138         if (ret < 0)
1139                 return ret;
1140
1141         ret = rc632_reg_write(handle, RC632_REG_BPSK_DEM_CONTROL,
1142                               ((0x2 & RC632_BPSKD_TAUB_MASK)<<RC632_BPSKD_TAUB_SHIFT |
1143                                (0x3 & RC632_BPSKD_TAUD_MASK)<<RC632_BPSKD_TAUD_SHIFT |
1144                                RC632_BPSKD_FILTER_AMP_DETECT |
1145                                RC632_BPSKD_NO_RX_EOF |
1146                                RC632_BPSKD_NO_RX_EGT));
1147         if (ret < 0)
1148                 return ret;
1149
1150         ret = rc632_reg_write(handle, RC632_REG_RX_CONTROL2,
1151                               (RC632_RXCTRL2_AUTO_PD |
1152                                RC632_RXCTRL2_DECSRC_INT));
1153         if (ret < 0)
1154                 return ret;
1155
1156         ret = rc632_reg_write(handle, RC632_REG_RX_WAIT, 0x03);
1157         if (ret < 0)
1158                 return ret;
1159
1160         ret = rc632_reg_write(handle, RC632_REG_CHANNEL_REDUNDANCY,
1161                               (RC632_CR_TX_CRC_ENABLE |
1162                                RC632_CR_RX_CRC_ENABLE |
1163                                RC632_CR_CRC3309));
1164         if (ret < 0)
1165                 return ret;
1166
1167         ret = rc632_reg_write(handle, RC632_REG_CRC_PRESET_LSB, 0xff);
1168         if (ret < 0)
1169                 return ret;
1170
1171         ret = rc632_reg_write(handle, RC632_REG_CRC_PRESET_MSB, 0xff);
1172         if (ret < 0)
1173                 return ret;
1174
1175         return 0;
1176 }
1177
1178 static int
1179 rc632_iso15693_init(struct rfid_asic_handle *h)
1180 {
1181         int ret;
1182
1183         ret = rc632_reg_write(h, RC632_REG_TX_CONTROL,
1184                                                 (RC632_TXCTRL_MOD_SRC_INT |
1185                                                  RC632_TXCTRL_TX2_INV |
1186                                                  RC632_TXCTRL_TX2_RF_EN |
1187                                                  RC632_TXCTRL_TX1_RF_EN));
1188         if (ret < 0)
1189                 return ret;
1190
1191         ret = rc632_reg_write(h, RC632_REG_CW_CONDUCTANCE, 0x3f);
1192         if (ret < 0)
1193                 return ret;
1194
1195         ret = rc632_reg_write(h, RC632_REG_MOD_CONDUCTANCE, 0x03);
1196         if (ret < 0)
1197                 return ret;
1198
1199         ret = rc632_reg_write(h, RC632_REG_CODER_CONTROL,
1200                                                 (RC632_CDRCTRL_RATE_15693 |
1201                                                  0x03)); /* FIXME */
1202         if (ret < 0)
1203                 return ret;
1204
1205         ret = rc632_reg_write(h, RC632_REG_MOD_WIDTH, 0x3f);
1206         if (ret < 0)
1207                 return ret;
1208
1209         ret = rc632_reg_write(h, RC632_REG_MOD_WIDTH_SOF, 0x3f);
1210         if (ret < 0)
1211                 return ret;
1212
1213         ret = rc632_reg_write(h, RC632_REG_TYPE_B_FRAMING, 0x00);
1214         if (ret < 0)
1215                 return ret;
1216
1217         ret = rc632_reg_write(h, RC632_REG_RX_CONTROL1,
1218                                                 (RC632_RXCTRL1_SUBCP_16 |
1219                                                  RC632_RXCTRL1_ISO15693 |
1220                                                  RC632_RXCTRL1_GAIN_35DB));
1221         if (ret < 0)
1222                 return ret;
1223
1224         ret = rc632_reg_write(h, RC632_REG_DECODER_CONTROL,
1225                                                 (RC632_DECCTRL_RXFR_15693 |
1226                                                  RC632_DECCTRL_RX_INVERT));
1227         if (ret < 0)
1228                 return ret;
1229
1230         ret = rc632_reg_write(h, RC632_REG_BIT_PHASE, 0xe0);
1231         if (ret < 0)
1232                 return ret;
1233
1234         ret = rc632_reg_write(h, RC632_REG_RX_THRESHOLD, 0xff);
1235         if (ret < 0)
1236                 return ret;
1237
1238         ret = rc632_reg_write(h, RC632_REG_BPSK_DEM_CONTROL, 0x00);
1239         if (ret < 0)
1240                 return ret;
1241
1242         ret = rc632_reg_write(h, RC632_REG_RX_CONTROL2,
1243                                                 (RC632_RXCTRL2_AUTO_PD |
1244                                                  RC632_RXCTRL2_DECSRC_INT));
1245         if (ret < 0)
1246                 return ret;
1247
1248         ret = rc632_reg_write(h, RC632_REG_CHANNEL_REDUNDANCY,
1249                                                 (RC632_CR_CRC3309 |
1250                                                  RC632_CR_RX_CRC_ENABLE |
1251                                                  RC632_CR_TX_CRC_ENABLE));
1252         if (ret < 0)
1253                 return ret;
1254
1255         ret = rc632_reg_write(h, RC632_REG_CRC_PRESET_LSB, 0xff);
1256         if (ret < 0)
1257                 return ret;
1258
1259         ret = rc632_reg_write(h, RC632_REG_CRC_PRESET_MSB, 0xff);
1260         if (ret < 0)
1261                 return ret;
1262
1263         return 0;
1264 }
1265
1266 static int
1267 rc632_iso15693_icode_init(struct rfid_asic_handle *h)
1268 {
1269         int ret;
1270
1271         ret = rc632_reg_write(h, RC632_REG_TX_CONTROL,
1272                                                 (RC632_TXCTRL_MOD_SRC_INT |
1273                                                  RC632_TXCTRL_TX2_INV |
1274                                                  RC632_TXCTRL_TX2_RF_EN |
1275                                                  RC632_TXCTRL_TX1_RF_EN));
1276         if (ret < 0)
1277                 return ret;
1278
1279         ret = rc632_reg_write(h, RC632_REG_CW_CONDUCTANCE, 0x3f);
1280         if (ret < 0)
1281                 return ret;
1282
1283         ret = rc632_reg_write(h, RC632_REG_MOD_CONDUCTANCE, 0x02);
1284         if (ret < 0)
1285                 return ret;
1286
1287         ret = rc632_reg_write(h, RC632_REG_CODER_CONTROL, 0x2c);
1288         if (ret < 0)
1289                 return ret;
1290
1291         ret = rc632_reg_write(h, RC632_REG_MOD_WIDTH, 0x3f);
1292         if (ret < 0)
1293                 return ret;
1294
1295         ret = rc632_reg_write(h, RC632_REG_MOD_WIDTH_SOF, 0x3f);
1296         if (ret < 0)
1297                 return ret;
1298
1299         ret = rc632_reg_write(h, RC632_REG_MOD_WIDTH_SOF, 0x3f);
1300         if (ret < 0)
1301                 return ret;
1302
1303         ret = rc632_reg_write(h, RC632_REG_TYPE_B_FRAMING, 0x00);
1304         if (ret < 0)
1305                 return ret;
1306
1307         ret = rc632_reg_write(h, RC632_REG_RX_CONTROL1, 0x8b); /* FIXME */
1308         if (ret < 0)
1309                 return ret;
1310
1311         ret = rc632_reg_write(h, RC632_REG_DECODER_CONTROL, 0x00);
1312         if (ret < 0)
1313                 return ret;
1314
1315         ret = rc632_reg_write(h, RC632_REG_BIT_PHASE, 0x52);
1316         if (ret < 0)
1317                 return ret;
1318
1319         ret = rc632_reg_write(h, RC632_REG_RX_THRESHOLD, 0x66);
1320         if (ret < 0)
1321                 return ret;
1322
1323         ret = rc632_reg_write(h, RC632_REG_BPSK_DEM_CONTROL, 0x00);
1324         if (ret < 0)
1325                 return ret;
1326
1327         ret = rc632_reg_write(h, RC632_REG_RX_CONTROL2,
1328                                                 RC632_RXCTRL2_DECSRC_INT);
1329         if (ret < 0)
1330                 return ret;
1331
1332         ret = rc632_reg_write(h, RC632_REG_CHANNEL_REDUNDANCY,
1333                                                 (RC632_CR_RX_CRC_ENABLE |
1334                                                  RC632_CR_TX_CRC_ENABLE));
1335         ret = rc632_reg_write(h, RC632_REG_CRC_PRESET_LSB, 0xfe);
1336         if (ret < 0)
1337                 return ret;
1338
1339         ret = rc632_reg_write(h, RC632_REG_CRC_PRESET_MSB, 0xff);
1340         if (ret < 0)
1341                 return ret;
1342
1343         return 0;
1344 }
1345
1346 static int
1347 rc632_iso15693_icl_init(struct rfid_asic_handle *h)
1348 {
1349         int ret;
1350
1351         /* ICL */
1352
1353         ret = rc632_reg_write(h, RC632_REG_TX_CONTROL,
1354                                                 (RC632_TXCTRL_MOD_SRC_INT |
1355                                                  RC632_TXCTRL_TX2_INV |
1356                                                  RC632_TXCTRL_TX2_RF_EN |
1357                                                  RC632_TXCTRL_TX1_RF_EN));
1358         if (ret < 0)
1359                 return ret;
1360
1361         ret = rc632_reg_write(h, RC632_REG_CW_CONDUCTANCE, 0x3f);
1362         if (ret < 0)
1363                 return ret;
1364
1365         ret = rc632_reg_write(h, RC632_REG_MOD_CONDUCTANCE, 0x11);
1366         if (ret < 0)
1367                 return ret;
1368
1369         ret = rc632_reg_write(h, RC632_REG_CODER_CONTROL,
1370                                                 (RC632_CDRCTRL_RATE_15693 |
1371                                                  RC632_CDRCTRL_TXCD_ICODE_STD |
1372                                                  0x03)); /* FIXME */
1373         if (ret < 0)
1374                 return ret;
1375
1376         ret = rc632_reg_write(h, RC632_REG_MOD_WIDTH, 0x3f);
1377         if (ret < 0)
1378                 return ret;
1379
1380         ret = rc632_reg_write(h, RC632_REG_MOD_WIDTH_SOF, 0x3f);
1381         if (ret < 0)
1382                 return ret;
1383         ret = rc632_reg_write(h, RC632_REG_RX_CONTROL1,
1384                                                 (RC632_RXCTRL1_SUBCP_16|
1385                                                  RC632_RXCTRL1_ISO15693|
1386                                                  RC632_RXCTRL1_GAIN_35DB));
1387         if (ret < 0)
1388                 return ret;
1389         ret = rc632_reg_write(h, RC632_REG_DECODER_CONTROL,
1390                                                 (RC632_DECCTRL_RX_INVERT|
1391                                                  RC632_DECCTRL_RXFR_15693));
1392         if (ret < 0)
1393                 return ret;
1394
1395         ret = rc632_reg_write(h, RC632_REG_BIT_PHASE, 0xbd);
1396         if (ret < 0)
1397                 return ret;
1398
1399         ret = rc632_reg_write(h, RC632_REG_RX_THRESHOLD, 0xff);
1400         if (ret < 0)
1401                 return ret;
1402
1403         ret = rc632_reg_write(h, RC632_REG_BPSK_DEM_CONTROL, 0x00);
1404         if (ret < 0)
1405                 return ret;
1406
1407         ret = rc632_reg_write(h, RC632_REG_RX_CONTROL2,
1408                                                 RC632_RXCTRL2_DECSRC_INT);
1409         if (ret < 0)
1410                 return ret;
1411
1412         ret = rc632_reg_write(h, RC632_REG_CHANNEL_REDUNDANCY, 0x00);
1413         if (ret < 0)
1414                 return ret;
1415
1416         ret = rc632_reg_write(h, RC632_REG_CRC_PRESET_LSB, 0x12);
1417         if (ret < 0)
1418                 return ret;
1419
1420         ret = rc632_reg_write(h, RC632_REG_CRC_PRESET_MSB, 0xe0);
1421         if (ret < 0)
1422                 return ret;
1423
1424         return 0;
1425 }
1426
1427 struct mifare_authcmd {
1428         u_int8_t auth_cmd;
1429         u_int8_t block_address;
1430         u_int32_t serno;        /* lsb 1 2 msb */
1431 } __attribute__ ((packed));
1432
1433
1434 #define RFID_MIFARE_KEY_LEN 6
1435 #define RFID_MIFARE_KEY_CODED_LEN 12
1436
1437 /* Transform crypto1 key from generic 6byte into rc632 specific 12byte */
1438 static int
1439 rc632_mifare_transform_key(const u_int8_t *key6, u_int8_t *key12)
1440 {
1441         int i;
1442         u_int8_t ln;
1443         u_int8_t hn;
1444
1445         for (i = 0; i < RFID_MIFARE_KEY_LEN; i++) {
1446                 ln = key6[i] & 0x0f;
1447                 hn = key6[i] >> 4;
1448                 key12[i * 2 + 1] = (~ln << 4) | ln;
1449                 key12[i * 2] = (~hn << 4) | hn;
1450         }
1451         return 0;
1452 }
1453
1454 static int
1455 rc632_mifare_set_key(struct rfid_asic_handle *h, const u_int8_t *key)
1456 {
1457         u_int8_t coded_key[RFID_MIFARE_KEY_CODED_LEN];
1458         u_int8_t reg;
1459         int ret;
1460
1461         ret = rc632_mifare_transform_key(key, coded_key);
1462         if (ret < 0)
1463                 return ret;
1464
1465         /* Terminate probably running command */
1466         ret = rc632_reg_write(h, RC632_REG_COMMAND, RC632_CMD_IDLE);
1467         if (ret < 0)
1468                 return ret;
1469
1470         ret = rc632_reg_write(h, RC632_REG_COMMAND, RC632_CMD_LOAD_KEY);
1471         if (ret < 0)
1472                 return ret;
1473
1474         ret = rc632_fifo_write(h, RFID_MIFARE_KEY_CODED_LEN, coded_key, 0x03);
1475         if (ret < 0)
1476                 return ret;
1477
1478         ret = rc632_wait_idle(h, RC632_TMO_AUTH1);
1479         if (ret < 0)
1480                 return ret;
1481
1482         ret = rc632_reg_read(h, RC632_REG_ERROR_FLAG, &reg);
1483         if (ret < 0)
1484                 return ret;
1485
1486         if (reg & RC632_ERR_FLAG_KEY_ERR)
1487                 return -EINVAL;
1488
1489         return 0;
1490 }
1491
1492 static int
1493 rc632_mifare_auth(struct rfid_asic_handle *h, u_int8_t cmd, u_int32_t serno,
1494                   u_int8_t block)
1495 {
1496         int ret;
1497         struct mifare_authcmd acmd;
1498         u_int8_t reg;
1499
1500         if (cmd != RFID_CMD_MIFARE_AUTH1A && cmd != RFID_CMD_MIFARE_AUTH1B) {
1501                 DEBUGP("invalid auth command\n");
1502                 return -EINVAL;
1503         }
1504
1505         /* Initialize acmd */
1506         acmd.block_address = block & 0xff;
1507         acmd.auth_cmd = cmd;
1508         //acmd.serno = htonl(serno);
1509         acmd.serno = serno;
1510
1511 #if 1
1512         /* Clear Rx CRC */
1513         ret = rc632_clear_bits(h, RC632_REG_CHANNEL_REDUNDANCY,
1514                                 RC632_CR_RX_CRC_ENABLE);
1515 #else
1516         /* Clear Rx CRC, Set Tx CRC and Odd Parity */
1517         ret = rc632_reg_write(h, RC632_REG_CHANNEL_REDUNDANCY,
1518                                 RC632_CR_TX_CRC_ENABLE | RC632_CR_PARITY_ODD |
1519                                 RC632_CR_PARITY_ENABLE);
1520 #endif
1521         if (ret < 0)
1522                 return ret;
1523
1524         /* Send Authent1 Command */
1525         ret = rc632_fifo_write(h, sizeof(acmd), (unsigned char *)&acmd, 0x03);
1526         if (ret < 0)
1527                 return ret;
1528
1529         ret = rc632_reg_write(h, RC632_REG_COMMAND, RC632_CMD_AUTHENT1);
1530         if (ret < 0) {
1531                 DEBUGP("error during AUTHENT1");
1532                 return ret;
1533         }
1534
1535         /* Wait until transmitter is idle */
1536         ret = rc632_wait_idle(h, RC632_TMO_AUTH1);
1537         if (ret < 0)
1538                 return ret;
1539
1540         ret = rc632_reg_read(h, RC632_REG_SECONDARY_STATUS, &reg);
1541         if (ret < 0)
1542                 return ret;
1543         if (reg & 0x07) {
1544                 DEBUGP("bitframe?");
1545                 return -EIO;
1546         }
1547
1548         /* Clear Tx CRC */
1549         ret = rc632_clear_bits(h, RC632_REG_CHANNEL_REDUNDANCY,
1550                                 RC632_CR_TX_CRC_ENABLE);
1551         if (ret < 0)
1552                 return ret;
1553
1554         /* Send Authent2 Command */
1555         ret = rc632_reg_write(h, RC632_REG_COMMAND, RC632_CMD_AUTHENT2);
1556         if (ret < 0)
1557                 return ret;
1558
1559         /* Wait until transmitter is idle */
1560         ret = rc632_wait_idle(h, RC632_TMO_AUTH1);
1561         if (ret < 0)
1562                 return ret;
1563
1564         /* Check whether authentication was successful */
1565         ret = rc632_reg_read(h, RC632_REG_CONTROL, &reg);
1566         if (ret < 0)
1567                 return ret;
1568
1569         if (!(reg & RC632_CONTROL_CRYPTO1_ON)) {
1570                 DEBUGP("authentication not successful");
1571                 return -EACCES;
1572         }
1573
1574         return 0;
1575 }
1576
1577 /* transceive regular frame */
1578 static int
1579 rc632_mifare_transceive(struct rfid_asic_handle *handle,
1580                         const u_int8_t *tx_buf, unsigned int tx_len,
1581                         u_int8_t *rx_buf, unsigned int *rx_len,
1582                         u_int64_t timeout, unsigned int flags)
1583 {
1584         int ret;
1585         u_int8_t rxl = *rx_len & 0xff;
1586
1587         DEBUGP("entered\n");
1588         memset(rx_buf, 0, *rx_len);
1589
1590 #if 1
1591         ret = rc632_reg_write(handle, RC632_REG_CHANNEL_REDUNDANCY,
1592                                 (RC632_CR_PARITY_ENABLE |
1593                                  RC632_CR_PARITY_ODD |
1594                                  RC632_CR_TX_CRC_ENABLE |
1595                                  RC632_CR_RX_CRC_ENABLE));
1596 #else
1597         ret = rc632_clear_bits(handle, RC632_REG_CHANNEL_REDUNDANCY,
1598                                 RC632_CR_RX_CRC_ENABLE|RC632_CR_TX_CRC_ENABLE);
1599 #endif
1600         if (ret < 0)
1601                 return ret;
1602
1603         ret = rc632_transceive(handle, tx_buf, tx_len, rx_buf, &rxl, 0x32, 0);
1604         *rx_len = rxl;
1605         if (ret < 0)
1606                 return ret;
1607
1608
1609         return 0;
1610 }
1611
1612 const struct rfid_asic rc632 = {
1613         .name   = "Philips CL RC632",
1614         .fc     = ISO14443_FREQ_CARRIER,
1615         .priv.rc632 = {
1616                 .fn = {
1617                         .power_up = &rc632_power_up,
1618                         .power_down = &rc632_power_down,
1619                         .turn_on_rf = &rc632_turn_on_rf,
1620                         .turn_off_rf = &rc632_turn_off_rf,
1621                         .transceive = &rc632_iso14443ab_transceive,
1622                         .iso14443a = {
1623                                 .init = &rc632_iso14443a_init,
1624                                 .transceive_sf = &rc632_iso14443a_transceive_sf,
1625                                 .transceive_acf = &rc632_iso14443a_transceive_acf,
1626                                 .set_speed = &rc632_iso14443a_set_speed,
1627                         },
1628                         .iso14443b = {
1629                                 .init = &rc632_iso14443b_init,
1630                         },
1631                         .iso15693 = {
1632                                 .init = &rc632_iso15693_init,
1633                         },
1634                         .mifare_classic = {
1635                                 .setkey = &rc632_mifare_set_key,
1636                                 .auth = &rc632_mifare_auth,
1637                         },
1638                 },
1639         },
1640 };