コード例 #1
0
ファイル: flash.c プロジェクト: koltegirish/esphttpd-1
/* flash_binary */
int ICACHE_FLASH_ATTR flash_binary(char *	pbData, 
								   int 		cbSize, 
								   int 		iPartition)
{
	/* initialization */
	SpiFlashOpResult 	eFlashOperationStatus 	= SPI_FLASH_RESULT_ERR;
	int 				iRet 					= 0;
	
	erase_block(partition[iPartition].iOffset + cbFlashedSize);
	
	/* source assumed to be 4 byte aligned */
	eFlashOperationStatus = spi_flash_write((partition[iPartition].iOffset + cbFlashedSize), 
											(uint32 *)pbData, 
											cbSize);
	if (SPI_FLASH_RESULT_OK == eFlashOperationStatus)
	{
		cbFlashedSize += cbSize;
		iRet = cbSize;
		goto lblCleanup;
	}
	else
	{

#ifdef FLASH_DEBUG
		os_printf("flash_binary: SpiFlashOpResult %d\n", iRet);
#endif

		iRet = 0;
		goto lblCleanup;
	}

lblCleanup:
	return iRet;
}
コード例 #2
0
int _main(int argc, char * argv[])
{
    int start;
    int count;

    if (1 >= argc)
    {
    fprintf(stderr,"You must specify a device\n");
    printf("Help : %s <device name >  <start>  <count> <unlock:1,lock :0> \n", argv[0]);
    return 16;
    }

    if (argc > 2)
    start = strtol(argv[2], NULL, 0);
    else
    start = 0;

    if (argc > 3)
    count = strtol(argv[3], NULL, 0);
    else
    count = 1;

    printf("L: %d \n",__LINE__);
    erase_block(argv[1],start,count);
    return 0;
}
コード例 #3
0
ファイル: display.c プロジェクト: parrosam/base_station
void update_screen(UART_instance_t * this_uart, int deg, float kp, float ki, float kd, float digit, k_value_t k_value)
{
	// Print the pendulum
	print_degrees(this_uart, deg);

	// Print the constants
	set_x(this_uart, 32);
	set_y(this_uart, 16);
	delay();
	char buffer[64];
	sprintf(buffer, "%07.3f\r\n%07.3f\r\n%07.3f", kp, ki, kd);
	UART_polled_tx_string( this_uart, (const uint8_t *)&buffer);

	// Clear the digit block
	erase_block(this_uart, 112, 16, 159, 56);

	// Print the digit increment/decrement
	set_x(this_uart, 112);
	delay();
	char digit_buffer[16];
	sprintf(digit_buffer, "%07.3f", digit);
	if (k_value == KP)
	{
		set_y(this_uart, 16);
	} else if (k_value == KI) {
		set_y(this_uart, 24);
	} else {
		set_y(this_uart, 32);
	}
	UART_polled_tx_string( this_uart, (const uint8_t *)&digit_buffer);
}
コード例 #4
0
ファイル: display.c プロジェクト: parrosam/base_station
void print_degrees(UART_instance_t * this_uart, int deg)
{
	static uint8_t old_x_pixel = 0;
	static uint8_t old_y_pixel = 0;

	if (old_x_pixel > 80) {
		erase_block(this_uart, 75, 127, old_x_pixel+5, old_y_pixel-5);
	}
	else if (old_x_pixel < 80) {
		erase_block(this_uart, 85, 127, old_x_pixel-5, old_y_pixel-5);
	}
	else {
		erase_block(this_uart, 75, 127, 85, old_y_pixel-10);
	}

	deg += 90.0;				//Convert to range 0 to 180 degrees

	//Set location of degree printout
	set_x(this_uart, 64);
	set_y(this_uart, 64);
	delay();

	//Convert int to char array
	char buffer[4];
	sprintf(buffer, "%03d", deg);

	//Print degrees
	UART_send( this_uart, (const uint8_t *)&buffer, sizeof(buffer) );

	//Get locations of x and y pixels for head of the pendulum
	uint8_t x_pixel = 80 - cos(deg * PI / 180) * 50;
	uint8_t y_pixel = 127 - sin(deg * PI / 180) * 50;

	//Draw pendulum
	draw_line(this_uart, 80, 127, x_pixel, y_pixel);
	draw_circle(this_uart, x_pixel, y_pixel, 5);

	old_x_pixel = x_pixel;
	old_y_pixel = y_pixel;
}
コード例 #5
0
ファイル: rfd_ftl.c プロジェクト: 325116067/semc-qsd8x50
/*
 * IMPROVE: It would be best to choose the block with the most deleted sectors,
 * because if we fill that one up first it'll have the most chance of having
 * the least live sectors at reclaim.
 */
