otgmsapp.c

linux下的usb开发

/*************************************************************
 * Philips otg mass storage demo
 *
 * (c) 2002 Koninklijke Philips Electronics N.V., All rights reserved
 * 
 * This  source code and any compilation or derivative thereof is the
 * proprietary information of Koninklijke Philips Electronics N.V.
 * and is confidential in nature.
 * Under no circumstances is this software to be exposed to or placed
 * under an Open Source License of any type without the expressed
 * written permission of Koninklijke Philips Electronics N.V.
 *
 * File Name:	otgmsapp.c
 *
 * History:	
 *
 *	Version	Date		Author		Comments
 * -------------------------------------------------
 * 	1.0		09/23/02	SYARRA		Initial Creation
 *
 *************************************************************/

#include <stdio.h>
#include <gtk/gtk.h>

#include<fcntl.h>
#include<stdio.h>
#include<stdlib.h>
#include<signal.h>
#include<sys/ioctl.h>
#include<sys/shm.h>
#include<unistd.h>
#include<string.h>

#include "usb_otg.h"
#include "otgmsapp.h"
#include "otgtool.h"

#define		SHM_KEY		3456
#define		DEF_PAD 10
#define		DEF_PAD_SMALL 5
#define		DEF_MAX_COLOR 3

usb_otg_info_t	get_otg_info;
usb_otg_info_t	set_otg_info;

shm_struct_t	*shm;
int				shmid;
int				otgfsm_fd;
char	sys_cmd[128];

char	otg_status_name[][25] = {		/* Status name array */
	"NONE                ",
	"PROTOCOL TIMEOUT    ",
	"VBUS_ERROR          ",
	"ENUMERATION SUCCESS ",
	"ENUMERATION FAILED  ",
	"DEVICE NOT SUPPORTED"
};

char	otg_state_name[25][15] = {
		"B_IDLE",
		"B_HOST",
		"B_DEVICE",
		"B_WAIT_ACON",
		"B_SRP_INIT",
		"INV_STATE",
		"INV_STATE",
		"INV_STATE",
		"INV_STATE",
		"INV_STATE",
		"INV_STATE",
		"INV_STATE",
		"INV_STATE",
		"INV_STATE",
		"INV_STATE",
		"INV_STATE",
		"A_IDLE",
		"A_HOST",
		"A_DEVICE",
		"A_WAIT_BCON",
		"A_WAIT_VRISE",
		"A_SUSPEND",
		"A_WAIT_VFALL",
		"A_VBUS_ERR"
};

char	port_id_name[2][10] = {
		"Mini A",
		"Mini B"
};

char	otg_local_disk[20]	= LOCAL_OTG_DISK;
char	otg_rmt_disk[20]	= RMT_OTG_DISK;

static char appClose=0;
static char mount_flag=0;
static char sourcefile_select=0;	  
static char destfile_select=0;	  
static int icolor=0;

char	printbuffer[200];
char	otg_mount_name[10];
char	fnamebuffer_sourcedisk[100];
char	fnamebuffer_destdisk[100];

GtkWidget *isp1362statuslabel;
GtkWidget *entry_sourcedisk, *entry_destdisk;
GtkWidget *scrolled_window;
GtkWidget *statuspadtext;
GdkColor colorarray[DEF_MAX_COLOR];

void addlist_otgapp( gchar* string)
{
		gfloat value;
		GtkAdjustment *adjustment;

		gtk_text_freeze (GTK_TEXT (statuspadtext));


		gtk_text_insert (GTK_TEXT (statuspadtext), NULL, &colorarray[icolor], NULL, string, -1);
		icolor++;
		icolor = icolor % DEF_MAX_COLOR;

		adjustment= gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW (scrolled_window));	   
		if((value= (GTK_TEXT (statuspadtext)->vadj->upper - GTK_TEXT (statuspadtext)->vadj->page_size)))
		{
			GTK_ADJUSTMENT(adjustment)->value = value; 
			gtk_signal_emit_by_name (GTK_OBJECT (adjustment), "changed"); 
		}
		gtk_text_thaw (GTK_TEXT (statuspadtext));
}


char find_vid()
{
	char bFound=0;
	
	system("mount -t usbdevfs 0 /proc/bus/usb");

	if( system("grep -iq Vendor=0781  /proc/bus/usb/devices 2>/dev/null"))
	{
 		g_print ("OTG:%s\n","Vendor=0781 ProdID=0002 found");
		bFound=1;
	}
	
	return bFound;
}

