/* mifare classic helper */
static int
mifare_classic_read_sector(struct rfid_protocol_handle *ph, int sector)
{
unsigned char buf[20];
unsigned int len = sizeof(buf);
int ret;
int block;
/* FIXME: make this work for sectors > 31 */
DEBUGPCR("Reading sector %u", sector);
for (block = sector*4; block < sector*4+4; block++) {
DEBUGP("Reading block %u: ", block);
ret = rfid_protocol_read(ph, block, buf, &len);
if(ret == -ETIMEDOUT)
DEBUGPCR("TIMEOUT");
if (ret < 0) {
DEBUGPCR("Error %d reading", ret);
return ret;
}
DEBUGPCR("Page 0x%x: %s", block, hexdump(buf, len));
}
return 0;
}
int _main_dbgu(char key)
{
unsigned char value;
switch (key) {
case '4':
AT91F_DBGU_Printk("Testing RC632 : ");
if (rc632_test(RAH) == 0)
AT91F_DBGU_Printk("SUCCESS!\n\r");
else
AT91F_DBGU_Printk("ERROR!\n\r");
break;
case '5':
opcd_rc632_reg_read(RAH, RC632_REG_RX_WAIT, &value);
DEBUGPCR("Reading RC632 Reg RxWait: 0x%02xr", value);
break;
case '6':
DEBUGPCR("Writing RC632 Reg RxWait: 0x55");
opcd_rc632_reg_write(RAH, RC632_REG_RX_WAIT, 0x55);
break;
case '7':
rc632_dump();
break;
}
return -EINVAL;
}
void req_ctx_init(void)
{
int i;
for (i = 0; i < NUM_RCTX_SMALL; i++) {
req_ctx[i].prev = req_ctx + i - 1;
req_ctx[i].next = req_ctx + i + 1;
req_ctx[i].size = RCTX_SIZE_SMALL;
req_ctx[i].tot_len = 0;
req_ctx[i].data = rctx_data[i];
req_ctx[i].state = RCTX_STATE_FREE;
DEBUGPCR("SMALL req_ctx[%02i] initialized at %08X, Data: %08X => %08X", i, req_ctx + i, req_ctx[i].data, req_ctx[i].data + RCTX_SIZE_SMALL);
}
for (; i < NUM_REQ_CTX; i++) {
req_ctx[i].prev = req_ctx + i - 1;
req_ctx[i].next = req_ctx + i + 1;
req_ctx[i].size = RCTX_SIZE_LARGE;
req_ctx[i].tot_len = 0;
req_ctx[i].data = rctx_data_large[i];
req_ctx[i].state = RCTX_STATE_FREE;
DEBUGPCR("LARGE req_ctx[%02i] initialized at %08X, Data: %08X => %08X", i, req_ctx + i, req_ctx[i].data, req_ctx[i].data + RCTX_SIZE_LARGE);
}
req_ctx[0].prev = NULL;
req_ctx[NUM_REQ_CTX - 1].next = NULL;
req_ctx_queues[RCTX_STATE_FREE] = req_ctx;
req_ctx_tails[RCTX_STATE_FREE] = req_ctx + NUM_REQ_CTX - 1;
req_counts[RCTX_STATE_FREE] = NUM_REQ_CTX;
for (i = RCTX_STATE_FREE + 1; i < RCTX_STATE_COUNT; i++) {
req_ctx_queues[i] = req_ctx_tails[i] = NULL;
req_counts[i] = 0;
}
}
void req_print(int state) {
int count = 0;
struct req_ctx *ctx, *last = NULL;
DEBUGP("State [%02i] start <==> ", state);
ctx = req_ctx_queues[state];
while (ctx) {
if (last != ctx->prev)
DEBUGP("*INV_PREV* ");
DEBUGP("%08X => ", ctx);
last = ctx;
ctx = ctx->next;
count++;
if (count > NUM_REQ_CTX) {
DEBUGP("*WILD POINTER* => ");
break;
}
}
DEBUGPCR("NULL");
if (!req_ctx_queues[state] && req_ctx_tails[state]) {
DEBUGPCR("NULL head, NON-NULL tail");
}
if (last != req_ctx_tails[state]) {
DEBUGPCR("Tail does not match last element");
}
}
void tc_cdiv_print(void)
{
DEBUGP("TCB_BMR=0x%08x ", tcb->TCB_BMR);
DEBUGP("TC0_CV=0x%08x ", tcb->TCB_TC0.TC_CV);
DEBUGP("TC0_CMR=0x%08x ", tcb->TCB_TC0.TC_CMR);
DEBUGPCR("TC0_SR=0x%08x", tcb->TCB_TC0.TC_SR);
DEBUGPCR("TC0_RA=0x%04x, TC0_RB=0x%04x, TC0_RC=0x%04x",
tcb->TCB_TC0.TC_RA, tcb->TCB_TC0.TC_RB, tcb->TCB_TC0.TC_RC);
}
static void help(void)
{
DEBUGPCR("o: decrease duty p: increase duty\r\n"
"k: stop pwm l: start pwn\r\n"
"n: decrease freq m: incresae freq\r\n"
"v: decrease mod_cond b: increase mod_cond\r\n"
"g: decrease cw_cond h: increase cw_cond");
DEBUGPCR("u: PA23 const 1 y: PA23 const 0\r\n"
"t: PA23 PWM0 f: toggle Force100ASK\r\n"
"{: decrease cdiv_idx }: increse cdiv idx");
}
void _init_func(void)
{
DEBUGPCR("\r\n===> main_pwm <===\r\n");
help();
rc632_init();
DEBUGPCRF("turning on RF");
rc632_turn_on_rf(RAH);
/* switch PA17 (connected to MFIN on board) to input */
AT91F_PIO_CfgInput(AT91C_BASE_PIOA, AT91C_PIO_PA17);
DEBUGPCRF("Initializing carrier divider");
tc_cdiv_init();
DEBUGPCRF("Initializing PWM");
pwm_init();
pwm_freq_set(0, 105937);
pwm_start(0);
pwm_duty_set_percent(0, 22); /* 22% of 9.43uS = 2.07uS */
rc632_modulate_mfin();
#ifdef SSC
DEBUGPCRF("Initializing SSC RX");
ssc_rx_init();
#endif
}
void req_ctx_set_state(struct req_ctx *ctx, unsigned long new_state)
{
unsigned long flags;
unsigned old_state;
if (new_state >= RCTX_STATE_COUNT) {
DEBUGPCR("Invalid new_state for req_ctx_set_state");
return;
}
local_irq_save(flags);
old_state = ctx->state;
if (ctx->prev)
ctx->prev->next = ctx->next;
else
req_ctx_queues[old_state] = ctx->next;
if (ctx->next)
ctx->next->prev = ctx->prev;
else
req_ctx_tails[old_state] = ctx->prev;
req_counts[old_state]--;
if ((ctx->prev = req_ctx_tails[new_state]))
ctx->prev->next = ctx;
else
req_ctx_queues[new_state] = ctx;
req_ctx_tails[new_state] = ctx;
ctx->state = new_state;
ctx->next = NULL;
req_counts[new_state]++;
local_irq_restore(flags);
}
struct req_ctx __ramfunc *req_ctx_find_get(int large,
unsigned long old_state,
unsigned long new_state)
{
struct req_ctx *toReturn;
unsigned long flags;
if (old_state >= RCTX_STATE_COUNT || new_state >= RCTX_STATE_COUNT) {
DEBUGPCR("Invalid parameters for req_ctx_find_get");
return NULL;
}
local_irq_save(flags);
toReturn = req_ctx_queues[old_state];
if (toReturn) {
if ((req_ctx_queues[old_state] = toReturn->next))
toReturn->next->prev = NULL;
else
req_ctx_tails[old_state] = NULL;
req_counts[old_state]--;
if ((toReturn->prev = req_ctx_tails[new_state]))
toReturn->prev->next = toReturn;
else
req_ctx_queues[new_state] = toReturn;
req_ctx_tails[new_state] = toReturn;
toReturn->state = new_state;
toReturn->next = NULL;
req_counts[new_state]++;
}
local_irq_restore(flags);
return toReturn;
}
void _main_func(void)
{
u_int32_t uid;
int status;
status = rfid_layer2_open(l2h);
if (status >= 0 && l2h->uid_len==4)
{
uid=((u_int32_t)l2h->uid[0]) |
((u_int32_t)l2h->uid[1])<< 8|
((u_int32_t)l2h->uid[2])<<16|
((u_int32_t)l2h->uid[3])<<24;
delay_scan=100;
if(uid!=last_uid)
{
last_uid=last_polled_uid=uid;
delay_blink=10;
DEBUGPCR("UID:0x%08X", uid);
}
}
else
if(delay_scan)
delay_scan--;
else
last_uid=0;
led_switch(1,(delay_blink==0)?1:0);
if(delay_blink)
delay_blink--;
/* first we try to get rid of pending to-be-sent stuff */
usb_out_process();
/* next we deal with incoming reqyests from USB EP1 (OUT) */
usb_in_process();
rc632_unthrottle();
}
static void __ramfunc tc_fdt_irq(void)
{
portSAVE_CONTEXT();
//vLedSetGreen(1);
u_int32_t sr = tcfdt->TC_SR;
DEBUGP("tc_fdt_irq: TC2_SR=0x%08x TC2_CV=0x%08x ",
sr, tcfdt->TC_CV);
if (sr & AT91C_TC_ETRGS) {
DEBUGP("Ext_trigger ");
}
if (sr & AT91C_TC_CPAS) {
DEBUGP("FDT_expired ");
}
if (sr & AT91C_TC_CPCS) {
DEBUGP("Compare_C ");
}
DEBUGPCR("");
AT91F_AIC_ClearIt(AT91C_ID_TC2);
AT91F_AIC_AcknowledgeIt();
//vLedSetGreen(0);
portRESTORE_CONTEXT();
}
int _main_dbgu(char key)
{
switch (key) {
case 'o':
if (duty_percent >= 1)
duty_percent--;
pwm_duty_set_percent(0, duty_percent);
break;
case 'p':
if (duty_percent <= 99)
duty_percent++;
pwm_duty_set_percent(0, duty_percent);
break;
case 'k':
pwm_stop(0);
break;
case 'l':
pwm_start(0);
break;
case 'n':
if (pwm_freq_idx > 0) {
pwm_freq_idx--;
pwm_stop(0);
pwm_freq_set(0, pwm_freq[pwm_freq_idx]);
pwm_start(0);
pwm_duty_set_percent(0, 22); /* 22% of 9.43uS = 2.07uS */
}
break;
case 'm':
if (pwm_freq_idx < ARRAY_SIZE(pwm_freq)-1) {
pwm_freq_idx++;
pwm_stop(0);
pwm_freq_set(0, pwm_freq[pwm_freq_idx]);
pwm_start(0);
pwm_duty_set_percent(0, 22); /* 22% of 9.43uS = 2.07uS */
}
break;
case 'u':
DEBUGPCRF("PA23 output high");
AT91F_PIO_CfgOutput(AT91C_BASE_PIOA, AT91C_PIO_PA23);
AT91F_PIO_SetOutput(AT91C_BASE_PIOA, AT91C_PIO_PA23);
break;
case 'y':
DEBUGPCRF("PA23 output low");
AT91F_PIO_CfgOutput(AT91C_BASE_PIOA, AT91C_PIO_PA23);
AT91F_PIO_ClearOutput(AT91C_BASE_PIOA, AT91C_PIO_PA23);
return 0;
break;
case 't':
DEBUGPCRF("PA23 PeriphA (PWM)");
AT91F_PIO_CfgPeriph(AT91C_BASE_PIOA, 0, AT91C_PA23_PWM0);
return 0;
break;
case 'f':
DEBUGPCRF("%sabling Force100ASK", force_100ask ? "Dis":"En");
if (force_100ask) {
force_100ask = 0;
opcd_rc632_clear_bits(RAH, RC632_REG_TX_CONTROL,
RC632_TXCTRL_FORCE_100_ASK);
} else {
force_100ask = 1;
opcd_rc632_set_bits(RAH, RC632_REG_TX_CONTROL,
RC632_TXCTRL_FORCE_100_ASK);
}
return 0;
break;
case 'v':
if (mod_conductance > 0) {
mod_conductance--;
opcd_rc632_reg_write(RAH, RC632_REG_MOD_CONDUCTANCE,
rsrel_table[mod_conductance]);
}
break;
case 'b':
if (mod_conductance < 0x3f) {
mod_conductance++;
opcd_rc632_reg_write(RAH, RC632_REG_MOD_CONDUCTANCE,
rsrel_table[mod_conductance]);
}
break;
case 'g':
if (cw_conductance > 0) {
cw_conductance--;
opcd_rc632_reg_write(RAH, RC632_REG_CW_CONDUCTANCE,
rsrel_table[cw_conductance]);
}
break;
case 'h':
if (cw_conductance < 0x3f) {
cw_conductance++;
opcd_rc632_reg_write(RAH, RC632_REG_CW_CONDUCTANCE,
rsrel_table[cw_conductance]);
}
break;
case '?':
help();
return 0;
break;
case '<':
tc_cdiv_phase_inc();
break;
case '>':
tc_cdiv_phase_dec();
break;
case '{':
if (cdiv_idx > 0)
cdiv_idx--;
tc_cdiv_set_divider(cdivs[cdiv_idx]);
break;
case '}':
if (cdiv_idx < ARRAY_SIZE(cdivs)-1)
cdiv_idx++;
tc_cdiv_set_divider(cdivs[cdiv_idx]);
break;
#ifdef SSC
case 's':
ssc_rx_start();
break;
case 'S':
ssc_rx_stop();
break;
#endif
default:
return -EINVAL;
}
DEBUGPCR("pwm_freq=%u, duty_percent=%u, mod_cond=%u, cw_cond=%u tc_cdiv=%u",
pwm_freq[pwm_freq_idx], duty_percent, mod_conductance, cw_conductance,
cdivs[cdiv_idx]);
return 0;
}
static void sys_irq(void)
{
u_int32_t sr;
DEBUGP("sys_irq ");
/* Somehow Atmel decided to do really stupid interrupt sharing
* for commonly-used interrupts such as the timer irq */
/* dbgu */
if (*AT91C_DBGU_IMR) {
sr = *AT91C_DBGU_CSR;
if (sr & *AT91C_DBGU_IMR) {
DEBUGP("DBGU(");
if (sysirq_hdlrs[AT91SAM7_SYSIRQ_DBGU]) {
DEBUGP("handler ");
//by Shan. We'll never call the long DBGU process rountine, no interrupt handling for DBGU, time saving.
//sysirq_hdlrs[AT91SAM7_SYSIRQ_DBGU](sr);
} else {
*AT91C_DBGU_IDR = *AT91C_DBGU_IMR;
DEBUGP("no handler ");
}
DEBUGP(") ");
}
}
/* pit_irq */
if (*AT91C_PITC_PIMR & AT91C_PITC_PITIEN) {
sr = *AT91C_PITC_PISR;
if (sr & AT91C_PITC_PITS) {
if (sysirq_hdlrs[AT91SAM7_SYSIRQ_PIT]) {
sysirq_hdlrs[AT91SAM7_SYSIRQ_PIT](sr);
} else {
DEBUGP("no handler DISABLE_PIT ");
*AT91C_PITC_PIMR &= ~AT91C_PITC_PITIEN;
}
}
}
/* rtt_irq */
if (*AT91C_RTTC_RTMR & (AT91C_RTTC_ALMIEN|AT91C_RTTC_RTTINCIEN)) {
sr = *AT91C_RTTC_RTSR;
if (sr) {
DEBUGP("RTT(");
if (sysirq_hdlrs[AT91SAM7_SYSIRQ_RTT]) {
DEBUGP("handler ");
sysirq_hdlrs[AT91SAM7_SYSIRQ_RTT](sr);
} else {
*AT91C_RTTC_RTMR &= ~(AT91C_RTTC_ALMIEN|
AT91C_RTTC_RTTINCIEN);
DEBUGP("no handler ");
}
DEBUGP(") ");
}
}
/* pmc_irq */
if (*AT91C_PMC_IMR) {
sr = *AT91C_PMC_SR;
if (sr & *AT91C_PMC_IMR) {
DEBUGP("PMC(");
if (sysirq_hdlrs[AT91SAM7_SYSIRQ_PMC]) {
DEBUGP("handler ");
sysirq_hdlrs[AT91SAM7_SYSIRQ_PMC](sr);
} else {
*AT91C_PMC_IDR = *AT91C_PMC_IMR;
DEBUGP("no handler ");
}
DEBUGP(") ");
}
}
/* rstc_irq */
if (*AT91C_RSTC_RMR & (AT91C_RSTC_URSTIEN|AT91C_RSTC_BODIEN)) {
sr = *AT91C_RSTC_RSR;
if (sr & (AT91C_RSTC_URSTS|AT91C_RSTC_BODSTS)) {
DEBUGP("RSTC(");
if (sysirq_hdlrs[AT91SAM7_SYSIRQ_RSTC]) {
DEBUGP("handler ");
sysirq_hdlrs[AT91SAM7_SYSIRQ_RSTC](sr);
} else {
*AT91C_RSTC_RMR &= ~(AT91C_RSTC_URSTIEN|
AT91C_RSTC_BODIEN);
DEBUGP("no handler ");
}
DEBUGP(") ");
}
}
/* mc_irq */
if (*AT91C_MC_FMR & (AT91C_MC_LOCKE | AT91C_MC_PROGE)) {
sr = *AT91C_MC_FSR;
if ((*AT91C_MC_FMR & AT91C_MC_LOCKE && (sr & AT91C_MC_LOCKE))||
(*AT91C_MC_FMR & AT91C_MC_PROGE && (sr & AT91C_MC_PROGE))){
DEBUGP("EFC(");
if (sysirq_hdlrs[AT91SAM7_SYSIRQ_EFC]) {
DEBUGP("handler ");
sysirq_hdlrs[AT91SAM7_SYSIRQ_EFC](sr);
} else {
*AT91C_MC_FMR &= ~(AT91C_MC_LOCKE |
AT91C_MC_PROGE);
DEBUGP("no handler ");
}
DEBUGP(") ");
}
}
/* wdt_irq */
if (*AT91C_WDTC_WDMR & AT91C_WDTC_WDFIEN) {
sr = *AT91C_WDTC_WDSR;
if (sr) {
DEBUGP("WDT(");
if (sysirq_hdlrs[AT91SAM7_SYSIRQ_WDT]) {
DEBUGP("handler ");
sysirq_hdlrs[AT91SAM7_SYSIRQ_WDT](sr);
} else {
/* we can't disable it... */
DEBUGP("no handler ");
}
DEBUGP(") ");
}
}
AT91F_AIC_ClearIt(AT91C_BASE_AIC, AT91C_ID_SYS);
DEBUGPCR("END");
}
static int init_proto(void)
{
struct req_ctx *detect_rctx;
struct openpcd_hdr *opcdh;
struct openpcd_l2_connectinfo *l2c;
struct openpcd_proto_connectinfo *pc;
unsigned int size;
l2h = rfid_layer2_scan(rh);
if (!l2h)
return 0;
DEBUGP("l2='%s' ", rfid_layer2_name(l2h));
detect_rctx = req_ctx_find_get(0, RCTX_STATE_FREE,
RCTX_STATE_LIBRFID_BUSY);
if (detect_rctx) {
unsigned int uid_len;
opcdh = (struct openpcd_hdr *) detect_rctx->data;
l2c = (struct openpcd_l2_connectinfo *)
(char *) opcdh + sizeof(opcdh);
l2c->uid_len = sizeof(l2c->uid);
opcdh->cmd = OPENPCD_CMD_LRFID_DETECT_IRQ;
opcdh->flags = 0x00;
opcdh->reg = 0x03;
opcdh->val = l2h->l2->id;
detect_rctx->tot_len = sizeof(*opcdh) + sizeof(*l2c);
#if 0
/* copy UID / PUPI into data section */
rfid_layer2_getopt(l2h, RFID_OPT_LAYER2_UID, (void *)l2c->uid,
&uid_len);
l2c->uid_len = uid_len & 0xff;
size = sizeof(l2c->proto_supported);
rfid_layer2_getopt(l2h, RFID_OPT_LAYER2_PROTO_SUPP,
&l2c->proto_supported, &size);
switch (l2h->l2->id) {
case RFID_LAYER2_ISO14443A:
break;
case RFID_LAYER2_ISO14443B:
break;
case RFID_LAYER2_ISO15693:
break;
}
#endif
req_ctx_set_state(detect_rctx, RCTX_STATE_UDP_EP3_PENDING);
} else
DEBUGPCRF("=>>>>>>>>>>>>>>no req_ctx for L2!");
ph = rfid_protocol_scan(l2h);
if (!ph)
return 3;
DEBUGP("p='%s' ", rfid_protocol_name(ph));
detect_rctx = req_ctx_find_get(0, RCTX_STATE_FREE,
RCTX_STATE_LIBRFID_BUSY);
if (detect_rctx) {
opcdh = (struct openpcd_hdr *) detect_rctx->data;
pc = (struct openpcd_proto_connectinfo *)
((char *) opcdh + sizeof(*opcdh));
detect_rctx->tot_len = sizeof(*opcdh) + sizeof(*pc);
opcdh->cmd = OPENPCD_CMD_LRFID_DETECT_IRQ;
opcdh->flags = 0x00;
opcdh->reg = 0x04;
opcdh->val = ph->proto->id;
/* copy L4 info into data section */
#if 0
switch (ph->proto->id) {
case RFID_PROTOCOL_TCL: {
struct openpcd_proto_tcl_connectinfo *ptc
= (struct openpcd_proto_tcl_connectinfo *)
((char *) ph + sizeof(*ph));
unsigned int space;
detect_rctx->tot_len += sizeof(*ptc);
space = detect_rctx->size - sizeof(*opcdh)-sizeof(*pc);
size = space;
rfid_protocol_getopt(ph, RFID_OPT_P_TCL_ATS,
&ptc->ats_snippet, &size);
if (size == space) {
/* we've only copied part of the ATS */
size = sizeof(ptc->ats_tot_len);
rfid_protocol_getopt(ph,
RFID_OPT_P_TCL_ATS_LEN,
&ptc->ats_tot_len, &size);
} else {
ptc->ats_tot_len = size;
}
} break;
}
#endif
req_ctx_set_state(detect_rctx, RCTX_STATE_UDP_EP3_PENDING);
} else
DEBUGPCRF("=>>>>>>>>>>>>>>no req_ctx for L2!");
led_switch(1, 1);
if (ph->proto->id == RFID_PROTOCOL_MIFARE_CLASSIC) {
int rc;
DEBUGPCR("Authenticating sector %u: ", sector);
rc = mfcl_set_key(ph, MIFARE_CL_KEYA_DEFAULT_INFINEON);
if (rc < 0) {
DEBUGPCR("key format error");
return 4;
}
rc = mfcl_auth(ph, RFID_CMD_MIFARE_AUTH1A, sector*4);
if (rc < 0) {
DEBUGPCR("mifare auth error");
return 4;
} else
DEBUGPCR("mifare auth succeeded!\n");
mifare_classic_read_sector(ph, sector);
return 5;
}
return 4;
}
