# 1 "avr-bug.c"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "avr-bug.c"
# 104 "avr-bug.c"
typedef signed char int8_t;
typedef unsigned char uint8_t;
typedef signed short int16_t;
typedef unsigned short uint16_t;
typedef signed long int32_t;
typedef unsigned long uint32_t;
# 123 "avr-bug.c"
typedef uint16_t caddr_t;

typedef uint16_t size_t;


typedef uint8_t boolean;
typedef unsigned short wchar_t;

typedef unsigned long long uint64_t;
# 149 "avr-bug.c"
typedef char text_char_t;
typedef uint8_t text_byte_t;
typedef uint16_t text_word_t;
typedef uint32_t text_quad_t;

int text_strlen(const text_char_t *str);
void memory_set(caddr_t s, uint8_t c, size_t count);
void memory_copy(caddr_t dest, const caddr_t src, size_t count);

typedef uint8_t bits_t;
# 170 "avr-bug.c"
void set_bit(uint8_t nr, bits_t *addr);
void clear_bit(uint8_t nr, bits_t *addr);
boolean test_bit(uint8_t nr, const bits_t *addr);




uint8_t find_next_set_bit(const bits_t *addr,
     uint8_t size, uint8_t offset);
uint8_t find_next_clear_bit(const bits_t *addr,
       uint8_t size, uint8_t offset);




uint8_t __ffs8(uint8_t word);
uint8_t __ffs16(uint16_t word);
uint8_t __fls8(uint8_t x);
uint8_t __fls16(uint16_t word);
uint8_t __fls32(uint32_t word);


uint32_t __roundup32(uint32_t n);
uint32_t __rounddown32(uint32_t n);
uint16_t __roundup16(uint16_t n);



extern uint8_t ____ilog2_NaN(void);
# 269 "avr-bug.c"
uint8_t bitrev8(uint8_t byte);
uint8_t hweight8(uint8_t byte);
uint8_t hweight16(uint16_t word);
# 317 "avr-bug.c"
void dbg_print(uint8_t tag, uint8_t val);
void dbg_dump_str(const text_char_t *str);
# 331 "avr-bug.c"
void dbg_panic(const text_char_t *file, int line);
# 514 "avr-bug.c"
typedef uint16_t scs_size_t;
typedef uint16_t scs_off_t;




typedef uint8_t scs_err_t;

typedef void (*scs_cmpl_cb)(void);
typedef scs_err_t (*scs_txfr_cb)(scs_size_t nc, scs_size_t ne);
typedef void (*scs_tvoid_cb)(void);
# 551 "avr-bug.c"
struct nfc_dep_info {
 uint8_t abtNFCID3[10];
 uint8_t btDID;
 uint8_t btBS;
 uint8_t btBR;
 uint8_t btTO;
 uint8_t btPP;
 uint8_t abtGB[48];
 size_t szGB;
 uint8_t ndm;



} __attribute__((packed));

struct nfc_iso14443a_info {
 uint8_t abtAtqa[2];
 uint8_t btSak;
 size_t szUidLen;
 uint8_t abtUid[10];
 size_t szAtsLen;

 uint8_t abtAts[254];
} __attribute__((packed));

struct nfc_felica_info {
 size_t szLen;
 uint8_t btResCode;
 uint8_t abtId[8];
 uint8_t abtPad[8];
 uint8_t abtSysCode[2];
} __attribute__((packed));

struct nfc_iso14443b_info {



 uint8_t abtPupi[4];



 uint8_t abtApplicationData[4];



 uint8_t abtProtocolInfo[3];



 uint8_t ui8CardIdentifier;
} __attribute__((packed));

struct nfc_iso14443bi_info {
 uint8_t abtDIV[4];
 uint8_t btVerLog;
 uint8_t btConfig;
 size_t szAtrLen;
 uint8_t abtAtr[33];
} __attribute__((packed));

struct nfc_iso14443b2sr_info {
 uint8_t abtUID[8];
} __attribute__((packed));

