Subversion Repositories usb_nand_reader

 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <libusb-1.0/libusb.h>
#include "include/opcodes.h"
#include "include/actions.h"
#include "include/nand_vendors.h"
 
unsigned char ioBuffer[64];
int dataTransfered;
 
int
usb_write(libusb_device_handle* usb, unsigned char* data, int len)
{
	int ds;
	int i = 0;
	int l = (len < 64)? 64 : len;
 
	while(i < l)
	{
		libusb_bulk_transfer(usb, 0x01, data + i, l - i, &ds, 1000);
		i += ds;
	}
	return i;
}
 
int 
usb_read(libusb_device_handle* usb, unsigned char* data, int len)
{
	int ds;
	int i = 0, r;
	if(len % 64 != 0)
	{
		fprintf(stderr, "\nIncorrect read length\n");
		return 0;
	}
	while(i < len)
	{
		if(0 > (r = libusb_bulk_transfer(usb, 0x81, data + i, len - i, &ds, 10000)))
		{
			fprintf(stderr, "libusb_bulk_transfer() returned %d\n", r);
			//exit(-4);
		}
		i += ds;
		if(0 == ds)
			exit(-3);
	}
	return i;
}
 
USB_ACTION(nand_reset)
{
	ioBuffer[0] = NAND_CHIP_RESET;
	usb_write(usb, ioBuffer, 1);
	return 0;
}
 
USB_ACTION(nand_enable, int dieIndex)
{
	ioBuffer[0] = NAND_CHIP_ENABLE;
	ioBuffer[1] = (unsigned char)(dieIndex & 3);
	usb_write(usb, ioBuffer, 2);
	return 0;
}
 
USB_ACTION(nand_disble)
{
	ioBuffer[0] = NAND_CHIP_DISABLE;
	usb_write(usb, ioBuffer, 1);
	return 0;
}
 
USB_ACTION(nand_read_id, unsigned char* idBuffer)
{
	ioBuffer[0] = NAND_CHIP_READ_ID;
	usb_write(usb, ioBuffer, 1);
	usb_read(usb, ioBuffer, 64);
	memcpy(idBuffer, ioBuffer, 5);
	return 0;
}
 
USB_ACTION(nand_is_onfi, unsigned char* signature)
{
	ioBuffer[0] = NAND_CHIP_READ_ID_ONFI;
	usb_write(usb, ioBuffer, 1);
	usb_read(usb, ioBuffer, 64);
	memcpy(signature, ioBuffer, 4);
	if(ioBuffer[0] == 'O' && ioBuffer[1] == 'N' && ioBuffer[2] == 'F' && ioBuffer[3] == 'I')
		return 1;
	return 0;
}
 
USB_ACTION(nand_read_onfi_param_page, unsigned char* paramPageBuffer)
{
	ioBuffer[0] = NAND_CHIP_READ_PARAM_PAGE;
	usb_write(usb, ioBuffer, 1);
	usb_read(usb, paramPageBuffer, 256);
	return 0;
}
 
USB_ACTION(nand_set_config_data, pnand_t nand)
{
	ioBuffer[0] = NAND_SET_CONFIG_DATA;
	*(int*)(&ioBuffer[1]) = nand->bytesPerPage + nand->oobPerPage;
	ioBuffer[5] = (unsigned char)(nand->addressCycles & 0xff);
	ioBuffer[6] = (unsigned char)(nand->busWidth);
	usb_write(usb, ioBuffer, 6);
	return 0;
}
 
USB_ACTION(nand_read_page, unsigned int pageAddress, pnand_t nand)
{
	//struct timespec start = {0, 0}, end = {0, 0};
	ioBuffer[0] = NAND_CHIP_READ_PAGE;
	ioBuffer[1] = ioBuffer[2] = 0;
	*(unsigned int*)(&ioBuffer[3]) = (pageAddress & 0x00ffffff);
	//clock_gettime(CLOCK_MONOTONIC, &start);
	usb_write(usb, ioBuffer, 64);
	//printf("read %d bytes\n", usb_read(usb, nand->pageBuffer, nand->bytesPerPage + nand->oobPerPage));
 
	usb_read(usb, nand->pageBuffer, nand->bytesPerPage + nand->oobPerPage);
	//clock_gettime(CLOCK_MONOTONIC, &end);
	//printf("\r\tPage read in %.10f seconds.", ((double)end.tv_sec + 1.0e-9 * end.tv_nsec) - ((double)start.tv_sec + 1.0e-9 * start.tv_nsec));
	//fflush(stdout);
	return 0;
}
 
