zc3xx.h

三星2440 cpu WINCE 5.00板级支持包

#ifndef ZC3XXUSB_H
#define ZC3XXUSB_H
/****************************************************************************
#	 	Z-star zc301 zc302 P library                                #
# 		Copyright (C) 2004 Michel Xhaard   [e-mail]         #
#                                                                           #
# This program is free software; you can redistribute it and/or modify      #
# it under the terms of the GNU General Public License as published by      #
# the Free Software Foundation; either version 2 of the License, or         #
# (at your option) any later version.                                       #
#                                                                           #
# This program is distributed in the hope that it will be useful,           #
# but WITHOUT ANY WARRANTY; without even the implied warranty of            #
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             #
# GNU General Public License for more details.                              #
#                                                                           #
# You should have received a copy of the GNU General Public License         #
# along with this program; if not, write to the Free Software               #
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA #
#                                                                           #
****************************************************************************/
#include "tas5130c.h"
#include "tas5130c_fv0250.h"
#include "icm105a.h"
#include "hdcs2020.h"
#include "hv7131b.h"
#include "pb0330.h"
#include "hv7131c.h"
#include "cs2102.h"
#include "pas106b.h"
#include "ov7630c.h"
#define SENSOR_SAA7113 0
#define SENSOR_INTERNAL 1
#define SENSOR_HV7131B  2
#define SENSOR_HDCS1020 3
#define SENSOR_PB100_BA 4
#define SENSOR_PB100_92 5
#define SENSOR_PAS106_80 6
#define SENSOR_TAS5130CXX 7
#define SENSOR_ICM105A 8
#define SENSOR_HDCS2020 9
#define SENSOR_PAS106 10
#define SENSOR_PB0330 11
#define SENSOR_HV7131C 12
#define SENSOR_CS2102 13
#define SENSOR_HDCS2020b 14
#define SENSOR_HV7131R 15
#define SENSOR_OV7630 16
#define SENSOR_MI0360 17
#define SENSOR_TAS5110 18
#define SENSOR_PAS202 19
#define SENSOR_PAC207 20
#define SENSOR_OV7630C 21
#define SENSOR_TAS5130C_FV0250 22
/*******************     Camera Interface   ***********************/
static U16 zc3xx_getbrightness(USBCAM_CONTEXT *spca50x);
static U16 zc3xx_getcontrast(USBCAM_CONTEXT *spca50x);
static U16 zc3xx_getcolors(USBCAM_CONTEXT *spca50x);
static void zc3xx_setbrightness(USBCAM_CONTEXT *spca50x);
static void zc3xx_setcontrast(USBCAM_CONTEXT *spca50x);
static void zc3xx_setcolors(USBCAM_CONTEXT *spca50x);
static int zc3xx_init(USBCAM_CONTEXT *spca50x);
static void zc3xx_start(USBCAM_CONTEXT *spca50x);
static void zc3xx_stop0(USBCAM_CONTEXT *spca50x);
static void zc3xx_stopN(USBCAM_CONTEXT *spca50x);
static int zc3xx_config(USBCAM_CONTEXT *spca50x);
static void zc3xx_shutdown(USBCAM_CONTEXT *spca50x);
static void zc3xx_setAutobright(USBCAM_CONTEXT *spca50x);
static void zc3xx_setquality(USBCAM_CONTEXT *spca50x);
static int zc3xx_sofdetect(USBCAM_CONTEXT *spca50x, unsigned char *cdata,int *iPix, int seqnum, int *datalength);
/*******************      Banding flilter   ***********************/
static void zc3xx_set50HZ(USBCAM_CONTEXT *spca50x);
static void zc3xx_set60HZ(USBCAM_CONTEXT *spca50x);
static void zc3xx_set50HZScale(USBCAM_CONTEXT *spca50x);
static void zc3xx_set60HZScale(USBCAM_CONTEXT *spca50x);
static void zc3xx_setNoFliker(USBCAM_CONTEXT *spca50x);
static void zc3xx_setNoFlikerScale(USBCAM_CONTEXT *spca50x);
/*******************     Camera Private     ***********************/
static void zc3xx_stopN(USBCAM_CONTEXT *spca50x){}
/******************************************************************/
static struct cam_operation fzc3xx = {
	zc3xx_init,
	zc3xx_config,
	zc3xx_start,
	zc3xx_stopN,
	zc3xx_stop0,
	zc3xx_getbrightness,
	zc3xx_setbrightness,
	zc3xx_getcontrast,
	zc3xx_setcontrast,
	zc3xx_getcolors,
	zc3xx_setcolors,
	zc3xx_setAutobright,
	zc3xx_setquality,
	zc3xx_shutdown,
	zc3xx_sofdetect,
	zc3xx_set50HZ,
	zc3xx_set60HZ,
	zc3xx_set50HZScale,
	zc3xx_set60HZScale,
	zc3xx_setNoFliker,
	zc3xx_setNoFlikerScale,	
 };
 