struct nfc_iso14443b2ct_info {
 uint8_t abtUID[4];
 uint8_t btProdCode;
 uint8_t btFabCode;
} __attribute__((packed));

struct nfc_jewel_info {
 uint8_t btSensRes[2];
 uint8_t btId[4];
} __attribute__((packed));


union nfc_target_info {
 struct nfc_iso14443a_info nai;
 struct nfc_felica_info nfi;
 struct nfc_iso14443b_info nbi;
 struct nfc_iso14443bi_info nii;
 struct nfc_iso14443b2sr_info nsi;
 struct nfc_iso14443b2ct_info nci;
 struct nfc_jewel_info nji;
 struct nfc_dep_info ndi;
};
# 657 "avr-bug.c"
struct nfc_target {
 union nfc_target_info nti;
 uint16_t nm;
} __attribute__((packed));
# 969 "avr-bug.c"
boolean pn53x_hw_poll_ready(void);
void pn53x_hw_write_cmpl(scs_size_t nc);
void pn53x_hw_read_cmpl(scs_size_t ne);
uint8_t pn53x_hw_xchg_read(scs_off_t index);
void pn53x_hw_xchg_write(scs_off_t index, uint8_t val);
void pn53x_hw_ctrl_init(void);


uint8_t pn53x_nm_to_pm(const uint16_t nm);
uint16_t pn53x_ptt_to_nm(const uint8_t ptt);
uint8_t pn53x_nm_to_ptt(const uint16_t nm);
# 989 "avr-bug.c"
struct pn53x_stub_driver {
 uint16_t nm;
 scs_err_t (*get_info)(uint8_t tg, union nfc_target_info *info);
 scs_err_t (*read_ready)(uint8_t tg);
 scs_size_t (*read_count)(uint8_t tg);
 uint8_t (*read_byte)(uint8_t tg, scs_off_t index);
 void (*write_ready)(uint8_t tg, scs_size_t size);
 void (*write_byte)(uint8_t tg, scs_off_t index, uint8_t value);
};
typedef struct pn53x_stub_driver pn53x_stub_driver_t;
uint8_t pn53x_register_stub_driver(pn53x_stub_driver_t *driver);
void pn53x_stub_driver_init(void);

uint8_t pn53x_stub_cmd[264];
uint8_t pn53x_stub_resp[264];
scs_size_t pn53x_stub_nc;
scs_size_t pn53x_stub_ne;
boolean pn53x_stub_ready;
boolean pn53x_stub_is_resp;
boolean pn53x_stub_is_cmd;
static uint8_t pn53x_flags;
static uint8_t pn53x_serial_br;
static uint8_t pn53x_sfr_p3;
static uint8_t pn53x_sfr_p7;
static uint8_t pn53x_hci_mode = 0x02;
static struct nfc_target pn53x_targets[2];
static uint8_t pn53x_nr_targets;

static pn53x_stub_driver_t *pn53x_stub_drivers[1];
static uint8_t pn53x_nr_drivers;
static uint8_t pn53x_ciu_regs[0x40] = {
 0x00, 0x3B, 0x00, 0x00, 0x80, 0x00, 0x10, 0x84,
 0x84, 0x4F, 0x00, 0x00, 0x62, 0x00, 0x00, 0x00,
 0x00, 0xFF, 0xFF, 0x88, 0x26, 0x87, 0x48, 0x88,
 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x80,
 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 0x00, 0x20, 0x00, 0x00, 0x14, 0x00, 0x00, 0x21,
 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0xA0, 0x00
};
static uint8_t pn53x_ciu_writables[0x40] = {
 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xEF, 0xFF, 0xFF,
 0xF7, 0xEF, 0xFF, 0xFF, 0xFF, 0x7F, 0xDF, 0x00,
 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 0x3F, 0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00,
 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x0F, 0x00,
 0xFF, 0x3F, 0x3F, 0x00, 0x00, 0x00, 0x00, 0xFF,
 0x8F, 0x3F, 0x7F, 0x2F, 0xFF, 0x9F, 0x00, 0x00,
 0x98, 0xFF, 0x80, 0x3F, 0xF0, 0xF7, 0x80, 0x00
};
static uint8_t pn53x_ciu_readables[0x40] = {
 0x00, 0xFF, 0xFF, 0xFF, 0xFB, 0xFB, 0xFF, 0xFF,
 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00,
 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00,
 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xFF,
 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x7F, 0xFF, 0xFF,
 0xFF, 0xFF, 0x7F, 0xFF, 0x3F, 0x7F, 0xFF, 0x00
};
static uint8_t pn53x_ctrl_reg_switch_rng;

