ycc_driver.c

在SoC单片机上实现对内部Flash的操作,基于uc/os-II.

/*
	YCC4型集中器的底层驱动函数，工作于多任务操作系统下

	马兴录，2005-07-19
*/
#include "includes.h"

//串口驱动函数，马兴录，2005-10-20
#ifdef _UCOS_II
int ycc_com_init(char port,unsigned long ctrl,unsigned int baud) reentrant
{
	

}
#endif


#ifndef _ECOS //1
static int ycc_com_fd=0;  //串口句柄,本系统只有一个串口
int ycc_com_init(char *port,unsigned long ctrl,unsigned int baud)
{
	if(ycc_com_fd>0)
		close(ycc_com_fd);
	ycc_com_fd=open("/dev/ttyS0",O_RDWR|O_NOCTTY|O_SYNC);

	if(ycc_com_fd<=0)
	{
		return -1;
	}
		
	fcntl(ycc_com_fd,F_SETFL,O_NONBLOCK|fcntl(ycc_com_fd,F_GETFL,0));
	struct termios oldtio,newtio;
	tcgetattr(ycc_com_fd,&oldtio);
	bzero(&newtio, sizeof(newtio));

	newtio.c_cflag &= ~CSIZE;
	newtio.c_cflag =  B1200 |  CS8 | CLOCAL | CREAD;
	newtio.c_cflag |= PARENB;
	newtio.c_cflag &=~PARODD;
	newtio.c_cflag &=~CSTOPB;
	
	newtio.c_iflag |= INPCK;
	newtio.c_oflag = 0;
	newtio.c_lflag = 0;//ICANON;

	newtio.c_cc[VINTR] = 0; // Ctrl-c 
	newtio.c_cc[VQUIT] = 0; // Ctrl-
	newtio.c_cc[VERASE] = 0; // del 
	newtio.c_cc[VKILL] = 0; // @ 
	newtio.c_cc[VEOF] = 0; // Ctrl-d 
	newtio.c_cc[VTIME] = 0; // inter-character timer unused 
	newtio.c_cc[VMIN] = 1; // blocking read until 1 character arrives 
	newtio.c_cc[VSWTC] = 0; // '\0' 
	newtio.c_cc[VSTART] = 0; // Ctrl-q 
	newtio.c_cc[VSTOP] = 0; // Ctrl-s 
	newtio.c_cc[VSUSP] = 0; // Ctrl-z 
	newtio.c_cc[VEOL] = 0; // '\0' 
	newtio.c_cc[VREPRINT] = 0; // Ctrl-r 
	newtio.c_cc[VDISCARD] = 0; // Ctrl-u 
	newtio.c_cc[VWERASE] = 0; // Ctrl-w 
	newtio.c_cc[VLNEXT] = 0; // Ctrl-v 
	newtio.c_cc[VEOL2] = 0; // '\0' 

	tcflush(ycc_com_fd, TCIOFLUSH);
	if(tcsetattr(ycc_com_fd,TCSANOW,&newtio)!=0)
	{
	#ifdef __YCC_DEBUG
		ycc_printf("open com failed!\n");
	#endif
		return -1;
	}
	
   	return 0;
}
int ycc_com_sendchar(char port,unsigned char c)
{

	if(ycc_com_fd<0)
		return -1;
	if(write(ycc_com_fd,&c,1)<=0)
		return -1;
	else 
	{
	#ifdef __YCC_DEBUG
		//ycc_printf("%02X \n",c);
	#endif
		return 0;
	}
}

int ycc_com_getchar(char port,unsigned char *c)
{
	if(ycc_com_fd<0)
		return -1;
#ifdef __YCC_DEBUG
	//ycc_printf("ycc_com_fd:%d\n",ycc_com_fd);
#endif
	if(read(ycc_com_fd,c,sizeof(char))>0)
		return 0;
	else
		return 1;
}

int ycc_com_sendbuf(char port,unsigned char *bf,int len)
{
	if(ycc_com_fd<0)
	{
	#ifdef __YCC_DEBUG
		ycc_printf("com send buf\n");	
	#endif
		return -1;
	}
	
	if(write(ycc_com_fd,bf,len)<=0)
	{
	#ifdef __YCC_DEBUG
		ycc_printf("com send buf write error\n");
	#endif	
		return 1;
	}
	else 
		return 0;
}