static int find_free_block(struct partition *part)
{
	int block, stop;

	block = part->current_block == -1 ?
			jiffies % part->total_blocks : part->current_block;
	stop = block;

	do {
		if (part->blocks[block].free_sectors &&
				block != part->reserved_block)
			return block;

		if (part->blocks[block].state == BLOCK_UNUSED)
			erase_block(part, block);

		if (++block >= part->total_blocks)
			block = 0;

	} while (block != stop);

	return -1;
}
コード例 #6
0
static int mark_sector_deleted(struct partition *part, u_long old_addr)
{
	int block, offset, rc;
	u_long addr;
	size_t retlen;
	u16 del = const_cpu_to_le16(SECTOR_DELETED);

	block = old_addr / part->block_size;
	offset = (old_addr % part->block_size) / SECTOR_SIZE -
		part->header_sectors_per_block;

	addr = part->blocks[block].offset +
			(HEADER_MAP_OFFSET + offset) * sizeof(u16);
	rc = part->mbd.mtd->write(part->mbd.mtd, addr,
		sizeof(del), &retlen, (u_char*)&del);

	if (!rc && retlen != sizeof(del))
		rc = -EIO;

	if (rc) {
		printk(KERN_WARNING PREFIX "error writing '%s' at "
			"0x%lx\n", part->mbd.mtd->name, addr);
		if (rc)
			goto err;
	}
	if (block == part->current_block)
		part->header_cache[offset + HEADER_MAP_OFFSET] = del;

	part->blocks[block].used_sectors--;

	if (!part->blocks[block].used_sectors &&
	    !part->blocks[block].free_sectors)
		rc = erase_block(part, block);

err:
	return rc;
}
コード例 #7
0
static int reclaim_block(struct partition *part, u_long *old_sector)
{
	int block, best_block, score, old_sector_block;
	int rc;

	/* we have a race if sync doesn't exist */
	if (part->mbd.mtd->sync)
		part->mbd.mtd->sync(part->mbd.mtd);

	score = 0x7fffffff; /* MAX_INT */
	best_block = -1;
	if (*old_sector != -1)
		old_sector_block = *old_sector / part->block_size;
	else
		old_sector_block = -1;

	for (block=0; block<part->total_blocks; block++) {
		int this_score;

		if (block == part->reserved_block)
			continue;

		/*
		 * Postpone reclaiming if there is a free sector as
		 * more removed sectors is more efficient (have to move
		 * less).
		 */
		if (part->blocks[block].free_sectors)
			return 0;

		this_score = part->blocks[block].used_sectors;

		if (block == old_sector_block)
			this_score--;
		else {
			/* no point in moving a full block */
			if (part->blocks[block].used_sectors ==
					part->data_sectors_per_block)
				continue;
		}

		this_score += part->blocks[block].erases;

		if (this_score < score) {
			best_block = block;
			score = this_score;
		}
	}

	if (best_block == -1)
		return -ENOSPC;

	part->current_block = -1;
	part->reserved_block = best_block;

	pr_debug("reclaim_block: reclaiming block #%d with %d used "
		 "%d free sectors\n", best_block,
		 part->blocks[best_block].used_sectors,
		 part->blocks[best_block].free_sectors);

	if (part->blocks[best_block].used_sectors)
		rc = move_block_contents(part, best_block, old_sector);
	else
		rc = erase_block(part, best_block);

	return rc;
}
コード例 #8
0
static int move_block_contents(struct partition *part, int block_no, u_long *old_sector)
{
	void *sector_data;
	u16 *map;
	size_t retlen;
	int i, rc = -ENOMEM;

	part->is_reclaiming = 1;

	sector_data = kmalloc(SECTOR_SIZE, GFP_KERNEL);
	if (!sector_data)
		goto err3;

	map = kmalloc(part->header_size, GFP_KERNEL);
	if (!map)
		goto err2;

	rc = part->mbd.mtd->read(part->mbd.mtd,
		part->blocks[block_no].offset, part->header_size,
		&retlen, (u_char*)map);

	if (!rc && retlen != part->header_size)
		rc = -EIO;

	if (rc) {
		printk(KERN_NOTICE PREFIX "error reading '%s' at "
			"0x%lx\n", part->mbd.mtd->name,
			part->blocks[block_no].offset);

		goto err;
	}

	for (i=0; i<part->data_sectors_per_block; i++) {
		u16 entry = le16_to_cpu(map[HEADER_MAP_OFFSET + i]);
		u_long addr;


		if (entry == SECTOR_FREE || entry == SECTOR_DELETED)
			continue;

		if (entry == SECTOR_ZERO)
			entry = 0;

		/* already warned about and ignored in build_block_map() */
		if (entry >= part->sector_count)
			continue;

		addr = part->blocks[block_no].offset +
			(i + part->header_sectors_per_block) * SECTOR_SIZE;

		if (*old_sector == addr) {
			*old_sector = -1;
			if (!part->blocks[block_no].used_sectors--) {
				rc = erase_block(part, block_no);
				break;
			}
			continue;
		}
		rc = part->mbd.mtd->read(part->mbd.mtd, addr,
			SECTOR_SIZE, &retlen, sector_data);

		if (!rc && retlen != SECTOR_SIZE)
			rc = -EIO;

		if (rc) {
			printk(KERN_NOTICE PREFIX "'%s': Unable to "
				"read sector for relocation\n",
				part->mbd.mtd->name);

			goto err;
		}

		rc = rfd_ftl_writesect((struct mtd_blktrans_dev*)part,
				entry, sector_data);

		if (rc)
			goto err;
	}

err:
	kfree(map);
err2:
	kfree(sector_data);
err3:
	part->is_reclaiming = 0;

	return rc;
}
コード例 #9
0
ファイル: gui.c プロジェクト: simen/cnc-monitor
void rewrite_line(char line) {
  char y = (TEXT_LINES-line)*8;
  erase_block(0,y+1,MAX_X,y+8);
  set_text_position(0,y+8);
}
コード例 #10
0
ファイル: nftl_format.c プロジェクト: jhbsz/102
int main(int argc, char **argv)
{
	unsigned long startofs = 0, part_size = 0;
	unsigned long ezones = 0, ezone = 0, bad_zones = 0;
	unsigned char unit_factor = 0xFF;
	long MediaUnit1 = -1, MediaUnit2 = -1;
	long MediaUnitOff1 = 0, MediaUnitOff2 = 0;
	unsigned char oobbuf[16];
	struct mtd_oob_buf oob = {0, 16, oobbuf};
	char *mtddevice, *nftl;
	int c, do_inftl = 0, do_bbt = 0;


	printf("$Id: nftl_format.c,v 1.24 2005/11/07 11:15:13 gleixner Exp $\n");

	if (argc < 2)
        	usage(1);

	nftl = "NFTL";

	while ((c = getopt(argc, argv, "?hib")) > 0) {
		switch (c) {
		case 'i':
			nftl = "INFTL";
			do_inftl = 1;
			break;
		case 'b':
			do_bbt = 1;
			break;
		case 'h':
		case '?':
			usage(0);
			break;
		default:
			usage(1);
			break;
		}
	}

	mtddevice = argv[optind++];
	if (argc > optind) {
		startofs = strtoul(argv[optind++], NULL, 0);
	}
	if (argc > optind) {
		part_size = strtoul(argv[optind++], NULL, 0);
	}

	// Open and size the device
	if ((fd = open(mtddevice, O_RDWR)) < 0) {
		perror("Open flash device");
		return 1;
	}

	if (ioctl(fd, MEMGETINFO, &meminfo) != 0) {
		perror("ioctl(MEMGETINFO)");
		close(fd);
		return 1;
	}

	switch (meminfo.erasesize) {
	case 0x1000:
	case 0x2000:
	case 0x4000:
	case 0x8000:
		break;
	default:
		printf("Unrecognized Erase size, 0x%x - I'm confused\n",
			meminfo.erasesize);
		close(fd);
		return 1;
	}
	writebuf[0] = malloc(meminfo.erasesize * 5);
	if (!writebuf[0]) {
		printf("Malloc failed\n");
		close(fd);
		return 1;
	}
	writebuf[1] = writebuf[0] + meminfo.erasesize;
	writebuf[2] = writebuf[1] + meminfo.erasesize;
	writebuf[3] = writebuf[2] + meminfo.erasesize;
	readbuf = writebuf[3] + meminfo.erasesize;
	memset(writebuf[0], 0xff, meminfo.erasesize);
	memset(writebuf[1], 0x00, meminfo.erasesize);
	memset(writebuf[2], 0x5a, meminfo.erasesize);
	memset(writebuf[3], 0xa5, meminfo.erasesize);
	memset(BadUnitTable, ZONE_GOOD, MAX_ERASE_ZONES);

	if (part_size == 0 || (part_size > meminfo.size - startofs))
		/* the user doest not or incorrectly specify NFTL partition size */
		part_size = meminfo.size - startofs;

	erase.length = meminfo.erasesize;
	ezones = part_size / meminfo.erasesize;

	if (ezones > MAX_ERASE_ZONES) {
		/* Ought to change the UnitSizeFactor. But later. */
		part_size = meminfo.erasesize * MAX_ERASE_ZONES;
		ezones = MAX_ERASE_ZONES;
		unit_factor = 0xFF;
	}

	/* If using device BBT then parse that now */
	if (do_bbt) {
		checkbbt();
		do_oobcheck = 0;
		do_rwecheck = 0;
	}

	/* Phase 1. Erasing and checking each erase zones in the NFTL partition.
	   N.B. Erase Zones not used by the NFTL partition are untouched and marked ZONE_GOOD */
	printf("Phase 1. Checking and erasing Erase Zones from 0x%08lx to 0x%08lx\n",
	       startofs, startofs + part_size);
	for (ezone = startofs / meminfo.erasesize;
	     ezone < (ezones + startofs / meminfo.erasesize); ezone++) {
		if (BadUnitTable[ezone] != ZONE_GOOD)
			continue;
		if ((BadUnitTable[ezone] = erase_block(ezone)) == ZONE_GOOD) {
			if (MediaUnit1 == -1) {
				MediaUnit1 = ezone;
			} else if (MediaUnit2 == -1) {
				MediaUnit2 = ezone;
			}
		} else {
			bad_zones++;
		}
	}
	printf("\n");

	/* N.B. from dump of M-System original chips, NumEraseUnits counts the 2 Erase Unit used
	   by MediaHeader and the FirstPhysicalEUN starts from the MediaHeader */
	if (do_inftl) {
		unsigned long maxzones, pezstart, pezend, numvunits;

		INFTLhdr = (struct INFTLMediaHeader *) (writebuf[0]);
		strcpy(INFTLhdr->bootRecordID, "BNAND");
		INFTLhdr->NoOfBootImageBlocks = cpu_to_le32(0);
		INFTLhdr->NoOfBinaryPartitions = cpu_to_le32(0);
		INFTLhdr->NoOfBDTLPartitions = cpu_to_le32(1);
		INFTLhdr->BlockMultiplierBits = cpu_to_le32(0);
		INFTLhdr->FormatFlags = cpu_to_le32(0);
		INFTLhdr->OsakVersion = cpu_to_le32(OSAK_VERSION);
		INFTLhdr->PercentUsed = cpu_to_le32(PERCENTUSED);
		/*
		 * Calculate number of virtual units we will have to work
		 * with. I am calculating out the known bad units here, not
		 * sure if that is what M-Systems do...
		 */
		MediaUnit2 = MediaUnit1;
		MediaUnitOff2 = 4096;
		maxzones = meminfo.size / meminfo.erasesize;
		pezstart = startofs / meminfo.erasesize + 1;
		pezend = startofs / meminfo.erasesize + ezones - 1;
		numvunits = (ezones - 2) * PERCENTUSED / 100;
		for (ezone = pezstart; ezone < maxzones; ezone++) {
			if (BadUnitTable[ezone] != ZONE_GOOD) {
				if (numvunits > 1)
					numvunits--;
			}
		}

		INFTLhdr->Partitions[0].virtualUnits = cpu_to_le32(numvunits);
		INFTLhdr->Partitions[0].firstUnit = cpu_to_le32(pezstart);
		INFTLhdr->Partitions[0].lastUnit = cpu_to_le32(pezend);
		INFTLhdr->Partitions[0].flags = cpu_to_le32(INFTL_BDTL);
		INFTLhdr->Partitions[0].spareUnits = cpu_to_le32(0);
		INFTLhdr->Partitions[0].Reserved0 = INFTLhdr->Partitions[0].firstUnit;
		INFTLhdr->Partitions[0].Reserved1 = cpu_to_le32(0);

	} else {

		NFTLhdr = (struct NFTLMediaHeader *) (writebuf[0]);
		strcpy(NFTLhdr->DataOrgID, "ANAND");
		NFTLhdr->NumEraseUnits = cpu_to_le16(part_size / meminfo.erasesize);
		NFTLhdr->FirstPhysicalEUN = cpu_to_le16(MediaUnit1);
		/* N.B. we reserve 2 more Erase Units for "folding" of Virtual Unit Chain */
		NFTLhdr->FormattedSize = cpu_to_le32(part_size - ( (5+bad_zones) * meminfo.erasesize));
		NFTLhdr->UnitSizeFactor = unit_factor;
	}

	/* Phase 2. Writing NFTL Media Headers and Bad Unit Table */
	printf("Phase 2.a Writing %s Media Header and Bad Unit Table\n", nftl);
	pwrite(fd, writebuf[0], 512, MediaUnit1 * meminfo.erasesize + MediaUnitOff1);
	for (ezone = 0; ezone < (meminfo.size / meminfo.erasesize); ezone += 512) {
		pwrite(fd, BadUnitTable + ezone, 512,
			(MediaUnit1 * meminfo.erasesize) + 512 * (1 + ezone / 512));
	}

#if 0
	printf("  MediaHeader contents:\n");
	printf("    NumEraseUnits: %d\n", le16_to_cpu(NFTLhdr->NumEraseUnits));
	printf("    FirstPhysicalEUN: %d\n", le16_to_cpu(NFTLhdr->FirstPhysicalEUN));
	printf("    FormattedSize: %d (%d sectors)\n", le32_to_cpu(NFTLhdr->FormattedSize),
	       le32_to_cpu(NFTLhdr->FormattedSize)/512);
#endif
	printf("Phase 2.b Writing Spare %s Media Header and Spare Bad Unit Table\n", nftl);
	pwrite(fd, writebuf[0], 512, MediaUnit2 * meminfo.erasesize + MediaUnitOff2);
	for (ezone = 0; ezone < (meminfo.size / meminfo.erasesize); ezone += 512) {
		pwrite(fd, BadUnitTable + ezone, 512,
			(MediaUnit2 * meminfo.erasesize + MediaUnitOff2) + 512 * (1 + ezone / 512));
	}

	/* UCI #1 for newly erased Erase Unit */
	memset(oobbuf, 0xff, 16);
	oobbuf[11] = oobbuf[10] = oobbuf[9] = 0;
	oobbuf[8]  = (do_inftl) ? 0x00 : 0x03;
	oobbuf[12] = oobbuf[14] = 0x69;
	oobbuf[13] = oobbuf[15] = 0x3c;

	/* N.B. The Media Header and Bad Erase Unit Table are considered as Free Erase Unit
	   by M-System i.e. their Virtual Unit Number == 0xFFFF in the Unit Control Information #0,
	   but their Block Status is BLOCK_USED (0x5555) in their Block Control Information */
	/* Phase 3. Writing Unit Control Information for each Erase Unit */
	printf("Phase 3. Writing Unit Control Information to each Erase Unit\n");
	for (ezone = MediaUnit1; ezone < (ezones + startofs / meminfo.erasesize); ezone++) {
		/* write UCI #1 to each Erase Unit */
		if (BadUnitTable[ezone] != ZONE_GOOD)
			continue;
		oob.start = (ezone * meminfo.erasesize) + 512 + (do_inftl * 512);
		if (ioctl(fd, MEMWRITEOOB, &oob))
			printf("MEMWRITEOOB at %lx: %s\n", (unsigned long)oob.start, strerror(errno));
	}

	exit(0);
}
コード例 #11
0
int main (void)
{
	char x, y;
	//char a = 0;
    ioinit(); //Setup IO pins and defaults
	USART_Init( MYUBRR);
	rprintf_devopen(put_char); /* init rrprintf */
	
	//set_data(0x55);

	//PORTC |= ((1 << RESET) | (1 << EN) | (1 << R_W) | (1 << CS1) | (1 << CS2) | (1 << RS));//all high
	
	//while(1);
	
	/*
	while(1)
	{
		PORTC &= ~((1 << EN) | (1 << R_W) | (1 << CS1) | (1 << CS2));//down
		delay_ms(500);
		//PORTC |= ((1 << EN) | (1 << R_W) | (1 << CS1) | (1 << CS2));//all high
		PORTC |= ((1 << RESET) | (1 << EN) | (1 << R_W) | (1 << CS1) | (1 << CS2) | (1 << RS));//all high
		delay_ms(500);
	}
	*/
	/*
	DDRC = 0b00000001;
	
	while(1)
	{
		PORTC |= 0b00000001;
		delay_1uS();
		PORTC &= 0b11111110;
		delay_1uS();
	
	}
	*/
	
	//Reset the display
	//PORTC = 0b11110111;
	PORTC &= ~(1 << RESET);
	delay_ms(50);
	PORTC |= (1 << RESET);
	delay_ms(500);
	
	clear_screen();
	
	set_page(0);
	set_x(0);
	
	display_on();
	
	//set display start line to 0
	//set control lines
	
	PORTC &= ~((1 << EN) | (1 << R_W) | (1 << RS));//down
	set_port_out();
	//set_data(0xC0);
	set_data(0xC0);
	delay_us(4);
	PORTC |= (1 << EN);//up
	delay_us(4);
	PORTC &= ~(1 << EN);//down
	delay_us(4);
	PORTC |= ((1 << EN) | (1 << R_W) | (1 << RS));//all high
	
	set_port_in();
	delay_us(4);
	
	
	x_offset = 0;

	set_page(0);
	
	//Backlight on
	PORTB &= (~(1<<BL_EN));
	
	//demo();  
	//put_char('X');
	
	while(1)
	{
		if(RX_in != RX_read)
		{
			x = RX_array[RX_read];
			RX_read++;
			if(RX_read >= 256) RX_read = 0;
			
			
			
			//Backspace===================================================
			if(x == 8) del_char(0);
			
			//Special commands
			else if (x == 124)
			{	
				//make sure the next byte is there
				while(RX_in == RX_read);
				
				//0, clear screen======================================================
				if(RX_array[RX_read] == 0)
				{
					clear_screen();
					RX_read++;
					if(RX_read >= 256) RX_read = 0;
				}
				
				
				//Backlight on/off
				else if(RX_array[RX_read] == 2)
				{
					y = PINB;
					if (y & (1<<BL_EN)) PORTB &= (~(1<<BL_EN));
					else PORTB |= (1<<BL_EN);
					RX_read++;
				}
				
				//demo mode
				else if(RX_array[RX_read] == 4)
				{
					RX_in = 0, RX_read = 0;
					demo();
					clear_screen();
					RX_in = 0;
				}
				
				else
				{				
					//set x or y=========================================================
					if((RX_array[RX_read] == 24) | (RX_array[RX_read] == 25))
					{
						RX_read++;
						if(RX_read >= 256) RX_read = 0;
						while(RX_in == RX_read);//wait for byte
						if (RX_array[RX_read-1] == 24) x_offset = RX_array[RX_read];
						else if (RX_array[RX_read-1] == 25) y_offset = RX_array[RX_read];
						
						RX_read++;
						if(RX_read >= 256) RX_read = 0;
						
						if (x_offset > 127) x_offset = 127;
						if (y_offset > 63) y_offset = 63;

					}

					//set pixel=========================================================
					if (RX_array[RX_read] == 16)
					{
						//need 3 bytes
						for (y = 0; y < 3; y++)
						{
							RX_read++;
							if(RX_read >= 256) RX_read = 0;
							while(RX_in == RX_read);//wait for byte
						}
						
						pixel(RX_array[RX_read], RX_array[RX_read-2], RX_array[RX_read-1]);
						
						RX_read++;
						if(RX_read >= 256) RX_read = 0;

					}

					//<ctrl>c, circle======================================================
					if(RX_array[RX_read] == 3)
					{
						//need 4 bytes
						for (y = 0; y < 4; y++)
						{
							RX_read++;
							if(RX_read >= 256) RX_read = 0;
							while(RX_in == RX_read);//wait for byte
						}
						
						circle(RX_array[RX_read], RX_array[RX_read-3], RX_array[RX_read-2], RX_array[RX_read-1]);
						
						RX_read++;
						if(RX_read >= 256) RX_read = 0;
					}
					
					
					//<ctrl>e, erase block======================================================
					if(RX_array[RX_read] == 5)
					{
						//need 4 bytes
						for (y = 0; y < 4; y++)
						{
							RX_read++;
							if(RX_read >= 256) RX_read = 0;
							while(RX_in == RX_read);//wait for byte
						}
						
						erase_block(RX_array[RX_read-3], RX_array[RX_read-2], RX_array[RX_read-1], RX_array[RX_read]);
						
						RX_read++;
						if(RX_read >= 256) RX_read = 0;
					}
					
					
					//<ctrl>o, box, running out of meaningful letters======================================================
					if(RX_array[RX_read] == 15)
					{
						//need 4 bytes
						for (y = 0; y < 4; y++)
						{
							RX_read++;
							if(RX_read >= 256) RX_read = 0;
							while(RX_in == RX_read);//wait for byte
						}
						
						box(RX_array[RX_read-3], RX_array[RX_read-2], RX_array[RX_read-1], RX_array[RX_read]);
						
						RX_read++;
						if(RX_read >= 256) RX_read = 0;
					}
					

					//<ctrl>L, line========================================================
					else if (RX_array[RX_read] == 12)
					{
						//need 5 bytes
						for (y = 0; y < 5; y++)
						{
							RX_read++;
							if(RX_read >= 256) RX_read = 0;
							while(RX_in == RX_read);//wait for byte
						}
						
						line(RX_array[RX_read], RX_array[RX_read-4], RX_array[RX_read-3], RX_array[RX_read-2], RX_array[RX_read+-1]);
						RX_read++;
						if(RX_read >= 256) RX_read = 0;
					}
					
					
				}
	
			}
			
			//print character to the screen===============================================
			else
			{
				
				del_char(1);
				//put_char('L');
				print_char(1, x);
				
			}
			
			//set_data(0xFF);
			//set_port_in();
			//display_on();
			//y = PINB;
			//PORTB = y;
		}
		
	}
	
}
コード例 #12
0
static int reclaim_block(struct partition *part, u_long *old_sector)
{
	int block, best_block, score, old_sector_block;
	int rc;

	
	if (part->mbd.mtd->sync)
		part->mbd.mtd->sync(part->mbd.mtd);

	score = 0x7fffffff; 
	best_block = -1;
	if (*old_sector != -1)
		old_sector_block = *old_sector / part->block_size;
	else
		old_sector_block = -1;

	for (block=0; block<part->total_blocks; block++) {
		int this_score;

		if (block == part->reserved_block)
			continue;

		
		if (part->blocks[block].free_sectors)
			return 0;

		this_score = part->blocks[block].used_sectors;

		if (block == old_sector_block)
			this_score--;
		else {
			
			if (part->blocks[block].used_sectors ==
					part->data_sectors_per_block)
				continue;
		}

		this_score += part->blocks[block].erases;

		if (this_score < score) {
			best_block = block;
			score = this_score;
		}
	}

	if (best_block == -1)
		return -ENOSPC;

	part->current_block = -1;
	part->reserved_block = best_block;

	pr_debug("reclaim_block: reclaiming block #%d with %d used "
		 "%d free sectors\n", best_block,
		 part->blocks[best_block].used_sectors,
		 part->blocks[best_block].free_sectors);

	if (part->blocks[best_block].used_sectors)
		rc = move_block_contents(part, best_block, old_sector);
	else
		rc = erase_block(part, best_block);

	return rc;
}
コード例 #13
0
int main (void)
{
        char x, y, a;
        
    ioinit(); //Setup IO pins and defaults
        USART_Init( MYUBRR);
        rprintf_devopen(put_char); /* init rrprintf */
        
        //reset the display
        delay_ms(1);
        PORTC |= (1<<RST);
        
        //initialize the display
        display_init();

        clear_screen();
        
        //Backlight on
        PORTB &= (~(1<<BL_EN));
        
        while(1)
        {
                if(RX_in != RX_read)
                {
                        x = RX_array[RX_read];
                        RX_read++;
                        if(RX_read >= 256) RX_read = 0;
                        
                        //Backspace===================================================
                        if(x == 8) del_char(0);
                        
                        //Special commands
                        else if (x == 124)
                        {        
                                //make sure the next byte is there
                                while(RX_in == RX_read);
                                
                                //0, clear screen======================================================
                                if(RX_array[RX_read] == 0)
                                {
                                        clear_screen();
                                        RX_read++;
                                        if(RX_read >= 256) RX_read = 0;
                                }
                                
                                
                                //Backlight on/off
                                else if(RX_array[RX_read] == 2)
                                {
                                        y = PINB;
                                        if (y & (1<<BL_EN)) PORTB &= (~(1<<BL_EN));
                                        else PORTB |= (1<<BL_EN);
                                        RX_read++;
                                }
                                
                                //demo mode
                                else if(RX_array[RX_read] == 4)
                                {
                                        RX_in = 0, RX_read = 0;
                                        demo();
                                        clear_screen();
                                        RX_in = 0;
                                }
                                
                                else
                                {                                
                                        //set x or y=========================================================
                                        if((RX_array[RX_read] == 24) | (RX_array[RX_read] == 25))
                                        {
                                                RX_read++;
                                                if(RX_read >= 256) RX_read = 0;
                                                while(RX_in == RX_read);//wait for byte
                                                if (RX_array[RX_read-1] == 24) x_offset = RX_array[RX_read];
                                                else if (RX_array[RX_read-1] == 25) y_offset = RX_array[RX_read];
                                                
                                                RX_read++;
                                                if(RX_read >= 256) RX_read = 0;
                                                
                                                if (x_offset > 159) x_offset = 159;
                                                if (y_offset > 127) y_offset = 127;

                                        }

                                        //set pixel=========================================================
                                        if (RX_array[RX_read] == 16)
                                        {
                                                //need 3 bytes
                                                for (y = 0; y < 3; y++)
                                                {
                                                        RX_read++;
                                                        if(RX_read >= 256) RX_read = 0;
                                                        while(RX_in == RX_read);//wait for byte
                                                }
                                                
                                                pixel(RX_array[RX_read], RX_array[RX_read-2], RX_array[RX_read-1]);
                                                
                                                RX_read++;
                                                if(RX_read >= 256) RX_read = 0;

                                        }

                                        //<ctrl>c, circle======================================================
                                        if(RX_array[RX_read] == 3)
                                        {
                                                //need 4 bytes
                                                for (y = 0; y < 4; y++)
                                                {
                                                        RX_read++;
                                                        if(RX_read >= 256) RX_read = 0;
                                                        while(RX_in == RX_read);//wait for byte
                                                }
                                                
                                                circle(RX_array[RX_read], RX_array[RX_read-3], RX_array[RX_read-2], RX_array[RX_read-1]);
                                                
                                                RX_read++;
                                                if(RX_read >= 256) RX_read = 0;
                                        }
                                        
                                        
                                        //<ctrl>e, erase block======================================================
                                        if(RX_array[RX_read] == 5)
                                        {
                                                //need 4 bytes
                                                for (y = 0; y < 4; y++)
                                                {
                                                        RX_read++;
                                                        if(RX_read >= 256) RX_read = 0;
                                                        while(RX_in == RX_read);//wait for byte
                                                }
                                                
                                                erase_block(RX_array[RX_read-3], RX_array[RX_read-2], RX_array[RX_read-1], RX_array[RX_read]);
                                                
                                                RX_read++;
                                                if(RX_read >= 256) RX_read = 0;
                                        }
                                        
                                        
                                        //<ctrl>o, box, running out of meaningful letters======================================================
                                        if(RX_array[RX_read] == 15)
                                        {
                                                //need 4 bytes
                                                for (y = 0; y < 4; y++)
                                                {
                                                        RX_read++;
                                                        if(RX_read >= 256) RX_read = 0;
                                                        while(RX_in == RX_read);//wait for byte
                                                }
                                                
                                                box(RX_array[RX_read-3], RX_array[RX_read-2], RX_array[RX_read-1], RX_array[RX_read]);
                                                
                                                RX_read++;
                                                if(RX_read >= 256) RX_read = 0;
                                        }


                                        //<ctrl>L, line========================================================
                                        else if (RX_array[RX_read] == 12)
                                        {
                                                //need 5 bytes
                                                for (y = 0; y < 5; y++)
                                                {
                                                        RX_read++;
                                                        if(RX_read >= 256) RX_read = 0;
                                                        while(RX_in == RX_read);//wait for byte
                                                }
                                                
                                                line(RX_array[RX_read], RX_array[RX_read-4], RX_array[RX_read-3], RX_array[RX_read-2], RX_array[RX_read+-1]);
                                                RX_read++;
                                                if(RX_read >= 256) RX_read = 0;
                                        }
                                        
                                        
                                }
        
                        }
                        
                        //print character to the screen===============================================
                        else
                        {
                                del_char(1);
                                print_char(1, x);
                        }
                }
                
        }
        
        

}
コード例 #14
0
ファイル: vuprom.c プロジェクト: A2-Collaboration/a2vme
void eraseFlashMemory(int moduleNumber, bool simulate, bool verbose)
{
  int i;
  int status;
  bool errorOccured = true;
  int loopCounter = 0;
  unsigned long vmeaddr;
  unsigned long vme_virt_addr;
  int fbase;

  printlog("erasing flash memory", true, !quiet);
  while (errorOccured && (loopCounter < MAXLOOPS)) {
    loopCounter++;
    printlog("attempt #: ", true, verbose);
    printlogInt(loopCounter, verbose);
    errorOccured = false;
    vmeaddr = moduleNumber * MODULE_LENGTH  ;
    vme_virt_addr = (unsigned long) openvme((void *)vmeaddr, VME_LENGTH, verbose);
    fbase = vme_virt_addr + FLASHBASE;
    select_range(vme_virt_addr, 0+RANGENUMBER, verbose);
    for (i = 0; i <= 7; i++) {
      printlog("block #: ", true, verbose);
      printlogInt(i, verbose);
      if (!simulate) {
        status = erase_block(fbase, i, verbose);
      } else {
        status = 0;
      }
      if (status == 0) {
        printlog(" successfully erased", false, verbose);
      } else {
        printlog(" can\'t be erased", false, verbose);
        errorOccured = true;
      }
    }

    if (!errorOccured) {
      select_range(vme_virt_addr, 1+RANGENUMBER, verbose);
      for (i = 0; i <= 7; i++) {
        printlog("block #: ", true, verbose);
        printlogInt(i, verbose);
        if (!simulate) {
          status = erase_block(fbase, i, verbose);
        } else {
          status = 0;
        }
        if (status == 0) {
          printlog(" successfully erased", false, verbose);
        } else {
          printlog(" can\'t be erased", false, verbose);
          errorOccured = true;
        }
      }
    }
    read_array(fbase);
    closevme(verbose);
    sleep(2);
  }
  if(errorOccured) {
    printlog("Error erasing flash memory, aborting", true, verbose);
    closeLog(verbose);
    exit(1);
  }

}
コード例 #15
0
int main (void)
{
	char x, y, temp, q;
    ioinit(); //Setup IO pins and defaults
	//USART_Init( MYUBRR);
	set_baud(6);//115200
	rprintf_devopen(put_char); /* init rrprintf */
	
	//check for existing preset values==============================================================
	temp = EEPROM_read((unsigned int)BPS);
	
	if ((temp < 1) | (temp > 6))//BPS will only be 1-6
	{
		cli();//Disable Interrupts
		
		EEPROM_write((unsigned int) BPS, 6);
		EEPROM_write((unsigned int) BACKLIGHT, 100);
		EEPROM_write((unsigned int) SPLASH, 1);
		EEPROM_write((unsigned int) REV, 0);
		
		sei();//Enable Interrupts
		
		BL_dutycycle = 100;
		baud_rate = 6;
		splash_screen = 1;
		reverse = 0;
	}
	
	else
	{
		baud_rate = temp;
		BL_dutycycle = EEPROM_read((unsigned int)BACKLIGHT);
		splash_screen = EEPROM_read((unsigned int)SPLASH);
		reverse = EEPROM_read((unsigned int)REV);
	}
	
	
	//Reset the display
	PORTC &= ~(1 << RESET);
	delay_ms(50);
	PORTC |= (1 << RESET);
	//delay_ms(500);

	
	clear_screen();

	set_page(0);
	
	set_x(0);
	
	display_on();
	
	//set display start line to 0
	//set control lines
	PORTC &= ~((1 << EN) | (1 << R_W) | (1 << RS));//down
	
	set_data(0xC0);
	//set_data(0xFF);
	delay();
	PORTC |= (1 << EN);//up
	delay();
	PORTC &= ~(1 << EN);//down
	delay();
	PORTC |= ((1 << EN) | (1 << R_W) | (1 << RS));//all high
	
	delay();
	
	x_offset = 0;

	set_page(0);
	
	DDRB |= (1<<BL_EN);//set PB2 as output
	
	set_backlight(BL_dutycycle);
	
	//Logo==========================================================
	if (splash_screen == 1)
	{
		y = 40;
		
		for (q = 0; q < 30; q++)
		{
			temp = logo[q];
			for (x = 56; x < 64; x++)
			{
				if (temp & 0x80) pixel(1,x,y);
				
				temp <<= 1;
			}
			
			q++;
			
			temp = logo[q];
			for (x = 64; x < 72; x++)
			{
				if (temp & 0x80) pixel(1,x,y);
				
				temp <<= 1;
			}
			y--;
	
		}	
	}
	
	pixel(0,0,0);//cheat
	
	RX_in = 0;
	
	delay_ms(1000);
	clear_screen();
	
	if (RX_in > 0)//revert to 115200
	{
		print_char(1,'1');
		print_char(1,'1');
		print_char(1,'5');
		print_char(1,'2');
		print_char(1,'0');
		print_char(1,'0');
		
		baud_rate = 6;
		set_baud(6);//115200
		
		cli();
		
		EEPROM_write((unsigned int) BPS, 6);
		
		sei();//Enable Interrupts
	}
	
	else (set_baud(baud_rate));
	
	delay_ms(1000);
	clear_screen();
	
	//main loop===================================================
	while(1)
	{
		if(RX_in != RX_read)
		{
			x = RX_array[RX_read];
			RX_read++;
			if(RX_read >= 416) RX_read = 0;
			
			//Backspace===================================================
			if(x == 8) del_char(0);
			
			//Special commands
			else if (x == 124)
			{	
				//make sure the next byte is there
				while(RX_in == RX_read);
				
				//0, clear screen======================================================
				if(RX_array[RX_read] == 0)//^@
				{
					clear_screen();
					RX_read++;
					if(RX_read >= 416) RX_read = 0;
				}
				
				//demo mode
				else if(RX_array[RX_read] == 4)//^d
				{
					RX_in = 0, RX_read = 0;
					demo();
					clear_screen();
					RX_in = 0;
				}
				
				
				//reverse mode
				else if(RX_array[RX_read] == 18)//^r
				{
					reverse ^= 1;
					clear_screen();
					RX_read++;
					if(RX_read >= 416) RX_read = 0;
					
					cli();
					EEPROM_write((unsigned int) REV, reverse);
					sei();
				}
				
				
				//toggle spasl screen
				else if(RX_array[RX_read] == 19)//^s
				{
					splash_screen ^= 1;
					//clear_screen();
					RX_read++;
					if(RX_read >= 416) RX_read = 0;
					
					cli();
					EEPROM_write((unsigned int) SPLASH, splash_screen);
					sei();
				}
				
				else
				{
					//set backlight (0 to 100)=========================================================
					if(RX_array[RX_read] == 2)//^b
					{
						RX_read++;
						if(RX_read >= 416) RX_read = 0;
						while(RX_in == RX_read);//wait for byte
						BL_dutycycle = RX_array[RX_read];
						
						RX_read++;
						if(RX_read >= 416) RX_read = 0;
						
						set_backlight(BL_dutycycle);
						
						cli();
						EEPROM_write((unsigned int) BACKLIGHT, BL_dutycycle);
						sei();
						
						

					}
					
					
					//change baud rate=========================================================
					if(RX_array[RX_read] == 7)//^g
					{
						RX_read++;
						if(RX_read >= 416) RX_read = 0;
						while(RX_in == RX_read);//wait for byte
						//if (RX_array[RX_read] == '1') USART_Init( 1000000/2400-1);//4800
						//else if (RX_array[RX_read] == '2') USART_Init( 1000000/4800-1);//9600
						//else if (RX_array[RX_read] == '3') USART_Init( 1000000/9600-1);//19200
						//else if (RX_array[RX_read] == '4') USART_Init( 1000000/19200-1);//38400
						//else if (RX_array[RX_read] == '5') USART_Init( 1000000/28800-1);//57600
						//else if (RX_array[RX_read] == '6') USART_Init( 1000000/57600-1);//115200
						
						if ((RX_array[RX_read] > '0') * (RX_array[RX_read] < '7')) baud_rate = (RX_array[RX_read]) - 48;
						
						set_baud(baud_rate);
						
						cli();
						EEPROM_write((unsigned int) BPS, baud_rate);
						sei();
						
						RX_read++;
						if(RX_read >= 416) RX_read = 0;
						
					}	
					
					
					//set x or y=========================================================
					if((RX_array[RX_read] == 24) | (RX_array[RX_read] == 25))//^x or ^y
					{
						RX_read++;
						if(RX_read >= 416) RX_read = 0;
						while(RX_in == RX_read);//wait for byte
						if (RX_array[RX_read-1] == 24) x_offset = RX_array[RX_read];
						else if (RX_array[RX_read-1] == 25) y_offset = RX_array[RX_read];
						
						RX_read++;
						if(RX_read >= 416) RX_read = 0;
						
						if (x_offset > 159) x_offset = 159;
						if (y_offset > 127) y_offset = 127;

					}

					//set pixel=========================================================
					if (RX_array[RX_read] == 16)//^p
					{
						//need 3 bytes
						for (y = 0; y < 3; y++)
						{
							RX_read++;
							if(RX_read >= 416) RX_read = 0;
							while(RX_in == RX_read);//wait for byte
						}
						
						pixel(RX_array[RX_read], RX_array[RX_read-2], RX_array[RX_read-1]);
						
						RX_read++;
						if(RX_read >= 416) RX_read = 0;

					}

					
					//<ctrl>c, circle======================================================
					if(RX_array[RX_read] == 3)//^c
					{
						//need 4 bytes
						for (y = 0; y < 4; y++)
						{
							RX_read++;
							if(RX_read >= 416) RX_read = 0;
							while(RX_in == RX_read);//wait for byte
						}
						
						circle(RX_array[RX_read], RX_array[RX_read-3], RX_array[RX_read-2], RX_array[RX_read-1]);
						
						RX_read++;
						if(RX_read >= 416) RX_read = 0;
					}
					
					
					//<ctrl>e, erase block======================================================
					if(RX_array[RX_read] == 5)//^e
					{
						//need 4 bytes
						for (y = 0; y < 4; y++)
						{
							RX_read++;
							if(RX_read >= 416) RX_read = 0;
							while(RX_in == RX_read);//wait for byte
						}
						
						erase_block(RX_array[RX_read-3], RX_array[RX_read-2], RX_array[RX_read-1], RX_array[RX_read]);
						
						RX_read++;
						if(RX_read >= 416) RX_read = 0;
					}
					
					
					//box======================================================
					if(RX_array[RX_read] == 15)//^o
					{
						//need 4 bytes
						for (y = 0; y < 4; y++)
						{
							RX_read++;
							if(RX_read >= 416) RX_read = 0;
							while(RX_in == RX_read);//wait for byte
						}
						
						box(RX_array[RX_read-3], RX_array[RX_read-2], RX_array[RX_read-1], RX_array[RX_read]);
						
						RX_read++;
						if(RX_read >= 416) RX_read = 0;
					}


					//line========================================================
					else if (RX_array[RX_read] == 12)//^l
					{
						//need 5 bytes
						for (y = 0; y < 5; y++)
						{
							RX_read++;
							if(RX_read >= 416) RX_read = 0;
							while(RX_in == RX_read);//wait for byte
						}
						
						line(RX_array[RX_read], RX_array[RX_read-4], RX_array[RX_read-3], RX_array[RX_read-2], RX_array[RX_read+-1]);
						RX_read++;
						if(RX_read >= 416) RX_read = 0;
					}
					
					
				}
	
			}
			
			//print character to the screen===============================================
			else
			{
				del_char(1);
				print_char(1, x);
			}
		}
		
	}
	
	//demo();
	


    
}
コード例 #16
0
int main(int argc, char **argv)
{
	unsigned long startofs = 0, part_size = 0;
	unsigned long ezones = 0, ezone = 0, bad_zones = 0;
	unsigned char unit_factor = 0xFF;

	long MediaUnit1 = -1, MediaUnit2 = -1;
	unsigned char oobbuf[16];
	struct mtd_oob_buf oob = {0, 16, oobbuf};

	printf("$Id: nftl_format.c,v 1.1.1.1 2006-07-11 09:31:28 andy Exp $\n");

	if (argc < 2) {
		fprintf(stderr, "Usage: %s <mtddevice> [<start offset> [<size>]]\n",
			argv[0]);
		return 1;
	}

	if (argc > 2) {
		startofs = strtoul(argv[2], NULL, 0);
	}
	if (argc > 3) {
		part_size = strtoul(argv[3], NULL, 0);
	}

	// Open and size the device
	if ((fd = open(argv[1], O_RDWR)) < 0) {
		perror("Open flash device");
		return 1;
	}

	if (ioctl(fd, MEMGETINFO, &meminfo) != 0) {
		perror("ioctl(MEMGETINFO)");
		close(fd);
		return 1;
	}

	switch (meminfo.erasesize) {
	case 0x1000:
	case 0x2000:
	case 0x4000:
		break;
	default:
		printf("Unrecognized Erase size, 0x%x - I'm confused\n", 
			meminfo.erasesize);
		close(fd);
		return 1;
	}
	writebuf[0] = malloc(meminfo.erasesize * 5);
	if (!writebuf[0]) {
		printf("Malloc failed\n");
		close(fd);
		return 1;
	}
	writebuf[1] = writebuf[0] + meminfo.erasesize;
	writebuf[2] = writebuf[1] + meminfo.erasesize;
	writebuf[3] = writebuf[2] + meminfo.erasesize;
	readbuf = writebuf[3] + meminfo.erasesize;
	memset(writebuf[0], 0xff, meminfo.erasesize);
	memset(writebuf[1], 0x00, meminfo.erasesize);
	memset(writebuf[2], 0x5a, meminfo.erasesize);
	memset(writebuf[3], 0xa5, meminfo.erasesize);
	memset(BadUnitTable, ZONE_GOOD, MAX_ERASE_ZONES);

	if (part_size == 0 || (part_size > meminfo.size - startofs))
		/* the user doest not or incorrectly specify NFTL partition size */ 
		part_size = meminfo.size - startofs;

	erase.length = meminfo.erasesize;
	ezones = part_size / meminfo.erasesize;

	if (ezones > MAX_ERASE_ZONES) {
		/* Ought to change the UnitSizeFactor. But later. */
		part_size = meminfo.erasesize * MAX_ERASE_ZONES;
		ezones = MAX_ERASE_ZONES;
		unit_factor = 0xFF;
	}

	/* Phase 1. Erasing and checking each erase zones in the NFTL partition.
	   N.B. Erase Zones not used by the NFTL partition are untouched and marked ZONE_GOOD */
	printf("Phase 1. Checking and erasing Erase Zones from 0x%08lx to 0x%08lx\n",
	       startofs, startofs + part_size);
	for (ezone = startofs / meminfo.erasesize;
	     ezone < (ezones + startofs / meminfo.erasesize); ezone++) {
		if ((BadUnitTable[ezone] = erase_block(ezone)) == ZONE_GOOD) {
			if (MediaUnit1 == -1) {
				MediaUnit1 = ezone;
			} else if (MediaUnit2 == -1) {
				MediaUnit2 = ezone;
			}
		} else {
			bad_zones++;
		}
	}
	printf("\n");

	/* N.B. from dump of M-System original chips, NumEraseUnits counts the 2 Erase Unit used
	   by MediaHeader and the FirstPhysicalEUN starts from the MediaHeader */
	NFTLhdr = (struct NFTLMediaHeader *) (writebuf[0]);
	strcpy(NFTLhdr->DataOrgID, "ANAND");
	NFTLhdr->NumEraseUnits = cpu_to_le16(part_size / meminfo.erasesize);
	NFTLhdr->FirstPhysicalEUN = cpu_to_le16(MediaUnit1);
	/* N.B. we reserve 2 more Erase Units for "folding" of Virtual Unit Chain */
	NFTLhdr->FormattedSize = cpu_to_le32(part_size - ( (5+bad_zones) * meminfo.erasesize));
	NFTLhdr->UnitSizeFactor = unit_factor;

	/* Phase 2. Writing NFTL Media Headers and Bad Unit Table */
	printf("Phase 2.a Writing NFTL Media Header and Bad Unit Table\n");
	pwrite(fd, writebuf[0], 512, MediaUnit1 * meminfo.erasesize);
	for (ezone = 0; ezone < (meminfo.size / meminfo.erasesize); ezone += 512) {
		pwrite(fd, BadUnitTable + ezone, 512,
		       (MediaUnit1 * meminfo.erasesize) + 512 * (1 + ezone / 512));
	}
#if 0
	printf("  MediaHeader contents:\n");
	printf("    NumEraseUnits: %d\n", le16_to_cpu(NFTLhdr->NumEraseUnits));
	printf("    FirstPhysicalEUN: %d\n", le16_to_cpu(NFTLhdr->FirstPhysicalEUN));
	printf("    FormattedSize: %d (%d sectors)\n", le32_to_cpu(NFTLhdr->FormattedSize),
	       le32_to_cpu(NFTLhdr->FormattedSize)/512);
#endif
	printf("Phase 2.b Writing Spare NFTL Media Header and Spare Bad Unit Table\n");
	pwrite(fd, writebuf[0], 512, MediaUnit2 * meminfo.erasesize);
	for (ezone = 0; ezone < (meminfo.size / meminfo.erasesize); ezone += 512) {
		pwrite(fd, BadUnitTable + ezone, 512,
		       (MediaUnit2 * meminfo.erasesize) + 512 * (1 + ezone / 512));
	}

	/* UCI #1 for newly erased Erase Unit */
	memset(oobbuf, 0xff, 16);
	oobbuf[11] = oobbuf[10] = oobbuf[9] = 0;
	oobbuf[8]  = 0x03;
	oobbuf[12] = oobbuf[14] = 0x69;
	oobbuf[13] = oobbuf[15] = 0x3c;

	/* N.B. The Media Header and Bad Erase Unit Table are considered as Free Erase Unit
	   by M-System i.e. their Virtual Unit Number == 0xFFFF in the Unit Control Information #0,
	   but their Block Status is BLOCK_USED (0x5555) in their Block Control Information */
	/* Phase 3. Writing Unit Control Information for each Erase Unit */
	printf("Phase 3. Writing Unit Control Information to each Erase Unit\n");
	for (ezone = cpu_to_le16(NFTLhdr->FirstPhysicalEUN);
	     ezone < (ezones + startofs / meminfo.erasesize); ezone++) {
		/* write UCI #1 to each Erase Unit */
		if (BadUnitTable[ezone] != ZONE_GOOD)
			continue;
		oob.start = (ezone * meminfo.erasesize) + 512;
		if (ioctl(fd, MEMWRITEOOB, &oob))
			printf("MEMWRITEOOB at %lx: %s\n", (unsigned long)oob.start, strerror(errno));
	}

	exit(0);
}
コード例 #17
0
ファイル: flashtool.c プロジェクト: sauter-hq/flashtool
int main(int argc, char *argv[])
{
	int pagelen;
	int ret;
	int rewind;		// bad block, write the same data in next block

	handle_options(argc, argv);

	if (legacy || dm365_rbl || omap_bch || omap_hamming)
    {
		genecc = 1;
		fprintf(stderr, "ecc information will be generated and written to the nand\n");
    }
	else
		genecc = 0;

	if ((mtd_fd = open(mtd_path, O_RDWR)) == -1) {
		perror(mtd_path);
		exit(EXIT_FAIL);
	}

	if (ioctl(mtd_fd, MEMGETINFO, &mi) != 0) {
		perror("MEMGETINFO");
		close(mtd_fd);
		exit(EXIT_FAIL);
	}

	// Right now, only support one expected NAND size
	if (mi.oobsize != 64) {
		fprintf(stderr, "oobsize %d not supported\n", mi.oobsize);
		exit(EXIT_FAIL);
	}
	if (mi.writesize != 2048) {
		fprintf(stderr, "writesize %d not supported\n", mi.writesize);
		exit(EXIT_FAIL);
	}

	if (start_off & (mi.writesize - 1)) {
		fprintf(stderr, "Start offset must be aligned to page size 0x%x\n",
				mi.writesize);
		close(mtd_fd);
		exit(EXIT_FAIL);
	}

	pagelen = mi.size - mi.oobsize; 

	if (write_mode) {
		/* Determine if we are reading from standard input or from a file. */  
		if (strcmp(image_path, standard_input) == 0) {
				image_fd = STDIN_FILENO;
		} else {
				image_fd = open(image_path, O_RDONLY);
		}

		if (image_fd == -1) {
			perror(image_path);
			exit(EXIT_FAIL);
		}

		if (image_fd == STDIN_FILENO) {
				if (input_size < 0)
						input_size = pagelen;
		} else {
			input_size = lseek(image_fd, 0, SEEK_END);
			lseek(image_fd, 0, SEEK_SET);
		}

		if (req_length < 0) {
			req_length = input_size;
		} else if (req_length > input_size) {
			fprintf(stderr, "File smaller (%d) than requested length (%d)\n",
					(int)input_size, req_length);
			exit(EXIT_FAIL);
		}
		DBG("input_size: %d\n", (int)input_size);
	}

	if (req_length < 0) {
		fprintf(stderr, "Must specify length or supply an input file\n");
		exit(EXIT_FAIL);
	}

	req_pages = (((req_length - 1) / mi.writesize) + 1);
	block_pages = mi.erasesize / mi.writesize;

	if (max_off < 0) {
		max_off = mi.size;
	} else {
		if (max_off > mi.size) {
			max_off = mi.size;
			fprintf(stderr, "Max offset truncated to device size: 0x%x\n",
					max_off);
		}
	}

	if (req_pages * mi.writesize > mi.size - start_off) {
		dump_stats();
		fprintf(stderr, "Request would pass the end of device\n");
		exit(EXIT_NOSPACE);
	}

	if (req_pages * mi.writesize > max_off - start_off) {
		dump_stats();
		fprintf(stderr, "Request would exceed max offset limit\n");
		exit(EXIT_NOSPACE);
	}

	if (write_mode)  {
		if (genecc) {
			ret = ioctl(mtd_fd, MTDFILEMODE, (void *) MTD_MODE_RAW);
			if (ret != 0) {
				perror ("MTDFILEMODE");
				close (mtd_fd);
				exit (EXIT_FAIL);
			} else {
				DBG("Set MTD_MODE_RAW\n");
			}
			genecc_init();
		}
		// allocate block buffer: in-band page size * pages per block
		block_buf = malloc(mi.writesize * block_pages);
		if (!block_buf) {
			fprintf(stderr, "block_buf malloc failed\n");
			exit(EXIT_FAIL);
		}
	}

	/*
	 * Main write loop:
	 */

    dump_stats();
	rewind = 0;
	// start at beginning of block containing start_off
	for (block_off = start_off & ~(mi.erasesize - 1);
		bytes_done < req_length;
		block_off += mi.erasesize
	) {
		int start_page_num, page_num;
		int write_pages;
		loff_t ll_off;

		block_bytes_done = 0;

		// check bad block. Have to pass a long long to ioctl.
		ll_off = block_off;
		ret = ioctl(mtd_fd, MEMGETBADBLOCK, &ll_off);
		if (ret < 0) {
			perror("MEMGETBADBLOCK");
			exit(EXIT_FAIL);
		}
		if (ret == 1) {
			fprintf(stderr, "Bad block at 0x%x : ", block_off);
			if (failbad) {
				fprintf(stderr, "ABORT\n");
				exit(EXIT_BADBLOCK);
			} else {
				fprintf(stderr, "skip\n");
				continue;
			}
		}

		if (!quiet) {
			if (erase_mode && write_mode)
				printf("Erase + write");
			else if (erase_mode)
				printf("Erase");
			else if (write_mode)
				printf("Write");
			else
				exit(EXIT_FAIL);	// bug
			printf(" block at 0x%x\n", block_off);
		}

		if (erase_mode) {
			if (block_off + mi.erasesize > max_off) {
				fprintf(stderr, "Erasing next block would exceed max offset\n");
				dump_stats();
				exit(EXIT_NOSPACE);
			}

			ret = erase_block(block_off);
			if (ret < 0) {
				fprintf(stderr, "Erase block at 0x%x failed\n", block_off);
				if (mark_block_bad(block_off) < 0) {
					fprintf(stderr, "Marking block bad failed\n");
					// If not marked bad it would be misread, so this is fatal
					exit(EXIT_FAIL);
				} else {
					continue;	// try next block
				}
			}
		}

		if (start_off > block_off) {
			// first block, starting later than page 0
			start_page_num = (start_off - block_off) / mi.writesize;
		} else {
			start_page_num = 0;
		}

		if (write_mode) {
			// don't read more image file if skipping a bad block
			if (!rewind)
				next_image_block();
		} else {
			// erasing, update count now
			bytes_done += mi.erasesize - start_page_num * mi.writesize;
			continue;
		}

		/*
		 * UBI assumes it can write to any pages at the end of a PEB which
		 * are all FFs in the in-band data area, so we must not write those
		 * pages as we write (non-FF) ECC and UBI's later write would end up
		 * with corrupt ECC (bitwise ANDed with ours).
		 *
		 * http://www.linux-mtd.infradead.org/doc/ubi.html#L_flasher_algo
		 */
		if (ubi)
			write_pages = block_pages - count_trailing_ff_pages();
		else
			write_pages = block_pages;

		if (!quiet && write_pages != block_pages)
			printf("Skip last %d pages of block\n", block_pages - write_pages);

		rewind = 0;
		// foreach page in this block, until done
		for (page_num = start_page_num; page_num < block_pages;	++page_num) {

			if (block_off + (page_num + 1) * mi.writesize > max_off) {
				fprintf(stderr, "Writing this page would exceed max offset\n");
				dump_stats();
				exit(EXIT_NOSPACE);
			}

			if (page_num >= write_pages) {
				/*
				 * Do the UBI mode skip here but stay in the loop so our "done"
				 * counters get incremented appropriately
				 */
				DBG("Skipping page %d\n", page_num);
				ret = 0;
			} else {
				ret = write_page(block_off, page_num);
			}

			if (ret < 0) {
				fprintf(stderr, "Write block at 0x%x, page %d failed: ",
						block_off, page_num);
				if (failbad) {
					fprintf(stderr, "ABORT\n");
					exit(EXIT_BADBLOCK);
				} else {
					fprintf(stderr, "Mark bad and skip\n");
				}

				if (erase_block(block_off) < 0) {
					fprintf(stderr, "Erase block at 0x%x failed\n", block_off);
					// This isn't so important as we are about to mark bad
				}
				if (mark_block_bad(block_off) < 0) {
					fprintf(stderr, "Marking block bad at 0x%x failed\n",
							block_off);
					// If not marked bad it would be misread, so this is fatal
					exit(EXIT_FAIL);
				}
				rewind = 1;
				break;
			}

			block_bytes_done += mi.writesize;
			if (bytes_done + block_bytes_done >= req_length)
				break;
		}
		if (!rewind) {
			bytes_done += block_bytes_done;
		}
	}

    // clean up bch memory
	if (genecc) {
        switch (layout) {
            case GENECC_LAYOUT_LEGACY:
                break;
            case GENECC_LAYOUT_DM365_RBL:
                break;
            case GENECC_LAYOUT_OMAP_BCH:
                // free bch struture
                free_ecc_memory();
                break;
            case GENECC_LAYOUT_OMAP_HAMMINGROMCODE:
                break;
            default:
                break;
        }
    }
    dump_stats();

	if (image_fd != -1)
		close(image_fd);
	close(mtd_fd);

	if (mtd_path)
		free(mtd_path);
	if (image_path)
		free(image_path);
	if (page_buf)
		free(page_buf);
	if (block_buf)
		free(block_buf);

	return 0;
}
コード例 #18
0
ファイル: lart.c プロジェクト: smx-smx/dsl-n55u
static int flash_erase (struct mtd_info *mtd,struct erase_info *instr)
{
   __u32 addr,len;
   int i,first;

#ifdef LART_DEBUG
   printk (KERN_DEBUG "%s(addr = 0x%.8x, len = %d)\n",__FUNCTION__,instr->addr,instr->len);
#endif

   /* sanity checks */
   if (instr->addr + instr->len > mtd->size) return (-EINVAL);

   /*
	* check that both start and end of the requested erase are
	* aligned with the erasesize at the appropriate addresses.
	*
	* skip all erase regions which are ended before the start of
	* the requested erase. Actually, to save on the calculations,
	* we skip to the first erase region which starts after the
	* start of the requested erase, and then go back one.
	*/
   for (i = 0; i < mtd->numeraseregions && instr->addr >= mtd->eraseregions[i].offset; i++) ;
   i--;

   /*
	* ok, now i is pointing at the erase region in which this
	* erase request starts. Check the start of the requested
	* erase range is aligned with the erase size which is in
	* effect here.
	*/
   if (instr->addr & (mtd->eraseregions[i].erasesize - 1)) return (-EINVAL);

   /* Remember the erase region we start on */
   first = i;

   /*
	* next, check that the end of the requested erase is aligned
	* with the erase region at that address.
	*
	* as before, drop back one to point at the region in which
	* the address actually falls
	*/
   for (; i < mtd->numeraseregions && instr->addr + instr->len >= mtd->eraseregions[i].offset; i++) ;
   i--;

   /* is the end aligned on a block boundary? */
   if ((instr->addr + instr->len) & (mtd->eraseregions[i].erasesize - 1)) return (-EINVAL);

   addr = instr->addr;
   len = instr->len;

   i = first;

   /* now erase those blocks */
   while (len)
	 {
		if (!erase_block (addr))
		  {
			 instr->state = MTD_ERASE_FAILED;
			 return (-EIO);
		  }

		addr += mtd->eraseregions[i].erasesize;
		len -= mtd->eraseregions[i].erasesize;

		if (addr == mtd->eraseregions[i].offset + (mtd->eraseregions[i].erasesize * mtd->eraseregions[i].numblocks)) i++;
	 }

   instr->state = MTD_ERASE_DONE;
   mtd_erase_callback(instr);

   return (0);
}
コード例 #19
0
ファイル: flash.c プロジェクト: c77180/Git_First
void erase_block_all(void)//删除所有块
{
	unsigned int i;	
	for(i=0;i<4096;i++)
		erase_block(i*32);		
}