/***************************************************************************
 *     Copyright (c) 2003-2008, Broadcom Corporation
 *     All Rights Reserved
 *     Confidential Property of Broadcom Corporation
 *
 *  THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED SOFTWARE LICENSE
 *  AGREEMENT  BETWEEN THE USER AND BROADCOM.  YOU HAVE NO RIGHT TO USE OR
 *  EXPLOIT THIS MATERIAL EXCEPT SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.
 *
 * $brcm_Workfile: bvdb.c $
 * $brcm_Revision: Hydra_Software_Devel/5 $
 * $brcm_Date: 7/14/08 3:21p $
 *
 * Module Description:
 *
 * Revision History:
 *
 * $brcm_Log: /magnum/commonutils/vdb/3548/A0/bvdb.c $
 * 
 * Hydra_Software_Devel/5   7/14/08 3:21p jessem
 * PR 43759: Updated API and implementation
 * 
 * Hydra_Software_Devel/4   7/11/08 4:49p jessem
 * PR 39237: Corrected check for BVDB_VideoDisplayMode in
 * BVDB_GetVdbEntry.
 * 
 * Hydra_Software_Devel/3   7/11/08 10:59a jessem
 * PR 39237: Changed check for BVDB_VideoDisplayMode in BVDB_GetVdbEntry.
 * 
 * Hydra_Software_Devel/2   7/10/08 12:01p jessem
 * PR 44689: Removed include "bavc.h".
 * 
 * Hydra_Software_Devel/2   6/18/08 3:43p jessem
 * PR 39237: Added check for config ID in BVDB_GetVdbEntry.
 * 
 * Hydra_Software_Devel/1   6/18/08 12:35p jessem
 * PR 43759: Initial version.
 *
 ***************************************************************************/ 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "bstd.h"
#include "berr.h"
#include "bkni.h"
#include "bfmt.h"
#include "blst_circleq.h"
#include "bdbg.h"

#include "bvdb.h"
#include "bvdb_priv.h"
#include "bvdb_viddispmode_priv.h"

BDBG_MODULE(BVDB);

extern const BVDB_UsageMode aVdbEntries[];
extern uint32_t ulVdbTableSize;

/* Public Functions */
BERR_Code BVDB_CreateVdb
	( BVDB_Handle            *phVdb,
	  uint32_t               *pulEntries)
{
	BERR_Code err = BERR_SUCCESS;
	BVDB_P_Context *pVdb;
	uint32_t i;

	/* create head */
	pVdb = (BVDB_Handle)BKNI_Malloc(sizeof(BVDB_Handle));
	if (pVdb == NULL)
	{
		BDBG_ERR(("Out of memory"));
		return BERR_OUT_OF_SYSTEM_MEMORY;
	}

	BLST_CQ_INIT(pVdb);

	for (i=0; i<ulVdbTableSize; i++)
	{
		BVDB_UsageMode *pUsageMode; 

		pUsageMode = (BVDB_UsageMode *)BKNI_Malloc(sizeof(BVDB_UsageMode));
		if (pUsageMode == NULL)
		{
			do 
			{
				pUsageMode = BLST_CQ_FIRST(pVdb);
				BLST_CQ_REMOVE_HEAD(pVdb, link);
				BKNI_Free(pUsageMode);
			} while (!BLST_CQ_EMPTY(pVdb));

			BKNI_Free(pVdb);
			BDBG_ERR(("Out of memory"));
			return BERR_OUT_OF_SYSTEM_MEMORY;
		}

		/* copy from array to doubly-linked list */
		BKNI_Memcpy((void *)pUsageMode, (void *)&aVdbEntries[i], sizeof(BVDB_UsageMode));

		BLST_CQ_INSERT_TAIL(pVdb, pUsageMode, link);
	}

	/* Validate entries */
	err = BVDB_P_ValidateVdb(pVdb);
	if (err != BERR_SUCCESS)
	{
		BDBG_ERR(("Errors in VDB."));
	}

	/* All done. now return the new fresh context to user. */
	*phVdb = (BVDB_Handle)pVdb;
	*pulEntries = ulVdbTableSize;

	return err;
}

