usbcam.c

Windows CE下USB驱动（OV511）

            bRc = FALSE;
            break;
        }
    }
    
    return bRc;
}

BOOL
OV518IICWrite(PDRVCONTEXT pDrv,
              BYTE reg,
              BYTE value)
{
    BOOL bRc;

    DEBUGMSG(1, (TEXT("OV511 Write IIC 0x%2X:0x%2X\r\n"), reg, value));

	/* Select camera register */
	bRc = RegisterWrite(pDrv, R51x_I2C_SADDR_3, reg);
	if (bRc == FALSE)
		return bRc;

	/* Write "value" to I2C data port of OV511 */
	bRc = RegisterWrite(pDrv, R51x_I2C_DATA, value);
	if (bRc == FALSE)
		return bRc;

	/* Initiate 3-byte write cycle */
	bRc = RegisterWrite(pDrv, R518_I2C_CTL, 0x01);
	if (bRc == FALSE)
		return bRc;

	return bRc;
}

BOOL
OV511IICRead(PDRVCONTEXT pDrv, 
             BYTE reg, 
             BYTE *value)
{
    DWORD retries;
    BOOL bRc = FALSE;
    BYTE tmp;

    /* Two byte write cycle */
    retries = OV511IICREADETRIES;
    while(1) {
        /* Select camera register */
        bRc = RegisterWrite(pDrv, R51x_I2C_SADDR_2, reg);
        if (bRc == FALSE)
            return bRc;
        
        /* Initiate 2-byte write cycle */
        bRc = RegisterWrite(pDrv, R511_I2C_CTL, 0x03);
        if (bRc == FALSE)
            return bRc;
        
        /* Retry until idle */
        do
        {
            bRc = RegisterRead(pDrv, R511_I2C_CTL, &tmp);
        }while ((bRc == TRUE) && (tmp & 1) == 0);
        
        if ((tmp & 2) == 0) /* Ack? */
            break;
        
        /* I2C abort */
        RegisterWrite(pDrv, R511_I2C_CTL, 0x10);
        
        if (--retries < 0) {
            bRc = FALSE;
            DEBUGMSG(1, (TEXT("IIC write retries exhausted\r\n")));
            return bRc;
        }
    }
    
    /* Two byte read cycle */
    retries = OV511IICREADETRIES;
    while (1) {
        /* Initiate 2-byte read cycle */
        bRc = RegisterWrite(pDrv, R511_I2C_CTL, 0x05);
        if (bRc == FALSE)
            return bRc;
        
        /* Retry until idle */
        do
        {
            bRc = RegisterRead(pDrv, R511_I2C_CTL, &tmp);
        }while ((bRc == TRUE) && (tmp & 1) == 0);
        
        if ((tmp & 2) == 0) /* Ack? */
            break;
        
        /* I2C abort */
        bRc = RegisterWrite(pDrv, R511_I2C_CTL, 0x10);
        if (bRc == FALSE)
            return bRc;
        
        if (--retries < 0) {
            DEBUGMSG(1, (TEXT("IIC read retries exhausted\r\n")));
            return -1;
        }
    }
    
    bRc = RegisterRead(pDrv, R51x_I2C_DATA, &tmp);
    
    DEBUGMSG(1,(TEXT("0x%02X:0x%02X\r\n"), reg, tmp));
    
    /* This is needed to make OV511IICWrite() work */
    bRc = RegisterWrite(pDrv, R511_I2C_CTL, 0x05);
    if (bRc == FALSE)
        return bRc;
    
    *value = tmp;

    return bRc;
}

BOOL
OV518IICRead(PDRVCONTEXT pDrv, 
             BYTE reg, 
             BYTE *value)
{
    BOOL bRc;
    BYTE tmp;

	/* Select camera register */
	bRc = RegisterWrite(pDrv, R51x_I2C_SADDR_2, reg);
	if (bRc == FALSE)
		return bRc;

	/* Initiate 2-byte write cycle */
	bRc = RegisterWrite(pDrv, R518_I2C_CTL, 0x03);
	if (bRc == FALSE)
		return bRc;

	/* Initiate 2-byte read cycle */
	bRc = RegisterWrite(pDrv, R518_I2C_CTL, 0x05);
	if (bRc == FALSE)
		return bRc;

	bRc = RegisterRead(pDrv, R51x_I2C_DATA, &tmp);
    if(bRc == FALSE)
        return bRc;

    *value = tmp;

	return bRc;
}

