mt9t001_fxns.c

TI DM642 DSP 驱动CMOS 成像芯片MT9T001(Micron)源代码,TI原版资料.包含驱动环境配置,对如基于DSP的数码相机,摄像机开发有重要参考价值.

/*
 *  Copyright 2004 by Texas Instruments Incorporated.
 *  All rights reserved. Property of Texas Instruments Incorporated.
 *  Restricted rights to use, duplicate or disclose this code are
 *  granted through contract.
 *  
 */

/********************************************
 Include Files
********************************************/

#include <std.h>        
#include <evmdm642.h>
#include "edc.h"

#include "_iic.h"
#include "MT9T001.h"
#include "MT9T001_fxns.h"

/********************************************
 Constants
********************************************/
#define MT9T001_ON_VP0 0
#define MT9T001_ON_VP1 1

#define PCA9540B_ADDRESS 0xE0 >> 1
#define PCA9540B_VP0	0x04
#define PCA9540B_VP1	0x05

// Handle to I2C
extern I2C_Handle EVMDM642_I2C_hI2C;

// EDC Required Functions
far EDC_Fxns MT9T001_Fxns = {
    MT9T001_open,
    MT9T001_close,
    MT9T001_ctrl
};

/****************************************
 MT9T001 Register Variable Declarations
****************************************/


/********************************************
 MT9T001_open
  - Open the Sensor for use
********************************************/
static EDC_Handle MT9T001_open(String devName, Arg optArg)
{

    Int devId;

    /* Check if the addresse is correct */
    if(devName[0] != '/')
    {
        devId = -1;
    } 
    // Sensor on VP0
    else if(devName[1] == '0') 
    {
         devId = MT9T001_ON_VP0;
         MT9T001_Reset_Dev((EDC_Handle)devId);
    }
    // Sensor on VP1 
    else if(devName[1] == '1')
    {
         devId = MT9T001_ON_VP1;
         MT9T001_Reset_Dev((EDC_Handle)devId);
    }
    // Invalid 
    else 
    {
         devId = -1;
    }
    
    return (EDC_Handle)devId;

}

/********************************************
 MT9T001_close
  - Close and powerdown the sensor
********************************************/
static Int MT9T001_close(EDC_Handle handle) 
{

	// I2C address multiplexing
	MT9T001_PCA9540_Address_Multiplex(handle);
	MT9T001_PowerDown(handle);
    return EDC_SUCCESS;    

}

/********************************************
 MT9T001_ctrl
  - Issue commands to the sensor
********************************************/
static int MT9T001_ctrl(EDC_Handle handle, unsigned int cmd, Arg arg)
{
	Bool status = 1;
	
	// I2C address multiplexing
	status &= MT9T001_PCA9540_Address_Multiplex(handle);
	
	switch(cmd)
	{

		case EDC_CONFIG:
			status &= MT9T001_Config(handle, (void *)arg);		
		break;
		
		case EDC_RESET:
			MT9T001_Reset_Dev(handle);
		break;
		
		case EDC_START:
			// Restart Frame and Enable continuous capture mode
			status &= MT9T001_Begin_Capture(handle);			
		break;
				
		default:
			return EDC_FAILED;
		//break;
	
	} // end switch
	
	if(status == 1)
		return EDC_SUCCESS;
	else
		return EDC_FAILED;
			
}

/********************************************
 MT9T001_Config
  - Configure the sensor for the desired
  	capture resolution.
********************************************/
static Bool MT9T001_Config(EDC_Handle handle, MT9T001_Params *params)
{
	int status = 1;
	
	status &= MT9T001_PCA9540_Address_Multiplex(handle);
	
	
	RowSize_reg.data = params->rowsize;
	ColSize_reg.data = params->colsize;
	HorizBlank_reg.data = params->horizblank;
	VertBlank_reg.data = params->vertblank;
	ShutterWidth_reg.data = params->shutterwidth;
	
	RedGain_reg.data = params->redgain;
	BlueGain_reg.data = params->bluegain;
	BlackLevel_reg.data = params->blacklevel;
 	GlobalGain_reg.data = params->globalgain;
 	Green1Gain_reg.data = params->green1gain;
 	Green2Gain_reg.data = params->green2gain;	
	
	status &= MT9T001_Write_Verify(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_ROW_SIZE, &RowSize_reg.byte[0], 2);
	status &= MT9T001_Write_Verify(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_COLUMN_SIZE, &ColSize_reg.byte[0], 2);
	status &= MT9T001_Write_Verify(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_HORIZONTAL_BLANK, &HorizBlank_reg.byte[0], 2);
	status &= MT9T001_Write_Verify(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_VERTICAL_BLANK, &VertBlank_reg.byte[0], 2);
	status &= MT9T001_Write_Verify(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_SHUTTER_WIDTH, &ShutterWidth_reg.byte[0], 2);
	
	status &= MT9T001_Write_Verify(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_BLUE_GAIN, &RedGain_reg.byte[0], 2);
	status &= MT9T001_Write_Verify(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_RED_GAIN, &BlueGain_reg.byte[0], 2);
	status &= MT9T001_Write_Verify(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_BLACK_LEVEL, &BlackLevel_reg.byte[0], 2);
	status &= MT9T001_Write_Verify(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_GLOBAL_GAIN, &GlobalGain_reg.byte[0], 2);
	status &= MT9T001_Write_Verify(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_GREEN1_GAIN, &Green1Gain_reg.byte[0], 2);
	status &= MT9T001_Write_Verify(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_GREEN2_GAIN, &Green2Gain_reg.byte[0], 2);
	
	
	status &= MT9T001_Common_Config_Settings(handle);
	
	if(!status)
		return(FALSE);
	else
		return(TRUE);
	
}

