analog_video.c

1. 8623L平台

/*
 *
 * Copyright (c) 2001-2007 Sigma Designs, Inc. 
 * All Rights Reserved. Proprietary and Confidential.
 *
 */

/**
  @file   analog_video.c
  @brief  Interface to access an analog video capture port
  
  @author Christian Wolff, Sean.Sekwon.Choi
  @date   2007-07-18
*/

// to enable or disable the debug messages of this source file, put 1 or 0 below
#if 1
#define LOCALDBG ENABLE
#else
#define LOCALDBG DISABLE
#endif

#include "common.h"
#include "analog_video.h"
#include "SAA7119.h"
#include "TW9919.h"

// internal state of the analog video capture port
struct cap_analog_video_instance {
	// Access
	struct RUA *pRUA;
	struct cap_chip_instance *pChip;
	//RMuint32 I2CModuleID;  // emhwlib Module ID of the I2C bus access
	//struct EMhwlibI2CDeviceParameter I2CDevice;
	//RMuint8 BaseDevice;  // base device address of the device
	//enum cap_chip chip;
	
	// handle for specific input device
	//struct cap_SAA7119_instance *pSAA7119;
	//struct cap_TW9919_instance *pTW9919;
	//struct cap_AD9883_instance *pAD9883;
};

RMstatus cap_analog_video_open(
	struct RUA *pRUA, 
	struct cap_analog_video_instance **ppAnalogVideo, 
	struct cap_chip_instance *pChip)
{
	RMstatus err = RM_OK;
	struct cap_analog_video_instance *pAnalogVideo;

	RMDBGLOG((FUNCNAME, "%s\n",__func__));	

	// Sanity checks
	if (ppAnalogVideo == NULL) return RM_FATALINVALIDPOINTER;
	*ppAnalogVideo = NULL;
	if (pRUA == NULL) return RM_FATALINVALIDPOINTER;
	
	// Allocate and clear local instance
	pAnalogVideo = (struct cap_analog_video_instance *)RMMalloc(sizeof(struct cap_analog_video_instance));
	if (pAnalogVideo == NULL) {
		RMDBGLOG((ENABLE, "FATAL! Not enough memory for struct cap_analog_video_instance!\n"));
		return RM_FATALOUTOFMEMORY;
	}
	RMMemset(pAnalogVideo, 0, sizeof(struct cap_analog_video_instance));
	*ppAnalogVideo = pAnalogVideo;
	
	// Set default and non-zero startup values
	pAnalogVideo->pRUA = pRUA;
	pAnalogVideo->pChip = pChip;
	
	// Open selected chip
	switch (pAnalogVideo->pChip->chip) {
	case cap_chip_none:
		err = RM_NOT_SUPPORTED; 
		break;
	case cap_chip_SAA7119:
		//err = cap_SAA7119_open(pRUA, &(pAnalogVideo->pSAA7119), I2CModuleID, pI2CDevice, XtalClock, SampleRate);
		err = RM_OK;
		break;
	case cap_chip_TW9919:
		//err =  cap_TW9919_open(pRUA, &(pAnalogVideo->pTW9919), I2CModuleID, pI2CDevice, XtalClock);
		err = RM_OK;
		break;
	case cap_chip_AD9883:
		err = RM_NOTIMPLEMENTED;  // TODO
		break;
	case cap_chip_AD9380:
		err = RM_OK;
		break;
	default:
		err = RM_INVALID_PARAMETER;
	}
	
	if (RMFAILED(err)) {
		RMFree(pAnalogVideo);
		*ppAnalogVideo = NULL;
	}
	return err;
}

RMstatus cap_analog_video_close(
	struct cap_analog_video_instance *pAnalogVideo)
{
	RMstatus err = RM_OK;

	RMDBGLOG((FUNCNAME, "%s\n",__func__));	
	// Sanity checks
	if (pAnalogVideo == NULL) return RM_FATALINVALIDPOINTER;
	
	// Free all ressources
	switch (pAnalogVideo->pChip->chip) {
	case cap_chip_SAA7119:
		err = RM_OK;
		break;
	case cap_chip_TW9919:
		err = RM_OK;
		break;
	case cap_chip_AD9883:
		err = RM_NOTIMPLEMENTED;  // TODO	
		break;
	default:
		err = RM_ERROR;
	}
	
	RMFree(pAnalogVideo);
	
	return err;
}

RMstatus cap_analog_video_tristate(struct cap_analog_video_instance *pAnalogVideo)
{
	RMDBGLOG((FUNCNAME, "%s\n",__func__));

	if (pAnalogVideo == NULL) return RM_FATALINVALIDPOINTER;

	switch (pAnalogVideo->pChip->chip) {
	case cap_chip_SAA7119:
		return cap_SAA7119_tristate(pAnalogVideo->pChip->instance.pSAA7119);
		break;
	case cap_chip_TW9919:
		return cap_TW9919_tristate(pAnalogVideo->pChip->instance.pTW9919);
		break;
	case cap_chip_AD9883:
		//return cap_AD9883_tristate(pAnalogVideo->pChip->instance.pAD9883);
		break;
	default:
		return RM_ERROR;
	}

	return RM_OK;
}

