burn.cpp.svn-base

vc环境下编译的一个对USB设备进行烧录的驱动程序

		PostMessage(hWnd, ON_BURNFLASH_MESSAGE, WPARAM(ID+100), LPARAM(MESSAGE_DOWNLOAD_FILE_LEN) );
		
		if(read_len < MAX_PACKET_LENGTH)//last packet
		{
			CloseHandle(hFile);
			break;
		}
    }

    return true;
}

bool BurnFlash::download_file_use_com(char *pc_path, int loadfile_destination_address)
{
	#define MAX_BLOCK_SIZE (4096)
	#define TX_SIZE 2048
	
	HANDLE hFile;
    DWORD fileSize;
    unsigned short cs=0;
    DWORD i;
    unsigned long threadResult=1;

	char *txBuf = NULL;
	DWORD iTxBuf;
	DWORD txBufSize;

	void *txBlk = NULL;
    DWORD txBlkSize;

//	TCHAR text[255];
	CString text;
	char c =0x0d;

	if(NULL == pc_path)
	{
		return false;
	}

	command_download_com(pc_path, loadfile_destination_address, com);
	
//	Sleep(100); //to save cpu time.
	if(WaitForSingleObject(download_init_event, 3000) != WAIT_OBJECT_0)
	{
		ReleaseMutex(download_init_event);
		PostMessage(get_wnd(), ON_BURNFLASH_MESSAGE, WPARAM(get_id()+100), LPARAM(MESSAGE_DOWNLOAD_LOADFILE_FAIL));
		return false;
	}
	
	ResetEvent(download_init_event);
	
    hFile = CreateFile(ConverPathToAbsolute(pc_path), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
	
    if(hFile == INVALID_HANDLE_VALUE)
    {
		return false;
    }
    
    fileSize = GetFileSize(hFile, NULL);
	
    txBuf = (char *)malloc(fileSize+6);
    if(txBuf == NULL)
    {
		return false;
    }
	
    ReadFile(hFile, (void *)(txBuf+4), fileSize, &txBufSize, NULL);
    if(txBufSize != fileSize)
    {
		free(txBuf);
		return false;
    }
	
    *((DWORD *)txBuf) = fileSize+6;   //attach filesize(n+6) 
	
    for(i=4; i<(fileSize+4); i++)
		cs += (BYTE)(txBuf[i]);
    *((WORD *)(txBuf+4+fileSize)) = cs;   //attach checksum 
    
    txBufSize += 6;
    iTxBuf = 0;
	
    CloseHandle(hFile);

	while(1) 
	{
		if((txBufSize - iTxBuf) > TX_SIZE)
			txBlkSize = TX_SIZE;
		else
			txBlkSize = txBufSize-iTxBuf;
		
		txBlk = (void *)(txBuf+iTxBuf);
		
		com.write((char *)txBlk, txBlkSize);

		//if(write_len != txBlkSize)
		//{
		//	free(txBuf);
		//	return false;
		//}

		iTxBuf += txBlkSize;

		download_file_len += txBlkSize;

		PostMessage(get_wnd(), ON_BURNFLASH_MESSAGE, WPARAM(get_id()+100), LPARAM(MESSAGE_DOWNLOAD_FILE_LEN) );
		
		if(iTxBuf >= txBufSize)
			break;
    }

    free((void *)txBuf);

	return true;
	
}

bool BurnFlash::download_u_file(download_file *dFile)
{
	T_WRITE_FILE_DATA write_file;
	char buf[256];

	DWORD  dwSize = 0, read_len = 0;
	HANDLE hFile = NULL;
	
	if((dFile->file_attribute & FILE_ATTRIBUTE_DIRECTORY) != FILE_ATTRIBUTE_DIRECTORY )
	{
		hFile = CreateFile(ConverPathToAbsolute(dFile->file_pc_path) , GENERIC_READ , FILE_SHARE_READ , NULL , 
		OPEN_EXISTING , FILE_ATTRIBUTE_NORMAL , NULL);

		if (hFile == INVALID_HANDLE_VALUE) 
		{ 
			sprintf(buf, "[PC PRINT]: OpenFile Error\r\n");
			record_write(buf, strlen(buf), get_id()+config.base_com);
			
			return false;
		}

		dwSize = GetFileSize (hFile, NULL) ; 

		if (dwSize == 0xFFFFFFFF) 
		{ 
			sprintf(buf, "[PC PRINT]: GetFileSize Error\r\n");
			record_write(buf, strlen(buf), get_id()+config.base_com);

			CloseHandle(hFile);
			return false;
		}

        CloseHandle(hFile);
	}

	write_file.File_mode = 0;

	if((dFile->file_attribute & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY )
	{
		write_file.File_mode |= FS_S_IFDIR;
	}
	if((dFile->file_attribute & FILE_ATTRIBUTE_HIDDEN ) == FILE_ATTRIBUTE_HIDDEN )
	{
		write_file.File_mode |= FS_AHIDDEN;
	}
	if((dFile->file_attribute & FILE_ATTRIBUTE_READONLY ) == FILE_ATTRIBUTE_READONLY )
	{
		write_file.File_mode |= FS_UNDELETE;
	}
	if((dFile->file_attribute & FILE_ATTRIBUTE_SYSTEM ) == FILE_ATTRIBUTE_SYSTEM )
	{
		write_file.File_mode |= FS_ASYSTEM;
	}
	
	write_file.File_length = dwSize;

	strcpy(write_file.File_Path , dFile->file_flash_path);

	if( !write_transc_packet(WRITE_FILE_TRANSC, sizeof(T_WRITE_FILE_DATA), (BYTE *)&write_file))
	{
		sprintf(buf, "[PC PRINT]: WRITE TRANSC Error\r\n");
		record_write(buf, strlen(buf), get_id()+config.base_com);

		CloseHandle(hFile);
		return false;
	}

	if( read_transc_ack() != ACK_SUCCESS)
	{
		sprintf(buf, "[PC PRINT]: READ TRANSC ACK Error\r\n");
		record_write(buf, strlen(buf), get_id()+config.base_com);
		
		return false;
	}

	if((dFile->file_attribute & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY)
		return true;


	PostMessage(get_wnd(), ON_BURNFLASH_MESSAGE, WPARAM(get_id()+100), LPARAM(MESSAGE_DOWNLOADING_FILE) );

	if(download_data(dFile->file_pc_path))
    {
        if(dFile->compare)
		{
			PostMessage(get_wnd(), ON_BURNFLASH_MESSAGE, WPARAM(get_id()+100), LPARAM(MESSAGE_COMPARE_FILE) );

			if(!compare_transc(dFile->file_pc_path))
			{
				PostMessage(get_wnd(), ON_BURNFLASH_MESSAGE, WPARAM(get_id()+100), LPARAM(MESSAGE_COMPARE_FILE_FAIL) );
				return false;
			}

			PostMessage(get_wnd(), ON_BURNFLASH_MESSAGE, WPARAM(get_id()+100), LPARAM(MESSAGE_COMPARE_FILE_SUCCESS) );

		}

		return true;
    }
    else
        return false;
}

bool BurnFlash::download_u_transc(download_file *download_files, int count )
{
	if(bDownEncryptFile)
	{
		bDownEncryptFile = false;
		if(!download_u_file(&encrypt_file))
		{
			return false;
		}
	}
	
	for(int i = 0; i< count; i++)
	{
		if(!download_u_file(&download_files[i]))
		{
			return false;
		}
	}

	return true;
}


bool BurnFlash::download_nandboot_data_transc()
{
    T_WRITE_DATA_DATA write_data;

	DWORD  dwSize = 0;
	HANDLE hFile = NULL;

	hFile = CreateFile(ConverPathToAbsolute(config.nandboot_path) , GENERIC_READ , FILE_SHARE_READ , NULL , 
	OPEN_EXISTING , FILE_ATTRIBUTE_NORMAL , NULL);

	if (hFile == INVALID_HANDLE_VALUE) 
	{ 
		return false;
	}

	dwSize = GetFileSize (hFile, NULL) ; 

	if (dwSize == 0xFFFFFFFF) 
	{
		CloseHandle(hFile);
		return false;
	}

    CloseHandle(hFile);

	write_data.Download_Type = DOWNLOAD_TO_NANDFLASH;	
	write_data.Start_Address = 0x0000000;
	write_data.End_Address = CONFIG_ADDR;
	write_data.Backup_Start_Address = 0x0000000;
	write_data.Backup_End_Address = 0x0000000;
    write_data.Backup_Map_Address = 0;
    write_data.map_index = map_index++;

	write_data.Data_Length = dwSize;

	if(!write_transc_packet(WRITE_DATA_TRANSC, sizeof(T_WRITE_DATA_DATA), (BYTE *)&write_data))
	{
		return false;
	}

	if( read_transc_ack() != ACK_SUCCESS)
		return false;

    PostMessage(get_wnd(), ON_BURNFLASH_MESSAGE, WPARAM(get_id()+100), LPARAM(MESSAGE_DOWNLOADING_FILE) );

    if(download_data(config.nandboot_path))
    {
        PostMessage(get_wnd(), ON_BURNFLASH_MESSAGE, WPARAM(get_id()+100), LPARAM(MESSAGE_COMPARE_FILE) );

		if(!compare_transc(config.nandboot_path))
		{
			PostMessage(get_wnd(), ON_BURNFLASH_MESSAGE, WPARAM(get_id()+100), LPARAM(MESSAGE_COMPARE_FILE_FAIL) );
			return false;
		}

		PostMessage(get_wnd(), ON_BURNFLASH_MESSAGE, WPARAM(get_id()+100), LPARAM(MESSAGE_COMPARE_FILE_SUCCESS) );

    }
    else
        return false;

	return true;

}

bool BurnFlash::download_bios_data_transc()
{
    T_WRITE_DATA_DATA write_data;

	DWORD  dwSize = 0;
	HANDLE hFile = NULL;

	hFile = CreateFile(ConverPathToAbsolute(config.bios_path) , GENERIC_READ , FILE_SHARE_READ , NULL , 
	OPEN_EXISTING , FILE_ATTRIBUTE_NORMAL , NULL);

	if (hFile == INVALID_HANDLE_VALUE) 
	{ 
		return false;
	}

	dwSize = GetFileSize (hFile, NULL) ; 

	if (dwSize == 0xFFFFFFFF) 
	{
		CloseHandle(hFile);
		return false;
	}

    CloseHandle(hFile);


	if( !download_BIOS_config(dwSize))
        return false;

	write_data.Download_Type = DOWNLOAD_TO_NANDFLASH;
	write_data.Start_Address = config.bios_start_address;
	write_data.End_Address = config.bios_end_address;
	write_data.Backup_Start_Address = config.bios_backup_start_address;
	write_data.Backup_End_Address = config.bios_backup_end_address;
    
    if(config.bios_backup_start_address != 0 &&
        config.bios_backup_end_address != 0)
    {
        write_data.Backup_Map_Address = CONFIG_ADDR + 0x0200;
        
		map_len += ((config.bios_end_address - config.bios_start_address) 
			/ (chip_para.nandflash_parameter.page_per_blk * 
            chip_para.nandflash_parameter.page_size)
            * sizeof(T_U16) + 511) / 512;
    }
    else
        write_data.Backup_Map_Address = 0;


    write_data.map_index = map_index++;

	write_data.Data_Length = dwSize;

	if(!write_transc_packet(WRITE_DATA_TRANSC, sizeof(T_WRITE_DATA_DATA), (BYTE *)&write_data))
	{
		return false;
	}

	if( read_transc_ack() != ACK_SUCCESS)
		return false;

    PostMessage(get_wnd(), ON_BURNFLASH_MESSAGE, WPARAM(get_id()+100), LPARAM(MESSAGE_DOWNLOADING_FILE) );

    if(download_data(config.bios_path))
    {
        PostMessage(get_wnd(), ON_BURNFLASH_MESSAGE, WPARAM(get_id()+100), LPARAM(MESSAGE_COMPARE_FILE) );

		if(!compare_transc(config.bios_path))
		{
			PostMessage(get_wnd(), ON_BURNFLASH_MESSAGE, WPARAM(get_id()+100), LPARAM(MESSAGE_COMPARE_FILE_FAIL) );
			return false;
		}

		PostMessage(get_wnd(), ON_BURNFLASH_MESSAGE, WPARAM(get_id()+100), LPARAM(MESSAGE_COMPARE_FILE_SUCCESS) );
    }
    else
        return false;

	return true;
}

bool BurnFlash::get_para_transc()
{
    BYTE data[MAX_PACKET_LENGTH];
    UINT uploaded_count = 0;
	T_CHIP_SELECT_DATA chip_select;

	chip_select.b_chip_select_loop = config.bPiece_Select_Loop;
	chip_select.b_chip_select[0] = config.bHavePieceZero;
	chip_select.b_chip_select[1] = config.bHavePieceOne;
	chip_select.b_chip_select[2] = config.bHavePieceTwo;
	chip_select.b_chip_select[3] = config.bHavePieceThree;
//	get_piece_select_info();

	memcpy(data, &chip_select, sizeof(T_CHIP_SELECT_DATA));

	if( !write_transc_packet(GET_CHIPPARA_TRANS, 64, data))
		return false;
	
	Sleep(5000);
	
    if(!m_usb.M3USB_UPLOAD(data, 64, &uploaded_count))
        return false;

    if(uploaded_count == 0)
        return false;

    memcpy(&chip_para, data, sizeof(T_CHIPPARA_DATA));

    return true;
}

bool BurnFlash::set_para_transc()
{
    UINT uploaded_count = 0;
    UINT i = 0;

	//获取片选选择数据

    for(i = 0; i < config.nandflash_parameter_count; i++)
    {
        if(chip_para.nandflash_parameter.chip_id == config.nandflash_parameter[i].chip_id)
        {
            memcpy(&chip_para.nandflash_parameter, 
                    &config.nandflash_parameter[i],
                    sizeof(T_NAND_PHY_INFO));
            break;
        }
    }
	
    if(i >= config.nandflash_parameter_count)
        return false;

	if( !write_transc_packet(SET_CHIPPARA_TRANS, 64, (BYTE *)&chip_para))
		return false; 

    if( read_transc_ack() != ACK_SUCCESS)
		return false;

    return true;

} 

bool BurnFlash::construct_zone_detail()
{
    bool fake = false;
    int fake_index = 0;
    int nand_num = 0;
	int partition_num = 0;
    UINT total_size = 0;
	int sectorsize = 0;

	UINT Temp_End_Add = 0;

	double tempSize;

	tempSize = ((double)chip_para.count)*chip_para.nandflash_parameter.page_size *	
		chip_para.nandflash_parameter.page_per_blk * chip_para.nandflash_parameter.blk_num;

	if(tempSize > 0xFFFFFFFF)
	{
		total_size = TOTAL_SIZE_UINT;
	}
	else
	{
		total_size = chip_para.count * chip_para.nandflash_parameter.page_size *
			chip_para.nandflash_parameter.page_per_blk * chip_para.nandflash_parameter.blk_num;
	}

	sectorsize = chip_para.nandflash_parameter.page_size;

    information.Zone_Cnt = config.format_count;

    information.TotalLen = sizeof(T_INFOMATION) + sizeof(T_ZONE_DATAIL) * information.Zone_Cnt;

    information.Zone_Group = (TP_ZONE_DATAIL)malloc(information.Zone_Cnt * sizeof(T_ZONE_DATAIL));

    if(information.Zone_Group == NULL)
        return false;