iccard.c.bak

IC卡驱动程序,采用哈希表算法,以在一万张以上IC卡中尽快找到正确的那张.

/*
** 	Name     iccard.c 
**
**  Copyright (C) 2005 ~ 2006 IntercomElc
**
**  Desc      IC卡模块
**
**	Date	  2005-08-24    
*/

#include <psos.h>
#include "tm1/mmio.h"
#include <tm1/tmXIO.h>
#include <tm1/tmInterrupts.h>
#include <tm1/tmHelp.h>
#include <tmlib/dprintf.h>

#include "iccard.h"
#include "uart.h"
#include "flash.h"
#include "winmgr.h"


#define DB_PRINT printf

static IC_NODE ic_hash_head[MAX_IC_HASH_SIZE];
static int iccard_list_count;
static IC_LIST iccard_list[MAX_IC_CARD_LIST_SIZE];

int set_iccard_auto_read()
{
	int i;
	unsigned char cmd[]={0x0a, 0x0e, 0x62, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
	unsigned char status;
	for(i=0;i<sizeof(cmd);i++)
	{
		for(;;)
		{
			status = xioRead(uc_552a_lsr);
			if(status & 0x20)
				break;
			microsleep(1);
		}
		xioWrite(uc_552a_thr,cmd[i]);
		DP(("cmd:%x\n",cmd[i]));
		microsleep(3000);
	}	
	DP(("TEST\n"));
	return 0;
}

void iccard_init()
{
	ic_card_list_init();
#if !NEW_ICCARD_AR900
	set_iccard_auto_read();
#endif
}

static
int ic_info_hash(IC_INFO *pICInfo)
{
	unsigned long cardid, index;
	memcpy((unsigned char *)&cardid, 
		(unsigned char *)pICInfo ->ICCardID, 4);
	index = cardid % MAX_IC_HASH_SIZE;
	DB_PRINT("ic_info_hash: cardid = 0x%x = %ul, index = %d \n", cardid, cardid, index);	
	return index;
}

static
int ic_card_id_compare(unsigned char id1[MAX_IC_CARD_ID_SIZE], 
	unsigned char id2[MAX_IC_CARD_ID_SIZE], int size)
{
	return memcmp(id1, id2, size);
}

static 
int ic_info_compare(IC_INFO *pICInfo1, IC_INFO *pICInfo2)
{
	return ic_card_id_compare(pICInfo1->ICCardID, 
		pICInfo2->ICCardID, MAX_IC_CARD_ID_SIZE);
}

static 
IC_NODE * ic_node_new(IC_INFO *pICInfo)
{
	IC_INFO *pNewInfo;
	IC_NODE *pNewNode;

	int i;
	for(i = 0, pNewInfo = NULL; i < MAX_IC_CARD_LIST_SIZE; i++)
	{
		if(iccard_list[i].valid != 1){
			pNewInfo = &(iccard_list[i].ICInfo);
			iccard_list[i].valid= 1;
			break;
		}
	}
	
	if(pNewInfo == NULL)
		return (IC_NODE *)NULL;
		
	pNewNode = (IC_NODE *)calloc(1, sizeof(IC_NODE));
	if(pNewNode == NULL)
	{
		iccard_list[i].valid = 0;
		return (IC_NODE *)NULL;
	}
	
	memcpy(pNewInfo, pICInfo, sizeof(IC_INFO));
	
	pNewNode->pICInfo = pNewInfo;
	pNewNode->pNext = NULL;	

	return pNewNode;
}

static 
int ic_node_free(IC_NODE *pICNode)
{
	if(pICNode)
	{
		if(pICNode->pICInfo)
		{
			((IC_LIST *)(pICNode->pICInfo))->valid = 0;

			pICNode->pICInfo = NULL;
		}
		free(pICNode);
		pICNode = NULL;
	}
	return 0;
}

int ic_card_list_init()
{
	int i;
	unsigned long hIndex;
	IC_LIST *pICList;
	IC_NODE *pNewNode;
	for(i = 0; i< MAX_IC_HASH_SIZE; i++)
		ic_hash_head[i].pNext = (IC_NODE *)NULL;
		
	iccard_list_count = 0;	
	
	memset(&iccard_list, 0, sizeof(iccard_list));
	
	ReadICCardListFromFlash();
	
	for(i = 0, pICList = iccard_list; i < MAX_IC_CARD_LIST_SIZE; i++, pICList++)
	{
		if(pICList->valid == 1)
		{
			pNewNode = (IC_NODE *)calloc(1, sizeof(IC_NODE));
			if(pNewNode != NULL)
			{
				pNewNode->pICInfo = &(pICList->ICInfo);
				hIndex  = ic_info_hash(&(pICList->ICInfo));
				pNewNode->pNext = ic_hash_head[hIndex].pNext;	
				ic_hash_head[hIndex].pNext = pNewNode;
				iccard_list_count ++;						
			}
		}
	}

	return 0;
}


int ic_card_list_add(IC_INFO *pICInfo)
{
	unsigned long hIndex;
	IC_NODE *pNew;
	
	ic_card_list_del(pICInfo);
	if((pICInfo ==  (IC_INFO *)NULL)|| (iccard_list_count >= MAX_IC_CARD_LIST_SIZE))
		return -1;
		
	hIndex  = ic_info_hash(pICInfo);
	
	pNew = ic_node_new(pICInfo);
	if(pNew == (IC_NODE *)NULL)
		return -1;
				
	pNew->pNext = ic_hash_head[hIndex].pNext;
	ic_hash_head[hIndex].pNext = pNew;
	iccard_list_count ++;
	
	return 0;
}

int ic_card_list_del(IC_INFO *pICInfo)
{
	unsigned long hIndex;
	IC_NODE *p,*q;
	
	if((pICInfo == (IC_INFO *)NULL) || (iccard_list_count == 0))
		return -1;
		
	hIndex  = ic_info_hash(pICInfo);
	
	if(ic_hash_head[hIndex].pNext != NULL)
	{
		p = ic_hash_head[hIndex].pNext;
		if(ic_info_compare(p->pICInfo, pICInfo) == 0)
		{
			ic_hash_head[hIndex].pNext = p->pNext;
			ic_node_free(p);
			iccard_list_count --;
			return 0;
		}
		for(q = p; p != (IC_NODE *)NULL; q = p, p = p->pNext)
		{
			if(ic_info_compare(p->pICInfo, pICInfo) == 0)
			{
				q->pNext = p->pNext;
				ic_node_free(p);
				iccard_list_count --;
				return 0;
			}
		}
	}
	
	return 1;
}

int ic_card_list_del_all()
{
	IC_NODE *p,*q;
	int i;
	for(i = 0; i< MAX_IC_HASH_SIZE; i++)
	{
		for(p = ic_hash_head[i].pNext; p != (IC_NODE *)NULL; p = q)
		{
			q = p->pNext;
			ic_node_free(p);
		}
		ic_hash_head[i].pNext = NULL;
	}
	return 0;
}

int ic_card_list_browse()
{
	IC_NODE *p;
	int i;

	ICCardView_Add(NULL) ;
	
	for(i = 0; i< MAX_IC_HASH_SIZE; i++)
	{
		for(p = ic_hash_head[i].pNext; p != (IC_NODE *)NULL; p = p->pNext)
		{
			if (NULL != ICCardView_Add)
				ICCardView_Add(p->pICInfo) ;
		}
	}
	
	return 0;
}

IC_INFO * get_ic_info(unsigned char ICCardID[MAX_IC_CARD_ID_SIZE])
{
	unsigned long hIndex;
	IC_INFO ICInfo;
	IC_NODE *p;
	
	memcpy(&(ICInfo.ICCardID), ICCardID, MAX_IC_CARD_ID_SIZE);
	
	hIndex  = ic_info_hash(&ICInfo);
	
	for(p = ic_hash_head[hIndex].pNext; p != (IC_NODE *)NULL; p = p->pNext)
	{
		if(ic_card_id_compare(p->pICInfo->ICCardID, ICCardID, MAX_IC_CARD_ID_SIZE) == 0)
			return p->pICInfo;		
	}
	
	return (IC_INFO *)NULL;
}


int ReadICCardListFromFlash()
{
	read_flash_data((unsigned char *)iccard_list,sizeof(iccard_list), G_LOCAL_INFO_BASE_ICCARD);
	return 0;
}

static int saving = 0;

int SaveICCardListToFlash()
{
	if(!saving)
		saving = 1;
	else
		return -1;

	write_flash_data((unsigned char *)iccard_list,sizeof(iccard_list), G_LOCAL_INFO_BASE_ICCARD);
	
	saving = 0;
	return 0;
}


int ResetICCardListToFlash()
{
	memset(&iccard_list, 0, sizeof(iccard_list));
	write_flash_data((unsigned char *)iccard_list,sizeof(iccard_list), G_LOCAL_INFO_BASE_ICCARD);
	return 0;
}