sim_dev.c

电子盘DEMO板程序

	/*Indicate a reset has occured*/
	bResetStatus = TRUE;

	tffsset(ataDebug, 0, sizeof(ataDebug));

	for( bDev=0; bDev<(simSocket.bSlavePresent + 1)/*ATA_MAX_NUM_OF_DEVICES*/; bDev++)
	{
		simDev = &simSocket.device[bDev];

		tffsset(&partSetupInfo, 0, sizeof(partSetupInfo));
		if(fNewDev==TRUE)
		{
			tffsset(&diskOnChipDeviceInfo[bDev], 0, sizeof(diskOnChipDeviceInfo[bDev]));

			/*Initialize diskOnChipDeviceInfo info structure*/
			/*==============================================*/
			tffscpy(&diskOnChipDeviceInfo[bDev].bSerialNumber,
					 DOCH_SIM_EXTINFO_SERIAL_NUM,
					 sizeof(DOCH_SIM_EXTINFO_SERIAL_NUM));	

			tffscpy(&diskOnChipDeviceInfo[bDev].bModelNumber,
					 DOCH_SIM_EXTINFO_MODEL_NUM,
					 sizeof(DOCH_SIM_EXTINFO_MODEL_NUM));	
			tffscpy((FLByte*)&diskOnChipDeviceInfo[bDev].bModelNumber + sizeof(DOCH_SIM_EXTINFO_MODEL_NUM),
					 dochSimulatorVer,
					 sizeof(dochSimulatorVer));	

			tffscpy(&diskOnChipDeviceInfo[bDev].bUniqueID,
					 DOCH_SIM_EXTINFO_UNIQUE_ID,
					 sizeof(DOCH_SIM_EXTINFO_UNIQUE_ID));	

			tffscpy(&diskOnChipDeviceInfo[bDev].bProgrammerName,
					 DOCH_SIM_EXTINFO_PROGNAME,
					 sizeof(DOCH_SIM_EXTINFO_PROGNAME));	

			tffscpy(&diskOnChipDeviceInfo[bDev].bProgrammerVersion,
					 DOCH_SIM_EXTINFO_PROGVER,
					 sizeof(DOCH_SIM_EXTINFO_PROGVER));		
			tffscpy((FLByte*)&diskOnChipDeviceInfo[bDev].bProgrammerVersion + sizeof(DOCH_SIM_EXTINFO_PROGVER),
					 DochSDKVersion,
					 sizeof(DochSDKVersion));	


			for(bPart=0; bPart<DOCH_MAX_PARTITIONS; bPart++ )
			{
				if( simDev->partitions[bPart].wActive==0 )
					break;
				
				diskOnChipDeviceInfo[bDev].wTotalNumOfPartitions ++;
			}

#ifdef DOCH_FILE_SIMULATION
			diskOnChipDeviceInfo[bDev].dwUnformattedCapacity = simDev->dwTotalDevSizeInSectors;
			diskOnChipDeviceInfo[bDev].dwUnitSize			 = (diskOnChipDeviceInfo[bDev].dwUnformattedCapacity>>9);
#else /*DOCH_FILE_SIMULATION*/
			simDev->dwTotalDevSizeInSectors = 
			diskOnChipDeviceInfo[bDev].dwUnformattedCapacity = (FLDword)(DOCH_SIM_CAPACITY >> DOCH_SECTOR_SIZE_BITS);
#endif /*DOCH_FILE_SIMULATION*/
			diskOnChipDeviceInfo[bDev].dwReservedConfigPartitionSize = 4;

		}
		else
		{
			DOCH_SimSocket* pSimSock = getSimSocket();

			#ifdef DOCH_MEMMAP_FILE
			if(simFileIO(pSimSock, SIM_ITEM_MAX_IPL_SIZE, 0, TRUE, (void*)&(pSimSock->device[bDev].dwXIPMaxSize)))
				return -1;
			#else /*DOCH_MEMMAP_FILE*/
			simDev->dwXIPMaxSize = simDev->partitions[DOCH_IPL_PARTITION].dwSize;
			#endif /*DOCH_MEMMAP_FILE*/
			
		}
	}

	/*Add capacity to Serial Number string*/
	/*Note: If Dev1 exists, add its capacity to the string as well!*/
	totalCapacity = diskOnChipDeviceInfo[0].dwUnformattedCapacity;
	if(simSocket.bSlavePresent || (diskOnChipDeviceInfo[1].dwUnformattedCapacity != 0))
		totalCapacity += diskOnChipDeviceInfo[1].dwUnformattedCapacity;

	digits = sprintf((char*)diskOnChipDeviceInfo[0].bSerialNumber + sizeof(DOCH_SIM_EXTINFO_SERIAL_NUM),
					 "%d",
					 (totalCapacity / 2048));
	tffscpy(&diskOnChipDeviceInfo[0].bSerialNumber[sizeof(DOCH_SIM_EXTINFO_SERIAL_NUM) + digits],
			"MB",
			2);

