dsae.c

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

    /* for Ess3721 servo,I do  servo initializtion first,and then set motor
       driver on, so SERVO_close() should be done after SERVO_DSP_init(),
       this can avoid pickup LENS Unstable while turnning on/off power
       very quickly.
    */
    SERVO_DSP_init();
#if (defined MP3_LOGO && defined ENABLE_MP3)
#ifdef CXD3059
	CLEAR_SERVO_MUTE; /* enable cxd3059 audio-dac */
#endif
	    /*moved here from top.c, for slideshow problems due to longjump*/
	play_mp3_logo((int *)mp3logo, T_mp3logo_SZ>>2);
#endif /* MP3_LOGO */
    SERVO_close();

    retry_cnt = 0;

SERVO_ltoc_retry:

    /* Interrupted by user */
    if (SERVO_check_key_new())
	goto ltoc_err_return;

    /* Focus off, sled into inner position to read TOC, and focus again */
    SERVO_all_servo_off();
    SERVO_sledin();

    SERVO_mode = SERVO_TOC;
    servo_task = SERVO_focus;
    SERVO_schedule();

    if (!servo_focus_on) {
	CDinfo.type = CD_NODISC;
	err_code = ERR_TRAYEMPTY;
	goto ltoc_err_return;
    }

    if (retry_cnt >= 2) {
	CDinfo.type = CD_UNKNOWN;
	err_code = ERR_LTOC;
	goto ltoc_err_return;      /* Retried twice and still fails */
    }

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

    for (i = 0; i < szTk; i++)
	pTk[i] = xff000000;
    pt_A0 = pt_A1 = pt_A2 = 0;
    track_rd_num = num_of_track = 0;
    multi_session = 0;
    num_of_session = 1;
#ifdef MULTI_SESSION
    pt_B0 = pt_C0 = 0;
    last_session_msf = 0;
#endif MULTI_SESSION

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

#if defined(CD_TEXT) && !defined(ANTI_SHOCK)
    CD_text_init(1);
