gdtservo.c

ESS3890+SL原代码（1*16内存）

/*
 * Read the table of content. CD-module passes all track info. Information
 * depends on track number:
 *	0 <= track number <= 63
 *		track number
 *		control & address
 *		start time (min)
 *		start time (sec)
 *		start time (frm)
 *
 * This routine initialize track information as well as lead out time.
 *
 * Input:
 *	pTk:	Pointer to the track information buffer
 *	szTk:	Size (number of entries) of track information buffer
 *
 * Return:
 *	0:	failed
 *	1:	OK
 */
int dsa_ltoc(pTk,szTk )
unsigned int *pTk;
int szTk;
{
    int track_rd_num,i;		/* # of track info have been read */
    unsigned char data_1,cmd;
    int t64r, t65r, t66r;	/* Keep track whether we have received	 *
				 * 64h, 65h, 66h (A0, A1, A2)		 */
    int ltoc_done;		/* LTOC is done				 */
    unsigned char track;	/* Current track number			 */
    int retry_cnt = 0;		/* This routine's retry count		 */
    int loopcnt;		/* Number of replies from servo.	 */
    int tk1_ctl_adr;		/* Track #1 Control/Address		 */
    char tk64_data;		/* Track #64 data			 */

    int dly1 = 0;
    int num, test;
    int pt_B0, pt_C0;

    int multi_session=0;
    int return_val=0;

    CDinited = 0;		/* Avoid partially initialized CD info	 */
    SERVO_rest();

/* Start Servo until Servo on stable */
    SET_servo_adj;
    SERVO_mode = Mode_Focusing;
    SERVO_state = Focus_Para;
    while (1) {
	microEngine();
	/* Servo Process in dsa_ltoc() - Start Servo */
	SERVO_service();
	if (SERVO_STATUS == SERVO_RET_clvok) break;
	if (SERVO_STATUS == SERVO_RET_int) return (0);
	if ((SERVO_STATUS==SERVO_RET_loss)
            || (SERVO_STATUS==SERVO_RET_clvng)) {
	    CDinfo.type = CD_NODISC;
	    return (0);
	}
        if(SERVO_check_key_new()) return(0);
    }

    CDinfo.type = 255;

    for (i = 0; i < szTk; i++) pTk[i] = 0xff000000;
    t64r = t65r = t66r = 0;
    track_rd_num = num_of_track = 0;
    multi_session = 0;
    num_of_session = 1;
    last_session_msf = 0;

#if defined(CD_TEXT) && !defined(ANTI_SHOCK)
    CD_text_init(1);
#endif

    /* process received data until it is done */
    loopcnt = ltoc_done = 0;

    while (!ltoc_done) {
#ifdef ECHO
        MIC_service();
#endif
	VCX_service();
	dly1 = glbTimer;

        SERVO_STATUS = 0;
        if(SERVO_check_key_new()) return(0);

	do {
	    /* Monitor Servo Stability in dsa_ltoc() */
	    SERVO_service();
	    if (SERVO_STATUS == SERVO_RET_Qcode) break;
	    if (SERVO_STATUS == SERVO_RET_int) return (0);
	    if((SERVO_STATUS==SERVO_RET_loss) 
               || (SERVO_STATUS==SERVO_RET_clvng)){
		CDinfo.type = CD_NODISC;
		return (0);
	    }
            if(SERVO_check_key_new()) return(0);
	} while (1);

/*	OUTOSD(12,"QDATA","QDATA",1);		/* OSD-Q DATA READY */
	for (num = 0; num < 10; num++) {
	    Qcode[num ] = (unsigned char)SERVO_Qarray_current[num];	   
	}

	switch ( Qcode[SERVO_QTRACK]) {
	  case 0x00:
	    switch (Qcode[SERVO_QPOINT]) {
	      case 0xA0:
/*		OUTOSD(6,"MIN","MIN",10);	/* OSD-FIRST TRACK */
                if( num_of_session == 1){
	  	   CDinfo.firsttrack = bcd2hex[Qcode[SERVO_QPMIN]];
		   tk64_data = Qcode[SERVO_QPSEC];
		   if (tk64_data == 0xa) CDinfo.type = CD_CDI;
                }
		t64r = 1;
		break;

	    case 0xA1:
/*		OUTOSD(8,"MAX","MAX",10);	/* OSD-LAST TRACK */
		CDinfo.lasttrack = bcd2hex[Qcode[SERVO_QPMIN]] - 1;
		if (CDinfo.type == CD_CDI)
		    num_of_track = -1;
		else
		    num_of_track = CDinfo.lasttrack - CDinfo.firsttrack + 1;
		t65r = 1;
		break;

	    case 0xA2:
/*		OUTOSD(10,"LEAD","LEAD",10);	/* OSD-LEAD OUT */
		t66r = 1;
                if (multi_session) break;
                CDinfo.leadout = (Qcode[SERVO_QPMIN] << 16) & 0x00ff0000;
                CDinfo.leadout |= (Qcode[SERVO_QPSEC] << 8) & 0x0000ff00;
                CDinfo.leadout |= (Qcode[SERVO_QPFRAME]) & 0x000000ff;
		break;

#ifdef MULTI_SESSION
            case 0xB0:
/*              OUTOSD(7,"B0","B0",10);*/
                if (!((Qcode[SERVO_QRMIN]==0xff) &&
                    (Qcode[SERVO_QRSEC]==0xff) &&
                    (Qcode[SERVO_QRFRAME]==0xff))){
                    multi_session=1;
/*                  OUTOSD(11,"MULT","MULT",10); */
                    last_session_msf = Qcode[SERVO_QRMIN]<<16 ;
                    last_session_msf|= Qcode[SERVO_QRSEC]<<8;
                    last_session_msf|= Qcode[SERVO_QRFRAME];
                    target_min  = Qcode[SERVO_QRMIN] ;
                    target_sec  = Qcode[SERVO_QRSEC];
                    target_frame= Qcode[SERVO_QRFRAME];
                 }
                 CDinfo.leadout = Qcode[SERVO_QPMIN]<<16 ;
                 CDinfo.leadout |= Qcode[SERVO_QPSEC]<<8;
                 CDinfo.leadout |= Qcode[SERVO_QPFRAME];
                 pt_B0 = 1;
                 break;

            case 0xC0:
/*               OUTOSD(8,"C0","C0",10); */
                 if (!multi_session) { multi_session=1; }
                    pt_C0=0;
                    break;
#endif /*MULTI_SESSION*/

	    default:
		if (t64r && t65r && t66r) {
		    if ((Qcode[SERVO_QPOINT] < 0xa0) &&
			(Qcode[SERVO_QPOINT] > 0x00))
			if (pTk[((bcd2hex[Qcode[SERVO_QPOINT]]) - 1)] ==
			    0xff000000) {
			    pTk[(bcd2hex[Qcode[SERVO_QPOINT]] - 1)] =
				((Qcode[SERVO_QCTRADD] << 24) & 0xff000000);
			    pTk[(bcd2hex[Qcode[SERVO_QPOINT]] - 1)] |=
				((Qcode[SERVO_QPMIN] << 16) & 0x00ff0000);
			    pTk[(bcd2hex[Qcode[SERVO_QPOINT]] - 1)] |=
				((Qcode[SERVO_QPSEC] << 8) & 0x0000ff00);
			    pTk[(bcd2hex[Qcode[SERVO_QPOINT]] - 1)] |=
				((Qcode[SERVO_QPFRAME]) & 0x000000ff);
			    if (Qcode[SERVO_QPOINT] == 1)
				tk1_ctl_adr = Qcode[SERVO_QCTRADD];
			    track_rd_num++;
			}
		}
		break;
	    }
	    break;

	default:
            SERVO_near_jump(1, 32);
	    break;
	}


        if(/*t64r&&t65r&&t66r&&*/(track_rd_num > num_of_track) ){
           t64r = t65r = t66r = 0;
           if(num_of_session == 1){
              if (tk1_ctl_adr == 0x01 || tk1_ctl_adr == 0x11 ||
                  tk1_ctl_adr == 0x21 || tk1_ctl_adr == 0x31)
                  CDinfo.type = CD_CDDA;
              else if (tk64_data != 0 && (tk1_ctl_adr == 0x41
                       || tk1_ctl_adr == 0x61)) {
                  CDinfo.type = CD_VCD;
                  OUTOSD(10, "CD_VCD", "CD_VCD", 0);
              /* Note: Photo-CD will also pass as VCD */
             } else
#ifdef DATA_CD
             if (!tk64_data) {
               CDinfo.type = CD_DATA;
               OUTOSD(10, "CD_DATA", "CD_DATA", 0);
             } else
#endif
             CDinfo.type = CD_UNKNOWN;
           }
           if (!multi_session) {
               ltoc_done = 1;
               OUTOSD(8, "TOC OK", "TOC OK", 1); 
           }
#ifdef MULTI_SESSION
           else {
               multi_session = 0;
               loopcnt=0;
               num_of_session++;
              return_val = SERVO_go_next_session();
           }
#endif /*MULTI_SESSION*/

       }

    }				/* end of while(ltoc_done) */

#if defined(CD_TEXT) && !defined(ANTI_SHOCK)
    CD_text_init(0);
#endif


    if (CDinfo.type == CD_CDDA) {
	/*
	 * We need to adjust the track info. Even track 0 is used here. We
	 * want to map track i to track i+1.
	 */
        OUTOSD(10, "CD_CDDA", "CD_CDDA", 0);
	CDinfo.lasttrack += 1;
	num_of_track++;
	for (i = CDinfo.lasttrack; i >= CDinfo.firsttrack; i--)
	    pTk[i] = pTk[i - 1];

	dsa_mode(currDSAmode = MODE_ATTI_REL | MODE_AUDIO | MODE_SPEED_NORMAL);
    } 

    dsa_mode(currDSAmode = MODE_ATTI_REL | MODE_CDROM | MODE_SPEED_NORMAL);
    bcd_num_of_track = (int) hex2bcd[num_of_track];

    CDinited = 1;

    DISP_cigam(CDinfo.type != CD_CDDA);
    return (1);

 ltoc_err_return:
    (void) dsa_stop();
    return (0);
}