#ifdef DOCH_MEMMAP_FILE
	for( bDev=0; bDev<(simSocket.bSlavePresent + 1); bDev++)
	{
		simDev = &simSocket.device[bDev];

		if(simFileIO(&simSocket, SIM_ITEM_DEV_INFO, bDev, FALSE, (void*)&(diskOnChipDeviceInfo[bDev])))
			return -1;
	}
#endif /*DOCH_MEMMAP_FILE*/

	return DOCH_OK;
}

static
FLSNative unAuthenticatePartitions(DOCH_SimDevice* simDev)
{
	FLByte devNum;
	FLByte passkeyExists;
	register int i;
	register int j;

	/*UnAuthenticate protected partitions, in both devices*/
	/*====================================================*/
	for(devNum=0; (devNum<simSocket.bSlavePresent + 1); devNum++)
	{
		 simDev = getSimDev(simSocket.selDevNum);
		 i = 0;

		 while((i<DOCH_MAX_PARTITIONS) && (simDev->partitions[i].wActive == TRUE))
		 {
			/*Check every partition in the device*/
			/*If passkey exists - unauthenticated*/
			/*==================================*/
			passkeyExists = FALSE;
			for(j=0; j<sizeof(simDev->partitions[i].sbPasskey); j++)
			{
				if(simDev->partitions[i].sbPasskey[j] != 0)
				{
					passkeyExists = TRUE;
					break;
				}
			}

			if((passkeyExists) &&
			   (((simDev->partitions[i].info.partitionAttributes2&DOCH_PA2B_GUEST_MODE)!=DOCH_PART_ACCESS_MODE_FULL ) ||
			   ((simDev->partitions[i].info.partitionAttributes2&DOCH_PA2B_USER_MODE) !=DOCH_PART_ACCESS_MODE_FULL )))
			{
				simDev->partitions[i].wAuthenticated = FALSE;
				simDev->bPpartitionAuthenticated[i] = FALSE;
				simDev->partitions[i].info.dwCommandFlagsOrStatuses &= ~DOCH_CFSB_USER_AUTHENTICATED;
			}
			else
			{
				simDev->partitions[i].wAuthenticated = TRUE;
				simDev->bPpartitionAuthenticated[i] = TRUE;
				/*simDev->partitions[i].info.dwCommandFlagsOrStatuses |= DOCH_CFSB_USER_AUTHENTICATED;*/
			}

			i++;
		 }
	}

	return DOCH_OK;
}

/*Main routine for operations AFTER data transfer is finshed*/
/*==========================================================*/
FLSNative doch_sim_finish_data_xfer(DOCH_SimSocket* simSocket)
{
	FLSNative  rc = 0;

	simSocket->out_regs.bStatusCommand |= DOCH_BUSY;
	simSocket->out_regs.bStatusCommand &= ~DOCH_DRQ;

	switch(simSocket->in_regs.bStatusCommand)
	{
	case DOCH_CMD_IDENTIFY_DEV:
	case DOCH_VSCMD_READ_PARTITION:
	case DOCH_VSCMD_WRITE_PARTITION:
		/*Do nothing!*/
		break;

	case DOCH_DOWNLOAD_MICROCODE:
		rc = setMicrocode(simSocket);
		break;

	case DOCH_VSCMD_PARTITION_MANAGEMENT:
		switch(simSocket->in_regs.bErrorFeature)
		{
		case DOCH_GET_PARTITION_INFO:
		case DOCH_GET_PARTITION_USER_ATTR:
			/*Do nothing!*/
			break;

		case DOCH_SET_PARTITION_PROTECTION:
			rc = setPartitionProperties(simSocket);
			break;

		case DOCH_SET_PARTITION_USER_ATTR:
			rc = setPartitionUserAttr(simSocket);
			break;

		case DOCH_ADD_PARTITION:
			rc = addPartition(simSocket);
			break;

		case DOCH_SECURE_ERASE:
			rc = secureErase(simSocket);
			break;

		default:
			rc = DOCH_ATA_ERROR_ABORT;
			break;
		}
		break;

	case DOCH_VSCMD_ACCESS_CONTROL:
		switch(simSocket->in_regs.bErrorFeature)
		{
		case DOCH_EN_ACCESS_WPWD:
			rc = authenticatePartition(simSocket);
			break;

		default:
			rc = DOCH_ATA_ERROR_ABORT;
			break;
		}
		break;		

	case DOCH_VSCMD_EXT_DEVICE_CTRL:
		switch(simSocket->in_regs.bErrorFeature)
		{
		case DOCH_IDENTIFY_DISKONCHIP_DEVICE:
		case DOCH_GET_EXTENDED_DEVICE_INFO:
		case DOCH_GET_RESET_STATUS:
		case DOCH_GET_DISK_USER_ATTR:
		case DOCH_GET_CONFIGURATION_DATA:
		case DOCH_SET_CONFIGURATION_DATA:
		case DOCH_RETRIEVE_DBG_MSG:
		case DOCH_NOTIFY_RESET:
		case DOCH_NOTIFY_PLATFORM_RESUMED:
			/*Do nothing!*/
			break;

		case DOCH_SET_DISK_USER_ATTR:
			rc = setDiskUserAttr(simSocket);
			break;

		default:
			rc = DOCH_ATA_ERROR_ABORT;
			break;
		}
		break;

	default:
		rc = DOCH_ATA_ERROR_ABORT;
		break;
	}

	simSocket->out_regs.bStatusCommand |= DOCH_READY;
	simSocket->out_regs.bStatusCommand &= ~DOCH_BUSY;

	simSocket->out_regs.bAltStatusControl = simSocket->out_regs.bStatusCommand;
	
	return rc;
}

