void Initialize_NOR_Info(void)
{
#if defined(_NOR_FLASH_BOOTING_)
   kal_uint32 blk_addr = 0;

   /* Initialize MTD data table */
   fue_nor_mtdflash.Signature = ~((kal_uint32)NORRegionInfo);

   #if !defined(__UBL__)
   FlashDriveData.MTDDriver = &NORFlashMtd;
   #endif /* __UBL__ */
   FlashDriveData.MTDData = &fue_nor_mtdflash;

#ifdef __MTK_TARGET__
   #if defined(MT6238) || defined(MT6235) || defined(MT6239) || defined(MT6235B)
   fue_nor_mtdflash.BaseAddr = (BYTE *)(custom_get_NORFLASH_Base()|0x08000000);
   #elif defined(MT6228) || defined(MT6229) || defined(MT6230) || defined(MT6225) || defined(MT6268T)
   fue_nor_mtdflash.BaseAddr = (BYTE *)(custom_get_NORFLASH_Base()|0x04000000);
   #else
   fue_nor_mtdflash.BaseAddr = (BYTE *)custom_get_NORFLASH_Base();
   #endif
#endif /* __MTK_TARGET__ */

   fue_nor_mtdflash.RegionInfo = (FlashRegionInfo *)NORRegionInfo;
#if defined(__SINGLE_BANK_NOR_FLASH_SUPPORT__) && (defined(__MULTI_BANK_NOR_DEVICE__) || defined(__ARM9_MMU__) || defined(__ARM11_MMU__))
   fue_nor_mtdflash.BankInfo = (FlashBankInfo*)FOTANORBankInfo;
#endif

#ifdef __FOTA_DM__
   blk_addr = SSF_GetUAImageLoadAddress()|custom_get_NORFLASH_Base();
   #if defined(MT6238) || defined(MT6235) || defined(MT6239) || defined(MT6235B)
   blk_addr |= 0x08000000;
   #elif defined(MT6228) || defined(MT6229) || defined(MT6230) || defined(MT6225) || defined(MT6268T)
   blk_addr |= 0x04000000;
   #else
   blk_addr |= 0x0;
   #endif
   blk_addr -= (kal_uint32)fue_nor_mtdflash.BaseAddr;
   FlashDriveData.FlashInfo.baseUnlockBlock = BlockIndex(&fue_nor_mtdflash, blk_addr);

   #if (defined(__UP_PKG_ON_NAND__) && defined(NAND_SUPPORT))
   blk_addr =  (custom_get_NORFLASH_ROMSpace() - 1) | custom_get_NORFLASH_Base();
   #else
   blk_addr =  FOTA_GetPackageStorageBase()+FOTA_GetPackageStorageSize();
   #endif /* __UP_PKG_ON_NAND__ && NAND_SUPPORT */

   #if defined(MT6238) || defined(MT6235) || defined(MT6239) || defined(MT6235B)
   blk_addr |= 0x08000000;
   #elif defined(MT6228) || defined(MT6229) || defined(MT6230) || defined(MT6225) || defined(MT6268T)
   blk_addr |= 0x04000000;
   #else
   blk_addr |= 0x0;
   #endif

   blk_addr -= (kal_uint32)fue_nor_mtdflash.BaseAddr;
   FlashDriveData.FlashInfo.endUnlockBlock = BlockIndex(&fue_nor_mtdflash, blk_addr);
#endif

#endif // _NOR_FLASH_BOOTING_ 
}
Example #2
0
status_t
SymLink::WriteSymLink(const char* buffer, size_t toWrite,
	Transaction& transaction)
{
	uint64 size = Size();
	if (size > kMaxSymLinkSize)
		RETURN_ERROR(B_BAD_DATA);

	if (toWrite > kMaxSymLinkSize)
		RETURN_ERROR(B_NAME_TOO_LONG);

	if (toWrite == 0) {
		SetSize(0);
		return B_OK;
	}

	Block block;
	if (!block.GetWritable(GetVolume(), BlockIndex(), transaction))
		return B_ERROR;

	char* data = (char*)block.Data() + kSymLinkDataOffset;
	memcpy(data, buffer, toWrite);
	SetSize(toWrite);

	return B_OK;
}
Example #3
0
status_t
SymLink::ReadSymLink(char* buffer, size_t toRead, size_t& _bytesRead)
{
	uint64 size = Size();
	if (size > kMaxSymLinkSize)
		RETURN_ERROR(B_BAD_DATA);

	if (toRead > size)
		toRead = size;

	if (toRead == 0) {
		_bytesRead = 0;
		return B_OK;
	}

	// get the block
	Block block;
	if (!block.GetReadable(GetVolume(), BlockIndex()))
		RETURN_ERROR(B_ERROR);

	const char* data = (char*)block.Data() + kSymLinkDataOffset;
	memcpy(buffer, data, toRead);

	_bytesRead = toRead;
	return B_OK;
}
/* -------------------------------------------------
 * Tell the block index of the specified address
 * Default value : generated based on scatter file
 * -------------------------------------------------*/
kal_uint32 custom_Block_Size(kal_uint32 nor_addr)
{
   kal_uint32 blk_idx = 0;
   NOR_Flash_MTD_Data *mtdflash     = (NOR_Flash_MTD_Data *)FlashDriveData.MTDData;

   blk_idx = BlockIndex((void *)mtdflash, nor_addr & (~((kal_uint32)mtdflash->BaseAddr)));

   return BlockSize((void *)mtdflash, blk_idx);
}
Example #5
0
void
Directory::DeletingNode()
{
	Node::DeletingNode();

	// iterate through the directory and remove references to all entries' nodes
	char* name = (char*)malloc(kCheckSumFSNameLength + 1);
	if (name != NULL) {
		name[0] = '\0';

		DirEntryTree entryTree(this);
		size_t nameLength;
		uint64 blockIndex;
		while (entryTree.LookupNextEntry(name, name, nameLength,
				blockIndex) == B_OK) {
			Node* node;
			if (GetVolume()->GetNode(blockIndex, node) == B_OK) {
				Transaction transaction(GetVolume());
				if (transaction.StartAndAddNode(node) == B_OK) {
					node->SetHardLinks(node->HardLinks() - 1);
					if (node->HardLinks() == 0)
						GetVolume()->RemoveNode(node);

					if (transaction.Commit() != B_OK) {
						ERROR("Failed to commit transaction for dereferencing "
							"entry node of deleted directory at %" B_PRIu64
							"\n", BlockIndex());
					}
				} else {
					ERROR("Failed to start transaction for dereferencing "
						"entry node of deleted directory at %" B_PRIu64 "\n",
						BlockIndex());
				}

				GetVolume()->PutNode(node);
			} else {
				ERROR("Failed to get node %" B_PRIu64 " referenced by deleted "
					"directory at %" B_PRIu64 "\n", blockIndex, BlockIndex());
			}
		}

		free(name);
	}

	// free the directory entry block tree
	Transaction transaction(GetVolume());
	if (transaction.Start() != B_OK) {
		ERROR("Failed to start transaction for freeing entry tree of deleted "
			"directory at %" B_PRIu64 "\n", BlockIndex());
		return;
	}

	DirEntryTree entryTree(this);
	if (entryTree.FreeTree(transaction) != B_OK) {
		ERROR("Failed to freeing entry tree of deleted directory at %" B_PRIu64
			"\n", BlockIndex());
		return;
	}

	if (transaction.Commit() != B_OK) {
		ERROR("Failed to commit transaction for freeing entry tree of deleted "
			"directory at %" B_PRIu64 "\n", BlockIndex());
	}
}