char mount_device()
{
	char	dev_c, proc_c;
	int		result = 0;
	int		dev_fd;
	char	dev_file_name[32];
	char	proc_file_name[64];

	dev_c = 'a';
	proc_c = '0';
	strcpy(dev_file_name,"/dev/sd");
	strcpy(proc_file_name,"/proc/scsi/usb-storage-");
	while(dev_c < 'e') {
		
		sprintf(dev_file_name,"%s%c","/dev/sd",dev_c);
		dev_fd = open(dev_file_name,O_RDWR);

		if(dev_fd > 0) {
			close(dev_fd);
			sprintf(sys_cmd,"mount %s1 %s\n",dev_file_name,RMT_OTG_DISK);
			system(sys_cmd);
			result = 1;	
		}
		dev_c++;
		proc_c++;
	}

	if(result) {
		sprintf(sys_cmd,"dd if=%s of=%s1 bs=%d skip=%d >/dev/null\n",MSDISK_FILE,MSDISK_FILE,BLOCK_SIZE,LINUX_UNIT_SIZE);
		system(sys_cmd);
		sprintf(sys_cmd,"mount %s1 %s -o loop\n",MSDISK_FILE,LOCAL_OTG_DISK);
		system(sys_cmd);
		mount_flag = 1;
	}

	return result;

}

char umount_device()
{
	char	bFound = mount_flag;

	if(mount_flag==1) {

		sprintf(sys_cmd,"umount %s\n",LOCAL_OTG_DISK);
		system(sys_cmd);
		sprintf(sys_cmd,"dd if=%s1 of=%s bs=%d seek=%d >/dev/null\n",MSDISK_FILE,MSDISK_FILE,BLOCK_SIZE,LINUX_UNIT_SIZE);
		system(sys_cmd);

		sprintf(sys_cmd,"umount %s\n",RMT_OTG_DISK);
		system(sys_cmd);

		mount_flag = 0;
		sourcefile_select = 0;
		destfile_select = 0;
		gtk_entry_set_text (GTK_ENTRY (entry_sourcedisk), "Local Disk not Available");
		gtk_entry_set_text (GTK_ENTRY (entry_destdisk), "Remote Disk not Available");
	}

	return bFound;
}


void display_current_state(){
	int	i;

	sprintf(printbuffer, "%s",  otg_state_name[get_otg_info.state]);
	gtk_label_set_text  ((GtkLabel*)isp1362statuslabel, printbuffer);

	if(get_otg_info.state == OTG_INV_STATE) {
		sprintf(printbuffer, "Port Status:: %s \n", "OTG Hw Not Initialized");
		addlist_otgapp(printbuffer);
	} else {
		sprintf(printbuffer, "plugged:: %s     state:: %s \n", port_id_name[get_otg_info.id], otg_state_name[get_otg_info.state]);
		addlist_otgapp(printbuffer);
	}

	for(i=0;i<shm->signal_count;i++){
		sprintf(printbuffer,"state change::  %s\n",otg_state_name[shm->state[i]]);
		addlist_otgapp(printbuffer);
	}
	shm->signal_count = 0;
	shm->signal = 0;
	shm->flag = 0;

}

void sig_handler(int	signal){

	ioctl(otgfsm_fd, OTG_IOC_GET_STATE, &get_otg_info);
	shm->flag = 1;
	shm->signal = 1;
	shm->c = 'R';
	shm->state[shm->signal_count] = get_otg_info.state;
	shm->signal_count = (shm->signal_count+1) % MAX_PREV_OTG_STATES;

	if(get_otg_info.state == OTG_A_VBUS_ERR) { 					/* This can only happen to A device, bring back it to IDLE state */
		shm->c = 'C';											/* Clear VBUS ERROR */
	}

	if(get_otg_info.status_code == OTG_STATUS_ENUM_FAILED) {
		shm->c = 'I'; 											/* Enumeration failed, go back to Idle */
	}
	
	display_current_state();

	//handle the unmount here based on the state change.
	if( (mount_flag == 1) && 
	( get_otg_info.state != OTG_A_HOST && 
	  get_otg_info.state != OTG_B_HOST ) ) {
		umount_device();
	}

}

void close_otgapp( GtkWidget *widget,
                        gpointer   data )
{

    umount_device();
	set_otg_info.state = OTG_IDLE;
	ioctl(otgfsm_fd, OTG_IOC_SET_STATE, &set_otg_info);
	ioctl(otgfsm_fd, OTG_IOC_GET_STATE, &get_otg_info);

	appClose = 1;

	close(otgfsm_fd) ;
	shmdt(shm);
    shmctl(shmid,IPC_RMID,0);

	gtk_main_quit();
}

