sim_dev.c

电子盘DEMO板程序

{

	if((!simSocket.bSlavePresent) && (simSocket.selDevNum == 1))
		return -1;

#ifdef DOCH_MEMMAP_FILE
	if((offset >= HIB_CHIPID1_REG) && (offset <= HIB_BURST_READ_MODE_CTRL_REG))
	{
		DOCH_SimSocket* pSimSock = getSimSocket();

		if(simFileIO(pSimSock, SIM_ITEM_CONFIG_REGS, 0, TRUE, (void*)&(pSimSock->config_regs)))
			return -1;
	}
#endif /*DOCH_MEMMAP_FILE*/


	/*If in DPD mode - wake UP !*/
	if((simSocket.config_regs.wPowerMode & 0x01) == 0x01)
		simDPDMode(&simSocket, FALSE);

	/*ATA Registers*/
	if(offset == DOCH_DATA_REG)
	{
	}
	else if(offset == DOCH_FEATURES_REG)
	{
		return simSocket.out_regs.bErrorFeature;
	}
	else if(offset == DOCH_SECTOR_CNT_REG)
	{
		return simSocket.out_regs.bSectorCount;
	}
	else if(offset == DOCH_SECTOR_NO_REG)
	{
		return simSocket.out_regs.bLBALow;
	}
	else if(offset == DOCH_CYLINDER_LOW_REG)
	{
		return simSocket.out_regs.bLBAMid;
	}
	else if(offset == DOCH_CYLINDER_HIGH_REG)
	{
		return simSocket.out_regs.bLBAHigh;
	}
	else if(offset == DOCH_DRIVE_HEAD_REG)
	{
		return simSocket.out_regs.bDevice;
	}
	else if(offset == DOCH_COMMAND_REG)
	{
		return simSocket.out_regs.bStatusCommand;
	}
	else if(offset == DOCH_ALT_STATUS_REG)
	{
		return simSocket.out_regs.bAltStatusControl;
	}

	/*HOST configuration registers*/
	else if(offset == HIB_CHIPID1_REG)
	{
		return simSocket.config_regs.wChipID1;
	}
	else if(offset == HIB_BURST_WRITE_MODE_CTRL_REG)
	{
		return simSocket.config_regs.wBurstWriteModeCtrl;
	}
	else if(offset == HIB_DOWNLOAD_CONTROL_REG)
	{
		return simSocket.config_regs.wDownloadCtrl;
	}
	else if(offset == HIB_IPL_CONTROL_REG)
	{
		return simSocket.config_regs.wIPLCtrl;
	}
	else if(offset == HIB_WARM_BOOT_REG)
	{
		return simSocket.config_regs.wWarmBoot;
	}
	else if(offset == HIB_POWER_DOWN_REG)
	{
		return simSocket.config_regs.wPowerDown;
	}
	else if(offset == HIB_DMA_CTRL_REG)
	{
		return simSocket.config_regs.wDownloadCtrl;
	}
	else if(offset == HIB_SW_LOCK_REG)
	{
		return simSocket.config_regs.wSWLock;
	}
	else if(offset == HIB_ENDIAN_CTRL_REG)
	{
		return simSocket.config_regs.wEndianCtrl;
	}
	else if(offset == HIB_OPERATION_MODE_REG)
	{
		return simSocket.config_regs.wOperationMode;
	}
	else if(offset == HIB_DMA_NEGATION_REG)
	{
		return simSocket.config_regs.wDmaNegation;
	}
	else if(offset == HIB_CHIPID2_REG)
	{
		return simSocket.config_regs.wChipID2;
	}
	else if(offset == HIB_BURST_READ_MODE_CTRL_REG)
	{
		return simSocket.config_regs.wBurstReadModeCtrl;
	}
	else if((offset == HIB_BURST_WRITE_MODE_EXIT_REG) || (offset == HIB_POWER_MODE_REG))
	{
		DBG_PRINT_FLOW_PRM(FLZONE_MTD, (FLTXT("Register at offset %x is read only!!!\r\n"), offset));
		return DOCH_BadParameter;
	}
	else if(offset == 0x400) /*Special case - Paged ram registers*/
	{
		return simSocket.out_regs.bAltStatusControl;
	}	
	else if((offset == HIB_PCI_CONTROL_REGISTER) || (offset == HIB_PCI_INTERRUPT_COUNTER))
	{
		/*Do Nothing*/
	}
	else
	{
		DBG_PRINT_FLOW_PRM(FLZONE_MTD, (FLTXT("Wrong ATA register offset\r\n")));
		return DOCH_BadParameter;
	}

	return DOCH_OK;
}

