dt_utility.c

最新MTK手机软件源码

				/* open successully, store the file_handle, filename, 
					and folder for furthur write and close */
				DT_PTR->fd[0] = file_handle;
				DT_PTR->data_folder = app_type;
				
				DT_PTR->downloadFilename = (kal_wchar*)get_ctrl_buffer(FS_MAX_PATH);
				kal_mem_cpy(DT_PTR->downloadFilename, full_name, FS_MAX_PATH);
				
				//start the guard time
				dt_start_data_download_timer_hdlr();
			}
			break;
		}
		/****************CLOSE FILE *****************/
		case DT_FS_CLOSE:
		{
		  	/* check if the stored file_handle valid */
			if ((DT_PTR->fd[0] <0 ) ||(DT_PTR->fd[0] == 0))
			{
		  		kal_trace(TRACE_GROUP_4, DT_CLOSE_FILE_FAIL);
   				DT_PTR->cmee_err = DT_ERR_UNKNOWN;		 		
		  		return KAL_FALSE;
			}
			else
			{
				/* clear data download timer*/
				dt_clear_download_timer();

				/* close the file */
				file_handle = DT_PTR->fd[0];
				ret_v = FS_Close(file_handle);
				kal_trace (TRACE_GROUP_4, DT_FS_ACCESS, DT_FS_CLOSE, ret_v);
				
				/* clear the stored infomation */
			  	DT_PTR->fd[0] = 0;
			  	DT_PTR->data_folder= 0;
				if(DT_PTR->downloadFilename!=NULL)
				{
					free_ctrl_buffer(DT_PTR->downloadFilename);
					DT_PTR->downloadFilename = NULL;
				}
				//mtk00924_051021: send OK from L4C				
				/* sent "OK" to DTE after close the file */
      				//dt_result_code_fmttr (DT_RCODE_OK, DT_NO_ERR);
			}
		  	break;
	  	}
		/****************READ*****************/
		case DT_FS_READ:
		{
			kal_bool ret_val;
			file_handle = FS_Open(full_name, FS_READ_ONLY|FS_OPEN_NO_DIR);

			if (file_handle < 0)
			{
				kal_trace (TRACE_GROUP_4, DT_FS_ACCESS, DT_FS_OPEN, file_handle);
				DT_PTR->cmee_err = DT_ERR_OPEN_FILE_FAILURE;													   
				return KAL_FALSE;
			}
			else
			{
				/* store infomation for FS_READ*/
				DT_PTR->fd[0] = file_handle;
				
				DT_PTR->data_folder = app_type;
				DT_PTR->printingDownloadData_loopCount = 0;
				/* read data from file and print to PC*/
				ret_val=(kal_bool)dt_eq_fs_read_req();
				return ret_val;
			}
			break;
		  }
		 /****************WRITE*****************/
		 case DT_FS_WRITE:
		 {
			kal_uint32 len;
		 	/* check if the stored file_handle valid */
			if ((DT_PTR->fd[0] <0 ) ||(DT_PTR->fd[0] == 0))
			{
   				DT_PTR->cmee_err = DT_ERR_UNKNOWN;		 		
		 		return KAL_FALSE;
			}
			else
			{
				file_handle = DT_PTR->fd[0];
				dt_start_data_download_timer_hdlr();
			  	ret_v = FS_Write(file_handle,(kal_uint8 *)data,data_len,&len );
			  	if((data_len != len) || (ret_v != FS_NO_ERROR))
			  	{
			  		kal_trace (TRACE_GROUP_4, DT_FS_ACCESS, DT_FS_WRITE, ret_v);
				  	dt_data_download_error_hdlr();
   					DT_PTR->cmee_err = DT_ERR_UNSPECIFIED;		 		
					kal_print("Write FILE Fail!");
					return KAL_FALSE;
			  	}
			}
			break;
		  }
		/***************DELETE******************/
		  case DT_FS_DELETE:
	  	  {
			/* delete file directly from File System */	  	  	
			ret_v = FS_Delete(full_name);
			kal_trace (TRACE_GROUP_4, DT_FS_ACCESS, DT_FS_DELETE, ret_v);
			
			if(ret_v == FS_NO_ERROR) 
			{
      				dt_result_code_fmttr (DT_RCODE_OK, DT_NO_ERR);
				return KAL_TRUE;
			}
			else 
			{
      				dt_result_code_fmttr (DT_RCODE_ERROR, DT_ERR_UNSPECIFIED);			
				return KAL_FALSE;
			}
	 	  	break;
		  }
		/***************LIST FILEs in FOLDER ******************/
		  case DT_FS_DIR:
		  {
			FS_DOSDirEntry fileinfo;			
		   	kal_wchar *filename = NULL;			
			kal_uint8 *outputfile;
		      	kal_uint8 buffer[DT_MAX_DATA_OUTPUT_QUEUE_LENGTH];
		      	kal_uint16 string_length;
   			kal_uint16 sub_length;
		      	kal_uint8 i;
		      
			ret_drv = FS_GetDrive(FS_DRIVE_V_NORMAL, 2, FS_ONLY_ALT_SERIAL);
			if(!((ret_drv>='A')&&(ret_drv<='Z'))) 
			{
				ret_drv = FS_GetDrive(FS_DRIVE_V_REMOVABLE, 1, FS_NO_ALT_DRIVE);
				if(!((ret_drv>='A')&&(ret_drv<='Z'))) 
				{	
   					DT_PTR->cmee_err = DT_ERR_UNSPECIFIED;		 		
					return KAL_FALSE;
				}
			}
			switch(app_type)
			{
				case DT_IMAGE:
					kal_sprintf((char*)buf, "%c:\\Images\\?*.*", ret_drv);
           				break;
				case DT_IMELODY:
					kal_sprintf((char*)buf, "%c:\\Audio\\?*.imy", ret_drv);
	        			break;
				case DT_SOUND_OTHER:
					kal_sprintf((char*)buf, "%c:\\Audio\\?*.mid", ret_drv);
	        			break;
				default:
   					DT_PTR->cmee_err = DT_ERR_UNKNOWN;		 		
					return KAL_FALSE;
			}
			dt_ascii_to_ucs2( buf, UCS2_buf );

	 		filename = (kal_wchar*)get_ctrl_buffer(FS_MAX_PATH);
			file_handle = FS_FindFirst(UCS2_buf, 0, 0, &fileinfo, filename, FS_MAX_PATH);  	
			if(file_handle>=0)
			{				
				outputfile= get_ctrl_buffer(FS_MAX_PATH*2+1);
				ret_v = FS_NO_ERROR;
	   			while(ret_v==FS_NO_ERROR)
	   			{
	   				/* If it's not a Directory and not Hidden */
	   				if( (fileinfo.Attributes & (FS_ATTR_DIR|FS_ATTR_HIDDEN))==0)
					{	
		   				/* +EIMG, +EMDY print reverse UCS2 to PC suite: "41004200..." */
						dt_print_hex_value((kal_uint8*)filename, outputfile);

#if 1
				 		/* Begin :
				 		this part of codes is to seperate the output filename (might be upto 1040 bytes) 
					 	so it can fit to RMMI's output queue */
					  	switch(app_type)
					  	{
							case DT_IMAGE:
	 	            					kal_sprintf((char *)buffer, "%c%c+EIMG: \"", DT_PTR->s_reg.s3, DT_PTR->s_reg.s4);
	 	            					break;
							case DT_IMELODY:
							case DT_SOUND_OTHER:
	 	            					kal_sprintf((char *)buffer, "%c%c+EMDY: \"", DT_PTR->s_reg.s3, DT_PTR->s_reg.s4);
	 	            					break;
						}
		          	 		dt_write_to_uart((kal_uint8 *)buffer, (kal_uint16)strlen ((char *)buffer), KAL_FALSE);
		                 		i=0;
		       	         	string_length = strlen((char*)outputfile);
				   		 while((string_length-i*500)>0) //the output of filename is not finished 
				   		 {
				   		 	/* determine "sub_length" which the length of sub string each time we print out. */
				   		 	if((string_length-i*500)>=500)
				   		 		sub_length = 500;	//max sub length
				   		 	else
				   		 		sub_length = string_length-i*500;
				   		 	
				   		 	kal_mem_cpy(buffer, outputfile+i*500, sub_length);
							buffer[sub_length]='\0';
					         	dt_write_to_uart((kal_uint8 *)buffer, sub_length, KAL_FALSE);	         	 
							i++;
				   		 }
			         	 	 kal_sprintf((char *)buffer, "00\"%c%c", DT_PTR->s_reg.s3, DT_PTR->s_reg.s4);
				          	 dt_write_to_uart((kal_uint8 *)buffer, (kal_uint16)strlen ((char *)buffer), KAL_FALSE);
						/* End */
#else
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
#endif
					}							   				
   					ret_v = FS_FindNext(file_handle, &fileinfo, filename, FS_MAX_PATH);   					
   					
	   			}
	   			if(outputfile!=NULL)	
	   				free_ctrl_buffer(outputfile);
			}
			
	   		FS_FindClose(file_handle);
			if(filename!=NULL)	free_ctrl_buffer(filename);
      			dt_result_code_fmttr (DT_RCODE_OK, DT_NO_ERR);
			return KAL_TRUE;
		  	break;
		 }
		 default:	//unknown operation
   			DT_PTR->cmee_err = DT_ERR_UNKNOWN;		 		
		 	return KAL_FALSE;

   	}