BERR_Code BVDB_DestroyVdb
	( BVDB_Handle             hVdb  )
{
	BVDB_UsageMode *pMode;
	BVDB_P_Context *pVdb;

	BVDB_P_GET_CONTEXT(hVdb, pVdb);

	while (!BLST_CQ_EMPTY(pVdb))
	{
		pMode = BLST_CQ_FIRST(pVdb);
		BLST_CQ_REMOVE_HEAD(pVdb, link);
		BKNI_Free(pMode);
	}
	
	BKNI_Free((void*)pVdb);
	pVdb = NULL;

	return BERR_SUCCESS;
}


BERR_Code BVDB_PrintUsageMode
	( const BVDB_UsageMode    *pstUsageMode )
{
	char acStr[20];
	BVDB_VideoDisplayMode stDispMode = pstUsageMode->stDisplayMode;

	BDBG_ASSERT(pstUsageMode);

	/* ID */
	BDBG_P_PrintString("ID: %s\n", pstUsageMode->acId);
	
	/* Input format */
	BVDB_P_GetSourceFormatSetStr(pstUsageMode->eSrcFmtSet, acStr);
	BDBG_P_PrintString("\tInput format: %s\n", acStr);
	
	/* Display */
	BVDB_P_GetDisplayStr(pstUsageMode->eDisplay, acStr);
	BDBG_P_PrintString("\tDisplay: %s\n", acStr);
	
	/* Window */
	BVDB_P_GetWindowStr(pstUsageMode->eWindow, acStr);
	BDBG_P_PrintString("\tWindow: %s\n", acStr);
	
	/* Input */
	BVDB_P_GetInputStr(pstUsageMode->eInput, acStr);
	BDBG_P_PrintString("\tInput: %s\n", acStr);
	
	/* display usage mode */
	BVDB_P_GetVideoDisplayModeStr(&stDispMode, acStr);
	BDBG_P_PrintString("\tVideo Display Usage Mode: %s\n", acStr);
	
	/* OSD size */
	BVDB_P_GetOsdStr(pstUsageMode->eOsd, acStr);
	BDBG_P_PrintString("\tOSD: %s\n", acStr);
	
	/* 3D comb */
	BVDB_P_GetStateStr(pstUsageMode->e3dComb, acStr);
	BDBG_P_PrintString("\t3D Comb: %s\n", acStr);
	
	/* oversample */
	BVDB_P_GetStateStr(pstUsageMode->eOversample, acStr);
	BDBG_P_PrintString("\tOversample: %s\n", acStr);
	
	/* MNR/BNR */
	BVDB_P_GetStateStr(pstUsageMode->eMnrBnr, acStr);
	BDBG_P_PrintString("\tMNR/BNR: %s\n", acStr);
	
	/* DCR */
	BVDB_P_GetStateStr(pstUsageMode->eDcr, acStr);
	BDBG_P_PrintString("\tDCR: %s\n", acStr);
	
	/* ANR format */
	BVDB_P_GetPixelFormatStr(pstUsageMode->stAnr.ePixelFormat, pstUsageMode->stAnr.eState, acStr);
	BDBG_P_PrintString("\tANR: %s\n", acStr);
	
	/* CAP/VFD */
	BVDB_P_GetPixelFormatStr(pstUsageMode->stCapVfd.ePixelFormat, pstUsageMode->stCapVfd.eState, acStr);
	BDBG_P_PrintString("\tCAP/VFD: %s\n", acStr);
	
	/* MAD */
	BVDB_P_GetPixelFormatStr(pstUsageMode->stMad.ePixelFormat, pstUsageMode->stMad.eState, acStr);
	if (pstUsageMode->stMad.eState == BVDB_State_eYes)
	{
		char acTemp[20];
		
		BVDB_P_GetFieldStoreCntStr(pstUsageMode->stMad.eFieldStore, acTemp);
		strcat(acTemp, "\t");
		strcat(acTemp, acStr);
		strcpy(acStr, acTemp);
	}
	else
	{
		if (pstUsageMode->stMad.ePixelFormat == BVDB_PixelFmt_eInvalid)
			strcat(acStr, "\tn/a");
		else
			strcpy(acStr, "\tno");
	}
	BDBG_P_PrintString("\tMAD: %s\n", acStr);
	
	/* RTS */
	BVDB_P_GetRtsSetStr(pstUsageMode->eRtsSet, acStr);
	BDBG_P_PrintString("\tRTS: %s\n", acStr);

	/* SCL-CAP tolerance and bias */
	BDBG_P_PrintString("\tSCL-CAP tolerance: %d\n", pstUsageMode->ulSclCapTolerance);

	BVDB_P_GetSclCapBiasStr(pstUsageMode->eSclCapBias, acStr);
	BDBG_P_PrintString("\tSCL-CAP bias: %s\n", acStr);
	
	return BERR_SUCCESS;
}

