tcservo.c

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

/*
 * Pause release. This is for CDDA.
 */
int dsa_pauserelease(void)
{
    if (TC_SERVO_search(0)) {
	/* We need this for MP3 and WMA in case when we pause after all 
	 * the file's data is already in..we'll restart at "paused" location
	 * saved in "previous_sector". 
	 */
	end_of_play = 0;
	
	return (1);
    } else {
	return (0);
    }
}



/*
 * 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;           /* # of track info have been read */
    unsigned char data, cmd;
    int i;
    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              */
    int 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   */

/* 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 */
        i = TC_SERVO_process();
        if (i == SERVO_RET_clvok)
            break;
        if (i == SERVO_RET_int)
            return (0);
        if ((i == SERVO_RET_fng) || (i == SERVO_RET_clvng)) {
            CDinfo.type = CD_NODISC;
            return (0);
        }
    }

    /* initialize some CDinfo */
    CDinfo.type = 255;
    CDinfo.firsttrack = 0;
    CDinfo.lasttrack = 0;

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


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

    while (!ltoc_done) {
        VCX_service();
        dly1 = glbTimer;
        do {
            /* Monitor Servo Stability in dsa_ltoc() */
            i = TC_SERVO_process();
            if (i == SERVO_RET_Qcode)
                break;
            if (i == SERVO_RET_int)
                return (0);
            if ((i == SERVO_RET_fng) || (i == SERVO_RET_clvng)) {
                CDinfo.type = CD_NODISC;
                return (0);
            }
        }
        while (1);

	/*OUTOSD(12,"QDATA","QDATA",1);           /* OSD-Q DATA READY */
        for (num = 0; num < 5; num++) {
            test = SERVO_Qarray_new[num];
            Qcode[num * 2] = (unsigned char) ((test >> 8) & 0x00ff);
            Qcode[num * 2 + 1] = (unsigned char) (test & 0x00ff);
        }

        switch ((int) 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 = (unsigned int) bcd2hex[Qcode[SERVO_QPMIN]];
                   tk64_data = Qcode[SERVO_QPSEC];
                   if (tk64_data == 0xa) CDinfo.type = CD_CDI;
                }
                t64r = 1;
                break;

            case 0xA1:
/*              OUTOSD(9,"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 0 
			    /* for single session DATA discs (MP3...) which 
			     * have only one track, depending on the order 
			     * of Q-code, we may not have a chance to set 
			     * tk1_ctl_adr. tk1_ctl_adr can be more reliably
			     * set after all the TOC info has been acquired.
			     */
                            if (Qcode[SERVO_QPOINT] == CDinfo.firsttrack)
                                tk1_ctl_adr = Qcode[SERVO_QCTRADD];
#endif
                            track_rd_num++;
                        }
                }
                break;
            }


            break;

        default:
/*          OUTOSD(11,"JUMP","JUMP",1); /* OSD-TOC JUMP */
            SERVO_near_jump(32, J_BACKWARD);   /* old is 32 , HuaBin */
            break;
        }

	
        if(/*t64r&&t65r&&t66r&&*/(track_rd_num > num_of_track) ){
	    /* set tk1_ctl_adr after getting all toc info */
	   tk1_ctl_adr = pTk[CDinfo.firsttrack-1] >> 24;

	   t64r = t65r = t66r = 0;
           if(num_of_session == 1){
	       if ((tk1_ctl_adr & 0xcf) == 0x01) {
		   CDinfo.type = CD_CDDA;
	       } else if (tk64_data != 0 && 
			  (tk1_ctl_adr == 0x41 || tk1_ctl_adr == 0x61)) {
		   CDinfo.type = CD_VCD;
		   /* Note: Photo-CD will also pass as VCD */
	       } else {
#ifdef DATA_CD
		   if (!tk64_data) CDinfo.type = CD_DATA;
		   else
#endif
		       CDinfo.type = CD_UNKNOWN;
	       }
           }
           if (!multi_session) {
               ltoc_done = 1;
/*             DBG_OSD(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) */

/*
 *    SERVO_stop();
 */

    dsa_mode(MODE_ATTI_REL | MODE_CDROM | MODE_SPEED_NORMAL);

    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 search_timer;


    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)
		return_val = TC_SERVO_process();/* Wait until stop idle */
	    /* Start Servo until Servo on stable */
	    SERVO_mode = Mode_Focusing;
	    SERVO_state = Focus_Para;
	    while (1) {
		microEngine();
		return_val = TC_SERVO_process();
		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 = time & 0x00ff;
	target_sec = time >> 8 & 0x00ff;
	target_min = time >> 16 & 0x00ff;

	search_timer = glbTimer + 5*ONE_SECOND;

	dsa_go_state = DSA_GO_SEARCHING;
	TC_SERVO_search_init();
	TC_SERVO_search_request(0);

	return_val = 1;
	break;

      case DSA_GO_SEARCHING:
	return_val = TC_SERVO_search_request(0);

	if (return_val == 2) {
	    dsa_go_state = DSA_GO_FOUND_TARGET;
	    /*OUTOSD(4,"FOUND","FOUND",1);	/* Found target */
	} 

	check_user_input();	/* derek */

	if(forceDSAabort || (glbTimer > search_timer)) {
	    dsa_go_state = DSA_GO_INIT;
	    return_val = 0;
    	} else {
	    return_val = 1;
	}
	
	break;

      case DSA_GO_FOUND_TARGET:
	servo_info = 0;
	if (CDinfo.type != CD_CDI) {
	    servo_info = (((SERVO_Qarray_new[1] << 8) & 0x00ffff00)
			  | ((SERVO_Qarray_new[2] >> 8) & 0x000000ff));
	} else servo_info = currCDtime >> 8;
	
	r_tmp = bcd2hex[SERVO_Qarray_new[0] & 0x000000ff];
	r_tmp = r_tmp - ((CDinfo.type == CD_CDDA) ? 0 : 1);
	/* Modify by Andy Yam */
	/*
	   servo_info |= (hex2bcd[r_tmp] & 0x0000ff)<<24 |
	   (SERVO_Qarray_new[1]>>8 & 0x0000ff)<<16;
	   */
	servo_info |= (hex2bcd[r_tmp] << 24) & xff000000;

#if 0
	for (r_tmp = 0; r_tmp < 7; r_tmp++)
	    SERVO_Qarray_current[r_tmp] = SERVO_Qarray_new[r_tmp] & 0xffff;
#endif
	/* Modify by Andy Yam */
	last_servo_info = servo_info;
	updateLCDtime();
	OSD_update_info();	/* OSD info needs to update */
	
	dsa_go_state = DSA_GO_INIT;
	return_val = 2;
	break;
    }
    TC_SERVO_process();

    return (return_val);
}


/* Added by Mao Mar-28-2001 for Shutter  */
void Slide_In();
void Open_Shutter();
void Close_Shutter();

void CloseTray()
{
    int ii;
    SET_MOTOR_REV;
    CLEAR_MOTOR_FWD;
    if(share_open_close)
    for (ii = 0; ii < 9000000; ii++);    /* about 200 ms */

}

void OpenTray()
{
    int ii;
    Slide_In();
    CLEAR_MOTOR_REV;
    SET_MOTOR_FWD;
    if(share_open_close)
    for (ii = 0; ii < 9000000; ii++);    /* about 200 ms */

}
void StopTray()
{
    SET_MOTOR_REV;
    SET_MOTOR_FWD;
}
void Slide_In()
{
    int slide_delay;
    if(LIMIT_SW_HIGH){
       Pull_PickUp();
       slide_delay = glbTimer+0x300;
       while(1){
       if(LIMIT_SW_LOW) break;
       if(slide_delay<glbTimer) break;
       };
       Stop_PickUp();
      }
    Close_Shutter();
}
void Open_Shutter()
{
    int i;
    if(use_shutter&&(!shutter_opened)){
       Push_PickUp();
       for(i=0;i<0x20000;i++);
       Stop_PickUp();
    }
    shutter_opened = 1;
}
void Close_Shutter()
{
    int i;
    if(use_shutter&&(shutter_opened)){
       Pull_PickUp();
       for(i=0;i<0x20000;i++);
       Stop_PickUp();
    }
    shutter_opened = 0;
}