BOOL
OV511IICWriteMask(PDRVCONTEXT pDrv,
                  BYTE reg,
                  BYTE value,
                  BYTE mask)
{
    BOOL bRc;
    BYTE oldval, newval, tmp;
    
    if (mask == 0xff) {
        newval = value;
    } 
    else 
    {
        bRc = OV511IICRead(pDrv, reg, &tmp);
        
        if (bRc == FALSE)
            return bRc;
        
        oldval = tmp;
        oldval &= (~mask);		/* Clear the masked bits */
        value &= mask;			/* Enforce mask on value */
        newval = oldval | value;	/* Set the desired bits */
    }
    bRc = OV511IICWrite(pDrv, reg, newval);
    return bRc;
}

BOOL
OV518IICWriteMask(PDRVCONTEXT pDrv,
                  BYTE reg,
                  BYTE value,
                  BYTE mask)
{
    BOOL bRc;
    BYTE oldval, newval, tmp;
    
    if (mask == 0xff) {
        newval = value;
    } 
    else 
    {
        bRc = OV518IICRead(pDrv, reg, &tmp);
        
        if (bRc == FALSE)
            return bRc;
        
        oldval = tmp;
        oldval &= (~mask);		/* Clear the masked bits */
        value &= mask;			/* Enforce mask on value */
        newval = oldval | value;	/* Set the desired bits */
    }
    bRc = OV518IICWrite(pDrv, reg, newval);
    return bRc;
}


BOOL 
IICRead(    PDRVCONTEXT pDrv, 
            BYTE reg, 
            BYTE *value)
{
    BOOL bRc;

	if (ov.bclass == BCL_OV518)
		bRc = OV518IICRead(pDrv, reg, value);
	else
		bRc = OV511IICRead(pDrv, reg, value);

	return bRc;
}

BOOL
IICWrite(   PDRVCONTEXT pDrv, 
            BYTE reg, 
            BYTE value)
{
	BOOL bRc;

    if (ov.bclass == BCL_OV518)
		bRc = OV518IICWrite(pDrv, reg, value);
	else
		bRc = OV511IICWrite(pDrv, reg, value);

    return bRc;
}

BOOL
IICWriteMask(   PDRVCONTEXT pDrv,
                BYTE reg,
                BYTE value,
                BYTE mask)
{
    BOOL bRc;

    if (ov.bclass == BCL_OV518)
		bRc = OV518IICWriteMask(pDrv, reg, value, mask);
	else
		bRc = OV511IICWriteMask(pDrv, reg, value, mask);

    return bRc;
}

BOOL
WriteRegisters( PDRVCONTEXT pDrv, 
                POV511REGVALS *pRegvals)
{
    BOOL bRc;
    
    while (pRegvals->bus != OV511_DONE_BUS) {
        switch(pRegvals->bus)
        {
        case OV511_REG_BUS:
            bRc = RegisterWrite(pDrv, pRegvals->reg, pRegvals->val);
            if(bRc == FALSE)
            {
                return bRc;
            }
            break;
        case OV511_I2C_BUS:
            bRc = OV511IICWrite(pDrv, pRegvals->reg, pRegvals->val);
            if(bRc == FALSE)
            {
                return bRc;
            }
            break;
        case OV511_DONE_BUS:
            break;
            
        default:
            DEBUGMSG(1, (TEXT("Error Reg bus!\r\n")));
            break;
        }	
        pRegvals++;
    }
    return bRc;
}

void OV51XLedControl(PDRVCONTEXT pDrv, 
                     BOOL enable)
{
    DEBUGMSG(1, (TEXT("OV511 Led %s\r\n"), enable ? "turn on" : "turn off"));
    
    if (ov.bridge == BRG_OV511PLUS)
        RegisterWrite(pDrv, R511_SYS_LED_CTL, enable ? 1 : 0);
    else if (ov.bclass == BCL_OV518)
        RegWriteMask(pDrv, R518_GPIO_OUT, enable ? 0x02 : 0x00, 0x02);
    
    return;
}

BOOL    
OV511UploadQuanTables(PDRVCONTEXT pDrv)
{
    BYTE *pYTable = yQuanTable511;
    BYTE *pUVTable = uvQuanTable511;
    BYTE val0, val1;
    BYTE reg = R511_COMP_LUT_BEGIN;
    int i;
    BOOL bRc;
    DEBUGMSG(1, (TEXT("Uploading quantization tables\r\n")));
    
    for (i = 0; i < OV511_QUANTABLESIZE / 2; i++) {
        if (ENABLE_Y_QUANTABLE)	{
            val0 = *pYTable++;
            val1 = *pYTable++;
            val0 &= 0x0f;
            val1 &= 0x0f;
            val0 |= val1 << 4;
            bRc = RegisterWrite(pDrv, reg, val0);
            if (bRc == FALSE)
                return bRc;
        }
        
        if (ENABLE_UV_QUANTABLE) {
            val0 = *pUVTable++;
            val1 = *pUVTable++;
            val0 &= 0x0f;
            val1 &= 0x0f;
            val0 |= val1 << 4;
            bRc = RegisterWrite(pDrv, reg + OV511_QUANTABLESIZE/2, val0);
            if (bRc == FALSE)
                return bRc;
        }
        
        reg++;
    }
    
    return bRc;
}

BOOL
OV511InitCompression(PDRVCONTEXT pDrv)
{
    BOOL bRc = FALSE;
    
    bRc = RegisterWrite(pDrv, 0x70, phy);
    if(bRc == FALSE)
        return bRc;
    bRc = RegisterWrite(pDrv, 0x71, phuv);
    if(bRc == FALSE)
        return bRc;
    bRc = RegisterWrite(pDrv, 0x72, pvy);
    if(bRc == FALSE)
        return bRc;
    bRc = RegisterWrite(pDrv, 0x73, pvuv);
    if(bRc == FALSE)
        return bRc;
    bRc = RegisterWrite(pDrv, 0x74, qhy);
    if(bRc == FALSE)
        return bRc;
    bRc = RegisterWrite(pDrv, 0x75, qhuv);
    if(bRc == FALSE)
        return bRc;
    bRc = RegisterWrite(pDrv, 0x76, qvy);
    if(bRc == FALSE)
        return bRc;
    bRc = RegisterWrite(pDrv, 0x77, qvuv);
    if(bRc == FALSE)
        return bRc;
    bRc = OV511UploadQuanTables(pDrv);
    if (bRc == FALSE) {
        DEBUGMSG(1, (TEXT("Error uploading quantization tables\r\n")));
        return bRc;
    }
    
    return bRc;
}

BOOL
IICSetSlaveInternal(PDRVCONTEXT pDrv, 
                    BYTE slave)
{
    BOOL bRc;
    
    bRc = RegisterWrite(pDrv, R51x_I2C_W_SID, slave);
    if (bRc == FALSE)
        return bRc;
    
    bRc = RegisterWrite(pDrv, R51x_I2C_R_SID, slave + 1);
    if (bRc == FALSE)
        return bRc;
    
    return bRc;
}

BOOL
OV511SetSlaveIds(PDRVCONTEXT pDrv, 
                 BYTE sid)
{
    BOOL bRc;
    
    bRc = IICSetSlaveInternal(pDrv, sid);
    if (bRc == FALSE)
        return bRc;
    
    // FIXME: Is this actually necessary?
    bRc = OV511Reset(pDrv, OV511_RESET_NOREGS);
    
    return bRc;
}

BOOL
OV511Reset(PDRVCONTEXT pDrv, 
           BYTE reset_type)
{
    BOOL bRc;
    
    /* Setting bit 0 not allowed on 518/518Plus */
    if (ov.bclass == BCL_OV518)
        reset_type &= 0xfe;
    
    DEBUGMSG(1, (TEXT("Reset OV511: type=0x%02X\r\n"), reset_type));
    
    bRc = RegisterWrite(pDrv, R51x_SYS_RESET, reset_type);
    bRc = RegisterWrite(pDrv, R51x_SYS_RESET, 0);
    
    if (bRc == FALSE)