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

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