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

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