static int xbee_set(netdev_t *ndev, netopt_t opt, void *value, size_t len)
{
xbee_t *dev = (xbee_t *)ndev;
assert(dev);
switch (opt) {
case NETOPT_ADDRESS:
return _set_addr(dev, (uint8_t *)value, len);
case NETOPT_ADDR_LEN:
case NETOPT_SRC_LEN:
return _set_addr_len(dev, value, len);
case NETOPT_CHANNEL:
return _set_channel(dev, (uint8_t *)value, len);
case NETOPT_NID:
return _set_panid(dev, (uint8_t *)value, len);
#ifdef MODULE_XBEE_ENCRYPTION
case NETOPT_ENCRYPTION:
return _set_encryption(dev, (uint8_t *)value);
case NETOPT_ENCRYPTION_KEY:
return _set_encryption_key(dev, (uint8_t *)value, len);
#endif
default:
return -ENOTSUP;
}
}
NICEAPI_EXPORT gboolean
nice_candidate_set_base_addr (NiceCandidate *candidate, const gchar *addr, guint port)
{
return _set_addr (&candidate->base_addr, addr, port);
}
/*******************************************************************************
* NFC_Write
*
* Description : write one page data into flash in single plane mode.
* Arguments : *wcmd -- the write command sequence list head。
* *mainbuf -- point to data buffer address, it must be four bytes align.
* *sparebuf -- point to spare buffer address.
* dma_wait_mode -- how to deal when dma start, 0 = wait till dma finish,
1 = dma interrupt was set and now sleep till interrupt occurs.
* rb_wait_mode -- 0 = do not care rb, 1 = set rb interrupt and do not wait rb ready.
* page_mode -- 0 = common command, 1 = page command.
* Returns : 0 = success.
-1 = fail.
* Notes : the unit must be page, so if page_mode is not 1, return fail,the function exits without checking status,
if the commands do not fetch data,ecc is not neccesary.
********************************************************************************/
__s32 NFC_Write( NFC_CMD_LIST *wcmd, void *mainbuf, void *sparebuf, __u8 dma_wait_mode, __u8 rb_wait_mode,
__u8 page_mode)
{
__s32 ret;
__s32 i;
__u32 cfg;
__u32 program_cmd,random_program_cmd;
NFC_CMD_LIST *cur_cmd,*program_addr_cmd;
if (page_mode == 0){
return -1;
}
ret = 0;
_enter_nand_critical();
/*write in page_mode*/
program_addr_cmd = wcmd;
cur_cmd = wcmd;
cur_cmd = cur_cmd->next;
random_program_cmd = cur_cmd->value;
cur_cmd = cur_cmd->next;
program_cmd = cur_cmd->value;
//access NFC internal RAM by DMA bus
NFC_WRITE_REG(NFC_REG_CTL, (NFC_READ_REG(NFC_REG_CTL)) | NFC_RAM_METHOD);
/*set dma and run*/
// if (NFC_IS_SDRAM((__u32)mainbuf))
// attr = 0x2930281;
// else
// attr = 0x2930280;
_dma_config_start(1, (__u32)mainbuf, pagesize);
/*wait cmd fifo free*/
ret = _wait_cmdfifo_free();
if (ret){
_exit_nand_critical();
return ret;
}
/*set NFC_REG_CNT*/
NFC_WRITE_REG(NFC_REG_CNT,1024);
/*set NFC_REG_RCMD_SET*/
cfg = 0;
cfg |= (program_cmd & 0xff);
cfg |= ((random_program_cmd & 0xff) << 8);
NFC_WRITE_REG(NFC_REG_WCMD_SET, cfg);
/*set NFC_REG_SECTOR_NUM*/
NFC_WRITE_REG(NFC_REG_SECTOR_NUM, pagesize/1024);
/*set user data*/
for (i = 0; i < pagesize/1024; i++){
NFC_WRITE_REG(NFC_REG_USER_DATA(i), *((__u32 *)sparebuf + i) );
}
/*set addr*/
_set_addr(program_addr_cmd->addr,program_addr_cmd->addr_cycle);
/*set NFC_REG_CMD*/
cfg = 0;
/*set sequence mode*/
//cfg |= 0x1<<25;
cfg |= program_addr_cmd->value;
cfg |= ( (program_addr_cmd->addr_cycle - 1) << 16);
//cfg |= (NFC_SEND_ADR | NFC_ACCESS_DIR | NFC_DATA_TRANS | NFC_SEND_CMD | NFC_WAIT_FLAG | NFC_DATA_SWAP_METHOD);
cfg |= (NFC_SEND_ADR | NFC_ACCESS_DIR | NFC_DATA_TRANS | NFC_SEND_CMD1 | NFC_SEND_CMD2 | NFC_DATA_SWAP_METHOD);
cfg |= ((__u32)0x2 << 30);//page command
if (pagesize/1024 == 1)
cfg |= NFC_SEQ;
/*enable ecc*/
_enable_ecc(1);
NFC_WRITE_REG(NFC_REG_CMD,cfg);
NAND_WaitDmaFinish();
_wait_twb();
_wait_cmdfifo_free();
_wait_cmd_finish();
/*start dma?*/
/*if dma mode is wait*/
if(0 == dma_wait_mode){
ret = _wait_dma_end();
}
/*disable ecc*/
_disable_ecc();
/*switch to ahb*/
NFC_WRITE_REG(NFC_REG_CTL, (NFC_READ_REG(NFC_REG_CTL)) & (~NFC_RAM_METHOD));
_exit_nand_critical();
return ret;
}
__s32 _read_in_page_mode_spare(NFC_CMD_LIST *rcmd,void *mainbuf,void *sparebuf,__u8 dma_wait_mode)
{
__s32 ret,ret1;
__s32 i;
__u32 cfg;
NFC_CMD_LIST *cur_cmd,*read_addr_cmd;
__u32 read_data_cmd,random_read_cmd0,random_read_cmd1;
ret = 0;
read_addr_cmd = rcmd;
cur_cmd = rcmd;
cur_cmd = cur_cmd->next;
random_read_cmd0 = cur_cmd->value;
cur_cmd = cur_cmd->next;
random_read_cmd1 = cur_cmd->value;
cur_cmd = cur_cmd->next;
read_data_cmd = cur_cmd->value;
//access NFC internal RAM by DMA bus
NFC_WRITE_REG(NFC_REG_CTL, (NFC_READ_REG(NFC_REG_CTL)) | NFC_RAM_METHOD);
///*set dma and run*/
///*sdram*/
//if (NFC_IS_SDRAM((__u32)mainbuf))
// attr = 0x2810293;
///*sram*/
//else
// attr = 0x2800293;
_dma_config_start(0, (__u32)mainbuf, 2048);
/*wait cmd fifo free*/
ret = _wait_cmdfifo_free();
if (ret)
return ret;
/*set NFC_REG_CNT*/
NFC_WRITE_REG(NFC_REG_CNT,1024);
/*set NFC_REG_RCMD_SET*/
cfg = 0;
cfg |= (read_data_cmd & 0xff);
cfg |= ((random_read_cmd0 & 0xff) << 8);
cfg |= ((random_read_cmd1 & 0xff) << 16);
NFC_WRITE_REG(NFC_REG_RCMD_SET, cfg);
/*set NFC_REG_SECTOR_NUM*/
NFC_WRITE_REG(NFC_REG_SECTOR_NUM, 2048/1024);
/*set addr*/
_set_addr(read_addr_cmd->addr,read_addr_cmd->addr_cycle);
/*set NFC_REG_CMD*/
cfg = 0;
cfg |= read_addr_cmd->value;
/*set sequence mode*/
//cfg |= 0x1<<25;
cfg |= ( (read_addr_cmd->addr_cycle - 1) << 16);
cfg |= (NFC_SEND_ADR | NFC_DATA_TRANS | NFC_SEND_CMD1 | NFC_SEND_CMD2 | NFC_WAIT_FLAG | NFC_DATA_SWAP_METHOD);
cfg |= ((__u32)0x2 << 30);//page command
if (pagesize/1024 == 1)
cfg |= NFC_SEQ;
/*enable ecc*/
_enable_ecc(1);
NFC_WRITE_REG(NFC_REG_CMD,cfg);
NAND_WaitDmaFinish();//
/*wait cmd fifo free and cmd finish*/
ret = _wait_cmdfifo_free();
ret |= _wait_cmd_finish();
if (ret){
_disable_ecc();
return ret;
}
/*get user data*/
for (i = 0; i < 2048/1024; i++){
*(((__u32*) sparebuf)+i) = NFC_READ_REG(NFC_REG_USER_DATA(i));
}
/*ecc check and disable ecc*/
ret = _check_ecc(2048/1024);
_disable_ecc();
/*if dma mode is wait*/
if(0 == dma_wait_mode){
ret1 = _wait_dma_end();
if (ret1)
return ret1;
}
return ret;
}
__s32 _read_in_page_mode_seq(NFC_CMD_LIST *rcmd,void *mainbuf,void *sparebuf,__u8 dma_wait_mode)
{
__s32 ret,ret1;
__s32 i;
__u32 cfg;
NFC_CMD_LIST *cur_cmd,*read_addr_cmd;
__u32 read_data_cmd,random_read_cmd0,random_read_cmd1;
__u32 page_size_temp, ecc_mode_temp, page_size_set, ecc_set;
ret = 0;
read_addr_cmd = rcmd;
cur_cmd = rcmd;
cur_cmd = cur_cmd->next;
random_read_cmd0 = cur_cmd->value;
cur_cmd = cur_cmd->next;
random_read_cmd1 = cur_cmd->value;
cur_cmd = cur_cmd->next;
read_data_cmd = cur_cmd->value;
//access NFC internal RAM by DMA bus
NFC_WRITE_REG(NFC_REG_CTL, (NFC_READ_REG(NFC_REG_CTL)) | NFC_RAM_METHOD);
//set pagesize to 8K
page_size_temp = (NFC_READ_REG(NFC_REG_CTL) & 0xf00)>>8;
NFC_WRITE_REG(NFC_REG_CTL, ((NFC_READ_REG(NFC_REG_CTL)) & (~NFC_PAGE_SIZE))| (0x3<<8));
page_size_set = 8192;
_dma_config_start(0, (__u32)mainbuf, page_size_set);
/*wait cmd fifo free*/
ret = _wait_cmdfifo_free();
if (ret)
return ret;
/*set NFC_REG_CNT*/
NFC_WRITE_REG(NFC_REG_CNT,1024);
/*set NFC_REG_RCMD_SET*/
cfg = 0;
cfg |= (read_data_cmd & 0xff);
cfg |= ((random_read_cmd0 & 0xff) << 8);
cfg |= ((random_read_cmd1 & 0xff) << 16);
NFC_WRITE_REG(NFC_REG_RCMD_SET, cfg);
/*set NFC_REG_SECTOR_NUM*/
NFC_WRITE_REG(NFC_REG_SECTOR_NUM, page_size_set/1024);
/*set addr*/
_set_addr(read_addr_cmd->addr,read_addr_cmd->addr_cycle);
/*set NFC_REG_CMD*/
cfg = 0;
cfg |= read_addr_cmd->value;
/*set sequence mode*/
cfg |= 0x1<<25;
cfg |= ( (read_addr_cmd->addr_cycle - 1) << 16);
cfg |= (NFC_SEND_ADR | NFC_DATA_TRANS | NFC_SEND_CMD1 | NFC_SEND_CMD2 | NFC_WAIT_FLAG | NFC_DATA_SWAP_METHOD);
cfg |= ((__u32)0x2 << 30);//page command
/*enable ecc*/
_enable_ecc(1);
/*set ecc to specified ecc*/
ecc_mode_temp = (NFC_READ_REG(NFC_REG_ECC_CTL) & 0xf000)>>12;
if(ecc_mode_temp>=4) //change for hynix 2y nm flash
ecc_set = 0x4;
else//change for hynix 2x nm flash
ecc_set = 0x1;
NFC_WRITE_REG(NFC_REG_ECC_CTL, ((NFC_READ_REG(NFC_REG_ECC_CTL) & (~NFC_ECC_MODE))|(ecc_set<<12) ));
NFC_WRITE_REG(NFC_REG_CMD,cfg);
NAND_WaitDmaFinish();
/*wait cmd fifo free and cmd finish*/
ret = _wait_cmdfifo_free();
ret |= _wait_cmd_finish();
if (ret){
_disable_ecc();
return ret;
}
/*get user data*/
for (i = 0; i < page_size_set/1024; i++){
*(((__u32*) sparebuf)+i) = NFC_READ_REG(NFC_REG_USER_DATA(i));
}
/*ecc check and disable ecc*/
ret = _check_ecc(page_size_set/1024);
_disable_ecc();
/*if dma mode is wait*/
// if(0 == dma_wait_mode){
// ret1 = _wait_dma_end();
// if (ret1)
// return ret1;
// }
/*set ecc to original value*/
NFC_WRITE_REG(NFC_REG_ECC_CTL, (NFC_READ_REG(NFC_REG_ECC_CTL) & (~NFC_ECC_MODE))|(ecc_mode_temp<<12));
/*set pagesize to original value*/
NFC_WRITE_REG(NFC_REG_CTL, ((NFC_READ_REG(NFC_REG_CTL)) & (~NFC_PAGE_SIZE)) | (page_size_temp<<8));
return ret;
}
__s32 NFC_Write_Seq( NFC_CMD_LIST *wcmd, void *mainbuf, void *sparebuf, __u8 dma_wait_mode, __u8 rb_wait_mode,
__u8 page_mode)
{
__s32 ret;
__s32 i;
__u32 cfg;
__u32 page_size_temp, ecc_mode_temp,page_size_set,ecc_set;
__u32 program_cmd,random_program_cmd;
NFC_CMD_LIST *cur_cmd,*program_addr_cmd;
if (page_mode == 0){
return -1;
}
ret = 0;
_enter_nand_critical();
/*write in page_mode*/
program_addr_cmd = wcmd;
cur_cmd = wcmd;
cur_cmd = cur_cmd->next;
random_program_cmd = cur_cmd->value;
cur_cmd = cur_cmd->next;
program_cmd = cur_cmd->value;
//access NFC internal RAM by DMA bus
NFC_WRITE_REG(NFC_REG_CTL, (NFC_READ_REG(NFC_REG_CTL)) | NFC_RAM_METHOD);
//set pagesize to 8K for burn boot0 lsb mode
page_size_temp = (NFC_READ_REG(NFC_REG_CTL) & 0xf00)>>8;
NFC_WRITE_REG(NFC_REG_CTL, ((NFC_READ_REG(NFC_REG_CTL)) & (~NFC_PAGE_SIZE))| (0x3<<8));
page_size_set = 8192; //fix pagesize 8k to burn boot1.bin for hynix 2x and 2y nm flash
_dma_config_start(1, (__u32)mainbuf, page_size_set);
/*wait cmd fifo free*/
ret = _wait_cmdfifo_free();
if (ret){
_exit_nand_critical();
return ret;
}
/*set NFC_REG_CNT*/
NFC_WRITE_REG(NFC_REG_CNT,1024);
/*set NFC_REG_RCMD_SET*/
cfg = 0;
cfg |= (program_cmd & 0xff);
cfg |= ((random_program_cmd & 0xff) << 8);
NFC_WRITE_REG(NFC_REG_WCMD_SET, cfg);
/*set NFC_REG_SECTOR_NUM*/
NFC_WRITE_REG(NFC_REG_SECTOR_NUM, page_size_set/1024);
/*set user data*/
for (i = 0; i < page_size_set/1024; i++){
NFC_WRITE_REG(NFC_REG_USER_DATA(i), *((__u32 *)sparebuf + i) );
}
/*set addr*/
_set_addr(program_addr_cmd->addr,program_addr_cmd->addr_cycle);
/*set NFC_REG_CMD*/
cfg = 0;
/*set sequence mode*/
cfg |= 0x1<<25;
cfg |= program_addr_cmd->value;
cfg |= ( (program_addr_cmd->addr_cycle - 1) << 16);
//cfg |= (NFC_SEND_ADR | NFC_ACCESS_DIR | NFC_DATA_TRANS | NFC_SEND_CMD | NFC_WAIT_FLAG | NFC_DATA_SWAP_METHOD);
cfg |= (NFC_SEND_ADR | NFC_ACCESS_DIR | NFC_DATA_TRANS | NFC_SEND_CMD1 | NFC_SEND_CMD2 | NFC_DATA_SWAP_METHOD);
cfg |= ((__u32)0x2 << 30);//page command
/*enable ecc*/
_enable_ecc(1);
/*set ecc to specified ecc*/
ecc_mode_temp = (NFC_READ_REG(NFC_REG_ECC_CTL) & 0xf000)>>12;
if(ecc_mode_temp>=4) //change for hynix 2y nm flash
ecc_set = 0x4;
else//change for hynix 2x nm flash
ecc_set = 0x1;
NFC_WRITE_REG(NFC_REG_ECC_CTL, ((NFC_READ_REG(NFC_REG_ECC_CTL) & (~NFC_ECC_MODE))|(ecc_set<<12) ));
NFC_WRITE_REG(NFC_REG_CMD,cfg);
NAND_WaitDmaFinish();
_wait_twb();
_wait_cmdfifo_free();
_wait_cmd_finish();
/*start dma?*/
/*if dma mode is wait*/
// if(0 == dma_wait_mode){
// ret = _wait_dma_end();
// }
/*disable ecc*/
_disable_ecc();
/*set ecc to original value*/
NFC_WRITE_REG(NFC_REG_ECC_CTL, (NFC_READ_REG(NFC_REG_ECC_CTL) & (~NFC_ECC_MODE))|(ecc_mode_temp<<12));
/*set pagesize to original value*/
NFC_WRITE_REG(NFC_REG_CTL, ((NFC_READ_REG(NFC_REG_CTL)) & (~NFC_PAGE_SIZE)) | (page_size_temp<<8));
/*switch to ahb*/
NFC_WRITE_REG(NFC_REG_CTL, (NFC_READ_REG(NFC_REG_CTL)) & (~NFC_RAM_METHOD));
_exit_nand_critical();
return ret;
}
int xbee_init(netdev_t *dev)
{
uint8_t tmp[2];
xbee_t *xbee = (xbee_t *)dev;
/* set default options */
xbee->addr_flags = XBEE_ADDR_FLAGS_LONG;
xbee->options = 0;
/* initialize buffers and locks*/
mutex_init(&(xbee->tx_lock));
mutex_init(&(xbee->resp_lock));
xbee->resp_limit = 1; /* needs to be greater then 0 initially */
xbee->rx_count = 0;
/* initialize UART and GPIO pins */
if (uart_init(xbee->p.uart, xbee->p.br, _rx_cb, xbee) != UART_OK) {
DEBUG("[xbee] init: error initializing UART\n");
return -ENXIO;
}
/* if reset pin is connected, do a hardware reset */
if (xbee->p.pin_reset != GPIO_UNDEF) {
gpio_clear(xbee->p.pin_reset);
xtimer_usleep(RESET_DELAY);
gpio_set(xbee->p.pin_reset);
}
/* put the XBee device into command mode */
xtimer_usleep(ENTER_CMD_MODE_DELAY);
_at_cmd(xbee, "+++");
xtimer_usleep(ENTER_CMD_MODE_DELAY);
/* disable non IEEE802.15.4 extensions */
_at_cmd(xbee, "ATMM2\r");
/* put XBee module in "API mode without escaped characters" */
_at_cmd(xbee, "ATAP1\r");
/* apply AT commands */
_at_cmd(xbee, "ATAC\r");
/* exit command mode */
_at_cmd(xbee, "ATCN\r");
/* load long address (we can not set it, its read only for Xbee devices) */
if (_get_addr_long(xbee, xbee->addr_long.uint8, IEEE802154_LONG_ADDRESS_LEN) < 0) {
DEBUG("[xbee] init: error getting address\n");
return -EIO;
}
if (_set_addr(xbee, &((xbee->addr_long).uint8[6]), IEEE802154_SHORT_ADDRESS_LEN) < 0) {
DEBUG("[xbee] init: error setting short address\n");
return -EIO;
}
/* set default channel */
tmp[1] = 0;
tmp[0] = XBEE_DEFAULT_CHANNEL;
if (_set_channel(xbee, tmp, 2) < 0) {
DEBUG("[xbee] init: error setting channel\n");
return -EIO;
}
/* set default PAN ID */
tmp[1] = (uint8_t)(XBEE_DEFAULT_PANID >> 8);
tmp[0] = (uint8_t)(XBEE_DEFAULT_PANID & 0xff);
if (_set_panid(xbee, tmp, 2) < 0) {
DEBUG("[xbee] init: error setting PAN ID\n");
return -EIO;
}
DEBUG("[xbee] init: Initialization successful\n");
return 0;
}
__s32 _read_in_page_mode_spare_first(NFC_CMD_LIST *rcmd,void *mainbuf,void *sparebuf,__u8 dma_wait_mode)
{
__s32 ret;
__u32 cfg;
NFC_CMD_LIST *cur_cmd,*read_addr_cmd;
__u32 read_data_cmd,random_read_cmd0,random_read_cmd1;
ret = 0;
read_addr_cmd = rcmd;
cur_cmd = rcmd;
cur_cmd = cur_cmd->next;
random_read_cmd0 = cur_cmd->value;
cur_cmd = cur_cmd->next;
random_read_cmd1 = cur_cmd->value;
cur_cmd = cur_cmd->next;
read_data_cmd = cur_cmd->value;
//access NFC internal RAM by DMA bus
NFC_WRITE_REG(NFC_REG_CTL, (NFC_READ_REG(NFC_REG_CTL)) | NFC_RAM_METHOD);
//_dma_config_start(0, (__u32)mainbuf, 2048);
/*wait cmd fifo free*/
ret = _wait_cmdfifo_free();
if (ret)
return ret;
/*set NFC_REG_CNT*/
NFC_WRITE_REG(NFC_REG_CNT,1024);
/*set NFC_REG_RCMD_SET*/
cfg = 0;
cfg |= (read_data_cmd & 0xff);
cfg |= ((random_read_cmd0 & 0xff) << 8);
cfg |= ((random_read_cmd1 & 0xff) << 16);
NFC_WRITE_REG(NFC_REG_RCMD_SET, cfg);
/*set NFC_REG_SECTOR_NUM*/
NFC_WRITE_REG(NFC_REG_SECTOR_NUM, 2048/1024);
/*set addr*/
_set_addr(read_addr_cmd->addr,read_addr_cmd->addr_cycle);
/*set NFC_REG_CMD*/
cfg = 0;
cfg |= read_addr_cmd->value;
/*set sequence mode*/
//cfg |= 0x1<<25;
cfg |= ( (read_addr_cmd->addr_cycle - 1) << 16);
//cfg |= (NFC_SEND_ADR | NFC_DATA_TRANS | NFC_SEND_CMD1 | NFC_SEND_CMD2 | NFC_WAIT_FLAG | NFC_DATA_SWAP_METHOD);
cfg |= (NFC_SEND_ADR | NFC_DATA_TRANS | NFC_SEND_CMD1 | NFC_SEND_CMD2 | NFC_WAIT_FLAG );
cfg |= ((__u32)0x2 << 30);//page command
if (pagesize/1024 == 1)
cfg |= NFC_SEQ;
/*enable ecc*/
_enable_ecc(1);
NFC_WRITE_REG(NFC_REG_CMD,cfg);
return ret;
}
__s32 NFC_Write_1K( NFC_CMD_LIST *wcmd, void *mainbuf, void *sparebuf, __u8 dma_wait_mode, __u8 rb_wait_mode,
__u8 page_mode)
{
__s32 ret;
__s32 i;
__u32 cfg;
__u32 page_size_temp, ecc_mode_temp;
__u32 program_cmd,random_program_cmd;
NFC_CMD_LIST *cur_cmd,*program_addr_cmd;
if (page_mode == 0){
return -1;
}
ret = 0;
_enter_nand_critical();
/*write in page_mode*/
program_addr_cmd = wcmd;
cur_cmd = wcmd;
cur_cmd = cur_cmd->next;
random_program_cmd = cur_cmd->value;
cur_cmd = cur_cmd->next;
program_cmd = cur_cmd->value;
//access NFC internal RAM by DMA bus
NFC_WRITE_REG(NFC_REG_CTL, (NFC_READ_REG(NFC_REG_CTL)) | NFC_RAM_METHOD);
//set pagesize to 1K
page_size_temp = (NFC_READ_REG(NFC_REG_CTL) & 0xf00)>>8;
NFC_WRITE_REG(NFC_REG_CTL, ((NFC_READ_REG(NFC_REG_CTL)) & (~NFC_PAGE_SIZE))| (0x0<<8));
_dma_config_start(1, (__u32)mainbuf, 1024);
/*wait cmd fifo free*/
ret = _wait_cmdfifo_free();
if (ret){
_exit_nand_critical();
return ret;
}
/*set NFC_REG_CNT*/
NFC_WRITE_REG(NFC_REG_CNT,1024);
/*set NFC_REG_RCMD_SET*/
cfg = 0;
cfg |= (program_cmd & 0xff);
cfg |= ((random_program_cmd & 0xff) << 8);
NFC_WRITE_REG(NFC_REG_WCMD_SET, cfg);
/*set NFC_REG_SECTOR_NUM*/
NFC_WRITE_REG(NFC_REG_SECTOR_NUM, 1024/1024);
/*set user data*/
for (i = 0; i < 1024/1024; i++){
NFC_WRITE_REG(NFC_REG_USER_DATA(i), *((__u32 *)sparebuf + i) );
}
/*set addr*/
_set_addr(program_addr_cmd->addr,program_addr_cmd->addr_cycle);
/*set NFC_REG_CMD*/
cfg = 0;
/*set sequence mode*/
cfg |= 0x1<<25;
cfg |= program_addr_cmd->value;
cfg |= ( (program_addr_cmd->addr_cycle - 1) << 16);
//cfg |= (NFC_SEND_ADR | NFC_ACCESS_DIR | NFC_DATA_TRANS | NFC_SEND_CMD | NFC_WAIT_FLAG | NFC_DATA_SWAP_METHOD);
cfg |= (NFC_SEND_ADR | NFC_ACCESS_DIR | NFC_DATA_TRANS | NFC_SEND_CMD1 | NFC_SEND_CMD2 | NFC_DATA_SWAP_METHOD);
cfg |= ((__u32)0x2 << 30);//page command
if (pagesize/1024 == 1)
cfg |= NFC_SEQ;
/*enable ecc*/
_enable_ecc(1);
/*set ecc to 64-bit ecc*/
ecc_mode_temp = (NFC_READ_REG(NFC_REG_ECC_CTL) & 0xf000)>>12;
NFC_WRITE_REG(NFC_REG_ECC_CTL, ((NFC_READ_REG(NFC_REG_ECC_CTL) & (~NFC_ECC_MODE))|(0x8<<12) ));
NFC_WRITE_REG(NFC_REG_CMD,cfg);
NAND_WaitDmaFinish();
ret = _wait_dma_end(1, (__u32)mainbuf, 1024);
if (ret)
return ret;
_wait_twb();
_wait_cmdfifo_free();
_wait_cmd_finish();
/*disable ecc*/
_disable_ecc();
/*set ecc to original value*/
NFC_WRITE_REG(NFC_REG_ECC_CTL, (NFC_READ_REG(NFC_REG_ECC_CTL) & (~NFC_ECC_MODE))|(ecc_mode_temp<<12));
/*set pagesize to original value*/
NFC_WRITE_REG(NFC_REG_CTL, ((NFC_READ_REG(NFC_REG_CTL)) & (~NFC_PAGE_SIZE)) | (page_size_temp<<8));
/*switch to ahb*/
NFC_WRITE_REG(NFC_REG_CTL, (NFC_READ_REG(NFC_REG_CTL)) & (~NFC_RAM_METHOD));
_exit_nand_critical();
return ret;
}
/*
* Driver's "public" functions
*/
int xbee_init(xbee_t *dev, uart_t uart, uint32_t baudrate,
gpio_t reset_pin, gpio_t sleep_pin)
{
uint8_t tmp[2];
/* check device and bus parameters */
if (dev == NULL) {
return -ENODEV;
}
if (uart >= UART_NUMOF) {
return -ENXIO;
}
/* set device driver */
dev->driver = &xbee_driver;
/* set peripherals to use */
dev->uart = uart;
dev->reset_pin = reset_pin;
dev->sleep_pin = sleep_pin;
/* set default options */
dev->addr_flags = 0;
dev->proto = XBEE_DEFAULT_PROTOCOL;
dev->options = 0;
/* initialize buffers and locks*/
mutex_init(&(dev->tx_lock));
mutex_init(&(dev->resp_lock));
dev->resp_limit = 1; /* needs to be greater then 0 initially */
dev->rx_count = 0;
/* initialize UART and GPIO pins */
if (uart_init(uart, baudrate, _rx_cb, dev) < 0) {
DEBUG("xbee: Error initializing UART\n");
return -ENXIO;
}
if (reset_pin != GPIO_UNDEF) {
if (gpio_init(reset_pin, GPIO_DIR_OUT, GPIO_NOPULL) < 0) {
DEBUG("xbee: Error initializing RESET pin\n");
return -ENXIO;
}
gpio_set(reset_pin);
}
if (sleep_pin != GPIO_UNDEF) {
if (gpio_init(sleep_pin, GPIO_DIR_OUT, GPIO_NOPULL) < 0) {
DEBUG("xbee: Error initializing SLEEP pin\n");
return -ENXIO;
}
gpio_clear(sleep_pin);
}
/* if reset pin is connected, do a hardware reset */
if (reset_pin != GPIO_UNDEF) {
gpio_clear(reset_pin);
xtimer_usleep(RESET_DELAY);
gpio_set(reset_pin);
}
/* put the XBee device into command mode */
xtimer_usleep(ENTER_CMD_MODE_DELAY);
_at_cmd(dev, "+++");
xtimer_usleep(ENTER_CMD_MODE_DELAY);
/* disable non IEEE802.15.4 extensions */
_at_cmd(dev, "ATMM2\r");
/* put XBee module in "API mode without escaped characters" */
_at_cmd(dev, "ATAP1\r");
/* apply AT commands */
_at_cmd(dev, "ATAC\r");
/* exit command mode */
_at_cmd(dev, "ATCN\r");
/* load long address (we can not set it, its read only for Xbee devices) */
_get_addr_long(dev, dev->addr_long.uint8, 8);
/* set default channel */
_set_addr(dev, &((dev->addr_long).uint8[6]), 2);
tmp[1] = 0;
tmp[0] = XBEE_DEFAULT_CHANNEL;
_set_channel(dev, tmp, 2);
/* set default PAN ID */
tmp[1] = (uint8_t)(XBEE_DEFAULT_PANID >> 8);
tmp[0] = (uint8_t)(XBEE_DEFAULT_PANID & 0xff);
_set_panid(dev, tmp, 2);
DEBUG("xbee: Initialization successful\n");
return 0;
}