enum {
    SensorId = 0,
    reg8d,
    val8d,
    SensorReg1,
    valSreg1L,
    valSreg1H,
    SensorReg2,
    valSreg2L,
    valSreg2H,
    totval,
};
#define VGATOT 9
static U8 zcxxi2cSensor[VGATOT][totval] = {
    {0x00, 0xff, 0xff, 0x01, 0xaa, 0x00, 0xff, 0xff, 0xff},	// HV7131B
    {0x04, 0xff, 0xff, 0x01, 0xaa, 0x00, 0xff, 0xff, 0xff},	// CS2102
    {0x06, 0x8d, 0x08, 0x11, 0xaa, 0x00, 0xff, 0xff, 0xff},
    {0x08, 0xff, 0xff, 0x1c, 0x00, 0x00, 0x15, 0xaa, 0x00},	// HDCS2020 ?
    {0x0a, 0xff, 0xff, 0x07, 0xaa, 0xaa, 0xff, 0xff, 0xff},	// MI330 PB330
    {0x0c, 0xff, 0xff, 0x01, 0xaa, 0x00, 0xff, 0xff, 0xff},	// ICM105
    {0x0e, 0x8d, 0x08, 0x03, 0xaa, 0x00, 0xff, 0xff, 0xff},	// pas102
    {0x02, 0xff, 0xff, 0x01, 0xaa, 0x00, 0xff, 0xff, 0xff},
    {0x06, 0x8b, 0xa1, 0x12, 0x80, 0x00, 0x0a, 0x0b, 0xff},	// OV7630c
};