RMstatus cap_analog_video_select_input(struct cap_analog_video_instance *pAnalogVideo,
				       enum cap_board board,
				       enum cap_video_input video_input, 
				       RMuint32 video_input_num )
{
	RMstatus err = RM_OK;

	RMDBGLOG((FUNCNAME, "%s\n",__func__));
	RMDBGLOG((FUNCNAME, "chip %d\n",pAnalogVideo->pChip->chip));
	// Sanity checks
	if (pAnalogVideo == NULL) return RM_FATALINVALIDPOINTER;

	switch (pAnalogVideo->pChip->chip) {
	case cap_chip_SAA7119:
		err = cap_SAA7119_init_capture(pAnalogVideo->pChip->instance.pSAA7119, 
					       board, 
					       video_input, 
					       video_input_num);
		if(RMFAILED(err)){
			return err;
		}
		err = cap_SAA7119_init_audio(pAnalogVideo->pChip->instance.pSAA7119);
		break;
	case cap_chip_TW9919:
		err = cap_TW9919_init_capture(pAnalogVideo->pChip->instance.pTW9919, board, video_input, video_input_num);
		err = cap_TW9919_setup_audio_mclk(pAnalogVideo->pChip->instance.pTW9919);
		break;
	case cap_chip_AD9883:
		err = RM_NOTIMPLEMENTED;  // TODO	
		break;
	case cap_chip_AD9380:
		err = cap_AD9380_init_analog_capture(pAnalogVideo->pChip->instance.pAD9380, video_input);
		break;
	default:
		err = RM_ERROR;
	}

	if(RMFAILED(err)){
		RMDBGLOG((ENABLE, "%failed for input select\n"));	
	}

	return err;
}

RMstatus cap_analog_video_setup_output(struct cap_analog_video_instance *pAnalogVideo, 
				       struct cap_update *pUpdate)
{
	RMstatus err = RM_OK;

	//RMDBGLOG((FUNCNAME, "%s\n",__func__));

	// Sanity checks
	if (pAnalogVideo == NULL) return RM_FATALINVALIDPOINTER;
	if (pUpdate == NULL) return RM_FATALINVALIDPOINTER;
	
	// Free all ressources
	switch (pAnalogVideo->pChip->chip) {
	case cap_chip_SAA7119:
		err = cap_SAA7119_setup_output(pAnalogVideo->pChip->instance.pSAA7119, pUpdate);
		if(RMFAILED(err)){
			return err;
		}
		err = cap_SAA7119_setup_audio(pAnalogVideo->pChip->instance.pSAA7119, pUpdate);
		break;
	case cap_chip_TW9919:
		err = cap_TW9919_setup_output(pAnalogVideo->pChip->instance.pTW9919, pUpdate);
		if(RMFAILED(err)){
			return err;
		}		
		err = cap_TW9919_setup_audio(pAnalogVideo->pChip->instance.pTW9919, pUpdate);
		break;
	case cap_chip_AD9883:
		err = RM_NOTIMPLEMENTED;  // TODO	
		break;
	default:
		err = RM_ERROR;
	}
	
	return err;
}


/*** Interrupt handling functions ***/

/* Returns RM_OK if cap_analog_video_handle_int() needs to be called */
RMstatus cap_analog_video_check_int(struct cap_analog_video_instance *pAnalogVideo)
{
	// Sanity checks
	if (pAnalogVideo == NULL) return RM_FATALINVALIDPOINTER;
	
	switch (pAnalogVideo->pChip->chip) {
	case cap_chip_SAA7119:
		return cap_SAA7119_check_int(pAnalogVideo->pChip->instance.pSAA7119);
		break;
	case cap_chip_TW9919:
		return cap_TW9919_check_int(pAnalogVideo->pChip->instance.pTW9919);
		break;
	case cap_chip_AD9380:
		return cap_AD9380_analog_check_int(pAnalogVideo->pChip->instance.pAD9380);
		break;		
	default:
		return RM_ERROR;
	}
}

/* check and handle interrupts and/or other changes on the chip, 
   fill in update information to pUpdate */
RMstatus cap_analog_video_handle_int(
	struct cap_analog_video_instance *pAnalogVideo, 
	struct cap_update *pUpdate)
{
	RMstatus err;
	
	// Sanity checks
	if (pAnalogVideo == NULL) return RM_FATALINVALIDPOINTER;
	
	switch (pAnalogVideo->pChip->chip) {
	case cap_chip_SAA7119:
		err = cap_SAA7119_handle_int(pAnalogVideo->pChip->instance.pSAA7119, pUpdate);
		break;
	case cap_chip_TW9919:
		err = cap_TW9919_handle_int(pAnalogVideo->pChip->instance.pTW9919, pUpdate);
		break;
	default:
		err = RM_ERROR;
		break;
	}
	if (RMFAILED(err)) return err;
	return err;
}