void pn53x_build_frame(uint8_t len)
{
 scs_size_t ne;
 uint8_t dcs = 0x00;
 uint8_t i;

 pn53x_stub_resp[3] = len;
 pn53x_stub_resp[4] = (uint8_t)(0x00-len);


 ne = ((6 -1) + (pn53x_stub_resp)[3] + 2);
 for (i = 0; i < pn53x_stub_resp[3]; i++)
  dcs -= pn53x_stub_resp[5 +i];
 pn53x_stub_resp[ne-2] = dcs;
 pn53x_stub_resp[ne-1] = 0x00;

 pn53x_stub_ne = ne;
 pn53x_stub_is_resp = !(unsigned char)0;
 pn53x_stub_ready = !(unsigned char)0;
}

void pn53x_response_error(uint8_t ec)
{
 dbg_print(((10<<4)+3), (ec));

 pn53x_stub_resp[5] = ec;
 pn53x_build_frame(1);
}

void pn53x_response_Diagnose(void)
{
 uint8_t len;
 switch (pn53x_stub_cmd[(6 +(1))]) {
 case 0x00:
  len = pn53x_stub_cmd[3];
  memory_copy((caddr_t)(pn53x_stub_resp)+(6 +(1)),
       (caddr_t)(pn53x_stub_cmd)+(6 +(1)),
       len-2);
  break;
 case 0x01:
 case 0x02:
  pn53x_stub_resp[(6 +(1))] = 0x00;
  len = 3;
  break;
 case 0x04:
 case 0x05:
 case 0x06:
 case 0x07:
  pn53x_response_error(0x27);
  return;
 default:
  pn53x_response_error(0x27);
  return;
 }
 pn53x_build_frame(len);
}

void pn53x_response_GetFirmwareVersion(void)
{
 pn53x_stub_resp[(6 +(1))] = 0x32;
 pn53x_stub_resp[(6 +(2))] = 0x01;
 pn53x_stub_resp[(6 +(3))] = 0x06;
 pn53x_stub_resp[(6 +(4))] = 0x07;
 pn53x_build_frame(6);
}

void pn53x_response_SetParameters(void)
{
 pn53x_flags = pn53x_stub_cmd[(6 +(1))];



 pn53x_build_frame(2);
}

static uint8_t pn53x_target_iso14443a_size(uint8_t tg)
{
 uint8_t size = 4;
 uint8_t len;

 len = pn53x_targets[tg].nti.nai.szAtsLen;
 if (len)
  size += (1+len);
 size += pn53x_targets[tg].nti.nai.szUidLen;
 return size;
}

static uint8_t pn53x_target_info_size(uint8_t tg)
{
 uint8_t size = 1;
 switch (((uint8_t)((pn53x_targets[tg].nm)>>8))) {
 case 0x00:
  size += pn53x_target_iso14443a_size(tg);
  break;
 default:
  dbg_panic("avr-bug.c", 1146);
  break;
 }
 return size;
}