#define SIFTOT 1
static U8 zcxxi2cSensorSIF[SIFTOT][totval] = {
#if 0
    {0x01, 0xff, 0xff, 0x01, 0xaa, 0x00, 0xff, 0xff, 0xff},	// corrupt with 0x00 hv7131b reg 0 return 0x01 readonly
    {0x05, 0xff, 0xff, 0x01, 0xaa, 0x00, 0xff, 0xff, 0xff},
    {0x07, 0x8d, 0x08, 0x11, 0xaa, 0x00, 0xff, 0xff, 0xff},
    {0x09, 0xff, 0xff, 0x1c, 0x00, 0x00, 0x15, 0xaa, 0x00},	// corrupt with 0x08 hdcs2020 reg 0 return 0x18 readonly
    {0x0b, 0xff, 0xff, 0x07, 0xaa, 0xaa, 0xff, 0xff, 0xff},
    {0x0d, 0xff, 0xff, 0x01, 0x11, 0x00, 0xff, 0xff, 0xff},	// corrupt with 0x0c ICM105 reg 0 is writable
#endif
    {0x0f, 0x8d, 0x08, 0x03, 0xaa, 0x00, 0xff, 0xff, 0xff},	// PAS106 reg3 did not write with 0x0e !conflict PAS102 
};
static U8 zcxx3wrSensor[][5] = {
    {0x8b, 0xb3, 0x11, 0x12, 0xff},	// HV7131R
    {0x8b, 0x91, 0x14, 0x15, 0x16},
    {0x8b, 0xe0, 0x14, 0x15, 0x16},
    {0, 0, 0, 0, 0}
};
/***************************** Implementation ****************************/
static void spca5xxRegRead(USBCAM_CONTEXT *pUsbCam,
			   U16 reg,
			   U16 value,
			   U16 index, U8 * buffer, U16 length)
{
    USB_DEVICE_REQUEST ControlHeader;
    DWORD  dwBytesTransferred = 0;
    DWORD  dwUsbErr = USB_NO_ERROR;
    DWORD  dwErr = ERROR_SUCCESS;


    DEBUGMSG( ZONE_USB_CONTROL, (TEXT(">GetPortStatus\n")));

    if ( !VALID_CONTEXT( pUsbCam)  ) {
        DEBUGMSG( ZONE_ERR, (TEXT("Invalid parameter\n")));
    } else {

        ControlHeader.bmRequestType = USB_REQUEST_DEVICE_TO_HOST | USB_REQUEST_CLASS | USB_REQUEST_FOR_INTERFACE;
        ControlHeader.bRequest = (UCHAR)reg;
        ControlHeader.wValue   = value;
        ControlHeader.wIndex   = index;
        ControlHeader.wLength  = 1;

        dwErr = IssueVendorTransfer( pUsbCam->UsbFuncs,
                                     pUsbCam->hUsbDevice,
                                     DefaultTransferComplete,
                                     pUsbCam->hEP0Event,
                                     (USB_IN_TRANSFER | USB_SHORT_TRANSFER_OK),
                                     &ControlHeader,
                                     buffer, length,
                                     &dwBytesTransferred,
                                     pUsbCam->UsbTimeouts.PortStatusTimeout,
                                     &dwUsbErr );

        if ( ERROR_SUCCESS != dwErr || USB_NO_ERROR != dwUsbErr) {
            DEBUGMSG( ZONE_ERR, (TEXT("IssueVendorTransfer ERROR:%d 0x%x\n"), dwErr, dwUsbErr));
            //IoErrorHandler( pUsbCam, NULL, 0, dwUsbErr);
        }
    }

    DEBUGMSG( ZONE_USB_CONTROL, (TEXT("<GetPortStatus:0x%x\n"), usStatus));

    return;
}


static void spca5xxRegWrite(USBCAM_CONTEXT *pUsbCam,
			    U16 reg,
			    U16 value,
			    U16 index, U8 * buffer, U16 length)
{
     USB_DEVICE_REQUEST ControlHeader;
    DWORD  dwBytesTransferred = 0;
    DWORD  dwUsbErr = USB_NO_ERROR;
    DWORD  dwErr = ERROR_SUCCESS;
    USHORT usStatus = 0;
    BOOL bRc = TRUE;

    DEBUGMSG( ZONE_USB_CONTROL, (TEXT(">spca5xxRegWrite\n")));

    if ( !VALID_CONTEXT( pUsbCam) ) {
        DEBUGMSG( ZONE_ERR, (TEXT("Invalid parameter\n")));
        bRc = FALSE;
   } else {

        ControlHeader.bmRequestType = USB_REQUEST_HOST_TO_DEVICE | USB_REQUEST_CLASS | USB_REQUEST_FOR_OTHER;
        ControlHeader.bRequest = reg;
        ControlHeader.wValue   = value;
        ControlHeader.wIndex   = index;
        ControlHeader.wLength  = 0;

        dwErr = IssueVendorTransfer( pUsbCam->UsbFuncs,
                                     pUsbCam->hUsbDevice,
                                     DefaultTransferComplete,
                                     pUsbCam->hEP0Event,
                                     (USB_OUT_TRANSFER | USB_SHORT_TRANSFER_OK),
                                     &ControlHeader,
                                     buffer, length,
                                     &dwBytesTransferred,
                                     pUsbCam->UsbTimeouts.SoftResetTimeout,
                                     &dwUsbErr );

        if ( ERROR_SUCCESS != dwErr || USB_NO_ERROR != dwUsbErr) {
            DEBUGMSG( ZONE_ERR, (TEXT("IssueVendorTransfer ERROR:%d 0x%x\n"), dwErr, dwUsbErr));
            //IoErrorHandler( pUsbCam, NULL, 0, dwUsbErr);
        }
    }

    DEBUGMSG( ZONE_USB_CONTROL, (TEXT("<SoftReset:%d\n"), bRc));

     return;
}

