mst705Ȧ

MST705源代码

            WORD wStatus = msVDGetSyncStatus();
            PrintVDStatus(wStatus);
            //Test_CalClock(1);
        }
            break;
        case 0xD2: msVDReset();
            break;
        case 0xD3:
            printf("\r\n VdStatus=%x",msVDGetSyncStatus());
            printf("\r\n g_VdInfo.wVideoStatus=%x",g_VdInfo.wVideoStatus);
            break;
        case 0xD5:
            g_ucIrCode = IRKEY_SCANMODE;
            g_bIrDetect = TRUE;
            break;
        case 0xD6:
            g_ucIrCode = IRKEY_SOUNDMODE;
            g_bIrDetect = TRUE;
            break;
        case 0xD7:
            g_ucIrCode = IRKEY_OSD_UP;
            g_bIrDetect = TRUE;
            break;
        case 0xD8:
            //msAutoGeometry(AUTO_TUNE_YUV_COLOR);
            //usrSaveAdcSetting(ADC_SET_YPBPR); // save YPbPr setting(manufactory)
            break;
        case 0xFF:
		GetScale100Value(g_PcSetting.Brightness, 0, 100);
            break;

    #if 0
        case 0xbb:
            ExecuteKeyEvent(MIA_HSYNC);
            break;
    #endif

        // if enable g_bDebugASCIICommandFlag,
        // it means the program is received command that user use ASCII command type in debug tool software.
        // and the program should respond the register value by message type (printf)
        //    test command + 0xF0 -> disable
        //    test command + 0xF1 -> enable
        case 0xF0:
            g_bDebugASCIICommandFlag = _DISABLE;
            break;
        case 0xF1:
            g_bDebugASCIICommandFlag = _ENABLE;
            break;
        case 0xF2:
	     	P4SEL=g_UartCommand.Buffer[_UART_CMD_INDEX2_];
	     	P4IO=g_UartCommand.Buffer[_UART_CMD_INDEX2_];
            printf("\r\n P4 CONTROL=%x",g_UartCommand.Buffer[_UART_CMD_INDEX2_]);
            break;
        case 0xF3:
	     	P4=g_UartCommand.Buffer[_UART_CMD_INDEX2_];
            printf("\r\n P4 =%x",g_UartCommand.Buffer[_UART_CMD_INDEX2_]);
            break;
        case 0xF4:
            printf("\r\n P4 Read Data=%x",P4);
            break;
        case 0xFD:
            PrintModeSetting();
            break;
        case 0xfe: // Display system flag
        /*
            putstr("\r\nSystemInfo:");
            printf("\r\n_ucSysStatus=%x", g_SystemInfo._ucSysStatus);
            printf("\r\n_ucInputSrcType=%x", g_SystemInfo._ucInputSrcType);
            printf("\r\n_inputPortType=%x", g_SystemInfo._inputPortType);
            printf("\r\n_ucSignalColorType=%x", g_SystemInfo._ucSignalColorType);
            */
            break;
        case 0xff55: // Here will never called! For disable some uncall warning
        /*
            i2cReadCurrent(0);
            msOsdSetBrightness(0xff);
            msOsdReadCode( 0 );
            msOsdReadAttr( 0 );
            msAdjustHSC(50,0x80,0x80);
            SetOPLevel(0, 0);*/
            break;
#endif
    }

    msWriteByte( BK0_00_REGBK, ucBank );
}

void uartDecodeCommand(void)
{
    if(_testbit_(g_bUartDetected)) // cehck command flag
    {
        //putstr("\r\nDecode UartCmd");
        if (UART_EXT)
        {
        #if (_DEBUG_EXTDEV_EN_)
            uartDecodeExtCommand();
        #endif
        }
        else
            uartDecodeNormalCommand();
    }
}

#if (_DEBUG_EXTDEV_EN_)
void uartDecodeExtCommand(void)
{
    BYTE i;
    XDATA BYTE acI2cBuf[16];

    {
        switch(UART_EXT_DEV)
        {
        #if 0//(( AUDIO_DECODER_SEL == AUDIO_DECODER_MSP34X0 ) ||( AUDIO_DECODER_SEL == AUDIO_DECODER_MSP34X5 ))
            case DEV_MICRONAS_AUDIO:
            {
                XDATA MSPI2cType mspParam;
                switch(UART_EXT_CMD)
                {
                    case URCMD_MICRONAS_AUDIO_WRITE:
                        mspParam.SubAddr = UART_EXT_CMD_MS_DAT1;
                        mspParam.AddrByte_High = UART_EXT_CMD_MS_DAT2;
                        mspParam.AddrByte_Low = UART_EXT_CMD_MS_DAT3;
                        mspParam.DataByte_High = UART_EXT_CMD_MS_DAT4;
                        mspParam.DataByte_Low = UART_EXT_CMD_MS_DAT5;
                        devAudioWrite(&mspParam);
                        putstr("\r\nMSP Write");
                        break;
                    case URCMD_MICRONAS_AUDIO_READ:
                        mspParam.SubAddr = UART_EXT_CMD_MS_DAT1;
                        mspParam.AddrByte_High = UART_EXT_CMD_MS_DAT2;
                        mspParam.AddrByte_Low = UART_EXT_CMD_MS_DAT3;
                        devAudioRead(&mspParam);
                        putchar(0xF3);
                        putchar( mspParam.DataByte_Low );
                        putchar( mspParam.DataByte_High );
                        putstr("\r\nMSP Read");
                        break;
                } // End of switch(dev_cmd)
                break;
            }
        #endif

#if TV_ENABLE
            case DEV_PHLIPS_TUNER:
            {
                switch(UART_EXT_CMD)
                {
                    case URCMD_PHLIPS_TUNER_SET_FREQ: // Write and get status
                    {
                        XDATA TunerProgramType tunerParam;
                        putstr("\r\nTuner write");
                        tunerParam.ProgDivide = ((WORD)UART_EXT_CMD_MS_DAT2 <<8) + UART_EXT_CMD_MS_DAT1; // Program divider 2 byte (n14-n0)
                        tunerParam.ControlInfo1 = UART_EXT_CMD_MS_DAT3; // Control information byte 1
                        tunerParam.ControlInfo2 = UART_EXT_CMD_MS_DAT4; // Control information byte 1(P7-P0)
        #if 0//( TUNER_IS_PHILIPS )
                        tunerParam.AuxilliaryByte = UART_EXT_CMD_MS_DAT5; // Auxilliary byte
        #endif

		                i2c_AccessStart(TN_PROG_I2C_ADDR, I2C_WRITE);
		                i2c_SendByte(tunerParam.ProgDivide>>8);
		                Delay1ms(1);
		                i2c_SendByte(tunerParam.ProgDivide&0xff);
		                Delay1ms(1);
		                i2c_SendByte(tunerParam.ControlInfo1);
		                Delay1ms(1);
		                i2c_SendByte(g_bTunerParm.ControlInfo2);
		                Delay1ms(1);
		                i2c_Stop();

                        UART_CMD_MS_DAT = 0;//DevTunerWrite(&tunerParam);
                        putchar(0xF2);
                        putchar( UART_CMD_MS_DAT );
                    }
                        break;
                    case URCMD_PHLIPS_TUNER_GET_STATUS:
                        putstr("\r\nTuner Read");
                        UART_CMD_MS_DAT = devTunerGetStatus(20);
                        putchar(0xF2);
                        putchar( UART_CMD_MS_DAT );
                        break;
                } // End of switch(dev_cmd)
                break;
            }
            // other device ...
#endif

            // I2C Debug ...
            case 0xf0: // I2C Write Bytes(Has sub address)
                i2cBurstWriteBytes( g_UartCommand.Buffer[_UART_CMD_INDEX3_],
                                    g_UartCommand.Buffer[_UART_CMD_INDEX4_],
                                    &(g_UartCommand.Buffer[_UART_CMD_INDEX5_]),
                                    UART_CMD_EXT_LENGTH-5 );
                printf("\r\nI2C Write %X", g_UartCommand.Buffer[_UART_CMD_INDEX3_]);
                printf(",%X => ", g_UartCommand.Buffer[_UART_CMD_INDEX4_]);
                for( i = 0; i < UART_CMD_EXT_LENGTH-5; ++ i )
                {
                    printf("[%x]", g_UartCommand.Buffer[_UART_CMD_INDEX5_+i]);
                }
                putstr("\r\n");
                break;
            case 0xf1: // I2C Read Bytes(Has sub address)
                i2cBurstReadBytes(g_UartCommand.Buffer[_UART_CMD_INDEX3_],
                                g_UartCommand.Buffer[_UART_CMD_INDEX4_],
                                acI2cBuf,
                                g_UartCommand.Buffer[_UART_CMD_INDEX5_]);
                printf("\r\nI2C Read %x", g_UartCommand.Buffer[_UART_CMD_INDEX3_] );
                printf(",%X => ", g_UartCommand.Buffer[_UART_CMD_INDEX4_] );
                for( i = 0; i < g_UartCommand.Buffer[_UART_CMD_INDEX5_]; ++ i )
                {
                    printf("[%x]", acI2cBuf[i]);
                }
                putstr("\r\n");
               break;
            case 0xf2: // I2C Write Bytes(No sub address)
                i2cBurstCurrentBytes( g_UartCommand.Buffer[_UART_CMD_INDEX3_],
                                      &(g_UartCommand.Buffer[_UART_CMD_INDEX4_]),
                                      UART_CMD_EXT_LENGTH-4 );
                printf("\r\nI2C Write_2 %X => ", g_UartCommand.Buffer[_UART_CMD_INDEX3_]);
                for( i = 0; i < UART_CMD_EXT_LENGTH-4; ++ i )
                {
                    printf("[%x]", g_UartCommand.Buffer[_UART_CMD_INDEX4_+i]);
                }
                putstr("\r\n");
                break;
            case 0xf3: // I2C Read Bytes(No sub address)
                i2cBurstCurrentBytes( g_UartCommand.Buffer[_UART_CMD_INDEX3_],
                                    acI2cBuf,
                                    g_UartCommand.Buffer[_UART_CMD_INDEX4_] );
                printf("\r\nI2C Read_2 %x => ", g_UartCommand.Buffer[_UART_CMD_INDEX3_] );
                for( i = 0; i < g_UartCommand.Buffer[_UART_CMD_INDEX4_]; ++ i )
                {
                    printf("[%x]", acI2cBuf[i]);
                }
                putstr("\r\n");
                break;
        } // End of switch( device )
    }
}
#endif

///////////////////////////////////////
//  Decode Uart command
///////////////////////////////////////
//0 sCALER
//1 adc
//2 vd
//3 COMB
//4 ??
//5 dsp
// OSD
//===== ぃノresotre =====
//6 MCU
//A DEBUG1
//B Debug2
//C debug3
void uartDecodeNormalCommand(void)
{
    BYTE ucBank;

    {
        ucBank = msReadByte(BK0_00_REGBK);

        switch(UART_CMD)
        {
/*
            case kEnter_ISP:
                {
                    // new check ISP command
                    if (g_UartCommand.Buffer[_UART_CMD_INDEX1_] != 0x55 ||
                        g_UartCommand.Buffer[_UART_CMD_INDEX2_] != 0xaa)
                       break;

                    putstr("\r\n- Isp -");
                #if(PANEL_TYPE_SEL!=PNL_DAC_CRT)
                    pwPanelOffSequence();
                #endif

                  #if( MCU_SEL==MCU_W78E65 )
                    CHPENR = 0x87; // CHPENR = 0x59, enable CHPCON register write attribute
                    CHPENR = 0x59; // CHPENR = 0x59, enable CHPCON register write attribute
                    CHPCON = 0x03; // CHPCON = 0x03, enter in-system programming mode
                    CHPENR = 0x00; // CHPENR = 0x00, disable CHPCON write attribute

                    TR0 = 0;       // Timer0 stop
                    IP = 0x00;     // Set interrupt priority

                    EA = 1;        // Set single interrupt
                    ET0 = 1;       // Enable TIMER0 iterrrupt
                                   // Timer0 interrupt enable for wake-up from INDLE mode

                    // Set time for enter ISP mode about 1.676 us
                    TL0 = 0xf0; // TL0 = 0xf0
                    TH0 = 0xff; // TH0 = 0xff
                    TMOD |= 0x01;  // Set Timer0 mode 1 (16-bit timer)
                    TR0 = 1;       // Start Timer0
                    PCON = 0x01;   // Enter IDLE mode for launching the in-system programmability
                  #endif
                  #if(MCU_SEL==MCU_W77E532)
                    //P4 = 0x00;

                    IE = 0;
                    TCON = 0;

                    TA = 0xAA;
                    TA = 0x55;
                    TURBO_CHPCON = 0x03; // CHPCON = 0x03, enter in-system programming mode
                    TA = 0x00;

                    TR0 = 0;       // Timer0 stop
                    IP = 0x00;     // Set interrupt priority

                    EA = 1;        // Set single interrupt
                    ET0 = 1;       // Enable TIMER0 iterrrupt
                                   // Timer0 interrupt enable for wake-up from INDLE mode

                    // Set time for enter ISP mode about 1.676 us
                    TL0 = 0xf0; // TL0 = 0xf0
                    TH0 = 0xff; // TH0 = 0xff
                    TMOD |= 0x01;  // Set Timer0 mode 1 (16-bit timer)
                    TR0 = 1;       // Start Timer0
                    PCON = 0x01;   // Enter IDLE mode for launching the in-system programmability
                  #endif
                    break;
                }
*/
/*
            case kWrite_MST_Bank0:
                {
                    msWriteByte(BK0_00_REGBK, REG_BANK_SCALER);
                    msWriteByte(UART_CMD_MS_REG, UART_CMD_MS_DAT);
                    if (!g_bDebugASCIICommandFlag) putchar(0xF1);
                    break;
                }
            case kRead_MST_Bank0:
                {
                    msWriteByte(BK0_00_REGBK, REG_BANK_SCALER);
                    UART_CMD_MS_DAT = msReadByte(UART_CMD_MS_REG);
                    putchar(0xF2);
                    putchar(UART_CMD_MS_DAT);
                    if (g_bDebugASCIICommandFlag)
                    {
                        printf("BK0[0x%x]=", UART_CMD_MS_REG);
                        printf("0x%x \r\n", UART_CMD_MS_DAT);
                    }
                    break;
                }
            case kWrite_MST_Bank1:
                {
                    msWriteByte(BK0_00_REGBK, REG_BANK1_ADC_ACE_MCU);
                    msWriteByte(UART_CMD_MS_REG, UART_CMD_MS_DAT);
                    if (!g_bDebugASCIICommandFlag) putchar(0xF1);
                    break;
                }
            case kRead_MST_Bank1:
                {
                    msWriteByte(BK0_00_REGBK, REG_BANK1_ADC_ACE_MCU);
                    UART_CMD_MS_DAT = msReadByte(UART_CMD_MS_REG);
                    putchar(0xF2);
                    putchar(UART_CMD_MS_DAT);
                    if (g_bDebugASCIICommandFlag)
                    {
                        printf("BK1[0x%x]=", UART_CMD_MS_REG);
                        printf("0x%x \r\n", UART_CMD_MS_DAT);
                    }
                    break;
                }
            case kWrite_MST_Bank2:
                {
                    msWriteByte(BK0_00_REGBK, 2);
                    msWriteByte(UART_CMD_MS_REG, UART_CMD_MS_DAT);
                    if (!g_bDebugASCIICommandFlag) putchar(0xF1);
                    break;
                }
            case kRead_MST_Bank2:
                {
                    msWriteByte(BK0_00_REGBK, 2);
                    UART_CMD_MS_DAT = msReadByte(UART_CMD_MS_REG);
                    putchar(0xF2);
                    putchar(UART_CMD_MS_DAT);
                    if (g_bDebugASCIICommandFlag)
                    {
                        printf("BK2[0x%x]=", UART_CMD_MS_REG);
                        printf("0x%x \r\n", UART_CMD_MS_DAT);
                    }
                    break;
                }
            case kWrite_MST_Bank3:
                {
                    msWriteByte(BK0_00_REGBK, 3);
                    msWriteByte(UART_CMD_MS_REG, UART_CMD_MS_DAT);
                    if (!g_bDebugASCIICommandFlag) putchar(0xF1);
                    break;
                }
            case kRead_MST_Bank3:
                {
                    msWriteByte(BK0_00_REGBK, 3);
                    UART_CMD_MS_DAT = msReadByte(UART_CMD_MS_REG);
                    putchar(0xF2);