/*
This file is part of CanFestival, a library implementing CanOpen Stack.

 Author: Christian Fortin (canfestival@canopencanada.ca)

See COPYING file for copyrights details.

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include <stdlib.h>

#include <sys/time.h>
#include <signal.h>

#include <cyg/kernel/kapi.h>
#include <cyg/hal/hal_arch.h>

#include "applicfg.h"
#include <data.h>
#include <def.h>
#include <can.h>
#include <can_driver.h>
#include <objdictdef.h>
#include <objacces.h>

#include "lpc2138_pinout.h"
#include "lpc2138_defs.h"
#include "lpc2138.h"

#include "sja1000.h"

#include "time_slicer.h"


/*
	SEND/RECEIVE
*/
CAN_HANDLE canOpen(s_BOARD *board)
{
	return NULL;
}

/***************************************************************************/
int canClose(CAN_HANDLE fd0)
{
	return 0;
}

UNS8 canReceive(CAN_HANDLE fd0, Message *m)
/*
Message *m :
	typedef struct {
	  SHORT_CAN cob_id;     // l'ID du mesg
	  UNS8 rtr;             // remote transmission request. 0 if not rtr,
        	                // 1 for a rtr message
	  UNS8 len;             // message length (0 to 8)
	  UNS8 data[8];         // data
	} Message;

Fill the structure "Message" with data from the CAN receive buffer

return : 0
*/
{
/*
	the sja1000 must be set to the PeliCAN mode
*/
    m->cob_id.w = sja1000_read(16) + (sja1000_read(17)<<8); // IO_PORTS_16(CAN0 + CANRCVID) >> 5

    m->rtr = (sja1000_read(17) >> 4) & 0x01; // (IO_PORTS_8(CAN0 + CANRCVID + 1) >> 4) & 0x01; 

    m->len = sja1000_read(18);

    m->data[0] = sja1000_read(19);
    m->data[1] = sja1000_read(20);
    m->data[2] = sja1000_read(21);
    m->data[3] = sja1000_read(22);
    m->data[4] = sja1000_read(23);
    m->data[5] = sja1000_read(24);
    m->data[6] = sja1000_read(25);
    m->data[7] = sja1000_read(26);

    sja1000_write(CMR, 1<<RRB );        // release fifo

    return 0;
}


UNS8 canSend(CAN_HANDLE fd0, Message *m)
/*
Message *m :
	typedef struct {
	  SHORT_CAN cob_id;     // l'ID du mesg
	  UNS8 rtr;                     // remote transmission request. 0 if not rtr,
        	                        // 1 for a rtr message
	  UNS8 len;                     // message length (0 to 8)
	  UNS8 data[8];         // data
	} Message;

Send the content of the structure "Message" to the CAN transmit buffer

return : 0 if OK, 1 if error
*/
{
    unsigned char rec_buf;

    do
    {
        rec_buf = sja1000_read(SR);
    }
    while ( (rec_buf & (1<<TBS))==0);           // loop until TBS high

    sja1000_write(16, m->cob_id.w & 0xff); 
    sja1000_write(17, (m->cob_id.w >> 8) & 0xff);
    sja1000_write(18, m->len);

    sja1000_write(19, m->data[0]); // tx data 1
    sja1000_write(20, m->data[1]); // tx data 2
    sja1000_write(21, m->data[2]); // tx data 3
    sja1000_write(22, m->data[3]); // tx data 4
    sja1000_write(23, m->data[4]); // tx data 5
    sja1000_write(24, m->data[5]); // tx data 6
    sja1000_write(25, m->data[6]); // tx data 7
    sja1000_write(26, m->data[7]); // tx data 8

    sja1000_write(CMR,( (0<<SRR) | (0<<CDO) | (0<<RRB) | (0<<AT) | (1<<TR)));
    do
    {
        rec_buf = sja1000_read(SR);
    }
    while ( (rec_buf & (1<<TBS))==0);           // loop until TBS high

    return 0;
}


/*
	SEQUENTIAL I/O TO FLASH
	those functions are for continous writing and read
*/