BERR_Code BVDB_PrintVdb
	( BVDB_Handle             hVdb )
{
	BVDB_UsageMode *pstTemp;
	BVDB_P_Context *pVdb;

	BVDB_P_GET_CONTEXT(hVdb, pVdb);

	pstTemp = BLST_CQ_FIRST(pVdb);
	
	do 
	{
		BVDB_PrintUsageMode(pstTemp);
		pstTemp = BVDB_P_UsageMode_GetNextNode(pstTemp);
	} while(pstTemp != BLST_CQ_FIRST(pVdb));

	return BERR_SUCCESS;
}

BERR_Code BVDB_AddVdbEntry
	( BVDB_Handle             hVdb,
	  const BVDB_UsageMode   *pstUsageMode )
{
	BERR_Code             err = BERR_SUCCESS;
	BVDB_P_Context       *pVdb;
	BVDB_VideoDisplayMode stDispMode = pstUsageMode->stDisplayMode;
	BVDB_UsageMode        stUsageMode;

	BVDB_P_GET_CONTEXT(hVdb, pVdb);

	BKNI_Memcpy((void*)&stUsageMode, (void *)pstUsageMode, sizeof(BVDB_UsageMode));

	/* Create ID based on given parameters */
	if (BVDB_P_CreateId(pVdb, &stUsageMode) == BERR_SUCCESS)
	{
		BVDB_UsageMode *pCurr, *pNext, *pPrev = NULL, *pInsert = NULL;
		bool bInsertPointBefore = false, bInsertPointAfter = false;
		BVDB_DispModeType eDispMode, eInsertDispMode;
		
		/* Validate Entry */
		err = BVDB_P_ValidateVdbEntry(NULL, &stUsageMode);

		if (err == BERR_SUCCESS)
		{
			pCurr = BLST_CQ_FIRST(pVdb);
			do
			{
				/* search for similar source format, display and window */
				if ((pCurr->eSrcFmtSet == stUsageMode.eSrcFmtSet) &&
					(pCurr->eDisplay == stUsageMode.eDisplay) &&
					(pCurr->eWindow == stUsageMode.eWindow))
				{		
					eDispMode = BVDB_P_GetVideoDisplayModeType(&pCurr->stDisplayMode);
					eInsertDispMode = BVDB_P_GetVideoDisplayModeType(&stDispMode);
					pNext = BVDB_P_UsageMode_GetNextNode(pCurr);
					pPrev = BVDB_P_UsageMode_GetPrevNode(pCurr);
					
					if (((pCurr->eInput == stUsageMode.eInput) && (eDispMode < eInsertDispMode)) || /* compare inputs and display mode */
						((pCurr->eInput < stUsageMode.eInput) && (stUsageMode.eInput < pNext->eInput))) /* compare inputs */
					{
						bInsertPointAfter = true;
						break;
					}
					else if (((pCurr->eInput == stUsageMode.eInput) && (eDispMode > eInsertDispMode)) || /* compare inputs and display mode */
						((pCurr->eInput > stUsageMode.eInput) && (stUsageMode.eInput > pPrev->eInput))) /* compare inputs */
					{
						bInsertPointBefore = true;
						break;
					}
				}
				pCurr = BVDB_P_UsageMode_GetNextNode(pCurr);
			} while (pCurr != BLST_CQ_FIRST(pVdb));

			pInsert = (BVDB_UsageMode *)BKNI_Malloc(sizeof(BVDB_UsageMode));
			if (pInsert == NULL)
			{	
				BDBG_ERR(("Out of memory"));
				return BERR_OUT_OF_SYSTEM_MEMORY;
			}

			BKNI_Memcpy((void *)pInsert, (void *)&stUsageMode, sizeof(BVDB_UsageMode));
					
			/* compare input of above usage mode with to be inserted usage mode. */ 
			if (bInsertPointAfter)
			{
				BLST_CQ_INSERT_AFTER(pVdb, pCurr, pInsert, link);
			}
			else if (bInsertPointBefore)
			{
				BLST_CQ_INSERT_BEFORE(pVdb, pCurr, pInsert, link);
			}
			else /* add at tail */
			{
				BLST_CQ_INSERT_TAIL(pVdb, pInsert, link);
			}
			BDBG_MSG(("Added usage mode %s", stUsageMode.acId));
		}
	}
	else
	{
		BDBG_ERR(("Failed to add usage mode due to bad parameters entered"));
		err = BERR_INVALID_PARAMETER;
	}
	return err;
}

