dfu.c

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

/*
 * dfu.c
 *
 * DFU download utility
 *
 * Copyright Brad Hards and Bas Vermeulen
 *
 */

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <usb.h>
#include "dfu.h"

#define DEBUG 1

#define USB_DIR_IN 			0x80
#define USB_DIR_OUT 			0x00

#define STATUS_SUCCESS			1
#define STATUS_UNSUCCESSFUL		-1
#define STATUS_INVALID_PARAMETER	-9999
#define USB_SUCCESS(a) 			(a >= 0)

/* Should be read from interface functional descriptor */
#define DFU_PACKETSIZE			1024

#define TIMEOUT                         1000

int DFUDetach(usb_dev_handle * dev)
{
	int result;

	printf("ATMEL - DFU Detach\n");

	result = usb_control_msg(dev, USB_DIR_OUT | 0x40 | USB_RECIP_INTERFACE, DFU_DETACH, 
                                 1000,	/* Value */
				 0,	/* Index */
				 NULL,	/* Buffer */
				 0,	/* Size */
				 TIMEOUT);

	if (!USB_SUCCESS(result))
		printf("ATMEL - DFU Detach FAILED (%s)!\n", usb_strerror());

	return result;
}


int DFUDownload(usb_dev_handle * dev, unsigned char *Buffer,
		unsigned long Bytes, unsigned short Block)
{
	int result;

#if 0
	printf("DOWNLOADING %ld Bytes (Block = %d)\n", Bytes, Block);
#endif
	result = usb_control_msg(dev, USB_TYPE_CLASS | USB_DIR_OUT | USB_RECIP_INTERFACE, DFU_DNLOAD, Block,	/* Value */
				 0,	/* Index */
				 Buffer,	/* Buffer */
				 Bytes,	/* Size */
				 TIMEOUT);

	if (!USB_SUCCESS(result))
		printf("Write FW Block %d failed (%s)!\n", Block,
		       usb_strerror());

	return result;
}


int DFUGetStatus(usb_dev_handle * dev, struct dfu_status *status)
{
	int result;
	unsigned char stat_buff[6];

	result = usb_control_msg(dev, USB_TYPE_CLASS | USB_DIR_IN | USB_RECIP_INTERFACE, DFU_GETSTATUS, 0,	/* Value */
				 0,	/* Index */
				 (unsigned char *) &stat_buff,	/* Buffer */
				 6,	/* Size */
				 TIMEOUT);

	memcpy(status, &stat_buff, 6);

	return result;
}

unsigned char DFUGetState(usb_dev_handle * dev, unsigned char *state)
{
	int result;
	result = usb_control_msg(dev, USB_TYPE_CLASS | USB_DIR_IN | USB_RECIP_INTERFACE,	/* Request Type */
				 DFU_GETSTATE,	/* Request */
				 0,	/* Value */
				 0,	/* Index */
				 state,	/* Buffer */
				 1,	/* Size */
				 TIMEOUT);

	return result;
}