/*Write value to simulated ATA register*/
/*=====================================*/
FLSNative setSimReg(FLSNative  offset, FLSNative  value)
{
	FLSNative  rc = 0;

	/*ATA registers*/
	if(offset == DOCH_DATA_REG)
	{
		/*Do Nothing*/
	}
	else if(offset == DOCH_FEATURES_REG)
	{
		simSocket.in_regs.bErrorFeature = (FLByte)(value);
	}
	else if(offset == DOCH_SECTOR_CNT_REG)
	{
		simSocket.in_regs.bSectorCount = (FLByte)(value);
	}
	else if(offset == DOCH_SECTOR_NO_REG)
	{
		simSocket.in_regs.bLBALow = (FLByte)(value);
	}
	else if(offset == DOCH_CYLINDER_LOW_REG)
	{
		simSocket.in_regs.bLBAMid = (FLByte)(value);
	}
	else if(offset == DOCH_CYLINDER_HIGH_REG)
	{
		simSocket.in_regs.bLBAHigh = (FLByte)(value);
	}
	else if(offset == DOCH_DRIVE_HEAD_REG)
	{
		simSocket.selDevNum = (value & DOCH_DEVICE) >> 4;
		simSocket.in_regs.bDevice		= (FLByte)(value);
	}
	else if(offset == DOCH_COMMAND_REG)
	{
		simSocket.in_regs.bStatusCommand = (FLByte)(value);
		rc = activateAtaCommand(&simSocket, value);
	}
	else if(offset == DOCH_CONTROL_REG)
	{
		rc = parseControlReg(&simSocket, value);
	}

	/*HOST configuration registers*/
	else if(offset == HIB_BURST_WRITE_MODE_CTRL_REG)
	{
		simSocket.config_regs.wBurstWriteModeCtrl = (FLWord)(value);
	}
	else if(offset == HIB_BURST_WRITE_MODE_EXIT_REG)
	{
		simSocket.config_regs.wBurstWriteModeExit = (FLWord)(value);
	}
	else if(offset == HIB_IPL_CONTROL_REG)
	{
		simSocket.config_regs.wIPLCtrl = ((FLWord)(value) | DOCH_IPL_WRITE_READY);
	}
	else if(offset == HIB_WARM_BOOT_REG)
	{
		simSocket.config_regs.wWarmBoot = (FLWord)(value);
	}
	else if(offset == HIB_POWER_DOWN_REG)
	{
		simSocket.config_regs.wPowerDown = (FLWord)(value);
	}
	else if(offset == HIB_DMA_CTRL_REG)
	{
		simSocket.config_regs.wDMACtrl = (FLWord)(value);
	}
	else if(offset == HIB_SW_LOCK_REG)
	{
		simSocket.config_regs.wSWLock = (FLWord)(value);
		if((simSocket.config_regs.wSWLock & 0x01) == 0x01)
			stickyLockAction(&simSocket);
	}
	else if(offset == HIB_ENDIAN_CTRL_REG)
	{
		simSocket.config_regs.wEndianCtrl = (FLWord)(value);
	}
	else if(offset == HIB_OPERATION_MODE_REG)
	{
		simSocket.config_regs.wOperationMode = (FLWord)(value);
	}
	else if(offset == HIB_POWER_MODE_REG)
	{
		simSocket.config_regs.wPowerMode = (FLWord)(value);
		simDPDMode(&simSocket, TRUE);
	}
	else if(offset == HIB_DMA_NEGATION_REG)
	{
		simSocket.config_regs.wDmaNegation = (FLWord)(value);
	}
	else if(offset == HIB_BURST_READ_MODE_CTRL_REG)
	{
		simSocket.config_regs.wBurstReadModeCtrl = (FLWord)(value);
	}
	else if((offset == HIB_CHIPID1_REG) ||
			(offset == HIB_DOWNLOAD_CONTROL_REG) ||
			(offset == HIB_CHIPID2_REG))
	{
		DBG_PRINT_FLOW_PRM(FLZONE_MTD, (FLTXT("Register at offset %x is read only!!!\r\n"), offset));
		return DOCH_BadParameter;
	}
	else if((offset == HIB_PCI_CONTROL_REGISTER) || ((FLDword)offset == HIB_PCI_INTERRUPT_COUNTER))
	{
		/*Do Nothing*/
	}
	else
	{
		DBG_PRINT_FLOW_PRM(FLZONE_MTD, (FLTXT("Wrong ATA register offset\r\n")));
	}

	return rc;
}

/*Retrieve value of simulated ATA register*/
/*========================================*/
FLSNative getSimReg(FLSNative  offset)