sony_servo.c

索尼CX3068VCD伺服的随身听

				/* Go back to previous position after emergency handling */
	//			pcm_mute();
				#ifdef NEW_DSP
				     regs16->Game_TLB_23=0x15;
			    #else
				     pcm_mute();
			    #endif
    
				found = SERVO_search();
				if (!found && !servo_focus_on) {
					SERVO_stop();
					break;
				}

				#ifdef NEW_DSP
				     regs16->Game_TLB_23=0x0;
			    #else
				     pcm_restore();
			    #endif 
			
			//	pcm_restore();
			}
			/* Update VFD display for any new information during playing.	  */
			/* Update the Q-sub data to SERVO_Qarray_current from		  */
			/* SERVO_Qarray_new, for the RECOVER use if any lost of the track */
			if (SERVO_new_Qcode && kickfg) {
				dsa_recv.word=DSR_FOUND;  ///kzy add 5/23
				SERVO_new_Qcode = 0;
				if ((SERVO_Qarray_new[SERVO_QCTRADD] & 0xf) == 0x01) {
				int prev_time;
					/* Keep out of lead out area */
					if (SERVO_Qarray_new[SERVO_QTRACK] == 0xaa) {
											dsa_recv.byte[DSA_PAR] = 0xaa;
						CDU_CDactTit();
											break;
					}
					/* abnormal Q_time */
					prev_time = (SERVO_Qarray_current[SERVO_QPMIN] << 16) |
								(SERVO_Qarray_current[SERVO_QPSEC] << 8) |
								SERVO_Qarray_current[SERVO_QPFRAME];
					if ((SERVO_cdtime < prev_time) ||
						(SERVO_cdtime > adjCDtime(prev_time, 0x50, 1)))
					{
						int tmp,found;

						tmp = adjCDtime(prev_time, 0x30, 1);
						target_min   = (tmp>>16) & 0xff;
						target_sec   = (tmp >>8) & 0xff;
						target_frame = tmp & 0xff;

					    #ifdef NEW_DSP
					       regs16->Game_TLB_23=0x15;
					    #else 
						   pcm_mute();
					    #endif
      

					//	pcm_mute();
						
						found = SERVO_search();
						if (!found && !servo_focus_on) {
							SERVO_stop();
							break;
						}
						#ifdef NEW_DSP
     						 regs16->Game_TLB_23=0x0;
					    #else
						     pcm_restore();
					    #endif
     
//						pcm_restore();
					}

					if (SERVO_Qarray_current[SERVO_QTRACK] != SERVO_Qarray_new[SERVO_QTRACK])
					{   /* Track Change */
						for (num = 0; num < SUBQ_LEN; num++)
							SERVO_Qarray_current[num] = SERVO_Qarray_new[num];
						SERVO_update_track = 1;
						SERVO_update_second = 1;
						/* Take care about lead out ! */
						r_tmp = SERVO_Qarray_new[SERVO_QTRACK];
						r_tmp = CVbcd2hex[r_tmp];
						r_tmp = r_tmp - ((CDinfo.type == CD_CDDA) ? 0 : 1);
						servo_info = CVhex2bcd[r_tmp] << 24;
						r_tmp = SERVO_Qarray_new[SERVO_QPOINT] << 16;
						servo_info += r_tmp;
						//////// added by Wenxin //////////////////
						dsa_recv.byte[DSA_PAR] = CVbcd2hex[SERVO_Qarray_new[SERVO_QTRACK]];
						#ifdef ENABLE_ESP
						esp_track_change(dsa_recv.byte[DSA_PAR]);
						#endif
						CDU_CDactTit();
						///////////////////////////////////////////
					}
					else {	/* Track Keep */
#if 0	// Wenxin -- never used variable
						static int check_time = 0;
#endif
						int prev_cdtime;
						/* Check for subQ-code. If it doesn't advance *
						* in 2 seconds, do a jump track to skip it */
						prev_cdtime = (SERVO_Qarray_current[SERVO_QPMIN] << 16) |
									  (SERVO_Qarray_current[SERVO_QPSEC] << 8) |
									  SERVO_Qarray_current[SERVO_QPFRAME];
						/* Do NOT copy backward-going subQ */
						if (SERVO_cdtime > prev_cdtime) {
							for (num = 0; num < SUBQ_LEN; num++)
								SERVO_Qarray_current[num] = SERVO_Qarray_new[num];
							/* update index */
							servo_info &= 0xff00ffff;
							r_tmp = SERVO_Qarray_new[SERVO_QPOINT] << 16;
							servo_info += r_tmp;
							/* check necessary for update time */
							if ((servo_info & 0xff) != SERVO_Qarray_new[SERVO_QPSEC]) {	//chu use abs. time !!
								r_tmp = SERVO_Qarray_new[SERVO_QPMIN] << 8;				//chu
								r_tmp += SERVO_Qarray_new[SERVO_QPSEC];					//chu
								servo_info &= 0xffff0000;
								servo_info += r_tmp;
								SERVO_update_second = 1;
#if 1
								if( (sysMode == SYS_PLAY) /*&& (VCD_ver != VCD30)*/ ){
									if( !jump_flag && !ls_pause && !cd_pause && !SERVO_Qarray_new[6] &&
										!servo_focus_drop && !servo_gfs_drop && !servo_subq_drop 
#ifdef USE_OSD_FUNC		//chu
										&& !slow_state
#endif										
									  )
									  {
// sz added Jul 3(rd) -> goto track => toby
										if( CVbcd2hex[SERVO_Qarray_new[SERVO_QTRACK]] != cdm.trk){			
											dsa_recv.byte[DSA_PAR] = CVbcd2hex[SERVO_Qarray_new[SERVO_QTRACK]];
											#ifdef ENABLE_ESP 
												esp_track_change(dsa_recv.byte[DSA_PAR]);
											#endif
											CDU_CDactTit();
										}
// the end									  
										if( CVbcd2hex[SERVO_Qarray_new[SERVO_QPMIN]] != cdm.min){
											dsa_recv.byte[DSA_PAR] = CVbcd2hex[SERVO_Qarray_new[SERVO_QPMIN]];
											CDU_CDabsMin();
										}
										dsa_recv.byte[DSA_PAR] = CVbcd2hex[SERVO_Qarray_new[SERVO_QPSEC]];
										CDU_CDabsSec();
/////////// Added by Wenxin /////////////////
										if ( cd_ab_flag &&
											(CVbcd2hex[SERVO_Qarray_new[SERVO_QPMIN]]*60*75+
											 CVbcd2hex[SERVO_Qarray_new[SERVO_QPSEC]]*75+
											 CVbcd2hex[SERVO_Qarray_new[SERVO_QPFRAME]] >= msf2frm(&ab1)) )
										{
											MSF	temp;
											debugprint("CDU_CDfound",cd_ab);
											temp.min = ab0.min;
											temp.sec = ab0.sec;
											temp.frm = ab0.frm;
											pcm_mute();
											Cdm_gotoMSF( &temp );
											CDU_CDfound();
										}
/////////// end fo added //////////////////////
									  }
								}
#endif
							}
						}
					}
				}
			}
			break;
		case SERVO_PAUSE:
				if (SERVO_new_Qcode && kickfg) {
				pcm_mute();
				Do_mute();
			      flag=SERVO_Seek(pause_min,pause_sec,pause_frame);
				  SERVO_mode=SERVO_PAUSE;
					if(!flag && !servo_focus_on)
						{
							SERVO_stop();
							dsa_recv.word=DSR_ERROR;
										}
                                     }	
			break;
		case SERVO_RELEASEPAUSE:
			/*flag=SERVO_Seek(pause_min,pause_sec,pause_frame);
	        if (!flag && !servo_focus_on)
    	        {
        	    	SERVO_stop();
            		dsa_recv.word=DSR_ERROR;
 	     		}
 	     	else*/ SERVO_mode=SERVO_PLAY;
			break;
		case SERVO_SEARCH:
			break;
		case SERVO_TRAY:
			if(servo_pres_m == OPEN_10)
				{	
		    		if ((glbTimer - open_delay) > T300MS) 
		    		{
						if (SERVO_OPEN_HIGH) {	
							SERVO_close();
//							regs16->Control_Status = 0xff;
							FIX_KYopcl();	// sz 7/12 => tray moving inside 
											}
						}										
				} 
		     		break;	   
		     
		default:
			break;
	}
	enable_reset_timer();
	return;
}