#endif /* __FS_ON__*/
#endif /*(defined(__SLIM_AT__) || defined( __EM_AT_ONLY__))*/
   	return KAL_TRUE;
  
}
  
/*****************************************************************************
* FUNCTION
*  dt_eq_fs_efsl_list
*
* DESCRIPTION
*  to format the +EFSL result code and write to UART
*
*****************************************************************************/
void dt_eq_fs_efsl_list(kal_wchar* filename, FS_DOSDirEntry* fileinfo)
{
#if !(defined(__SLIM_AT__) || defined( __EM_AT_ONLY__))
	kal_uint8 *outputfile = NULL;
   	kal_uint8 buffer[DT_MAX_DATA_OUTPUT_QUEUE_LENGTH];
   	kal_uint16 string_length;
   	kal_uint16 i;
   	kal_uint16 sub_length;

   	outputfile= (kal_uint8*)get_ctrl_buffer(FS_MAX_PATH*2+1);

	switch(DT_PTR->char_set)
	{
		case DT_CHSET_IRA:
			dt_ucs2_to_ascii(filename, outputfile);
			break;
	   	case DT_CHSET_UCS2:
	 	default:
			dt_unicode_to_string((kal_uint8*)filename, outputfile);
	 		/*
			rmmi_byte_order_reverse((kal_uint8*)filename, FS_MAX_PATH);
			rmmi_print_ucs2( (kal_uint8*)filename, outputfile);
			*/
	}
		   		
	/* Following part of codes is to seperate the output filename (might be upto 1040 bytes) 
	 so it can fit to RMMI's output queue */
	kal_sprintf((char *)buffer, "%c%c+EFSL: \"",DT_PTR->s_reg.s3, DT_PTR->s_reg.s4);
	dt_write_to_uart((kal_uint8 *)buffer, (kal_uint16)strlen ((char *)buffer), KAL_FALSE);
	i=0;
	string_length = strlen((char*)outputfile);
	 while((string_length-i*500)>0) //the output of filename is not finished 
	 {
	 	/* determine "sub_length" which the length of sub string each time we print out. */
	 	if((string_length-i*500)>=500)
	 		sub_length = 500;	//max sub length
	 	else
	 		sub_length = string_length-i*500;
		   		 	
	 	kal_mem_cpy(buffer, outputfile+i*500, sub_length);
		buffer[sub_length]='\0';
	      	dt_write_to_uart((kal_uint8 *)buffer, sub_length, KAL_FALSE);	         	 
		i++;
	 }
	 kal_sprintf((char *)buffer, "\", %u, %d%c%c", fileinfo->FileSize, fileinfo->Attributes, DT_PTR->s_reg.s3, DT_PTR->s_reg.s4);
	 dt_write_to_uart((kal_uint8 *)buffer, (kal_uint16)strlen ((char *)buffer), KAL_FALSE);

	if(outputfile!=NULL)
		free_ctrl_buffer(outputfile);
#endif	
}

  
/*****************************************************************************
* FUNCTION
*  l4c_eq_fs_efsl_next
*
* DESCRIPTION
*  to search for the next file for +EFSL
*
*****************************************************************************/
void dt_eq_fs_efsl_next(void)
{
#if !(defined(__SLIM_AT__) || defined( __EM_AT_ONLY__))
   	kal_int32  ret_v;
   	kal_wchar *filename = NULL;
  	FS_DOSDirEntry fileinfo;
	filename = (kal_wchar*)get_ctrl_buffer(FS_MAX_PATH);

	while(1)
	{
		 ret_v = FS_FindNext(DT_PTR->fd[1], &fileinfo, filename, FS_MAX_PATH);
		 if (ret_v != FS_NO_ERROR)
		 {

			FS_FindClose(DT_PTR->fd[1]);
			DT_PTR->fd[1] = 0;
        		dt_result_code_fmttr (DT_RCODE_OK, DT_NO_ERR);
		 	break;
		 }

		 // print "+EFSL" to PC
		 dt_eq_fs_efsl_list(filename, &fileinfo);
		 // UART is busy, return first, continue after receive UART_READY_TO_WRITE_IND 
		//if(DT_PTR->uart_stop_send_flag & (0x01 << 0))
		if(DT_PTR->uart_stop_send_flag == KAL_TRUE)
			break;	
	}	
	
  	if(filename!=NULL)	free_ctrl_buffer(filename);
  	return;
#endif  	
}


