dsak.c

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

	    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;
			SERVO_2N_trackjump(0, 64);
			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 = 0;
#ifdef MULTI_SESSION
		pt_B0 = 0;
#endif
		if ((tk1_ctl_adr & 0xcf) == 0x01){
		    CDinfo.type = CD_CDDA;
		    cmdout(0x9021);
		    if(!cdrw_disc)cmdout(0x8d08);
		} 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:
	    SERVO_2N_trackjump(0, 64);
	    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 DONE", 0);
    
    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;


    dsa_go_state = DSA_GO_INIT;
#ifdef SAM_SRV
    if(mp3_service)
       mp3_seek=1;
#endif

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

#ifdef SAM_SRV
    if(mp3_service)
       mp3_seek=0;
#endif
    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:
#ifdef SAM_SRV
	    if(mp3_service)
		mp3_seek=1;
#endif
	    if (!kickfg) {
#ifdef SAM_SRV
		forceDSAabort = 0;
		/*SERVO_sledin();*/
			if(sledin_fg_TRUE){
				CLR_sledin_fg;
	       		/*Command_Out_sam(0x86f);*/
	       		SERVO_sledin();
			}
		    servo_task = SERVO_focus;
		    SERVO_schedule();
		    /* Do not continue if focus failed or user key input */
		    if (!servo_focus_on || forceDSAabort){
		    	if(tasking_fg_FALSE)
					return (0);
			}
		#else
	    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);
		#endif
	}
	SERVO_target_msf = time;

	Do_mute();

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

	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) & 0xff000000;
        for(r_tmp=0; r_tmp<SUBQ_LEN; r_tmp++)
            SERVO_Qarray_current[r_tmp] = SERVO_Qarray_new[r_tmp];

        last_servo_info = servo_info;

        updateLCDtime();
        OSD_update_info();      /* OSD info needs to update */

#ifdef SAM_SRV
        if(mp3_service)
        mp3_seek=0;
#endif
        SERVO_mode = SERVO_PLAY;
        Undo_mute();

	dsa_go_state = DSA_GO_INIT;
	return_val = 2;
	break;
    }

#ifdef SAM_SRV
    if(!mp3_playing)
#endif
    SERVO_service(1);
    return (return_val);
}


#ifdef THREE_CDS
int dsa_get_disc_status(unsigned char *status)
{
    int	tmp;
    int	retry = 2;
    int force_quit;	/* 1: force abort; 0: receive OK		*/

    do {
	trans_dsa(DSA_GET_DISC_STATUS, 0);

	do {
	    force_quit = !receive_dsa_all(0);
	    tmp = (dsa_word >> 8) & 0xff;
	    if ((tmp == SERVO_DISC_STATUS) || force_quit) {
		*status = dsa_word & 0xff;
		return(1);
	    } else
		break;
	} while (1);
    } while (--retry);	/* Retry if we get unexpected result */

    /* Shall never get here! */
    return(0);
}
#endif

#ifdef SONY3D
int dsa_rotate_disk(int direction)
{
    int tmp;
    int rotation;
    int retry = 2;
    int force_quit;	/* 1: force abort; 0: receive OK		*/
    int Timer,Timer1,i;
#ifdef SONY3D
    unsigned char disc_status;
#endif
#ifdef SERVO_7
    /* we have to send a dsa_stop here before rotate. */
    dsa_stop();
#endif        /*SERVO_7 */

#ifdef SONY3D
   if (SERVO_DOWN_HIGH) {
       TRAY_CLOSE;
       while(SERVO_DOWN_HIGH);
       TRAY_STOP;
       process_up_down();
   }

   if (direction) {
       ROTATE_CLOCK_ANTI_MOVE;
   }
   else {
       ROTATE_CLOCK_MOVE;
   }
   Timer = glbTimer;
   while ((glbTimer - Timer) < 20);
   while (SERVO_STSW_HIGH);
   ROTATE_STOP;

   if (direction) {
       ROTATE_CLOCK_MOVE;
   }
   else {
       ROTATE_CLOCK_ANTI_MOVE;
   }
   SERVO_delay_n_ms(2); /*for (i = 0; i < 0x5fff;i++);*/
   ROTATE_STOP;

  if (SERVO_UP_HIGH && !cd_opened) {
       TRAY_CLOSE;
       while(SERVO_UP_HIGH);
       TRAY_STOP;
       process_up_down();
   }

   if (direction) {
        if (cd_disc_slot == 3)
            cd_disc_slot = 1;
        else
            cd_disc_slot++;
   }
    else {
         if (cd_disc_slot == 1)
             cd_disc_slot = 3;
        else
             cd_disc_slot--;
   }

    panel_disc_slot(cd_disc_slot);
    return(1);
#else
    rotation = (direction) ? DSA_ROTATE_ANTI_CLOCKWISE: DSA_ROTATE_CLOCKWISE;

    do {
	trans_dsa(rotation, 0);

	do {
	    force_quit = !receive_dsa_all(0);
	    tmp = (dsa_word >> 8) & 0xff;
	    if ((tmp == SERVO_CAROUSEL_STOPPED) || force_quit) {
		return(1);
	    } else if (tmp == SERVO_CAROUSEL_MOVING) /* Intermediate */
		continue;
	    else
		break;
	} while (1);
    } while (--retry);	/* Retry if we get unexpected result */
#endif

    /* Shall never get here! */
    return(0);
}