/************************************************************************
 * SEND COMMANDS TO DSP                                                 *
 ************************************************************************/
/*
 * Send 1 command(4 bits) to DSP
 */
void SERVO_send_one_command(unsigned char cmd1)
{
    int num1 = 0;
    unsigned int cmd;

    for (num1 = 0; num1 < 4; num1++) {
		cmd = cmd1;
		CLEAR_SERVO_CLOCK;
		if (cmd & 0x0001)
		    SET_SERVO_DATA;
		else
		    CLEAR_SERVO_DATA;
		cmd1 >>= 1;
		SERVO_short_delay(2);
		SET_SERVO_CLOCK;
		SERVO_short_delay(2);	
	}
}

void SERVO_send_one_command1(unsigned char cmd1)
{
    int num1 = 0;
    unsigned int cmd;
    volatile int i;

    for (num1 = 0; num1 < 4; num1++) {
		cmd = cmd1;
		CLEAR_SERVO_CLOCK;
		if (cmd & 0x0001)
		    SET_SERVO_DATA;
		else
		    CLEAR_SERVO_DATA;
		cmd1 >>= 1;
		for (i=0; i<3; i++);
		SET_SERVO_CLOCK;
		for (i=0; i<3; i++);
   		}
}

void SERVO_send_command(int num, unsigned int data)
{
    int nump;
    int interrupt_backup;

    interrupt_backup = enable_interrupt;
	enable_interrupt = 0;
    for (nump = 0; nump < num; nump++) {
		SERVO_send_one_command((unsigned char)(data & 0xf));
		data >>= 4;
    	}
    	
    CLEAR_SERVO_XLAT;
	SERVO_short_delay(2);
    SET_SERVO_XLAT;
	SERVO_short_delay(2);	
	enable_interrupt = interrupt_backup;
}

