dtv_ttr_audio.c

用于TM1300/PNX1300系列DSP（主要用于视频处理）的设备库的源码

   bit 4    lock/unlock     input
   bit 5    48.0 kHz        input
   bit 6    44.1 kHz        input
   bit 7    32.0 kHz        input
*/

/* L3 IIC expander:
   address: 0x74
   bit 0  Dout L3 mode
   bit 1  Dout L3 clock
   bit 2  Dout L3 data
   bit 3  Dout L3 strobe
   bit 4  Din L3 mode
   bit 5  Din L3 clock
   bit 6  Din L3 data
   bit 7  Din L3 strobe
*/

/* function called in aiInstanceSetup():  On success, must leave
 * the audio input system "stopped" but otherwise ready for action.
 * MMIO setup will be done, as well as other board or codec specific 
 * actions like setting IIC control bits or initializing codec registers.
 */
extern tmLibdevErr_t dtv_ttr_AI_Init(boardAIParam_t * param)
{
    UInt                iicd;
    Float               val;
    pprocCapabilities_t procCap;
    Int                 err = TMLIBDEV_OK;

    /* get the clock frequency of the TriMedia CPU */       
    err = procGetCapabilities(&procCap);
    if (err) return err;
    dtvTtrCPUClock = (Float) procCap->cpuClockFrequency;

    if (procCap->deviceID == PROC_DEVICE_TM1100)
    {
        dtvTtrCPUisTM1100 = True;
    }
    
    /* set strobe to zero */
    err  = iicReadReg(TTR_L3_IIC_EXPANDER_ADDRESS, -1, &iicd);
    iicd &= ~(TTR_INPUT_L3_STROBE);
    err |= iicWriteReg(TTR_L3_IIC_EXPANDER_ADDRESS, -1, iicd);
    if (err) return err;
    

    aiRESET();
 
    /* clock freq is in hz.  Math is 32 bit- should be 64 bit!
       In the digital input mode the clock is only needed to use the L3 interface.
       In this case is the TriMedia clock slave.
       In the analog input mode the clocks are needed because the CS5331 is clock 
       slave. */
       
    val = param->sRate * 256; /* 256 * sampleRate */
    if (dtvTtrCPUisTM1100)
    {
        val = 0.5 + (477218588.0 * (val / dtvTtrCPUClock));    /* 2**32 / 9 */
        aiSetFREQ(((UInt) val) | 0x80000000);
    }
    else
    {
        val = 0.5 + (1431655765.0 * (val / dtvTtrCPUClock));    /* 2**32 / 3 */
        aiSetFREQ((UInt) val);
    }
    
    if (param->input == aaaNone) 
    {
        param->input = aaaDigitalInput; /* digital input is the default */
    }
    
    switch (param->input)
    {
    case aaaDigitalInput:   /* use TDA 1315 */
        /* set a small value for the input DDS frequency to disable the CS5331 */
        aiSetFREQ((UInt) (val / 10));
        /* set powerdown for input TDA1315 to zero (normal operation) */
        err = iicReadReg(TTR_INPUT_IIC_EXPANDER_ADDRESS, -1, &iicd);
        tmAssert(err == TMLIBDEV_OK, err);
        iicd &= ~(TTR_TDA1315_IN_IIC_POWERDOWN);
        err = iicWriteReg(TTR_INPUT_IIC_EXPANDER_ADDRESS, -1, iicd);
        tmAssert(err == TMLIBDEV_OK, err);
        microsleep(1000);

        /* initalize the tda1315 */
        inputL3Params.data = &inputL3Regs[0];
        err = tda1315InitInput(&inputL3Params, param);

        aiDisableSER_MASTER();  /* tda1315 is master of clock */
        microsleep(10);         /* wait until internal state of audio in unit is stable */
        
        if (err == TMLIBDEV_OK)
        {    
            aiSetCAP_MODE(3);               /* Stereo 16 bits per sample */
            aiDisableSIGN_CONVERT();
            aiMsbFirst();                   /* MSB first */
            aiSetFRAMEMODE(0);              /* ignore valid bit */
            aiSampleRisingCLOCK_EDGE();     /* sample on rising edge */
            aiStartFallingEdgeWS();
            aiSetSSPOS(0);    
            aiSetLEFTPOS(0);            
            aiSetRIGHTPOS(32);
            aiSetSIZE(param->size);

#ifdef __LITTLE_ENDIAN__
            aiEnableLITTLE_ENDIAN();
#else
            aiDisableLITTLE_ENDIAN();
#endif
        }
        else return err;
        
        dtvTtrAiInput = aaaDigitalInput;
        break;
    default:
        err = AIO_ERR_UNSUPPORTED_INPUT;
        break;
    }

    /* store parameters */
    dtvTtrAiAudioTypeFormat      = param->audioTypeFormat;       
    dtvTtrAiAudioSubtypeFormat   = param->audioSubtypeFormat;
    dtvTtrAiSRate                = param->sRate;
    dtvTtrAiSize                 = param->size;
    
    return err;

}