static U16 zcxx_i2cRead(USBCAM_CONTEXT *dev, U8 reg)
{
    U8 retbyte = 0;
    U8 retval[] = { 0, 0 };

    spca5xxRegWrite(dev, 0xa0, reg, 0x92, NULL, 0);
    spca5xxRegWrite(dev, 0xa0, 0x02, 0x90, NULL, 0);	// <-read command
    spca5xxRegRead(dev, 0xa1, 0x01, 0x0091, &retbyte, 1);	// read status
    spca5xxRegRead(dev, 0xa1, 0x01, 0x0095, &retval[0], 1);	// read Lowbyte
    spca5xxRegRead(dev, 0xa1, 0x01, 0x0096, &retval[1], 1);	// read Hightbyte
    return ((retval[1] << 8) | retval[0]);
}
static U8 zcxx_i2cWrite(USBCAM_CONTEXT *dev, U8 reg, U8 valL,
			  U8 valH)
{
    U8 retbyte = 0;
    spca5xxRegWrite(dev, 0xa0, reg, 0x92, NULL, 0);
    spca5xxRegWrite(dev, 0xa0, valL, 0x93, NULL, 0);
    spca5xxRegWrite(dev, 0xa0, valH, 0x94, NULL, 0);
    spca5xxRegWrite(dev, 0xa0, 0x01, 0x90, NULL, 0);	// <-write command
    spca5xxRegRead(dev, 0xa1, 0x01, 0x0091, &retbyte, 1);	// read status
    return (retbyte);
}
static int zcxx_probeSensor(USBCAM_CONTEXT*spca50x)
{
    int i, j;
    U8 retbyte = 0;
    U16 checkword = 0;
   U16 checkid = 0xffff;
/* check i2c */
/* check SIF */
    for (i = 0; i < SIFTOT; i++) {
        checkword = 0;
	spca5xxRegWrite(spca50x, 0xa0, 0x01, 0x0000, NULL, 0);
	spca5xxRegWrite(spca50x, 0xa0, zcxxi2cSensorSIF[i][SensorId],
			0x0010, NULL, 0);
	spca5xxRegWrite(spca50x, 0xa0, 0x01, 0x0001, NULL, 0);
	spca5xxRegWrite(spca50x, 0xa0, 0x03, 0x0012, NULL, 0);
	spca5xxRegWrite(spca50x, 0xa0, 0x01, 0x0012, NULL, 0);
	Sleep(1);
	if (zcxxi2cSensorSIF[i][reg8d] == 0x8d){
	    spca5xxRegWrite(spca50x, 0xa0, zcxxi2cSensorSIF[i][val8d],
			    0x008d, NULL, 0);
	Sleep(15);
	checkword = ((zcxx_i2cRead(spca50x,0x00) & 0x0f) << 4) 
	               | ((zcxx_i2cRead(spca50x,0x01) & 0xf0) >> 4 );
	
	    if (checkword == 0x07){
	        spca5xxRegWrite(spca50x, 0xa0, 0x01, 0x0000, NULL, 0);
		spca5xxRegWrite(spca50x, 0xa0, 0x03, 0x003a, NULL, 0);
		spca5xxRegWrite(spca50x, 0xa0, 0x0c, 0x003b, NULL, 0);
		spca5xxRegWrite(spca50x, 0xa0, 0x08, 0x0038, NULL, 0);
	    return zcxxi2cSensorSIF[i][SensorId];
	    } 	    
	}
	retbyte =
	    zcxx_i2cWrite(spca50x, zcxxi2cSensorSIF[i][SensorReg1],
			  zcxxi2cSensorSIF[i][valSreg1L],
			  zcxxi2cSensorSIF[i][valSreg1H]);
	Sleep(1);
	retbyte =
	    (zcxx_i2cRead(spca50x, zcxxi2cSensorSIF[i][SensorReg1])) &
	    0xff;
	Sleep(1);
	RETAILMSG(1, (TEXT("sensor answer1  %d "), retbyte));
	if (retbyte != zcxxi2cSensorSIF[i][valSreg1L])
	    continue;
	if (zcxxi2cSensorSIF[i][SensorReg2] != 0xff) {
	    retbyte =
		zcxx_i2cWrite(spca50x,
			      zcxxi2cSensorSIF[i][SensorReg2],
			      zcxxi2cSensorSIF[i][valSreg2L],
			      zcxxi2cSensorSIF[i][valSreg2H]);
	    retbyte =
		(zcxx_i2cRead
		 (spca50x, zcxxi2cSensorSIF[i][SensorReg2])) & 0xff;
	    RETAILMSG(1, (TEXT("sensor answer2  %d "), retbyte));
	    if (retbyte == zcxxi2cSensorSIF[i][valSreg2L])
		return zcxxi2cSensorSIF[i][SensorId];
	}
    }
/* check VGA */
    for (i = 0; i < VGATOT; i++) {
	if ((zcxxi2cSensor[i][reg8d] == 0x8b)
	    && (zcxxi2cSensor[i][val8d] == 0xa1)) {
	    /* code for stephane sensor ov7630c */
	    checkword = 0;
	    spca5xxRegWrite(spca50x, 0xa0, 0x01, 0x0000, NULL, 0);
	    spca5xxRegWrite(spca50x, 0xa0, 0x01, 0x0001, NULL, 0);
	    spca5xxRegWrite(spca50x, 0xa0, zcxxi2cSensor[i][SensorId],
			    0x0010, NULL, 0);
	    spca5xxRegWrite(spca50x, 0xa0, zcxxi2cSensor[i][val8d],
			    0x008b, NULL, 0);
	    spca5xxRegWrite(spca50x, 0xa0, 0x08, 0x008d, NULL, 0);
	    Sleep(15);
	    spca5xxRegWrite(spca50x, 0xa0, 0x01, 0x0012, NULL, 0);
	    retbyte =
		zcxx_i2cWrite(spca50x, zcxxi2cSensor[i][SensorReg1],
			      zcxxi2cSensor[i][valSreg1L],
			      zcxxi2cSensor[i][valSreg1H]);

	    retbyte =
		(zcxx_i2cRead(spca50x, zcxxi2cSensor[i][SensorReg2]))
		& 0xff;
	    checkword = retbyte << 8;
	    checkword |= ((zcxx_i2cRead(spca50x, 0x0b)) & 0xff);
	    if (checkword == 0x7631) {
		RETAILMSG(0, (TEXT("sensor answervga  0x%04X "), checkword));
		spca5xxRegWrite(spca50x, 0xa0,
				zcxxi2cSensor[i][SensorId], 0x0010, NULL,
				0);
		return zcxxi2cSensor[i][SensorId];
	    }
	    continue;
	}
	spca5xxRegWrite(spca50x, 0xa0, 0x01, 0x0000, NULL, 0);
	spca5xxRegWrite(spca50x, 0xa0, zcxxi2cSensor[i][SensorId],
			0x0010, NULL, 0);
	spca5xxRegWrite(spca50x, 0xa0, 0x01, 0x0001, NULL, 0);
	spca5xxRegWrite(spca50x, 0xa0, 0x03, 0x0012, NULL, 0);
	spca5xxRegWrite(spca50x, 0xa0, 0x01, 0x0012, NULL, 0);
	Sleep(1);
	if (zcxxi2cSensor[i][reg8d] == 0x8d)
	    spca5xxRegWrite(spca50x, 0xa0, zcxxi2cSensor[i][val8d],
			    0x008d, NULL, 0);
	retbyte =
	    zcxx_i2cWrite(spca50x, zcxxi2cSensor[i][SensorReg1],
			  zcxxi2cSensor[i][valSreg1L],
			  zcxxi2cSensor[i][valSreg1H]);
	if (zcxxi2cSensor[i][SensorReg2] != 0xff) {
	    retbyte =
		zcxx_i2cWrite(spca50x, zcxxi2cSensor[i][SensorReg2],
			      zcxxi2cSensor[i][valSreg2L],
			      zcxxi2cSensor[i][valSreg2H]);