#endif
    while (!ltoc_done) {
#ifdef ECHO
        MIC_service();
#endif
	VCX_service();
#ifdef LTOC_TV_CHANGE
	DISP_TV_service();
#endif

	loopcnt++;
	if (loopcnt > 2000) {
	    /*
	     * Servo is going crazy! This rarely happens; however, I have
	     * seen this happened!
	     */
	    goto SERVO_ltoc_retry;
	}

	/* Higher priority command received. Go handle it */
	if ((loopcnt % 8) == 0)
	    if(SERVO_check_key_new()) goto ltoc_err_return;

	timeout = glbTimer + FOUR_SECOND;
	
	do {
	    SERVO_service(1);
	    if (!servo_focus_on || (glbTimer > timeout)) {
                SERVO_CLV_KICK;
		goto SERVO_ltoc_retry;	/* Focus is down or time out, *
					 * do not proceed */
	    }
	    
	    if (SERVO_new_Qcode) {
		SERVO_new_Qcode = 0;
		break;
	    }
	    if ((loopcnt % 8) == 0)
		if (SERVO_check_key_new())
		    goto ltoc_err_return;
	    
#ifdef LTOC_TV_CHANGE
	    DISP_TV_service();
#endif
	    SERVO_focus_monitor();
	    if(servo_focus_drop)   SERVO_fcstry();
    	} while (1);

        switch (SERVO_Qarray_new[SERVO_QTRACK]) {
        case 0x00:
	    switch (SERVO_Qarray_new[SERVO_QPOINT]) {
	    case 0xA0:
		CDinfo.firsttrack = bcd2hex[SERVO_Qarray_new[SERVO_QPMIN]];
		pt_A0_PSEC = SERVO_Qarray_new[SERVO_QPSEC];
		if (pt_A0_PSEC == 0xa)
		    CDinfo.type = CD_CDI;
		pt_A0 = 1;

		break;

	    case 0xA1:
		/*make sure we have read first track info before set pt_A1*/
		if(!pt_A0) break;

		CDinfo.lasttrack =
		    bcd2hex[SERVO_Qarray_new[SERVO_QPMIN]] - 1;

		if (CDinfo.type == CD_CDI)
		    num_of_track = -1;
		else
		    num_of_track =
			CDinfo.lasttrack - CDinfo.firsttrack + 1;
		pt_A1 = 1;
		break;

	    case 0xA2:
		CDinfo.leadout = SERVO_Qarray_new[SERVO_QPMIN]<<16 ;
		CDinfo.leadout |= SERVO_Qarray_new[SERVO_QPSEC]<<8;
		CDinfo.leadout |= SERVO_Qarray_new[SERVO_QPFRAME];
		pt_A2 = 1;
		break;
#ifdef MULTI_SESSION

	    case 0xB0:
		if (pt_B0) break;
		first_session_retry_cnt++;

		if (!((SERVO_Qarray_new[SERVO_QRMIN]==0xff) &&
		      (SERVO_Qarray_new[SERVO_QRSEC]==0xff) &&
		      (SERVO_Qarray_new[SERVO_QRFRAME]==0xff))){
		    multi_session=1;
		    last_session_msf_1=last_session_msf;
		    last_session_msf = SERVO_Qarray_new[SERVO_QRMIN]<<16 ;
		    last_session_msf|= SERVO_Qarray_new[SERVO_QRSEC]<<8;
		    last_session_msf|= SERVO_Qarray_new[SERVO_QRFRAME];
		}
		pt_B0 = 1;
		break;

	    case 0xC0:
		pt_C0=1;
		break;
#endif /*MULTI_SESSION*/

	    default:
		if ((SERVO_Qarray_new[SERVO_QPOINT] < 0xa0) &&
		    (SERVO_Qarray_new[SERVO_QPOINT] > 0x00)) {
		    int trk_index;

		    trk_index =
			bcd2hex[SERVO_Qarray_new[SERVO_QPOINT]] - 1;

		    /*allow toc overriding*/
		    i = (SERVO_Qarray_new[SERVO_QCTRADD] << 24) |
			(SERVO_Qarray_new[SERVO_QPMIN] << 16)|
			(SERVO_Qarray_new[SERVO_QPSEC] << 8)|
			SERVO_Qarray_new[SERVO_QPFRAME];

		    if(pTk[trk_index] != i){
			if (pTk[trk_index] == xff000000) track_rd_num++;

			pTk[trk_index] = i;
			if ((num_of_session==1) &&
			    ((SERVO_Qarray_new[SERVO_QCTRADD] & 0x4f) == 0x01))/*CDDA*/
			    first_session_cdda = 1;

#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 (SERVO_Qarray_new[SERVO_QPOINT] ==
			    CDinfo.firsttrack)
			    tk1_ctl_adr = SERVO_Qarray_new[SERVO_QCTRADD];
#endif
		    }
		}
		break;
	    } /*One Point of a qcode*/

	    if ((pt_A0 && pt_A1 && pt_A2) &&
		(track_rd_num > num_of_track)) {
#ifdef MULTI_SESSION
		if((num_of_session==1) &&
		   ((!pt_C0 && pt_B0)  /*more than two open/close sessions*/
		    || (!first_session_cdda && (CDinfo.firsttrack >1)))){/*two closed sessions*/
		    if (first_session_retry_cnt < 20) { /*11 normally*/
			pt_A0 = pt_A1 = pt_A2 = pt_B0 = pt_C0 =0;

			/* Anti-shock off, brake on, TG up */
			SERVO_tracking_control((AS_ON|BRK_ON|TG_UP),
					       (BRK_ON|TG_UP));

			SERVO_2N_trackjump(0, 64);

			/* Anti-shock off, brake off, TG normal */
			SERVO_tracking_control((AS_ON|BRK_ON|TG_UP),0);

			last_session_msf_1 =last_session_msf=0;
			track_rd_num =0;
			multi_session=0;
			num_of_track =0;
			first_session_cdda = 0;
			for (i = 0; i < szTk; i++)
			    pTk[i] = xff000000;
			break;
		    } else {  /*first session locate error*/
			last_session_msf= last_session_msf_1;
			multi_session=0;
		    }
		}
		track_rd_num =0;
		pt_C0 =0;

		/* if 1st session is CDDA then set disc type
		 * as CDDA, else let last track of last session
		 * decide the CD type
		 */
		tk1_ctl_adr = (first_session_cdda)
		    ? 0x01 : (pTk[CDinfo.lasttrack] >> 24);
#else
		/* set tk1_ctl_adr after getting all toc info */
		tk1_ctl_adr = pTk[CDinfo.firsttrack-1] >> 24;
#endif /* MULTI_SESSION */

		pt_A0 = pt_A1 = pt_A2 = pt_B0 = 0;
		if ((tk1_ctl_adr & 0xcf) == 0x01)
		    CDinfo.type = CD_CDDA;
		else if (pt_A0_PSEC != 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 (!pt_A0_PSEC)
			CDinfo.type = CD_DATA;
		    else
#endif
			CDinfo.type = CD_UNKNOWN;
		}

		if (!multi_session || first_session_cdda){
                        ltoc_done = 1;
		}
#ifdef MULTI_SESSION
		else {
		    return_val = SERVO_go_next_session();

		    if ((return_val ==3 )||
			(return_val ==1 )) { /*due to time out*/
			last_session_msf=last_session_msf_1;
			ltoc_done = 1;
		    } else if (!return_val) {
			goto SERVO_ltoc_retry;
		    } else {
			multi_session = 0;
			loopcnt=0;
			num_of_session++;
			/*debug_osd("SESS ", num_of_session, 7);*/
		    }
		}
#endif MULTI_SESSION
	    }

	    break;

	default:
	    /* Anti-shock off, brake on, TG up */
	    SERVO_tracking_control((AS_ON|BRK_ON|TG_UP),
				   (BRK_ON|TG_UP));

	    if(ess3721_disc_info&0x02) SERVO_2N_trackjump(0, 200);
	    else  SERVO_2N_trackjump(0, 64);

	    /* Anti-shock on, brake off, TG normal */
	    SERVO_tracking_control((AS_ON|BRK_ON|TG_UP), 0 /*AS_ON*/);

            break;
        }
    }	/* end of while(ltoc_done) */

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

    dsa_mode(MODE_ATTI_REL | MODE_CDROM | MODE_SPEED_NORMAL);

    CDinited = 1;

    CPRINTF("LTOC", retry_cnt);

    DISP_cigam(CDinfo.type != CD_CDDA);

    return(1);