USB_ACTION(nand_read_page_cache, unsigned int startPageAddress, int pageCount, FILE* storeTo, pnand_t nand)
{
	int currentPage, blocks = 0;
	unsigned int sa = startPageAddress;
 
	if(0 != pageCount % nand->pagesPerBlock)
		return -1;
 
	while(blocks < pageCount / nand->pagesPerBlock)
	{
		fprintf(stderr,"\rBlock #%d (%0.4f%%)", blocks, (float)blocks / ((float)(pageCount / nand->pagesPerBlock) / 100.0f));
		ioBuffer[0] = NAND_CHIP_READ_CACHE_SEQ;
		ioBuffer[1] = ioBuffer[2] = 0;
		*(unsigned int*)(&ioBuffer[3]) = (sa & 0x00ffffff);
		*(int*)(&ioBuffer[6]) = nand->pagesPerBlock;
		usb_write(usb, ioBuffer, 64);
 
		for(currentPage = 0; currentPage < nand->pagesPerBlock; currentPage++)
		{
			usb_read(usb, nand->pageBuffer, nand->bytesPerPage + nand->oobPerPage);
			if(NULL != storeTo)
				store_page(storeTo, nand);
			//fprintf(stderr,"\rBlock #%d %0.2f%% completed", blocks, (float)currentPage / ((float)nand->pagesPerBlock / 100.0f));
		}
		blocks++;
		sa += nand->pagesPerBlock;
	}
	fprintf(stderr, "\n");
	return 0;
}
 
USB_ACTION(nand_read_status, unsigned char* status)
{
	ioBuffer[0] = NAND_CHIP_READ_STATUS;
	usb_write(usb, ioBuffer, 64);
	usb_read(usb, ioBuffer, 64);
	if(status)
		*status = ioBuffer[0];
	return (int)ioBuffer[0];
}
 
USB_ACTION(nand_read_status_enhanced, unsigned int address, unsigned char* status)
{
	ioBuffer[0] = NAND_CHIP_READ_STATUS;
	*(unsigned int*)(&ioBuffer[1]) = address & 0xffffff;
	usb_write(usb, ioBuffer, 64);
	usb_read(usb, ioBuffer, 64);
	if(status)
		*status = ioBuffer[0];
	return (int)ioBuffer[0];
}
 
USB_ACTION(nand_read_unique_id, unsigned char* uid)
{
	ioBuffer[0] = NAND_CHIP_READ_UNIQUE_ID;
	usb_write(usb, ioBuffer, 64);
	usb_read(usb, ioBuffer, 64);
	memcpy(uid, ioBuffer, 64);
	return 0;
}
 
int nand_check_uid(unsigned char* buffer)
{
	int i;
	for(i = 0; i < 16; i++)
	{
		if(0xFF != (*(buffer + i) ^ *(buffer + i + 16)))
			return 0;
	}
	return 1;
}
 
 
USB_ACTION(nand_block_erase, unsigned int blockAddress)
{
	ioBuffer[0] = NAND_CHIP_BLOCK_ERASE;
	*(unsigned int*)(&ioBuffer[1]) = (blockAddress & 0x00ffffff);
	usb_write(usb, ioBuffer, 64);
	return 0;
}
 
USB_ACTION(nand_toggle_wp)
{
	ioBuffer[0] = NAND_CHIP_TOGGLE_WP;
	usb_write(usb, ioBuffer, 64);
	return 0;
}
 
USB_ACTION(nand_page_program, unsigned int pageAddress, pnand_t nand)
{
	//int i;
 
	ioBuffer[0] = NAND_CHIP_PAGE_PROGRAM;
	ioBuffer[1] = ioBuffer[2] = 0;
	*(unsigned int*)(&ioBuffer[3]) = (pageAddress & 0x00ffffff);
	usb_write(usb, ioBuffer, 64);
	/*
	for(i = 0; i < nand->bytesPerPage + nand->oobPerPage; i += 64)
	{
		fprintf(stderr, "Written %d bytes\n", usb_write(usb, nand->pageBuffer + i, 64));
	}
	 */
 
	fprintf(stderr, "Written %d bytes\n", usb_write(usb, nand->pageBuffer, nand->bytesPerPage + nand->oobPerPage));
	return 0;
}