fucdlayer.cpp

atmel芯片的Linux驱动程序。很多802.11协议的无限网卡都使用该芯片

#include "FucdLayer.h"

/********************************/
/* 	UsbDevInfo Methods	*/
/********************************/

UsbDevInfo::UsbDevInfo(struct usb_device *dev, int devnum) 
{
	_devnum = devnum;
	_device = dev;
	_name = new wxString(atmel_device_ids[_devnum].name);
}

void UsbDevInfo::Prepare()
{
	//FIXME: this name has to change
	char name[20];
	_handle = usb_open(_device);
	if(_devnum<4 && _devnum>=0) {
		usb_get_driver_np(_handle, 0, name, ondevnum[_devnum]);
                usb_detach_kernel_driver_np(_handle, 0);
                printf("Driver is Detached\n");
	}
	else  printf("There is no driver to detach\n");
	/* Claim the interface */
	usb_claim_interface(_handle, 0);
}

void UsbDevInfo::Close()
{
	usb_close(_handle);
}



/********************************/
/* 	FucdLayer Methods	*/
/********************************/

FucdLayer::FucdLayer()
{
	firmware = new unsigned char *;
	*firmware = NULL;
//	_init_usb_subsystem();
	for(int i=0; i<MAX_DEVICES; i++)
		devinfos[i] = NULL; 
}

void FucdLayer::Prepare()
{
	if(_activedev >= n_devices) return;
	else devinfos[_activedev]->Prepare();
}


void FucdLayer::Close()
{
	devinfos[_activedev]->Close();
}


void FucdLayer::_init_usb_subsystem()
{
	// Initialize USB subsystem 
	usb_init();
	// Enumerate all busses 
	usb_find_busses();
	// Enumerate all devices 
	usb_find_devices();
}


bool FucdLayer::FindDevices()
{
	struct usb_bus *bus;
	struct usb_device *device; 
	int devnum=0;
	bool retval = false;

	n_devices = 0;
	// Check if already scanned for devices
	for(int i=0; i<MAX_DEVICES; i++)
		if (devinfos[i] != NULL) {
			delete devinfos[i];
			devinfos[i] = NULL;
		}	

	_init_usb_subsystem();

	// Find all devices in all busses
	for(bus=usb_busses; bus; bus=bus->next)
		for(device=bus->devices; device; device = device->next)
			for(int devnum=0; devnum<(sizeof(atmel_device_ids)/sizeof(struct at76c503a_device_id)); devnum++) 
				if ((device->descriptor.idVendor == atmel_device_ids[devnum].idVendor) &&
				    (device->descriptor.idProduct == atmel_device_ids[devnum].idProduct)) {
					devinfos[n_devices++] = new UsbDevInfo(device, devnum);
					retval = true;
				}
	return retval;
}


void FucdLayer::GetDevNames(wxChoice* devchoice) 
{
	devchoice->Clear();	
	if(!n_devices) {
		devchoice->Append("No Devices Found");
		return;
		}
	for(int i=0; i<n_devices; i++)
		if(devinfos[i] != NULL) devchoice->Append( *(devinfos[i]->GetName()) );
		else return;
}


bool FucdLayer::AtmelFirmwareUpgrade(wxGauge *gg_dload) 
{
	gg_dload->SetValue(gg_dload->GetValue()+10);
	usb_dev_handle *handle = devinfos[_activedev]->GetHandle();
	switch (_opermode){
		case 1:
			DFUDetach();
			wxSleep(1);
			gg_dload->SetValue(gg_dload->GetValue()*5);
			usb_reset(handle);
			usb_claim_interface(handle, 0);
			DownloadFirmware();
			gg_dload->SetValue(gg_dload->GetValue()*4/5);
			wxSleep(1);
			gg_dload->SetValue(gg_dload->GetValue()-1);
			usb_reset(handle);
			break;
		case 3:
			DownloadFirmware();
			gg_dload->SetValue(gg_dload->GetValue()*3/4);
			wxSleep(1);
			gg_dload->SetValue(gg_dload->GetValue()-1);
			usb_reset(handle);
			usb_claim_interface(handle, 0);
			break;

		default:
			return false;

	}
	return true;
}

//TODO: Check the original return value
bool FucdLayer::AtmelGetFwVersion(wxString &ver)
{
	unsigned char version[4];
	if (_activedev >= n_devices) {
		ver = "No valid device selected\n";
		return false;	// Index out of range
	}
	if (_opermode != 1) {
		ver = "No Firmware Version Available\n";
		return true;	// Device does not allow this command
	}
        if (::AtmelGetFwVersion(devinfos[_activedev]->GetHandle(), version) >= 0) {
		ver.Printf("%d.%d.%d.%d\n", version[0], version[1], version[2], version[3]);
		return true;
	}
	ver = "Firmware Version Retrieval FAILED!\n";
	return false;
}	

//TODO: Check the original return value
bool FucdLayer::AtmelGetModeOfOperation() 
{
	if (_activedev >= n_devices) return false;	// Index out of range
        if(::AtmelGetModeOfOperation(devinfos[_activedev]->GetHandle(), &_opermode) < 0)
		return false;	// usb command failed
	if(_opermode != 1) return false;	
	return true;
}
/*

        // *****  dfu.c  *****

int FucdLayer::DFUDownload(usb_dev_handle *dev, char *Buffer, unsigned long Bytes, unsigned short Block)
{
        return ::DFUDownload(dev, Buffer, Bytes, Block);
}

int FucdLayer::DFUGetStatus(usb_dev_handle *dev, struct dfu_status *status) 
{
        return ::DFUGetStatus(dev, status);
}

unsigned char FucdLayer::DFUGetState(usb_dev_handle *dev, char *state)
{
        return ::DFUGetState(dev, state);
}


*/
int FucdLayer::DFUDetach()
{
        return ::DFUDetach(devinfos[_activedev]->GetHandle());
}

int FucdLayer::DownloadFirmware()
{
        return ::DownloadFirmware(devinfos[_activedev]->GetHandle(), *firmware, fwsize);
}

bool FucdLayer::ReadFirmware()
{
	if(*firmware != NULL) delete *firmware;
	
        fwsize = ::ReadFirmware((char*)filename.c_str(), firmware);
	if(fwsize <= MAX_ALLOWED_FW_SIZE) return true;
	else {
		delete *firmware;
		*firmware = NULL;
		return false;
}	}
        

void FucdLayer::SetFilename(const wxString fname) 
{
	filename = fname;
}