hw_at2041_api.c

1、基于韩国at2041芯片开发的Linux环境的DVR代码。 2、以原来代码进行了修改。 3、主要修改网络通讯出现异常问题处理 4、硬盘覆盖录像不起作用

/* set tabstop=4 */
/********************************************************************************
 *                                                                              *
 * Copyright(C) 2002  Penta-Micro                                               *
 *                                                                              *
 * ALL RIGHT RESERVED                                                           *
 *                                                                              *
 * This software is the property of Penta-Micro and is furnished under          *
 * license by Penta-Micro. This software may be used only in accordance         *	
 * with the terms of said license. This copyright notice may not be             *
 * removed, modified or obliterated without the prior written permission        *
 * of Penta-Micro.                                                              *
 *                                                                              *
 * This software may not be copyed, transmitted, provided to or otherwise       *
 * made available to any other person, company, corporation	or other entity     *
 * except as specified in the terms of said license.                            *
 *                                                                              *
 * No right, title, ownership or other interest in the software is hereby       *
 * granted or transferred.                                                      *
 *                                                                              *
 * The information contained herein is subject to change without notice and     *
 * should not be construed as a commitment by Penta-Micro.                      *
 *                                                                              *
 ********************************************************************************
 
  MODULE NAME:  AT2041_API.C
 
  DESCRIPTION:
  
  This Module contains AT2041 API function.
  
 ...............................................................................
*/            
 

/** ************************************************************************* ** 
 ** includes
 ** ************************************************************************* **/
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <asm/ioctl.h>
#include <asm/errno.h>
#include <linux/slab.h>
#include <linux/config.h>

#include "hw_at2041_api.h"
#include "hw_at2041_reg.h"


/** ************************************************************************* ** 
 ** defines
 ** ************************************************************************* **/
//#define m_DEBUG(format, args...)  printf(format, ## args) 
#define m_DEBUG(format, args...)  
#define m_MSG(format, args...)	printf(format, ## args) 
#define m_ERROR(format, args...)  printf(format, ## args);fflush(stdout); 


/** ************************************************************************* ** 
 ** typedefs
 ** ************************************************************************* **/

	 
/** ************************************************************************* ** 
 ** globals
 ** ************************************************************************* **/

/** ************************************************************************* ** 
 ** locals
 ** ************************************************************************* **/
static S32 fd_at2041;
UNS16     rx_id, rx_data, state;


/** ************************************************************************* ** 
 ** forward declarations
 ** ************************************************************************* **/

/* AT2041 general functions */
RETURN at2041_open(void)
{
	/* file[AT2041 device] open */
	if (!(fd_at2041 = open("/dev/at2041", O_RDWR))) {
		m_DEBUG(" device driver open fail!!!\n");		
		return FAILURE;
	}
      return SUCCESS;
}

void at2041_close(void)
{
	close(fd_at2041);
}

int at2041_ioctl_init()
{
	int return_data;
	
	ioctl(fd_at2041, AT2041_INIT, &return_data);	
//printf("[at2041_api][at2041_ioctl_init] return_data= %d\n", return_data);
	return return_data;
}