/********************************************
 MT9T001_Begin_Capture
 - Restart Frame and Enable continuous 
 	capture mode
********************************************/
int MT9T001_Begin_Capture(EDC_Handle handle)
{

	int status = 1;

	// I2C address multiplexing
	status &= MT9T001_PCA9540_Address_Multiplex(handle);
		
	FrameRestart_reg.data = 1;
	
	// read the readmode1 register
	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_READ_MODE_1, &ReadMode1_reg.byte[1], 2);
	ReadMode1_reg.flds.snapshot = 0;
	
	// Restart Frame - This register returns to zero when a new frame starts.  Checking the status will result in errors
	//   as a result
	MT9T001_Write_Verify(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_FRAME_RESTART, &FrameRestart_reg.byte[0], 2);
	
	// Enable continuous capture
	status &= MT9T001_Write_Verify(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_READ_MODE_1, &ReadMode1_reg.byte[0], 2);
	
	return status;
	
}


/********************************************
 MT9T001_Reset_Dev
 - Reset the sensor
********************************************/
void MT9T001_Reset_Dev(EDC_Handle devHandle)
{ 

	Uint8 resetEnable[2] = {1,1};
	Uint8 resetDisable[2] = {0,0};
	
	// I2C address multiplexing
	MT9T001_PCA9540_Address_Multiplex(devHandle);
	
	MT9T001_Write_Verify(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_RESET, &resetEnable[0], 2);
	MT9T001_Write_Verify(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_RESET, &resetDisable[0], 2);

}


/********************************************
 MT9T001_PowerDown
 - Power down the sensor
********************************************/
void MT9T001_PowerDown(EDC_Handle devHandle)
{ 

	OutCtrl_reg.data = 0;
	OutCtrl_reg.flds.chipEnable = 0;
	
	// I2C address multiplexing
	MT9T001_PCA9540_Address_Multiplex(devHandle);
	MT9T001_Write_Verify(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_OUTPUT_CONTROL, &OutCtrl_reg.byte[0], 2);

}

/********************************************
 MT9T001_Write_Verify
 - Access sensor registers via I2C
 	This function writes to the desired 
 	register, then reads the register back
 	to verify the written data.
********************************************/
Bool MT9T001_Write_Verify(I2C_Handle hI2C, Uint8 devAddress, Uint32 subAddress, Uint8 *data, Uint16 numBytes)
{

	int status = 1;

	typedef union DATAREAD  
	{
		Uint16 word;
		Uint8 byte[2];
	} u_DATAREAD;
	
	typedef union DATAWRITE
	{
		Uint16 word;
		Uint8 byte[2];
	} u_DATAWRITE;
	
	u_DATAREAD dataRead = {0};
	u_DATAWRITE dataWrite = {0};
	
	Uint8 jj = 0;
	
	dataWrite.byte[1] = data[1]; 
	dataWrite.byte[0] = data[0];
	
	_IIC_write_rev(hI2C, devAddress, subAddress, &dataWrite.byte[1], numBytes);	
	_IIC_read_rev(hI2C, devAddress, subAddress, &dataRead.byte[1], numBytes);

	// compare what was written to what was read back
	for(jj = 0; jj < numBytes; jj++)
	{
		 // error
		 if(dataWrite.byte[jj] != dataRead.byte[jj])
		 	status = 0;
	}
	
	return status;
}							