static void pn53x_target_iso14443a_data(uint8_t tg,
     scs_off_t offset)
{
 uint8_t len;
 pn53x_stub_resp[offset++] = pn53x_targets[tg].nti.nai.abtAtqa[0];
 pn53x_stub_resp[offset++] = pn53x_targets[tg].nti.nai.abtAtqa[1];
 pn53x_stub_resp[offset++] = pn53x_targets[tg].nti.nai.btSak;
 len = pn53x_targets[tg].nti.nai.szUidLen;
 pn53x_stub_resp[offset++] = len;
 memory_copy((caddr_t)(pn53x_stub_resp)+offset,
      (caddr_t)(pn53x_targets[tg].nti.nai.abtUid),
      len);
 offset += len;
 len = pn53x_targets[tg].nti.nai.szAtsLen;
 if (len) {
  pn53x_stub_resp[offset++] = len;
  memory_copy((caddr_t)(pn53x_stub_resp)+offset,
       (caddr_t)(pn53x_targets[tg].nti.nai.abtAts),
       len);
 }
}

static void pn53x_target_info_data(uint8_t tg,
       scs_off_t offset)
{
 pn53x_stub_resp[offset++] = tg;
 switch (((uint8_t)((pn53x_targets[tg].nm)>>8))) {
 case 0x00:
  pn53x_target_iso14443a_data(tg, offset);
  break;
 default:
  dbg_panic("avr-bug.c", 1183);
  break;
 }
}

uint8_t pn53x_stub_get_driver(uint16_t nm)
{
 uint8_t drv;
 for (drv = 0; drv < pn53x_nr_drivers; drv++) {
  if (nm == pn53x_stub_drivers[drv]->nm)
   break;
 }
 return drv;
}

static void pn53x_poll_targets(uint8_t period)
{
 scs_err_t err;
 uint8_t tg, drv;
 pn53x_stub_driver_t *driver;

 pn53x_nr_targets = 0;
 for (drv = 0; drv < pn53x_nr_drivers; drv++) {
  driver = pn53x_stub_drivers[drv];
  do { if (!driver || !driver->get_info) dbg_panic("avr-bug.c", 1207); } while (0);
  for (tg = 0; tg < 2; tg++) {
   pn53x_targets[tg].nm = driver->nm;
   err = driver->get_info(tg, &pn53x_targets[0].nti);
   if (err == 0x00) {
    pn53x_nr_targets++;
    break;
   }
  }
 }
}

void pn53x_response_InAutoPoll(void)
{
 uint8_t nr_poll;
 uint8_t period;
 uint8_t i;
 scs_off_t offset;




 nr_poll = pn53x_stub_cmd[(6 +(1))];
 period = pn53x_stub_cmd[(6 +(2))];
 do {
  if (pn53x_nr_targets == 0)
   pn53x_poll_targets(period);
  if (pn53x_nr_targets > 0)
   break;
  if (nr_poll != 0xFF)
   nr_poll--;
 } while (nr_poll > 0);

 offset = (6 +(1));
 pn53x_stub_resp[offset++] = pn53x_nr_targets;
 for (i = 0; i < pn53x_nr_targets; i++) {
  uint8_t size = pn53x_target_info_size(i);
  pn53x_stub_resp[offset++] =
   pn53x_nm_to_ptt(pn53x_targets[i].nm);
  pn53x_stub_resp[offset++] = size;
  pn53x_target_info_data(i, offset);
  offset += size;
 }
 pn53x_build_frame(offset-5);
}

static boolean pn53x_is_ciu_register(uint16_t reg)
{
 return (reg >= 0x6300) &&
        (reg < (0x6300 + 0x40));
}

void pn53x_ciu_write_register(uint16_t reg, uint8_t val)
{
 uint8_t index = ((reg) - 0x6300);
 do { if (!pn53x_is_ciu_register(reg)) dbg_panic("avr-bug.c", 1262); } while (0);
 pn53x_ciu_regs[index] = val;
}

uint8_t pn53x_ciu_read_register(uint16_t reg)
{
 uint8_t index = ((reg) - 0x6300);
 do { if (!pn53x_is_ciu_register(reg)) dbg_panic("avr-bug.c", 1269); } while (0);
 return pn53x_ciu_regs[index];
}