FLSNative parseControlReg(DOCH_SimSocket* simSocket, int val)
{
	DOCH_SimSocket* pSimSock = getSimSocket();
	DOCH_SimDevice* pSim = &(pSimSock->device[0]);

	if( (val & DOCH_ATA_SRST) == DOCH_ATA_SRST)
	{
		DBG_PRINT_WRN_PRM(FLZONE_MTD, (FLTXT("\r\nATA reset requested\r\n")));

		initVarious(TRUE);
		initSimRegisters();
		initDriveParameters((FLByte)((simSocket->bSlavePresent) ? ATA_MAX_NUM_OF_DEVICES:1));
		unAuthenticatePartitions(&pSim[0]);
	}

	if( (val & DOCH_ATA_NIEN) == DOCH_ATA_NIEN)
	{
		/*DBG_PRINT_WRN_PRM(FLZONE_MTD, (FLTXT("ATA Interrupt disabled\r\n")));*/
		intDisabled = TRUE;
	}
	else
	{
		/*DBG_PRINT_WRN_PRM(FLZONE_MTD, (FLTXT("ATA Interrupt enabled\r\n")));*/
		intDisabled = FALSE;
	}

	return flOK;
}

/*********************************************************/
/* Function name	: formatPartition*/
/* Description	    : */
/* Return type		: static DOCH_Error */
/* Argument         : DOCH_SimDevice* simDev*/
/* Argument         : FLByte bPart*/
/* Argument         : FLSNative iUnitSizeInSectors*/
/* Argument         : FLSNative  iOffset*/
/* Argument         : FLSNative  iCurNumOfPartitions*/
/* Argument         : FLSNative  iTotalPart2Add*/
/*********************************************************/
static DOCH_Error formatPartition(DOCH_SimDevice* simDev, FLByte bPart, FLSNative iUnitSizeInSectors, FLSNative  iOffset,  FLSNative  iCurNumOfPartitions, FLSNative  iTotalPart2Add)
{
	FLSNative  j;
	FLBoolean  passkeyExists = FALSE;
	DOCH_PartitionFormatInfo * pPartFormatInfoPtr = &partSetupInfo;
	sSimPartitionInfo * pSimPartInfo = &simDev->partitions[bPart];
	FLDword	   protectionType;
	FLBoolean  iplPartition = (bPart == 0);
	FLDword	   totalPartSizeInSectors = 0;
	FLDword	   fastAreaSizeInSectors = 0;
	FLBoolean  fastAreaSizeInPercent = ((pPartFormatInfoPtr->dwCommandFlagsOrStatuses & DOCH_CFSB_FAST_AREA_SIZE_TYPE) 
											== DOCH_CFSB_FAST_AREA_SIZE_TYPE);

	if(fastAreaSizeInPercent)
	{
		/*Fast area given in percent*/

		/*Sanity check - cant be more the 100 percent...*/
		if(pPartFormatInfoPtr->nFastAreaSize > 100) {
			DBG_PRINT_FLOW_PRM(FLZONE_MTD, (FLTXT("\r\nFast area percentage cannot exceed 100 percent!!!\r\n")));
			return DOCH_BadParameter;
		}

		fastAreaSizeInSectors = (((pPartFormatInfoPtr->nPartitionSize * pPartFormatInfoPtr->nFastAreaSize) / 100)
									* (1<<(pPartFormatInfoPtr->wFastAreaFactor-1)));
	}
	else
	{
		/*Fast area given in sectors*/
		/*fastAreaSizeInSectors = (pPartFormatInfoPtr->nFastAreaSize * 2);*/
		fastAreaSizeInSectors = (pPartFormatInfoPtr->nFastAreaSize * (1<<(pPartFormatInfoPtr->wFastAreaFactor-1)));
		
	}

	totalPartSizeInSectors = (pPartFormatInfoPtr->nPartitionSize + fastAreaSizeInSectors);

	/* Sanity Check - is there enough space left on the device? */
	if((totalPartSizeInSectors + (iOffset >> DOCH_SECTOR_SIZE_BITS))
		> simDev->dwDevSizeInSectors)
	{
		simSocket.out_regs.bStatusCommand |= DOCH_ERROR;
		simSocket.out_regs.bErrorFeature = (DOCH_ATA_ERROR_ABORT | DOCH_ATA_ERROR_WRITE_PROTECTED);
		return DOCH_BadParameter;
	}

	pSimPartInfo->dwOffset = iOffset;
	pSimPartInfo->wActive = 1;

	/* zero size parition */
	if( pPartFormatInfoPtr->nPartitionSize == 0 )
	{
		if( bPart!=(iTotalPart2Add  + iCurNumOfPartitions - 1) ) /* not last partition */
			return DOCH_BadParameter;

		/* Special case - IPL partition */
		if(iplPartition)
		{
			pSimPartInfo->dwSize = 512;	/*Make room for 256KB*/
			pSimPartInfo->dwRequestedSize = pSimPartInfo->dwSize + (fastAreaSizeInSectors);
			simDev->dwXIPMaxSize = pSimPartInfo->dwRequestedSize;
#ifdef DOCH_MEMMAP_FILE
			 /*Write MAX IPL Size to file*/
			 if(simFileIO(&simSocket, SIM_ITEM_MAX_IPL_SIZE, 0, FALSE, (void*)&(simDev->dwXIPMaxSize)))
				return DOCH_GeneralFailure;
#endif /*DOCH_MEMMAP_FILE*/

		}
		/* User Partition */
		else
		{
			pSimPartInfo->dwSize = ( (simDev->dwDevSizeInSectors << DOCH_SECTOR_SIZE_BITS) - iOffset);
			pSimPartInfo->dwSize = (pSimPartInfo->dwSize >> DOCH_SECTOR_SIZE_BITS) & (~(iUnitSizeInSectors - 1));
			pSimPartInfo->dwRequestedSize = pSimPartInfo->dwSize;
		}
	}
	else
	{
		if(iplPartition)
		{
			if(totalPartSizeInSectors > IPL_PARTITION_SIZE_SECTORS)
			{
				DBG_PRINT_FLOW_PRM(FLZONE_MTD, (FLTXT("\r\nIPL size too large!!!\r\n")));
				return DOCH_BadParameter;
			}
			 simDev->dwXIPMaxSize = (pPartFormatInfoPtr->nPartitionSize + fastAreaSizeInSectors);

#ifdef DOCH_MEMMAP_FILE
			 /*Write MAX IPL Size to file*/
			 if(simFileIO(&simSocket, SIM_ITEM_MAX_IPL_SIZE, 0, FALSE, (void*)&(simDev->dwXIPMaxSize)))
				return DOCH_GeneralFailure;
#endif /*DOCH_MEMMAP_FILE*/
		}

		/*Round partition size to Unit Size*/
		pSimPartInfo->dwRequestedSize = totalPartSizeInSectors;
		pSimPartInfo->dwSize = (pSimPartInfo->dwRequestedSize + iUnitSizeInSectors - 1) & (~(iUnitSizeInSectors - 1));
	}


	/*Fill INFO structure*/
	pSimPartInfo->info.nPartitionSize  = pPartFormatInfoPtr->nPartitionSize;
	pSimPartInfo->info.nFastAreaSize   = pPartFormatInfoPtr->nFastAreaSize;
	pSimPartInfo->info.wFastAreaFactor = pPartFormatInfoPtr->wFastAreaFactor;

	DOCH_SetBits(&pSimPartInfo->info.partitionAttributes2,
				 DOCH_PA2B_PROTECTION_TYPE,
				 DOCH_PA2O_PROTECTION_TYPE,
				 ((pPartFormatInfoPtr->partitionAttributes2 & DOCH_PA2B_PROTECTION_TYPE) >> DOCH_PA2O_PROTECTION_TYPE)
				 );
	DOCH_SetBits(&pSimPartInfo->info.partitionAttributes2,
				 DOCH_PA2B_USER_MODE,
				 DOCH_PA2O_USER_MODE,
				 ((pPartFormatInfoPtr->partitionAttributes2 & DOCH_PA2B_USER_MODE) >> DOCH_PA2O_USER_MODE)
				 );
	DOCH_SetBits(&pSimPartInfo->info.partitionAttributes2,
				 DOCH_PA2B_GUEST_MODE,
				 DOCH_PA2O_GUEST_MODE,
				 ((pPartFormatInfoPtr->partitionAttributes2 & DOCH_PA2B_GUEST_MODE) >> DOCH_PA2O_GUEST_MODE)
				 );
	DOCH_SetBits(&pSimPartInfo->info.partitionAttributes2,
				 DOCH_PA2B_MASTER_CTRL,
				 DOCH_PA2O_MASTER_CTRL,
				 ((pPartFormatInfoPtr->partitionAttributes2 & DOCH_PA2B_MASTER_CTRL) >> DOCH_PA2O_MASTER_CTRL)
				 );
	DOCH_SetBits(&pSimPartInfo->info.partitionAttributes2,
				 DOCH_PA2B_ENCRYPT_TYPE,
				 DOCH_PA2O_ENCRYPT_TYPE,
				 ((pPartFormatInfoPtr->partitionAttributes2 & DOCH_PA2B_ENCRYPT_TYPE) >> DOCH_PA2O_ENCRYPT_TYPE)
				 );
	DOCH_SetBits(&pSimPartInfo->info.partitionAttributes2,
				 DOCH_PA2B_OTP_BIT,
				 DOCH_PA2O_OTP_BIT,
				 ((pPartFormatInfoPtr->partitionAttributes2 & DOCH_PA2B_OTP_BIT) >> DOCH_PA2O_OTP_BIT)
				 );
	DOCH_SetBits(&pSimPartInfo->info.partitionAttributes2,
				 DOCH_PA2B_LOCK_CTRL,
				 DOCH_PA2O_LOCK_CTRL,
				 ((pPartFormatInfoPtr->partitionAttributes2 & DOCH_PA2B_LOCK_CTRL) >> DOCH_PA2O_LOCK_CTRL)
				 );
	DOCH_SetBits(&pSimPartInfo->info.partitionAttributes2,
				 DOCH_PA2B_MAX_AUTH_ATTEMPTS,
				 DOCH_PA2O_MAX_AUTH_ATTEMPTS,
				 ((pPartFormatInfoPtr->partitionAttributes2 & DOCH_PA2B_MAX_AUTH_ATTEMPTS) >> DOCH_PA2O_MAX_AUTH_ATTEMPTS)
				 );

	for(j=0; j<sizeof(pPartFormatInfoPtr->bPasskey); j++)
	{
		passkeyExists = FALSE;
		if(pPartFormatInfoPtr->bPasskey[j] != 0)
		{
			passkeyExists = TRUE;
			break;
		}
	}


	protectionType = ((pSimPartInfo->info.partitionAttributes2 & DOCH_PA2B_PROTECTION_TYPE) >> DOCH_PA2O_PROTECTION_TYPE);

	if((passkeyExists) && (protectionType != DOCH_PARTITION_NOT_PROTECTED))
	{
		tffscpy(pSimPartInfo->sbPasskey, pPartFormatInfoPtr->bPasskey, sizeof(pSimPartInfo->sbPasskey));
		pSimPartInfo->wAuthenticated = FALSE;
		simDev->bPpartitionAuthenticated[bPart] = FALSE;
		pSimPartInfo->info.dwCommandFlagsOrStatuses &= ~DOCH_CFSB_USER_AUTHENTICATED;
	}
	else
	{
		pSimPartInfo->wAuthenticated = TRUE;
		simDev->bPpartitionAuthenticated[bPart] = TRUE;
		/*pSimPartInfo->info.dwCommandFlagsOrStatuses |= DOCH_CFSB_USER_AUTHENTICATED;*/
	}

	tffsset(pPartFormatInfoPtr, 0, sizeof(DOCH_PartitionFormatInfo));
	return DOCH_OK;
}/*formatPartition()*/