ltoc_err_return:
    cd_stop = CDinited = 1;
    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;
    int start_time;


    dsa_go_state = DSA_GO_INIT;
    start_time  = glbTimer+ONE_SECOND;
    do {
        if(servo_task != NULL)   start_time  = glbTimer+ONE_SECOND;
        if((servo_task == NULL)&&(start_time< glbTimer)){
	    start_time  = glbTimer+ONE_SECOND;
	    SERVO_focus_monitor();
	    if(servo_focus_drop)   SERVO_fcstry();
	}

        return_val = dsa_go_step_by_step(time);
#ifdef ECHO
	MIC_service();
#endif
        MP3CDG_service();
    } while (return_val==1);

    VCX_service();

    return ((return_val == 2));
}

int SERVO_dsa_go_state(void)
{
    return (dsa_go_state);
}

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.
 ****************************************************************************/
PRIVATE 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:
	if (!kickfg) {
//	    SERVO_filter_setting();

	    forceDSAabort = 0;
	    SERVO_sledin();
	    servo_task = SERVO_focus;
	    SERVO_schedule();
	    /* Do not continue if focus failed or user key input */
	    if (!servo_focus_on || forceDSAabort)
		return (0);
	}
	SERVO_target_msf = time;

	Do_mute();

	/* For bad discs limit search time..
	 * more consistent than retry limits used before.
	 */
	SERVO_search_timeout =
	    search_timer = glbTimer + 10*ONE_SECOND;

        SERVO_mode = SERVO_SEARCH;
	SERVO_search_init();
	SERVO_search_request(); /* do early request */
	dsa_go_state = DSA_GO_STILL_SEARCHING;

	return_val = 1;
	break;

      case DSA_GO_STILL_SEARCHING:
	return_val = SERVO_search_request();

	if (return_val == 2) dsa_go_state = DSA_GO_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[SERVO_QPOINT] << 16) |
		(SERVO_Qarray_new[SERVO_QRMIN] << 8) |
		    SERVO_Qarray_new[SERVO_QRSEC];
        }
        else
            servo_info = currCDtime >> 8;

        r_tmp = bcd2hex[SERVO_Qarray_new[SERVO_QTRACK]];
        if (CDinfo.type != CD_CDDA)
            r_tmp --;
        servo_info |= (hex2bcd[r_tmp]<<24) & xff000000;
        for(r_tmp=0; r_tmp<SUBQ_LEN; r_tmp++)
            SERVO_Qarray_current[r_tmp] = SERVO_Qarray_new[r_tmp];
#if 0
        updateLCDtime();
        OSD_update_info();      /* OSD info needs to update */
#endif
        SERVO_mode = SERVO_PLAY;
        Undo_mute();

	dsa_go_state = DSA_GO_INIT;
	return_val = 2;
	break;
    }

    SERVO_service(1);
    return (return_val);
}

void SERVO_filter_setting(void)
{
    int i;

    SERVO_port_reset();
#if 1
    for (i = 0; i < (T_filtertbl_SZ/2)/sizeof(unsigned short); i ++) {
	SERVO_send_command_filter(filtertbl[2*i],filtertbl[2*i+1]);
#ifdef ECHO
	MIC_service();
#endif
        risc_sleep_a_bit(MICROSECOND(14)); /*for(j=0;j<0x100;j++);*/
    }
#else
    SERVO_send_command_filter(0x040,0xf00);
    SERVO_send_command_filter(0x040,0x000);
#endif
    for (i = 0; i < (T_dsp_default_SZ/2)/sizeof(unsigned char); i ++) {
       	SERVO_send_command(dsp_default[2*i],dsp_default[2*i+1]);
#ifdef ECHO
	MIC_service();
#endif
        risc_sleep_a_bit(MICROSECOND(14)); /*for(j=0;j<0x100;j++);*/
    }

    return;
}


void Ess3721_reset_start()
{
    SERVO_delay_n_ms(20);
    CLEAR_CTSERVO_DRV_ON;
    SERVO_delay_n_ms(20);
}

void Ess3721_reset_end()
{
    SERVO_delay_n_ms(20);
    SET_CTSERVO_DRV_ON;
    SERVO_delay_n_ms(20);
}
int get_dsa_go_state()
{
    return (dsa_go_state);
}
int Stream_type_return()
{
    if(STREAM_type&(MP3_ID|JPEG_ID|MP3CDG_ID)) return 1;
      else return 0;
}
int servo_task_null()
{
    if(servo_task == NULL) return 1;
     else return 0;
}
void set_PBC_off()
{
    if(PBC_on) {
     assign_key = PBC_KEY;
     }
}