void pn53x_response_ReadRegister(void)
{
 uint8_t i, j;
 uint16_t reg;
 uint8_t val;

 for (i = 0, j = 0;
      i < (pn53x_stub_cmd[3]-2);
      i += 2, j++) {
  reg = ((uint16_t)(((uint16_t)(pn53x_stub_cmd[(6 +(2))+i])) | ((uint16_t)(pn53x_stub_cmd[(6 +(1))+i])) << 8))
                                        ;
  if (!pn53x_is_ciu_register(reg)) {
   if (reg == 0x6106) {
    val = pn53x_ctrl_reg_switch_rng;
   } else {
    pn53x_response_error(0x27);
    return;
   }
  } else {
   uint8_t mask;
   uint8_t index = ((reg) - 0x6300);
   mask = pn53x_ciu_readables[index];
   val = (pn53x_ciu_read_register(reg) & mask);
  }
  pn53x_stub_resp[(6 +(1))+j] = val;
 }
 pn53x_build_frame(j+2);
}

void pn53x_response_WriteRegister(void)
{
 uint8_t i;
 uint8_t val;
 uint16_t reg;

 for (i = 0;
      i < (pn53x_stub_cmd[3]-2);
      i += 3) {
  reg = ((uint16_t)(((uint16_t)(pn53x_stub_cmd[(6 +(2))+i])) | ((uint16_t)(pn53x_stub_cmd[(6 +(1))+i])) << 8))
                                        ;
  val = pn53x_stub_cmd[(6 +(3))+i];
  if (!pn53x_is_ciu_register(reg)) {
   if (reg == 0x6106) {
    pn53x_ctrl_reg_switch_rng = val;
   } else {
    pn53x_response_error(0x27);
    return;
   }
  } else {
   uint8_t mask;
   uint8_t index;
   index = ((reg) - 0x6300);
   mask = pn53x_ciu_writables[index];
   pn53x_ciu_write_register(reg, val & mask);
  }
 }
 pn53x_build_frame(2);
}

void pn53x_response_ReadGPIO(void)
{
 pn53x_stub_resp[(6 +(1))] = (pn53x_sfr_p3 & (~((1 << (7)) | (1 << (6)))));
 pn53x_stub_resp[(6 +(2))] = (pn53x_sfr_p7 & ((1 << (2)) | (1 << (1))));
 pn53x_stub_resp[(6 +(3))] = pn53x_hci_mode;
 pn53x_build_frame(5);
}

void pn53x_response_WriteGPIO(void)
{
 pn53x_sfr_p3 = pn53x_stub_cmd[(6 +(1))];
 pn53x_sfr_p7 = pn53x_stub_cmd[(6 +(2))];
 pn53x_build_frame(2);
}

void pn53x_response_SetSerialBaudRate(void)
{
 pn53x_serial_br = pn53x_stub_cmd[(6 +(1))];
 pn53x_build_frame(2);
}

void pn53x_response_SAMConfiguration(void)
{
 uint8_t mode;
 uint8_t timeout;
 uint8_t irq;
 mode = pn53x_stub_cmd[(6 +(1))];
 timeout = pn53x_stub_cmd[(6 +(2))];
 if (pn53x_stub_cmd[3] > 4)
  irq = pn53x_stub_cmd[(6 +(3))];
 pn53x_build_frame(2);
}

void pn53x_response_PowerDown(void)
{
 uint8_t wakeupenable;
 uint8_t generateirq;
 wakeupenable = pn53x_stub_cmd[(6 +(1))];
 if (pn53x_stub_cmd[3] > 3)
  generateirq = pn53x_stub_cmd[(6 +(2))];
 pn53x_response_error(0x00);
}

void pn53x_response_RFConfiguration(void)
{
 uint8_t type = pn53x_stub_cmd[(6 +(1))];

 switch (type) {
 case 0x01:
 case 0x04:
  break;
 case 0x02:
 case 0x05:
 case 0x0C:
  break;
 case 0x0B:
  break;
 case 0x0D:
  break;
 case 0x0A:
  break;
 default:
  dbg_panic("avr-bug.c", 1394);
  break;
 }
 pn53x_build_frame(2);
}