/*********************************************************/
/* Function name	: addPartition*/
/* Description	    : adds partition */
/* Return type		: static FLSNative */
/* Argument         : DOCH_SimSocket* simSocket*/
/*********************************************************/
static FLSNative  addPartition(DOCH_SimSocket* simSocket)
{
	DOCH_Error rc = DOCH_OK;
	FLByte bDev = simSocket->selDevNum;
	FLByte bCurNumPart = (FLByte)diskOnChipDeviceInfo[bDev].wTotalNumOfPartitions; /* number of partitions currently found*/
	DOCH_SimDevice* simDev = getSimDev(simSocket->selDevNum);
	FLDword dwCurOffset = 0;
	FLWord unitSizeInSectors = (FLWord)(simDev->dwTotalDevSizeInSectors / 512);

	/* calculate where last existing partition ended */
	if(bCurNumPart > 0)
		dwCurOffset = (simDev->partitions[bCurNumPart-1].dwOffset + (simDev->partitions[bCurNumPart-1].dwSize << DOCH_SECTOR_SIZE_BITS));

	rc = formatPartition( simDev, bCurNumPart, unitSizeInSectors, (FLSNative)dwCurOffset,  (FLSNative)bCurNumPart, 1);
	if( rc==DOCH_OK )
	{
		/* Set partition number as output */
		simSocket->out_regs.bSectorCount = bCurNumPart;

		/* Update diskOnChipDeviceInfo structure */
		diskOnChipDeviceInfo[bDev].wTotalNumOfPartitions ++;