int nvram_open(void)
{
	int n = NVRAM_BLOCK_SIZE / sizeof(unsigned int);

	/* some actions to initialise the flash */
	data_len = 0;
	data_num_pages = 0;

	data_page = (unsigned int *)malloc(sizeof(unsigned int) * n);
	memset(data_page, 0, sizeof(unsigned int)*n);

	if (data_page == NULL)
		return -1;

	regs_page = (unsigned int *)malloc(sizeof(unsigned int) * n);
	memset(regs_page, 0, sizeof(unsigned int)*n);
	if (regs_page == NULL)
		return -2;

	iat_flash_read_regs();

	/* start the data at the location specified in the registers */ 
	if (0) /* for now it is 0, but put here a test to know whether
                  or not the NVRAM has been written before */
		data_addr = regs_page[1];
	else
		data_addr = NVRAM_BLOCK_SIZE; /* let start at block 1 */

	return 0;
}


void nvram_close(void)
{
	/* write the last page before closing */
	iat_flash_write_page(data_addr);

	/* some actions to end accessing the flash */
	free(data_page);

	regs_page[4] = data_num_pages;
	/* write the registers to the NVRAM before closing */
	iat_flash_write_regs();
	free(regs_page);
}


void nvram_set_pos(UNS32 pos)
/* set the current position in the NVRAM to pos */
{
}


void nvram_new_firmwave()
{
/*
	this function is called whenever a new firmware is about
	to be written in the NVRAM
*/
	data_addr = regs_page[1] + regs_page[4]*NVRAM_BLOCK_SIZE;
	if (data_addr > NVRAM_MAX_SIZE)
		data_addr = NVRAM_BLOCK_SIZE;
}

int _get_data_len(int type)
{
	int len = 0; /* number of bytes */
	switch(type)
	{
		case  boolean:
			len = 1;
			break;

		case  int8:
		case  uint8:
			len = 1;
			break;
		case  int16:
		case  uint16:
			len = 2;
			break;
		case  int24:
		case  uint24:
			len = 3;
			break;
		case  int32:
		case  uint32:
		case  real32:
			len = 4;
			break;
		case  int40:
		case  uint40:
			len = 5;
			break;
		case  int48:
		case  uint48:
			len = 6;
			break;
		case  int56:
		case  uint56:
			len = 7;
			break;
		case  int64:
		case  uint64:
		case  real64:
			len = 8;
			break;
#if 0
/* TO DO */
		case  visible_string:
		case  octet_string:
		case  unicode_string:
		case  time_of_day:
		case  time_difference:
#endif
	}

	return len;
}


char nvram_write_data(int type, int access_attr, void *data)
/* return 0 if successfull */
{
	int len = _get_data_len(type);

	if (data_len+len > NVRAM_BLOCK_SIZE)
	{
		iat_flash_write_page(data_addr);
		data_len = 0;
		data_addr += NVRAM_BLOCK_SIZE; 

		/* wrap-around address pointer */
		if (data_addr > NVRAM_MAX_SIZE)
			data_addr = NVRAM_BLOCK_SIZE;

		data_num_pages++;
	}
		
	memcpy(((char *)data_page)+data_len, data, len);

	data_len += len;

	return 0;
}


char nvram_read_data(int type, int access_attr, void *data)
/* return 0 if successful */
{
	int len = _get_data_len(type);

	if (data_len+len > NVRAM_BLOCK_SIZE)
	{
		data_addr += NVRAM_BLOCK_SIZE;

		/* wrap-around address pointer */
		if (data_addr > NVRAM_MAX_SIZE)
			data_addr = NVRAM_BLOCK_SIZE;

		iat_flash_read_page(data_addr);
		data_len = 0;		
	}

	memcpy(data, ((char *)data_page)+data_len, len);

	data_len += len;

	return 0;
}

/*
	NVRAM registers at block 0
	pos        description
	0          version of the current dictionnary
	1          starting address for data block
	2          date of last writing
	3          address of the previous dictionnary          
	4          size in pages of the current dict
*/
void nvram_write_reg(UNS32 reg, UNS16 pos)
/* write reg at the position in the data block 0 */
{
	regs_page[pos] = reg;
}

UNS32 nvram_read_reg(UNS16 pos)
/* read reg at the position in the data block 0 */
{
	return regs_page[pos];
}


/*
	LED
*/

void led_set_redgreen(UNS8 bits)
/* bits : each bit of this uns8 is assigned a led 
          0=off, 1=on
*/
{
	lpc2138_redgreenled_set(bits);
}