#endif



#ifdef SONY3D
int servo_check_up()
{
    unsigned char p;

    p = * (unsigned char *) 0x18000000;
    if (p & 0x02) return(1);
    else return(0);
}

int servo_check_down()
{
    unsigned char p;

    p = * (unsigned char *) 0x18000000;
    if (p & 0x01) return(1);
    else return(0);
}

int servo_check_stsw()
{
    unsigned char p;

    p = * (unsigned char *) 0x18000000;
    if (p & 0x10) return(1);
    else return(0);
}

int servo_check_rssw()
{
    unsigned char p;

    p = * (unsigned char *) 0x18000000;
    if (p & 0x20) return(1);
    else return(0);
}

int servo_check_ior3()
{
    unsigned char p;

    p = * (unsigned char *) 0x18000000;
    if (p & 0x40) return(1);
    else return(0);
}

PRIVATE void searchDisc1(void)
{
    int Timer;

again:
    ROTATE_CLOCK_MOVE;
    Timer = glbTimer;
    while ((glbTimer - Timer) < 20);
    while (SERVO_STSW_HIGH);
    ROTATE_STOP;
    ROTATE_CLOCK_ANTI_MOVE;
    SERVO_delay_n_ms(2); /* for (i = 0; i < 0x5fff;i++); */
    ROTATE_STOP;
    if (!IS_DISC_1)
	goto again;
}

void TRAY_init()
{
    int Timer;

    if(SERVO_CLOSE_HIGH) {
	TRAY_CLOSE;
	while(SERVO_CLOSE_HIGH)
	    microEngine();
	TRAY_STOP;
    }

    if (!IS_DISC_1) {
	if (SERVO_DOWN_HIGH) {
	    process_up_down();
	    TRAY_CLOSE;
	    while(SERVO_DOWN_HIGH);
	    TRAY_STOP;
	    process_up_down();
	}
	searchDisc1();
    }

    if (SERVO_UP_HIGH) {
	process_up_down();
	TRAY_CLOSE;
	while(SERVO_UP_HIGH);
	TRAY_STOP;
	process_up_down();
    }
    cd_disc_slot = 1;
}

PRIVATE void process_eject()
{
    if (TrayStatus == TRAY_OPENING)
    {
        if (SERVO_OPEN_LOW || int_eject)
        {
            TRAY_STOP ;
            TrayStatus = TRAY_OPENED;
            cd_opened = 1 ;
        }
    }
    else if (TrayStatus == TRAY_CLOSING)
    {
        if (SERVO_CLOSE_LOW || int_eject)
        {
            TRAY_STOP;
            TrayStatus = TRAY_CLOSED;
            cd_opened = 0;
        }
    }
}

PRIVATE void process_up_down()
{
    TRAY_OPEN;
    while (SERVO_CLOSE_LOW);
    TRAY_CLOSE;
    while (SERVO_CLOSE_HIGH);
    TRAY_STOP;
}
#endif /* SONY3D */