Add realtek target files

Signed-off-by: Roman Yeryomin <roman@advem.lv>

1 files changed, 530 insertions, 0 deletions

diff --git a/target/linux/realtek/files/drivers/net/rtl819x/common/rtl865x_eventMgr.c b/target/linux/realtek/files/drivers/net/rtl819x/common/rtl865x_eventMgr.c
new file mode 100644
index 000000000..8d6950ba6
--- /dev/null
+++ b/target/linux/realtek/files/drivers/net/rtl819x/common/rtl865x_eventMgr.c
@@ -0,0 +1,530 @@
+/*

+* Copyright c                  Realtek Semiconductor Corporation, 2008  

+* All rights reserved.

+* Abstract : 

+* Author : hyking (hyking_liu@realsil.com.cn)  

+*/

+#include <net/rtl/rtl_types.h>
+#include <net/rtl/rtl_glue.h>
+#include "rtl_errno.h"

+//#include "rtl_utils.h"

+#include "rtl865x_eventMgr.h"

+#include "rtl865x_vlan.h"

+

+/*record the allocated memory pool pointer, 

+it can be used when event management module destroyed*/

+static char eventMgrInitFlag=FALSE;

+static rtl865x_event_t *eventPool;

+static rtl865x_eventLayerList_t *eventLayerListPool;

+static struct rtl865x_eventTables_s eventsTables;

+static rtl865x_eventMgr_param_t eventMgrParam;

+

+int32 rtl865x_initEventMgr(rtl865x_eventMgr_param_t *param)

+{

+	int32 i;

+	memset(&eventMgrParam,0,sizeof(rtl865x_eventMgr_param_t));

+	

+	if(param==NULL)

+	{

+		eventMgrParam.eventCnt=DEFAULT_EVENT_CNT;

+		eventMgrParam.eventListCnt=DEFAULT_EVENT_LIST_CNT;

+	}

+	else

+	{

+		if(param->eventCnt>MAX_EVENT_CNT)

+		{

+			eventMgrParam.eventCnt=MAX_EVENT_CNT;

+		}

+		else if(param->eventCnt==0)

+		{

+			eventMgrParam.eventCnt=DEFAULT_EVENT_CNT;

+		}

+		else

+		{

+			eventMgrParam.eventCnt=param->eventCnt;

+		}

+		

+		

+		if(param->eventListCnt>MAX_EVENT_LIST_CNT)

+		{

+			eventMgrParam.eventListCnt=MAX_EVENT_LIST_CNT;

+		}

+		else if(param->eventListCnt==0)

+		{

+			eventMgrParam.eventListCnt=DEFAULT_EVENT_LIST_CNT;

+		}

+		else

+		{

+			eventMgrParam.eventListCnt=param->eventListCnt;

+		}	

+	}

+	

+	CTAILQ_INIT(&eventsTables.freeList.eventHead);

+	CTAILQ_INIT(&eventsTables.freeList.eventLayerListHead);

+	CTAILQ_INIT(&eventsTables.inuseList.eventLayerListHead);

+

+	//#ifdef __KERNEL__

+	

+	TBL_MEM_ALLOC(eventPool, rtl865x_event_t, eventMgrParam.eventCnt);

+	//#else

+	//eventPool= (rtl865x_event_t *)malloc(eventMgrParam.eventCnt * sizeof(rtl865x_event_t)); 

+	//#endif

+	if(eventPool!=NULL)

+	{

+		memset( eventPool, 0, eventMgrParam.eventCnt * sizeof(rtl865x_event_t));	

+	}

+	else

+	{

+		return FAILED;

+	}

+	

+	

+	//#ifdef __KERNEL__

+	TBL_MEM_ALLOC(eventLayerListPool, rtl865x_eventLayerList_t, eventMgrParam.eventListCnt);

+	//#else

+	//eventLayerListPool=(rtl865x_eventLayerList_t *)malloc(eventMgrParam.eventListCnt * sizeof(rtl865x_eventLayerList_t)); 

+	//#endif	

+	if(eventLayerListPool!=NULL)

+	{

+		memset( eventLayerListPool, 0, eventMgrParam.eventListCnt * sizeof(rtl865x_eventLayerList_t));	

+	}

+	else

+	{

+		return FAILED;

+	}

+

+	for(i = 0; i<eventMgrParam.eventCnt;i++)

+	{

+		CTAILQ_INSERT_HEAD(&eventsTables.freeList.eventHead, &eventPool[i], next);

+	}

+	

+	for(i = 0; i<eventMgrParam.eventListCnt;i++)

+	{

+		CTAILQ_INSERT_HEAD(&eventsTables.freeList.eventLayerListHead, &eventLayerListPool[i], next);

+	}

+	

+	eventMgrInitFlag=TRUE;

+	return SUCCESS;

+}