void SERVO_send_command_no_latch(int num, unsigned int data)
{
    int nump;
    int interrupt_backup;
	interrupt_backup = enable_interrupt;
	enable_interrupt = 0;
    for (nump = 0; nump < num; nump++) {
		SERVO_send_one_command((unsigned char)(data & 0xf));
		data >>= 4;
    	}
	enable_interrupt = interrupt_backup;
	SERVO_short_delay(2);
}

void SERVO_send_command_no_latch1(int num, unsigned int data)
{
    int nump;
    volatile int i;

	enable_interrupt = 0;
    for (nump = 0; nump < num; nump++) {
		SERVO_send_one_command1((unsigned char)(data & 0xf));
		data >>= 4;
    	}
	for (i=0; i<5; i++);
	enable_interrupt = 1;
}

void SERVO_send_8X_command(unsigned char soct, int mode)
{
    unsigned int command;

    command = 0x81170800;
    if (soct)
    	command |= (0x20 << 16);
    if (mode)
		command |= (0x800 << 16);
    SERVO_send_command(8, command);
}








/************************************************************************
 * SET FILTERS                                                          *
 ************************************************************************/
#ifdef USE_SONY_3068  		// sz 8/18
unsigned int filtertbl[] = {
    0x340080, 0x340504, 0x341120, 0x34400c,/*b*/
    0x34436a, 0x34444a/*7*/, 0x344572/*d*/
};  
#else
unsigned int filtertbl[] = {
    0x340080, 0x340504, 0x341120, 0x34400b,
    0x34436a, 0x344447, 0x34457d
};  
#endif
void SERVO_filter_setting(void)
{
    int i;

    for (i=0; i<7; i++)
		SERVO_send_command(6, filtertbl[i]);
}






/************************************************************************
 * SERVO MUTE COMMANDS                                                  *
 ************************************************************************/
void Do_mute()
{
    servo_mute_on = 1;
    SERVO_send_command(6, 0xA20000);
}

void Undo_mute()
{
    servo_mute_on = 0;
    SERVO_send_command(6, 0xA00000);
}




/************************************************************************
 * AVERAGING                                                            *
 ************************************************************************/
void SERVO_avrg_ctl(void)
{
    SERVO_send_command(6, 0x380800);
    SERVO_delay_n_ms(8);
    SERVO_send_command(6, 0x382000);
    SERVO_delay_n_ms(8);
    SERVO_send_command(6, 0x380010);
    SERVO_delay_n_ms(8);
    SERVO_send_command(6, 0x388000);
    SERVO_delay_n_ms(8);
    SERVO_send_command(6, 0x38148a);
    SERVO_delay_n_ms(8);
    SERVO_send_command(2, F_OFF);
    SERVO_delay_n_ms(5);
}




/*
 * Return 1 if FOK is HIGH for most of the 10ms period
 * Otherwise return 0
 */