//#endif /*DATA_DOWNLOAD*/

//#ifdef DATA_DOWNLOAD
//#if !(defined(__SLIM_AT__) || defined( __EM_AT_ONLY__))

//this function is using to guard the data download, when open file but no any resonse
void dt_start_data_download_timer_hdlr ()
{ 
	dt_clear_download_timer();
   	DT_PTR->event_id[1] = evshed_set_event (DT_PTR->event_scheduler_ptr,
					      (kal_timer_func_ptr)dt_data_download_error_hdlr,
					            NULL, DT_DOWNLOAD_ERROR_TIMER * KAL_TICKS_100_MSEC);
}


void dt_resume_download()
{ 
	dt_clear_download_timer();
	dt_eq_fs_read_req();
	return; 
}

void dt_data_download_error_hdlr ()
{
   
	FS_HANDLE file_handle;
//   	kal_wchar * full_name;
	kal_int32 ret_v;
   	/* clear download timer */
	dt_clear_download_timer();

   	/* mtk00714: L4C_PTR->downloadFullpath is set by +EFSF=2,<folder> */
   	/* we have to clear the stored information after timeout */
      	if(DT_PTR->downloadFullpath!=NULL)
	{
		/* clear stored L4C_PTR->downloadFullpath */
		free_ctrl_buffer(DT_PTR->downloadFullpath);
		DT_PTR->downloadFullpath=NULL;
		l4c_set_download_path(DT_PTR->downloadFullpath);
      	}
	//dt_clear_rename_path();
		/* check if the stored file_handle valid */
		if ((DT_PTR->fd[0] <0 ) ||(DT_PTR->fd[0] == 0))
			{
	     		return;
			}
	  	else
	  	{
			/* close the file */
			file_handle = DT_PTR->fd[0];
			ret_v = FS_Close(file_handle);
			kal_trace(TRACE_GROUP_4, DT_FS_ACCESS,DT_FS_CLOSE,ret_v);
//#ifndef FMT_NOT_PRESENT 				
			/* delete the file in FS */
			 if(DT_PTR->downloadFilename!=NULL)
			 {
				ret_v = FS_Delete((kal_wchar *)DT_PTR->downloadFilename);
				kal_trace(TRACE_GROUP_4, DT_FS_ACCESS,DT_FS_DELETE, ret_v);
			 	free_ctrl_buffer((kal_wchar *)DT_PTR->downloadFilename);
			 	DT_PTR->downloadFilename = NULL;
			 }
//#else //mtk00924_051021: No FMT presented, can be marked
//			/* delete the file in FS */
//			if(DT_PTR->data_folder==DT_APP_UNKNOWN)
//			{
//			  	if(DT_PTR->downloadFilename!=NULL)
//			  	{
//						FS_Delete((kal_wchar *)DT_PTR->downloadFilename);
//			  			free_ctrl_buffer((kal_wchar *)DT_PTR->downloadFilename);
//			  			DT_PTR->downloadFilename = NULL;
//			  	}
//			}
//			else
//			{
//				full_name = get_ctrl_buffer(50*sizeof(kal_wchar));
//	   		  	switch(DT_PTR->data_folder)
//			  	{
//					case L4C_IMELODY:
//						kal_wsprintf(full_name, "%w\\%w", DT_IMELODY_DIR, (kal_wchar *)DT_PTR->data_filename);
//						break;
//					case L4C_SOUND_OTHER:
//						kal_wsprintf(full_name, "%w\\%w", DT_SOUND_OTHER_DIR, (kal_wchar *)DT_PTR->data_filename);
//						break;	
//					case L4C_IMAGE:
//						kal_wsprintf(full_name, "%w\\%w", DT_IMAGE_DIR, (kal_wchar *)DT_PTR->data_filename);
//						break;
//			  	}
//				FS_Delete((kal_wchar *)full_name);
//				free_ctrl_buffer(full_name);
//				kal_mem_set((kal_wchar *)DT_PTR->data_filename, 0, sizeof(kal_wchar)*50);
//			}
//#endif
			
			/* clear the stored infomation */
			DT_PTR->fd[0] = 0;
			DT_PTR->data_folder= 0;
	   	}      
}


void dt_clear_download_timer()
{
   	if (DT_PTR->event_id[1] != 0)
   	{
		kal_trace (TRACE_INFO, INFO_DT_CLEAR_DOWNLOAD_TIMER, DT_PTR->event_id[1]);
      		evshed_cancel_event (DT_PTR->event_scheduler_ptr, &(DT_PTR->event_id[1]));
	      	DT_PTR->event_id[1] = 0;
   	}
}


/*****************************************************************************
* FUNCTION
*  	dt_get_downloadFullpath
* DESCRIPTION
*  	This function is to append the input filename to the stored path and return the full-path filename.
*  	the stored path is set by +EFSF=2, <folder>.  
*  	the function might be called by +EFSR, +EFSW, +EFSL, +EFSD
* PARAMETERS
* 	IN/OUT file_name
* RETURNS
* 	none
* GLOBALS AFFECTED
*   cancel timer and free L4C_PTR->downloadFullpath.
*****************************************************************************/
void dt_get_downloadFullpath(kal_wchar * file_name)