+

+

+static int32 rtl865x_flushEventLayerList(rtl865x_eventLayerList_t  *eventLayerList)

+{

+	rtl865x_event_t *event;

+	rtl865x_event_t *nextEvent;

+

+	if(eventLayerList==NULL)

+	{

+		return SUCCESS;

+	}

+	

+	event = CTAILQ_FIRST(&eventLayerList->eventHead);

+	while(event)

+	{

+		nextEvent = CTAILQ_NEXT( event, next );

+		event->eventId=0;

+		event->eventPriority=0;

+		event->event_action_fn=NULL;

+		CTAILQ_REMOVE(&eventLayerList->eventHead, event, next);

+		CTAILQ_INSERT_HEAD(&eventsTables.freeList.eventHead, event, next);

+		event = nextEvent;

+	}

+	return SUCCESS;

+}

+

+int32 rtl865x_reInitEventMgr(void)

+{

+	rtl865x_eventLayerList_t *eventLayerList;

+	rtl865x_eventLayerList_t *nextEventLayerList;

+

+	if(eventMgrInitFlag==FALSE)

+	{

+		return FAILED;

+	}

+	

+	eventLayerList = TAILQ_FIRST(&eventsTables.inuseList.eventLayerListHead);

+	

+	for (;eventLayerList!=NULL;eventLayerList=nextEventLayerList)

+	{

+		nextEventLayerList=TAILQ_NEXT(eventLayerList, next);

+		rtl865x_flushEventLayerList(eventLayerList);

+		

+		CTAILQ_REMOVE(&eventsTables.inuseList.eventLayerListHead, eventLayerList, next);

+		eventLayerList->eventLayerId=0;

+		CTAILQ_INIT(&eventLayerList->eventHead);

+		CTAILQ_INSERT_HEAD(&eventsTables.freeList.eventLayerListHead, eventLayerList, next);

+	}

+	return SUCCESS;

+}

+

+int32 rtl865x_destroyEventMgr(void)

+{

+

+	if(eventMgrInitFlag==FALSE)

+	{

+		return FAILED;

+	}

+	

+	rtl865x_reInitEventMgr();

+	#ifdef __KERNEL__

+	if(eventPool!=NULL)

+	{

+		kfree(eventPool);

+		eventPool=NULL;

+	}

+

+	if(eventLayerListPool!=NULL)

+	{

+		kfree(eventLayerListPool);

+		eventLayerListPool=NULL;

+	}

+	#else

+	if(eventPool!=NULL)

+	{

+		free(eventPool); 

+		eventPool=NULL;

+	}

+

+	if(eventLayerListPool!=NULL)

+	{

+		free(eventLayerListPool); 

+		eventLayerListPool=NULL;

+	}

+	#endif

+	

+	eventMgrInitFlag=FALSE;

+	

+	return SUCCESS;

+}

+

+static rtl865x_eventLayerList_t * rtl865x_searchEventLayerList(rtl865x_event_Param_t *eventParam)

+{

+	rtl865x_eventLayerList_t *eventLayerList;

+	CTAILQ_FOREACH(eventLayerList, &eventsTables.inuseList.eventLayerListHead, next)

+	{

+		if(eventLayerList->eventLayerId==eventParam->eventLayerId)

+		{

+			return eventLayerList;

+		}

+	}

+

+	return NULL;

+}

+

+static rtl865x_event_t * rtl865x_searchEvent(rtl865x_eventLayerList_t *eventList,rtl865x_event_Param_t *eventParam)

+{

+	rtl865x_event_t *event=NULL;

+	

+	if(eventParam==NULL)

+	{

+		return NULL;

+	}

+	

+	CTAILQ_FOREACH(event, &eventList->eventHead, next)

+	{

+		if(	(event->eventId==eventParam->eventId) 

+			&&(event->eventPriority==eventParam->eventPriority)

+			&&(event->event_action_fn== eventParam->event_action_fn))

+		{

+			return event;

+		}	

+	}

+	

+	return NULL;

+}

+

+static void rtl865x_insertEventLayerList(rtl865x_eventLayerList_t *eventLayerList)

+{

+	rtl865x_eventLayerList_t *tmpEventLayerList=NULL;

+	if(eventLayerList==NULL)

+	{

+		return;

+	}

+	

+	CTAILQ_FOREACH(tmpEventLayerList, &eventsTables.inuseList.eventLayerListHead, next)

+	{

+		if(tmpEventLayerList->eventLayerId>=eventLayerList->eventLayerId)

+		{

+			CTAILQ_INSERT_BEFORE(&eventsTables.inuseList.eventLayerListHead,tmpEventLayerList,eventLayerList,next);

+			break;	

+		}

+	}

+	

+	if(tmpEventLayerList==NULL)

+	{

+		CTAILQ_INSERT_TAIL(&eventsTables.inuseList.eventLayerListHead,eventLayerList,next);

+	}

+	return;

+	

+}