void pn53x_response_InListPassiveTarget(void)
{
 uint8_t i;
 uint8_t modulation;
 uint8_t max_targets, nr_targets;
 scs_off_t offset;


 max_targets = pn53x_stub_cmd[(6 +(1))];
 if (max_targets > 2) {

  pn53x_response_error(0x2a);
  return;
 }
 if (max_targets > pn53x_nr_targets)
  max_targets = pn53x_nr_targets;

 if (pn53x_nr_targets == 0)
  pn53x_poll_targets(0);

 modulation = pn53x_stub_cmd[(6 +(2))];
 nr_targets = 0;
 offset = (6 +(2));
 for (i = 0; i < pn53x_nr_targets; i++) {
  if (pn53x_nm_to_pm(pn53x_targets[i].nm) == modulation) {
   nr_targets++;
   pn53x_target_info_data(i, offset);
   offset += pn53x_target_info_size(i);
  }
 }
 pn53x_stub_resp[(6 +(1))] = nr_targets;
 pn53x_build_frame(offset-5);
}

void pn53x_response_InDataExchange(void)
{
 uint8_t tg, drv;
 scs_off_t offset, i;
 scs_size_t len;
 pn53x_stub_driver_t *driver;
 scs_err_t err;

 tg = pn53x_stub_cmd[(6 +(1))];
 if (tg >= pn53x_nr_targets) {
  pn53x_response_error(0x2a);
  return;
 }

 drv = pn53x_stub_get_driver(pn53x_targets[tg].nm);
 driver = pn53x_stub_drivers[drv];

 do { if (!driver) dbg_panic("avr-bug.c", 1451); } while (0);
 do { if (!driver->write_byte || !driver->write_ready) dbg_panic("avr-bug.c", 1452); } while (0);


 offset = (6 +(2));
 len = pn53x_stub_cmd[3]-2;
 for (i = 0; i < len; i++) {
  driver->write_byte(tg, i, pn53x_stub_cmd[offset++]);
 }
 driver->write_ready(tg, i);





 do { if (!driver->read_ready || !driver->read_count || !driver->read_byte) dbg_panic(
 "avr-bug.c"
# 1466 "avr-bug.c"
 ,
 1467
# 1466 "avr-bug.c"
 ); } while (0)
                           ;
 do {
  err = driver->read_ready(tg);
  if (err != 0x0A)
   break;
 } while (1);

 if (err != 0x00) {
  pn53x_response_error(0x27);
  return;
 }


 pn53x_stub_resp[(6 +(1))] = 0x00;

 offset = (6 +(2));
 len = driver->read_count(tg);
 for (i = 0; i < len; i++) {
  pn53x_stub_resp[offset++] = driver->read_byte(tg, i);
 }
 pn53x_build_frame(offset-5);
}

boolean pn53x_valiate_cmd(void)
{
 uint8_t i;
 uint8_t dcs;


 if (0x00 != (uint8_t)(pn53x_stub_cmd[3]+
         pn53x_stub_cmd[4]))
  return (unsigned char)0;

 if (pn53x_stub_cmd[5] != 0xD4)
  return (unsigned char)0;

 for (i = 0, dcs = 0; i <= pn53x_stub_cmd[3]; i++)
  dcs += pn53x_stub_cmd[5 +i];
 if (dcs != 0x00)
  return (unsigned char)0;
 return !(unsigned char)0;
}

void pn53x_xchg_pseudo(void)
{
 uint8_t cmd;

 pn53x_stub_resp[0] = 0x00;
 pn53x_stub_resp[1] = 0x00;
 pn53x_stub_resp[2] = 0xFF;
 pn53x_stub_resp[5] = 0xD5;
 pn53x_stub_resp[6] = pn53x_stub_cmd[6] + 1;
 cmd = pn53x_stub_cmd[6];
 dbg_print(((10<<4)+2), (cmd));
 switch (cmd) {
 case 0x00:
  pn53x_response_Diagnose();
  break;
 case 0x02:
  pn53x_response_GetFirmwareVersion();
  break;
 case 0x06:
  pn53x_response_ReadRegister();
  break;
 case 0x08:
  pn53x_response_WriteRegister();
  break;
 case 0x0C:
  pn53x_response_ReadGPIO();
  break;
 case 0x0E:
  pn53x_response_WriteGPIO();
  break;
 case 0x10:
  pn53x_response_SetSerialBaudRate();
  break;
 case 0x12:
  pn53x_response_SetParameters();
  break;
 case 0x14:
  pn53x_response_SAMConfiguration();
  break;
 case 0x16:
  pn53x_response_PowerDown();
  break;
 case 0x32:
  pn53x_response_RFConfiguration();
  break;
 case 0x4A:
  pn53x_response_InListPassiveTarget();
  break;
 case 0x60:
  pn53x_response_InAutoPoll();
  break;
 case 0x40:
  pn53x_response_InDataExchange();
  break;
 case 0x56:
 case 0x46:
 case 0x48:
 case 0x50:
 case 0x4E:
 case 0x42:
 case 0x38:
 case 0x44:
 case 0x52:
 case 0x54:
 case 0x18:
 default:
  pn53x_response_error(0x27);
  break;
 }
}

uint8_t pn53x_register_stub_driver(pn53x_stub_driver_t *driver)
{
 uint8_t drv = pn53x_nr_drivers;
 do { if (drv >= 1) dbg_panic("avr-bug.c", 1584); } while (0);
 pn53x_stub_drivers[drv] = driver;
 pn53x_nr_drivers++;
 return drv;
}

boolean pn53x_hw_poll_ready(void)
{
 return pn53x_stub_ready;
}

void pn53x_hw_read_cmpl(scs_size_t ne)
{
 pn53x_stub_ready = (unsigned char)0;
 if (!pn53x_stub_is_resp && pn53x_stub_is_cmd) {
  pn53x_xchg_pseudo();
 }
}

void pn53x_hw_write_cmpl(scs_size_t nc)
{
 pn53x_stub_nc = nc;

 pn53x_stub_ready = (unsigned char)0;
 switch (((uint16_t)(((uint16_t)((pn53x_stub_cmd)[4])) | ((uint16_t)((pn53x_stub_cmd)[3])) << 8))) {
 case 0x00FF:
  pn53x_stub_is_cmd = (unsigned char)0;
  pn53x_stub_is_resp = (unsigned char)0;
  pn53x_stub_ne = 0;
  break;
 case 0xFF00:
  if (pn53x_stub_is_resp)
   pn53x_stub_ready = !(unsigned char)0;
  break;
 default:

  if (pn53x_valiate_cmd()) {
   pn53x_stub_is_cmd = !(unsigned char)0;
   pn53x_stub_is_resp = (unsigned char)0;
   pn53x_stub_resp[0] = 0x00;
   pn53x_stub_resp[1] = 0x00;
   pn53x_stub_resp[2] = 0xFF;
   pn53x_stub_resp[3] = 0x00;
   pn53x_stub_resp[4] = 0xFF;
   pn53x_stub_resp[5] = 0x00;
   pn53x_stub_ne = 6;
   pn53x_stub_ready = !(unsigned char)0;
  }
  break;
 }
}

uint8_t pn53x_hw_xchg_read(scs_off_t index)
{
 if (index < pn53x_stub_ne)
  return pn53x_stub_resp[index];
 return 0;
}

void pn53x_hw_xchg_write(scs_off_t index, uint8_t val)
{
 pn53x_stub_cmd[index] = val;
}

void pn53x_hw_ctrl_init(void)
{
 pn53x_stub_nc = 0;
 pn53x_stub_ne = 0;
 pn53x_stub_ready = (unsigned char)0;
 pn53x_stub_is_resp = (unsigned char)0;
 pn53x_stub_is_cmd = (unsigned char)0;
 pn53x_stub_driver_init();
}