/* called in aiClose().  Should leave audio input system shut down */
extern tmLibdevErr_t dtv_ttr_AI_Term(void)
{
    return TMLIBDEV_OK;
}

/* called in aiStart(). */
extern tmLibdevErr_t dtv_ttr_AI_Start(void)
{
    aiEnableCAP_ENABLE();
    
    return TMLIBDEV_OK;
}

/* called in aiStop(). */
extern tmLibdevErr_t dtv_ttr_AI_Stop(void)
{
    aiDisableCAP_ENABLE();

    return TMLIBDEV_OK;
}

/* called from aiSetSampleRate(). */
extern tmLibdevErr_t dtv_ttr_AI_SetSrate(Float sRate)
{
    Float               val;
    
    /* it's not possible to change the input rate for digital input */
    if (dtvTtrAiInput == aaaDigitalInput)
    {
        return TMLIBDEV_OK;
    }
    
    val = sRate * 256.0; /* oversampling clock is 256 * fs */
    if (dtvTtrCPUisTM1100)
    {
        val = 0.5 + (477218588.0 * (val / dtvTtrCPUClock));    /* 2**32 / 9 */
        aiSetFREQ(((UInt) val) | 0x80000000);
    }
    else
    {
        val = 0.5 + (1431655765.0 * (val / dtvTtrCPUClock));    /* 2**32 / 3 */
        aiSetFREQ((UInt) val);
    }

    return TMLIBDEV_OK;
}

/* called from aiGetSampleRate().  
 * Should return an accurate value from the hardware. 
 */
extern tmLibdevErr_t dtv_ttr_AI_GetSrate(Float * sRate)
{
    UInt    iicd;
    Int     err = TMLIBDEV_OK;

    tmAssert(sRate, TMLIBDEV_ERR_NULL_PARAMETER);

    if (dtvTtrAiInput == aaaDigitalInput)
    {
        err     = iicReadReg(TTR_INPUT_IIC_EXPANDER_ADDRESS, -1, &iicd);
        iicd    |= TTR_TDA1315_IN_IIC_FREQUENCY_MASK;
        err     |= iicWriteReg(TTR_INPUT_IIC_EXPANDER_ADDRESS, -1, iicd);
        err     |= iicReadReg(TTR_INPUT_IIC_EXPANDER_ADDRESS, -1, &iicd);
        if (err) return err;

        switch (iicd & TTR_TDA1315_IN_IIC_FREQUENCY_MASK)
        {
        case TTR_TDA1315_IN_IIC_44100_HZ:
            *sRate = 44100.0;
            break;
        case TTR_TDA1315_IN_IIC_48000_HZ:
            *sRate = 48000.0;
            break;
        case TTR_TDA1315_IN_IIC_32000_HZ:
            *sRate = 32000.0;
            break;
        default:
            *sRate = 0.0;
            break;
        }    
    }
    else
    {
        if (dtvTtrCPUisTM1100)
        {
            *sRate = (Float) (MMIO(AI_FREQ) & 0x7fffffff) * dtvTtrCPUClock / 477218588.0 / 256.0;
        }
        else
        {
            *sRate = (Float) MMIO(AI_FREQ) * dtvTtrCPUClock / 1431655765.0 / 256.0;
        }
    }
    return TMLIBDEV_OK;
}