//调试信息显示函数
int ycc_printf(char *format, ...)
{
	va_list arg;

  	va_start(arg, format);
  	vprintf(format,arg);
  	va_end(arg);
}

//to-do:init tcp socket
//These functions should be rewrite in ecos
void modem_data_req(void)
{
	gprs_ppp_network=true;
}

void modem_ppp_status(unsigned char s)
{
	return;
}
/*void reset_tcp_ppp(void)
{
	return;
}*/
unsigned long ByteToNetIP(unsigned char *arry)
{
	unsigned long iIP;
	int i;
	iIP=0;
	for(i=0;i<4;i++)
	{
	#ifdef YCC__DEBUG
		ycc_printf("arry[%d] is %d\n",i,arry[i]);
	#endif
		iIP=iIP<<8;
		iIP|=arry[i];
	}
#ifdef __DEBUG
	ycc_printf("the IP is %lu\n",iIP);
#endif
	return iIP;
}
/* get IP address of relay server form SIM card or flash */
void get_relay_server_ipaddr(void)
{	
	//struct in_addr rs;
	//inet_aton((unsigned char *)("211.97.245.108"),&rs);
	sa_tcp_server_ip.sin_family=AF_INET;
	sa_tcp_server_ip.sin_port = htons(yccpara.frmPort);
	sa_tcp_server_ip.sin_addr.s_addr=htonl(ByteToNetIP(yccpara.frmIP));
}
void ljc_os_start(void)
{
	return;
}
//Task for tcp receive

unsigned long get_current_tick(void)
{
	return time(NULL);
}

unsigned short init_board(void)
{	
	pthread_mutex_init(&ComLock,NULL);
	pthread_mutex_init(&MeterListLock,NULL);
	pthread_mutex_init(&AlmListLock,NULL);
	pthread_mutex_init(&MemLock,NULL);
	pthread_mutex_init(&SendBufLock,NULL);
	pthread_mutex_init(&LogRecLock,NULL);
	return 8888;
}

LJC_UINT ljc_thread_cread(ljc_thread_entry_t *thread_entry)
{
	t_ljc_thread_type *p_ljc_thread;
	p_ljc_thread=malloc(sizeof(t_ljc_thread_type));
	if(NULL == p_ljc_thread) return 0;	
	
	pthread_attr_init(&p_ljc_thread->thread_Attr);	
	pthread_attr_setdetachstate(&p_ljc_thread->thread_Attr,PTHREAD_CREATE_DETACHED);	
	if(0!=pthread_create(&p_ljc_thread->thread_id,&p_ljc_thread->thread_Attr,(void*)thread_entry,NULL)) return 0;
	return p_ljc_thread->thread_id;
	
}

void ljc_delay_us(unsigned int us)
{
	struct timespec t1;
	
	t1.tv_sec=us/1000000;	
	t1.tv_nsec=(us%1000000)*1000;	
	nanosleep(&t1,NULL);
	
}
void ljc_sleep_ms(unsigned long ms)
{
	unsigned long t;
	ljc_delay_us(ms*1000);
	
	/*
	t=ms/1000;
	if(ms%1000) t++;
	sleep(t);*/
}
bool ljc_flash_add_config(struct config_option *opt, bool update)
{
	return 0;
}
bool ljc_flash_get_config(char *key, void *val, int type)
{
	return 0;
}
void ljc_memory_lack_handler(void)
{
	return;
}

void system_reset(void)
{
	system("Reboot");
	return;
}
void power_relay_control(unsigned int mode) 
{
	return;
}
int nand_memory_valid(void)
{
	return 4096;
}
void ljc_clear_nand_memory(void)
{
	return;
}
int (* gt08_app_callback)(int,int)=NULL;// app call back for app purpose
unsigned long (* sms_rev_callback)(unsigned long len, unsigned char *buf,unsigned char *sender_phnum)=NULL;// sms send call back, the real fun is duty of the app
int								gprs_ppp_network=true; 					
unsigned long					rcp_link_flag=0;
struct sockaddr_in				sa_tcp_server_ip;
bool							relay_server_have_static_ip;
unsigned char 					ljc_admin_number1[16];
unsigned char 					ljc_admin_number2[16];
unsigned char 					ljc_admin_number3[16];
#endif //_ECOS //2