RETURN at2041_load_image(void)
{
	UNS16	read_data;
	UNS32	r_data;
	int		boot_size, i;
	int		return_data;
	int 		dummy;
	FILE	*fp;

	if ((fp=fopen("at2041.bin", "rb")) < 0) {
		m_ERROR("[at2041_api] cannot found boot image");
		return FAILURE;
	}

AT2041_DOWNLOAD_ROUTINE:
	m_MSG("\nat2041 uploading... \n");		
	// read file size...
	fseek(fp, 0, SEEK_END);
	boot_size = ftell(fp);
	fseek(fp, 0, SEEK_SET);

	// swpark
	// disable at2041 interrupt

	printf("at2041 interrupt disable !!\n");
	ioctl(fd_at2041, AT2041_INT_DISABLE, &dummy);
	usleep(1000);
	
	ppc405_gpio_at2041_reset();	


#if 1

	// check ready status
	while (!(read_status() & 0x1000)) {
		usleep(300000);
		printf("AT2041 status register is not empty !!\n");
		goto AT2041_DOWNLOAD_ROUTINE;
	}

	write_command_register(0x02); // SDRAM scheduler start	

	for (i = 0; i < (boot_size/4); i++) {
		if (fread(&r_data, sizeof(UNS32), 1, fp) <= 0) {
			m_ERROR("\n[at2041_api] Error read firmware data");		
		}	
		read_data= ((r_data & 0xff) << 8) | ((r_data & 0xff00) >> 8);
		write_demux_fifo(read_data);
		read_data= ((r_data & 0xff0000) >>8) | ((r_data & 0xff000000) >> 24);
		write_demux_fifo(read_data);
	}

	for(i=0; i < 2048; i++)
	{
		read_data = 0x0000;			//e05f
		write_demux_fifo(read_data);
		write_demux_fifo(read_data);		
	}	

	// sdram enable...
	write_command_register(0x01);	

#endif
	usleep(1000);
	return_data= at2041_ioctl_init();
	if (return_data != 0){
		printf("Error loading AT2041 firmware data : return_data= %d !!\n", return_data);
		goto AT2041_DOWNLOAD_ROUTINE;
	}

	fclose(fp);
	m_MSG("AT2041 Firmware download completed !!\n\n");

	/* size : 64 ~ 1024 Mbit, default is 256 Mbit */
	set_sdram_size(256);
	/* ch_size : 1 ~ 16 channel, default is 4 channel */
	set_channel_size(4);

	/* mode : '0' forbidden, '1' encoder, '2' codec, '3' decoder
	 *        default is 0x00
	 */
	set_operation_mode(2);

      // set gio mode : GID= 0, CID= 0, PID= 0x12
	set_gio_mode(1); // set gio to debug mode 

	// set input clock 
//	set_input_video_clock_inversion(1); // use inversion clock
//	output_video_clock_inversion(0);
//	colorbar_mode(1);

#if 1//org code
	// set input video sync mode : GID= 4, CID=0, PID= 3
	set_input_video_sync_mode(0); // normal embeded sync mode
#endif

	/* mode : '0' use input clock
	 *        '1' use inverted input clock
	 *        default is '0'
	 */	
	output_video_clock_inversion(0);
	/* mode : '0' off
	 *        '1' background image display mode
	 *        '2' input video monitor mode
	 *        default is '0'
	 */	
	background_image_display_mode(0);

// 2005.10.21 pentamicro
// This must be included in the initial phase. This might not be located in set_dec_park
	background_color_mode1(16, 128, 128);

	/* mode:      data ready ack: '0'  default is '0'
         *          alt data ready ack: '1' 
      */
	set_data_ready_ack_mode(1);

	/* lpf : low pass filter, '0' off, '1' on, default is 'on'
         * med : median filter, '0' off, '1' on, default is 'on'
      */
	set_preprocess(0, 0);

	/* format : audio input format
	 *          '0' I2S mode, '1' left justified mode, '2' u-Law PCM mode,
	 *          '3' a-Law PCM mode, '4' linear PCM mode, default is '2'
	 * bits : bits per sample x the number of the input channel
	 *        '0' 8-bit, '1' 16-bit, '4' 32-bit, '5' 64-bit,
	 *        '6' 128-bit, default is '4'
	 * delay_mode : delay mode, '0' no delay, '1' 1 bit delay, default is 0
	 */
	audio_input_format(2, 4, 0);

	/* mode : '0' single channel encoding (channel ID = 0)
     	*        '1' AT401xE VBI interface mode
     	*        '70' TW2834 interface mode
     	*        default is 0
     	*/
	set_channel_id_interface_mode(70);
	// enable at2041 interrupt
	printf("at2041 interrupt enable !!\n");
	ioctl(fd_at2041, AT2041_INT_ENABLE, &dummy);
	usleep(1000);

	return SUCCESS;
}

void write_command_register(UNS16 data)
{
	ioctl(fd_at2041, WRITE_COMMAND_REG, &data);
}

void write_demux_fifo(UNS16 data)
{
	ioctl(fd_at2041, WRITE_DEMUX_FIFO, &data);
}

/* 
 * Rx FIFO access 
 */

/* Global parameters */
void ack_for_tx(void)
{
	rx_id = RxID(GID_GLB, 0x00, PID_GLB_ACK, W_FLAG);
	ioctl(fd_at2041, WRITE_Rx_FIFO, &rx_id);
	
	ioctl(fd_at2041, END_OF_WRITE_Rx_FIFO);
}

void set_operation_mode(UNS16 mode)
{
       /* mode : '0' forbidden, '1' encoder, '2' codec, '3' decoder
	 *        default is 0x00
         */
        rx_id = RxID(GID_GLB, 0x00, PID_GLB_OP, W_FLAG);
        write_parm(rx_id, mode);
}

void set_sdram_size(UNS16 size)
{
        /* size : 64 ~ 1024 Mbit, default is 256 Mbit */
        rx_id = RxID(GID_GLB, 0x00, PID_GLB_SDR_SIZE, W_FLAG);
        write_parm(rx_id, size);
}

void set_maximum_video_size(UNS16 hsize, UNS16 vsize)
{
        /* hsize : 32 ~ 720, vsize : 16 ~ 576
         *         default is 720 x 576
         */
        rx_id = RxID(GID_GLB, 0x00, PID_GLB_VID_SIZE, W_FLAG);
        ioctl(fd_at2041, WRITE_Rx_FIFO, &rx_id);
        ioctl(fd_at2041, WRITE_Rx_FIFO, &hsize);
        ioctl(fd_at2041, WRITE_Rx_FIFO, &vsize);
        
        ioctl(fd_at2041, END_OF_WRITE_Rx_FIFO);
}

