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