//success 0,failed >0,pos(high 16 bit:memblk,low 16 bit:offset in memblk
int ycc_mem_read(unsigned char *data,int len,unsigned long pos)
{
	//value boundary check
	unsigned long MemBlk=0,nOffset=0;
	MemBlk=pos & 0xffff0000;
	MemBlk=MemBlk>>16;
	nOffset=pos & 0xffff;
	if(MemBlk<=0 || MemBlk>nand_memory_valid() || nOffset<0 || nOffset >MEMBLKSIZE-1)
	{
	#ifdef __YCC_DEBUG
		ycc_printf("read nand flash over boundary!\n");
	#endif
		return 1;
	}
	if(len<0 || len>MEMBLKSIZE)
	{
	#ifdef __YCC_DEBUG
		ycc_printf("read nand flash,len too long!\n");
	#endif
		return 2;
	}

	LJC_Mutex_lock(MemLock);
	unsigned char *tmpBuf=malloc(MEMBLKSIZE);
	if(NULL==tmpBuf)
	{
	#ifdef __YCC_DEBUG
		ycc_printf("read nand flash,alloc memory error!\n");
	#endif
		return 3;
	}
	
	if(nand_memory_read(tmpBuf,MEMBLKSIZE,MemBlk)!=1)
	{
	#ifdef __YCC_DEBUG
		ycc_printf("read nand flash error!\n");
	#endif	
		free(tmpBuf);
		LJC_Mutex_unlock(MemLock);
		return 4;
	}
	
	memcpy(data,&tmpBuf[nOffset],len);
	free(tmpBuf);
	LJC_Mutex_unlock(MemLock);
	return 0;
}
//same as ycc_mem_read in parameters passed into function
int ycc_mem_write(unsigned char *data,int len,unsigned long pos)
{
	unsigned long MemBlk=0,nOffset=0;
	MemBlk=pos & 0xffff0000;
	MemBlk=MemBlk>>16;
	nOffset=pos & 0xffff;	
#ifdef __YCC_DEBUG
	//ycc_printf("in mem write,pos:%lu,memblk:%d,nOffset:%d",pos,MemBlk,nOffset);
#endif	
	//value boundary check
	if(MemBlk<=0 || MemBlk>nand_memory_valid() || nOffset<0 || nOffset>MEMBLKSIZE-1)
	{
	#ifdef __YCC_DEBUG
		ycc_printf("when write,nand flash pos over boundary!:");
		ycc_printf("MemBlk:%lu,nOffset:%lu\n",MemBlk,nOffset);
	#endif	
		return 1;
	}

	if(len<0 || len>MEMBLKSIZE)
	{
	#ifdef __YCC_DEBUG
		ycc_printf("when write nandflash,buffer len less than zero!\n");
	#endif
		return 2;
	}

#ifdef __YCC_DEBUG
	//ycc_printf("write nand flash,memblk:%d,offset:%d\n",MemBlk,nOffset);
#endif
	
	LJC_Mutex_lock(MemLock);
	unsigned char *tmpBuf=malloc(MEMBLKSIZE);
	if(NULL==tmpBuf)
	{
	#ifdef __YCC_DEBUG
		ycc_printf("when operate nand flash,allocate memory error!\n");
	#endif	
		LJC_Mutex_unlock(MemLock);
		return 3;
	}
	
	memset(tmpBuf,0,MEMBLKSIZE);
	if(nand_memory_read(tmpBuf,MEMBLKSIZE,MemBlk)!=1)
	{
	#ifdef __YCC_DEBUG
		ycc_printf("read nand flash error!\n");
	#endif	
		free(tmpBuf);
		LJC_Mutex_unlock(MemLock);
		return 4;
	}

	if(len>MEMBLKSIZE-nOffset)	//if data large than memblksize,firstly write predata
	{
		memcpy(&tmpBuf[nOffset],data,MEMBLKSIZE-nOffset);
		if(nand_memory_write(tmpBuf,MEMBLKSIZE,MemBlk)!=1)//写错，再写一次，一般成功
		{
			if(nand_memory_write(tmpBuf,MEMBLKSIZE,MemBlk)!=1)
			{
			#ifdef __YCC_DEBUG
				ycc_printf("write nand flash error!\n");
			#endif
				free(tmpBuf);
				LJC_Mutex_unlock(MemLock);
				return 5;
			}
		}
		memset(tmpBuf,0,MEMBLKSIZE);
		memcpy(tmpBuf,data+MEMBLKSIZE-nOffset,len-(MEMBLKSIZE-nOffset));
		if(nand_memory_write(tmpBuf,MEMBLKSIZE,MemBlk+1)!=1)
		{
			if(nand_memory_write(tmpBuf,MEMBLKSIZE,MemBlk+1)!=1)
			{
			#ifdef __YCC_DEBUG
				ycc_printf("write nand flash error!\n");
			#endif	
				free(tmpBuf);
				LJC_Mutex_unlock(MemLock);
				return 6;
			}
		}
	}
	else
	{
		memcpy(&tmpBuf[nOffset],data,len);
		if(nand_memory_write(tmpBuf,MEMBLKSIZE,MemBlk)!=1)
		{
			if(nand_memory_write(tmpBuf,MEMBLKSIZE,MemBlk)!=1)
			{
			#ifdef __YCC_DEBUG
				ycc_printf("write nand flash error!\n");
			#endif			
				free(tmpBuf);
				LJC_Mutex_unlock(MemLock);
				return 7;
			}
		}
		else
		{
		#ifdef __YCC_DEBUG
			ycc_printf("write nand flash blk:%d\n",MemBlk);
		#endif
		}
	}

	free(tmpBuf);
	LJC_Mutex_unlock(MemLock);
	return 0;
}