BERR_Code BVDB_RemoveVdbEntry
	( BVDB_Handle             hVdb,
	  const BVDB_UsageMode   *pstUsageMode )
{
	BERR_Code        err = BERR_SUCCESS;
	BVDB_P_Context  *pVdb;
	BVDB_UsageMode  *pCurr;
	bool             bFound = false;

	BVDB_P_GET_CONTEXT(hVdb, pVdb);

	pCurr = BLST_CQ_FIRST(pVdb);
	do 
	{
		if (strcmp(pCurr->acId, pstUsageMode->acId) == 0)
		{
			bFound = true;
			break;
		}
		pCurr = BVDB_P_UsageMode_GetNextNode(pCurr);
	} while (pCurr != BLST_CQ_FIRST(pVdb));

	if (bFound)
	{
		/* remove entry */
		BLST_CQ_REMOVE(pVdb, pCurr, link);
		BKNI_Free(pCurr);
	}
	else
	{
		BDBG_ERR(("ID not found"));
		err = BERR_INVALID_PARAMETER;
	}

	return err;
}

BERR_Code BVDB_GetVdbEntry
	( BVDB_Handle                       hVdb,
	  BVDB_UsageMode                   *pstUsageMode )
{
	BERR_Code                err = BERR_SUCCESS;
	BVDB_P_Context          *pVdb;	
	BVDB_UsageMode          *pstTemp;
	bool                     bFound = false;
	BVDB_VideoDisplayMode   *pMode, *pSearchMode;
	uint32_t                 ulUsrId, ulTempId;

	BVDB_P_GET_CONTEXT(hVdb, pVdb);

	ulUsrId = BVDB_P_GetConfigId(pstUsageMode->acId);

	pstTemp = BLST_CQ_FIRST(pVdb);
	do 
	{
		pMode = &pstTemp->stDisplayMode;
		pSearchMode = &(pstUsageMode->stDisplayMode);
		ulTempId = BVDB_P_GetConfigId(pstTemp->acId);

		if ((ulUsrId == ulTempId) &&
			(pstUsageMode->eSrcFmtSet == pstTemp->eSrcFmtSet) &&
			(pstUsageMode->eDisplay == pstTemp->eDisplay) &&
			(pstUsageMode->eWindow == pstTemp->eWindow) &&
			(pstUsageMode->eInput == pstTemp->eInput) &&
			((*(uint32_t*)pMode) & (*(uint32_t *)pSearchMode)))
		{
			bFound = true;
			break;
		}
		pstTemp = BVDB_P_UsageMode_GetNextNode(pstTemp);
	} while (pstTemp != BLST_CQ_FIRST(pVdb));

	if (bFound == false)
		err = BERR_INVALID_PARAMETER;
	else
	{
		BKNI_Memcpy((void *)pstUsageMode, (void *)pstTemp, sizeof(BVDB_UsageMode));
	}
	
	return err;
}

BERR_Code BVDB_GetVdbEntryById
	( BVDB_Handle                       hVdb,
	  BVDB_UsageMode                   *pstUsageMode )
{
	BERR_Code       err = BERR_SUCCESS;
	BVDB_P_Context *pVdb;	
	BVDB_UsageMode *pstTemp;
	bool            bFound = false;

	BVDB_P_GET_CONTEXT(hVdb, pVdb);

	pstTemp = BLST_CQ_FIRST(pVdb);
	do
	{
		if (strcmp(pstUsageMode->acId, pstTemp->acId) == 0)
		{
			BKNI_Memcpy((void *)pstUsageMode, (void *)pstTemp, sizeof(BVDB_UsageMode));
			bFound = true;
			break;
		}
		pstTemp = BVDB_P_UsageMode_GetNextNode(pstTemp);
	} while (pstTemp != BLST_CQ_FIRST(pVdb));

	if (bFound == false)
		err = BERR_INVALID_PARAMETER;

	return err;
}