int DownloadFirmware(usb_dev_handle * dev, unsigned char *DfuBuffer,
		     unsigned int DfuLen)
{
	int status = STATUS_SUCCESS;
	int NeedDFUState = 1;
	int IsDone = 0;
	struct dfu_status DfuStatusBuffer;
	unsigned char DfuState = 0;
	unsigned long DfuTimeout = 0;
	unsigned long DfuBlockBytes, DfuBytesLeft, DfuBufferOffset;
	unsigned long DfuBlockCnt;
	int t;

	DfuBlockCnt = 0;
	DfuBytesLeft = DfuLen;
	DfuBlockBytes = 0;
	DfuBufferOffset = 0;

	if (DfuLen == 0) {
		printf("FW Buffer length invalid!\n");
		return STATUS_UNSUCCESSFUL;
	}

#if 0
	printf("Start FW Downloading...\n");
#endif

	do {
		if (NeedDFUState) {
			status = DFUGetState(dev, &DfuState);
			if (!USB_SUCCESS(status)) {
				printf
				    ("ATMEL - DFU: Failed to get DFU state...\n");
				return STATUS_UNSUCCESSFUL;
			}
			NeedDFUState = 0;
		}

		switch (DfuState) {
		case STATE_DFU_DOWNLOAD_SYNC:
#if 0
			printf("STATE_DFU_DOWNLOAD_SYNC\n");
#endif
			if (USB_SUCCESS
			    (DFUGetStatus(dev, &DfuStatusBuffer))) {
				DfuState = DfuStatusBuffer.bState;
				DfuTimeout = 0;
				DfuTimeout =
				    (unsigned long) (DfuStatusBuffer.
						     bwPollTimeout[2] <<
						     16);
				DfuTimeout |=
				    (unsigned long) (DfuStatusBuffer.
						     bwPollTimeout[1] <<
						     8);
				DfuTimeout |=
				    (unsigned long) (DfuStatusBuffer.
						     bwPollTimeout[0]);
				NeedDFUState = 0;
			}
			break;
		case STATE_DFU_DOWNLOAD_BUSY:
#if 0
			printf("STATE_DFU_DOWNLOAD_BUSY\n");
#endif
			NeedDFUState = 1;

			if (DfuTimeout > 0)
				printf("ATMEL - DFU: Resetting device - Waiting ...\nDownloading FW Blocks\n");
			else
				printf("ATMEL - DFU: In progress\n");

			for (t = 1; t <= DfuTimeout / 500; t++)
				usleep(500 * 1000);	/* Sleep for 500 ms */
			break;
		case STATE_DFU_DOWNLOAD_IDLE:
#if 0
			printf("DOWNLOAD ");
#endif
		case STATE_DFU_IDLE:
#if 0
			printf("DFU IDLE\n");
#endif

			if (DfuBytesLeft <= DFU_PACKETSIZE)
				DfuBlockBytes = DfuBytesLeft;
			else
				DfuBlockBytes = DFU_PACKETSIZE;

			if (USB_SUCCESS(status)) {
				DfuBytesLeft -= DfuBlockBytes;
				status = DFUDownload(dev,
						     DfuBuffer +
						     DfuBufferOffset,
						     DfuBlockBytes,
						     DfuBlockCnt);
				DfuBufferOffset += DfuBlockBytes;
				DfuBlockCnt++;
			}
			NeedDFUState = 1;
			break;
		case STATE_DFU_MANIFEST_SYNC:
#if 0
			printf("STATE_DFU_MANIFEST_SYNC\n");
#endif
			status = DFUGetStatus(dev, &DfuStatusBuffer);

			if (USB_SUCCESS(status)) {
				DfuState = DfuStatusBuffer.bState;
				DfuTimeout = 0;
				DfuTimeout =
				    (unsigned long) (DfuStatusBuffer.
						     bwPollTimeout[2] <<
						     16);
				DfuTimeout |=
				    (unsigned long) (DfuStatusBuffer.
						     bwPollTimeout[1] <<
						     8);
				DfuTimeout |=
				    (unsigned long) (DfuStatusBuffer.
						     bwPollTimeout[0]);
				NeedDFUState = 0;

				if (DfuTimeout > 0)
					printf("ATMEL - DFU: Resetting device - Waiting ...\n");
				else
					printf("ATMEL - DFU: In progress\n");

				for (t = 1; t <= DfuTimeout / 500; t++)
					usleep(500 * 1000);	/* Sleep for 500 ms */
			}
			break;
		case STATE_DFU_MANIFEST:
			printf("STATE_DFU_MANIFEST - We Are About to sleep 7 seconds\n");
                        sleep(7);
			IsDone = 1;
			break;
		case STATE_DFU_MANIFEST_WAIT_RESET:
			printf("STATE_DFU_MANIFEST_WAIT_RESET\n");
			usb_reset(dev);
			break;
		case STATE_DFU_UPLOAD_IDLE:
			printf("STATE_DFU_UPLOAD_IDLE\n");
			break;
		case STATE_DFU_ERROR:
			printf("STATE_DFU_ERROR\n");
			usb_reset(dev);
			break;
		default:
			printf("DFU UNKNOWN STATE (%d)\n", DfuState);
			status = STATUS_INVALID_PARAMETER;
			break;
		}
	} while (!IsDone && USB_SUCCESS(status));

	return status;
}

unsigned long ReadFirmware(char *file, unsigned char **buffer)
{
	struct stat filestat;
	unsigned long fwsize;
	unsigned long bytesread;
	int fd;

	stat(file, &filestat);
	fwsize = filestat.st_size;

	if ((*buffer = malloc(fwsize)) == NULL) {
		printf("Unable to allocate %ld bytes!\n", fwsize);
		return -ENOMEM;
	}

	/* Open the firmware file */
	if ((fd = open(file, O_RDONLY)) < 0) {
		printf("Unable to open %s!\n", file);
		free(*buffer);
		return -errno;
	}

	/* Read the firmware file into the buffer */
	bytesread = read(fd, *buffer, fwsize);

	/* Close the firmware file */
	close(fd);

	if (bytesread < fwsize) {
		printf("Short read in %s!\n", file);
		free(*buffer);
		return -EINVAL;
	}

	return fwsize;
}