int change_rs_port (unsigned int port,bool flag)
{
	unsigned int port_id;
	struct config_option * opt;
	port_id = port;
	ycc_printf("port_id = %d\n" , port_id);
	
	opt = (struct config_option*) malloc(sizeof(struct config_option));
	if (!opt)
	{
		ljc_memory_lack_handler();
	}
	memset(opt, 0, sizeof(struct config_option));
	opt->type = CONFIG_INT;
	opt->enable = "gprs_mc8k";
	relay_server_have_static_ip = true;
	
	opt->enable_sense = false;
	
	opt->key="gprs_relay_nmc8k_tport";		
	opt->title = "Tcp Server Port";		
			
	memcpy(&opt->dflt,&(port_id),4);
	if(!ljc_flash_add_config(opt,flag))
	{
		ycc_printf("\nFailed to write new config to flash.\n");
		free(opt);
		return 0;
	}	
	free(opt);		
	return 1;

}

int change_rs_addr(unsigned char * address,bool flag)
{
	struct in_addr rs_in_addr;
	struct config_option * opt;
	int res;

	//change the ip address of MC8000
	res = inet_aton(address,&rs_in_addr);
	if(res == -1){
		ycc_printf("invalid ip address \n");
		return 0;
	}
	ycc_printf("\nchange relay_server ip address to %s\n",address);
	sa_tcp_server_ip.sin_addr.s_addr = rs_in_addr.s_addr;

	//organize the config option 
	opt = (struct config_option*) malloc(sizeof(struct config_option));
	if (!opt)
	{
		ljc_memory_lack_handler();
	}
	memset(opt, 0, sizeof(struct config_option));
	opt->key="gprs_relay_ip";
	opt->type = CONFIG_IP;
	opt->enable = "gprs_relay";
	opt->enable_sense = true;
	opt->title = "GPRS Network Relay Server IP Address";
	memcpy(&opt->dflt,&rs_in_addr,sizeof(in_addr_t));

	//add the option to flash
	if(!ljc_flash_add_config(opt,flag))
	{
		ycc_printf("\nFailed to write new config to flash.\n");
		free(opt);
		return 0;
	}

	memset(opt, 0, sizeof(struct config_option));
	opt->key="gprs_relay";
	opt->type = CONFIG_BOOL;
	opt->enable = "gprs";
	opt->enable_sense = true;
	opt->title = "GPRS Relay Sever Have Static IP Address";
	opt->dflt  = true;
	relay_server_have_static_ip = true;

	//add the option to flash
	if(!ljc_flash_add_config(opt,flag))
	{
		ycc_printf("\nFailed to write new config to flash.\n");
		free(opt);
		return 0;
	}
	
	free(opt);
	return 1;
}