/*
 * Goto time. This command forces the CD-module to jump to the requested
 * absolute time location.
 *
 * Input:
 *	time:	CD sector time in MMSSFF format where each of MM/SS/FF
 *		is a BCD number.
 *
 * Return:
 *	1:	successful
 *	0:	otherwise
 */
int dsa_go(unsigned int time)
{
    int return_val;
    int r_tmp;


    dsa_go_state = DSA_GO_INIT;
    
    do {
        return_val = dsa_go_step_by_step(time);
    } while (return_val==1);

    return ((return_val == 2));
}

void reset_dsa_go(void)
{
    dsa_go_state = DSA_GO_INIT;
}

/****************************************************************************
 Step by step go time. Returns 0 if failed, 1 if don't know, 2 if succeed.
 ****************************************************************************/
int dsa_go_step_by_step(unsigned int time)
{
    int return_val, r_tmp;
    /*static int ssearch_cnt;*/


    switch (dsa_go_state) {
      case DSA_GO_INIT:
	/*OUTOSD(5,"GO","GO",1);	/* Goto target */
	if (SERVO_mode == Mode_Stopping)
        {
	    while (SERVO_state != STOP_idle)
		   GDT_SERVO_process();/* Wait until stop idle */
	    /* Start Servo until Servo on stable */
	    SERVO_mode = Mode_Focusing;
	    SERVO_state = Focus_Para;
	    while (1) {
		microEngine();
                SERVO_service();
		return_val = SERVO_STATUS;
		if (return_val == SERVO_RET_clvok)
		    break;
		if ((return_val == SERVO_RET_int)||
		    (return_val == SERVO_RET_fng)||
		    (return_val == SERVO_RET_clvng)) {
		    return (0);
		}
	    }
	}
	target_frame = bcd2hex[time&0xff];
	target_sec = bcd2hex[(time>>8)&0xff];
	target_min = bcd2hex[(time>>16)&0xff];

#if 0
	/*ssearch_cnt = 0;*/
	search_timer = glbTimer + 3000;
#endif

	dsa_go_state = DSA_GO_SEARCHING;

        SERVO_mode = Mode_Seek;
        SERVO_state = Seek_Initial;
        CLR_search_flag;
        GDT_SERVO_process();

	return_val = 1;
	break;

      case DSA_GO_SEARCHING:

        GDT_SERVO_process();
        return_val = 1;

        if (search_flag_TRUE){
	    dsa_go_state = DSA_GO_FOUND_TARGET;
            CLR_search_flag;
        }  
        else if ((SERVO_STATUS == SERVO_RET_int)||
            (SERVO_STATUS == SERVO_RET_fng)||
            (SERVO_STATUS == SERVO_RET_clvng)) {
#if 0
            if (glbTimer > search_timer)
                return(0);
            else
#endif
                return(1);
        }
	
	break;

      case DSA_GO_FOUND_TARGET:
	servo_info = 0;
	if (CDinfo.type != CD_CDI)
	{ 
	    /* TTMMSSFF */
	    servo_info = 
		(SERVO_Qarray_current[SERVO_QTRACK] << 24) |
		(SERVO_Qarray_current[SERVO_QRMIN] << 16) |
		(SERVO_Qarray_current[SERVO_QRSEC] << 8) |
		SERVO_Qarray_current[SERVO_QRFRAME]; 		
	} else 	servo_info = currCDtime >> 8;
	
	r_tmp = bcd2hex[SERVO_Qarray_current[SERVO_QCTRADD]];
	r_tmp = r_tmp - ((CDinfo.type == CD_CDDA) ? 0 : 1);
	/* Modify by Andy Yam */
	/*
	   servo_info |= (hex2bcd[r_tmp] & 0x0000ff)<<24 |
	   (SERVO_Qarray_current[1]>>8 & 0x0000ff)<<16;
	   */
	servo_info |=((long)(hex2bcd[r_tmp]) << 24) & 0xff000000;

	/* Modify by Andy Yam */
	last_servo_info = servo_info;
	updateLCDtime();
	OSD_update_info();	/* OSD info needs to update */	

	dsa_go_state = DSA_GO_INIT;
/*	OUTOSD(1,"FOUND","FOUND",1);	/* Found target */
	return_val = 2;
	break;
    }
    GDT_SERVO_process();

    return (return_val);
}

/*
 * Open the tray, need to stop the motor first if it is playing
 */
int SERVO_open()
{
    unsigned int timeout;
    volatile int flag = 0;

    SERVO_off();

    SET_servo_stop;
   
    Start_Open_Tray();
    timeout = glbTimer + FIVE_SECOND;

    do {
        GDT_SERVO_process();
        if (SERVO_STATUS == SERVO_RET_trayoutok) flag = 1;
        if (SERVO_STATUS == SERVO_RET_int ) break;
        if (glbTimer > timeout || SERVO_check_key_new()) break;
    } while (!flag);

    return (0);
}

/*
 * Open the tray, need to stop the motor first if it is playing
 */
int SERVO_close()
{
    unsigned int timeout;
    int tray_closed = 0;

    Start_Close_Tray();

    timeout = glbTimer + FIVE_SECOND;
    while(1) {
        GDT_SERVO_process();
        if (SERVO_STATUS == SERVO_RET_trayinok) {
            tray_closed = 1; break;
        }
        if (SERVO_STATUS == SERVO_RET_int ) break;
        if (glbTimer > timeout || SERVO_check_key_new()) break;
    };
    if (tray_closed) cd_tray_closed();

    return (1);
}

void SERVO_service()
{
    int var;
    unsigned char status;
    extern int FC_loop_counter;

    status = Read_Servo_Register(STATUS1);

#if 1 
    if ((SERVO_mode==Mode_Tracking) || (SERVO_mode==Mode_Monitor) || (SERVO_mode==Mode_Seek)){
       if ((status & FOK) != FOK ){
           OUTOSD(3, "ERROR", "ERROR", 0);
           old_SERVO_mode = SERVO_mode;
           Turn_Off_Servo();
           FC_loop_counter++;
           if (FC_loop_counter <= 4) {
              SERVO_STATUS = SERVO_RET_fng;          /* Default loss */
              SERVO_mode = Mode_Focusing;     /* Try to recover it */
              SERVO_state = Focus_recover;
           } else {
              SERVO_STATUS = Mode_Stopping;
              SERVO_state = STOP_start;
              SERVO_STATUS = SERVO_RET_loss;
              FC_loop_counter = 0;
           }
        }
    }
#endif
    GDT_SERVO_process();
    Read_Servo_Qcode();

    return;
    var = SERVO_STATUS;
    if(var == SERVO_RET_Qcode) {
      if(search_flag_FALSE) {}
    } else if (var == SERVO_RET_stopok) { /* Stop Completed */
    } else if (var == SERVO_RET_fng) { /*loss focus*/
      /*Done in GDT_SERVO_process*/
    } else if ((var==SERVO_RET_loss) || (var==SERVO_RET_int)
                || (var==SERVO_RET_clvng)) {
        SERVO_off();
        /*Add codes to clear all VCD state machine*/
        /* .....*/
    }

}