void set_channel_size(UNS16 ch_size)
{
        /* ch_size : 1 ~ 16 channel, default is 4 channel */
        rx_id = RxID(GID_GLB, 0x00, PID_GLB_CH_SIZE, W_FLAG);
        write_parm(rx_id, ch_size);
}

void set_maximum_gopm(UNS16 gopm_size)
{
        /* gopm_size : 1 ~ 3, default is 3 */
        rx_id = RxID(GID_GLB, 0x00, PID_GLB_GOPM_SIZE, W_FLAG);
        write_parm(rx_id, gopm_size);
}

void set_gio_mode(UNS16 mode)
{
	rx_id= RxID(GID_GLB, 0x00, PID_GLB_GIO_MODE, W_FLAG);
	write_parm(rx_id, mode);
}

void set_encoder_buffer_size(UNS16 system_stream_buf_size, UNS16 video_es_buf_size, 
	UNS16 audio_es_buf_size, UNS16 audio_data_input_buf_size)
{
        /* system_stream_buf_size : 1 ~ 16 Mbit, default is 1 Mbit
         * video_es_buf_size : 1 ~ 16 Mbit, default is 4 Mbit
         * audio_es_buf_size : 1 ~ 16 Mbit, default is 1 Mbit
         * audio_data_input_buf_size : 1 ~ 16 Mbit, default is 2 Mbit
         */
        rx_id = RxID(GID_GLB, 0x00, PID_GLB_ENCB_SIZE, W_FLAG);
        ioctl(fd_at2041, WRITE_Rx_FIFO, &rx_id);
        ioctl(fd_at2041, WRITE_Rx_FIFO, &system_stream_buf_size);
        ioctl(fd_at2041, WRITE_Rx_FIFO, &video_es_buf_size);
        ioctl(fd_at2041, WRITE_Rx_FIFO, &audio_es_buf_size);
        ioctl(fd_at2041, WRITE_Rx_FIFO, &audio_data_input_buf_size);
        
        ioctl(fd_at2041, END_OF_WRITE_Rx_FIFO);
}

void set_decoder_buffer_size(UNS16 input_stream_buf0_size, UNS16 input_stream_buf1_size, 
	UNS16 input_stream_buf2_size, UNS16 input_stream_buf3_size, 
	UNS16 audio_data_output_buf_size)
{
        /* input_stream_buf0_size : 1 ~ 16 Mbit, default is 4 Mbit
         * input_stream_buf1_size : 1 ~ 16 Mbit, default is 2 Mbit
         * input_stream_buf2_size : 1 ~ 16 Mbit, default is 1 Mbit
         * input_stream_buf3_size : 1 ~ 16 Mbit, default is 1 Mbit
         * audio_data_output_buf_size : 1 ~ 16 Mbit, default is 2 Mbit
         */
        rx_id = RxID(GID_GLB, 0x00, PID_GLB_DECB_SIZE, W_FLAG);
        ioctl(fd_at2041, WRITE_Rx_FIFO, &rx_id);
        ioctl(fd_at2041, WRITE_Rx_FIFO, &input_stream_buf0_size);
        ioctl(fd_at2041, WRITE_Rx_FIFO, &input_stream_buf1_size);
        ioctl(fd_at2041, WRITE_Rx_FIFO, &input_stream_buf2_size);
        ioctl(fd_at2041, WRITE_Rx_FIFO, &input_stream_buf3_size);
        ioctl(fd_at2041, WRITE_Rx_FIFO, &audio_data_output_buf_size);
        
        ioctl(fd_at2041, END_OF_WRITE_Rx_FIFO);
}

void sdram_allocation(void)
{
        /* before this command, you should set the following parameters properly
         * operation mode, SDRAM size, maximum video size, channel size,
         * maxmum GOPM, encoder buffer size, decoder buffer size etc.
         */
        rx_id = RxID(GID_GLB, 0x00, PID_GLB_SDR_ALLOC, W_FLAG);
        ioctl(fd_at2041, WRITE_Rx_FIFO, &rx_id);
        
        ioctl(fd_at2041, END_OF_WRITE_Rx_FIFO);
}

/* Encoder system parameters */
void encoder_start(void)
{
	/* video/audio encoder start */
	rx_id = RxID(GID_ENC, 0x00, PID_ENC_START, W_FLAG);
	write_parm(rx_id, 0x0003);
}

void encoder_stop(void)
{
	/* video/audio encoder stop */
	rx_id = RxID(GID_ENC, 0x00, PID_ENC_STOP, W_FLAG);
	write_parm(rx_id, 0x0003);
}

void video_encoder_start(void) 
{
	rx_id = RxID(GID_ENC, 0x00, PID_ENC_START, W_FLAG);
	write_parm(rx_id, 0x0003);
}

void video_encoder_stop(void) 
{
	rx_id = RxID(GID_ENC, 0x00, PID_ENC_STOP, W_FLAG);
	write_parm(rx_id, 0x0003);
}

void video_encoder_buffer_reset(void)
{
	S32 dummy;

	ioctl(fd_at2041, AT2041_ENC_RESET_BUFFER, &dummy);
}