int set_tele_number(unsigned char * phone_num, int len)
{
	struct config_option * opt;
	unsigned char buf[16]={0};
	unsigned long val;
	bool ret;
	
	//organize the config option 
	opt = (struct config_option*) malloc(sizeof(struct config_option) + MAX_STRING_LENGTH);
	if(!opt)
	{
		ljc_memory_lack_handler();
	}
	memset(opt, 0, sizeof(struct config_option) + MAX_STRING_LENGTH);
	opt->dflt = (unsigned long)((unsigned char*)opt + sizeof(struct config_option));

	opt->key="voice_num1";
	opt->type = CONFIG_STRING;
	opt->enable = ALWAYS_ENABLED;
	opt->enable_sense = true;
	opt->title = "SMS admin number1";
	memcpy((unsigned char*)(opt->dflt),phone_num,len);
	
	//add the option to flash
	if(!ljc_flash_add_config(opt,true))
	{
		ycc_printf("\nFailed to write new config to flash.\n");
		free(opt);
		return 0;
	}
	else
		free(opt);

	if((ret = ljc_flash_get_config("voice_num1", &val, CONFIG_STRING)))
    {
        strcpy(buf, (char*)val);
        ycc_printf("get admin number1 ok =%s\n",buf);
        	
        
        strcpy(ljc_admin_number1, "+86");
        strcat(ljc_admin_number1, (char*)val);
        strcat(ljc_admin_number1, "\r");
    }
	
	return 1;
}

unsigned long sms_callback (unsigned long sms_len, unsigned char *sms_buf,unsigned char *sender_phnum)
{
	unsigned char command[8];
	int command_id;	
	
	unsigned char buffer[300];
	int len,res;
	ycc_printf(" begin to process sms...........!\n");
	
	memcpy(command, sms_buf, 7);
	len=0;
	command[7]= '\0';
	command_id = atoi(command);
	ycc_printf("command_id = %d\n" , command_id);
	
	switch(command_id) 
	{
		case RESET_SYSTEM:
			ycc_printf("Reset system sms\n");
			buffer[0] = 'R';
			buffer[1] = 'E';
			buffer[2] = 'S';
			buffer[3] = 'E';
			buffer[4] = 'T';
			buffer[5] = 'O';
			buffer[6] = 'K';
			buffer[7] = '\0';
			len=8;
			//send_one_sms(buffer, len, sender_phnum);
			ycc_printf("sms RESET_SYSTEM\n");
			break;
		
		case CHANGE_MC8000_IP:
			memcpy(buffer, sms_buf+8, 15);
			buffer[15] = '\0';
			ycc_printf("Changge MC8000 IP sms \n");
			//res = change_rs_addr(buffer);
			res=1;
			if(res == 1)
			{
				buffer[0] = 'O';
				buffer[1] = 'K';
				buffer[2] = '\0';
				len =3 ;
			}
			
			if(res == 0)
			{
				buffer[0] = 'E';
				buffer[1] = 'R';
				buffer[2] = 'R';
				buffer[3] = '\0';
				len = 4;
			}
			//send_one_sms(buffer, len, sender_phnum);
			break;
		
		case CHANGE_SERVER_PORT:
			memcpy(buffer, sms_buf+8, 5);
			buffer[5] = '\0';
			ycc_printf("Changge SERVER PORT sms \n");
			unsigned int port;
			port=atoi(buffer);
			//res = change_rs_port(port);
			res=1;
			if(res == 1)
			{
				buffer[0] = 'O';
				buffer[1] = 'K';
				buffer[2] = '\0';
				len =3 ;
			}
			
			if(res == 0)
			{
				buffer[0] = 'E';
				buffer[1] = 'R';
				buffer[2] = 'R';
				buffer[3] = '\0';
				len = 4;
			}
			//send_one_sms( buffer, len, sender_phnum);
			break;
		
		default :
			break;
		}
	system_reset();
	return 1;
}

int ycc_get_para(int itemID,unsigned char *iErr)
{
	LJC_Mutex_lock(MemLock);
	*iErr=0;
	unsigned char *tmpBuf;
	tmpBuf=malloc(MEMBLKSIZE);
	if(NULL==tmpBuf)
	{
	#ifdef __YCC_DEBUG
		ycc_printf("when get sys parametes,failed!\n");
	#endif
		LJC_Mutex_unlock(MemLock);
		return 1;
	}