int check_focus_ok()
{
    int high_count = 0, low_count = 0;

    /* For the next 10 ms, sample FOK and record number of HIGHs and LOWs */
	SERVO_start_timer(10);
	while (SERVO_check_timer()) {
		SERVO_Wait750();
		if (SERVO_FOK_HIGH)
		    high_count++;
		else
		    low_count++;
		SERVO_Idle();  // add for esp seed6
   		}
	if ((high_count >> 4) > low_count)
		return(1);
	else {
/*		IoPrint2("BAD check_focus_ok %d %d\n",high_count,low_count); */
		return(0);
		}
}




/************************************************************************
 * SLED IN/OUT                                                          *
 ************************************************************************/
/*
 * Pulling in SLED head to roughly around the TOC region.
 */
extern void Dsa_Idle();
extern void SERVO_close_shutter();
void SERVO_sledin()
{
	int timeout;
    IoPrint1("SERVO_sledin %d\n",glbTimer);
    servo_pres_m = SLED_10;
#ifdef USE_SONY_3068			// sz 8/18
	SERVO_send_command(2, 0x33);
#endif
    SERVO_send_command(2, TOFF_SREV);		/* sled rev */
	timeout  = glbTimer + T12SECOND;
    while (glbTimer < timeout) {
		SERVO_delay_n_ms(2);
		enable_interrupt = 0;
		SERVO_send_command_no_latch(2, 0x30);	/* read SENS for SSTP */
/* --white
#ifdef MALATA_ALL_IN_ONE_BOARD
		if (!SERVO_SENS_HIGH)
#endif
#ifdef LS188_PUBLIC_BOARD_A1
		if (SERVO_SENS_HIGH)
#endif
*/
		#ifdef ENABLE_STD_SOL
			if (!SERVO_SENS_HIGH)
		#else
			if (SERVO_SENS_HIGH)
		#endif		
			break;
		if ( SERVO_SENS_LOW ) break ;		// sz 8/22
    	enable_interrupt = 1;
		SERVO_Idle();
    	}
   	enable_interrupt = 1;
#ifdef USE_SONY_3068			// sz 8/18
	SERVO_send_command(2, 0x30);
#endif
    SERVO_TRK_SLD_OFF;
    zputs("SLEDIN DONE\n");
#ifdef USE_SONY_3068_WITH_SHUTTER			// sz 8/18
    SERVO_close_shutter();
#endif
}

/*
 * subroutine to stop the servo, & move the SLED to the normal position
 */
int SERVO_stop(void)
{
    int brake_start_time, brake_time;

    IoPrint1("SERVO_stop %d\n",glbTimer);
    debugprint("SERVO_stop\n",glbTimer);
    Do_mute();
//	SERVO_mode = SERVO_STOP;
	SERVO_mode=SERVO_IDLE;
    /* In case we quit during focusing */
    SERVO_AUTOSEQ_CANCEL;

    if (servo_focus_on) {
    	IoPrint1("SERVO_stop servo_focus_on %d\n",glbTimer);
        debugprint("SERVO_stop servo_focus_on \n",glbTimer);        
		servo_focus_on = 0;
		servo_sys_timer = T2SECOND;
		SERVO_CLV_BRK;
		brake_start_time = glbTimer;
		while (servo_sys_timer) {
		    if (!check_focus_ok()) {
				/* All servo off */
				SERVO_all_servo_off();
				SERVO_delay_n_ms(2000);
				goto brake_done;
			    }
			SERVO_send_command_no_latch(2, 0xe0);
		    if (SERVO_SENS_LOW) {
				break;
				}
			SERVO_Idle();		
			}
		/* Set a minimum braking time to brake on bad disc */
		IoPrint1("SERVO_stop end systimer disk %d\n",servo_sys_timer);
                debugprint("SERVO_stop end systimer disk \n",servo_sys_timer);
		if (glbTimer < brake_start_time + T80MS) {
		    while (glbTimer < brake_start_time + T200MS)
		    {
			SERVO_Idle();
		    };
			}
/*		brake_time = (glbTimer - brake_start_time)*10; */
		brake_time = (glbTimer - brake_start_time)*5;	
		SERVO_TRK_SLD_OFF;
		SERVO_FOCUS_OFF;
		SERVO_delay_n_ms(brake_time);
		SERVO_all_servo_off();
		SERVO_delay_n_ms(500);	//chu some more delay.
    	} 
	else if (kickfg) {
    	IoPrint1("SERVO_stop kickfg %d\n",glbTimer);
		/* All servo off */
		SERVO_all_servo_off();
		SERVO_delay_n_ms(2000);
    	}else SERVO_all_servo_off();		// sz 8/29

brake_done: