/** * * Write a CompactFlash sector. This is a blocking, low-level function which * does not return until the specified sector is written in its entirety. * * @param BaseAddress is the base address of the device * @param SectorId is the id of the sector to write * @param BufferPtr is a pointer to a buffer used to write the sector. * * @return * * The number of bytes written. If this number is not equal to the sector size, * 512 bytes, then an error occurred. * * @note * * None. * ******************************************************************************/ int XSysAce_WriteSector(Xuint32 BaseAddress, Xuint32 SectorId, Xuint8 *BufferPtr) { int NumSent; /* Get the lock */ XSysAce_mWaitForLock(BaseAddress); /* See if the CF is ready for a command */ if (!XSysAce_mIsReadyForCmd(BaseAddress)) { return 0; } /* Write the sector ID (LBA) */ XSysAce_RegWrite32(BaseAddress + XSA_MLR_OFFSET, SectorId); /* Send a write command of one sector to the controller */ XSysAce_RegWrite16(BaseAddress + XSA_SCCR_OFFSET, XSA_SCCR_WRITEDATA_MASK | 1); /* Reset configuration controller (be sure to keep the lock) */ XSysAce_mOrControlReg(BaseAddress, XSA_CR_CFGRESET_MASK); /* Write a sector of data to the data buffer */ NumSent = XSysAce_WriteDataBuffer(BaseAddress, BufferPtr, XSA_CF_SECTOR_SIZE); /* Clear reset of configuration controller and locks */ XSysAce_mAndControlReg(BaseAddress, ~(XSA_CR_CFGRESET_MASK | XSA_CR_LOCKREQ_MASK)); return NumSent; }
/** * * Handle cleanup when a data transfer is complete. This means intializing the * state variables, disabling the data-buffer-ready interrupt, and sending the * event to the user. * * @param InstancePtr is a pointer to the XSysAce instance to be worked on. * * @return * * None. * * @note * * None. * ******************************************************************************/ static void DataComplete(XSysAce * InstancePtr) { InstancePtr->NumRequested = 0; InstancePtr->NumRemaining = 0; InstancePtr->BufferPtr = NULL; /* * Disable the data-buffer-ready interrupt. This isn't necessary when * reading since the DATABUFRDY status bit is cleared by the ACE after * the last data buffer is read. However, the ACE isn't currently * smart enough to clear the DATABUFRDY status bit after the last data * buffer is written during a write operation. So, we need to use the * enable/disable interrupt bit to control its usefulness. */ XSysAce_mAndControlReg(InstancePtr->BaseAddress, ~XSA_CR_DATARDYIRQ_MASK); /* * The same code is executed for JTAG configuration as well as CompactFlash * transfers, so we need to distinguish between JTAG config done and CF * data transfer done. We look at the CFGSEL value in the control register * to determine if an MPU JTAG config process has just completed. The * CFG_DONE event is passed up later by the main interrupt handler. */ if ((XSysAce_mGetControlReg(InstancePtr->BaseAddress) & XSA_CR_CFGSEL_MASK) == 0) { /* no JTAG configuration in progress */ InstancePtr->EventHandler(InstancePtr->EventRef, XSA_EVENT_DATA_DONE); } }
/** * * Initialize a specific XSysAce instance. The configuration information for * the given device ID is found and the driver instance data is initialized * appropriately. * * @param InstancePtr is a pointer to the XSysAce instance to be worked on. * @param DeviceId is the unique id of the device controlled by this XSysAce * instance. * * @return * * XST_SUCCESS if successful, or XST_DEVICE_NOT_FOUND if the device was not * found in the configuration table in xsysace_g.c. * * @note * * We do not want to reset the configuration controller here since this could * cause a reconfiguration of the JTAG target chain, depending on how the * CFGMODEPIN of the device is wired. * ******************************************************************************/ XStatus XSysAce_Initialize(XSysAce *InstancePtr, u16 DeviceId) { XSysAce_Config *ConfigPtr; XASSERT_NONVOID(InstancePtr != NULL); InstancePtr->IsReady = 0; /* * Lookup configuration data in the device configuration table. * Use this configuration info down below when initializing this component. */ ConfigPtr = XSysAce_LookupConfig(DeviceId); if (ConfigPtr == (XSysAce_Config *)NULL) { return XST_DEVICE_NOT_FOUND; } /* * Set some default values for the instance data */ InstancePtr->BaseAddress = ConfigPtr->BaseAddress; InstancePtr->EventHandler = StubEventHandler; InstancePtr->NumRequested = 0; InstancePtr->NumRemaining = 0; InstancePtr->BufferPtr = NULL; /* * Put the device into 16-bit mode or 8-bit mode depending on compile-time * parameter */ #if (XPAR_XSYSACE_MEM_WIDTH == 16) XSysAce_RegWrite16(InstancePtr->BaseAddress + XSA_BMR_OFFSET, XSA_BMR_16BIT_MASK); #else XSysAce_RegWrite16(InstancePtr->BaseAddress + XSA_BMR_OFFSET, 0); #endif /* * Disable interrupts. Interrupts must be enabled by the user using * XSysAce_EnableInterrupt(). Put the interrupt request line in reset and * clear the interrupt enable bits. */ XSysAce_mOrControlReg(InstancePtr->BaseAddress, XSA_CR_RESETIRQ_MASK); XSysAce_mAndControlReg(InstancePtr->BaseAddress, ~(XSA_CR_DATARDYIRQ_MASK | XSA_CR_ERRORIRQ_MASK | XSA_CR_CFGDONEIRQ_MASK)); /* * Indicate the instance is now ready to use, initialized without error */ InstancePtr->IsReady = XCOMPONENT_IS_READY; return XST_SUCCESS; }
/** * * Enable System ACE interrupts. There are three interrupts that can be enabled. * The error interrupt enable serves as the driver's means to determine whether * interrupts have been enabled or not. The configuration-done interrupt is not * enabled here, instead it is enabled during a reset - which can cause a * configuration process to start. The data-buffer-ready interrupt is not enabled * here either. It is enabled when a read or write operation is started. The * reason for not enabling the latter two interrupts are because the status bits * may be set as a leftover of an earlier occurrence of the interrupt. * * @param InstancePtr is a pointer to the XSysAce instance to work on. * * @return * * None. * * @note * * None. * ******************************************************************************/ void XSysAce_EnableInterrupt(XSysAce * InstancePtr) { XASSERT_VOID(InstancePtr != NULL); XASSERT_VOID(InstancePtr->IsReady == XCOMPONENT_IS_READY); /* By default, enable only the error interrupt */ XSysAce_mOrControlReg(InstancePtr->BaseAddress, XSA_CR_ERRORIRQ_MASK); /* Clear the reset on the interrupt line if it was in reset */ XSysAce_mAndControlReg(InstancePtr->BaseAddress, ~XSA_CR_RESETIRQ_MASK); }
/** * * Release the MPU lock to the CompactFlash. If a lock is not currently granted * to the MPU port, this function has no effect. * * @param InstancePtr is a pointer to the XSysAce instance to be worked on. * * @return * * None. * * @note * * None. * ******************************************************************************/ void XSysAce_Unlock(XSysAce * InstancePtr) { XASSERT_VOID(InstancePtr != NULL); XASSERT_VOID(InstancePtr->IsReady == XCOMPONENT_IS_READY); /* * Blindly clear the lock and force-lock request bits of the control * register */ XSysAce_mAndControlReg(InstancePtr->BaseAddress, ~(XSA_CR_LOCKREQ_MASK | XSA_CR_FORCELOCK_MASK)); }
/** * * Disable all System ACE interrupts and hold the interrupt request line of * the device in reset. * * @param InstancePtr is a pointer to the XSysAce instance that just interrupted. * * @return * * None. * * @note * * None. * ******************************************************************************/ void XSysAce_DisableInterrupt(XSysAce *InstancePtr) { XASSERT_VOID(InstancePtr != NULL); XASSERT_VOID(InstancePtr->IsReady == XCOMPONENT_IS_READY); /* Put the interrupt request line in reset */ XSysAce_mOrControlReg(InstancePtr->BaseAddress, XSA_CR_RESETIRQ_MASK); /* Clear the interrupt enable bits */ XSysAce_mAndControlReg(InstancePtr->BaseAddress, ~(XSA_CR_DATARDYIRQ_MASK | XSA_CR_ERRORIRQ_MASK | XSA_CR_CFGDONEIRQ_MASK)); }
/** * * Initialize a specific XSysAce instance. The configuration information is * passed in as an argument and the driver instance data is initialized * appropriately. * * @param InstancePtr is a pointer to the XSysAce instance to be worked on. * @param Config is a reference to a structure containing information about a * specific SysAce device. This function initializes an InstancePtr object * for a specific device specified by the contents of Config. This function * can initialize multiple instance objects with the use of multiple calls * giving different Config information on each call. * @param EffectiveAddr is the device base address in the virtual memory address * space. The caller is responsible for keeping the address mapping * from EffectiveAddr to the device physical base address unchanged * once this function is invoked. Unexpected errors may occur if the * address mapping changes after this function is called. If address * translation is not used, use Config->BaseAddress for this parameters, * passing the physical address instead. * * @return * * XST_SUCCESS if successful. * * @note * * We do not want to reset the configuration controller here since this could * cause a reconfiguration of the JTAG target chain, depending on how the * CFGMODEPIN of the device is wired. * <br><br> * The Config pointer argument is not used by this function, but is provided * to keep the function signature consistent with other drivers. * ******************************************************************************/ XStatus XSysAce_CfgInitialize(XSysAce * InstancePtr, XSysAce_Config * Config, u32 EffectiveAddr) { XASSERT_NONVOID(InstancePtr != NULL); InstancePtr->IsReady = 0; /* * Set some default values for the instance data */ InstancePtr->BaseAddress = EffectiveAddr; InstancePtr->EventHandler = StubEventHandler; InstancePtr->NumRequested = 0; InstancePtr->NumRemaining = 0; InstancePtr->BufferPtr = NULL; /* * Put the device into 16-bit mode or 8-bit mode depending on compile-time * parameter */ #if (XPAR_XSYSACE_MEM_WIDTH == 16) XSysAce_RegWrite16(InstancePtr->BaseAddress + XSA_BMR_OFFSET, XSA_BMR_16BIT_MASK); #else XSysAce_RegWrite16(InstancePtr->BaseAddress + XSA_BMR_OFFSET, 0); #endif /* * Disable interrupts. Interrupts must be enabled by the user using * XSysAce_EnableInterrupt(). Put the interrupt request line in reset and * clear the interrupt enable bits. */ XSysAce_mOrControlReg(InstancePtr->BaseAddress, XSA_CR_RESETIRQ_MASK); XSysAce_mAndControlReg(InstancePtr->BaseAddress, ~(XSA_CR_DATARDYIRQ_MASK | XSA_CR_ERRORIRQ_MASK | XSA_CR_CFGDONEIRQ_MASK)); /* * Indicate the instance is now ready to use, initialized without error */ InstancePtr->IsReady = XCOMPONENT_IS_READY; return XST_SUCCESS; }
/** * * Reset the JTAG configuration controller. This comprises a reset of the JTAG * configuration controller and the CompactFlash controller (if it is currently * being accessed by the configuration controller). Note that the MPU controller * is not reset, meaning the MPU registers remain unchanged. The configuration * controller is reset then released from reset in this function. * * The CFGDONE status (and therefore interrupt) is cleared when the configuration * controller is reset. If interrupts have been enabled, we go ahead and enable * the CFGDONE interrupt here. This means that if and when a configuration * process starts as a result of this reset, an interrupt will be received when * it is complete. * * @param InstancePtr is a pointer to the XSysAce instance to be worked on. * * @return * * None. * * @note * * This function is not thread-safe. * ******************************************************************************/ void XSysAce_ResetCfg(XSysAce * InstancePtr) { XASSERT_VOID(InstancePtr != NULL); XASSERT_VOID(InstancePtr->IsReady == XCOMPONENT_IS_READY); /* Reset the configuration controller */ XSysAce_mOrControlReg(InstancePtr->BaseAddress, XSA_CR_CFGRESET_MASK); /* * If in interrupt mode, enable the CFGDONE and error interrupts. * A reset clears the CFGDONE and error statuses, so we're going to * re-enable the interrupts here so any new errors or CFGDONEs will be * caught. */ if (XSysAce_mIsIntrEnabled(InstancePtr->BaseAddress)) { XSysAce_mOrControlReg(InstancePtr->BaseAddress, XSA_CR_CFGDONEIRQ_MASK | XSA_CR_ERRORIRQ_MASK); } /* Release the reset of the configuration controller */ XSysAce_mAndControlReg(InstancePtr->BaseAddress, ~XSA_CR_CFGRESET_MASK); }
/** * * The interrupt handler for the System ACE driver. This handler must be * connected by the user to an interrupt controller or source. This function * does not save or restore context. * * This function continues reading or writing to the compact flash if such an * operation is in progress, and notifies the upper layer software through * the event handler once the operation is complete or an error occurs. On an * error, any command currently in progress is aborted. * * @param InstancePtr is a pointer to the XSysAce instance that just interrupted. * * @return * * None. * * @note * * None. * ******************************************************************************/ void XSysAce_InterruptHandler(void *InstancePtr) { u32 StatusReg; XSysAce *AcePtr = (XSysAce *) InstancePtr; XASSERT_VOID(InstancePtr != NULL); /* * Get the status in order to process each interrupt that has occurred */ StatusReg = XSysAce_mGetStatusReg(AcePtr->BaseAddress); /* * Reset the interrupt line to effectively clear the interrupt conditions. * We need to set the bit to clear the interrupts, then clear the bit so * that new interrupts can be generated. */ XSysAce_mOrControlReg(AcePtr->BaseAddress, XSA_CR_RESETIRQ_MASK); XSysAce_mAndControlReg(AcePtr->BaseAddress, ~XSA_CR_RESETIRQ_MASK); /* * Check for data buffer ready, which means an operation (either read or * write) is in progress. */ if (StatusReg & XSA_SR_DATABUFRDY_MASK) { /* * Handles the data buffer, and invokes the callback to the user for * data transfer completion. */ HandleDataBuffer(AcePtr, StatusReg); } /* * Check for completion of JTAG configuration and report the event up. * We only do this if the CFGDONE interrupt is enabled since the CFGDONE * status only gets cleared when the confguration controller is reset, * which we do not do unless requested by the user because it may cause * a configuration process to start. We could have gotten into this * interrupt handler by another interrupt, yet have a leftover CFGDONE * status from an earlier configuration process. */ if ((StatusReg & XSA_SR_CFGDONE_MASK) && (XSysAce_mGetControlReg(AcePtr->BaseAddress) & XSA_CR_CFGDONEIRQ_MASK)) { /* * Clear the bit indicating MPU is the source of configuration data * since we're done configuring from the MPU for now. Also clear the * force CFGMODE bit and the CFGSTART bit, basically undoing what was * done in XSysAce_ProgramChain(). Disable the interrupts since the * CFGDONE status does not get cleared unless a reset occurs - and in * the meantime we may get into this interrupt handler again. */ XSysAce_mAndControlReg(AcePtr->BaseAddress, ~(XSA_CR_CFGSEL_MASK | XSA_CR_CFGSTART_MASK | XSA_CR_CFGDONEIRQ_MASK | XSA_CR_DATARDYIRQ_MASK | XSA_CR_FORCECFGMODE_MASK)); AcePtr->EventHandler(AcePtr->EventRef, XSA_EVENT_CFG_DONE); } /* * Check for errors and report the event (the user is responsible for * retrieving and interpreting the errors). We only do this if the error * interrupt is enabled since the error status only gets cleared when the * CompactFlash or confguration controller is reset, which we do not do * because it may cause a configuration process to start. We could have * entered this interrupt handler by another interrupt and have a leftover * error status from a previous error. */ if ((StatusReg & (XSA_SR_CFGERROR_MASK | XSA_SR_CFCERROR_MASK)) && (XSysAce_mGetControlReg(AcePtr->BaseAddress) & XSA_CR_ERRORIRQ_MASK)) { /* Clear the transfer state to effectively abort the operation */ AcePtr->NumRequested = 0; AcePtr->NumRemaining = 0; AcePtr->BufferPtr = NULL; /* * Disable the error interrupt since the only way to clear the * error status is to reset the CF or the configuration controller, * neither of which we want to do here since the consequences may * be undesirable (i.e., may cause a reconfiguration). The user * will need to perform the reset based on the error event. */ XSysAce_mAndControlReg(AcePtr->BaseAddress, ~XSA_CR_ERRORIRQ_MASK); AcePtr->EventHandler(AcePtr->EventRef, XSA_EVENT_ERROR); } }
/** * * Attempt to lock access to the CompactFlash. The CompactFlash may be accessed * by the MPU port as well as the JTAG configuration port within the System ACE * device. This function requests exclusive access to the CompactFlash for the * MPU port. This is a non-blocking request. If access cannot be locked * (because the configuration controller has the lock), an appropriate status is * returned. In this case, the user should call this function again until * successful. * * If the user requests a forced lock, the JTAG configuration controller will * be put into a reset state in case it currently has a lock on the CompactFlash. * This effectively aborts any operation the configuration controller had in * progress and makes the configuration controller restart its process the * next time it is able to get a lock. * * A lock must be granted to the user before attempting to read or write the * CompactFlash device. * * @param InstancePtr is a pointer to the XSysAce instance to be worked on. * @param Force is a boolean value that, when set to TRUE, will force the MPU * lock to occur in the System ACE. When set to FALSE, the lock is * requested and the device arbitrates between the MPU request and * JTAG requests. Forcing the MPU lock resets the configuration * controller, thus aborting any configuration operations in progress. * * @return * * XST_SUCCESS if the lock was granted, or XST_DEVICE_BUSY if the lock was * not granted because the configuration controller currently has access to * the CompactFlash. * * @note * * If the lock is not granted to the MPU immediately, this function removes its * request for a lock so that a lock is not later granted at a time when the * application is (a) not ready for the lock, or (b) cannot be informed * asynchronously about the granted lock since there is no such interrupt event. * ******************************************************************************/ XStatus XSysAce_Lock(XSysAce * InstancePtr, u32 Force) { u32 IsLocked; XASSERT_NONVOID(InstancePtr != NULL); XASSERT_NONVOID(InstancePtr->IsReady == XCOMPONENT_IS_READY); /* * Check to see if the configuration controller currently has the lock */ IsLocked = (XSysAce_mGetStatusReg(InstancePtr->BaseAddress) & XSA_SR_CFGLOCK_MASK); if (Force) { /* * Reset the configuration controller if it has the lock. Per ASIC * designer, this eliminates a potential deadlock if the FORCELOCK and * LOCKREQ bits are both set and the RDYFORCFCMD is not set. */ if (IsLocked) { /* Reset the configuration controller */ XSysAce_mOrControlReg(InstancePtr->BaseAddress, XSA_CR_CFGRESET_MASK); } /* Force the MPU lock. The lock will occur immediately. */ XSysAce_mOrControlReg(InstancePtr->BaseAddress, XSA_CR_LOCKREQ_MASK | XSA_CR_FORCELOCK_MASK); } else { /* * Check to see if the configuration controller has the lock. If so, * return a busy status. */ if (IsLocked) { return XST_DEVICE_BUSY; } /* Request the lock, but do not force it */ XSysAce_mOrControlReg(InstancePtr->BaseAddress, XSA_CR_LOCKREQ_MASK); } /* * See if the lock was granted. Note that it is guaranteed to occur if * the user forced it. */ if (!XSysAce_mIsMpuLocked(InstancePtr->BaseAddress)) { /* Lock was not granted, so remove request and return a busy */ XSysAce_mAndControlReg(InstancePtr->BaseAddress, ~(XSA_CR_LOCKREQ_MASK | XSA_CR_FORCELOCK_MASK)); return XST_DEVICE_BUSY; } /* * Lock has been granted. * * If the configuration controller had the lock and has been reset, * go ahead and release it from reset as it will not be able to get * the lock again until the MPU lock is released. */ if (IsLocked && Force) { /* Release the reset of the configuration controller */ XSysAce_mAndControlReg(InstancePtr->BaseAddress, ~XSA_CR_CFGRESET_MASK); } return XST_SUCCESS; }