+

+static void rtl8651_insertEvent(rtl865x_eventLayerList_t *eventLayerList,rtl865x_event_t *event)

+{

+	rtl865x_event_t *tmpEvent=NULL;

+	if( (eventLayerList==NULL) ||(event==NULL))

+	{

+		return ; 

+	}

+	

+	CTAILQ_FOREACH(tmpEvent, &eventLayerList->eventHead, next)

+	{

+	

+		if((tmpEvent->eventId>event->eventId)||

+			((tmpEvent->eventId== event->eventId) && (tmpEvent->eventPriority>=event->eventPriority)))

+		{

+			CTAILQ_INSERT_BEFORE(&eventLayerList->eventHead,tmpEvent,event,next);

+			break;	

+		}

+	}

+

+	if(tmpEvent==NULL)

+	{

+		CTAILQ_INSERT_TAIL(&eventLayerList->eventHead,event,next);

+	}

+	return ;

+	

+}

+

+int32 rtl865x_registerEvent(rtl865x_event_Param_t *eventParam)

+{

+	rtl865x_eventLayerList_t *eventLayerList=NULL;

+	rtl865x_event_t *event=NULL;

+	

+	if(eventMgrInitFlag==FALSE)

+	{

+		return FAILED;

+	}

+	

+	if(eventParam==NULL)

+	{

+		return RTL_EINVALIDINPUT;

+	}

+

+	if(eventParam->eventLayerId==0)

+	{

+		return RTL_EINVALIDINPUT;

+	}

+	

+	eventLayerList=rtl865x_searchEventLayerList(eventParam);

+	if(eventLayerList==NULL)

+	{

+		eventLayerList = CTAILQ_FIRST(&eventsTables.freeList.eventLayerListHead);

+		if(eventLayerList==NULL)

+		{

+			return RTL_ENOFREEBUFFER;

+		}

+		CTAILQ_REMOVE(&eventsTables.freeList.eventLayerListHead, eventLayerList, next);

+		CTAILQ_INIT(&eventLayerList->eventHead);

+		eventLayerList->eventLayerId=eventParam->eventLayerId;

+		rtl865x_insertEventLayerList(eventLayerList);

+	}

+

+	if(	(eventParam->eventId< 0) || 

+		(eventParam->eventId >MAX_SYSTEM_EVENT_ID) ||

+		(eventParam->event_action_fn == NULL))

+		return RTL_EINVALIDINPUT;

+

+	

+	/*check duplicate entry*/

+	event=rtl865x_searchEvent(eventLayerList,eventParam);

+	if(event!=NULL)

+	{

+		return RTL_EENTRYALREADYEXIST;

+	}

+	else

+	{

+

+		event = CTAILQ_FIRST(&eventsTables.freeList.eventHead);

+		if(event==NULL)

+		{

+			return RTL_ENOFREEBUFFER;

+		}

+		CTAILQ_REMOVE( &eventsTables.freeList.eventHead, event, next);

+		event->eventId= eventParam->eventId;

+		event->eventPriority = eventParam->eventPriority;

+		event->event_action_fn = eventParam->event_action_fn;

+		

+		rtl8651_insertEvent(eventLayerList,event);

+	}

+

+	return SUCCESS;

+		

+}

+

+int32 rtl865x_unRegisterEvent(rtl865x_event_Param_t *eventParam)

+{

+	rtl865x_eventLayerList_t *eventLayerList=NULL;

+	rtl865x_event_t *event=NULL;

+	

+	if(eventMgrInitFlag==FALSE)

+	{

+		return FAILED;

+	}

+		

+	if(eventParam==NULL)

+	{

+		return RTL_EINVALIDINPUT;

+	}

+	

+	eventLayerList=rtl865x_searchEventLayerList(eventParam);

+	if(eventLayerList==NULL)

+	{

+		return RTL_EINVALIDINPUT;

+	}

+

+	if(	(eventParam->eventId< 0) || 

+		(eventParam->eventId >MAX_SYSTEM_EVENT_ID) ||

+		(eventParam->event_action_fn == NULL))

+		return RTL_EINVALIDINPUT;

+

+	

+	event=rtl865x_searchEvent(eventLayerList,eventParam);

+	if(event!=NULL)

+	{

+		event->eventId = 0;

+		event->eventPriority = 0;

+		event->event_action_fn = NULL;

+		CTAILQ_REMOVE(&eventLayerList->eventHead, event, next);

+		CTAILQ_INSERT_HEAD(&eventsTables.freeList.eventHead, event, next);

+		

+		if(CTAILQ_EMPTY(&eventLayerList->eventHead))

+		{

+			CTAILQ_REMOVE(&eventsTables.inuseList.eventLayerListHead, eventLayerList, next);

+			eventLayerList->eventLayerId=0;

+			CTAILQ_INIT(&eventLayerList->eventHead);

+			CTAILQ_INSERT_HEAD(&eventsTables.freeList.eventLayerListHead, eventLayerList, next);

+		}

+		

+		return SUCCESS;

+	}

+	else

+	{

+		return RTL_EINVALIDINPUT;

+	}

+

+	return SUCCESS;

+		

+}	

