qci.c

wince 6.0 摄像头(ov7670)驱动,已在ce6测试通过

    PXA_CIClearInterruptStatus(g_pCIRegs, 0xFFFFFFFF);

    PXA_CIDisableComplete(g_pCIRegs);

    if (cgu_enable)
        if (LutLoad())
        PXA_CICGUEnable(g_pCIRegs, TRUE);

    DMALoad();

    //QCI Enable
    PXA_CISetFIFO(g_pCIRegs, 0, PXA_CI_FIFO_THL_32, TRUE, TRUE);
    PXA_CIEnable(g_pCIRegs);
    
    still_skips = in_still_skips;
    PXA_CISetInterruptMask(g_pCIRegs, PXA_CI_CICR0_INTERRUPT_MASK & (~PXA_CI_INT_EOF));
    
}


void QCICaptureStop()

{
    PXA_CISetInterruptMask(g_pCIRegs, PXA_CI_CICR0_INTERRUPT_MASK);
    //qci_disable();
    PXA_CIDisable(g_pCIRegs, /*ost_reg, */TRUE, TRUE);
    PXA_CIResetFIFO(g_pCIRegs);
}


BOOL QCIAddCallBack(callback_data_t* callback_data)
{
    ULONG index = callback_data->mode;

    if (index >= MAX_CALLBACK_NUM)
        return FALSE;

    callbacks[index].callback = callback_data->callback;
    callbacks[index].user = callback_data->user;
    callbacks[index].frame = callback_data->frame;
    return TRUE;
}

void QciCallBack(frame_t* frame)
{
    int i;

    for (i = 0; i < MAX_CALLBACK_NUM; i++)
    {
        if (callbacks[i].callback == NULL)
            continue;

        __try
        {
            *(callbacks[i].frame) = frame;
            callbacks[i].callback(callbacks[i].user, i);
        }
        __except( EXCEPTION_EXECUTE_HANDLER )
        {
            DEBUGMSG(ZONE_ERROR,(TEXT("CAM: Qcibus.DLL : frame %x callback exception\r\n"), frame));
        }
    }
}

#ifdef DEBUG
void QciDumpRegs()
{



    
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CICR0 0x%08x\r\n",g_pCIRegs->PXA_CICR0));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CICR1 0x%08x\r\n",g_pCIRegs->PXA_CICR1));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CICR2 0x%08x\r\n",g_pCIRegs->PXA_CICR2));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CICR3 0x%08x\r\n",g_pCIRegs->PXA_CICR3));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CICR4 0x%08x\r\n",g_pCIRegs->PXA_CICR4));
    
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CISR 0x%08x\r\n",g_pCIRegs->PXA_CISR));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CITOR 0x%08x\r\n",g_pCIRegs->PXA_CITOR));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CIBR0 0x%08x\r\n",g_pCIRegs->PXA_CIBR0));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CIBR1 0x%08x\r\n",g_pCIRegs->PXA_CIBR1));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CIBR2 0x%08x\r\n",g_pCIRegs->PXA_CIBR2));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CIBR3 0x%08x\r\n",g_pCIRegs->PXA_CIBR3));
    
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CIFR0 0x%08x\r\n",g_pCIRegs->PXA_CIFR0));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CIFR1 0x%08x\r\n",g_pCIRegs->PXA_CIFR1));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CIFSR 0x%08x\r\n",g_pCIRegs->PXA_CIFSR));
    
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CIDCSR0 0x%08x\r\n",g_pCIRegs->PXA_CIDCSR0));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CIDCSR1 0x%08x\r\n",g_pCIRegs->PXA_CIDCSR1));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CIDCSR2 0x%08x\r\n",g_pCIRegs->PXA_CIDCSR2));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CIDCSR3 0x%08x\r\n",g_pCIRegs->PXA_CIDCSR3));
    
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CIDBR0 0x%08x\r\n",g_pCIRegs->PXA_CIDBR0));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CIDBR1 0x%08x\r\n",g_pCIRegs->PXA_CIDBR1));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CIDBR2 0x%08x\r\n",g_pCIRegs->PXA_CIDBR2));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CIDBR3 0x%08x\r\n",g_pCIRegs->PXA_CIDBR3));
    
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CIDADR0 0x%08x\r\n",g_pCIRegs->PXA_CIDADR0));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CITADR0 0x%08x\r\n",g_pCIRegs->PXA_CITADR0));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CISADR0 0x%08x\r\n",g_pCIRegs->PXA_CISADR0));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CICMD0 0x%08x\r\n",g_pCIRegs->PXA_CICMD0));
    
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CIDADR1 0x%08x\r\n",g_pCIRegs->PXA_CIDADR1));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CITADR1 0x%08x\r\n",g_pCIRegs->PXA_CITADR1));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CISADR1 0x%08x\r\n",g_pCIRegs->PXA_CISADR1));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CICMD1 0x%08x\r\n",g_pCIRegs->PXA_CICMD1));
    
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CIDADR2 0x%08x\r\n",g_pCIRegs->PXA_CIDADR2));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CITADR2 0x%08x\r\n",g_pCIRegs->PXA_CITADR2));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CISADR2 0x%08x\r\n",g_pCIRegs->PXA_CISADR2));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CICMD2 0x%08x\r\n",g_pCIRegs->PXA_CICMD2));
    
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CIDADR3 0x%08x\r\n",g_pCIRegs->PXA_CIDADR3));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CITADR3 0x%08x\r\n",g_pCIRegs->PXA_CITADR3));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CISADR3 0x%08x\r\n",g_pCIRegs->PXA_CISADR3));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CICMD3 0x%08x\r\n",g_pCIRegs->PXA_CICMD3));
    
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CICMR 0x%08x\r\n",g_pCIRegs->PXA_CICMR));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CICMC0 0x%08x\r\n",g_pCIRegs->PXA_CICMC0));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CICMC1 0x%08x\r\n",g_pCIRegs->PXA_CICMC1));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CICMC2 0x%08x\r\n",g_pCIRegs->PXA_CICMC2));
    DEBUGMSG(ZONE_IOCTL,(L"PXA_CICCR 0x%08x\r\n",g_pCIRegs->PXA_CICCR));

}
#endif


#if 0
void histogram_lut_init()
{
    UINT size;
    dma_buf_t *buf = &histogram_lut_buf;

    size = HISTOGRAM_LUT_BUF_SIZE + sizeof(PXA_CI_DMAC_DESCRIPTOR_T);
    dma_buf_alloc(buf, size, 0);
    histogram_lut_desc = (int*)(buf->buf + HISTOGRAM_LUT_BUF_SIZE);
    histogram_lut_desc_phy = buf->phy_addr + HISTOGRAM_LUT_BUF_SIZE;
}


void histogram_lut_deinit()
{
    dma_buf_free(&histogram_lut_buf);
}


BOOL lut_load()
{
    PXA_STATUS_T status;

    if (lut)
    {
    
        status = PXA_CICGULoadLutRam(ci_reg, 
                                   ost_reg, 
                                   (UINT*)histogram_lut_buf.buf,
                                   histogram_lut_buf.phy_addr,
                                   (UINT*)histogram_lut_desc,
                                   histogram_lut_desc_phy,
                                   lut);

        return status == PXA_STATUS_SUCCESS;
    }

    return FALSE;
}


BOOL get_histogram(int in_format, PXA_CI_HSU_COLOR_TYPE color, UINT *size, UINT *sum)
{
    PXA_CI_HSU_MUX_SEL_TYPE mux_select;

    switch (in_format)
    {
    case PXA_CAMERA_IMAGE_FORMAT_RAW10:
        mux_select = PXA_CI_HSU_MUX_1_TO_9;
        break;
    case PXA_CAMERA_IMAGE_FORMAT_RAW9:
        mux_select = PXA_CI_HSU_MUX_0_TO_8;
        break;
    default:
        mux_select = PXA_CI_HSU_MUX_0_TO_7;
    }

    *size = (mux_select == PXA_CI_HSU_MUX_0_TO_7)? 512 : 1024;

    return PXA_CIHSUGetHistgram(ci_reg,
                                ost_reg,
                                color,
                                mux_select,
                                (UINT*)histogram_lut_buf.buf,
                                histogram_lut_buf.phy_addr,
                                (UINT*)histogram_lut_desc,
                                histogram_lut_desc_phy,
                                *size,
                                sum);
                                
}

#endif

static UCHAR default_lut[] = {
    // RED LUT
    0x00, 0x04, 0x08, 0x0c, 0x10, 0x14, 0x18, 0x1c,
    0x20, 0x24, 0x28, 0x2c, 0x30, 0x34, 0x38, 0x3c,
    0x40, 0x44, 0x48, 0x4c, 0x50, 0x54, 0x58, 0x5c,
    0x60, 0x64, 0x68, 0x6c, 0x70, 0x74, 0x78, 0x7c,
    0x80, 0x84, 0x88, 0x8c, 0x90, 0x94, 0x98, 0x9c,
    0xa0, 0xa4, 0xa8, 0xac, 0xb0, 0xb4, 0xb8, 0xbc,
    0xc0, 0xc4, 0xc8, 0xcc, 0xd0, 0xd4, 0xd8, 0xdc,
    0xe0, 0xe4, 0xe8, 0xec, 0xf0, 0xf4, 0xf8, 0xfc,

    // BLUE LUT
    0x00, 0x04, 0x08, 0x0c, 0x10, 0x14, 0x18, 0x1c,
    0x20, 0x24, 0x28, 0x2c, 0x30, 0x34, 0x38, 0x3c,
    0x40, 0x44, 0x48, 0x4c, 0x50, 0x54, 0x58, 0x5c,
    0x60, 0x64, 0x68, 0x6c, 0x70, 0x74, 0x78, 0x7c,
    0x80, 0x84, 0x88, 0x8c, 0x90, 0x94, 0x98, 0x9c,
    0xa0, 0xa4, 0xa8, 0xac, 0xb0, 0xb4, 0xb8, 0xbc,
    0xc0, 0xc4, 0xc8, 0xcc, 0xd0, 0xd4, 0xd8, 0xdc,
    0xe0, 0xe4, 0xe8, 0xec, 0xf0, 0xf4, 0xf8, 0xfc,

    // GREEN LUT
    0x00, 0x04, 0x08, 0x0c, 0x10, 0x14, 0x18, 0x1c,
    0x20, 0x24, 0x28, 0x2c, 0x30, 0x34, 0x38, 0x3c,
    0x40, 0x44, 0x48, 0x4c, 0x50, 0x54, 0x58, 0x5c,
    0x60, 0x64, 0x68, 0x6c, 0x70, 0x74, 0x78, 0x7c,
    0x80, 0x84, 0x88, 0x8c, 0x90, 0x94, 0x98, 0x9c,
    0xa0, 0xa4, 0xa8, 0xac, 0xb0, 0xb4, 0xb8, 0xbc,
    0xc0, 0xc4, 0xc8, 0xcc, 0xd0, 0xd4, 0xd8, 0xdc,
    0xe0, 0xe4, 0xe8, 0xec, 0xf0, 0xf4, 0xf8, 0xfc,
};

PXA_CI_CMU_COE_MATRIX default_coe = 
{
    YUV_FLOAT_TO_INT(0.299), YUV_FLOAT_TO_INT(0.587), YUV_FLOAT_TO_INT(0.114),
    YUV_FLOAT_TO_INT(0.5), YUV_FLOAT_TO_INT(-0.41869), YUV_FLOAT_TO_INT(-0.08131),
    YUV_FLOAT_TO_INT(-0.16874), YUV_FLOAT_TO_INT(-0.33126), YUV_FLOAT_TO_INT(0.5)
};

// set the black level, color correction and gama correction
// if no configuration specified, default values will be used


void QCIImageProcCfg(qci_image_proc_cfg_t* cfg)
{
    UINT32 black_level = 0;
    PXA_CI_CMU_COE_MATRIX* coe = &default_coe;

    lut = default_lut;

    if (cfg)
    {
        cgu_enable = 1;

        black_level = cfg->black_level;
        coe = &cfg->coe;
        if (cfg->lut)
            lut = cfg->lut;
    }

    PXA_CICGUSetBlackLevel(g_pCIRegs, black_level);
    PXA_CICMUSetColorCorrectionCoe(g_pCIRegs, coe);
}