X-Git-Url: http://git.rot13.org/?a=blobdiff_plain;f=src%2Frfid_asic_rc632.c;h=4286565da6dca5952f5be6329237d95fe7d3e0e3;hb=a7c201deb99239d6d98a45b3cc642d8554231a22;hp=ac3df2c5ab40ec0591b4a11ca79a2991fbaf003b;hpb=72cfffa027a83ee186153e522088ef70dbfe8338;p=librfid diff --git a/src/rfid_asic_rc632.c b/src/rfid_asic_rc632.c index ac3df2c..4286565 100644 --- a/src/rfid_asic_rc632.c +++ b/src/rfid_asic_rc632.c @@ -1,6 +1,6 @@ /* Generic Philips CL RC632 Routines * - * (C) Harald Welte + * (C) 2005-2006 Harald Welte * */ @@ -16,13 +16,16 @@ * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA */ +#define DEBUG_LIBRFID + #include #include #include #include +#include #include #include @@ -30,17 +33,27 @@ #include #include #include +#include #include #include "rfid_iso14443_common.h" #include "rc632.h" -//#include "rc632_14443a.h" +#ifdef __MINGW32__ +#include "usleep.h" +#endif/*__MINGW32__*/ + +#define RC632_TMO_AUTH1 140 -#define RC632_TMO_AUTH1 14000 +#define TIMER_RELAX_FACTOR 10 #define ENTER() DEBUGP("entering\n") -struct rfid_asic rc632; +const struct rfid_asic rc632; + +struct register_file { + u_int8_t reg; + u_int8_t val; +}; /* Register and FIFO Access functions */ static int @@ -135,33 +148,51 @@ rc632_clear_bits(struct rfid_asic_handle *handle, return rc632_reg_write(handle, reg, (tmp & ~val)&0xff); } -static int -rc632_turn_on_rf(struct rfid_asic_handle *handle) +static int +rc632_clear_irqs(struct rfid_asic_handle *handle, u_int8_t bits) { - ENTER(); - return rc632_set_bits(handle, RC632_REG_TX_CONTROL, 0x03); + return rc632_reg_write(handle, RC632_REG_INTERRUPT_RQ, (~RC632_INT_SET)&bits); } static int -rc632_turn_off_rf(struct rfid_asic_handle *handle) +rc632_rf_power(struct rfid_asic_handle *handle, int on) { ENTER(); - return rc632_clear_bits(handle, RC632_REG_TX_CONTROL, 0x03); + if (on) + return rc632_set_bits(handle, RC632_REG_TX_CONTROL, + RC632_TXCTRL_TX1_RF_EN| + RC632_TXCTRL_TX2_RF_EN); + else + return rc632_clear_bits(handle, RC632_REG_TX_CONTROL, + RC632_TXCTRL_TX1_RF_EN| + RC632_TXCTRL_TX2_RF_EN); } static int -rc632_power_up(struct rfid_asic_handle *handle) +rc632_power(struct rfid_asic_handle *handle, int on) { ENTER(); - return rc632_clear_bits(handle, RC632_REG_CONTROL, - RC632_CONTROL_POWERDOWN); + if (on) + return rc632_clear_bits(handle, RC632_REG_CONTROL, + RC632_CONTROL_POWERDOWN); + else + return rc632_set_bits(handle, RC632_REG_CONTROL, + RC632_CONTROL_POWERDOWN); } static int -rc632_power_down(struct rfid_asic_handle *handle) +rc632_execute_script(struct rfid_asic_handle *h, struct register_file *f, + int len) { - return rc632_set_bits(handle, RC632_REG_CONTROL, - RC632_CONTROL_POWERDOWN); + int i, ret; + + for (i = 0; i < len; i++) { + ret = rc632_reg_write(h, f[i].reg, f[i].val); + if (ret < 0) + return ret; + } + + return 0; } /* calculate best 8bit prescaler and divisor for given usec timeout */ @@ -171,7 +202,7 @@ static int best_prescaler(u_int64_t timeout, u_int8_t *prescaler, u_int8_t best_prescaler, best_divisor, i; int64_t smallest_diff; - smallest_diff = 0x7fffffffffffffff; + smallest_diff = LLONG_MAX; best_prescaler = 0; for (i = 0; i < 21; i++) { @@ -213,6 +244,8 @@ rc632_timer_set(struct rfid_asic_handle *handle, int ret; u_int8_t prescaler, divisor; + timeout *= TIMER_RELAX_FACTOR; + ret = best_prescaler(timeout, &prescaler, &divisor); ret = rc632_reg_write(handle, RC632_REG_TIMER_CLOCK, @@ -232,27 +265,34 @@ rc632_timer_set(struct rfid_asic_handle *handle, } /* Wait until RC632 is idle or TIMER IRQ has happened */ -static rc632_wait_idle_timer(struct rfid_asic_handle *handle) +static int rc632_wait_idle_timer(struct rfid_asic_handle *handle) { int ret; - u_int8_t irq, cmd; + u_int8_t stat, irq, cmd; while (1) { - rc632_reg_read(handle, RC632_REG_PRIMARY_STATUS, &irq); - rc632_reg_read(handle, RC632_REG_ERROR_FLAG, &irq); - ret = rc632_reg_read(handle, RC632_REG_INTERRUPT_RQ, &irq); - if (ret < 0) - return ret; - - /* FIXME: currently we're lazy: If we actually received - * something even after the timer expired, we accept it */ - if (irq & RC632_IRQ_TIMER && !(irq & RC632_IRQ_RX)) { - u_int8_t foo; - rc632_reg_read(handle, RC632_REG_PRIMARY_STATUS, &foo); - if (foo & 0x04) - rc632_reg_read(handle, RC632_REG_ERROR_FLAG, &foo); + rc632_reg_read(handle, RC632_REG_PRIMARY_STATUS, &stat); + DEBUGP_STATUS_FLAG(stat); + if (stat & RC632_STAT_ERR) { + u_int8_t err; + rc632_reg_read(handle, RC632_REG_ERROR_FLAG, &err); + DEBUGP_ERROR_FLAG(err); + if (err & (RC632_ERR_FLAG_COL_ERR | + RC632_ERR_FLAG_PARITY_ERR | + RC632_ERR_FLAG_FRAMING_ERR | + RC632_ERR_FLAG_CRC_ERR)) + return -EIO; + } + if (stat & RC632_STAT_IRQ) { + ret = rc632_reg_read(handle, RC632_REG_INTERRUPT_RQ, &irq); + if (ret < 0) + return ret; + DEBUGP_INTERRUPT_FLAG(irq); - return -110; + if (irq & RC632_IRQ_TIMER && !(irq & RC632_IRQ_RX)) { + DEBUGP("timer expired before RX!!\n"); + return -ETIMEDOUT; + } } ret = rc632_reg_read(handle, RC632_REG_COMMAND, &cmd); @@ -276,25 +316,39 @@ rc632_wait_idle(struct rfid_asic_handle *handle, u_int64_t timeout) int ret, cycles = 0; #define USLEEP_PER_CYCLE 128 + timeout *= TIMER_RELAX_FACTOR; + while (cmd != 0) { ret = rc632_reg_read(handle, RC632_REG_COMMAND, &cmd); if (ret < 0) return ret; - if (cmd == 0) { - /* FIXME: read second time ?? */ - return 0; - } - { u_int8_t foo; rc632_reg_read(handle, RC632_REG_PRIMARY_STATUS, &foo); - if (foo & 0x04) + DEBUGP_STATUS_FLAG(foo); + /* check if Error has occured (ERR flag set) */ + if (foo & RC632_STAT_ERR) { rc632_reg_read(handle, RC632_REG_ERROR_FLAG, &foo); + DEBUGP_ERROR_FLAG(foo); + } + /* check if IRQ has occurred (IRQ flag set)*/ + if (foo & RC632_STAT_IRQ) { + ret = rc632_reg_read(handle, RC632_REG_INTERRUPT_RQ, &foo); + DEBUGP_INTERRUPT_FLAG(foo); + /* clear all interrupts */ + rc632_clear_irqs(handle, 0xff); + } + } + if (cmd == 0) { + /* FIXME: read second time ?? */ + DEBUGP("cmd == 0 (IDLE)\n"); + return 0; } /* Abort after some timeout */ - if (cycles > timeout*100/USLEEP_PER_CYCLE) { + if (cycles > timeout/USLEEP_PER_CYCLE) { + DEBUGP("timeout...\n"); return -ETIMEDOUT; } @@ -314,6 +368,8 @@ rc632_transmit(struct rfid_asic_handle *handle, int ret, cur_len; const u_int8_t *cur_buf = buf; + DEBUGP("timeout=%u, tx_len=%u\n", timeout, len); + if (len > 64) cur_len = 64; else @@ -348,7 +404,7 @@ rc632_transmit(struct rfid_asic_handle *handle, static int tcl_toggle_pcb(struct rfid_asic_handle *handle) { - // FIXME: toggle something between 0x0a and 0x0b + /* FIXME: toggle something between 0x0a and 0x0b */ return 0; } @@ -361,25 +417,38 @@ rc632_transceive(struct rfid_asic_handle *handle, u_int64_t timer, unsigned int toggle) { - int ret, cur_tx_len; + int ret, cur_tx_len, i; u_int8_t rx_avail; const u_int8_t *cur_tx_buf = tx_buf; - DEBUGP("timer = %u\n", timer); + DEBUGP("timeout=%u, rx_len=%u, tx_len=%u\n", timer, *rx_len, tx_len); if (tx_len > 64) cur_tx_len = 64; else cur_tx_len = tx_len; - ret = rc632_timer_set(handle, timer*10); - if (ret < 0) - return ret; - + ret = rc632_reg_write(handle, RC632_REG_COMMAND, 0x00); /* clear all interrupts */ ret = rc632_reg_write(handle, RC632_REG_INTERRUPT_RQ, 0x7f); + ret = rc632_reg_write(handle, RC632_REG_ERROR_FLAG, 0xff); + + { u_int8_t tmp; + rc632_reg_read(handle, RC632_REG_PRIMARY_STATUS, &tmp); + DEBUGP_STATUS_FLAG(tmp); + rc632_reg_read(handle, RC632_REG_PRIMARY_STATUS, &tmp); + DEBUGP_STATUS_FLAG(tmp); + rc632_reg_read(handle, RC632_REG_PRIMARY_STATUS, &tmp); + DEBUGP_STATUS_FLAG(tmp); + rc632_reg_read(handle, RC632_REG_ERROR_FLAG, &tmp); + DEBUGP_ERROR_FLAG(tmp); + } + ret = rc632_timer_set(handle, timer); + if (ret < 0) + return ret; + do { ret = rc632_fifo_write(handle, cur_tx_len, cur_tx_buf, 0x03); if (ret < 0) @@ -401,7 +470,6 @@ rc632_transceive(struct rfid_asic_handle *handle, return ret; cur_tx_len = 64 - fifo_fill; - printf("refilling tx fifo with %u bytes\n", cur_tx_len); } else cur_tx_len = 0; @@ -410,8 +478,10 @@ rc632_transceive(struct rfid_asic_handle *handle, if (toggle == 1) tcl_toggle_pcb(handle); - //ret = rc632_wait_idle_timer(handle); - ret = rc632_wait_idle(handle, timer); + ret = rc632_wait_idle_timer(handle); + //ret = rc632_wait_idle(handle, timer); + + DEBUGP("rc632_wait_idle >> ret=%d %s\n",ret,(ret==-ETIMEDOUT)?"ETIMEDOUT":""); if (ret < 0) return ret; @@ -420,23 +490,94 @@ rc632_transceive(struct rfid_asic_handle *handle, return ret; if (rx_avail > *rx_len) - printf("rx_avail(%d) > rx_len(%d), JFYI\n", rx_avail, *rx_len); + DEBUGP("rx_avail(%d) > rx_len(%d), JFYI\n", rx_avail, *rx_len); else if (*rx_len > rx_avail) *rx_len = rx_avail; + DEBUGP("rx_len == %d\n",*rx_len); + + if (rx_avail == 0) { + u_int8_t tmp; + + for (i = 0; i < 1; i++){ + rc632_reg_read(handle, RC632_REG_PRIMARY_STATUS, &tmp); + DEBUGP_STATUS_FLAG(tmp); + rc632_reg_read(handle, RC632_REG_ERROR_FLAG, &tmp); + DEBUGP_ERROR_FLAG(tmp); + } + rc632_reg_read(handle, RC632_REG_CHANNEL_REDUNDANCY, &tmp); + + //return 0; + return -1; + } + + return rc632_fifo_read(handle, *rx_len, rx_buf); + /* FIXME: discard addidional bytes in FIFO */ +} + + +static int +rc632_receive(struct rfid_asic_handle *handle, + u_int8_t *rx_buf, + u_int8_t *rx_len, + u_int64_t timer) +{ + int ret, cur_tx_len, i; + u_int8_t rx_avail; + + DEBUGP("timeout=%u, rx_len=%u\n", timer, *rx_len); + ret = rc632_reg_write(handle, RC632_REG_COMMAND, 0x00); /* IDLE */ + /* clear all interrupts */ + ret = rc632_reg_write(handle, RC632_REG_INTERRUPT_RQ, 0x7f); + + ret = rc632_timer_set(handle, timer); + if (ret < 0) + return ret; + + ret = rc632_reg_write(handle, RC632_REG_COMMAND,RC632_CMD_RECEIVE); + if (ret < 0) + return ret; + + /* the timer cannot start in hardware based on the command we just + * sent. this means that our timing will always be quite a bit more lax, + * i.e. we'll always wait for a bit longer than the specs ask us to. */ + ret = rc632_set_bits(handle, RC632_REG_CONTROL, + RC632_CONTROL_TIMER_START); + if (ret < 0) + return ret; + + //ret = rc632_wait_idle(handle, timer); + ret = rc632_wait_idle_timer(handle); + if (ret < 0) + return ret; + + ret = rc632_reg_read(handle, RC632_REG_FIFO_LENGTH, &rx_avail); + if (ret < 0) + return ret; + + if (rx_avail > *rx_len) { + //printf("rx_avail(%d) > rx_len(%d), JFYI\n", rx_avail, *rx_len); + } else if (*rx_len > rx_avail) + *rx_len = rx_avail; + if (rx_avail == 0) { u_int8_t tmp; DEBUGP("rx_len == 0\n"); - rc632_reg_read(handle, RC632_REG_ERROR_FLAG, &tmp); - rc632_reg_read(handle, RC632_REG_CHANNEL_REDUNDANCY, &tmp); + for (i = 0; i < 1; i++) { + rc632_reg_read(handle, RC632_REG_PRIMARY_STATUS, &tmp); + DEBUGP_STATUS_FLAG(tmp); + rc632_reg_read(handle, RC632_REG_ERROR_FLAG, &tmp); + DEBUGP_ERROR_FLAG(tmp); + } + rc632_reg_read(handle, RC632_REG_CHANNEL_REDUNDANCY, &tmp); return -1; } return rc632_fifo_read(handle, *rx_len, rx_buf); - /* FIXME: discard addidional bytes in FIFO */ + /* FIXME: discard additional bytes in FIFO */ } static int @@ -464,7 +605,7 @@ rc632_read_eeprom(struct rfid_asic_handle *handle) if (ret < 0) return ret; - // FIXME: do something with eeprom contents + /* FIXME: do something with eeprom contents */ return ret; } @@ -491,7 +632,7 @@ rc632_calc_crc16_from(struct rfid_asic_handle *handle) if (ret < 0) return ret; - usleep(10000); // FIXME: no checking for cmd completion? + usleep(10000); /* FIXME: no checking for cmd completion? * ret = rc632_reg_read(handle, RC632_REG_CRC_RESULT_LSB, &crc_lsb); if (ret < 0) @@ -501,7 +642,7 @@ rc632_calc_crc16_from(struct rfid_asic_handle *handle) if (ret < 0) return ret; - // FIXME: what to do with crc result? + /* FIXME: what to do with crc result? */ return ret; } @@ -509,17 +650,14 @@ rc632_calc_crc16_from(struct rfid_asic_handle *handle) int rc632_register_dump(struct rfid_asic_handle *handle, u_int8_t *buf) { - int ret; + int ret = 0; u_int8_t i; - for (i = 0; i <= 0x3f; i++) { - ret = rc632_reg_read(handle, i, &buf[i]); - // do we want error checks? - } - return 0; -} - + for (i = 0; i <= 0x3f; i++) + ret |= rc632_reg_read(handle, i, &buf[i]); + return ret; +} /* generic FIFO access functions (if no more efficient ones provided by * transport driver) */ @@ -527,14 +665,14 @@ rc632_register_dump(struct rfid_asic_handle *handle, u_int8_t *buf) static int generic_fifo_write() { - // FIXME: implementation (not needed for CM 5121) + /* FIXME: implementation (not needed for CM 5121) */ return -1; } static int generic_fifo_read() { - // FIXME: implementation (not neded for CM 5121) + /* FIXME: implementation (not neded for CM 5121) */ return -1; } @@ -544,14 +682,14 @@ rc632_init(struct rfid_asic_handle *ah) int ret; /* switch off rf (make sure PICCs are reset at init time) */ - ret = rc632_power_down(ah); + ret = rc632_power(ah, 0); if (ret < 0) return ret; usleep(10000); /* switch on rf */ - ret = rc632_power_up(ah); + ret = rc632_power(ah, 1); if (ret < 0) return ret; @@ -565,8 +703,15 @@ rc632_init(struct rfid_asic_handle *ah) if (ret < 0) return ret; + /* switch off rf */ + ret = rc632_rf_power(ah, 0); + if (ret < 0) + return ret; + + usleep(100000); + /* switch on rf */ - ret = rc632_turn_on_rf(ah); + ret = rc632_rf_power(ah, 1); if (ret < 0) return ret; @@ -579,11 +724,11 @@ rc632_fini(struct rfid_asic_handle *ah) int ret; /* switch off rf */ - ret = rc632_turn_off_rf(ah); + ret = rc632_rf_power(ah, 0); if (ret < 0) return ret; - ret = rc632_power_down(ah); + ret = rc632_power(ah, 0); if (ret < 0) return ret; @@ -595,12 +740,12 @@ rc632_open(struct rfid_asic_transport_handle *th) { struct rfid_asic_handle *h; - h = malloc(sizeof(*h)); + h = malloc_asic_handle(sizeof(*h)); if (!h) return NULL; memset(h, 0, sizeof(*h)); - h->asic = &rc632; + h->asic = (void*)&rc632; h->rath = th; h->fc = h->asic->fc; /* FIXME: this is only cm5121 specific, since the latency @@ -608,7 +753,7 @@ rc632_open(struct rfid_asic_transport_handle *th) h->mtu = h->mru = 64; if (rc632_init(h) < 0) { - free(h); + free_asic_handle(h); return NULL; } @@ -619,114 +764,91 @@ void rc632_close(struct rfid_asic_handle *h) { rc632_fini(h); - free(h); + free_asic_handle(h); } - -/* - * Philips CL RC632 primitives for ISO 14443-A compliant PICC's - * - * (C) 2005 by Harald Welte - * +/* + * ISO14443A */ +/* Register file for ISO14443A standard */ +static struct register_file iso14443a_script[] = { + { + .reg = RC632_REG_TX_CONTROL, + .val = RC632_TXCTRL_MOD_SRC_INT | + RC632_TXCTRL_TX2_INV | + RC632_TXCTRL_FORCE_100_ASK | + RC632_TXCTRL_TX2_RF_EN | + RC632_TXCTRL_TX1_RF_EN, + }, { + .reg = RC632_REG_CW_CONDUCTANCE, + .val = CM5121_CW_CONDUCTANCE, + }, { + .reg = RC632_REG_MOD_CONDUCTANCE, + .val = CM5121_MOD_CONDUCTANCE, + }, { + .reg = RC632_REG_CODER_CONTROL, + .val = (RC632_CDRCTRL_TXCD_14443A | + RC632_CDRCTRL_RATE_106K), + }, { + .reg = RC632_REG_MOD_WIDTH, + .val = 0x13, + }, { + .reg = RC632_REG_MOD_WIDTH_SOF, + .val = 0x3f, + }, { + .reg = RC632_REG_TYPE_B_FRAMING, + .val = 0x00, + }, { + .reg = RC632_REG_RX_CONTROL1, + .val = (RC632_RXCTRL1_GAIN_35DB | + RC632_RXCTRL1_ISO14443 | + RC632_RXCTRL1_SUBCP_8), + }, { + .reg = RC632_REG_DECODER_CONTROL, + .val = (RC632_DECCTRL_MANCHESTER | + RC632_DECCTRL_RXFR_14443A), + }, { + .reg = RC632_REG_BIT_PHASE, + .val = CM5121_14443A_BITPHASE, + }, { + .reg = RC632_REG_RX_THRESHOLD, + .val = CM5121_14443A_THRESHOLD, + }, { + .reg = RC632_REG_BPSK_DEM_CONTROL, + .val = 0x00, + }, { + .reg = RC632_REG_RX_CONTROL2, + .val = (RC632_RXCTRL2_DECSRC_INT | + RC632_RXCTRL2_CLK_Q), + }, { + .reg = RC632_REG_RX_WAIT, + //.val = 0x03, /* default value */ + .val = 0x06, /* omnikey */ + }, { + .reg = RC632_REG_CHANNEL_REDUNDANCY, + .val = (RC632_CR_PARITY_ENABLE | + RC632_CR_PARITY_ODD), + }, { + .reg = RC632_REG_CRC_PRESET_LSB, + .val = 0x63, + }, { + .reg = RC632_REG_CRC_PRESET_MSB, + .val = 0x63, + }, +}; + static int rc632_iso14443a_init(struct rfid_asic_handle *handle) { int ret; - // FIXME: some fifo work (drain fifo?) - /* flush fifo (our way) */ - ret = rc632_reg_write(handle, RC632_REG_CONTROL, 0x01); - - ret = rc632_reg_write(handle, RC632_REG_TX_CONTROL, - (RC632_TXCTRL_TX1_RF_EN | - RC632_TXCTRL_TX2_RF_EN | - RC632_TXCTRL_TX2_INV | - RC632_TXCTRL_FORCE_100_ASK | - RC632_TXCTRL_MOD_SRC_INT)); - if (ret < 0) - return ret; - - ret = rc632_reg_write(handle, RC632_REG_CW_CONDUCTANCE, - CM5121_CW_CONDUCTANCE); - if (ret < 0) - return ret; - - /* Since FORCE_100_ASK is set (cf mc073930.pdf), this line may be left out? */ - ret = rc632_reg_write(handle, RC632_REG_MOD_CONDUCTANCE, - CM5121_MOD_CONDUCTANCE); - if (ret < 0) - return ret; - - ret = rc632_reg_write(handle, RC632_REG_CODER_CONTROL, - (RC632_CDRCTRL_TXCD_14443A | - RC632_CDRCTRL_RATE_106K)); - if (ret < 0) - return ret; - - ret = rc632_reg_write(handle, RC632_REG_MOD_WIDTH, 0x13); - if (ret < 0) - return ret; - - ret = rc632_reg_write(handle, RC632_REG_MOD_WIDTH_SOF, 0x3f); - if (ret < 0) - return ret; - - ret = rc632_reg_write(handle, RC632_REG_TYPE_B_FRAMING, 0x00); - if (ret < 0) - return ret; - - ret = rc632_reg_write(handle, RC632_REG_RX_CONTROL1, - (RC632_RXCTRL1_GAIN_35DB | - RC632_RXCTRL1_ISO14443 | - RC632_RXCTRL1_SUBCP_8)); - if (ret < 0) - return ret; - - ret = rc632_reg_write(handle, RC632_REG_DECODER_CONTROL, - (RC632_DECCTRL_MANCHESTER | - RC632_DECCTRL_RXFR_14443A)); - if (ret < 0) - return ret; - - ret = rc632_reg_write(handle, RC632_REG_BIT_PHASE, - CM5121_14443A_BITPHASE); - if (ret < 0) - return ret; + ret = rc632_reg_write(handle, RC632_REG_CONTROL, + RC632_CONTROL_FIFO_FLUSH); - ret = rc632_reg_write(handle, RC632_REG_RX_THRESHOLD, - CM5121_14443A_THRESHOLD); - if (ret < 0) - return ret; - - ret = rc632_reg_write(handle, RC632_REG_BPSK_DEM_CONTROL, 0x00); - if (ret < 0) - return ret; - - ret = rc632_reg_write(handle, RC632_REG_RX_CONTROL2, - (RC632_RXCTRL2_DECSRC_INT | - RC632_RXCTRL2_CLK_Q)); - if (ret < 0) - return ret; - - /* Omnikey proprietary driver has 0x03, but 0x06 is the default reset value ?!? */ - ret = rc632_reg_write(handle, RC632_REG_RX_WAIT, 0x06); - if (ret < 0) - return ret; - - ret = rc632_reg_write(handle, RC632_REG_CHANNEL_REDUNDANCY, - (RC632_CR_PARITY_ENABLE | - RC632_CR_PARITY_ODD)); - if (ret < 0) - return ret; - - ret = rc632_reg_write(handle, RC632_REG_CRC_PRESET_LSB, 0x63); - if (ret < 0) - return ret; - - ret = rc632_reg_write(handle, RC632_REG_CRC_PRESET_MSB, 0x63); + ret = rc632_execute_script(handle, iso14443a_script, + ARRAY_SIZE(iso14443a_script)); if (ret < 0) return ret; @@ -738,7 +860,7 @@ rc632_iso14443a_fini(struct iso14443a_handle *handle_14443) { #if 0 - ret = rc632_turn_off_rf(handle); + ret = rc632_rf_power(handle, 0); if (ret < 0) return ret; #endif @@ -757,8 +879,9 @@ rc632_iso14443a_transceive_sf(struct rfid_asic_handle *handle, int ret; u_int8_t tx_buf[1]; u_int8_t rx_len = 2; + u_int8_t error_flag; - memset(atqa, 0, sizeof(atqa)); + memset(atqa, 0, sizeof(*atqa)); tx_buf[0] = cmd; @@ -797,6 +920,21 @@ rc632_iso14443a_transceive_sf(struct rfid_asic_handle *handle, if (ret < 0) return ret; + /* determine whether there was a collission */ + ret = rc632_reg_read(handle, RC632_REG_ERROR_FLAG, &error_flag); + if (ret < 0) + return ret; + + if (error_flag & RC632_ERR_FLAG_COL_ERR) { + u_int8_t boc; + /* retrieve bit of collission */ + ret = rc632_reg_read(handle, RC632_REG_COLL_POS, &boc); + if (ret < 0) + return ret; + DEBUGP("collision detected in xcv_sf: bit_of_col=%u\n", boc); + /* FIXME: how to signal this up the stack */ + } + if (rx_len != 2) { DEBUGP("rx_len(%d) != 2\n", rx_len); return -1; @@ -839,6 +977,12 @@ rc632_iso14443ab_transceive(struct rfid_asic_handle *handle, channel_red = RC632_CR_PARITY_ENABLE|RC632_CR_PARITY_ODD; break; #endif + case RFID_15693_FRAME: + channel_red = RC632_CR_CRC3309 | RC632_CR_RX_CRC_ENABLE + | RC632_CR_TX_CRC_ENABLE; + break; + case RFID_15693_FRAME_ICODE1: + /* FIXME: implement */ default: return -EINVAL; break; @@ -847,7 +991,7 @@ rc632_iso14443ab_transceive(struct rfid_asic_handle *handle, channel_red); if (ret < 0) return ret; - + DEBUGP("tx_len=%u\n",tx_len); ret = rc632_transceive(handle, tx_buf, tx_len, rx_buf, &rxl, timeout, 0); *rx_len = rxl; if (ret < 0) @@ -866,7 +1010,7 @@ rc632_iso14443a_transceive_acf(struct rfid_asic_handle *handle, int ret; u_int8_t rx_buf[64]; u_int8_t rx_len = sizeof(rx_buf); - u_int8_t rx_align = 0, tx_last_bits, tx_bytes; + u_int8_t rx_align = 0, tx_last_bits, tx_bytes, tx_bytes_total; u_int8_t boc; u_int8_t error_flag; *bit_of_col = ISO14443A_BITOFCOL_NONE; @@ -890,14 +1034,14 @@ rc632_iso14443a_transceive_acf(struct rfid_asic_handle *handle, if (ret < 0) return ret; - tx_last_bits = acf->nvb & 0x0f; /* lower nibble indicates bits */ - tx_bytes = acf->nvb >> 4; + tx_last_bits = acf->nvb & 0x07; /* lower nibble indicates bits */ + tx_bytes = ( acf->nvb >> 4 ) & 0x07; if (tx_last_bits) { - tx_bytes++; - rx_align = (tx_last_bits+1) % 8;/* rx frame complements tx */ + tx_bytes_total = tx_bytes+1; + rx_align = tx_last_bits & 0x07; /* rx frame complements tx */ } - - //rx_align = 8 - tx_last_bits;/* rx frame complements tx */ + else + tx_bytes_total = tx_bytes; /* set RxAlign and TxLastBits*/ ret = rc632_reg_write(handle, RC632_REG_BIT_FRAMING, @@ -905,7 +1049,7 @@ rc632_iso14443a_transceive_acf(struct rfid_asic_handle *handle, if (ret < 0) return ret; - ret = rc632_transceive(handle, (u_int8_t *)acf, tx_bytes, + ret = rc632_transceive(handle, (u_int8_t *)acf, tx_bytes_total, rx_buf, &rx_len, 0x32, 0); if (ret < 0) return ret; @@ -914,8 +1058,10 @@ rc632_iso14443a_transceive_acf(struct rfid_asic_handle *handle, acf->uid_bits[tx_bytes-2] = ( (acf->uid_bits[tx_bytes-2] & (0xff >> (8-tx_last_bits))) | rx_buf[0]); + /* copy the rest */ - memcpy(&acf->uid_bits[tx_bytes+1-2], &rx_buf[1], rx_len-1); + if (rx_len) + memcpy(&acf->uid_bits[tx_bytes-1], &rx_buf[1], rx_len-1); /* determine whether there was a collission */ ret = rc632_reg_read(handle, RC632_REG_ERROR_FLAG, &error_flag); @@ -1002,8 +1148,7 @@ static struct tx_config tx_configs[] = { }; static int rc632_iso14443a_set_speed(struct rfid_asic_handle *handle, - unsigned int tx, - u_int8_t rate) + unsigned int tx, unsigned int rate) { int rc; u_int8_t reg; @@ -1058,14 +1203,88 @@ static int rc632_iso14443a_set_speed(struct rfid_asic_handle *handle, return 0; } +#if 0 +static struct register_file iso14443b_script[] = { + { + .reg = RC632_REG_TX_CONTROL, + .val = (RC632_TXCTRL_TX1_RF_EN | + RC632_TXCTRL_TX2_RF_EN | + RC632_TXCTRL_TX2_INV | + RC632_TXCTRL_MOD_SRC_INT), + }, { + .reg = RC632_REG_CW_CONDUCTANCE, + .val = 0x3f, + }, { + .reg = RC632_REG_MOD_CONDUCTANCE, + .val = 0x04, + }, { + .reg = RC632_REG_CODER_CONTROL, + .val = (RC632_CDRCTRL_TXCD_NRZ | + RC632_CDRCTRL_RATE_14443B), + }, { + .reg = RC632_REG_MOD_WIDTH, + .val = 0x13, + }, { + .reg = RC632_REG_MOD_WIDTH_SOF, + .val = 0x3f, + }, { + .reg = RC632_REG_TYPE_B_FRAMING, + .val = (RC632_TBFRAMING_SOF_11L_3H | + (6 << RC632_TBFRAMING_SPACE_SHIFT) | + RC632_TBFRAMING_EOF_11); + }, { + .reg = RC632_REG_RX_CONTROL1, + .val = (RC632_RXCTRL1_GAIN_35DB | + RC632_RXCTRL1_ISO14443, + RC632_RXCTRL1_SUBCP_8), + }, { + .reg = RC632_REG_DECODER_CONTROL, + .val = (RC632_DECCTRL_BPSK | + RC632_DECCTRL_RXFR_14443B), + }, { + .reg = RC632_REG_BIT_PHASE, + .val = CM5121_14443B_BITPHASE, + }, { + .reg = RC632_REG_RX_THRESHOLD, + .val = CM5121_14443B_THRESHOLD, + }, { + .reg = RC632_REG_BPSK_DEM_CONTROL, + .val = ((0x2 & RC632_BPSKD_TAUB_MASK)< 0) { + out[i] = in[len]; + len--; + i++; + } +} + +static int +rc632_iso15693_transceive_ac(struct rfid_asic_handle *handle, + const struct iso15693_anticol_cmd *acf, + unsigned int acf_len, + struct iso15693_anticol_resp *resp, + unsigned int *rx_len, char *bit_of_col) +{ + u_int8_t error_flag, boc; + //u_int8_t rx_len; + + int ret, tx_len, mask_len_bytes; + unsigned int rate = ISO15693_T_SLOW; + + if (acf->req.flags & RFID_15693_F_RATE_HIGH) + rate = ISO15693_T_FAST; + + printf("acf = %s\n", rfid_hexdump(acf, acf_len)); + + ret = rc632_transceive(handle, (u_int8_t *)acf, acf_len, + (u_int8_t *) resp, rx_len, + iso15693_timing[rate][ISO15693_T1], 0); + if (ret == -ETIMEDOUT) + return ret; + + /* determine whether there was a collission */ + ret = rc632_reg_read(handle, RC632_REG_ERROR_FLAG, &error_flag); + if (ret < 0) + return ret; + DEBUGP_ERROR_FLAG(error_flag); + + if (error_flag & RC632_ERR_FLAG_COL_ERR) { + /* retrieve bit of collission */ + ret = rc632_reg_read(handle, RC632_REG_COLL_POS, &boc); + if (ret < 0) + return ret; + *bit_of_col = boc; + } + + return 0; + +#if 0 + *bit_of_col = 0; + + mask_len_bytes = (acf->mask_len % 8) ? acf->mask_len/8+1 : acf->mask_len/8; + + if (acf->current_slot == 0) { + /* first call: transmit Inventory frame */ + DEBUGP("first_frame\n"); + + tx_len = sizeof(struct iso15693_request) + 1 + mask_len_bytes; + + ret = rc632_transceive(handle, (u_int8_t *)&req, tx_len, + (u_int8_t *)&rx_buf, &rx_len, ISO15693_T1, 0); + acf->current_slot = 1; + DEBUGP("rc632_transceive ret: %d rx_len: %d\n",ret,rx_len); + /* if ((ret < 0)&&(ret != -ETIMEDOUT)) + return ret; */ + + } else { + /* second++ call: end timeslot with EOFpulse and read */ + DEBUGP("second++_frame\n"); + if ((acf->current_slot > 16) || + ((acf->flags & RFID_15693_F5_NSLOTS_1 == 0) + && (acf->current_slot > 1))) { + + memset(uuid, 0, ISO15693_UID_LEN); + return -1; + } + + /* reset EOF-pulse-bit to 0 */ + ret = rc632_clear_bits(handle, RC632_REG_CODER_CONTROL, + RC632_CDRCTRL_15693_EOF_PULSE); + usleep(50); + /* generate EOF pulse */ + ret = rc632_set_bits(handle, RC632_REG_CODER_CONTROL, + RC632_CDRCTRL_15693_EOF_PULSE); + if (ret < 0) + return ret; + // DEBUGP("waiting for EOF pulse\n"); + // ret = rc632_wait_idle(handle, 10); //wait for idle + + rx_len = sizeof(rx_buf); + ret = rc632_receive(handle, (u_int8_t*)&rx_buf, &rx_len, ISO15693_T3); + DEBUGP("rc632_receive ret: %d rx_len: %d\n", ret, rx_len); + acf->current_slot++; + + /* if ((ret < 0)&&(ret != -ETIMEDOUT)) + return ret; */ + } + + rc632_reg_read(handle, RC632_REG_PRIMARY_STATUS, &tmp); + DEBUGP_STATUS_FLAG(tmp); + + if (ret == -ETIMEDOUT) { + /* no VICC answer in this timeslot*/ + memset(uuid, 0, ISO15693_UID_LEN); + return -ETIMEDOUT; + } else { + /* determine whether there was a collission */ + ret = rc632_reg_read(handle, RC632_REG_ERROR_FLAG, &error_flag); + DEBUGP_ERROR_FLAG(error_flag); + if (ret < 0) + return ret; + + if (error_flag & RC632_ERR_FLAG_COL_ERR) { + /* retrieve bit of collission */ + ret = rc632_reg_read(handle, RC632_REG_COLL_POS, &boc); + if (ret < 0) + return ret; + *bit_of_col = boc; + memcpy(uuid, rx_buf.uuid, ISO15693_UID_LEN); + // uuid_reversecpy(uuid, rx_buf.uuid, ISO15693_UID_LEN); + DEBUGP("Collision in slot %d bit %d\n", + acf->current_slot,boc); + return -ECOLLISION; + } else { + /* no collision-> retrieve uuid */ + DEBUGP("no collision in slot %d\n", acf->current_slot); + memcpy(uuid, rx_buf.uuid, ISO15693_UID_LEN); + //uuid_reversecpy(uuid, rx_buf.uuid, ISO15693_UID_LEN); + } + } + + return 0; +#endif +} + struct mifare_authcmd { u_int8_t auth_cmd; u_int8_t block_address; @@ -1453,6 +1839,11 @@ rc632_mifare_set_key(struct rfid_asic_handle *h, const u_int8_t *key) if (ret < 0) return ret; + /* Terminate probably running command */ + ret = rc632_reg_write(h, RC632_REG_COMMAND, RC632_CMD_IDLE); + if (ret < 0) + return ret; + ret = rc632_fifo_write(h, RFID_MIFARE_KEY_CODED_LEN, coded_key, 0x03); if (ret < 0) return ret; @@ -1461,7 +1852,12 @@ rc632_mifare_set_key(struct rfid_asic_handle *h, const u_int8_t *key) if (ret < 0) return ret; - ret = rc632_wait_idle(h, RC632_TMO_AUTH1); + ret = rc632_timer_set(h, RC632_TMO_AUTH1); + if (ret < 0) + return ret; + + //ret = rc632_wait_idle(h, RC632_TMO_AUTH1); + ret = rc632_wait_idle_timer(h); if (ret < 0) return ret; @@ -1483,8 +1879,10 @@ rc632_mifare_auth(struct rfid_asic_handle *h, u_int8_t cmd, u_int32_t serno, struct mifare_authcmd acmd; u_int8_t reg; - if (cmd != RFID_CMD_MIFARE_AUTH1A && cmd != RFID_CMD_MIFARE_AUTH1B) + if (cmd != RFID_CMD_MIFARE_AUTH1A && cmd != RFID_CMD_MIFARE_AUTH1B) { + DEBUGP("invalid auth command\n"); return -EINVAL; + } /* Initialize acmd */ acmd.block_address = block & 0xff; @@ -1492,9 +1890,16 @@ rc632_mifare_auth(struct rfid_asic_handle *h, u_int8_t cmd, u_int32_t serno, //acmd.serno = htonl(serno); acmd.serno = serno; +#if 1 /* Clear Rx CRC */ ret = rc632_clear_bits(h, RC632_REG_CHANNEL_REDUNDANCY, RC632_CR_RX_CRC_ENABLE); +#else + /* Clear Rx CRC, Set Tx CRC and Odd Parity */ + ret = rc632_reg_write(h, RC632_REG_CHANNEL_REDUNDANCY, + RC632_CR_TX_CRC_ENABLE | RC632_CR_PARITY_ODD | + RC632_CR_PARITY_ENABLE); +#endif if (ret < 0) return ret; @@ -1504,19 +1909,28 @@ rc632_mifare_auth(struct rfid_asic_handle *h, u_int8_t cmd, u_int32_t serno, return ret; ret = rc632_reg_write(h, RC632_REG_COMMAND, RC632_CMD_AUTHENT1); - if (ret < 0) + if (ret < 0) { + DEBUGP("error during AUTHENT1"); return ret; + } /* Wait until transmitter is idle */ - ret = rc632_wait_idle(h, RC632_TMO_AUTH1); + ret = rc632_timer_set(h, RC632_TMO_AUTH1); + if (ret < 0) + return ret; + + //ret = rc632_wait_idle(h, RC632_TMO_AUTH1); + ret = rc632_wait_idle_timer(h); if (ret < 0) return ret; ret = rc632_reg_read(h, RC632_REG_SECONDARY_STATUS, ®); if (ret < 0) return ret; - if (reg & 0x07) + if (reg & 0x07) { + DEBUGP("bitframe?"); return -EIO; + } /* Clear Tx CRC */ ret = rc632_clear_bits(h, RC632_REG_CHANNEL_REDUNDANCY, @@ -1524,13 +1938,19 @@ rc632_mifare_auth(struct rfid_asic_handle *h, u_int8_t cmd, u_int32_t serno, if (ret < 0) return ret; + /* Wait until transmitter is idle */ + ret = rc632_timer_set(h, RC632_TMO_AUTH1); + if (ret < 0) + return ret; + /* Send Authent2 Command */ ret = rc632_reg_write(h, RC632_REG_COMMAND, RC632_CMD_AUTHENT2); if (ret < 0) return ret; /* Wait until transmitter is idle */ - ret = rc632_wait_idle(h, RC632_TMO_AUTH1); + //ret = rc632_wait_idle(h, RC632_TMO_AUTH1); + ret = rc632_wait_idle_timer(h); if (ret < 0) return ret; @@ -1539,11 +1959,12 @@ rc632_mifare_auth(struct rfid_asic_handle *h, u_int8_t cmd, u_int32_t serno, if (ret < 0) return ret; - if (!(reg & RC632_CONTROL_CRYPTO1_ON)) + if (!(reg & RC632_CONTROL_CRYPTO1_ON)) { + DEBUGP("authentication not successful"); return -EACCES; + } return 0; - } /* transceive regular frame */ @@ -1581,27 +2002,40 @@ rc632_mifare_transceive(struct rfid_asic_handle *handle, return 0; } -struct rfid_asic rc632 = { + +static int +rc632_layer2_init(struct rfid_asic_handle *h, enum rfid_layer2_id l2) +{ + switch (l2) { + case RFID_LAYER2_ISO14443A: + return rc632_iso14443a_init(h); + case RFID_LAYER2_ISO14443B: + return rc632_iso14443b_init(h); + case RFID_LAYER2_ISO15693: + return rc632_iso15693_init(h); + case RFID_LAYER2_ICODE1: + return rc632_iso15693_icode1_init(h); + default: + return -EINVAL; + } +} + +const struct rfid_asic rc632 = { .name = "Philips CL RC632", .fc = ISO14443_FREQ_CARRIER, .priv.rc632 = { .fn = { - .power_up = &rc632_power_up, - .power_down = &rc632_power_down, - .turn_on_rf = &rc632_turn_on_rf, - .turn_off_rf = &rc632_turn_off_rf, + .power = &rc632_power, + .rf_power = &rc632_rf_power, .transceive = &rc632_iso14443ab_transceive, + .init = &rc632_layer2_init, .iso14443a = { - .init = &rc632_iso14443a_init, .transceive_sf = &rc632_iso14443a_transceive_sf, .transceive_acf = &rc632_iso14443a_transceive_acf, .set_speed = &rc632_iso14443a_set_speed, }, - .iso14443b = { - .init = &rc632_iso14443b_init, - }, .iso15693 = { - .init = &rc632_iso15693_init, + .transceive_ac = &rc632_iso15693_transceive_ac, }, .mifare_classic = { .setkey = &rc632_mifare_set_key,