+

+

+int32 rtl865x_raiseEvent(int32 eventId,void *actionParam)

+{

+	rtl865x_eventLayerList_t *eventLayerList;

+	rtl865x_event_t *event;

+	int retValue;

+

+	if(eventMgrInitFlag==FALSE)

+	{

+		return FAILED;

+	}

+	

+	CTAILQ_FOREACH(eventLayerList, &eventsTables.inuseList.eventLayerListHead, next)

+	{

+		CTAILQ_FOREACH(event, &eventLayerList->eventHead, next)

+		{

+			if((event->eventId==eventId))

+			{	

+				if(event->event_action_fn!=NULL)

+				{

+					do

+					{

+						retValue=event->event_action_fn(actionParam);

+					}while(retValue==EVENT_RE_EXECUTE);

+					

+					switch(retValue)

+					{

+						

+						case EVENT_STOP_EXECUTE:

+							return SUCCESS;

+

+						case EVENT_CONTINUE_EXECUTE:

+							break;

+							

+						default:

+							break;

+					}

+				}

+			}	

+		}

+	

+	}

+	

+	return SUCCESS;

+}

+

+void rtl865x_dumpAllEventLayerListInfo(void)

+{

+	

+	rtl865x_eventLayerList_t *eventLayerList;

+	rtl865x_event_t *event;

+	int eventListCnt=0;

+	int eventCnt=0;

+	CTAILQ_FOREACH(eventLayerList, &eventsTables.inuseList.eventLayerListHead, next)

+	{

+		eventListCnt++;

+		eventCnt=0;

+		rtl865x_debug_printf(" No.%d eventLayerList:eventLayerId:%d \n",eventListCnt,eventLayerList->eventLayerId);

+		CTAILQ_FOREACH(event, &eventLayerList->eventHead, next)

+		{

+			eventCnt++;

+			rtl865x_debug_printf(" \tNo.%d event:eventId:%d,priority:%d,action_fn is 0x%x\n",eventCnt,event->eventId, event->eventPriority,(unsigned int)(event->event_action_fn));

+		}

+	

+	}

+	

+	return;

+}

+

+

+#ifdef CONFIG_RTL865X_EVENT_PROC_DEBUG

+int32 rtl865x_event_proc_read( char *page, char **start, off_t off, int count, int *eof, void *data )

+{

+	int len=0;

+	rtl865x_eventLayerList_t *eventLayerList;

+	rtl865x_event_t *event;

+	int eventListCnt=0;

+	int eventCnt=0;

+	

+	len = sprintf(page, "%s\n", "realtek event management Table:");

+

+	CTAILQ_FOREACH(eventLayerList, &eventsTables.inuseList.eventLayerListHead, next)

+	{

+		eventListCnt++;

+		eventCnt=0;

+		len += sprintf(page+len, " No.%d eventLayerList:eventLayerId:0x%x \n",eventListCnt,eventLayerList->eventLayerId);

+		CTAILQ_FOREACH(event, &eventLayerList->eventHead, next)

+		{

+			eventCnt++;

+			len += sprintf(page+len, " \tNo.%d event:eventId:0x%x,priority:%d,action_fn is 0x%x\n",eventCnt,event->eventId, event->eventPriority,(unsigned int)(event->event_action_fn));

+		}

+	

+	}

+	

+	if (len <= off+count) 

+	{

+		*eof = 1;

+	}

+	

+	*start = page + off;
+	len -= off;

+	

+	if (len>count)

+	{

+		len = count;

+	}

+	

+	if (len<0)

+	{

+	  	len = 0;

+	}

+
+	return len;
+}
+
+int32  rtl865x_event_proc_write( struct file *filp, const char *buff,unsigned long len, void *data )

+{

+	return len;
+}

+#endif

+

+