/********************************************
 MT9T001_Read_All_Registers
 - Read all sensor registers.
 	Register values are stored in structure
 	[Reg]_reg_str
********************************************/
int MT9T001_Read_All_Registers(EDC_Handle devHandle)
{
	int status = 1;
	
	// I2C address multiplexing
	status &= MT9T001_PCA9540_Address_Multiplex(devHandle);
	
	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_CHIPID, &chipID_reg_str.byte[1], 2);
	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_ROW_START, &RowStart_reg_str.byte[1], 2);
	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T00ADDR1_COLUMN_START, &ColStart_reg_str.byte[1], 2);
	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_ROW_SIZE, &RowSize_reg_str.byte[1], 2);
	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_COLUMN_SIZE, &ColSize_reg_str.byte[1], 2);   	
   	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_HORIZONTAL_BLANK, &HorizBlank_reg_str.byte[1], 2);
   	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_VERTICAL_BLANK, &VertBlank_reg_str.byte[1], 2);
   	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_OUTPUT_CONTROL, &OutCtrl_reg_str.byte[1], 2);
   	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_SHUTTER_WIDTH_UPPER, &ShutterWidthUpper_reg_str.byte[1], 2);
   	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_CHIPID, &chipID_reg_str.byte[1], 2);
   	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_SHUTTER_WIDTH, &ShutterWidth_reg_str.byte[1], 2);
	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_PIXEL_CLOCK_CTRL, &PixlClkCtrl_reg_str.byte[1], 2);
   	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_FRAME_RESTART, &FrameRestart_reg_str.byte[1], 2);
	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_SHUTTER_DELAY, &ShutterDelay_reg_str.byte[1], 2);
	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_RESET, &Reset_reg_str.byte[1], 2);
	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_READ_MODE_1, &ReadMode1_reg_str.byte[1], 2);
	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_READ_MODE_2, &ReadMode2_reg_str.byte[1], 2);
	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_READ_MODE_3, &ReadMode3_reg_str.byte[1], 2);
	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_ROW_ADDRESS_MODE, &RowAddress_reg_str.byte[1], 2);
	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_COLUMN_ADDRESS_MODE, &ColAddress_reg_str.byte[1], 2);
	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_GREEN1_GAIN, &Green1Gain_reg_str.byte[1], 2);
	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_BLUE_GAIN, &BlueGain_reg_str.byte[1], 2);
	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_RED_GAIN, &RedGain_reg_str.byte[1], 2);
	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_GREEN2_GAIN, &Green2Gain_reg_str.byte[1], 2);
	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_GLOBAL_GAIN, &GlobalGain_reg_str.byte[1], 2);
	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_BLACK_LEVEL, &BlackLevel_reg_str.byte[1], 2);
	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_BLACK_LEVEL_CAL_COARSE, &BlackCoarse_reg_str.byte[1], 2);
	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_BLACK_LEVEL_CAL_TARGET, &BlackTarget_reg_str.byte[1], 2);
	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_GREEN1_OFFSET, &Green1Offset_reg_str.byte[1], 2);
	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_GREEN2_OFFSET, &Green2Offset_reg_str.byte[1], 2);
	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_BLACK_LEVEL_CAL, &BlackLevelCal_reg_str.byte[1], 2);
	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_RED_OFFSET, &RedOffset_reg_str.byte[1], 2);
	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_BLUE_OFFSET, &BlueOffset_reg_str.byte[1], 2);
	_IIC_read_rev(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_CHIP_ENABLE, &ChipEnableSync_reg_str.byte[1], 2);

	return status;
}

/******************************************************
 MT9T001_Common_Config_Settings
 - Initialize register values that are common to all
 	capture modes
******************************************************/
static int MT9T001_Common_Config_Settings(EDC_Handle devHandle)
{

	int status = 1;
	
	// I2C address multiplexing
	status &= MT9T001_PCA9540_Address_Multiplex(devHandle);
	
	// initialize registers
	PixlClkCtrl_reg.data = 0;
	FrameRestart_reg.data = 0; 
	ReadMode1_reg.data = 0;
	ReadMode2_reg.data = 0;
	
	// invert pixel clock
	PixlClkCtrl_reg.flds.invert = 1;
	
	// Disable continuous mode	
	ReadMode1_reg.flds.snapshot = 1;
	
	// No bad frames, no line valid during vertical blanks
	ReadMode2_reg.flds.noBadFrame = 0;
	ReadMode2_reg.flds.contLV = 0;
	ReadMode2_reg.flds.xorLV = 0;
	

	// write to MT9T001
	status &= MT9T001_Write_Verify(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_PIXEL_CLOCK_CTRL, &PixlClkCtrl_reg.byte[0], 2);
	status &= MT9T001_Write_Verify(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_READ_MODE_1, &ReadMode1_reg.byte[0], 2);
	status &= MT9T001_Write_Verify(EVMDM642_I2C_hI2C,  MT9T001_ADDRESS, MT9T001ADDR_READ_MODE_2, &ReadMode2_reg.byte[0], 2);
			
	return status;
	
}


/********************************************
 MT9T001_PCA9540_Address_Multiplex()
  - Perform address translation based on the handle.
  	The drivers are capable of handling 2 MT9T001 sensors.
  	Both sensors have the same i2c address.  The PCA9540
  	performs the address multiplexing required.
********************************************/
int MT9T001_PCA9540_Address_Multiplex(EDC_Handle handle) 
{
	Int devID = (int)handle;
	int status = 1;

	switch(devID)
	{

		case MT9T001_ON_VP0:
			// Perform address translation
			_IIC_write(EVMDM642_I2C_hI2C,  PCA9540B_ADDRESS, PCA9540B_VP0, NULL, 0);
			status = 1;
		break;
		
		case MT9T001_ON_VP1:
			// Perform address translation
			_IIC_write(EVMDM642_I2C_hI2C,  PCA9540B_ADDRESS, PCA9540B_VP1, NULL, 0);
			status = 1;
		break;
		
		default:
			status = 0;
		//break;
	
	} // end switch

        return status;    

}