void realize_text( GtkWidget *text,
                   gpointer data )
{
    gtk_text_freeze (GTK_TEXT (text));
    gtk_text_insert (GTK_TEXT (text), NULL, &colorarray[0], NULL,
			"\t\t\t\t\t\t\t     OTG Test Application\n", -1);
    gtk_text_insert (GTK_TEXT (text), NULL, &colorarray[1], NULL,
			"\t\t\t\t\t\t\t Philips Innovation Center APIC\n", -1);  
    gtk_text_insert (GTK_TEXT (text), NULL, &colorarray[2], NULL,
			"\t\t\t\t\t\tPhilips Electronics Singapore Pte Ltd\n", -1);  
 
	gtk_text_thaw (GTK_TEXT (text));
}
   

/* Create a scrolled text area that displays a "message" */
GtkWidget *create_text( void )
{

    GtkWidget *scrolled_window;
   
	/* Create a new scrolled window, with scrollbars only */
	scrolled_window = gtk_scrolled_window_new (NULL, NULL);
	gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
								  GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
	gtk_widget_set_usize(scrolled_window, 200, 270);

	/* Put a text widget in the upper left hand corner. Note the use of
	* GTK_SHRINK in the y direction */
	statuspadtext = gtk_text_new (NULL, NULL);
	gtk_container_add (GTK_CONTAINER (scrolled_window), statuspadtext);
	gtk_widget_grab_focus (statuspadtext);
	gtk_text_set_word_wrap(GTK_TEXT( statuspadtext), TRUE);
	/* Add a handler to put a message in the text widget when it is realized */
	gtk_signal_connect (GTK_OBJECT (statuspadtext), "realize",
					  GTK_SIGNAL_FUNC (realize_text), NULL);
	return scrolled_window;
}

void
file_selection_ok_source (GtkWidget *w,
		   GtkFileSelection *fs)
{

	gchar filename[200];
	gint	filenamesize=0;
	FILE* fp;


	sprintf(filename,gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs))); 

	fp =fopen(filename,"r");
	if(fp>0) fclose(fp);
	else
	{
		sprintf(printbuffer, "Selected file %s does NOT exists\n", filename);
		addlist_otgapp(printbuffer);
		goto RET;
	}

	if( (strncmp(filename,otg_local_disk,strlen(otg_local_disk)) != 0 ) &&
		 (strncmp(filename,otg_rmt_disk,strlen(otg_rmt_disk)) != 0 ) ) {
	sprintf(printbuffer, "%s is not from OTG disk, use normal cp Command \n", filename);
	addlist_otgapp(printbuffer);
	goto RET;
	}

	while(filename[filenamesize] != '\0')
	filenamesize++;

	if( fp >0 && filename[filenamesize-1]!='/' )
	{
	sourcefile_select=1;
	addlist_otgapp("Source file selection is okay\n");
	gtk_entry_set_text (GTK_ENTRY (entry_sourcedisk), filename);
	}
	else
	{
	  sourcefile_select=0;

	  if( filename[filenamesize-1]=='/')
	  { 
		sprintf(printbuffer, "Hunh, so you wish to copy/move/delete a DIRECTORY itself\n");
		addlist_otgapp(printbuffer);
		sprintf(printbuffer, "Please select a file .........\n");
		addlist_otgapp(printbuffer);
	  }

	}

RET:
	gtk_widget_destroy (GTK_WIDGET (fs));
}

void
file_selection_ok_dest (GtkWidget *w,
		   GtkFileSelection *fs)
{
	gchar filename[200];
	FILE* fp;


	sprintf(filename,gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs))); 

	fp =fopen(filename,"r");
	if(fp>0) fclose(fp);
	else
	{
		sprintf(printbuffer, "Selected file %s does NOT exists\n", filename);
		addlist_otgapp(printbuffer);
	}

	if( (strncmp(filename,otg_local_disk,strlen(otg_local_disk)) != 0 ) &&
		 (strncmp(filename,otg_rmt_disk,strlen(otg_rmt_disk)) != 0 ) ) {
	sprintf(printbuffer, "%s is not from OTG disk, use normal cp Command \n", filename);
	addlist_otgapp(printbuffer);
	goto RET1 ;
	}