/* called from aiSetInput() */
extern tmLibdevErr_t dtv_ttr_AI_SetInput(tmAudioAnalogAdapter_t input)
{
    boardAIParam_t  param;
    UInt            err;
    static Bool     capEnable = False;
    UInt32          buf1 = MMIO(AI_BASE1);
    UInt32          buf2 = MMIO(AI_BASE2);
    UInt32          size = MMIO(AI_SIZE);
    UInt32          aiIntControl = MMIO(AI_CTL) & (AI_BUF1_INTEN | AI_BUF2_INTEN | AI_OVR_INTEN | AI_HBE_INTEN);
    
    /* check if we realy have to change the input */
    if (input == dtvTtrAiInput)
    {
        return TMLIBDEV_OK;
    }
    
    /* stop audio in */
    if (MMIO(AI_CTL) & AI_CAP_ENABLE)
    {
        aiDisableCAP_ENABLE();
        capEnable = True;
    }
    
    param.audioTypeFormat    = dtvTtrAiAudioTypeFormat;       
    param.audioSubtypeFormat = dtvTtrAiAudioSubtypeFormat;
    param.sRate              = dtvTtrAiSRate;
    param.size               = dtvTtrAiSize;
    param.input              = input;
    dtvTtrAiInput            = input;
    
    
    err = dtv_ttr_AI_Init(&param);

    /* restore MMIO registers */
    MMIO(AI_BASE1)  = buf1;
    MMIO(AI_BASE2)  = buf2;
    MMIO(AI_SIZE)   = size;
    MMIO(AI_CTL)   |= aiIntControl;
    
    if (err)
    {
        return err;
    }
    
    if (capEnable)
    {
        aiEnableCAP_ENABLE();
    }
    
    return TMLIBDEV_OK;
}

/* called from aiGetInput() */
extern tmLibdevErr_t dtv_ttr_AI_GetInput(tmAudioAnalogAdapter_t * input)
{
    tmAssert(input, TMLIBDEV_ERR_NULL_PARAMETER);
    
    *input = dtvTtrAiInput;
    
    return TMLIBDEV_OK;
}

/* called from aiGetInputFormat */
extern tmLibdevErr_t dtv_ttr_AI_GetFormat(ptmAudioFormat_t inputFormat)
{
    Float   sRate;
    Int     err;
    Char    statusReg[2] = {0,0};

    /* initialize the inputFormat */
    inputFormat->size        = sizeof(tmAudioFormat_t);
    inputFormat->dataClass   = avdcAudio;
    inputFormat->dataType    = atfNone;
    inputFormat->dataSubtype = apfNone;
    inputFormat->sampleRate  = 0.0;
    
    /* get sample rate, if sample rate is 0.0 -> TDA 1315 is not locked */
    err = dtv_ttr_AI_GetSrate(&sRate);
    if (err) return err;
    
    if (sRate == 0.0)
    {
        return TMLIBDEV_OK;
    }
    
    inputFormat->sampleRate     = sRate;
    inputFormat->dataType       = atfLinearPCM;
    inputFormat->dataSubtype    = apfStereo16;

    /* get channel status information */
    inputL3Params.data = statusReg;
    err = tda1315AccessL3(&inputL3Params, READ_CHANNEL_STATUS_REGISTER);
    if (err)
        return err;
    
    if ((statusReg[0] & TDA1315_L3_CHAN_STAT_DATA_MASK) == TDA1315_L3_CHAN_STAT_DATA)
    {
        inputFormat->dataType = atf1937;
        inputFormat->dataSubtype = apfGeneric;
    }
    
    return err;
}    

/* a backdoor to support features not forseen in the initial design */
extern tmLibdevErr_t dtv_ttr_AI_Config(UInt32 subaddr, Pointer value)
{
    return TMLIBDEV_OK;
}